Die Hamster-Challenge

Aufgabe

Unten findest du Reiter mit drei Levels. Die Level sind verschiedene Schwierigkeitsstufen und haben unterschiedliche Voraussetzungen. Du wählst selbst aus, welche Challenges aus welchem Level du bearbeitest.

Deine Aufgabe ist es, so viele Punkte wie möglich zu sammeln. Jede Challenge bringt eine verschiedene Anzahl von Punkten. Pro Level können max. 17 Punkte erreicht werden. Notiere deine Punkte pro Level:

Level	Punkte
1	0
2	0
3	0

Level 1

Voraussetzungen

Challenge 1.1 - 1 Punkt

Der Hamster soll die Körner einsammeln.

Challenge 1.2 - 2 Punkte

Der Hamster soll die Körner einsammeln und im Lager deponieren. Du musst mindestens zwei eigene Methoden verwenden!

Ausgangssituation:

Zielsituation:

Challenge 1.3 - 2 Punkte

Der Hamster soll Slalom laufen. Verwende möglichst viele sinnvolle eigene Methoden.

Challenge 1.4 - 3 Punkte

Der Hamster soll Slalom laufen und die Körner einsammeln. Verwende möglichst viele sinnvolle eigene Methoden.

Challenge 1.5 - 4 Punkte

Der Hamster soll Slalom laufen, und Körner einsammeln, falls welche da sind. Verwende möglichst viele sinnvolle eigene Methoden.

Challenge 1.6 - 5 Punkte

Der Hamster soll alle Körner einsammeln. Auf jeder Kachel können entweder 0, 1, 2 oder 3 Körner liegen. Der Hamster soll auch auf ähnlichen Territorien funktionieren (Position der Körner anders, Größe des Felds gleich). Halte deinen Code durch Methoden so übersichtlich wie möglich!

Level 2

Voraussetzungen

Voraussetzungen von Level 1
Wiederholungen
boolsche Funktionen

Challenge 2.1 - 1 Punkte

Der Hamster soll an die Wand rennen - egal wie weit diese weg ist - und das Korn aufsammeln!

Challenge 2.2 - 1 Punkte

Der Hamster soll auf genau diesem Territorium (Größe bleibt gleich, Körneranzahl kann verändert werden) alle Körner einsammeln.

Challenge 2.3 - 3 Punkte

Der Hamster soll auf einem ähnlichen Territorium (Länge des Wegs und Körneranzahl kann verändert werden) alle Körner einsammeln.

Challenge 2.4 - 5 Punkte

Der Hamster soll Slalom laufen und alle Körner einsammeln. Das Territorium kann beliebig lang sein, hört aber immer nach einer "unteren" Wand auf!

Challenge 2.5 - 3 Punkte

Der Hamster soll an der Wand entlanglaufen, bis er den Abgrund findet. Danach soll er abstürzen, bis er die Höhle findet.

Challenge 2.6 - 4 Punkte

Der Hamster ist Skifahrer und soll eigentlich gerade aus bis zum Korn fahren. Aber es gibt Hindernisse, denen er ausweichen muss!

Level 3

Voraussetzungen

Voraussetzungen von Level 2
Variablen und Datentypen
Funktionen, Return und Parameter

Challenge 3.1 - 1 Punkte

Gib dem Hamster am Anfang zwischen 1 und 9 Körner ins Maul. Der Hamster soll zählen, wie viele Körner er im Maul hat und so viele Schritte nach vorne gehen.

Challenge 3.2 - 3 Punkte

Der Hamster soll sich in einem Territorium nach folgendem Schema bewegen:

1 Korn: Rechts abbiegen und weiter!
2 Körner: Links abbiegen und weiter!
3 Körner: Stehen bleiben!

Das Territorium soll jedes mal anders "programmiert" werden (Körner anders verteilen)!

Challenge 3.3 - 2 Punkte

Der Hamster soll durch genau dieses Labyrinth gelenkt werden. Nutze nur Methoden mit Parametern!

Challenge 3.4 - 3 Punkte

Der Hamster berechnet Flächen, indem er die Länge und Breite des Territoriums zählt und entsprechend Körner auslegt!

Challenge 3.5 - 5 Punkte

Der Hamster soll Dezimalzahlen addieren. Der Hamster hat von Anfang an genug Körner im Maul, um das Ergebnis zu legen. Es gibt keinen Übertrag beim Addieren.

Ausgangssituation (Beispiel)

Zielsituation (Beispiel)

Challenge 3.6 - 3 Punkte

Der Hamster soll Dezimalzahlen addieren. Der Hamster hat von Anfang an genug Körner im Maul, um das Ergebnis zu legen. Es kann Überträge beim Addieren geben!

Ausgangssituation (Beispiel)

Zielsituation (Beispiel)

Lösungen

1.1

void main() {
	vor();
	vor();
 
	linksUm();
	linksUm();
	linksUm();
 
	vor();
	vor();
 
	nimm();
 
	linksUm();
 
	vor();
	vor();
	vor();
 
	linksUm();
	linksUm();
	linksUm();
 
	vor();
	vor();
 
	nimm();
}

1.2

void main() {
	vor3();
	vor3();
	vor();
 
	rechtsUm();
 
	nimm();
	nimm();
	nimm();
 
	vor();
	vor();
	vor();
	vor();
 
	rechtsUm();
 
	vor();
	vor3();
 
	kehrt();
 
	nimm();
	nimm();
 
	vor3();
 
	rechtsUm();
 
	vor3();
 
	gib();
	gib();
	gib();
	gib();
	gib();
 
	kehrt();
	vor();
}
 
void rechtsUm() {
	kehrt();
	linksUm();
}
 
void kehrt() {
	linksUm();
	linksUm();
}
 
void vor3() {
	vor();
	vor();
	vor();
}

1.3

void main() {
	vor();
	rechtsUm();
 
	reihe();
	linksUm();
	reihe();
	linksUm();
 
	reihe();
	rechtsUm();
	reihe();
	rechtsUm();
 
	reihe();
	linksUm();
	reihe();
	linksUm();
 
	reihe();
	rechtsUm();
	vor();
}
 
void rechtsUm() {
	linksUm();
	linksUm();
	linksUm();
}
 
void reihe() {
	vor();
	vor();
}

1.4

void main() {
	nimm();
	vor();
	rechtsUm();
 
	reihe();
	linksUm();
	reihe();
	linksUm();
 
	reihe();
	rechtsUm();
	reihe();
	rechtsUm();
 
	reihe();
	linksUm();
	reihe();
	linksUm();
 
	reihe();
	rechtsUm();
	reihe();
	rechtsUm();
 
	reihe();
	nimm();
}
 
void rechtsUm() {
	linksUm();
	linksUm();
	linksUm();
}
 
void reihe() {
	nimm();
	vor();
	nimm();
	vor();
}

1.5

void main() {
	nimmWennDa();
	vor();
	rechtsUm();
 
	reihe();
	linksUm();
	reihe();
	linksUm();
 
	reihe();
	rechtsUm();
	reihe();
	rechtsUm();
 
	reihe();
	linksUm();
	reihe();
	linksUm();
 
	reihe();
	rechtsUm();
	reihe();
	rechtsUm();
 
	reihe();
	nimmWennDa();
}
 
void rechtsUm() {
	linksUm();
	linksUm();
	linksUm();
}
 
void reihe() {
	nimmWennDa();
	vor();
	nimmWennDa();
	vor();
}
 
void nimmWennDa() {
	if (kornDa()) {
		nimm();
	}
}

1.6

void main() {
	reihe();
 
	rechtsUm();
	vor();
	rechtsUm();
 
	reihe();
 
	linksUm();
	vor();
	linksUm();
 
	reihe();
 
	rechtsUm();
	vor();
	rechtsUm();
 
	reihe();
}
 
void rechtsUm() {
	linksUm();
	linksUm();
	linksUm();
}
 
void reihe() {
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
}
 
void nimmAlle() {
	nimmWennDa();
	nimmWennDa();
	nimmWennDa();
}
 
void nimmWennDa() {
	if (kornDa()) {
		nimm();
	}
}

2.1

void main() {
	while (vornFrei()) {
		vor();
	}
 
	nimm();
}

2.2

void main() {
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
	vor();
	nimmAlle();
}
 
void nimmAlle() {
	while (kornDa()) {
		nimm();
	}
}

2.3

void main() {
	nimmAlle();
 
	while (vornFrei()) {
		vor();
		nimmAlle();
	}
}
 
void nimmAlle() {
	while (kornDa()) {
		nimm();
	}
}

2.4

void main() {
	nimmAlle();
	vor();
 
	rechtsUm();	
	reihe();
 
	linksUm();
 
	while (vornFrei()) {
		reihe();
		linksUm();
 
		reihe();	
		rechtsUm();
 
		reihe();	
		rechtsUm();
 
		reihe();
		linksUm();
	}
 
	nimmAlle();
}
 
void reihe() {
	nimmAlle();
	vor();
	nimmAlle();
	vor();
}
 
void kehrt() {
	linksUm();
	linksUm();
}
 
void rechtsUm() {
	kehrt();
	linksUm();
}
 
void nimmAlle() {
	while (kornDa()) {
		nimm();
	}
}

2.5

void main() {
	vorBisLueckeRechts();
 
	rechtsUm();
	vor();
 
	vorBisLueckeRechts();
 
	rechtsUm();
	vor();
}
 
void vorBisLueckeRechts() {
	while (!rechtsFrei()) {
		vor();
	}
}
 
boolean rechtsFrei() {
	rechtsUm();
 
	boolean res = vornFrei();
 
	linksUm();
 
	return res;
}
 
void kehrt() {
	linksUm();
	linksUm();
}
 
void rechtsUm() {
	kehrt();
	linksUm();
}

2.6

void main() {
	vorBisLueckeRechts();
 
	rechtsUm();
	vor();
	linksUm();
 
	vorBisWand();
 
	rechtsUm();
	vor();
	linksUm();
	vor();
 
	vorBisLueckeLinks();
 
	linksUm();
	vor();
	rechtsUm();
 
	vorBisWand();
 
	linksUm();
	vor();
	rechtsUm();
	vor();
 
 
	vorBisLueckeRechts();
 
	rechtsUm();
	vor();
	linksUm();
 
	vorBisWand();
 
	rechtsUm();
	vor();
	linksUm();
	vor();
 
	vorBisLueckeLinks();
 
	linksUm();
	vor();
	rechtsUm();
 
	vorBisWand();
}
 
void vorBisLueckeRechts() {
	while (!rechtsFrei()) {
		vor();
	}
}
 
void vorBisLueckeLinks() {
	while (!linksFrei()) {
		vor();
	}
}
 
void vorBisWand() {
	while (vornFrei()) {
		vor();
	}
}
 
boolean rechtsFrei() {
	rechtsUm();
 
	boolean res = vornFrei();
 
	linksUm();
 
	return res;
}
 
boolean linksFrei() {
	linksUm();
 
	boolean res = vornFrei();
 
	rechtsUm();
 
	return res;
}
 
void kehrt() {
	linksUm();
	linksUm();
}
 
void rechtsUm() {
	kehrt();
	linksUm();
}

3.1

void main() {
	int koerner = zaehleKoerner();
	vor(koerner);
}
 
int zaehleKoerner() {
	int anzahl = 0;
 
	while (!maulLeer()) {
		gib();
		anzahl++;
	}
 
	int temp = anzahl;
 
	while (temp > 0) {
		nimm();
		temp--;
	}
 
	return anzahl;
}
 
void vor(int num) {
	while (num > 0) {
		vor();
		num--;
	}
}

3.2

void main() {
	while (true) {
		vor(3);
		int koerner = zaehleKoerner();
 
		if (koerner == 1) {
			drehe(3);
		} else if (koerner == 2) {
			drehe(1);		
		} else if (koerner == 3) {
			break;
		}
	}
}
 
int zaehleKoerner() {
	int anzahl = 0;
 
	while (kornDa()) {
		nimm();
		anzahl++;
	}
 
	int temp = anzahl;
 
	while (temp > 0) {
		gib();
		temp--;
	}
 
	return anzahl;
}
 
void vor(int num) {
	while (num > 0) {
		vor();
		num--;
	}
}
 
void drehe(int num) {
	while (num > 0) {
		linksUm();
		num--;
	}
}

3.3

void main() {
	vor(11);
	drehe(3);
	vor(7);
	drehe(3);
	vor(2);
	drehe(3);
	vor(3);
	drehe(1);
	vor(2);
	drehe(1);
	vor(3);
	drehe(3);
	vor(7);
	drehe(3);
	vor(3);
	nimm();
}
 
void vor(int num) {
	while (num > 0) {
		vor();
		num--;
	}
}
 
void drehe(int num) {
	while (num > 0) {
		linksUm();
		num--;
	}
}

3.4

void main() {
	int laenge = vorBisWandZaehlen();
 
	drehe(3);
 
	int breite = vorBisWandZaehlen();
 
	gib(laenge * breite);
 
	drehe(3);
	vorBisWandZaehlen();
	drehe(3);
	vorBisWandZaehlen();
	drehe(3);
}
 
int vorBisWandZaehlen() {
	int schritte = 1;
 
	while (vornFrei()) {
		vor();
		schritte++;
	}
 
	return schritte;
}
 
void drehe(int num) {
	while (num > 0) {
		linksUm();
		num--;
	}
}
 
void gib(int num) {
	while (num > 0) {
		gib();
		num--;
	}
}

3.5

void main() {
	vorBisWand();
	drehe(2);
 
	addiereSpalte();
	vor();
 
	addiereSpalte();
	vor();
 
	addiereSpalte();
	vor();
 
	drehe(2);
}
 
void drehe(int num) {
	while (num > 0) {
		linksUm();
		num--;
	}
}
 
void vorBisWand() {
	while (vornFrei()) {
		vor();
	}
}
 
void addiereSpalte() {
	drehe(3);
 
	int anzahl = 0;
 
	vor();	
	anzahl += zaehleKoerner();
 
	vor();	
	anzahl += zaehleKoerner();
 
	vor();	
	anzahl += zaehleKoerner();
 
	drehe(2);
 
	vorBisWand();
 
	lege(anzahl);
 
	drehe(3);
}
 
int zaehleKoerner() {
	int anzahl = 0;
 
	while (kornDa()) {
		nimm();
		anzahl++;
	}
 
	int temp = anzahl;
 
	while (temp > 0) {
		gib();
		temp--;
	}
 
	return anzahl;
}
 
void lege(int anzahl) {
	while (anzahl > 0) {
		gib();
		anzahl--;
	}
}

3.6

void main() {
	vorBisWand();
	drehe(2);
 
	int rest = addiereSpalte(0);
	vor();
 
	rest = addiereSpalte(rest);
	vor();
 
	rest = addiereSpalte(rest);
	vor();
 
	lege(rest);
 
	drehe(2);
}
 
void drehe(int num) {
	while (num > 0) {
		linksUm();
		num--;
	}
}
 
void vorBisWand() {
	while (vornFrei()) {
		vor();
	}
}
 
int addiereSpalte(int uebertrag) {
	drehe(3);
 
	int anzahl = uebertrag;
 
	vor();	
	anzahl += zaehleKoerner();
 
	vor();	
	anzahl += zaehleKoerner();
 
	vor();	
	anzahl += zaehleKoerner();
 
	drehe(2);
 
	vorBisWand();
 
	lege(anzahl % 10);
 
	drehe(3);
 
	return (anzahl - (anzahl % 10)) / 10;
}
 
int zaehleKoerner() {
	int anzahl = 0;
 
	while (kornDa()) {
		nimm();
		anzahl++;
	}
 
	int temp = anzahl;
 
	while (temp > 0) {
		gib();
		temp--;
	}
 
	return anzahl;
}
 
void lege(int anzahl) {
	while (anzahl > 0) {
		gib();
		anzahl--;
	}
}