Question

我有一个2D数组，如果这样填充。

另一个例子

我想写的代码是

搜索数组中重复的最大数字集。

在示例1中：答案是3，因为最大值是（3 4 5）重复3次，而不像（1 2）重复一次。

同样在示例2中，最大值为2，因为重复次数不会超过两次的同一组数字。

我想为此编写代码。

任何帮助？！

Answer 1

我会过滤数组并将每个相同的数字添加到变量中，然后显示命中次数最多的变量

int three = 0;

for (int i = 0; i < array.size(); i++){
     if(array.get(i) == 3){
        three++;
     }else if(array.get(i) == "Some other number"){
        number++;
      }

那么您需要过滤掉刚添加的数字

Collections.sort(arrayList); // Sort the arraylist
arrayList.get(arrayList.size() - 1); //gets the last item, largest for an ascending sort

然后我会对数组进行排序，看看有多少是相同的

if(arrayList.size() - 1 == arrayList.size() - 2){
   System.out.println(arrayList.size() - 1 " & " arrayList.size() - 2);
 }

将会有更多繁琐的编码，但这将是您的代码的基础，您首先将值添加到变量并对数组列表进行排序，以查看最多出现的值，并且您需要使用2D数组进行添加我们在开始时做的实际变量然后将它们从最高到最低排序。

Answer 2

这里使用这个程序

public class Matrix {
    public static void main(String[] args) {
        int[][] a = new int[][] {
            { 1, 2, 3 },
            { 3, 3, 3 },
            { 1, 2, 3 }
        };
        int result = 0;
        int largestNum = 0;

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (result <= count(a[i][j], a)) {
                    result = count(a[i][j], a);
                    largestNum = a[i][j];
                }
            }
        }

        // Display the result
        System.out.println("Largest Number: " + largestNum);
    }

    public static int count(int arrVal, int[][] a) {
        int count = 0;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (arrVal == a[i][j]) {
                    count++;
                }
            }
        }

        return count;
    }
}

为简单起见，我已经为行和列声明了一个长度为3的二维数组。你可以使用任何长度的数组

Answer 3

虽然这不能直接解决您的问题，但您可以通过将所有序列指定为Map中的键来收集和计算所有序列。执行此操作后，您可以获得最长的序列，并查看哪个序列具有最高频率。

代码

的输出

Sequence   Frequency
--------   ---------
2          2
5          3
1,2        2
3,4,5      3         // <- Longest sequence, Highest frequency.
4,5        3

Sequence   Frequency
--------   ---------
1          1
2          1
3          1
4          3         // <- Highest frequency, but not a sequence.
2,3,4      1
1,2        1
1,2,3      1
2,3        1
3,4        2         // <- Second highest frequency, is a sequence.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class MatrixSequenceFrequency {
    public static void main(String[] args) {
        int[][] arr1 = new int[][] {
            { 1, 2, 0, 0, 0 },
            { 1, 2, 0, 0, 0 },
            { 0, 0, 3, 4, 5 },
            { 0, 0, 3, 4, 5 },
            { 0, 0, 3, 4, 5 }
        };

        printSequences(findSequences(arr1));

        int[][] arr2 = new int[][] {
            { 1, 2, 3, 0 },
            { 1, 2, 0, 4 },
            { 1, 0, 3, 4 },
            { 0, 2, 3, 4 }
        };

        printSequences(findSequences(arr2));
    }

    private static Map<String, Integer> findSequences(int[][] arr) {
        Map<String, Integer> sequences = new HashMap<String, Integer>();

        for (int i = 0; i < arr.length; i++) {
            indexSequences(arr[i], sequences);
        }

        return sequences;
    }

    private static void indexSequences(int[] arr, Map<String, Integer> sequences) {
        StringBuffer buff = new StringBuffer();

        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[j] != 0) {
                    buff.append(arr[j]).append(',');
                } else {
                    break; // `0` breaks the sequence.
                }
            }

            if (buff.length() > 0) {
                if (buff.charAt(buff.length() - 1) == ',') {
                    buff.deleteCharAt(buff.length() - 1); // Remove extra comma.
                }

                Integer value = sequences.get(buff.toString());
                sequences.put(buff.toString(), value == null ? 1 : value + 1);
                buff.delete(0, buff.length()); // Clear Buffer
            }
        }
    }

    private static void printSequences(Map<String, Integer> sequences) {
        String format = "%-10s %s%n";
        System.out.printf(format, "Sequence", "Frequency");
        System.out.printf(format, "--------", "---------");
        for (Iterator<Entry<String, Integer>> it = sequences.entrySet().iterator(); it.hasNext();) {
            Entry<String, Integer> entry = it.next();
            System.out.printf(format, entry.getKey(), entry.getValue().toString());
        }
        System.out.println();
    }
}

如何在2D数组中找到常用的数字集？

3 个答案:

代码