Related
I need to find the unique elements in two different arrays.
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
boolean contains = false;
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if(!contains){
list.add(arr1[i]);
}
else{
contains = false;
}
}
System.out.println(list);
}
But here I'm getting [1,2,3,4] as output. But the expected output is [1,2,3,4,7,8]. I'm not sure what I'm doing wrong here. And I need it in a traditional way. I don't want to use any inbuilt methods to acheive this.
Note: I feel it is not a duplicate because, the solution provided is not finding the unique elements on two arrays.
This solves your problem:
public static void main(String[] args) {
// Make the two lists
List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 4, 5, 6);
List<Integer> list2 = Arrays.asList(5, 6, 7, 8);
// Prepare a union
Set<Integer> union = new HashSet<Integer>(list1);
union.addAll(list2);
// Prepare an intersection
Set<Integer> intersection = new HashSet<Integer>(list1);
intersection.retainAll(list2);
// Subtract the intersection from the union
union.removeAll(intersection);
// Print the result
for (Integer n : union) {
System.out.println(n);
}
}
Using HashSet, for educative purposes, which could be very fast if lists are big:
public static void main(final String[] args) {
final List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
final Set<Integer> set1 = new HashSet<>(list1);
final List<Integer> list2 = new ArrayList<>(Arrays.asList(5, 6, 7, 8));
final Set<Integer> set2 = new HashSet<>(list2);
set1.retainAll(set2); // Keep union.
// Remove union to keep only unique items.
list1.removeAll(set1);
list2.removeAll(set1);
// Accumulate unique items.
list1.addAll(list2);
System.out.println(new HashSet<>(list1));
// [1,2,3,4,7,8]
}
Actually, there is a more simple solution using Java TreeSet.java TreeSet doesn't contain duplicate elements. Therefore, all you have to do is create a TreeSet and adding all elements to it. It also keeps the natural (sorted) Order.
public static void main(String[] args) {
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
TreeSet<Integer> set = new TreeSet<>();
for (int i:arr1) {
set.add(i);
}
for (int i:arr2) {
set.add(i);
}
System.out.println(set);
}
output: [1, 2, 3, 4, 5, 6, 7, 8]
If you are using java 8 i would suggest this solution :
public static void main(String[] args) {
int[] arr1 = new int[]{1, 2, 3, 4, 5, 6};
int[] arr2 = new int[]{5, 6, 7, 8};
List<Integer> list = new ArrayList<>();//create a list or Integers
//add the values of the two arrays in this list
list.addAll(Arrays.stream(arr1).boxed().collect(Collectors.toList()));
list.addAll(Arrays.stream(arr2).boxed().collect(Collectors.toList()));
//we need a set to check if the element is duplicate or not
Set<Integer> set = new HashSet();
List<Integer> result = new ArrayList<>(list);
//loop throw your list, and check if you can add this element to the set
// or not, if not this mean it is duplicate you have to remove it from your list
list.stream().filter((i) -> (!set.add(i))).forEachOrdered((i) -> {
result.removeAll(Collections.singleton(i));
});
System.out.println(result);
}
Output
[1, 2, 3, 4, 7, 8]
To solve this problem, i based to this posts : Identify duplicates in a List
And here another streaming (Java 8) solution. Using streams one should avoid modifying stream outside variables.
The idea here is to union the lists and then to count the occurance of each item. All items with count 1 are only in one list. Those are collected to the result list.
//using here Integer instead of atomic int, simplifies the union.
Integer[] arr1 = new Integer[]{1, 2, 3, 4, 5, 6};
Integer[] arr2 = new Integer[]{5, 6, 7, 8};
List<Integer> list = new ArrayList<>();
list.addAll(new HashSet<>(Arrays.asList(arr1)));
list.addAll(new HashSet<>(Arrays.asList(arr2)));
System.out.println(
list.stream()
.collect(groupingBy(identity(), counting()))
.entrySet().stream()
.filter(i -> i.getValue() == 1)
.map(i -> i.getKey())
.collect(toList())
);
EDIT:
Changed this answer to adress multiples within one list problem.
You have to add a second for-loop to check if elements of arr2 are in arr1 cause you are only checking if elements of arr1 are in arr2
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
boolean contains = false;
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if(!contains){
list.add(arr1[i]);
}
else{
contains = false;
}
}
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr1.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if(!contains){
list.add(arr2[i]);
}
else{
contains = false;
}
}
System.out.println(list);
}
A more optimized way would be using list iterators.
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
List<Integer> list1 = IntStream.of(arr1).boxed().collect(Collectors.toList());
List<Integer> list2 = IntStream.of(arr2).boxed().collect(Collectors.toList());
Iterator list1Iter = list1.iterator();
boolean contains = false;
while(list1Iter.hasNext()) {
int val1 = (int)list1Iter.next();
Iterator list2Iter = list2.iterator();
while(list2Iter.hasNext()) {
int val2 = (int)list2Iter.next();
if( val1 == val2) {
// remove duplicate
list1Iter.remove();
list2Iter.remove();
}
}
}
list1.addAll(list2);
for( Object val : list1) {
System.out.println(val);
}
If you are using Java 8, you can do the following :
List resultList = list1.stream().filter(nbr -> !list2.contains(nbr)).collect(Collectors.toList());
resultList.addAll(list2.stream().filter(nbr -> !list1.contains(nbr)).collect(Collectors.toList()));
import java.util.Scanner;
import java.io.*;
public class CandidateCode{
static int count =0;
public static void main(String args[])
{
int n,n1;
Scanner sc=new Scanner(System.in);
System.out.println("Enter no. of elements for first array");
n=sc.nextInt();
int arr[]=new int[n];
System.out.println("Enter the elements of first array");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt();
}
System.out.println("Enter no. of elements for second array");
n1=sc.nextInt();
int arr1[]=new int[n1];
System.out.println("Enter the elements of second array");
for(int i=0;i<n1;i++)
{
arr1[i]=sc.nextInt();
}
unique_ele(arr,arr1);
unique_ele(arr1,arr);
System.out.println("The number of unique elements are");
System.out.println(count);
}
public static int unique_ele(int arr2[],int arr3[])
{
boolean contains = false;
for(int i=0;i<arr2.length;i++)
{
for(int j=0;j<arr3.length;j++)
{
if (arr2[i] == arr3[j]) {
contains = true;
break;
}
}
if(!contains){
count++;
}
else{
contains = false;
}
}
return count;
}
}
public static ArrayList<Integer> findUniqueAmongLists(ArrayList<Integer> a, ArrayList<Integer> b){
ArrayList<Integer> uniqueArr = new ArrayList<>();
ArrayList<Integer> duplicateArr = new ArrayList<>();
for(int i=0; i< a.size(); i++){
if(!duplicateArr.contains(a.get(i))){
uniqueArr.add(a.get(i));
duplicateArr.add(a.get(i));
}
else{
uniqueArr.remove(a.get(i));
}
}
for(int j=0; j< b.size(); j++){
if(!duplicateArr.contains(b.get(j))){
uniqueArr.add(b.get(j));
duplicateArr.add(b.get(j));
}
else{
uniqueArr.remove(b.get(j));
}
}
return uniqueArr;
}
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
boolean contains = false;
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if (!contains) {
list.add(arr1[i]);
} else {
contains = false;
}
}
for (int j = 0; j < arr2.length; j++) {
for (int k = 0; k < arr1.length; k++) {
if (arr2[j] == arr1[k]) {
contains = true;
break;
}
}
if (!contains) {
list.add(arr2[j]);
} else {
contains = false;
}
}
System.out.println(list);
}
public class UniqueElementFrom2array {
public static void main(String[] args)
{
int[] a= {1,2,3,4,5,6,7};
int[] b= {1,2,3,8,9,4,10,11,12};
int[] c=new int[a.length+b.length];
int len1=a.length;
int len2=b.length;
System.arraycopy(a, 0, c, 0, len1);
System.arraycopy(b, 0, c, len1,len2);
Arrays.sort(c);
System.out.println(Arrays.toString(c));
Set s=new HashSet();
for(int i=0;i<c.length;i++)
{
if(!s.contains(c[i]))
{
s.add(c[i]);
System.out.print(c[i] + " ");
}
}
}
}
A complete code using TreeSet in java.
import java.util.*;
import java.util.Scanner;
public class Main
{
public static void uniqElements(int arr1[], int arr2[],int n){
TreeSet<Integer> set1 = new TreeSet<>();
TreeSet<Integer> set2 = new TreeSet<>();
TreeSet<Integer> set3 = new TreeSet<>();
TreeSet<Integer> set4 = new TreeSet<>();
for (int i:arr1) {
set1.add(i);
set3.add(i);
}
for (int i:arr2) {
set2.add(i);
set4.add(i);
}
set3.addAll(set4);
set1.retainAll(set2);
set3.removeAll(set1);
System.out.println(set3);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr1 = new int[n];
int[] arr2 = new int[n];
for(int i =0;i<n;i++){
arr1[i]=sc.nextInt();
}
for(int i =0;i<n;i++){
arr2[i]=sc.nextInt();
}
uniqElements(arr1,arr2,n);
}
}
public static void main(String[] args) {
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
System.out.println(Stream.concat(Arrays.stream(arr1).boxed(), Arrays.stream(arr2).boxed()).distinct().collect(Collectors.toList()));
}
Merge all array.
Remove elements at merged array that contains second array value.
import java.util.TreeSet;
public class ArrayUnique {
public static void getUniqueElements(int arr1[], int arr2[]){
// Merge all array with treeset
// it will remove duplicate element
TreeSet<Integer> all= new TreeSet<>();
TreeSet<Integer> secondArray= new TreeSet<>();
for(int i:arr1){
all.add(i);
}
for(int i:arr2){
all.add(i);
secondArray.add(i);
}
//Delete element that contains secondArray value
all.removeAll(secondArray);
//print to console
System.out.println(all);
}
public static void main(String[] args) {
int[] arr1 = {1,2,3,4};
int[] arr2 = {1,3,5,10,16};
getUniqueElements(arr1,arr2);
//Result: [2,4]
}
}
Try this:
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
List<Integer> list = Stream.concat(Arrays.stream(arr1).boxed(), Arrays.stream(arr2).boxed()).distinct().collect(Collectors.toList());
System.out.println(list);
}
hope this will resolve issue.
This will give you the unique values from two arrays;
public static String[] uniqueArr(String[] names1, String[]
names2)
{
Set<String> set = new HashSet<>(new
LinkedList<>(Stream.of(names1,
names2).flatMap(Stream::of).collect(Collectors.toList())));
String[] arr = new String[set.size()];
set.toArray(arr);
return arr;
}
I have an ArrayList of arrays and i want to change the value of 5
List<int[]> list = new ArrayList<int[]>();
int[] arr1 = {2,4,6};
int[] arr2 = {1,3,5};
list.add(arr1);
list.add(arr2);
for (int[] ss : list)
{
for(int sd : ss)
{
//System.out.println(sd);
if(sd == 5)
{
System.out.println("Yes");
//change 5 to 12
//list.set(list.indexOf(5), 12);
}
}
System.out.println(Arrays.toString(ss));
}
[2, 4, 6] [1, 3, 5]
I want to change 5 to 12
Change your code to :
public static void main(String args[]) {
List<int[]> list = new ArrayList<int[]>();
int[] arr1 = { 2, 4, 6 };
int[] arr2 = { 1, 3, 5 };
list.add(arr1);
list.add(arr2);
for (int[] ss : list) {
for (int i = 0; i < ss.length; i++) {
// System.out.println(sd);
if (ss[i] == 5) { // if current value is 5
System.out.println("Yes");
ss[i] = 12; // set it to 12
}
}
System.out.println(Arrays.toString(ss));
}
}
This question already has answers here:
Printing distinct integers in an array
(8 answers)
Closed 8 years ago.
A program in Java that should count the no. of occurrence and display the most repeated first no. followed by others. for eg. input: 223331544 output: 32415
class Example {
public static void main(String a[]) {
int[] arr = {5, 2, 7, 2, 4, 7, 8, 2, 3};
for (int i = 0; i < arr.length; i++) {
boolean isDistinct = false;
for (int j = 0; j < i; j++) {
if (arr[i] == arr[j]) {
isDistinct = true;
break;
}
}
if (!isDistinct) {
System.out.print(arr[i] + " ");
}
}
}
}
The following code will print out distinct numbers:
import java.util.*;
public class Example {
public static void main(String[] args) {
Integer[] arr = {5, 2, 7, 2, 4, 7, 8, 2, 3};
Set<Integer> s = new HashSet<Integer>(Arrays.asList(arr));
System.out.println(s);
}
}
But this is not the answer. The requirement is to remove all the numbers that appear more than once. To do that, make a Map that containts the number as key and occurrence as value. While put the numbers into the Map, if the number is already exists, +1 the occurrence. So the code is like the following:
import java.util.*;
public class Test {
public static void main(String[] args) {
int[] arr = { 5, 2, 7, 2, 4, 7, 8, 2, 3 };
Map<Integer, Integer> m = new HashMap<Integer, Integer>();
for (int i : arr) {
if (m.get(i) == null)
m.put(i, 1);
else
m.put(i, m.get(i) + 1);
}
for (Map.Entry<Integer, Integer> e : m.entrySet()) {
if (e.getValue() == 1)
System.out.print(e.getKey() + " ");
}
}
}
Try this solution for your problem.
import java.util.*;
class Hello
{
public static void main(String[] args)
{
int[] arr = {5, 2, 7, 2, 4, 7, 8, 2, 3};
Set<Integer> set = new HashSet<Integer>();
for(int i = 0; i < arr.length; i++){
set.add(arr[i]);
}
//now if you will iterate through this set, it will contain only unique values.
Iterator it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
I thinkd Set already can help u do this, advanced Link.http://docs.oracle.com/javase/7/docs/api/java/util/Set.html
You can try in this way
public static void main(String a[]) {
int[] arr = {1,2,2,3,4,5,5};
for (int i = 0; i < arr.length; i++) {
boolean isDistinct = false;
for (int j = 0; j < arr.length; j++) {
if (arr[i] == arr[j] && i!=j) {
isDistinct = true;
break;
}
}
if (!isDistinct) {
System.out.print(arr[i] + " ");
}
}
}
Out put:
1 3 4
Use set
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class NonDuplicateElement{
public static void main(String []args){
int[] arr = {5,2,7,2,4,7,8,2,3};
Set<Integer>set = new HashSet<Integer>();
Set<Integer>remset = new HashSet<Integer>();
for(int i=0;i<arr.length;i++)
{
if(set.contains(arr[i]))
{
remset.add(arr[i]);
}
else
{
set.add(arr[i]);
}
}
Iterator<Integer> iter = remset.iterator();
while(iter.hasNext())
{
Integer element = iter.next();
if(set.contains(element))
{
set.remove(element);
}
}
iter = set.iterator();
while(iter.hasNext())
{
System.out.println(iter.next()+ "\t");
}
}
}
Output : 3 4 5 8
I need to efficiently sort through 4 arrays and return 2 results.
The first result will contain all numbers that exist in the arrays.
The second result will contain, all occurrences of each number in the result
int[] a = [1,2,3,4,5];
int[] b = [1,2,3,4,5,6];
int[] c = [1,3,7];
int[] d = [2,3,4,8,9,10];
int[] result1 = [1,2,3,4,5,6,7,8,9,10];
int[] result2 = [1,1,1,2,2,2,3,3,3,3,4,4,4,5,5,6,7,8,9,10];
Step 1: Combine all the arrays
Step 2: Sort arrays using Arrays.sort(array);
Step 3: Remove the duplicates.
int[] a = {1,2,3,4,5};
int[] b = {1,2,3,4,5,6};
int[] c = {1,3,7};
int[] d = {2,3,4,8,9,10};
int[] resultArray1 = new int[a.length+b.length+c.length+d.length];
int arrayIndex = 0;
for (int i=0; i< a.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = a[i];
}
for (int i=0; i< b.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = b[i];
}
for (int i=0; i< c.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = c[i];
}
for (int i=0; i< d.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = d[i];
}
// Sorting Arrays
System.out.println("Array before Sort"+Arrays.toString(resultArray1));
Arrays.sort(resultArray1);
System.out.println("Array after Sort"+Arrays.toString(resultArray1));
// Removing duplicates
Set<String> set = new HashSet<String>();
for (int i = 0; i < resultArray1.length; i++) {
set.add(""+resultArray1[i]); // To convert to string
}
String[] uniqueStringArray = set.toArray(new String[set.size()]); ;
int [] uniqueIntArray = new int [uniqueStringArray.length];
// Converting string array to int array
for(int i=0;i<uniqueStringArray.length;i++)
{
uniqueIntArray[i]= Integer.parseInt(uniqueStringArray[i]);
}
Arrays.sort(uniqueIntArray);
System.out.println("Unique Array after Sort"+Arrays.toString(uniqueIntArray));
Output:
Array before Sort[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 1, 3, 7, 2, 3, 4, 8, 9, 10]
Array after Sort[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 8, 9, 10]
Unique Array after Sort[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Combine all 4 arrays in 1 array
sort Array
Remove Dublicate from array
import java.util.Vector;
class sort
{
public static void main(String args[])
{
int[] a = {1,2,3,4,5};
int[] b = {1,2,3,4,5,6};
int[] c = {1,3,7};
int[] d = {2,3,4,8,9,10};
int[] s = combine(a,b,c,d); //concate array using concate function
int[] sort = sort(s);//sort array using sort function
//SORTING ARRAY
System.out.print("ARRAY AFTER SORT ");
System.out.print("[");
for(int i=0;i<sort.length;i++)
{
if(i==sort.length-1)
System.out.print(sort[i]);
else
System.out.print(sort[i]+",");
}
System.out.println("]\n");
//REMOVE DUPLICATE
int[] removedups=removedups(sort);// Remove Duplicate item from array using removedups
System.out.print("ARRAY REMOVE DUPLICATE ");
System.out.print("[");
for(int i=0;i<removedups.length;i++)
{
if(i==removedups.length-1)
System.out.print(removedups[i]);
else
System.out.print(removedups[i]+",");
}
System.out.print("]");
}
public static int[] combine(int a[],int b[],int c[],int d[])//combine array
{
int sort []=new int[a.length+b.length+c.length+d.length];
int j=0;
for(int i=0;i<a.length;i++)
{
sort[j]=a[i];
j++;
}
for(int i=0;i<b.length;i++)
{
sort[j]=b[i];
j++;
}
for(int i=0;i<c.length;i++)
{
sort[j]=c[i];
j++;
}
for(int i=0;i<d.length;i++)
{
sort[j]=d[i];
j++;
}
return sort;
}
public static int[] sort(int s[]) // sort array
{
int temp;
for(int i=0;i<s.length;i++)
{
for(int j=i+1;j<s.length-1;j++)
{
if(s[i]>s[j])
{
temp=s[i];
s[i]=s[j];
s[j]=temp;
}
}
}
return s;
}
public static int[] removedups(int s[])//remove dups from sorted array
{
Vector array=new Vector();
int l=0;
for(int i=0;i<s.length-1;i++)
{
if(s[i]!=s[i+1])
{
array.add(s[i]);
l++;
}
}
int[] temp=new int[array.size()];
for(int j=0;j<temp.length;j++)
{
temp[j]=Integer.parseInt(""+array.get(j));
}
return temp ;
}
}//end the program
Simpliest way is use sort and HashSet
public class SortClass {
public static void main(String[] args) {
//Define imput data
int[] a = {1, 2, 3, 4, 5};
int[] b = {1, 2, 3, 4, 5, 6};
int[] c = {1, 3, 7};
int[] d = {2, 3, 4, 8, 9, 10};
//Actual algorithm
List<Integer> all = new ArrayList<Integer>();
all.addAll(toList(a));
all.addAll(toList(b));
all.addAll(toList(c));
all.addAll(toList(d));
Collections.sort(all);
TreeSet<Integer> set = new TreeSet<Integer>();
set.addAll(all);
int[] sorted = toIntArray(all);
int[] sortedUniq = toIntArray(set);
//Output result
System.out.println("Sorted: " + Arrays.toString(sorted));
System.out.println("Sorted uniq: " + Arrays.toString(sortedUniq));
}
// We need pair of method to convert between `int[]` and `Collection<Integer>`
private static int[] toIntArray(Collection<Integer> all) {
int[] ints = new int[all.size()];
int i =0;
for (int val : all) {
ints[i] = val;
i++;
}
return ints;
}
private static Collection<? extends Integer> toList(int[] ints) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i : ints) {
list.add(i);
}
return list;
}
}
But if performance is critical we can utilize the fact that input arrays already sorted and us merge sort:
public class SortClass {
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 5};
int[] b = {1, 2, 3, 4, 5, 6};
int[] c = {1, 3, 7};
int[] d = {2, 3, 4, 8, 9, 10};
//Prepare data structure
List<ArrayTail> all = new ArrayList<ArrayTail>();
add(all, new ArrayTail(a));
add(all, new ArrayTail(b));
add(all, new ArrayTail(c));
add(all, new ArrayTail(d));
int[] sorted = sort(all);
int[] sortedUniq = getUniq(sorted);
System.out.println("Sorted: " + Arrays.toString(sorted));
System.out.println("Sorted uniq: " + Arrays.toString(sortedUniq));
}
private static int[] getUniq(int[] sorted) {
Collection<Integer> result = new ArrayList<Integer>();
int current = sorted[0];
result.add(current);
for (int i : sorted){
if(i != current){
current = i;
result.add(i);
}
}
return toIntArray(result);
}
private static int[] sort(List<ArrayTail> all) {
int totalLength = 0;
for (ArrayTail tail : all){
totalLength+=tail.size();
}
int[] result = new int[totalLength];
int pos = 0;
while(!all.isEmpty()){
//Take smallest value from smallest array
ArrayTail smallest = all.get(0);
result[pos] = smallest.take();
pos++;
// remove array if no more elements in it
if(smallest.size() ==0){
all.remove(0);
} else {
// ensure that first element steel smallest
sortFirstElement(all);
}
}
return result;
}
// This is actually on step of bubble sort, but it
// works because all other list except may be first already sorted
private static void sortFirstElement(List<ArrayTail> all) {
for (int i = 0; i < all.size()-1; i++) {
if(all.get(i).get() > all.get(i+1).get()){
Collections.swap(all, i, i + 1);
} else {
break;
}
}
}
private static void add(List<ArrayTail> all, ArrayTail arrayTail) {
// all sorted here
all.add(0, arrayTail);
sortFirstElement(all);
// all sorted here, again
}
private static int[] toIntArray(Collection<Integer> all) {
int[] ints = new int[all.size()];
int i =0;
for (int val : all) {
ints[i] = val;
i++;
}
return ints;
}
// Simpl data structure representing tail of array
private static class ArrayTail {
private final int[] arr;
private int pos;
public ArrayTail(int[] arr) {
this.arr = arr;
this.pos = 0;
}
public int size() {
return arr.length - pos;
}
public int take() {
return arr[pos++];
}
public int get() {
return arr[pos];
}
}
}
As you can see code become more complex but possible work faster.
PS: fun thing is that bubble sort can be used in real life :)
TRY Using merge sort algorithm. wikipedia page here
For result 1, dump the contents of your 4 lists into a TreeSet. This will sort and remove duplicates from the set at the same time. Then get the array of the set.
For result 2, use array copy to copy all the numbers into 1 array and then sort that array using Arrays.sort(...). There is no need to try to merge them on your own due to the nature of the sorting algorithm which is O(nlog(n)). Quadrupling the size results in a multiplying factor of only 2.
I'm working on a program that returns the largest number that is in both arrays. The following is some expectations:
maxInCommon({1, 2, 3, 4, 5, 6, 7, 8}, {-1, -2, 9, 5}) → 5
maxInCommon({1}, {}) → 0
maxInCommon({-1, -2}, {-2, -3, -4}) → -2
My code works for many situations, but not for this one:
asn9_maxInCommon({-10, -11}, {-10, -11, -12}) → -10
Instead of yielding "-10", my program returns a "-11". The following is my UPDATED code:
public int maxInCommon(int[] nums1, int[] nums2) {
int numInCommon = 0;
Arrays.sort(nums1);
Arrays.sort(nums2);
ArrayList<Integer> nums1List = new ArrayList();
ArrayList<Integer> nums2List = new ArrayList();
int number = 0;
int number1 = 0;
for (int a = 0; a < nums1.length; a++)
{
number = nums1[a];
nums1List.add(number);
}
for (int b = 0; b < nums2.length; b++)
{
number1 = nums2[b];
nums2List.add(number1);
}
for (int c = (nums1List.size() - 1); c > - 1; c--)
{
for (int d = (nums2List.size() - 1); d > -1; d--)
{
if (nums1List.get(c) == nums2List.get(d))
numInCommon = nums1List.get(c);
}
}
return numInCommon;
}
I thought the logic of the code should be fine, but it still does not work. Some other cases for which the logic fails are:
maxInCommon({0,2}, {0,1,2}) → 2
My code yields "0" instead.
maxInCommon({1, 2, 3, 4, 5, 6, 7, 8}, {-1, -2, 9, 6, 7, 8, 9}) → 8
My code yields "6" instead.
The purpose of the ArrayLists is to somehow remove an element after each comparison. I have not used that feature here.
the following works:
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
int[] array2 = new int[]{-1, -2, 9, 5};
System.out.println(getCommonMax(array1, array2));
}
static int getCommonMax(int[] array1, int[] array2) {
int commonMax = 0;
Arrays.sort(array1);
for(int i = array1.length -1; i > -1; i--) {
if(contains(array2, array1[i])) {
commonMax = array1[i];
break;
}
}
return commonMax;
}
static boolean contains(int[] array, int i) {
boolean contains = false;
for(int i2 : array) {
if(i2 == i) {
contains = true;
break;
}
}
return contains;
}
}
If your code actually works, you could change this part:
if (max1 == nums2[b])
numInCommon = max1;
to
if (max1 == nums2[b] && numInCommon < max1) {
numInCommon = max1;
}
that should do it
The problem is that you have max1 = nums1[a]; in the outer for loop and then simply assign max1 to numInCommon if max1 is contained within the second array. max1 is always going to be the last element in the first array, the if statement immediately after that is pointless.
Therefore the reason you get -11 as the largest number in common is because -11 is the last element in the first array, which is also in the second - that's what your function is computing.
You should instead be comparing if max1 is greater than the largest number in common, and remove the unnecessary if statement from the outer for loop. A better name for max1 is temp, and it's an unnecessary variable when you can just access nums1[a] from the inner for loop.
EDIT: Didn't see the homework tag, try and make the changes to the code yourself using the above information.
You should also probably have some way of indicating if there are no numbers in common between the two arrays.
Now its working fine.
package test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class test {
public static void main(String[] args) {
int a[] = {-1,-2};
int b[] = {-2,-3,-4};
try{
System.out.println(getMaxCommon(a,b));
}catch(Exception e){
System.out.println("Not found common no");
}
}
public static int getMaxCommon(int[] arr1,int[] arr2) {
int arr1Temp[] = arr1.clone();
int arr2Temp[] = arr2.clone();
Arrays.sort(arr1Temp);
Arrays.sort(arr2Temp);
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();
for(int i=0;i<arr1Temp.length;i++){
list1.add(arr1Temp[i]);
}
for(int i=0;i<arr2Temp.length;i++){
list2.add(arr2Temp[i]);
}
if(arr1Temp.length < arr2Temp.length){
for(int i=arr1Temp.length-1;i>=0;i--){
if(list2.contains(arr1Temp[i])){
return arr1Temp[i];
}
}
}else{
for(int i=arr2Temp.length-1;i>=0;i--){
System.out.println();
if(list1.contains(arr2Temp[i])){
return arr2Temp[i];
}
}
}
return (Integer) null;
}
}