After re-reading the instructions for these sets of problems, I found that I should replace multiple statements of code used for one action with a method().
Additionally, the best practice is comment your preconditions and post conditions before every method in your program.
This practice helps in writing the code without getting off track.
It took a little while to learn that if I initialize an “Int” variable in the class before my methods, and if I use “Int” with the same variable again inside the method, then I am re-declaring the variable as a local variable, and the class variable will not retain it’s values throughout the different methods. If you want a variable’s values to be available to that variable throughout your methods, only declare the type one time in the class.

A few “firsts” for me in this app was 1. The use of the break; command to exit a loop. and 2. The use of if(){} else {if{}} and 3. Methods() to replace multiple statements.

So here is the much-cleaned up and easier to read/use (and working) solution to Problem 3:


/*
* File: FindRange.java
* Name: Jason Coltrin
* Section Leader: n/a
* --------------------
* This file is the starter file for the FindRange problem.
* write a ConsoleProgram that reads in a list of integers, one per line, until a sentinel value of 0
* is entered. When the sentinel is read, your program should display the smallest and largest values
* in the list.
* The program should handle the following special cases:
* • If the user enters only one value before the sentinel, the program should report
* that value as both the largest and smallest.
* • If the user enters the sentinel on the very first input line, then no values have been
* entered, and your program should display a message to that effect.
*/

}
}

And here is the output:

Here is my answer to the hailstone sequence problem. The problem is as follows:

Pick some positive integer and call it n.
If n is even, divide it by two.
If n is odd, multiply it by three and add one.
Continue this process until n is equal to one.

The numbers go up and down, but eventually—at least for all numbers that have ever been tried—comes down to end in 1. In some respects, this process is reminiscent of the formation of hailstones, which get carried upward by the winds over and over again before they finally descend to the ground. Because of this analogy, this sequence of numbers is usually called the Hailstone sequence, although it goes by many other names as well.


/*
* File: Hailstone.java
* Name: Jason Coltrin
* Section Leader: n/a
* --------------------
*This file is the starter file for the Hailstone problem.
*Pick some positive integer and call it n. If n is even,
*divide it by two. If n is odd, multiply it by three and
*add one. Continue this process until n is equal to one.
*/

println("You've reached the number 1, I'm stopping.");
println("The process took " + count + " steps to reach 1.");
}
}


This problem makes use of a while/if/else loop, and increment a counter. I thought I would have to use a For loop and a Boolean to increment the counter, but once I initialized the count variable at 0, it just took a little work to place the count++ in the correct location.

Here is what the output looks like:

Below is my answer for Problem 1, Assignment 2:

The question asks,
By using the Pythagorean Theorem, calculate the value of c, in relation to input provided by the user for the values of a, and b. Write a ConsoleProgram that accepts values for a and b as doubles (you can
assume that a and b will be positive) and then calculates the solution of c as a
double.

My solution is as follows:

/*
* File: PythagoreanTheorem.java
* Name: Jason Coltrin
* Section Leader: n/a
* -----------------------------
* This file is the starter file for the PythagoreanTheorem problem.
*/

// Prints the answer after "C ="
println("c = " + c);
}
}


The output looks like below:

A few for loop examples:

• General form: 

for (init; condition; step) {
statements
}


• init done once at start of the loop
• condition (can be a boolean) checked before every iteration through the loop – we execute the statements if they are true.
• step every time through loop after statements
• example:

for (int i = 0; i < 5; i++) { println(i); }

The result here of course would be the counting up to 5, starting at 0, and the output would be 0, 1, 2, 3, 4

• Another example of counting down:

for (int i = 6; i > 0; i -= 2) {

}


This will cause 2 to be subtracted from i with each pass through the loop and will not print out 0 because 0 is not > 0:

6

4

2

Here is an enhanced "for" loop in Java introduced in Java 5:

public class Test {

for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for (String name: names) {
System.out.print(name);
System.out.print(",");
}
}
}

Here your output will look like:
10,20,30,40,50,
James,Larry,Tom,Lacy

The "break" keyword will end the loop if a condition is met, for example:

for(int x : numbers ) {
if( x == 30 ) {
break;
}

As such the following output:
10,20

The continue keyword will continue the loop and for example, skipping thirty something like this:

if( x == 30 ) {
continue;
}

and the following output:
10,20,40,50

kudos to Stanford University & http://www.tutorialspoint.com/

I’ve been studying the free Standford CS106a lectures for some time now on YouTube – Playlist Here – and have been following along with the assignments. The first assignments revolve around manipulating a java-based robot application named Karel. Karel can only perform a limited amount of movements like move, turn left, pick beeper, and put beeper. The assignment I’ve been working on involves moving Karel around a number of different worlds and place beepers in a checker pattern. However, if trying to move through a wall, Karel can be blocked. Other errors like these pop up and make my life suck. During the programming of the checkerboard application, I utilized and became familiar with the following:

1. Program structure
2. Top-down programming/decomposition/subproblems
3. Conditional statements (if) (if/else)
4. Iterative Statements (for/while)
5. Method definition – private void name () { … }
6. Recursion – having a method call itself
7. Using import to include definitions from libraries

Programming with Java is all about primitives, camelcase, fence posts, and calling methods on objects! Programming is quite methodical and step-by-step in the first stages of an application. Thinking about what are my most simple, primitive moves and actions first, and then building on those is the start. Then once the most simple steps have been defined, I start to create methods that are more universal, and writing statements that are sub-methods of the top level methods. When programming top-down it’s fun because I am beginning to rely on the skills I’ve learned to trust that I can write later what I’d defined as a method.

Anyway, getting to where Karel ends in the video linked below has been a pretty mind-wracking endeavor. I’ve pretty much started over with the code three times but I can finally see the light at the end of the tunnel. One of the most difficult obstacles is writing the code so that it will run the same in all of the different “worlds” (8×8) (8×1) (1×8) etc. Also another thing about programming I’ve found is that by relying on my own skills and knowledge I have found I can arrive at a solution faster than searching online and there are many different ways of accomplishing the same task.

2013-07-13 16.09.29