Zahlen erstellen lassen?



  • Das hier geht (bedenke die Console zeigt nicht mehr als 300 Zeilen an, jedenfalls bei mir!)

    unsigned int i = 0, j = 0, k = 0; 
    
    while(i < 10)
    {
    	while(j < 10)
    	{
    		while(k < 10)
    		{
    			cout << i << j << k << endl;
    			k = k + 1;
    		}
    		k = 0;
    		j = j + 1;
    	}
    	j = 0;
    	i = i + 1;
    }
    


  • Dein Code gibt schon alle Zahlen aus, dennoch hier mal den kürzeren (und imho verständlicheren) Code:

    #include <iostream>
    
    int main()
    {
        for(unsigned int i = 0; i<10; ++i)
            for(unsigned int j = 0; j<10; ++j)
                for(unsigned int k = 1; k<10; ++k)
                    std::cout << i << j << k << std::endl;
    }
    


  • @muli: Hab ich mir auch schon gedacht, dass meine Konsole den Anfang nicht ausgibt. Wie bring ich sie denn noch dazu?

    Ich hab hier nun meinen fertigen Code. Er soll mir aus allen Zahl von 0 bis 999 die narzissistischen Zahlen (auch Armstrong Zahlen) raussuchen. Wenn ihr den Code mal durchgeht, dann werdet ihr sehen, dass auf grund der if-Schleife 0 und 1 auch als gültige "Armstrong-Zahl" erkannt wird, da 0*100+0*10+0*1=0 gleich 0*0*0+0*0*0+0*0*0=0 und auch 1*100+1*10+1*1=1 gleich 1*1*1+1*1*1+1*1*1=1 ist. Wie kann ich das nun umgehen und nur die wirklichen Armstrong-Zahlen ausgeben?

    #include<iostream>
    using namespace std;
    
    //Funktionendeklaration
    
    int kubik(unsigned int x)
    {
        unsigned int y;
    
        y = x * x * x;
        return y;
    }
    
    //Hauptfunktion
    
    int main()
    {
        unsigned int i, j, k, z, a, b, c;
    
    i = 0;
    while(i < 10)
    {
     j = 0;
     while(j < 10)
     {
      k = 0;
      while(k < 10)
      {
       //cout << i << j << k << endl;
       a = i * 100 + j * 10 + k * 1;
       //b = i * i * i + j * j * j + k * k * k;
       b = kubik(i) + kubik(j) + kubik(k);
    
         if(a == b)
         {
            cout << a << endl;
         }
       k = k + 1;
      }
      j = j + 1;
     }
     i = i + 1;
    }
    
    system("pause");
    return 0;
    }
    


  • Ich hab jetzt noch die Bedingung für die Abfrage der if-Schleife zu dem hier verändert:

    if((a == b) && (a != 0) && (a != 1))
    

    Das dumme daran ist, dass ich mir nicht sicher bin ob denn nun 0 und 1 wirklich keine Armstrong Zahl ist. Laut Wikipedia aber nicht...



  • bandchef schrieb:

    @muli: Hab ich mir auch schon gedacht, dass meine Konsole den Anfang nicht ausgibt. Wie bring ich sie denn noch dazu?

    Über die Eigenschaften der Konsole selbst. Reiter Layout > Fensterpuffergröße

    bandchef schrieb:

    1*100+1*10+1*1=1 gleich 1*1*1+1*1*1+1*1*1=1

    😕 Adam Ries würde sich im Grabe umdrehen, wenn er das sehen würde 👎

    wikipedia schrieb:

    Die PPDI sind narzisstische Zahlen, deren Summe ihrer Ziffern, jeweils potenziert mit der Stellenanzahl der Zahl, wieder die Zahl selbst ergibt

    von daher sind bei einstelligen Zahlen auch die 0 und 1 narzistische Zahlen.

    Siehe hierzu auch folgende Tabelle:
    http://mathworld.wolfram.com/NarcissisticNumber.html



  • bandchef schrieb:

    @padreigh: Sorry, aber auch bei deinem Beispiel werden nur Zahl von 701 bis 999 bei mir ausgegeben. Ich denke das Problem liegt nich an der Programmierung!

    Und so wie du das gemacht hast, hilft es mir nicht viel, da ich mit jeder einzelnen Zahl die mir die Schleife "berechnet" noch einen vergleich anstellen soll!

    D.h. ich muss es so machen wie ich!

    Erstens glaub ich das nicht, zweitens sag ich dir auch wieso:
    Zahlen 1-9: insgesamt 9 Stellen
    Zahlen 10-99: insgesamt 892 Stellen
    Zahlen 100-999: insgesamt 899
    3 Stellen
    In Summe so ca 2850 Zeichen ... das ist bei ner normalen Konsole mit 80er Breite roundabout 250 Zeilen ... damit viel mehr als dein Bildschirm hoch ist ... alle werden ausgegeben - du SIEHST nur die letzten 200somewhats.
    wenn du nach jeder nen "\n" machst sinds ziemlich genau 999 Zeilen ... auch das ist mehr als dein Schirm frisst 🙂

    Und ... du "musst" das garnicht so machen, es ginge zB auch so:

    for (int i=0; i < 1000; ++i)
    {
        int hunderter = i / 100;
        int zehner = (i - hunderter*100) / 10;
        int einer = (i - hunderter*100 - zehner*10);
    
        // qed :D
    }
    


  • Hm, da hab ich wohl wirklich dumme Sachen geschrieben mit,

    1*100+1*10+1*1=1 gleich 1*1*1+1*1*1+1*1*1=1

    Aber warum lässt dann die Schleife wirklich 1 zu?



  • 0*100 + 0*10 + 1*1
    

    rechne es aber lieber nochmal nach 😃



  • Wenn ich mir nun nochmal die Schleife ansehe, dann läuft doch folgendes ab. Im ersten Moment ist i=j=k=0. Das heißt alle Schleifen werden übersprungen bis man in der innersten ist. Dort wir dann a = 0*100 + 0*10 + 0*1 gerechnet. Jetzt wird k = k + 1, j = j + 1 und i = i + 1 gerechnet. Und dann hab ich ja gleich als nächste Rechnung für a das stehen: a = 1*100 + 1*10 + 1*1, oder?

    Oder ist es so, dass wenn die if-Schleife nach dem ersten Durchgang erfüllt war als letzter Teil des ersten Durchgangs k = k + 1 gerechnet und dann wieder ganz nach vorne zum ersten while gesprungen wird? Ich denke so ist's, stimmts?



  • Nach deinem Muster würde aber

    000
    111
    222
    333
    444
    555
    666
    777
    888
    999
    

    Wie erklärst du dir dann also die 153 🙄

    Deine innerste Schleife hat die Bedingung k<10.
    Somit kommt nach 000 erstmal 001

    Mach nen Schreibtischtest 😉



  • Was ist ein Schreibtischtest?



  • bandchef schrieb:

    Was ist ein Schreibtischtest?

    Auf Papier die Variablen aufschreiben und das Programm Befehl für Befehl im Kopf durcgehen und die Variablen immer aktualisieren.



  • Wenn ich jetzt die Schreibtischtest mache, komm ich in der Tat auf

    000
    111
    222
    333
    444
    555
    666
    777
    888
    999
    

    Ich weiß aber nicht wie meine "Denke" falsch ist...



  • Auf die Ergebnisse komme ich aber, wenn ich jedesmal nach dem i=0 und j=0 waren und k<10 j = j + 1 und i = i + 1 überspringe, und nur j = j + 1 rechne, wenn k<10 nicht mehr erfüllt ist. So stimmts doch jetzt...



  • Entschuldige bitte 🤡 ... mein Fehler.
    Ein PAP oder Structogramm könnte dir weiterhelfen, aber dazu bietet die Eingabenmaske hier keine Buttons. Ich versuch es mal bildhaft zu argumentieren:

    int i=0;
    
    // fuehre die Schleife solange aus, wie i kleiner 10
    while(i < 10)
    {
        int j=0;
    
        // fuehre die Schleife solange aus, wie j kleiner 10 
      -> while(j < 10)
     |  {
     |      // j um 1 erhoehen
     |      cout << i << "-" << j << endl;
     |      j++;
      --}
        // i um 1 erhoehen, wenn Schleife davor j >= 10 erreicht hat
        i++;
    }
    

    Ausgabe:

    i  j
    ----
    0  0
    0  1
    0  2
    usw
    1  0
    1  1
    1  2
    usw
    9  0
    9  1
    


  • Danke für deine ausführliche Erklärung. Ich hab's mir jetzt zusätzlich in Visual Studio 2010 mit dem Debugger angesehen. Da sieht man es sehr schön, dass die innerste while-Schleife so lange ausgeführt ist, bis k=10 ist und erst dann zum ersten mal die zweite while-Schleife (von "außen" gesehen; du weißt schon was ich meine... :-)) ausgeführt wird und j = j + 1 gerechnet wird...


Anmelden zum Antworten