Подсчет числа целых чисел в массиве

Question

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

Примечание: нет отображения, нет сортировки

Вот мой код:

public static void countArray(int[] n){ 
     int[] m = new int[n.length]; //50 elements of integers between values of 10 & 20 
     int count = 0; 
     int sum = 0; 

     for (int i = 0; i < n.length ; i++){ 
      m[i] = n[i]; //make a copy of array 'n' 
      System.out.print(m[i]+" "); 

     }System.out.println(); 

     for (int j =0; j < n.length ; j++){ 
      count =0; 
      for(int i = 0; i < n.length ; i++){ 
       if (n[j]%m[i]==0 && n[j] == m[i]) 
        count++; 
      }if (n[j]%m[j] == 0) 
      System.out.println(m[j] + " occurs = " + count); 
     } 
    } 

Так что проблема: я получаю повторяющиеся результаты, как: "25 происходит = 5", на разных линиях.

Что я думаю: проблема возникает из-за if (n[j]%m[j] == 0) поэтому я попробовал if (n[j]%m[j+1] == 0). Другая проблема возникает, так как m[j] будет m[50], поэтому он падает, но вроде дайте мне результаты, которые я хочу.

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

17 occurs = 3 
23 occurs = 2 
19 occurs = 3 
15 occurs = 2 
12 occurs = 2 

Я ценю все положительные и отрицательные комментарии. PS новое для программирования Java

Answer 1

С некоторой адаптации ваш код должен работать:

public static void countArray(int[] n){ 
    boolean [] alreadyCounted = new boolean[n.length]; 

    for (int i = 0; i < n.length ; i++){ 
     int count = 0; 
     if (alreadyCounted[i]) { 
      // skip this one, already counted 
      continue; 
     } 
     for(int j = 0; j < n.length ; j++){ 
      if (n[i] == n[j]) { 
       // mark as already counted 
       alreadyCounted[j] = true; 
       count++; 
      } 
     } 
     System.out.println(n[i] + " occurs = " + count); 
    } 
} 

Вы можете определенно использовать та же логика с лучшим кодом, я просто старался следовать оригинальному «стилю кодирования»;

Это решение O (n^2) (см. «очень медленно»).
Если вы можете использовать сортировку, вы можете сделать это в O (n log (n)) - то есть быстро.
С картографированием вы можете сделать это в O (n) - то есть невероятно быстро;

Answer 2

попробовать это: (сортировки массива, а затем подсчитывают вхождение элемента)

public static void countArray(int[] n) { 
    int count = 0; 
    int i, j, t; 
    for (i = 0; i < n.length - 1; i++) // sort the array 
    { 
     for (j = i + 1; j < n.length; j++) { 
      if (n[i] > n[j]) { 
       t = n[i]; 
       n[i] = n[j]; 
       n[j] = t; 
      } 

     } 
    } 

    for (i = 0; i < n.length;) 
    { 
     for (j = i; j < n.length; j++) { 
      if (n[i] == n[j]) 
      { 
       count++; 
      } else 
       break; 
     } 
     System.out.println(n[i] + " occurs " + count); 
     count = 0; 
     i = j; 

    } 

} 

Answer 3

Если вы эксплуатируете предел ввода вы можете потерять вложенный цикл:

public static void main(String[] args) 
{ 
    //6 elements of integers between values of 10 & 20 
    int[] countMe = { 10, 10, 20, 10, 20, 15 }; 

    countArray(countMe); 
} 

/** Count integers between values of 10 & 20 (inclusive) */ 
public static void countArray(int[] input) 
{ 
    final int LOWEST = 10; 
    final int HIGHEST = 20; 

    //Will allow indexes from 0 to 20 but only using 10 to 20 
    int[] count = new int[HIGHEST + 1]; 

    for(int i = 0; i < input.length; i++) 
    { 
     //Complain properly if given bad input 
     if (input[i] < LOWEST || HIGHEST < input[i]) 
     { 
      throw new IllegalArgumentException("All integers must be between " + 
        LOWEST + " and " + HIGHEST + ", inclusive"); 
     } 

     //count 
     int numberFound = input[i]; 
     count[numberFound] += 1; 
    } 

    for(int i = LOWEST; i <= HIGHEST; i++) 
    { 
     if (count[i] != 0) 
     { 
      System.out.println(i + " occurs = " + count[i]); 
     } 
    } 
} 

Answer 4

Вот хороший, эффективный способ сделать это, а более эффективно, чем другие решения, размещенные здесь. Это выполняется в O (n) времени, где массив имеет длину n. Предполагается, что у вас есть номер MAX_VAL, представляющий максимальное значение, которое вы можете найти в своем массиве, и что минимум равен 0. В ваших комментариях вы предлагаете, что MAX_VAL==20.

public static void countOccurrences(int[] arr) { 
    int[] counts = new int[MAX_VAL+1]; 
    //first we work out the count for each one 
    for (int i: arr) 
     counts[i]++; 
    //now we print the results 
    for (int i: arr) 
     if (counts[i]>0) { 
      System.out.println(i+" occurs "+counts[i]+" times"); 
      //now set this count to zero so we won't get duplicates 
      counts[i]=0; 
     } 
} 

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

Если вы не любите for (int i: arr) стиль, это точно эквивалентно:

public static void countOccurrences(int[] arr) { 
    int[] counts = new int[MAX_VAL+1]; 
    //first we work out the count for each one 
    for (int i=0; i<arr.length; i++) 
     counts[arr[i]]++; 
    //now we print the results 
    for (int i=0; i<arr.length; i++) 
     if (counts[arr[i]]>0) { 
      System.out.println(arr[i]+" occurs "+counts[arr[i]]+" times"); 
      //now set this count to zero so we won't get duplicates 
      counts[arr[i]]=0; 
     } 
}