Подсчет вхождений внутри массива

1

Я вернулся, как советовал, и начал изучать какой-то код, который я ошибался несколько месяцев назад, и пытался его обновить, так как он будет более эффективным.

Все, что я хочу, это для моего метода вернуть новый массив, в котором есть вхождения.

например: count({2,4,0,7,4,2,1,0}) returns {2,1,2,0,2,0,0,1}

до сих пор мой метод для этого - это и только для записи, и я думаю, что зрители ради, массив, с которым я работаю, - это.

18  29  23  35  23  28  36  27  16  21  33  21  18  33  16  6  19  22  9  26  28  16  19  14  18  12  17  28

это мой класс подсчета

public int[] count(Integer[] nums)
{
    Integer[] numOccur = new Integer[nums.length]; //new array that will be returned with the occurances

    for (int i = 0; i < nums.length; ++i) //goes through the array for nums.length times.
    {
        Integer count = nums[i]; //assigns count to nums[i]
        numOccur[count]++;         //ERROR
        System.out.println(numOccur[i]); //testing to see if i'm printing the right value
    }

    return numOccur;
}

Я получаю

at WeatherSrv.count(WeatherSrv.java:94)
    at WeatherDrv.main(WeatherDrv.java:55)
Java Result: 1

Я знаю, что проблема возникает в моем назначении новых элементов внутри моего массива [] numOccur, это просто из-за моего назначения? Я просто хочу знать, пойду ли я в правильном направлении.

В моей предыдущей версии этого я использовал только оператор switch, никаких массивов, поэтому это немного отличается.

EDIT 1: Я должен был опубликовать свой основной метод, с которым я использую это!

weather.count(res) где res - массив, который я разместил в верхней части над моим классом

/* ЭТО МОЯ ПЕРВАЯ ПОЧТА КАЖДОГО - если у кого-нибудь есть какие-то советы по формулировке лучшего вопроса, пожалуйста, не стесняйтесь, я хотел бы получить самый ясный, не заданный ответ

  • 0
    Может быть, вам нужно только привести число, я имею в виду, вы должны сделать это: numOccur [(int) count] ++;
  • 0
    это потому, что это целое число, и мне нужно это как INT? в любом случае, я все еще получил ту же ошибку, что и раньше
Показать ещё 5 комментариев
Теги:
arrays

3 ответа

0
Лучший ответ

Вы могли бы точно реализовать свою текущую реализацию с тем, что предложил @Elliott Frisch, но вы также можете пойти другим путем и использовать HashMap.

Вот работающее решение с использованием HashMap, оно имеет дополнительное преимущество: не нужно перебирать потенциально большое количество пустых индексов, так как только числа, которые существуют в начальном массиве, будут иметь значение в HashMap.

import java.util.HashMap;

public class CountOccur
{
  public static void main(String[] args)
  {
    Integer[] arr = new Integer[]{2,4,0,7,4,2,1,0};
    HashMap<Integer, Integer> countMap = count(arr);

    for (Integer key : countMap.keySet()) {
      System.out.println(key + " count: " + countMap.get(key));
   }

  }

  public static HashMap<Integer, Integer> count(Integer[] nums)
  { 
      HashMap<Integer, Integer> countMap = new HashMap<Integer, Integer>();

      for (int i = 0; i < nums.length; ++i)
      {
          Integer count = countMap.get(nums[i]); 
          if (count  == null){
            //first occurrence, enter a value of 1 for count
            countMap.put(nums[i], 1);
          }
          else{
            //already in the HashMap, increment the count
            countMap.put(nums[i], count + 1);
          }

      }

      return countMap;
  }
}

Вывод:

0 count: 2
1 count: 1
2 count: 2
4 count: 2
7 count: 1

Чтобы обратить внимание на исходный подход, представьте себе вход: {1,1000000}. Вам понадобится массив размером 1000001, и для обработки возвращаемого массива вам потребуется перебрать все миллион и один индекс, причем все они будут пустыми, кроме двух.

Поделиться
  • 0
    в будущем это можно считать более эффективным выбором? и куда пойдет публичный статический HashMap? внутри моего класса обслуживания или основного класса?
  • 0
    Единственная другая проблема, с которой я столкнулся, это блестяще, но теперь у меня вообще нет метода подсчета?
Показать ещё 7 комментариев
0

когда вы вызываете эту строку:

Integer[] numOccur = new Integer[nums.length]

это означает, что вы создаете новый массив с nums.length, поэтому вы можете получить индекс от 0 до nums.length-1, но когда вы назначаете значение этому массиву, как этот numOccur[count]++; count - значение массива с именем nums, count может быть больше nums.length-1. Ваша программа может указать исключение ArrayIndexOutOfBoundsException

Поделиться
  • 0
    поэтому мне нужно что-то вроде, возможно, numOccur [count [i] ++; в теории?
0

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

private static int getMaxValue(Integer[] nums) {
    int max = nums[0];
    for (int i = 1; i < nums.length; i++) {
        max = Math.max(max, nums[i]);
    }
    return max;
}

Тогда ваш метод должен определять размер своего массива вывода

// You return an 'int[]'
int[] numOccur = new int[1+getMaxValue(nums)];
Поделиться
  • 0
    что бы это сделать? у меня есть метод, который получает максимум, но я не понимаю, почему я использовал бы его здесь, когда моя длина чисел будет такой же, как каждый элемент будет происходить хотя бы один раз, так как его там
  • 0
    @WilliamMabry Я полагаю, ваш код подсчитывает вхождения значений от 0 до n . В исходном методе вы предполагали, что n - это длина массива nums . Я говорю вам, что n - это maxValue массива nums .

Ещё вопросы

Сообщество Overcoder
Наверх
Меню