Question

enter image description here

以上是我的任务。

基本上，我填充一个数组，并计算每个元素的出现次数。但是，根据说明，这意味着它必须准确并且不能输出错误的出现次数。如果你认为这样的修辞，对你有好处。这不是我的问题。

我的代码：

public class CalcOccurrence {

    public static int findIt(int[] list, int i) {
            int[] occurence = {0,0,0,0,0,0,0,0,0,0};
            occurence[i] = list[i];
            boolean hasChecked = false;
            int numberOfTimes = 0;

            for(int j=0; j < list.length; j++) {
                if(j!=9) {
                    if(list[i]==occurence[++j]) {
                        hasChecked=true;
                    }
                }
            }
            if(hasChecked=false) {
                for(int y = 0; y < list.length; y++) {
                    if(list[i]==list[y]) {
                        numberOfTimes++;
                    }
                }
            }

            return numberOfTimes;
        }


        public static void main(String[] args) {
            Scanner userInput = new Scanner(System.in);
            int[] list = new int[10];
            int[] counter = new int[10];

            for(int i = 0; i < list.length; i++) {
                System.out.println("Please input an integer between 1 and 100: ");
                list[i] = userInput.nextInt();
            }

            userInput.close();

            for(int n = 0; n < list.length; n++) {
                if(list[n]!=0) {
                    counter[n] = findIt(list, n);
                    if(counter[n] > 1) {
                        System.out.println(list[n] + " occurs " + counter[n] + " times.");
                    } else {
                        System.out.println(list[n] + " occurs " + counter[n] + " time.");
                    }
                }
            }
        }
}

我已经修改了两次，我仍然无法用正确的方式来解决这个问题。我不能使用任何高级的Java调整或代码，这些调整或代码会让我觉得自己被骗了或者基本上把它从网上撕掉了。我严格地只使用上面代码中的内容。

我上面写的是我尝试实施这种公式。我以为我可以并行制作两个数组，以保持其相邻索引中的出现次数。所以，让我们说如果我为列表[0]键入1，并且还有4次出现。 findIt（）方法应该返回一个值4，它将被赋值给count [0]。但是，此方法不起作用，并且为每个实例输出不一致的事件。对于每个实例都会重复我的意思。所以，我发明了一个数组来检查数字是否已经被检查过，但是失败了。

我已经查看了类似问题的一些以前的答案，但代码要么太高级了，要么我不能为我的目的实现它。

Answer 1

您的输入仅由1到100之间的整数组成。因此，您可以使用单个数组来解决此问题。

首先，创建一个可以存储100个元素的数组，每个元素对应一个可能的值：

int[] count = new int[100];

默认情况下，数组中的每个位置都将用0初始化。

现在迭代list为你找到的每个号码的对应位置添加一个：

for (int number : list) {
    count[number - 1]++;
}

我们执行了number - 1，因此我们将1的计数存储在count[0]中，2中的count[1]，直到100为止count[99]。

要打印某个号码在list中出现的次数，您只需要执行以下操作：

System.out.println(count[number - 1]);

请注意，您的示例输出已排序。这非常适合这种方法，因为我们在计算元素时隐式地对输入数组进行了排序。要打印数字及其计数，您只需执行以下操作：

for (int i = 0; i < count.length; i++) {
    System.out.println((i + 1) + ": " + count[i]);
}

这将打印从1到100的每个数字，即使是0次出现的数字。几次检查应足以只打印出一次或多次出现的数字，并处理“时间”和“时间”要求。

此算法称为计数排序，您可以找到有关它的更多信息here。

Answer 2

这一行似乎错了：

occurence[i] = list[i];

如果你正在寻找5，那么出现[5]将是数组的第6个元素，可能是也可能不是5。

我看到前进的道路有两条：

对数组进行排序，然后您可以迭代一次，每次遇到与最后一个数字不同的数字时，输出一个计数器并重置计数器。换句话说，更容易发现2在[2,2,5,6,7,7,10]中出现2次比在[5,2,7,2,6,7,10]中出现两次。
创建一个整数值到出现的地图：Map<Integer, Integer>。迭代你的数组（如果你做这个解决方案，排序无关紧要），对于每个元素，如果map.containsKey(n)没有映射到任何东西，则将它映射到1，否则，得到它的正确值并递增1。

第一个例子

int lastElement;
int count = 0;

for (int element : elements) {
    if (element == lastElement) {
        count++;
    }
    else {
        System.out.println(element + " occurs " + count + " time(s).");
        count = 0;
        lastElement = element;
    }
}

您需要弄清楚如何最好地处理第一次迭代的初始情况，因为lastElement未初始化。我会留给你的。

第二个例子

SortedMap<Integer, Integer> occurences = new TreeMap<>();
for (int element : elements) {
    if (occurences.containsKey(element)) {
        occurences.put(occurences.get(element) + 1);
    }
    else {
        occurences.put(element, 1);
    }
)

如果要求对输出进行排序，则这些方法中的任何一种都应该起作用。我使用SortedMap接口来确保无法使用HashMap之类的无序实现。

Answer 3

使用地图：

public static void main(String... args) {
    int[] input = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2, 3, 1, 2, 1, 10000, 500000 };
    System.out.println(countOccurances(input));
}

private static Map<Integer, Integer> countOccurances(int[] input) {
    Map<Integer, Integer> ret = new HashMap<Integer, Integer>();
    for (int i : input) {
        Integer curr = ret.get(i);
        if (curr == null) {
            ret.put(i, 1);
        } else {
            ret.put(i, ++curr);
        }
    }
    return ret;
}

输出：{500000=1, 10000=1, 1=5, 2=4, 3=3, 4=2, 5=1}

如何编写用于计算数组中特定项的出现的代码？

3 个答案: