Develop Reference

why i cannot search for my random generate value?

So far i can generate random 20 number that i want...but when i want to Search for my random 20 number ...it alwayS Show "the number you enter cannot found " why ???how do i Search the value from the number i generated ? would be happy if Someone can teach me how to do .
package labtask.pkg5;
import java.util.Scanner;
import java.util.Random;
public class Labtask5 {
/**
* #param args the command line arguments
*/
public static void main(String[] args) {
int search = 1;
int[] array = new int[20];
Scanner read = new Scanner(System.in);
Random r = new Random(); //generate random number
for (int x = 0; x < 20; x++) {
System.out.println(r.nextInt(100));
}
while (search != 0) //Search for a number
{
System.out.println("Search a number");
search = read.nextInt();
if (SearchValue(search, array) == true) {
System.out.println("The number you enter been found");
} else {
System.out.println("The number you enter did not found");
}
}
}
public static boolean SearchValue(int search, int[] array) {
for (int y = 0; y < 20; y++) {
if (search == array[y]) {
return true;
} else {
return false;
}
}
return true;
}
}

Your first problem is with this function:
public static boolean SearchValue(int search, int[] array) {
for (int y = 0; y < 20; y++) {
if (search == array[y]) {
return true;
} else {
return false;
}
}
return true;
}
You will always return either true or false on the first iteration of the loop and you will never get past y = 0.
Additionally, you do not need to hardcode the value 20. The array is aware of its own size.
I would expect this to look like:
public static boolean SearchValue(int search, int[] array) {
for (int y = 0; y < array.length; y++) {
if (search == array[y]) {
return true;
}
}
return false;
}

1 things:
you are printing 20 random numbers only, but not assigning it into the array:
for (int x = 0; x<20; x++){
System.out.println(r.nextInt(100));
}
do instead:
for (int x = 0;x<20;x++) {
array[x] = r.nextInt(100);
System.out.println(array[x]);
}
on the other hand, the method:
SearchValue(int search, int[] array)
is returning some boolean immediantly after checking the 1st element in the array, you need to BROWSE the whole array instead...
do instead something like:
public static boolean SearchValue(int search, int[] array) {
for (int y = 0; y < 20; y++) {
if (search == array[y]) {
return true;
}
}
return false;
}

Sequential search algorithm

Hello guys, i'm having trouble with creating a sequential
search algorithm for a two dimensional int array. not sure exactly how to go about augmenting the while loop so it works , the example i'm using does it exactly how i wrote it out, as you can see my compiler is complaining about the incompatibility with the way its written out!
import java.util.*;
import javax.swing.*;
public class pencilneck
{
public static void main(String []alex)
{
int ROWS = 6;
int COLS = 3;
int[][] chargeAcc = new int[ROWS][COLS];
Scanner keyboard = new Scanner(System.in);
for(int row = 0; row < ROWS; row++)
{
for(int col = 0; col < COLS; col++)
{
System.out.print("Enter Account");
chargeAcc[row][col] = keyboard.nextInt();
}
}
System.out.print("Enter an account to be Charged");
int input = keyboard.nextInt();
int results = SequentialSearch(chargeAcc,input);
if(results ==-1)
{
System.out.println("that is an invalid #");
}
else
{
System.out.println("the # is valid");
}
}
public static int SequentialSearch(int[][] array, int value)
{
int index1 = 0;
int element = -1;
boolean found = false;
while(!found && index1 == value)
{
if(array[index] == value)
{
found = true;
element = index;
}
index++;
}
return element;
}
}

Your question doesn't quite make sense, but the bug in your code is easy enough to find.
while(!found && index1 == value)
This says in plain english, do the stuff in the loop while these conditions are both true:
Found is false
index (index of array) is equal to value (number you want to find in array)
At the start of the loop, index == 0. Since value is likely nonzero, the second condition is false and the loop never runs, causing SequentialSearch to return -1 immediately.
Now that you know what the problem is, I'll leave it to you to take time to understand what you did wrong and figure out how to fix it.

Array[index] is not an int, is an array.
i think what you are looking for is something like this:
enter code here
import java.util.*;
import javax.swing.*;
public class pencilneck
{
public static void main(String []alex)
{
int ROWS = 6;
int COLS = 3;
int[][] chargeAcc = new int[ROWS][COLS];
Scanner keyboard = new Scanner(System.in);
for(int row = 0; row < ROWS; row++)
{
for(int col = 0; col < COLS; col++)
{
System.out.print("Enter Account");
chargeAcc[row][col] = keyboard.nextInt();
}
}
System.out.print("Enter an account to be Charged");
int input = keyboard.nextInt();
int results = SequentialSearch(chargeAcc,input);
if(results ==-1)
{
System.out.println("that is an invalid #");
}
else
{
System.out.println("the # is valid");
}
}
public static int SequentialSearch(int[][] array, int value)
{
int rowIndex = 0;
int element = -1;
boolean found = false;
while(!found && index1 != value)
{
for(int i =0;i<array[index].length;i++)
{
if(array[index][i] == value)
{
found = true;
element = index;
}
}
index++;
}
return element;
}
for each row you search in all of it's cols.
(you could break the for loop if found, to gain efficiency.

Generating 10 random numbers without duplicate with fundamental techniques

my intend is to use simplest java (array and loops) to generate random numbers without duplicate...but the output turns out to be 10 repeating numbers, and I cannot figure out why.
Here is my code:
int[] number = new int[10];
int count = 0;
int num;
while (count < number.length) {
num = r.nextInt(21);
boolean repeat = false;
do {
for (int i=0; i<number.length; i++) {
if (num == number[i]) {
repeat = true;
} else if (num != number[i] && i == count) {
number[count] = num;
count++;
repeat = true;
}
}
} while (!repeat);
}
for (int j = 0; j < number.length; j++) {
System.out.print(number[j] + " ");
}

How about you use a Set instead? If you also want to keep track of the order of insertion you can use a LinkedHashSet.
Random r = new Random();
Set<Integer> uniqueNumbers = new HashSet<>();
while (uniqueNumbers.size()<10){
uniqueNumbers.add(r.nextInt(21));
}
for (Integer i : uniqueNumbers){
System.out.print(i+" ");
}
A Set in java is like an Array or an ArrayList except it handles duplicates for you. It will only add the Integer to the set if it doesn't already exist in the set. The class Set has similar methods to the Array that you can utilize. For example Set.size() is equivalent to the Array.length and Set.add(Integer) is semi-equivalent to Array[index] = value. Sets do not keep track of insertion order so they do not have an index. It is a very powerful tool in Java once you learn about it. ;)
Hope this helps!

You need to break out of the for loop if either of the conditions are met.
int[] number = new int[10];
int count=0;
int num;
Random r = new Random();
while(count<number.length){
num = r.nextInt(21);
boolean repeat=false;
do{
for(int i=0; i<number.length; i++){
if(num==number[i]){
repeat=true;
break;
}
else if(i==count){
number[count]=num;
count++;
repeat=true;
break;
}
}
}while(!repeat);
}
for(int j=0;j<number.length;j++){
System.out.print(number[j]+" ");
}
This will make YOUR code work but #gonzo proposed a better solution.

Your code will break the while loop under the condition: num == number[i].
This means that if the pseudo-generated number is equal to that positions value (the default int in java is 0), then the code will end execution.
On the second conditional, the expression num != number[i] is always true (otherwise the code would have entered the previous if), but, on the first run, when i == count (or i=0, and count=0) the repeat=true breaks the loop, and nothing else would happen, rendering the output something such as
0 0 0 0 0 0...

Try this:
int[] number = new int[10];
java.util.Random r = new java.util.Random();
for(int i=0; i<number.length; i++){
boolean repeat=false;
do{
repeat=false;
int num = r.nextInt(21);
for(int j=0; j<number.length; j++){
if(number[j]==num){
repeat=true;
}
}
if(!repeat) number[i]=num;
}while(repeat);
}
for (int k = 0; k < number.length; k++) {
System.out.print(number[k] + " ");
}
System.out.println();
Test it here.

I believe the problem is much easier to solve. You could use a List to check if the number has been generated or not (uniqueness). Here is a working block of code.
int count=0;
int num;
Random r = new Random();
List<Integer> numbers = new ArrayList<Integer>();
while (count<10) {
num = r.nextInt(21);
if(!numbers.contains(num) ) {
numbers.add(num);
count++;
}
}
for(int j=0;j<10;j++){
System.out.print(numbers.get(j)+" ");
}
}

Let's start with the most simple approach, putting 10 random - potentially duplicated - numbers into an array:
public class NonUniqueRandoms
{
public static void main(String[] args)
{
int[] number = new int[10];
int count = 0;
while (count < number.length) {
// Use ThreadLocalRandom so this is a contained compilable unit
number[count++] = ThreadLocalRandom.current().nextInt(21);
}
for (int j = 0; j < number.length; j++) {
System.out.println(number[j]);
}
}
}
So that gets you most of the way there, the only thing you know have to do is pick a number and check your array:
public class UniqueRandoms
{
public static void main(String[] args)
{
int[] number = new int[10];
int count = 0;
while (count < number.length) {
// Use ThreadLocalRandom so this is a contained compilable unit
int candidate = ThreadLocalRandom.current().nextInt(21);
// Is candidate in our array already?
boolean exists = false;
for (int i = 0; i < count; i++) {
if (number[i] == candidate) {
exists = true;
break;
}
}
// We didn't find it, so we're good to add it to the array
if (!exists) {
number[count++] = candidate;
}
}
for (int j = 0; j < number.length; j++) {
System.out.println(number[j]);
}
}
}

The problem is with your inner 'for' loop. Once the program finds a unique integer, it adds the integer to the array and then increments the count. On the next loop iteration, the new integer will be added again because (num != number[i] && i == count), eventually filling up the array with the same integer. The for loop needs to exit after adding the unique integer the first time.
But if we look at the construction more deeply, we see that the inner for loop is entirely unnecessary.
See the code below.
import java.util.*;
public class RandomDemo {
public static void main( String args[] ){
// create random object
Random r = new Random();
int[] number = new int[10];
int count = 0;
int num;
while (count < number.length) {
num = r.nextInt(21);
boolean repeat = false;
int i=0;
do {
if (num == number[i]) {
repeat = true;
} else if (num != number[i] && i == count) {
number[count] = num;
count++;
repeat = true;
}
i++;
} while (!repeat && i < number.length);
}
for (int j = 0; j < number.length; j++) {
System.out.print(number[j] + " ");
}
}
}

This would be my approach.
import java.util.Random;
public class uniquerandom {
public static void main(String[] args) {
Random rnd = new Random();
int qask[]=new int[10];
int it,i,t=0,in,flag;
for(it=0;;it++)
{
i=rnd.nextInt(11);
flag=0;
for(in=0;in<qask.length;in++)
{
if(i==qask[in])
{
flag=1;
break;
}
}
if(flag!=1)
{
qask[t++]=i;
}
if(t==10)
break;
}
for(it=0;it<qask.length;it++)
System.out.println(qask[it]);
}}

public String pickStringElement(ArrayList list, int... howMany) {
int counter = howMany.length > 0 ? howMany[0] : 1;
String returnString = "";
ArrayList previousVal = new ArrayList()
for (int i = 1; i <= counter; i++) {
Random rand = new Random()
for(int j=1; j <=list.size(); j++){
int newRand = rand.nextInt(list.size())
if (!previousVal.contains(newRand)){
previousVal.add(newRand)
returnString = returnString + (i>1 ? ", " + list.get(newRand) :list.get(newRand))
break
}
}
}
return returnString;
}

Create simple method and call it where you require-
private List<Integer> q_list = new ArrayList<>(); //declare list integer type
private void checkList(int size)
{
position = getRandom(list.size()); //generating random value less than size
if(q_list.contains(position)) { // check if list contains position
checkList(size); /// if it contains call checkList method again
}
else
{
q_list.add(position); // else add the position in the list
playAnimation(tv_questions, 0, list.get(position).getQuestion()); // task you want to perform after getting value
}
}
for getting random value this method is being called-
public static int getRandom(int max){
return (int) (Math.random()*max);
}

Arraylist, incomparable types: DieClass and int

Trying to write a program that "rolls" dice and displays the results of the players and computer's rolls, as well as find how many of each number was rolled. Say, player rolls 3 4 3 5 6, then the player has a match composed of 2 3's. Haven't wrote the code to display the matching yet.
My problem is that I am trying to record the rolls to an ArrayList, then compare each number for the players and computers rolls from the ArrayList, and count up the number of each number's occurrence, but it I keep getting the error of
error: incomparable types: DieClass and int
Whenever I try to compare from the ArrayList
The program in question uses methods from the class DieClass
import java.util.ArrayList;
public class DieTester
{
private static ArrayList<DieClass> player = new ArrayList<DieClass>();
private static ArrayList<DieClass> computer = new ArrayList<DieClass>();
public static void main(String[] args)
{
for(int a = 1; a <= 5; a++)
{
DieClass roller = new DieClass();
player.add(roller);
}
for(int a = 1; a <= 5; a++)
{
DieClass roller = new DieClass();
computer.add(roller);
}
System.out.println("The user rolls: "+player);
System.out.println("The computer rolls: "+computer);
}
public String findMatching()
{
int count1 = 0;
int count2 = 0;
int count3 = 0;
int count4 = 0;
int count5 = 0;
for(int i=1; i<player.size(); i++)
{
if(player.get(i)==1)
{
count1++;
}
else if(player.get(i)==2)
{
count2++;
}
else if(player.get(i)==3)
{
count3++;
}
else if(player.get(i)==4)
{
count4++;
}
else if(player.get(i)==5)
{
count5++;
}
}
for(int i=1; i<player.size(); i++)
{
if(computer.get(i)==1)
{
count1++;
}
else if(computer.get(i)==2)
{
count2++;
}
else if(computer.get(i)==3)
{
count3++;
}
else if(computer.get(i)==4)
{
count4++;
}
else if(computer.get(i)==5)
{
count5++;
}
}
}
}

Your problem is that you are comparing DieClass with Integers
if(player.get(i)==1)
For the counters, why don't you use an array of int? like
int counters [] = new int[6];
counters[2]++;
Please post DieClass, however, I think that your code should be like this.
for (DieClass dieClass : player) {
counters[dieClass.getNumber()-1]++; //Supose that DieClass has a getNumber method and set minus one because counters goes from 0 to 5
}

Program does not run as expected

I'm doing a magicsquare program that allows a user to input numbers >0 to form a magicsquare. What a magic square is, is pretty much a square, meaning that n has to have n(squared) numbers. Much like ticTacToe, all the rows, columns, and diagonals each have the same sum to be considered a magic square When I run my program, It always confuses the 2D array set and claim that the set of numbers are a magicsquare when usually, it isnt necessarily so. Please help!
import java.util.Scanner;
public class SquareRunner
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
Square test = new Square();
System.out.println("Enter a row of integers. When you are finished, type 'n' in a new line");
boolean flag = false;
while(!flag)
{
String numbers = in.next();
if(numbers.equals("n"))
flag = true;
else
test.add(numbers);
}
test.isMagic();
}
}
public class Square
{
private int[][] values;
private int row;
public Square()
{
row = 0;
}
public void add(String numbers)
{
int b = 1;
int amount = numbers.length();
values = new int[amount][amount];
for(int j =0;j<amount;j++)
{
String a = numbers.substring(j,b);
int convert = Integer.parseInt(a);
values[row][j] = convert;
b++;
}
row++;
}
public Boolean isMagic()
{
int checkAmountColumns = values[0].length;
int checkAmountRows = values.length;
int isSquare = checkAmountColumns * checkAmountRows;
for(int q = 0;q<values.length;q++)
{
for(int w=0;w<values[0].length;w++)
{
int checkZero = values[q][w];
if(checkZero == 0)
{
System.out.print("To be a perfect square, your number of rows and columns, n must be a perfect ");
System.out.println("Square i.e. 9 total numbers is 3 numbers per row");
return false;
}
}
}
if(checkAmountColumns != checkAmountRows || Math.sqrt(isSquare) != checkAmountColumns)
{
System.out.print("To be a perfect square, your number of rows and columns, n must be a perfect ");
System.out.println("Square i.e. 9 total numbers is 3 numbers per row");
return false;
}
else
{
int magicNumber = 0;
int counter = 0;
int compareTo = 0;
//row to row
for(int i =0;i<values.length;i++)
{
for(int j = 0;j<values[0].length;j++)
{
values[i][j] += compareTo;
if(counter == 0)
values[i][j] += magicNumber;
}
counter ++;
compareTo = 0;
if(compareTo != magicNumber)
{
System.out.println("This Selection of numbers is not a perfect square");
return false;
}
}
//column to column
for(int i =0;i<values[0].length;i++)
{
for(int j = 0;j<values.length;j++)
{
values[j][i] += compareTo;
if(counter == 0)
values[j][i] += magicNumber;
}
counter ++;
compareTo = 0;
if(compareTo != magicNumber)
{
System.out.println("This Selection of numbers is not a perfect square");
return false;
}
}
System.out.println("This selection of numbers is a MagicSquare!");
return true;
}
}
}

The first thing I notice is that your add() method probably won't work correctly. Every time you call it, you overwrite the previous values member with a newly allocated array. This throws away the previous row that you entered.

Same answer as Greg.
Add this to your add method and delete the initialisation of your values array.
if(values == null){values = new int[amount][amount];}