Für die alde

test.py

# Hier ist ein möglicher lösungsansatz:
# Stell dir vor, du hast vier Geo-Dreiecke. Du legst eines an jede Seite
# der Matrix. Du wanderst am Anfang nach Rechts, bis es nicht weiter geht:
# Also du gibst die elemente 1, 2, 3, 4, 5 aus. Du bist ein blöder Computer, deshalb
# musst du dir merken, dass du diese erste zeile abgearbeitet hast, also schiebst du
# das geodreieck, dass an der oberen seite der matrix ist eine position runter, so dass
# es jetzt an der reihe [ 6, 7, 8, 9, 10 ] anliegt. Du gehst jetzt runter bis es nicht mehr
# geht, also gibst die elemente 10, 15, 20 aus. Du bist ein blöder Computer, deshalb
# merkst du dir wieder, dass du den rechten rand abgearbeitet hast, tust also das geodreieck
# dass auf der rechten seite der matrix liegst eine spalte nach links verschieben.
# Jetzt gehst du nach links: 19, 18, 17, 16. Das Untere geodreieck eine zeile höher.
# Jetzt gehst du nach oben: 11, 6, .... da liegt das obere geodreieck! Ich bin ein
# doofer computer, das hab ich wahrscheinlich schon gemacht. Also wieder nach Rechts.
# Vorher noch das Linke Geodreieck um eine position nach rechts verschieben.
# 7, 8, 9, ... da liegt das rechte geodreieck, also jetzt wieder runter, und vorher
# das obere geodreieck wieder nach unten verschieben. 14. Da liegt wieder das untere
# geodreieck. Also jetzt nach links und das rechte geodreieck eins nach links verschieben.
# 13, 12... jetzt ist dort das linke geodreieck, also gehe ich jetzt nach oben und verschiebe
# das untere geodreieck wieder eins nach oben... warte, jetzt würden sich das untere und
# das obere geodreieck überlappen! Dann ist das wohl das ende!
matrix = [
    [  1,  2,  3,  4,  5 ],
    [  6,  7,  8,  9, 10 ],
    [ 11, 12, 13, 14, 15 ],
    [ 16, 17, 18, 19, 20 ]
]

# Initial fangen wir bei [0, 0] an und wollen uns nach rechts bewegen
richtung = 'Rechts'
index_zeile = 0
index_spalte = 0

# Initial ist das Limit, also das maximum in das wir uns in eine
# richtung bewegen, die größe der Matrix, in diesem fall 4x5 (und in
# CS fängt man bei 0 an zu zählen, daher 3x4.)
limit_zeile_oben = 3
limit_spalte_oben = 4

# Es gibt auch ein unteres limit, also wenn wir uns nach oben oder linke
# bewegen, dass wir wissen, wo wir aufhören
limit_spalte_unten = 0
limit_zeile_unten = 0


while True:
    # Wenn wir uns nach Rechts bewegen und wir am "Rand" des erlaubten Rand
    # sind, also oben rechts, dann wollen wir zwei sachen machen
    # a) wir merken uns dass wir uns als nächstes nach unten bewegen wollen
    # b) wir ändern das obere limit: nach diesem nach rechts bewegen wollen
    #    wir nie wieder in die spalte ganz rechts, daher dekrementieren wir
    if richtung == 'Rechts' and index_spalte >= limit_spalte_oben:
        richtung = 'Runter'
        limit_spalte_oben -= 1
    # Wenn wir uns nach Rechts bewegen und nicht an irgendeinem Rand sind,
    # dann machen wir zwei sachen
    # a) wir geben das element aus, wie in der aufgabe steht
    # b) wir merken uns, dass nächste mal zum nächsten element zu gehen.
    elif richtung == 'Rechts':
        print(matrix[index_zeile][index_spalte])
        index_spalte += 1

    # Das Gleiche wenn wir uns runter bewegen. Hier bekommen wir raus, ob wir am
    # Rand des erlaubten bereich sind, indem wir checken, ob die zeile in der wir 
    # sind größer gleich dem limit ist. Wenn das der fall ist, wollen wir nach links
    elif richtung == 'Runter' and index_zeile >= limit_zeile_oben:
        richtung = 'Links'
        limit_zeile_oben -= 1
    elif richtung == 'Runter':
        print(matrix[index_zeile][index_spalte])
        index_zeile += 1

    # Hier das gleiche. Nur zu bemerken, dass wenn wir uns nach links bewegen
    # das untere limit (also am anfang 0) berücksichtigen und wenn wir am rand sind
    # dieses inkrementieren
    elif richtung == 'Links' and index_spalte <= limit_spalte_unten:
        richtung = 'Hoch'
        limit_zeile_unten += 1
    elif richtung == 'Links':
        print(matrix[index_zeile][index_spalte])
        index_spalte -= 1

    # Same here, für den fall "Hoch"
    elif richtung == 'Hoch' and index_zeile <= limit_zeile_unten:
        richtung = 'Rechts'
        limit_spalte_unten += 1
    elif richtung == 'Hoch':
        print(matrix[index_zeile][index_spalte])
        index_zeile -= 1

    # So, das ist unsere Schleifen-end bedingung, wenn das obere zeilenlimit 
    # größer wird als das untere zeilenlimit, oder das selbe für spalten, dann sind
    # wir am letzten element, geben das noch aus und brechen dann aus der schleife aus.
    if limit_zeile_oben < limit_zeile_unten or limit_spalte_oben < limit_spalte_unten:
        print(matrix[index_zeile][index_spalte])
        break

# Ausgabe des Skripts:
# geo@gg ~> python /tmp/test.py
# 1
# 2
# 3
# 4
# 5
# 10
# 15
# 20
# 19
# 18
# 17
# 16
# 11
# 6
# 7
# 8
# 9
# 14
# 13
# 12