Как запросить диапазон в массиве и вывести [xth, x + yth] наиболее часто встречающиеся целые числа в массиве?

Question

Предположим некоторый произвольный массив целых чисел, например [3, 1, 1, 1, 13, 13, 13, 13, 13, 8, 8, 8, 8, 8, 8] (порядок не имеет значения, я простоупорядочил их так, чтобы их было легче читать)

Как я могу создать метод, который при запросе диапазона, скажем, [2,4], печатает 2-е наиболее, 3-е наиболее и 4-е наиболее часто встречающиеся целые числав данном массиве? В этом примере массива он будет печататься в порядке частот: Значение: 13. Частота: 5 Значение: 1. Частота: 3 Значение: 3. Частота: 1

, отмечая, как целое число 8 является наиболее частымцелое число, а 3 - четвертое по частоте целое число.

Answer 1

Вы хотите сначала заполнить карту всеми целыми числами, где каждое целое число является ключом, а частота - значением. Если вы встречаете существующее целое число, вы увеличиваете частоту (значение).

Затем вы сортируете записи в этой карте по их значениям (частотам) и просто помещаете результат в список.

Теперь у вас есть отсортированный список наборов записей, где ключ - это целое число, а значение - это частота, к которой вы можете просто получить доступ по индексу:

public static void main(final String[] args) {
    final int integers[] = new int[] {3, 1, 1, 1, 13, 13, 13, 13, 13, 8, 8, 8, 8, 8, 8};

    final Map<Integer, Integer> integerFrequencies = new HashMap<>();

    // Create a map of all integers with their frequency:
    for (final int i : integers) {
        if (integerFrequencies.containsKey(i)) {
            integerFrequencies.put(i, integerFrequencies.get(i) + 1);
        }
        else {
            integerFrequencies.put(i, 1);
        }
    }

    // Sort the map entries by their value (frequency) into a list:
    final var integerFrequenciesSorted = integerFrequencies.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).collect(Collectors.toList());

    // Print 2nd to 4th entry:
    for (int i = 1; i < 4; i++) {
        final var integerFrequency = integerFrequenciesSorted.get(i);
        System.out.println("Value: " + integerFrequency.getKey() + ". Frequency: " +  integerFrequency.getValue());
    }
}

печатает:

Значение: 13. Частота: 5
Значение: 1. Частота: 3
Значение: 3. Частота: 1

Answer 2

public static void main(String[] args) {
    SomeClass obj = new SomeClass();
    obj.printRange(new int[]{2, 4}, new int[]{1, 1, 1, 3, 4, 4, 8, 8});
}

public void printRange(int[] range, int[] arrayOfNumber) {
    // Using HashMap so we can save frequency against each number
    HashMap<Integer, Integer> hashMap = new HashMap<>();
    for (int i = 0; i < arrayOfNumber.length; i++) {
        if (hashMap.get(arrayOfNumber[i]) != null) {
            hashMap.put(arrayOfNumber[i], hashMap.get(arrayOfNumber[i]) + 1);
        } else {
            hashMap.put(arrayOfNumber[i], 1);
        }
    }

    //Sort the hashmap and convert it to linkedhashmap
    LinkedHashMap<Integer, Integer> linkedHashMap = sortHashMapByValues(hashMap);
    Iterator<Map.Entry<Integer, Integer>> itr = linkedHashMap.entrySet().iterator();
    //iterate through the linkedhashmap
    for (int i = 0; i < range[1]; i++) {
        // print only your range: expecting range in array → [2,4]
        // start with range[0]→2, range[1]→4
        if (i >= range[0] && itr.hasNext()) {
            Map.Entry<Integer, Integer> entry = itr.next();
            System.out.println("Range at: " + i);
            System.out.println("key: " + entry.getKey());
            System.out.println("Frequency: " + entry.getValue());
        }
    }
}

public LinkedHashMap<Integer, Integer> sortHashMapByValues(
    HashMap<Integer, Integer> passedMap) {
    List<Integer> mapKeys = new ArrayList<>(passedMap.keySet());
    List<Integer> mapValues = new ArrayList<>(passedMap.values());
    Collections.sort(mapValues);
    Collections.sort(mapKeys);

    LinkedHashMap<Integer, Integer> sortedMap =
        new LinkedHashMap<>();

    Iterator<Integer> valueIt = mapValues.iterator();
    while (valueIt.hasNext()) {
        int val = valueIt.next();
        Iterator<Integer> keyIt = mapKeys.iterator();

        while (keyIt.hasNext()) {
            Integer key = keyIt.next();
            int comp1 = passedMap.get(key);
            int comp2 = val;

            if (comp1 == comp2) {
                keyIt.remove();
                sortedMap.put(key, val);
                break;
            }
        }
    }
    return sortedMap;
}