Tunti 2 ehtolauseet ja toisto-vastauksetMH.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 ehtolauseet ja toisto\n",
    "\n",
    "Luvun 2 tehtävissä tutkitaan toistoa laskemalla lukujonoihin liittyviä esimerkkejä. Ehtolauseita tutkitaan esimerkiksi tehtävässä 2.8, jossa sanallinen tehtävänanto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ehtolauseet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ohjelman täytyy joskus suorittaa komentoja vain, jos jokin ehto täyttyy. Silloin käytetään if-rakennetta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muuttujan x arvo ohjelman lopussa: 22\n"
     ]
    }
   ],
   "source": [
    "# Testaa ohjelman tulostetta muuttamalla muuttujan x arvoa:\n",
    "x = 11\n",
    "\n",
    "# Tarkistetaan, onko muuttujan x arvo 10? Jos ehto toteutuu, niin suoritetaan sisennetty lohko\n",
    "if x == 10:\n",
    "    # kommentti\n",
    "    x = x + 2\n",
    "    print(\"Muuttujan x arvo if-ehdon sisällä :\", x)\n",
    "# muuttujan x arvoksi asetaan 2-kertaa suurempi arvo\n",
    "x = 2 * x\n",
    "print(\"Muuttujan x arvo ohjelman lopussa:\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ylläolevan koodia koodia vastaa \"Jos x on yhtä suuri kuin kymmenen, lisää siihen kaksi ja tulosta x. Lopuksi joka tapauksessa kerro x kahdella.\"\n",
    "\n",
    "Pythonissa if-lauseen syntaksissa on sana `if`, sen jälkeen jokin ehto ja kaksoispiste. If-lauseen sisällä olevat komennot sisennetään neljällä välilyönnillä.\n",
    "\n",
    "If-lausetta voi jatkaa elif- ja else-rakenteilla. Else ei ota mitään ehtoa, vaan sen jälkeen tuleva koodi suoritetaan, jos if:n jälkeistä ei suoriteta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x on pienempi tai yhtä suuri kuin 10\n",
      "Testi tulostuuko\n",
      "Lopputulostus\n"
     ]
    }
   ],
   "source": [
    "x = 9\n",
    "if x > 10:\n",
    "    print(\"x on suurempi kuin 10\")\n",
    "else:\n",
    "    print(\"x on pienempi tai yhtä suuri kuin 10\")\n",
    "    print(\"Testi tulostuuko\")\n",
    "    \n",
    "print(\"Lopputulostus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If-else-rakenne on siis joko-tai-rakenne. Aina jompi kumpi suoritetaan.\n",
    "\n",
    "Elif on lyhenne sanoista else if. Se toimii samalla if-else-rakenne, mutta sitä on helpompi ketjuttaa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x on negatiivinen\n"
     ]
    }
   ],
   "source": [
    "x = -1\n",
    "\n",
    "if x > 10:\n",
    "    print(\"x on suurempi kuin kymmenen\")\n",
    "else:\n",
    "    if x < 0:\n",
    "        print(\"x on negatiivinen\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "tarkoittaa samaa kuin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x > 10:\n",
    "    print(\"x on suurempi kuin kymmenen\")\n",
    "elif x < 0:\n",
    "    print(\"x on negatiivinen\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esimerkki if-elif-else -ketjusta. Alla oleva ohjelma laskee pisteet-muuttujan arvosta yo-arvosanan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n"
     ]
    }
   ],
   "source": [
    "pisteet = 95\n",
    "\n",
    "if pisteet < 28:\n",
    "    print(\"I\")\n",
    "elif pisteet < 40:\n",
    "    print(\"A\")\n",
    "elif pisteet < 52:\n",
    "    print(\"B\")\n",
    "elif pisteet < 64:\n",
    "    print(\"C\")\n",
    "elif pisteet < 75:\n",
    "    print(\"M\")\n",
    "elif pisteet < 90:\n",
    "    print(\"E\")\n",
    "else:\n",
    "    print(\"L\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yhdessä if-rakenteessa on oltava yksi if, niin monta elif:iä kuin tarvitaan ja korkeintaan yksi else. Jos elseä käytetään, sen täytyy olla aina viimeisenä. Esimerkiksi seuraava ohjelma ei ole sallittu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (781671904.py, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/var/folders/fw/_rn0vqpd5qqcdx33s5t8g45h0000gn/T/ipykernel_23935/781671904.py\"\u001b[0;36m, line \u001b[0;32m6\u001b[0m\n\u001b[0;31m    elif x < 0:\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "if x == 0:\n",
    "    print(\"x on 0\")\n",
    "else:\n",
    "    print(\"x ei ole 0\")\n",
    "elif x < 0:\n",
    "    print(\"x on negatiivinen\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yllä olevan esimerkin oikea rakenne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x ei ole 0\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "if x == 0:\n",
    "    print(\"x on 0\")\n",
    "elif x < 0:\n",
    "    print(\"x on negatiivinen\")\n",
    "else:\n",
    "    print(\"x ei ole 0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Tee ohjelma, joka kysyy käyttäjältä luvun ja kertoo onko luku pariton vai parillinen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Luku on pariton\n"
     ]
    }
   ],
   "source": [
    "# Kirjoita ohjelma tähän\n",
    "luku = 5\n",
    "# jaollisuus tutkitaan % operaattorilla. Se kertoo jakojäännöksen\n",
    "if luku % 2 == 0:\n",
    "    print(\"Luku on parillinen\")\n",
    "else:\n",
    "    print(\"Luku on pariton\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.1\n",
    "Toteuta lipunmyyntiohjelma, joka ottaa syötteenä iän ja tulostaa lipun hinnan. Hinnasto: \n",
    "\n",
    "\n",
    "| Ikä        | Hinta |\n",
    "|------------|-------|\n",
    "| Alle 7     | 0€    |\n",
    "| 7-17       | 1.40€ |\n",
    "| 18-69      | 2.80€ |\n",
    "| 70 tai yli | 1.40€ |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hinta on 1.40 eur\n"
     ]
    }
   ],
   "source": [
    "ikä = 71\n",
    "\n",
    "if ikä < 7:\n",
    "    print(\"Hinta on 0 euroa.\")\n",
    "elif ikä < 18:\n",
    "    print(\"Hinta on 1.4 eur.\")\n",
    "elif ikä < 70:\n",
    "    print(\"Hinta 2.80 eur\")\n",
    "else:\n",
    "    print(\"Hinta on 1.40 eur\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Silmukat\n",
    "\n",
    "Silmukoilla voi toistaa komentoja. Pythonissa on kahdenlaisia silmukoita. For-silmukat ovat hyviä listan läpikäymiseen, mutta while-silmukat ovat usein parempia. Niitä käytetään, jos toistojen määrä ei ole tiedossa etukäteen.\n",
    "\n",
    "Silmukoiden jälkeen ohjelman suoritus jatkuu normaalisti rivi riviltä."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for luku in range(10):\n",
    "    print(luku)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Neliöjuuri luvusta 0 on 0.0\n",
      "Neliöjuuri luvusta 1 on 1.0\n",
      "Neliöjuuri luvusta 2 on 1.4142135623730951\n",
      "Neliöjuuri luvusta 3 on 1.7320508075688772\n",
      "Neliöjuuri luvusta 4 on 2.0\n",
      "Neliöjuuri luvusta 5 on 2.23606797749979\n",
      "summa on : 8.382332347441762\n"
     ]
    }
   ],
   "source": [
    "# tuodaan math-kirjaston funktiot käyttöön\n",
    "import math\n",
    "\n",
    "summa = 0\n",
    "\n",
    "for i in range(6):\n",
    "    # sqrt on neliöjuuri\n",
    "    print(\"Neliöjuuri luvusta\", i, \"on\", math.sqrt(i))\n",
    "    summa  += math.sqrt(i)\n",
    "\n",
    "print(\"summa on :\",summa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ylläolevassa esimerkissä `print(i)` ajettiin kymmenen kertaa.\n",
    "\n",
    "While-silmukka toimii melkein kuin if. Esimerkki:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n",
      "64\n",
      "Ohjelman suoritus jatkuu nyt tästä kohti\n"
     ]
    }
   ],
   "source": [
    "luku = 1\n",
    "\n",
    "while luku < 100:\n",
    "    print(luku)\n",
    "    luku = luku * 2\n",
    "\n",
    "print(\"Ohjelman suoritus jatkuu nyt tästä kohti\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ohjelman suoritus jatkuu nyt tästä kohti\n"
     ]
    }
   ],
   "source": [
    "luku = 1\n",
    "\n",
    "while luku >= 100:\n",
    "    print(luku)\n",
    "    luku = luku * 2\n",
    "\n",
    "print(\"Ohjelman suoritus jatkuu nyt tästä kohti\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While-silmukassa runkoa eli silmukan sisällä olevaa koodia ajetaan niin kauan kun ehto on tosi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tehtäviä:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.2\n",
    "Aritmeettinen lukujono alkaa 5, 8, 11... \n",
    "\n",
    "a) Luettele lukujonon 30 ensimmäistä jäsentä."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 .luku on 5\n",
      "2 .luku on 8\n",
      "3 .luku on 11\n",
      "4 .luku on 14\n",
      "5 .luku on 17\n",
      "6 .luku on 20\n",
      "7 .luku on 23\n",
      "8 .luku on 26\n",
      "9 .luku on 29\n",
      "10 .luku on 32\n",
      "11 .luku on 35\n",
      "12 .luku on 38\n",
      "13 .luku on 41\n",
      "14 .luku on 44\n",
      "15 .luku on 47\n",
      "16 .luku on 50\n",
      "17 .luku on 53\n",
      "18 .luku on 56\n",
      "19 .luku on 59\n",
      "20 .luku on 62\n",
      "21 .luku on 65\n",
      "22 .luku on 68\n",
      "23 .luku on 71\n",
      "24 .luku on 74\n",
      "25 .luku on 77\n",
      "26 .luku on 80\n",
      "27 .luku on 83\n",
      "28 .luku on 86\n",
      "29 .luku on 89\n",
      "30 .luku on 92\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "d = 3\n",
    "\n",
    "for i in range(30):\n",
    "    #for lohko alkaa\n",
    "    print(i+1,\".luku on\",a)\n",
    "    a = a + d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Mikä on sadan ensimmäisen jäsenen summa?\n",
    "\n",
    "$$\n",
    "S_n = \\frac{a_1 + a_n}{2}\\cdot n\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kaikkien lukujen suma on 15350\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "d = 3\n",
    "summa = 0\n",
    "\n",
    "for i in range(100):\n",
    "    #print(i+1,\".luku on\", a)\n",
    "    summa = summa + a\n",
    "    a = a + d\n",
    "\n",
    "print(\"Kaikkien lukujen suma on\", summa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Kuinka moni jonon jäsenistä on pienempi kuin 500?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lukujen lukumäärä on 165\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "d = 3\n",
    "\n",
    "määrä = 0\n",
    "\n",
    "while a < 500:\n",
    "    #print(a)\n",
    "    a = a + d\n",
    "    määrä = määrä + 1\n",
    "\n",
    "print(\"Lukujen lukumäärä on\", määrä)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.3\n",
    "Luettele kaikki luvut väliltä 1 - 50, mutta jos luku on jaollinen viidellä, tulosta luvun sijaan \"foo\". Jos luku on jaollinen seitsemällä, tulosta luvun sijaan \"bar\". Jos luku on jaollinen sekä viidellä että seitsemällä tulosta \"foobar\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "foo\n",
      "6\n",
      "bar\n",
      "8\n",
      "9\n",
      "foo\n",
      "11\n",
      "12\n",
      "13\n",
      "bar\n",
      "foo\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "foo\n",
      "bar\n",
      "22\n",
      "23\n",
      "24\n",
      "foo\n",
      "26\n",
      "27\n",
      "bar\n",
      "29\n",
      "foo\n",
      "31\n",
      "32\n",
      "33\n",
      "34\n",
      "foobar\n",
      "36\n",
      "37\n",
      "38\n",
      "39\n",
      "foo\n",
      "41\n",
      "bar\n",
      "43\n",
      "44\n",
      "foo\n",
      "46\n",
      "47\n",
      "48\n",
      "bar\n",
      "foo\n"
     ]
    }
   ],
   "source": [
    "for luku in range(1, 50+1):\n",
    "    if luku % 35 == 0:\n",
    "        print(\"foobar\")\n",
    "    elif luku % 5 == 0:\n",
    "        print(\"foo\")\n",
    "    elif luku % 7 == 0:\n",
    "        print(\"bar\")\n",
    "    else:\n",
    "        print(luku)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.4\n",
    "Laske kaikkien nelinumeroisten seitsemällä jaollisten lukujen summa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7:lla jaollisten 4-numeroisten lukujen summa: 7071071\n"
     ]
    }
   ],
   "source": [
    "# 1.nelinumeroinen 7:lla jaollinen luku on 1001, koska 1001 / 7 = 143\n",
    "# viimeinen 4-numeroinen luku on 9999\n",
    "# kuvataan luvut lukujonona\n",
    "\n",
    "a = 1001\n",
    "d = 7\n",
    "\n",
    "summa = 0\n",
    "\n",
    "while a < 10000:\n",
    "    summa = summa + a\n",
    "    a = a + d\n",
    "\n",
    "print(\"7:lla jaollisten 4-numeroisten lukujen summa:\", summa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tehtävän voi ratkaista myös seuraavasti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7:lla jaollisten 4-numeroisten lukujen summa on  7071071\n"
     ]
    }
   ],
   "source": [
    "summa = 0\n",
    "\n",
    "for luku in range(1000, 9999+1):\n",
    "    #print(luku)\n",
    "    if luku % 7 == 0:\n",
    "        summa = summa + luku\n",
    "        #print(\"bingo\")\n",
    "\n",
    "\n",
    "print(\"7:lla jaollisten 4-numeroisten lukujen summa on \",summa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.5\n",
    "Tutki, kuinka monta geometrisen lukujonon 3, 9, 27, 81, ... jäsentä on laskettava yhteen, että summan arvo ylittää 9999?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lukujen lukumäärä on  9\n",
      "summa 29523\n"
     ]
    }
   ],
   "source": [
    "# Geometrinen lukujono\n",
    "a = 3\n",
    "#suhdeluku, jolla kerrotaan\n",
    "q = 3\n",
    "\n",
    "summa = 0\n",
    "määrä = 0\n",
    "\n",
    "while summa < 9999:\n",
    "    #print(\"luku on \", a)\n",
    "    summa = summa + a\n",
    "    #print(\"summa on\", summa)\n",
    "    a = a*q\n",
    "    määrä = määrä + 1 \n",
    "    \n",
    "print(\"Lukujen lukumäärä on \", määrä)\n",
    "print(\"summa\", summa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.6\n",
    "Ohjelma kysyy käyttäjältä suorakulmion leveyden ja korkeuden. Tämän jälkeen ohjelma kysyy haluatko laskea p=piirin  vai a=pinta-alan ? Tämän jälkeen ohjelma tulostaa tiedon näytölle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Syötä korkeus h: 12\n",
      "Syötä leveys l: 10\n",
      "Lasketaanko piiri (p) vai pinta-ala (a)? p\n",
      "Piiri on 44.0\n"
     ]
    }
   ],
   "source": [
    "# Luetaan käyttäjän syöte komentoriviltä\n",
    "h = float(input(\"Syötä korkeus h: \"))\n",
    "l = float(input(\"Syötä leveys l: \"))\n",
    "\n",
    "operaatio = input(\"Lasketaanko piiri (p) vai pinta-ala (a)? \")\n",
    "\n",
    "if operaatio == \"p\":\n",
    "    print(\"Piiri on\", 2 * h + 2 * l)\n",
    "elif operaatio == \"a\":\n",
    "    print(\"Pinta-ala on\", h * l)\n",
    "else:\n",
    "    print(\"Virheellinen syöte\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.7\n",
    "Kunnan väkiluku kasvoi 1.2%ia vuodessa. Vuonna 2015 kunnassa oli 24500 asukasta. Tutki minä vuonna kunnan asukasluku ylittää 30 000 asukkaan rajan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vuonna 2015 kunnassa on 24500 asukasta\n",
      "Vuonna 2016 kunnassa on 24794 asukasta\n",
      "Vuonna 2017 kunnassa on 25092 asukasta\n",
      "Vuonna 2018 kunnassa on 25393 asukasta\n",
      "Vuonna 2019 kunnassa on 25697 asukasta\n",
      "Vuonna 2020 kunnassa on 26006 asukasta\n",
      "Vuonna 2021 kunnassa on 26318 asukasta\n",
      "Vuonna 2022 kunnassa on 26634 asukasta\n",
      "Vuonna 2023 kunnassa on 26953 asukasta\n",
      "Vuonna 2024 kunnassa on 27277 asukasta\n",
      "Vuonna 2025 kunnassa on 27604 asukasta\n",
      "Vuonna 2026 kunnassa on 27935 asukasta\n",
      "Vuonna 2027 kunnassa on 28270 asukasta\n",
      "Vuonna 2028 kunnassa on 28610 asukasta\n",
      "Vuonna 2029 kunnassa on 28953 asukasta\n",
      "Vuonna 2030 kunnassa on 29300 asukasta\n",
      "Vuonna 2031 kunnassa on 29652 asukasta\n",
      "Vuonna 2032 kunnassa on 30008 asukasta, eli yli 30 000 asukasta.\n"
     ]
    }
   ],
   "source": [
    "a = 24500 # vuosi 2015\n",
    "q = 1.012\n",
    "vuosi = 2015\n",
    "\n",
    "while a < 30000:\n",
    "    print(\"Vuonna\", vuosi, \"kunnassa on\", round(a), \"asukasta\")\n",
    "    vuosi = vuosi + 1\n",
    "    a = a * q\n",
    "print(\"Vuonna\", vuosi, \"kunnassa on\", round(a), \"asukasta, eli yli 30 000 asukasta.\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.8\n",
    "Kännykkäliittymän A kuukausimaksu on  4 euroa ja puhelumaksu on 0.09 euroa/min. Liittymässä B ei ole kuukausimaksua, mutta  puhelumaksu on 0.12 euroa/min.  Tee ohjelma, joka kysyy käyttäjältä kuukauden puheaikaa, ja ilmoittaa käyttäjälle kumpi liittymä A vai B kannattaa valita ja mitä kuukauden puhelut maksavat. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Montako minuuttia puhut kuussa? 10\n",
      "10.0\n",
      "kannattaa valita b\n",
      "hinta olisi 1.2 €\n"
     ]
    }
   ],
   "source": [
    "minuutit = float(input(\"Montako minuuttia puhut kuussa? \"))\n",
    "\n",
    "print(minuutit)\n",
    "\n",
    "a_hinta = 4 + 0.09 * minuutit\n",
    "b_hinta = 0.12 * minuutit\n",
    "\n",
    "if a_hinta < b_hinta:\n",
    "    print(\"kannattaa valita a\")\n",
    "    print(\"hinta on\", a_hinta, \"€\")\n",
    "elif b_hinta < a_hinta:\n",
    "    print(\"kannattaa valita b\")\n",
    "    print(\"hinta olisi\", b_hinta, \"€\")\n",
    "else:\n",
    "    print(\"ei ole väliä mitä valitsee\")\n",
    "    print(\"hinnat olisivat\", a_hinta, \"€ ja\", b_hinta, \"€\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.9\n",
    "Tarkastellaan lukujonoa $a_n =15n + 120, n=1, 2,3\\dots$  Kirjoita ohjelma, joka vastaa seuraaviin kysymyksiin:\n",
    "\n",
    "a) Ohjelma tulostaa jonon 10 ensimmäistä jäsentä.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "135\n",
      "150\n",
      "165\n",
      "180\n",
      "195\n",
      "210\n",
      "225\n",
      "240\n",
      "255\n",
      "270\n"
     ]
    }
   ],
   "source": [
    "# Jonon 1.jäsen sadaan kun n=1, eli a1= 15*1+120\n",
    "a = 120 + 15\n",
    "d = 15\n",
    "for i in range(10):\n",
    "    print(a)\n",
    "    a = a + d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Onko luku  12 455 lukujonon jäsen?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12015\n",
      "12030\n",
      "12045\n",
      "12060\n",
      "12075\n",
      "12090\n",
      "12105\n",
      "12120\n",
      "12135\n",
      "12150\n",
      "12165\n",
      "12180\n",
      "12195\n",
      "12210\n",
      "12225\n",
      "12240\n",
      "12255\n",
      "12270\n",
      "12285\n",
      "12300\n",
      "12315\n",
      "12330\n",
      "12345\n",
      "12360\n",
      "12375\n",
      "12390\n",
      "12405\n",
      "12420\n",
      "12435\n",
      "12450\n",
      "12465\n",
      "Ei ole lukujonon jäsen\n"
     ]
    }
   ],
   "source": [
    "a = 120 + 15\n",
    "d = 15\n",
    "\n",
    "# tulostetaan jäseniä lukujonosta luvusta 12015 alkaen\n",
    "while a <= 12455:\n",
    "    a = a + d\n",
    "    if a > 12000:\n",
    "        print(a)\n",
    "# tutkitaan onko luku 12455 jonon jäsen      \n",
    "if (12455 - 135) % 15 == 0:\n",
    "    print(\"On lukujonon jäsen\")\n",
    "else:\n",
    "    print(\"Ei ole lukujonon jäsen\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c)  Mistä jäsenestä alkaen lukujonon jäsenet ovat suurempia kuin  1000?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "135 1\n",
      "150 2\n",
      "165 3\n",
      "180 4\n",
      "195 5\n",
      "210 6\n",
      "225 7\n",
      "240 8\n",
      "255 9\n",
      "270 10\n",
      "285 11\n",
      "300 12\n",
      "315 13\n",
      "330 14\n",
      "345 15\n",
      "360 16\n",
      "375 17\n",
      "390 18\n",
      "405 19\n",
      "420 20\n",
      "435 21\n",
      "450 22\n",
      "465 23\n",
      "480 24\n",
      "495 25\n",
      "510 26\n",
      "525 27\n",
      "540 28\n",
      "555 29\n",
      "570 30\n",
      "585 31\n",
      "600 32\n",
      "615 33\n",
      "630 34\n",
      "645 35\n",
      "660 36\n",
      "675 37\n",
      "690 38\n",
      "705 39\n",
      "720 40\n",
      "735 41\n",
      "750 42\n",
      "765 43\n",
      "780 44\n",
      "795 45\n",
      "810 46\n",
      "825 47\n",
      "840 48\n",
      "855 49\n",
      "870 50\n",
      "885 51\n",
      "900 52\n",
      "915 53\n",
      "930 54\n",
      "945 55\n",
      "960 56\n",
      "975 57\n",
      "990 58\n",
      "Vastaus: Jonon 59 jäsen, eli luku 1005 on suurempi kuin luku 1000\n"
     ]
    }
   ],
   "source": [
    "a = 120 + 15\n",
    "d = 15\n",
    "\n",
    "\n",
    "laskuri = 1\n",
    "\n",
    "while a <= 1000:\n",
    "    print(a,laskuri)\n",
    "    laskuri = laskuri + 1\n",
    "    a = a + d\n",
    "print(\"Vastaus: Jonon\",laskuri,\"jäsen, eli luku\", a, \"on suurempi kuin luku 1000\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtäviä 2.10\n",
    "\n",
    "Jaa luku 29282 alkutekijöihin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 on alkutekijä\n",
      "11 on alkutekijä\n",
      "11 on alkutekijä\n",
      "11 on alkutekijä\n",
      "11 on alkutekijä\n"
     ]
    }
   ],
   "source": [
    "n = 29282\n",
    "jakaja = 2\n",
    "\n",
    "# Käydään läpi kaikki lukua n pienemmät luvut\n",
    "\n",
    "while jakaja < n + 1:\n",
    "    \n",
    "    # Kokeillaan, jakaako jakaja luvun n\n",
    "    \n",
    "    if n % jakaja == 0:\n",
    "        \n",
    "        # Jos jakaja on alkutekijä, tulostetaan se ja aloitetaan läpikäynti alusta\n",
    "        \n",
    "        print(jakaja, \"on alkutekijä\")\n",
    "        n = n // jakaja\n",
    "        jakaja = 2\n",
    "    else:\n",
    "        \n",
    "        # Jos jakaja ei ole alkutekijä, siirrytään seuraavaan lukuun\n",
    "        \n",
    "        jakaja = jakaja + 1\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29282"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tarkistus\n",
    "2*11**4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tehtävä 2.11\n",
    "\n",
    "Vuosi on karkausvuosi, jos se on jaollinen 4:llä. Kuitenkin jos vuosi on jaollinen 100:lla, se on karkausvuosi vain silloin, kun se on myös jaollinen 400:lla.\n",
    "Tee ohjelma, joka tulostaa kaikki karkausvuodet välillä 1800...2200, jokainen vuosi omalla rivillään.\n",
    "\n",
    "Tuloste alkaa siis seuraavasti:\n",
    "\n",
    "1808\n",
    "1812\n",
    "1816\n",
    "1820\n",
    "1824\n",
    "1828\n",
    "1832\n",
    "1836\n",
    "1840\n",
    "1844\n",
    "1848\n",
    "1852\n",
    "1856\n",
    "1860\n",
    "1864\n",
    "1868\n",
    "1872\n",
    "1876"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1804\n",
      "1808\n",
      "1812\n",
      "1816\n",
      "1820\n",
      "1824\n",
      "1828\n",
      "1832\n",
      "1836\n",
      "1840\n",
      "1844\n",
      "1848\n",
      "1852\n",
      "1856\n",
      "1860\n",
      "1864\n",
      "1868\n",
      "1872\n",
      "1876\n",
      "1880\n",
      "1884\n",
      "1888\n",
      "1892\n",
      "1896\n",
      "1904\n",
      "1908\n",
      "1912\n",
      "1916\n",
      "1920\n",
      "1924\n",
      "1928\n",
      "1932\n",
      "1936\n",
      "1940\n",
      "1944\n",
      "1948\n",
      "1952\n",
      "1956\n",
      "1960\n",
      "1964\n",
      "1968\n",
      "1972\n",
      "1976\n",
      "1980\n",
      "1984\n",
      "1988\n",
      "1992\n",
      "1996\n",
      "2000\n",
      "2004\n",
      "2008\n",
      "2012\n",
      "2016\n",
      "2020\n",
      "2024\n",
      "2028\n",
      "2032\n",
      "2036\n",
      "2040\n",
      "2044\n",
      "2048\n",
      "2052\n",
      "2056\n",
      "2060\n",
      "2064\n",
      "2068\n",
      "2072\n",
      "2076\n",
      "2080\n",
      "2084\n",
      "2088\n",
      "2092\n",
      "2096\n",
      "2104\n",
      "2108\n",
      "2112\n",
      "2116\n",
      "2120\n",
      "2124\n",
      "2128\n",
      "2132\n",
      "2136\n",
      "2140\n",
      "2144\n",
      "2148\n",
      "2152\n",
      "2156\n",
      "2160\n",
      "2164\n",
      "2168\n",
      "2172\n",
      "2176\n",
      "2180\n",
      "2184\n",
      "2188\n",
      "2192\n",
      "2196\n"
     ]
    }
   ],
   "source": [
    "for vuosi in range(1800,2201):\n",
    "    if vuosi % 4 == 0 and (vuosi % 100 != 0 or vuosi % 400 == 0):\n",
    "        print(vuosi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tehtävä 2.12\n",
    "\n",
    "Kalle on vuoden vanhempi kuin Jaakko, joka taas on vuoden vanhempi kuin Aapo. Heidän ikiensä tulo on 42840. Kuinka vanha Aapo on?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n"
     ]
    }
   ],
   "source": [
    "# Oletetaan että Aapon ikä x on <150 vuotta.\n",
    "for x in range(150):\n",
    "    if x*(x+1)*(x+2) == 42840:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tehtävä 2.13\n",
    "\n",
    "Etsi kokonaisluku x, joka ratkaisee yhtälön $x^3 - 60x^2 + 60x = 59$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59\n"
     ]
    }
   ],
   "source": [
    "#Ratkaisu 1,\n",
    "x = 0\n",
    "löytyi = False\n",
    "\n",
    "while not löytyi:\n",
    "    if x**3 -60*x**2+60*x == 59:\n",
    "        print(x)\n",
    "        löytyi = True\n",
    "    x = x +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59\n"
     ]
    }
   ],
   "source": [
    "# ratkaisu 2\n",
    "# etsitään ratkaisua väliltä 0..1999\n",
    "for x in range(2000):\n",
    "    if x**3-60*x**2+60*x == 59:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tehtävä 2.14\n",
    "\n",
    "Mikä on pienin positiivinen kokonaisluku, joka on jaollinen luvuilla 12, 34 ja 56?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2856\n"
     ]
    }
   ],
   "source": [
    "# tehtävässä harjoitellaan silmukan keskeyttämistä break -komennolla\n",
    "for x in range(1,20000):\n",
    "    if x%12 == 0 and x%34 == 0 and x%56 == 0:\n",
    "        print(x)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.15\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": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jonon  1 jäsen on luku a  3\n",
      "Jonon jäsenten summa on: 3\n",
      "Jonon  2 jäsen on luku a  9\n",
      "Jonon jäsenten summa on: 12\n",
      "Jonon  3 jäsen on luku a  27\n",
      "Jonon jäsenten summa on: 39\n",
      "Jonon  4 jäsen on luku a  81\n",
      "Jonon jäsenten summa on: 120\n",
      "Jonon  5 jäsen on luku a  243\n",
      "Jonon jäsenten summa on: 363\n",
      "Jonon  6 jäsen on luku a  729\n",
      "Jonon jäsenten summa on: 1092\n",
      "Jonon  7 jäsen on luku a  2187\n",
      "Jonon jäsenten summa on: 3279\n",
      "Jonon  8 jäsen on luku a  6561\n",
      "Jonon jäsenten summa on: 9840\n",
      "Jonon  9 jäsen on luku a  19683\n",
      "Jonon jäsenten summa on: 29523\n",
      "Summa ylittää 9999 ensimmäisen kerran kun summa on 29523\n",
      "Tällöin lukujonon jäsenten määrä on 9\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "q = 3\n",
    "summa = 0\n",
    "määrä = 0\n",
    "\n",
    "while summa < 9999:\n",
    "    print(\"Jonon \",määrä+1,\"jäsen on luku a \", a)\n",
    "    summa = summa + a\n",
    "    print(\"Jonon jäsenten summa on:\", summa)\n",
    "    a = a * q\n",
    "    määrä = määrä + 1\n",
    "\n",
    "print(\"Summa ylittää 9999 ensimmäisen kerran kun summa on\", summa)\n",
    "print(\"Tällöin lukujonon jäsenten määrä on\", määrä)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tehtävä 2.15\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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "10\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "a = 4\n",
    "b = 25\n",
    "print(a*b)\n",
    "print(int(sqrt(a*b)))\n",
    "print(int(3.25))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.031\n"
     ]
    }
   ],
   "source": [
    "#a)-kohdassa esimerkiksi luvut 4 ja 25, joiden tulo on 100 ja tulon neliöjuuri 10\n",
    "#b) käydään läpi kaikki yhdistelmät\n",
    "import random\n",
    "import math\n",
    "\n",
    "\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": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.030959\n"
     ]
    }
   ],
   "source": [
    "# ratkaisu 2 eli simulointi, arvotaan luvut ja testataan. Kun toistoja on todella paljon, niin saadaan tilastollinen\n",
    "#tulos joka on lähellä oikeaa ratkaisua. Muuta toistojen määrää isommaksi, niin saat tarkemman tuloksen\n",
    "toistot = 1000000\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)"
   ]
  }
 ],
 "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
}