Поиск наивысшего числа повторяющихся цифр числа

Question

Я занимаюсь колледжем, и я просто не могу сделать один из них. Нас попросят ввести число, например 1975333, и программа должна вернуть «Число 3 появляется 3 раза». В основном предполагается рассказать вам о способе номера.

Это то, что у меня есть, но я не могу показаться, чтобы не работать, независимо от того, что я пытаюсь:

import static java.lang.System.*; 
import static javax.swing.JOptionPane.*; 
import static java.lang.Math.*; 

public class Oblig5 { 

    public static void main(String[] args) { 

     int tall = input_tall(); 
     int siffervekt = 0; 
     int t_siffervekt = 0; 

     int lengde = (int) (Math.log10(tall) + 1); 

     for (int siffer = 0; siffer == lengde; siffer++) { 
      System.out.println("Siffer = " + siffer); 
       for (int x = 0; x < lengde; x++) { 
        int asiffer = (tall % 10); 
        System.out.println("Asiffer = " + asiffer); 
        if (asiffer == siffer) { 
         siffervekt++; 
         out.println(siffervekt); 
        } 
        tall = tall/10; 
       } 
      t_siffervekt = max(siffervekt, t_siffervekt); 
     } 
    } 

    private static int input_tall() { 
     return Integer.parseInt(showInputDialog(null, "Skriv inn ønsket tall")); 
    } 

} 

Answer 1

for (int siffer=0; siffer==lengde; siffer++) 

изменение:

for (int siffer=0; siffer < lengde; siffer++) 

потому siffer 0 в начале и lengde - 7, поэтому ваш цикл цикла никогда не будет выполняться ...

Answer 2

С подсчетами каждого типа я считаю, что было бы легче сохранить номер как String (убрать Integer.parseInt()), затем пересчитать каждый char по HashMap по значению и количеству. Например:

public int[] getMostCommon(String numbers){ //Returning int[] for [0] = digit and [1] = frequency 
    HashMap<Character, Integer> digits = new HashMap<Character, Integer>(); 
    for (char myChar : numbers.toCharArray()){ 
     int count = digits.getOrDefault(myChar, 0); 
     digits.put(myChar, count+1); //getOrDefault is Java 8+ only, see below if running earlier versions 
    } 
    int[] returnValue = new int[] {0, 0}; 
    for (int i = 0; i <= 9; i++){ //Loop through each digit to see which is most frequent 
     if (digits.get((char) i+48) > returnValue[1]){ //+48 for ASCII conversion to char, see http://www.asciitable.com/ 
      returnValue[0] = i; 
      returnValue[1] = digits.get((char) i+48); 
     } 
    } 
    return returnValue; 
} 

Если вы не используете Java 8, вам нужно использовать следующий код вместо getOrDefault:

int count = 0; 
if (digits.containsKey(myChar)){ 
    count = digits.get(myChar); 
} 

Answer 3

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

// the input number 
int input = 1975333; 

// check the last digit and increment the count for this digit 
int[] digits = new int[10]; 
while (input > 0) { 
    digits[input % 10]++; 
    input /= 10; 
} 

// find the digit with the highest count 
int maxCount = 0; 
int maxIdx = 0; 
for (int i = 0; i < digits.length; i++) { 
    if (digits[i] > maxCount) { 
     maxCount = digits[i]; 
     maxIdx = i; 
    } 
} 
System.out.printf("max digit: %d count: %d%n", maxIdx, maxCount); 

Answer 4

Просто выполняйте общее количество каждой цифры, а затем ищите самый большой. Используйте сам val, чтобы управлять циклом, чтобы избежать просчетов длины анализируемого значения.

public Mode(long val) { 
     long[] count = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 
     while(val > 0) { 
      int digit = (int)(val % 10L); 
      count[digit] ++; 
      val /= 10; 
     } 
     int mode = 0; 
     long maxVal = 0; 
     for(int i = 0; i < 10; i++) { 
      if(count[i] > mode) { 
       mode = i; 
       maxVal = count[i]; 
      } 
     } 
     System.out.println("Number " + mode + " appears " + maxVal + " times"); 
    } 

Answer 5

Вы можете сделать это с помощью нового Array[10], в котором вы будете сохранять частоту каждой цифры [0-9], а затем возвращает максимальное значение этого массива:

public int mostFrequentVlaue(int number){ 
    String num=number.toString(); 
    int[] freqArray=new int[10]; 
    // initialize the frequency array with zeros 
    for(int k=0;k<9;k++){ 
     freqArray[k]=0; 
    } 

    //loop throught our number string and count frequency of each digit 
    for(int i=0;i<num.length();i++){ 
    switch (num.charAt(i)) { 
     case '0': freqArray[0]++; 
       break; 
     case '1': freqArray[1]++; 
       break; 
     case '2': freqArray[2]++; 
       break; 
     case '3': freqArray[3]++; 
       break; 
     case '4': freqArray[4]++; 
       break; 
     case '5': freqArray[5]++; 
       break; 
     case '6': freqArray[6]++; 
       break; 
     case '7': freqArray[7]++; 
       break; 
     case '8': freqArray[8]++; 
       break; 
     case '9': freqArray[9]++; 
       break; 
    } 
    } 
    int max=freqArray[0]; 
    int freq=0; 
    for(int j=1;j<9;j++){ 
     if (freqArray[j] > max) { 
      max = freqArray[j]; 
      freq=j; 
     } 
    } 
    return freq; 
} 

И это все что вам нужно.

Answer 6

public static void getMode(int number){ 
    int[] countArray = new int[10]; 
    while(number > 0){ 
     //We take a single number from the number using modulo 
     int n = number%10; 
     countArray[n]++; 
     //We remove the number we already used. 
     number= number/10; 
    } 
    //Count cannot possibly be less than -1 
    int max = -1; 
    for(int i = 0; i< 10; i++){ 
     //Checking which number occurs the most and updates max 
     if(countArray[i] > max) 
      max = countArray[i]; 
    } 
    System.out.println("Number " + getNumber(countArray, max) + " appears " + max + " times"); 
} 

//Helping method I made in order to get which number was found the most 
public static int getNumber(int [] array, int max){ 
    //Simply the array element which contained max is the element 
    //that occured the most. 
    for(int i = 0; i < array.length; i++){ 
     if(array[i] == max) 
      return i; 
    } 
    return -1; 
} 

При подсчете чисел массив из 0-9 помогает много, потому что он охватывает диапазон всех возможных номеров. Поэтому позвольте мне провести вас через мой код. Пользователь вводит число, предположим, что он равен 123455.

Вы вводите цикл while, и это число действительно больше 0. Используя% от числа, вы получите 5. countArray [5] ++ означает, что countArray в позиции 5 увеличивается на 1. Затем число должно быть разделено на 10, чтобы избавиться от числа, которое вы уже использовали, и оно обновляется.

Теперь ваш countArray выглядит так: {0, 0, 0, 0, 0, 1, 0, 0, 0, 0}. Теперь ваш номер 12345, который еще больше 0, вы входите в цикл. Использование% снова дает вам 5. countArray [5], который теперь равен 1, увеличивается на 1 раз.

Ваш countArray выглядит как {0, 0, 0, 0, 0, 2, 0, 0, 0, 0}. Теперь ваш номер 1234, который еще больше 0, вы возвращаетесь в цикл. Использование% дает вам 4. countArray [4] увеличивается. Ваш countArray выглядит как {0, 0, 0, 0, 1, 2, 0, 0, 0, 0}. Итак, так далее и так далее, пока не будет больше чисел, чтобы подсчитать, что в этом случае массив будет выглядеть как {0, 1, 1, 1, 1, 2, 0, 0, 0, 0}.

Следующий цикл - это поиск того, что было найдено максимальное количество. Это просто, петли над массивом, и если он найдет число больше max, max станет этим числом. В этом случае макс в конечном итоге станет 2.

Хотя мы нашли, сколько раз подсчитывалось самое подсчитанное число, мы все еще не знаем, что это число, т.е. в моем примере, мы знаем, что самое подсчитанное число считалось 2 но мы до сих пор не знаем, что это 5. Следовательно, метод помощника, который я создал, находит, какой номер был подсчитан больше всего. Он перемещается по массиву, если массив в некоторой позиции содержит максимальное количество отсчетов, то это должно быть число.

Answer 7

Я попробовал реализовать с использованием карты, которая дает правильный результат. Надеюсь, что это может помочь вам .. :)

package digit; 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.*; 
import java.util.concurrent.ConcurrentHashMap; 
import java.util.concurrent.ConcurrentMap; 
import java.util.concurrent.atomic.AtomicInteger; 

public class RecurringDigit { 


public static void main(String args[]) throws IOException { 
    try { 
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
     String str = br.readLine(); 
     char[] chars = str.toCharArray(); 
     //Created map for each digit 
     final ConcurrentMap<Character, AtomicInteger> map = new ConcurrentHashMap<>(); 
     for (char c : chars) { 
      final char key = c; 
      map.putIfAbsent(key, new AtomicInteger(0)); 
      map.get(key).incrementAndGet(); 
     } 
     //To find max count of that digit 
     Map.Entry<Character, AtomicInteger> maxEntry = null; 

     for (Map.Entry<Character, AtomicInteger> entry : map.entrySet()) { 

      if (maxEntry == null || entry.getValue().intValue() > maxEntry.getValue().intValue()) { 
       maxEntry = entry; 
      } 
     } 
     System.out.println("Number "+ maxEntry.getKey() + " appears " + maxEntry.getValue() +" times"); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 

    } 
} 

Answer 8

Попробуйте это:

public class RecurringDigit { 
    public static void main(String args []) { 
     //--------Change input--------\\ 
     int input = 1975333; 
     //----------------------------\\ 

     int[] digits = toDigitArray(input); 
     int[] counts = new int[10]; 

     int mode = 1; 
     int modeAmount = 1; 
     boolean isMode = false; 

     for(int i = 0; i < digits.length; i++) { 
      int digit = digits[i]; 
      counts[digit]++; 

      if(modeAmount < counts[digit]) { 
       modeAmount = counts[digit]; 
       mode = digits[i]; 
       isMode = true; 
      } 
     } 

     if(isMode) { 
      System.out.println("Number " + mode + " appears " + counts[mode] + " times."); 
     } else { 
      System.out.println("All numbers appear an equal amount of times."); 
     } 
    } 

    public static int[] toDigitArray(int number) { 
     String temp = Integer.toString(number); 
     int[] output = new int[temp.length()]; 
     for (int i = 0; i < temp.length(); i++) 
     { 
      output[i] = temp.charAt(i) - '0'; 
     } 

     return output; 
    } 
} 

Код первым превращает Int в целочисленный массив под названием digits, который содержит все цифры, каждый в другом индекс. Затем создается массив int, называемый counts, чтобы удерживать количество раз, когда число имеет значение, каждый индекс, представляющий другое число (пример: counts[5] равен количеству раз 5). Затем цикл for используется для обновления массива counts и обновления mode, если текущая сумма возникновения наибольшая. Цикл for также устанавливает isMode логическое значение true при первом обновлении режима. Наконец, печатается режим (из переменной mode) и количество раз, которое происходит в этом режиме (от counts[mode]). Кроме того, если логическое значение isMode истинно, печатается сообщение, в котором говорится, что нет режима. Надеюсь, код вам немного помог.