Есть ли способ скопировать int [] в другой int [] без повторяющихся целых чисел?

Поскольку никакие библиотечные средства, такие как Set или Map, и соответствующие реализации не могут быть использованы в этой задаче, и повторное изобретение колес для повторной реализации этих классов кажется гораздо более сложным, чем необходимо, простое решение может быть основано на использовании объектной оболочки Integer для int, чтобы использовать null для отметки значений, которые должны быть удалены.

Итак, алгоритм будет следующим:

1. Преобразовать ввод int[] в Integer[]
2. Инициализируйте nullCount, используя вложенные циклы, обнаружите повторяющиеся значения, превышающие порог, и установите их на null вместе с увеличением nullCount
3. Создайте массив результатов, скопируйте ненулевые значения и верните его.

Пример реализации:

public static int[] deleteNth(int[] elements, int maxOccurrences) {
    Integer[] arr = new Integer[elements.length];
    int i = 0;
    for (Integer x : elements) {
        arr[i++] = x;
    }
    
    int nullCount = 0;
    for (i = 0; i < arr.length; i++) {
        Integer x = arr[i];
        if (null == x) {
            continue;
        }
        int cnt = 1;
        for (int j = i + 1; j < arr.length; j++) {
            Integer y = arr[j];
            if (null == y) {
                continue;
            }
            if (x.equals(y)) {
                cnt++;
                if (cnt > maxOccurrences) {
                    arr[j] = null;
                    nullCount++;
                }
            }
        }
    }
    int[] result = new int[arr.length - nullCount];
    i = 0;
    for (int j = 0; j < arr.length; j++) {
        Integer x = arr[j];
        if (null != x) {
            result[i++] = x;
        }
    }
    return result;
}

Тест и вывод:

System.out.println(Arrays.toString(deleteNth(new int[] {20,37,20,21}, 1))); // return [20,37,21]
System.out.println(Arrays.toString(deleteNth(new int[] {1,1,3,3,7,2,2,2,2}, 3))); // return [1, 1, 3, 3, 7, 2, 2, 2]

Выход:

[20, 37, 21]
[1, 1, 3, 3, 7, 2, 2, 2]

Более быстрая версия может использовать дополнительный логический массив для отслеживания повторяющихся значений, чтобы их можно было пропустить во вложенном цикле.

Решение на основе потока (только для справки и сравнения) будет таким:

• подготовить начальную карту с элементами массива в качестве ключей, а значение - список индексов, используя Collectors.groupingBy
• переназначить записи в исходной карте: index -> key (элемент массива) с помощью flatMap и Stream::limit для соблюдения порогового значения
• отсортировать новые записи по индексу
• получить значения и собрать их в массив

public static int[] deleteNth(int[] arr, int threshold) {
    return IntStream
            .range(0, arr.length)
            .boxed()
            .collect(Collectors.groupingBy(
                i -> arr[i], 
                Collectors.mapping(i -> i, Collectors.toList())
            ))
            .entrySet()
            .stream()
            .flatMap(e -> e.getValue().stream()
                    .limit(threshold)
                    .map(ix -> Map.entry(ix, e.getKey())) // Map.entry since Java 9
            )
            .sorted(Map.Entry.comparingByKey())
            .mapToInt(Map.Entry::getValue)
            .toArray();
}

Вы можете сделать это с помощью HashMap, чтобы отслеживать количество появлений каждого числа:

public static int[] deleteNth(int[] elements, int maxOccurrences){
    // get number of occurrences of each number in elements less than max
    Map<Integer,Integer> occurences = new HashMap<>();
    for(int element : elements) {
        int count = occurences.containsKey(element) ? occurences.get(element) : 0;
        if(count < maxOccurrences) occurences.put(element, count+1);
    }
    // calculate total size of array to return
    int size = 0;
    for(int numberOccurences : occurences.values()) size += numberOccurences;
    int[] res = new int[size];
    // clear map to reuse it
    occurences.clear();
    // reiterate over elements array
    int i = 0;
    for(int element : elements) {
        int count = occurences.containsKey(element) ? occurences.get(element) : 0;
        // add number to resulting array if its count in it is still less than max
        if(count < maxOccurrences) res[i++] = element;
        occurences.put(element, count+1);
    }
    return res;
}