題目

由4個不同的數(shù)字，組成的一個乘法算式，它們的乘積仍然由這4個數(shù)字組成。
比如：

210 x 6 = 1260 
8 x 473 = 3784
27 x 81 = 2187 

都符合要求。
如果滿足乘法交換律的算式算作同一種情況，那么，包含上邊已列出的3種情況，一共有多少種滿足要求的算式。
請?zhí)顚懺摂?shù)字，通過瀏覽器提交答案，不要填寫多余內容（例如：列出所有算式）。

答案

12種情況，如下：

3*501=3501
3*510=3510
6*201=6201
6*210=6210
8*473=8473
9*351=9351
15*93=1593
21*60=2160
21*87=2187
27*81=2781
30*51=3051
35*41=3541

分析

對于該題，我使用了枚舉法，通過兩個for循環(huán)，將所有算式 i*j=s都檢查了一遍，但是所有算式中的i、j、s需要滿足以下條件：

• 1<=i<100；
• 10<=j<1000；
• 對于String m = "" + i+ j;，m的長度必須==4;
• 對于String s = "" + (i * j);，s的長度必須==4;
• 組成m與s的數(shù)字必須相等；
• 因子i與中的數(shù)字不能重復；

題目中，我使用了ArrayList<Factor>，并創(chuàng)建了一個內部類：Factor，重寫了equals()方法，將所有正確的結果放入ArrayList<Factor>中，通過contains()方法排除了滿足交換律而重復的結果，最終得出12個結果,用時：101ms。

代碼

import java.util.ArrayList;
import java.util.Arrays;

public class Three {
    static int counter;

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        fourNumber();
        System.out.println(counter);
        long end = System.currentTimeMillis();
        System.out.println(end-start+"ms");
    }
    
    public static void fourNumber() {
        ArrayList<Factor> array = new ArrayList<Factor>();
        for (int i = 1; i < 100; i++) {
            for (int j = 10; j < 1000; j++) {
                String m = "" + i + j;
                String s = "" + (i * j);
                if (!isRepeat(String.valueOf(i), String.valueOf(j))
                        && m.length() == 4 && s.length() == 4) {
                    Factor factor = new Factor(i, j, Integer.parseInt(s));
                    if (isFind(m, s) && !array.contains(factor)) {
                        array.add(factor);
                        counter++;
                        System.out.println(i+"*"+j+"="+m);
                    }
                }
            }
        }
    }

    // 判斷a與b中是否出現(xiàn)了重復數(shù)字
    private static boolean isRepeat(String a, String b) {
        char[] arr1 = a.toCharArray();
        for (char c : arr1) {
            if (b.contains("" + c)) {
                return true;
            }
        }
        return false;
    }

    // 判斷組成m與s的數(shù)字是否相等
    private static boolean isFind(String m, String s) {
        char[] arr1 = m.toCharArray();
        char[] arr2 = s.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        boolean isFind = String.valueOf(arr1).equals(String.valueOf(arr2));
        return isFind;
    }

    // 內部類，重寫了equals方法
    private static class Factor {
        int a;
        int b;
        int c;

        public Factor(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

        public boolean equals(Object obj) {
            if (obj instanceof Factor) {
                Factor factor = (Factor) obj;
                if ((this.a == factor.a && this.b == factor.b && this.c == factor.c)
                        || (this.a == factor.b && this.b == factor.a && this.c == factor.c)) {
                    return true;
                }
            }
            return false;
        }
    }
}