So implementieren Sie die Summierung in Java ohne arithmetische Operatoren

Die Frage besagt, dass arithmetische Operatoren nicht verwendet werden können, sodass wir nur mit logischen Operatoren und Schiebeoperatoren beginnen können.

Wir wissen, dass die ^ (XOR)-Operation eine übertragsfreie Summe zweier Zahlen ist. Wenn die Addition zweier Zahlen keinen Übertrag ergibt, dann ist die Summe die Summe der beiden Zahlen. Dies ist der Schlüssel zur Lösung des Problems. Im Allgemeinen ergibt die Addition zweier Zahlen einen Übertrag. Um die richtige Summe zu erhalten, sollten wir einen Übertrag auf der Grundlage der „Summe ohne Übertrag“ addieren. Wir wissen, dass ein Übertrag auftritt, wenn die entsprechenden Positionen der beiden Zahlen 1 sind. Das heißt, unter der Bedingung, dass die entsprechenden Positionen A und B == 1 sind, können wir für jedes Bit einen Übertrag erhalten, aber der Übertrag muss addiert werden diese 1 auf die entsprechende höhere Ziffer, also verschieben wir den erhaltenen Übertrag um eine Ziffer nach links und addieren ihn dann zur zuvor erhaltenen „Summe ohne Übertrag“, um die Summe der beiden Zahlen zu erhalten.

Wir haben festgestellt, dass wir hier unendlich viele Matroschka-Puppen haben können, um die Summe aus „Summe ohne Übertrag“ und „erzeugter Übertrag“ zu erhalten. Die vorherige Operation wird ebenfalls wiederholt, bis die beiden Zahlen keinen Übertrag mehr erzeugen können und das Ergebnis direkt durch die ^-Operation erhalten werden kann.

Angenommen, wir finden den Wert von 23 + 16

Entsprechend Zur obigen Idee können wir den Code einfach schreiben

public static int addAB(int A, int B) {
		// 当两数的产生的进位为 0,就退出循环，返回其无进位和，就是结果
        while ((A & B) != 0) {
            int A_B = A ^ B;// 无进位求和
            int AB = (A & B) << 1;// 得到进位
            // 接下来就是求 得到的进位 + 无进位之和，重复前面的操作，直到不产生进位
            A = A_B;
            B = AB;
        }
        // 最后返回新的无进位之和
        return (A ^ B);
    }

Um seine Richtigkeit zu überprüfen, verwenden wir hier einen Logarithmierer, um die Funktion mit dem Operator ’

public static void main(String[] args) {
    int count = 1_0000_0000;// 比较次数 100000000次
    Random random = new Random();// 生成随机数字
    boolean flag = true;// 相等则为 true

    for (int i = 0; i < count; i++) {
        int num1 = random.nextInt(Integer.MAX_VALUE/2);// 随机正数1
        int num1_2 = random.nextInt(Integer.MAX_VALUE/2);// 随机正数2
        // 随机正数1 + 随机正数2
        if ((num1+num1_2) != addAB(num1,num1_2)){
            // 有一次不相等的，则退出循环
            flag = false;
            break;
        }

        int num2 = -random.nextInt(Integer.MAX_VALUE/2);// 随机负数1
        int num2_2 = -random.nextInt(Integer.MAX_VALUE/2);// 随机负数2
        // 随机负数1  + 随机负数2
        if ((num2+num2_2) != addAB(num2,num2_2)){
            // 有一次不相等的，则退出循环
            flag = false;
            break;
        }

        int num3 = random.nextInt(Integer.MAX_VALUE);// 随机正数
        int num4 = -random.nextInt(Integer.MAX_VALUE);// 随机负数
        // 随机正数  + 随机负数
        if ((num3+num4) != addAB(num3,num4)){
            // 有一次不相等的，则退出循环
            flag = false;
            break;
        }
    }
    System.out.println(flag);
}

Laufergebnis:

Das endgültige Ausgabeergebnis ist wahr, was darauf hinweist, dass wir zufällig generierte positive Zahlen + positive Zahlen berechnen , Negative Zahlen + negative Zahlen und positive Zahlen + negative Zahlen wurden jeweils 100.000.000 Mal ohne Fehler wiederholt, was darauf hinweist, dass die Funktion zuverlässig ist.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Summierung in Java ohne arithmetische Operatoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!