05-Aufgabe.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Schere, Stein, Papier - Simulation\n",
    "### - Aufgabe - "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aber ohne Brunnen!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schere, Stein, Papier ist ein weltweit bekanntes Spiel. Zwei Spieler treten gegeneinander an und geben gleichzeitig ein Handzeichen. Je nachdem, welche Zeichen angegeben sind, gewinnt einer der Spieler oder es ist ein Unentschieden. Die folgende Grafik veranschaulicht das Vefahren:\n",
    "\n",
    "![Schere, Stein, Papier](https://upload.wikimedia.org/wikipedia/commons/d/d0/Rock-paper-scissors_de.svg)\n",
    "(Quelle: https://upload.wikimedia.org/wikipedia/commons/d/d0/Rock-paper-scissors_de.svg)\n",
    "\n",
    "Diese Aufgabe (und auch noch eine zweite Aufgabe) beschäftigen sich mit der Entwicklung eines Simulators für Schere, Stein, Papier und auch mit der Fairnessthematik, wenn mehr als zwei Personen gegeneinander spielen.\n",
    "\n",
    "Du musst den folgenden Code bei \"...\" erweitern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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",
    "print(schere)\n",
    "print(stein)\n",
    "print(papier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zunächst musst du die Beziehung der drei Handzeichen untereinander codieren, wozu du ein Dictionary verwenden kannst.\n",
    "\n",
    "Dictionaries sind Datenkollektionen, wie das auch Listen in Python sind. Jedoch werden bei Listen die Elemente mit Ganzzahlen von 0 bis zur Länge der Liste - 1 nummeriert. In Dictionaries kann man dazu beliebige andere Daten als \"Nummerierung\" (genannt Key oder Indices) verwenden. Dictionaries enthalten also ein \"Mapping\" von Elementen auf andere Elemente. Ein Beispiel ist das Morse-Alphabet als Python Dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Morsealphabet (gekürzt) zur Veranschaulichung eines Python Dictionaries\n",
    "morse = {\n",
    "\"A\" : \".-\", \n",
    "\"B\" : \"-...\", \n",
    "\"C\" : \"-.-.\", \n",
    "\"D\" : \"-..\", \n",
    "\"E\" : \".\", \n",
    "\"F\" : \"..-.\"\n",
    "# Alphabet hier nicht weiter ausgeschrieben\n",
    "}\n",
    "\n",
    "print(morse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lies dir am Besten noch eine Einführung zu Dictionaries durch: https://py-tutorial-de.readthedocs.io/de/latest/datastructures.html#dictionaries.\n",
    "\n",
    "Erstelle nun ein Dictionary, welches die Regeln von Schere, Stein, Papier abbildet. Dazu soll das Mapping enthalten, welches Handzeichen gegen welches gewinnt (das ist die \"Vorwärtsrichtung\" der Pfeile in dem Bild oben)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Die Gewinnregeln von Schere, Stein, Papier:\n",
    "regeln = {\n",
    "    schere : ...,\n",
    "    ... : ...,\n",
    "    ... : ...\n",
    "}\n",
    "\n",
    "# So kannst du auf einzelne Elemente des Dictionaries zugreifen:\n",
    "print(schere + \" schlägt \" + regeln[schere])\n",
    "print(stein + \" schlägt \" + regeln[stein])\n",
    "print(papier + \" schlägt \" + regeln[papier] + \"\\n\")\n",
    "\n",
    "# Und so auf eine Liste aller Keys, also nur der linken Seite des Mappings:\n",
    "print(regeln.keys())\n",
    "\n",
    "# So kannst du Elemente dem Dictionary hinzufügen:\n",
    "morse.update({\"G\" : \"--.\"})\n",
    "morse.update({\"H\" : \"....\"})\n",
    "print() # Leerzeile\n",
    "print(morse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun wollen wir in der Lage sein, das Spiel zu spielen. Schreibe dazu eine Funktion, welche die Handzeichen von zwei Spielern als Parameter erhält und zurückgibt, ob Spieler 1 oder Spieler 2 gewonnen hat, oder ob es ein Unentschieden war.\n",
    "Verwende dazu das Dictionary, das du gerade angelegt hast!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Wer hat die Runde gewonnen? Oder war es ein Unentschieden?\n",
    "def spiele(handzeichen_1, handzeichen_2):\n",
    "    if ...:\n",
    "        return \"Spieler 1\"\n",
    "    elif ...:\n",
    "        return \"Spieler 2\"\n",
    "    else:\n",
    "        return \"Unentschieden\"\n",
    "\n",
    "# Hier kannst du deine Funktion testen.\n",
    "print(spiele(schere, stein)) # Spieler 2 gewinnt\n",
    "print(spiele(stein, schere)) # Spieler 1 gewinnt\n",
    "print(spiele(papier, stein)) # Spieler 1 gewinnt\n",
    "print(spiele(schere, schere)) # Unentschieden\n",
    "print(spiele(stein, stein)) # Unentschieden\n",
    "print(spiele(papier, papier)) # Unentschieden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt wollen wir einen Computergegner entwickeln, der immer gewinnt. Life is not fair, is it?\n",
    "Dazu musst du das Mapping von oben invertieren, also die Richtung der Pfeile im Bild oben umkehren. Dann kann der Computergegner einfach aus diesem Computergegner-Mapping das passende Handzeichen auswählen, um immer zu gewinnen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# In dieser Funktion soll das Dictionary \"regeln\" invertiert werden.\n",
    "# Dazu brauchst du eine for-Schleife über die Keys des Dictionaries\n",
    "# und die update-Funktion des Ausgabe-Dictionaries.\n",
    "def invertiere_dictionary(dictionary):\n",
    "    ausgabe_dictionary = {}\n",
    "    for key in dictionary.keys():\n",
    "        ...\n",
    "    return ausgabe_dictionary\n",
    "\n",
    "# Hier kannst du deine Funktion überprüfen. Es sollen immer paarweise die Handzeichen getauscht sein.\n",
    "print(regeln)\n",
    "computergegner_dict = invertiere_dictionary(regeln)\n",
    "print(computergegner_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Implementiere nun einen unschlagbaren Computergegner, der als Spieler 2 spielt.\n",
    "def spiele_gegen_computer(handzeichen_mensch):\n",
    "    return ...\n",
    "\n",
    "handzeichen_mensch = schere\n",
    "# oder handzeichen_mensch = stein\n",
    "# oder handzeichen_mensch = papier\n",
    "\n",
    "# Spieler 2 (der Computergegner) soll nun immer gewinnen\n",
    "print(spiele(handzeichen_mensch, spiele_gegen_computer(handzeichen_mensch)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aller guten Dinge sind drei. Oder auch fünf.\n",
    "\n",
    "Es gibt auch eine Variante von Schere, Stein, Papier, bei der noch Brunnen (Wasser) und Streichholz (Feuer) als weitere Handzeichen aufgenommen werden. Die Gewinnregeln dazu sind in dieser Tabelle aufgeführt: https://de.wikipedia.org/wiki/Schere,_Stein,_Papier#F%C3%BCnf_Gesten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "brunnen = \"💦 Brunnen\"\n",
    "streichholz = \"🔥 Streichholz\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine Matrix in der Mathematik ist vergleichbar mit einer Tabelle, die Zahlen und Variablen enthalten kann. Matrizen kann man in Python u. a. durch eine Liste von Listen abbilden. Implementiere Regeln des Spieln mit fünf Handzeichen als Matrix und schreibe die Funktion \"spiele(handzeichen_1, handzeichen_2)\" von vorhin im Folgenden als \"spiele5(handzeichen_1, handzeichen_2)\" neu, so dass sie die neuen Regeln verwendet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Eine Hilfsfunktion, welche die Handzeichen in ihre Nummern (von 0 bis 4) umwandelt.\n",
    "# Die Tabelle auf Wikipedia ist nicht ganz logisch sortiert, das wird in dieser\n",
    "# Funktion genauso gemacht, so dass das einheitlich ist.\n",
    "def handzeichen_zu_nummer(handzeichen):\n",
    "    alle_zeichen = [stein, schere, papier, brunnen, streichholz]\n",
    "    return alle_zeichen.index(handzeichen)\n",
    "\n",
    "# Die Gewinnregeln von Schere, Stein, Papier, Brunnen, Streichholz:\n",
    "regeln5 = [\n",
    "    [\"X\", \"+\", \"-\", \"-\", \"+\"],\n",
    "    ...,\n",
    "    ...,\n",
    "    ...,\n",
    "    ...\n",
    "]\n",
    "\n",
    "# Wer hat die Runde gewonnen? Oder war es ein Unentschieden?\n",
    "def spiele5(handzeichen_1, handzeichen_2):\n",
    "    nummer_handzeichen_1 = handzeichen_zu_nummer(handzeichen_1)\n",
    "    nummer_handzeichen_2 = handzeichen_zu_nummer(handzeichen_2)\n",
    "    if ...:\n",
    "        return \"Spieler 1\"\n",
    "    elif ...:\n",
    "        return \"Spieler 2\"\n",
    "    else:\n",
    "        return \"Unentschieden\"\n",
    "\n",
    "# Hier kannst du deine Funktion testen.\n",
    "print(spiele5(schere, stein)) # Spieler 2 gewinnt\n",
    "print(spiele5(papier, schere)) # Spieler 2 gewinnt\n",
    "print(spiele5(streichholz, brunnen)) # Spieler 1 gewinnt\n",
    "print(spiele5(papier, streichholz)) # Spieler 2 gewinnt\n",
    "print(spiele5(stein, streichholz)) # Spieler 1 gewinnt\n",
    "print(spiele5(papier, papier)) # Unentschieden\n",
    "print(spiele5(brunnen, brunnen)) # Unentschieden\n",
    "print(spiele5(streichholz, streichholz)) # Unentschieden"
   ]
  },
  {
   "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 3",
   "language": "python",
   "name": "python3"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}