Teil 2: Auf die Umgebung reagieren

2. Februar 2021 / 47 Kommentare

Herzlich willkommen beim zweiten Teil unseres kostenlosen Kurses Programmieren lernen für Anfänger.

Dieser Teil baut auf dem Wissen des ersten Teils auf. Lass uns nochmals kurz zusammenfassen was wir schon gelernt haben.

Wir haben gelernt einfache Funktionen wie forward(), turnLeft() oder takeStone() aufzurufen um Nana zu steuern.
Wir wissen, dass Fehler ganz normal und wichtig sind! Wir versuchen Fehlermeldungen zu verstehen um daraus zu lernen. So können wir beim nächsten Mal das Problem schneller lösen.
Abstände, Einrückungen und Kommentare helfen den Programmcode übersichtlich und verständlich zu halten. So können wir Fehler schneller finden und uns in altem Code noch gut zurechtfinden.
Wir haben gelernt mit dem Schlüsselwort fun eigene Funktionen wie turnRight oder forward3 zu erstellen. So halten wir unseren Code kurz und müssen uns nicht dauernd wiederholen.

Falls du dich an manche Dinge nicht mehr so gut erinnern kannst, schau einfach nochmal im ersten Teil „Deine ersten Schritte beim Programmieren“ vorbei und löse die Aufgaben dort.

Im letzten Beispiel des ersten Teils sind wir auf ein, für uns noch nicht zu schaffendes, Problem gestoßen. Nana muss zwei Level mit dem gleichen Programmcode meistern. Bisher waren alle unsere Programme ein fix einprogrammierter Ablauf von Befehlen. In diesem Teil lernst du dynamisch auf deine Umgebung zu reagieren und so Nana flexibel zum Ziel zu steuern.

Hier nochmal das Beispiel mit der Lösung für den ersten Level.

import com.chronimo.space.*

fun main() {
    game {
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            setStones(3, 1, 2)
            setStones(4, 1, 1)
            successCheck = {
           		firstShip.run { 
                	position == Coordinates(5, 1) && stones == 3
                }
            }
        }
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            setStones(3, 1, 1)
            setStones(4, 1, 1)
            successCheck = {
                firstShip.run {
                    position == Coordinates(5, 1) && stones == 2
                }
            }
        }
    }.runImp(::solution)
}

fun forward2() {
    forward()
    forward()
}

fun forward3() {
    forward2()
    forward()
}

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

//sampleStart
fun solution() {
    forward3()
    takeStone()
    takeStone()
    forward()
    takeStone()
    forward()
}
//sampleEnd

Im zweiten Level explodiert Nana, weil sie versucht einen Loridium Stein aufzunehmen der nicht da liegt. An dieser Stelle liegen im ersten Level noch zwei Steine, im zweiten aber nur noch einer.

Tipp: In Beispielen mit mehreren Leveln, kannst du nach dem „Zurücksetzen“ mit den Pfeilen oben zwischen den Leveln wechseln.

Funktionen, die Antworten liefern

Du brauchst eine Möglichkeit um zu überprüfen ob ein Stein am Feld liegt, bevor du ihn versuchst aufzunehmen. Nana hat dazu die Funktion fieldHasStone() im Bordcomputer einprogrammiert. Übersetzt bedeutet das „Feld hat Stein“. Diese Funktion ist etwas anders als die uns bisher bekannten Funktionen. Die uns bekannten forward() und turnLeft() bewegen Nana. Die Funktion fieldHasStone() hingegen beantwortet eine Frage. Sie sagt ob auf dem Feld auf dem Nana gerade steht ein Loridium Stein liegt. Die Antwort ist also entweder „Ja“ oder „Nein“. Beim Programmieren wird anstatt „Ja“ und „Nein“, true und false verwendet. Auf Deutsch also „wahr“ und „falsch“. Lass uns mal ausprobieren fieldHasStone() aufzurufen.

Aufgabe: Führe den Code unten aus und schaue was passiert.

import com.chronimo.space.*

fun main() {
    game {
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            setStones(3, 1, 2)
            setStones(4, 1, 1)
            successCheck = {
           		firstShip.run { 
                	position == Coordinates(5, 1) && stones == 3
                }
            }
        }
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            setStones(3, 1, 1)
            setStones(4, 1, 1)
            successCheck = {
                firstShip.run {
                    position == Coordinates(5, 1) && stones == 2
                }
            }
        }
    }.runImp(::solution)
}

//sampleStart
fun solution() {
    fieldHasStone()
}
//sampleEnd

Viel hat sich da ja jetzt nicht gerade getan. Nana steht einfach nur rum und nichts passiert? Wie oben beschrieben ist fieldHasStone() eine Funktion die eine Antwort liefert. Nur in diesem Fall machen wir nichts mit der Antwort. Das ist ein wenig so als wenn du eine Freundin fragst: „Magst du ein Eis?“ Sie sagt zwar „Ja!“ aber du hörst einfach nicht zu und machst nichts mit der Information. Das ist etwas unfreundlich, da hättest du gar nicht erst fragen brauchen. 😀 Genauso ist es hier, wir fragen ob auf dem Feld ein Stein liegt, machen aber nichts weiter mit der Information. Der Aufruf ist in dieser Form also nutzlos. Wir müssen mit der Information erst etwas anfangen.

Beim Programmieren nennt man Funktionen die eine Antwort liefern, „Funktionen mit Rückgabewert“. Der Rückgabewert ist die Antwort. Im Fall von fieldHasStone() ist die Antwort immer true oder false. Das nennt man einen „Boolean“ Rückgabewert.
Auf English sagt man zu Rückgabewert „return value“.

Programmteile bedingt ausführen mit „if“

Was wir brauchen ist eine Möglichkeit takeStone() nur dann aufzurufen, wenn fieldHasStone() mit true antwortet. Kotlin hat dazu den Befehl if, auf Deutsch also „wenn“, eingebaut. Dieser funktioniert so:

if (/* Code der mit true oder false antwortet */) {
    // Dieser Code hier wird nur ausgeführt wenn 
    // der Code in den Klammern oben mit true antwortet.
}

Direkt hinter dem if Befehl kommt, zwischen runden Klammern, ein Stück Code das mit einem Boolean-Wert (also true oder false) antworten muss. Man nennt diesen Code-Teil des if-Befehls „Bedingung“. Also zum Beispiel if (fieldHasStone()). Danach kommt ein Block an Code der zwischen geschwungenen Klammern steht. Dieser Block wird nur dann ausgeführt, wenn die Bedingung mit true antwortet. Wenn sie mit false antwortet, wird dieser Teil einfach übersprungen.

Schaffst du es mit der Hilfe von if und fieldHasStone() den Code unten so umzubauen, damit Nana beide Level erfolgreich absolviert?

Aufgabe: Passe den Code im folgenden Eingabefeld so an, dass Nana beide Level erfolgreich absolviert.
Hinweis: Nimm der etwas Zeit um es auszuprobieren. Falls du etwas Hilfe benötigst, findest du direkt unter dem Beispiel einen Tipp.

import com.chronimo.space.*

fun main() {
    game {
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            setStones(3, 1, 1)
            successCheck = {
           		firstShip.run { 
                	position == Coordinates(5, 1) && stones == 1
                }
            }
        }
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            successCheck = {
                firstShip.run {
                    position == Coordinates(5, 1) && stones == 0
                }
            }
        }
    }.runImp(::solution)
}

fun forward2() {
    forward()
    forward()
}

fun forward3() {
    forward2()
    forward()
}

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

//sampleStart
fun solution() {
    forward3()
    takeStone()
    forward2()
}
//sampleEnd

Wie ist es dir dabei gegangen? Hat alles geklappt? Hier ein Tipp. 🙂 Der Code unten nimmt einen Stein nur dann, wenn er da liegt. Wenn nicht, wird takeStone() einfach übersprungen. So kannst du vermeiden, dass Nana einen Loridium Stein aufnimmt den es nicht gibt und explodiert.

if (fieldHasStone()) {
    takeStone()
}

Hilft dir das weiter? Versuche es gleich nochmal!

Falls du es nach ein paar mal versuchen nicht weiterkommst, schau dir hier die ganze Lösung an. So fällt dir das nächste Beispiel bestimmt gleich leichter!

import com.chronimo.space.*

fun main() {
    game {
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            setStones(3, 1, 1)
            successCheck = {
           		firstShip.run { 
                	position == Coordinates(5, 1) && stones == 1
                }
            }
        }
        level(6, 3) {
            addShip(0, 1, Direction.RIGHT)
            setFlag(5, 1, Flag.GREEN)
            successCheck = {
                firstShip.run {
                    position == Coordinates(5, 1) && stones == 0
                }
            }
        }
    }.runImp(::solution)
}

fun forward2() {
    forward()
    forward()
}

fun forward3() {
    forward2()
    forward()
}

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

fun solution() {
    forward3()
    // Wenn kein Stein am Feld liegt überpringen wir das Aufheben.
    if (fieldHasStone()) {
       takeStone()
    }
    forward2()
}
//sampleStart
// Klappe diesen Block auf um unsere Lösung zu sehen
//sampleEnd

Einrückungen, Leerzeichen und sonstige Abstände spielen in Kotlin in den meisten Fällen keine Rolle. So auch im Zusammenhang mit dem if Befehl. Die folgenden Versionen sind für Kotlin alle genau gleich.

// Version 1
if (fieldHasStone()) {
    takeStone()
    forward()
}

// Version 2
if (fieldHasStone()) {
takeStone()
forward()
}

// Version 3
if (fieldHasStone())
{
    takeStone()
    forward()
}

Kotlin erlaubt sogar die geschwungenen Klammern wegzulassen. In diesem Fall wird nur der direkt hinter den runden Klammern kommende Befehl übersprungen, wenn die Bedingung false zurückliefert. Ohne Klammern kann also nur ein einziger Befehl übersprungen werden.

// Version 4
if (fieldHasStone())
    takeStone()

// Version 5
if (fieldHasStone()) takeStone()

// Version 6
if (fieldHasStone()) { takeStone() }

// Version 7 (Achtung!)
if (fieldHasStone())
    takeStone()
    forward()

Versionen 4 bis 7 machen alle genau das gleiche. Aufpassen bei Nummer 7! Auch hier wird nur der Befehl takeStone() übersprungen, wenn kein Stein im Feld liegt. Der Befehl forward() wird hingegen immer ausgeführt. Das ist, weil wir keine geschwungenen Klammern verwenden. Kotlin überspringt somit nur den ersten Befehl hinter der Bedingung.

Hier ist nochmals Version 7 mit besserer Formatierung. Du erkennst auf den ersten Blick welcher Code übersprungen wird und welcher nicht.

fun solution() {
    // version 7 (besser formatiert)
    if (fieldHasStone())
        takeStone()

    forward()
}

Wie du siehst, ist es sehr wichtig den Code gut einzurücken. In der Praxis ist Version 1 sehr beliebt. Sie ist kompakt, übersichtlich und erlaubt auch mehrere Befehle zu überspringen.

Hier ein weiteres Beispiel, dass du nur mit dem if Befehl lösen kannst. Die Steine werden bei jedem Mal neu Ausführen zufällig am Planeten verteilt. Es liegt aber immer maximal ein Stein auf einem Feld.

Aufgabe: Löse das Beispiel unten mit der Hilfe des if-Befehls.
Tipp: Versuche das Programm Schritt für Schritt zu lösen. Führe das Programm dazwischen oft aus. So siehst du gleich ob noch alles funktioniert.

import com.chronimo.space.*
import com.chronimo.space.*

val stonePositions = listOf(
        1 to 1,
        0 to 1,
        0 to 2,
        0 to 3,
        1 to 3,
        1 to 4,
        1 to 5
    )
    .shuffled()
    .chunked(3)

fun GameBuilder.createLevel(level: Int) {
    level(6, 2) {
    	addShip(0, 1, Direction.RIGHT)
        setFlag(5, 0, Flag.GREEN)
        putHole(0, 0)
        putHole(2, 1)
        putHole(4, 0)
        stonePositions[level].forEach { (y, x) ->
        	setStones(x, y, 1)
        }
        successCheck = {
            firstShip.run { 
                position == Coordinates(5, 0) && stones == 3
            }
        }
    }
}
fun main() {
    game {
        createLevel(0)
        createLevel(1)
    }.runImp(::solution)
}

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

//sampleStart
fun solution() {
    
}
//sampleEnd

Hast du es geschafft? Wie lange ist dein Code geworden? Schaffst du es deine solution Funktion in weniger als 15 Zeilen zu programmieren? Tipp: Erstelle eine Funktion die Nana nach vorne bewegt und dann den Stein nimmt, falls er dort liegt. Wenn du nicht mehr ganz sattelfest im Erstellen von Funktionen bist, schau einfach nochmal im entsprechenden Abschnitt in Teil 1 dieses Kurses nach.

import com.chronimo.space.*
import com.chronimo.space.*

val stonePositions = listOf(
        1 to 1,
        0 to 1,
        0 to 2,
        0 to 3,
        1 to 3,
        1 to 4,
        1 to 5
    )
    .shuffled()
    .chunked(3)

fun GameBuilder.createLevel(level: Int) {
    level(6, 2) {
    	addShip(0, 1, Direction.RIGHT)
        setFlag(5, 0, Flag.GREEN)
        putHole(0, 0)
        putHole(2, 1)
        putHole(4, 0)
        stonePositions[level].forEach { (y, x) ->
        	setStones(x, y, 1)
        }
        successCheck = {
            firstShip.run { 
                position == Coordinates(5, 0) && stones == 3
            }
        }
    }
}
fun main() {
    game {
        createLevel(0)
        createLevel(1)
    }.runImp(::solution)
}

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

/**
 * Bewegt Nana nach vorne und nimmt einen Stein,
 * wenn er auf dem neuen Feld liegt.
 */
fun forwardAndTake() {
    forward()
    if (fieldHasStone()) {
        takeStone()
    }
}

fun solution() {
    forwardAndTake()
    turnLeft()
    forwardAndTake()
    turnRight()
    forwardAndTake()
    forwardAndTake()
    turnRight()
    forwardAndTake()
    turnLeft()
    forwardAndTake()
    forwardAndTake()
    turnLeft()
    forward()
}
//sampleStart
// Klappe diesen Block auf um unsere Lösung zu sehen
//sampleEnd

Super! Das war schon ein sehr komplexes Level. Obwohl die Steine völlig zufällig verteilt sind, kann Nana sie alle einsammeln.

Entscheidungen treffen mit „if“ und „else“

Im nächsten Beispiel muss Nana ein Labyrinth durchfahren. Die Steine am Feld dienen dabei als Wegweiser. Wenn ein Loridium Stein auf dem Feld liegt, geht es nach rechts weiter, ansonsten nach links. In diesem Fall müssen wir also abhängig davon ob ein Stein auf dem Feld liegt die eine oder andere Aktion ausführen. Der if-Befehl kann dafür mit else erweitert werden. „else“ kann ins Deutsche mit „andernfalls“ oder „sonst“ übersetzt werden.

if (/* Bedingung */) {
    // Dieser Code wird ausgeführt, wenn die Bedingung mit "true" antwortet.
} else {
   // Ansonsten wird dieser Code ausgeführt.
}

Wenn die Bedingung mit true antwortet, wird der Code-Block direkt hinter if ausgeführt und der hinter else übersprungen. Antwortet die Bedingung mit false, ist es genau umgekehrt. Der if-Block wird übersprungen und der else-Block ausgeführt. Es wird also abhängig von der Bedingung der eine oder andere Code ausgeführt.

Schaue dir beide Level im folgenden Beispiel an. Kannst du die Gemeinsamkeit zwischen ihnen erkennen? Vergiss nicht, die Steine dienen hier als Wegweiser. Wenn ein Stein auf dem Feld liegt, geht es nach rechts weiter. Wenn kein Stein auf dem Feld liegt nach links. Viel Spaß beim Lösen dieser Aufgabe mit if und else!

import com.chronimo.space.*

fun main() {
    // ship full
    // flag color
    // land in front
    // fieldHasStone (follow path)
    
    fun GameBuilder.levelOfArray(field: Array<IntArray>, build: Level.() -> Unit) {
        val width = field[0].size
        val height = field.size
        level(width, height) {
            for (x in 0 until width) {
                for (y in 0 until height) {
                    if (field[y][x] == 0) {
                        putHole(x, y)
                    }
                }
            }
            
            build()
        }
    }
    
    val planet1 = arrayOf(
        intArrayOf(0, 0, 0, 0, 0, 0, 0, 0, 0),
    	intArrayOf(0, 1, 0, 1, 1, 1, 0, 1, 0),
        intArrayOf(0, 1, 0, 1, 0, 1, 0, 1, 0),
        intArrayOf(0, 1, 1, 1, 0, 1, 1, 1, 0),
        intArrayOf(0, 0, 0, 0, 0, 0, 0, 0, 0)
    )
    val planet2 = arrayOf(
    	intArrayOf(1, 1, 1, 0, 0, 0, 0, 0, 0),
    	intArrayOf(0, 0, 1, 0, 0, 0, 0, 0, 0),
    	intArrayOf(0, 0, 1, 1, 1, 0, 1, 1, 1),
    	intArrayOf(0, 0, 0, 0, 1, 0, 1, 0, 0),
    	intArrayOf(0, 0, 0, 0, 1, 1, 1, 0, 0)
    )
    
    game {
        levelOfArray(planet1) {
            addShip(1, 1, Direction.LEFT, 0)
            setFlag(7, 1, Flag.GREEN)
            setStones(3, 1, 1)
            setStones(5, 1, 1)
            successCheck = { 
                firstShip.position == Coordinates(7, 1) &&
                firstShip.stones == 2
            }
        }
        levelOfArray(planet2) {
            addShip(0, 0, Direction.DOWN, 0)
            setStones(2, 0, 1)
            setStones(4, 2, 1)
            setStones(6, 2, 1)
            setFlag(8, 2, Flag.GREEN)
            successCheck = {
                firstShip.position == Coordinates(8, 2) &&
                firstShip.stones == 3
            }
        }
    }.runImp(::solution)
}

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

//sampleStart
fun solution() {
    
}
//sampleEnd

Wie ist es dir dabei gegangen? Hat alles gleich geklappt? Hier noch ein Tipp: Nach jeder Drehung muss Nana zweimal gerade aus fahren. Das ist die Gemeinsamkeit in beiden Leveln.

Okay, ich nehme mal an du hast es geschafft. Falls nicht, sende uns eine e-mail und wir helfen gerne weiter. Du kannst auch gerne unten ein Kommentar hinterlassen.

Kannst du deinen Code noch kürzer und übersichtlicher gestalten, indem du Programmteile in eigenen Funktionen auslagerst?

Unten findest du wie immer unsere Lösung für diese Aufgabe.

import com.chronimo.space.*

fun main() {
    // ship full
    // flag color
    // land in front
    // fieldHasStone (follow path)
    
    fun GameBuilder.levelOfArray(field: Array<IntArray>, build: Level.() -> Unit) {
        val width = field[0].size
        val height = field.size
        level(width, height) {
            for (x in 0 until width) {
                for (y in 0 until height) {
                    if (field[y][x] == 0) {
                        putHole(x, y)
                    }
                }
            }
            
            build()
        }
    }
    
    val planet1 = arrayOf(
        intArrayOf(0, 0, 0, 0, 0, 0, 0, 0, 0),
    	intArrayOf(0, 1, 0, 1, 1, 1, 0, 1, 0),
        intArrayOf(0, 1, 0, 1, 0, 1, 0, 1, 0),
        intArrayOf(0, 1, 1, 1, 0, 1, 1, 1, 0),
        intArrayOf(0, 0, 0, 0, 0, 0, 0, 0, 0)
    )
    val planet2 = arrayOf(
    	intArrayOf(1, 1, 1, 0, 0, 0, 0, 0, 0),
    	intArrayOf(0, 0, 1, 0, 0, 0, 0, 0, 0),
    	intArrayOf(0, 0, 1, 1, 1, 0, 1, 1, 1),
    	intArrayOf(0, 0, 0, 0, 1, 0, 1, 0, 0),
    	intArrayOf(0, 0, 0, 0, 1, 1, 1, 0, 0)
    )
    
    game {
        levelOfArray(planet1) {
            addShip(1, 1, Direction.LEFT, 0)
            setFlag(7, 1, Flag.GREEN)
            setStones(3, 1, 1)
            setStones(5, 1, 1)
            successCheck = { 
                firstShip.position == Coordinates(7, 1) &&
                firstShip.stones == 2
            }
        }
        levelOfArray(planet2) {
            addShip(0, 0, Direction.DOWN, 0)
            setStones(2, 0, 1)
            setStones(4, 2, 1)
            setStones(6, 2, 1)
            setFlag(8, 2, Flag.GREEN)
            successCheck = {
                firstShip.position == Coordinates(8, 2) &&
                firstShip.stones == 3
            }
        }
    }.runImp(::solution)
}

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

fun move() { 
    if (fieldHasStone()) {
        takeStone()
        turnRight()
    } else {
        turnLeft()
    }
    
    forward()
    forward()
}

fun solution() {
    move()
    move()
    move()
    move()
    move()
    move()
    move()
}
//sampleStart
// Klappe diesen Block auf um unsere Lösung zu sehen
//sampleEnd

Obwohl wir schon eine eigene Funktion verwenden, ist der Code noch immer ziemlich lange. Außerdem scheint es ziemlich sinnlos, dass wir move() ganze acht mal direkt hintereinander schreiben müssen. Was wenn der Level viel größer wäre?

Im nächsten Teil dieses Kurses „Programmieren lernen für Anfänger„, lernen wir eine sogenannte Schleife kennen. Mit dieser können wir solchen Code optimieren und Nana noch viel flexibler steuern. Wir werden lernen den Boardcomputer so zu programmieren, dass Nana unbekannte Labyrinthe völlig selbständig lösen kann.

Melde dich bei unserem Newsletter an! Wir erinnern dich sobald der nächste Teil verfügbar ist 🙂

47 Kommentare zu „Teil 2: Auf die Umgebung reagieren“

Thomas Schlitt

12. Februar 2021 um 11:58 Uhr

Euer Kurs macht viel Spaß. Danke

Antworten

Thomas

26. Februar 2021 um 17:15 Uhr

also, macht mega Spass! Nur eine Frage zum Verständnis: Muss die if / else Abfrage immer in einer Funktion festgelegt werden? Denn wenn die if / else Abfrage unter fun solution steht dann macht der das NICHT !!
Danke für die Antwort

Antworten

NixC0d3r

5. März 2022 um 15:26 Uhr

Warum es Sinn macht die if/else Anweisung in einer Funktion festzulegen ergibt es aus folgendem, funktionierendem, Code-Beispiel:

fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}

fun solution () {
    // 1.
    if (fieldHasStone()) {
        takeStone()
        turnRight()
          }
	else {
    turnLeft()
    	 }
    forward()
    forward()
    
    // 2.
       if (fieldHasStone()) {
        takeStone()
        turnRight()
          }
	else {
    turnLeft()
    	 }
    forward()
    forward()
    
	// 3.
	if (fieldHasStone()) {
        takeStone()
        turnRight()
          }
	else {
    turnLeft()
    	 }
    forward()
    forward()
    
// 4.
	if (fieldHasStone()) {
        takeStone()
        turnRight()
          }
	else {
    turnLeft()
    	 }
    forward()
    forward()
    
   // 5.
	if (fieldHasStone()) {
        takeStone()
        turnRight()
          }
	else {
    turnLeft()
    	 }
    forward()
    forward()
    
    // 6.
	if (fieldHasStone()) {
        takeStone()
        turnRight()
          }
	else {
    turnLeft()
    	 }
    forward()
    forward()
    
    // 7.
	if (fieldHasStone()) {
        takeStone()
        turnRight()
          }
	else {
    turnLeft()
    	 }
    forward()
    forward()
}

Siehst du den Unterschied zur „Lösung der Aufgabe“ oben?
Genau!
Hier würde man den Code zusätzlich aufblähen!

Antworten

jas
29. April 2022 um 13:23 Uhr

hat jemand die Lösung für die erste Aufgabe?

Antworten
1. Finn
  13. Juni 2022 um 14:23 Uhr
  
  Iam gay
  
  Antworten
2. Silas
  7. September 2022 um 14:50 Uhr
  
  Für sowohl die erste, als auch die zweite Aufgabe gibt es bewusst keine Lösung, da dieses Problem erst bei Aufgabe drei gelöst wird.
  
  Antworten

Light
20. März 2021 um 19:06 Uhr

Sehr hilfreich, danke

Antworten
jessi
23. März 2021 um 11:00 Uhr

warte gespannt auf den dritten teil oder halt weitere, wenn es nich dazu kommt bitte ich um gute andere Seiten um zu programmieren zu lernen.
Danke für ihr Verständnis

Antworten
Kay
26. März 2021 um 22:43 Uhr
Hallo,

erst einmal Danke für die Mühe. Leider wird eure eigene Lösung – die auch meine ist – nich angenommen.
```
fun turnRight() {
    turnLeft()
    turnLeft()
    turnLeft()
}



fun solution()
{if (fieldHasStone()) {
    turnLeft()
} else {
  turnRight()}
```
Zum einen ist der erste Teil bereits im Hintergrund vorhanden.
Beim zweiten Teil gibt es die Fehlermeldung
„Expecting ‚}'“

Könnte mir das bitte einer erklären?

Vielen lieben Dank

Antworten
1. Kay
  26. März 2021 um 23:15 Uhr
  
  Sorry, die Lösung war meine Lösung.
  
  Antworten
2. lord
  9. April 2021 um 18:51 Uhr
  
  Hey
  Falls du das noch liest 😀
  Ich denke dir fehlt ganz zum Schluss noch eine geschweifte Klammer } (das sagt dir ja auch die Fehlermeldung), die deine fun solution eingrenzt. Bisher schließt deine letzte Klammer nur die „else“ Bedingung.
  Und wenn die Funktion turnRight() schon gegeben ist, musst du sie natürlich nicht nochmal selbst hinschreiben.
  
  Antworten
3. dominic.czyszczon
  28. August 2021 um 16:10 Uhr
  Hallo es ist gemeint
  
  fun turnRight() { turnLeft() turnLeft() turnLeft() } fun solution() {if (fieldHasStone()) { turnLeft() } else { turnRight() }
  
  Nicht
  
  fun turnRight() { turnLeft() turnLeft() turnLeft() } fun solution() {if (fieldHasStone()) { turnLeft() } else { turnRight()}
  
  Antworten
4. NixC0d3r
  5. März 2022 um 16:06 Uhr
  Da fehlt eine geschweifte Klammer ( „}“ ) !
  Zudem ist dein Code falsch!
  Aufgabe richtig lesen!
  
  Der Teil steht oben und stimmt somit:
  
  fun turnRight() { turnLeft() turnLeft() turnLeft() }
  
  Ab hier sieht dein Code anders aus, als mein folgender:
  
  //Achtung: Entweder 7 mal in "fun solution" die Anweisung oder besser per eigener Funktion auslagern! fun solution () { // 1. if/else // wenn Stein auf Feld... if (fieldHasStone()) { // sammle Stein takeStone() // UND drehe dich nach rechts turnRight() } // Andernfalls else { // drehe dich nach links turnLeft() } // 2 Felder vorwärts gehen forward() forward() // 2.te if/else .... // 3.te bis 7.te if /else } // Ende "fun solution" // oder: // Ausgelagerte Funktion: fun move() { if (fieldHasStone()) { takeStone() turnRight() } else { turnLeft() } forward() forward() } // Ende "fun move"
  
  Antworten
5. wolf
  21. Juni 2022 um 21:17 Uhr
  
  fun turnRight() {
  turnLeft()
  turnLeft()
  turnLeft()
  }
  
  fun solution()
  {if (fieldHasStone()) {
  turnLeft()
  } else {
  turnRight()} < da fehlt noch eine weitere } klammer
  
  du hast sie vor dem if geöffnet also musst du sie am ende auch wieder schließen
  
  Antworten
Luka
2. April 2021 um 1:43 Uhr

bei mir kommt immer die Fehlermeldung expecting was habe ich hier falsch gemacht ? zur info das unterste zeichen ist anscheinend das problem ?
fun solution() {
forward()
if (fieldHasStone()) {
takeStone()
forward()

}

Antworten
1. Jessica
  2. April 2021 um 18:49 Uhr
  
  Dir fehlt eine weitere geschlossene Geschweifte Klammer am Ende.
  
  Antworten
2. carsten
  13. Dezember 2021 um 9:03 Uhr
  
  du musst die unterste geschweifte klammer eine zeile weiter nach oben machen
  
  Antworten
3. NixC0d3r
  5. März 2022 um 16:14 Uhr
  
  Die Anzahl der geöffnete geschweiften Klammern muss mit der Anzahl der geschlossenen geschweifte Klammern übereinstimmen!
  Zwei geöffnete geschweifte Klammern sehe ich, aber nur eine geschlossene geschweifte Klammer.
  
  Die geöffnete und geschlossene gehört zur „fun solution“; die if-Anweisnung hat – bei dir – keine geschlossene, sondern nur eine geöffnete.
  
  Antworten
Randy
13. Mai 2021 um 22:08 Uhr

Der Kurs ist mega gut

Antworten
Mean28211
18. Mai 2021 um 21:26 Uhr

Super danke,
Es war sehr ausführlich

Antworten
Bünni
19. Mai 2021 um 14:56 Uhr

Ich finde diesen Kurs einfach genial und bin euch so dankbar, dass dieser Kurs nur für Anfänger und kostenlos ist. Ich wollte schon immer mal Programmieren lernen, habe aber leider nichts gefunden. Ich bin 15 und in der Schule lernen wir nur so „Kindergarten programmieren“.
Ich muss den dritten Teil haben, kann es kaum erwarten 🤣.
LG Bünni 🙃

Antworten
Maximize
3. Juli 2021 um 10:59 Uhr

wie kann ich jetzt spiele programmieren?

Antworten
1. NixC0d3r
  5. März 2022 um 16:20 Uhr
  
  Erstmal alles verstehen, da kommt noch mehr was garnicht behandelt wurde.
  Zum Spiele erstellen nimmt man, je nach Genre, am besten aber auch eine Game Engine, z.B. Unreal Engine, Unity…. zudem eine andere Programmiersparche statt Kotlin.
  
  Falls dich das Thema interessiert, es gibt genügend YouTube Videos (mit welchen man seine Zeit totschlagen kann) und Bücher die das Thema Spieleentwicklung behandeln!
  Sei aber nicht enttäuscht, wenn du nach ein paar Stunden noch nichts zusammenbekommen hast!
  Zeit ist das Stichwort!
  
  Antworten
Aida
8. Juli 2021 um 12:18 Uhr

Hallo Maximze,
Als Antwort auf deine Frage:
Auf der Internetseite der „Sendung mit der Maus“ des WDR gibt es einen Kurs zum Programmieren von Computerspielen mit der – auch für Anfänger/Innen geeigneten – Programmiersprache „Scratch“.
Hilft dir das weiter?

Antworten
Saskia
10. Juli 2021 um 17:14 Uhr

Hallo,
ich verstehe die letzte Aufgabe nicht ganz: Soll Nana die Steine, sofern vorhanden, auch einsammeln oder sich nur nach rechts drehen bzw. nach links, wenn kein Stein da liegt?

Antworten
1. NixC0d3r
  5. März 2022 um 16:22 Uhr
  
  Was denkst du denn?
  Hast du es mal ausprobiert, was geschieht, wenn ein Stein auf einem Feld liegt, dieser aber nicht eingesammelt wurde und sich Nana weiterbewegt?
  Die Antwort sollte eigentlich, ohne den Code auszuführen, schon logisch sein!
  
  Antworten
Konstantin
24. Juli 2021 um 17:58 Uhr

Hey, ich freue mich schon sehr auf den nächsten Kurs!
(Hab festgestellt. dass euer Programm die „repeat (Anzahl) {Funktion}“ Funktion zulässt. Aber autonom ist das ja noch nicht richtig XD)
LG Konstantin

Antworten
Oliver
3. August 2021 um 18:13 Uhr

Auch der zweite Kurs hat viel Spaß gemacht. Vielen Dank an Euch und ich freue mich auf den dritten Teil 🙂

Antworten

Thomas Winter

12. August 2021 um 19:39 Uhr

Ich hab eine frage warum wen ich bei dem 2. Level schon bei der Fahe bin bewegt sich es bei mir noch weiter uns so drifte ich ins all das hier ist meine Programierung.

fun solution() {
turnLeft()
forward2()
if ( fieldHasStone()){
      takeStone()
      turnRight()
      forward2()
      turnLeft()
      forward2()
      takeStone()
      turnRight()
      forward2()
      turnLeft()
      forward2()
      turnLeft()
      forward2()
      takeStone()
      turnRight() 
      forward2()
}
turnLeft()
forward2()
if ( fieldHasStone()){
      takeStone()}
turnLeft()
forward2()
if ( fieldHasStone()){
      takeStone()}
turnRight()
forward2()
if ( fieldHasStone()){
      takeStone()}
turnRight()
forward2()
turnLeft()
forward2()
turnLeft()
forward2()}
fun forward2() {
    forward()
    forward()
}
fun forward3(){
    forward()
    forward()
    forward()
}

Ich hoffe mir kann jemand schnell helfen weil ich umbedingt mit dem Kurs fertig werden will.

Antworten

Manuel Brütsch
26. Oktober 2021 um 0:11 Uhr

Thomas ich bin mir nicht siecher welche aufgabe du meinst, könnte es sein das du ein forward() zuviel hast? ich meine das gans am ende.

Antworten

Melcae

29. Dezember 2021 um 12:51 Uhr

wenn zufällige Anzahlen an Steinen auf den Feldern mit Steinen Lägen würde es mit diesem Code funktionieren:

fun turnAround() {
    turnLeft()
    turnLeft()
}
fun move() {
    forward()
    forward()
}
fun solution() {
    var x : Int = 0
    var y : Int = 0
    var z : Int = 1
    while (y < 7) {
        turnLeft()
        if (fieldHasStone()) {
            turnAround()
            z --
            while (z < 1) {
            	if (x < 6) {
            	    takeStone()
                    z ++
                    x ++
                    if (fieldHasStone()) {
                        z --
                    }
            	} else {
                    z = 6
        	}
            }
        }
        move()
        y ++
    }
}

Antworten

NixC0d3r
5. März 2022 um 16:25 Uhr

Bin ebenfalls schon auf den 3. Teil gespannt!

PS: Bin selbst kein Programmierer, verstehe aber dennoch einiges und konnte es bis hierher auch umsetzen (wenn auch manchmal anders als Eure Lösung; z.B. mittels weniger Code-Zeilen).

Antworten
Anonymous
20. März 2022 um 18:09 Uhr

Super, warte nun auf den 3. Teil.
Tolle Arbeit!

Antworten
Anonymous
20. März 2022 um 18:12 Uhr

Erinnert mich an Karel 😉 Hat mir ebenfalls gut geholfen.
Wirklich toll gemacht, warte auf den dritten Teil.

Antworten
Sophie
4. April 2022 um 11:07 Uhr

Hallo,

erstmal Kompliment für den Kurs !!

Bei der Aufgabe, wo die Steine zufällig verteilt liegen, erscheint bei mir ständig dieser Fehlercode:

„Conflicting overloads: public fun turnRight(): Unit defined in root package in file File.kt, public fun turnRight(): Unit defined in root package in file File.kt“

Mein Code sieht aber genauso aus wie in der Lösung..

Grüße von Sophie 🙂

Antworten
1. Flo
  5. April 2022 um 8:09 Uhr
  
  Hallo Sophie!
  Es freut uns sehr, dass dir der Kurs gefällt. Danke für dein Feedback!
  
  Wenn du am oberen Rand in der Mitte des Eigabefeld auf das „+“ klickst, siehst du dass dort schon die Funktion „turnRight“ für dich erstellt ist.
  
  Wenn du selbst auch noch eine Funktion „turnRight“ erstellst gibt es die Funktion zwei mal und kotlin kennt sich nicht aus, weil es die beiden Funktionen nicht unterscheiden kann. Daher bekommst du eine „Conflicting overloads“ Fehlermeldung die dir zwei mal sagt dass die Funktion „turnRight“ in „File.kt“ definiert wurde.
  
  Wenn du aus deinem Code die Definition von „turnRight()“ weglässt wird es funktionieren.
  
  Viel Spaß beim Programmieren!
  Liebe Grüße,
  Flo
  
  Antworten
Christian
5. April 2022 um 13:16 Uhr

Ich finde diese Aufgaben sehr intressant, sie machen viel spaß dennoch hab ich oft probleme mir einfach die sachen zu merken oder weiß nicht was ich machen soll. Ich schau dann meistens in den lösungen und schreibe nur ab was ineffektiv ist.
Hat jemand tipps damit das nicht mehr passiert?

Antworten
No. 1
3. Mai 2022 um 18:28 Uhr

Wann kommt der nächste Teil?!

Antworten
C64
16. Mai 2022 um 15:30 Uhr

Hier mal meine Lösung 🙂
fun turnRight() {
turnLeft()
turnLeft()
turnLeft()
}

fun forward2(){
forward()
forward()
}

fun turnLeftandMove2(){
turnLeft()
forward2()
}

fun turnRightandMove2(){
turnRight()
forward2()
}

fun Steincheck(){
if (fieldHasStone()){
takeStone()
turnRightandMove2()
} else {turnLeftandMove2()}
}

fun solution() {
Steincheck()
Steincheck()
Steincheck()
Steincheck()
Steincheck()
Steincheck()
Steincheck()
}

Antworten
Johanna
25. Juli 2022 um 19:10 Uhr

Erstmal vorneweg: super tolle Seite, die einem das Ganze gut zeigt. So schaffe ich es auch endlich, das was vorher so abstrakt wirkte, zu verstehen.

Ich hatte Schwierigkeiten bei Teil 2 bei der ersten Aufgabe mit dem Labyrinth. Ich hatte es so verstanden, dass die Steine nur noch als Wegweiser dienen und nicht mehr eingesammelt werden müssen. 10 Minuten später und einen halben kleinen Nervenzusammenbruch, hab ich das erst im Vergleich mit dem Beispielcode entdeckt….

Antworten
Leon
21. August 2022 um 21:39 Uhr

Hallo,
ich habe viele Fehlermeldungen bei Programmteile bedingt ausführen mit „if“ . Ich habe meine Lösung mit eurer Lösung verglichen , aber es scheint trotzdem nicht richtig zu sein . Ich wurde gerne wissen , woran das liegt und wie ich es beheben könnte . Ich habe sogar versucht euren vorgeschlagenen Code zu verwenden , um zu schauen , ob es funktioniert , aber das ging auch nicht.

So sieht mein Code aus :
fun turnRight() {
turnLeft()
turnLeft()
turnLeft()
}
fun IsThereAStone() {
forward()
if (fieldHasStone()) {
takeStone()
}
}
fun solution() {

IsThereAStone()
turnLeft()
IsThereAStone()
turnRight()
IsThereAStone()
IsThereAStone()
turnRight()
IsThereAStone()
turnLeft()
IsThereAStone()
IsThereAStone()
turnLeft()
forward()
}

fun forwardAndTake() {
forward()
if (fieldHasStone()) {
takeStone()
}
}

Und das sind die folgenden Fehlermeldungen:
Conflicting overloads: public fun turnRight(): Unit defined in root package in file File.kt, public fun turnRight(): Unit defined in root package in file File.kt
Conflicting overloads: public fun turnRight(): Unit defined in root package in file File.kt, public fun turnRight(): Unit defined in root package in file File.kt
Overload resolution ambiguity: public fun turnRight(): Unit defined in root package in file File.kt public fun turnRight(): Unit defined in root package in file File.kt
Overload resolution ambiguity: public fun turnRight(): Unit defined in root package in file File.kt public fun turnRight(): Unit defined in root package in file File.kt

Antworten
Dose
23. August 2022 um 21:49 Uhr

Der Kurs hat Spaß gemacht, allerdings frage ich mich, ob Teil 3 überhaupt noch kommen wird. Teil 2 ist nun ja auch schon ein Jahr her.

Antworten
Noah
29. August 2022 um 16:51 Uhr

hat viel spaß gemacht bin aber bisschen untergbegat, deswegen war ich sehr langsam

Antworten
DerApple
13. Dezember 2022 um 21:55 Uhr

if (finishedClass()) {
lotsOfFun()
} else { not()
}

😉

Antworten
Vindi
3. März 2023 um 11:27 Uhr

Hier mal meine Lösung:

fun turnRight() {
turnLeft()
turnLeft()
turnLeft()
}

fun forward2(){
forward()
forward()
}

fun move(){
if (fieldHasStone()){
takeStone()
turnRight()
} else {
turnLeft()
}
forward2()
}

fun play(){
turnLeft()
forward2()
move()
move()
move()
move()
move()
move()
}

fun solution() {
play()
}
// Es hat mir viel Spaß gemacht! //

Antworten
Milo
18. Februar 2024 um 14:55 Uhr

Ein herzliches Danke an Euch : ) Hab etwas dazu gelernt und meine grauen Zellen in Schwung gebracht : ))
In Informatik war ich früher schlecht… Dank Eurer guten Didaktik habe ich endlich kapiert wie Programmieren funktioniert und dass ich das auch kann, wenn es mir anschaulich erklärt wird. Außerdem hat es tatsächlich Spaß gemacht
Hier meine Lösung für die solution Funktion in 10 Zeilen ( ^_^)

fun turnRight() {
turnLeft()
turnLeft()
turnLeft()
}

fun StoneLeftBanch() {
turnLeft()
forward()
if (fieldHasStone()) {
takeStone()
}
}

fun StoneRightBanch() {
turnRight()
forward()
if (fieldHasStone()) {
takeStone()
}
}
fun StoneForward(){
forward()
if (fieldHasStone()) {
takeStone()
}
}

fun solution() {
StoneForward()
StoneLeftBanch()
StoneRightBanch()
StoneForward()
StoneRightBanch()
StoneLeftBanch()
StoneForward()
StoneLeftBanch()
}

Antworten
1. Flo
  21. Februar 2024 um 20:17 Uhr
  
  Es freut uns sehr, dass es dir Spaß gemacht hat und du Freude an der Informatik endteckt hast 🙂
  
  Antworten

Kommentar verfassen Kommentieren abbrechen

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.

Funktionen, die Antworten liefern

Programmteile bedingt ausführen mit „if“

Entscheidungen treffen mit „if“ und „else“

codefuchs Newsletter

47 Kommentare zu „Teil 2: Auf die Umgebung reagieren“

Kommentar verfassen Kommentieren abbrechen