Develop Reference

How to sort only odd integers from an array of both odd and even integers and only display the sorted odd integer?

here is the integer array given to me 111,77, 88, 44, 32, 11, 13, 25, 44 I need to sort & display only the odd elements of the array .
I had tried solving it using loops and if condition
i had expected the output as 11 13 25 77 111
import java.lang.reflect.Array;
public class oddsortSolution {
public static void main(String args[]) {
int n[] = { 111, 77, 88, 44, 32, 11, 13, 25, 44 };
int i = 0;
int temp = 0;
while (i < n.length) {
if (n[i] % 2 != 0) {
for (int j = i + 1; j < n.length; j++) {
if (n[j] > n[i]) {
n[j] = temp;
n[j] = n[i];
n[i] = temp;
}
}
}
}
System.out.println(n[1]);
}
}

You basically need to keep track of your odd array size, increment it every time you find an odd value, determine if the value should be swapped somewhere in the existing array (ranging from 0 to oddArraySize) and insert it in the correct position. Try the following code,
public class oddsortSolution {
public static void main(String args[]) {
int n[] = { 111, 77, 88, 44, 32, 11, 13, 25, 44 };
int oddArraySize = 0;
for (int i = 0;i < n.length; i++) {
if (n[i] % 2 != 0) {
oddArraySize++;
for (int j = 0; j < oddArraySize; j++) {
if (j == oddArraySize - 1) {
n[j] = n[i];
} else if (n[j] > n[i]) {
int temp = n[j];
n[j] = n[i];
n[i] = temp;
}
}
}
}
int[] oddArray = Arrays.copyOfRange(n, 0, oddArraySize);
System.out.println( Arrays.toString( oddArray ));
}
}

Threadpool with callable

I got struked with the ThreadPool method with callable. I want to find Large number in array as well Frequency of it occurence, so i did everything but it showing error. Anyone can help me. Thank you.
import java.util.concurrent.Callable;
public class CallableMethod im``plements Callable<Integer>{
//#SuppressWarnings("unused")
private int[] num;
public CallableMethod(int [] num){
this.num = num;
}
public Integer call() throws Exception{
int n = num[0];
int frequency = 0;
for(int i=1; i< num.length; i++)
{
if(n < num[i]){
n = num[i];
}
}
for(int i = 1; i< num.length; i++){
if (n == num[i]){
frequency++;
}
}
//System.out.println("Largest Number is : " + num);
//System.out.println("frequency of occurence : " + frequency);
return frequency;
}
}
Above one is my callabe() code and
import java.util.concurrent.*;
import java.util.*;
class ThreadPoolMethod {
// static ExecutorService pool = Executors.newFixedThreadPool(2);
public static void main(String[] args) {
ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
int number[] = { 32, 43, 145, 53, 25, 98, 54, 32, 65, 63, 145, 98, 43, 23, 25, 98, 100, 102, 105, 123, 145,
122, 123, 11, 12, 1, 0, 123, 145, 145 };
ArrayList<Future<Integer>> future = new ArrayList<Future<Integer>>();
for (int j = 0; j < number.length; j++) {
Future<Integer> f = pool.submit(new CallableMethod(number));
future.add(f);
}
// create array to store results
int result[] = new int[number.length];
for (int j = 0; j < result.length; j++) {
try {
Future<Integer> f = future.get(j);
result[j] = f.get();
} catch (InterruptedException e) {
} catch (ExecutionException e) {
};
}
System.out.println("The Large Number in array is: " + n);
System.out.println("The : " + frequency);
pool.shutdown();
for(int x : result)
System.out.print(x);
}
}
This one is my ThreadPool. Please I'm struked. I cant call callable work into ThreadPool method.Please help me

Try to use this example on java 8 with Streams, CompletableFuture, ForkJoinPool
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ForkJoinPool;
import java.util.stream.Collectors;
public class DemoController {
public static void main(String[] args) {
ForkJoinPool forkJoinPool = new ForkJoinPool(2);
int number[] = {32, 43, 145, 53, 25, 98, 54, 32, 65, 63, 145, 98, 43, 23, 25, 98, 100, 102, 105, 123, 145,
122, 123, 11, 12, 1, 0, 123, 145, 145};
List<CompletableFuture<Integer>> future = new ArrayList<>();
for (int j = 0; j < number.length; j++) {
CompletableFuture<Integer> f = CompletableFuture.supplyAsync(() -> func(number), forkJoinPool);
future.add(f);
}
List<Integer> result = future.stream().map(f -> {
try {
return f.get();
} catch (Exception e) {
throw new RuntimeException(e);
}
}).collect(Collectors.toList());
forkJoinPool.shutdown();
result.forEach(System.out::println);
}
private static Integer func(int num[]) {
int n = num[0];
int frequency = 0;
for (int i = 1; i < num.length; i++) {
if (n < num[i]) {
n = num[i];
}
}
for (int i = 1; i < num.length; i++) {
if (n == num[i]) {
frequency++;
}
}
System.out.println("Largest Number is : " + n);
System.out.println("frequency of occurence : " + frequency);
return frequency;
}
}

How can I find the top three test scores + names from my array

I have completed the first two steps of my assignment as to how my teacher wanted me to, which were to:
calculate and print the average score for each exam
calculate and print the average score for each student, and the top scoring student
and now I can't figure out how to get it so it displays the top THREE scoring student's and their scores
I want to do this without sorting the array is ascending/descending order
My code so far is:
public class GradeBook {
public static void main(String[] args) {
String[] names = {"Alex", "Barry","Cindy", "Deb", "Eric", "Fran", "Gary", "Helen"};
int[][] grades = {
{ 77, 83, 96 },
{ 88, 67, 78 },
{ 92, 77, 76 },
{ 94, 42, 81 },
{ 99, 54, 72 },
{ 90, 46, 54 },
{ 76, 59, 88 },
{ 94, 69, 88 }
};
int rSize = grades[0].length;
int cSize = grades.length;
double avg = 0;
double maxNum = 0;
double avgSc = 0;
ArrayList<Double> avgScores = new ArrayList();
ArrayList topThree = new ArrayList();
// calculate and print the average score for each exam
for (int r = 0; r < rSize; r++) {
avg = 0;
for (int c = 0; c < cSize; c++) {
avg += grades[c][r];
}
avg /= cSize;
DecimalFormat a = new DecimalFormat("#.##");
double x = Double.parseDouble(a.format(avg));
System.out.println("\nThe average grade for Exam #" + (r+1) + ": " +x);
}
// calculate and print the average score for each student, and the top scoring student
for (int c = 0; c < cSize; c++) {
avgSc = 0;
for (int r = 0; r < rSize; r++) {
avgSc += grades[c][r];
}
avgSc /= rSize;
DecimalFormat a = new DecimalFormat("#.##");
double x = Double.parseDouble(a.format(avgSc));
System.out.println("\nThe average grade for " + names[c] + ": " +x);
avgScores.add(avgSc);
}
maxNum = 0;
int topI = -1;
for (int i = 0; i<cSize; i++) {
if (avgScores.get(i) > maxNum){
maxNum = avgScores.get(i);
topI = i;
}
else {
continue;
}
}
DecimalFormat a = new DecimalFormat("#.##");
double x = Double.parseDouble(a.format(maxNum));
System.out.println("\nThe top scoring student is: " + names[topI] + ", who has an average score of: " + x);
double top1 = 0;
double top2 = 0;
double top3 = 0;
String name1 = "";
String name2 = "";
String name3 = "";
// Some loop that gets the top 3 students and their scores
}
}

There are three possible ways I can think of:
Sorting. Ref: http://www.giantbomb.com/forums/off-topic-31/java-enter-number-of-students-enter-grades-and-nam-544969/
Selection Algorithm (find kth largest element). Ref: http://www.careercup.com/question?id=182717
Simply loop over the scores and corresponding student to find the top three students.

How to copy non-duplicated values from one array to the other?

I am using first array to store all database of numbers where some numbers are duplicates.
I have went through this array to see which items are duplicated and am adding index of duplicated items to second array.
Now, I must loop through first array and add all but duplicated values to third array (assuming that we know which fields are duplicated).
But how to do this correctly? I can't make it stop adding every item from first array to third array.
Assuming I can't use HashSet().
The purpose of this is to demonstrate how to move one array to other with removed duplicated in O(N) time complexity.
Input numbers: 00, 11, 11, 22, 33, 44, 55, 55, 66, 77, 88, 99
Output which index are duplicated: 1, 2, 6, 7
Output I get: 00, 11, 11, 22, 33, 44, 55, 55, 66, 77, 88, 99 (same as the input)
Code:
public void dups()
{
int[] b = new int[100];
int[] c = new int[100];
int k = 0;
int n = 0;
int p = 0;
for (int i = 0; i < nElems; i++)
for (int j = 0; j < nElems; j++)
if(a[j].equals(a[i]) && j != i)
b[k++] = i;
for (int l = 0; l < k; l++)
System.out.print(b[l] + " ");
for (int m = 0; m < nElems; m++)
if (m != b[p + 2])
c[m] = (Integer) a[n++];
System.out.print("\n");
for (int o = 0; o < nElems; o++)
System.out.print(c[o] + " ");
}

It can be done in a simpler way:
Set<Integer> uniqueSet = new HashSet<Integer>();
uniqueSet.addAll(list);
//not uniqueSet contains only unique elements from the list.
The reason it works is that a Set cannot contain duplicates. So while adding elements to a Set, it ignores those that are duplicates.

You can use a HashSet instead of Array to store all database of numbers.
After that use Collections.toArray() to get your desired Array.
I see that the question got edited and we don't want to use HashSet anymore.
Anyways, your problem is already answered here, Algorithm: efficient way to remove duplicate integers from an array

Instead of marking all duplicates you could mark all that have already been seen earlier.
Instead of:
for (int i = 0; i < nElems; i++)
for (int j = 0; j < nElems; j++)
if(a[j].equals(a[i]) && j != i)
b[k++] = i;
Use something like:
for (int i = 0; i < nElems; i++)
for (int j = i+1; j < nElems; j++)
if(a[j].equals(a[i]))
b[k++] = j;
You should then see:
Output which index are duplicated: 2, 7
Which should be much easier to work with.
Here's a working solution - although I wouldn't do it this way:
public class Test {
Integer[] a = {00, 11, 11, 22, 33, 44, 55, 55, 66, 77, 88, 99};
int nElems = a.length;
public void dups() {
int[] b = new int[100];
int[] c = new int[100];
int k = 0;
int n = 0;
int p = 0;
for (int i = 0; i < nElems; i++) {
for (int j = i + 1; j < nElems; j++) {
if (a[j].equals(a[i])) {
b[k++] = j;
}
}
}
for (int l = 0; l < k; l++) {
System.out.print(b[l] + " ");
}
for (int m = 0; m < nElems; m++) {
if (m != b[p]) {
c[n++] = a[m];
} else {
p += 1;
}
}
System.out.print("\n");
for (int o = 0; o < nElems - k; o++) {
System.out.print(c[o] + " ");
}
}
public static void main(String args[]) {
new Test().dups();
}
}
which prints:
2 7
0 11 22 33 44 55 66 77 88 99

I don't know if this is what you were looking for. But it removes duplicate. Give it a shot,
int[] b = { 00, 11, 11, 22, 33, 44, 55, 55, 66, 77, 88, 99 };
List<Integer> noDups = new ArrayList<Integer>();
Boolean dupliceExists;
for (int i = 0; i < b.length; i++) {
dupliceExists = Boolean.FALSE;
for (Integer integ : noDups) {
if (Integer.valueOf(b[i]).equals(integ)) {
dupliceExists = Boolean.TRUE;
//Get index if you need the index of duplicate from here
}
}
if (!dupliceExists) {
noDups.add(b[i]);
}
}
for (int i = 0; i < noDups.size(); i++) {
System.out.println(noDups.get(i));
}

I am going to coding for copying non-duplicate elements from one Array to another Array.
/*
* print number of occurance of a number in an array beside it
*
* */
class SpoorNumberOfOccuranceInArray{
public static void main(String[] args){
int[] arr={65,30,30,65,65,70,70,70,80};
int[] tempArr=new int[arr.length];//making size compatible to source Array.
int count=0;
for(int i=0;i<arr.length;i++){
int temp=arr[i];
for(int j=0;j<tempArr.length;j++){
if(temp==tempArr[j]){ //Comparing the Availability of duplicate elements in the second Array.---------
break;
}
else{ //Inserting if value is not in the second Array.---------------
if( tempArr[j]==0){
tempArr[j]=temp;
break;
}//end if
}//end else
}//end if
}//end for
for(int i=0;i<tempArr.length;i++){
for(int j=0;j<arr.length;j++){
if(tempArr[i]==arr[j])
count++;
}
System.out.println(tempArr[i]+" "+count);
count=0;
}
}
}

Adding the diagonal values in a 2d array

I have the following 2d array
int [][] array = {{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
{10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
{20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
{30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
{40, 41, 42, 43, 44, 45, 46, 47, 48, 49},
{50, 51, 52, 53, 54, 55, 56, 57, 58, 59},
{60, 61, 62, 63, 64, 65, 66, 67, 68, 69},
{70, 71, 72, 73, 74, 75, 76, 77, 78, 79},
{80, 81, 82, 83, 84, 85, 86, 87, 88, 89},
{90, 91, 92, 93, 94, 95, 96, 97, 98, 99}};
I have this code to find the sum of all the values in the array. How can I modify it to add only the diagonal values starting at 0 (0+11+22+33 etc.)?
public static int arraySum(int[][] array)
{
int total = 0;
for (int row = 0; row < array.length; row++)
{
for (int col = 0; col < array[row].length; col++)
total += array[row][col];
}
return total;
}

Since the diagonals are at perfect square you only need one loop to add the diagonals.
Adding diagonal from orgin:
public static int arraySum(int[][] array){
int total = 0;
for (int row = 0; row < array.length; row++)
{
total += array[row][row];
}
return total;
}
Add both diagonals:
Adding diagonal from orgin: (note it adds the center twice..you can subtract one if needed)
public static int arraySum(int[][] array){
int total = 0;
for (int row = 0; row < array.length; row++)
{
total += array[row][row] + array[row][array.length - row-1];
}
return total;
}

public static int arraySum(int[][] array)
{
int total = 0;
for (int index = 0; index < array.length; index++)
{
total += array[index][index];
}
return total;
}
This of course assumes m x m for the dimensions.

Here is my solution -
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int a[][] = new int[n][n];
for(int a_i=0; a_i < n; a_i++){
for(int a_j=0; a_j < n; a_j++){
a[a_i][a_j] = in.nextInt();
}
}
int l_sum = 0;
for(int i = 0; i<n ; i++){
l_sum+=a[i][i];
}
int r_sum = 0;
for(int j = 0; j<n ; j++){
r_sum+=a[j][n-1-j];
}
int sum = l_sum + r_sum;
System.out.println(sum);
}
}

import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int leftStartDiagnol = 0;
int rightStartDiagnol = n;
int leftTotal = 0;
int rightTotal = 0;
int a[][] = new int[n][n];
for (int a_i = 0; a_i < n; a_i++) {
for (int a_j = 0; a_j < n; a_j++) {
a[a_i][a_j] = in.nextInt();
}
}
for (int a_i = 0; a_i < n; a_i++) {
boolean leftNotFound = true;
boolean rightNotFound = true;
rightStartDiagnol = --rightStartDiagnol;
for (int a_j = 0; a_j < n; a_j++) {
if (leftStartDiagnol == a_j && leftNotFound) {
leftTotal = leftTotal + a[a_i][a_j];
leftNotFound = false;
}
if (rightStartDiagnol == a_j && rightNotFound) {
rightTotal = rightTotal + a[a_i][a_j];
rightNotFound = false;
}
}
leftStartDiagnol = ++leftStartDiagnol;
}
int data = leftTotal - rightTotal;
System.out.println(Math.abs(data));
}
}

Here is my solution. Check out it.
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int a[][] = new int[n][n];
int total1=0;
int total2=0;
for(int a_i=0; a_i < n; a_i++){
for(int a_j=0; a_j < n; a_j++){
a[a_i][a_j] = in.nextInt();
}
total1+= a[a_i][a_i];
total2+=a[a_i][n-1-a_i];
}
System.out.println(Math.abs(total1-total2));
}
}

import java.io.*;
import java.util.*;
public class DigArraySum {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int n=Integer.parseInt(s.nextLine()); //array size
int[][] a=new int[n][n]; // new array
for (int i=0;i<n;i++) {
String str=s.nextLine();
String[] tempArray=str.split(" ");
for (int j=0;j<n;j++) {
a[i][j]=Integer.parseInt(tempArray[j]);
}
}
int x=0;//primary diagonal sum
int y=0;//secondary diagonal sum
int sum=0;//total sum
for (int i=0;i<n;i++) {
x += a[i][i];
}
for (int p=0;p<n;p++) {
int k=a.length-p-1;
y+=a[p][a.length-p-1];
k+=-1;
}
sum=x-y;
System.out.println(Math.abs(sum));
}
}
Explanation:
for example 3*3 matrix:
3// Array size
11 2 4
4 5 6
10 8 -12
The primary diagonal is:
11
5
-12
Sum across the primary diagonal: 11 + 5 - 12 = 4
The secondary diagonal is:
4
5
10
Sum across the secondary diagonal: 4 + 5 + 10 = 19
Total Sum: |4 + 19| = 23

Solution in PHP. The logic is exactly the same what is already posted here. It's only in PHP that's different.
<?php
$handle = fopen ("php://stdin", "r");
function diagonalDifference($a) {
$sumA = [];
$sumB = [];
$n = count($a);
for ($i = 0; $i < $n; $i++) {
for ($j = 0; $j < $n; $j++) {
if ($i === $j) {
$sumA[] = $a[$i][$j];
}
if ($i + $j == count($a) -1 ) {
$sumB[] = $a[$i][$j];
}
}
}
$sum1 = array_sum($sumA);
$sum2 = array_sum($sumB);
return abs($sum1 - $sum2);
}
fscanf($handle, "%i",$n);
$a = array();
for($a_i = 0; $a_i < $n; $a_i++) {
$a_temp = fgets($handle);
$a[] = explode(" ",$a_temp);
$a[$a_i] = array_map('intval', $a[$a_i]);
}
$result = diagonalDifference($a);
echo $result . "\n";
?>

The solution is:
int total = 0;
for (int row = 0; row < array.length; row++)
{
total += array[row][row] + array[row][array.length - row - 1];
}
System.out.println("FINAL ANSWER: " + total);

Here is the code which I did to find the sum of primary diagonal numbers and secondary diagonal numbers
static int diagSum(int[][] arr) {
int pd=0;
int sd=0;
int sum=0;
for(int i=0;i<=arr.length-1;i++){
pd=pd+arr[i][i];
}
for (int k=0,l=arr.length-1; k<arr.length&&l>=0 ; k++,l--) {
sd=sd+arr[k][l];
}
sum=pd+sd;
return sum;
}

difference between the sums of its diagonals in kotlin :
val total = (0 until array.size).sumBy { array[it][it] - array[it][array.size - it - 1] }
if you want absolute difference:
return Math.abs(total)

public class matrix {
public static void main(String[] args) {
int sum=0;
int a[][]= new int[][]{{2,3,4},{4,5,6},{5,5,5}};
for(int i=0;i<=2;i++)
{
sum=sum+a[i][i];
}
System.out.println(sum);
}
}

If you want to add both diagonal in a 2d array then here is my program.
static int diagonalDifference(int[][] arr) {
int r = arr.length;
int sum1 = 0;
int sum2 = 0;
int j=0;
for(int i=0;i<r;i++){
sum1 = sum1 + arr[i][j];
j++;
}
j--;
for(int i=0;i<r;i++) {
sum2 = sum2 + arr[i][j];
j--;
}
int sum=sum1+sum2;
return sum;
}

If you want to add both diagonal in a 2d array then here is a solution:
int j = row_col_size-1;
for (int i = 0; i < intArray.length; i++) {
sum_left += intArray[i][i];
sum_right += intArray[i][j];
j--;
}

Although this post is very old. Providing my solution. This might be useful for someone
func diagonalDifference(arr [][]int32) int32 {
return int32(math.Abs(float64(arraySumPrimary(arr)) - float64(arraySumSecondary(arr))) )
}
func arraySumPrimary(arr [][]int32) int32{
var total int32 =0
for row :=0; row < len(arr) ; row ++{
total = total + arr[row][row]
}
return total
}
func arraySumSecondary(arr [][]int32) int32{
var total int32 =0
x := len(arr)-1
y := 0
for x >=0 && y < len(arr){
total = total + arr[x][y]
x--
y++
}
return total
}