small fix assignment 5

_sources/Extensions/1.1.rst

@@ -0,0 +1,84 @@
+======================================================
+Extension 1.1: Speed Limit Fine Calculator (3 points)
+======================================================
+
+Authors:
+
+* `Ron K. Cytron <http://www.cs.wustl.edu/~cytron/>`_
+* Michael Waldman
+* Alan Waldman
+* Cameron Wong
+
+You will calculate the fine drivers have to pay when going over the speed limit in the state of Massachusetts according to the `Massachusetts DMV <http://www.dmv.org/ma-massachusetts/traffic-tickets.php>`_.
+
+By completing this work, you demonstrate that you can:
+
+* Create a Java class on your own
+* Arrange for the class to take inputs of interest
+* Compute output values of interest
+* Produce meaningful output based on your computations
+
+The objective of this extension is to allow you to practice **assignment statements** and **data types** as well as for you to create a practical tool, though of course we hope you never need to compute a speeding fine for yourself.
+
+Consider the following story: 
+
+* Pat is driving a Mini Cooper at 85 MPH on a road that has the speed limit of 60 MPH.
+* Pat is therefore going 25 MPH over the speed limit.
+* If Pat is caught speeding, what would be Pat's fine?  
+
+We'll model the fine after Massachusetts law:
+
+* A fine is assessed only if the driver's speed is over the speed limit.
+* The fine is $10 for every mile over the speed limit, but there is a $100 minimum fine.
+* Example: If someone is going 75 MPH on a road with a speed limit of 60 MPH, the fine would be 15*$10 = $150.
+* Example: If someone is going 65 MPH on a road with a speed limit of 60 MPH, the fine would be $100.
+
+Procedure
+==================
+
+
+1. First, create a **SpeedLimit** Java class in the ``speeding`` package of the ``extensions`` source folder.
+2. Consider and decide upon the **data type** to represent information of interest to this problem.
+3. You must ask the user for input values for the driver's speed and the speed limit. For the automated test to work properly, please ask in that order.
+4. Arrange for your program to produce output such that if the driver is going at or under the speed limit, the fine is $0 and the only thing you print is "Have a nice day.". (You may use an if statement for this and wrap the rest in an else statement, but you may not use any other if or else if statements.)
+
+5. If the driver is speeding, your program should print how many miles you were going over the speed limit and how much money the fine will be.
+
+	Reminder:
+
+	* If the driver is going less than 10 miles over the speed limit, the fine is $100.
+	* If the driver is going over 10 miles over the speed limit, the fine is 10 times the number of miles over the speed limit.
+
+You must compute the fine **without** using `if`-statements.  To evaluate an expression conditionally, use the `ternary <http://alvinalexander.com/java/edu/pj/pj010018>`_ operator, an example of which follows:
+
+::
+
+	int x = (y > 7) ? 12 : 5;
+
+
+If ``y``'s value is greater than ``7``, the variable ``x`` is set to ``12``;  otherwise ``x`` is set to ``5``.
+
+Sample output based on the example story above:
+
+::
+
+	You reported a speed of 85 MPH for a speed limit of 60 MPH.
+	You went 25 MPH over the speed limit.
+	Your fine is $250.
+
+Make sure to match the format exactly in order to pass the tests.
+
+Running JUnit tests
+===================
+
+JUnit tests allow you to automatically check your work. To run the tests for this extension, right-click on ``SpeedLimitTestSuite.java`` > Run As... > JUnit Test. You may also simply open the Test Suite file and click the green Run button.
+
+Important: when you're running JUnit tests, make sure to comment out any Scanner input-related print statements (such as asking for the driver's speed). The tests don't expect those lines at the beginning.
+
+If your code passes all the tests, you'll see a green bar.
+
+If your code does not pass all the tests, you'll see a red bar. On the bottom-left corner of the screen, you'll see a section titled the "Failure Trace". This section will be extremely useful throughout this class for figuring out how to fix your code!
+
+Usually, test errors will say something along the lines of "expected abc, actual xyz", which means that the correct output would have been "abc", but your program is currently outputting "xyz" for those inputs.
+
+Use these differences to guide your understanding of what parts of your program you need to fix.

_sources/Extensions/2.1.rst

@@ -0,0 +1,91 @@
+========================================================
+Extension 2.1: Image Processor With Iteration
+========================================================
+
+**Authors**
+
+* `Ron K. Cytron <http://www.cs.wustl.edu/~cytron/>`_
+* Ken Goldman
+* Logan Sorentino
+* `Dennis Cosgrove <http://www.cs.wustl.edu/~cosgroved/>`_
+
+
+Manipulating an Image Raster
+============================
+
+In the ``nonexam.imagetransform`` package, modify the provided ``ImageTransforms`` Java program to implement the methods as described below. Your methods will use iteration (either `while` loops or `for` loops) to operate on the pixels of a picture.
+
+.. youtube:: VJiE78FTohs
+    :width: 600
+    :align: center
+
+
+Testing
+============
+
+Some common errors you may see while testing this extension:
+
+* ArrayIndexOutOfBoundsException. This error means you're trying to use an array index that is out of bounds (<0 or >=length). The error will tell you the index you're trying to use and the length of the array, and the second line will tell you which line the error is happening on. (Ex: ImageTransforms.java:70 means the erroneous index is on line 70 of ``ImageTransforms.java``
+* NullPointerException. Generally, this error means something is null (hasn't been initialized) that shouldn't be null. For this assignment, that means at least one of the values in ``destination`` is null, which means you didn't finish filling in the values.
+
+For this extension, we recommend using ``ImageTransformsDebugApp`` for a more visual testing experience.
+
+Quick tip: uncheck "display correct results?" on the top right of the debug app to skip to the cases you need to fix.
+
+
+Instructions
+============
+
+Each of the methods described below is found in the ``ImageTransforms`` class.
+
+Quick tip: You will be using a lot of nested for loops in this extension. Reminder that ``i`` is just a variable name and you can name the loop variable anything, like ``row`` or something else descriptive.
+
+1. Complete the method ``Color[][] copy(Color[][] source)`` to create a new 2D array of Colors which is simply copy the values from source 2D array of Colors.
+
+	.. image:: 2.1/copy_gradient.png
+
+	.. image:: 2.1/copy_you_belong_here.png
+
+	.. image:: 2.1/copy_bear.png
+
+2. Complete the method ``Color[][] flipHorizontal(Color[][] source)`` to create a new 2D array of Colors which contains the flipped horizontally values from source 2D array of Colors.
+
+
+	.. image:: 2.1/flip_horizontal_gradient.png
+
+	.. image:: 2.1/flip_horizontal_you_belong_here.png
+
+	.. image:: 2.1/flip_horizontal_bear.png
+
+3. Complete the method ``Color[][] flipVertical(Color[][] source)`` to create a new 2D array of Colors which contains the flipped vertically values from source 2D array of Colors.
+
+	.. image:: 2.1/flip_vertical_gradient.png
+
+	.. image:: 2.1/flip_vertical_you_belong_here.png
+
+	.. image:: 2.1/flip_vertical_bear.png
+
+4. Complete the method ``Color[][] mirrorLeftOntoRight(Color[][] source)`` to create a new 2D array of Colors which contains mirrored values from source 2D array of Colors.
+
+	> The left half of the target image should be same as the source, but the right half of the destination image should be the mirror of the left half of the source.
+
+	.. image:: 2.1/mirror_left_onto_right_gradient.png
+
+	.. image:: 2.1/mirror_left_onto_right_you_belong_here.png
+
+	.. image:: 2.1/mirror_left_onto_right_bear.png
+
+5. Complete the method ``Color[][] rotateRight(Color[][] source)`` to create a new 2D array of Colors which contains rotated right values from source 2D array of Colors.
+
+	Note: the dimensions of the returned destination are different from the source.
+
+	.. image:: 2.1/rotate_right_gradient.png
+
+	.. image:: 2.1/rotate_right_you_belong_here.png
+
+	.. image:: 2.1/rotate_right_bear.png
+
+
+
+
+

_sources/Extensions/2.3.rst

@@ -0,0 +1,98 @@
+=================
+Extension 2.3: Rock-Paper-Scissors
+=================
+
+**Authors**
+
+* `Ron Cytron <http://www.cs.wustl.edu/~cytron/>`_
+
+The game of `Rock-Paper-Scissors <https://en.wikipedia.org/wiki/Rock-paper-scissors>`_ (hereafter, RPS) is a two-player game that can be used to avoid boredom and to settle disputes.
+
+In this extension you will simulate two players: one plays randomly while
+the other rotates faithfully from rock to paper to scissors. Your task is
+to simulate this game and to report the fraction of games won by
+each of the two players.
+
+Procedure
+==================
+
+Find the ``nonexam.rockpaperscissors`` package in the source folder.
+
+It is suggested that you develop code in small steps, so that you can proceed from confidence to confidence, and not have a big pile of untested code to debug at the end.
+
+To help motivate this approach, the TAs will not help you unless you have shown progress based on these steps. Ask for help as soon as you need it, but please follow the steps below so that you can gain confidence.
+
+The steps you might consider are as follows:
+
+1. What inputs does your program need? First, get your program to accept those inputs and print them out so you can see they are set properly.
+
+  This means that you should type in the code to prompt the user for the input(s), print out the values of those inputs, and that\'s all for now. Run your program at this point
+  and make sure it is behaving as you want.
+  What inputs do you need? There\'s no reason to ask for more than is necessary. At a minimum, you have to know how many rounds of RPS to play before printing the resulting
+  statistics
+
+2. Next, create a loop that simply iterates the desired number of times.
+
+  Again, run your program. You may want to print something out in your loop so you can
+  verify that the loop works correctly.
+
+3. You next can make the concept of the random player real. This means declaring a variable name of a suitable type to represent this concept, establishing the variable\'s initial value.
+
+  What is the concept of the player? There are many details about the
+  player that appear unnecessary: the player\'s name, address, cell phone number.
+
+  On the other hand, if we are going to play RPS, we need to know what move the player has made. This is the important concept.
+
+  How do we represent the choice of rock, paper, or scissors?
+  This is left up to you, so try for something simple. It may help to recall how Paul
+  Revere was `poetically <http://www.nationalcenter.org/PaulRevere%27sRide.html>`_ told of how the British were coming: one if by land,
+  two if by sea.
+
+  In otherwords, an ``int`` encoded the manner of invasion.
+
+  If there were only two choices, why didn\'t Paul use a ``boolean``?
+  Sadly, `Boole <https://en.wikipedia.org/wiki/George_Boole>`_
+  was not yet born
+
+4. In your loop, you should modify this variable\'s value to reflect the associated player choosing randomly among rock, paper, and scissors each iteration.
+
+  You\'ve seen how to use the random number generator to pick between two outcomes.
+  Now you must pick between three.
+
+5. Run your program and verify that the player is choosing randomly.
+
+6. OK, now for the other player. This player must cycle among rock, paper, and scissors. Let\'s make this player real by declaring a variable name of a suitable type and establishing its initial value.
+
+  In the interest of consistency and simplicity, you should use the same
+  encoding for this player in terms of what value means rock, what value means
+  paper, and what value means scissors.
+
+7. In your loop, arrange for this player to choose its next move based on its previous move. If the move used to be rock, it\'s now paper. If the move used to be paper, it\'s now scissors. If the move was scissors, it\'s now rock.
+
+8. Run your program again and make sure the cycling player is behaving properly.
+
+  To verify the cycling player\'s behavior, you will probably want to print out
+  the values representing that player\'s move each iteration.
+
+  It won\'t take many iterations to see if this is working or not: 10 should do.
+
+9. Each player has made a move; now let\'s see who won. First, pick a name, type, and initial value for the number of wins a player has. Do the same for the other player.
+
+  Why do we need a variable to keep track of each player\'s wins?
+  Why not keep track of only one player\'s wins and assume the other player won the
+  other rounds?
+
+10. In the loop, determine who won based on the current value of each player\'s move.
+
+  Use the `rules <https://en.wikipedia.org/wiki/Rock-paper-scissors#Game_play>`_
+  of RPS to adjudicate the winner,
+  and credit the win count properly.
+
+11. After the loop completes, report the fraction of wins awarded to each of the two players.
+
+12. Test your code by trying it with just one iteration, two iterations, and three iterations. Make sure it\'s working before you set it loose.
+
+13. Run your code several times, each on 1000 iterations.
+
+14. Based on what you see, did one player tend to win more often than the other?
+

_sources/Extensions/2.5.rst

@@ -0,0 +1,75 @@
+=========================
+Extension 2.5: Mario
+=========================
+
+Authors:
+
+* Nathan Vogt
+* Elie Schramm
+* Dotun Taiwo
+
+`Mario <https://en.wikipedia.org/wiki/Mario_(franchise)>`_, created in 1981 by Nintendo, is a classic video game starring the fictional Italian character Mario. In the assignment,  loops printing hashtags will be used to build the block mountains as seen in the picture. 
+
+.. image:: Super-Mario-Bros.-3.jpg
+
+* Find and open the Java class Mario in the ``nonexam.mario`` package.
+* Your program must first prompt the user for two integer inputs using ``Scanner``. These must be requested in the following order:
+
+	``size``: What is the size of the mountain? In the picture above, the mountain has size 5 because there are 5 levels of squares, and the widest part of the mountain, at its bottom, is also 5 squares. A mountain will always be a square structure containing size×size elements, some of which are hashtags (#) and some of which are blanks.
+
+	``pattern``: We will use an integer in the range 1 to 4 to indicate which pattern your program should produce. In the picture above, pattern 1 is shown. The other patterns are explained below
+
+* Your program then prints the mountain of the specified size and pattern.
+
+1. Mario runs from left to right. Create a mountain that he would have to climb, as shown in the example for a size 5 mountain.
+
+::
+
+	    #
+	   ##
+	  ###
+	 ####
+	#####
+
+
+2. Create a mountain that he would descend, as shown below for a size 3 mountain.
+
+::
+
+	#  
+	## 
+	###
+
+
+3. Make a mountain that resembles pattern 1, but flipped upside-down. Below is shown a size 7 mountain for this pattern.
+
+::
+
+	#######
+	 ######
+	  #####
+	   ####
+	    ###
+	     ##
+	      #
+
+
+4. Make a mountain that resembles pattern 2, but flipped upside down. Below is shown a size 4 mountain for this pattern.
+
+::
+
+	#### 
+	###  
+	##   
+	#  
+
+
+Try running your Mario class and test yourself using various sizes (say, 1 to 10) and patterns (always an integer from 1 to 4).
+
+Note that this problem requires careful use of `whitespace <https://en.wikipedia.org/wiki/Whitespace_character>`_ which are the characters like tab, space, and newlines that don't show anything in the foreground color.  On a white background whitespace characters don't have a visible impact, but they do move the cursor to a new location. In particular:
+
+* Avoid extra spaces at the beginning of lines
+
+* Avoid using more ``ln`` s than needed.  For example, if the size is 5 there should be exactly 5 things that move to a new line (5 ``println`` s or 5 ``\n`` s or a mix of the two.)
+
+