ich moechte zwei binaer strings addieren...

ich weiss das folgender code nicht besonders schoen ist, wie kann ich die lesbarkeit/performance verbessern?

#include <iostream>
#include <string>
#include <vector>
using namespace std;

/*
a = "1100"
b = "111"
addiere beide strings und gebe folgendes zurueck: "10011".
*/

string zeroPadding(string s, int bits) {
	for (int i = 0; i < bits; i++) {
		s = "0" + s;
	}
	return s;
}

class MyPair {
public:
	char first;
	char second;
	MyPair(char first_, char second_): first(first_), second(second_) {}
};

string addBinary(string a, string b) {
	int len1 = a.size();
	int len2 = b.size();
	string result;
	char carry = '0';
	char sum = '0';                   // a=0,b=0       // a=0,b=1
	vector<vector<MyPair>> andVec = {{MyPair('0','0'), MyPair('1','0')},
	                                  // a=1,b=0       // a=1,b=1
								     {MyPair('1','0'), MyPair('0','1')}};
                                               // a=0,b=0       // a=0,b=1
	vector<vector<MyPair>> andVecWithCarry = {{MyPair('1','0'), MyPair('1=0','1')},
	                                           // a=1,b=0       // a=1,b=1
								              {MyPair('0','1'), MyPair('1','1')}};	
	if (len1 < len2) {
		a = zeroPadding(a, len2 - len1);
	} else if (len1 > len2) {
		b = zeroPadding(b, len1 - len2);
	}

	for (int i = len1 - 1; i >= 0; i--) {
		if (carry == '0') {
			auto p = andVec[a[i] - '0'][b[i] - '0'];
			sum = p.first;
			carry = p.second;
		} else if (carry == '1') {
			auto p = andVecWithCarry[a[i] - '0'][b[i] - '0'];
			sum = p.first;
			carry = p.second;
		}

		result = sum + result;
	}

	if (carry == '1') {
		result = carry + result;
	}

	return result;
}

int main() {
	// your code goes here

	cout << addBinary("1100", "111") << endl;

	return 0;
}

ich weiss das folgender code nicht besonders schoen ist, wie kann ich die lesbarkeit/performance verbessern?

Kommt drauf an, was das Ziel ist. Rechnen mit binären Strings und Performance passt von Grund auf nicht zusammen. Wenn es also um eine echte Anwendung geht, dann wäre die richtige Hilfestellung, dir zu helfen, wie du diesen Fall von Vorhinein vermeiden kannst. Wenn es um die Addition binärer Strings als Selbstzweck geht, dann geht das natürlich trotzdem viel schöner und schneller. Ich gucke jetzt absichtlich nicht bei Wikipedia, um dir einen Einblick zu geben, wie man solche Probleme angeht. Denn der erste Tipp ist: Mal bei Wikipedia gucken, ob es effiziente Additionsalgorithmen für das Binärsystem gibt.

Weitere technische Fehler, die sofort auffallen:

'1=0'

Hast etwa du den Code abgetippt fürs Forum oder steht das wirklich da? Beides ist nicht gut. Immer Copy & Paste fürs Forum benutzen. Oder Compilerwarnungen aktivieren und beachten. Je nachdem, welche Antwort zutrifft.

Statische Lookuptables initialisiert man nicht bei jedem Funktionsaufruf. Statische Felder stopft man nicht in einen Vector. Erst recht nicht "rechteckige" Felder in einen vector<vector>.
Ein Lookuptable für 4 Kombinationen klingt sowieso reichlich ineffizient, würde ich gar nicht erst so machen.

Das mit dem Padding sieht spontan auch nicht elegant aus. Geht sicher genau so gut oder besser, wenn man es einfach weg lässt.

Und jetzt gucke ich mal auf Wikipedia nach und vielleicht schreibe ich selber was, mal sehen, habe gerade anderweitig zu tun.

string binary_add(string lhs, string rhs)
{
  size_t size = max(lhs.size(), rhs.size()); 
  lhs.insert(lhs.begin(), size - lhs.size(), '0');
  rhs.insert(rhs.begin(), size - rhs.size(), '0'); 
  unsigned int carry = 0;
  string result(size, '\0');

  for (size_t i = size; i != size_t(-1); --i)
    {
      unsigned int intermediate_result = carry + lhs[i] - '0' + rhs[i] - '0';
      switch (intermediate_result)
        {
        case 0:
          carry = 0;
          result[i] = '0';
          break;
        case 1:
          carry = 0;
          result[i] = '1';
          break;
        case 2:
          carry = 1;
          result[i] = '0';
          break;
        case 3:
          carry = 1;
          result[i] = '1';
          break;
        }
    }

  if (carry) result.insert(result.begin(), '1');

  return result;
}

Das ganze ist halt relativ unschön, da die Zahlen hier big endian dargestellt werden. Daher muss man rückwärts durch die Strings laufen (damit kann man ja noch leben) und mehrmals Einfügungen am Anfang machen (wofür strings eine denkbar ungeeignete Datenstruktur sind) und hat zudem noch zwei teure Stringkopien^*.

Und das war's dann auch schon. Denn ich fand keinen coolen Trick für binäre Addition. Auf Wikipedia wird eine "long carry" Methode beschrieben. Das scheint aber eine Methode rein für den menschlichen Gebrauch mit Zettel und Stift zu sein. Denn es geht um das Ausnutzen gewisser Muster in den Zahlen. Ein Mensch findet diese auf einen Blick, aber der Computer muss letztlich doch alle Ziffern angucken, genau wie jetzt auch. Ob er dann mit diesen Ziffern eine triviale Rechenoperation durchführt oder darin Muster sucht, ist keine Vereinfachung, ja eher eine Verkomplizierung. Die Methode ist interessant und werde ich mir merken, für den Fall, dass ich mal in die Verlegenheit komme, binär auf Papier zu addieren, aber ich werde es nicht im Computer implementieren.

^*: Das sind natürlich lösbare Probleme, aber dann ist der Code nicht mehr schön und knackig und man hat bei jedem Zugriff einen Haufen if-Abfragen, die man sich hier spart.

unsigned int intermediate_result = carry + lhs[i] - '0' + rhs[i] - '0';
      switch (intermediate_result)
        {
        case 0:
          carry = 0;
          result[i] = '0';
          break;
        case 1:
          carry = 0;
          result[i] = '1';
          break;
        case 2:
          carry = 1;
          result[i] = '0';
          break;
        case 3:
          carry = 1;
          result[i] = '1';
          break;
        }

Warum nicht:

unsigned int intermediate_result = (carry + lhs[i] - '0' + rhs[i] - '0');
result[i] = intermediate_result & 0x01;
carry = intermediate_result & 0x02;

result[i] = intermediate_result & 0x01 + '0';

Warum nicht: [...]

Weil:

SeppJ schrieb:

Habe etwas Zeit gefunden. Erst einmal die einfachste Implementierung, die mir eingefallen ist. Nutzt die gleiche Methode, wie dein Programm, sollte aber effizienter und lesbarer sein als der Lookuptable. Das Padding war übrigens vielleicht doch eine gute Idee, zumindest, wenn man es einfach haben will :

PS: Warum schreibst du 0x01 statt 1 und 0x02 statt 2? Ist dezimal nicht 0x539 genug?

PS: Warum schreibst du 0x01 statt 1 und 0x02 statt 2? Ist dezimal nicht 0x539 genug?

Reine Angewohnheit aus meiner fruehen hardwarenahen Sozialisierungsphase. Die Regel in der Firma war, dass alle Bitmasken hexadezimal geschrieben werden mussten.

Sobald es der Compiler unterstuetzt wird auf binary literals umgestellt.

Da war im Uebrigen noch ein Fehler drin, das Carry-bit muss auf 0/1 geschoben werden.

unsigned int intermediate_result = carry + (lhs[i] - '0') + (rhs[i] - '0');

result[i] = intermediate_result & 0b01 + '0'; // mask binary sum
carry = (intermediate_result & 0b10)>>1; // mask carry and shift to LSB

Ich empfinde das einfacher zu lesen und zu verstehen als einen Case-switch, aber das ist wohl eher dem Umfeld in dem ich programmieren gelernt habe geschuldet.