Programmieren Repetitionsdossier

• 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.
  
  

benötigtes Vorwissen:

• Variablen
• while-Schleifen
• if-(elif-)else-Verzweigungen

Bestimme die Summe aller dreistelliger ganzer Zahlen.

Das Resultat muss sein: $494550$

Erzeuge die folgende Figur mit Turtle Graphics. Verwende dazu Schleifen wo möglich.

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.

Erzeuge die folgende Figur mit Turtle Graphics. Verwende dazu Schleifen wo möglich.

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.

Bestimme das Produkt von allen Zahlen von 50 bis und mit 100.

Die Lösung ist 153425937812748301860136522976473486961422986084234447972389349349107947938617753600000000000000.

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.

Erzeuge die folgende Figur mit Turtle Graphics. Verwende dazu Schleifen wo möglich.

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.
   
   
2. Modifiziere nun den Code so, dass der Benutzer solange aufgefordert wird, einen solchen String einzugeben, bis die Bedingung erfüllt ist.

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.

Zeichne ein Pentagramm.

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.

benötigtes Vorwissen:

• Vorwissen von Grundlagen I
• Schleifen
• Funktionen
• Listen

Löse nur, wenn du for-Schleifen kennst.

Wandle in while-Schleife um:

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

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.

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ö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

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

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 +

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.

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

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.

Der Benutzer wird nach einer ganzen Zahl gefragt. Es wird dann eine Liste mit dieser Anzahl an Zufallszahlen gefüllt und ausgegeben.

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?

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.
   
   
2. 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.

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“.

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)))

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“.

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.

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.

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.

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

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

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.

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]))

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.

Weitere Umwandlungsaufgaben:

(zählen alle zusammen als eine Aufgabe für einen Tag)

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)

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

# 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)

Definiere eine Funktion product(L), die eine Liste L mit Zahlen entgegennimmt, deren Produkt bestimmt und zurückgibt.

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

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.

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

Bestimme die Summe aller Primzahlen $< 1000$. Verwende dazu die Funktion von der Aufgabe oben.

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

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]

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))

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.

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))

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.

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))

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.

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))

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.

def quadratzahlen(liste):
	quadratliste = []
	for i in liste:
		quadratliste.append(i*i)
	return quadratliste 
 
print(quadratzahlen([4,5,11,20]))

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.

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))

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.

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

1. 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.
2. Kopiere untenstehende Listen in deinen Code.
3. 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:
   1. „Das Alter von … ist …“ oder
   2. „Der Name … wurde nicht gefunden“

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

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]))

1. 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.
2. Kopiere untenstehende Listen in deinen Code.
3. 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:
   1. „Die Zahl … schreibt man so: ….“ oder
   2. „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"]

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]))

1. 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.
2. Kopiere die Liste unten in deinen Code.
3. 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"]

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))

1. Schreibe eine Funktion namens pop_min(li), die eine Liste als Parameter annimmt, daraus das kleinste Element entfernt und dieses zurückgibt.
2. Kopiere die Liste unten in deinen Code.
3. 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"]

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)

1. Schreibe eine Funktion namens sortiere(li), die eine unsortierte Liste als Parameter annimmt und diese sortiert zurückgibt.
2. Kopiere die unsortierte Liste unten in deinen Code.
3. 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"]

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))

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.

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))

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

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

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))

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.

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))

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.

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))

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.

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.

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.

n = 42
summe = 0
 
for i in range(1,n+1):
    summe += 1/2**i
 
error = summe - 1    
 
print(summe,error)

Löse Zusatzaufgaben

• Lotto

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

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:

1. Benutzerin wirst aufgefordert, Schere (1), Stein (2) oder Papier (3) auszuwählen.
2. Computer macht Zug, wählt also random Schere, Stein oder Papier aus.
3. Es wird überprüft, ob Benutzerin oder Computer die Runde gewonnen hat.
4. Entsprechende Ausgabe (wer hat Runde gewonnen) und aktuellen Spielstand wird ausgegeben.
5. Spiel wird so lange wiederholt, bis Benutzerin oder Computer 5 Punkte erreicht hat.
6. Ergebnis und Siegerin wird ausgegeben.

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!")

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"

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])

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"

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())