// Primzahlberechner
// Eingabe einer unteren und einer oberen Grenze
// Ausgabe aller dazwischen gefundenen Primzahlen

//Übersicht über die Variablen

//Teller  1:	konstanter Inhalt, 0
//Teller  2:	konstanter Inhalt, 1
//Teller  3:	konstanter Inhalt, 2
//Teller  4:	Kontrollvariable für die Schleife, 1 -> Primzahl, 0 -> keine  		--> prim
//Teller  5:	untere Grenze 														--> a
//Teller  6:	obere Grenze 														--> b
//Teller  7:	Schleifenvariable 1 												--> i
//Teller  8:	Schleifenvariable 2 												--> j
//Teller  9:	Bedingungsvariable für Schleife 2 									--> con1
//Teller 10:	Wert für if-Bedingung, Schleifenvariable 1 % Schleifenvariable 2 	--> con2
//Teller 11:	temporäre Variable 													--> temp1
//Teller 12:	temporäre Variable 													--> temp2
//Teller 13:	temporäre Variable 													--> temp3

//////////////////////////////////////////////////////////////////////////////////////////////

//Speicher beschaffen
Hole dir 13 Teller!

//Konstanten definieren -> Teller 1 ist initial Null!
Lege 1 Nudel auf Teller 2!
Lege 2 Nudeln auf Teller 3!

//Kontrollvariable für später --> prim = 1;
Lege 1 Nudel auf Teller 4!

//untere Grenze abfragen
Frag mich, 
	wieviele Nudeln auf Teller 5 liegen sollen! 
	
//obere Grenze abfragen
Frag mich,
	wieviele Nudeln auf Teller 6 liegen sollen!
	
//überprüfen, ob die obere Grenze kleiner, als die untere Grenze ist
//wenn es so ist die Inhalte von Teller 5 und 6 mit Hilfe von Teller 11 tauschen
Mache folgendes,

	//temp1 = a;
	lege so viele Nudeln, 
		wie auf Teller 5 liegen,
	auf Teller 11, 
	
	und
	
	//a += b; a -= temp1;
	lege soviele Nudeln,
		wie auf Teller 6 liegen,
	auf Teller 5,
	und 
	nimm soviele Nudeln,
		wie auf Teller 11 liegen,
	von Teller 5,
	
	und 
	
	//b += temp1; b -= a;
	lege soviele Nudeln, 
		wie auf Teller 11 liegen,
	auf Teller 6,
	und
	nimm so viele Nudeln, 
		wie auf Teller 5 liegen,
	von Teller 6,
	
	und
	
	//temp1 auf 0 setzen: temp1 -= temp1;
	nimm soviele Nudeln, 
		wie auf Teller 11 liegen,
	von Teller 11,
	
wenn Teller 5 voller als Teller 6 ist!

//Schleifenvariable 1 mit dem Wert der unteren Grenze initialisieren --> i=a;
Lege soviele Nudeln,
	wie auf Teller 5 liegen,
auf Teller 7!

//äußere Schleife
//durchläuft alle Zahlen von der unteren (a) bis zur oberen Grenze (b)
Wiederhole folgendes,
	
	//Schleifenvariable 2 richtig initialisieren --> j=2;
	lege 2 Nudeln auf Teller 8,
	
	und 
	
	//Bedingungsvariable für Schleife 2 richtig initialisieren
	wiederhole folgendes, 
		
		//++temp1
		lege 1 Nudel auf Teller 11,
		
		und 
		
		//++temp2
		lege 1 Nudel auf Teller 12,
		
		und
		
		//temp3 = temp1*temp2
		wiederhole folgendes,
			lege soviele Nudeln, 
				wie auf Teller 11 liegen,
			auf Teller 13,
			und
			nimm 1 Nudel von Teller 12,
		solange Teller 12 nicht leer ist,
	
	solange Teller 13 leerer als Teller 7 ist, 
	
	und
	
	//con1 = temp1 --> con1 ist nun die kleinste natürliche Zahl, die größer oder gleich sqrt(i) ist.
	lege soviele Nudeln,
		wie auf Teller 11 liegen,
	auf Teller 9, 
	
	und
	
	//temporäre Variablen zurück auf 0 setzen
	nimm soviele Nudeln,
		wie auf Teller 11 liegen,
	von Teller 11,
	und
	nimm soviele Nudeln,
		wie auf Teller 12 liegen,
	von Teller 12,
	und
	nimm soviele Nudeln,
		wie auf Teller 13 liegen,
	von Teller 13,
	
	und
	
	//innere Schleife
	//prüft die gerade betrachtete Zahl auf Teilbarkeit bezüglich aller Zahlen von 2 bis zu der kleinsten
	//natürlichen Zahl, die größer oder gleich der Quadratwurzel aus der gerade betrachteten Zahl ist.
	wiederhole folgendes,
		
		//temporäre Variablen mit den Werten von i und j initialisieren, also con2=i; temp1=j;
		lege so viele Nudeln, 
			wie auf Teller 7 liegen,
		auf Teller 10,
		und
		lege so viele Nudeln, 
			wie auf Teller 8 liegen,
		auf Teller 11,
		
		und
				
		//Division con2/temp1 berechnen und in temp2 speichern --> con2 enthält den Rest der Division (Modulo)
		Wiederhole folgendes,
			mache folgendes,
				nimm soviele Nudeln, 
					wie auf Teller 11 liegen,
				von Teller 10,
				und
				lege 1 Nudel auf Teller 12,
			wenn Teller 10 nicht leerer als Teller 11 ist,
		solange Teller 10 nicht leerer als Teller 11 ist,
		
		und 
		
		//temporäre Variablen zurück auf 0 setzen
		nimm soviele Nudeln,
			wie auf Teller 11 liegen,
		von Teller 11,
		und
		nimm soviele Nudeln,
			wie auf Teller 12 liegen,
		von Teller 12,
		
		und
		
		//ist i%j Null? --> i ist keine Primzahl --> prim = 0;
		mache folgendes,
			//prim -= 1;
			nimm 1 Nudel von Teller 4,
		wenn Teller 10 genauso voll wie Teller 1 ist,
		
		und
		
		//++j
		lege 1 Nudel auf Teller 8,
		
	solange Teller 8 nicht voller als Teller 9 ist und Teller 4 voller als Teller 1 ist,
	//innere Schleife zu Ende 
	
	und
	
	//hat die Kontrollvariable noch den Wert 1, dann ist die gerade 
	//betrachtete Zahl eine Primzahl und wird deshalb ausgegeben
	mache folgendes,
		sag mir,
			wieviele Nudeln auf Teller 7 liegen, 
	wenn Teller 4 genauso voll wie Teller 2 ist, 
	
	und
	
	//hat die Kontrollvariable micht mehr den Wert 1, dann ist die 
	//gerade betrachtete Zahl keine Primzahl --> Resetten der Kontrollvariable
	mache folgendes,
		lege 1 Nudel auf Teller 4,
	wenn Teller 4 genauso voll wie Teller 1 ist, 
	
	und
	
	//++i
	lege 1 Nudel auf Teller 7,
	
	und
	
	//Variablen con1 und con2 resetten
	nimm soviele Nudeln,
		wie auf Teller 9 liegen,
	von Teller 9,
	und 
	nimm soviele Nudeln,
		wie auf Teller 10 liegen,
	von Teller 10,
	
	und
	
	//Schleifenvariable 2 (j) resetten
	nimm soviele Nudeln,
		wie auf Teller 8 liegen,
	von Teller 8,
	
solange Teller 7 nicht voller als Teller 6 ist! 
	
Bis bald!