==== 3.2 ====

Ineinander geschachtelte ''for''-Schlaufen: 

  * **Primzahlen**: Schreibe ein Programm, dass dir bis zu einer Zahl $n$ alle Primzahlen ausgibt.
  * **"Gläser anstossen"**. Zeichne Kreis mit $n$ gleichverteilten Punkten (Punkte auf dem Kreis haben die Koordinaten $(r\cdot \cos(\frac{2\pi}{n}\cdot i),r\cdot \sin(\frac{2\pi}{n}\cdot i))$. $i$ ist der $i$-te Punkt). Verbinde jeden dieser Punkte mit allen anderen Punkten. Die graphische Umsetztung kann entweder mit GPanel oder einer Turtle erfolgen. {{ :efinf:blcks2017:jython:efinf:blcks2017:jython:complete_graph.png?200 |}}. Achtung: Es stosst jeder mit jedem, das heisst Ernst mit Silvia und Silvia mit Ernst.
      * **GPanel**. Schau dir die Funktion ''line'' und ''move'' in der Dokumentation an
        * Optional: Farben können in [[https://de.wikipedia.org/wiki/RGB-Farbraum|RGB]] spezifiert werden und haben in der RGBA-Erwweiterung sogenannten [[https://de.wikipedia.org/wiki/RGB-Farbraum#RGBA-Erweiterung|Alpha-Kanal]], welcher die Transparenz definiert. Mit ''setColor(makeColor(255, 0, 0, 100))'' wird zum Beispiel ein transparentes Rot dargestellt.
        * //Optional//: Jetzt soll nicht mehr jeder mit jedem anstossen sondern es soll nur noch einmal gemeinsam anstossen werden.
      * **Turtle**. Die Grafik ist auch mit der Turtle möglich. Es empfiehlt sich allerdings, die Funktionen ''pushState()'' und ''popState()''  (siehe Beispiel Kapitel 2.11) anzuschauen. 
  * **"Bruteforce-Attack"**.Schreibe ein Programm, dass alle möglichen Passwordkombinationen der Länge $3$ mit einem beliebigen Alphabet $\{a,b,c,d\}$ ausgibt. Tipp: Strings sind in Python sogenannt iterierbare Objekte: <code python>
for c in 'abcd':
  print c
 </code>
    * //Optional//: Obige Aufgabe mit beliebiger Länge. Tipp: Rekursion.


==== 3.4 ====
Neber der Möglichkeit, Farben als Strings anzugeben, besteht immer auch die Möglichkeit, Farben als RGB-Werte mit ''setColor(makeColor(r,g,b))'' zu definieren. $r$, $g$, $b$ sind dabei die Rot-, Grün- und Blau-Anteile zwischen $0$ und $255$. Farben auswählen kann man mit einem [[http://lmgtfy.com/?q=color+picker|ColorPicker]]
  * **Abstand vom Urpsrung**: Modifiziere das [[efinf:blcks2017:jython:lektionen#l6|Beispiel aus Kapitel 2.10]]. Schreibe eine Funktion welche auf Grund des Abstands zum Ursprung die Farbe der Turtle verändert. Der Rückggabewert deiner Funktion soll Argument zu ''setColor()'' werden. Verwende dabei mindestens drei Farben.
    * Optional: Lies dir das Kapitel zu "Dictionary" (6.3) durch. Findest du eine Lösung, wie du beliebig viele Farben und Distanzbereiche verwenden kannst?
  * **2048**: Schreibe eine Funktion, welche dir auf Grund eines Kachelwerts (einer Zweierpotenz) die zugehörige Farbe liefert. Du kannst das Skelett unten verwenden. Es geht einzig darum, die Funktion ''definiereFarbe'' zu schreiben.


<code python skelett.py>
from gpanel import *


# Globale Variablen zur Steurung 
kachelsize = 4
kachelno = 4


makeGPanel(0, kachelno*kachelsize, 0, kachelno*kachelsize)

#Spielbrett
tiles = [[-1,  2 ,4, 8],
            [16, 32 , 64, 128 ],
            [256, 512, 1024, 2048],
            [ -1 , -1,  -1 , -1 ]]
            
# Funktion zeichnet Kachel. 
# Argumente: olx, oly x und y Koordinate oben links
#            shownumber: Zahl die angezeigt werden soll
#            size: Grösse der Kachel

def zeichneKachel(olx, oly, color, shownumber="", size=kachelsize):
    setColor(color)
    fillRectangle(olx,oly,olx+size,oly-size)
    if shownumber <> "":
        text(olx+size/2,oly-size/2,str(tiles[i][j]), Font("Courier", Font.PLAIN, 24),"black","white")

# Funktion gibt Farbe auf Grund von Kachelwert zurück 
# Argumente: Kachelwert -1,2,4,...,2049
def definiereFarbe(kachelwert):
    # hier die Funktion definieren
    return("green")

#loop durch zeilen
for i in range(0, kachelno):
    #loop durch spalten
    for j in range(0, kachelno):
        #zeichne die Kachel i,j mit definierter Farbe 
        zeichneKachel(0+j*kachelsize, kachelno*kachelsize-i*kachelsize, definiereFarbe(tiles[i][j]), str(tiles[i][j]))
        
getKeyCodeWait()
dispose()
</code>
==== 3.9 ==== 
Für 2048 müssen wir Elemente in Listen verschieben und ändern. Löse dazu folgende Aufgaben:
  - Schreibe eine Funktion, welche alle Elemente in einer Liste ''[3,8,-1,3]'' nach rechts schiebt. Achtung: '-1' steht dabei für <<leer>> 
  - Schreibe eine Funktion, welche einerseits alle Elemente nach rechts schiebt und wenn zwei gleiche Zahlen (ausser <<leer>>) nebeneinander liegen, diese durch eine leere und das doppelte der beiden ersetzt.
  - Schreibe eine Funktion, welche das ganze für eine <<Liste von Listen>> durchführt: Dazu kannst du deine Funktion aus 2 auf jedes Element der oberen Liste anwenden.
  - Optional: Schreibe eine Funktion, welche eine geschachtelte Liste rotiert, i.e. <code> 
%aus
[[-1, 2, 4, 8],
 [16, 32, 64, 128],
 [256, 512, 1024, 2048],
 [-1, -1, -1, -1]]
% wird
[[-1, 256, 16, -1],
 [-1, 512, 32, 2],
 [-1, 1024, 64, 4],
 [-1, 2048, 128, 8]]</code>
<hidden Tipps> 
  - Schreibe eine erste Funktion, welche alle Zahlen aus der Liste in eine neue Liste packt. Ergänze dann diese neue Liste an der richtigen Stelle um die ignorierten leeren Zellen (also um  '-1'). Hilfreiche Funktionen können sein: 
    * ''count(x)'' zählt die Vorkommen von ''x'' in der Liste. Bsp.: ''[3,8,-1,3].count(3)'' liefert ''2'' zurück.
    * Alle Funktionen im <<Memo>> im Kapitel 3.9
  - Verwende die Funktion aus 1. um alle Elemente nach rechts zu schieben. Hast du das, kannst du den nächsten Schritt angehen, das heisst, überprüfen, ob zwei nebeneinanderliegende Elemente identisch sind. Falls ja, diese durch ''-1'' resp. ''2*list[i]'' ersetzen.
  - Am besten iterierst du über eine ''for''-Schlaufe durch die Zeilen der Liste. Die einzelnen Zeilen kannst du dann mit der Funktion 2 bearbeiten und den Rückgabewert der Funktion als neue Zeile verwenden. 

<code python skelett_a12.py>
liste =[[-1, 2, 4, 8],
 [16, 32, 64, 128],
 [256, 512, 1024, 2048],
 [-1, -1, -1, -1]]

print(liste)
#dumme funktion die das zweite und dritte element vertauscht
def meinefunktiondiediezeilemodifiziert(inzeile):
    print("Ich habe als Argument erhalten:")
    print(inzeile)
    outzeile = [inzeile[0],inzeile[2],inzeile[1],inzeile[3]]
    return(outzeile)

for i in range(len(liste)):
    liste[i] = meinefunktiondiediezeilemodifiziert(liste[i])

print(liste)  
</code>
</hidden>
=== Listen iterieren ===
Listen sind zwar iterierbare Objekte, manchmal ist es aber hilfreich die Indices zu verwenden: Zwei von der Ausgabe her äquivalente Lösungen zur Ausgabe jedes Elements sind unten.
<code python listloops.py>
items = [2,-1,8,4]

for i in range(len(items)):
    print(items[i])

for el in items:
    print(el)
</code>
=== Ausgabe Listen ===
Als kleine Hilfestellung noch die untenstehende Funktion ''printDoubleLists(lists)''. Diese gibt eine geschachtelte Liste wie sie z.B. in 2048 vorkommen, auf der Konsole aus.
<code python printdoublelists.py>
import sys
tiles = [[-1,  2 ,4, 8],
            [16, 32 , 64, 128 ],
            [256, 512, 1024, 2048],
            [ -1 , -1,  -1 , -1 ]]


def printDoubleLists(lists):
    for i in range(len(lists)):
        for j in range(len(lists[i])):
            sys.stdout.write(str(lists[i][j]))
            sys.stdout.write("\t")
        sys.stdout.write("\n")
        
printDoubleLists(tiles)
</code>