Skip to content

Latest commit

 

History

History
135 lines (80 loc) · 9.35 KB

README.md

File metadata and controls

135 lines (80 loc) · 9.35 KB
Raw

ENSF-593 Assignment 3

An assignment on working with loops for computation and strings.

This assignment has two mandatory parts:

and four optional parts (not graded):

1. Calculating Square Root

Problem Statement

Newton's method for calculating the square root of N starts by making a (non zero) guess at the square root. It then uses the original guess to calculate a new guess, according to the following formula:

guess = (( N / guess) + guess) / 2 ;

No matter how wild the original guess is, if we repeat this calculation the algorithm will eventually find the square root of N.

Design a Java program that let's the user input a number N, a maximum error that determines the difference between two consecutive Newton computations, and the user's initial guess. Then calculate the square root using Newton's method and report both the square root and the number of guesses required to calculate it.

Object Decomposition and Class Design

What objects will your solution use? Follow the design from last assignment: An App class, let's call it NewtonApp uses a KeyboardReader (already given) for input/output and a computational object to implement Newton's method. Let's call the computational object NewtonTester. For NewtonApp and NewtonTester, draw their UML class diagrams showing class name, instance variables, and public and private methods. Show relationships between classes, including KeyboardReader (without instance variables and methods).

One public method that your NewtonTester class should have is the sqrt() method. This is the method that the command line UI will call to calculate the square root of N.

Don't forget that your NewtonTester object must not only be able to calculate the square root of a number that it is given, it must also remember how many iterations it took to calculate the square root. It must also "know" what the tolerance is and what the initial guess is in order to perform its calculation.

Method design

For this project your UI class and methods can be modeled after the command line UIs you designed in the previous lab. The constructor method should instantiate the UI components. The run() method should implement the dialog: input the values that the user typed and pass them to the NewtonTester object to perform the calculation.

For the NewtonTester you'll need methods to set and get the values of certain instance variables -- e.g., the number of iterations used -- as well as the method to calculate the square root.

Algorithm design

To design the dialog, start by writing an example on paper.

The algorithm for the NewtonTester object's sqrt() method, start by write out pseudocode description. Remember, in addition to calculating the square root, the square root method should also keep track of how many iterations were required.

**Implementation **

Use the stepwise refinement approach as you develop your code, compiling and testing short segments of your code at each stage. Commit working portions to your git repository with meaningful messages.

Here are some appropriate steps:

  • Create the command line UI, with constructor. Compile and Test.
  • Implement the dialog in the command line UI's run() method, initially just echoing the user's input. Compile and Test.
  • Create the NewtonTester object and test passing a value between the UI and its sqrt() method. The sqrt() method can just return the value it is passed for this stage. Compile and Test.
  • Develop and test the square root algorithm.

Reporting

In a markdown file Newton.md add the UML class diagram you drew as an embedded image. Include a screenshot demonstrating successful execution and outputs for at least 3 numbers. Explain why you chose these numbers for your test.

2. Secret Word

Problem Statement

Write a class that manages the String processing for an GUI that lets the user make repeated guesses at the letters contained in a secret word. The secret word is shown in masked form. For example, if the secret word is hello, it would be displayed as *****. Each time the user makes a guess, the GUI reports whether the guess is correct or not and displays the updated version of the secret word. For example, if on the first guess the user guesses 'e', the secret word would be displayed as *e***.

GUI Specifications

ELements and layouts of the GUI are implemented in src/SecretWordGUI.java.

Design Specifications

You need two Java classes for this project.

SecretWordGUI provides the graphical user interface. To save time and help focus on designing and implementing the SecretWord class, you are given the GUI interface. The GUI's actionPerformed() method uses methods of the SecretWord class.

The class, src/SecretWord.java, will be responsible for managing the secret word. You must design and implement the following elements for the SecretWord class:

  • A private String variable named secretWord initialized to a word of your choice. This string will contain the secret word against which the user's guesses will be compared.
  • A private String variable named displayedWord. This is the string that will be displayed in the GUI interface.
  • A public method named getDisplayedWord() will return the displayedWord. For example, if the game just started and the secret word is "hello", this method would return "*****".
  • A public method named getSecretWord() returns the secretWord.
  • The replaceChars() method takes two parameters, a String and a char. It replaces every character in the string with the char and returns the result. For example, replaceChars("hello", '*') will return "*****".
  • The SecretWord() constructor should assign a string literal to the secretWord variable, and it should invoke the replaceChars() method to replace all the letters in secretWord with asterisks and assign the result to displayedWord.
  • The replaceChars(String s1, String s2, char ch) method replaces in s2 every occurrence of ch in s1. For example, replaceChars("hello", "*e***", 'l') would return "*ell*".
  • The makeGuess(char ch) method tests whether its char parameter is contained in secretWord. If so it updates the displayedWord, revealing the position(s) of the guessed letter, and returns true; otherwise it returns false. For example, if the secret word is "hello", makeGuess('e') would return true and would update the displayed word to "*e***".

Implementation: Step-wise refinement

  1. Draw a UML diagram for the SecretWordGUI and SecretWord classes.
  2. A good first step for this problem is to create a stub version of the SecretWord class. The stub version must contain stub definitions of all of the SecretWord methods that are called from SecretWordGUI.
  3. Study the algorithm used in the SecretWordGUI. Initially the GUI displays the masked secret word in its text area. Each time the user types a return in the input text field, the GUI inputs the user's guess and calls the SecretWord.makeGuess() method. The GUI then displays an appropriate message and the updated secret word.
  4. Implement and test the replaceChars(String, char) method.
  5. Implement and test the makeGuess() method.
  6. Implement and test the replaceChars(String, String, char) method. This method is the most challenging part. Before starting to work on this method, you should develop the algorithm on paper.

Reporting

In a markdown file SecretWord.md add the UML class diagram you drew as an embedded image. Include a screenshot demonstrating successful execution and outputs of a guessing interaction.

Optional: Newton GUI

Instead of a command line interface, design a graphical user interface to use the NewtonTester class in problem 1.

In addition to the GUI, make the following changes:

  • Validating input, number and initial guess need to be positive.
  • Add the gold standard value of Math.sqrt() for comparison.

Rename your class to NewtonTester2.

Optional: Prime Number GUI

Write a Java GUI that prompts the user for a positive integer and then displays all of the prime numbers less than or equal to the user's integer.

How many classes do you need? What are their designs?

Optional: Pig Latin

Write a Java GUI that translates an English sentence or expression into Pig Latin https://en.wikipedia.org/wiki/Pig_Latin. The rules of Pig Latin are:

  • If the word begins with a consonant -- such as "string" "Latin" -- divide the word at the first vowel, swapping the front and back halves and append "ay" to the word -- "ingstray," "atinLay.".
  • If the word begins with a vowel -- such as "am," "are," "i" -- append "yay" to the word -- "amyay," "areyay,", "iyay.".
  • If the word has no vowels (other than 'y') -- such as "my," "thy" -- append "yay" to it -- "myyay," "thyyay."

Optional: Verifying Math

Starting at minute 57 in this video https://www.youtube.com/watch?v=QvuQH4_05LI Grant Sanderson of 3blue1brown shows how he uses Python to verify if his solution to a probability problem is correct.

Using Math.random() and loops can you verify the solution in Java following the spirit of his Python implementation? The idea is not to use arrays or any advanced packages.