{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Циклы\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Цикл `while`\n",
    "\n",
    "Вспомним вот эту задачу \n",
    "\n",
    "---\n",
    "**Integer8**. Дано двузначное число. Вывести число, полученное при перестановке цифр исходного числа.\n",
    "\n",
    "---\n",
    "и ее решение\n",
    "```python\n",
    "n = int(input(\"двузначное число: \"))\n",
    "e = n%10\n",
    "d = n//10\n",
    "print(10*e + d)\n",
    "```\n",
    "\n",
    "Немного подумав и удлинив код, можно записать решение и для трехзначных чисел. И даже для четырехзначных. А для 150-значных? 😱🤷‍♂️\n",
    "\n",
    "На помощь приходят **циклы**. Они дают возможность выполнить одну и ту же последовательность действий много раз. \n",
    "\n",
    "Как много? Столько, столько требуется (если, конечно, программа написана правильно). \n",
    "\n",
    "---\n",
    "\n",
    "Цикл while (\"***пока***\") позволяет выполнять последовательность одинаковых действий, пока проверяемое условие истинно.\n",
    "\n",
    "Чуть позже решим задачу типа **Integer8** для числа с любым количеством десятичных цифр. А пока задачи попроще.\n",
    "\n",
    "\n",
    "\n",
    "Синтаксис цикла `while` в простейшем случае выглядит так: \n",
    "```python\n",
    "# предыдущий код\n",
    "while условие:\n",
    "    действие 1\n",
    "    действие 1\n",
    "    ...\n",
    "    действие N\n",
    "# код после цикла    \n",
    "```\n",
    "При выполнении цикла `while` сначала проверяется истинность или ложность условия. Если условие истинно, то выполняется цепочка действий (*тело цикла* или одна *итерация*), после чего условие проверяется снова и снова выполняется эта цепочка. Так продолжается до тех пор, пока условие будет истинно. Как только условие станет ложно, работа цикла завершится и управление передастся следующей инструкции после цикла. \n",
    "\n",
    "Если условие ложно в самом начале, то цикл не начинается, управление сразу передается на следующую команду после тела цикла `while`. \n",
    "\n",
    "---\n",
    "\n",
    "В качестве примера рассмотрим задачу:  \n",
    "Дано натуральное число $m$. Вычислить $m^2$, не используя символ `*`. \n",
    "\n",
    "Умножения придется заменить сложением:\n",
    "$$ m^2 = \\underbrace{m + m + \\ldots + m}_{m \\ слагаемых}$$\n",
    "\n",
    "На каждом шаге цикла нужно увеличивать сумму, а также уменьшать оставшееся количество итераций."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = int(input(\"m: \"))\n",
    "iters_left = m      # количество оставшихся итераций\n",
    "answer = 0          # переменная для накопления суммы\n",
    "while iters_left>0:\n",
    "    answer += m\n",
    "    iters_left -= 1\n",
    "print(f'm^2 = {answer}')    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Устные упражнения:  определите результат работы программы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример 1. Что выведет программа?\n",
    "\n",
    "num = 0\n",
    "while num <= 5:\n",
    "    print (num)\n",
    "    num += 1\n",
    "\n",
    "print (\"Вне цикла\")\n",
    "print (num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример 2. Что выведет программа?\n",
    "\n",
    "number_of_loops = 0\n",
    "number_of_apples = 2\n",
    "while number_of_loops < 10:\n",
    "    number_of_apples *= 2\n",
    "    number_of_apples += number_of_loops\n",
    "    number_of_loops -= 1\n",
    "print (\"Количество яблок: \", number_of_apples)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример 3. Что выведет программа?\n",
    "\n",
    "num = 10\n",
    "while num > 3:\n",
    "    num -= 1\n",
    "    print (num) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В языке Питон, как и во многих других языках, есть специальная команда, позволяющая прервать выполнение итераций цикла и сразу перейти к командам, расположенным после тела цикла. Это команда `break`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример 4. Что выведет программа?\n",
    "\n",
    "num = 10\n",
    "while True:\n",
    "    if num < 7:\n",
    "        print ('Прерываем цикл')\n",
    "        break\n",
    "    print (num)\n",
    "    num -= 1\n",
    "print ('После цикла')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример 5. Что выведет программа?\n",
    "\n",
    "num = 100\n",
    "while not False:\n",
    "    if num < 0:\n",
    "        break\n",
    "print ('num is:', num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Порешаем задачи\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**While4**. Дано целое число $n$ (> 0). Если оно является степенью числа 3, то вывести `True`, если не является — вывести `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Решение\n",
    "n = int(input(\"целое число: \"))\n",
    "# вариант 1\n",
    "while n%3==0:\n",
    "    n //= 3\n",
    "print(n==1)    \n",
    "\n",
    "# вариант 2\n",
    "n = int(input(\"целое число: \"))\n",
    "p = 1\n",
    "while p<n:\n",
    "    p *= 3\n",
    "print(p==n)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "515377520732011331036461129765621272702107522001"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3**100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**While18**. Дано целое число $n$ (> 0). Используя операции деления нацело и взятия остатка от деления, найти количество и сумму его цифр. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Решение\n",
    "n = int(input(\"целое число: \"))\n",
    "k = 0\n",
    "s = 0\n",
    "while n>0:\n",
    "    k += 1\n",
    "    s += n%10\n",
    "    n //= 10\n",
    "print(k, s)    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Integer8** (усложненный вариант). Дано натуральное число. Вывести число, полученное при перестановке цифр исходного числа в обратном порядке.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Решение\n",
    "n = int(input(\"натуральное число: \"))\n",
    "s = 0\n",
    "while n>0:\n",
    "    s = s*10 + n%10\n",
    "    n //= 10\n",
    "print(s)    \n",
    "   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**While22**. Дано целое число $n$ (> 1). Если оно является простым, т. е. не имеет положительных делителей, кроме 1 и самого себя, то вывести `True`, иначе вывести `False`. \n",
    "\n",
    "*Работу программы можно проверить на числах 9973, 9999901 и 2147483647, которые являются простыми*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "натуральное число: 9999901\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Решение 1\n",
    "n = int(input(\"натуральное число: \"))\n",
    "k = 2\n",
    "while k<n:\n",
    "    if n%k==0:\n",
    "        break\n",
    "    k += 1    \n",
    "print(k==n)        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "натуральное число: 2147483647\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Решение 2\n",
    "n = int(input(\"натуральное число: \"))\n",
    "k = 2\n",
    "b = int(n**0.5)+1\n",
    "while k<b:\n",
    "    if n%k==0:\n",
    "        break\n",
    "    k += 1\n",
    "print(k==b)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**While24**. Дано целое число $n$ (> 1). Последовательность чисел Фибоначчи $F_k$ определяется следующим образом: \n",
    "$$\n",
    "F_1 = 1, \\  F_2 = 1,  F_k = F_{k-2} + F_{k−1},  \\  k = 3, 4, \\ldots.\n",
    "$$\n",
    "Проверить, является ли число $n$ числом Фибоначчи. Если является, то вывести `True`, если нет — вывести `False`. \n",
    "\n",
    "*Например, 17711 -  число Фибоначчи*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Решение\n",
    "n = int(input(\"натуральное число: \"))\n",
    "a, b = 1, 1\n",
    "while b<n:\n",
    "    a, b = b, a+b\n",
    "    print(b)\n",
    "print(b==n)    \n",
    "   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Цикл `for`\n",
    "\n",
    "Цикл `for`, также называемый циклом с параметром, позволяет выполнить заранее известное количество итераций. Параметр цикла, или *счетчик*, $-$ это переменная, указываемая в цикле `for`. В нем также задается множество (диапазон) значений, по которому будет пробегать эта переменная. \n",
    "```python\n",
    "# ... какой-то код до цикла\n",
    "for параметр_цикла in множество_значений:\n",
    "    действие 1\n",
    "    действие 2\n",
    "    ...\n",
    "    действие N\n",
    "# ... код после цикла  \n",
    "```\n",
    "    \n",
    "Множество значений может быть задано, например, списком, строкой или диапазоном. Начнем с последнего $-$ очень распространенного и полезного объекта `range()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "# меняйте параметры функции range, \n",
    "#         чтобы лучше понять, как она работает\n",
    "for i in  range(1,10): # [1, 10)\n",
    "    print(i, end=' ')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "    print(i, end=' ')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i, end=' ')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 "
     ]
    }
   ],
   "source": [
    "for i in range(0,10,2):\n",
    "    print(i, end=' ')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10,-1):\n",
    "    print(i)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 9 8 7 6 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "for i in range(10,0,-1): #[10, 0)\n",
    "    print(i, end=' ')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# range умеет проверять\n",
    "500 in range(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Примеры других вариантов задания множества значений параметра цикла."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Цвета российского флага:\n",
      "Цвет 1 - белый\n",
      "Цвет 2 - синий\n",
      "Цвет 3 - красный\n"
     ]
    }
   ],
   "source": [
    "# \"перечисление\" (список или кортеж)\n",
    "print('Цвета российского флага:')\n",
    "i = 1\n",
    "for color in 'белый', 'синий', 'красный':\n",
    "    print(f'Цвет {i} - {color}')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# В этом примере ниже cимвол \"\\\" позволил разорвать\n",
    "# слишком длинную строку (для удобства чтения)\n",
    "# После этого символа в строке не должно быть ничего, \n",
    "#       даже пробела\n",
    "\n",
    "i = 1\n",
    "for цвет in 'красный','оранжевый',  \\\n",
    "            'желтый', 'зеленый', 'голубой', \\\n",
    "            'синий', 'фиолетовый':\n",
    "    print(f'{i}-й цвет радуги - это {цвет}')\n",
    "    i += 1\n",
    "\n",
    "# И да, Python разрешает русские имена переменных.\n",
    "# Но не стоит этим злоупотреблять!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Название 1-го цвета радуги начинается с буквы К\n",
      "Название 2-го цвета радуги начинается с буквы О\n",
      "Название 3-го цвета радуги начинается с буквы Ж\n",
      "Название 4-го цвета радуги начинается с буквы З\n",
      "Название 5-го цвета радуги начинается с буквы Г\n",
      "Название 6-го цвета радуги начинается с буквы С\n",
      "Название 7-го цвета радуги начинается с буквы Ф\n"
     ]
    }
   ],
   "source": [
    "# Цикл по символам строки\n",
    "i = 1\n",
    "for letter in 'КОЖЗГСФ':\n",
    "    print(f'Название {i}-го цвета радуги начинается с буквы', \n",
    "          letter)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Решаем задачи"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**For7**. Даны два целых числа $a$ и $b$ ($a < b$). Найти сумму всех целых чисел от $a$ до $b$ включительно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "введите целое число a 1\n",
      "введите целое число b 5\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"введите целое число a \"))\n",
    "b = int(input(\"введите целое число b \"))\n",
    "# Решение с использованием цикла\n",
    "s = 0\n",
    "for i in range(a,b+1):\n",
    "    s += i\n",
    "print(s)    \n",
    "   \n",
    "\n",
    "# Эффективное решение\n",
    "s = sum(range(a, b+1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49999995000000 1.8900024890899658\n",
      "49999995000000 0.5700008869171143\n"
     ]
    }
   ],
   "source": [
    "# сравнение\n",
    "from time import time\n",
    "n = 10**7\n",
    "start = time()\n",
    "s = 0\n",
    "for x in range(n):\n",
    "    s += x\n",
    "finish = time()\n",
    "print(s, finish-start)\n",
    "\n",
    "\n",
    "\n",
    "# Эффективное решение\n",
    "start = time()\n",
    "s = sum(range(n))\n",
    "finish = time()\n",
    "print(s, finish-start)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**For19**. Дано целое число $n$ (> 0). Найти произведение\n",
    "$$ n! = 1·2·…·n\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Решение\n",
    "n = int(input(\"введите целое n(>0): \"))\n",
    "p = 1\n",
    "for i in range(1, n+1):\n",
    "    p *= i\n",
    "print(p)    \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000\n",
      "788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.prod(range(1,n+1)))\n",
    "\n",
    "print(math.factorial(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**For17**. Дано вещественное число $x$ и целое число $n$ (> 0). Используя один цикл (и не используя операцию возведения в степень), найти сумму \n",
    "$$\n",
    "1 + x + x^2 + x^3 + … + x^n.\n",
    "$$\n",
    "\n",
    "<font color='#0000FF'>\n",
    "    \n",
    "**дополнительно**: а почему в этой задаче действительно  важно не использовать возведение в степень?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 1\n",
      "введите целое n(>0): 10\n",
      "11.0\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "x = float(input('x: '))\n",
    "n = int(input(\"введите целое n(>0): \"))\n",
    "s = 1\n",
    "p = 1\n",
    "for i in range(1, n+1):\n",
    "    p *= x\n",
    "    s += p\n",
    "print(s)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**For24**. Дано вещественное число $x$ и целое число $n$ (> 0). Найти значение выражения \n",
    "$$\n",
    "1 − \\frac{x^2}{2!} + \\frac{x^4}{4!} − … + (−1)^n\\frac{x^{2n}}{(2n)!}\n",
    "$$\n",
    "Полученное число является приближенным значением функции $\\cos$ в точке $x$. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "введите x: 1.57\n",
      "введите целое n(>0): 5\n",
      "s = 0.0007958647579494599\n",
      "cos(1.57) = 0.0007963267107332633\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "x = float(input(\"введите x: \"))\n",
    "n = int(input(\"введите целое n(>0): \"))\n",
    "s = 0\n",
    "p = 1\n",
    "d = 1\n",
    "for i in range(n+1):\n",
    "    p *= d\n",
    "    s += p\n",
    "    d = -x*x/(2*i+1)/(2*i+2)    \n",
    "print(f'{s = }')\n",
    "from math import cos\n",
    "print(f'cos({x}) = {cos(x)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**For39**. Даны целые положительные числа $m$ и $n$ ($m<n$). Вывести все целые числа от $m$ до $n$ включительно; при этом каждое число должно выводиться столько раз, каково его значение (например, число 3 выводится 3 раза)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "введите целое m(>0): 5\n",
      "введите целое n(>0): 12\n",
      "5 5 5 5 5 \n",
      "6 6 6 6 6 6 \n",
      "7 7 7 7 7 7 7 \n",
      "8 8 8 8 8 8 8 8 \n",
      "9 9 9 9 9 9 9 9 9 \n",
      "10 10 10 10 10 10 10 10 10 10 \n",
      "11 11 11 11 11 11 11 11 11 11 11 \n",
      "12 12 12 12 12 12 12 12 12 12 12 12 \n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "m = int(input(\"введите целое m(>0): \"))\n",
    "n = int(input(\"введите целое n(>0): \"))\n",
    "for i in range(m, n+1):\n",
    "    for _ in range(i):\n",
    "        print(i, end = ' ')\n",
    "    print()    \n",
    "  \n",
    "   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Лесенка**. По данному натуральному $n\\leq9$ выведите лесенку из $n$ ступенек, $i$-я ступенька состоит из чисел от 1 до $i$ без пробелов. Например, при $n=5$ должно получиться\n",
    "```\n",
    "1\n",
    "12\n",
    "123\n",
    "1234\n",
    "12345\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "введите n(<=9): 9\n",
      "1\n",
      "12\n",
      "123\n",
      "1234\n",
      "12345\n",
      "123456\n",
      "1234567\n",
      "12345678\n",
      "123456789\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "n = int(input(\"введите n(<=9): \"))\n",
    "for i in range(1, n+1):\n",
    "    for j in range(1, i+1):\n",
    "        print(j, end='')\n",
    "    print()    \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Готовимся к контрольной \n",
    "\n",
    "**Финальная задача демонстрационного варианта контрольной работы**\n",
    "\n",
    "Назовем положительное число $n$ *квадратно-четным*, если все цифры его \n",
    "квадрата $–$ четные. Среди однозначных таких чисел два (2 и 8), примером \n",
    "двухзначных могут служить числа 20 и 68 (202 = 400, 682 = 4624), 498 $–$ это \n",
    "пример трехзначного квадратно-четного числа (4982 = 248004). \n",
    "Разработайте программу, которая для заданного натурального числа $m$ \n",
    "($m<8$) определяет, сколько существует $m$-значных квадратно-четных чисел. \n",
    "Примерная схема взаимодействия программы с пользователем: \n",
    "\n",
    "\n",
    "|Введенное число|Сообщение программы|\n",
    "|:-------------:|:------------------|\n",
    "| m = -1 | Введенное Вами число должны быть положительно. Учтите это при следующем запуске программы   |\n",
    "| m = 10 | Ваше число больше семи. Программа может работать слишком долго. В следующий раз введите число поменьше   |\n",
    "| m = 2  | Кол-во 2-значных квадратно-четных чисел = 6     |\n",
    "| m = 3  | Кол-во 3-значных квадратно-четных чисел = 18    |\n",
    "| m = 7  | Кол-во 7-значных квадратно-четных чисел = 850   |\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m:7\n",
      "850\n"
     ]
    }
   ],
   "source": [
    "# Решение\n",
    "m = int(input('m:'))\n",
    "if m<=0:\n",
    "    print('Введенное Вами число должны быть положительно. Учтите это при следующем запуске программы')\n",
    "elif m>7:    \n",
    "    print('Ваше число больше семи. Программа может работать слишком долго. В следующий раз введите число поменьше')\n",
    "else:\n",
    "    k = 0\n",
    "    for num in range(10**(m-1), 10**m):\n",
    "        k += 1\n",
    "        square = num*num\n",
    "        while square:\n",
    "            c = square%10\n",
    "            if c%2 != 0:\n",
    "                k -= 1\n",
    "                break                \n",
    "            square //= 10\n",
    "    print(k)"
   ]
  },
  {
   "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
}