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.
Related
I'm making a program where you put in two integers, and the program finds the greatest common divisor between the two numbers.
It runs fine, except it prints "1" as the GCD, even when the two numbers should have a different GCD. (Example: 4 & 64. GCD should be 4, but 1 still gets printed.) I can't figure out what's wrong with my code.
For those who want to answer using one method instead, I can't: It's an assignment that requires me to use two different methods in the same program. Please help?
Thanks for reading, and have a good week.
Here my code:
import java.util.Scanner;
public class greatestCommonDivisorMethod {
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
//Number entry prompts
System.out.print("Please enter first integer: ");
int num1 = input.nextInt();
System.out.print("Please enter second integer: ");
int num2 = input.nextInt();
//Result printed
System.out.println("The greatest common divisor of " +num1+ " and " +num2+ " is " +gcd(num1, num2)+".");
}
public static int gcd(int num1, int num2) {
int gcd = 1;
int k = 2;
while (num1 <= k && k <= num2)
{
if (num1 % k == 0 && num2 % k == 0)
gcd = k;
k++;
}
return gcd;
}
}
while (num1 <= k && k <= num2)
{
if (num1 % k == 0 && num2 % k == 0)
gcd = k;
k++;
}
It looks like you accidentally switched num1 and k in your while loop.
The while condition should probably have k<=num1 instead of num1<=k
Assign your return to a variable then print it
int answer = gcd(num1, num2);
then when printing cast to String or use toString method.
System.out.println("The greatest common divisor of " +answer.toString());
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));
}
}
}
I'm supposed to write a program for a Java Intro class that lists the prime numbers up to the number a user inputs. However, with the code I have, if the user inputs a prime number, my program won't list back that number, even though it's supposed to do so when it's prime. Could someone give me a hint as to why it's not working?
int userNum=kbd.nextInt();
if (userNum<2){
System.out.println("Not a valid number.");
System.exit(1);
}
System.out.println("The prime numbers up to your integer are:");
for (int num1 = 2; num1<userNum; num1++) {
boolean prime = true;
for (int num2 = 2; num2 < num1; num2++) {
if (num1 % num2 == 0) {
prime = false;
break;
}
}
// Prints the number if it's prime.
if (prime) {
System.out.print(num1 + " ");
}
}
For example, when I input "19," the program prints all prime numbers up to and including "17."
Thanks!
You need num1 to take the value userNum as the last value to check.
Therefore, you need to replace num1 < userNum with num1 <= userNum.
Your loop has a condition of num1 < userNum. This means that it allows all numbers below userNum. What you appear to want is all numbers below and including userNum, so you want num1 <= userNum.
The start of your loop would thus be this:
for (int num1 = 2; num1 <= userNum; num1++) {
Change this
num1<userNum
to
num1<=userNum
At the moment you stop before the two numbers are equal in your for loop.
Change the end condition of your for statement to num1<=userNum.
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.
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;
}
}