CODEWITHSUNDEEP
javaarrays
Rayden
Rayden

Reputation: 160

Creating an Array with the same numbers from an old one but without repetitions

So I created an array with random numbers, i printed and counted the repeated numbers, now I just have to create a new array with the same numbers from the first array but without any repetitions. Can't use ArrayList by the way.

What I have is.

public static void main(String[] args) {

    Random generator = new Random();
    int aR[]= new int[20];

    for(int i=0;i<aR.length;i++){
        int number=generator.nextInt(51);
        aR[i]=number;
        System.out.print(aR[i]+" ");

    }
    System.out.println();
    System.out.println();
    int countRep=0;
    for(int i=0;i<aR.length;i++){
        for(int j=i+1;j<aR.length-1;j++){
            if(aR[i]==aR[j]){
                countRep++;
                System.out.println(aR[i]+" "+aR[j]);
                break;
            }
        }
    }   
    System.out.println();
    System.out.println("Repeated numbers:  "+countRep);

    int newaR[]= new int[aR.length - countRep];




}

Can someone help?

EDIT: Can't really use HashSet either. Also the new array needs to have the correct size.

Upvotes: 1

Views: 114

Answers (4)

Jean Logeart
Jean Logeart

Reputation: 53819

Try:

Set<Integer> insertedNumbers = new HashSet<>(newaR.length);
int index = 0;
for(int i = 0 ; i < aR.length ; ++i) {
    if(!insertedNumbers.contains(aR[i])) {
        newaR[index++] = aR[i];
    }
    insertedNumbers.add(aR[i]);
}

Upvotes: 0

Sean Reilly
Sean Reilly

Reputation: 21836

This sounds like a homework question, and if it is, the technique that you should pick up on is to sort the array first.

Once the array is sorted, duplicate entries will be adjacent to each other, so they are trivial to find:

int[] numbers = //obtain this however you normally would
java.util.Arrays.sort(numbers);

//find out how big the array is
int sizeWithoutDuplicates = 1; //there will be at least one entry
int lastValue = numbers[0];

//a number in the array is unique (or a first duplicate)
//if it's not equal to the number before it
for(int i = 1; i < numbers.length; i++) {
    if (numbers[i] != lastValue) {
        lastValue = i;
        sizeWithoutDuplicates++;
    }
}

//now we know how many results we have, and we can allocate the result array
int[] result = new int[sizeWithoutDuplicates];

//fill the result array
int positionInResult = 1; //there will be at least one entry
result[0] = numbers[0];
lastValue = numbers[0];

for(int i = 1; i < numbers.length; i++) {
    if (numbers[i] != lastValue) {
        lastValue = i;
        result[positionInResult] = i;
        positionInResult++;
    }
}

//result contains the unique numbers

Not being able to use a list means that we have to figure out how big the array is going to be in a separate pass — if we could use an ArrayList to collect the results we would have only needed a single loop through the array of numbers.

This approach is faster (O(n log n) vs O (n^2)) than a doubly-nested loop through the array to find duplicates. Using a HashSet would be faster still, at O(n).

Upvotes: 0

Marco13
Marco13

Reputation: 54639

One possible approach is to walk through the array, and for each value, compute the index at which it again occurs in the array (which is -1 if the number does not occur again). The number of values which do not occur again is the number of unique values. Then collect all values from the array for which the corresponding index is -1. 

import java.util.Arrays;
import java.util.Random;

public class UniqueIntTest
{
    public static void main(String[] args)
    {
        int array[] = createRandomArray(20, 0, 51);
        System.out.println("Array " + Arrays.toString(array));

        int result[] = computeUnique(array);
        System.out.println("Result " + Arrays.toString(result));
    }

    private static int[] createRandomArray(int size, int min, int max)
    {
        Random random = new Random(1);
        int array[] = new int[size];
        for (int i = 0; i < size; i++)
        {
            array[i] = min + random.nextInt(max - min);
        }
        return array;
    }

    private static int[] computeUnique(int array[])
    {
        int indices[] = new int[array.length];
        int unique = computeIndices(array, indices);
        int result[] = new int[unique];
        int index = 0;
        for (int i = 0; i < array.length; i++)
        {
            if (indices[i] == -1)
            {
                result[index] = array[i];
                index++;
            }
        }
        return result;
    }

    private static int computeIndices(int array[], int indices[])
    {
        int unique = 0;
        for (int i = 0; i < array.length; i++)
        {
            int value = array[i];
            int index = indexOf(array, value, i + 1);
            if (index == -1)
            {
                unique++;
            }
            indices[i] = index;
        }
        return unique;
    }

    private static int indexOf(int array[], int value, int offset)
    {
        for (int i = offset; i < array.length; i++)
        {
            if (array[i] == value)
            {
                return i;
            }
        }
        return -1;
    }
}

Upvotes: 0

skiwi
skiwi

Reputation: 69259

Using Java 8 and streams you can do the following:

int[] array = new int[1024];
//fill array
int[] arrayWithoutDuplicates = Arrays.stream(array)
        .distinct()
        .toArray();

This will:

  1. Turn your int[] into an IntStream.
  2. Filter out all duplicates, so retaining distinct elements.
  3. Save it in a new array of type int[].

Upvotes: 1

Related Questions