Academic Integrity: tutoring, explanations, and feedback — we don’t complete graded work or submit on a student’s behalf.

JAVA package algs11; import java.util.Arrays; import stdlib.*; /** * This is a s

ID: 3872207 • Letter: J

Question

JAVA

package algs11;

import java.util.Arrays;
import stdlib.*;

/**
* This is a skeleton file for your homework. Edit the sections marked TODO. You
* may also edit the function "main" to test your code.
*
* You must not change the declaration of any method. This will be true of every
* skeleton file I give you.
*
* For example, you will get zero points if you change the line
* <pre>
*     public static double minValue (double[] list) {
* </pre>
* to something like
* <pre>
*     public static void minValue (double[] list) {
* </pre>
* or
* <pre>
*     public static double minValue (double[] list, int i) {
* </pre>
*
* Each of the functions below is meant to be SELF CONTAINED. This means that
* you should use no other functions or classes. You should not use any HashSets
* or ArrayLists, or anything else! In addition, each of your functions should go
* through the argument array at most once. The only exception to this
* removeDuplicates, which is allowed to call numUnique and then go through the
* array once after that.
*/
public class CSC300Program2 {

   /**
   * numUnique returns the number of unique values in an array of doubles.
   * Unlike the previous questions, the array may be empty and it may contain
   * duplicate values. Also unlike the previous questions, you can assume the
   * array is sorted.
   *
   * Your solution must go through the array exactly once. Your solution must
   * not call any other functions. Here are some examples (using "=="
   * informally):
   *
   * <pre>
   *     0 == numUnique(new double[] { })
   *     1 == numUnique(new double[] { 11 })
   *     1 == numUnique(new double[] { 11, 11, 11, 11 })
   *     8 == numUnique(new double[] { 11, 11, 11, 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88, 88 })
   *     8 == numUnique(new double[] { 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88 })
   * </pre>
   */
   public static int numUnique (double[] list) {
       return StdRandom.uniform (100); //TODO: fix this
   }

   /**
   * removeDuplicates returns a new array containing the unique values in the
   * array. There should not be any extra space in the array --- there should
   * be exactly one space for each unique element (Hint: numUnique tells you
   * how big the array should be). You may assume that the list is sorted, as
   * you did for numUnique.
   *
   * Your solution may call numUnique, but should not call any other
   * functions. After the call to numUnique, you must go through the array
   * exactly one more time. Here are some examples (using "==" informally):
   *
   * <pre>
   *   new double[] { }
   *     == removeDuplicates(new double[] { })
   *   new double[] { 11 }
   *     == removeDuplicates(new double[] { 11 })
   *     == removeDuplicates(new double[] { 11, 11, 11, 11 })
   *   new double[] { 11, 22, 33, 44, 55, 66, 77, 88 }
   *     == removeDuplicates(new double[] { 11, 11, 11, 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88, 88 })
   *     == removeDuplicates(new double[] { 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88 })
   * </pre>
   */
   public static double[] removeDuplicates (double[] list) {
       return list; // TODO: fix this
   }
/**
* Objective: become familiar with the drawing routines in the StdDraw library. page 43
*
* #1 : create a cohesive image.
*/
   public static void drawASimplePicture() {
       // To Do:   remove the code below and replace your code which meets the above spec
       StdDraw.square(.5, .5, .5);
       StdDraw.setPenColor(StdDraw.BLUE);
       StdDraw.line(.5, .5, .9, .5);
       StdDraw.line(.9, .5, .5, .8);
       StdDraw.line(.5, .8, .5, .5);
       StdDraw.circle(.7, .65, .25);
   }
   /**
   * A test program, using private helper functions. See below.
   * To make typing tests a little easier, I've written a function to convert strings to arrays. See below.
   */
   public static void main (String[] args) {      
       // for numUnique: array must be sorted
       testNumUnique (0, new double[] {});
       testNumUnique(1,new double[] {11});
       testNumUnique(1,new double[] {11,11,11,11});
       testNumUnique(4,new double[] {11,21,31,41});
       testNumUnique(4,new double[] {11,11,11,21,31,31,31,31,41});
       testNumUnique(4,new double[] {11,21,21,21,31,41,41,41,41});
       testNumUnique(4,new double[] {11,11,21,21,21,31,31,41,41,41,41});
       testNumUnique(8,new double[] {11,11,11,11,21,31,41,41,41,41,41,51,51,61,71,81,81});
       testNumUnique(8,new double[] {11,21,31,41,41,41,41,41,51,51,61,71,81});
       testNumUnique(7,new double[] {11,11,11,11,21,31,41,41,41,41,41,51,51,61,71});
       testNumUnique(7,new double[] {11,21,31,41,41,41,41,41,51,51,61,71});
       testNumUnique(8,new double[] {-81,-81,-81,-81,-71,-61,-51,-51,-51,-51,-41,-41,-31,-21,-11,-11,-11});

       // for removeDuplicates: array must be sorted
       testRemoveDuplicates (new double[] {}, new double[] {});
       testRemoveDuplicates (new double[] {11}, new double[] {11} );
       testRemoveDuplicates (new double[] {11}, new double[] {11,11,11,11} );
       testRemoveDuplicates (new double[] {11,21,31,41}, new double[] {11,21,31,41} );
       testRemoveDuplicates (new double[] {11,21,31,41}, new double[] {11,11,11,21,31,31,31,31,41} );
      
  
       testRemoveDuplicates(new double[] {11,21,31,41} , new double[] {11,21,21,21,31,41,41,41,41} );
       testRemoveDuplicates(new double[] {11,21,31,41} , new double[] {11,11,21,21,21,31,31,41,41,41,41} );
       testRemoveDuplicates(new double[] {11,21,31,41,51,61,71,81} , new double[] {11,11,11,11,21,31,41,41,41,41,41,51,51,61,71,81,81} );
       testRemoveDuplicates(new double[] {11,21,31,41,51,61,71,81} , new double[] {11,21,31,41,41,41,41,41,51,51,61,71,81} );
       testRemoveDuplicates(new double[] {11,21,31,41,51,61,71} , new double[] {11,11,11,11,21,31,41,41,41,41,41,51,51,61,71} );
       testRemoveDuplicates(new double[] {11,21,31,41,51,61,71} , new double[] {11,21,31,41,41,41,41,41,51,51,61,71} );
       testRemoveDuplicates(new double[] {-81,-71,-61,-51,-41,-31,-21,-11} , new double[] {-81,-81,-81,-81,-71,-61,-51,-51,-51,-51,-41,-41,-31,-21,-11,-11,-11} );
       StdOut.println ("Finished tests");
      
       drawASimplePicture();
   }

   private static void testNumUnique (int expected, double[] list) {
  
       int actual = numUnique (list);

       if (expected != actual) {
           StdOut.format ("Failed numUnique([%s]): Expecting (%d) Actual (%d) ", Arrays.toString(list), expected, actual);
       }
   }
   private static void testRemoveDuplicates (double[] expected, double[] list) {
  
       double[] actual = removeDuplicates (list);

       // != operator does not do what we want on arrays, use   equals   function from Arrays class
       if (! Arrays.equals (expected, actual)) {
           StdOut.format ("Failed removeDuplicates([%s]): Expecting (%s) Actual (%s) ", Arrays.toString(list), Arrays.toString (expected), Arrays.toString (actual));
       }
   }

}

Explanation / Answer

Hi ,

Please have the code and output.

========================CSC300Program2.java===========================

package algs11;

import java.util.Arrays;

import edu.princeton.cs.introcs.StdDraw;

import edu.princeton.cs.introcs.StdOut;

/**

* This is a skeleton file for your homework. Edit the sections marked TODO. You may also edit the function "main" to test your

* code.

*

* You must not change the declaration of any method. This will be true of every skeleton file I give you.

*

* For example, you will get zero points if you change the line

*

* <pre>

* public static double minValue (double[] list) {

* </pre>

*

* to something like

*

* <pre>

* public static void minValue (double[] list) {

* </pre>

*

* or

*

* <pre>

* public static double minValue (double[] list, int i) {

* </pre>

*

* Each of the functions below is meant to be SELF CONTAINED. This means that you should use no other functions or classes. You

* should not use any HashSets or ArrayLists, or anything else! In addition, each of your functions should go through the argument

* array at most once. The only exception to this removeDuplicates, which is allowed to call numUnique and then go through the array

* once after that.

*/

public class CSC300Program2 {

/**

* numUnique returns the number of unique values in an array of doubles. Unlike the previous questions, the array may be empty

* and it may contain duplicate values. Also unlike the previous questions, you can assume the array is sorted.

*

* Your solution must go through the array exactly once. Your solution must not call any other functions. Here are some examples

* (using "==" informally):

*

* <pre>

* 0 == numUnique(new double[] { })

* 1 == numUnique(new double[] { 11 })

* 1 == numUnique(new double[] { 11, 11, 11, 11 })

* 8 == numUnique(new double[] { 11, 11, 11, 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88, 88 })

* 8 == numUnique(new double[] { 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88 })

* </pre>

*/

public static int numUnique(double[] list) {

int count = 0;

for (int i = 0; i < list.length; i++) {

if (i != 0) {

if (list[i] != list[i - 1]) {

count++;

}

} else

count++;

}

return count;

}

/**

* removeDuplicates returns a new array containing the unique values in the array. There should not be any extra space in the

* array --- there should be exactly one space for each unique element (Hint: numUnique tells you how big the array should be).

* You may assume that the list is sorted, as you did for numUnique.

*

* Your solution may call numUnique, but should not call any other functions. After the call to numUnique, you must go through

* the array exactly one more time. Here are some examples (using "==" informally):

*

* <pre>

* new double[] { }

* == removeDuplicates(new double[] { })

* new double[] { 11 }

* == removeDuplicates(new double[] { 11 })

* == removeDuplicates(new double[] { 11, 11, 11, 11 })

* new double[] { 11, 22, 33, 44, 55, 66, 77, 88 }

* == removeDuplicates(new double[] { 11, 11, 11, 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88, 88 })

* == removeDuplicates(new double[] { 11, 22, 33, 44, 44, 44, 44, 44, 55, 55, 66, 77, 88 })

* </pre>

*/

public static double[] removeDuplicates(double[] list) {

double[] list2 = new double[numUnique(list)];

int j = 0;

for (int i = 0; i < list.length; i++) {

if (i != 0) {

if (list[i] != list[i - 1]) {

list2[j] = list[i];

j++;

}

} else {

list2[j] = list[i];

j++;

}

}

return list2;

}

/**

* Objective: become familiar with the drawing routines in the StdDraw library. page 43

*

* #1 : create a cohesive image.

*/

public static void drawASimplePicture() {

// To Do: remove the code below and replace your code which meets the above spec

StdDraw.square(.5, .5, .5);

StdDraw.setPenColor(StdDraw.BLUE);

StdDraw.line(.5, .5, .9, .5);

StdDraw.line(.9, .5, .5, .8);

StdDraw.line(.5, .8, .5, .5);

StdDraw.circle(.7, .65, .25);

}

/**

* A test program, using private helper functions. See below. To make typing tests a little easier, I've written a function to

* convert strings to arrays. See below.

*/

public static void main(String[] args) {

// for numUnique: array must be sorted

testNumUnique(0, new double[] {});

testNumUnique(1, new double[] { 11 });

testNumUnique(1, new double[] { 11, 11, 11, 11 });

testNumUnique(4, new double[] { 11, 21, 31, 41 });

testNumUnique(4, new double[] { 11, 11, 11, 21, 31, 31, 31, 31, 41 });

testNumUnique(4, new double[] { 11, 21, 21, 21, 31, 41, 41, 41, 41 });

testNumUnique(4, new double[] { 11, 11, 21, 21, 21, 31, 31, 41, 41, 41, 41 });

testNumUnique(8, new double[] { 11, 11, 11, 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71, 81, 81 });

testNumUnique(8, new double[] { 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71, 81 });

testNumUnique(7, new double[] { 11, 11, 11, 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71 });

testNumUnique(7, new double[] { 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71 });

testNumUnique(8, new double[] { -81, -81, -81, -81, -71, -61, -51, -51, -51, -51, -41, -41, -31, -21, -11, -11, -11 });

// for removeDuplicates: array must be sorted

testRemoveDuplicates(new double[] {}, new double[] {});

testRemoveDuplicates(new double[] { 11 }, new double[] { 11 });

testRemoveDuplicates(new double[] { 11 }, new double[] { 11, 11, 11, 11 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41 }, new double[] { 11, 21, 31, 41 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41 }, new double[] { 11, 11, 11, 21, 31, 31, 31, 31, 41 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41 }, new double[] { 11, 21, 21, 21, 31, 41, 41, 41, 41 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41 }, new double[] { 11, 11, 21, 21, 21, 31, 31, 41, 41, 41, 41 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41, 51, 61, 71, 81 },

new double[] { 11, 11, 11, 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71, 81, 81 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41, 51, 61, 71, 81 },

new double[] { 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71, 81 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41, 51, 61, 71 },

new double[] { 11, 11, 11, 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71 });

testRemoveDuplicates(new double[] { 11, 21, 31, 41, 51, 61, 71 },

new double[] { 11, 21, 31, 41, 41, 41, 41, 41, 51, 51, 61, 71 });

testRemoveDuplicates(new double[] { -81, -71, -61, -51, -41, -31, -21, -11 },

new double[] { -81, -81, -81, -81, -71, -61, -51, -51, -51, -51, -41, -41, -31, -21, -11, -11, -11 });

StdOut.println("Finished tests");

drawASimplePicture();

}

private static void testNumUnique(int expected, double[] list) {

int actual = numUnique(list);

if (expected != actual) {

StdOut.printf("Failed numUnique([%s]): Expecting (%d) Actual (%d) ", Arrays.toString(list), expected, actual);

}

}

private static void testRemoveDuplicates(double[] expected, double[] list) {

double[] actual = removeDuplicates(list);

// != operator does not do what we want on arrays, use equals function from Arrays class

if (!Arrays.equals(expected, actual)) {

StdOut.printf("Failed removeDuplicates([%s]): Expecting (%s) Actual (%s) ", Arrays.toString(list),

Arrays.toString(expected), Arrays.toString(actual));

}

}

}

====O/P===

Finished tests

Let me know in case of any concerns.

Related Questions

JAVA expert please help me the program with hashCode() URL: https://en.wikipedia
Question #3810026
JAVA expert please help me: import java.util.ArrayList; import java.util.HashMap
Question #3810023
JAVA from 26 to 29 pleases 26. What is recursion in Java? 27. The condition that
Question #3720700
JAVA from 6 to 7 pleases 6. Printing objects. Consider the class below: public s
Question #3720441
JAVA from control structures through objects 6th edition tony gaddis java progra
Question #3836708
JAVA from control structures through objects 6th edition tony gaddis java progra
Question #3836758
JAVA game design The game is a puzzle; the objective is to place all eight color
Question #2246329
JAVA have to do copyList() can anyone help please? 2. (2.5 points) Starting from
Question #3855452

Navigate

Previous
JAVA only. Do not copy and paste from another code, you will not get points. Wri
Next
JAVA package algs21; import stdlib.*; // Exercise 2.1.14 /** * Complete the foll

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.