fork download 
  1. import java.util.Random;
  2.  
  3. class BasicOperations
  4. {
  5.     /** Array of integers to be used in several basic operations. */
  6.     private int [] v;
  7.     /** Number of valid elements stored in the array v. */
  8.     private int    n;
  9.  
  10.     public BasicOperations(int size)
  11.     {
  12.         v = new int [size];
  13.         n = 0;
  14.     }
  15.  
  16.     public int capacity() { return v.length; }
  17.     public int size() { return n; }
  18.     public void reset() { n = 0; }
  19.  
  20.     @Override 
  21.     public String toString()
  22.     {
  23.         StringBuffer sb = new StringBuffer();
  24.  
  25.         sb.append(String.format("array size %3d: ", n));
  26.         sb.append("{");
  27.         if (n > 0) sb.append(v[0]);
  28.         for (int i = 1; i < n; i++) sb.append(", " + v[i]);
  29.         sb.append("}");
  30.         return sb.toString();
  31.     }
  32.  
  33.     public static String toString(int [] a)
  34.     {
  35.         StringBuffer sb = new StringBuffer();
  36.  
  37.         sb.append("{");
  38.         if (a.length > 0) sb.append(a[0]);
  39.         for (int i = 1; i < a.length; i++) sb.append(", " + a[i]);
  40.         sb.append("}");
  41.         return sb.toString();
  42.     }
  43.  
  44.     public static int [] genRandomArray(int size)
  45.     {
  46.         int [] v = new int [size];
  47.         Random r = new Random();
  48.  
  49.         for (int i = 0; i < v.length; i++)
  50.             v[i] = r.nextInt(100);
  51.  
  52.         return v;
  53.     }
  54.  
  55.     /** 
  56.      * Returns the index of the first position
  57.      * of x in the array, -1 if it does not
  58.      * exist in the array.
  59.      * 
  60.      * @param x The value to be found in the array.
  61.      */
  62.     public int find(int x)
  63.     {
  64.         int i = 0;
  65.  
  66.         while (i < n && v[i] != x) i++;
  67.  
  68.         return (i < n) ? i : -1;
  69.     }
  70.  
  71.     /** 
  72.      * Removes the element at the given position.
  73.      * 
  74.      * @param pos Index of the position whose element must be removed.
  75.      */
  76.     public void removeAtPos(int pos)
  77.     {
  78.         if (0 <= pos && pos < n) {
  79.             for (int i = pos; i < n; i++) v[i] = v[i + 1];
  80.             --n;
  81.         }
  82.     }
  83.  
  84.     /** 
  85.      * Removes the given value if contained in the array.
  86.      * 
  87.      * @param x The value to be removed from the array if it exists.
  88.      */
  89.     public void remove(int x)
  90.     {
  91.         int pos = find(x);
  92.         if (pos >= 0) removeAtPos(pos);
  93.     }
  94.  
  95.     /**
  96.      * Adds a new element in the array after the stored elements,
  97.      * i.e., in the first free position.
  98.      * 
  99.      * @param x New value to be stored in the array.
  100.      */
  101.     public void add(int x)
  102.     {
  103.         if (n == v.length) increaseSize(10);
  104.  
  105.         v[n++] = x;
  106.     }
  107.  
  108.     /**
  109.      * Inserts a new element in the array at the specified position.
  110.      * 
  111.      * @param x New value to be stored in the array.
  112.      * @param pos Position at the new element must be inserted.
  113.      */
  114.     public void insert(int x, int pos)
  115.     {
  116.         if (n == v.length) increaseSize(10);
  117.  
  118.         // Move all the existing elements from pos to n one position to the right.
  119.         for (int i = n; i > pos; i--) v[i] = v[i - 1];
  120.  
  121.         // Now, position pos is free and x can be stored in such position.
  122.         v[pos] = x;
  123.     }
  124.  
  125.     /**
  126.      * Inserts a new element in the array at the corresponding position in order
  127.      * to guarantee the array remains sorted in ascending order.
  128.      * Precondition, the array is already sorted in ascending order.
  129.      * 
  130.      * @param x New value to be stored in the array.
  131.      */
  132.     public void insertInOrder(int x)
  133.     {
  134.         if (n == v.length) increaseSize(10);
  135.  
  136.         int i = n - 1;
  137.         // Shifting one position to the right all the values in v greater than x.
  138.         while (i >= 0 && v[i] > x) {
  139.             v[i + 1] = v[i];
  140.             i--;
  141.         }
  142.         v[i + 1] = x;
  143.         n++;
  144.     }
  145.  
  146.     /**
  147.      * Increases the size of the array, but not the number
  148.      * of elements stored in it.
  149.      * 
  150.      * @param s Number of new positions to be available in the array.
  151.      */
  152.     public void increaseSize(int s)
  153.     {
  154.         // Creation of a new array larger than the existing one.
  155.         int [] newArray = new int [v.length + s];
  156.  
  157.         // Copying the contents of the existing array to the new one.
  158.         for (int i = 0; i < n; i++) newArray[i] = v[i];
  159.  
  160.         // The new array substitutes the existing one.
  161.         v = newArray;
  162.     }
  163.  
  164.     /**
  165.      * 
  166.      */
  167.     public static void main(String [] args)
  168.     {
  169.         BasicOperations bo = new BasicOperations(100);
  170.         System.out.println("Capacity = " + bo.capacity() + ", size = " + bo.size());
  171.  
  172.         int [] temp = BasicOperations.genRandomArray(10);
  173.  
  174.         BasicOperations.toString(temp);
  175.  
  176.         for (int i = 0; i < temp.length; i++) {
  177.             bo.add(temp[i]);
  178.             System.out.println(bo);
  179.         }
  180.  
  181.         bo.reset();
  182.         System.out.println("\nAfter the reset: ");
  183.         System.out.println(bo);
  184.         System.out.println();
  185.  
  186.         for (int i = 0; i < temp.length; i++) {
  187.             bo.insertInOrder(temp[i]);
  188.             System.out.println(bo);
  189.         }
  190.         System.out.println("\nLet's remove the elements: ");
  191.         for (int i = 0; i < temp.length; i++) {
  192.             System.out.println("    removing " + temp[i]);
  193.             System.out.println(bo);
  194.             bo.remove(temp[i]);
  195.             System.out.println(bo);
  196.         }
  197.     }
  198. }
Success #stdin #stdout 0.18s 50996KB
comments (?)
stdin 
add $s0, $t2, $s0
stdout 
Capacity = 100, size = 0
array size   1: {0}
array size   2: {0, 43}
array size   3: {0, 43, 12}
array size   4: {0, 43, 12, 9}
array size   5: {0, 43, 12, 9, 0}
array size   6: {0, 43, 12, 9, 0, 69}
array size   7: {0, 43, 12, 9, 0, 69, 2}
array size   8: {0, 43, 12, 9, 0, 69, 2, 92}
array size   9: {0, 43, 12, 9, 0, 69, 2, 92, 69}
array size  10: {0, 43, 12, 9, 0, 69, 2, 92, 69, 33}

After the reset: 
array size   0: {}

array size   1: {0}
array size   2: {0, 43}
array size   3: {0, 12, 43}
array size   4: {0, 9, 12, 43}
array size   5: {0, 0, 9, 12, 43}
array size   6: {0, 0, 9, 12, 43, 69}
array size   7: {0, 0, 2, 9, 12, 43, 69}
array size   8: {0, 0, 2, 9, 12, 43, 69, 92}
array size   9: {0, 0, 2, 9, 12, 43, 69, 69, 92}
array size  10: {0, 0, 2, 9, 12, 33, 43, 69, 69, 92}

Let's remove the elements: 
    removing 0
array size  10: {0, 0, 2, 9, 12, 33, 43, 69, 69, 92}
array size   9: {0, 2, 9, 12, 33, 43, 69, 69, 92}
    removing 43
array size   9: {0, 2, 9, 12, 33, 43, 69, 69, 92}
array size   8: {0, 2, 9, 12, 33, 69, 69, 92}
    removing 12
array size   8: {0, 2, 9, 12, 33, 69, 69, 92}
array size   7: {0, 2, 9, 33, 69, 69, 92}
    removing 9
array size   7: {0, 2, 9, 33, 69, 69, 92}
array size   6: {0, 2, 33, 69, 69, 92}
    removing 0
array size   6: {0, 2, 33, 69, 69, 92}
array size   5: {2, 33, 69, 69, 92}
    removing 69
array size   5: {2, 33, 69, 69, 92}
array size   4: {2, 33, 69, 92}
    removing 2
array size   4: {2, 33, 69, 92}
array size   3: {33, 69, 92}
    removing 92
array size   3: {33, 69, 92}
array size   2: {33, 69}
    removing 69
array size   2: {33, 69}
array size   1: {33}
    removing 33
array size   1: {33}
array size   0: {}
https://ideone.com/7B0h56
language:
Java (HotSpot 12)
created:
3 years ago
visibility:
public

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!