Sale!

ASSIGNMENT 3 COMP-202 solution

$30.00

ASSIGNMENT 3
COMP-202
Please read the entire PDF before starting. You must do this assignment individually.
It is very important that you follow the directions as closely as possible. The directions, while
perhaps tedious, are designed to make it as easy as possible for the TAs to mark the assignments by letting
them run your assignment, in some cases through automated tests. While these tests will never be used to
determine your entire grade, they speed up the process significantly, which allows the TAs to provide better
feedback and not waste time on administrative details. Plus, if the TA is in a good mood while he or she is
grading, then that increases the chance of them giving out partial marks. 🙂

Category:

Description

5/5 - (2 votes)

ASSIGNMENT 3
COMP-202
Please read the entire PDF before starting. You must do this assignment individually.
It is very important that you follow the directions as closely as possible. The directions, while
perhaps tedious, are designed to make it as easy as possible for the TAs to mark the assignments by letting
them run your assignment, in some cases through automated tests. While these tests will never be used to
determine your entire grade, they speed up the process significantly, which allows the TAs to provide better
feedback and not waste time on administrative details. Plus, if the TA is in a good mood while he or she is
grading, then that increases the chance of them giving out partial marks. 🙂
Up to 30% can be removed for bad indentation of your code as well as omitting comments, or poor coding
structure.
To get full marks, you must:
• Follow all directions below
– In particular, make sure that all classes and method names are spelled and capitalized exactly
as described in this document. Otherwise, you will receive a 50% penalty.
• Make sure that your code compiles
– Non-compiling code will receive a 0.
• Write your name and student ID as a comment in all .java files you hand in
• Indent your code properly
• Name your variables appropriately
– The purpose of each variable should be obvious from the name
• Comment your work
– A comment every line is not needed, but there should be enough comments to fully understand
your program
1
Part 1 (0 points): Warm-up
Do NOT submit this part, as it will not be graded. However, doing these exercises might help you to do the
second part of the assignment, which will be graded. If you have difficulties with the questions of Part 1, then
we suggest that you consult the TAs during their office hours; they can help you and work with you through
the warm-up questions. You are responsible for knowing all of the material in these questions.
Warm-up Question 1 (0 points)
Create a method to print the outline of a square made up of * signs. This method must have one
parameter, which is the length of the sides in number of *’s. This method should use only two for loops,
and use if statements within the for loops to decide whether to draw a space or a star.
Draw the outline of a square as follows:
∗∗∗∗∗∗∗∗∗∗
∗ ∗
∗ ∗
∗ ∗
∗ ∗
∗ ∗
∗ ∗
∗ ∗
∗ ∗
∗∗∗∗∗∗∗∗∗∗
N.B. It is normal that the square does not appear to be a perfect square on screen as the width and the
length of the characters are not equal.
Warm-up Question 2 (0 points)
Change the method you just created to have two parameters, so that you can create rectangles. The
first parameter will be the height of the rectangle, and the second parameter will be the width of the
rectangle.
Warm-up Question 3 (0 points)
Write a program to display the (x,y) coordinates up to (9,9) of the upper right quadrant of a Cartesian
plane. As in the previous warm-up question, your solution should use two nested for loops. Your program
should also display the axes, by checking to see if the x-coordinate is zero or if the y-coordinate is zero.
Note that when both the x and y coordinates are zero, you should print a + character.
For example, the output of your code should look like:
^
|(1,9)(2,9)(3,9)(4,9)(5,9)(6,9)(7,9)(8,9)(9,9)
|(1,8)(2,8)(3,8)(4,8)(5,8)(6,8)(7,8)(8,8)(9,8)
|(1,7)(2,7)(3,7)(4,7)(5,7)(6,7)(7,7)(8,7)(9,7)
|(1,6)(2,6)(3,6)(4,6)(5,6)(6,6)(7,6)(8,6)(9,6)
|(1,5)(2,5)(3,5)(4,5)(5,5)(6,5)(7,5)(8,5)(9,5)
|(1,4)(2,4)(3,4)(4,4)(5,4)(6,4)(7,4)(8,4)(9,4)
|(1,3)(2,3)(3,3)(4,3)(5,3)(6,3)(7,3)(8,3)(9,3)
|(1,2)(2,2)(3,2)(4,2)(5,2)(6,2)(7,2)(8,2)(9,2)
|(1,1)(2,1)(3,1)(4,1)(5,1)(6,1)(7,1)(8,1)(9,1)
+———————————————
Note that in the above image, all of the coordinates containing 0’s are not displayed, since we are printing
axes instead.
Page 2
Warm-up Question 4 (0 points)
Write a method generateRandomArray() that takes as input an integer n and returns an array of size
n. The elements of the array should be random doubles between 0 (included) and 5 (excluded). You can
use Math.random() to do this.
Warm-up Question 5 (0 points)
Write a method getLargestElement() that takes an array of integers as input and returns the largest
element inside the array. For example, if the input is:
int[] arr= {1, 5, -3, 15, 4};
then getLargestElement(arr) should return 15.
Warm-up Question 6 (0 points)
Write a method getSum() that takes an array of integers as input and returns the sum of all the elements
inside the array. For example, if the input is:
int[] arr= {1, 5,-3, 15, 4};
then getSum(arr) should return 22.
Warm-up Question 7 (0 points)
Write a method countNegatives() that takes an array of integers as input and returns the number of
negative numbers inside the array. For example, if the input is:
int[] arr= {1,5,-3, 15, -13};
then countNegative(arr) should return 2.
Warm-up Question 8 (0 points)
Write a method getVowels() that takes a String as input and returns an array characters containing
all the vowels from the given string. For example, if the input is:
String s = “kangaroo”;
then getVowels(s) should return {‘a’, ‘a’, ‘o’, ‘o’}.
Warm-up Question 9 (0 points)
Create a file called Counting.java, and in this file, declare a class called Counting. This class should
ask the user when the computer should stop counting.
When should I stop counting to?
10 <—- User typed this
I am counting until 10: 1 2 3 4 5 6 7 8 9 10
Warm-up Question 10 (0 points)
For this question you have to generalize the last question. The user will give you the number they want
the computer to count up to and the step by which it will do so.
When should I stop counting to?
25 <—-
Which step should I use?
3 <—-
I am counting to 25 with a step of 3:
1 4 7 10 13 16 19 22 25
Page 3
Part 2
The questions in this part of the assignment will be graded.
Throughout this assignment you are allowed to use everything we have learned in class up to and including
arrays, Scanner, and Random. This does not mean however that you are allowed to change any of the headers
of the methods described below. You need to make sure to follow precisely the instructions provided (for
example, you’ll be using Scanner only in one of the methods for this assignment!).
Question 1: BullsAndCows (60 points)
Bulls and Cows is an old code-breaking mind game. For this question, you will write a Java program that
implements a game of Bulls and Cows in which the player needs to guess a randomly generated secret
4-digits number. When the player takes a guess, the program reveals the number of digits that match
with the secret number. If the matching digits are in the correct positions, they are called “bulls”, if
they are in different positions, they are called “cows”. After each guess, the program reveals how many
bulls and cows the player’s guess contains.
To complete this task, you will need to implement all the methods listed below. Note that you are free
to write more methods if they help the design or readability of your code. All the code for this question
must be placed in a file named BullsAndCows.java.
1a) Method to check if an element is contained in a given array
Write a method called contains() that takes as input an array of integers and a specific integer. The
method returns true if the specified integer is an element of the given array, false otherwise. For
example, let
int[] x = {-2, 7};
int[] y = {9, 0, 2, 6};
int[] z = {};
Then,
• contains(x, -3) returns false
• contains(y, 2) returns true
• contains(z, 5) returns false
1b) Method to generate the secret number
Write a method called generateSecretDigits() that takes as input an integer and returns an array
of integers containing the 4 digits that make up the randomly generated secret number. The method
uses the input to create an object of type Random with the provided seed (remember that to use Random
you should add the appropriate import statement at the beginning of your file). The method then uses
such object to generate a random integer between 0 and 9 (both included). If the integer is not already
part of the array, then the method uses it to initialize one of the elements of the array, otherwise a new
integer is generated. The process continues until all four elements of the array have been generated.
This allows us to generate an array containing four digits that are all different from one another. Make
sure to initialize the elements of the array from the first one to the last one.
For example:
• generateSecretDigits(123) returns the array {2, 0, 6, 9}
• generateSecretDigits(45) returns the array {9, 1, 0, 7}
• generateSecretDigits(987) returns the array {5, 8, 9, 7}
Page 4
1c) Method to extract the digits from a given number
Write a method called extractDigits() that takes as input an integer and returns an array containing
all the digits of the given number. Note that if the number contains less than 4 digits, then the method
returns an array with 4 elements where the missing digits are replaced by 0s and placed at the beginning
of the array.
For example,
• extractDigits(1234) returns the array {1, 2, 3, 4}.
• extractDigits(75) returns the array {0, 0, 7, 5}.
• extractDigits(593823) returns the array {5, 9, 3, 8, 2, 3}.
• extractDigits(-326) returns the array {0, 3, 2, 6}.
1d) Method to get the number of bulls in a guess
Write a method called getNumOfBulls() that takes as input two integer arrays. The first one represents
the digits of the secret number, while the second one represents the digits of the number guessed by the
player. The method returns the number of bulls in the guess of the players (see the intro paragraph for
the definition of bull in this context). If the input arrays have a different number of elements, then the
method should throw an IllegalArgumentException with an appropriate message.
For example, consider the following arrays:
int[] secret = {2, 0, 6, 9};
int[] guessOne = {9, 5, 6, 2};
int[] guessTwo = {2, 0, 6, 2};
int[] guessThree = {1, 2, 3, 4, 5, 6};
int[] guessFour = {1, 3, 4, 4, 0, 5};
Then:
• getNumOfBulls(secret, guessOne) returns 1.
• getNumOfBulls(secret, guessTwo) returns 3.
• getNumOfBulls(secret, guessThree) raises an exception.
• getNumOfBulls(guessThree, guessFour) returns 2.
1e) Method to get the number of cows in a guess
Write a method called getNumOfCows() that takes as input two integer arrays. The first one represents
the digits of the secret number, while the second one represents the digits of the number guessed by the
player. The method returns the number of cows in the guess of the players (see the intro paragraph for
the definition of cow in this context). If the input arrays have a different number of elements, then the
method should throw an IllegalArgumentException with an appropriate message.
For example, consider the following arrays:
int[] secret = {2, 0, 6, 9};
int[] guessOne = {9, 5, 6, 2};
int[] guessTwo = {2, 0, 6, 2};
int[] guessThree = {1, 2, 3, 4, 5, 6};
int[] guessFour = {1, 3, 4, 4, 0, 5};
Then:
• getNumOfCows(secret, guessOne) returns 2.
Page 5
• getNumOfCows(secret, guessTwo) returns 0.
• getNumOfCows(secret, guessThree) raises an exception.
• getNumOfCows(guessThree, guessFour) returns 3.
1f) Method to simulate a game
Write a method playBullsAndCows() which takes an integer as input and simulates a game of Bulls and
Cows. The method creates one object of type Scanner to retrieve the inputs from the user (remember
that to use Scanner you should add the appropriate import statement at the beginning of your file).
The method should then do the following:
1. Generate a random secret number to be guessed using generateSecretDigits() and the integer
received as input.
2. Display a welcome message to the player. It is up to you to decide how to welcome the users of
your program.
3. Display a message encouraging the player to make a guess. The message should also display the
guess attempt.
4. The method retrieves the guess as an integer. Here you can assume that the player will enter an
input of the correct type.
• If the player inputs a negative integer or an integer with more than 5 digits, then the method
displays a message letting them know they wasted one guess and that they should enter a
positive integer with at most 4 digits.
• Otherwise, the method displays how many bulls and cows the player’s guess contains.
5. If the player guessed the secret number, then the method congratulates the player and let them
know how many tries were needed to win the game.
6. If the player has not guessed the secret number after 5 guesses, then the method should start to
ask the player if they want to quit the game at each incorrect guess. If the player replies with a
‘y’ (which is retrieved as a String) the method should displays a message acknowledging that the
player wanted to quit and letting them know how many times they tried to guess the secret number.
7. If the player did not guess the number nor decided to quit, then the method goes back to step
three.
To complete the program, simply call playBullsAndCows() from the main method providing an integer
of your choice as input. Note that the secret number generated depends on that integer. If you want
to test your program with different numbers you should change the integer provided as input. In fact,
to play the game you can generate a random integer inside the main method (using Math.random())
and provide such integer as input to playBullsAndCows(). To debug your program, we highly suggest
you fix a specific integer so that it will be easier to understand whether your method is behaving as it
should.
Note that you can add additional features of your choice to the game. For example your game could do
the following:
• Your method could ask for the name of the player.
• Your method could display different messages depending on the number guess attempts.
• Your method could use a different layout.
• Your method could display the number of seconds the game was played for (if you’d like to do that,
you can use System.currentTimeMillis()).
Page 6
• Any other thing you can think of as long as you don’t use any another class beside Scanner, Random,
and those that belongs to java.lang package.
Note that none of the above features is needed (you won’t receive extra marks for it), but it might be
fun to make the game a little more original. 🙂
Below you can find a couple of sample runs of the program. Note that our program displays the number
of seconds played, but yours does not have to do that. In all of the examples, the call made from the
main method was playBullsAndCows(123) (this means that the secret number to guess is 2069).
Examples
Page 7
Page 8
Question 2: Polynomial functions (40 points)
For this question you will write a program which allows you to draw curves corresponding to functions
of the form
y = anx
n + an−1x
n−1 + · · · + a1x + a0
where the ai
’s are decimal numbers. Although the general formula might look quite complicated, particular examples are much simpler. For instance, the following equation represents a constant function
which is a polynomial function of degree 0:
y = 4
The following equation represents a line which is a polynomial function of degree 1:
y = x + 2
The following equation represents a parabola which is a polynomial function of degree 2:
y = 0.1x
2 − x − 8
And finally, the following equation represents a cubic which is a polynomial function of degree 3:
y =
1
25
x
3 + 0.1x + 0.5
You will be able to draw the graphs of the functions using print statements, conditional statements, and
loops. The graphs should be drawn on a Cartesian plane with four quadrants, where each quadrant has
at least a 10 by 10 grid size. To achieve this, write the following three methods. Note that you are free
to write more methods if they help the design or readability of your code. The code for this question
must be placed in the file named PolynomialCurves.java
2a. A method called onCurve
Write a method called onCurve() that takes 3 inputs: an integer array representing the coordinates of
a point on the plane, a double array representing the coefficients of the polynomial function you want
to draw, and a double representing the desired thickness of the curve. The method determines whether
or not the given point should be considered to be part of the specified curve given the desired thickness.
In general, given the coefficients of a polynomial function {an, an−1, . . . , a1, a0}, a specific point (x0, y0)
is considered to be part of the curve if the following equation holds:
y0 = anx
n
0 + an−1x
n−1
0 + · · · + a1x0 + a0
Since our drawing system is not continuous (i.e. it is a 20 by 20 grid), you need to relax the equality in
the equation. Instead of checking if the equality is satisfied, you should check if the following inequalities
are satisfied
y0 − t < anx
n
0 + an−1x
n−1
0 + · · · + a1x0 + a0 < y0 + t
where t represents the thickness of the curve being drawn.
Thus, to recap, the method receives as input the coordinates of a point ({x0, y0}), the coefficients of a curve ({an, an−1, . . . , a1, a0}), and a desired thickness (t). The method returns
true if the above inequalities are satisfied, false otherwise.
Consider the following variables
double[] line = {1.0, 2}; // y = x + 2
double[] parabola = {0.1, -1, -8}; // y = 0.1x^2 – x – 8
int[] pointOne = {0, 2};
int[] pointTwo = {0, -8};
int[] pointThree = {-5, -1};
int[] pointFour = {3, 5};
double lineThickness = 1;
double parabolaThickness = 1.05;
Page 9
Then,
• onCurve(pointOne, line, lineThickness) returns true
• onCurve(pointTwo, line, lineThickness) returns false
• onCurve(pointThree, line, lineThickness) returns false
• onCurve(pointFour, line, lineThickness) returns true
• onCurve(pointOne, parabola, parabolaThickness) returns false
• onCurve(pointTwo, parabola, parabolaThickness) returns true
• onCurve(pointThree, parabola, parabolaThickness) returns true
• onCurve(pointFour, parabola, parabolaThickness) returns false
2b. A method to verify the inputs
Write a method called verifyInput() which takes two inputs: an array of doubles representing the
coefficients of a polynomial curve, and a double representing the desired thickness of the curve. The
method should throw an IllegalArgumentException (and display a helpful error message) if the array
does not have at least one element, or if the second input is not a positive number. Note that the
messages should be different depending on the issue. Otherwise, the method will not do anything. Note
that this means in particular that the method does not return any value.
2c. A method to draw the graph of a polynomial curve
Write a method called drawCurve() that takes 3 inputs: an array of doubles representing the coefficients of a polynomial curve, a double representing the desired thickness of the curve, and a character
representing the symbol with which the curve will be drawn. Both of the methods described above must
be called and used appropriately in this method in order to get full points.
The method first verifies that the inputs received are valid and if so, the method proceeds to draw the
specified curve.
Remember that the graph of the curve should be drawn on a Cartesian plane with four quadrants, where
each quadrant has at least a 10 by 10 grid size.
The rules for displaying the axes (the x-axis and the y-axis) are as follows: to represent the x-axis dashes
(-) should be used, to represent the y-axis vertical bars (|) should be used. The y-axis (in the positive
direction) should end in a hat symbol (ˆ), and the x-axis (in the positive direction) should end in a right
triangle bracket (). You should use the plus symbol (+) to represent the origin. This means that there
are a total of 21 characters on the x-axis, and 21 characters on the y-axis, with the origin counting as
being on both.
Note that, we want the y-axis to extend at least 5 points above and below the y-intercept of the curve
(the point on the curve with x-coordinate 0). Therefore, if this does not happen naturally with the set
up of the grid, then the y-axis should be extended accordingly.
Finally, if more than one character should be drawn at the same location (eg, if the curve intersects with
an axis), the curve gets priority.
To achieve all this, you will have to use two loops, one counting the x position and the other one counting
the y position. For each position (x, y) in the grid, you need to determine what to draw at that particular
position. Pay attention to the order of importance for drawing the symbols 1
.
Your main method will not be graded. However, we strongly advise that you write a main method in
order to test your code. You may include it in your submission as long as it compiles.
1e.g. The axis arrow head has higher importance than the axis lines -.
Page 10
You can find below what would be displayed when each snippet of codes is executed.
Examples
double[] constant = {4}; // y = 4
drawCurve(constant, 1, ’O’);
Page 11
double[] lineOne = {1.0, 2}; // y = x + 2
drawCurve(lineOne, 1, ‘*’);
Page 12
double[] lineTwo = {-2.0, 12}; // y = -2x + 12
drawCurve(lineTwo, 1, ‘@’);
Page 13
double[] parabola = {0.1, -1, -8}; // y = 0.1x^2 – x – 8
drawCurve(parabola, 1.05, ‘&’);
Page 14
double[] cubic = {1.0/25, 0, 0.1, -1.5};
drawCurve(cubic, 1, ‘o’);
What To Submit
Please put all your files in a folder called Assignment3. Zip the folder (DO NOT RAR it) and submit it in
MyCourses.
Inside your zipped folder, there must be the following files. Do not submit any other files, especially
.class files. Any deviation from these requirements may lead to lost marks.
BullsAndCows.java
PolynomialCurves.java
Confession.txt (optional) In this file, you can tell the TA about any issues you ran into doing
this assignment.
Page 15