Programmieren lernt man am besten durch Programmieren. Nicht durch das Zugucken, auch nicht durch das Lesen von Büchern und Webseiten, und auch nicht durch das Schauen von Videos.

→ Programmierübungen Schleifen

• BMI-Rechner
• Notenrechner
• Zahlenraten
• IBAN

→ Programmierübungen Klassen

→ Programmierübungen Fehler

Welche stilistischen Probleme erkennst du bei der folgenden Funktion?

def handleStuff(inputRec, crnQtr, empRec, estimRevenue, ytdRevenue, screenx, screeny, newColor, prevColor, status, expenseType):
	for i in range(100):
		inputRec[i] = 0
		inputRec[i] = corpExpense[ crnQtr ][ i];
 
	UpdateCorpDatabase(empRec)
	estimRevenue = ytdRevenue * 4.0 / double(crnQtr)
	newColor = prevColor
	status = SUCCESS
	if expenseType == 1:
		for i in range(12):
			profit[i] = revenue[i] - expense.type2[i]
	elif expenseType == 2:
		profit[i] = revenue[i] - expense.type2[i]
	elif expenseType == 3:
			profit[i] = revenue[i] - expense.type3[i]

Erstelle die Funktionen, linear(n), quadratic(n), cubic(n), exponential(n), die in Abhängigkeit von n eine lineare, quadratische, kubische oder exponentielle Laufzeit haben.

Das bedeutet: wenn linear(10) eine Laufzeit von 10 Sekunden hat, dann hat quadratic(10) eine Laufzeit von 10*10=100 Sekunden, cubic(10) eine Laufzeit von 10*10*10=1000 Sekunden und exponential(10) eine Laufzeit von 2^10 = 1024 Sekunden.

Ergänze eine Gewinnüberprüfung für das Spiel TicTacToe in der folgenden Klasse. Programmiere dafür die Methoden `x_wins` und `o_wins`.

ttt.py

class TicTacToe:
    'A game of tic tac toe.'
 
    def __init__(self):
        # mapping (x,y) to 'x' or 'o'
        self.stones = {}
 
    def place_x_at(self, x, y):
        assert 0 <= x <= 2 and 0 <= y <= 2
        self.stones[(x, y)] = "x"
 
    def place_o_at(self, x, y):
        assert 0 <= x <= 2 and 0 <= y <= 2
        self.stones[(x, y)] = "o"
 
    def x_wins(self):
        'Return whether player x has three in a row.'
 
    def o_wins(self):
        'Return whether player o has three in a row.'
 
 
# Tests
 
ttt = TicTacToe()
'''
o.x
xxo
x.o
'''
for x, y in [(2, 0), (1, 0), (1, 1), (0, 2)]:
    ttt.place_x_at(x, y)
for x, y in [(0, 0), (2, 1), (2, 2)]:
    ttt.place_o_at(x, y)
assert len(ttt.stones) == 7
assert ttt.x_wins()
assert not ttt.o_wins()

Schreibe ein Programm, das den eigenen Quelltext ausgibt. Dabei darf nicht auf Dateioperationen zurückgegriffen werden. Sonst wäre es zu einfach. Dann könnte man einfach nur die Datei ausgeben, die den Quelltext enthält.

Das schöne an dieser Aufgabenstellung ist, dass sie zunächst sehr einfach und nach ein paar Versuchen faktisch unmöglich erscheint.

Versuche dich selbst an einem Python-Programm, das den eigenen Quelltext ausgibt.

Wenn du keinen Ansatz findest, kann du den (unvollständigen) Quelltext aus der Fußnote¹⁾ nutzen.

Bei dem FizzBuzz-Spiel werden die Zahlen von 1 bis 100 durchlaufen. Nun können folgende Fälle eintreten:

1. Wenn die Zahl durch 3 teilbar ist, wird „Fizz“ ausgegeben
2. wenn sie durch 5 teilbar ist, wird „Buzz“ ausgegeben und
3. wenn sie durch 3 und 5 teilbar ist, wird „FizzBuzz“ ausgegeben.
4. Tritt keiner dieser Fälle ein, wird die Zahl ausgegeben.

Ob eine Zahl durch eine andere Zahl teilbar ist, kann mit Hilfe des Modulo-Operators (oder Restwert-Operator) % herausgefunden werden. Er berechnet den Divisionsrest: 10 % 3 ist 1, da 10 geteilt durch 3 genau 3 Rest 1 ergibt.

Die ersten 20 Ausgaben sehen wir folgt aus:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz

Versuche das Problem nun auf unterschiedliche Arten in den folgenden Katas (Übungen) zu lösen:

1. auf Papier
2. mit einer Methode
3. ohne Verwendung einer Schleife (rekursiv)
4. mit Hilfe von nebenläufigen Threads
5. mit einer anderen IDE
6. in einer anderen Programmiersprache
7. als Client-Server Anwendung
8. mit einer grafischen Oberfläche (GUI)
9. Objekt-Orientiert: Klassen und Objekte verwenden
10. objekt-orientiert mit Vererbung
11. funktional mit map, reduce und lambda-Ausdrücken
12. als Webanwendung (mit bottle)
13. in git-repo einchecken
14. als installierbares Programm
15. als getestetes Programm (mit unittest und doctests)
16. mit einem EA-Modul ansteuern
17. mit Anbindung an eine Datenbank
18. mit Dokumentation
19. als Chatbot (z.B. mit sopel https://sopel.chat/)
20. auf einem Cluster (mit GNU parallel)
21. in einem UML-Aktivitätsdiagramm
22. in einem UML-Sequenzdiagramm
23. in einem UML-Klassendiagramm
24. Als IOT-Anwendung mit einem Message-Broker (MQTT)
25. Mit Kommandozeilenparametern
26. Mit einer Konfigurationsdatei
27. Als Web-Service mit REST-API
28. In einer MVC-Architektur
29. Als Spiel (mit pygame)
30. In einem docker Container
31. Mit Fehlerbehandlung
32. Mit einem neuronalen Netzwerk
33. Mit logging in ein logfile
34. Mit einem Profiler
35. Mit einer geplotteten Visualisierung

Mögliche Lösungen für die Katas befinden sich hier oder hier.

Ein Coding Dojo ist eine Form der gezielten kollaborativen Übung für Softwerker, bei der wir voneinander lernen und zusammen eine interessante Programmieraufgabe lösen können.

Es arbeiten immer zwei Leute an einem Computer und programmieren zusammen testgetrieben (TDD) und im Pair (Driver + Navigator). Die Zuschauer können via Beamer das Entwickeln verfolgen und den Programmierenden Anregungen und Tipps geben.
Nach ein paar Minuten (Timebox) rotieren wir weiter (Randori Prinzip):
Einer der Programmierenden kehrt ins Publikum zurück, ein weiterer Zuschauer rückt aus dem Publikum nach. So kann jeder zur Lösung beitragen und von möglichst vielen Leuten lernen.

Welches Code Kata wir wählen, also welcher Problemstellung wir uns an diesem Abend widmen, entscheiden wir gemeinsam in der Gruppe.

(Quelle: Softwerkskammer)

• Practice Python enthält verschiedene Übungen für Anfänger.
• Weitere Übungen zur OOP mit Python gibt es hier.
• Project Euler ist eine Sammlung mathematischer Aufgaben und Programmierübungen für unterschiedliche Programmiersprachen. Es gibt viele Lösungen, die in einem Forum gesammelt werden.
• Wer der englischen Sprache mächtig ist, findet bei RosettaCode eine Vielzahl von Programmieraufgaben inklusive Lösungen in vielen verschiedenen Programmiersprachen.
• codewars enthält verschiedene Übungen für verschiedene Sprachen und einem Forum, um die Lösungen zu diskutieren.
• Advent Of Code stellt jedes Jahr im Dezember im Stile eines Adventskalenders an jedem Tag ein neues Programmierproblem vor, das mit einer beliebigen Programmiersprache gelöst werden kann. Die Aufgabenschwierigkeit reicht von leicht bis knackig.
• Python > Python lernen
• Flagserver
• Programm, welches den eigenen Quelltext ausgibt