{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Praktikum 4, lahendused\n", "\n", "Allolevad ülesanded on kusrsuse \"Sissejuhatus programmeerimisse Pythoni baasil\" YFX0500 **praktikumis** koos kursusega ja **kodus** iseseisvalt lahendamiseks. Kuidas lahendada allolevaid ülesandeid? Uuri ja kasuta loengus kommenteeritud süntaksi näiteid, abiinfot (Pythoni sisseehitatud funktsioon `help`, jne.), Internetti ja enda aju. Küsimuste korral, mis tekivad praktikumi ajal, pöördu õppejõu või õppejõudude poole. Iganädalaselt peale praktikumi toimumist avaldatakse ülesannete lahendused kursuse kodulehel.\n", "\n", "
Viimati uuendatud 23.09.2024.
\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 1:**\n", "\n", "Juulius Tipikas ei oska süüa. Keegi ütles talle, et ta peab päeavas sööma vähemalt ühe köögivilja ja vähemalt ühe puuvilja selleks, et ta kõht oleks täis. Juuliusel on tavaliselt külmkapis kapsad, porgandid pirnid ja ploomid. Juulius kirjutas järgmise programmi. See programm tuletab talle meelde kas ta kõht on tühi või mitte ja kas ta peab veel sööma ja mida ta võiks süüa.\n", "\n", "```python\n", "kapsas = 3 # Köögivili\n", "porgand = 1 # Köögivili\n", "pirn = 0 # Puuvili\n", "ploom = 0 # Puuvili\n", "\n", "if kapsas or porgand and pirn or ploom:\n", " print('Juulius sinu kõht on täis.')\n", "else:\n", " print('Juulius sinu kõht pole päris täis.')\n", " if kapsas == False and porgand == False:\n", " print('Söö veel vähemalt üks puuvili.')\n", " else:\n", " print('Söö veel vähemalt üks köögivili.')\n", "```\n", "\n", "Probleem on selles, et programm ei tööta. Paranda selles esinevad vead.\n", "\n", "Vihje: Uuri allpool näidatud loogikaoperaatorite `and` ja `or` tõeväärtustabeleid ja vt. Loeng 3 koodinäited.\n", "\n", "\n", "
Tabel 1. Loogikaoperaatori and tõeväärtustabel.Tabel 2. Loogikaoperaatori or tõeväärtustabel.
\n", "\n", "| x | y |`x and y`|\n", "|:-:|:-:|:-------:|\n", "| 0 | 0 | 0 |\n", "| 0 | 1 | 0 |\n", "| 1 | 0 | 0 |\n", "| 1 | 1 | 1 |\n", "\n", "\n", "\n", "| x | y |`x or y`|\n", "|:-:|:-:|:------:|\n", "| 0 | 0 | 0 |\n", "| 0 | 1 | 1 |\n", "| 1 | 0 | 1 |\n", "| 1 | 1 | 1 |\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius sinu kõht pole päris täis.\n", "Söö veel vähemalt üks köögivili.\n" ] } ], "source": [ "kapsas = 0 # Köögivili\n", "porgand = 0 # Köögivili\n", "pirn = 1 # Puuvili\n", "ploom = 2 # Puuvili\n", "\n", "if (kapsas or porgand) and (pirn or ploom): # Tehete järjekord.\n", " print('Juulius sinu kõht on täis.')\n", "else:\n", " print('Juulius sinu kõht pole päris täis.')\n", " if kapsas == False and porgand == False: \n", " print('Söö veel vähemalt üks köögivili.') # puuvili --> köögivili.\n", " else:\n", " print('Söö veel vähemalt üks puuvili.') # köögivili --> puuvili." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius sinu kõht pole päris täis.\n", "Söö veel vähemalt üks köögivili.\n" ] } ], "source": [ "kapsas = 0 # Köögivili\n", "porgand = 0 # Köögivili\n", "pirn = 1 # Puuvili\n", "ploom = 2 # Puuvili\n", "\n", "if (kapsas or porgand) and (pirn or ploom): # Tehete järjekord.\n", " print('Juulius sinu kõht on täis.')\n", "else:\n", " print('Juulius sinu kõht pole päris täis.')\n", " if kapsas == porgand == False: # Vähem operaatoreid. \n", " print('Söö veel vähemalt üks köögivili.') # puuvili --> köögivili.\n", " else:\n", " print('Söö veel vähemalt üks puuvili.') # köögivili --> puuvili." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Söö midagi! Ükskõik mida!\n" ] } ], "source": [ "# Parandame juhu kui kõik sisendid on nullid.\n", "kapsas = 0 # Köögivili\n", "porgand = 0 # Köögivili\n", "pirn = 0 # Puuvili\n", "ploom = 0 # Puuvili\n", "\n", "if (kapsas or porgand) and (pirn or ploom): # Tehete järjekord.\n", " print('Juulius sinu kõht on täis.')\n", "elif kapsas == porgand == pirn == ploom == False:\n", " print('Söö midagi! Ükskõik mida!')\n", "else:\n", " print('Juulius sinu kõht pole päris täis.')\n", " if kapsas == porgand == False:\n", " print('Söö veel vähemalt üks köögivili.') # puuvili --> köögivili.\n", " else:\n", " print('Söö veel vähemalt üks puuvili.') # köögivili --> puuvili." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 2:**\n", "\n", "Kirjuta funktsioon mis kontrollib ja teatab kasutajat sellest kas etteantud arv on täisarv (`int`), reaalne murdarv (`float`) või kompleksarv (`complex`). Lisaks peab funktsioon teisendama etteantud arvu kompleksarvuks.\n", "\n", "Vihje: Objekti andmetüüpi saab järgi vaadata kasutades sisseehitatud funktsiooni `type`. Lisaks eksisteerib sissehitatud funktsioon `isinstance`." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number is an integer. Defined in class named int.\n", "(2+0j)\n" ] } ], "source": [ "def to_complex(number):\n", " if type(number) == int:\n", " print('Number is an integer. Defined in class named int.')\n", " elif type(number) == float:\n", " print('Number is a floating-point number. Defined in class named float.')\n", " elif type(number) == complex:\n", " print('Number is a complex number. Defined in class named complex.')\n", " else:\n", " print('Not a number.')\n", " return complex(number) # Will rase an error for non-number datatype.\n", " \n", "print(to_complex(2))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Not a number.\n", "None\n" ] } ], "source": [ "def to_complex(number):\n", " if type(number) == int:\n", " print('Number is an integer. Defined in class named int.')\n", " return complex(number)\n", " elif type(number) == float:\n", " print('Number is a floating-point number. Defined in class named float.')\n", " return complex(number)\n", " elif type(number) == complex:\n", " print('Number is a complex number. Defined in class named complex.')\n", " return complex(number)\n", " else:\n", " print('Not a number.')\n", " return None\n", " \n", "print(to_complex('f'))" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number is an integer. Defined in class named int.\n", "(2+0j)\n" ] } ], "source": [ "def to_complex(number):\n", " not_number = False\n", " if type(number) == int:\n", " print('Number is an integer. Defined in class named int.')\n", " elif type(number) == float:\n", " print('Number is a floating-point number. Defined in class named float.') \n", " elif type(number) == complex:\n", " print('Number is a complex number. Defined in class named complex.')\n", " else:\n", " not_number = True\n", " print('Not a number.')\n", " \n", " if not_number:\n", " return None\n", " else:\n", " return complex(number)\n", " \n", "print(to_complex(2))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Not a number.\n", "None\n" ] } ], "source": [ "def to_complex(number):\n", " not_number = False\n", " if isinstance(number, int):\n", " print('Number is an integer. Defined in class named int.')\n", " elif isinstance(number, float):\n", " print('Number is a floating-point number. Defined in class named float.') \n", " elif isinstance(number, complex):\n", " print('Number is a complex number. Defined in class named complex.')\n", " else:\n", " not_number = True\n", " print('Not a number.')\n", " \n", " if not_number:\n", " return None\n", " else:\n", " return complex(number)\n", " \n", "print(to_complex('2'))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number is an integer. Defined in class named int.\n", "(2+0j)\n" ] } ], "source": [ "def to_complex(number):\n", " not_number = False\n", " if isinstance(number, int):\n", " print('Number is an integer. Defined in class named int.')\n", " elif isinstance(number, float):\n", " print('Number is a floating-point number. Defined in class named float.') \n", " elif isinstance(number, complex):\n", " print('Number is a complex number. Defined in class named complex.')\n", " else:\n", " not_number = True\n", " print('Not a number.')\n", " return None if not_number else complex(number)\n", " \n", "print(to_complex(2))" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(, (2+0j))\n", "(2+0j)\n" ] } ], "source": [ "# Lahend klassist.\n", "def to_complex(number):\n", " return type(number), complex(number)\n", " \n", "print(to_complex(2))\n", "\n", "new_number = to_complex(2)[1] # Kasutan ainult loodud numbrit.\n", "\n", "print(new_number)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 3:**\n", "\n", "Juulius Tipika arst kirjutas programmi. Programm näitab mis juhtub Juuliuse kehaga erinevatel temperatuuridel.\n", "\n", "```python\n", "temp = -36 # Temperatuur Celsiuse kraadides.\n", "\n", "if temp > 20:\n", " print('Juulius higistab.') \n", "elif temp > 25:\n", " print('Juulius saab kuumarabanduse.')\n", "elif temp > 30:\n", " print('Juulius saab infarkti ja insuldi ning sureb.')\n", "else:\n", " print('Juulius alajahtub ja sureb.')\n", "```\n", "\n", "Paranda programmis esinevad vead.\n", "\n", "Vihje: Uuri `if-elif-else` bloki voodiagrammi." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius higistab.\n" ] } ], "source": [ "temp = 21 # Temperatuur Celsiuse kraadides.\n", "\n", "if temp > 30: # Tingimus ei tohi olla liiga ranged.\n", " print('Juulius saab infarkti ja insuldi ning sureb.')\n", "elif temp > 25:\n", " print('Juulius saab kuumarabanduse.')\n", "elif temp > 20:\n", " print('Juulius higistab.')\n", "else:\n", " print('Juulius alajahtub ja sureb.')" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius higistab.\n" ] } ], "source": [ "temp = 21 # Temperatuur Celsiuse kraadides.\n", "\n", "temp_surm = temp > 30\n", "temp_rabandus = temp > 25\n", "temp_higi = temp > 20\n", "\n", "if temp_surm: # Tingimus ei tohi olla liiga ranged.\n", " print('Juulius saab infarkti ja insuldi ning sureb.')\n", "elif temp_rabandus:\n", " print('Juulius saab kuumarabanduse.')\n", "elif temp_higi:\n", " print('Juulius higistab.')\n", "else:\n", " print('Juulius alajahtub ja sureb.')" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius higistab.\n" ] } ], "source": [ "temp = 21 # Temperatuur Celsiuse kraadides.\n", "\n", "temp_surm = temp > 30\n", "temp_rabandus = temp > 25\n", "temp_higi = temp > 20\n", "\n", "kulmub = 'Juulius alajahtub ja sureb.'\n", "higi = 'Juulius higistab.'\n", "rabandus = 'Juulius saab kuumarabanduse.'\n", "sureb = 'Juulius saab infarkti ja insuldi ning sureb.'\n", "\n", "print(sureb if temp_surm else rabandus if temp_rabandus else higi if temp_higi else kulmub)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 4:**\n", "\n", "Lisa eelmises ülesandes kasutatud valikuavaldistele uue lisatingimuse. Lisaks olemasolevale temperatuurile lisa saju olemasolu (vihn, lumi, jne.). On teada, et lisaks eelmises ülesandes viidatud tegevustele hakkab Juulius nutma kui väljas sajab." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius nutab ja higistab.\n" ] } ], "source": [ "temp = 21 # Temperatuur Celsiuse kraadides.\n", "\n", "temp_surm = temp > 30\n", "temp_rabandus = temp > 25\n", "temp_higi = temp > 20\n", "sajab = True\n", "\n", "if temp_surm and sajab:\n", " print('Juulius nutab ja saab infarkti ja insuldi ning sureb.')\n", "elif temp_surm and not sajab:\n", " print('Juulius saab infarkti ja insuldi ning sureb.')\n", "elif temp_rabandus and sajab:\n", " print('Juulius nutab ja saab kuumarabanduse.')\n", "elif temp_rabandus and not sajab:\n", " print('Juulius saab kuumarabanduse.')\n", "elif temp_higi and sajab:\n", " print('Juulius nutab ja higistab.')\n", "elif temp_higi and not sajab:\n", " print('Juulius higistab.')\n", "else:\n", " if sajab:\n", " print('Juulius nutab ja alajahtub ja sureb.')\n", " else:\n", " print('Juulius alajahtub ja sureb.')" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius nutab ja higistab.\n" ] } ], "source": [ "temp = 21 # Temperatuur Celsiuse kraadides.\n", "sajab = True\n", "\n", "if sajab:\n", " if temp > 30:\n", " print('Juulius nutab ja saab infarkti ja insuldi ning sureb.')\n", " elif temp > 25:\n", " print('Juulius nutab ja saab kuumarabanduse.')\n", " elif temp > 20:\n", " print('Juulius nutab ja higistab.')\n", " else:\n", " print('Juulius nutab ja alajahtub ja sureb.')\n", "else:\n", " if temp > 30:\n", " print('Juulius saab infarkti ja insuldi ning sureb.')\n", " elif temp > 25:\n", " print('Juulius saab kuumarabanduse.')\n", " elif temp > 20:\n", " print('Juulius higistab.')\n", " else:\n", " print('Juulius alajahtub ja sureb.')" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius nutab ja Juulius higistab.\n" ] } ], "source": [ "temp = 21 # Temperatuur Celsiuse kraadides.\n", "sajab = True\n", "\n", "temp_surm = temp > 30\n", "temp_rabandus = temp > 25\n", "temp_higi = temp > 20\n", "\n", "if sajab:\n", " print('Juulius nutab ja ', end='')\n", " \n", "if temp_surm: \n", " print('Juulius saab infarkti ja insuldi ning sureb.')\n", "elif temp_rabandus:\n", " print('Juulius saab kuumarabanduse.')\n", "elif temp_higi:\n", " print('Juulius higistab.')\n", "else:\n", " print('Juulius alajahtub ja sureb.')" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius nutab ja Juulius higistab.\n" ] } ], "source": [ "temp = 21 # Temperatuur Celsiuse kraadides.\n", "sajab = True\n", "\n", "temp_surm = temp > 30\n", "temp_rabandus = temp > 25\n", "temp_higi = temp > 20\n", "\n", "if sajab:\n", " lisa_lause = 'Juulius nutab ja '\n", "else:\n", " lisa_lause = ''\n", " \n", "if temp_surm: \n", " print(lisa_lause + 'Juulius saab infarkti ja insuldi ning sureb.')\n", "elif temp_rabandus:\n", " print(lisa_lause + 'Juulius saab kuumarabanduse.')\n", "elif temp_higi:\n", " print(lisa_lause + 'Juulius higistab.')\n", "else:\n", " print(lisa_lause + 'Juulius alajahtub ja sureb.')" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius nutab ja Juulius saab kuumarabanduse.\n" ] } ], "source": [ "temp = 26 # Temperatuur Celsiuse kraadides.\n", "sajab = True\n", "\n", "temp_surm = temp > 30\n", "temp_rabandus = temp > 25\n", "temp_higi = temp > 20\n", "\n", "lisa_lause = 'Juulius nutab ja ' if sajab else ''\n", " \n", "if temp_surm: \n", " print(lisa_lause + 'Juulius saab infarkti ja insuldi ning sureb.')\n", "elif temp_rabandus:\n", " print(lisa_lause + 'Juulius saab kuumarabanduse.')\n", "elif temp_higi:\n", " print(lisa_lause + 'Juulius higistab.')\n", "else:\n", " print(lisa_lause + 'Juulius alajahtub ja sureb.')" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Juulius nutab ja Juulius saab kuumarabanduse.\n" ] } ], "source": [ "temp = 26 # Temperatuur Celsiuse kraadides.\n", "sajab = True\n", "\n", "temp_surm = temp > 30\n", "temp_rabandus = temp > 25\n", "temp_higi = temp > 20\n", " \n", "if temp_surm: \n", " print(('Juulius nutab ja ' if sajab else '') + 'Juulius saab infarkti ja insuldi ning sureb.')\n", "elif temp_rabandus:\n", " print(('Juulius nutab ja ' if sajab else '') + 'Juulius saab kuumarabanduse.')\n", "elif temp_higi:\n", " print(('Juulius nutab ja ' if sajab else '') + 'Juulius higistab.')\n", "else:\n", " print(('Juulius nutab ja ' if sajab else '') + 'Juulius alajahtub ja sureb.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 5:**\n", "\n", "Number `7` on väga-super-hea täisarv. Kui sisendiks on kaks täisarvu `a` ja `b`, tagasta `True` kui üks nendest on `7` või kui nende summa või vahe on `7`.\n", "\n", "Märkus: Sisseehitatud funktsioon `abs` leiab arvu absoluutväärtuse." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "def seitse_on_lahe(a, b):\n", " if a == 7 or b == 7 or a + b == 7 or a - b == 7 or b - a == 7:\n", " return True\n", " else:\n", " return False\n", "\n", "print(seitse_on_lahe(3, 10))" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "def seitse_on_lahe(x, y):\n", " if x == 7 or y == 7 or x + y == 7 or abs(x - y) == 7:\n", " return True\n", " else:\n", " return False\n", "\n", "a = 10\n", "b = 3\n", "print(seitse_on_lahe(a, b))" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "def seitse_on_lahe(a, b):\n", " return True if a == 7 or b == 7 or a + b == 7 or abs(a - b) == 7 else False\n", "\n", "x = 10\n", "y = 3\n", "print(seitse_on_lahe(x, y))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 6:**\n", "\n", "Given a day of the week encoded as 1 = Mon, 2 = Tue, 3 = Wed, ..., 7 = Sun, and a boolean indicating if we are on vacation, return a string of the form `7:00` indicating when the alarm clock should ring. Weekdays, the alarm should be `7:00` and on the weekend it should be `10:00`. Unless we are on vacation, then on weekdays it should be `10:00` and weekends it should be `off`.\n", "\n", "Expected outcome:\n", "```python\n", "alarm_clock(1, False) # --> 7:00\n", "alarm_clock(5, True) # --> 10:00\n", "alarm_clock(7, True) # --> off\n", "```" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "off\n" ] } ], "source": [ "def alarm_clock(day, vacation):\n", " if vacation:\n", " if 1 <= day <= 5:\n", " print(\"10:00\")\n", " else:\n", " print(\"off\")\n", " else:\n", " if 1 <= day <= 5:\n", " print(\"7:00\")\n", " else:\n", " print(\"10:00\")\n", "\n", "alarm_clock(7, True)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7:00\n" ] } ], "source": [ "def alarm_clock(day, vacation):\n", " if vacation and not 1 <= day <= 5:\n", " print(\"off\")\n", " elif not vacation and 1 <= day <= 5:\n", " print(\"7:00\")\n", " else: # Siin all on puhkuse tööpäevad ja tööaja nädalavahetused.\n", " print(\"10:00\") # Need sai ühe juhu alla panna.\n", "\n", "alarm_clock(1, False)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7:00\n" ] } ], "source": [ "def alarm_clock(day, vacation):\n", " weekday = 1 <= day <= 5\n", " if vacation and not weekday:\n", " print(\"off\")\n", " elif not vacation and weekday:\n", " print(\"7:00\")\n", " else: # Siin all on puhkuse tööpäevad ja tööaja nädalavahetused.\n", " print(\"10:00\") # Need sai ühe juhu alla panna.\n", "\n", "alarm_clock(1, False)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "off\n" ] } ], "source": [ "def alarm_clock(day, vacation):\n", " weekday = 1 <= day <= 5\n", " print(\"off\" if vacation and not weekday else \"7:00\" if not vacation and weekday else \"10:00\")\n", "\n", "alarm_clock(7, True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 7:**\n", "\n", "Loo kolm funktsiooni:\n", "1. Funktsioon mis tõstab etteantud arvu ruutu.\n", "2. Funktsioon mis tõstab etteantud arvu kuupi.\n", "3. Funktsioon mis juurib etteantud arvu.\n", "\n", "Kasuta lausendit `lambda`." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "# 1)\n", "ruut = lambda x: x**2\n", "print(ruut(2))" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 1)\n", "(lambda x: x**2)(2)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "# 1)\n", "print((lambda x: x**2)(2))" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "27" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 2)\n", "(lambda x: x**3)(3)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "27\n" ] } ], "source": [ "# 2)\n", "kuup = lambda x: x**3\n", "print(kuup(3))" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "27\n" ] } ], "source": [ "# 2)\n", "x = (lambda x: x**3)(3)\n", "print(x)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(8.659560562354934e-17+1.4142135623730951j)" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 3)\n", "juur = lambda x: x**0.5\n", "juur(-2)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(8.659560562354934e-17+1.4142135623730951j)" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 3)\n", "(lambda x: x**0.5)(-2)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(8.659560562354934e-17+1.4142135623730951j)\n" ] } ], "source": [ "# 3)\n", "y = (lambda x: x**0.5)(-2)\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 8:**\n", "\n", "Loo anonüümne funktsioon mis leiab kolme etteantud arvu ruutkeskväärtuse. Kasuta valemit\n", "\n", "$$x_{\\rm rms} = \\sqrt{\\frac{x_1^2 + x_2^2 + x_3^2}{3}}.$$" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.1091263510296048" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(lambda x1, x2, x3: ((x1**2 + x2**2 + x3**2) / 3)**0.5)(2, 3, 4)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.1091263510296048\n" ] } ], "source": [ "x = (lambda x1, x2, x3: ((x1**2 + x2**2 + x3**2) / 3)**0.5)(2, 3, 4)\n", "print(x)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.1091263510296048\n" ] } ], "source": [ "xrms = lambda x1, x2, x3: ((x1**2 + x2**2 + x3**2) / 3)**0.5\n", "print(xrms(2, 3, 4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 9:**\n", "\n", "Kirjuta allolev `if`-blokk `if`-`else` valikuavaldise kujule.\n", "\n", "```python\n", "num = 3.4\n", "\n", "if num > 0:\n", " print(\"Positiivne\")\n", "elif num == 0:\n", " print(\"Neutraalne\")\n", "else:\n", " print(\"Negatiivne\") \n", "```" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Positiivne'" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num = 3.4\n", "\"Positiivne\" if num > 0 else \"Neutraalne\" if num == 0 else \"Negatiivne\"" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Positiivne'" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num = 3.4\n", "(\"Positiivne\" if num > 0 else \"Neutraalne\" if num == 0 else \"Negatiivne\")" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Positiivne\n" ] } ], "source": [ "num = 3.4\n", "print(\"Positiivne\" if num > 0 else \"Neutraalne\" if num == 0 else \"Negatiivne\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 10:**\n", "\n", "Kasuta `if`-`else` valikuavaldist funktsiooni `print` argumendina. Koosta programm mis hindab arvu paarsust ja väljastab tulemuse konsooli järgmise sõnena\n", "\n", "```\n", " on paaris.\n", "```\n", "või\n", "```\n", " on paaritu.\n", "```\n", "kus `` on täisarvu numbriline väärtus." ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "123 on paaritu.\n" ] } ], "source": [ "arv = 123\n", "print(arv, 'on', ('paaris.' if arv % 2 == 0 else 'paaritu.'))" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "123 on paaritu.\n" ] } ], "source": [ "arv = 123\n", "print(arv, 'on', 'paaris.' if arv % 2 == 0 else 'paaritu.')" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "123 on paaritu.\n" ] } ], "source": [ "arv = 123\n", "print(f'{arv} on paaris.' if arv % 2 == 0 else f'{arv} on paaritu.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 11:**\n", "\n", "Kirjuta programm mis sarnaneb ja käitub sarnaselt eelmises ülesandes loodule. `if`-`else` valikuavaldise asemel kasuta `and` ja `or` operaatoreid." ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "124 on paaris.\n" ] } ], "source": [ "arv = 124\n", "print(arv, arv % 2 and 'on paaritu.' or 'on paaris.')" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "124 on paaris.\n" ] } ], "source": [ "arv = 124\n", "print(arv, 'on', arv % 2 and 'paaritu.' or 'paaris.')" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "124 on paaris.\n" ] } ], "source": [ "arv = 124\n", "print(arv % 2 and f'{arv} on paaritu.' or f'{arv} on paaris.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 12:**\n", "\n", "Kuidas töötab arvu paarsust leidev programm kujul:\n", "\n", "```python\n", "def is_even(x):\n", " if x == 0:\n", " return True\n", " else:\n", " return is_odd(x - 1)\n", "\n", "def is_odd(x):\n", " if x == 0:\n", " return False\n", " else:\n", " return is_even(x - 1)\n", "\n", "print(is_even(5)) # --> False\n", "```\n", "Tegemist on nn. vastastikuse rekursiooni algoritmiga täisarvu paarsuse määramiseks.\n", "\n", "Vihje või soovitus: Kasuta funktsiooni `print`." ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Enters is_oven x = 6\n", " Enters is_odd x = 5\n", "Enters is_oven x = 4\n", " Enters is_odd x = 3\n", "Enters is_oven x = 2\n", " Enters is_odd x = 1\n", "Enters is_oven x = 0\n", "True\n" ] } ], "source": [ "# pendeldab kahe funktsoiooni vahel kuni x = 0\n", "def is_even(x):\n", " print('Enters is_oven x =', x)\n", " if x == 0:\n", " return True\n", " else:\n", " return is_odd(x - 1)\n", "\n", "def is_odd(x):\n", " print(' Enters is_odd x =', x)\n", " if x == 0:\n", " return False\n", " else:\n", " return is_even(x - 1)\n", "\n", "print(is_even(6))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 13:** \n", "\n", "Kirjuta programm vastavalt allolevale algoritmile.\n", "\n", "Ruutvõrrandi kommenteeritud lahendamine:\n", "1. Defineeri muutujad `a`, `b`, `c` väärtustega `1`, `-5`, `4` (ruutvõrrandi kordajad).\n", "2. Juhul kui `a = 0`, väljasta vastav teade ja määra lahendiks tühimärgid (`None`) ning lõpeta programmi töö.\n", "3. Arvuta diskriminant `D` väärtus.\n", "4. Juhul kui `D > 0`, väljasta teade, et lahendid on reaalsed ja arvuta võrrandi reaalsete lahendite väärtused.\n", "5. Juhul kui `D = 0`, väljasta teade, et lahend on reaalne ja arvuta võrrandi reaalse lahendi väärtus.\n", "6. Juhul kui `D < 0`, väljasta teade, et reaalseid lahendeid ei eksisteeri ja arvuta kompleksete lahendite väärtused.\n", "7. Väljasta ruutvõrrandi lahendite väärtused.\n", "9. Muuda muutujate `a`, `b`, `c` väärtusi. Nt.\n", "```\n", "a = 1, b = 2, c = 1,\n", "a = 1, b = 2, c = 5,\n", "a = 0, b = 1, c = 1\n", "```\n", "\n", "**Teoreetiline taust:**\n", "\n", "Ruutvõrrand on antud kujul\n", "\n", "$$a x^2 + b x + c = 0,$$\n", "\n", "kus $x$ on tundmatu, $a$, $b$ ja $c$ on etteantud koefitsendid. Ruutvõrrandi üldlahend on antud kujul:\n", "\n", "$$x_\\pm = \\frac{-b \\pm \\sqrt{\\Delta}}{2 a},$$\n", "\n", "kus lahendi käitumine sõltub diskriminandi\n", "\n", "$$\\Delta = b^2 - 4ac$$\n", "\n", "väärtusest. Lahendi sõltuvus diskriminandist ja kordajatest $a$, $b$, $c$ on järgmine:\n", "\n", "1. Kui $a = 0$ siis pole tegu ruutvõrrandiga.\n", "\n", "2. Kui $\\Delta > 0$ eksisteerivad reaalsed lahendid:\n", " $$x_\\pm = \\frac{-b \\pm \\sqrt{\\Delta}}{2a}.$$\n", "\n", "3. Kui $\\Delta = 0$ siis eksisteerib üks reaalne lahend:\n", " $$x = x_+ = x_- = -\\frac{b}{2a}.$$\n", "\n", "4. Kui $\\Delta < 0$ siis eksisteerivad kompleksarvulised lahendid kujul:\n", " $$x_{\\pm} = -\\frac{b}{2a} \\pm \\frac{\\sqrt{-\\Delta}}{2a}{\\rm i},$$\n", " kus ${\\rm i}$ on imaginaarühik." ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEADE: Lahendid on kompleksed.\n", "(-1+2j) (-1-2j)\n" ] } ], "source": [ "def ruutvorrand(a, b, c):\n", " if a == 0:\n", " print('TEADE: Tegemist pole ruutvõrrandiga.')\n", " return None, None\n", " else:\n", " D = b**2 - 4 * a * c\n", " if D > 0:\n", " print('TEADE: Lahendid on reaalsed ja erinevad.')\n", " x1 = (-b + D**0.5) / (2 * a)\n", " x2 = (-b - D**0.5) / (2 * a)\n", " elif D == 0:\n", " print('TEADE: Lahend on reaalne, kus x1 = x2.')\n", " x1 = -b / (2 * a)\n", " x2 = x1\n", " else:\n", " print('TEADE: Lahendid on kompleksed.')\n", " x1 = complex(-b / (2 * a), (-D)**0.5 / (2 * a))\n", " x2 = complex(-b / (2 * a), -(-D)**0.5 / (2 * a))\n", " return x1, x2\n", "\n", "#a, b, c = 1, -5, 4 # Reaalne kaks tk.\n", "#a, b, c = 1, 2, 1 # Reaalne korduv lahend.\n", "a, b, c = 1, 2, 5 # Kompleksne.\n", "#a, b, c = 0, 1, 1 # Mitte ruutvorrand.\n", "\n", "x1, x2 = ruutvorrand(a, b, c)\n", "print(x1, x2)" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEADE: Lahendid on kompleksed.\n", "(-1+2j) (-1-2j)\n" ] } ], "source": [ "def ruutvorrand(a, b, c):\n", " if a == 0:\n", " print('TEADE: Tegemist pole ruutvõrrandiga.')\n", " return None, None\n", " else:\n", " D = b**2 - 4 * a * c\n", " if D > 0:\n", " print('TEADE: Lahendid on reaalsed ja erinevad.')\n", " x1 = (-b + D**0.5) / (2 * a)\n", " x2 = (-b - D**0.5) / (2 * a)\n", " elif D == 0:\n", " print('TEADE: Lahend on reaalne, kus x1 = x2.')\n", " x1 = -b / (2 * a)\n", " x2 = x1\n", " else:\n", " print('TEADE: Lahendid on kompleksed.')\n", " x1 = (-b + (-D)**0.5 * 1j) / (2 * a)\n", " x2 = (-b - (-D)**0.5 * 1j) / (2 * a)\n", " return x1, x2\n", "\n", "#a, b, c = 1, -5, 4 # Reaalne kaks tk.\n", "#a, b, c = 1, 2, 1 # Reaalne korduv lahend.\n", "a, b, c = 1, 2, 5 # Kompleksne.\n", "#a, b, c = 0, 1, 1 # Mitte ruutvorrand.\n", "\n", "x1, x2 = ruutvorrand(a, b, c)\n", "print(x1, x2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 14:**\n", "\n", "Üldista eelmises ülesandes kasutatud algoritmi juhule $a = 0$. Teatavasti kui $a = 0$ siis\n", "\n", "$$ax^2 + bx + c = 0 \\quad \\Rightarrow \\quad bx + c = 0.$$\n", "\n", "Lahendamine $x$ suhtes annab\n", "\n", "$$x = -\\frac{c}{b}.$$" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEADE: Tegemist pole ruutvõrrandiga.\n", "-1.0 None\n" ] } ], "source": [ "def ruutvorrand(a, b, c):\n", " if a == 0:\n", " print('TEADE: Tegemist pole ruutvõrrandiga.')\n", " x1 = -c / b\n", " return x1, None\n", " else:\n", " D = b**2 - 4 * a * c\n", " print(D)\n", " if D > 0:\n", " print('TEADE: Lahendid on reaalsed ja erinevad.')\n", " x1 = (-b + D**0.5) / (2 * a)\n", " x2 = (-b - D**0.5) / (2 * a)\n", " elif D == 0:\n", " print('TEADE: Lahend on reaalne, kus x1 = x2.')\n", " x1 = -b / (2 * a)\n", " x2 = x1\n", " else:\n", " print('TEADE: Lahendid on kompleksed.')\n", " x1 = complex(-b / (2 * a), (-D)**0.5 / (2 * a))\n", " x2 = complex(-b / (2 * a), -(-D)**0.5 / (2 * a))\n", " return x1, x2\n", "\n", "a, b, c = 0, 1, 1 # Mitte ruutvõrrand.\n", "\n", "x1, x2 = ruutvorrand(a, b, c)\n", "print(x1, x2)" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEADE: Tegemist pole ruutvõrrandiga.\n", "-1.0 None\n" ] } ], "source": [ "def ruutvorrand(a, b, c):\n", " if a == 0:\n", " print('TEADE: Tegemist pole ruutvõrrandiga.')\n", " x1 = -c / b\n", " return x1, None\n", " else:\n", " D = b**2 - 4 * a * c\n", " print(D)\n", " if D > 0:\n", " print('TEADE: Lahendid on reaalsed ja erinevad.')\n", " x1 = (-b + D**0.5) / (2 * a)\n", " x2 = (-b - D**0.5) / (2 * a)\n", " elif D == 0:\n", " print('TEADE: Lahend on reaalne, kus x1 = x2.')\n", " x1 = -b / (2 * a)\n", " x2 = x1\n", " else:\n", " print('TEADE: Lahendid on kompleksed.')\n", " x1 = (-b + (-D)**0.5 * 1j) / (2 * a)\n", " x2 = (-b - (-D)**0.5 * 1j) / (2 * a)\n", " return x1, x2\n", "\n", "a, b, c = 0, 1, 1 # Mitte ruutvõrrand.\n", "\n", "x1, x2 = ruutvorrand(a, b, c)\n", "print(x1, x2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 15:**\n", "\n", "Sabarekursiivne faktoriaali leidmine. Uuri allolevat koodi ja mõista mille poolest erineb see loengus näidatud algoritmist?\n", "\n", "```python\n", "def saba_faktoriaal(n, konteiner):\n", " if n <= 1:\n", " return konteiner\n", " else:\n", " return saba_faktoriaal(n - 1, n * konteiner)\n", "\n", "arv = 5\n", "print(saba_faktoriaal(arv, 1))\n", "```" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vahetulemus: n = 5\n", "\t konteiner = 1\n", "\t n * konteiner = 5\n", "Vahetulemus: n = 4\n", "\t konteiner = 5\n", "\t n * konteiner = 20\n", "Vahetulemus: n = 3\n", "\t konteiner = 20\n", "\t n * konteiner = 60\n", "Vahetulemus: n = 2\n", "\t konteiner = 60\n", "\t n * konteiner = 120\n", "Vahetulemus: n = 1\n", "\t konteiner = 120\n", "\t n * konteiner = 120\n", "120\n" ] } ], "source": [ "def saba_faktoriaal(n, konteiner):\n", " print('Vahetulemus: n =', n)\n", " print('\\t konteiner =', konteiner)\n", " print('\\t n * konteiner =', n * konteiner)\n", " if n <= 1:\n", " return konteiner\n", " else:\n", " return saba_faktoriaal(n - 1, n * konteiner)\n", "\n", "arv = 5\n", "print(saba_faktoriaal(arv, 1))\n", "\n", "# NB! Konteineri algväärtus peab olema `1`, sest tegu on korrutamisega.\n", "# Teadagi 0 * = 0. Seega antud funktsioon nõuab numbrit 1. \n", "# Lõpptulemuse leidmise korral tuleks loomulikult konteiner panna võrduma 1-ga." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 16:**\n", "\n", "Defineeri rekursiivne funktsioon mis leiab $n$-da Fibonacci jada liikme, kasutades lausendit `def`.\n", "\n", "Fibonacci arvude jada on selline positiivsete täisarvude jada, mis algab ühega ja mille iga järgmine liige on kahe eelmise liikme summa:\n", "\n", "$$1,\\;1,\\;2,\\;3,\\;5,\\;8,\\;13,\\;21,\\;34,\\;55,\\;89,\\;144,\\; \\ldots$$\n", "\n", "$n$-da Fibonacci jada liikme leidmise rekursiivne lahenduseeskiri on kujul:\n", "\n", "$$F(n) = F(n-2) + F(n-1),$$\n", "\n", "kus $n > 2$ ja $F(1) = F(2) = 1$. Joonis 1 näitab kuidas leida kuues Fibonacci jada liige rekursiivselt.\n", "\n", "\n", "||\n", "|:----------------------------:|\n", "|Joonis 1: Fibonacci jada liikme leidmine juhul $n = 6$.|" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8\n" ] } ], "source": [ "def F(n): # Suure tähega nime ei soovitata, PEP 8\n", " if n <= 2:\n", " return 1\n", " else:\n", " return F(n - 2) + F(n - 1)\n", "\n", "print(F(6))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 17:**\n", "\n", "Loo funktsioon mis arvutab $n$-da Fibonacci jada liikme rekursiivselt. Kasuta lausendit `lambda`." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8\n" ] } ], "source": [ "fib = lambda n: 1 if n <= 2 else fib(n - 2) + fib(n - 1)\n", "print(fib(6))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 18:**\n", "\n", "Loo kõrgemat järku funktsioon mis kasutab kahes eelmises ülesandes loodud funktsioone, et leida kahe meelevaldselt valitud Fibonacci jada liikme summa. Ära kasuta suuri $n$ väärtusi.\n", "\n", "Näide: Juhul kui $n=3$ ja $n=6$ siis\n", "\n", "$${\\rm summa} = F(3) + F(6) = 2 + 8 = 10.$$" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "def sum_F(n1, n2, func):\n", " return func(n1) + func(n2)\n", "\n", "print(sum_F(3, 6, F))" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "print(sum_F(3, 6, fib))" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "# Kasutab mõlemat.\n", "def sum_F2(n1, n2, func1, func2):\n", " return func1(n1) + func2(n2)\n", "\n", "print(sum_F2(3, 6, F, fib))" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sum_F2(3, 6, fib, F)" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(lambda n1, n2, func: func(n1) + func(n2))(3, 6, F)" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "x = (lambda n1, n2, func1, func2: func1(n1) + func2(n2))(3, 6, fib, F)\n", "print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 19:**\n", "\n", "Defineeri kõrgemat järku funktsioon mis võtab argumentidena vastu täisarvu ja kaks funktsiooni. Loodav kõrgemat järku funktsioon peab väljastama esimese funktsiooni kui arv on paaris ja teise kui arv on paaritu.\n", "\n", "Kasuta defineeritud kõrgemat järku funktsiooni koos Ülesannetes 16 ja 17 loodud funktsioonidega. Veendu loodud funktsiooni töös leides Fibonacci jada kuuenda liikme väärtuse." ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8\n" ] } ], "source": [ "def kjf(arv, func1, func2):\n", " if arv % 2 == 0:\n", " return func1\n", " else:\n", " return func2\n", " \n", "print(kjf(1, fib, F)(6))" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8\n" ] } ], "source": [ "def kjf(arv, func1, func2):\n", " if arv % 2 == 0:\n", " return func1\n", " else:\n", " return func2\n", " \n", "fun = kjf(1, fib, F)\n", "print(fun(6))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "### Kodus\n", "\n", "**Ülesanna 20:****\n", "Ülemus palkab kullerid kes toimetavad pakid järgmistesse kodudesse\n", "\n", "`kodud = [\"Juuliuse kodu\", \"Mari kodu\", \"Kerdi kodu\", \"Juulia kodu\"]`\n", "\n", "Kuna ülemus on laisk ei toimeta ta pakke isiklikult. Ta kasutab järgmist strateegiat:\n", "\n", "1. Palka kuller ja delegeeri talle kogu vastutus.\n", "2. Kui kulleri vastutusalas on rohkem kui üks maja siis luba tal palgata kaks uut kullerit ja jagada kulleritöö nenede vahel ära.\n", "3. Kui kulleri vastutuses on ainult üks maja peab ta paki isiklikult kohale toimetama.\n", "\n", "Eelmanitud strateegia on kujutatud Joonisel 2. \n", "\n", "||\n", "|:----------------------------:|\n", "|Joonis 2: Rekursiivne kulleriteenus.|" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pakk saabus sihtkohta: Juuliuse kodu\n", "Pakk saabus sihtkohta: Mari kodu\n", "Pakk saabus sihtkohta: Kerdi kodu\n", "Pakk saabus sihtkohta: Juulia kodu\n" ] } ], "source": [ "kodud = [\"Juuliuse kodu\", \"Mari kodu\", \"Kerdi kodu\", \"Juulia kodu\"]\n", "\n", "def saada_pakkid(kodud): \n", " if len(kodud) == 1:\n", " kodu = kodud[0]\n", " print(\"Pakk saabus sihtkohta:\", kodu)\n", " else:\n", " mid = len(kodud) // 2\n", " saada_pakkid(kodud[:mid])\n", " saada_pakkid(kodud[mid:])\n", " \n", "saada_pakkid(kodud)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 21**:**\n", "\n", "Täienda Ülesandes 13 loodud funktsiooni. Kontrolli kas leitud lahendid rahuldavad võrrandit. Võrdle võrrandi vasakut ja paremat poolt. Teavita kasutajat kontrolli tulemusest.\n", "\n", "Vihje/probleem: Kas vasak ja parem pool on *võrdsed*. Kas arvuti suudab tulemusi leida apsoluutse täpsusega?" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEADE: Lahendid on kompleksed.\n", "TEADE: Lahend või lahendid rahuldavad võrrandit.\n", "(-1+2j) (-1-2j)\n" ] } ], "source": [ "def polunoom(a, b, c, x): # Võrrandi vasaku poole leidmiseks.\n", " pol = a*x**2 + b*x + c\n", " return pol\n", "\n", "def ruutvorrand(a, b, c):\n", " if a == 0:\n", " print('TEADE: Tegemist pole ruutvõrrandiga.')\n", " return None, None\n", " else:\n", " D = b**2 - 4 * a * c\n", " if D > 0:\n", " print('TEADE: Lahendid on reaalsed ja erinevad.')\n", " x1 = (-b + D**0.5) / (2 * a)\n", " x2 = (-b - D**0.5) / (2 * a)\n", " elif D == 0:\n", " print('TEADE: Lahend on reaalne, kus x1 = x2.')\n", " x1 = -b / (2 * a)\n", " x2 = x1\n", " else:\n", " print('TEADE: Lahendid on kompleksed.')\n", " #x1 = complex(-b / (2*a), (-D)**0.5 / (2*a))\n", " #x2 = complex(-b / (2*a), -(-D)**0.5 / (2*a))\n", " x1 = (-b + (-D)**0.5 * 1j) / (2 * a)\n", " x2 = (-b - (-D)**0.5 * 1j) / (2 * a)\n", " \n", " vasak1 = polunoom(a, b, c, x1)\n", " vasak2 = polunoom(a, b, c, x2)\n", " eps = 1e-14 # Meid rahuldav täpsus\n", " \n", " if abs(vasak1) < eps and abs(vasak2) < eps: # Sisseehitatud funktsioon abs, kompleksarvu puhul moodul.\n", " print('TEADE: Lahend või lahendid rahuldavad võrrandit.')\n", " return x1, x2\n", " else:\n", " print('TEADE: Lahend või lahendid ei rahulda võrrandit.')\n", " return None, None\n", "\n", "#a, b, c = 1, -5, 4 # Reaalne.\n", "#a, b, c = 1, 2, 1 # Reaalne korduv lahend\n", "a, b, c = 1, 2, 5 # Kompleksne.\n", "#a, b, c = 0, 1, 1 # Mitte ruutvorrand\n", "\n", "x1, x2 = ruutvorrand(a, b, c)\n", "print(x1, x2)" ] }, { "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.11.0" } }, "nbformat": 4, "nbformat_minor": 4 }