Luku 4 numeerisia menetelmiä.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.1\n",
    "Yhtälöllä $sin(2x)=2cos(x)-1$ on välillä $]4,5[$ yksi ratkaisu. Määritä **välinpuolitusmenetelmällä** sen likiarvo 5 desimaalin tarkkuudella."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.5\n",
      "4.25\n",
      "4.375\n",
      "4.3125\n",
      "4.28125\n",
      "4.296875\n",
      "4.2890625\n",
      "4.28515625\n",
      "4.287109375\n",
      "4.2880859375\n",
      "4.28857421875\n",
      "4.288330078125\n",
      "4.2884521484375\n",
      "4.28839111328125\n",
      "4.288360595703125\n",
      "4.2883453369140625\n",
      "4.288352966308594\n",
      "Nollakohdan likiarvo: 4.2884\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "a = 4\n",
    "b = 5\n",
    "n = 4\n",
    "\n",
    "\n",
    "def f(x):\n",
    "    return 2 * math.sin(x) - 2 * math.cos(x) + 1\n",
    "\n",
    "\n",
    "while True:\n",
    "    c = (a + b) / 2\n",
    "    if f(a) * f(c) < 0:\n",
    "        b = c\n",
    "    else:\n",
    "        a = c\n",
    "    print(c)\n",
    "    if abs(b - a) < 10 ** (-(n + 1)) or f(c) == 0:\n",
    "        print(\"Nollakohdan likiarvo:\", round(c, n))\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.2\n",
    "Yhtälöllä $sin(2x)=2cos(x)-1$ on välillä $]4,5[$ yksi ratkaisu. Määritä puolitusmenetelmällä sen likiarvo 5 desimaalin tarkkuudella."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "5.0\n",
      "2.5\n",
      "1.25\n",
      "1.875\n",
      "1.5625\n",
      "1.40625\n",
      "1.484375\n",
      "1.5234375\n",
      "1.50390625\n",
      "1.494140625\n",
      "1.4990234375\n",
      "1.50146484375\n",
      "1.502685546875\n",
      "1.5032958984375\n",
      "1.50360107421875\n",
      "1.503448486328125\n",
      "1.5033721923828125\n",
      "1.5033340454101562\n",
      "1.5033531188964844\n",
      "1.5033435821533203\n",
      "Nollakohdan likiarvo: 1.5033\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "a = -10\n",
    "b = 10\n",
    "\n",
    "n = 4\n",
    "\n",
    "\n",
    "def f(x):\n",
    "    return math.exp(x) - (6 - x)\n",
    "\n",
    "\n",
    "while True:\n",
    "    c = (a + b) / 2\n",
    "    if f(a) * f(c) < 0:\n",
    "        b = c\n",
    "    else:\n",
    "        a = c\n",
    "    print(c)\n",
    "    if abs(b - a) < 1 * 10 ** (-(n + 1)) or f(c) == 0:\n",
    "        print(\"Nollakohdan likiarvo:\", round(c, n))\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.3\n",
    "Laske lukujonon \n",
    "\n",
    "$a_n=\\frac{2n-8}{n+1}$\n",
    "\n",
    "100 ensimmäistä jäsentä. Mitä lukua jäsenet näyttävät lähestyvän?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 1.900990099009901\n",
      "200 1.9502487562189055\n",
      "300 1.9667774086378738\n",
      "400 1.9750623441396509\n",
      "500 1.9800399201596806\n",
      "600 1.983361064891847\n",
      "700 1.985734664764622\n",
      "800 1.9875156054931336\n",
      "900 1.9889012208657049\n",
      "1000 1.99000999000999\n",
      "1100 1.9909173478655768\n",
      "1200 1.9916736053288926\n",
      "1300 1.9923136049192929\n",
      "1400 1.9928622412562456\n",
      "1500 1.9933377748167889\n",
      "1600 1.9937539038101186\n",
      "1700 1.9941211052322163\n",
      "1800 1.994447529150472\n",
      "1900 1.994739610731194\n"
     ]
    }
   ],
   "source": [
    "def a(n):\n",
    "    return (2 * n - 8) / (n + 1)\n",
    "\n",
    "\n",
    "for n in range(1, 2000):\n",
    "    if n % 100 == 0: # vähennetään tulostuksen määrää\n",
    "        print(n, a(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.6\n",
    "Määritä funktion $f(x)=x^5-4x-3$ ainoa nollakohta kolmen desimaalin tarkkuudella. Ratkaise yhtälö Newtonin menetelmällä."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nollakohdan likiarvo:  1.560040682404455\n",
      "Funktion arvo nollakohdan likiarvossa:  0.0\n"
     ]
    }
   ],
   "source": [
    "n = 15\n",
    "a = 1\n",
    "\n",
    "def f(x):\n",
    "    return x**5 -4*x -3\n",
    "\n",
    "def d(x):\n",
    "    return 5*x**4-4\n",
    "\n",
    "def g(x):\n",
    "    return x - f(x)/ d(x)\n",
    "\n",
    "i = 0\n",
    "x = g(a)\n",
    "while i < n:\n",
    "    x = g(x)\n",
    "    i += 1\n",
    "\n",
    "print(\"Nollakohdan likiarvo: \",x)\n",
    "print(\"Funktion arvo nollakohdan likiarvossa: \", f(x))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5600406824053061\n",
      "Varoitus: rekursio on hidas\n"
     ]
    }
   ],
   "source": [
    "# Määritellään funktio f(x)\n",
    "# Rekursiivinen ratkaisu on pythonissa hidas ja huono valinta\n",
    "def f(x):\n",
    "    return x ** 5 - 4 * x - 3\n",
    "\n",
    "\n",
    "# Määritellään funktion f(x) derivaatta fd(x)\n",
    "def fd(x):\n",
    "    return 5 * x ** 4 - 4\n",
    "\n",
    "\n",
    "# rekursiivinen ratkaisu 16 iterointikierroksella\n",
    "def newton(n):\n",
    "    if n == 1:\n",
    "        return 1 - f(1) / fd(1)\n",
    "    return newton(n - 1) - f(newton(n - 1)) / fd(newton(n - 1))\n",
    "\n",
    "\n",
    "print(newton(12))\n",
    "print(\"Varoitus: rekursio on hidas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alkuarvaus: 1\n",
      "1 .iterointikierros: 7.0\n",
      "2 .iterointikierros: 5.602116490292476\n",
      "3 .iterointikierros: 4.485946008353707\n",
      "4 .iterointikierros: 3.597344922983486\n",
      "5 .iterointikierros: 2.895289744966627\n",
      "6 .iterointikierros: 2.3515419422897255\n",
      "7 .iterointikierros: 1.9519225753093643\n",
      "8 .iterointikierros: 1.6963598142898584\n",
      "9 .iterointikierros: 1.5824209666021791\n",
      "10 .iterointikierros: 1.5607561240125074\n",
      "11 .iterointikierros: 1.560041440173885\n",
      "12 .iterointikierros: 1.5600406824053061\n",
      "13 .iterointikierros: 1.560040682404455\n",
      "14 .iterointikierros: 1.560040682404455\n",
      "15 .iterointikierros: 1.560040682404455\n",
      "16 .iterointikierros: 1.560040682404455\n",
      "tulos 16 .kierroksen jälkeen: 1.560040682404455\n"
     ]
    }
   ],
   "source": [
    "# Tapa 2:\n",
    "# Toistot\n",
    "n = 16\n",
    "# Alkuarvaus\n",
    "a = 1\n",
    "\n",
    "\n",
    "def f(x):\n",
    "    return x ** 5 - 4 * x - 3\n",
    "\n",
    "\n",
    "# Määritellään funktion f(x) derivaatta fd(x)\n",
    "def fd(x):\n",
    "    return 5 * x ** 4 - 4\n",
    "\n",
    "\n",
    "# Iteroitava funktio g(x)\n",
    "def g(x):\n",
    "    return x - f(x) / fd(x)\n",
    "\n",
    "\n",
    "laskuri = 0\n",
    "x = a\n",
    "print(\"alkuarvaus:\", x)\n",
    "while laskuri < n:\n",
    "    x = g(x)\n",
    "    laskuri += 1\n",
    "    print(laskuri, \".iterointikierros:\", x)\n",
    "print(\"tulos\", n, \".kierroksen jälkeen:\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.7\n",
    "Italialainen Fibonancci laski vuonna 1225 yhtälön $x^3+2x^2+10x-20=0$ juurelle likiarvon $x= 1.368808108$. Kuinka mones iterointikierros tuottaa samat yhdeksän desimaalia kuin Fibonaccin laskemassa likiarvossa? Käytä alkuarvausta x=1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alkuarvaus: 1\n",
      "1 .iterointikierros: 1.4117647058823528\n",
      "2 .iterointikierros: 1.3693364705882352\n",
      "3 .iterointikierros: 1.3688081886175318\n",
      "4 .iterointikierros: 1.3688081078213745\n",
      "tulos 4 .kierroksen jälkeen: 1.368808108\n"
     ]
    }
   ],
   "source": [
    "# Alkuarvaus\n",
    "a = 1\n",
    "target_ans = 1.368808108\n",
    "\n",
    "\n",
    "def f(x):\n",
    "    return x ** 3 + 2 * x ** 2 + 10 * x - 20\n",
    "\n",
    "\n",
    "# Määritellään funktion f(x) derivaatta fd(x)\n",
    "def fd(x):\n",
    "    return 3 * x ** 2 + 4 * x + 10\n",
    "\n",
    "\n",
    "# Iteroitava funktio g(x)\n",
    "def g(x):\n",
    "    return x - f(x) / fd(x)\n",
    "\n",
    "\n",
    "laskuri = 0\n",
    "x = a\n",
    "print(\"alkuarvaus:\", x)\n",
    "while abs(x - target_ans) >= 1 * 10 ** (-9):\n",
    "    x = g(x)\n",
    "    laskuri += 1\n",
    "    print(laskuri, \".iterointikierros:\", x)\n",
    "print(\"tulos\", laskuri, \".kierroksen jälkeen:\", round(x, 9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.8\n",
    "Määritä kiintopistemenetelmällä yhtälön $2^{-x}-x =0$ ainoa ratkaisu kiintopistemenetelmällä."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n",
      "2 0.5\n",
      "3 0.7071067811865476\n",
      "4 0.6125473265360659\n",
      "5 0.6540408600420695\n",
      "6 0.6354978458133738\n",
      "7 0.6437186417228691\n",
      "8 0.6400610211772397\n",
      "9 0.6416858070429983\n",
      "10 0.6409635371779633\n",
      "11 0.641284509066585\n",
      "12 0.6411418514717379\n",
      "13 0.6412052524498624\n",
      "14 0.6411770745288387\n",
      "15 0.6411895977668723\n",
      "16 0.6411840319786225\n",
      "17 0.6411865056139605\n",
      "18 0.6411854062407777\n",
      "19 0.6411858948418261\n"
     ]
    }
   ],
   "source": [
    "# yhtälön kiintopistemuoto on x=2^(-x)\n",
    "def g(x):\n",
    "    return 2 ** (-x)\n",
    "\n",
    "\n",
    "# Alkuarvaus\n",
    "x = 1\n",
    "\n",
    "for i in range(1, 20):\n",
    "    print(i, x)\n",
    "    x = g(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.9\n",
    "Määritä erotusosamäärän avulla funktion $2^x$ derivaatan arvo kohdassa $0$. Käytä $h$:n arvoa 0.1, 0.01 ja 0.001."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7177346253629313\n",
      "0.6955550056718884\n",
      "0.6933874625807412\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return 2 ** x\n",
    "\n",
    "\n",
    "x_0 = 0\n",
    "\n",
    "h = 0.1\n",
    "\n",
    "print((f(x_0 + h) - f(x_0)) / h)\n",
    "\n",
    "\n",
    "h = 0.01\n",
    "\n",
    "print((f(x_0 + h) - f(x_0)) / h)\n",
    "\n",
    "\n",
    "h = 0.001\n",
    "\n",
    "print((f(x_0 + h) - f(x_0)) / h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.10\n",
    "Funktion $f(x)=\\frac{6-x}{x+1}$ kuvaaja ja x-akseli rajaavat välillä $[1,4]$ alueen. Arvioi suorakaidesäännöllä alueen pinta-ala. Käytä laskentapisteinä osavälien keskipisteitä ja osavälien lukumäärää 50. Huomaa, että tapa 2 edellyttää pythonin sympy-kirjaston asennusta. Komentoriviltä pyydetyt arvot eivät ole välttämättömiä, arvot voi asettaa ohjelman sisällä."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4138146633849162\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return (6 - x) / (x + 1)\n",
    "\n",
    "\n",
    "a = 1\n",
    "b = 4\n",
    "\n",
    "n = 50\n",
    "\n",
    "askel = (b - a) / n\n",
    "\n",
    "x = a + askel / 2\n",
    "summa = 0\n",
    "for i in range(n):\n",
    "    # print(x)\n",
    "    summa = summa + f(x) * askel\n",
    "    x = x + askel\n",
    "print(summa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ohjelma ratkaisee funktion f(x) nollakohdan välinpuolitusmenetelmällä. Määrittele funktio ja väli, johon 0-kohta sisältyy.\n",
      "Anna funktio f(x) = 2*x\n",
      "Välin alaraja a = -1\n",
      "Välin yläraja b = 1\n",
      "Syötä kokonaislukuna, kuinka monen desimaalin tarkkuudella ratkaistaan?\n",
      "2\n",
      "Nollakohta on välillä: ] 0.0   1.0 [\n",
      "Nollakohdan likiarvo on:  0.0 2 .desimaalin tarkkuudella.\n"
     ]
    }
   ],
   "source": [
    "from sympy import *\n",
    "\n",
    "x = symbols(\"x\")\n",
    "\n",
    "print(\n",
    "    \"Ohjelma ratkaisee funktion f(x) nollakohdan välinpuolitusmenetelmällä. Määrittele funktio ja väli, johon 0-kohta sisältyy.\"\n",
    ")\n",
    "\n",
    "f = sympify(input(\"Anna funktio f(x) = \"))\n",
    "\n",
    "a = float(input(\"Välin alaraja a = \"))\n",
    "b = float(input(\"Välin yläraja b = \"))\n",
    "\n",
    "n = int(\n",
    "    input(\"Syötä kokonaislukuna, kuinka monen desimaalin tarkkuudella ratkaistaan?\\n\")\n",
    ")\n",
    "\n",
    "while True:\n",
    "    c = (a + b) / 2\n",
    "    if f.subs(x, a) * f.subs(x, c) < 0:\n",
    "        b = c\n",
    "    else:\n",
    "        a = c\n",
    "    print(\"Nollakohta on välillä: ]\", a, \" \", b, \"[\")\n",
    "    if abs(b - a) < 10 ** (-(n + 1)) or f.subs(x, c) == 0:\n",
    "        print(\"Nollakohdan likiarvo on: \", round(c, n), n, \".desimaalin tarkkuudella.\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.11\n",
    "Tutki laskimen avulla kuinka monta geometrisen jonon $3, 9, 27, 81 ...$ jäseniä on laskettava yhteen, että summa ylittää arvon $9999$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 summa: 3\n",
      "27 summa: 12\n",
      "81 summa: 39\n",
      "243 summa: 120\n",
      "729 summa: 363\n",
      "2187 summa: 1092\n",
      "6561 summa: 3279\n",
      "19683 summa: 9840\n",
      "59049 summa: 29523\n",
      "9 jäsentä on laskettava yhteen, jolloin summa on 29523\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "q = 3\n",
    "summa = 0\n",
    "laskuri = 0\n",
    "while summa <= 9999:\n",
    "    summa = summa + a\n",
    "    a = a * q\n",
    "    laskuri = laskuri + 1\n",
    "    print(a, \"summa:\", summa)\n",
    "print(laskuri, \"jäsentä on laskettava yhteen, jolloin summa on\", summa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Laske vektorien $\\overline{a}=2\\overline{i}+4\\overline{j}-\\overline{k}$ ja $\\overline{b}=5\\overline{i}-2\\overline{j}+2\\overline{k}$ pistetulo. ovatko vektorit kohtisuorassa?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vektorit ovat kohtisuorassa, koska pistetulo on  0\n"
     ]
    }
   ],
   "source": [
    "a_vektori = [2, 4, -1]\n",
    "b_vektori = [5, -2, 2]\n",
    "pistetulo = 0\n",
    "for i in range(len(a_vektori)):\n",
    "    pistetulo = pistetulo + a_vektori[i] * b_vektori[i]\n",
    "\n",
    "if pistetulo == 0:\n",
    "    print(\"Vektorit ovat kohtisuorassa, koska pistetulo on \", pistetulo)\n",
    "else:\n",
    "    print(\"Eivät ole, koska pistetulo on\", pistetulo, \"joka on erisuuuri kuin nolla.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.12\n",
    "Määritä pisteiden $A(1,5,3)$ ja $B(4,3,9)$ välinen vektori $\\overline{AB}$. Mikä on vektorin $\\overline{AB}$ pituus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a)  [3, -2, 6]\n",
      "b)  7.0\n"
     ]
    }
   ],
   "source": [
    "A = [1, 5, 3]\n",
    "B = [4, 3, 9]\n",
    "AB = [0, 0, 0]\n",
    "for i in range(len(A)):\n",
    "    AB[i] = B[i] - A[i]\n",
    "print(\"a) \", AB)\n",
    "\n",
    "etaisyys = 0\n",
    "for i in range(len(AB)):\n",
    "    etaisyys += AB[i] ** 2\n",
    "\n",
    "etaisyys = math.sqrt(etaisyys)\n",
    "print(\"b) \", etaisyys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.13\n",
    "Yo-tehtävä: Kahden positiivisen luvun $a$ ja $b$ geometrinen on $\\sqrt{ab}$.\n",
    "\n",
    "a) Anna esimerkki välin $2-100$ kahdesta luvusta, joille $\\sqrt{ab}$ on kokonaisluku.\n",
    "\n",
    "b) Satunnaislukugeneraattori arvoo toisistaan riippumatta kaksi lukua väliltä 1-100 niin, että jokaisen luvun todennäköisyys on $\\frac{1}{100}$. Mikä on todennäköisyys, että arvottujen lukujen geometrinen keskiarvo on kokonaisluku? Voit esittää simulointiin perustuvan ratkaisun."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.03149\n",
      "0.031\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import math\n",
    "\n",
    "toistot = 100000\n",
    "summa = 0\n",
    "for i in range(toistot):\n",
    "    noppa1 = random.randint(1, 100)\n",
    "    noppa2 = random.randint(1, 100)\n",
    "    if math.sqrt(noppa1 * noppa2) == int(math.sqrt(noppa1 * noppa2)):\n",
    "        # print(noppa1, noppa2, math.sqrt(noppa1 * noppa2))\n",
    "        summa = summa + 1\n",
    "print(summa / toistot)\n",
    "summa = 0\n",
    "toistot = 100 * 100\n",
    "for noppa1 in range(1, 101):\n",
    "    for noppa2 in range(1, 101):\n",
    "\n",
    "        if math.sqrt(noppa1 * noppa2) == int(math.sqrt(noppa1 * noppa2)):\n",
    "            # print(noppa1, noppa2, math.sqrt(noppa1 * noppa2))\n",
    "            summa = summa + 1\n",
    "print(summa / toistot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 6.15\n",
    "Etsi Eratostheneen seulalla kaikki 100 pienemmät alkuluvut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n",
      "73\n",
      "79\n",
      "83\n",
      "89\n",
      "97\n"
     ]
    }
   ],
   "source": [
    "n = 100\n",
    "\n",
    "l = [\"alkuluku\"] * n\n",
    "\n",
    "jakaja = 2\n",
    "\n",
    "while jakaja < n:\n",
    "    if l[jakaja] == \"alkuluku\":\n",
    "        kohta = 2 * jakaja\n",
    "        while kohta < n:\n",
    "            l[kohta] = \"ei alkuluku\"\n",
    "            kohta = kohta + jakaja\n",
    "    jakaja = jakaja + 1\n",
    "\n",
    "\n",
    "for i in range(2, n):\n",
    "    if l[i] == \"alkuluku\":\n",
    "        print(i)"
   ]
  },
  {
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}