Algorithme pour l'arithmétique binaire en Java

Le code suivant implémente l'ajout binaire sans réellement faire des arithmétique binaire ou autre. Le vrai "plus" est fait par lookupTable, et tout le reste est linéaire jusqu'à la manipulation de chaînes. Je l'ai écrit avec l'intention de le faire aussi instructif que possible, mettant l'accent sur le processus plutôt que de l'efficacité. Espérons que cela aide.

public class BinaryArithmetic {
static String[] lookupTable = {
"0+0+0=00",
"0+0+1=01",
"0+1+0=01", 
"0+1+1=10",
"1+0+0=01",
"1+0+1=10",
"1+1+0=10",
"1+1+1=11",
};
static String lookup(char b1, char b2, char c) {
String formula = String.format("%c+%c+%c=", b1, b2, c);
for (String s : lookupTable) {
if (s.startsWith(formula)) {
return s.substring(s.indexOf("=") + 1);
}
}
throw new IllegalArgumentException();
}
static String zeroPad(String s, int length) {
while (s.length() < length) {
s = "0" + s;
}
return s;
}   
static String add(String s1, String s2) {
int length = Math.max(s1.length(), s2.length());
s1 = zeroPad(s1, length);
s2 = zeroPad(s2, length);
String result = "";
char carry = '0';
for (int i = length - 1; i >= 0; i--) {
String columnResult = lookup(s1.charAt(i), s2.charAt(i), carry);
result = columnResult.charAt(1) + result;
carry = columnResult.charAt(0);
}
if (carry == '1') {
result = carry + result;
}
return result;
}
public static void main(String args[]) {
System.out.println(add("11101", "1001"));
}
}

---

Pendant que nous y sommes, je pourrais aussi bien faire multiply trop.

static String multiply(String s1, String s2) {
String result = "";
String zeroSuffix = "";
for (int i = s2.length() - 1; i >= 0; i--) {
if (s2.charAt(i) == '1') {
result = add(result, s1 + zeroSuffix);
}
zeroSuffix += "0";
}
return result;
}

Les algorithmes, depuis wikipédia:

Plus:

La plus simple opération arithmétique dans
binaire est plus. L'ajout de deux
un seul chiffre les nombres binaires est
relativement simple, à l'aide d'un formulaire de
réalisation:

0 + 0 → 0
0 + 1 → 1
1 + 0 → 1
1 + 1 → 0, carry 1 (since 1 + 1 = 0 + 1 × 10 in binary)

L'ajout de deux "1" chiffres génère un chiffre
"0", tandis que 1 devront être ajoutés à
la colonne suivante.

Soustraction:

Soustraction fonctionne de la même
moyen:

0 − 0 → 0
0 − 1 → 1, borrow 1
1 − 0 → 1
1 − 1 → 0

La soustraction d'un "1" chiffres de "0"
chiffres produit le chiffre "1", tandis que 1
devra être soustraite de la
colonne suivante. Ceci est connu comme
d'emprunt. Le principe est le même
comme pour le transport. Lorsque le résultat d'un
la soustraction est inférieure à 0, le moins
possible de la valeur d'un chiffre, l'
la procédure consiste à "emprunter" le déficit
divisé par la racine (qui est, 10/10)
à partir de la gauche, de le soustraire de la
à côté de position de la valeur.

Multiplication:

Multiplication en binaire est similaire à
ses décimales homologue. Deux numéros Un
et B peut être multipliée par partielles
produits: pour chaque chiffre dans B, le
le produit de ce chiffre dans Un est
calculer et à écrire sur une nouvelle ligne,
décalée vers la gauche de sorte que son plus à droite
chiffres avec les chiffres en B
qui a été utilisé. La somme de tous ces
produits partiels donne au final
résultat.

Il n'y a que deux chiffres dans
binaire, il y a seulement deux
les résultats de chaque partiel
multiplication:

* If the digit in B is 0, the partial product is also 0
* If the digit in B is 1, the partial product is equal to A

Par exemple, les nombres binaires 1011
et 1010 sont multipliés comme suit:

 
1 0 1 1 (A) 
× 1 0 1 0 (B) 
--------- 
0 0 0 0 ← Correspond à un zéro en B 
+ 1 0 1 1 ← Correspond à un B 
+ 0 0 0 0 
+ 1 0 1 1 
--------------- 
= 1 1 0 1 1 1 0 

Convertir les chaînes binaires d'Entiers et ensuite fonctionner sur les Entiers, par exemple

String add(String s1, String s2) {
int i1 = Integer.parseInt(s1);
int i2 = Integer.parseInt(s2);
return Integer.toBinaryString(i1 + i2);
}