/home/bakera/wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== Programmierübungen ======

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.

===== Übungen zu Schleifen =====

→ [[Programmierübungen Schleifen]]


===== Mini-Projekte =====

Die folgenden kleineren Projekte können in kurzer Zeit umgesetzt werden und
zeigen unterschiedliche interessante Aspekte der Programmierung.

  * [[BMI-Rechner]]
  * [[Notenrechner]]
  * [[Zahlenraten]]
  * [[IBAN]]
  * [[FizzBuzz Katas]]
  
===== Übungen zu Klassen und Objekten =====

→ [[Programmierübungen Klassen]]

===== Übungen zu Fehlern und Exceptions =====

→ [[Programmierübungen Fehler]]

===== Schlechter Stil =====

Welche stilistischen Probleme erkennst du bei der folgenden Funktion? Nenne möglichst viele
Probleme.

<code python>
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]
</code>

<html><!--
1. Name handleStuff nicht aussagekräftig.
2. Keine Kommentare
3. Schlechtes Layout: Einrückung bei expenseType==3
4. Eingabe-Parameter werden verändert (inputRec)
5. Globale Variablen werden gelesen und geschrieben (corpExpense, profit)
6. Es werden mehrere Aufgaben erledigt: Initialisierungen, DB-Zugriff, Berechnungen, 
7. Keine Prüfung "schmutziger" Eingaben: crnQtr=0
8. Verschiedene "magic numbers" werden genutzt: 100, 4.0, 12, 2, 3
9  Nicht alle Parameter werden genutzt: screenX, screenY
10, Zu viele Parameter
11. Parameter schlecht geordnet, nicht selbsterklärend
12. unnötiges Semikolon
--></html>
 
===== Testgetriebene Entwicklung (TDD) =====

→ [[Testgetriebene Entwicklung (Übung)]]


===== Unterschiedliche Laufzeiten =====

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.

^ n ^ Methode ^ Laufzeit in Sekunden ^
| 10 | linear      | 10   |
|    | quadratic   | 100  |
|    | cubic       | 1000 |
|    | exponential | 1024 |
|    |             |      |
| 20 | linear      | 20   |
|    | quadratic   | 400  |
|    | cubic       | 8000 |
|    | exponential | 1048576 |
|    |             |      |
| 50 | linear      | 50   |
|    | quadratic   | 2500  |
|    | cubic       | 125000 |
|    | exponential | 1125899906842624 |


<html><!--

# https://gist.github.com/pintman/95def0e4a41fcd37b8e4c9413a7d4226

import time

WAIT_TIME = 0.001  # seconds
MAX = 10


def do_something_time_comsuming():
    time.sleep(WAIT_TIME)

def linear(n):
    for i in range(n):
        do_something_time_comsuming()

def quadratic(n):
    for _i in range(n*n):
        do_something_time_comsuming()

def cubic(n):
    for _i in range(n**3):
        do_something_time_comsuming()

def exponential(n):
    for i in range(3**n):
        do_something_time_comsuming()

        
print("LINEAR")
for i in range(MAX):
    start = time.time()
    linear(i)
    delta = time.time() -start
    print(str(i) + ";" + str(round(delta, 4)))

print("QUADRATIC")
for i in range(MAX):
    start = time.time()
    quadratic(i)
    delta = time.time() -start
    print(str(i) + ";" + str(round(delta, 4)))

print("CUBIC")
for i in range(MAX):
    start = time.time()
    cubic(i)
    delta = time.time() -start
    print(str(i) + ";" + str(round(delta, 4)))

print("EXP")
for i in range(MAX):
    start = time.time()
    exponential(i)
    delta = time.time() -start
    print(str(i) + ";" + str(round(delta, 4)))

'''
Possible output
LINEAR
0;0.0
1;0.0011
2;0.0021
3;0.0032
4;0.0043
5;0.0053
6;0.0064
7;0.0074
8;0.0085
9;0.0096
QUADRATIC
0;0.0
1;0.0011
2;0.0043
3;0.0095
4;0.017
5;0.0266
6;0.0383
7;0.052
8;0.068
9;0.0859
CUBIC
0;0.0
1;0.0011
2;0.0085
3;0.0288
4;0.068
5;0.1347
6;0.2329
7;0.3692
8;0.5433
9;0.7736
EXP
0;0.0011
1;0.0032
2;0.0096
3;0.0287
4;0.086
5;0.2585
6;0.7779
7;2.3645
8;7.0943
9;21.2798
'''


--></html>

===== Tic Tac Toe =====

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

<file python ttt.py>
'''
Auf diese Art kann die Klasse verwendet werden:

>>> ttt = TicTacToe()
>>> ttt.stones
{}
>>> ttt.place_x_at(1,1)
>>> ttt.place_o_at(0,0)
>>> ttt.stones
{(1, 1): 'x', (0, 0): 'o'}
>>> ttt.x_wins()
False
>>> ttt.o_wins()
False
>>> ttt.place_x_at(0,1)
>>> ttt.place_o_at(1,0)
>>> ttt.place_x_at(2,1)
>>> ttt.x_wins()
True
>>> ttt.o_wins()
False
>>> ttt.stones
{(1, 1): 'x', (0, 0): 'o', (0, 1): 'x', (1, 0): 'o', (2, 1): 'x'}
'''

import doctest

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




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

doctest.testmod()  # running tests from class documentation
</file>

<html><!--
'''
Auf diese Art kann die Klasse verwendet werden:

>>> ttt = TicTacToe()
>>> ttt.stones
{}
>>> ttt.place_x_at(1,1)
>>> ttt.place_o_at(0,0)
>>> ttt.stones
{(1, 1): 'x', (0, 0): 'o'}
>>> ttt.x_wins()
False
>>> ttt.o_wins()
False
>>> ttt.place_x_at(0,1)
>>> ttt.place_o_at(1,0)
>>> ttt.place_x_at(2,1)
>>> ttt.x_wins()
True
>>> ttt.o_wins()
False
>>> ttt.stones
{(1, 1): 'x', (0, 0): 'o', (0, 1): 'x', (1, 0): 'o', (2, 1): 'x'}
'''

import doctest

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.'
        return self._xo_wins('x')

    def o_wins(self):
        'Return whether player o has three in a row.'
        return self._xo_wins('o')

    def _xo_wins(self, xo):
        assert xo in "xo"

        # horizontal, vertical and diagonal (down, up)
        directions = [(1, 0), (0, 1), (1, 1), (1, -1)]
        my_stones = []
        for x, y in self.stones:
            if self.stones[x, y] == xo:
                my_stones.append((x, y))

        for x, y in my_stones:
            for dirx, diry in directions:
                counter = 0
                for i in range(-3, 4):
                    x_, y_ = x + i * dirx, y + i * diry
                    if (x_, y_) in my_stones:
                        counter += 1

                if counter == 3:
                    return True

        return False


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

doctest.testmod()  # running tests from class documentation
--></html>


===== Programm, das den eigenen Quelltext ausgibt =====

→ [[Eigenen Quelltext ausgeben]]



===== Katas im Randori-Prinzip =====

> 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: [[https://www.softwerkskammer.org/activities/bo-apr-17|Softwerkskammer]])



===== Links =====

  * Hinter einem [[wpde>Kata (Programmierung)|Kata]] verbirgt sich in der Programmierung eine kleine, abgeschlossene Übung. [[http://codekata.com/|CodeKata]] versammelt eine Reihe interessanter Übungen.
  * [[https://www.practicepython.org/|Practice Python]] enthält verschiedene Übungen für Anfänger.
  * Weitere Übungen zur OOP mit Python gibt es [[https://www.inf-schule.de/modellierung/ooppython/bank/objekteklassen/uebungen|hier]].
  * [[https://projecteuler.net/|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 [[http://rosettacode.org/wiki/Category:Programming_Tasks|RosettaCode]] eine Vielzahl von Programmieraufgaben inklusive Lösungen in vielen verschiedenen Programmiersprachen.
  * [[https://www.codewars.com/|codewars]] enthält verschiedene Übungen für verschiedene Sprachen und einem Forum, um die Lösungen zu diskutieren.
  * [[https://adventofcode.com/|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|Python > Python lernen]]
  * [[Flagserver]]
  * [[https://blog.bakera.de/ein-programm-das-den-eigenen-quelltext-ausgibt.html|Programm, welches den eigenen Quelltext ausgibt]]
  * Bei der [[https://github.com/pintman/python-elevator-challenge|Python Elevator Challenge]] muss ein Aufzug in [[Python]] programmiert werden.