Question

JAVA

// TO DO: add your implementation and JavaDoc

public class SmartArray<T>{

   private static final int DEFAULT_CAPACITY = 2;   //default initial capacity / minimum capacity
   private T[] data;   //underlying array

   // ADD MORE PRIVATE MEMBERS HERE IF NEEDED!
  
   @SuppressWarnings("unchecked")
   public SmartArray(){
       //constructor
       //initial capacity of the array should be DEFAULT_CAPACITY
   }

   @SuppressWarnings("unchecked")
   public SmartArray(int initialCapacity){
       // constructor
       // set the initial capacity of the smart array as initialCapacity

       // throw IllegalArgumentException if initialCapacity is smaller than 1
   }
  

   public int size() {  
       //report number of elements in the smart array
       // O(1)
      
       return 0;
   }
      
   public int capacity() {
       //report max number of elements before the next expansion
       // O(1)

       return 0;
   }
  
   @SuppressWarnings("unchecked")
   public void add(int index, T value){
       // insert value at index, shift elements if needed
       // double the capacity if no space is available
       // throw IndexOutOfBoundsException for invalid index
       // O(N) where N is the number of elements in the array
      
       // Note: this method may be used to append items as
       // well as insert items
   }

   public T get(int index){
       // return the item at index
       // throw IndexOutOfBoundsException for invalid index
       // O(1)

       return null;
   }

   public T replace(int index, T value){
       // change item at index to be value  
       // return old item at index
       // throw IndexOutOfBoundsException for invalid index
       // O(1)
      
       // Note: you cannot add new items with this method

       return null;
   }

   @SuppressWarnings("unchecked")
   public T delete(int index){
       // remove and return element at position index
       // shift elements to remove any gap in the array
       // throw IndexOutOfBoundsException for invalid index
      
       // halve capacity if the number of elements falls below 1/4 of the capacity
       // capacity should NOT go below DEFAULT_CAPACITY
      
       // O(N) where N is the number of elements in the list

       return null;
   }

   @SuppressWarnings("unchecked")
   public boolean ensureCapacity(int newCapacity){
       // change the max number of items allowed before next expansion to newCapacity
      
       // capacity should not be changed if:
       // - newCapacity is below DEFAULT_CAPACITY; or
       // - newCapacity is not large enough to accommodate current number of items
      
       // return true if newCapacity gets applied; false otherwise
       // O(N) where N is the number of elements in the array
      
       return false;  
   }

   // --------------------------------------------------------
   // example testing code... edit this as much as you want!
   // --------------------------------------------------------

   // Not required, update for your own testing
   public String toString(){
       // return string representation of DynamicArray
       // update if you want to include more information
       return "SmartArray";
   }

   // Not required, update for your own testing
   public static void main (String args[]){

       //create a smart array of integers
       SmartArray<Integer> nums = new SmartArray<>();
       if ((nums.size() == 0) && (nums.capacity() == 2)){
           System.out.println("Yay 1");
       }

       //append some numbers
       for (int i=0; i<3;i++)
           nums.add(i,i*2);
      
       if (nums.size()==3 && nums.get(2) == 4 && nums.capacity() == 4 ){
           System.out.println("Yay 2");
       }
      
       //create a smart array of strings
       SmartArray<String> msg = new SmartArray<>();
      
       //insert some strings
       msg.add(0,"world");
       msg.add(0,"hello");
       msg.add(1,"new");
       msg.add(3,"!");
      
       //replace and checking
       if (msg.get(0).equals("hello") && msg.replace(1,"beautiful").equals("new")
           && msg.size() == 4 && msg.capacity() == 4 ){
           //System.out.println(msg);
           System.out.println("Yay 3");
       }
      
       //change capacity
       if (!msg.ensureCapacity(0) && !msg.ensureCapacity(3) && msg.ensureCapacity(20)
           && msg.capacity() == 20){
           System.out.println("Yay 4");
       }     

       //delete and shrinking
       if (msg.delete(1).equals("beautiful") && msg.get(1).equals("world")
           && msg.size() == 3 && msg.capacity() == 10 ){
           System.out.println("Yay 5");
       }
   }
}

Answer 1

IF YOU HAVE ANY DOUBTS PLEASE COMMENT BELOW I WILL THERE TO HELP YOU

ANSWER:

CODE:

public class DynamicArray<T>{

  

   private static final int INITCAP = 2; // default initial capacity / minimum capacity

   private T[] storage; // underlying array

   private int size = 0;

   private int capacity = 0;

   // ADD MORE PRIVATE MEMBERS HERE IF NEEDED!

  

   @SuppressWarnings("unchecked")

   public DynamicArray(){

   // constructor

   // initial capacity of the array should be INITCAP

   storage = (T[]) new Object[INITCAP];

   size = 0;

   capacity = INITCAP;

   }

   @SuppressWarnings("unchecked")

   public DynamicArray(int initCapacity){

   // constructor

   // set the initial capacity of the array as initCapacity

   // throw IllegalArgumentException if initCapacity < 1

   if(initCapacity < 1)

       throw new IllegalArgumentException();

   storage = (T[]) new Object[initCapacity];

   size = 0;

   capacity = initCapacity;

   }

   public int size() {

   //report the number of elements in the list

   // O(1)

   return size;

   }

  

   public int capacity() {

   //report the max number of elements before the next expansion

   // O(1)

   return capacity;

     

   }

  

   public T set(int index, T value){

   // change item x at index i to be value

   // return old item at index

   // throw IndexOutOfBoundsException for invalid index

   // O(1)

  

   // Note: you cannot add new items with this method

   if (index < 0 || index >=capacity)

       throw new IllegalArgumentException();

     

   T old = storage[index];

   storage[index] = value;

   return old;

   }

   public T get(int index){

   // return the item at index

   // throw IndexOutOfBoundsException for invalid index

   // O(1)

   if (index < 0 || index >=capacity)

       throw new IllegalArgumentException();

     

   return storage[index];

   }

   @SuppressWarnings("unchecked")

   public boolean add(T value){

   // add value to the end of the list (append)

   // return true

  

   // double the capacity if no space is available

   // amortized O(1)

  

   // Note: Remember... code reuse is awesome...

   if(size==capacity){

          T[] temp = (T[]) new Object[2*capacity];

          for(int i=0 ;i<size; ++i)

           temp[i] = storage[i];

       storage = temp;

       capacity = 2*capacity;

   }

   storage[size] = value;

   size++;

     

   return true;

   }

  

  

   @SuppressWarnings("unchecked")

   public void add(int index, T value){

   // insert value at index, shift elements if needed

   // double the capacity if no space is available

   // throw IndexOutOfBoundsException for invalid index

   // O(N) where N is the number of elements in the list

  

   // Note: this method may be used to append items as

   // well as insert items

     

   if (index < 0)

       throw new IllegalArgumentException();

     

   if(index==capacity || size == capacity){

              T[] temp = (T[]) new Object[2*capacity];

              for(int i=0 ;i<size; ++i)

               temp[i] = storage[i];

           storage = temp;

           capacity = 2*capacity;

   }

     

   for(int k = size-1; k>=index; k--)

       storage[k+1] = storage[k];

     

   storage[index] = value;

     

   size++;

     

     

     

   }

  

  

   @SuppressWarnings("unchecked")

   public T remove(int index){

   // remove and return element at position index

   // shift elements to remove any gap in the list

   // throw IndexOutOfBoundsException for invalid index

  

   // halve capacity if the number of elements falls below 1/3 of the capacity

   // capacity should NOT go below INITCAP

  

   // O(N) where N is the number of elements in the list

     

   if (index < 0 || index >=capacity)

       throw new IllegalArgumentException();

     

   T val = storage[index];

   for(int k = index; k<size; k++)

       storage[k] = storage[k+1];

     

   size--;

     

   if(size <= capacity/3) {

         

       T[] temp = (T[]) new Object[capacity/2];

              for(int i=0 ;i<size; ++i)

               temp[i] = storage[i];

           storage = temp;

           capacity = capacity/2;

   }

     

   return val;

  

   }

  

  

   // --------------------------------------------------------

   // example testing code... edit this as much as you want!

   // --------------------------------------------------------

   // Not required, update for your own testing

   @Override

   public String toString(){

   // return string representation of DynamicArray

   // update if you want to include more information

   return "DynamicArray with size "+size+", capacity "+capacity;

  

   }

  

   public static void main (String args[]){

   // new list?

   DynamicArray<Integer> ida = new DynamicArray<>();

   if ((ida.size() == 0) && (ida.capacity() == 2)){

   System.out.println("Yay 1");

   }

   // adding to the list?

   boolean ok = true;

   for (int i=0; i<3;i++)

   ok = ok && ida.add(i*5);

  

   if (ok && ida.size()==3 && ida.get(2) == 10 && ida.capacity() == 4 ){

   System.out.println("Yay 2");

   }

  

   ida.add(1,-10);

   ida.add(4,100);

   if (ida.set(1,-20)==-10 && ida.get(2) == 5 && ida.size() == 5

   && ida.capacity() == 8 ){

   System.out.println("Yay 3");

   }

  

   // removing from the list?

   if (ida.remove(0) == 0 && ida.remove(0) == -20 && ida.remove(2) == 100

   && ida.size() == 2 && ida.capacity() == 4 ){

   System.out.println("Yay 4");

   }

  

   // remember to tests more things...

   }

}

===================================
See Output

Thanks, PLEASE UPVOTE if helpful