06-Loesung.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Schere, Stein, Papier - Multiplayer\n",
    "### - Lösung - "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add-On: Mehr als zwei Spieler\n",
    "\n",
    "Wir wollen an den ersten Teil der Aufgabe anknüpfen und uns überlegen wie bei \"Schere-Stein-Papier\" mehr als zwei Spieler gegeneinander antreten können. Für diese Aufgabe verwenden wir wieder die klassische Version des Spiels mit drei Handzeichen.\n",
    "\n",
    "Um das Spiel mit mehr als zwei Spielern zu spielen, gibt es mehrere Möglichkeiten.\n",
    "Wenn die Anzahl der Spieler eine Zweierpotenz ist, dann kann man ein K.-o.-System verwenden, wie es z. B. ab dem Achtelfinale bei großen Fußballturnieren auch verwendet wird. Dabei treten immer nur zwei Spieler gegeneinander an und die Gewinnerin oder der Gewinner jeder Stufe kommen je eine Runde weiter, bis nach dem Finale das Ergebnis feststeht.\n",
    "Im ersten Teil der Aufgabe wollen wir so ein K.o.-System programmieren und für eine bestimmte Anzahl an Spielern einen Tunierplan erstellen.\n",
    "\n",
    "Da es bei so vielen Codeblöcken schnell unübersichtlich werden kann, haben wir eine Checkliste erstellt, was ihr für den ersten Teil implementieren müsst:\n",
    "* Funktion, die testet ob die eingegebene Zahl eine Zweierpotenz ist.\n",
    "* Funktion, die eine Liste mit Spielern in zufällige Paare unterteilt\n",
    "* die Funktion tunierplan_erstellen() vervollständigen, sodass die Spieler in Runden solange gegeneinander spielen,\n",
    "  bis alle außer ein Spieler ausgeschieden sind, welcher das Spiel gewinnt\n",
    "\n",
    "\n",
    "Auf dieser Seite könnt ihr Informationen zu (Zweier)Potenzen finden:\n",
    "\n",
    "https://www.mathematik.de/algebra/177-erste-hilfe/zahlenbereiche/nat%C3%BCrliche-zahlen/2307-potenzen (abgerufen am 01.05.2020)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Die folgenden Pakete könnten nützlich für die Aufgaben sein\n",
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der folgende Codeblock ist größtenteils von letzter Woche übernommen und definiert die Handzeichen, Regeln und zwei Funktionen um ein zufälliges Handzeichen auszuwählen und um zu ermitteln welcher von zwei Spielern eine Runde gewinnt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Python 3 kann mit utf-8 Zeichen umgehen, und auch mit Emojis!\n",
    "schere = \"💇 Schere\"\n",
    "stein = \"🗿 Stein\"\n",
    "papier = \"📝 Papier\"\n",
    "\n",
    "# ein dictionary mit den Regeln, d.h. Schere schlägt Papier, Stein schlägt Schere und Papier schlägt Stein\n",
    "regeln = {\n",
    "    schere : papier,\n",
    "    stein : schere,\n",
    "    papier : stein}\n",
    "\n",
    "# Eine Hilfsfunktion, welche zufällig eines der drei möglichen Handzeichen zurückgibt\n",
    "def zufaelliges_handzeichen():\n",
    "    alle_zeichen = [schere, stein, papier]\n",
    "    return np.random.choice(alle_zeichen)\n",
    "\n",
    "# Wer hat gewonnen? Oder war es ein Unentschieden?\n",
    "def spiele(handzeichen_1, handzeichen_2):\n",
    "    if regeln[handzeichen_1] == handzeichen_2:\n",
    "        return 0 # Spieler 1 gewinnt\n",
    "    elif regeln[handzeichen_2] == handzeichen_1:\n",
    "        return 1 # Spieler 2 gewinnt\n",
    "    else:\n",
    "        return None # Unentschieden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# fordert den User auf eine Spieleranzahl einzugeben und testet, ob eine ganze Zahl eingegeben wurde\n",
    "def eingabe():\n",
    "    while True:\n",
    "        try:\n",
    "            # input() nimmt Eingaben über die Tastatur auf\n",
    "            anzahl = input(\"Bitte die Anzahl der Spieler eingeben: \")\n",
    "            anzahl = int(anzahl)\n",
    "            return anzahl\n",
    "        # Falls keine ganze Zahl eingegeben wurde, Eingabe wiederholen\n",
    "        except ValueError:\n",
    "            print(\"Bitte eine Zahl eingeben.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# testet ob die eingegebene Spieleranzahl mindestens 2 ist und zudem eine Zweierpotenz ist (also 2,4,8 usw.)\n",
    "def zweierpotenz_test(anzahl):\n",
    "    \"\"\"Funktion, die testet ob die eingegebene Spieleranzahl mindestens 2 ist und zudem eine Zweierpotenz ist\n",
    "\n",
    "    Parameters:\n",
    "    anzahl (int): Spieleranzahl\n",
    "\n",
    "    Returns:\n",
    "    bool: True wenn obige Bedingungen erfüllt sind, ansonsten False\n",
    "\n",
    "   \"\"\"  \n",
    "    if (anzahl >= 2) and (anzahl & (anzahl-1) == 0): # alternativ: math.log2(anzahl).is_integer()\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "# teste deine Funktion\n",
    "# Wenn du einen AssertionError bekommst, dann funktioniert deine Funktion noch nicht richtig\n",
    "assert zweierpotenz_test(8) == True\n",
    "assert zweierpotenz_test(18) == False\n",
    "assert zweierpotenz_test(1) == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Spieler_1 ', 'Spieler_6 '], ['Spieler_5 ', 'Spieler_8 '], ['Spieler_3 ', 'Spieler_4 '], ['Spieler_7 ', 'Spieler_2 ']]\n"
     ]
    }
   ],
   "source": [
    "# Funktion, die eine Liste mit Spielern in zufällige Paare unterteilt\n",
    "# Hier ist es wichtig, dass jeder Spieler nur einmal eingeteilt wird und niemand übrig bleibt\n",
    "def zufaellige_paare(spieler_liste):\n",
    "    \"\"\"Funktion, die eine Liste mit Spielern in zufällige Paare unterteilt\n",
    "\n",
    "    Parameters:\n",
    "    spieler_liste (list): Liste mit den Spielern\n",
    "\n",
    "    Returns:\n",
    "    list: Liste mit den Spielerpaaren (z.B. [[\"Spieler_1\",\"Spieler_3\"],[\"Spieler_4\",\"Spieler_2]])\n",
    "\n",
    "   \"\"\"\n",
    "    \n",
    "    paar_liste = []\n",
    "    \n",
    "    for i in range(len(spieler_liste)//2):\n",
    "        paar = list(np.random.choice(spieler_liste,size=2,replace=False))\n",
    "        paar_liste.append(paar)\n",
    "        spieler_liste.remove(paar[0])\n",
    "        spieler_liste.remove(paar[1])\n",
    "        \n",
    "    return paar_liste\n",
    "\n",
    "# teste deine Funktion\n",
    "spieler = ['Spieler_1 ','Spieler_2 ','Spieler_3 ','Spieler_4 ','Spieler_5 ','Spieler_6 ','Spieler_7 ','Spieler_8 ']\n",
    "print(zufaellige_paare(spieler))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vervollständige die Funktion tunierplan_erstellen(), sodass so viele Runden gespielt werden bis ein endgültiger Gewinner ermittelt ist. Um eine Runde zu spielen, verwende die schon definierte Funktion spiele_runde().\n",
    "\n",
    "\n",
    "Um den Output schöner zu gestalten, gib in jeder Runde die aktuelle Rundennummer aus.\n",
    "Verwende dazu die auskommentierten print-Befehle und kopiere sie an die richtige Stelle in deinem Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#print('\\n')\n",
    "#print('Runde '+str(runde))\n",
    "#print('========')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tipps: es gibt mehrere Möglichkeiten diesen Teil der Aufgabe zu lösen, du kannst z.B.:\n",
    "\n",
    "* eine for-Schleife verwenden und vorher ermitteln wie viele Runden benötigt werden für die gegebene Anzahl an Spielern\n",
    "\n",
    "* eine while-Schleife verwenden, und als Bedingungen setzen, dass es noch mindestens zwei Spieler gibt\n",
    "\n",
    "* die Aufgabe rekursiv lösen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def spiele_runde(spieler_liste):\n",
    "    \"\"\"Eine Spielrunde läuft wie folgt ab: \n",
    "       - die Spieler werden zufällig in Paare unterteilt\n",
    "       - alle Paare spielen gegeneinander\n",
    "       - die Sieger aller Spieler werden als Rundensieger zurückgegeben\n",
    "\n",
    "    Parameters:\n",
    "    spieler_liste (list): Liste mit den Spielern für diese Runde\n",
    "\n",
    "    Returns:\n",
    "    list: Liste mit den Gewinnern der Spiele (Rundengewinner)\n",
    "\n",
    "   \"\"\"\n",
    "    \n",
    "    # teilt Spieler in zufällige Paare ein\n",
    "    paar_liste = zufaellige_paare(spieler_liste)\n",
    "    \n",
    "    gewinner_liste = []\n",
    "    \n",
    "    # jedes Paar spielt Schere-Stein-Papier gegeneinander, bis einer der beiden gewinnt\n",
    "    for paar in paar_liste:\n",
    "        gewinner = None\n",
    "        \n",
    "        while gewinner == None:\n",
    "            handzeichen_spieler1 = zufaelliges_handzeichen()\n",
    "            handzeichen_spieler2 = zufaelliges_handzeichen()\n",
    "\n",
    "            gewinner = spiele(handzeichen_spieler1,handzeichen_spieler2)\n",
    "            \n",
    "        gewinner_liste.append(paar[gewinner])\n",
    "        \n",
    "        print('{} vs. {}: {} gewinnt die Runde!'.format(paar[0],paar[1],paar[gewinner]))\n",
    "    \n",
    "    # die Liste aller Rundengewinner wird zurückgegeben\n",
    "    return gewinner_liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def tunierplan_erstellen():\n",
    "    \n",
    "    anzahl_spieler = eingabe()\n",
    "\n",
    "    # testet ob die eingegebene Spieleranzahl eine Zweierpotenz ist (also 2,4,8 usw.)\n",
    "    while zweierpotenz_test(anzahl_spieler) == False:\n",
    "        print(\"Die eingegebene Spieleranzahl ist leider keine Zweierpotenz (oder ist <2).\")\n",
    "        anzahl_spieler = eingabe()\n",
    "    \n",
    "    # erstellt eine Liste mit allen Spielern\n",
    "    spieler_liste = []\n",
    "    for spieler in range(1,anzahl_spieler+1):\n",
    "        spieler_liste.append('Spieler_{:^2}'.format(spieler))\n",
    "    \n",
    "    anzahl_runden = int(math.log2(anzahl_spieler))\n",
    "\n",
    "    for runde in range(1,anzahl_runden+1):\n",
    "        print('\\n')\n",
    "        print('Runde '+str(runde))\n",
    "        print('========')\n",
    "        spieler_liste = spiele_runde(spieler_liste)\n",
    "        \n",
    "    gewinner = spieler_liste[0]\n",
    "    \n",
    "    print(\"\\n\")\n",
    "    print(\"===================================\")\n",
    "    print(\"{} gewinnt das Spiel!!!\".format(gewinner))\n",
    "    print(\"===================================\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bitte die Anzahl der Spieler eingeben: 4\n",
      "\n",
      "\n",
      "Runde 1\n",
      "========\n",
      "Spieler_3  vs. Spieler_4 : Spieler_4  gewinnt die Runde!\n",
      "Spieler_2  vs. Spieler_1 : Spieler_1  gewinnt die Runde!\n",
      "\n",
      "\n",
      "Runde 2\n",
      "========\n",
      "Spieler_1  vs. Spieler_4 : Spieler_4  gewinnt die Runde!\n",
      "\n",
      "\n",
      "===================================\n",
      "Spieler_4  gewinnt das Spiel!!!\n",
      "===================================\n"
     ]
    }
   ],
   "source": [
    "# teste die Funktion tunierplan_erstellen()\n",
    "tunierplan_erstellen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Life is not fair, but life is not fair for everyone; which actually makes it fair. (unbekannt)\n",
    "\n",
    "\n",
    "Ist die Anzahl Spieler keine Zweierpotenz, so wird dieses Verfahren unfair, da dann z. B. Spieler, für die kein Gegenspieler existiert, ohne zu gewinnen eine Runde weiter kommen.\n",
    "\n",
    "Alternativ können auch mehrere Spieler zugleich spielen. Wenn alle Spieler das gleiche Handzeichen spielen, ist das Spiel natürlich unentschieden. Wenn insgesamt nur zwei Handzeichen gespielt werden, gibt es eine Gewinnergruppe und eine Verlierergruppe. Jedoch wird die Auswertung, wer die Runde gewonnen hat, schwieriger, wenn alle drei Handzeichen gespielt werden. Wer gewinnt, wenn bei einem Spiel mit fünf Spielern zweimal Stein, zweimal Papier und einmal Schere gezeigt sind? Man könnte nun über die Anzahl der Spieler, die das selbe Zeichen gespielt haben die Gewinner- und Verlierergruppen ermitteln. Alternativ kann die Regel auch sein, dass sobald alle drei Handzeichen gespielt sind, die Runde unentschieden ist.\n",
    "\n",
    "Diese letzte Möglichkeit wollen wir nun näher betrachten. Insbesondere ist interessant, wie hoch die Wahrscheinlichkeit für ein Unentschieden ist, da das Spiel dann wiederholt werden muss. Die Wahrscheinlichkeit für ein Unentschieden steigt mit der Anzahl der Spieler schnell an. Es kann bei vielen Spielern also sehr lange dauern, bis eine Gewinnergruppe feststeht.\n",
    "\n",
    "Deine Aufgabe ist es nun, viele zufällige Spiele mit einer unterschiedlichen Anzahl von Spielern zu simulieren und dabei zu erfassen, wie oft ein Unentschieden aufgetreten ist. Darauskannst du das Verhältnis zwischen der Anzahl an Unentschieden und Anzahl der Spiele bestimmen und dies in einen Graphen einzeichen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.328, 0.4746, 0.6126, 0.7376, 0.8262, 0.882, 0.926, 0.9526, 0.9662, 0.9768, 0.9826, 0.9894, 0.9944, 0.9944, 0.9976, 0.9974, 0.9994, 0.9988, 0.9992, 0.9996, 0.9998, 0.9996]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Eine Hilfsfunktion, welche zufällig eines der drei möglichen Handzeichen zurückgibt\n",
    "def zufaelliges_handzeichen():\n",
    "    alle_zeichen = [schere, stein, papier]\n",
    "    return np.random.choice(alle_zeichen)\n",
    "\n",
    "# Eine Hilfsfunktion, die alle Duplikate aus der Liste enfernt und die Anzahl der\n",
    "# nun verschiedenen Elemente zurückgibt\n",
    "def anzahl_verschiedener_elemente(liste):\n",
    "    return len(set(liste))\n",
    "\n",
    "# Diese Funktion gibt eine Liste der Handzeichen zurück, die die Spieler (zufällig) gewählt haben.\n",
    "def simuliere_spiel(anzahl_spieler):\n",
    "    dieses_spiel = []\n",
    "    for k in range(anzahl_spieler):\n",
    "        dieses_spiel.append(zufaelliges_handzeichen())\n",
    "    return dieses_spiel\n",
    "\n",
    "# Diese Funktion gibt zurück, ob ein Spiel unentschieden ist,\n",
    "# weil nur eines oder alle drei Handzeichen gezeigt wurden\n",
    "def spiel_ist_unentschieden(spiel):\n",
    "    anzahl_handzeichen = anzahl_verschiedener_elemente(spiel)\n",
    "    return anzahl_handzeichen != 2\n",
    "\n",
    "# In dieser Funktion wird die Wahrscheinlichkeit dafür, dass ein Spiel mit der gegeben\n",
    "# Anzahl an Spielern unentschieden ausgeht ermittelt.\n",
    "def wahrscheinlichkeit_unentschieden(anzahl_spieler):\n",
    "    # Lege fest, wie viele Spiele jeweils gespielt werden sollen\n",
    "    anzahl_zu_spielende = 5000\n",
    "    anzahl_unentschieden = 0\n",
    "    for spiel_nummer in range(anzahl_zu_spielende):\n",
    "        if spiel_ist_unentschieden(simuliere_spiel(anzahl_spieler)):\n",
    "            anzahl_unentschieden += 1\n",
    "    return anzahl_unentschieden / anzahl_zu_spielende\n",
    "\n",
    "# Lege fest, bis zu welcher Anzahl Spieler die Wahrscheinlichkeiten berechnet werden sollen\n",
    "minimale_anzahl_spieler = 3\n",
    "maximale_anzahl_spieler = 25\n",
    "\n",
    "# Führe die Berechnung für verschiedene Anzahlen an Spielern aus\n",
    "wahrscheinlichkeiten = []\n",
    "for i in range(minimale_anzahl_spieler, maximale_anzahl_spieler):\n",
    "    wahrscheinlichkeiten.append(wahrscheinlichkeit_unentschieden(i))\n",
    "\n",
    "    \n",
    "print(wahrscheinlichkeiten)\n",
    "# Zeichne den Graphen\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(range(minimale_anzahl_spieler, maximale_anzahl_spieler), wahrscheinlichkeiten)\n",
    "#plt.plot(range(minimale_anzahl_spieler, maximale_anzahl_spieler), wahrscheinlichkeiten_berechnet)\n",
    "plt.xlabel('Anzahl der Spieler im Spiel')\n",
    "plt.ylabel('Wahrscheinlichkeit für Unentschieden')\n",
    "plt.grid()\n",
    "plt.axis([0.0, maximale_anzahl_spieler, 0.0, 1.05])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fragen & Feedback:\n",
    "\n",
    "**Wenn ihr Fragen oder Anregungen zu der Aufgabe (oder Lösung) habt, dann tauscht euch gerne im [Chat](https://spectrum.chat/bwki/aufgabenarchiv/) darüber aus oder schreibt uns eine E-Mail (an info@bw-ki.de).**\n",
    "\n",
    "Wir freuen uns auch immer über **Feedback** (auch unter info@bw-ki.de):\n",
    "\n",
    "- War diese Aufgabe zu leicht, zu schwer oder genau richtig?\n",
    "- Wie lang hast du für diese Aufgabe ungefähr gebraucht?\n",
    "- Welche Art von Aufgaben wünschst du dir in Zukunft?"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:bwki_env]",
   "language": "python",
   "name": "conda-env-bwki_env-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}