====== - Programmieren Repetitionsdossier ====== ==== Informationen ==== * Verwende nur die vordefinierten Funktionen, die im Dossier zur Programmierung vorkommen. Alles andere muss **selbst programmiert werden**. Soll man zum Beispiel die Summe aller Elemente einer Liste berechnen, so mache dies selbst in einer Schleife und verwende //nicht// die vordefinierte Funktion `sum()`. Diese Regel gilt auch für **Prüfungen**. \\ \\ * Die Verwendung von **repeat** ist verboten! Verwende stattdessen while-Schleifen und später auch for-Schleifen. * Es werden **keine Musterlösungen** verteilt. Sende deine Lösungen per Teams an deine Lehrperson, um eine Rückmeldung zu erhalten. Gib in einem Kommentar oberhalb der Aufgabe an, um welche Aufgabe es sich handelt, z.B. `# Aufgabe 1.7`. Gib weiter an, ob der Code funktioniert, resp. beschreibe den auftretenden Fehler. \\ \\ * Die Aufgaben unten können durch weitere ergänzt werden, es lohnt sich also, regelmässig nachzuschauen. \\ \\ ===== - Grundlagen I ===== benötigtes **Vorwissen**: * Variablen * while-Schleifen * if-(elif-)else-Verzweigungen ==== - Aufgabe ==== Bestimme die Summe aller dreistelliger ganzer Zahlen. Das Resultat muss sein: $494550$ ++++Lösung|

++++ ==== - Aufgabe ==== Erzeuge die folgende Figur mit Turtle Graphics. Verwende dazu Schleifen wo möglich. \\ {{:gf_informatik_1m_20_21:spirale_dreieck.png?200|}} ++++Lösung|

++++ ==== - Aufgabe ==== **Pythagoras-Rechner:** Die Idee ist, ein Programm zu schreiben, in welches man zwei Seiten von einem rechtwinkligen Dreieck eingeben kann und die dritte mithilfe des Satzes von Pythagoras dann berechnet wird. Für den Satz vom Pythagoras gibt es zwei Fälle: * Fall 1: Beide Katheten gegeben, berechne Hypotenuse * Fall 2: Eine Kathete und Hypotenuse gegeben, berechne zweite Kathete Zuerst soll die Benutzerin gefragt werden, welchen Fall (inkl. kurzer Beschreibung) sie berechnen möchte. Dann wird sie aufgefordert, die entsprechenden Werte für Kathete(n)/Hypotenuse einzugeben. Das Resultat wird berechnet und ausgegeben. ==== - Aufgabe ==== Erzeuge die folgende Figur mit Turtle Graphics. Verwende dazu Schleifen wo möglich. \\ {{:gf_informatik_1m_20_21:spirale_sechseck.png?200|}} ++++Lösung|

++++ ==== - Aufgabe ==== Der Benutzer wird aufgefordert, eine beliebige dreistellige Zahl einzugeben. Dem Benutzer wird zuerst einmal mitgeteilt ob er überhaupt eine Zahl eingegeben hat. Falls ja, wird weiter mitgeteilt, ob die eingegebene Zahl das Kriterium erfüllt. //Tipp:// Mit `type(x)` kann der Typ der Variable `x` (z.B. `int` oder `str`) ermittelt werden. ++++Lösung|

++++ ==== - Aufgabe ==== Bestimme das Produkt von allen Zahlen von 50 bis und mit 100. Die Lösung ist `153425937812748301860136522976473486961422986084234447972389349349107947938617753600000000000000`. ++++Lösung|

++++ ==== - Aufgabe ==== In der Mathematik (besonders in Wahrscheinlichkeit und Kombinatorik) braucht man oft die **Fakultät**: $$n! = n \cdot (n-1) \cdot (n-2) \cdot \ldots 2 \cdots 1$$ Einige Beispiele: * Fakultät von $3$: $3! = 3 \cdot 2 \cdot 1 = 6$ * Fakultät von $5$: $5! = 5 \cdot 4 \cdot 3 \cdot 2 \cdot 1 = 120$ * Fakultät von $1$: $1! = 1$ * Fakultät von $0$ ist definiert als: $0! = 1$ * Fakultät von negativen Zahlen ist nicht definiert. Der Benutzer wird aufgefordert eine Zahl einzugeben. Von dieser Zahl wird die Fakultät berechnet und ausgegeben. Stelle sicher, dass die Spezialfälle (0,1, negative Zahlen) auch korrekt verarbeitet werden. ==== - Aufgabe ==== Erzeuge die folgende Figur mit Turtle Graphics. Verwende dazu Schleifen wo möglich. \\ {{:gf_informatik_1m_20_21:sechseck.png?200|}} ++++Lösung|

++++ ==== - Aufgabe ==== 1. Der Benutzer wird aufgefordert, einen String einzugeben, der aus genau 10 Zeichen besteht. Dem Benutzer wird zurückgemeldet, ob der eingegebene String diese Bedingung erfüllt, ob er zu lange oder zu kurz ist. Die Länge eines Strings (z.B. `s = "Ich bin ein String"`) wird mit `len(s)`bestimmt.\\ \\ 1. Modifiziere nun den Code so, dass der Benutzer solange aufgefordert wird, einen solchen String einzugeben, bis die Bedingung erfüllt ist. ++++Lösung|

++++ ==== - Aufgabe ==== **Lebenstipps:** Die Benutzerin wird aufgefordert einzugeben, wie sie sich gerade fühlt auf einer Skala von $0$ (total mies) bis $5$ (sensationell!). Je nach eingegebener Zahl, soll ihr ein anderer Tipp fürs Leben mitgegeben werden. ==== - Aufgabe ==== Zeichne ein Pentagramm. \\ {{:gf_informatik_1m_20_21:pentagramm.png?200|}} ++++Lösung|

++++ ==== - Aufgabe ==== Zeichne einen Kreis, ohne Funktionen wie `rightArc(x,y)`, `leftArc(x,y)`, `leftCircle(x)` oder `rightCircle(x)` zu verwenden. Verwende stattdessen `forward(x)` und `right(x)` usw. ++++Lösung|

++++ ===== - Grundlagen II ===== benötigtes **Vorwissen**: * Vorwissen von Grundlagen I * Schleifen * Funktionen * Listen ==== - Aufgabe ==== *Löse nur, wenn du for-Schleifen kennst.* Wandle in while-Schleife um:


for i in range(4,12):
	print(i)

++++Lösung|

++++ ==== - Aufgabe ==== Die Innenwinkelsumme in einem Dreieck ist 180 Grad. Sobald man also zwei Winkel kennt, kann man den dritten berechnen. Definiere eine Funktion `innenwinkelsumme(a,b)`, welcher man zwei Winkel a und b übergibt. Die Funktion bestimmt dann den dritten Winkel und gibt diesen zurück. ++++Lösung|

++++ ==== - Aufgabe ==== Schreibe eine Funktion `mul(a,b)`, welche zwei ganze Zahlen a und b multipliziert und zurückgibt. Als einzige mathematische Operation darf Plus (+) verwendet werden! Die Operation * darfst du also nicht gebrauchen. ++++Lösung|

++++ ==== - Aufgabe ==== *Löse nur, wenn du for-Schleifen kennst.* Wandle in möglichst kurze for-Schleife (max. 2 Zeilen) um:


i = 10
while i < 29:
    print(i)
    i = i + 3

++++Lösung|


for i in range(10,30,3):
    print(i)
"""
OUTPUT:
10
13
16
19
22
25
28
"""

++++ ==== - Aufgabe ==== Schreibe eine Funktion `power(a,n)`, welche a hoch n berechnet und zurückgibt. Dabei darfst du den Hoch-Operator \*\* nicht gebrauchen: * Variante 1 (einfacher): Verwende den Multiplikations-Operator * * Variante 2 (anspruchsvoller): Verwende den Additions-Operator + ++++Lösung|

++++ ==== - Aufgabe ==== Schreibe eine Funktion `teilbar_durch(a,b)`, welche zwei ganze Zahlen als Argumente erwartet. Die Funktion gibt True (False) zurück, falls man a (nicht) durch b ohne Rest dividieren kann. ++++Lösung|

++++ ==== - Aufgabe ==== Schreibe eine Funktion `celsius_zu_fahrenheit(x)`, die eine Temperatur in Grad Celsius x in die entsprechende Temperatur in Fahrenheit umwandelt und zurück gibt. Die entsprechende Formel findest du hier: https://de.wikipedia.org/wiki/Grad_Fahrenheit#Umrechnung ++++Lösung|

++++ ==== - Aufgabe ==== Schreibe eine Funktion `div_mit_rest(a,b)`, welche zwei ganze Zahlen a und b ganzzahlig und mit Rest dividiert. Zurückgegeben wird eine Liste mit zwei Elementen: Das erste Element ist das Resultat der Division, das zweite der Rest. Als einzige mathematische Operationen darf Plus (+) und Minus (-) verwendet werden! Für `div_mit_rest(20,7)` erhält man die Liste [2,6] zurück, da 20:7 = 2 Rest 6 ist. ++++Lösung|

++++ ==== - Aufgabe ==== Der Benutzer wird nach einer ganzen Zahl gefragt. Es wird dann eine Liste mit dieser Anzahl an Zufallszahlen gefüllt und ausgegeben. ++++Lösung|

++++ ==== - Aufgabe ==== *Löse nur, wenn du for-Schleifen kennst.* Schreibe als for-Schleife:


k = 4
while(k < 13):
	print(k)
	k = k+2

Schaffst du es mit nur zwei (oder gar einer) Zeile(n) Code? ++++Lösung|

++++ ==== - Aufgabe ==== 1. Definiere eine Funktion `zweierpotenzen(n)`, welche die ersten n Zweierpotenzen in eine Liste schreibt und zurückgibt. Für `zweierpotenzen(5)` erhält man `[2,4,8,16,32]` zurück.\\ \\ 1. Erhöhter Schwierigkeitsgrad: Definiere nun eine zweite Version dieser Funktion `zweierpotenzen_b(n)`. Hier sollen nun diejenigen Zweierpotenzen in eine Liste geschrieben werden, die kleiner gleich n sind. Für `zweierpotenzen(20)` erhält man `[2,4,8,16]` zurück. ++++Lösung|

++++ ==== - Aufgabe ==== Definiere eine Funktion `mittelwert(a, b, c, d)`, der vier Zahlen übergeben wird. Die Funktion soll deren Mittelwert berechnen und zurückgegeben. Übergibt man zum Beispiel vier Schulnoten, so erhält man den Notendurchschnitt zurück. Zeige den Durchschnittswert dann in einem formatierten String an, z.B. "Der Mittelwert ist 4.46". ++++Lösung|


def mittelwert(a,b,c,d):
  summe = a + b + c + d
  return summe / 4

print("Der Mittelwert ist {0}".format(mittelwert(4.2, 3.8, 5.7, 5.1)))

++++ ==== - Aufgabe ==== Definiere eine Funktion `mittelwert(L)`, welcher eine Liste mit Zahlen übergeben wird. Von diesen Zahlen wird dann der Mittelwert berechnet und zurückgegeben. Übergibt man zum Beispiel eine Liste mit Schulnoten, so erhält man den Notendurchschnitt zurück. Zeige den Durchschnittswert dann in einem formatierten String an, z.B. "Der Mittelwert ist 4.46". ++++Lösung|

++++ ==== - Aufgabe ==== Definiere eine Funktion `anzahl_null(L)`, welcher eine Liste mit Zahlen übergeben wird. Es wird gezählt, wie oft der Wert 0 darin vorkommt. Diese Anzahl wird zurückgegeben. Für die List `[5,0,4,1,2,0,3,0]` erhält man 3 zurück. ++++Lösung|

++++ ==== - Aufgabe ==== Schreibe eine Funktion `my_max(x,y,z)`, die von den drei Zahlen, die übergeben werden, die grösste bestimmt und //zurückgibt//. Verwende keine vordefinierten Funktionen, programmiere selbst. ++++Lösung|

++++ ==== - Aufgabe ==== **Einkaufs-Rechner** Du kaufst ein: 6 Eier (je 85 Rp.), 4 Brötchen (je 1.20 Fr.), 1 Flasche Rivella (2.50). Diese Information wird in zwei Listen gespeichert:


anzahl = [6,4,1]
preise = [0.85,1.20,2.50]

Schreibe eine Funktion `shopping_calculator(anz,pri)` die berechnet, wieviel der Einkauf kostet. Dieser Wert wird zurückgegeben. Für das obige Beispiel, also mit `shopping_calculator([6,4,1],[0.85,1.20,2.50])`, soll man das Ergebnis $12.40$ erhalten. ++++Lösung|


def shopping_calculator(anz,pri):
    kosten = 0
    for i in range(len(anz)):
        kosten += anz[i] * pri[i]
    return kosten

++++ ==== - Aufgabe ==== Schreibe eine Funktion `fortune_cookie()`, die ein Glückskeks-Spruch-Generator ist: Jedesmal wenn die Funktion aufgerufen wird, wird random ein Spruch, der in einer Liste gespeichert wird, ausgegeben. Im Internet gibt es viele Sprüche, die du dafür verwenden kannst: https://examples.yourdictionary.com/articles/funny-fortune-cookie-sayings.html ==== - Aufgabe ==== Schreibe eine Funktion `find_42(L)` die zählt, wie oft die Zahl $42$ in der Liste L vorkommt und diese Anzahl zurückgibt. Verwende keine vordefinierten Funktionen. ++++Lösung|


def find_42(L):
    count = 0
    for l in L:
        if l == 42:
            count = count + 1
    return count

print(find_42([4,1,"blabla",42,7,13,42]))

++++ ==== - Aufgabe ==== Schreibe eine Funktion `split_list(L,x)`. Diese nimmt eine Liste mit Zahlen, sowie eine einzelne Zahl x entgegen. Die Zahlen in L sollen auf zwei Listen aufgeteilt werden: Die eine Liste soll alle Zahlen aus L, die kleiner gleich x sind beinhalten und die andere Liste alle Zahlen, die grösser sind. Die beiden Listen werden zurückgegeben. ==== - Aufgabe ==== Weitere Umwandlungsaufgaben: (zählen alle zusammen als //eine// Aufgabe für einen Tag) === for -> while === *Löse nur, wenn du for-Schleifen kennst.* Schreibe als while-Schleife:


for i in range(5):
    print(i)


for k in range(2,13):
    print(k)


for j in range(10,50,5):
    print(j)

=== while -> for === Schreibe als //möglichst kurze// for-Schleife:


i = 5
while i < 20:
    i = i + 1
    print(i)


i = 5
while i < 20:
    print(i)
    i = i + 3

++++Lösung|


# a)
"""
for i in range(5):
    print(i)
"""
i = 0
while i < 5:
    print(i)
    i += 1

# b)
"""
for k in range(2,13):
    print(k)
"""
i = 2
while i < 13:
    print(i)
    i += 1

# c)
"""
for j in range(10,50,5):
    print(j)
"""
i = 10
while i < 50:
    print(i)
    i += 5

# d)
"""
i = 5
while i < 20:
    i = i + 1
    print(i)
    # output: 6,7,...,20
"""
for i in range(6,21):
    print(i)

# e)
"""
i = 5
while i < 20:
    print(i)
    i = i + 3
"""
for i in range(5,20,3):
    print(i)

++++ ==== - Aufgabe ==== Definiere eine Funktion `product(L)`, die eine Liste `L` mit Zahlen entgegennimmt, deren Produkt bestimmt und zurückgibt. ++++Lösung|


def product(L):
    p = 1
    for x in L:
        p = p*x
    return p

++++ ==== - Aufgabe ==== Schreibe eine Funktion `is_prime(x)`, die eine Zahl `x` entgegennimmt, entscheidet, ob diese Zahl eine Primzahl ist oder nicht und dementsprechend True/False zurückgibt. Achtung: Diese Funktion hast du bereits einmal programmiert. Programmiere diese Funktion aber neu und ohne den alten Code anzuschauen. ++++Lösung|


def is_prime(x):
    for i in range(2,x):
        if x % i == 0:
            return False
    return True

++++ ==== - Aufgabe ==== Bestimme die Summe aller Primzahlen $< 1000$. Verwende dazu die Funktion von der Aufgabe oben. ++++Lösung|


def is_prime(x):
    for i in range(2,x):
        if x % i == 0:
            return False
    return True

sum_primes = 0
for i in range(2,1000):
    if is_prime(i):
        sum_primes += i
print(sum_primes) # = 76127

++++ ==== - Aufgabe ==== Schreibe eine Funktion `list_shift(L,x)`, der eine Liste mit Zahlen `L` und eine Zahl `x` übergeben wird. Die Funktion addiert zu jedem Wert in der Liste die Zahl `x`. Diese modifizierte Liste wird dann zurückgegeben. Beispiel: `print(list_shift([1,2,3],5))` gibt zurück: `[6, 7, 8]` ++++Lösung|


def list_shift(L,x):
    for i in range(len(L)):
        L[i] = L[i] + x
    return L

print(list_shift([1,2,3],5))

++++ ==== - Aufgabe ==== **Zeitunterschied:** Schreibe eine Funktion `time_difference(h1,m1,h2,m2)`, die zwei Zeiten $h1:m1$ und $h2:m2$, z.B. $13:46$ und $17:42$ entgegennimmt und berechnet, wie viele Zeit zwischen diesen beiden Zeitpunkten liegt und zurückgibt. ++++Lösung|


def time_difference(h1,m1,h2,m2):
    m = h2*60 + m2 - h1*60 - m1
    h = m // 60
    m_rest = m % 60
    return h,m_rest
    
print(time_difference(6,46,13,28))
print(time_difference(6,46,7,48))

++++ ==== - Aufgabe ==== Schreibe eine Funktion ''generate\_num\_list(low, high, n)'', die eine Liste mit ''n'' Zufallszahlen zwischen ''low'' und ''high'' zurückgibt. Benutze das Modul ''random'' und die Funktion ''random.randint()''. Teste die Funktion. ++++Lösung|


import random
def generate_num_list(low, high, n):
    numbers = []
    for i in range(n):
        numbers.append(random.randint(low, high))
    return numbers

print(generate_num_list(1,99,12))

++++ ==== - Aufgabe ==== Schreibe eine Funktion namens ''maximum(liste)'', die eine Liste von Zahlen als Parameter (Argument) annimmt und das grösste Element in der Liste zurückgibt. Teste die Funktion. ++++Lösung|


def maximum(liste):
    max_wert = liste[0]
    for i in liste:
        if i > max_wert:
            max_wert = i
    return max_wert

l = [31, 69, 10, 92, 74, 75, 6, 33, 32, 94, 7, 3]

print(maximum(l))

++++ ==== - Aufgabe ==== Schreibe eine Funktion namens ''quadratzahlen(liste)'', die eine Liste von Zahlen annimmt und eine neue Liste zurückgibt, in der alle Zahlen quadriert sind. Teste die Funktion. ++++Lösung|


def quadratzahlen(liste):
	quadratliste = []
	for i in liste:
		quadratliste.append(i*i)
	return quadratliste 

print(quadratzahlen([4,5,11,20]))

++++ ==== - Aufgabe ==== Schreibe eine Funktion namens ''gerade_zahlen(liste)'', die eine Liste von Zahlen annimmt und eine neue Liste zurückgibt, die nur die geraden Zahlen aus der ursprünglichen Liste enthält. Teste die Funktion. ++++Lösung|


def gerade_zahle(liste):
	liste_gerade = []
	for i in liste:
		if i % 2 == 0:
			liste_gerade.append(i)
	return liste_gerade

l = [31, 69, 10, 92, 74, 75, 6, 33, 32, 94, 7, 3]

print(gerade_zahle(l))

++++ ==== - Aufgabe ==== Schreibe eine Funktion namens ''fakultaet(n)'', die eine Zahl als Parameter annimmt und die Fakultät dieser Zahl berechnet. Die Fakultät einer Zahl n wird definiert als das Produkt aller positiven ganzen Zahlen von 1 bis n. ++++Lösung|


def fakultaet(n):
	produkt = 1
	for i in range(2,n+1):
		produkt = produkt * i
	return produkt

print(fakultaet(5))

++++ ==== - Aufgabe ==== - Schreibe eine Funktion namens ''lineare_suche(li, el)'', die eine Liste und das gesuchte Element als Parameter annimmt. Die Funktion soll den Index des gesuchten Elements in der Liste zurückgeben, falls er vorhanden ist, oder ''None'', wenn das Element nicht gefunden wird. - Kopiere untenstehende Listen in deinen Code. - Schreibe Code, mit dem Du einen Namen festlegen kannst und der dann dass passende Alter ermittelt. Der Code soll eine der folgenden beiden Nachrichten ausgeben: - "Das Alter von ... ist ..." oder - "Der Name ... wurde nicht gefunden"


namen = ["Max", "Anna", "Karl", "Lisa"]
alter = [25, 30, 27, 22]

++++Lösung|


def lineare_suche(li, el):
    for index in range(len(li)):
        if li[index] == el:
            return index
    return None

namen = ["Max", "Anna", "Karl", "Lisa"]
alter = [25, 30, 27, 22]

name = "Karl"
index = lineare_suche(namen, name)
if index is None:
    print("Der Name {} wurde nicht gefunden.".format(name))
else:
    print("Das Alter von {} beträgt {} Jahre.".format(name, alter[index]))

++++ ==== - Aufgabe ==== - Schreibe eine Funktion namens ''binaere\_suche(li, el)'', die eine sortierte Liste und das gesuchte Element als Parameter annimmt. Die Funktion soll //im Modus der binären Suche// das gesuchte Element in der Liste finden und den Index dieses Elements zurückgben. Falls das gesuchte Element nicht gefunden wird, soll die Funktion ''None'' zurückgeben. - Kopiere untenstehende Listen in deinen Code. - Schreibe Code, mit dem du einen Zahl festlegen kannst und der dann die passende Beschreibung ermittelt. Der Code soll eine der folgenden beiden Nachrichten ausgeben: - "Die Zahl ... schreibt man so: ...." oder - "Die Zahl ... wurde nicht gefunden."


nummern = [1, 5, 10, 15, 20, 25, 30, 35]
beschreibungen = ["Eins", "Fünf", "Zehn", "Fünfzehn", "Zwanzig", "Fünfundzwanzig", "Dreissig", "Fünfunddreissig"]

++++Lösung|


def binary_search(li,el):
    left = 0
    right = len(li)-1
    while left <= right:
        middle = (left + right) //2
        if li[middle] == el:
            return middle
        elif li[middle] < el:
            left = middle + 1
        else:
            right = middle - 1
    return None

nummern = [1, 5, 10, 15, 20, 25, 30, 35]
beschreibungen = ["Eins", "Fünf", "Zehn", "Fünfzehn", "Zwanzig", "Fünfundzwanzig", "Dreissig", "Fünfunddreissig"]

meine_nummer = 25
mein_index = binary_search(nummern, meine_nummer)
if mein_index is None:
    print("Die Zahl {} wurde nicht gefunden.".format(meine_nummer))
else:
    print("Die Zahl {} schreibt man so: {}.".format(meine_nummer, beschreibungen[mein_index]))

++++ ==== - Aufgabe ==== - Schreibe eine Funktion namens ''find\_min(li)'', die eine Liste als Parameter annimmt, darin das kleinste Element findet und **den Index** dieses Elements zurückgibt. - Kopiere die Liste unten in deinen Code. - Teste deine Funktion: Schreibe Code, der den Index des kleinsten Elements der Liste ausgibt, nämlich: 8.


gemuese = ["Tomate", "Karotte", "Brokkoli", "Zucchini", "Paprika", "Gurke", "Kartoffel", "Spinat", "Aubergine", "Spargel", "Blumenkohl", "Rote Bete"]

++++Lösung|


def find_min(li):
	min_index = 0
	for j in range(len(li)):
		if li[j] < li[min_index]:
			min_index = j
	return min_index

gemuese = ["Tomate", "Karotte", "Brokkoli", "Zucchini", "Paprika", "Gurke", "Kartoffel", "Spinat", "Aubergine", "Spargel", "Blumenkohl", "Rote Bete"]

print(find_min(gemuese))

++++ ==== - Aufgabe ==== - Schreibe eine Funktion namens ''pop\_min(li)'', die eine Liste als Parameter annimmt, daraus das kleinste Element entfernt und dieses zurückgibt. - Kopiere die Liste unten in deinen Code. - Teste deine Funktion: Schreibe Code, der das kleinste Element der Liste ausgibt und anschliessend die verkürzte Liste ausgibt.


obstsorten = ["Apfel", "Banane", "Kirsche", "Orange", "Mango", "Pfirsich", "Erdbeere", "Birne", "Himbeere", "Kiwi", "Ananas", "Blaubeere"]

++++Lösung|


def find_min(li):
	min_index = 0
	for j in range(len(li)):
		if li[j] < li[min_index]:
			min_index = j
	return min_index

def pop_min(li):
	min_index = find_min(li)
	return li.pop(min_index)

obstsorten = ["Apfel", "Banane", "Kirsche", "Orange", "Mango", "Pfirsich", "Erdbeere", "Birne", "Himbeere", "Kiwi", "Ananas", "Blaubeere"]
print(pop_min(obstsorten))
print(obstsorten)

++++ ==== - Aufgabe ==== - Schreibe eine Funktion namens ''sortiere(li)'', die eine unsortierte Liste als Parameter annimmt und diese sortiert zurückgibt. - Kopiere die unsortierte Liste unten in deinen Code. - Schreibe Code, der erst die unsortierte, dann die sortierte Liste ausgibt.


laender = ["Deutschland", "Frankreich", "Italien", "Spanien", "Kanada", "Australien", "Japan", "Brasilien", "Indien", "Mexiko", "Südafrika", "Russland"]

++++Lösung|


def find_min(li):
	min_index = 0
	for j in range(len(li)):
		if li[j] < li[min_index]:
			min_index = j
	return min_index

def pop_min(li):
	min_index = find_min(li)
	return li.pop(min_index)

def sortiere(li):
	sortierte_liste = []
	while len(li) > 0:
		kleinstes_element = pop_min(li)
		sortierte_liste.append(kleinstes_element)
	return sortierte_liste

laender = ["Deutschland", "Frankreich", "Italien", "Spanien", "Kanada", "Australien", "Japan", "Brasilien", "Indien", "Mexiko", "Südafrika", "Russland"]

print(laender)
print(sortiere(laender))

++++ ==== - Aufgabe ==== Schreibe eine Funktion namens ''get\_shortest(li)'', die eine Liste mit Wörtern als Parameter annimmt, darin das kürzeste Wort findet und zurückgibt. Für die Liste ''vornamen = ["Annamaria", "Liam", "Marcel", "Leonardo", "Mia", "Susanna"]'' zum Beispiel soll die Funktion das Element "Mia" zurückgeben. ++++Lösung|


def find_shortest(li):
	shortest = li[0]
	for i in li:
		if len(i) < len(shortest):
			shortest = i
	return shortest

vornamen = ["Annamaria", "Liam", "Marcel", "Leonardo", "Mia", "Susanna"]

print(find_shortest(vornamen))

++++ ==== - Aufgabe ==== Schreibe eine Funktion namens ''remove\_duplicates(li)'', die alle Duplikate aus einer Liste entfernt. Die Funktion nimmt die Liste ''li'' an und gibt eine Liste zurück, in der jeder Eintrag nur einmal enthalten ist. Beispiel: Für die Liste ''farben = ['gelb', 'rot', 'gelb', 'grün', 'blau', 'rot', 'rot', 'rot', 'braun', 'orange', 'orange', 'orange']'' soll die Funktion die Liste ''['gelb', 'rot', 'grün', 'blau', 'braun', 'orange']'' zurückgeben. ++++Hinweis| Code zum Überprüfen, ob ein Element `el` (nicht) bereits in einer Liste `li` vorkommt:


if el in li:
    # Code der ausgefuehrt wird, wenn el bereits in li vorkommt
    
if not el in li:
    # Code der ausgefuehrt wird, wenn el NICHT bereits in li vorkommt

++++ ++++Lösung|


def remove_duplicates(li):
	new_list = []
	for i in li:
		if not i in new_list:
			new_list.append(i)
	return new_list

farben = ["gelb", "rot", "gelb", "grün", "blau", "rot", "rot", "rot", "braun", "orange", "orange", "orange"]

print(remove_duplicates(farben))

++++ ==== - Aufgabe ==== Schreibe eine Funktion namens ''boese\_sieben(li)'', die eine Liste mit Zahlen annimmt, darin alle durch sieben teilbaren Elemente durch das Wort "böse" ersetzt und die Liste zurückgibt. Beispiel: Für die Liste ''zahlen = [5, 9, 14, 17, 19, 21, 41, 42, 46, 49]'' soll die Funktion die Liste ''[5, 9, 'böse', 17, 19, 'böse', 41, 'böse', 46, 'böse']'' zurückgeben. ++++Lösung|


def boese_sieben(li):
	results = []
	for i in li:
		if i % 7 == 0:
			results.append('böse')
		else:
			results.append(i)
	return results

zahlen = [5, 9, 14, 17, 19, 21, 41, 42, 46, 49]
print(boese_sieben(zahlen))

++++ ==== - Aufgabe ==== Erweitere die Funktion aus der vorherigen Aufgabe, sodass auch alle Zahlen, in denen eine 7 drin vorkommt, als "böse" erkannt werden. Also zum Beispiel auch 17, 27 und alle Zahlen von 70 bis 79. Die Funktion soll für Zahlen zwischen 1 und 99 funktionieren. Für die Liste ''[5, 9, 14, 17, 19, 21, 26, 27, 28, 46, 49, 70, 73, 80]'' soll die Liste ''[5, 9, 'böse', 'böse', 19, 'böse', 26, 'böse', 'böse', 46, 'böse', 'böse', 'böse', 80]'' zurückgegeben werden. ++++Lösung|


def boese_sieben(li):
	results = []
	for i in li:
		if i % 7 == 0 or i % 10 == 7 or i > 70 and i < 80:
			results.append('böse')
		else:
			results.append(i)
	return results

zahlen = [5, 9, 14, 17, 19, 21, 26, 27, 28, 46, 49, 70, 73, 80]
print(boese_sieben(zahlen))

++++ ===== - Erweiterte Anforderungen ===== ==== - Aufgabe ==== Schreibe eine Funktion `anzahl_ziffern(x)`, welche für eine positive ganze Zahl die Anzahl Ziffern berechnet und zurück gibt. Für die Zahl 412543 soll also 6 zurückgegeben werden. Die Verwendung von `len` oder ähnlichen, vordefinierten Funktionen ist nicht erlaubt. ++++Lösung|

++++ ==== - Aufgabe ==== Schreibe eine Funktion `quersumme(x)`, welche die Quersumme einer positiven ganzen Zahl x berechnet und zurück gibt. Die Quersumme von 142 ist 1+4+2=7. //Tipp:// Mit `str(x)` kannst du eine Zahl `x` in einen String umwandeln. Strings haben viele Ähnlichkeiten mit Listen: sie bestehen aus mehreren Buchstaben, genau so wie eine Zahlenliste aus mehreren Zahlen besteht. ++++Lösung|

++++ ==== - Aufgabe ==== Ein Resultat aus der Mathematik besagt, dass der Wert der Reihe $$\frac1{2} + \frac1{4} + \frac1{8} + \frac1{16} + \frac1{32} + \frac1{64} + \frac1{128} + ...$$ nie den Wert 1 überschreitet, selbst wenn man unendlich viele weitere passende Summanden hinzuaddiert. Je mehr Werte man aufsummiert, desto näher gelangt man an den Wert 1. Vergewissere dich, dass dies stimmt, indem du in einer Schleife den Wert dieser Reihe für sehr viele Summanden berechnest. ++++Lösung|


n = 42
summe = 0

for i in range(1,n+1):
    summe += 1/2**i

error = summe - 1    

print(summe,error)

++++ ==== - Aufgabe ==== Löse [[gf_informatik:programmieren_zusatzaufgaben|Zusatzaufgaben]] * Lotto ++++Lösung|


import random

# a)
def lotto():
    lotto_zahlen = []
    for i in range(6):
        lotto_zahlen.append(random.randint(1,42))
    zusatz_zahl = random.randint(1,6)
    return sorted(lotto_zahlen),zusatz_zahl

# b) ohne Zahlenwiederhohlung
def lotto_ohne_wiederhohlung():
    zahlen_alle = [i for i in range(1,42+1)]
    lotto_zahlen = []
    for i in range(6):
        z = random.choice(zahlen_alle)
        zahlen_alle.remove(z)
        lotto_zahlen.append(z)
    zusatz_zahl = random.randint(1,6)
    return sorted(lotto_zahlen),zusatz_zahl

print(lotto())
print(lotto_ohne_wiederhohlung())

++++ **ab hier: neue Aufgaben März/April 2022** ==== - Aufgabe ==== **Ziel:** Das Spiel **Schere-Stein-Papier** programmieren. Die Benutzerin spielt das Spiel gegen den Computer. Wer zuerst 5 Punkte erreicht hat, hat gewonnen. Das Spiel kann gerne auch auf Englisch (**Rock Paper Scissors**) programmiert werden. Ablauf Spiel: - Benutzerin wirst aufgefordert, Schere (1), Stein (2) oder Papier (3) auszuwählen. - Computer macht Zug, wählt also random Schere, Stein oder Papier aus. - Es wird überprüft, ob Benutzerin oder Computer die Runde gewonnen hat. - Entsprechende Ausgabe (wer hat Runde gewonnen) und aktuellen Spielstand wird ausgegeben. - Spiel wird so lange wiederholt, bis Benutzerin oder Computer 5 Punkte erreicht hat. - Ergebnis und Siegerin wird ausgegeben. ++++Lösung|


import random

POINTS_WIN = 5
OBJECTS = ["Rock","Paper","Scissors"]
rounds = 1
points_player = 0
points_computer = 0

while points_player < POINTS_WIN and points_computer < POINTS_WIN:
    while True:
        pl = input("Select: Rock (1), Paper (2) or Scissors (3)")
        if pl == 1 or pl == 2 or pl == 3:
            break
    pl = int(pl) - 1
    comp = random.randint(0,2)
    print("Round {0}:".format(rounds))
    print("Player chose:   {0}".format(OBJECTS[pl]))
    print("Computer chose: {0}".format(OBJECTS[comp]))
    
    result = [pl,comp]
    if result == [0,0] or result == [1,1] or result == [2,2]:
        print("Round undecided")
    elif result == [0,2] or result == [1,0] or result == [2,1]:
        points_player += 1
        print("Winner round: PLAYER")
    else:
        points_computer += 1
        print("Winner round: COMPUTER")
    print("Points: player ({0}), computer ({1})".format(points_player,points_computer))
    rounds += 1

if points_player >= POINTS_WIN:
    print("PLAYER WINS GAME!")
else:
    print("COMPUTER WINS GAME!")

++++ ==== - Aufgabe ==== Mit `s.capitalize()` wird der String `s` so umgewandelt, dass der erste Buchstabe gross und die restlichen Buchstaben klein geschrieben werden. Programmiere diese Funktion selbst: Schreibe dazu eine eigene Funktion `capitalize(s)`, die einen String `s` 'capizalizes'. Der umgewandelte String wird zurückgegeben. Tipp: Verwende die vordefinierten Funktionen `upper` und `lower`, diese Wandeln alle Buchstaben in Gross-/Kleinbuchstaben um. Beispiele: * `capitalize("FRITZ")` ergibt `"Fritz"` * `capitalize("monika")` ergibt `"Monika"` * `capitalize("kAmEl")` ergibt `"Kamel"` * `capitalize("Korrekt")` ergibt `"Korrekt"` ++++Lösung|


def capitalize(word):
    word_cap = upper(word[0])
    for i in range(1,len(word)):
        word_cap += lower(word[i])
    return word_cap
    
def capitalize2(word):
    return upper(word[0]) + lower(word[1:len(word)-1])

++++ ==== - Aufgabe ==== **Random-Word-Generator** Schreibe eine Funktion, welche ein **Zufallsword generiert** und zurückgibt (wende darauf deine `capitalize` Funktion von oben an). Die Länge des Wortes kann vorgegeben werden oder per Zufall festgelegt werden. Das Word soll abwechslungsweise aus Vokalen und Konsonanten bestehen. Ob es mit einem Vokal oder Konsonanten beginnt, soll per Zufall bestimmt werden. Rufe die Funktion mehrfach aus und teile deiner Lehrperson das coolste Wort mit, welches dein Code erzeugt hat. Was (oder wen) würdest du so benennen? Du kannst die folgenden zwei Listen mit Konsonanten und Vokalen verwenden:


consonants = ["B","C","D","F","G","H","J","K","L","M","N","P","Q","R","S","T","V","W","X","Z"]
vowels = ["A","E","I","O","U"] #"Ä","Ö","Ü","Y"

++++Lösung|


import random
consonants = ["B","C","D","F","G","H","J","K","L","M","N","P","Q","R","S","T","V","W","X","Z"]
vowels = ["A","E","I","O","U"] #"Ä","Ö","Ü","Y"

def capitalize(word):
    word_cap = upper(word[0])
    for i in range(1,len(word)):
        word_cap += lower(word[i])
    return word_cap

def random_word_generate():
    N = random.randint(3,10)
    word = ""
    next_is_vowel = random.choice([True,False])
    
    for i in range(N):
        if next_is_vowel:
            word += random.choice(vowels)
        else:
            word += random.choice(consonants)
        next_is_vowel = not next_is_vowel
    return capitalize(word)

for i in range(10):
    print(random_word_generate())

++++