Prüfen, ob Zahl Zweier oder Dreierpärchen 1 oder 0 hat



  • Hi,

    ich würde gerne wissen, wie man herausfinden kann, ob in einer Zahl ein Zweierpärchen oder Dreierpärchen der Zahl 0 oder 1 auftritt, auf binärer Ebene.
    Angenommen, die Zahl 5 wird eingegeben. Die Zahl lautet binär ja 0101.
    Es soll nun ausgegeben werden, ob die Folgen '00', '000', '11' und '111' vorhanden sind.
    Wie bewerkstellige ich das? Geht das mit den logischen Operatoren & bzw. |?



  • Mittels

    zahl & (1 << bit)
    

    kannst du für jedes bit herausfinden, ob es gesetzt ist. Und dann mit einer Schleife überprüfen.

    Du könntest aber auch einfach die Binärzahl als String konvertieren und dadrin dann die Teilsequenzen suchen.



  • Kababär schrieb:

    Angenommen, die Zahl 5 wird eingegeben. Die Zahl lautet binär ja 0101.

    Warum nicht 00101 oder 00000101? Oder nur 101?

    Soll also in einer 4-Bit-Zahl nach der Folge 000 gesucht werden oder allgemein für irgendeine Zahl, wobei führende Nullen ignoriert werden sollen? Konkret: wenn deine Zahl 1 ist, (0001b), ist in ihr dann die Folge 000 enthalten?

    Wie bewerkstellige ich das? Geht das mit den logischen Operatoren & bzw. |?

    Solange die zahl>0 ist, ermittelst du das rechte Bit mit zahl&1 und schiebst sie dann eins nach rechts: zahl = zahl >> 1 . Du musst nur zählen, wie oft hintereinander 1 bzw. 0 rauskommt.



  • Danke für die Rückmeldungen. Ich habe es nun hinbekommen! Das erste Mal, dass ich mit den Operatoren arbeiten muss. Vielen Dank!

    Mein Code sieht derzeit so aus:

    #include "stdafx.h"
    #include <iostream>
    
    int main()
    {
    	int zahl = 7;
    	int counter = 0;
    	while (zahl > 0) {
    		std::cout << "Zahl Anfang (while): " << zahl << std::endl;
    		int tmpZahl = zahl & 1;
    		if (tmpZahl == 1) {
    			counter++;
    			if (counter == 3) {
    				std::cout << "Zahl enthält 1er Drilling!" << std::endl;
    				break;
    			}
    		}
    		else {
    			counter = 0;
    		}
    		zahl = zahl >> 1;
    
    	}
    
        return 0;
    }
    


  • Wenn ich es allerdings für 0en versuche, zählt er immer eine 0 zu viel..

    #include "stdafx.h"
    #include <iostream>
    
    int main()
    {
    	//std::cout << "Please enter a positive number: " << std::endl;
    	int zahl(1), counter=0;
    	//std::cin >> zahl;
    
    	while (zahl > 0) {
    		int tmp = zahl & 0;
    		if (tmp == 0) {
    			counter++;
    		}
    		zahl = zahl >> 1;
    	}
    	std::cout << "The number you entered contains " << counter << " zeros" << std::endl;
        return 0;
    }
    

    Eine 1 ist doch 1 oder 01, etc. Die counter-Variable hat nach der Schleife den Wert 1. Erwartet hätte ich 0. Setze ich die zahl-Variable auf 3, steht counter nach der Schleife auf 2. Wieso ist das so?



  • Schau dir mal die Wahrheitstabellen von Boolschen Operationen an.

    Hint: X AND 0 == 0. immer.



  • Ich komm nicht drauf klar. Daher habe ich einfach die Lösung für das Zählen der 1en genommen und die If-Abfrage negiert. Also

    if (tmpZahl != 1){...}
    


  • Irgendwie finde ich das unschön. Ich werf folgendes in den Raum.

    #include <array>
    #include <bitset>
    #include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
    	int number;
    	do
    	{
    		cout << "Positive Zahl eingeben: ";
    		cin >> number;
    	}
    	while( number < 0 );
    
    	auto str_number = bitset< 4 >( number ).to_string();
    	cout << "Deine Zahl in binär: " << str_number << endl;
    
    	array< string, 4 > search = { { "00", "000", "11", "111" } };
    	for( const auto& s : search )
    	{
    		if( str_number.find( s ) != string::npos )
    			cout << "Deine Zahl enthaelt " << s << endl;
    	}
    }