fork download 
  1. /* package whatever; // don't place package name! */
  2.  
  3. import java.util.*;
  4. import java.lang.*;
  5. import java.io.*;
  6.  
  7. /* Name of the class has to be "Main" only if the class is public. */
  8. class Ideone
  9. {
  10.  
  11. public static class Matrix<T> {
  12.  
  13.     private ArrayList<T> array;
  14.     private int rows;
  15.     private int columns;
  16.  
  17.     public Matrix(int rows, int columns) {
  18.         this.array = new ArrayList<T>(Collections.nCopies(rows * columns, (T)null));
  19.         this.rows = rows;
  20.         this.columns = columns;
  21.     }
  22.  
  23.     public T get(int row, int col) {
  24.         return this.array.get(row * this.columns + col);
  25.     }
  26.  
  27.     public T set(int row, int col, T n) {
  28.         return this.array.set(row * this.columns + col, n);
  29.     }
  30.  
  31.     public Stripe row(int row) { return this.new Stripe(row, true); }
  32.     public Stripe column(int col) { return this.new Stripe(col, false); }
  33.  
  34.     public class Stripe implements List<T> {
  35.  
  36.         private class StripeIterator implements ListIterator<T> {
  37.             private int curr;
  38.             private int from;
  39.  
  40.             public StripeIterator() { this(0); }
  41.             public StripeIterator(int from) { this.curr = from; this.from = from; }
  42.             public void add(T e) { throw new UnsupportedOperationException(); }
  43.             public boolean hasNext() { return this.curr < Stripe.this.size(); }
  44.             public boolean hasPrevious() { return this.curr > this.from; }
  45.             public T next() { return Stripe.this.get(curr++); }
  46.             public int nextIndex() { return this.curr + 1; }
  47.             public T previous() { return Stripe.this.get(curr--); }
  48.             public int previousIndex() { return this.curr + 1; }
  49.             public void remove() { throw new UnsupportedOperationException(); }
  50.             public void set(T n) { Stripe.this.set(this.curr - 1, n); }
  51.         }
  52.  
  53.         private int i;
  54.         private boolean isRow;
  55.         private int from;
  56.         private int to;
  57.  
  58.         private Stripe(int i, boolean isRow) {
  59.             this(i, isRow, 0, 0);
  60.             this.to = (isRow) ? Matrix.this.columns : Matrix.this.rows;
  61.         }
  62.  
  63.         private Stripe(int i, boolean isRow, int from, int to) {
  64.             this.i = i;
  65.             this.isRow = isRow;
  66.             this.from = from;
  67.             this.to = to;
  68.         }
  69.  
  70.         // Operations that modify the size are now allowed by the contract of
  71.         // this class. In fact they are optional as far as `List` is concerned.
  72.         public boolean add(T e) { throw new UnsupportedOperationException(); }
  73.         public void add(int i, T e) { throw new UnsupportedOperationException(); }
  74.         public boolean addAll(Collection<? extends T> c) 
  75.             { throw new UnsupportedOperationException(); }
  76.         public boolean addAll(int index, Collection<? extends T> c) 
  77.             { throw new UnsupportedOperationException(); }
  78.         public void clear() { throw new UnsupportedOperationException(); }
  79.         public T remove(int index) { throw new UnsupportedOperationException(); }
  80.         public boolean remove(Object o) { throw new UnsupportedOperationException(); }
  81.         public boolean removeAll(Collection<?> c) { throw new UnsupportedOperationException(); }
  82.         public boolean retainAll(Collection<?> c) { throw new UnsupportedOperationException(); }
  83.  
  84.         public boolean contains(Object o) { 
  85.             for (int c = 0; c < this.size(); c++)
  86.                 if (this.get(c).equals(o))
  87.                     return true;
  88.             return false;
  89.         }
  90.  
  91.         public boolean containsAll(Collection<?> c) {
  92.             for (Object e : c)
  93.                 if (!this.contains(e))
  94.                     return false;
  95.             return true;
  96.         }
  97.  
  98.         public T get(int k) { 
  99.             if (this.isRow) return Matrix.this.get(this.i, k + this.from);
  100.             else return Matrix.this.get(k + this.from, this.i);
  101.         }
  102.  
  103.         public int hashCode() {
  104.             int hashCode = 1;
  105.             for (T e : this)
  106.                 hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());
  107.             return hashCode;
  108.         }
  109.  
  110.         public int indexOf(Object o) {
  111.             for (int j = 0; j < this.size(); j++)
  112.                 if (this.get(j).equals(o))
  113.                     return j;
  114.             return -1;
  115.         }
  116.  
  117.         public boolean isEmpty() {
  118.             return false;
  119.         }
  120.  
  121.         public Iterator<T> iterator() {
  122.             return this.listIterator();
  123.         }
  124.  
  125.         public ListIterator<T> listIterator() {
  126.             return this.new StripeIterator();
  127.         }
  128.  
  129.         public ListIterator<T> listIterator(int from) {
  130.             return this.new StripeIterator(from);
  131.         }
  132.  
  133.         public int lastIndexOf(Object o) {
  134.             int last = -1;
  135.             for (int j = 0; j < this.size(); j++)
  136.                 if (this.get(j).equals(o))
  137.                     last = j;
  138.             return last;
  139.         }
  140.  
  141.         public T set(int k, T n) { 
  142.             if (this.isRow) return Matrix.this.set(this.i, k + this.from, n);
  143.             else return Matrix.this.set(k + this.from, this.i, n);
  144.         }
  145.  
  146.         public int size() { return this.to - this.from; } 
  147.  
  148.         public List<T> subList(int fromIndex, int toIndex) {
  149.             return new Stripe(this.i, this.isRow, fromIndex, toIndex);
  150.         }
  151.  
  152.         public Object[] toArray() {
  153.             Object[] arr = new Object[this.size()];
  154.             for (int i = 0; i < this.size(); i++)
  155.                 arr[i] = this.get(i);
  156.             return arr;
  157.         }
  158.  
  159.         public <E> E[] toArray(E[] arr) {
  160.             if (arr.length < this.size()) {
  161.                 return (E[]) this.toArray();
  162.             } else {
  163.                 for (int i = 0; i < this.size(); i++)
  164.                     arr[i] = (E) this.get(i);
  165.                 for (int i = this.size(); i < arr.length; i++)
  166.                     arr[i] = null;
  167.                 return arr;
  168.             }
  169.  
  170.         }
  171.  
  172.     }
  173.  
  174. }
  175.  
  176. 	public static void main (String[] args) throws java.lang.Exception
  177. 	{
  178. 		Matrix<String> x = new Matrix<String>(2, 5);
  179. 		x.set(0, 0, "1");
  180. 		x.set(0, 1, "2");
  181. 		x.set(0, 2, "3");
  182. 		x.set(0, 3, "4");
  183. 		x.set(0, 4, "5");
  184. 		x.set(1, 0, "6");
  185. 		x.set(1, 1, "7");
  186. 		x.set(1, 2, "8");
  187. 		x.set(1, 3, "9");
  188. 		x.set(1, 4, "10");
  189.  
  190. 		System.out.print("Row 0\n\t");
  191. 		for (String a : x.row(0))
  192. 			System.out.print(a + " ");
  193. 		System.out.print("\nRow 1\n\t");
  194. 		for (String b : x.row(1))
  195. 			System.out.print(b + " ");
  196. 		System.out.print("\nCol 0\n\t");
  197. 		for (String b : x.column(0))
  198. 			System.out.print(b + " ");
  199. 	}
  200. }
Success #stdin #stdout 0.06s 380160KB
comments (?)
stdin 
Standard input is empty
stdout 
Row 0
	1 2 3 4 5 
Row 1
	6 7 8 9 10 
Col 0
	1 6
https://ideone.com/9sy2xP
language:
Java (12.0.1)
created:
10 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!