I'm new to java, and i'm trying to make a array who's size is user defined. I'm staring off by filling in the entire array with zeros and moving from there. How should I go about doing that? What I have right now is something similar to: (input being my scanner object)
int num1, num2, num3 = 0, num4 = 0, active = 0;
num1 = input.nextInt();
num2 = input.nextInt();
int[][] ver = new int[num1][num2];
while(active == 0){
ver [num3][num4] = 0;
++num4;
if(num4 > num2){
++num3;
num4 = 0;
}
if(num3 > num1){
++active
}
}
This keeps giving me an ArrayIndexOutOfBoundsException:0, making me think ver[0][0] doesn't exist. Thanks in advance.
You are not checking num3 and num4 properly (they both are allowed to reach the upper bound) so they will eventually go out of bounds.
Since you're just trying to fill your array with zeros why don't you consider the following code:
import java.util.Arrays;
// ...
int num1 = 2; // fixed number just for test purposes
int num2 = 2; // fixed number just for test purposes
int[][] ver = new int[num1][num2];
for (int[] row: ver)
Arrays.fill(row, 0);
System.out.println(ver[0][0]); // prints 0 as expected
Since every subarray (row in the example) is an array the above code will loop through them filling them with zeros, taking advantage of the fill method of the Arrays class, which you need to import as shown in the example.
There is no checking for the values of num3 and num4 in your code. Add proper restrictions as I envisage, you don't what them to be greater thatn num1 and num2 respectively.
If the value of num3 or num4 goes beyond the limit you get the ArrayIndexOutOfBoundException.
This fails when num4 == num2 as you are checking num4 > num2; because num2 is the length of the array while index goes to length-1. Same goes with num3 and num1 comparison. Use num2-1 and num1-1 in the comparison as below:
int num1=0, num2=0, num3=0,num4=0;
num1 = input.nextInt(); //<--Input a value >0
num2 = input.nextInt(); //<--Input a value >0
int[][] ver = new int[num1][num2];
int active = 0;
while(active == 0){
ver[num3][num4] = 0;
++num4;
if(num4 > num2-1){ // or if(num4 >= num2)
++num3;
num4 = 0;
}
if(num3 > num1-1){ // or if(num3 >= num1)
++active;
}
}
Related
This is my code, it is a russian peasant multiplication algorithm. I find the time and space complexity very confusing so I needed some help.
This is also for java language
Thank you.
int num1 = Integer.parseInt(jTextField1.getText());
int num2 = Integer.parseInt(jTextField2.getText());
int res=0;
// While second number doesn't become 1
while (num2 > 0)
{
// If second number becomes odd,
// add the first number to result
if ((num2 & 1) != 0)
res = res + num1;
// Double the first number
// and halve the second number
num1 = num1 << 1;
num2 = num2 >> 1;
}
jTextField3.setText(String.valueOf(res));
}
The loop continues to execute provided that num2 be greater than zero. After each iteration of the loop, num2 is halved. This means that the loop will execute log_2(num2) times. So, assuming num2 be represented by N, we can say that the complexity of this loop is log_2(N).
This question already has answers here:
How do I generate random integers within a specific range in Java?
(72 answers)
Closed 6 years ago.
I'm making a game where the user must solve a simple subtraction but the result must be a positive whole number. I managed to do everything but for some reason the answer is sometimes negative and I'm not sure how to fix it
import java.util.Random;
import java.util.Scanner;
public class Subtraction {
public static void main(String[] args) {
Random r = new Random();
final int MAX = 10;
// get two random numbers between 1 and MAX
int num1 = r.nextInt(MAX) - 1;
int num2 = r.nextInt(MAX) - 1;
int total = (num1 - num2);
// display a question
System.out.printf("What is your answer to %d - %d = ?%n", num1, num2);
// read in the result
Scanner stdin = new Scanner(System.in);
int ans = stdin.nextInt();
stdin.nextLine();
// give an reply
if (ans == total) {
System.out.println("You are correct!");
} else {
System.out.println("Sorry, wrong answer!");
System.out.printf("The answer is %d + %d = %d%n", num1, num2, (num1 - num2));
}
}
}
Two possible solutions: Just change your total line with a condition to subtract the larger one from the smaller one (unless they're the same, in which case you'll get 0)
int total = (num1 > num2) ? (num1 - num2) : (num2 - num1);
Or just use the absolute value:
int total = java.lang.Math.abs(num1 - num2);
Change the printf as well:
System.out.printf("What is your answer to %d - %d = ?%n", (num1 > num2) ? num1 : num2, (num1 > num2) ? num2 : num1);
The conditionals are just making sure that the bigger number comes before the smaller number, or if they happen to be equal, that they are both listed.
Check out http://www.cafeaulait.org/course/week2/43.html for a more thorough explanation of the ? operator.
Generate your first value with room at the bottom for a second value to be subtracted, and the second one from a range bounded by the first:
int num1 = r.nextInt(MAX - 1) + 2; // produces values from 2 to MAX, inclusive
int num2 = r.nextInt(num1 - 1) + 1; // produces values from 1 to (num1 - 1), inclusive
The first number will always be strictly larger than the second, by construction, so the difference will always be a positive integer.
Well, with two random numbers in the same range, in random order, either cold be larger and the subtraction could be negative. Either fix how you get the numbers, or fix how they are ordered, or fix how you get their difference; any of these will do the job.
The code at the very heart of your program is wrong:
// get two random numbers between 1 and MAX
int num1 = r.nextInt(MAX) - 1;
int num2 = r.nextInt(MAX) - 1;
r.nextInt(MAX) returns a number between 0 (inclusive) and MAX (exclusive). Your code subtracts one from it, so you get a number in the range [−1, MAX−2].
Since you want it to be a simple subtraction where all numbers are in the range [1, MAX], you have to generate them that way. The general form of the subtraction is:
result = num1 − num2
This equation has the following constraints:
1 <= result <= MAX
1 <= num1 <= MAX
1 <= num2 <= MAX
result < MAX, since otherwise num2 would have to be 0
1 < num1, since otherwise the result would become negative
num2 < MAX, since otherwise result would have to be larger than MAX
This leaves the following allowed ranges:
1 <= result <= MAX − 1
2 <= num1 <= MAX
1 <= num2 <= MAX − 1
num2 <= num1 - 1
To generate these numbers, the code has to look like this:
int num1 = randomBetween(2, MAX);
int maxNum2 = Math.min(MAX - 1, num1 - 1);
int num2 = randomBetween(1, maxNum2);
Now what is randomBetween? You have to define it:
randomBetween(min, max) ≡ r.nextInt(max + 1 - min) + min
Together, this is:
int num1 = r.nextInt(MAX + 1 - 2) + 2;
int maxNum2 = Math.min(MAX - 1, num1 - 1);
int num2 = r.nextInt(maxNum2 + 1 - 1) + 1;
int result = num1 - num2;
assert 1 <= result && result <= MAX;
Since you know the result must be positive, I would start with the result
int total = r.nextInt(MAX) + 1;
int num2 = r.nextInt(MAX - total + 1);
int num1 = total + num2;
This way you can be sure that num1 - num2 will always be positive.
package optinalTest;
import java.util.Scanner;
import java.util.concurrent.ThreadLocalRandom;
public class Subtraction {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
randomNumber();
}
}
private static void randomNumber() {
// get two random numbers between 1 and MAX
int num1 = ThreadLocalRandom.current().nextInt(10000, 9999998);
int num2 = ThreadLocalRandom.current().nextInt(num1 + 1, 9999999);
int total = (num2 - num1);
// display a question
System.out.printf("What is your answer to %d - %d = ?%n", num2, num1);
// read in the result
Scanner stdin = new Scanner(System.in);
int ans = stdin.nextInt();
stdin.nextLine();
// give an reply
if (ans == total) {
System.out.println("You are correct!");
} else {
System.out.println("Sorry, wrong answer!");
System.out.printf("The answer is %d - %d = %d%n", num2, num1, (num2 - num1));
}
}
}
Is there a way to determine if a number is within a range of two specific numbers, if those numbers are changing? For example:
int num1 = -10;
int num2 = 100;
int num3 = 5;
if(num3 > num 1 && num3 < num2){
}
It would be rather easy to determine whether num3 is in between num1 and num2. However, lets say num1 and num2 change dynamically during the running of the program:
num2 becomes -30
All else remains the same. Now the same algorithm as before would no longer work. Is there an elegant way to check if a number is withing a range using dynamically changing max and min values?
You can try the following, i create 2 more variable iMin & iMax, and before checking num3 is in rank, we define max value and min value:
int num1 = -10;
int num2 = 100;
int num3 = 5;
if (num3 > Math.min(num1, num2) && num3 < Math.max(num1, num2)) {
}
That's kinda silly. If you have an algorithm in a function and you say you want num3 to be between num1 and num2, that's it. That rule shouldn't change, because num1 or num2 changed. The implementation should be generic and independent of the values.
If you need some verification prior to that, do it. I don't a see any other elegant way to do it.
The question is to Write a program that sorts three integers. The integers are entered from the input dialogs and stored in variables num1, num2, and num3, respectively. The program sorts the numbers so that num1 <= num2 <= num3.
actually I do that but the result is available only to 1 ,2 and 3 numbers !
When I enter any different number it doesn't show me the result I want it !
here is my code..
import javax.swing.JOptionPane;
public class number order {
public static void main(String[] args) {
int num1;
int num2;
int num3;
String n = JOptionPane.showInputDialog(null, "input NUM 1 " );
num1 = Integer.parseInt(n);
String u = JOptionPane.showInputDialog(null, "input NUM 2 " );
num2 = Integer.parseInt(u);
String m = JOptionPane.showInputDialog(null, "input NUM 3 " );
num3 = Integer.parseInt(m);
if (num1<=num2&& num2<=num3)
System.out.println( num1+"<="+ num2+"<="+num3 );
if(num2<=num1&&num1<=num3)
System.out.println(num2+"<="+num1+"<="+num3);
if (num3<=num1&&num1<=num2)
System.out.println(num3+"<="+num1+"<="+num2);
// TODO code application logic here
}
}
The problem is that you check only three out of six possible arrangements of those three numbers. Also note that, even for those three, you are not actually sorting the numbers, but only printing them in sorted order, i.e., you are never reassigning the variables num1, num2, and num3.
Just as an alternative to checking all the possible arrangements of the three numbers or implementing a full sorting algorithm, you can also compare and swap pairs of numbers. This way, you get away with far fewer comparisons while still being able to sort all permutations of three numbers.
if num1 > num2, swap num1 and num2
if num2 > num3, swap num2 and num3
if num1 > num2, swap num1 and num2 again
After those three swaps, the numbers are in sorted order.
Of course, if you have more than three numbers this gets impractical, and you should rather implement a full sorting algorithm (for exercise) or go with one of the builtins, like Arrays.sort (for real life).
You haven't checked all cases:
1 < 2 < 3
1 < 3 < 2
2 < 1 < 3
2 < 3 < 1
3 < 1 < 2
3 < 2 < 1
However to check all case like that is not to useful.
an sorted array would be more easy:
int arr[3]={num1,num2,num3}
java.utils.Arrays.sort(arr);
println(arr[0] + "<=" + arr[1] + "<=" + arr[2]);
int[] all = new int[]();
num1 = Integer.parseInt(n);
all[0] = num1;
num2 = Integer.parseInt(u);
all[1] = num1;
num3 = Integer.parseInt(m);
all[2] = num1;
for(int i=0; i <all.length ;i++){
if(i!=0 && all[i]< all[i-1]){
temp = all[i-1];
all[i-1] = all[i];
all[i] = temp;
}
}
all will have sorted array
or more simply
2 steps
1)add all to a array.
2) call Arrays.sort(array)
how about
int min = min(min(num1,num2),num3);
int max = max(max(num1,num2),num3);
int mid = num1 + num2 + num3 - min - max;
System.out.println(min+"<="+mid+"<="+max);
if(num1 < num2){ if(num3 < num1) System.out.println("num2 > num1 > num3");}
else{ if(num2 < num3) System.out.println("num3 > num2 > num1"); else System.out.println("num1 > num2 > num3");}
Sort in descending order.
Hope it helps.
In this program if I enter 10 when it says enter a value what would be the output? num1 becomes 10, while num2 is 6, I don't understand what num1 = num1 mean? 10 = 10 + 2 = 12?
I think I understood it, it takes 10 from the user, num1 is then assigned the value of num1 + 2, which is 12. num2 then becomes num1, 12 then 12/6 = 2.
Output: 2
import java.util.*;
public class Calculate
{
public static void main (String[] args)
{
Scanner sc = new Scanner(system.in);
int num1, num2;
num2 = 6;
System.out.print("Enter value");
num1 = sc.nextInt();
num1 = num1 + 2;
num2 = num1 / num2;
System.out.println("result = " + num2);
}
}
It assigns the value of num1 + 2 back to num1.
So yes, if num1 = 10, the value 12 will be stored in num1.
Then that will be divided by 6, leaving 2.
Also, it never says num1 = num1, you can't isolate parts of a statement like that--the statement, an assignment, is num1 = num1 + 2.
What you have to understand is that num1 does not become a fixed number (eg 10) it remains a variable. And by definition a variable varies.
when you say x = 10 and then x = x+1, what really happens is something like this: y = x + 1 and then x = y
int num1, num2;
num2 = 6; // Now num2 has value 6
System.out.print(Enter value");
num1 = sc.nextInt(); // Now num1 has value 10, which you just entered
num1 = num1 +2; // num1 is being assigned the value 10 + 2, so num1 becomes 12
num2 = num1/num2; // Now num1 = 12 and num2 = 6; 12/6 = 2
System.out.println("result = "+num2);
You should get an output of 2; see above comments...
public class Calculate {
public static void main (String[] args) {
Scanner sc = new Scanner(system.in); // Whatever you read from System.in goes into the "sc" variable.
int num1, num2; // num1 = 0. num2 = 0.
num2 = 6; // num2 = 6.
System.out.print(Enter value");
num1 = sc.nextInt(); // Read in the next integer input and store it in num1.
num1 = num1 +2; // num1 gets 2 added to it and stored back in num1.
num2 = num1/num2; // num1 gets divided by num2 and the (integer) result is stored in num2.
System.out.println("result = "+num2); // Print out the result which is stored in num2.
}
}
In Java, the equal sign = is an assignment operator. It evaluates the expression on the right and assigns the resulting value to the variable on the left. So if num1 had the value 10 before the statement num1 = num1 + 2;, then after that statement it would have the value 12.
num1 = sc.nextInt();
num1 = num1 +2;
num2 = num1/num2;
In these statements, = is the assignment operator, not the equality operator. When you read it, don't say "equals", but rather "is assigned the value of":
num1 is assigned the value of sc.nextInt().
So, num1 is now 10.
num1 is assigned the value of num1 + 2
So, num1 is now 12
num2 is assigned the value of num1 / num2, or
num2 is assigned the value of 12 / 6
So, num2 is now 2.
It takes number input from user.
Adds 2 to the number that user entered.
Divides this value with 6 and add result to the num2 variable.
Prints "result = some number" to the user.
num1 = num1 +2;
means you are adding 2 to your num1. This can be represented as
num1 += 2; //which means the same as above
The outcome of your program will be determined by the integer division you are doing:
num2 = num1/num2;