logo标签列表

寻找一个数字中重复数字最多的数量

java
4

我正在做大学课程练习，但是有一道题我做不出来。我们被要求输入一个数字，例如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"));
    }

}
1
“数字的众数”是什么？ - user1907906
你知道吗，平均数、中位数和众数？ 基本上就是出现次数最多的数字。 - TobiasS
2
@LutzHorn：他没有说是中位数。他说的是“平均数、中位数、众数”，这些都是平均值的度量标准。他想要的是众数。 - michaelgulak
3
@LutzHorn说过他从未表示想要寻找中位数，也从未有人说过中位数和其他事物是相同的。请再次阅读评论。 - michaelgulak
1
但是，medium的复数形式是media，而不是mean。 - user146043
显示剩余6条评论
8个回答
0

通过统计每个特定数字，我觉得将数字作为一个 String 会更容易（去掉 Integer.parseInt()），然后通过值和计数在 HashMap 中计算每个 char。例如：

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);
}
0

找到具有最高计数的数字的一个可能的简单解决方案片段。
此片段不应为所有边缘情况提供解决方案。它只是展示一种可能的找到解决方案的方式。

// 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);
0

只需保持每个数字的累加总和，然后寻找最大值。使用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");
    }
0
你可以使用一个新的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;
}

这就是你所需要的全部。

0

试试这个：

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;
    }
}

代码首先将整数转换为一个名为digits的整数数组，其中包含所有数字，每个数字位于不同的索引中。 然后创建一个名为counts的整数数组来保存数字出现的次数，每个索引代表不同的数字（例如：counts[5]表示数字5出现的次数）。 然后使用for循环更新counts数组，并在当前出现次数最大时更新mode。for循环还在第一次更新模式时将isMode布尔值设置为true。 最后打印模式（从mode变量中）和模式出现的次数（从counts[mode]中）。此外，如果布尔值isMode为true，则会打印一条消息，说明没有模式。 希望这段代码能对您有所帮助。

0
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] ++意味着位置5处的countArray增加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}。

下一个for循环是为了找出最大的计数。它很简单，遍历整个数组，如果找到比max大的数字，那么max就变成那个数字。在这种情况下，max最终会变成2。

虽然我们已经找到了最常出现的数字被计数的次数，但我们仍然不知道那个数字是什么，例如在我的例子中，我们知道最常出现的数字被计数了2次，但我们仍然不知道它是5。因此，我创建了一个辅助方法来查找哪个数字被计数最多。它循环遍历数组，如果数组在某个位置包含最大数量的计数，则必须是该数字。

0

我尝试使用map实现，得到了正确的输出。 希望这可以帮到你.. :)

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();
    }

   }
 }
-1
for (int siffer=0; siffer==lengde; siffer++)

更改为：

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

因为在开始时siffer为0且lengde为7，所以您的for循环将永远不会执行...

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接