{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Проверим себя"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Какого типа данных нет в языке Python:\n",
    "\n",
    "int  \n",
    "float   \n",
    "bool  \n",
    "str  \n",
    "real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Проверка\n",
    "int\n",
    "float\n",
    "bool\n",
    "str\n",
    "real"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.  Чему равно значение выражения \n",
    "```python\n",
    "int(3.45) - int(1.95)\n",
    "```\n",
    " **A**. 1  \n",
    " **B**. 1.0  \n",
    " **C**. 2  \n",
    " **D**. 2.0  \n",
    " **E**. Ошибка  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Проверка\n",
    "int(3.45) - int(1.95)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Что напечатает этот код:\n",
    "\n",
    "```python\n",
    "print(bool(1-1), bool(1+1))\n",
    "```\n",
    "\n",
    "**A**. True True  \n",
    "**B**. True False  \n",
    "**C**. False True  \n",
    "**D**. False False  \n",
    "**E**. Ошибка  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Проверка\n",
    "print(bool(1-1), bool(1+1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Что напечатает этот код:\n",
    "\n",
    "```python\n",
    "print(0.1 + 0.1 + 0.1 - 0.3)\n",
    "```\n",
    "**A**. 0.1 + 0.1 + 0.1 - 0.3  \n",
    "**B**. 0  \n",
    "**C**. 0.0  \n",
    "**D**. 5.551115123125783e-17  \n",
    "**E**. Ошибка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Проверка\n",
    "print(0.1 + 0.1 + 0.1 - 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. Что напечатает этот код:\n",
    "\n",
    "```python\n",
    "print(pi/10)\n",
    "```\n",
    "\n",
    "**A**. 0.314      \n",
    "**B**. 0.3141592653589793  \n",
    "**C**. 3.141592653589793e-1    \n",
    "**D**.  $\\pi$/10  \n",
    "**E**. Ошибка   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Проверка\n",
    "print(pi/10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Простейшие задачи\n",
    "\n",
    "В этом файле нумерация задач соответствует нумерации в электронном задачнике М.Э. Абрамяна <a href=\"http://ptaskbook.com/ru/\">Programming Taskbook</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Begin14**. Дана длина $L$ окружности. Найти ее радиус $R$ и площадь $S$ круга, ограниченного этой окружностью, учитывая, что $L = 2πR$,    $S = πR^2$. В качестве значения $π$ использовать 3.14. \n",
    "\n",
    "  \n",
    ".  \n",
    ".  \n",
    ".  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = 3.14\n",
      "r = 0.5  s = 0.785\n",
      "r=0.5 s=0.785\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "L = float(input(\"L = \"))\n",
    "pi = 3.14\n",
    "r = L/(2*pi)\n",
    "s = pi*r*r\n",
    "print('r =', r, ' s =', s)\n",
    "print(f'{r=} {s=}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Begin11**. Даны два ненулевых числа.  \n",
    "Найти сумму, разность, произведение и частное их модулей. \n",
    "\n",
    ".  \n",
    ".  \n",
    ".  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 3\n",
      "b = -5\n",
      "|3.0| + |-5.0| = 8.0\n",
      "|3.0| - |-5.0| = -2.0\n",
      "|3.0| * |-5.0| = 15.0\n",
      "|3.0| : |-5.0| = 0.6\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"a = \"))\n",
    "b = float(input(\"b = \"))\n",
    "print(f'|{a}| + |{b}| = {abs(a) + abs(b)}')\n",
    "print(f'|{a}| - |{b}| = {abs(a) - abs(b)}')\n",
    "print(f'|{a}| * |{b}| = {abs(a) * abs(b)}')\n",
    "print(f'|{a}| : |{b}| = {abs(a) / abs(b)}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Библиотека математических функций\n",
    "\n",
    "Варианты подключения\n",
    "```python\n",
    "import math \n",
    "import math as m \n",
    "from math import * \n",
    "from math import sin \n",
    "from math import sin as s # НИКОГДА так не делайте!\n",
    "```\n",
    "\n",
    "Список функций  \n",
    "`dir(math)`\n",
    "\n",
    "Помощь по всем функциям  \n",
    "`help(math)`\n",
    "\n",
    "Подсказка по конкретной функции  \n",
    "`help(sqrt)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'comb',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'dist',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'isqrt',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'perm',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'prod',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function log1p in module math:\n",
      "\n",
      "log1p(x, /)\n",
      "    Return the natural logarithm of 1+x (base e).\n",
      "    \n",
      "    The result is computed in a way which is accurate for x near zero.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.log1p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример:**  \n",
    "Найти значение выражения\n",
    "$$\\sqrt{\\ln\\left(1+\\frac{4\\pi}{7}\\right)}$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.013855097415085"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# вариант 1\n",
    "import math\n",
    "math.sqrt(math.log(1+4*math.pi/7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.013855097415085"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# вариант 2\n",
    "from math import log, sqrt, pi \n",
    "sqrt(log(1+4*pi/7)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Begin22**. Поменять местами содержимое переменных $a$ и $b$ и вывести новые значения $a$ и $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 1\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 10\n",
    "# решение:\n",
    "a,b = b,a\n",
    "\n",
    "print(a, b) # должно получиться 10 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Integer6**. Дано двузначное число. Вывести вначале его левую цифру (десятки), а затем — его правую цифру (единицы). Для нахождения десятков использовать операцию деления нацело, для нахождения единиц — операцию взятия остатка от деления. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "двузначное число: 56\n",
      "5 6\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"двузначное число: \"))\n",
    "# Решение:\n",
    "e = x%10\n",
    "d = x//10\n",
    "print(d, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Integer8**. Дано двузначное число. Вывести число, полученное при перестановке цифр исходного числа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "двузначное число: 56\n",
      "65\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"двузначное число: \"))\n",
    "# Решение\n",
    "e = x%10\n",
    "d = x//10\n",
    "print(e*10 + d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Integer9**. Дано трехзначное число. Используя одну операцию деления нацело, \n",
    "вывести первую цифру данного числа (сотни). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Решение\n",
    "n = int(input(\"трехзначное число: \"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean1**. Дано целое число $a$. Проверить истинность высказывания: «Число $a$ является положительным». "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "целое число: 0\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "a = int(input(\"целое число: \"))\n",
    "print(a>0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean7**. Даны три целых числа: $a$, $b$, $c$. Проверить истинность высказывания: «Число $b$ находится между числами $a$ и $c$». "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "целое число a: 10\n",
      "целое число b: 5\n",
      "целое число c: 20\n",
      "5 находится между 10 и 20: False\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "a = int(input(\"целое число a: \"))\n",
    "b = int(input(\"целое число b: \"))\n",
    "c = int(input(\"целое число c: \"))\n",
    "res = a<=b<=c or c<=b<=a\n",
    "print(f\"{b} находится между {a} и {c}:\",  res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "\n",
    "## Напоминание: логические операции\n",
    "\n",
    "### and\n",
    "\n",
    "| `x`     | `y`      |`x and y`|\n",
    "|:-------:|:--------:|:-------:|\n",
    "| `False` | `False`  |`False`  |\n",
    "| `False` | `True`   |`False`  |\n",
    "| `True`  | `False`  |`False`  |\n",
    "| `True`  | `True`   |`True`   |\n",
    "\n",
    "### or\n",
    "\n",
    "| `x`     | `y`      |`x or y`|\n",
    "|:-------:|:--------:|:------:|\n",
    "| `False` | `False`  |`False` |\n",
    "| `False` | `True`   |`True`  |\n",
    "| `True`  | `False`  |`True`  |\n",
    "| `True`  | `True`   |`True`  |\n",
    "\n",
    "\n",
    "### not\n",
    "\n",
    "| `x`     |  `not x` |\n",
    "|:-------:|:--------:|\n",
    "| `False` | `True`   |\n",
    "| `True`  | `False`  |\n",
    "\n",
    "\n",
    "### Приоритеты\n",
    "\n",
    "```python\n",
    "not\n",
    "and\n",
    "or\n",
    "```\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# например\n",
    "not True and True or not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "В заданиях из раздела Boolean программа должна выдавать только `True` или `False`\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "**Boolean8**. Даны два целых числа: $a$, $b$. Проверить истинность высказывания: «Каждое из чисел $a$ и $b$ нечетное»."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "целое число a: -7\n",
      "целое число b: -11\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Решение (два решения?)\n",
    "a = int(input(\"целое число a: \"))\n",
    "b = int(input(\"целое число b: \"))\n",
    "res = a%2!=0 and b%2!=0\n",
    "print(res)\n",
    "res = (a*b)%2 != 0\n",
    "print(res)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean17**. Дано целое положительное число. Проверить истинность\n",
    "высказывания: «Данное число является нечетным трехзначным». "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "целое число a: 1013\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "a = int(input(\"целое число a: \"))\n",
    "res = a%2!=0 and 99<a<1000\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean25**. Даны числа $x$, $y$. Проверить истинность высказывания: «Точка с \n",
    "координатами $(x, y)$ лежит во второй координатной четверти». "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = -5\n",
      "y = 6\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "x = float(input(\"x = \"))\n",
    "y = float(input(\"y = \"))\n",
    "res = x<0 and y>0\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "**Boolean35**. Даны координаты двух различных полей \n",
    "шахматной доски $x_1$, $y_1$, $x_2$, $y_2$ (целые числа, лежащие \n",
    "в диапазоне 1–8). Проверить истинность \n",
    "высказывания: «Данные поля имеют одинаковый \n",
    "цвет».  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1 = 1\n",
      "y1 = 1\n",
      "x2 = 2\n",
      "y2 = 1\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "x1 = int(input(\"x1 = \"))\n",
    "y1 = int(input(\"y1 = \"))\n",
    "x2 = int(input(\"x2 = \"))\n",
    "y2 = int(input(\"y2 = \"))\n",
    "res = (x1+y1+x2+y2)%2 == 0\n",
    "print(res)"
   ]
  },
  {
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}