{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "remove_cell"
    ]
   },
   "source": [
    "<div style=\"width: 100%; overflow: hidden;\">\n",
    "    <div style=\"width: 500px; float: left;\"> \n",
    "        <h1>Ingenieurinformatik – Übung</h1>\n",
    "        Lehrstuhl <b>Computational Civil Engineering</b><br>\n",
    "        Kontakt: <a href = \"mailto: cce-inginf@uni-wuppertal.de\">Email senden</a> | Individuelle Kontakte siehe Webseite des Lehrstuhls<br>\n",
    "        Links: \n",
    "        <a href=\"cce.uni-wuppertal.de/inginf\">Vorlesungsskript</a> | \n",
    "        <a href=\"cce.uni-wuppertal.de/\">Webseite des Lehrstuhls</a>\n",
    "    </div>\n",
    "    <div style=\"float:right;\"> \n",
    "        <img src=\"logo_cce_combined.png\" style=\"width:150px;\"/>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sortieralgorithmus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mittels Schleifen und Abzweigungen wird eine Funktion zum Sortieren von Zahlenlisten implementiert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabenteil A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implementieren Sie die den Bubblesort Algorithmus als eine eigene Funktion. Sie bekommt als Argument eine Liste, welche nach der Größe ihrer Elemente sortiert werden soll, und das Ergebnis zurückgibt. Als optionaler Parameter soll eine Ausgabe gesteuert werden, welche den Zwischenzustand der zu sortierenden Liste ausgibt.\n",
    "\n",
    "Testen Sie ihre Funktion anhand folgender Zufallszahlen:\n",
    "\n",
    "* 9, 74, 90, 23, 69, 10, 72, 93, 99, 91, 45, 81, 4, 71, 14, 16, 50, 53, 82, 47, 40, 44, 4, 30, 32, 73, 99, 93, 65, 36\n",
    "* 69, 70, 93, 25, 85, 68, 73, 97, 22, 35, 41, 99, 22, 33, 56, 95, 86, 45, 24, 64, 73, 60, 53, 40, 94, 12, 97, 18, 75, 8\n",
    "* 84, 51, 4, 8, 28, 55, 64, 25, 1, 47, 8, 66, 12, 60, 28, 18, 89, 37, 2, 48, 92, 74, 78, 28, 35, 87, 88, 51, 57, 6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lösungshinweis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um zu prüfen ob Ihre Funktion richtig arbeitet, können Sie eine weitere Funktion schreiben, welche prüft, ob eine Liste sortiert ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = [9, 74, 90, 23, 69, 10, 72, 93, 99, 91, \n",
    "      45, 81, 4, 71, 14, 16, 50, 53, 82, 47, \n",
    "      40, 44, 4, 30, 32, 73, 99, 93, 65, 36]\n",
    "t2 = [69, 70, 93, 25, 85, 68, 73, 97, 22, 35,\n",
    "      41, 99, 22, 33, 56, 95, 86, 45, 24, 64,\n",
    "      73, 60, 53, 40, 94, 12, 97, 18, 75, 8]\n",
    "t3 = [84, 51, 4, 8, 28, 55, 64, 25, 1, 47, \n",
    "      8, 66, 12, 60, 28, 18, 89, 37, 2, 48, \n",
    "      92, 74, 78, 28, 35, 87, 88, 51, 57, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "source": [
    "### Lösungsvorschlag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "source": [
    "Um lange Listen in dem Skript kompakt darstellen zu können, wird im Folgenden diese Funktion verwendet: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [],
   "source": [
    "# Hilfsfunktion zur Ausgabe langer Listen im Skript\n",
    "def list_str(A, n=10):\n",
    "    res = \"\"\n",
    "    res += \"[\"\n",
    "    nflines = len(A)//n\n",
    "    nhlines = len(A)%n\n",
    "    for i in range(nflines):\n",
    "        if nflines > 0:\n",
    "            res += \" \"\n",
    "        for j in range(n):\n",
    "            res += str(A[i*n+j])\n",
    "            if i*n+j < len(A)-1:\n",
    "                res += \", \"\n",
    "        if not (nhlines == 0 and i == nflines-1):\n",
    "            res += \"\\n\"\n",
    "    for j in range(nhlines):\n",
    "        res += str(A[nflines*n+j])\n",
    "        if j < nhlines-1:\n",
    "                res += \", \"\n",
    "    res += \"]\"\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [],
   "source": [
    "def bubble_sort(A, ausgabe=False):\n",
    "\n",
    "    # Initialer Wert für n, wird bei jedem Schleifendurchlauf \n",
    "    # um Eins verringert\n",
    "    n = len(A)\n",
    "\n",
    "    # Variable zum Prüfen ob eine Vertauschung erfolgt ist \n",
    "    # initial wird sie auf wahr gesetzt\n",
    "    getauscht = True\n",
    "    \n",
    "    # Iterationszähler\n",
    "    izaehler = 0\n",
    "    \n",
    "    while getauscht == True:\n",
    "        getauscht = False\n",
    "        izaehler += 1\n",
    "        \n",
    "        if ausgabe == True:\n",
    "            print(\"Iteration:\", izaehler)\n",
    "            print(\"   Liste zu Beginn der Iteration: \")\n",
    "            print(\"   \", list_str(A))\n",
    "        \n",
    "        # Vertauschungsschleife\n",
    "        for j in range(n-1):\n",
    "            # Prüfen ob das nachfolgende Element kleiner ist,\n",
    "            # falls ja, werden beide getauscht\n",
    "            if A[j+1] < A[j]:\n",
    "                if ausgabe == True:\n",
    "                    print(\"   Tausche: \", A[j], \"und\", A[j+1])\n",
    "                \n",
    "                # Tauschen des j mit dem j+1 Elementwert\n",
    "                mv = A[j]\n",
    "                A[j] = A[j+1]\n",
    "                A[j+1] = mv\n",
    "                \n",
    "                # Markierung, dass eine Vertauschung stattfand\n",
    "                getauscht = True\n",
    "                \n",
    "                if ausgabe == True:\n",
    "                    print(\"   Liste nach Tausch: \")\n",
    "                    print(\"   \", list_str(A))\n",
    "            else:\n",
    "                if ausgabe == True:\n",
    "                    print(\"   Elemente \", A[j], \"und\", A[j+1], \" müssen nicht getauscht werden\")\n",
    "\n",
    "        # Schleifendurchlauf wird verkürzt \n",
    "        n -= 1\n",
    "        if not getauscht:\n",
    "            if ausgabe == True:\n",
    "                print(\"   kein Tausch mehr notwendig, Liste ist nun sortiert\")\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9, 74, 90, 23, 69, 10, 72, 93, 99, 91, \n",
      " 45, 81, 4, 71, 14, 16, 50, 53, 82, 47, \n",
      " 40, 44, 4, 30, 32, 73, 99, 93, 65, 36]\n",
      "[ 4, 4, 9, 10, 14, 16, 23, 30, 32, 36, \n",
      " 40, 44, 45, 47, 50, 53, 65, 69, 71, 72, \n",
      " 73, 74, 81, 82, 90, 91, 93, 93, 99, 99]\n"
     ]
    }
   ],
   "source": [
    "print( list_str(t1) )\n",
    "print( list_str( bubble_sort(t1) ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [],
   "source": [
    "# Funktion zum Prüfen der Sortierung\n",
    "def pruefe_sortierung(A):\n",
    "    for i in range(len(A)-1):\n",
    "        if A[i+1] < A[i]:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 69, 70, 93, 25, 85, 68, 73, 97, 22, 35, \n",
      " 41, 99, 22, 33, 56, 95, 86, 45, 24, 64, \n",
      " 73, 60, 53, 40, 94, 12, 97, 18, 75, 8]\n",
      "[ 8, 12, 18, 22, 22, 24, 25, 33, 35, 40, \n",
      " 41, 45, 53, 56, 60, 64, 68, 69, 70, 73, \n",
      " 73, 75, 85, 86, 93, 94, 95, 97, 97, 99]\n",
      "Sortiert? True\n"
     ]
    }
   ],
   "source": [
    "print( list_str( t2 ) )\n",
    "t2_sort = bubble_sort(t2)\n",
    "print( list_str( t2_sort)  )\n",
    "print(\"Sortiert?\", pruefe_sortierung(t2_sort))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8, 12, 18, 50, 22, 24, 25, 33, 35, 40, \n",
      " 41, 45, 53, 56, 60, 64, 68, 69, 70, 73, \n",
      " 73, 75, 85, 86, 93, 94, 95, 97, 97, 99]\n",
      "Sortiert? False\n"
     ]
    }
   ],
   "source": [
    "t2_sort[3] = 50\n",
    "print( list_str(t2_sort) )\n",
    "print(\"Sortiert?\", pruefe_sortierung(t2_sort))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 1\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 84, 51, 4, 8, 28, 55, 64, 25, 1, 47]\n",
      "   Tausche:  84 und 51\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 84, 4, 8, 28, 55, 64, 25, 1, 47]\n",
      "   Tausche:  84 und 4\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 84, 8, 28, 55, 64, 25, 1, 47]\n",
      "   Tausche:  84 und 8\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 8, 84, 28, 55, 64, 25, 1, 47]\n",
      "   Tausche:  84 und 28\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 8, 28, 84, 55, 64, 25, 1, 47]\n",
      "   Tausche:  84 und 55\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 8, 28, 55, 84, 64, 25, 1, 47]\n",
      "   Tausche:  84 und 64\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 8, 28, 55, 64, 84, 25, 1, 47]\n",
      "   Tausche:  84 und 25\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 8, 28, 55, 64, 25, 84, 1, 47]\n",
      "   Tausche:  84 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 8, 28, 55, 64, 25, 1, 84, 47]\n",
      "   Tausche:  84 und 47\n",
      "   Liste nach Tausch: \n",
      "    [ 51, 4, 8, 28, 55, 64, 25, 1, 47, 84]\n",
      "Iteration: 2\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 51, 4, 8, 28, 55, 64, 25, 1, 47, 84]\n",
      "   Tausche:  51 und 4\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 51, 8, 28, 55, 64, 25, 1, 47, 84]\n",
      "   Tausche:  51 und 8\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 51, 28, 55, 64, 25, 1, 47, 84]\n",
      "   Tausche:  51 und 28\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 51, 55, 64, 25, 1, 47, 84]\n",
      "   Elemente  51 und 55  müssen nicht getauscht werden\n",
      "   Elemente  55 und 64  müssen nicht getauscht werden\n",
      "   Tausche:  64 und 25\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 51, 55, 25, 64, 1, 47, 84]\n",
      "   Tausche:  64 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 51, 55, 25, 1, 64, 47, 84]\n",
      "   Tausche:  64 und 47\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 51, 55, 25, 1, 47, 64, 84]\n",
      "Iteration: 3\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 4, 8, 28, 51, 55, 25, 1, 47, 64, 84]\n",
      "   Elemente  4 und 8  müssen nicht getauscht werden\n",
      "   Elemente  8 und 28  müssen nicht getauscht werden\n",
      "   Elemente  28 und 51  müssen nicht getauscht werden\n",
      "   Elemente  51 und 55  müssen nicht getauscht werden\n",
      "   Tausche:  55 und 25\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 51, 25, 55, 1, 47, 64, 84]\n",
      "   Tausche:  55 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 51, 25, 1, 55, 47, 64, 84]\n",
      "   Tausche:  55 und 47\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 51, 25, 1, 47, 55, 64, 84]\n",
      "Iteration: 4\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 4, 8, 28, 51, 25, 1, 47, 55, 64, 84]\n",
      "   Elemente  4 und 8  müssen nicht getauscht werden\n",
      "   Elemente  8 und 28  müssen nicht getauscht werden\n",
      "   Elemente  28 und 51  müssen nicht getauscht werden\n",
      "   Tausche:  51 und 25\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 25, 51, 1, 47, 55, 64, 84]\n",
      "   Tausche:  51 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 25, 1, 51, 47, 55, 64, 84]\n",
      "   Tausche:  51 und 47\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 28, 25, 1, 47, 51, 55, 64, 84]\n",
      "Iteration: 5\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 4, 8, 28, 25, 1, 47, 51, 55, 64, 84]\n",
      "   Elemente  4 und 8  müssen nicht getauscht werden\n",
      "   Elemente  8 und 28  müssen nicht getauscht werden\n",
      "   Tausche:  28 und 25\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 25, 28, 1, 47, 51, 55, 64, 84]\n",
      "   Tausche:  28 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 25, 1, 28, 47, 51, 55, 64, 84]\n",
      "   Elemente  28 und 47  müssen nicht getauscht werden\n",
      "Iteration: 6\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 4, 8, 25, 1, 28, 47, 51, 55, 64, 84]\n",
      "   Elemente  4 und 8  müssen nicht getauscht werden\n",
      "   Elemente  8 und 25  müssen nicht getauscht werden\n",
      "   Tausche:  25 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 8, 1, 25, 28, 47, 51, 55, 64, 84]\n",
      "   Elemente  25 und 28  müssen nicht getauscht werden\n",
      "Iteration: 7\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 4, 8, 1, 25, 28, 47, 51, 55, 64, 84]\n",
      "   Elemente  4 und 8  müssen nicht getauscht werden\n",
      "   Tausche:  8 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 4, 1, 8, 25, 28, 47, 51, 55, 64, 84]\n",
      "   Elemente  8 und 25  müssen nicht getauscht werden\n",
      "Iteration: 8\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 4, 1, 8, 25, 28, 47, 51, 55, 64, 84]\n",
      "   Tausche:  4 und 1\n",
      "   Liste nach Tausch: \n",
      "    [ 1, 4, 8, 25, 28, 47, 51, 55, 64, 84]\n",
      "   Elemente  4 und 8  müssen nicht getauscht werden\n",
      "Iteration: 9\n",
      "   Liste zu Beginn der Iteration: \n",
      "    [ 1, 4, 8, 25, 28, 47, 51, 55, 64, 84]\n",
      "   Elemente  1 und 4  müssen nicht getauscht werden\n",
      "   kein Tausch mehr notwendig, Liste ist nun sortiert\n"
     ]
    }
   ],
   "source": [
    "t3 = [84, 51, 4, 8, 28, 55, 64, 25, 1, 47, \n",
    "      8, 66, 12, 60, 28, 18, 89, 37, 2, 48, \n",
    "      92, 74, 78, 28, 35, 87, 88, 51, 57, 6]\n",
    "t3_sort = bubble_sort(t3[:10], ausgabe=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabenteil B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Erweitern Sie die obige Funktion um eine weitere Rückgabe. Diese soll die Anzahl der durchgeführten Vertauschungen enthalten. Untersuchen Sie wie diese Anzahl mit der Länge der zu sortierenden Liste zusammenhängt. Sie können sich auf die obigen Datensätze beschränken.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "source": [
    "### Lösungsvorschlag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [],
   "source": [
    "def bubble_sort_zaehler(A):\n",
    "\n",
    "    # Initialer Wert für n, wird bei jedem Schleifendurchlauf \n",
    "    # um Eins verringert\n",
    "    n = len(A)\n",
    "    \n",
    "    # Variable zum Prüfen ob eine Vertauschung erfolgt ist \n",
    "    # initial wird sie auf wahr gesetzt\n",
    "    getauscht = True\n",
    "    \n",
    "    # Zähler für Vertauschungen\n",
    "    vertauschungen = 0\n",
    "    \n",
    "    # Schleife wird solgange ausgeführt bis keine\n",
    "    # weitere Vertauschung notwendig ist\n",
    "    while getauscht == True:\n",
    "        getauscht = False\n",
    "        \n",
    "        # Vertauschungsschleife\n",
    "        for j in range(n-1):\n",
    "            # Prüfen ob das nachfolgende Element kleiner ist,\n",
    "            # falls ja, werden beide getauscht\n",
    "            if A[j+1] < A[j]:\n",
    "\n",
    "                # Tauschen des j mit dem j+1 Elementwert\n",
    "                mv = A[j]\n",
    "                A[j] = A[j+1]\n",
    "                A[j+1] = mv\n",
    "                \n",
    "                # Markierung, dass eine Vertauschung stattfand\n",
    "                getauscht = True\n",
    "                \n",
    "                # Erhöhe Zähler der Vertauschungen\n",
    "                vertauschungen += 1\n",
    "                \n",
    "        # Schleifendurchlauf wird verkürzt \n",
    "        n -= 1\n",
    "\n",
    "    # Rückgabe der sortierten Liste als auch der Anzahl \n",
    "    # der Vertauschungen \n",
    "    return A, vertauschungen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 69, 70, 93, 25, 85, 68, 73, 97, 22, 35, \n",
      " 41, 99, 22, 33, 56, 95, 86, 45, 24, 64, \n",
      " 73, 60, 53, 40, 94, 12, 97, 18, 75, 8]\n",
      "[ 8, 12, 18, 22, 22, 24, 25, 33, 35, 40, \n",
      " 41, 45, 53, 56, 60, 64, 68, 69, 70, 73, \n",
      " 73, 75, 85, 86, 93, 94, 95, 97, 97, 99]\n",
      "Anzahl der Vertauschungen: 245\n"
     ]
    }
   ],
   "source": [
    "t2 = [69, 70, 93, 25, 85, 68, 73, 97, 22, 35,\n",
    "      41, 99, 22, 33, 56, 95, 86, 45, 24, 64,\n",
    "      73, 60, 53, 40, 94, 12, 97, 18, 75, 8]\n",
    "\n",
    "print( list_str( t2 ) )\n",
    "t2_sort, v = bubble_sort_zaehler(t2)\n",
    "print( list_str( t2_sort ) )\n",
    "print( \"Anzahl der Vertauschungen:\", v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "loesung",
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\tAnzahl Vertauschungen\n",
      "=============================\n",
      "0 \t 0\n",
      "1 \t 0\n",
      "2 \t 0\n",
      "3 \t 0\n",
      "4 \t 3\n",
      "5 \t 4\n",
      "6 \t 8\n",
      "7 \t 10\n",
      "8 \t 10\n",
      "9 \t 18\n",
      "10 \t 25\n",
      "11 \t 32\n",
      "12 \t 32\n",
      "13 \t 43\n",
      "14 \t 53\n",
      "15 \t 61\n",
      "16 \t 63\n",
      "17 \t 67\n",
      "18 \t 78\n",
      "19 \t 94\n",
      "20 \t 104\n",
      "21 \t 110\n",
      "22 \t 122\n",
      "23 \t 136\n",
      "24 \t 153\n",
      "25 \t 156\n",
      "26 \t 181\n",
      "27 \t 182\n",
      "28 \t 208\n",
      "29 \t 216\n"
     ]
    }
   ],
   "source": [
    "print(\"N\\tAnzahl Vertauschungen\")\n",
    "print(\"=\"*29)\n",
    "\n",
    "for N in range(30):\n",
    "    t2 = [69, 70, 93, 25, 85, 68, 73, 97, 22, 35,\n",
    "      41, 99, 22, 33, 56, 95, 86, 45, 24, 64,\n",
    "      73, 60, 53, 40, 94, 12, 97, 18, 75, 8]\n",
    "    t2_sort, v = bubble_sort_zaehler(t2[:N])\n",
    "    \n",
    "    print(N, '\\t', v)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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": 4
}