某個正整數的數字根定義為所有數字的總和

Question

我正在嘗試在一個在線挑戰網站上解決此挑戰，但我有些困惑。 以下是有關該問題的更多信息：

您將得到一個整數數組。 按以下方式對其進行排序：如果a在b之前，則a的數字根小於或等於b的數字根。 如果兩個數字具有相同的數字根，則較小的一個（通常是）應排在第一位。 例如4和13具有相同的數字根，但是4 <13因此4在出現兩者的任何digitRoot排序中都在13之前。

這是我的輸出：

Input: a: [13, 20, 7, 4]
Output: [20, 13, 4, 7]
Expected Output: [20, 4, 13, 7]

這是我的代碼：

int digitRoot(int b) {
    int c, sum = 0;
    while(b>0) {
        c=b%10;
        sum=sum+c;
        b=b/10;
    }
    return sum;
}

int[] digitRootSort(int[] a) {
    HashMap<Integer, ArrayList<Integer>> map = new HashMap<Integer, ArrayList<Integer>>();
    int[] a1 = new int[a.length];
    for (int i=0;i<a.length;i++) {
        a1[i]=digitRoot(a[i]);
        if (map.containsKey(a1[i])) {
            ArrayList<Integer> temp = map.get(a1[i]);
            temp.add(a[i]);
            map.put(a1[i], temp);
        }
        else { 
            ArrayList<Integer> list = new ArrayList<Integer>();
            list.add(a[i]);
            map.put(a1[i], list);
        }
    }
    Arrays.sort(a1);
    for (int i=0;i<a.length;i++) {
        ArrayList<Integer> temp = map.get(a1[i]);
        for(int j=0;j<temp.size();j++) {
            a[i]=temp.get(j);
            if (j<temp.size()-1)
                i++;
        }
    }
    return a;
}

但是如果我改變map.put（a1 [i]，temp）; 到map.put（a1 [i]，Collections.sort（temp））;，出現此錯誤：第24行上的file.java：

 error: 'void' type not allowed here
                map.put(a1[i], Collections.sort(list));

Answer 1

您似乎正在嘗試插入集合的排序值。 無論好壞， Collections.sort(List)對列表進行原位排序，但不返回任何內容。 首先對列表進行排序，然后將其插入地圖。

Answer 2

只需包括這個Collections.sort(temp); 在您的最后一個for循環中，這是必要的，因為多個數字可以具有相同的digitRoot，並應按排序放在列表中。

for (int i=0;i<a.length;i++) {
        ArrayList<Integer> temp = map.get(a1[i]);
        Collections.sort(temp);
        for(int j=0;j<temp.size();j++) {
            a[i]=temp.get(j);
            if (j<temp.size()-1)
                i++;
        }
    }

Input: a: [13, 20, 7, 4]
Output: [20, 4, 13, 7]

編輯：關於錯誤

因為在put(a1[i], Collections.sort(list)) ，put方法期望的是put(int, List) ，但是您給它put(int, void) ，因為Collections.sort()的返回類型是void ，您只需要首先對列表進行排序，然后再傳遞

Answer 3

看來您過於復雜了。 編寫一個實現排序規則的Comparator ，然后簡單地對值進行排序。

由於您不能使用Comparator對int[]進行排序，因此首先必須對值進行裝箱，否則非常容易，尤其是使用Java 8+流時。

static int[] digitRootSort(int... values) {
    return IntStream.of(values).boxed()
                    .sorted(new DigitRootComparator())
                    .mapToInt(Integer::intValue).toArray();
}

static final class DigitRootComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer a, Integer b) {
        int cmp = Integer.compare(digitRoot(a), digitRoot(b));
        return (cmp != 0 ? cmp : Integer.compare(a, b));
    }
    private static int digitRoot(int value) {
        int sum = 0;
        for (int remain = value; remain > 0; remain /= 10)
            sum += remain % 10;
        return sum;
    }
}

測試

System.out.println(Arrays.toString(digitRootSort(13, 20, 7, 4)));

輸出量

[20, 4, 13, 7]

Answer 4

放入地圖時，無需對數組進行排序。 相反，您可以在最后一個循環中對它進行排序：

    Arrays.sort(a1);
    for (int i=0;i<a.length;i++) {
        ArrayList<Integer> temp = map.get(a1[i]);
        Collections.sort(temp);
        for(int j=0;j<temp.size();j++) {
            a[i]=temp.get(j);
            if (j<temp.size()-1)
                i++;
        }
    }

如果需要在放入地圖時進行排序，則應使用SortedSet，因為這將自動使元素保持排序：

int[] digitRootSort(int[] a) {
    HashMap<Integer, TreeSet<Integer>> map = new HashMap<Integer, TreeSet<Integer>>();
    int[] a1 = new int[a.length];
    for (int i = 0; i < a.length; i++) {
        a1[i] = digitRoot(a[i]);
        if (map.containsKey(a1[i])) {
            TreeSet<Integer> set = map.get(a1[i]);
            set.add(a[i]);
            map.put(a1[i], set);
        } else {
            TreeSet<Integer> set = new TreeSet<Integer>();
            set.add(a[i]);
            map.put(a1[i], set);
        }
    }
    Arrays.sort(a1);
    for (int i = 0; i < a.length;) {
        TreeSet<Integer> set = map.get(a1[i]);
        for (int j : set) {
            a[i] = j;
            i++;
        }
    }
    return a;
}

但是，通過使用適當的比較器，甚至還有一種更簡單的方式來處理排序集：

int[] digitRootSort(int[] a) {
    SortedSet<Integer> set = new TreeSet<Integer>(new Comparator<Integer>() {

        @Override
        public int compare(Integer a, Integer b) {
            int result = Integer.compare(digitRoot(a), digitRoot(b));
            result = result == 0 ? Integer.compare(a, b) : result;
            return result;
        }
    });

    for (int i : a) {
        set.add(i);
    }

    int i = 0;
    for (int j : set) {
        a[i++] = j;
    }

    return a;
}