Related
I need to write a program which defines two arrays of int's and prints all elements of the first array which do not appear in the second, but each value once only, without repetitions (the order of printed values is irrelevant).
For example for arrays:
int[] arr = { 4, 3, 4, 3, 6, 7, 4, 8, 2, 9 };
int[] brr = { 2, 3, 6, 8, 1, 5 };
The result should be:
7 4 9
It only use the java.lang. package and it can't create any arrays, collections or Strings.
This prints all elements of the first array which do not appear in the second, now you just have to check for repetitions.
public static void compareArrays(int[] arr1, int[] arr2) {
boolean equal = false;
int[] printed = null;
for (int i = 0; i < arr1.length; i++) {
for (int x = 0; x < arr2.length; x++) {
if (arr1[i] == arr2[x]) {
equal = true;
break;
} else {
equal = false;
}
}
if (equal != true) {
System.out.println(arr1[i]);
}
}
}
public static void main(String[] args) {
int[] arr = { 4, 3, 4, 3, 6, 7, 4, 8, 2, 9 };
int[] brr = { 2, 3, 6, 8, 1, 5 };
compareArrays(arr, brr);
}
I will give you some pointers, but will not provide any code as I've not seen any attempt from your side. You can tackle this problem several ways, have a look and try to implement this yourself. You will learn much more during the process, rather than if someone gives you a complete full-code answer. So here goes:
First method:
Create a new ArrayList that will hold your output.
Iterate through the first array, iterate through the second array. Compare each value.
If value is not present and is not present in the output list (you would need to check for that specifically, so you dont have repetition of values), then add it to output list.
Print output list.
Second method:
Convert both arrays into an ArrayList.
Use the removeAll() method provided with Lists to get difference between the arrays. This will be stored in one of the lists you created earlier.
Remove repetitive items from the list (e.g. using Streams).
Third method:
Create a new ArrayList that will hold your output.
Iterate through values of array1.
Initialize a boolean variable (e.g. call it contains) that will determine whether a value from array1 is present in array2 using an IntStream.
Create if statement - if contains is true, add the value to your output list. Check that your output List already doesn't have the value and only add if it doesn't. Print output list.
Try using this instead:
String[] unique = new HashSet<String>(Arrays.asList(arr)).toArray(new String[0]);
for (int uEach : unique) {
for (int bEach : brr) {
if (unique[uEach] == brr[bEach]) {
ArrayUtils.removeElement(unique, uEach);
}
}
};
System.out.print(unique);
You can use to get distanct value from an array:
int[] unique = Arrays.stream(arr).distinct().toArray();
Then loop over both arrays and match strings if not found print that:
int i, j, occ;
int[] arr = { 4, 3, 4, 3, 6, 7, 4, 8, 2, 9 };
int[] brr = { 2, 3, 6, 8, 1, 5 };
arr = Arrays.stream(arr).distinct().toArray();
for (i = 0; i < arr.length; i++) {
occ = 0;
for (j = 0; j < brr.length; j++) {
if (arr[i] == brr[j]) {
occ++;
}
}
if (occ == 0) {
System.out.println(arr[i]);
}
}
static void findMissing(int a[], int b[]) {
for (int i = 0; i < a.length; i++) {
int j;
for (j = 0; j < b.length; j++) {
if (a[i] == b[j]) {
break;
}
}
if (j == b.length) {
System.out.print(a[i] + " ");
}
}
}
Hi, I'm a newbie to Java and I was doing this lab assignment where we compare elements of two arrays to get the common elements. I am stuck on how to get rid of duplicates.
My current code is giving me the output [3, 0, 5, 6, 5, 0, 9, 0] and the desired output of common is [3, 5, 6, 9, 0, 0, 0, 0].
Also, since I am not that experienced, please do not post professional ways to do the problem or "experienced" answers to my question, as that would not help me at all :D.
Thanks!
public static void main (String[] args) {
int[] a1 = {3, 8, 5, 6, 5, 8, 9, 2};
int[] a2 = {5, 15, 4, 6, 7, 3, 9, 11, 9, 3, 12, 13, 14, 9, 5, 3, 13};
int[] common = new int[a1.length];
System.out.println("Exercise 3: ");
findCommon(a1,a2,common);
}
public static void findCommon(int[] a1, int[]a2, int[] common) {
int num = 0;
for (int i = 0; i < common.length; i++)
{
for (int j = 0; j < a2.length; j++)
{
if (a1[i] == a2[j]) // loops through every index of j, while keeping i at one index
num = a1[i];
for (int k = 0; k < common.length; k++) // makes sure there are no duplicates in common
{
if (num != common[k])
common[i] = num;
}
}
}
for (int elements : common)
System.out.print(elements + " ");
}
You should look into using Sets to do this kind of thing, but since this is an exercise I've provided a solution with some comments along the way in the code.
Basically you should break the problem down into pieces, each of which is its own method. That way you will have an easier time getting it straight.
arrayIntersect(int[], int[])
This method's job is to create an array from two arrays. The resulting array must have unique elements that are present in both arrays.
You can do n. 1 with a helper method (mentioned below).
inArray(int, int[])
This method returns true if an array contains the given element, false otherwise.
Example
public static void main (String[] args) {
int[] a1 = {3, 8, 5, 6, 5, 8, 9, 2};
int[] a2 = {5, 15, 4, 6, 7, 3, 9, 11, 9, 3, 12, 13, 14, 9, 5, 3, 13};
int[] a3 = arrayIntersect(a1, a2);
for (int a : a3) {
System.out.println(a);
}
}
private static int[] arrayIntersect(int[] a1, int[] a2) {
int[] intersect = new int[Math.min(a1.length, a2.length)];
int curIndex = 0;
for (int x : a1) {
if (inArray(x, a2) && !inArray(x, intersect)) {
intersect[curIndex] = x;
curIndex++;
}
}
// resize intersect array to not include unused indexes
int[] tmp = intersect;
intersect = new int[curIndex];
for (int i = 0; i < intersect.length; i++) {
intersect[i] = tmp[i];
}
return intersect;
}
private static boolean inArray(int element, int[] array) {
boolean result = false;
for (int a : array) {
if (element == a) {
result = true;
break;
}
}
return result;
}
You are very close to the correct anwser, but the for loop for (int k = 0; k < common.length; k++) is being executed for every element of a2. So, when an value exist for a1 but doesn't exist for a2, you are putting the old value of num at the common array. If you look at the elements printed, you will see that every time that an element just exist in a1, the element repeat.
The result of the code is
3 3 5 6 5 5 9 9
You put the right identation, but forgot the curly brackets. If you put the curly brackets at the if (a1[i] == a2[j]), this will be the result:
3 0 5 6 5 0 9 0
But why these 0 are there? Because when you create an int array in java, all elements start with the value of 0. And you are putting the common elements at the same position of the presence of this elements in the a1 array. You can correct this by populating the int array with an invalid number and them ignorin it. At this code, I assumed that -1 is an invalid value.
public static void findCommon(int[] a1, int[] a2, int[] common) {
int num = 0;
for (int i = 0; i < common.length; i++) {
common[i] = -1;
}
for (int i = 0; i < common.length; i++) {
for (int j = 0; j < a2.length; j++) {
if (a1[i] == a2[j]) { // loops through every index of j, while keeping i at one index
num = a1[i];
for (int k = 0; k < common.length; k++) // makes sure there are
// no duplicates in common
{
if (num != common[k])
common[i] = num;
}
}
}
}
for (int elements : common) {
if (elements != -1)
System.out.print(elements + " ");
}
}
If you see, At the if (elements != -1) I didn't put the curly brackets but it worked. If you don't put the curly brackets, it will just execute the next command.
I'm looking for a hint on how to solve this or where I am going wrong.
The question is as follows: Write a static method named stretch that accepts an array of integers as a parameter and returns a new array twice as large as the original, replacing every integer from the original array with a pair of integers, each half the original. If a number in the original array is odd, then the first number in the new pair should be one higher than the second so that the sum equals the original number. For example, if a variable named list refers to an array storing the values {18, 7, 4, 24, 11}, the call of stretch(list) should return a new array containing {9, 9, 4, 3, 2, 2, 12, 12, 6, 5}. (The number 18 is stretched into the pair 9, 9, the number 7 is stretched into 4, 3, the number 4 is stretched into 2, 2, the number 24 is stretched into 12, 12 and the number 11 is stretched into 6, 5.)
Test your code with the following class:
import java.util.*;
public class TestStretch {
public static void main(String[] args) {
int[] list = {18, 7, 4, 14, 11};
int[] list2 = stretch(list);
System.out.println(Arrays.toString(list)); // [18, 7, 4, 24, 11]
System.out.println(Arrays.toString(list2)); // [9, 9, 4, 3, 2, 2, 7, 7, 6, 5]
}
// your code goes here
}
This is currently what I have, but it is not quite working correctly... I have a feeling it is how i'm using int i and int j, but i'm not sure what to do to fix it so that it works as intended.
import java.util.*;
public class TestStretch {
public static void main(String[] args) {
int[] list = {18, 7, 4, 14, 11};
int[] list2 = stretch(list);
System.out.println(Arrays.toString(list)); // [18, 7, 4, 24, 11]
System.out.println(Arrays.toString(list2)); // [9, 9, 4, 3, 2, 2, 7, 7, 6, 5]
}
public static int[] stretch(int[] array){
int length = array.length;
int[] newArray = new int[array.length*2];
for(int i = 0; i< length; i=i+2){
int j = 0;
if(array[i] % 2 == 0){
newArray[i] = (array[j]/2);
newArray[i+1] = newArray[i];
j++;
} else{
newArray[i] = (array[j]/2);
newArray[i+1] = (newArray[i] + 1);
j++;
}
}
return newArray;
}
}
The output I get is:
[18, 7, 4, 14, 11]
[9, 9, 9, 9, 9, 10, 0, 0, 0, 0]
Instead of:
[18, 7, 4, 24, 11]
[9, 9, 4, 3, 2, 2, 7, 7, 6, 5]
There are a couple of mistakes:
The loop iterates only until half of the array, skipping elements by 2
The value of j is reset to 0 in each iteration
Also, the algorithm can be simplified:
For each index i in the input, you want to set in the destination at position 2 * i and 2 * i + 1.
The second value to set is simply the original value divided by 2, with integer truncation
The first value to set is the same as the second, +1 if the division by 2 leaves a remainder
With the above issues corrected, and the implementation simplified:
int[] newArray = new int[array.length * 2];
for (int i = 0; i < array.length; i++) {
newArray[2 * i] = array[i] / 2 + array[i] % 2;
newArray[2 * i + 1] = array[i] / 2;
}
return newArray;
First of all, if you are looping to the old array's length, don't increment i by 2.
If i increases by 1 each time, we need to figure out how to map the old array's index i to the new array's index. It is quite simple: the new array's indices are just i*2 and i*2+1.
Now j seems redundant because it always holds the same value as i, so you can remove that.
This is the full code:
int length = array.length;
int[] newArray = new int[array.length*2];
for(int i = 0; i< length; i++){
if(array[i] % 2 == 0){
newArray[i*2] = (array[i]/2);
newArray[i*2+1] = newArray[i*2];
} else{
newArray[i*2] = (array[i]/2);
newArray[i*2+1] = (newArray[i*2] + 1);
}
}
return newArray;
Three mistakes:
j should be initialized outside the for-loop
we should use j to record the new value into the new array
we should increment j upon every iteration in 2 - and we should increment i only by 1 (since we're using j to insert two item while we use i to iterate the original array):
int j = 0;
for(int i = 0; i< length; i++){
if(array[i] % 2 == 0){
newArray[j] = newArray[j+1] = array[i]/2;
} else{
newArray[j] = array[i]/2 + 1;
newArray[j+1] = array[i]/2;
}
j += 2;
}
Note: giving a variable that holds an array the name "list" might create confusion!
for(int i = 0; i< length; i=i+2){
length is the length of the original array, so you iterate only over half of the values because you increase i by 2 each step.
if(array[i] % 2 == 0){
This should be
if(array[j] % 2 == 0){
And because you define j within your for-loop, array[j] always returns 18. Oh and you set the second element of the tuple to be the higher one while your comment in the code says the contrary should take place.
So a fixed version of your method would look like this:
public static int[] stretch(int[] array){
int length = array.length;
int[] newArray = new int[array.length*2];
int j = 0;
for(int i = 0; i< newArray.length; i=i+2){
if(array[j] % 2 == 0){
newArray[i] = (array[j]/2);
newArray[i+1] = newArray[i];
} else{
newArray[i+1] = (array[j]/2);
newArray[i] = (newArray[i+1] + 1);
}
j++;
}
return newArray;
}
Avoiding duplicate code:
public static int[] stretch(int[] array){
int[] newArray = new int[array.length*2];
int j = 0;
for(int i = 0; i< newArray.length; i=i+2){
int val = array[j];
newArray[i] = (val/2);
newArray[i+1] = newArray[i];
if(val % 2 != 0){
newArray[i]++;
}
j++;
}
return newArray;
}
Or using fancy streams:
public static int[] stretch(int[] array){
return Arrays.stream(array)
.flatMap(elem -> {
int half = elem / 2;
int otherHalf = half;
if (elem % 2 != 0) {
half++;
}
return IntStream.of(half, otherHalf);
}).toArray();
}
}
Suppose I have 2D array as follow:
int[][] temp={
{1,2,3,4},
{5,6,7,8},
{9,10,11,12}};
and i want to get sub-array start from X direction 1 to 2 and Y direction 1 to 2 i.e.
{6,7}
{10,11}
can anyone give me solution for above problem.
Here you are
int[][] temp = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };
int[][] a = new int[temp.length][];
for (int i = 0; i < temp.length; i++) {
a[i] = Arrays.copyOfRange(temp[i], 1, 3);
}
System.out.println(Arrays.deepToString(a));
output
[[2, 3], [6, 7], [10, 11]]
answering your question in comment if we want to access only [[6, 7], [10, 11]]
int[][] a = new int[2][];
for (int i = 1, j = 0; i < 3; i++, j++) {
a[j] = Arrays.copyOfRange(temp[i], 1, 3);
}
output
[[6, 7], [10, 11]]
As an example without using the Arrays class:
int[][] temp = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };
int[][] subArray = new int[temp.length][];
for (int i = 0; i < subArray.length; i++) {
subArray[i] = new int[2];
subArray[i][0] = temp[i][1];
subArray[i][1] = temp[i][2];
}
You can then access any part of subArray that you want. This will access the values [[6, 7], [10, 11]]:
for (int x = 1; x < 3; x++) {
System.out.println(subArray[x][0]);
System.out.println(subArray[x][1]);
}
[Additional] To address the modified question:
If you want to create a smaller array you can play around with the start and end points of the loop, and the indices accessed within the loop, for example this will create the array you ask for:
int[][] subArray = new int[2][];
for (int i = 1; i < temp.length; i++) {
subArray[i-1] = new int[2];
subArray[i-1][0] = temp[i][1];
subArray[i-1][1] = temp[i][2];
}
You could instantiate a new array and loop through the appropriate indices of the original array to initialize the subarray.
I'm trying to swap elements around in an ArrayList, but I don't know how to get the position of the items I want to sawp around because it's not a 2D array. I'm trying to use
Collections.swap(list, 3, 3-1);
But it doesn't work.
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 16; i++) {
list.add(i);
}
//System.out.println(list); //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
Collections.shuffle(list);
// System.out.println(list); //[11, 5, 10, 9, 7, 0, 6, 1, 3, 14, 2, 4, 15, 13, 12, 8]
int[][] a2 = new int[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j< 4; j++) {
a2[i][j] = list.get(i*4 + j);
// System.out.println(Arrays.deepToString(a2)); //[[11, 5, 10, 9], [7, 0, 6, 1], [3, 14, 2, 4], [15, 13, 12, 8]]
}
//System.out.println(Arrays.deepToString(a2)); //[[11, 5, 10, 9], [7, 0, 6, 1], [3, 14, 2, 4], [15, 13, 12, 8]]
// System.out.println();
}
for (int[] row : a2) {
System.out.print("[");
for (int i : row)
System.out.printf("%4d", i);
System.out.println("]");
}
Collections.swap(list, 3, 3-1); //this is where im stuck
}
I view this as a matrix, thats why I want to swap. How do co-ordinates in ArrayList work?
The output when you run this is:
[ 10 15 12 7]
[ 0 9 2 6]
[ 4 3 1 11]
[ 5 8 14 13]
I want to swap the elements up, down and sideways.
I'm not very sure I understand your question, but as for the remark:
"I don't know how to get the position of the items"
use ArrayList.add(int index, E element), this way you'll know that the element you just added is at poistion "index"
To swap element at i,j with element at k,l you could do
Collections.swap(list, i*4+j, k*4+l);
I'm assuming
You want to work with a matrix. That 4x4 square of numbers. Right?
You want to swap elements between positions in the matrix
You are using two ways of representation: List<Integer> and a int[][]
How to swap with array
Position (i, j) in your matrix is simply a2[i][j] so swaping between (i, j) and (k, l) is:
int aux = a2[k][l];
a2[k][l] = a[i][j]; // move value at first point to second point
a2[i][j] = aux; // move value at second poin tof irst point
How to swap with list
Position (i, j) in your list (because of the way you saved it) is 4*i+j. So the indexes for the same points in the list are (as #aioobe said):
4*i+j
4*k+l
So you'd need to do this:
Collections.swap(list, 4*i+j, 4*k+l);
where 4 is the size of each row.
Changing the approach
If what you want is simply using that list for shuffling (because all the rest of the handling doesn't need a list but a matrix) I suggest: use only List for that shuffling and forgetting. How?
// at this point you only have a matrix: your `int a2[][]`
// and the List will only exist for the shuffling
// lets say that WIDTH HEIGHT exist and are int constants
List<Integer> tempList = new ArrayList<Integer>(WIDTH*HEIGHT);
for (int i=0; i<HEIGHT; i++)
for (int j=0; j<WIDTH; j++)
list.add(a2[i][i]);
// now your integers are in the list and you can shuffle them
Collections.shuffle(tempList);
// now give the numbers back to the matrix (as on your previous code)
for (int i=0; i<HEIGHT; i++)
for (int j=0; j<WIDTH; j++)
a2[i][i] = list.get(i*WIDTH+j);
// and you can forget your tempList
Even better you could make this a method:
private void shuffle(int[][] matrix, int width, int height) {
List<Integer> tempList = new ArrayList<Integer>(width*height);
for (int i=0; i<height; i++)
for (int j=0; j<width; j++)
list.add(matrix[i][i]);
// now your integers are in the list and you can shuffle them
Collections.shuffle(tempList);
// now give the numbers back to the matrix (as on your previous code)
for (int i=0; i<height; i++)
for (int j=0; j<width; j++)
matrix[i][i] = tempList.get(i*width+j);
}
Notice that tempList exists only when method executes.
Even better: create two methods for converting from matrix representation to list and viceversa. That way you can use them in other places (and your code is more readable). By example, you could refactor you code to initialize the ordered list and calling that method to convert it into an int matrix.
private List<Integer> toList(int[][] matrix, int width, int height) {
List<Integer> list = new ArrayList<Integer>(width*height);
for (int i=0; i<height; i++)
for (int j=0; j<width; j++)
list.add(matrix[i][i]);
return list;
}
private int[][] toMatrix(List<Integer> list, int width, int height) {
// now give the numbers back to the matrix (as on your previous code)
int[][] result = new int[height][];
for (int i=0; i<height; i++) {
result[i] = new int[width];
for (int j=0; j<width; j++)
result[i][i] = list.get(i*width+j);
}
return result;
}
private int[][] shuffle(int[][] matrix, int width, int height) {
List<Integer> tempList = toList(matrix, width, height);
// now your integers are in the list and you can shuffle them
Collections.shuffle(tempList);
return toMatrix(tempList, width, height);
}
Notice toMatrix and shuffle methods now return a new matrix!!
Bottomline
It's useful to see your code as small blocks of code each one doing some clearly defined task. The you can maintain the abstractions in your code and create methods (or even classes ;-) with useful names as I tried to do. Of course, as all things it comes with practice. Good luck.
Disclaimer
It's not usual to write all the solution but in order to learn it can be useful. So it is. Hope it's useful!