Ich will mir alle Zahlen von 1 - 999 durch Schleifen ausgeben lassen. Mein bisheriger Code sieht so aus:

int main()
{
    unsigned int i = 0, j, k, a, b, c;

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

Warum aber geben mir diese verschachtelten while-Schleifen nur so die Hälfte aus? Könnt ihr mir helfen?

Jetzt hab ich meine Schleife schon mal so hingebracht, dass sie mir von 701 bis 999 zählt. Aber ich will halt von 001 - 999 zählen lassen. Hier der Code:

int main()
{
    unsigned int i, j, k, a, b, c;

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

int i;
for (i=0;i<1000;++i) 
    std::cout << i;

i=0;
while (i < 1000){
    std::cout << i++;
}

i=0;
do { 
    std::cout << i;
} while (++i < 1000)
;

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!

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;
}

#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;
}

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;
}

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...

@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

@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 8993 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
}

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?

rechne es aber lieber nochmal nach

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?

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?

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

000
111
222
333
444
555
666
777
888
999

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

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