Binärzähler?

lounsome

Hallo

Ich würde gerne einen Binärzähler programmieren, das Ergebnis sollte in etwa so aussehen:
*
0000000
0000001
0000010
0000011
0000100
...
..
.
usw.
*

Hat von euch jemand ne Idee, wie ich das anstellen könnte?

Gruß Leo

akari

Hallo

zähl eine Integer-Variable hoch und gib sie binär aus.

bis bald
akari

net 0

oder sowas:

#include <stdio.h>

void binary_counter (char *p)
{
   (*p)++;
   if (*p == '2')
   {
      *p = '0';
      binary_counter (p-1);
   }
}

void main (void)
{
   char number[] = "000000000000000000000000";
   for (;;)
   {
      printf ("%s\n", number);
      binary_counter (number + strlen(number)-1);
   }   
}

Phoemuex

oder sowas:

#include <iostream>

using namespace std;

int main()
{
    int zahl = 0;
    cin >> zahl;
    int zahl2 = 1;
    zahl2 <<= 30;
    for(int i = 0; i < 31; ++i)
    {
        if(zahl & zahl2)
        {
            cout << '1';
        }
        else
        {
            cout << '0';
        }
        zahl2 >>= 1;
    }
    cin.get();
    cin.get();
    return 0;
}

P.S.:

[b] void [/b] main (void)

net 0

Phoemuex schrieb:

P.S.:

[b] void [/b] main (void)

ich seh' das nicht so eng

David_pb

Solltest du aber schon tun!

volkard

net schrieb:

void binary_counter (char *p)
{
   (*p)++;
   if (*p == '2')
   {
      *p = '0';
      binary_counter (p-1);
   }
}

uih! das ist aber mal ein heißer einsatz für unsere freundin die rekursion.

void binary_increment (char *p)
{
   (*p)++;
   while (*p == '2')
   {
      *p = '0';
      --p;
      (*p)++;
   }
}

und (*p)++ sieht unfein aus.

void binary_increment (char *p)
{
   ++*p;
   while (*p == '2')
   {
      *p = '0';
      --p;
      ++*p;
   }
}

noch den schleifenkörper um eine zeile rotieren

void binary_increment (char *p)
{
   while (*p == '1')
   {
      ++*p;
      *p = '0';
      --p;
   }
}

so, und jetzt die main noch pinpen.

int main () 
{ 
   char number[] = "000000000000000000000000"; 
   for (;;) 
   { 
      printf ("%s\n", number); 
      binary_increment (number + strlen(number)-1); 
   }   
}

kein abbruch und absturz am ende.

int main () 
{ 
   char number[] = "0000000000000000000000000"; //eine mehr als nötig
   for (;number[0]=='0';) 
   { 
      printf ("%s\n", number+1); 
      binary_increment (number + strlen(number)-1); 
   }   
}

oder

int main () 
{ 
   char mem[] = "0000000000000000000000000"; //eine mehr als nötig
   char* number=mem+1;
   char* last=mem+sizeof(mem)-1;//richtig gezählt?
   while (mem[0]=='0') 
   { 
      printf ("%s\n", number); 
      binary_increment (last); 
   }   
}

meistens versuche ich, vorwärts durchzulaufen, also
00000
10000
11000
00100
10100
...

camper

void binary_increment(char *p)
{
    while ( ( *p-- ^= '0' ^ '1' ) == '0' );
}

net 0

camper schrieb:

void binary_increment(char *p)
{
    while ( ( *p-- ^= '0' ^ '1' ) == '0' );
}

sehr schön
das gehört auf 'ne webseite mit tollen code snippets.

btw: mit meiner version kann man aber auch dezimal, oktal oder sonstwie zählen (einfach mit dem 'if (*p == ...)' auf die erste, nicht erlaubte ziffer prüfen).

volkard

nets code, wenn man ihn auch so verfrickelt.

void binary_increment (char *p) //p zeigt auf \0
{ 
   while ((*--p)++ == '2') *p='0';
}

wird aber leider nicht schneller davon.

edit: übrigens war das beinahe die schleife, wo der microsoftcompiler für while und for andere geschwindigkeiten hervorgebracht hat und while schneller als for war (normalerweise isses gleich oder for ist schneller).
die schlimme schleife ging vorwärts und hat gegen 0 gestetet.

while (~((*++p)++));

wenn ich mich recht erinnere. da sind SCHRECKLICHE dinge passiert. zum beispiel war ~ schneller als !. und diese while-schleife war schneller als jeder leichter lesbare code.

lounsome

Krass !

Konrad Rudolph

volkard schrieb:

net schrieb:
void binary_counter (char *p)
{
   (*p)++;
   if (*p == '2')
   {
      *p = '0';
      binary_counter (p-1);
   }
}
uih! das ist aber mal ein heißer einsatz für unsere freundin die rekursion.

Ja, finde ich auch. Was ist hier gegen Rekursion zu sagen? Ich hätte es genauso gemacht.

volkard

Konrad Rudolph schrieb:

Ja, finde ich auch. Was ist hier gegen Rekursion zu sagen? Ich hätte es genauso gemacht.

rekursion, finde ich, ist angebrachter bei teile-und-herrsche-ansätzen. ein einfaches lauf, solange du kannst, ist als schleife naheliegender.
außer natürlich in sprachen, die traditionell viel rekursion einsetzen, da gehört c++ aber nicht wirklich dazu.

OkaR

Ich bin noch c++ anfänger, da ich die Aufgabe aber interessant fand hab ich mich heute mal mit so einem Binärzhäler beschäftigt.
hatte mehrere vorgängerversionen, die alle nur käse rausbrachten. auch der versuch ein dynamisches array zu nehmen stellte sich als kompliziert und vor allem unnötig raus.
so nun wollt ich einfach ma wissen was ihr davon haltet ^^
hier mein prog:

#include<iostream>
#include<cmath>
using namespace std;

int calcStellen(int);
void fuellen(int const& Stellen, int const& StellenTmp);
int main()
{
	int Zahl=20;//Zahl=Zahl bis zu der gezaehlt werden soll
	cout<<"Bis zu welcher Zahl soll der Binaerzaehler zaehlen?\n";
	cin>>Zahl;
	int Stellen=calcStellen(Zahl);//Stellen==Stellen der Zahl bis zu der gezaehlt werden soll
	for(int i=0;i<=Zahl;++i)     //Zahlen bis zur gewuenschten Zahl durchgehen
	{
		int StellenTmp;
		StellenTmp=calcStellen(i);//StellenTmp=Stellen der aktuellen Zahl
		fuellen(Stellen,StellenTmp);//Mit Nullen auffuellen
		int ZahlTmp=i;
		for(int j=StellenTmp;j>0;--j)     //Funktion jeweilige Zahl 
		{
			if(ZahlTmp-pow(double(2),(j-1))>=0)
			{
				cout<<1;
				ZahlTmp=ZahlTmp-(pow(double(2),(j-1)));				
			}else
				cout<<0;
		}	
		cout<<"\n";
	}
}

void fuellen(int const& Stellen, int const& StellenTmp)
{
	for(int j=0;j<(Stellen-StellenTmp);++j) //Mit Nullen fuellen
	{
		cout<<'0';
	}
}

int calcStellen(int Zahl)
{
	if(Zahl==0) return 1;
	int times=0;
	while(Zahl>0)
	{
		Zahl=Zahl/2;
		++times;
	}
	return times;
}

net 0

OkaR schrieb:

so nun wollt ich einfach ma wissen was ihr davon haltet ^^

naja, etwas umständlich im vergleich zu campers variante

OkaR schrieb:

int calcStellen(int Zahl)
{
	if(Zahl==0) return 1;
	int times=0;
	while(Zahl>0)
	{
		Zahl=Zahl/2;
		++times;
	}
	return times;
}

kannste z.b. so machen:

#define calcStellen(zahl) 1+(int)(log(zahl)/0.693147)

oder mal wieder was rekursives:

int calcStellen (int x)
{
   if (x < 2)
      return 1;
   return 1 + calcStellen (x>>1);
}