Lernaufgaben_2020-01-18.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quotient in in Z/nZ darstellen (vertreter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zahl = x/y,  m = modulo\n",
    "def quotient_z(x, y, m):\n",
    "    from sympy import mod_inverse\n",
    "    a = mod_inverse(y, m)\n",
    "    \n",
    "    if (y * a) % m != 1:\n",
    "        return None\n",
    "    \n",
    "    return x * a % m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient_z(5, 9, 29)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zahlensysteme Konvertieren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('42', '101010', '52', '2A')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zahl = 42\n",
    "(\n",
    "    '{}'.format(zahl), # dez\n",
    "    '{:b}'.format(zahl), # bin\n",
    "    '{:o}'.format(zahl), # oct\n",
    "    '{:X}'.format(zahl) # hex\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zweierkomplement in N-bit Rechner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x = zahl, b = bits\n",
    "def twos_comp(x, b):\n",
    "    return '{:b}'.format(x + 2**b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1111111111010010'"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "twos_comp(-46, 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Teilbarkeit durch 7 (für große Zahlen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_div_seven(x):\n",
    "    current = x\n",
    "    while len(str(current)) > 2:\n",
    "        num = current % 10\n",
    "        current //= 10\n",
    "        current -= num * 2\n",
    "    return current % 7 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_div_seven(7**7*7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chinesischen Restsatz anwenden\n",
    "\n",
    "$\n",
    "x \\equiv a \\quad (\\textbf{mod} x) \\\\\n",
    "x \\equiv b \\quad (\\textbf{mod} y) \\\\\n",
    "x \\equiv c \\quad (\\textbf{mod} z)\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(mpz(27), 140)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sympy.ntheory.modular import crt\n",
    "\n",
    "a, b, c = 2, 3, 6\n",
    "x, y, z = 5, 4, 7\n",
    "\n",
    "x, restklasse = crt([x, y, z], [a, b, c])\n",
    "x, restklasse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Float als Binär darstellen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.10110011001100110\n"
     ]
    }
   ],
   "source": [
    "# periode mit strich anmerken!\n",
    "def f2bin(x, stop=16):\n",
    "    mant = []\n",
    "    for i in range(stop + 1):\n",
    "        x *= 2\n",
    "        if x > 1:\n",
    "            mant.append(1)\n",
    "            x -= 1\n",
    "        else:\n",
    "            mant.append(0)\n",
    "    print('0.{}'.format(''.join(map(str, mant))))\n",
    "    \n",
    "    \n",
    "f2bin(0.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Float biases\n",
    "\n",
    "half: 5-bit (0..31) -15 .. 16\n",
    "\n",
    "single: 8-bit (127), −126 .. +127.\n",
    "\n",
    "double: 11-bit, -1022 .. +1023 (-1023 and 1024 have special meanings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variationen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# n = anzahl objekte, k = ziehungen\n",
    "def vars_norepeat(n, k):\n",
    "    from math import factorial\n",
    "    return int(factorial(n) / factorial(n - k))\n",
    "\n",
    "vars_norepeat(10, 2) # sitzplatzverteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# n = anzahl objekte, k = ziehungen\n",
    "def vars_repeat(n, k):\n",
    "    return n ** k\n",
    "\n",
    "vars_repeat(10, 4) # SIM-Karte wechseln, du otto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binomialkoeffizient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binom_coeff(n, k):\n",
    "    from math import factorial\n",
    "    return int(factorial(n) / (factorial(k) * factorial(n - k)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13983816"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binom_coeff(49, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binomialkoeffizient mit Binom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 531441 x^{12} + 2125764 x^{11} + 3897234 x^{10} + 4330260 x^{9} + 3247695 x^{8} + 1732104 x^{7} + 673596 x^{6} + 192456 x^{5} + 40095 x^{4} + 5940 x^{3} + 594 x^{2} + 36 x + 1$"
      ],
      "text/plain": [
       "531441*x**12 + 2125764*x**11 + 3897234*x**10 + 4330260*x**9 + 3247695*x**8 + 1732104*x**7 + 673596*x**6 + 192456*x**5 + 40095*x**4 + 5940*x**3 + 594*x**2 + 36*x + 1"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sympy import symbols, expand\n",
    "x = symbols('x')\n",
    "expand( (1 + 3*x)**12 )\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import gcd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 43$"
      ],
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gcd([471694074821, 471766128373, 471757130107])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=-14, b=23\n",
      "a=-3, b=5\n",
      "a=8, b=-13\n",
      "a=19, b=-31\n"
     ]
    }
   ],
   "source": [
    "for a in range(-40, 41):\n",
    "    for b in range(-40, 41):\n",
    "        if a*18 + b*11 == 1:\n",
    "            print('a={}, b={}'.format(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=1\n",
      "a=2, b=14\n",
      "a=4, b=7\n",
      "a=5, b=11\n",
      "a=7, b=4\n",
      "a=8, b=17\n",
      "a=10, b=19\n",
      "a=11, b=5\n",
      "a=13, b=25\n",
      "a=14, b=2\n",
      "a=16, b=22\n",
      "a=17, b=8\n",
      "a=19, b=10\n",
      "a=20, b=23\n",
      "a=22, b=16\n",
      "a=23, b=20\n",
      "a=25, b=13\n",
      "a=26, b=26\n"
     ]
    }
   ],
   "source": [
    "for a in range(1, 27):\n",
    "    for b in range(1, 27):\n",
    "        if (a * b) % 27 == 1:\n",
    "            print('a={}, b={}'.format(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient_z(2, 9, 23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "23\n",
      "13\n",
      "5\n",
      "31\n",
      "11\n",
      "37\n",
      "29\n",
      "19\n",
      "25\n",
      "41\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 42):\n",
    "    from sympy import mod_inverse\n",
    "    try:\n",
    "        x = mod_inverse(i, 42)\n",
    "        print(x)\n",
    "    except:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n",
      "5 5\n",
      "7 7\n",
      "11 11\n",
      "13 13\n",
      "17 17\n",
      "19 19\n",
      "23 23\n"
     ]
    }
   ],
   "source": [
    "for x in range(24):\n",
    "    for y in range(24):\n",
    "        if (x * y) % 24 == 1:\n",
    "            print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "801\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = 0\n",
    "for x in range(1, 803):\n",
    "    if (x*x) % 802 == 1:\n",
    "        print(x)\n",
    "        count += 1\n",
    "count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sympy import prime\n",
    "prime(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0680689614440563e+19"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import log\n",
    "\n",
    "10**21 / log(10**21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}