1_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fundamentals of Data Analytics\n",
    "# Exercise Sheet 1: Introduction to Python, NumPy, and SciPy\n",
    "\n",
    "---\n",
    "\n",
    "## Part 1: Python Basics\n",
    "\n",
    "### Task 1.1: Variables and Data Types\n",
    "\n",
    "Let's start with some basic Python concepts.\n",
    "\n",
    "1. Define a variable `age` with an integer value `25`.\n",
    "2. Define a variable `name` with a string value `\"Alice\"`.\n",
    "3. Define a float variable `height` with a value `5.4`.\n",
    "4. Create a dictionary variable `numbers_dict` containing the numbers from 1 to 5 as keys and their corresponding written forms as values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 1.1: Define the variables\n",
    "age = 25\n",
    "name = \"Alice\"\n",
    "height = 5.4\n",
    "numbers_dict = {\"1\": \"one\", \"2\": \"two\", \"3\": \"three\", \"4\": \"four\", \"5\": \"five\"}\n",
    "numbers_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.2: Basic Operations\n",
    "\n",
    "1. Add 10 to the `age` variable, and store the result in a new variable `new_age`.\n",
    "2. Create a new variable `description` that includes `name` and `height` in a sentence. Example: \"Alice is 5.4 feet tall.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task 1.2: Perform operations\n",
    "new_age = age + 10\n",
    "description = f\"{name} is {height} feet fall\"\n",
    "print(description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.3: Control Structures\n",
    "\n",
    "1. Use a `for` loop to create a list of numbers from 1 to 10.\n",
    "2. Use a list comprehension to create a list of numbers from 1 to 10.\n",
    "3. Use a `while` loop to calculate the factorial of 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "# Task 1.3.1: Create a list using a for loop\n",
    "numbers_list = []\n",
    "for i in range(1, 10, 1):\n",
    "    numbers_list.append(i)\n",
    "\n",
    "print(numbers_list)\n",
    "...\n",
    "\n",
    "# Task 1.3.2: Create a list using a list comprehension\n",
    "...\n",
    "squares = [x**2 for x in numbers_list]\n",
    "print(squares)\n",
    "\n",
    "# Task 1.3.3: Calculate factorial using a while loop\n",
    "n = 5\n",
    "factorial = 1\n",
    "i = 1\n",
    "while i <= 5:\n",
    "    factorial *= i\n",
    "    i += 1\n",
    "    \n",
    "\n",
    "print(factorial)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.4: Functions\n",
    "\n",
    "1. Write a function `square` that takes a number as input and returns its square.\n",
    "2. Write a function `greet` that takes a `name` as input and returns a greeting message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "Hello Nasrul!\n"
     ]
    }
   ],
   "source": [
    "# Task 1.4: Define and execute the functions\n",
    "def square(num: int) -> int:\n",
    "    return num**2\n",
    "\n",
    "def greet(name: str) -> str:\n",
    "    return f\"Hello {name}!\"\n",
    "\n",
    "print(square(4))\n",
    "print(greet(\"Nasrul\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.5: File I/O using the `with open(...)` statement\n",
    "\n",
    "1. Create a variable `numbers` containing a list of numbers from 0 to 99\n",
    "2. Write the numbers to a file named `numbers.txt`, each on a different line.\n",
    "3. Read the contents of `numbers.txt` and print them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n",
      "34\n",
      "35\n",
      "36\n",
      "37\n",
      "38\n",
      "39\n",
      "40\n",
      "41\n",
      "42\n",
      "43\n",
      "44\n",
      "45\n",
      "46\n",
      "47\n",
      "48\n",
      "49\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "55\n",
      "56\n",
      "57\n",
      "58\n",
      "59\n",
      "60\n",
      "61\n",
      "62\n",
      "63\n",
      "64\n",
      "65\n",
      "66\n",
      "67\n",
      "68\n",
      "69\n",
      "70\n",
      "71\n",
      "72\n",
      "73\n",
      "74\n",
      "75\n",
      "76\n",
      "77\n",
      "78\n",
      "79\n",
      "80\n",
      "81\n",
      "82\n",
      "83\n",
      "84\n",
      "85\n",
      "86\n",
      "87\n",
      "88\n",
      "89\n",
      "90\n",
      "91\n",
      "92\n",
      "93\n",
      "94\n",
      "95\n",
      "96\n",
      "97\n",
      "98\n",
      "99\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Task 1.5: File I/O\n",
    "numbers = []\n",
    "for i in range(100):\n",
    "    numbers.append(i)\n",
    "print(numbers)\n",
    "\n",
    "# Write numbers to a file\n",
    "with open(\"numbers.txt\", 'w') as file:\n",
    "    for num in numbers:\n",
    "        file.write(f'{num}\\n')\n",
    "\n",
    "# Read and print the contents of the file\n",
    "with open(\"numbers.txt\", 'r') as file:\n",
    "    content = file.read()\n",
    "    print(content)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Part 2: NumPy Basics\n",
    "\n",
    "### Task 2.1: Creating and Manipulating Arrays\n",
    "\n",
    "1. Create a NumPy array of the first ten positive integers.\n",
    "2. Reshape this array into a 2x5 matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Task 2.1.1: Create array\n",
    "array_1_to_10 = np.arange(1, 11)\n",
    "print(array_1_to_10)\n",
    "\n",
    "# Task 2.1.2: Reshape into 2x5 matrix\n",
    "matrix_2x5 = np.reshape(array_1_to_10, (2,5))\n",
    "matrix_2x5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2.2: Array Operations\n",
    "\n",
    "1. Calculate the transpose of `matrix_2x5`.\n",
    "2. Flatten the matrix back into a 1D array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  6]\n",
      " [ 2  7]\n",
      " [ 3  8]\n",
      " [ 4  9]\n",
      " [ 5 10]]\n",
      "[ 1  2  3  4  5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "# Task 2.2.1: Transpose the matrix\n",
    "transposed_matrix = np.transpose(matrix_2x5)\n",
    "print(transposed_matrix)\n",
    "\n",
    "# Task 2.2.2: Flatten the matrix\n",
    "flattened_array = matrix_2x5.flatten()\n",
    "print(flattened_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2.3: Statistical Operations\n",
    "\n",
    "1. Calculate the mean, median, and standard deviation of the `array_1_to_10`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.5\n",
      "5.5\n",
      "2.8722813232690143\n"
     ]
    }
   ],
   "source": [
    "# Task 2.3: Statistical operations\n",
    "mean_value = array_1_to_10.mean()\n",
    "median_value = np.median(array_1_to_10)\n",
    "std_dev = array_1_to_10.std()\n",
    "\n",
    "print(mean_value)\n",
    "print(median_value)\n",
    "print(std_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Part 3: SciPy Introduction\n",
    "\n",
    "### Task 3.1: Numerical Integration\n",
    "\n",
    "1. Use SciPy to integrate the function $f(x) = x^2$ from 0 to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3333333333333333\n",
      "3.700743415417188e-15\n"
     ]
    }
   ],
   "source": [
    "from scipy.integrate import quad\n",
    "\n",
    "# Task 3.1: Define function and integrate\n",
    "def f(x):\n",
    "    return x**2\n",
    "\n",
    "a = 0\n",
    "b = 1\n",
    "\n",
    "integral_value, error = quad(f, a, b)\n",
    "print(integral_value)\n",
    "print(error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 3.2: Solving Linear Systems\n",
    "\n",
    "1. Solve the following system of equations using SciPy:\n",
    "    - $2x + 3y = 8$\n",
    "    - $x - y = 1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.2 1.2]\n"
     ]
    }
   ],
   "source": [
    "from scipy.linalg import solve\n",
    "\n",
    "# Coefficients matrix\n",
    "A = np.array([[2, 3],[1, -1]])\n",
    "\n",
    "# Constants vector\n",
    "b = np.array([8, 1])\n",
    "\n",
    "# Solve the system\n",
    "solution = solve(A, b)\n",
    "print(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 3.3: Optimization\n",
    "\n",
    "1. Find the minimum of the function $f(x) = x^2 + 2x + 1$ using SciPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  message: Optimization terminated successfully.\n",
      "  success: True\n",
      "   status: 0\n",
      "      fun: 0.0\n",
      "        x: [-1.000e+00]\n",
      "      nit: 2\n",
      "      jac: [ 0.000e+00]\n",
      " hess_inv: [[ 5.000e-01]]\n",
      "     nfev: 6\n",
      "     njev: 3\n"
     ]
    }
   ],
   "source": [
    "from scipy.optimize import minimize\n",
    "\n",
    "# Task 3.3: Define function and find minimum\n",
    "def f_to_minimize(x):\n",
    "    return x**2 + 2*x + 1\n",
    "\n",
    "initial_guess = 0\n",
    "result = minimize(f_to_minimize, initial_guess)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1 Task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [0] * 5\n",
    "list2 = [1] * 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "lis3 = list1 + list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "list4 = list(range(1, 11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "list5 = list4 + lis3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique = set()\n",
    "for num in list5:\n",
    "    unique.add(num)\n",
    "unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "unique.remove(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "unique.add(\"2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 10, '2', 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "unique.add(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 10, '2', 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# True is 1 and False is 0 and we already have 1 and 0 in the set so adding another True is not possible\n",
    "# However, in order to do that we would have to convert the set into a list\n",
    "result_list = list(unique)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 3, 4, 5, 6, 7, 8, 9, 10, '2']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_list.append(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 3, 4, 5, 6, 7, 8, 9, 10, '2', True]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 3\n",
    "\n",
    "# Reverse a list without using loops \n",
    "li = list(range(1, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_index = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse_list(input_index: int, li: list) -> list:\n",
    "    li1 = li[0:input_index]\n",
    "    li2 = li[input_index + 1: ]\n",
    "    return li1[::-1] + [li[input_index]] + li2[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 3, 9, 8, 7, 6, 5, 4]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_list(input_index, li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "Exercise 4 — Scrabble - 0 Points - Programming task\n",
    "Create a function in a script that takes a word and calculates its Scrabble score. Use the following\n",
    "values for this:\n",
    "values = {\"a\": 1, \"b\": 3, \"c\": 4, \"d\": 1, \"e\": 1, \"f\": 4, \"g\": 2, \"h\": 2, \"i\": 1, \"j\":\n",
    "6, \"k\": 4, \"l\": 2, \"m\": 3, \"n\": 1, \"o\": 2, \"p\": 4, \"q\": 10, \"r\": 1, \"s\": 1, \"t\":\n",
    "1, \"u\": 1, \"v\": 6, \"w\": 3, \"x\": 8, \"y\": 10, \"z\": 3, \"ä\": 6, \"ö\": 8, \"ü\": 6}\n",
    "An example looks like this:\n",
    "scrabble(’informatikum’)\n",
    "23\n",
    "Hint 1: The following should be the first line in your script so that the umlauts are correctly recognized:\n",
    "# -*- coding: utf-8 -*-\n",
    "Hint 2: Assume that the entry always consists of lowercase letters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4 — Scrabble - 0 Points - Programming task\n",
    "Create a function in a script that takes a word and calculates its Scrabble score. Use the following\n",
    "values for this:\n",
    "values = {\"a\": 1, \"b\": 3, \"c\": 4, \"d\": 1, \"e\": 1, \"f\": 4, \"g\": 2, \"h\": 2, \"i\": 1, \"j\":\n",
    "6, \"k\": 4, \"l\": 2, \"m\": 3, \"n\": 1, \"o\": 2, \"p\": 4, \"q\": 10, \"r\": 1, \"s\": 1, \"t\":\n",
    "1, \"u\": 1, \"v\": 6, \"w\": 3, \"x\": 8, \"y\": 10, \"z\": 3, \"ä\": 6, \"ö\": 8, \"ü\": 6}\n",
    "An example looks like this:\n",
    "scrabble(’informatikum’)\n",
    "23\n",
    "Hint 1: The following should be the first line in your script so that the umlauts are correctly recognized:\n",
    " -*- coding: utf-8 -*-\n",
    "Hint 2: Assume that the entry always consists of lowercase letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = {\"a\": 1, \"b\": 3, \"c\": 4, \"d\": 1, \"e\": 1, \"f\": 4, \"g\": 2, \"h\": 2, \"i\": 1, \"j\":\n",
    "6, \"k\": 4, \"l\": 2, \"m\": 3, \"n\": 1, \"o\": 2, \"p\": 4, \"q\": 10, \"r\": 1, \"s\": 1, \"t\":\n",
    "1, \"u\": 1, \"v\": 6, \"w\": 3, \"x\": 8, \"y\": 10, \"z\": 3, \"ä\": 6, \"ö\": 8, \"ü\": 6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scrabble_score(s: str) -> int:\n",
    "    score = 0\n",
    "    for ch in s:\n",
    "        score += values[ch]\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scrabble_score(\"informatikum\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}