Develop Reference

finding first even element and outputting index

My program:
public static void evenval (int[] array ){
int even=0;
for (int r = 0; r < array.length; r++) {
while (r == array[r]) {
if (array[r] % 2 ==0) {
even = array[r];
System.out.println("The first even number's index is:"+array[r]);
}
I'm trying to make a loop where it finds the first even number in an array and get it to output it's index to the main method.
I'm stuck, please help.

Try to use just for loop like this:
int even = 0;
for (int r=0;r<array.length;r++){
if (array[r] % 2 ==0){
even = r;
break;
}
}
System.out.println("The first even number's index is:"+ even );
Using the break; when find the even number.
For example if you want to find 100th even number use this:
int even = 0;
int count = 0;
for (int r=0;r<array.length;r++){
if(array[r] % 2 ==0){
if(count !=100){
count++;
}else{
even = r;
break;
}
}
}
System.out.println("The first even number's index is:"+ even );

It's better to create a small method in your class and call it from main to do this for you and return the index or -1 if a valid even number is not found. :
public class EvenTest{
int getFirstEvenIndex(int[] array){
for (int r=0; r < array.length; r++){
if (array[r] % 2 ==0){
return r;
}
}
return -1;
}
public static void main(String... args){
int[] arr = [3,5,1,2,7,8];
EvenTest et = new EvenTest();
System.out.println("First even is at index: " + et.getFirstEvenIndex(arr));
}
}

class test {
public static void main(String[] args) {
int[] array = {5, 7, 1, 8, 9, 3,110};
int evenCount =2;//required count ....for 100th even put evenCount = 100;
evenval(array,evenCount);
}
public static void evenval(int[] array,int evenCount) {
for (int i=0;i<array.length;i++) {
if(array[i] % 2 == 0&&--evenCount==0) {
System.out.println("the required even number is "+array[i]+" at index "+i);
return;
}
}
}
}

Just remove while statement in your code.
int even = 0;
for (int r = 0; r < array.length; r++) {
if (array[r] % 2 == 0) {
even = array[r];
System.out.println("The first even number's index is:" + array[r]);
}
}
If you want to stop after finding first even number, just put break inside if statement
int even = 0;
for (int r = 0; r < array.length; r++) {
if (array[r] % 2 == 0) {
even = array[r];
System.out.println("The first even number's index is:" + array[r]);
break;
}
}

You could simply use a bitwise operation as well (performance wise, it's quicker):
for (int n : array) {
if ((n&1) == 0) {
System.out.println("The first even number's index is:" + n);
break;
}
}

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);
}

How to remove element from a raw array

I have a program that will push pop and display, but I cannot pop the pushed numbers in my program probably I can't delete the element of that array. This is my code so far:
import java.io.*;
import java.util.*;
import java.awt.*;
import javax.swing.*;
public class Class2 {
public static void main(String args[]) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out
.print("1.)Push\n2.)Pop\n3.)Display\n4.)Exit\n\nChoose Item :");
int x = Integer.parseInt(in.readLine());
int[] a = new int[10];
int b = 0;
int i = 0;
do
{
switch (x) {
case 1:
System.out.print("Enter Push number :");
int v = Integer.parseInt(in.readLine());
a[b] = v;
b += 1;
System.out.print("Item push :" + v + "\n");
System.out
.print("1.)Push\n2.)Pop\n3.)Display\n4.)Exit\n\nChoose Item :");
x = Integer.parseInt(in.readLine());
if (x == 3) {
for (i = 0; i < b; i++) {
System.out.print(a[i] + " ");
}
}
break;
case 2:
System.out.print("Enter Pop Number :");
int c = Integer.parseInt(in.readLine());
if (c == a[i]) {
}
System.out.print("Item Pop :" + c + "\n");
System.out
.print("1.)Push\n2.)Pop\n3.)Display\n4.)Exit\n\nChoose Item :");
x = Integer.parseInt(in.readLine());
if (x == 3) {
for (i = 0; i < b; i++) {
System.out.print(a[i] + " ");
}
}
break;
case 4:
break;
}
} while (x == 1 || x == 2);
}
}

First of all, if you want to change the elements of an array, then you should not use an array.
If you really don't want to use containers, then you could allocate dynamically a new array without the element you want to remove (not so a good idea probably because of bad performance and wasted memory).
This could be the method that returns the new array:
public static int[] removeElementAt(int [] array, int index){
if(index > 0 && index < array.length){
int [] newArray = new int[array.length - 1];
for(int i=0; i<index; i++)
newArray[i] = array[i]; // copying elements
for(int i=index+1; i<array.length; i++)
newArray[i-1] = array[i];
array = newArray;
}
return array;
}
This is just a simple example:
myArray = Class.removeElementAt(myArray, 5); // removes 6. element
You could also use the function removeElement from the API ArrayUtils, something like this:
array = ArrayUtils.removeElement(array, element)
Another alternative would be to convert your array to a list, remove the element, and then convert it back to an array: not so a good idea, because you could use directly an ArrayList.
So, the idea is to use dynamic containers when you want to modify the content, otherwise use a normal raw array.

you can use below code and it might solve your issue.
int brr[]= new int [a.length-1];
int j=0;
for(;j<a.length;j++)
{
if(c== a[j])
{
break;
}
else{
brr[j]=a[j];
}
}
for(j=j+1;j<a.length;j++)
{
brr[j-1] =a[j];
}
in display show brr array.

When you push 2, 5, and 6 you have a queue with 3 items in it:
a[0] == 2
a[1] == 5
a[2] == 6
When you pop 2, you want to remove it from the array. To do this, you need to copy everything after where 2 was popped from into the position above, so that you end up with:
a[0] == 5
a[1] == 6
The code for this would look something like:
int popPosition = findPopPosition();
for(int i = popPosition + 1; i < MAX; i++)
a[i - 1] = a[i];
b--; // Decrease effective queue size
Where findPopPosition() would need to find the index that 2 is at, so it would return 0 in this example.
Or, alternatively, the user could input the pop position directly (so pop element 0) instead of specifying what value they want to pop. That's probably more useful.

Not all test cases have been handled, but a sample working program as per your requirements.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class ArrayDemo {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the Array Max Capacity");
int maxSize = Integer.parseInt(br.readLine().trim());
int[] array = new int[maxSize];
int arrayCount = 0;
int choice = 0;
do {
System.out.println("\n1.Insert\n2.Delete\n3.Display\n4.Exit");
choice = Integer.parseInt(br.readLine().trim());
switch (choice) {
case 1:
boolean insertTrue = insertElement(br, maxSize, array,
arrayCount);
if (insertTrue) {
arrayCount++;
}
break;
case 2:
System.out.println("Enter Element to delete");
int delElement = Integer.parseInt(br.readLine().trim());
int numOccurrence = getOccurrenceCount(array, arrayCount,
delElement);
int newArrayCount = arrayCount - numOccurrence;
if (numOccurrence == 0) {
System.out.println("No Such Element to delete");
} else {
array = deleteElement(array, arrayCount, delElement,
newArrayCount,maxSize);
}
arrayCount =newArrayCount;
break;
case 3:
displayArray(array, arrayCount);
break;
case 4:
System.out.println("Exiting");
break;
default:
System.out.println("Invalid Choice, Exiting");
choice = 4;
}
} while (choice >= 1 && choice <= 3);
}
private static int[] deleteElement(int[] array, int arrayCount,
int delElement, int newArrayCount,int maxSize) {
int newArray[] = new int[newArrayCount];
int index=0;
for (int i = 0; i < arrayCount; i++) {
if (array[i] != delElement) {
newArray[index] = array[i];
index++;
}
}
resetArray(array, maxSize);
for(int i=0;i<newArrayCount;i++){
array[i]=newArray[i];
}
return array;
}
private static int[] resetArray(int[] array,int maxSize){
for(int i=0;i<maxSize;i++){
array[i]=0;
}
return array;
}
private static int getOccurrenceCount(int[] array, int arrayCount,
int delElement) {
int numOccurrence = 0;
for (int i = 0; i < arrayCount; i++) {
if (array[i] == delElement) {
numOccurrence++;
}
}
return numOccurrence;
}
private static void displayArray(int[] array, int arrayCount) {
if (arrayCount == 0) {
System.out.println("No Elements to Display");
} else {
System.out.println("Array is");
for (int i = 0; i < arrayCount; i++) {
System.out.print(array[i] + " ");
}
System.out.println("\n");
}
}
private static boolean insertElement(BufferedReader br, int maxSize,
int[] array, int arrayCount) throws IOException {
if (arrayCount < maxSize) {
System.out.println("Enter Element for Insertion");
array[arrayCount] = Integer.parseInt(br.readLine().trim());
return true;
} else {
System.out.println("Max Limit Reached, Insertion not possible");
return false;
}
}
}

Display Matrix to get a unique Pattern

I want to construct a square matrix (2D) of size n (which will be input by the user)
Now I want to construct a diagonal pattern.
For example (3X3 Matrix):
2 3
1
4 5
The value variable will be initialized to 1 and stored at the center of the square matrix. Then value will be incremented and stored at upper left corner as shown above, and so on.
It is a simple program to be displayed on console.
User input can taken from command line.
I am trying to generalize a condition in a for loop that will work for square matrix of size 5,7,9... (odd numbers).
For a matrix of size 5 it will be
6 7
2 3
1
4 5
8 9
(the empty spaces can be zero)
My code:
import java.util.*;
public class MatrixAdv
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
System.out.println("Please enter size of element...");
int n=sc.nextInt(); //stores size of Matrix
int value=0; //To be incremented everytime to get the Pattern
int [][] matrix = new int[n][n];
int k=0;
for(int i=0;i<some Condition;i++)
{
for(int j=1;j<some Condition;j++)
{
k=n-2-j;
matrix[k][k]=++value;
}
}
}
//Display the value in matrix form
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
Print(matrix[i][j]+"\t");
}
Print("\n");
}
}

its very easy to print 99% matrix patterns if you know the magic of matrix...and you can do it without using any memory.
here is the code......
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
if(n == 1)
cout<<1;
else
{
int sv=2*n-4,a,b;
a=sv;b=sv+1;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i == j && i+j == n+1)
{
cout<<" 1 ";
sv=4;
}
else
{
if(i == j)
cout<<" "<<a<<" ";
else if((i+j) == n+1)
cout<<" "<<b<<" ";
else
cout<<" ";
}
}
if(i < n/2+1)
{
sv=sv-4;
a=sv;b=sv+1;
}
else if(i > n/2+1)
{
sv=sv+4;
b=sv;a=sv+1;
}
else
{
sv=4;
b=sv;a=sv+1;
}
cout<<"\n";
}
}
}

There are basically 2 options for solving this:
Go through the whole matrix, row by row and column by column, and check whether a certain value has to be set at the current position
Go through all the positions where a certain value has to be set.
Both of them have nothing to do with the condition of a for-loop. However, here an example for the second approach:
public class MatrixAdv
{
public static void main(String args[])
{
//Scanner sc = new Scanner(System.in);
//System.out.println("Please enter size of element...");
//int n = sc.nextInt(); // stores size of Matrix
int n = 9;
int value = 0;// To be incremented everytime to get the Pattern
int[][] matrix = new int[n][n];
matrix[n/2][n/2] = 1;
int maxValue = ((n / 2) * 4) + 1;
int r = n / 2 - 1;
int c = n / 2 - 1;
int d = 2;
for (value=2; value<=maxValue; value++)
{
matrix[r][c] = value;
int step = ((value-2)%4);
switch (step)
{
case 0: c+=d; break;
case 1: r+=d; c-=d; break;
case 2: c+=d; break;
case 3: d+=2; r-=d-1; c-=d-1; break;
}
}
// Display the value in matrix form
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (matrix[i][j] == 0)
{
System.out.printf("%3s", "_");
}
else
{
System.out.printf("%3d", matrix[i][j]);
}
}
System.out.print("\n");
}
}
}

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];}