如何确定重复整数的数量及其计数？

Question

我试图编写一个程序来确定数组中重复整数的数量及其计数，但是程序输出的结果大致为fulse，所以我的问题是我的代码中的问题是我不想使用任何类，谢谢。

例如 ：

输入：输入数组大小：11输入数组元素：13 34 22 4 499 4 22 18 4 1 1输出：有3个重复数字：22：2次4：3次1：2次

但我的输出是：

1：2倍4：3倍4：2倍22：2倍

import java.util.Scanner;

public class repeated_elements {

    public static void main(String[] args) {
        Scanner input = new Scanner (System.in);
        // User Choose The Array Size
        System.out.println("Enter Array Size: ");
        int size = input.nextInt();

        // The Array
        int[]Array = new int[size];

        // Read The Array Elements From The User
        System.out.println("Enter Array Elements:");
        for(int i =0; i<size; i++){
            Array[i]=input.nextInt();
        }

        // Sorting The Array (Ascending Order)
        for(int j = 0; j<size; j++){

            int mini = Array[j];
            int mini_index = j;

            for(int i = j; i<size; i++){
                if(Array[i] < mini){
                    mini = Array[i];
                    mini_index = i; 
                }
            }
            int tmp = Array[j];
            Array[j] = Array[mini_index];
            Array[mini_index] = tmp;
        }

        // Count The Repeated Numbers
        for(int i=0; i<size; i++){

            int key = Array[i];
            int counter = 0;

            for(int j=i; j<size; j++){
                if(key == Array[j]){
                    counter++;
                }
            }

            if(counter > 1 ){
                System.out.println(Array[i]+":"+counter+" times ");
            }
        }
    }
}

Answer 1

而不是这段代码：

   // Count The Repeated Numbers
    for(int i=0; i<size; i++){

        int key = Array[i];
        int counter = 0;

        for(int j=i; j<size; j++){
            if(key == Array[j]){
                counter++;
            }
        }

        if(counter > 1 ){
            System.out.println(Array[i]+":"+counter+" times ");
        }
    }

尝试这个：

   // Count The Repeated Numbers
    for(int i=0; i<size; ){   //<--- note the removal of i++

        int key = Array[i];
        int counter = 0;

        for(int j=i; j<size; j++){
            if(key == Array[j]){
                counter++;
            }else{
                i=j;
                break;
            }
        }

        if(counter > 1 ){
            System.out.println(key+":"+counter+" times ");
        }
    }

问题是您不同步i和j变量

所以对于像这样的输入：

1 1 1 1

你会得到

1:4
1:3
1:2

更正后，我测试了程序并输入：

11
13 34 22 4 499 4 22 18 4 1 1

我得到：

1:2 times 
4:3 times 
22:2 times

编辑：AS @CabelB建议。 值得一看一下Map实现。

Answer 2

如果我是您，我可以通过Map进行解决，并在那里进行计数，但是您的代码已更正：

公共类Rep {

public static void main(String[] args) {
    int[] input = {1,1,2,2,2,0};
    // User Choose The Array Size
    System.out.println("Enter Array Size: ");
    int size = input.length;

    // The Array
    int[]Array = new int[size];

    // Read The Array Elements From The User
    System.out.println("Enter Array Elements:");
    for(int i =0; i<size; i++){
        Array[i]=input[i];
    }

    // Sorting The Array (Ascending Order)
    for(int j = 0; j<size; j++){

        int mini = Array[j];
        int mini_index = j;

        for(int i = j; i<size; i++){
            if(Array[i] < mini){
                mini = Array[i];
                mini_index = i; 
            }
        }
        int tmp = Array[j];
        Array[j] = Array[mini_index];
        Array[mini_index] = tmp;
    }

    // Count The Repeated Numbers
    for(int i=0; i<size; i++){

        int key = Array[i];
        int counter = 0;

        for(int j=0; j<size; j++){
            if(key == Array[j]){
                counter++;
            }
        }

        if(counter > 0 ){
            System.out.println(Array[i]+":"+counter+" times ");
        }
    }
}

}

Answer 3

您的代码似乎还可以，但是有一个小问题。 输出外观数时，每次都将遍历整个数组，而不管当前检查的值是否已经被检查过。 简而言之，对于[1、1、1、1、2、2、2、2、3、3]的输入数组，输出是1：4倍，1：3倍和1：2倍，依此类推。

我认为您需要从排序后的数组中分离出不同的值，或者至少确保不对已经计数的值重复计数。

Answer 4

您每次都解析整个数组，因此您必须跳过已解析的项目。 最后将i计数器按counter值递增：

if(counter > 1 ){
    System.out.println(Array[i]+":"+counter+" times ");
    i +=counter;
}

那就足够了，希望对您有所帮助

Answer 5

当我们拿起钥匙来寻找发生的地方时，首先我们需要检查它是否已经在寻找发生的地方（例如4）。 因此，我将键保留在数组中，没有任何重复，然后开始搜索它。 使用collections方法可以轻松完成。

public class RepeatedElements {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        // User Choose The Array Size
        System.out.println("Enter Array Size: ");
        int size = input.nextInt();

        // The Array
        int[] Array = new int[size];

        // Read The Array Elements From The User
        System.out.println("Enter Array Elements:");
        for (int i = 0; i < size; i++) {
            Array[i] = input.nextInt();
        }

        // Sorting The Array (Ascending Order)
        for (int j = 0; j < size; j++) {

            int mini = Array[j];
            int mini_index = j;

            for (int i = j; i < size; i++) {
                if (Array[i] < mini) {
                    mini = Array[i];
                    mini_index = i;
                }
            }
            int tmp = Array[j];
            Array[j] = Array[mini_index];
            Array[mini_index] = tmp;
        }
//      System.out.println("sorted array:"+Arrays.asList(Array));
        int key[] = new int[Array.length];
        int keylen = 0;
        // Count The Repeated Numbers
        for (int i = 0; i < size; i++) {


            int found = 0;
            int k;
            for ( k=0;k<keylen;k++){
                if (key[k]==Array[i]){
                    found=1;
                }
            }
//      11  System.out.println("k value"+k+"i value"+i);
            if (found==1)
                continue;//already counted
            else
                key[keylen]=Array[i];

            int counter = 0;

            for (int j = i; j < size; j++) {
                if (key[keylen] == Array[j]) {
                    counter++;
                }
            }
            keylen++;
            if (counter > 1) {
                System.out.println(Array[i] + ":" + counter + " times ");
            }
        }

    }
}

输出附在屏幕截图中。