Develop Reference

3 quick for-loop integer homework problems

Have some loops homework to do, and need some help! Here are the 3 questions:
Us the method below to take two integers and only output numbers divisible by ten. Make the list start with the largest of the numbers.
public static void divisibleByTen( int start, int end )
The above method is the example on the HW sheet. I have no idea how to implement it. I also don't know how to start with the largest number. Right now, I don't know how to take user input into the loop, so I made an example with 10 and 100:
public class QuestionOne {
public static void main(String [] args) {
for (int i = 10; i <= 100; i += 10){
System.out.println(i + "");
}
}
}
Use the method below to output the triangle below. Assume the positive number is between 3 and 9.
public static void printLeftUpper( int num)
Desired output is this number triangle:
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
Here's my code so far:
public class QuestionTwo {
public static void main(String [] args) {
for(int i = 5; i >= 1; i--) {
for(int j = 1; j <= i; ++j) {
System.out.print(j + " ");
}
System.out.println();
}
}
}
The third question I have ZERO idea how to start.
3. public static void sumEvens( int begin, int end )
Use the method above to take in two numbers, called begin and end, inclusive, checks if the numbers between them are even. Include the numbers in the sum if they are even as well, and print out the sum of all such numbers.
Example: sumEven(16, 11) uses 16+14+12 = 42, and outputs "For numbers between 16 and 11, the sum of all even numbers is 42."
The help is GREATLY appreciated. Thanks so much!!

Who likes homework? I've taken the liberty of doing Question 3, hope that helps!
import java.util.List;
import java.util.ArrayList;
public class OddEven {
public static void main(String[] args) {
sumEvens(0,1000);
}
// Gets sum of odd and even numbers between a given range:
public static void sumEvens(int begin, int end)
{
List<Integer> evenNumbers = new ArrayList<Integer>();
List<Integer> oddNumbers = new ArrayList<Integer>();
if (begin < end)
{
for (int i = begin; i <= end; i++)
{
// Number is even:
if (i % 2 == 0)
{
evenNumbers.add(i);
}
// Number is odd:
else
{
oddNumbers.add(i);
}
}
}
else
{
for (int i = begin; i >= end; i--)
{
// Number is even:
if (i % 2 == 0)
{
evenNumbers.add(i);
}
// Number is odd:
else
{
oddNumbers.add(i);
}
}
}
// Calculate even values:
int evenSum = 0;
for (int i: evenNumbers) {
evenSum += i;
}
System.out.println("The sum of all even numbers is: " + evenSum);
// Calculate odd values:
int oddSum = 0;
for (int i: oddNumbers) {
oddSum += i;
}
System.out.println("The sum of all odd numbers is: " + oddSum);
}
}

public class QuestionOne {
public static void main(String [] args) {
divisibleByTen( 1, 100 );
}
public static void divisibleByTen( int start, int end ){
// reversal big to small (100 to 1)
for(int i = end; i >= start; i--){
// use mod (%) to check if i is divisible by 10
if( i%10 == 0 ){
// it is then output
System.out.println(i);
}
}
}
}
Question 2 is correct.
Question 3
public static void main(String [] args) {
sumEvens( 16, 10);
}
public static void sumEvens( int begin, int end ){
int start = 0;
int last = end;
int sum = 0;
if(begin > end){
start = end;
end = begin;
}else{
start = begin;
}
for(int i = start; i <= end; i++){
// get even integers
if(i%2 == 0){
sum += i;
}
}
System.out.println("For numbers between " +begin+ " and " +last+ ", the sum of all even numbers is " +sum);
}

Blue J shows it is running, but will not open result window

I have been running a program that simulates the number of steps it will take to get across a 7-step bridge. A random number is generated to determine if the person takes a step forwards or backwards. This simulation is run 1000 times. After this the average number of steps it takes to get across is out printed, as well as the maximum number of steps it took.
This, in turn is run 1000 times. It compiles fine. My issue is that when I go to run it, (on BlueJ) the bar shows that it is running but the output window fails to appear. What is happening? (Most likely is something stupidly obvious that I am oblivious to.)
import java.util.Random;
public class Prog214a
{
public static void main (String[] args)
{
Random rn = new Random();
for (int m = 1; m <= 20; m++)
{
int max = 0;
for (int c = 1; c <= 1000; c++)
{
int s = 0;
int sn = 0;
int sum = 0;
while (s < 7)
{
int ans = rn.nextInt(1) + 0;
if (ans == 1) {
s = s + 1
}
else {
s = s - 1;
}
sn++;
}
sum = sum + sn;
if (sn > max) {
max = sn;
}
if (c == 1000) {
double avg = sum / c;
System.out.print(avg);
System.out.print(" " + max);
}
}
}
}
}

There is at least one problem. Here:
int ans = rn.nextInt(1) + 0;
if (ans == 1){
s = s + 1;
}
else {
s = s -1;
}
rn.nextInt(1) can only return 0, so ans will be 0. You have no guard to ensure that s does not go negative, so it does - and it remains less than 7, meaning that the while loop (with condition s < 7) goes on for a long time (specifically, until s wraps back to a positive number again).

Collatz Conjecture Recursion Error

I've lurked around for years, but today I have a question concerning my code. I am currently trying to create a collatz program that puts the number of steps for a certain number in an array, but at the same time puts the number of steps for every single number it passes through. Here's my code:
public class GenerousRecursion {
public static short steps;
public static int length;
public static short[] array = new short[101];
public static void main(String[] args) {
length = 100;
for (int count = 2; count < length + 1; count++){
steps = 0;
System.out.println(count + ": " + findCollatz(count));
}
}
public static short findCollatz(int number) {
if (number < length){
if (array[number] > 0) {
steps = array[number]++; return steps;
}
else if(number % 2 == 0) {
array[number] = findCollatz(number / 2);
steps ++;
return steps;
}
else {
array[number] = findCollatz(3 * number + 1);
steps ++;
return steps;
}
}
else {
if(number % 2 == 0) {
findCollatz(number / 2);
steps ++;
return steps;
}
else {
findCollatz(3 * number + 1);
steps ++;
return steps;
}
}
}
}
Here's a great video on the Collatz Conjecture: Numberphile
So here is the error being thrown (reduced), but I don't understand, because I am not anywhere near the bounds of any int or short:
Exception in thread "main" java.lang.StackOverflowError
at GenerousRecursion.findCollatz(GenerousRecursion.java:22)
at GenerousRecursion.findCollatz(GenerousRecursion.java:33)
at GenerousRecursion.findCollatz(GenerousRecursion.java:27)
I just listed these first three lines because these same three lines draw errors for hundreds of lines.
Whats the problem and how do I fix it? Thanks abunch!
Edit: When I ran the debugger, my program continously throws exceptions whenever the array is refrenced.

As stated in the video-clip continuing with 1 will end in an endless loop.
Try the following.
static int[] collatzCounts = new int[100];
static final int NO_COUNT = -1;
static {
Arrays.fill(collatzCounts, NO_COUNT);
collatzCounts{1] = 0; // Define collatz(1) = 0 (1, 4, 2, 1, ...)
}
public static void main(String[] args) {
for (int n = 2; n < 120; n++) {
int steps = countCollatz(n);
System.out.println(n + ": " + steps);
}
}
public static int countCollatz(int n) {
IntFunction f = k ->
k % 2 == 0
? 1 + countCollatz(k / 2)
: 1 + countCollatz(3 * k + 1);
//: 2 + countCollatz((3 * k + 1) / 2);
//if (n == 1) {
// return 0;
//}
if (n < collatzCounts.length) {
if (collatzCounts[n] == NO_COUNT) {
collatzCounts[n] = f.apply(n);
}
return collatzCounts[n];
} else {
return f.apply(n);
}
}
countCollatz simply counts the steps needed - to reach 1 actually. Though till further proof there might be a cycle of higher numbers.
I have used a Java 8 lambda expression, the IntFunction f, as it is more natural to repeat the calculation, once to fill the array, once for too large numberss.

Next Prime number Java only working with certain numbers

This function its only working for certain numbers, but for 15, or 5 it does not give me correct next prime.
public static int nextPrime(int n) {
boolean isPrime = false;
int m = (int) Math.ceil(Math.sqrt(n));
int start = 3;
if (n % 2 == 0) {
n = n + 1;
}
while (!isPrime) {
isPrime = true;
for (int i = start; i <= m; i = i + 2) {
if (n % i == 0) {
isPrime = false;
break;
}
}
if (!isPrime) {
n = n + 2;
}
}
return n;
}

You don't need to go upto sqrt(n), you need to go upto sqrt(number) that you are evaluating
for example consider you pass n = 5
it will start loop from 3 and it will end the loop at 4 that is not what you need to find next prime number
outer loop
start from n + 1 until you find prime
inner loop
you should start from 3 and sqrt(numberUnderIteration)

You're setting your boundary at the square root of the original number only. In order for you to check if every next number works, you need to recalculate the boundary whenever the n value is changed. So, put int m = (int) Math.ceil(Math.sqrt(n)); inside of your while loop.
You also need to increment n by 1 before you start any calculations, or it will accept n itself as a prime number if it is one. For example, nextPrime(5) would return 5 because it passes the conditions.
And finally, you don't need to increment n by 2 at the end of your while loop because if you are on an even number, it will break out (keep adding 2 to an even number will always be even). I've commented the part of your code that I changed:
public static int nextPrime(int n) {
boolean isPrime = false;
int start = 2; // start at 2 and omit your if statement
while (!isPrime) {
// always incrememnt n at the beginning to check a new number
n += 1;
// redefine max boundary here
int m = (int) Math.ceil(Math.sqrt(n));
isPrime = true;
// increment i by 1, not 2 (you're skipping numbers...)
for (int i = start; i <= m; i++) {
if (n % i == 0) {
isPrime = false;
break;
}
}
// you don't need your "if (!isPrime)..." because you always increment
}
return n;
}
public static void main(String[] args) {
System.out.println(nextPrime(15)); // 17
System.out.println(nextPrime(5)); // 7
System.out.println(nextPrime(8)); // 11
}

You need to compute m inside the for loop.
while (!isPrime) {
isPrime = true;
int m = (int) Math.ceil(Math.sqrt(n));
// do other stuff

Your code works fine except when a prime number is given as input, your method returns input itself.
Example if 5 is your input nextPrime(5) returns 5. If you want 7 (next prime number after 5) to be returned in this case.
Just add n=n+1; at the start of your method. Hope this helps

Just for fun, I coded a quick Prime class that tracks known primes, giving a huge performance boost to finding multiple large primes.
import java.util.ArrayList;
public class Primes {
private static ArrayList<Integer> primes = new ArrayList<Integer>();
public static int nextPrime(int number){
//start it off with the basic primes
if(primes.size() == 0){
primes.add(2);
primes.add(3);
primes.add(5);
primes.add(7);
}
int idx = primes.size()-1;
int last = primes.get(idx);
//check if we already have the prime we are looking for
if(last > number){
//go to the correct prime and return it
boolean high = false;
boolean low = false;
int prevIdx = 0;
int spread = 0;
//keep finagling the index until we're not high or low
while((high = primes.get(idx-1) > number) || (low = primes.get(idx) <= number)){
spread = Math.abs(prevIdx-idx);
//because we always need to move by at least 1 or we will get stuck
spread = spread < 2 ? 2: spread;
prevIdx = idx;
if(high){
idx -= spread/2;
} else if(low){
idx += spread/2;
}
};
return primes.get(idx);
}
/*FIND OUR NEXT SERIES OF PRIMES*/
//just in case 'number' was prime
number++;
int newPrime = last;
//just keep adding primes until we find the right one
while((last = primes.get(primes.size()-1)) < number){
//here we find the next number
newPrime += 2;
//start with the assumption that we have a prime, then try to disprove that
boolean isPrime = true;
idx = 0;
int comparisonPrime;
int sqrt = (int) Math.sqrt(newPrime);
//make sure we haven't gone over the square root limit- also use post-increment so that we use the idx 0
while((comparisonPrime = primes.get(idx++)) <= sqrt){
if(newPrime % comparisonPrime == 0){
isPrime = false;
}
}
if(isPrime){
primes.add(newPrime);
}
}
return last;
}
}
And here is the test:
public class Test {
public static void main(String[] args){
long start;
long end;
int prime;
int number;
number = 1000000;
start = System.currentTimeMillis();
prime = Primes.nextPrime(number);
end = System.currentTimeMillis();
System.out.println("Prime after "+number+" is "+prime+". Took "+(end-start)+" milliseconds.");
number = 500;
start = System.currentTimeMillis();
prime = Primes.nextPrime(number);
end = System.currentTimeMillis();
System.out.println("Prime after "+number+" is "+prime+". Took "+(end-start)+" milliseconds.");
number = 1100000;
start = System.currentTimeMillis();
prime = Primes.nextPrime(number);
end = System.currentTimeMillis();
System.out.println("Prime after "+number+" is "+prime+". Took "+(end-start)+" milliseconds.");
}
}
This results in the following output:
Prime after 1000000 is 1000003. Took 384 milliseconds.
Prime after 500 is 503. Took 10 milliseconds.
Prime after 1100000 is 1100009. Took 65 milliseconds.
As you can see, this takes a long time the first iteration, but we only have to perform that operation once. After that, our time is cut down to almost nothing for primes less than our first number (since it's just a lookup), and it is very fast for primes that are just a bit bigger than our first one (since we have already done most of the work).
EDIT: Updated search for existing primes using a variation on a Binary Search Algorithm. It cut the search time at least in half.

import java.util.Scanner;
class Testing
{
public static void main(String Ar[])
{
int a = 0, i, j;
Scanner in = new Scanner(System.in);
a = in.nextInt();
for (j = a + 1;; j++)
{
for (i = 2; i < j; i++)
{
if (j % i == 0)
break;
}
if (i == j)
{
System.out.println(j);
break;
}
}
}
}

Here is the perfect code for finding next prime for a given number.
public class NextPrime
{
int nextPrime(int x)
{
int num=x,j;
for( j=num+1;;j++)
{
int count=0;
for(int i=1;i<=j;i++)
{
if(j%i==0)
{
count++;
//System.out.println("entered");
}
//System.out.println(count);
}
if(count==2)
{
System.out.println(" next prime is ");
break;
}
}return j;
}
public static void main(String args[])
{
NextPrime np = new NextPrime();
int nxtprm = np.nextPrime(9);
System.out.println(nxtprm);
}
}

//I hope the following code works exactly.
import java.util.Scanner;
public class NextPrime {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a positive integer number : ");
int n = scanner.nextInt();
for (int x = n + 1;; x++) {
boolean isPrime = true;
for (int i = 2; i < x / 2; i++) {
if (x % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
System.out.println("Next prime is : " + x);
break;
}
}
}
}

Linear search returning not found when it should be returning subscript number

I'm working on a homework assignment for Java, where a program is supposed to read in 10 numbers from the user, then ask for a number to search. It sorts the numbers (ascending) and performs a linear search on the array, then should either return the subscript it was found at or a message saying not found.
My code is giving me the "not found" response even when the subscript should be returned. Can you take a look at my code? I've tried altering my if statement and it didn't help. I've used the book examples of the search and sort methods as closely as I could (feel free to point out errors).
Here is the code.
package program11;
import java.util.Scanner;
public class ArraySearch {
public static void main(String[] args) {
double[] arrayBuild = new double[10];
Scanner input = new Scanner(System.in);
for (int i = 0; i < arrayBuild.length; i++) {
System.out.print("Enter a number.");
arrayBuild[i] = input.nextDouble();
}
System.out.print("Enter a number to search for ");
int objective = input.nextInt();
linearCheck(arrayBuild, objective);
if ((objective >= 0) && (objective < arrayBuild.length)) {
System.out.println("Found at index: " + objective);
} else {
System.out.println("Not Found");
}
}
public static void arraySort(double[] arrayBuild) {
for (int i = 1; i < arrayBuild.length; i++) {
double currentPoint = arrayBuild[i];
int r;
for (r = i - 1; r >= 0 && arrayBuild[r] > currentPoint; r--) {
arrayBuild[r + 1] = arrayBuild[r];
}
arrayBuild[r + 1] = currentPoint;
}
}
public static double linearCheck(double[] arrayBuild, int objective) {
for (int i = 0; i < arrayBuild.length; i++) {
if (objective == arrayBuild[i])
return i;
}
return -1;
}
}
EDIT- new code. It's all complete now, except when I enter a number that is not in the array I get a negative result. For example, entering 10 8 7 6 5 3 5 3 5 3 5 6 and searching for 11 gives me the result of -1 for the linear search and -11 for the binary search. I took your advice as well as I could. What am I missing now?
package program11;
import java.util.Scanner;
import javax.swing.JOptionPane;
public class ArraySearch {
public static void main(String[] args) {
double[] arrayBuild = new double[10];
Scanner input = new Scanner(System.in);
int reply = 2;
for (int i = 0; i < arrayBuild.length; i++) {
System.out.print("Enter a number.");
arrayBuild[i] = input.nextDouble();
}
while (reply != 1) {
System.out.print("Enter a number to search for ");
double objective = input.nextDouble();
arraySort(arrayBuild);
double linearResult = linearCheck(arrayBuild, objective);
if (objective >= 0) {
System.out.println("Linear search found at index: " + linearResult);
}
else {
System.out.println("Not Found (linear)");
}
double binaryResult = binaryCheck(arrayBuild, objective);
if (objective >= 0) {
System.out.println("Binary search found at index: " + binaryResult);
}
else {
System.out.println("Not Found (binary)");
}
reply = JOptionPane.showConfirmDialog(null, "Continue?");
}
}
public static void arraySort(double[] arrayBuild) {
for (int i = 1; i < arrayBuild.length; i++) {
double currentPoint = arrayBuild[i];
int r;
for (r = i - 1; r >= 0 && arrayBuild[r] > currentPoint; r--) {
arrayBuild[r + 1] = arrayBuild[r];
}
arrayBuild[r + 1] = currentPoint;
}
}
public static double linearCheck(double[] arrayBuild, double objective) {
for (int i = 0; i < arrayBuild.length; i++) {
if (objective == arrayBuild[i])
return i;
}
return -1;
}
public static double binaryCheck(double[] arrayBuild, double objective) {
int low = 0;
int high = arrayBuild.length - 1;
while (high >= low) {
int mid = (low + high) / 2;
if (objective < arrayBuild[mid])
high = mid - 1;
else if (objective == arrayBuild[mid])
return mid;
else
low = mid + 1;
}
return -low - 1;
}
}

I'm not sure exactly sure what is causing your problems, but I see a few issues with your code
If you want to be searching for Ints then I would also make arrayBuild of type int as well. Or you could search for doubles by changing the type of objective to double and getting the user to input a double
When you call linearCheck you are not storing the result anywhere, you should assign it to a variable
double foundLocation = linearCheck(arrayBuild, objective);
Your if statement doesn't make much sense, you ought to be using the returned value of linearCheck as follows
if (foundLocation >= 0) {
System.out.println("Found at index: " + foundLocation);
} else {
System.out.println("Not Found");
}
You are not calling arraySort anywhere in your main

You are never saving the value of your search. Your objective isn't the same as your result. Here's the code change I would make:
int result = linearCheck(arrayBuild, objective);
if ((result >= 0) && (result < arrayBuild.length)) {
System.out.println("Found at index: " + result);
} else {
System.out.println("Not Found");
}
This change requires you to make an int returned for your linear check routine.
this is in addition to make objective a double and not an integer.