exerciseList=[
  {
    "id": "1",
    "title": "Напишіть програму, яка отримує три цілих числа, введені з клавіатури (кожне число вводиться на окремому рядку), і друкує на екрані їх суму, добуток, результат піднесення першого числа до степеня різниці другого і третього чисел.",
    "inpdata": "2\n3\n6",
    "outdata": "11\n36\n0.125",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nprint(a + b + c)\nprint(a * b * c)\nprint(a ** (b - c))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "2",
    "title": "Напишіть програму, яка приймає ціле число n і обчислює значення виразу n + nn + nnn.",
    "inpdata": "5\n3\n1",
    "outdata": "615\n369\n123",
    "solution": "n = input()\nresult = int(n) + int(n*2) + int(n*3)\nprint(result)\nprint(int(n), '+', int(n*2), '+', int(n*3), '=', result)  # візуалізація додавання",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "3",
    "title": "Напишіть програму, яка отримує такі дані: ім’я, вік, хобі, введені з клавіатури (вводяться на окремих рядках), і друкує на екрані одним повідомленням повну інформацію на основі введених даних.",
    "inpdata": "Lord Voldemort\n72\nMagic",
    "outdata": "My name is Lord Voldemort. I am 72 and my hobby is Magic.",
    "solution": "name = input('What\\'s your name? ')\nage = int(input('How old are you? '))\nhobby = input('What is your hobby? ')\nprint('My name is ' + name + '. I am ' + str(age) + ' and my hobby is ' + hobby + '.')",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "4",
    "title": "Напишіть програму, яка зчитує довжину основи та висоту прямокутного трикутника (цілі числа), обчислює площу і друкує її значення на екрані у відформатованому вигляді (два символи після десяткової крапки). Кожен параметр вводиться на окремому рядку.",
    "inpdata": "3\n4",
    "outdata": "6.00",
    "solution": "c = int(input())\nh = int(input())\ns = (c * h) / 2\nprint('{0:.2f}'.format(s))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "5",
    "title": "Напишіть програму, яка зчитує ціле число, і друкує попереднє та наступне числа відносно введеного.",
    "inpdata": "179",
    "outdata": "The next number for the number 179 is 180.\nThe previous number for the number 179 is 178.",
    "solution": "number = int(input())\nprint('The next number for the number', number, 'is', number+1, end='.\\n')\nprint('The previous number for the number', number, 'is', number-1, end='.\\n')",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "6",
    "title": "Вводиться ціле додатне число. Надрукуйте останню цифру числа.",
    "inpdata": "179\n40\n101",
    "outdata": "9\n0\n1",
    "solution": "number = int(input())\nprint(number % 10)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "7",
    "title": "Напишіть програму, яка друкує на екрані наступне повідомлення: Hello, Starlink subscriber! Your current balance is 125.56 UAH. Назва стільникової мережі і значення балансу вводиться з клавіатури.",
    "inpdata": "Starlink\n4425",
    "outdata": "Hello, Starlink subscriber! Your current balance is 4425.0 UAH.",
    "solution": "name = input()\nbalance = float(input())\nprint('Hello, ' + name + ' subscriber! Your current balance is ' + str(balance) + ' UAH.')",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "8",
    "title": "Напишіть програму, яка приймає ім’я та прізвище від користувача у різних рядках та роздруковує їх у зворотному порядку з пропуском між ними у вітальному повідомленні.",
    "inpdata": "Gordon\nFreeman",
    "outdata": "Hello, Freeman Gordon!",
    "solution": "first_name = input()\nlast_name = input()\nprint ('Hello, ' + last_name + ' ' + first_name + '!')",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "9",
    "title": "Напишіть програму, яка вітає користувача, виводячи слово Hello, введене ім’я і розділові знаки за зразком (дивитися приклади вхідних і вихідних даних). Програма повинна зчитувати в рядкову змінну значення і виводити відповідне вітання. Зверніть увагу, що після коми повинен обов’язково стояти пропуск, а перед знаком оклику пропуску немає. Операцією конкатенації (об’єднанням) рядків (+) користуватися не можна.",
    "inpdata": "Alex",
    "outdata": "Hello, Alex!",
    "solution": "name = input()\nprint('Hello,', name, end='!\\n')",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "10",
    "title": "Вводиться ціле невід’ємне число n (n ≤ 100). Виведіть 2^n.",
    "inpdata": "10\n12\n5",
    "outdata": "1024\n4096\n32",
    "solution": "n = int(input())\nprint(2**n)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "11",
    "title": "Дано двоцифрове число. Знайдіть число десятків у ньому.",
    "inpdata": "42\n67\n81",
    "outdata": "4\n6\n8",
    "solution": "n = int(input())\nprint(n // 10)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "12",
    "title": "Напишіть програму для друку чисел, у яких розділювачами груп розрядів (групи по три цифри) є коми.",
    "inpdata": "10000000\n1000\n12003",
    "outdata": "10,000,000\n1,000\n12,003",
    "solution": "n = int(input())\nprint('{:,}'.format(n))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "13",
    "title": "Напишіть програму, яка отримує значення радіуса кола (дробове число) від користувача та обчислює площу круга і довжину колу. Виведення результату відбувається з трьома символами після десяткової крапки. Значення числа Пі округлити до сотих.",
    "inpdata": "5",
    "outdata": "78.540\n31.400",
    "solution": "r = float(input())\nprint('{0:.3f}\\n{1:.3f}'.format(3.14 * r**2, 2 * 3.14 * r))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "14",
    "title": "Напишіть програму для запису і розв’язування виразу (a + b) * (a + b), де a і b - натуральні цілі числа.",
    "inpdata": "4\n3",
    "outdata": "(4 + 3) * (4 + 3) = 49",
    "solution": "a, b = int(input()), int(input())\nresult = (a + b) * (a + b)\nprint(\"({0} + {1}) * ({0} + {1}) = {2}\".format(a, b, result))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "15",
    "title": "Напишіть програму для перетворення висоти (вказується окремо у футах (1 фут = 30,48 см) і дюймах (1 дюйм = 2,54 см) у сантиметри.",
    "inpdata": "Feet: 10\nInches: 5",
    "outdata": "Your height is: 318 cm.",
    "solution": "i = 2.54  # cm in inch\nf = 30.48  # cm in foot\nh_ft = int(input('Feet: '))\nh_inch = int(input('Inches: '))\ninch_cm = h_inch * i\nfoot_cm = h_ft * f\nheight = round(foot_cm + inch_cm)\nprint(\"Your height is: {0:} cm.\".format(height))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "16",
    "title": "Напишіть програму для перетворення відстані (вказана у футах) у дюйми (1 фут = 12 дюймів), ярди (1 фут = 0,333333333 ярда) і милі (1 фут = 0,000189393939 милі).",
    "inpdata": "Input distance in feet: 22",
    "outdata": "The distance in inches is 264 inches.\nThe distance in yards is 7.333 yards.\nThe distance in miles is 0.004 miles.",
    "solution": "d_ft = int(input('Input distance in feet: '))\nd_inches = d_ft * 12\nd_yards = d_ft * 0.33333\nd_miles = d_ft * 0.00018939\nprint('The distance in inches is {0:} inches.'.format(d_inches))\nprint('The distance in yards is {0:.3f} yards.'.format(d_yards))\nprint('The distance in miles is {0:.3f} miles.'.format(d_miles))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "17",
    "title": "Напишіть програму, щоб отримати ASCII значення введеного з клавіатури символа.",
    "inpdata": "G\nw\n+",
    "outdata": "71\n119\n43",
    "solution": "с = input()\nprint(ord(с))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "18",
    "title": "Напишіть програму, щоб вивести символ за введеним ASCII значенням.",
    "inpdata": "97\n121\n55",
    "outdata": "a\ny\n7",
    "solution": "num = int(input())\nprint(chr(num))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "19",
    "title": "Користувач вводить значення чисел a і b з клавіатури. Напишіть програму для друку дії додавання і результату обчислення як у вихідних даних.",
    "inpdata": "30\n20",
    "outdata": "30 + 20 = 50",
    "solution": "a = int(input())\nb = int(input())\nprint('{0:} + {1:} = {2:}'.format(a, b, a + b))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "20",
    "title": "Напишіть програму, яка зчитує значення двох змінних a і b, потім змінює їх значення місцями (тобто в змінній a має бути записано те, що раніше зберігалося в b, а в змінній b записано те, що раніше зберігалося в a). Потім виведіть значення змінних. Виконайте подане завдання без використання третьої змінної. У якому порядку значення змінних були введені, у тому ж порядку повинні і виводитися.",
    "inpdata": "34\n190",
    "outdata": "190\n34",
    "solution": "a = input()\nb = input()\na, b = b, a\nprint(a)\nprint(b)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "21",
    "title": "Напишіть програму для друку дробових чисел у форматі до 2 десяткових знаків.",
    "inpdata": "3.1415926\n1.4567\n5.8",
    "outdata": "3.14\n1.46\n5.80",
    "solution": "a = float(input())\nprint('{:.2f}'.format(a))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "22",
    "title": "Напишіть програму для друку цілих чисел з нулями ліворуч, якщо введене число має у своєму записі менше 5 розрядів.",
    "inpdata": "125\n20\n12805",
    "outdata": "00125\n00020\n12805",
    "solution": "a = int(input())\nprint('{:0>5d}'.format(a))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "23",
    "title": "Напишіть програму, щоб надрукувати цілі числа із ? справа, якщо введене число має у своєму записі менше 7 розрядів.",
    "inpdata": "23\n1400231\n-16",
    "outdata": "23*****\n1400231\n-16****",
    "solution": "a = int(input())\nprint('{:*<7d}'.format(a))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "24",
    "title": "Напишіть програму для форматування числа з відсотком.",
    "inpdata": "0.05\n0.245\n1",
    "outdata": "5.00%\n24.50%\n100.00%",
    "solution": "a = float(input())\nprint('{:.2%}'.format(a))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "25",
    "title": "Напишіть програму, яка отримує три цифри і друкує їх суму. Кожна цифра вводиться на окремому рядку.",
    "inpdata": "1\n3\n5",
    "outdata": "9",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nprint(a + b + c)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "26",
    "title": "Напишіть програму, щоб конвертувати усі введені користувачем одиниці часу (дні, години, хвилини, секунди) в загальну кількість секунд.",
    "inpdata": "Days: 1\nHours: 16\nMinutes: 25\nSeconds: 50",
    "outdata": "The amounts of seconds: 145550.",
    "solution": "days = int(input('Input days: ')) * 3600 * 24\nhours = int(input('Input hours: ')) * 3600\nminutes = int(input('Input minutes: ')) * 60\nseconds = int(input('Input seconds: '))\ntime = days + hours + minutes + seconds\nprint('The amounts of seconds:', time, end='.\\n')",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "27",
    "title": "Необхідно певну суму грошей залишити на банківському рахунку, щоб отримувати відсотки по закінченню певного часу. Наприклад, через 10 років ви хотіли б отримати 10 000 доларів США на власному рахунку. Скільки потрібно внести грошей на депозит сьогодні, щоб це сталося? Для розв’язування цієї задачі можна використовувати формулу p = f/(1+r)*n, де p - це поточна сума, яку потрібно внести сьогодні, f - майбутнє значення, яке ви хочете отримати (у нашому випадку становить 10 000 доларів США), r - річна відсоткова ставка, n - кількість років перебування грошей на рахунку.",
    "inpdata": "Enter the desired future value: 10000\nEnter the annual interest rate: 0.05\nEnter the number of years the money will grow: 10",
    "outdata": "You will need to deposit this amount: 6139.13.",
    "solution": "future_value = float(input('Enter the desired future value: '))\nrate = float(input('Enter the annual interest rate: '))\nyears = int(input('Enter the number of years the money will grow: '))\npresent_value = future_value / (1.0 + rate)**years\nprint('You will need to deposit this amount: {:.2f}.'.format(present_value))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "28",
    "title": "Напишіть програму, яка обчислює значення a + aa + aaa + aaaa із заданою цифрою як цілочисельне значення a.",
    "inpdata": "9\n1\n3",
    "outdata": "11106\n1234\n3702",
    "solution": "a = input()\nn1 = int('{0:s}'.format(a))\nn2 = int('{0:s}{1:s}'.format(a, a))\nn3 = int('{0:s}{1:s}{2:s}'.format(a, a, a))\nn4 = int('{0:s}{1:s}{2:s}{3:s}'.format(a, a, a, a))\nprint(n1 + n2 + n3 + n4)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "29",
    "title": "Вивести на екран три цілих числа в один рядок через пропуск у порядку, зворотному введенню чисел.",
    "inpdata": "4\n12\n-7",
    "outdata": "-7 12 4",
    "solution": "a, b, c = int(input()), int(input()), int(input())\nprint(c, b, a)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "30",
    "title": "Обчисліть n^181 і виведіть на екран обчислене значення. Значення n - ціле число, яке вводиться з клавіатури.",
    "inpdata": "2",
    "outdata": "3064991081731777716716694054300618367237478244367204352",
    "solution": "n = int(input())\nprint(n**181)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "31",
    "title": "Дано два цілих додатних числа a і b, які не перевищують 1000. Обчисліть і виведіть гіпотенузу трикутника із заданими катетами.",
    "inpdata": "10\n18",
    "outdata": "20.591260281974",
    "solution": "a = int(input())\nb = int(input())\nprint(pow(a**2 + b**2, 1/2))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "32",
    "title": "Вводяться три додатних числа - довжини сторін трикутника. Обчисліть площу трикутника за формулою Герона.",
    "inpdata": "3\n4\n5",
    "outdata": "6.0",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\np = (a+b+c)/2\ns = (p*(p-a)*(p-b)*(p-c)) ** 0.5\nprint(float(s))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "33",
    "title": "Напишіть програму, яка виконує усі арифметичні дії і піднесення до степеня з двома змінними a і b в такому порядку: додавання, віднімання, множення, ділення, піднесення до степеня.",
    "inpdata": "15\n2",
    "outdata": "17\n13\n30\n7.5\n225",
    "solution": "a = int(input())\nb = int(input())\nprint(a + b)\nprint(a - b)\nprint(a * b)\nprint(a / b)\nprint(a ** b)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "34",
    "title": "Цілі числа a і b вводяться користувачем. Напишіть програму для обчислення значення математичного виразу (45 + a - 11) / (b - 5)^3.",
    "inpdata": "5\n10",
    "outdata": "0.312",
    "solution": "a = int(input())\nb = int(input())\nprint((45 + a - 11)/(b-5)**3)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "35",
    "title": "Напишіть програму, яка обчислює суму, різницю, добуток, частку двох чисел, піднесення до степеня, розділяючи результати, записані в один рядок, символом &.",
    "inpdata": "6\n3",
    "outdata": "9&3&18&2.0&216",
    "solution": "a = int(input())\nb = int(input())\nprint(a + b, a - b, a * b, a / b, a ** b, sep=\"&\")",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "36",
    "title": "Напишіть програму, яка виводить результат ділення цілих змінних a / b і b / a з роздільником ??? у форматі 9 знакових позицій і 5 знаків після десяткової крапки відповідн",
    "inpdata": "10\n3",
    "outdata": "  3.33333***  0.30000",
    "solution": "a = int(input())\nb = int(input())\nprint('{:9.5f}***{:9.5f}'.format(a/b, b/a), end=\"\\n\")",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "37",
    "title": "Напишіть програму для виведення такого повідомлення на екран: Points: 145, 67, 111. Довільні цілі числа вводить користувач з клавіатури і їх значення підставляються у повідомлення автоматично.",
    "inpdata": "145\n67\n111",
    "outdata": "Points: 145, 67, 111.",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nprint('Points: {0:}, {1:}, {2:}.'.format(a, b, c))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "38",
    "title": "Напишіть програму для перетворення значення введеного користувачем з клавіатури (як відомо, вводиться текстовий рядок) у дійсне і ціле число.",
    "inpdata": "345.89012",
    "outdata": "345.89012\n345",
    "solution": "n = input()\nprint(float(n))\nprint(int(float(n)))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "39",
    "title": "Введіть з клавіатури в окремих рядках різні типи величин: ціле число, текстовий рядок, дійсне число. Виведіть інформацію про типи введених даних.",
    "inpdata": "20\nPython\n14.7",
    "outdata": "<class 'int'>\n<class 'str'>\n<class 'float'>",
    "solution": "n = int(input())\ns = input()\nf = float(input())\nprint(type(n))\nprint(type(s))\nprint(type(f))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "40",
    "title": "Перетворіть введене з клавіатури ціле число у дробове і виведіть його на екран з трьома знаками після десяткової крапки.",
    "inpdata": "144\n5\n0",
    "outdata": "144.000\n5.000\n0.000",
    "solution": "n = int(input())\nprint('{0:.3f}'.format(float(n)))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "41",
    "title": "Перетворіть введене з клавіатури дробове число у ціле і виведіть його на екран.",
    "inpdata": "8.3\n4.6\n2.86",
    "outdata": "8\n4\n2",
    "solution": "n = float(input())\nprint(int(n))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "42",
    "title": "Перевірте приналежність до типу int таких величин як ціле число, текстовий рядок, дробове число.",
    "inpdata": "12\nGuido van Rossum\n19.56",
    "outdata": "True\nFalse\nFalse",
    "solution": "n = int(input())\ns = input()\nf = float(input())\nprint(isinstance(n, int))\nprint(isinstance(s, int))\nprint(isinstance(f, int))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "43",
    "title": "Напишіть програму для друку повідомлення: \"Значення змінної назва змінної дорівнює значення змінної, а її тип тип змінної.\" Значення змінної вводять з клавіатури і у повідомленні виводиться у лапках.",
    "inpdata": "45  # рядок\n45  # ціле число\n45  # дійсне число",
    "outdata": "Value of a is \"45\", and its type <class 'str'>.\nValue of b is \"45\", and its type <class 'int'>.\nValue of c is \"45.0\", and its type <class 'float'>.",
    "solution": "a = input()\nb = int(input())\nc = float(input())\nprint('Value of {0:} is \"{1:}\", and its type {2:}.'.format('a', a, type(a)))\nprint('Value of {0:} is \"{1:}\", and its type {2:}.'.format('b', b, type(b)))\nprint('Value of {0:} is \"{1:}\", and its type {2:}.'.format('c', c, type(c)))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "44",
    "title": "Припускаючи, що немає затримок, відстань, яку автомобіль долає, можна розрахувати за такою формулою: Відстань = Швидкість · Час. Значення швидкості автомобіля вводиться користувачем з клавіатури (у км/год). Напишіть програму, яка виведе на екран значення відстані у кілометрах, яку пройде автомобіль через 6, 10, 15 годин відповідно.",
    "inpdata": "70",
    "outdata": "420\n700\n1050",
    "solution": "v = int(input())\nprint(v * 6)\nprint(v * 10)\nprint(v * 15)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "45",
    "title": "Обчисліть, скільки коштуватиме певний товар в магазині, якщо діє знижка на нього. Значення ціни товару і відсоток знижки вводяться в окремих рядках користувачем з клавіатури.",
    "inpdata": "150\n0.3",
    "outdata": "105.0",
    "solution": "original_price = float(input())\npercentage = float(input())\ndiscount = original_price * percentage\nsale_price = original_price - discount\nprint(round(sale_price, 2))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "46",
    "title": "Напишіть програму, яка зчитує три цілих числа і виводить найбільше значення з них. Не можна користуватися розгалуженнями і циклами.",
    "inpdata": "12\n-2\n54",
    "outdata": "54\n-2",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nprint(max(a, b, c))\nprint(min(a, b, c))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "47",
    "title": "Визначити, яку платню одержить на фірмі сумісник за виконану роботу, якщо йому нараховано s гривень, а податок становить p. Значення платні і податку (у %) вводяться користувачем.",
    "inpdata": "100\n20",
    "outdata": "80.0",
    "solution": "s = int(input())\np = int(input())\nprint(s - (s * p / 100))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "48",
    "title": "Сашко, зазвичай, спить вночі a годин і влаштовує собі вдень тиху годину на b хвилин. Визначте, скільки всього хвилин Сашко спить на добу.",
    "inpdata": "8\n45",
    "outdata": "525",
    "solution": "a = int(input())\nb = int(input())\nprint(a*60 + b)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "49",
    "title": "Напишіть програму, яка отримує від користувача два числа a і b і виводить значення виразу a^b.",
    "inpdata": "2\n8",
    "outdata": "256",
    "solution": "a = int(input())\nb = int(input())\nprint(a**b)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "50",
    "title": "Троє друзів отримали в кафе рахунок на суму n гривень, який вони вирішили розділити порівну. Скільки повинен заплатити кожен з них, якщо чайові складають 10% від суми рахунку?",
    "inpdata": "46.70\n122.50\n25.20",
    "outdata": "17.12\n44.92\n9.24",
    "solution": "receipt = float(input())\ntip = receipt * 0.1\npay = receipt + tip\nprint('{0:5.2f}'.format(pay / 3))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "51",
    "title": "Дано відстань n в метрах. Знайти кількість повних кілометрів в ній.",
    "inpdata": "1737\n100\n384400000",
    "outdata": "1\n0\n384400",
    "solution": "n = int(input())\nprint(n // 1000)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "52",
    "title": "Внесок в банк склав n гривень. Через рік банк нараховує вкладнику a відсотків від суми вкладу. Скільки грошей буде на рахунку через рік?",
    "inpdata": "1000\n8",
    "outdata": "1080.0",
    "solution": "n = int(input()) \nx = int(input())\nprint(n + (n * x) / 100)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "53",
    "title": "Знайдіть модуль значення y, де y = (a / b)^x + (a^(x+1)) / (b^x). Введення здійснюється в такому порядку: a, b, x.",
    "inpdata": "1\n-1\n5",
    "outdata": "2.0",
    "solution": "a = int(input())\nb = int(input())\nx = int(input())\ny = (a/b)**x + (a**(x+1))/(b**x)\nprint(abs(y))",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "54",
    "title": "В магазині канцелярських товарів Дарина купила a олівців, b ручок та c фломастерів. Відомо, що ціна ручки на 2 гривні більша ціни на олівець і на 7 гривень менша ціни на фломастера. Так само відомо, що вартість олівця становить d гривень. Користувачем вводяться по порядку в окремих рядках кількість олівців, ручок, фломастерів і ціна одного олівця. Необхідно обчислити загальну вартість покупки.",
    "inpdata": "1\n2\n2\n3",
    "outdata": "37",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nd = float(input())\ns = d*a + (d+2)*b + (d+9)*c\nprint(s)",
    "chapter": "змінні і типи даних",
    "level": "початковий"
  },
  {
    "id": "55",
    "title": "n студентів беруть k яблук і розподіляють між собою порівну. Решта фруктів залишається в кошику. Скільки яблук отримає кожен студент? Скільки яблук залишиться в кошику? Програма зчитує числа n і k і друкує на екрані дві відповіді на поставлені вище запитання.",
    "inpdata": "6\n50",
    "outdata": "8\n2",
    "solution": "n = int(input())\nk = int(input())\nprint(k // n)\nprint(k % n)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "56",
    "title": "Дано натуральне число. Знайдіть цифру, що стоїть в розряді десятків в десятковому записі числа (друга цифра, якщо рахувати з кінця запису).",
    "inpdata": "1981\n158\n5",
    "outdata": "8\n5\n0",
    "solution": "n = int(input())\nprint(n % 100 // 10)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "57",
    "title": "Мама спекла пиріг з яблуками, в якому було 60% яблук, а решта - тісто. При цьому 30% тіста становили яйця і цукор, решта - борошно. Вся маса пирога дорівнює m кг. Яка маса борошна в пирозі в грамах?",
    "inpdata": "1.2\n1\n1.5",
    "outdata": "336.0\n280.0\n420.0",
    "solution": "m = 1000 * float(input()) \nprint(0.4 * m * 0.7)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "58",
    "title": "Знайти кількість відрізків b, розміщених на відрізку a, і довжину незайнятої частини на відрізку a. Користувачем вводиться довжина відрізка a, а потім довжина відрізка b на окремих рядках. Відповідь виводиться в одному рядку: кількість відрізків b і довжина незайнятої частини відрізка a.",
    "inpdata": "121\n11",
    "outdata": "11 0",
    "solution": "a, b = int(input()), int(input()) \nprint(a // b, a % b)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "59",
    "title": "Вводиться додатне ціле трицифрове число. Знайти суму цифр числа.",
    "inpdata": "153\n123\n565",
    "outdata": "9\n6\n16",
    "solution": "n = int(input('Enter number: '))\nprint(n // 100 + n % 100 // 10 + n % 10)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "60",
    "title": "Тетяна кожен день лягає спати рівно опівночі і нещодавно дізналась, що оптимальний час для її сну становить t хвилин. Тетяна хоче поставити собі будильник так, щоб він продзвенів рівно через t хвилин після півночі, однак для цього необхідно вказати час сигналу у форматі години і хвилини. Допоможіть Тані визначити, на який час завести будильник. Години і хвилини у виведенні програми повинні розташовуватися на різних рядках.",
    "inpdata": "450",
    "outdata": "7\n30",
    "solution": "t = int(input())\nprint(t // 60)\nprint(t % 60)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "61",
    "title": "Оленка дізналася, що їй для сну треба t хвилин. На відміну від Тетяни, Оленка лягає спати після опівночі в h годин і m хвилин. Допоможіть Оленці визначити, на який час їй поставити будильник, щоб він продзвенів рівно через t хвилин після того, як вона ляже спати. В окремомих рядках вводяться значення t, h і m відповідно. Гарантується, що Оленка повинна прокинутися в той же день, що і заснути. Програма повинна виводити час, на який потрібно поставити будильник: в першому рядку години, в другому - хвилини.",
    "inpdata": "430\n1\n40",
    "outdata": "8\n50",
    "solution": "t = int(input())\nh = int(input())\nm = int(input())\nprint((t + h*60 + m) // 60)\nprint((t + h*60 + m) % 60)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "62",
    "title": "Напишіть програму для перетворення введених секунд у кількість днів, годин, хвилин та секунд.",
    "inpdata": "6785\n456789\n86401",
    "outdata": "0 day(s), 1 hour(s), 53 minute(s), 5 second(s).\n5 day(s), 6 hour(s), 53 minute(s), 9 second(s).\n1 day(s), 0 hour(s), 0 minute(s), 1 second(s).",
    "solution": "user_seconds = int(input())\ndays = int(user_seconds // 86400)\nhours = int((user_seconds % 86400) // 3600)\nminutes = int(((user_seconds % 86400) % 3600) // 60)\nseconds = int(((user_seconds % 86400) % 3600) % 60)\nprint('{0:} day(s), {1:} hour(s), {2:} minute(s), {3:} second(s).'.format(days, hours, minutes, seconds))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "63",
    "title": "Враховуючи ціле число n - кількість хвилин, що пройшли з опівночі, - скільки годин і хвилин відображаються на екрані 24-годинного цифрового годинника? Програма повинна друкувати два числа: кількість годин (від 0 до 23) і кількість хвилин (від 0 до 59). Наприклад, якщо n = 150, то після опівночі пройшло 150 хвилин, тобто зараз 2:30 ранку. Так що програма повинна друкувати 2 30.",
    "inpdata": "150\n25\n440",
    "outdata": "2 30\n0 25\n7 20",
    "solution": "n = int(input())\nhours = (n // 60) % 24\nminutes = n % 60\nprint(hours, minutes)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "64",
    "title": "Вводиться додатне дійсне число, надрукуйте його дробову частину.",
    "inpdata": "17.9\n1.066\n0.01",
    "outdata": "0.9\n0.066\n0.01",
    "solution": "number = float(input())\nlength = len(str(number))\nprint(round(number - int(number), length - 2))\n# print(number % 1)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "65",
    "title": "Автомобіль може проїхати відстань n кілометрів за день. Скільки днів пройде для проїзду маршруту довжиною m кілометрів? Програма отримує два цілих додатних числа: n і m.",
    "inpdata": "600\n625",
    "outdata": "2",
    "solution": "n = int(input())\nm = int(input())\nprint(((m - 1) // n) + 1)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "66",
    "title": "Вводиться число n, необхідно \"відрізати\" від нього k останніх цифр. Наприклад, при n = 123456 і k = 3 відповідь повинна бути 123.",
    "inpdata": "456712\n2",
    "outdata": "4567",
    "solution": "n = int(input())\nk = int(input())\nprint(n // 10**k)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "67",
    "title": "Книга коштує a гривень і b копійок. Визначте, скільки гривень і копійок потрібно заплатити за n книг. Значення вводяться користувачем у порядку a, b, n на окремих рядках, а сума до сплати в одному рядку через пропуск: кількість гривень і копійок відповідно.",
    "inpdata": "10\n15\n2",
    "outdata": "20 30",
    "solution": "a = int(input())\nb = int(input())\nn = int(input())\nprint(n * a + n * b // 100, b * n % 100)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "68",
    "title": "Вводиться цифра 0 або 1, необхідно вивести 1 або 0 відповідно, не використовуючи конструкцію розгалуження.",
    "inpdata": "0\n1",
    "outdata": "1\n0",
    "solution": "n = int(input())\nprint((n + 1) % 2)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "69",
    "title": "Задане число n записали 100 разів поспіль і потім піднесли до квадрату. Що вийшло?",
    "inpdata": "1\n2",
    "outdata": "123456790123456790123...987654321\n493827160493827160493...950617284",
    "solution": "n = input()\nprint(int(n * 100) ** 2)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "70",
    "title": "Напишіть програму сумування перших n натуральних чисел. Результатом має бути ціле число.",
    "inpdata": "100\n15\n99",
    "outdata": "5050\n120\n4950",
    "solution": "n = int(input())\nsum_num = (n * (n + 1)) / 2\nprint(int(sum_num))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "71",
    "title": "Напишіть програму для обчислення координат середини відрізка.",
    "inpdata": "x1: 3\ny1: 5\nx2: 10\ny2: -4",
    "outdata": "The midpoint's x value is: 6.5\nThe midpoint's y value is: 0.5",
    "solution": "x1 = float(input('x1: '))\ny1 = float(input('y1: '))\nx2 = float(input('x2: '))\ny2 = float(input('y2: '))\nx_m_point = (x1 + x2) / 2\ny_m_point = (y1 + y2) / 2\nprint('The midpoint\\'s x value is:', x_m_point)\nprint('The midpoint\\'s y value is:', y_m_point)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "72",
    "title": "Напишіть програму, щоб перетворити ціле число в бінарне (двійкове). Передбачте зберігання провідних нулів у двійковому записі.",
    "inpdata": "389\n65\n2",
    "outdata": "110000101\n01000001\n00000010",
    "solution": "a = int(input())\nprint(format(a, '08b'))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "73",
    "title": "Напишіть програму для перетворення десяткового числа у шістнадцяткове.",
    "inpdata": "266\n55\n450",
    "outdata": "10a\n37\n1c2",
    "solution": "a = int(input())\nprint(format(a, '2x'))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "74",
    "title": "Число n^10 записали чотири рази поспіль, де n - ціле число, яке вводить користувач. З числа, що вийшло, обчислили корінь степеня 10. Скільки вийшло?",
    "inpdata": "181\n3\n45",
    "outdata": "1437734104.8509512\n94.868424673903\n5665164.353073757",
    "solution": "n = int(input())\nprint(pow(int(str(pow(n, 10)) * 4), 1/10))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "75",
    "title": "За правилами числа округлюються до найближчого цілого числа, а якщо дробова частина числа дорівнює 0.5, то число округляється вгору. Дано невід’ємне число a, яке необхідно округлити за цими правилами. Зверніть увагу, що функція round() не годиться для цього завдання! Використовувати розгалуження, цикли, математичний модуль math не можна.",
    "inpdata": "2.5\n5.4\n56.87",
    "outdata": "3\n5\n57",
    "solution": "n = float(input())\nprint(int(n + 0.5))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "76",
    "title": "Припустимо, учнівські канікули тривали кілька днів. Напишіть програму, на вхід якої подається кількість днів, а на екран виводиться у відформатованому вигляді (вирівнювання за лівим краєм, ширина поля: 10 знаків) загальна тривалість канікул у годинах, хвилинах, секундах.",
    "inpdata": "15",
    "outdata": "360        hours\n21600      minutes\n1296000    seconds",
    "solution": "days = int(input())\nhours = days * 24\nminutes = hours * 60 \nseconds = minutes * 60\nprint('{0:<10d} hours\\n{1:<10d} minutes\\n{2:<10d} seconds'.format(hours, minutes, seconds))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "77",
    "title": "Виконайте перетворення значення температури у градусах Цельсія (С) для інших температурних шкал: Фаренгейта (F) і Кельвіна (K). Програма повинна відображати еквівалентну температуру у градусах Фаренгейта (F = 32 + 9/5 * C) і у градусах Кельвіна (K = C + 273,15).",
    "inpdata": "25",
    "outdata": "25 Celsius = 77.000 Fahrenheit = 298.150 Kelvin",
    "solution": "c = int(input())\nf = 32 + 9/5 * c\nk = c + 273.15\nprint('{0:d} Celsius = {1:.3f} Fahrenheit = {2:.3f} Kelvin'.format(c, f, k))",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "78",
    "title": "Отримати реверсний (в зворотному порядку) запис введеного користувачем трицифрового числа.",
    "inpdata": "184",
    "outdata": "481",
    "solution": "n = int(input())\na = n % 10\nn = n // 10\nb = n % 10\nn = n // 10\nc = n\nn = 100*a + 10*b + c\nprint(n)",
    "chapter": "змінні і типи даних",
    "level": "середній"
  },
  {
    "id": "79",
    "title": "Школа вирішила замінити парти у трьох кабінетах. Кожна парта розрахована на двох учнів. Враховуючи кількість учнів у кожному класі, надрукуйте найменшу можливу кількість парт, які треба придбати. Програма повинна прочитати три цілих числа: кількість учнів в кожному з трьох класів a, b та c відповідно.",
    "inpdata": "20\n21\n22",
    "outdata": "32",
    "solution": "a, b, c = map(int, input().split(' '))\nf = a // 2 + b // 2 + c // 2\ng = a % 2 + b % 2 + c % 2\nprint(f, g)\nprint(f + g)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "80",
    "title": "Дано п’ятизначне десяткове число. Побудуйте нове десяткове число за наступними правилами. Необхідно обчислити два числа, з яких перше - це сума першої, третьої та п’ятої цифр і друге число - це сума другої і четвертої цифр введеного числа. Відповідь - це отримані два числа, які записуються один за одним в одному рядку.",
    "inpdata": "12345\n44444\n11111",
    "outdata": "96\n128\n32",
    "solution": "n = int(input()) \na = n // 10000 + n % 1000 // 100 + n % 10\nb = n // 1000 % 10  + n % 100 // 10\nprint(a, b, sep='')",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "81",
    "title": "Дано ціле число n. Виведіть наступне за ним парне число.",
    "inpdata": "7\n10\n11",
    "outdata": "8\n12\n12",
    "solution": "n = int(input())\nprint((n // 2) * 2 + 2)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "82",
    "title": "Електронний годинник показує час в форматі h: mm: ss, тобто спочатку записується кількість годин (число від 0 до 23, потім обов’язково двозначна кількість хвилин, потім обов’язково двозначна кількість секунд. Кількість хвилин і секунд при необхідності доповнюються до двозначного числа нулями. З початку доби минуло n секунд. Виведіть, що покаже годинник.",
    "inpdata": "3602\n4556789\n4568",
    "outdata": "1:00:02\n17:46:29\n1:16:08",
    "solution": "n = int(input())\nh = (n // 3600) % 24\nm = n // 60 % 60\ns = n % 60\nprint(h, ':', m // 10, m % 10, ':', s // 10, s % 10, sep='')",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "83",
    "title": "Дано два моменти часу в межах однієї доби. Для кожного моменту вказано години, хвилини і секунди. Відомо, що другий момент часу настав не раніше першого. Визначте скільки секунд пройшло між двома моментами часу. Програма на вхід отримує шість цілих чисел в окремих рядках. Перші три цілих числа відповідають годинам, хвилинам і секундам першого моменту, наступні три числа відповідають другому моменту. Години задаються числом від 0 до 23 включно. Хвилини і секунди - від 0 до 59.",
    "inpdata": "1\n1\n1\n2\n2\n2",
    "outdata": "3661",
    "solution": "h1 = int(input())\nm1 = int(input())\ns1 = int(input())\nh2 = int(input())\nm2 = int(input())\ns2 = int(input())\nprint((h2 - h1) * 3600 + (m2 - m1) * 60 + (s2 - s1))",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "84",
    "title": "Равлик повзе по вертикальній жердині висотою h метрів, піднімаючись за день на a метрів, а за ніч спускаючись на b метрів. На який день равлик доповзе до вершини жердини? Дані вводяться у порядку h, a, b.",
    "inpdata": "10\n3\n2",
    "outdata": "8",
    "solution": "h = int(input())\na = int(input())\nb = int(input())\nlift_days = h - a\nday = a - b\nprint(1 + lift_days // day + (lift_days % day + day - 1) // day)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "85",
    "title": "Дано чотиризначне число. Визначте, чи є його десятковий запис симетричним. Якщо число симетричне, то виведіть 1, інакше виведіть будь-яке інше ціле число. Число може мати менше чотирьох знаків, тоді потрібно вважати, що його десятковий запис доповнюється зліва нулями.",
    "inpdata": "2002",
    "outdata": "1",
    "solution": "n = int(input())\npart1 = n // 100\npart2 = n % 100\npart2 = (n % 100) % 10 * 10 + (n % 100) // 10\nprint(part1 - part2 + 1)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "86",
    "title": "Напишіть програму, яка зчитує два цілих числа a і b і виводить найбільше значення з них. Числа - цілі від 1 до 1000. При розв’язуванні задачі можна користуватися тільки цілочисельними арифметичними операціями. Не можна користуватися розгалуженнями, циклами, функціями.",
    "inpdata": "8\n5",
    "outdata": "8",
    "solution": "a = int(input())\nb = int(input())\nprint((a * (a // b) + b * (b // a)) // (b // a + a // b))",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "87",
    "title": "У цьому завданні необхідно перевірити, чи ділиться число a на число b без остачі і вивести YES або NO. Використовувати можна тільки арифметичні операції, використання будь-яких видів розгалужень, функцій заборонено.",
    "inpdata": "10\n5",
    "outdata": "YES",
    "solution": "a = int(input())\nb = int(input())\ns1 = 'Yes'\ns2 = 'No'\nx = a % b == 0\nprint(s1 * x + s2 * (1-x))",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "88",
    "title": "Напишіть програму для розрахунку суми цифр у 4-цифровому цілому числі, яке вводиться користувачем.",
    "inpdata": "4273\n1221\n3355",
    "outdata": "16\n6\n16",
    "solution": "num = int(input('Input a four digit numbers: '))\nx = num // 1000\nx1 = (num - x*1000)//100\nx2 = (num - x*1000 - x1*100)//10\nx3 = num - x*1000 - x1*100 - x2*10\nprint('The sum of digits in the number is', x + x1 + x2 + x3, end='.\\n')",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "89",
    "title": "Напишіть програму для сортування трьох цілих чисел без використання умовних виразів і циклів.",
    "inpdata": "1\n8\n5",
    "outdata": "1 5 8",
    "solution": "x = int(input())\ny = int(input())\nz = int(input())\na1 = min(x, y, z)\na3 = max(x, y, z)\na2 = (x + y + z) - a1 - a3\nprint(a1, a2, a3)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "90",
    "title": "Необхідно перевезти n книг. Для транспортування можна використовувати коробки, які вміщають m книг кожна. Порахуйте, яку кількість коробок необхідно використати для перевезення всіх книг за один раз. Користувачем вводиться два цілих числа n і m, а програма виводить одне ціле число - мінімальну кількість коробок.",
    "inpdata": "40\n15",
    "outdata": "3",
    "solution": "n = int(input())\nm = int(input())\nprint((n + m - 1) // m)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "91",
    "title": "Напишіть програму, яка по даному числу n від 1 до 9 виводить на екран n пінгвінів. Зображення одного пінгвіна має розмір 5 ? 9 символів, між двома сусідніми пінгвінами також є порожній (з пропусків) стовпець. Дозволяється вивести порожній стовпець після останнього пінгвіна. Для спрощення малювання скопіюйте пінгвіна з прикладу в середовище розробки.",
    "inpdata": "3",
    "outdata": "    _~_       _~_       _~_    \n   (o o)     (o o)     (o o)    \n  /  V  \\   /  V  \\   /  V  \\  \n /(  _  )\\ /(  _  )\\ /(  _  )\\ \n   ^^ ^^     ^^ ^^     ^^ ^^",
    "solution": "n = int(input())\nprint(n*\"    _~_   \", \"\\n\", n*\"  (o o)   \", \"\\n\", n*\" /  V  \\  \")\nprint(n*\" /(  _  )\\\\\", \"\\n\", n*\"  ^^ ^^   \")",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "92",
    "title": "В деякій школі заняття починаються о 9:00. Тривалість уроку - 45 хвилин, після 1-го, 3-го, 5-го і т. д. уроків перерва 5 хвилин, а після 2-го, 4-го, 6-го і т. д. - 15 хвилин. Вводиться номер уроку (число від 1 до 10). Визначте, коли закінчується зазначений урок, а саме, виведіть два цілих числа: час закінчення уроку в годинах і хвилинах.",
    "inpdata": "3\n4\n5",
    "outdata": "11 35\n12 25\n13 25",
    "solution": "a = int(input())\nn_break = a - 1\ntime_break = (n_break // 2 * 20) + (n_break % 2) * 5\ntime_lesson = a * 45\ntime_all_in_minutes = time_break + time_lesson\nhours = time_all_in_minutes // 60\nminutes = time_all_in_minutes % 60\nprint(hours + 9, minutes)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "93",
    "title": "У годиннику сіла батарейка, і вони стали йти вдвічі повільніше. Коли на годиннику було x1 годин y1 хвилин, правильний час був a1 годин b1 хвилин. Скільки часу буде насправді, коли годинник в наступний раз покаже x2 годин y2 хвилин? Програма отримує на вхід числа x1, y1, a1, b1, x2, y2 в зазначеному порядку. Всі числа цілі. Числа x1, a1, x2 - від 0 до 23, числа y1, b1, y2 - від 0 до 59. Виведіть два числа a2 і b2, що визначають скільки буде часу насправді, коли на годиннику буде x2 годин y2 хвилин.",
    "inpdata": "12\n34\n10\n34\n12\n35",
    "outdata": "10 36",
    "solution": "x1 = int(input())\ny1 = int(input())\na1 = int(input())\nb1 = int(input())\nx2 = int(input())\ny2 = int(input())\nt1 = x1 * 60 + y1\nt2 = a1 * 60 + b1\ndelta_t = 2 * t1 - t2\nt3 = x2 * 60 + y2\nreal_t = 2 * t3 - delta_t + 1440\na2 = int((real_t / 60) % 24)\nb2 = real_t % 60\nprint(a2, b2)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "94",
    "title": "Вводиться додатне дійсне число a. Виведіть його першу цифру після десяткового дробу. При розв’язуванні цього завдання не можна користуватися умовною конструкцією і циклом.",
    "inpdata": "4.65\n12.06\n12.46",
    "outdata": "6\n0\n4",
    "solution": "n = float(input())\nprint(int(n % 1 // 0.1))",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "95",
    "title": "З початку доби минуло h годин, m хвилин, s секунд (0 < h < 12, 0 < m < 60, 0 < s < 60). За даними числами h, m, s визначте кут (в градусах), на який повернулаcь годинникова стрілка з початку доби і виведіть його у вигляді дійсного числа. При розв’язуванні цього завдання не можна користуватися умовними конструкціями і циклами.",
    "inpdata": "2\n10\n45",
    "outdata": "65.375",
    "solution": "h = int(input())\nm = int(input())\ns = int(input())\nc = 12 * 3600 / 360\nprint((h*3600 + m*60 + s) / c)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "96",
    "title": "З початку доби годинникова стрілка повернулася на кут a градусів. Визначте на який кут повернулась хвилинна стрілка з початку останньої години. Вхідні і вихідні дані - дійсні числа. При розв’язуванні цього завдання не можна користуватися умовними конструкціями і циклами.",
    "inpdata": "190\n170\n370",
    "outdata": "120.0\n240.0\n120.0",
    "solution": "angle = float(input())\nc_all = 12 * 3600 / 360\nc_min = 60 * 60 / 360\nprint((angle * c_all) % 3600 / c_min)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "97",
    "title": "Відомо, що батько старший за сина на n років, а син молодший батька в m разів. Визначте, скільки років батькові і скільки років синові. Вхідні дані такі, що вік батька і вік сина є цілими числами. Програма має вивести два числа, розділені пропуском: вік батька і вік сина.",
    "inpdata": "20\n5",
    "outdata": "25 5",
    "solution": "n = int(input())\nm = int(input())\nprint(n*m // (m-1), n // (m-1))",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "98",
    "title": "Дано прямокутник з розмірами a x b мм. Скільки квадратів зі стороною c мм можна відрізати від нього? Вхідні дані такі, що сторони прямокутника і квадрата є цілими числами. Програма повинна вивести одне число: кількість квадратів, які можна відрізати від даного прямокутника.",
    "inpdata": "5\n4\n2",
    "outdata": "4",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nprint((a // c) * (b // c))",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "99",
    "title": "У книзі на одній сторінці поміщається k рядків. Таким чином, на 1-й сторінці друкуються рядки з 1-го по k-й, на другій сторінці - з (k + 1)-й по (2 * k)-й і т. д. Напишіть програму, на вхід якої подається кількість рядків k на сторінці і номер рядка n в тексті, по якому визначається номер сторінки, на якій буде надрукований цей рядок, і порядковий номер цього рядка на сторінці.",
    "inpdata": "20\n25",
    "outdata": "2 5",
    "solution": "k = int(input())\nn = int(input())\nprint((n + k + 1) // k, (n - 1) % k + 1)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "100",
    "title": "Потрібно підрахувати, на скільки раніше буде закінчуватися k-й урок, якщо всі перерви скоротити на 5 хвилин. Вводиться одне натуральне число k, не більше 7. Необхідно вивести одне натуральне число - час у хвилинах.",
    "inpdata": "2\n3\n5",
    "outdata": "5\n10\n20",
    "solution": "k = int(input())\nprint((k - 1) * 5)",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "101",
    "title": "Ви придбали товар на певну суму s. Скільки купюр різного номіналу треба віддати продавцю, якщо починати платити з найбільших? У вас є 1, 2, 5, 10, 100, 500 гривень.",
    "inpdata": "534\n1245\n12",
    "outdata": "1 (500), 0 (100), 3 (10), 0 (5), 4 (1)\n2 (500), 2 (100), 4 (10), 1 (5), 0 (1)\n0 (500), 0 (100), 1 (10), 0 (5), 2 (1)",
    "solution": "s = int(input())\nn500 = s // 500\ns = s % 500\nn100 = s // 100\ns = s % 100\nn10 = s // 10\ns = s % 10\nn5 = s // 5\nn1 = s % 5\nprint(n500, '(500),', n100, '(100),', n10, '(10),', n5, '(5),', n1, '(1)')",
    "chapter": "змінні і типи даних",
    "level": "високий"
  },
  {
    "id": "102",
    "title": "Напишіть програму, в якій користувач вводить пароль і якщо він співпадає із наперед визначеним паролем для цього користувача, то виводиться повідомлення \"Password accepted.\". У іншому випадку повідомлення буде \"Sorry, that is the wrong password.\".",
    "inpdata": "starlink\n12345",
    "outdata": "Password accepted.\nSorry, that is the wrong password.",
    "solution": "password = input()\nif password == 'starlink':\n    print('Password accepted.')\nelse:\n    print('Sorry, that is the wrong password.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "103",
    "title": "Користувачем вводиться два імені. Використовуючи конструкцію розгалуження програма повинна вивести імена в алфавітному порядку.",
    "inpdata": "Guido van Rossum\nDennis Ritchie",
    "outdata": "Dennis Ritchie\nGuido van Rossum",
    "solution": "name1 = input()\nname2 = input()\nif name1 < name2:\n    print(name1)\n    print(name2)\nelse:\n    print(name2)\n    print(name1)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "104",
    "title": "Напишіть програму, яка виводить назви введених чисел. Користувач вводить ціле число. Якщо це число або 1 або 2 або 3, то виводиться повідомлення - назва числа, відповідно, \"One\", \"Two\", \"Three\". В усіх інших випадках виводиться слово \"Unknown\".",
    "inpdata": "20\n1\n2\n3",
    "outdata": "Unknown\nOne\nTwo\nThree",
    "solution": "n = int(input())\nif n == 1:\n    print('One')\nelif n == 2:\n    print('Two')\nelif n == 3:\n    print('Three')\nelse:\n    print('Unknown')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "105",
    "title": "Користувач вводить дві різних англійські літери в окремих рядках. Напишіть програму, яка виводить повідомлення про місце розташування однієї літери відносно іншої у алфавіті.",
    "inpdata": "z\na",
    "outdata": "z is not less than a",
    "solution": "a = input()\nb = input()\nif a < b:\n    print('{0:s} is less than {1:s}'.format(a, b))\nelse:\n    print('{0:s} is not less than {1:s}'.format(a, b))",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "106",
    "title": "Напишіть програму, в якій користувач вводить значення температури, і, якщо це значення менше або дорівнює 0 градусів Цельсія, необхідно вивести повідомлення \"A cold, isn’t it?\". Якщо ж температура становить більше 0 і менше 10 градусів Цельсія повідомлення буде \"Cool.\", у інших випадках \"Nice weather we’re having.\".",
    "inpdata": "12.5\n-5\n9",
    "outdata": "Nice weather we're having.\nA cold, isn't it?\nCool.",
    "solution": "t = float(input())\nif t <= 0:\n    print('A cold, isn\\'t it?')\nelif t > 0 and t < 10:\n    print('Cool.')\nelse:\n    print('Nice weather we\\'re having.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "107",
    "title": "У чемпіонаті з футболу команді за виграш дається 3 очка, за програш - 0, за нічию - 1. Відомо кількість очок, отриманих командою за гру. Вивести результат гри у вигляді відповідних слів: \"виграш\", \"програш\" або \"нічия\".",
    "inpdata": "3\n1\n0",
    "outdata": "win\ndraw\nlose",
    "solution": "n = int(input())\nif n == 3:\n    print('win')\nelif n == 1:\n    print('draw')\nelif n == 0:\n    print('lose')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "108",
    "title": "Відомі дві швидкості: одна в кілометрах за годину, інша - в метрах за секунду. Яка з швидкостей більше?",
    "inpdata": "60\n18",
    "outdata": "18",
    "solution": "v1 = int(input()) \nv2 = int(input())\nv1_change = v1 * 1000 / 3600\nif v1_change > v2:\n    print(v1)\nelse:\n    print(v2)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "109",
    "title": "Дано радіус кола і сторона квадрата (дійсні числа). У якої фігури площа більше?",
    "inpdata": "2.5\n3.5\n3.6\n7.5",
    "outdata": "Circle\nSquare",
    "solution": "r = float(input()) \na = float(input()) \nif 3.14 * r**2 > a**2:\n    print('Circle')\nelse:\n    print('Square')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "110",
    "title": "Дано маси і об’єми двох тіл, виготовлених з різних матеріалів (дійсні числа). Матеріал якого з тіл має більшу густину? Введення величин відбувається у такому порядку: m1, v1, m2, v2.",
    "inpdata": "2\n3.5\n1.5\n2.3",
    "outdata": "1.5 2.3",
    "solution": "m1 = float(input())\nv1 = float(input()) \nm2 = float(input())\nv2 = float(input())\nif m1/v1 > m2/v2:\n    print(m1, v1)\nelse:\n    print(m2, v2)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "111",
    "title": "Серед учнів школи проводилося тестування з трьох предметів, по кожному з яких учні отримали певну кількість балів (цілі числа). Напишіть програму, яку можуть використати учні для обчислення їхнього середнього балу трьох тестів і виведення середнього значення. Окрім того, необхідно передбачити виведення повідомлення \"Congratulations! That is a great average!\", якщо середній бал більший ніж 95.",
    "inpdata": "143\n112\n135",
    "outdata": "130.00\nCongratulations! That is a great average!",
    "solution": "test1 = int(input(''))\ntest2 = int(input(''))\ntest3 = int(input(''))\naverage = (test1 + test2 + test3) / 3\nprint('{0:.2f}'.format(average))\nif average >= 95:\n    print('Congratulations! That is a great average!')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "112",
    "title": "Напишіть програму, на вхід якої подається два цілих числа - вік Сашка і вік Тетянки. Програма має вивести повідомлення про те, хто є старшим серед них.",
    "inpdata": "17\n22",
    "outdata": "Tatyana is the eldest.",
    "solution": "a = int(input())\nb = int(input())\nif a > b:  \t\n    print('Sasha is the eldest.')\nelif a == b:\n    print('The same age.')\nelse: \n    print('Tatyana is the eldest.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "113",
    "title": "Напишіть програму, яка запитує два цілих числа. Якщо добуток чисел перевищує їх суму, надрукувати добуток чисел, у протилежному випадку - вивести їх суму. Якщо добуток дорівнює сумі, вивести різницю чисел.",
    "inpdata": "2\n2",
    "outdata": "0",
    "solution": "a = int(input())\nb = int(input())\nif a * b > a + b:\n    print(a * b)\nelif a * b < a + b:\n    print(a + b)\nelse:\n    print(a - b)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "114",
    "title": "Напишіть програму, щоб перевірити, чи є введене число додатним, від’ємним або це нуль.",
    "inpdata": "7\n-5.6\n0",
    "outdata": "It is positive number\nIt is a negative number\nIt is Zero",
    "solution": "num = float(input())\nif num > 0:\n   print('It is positive number')\nelif num == 0:\n   print('It is Zero')\nelse:\n   print('It is a negative number')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "115",
    "title": "Напишіть програму, яка зчитує два цілих числа a і b (від 1 до 1000) та виводить найбільше значення з них.",
    "inpdata": "12\n3",
    "outdata": "12",
    "solution": "a = int(input())\nb = int(input())\nif a > b:\n    print(a)\nelse:\n    print(b)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "116",
    "title": "Напишіть програму, яка друкує \"Yes\", якщо вводяться рядки \"yes\" або \"YES\" або \"Yes\", у інших випадках друкує \"No\".",
    "inpdata": "yes\nYES\ndefinitely",
    "outdata": "Yes\nYes\nNo",
    "solution": "if s == 'yes' or s == 'YES' or s == 'Yes':\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "117",
    "title": "Дано три цілих числа. Визначте, скільки серед них збігаються. Програма повинна вивести одне з чисел: 3 (якщо усі однакові), 2 (якщо два однакові) або 0 (якщо усі числа різні).",
    "inpdata": "5\n5\n5",
    "outdata": "3",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nif a == b and b == c:\n    print(3)\nelif a == b or b == c or a == c:\n    print(2)\nelse:\n    print(0)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "118",
    "title": "Напишіть програму, яка визначає поведінку космічного апарата, що стартує на екваторі, залежно від його початкової швидкості v, заданої у км/с (дійсні числа). Як ви знаєте з уроків фізики, тут можливі чотири випадки: при v < 7,8 км/с апарат впаде на поверхню Землі; при 7,8 ≤ v < 11,2 км/с апарат стане супутником Землі; при 11,2 ≤ v < 16,4 км/с апарат стане супутником Сонця; при v ≥ 16,4 км/с космічний апарат покине Сонячну систему.",
    "inpdata": "12.5\n22.56\n8.3",
    "outdata": "The device became a satellite of the Sun.\nThe device left the Solar system.\nThe device became a satellite of the Earth.",
    "solution": "v = float(input())\nif v < 7.8:\n    print('Falls to the surface of the earth.')\nelif v > 7.8 and v < 11.2:\n    print('The device became a satellite of the Earth.')\nelif v >= 11.2 and v < 16.4:\n    print('The device became a satellite of the Sun.')\nelif v >= 16.4:\n    print('The device left the Solar system.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "119",
    "title": "В університеті використовується наступна шкала для інтерпретації результатів тестування студентів: 90 балів і вище (A), 80-89 (B), 70-79 (C), 60-69 (D), нижче 60 (F). Напишіть програму, яка дозволить студенту ввести тестовий бал, а потім відобразити оцінку для цього балу.",
    "inpdata": "95\n48\n74",
    "outdata": "Your grade is A.\nYour grade is F.\nYour grade is C.",
    "solution": "score = int(input())\nif score >= 90:\n    print('Your grade is A.')\nelif score >= 80 and score < 90:\n    print('Your grade is B.')\nelif score >= 70 and score < 80:\n    print('Your grade is C.')\nelif score >= 60 and score < 70:\n    print('Your grade is D.')\nelse:\n    print('Your grade is F.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "120",
    "title": "Автомобіль подолав відстань s км через населений пункт за t хв. Визначити, чи не порушив водій правил дорожнього руху, якщо швидкість автомобіля при цьому не повинна перевищувати 60 км/год.",
    "inpdata": "3\n3\n4\n1",
    "outdata": "Traffic rules are executed.\nTraffic rules are not met.",
    "solution": "s = int(input())\nt = int(input())\nv = s / (t / 60)\nif v > 60:\n    print('Traffic rules are not met.')\nelse:\n    print('Traffic rules are executed.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "121",
    "title": "Користувач вводить значення температури t у градусах Цельсія. Напишіть програму, яка виводить назву стану, у якому знаходиться вода при цій температурі за нормальних умов.",
    "inpdata": "-10.5\n25\n120",
    "outdata": "ice\nwater\nwater vapor",
    "solution": "t = float(input())\nif (t < 0):\n    print('ice')\nelif (t > 100):\n    print('water vapor')\nelse:\n    print('water')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "122",
    "title": "Дано п’ять цілих чисел a, b, c, d, e. Визначити, скільки з них додатних.",
    "inpdata": "3\n-2\n5\n0\n-1",
    "outdata": "2",
    "solution": "k = 0\na = int(input())\nif a > 0:\n    k += 1\nb = int(input())\nif b > 0:\n    k += 1\nc = int(input())\nif c > 0:\n    k += 1\nd = int(input())\nif d > 0:\n    k += 1\ne = int(input())\nif e > 0:\n    k += 1\nprint(k)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "123",
    "title": "Дано ціле число a. Знайти значення виразу: a/(|a|-10). Врахувати у програмі випадок, коли відбувається ділення на нуль.",
    "inpdata": "10\n20\n-10",
    "outdata": "Division by zero!\n2.0\nDivision by zero!",
    "solution": "a = int(input())\nif (a == 10) or (a == -10):\n    print('Division by zero!')\nelse:\n    print(a / (abs(a) - 10))",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "124",
    "title": "Напишіть програму, яка запитує користувача номер в діапазоні від 1 до 7. Програма повинна відображати відповідний день тижня, де 1 - це понеділок, а 7 - неділя. Програма має враховувати варіант, коли користувач вводить номер, що знаходиться за межами діапазону від 1 до 7.",
    "inpdata": "5\n10\n2",
    "outdata": "Friday\nThere is no such day of the week.\nTuesday",
    "solution": "number = int(input())\nif number == 1:\n    print('Monday')\nelif number == 2:\n    print('Tuesday')\nelif number == 3:\n    print('Wednesday')\nelif number == 4:\n    print('Thursday')\nelif number == 5:\n    print('Friday')\nelif number == 6:\n    print('Saturday')\nelif number == 7:\n    print('Sunday')\nelse:\n    print('There is no such day of the week.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "125",
    "title": "Напишіть програму, яка просить користувача ввести вік людини (ціле число). Програма повинна вивести повідомлення про те, чи є особа немовлям, дитиною, підлітком або дорослим за такими правилами: якщо людині 1 рік або менше, він або вона є немовлям, якщо особа старше 1 року, але молодше 13 років, вона є дитиною, якщо особа не молодше 13 років, але молодше 20 років, вона є підлітком і якщо особа віком старше 20 років, вона є дорослою.",
    "inpdata": "3\n14\n1\n25",
    "outdata": "You are a child.\nYou are a teenager.\nYou are an infant.\nYou are an adult.",
    "solution": "age = int(input())\nif age <= 1:\n    print('You are an infant.')\nelif age > 1 and age < 13:\n    print('You are a child.')\nelif age >= 13 and age < 20:\n    print('You are a teenager.')\nelse:\n    print('You are an adult.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "126",
    "title": "Напишіть програму, яка запропонує користувачеві ввести десяткове число у межах від 1 до 10. Програма повинна вивести версію римського числа. Програма має враховувати ситуацію, якщо введене число є за межами діапазону від 1 до 10.",
    "inpdata": "8\n10\n12",
    "outdata": "VIII\nX\nYou entered a number without the range.",
    "solution": "number = int(input())\nif number == 1:\n    print('I')\nelif number == 2:\n    print('II')\nelif number == 3:\n    print('III')\nelif number == 4:\n    print('IV')\nelif number == 5:\n    print('V')\nelif number == 6:\n    print('VI')\nelif number == 7:\n    print('VII')\nelif number == 8:\n    print('VIII')\nelif number == 9:\n    print('IX')\nelif number == 10:\n    print('X')\nelse:\n    print('You entered a number without the range.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "127",
    "title": "Дату 2 жовтня 2020 р. будемо називати \"магічною\", оскільки, коли вона записана у форматі 02.10.20, добуток значень дня і місяця дорівнюють значенню року. Напишіть програму, яка запропонує користувачеві ввести день, місяць і рік (лише останні дві цифри) у числовій формі. Програмі слід вивести повідомлення про те, що введена дата є \"магічною\". В іншому випадку має бути повідомлення, що це звичайна дата.",
    "inpdata": "02\n10\n20",
    "outdata": "The date is magic!",
    "solution": "day = int(input())\nmonth = int(input())\nyear = int(input())\nif month * day == year:\n    print('The date is magic!')\nelse:\n    print('The date is not magic.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "128",
    "title": "Червоний, зелений та синій кольори відомі як основні кольори колірної моделі RGB. При змішуванні червоного та зеленого кольорів, отримується жовтий, при змішуванні синього і зеленого - блакитний, а при змішуванні синього і червоного – пурпуровий колір. Напишіть програму, яка запропонує користувачеві ввести назви двох основних кольорів для змішування. Якщо користувач вводить щось інше, ніж \"червоний\", \"синій\" або \"зелений\", програма повинна виводити повідомлення про відсутність такої палітри. В іншому випадку програма повинна відображати назву кольору, що утворився.",
    "inpdata": "blue\nred",
    "outdata": "Magenta",
    "solution": "color1 = input()\ncolor2 = input()\nif color1 == 'red' and color2 == 'green' or color1 == 'green' and color2 == 'red':\n    print('Yellow')\nelif color1 == 'blue' and color2 == 'green' or color1 == 'green' and color2 == 'blue':\n    print('Cyan')\nelif color1 == 'blue' and color2 == 'red' or color1 == 'red' and color2 == 'blue':\n    print('Magenta')\nelse:\n    print('Missing palette')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "129",
    "title": "Книжковий інтернет-магазин має книжковий клуб, який нараховує бали своїм клієнтам на основі кількості книг, що купуються щомісяця (бали можна використати як знижку при черговому придбанні книги). Бали нараховуються таким чином: якщо клієнт купує менше 2 книг, він отримує 0 балів; якщо клієнт купує від 2 книг до 4 книг, він отримує 5 балів; якщо клієнт купує від 4 книг і до 6 книг, він заробляє 15 балів; якщо клієнт купує від 6 книг до 8 книг, він заробляє 30 балів; якщо клієнт купує 8 і більше книг, він заробляє 60 балів. Напишіть програму, яка просить користувача ввести кількість книг, які він придбав у цьому місяці, і відображає кількість отриманих балів.",
    "inpdata": "6\n9\n1",
    "outdata": "You earned 30 points.\nYou earned 60 points.\nYou earned 0 points.",
    "solution": "book = int(input())\nif book >= 8:\n    print('You earned 60 points.')\nelif book < 8 and book >= 6:\n    print('You earned 30 points.')\nelif book < 6 and book >= 4:\n    print('You earned 15 points.')\nelif book < 4 and book >= 2:\n    print('You earned 5 points.')\nelif book < 2 and book >= 0:\n    print('You earned 0 points.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "130",
    "title": "Компанія-виробник програмного забезпечення у сфері інформаційної безпеки реалізує один комплект програм за 2700 гривень. Якщо відбувається купівля декількох одиниць товару, працює система знижок: 10-19 одиниць товару - 10%, 20-49 - 20%, 50-99 - 30%, 100 або більше - 40%. Напишіть програму, яка отримує від користувача ціле число - кількість придбаних комплектів програмного забезпечення і виводить повідомлення про суму знижки (якщо така є) та загальну суму при купівлі зі знижкою.",
    "inpdata": "26\n3\n110",
    "outdata": "The amount of discount is 20%, total amount of the purchase after the discount is UAH 56160.0\nThe amount of discount is 0%, total amount of the purchase after the discount is UAH 8100\nThe amount of discount is 40%, total amount of the purchase after the discount is UAH 178200.0",
    "solution": "message = 'total amount of the purchase after the discount is UAH'\nnumber = int(input())\nif number >= 100:\n    print('The amount of discount is 40%,', message, 2700 * number * 0.6)\nelif number >= 50 and number <= 99:\n    print('The amount of discount is 30%,', message, 2700 * number * 0.7)\nelif number >= 20 and number <= 49:\n    print('The amount of discount is 20%,', message, 2700 * number * 0.8)\nelif number >= 10 and number <= 19:\n    print('The amount of discount is 10%,', message, 2700 * number * 0.9)\nelse:\n    print('The amount of discount is 0%,', message, 2700 * number)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "131",
    "title": "Напишіть програму, на вхід якої подається назва місяця, а програма виводить кількість днів у ньому. Врахуйте те, що місяць \"Лютий\" може мати 28 або 29 днів.",
    "inpdata": "September\nFebruary\nAugust",
    "outdata": "September has 30 days in it.\nFebruary has 28 or 29 days in it.\nAugust has 31 days in it.",
    "solution": "month = input()\ndays = '31'\nif month == 'April' or month == 'June' or month == 'September' or month == 'November':\n    days = '30'\nelif month == 'February':\n    days = '28 or 29'\nprint('{0:s} has {1:s} days in it.'.format(month, days))",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "132",
    "title": "Дано ціле число n (1 ≤ n ≤ 4), яке визначає пору року: весна, літо, осінь, зима. За вказаним значенням n необхідно надрукувати перелік місяців, які відносяться до цієї пори року.",
    "inpdata": "1\n4\n5",
    "outdata": "March, April, May\nDecember, January, February\nIncorrect data!",
    "solution": "n = int(input())\nif n == 1:\n    print('March, April, May')\nelif n == 2:\n    print('June, July, August')\nelif n == 3:\n    print('September, October, November')\nelif n == 4:\n    print('December, January, February')\nelse:\n    print('Incorrect data!')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "133",
    "title": "Залежно від розміру суми, розмір податку з неї розраховується за такою схемою: якщо сума не перевищує деяку величину a, то податок не вираховується; якщо сума більша за a, але не перевищує b, то податок становить 10%; якщо сума більша за b, але не перевищує c, то податок становить 25%; якщо сума більша c, то податок становить 50%. Визначити, який податок (дійсне число) буде вираховано із суми розміром s. Дані (цілі числа) вводяться в такому порядку: a, b, c, s.",
    "inpdata": "1000\n500\n700\n3200",
    "outdata": "1600.0",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\ns = int(input())\nif s <= a:\n    print(0)\nelif s > a and s <= b:\n    print(s * 0.1)\nelif s > b and s <= c:\n    print(s * 0.25)\nelif s > c:\n    print(s * 0.5)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "134",
    "title": "Напишіть програму виведення текстового варіанта шкільних оцінок: 1, 2, 3 (початковий рівень - initial level), 4, 5, 6 (середній рівень - average level), 7, 8, 9 (достатній рівень - sufficient level), 10, 11, 12 (високий рівень - high level).",
    "inpdata": "7\n10\n15",
    "outdata": "sufficient level\nhigh level\nlevel is absent",
    "solution": "n = int(input())\nif n == 1 or n == 2 or n == 3:\n    print('initial level')\nelif n == 4 or n == 5 or n == 6:\n    print('average level')\nelif n == 7 or n == 8 or n == 9:\n    print('sufficient level')\nelif n == 10 or n == 11 or n == 12:\n    print('high level')\nelse:\n    print('level is absent')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "135",
    "title": "Розробіть програму для виведення інформації про операційну систему, яка встановлена на комп’ютері користувачa, при введенні відповідного номера: 1 - Window, 2 - Linux, 3 - MacOS. Передбачте у роботі програми ситуації, коли користувач вводить інший номер, відмінний від наведених, або програма на вхід отримує порожній рядок.",
    "inpdata": "2\n\n5",
    "outdata": "Linux\nYou did not enter a number. Program has completed work.\nWe could not determine your operating system.",
    "solution": "os_name = input()\nif os_name != '':\n    if os_name == '1':\n        print('Windows')\n    elif os_name == '2':\n        print('Linux')\n    elif os_name == '3':\n        print('MacOS')\n    else:\n        print('We could not determine your operating system.')\nelse:\n    print('You did not enter a number. Program has completed work.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "136",
    "title": "Подорожуючи на автомобілі, ви заїхали на автозаправну станцію. До наступної заправки 200 кілометрів. Напишіть програму, яка буде визначати, чи потрібно вам заправлятися або ж можна почекати до наступної станції. Програма повинна запитати: який розмір вашого бензобаку в літрах; скільки пального в бензобаку (у відсотках); скільки кілометрів проходить автомобіль на одному літрі палива. Результатом роботи програми має бути інформація про кількість кілометрів, які ще можна проїхати і почекати до наступної автозаправної станції, або негайно заправитись.",
    "inpdata": "60\n30\n8",
    "outdata": "You can drive another 144.0 kilometers.\nNext refueling after 200 kilometers.\nFILL IN NOW!",
    "solution": "tank_size = int(input())\nfull = int(input ())\nmileage = int(input())\nrange = tank_size * (full / 100.0) * mileage\nprint('You can drive another', range, 'kilometers.\nNext refueling after 200 kilometers.')\nif range <= 200:\n    print('FILL IN NOW!')\nelse:\n    print('You can wait for the next refueling.')",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "137",
    "title": "Дано натуральне число. Визначити, чи закінчується воно цифрою 5.",
    "inpdata": "12395\n123",
    "outdata": "True\nFalse",
    "solution": "n = int(input())\nif n % 10 == 5:\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "138",
    "title": "Дано три цілих числа. Необхідно надрукувати ті з них, які є парними.",
    "inpdata": "4\n5\n6",
    "outdata": "4\n6",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nif a % 2 == 0:\n    print(a)\nif b % 2 == 0:\n    print(b)\nif c % 2 == 0:\n    print(c)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "139",
    "title": "Перевірити, чи належить число, введене з клавіатури, інтервалу (-5, 3).",
    "inpdata": "4\n2\n3",
    "outdata": "False\nTrue\nFalse",
    "solution": "n = int(input())\nif (n > -5) and (n < 3):\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "140",
    "title": "Визначити, чи є число а дільником числа b або, навпаки, число b дільником числа a.",
    "inpdata": "6\n3\n3\n2",
    "outdata": "True\nFalse",
    "solution": "a = int(input())\nb = int(input())\nif (a % b == 0) or (b % a == 0):\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "141",
    "title": "Перевести число, введене користувачем, у байти або кілобайти в залежності від його вибору. Користувач вводить значення у мегабайтах і, відповідно, вводить напрямок переведення: B (у байти) або KB (у кілобайти).",
    "inpdata": "1024\nB\n1024\nKB",
    "outdata": "1024 MB = 1073741824 B\n1024 MB = 1048576 KB",
    "solution": "n = int(input())\nc = input()\nif c == 'B':\n    print('{0:d} MB = {1:d} B'.format(n, n * 1024 * 1024))\nelif c == 'KB':\n    print('{0:} MB = {1:} KB'.format(n, n * 1024))",
    "chapter": "розгалуження",
    "level": "початковий"
  },
  {
    "id": "142",
    "title": "Визначте назву геометричної фігури за введеною кількістю її сторін. Програма повинна підтримувати фігури від 3 до 6 сторін. Якщо введена кількість сторін поза межами цього діапазону, програма повинна відображати відповідне повідомлення.",
    "inpdata": "2\n3\n4\n5\n6",
    "outdata": "That number of sides is not supported by this program.\nThat's a triangle.\nThat's a quadrilateral.\nThat's a pentagon.\nThat's a hexagon.",
    "solution": "nsides = int(input(''))\nname = ''\nif nsides == 3:\n    name = 'triangle'\nelif nsides == 4:\n    name = 'quadrilateral'\nelif nsides == 5:\n    name = 'pentagon'\nelif nsides == 6:\n    name = 'hexagon'\nif name == '':\n    print('That number of sides is not supported by this program.')\nelse:\n    print('That\\'s a {0:s}.'.format(name))",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "143",
    "title": "Ігрове поле рулетки поділено на номери від 0 до 36, які мають чорний, червоний або зелений кольори. Номер 0 має зелений колір, для номерів від 1 до 10, непарні номери - червоні, а парні - чорні. Непарні номери від 11 до 18 - чорні, а парні номери - червоні. Непарні номери від 19 до 28 - червоні, а парні номери - чорні. Непарні номери від 29 до 36 - чорні, а парні номери - червоні. Напишіть програму, яка отримує номер (число від 0 до 36) та показує, чи є номер зеленим, червоним або чорним. Програма повинна враховувати варіант, якщо користувач вводить номер, який знаходиться за межами діапазону від 0 до 36.",
    "inpdata": "24\n34\n10\n42",
    "outdata": "Black\nRed\nBlack\nThe bet will not play!",
    "solution": "number = int(input())\nif number == 0:\n    print('Green')\nelif number >= 1 and number <= 10:\n    if number % 2 != 0:\n        print('Red')\n    else:\n        print('Black')\nelif number >= 11 and number <= 18:\n    if number % 2 != 0:\n        print('Black')\n    else:\n        print('Red')\nelif number >= 19 and number <= 28:\n    if number % 2 != 0:\n        print('Red')\n    else:\n        print('Black')\nelif number >= 29 and number <= 36:\n    if number % 2 != 0:\n        print('Black')\n    else:\n        print('Red')\nelse:    \n    print('The bet will not play!')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "144",
    "title": "На станції ремонту автомобілів працює кілька працівників. Якщо який-небудь працівник працює понад 40 годин на тиждень, він отримує в 1,5 рази більше від звичайної погодинної оплати. Розробіть програму, яка розраховує заробітну плату працівника, включаючи оплату за додаткові години. Програма отримує на вхід два цілих числа - кількість робочих годин і ставку погодинної оплати.",
    "inpdata": "45\n15",
    "outdata": "712.50",
    "solution": "base_hours = 40\not_multiplier = 1.5\nhours = float(input())\npay_rate = float(input())\nif hours > base_hours:\n    overtime_hours = hours - base_hours\n    overtime_pay = overtime_hours * pay_rate * ot_multiplier\n    gross_pay = base_hours * pay_rate + overtime_pay\nelse:\n    gross_pay = hours * pay_rate\nprint(format(gross_pay, ',.2f'))",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "145",
    "title": "Напишіть програму для знаходження коренів квадратного рівняння a*x^2 + b*x + c = 0. Користувач вводить значення коефіцієнтів a, b, c. У вхідних даних наведено три пари вхідних значень коефіцієнтів, а у вихідних даних - відповідні повідомлення про кількість коренів або їх відсутність.",
    "inpdata": "8\n4\n2\n3.6\n10\n-3\n2\n4\n2",
    "outdata": "No roots.\n0.27 and -3.05\n-1.00",
    "solution": "a = float(input())\nb = float(input())\nc = float(input())\nd = b**2 - 4 * a * c\nif d > 0:\n    num_roots = 2\n    x1 = ((-b) + (d)**0.5)/(2 * a)     \n    x2 = ((-b) - (d)**0.5)/(2 * a)\n    print('{0:.2f} and {1:.2f}'.format(x1, x2))\nelif d == 0:\n    num_roots = 1\n    x = (-b) / (2 * a)\n    print('{0:.2f}'.format(x))\nelse:\n    num_roots = 0\n    print('No roots.')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "146",
    "title": "Дано дві точки: A (x1, y1) і B (x2, y2). Напишіть програму, яка визначає, яка із точок знаходиться далі від початку координат.",
    "inpdata": "1\n2\n3\n2\n4\n4\n4\n4",
    "outdata": "B\nThe distance is the same",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\nif ((x1**2 + y1**2)**0.5) > ((x2**2 + y2**2)**0.5):\n    print('A')\nelif ((x1**2 + y1**2)**0.5) < ((x2**2 + y2**2)**0.5):\n    print('B')\nelse:\n    print('The distance is the same')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "147",
    "title": "Вводяться координати (x, y) точки A і радіус кола (r). Визначити, чи належить дана точка колу, якщо його центр знаходиться в початку координат.",
    "inpdata": "3\n4\n5\n-2\n5\n3",
    "outdata": "The point belongs to the circle\nThe point is outside the circle",
    "solution": "x = float(input())\ny = float(input())\nr = float(input())\nh = (x**2 + y**2) ** 0.5\nif h > r:\n    print('The point is outside the circle')\nelse:\n    print('The point belongs to the circle')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "148",
    "title": "Дано натуральное число. Визначити, чи закінчується число парною цифрою.",
    "inpdata": "1234\n35",
    "outdata": "True\nFalse",
    "solution": "n = int(input())\nif (n % 10) % 2 == 0:\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "149",
    "title": "Дано трицифрове число. Визначити, чи рівний квадрат суми цифр числа сумі кубів його цифр.",
    "inpdata": "123\n210\n150",
    "outdata": "True\nTrue\nFalse",
    "solution": "n = int(input())\na = n // 100\nb = n % 100 // 10\nc = n % 10\nif (a + b + c)**2 == (a**3 + b**3 + c**3):\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "150",
    "title": "Розробіть програму-резюме, яка за введеними початковими даними і порядковим номером виводить таку інформацію: 1 - прізвище, 2 - ім’я, 3 - вік, 4 - хобі, 5 - номер телефону.",
    "inpdata": "Brendan\nEich\n57\nprogrammer\n4567231\n4",
    "outdata": "Programmer",
    "solution": "surname = input()\nname = input()\nage = int(input())\nhobby = input()\nphone = int(input())\nn = int(input())\nif n == 1:\n    print(surname)\nelif n == 2:\n    print(name)\nelif n == 3:\n    print(age)\nelif n == 4:\n    print(hobby)\nelif n == 5:\n    print(phone)\nelse:\n    print('The program has no such functionality.')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "151",
    "title": "Дано ціле число k (1 ≤ k ≤ 365). Визначити, яким буде k-й день року: вихідним (субота або неділя) або робочим, якщо 1 січня - понеділок.",
    "inpdata": "5\n7\n56",
    "outdata": "working day\nday off\nday off",
    "solution": "k = int(input())\nday = k % 7\nif day >= 1 and day <= 5:\n    print('working day')\nelif day == 6 or day == 0:\n    print('day off')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "152",
    "title": "Прямокутник на площині, зі сторонами, паралельними координатним осям, заданий координатами лівої верхньої і правої нижньої своїх вершин. Також дані координати точки. Усі координати - цілі числа. Визначити, чи належить вказана точка заданому прямокутнику.",
    "inpdata": "1\n7\n10\n2\n3\n3",
    "outdata": "Yes",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\na = int(input())\nb = int(input())\nif (a >= x1) and (a <= x2) and (b <= y1) and (b >= y2):\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "153",
    "title": "Визначити чверть координатної площини, якій належить точка A з координатами (x1, y1). Відомо, що координати не рівні нулю і є цілими числами.",
    "inpdata": "2\n-4\n-4\n3",
    "outdata": "IV\nII",
    "solution": "x = int(input())\ny = int(input())\nif x > 0 and y > 0:\n    print('I')\nelif x < 0 and y > 0:\n    print('II')\nelif x < 0 and y < 0:\n    print('III')\nelif x > 0 and y < 0:\n    print('IV')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "154",
    "title": "Визначити, чи увійде в конверт з внутрішніми розмірами a і b мм прямокутна листівка з розмірами с і d мм. Для розміщення листівки в конверті необхідний проміжок в 1 мм з кожної сторони. Значення сторін листівки і конверту - цілі числа.",
    "inpdata": "5\n6\n4\n5",
    "outdata": "Yes",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nd = int(input())\nif (a <= c) and (b <= d):\n    print('No')\nelif (a == c + 1) and (b == d + 1):\n    print('Yes')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "155",
    "title": "Розробити програму-довідник, яка за введеним значенням радіуса r пропронуватиме користувачу допомогу в обчисленні n (номер послуги): 1 - довжини кола, 2 - площі круга, 3 - об’єму кулі, 4 - площі поверхні кулі. Дані вводяться в такому порядку: r, n.",
    "inpdata": "8\n2",
    "outdata": "200.96",
    "solution": "r = float(input())\nn = int(input())\nif n == 1:\n    print(2 * 3.14 * r)\nelif n == 2:\n    print(3.14 * r**2)\nelif n == 3:\n    print(4 / 3 * 3.14 * r**3)\nelif n == 4:\n    print(4 * 3.14 * r**2)\nelse:\n    print('The program has no such functionality.')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "156",
    "title": "Напишіть програму, щоб визначити, чи задане ціле число (вводиться користувачем) парне або непарне.",
    "inpdata": "2\n5\n11",
    "outdata": "True\nFalse\nFalse",
    "solution": "number = int(input())\nif number % 2 == 0:\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "157",
    "title": "Дано дійсне число n, що містить два знака до десяткової точки і два після неї. Необхідно отримати нове число, помінявши в числі цілу і дробову частини.",
    "inpdata": "10\n5\n11\n5",
    "outdata": "2\n1",
    "solution": "x1, x2 = 0, 0\nn = float(input())\nx1 = int(n)\nx2 = round(n % 1, 2)\nprint(x1 / 100 + x2 * 100)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "158",
    "title": "Дано двоцифрове число. Визначити, чи є сума його цифр двоцифровим числом.",
    "inpdata": "55\n19\n15",
    "outdata": "True\nTrue\nFalse",
    "solution": "n = int(input())\na = n % 10\nb = n // 10\nif  (a + b) // 10 == 0:\n    print(False)\nelse:\n    print(True)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "159",
    "title": "Дано двоцифрове число. Визначити, яка з його цифр більше: перша (вивести 1) або друга (вивести 2), або цифри рівні (вивести \"=\").",
    "inpdata": "45\n85\n22",
    "outdata": "2\n1\n=",
    "solution": "n = int(input())\na = n // 10\nb = n % 10\nif  a > b:\n    print(1)\nelif a < b:\n    print(2)\nelse:\n    print('=')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "160",
    "title": "Дано натуральне число n (1 ≤ n ≤ 9999), що визначає вартість товару в копійках. Подайте вартість у гривнях і копійках. Якщо у результаті виходить 0 копійок, то замість цього значення необхідно записати порожній рядок.",
    "inpdata": "160\n1200\n2356",
    "outdata": "1 60\n12\n23 56",
    "solution": "n = int(input())\ng = n // 100\nk = n % 100\nif k == 0:\n    print(g)\nelse:\n    print(g, k)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "161",
    "title": "Відомі рік і номер місяця народження людини, а також рік і номер місяця сьогоднішнього дня (січень - 1 і т. д.). Визначити вік людини (число повних років). У разі збігу вказаних номерів місяців вважати, що пройшов повний рік.",
    "inpdata": "1998\n3\n2018\n2",
    "outdata": "19",
    "solution": "y = int(input())\nm = int(input())\ncurrent_y = int(input())\ncurrent_m = int(input())\nage = current_y - y\nif current_m < m:\n    print(age - 1)\nelse:\n    print(age)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "162",
    "title": "Виведіть імена видатних особистостей України, зображених на грошових знаках. Користувач вводить номінал банкноти, а програма виводить значення номіналу і ім’я особи, яка зображена на цій банкноті. Якщо користувач вводить неіснуюче значення номіналу, виводиться відповідне повідомлення.",
    "inpdata": "500\n20\n8",
    "outdata": "500, Grigory Skovoroda\n20, Ivan Franko\nNo bill.",
    "solution": "bill = int(input('Enter a face value: '))\nface = ''\nif bill == 1:\n    face = 'Volodymyr the Great'\nelif bill == 2:\n    face = 'Yaroslav the Wise'\nelif bill == 5:\n    face = 'Bogdan Khmelnitsky'\nelif bill == 10:\n    face = 'Ivan Mazepa'\nelif bill == 20:\n    face = 'Ivan Franko'\nelif bill == 50:\n    face = 'Michael Hrushevsky'\nelif bill == 100:\n    face = 'Taras Shevchenko'\nelif bill == 200:\n    face = 'Lesya Ukrainka'\nelif bill == 500:\n    face = 'Grigory Skovoroda'\nif face == '':\n    print('No bill.')\nelse:\n    print('{0:d}, {1:s}'.format(bill, face))",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "163",
    "title": "Уявіть будинок, побудований у футуристичному стилі, в якому є трикутні, прямокутні і круглі кімнати. Щоб швидко обчислити площу житлового приміщення, потрібно написати програму, на вхід якої подаються тип кімнати (трикутник (triangle), прямокутник (rectangle), коло (circle)) та відповідні параметри, за допомогою яких можна обчислити площу кімнати вказаної форми. Зверніть увагу, що кількість параметрів для обчислення площі для різних фігур є різною. Для числа Пі використовуйте значення 3.14.",
    "inpdata": "triangle\n3\n4\n5",
    "outdata": "6.0",
    "solution": "figure = input()\nif figure == 'triangle':\n    a = float(input())\n    b = float(input())\n    c = float(input())\n    p = (a+b+c)/2\n    print((p*(p-a)*(p-b)*(p-c))**0.5)\nif figure == 'rectangle':\n    a = float(input())\n    b = float(input())\n    print(a*b) \nif figure == 'circle':\n    r = float(input())\n    print(3.14*(r**2))",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "164",
    "title": "Напишіть програму для розрахунку індексу маси тіла, який обчислюється за формулою: індекс = маса / ( зріст * зріст). Користувач вводить значення зросту (у метрах) і маси (у кілограмах), а програма обчислює індекс маси тіла і виводить відповідне повідомлення: \"underweight\" (мала маса, індекс менше 18.5), \"normal weight\" (нормальна маса, індекс 18.5-24.9), \"overweight\" (надмірна маса, індекс більше 24.9).",
    "inpdata": "1.79\n88\n1.90\n85",
    "outdata": "Your body mass index is: 27.46 , that is overweight.\nYour body mass index is: 23.55 , that is normal weight.",
    "solution": "height = float(input()) \nweight = float(input()) \nbmi = weight / (height * height)\nif bmi <= 18.5: \n    result = 'underweight.'\nelif (18.5 < bmi) and (bmi <= 25):\n    result = 'normal weight.'\nelif (25 < bmi) and (bmi <= 29.9): \n    result = 'overweight.'\nelse: \n    result = 'obesity.'\nprint('Your body mass index is:', round((bmi), 2), ', that is', result)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "165",
    "title": "Напишіть програму простого калькулятора, яка зчитує введені користувачем три рядки: перше число, друге число і арифметичну дію, після чого застосовує введену дію до введених числах і виводить результат. Калькулятор повинен підтримувати такі арифметичні дії як: +, -, /, *, mod (залишок від ділення), pow (піднесення до степеня), div (цілочисельне ділення). Якщо виконується ділення і друге число дорівнює 0, необхідно виводити рядок \"Division by 0!\". Введені числа є дійсними.",
    "inpdata": "2.0\n3.0\npow\n12.5\n0.5\n+\n4.5\n0.0\n/",
    "outdata": "8.0\n13.0\nDivision by 0!",
    "solution": "a = float(input())\nb = float(input())\noperation = input()\nif operation == '+':\n    print(a + b)\nelif operation == '-':\n    print(a - b)\nelif operation == '*':\n    print(a * b)\nelif operation == '/':\n    if b == 0:\n        print('Division by 0!')\n    else:\n        print(a / b)\nelif operation == 'mod':\n    if b == 0:\n        print('Division by 0!')\n    else:\n        print(a % b)\nelif operation == 'pow':\n    print(a**b)\nelif operation == 'div':\n    if b == 0:\n        print('Division by 0!')\n    else:\n        print(a // b)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "166",
    "title": "Дано два натуральних числа n і m. Якщо одне з них ділиться на інше без остачі, виведіть 1, інакше виведіть будь-яке інше ціле число.",
    "inpdata": "3\n6",
    "outdata": "1",
    "solution": "n = int(input())\nm = int(input())\nif n % m == 0 or m % n == 0:\n    print(1)\nelse:\n    print(0)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "167",
    "title": "Дано натуральне число. Визначити, чи є воно двоцифровим.",
    "inpdata": "1\n55\n123",
    "outdata": "False\nTrue\nFalse",
    "solution": "n = int(input())\nif (n // 100 == 0) and (n // 10 > 0):\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "168",
    "title": "Дано трицифрове ціле число. Визначити суму першої і останньої цифр числа і порівняти її із значенням другої цифри числа. Відповідно вивести повідомлення: \">\", \"<\" і \"=\".",
    "inpdata": "122\n121\n263",
    "outdata": ">\n=\n<",
    "solution": "n = int(input())\na = n // 100\nb = n % 100 // 10\nc = n % 10\nif a + c > b:\n    print('>')\nelif a + c < b:\n    print('<')\nelse:\n    print('=')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "169",
    "title": "Напишіть програму, у яку вводяться трицифрове ціле число і цифра. Необхідно визначити, чи входить у число введена цифра.",
    "inpdata": "125\n2",
    "outdata": "True",
    "solution": "a = int(input())\nn = int(input())\nif ((a % 10) == n) or (((a // 10) % 10) == n) or ((a // 100) == n):\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "170",
    "title": "Дано трицифрове ціле число. Визначити кількість однакових цифр у записі числа і вивести значення цієї кількості.",
    "inpdata": "155\n111\n478",
    "outdata": "2\n3\n0",
    "solution": "n = int(input())\na = n // 100\nb = n % 100 // 10\nc = n % 10\nif a == c == b:\n    print(3)\nelif a == c or c == b or a == b:\n    print(2)\nelse:\n    print(0)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "171",
    "title": "Трикутник на координатній площині заданий цілочисельними координатами своїх вершин, які не лежать на одній прямій. Користувач вводить координати трьох вершин трикутника (три пари чисел), а програма, відповідно, має вивести \"Yes\" або \"No\" на питання, чи є трикутник прямокутним.",
    "inpdata": "1\n7\n7\n7\n1\n1",
    "outdata": "Yes",
    "solution": "x1, y1 = int(input()), int(input())\nx2, y2 = int(input()), int(input())\nx3, y3 = int(input()), int(input())\nkv_a, kv_b, kv_c = (x2 - x1) ** 2 + (y2 - y1) ** 2, (x3 - x2) ** 2 + (y3 - y2) ** 2, (x1 - x3) ** 2 + (y1 - y3) ** 2\nif kv_a > kv_c:\n    kv_a, kv_c = kv_c, kv_a\nif kv_b > kv_c:\n    kv_b, kv_c = kv_c, kv_b\nif kv_a + kv_b == kv_c:\n    print ('Yes')\nelse:\n    print ('No')",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "172",
    "title": "Напишіть програму, яка отримує на вхід ціле число, і виводить True, якщо передане значення потрапляє в інтервал (-15,12] ? (14,17) ? [19, + ?) і False в іншому випадку. Зверніть увагу на різні дужки, які використовуються для позначення інтервалів.",
    "inpdata": "25\n-19\n12",
    "outdata": "True\nFalse\nTrue",
    "solution": "number = int(input())\nif ((number > -15) and (number <= 12)) or (number > 14 and number < 17) or (number >= 19):\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "173",
    "title": "За рейтинговою системою оцінка визначається таким чином: якщо сумарний бал учня становить не менш як 90% від максимального, то виставляється оцінка 12, якщо не нижче за 70%, то виставляється оцінка 8, якщо ж не нижче за 50%, то оцінка 5, у інших випадках - оцінка 2. Визначте оцінку учня, якщо він набрав n балів, а максимальне значення сумарного балу становить m.",
    "inpdata": "70\n100",
    "outdata": "8",
    "solution": "n = int(input())\nm = int(input())\nif n >= 0.9 * m:\n    print(12)\nelif n >= 0.7 * m:\n    print(8)\nelif n >= 0.5 * m:\n    print(5)\nelse:\n    print(2)",
    "chapter": "розгалуження",
    "level": "середній"
  },
  {
    "id": "174",
    "title": "Потрібно визначити, чи є даний рік високосним. Нагадаємо, що високосними роками вважаються ті роки, порядковий номер яких або кратний 4, але при цьому не кратний 100, або кратний 400 (наприклад, 2000-й рік був високосним, а 2100-й буде невисокосним роком). Програма повинна коректно працювати на числах 1900 ≤ n ≤ 3000. Виведіть \"Leap year.\" в разі, якщо рік є високосним, і \"Ordinary year.\" у протилежному випадку.",
    "inpdata": "2001\n2019\n2020",
    "outdata": "Ordinary year.\nOrdinary year.\nLeap year.",
    "solution": "year = int(input())\nif (year % 4 == 0) and ((year % 100 != 0) or (year % 400 == 0)):\n    print('Leap year.')\nelse:\n    print('Ordinary year.')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "175",
    "title": "Дано чотирицифрове число. Визначити, чи дорівнює сума двох перших його цифр сумі двох його останніх цифр.",
    "inpdata": "1423\n2356\n1102",
    "outdata": "True\nFalse\nTrue",
    "solution": "n = int(input())\na = n // 1000\nb = n // 100 % 10\nc = n % 100 // 10\nd = n % 10\nif a + b == c + d:\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "176",
    "title": "Дано чотирицифрове число. Замінити усі парні цифри числа на символ \"*\" і вивести число.",
    "inpdata": "2358\n2227\n1353",
    "outdata": "*35*\n***7\n1353",
    "solution": "n = int(input())\na = n // 1000\nb = n // 100 % 10\nc = n % 100 // 10\nd = n % 10\nif a % 2 == 0:\n    a = '*'\nif b % 2 == 0:\n    b = '*'\nif c % 2 == 0:\n    c = '*'\nif d % 2 == 0:\n    d = '*'\nprint(a, b, c, d, sep='')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "177",
    "title": "Дано натуральне число n (n ≤ 9999). З’ясувати, чи різні усі чотири цифри цього числа (з урахуванням чотирьох цифр). Наприклад, в числі 5623 усі цифри різні, в числі 0012 - ні.",
    "inpdata": "1234\n1981",
    "outdata": "True\nFalse",
    "solution": "n = int(input())\na = n // 1000\nb = n // 100 % 10\nc = n % 100 // 10\nd = n % 10\nif (a != b) and (a != c) and (a != d) and (b != c) and (b != d) and (c != d):\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "178",
    "title": "Робота світлофора для пішоходів запрограмована таким чином: на початку кожної години протягом трьох хвилин горить зелений сигнал, потім протягом двох хвилин - червоний, а потім протягом трьох хвилин - знову зелений і т. д. Дано ціле число t, що означає час в хвилинах, що минув від початку чергової години. Визначити, сигнал якого кольору горить для пішоходів в цей момент.",
    "inpdata": "25\n23\n26",
    "outdata": "green\nred\ngreen",
    "solution": "t = int(input())\nsignal = t % 5\nif signal >= 0 and signal <= 2:   \n    print('green')\nelif signal >= 3 and signal <= 4:\n    print('red')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "179",
    "title": "Робота світлофора для водіїв запрограмована таким чином: на початку кожної години протягом трьох хвилин горить зелений сигнал, потім протягом однієї хвилини - жовтий, потім протягом двох хвилин - червоний, а далі протягом трьох хвилин - знову зелений і т. д. Дано ціле число t, що позначає час у хвилинах, що минув з початку чергової години. Визначити, сигнал якого кольору горить для водіїв в цей момент.",
    "inpdata": "4\n3\n5",
    "outdata": "yellow\ngreen\nred",
    "solution": "t = int(input())\nsignal = t % 6\nif signal <= 3:\n    print('green')\nelif signal > 3 and signal <= 4:\n    print('yellow')\nif signal > 4 and signal < 6:\n    print('red')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "180",
    "title": "Дано чотирицифрове число. Перевірте, чи є воно паліндромом. Примітка. Паліндромом називається число, слово або текст, які однаково читаються зліва направо і справа наліво. Наприклад, в нашому випадку, числами-паліндромами будуть: 1221, 4444, 9119 і т. д. Приклади інших цілих чисел-паліндромів, що не відносяться до розв’язуваної задачі: 2, 454, 33, 91219 і т. д.",
    "inpdata": "4556\n8118",
    "outdata": "False\nTrue",
    "solution": "n = int(input())\na = n % 10\nn = n // 10\nb = n % 10\nn = n // 10\na = 10 * a + b\nif n == a:  # print(n == a)\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "181",
    "title": "Дано однобайтове десяткове число (у межах 128-255). Перевірити, чи є двійкове подання десяткового числа паліндромом, з урахуванням зберігання старших нулів у двійковому поданні. Приклад таких десяткових чисел: 102 (у двійковому форматі 01100110), 129 (у двійковому вигляді 10000001) і т. д.",
    "inpdata": "231\n255\n178",
    "outdata": "True\nTrue\nFalse",
    "solution": "n = int(input())\na = n % 2\nn = n // 2\nb = n % 2\nn = n // 2\nc = n % 2\nn = n // 2\nd = n % 2\nn = n // 2\na = 8 * a + 4 * b + 2 * c + d\nif n == a:  # print(n == a)\n    print(True)\nelse:\n    print(False)",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "182",
    "title": "Напишіть програму, у якій користувач вводить значення поточної дати: день, місяць і рік (цілі числа), а програма виводить завтрашню дату у форматі: дд.мм.рррр.",
    "inpdata": "28\n2\n2020\n31\n12\n2017\n5\n7\n2019",
    "outdata": "29.2.2020\n1.1.2018\n6.7.2019",
    "solution": "d = int(input())\nm = int(input())\ny = int(input())\nif (y % 4 == 0) and ((y % 100 != 0) or (y % 400 == 0)):\n    leap_year = True\nelse:\n    leap_year = False\nif (m == 12) and (d == 31):\n    d = 1\n    m = 1\n    y += 1\nelif m == 2 and d == 29 and leap_year:\n    d = 1\n    m += 1\nelif m == 2 and d == 28:\n    if leap_year:\n        d += 1\n    else:\n        d = 1\n        m += 1\nelif (d == 31) and ((m == 3) or (m == 5) or (m == 7) or (m == 8) or (m == 10) or (m == 12)):\n    d = 1\n    m += 1\nelif (d == 30) and ((m == 4) or (m == 6) or (m == 9) or (m == 11)):\n    d = 1\n    m += 1\nelse:\n    d += 1\nprint('{0:}.{1:}.{2:}'.format(d, m, y))",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "183",
    "title": "Напишіть програму, у якій користувач вводить значення поточної дати: день, місяць і рік (цілі числа), а програма виводить вчорашню дату у форматі: дд.мм.рррр.",
    "inpdata": "1\n3\n2018\n1\n1\n2017\n1\n8\n2018",
    "outdata": "28.2.2018\n31.12.2016\n31.7.2018",
    "solution": "d = int(input())\nm = int(input())\ny = int(input())\nif (y % 4 == 0) and ((y % 100 != 0) or (y % 400 == 0)):\n    leap_year = True\nelse:\n    leap_year = False\nif (m == 1) and (d == 1):\n    d = 31\n    m = 12\n    y -= 1\nelif m == 3 and d == 1 and leap_year:\n    d = 29\n    m -= 1\nelif m == 3 and d == 1 and (not leap_year):\n    d = 28\n    m -= 1\nelif (d == 1) and ((m == 3) or (m == 5) or (m == 7) or (m == 10) or (m == 12)):\n    d = 30\n    m -= 1\nelif (d == 1) and ((m == 2) or (m == 4) or (m == 6) or (m == 8) or (m == 9) or (m == 11)):\n    d = 31\n    m -= 1\nelse:\n    d -= 1\nprint('{0:}.{1:}.{2:}'.format(d, m, y))",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "184",
    "title": "Плитка шоколаду має вигляд прямокутника, розділеного на n ? m частинок. Плитку шоколаду можна один раз розламати по прямій на дві частини. Визначте, чи можна таким чином відламати від плитки шоколаду шматок, що складається рівно з k частин. Програма отримує на вхід три числа: n, m, k і повинна вивести \"Yes\" або \"No\".",
    "inpdata": "5\n7\n1",
    "outdata": "No",
    "solution": "n = int(input())\nm = int(input())\nk = int(input())\nif (k <= m * n) and (k % m == 0 or k % n == 0):\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "185",
    "title": "Дано три цілих числа. Упорядкуйте їх у порядку зростання. Програма повинна зчитувати три числа a, b, c. Далі програма повинна змінювати їх значення так, щоб стали виконані умови a ≤ b ≤ c. Резельтатом роботи програми буде виведення трійки чисел a, b, c в одному рядку. При розв’язуванні задачі не можна використовувати додаткові змінні, тобто єдиною допустимою операцією присвоювання є обмін значень двох змінних типу (a, b) = (b, a).",
    "inpdata": "25\n78\n4",
    "outdata": "4 25 78",
    "solution": "a, b, c = int(input()), int(input()), int(input())\nif a > b:\n    a, b = b, a\nif b > c:\n    b, c = c, b\nif a > b:\n    a, b = b, a\nprint(a, b, c)",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "186",
    "title": "Скласти програму знаходження добутку двох найменших з трьох різних цілих чисел.",
    "inpdata": "4\n2\n3",
    "outdata": "6",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nif a > b:\n    a, b = b, a\nif b > c:\n    b, c = c, b\nif a > b:\n    a, b = b, a\nprint(a * b)",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "187",
    "title": "Визначити максимальну і мінімальну цифри із введеного трицифрового числа і вивести цифри в одному рядку через пропуск. Якщо цифри однакові, то вивести лише одну цифру.",
    "inpdata": "184\n244\n111",
    "outdata": "8 1\n4 2\n1",
    "solution": "n = int(input())\na = n // 100\nb = n // 10 % 10\nc = n % 10\nif a > b:\n    a, b = b, a\nif b > c:\n    b, c = c, b\nif a > b:\n    a, b = b, a\nif c == a:\n    print(c)\nelse:\n    print(c, a)",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "188",
    "title": "Провайдер здійснює підключення до Інтернету за таким тарифним планом. Щомісячна абонентська плата становить a гривень, і в цю абонентську плату включено b гігабайт трафіку. Невитрачені гігабайти в кінці місяця «згорають». Якщо трафік перевищує b гігабайт, то кожен гігабайт трафіку понад передплачених коштує с гривень. Відомо, що за минулий місяць один з абонентів витратив d гігабайт трафіку. Визначте, у скільки обійшовся йому доступ в Інтернет в минулому місяці (вважаючи, в тому числі і абонентську плату)? Вводяться чотири натуральних числа a, b, c, d. Всі числа не перевищують 100. Виведіть одне число - суму (у гривнях), яку абонент повинен заплатити за Інтернет.",
    "inpdata": "150\n10\n12\n15",
    "outdata": "210",
    "solution": "a, b, c, d = int(input()), int(input()), int(input()), int(input())\nif d <= b:\n    print(a)\nelse:\n    print(a + c * (d - b))",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "189",
    "title": "Напишіть програму, у якій до введеного числа додаються написи: \"гривень\" (hryven), \"гривня\" (hryvnia), \"гривні\" (hryvni), згідно з правилами українського правопису.",
    "inpdata": "10001\n516\n2022",
    "outdata": "10001 hryvnia\n516 hryven\n2022 hryvni",
    "solution": "n = int(input())\na = n % 10\nb = n // 10 % 10\nif (a == 1) and (b != 1):\n    print (n, 'hryvnia')\nelif ((a == 2) or (a == 3) or (a == 4)) and (b != 1):\n    print (n, 'hryvni')\nelse:\n    print(n, 'hryven')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "190",
    "title": "Напишіть програму, яка отримує на вхід три цілих числа, по одному числу в рядку, і виводить у три рядки спочатку максимальне, потім мінімальне, після чого число, що залишилося. Вводитися можуть повторювані числа. Використайте лише конструкції розгалуження, без обміну значеннями між двома змінними.",
    "inpdata": "2\n55\n14",
    "outdata": "55\n2\n14",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nif a > b and a > c:\n    if b > c:\n        print(a, c, b, sep=\"\\n\")\n    else:\n        print(a, b, c, sep=\"\\n\")\nelif b > a and b > c:\n    if a > c:\n        print(b, c, a, sep=\"\\n\")\n    else:\n        print(b, a, c, sep=\"\\n\")\nelif c > a and c > b:\n    if a > b:\n        print(c, b, a, sep=\"\\n\")\n    else:\n        print(c, a, b, sep=\"\\n\")\nelif a == b:\n    if a > c:\n        print(a, c, b, sep=\"\\n\")\n    else:\n        print(c, a, b, sep=\"\\n\")\nelif b == c:\n    if b > a:\n        print(b, a, c, sep=\"\\n\")\n    else:\n        print(a, b, c, sep=\"\\n\")\nelif a == c:\n    if a > b:\n        print(a, b, c, sep=\"\\n\")\n    else:\n        print(b, a, c, sep=\"\\n\")\nelif a == b and b == c:\n    print(a, b, c, sep=\"\\n\")",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "191",
    "title": "За багато років ув’язнення в’язень замку Іф зробив у стіні прямокутний отвір розміром d ? e. Замок Іф побудований із цегли, розміром a ? b ? c. Визначте, чи зможе в’язень викидати цеглини в море через цей отвір (сторони цегли є паралельними сторонам отвору). Програма отримує на вхід числа a, b, c, d, e і повинна вивести слово \"Yes\" або \"No\".",
    "inpdata": "1\n1\n1\n1\n1",
    "outdata": "Yes",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nd = int(input())\ne = int(input())\nif (a <= d and b <= e) or (a <= e and b <= d):\n    print('Yes')\nelif (c <= d and b <= e) or (c <= e and b <= d):\n    print('Yes')\nelif (c <= d and a <= e) or (c <= e and a <= d):\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "192",
    "title": "Шаховий офіцер (\"слон\") ходить по діагоналі. Дано дві різні клітинки шахової дошки, визначте, чи може офіцер потрапити з першої клітини на другу за один хід. Програма отримує на вхід чотири числа від 1 до 8 кожне, що задають номер стовпця і номер рядка спочатку для першої клітинки, потім для другої клітинки. Програма повинна вивести \"Yes\", якщо з першої клітинки ходом офіцера можна потрапити в другу або \"No\" в іншому випадку.",
    "inpdata": "3\n7\n4\n5",
    "outdata": "No",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\nif abs(x2 - x1) == abs(y2 - y1):\n    print('Yes') \nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "193",
    "title": "Шахова тура ходить по горизонталі або вертикалі. Дано дві різні клітинки шахової дошки, визначте, чи може тура потрапити з першої клітинки на другу за один хід. Програма отримує на вхід чотири числа від 1 до 8 кожне, що задають номер стовпця і номер рядка спочатку для першої клітинки, потім для другої клітинки. Програма повинна вивести \"Yes\", якщо з першої клітинки ходом тури можна потрапити в другу або \"No\" в іншому випадку.",
    "inpdata": "2\n2\n4\n4",
    "outdata": "No",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\nif x1 == x2 or y1 == y2:\n    print('Yes') \nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "194",
    "title": "Шаховий кінь ходить літерою \"Г\" - на дві клітини по вертикалі в будь-якому напрямку і на одну клітинку по горизонталі, або навпаки. Дано дві різні клітинки шахової дошки, визначте, чи може кінь потрапити з першої клітинки на другу за один хід. Програма отримує на вхід чотири числа від 1 до 8 кожне, що задають номер стовпця і номер рядка спочатку для першої клітинки, потім для другої клітинки. Програма повинна вивести \"Yes\", якщо з першої клітинки ходом коня можна потрапити в другу або \"No\" в іншому випадку.",
    "inpdata": "5\n5\n3\n6",
    "outdata": "Yes",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\nif abs(x2 - x1) == 1 and abs(y2 - y1) == 2: \n    print('Yes')\nelif abs(y2 - y1) == 1 and abs(x2 - x1) == 2:\n\tprint('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "195",
    "title": "Шаховий ферзь (\"королева\") ходить по діагоналі, горизонталі або вертикалі. Дано дві різні клітинки шахової дошки, визначте, чи може ферзь потрапити з першої клітинки на другу за один хід. Програма отримує на вхід чотири числа від 1 до 8 кожне, що задають номер стовпця і номер рядка спочатку для першої клітинки, потім для другої клітинки. Програма повинна вивести \"Yes\", якщо з першої клітинки ходом ферзя можна потрапити в другу або \"No\" в іншому випадку.",
    "inpdata": "3\n6\n8\n1",
    "outdata": "Yes",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\nif x1 == x2 or y1 == y2 or x1 - x2 == y1 - y2 or x1 - x2 == y2 - y1: \n    print('Yes') \nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "196",
    "title": "Шаховий король ходить по горизонталі, вертикалі і діагоналі, але тільки на 1 клітинку. Дано дві різні клітинки шахової дошки, визначте, чи може король потрапити з першої клітинки на другу за один хід. Програма отримує на вхід чотири числа від 1 до 8 кожне, що задають номер стовпця і номер рядка спочатку для першої клітинки, потім для другої клітинки. Програма повинна вивести \"Yes\", якщо з першої клітинки ходом короля можна потрапити в другу або \"No\" в іншому випадку.",
    "inpdata": "1\n1\n3\n3",
    "outdata": "No",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\nif abs(x2 - x1) <= 1 and abs(y2 - y1) <= 1:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "197",
    "title": "Задані дві клітини шахової дошки. Якщо вони зафарбовані в один колір, то виведіть слово \"Yes\", а якщо в різні кольори - \"No\". Програма отримує на вхід чотири числа від 1 до 8 кожне, що задають номер стовпця і номер рядка спочатку для першої клітинки, потім для другої клітинки.",
    "inpdata": "1\n2\n2\n2",
    "outdata": "No",
    "solution": "x1 = int(input())\ny1 = int(input())\nx2 = int(input())\ny2 = int(input())\nif (x1 + y1) % 2 == (x2 + y2) % 2:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "198",
    "title": "Дано три сторони трикутника a, b, c. Визначте тип трикутника із заданими сторонами. Виведіть одне з чотирьох слів: \"rectangular\" для прямокутного трикутника, \"acute\" для гострокутного трикутника, \"obtuse\" для тупокутного трикутника або \"impossible\", якщо трикутника з такими сторонами не існує.",
    "inpdata": "4\n5\n6",
    "outdata": "acute",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nif a > b:\n    a, b = b, a\nif b > c:\n    b, c = c, b\nif c >= a + b:\n    print('impossible')\nelse:\n    result = a*a + b*b - c*c\n    if result == 0:\n        print('rectangular')\n    elif result > 0:\n        print('acute')\n    else:\n        print('obtuse')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "199",
    "title": "Тетянка полюбляє їздити у громадському транспорті, а отримуючи квиток, відразу перевіряє, чи він щасливий. Квиток вважається щасливим, якщо сума перших трьох цифр збігається з сумою останніх трьох цифр номера квитка. Напишіть програму, яка перевірить рівність сум і виведе \"Happy\", якщо суми збігаються, і \"Ordinary\", якщо суми різні. На вхід програмі подається рядок із шести цифр.",
    "inpdata": "156012\n122005\n045090",
    "outdata": "Ordinary\nHappy\nHappy",
    "solution": "lot = int(input())\nif (lot // 100000 + lot % 100000 // 10000 + lot % 10000 // 1000) == (lot % 1000 // 100 + lot % 100 // 10 + lot % 10):\n    print('Happy')\nelse:\n    print('Ordinary')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "200",
    "title": "У будинку кілька під’їздів. У кожному під’їзді однакова кількість квартир. Квартири нумеруються підряд, починаючи з одиниці. Чи може в деякому під’їзді перша квартира мати номер x, а остання - номер y? Вводяться два натуральних числа x і y (x ≤ y), що не перевищують 10000. Виведіть слово \"Yes\", якщо таке можливо, і \"No\" у протилежному випадку.",
    "inpdata": "111\n15",
    "outdata": "Yes",
    "solution": "x = int(input())\ny = int(input())\nif x == 1 or y % (y - x + 1) == 0:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "201",
    "title": "Для даного числа n < 100 необхідно закінчити фразу \"На лузі пасеться…?\" одним з можливих продовжень: \"n корів\", \"n корова\", \"n корови\", правильно обравши закінчення. Вводиться натуральне число. Програма повинна вивести введене число n і одне зі слів: \"koriv\", \"korova\" або \"korovy\". Між числом і словом повинен стояти один пропуск.",
    "inpdata": "5\n23\n51",
    "outdata": "5 koriv\n23 korovy\n51 korova",
    "solution": "n = int(input())\nif n >= 11 and n <= 14:\n    print(n, 'koriv')\nelse:\n    t = n % 10\n    if t == 0 or (t >= 5 and t <= 9):\n        print(n, 'koriv')\n    if t == 1:\n        print(n, 'korova')\n    if t >= 2 and t <= 4:\n        print(n, 'korovy')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "202",
    "title": "Дано натуральне число n (0 ≤ n ≤ 1000), яке визначає період піврозпаду радіоактивних атомів, визначений у роках. Необхідно вивести значення періоду піврозпаду, додавши до цього числа відповідно \"рік\" (rik), \"роки\" (roku), \"років\" (rokiv).",
    "inpdata": "34\n21\n45",
    "outdata": "34 roku\n21 rik\n45 rokiv",
    "solution": "n = int(input())\nif n % 10 == 1 and n % 100 != 11:\n    print(n, 'rik')\nelif (n % 100 != 12 and n % 100 != 13 and n % 100 != 14) and (n % 10 == 2 or n % 10 == 3 or n % 10 == 4):\n    print(n, 'roku')\nelse:\n    print(n, 'rokiv')",
    "chapter": "розгалуження",
    "level": "високий"
  },
  {
    "id": "203",
    "title": "Виведіть повідомлення \"Hello, Python!\" на екран n разів (n - ціле число, яке вводить користувач).",
    "inpdata": "3",
    "outdata": "Hello, Python!\nHello, Python!\nHello, Python!",
    "solution": "n = int(input())\nfor i in range(n):\n    print('Hello, Python!')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "204",
    "title": "Дано два цілих числа a і b (a ≤ b). Виведіть всі числа від a до b включно.",
    "inpdata": "1\n12",
    "outdata": "1 2 3 4 5 6 7 8 9 10 11 12",
    "solution": "a = int(input())\nb = int(input())\nfor i in range(a, b + 1):\n    print(i, end=' ')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "205",
    "title": "Напишіть програму-таймер зворотного відліку, яка запитує у користувача кількість секунд n, з якої слід починати відлік.",
    "inpdata": "5",
    "outdata": "5\n4\n3\n2\n1\nStart!",
    "solution": "start = int(input())\nfor i in range (start, 0, -1):\n    print(i)\nprint('Start!')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "206",
    "title": "Користувач вводить кількість навчальних предметів n, а потім, відповідно, оцінки учня з n навчальних предметів. Визначте середню оцінку.",
    "inpdata": "5\n10\n11\n9\n8\n10",
    "outdata": "9.60",
    "solution": "n = int(input())\ns = 0\nfor i in range(1, n + 1):\n    subj = int(input())\n    s += subj\nprint(format(s / n, '.2f'))",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "207",
    "title": "Надрукувати у рядку m разів число n. Числа m і n - цілі числа, які вводить користувач у порядку n, m.",
    "inpdata": "10\n5",
    "outdata": "10 10 10 10 10",
    "solution": "n = int(input())\nm = int(input())\nfor i in range(1, m + 1):\n    print(n, end=' ')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "208",
    "title": "Напишіть програму для виведення усіх цілих чисел від 20 до n включно (n > 20), де n - ціле число, яке вводить користувач.",
    "inpdata": "25",
    "outdata": "20\n21\n22\n23\n24\n25",
    "solution": "n = int(input())\nfor i in range(20, n + 1):\n    print(i)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "209",
    "title": "Напишіть програму для друку цілих чисел від n до 0 із виведенням біля кожного числа кількості символів \"#\", що дорівнює значенню числа.",
    "inpdata": "6",
    "outdata": "6 ######\n5 #####\n4 ####\n3 ###\n2 ##\n1 #",
    "solution": "n = int(input())\nfor i in range (n, 0, -1):\n    print(i, '#' * i)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "210",
    "title": "Визначити суму всіх чисел від 1 до n (1 ≤ n ≤ 100).",
    "inpdata": "100\n16\n1",
    "outdata": "5050\n136\n1",
    "solution": "n = int(input())\ns = 0\nfor i in range(1, n + 1):\n    s += i\nprint(s)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "211",
    "title": "Напишіть програму для побудови шаблону як у вихідних даних за введеним значенням n.",
    "inpdata": "9",
    "outdata": "1\n22\n333\n4444\n55555\n666666\n7777777\n88888888\n999999999",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    print(str(i) * i)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "212",
    "title": "Напишіть програму для побудови шаблону як у вихідних даних за введеним значенням n.",
    "inpdata": "5",
    "outdata": "*****\n****\n***\n**\n*",
    "solution": "n = int(input())\nfor i in range(n, 0, -1):\n    print('*' * i)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "213",
    "title": "Напишіть програму для побудови шаблону як у вихідних даних за введеним значенням n.",
    "inpdata": "5",
    "outdata": "##\n# #\n#  #\n#   #\n#    #",
    "solution": "n = int(input())\nfor i in range(0, n):\n    print('#' + ' ' * i + '#')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "214",
    "title": "Напишіть програму, яка підраховує додатні і від’ємні числа, а також нулі, введені користувачем, і виводить їхню кількість в один рядок з одним пропуском між ними.",
    "inpdata": "5\n12\n-45\n0\n14\n0",
    "outdata": "2 1 2",
    "solution": "n = int(input())\nk = 0\nm = 0\nz = 0\nfor i in range(1, n + 1):\n    b = int(input())\n    if b > 0:\n        k += 1\n    elif b < 0:\n        m += 1\n    else:\n        z += 1\nprint(k, m, z)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "215",
    "title": "Напишіть програму, яка друкує в дному рядку через пропуск усі парні числа від 1 до n (1 < n ≤ 100, n - ціле число, яке вводить користувач). Використайте оператор continue.",
    "inpdata": "2\n10\n7",
    "outdata": "2\n2 4 6 8 10\n2 4 6",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    if (i % 2 != 0):\n        continue\n    print(i, end=' ')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "216",
    "title": "Надрукувати всі непарні двоцифрові числа, у яких остання цифра дорівнює n - ціле число, яке вводить користувач.",
    "inpdata": "5\n1\n0",
    "outdata": "15 25 35 45 55 65 75 85 95\n11 21 31 41 51 61 71 81 91\n10 20 30 40 50 60 70 80 90",
    "solution": "n = int(input())\nfor i in range(10, 100):\n    if i % 10 == n:\n        print(i, end=' ')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "217",
    "title": "Надрукувати всі цілі числа від a до b включно, кратні деякому числу c. Числа a, b, c - цілі числа, які вводить користувач.",
    "inpdata": "20\n50\n3",
    "outdata": "21 24 27 30 33 36 39 42 45 48",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nfor i in range(a, b + 1):\n    if i % c == 0:\n        print(i, end=' ')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "218",
    "title": "Дано натуральне ціле додатнє число n. Визначити кількість цифр в ньому.",
    "inpdata": "12367832\n142\n0",
    "outdata": "8\n3\n1",
    "solution": "n = int(input())\nif n == 0:\n    k = 1\nelse:\n    k = 0\nwhile n > 0:\n    n = n // 10\n    k += 1\nprint(k)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "219",
    "title": "Надрукувати квадрати усіх цілих чисел від 1 до n включно (значення n вводиться з клавіатури користувачем).",
    "inpdata": "10",
    "outdata": "1\n4\n9\n16\n25\n36\n49\n64\n81\n100",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    print(i**2)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "220",
    "title": "Напишіть програму для друку чисел від 0 до n включно і виведення в один рядок через один пропуск (n - ціле число, яке вводить користувач).",
    "inpdata": "9\n3\n15",
    "outdata": "0 1 2 3 4 5 6 7 8 9\n0 1 2 3\n0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15",
    "solution": "n = int(input())\nfor i in range(0, n + 1):\n    print(i, end=' ')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "221",
    "title": "Надрукувати таблицю відповідності між масою у фунтах і масою в кілограмах для значень n фунтів (1 фунт = 453 г) у вигляді таблиці.",
    "inpdata": "5",
    "outdata": "1     0.45\n2     0.91\n3     1.36\n4     1.81\n5     2.27",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    print('{0:d}    {1:5.2f}'.format(i, i * 453 / 1000))",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "222",
    "title": "Напишіть програму, яка друкує цілі числа від 1 до n (1 < n ≤ 1000) з такою умовою: для чисел кратних 3 виводить \"*3*\" замість числа, для чисел кратних 5 друкує \"*5*\", а для чисел, які кратні 3 і 5 одночасно, повідомлення буде \"*35*\".",
    "inpdata": "15",
    "outdata": "1\n2\n*3*\n4\n*5*\n*3*\n7\n8\n*3*\n*5*\n11\n*3*\n13\n14\n*35*",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    if i % 3 == 0 and i % 5 == 0:\n        print('*35*')\n        continue\n    elif i % 3 == 0:\n        print('*3*')\n        continue\n    elif i % 5 == 0:\n        print('*5*')\n        continue\n    print(i)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "223",
    "title": "Напишіть програму, яка зчитує цілі числа, введені користувачем, по одному числу n в рядку. Для кожного введеного числа необхідно перевірити: якщо число менше 10, то пропускаємо це число; якщо число більше 100, то припиняємо зчитувати числа; в інших випадках вивести це число в окремому рядку.",
    "inpdata": "15\n4\n11\n123",
    "outdata": "15\n11",
    "solution": "while True:\n    n = int(input())\n    if n > 100:\n        break\n    elif n < 10:\n        continue\n    else:\n        print(n)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "224",
    "title": "Напишіть програму для знаходження тих чисел із діапазону 1 ≤ n ≤ 1000 (число n вводить користувач), які кратні 7 і 5, і виведення таких чисел в один рядок.",
    "inpdata": "1",
    "outdata": "35 70 105 140 175 210 245 280 315 350 385 420 455 490 525 560 595 630 665 700 735 770 805 840 875 910 945 980",
    "solution": "n = int(input())\nfor i in range(n, 1001):\n    if (i % 7 == 0) and (i % 5 == 0):\n        print(i, end=' ')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "225",
    "title": "Напишіть програму для створення таблиці множення (від 1 до 10) для введеного цілого числа n.",
    "inpdata": "3",
    "outdata": "3 x 1 = 3\n3 x 2 = 6\n3 x 3 = 9\n3 x 4 = 12\n3 x 5 = 15\n3 x 6 = 18\n3 x 7 = 21\n3 x 8 = 24\n3 x 9 = 27\n3 x 10 = 30",
    "solution": "n = int(input())\nfor i in range(1, 11):\n    j = n * i\n    print('{0:} x {1:} = {2:}'.format(n, i, j))",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "226",
    "title": "Знайти суму 1^2 + 2^2 + 3^2 + …? + n^2 при заданому користувачем значенні цілого числа n.",
    "inpdata": "3\n2\n6",
    "outdata": "14\n5\n91",
    "solution": "n = int(input())\ns = 0\nfor i in range(1, n + 1):\n    s += i**2\nprint(s)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "227",
    "title": "При заданому користувачем значенні цілого числа n ≥ 2 обчислити вираз 1 ? 2 + 2 ? 3 + …? + (n - 1) ? n.",
    "inpdata": "6\n5\n3",
    "outdata": "70\n40\n8",
    "solution": "n = int(input())\ns = 0\nfor i in range(2, n + 1):\n    s += (i - 1) * i\nprint(s)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "228",
    "title": "Напишіть програму для обчислення виразу 1/2 + 2/3 + 3/4 + …? + n/(n + 1) із заданим n, яке вводить користувач (n > 0).",
    "inpdata": "5\n10\n3",
    "outdata": "3.55\n7.98\n1.92",
    "solution": "n = int(input())\nsum = 0\nfor i in range(1, n + 1):\n    sum += float(float(i) / (i + 1))\nprint('{0:.2f}'.format(sum))",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "229",
    "title": "Визначити суму всіх трицифрових чисел, які діляться націло на n, де n - ціле число, яке вводить користувач.",
    "inpdata": "125\n440\n600\n1000",
    "outdata": "3500\n1320\n600\n0",
    "solution": "n = int(input())\ns = 0\nfor i in range(100, 1000):\n    if i % n == 0:\n        s += i \nprint(s)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "230",
    "title": "Напишіть програму, в якій користувач вводить цілі числа. Якщо буде введено ціле число n, програма має завершити своє виконання повідомленням \"Done\". Спочатку користувач вводить число n, а потім решту чисел.",
    "inpdata": "5\n67\n112\n14\n5",
    "outdata": "Done",
    "solution": "n = int(input())\nwhile True:\n    a = int(input())\n    if a == n:\n        print('Done')\n        break",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "231",
    "title": "Пароль доступу до комп’ютера зберігається у змінній n - ціле число, яке вводить користувач. Напишіть програму, яка запитує пароль в користувача. У разі введення користувачем неправильного пароля на екран має виводитися повідомлення \"Error\", після чого дії повинні повторюватися до введення правильного значення. При успішній аутентифікації в ситемі має з’явитися повідомлення \"Done\".",
    "inpdata": "12345",
    "outdata": "111\nError\n45\nError\n12345\nDone",
    "solution": "n = int(input())\nwhile True:\n    a = int(input())\n    if a == n:\n        print('Done')\n        break\n    else:\n        print('Error')",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "232",
    "title": "Дано n чисел. Визначте, скільки з них дорівнюють нулю, і виведіть цю кількість. Спочатку вводиться число n, потім вводиться рівно n цілих чисел.",
    "inpdata": "4\n0\n23\n11\n0",
    "outdata": "2",
    "solution": "n = int(input())\nk = 0\nfor i in range(1, n + 1):\n    a = int(input())\n    if a == 0:\n        k += 1\nprint(k)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "233",
    "title": "Дано n цілих чисел. Кожне число вводиться в окремому рядку. Обчисліть суму чисел.",
    "inpdata": "10\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9",
    "outdata": "45",
    "solution": "n = int(input())\ns = 0\nfor i in range(1, n + 1):\n    a = int(input())\n    s += a\nprint(s)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "234",
    "title": "Система відслідковування помилок в комп’ютерній програмі збирає помилки щодня протягом n днів. Напишіть програму, яка знаходить загальну кількість помилок, зібраних протягом n днів. Користувач вводить кількість днів роботи системи відслідковування помилок n і вводить кількість помилок m щодня (n і m - цілі числа).",
    "inpdata": "6\n45\n101\n67\n43\n21\n0",
    "outdata": "277",
    "solution": "days = 1\ntotal = 0\nn = int(input())\nwhile days <= n:\n    bugs = int(input())\n    total += bugs\n    days += 1\nprint(total)",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "235",
    "title": "Біг на біговій доріжці дозволяє спалювати n калорій за хвилину. Напишіть програму, щоб відобразити кількість калорій, спалених протягом 10, 15, 20, 25 і 30 хвилин",
    "inpdata": "4.2",
    "outdata": "42.0\n63.0\n84.0\n105.0\n126.0",
    "solution": "n = float(input())\nminutes = 10\nwhile minutes <= 30:\n    print(minutes * n)\n    minutes += 5",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "236",
    "title": "Напишіть програму, яка виводить таблицю цілих значень температури не більше t (t ≥ 0) в градусах Цельсія (C) і відповідні значення за шкалою Фаренгейта (F) (F = 9*C/5 + 32).",
    "inpdata": "10",
    "outdata": "0 \t 32.00\n1 \t 33.80\n2 \t 35.60\n3 \t 37.40\n4 \t 39.20\n5 \t 41.00\n6 \t 42.80\n7 \t 44.60\n8 \t 46.40\n9 \t 48.20\n10 \t 50.00",
    "solution": "n = int(input())\nfor c in range(n + 1):\n    print(format(c, '.0f'), '\t', format(9 / 5 * c + 32, '.2f'))",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "237",
    "title": "Припускаючи, що рівень океану зараз зростає приблизно на n міліметрів на рік. Напишіть програму, яка відображатиме значення щорічного росту рівня океану протягом наступних m років.",
    "inpdata": "1.6\n5",
    "outdata": "1 \t  1.60\n2 \t  3.20\n3 \t  4.80\n4 \t  6.40\n5 \t  8.00",
    "solution": "n = float(input())\nm = int(input())\nfor i in range(1, m + 1):\n    print(format(i, '.0f'), '\t', format(i * n, '5.2f'))",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "238",
    "title": "Надрукувати таблицю значень 1, 2, …? n доларів США у переведенні на гривні за поточним курсом k (значення курсу вводиться з клавіатури).",
    "inpdata": "5\n27.85",
    "outdata": "1 \t 27.85\n2 \t 55.70\n3 \t 83.55\n4 \t 111.40\n5 \t 139.25",
    "solution": "n = int(input())\nm = float(input())\nfor i in range(1, n + 1):\n    print(format(i, 'd'), '\t', format(i * m, '.2f'))",
    "chapter": "цикли",
    "level": "початковий"
  },
  {
    "id": "239",
    "title": "Намалювати сходинки як у вихідних даних, використовуючи символи пропуску і решітки \"#\", коли на вхід програми подається ціле число n - кількість сходинок.",
    "inpdata": "4",
    "outdata": "   #\n  ##\n ###\n####",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    print(' ' * (n - i) + i * '#')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "240",
    "title": "Напишіть програму для побудови шаблону як у вихідних даних за введеними значеннями n і m.",
    "inpdata": "6\n3",
    "outdata": "0 \t0 \t0\n1 \t1 \t1\n2 \t2 \t2\n3 \t3 \t3\n4 \t4 \t4\n5 \t5 \t5\n6 \t6 \t6",
    "solution": "n = int(input())\nm = int(input())\nfor i in range(n + 1):\n    for j in range(m):\n        print(i, '\t', end ='')\n    print()",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "241",
    "title": "Напишіть програму для побудови шаблону як у вихідних даних за введеним значенням n.",
    "inpdata": "7",
    "outdata": "1 \t2 \t3 \t4 \t5 \t6 \t7\n2 \t3 \t4 \t5 \t6 \t7\n3 \t4 \t5 \t6 \t7\n4 \t5 \t6 \t7\n5 \t6 \t7\n6 \t7\n7",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    for j in range(i, n + 1):\n        print(j, '\t', end ='')\n    print()",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "242",
    "title": "Дано два цілих числа a і b. Виведіть всі числа від a до b включно, в порядку зростання, якщо a < b, або в порядку спадання у іншому випадку.",
    "inpdata": "12\n1",
    "outdata": "12 11 10 9 8 7 6 5 4 3 2 1",
    "solution": "a = int(input())\nb = int(input())\nif a < b:\n    n = 1\nelse:\n    n = -1\nfor i in range(a, b + n, n):\n        print(i, end=' ')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "243",
    "title": "Дано n чисел. Перше число на вході n, після чого задано n цілих чисел. Необхідно порахувати кількість нулів серед введених користувачем чисел.",
    "inpdata": "6\n2\n0\n9\n4\n0\n5",
    "outdata": "2",
    "solution": "num_zeroes = 0\nfor i in range(int(input())):\n    if int(input()) == 0:\n        num_zeroes += 1\nprint(num_zeroes)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "244",
    "title": "Надрукувати усі двоцифрові числа, сума квадратів цифр яких ділиться на n націло. Число n - ціле число, яке вводить користувач.",
    "inpdata": "100",
    "outdata": "59 68 69 78 79 86 87 88 89 95 96 97 98 99 100",
    "solution": "n = int(input())\nfor i in range(10, 101):\n    if ((i % 10)**2 + (i // 10)**2) // n:\n        print(i, end=' ')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "245",
    "title": "Напишіть програму, яка друкує усі непарні числа з інтервалу [1, b], де b - ціле число, яке вводить користувач. Не можна використовувати конструкцію розгалуження.",
    "inpdata": "15\n8",
    "outdata": "51 3 5 7 9 11 13 15\n1 3 5 7",
    "solution": "b = int(input())\nfor i in range(1, b + 1, 2):\n    print(i, end=' ')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "246",
    "title": "За даним цілим додатнім числом n обчисліть n! - значення факторіалу цього числа.",
    "inpdata": "3\n4\n1",
    "outdata": "6\n24\n1",
    "solution": "n = int(input())\nf = 1\nfor i in range(1, n + 1):\n    f = f * i\nprint(f)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "247",
    "title": "Дано ціле число n, яке вводить користувач. Необхідно обчислити значення виразу 1! +2! +3! + …? + n!.",
    "inpdata": "3\n4\n5",
    "outdata": "9\n33\n152",
    "solution": "n = int(input())\npartial_factorial = 1\npartial_sum = 0\nfor i in range(1, n + 1):\n    partial_factorial *= i\n    partial_sum += partial_factorial\nprint(partial_sum)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "248",
    "title": "Користувач вводить n-цифрове ціле число. Необхідно вивести числа, утворені із введеного, відкиданням останньої цифри з кожного попереднього числа.",
    "inpdata": "138945",
    "outdata": "13894\n1389\n138\n13\n1",
    "solution": "n = int(input())\nwhile n > 0:\n    n = n // 10\n    if n == 0:\n        continue\n    print(n)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "249",
    "title": "Програма отримує на вхід послідовність цілих невід’ємних чисел, кожне число вводиться в окремому рядку. Послідовність завершується числом 0, при зчитуванні якого програма повинна закінчити свою роботу і вивести кількість членів послідовності (не рахуючи завершального числа 0).",
    "inpdata": "8\n4\n6\n0",
    "outdata": "3",
    "solution": "k = 0\nwhile (int(input())) != 0:\n    k += 1\nprint(k)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "250",
    "title": "Визначте суму усіх елементів послідовності, яка завершується числом 0. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення).",
    "inpdata": "2\n5\n3\n0",
    "outdata": "10",
    "solution": "s = 0\nn = -1\nwhile n != 0:\n    n = int(input())\n    s += n\nprint(s)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "251",
    "title": "Визначте середнє значення всіх елементів послідовності, яка завершується числом 0. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення).",
    "inpdata": "3\n4\n5\n0",
    "outdata": "4.0",
    "solution": "s = 0\nk = -1\nn = -1\nwhile n != 0:\n    n = int(input())\n    s += n\n    k += 1\nprint('{0:}'.format(s / k))",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "252",
    "title": "Визначте кількість парних елементів в послідовності, яка завершується числом 0. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використвоується як ознака її закінчення).",
    "inpdata": "3\n6\n9\n8\n0",
    "outdata": "2",
    "solution": "k = 0\nn = -1\nwhile n != 0:\n    n = int(input())\n    if n % 2 == 0 and n != 0:\n        k += 1\nprint(k)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "253",
    "title": "Послідовність складається з натуральних чисел і завершується числом 0. Визначте значення найбільшого елемента послідовності. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення).",
    "inpdata": "5\n3\n8\n0",
    "outdata": "8",
    "solution": "m = 0\nn = -1\nwhile n != 0:\n    n = int(input())\n    if n > m:\n        m = n\nprint(m)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "254",
    "title": "Автогонщик в перший день ралі проїхав d км. Кожен наступний день він збільшував пробіг на 10% від пробігу попереднього дня. Через скільки днів автоспортивних змагань сумарний пробіг автомобіля за всі дні перевищить t км і яке значення сумарного пробігу? Введення даних користувачем відбувається в порядку: d, t.",
    "inpdata": "10\n200",
    "outdata": "211.14 km, 33 days",
    "solution": "d = int(input())\nt = int(input())\ndays = 1\ns = 0\nwhile d < t:\n    d = d * 1.1 \n    s = s + d\n    days += 1 \nprint('{0:5.2f} km, {1:d} days'.format(d, days))",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "255",
    "title": "Визначити кількість трицифрових чисел, сума цифр яких дорівнює деякому цілому значенню n, яке вводить користувач.",
    "inpdata": "27\n2\n20",
    "outdata": "1\n3\n36",
    "solution": "n = int(input())\nk = 0\nfor i in range(100, 1000):\n    if ((i // 100) + (i // 10 % 10) + (i % 10)) == n:\n        k += 1\nprint(k)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "256",
    "title": "Напишіть програму, яка виводить усі трицифрові числа, сума цифр яких дорівнює деякому значенню n, яке вводить користувач.",
    "inpdata": "4",
    "outdata": "112\n121\n130\n202\n211\n220\n301\n310\n400",
    "solution": "n = int(input())\nfor i in range(100, 1000):\n    if ((i // 100) + (i // 10 % 10) + (i % 10)) == n:\n        print(i)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "257",
    "title": "Дано ціле число n. З чисел 1, 4, 9, 16, 25, …? надрукувати ті, які не перевищують n.",
    "inpdata": "25",
    "outdata": "1\n4\n9\n16\n25",
    "solution": "n = int(input())\ni = 1\nwhile i**2 <= n:\n    print(i**2)\n    i += 1",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "258",
    "title": "Для обчислення числа Пі можна використовувати наступне наближення (ряд Лейбніца): Pi = 4/1 - 4/3 + 4/5 - 4/7 + .... Обчисліть перші n членів цього ряду.",
    "inpdata": "10",
    "outdata": "3.0418396189294032",
    "solution": "number_pi = 0\nn = int(input())\nfor i in range(0, n):\n    c = pow(-1, i)\n    number_pi += (4 * c)/(2 * i + 1)\nprint(number_pi)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "259",
    "title": "Дано цілі числа a і b. Знайти їх добуток, не використовуючи операцію множення.",
    "inpdata": "7\n3",
    "outdata": "21",
    "solution": "a = int(input())\nb = int(input())\np = 0\nfor i in range(1, b + 1):\n    p = p + a\nprint(p)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "260",
    "title": "Дано цілі числа a і b. Обчислити a^b, не використовуючи операцію піднесення до степеня.",
    "inpdata": "4\n2",
    "outdata": "16",
    "solution": "a = int(input())\nb = int(input())\np = 1\nfor i in range(1, b + 1):\n    p = p * a\nprint(p)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "261",
    "title": "Напишіть програму, яка зчитує числа (по одному в рядку) до тих пір, поки сума введених чисел не буде дорівнювати 0 і відразу після цього виводить суму квадратів всіх введених чисел. Гарантується, що в якийсь момент сума введених чисел дорівнюватиме 0, після цього зчитування продовжувати не потрібно.",
    "inpdata": "2\n-4\n6\n-17\n12\n10\n-9",
    "outdata": "670",
    "solution": "rez_sum = 0\nrez_sqr = 0\nwhile True:\n    s = int(input())\n    rez_sum += s\n    rez_sqr += s**2\n    if rez_sum == 0:\n        print(rez_sqr)\n        break",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "262",
    "title": "Одноклітинна амеба кожні 3 години ділиться на 2 клітини. Визначити, скільки клітин буде через t годин, якщо спочатку була одна амеба.",
    "inpdata": "6\n9\n24",
    "outdata": "4\n8\n256",
    "solution": "t = int(input())\nf = 1\nt = t // 3;\nfor i in range(1, t + 1):\n    f = f * 2\nprint(f)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "263",
    "title": "Учні 5 класу вели щоденники спостереження за погодою і щодня записували денну температуру. Знайдіть найнижчу температуру за весь час спостережень. Якщо температура знижувалась нижче -15 градусів, необхідно вивести \"Yes\", у протилежному випадку \"No\". Програма отримує на вхід кількість днів, протягом яких проводилося спостереження n (1 ≤ n ≤ 31), потім для кожного дня вводиться температура.",
    "inpdata": "3\n-20\n2\n-18",
    "outdata": "-20\nYes",
    "solution": "n = int(input())\nm = 100\nfor i in range(1, n + 1):\n    t = int(input())\n    if t < m:\n        m = t    \nprint(m)\nif m < -15:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "264",
    "title": "Старшокласники брали участь у вікторині з інформатики. Необхідно було відповісти на 20 питань. Переможцем вікторини вважається учасник, який правильно відповів на найбільшу кількість запитань. На скільки питань переможець відповів правильно? Якщо є учасники вікторини, які не змогли дати правильну відповідь ні на одне із запитань, виведіть \"Yes\", інакше виведіть \"No\". Гарантується, що є учасники, які правильно відповіли хоча б на одне запитання. Программа отримує на вхід число учасників вікторини n (1 ≤ n ≤ 50), потім для кожного учасника вводиться кількість питань, на які отримано правильну відповідь.",
    "inpdata": "5\n10\n15\n7\n0\n16",
    "outdata": "16\nYes",
    "solution": "n = int(input())\nk = 0\nm = 0\nfor i in range(1, n + 1):\n    b = int(input())\n    if b == 0:\n        k += 1\n    if b > m:\n        m = b    \nprint(m)\nif k > 0:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "265",
    "title": "Камера спостереження реєструє в автоматичному режимі швидкість проїжджаючих повз неї автомобілів, округляючи значення швидкості до цілих чисел. Необхідно визначити середню зареєстровану швидкість всіх автомобілів. Якщо швидкість хоча б одного автомобіля була більше 60 км/год, виведіть \"Yes\", інакше виведіть \"No\". Програма отримує на вхід число зафіксованих автомобілів n (1 ≤ n ≤ 30), потім вказуються їх швидкості. Значення швидкості не може бути менше 1 і більше 300. Програма повинна спочатку вивести середню швидкість з точністю до одного знака після десяткової крапки, потім \"Yes\" або \"No\".",
    "inpdata": "3\n50\n45\n65",
    "outdata": "53.3\nYes",
    "solution": "n = int(input())\ns = 0\nb = False\nfor i in range(1, n + 1):\n    v = int(input())\n    s += v\n    if v >= 60:\n        b = True\nprint('{0:.1f}'.format(s / n)) \nif b:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "266",
    "title": "Камера спостереження реєструє в автоматичному режимі швидкість проїжджаючих повз неї автомобілів, округляючи значення швидкості до цілих чисел. Необхідно визначити: різницю максимальної і мінімальної швидкостей автомобілів; кількість автомобілів, швидкість яких не перевищувала 30 км/год. Програма отримує на вхід число зафіксованих автомобілів n (1 ≤ n ≤ 30), потім вказуються їх швидкості. Значення швидкості не може бути менше 1 і більше 300. Програма повинна спочатку вивести різницю максимальної та мінімальної швидкостей автомобілів, потім кількість автомобілів, швидкість яких не перевищувала 30 км/год.",
    "inpdata": "3\n15\n25\n140",
    "outdata": "125\n2",
    "solution": "n = int(input())\nmax_v = 0\nmin_v = 301\nk = 0\nfor i in range(1, n + 1):\n    v = float(input())\n    if v <= 30:\n        k += 1\n    if v > max_v:\n        max_v = v\n    if v < min_v:\n        min_v = v       \nprint(round(max_v) - round(min_v))\nprint(k)",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "267",
    "title": "Напишіть програму, яка виводить двовимірну квадратну таблицю n x n чисел (n - ціле число, яке вводить користувач). По головній діагоналі таблиці (від лівого верхнього значення до нижнього правого значення) мають розміщуватися 0, вище головної діагоналі розміщуються 1, а нижче - -1. Для гарного відображення таблиці при виведенні її значень використовуйте символ табуляції \"\\t\".",
    "inpdata": "5",
    "outdata": "0\t1\t1\t1\t1\n-1\t0\t1\t1\t1\n-1\t-1\t0\t1\t1\n-1\t-1\t-1\t0\t1\n-1\t-1\t-1\t-1\t0",
    "solution": "n = int(input())\nfor i in range(n):\n    for j in range(n):\n        if i == j:\n            print(0, end='\t')\n        elif j > i:\n            print(1, end='\t')\n        elif i > j:\n            print(-1, end='\t')\n    print()",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "268",
    "title": "За даним натуральним числом n (n ≤ 9) виведіть драбинку з n сходинок як у вихідних даних, n-а сходинка складається з чисел від 1 до n без пропусків.",
    "inpdata": "5",
    "outdata": "1\n12\n123\n1234\n12345",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    for j in range(1, i + 1):\n        print(j, sep='', end='')\n    print()",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "269",
    "title": "Напишіть програму, на вхід якої безперервно (у циклі) подаються введені користувачем дані. При введенні будь-яких даних, окрім цілих числел, виводиться повідомлення про помилку за допомогою генерування винятку ValueError. Як тільки ввели ціле число, виводиться повідомлення True і відбувається вихід з програми.",
    "inpdata": "Python\n2.5\n@\n42",
    "outdata": "This is not a integer number. Try again...\nThis is not a integer number. Try again...\nThis is not a integer number. Try again...\nTrue",
    "solution": "while True:\n    try:\n        a = int(input())\n        print(True)\n        break\n    except ValueError:\n        print('This is not a integer number. Try again...')",
    "chapter": "цикли",
    "level": "середній"
  },
  {
    "id": "270",
    "title": "Дано натуральне число n. Визначити, чи є воно автоморфним числом. Примітка. Автоморфне число - число, квадрат якого рівний останнім розрядами квадрата цього числа: 5 - 25, 6 - 36, 25 - 625.",
    "inpdata": "9376\n26",
    "outdata": "True\nFalse",
    "solution": "n = int(input())\nm = n\nr = 1\nwhile m > 0:\n    m = m // 10\n    r = r * 10\nif (n * n % r) == n:\n    print(True)\nelse:\n    print(False)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "271",
    "title": "Дано натуральне число n. Надрукуйте всі n-значні непарні натуральні числа в порядку спадання.",
    "inpdata": "1\n2",
    "outdata": "9 7 5 3 1\n99 97 95 93 91 89 87 85 83 81 79 77 75 73 71 69 67 65 63 61 59 57 55 53 51 49 47 45 43 41 39 37 35 33 31 29 27 25 23 21 19 17 15 13 11",
    "solution": "n = int(input())\nif n != 1:\n    for i in range(int(n * '1') * 9, int(n * '1') - int((n - 1) * '1'), -1):\n        if i % 2 != 0:\n            print(i, end=' ')\nelse:\n    for i in range(10, n - 1, -1):\n        if i % 2 != 0:\n            print(i, end=' ')",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "272",
    "title": "Дано два натуральних числа a і b. Розробити програму для визначення найбільшого спільного дільника (НСД) заданих чисел. Використайте алгоритм Евкліда.",
    "inpdata": "8\n2",
    "outdata": "2",
    "solution": "a = int(input())\nb = int(input())\nwhile a != b:\n    if a > b:\n        a = a - b\n    else:\n        b = b - a\nprint(a)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "273",
    "title": "Напишіть програму, яка допомагає знайти число (НСК - найменше спільне кратне) двох чисел. Програма повинна зчитувати два додатних цілих числа a і b (кожне число вводиться на окремому рядку) і виводити найменше число, яке ділиться на обидва цих числа без залишку. НСК(a, b) = |ab| / НСД(a, b), де НСД(a, b) - найбільший спільний дільник чисел a, b.",
    "inpdata": "8\n5",
    "outdata": "40",
    "solution": "a = int(input())\nb = int(input())\nc = a * b\nwhile a != b:\n    if a > b:\n        a = a - b\n    else:\n        b = b - a\nprint(c // a)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "274",
    "title": "Дано цілі числа a і b (a > b). Визначити результати цілочисельного ділення a на b і залишку від ділення a на b, не використовуючи стандартні операції цілочисельного ділення і залишку від ділення. Результати необхідно вивести в одному рядку, спочатку результат цілочисельного ділення, а потім залишок від ділення, розділені одним пропуском.",
    "inpdata": "16\n5",
    "outdata": "3 1",
    "solution": "a = int(input())\nb = int(input())\nm = a\nn = 0\nwhile a >= b:\n    n += 1\n    a = a - b\nprint(n, m - (n * b))",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "275",
    "title": "Дано натуральне число n. Визначити, чи є різниця його максимальної та мінімальної цифр парним числом.",
    "inpdata": "2134389\n1234",
    "outdata": "True\nFalse",
    "solution": "n = int(input())\nmax_n = n % 10\nmin_n = n % 10\nk = 0\nwhile n // 10 > 0:\n    k = n % 10\n    n = n // 10\n    if k > max_n:\n        max_n = k \n    if k < min_n:\n        min_n = k \nk = n % 10\nn = n // 10\nif k > max_n:\n    max_n = k \nif k < min_n:\n    min_n = k \nif (max_n - min_n) % 2 == 0:\n    print(True)\nelse:\n    print(False)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "276",
    "title": "Є монотонна послідовність, в якій кожне натуральне число k зустрічається рівно k разів: 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, .... За введеним натуральним числом n виведіть перші n членів цієї послідовності.",
    "inpdata": "5",
    "outdata": "1 2 2 3 3",
    "solution": "n = int(input())\nk = 1\nfor i in range(1, n+ 1):\n    print(k, end=' ')\n    if i == k * (k + 1) // 2:\n        k += 1",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "277",
    "title": "Написати програму для обчислення суми цифр цілого числа n. Програма має враховувати, що на вхід може подаватися ціле від’ємне число.",
    "inpdata": "-123\n1\n412098",
    "outdata": "6\n1\n24",
    "solution": "n = int(input())\nif n < 0:\n    n = n * (-1)\ns = 0\nwhile n > 0:\n    s += n % 10\n    n = n // 10\nprint(s)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "278",
    "title": "Внесок на депозитний рахунок у банку становить d гривень. Щорічно він збільшується на r відсотків, після чого дробова частина копійок відкидається. Визначте, через скільки років внесок складе не менше b гривень. Програма отримує на вхід три натуральних числа: d, r, b.",
    "inpdata": "1000\n14\n2500",
    "outdata": "7",
    "solution": "d = float(input()) \nr = float(input())\nb = float(input())\ny = 0\nwhile d < b:\n    t = round(int(r * d) / 100, 2)\n    d += t\n    y += 1\nprint(y)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "279",
    "title": "Напишіть програму для отримання рядка Фібоначчі від 0 до n, де n - ціле число. Послідовність Фібоначчі - це серія чисел 0, 1, 1, 2, 3, 5, 8, 13, 21, .... Кожне наступне число знайдено шляхом додавання двох номерів перед ним.",
    "inpdata": "50",
    "outdata": "1 1 2 3 5 8 13 21 34",
    "solution": "x = 0\ny = 1\nn = int(input())\nif n == 0:\n    print(0)\nelse:\n    while y < n:\n        print(y, end=' ')\n        x, y = y, x + y",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "280",
    "title": "За введеним користувачем цілим числом n визначте n-е число Фібоначчі.",
    "inpdata": "9\n3\n5",
    "outdata": "34\n2\n5",
    "solution": "x = 0\ny = 1\nn = int(input())\nif n == 0:\n    print(0)\nelse:\n    for i in range(2, n + 1):\n        x, y = y, x + y\n    print(y)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "281",
    "title": "Дано натуральне число n. Визначте, яким за рахунком числом Фібоначчі воно є. Якщо n не є числом Фібоначчі, виведіть значення -1.",
    "inpdata": "11\n8",
    "outdata": "-1\n6",
    "solution": "x = 0\ny = 1\ni = 1\nn = int(input())\nif n == 0:\n    print(0)\nelse:\n    while y < n:\n        x, y = y, x + y\n        i += 1\n    if y == n:\n        print(i)\n    else:\n        print(-1)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "282",
    "title": "Послідовність складається з натуральних чисел і завершується числом 0. Визначте, скільки елементів цієї послідовності більше попереднього елемента. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення).",
    "inpdata": "4\n3\n6\n8\n0",
    "outdata": "2",
    "solution": "k = 0\nn = -1\nwhile n != 0:\n    m = int(input())\n    if (n < m) and (n != -1):\n        k += 1\n    n = m\nprint(k)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "283",
    "title": "Послідовність складається з цілих чисел і закінчується номером 0. Визначте, скільки елементів цієї послідовності більше наступного елемента. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення). Гарантується, що послідовність містить як мінімум два числа.",
    "inpdata": "2\n9\n1\n4\n3\n0",
    "outdata": "2",
    "solution": "prev = int(input())\nanswer = 0\nwhile prev != 0:\n    next = int(input())\n    if next != 0 and prev > next:\n        answer += 1\n    prev = next\nprint(answer)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "284",
    "title": "Послідовність складається з натуральних чисел і завершується числом 0. Визначте, скільки елементів цієї послідовності рівні її найбільшому елементу. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення).",
    "inpdata": "3\n8\n10\n2\n10\n7\n0",
    "outdata": "2",
    "solution": "m = 0\nc = 1\nm_index = 0\nwhile True:\n    n = int(input())\n    if n != 0:\n        if n == m:\n            c += 1\n        if m < n:\n           c = 1\n           m = n\n    else:\n        break\nprint(c)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "285",
    "title": "Послідовність складається з різних натуральних чисел і завершується числом 0. Визначте значення другого за величиною елемента в цій послідовності. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення). Гарантується, що в послідовності є хоча б два елементи.",
    "inpdata": "1\n4\n3\n2\n0",
    "outdata": "3",
    "solution": "m1, m2 = 0, 0\nwhile True:\n    n = int(input())\n    if n != 0:\n        if n > m1:\n            m2 = m1\n            m1 = n\n        elif n < m1:\n            if n > m2: \n                m2 = n\n    else:\n        print(m2)\n        break",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "286",
    "title": "Послідовність складається з натуральних чисел і завершується числом 0. Визначте індекс найбільшого елемента послідовності. Якщо найбільших елементів декілька, виведіть індекс першого з них. Нумерація елементів починається з нуля. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення).",
    "inpdata": "4\n2\n6\n9\n5\n0",
    "outdata": "3",
    "solution": "m = 0\nc = 0\nm_index = 0\nwhile True:\n    n = int(input())\n    if(n != 0):\n        c += 1\n        if m < n:\n           m = n\n           m_index = c\n    else:\n        break\nprint(m_index - 1)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "287",
    "title": "Дано послідовність ненульових цілих чисел, яка завершується нулем (саме число 0 в послідовність не входить, а використовується як ознака її закінчення). Необхідно обчислити скільки разів в цій послідовності змінюється знак (наприклад, в послідовності 10, -4, 12, 56, -4 знак змінюється 3 рази).",
    "inpdata": "-5\n-3\n10\n6\n-4\n7\n-1\n0",
    "outdata": "4",
    "solution": "k = 0\nn = int(input())\nif n > 0:\n    f = True\nelse:\n    f = False\nwhile n != 0: \n    if (n < 0) and f:\n        f = False \n        k += 1 \n    if (n > 0) and (not f):\n        f = True\n        k += 1\n    n = int(input())\nprint(k)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "288",
    "title": "Дано послідовність натуральних чисел, що завершується числом 0. Визначте найбільше число елементів цієї послідовності, що йдуть підряд один за одним, і дорівнюють один одному. Вводиться послідовність цілих чисел, що закінчується числом 0 (саме число 0 в послідовність не входить, а використовується як ознака її закінчення). Додаткове завдання: виведіть найбільш повторюваний елемент послідовності.",
    "inpdata": "1\n5\n5\n4\n3\n9\n9\n9\n7\n0",
    "outdata": "3",
    "solution": "m = 1\nc = 0\ncc = 1\nwhile True:\n    n = int(input())\n    if n != 0:\n        if n == m:\n            c += 1\n            if c >= cc:\n                r = n # число яке повторилось\n                cc = c # накопичення повторюваних чисел\n            m = n\n        else:\n            m = n\n            c = 1\n    else:\n        break\nprint(cc)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "289",
    "title": "Скласти програму для графічного зображення подільності чисел від 1 до n (значення n вводиться з клавіатури). У кожному рядку треба надрукувати чергове число і стільки символів \"+\", скільки є дільників у цього числа.",
    "inpdata": "5",
    "outdata": "1+\n2++\n3++\n4+++\n5++",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    print(i, end='')\n    for j in range(1, i + 1):\n        if i % j == 0:\n            print('+', end='')\n    print()",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "290",
    "title": "Дано натуральне число n. Визначити номер деякої заданої цифри d в ньому, відраховуючи від кінця числа. Якщо такої цифри немає, відповіддю має бути число 0; якщо таких цифр в числі кілька, повинен бути визначений номер позиції найправішої з них.",
    "inpdata": "1233572\n3",
    "outdata": "4",
    "solution": "n = int(input())\nd = int(input())\nk = 0\np = 0\ndigit = 0\nwhile n > 0:\n    digit = n % 10\n    p += 1\n    if digit == d:\n        k += 1\n        break\n    n = n // 10\nif n == 0 and d == 0:\n    print(1)\nelse:\n    if k > 0:\n        print(p)\n    else:\n        print(0)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "291",
    "title": "Вводиться ціле число n. Вивести число, зворотне по порядку складових його цифр.",
    "inpdata": "125\n123456789\n1",
    "outdata": "521\n987654321\n1",
    "solution": "n1 = int(input())\nn2 = 0\nwhile n1 > 0:\n    digit = n1 % 10\n    n1 = n1 // 10\n    n2 = n2 * 10\n    n2 = n2 + digit\nprint(n2)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "292",
    "title": "Назвемо число паліндромом, якщо воно не змінюється при перестановці його цифр у зворотному порядку. Напишіть програму, яка за введеним користувачем числом n (1 ≤ n ≤ 100000) виводить числа-паліндроми, які не перевищують n.",
    "inpdata": "50",
    "outdata": "1\n2\n3\n4\n5\n6\n7\n8\n9\n11\n22\n33\n44",
    "solution": "n = int(input())\nfor i in range(1, n + 1):\n    j = 0\n    m = i\n    while i > 0:\n        digit = i % 10\n        i = i // 10\n        j = j * 10\n        j = j + digit\n    if m == j:\n        print(m)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "293",
    "title": "Назвемо число паліндромом, якщо воно не змінюється при перестановці його цифр у зворотному порядку. Напишіть програму, яка за введеною користувачем кількістю n (1 ≤ n ≤ 100000) виводить кількість таких чисел-паліндромів, які не перевищують n.",
    "inpdata": "1\n50\n10",
    "outdata": "1\n13\n9",
    "solution": "n = int(input())\nk = 0\nfor i in range(1, n + 1):\n    j = 0\n    m = i\n    while i > 0:\n        digit = i % 10\n        i = i // 10\n        j = j * 10\n        j = j + digit\n    if m == j:\n        k += 1\nprint(k)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "294",
    "title": "Дано два чотирицифрових числа a і b. Виведіть усі чотирицифрові числа на відрізку від a до b, які є паліндромами (читаються однаково як зліва направо, так і справа наліво).",
    "inpdata": "1400\n2200",
    "outdata": "1441\n1551\n1661\n1771\n1881\n1991\n2002\n2112",
    "solution": "a = int(input())\nb = int(input())\nfor i in range(a, b + 1):\n    n4 = i % 10\n    n3 = (i // 10) % 10\n    n12 = i // 100\n    sum34 = 10 * n4 + n3\n    if n12 == sum34:\n        print(i)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "295",
    "title": "Вводяться два чотирицифрових числа a і b. Виведіть у порядку зростання всі чотирицифрові числа в інтервалі від a до b, запис яких містить тільки три однакові цифри.",
    "inpdata": "1400\n1600",
    "outdata": "1411\n1444\n1511\n1555",
    "solution": "a = int(input())\nb = int(input())\nfor i in range(a, b + 1):\n    n4 = i % 10\n    n3 = (i // 10) % 10\n    n2 = (i // 100) % 10\n    n1 = i // 1000\n    if ((n1 == n3) and (n3 == n4)) or ((n2 == n3) and (n3 == n4)) or ((n1 == n2) and (n2 == n3)) or ((n1 == n2) and (n2 == n4)):\n        if (n1 - n2 + n3 - n4) != 0:\n            print(i)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "296",
    "title": "Для настільної гри використовуються картки з номерами від 1 до n. Одна картка загубилася. Знайдіть її, знаючи номери решти карток. Користувач вводить ціле число n, далі n-1 номери решти карток (різні числа від 1 до n). Програма повинна вивести номер втраченої картки.",
    "inpdata": "5\n3\n4\n1\n5",
    "outdata": "2",
    "solution": "n = int(input())\ns = 0\nk = 0\nfor i in range(1, n):\n    number = int(input())\n    k += number\n    s += i\nprint(s + n - k)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "297",
    "title": "Оленка вчиться ділити з залишком. Вона взяла деяке число, розділила його на 2 і відкинула залишок. Те, що вийшло, розділила на 3 та знову відкинула залишок. Отримане число вона розділила на 4, відкинула залишок і отримала число k. Яке число могла вибрати Оленка спочатку? Вводиться натуральне число k, що не перевершує 1000. Необхідно вивести усі можливі числа, які могла б вибрати спочатку Оленка, за зростанням, розділяючи їх пропусками.",
    "inpdata": "1",
    "outdata": "24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47",
    "solution": "k = int(input())\nfor i in range(0, 24):\n    print(24 * k + i, end=' ')",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "298",
    "title": "Скільки всього натуральних чисел складаються з не менш ніж a цифр і не більше, ніж b цифр? Вводяться два довільних натуральних числа a і b в окремих рядках. Виведіть одне число: кількість чисел, що володіють зазначеними властивостями.",
    "inpdata": "1\n2\n1\n1",
    "outdata": "99\n9",
    "solution": "a = int(input())\nb = int(input())\nif a > b:\n    print(0)\nelse:\n    for i in range(a, b + 1):\n        print(9, end='')\n    for i in range(1, a - 1):\n        print(0, end='')",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "299",
    "title": "Дано натуральне число n (n ≤ 1000). Скласти програму для перевірки чи ділиться ціле число на кожну з його цифр без залишку. Надрукувати такі числа в інтервалі від 10 до n в порядку зростання, через пропуск.",
    "inpdata": "100\n40\n20",
    "outdata": "11 12 15 22 24 33 36 44 48 55 66 77 88 99\n11 12 15 22 24 33 36\n11 12 15",
    "solution": "n = int(input())\nfor i in range (10, n + 1):\n    flag = True\n    k = i\n    while k > 0:\n        x = k % 10\n        if x != 0:\n            if (i % x) != 0:\n                flag = False\n        else: \n            flag = False\n        k = k // 10\n    if flag:\n        print(i, end=' ')",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "300",
    "title": "В одній країні використовуються грошові купюри номіналом в 1, 2, 4, 8, 16, 32 і 64. Дано натуральне число n. Якою найменшою кількістю таких грошових знаків можна виплатити суму n (вказати кількість кожної з використовуваних для виплати купюр)? Передбачається, що є досить велика кількість купюр всіх номіналів.",
    "inpdata": "165",
    "outdata": "2 (64)\n1 (32)\n1 (4)\n1 (1)",
    "solution": "n = int(input())\nk = 64\nwhile n > 0: \n    if n >= k:\n        print('{0:} ({1:})'.format(n // k, k))\n        n = n % k\n    k = k // 2",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "301",
    "title": "Задумали два натуральних числа x і y (x, y ≤ 1000). Щоб відгадати ці числа, називають суму цих чисел a і їх добуток b. Відгадайте ці числа і виведіть їх в порядку зростання, розділяючи пропуском.",
    "inpdata": "12\n20\n6\n8",
    "outdata": "2 10\n2 4",
    "solution": "a = int(input())\nb = int(input())\nfor i in range(1, 1001):\n    x = i\n    y = a - x\n    if (x <= y) and (x * y == b):\n        print(x, y)",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "302",
    "title": "Надрукувати всі непарні числа з інтервалу [a, b] (a ≥ b). Розглянути варіант програми без використання інструкції розгалуження.",
    "inpdata": "10\n1",
    "outdata": "9 7 5 3 1",
    "solution": "a = int(input())\nb = int(input())\nfor i in range((a - 1) + a % 2, b - 1, -2):\n    print(i, end=' ')",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "303",
    "title": "Надрукувати всі парні числа з інтервалу [a, b] (a ≤ b). Розглянути варіант програми без використання інструкції розгалуження.",
    "inpdata": "1\n20",
    "outdata": "2 4 6 8 10 12 14 16 18 20",
    "solution": "a = int(input())\nb = int(input())\nfor i in range((a + 1) // 2 * 2, b + 1, 2):\n    print(i, end=' ')",
    "chapter": "цикли",
    "level": "високий"
  },
  {
    "id": "304",
    "title": "Напишіть програму, яка приймає від користувача рядок, і відображає цей рядок у верхньому і нижньому регістрах.",
    "inpdata": "My favourite language is Python",
    "outdata": "MY FAVOURITE LANGUAGE IS PYTHON\nmy favourite language is python",
    "solution": "s = input()\nprint(s.upper())\nprint(s.lower())",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "305",
    "title": "Скласти програму, яка запитує назву баскетбольної команди і повторює її на екрані зі словами: \"This is a champion!\".",
    "inpdata": "Atlanta Hawks",
    "outdata": "Atlanta Hawks! This is a champion!",
    "solution": "s = input()\nprint(s, 'This is a champion!', sep='! ')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "306",
    "title": "Напишіть програму, яка виводить на екран рядок з 5-ти копій останніх двох символів введеного користувачем рядка (довжина введеного рядка повинна бути не менше 2).",
    "inpdata": "emu\nlion",
    "outdata": "mumumumumu\nononononon",
    "solution": "s = input()\nprint(s[-2:]*5)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "307",
    "title": "Дано натуральне число. Знайти число, утворене з вхідного приписуванням до нього такого ж числа.",
    "inpdata": "125\n6\n1",
    "outdata": "125125\n66\n11",
    "solution": "print(input()*2)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "308",
    "title": "Дано натуральне число. Знайти число, що отримується при прочитанні його цифр справа наліво.",
    "inpdata": "98\n10010010\n1235",
    "outdata": "89\n01001001\n5321",
    "solution": "s = input()\nprint(s[::-1])",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "309",
    "title": "Дано рядок. Змініть регістр символів в цьому рядку так, щоб перша буква кожного слова була великою, а інші літери - малими.",
    "inpdata": "A scandal in Bohemia\nThe adventure of the Blue Carbuncle\nThe Boscombe valley mystery",
    "outdata": "A Scandal In Bohemia\nThe Adventure Of The Blue Carbuncle\nThe Boscombe Valley Mystery",
    "solution": "s = input().lower()\nprint(s.title())",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "310",
    "title": "Дано натуральне число. Знайти число, що отримується в результаті приписування по двійці в початок і кінець запису вхідного числа.",
    "inpdata": "45\n1\n0",
    "outdata": "2452\n212\n202",
    "solution": "s = input()\nprint('2' + s + '2')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "311",
    "title": "Користувач вводить рядок і набір символів. Напишіть програму, яка перевіряє чи починається рядок із зазначених символів.",
    "inpdata": "wireless router\nroute",
    "outdata": "False",
    "solution": "s = input()\nelements = input()\nprint(s.startswith(elements))\n",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "312",
    "title": "Дано рядок. Визначити порядковий номер першої вказаної букви. Якщо такої літери немає, вивести нуль.",
    "inpdata": "euro\nr",
    "outdata": "3",
    "solution": "print(input().find(input())+1)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "313",
    "title": "Дано слово. З'ясуйте, чи слово починається і закінчується на одну і ту ж букву? Регістр літер не враховувати.",
    "inpdata": "Africa\nOceania",
    "outdata": "True\nFalse",
    "solution": "s = input().lower()\nprint(s[0] == s[-1])",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "314",
    "title": "Напишіть програму, яка отримує три рядки: прізвище, ім’я і по батькові особи, а потім виводить на екран ініціали та прізвище.",
    "inpdata": "Hansson\nDavid\nHeinemeier",
    "outdata": "D.H.Hansson",
    "solution": "first = input()\nmiddle = input()\nlast = input()\nprint(middle[0].upper(), '.', last[0].upper(), '.', first, sep='')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "315",
    "title": "Скласти програму, яка визначає, який з двох введених рядків довший і друкує його. Якщо рядки рівні, вивести повідомлення \"equally\".",
    "inpdata": "Linus\nGuido",
    "outdata": "equally",
    "solution": "s1 = input()\ns2 = input()\nif len(s1) > len(s2):\n    print(s1)\nelif len(s1) < len(s2):\n    print(s2)\nelse:\n    print('equally')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "316",
    "title": "Дано натуральне число. Знайти число, що отримується з вхідного перестановкою його першої та останньої цифр. Врахувати випадок введення одноцифрового числа.",
    "inpdata": "1467\n5\n11\n12",
    "outdata": "7461\n5\n11\n21",
    "solution": "s = input()\nif len(s) >= 2:\n    print(s[-1] + s[1:-1] + s[0])\nelse:\n    print(s)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "317",
    "title": "Дано два слова. Скласти програму, яка визначає, чи перше слово починається на ту ж букву, на яку закінчується друге слово.",
    "inpdata": "Python\nRuby",
    "outdata": "False",
    "solution": "s1 = input()\ns2 = input()\nif s1[0] == s2[-1]:\n    print(True)\nelse:\n    print(False)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "318",
    "title": "Дано натуральне число. Знайти число, що отримується видаленням з вхідного усіх зазначених цифр.",
    "inpdata": "34547\n4",
    "outdata": "357",
    "solution": "s = input()\nd = input() \nprint(s.replace(d, ''))",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "319",
    "title": "Напишіть програму, яка зчитує значення a і b і виводить вірш, в якому замість a і b використовуються ці значення.",
    "inpdata": "A\nB",
    "outdata": "A and B sat in the tree.\nA had fallen, B was stolen.\nWhat's remaining in the tree?",
    "solution": "a = input()\nb = input()\nprint(a, 'and', b, 'sat in the tree.')\nprint(a, 'had fallen,', b, 'was stolen.')\nprint('What\\'s remaining in the tree?')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "320",
    "title": "Користувач вводить рядок, в якому можуть бути пристуні пропуски. Визначити, чи є рядок паліндромом, тобто таким, який однаково читається як справа наліво, так і зліва направо. Для літер регістр не враховувати. Приклади рядків-паліндромів: \"racecar\", \"10201\", \"Ada\", \"Never odd or even\".",
    "inpdata": "Ada\nAble was I ere I saw Elba\n10501\nOrigin",
    "outdata": "True\nTrue\nTrue\nFalse",
    "solution": "s = input().lower()\nif s == s[::-1]:\n    print(True)\nelse:\n    print(False)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "321",
    "title": "Дано два рядки, що можуть містити пропуски. Виведіть слово \"Yes\", якщо перший рядок є підрядком другого рядка або слово \"No\" в іншому випадку.",
    "inpdata": "Lords of the World\nBut who shall dwell in these worlds if they be inhabited? Are we or they Lords of the World? And how are all things made for man?",
    "outdata": "Yes",
    "solution": "c1 = input()\nc2 = input()\nif c1 in c2:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "322",
    "title": "З клавіатури вводиться два цілих числа a і b. Напишіть програму, яка порівнює ці числа і в залежності від результату порівняння виводить на екран потрібний вираз, наприклад: 3 < 5 або 3 = 3 або 3 > 2. Команду print для виведення результату дозволяється використовувати лише один раз.",
    "inpdata": "10\n15",
    "outdata": "10 < 15",
    "solution": "a = int(input())\nb = int(input())\nc = ''\nif a == b:\n    c = '='\nelif a > b:\n    c = '>'\nelse:\n    c = '<'\nprint(a, c, b)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "323",
    "title": "Напишіть програму, щоб перевірити, з яких символів складається рядок, введений користувачем: лише з цифр, лише з букв, або з букв і цифр.",
    "inpdata": "abc\nStreet122\n23",
    "outdata": "Your message includes letters only.\nYour message includes numbers and letters.\nYour message includes numbers only.",
    "solution": "s = input()\nif s.isdigit():\n    print('Your message includes numbers only.')\nelif s.isalpha():\n    print('Your message includes letters only.')\nelif s.isalnum():\n    print('Your message includes numbers and letters.')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "324",
    "title": "Для введеного єдиного символу, перевірте, чи є він цифрою. Під час розв’язування задачі не можна використовувати функції для роботи з рядками. Програма повинна вивести слово \"Yes\", якщо символ є цифрою, або слово \"No\".",
    "inpdata": "7\nA\nh",
    "outdata": "Yes\nNo\nNo",
    "solution": "c = input()\nif (c >= '0') and (c <= '9'):\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "325",
    "title": "Напишіть програму, щоб отримати новий рядок з двох заданих введених рядків (складаються мінімум з двох символів кожен), розділених пробілом, і обміном перших двох символів у кожному із вхідних рядків.",
    "inpdata": "liopping\nshst",
    "outdata": "shopping list",
    "solution": "a = input()\nb = input()\nnew_a = b[:2] + a[2:]\nnew_b = a[:2] + b[2:]\nprint(new_a + ' ' + new_b)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "326",
    "title": "Дано рядок. Замініть у цьому рядку всі цифри 4 на слово \"Four\".",
    "inpdata": "4 Christmases\nFantastic 4\nThe Nutcracker and the 4 Realms",
    "outdata": "Four Christmases\nFantastic Four\nThe Nutcracker and the Four Realms",
    "solution": "print(input().replace('4', 'Four'))",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "327",
    "title": "Дано рядок. Замініть у цьому рядку усі входження певної літери англійського алфавіту, яку вводить користувач у нижньому регістрі, на відповідну літеру у верхньому регістрі. Спочатку вводиться літера, а потім рядок, у якому треба виконати заміну.",
    "inpdata": "a\n\"Curiouser and curiouser!\" cried Alice (she was so much surprised that for the moment she quite forgot how to speak good English).",
    "outdata": "\"Curiouser And curiouser!\" cried Alice (she wAs so much surprised thAt for the moment she quite forgot how to speAk good English).",
    "solution": "letter = input()\ns = input()\nprint(s.replace(letter, letter.upper()))",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "328",
    "title": "Користувач вводить рядок, у якому чергуються цифри та інші символи. На початку і у кінці рядка цифри відсутні. Напишіть програму, яка друкує усі символи введеного рядка у тому ж порядку, але без цифр.",
    "inpdata": "H1e2l3l4o5w6o7r8l9d\ni1m3p4o9r0t4 6t7h8i9s",
    "outdata": "Helloworld\nimport this",
    "solution": "s = input()\ns = s[::2]\nprint(s)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "329",
    "title": "Напишіть програму, щоб у введеному користувачем рядку виконати обмін місцями першого та останнього символів.",
    "inpdata": "Hong Kong\nAntarctica",
    "outdata": "gong KonH\nantarcticA",
    "solution": "s = input()\nprint(s[-1] + s[1:-1] + s[0])",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "330",
    "title": "Напишіть програму, яка змінює регістр введеного єдиного символу, тобто переводить великі літери у малі, а малі - у великі, інші символи не змінює.",
    "inpdata": "a\nF\n5",
    "outdata": "A\nf\n5",
    "solution": "c = input()\nif c >= 'a' and c <= 'z':\n    print(chr(ord(c) - 32))\nelif c >= 'A' and c <= 'Z':\n    print(chr(ord(c) + 32))\nelse:\n    print(c)",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "331",
    "title": "Вводиться додатне ціле трицифрове число. Знайти суму цифр числа. Операціями ділення націло і остача від ділення користуватися не можна.",
    "inpdata": "179",
    "outdata": "17",
    "solution": "number = input()\nprint(int(number[0]) + int(number[1]) + int(number[2]))",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "332",
    "title": "Напишіть програму, яка виводить перше слово у рядку. Слово - це послідовність непробільних символів, обмежена пропусками або межами рядка. Вхідний рядок містить довільну послідовність символів. Програма повинна вивести перше слово цього рядка.",
    "inpdata": "Stranger Things",
    "outdata": "Stranger",
    "solution": "s = input().strip() \ni = s.find(' ')\nif i == -1: \n    print(s)\nelse:\n    print(s[:i])",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "333",
    "title": "Напишіть програму, яка виводить останнє слово у рядку. Слово – це послідовність непробільних символів, обмежена пропусками або межами рядка. Вхідний рядок містить довільну послідовність символів. Програма повинна вивести останнє слово цього рядка.",
    "inpdata": "Holmes & Watson",
    "outdata": "Watson",
    "solution": "s = input().strip() \ni = s.rfind(' ')\nprint(s[i + 1:])",
    "chapter": "робота з рядками",
    "level": "початковий"
  },
  {
    "id": "334",
    "title": "Напишіть програму, яка по введеному числу n від 1 до 9 виводить на екран n пінгвінів з відповідним номером - число від 1 до n. Зображення одного пінгвіна має розмір 5 x 9 символів, між двома сусідніми пінгвінами також є порожній (з пропусків) стовпець. Дозволяється вивести порожній стовпець після останнього пінгвіна. Для спрощення малювання скопіюйте пінгвіна із вихідних даних. Врахуйте, що виведення на екран виконується порядково, а не \"попінгвінно\".",
    "inpdata": "4",
    "outdata": "   _~_        _~_        _~_        _~_     \n  (o o)      (o o)      (o o)      (o o)    \n /  V  \\    /  V  \\    /  V  \\    /  V  \\   \n/(  1  )\\  /(  2  )\\  /(  3  )\\  /(  4  )\\  \n  ^^ ^^      ^^ ^^      ^^ ^^      ^^ ^^",
    "solution": "n = int(input())\nprint(n * '   _~_     ')\nprint(n * '  (o o)    ')\nprint(n * ' /  V  \\   ')\nrow = ''\nfor i in range(1, n + 1):\n    row += '/(  ' + str(i) + '  )\\\  '\nprint(row)\nprint(n * '  ^^ ^^    ')\n",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "335",
    "title": "Дано рядок, який, можливо, містить пропуски. \"Витягніть\" з цього рядка всі символи, які є цифрами і складіть з них новий рядок.",
    "inpdata": "3+3=6\n2 * 3 = 6",
    "outdata": "336\n236",
    "solution": "c = input()\nresult = ''\nfor i in range(len(c)):\n    if c[i] >= '0' and c[i] <= '9':\n        result += c[i]\nprint(result)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "336",
    "title": "Для доступу до власного акаунту на сайті соціальної мережі користувач ввів логін і пароль. Так як була увімкнена двофакторна авторизація, на його телефон прийшло повідомлення з рядком цифр та інформацією як отримати код доступу. У повідомленні йшлося: \"Кожну цифру, яка більша 5, необхідно націло розділити на 2, а потім з утвореної послідовності цифр видалити усі парні числа\". Який код повинен ввести користувач для успішної авторизації? Напишіть програму, на вхід якої вводиться рядок цифр із повідомлення, а програма повинна надрукувати правильний код доступу.",
    "inpdata": "5763\n1977",
    "outdata": "33\n33",
    "solution": "s = input()\nk = ''\nfor i in s:\n    if int(i) > 5:\n        k += str(int(i) // 2)\nfor i in k:\n    if int(i) % 2 != 0:\n        print(i, end='')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "337",
    "title": "Виведіть усі символи ASCII з кодами від n (n > 32) до m (m < 127) і їх коди в наступному вигляді: \"символ код\".",
    "inpdata": "101\n106",
    "outdata": "e 101\nf 102\ng 103\nh 104\ni 105\nj 106",
    "solution": "n = int(input())\nm = int(input())\nfor i in range(n, m + 1):\n    print(chr(i), ord(chr(i)))",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "338",
    "title": "У рядку є кілька слів, розділених одним або декількома пропусками. Потрібно прибрати з тексту зайві пропуски: два і більше пропусків поспіль, а також всі пропуски на початку і в кінці рядка. На вхід програмі подається рядок, що складається не більше ніж з 255 символів. Надрукувати новий рядок.",
    "inpdata": "   Beyond the green     swelling hills of the     Mittel Land rose mighty slopes of forest    up    to the lofty steeps of the Carpathians    themselves",
    "outdata": "Beyond the green swelling hills of the Mittel Land rose mighty slopes of forest up to the lofty steeps of the Carpathians themselves",
    "solution": "s = input().strip()\nwhile '  ' in s:\n    s = s.replace('  ', ' ')\nprint(s)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "339",
    "title": "Дано вираз, який має один з наступних виглядів: 'A+B', 'A-B' або 'A*B', де A і B - цілі числа від 0 до 1000000000. Визначте значення цього виразу.",
    "inpdata": "3*3\n50-49\n33+16",
    "outdata": "9\n1\n49",
    "solution": "c = input()\nfor i in range(len(c)):\n    if c[i] == '*':\n        print(int(c[:i]) * int(c[i+1:]))\n    if c[i] == '+':\n        print(int(c[:i]) + int(c[i+1:]))\n    if c[i] == '-':\n        print(int(c[:i]) - int(c[i+1:]))",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "340",
    "title": "Дано рядок, який, можливо, містить пропуски. Переведіть усі символи цього рядка в нижній регістр.",
    "inpdata": "Hearts of Three, by Jack London",
    "outdata": "hearts of three, by jack london",
    "solution": "c = input()\nresult = ''\nfor i in c:\n    if i >= 'A' and i <= 'Z':\n        result += chr(ord(i) + 32)\n    else:\n        result += i\nprint(result)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "341",
    "title": "Виведіть поспіль, без пропусків, усі символи, що лежать в таблиці ASCII між двома заданими символами. Програма отримує на вхід два символу, кожен в окремому рядку і повинна вивести рядок, що починається першим із заданих символів і закінчується другим.",
    "inpdata": "A\nF\n0\n9",
    "outdata": "ABCDEF\n0123456789",
    "solution": "a = input()\nb = input()\nfor i in range(ord(a), ord(b) + 1):\n    print(chr(i), end='')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "342",
    "title": "Дано рядок, що складається з слів, розділених пропусками. Визначте кількість слів у рядку.",
    "inpdata": "Events happened very rapidly with Francis Morgan that late spring morning",
    "outdata": "11",
    "solution": "print(input().count(' ') + 1)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "343",
    "title": "Дано рядок. Визначити число пропусків в ньому.",
    "inpdata": "After his hunger and thirst were satisfied, Robinson thought he would try to find another dwelling place",
    "outdata": "16",
    "solution": "print(input().count(' '))",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "344",
    "title": "Напишіть програму для друку таблиці індексів і значень символів у введеному користувачем рядку.",
    "inpdata": "Ruby",
    "outdata": "0 R\n1 u\n2 b\n3 y",
    "solution": "s = input()\nfor index, item in enumerate(s):\n    print(index, item)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "345",
    "title": "Напишіть програму, яка друкує введений користувачем рядок у верхньому регістрі для перших n символів у рядку.",
    "inpdata": "It was early on a fine summer's day, near the end of the eighteenth century, when a young man, of genteel appearance, journeying towards the north-east of Scotland\n36",
    "outdata": "IT WAS EARLY ON A FINE SUMMER'S DAY, near the end of the eighteenth century, when a young man, of genteel appearance, journeying towards the north-east of Scotland",
    "solution": "s = input()\nn = int(input())\nprint(s[:n].upper() + s[n:])",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "346",
    "title": "Напишіть програму, щоб отримати рядок із введеного користувачем рядка, де всі входження першого символа у рядку змінилися на рядок \"*HIDE*\", за винятком першого.",
    "inpdata": "Endless clouds drifted back and forth, blotting out the RED SUN",
    "outdata": "Endl*HIDE*ss clouds drift*HIDE*d back and forth, blotting out th*HIDE* R*HIDE*D SUN",
    "solution": "s = input()\nprint(s[:1] + s[1:].replace(s[0].upper(),'*HIDE*').replace(s[0].lower(),'*HIDE*'))",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "347",
    "title": "Напишіть програму для розрахунку довжини рядка без використання функції len().",
    "inpdata": "pythonguide.pp.ua",
    "outdata": "17",
    "solution": "s = input()\nc = 0\nfor char in s:\n    c += 1\nprint(c)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "348",
    "title": "Напишіть програму, яка по введеному числу n від 1 до 9 виводить на екран n прапорців з відповідними номерами. Зображення одного прапорця має розмір 4 x 4 символи, між двома сусідніми прапорцями також є порожній (з пропусків) стовпець. Дозволяється вивести порожній стовпець після останнього прапорця. Усередині кожного прапорця повинен бути записаний його номер - число від 1 до n.",
    "inpdata": "3",
    "outdata": "+___ +___ +___ \n|1 / |2 / |3 / \n|__\\ |__\\ |__\\ \n|    |    |",
    "solution": "n = int(input())\nrow = ''\nprint('+___ ' * n)\nfor i in range(1, n + 1):\n    row += '|' + str(i) + ' ' + '/ '\nprint(row)\nprint('|__\\ ' * n) \nprint('|    ' * n)  ",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "349",
    "title": "Дано рядок, що складається з рівно двох слів, розділених пропуском. Надрукуйте новий рядок, у якому позиції першого та другого слова змінені (друге слово друкується спочатку). У завданні не можна використовувати цикли і вказівку \"якщо\".",
    "inpdata": "Linux Ubuntu\nRichard Stallman",
    "outdata": "Ubuntu Linux\nStallman Richard",
    "solution": "s = input()\nfirst_word = s[:s.find(' ')]\nsecond_word = s[s.find(' ') + 1:]\nprint(second_word + ' ' + first_word)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "350",
    "title": "Напишіть програму, яка отримує рядок і обчислює кількість цифр і букв у ньому.",
    "inpdata": "Andromeda, M 31, NGC 224",
    "outdata": "Letters 13\nDigits 5",
    "solution": "s = input()\nd = k = 0\nfor c in s:\n    if c.isdigit():\n        d += 1 \n    elif c.isalpha():\n        k += 1\nprint('Letters', k)\nprint('Digits', d)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "351",
    "title": "Дано послідовність символів, що має вигляд p1*p2*...*pn, де pn - цифра. Обчисліть значення виразу.",
    "inpdata": "2*5*7",
    "outdata": "70",
    "solution": "s = input()\nd = 1\nfor i in s:\n    if i.isnumeric():\n        d *= int(i)\nprint(d)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "352",
    "title": "Користувач вводить рядок і один символ. Напишіть програму для підрахунку кількості входження символа в рядок. У випадку, якщо введений символ є літерою, великі і малі букви розрізняються.",
    "inpdata": "Poirot shook his head energetically. He was now arranging his moustache with exquisite care.\nw",
    "outdata": "3",
    "solution": "print(input().count(input()))",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "353",
    "title": "Користувач вводить рядок і певний номер n символа у ньому. Напишіть програму для видалення n-го символу з не порожнього рядка. Цикли і вказівку \"якщо\" для розв’язування задачі використовувати не можна.",
    "inpdata": "Poirot stopped for a moment, and gazed sorrowfully over the beautiful expanse of park, still glittering with morning dew.\n27",
    "outdata": "Poirot stopped for a moment and gazed sorrowfully over the beautiful expanse of park, still glittering with morning dew.",
    "solution": "s = input()\nn = int(input())\nfirst_part = s[:n] \nlast_part = s[n + 1:]\nprint(first_part + last_part)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "354",
    "title": "Напишіть програму для перевірки чи є введена літера голосною або приголосною.",
    "inpdata": "F\ne",
    "outdata": "F is a consonant\ne is a vowel",
    "solution": "ch = input()\nif ch.lower() in 'aeiou':\n    print(ch, 'is a vowel')\nelse:\n    print(ch, 'is a consonant')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "355",
    "title": "Вводиться додатне дійсне число, надрукуйте його першу цифру справа від десяткової точки.",
    "inpdata": "1.79\n100.89\n6.045",
    "outdata": "7\n8\n0",
    "solution": "number = float(input())\nlength = len(str(number))\nresult = str(round(number - int(number), length - 2))\nprint(result[2])",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "356",
    "title": "При заданому користувачем значенні цілого числа n ≥ 2 обчислити суму 1 x 2 + 2 x 3 + ... + (n - 1) x n. Відповідь виведіть у вигляді обчисленого виразу і його значення в точності, як показано у вихідних даних.",
    "inpdata": "2\n4",
    "outdata": "1*2=2\n1*2+2*3+3*4=20",
    "solution": "n = int(input())\ns = 0\nrow = ''\nfor i in range(2, n + 1):\n    s += (i - 1) * i\n    if i < n:\n        row += '{0:}*{1:}+'.format(i - 1, i)  \n    else:\n        row += '{0:}*{1:}={2:}'.format(i - 1, i, s)\nprint(row)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "357",
    "title": "Напишіть програму для видалення символів, які мають непарні значення індексів у введеному користувачем рядку.",
    "inpdata": "monkey\nkangaroo",
    "outdata": "mne\nknao",
    "solution": "s = input()\nresult = ''\nfor i in range(len(s)):\n    if i % 2 == 0:\n        result += s[i]\nprint(result)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "358",
    "title": "Користувач вводить рядок одноцифрових чисел без пропусків. Напишіть програму для обчислення суми цих чисел.",
    "inpdata": "1239\n88\n01",
    "outdata": "15\n16\n1",
    "solution": "numbers = input()\ntotal = 0\nfor i in numbers:\n    total += int(i)\nprint(total)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "359",
    "title": "Напишіть програму, яка зчитує рядок, введений користувачем, що містить дату у формі mm/dd/yyyy. Програма має вивести на екран дату у вигляді \"Місяць Число, Рік\".",
    "inpdata": "12/29/2022\n03/04/2025",
    "outdata": "December 29, 2022\nMarch 04, 2025",
    "solution": "d = input()\nmm = d[0:2]\nif mm == '01':\n    month = 'January'\nelif mm == '02':\n    month = 'February'\nelif mm == '03':\n    month = 'March'\nelif mm == '04':\n    month = 'April'\nelif mm == '05':\n    month = 'May'\nelif mm == '06':\n    month = 'June'\nelif mm == '07':\n    month = 'July'\nelif mm == '08':\n    month = 'August'\nelif mm == '09':\n    month = 'September'\nelif mm == '10':\n    month = 'October'\nelif mm == '11':\n    month = 'November'\nelif mm == '12':\n    month = 'December'\nprint(month, d[3:5] +  ',', d[6:10])",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "360",
    "title": "Вводиться рядок. Необхідно видалити з нього всі пропуски. Після цього визначити, чи є він паліндромом, тобто однаково пишеться як зліва направо, так і справа наліво. Програма має вивести \"Yes\", якщо слово є паліндромом, або \"No\" у протилежному випадку.",
    "inpdata": "123          621\nNever     odd   or        even",
    "outdata": "No\nYes",
    "solution": "s = input().lower()\ns = s.replace(' ', '')\nif s == s[::-1]:\n    print('Yes')\nelse:\n    print('No')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "361",
    "title": "Код Морзе - це код, в якому кожна буква алфавіту (наприклад, англійського), кожна цифра та різні знаки пунктуації представляються набором крапок і дефісів. Напишіть програму, яка перетворює рядок, введений користувачем, в код Морзе (таблицю значення кодів Морзе знайдіть в Інтернеті).",
    "inpdata": "W\n9\n,\nPython\n:)",
    "outdata": ".--\n----.\n--..--\n.--.-.--....----.\n---...-.--.-",
    "solution": "s = input()\ns = s.upper()\nmorse = ''\nfor i in s:\n    if i == ' ':\n        morse += ' '\n    elif i == ',':\n        morse += '--..--'\n    elif i == '.':\n        morse += '.-.-.-'\n    elif i == '?':\n        morse += '..--..'\n    elif i == '\"':\n        morse += '.-..-.'\n    elif i == ':':\n        morse += '---...'\n    elif i == \"'\":\n        morse += '.----.'\n    elif i == '_':\n        morse += '-....-'\n    elif i == '/':\n        morse += '-..-.'\n    elif i == '(':\n        morse += '-.--.'\n    elif i == ')':\n        morse += '-.--.-'\n    elif i == '0':\n        morse += '-----'\n    elif i == '1':\n        morse += '.----'\n    elif i == '2':\n        morse += '..---'\n    elif i == '3':\n        morse += '...--'\n    elif i == '4':\n        morse += '....-'\n    elif i == '5':\n        morse += '.....'\n    elif i == '6':\n        morse += '-....'\n    elif i == '7':\n        morse += '--...'\n    elif i == '8':\n        morse += '---..'\n    elif i == '9':\n        morse += '----.'\n    elif i == 'A':\n        morse += '.-'\n    elif i == 'B':\n        morse += '-...'\n    elif i == 'C':\n        morse += '-.-.'\n    elif i == 'D':\n        morse += '-..'\n    elif i == 'E':\n        morse += '.'\n    elif i == 'F':\n        morse += '..-.'\n    elif i == 'G':\n        morse += '--.'\n    elif i == 'H':\n        morse += '....'\n    elif i == 'I':\n        morse += '..'\n    elif i == 'J':\n        morse += '.---'\n    elif i == 'K':\n        morse += '-.-'\n    elif i == 'L':\n        morse += '.-..'\n    elif i == 'M':\n        morse += '--'\n    elif i == 'N':\n        morse += '-.'\n    elif i == 'O':\n        morse += '---'\n    elif i == 'P':\n        morse += '.--.'\n    elif i == 'Q':\n        morse += '--.-'\n    elif i == 'R':\n        morse += '.-.'\n    elif i == 'S':\n        morse += '...'\n    elif i == 'T':\n        morse += '-'\n    elif i == 'U':\n        morse += '..-'\n    elif i == 'V':\n        morse += '...-'\n    elif i == 'W':\n        morse += '.--'\n    elif i == 'X':\n        morse += '-..-'\n    elif i == 'Y':\n        morse += '-.-'\n    elif i == 'Z':\n        morse += '--..'\nprint(morse)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "362",
    "title": "Напишіть програму, яка зчитує рядок, введений користувачем, та визначає у ньому: кількість великих літер, кількість малих літер, кількість символів пропуску.",
    "inpdata": "By Red Flower Bagheera meant fire, only no creature in the jungle will call fire by its proper name.",
    "outdata": "Upper 4\nLower 76\nSpaces 18",
    "solution": "s = input()\nd = k = p = 0\nfor c in s:\n    if c.isalpha():\n        if c == c.upper():\n            k += 1\n        else:\n            d += 1\n    elif c == ' ':\n        p += 1\nprint('Upper', k)\nprint('Lower', d)\nprint('Spaces', p)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "363",
    "title": "Визначити, чи є введене слово ідентифікатором, тобто починається воно з літери англійського алфавіту (малої або великої) або знака підкреслення і не містить інших символів, крім букв англійського алфавіту (в будь-якому регістрі), цифр і знака підкреслення.",
    "inpdata": "_max\n123var\nmyClass#2",
    "outdata": "Yes\nNo\nNo",
    "solution": "s = input()\nk = 0\nif 'a' <= s[0].lower() <= 'z' or s[0] == '_':\n    for i in range(1, len(s)):\n        if not('a' <= s[i].lower() <= 'z' or '0' <= s[i].lower() <= '9' or s[i].lower() == '_'):\n            print('No')\n            k = 1\n            break\n    if k == 0:\n        print('Yes')\nelse:\n    print('No')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "364",
    "title": "Вводиться рядок. Потрібно видалити з нього повторювані символи і всі пропуски.",
    "inpdata": "aa\na a b b c dd e",
    "outdata": "a\nabcde",
    "solution": "s = input()\nr = ''\nfor i in s:\n    if (i not in r) and (i != ' '):\n        r += i\nprint(r)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "365",
    "title": "Користувач вводить рядок, у якому містяться слова, знаки пунктуації, причому усі слова записуються разом і перша літера кожного слова є великою. Напишіть програму, яка виводить рядок, у якому введені слова розділені пропусками.",
    "inpdata": "TheOldSeaDogAtTheAdmiralBenbow",
    "outdata": "The Old Sea Dog At The Admiral Benbow",
    "solution": "s = input()\nr = ''\nfor i, el in enumerate(s):\n    if el.isalpha():\n        if el == el.upper() and i != 0:\n            r += ' '\n    r += el\nprint(r)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "366",
    "title": "Знайти у рядку зазначений підрядок і замінити його на новий. Рядок, підрядок для заміни та новий рядок вводить користувач. Розгляньте випадок заміни усіх підрядків. Також необхідно врахувати випадок відсутності підрядка, який необхідно замінити (вивести \"is impossible\").",
    "inpdata": "12 45 32 567 32 109\n32\n0\n12 45 32 567 32 109\n33\n-1",
    "outdata": "12 45 0 567 0 109\nis impossible",
    "solution": "s = input()\nfind_s = input()\nchange_s = input()\nk = 0\nfor i in range(len(s)):\n    k = s.find(find_s, k)\n    if k == -1:\n        break\n    else:\n        s = s[:k] + change_s + s[k + len(find_s):]\nif i > 0:\n    print(s)\nelse:\n    print('is impossible')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "367",
    "title": "Напишіть програму, яка дає користувачеві можливість вводити рядок і відображає символ, який найчастіше з’являється у рядку та кількість його входжень. Якщо у рядку є кілька таких символів, необхідно врахувати лише перший з них.",
    "inpdata": "Black Dog Appears and Disappears\nI Go to Bristol",
    "outdata": "a 5\nпропуск 3",
    "solution": "s = input()\nk = 0\nitem = ''\nfor i in s:\n    h = s.count(i)\n    if h > k and i != item:\n        k = h\n        item = i\nprint(item, k)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "368",
    "title": "Користувач вводить рядок і певний символ. Напишіть програму, яка друкує місця розташування (індекси) першої та останньої появи введеного символа. Якщо символ зустрічається лише один раз, то виведіть його індекс. Якщо символ не зустрічається, надрукуйте \"missing\". У цьому завданні не можна використовувати цикли.",
    "inpdata": "9965 GNU\n6\n9965 GNU\n9\n9965 GNU\nN\n9965 GNU\nA",
    "outdata": "2\n0 1\n6\nmissing",
    "solution": "s = input()\nch = input()\nif s.count(ch) == 1:\n    print(s.find(ch))\nelif s.count(ch) >= 2:\n    print(s.find(ch), s.rfind(ch))\nelse:\n    print('missing')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "369",
    "title": "Користувач вводить рядок і певний символ. Напишіть програму, яка друкує індекс розташування другої появи введеного символа у рядку. Якщо рядок містить введений символ лише один раз, то надрукуйте -1, а якщо рядок не містить шуканого символа, то надрукуйте -2.",
    "inpdata": "The morning's sun rose clear and resplendent, touching the foamy waves into a network of ruby-tinted light.\ns",
    "outdata": "14",
    "solution": "s = input()\nch = input()\nif s.count(ch) == 1:\n    print(-1)\nelif s.count(ch) < 1:\n    print(-2)\nelse:\n    print(s.find(ch, s.find(ch) + 1))",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "370",
    "title": "Користувач вводить рядок і певний символ, який устрічається у рядку щонайменше двічі. Напишіть програму, яка видалить із введеного рядка перше і останнє входження символа, а також всі символи між ними.",
    "inpdata": "We left in pretty good time, and came after nightfall to Klausenburgh. Here I stopped for the night at the Hotel Royale.\nu",
    "outdata": "We left in pretty good time, and came after nightfall to Klargh. Here I stopped for the night at the Hotel Royale.",
    "solution": "s = input()\nch = input()\ns = s[:s.find(ch)] + s[s.rfind(ch) + 1:]\nprint(s)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "371",
    "title": "Дано рядок. Якщо в цьому рядку певний символ зустрічається тільки один раз, виведіть його індекс. Якщо він зустрічається два і більше разів, виведіть індекс його першої і останньої появи. Якщо символ в цьому рядку не зустрічається, нічого не виводьте.",
    "inpdata": "In the centre of the room, clamped to an upright easel, stood the full-length portrait of a young man of extraordinary personal beauty, and in front of it, some little distance away, was sitting the artist himself, Basil Hallward, whose sudden disappearance some years ago caused, at the time, such public excitement and gave rise to so many strange conjectures.\nm",
    "outdata": "24 337",
    "solution": "s = input()\nch = input()\nif ch in s:\n    n = s.find(ch) \n    m = s.rfind(ch)   \n    if n == m:\n        print(n)\n    elif (n != m) and (m != -1):\n        print(n, m)\n    else:\n        print(n)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "372",
    "title": "Дано рядок нулів та одиниць. Напишіть програму для знаходження найдовшої неперервної послідовності нулів у рядку.",
    "inpdata": "1001\n100001001010\n1000001",
    "outdata": "2\n4\n5",
    "solution": "s = input()\nc = 0\nm = c\nfor i in s:\n    if i =='0':\n        c += 1\n    else:\n        c = 0\n    if c > m:\n        m = c\nprint(m)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "373",
    "title": "Вводиться рядок. Необхідно визначити в ньому відсотки малих і великих букв.",
    "inpdata": "Hello, Guido!",
    "outdata": "61.54\n15.38",
    "solution": "s = input()\nsl = len(s)\nc_small = c_big = 0\nfor i in s:\n    if ('a' <= i) and (i <= 'z'):\n        c_small += 1\n    elif ('A' <= i) and (i <= 'Z'):\n        c_big += 1\nprint('{:.2f}'.format(c_small/sl * 100))        \nprint('{:.2f}'.format(c_big/sl * 100))",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "374",
    "title": "Дано два слова. Складіть програму, що визначає чи можна чи ні з букв слова A скласти слово B. Програма має враховувати регістр літер введених слів.",
    "inpdata": "Python\nnot\nRuby\nBuy",
    "outdata": "Yes\nNo",
    "solution": "s1 = input()\ns2 = input()\nk = 0\nif len(s1) < len(s2):\n    print('No')\nelse:\n    for i in s1:\n        if i in s2:\n            k += 1\n    if k == len(s2):\n        print('Yes')\n    else:\n        print('No')",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "375",
    "title": "В операційній системі Windows шлях до файлу складається з імені логічного диска і назв каталогів, в яких знаходиться цей файл. Частини шляху розділені знаками \"\\\" (зворотний слеш). Потрібно розбити заданий шлях до файлу на частини - ім’я диска і назви каталогів. Програма повинна вивести ім’я диска і назви всіх каталогів, що становлять шлях. Кожен елемент виводиться в окремому рядку. Використовувати модулі не можна.",
    "inpdata": "C:\\Python36\\python.exe",
    "outdata": "C:\nPython36\npython.exe",
    "solution": "s = input()\nr = ''\nfor i in s:\n    if i == \'\\\\':\n        print(r)\n        r = ''\n    else:\n        r += i\nprint(r)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "376",
    "title": "Дано рядок і символ, який зустрічається у рядку принаймні два рази. Напишіть програму, яка надрукує новий рядок (на основі введеного користувачем), у якому послідовність символів, що містяться між першою і останньою появою введеного символа, буде записана у зворотному порядку.",
    "inpdata": "Complex is better than complicated.\na",
    "outdata": "Complex is better thacilpmoc nated.",
    "solution": "s = input()\nch = input()\na = s[:s.find(ch)] \nb = s[s.find(ch):s.rfind(ch) + 1]\nc = s[s.rfind(ch) + 1:]\ns = a + b[::-1] + c\nprint(s)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "377",
    "title": "Користувачем вводиться рядок і буква, що зустрічається у рядку принаймні три рази. Напишіть програму, яка замінить кожне входження букви у нижньому регістрі на цю ж букву у верхньому регістрі, за винятком першого і останнього.",
    "inpdata": "There should be one-- and preferably only one --obvious way to do it.\nn",
    "outdata": "There should be one-- aNd preferably oNly one --obvious way to do it.",
    "solution": "s = input()\nch = input()\na = s[:s.find(ch) + 1] \nb = s[s.find(ch) + 1:s.rfind(ch)]\nc = s[s.rfind(ch):]\ns = a + b.replace(ch, ch.upper()) + c\nprint(s)",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "378",
    "title": "Дано рядок. Розріжте його на дві «рівні» частини (якщо довжина рядка непарна, помістіть центральний символ у першу частину, так що перша частина міститиме на один символ більше, ніж друга частина). Тепер надрукуйте новий рядок, у якому перша та друга половини обмінялися місцями (не використовуйте вказівку \"якщо\" для цього завдання).",
    "inpdata": "country\ntown",
    "outdata": "trycoun\nwnto",
    "solution": "s = input()\nprint(s[len(s) // 2 + len(s) % 2:] + s[:len(s) // 2 + len(s) % 2])",
    "chapter": "робота з рядками",
    "level": "середній"
  },
  {
    "id": "379",
    "title": "Дано послідовність символів довжини n (n ≥ 1). Перевірити баланс круглих дужок в цьому виразі (кожна відкита дужка має свою закриту дужку). Наприклад, при введенні виразу (()) () програма повинна повідомити про правильність розстановки дужок (True), а при введенні виразу ((()) - про неправильність (False). Напишіть програму, яка може перевіряти баланс дужок в арифметичних виразах, тексті і т. д.",
    "inpdata": "(3y + 21)(12 - (x + 5))\n(61x + 15(y + 2)",
    "outdata": "True\nFalse",
    "solution": "n = input()\nc = 0\nflag = False\nfor i in n:\n    if i == '(':\n        c += 1\n        flag = True \n    if i == ')':\n        c -= 1\n        flag = True\n    if c == -1:\n        break\nif c == 0 and flag:\n    print(True)\nelse:\n    print(False)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "380",
    "title": "Дано рядок, що складається з n цифр (тобто одноцифрових чисел), між якими стоїть n-1 знаків операцій, кожна з яких може бути або \"+\", або \"-\". Обчисліть значення цього виразу. Програма має надрукувати результат обчислення цього виразу.",
    "inpdata": "5-3+1\n6+3-2",
    "outdata": "3\n7",
    "solution": "c = input()\noperation = ''\nresult = 0\nfor i in range(len(c)):\n    if i % 2 == 0:\n        el = int(c[i])\n        if i == 0:\n            result += el\n        if operation == '+':\n            result += el\n        elif operation == '-':\n            result -= el\n    else:\n        if c[i] == '+':\n            operation = '+'\n        if c[i] == '-':\n            operation = '-'\nprint(result)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "381",
    "title": "Капітан Флінт закопав скарб на Острові скарбів. Він залишив опис, як знайти скарб. Опис складається з рядків виду: \"North 5\", де перше слово - одне з \"North\", \"South\", \"East\", \"West\", а друге число - кількість кроків, яку потрібно пройти в цьому напрямку. Напишіть програму, яка за описом шляху до скарбу визначає точні координати скарбу, вважаючи, що початок координат знаходиться на початку шляху, вісь OX спрямована на схід, вісь OY - на північ. Програма отримує на вхід послідовність рядків зазначеного виду, а введення завершується рядком зі словом \"Treasure!\". Програма має вивести два цілих числа в один рядок з пропуском між ними - координати скарбу.",
    "inpdata": "North 5\nEast 3\nSouth 1\nTreasure!",
    "outdata": "3 4",
    "solution": "x = 0\ny = 0\nm = ''\nwhile m != 'Treasure!':\n    m = input()\n    n = m.find(' ')\n    if m[:n] == 'North':\n        y += int(m[n+1:]) \n    if m[:n] == 'South':\n        y -= int(m[n+1:])\n    if m[:n] == 'West':\n        x -= int(m[n+1:])\n    if m[:n] == 'East':\n        x += int(m[n+1:])\nprint(x, y)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "382",
    "title": "Напишіть програму, на вхід якої даються чотири числа a, b, c і d, кожне у своєму рядку. Програма повинна вивести фрагмент таблиці множення для всіх чисел відрізка [a; b] на всі числа відрізка [c; d]. Числа a, b, c і d є натуральними і не перевищують 10, a ≤ b, c ≤ d. Дотримуйтесь формату виведення як у вихідних даних. Для поділу елементів всередині рядка використовуйте \"\\t\" - символ табуляції. Зауважте, що лівим стовпчиком і верхнім рядком виводяться самі числа із заданих відрізків.",
    "inpdata": "1\n4\n2\n5",
    "outdata": "\t2\t3\t4\t5\n1\t2\t3\t4\t5\n2\t4\t6\t8\t10\n3\t6\t9\t12\t15\n4\t8\t12\t16\t20",
    "solution": "a = int(input())\nb = int(input())\nc = int(input())\nd = int(input())\ns = ' '\nfor el in range(c, d + 1):\n    s = s + \"\t\" + str(el) \nprint(s)    \nfor item in range(a, b + 1):\n    print(item, end = \"\t\")\n    for el in range(c, d + 1):\n        print(item * el, end = \"\t\")\n    print()",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "383",
    "title": "Напишіть програму для друку літери A за допомогою введеного користувачем символа.",
    "inpdata": "*",
    "outdata": "  ***\n *   *\n *   *\n *****\n *   *\n *   *\n *   *",
    "solution": "element = input()\nresult = ''\nfor row in range(0, 7):    \n    for column in range(0, 7):     \n        if (((column == 1 or column == 5) and row != 0) or ((row == 0 or row == 3) and (column > 1 and column < 5))):    \n            result += element    \n        else:      \n            result += ' '    \n    result += '\\n'    \nprint(result)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "384",
    "title": "Напишіть програму для друку літери M за допомогою введеного користувачем символа.",
    "inpdata": "%",
    "outdata": " %   %\n %   %\n %% %%\n % % %\n %   %\n %   %\n %   %",
    "solution": "element = input()\nresult = ''\nfor row in range(0, 7):    \n    for column in range(0, 7):     \n        if (column == 1 or column == 5 or (row == 2 and (column == 2 or column == 4)) or (row == 3 and column == 3)):      \n            result += element    \n        else:      \n            result += ' '    \n    result += '\\n'    \nprint(result)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "385",
    "title": "Дано рядок, що є параграфом в тексті. Текст необхідно відформатувати так, щоб довжина кожного рядка не перевищувала числа m, слова при цьому не розривати. На вхід програмі спочатку подається число m (0 < m ≤ 255). У наступному рядку знаходиться вхідний текст. Довжина слів в ньому не перевищує m, слова розділені рівно одним пропуском. Виведіть розбиття цього тексту на рядки довжиною не більше ніж m символів (слово переноситься на наступний рядок тільки якщо в поточному рядку його розмістити вже неможливо). Новий рядок не повинен починатися з пропуску.",
    "inpdata": "10\nThe Wonderful Wizard of Oz",
    "outdata": "The\nWonderful\nWizard of\nOz",
    "solution": "n = int(input())\ns = input()\nrow = 0\nword = ''\nr = ''\nfor i in s:\n    if i != ' ':\n        word += i\n    else:\n        row = len(r + word)\n        if row > n:\n            print(r)\n            r = word + i\n        elif row == n:\n            print(r + word)\n            r = ''\n        else:\n            r += word + i\n        word = ''    \nif len(r + word) > n:\n    print(r + '\\n' + word)\nelse:\n    print(r + word)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "386",
    "title": "Послідовності із символів 0 і 1 називаються бінарними. Вони широко застосовуються в інформатиці. Одне з незручностей бінарних послідовностей – їх важко запам’ятовувати. Для вирішення цієї проблеми був запропонований такий спосіб їх стиснення: переглядаючи послідовність зліва направо, виконується заміна 1 на \"a\", 01 на \"b\", 001 на \"c\", ..., 00000000000000000000000001 на \"z\". Напишіть програму, яка допоможе автоматизувати такий процес заміни.",
    "inpdata": "1111\n1001101\n10000101",
    "outdata": "aaaa\nacab\naeb",
    "solution": "s = input()\nc = 0\nfor i in s:\n    if i == '1':\n        print(chr(97 + c), end='')\n        c = 0\n    else:\n        c += 1",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "387",
    "title": "Напишіть програму, яка зчитує рядок, кодує її запропонованим алгоритмом і виводить закодовану послідовність. Кодування повинно враховувати регістр символів. Правила кодування: групи однакових символів початкового рядка замінюються на цей символ і кількість його повторень в цій позиції рядка. Наприклад: рядок \"aaaabbbсaa\" кодується в \"a4b3с1a2\".",
    "inpdata": "aaaabbbcaa\nabc\nHello",
    "outdata": "a4b3c1a2\na1b1c1\nH1e1l2o1",
    "solution": "s = input()\nsum_letters = 1\nk = 1\nr = s[k:k+1]\nfor i in s:\n    if i in r:\n        sum_letters += 1\n    else:\n        print(i, end = '')\n        print(sum_letters, end = '')\n        sum_letters = 1\n    k = k + 1\n    r = s[k:k+1]",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "388",
    "title": "На вхід програми подається два рядка A і B, що складаються з малих букв англійського алфавіту. Виведіть кількість входжень рядка B в рядок A.",
    "inpdata": "aaaa\na\nababada\nabc\nabababa\naba",
    "outdata": "4\n0\n3",
    "solution": "a = input()\nb = input()\nk = 0\nfor i in range(len(a)):\n    if a.startswith(b, i, len(a)):\n        k += 1\nprint(k)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "389",
    "title": "Користувач вводить рядок цифр без пропусків. Необхідно написати програму, яка \"розіб’є\" це число на трійки цифр справа наліво комами. Якщо число містить менше трьох цифр, то воно виводиться без змін.",
    "inpdata": "4567\n123\n2348906",
    "outdata": "4,567\n123\n2,348,906",
    "solution": "s = input()\nfor i in range(len(s)):\n    if ((len(s) - i) % 3 == 0) and (i != len(s)) and len(s) > 3:\n        print(',', end='')\n    print(s[i], end='')",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "390",
    "title": "Дано слово, що складається лише з малих англійських літер. Визначте, яку найменшу кількість літер потрібно дописати до цього слова праворуч так, щоб воно стало паліндромом.",
    "inpdata": "NASA\nMars\nWebb",
    "outdata": "1\n3\n2",
    "solution": "s = input()\nfor i in range(len(s)):\n    r = s[:i] + s[::-1]\n    if r == r[::-1]:\n        print(i)\n        break",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "391",
    "title": "Користувачем вводиться рядок, що містить натуральні цілі числа і слова. Необхідно сформувати новий рядок лише з чисел, розділених комою і пропуском, що містяться у введеному рядку.",
    "inpdata": "District 9 (2009) - IMDb 8\nReviews 1301 user | 478 critic | Popularity 511\nR | 1h 52min | Sci-Fi, Thriller | 13 August 2009 (Ukraine)",
    "outdata": "9, 2009, 8\n1301, 478, 511\n1, 52, 13, 2009",
    "solution": "s = input().strip()\nr = ''\nnumbers = ''\nfor i in s:\n    if i.isdigit():\n        numbers += i \n    else:  \n        if not(i.isdigit()) and numbers != '':\n            r += numbers + ', '\n            numbers = ''\nresult = r + numbers \nprint(result.rstrip(', '))",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "392",
    "title": "Дано рядок. Знайдіть в цьому рядку найдовше слово і виведіть його. Якщо в рядку кілька слів однакової максимальної довжини, виведіть перше з них.",
    "inpdata": "The Lord of the Rings: The Two Towers (Adventure, Drama, Fantasy) [2002].\nThe Matrix (Action, Sci-Fi) [1999].\nWALL-E (Animation, Adventure, Family) [2008].",
    "outdata": "Adventure\nMatrix\nAnimation",
    "solution": "s = input().strip()\nk = 0\nn = 0\nword = ''\nout_w = ''\nfor i in s:\n    if i.isalpha():\n        k += 1\n        word += i\n    else:\n        if k > n:\n            n = k\n            out_w = word\n        k = 0\n        word = ''\nif len(word) <= len(out_w):\n    print(out_w)\nelse:\n    print(word)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "393",
    "title": "Напишіть програму, яка переводить ціле число N (1 ≤ |N| < 1000000000) з системи числення з основою K (2 ≤ K ≤ 36) в систему числення з основою M (2 ≤ M ≤ 36). Перший вхідний рядок містить запис числа N в системі числення з основою K. Другий рядок містить числа K і M, розділені пропуском. Програма повинна вивести запис числа N в системі числення з основою M.",
    "inpdata": "125\n8 16\nCD6\n16 3\n-AB\n16 10",
    "outdata": "55\n11111201\n-171",
    "solution": "x = input().upper()\nnegative = False\nif x[0] == '-':\n    negative = True\n    x = x.strip('-')\nnm = input()\nn = int(nm[:nm.find(' ')])\nm = int(nm[nm.find(' ') + 1:])\nalphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\nnumbers = '0123456789'\nequivalent = 0\nlen_number_x = len(x)\nk = 1\n# переведення в 10-ву\nfor i in x:\n    item = i\n    if item in alphabet:\n        item = alphabet.index(item.upper()) + 10\n    eq_item = int(item) * (int(n) ** (len_number_x - k))\n    equivalent += eq_item\n    k += 1\n# переведення в кінцеву\nres = ''\nwhile equivalent != 0:\n    item = str(equivalent % m)\n    if len(item) < 2:\n        res += item\n    else:\n        res += alphabet[int(item)-10]\n    equivalent = equivalent // m\nif negative:\n    print('-' + res[::-1])\nelse:\n    print(res[::-1])",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "394",
    "title": "Дано текст і відомо, що він шифрується наступним чином. Спочатку визначається кількість букв k в найдовшому слові (словом називається безперервна послідовність англійських букв, слова один від одного відокремлюються будь-якими іншими символами, довжина слова не перевищує 20 символів). Потім кожна англійська літера замінюється на букву, що стоїть в алфавіті на k букв раніше (алфавіт вважається циклічним, тобто перед буквою \"A\" стоїть буква \"Z\"). Інші символи залишаються незмінними. Малі літери при цьому залишаються малими, а великі - великими. Розшифруйте введений текст.",
    "inpdata": "Njzxwxgd Bpihjbdid, rgtpidg du iwt Gjqn egdvgpbbxcv apcvjpvt.",
    "outdata": "Yukihiro Matsumoto, creator of the Ruby programming language.",
    "solution": "s = input().strip()\nk = 0\nn = 0\nword = ''\nbig = ''\nfor i in s:\n    if i.isalpha():\n        k += 1\n        word += i\n    else:\n        if k > n:\n            n = k\n            big = word\n        k = 0\n        word = ''\nh = 0\nr = ''\nif len(word) <= len(big):\n    h = len(big)\nelse:\n    h = len(word)\nfor i in s:\n    if i >= 'a' and i <= 'z':\n        position = ord(i) - ord('a')\n        position = (position + h) % 26\n        new_char = chr(position + ord('a'))\n        r += new_char\n    elif i >= 'A' and i <= 'Z':\n        position = ord(i) - ord('A')\n        position = (position + h) % 26\n        new_char = chr(position + ord('A'))\n        r += new_char\n    else:\n        r += i  \nprint(r)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "395",
    "title": "Дано рядок, який, можливо, містить пропуски. Визначте кількість слів у цьому рядку. Слово - це кілька поспіль букв англійського алфавіту (як великих, так і малих). При розв’язуванні цього завдання не можна користуватися списками.",
    "inpdata": "Do you play any sports? Yes, I like to play basketball.",
    "outdata": "10",
    "solution": "s = input().strip()\nk = 0\nn = 0\nfor i in s:\n    if i in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':\n        k += 1\n    else:\n        if k > 1:\n            n += 1\n        k = 0\nif k > 1:\n    print(n + 1)\nelse:\n    print(n)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "396",
    "title": "У заданому рядку знайти найкоротше слово, вивести це слово і його розмір у символах. Слова можуть бути розділені пропусками, декількома пропусками, знаками пунктуації, цифрами тощо. Якщо найкоротших слів є кілька, вивести лише перше з них. Рядок слів гарантовано закінчується крапкою.",
    "inpdata": "He lives in house number 4.\nNow is better than never.\nTom Tells the Truth.",
    "outdata": "He 2\nis 2\nTom 3",
    "solution": "s = input().strip()\nk = 0\nw_min = len(s)\nword = ''\nw_out = ''\nfor i in s:\n    if i.isalpha():\n        k += 1\n        word += i\n    else:\n        if k < w_min and k != 0:\n            w_min = k\n            w_out = word\n        word = ''\n        k = 0\nprint(w_out, w_min)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "397",
    "title": "Шифр Цезаря полягає в заміні кожного символу вхідного рядка на символ, що знаходиться на кілька позицій ліворуч або праворуч його в алфавіті. Напишіть програму, яка шифрує текст шифром Цезаря. Використовуваний алфавіт - пропуск і малі літери англійського алфавіту. На першому рядку вказується зміщення шифрування: ціле число. Додатне число відповідає зміщенню вправо. На другому рядку вказується непорожній рядок-фраза для шифрування. Результатом роботи програми має бути записана зашифрована послідовність.",
    "inpdata": "3\ni am caesar\n26\nabc\n1\nPython",
    "outdata": "lcdpcfdhvdu\nabc\nqzuipo",
    "solution": "n = int(input())\nphrase = input().lower().strip()\nalphabet = ' abcdefghijklmnopqrstuvwxyz'\nresult = ''\nfor item in phrase:\n    if n > 0:\n        g = alphabet.index(item) + (n % 26)\n    else:\n        g = alphabet.index(item) - (abs(n) % 26)\n    if g > 26:\n        result += alphabet[g - 26]\n    elif g < 0:\n        result += alphabet[g + 26]\n    else:\n        result += alphabet[g]\nprint(result)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "398",
    "title": "Напишіть програму, яка переводить натуральне число N (1 ≤ N ≤ 3999) з римської системи числення в десяткову. Вхідний рядок містить число N, записане в римській системі числення. Програма повинна вивести десятковий запис числа N.",
    "inpdata": "MMMCMXCIX\nIV\nXXI",
    "outdata": "3999\n4\n21",
    "solution": "s = input()\nrome = 'M,CM,D,CD,C,XC,L,XL,X,IX,V,IV,I,'\nr = i = arabic = 0\nmark = ''\nfor el in rome:\n    if el.isalpha():\n        mark += el\n    else:\n        if mark == 'M':\n            arabic = 1000\n        elif mark == 'CM':\n            arabic = 900\n        elif mark == 'D':\n            arabic = 500\n        elif mark == 'CD':\n            arabic = 400\n        elif mark == 'C':\n            arabic = 100\n        elif mark == 'XC':\n            arabic = 90\n        elif mark == 'L':\n            arabic = 50\n        elif mark == 'XL':\n            arabic = 40\n        elif mark == 'X':\n            arabic = 10\n        elif mark == 'IX':\n            arabic = 9\n        elif mark == 'V':\n            arabic = 5\n        elif mark == 'IV':\n            arabic = 4\n        elif mark == 'I':\n            arabic = 1\n        while s[i:i+len(mark)] == mark:\n            r += arabic \n            i += len(mark)\n        mark = ''\nprint(r)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "399",
    "title": "Кодування довжин послідовностей - це базовий алгоритм стиснення даних. Реалізуйте один з найпростіших його варіантів. На вхід алгоритму подається рядок, що містить символи англійського алфавіту. Цей рядок розбивається на групи однакових символів, що йдуть підряд («серії»). Кожна серія характеризується символом і кількістю повторень. Саме ця інформація і записується в код: спочатку пишеться довжина серії повторюваних символів, потім сам символ. У серій довжиною в один символ кількість повторень не записується.",
    "inpdata": "aaabccccCCaB\naabcccddffffffffff",
    "outdata": "3ab4c2CaB\n2ab3c2d10f",
    "solution": "s = input() \nc = 1\nfor i in range(0, len(s)):\n    if i + 1 < len(s) and s[i] == s[i+1]:\n        c += 1\n    else:\n        if c == 1:\n            print(s[i], end='')\n            c = 1\n        else:\n            print(str(c) + s[i], end='')\n            c = 1",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "400",
    "title": "Дано рядок, який може містити пропуски. Визначте, чи є цей рядок паліндромом, за умови, що великі і малі літери не розрізняються, а всі символи, які не є буквами, повинні бути пропущені. Виведіть слово \"Yes\", якщо слово є паліндромом і слово \"No\", якщо ні. Довжина вхідного рядка може бути до 100000 символів. При виконанні цього завдання не можна використовувати списки.",
    "inpdata": "Was.it.a.rat.I.saw?\nRio-de-Janeiro!\na+b=b+a",
    "outdata": "Yes\nNo\nYes",
    "solution": "s = input().strip()\ns = ''.join(c for c in s if c.isalpha()).lower()  \nif len(s) < 2:\n    print('Yes')\nelse:\n    if len(s) % 2 == 0:\n        if s[:len(s) // 2] == s[len(s) // 2:][::-1]:\n            print('Yes')\n        else:\n            print('No')\n    else:\n        if s[:len(s) // 2] == s[(len(s) // 2) + 1:][::-1]:\n            print('Yes')\n        else:\n            print('No')",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "401",
    "title": "Дано рядок, що містить одне або більше цілих чисел від 0 до 1000000000, розділених знаками \"+\" або \"-\". Розрахуйте значення цього виразу.",
    "inpdata": "12-5+3\n26-14+2-1\n7-0+3",
    "outdata": "10\n13\n10",
    "solution": "s = input()\nnumber = ''\nk = res = 0\nfor i in range(len(s)-1, -1, -1):\n    if s[i].isnumeric():\n        k += 1\n        number = s[i] + number\n    else:\n        if k > 0:\n            if s[i] == '+':\n                res += int(number)\n            elif s[i] == '-':\n                res -= int(number)\n            k = 0\n            number = ''\nprint(res + int(number))",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "402",
    "title": "Дано рядок, який може міститити пропуски. Визначте, яка буква англійського алфавіту (або які букви) в цьому рядку зустрічається найчастіше. Великі і малі літери вважаються однаковими, а інші символи, які не є буквами, не враховуються. Програма повинна вивести в першому рядку всі букви, які зустрічаються найчастіше в заданому рядку. Виводити букви необхідно у верхньому регістрі, в алфавітному порядку (додатково), без пропусків. У другому рядку виведіть єдине число - скільки разів у цьому рядку зустрічаються ці літери. При виконанні цього завдання не можна користуватися вкладеними циклами. Вхідний рядок повинен оброблятися за один прохід.",
    "inpdata": "Project Gutenberg EBook of The jungle book, by Rudyard Kipling",
    "outdata": "EO\n6",
    "solution": "s = input().strip().upper()\nk = 0\nn = 0\nr = ''\nfor i in s:\n    if i.isalpha():\n        k = s.count(i)\n        if k > n:\n            n = k\n            r = i\n        elif k == n and i not in r:\n            r += i  \n        k = 0\nletter = ''\nout_row = ' '\nfor i in r:\n    if i > letter:\n        for j in range(len(out_row)):\n            if i > out_row[j]:\n                out_row = out_row[:j] + i + out_row[j:]\n                break\n    else:\n        out_row += i\n        letter = out_row[0]\nprint(out_row[::-1].strip())\nprint(n)",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "403",
    "title": "У мережі Інтернет кожному комп’ютері присвоюється IP-адреса (чотирьохбайтовий код, який прийнято записувати у вигляді чотирьох чисел, кожне з яких може приймати значення від 0 до 255 і між якими ставлять крапку). Ось приклади правильних IP-адрес: 192.168.0.1, 255.0.255.255, 10.10.0.2. Програма отримує на вхід рядок з довільних символів і якщо цей рядок є коректним записом IP-адреси, виведіть \"Yes\", інакше виведіть \"No\".",
    "inpdata": "C.E.R.N\n192.168.0.200\n256.0.0.255",
    "outdata": "No\nYes\nNo",
    "solution": "s = input()\nn = ''\nk = 0\nif s.count('.') != 3:\n    print('No')\nelse:\n    for i in s:\n        if i != '.':\n            n += i\n        else:\n            if n.isdigit():\n                if (int(n) >= 0) and (int(n) <= 255):\n                    k += 1\n            n = ''\n    if k == 3 and n.isdigit():\n        if (int(n) >= 0) and (int(n) <= 255):\n            print('Yes')\n        else:\n            print('No')\n    else:\n        print('No')",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "404",
    "title": "Напишіть програму, яка визначає, чи є у введеному рядку десяткові цифри, і виводить найбільше число, яке можна скласти з цих цифр. Провідних нулів у числі бути не повинно (за винятком числа 0, запис якого містить рівно одну цифру). Гарантовано, що у рядку є принаймні одна цифра. Вхідний рядок містить довільні символи. Програма повинна вивести найбільше число, яке можна скласти з присутніх в рядку десяткових цифр.",
    "inpdata": "Release Date: July 27, 2008\nLast Updated: February 22, 2018",
    "outdata": "872200\n822210",
    "solution": "s = input()\nr = ' '\nn = ''\nfor i in s:\n    if i.isdigit():\n        if i > n:\n            for j in range(len(r)):\n                if i > r[j]:\n                    r = r[:j] + i + r[j:]\n                    break\n        elif i <= n:\n            r += i\n            n = r[-1]\nprint(r.strip())",
    "chapter": "робота з рядками",
    "level": "високий"
  },
  {
    "id": "405",
    "title": "Створіть список на основі введеної послідовності цілих чисел і надрукуйте другу половину списку як у вихідних даних.",
    "inpdata": "7 2 1 0 4 2 5\n7 2 1 0 4 2",
    "outdata": "0 4 2 5\n0 4 2",
    "solution": "numbers = [int(i) for i in input().split()] \nlast_half = numbers[len(numbers)//2:]\nprint(*last_half)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "406",
    "title": "Створіть список на основі введеної послідовності цілих чисел і надрукуйте його елементи таким чином: два останні елементи переміщені з кінця в початок списку без зміни їх початкового порядку.",
    "inpdata": "4 10 2 9 4 7 3",
    "outdata": "7 3 4 10 2 9 4",
    "solution": "numbers = [int(i) for i in input().split()] \nresult = numbers[-2:] + numbers[:-2]\nprint(*result)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "407",
    "title": "Збережіть назви мов світу, які вводяться в одному рядку через пропуск, у списку. Простежте за тим, щоб елементи у списку не зберігались в алфавітному порядку. Відсортуйте список в алфавітному порядку і виведіть його елементи в рядку через пропуск.",
    "inpdata": "Ukrainian French Bulgarian Norwegian Latvian",
    "outdata": "Bulgarian French Latvian Norwegian Ukrainian",
    "solution": "languages = [i for i in input().split()]\nprint(*sorted(languages))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "408",
    "title": "Збережіть назви мов світу, які вводяться в одному рядку через пропуск, у списку. Простежте за тим, щоб елементи у списку не зберігались в алфавітному порядку. Відсортуйте список в порядку протилежному алфавітному і виведіть його елементи в рядку через пропуск.",
    "inpdata": "Ukrainian French Bulgarian Norwegian Latvian",
    "outdata": "Ukrainian Norwegian Latvian French Bulgarian",
    "solution": "languages = [i for i in input().split()] \nprint(*sorted(languages, reverse=True))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "409",
    "title": "Збережіть назви мов світу, які вводяться в одному рядку через пропуск, у списку. Виведіть елементи списку в зворотному порядку в рядку через пропуск.",
    "inpdata": "Ukrainian French Bulgarian Norwegian Latvian",
    "outdata": "Latvian Norwegian Bulgarian French Ukrainian",
    "solution": "languages = [i for i in input().split()] \nprint(*languages[::-1])",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "410",
    "title": "Виведіть елементи даного списку в зворотному порядку, не змінюючи сам список.",
    "inpdata": "2 6 1 7 9",
    "outdata": "9 7 1 6 2",
    "solution": "s = list(map(int, input().split()))\nprint(*s[::-1])",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "411",
    "title": "Виведіть всі елементи списку з парними індексами. Вводиться список чисел. Всі числа списку знаходяться на одному рядку.",
    "inpdata": "1 2 3 4 5",
    "outdata": "1 3 5",
    "solution": "s = input().split()\nfor i in range(len(s)):\n    if i % 2 == 0:\n        print(s[i], end=' ')",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "412",
    "title": "Напишіть програму, яка роздруковує лише ті елементи введеного списку, що менше введеного значення n. Список містить унікальні значення.",
    "inpdata": "2 7 11 3 8 90 144 15 5\n94",
    "outdata": "2 7 11 3 8 90 15 5",
    "solution": "nums = [int(i) for i in input().split()]\nn = int(input())\nresult = []\nfor i in nums:\n    if i < n:\n        result.append(i)\nprint(*result)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "413",
    "title": "Виведіть всі парні елементи списку. Вводиться список чисел. Всі числа списку знаходяться на одному рядку.",
    "inpdata": "1 2 2 3 3 3 4 4 4 4",
    "outdata": "2 2 4 4 4 4",
    "solution": "s = map(int, input().split())\nfor i in s:\n    if i % 2 == 0:\n        print(i, end=' ')",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "414",
    "title": "Знайдіть кількість додатних елементів у введеному списку. Вводиться список чисел. Всі числа списку знаходяться на одному рядку.",
    "inpdata": "2 -4 5 6 -3",
    "outdata": "3",
    "solution": "s = map(int, input().split())\nk = 0\nfor i in s:\n    if i > 0:\n        k += 1\nprint(k)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "415",
    "title": "Виведіть всі елементи списку з непарними індексами. Вводиться список чисел, елементи якого розділені комами без пропусків. Всі числа списку знаходяться на одному рядку. Необхідно вивести список в одному рядку і елементи списку мають бути розділені комами без пропусків.",
    "inpdata": "1,2,3,4,5,6,7,8,9",
    "outdata": "1,3,5,7,9",
    "solution": "values = input()\nnumbers = [x for x in values.split(\",\") if int(x)%2!=0]\nprint(\",\".join(numbers))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "416",
    "title": "Вводиться список чисел. Всі числа списку знаходяться на одному рядку. Виведіть ті його елементи, які зустрічаються в списку лише один раз. Елементи потрібно виводити в тому порядку, в якому вони зустрічаються в списку.",
    "inpdata": "4 5 6 6 6 5 4 4 7 4",
    "outdata": "7",
    "solution": "s = list(map(int, input().split()))\nfor i in s:\n    c = s.count(i)\n    if c == 1:\n        print(i)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "417",
    "title": "Вводиться список чисел. Всі числа списку знаходяться в одному рядку. Обчисліть, скільки у списку різних елементів, не змінюючи самого списку.",
    "inpdata": "5 7 7 9 12",
    "outdata": "4",
    "solution": "s = list(map(int, input().split()))\nr = []\nfor i in s:\n    if i not in r:\n        r.append(i)\nprint(len(r))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "418",
    "title": "Напишіть програму для доступу до індексу цілочисельних елементів списку. Числа списку вводяться на одному рядку через пропуск.",
    "inpdata": "3 44 6 8 9 12 7",
    "outdata": "0 3\n1 44\n2 6\n3 8\n4 9\n5 12\n6 7",
    "solution": "nums = list(map(int, input().split(' ')))\nfor num_index, num_val in enumerate(nums):\n    print(num_index, num_val)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "419",
    "title": "Вводиться список чисел. Всі числа списку знаходяться в одному рядку. Не змінюючи його і не використовуючи додаткові списки, визначте, яке число в цьому списку зустрічається найчастіше. Якщо таких чисел декілька, виведіть будь-яке з них.",
    "inpdata": "1 0 0 1 0 0 1 1 0\n2 4 6 9 9 2 3 2 4",
    "outdata": "0\n2",
    "solution": "s = list(map(int, input().split()))\nk = 0\nr = 0\nfor i in s:\n    c = s.count(i)\n    if c > k:\n        k = c\n        r = i\nprint(r)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "420",
    "title": "Вводиться список цілих чисел в одному рядку через пропуск. Надрукуйте всі елементи, які перевищують попередній елемент списку, через пропуск в новому рядку в порядку їх розміщення у списку.",
    "inpdata": "5 8 0 2 9 4 1",
    "outdata": "8 2 9",
    "solution": "a = [int(i) for i in input().split()]\nfor i in range(1, len(a)):\n    if a[i] > a[i - 1]:\n        print(a[i])",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "421",
    "title": "Вводиться список цілих чисел в одному рядку через пропуск. Надрукуйте кількість елементів, які є за значенням більші за обох їх сусідів. Перший і останній елементи списку не слід розглядати, оскільки вони не мають двох сусідів.",
    "inpdata": "1 2 1\n1 3 2 4 2\n1 2 3",
    "outdata": "1\n2\n0",
    "solution": "nums = [int(i) for i in input().split()]\nc = 0\nfor i in range(1, len(nums) - 1):\n    if nums[i-1] < nums[i] and nums[i] > nums[i+1]:\n        c += 1\nprint(c)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "422",
    "title": "Напишіть програму, яка отримує повне ім’я файлу від користувача та друкує на екрані розширення отриманого файлу.",
    "inpdata": "test.cpp",
    "outdata": "cpp",
    "solution": "filename = input()\nprint(filename.split('.')[-1])",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "423",
    "title": "Напишіть програму розрахунку суми цілих чисел, які вводяться користувачем в одному рядку через пропуск. Цикл використовувати не можна.",
    "inpdata": "1 5 9 5 2 8",
    "outdata": "30",
    "solution": "sequences = list(map(int, input().split()))\nprint(sum(sequences))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "424",
    "title": "Визначте, скільки різних слів у введеному рядку.",
    "inpdata": "New Delhi New York Paris Prague Reykjavik\nHappy New Year Happy New Year May we all have a vision now and then Of a world where every neighbor is a friend",
    "outdata": "6\n19",
    "solution": "s = list(map(str, input().split()))\nr = []\nfor i in s:\n    if i not in r:\n        r.append(i)\nprint(len(r))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "425",
    "title": "Напишіть програму, яка отримує два цілих числа в одному рядку через пропуск і виводить ці числа аналогічним чином, помінявши їх місцями.",
    "inpdata": "101 56",
    "outdata": "56 101",
    "solution": "a, b = map(int, input().split())\nprint(b, a)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "426",
    "title": "Вводиться дробове число. Надрукувати окремо цифри цілої частини і дробової. Розділювачем є десяткова крапка.",
    "inpdata": "12.567\n0.75",
    "outdata": "12 567\n0 75",
    "solution": "row = input().split('.')\nprint(row[0], row[1])",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "427",
    "title": "Створіть програму, яка отримує на вхід послідовність цілих чисел, і друкує на екрані: найменше число у списку, найбільше число у списку, кількість чисел у списку, середнє значення елементів у списку.",
    "inpdata": "1 3 7 5",
    "outdata": "1\n7\n4\n4.0",
    "solution": "numbers = list(map(int, input().split(' ')))\ntotal = len(numbers)\nprint(min(numbers))\nprint(max(numbers))\nprint(total)\nprint(sum(numbers) / total)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "428",
    "title": "Напишіть програму, яка приймає послідовність чисел, розділених комами, від користувача і створює список і кортеж з цими числами.",
    "inpdata": "7, 9, 12, 4",
    "outdata": "[7, 9, 12, 4]\n(7, 9, 12, 4)",
    "solution": "numbers = input() \nmy_list = list(map(int, numbers.split(',')))\nmy_tuple = tuple(my_list)\nprint(my_list)\nprint(my_tuple)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "429",
    "title": "Напишіть програму для підрахунку кількості днів, в яких температура була не нижче, ніж середня температура за весь період. У першому рядку вводиться список показників температури на кожен день. У рядку виведення одне число - кількість днів, які відповідають умові.",
    "inpdata": "-3 -1 0 2 6 8 12 15",
    "outdata": "4",
    "solution": "t = list(map(str, input().split(' ')))\nresult = []\nlen_t = len(t)\nsum_t = [abs(int(i)) for i in t]\naverage_t = sum(sum_t) / len_t\nresult = [int(i) for i in t if int(i) >= average_t]\nprint(len(result))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "430",
    "title": "Напишіть програму для підрахунку кількості цілих чисел n, які вводяться користувачем (значення вводяться через пропуск в одному рядку, число n вводиться у новому рядку).",
    "inpdata": "2 5 8 19 7\n5\n2 6 7 8 9 9 2 3\n9",
    "outdata": "1\n2",
    "solution": "s = input()\nn = int(input())\nnumbers = list(map(int, s.split()))\nprint(numbers.count(n))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "431",
    "title": "Напишіть програму для друкування всіх парних чисел із введеного списку чисел у тому ж порядку і припиніть друк, якщо у списку буде число n або нуль. Значення списку вводяться через пропуск в одному рядку, число n вводиться у новому рядку.",
    "inpdata": "1 8 9 0 4 2 5 6\n2",
    "outdata": "8",
    "solution": "numbers = map(int, input().split())\nn = int(input())\nfor i in numbers:\n    if i == n:\n        break\n    elif i % 2 == 0:\n        print(i)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "432",
    "title": "Напишіть програму, щоб перевірити, чи певне ціле число n перевищує всі елементи цілочисельного списку. Значення списку вводяться через пропуск в одному рядку, число n вводиться у новому рядку.",
    "inpdata": "4 67 109 25 44 12\n99",
    "outdata": "False",
    "solution": "enter_list = list(map(int, input().split()))\na = int(input())\nif a > max(enter_list):\n    print(True)\nelse:\n    print(False)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "433",
    "title": "Цілі числа (додатні і від’ємні) вводяться через пропуск в одному рядку. Напишіть програму для друку списку лише із введених додатних чисел.",
    "inpdata": "0 9 -4 6 8 -15 4",
    "outdata": "[9, 6, 8, 4]",
    "solution": "n = list(map(int, input().split()))\npositive_numbers = [i for i in n if i > 0]\nprint(positive_numbers)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "434",
    "title": "Напишіть програму для отримання частини рядка URL, що позначає назву ресурсу.",
    "inpdata": "https://www.namesite.com/folder/index.html",
    "outdata": "index.html",
    "solution": "str_url = input()\nprint(str_url.rsplit('/', 1)[1])",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "435",
    "title": "Напишіть програму для отримання найменшого цілого числа зі списку. Значення списку вводяться через пропуск в одному рядку.",
    "inpdata": "87 6 25 7 105 23 56",
    "outdata": "6",
    "solution": "nums = list(map(int, input().split(' ')))\nprint(min(nums))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "436",
    "title": "Напишіть програму для знаходження другого найменшого елемента у цілочисельного списку. Значення списку вводяться через пропуск в одному рядку.",
    "inpdata": "20 56 14 9 1 15",
    "outdata": "9",
    "solution": "nums = list(map(int, input().split(' ')))\nnums.sort()\nprint(nums[1])",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "437",
    "title": "Напишіть програму для перетворення списку декількох цілих чисел у єдине ціле число. Значення списку вводяться через пропуск в одному рядку.",
    "inpdata": "1 7 9 4",
    "outdata": "1794",
    "solution": "nums = list(map(int, input().split(' ')))\nnumbers = int(''.join(map(str, nums)))\nprint(int(numbers))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "438",
    "title": "Написати програму, яка обчислює середнє арифметичне елементів списку. Середнім арифметичним кількох чисел називається їх сума, поділена на їх кількість. Результат округлити до двох знаків після десяткової крапки.",
    "inpdata": "3 5 1 8 4",
    "outdata": "4.20",
    "solution": "numbers = list(map(int, input().split(' ')))\nlen_numbers = len(numbers)\nsum_numbers = sum(numbers)\nprint('{0:.2f}'.format(sum_numbers / len_numbers))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "439",
    "title": "Напишіть простий інтерпретатор математичного виразу. На вхід подається рядок з виразом, що складається з двох чисел (0 ≤ a, b ≤ 1000), об’єднаних бінарним оператором: a operator b, де замість operator можуть використовуватися такі слова: \"plus\", \"minus\", \"multiply\", \"divide\" для, відповідно, додавання, віднімання, множення і цілочисельного ділення. Результат обчислення - рядок, що містить ціле число.",
    "inpdata": "20 plus 7\n15 minus 9\n144 multiply 2\n49 divide ",
    "outdata": "27\n6\n288\n7",
    "solution": "math_expression = input().split(' ')\nif math_expression[1] == 'plus':\n    print(int(math_expression[0]) + int(math_expression[2]))\nelif math_expression[1] == 'minus':\n    print(int(math_expression[0]) - int(math_expression[2]))\nelif math_expression[1] == 'multiply':\n    print(int(math_expression[0]) * int(math_expression[2]))\nelif math_expression[1] == 'divide':\n    print(int(math_expression[0]) // int(math_expression[2]))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "440",
    "title": "Знайти відстань між двома точками із заданими координатами (x1, y1, x2, y2) в 2-вимірному просторі. Значення координат є цілими числами. Результат округлити до двох знаків після десяткової крапки.",
    "inpdata": "2 3 -7 4",
    "outdata": "9.06",
    "solution": "x1, y1, x2, y2 = map(int, input().split())\nresult = 0\nfor i, j in zip((x1, y1), (x2, y2)):\n    result += (int(i)-int(j))**2\ndistance = result**0.5\nprint('{0:.2f}'.format(distance))",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "441",
    "title": "Дано список цілих чисел. Визначте елемент у списку з найбільшим значенням. Надрукувати значення найбільшого елемента, а потім номер індексу. Якщо найбільший елемент не є унікальним, надрукуйте індекс першого входження найбільшого елемента.",
    "inpdata": "2 5 10 0 4 7 11 5 8",
    "outdata": "11 6",
    "solution": "index_of_max = 0\nnums = [int(i) for i in input().split()]\nfor i in range(1, len(nums)):\n    if nums[i] > nums[index_of_max]:\n        index_of_max = i\nprint(nums[index_of_max], index_of_max)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "442",
    "title": "Дано послідовність цілих чисел. Визначте, у відсортованому за зростанням списку, кількість елементів, що не повторюються один за одним.",
    "inpdata": "1 9 10 3 7 5 2 2 3 0 4 5 6",
    "outdata": "10",
    "solution": "nums = [int(i) for i in input().split()]\nnums.sort()\nnum_distinct = 1\nfor i in range(0, len(nums) - 1):\n    if nums[i] != nums[i+1]:\n        num_distinct += 1\nprint(num_distinct)",
    "chapter": "списки і кортежі",
    "level": "початковий"
  },
  {
    "id": "443",
    "title": "Циклічно посуньте елементи списку вправо (0-вий елемент переходить на місце 1-го, 1-ий на місце 2-го, ..., останній елемент переходить на місце 0-го). Вводиться список чисел. Всі числа списку знаходяться на одному рядку.",
    "inpdata": "2 0 2 5\n6\n1 2 3",
    "outdata": "5 2 0 2\n6\n3 1 2",
    "solution": "s = input().split()\nif len(s) > 1:\n    print(s[-1],s[0],' '.join(s[1:-1]))\nelse:\n    print(''.join(s))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "444",
    "title": "Напишіть програму, яка приймає послідовність слів, розділених комами і без пропусків в якості введення, і друкує послідовність слів, розділених комами, після сортування за алфавітом.",
    "inpdata": "one,moment,please",
    "outdata": "moment,one,please",
    "solution": "items = [i for i in input().split(',')]\nitems.sort()\nprint(','.join(items))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "445",
    "title": "Для введеної послідовності унікальних цілих чисел, поміняйте місцями мінімальний та максимальний елементи цієї послідовності. Надрукуйте отриманий список.",
    "inpdata": "1 9 12 5 3 8",
    "outdata": "12 9 1 5 3 8",
    "solution": "nums = [int(i) for i in input().split()]\nindex_of_min = 0\nindex_of_max = 0\nfor i in range(1, len(nums)):\n    if nums[i] > nums[index_of_max]:\n        index_of_max = i\n    if nums[i] < nums[index_of_min]:\n        index_of_min = i\nnums[index_of_min], nums[index_of_max] = nums[index_of_max], nums[index_of_min]\nprint(' '.join([str(i) for i in nums]))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "446",
    "title": "Дано список чисел, підрахуйте, скільки пар елементів мають однакове значення (рівні). Будь-які два елементи, що дорівнюють один одному, слід вважати рівно один раз.",
    "inpdata": "1 2 2 2 3 3 4\n4 5 5 8 10 12 3 3\n1 5 2 8 9 5",
    "outdata": "4\n2\n1",
    "solution": "nums = [int(i) for i in input().split()]\nc = 0\nfor i in range(len(nums)):\n    for j in range(i + 1, len(nums)):\n        if nums[i] == nums[j]:\n            c += 1\nprint(c)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "447",
    "title": "Напишіть програму, яка приймає послідовність рядків (порожній рядок для завершення програми) як вхідний рядок і друкує рядки у верхньому регістрі.",
    "inpdata": "python\nruby\ngo\n ",
    "outdata": "PYTHON\nRUBY\nGO",
    "solution": "lines = []\nwhile True:\n    row = input()\n    if row:\n        lines.append(row.upper())\n    else:\n        break\nfor row in lines:\n    print(row)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "448",
    "title": "Для введеної послідовності цілих чисел обміняйте сусідні елементи у парах (A[0] з A[1], A[2] з A[3] і т. д.). Надрукуйте отриманий список. Якщо в списку є непарне число елементів, залиште останній елемент на місці.",
    "inpdata": "1 4 5 3 7\n4 2 10 5\n2",
    "outdata": "4 1 3 5 7\n2 4 5 10\n2",
    "solution": "nums = [int(i) for i in input().split()]\nfor i in range(1, len(nums), 2):\n    nums[i-1], nums[i] = nums[i], nums[i-1]\nprint(' '.join([str(i) for i in nums]))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "449",
    "title": "Для списку цілих чисел знайдіть і надрукуйте елементи, які з’являються у списку лише один раз. Елементи повинні бути роздруковані у тому порядку, в якому вони перебувають у вхідному списку.",
    "inpdata": "5 3 1 6 5 8 0 12\n1 45 23 45 90 1 0",
    "outdata": "3 1 6 8 0 12\n23 90 0",
    "solution": "nums = [int(i) for i in input().split()]\nfor i in range(len(nums)):\n    for j in range(len(nums)):\n        if i != j and nums[i] == nums[j]:\n            break\n    else:\n        print(nums[i], end=' ')",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "450",
    "title": "У введеному списку цілих чисел, знайдіть і надрукуйте сусідні елементи, які мають однаковий знак. Якщо такої пари немає, не повинно нічого виводитися.",
    "inpdata": "1 -2 -3 5 6 -3 7 8",
    "outdata": "-2 -3\n5 6\n7 8",
    "solution": "nums = [int(i) for i in input().split()]\nfor i in range(1, len(nums)):\n    if nums[i-1] * nums[i] > 0:\n        print(nums[i-1], nums[i])",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "451",
    "title": "Напишіть програму, яка зчитує числа (по одному в рядку) до тих пір, поки сума введених чисел не буде дорівнює 0 і відразу після цього виводить суму квадратів всіх чисел. Гарантується, що в якийсь момент сума введених чисел дорівнюватиме 0, після цього зчитування продовжувати не потрібно.",
    "inpdata": "2\n3\n-6\n1",
    "outdata": "50",
    "solution": "result_sum = 0\nresult_sqr = 0\nwhile True:\n    s = int(input())\n    result_sum += s\n    result_sqr += s**2\n    if result_sum == 0:\n        print(result_sqr)\n        break",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "452",
    "title": "Напишіть програму для обчислення добутку цілих чисел (без використання циклу for), які вводяться через пропуск користувачем в одному рядку.",
    "inpdata": "2 5 3",
    "outdata": "30",
    "solution": "nums = list(map(str, input().split(' ')))\nnums_product = eval('*'.join(nums))\nprint(nums_product)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "453",
    "title": "Написати програму, яка приймає на вхід послідовність з цілих чисел, після чого друкує значення всіх її елементів, піднесені до квадрату.",
    "inpdata": "1 2 3 4 5 6 7 8 9",
    "outdata": "1 4 9 16 25 36 49 64 81",
    "solution": "result = []\nnumbers = list(map(int, input().split(' ')))\nresult = [i**2 for i in numbers]\nprint(*result)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "454",
    "title": "Напишіть програму для друку елементів певного цілочисельного списку після видалення з нього парних чисел. Значення списку вводяться через пропуск в одному рядку.",
    "inpdata": "3 44 6 8 9 12 7",
    "outdata": "[3, 9, 7]",
    "solution": "nums = list(map(int, input().split(' ')))\nnums_out = [i for i in nums if i % 2 != 0]\nprint(nums_out)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "455",
    "title": "Дано дві цілочисельні послідовності, елементи яких розділені пропуском і комою. Напишіть програму, яка повертає послідовність, що містить лише елементи, які є загальними між введеними послідовностями (без дублікатів). Переконайтеся, що ваша програма працює на двох послідовностях різних розмірів.",
    "inpdata": "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13",
    "outdata": "1 2 3 5 8 13",
    "solution": "one = [int(i) for i in input().split(',')]\ntwo = [int(i) for i in input().split(',')]\nresult = []\nfor number in one:\n    for numbers in two:\n        if (number == numbers) and number not in result:\n            result.append(number)\nprint(result)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "456",
    "title": "Напишіть програму, яка приймає послідовність 4-цифрових двійкових чисел, розділених комами, і друкує числа, які ділиться на 5 без остачі, в рядку і розділені комами.",
    "inpdata": "0100,0011,1010,1001,1100",
    "outdata": "1010",
    "solution": "items = []\nnum = [x for x in input().split(',')]\nfor p in num:\n    x = int(p, 2)\n    print(x)\n    if not x%5:\n        items.append(p)\nprint(','.join(items))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "457",
    "title": "Напишіть програму для знаходження медіани з трьох введених цілих чисел. Числа вводяться в одному рядку через пропуск.",
    "inpdata": "25 50 11\n1 9 7",
    "outdata": "25\n7",
    "solution": "a, b, c = map(int, input().split(' '))\nprint(sorted((a, b, c))[1])",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "458",
    "title": "Вводиться три числа, через кому і пропуск, що позначають день, місяць і рік. Надрукуйте дату у форматі як у вихідних даних, не використовуючи цикл і звернення до елементів за індексом.",
    "inpdata": "4, 3, 2019",
    "outdata": "4/3/2019",
    "solution": "happy = input().split(', ')\nday, month, year = happy\nprint('{0:}/{1:}/{2:}'.format(day, month, year))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "459",
    "title": "Програма отримує на вхід спадаючу послідовність натуральних чисел, що позначають значення зросту учнів. Після цього вводиться число - зріст учня, який має зайняти місце серед усіх інших. Всі числа у вхідних даних натуральні і не перевищують 200. Виведіть номер місця, яке має зайняти новий учень. Якщо є учні з однаковим зростом, таким же, як і у нового учня, то він повинен встати після них.",
    "inpdata": "165 163 160 160 157 157 155 154\n160",
    "outdata": "5",
    "solution": "s = list(map(int, input().split()))\nh = int(input())\nif s[-1] == h:\n    print(len(s) + 1)\nelif s[-1] > h:\n    print(len(s) + 1)    \nelse:\n    for i in range(len(s)):\n        if h > s[i]:\n            print(i + 1)\n            break",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "460",
    "title": "Вводиться список цілих чисел. Всі числа списку знаходяться на одному рядку. У списку всі елементи різні. Поміняйте місцями мінімальний і максимальний елементи цього списку.",
    "inpdata": "5 6 8 1 4 9 12",
    "outdata": "5 6 8 12 4 9 1",
    "solution": "s = list(map(int, input().split()))\nmax_el, min_el = max(s), min(s)\np_max = s.index(max_el)\np_min = s.index(min_el)\ns[p_max], s[p_min] = min_el, max_el\nprint(' '.join(str(el) for el in s))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "461",
    "title": "Ви вирішили написати перетворювач коду на Python в код на Java. Так як на Java прийнятий стандарт найменування \"CamelCase\", то ви вирішили навчитися перетворювати імена з \"underscore\" в цей формат. Стиль \"underscore\" характеризується тим, що слова в імені пишуться маленькими літерами і розділяються між собою символом підкреслення \"_\". Стиль \"CamelCase\" означає, що кожне слово пишеться з великої літери і роздільників між словами немає. Отже, вводиться один рядок, що містить ім’я, записане в форматі \"underscore\". Програма виводить рядок, що містить ім’я в форматі \"CamelCase\".",
    "inpdata": "my_class\nc",
    "outdata": "MyClass\nC",
    "solution": "s = input()\nsplit_row = s.lower().split('_')\nresult = ''\nfor item in split_row:\n    result += item[0].upper() + item[1:]\nprint(result)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "462",
    "title": "Напишіть програму, яка обчислює частку студентів, які отримали оцінку A. Використовується п’ятибальна система оцінювання з оцінками A, B, C, D, F. Вводиться рядок, в якому через пропуск записані оцінки студентів. Оцінок завжди не менш однієї. Виводиться дробове число з рівно двома знаками після коми.",
    "inpdata": "A B A A B C A D F\nA A A A A\nA F\nB B C B F F B C F",
    "outdata": "0.44\n1.00\n0.50\n0.00",
    "solution": "s = input().split(' ')\ncount_mark_a, count_marks = 0, 0\nfor item in s:\n    if item in 'A':\n        count_mark_a += 1\n    count_marks += 1    \nresult = count_mark_a/count_marks\nprint('{:.2f}'.format(result))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "463",
    "title": "У якийсь момент вам набридло використовувати імена файлів з пропусками і ви вирішили написати програму, яка перейменовує всі файли, що містять пропуски в імена, у яких групи прогалин замінено на символ підкреслення \"_\". Програма отримує один рядок, що містить довільні символи, в тому числі і пропуски, і виводить правильну назву із символом підкреслення замість пропусків.",
    "inpdata": "my file.txt\nstring     with        multi spaces\nsingle",
    "outdata": "my_file.txt\nstring_with_multi_spaces\nsingle",
    "solution": "s = input()\nsplit_row = s.split()  \njoin_row = '_'.join(split_row)  \nprint(join_row)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "464",
    "title": "На вхід програми подається деякий текст в одному рядку з пропусками. Необхідно знайти у тексті слово під певним номером (наприклад, п’яте слово за рахунком) і вивести на екран його першу букву.",
    "inpdata": "Now is better than never\n3",
    "outdata": "b",
    "solution": "s = input()\nn = int(input())\nprint(s.split()[n-1][0])",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "465",
    "title": "Дано список з чисел та індекс елемента в списку k. Видаліть зі списку елемент з індексом k, зсунувши вліво всі елементи, що стоять правіше елемента з індексом k. Програма отримує на вхід список, потім число k. Програма повинна здійснювати зміщення безпосередньо в списку, а не робити це при виведенні елементів. Також не можна використовувати додатковий список.",
    "inpdata": "5 7 9 0 3 11\n3",
    "outdata": "5 7 9 3 11",
    "solution": "s = list(map(int, input().split()))\nk = int(input())\ns.pop(k)\nprint(' '.join(map(str, s)))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "466",
    "title": "Дано список цілих чисел, число k і значення c. Необхідно вставити у список на позицію з індексом k елемент, рівний c, зсунувши всі елементи вправо. Вставку необхідно здійснювати у самому списку, не роблячи цього при виведенні і не створюючи додаткового списку. Вводиться список чисел. Всі числа списку знаходяться на одному рядку. У наступному рядку вводяться два цілих числа.",
    "inpdata": "9 4 6 2 0 7 14\n3 0",
    "outdata": "9 4 6 0 2 0 7 14",
    "solution": "s = list(map(int, input().split()))\nk, c = map(int, input().split())\ns = s[:k] + [c] + s[k:]\nprint(' '.join(map(str, s)))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "467",
    "title": "Напишіть програму для перетворення двійкового числа в десяткове число.",
    "inpdata": "1001\n101010111\n10000",
    "outdata": "9\n343\n16",
    "solution": "b_number = list(input())\nvalue = 0\nfor i in range(len(b_number)):\n    digit = b_number.pop()\n    if digit == '1':\n        value = value + pow(2, i)\nprint(value)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "468",
    "title": "Напишіть програму для видалення кожного третього елемента із цілочисельного списку і друку результуючого списку, доки список не стане порожнім. Початковий список цілих чисел вводиться в одному рядку через пропуск.",
    "inpdata": "2 5 8 9 4 78 7 1",
    "outdata": "[2, 5, 9, 4, 78, 7, 1]\n[2, 5, 4, 78, 7, 1]\n[2, 5, 78, 7, 1]\n[2, 5, 7, 1]\n[2, 5, 1]\n[2, 5]\n[5]\n[]",
    "solution": "nums = list(map(int, input().split(' ')))\nposition = 2\nlen_list = len(nums)\nwhile len_list > 0:\n    idx = 0\n    idx = position % len_list\n    nums.pop(idx)\n    len_list -= 1\n    print(nums)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "469",
    "title": "Необхідно зчитати рядок з цифр, розділених пропусками, і зберегти кожну цифру у список. Створіть копію списку із впорядкованими елементами у зворотному порядку. Виведіть число, яке утворюється об’єднанням елементів нового списку.",
    "inpdata": "1 4 8 3 9 5",
    "outdata": "593841",
    "solution": "numbers = [i for i in input().split()]\nnumbers_copy = numbers[:]\nnumbers_copy.reverse()\nresult = ''.join(numbers_copy)\nprint(result)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "470",
    "title": "Дано послідовність цілих чисел, яка вводиться в рядку через пропуск. Визначте два найменших елемента послідовності. Вони можуть бути як рівні між собою (обидва бути мінімальними), так і відрізнятися.",
    "inpdata": "14 3 40 56 42 43 89 69 64 72 5 44 11 25",
    "outdata": "5 3",
    "solution": "nums = [int(i) for i in input().split()]\nif nums[0] > nums[1]:\n    min1 = 0\n    min2 = 1\nelse:\n    min1 = 1\n    min2 = 0\nfor i in range(2, len(nums)):\n    if nums[i] < nums[min1]:\n        b = min1\n        min1 = i\n        if nums[b] < nums[min2]:\n            min2 = b\n    elif nums[i] < nums[min2]:\n        min2 = i\nprint(nums[min1], nums[min2])",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "471",
    "title": "Розташувати додатні і від’ємні числа введеної послідовності цілих чисел на початку списку і у кінці списку відповідно (за спаданням). Числа, рівні нулю, ігнорувати. Вивести на екран результуючий список.",
    "inpdata": "1 3 -5 0 10 -2 12 45 7 0 9 -4 -11 15 22 3",
    "outdata": "45 22 15 12 10 9 7 3 3 1 -2 -4 -5 -11",
    "solution": "nums = [int(i) for i in input().split()]\nresult_positive = []\nresult_negative = []\nfor i in nums:\n    if i > 0:\n        result_positive.append(i)\n    elif i < 0:\n        result_negative.append(i)\nresult_positive.sort(reverse=True)\nresult_negative.sort(reverse=True)\nresult = result_positive + result_negative\nprint(*result)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "472",
    "title": "Дано список слів. Напишіть програму, яка виконає заміну останніх трьох символів слів, що мають певну довжину, на певний символ. Користувач відповідно вводить наступні дані: кількість слів у списку, довжину слів, які будуть редагуватися, символ заміни останніх тьох символів і сам список слів (кожне слово в окремому рядку). Гарантовано, що довжина слів у списку щонайменше 3 символи.",
    "inpdata": "4\n5\n%\nwriter\npainter\nprogrammer\nscientist",
    "outdata": "['wri%', 'pain%', 'program%', 'scient%']",
    "solution": "n = int(input())\nlw = int(input())\nch = input()\nwords = []\nfor i in range(n):\n    words.append(input())\ni = 0\nwhile i < len(words):\n    if len(words[i]) > lw:\n    words[i] = words[i][0:-3] + ch\n    i += 1\nprint(words)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "473",
    "title": "Користувач вводить два цілих додатних числа n і m. Напишіть програму, яка створює двовимірний масив розміром n х m і заповнює його символами \".\" і \"*\" у шаховому порядку (як у вихідних даних). Лівий верхній кут повинен мати символ \".\".",
    "inpdata": "6 8",
    "outdata": ". * . * . * . *\n* . * . * . * .\n. * . * . * . *\n* . * . * . * .\n. * . * . * . *\n* . * . * . * .",
    "solution": "n, m = map(int, input().split())\nfor i in range(n):\n    for j in range(m):\n        if (i + j) % 2 == 0:\n            print('.', end=' ')\n        else:\n            print('*', end=' ')\n    print()",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "474",
    "title": "Вводиться непарне натуральне число n. Напишіть програму, яка створює зображення сніжинки за допомогою двовимірного масиву розміром n х n. Заповніть кожен елемент символом \".\". Потім заповніть середній рядок, середній стовпець і діагоналі символом \"*\". Розділяйте символи одним пропуском.",
    "inpdata": "7",
    "outdata": "* . . * . . *\n. * . * . * .\n. . * * * . .\n* * * * * * *\n. . * * * . .\n. * . * . * .\n* . . * . . *",
    "solution": "n = int(input())\nfor i in range(n):\n    for j in range(n):\n        if (i == j) or (j == n - i - 1) or (i == n // 2) or (j == n // 2):\n            print('*', end=' ')\n        else:\n            print('.', end=' ')\n    print()",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "475",
    "title": "Напишіть програму, яка приймає на вхід список чисел в одному рядку і виводить на екран в один рядок значення, які повторюються в ньому більш ніж один раз. Виведені числа не повинні повторюватися, порядок їх виведення маж бути за зростанням.",
    "inpdata": "5 8 1 3 5 2 1 3 0\n2 2 4 4 4 1",
    "outdata": "1 3 5\n2 4",
    "solution": "result = []\nnumbers = list(map(int, input().split(' ')))\nfor item in numbers:\n    if item not in result and numbers.count(item) > 1:\n        result.append(item)\nresult.sort()\nprint(*result)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "476",
    "title": "Напишіть програму, яка приймає 2 цілих числа, a і b і генерує двовимірний масив. Значення елемента в i-му рядку і j-му стовпці масиву має бути i * j (i = 0,1...,a-1; j = 0,1..., b-1).",
    "inpdata": "3 5",
    "outdata": "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]",
    "solution": "input_str = input()\nrow, col = map(int, input_str.split())\nmultilist = [[0 for col in range(col)] for row in range(row)]\nfor i in range(row):\n    for j in range(col):\n        multilist[i][j] = i*j\nprint(multilist)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "477",
    "title": "Для введеної послідовності цілих чисел, вивести їх у списку так, щоб парні елементи розташовувалися на початку списку, а непарні - в кінці.",
    "inpdata": "2 5 7 8 9 10 12 32 5",
    "outdata": "32 12 10 8 2 5 7 9 5",
    "solution": "nums = [int(i) for i in input().split()]\nresult = []\nfor i in nums:\n    if i % 2 == 0:\n        result.insert(0, i)\n    else:\n        result.append(i)\nprint(*result)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "478",
    "title": "Напишіть програму, яка обчислює суму на банківському рахунку на основі журналу транзакцій. Формат журналу транзакцій відображається наступним чином: D 100 або W 200, де D – покласти на депозит ціле значення суми, а W - вилучити. Введення транзакцій завершується порожнім рядком.",
    "inpdata": "D 100\nW 200\nD 300\nD 350\nW 200\nD 150",
    "outdata": "500",
    "solution": "netamount = 0\nwhile True:\n    s = input()\n    if not s:\n        break\n    operation, amount = map(str, s.split())\n    if operation == 'D':\n        netamount += int(amount)\n    elif operation == 'W':\n        netamount -= int(amount)\nprint(netamount)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "479",
    "title": "Робот може рухатися, починаючи від початкової точки (0, 0), вгору, вниз, вліво та вправо за допомогою кроків, наприклад: UP 5, DOWN 3, LEFT 3, RIGHT 2 тощо. Назви вказують напрямок, а цифри позначають кількість кроків. Введення порожнього рядка завершує рух робота. Напишіть програму для обчислення відстані від поточної позиції робота до початкової точки.",
    "inpdata": "UP 5\nDOWN 3\nLEFT 3\nRIGHT 2",
    "outdata": "2",
    "solution": "pos = [0, 0]\nwhile True:\n    s = input()\n    if not s:\n        break\n    direction, steps = map(str, s.split())\n    if direction == 'UP':\n        pos[1] += int(steps)\n    elif direction == 'DOWN':\n        pos[1] -= int(steps)\n    elif direction == 'LEFT':\n        pos[0] -= int(steps)\n    elif direction == 'RIGHT':\n        pos[0] += int(steps)\nprint(int(round((pos[1]**2 + pos[0]**2))**0.5))",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "480",
    "title": "Дано список назв міст світу, перерахованих в рядку через кому. Сформуйте з елементів списку повідомлення, у якому перед останнім елементом буде вставлено слово \"and\" так, як у вихідних даних. Програма має працювати з будь-якими списками, які мають довільну довжину, відмінну від нуля.",
    "inpdata": "Budapest, Rome, Istanbul, Sydney, Kyiv, Hong Kong\nKyiv, Hong Kong\nBudapest",
    "outdata": "Budapest, Rome, Istanbul, Sydney, Kyiv and Hong Kong\nKyiv and Hong Kong\nBudapest",
    "solution": "cities = [i for i in input().split(', ')] \nresult = []\nif len(cities) > 1:\n    for town in cities[:-2]:\n        result.append(town + ',')\n    result.extend([cities[-2], 'and', cities[-1]])\n    print(*result)\nelse:\n    print(*cities)",
    "chapter": "списки і кортежі",
    "level": "середній"
  },
  {
    "id": "481",
    "title": "У рядку через кому перераховані слова. Сформувати з цих слів новий рядок. Слова мають бути відсортовані за спаданням (від \"Z\" до \"A\") без урахування регістру і записані через пропуск.",
    "inpdata": "horse, cat, parrot, goldfish, dog",
    "outdata": "parrot horse goldfish dog cat",
    "solution": "s = input().split(', ')\ns.sort(reverse=True)\ns_sorted = ' '.join(s)\nprint(s_sorted)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "482",
    "title": "Дано послідовність цілих чисел, які записані в одному рядку через пропуск. Утворіть і надрукуйте голову (перший елемент) і хвіст (усі інші елементи) вказаної послідовності не використовуючи цикли і зрізи. Довжина послідовності може бути довільною.",
    "inpdata": "2 10 15 9 3 6 7 11",
    "outdata": "2\n10 15 9 3 6 7 11",
    "solution": "items = [int(i) for i in input().split()] \nhead, *tail = items\nprint(head)\nprint(*tail)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "483",
    "title": "Напишіть програму, яка виводить частину послідовності 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5... (число повторюється стільки разів, чому дорівнює). На вхід програми передається невід’ємне ціле число n - стільки елементів послідовності повинна надрукувати програма. На виході очікується послідовність чисел, записаних через пропуск в один рядок.",
    "inpdata": "8",
    "outdata": "1 2 2 3 3 3 4 4",
    "solution": "n = int(input())\nresult = []\nfor i in range(n):\n    k = 0\n    while k < i + 1:\n        result.append(i + 1)\n        k += 1\n    if len(result) > n: \n        break\nresult = result[0:n]\nprint(*result)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "484",
    "title": "Виведіть таблицю розміром n ? n, заповнену числами від 1 до n^2 по спіралі, що виходить з лівого верхнього кута і закрученою за годинниковою стрілкою.",
    "inpdata": "4",
    "outdata": "1 2 3 4\n12 13 14 5\n11 16 15 6\n10 9 8 7",
    "solution": "n = int(input())\nfor k in range(n**2+1):\n    matrix = [[None for j in range(n)] for i in range(n)]\nx, y, dx, dy = 0, 0, 1, 0\nfor element in range(1, n**2 + 1):\n    matrix[x][y] = element\n    vx, vy = x + dx, y + dy\n    if vx >= 0 and n > vx and vy >= 0 and n > vy and matrix[vx][vy] == None:    \n        x, y = vx, vy\n    else:\n        dx, dy = -dy, dx\n        x, y = x + dx, y + dy\nfor y in range(len(matrix)):\n    for x in range(len(matrix)):\n        print(matrix[x][y], end = ' ')\n    print()",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "485",
    "title": "Суть завдання та ж, що і у задачі Шифр Цезаря, з однією відмінністю: кодуються символи з інтервалу 1F600-1F64F таблиці символів Unicode. Використовується кодування UTF-8. Для всіх символів зсув один і той же. Зсув циклічний, тобто, якщо до останнього символу алфавіту застосувати одиничний зсув, то він заміниться на перший символ, і навпаки. Напишіть програму, яка шифрує текст шифром Цезаря. На першому рядку вказується використовуваний зсув шифрування: ціле число. Додатне число відповідає зсуву вправо. На другому рядку вказується непорожня фраза для шифрування. Не звертайте уваги, якщо у вас відображаються прямокутники замість деяких символів. Це означає, що ваш шрифт не містить цих символів. Програма має вивести єдиний рядок, в якій записана зашифрована послідовність.",
    "inpdata": "2\n😍😎😏",
    "outdata": "😏😐😑",
    "solution": "n = int(input())\nphrase = input().strip()\nresult = ''\nfor item in phrase:\n    g = ord(item) + (n % 80)\n    if g > 128591:\n        result += chr(g - 80)\n    elif g < 128512:\n        result += chr(g + 80)\n    else:\n        result += chr(g)\nprint('{0:}'.format(result))",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "486",
    "title": "Використовуючи поняття списку, напишіть програму, яка створює 3D масив елементів a x b x c, кожен з яких має значення 0. Значення a, b, c вводяться в одному рядку через пропуск.",
    "inpdata": "2 3 3\n4 4 4",
    "outdata": "[[[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]]]\n[[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]",
    "solution": "a, b, c = map(int, input().split())\narray = [[ [0 for col in range(a)] for col in range(b)] for row in range(c)]\nprint(array)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "487",
    "title": "Напишіть програму, на вхід якої подається список чисел одним рядком. Програма повинна для кожного елемента цього списку вивести суму двох його сусідів. Для елементів списку, які є крайніми, одним із сусідів вважається елемент, що знаходить на протилежному кінці цього списку. Якщо на вхід прийшло тільки одне число, треба вивести його ж. Виведення повинно містити один рядок з числами нового списку, розділеними пропусками.",
    "inpdata": "1 3 5 6 10\n5",
    "outdata": "13 6 9 15 7\n5",
    "solution": "result = []\nnumbers = list(map(int, input().split(' ')))\nlen_numbers = len(numbers)\nif len_numbers == 1:\n    print(numbers[0])\nelse:\n    for i in range(len_numbers):\n        if i == 0:\n            result.append(numbers[i+1] + numbers[-1])\n        elif i == len_numbers-1:\n            result.append(numbers[len_numbers-2] + numbers[0])\n        else:\n            result.append(numbers[i+1] + numbers[i-1])\n    print(*result)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "488",
    "title": "Вводиться рядок, що складається із слів, розділених пропусками. Потрібно впорядкувати слова в рядку так, щоб найбільш короткі з них були спочатку рядка, а найбільш довгі в кінці. Слова необхідно вивести на екран через кому і пропуск, а рядок впорядкованих слів має закінчуватися крапкою.",
    "inpdata": "ab aaab ba baaaaa a aba",
    "outdata": "a, ab, ba, aba, aaab, baaaaa.",
    "solution": "words = sorted(input().split(), key = len)\ns = ''\nfor item, value in enumerate(words):\n    s += value + ', '\nprint(s.strip(', ') + '.')",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "489",
    "title": "Вводяться n рядків. Визначити найдовший рядок і вивести його номер на екран. Якщо найдовших рядків кілька, то вивести номери всіх таких рядків.",
    "inpdata": "5\nThames\nAmazon\nNile\nYangtze\nDnieper",
    "outdata": "4\n5",
    "solution": "n = int(input())\nrows = []\nfor i in range(n):\n    rows.append(input())\nk = 0\nm = max([len(i) for i in rows]) \nfor i in range(n):\n    if len(rows[i]) == m:\n        print(i + 1)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "490",
    "title": "Дано список з n (1 ≤ n ≤ 100000) цілих чисел і число k (|k| < 100000). Циклічно посуньте список на |k| елементів вправо, якщо k - додатне і вліво, якщо від’ємне число. Програма отримує на вхід список цілих чисел, потім число k. Рішення повинно мати складність O(n), тобто не повинно залежати від k. Додатковим списком користуватися не можна.",
    "inpdata": "5 3 7 4 6\n3\n7 4 6 5 3\n-3",
    "outdata": "7 4 6 5 3\n5 3 7 4 6",
    "solution": "s = input().split()\nk = int(input())\ni = k % len(s)\nprint(' '.join(s[-i:] + s[:-i]))",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "491",
    "title": "Користувач вводить ціле число n і видаляє одну цифру числа так, щоб число що утворилось, було максимально можливим. Наприклад, якщо число, яке ввели 432, то необхідно видалити цифру 2, яка стоїть на 3 місці, щоб отримати максимально можливе число 43. Напишіть програму, яка знайде максимально можливе число, яке можна отримати після видалення однієї цифри.",
    "inpdata": "432\n239\n101",
    "outdata": "43\n39\n11",
    "solution": "n = list(input())\nmy_temp_list = []\nfor item in range(len(n)):\n    my_temp_list.append(''.join(n[:item] +n[item + 1:]))\nprint(sorted(my_temp_list)[-1])",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "492",
    "title": "Вводиться рядок слів, розділених пропусками. Знайти найдовше слово і вивести його на екран. Розглянути випадок, коли найдовших неоднакових слів може бути кілька.",
    "inpdata": "Sparse is better than dense\nReadability counts\nLong time Pythoneer Tim Peters succinctly channels the BDFL's guiding principles for Python's design into 20 aphorisms",
    "outdata": "Sparse better\nReadability\nsuccinctly principles",
    "solution": "s = input().split()\nr = []\nf = '' \ns_sorted = sorted(s, key=len)\nel = len(s_sorted[-1])\nfor i in s:\n    t = i.strip(',')\n    if len(t) == el:\n        if t not in r:\n            r.append(t)      \nfor i in r:\n    f += i + ' ' \nprint(f.strip())",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "493",
    "title": "В один ряд поставили n кеглів, пронумерувавши їх зліва направо числами від 1 до n. Потім в цей ряд кинули k куль, при цьому i-та куля збила всі кеглі з номерами від m до h включно. Визначте, які кеглі залишилися стояти на місці. Програма отримує на вхід кількість кеглів n і кількість кидків k. Далі йде k пар чисел m, h, при цьому 1 ≤ m ≤ h ≤ n ≤ 100. Програма повинна вивести послідовність з n символів, де j-й символ є \"I\", якщо j-та кегля залишилася стояти, або \".\", якщо j-та кегля була збита.",
    "inpdata": "10 3\n8 10\n2 5\n3 6",
    "outdata": "I.....I...",
    "solution": "n, m = map(int, input().split())\nrow = ['I' for i in range(n)]\ni = 0\nwhile i < m:\n    s = input().split()\n    for j in range(len(row)):\n        if j+1 >= int(s[0]) and j+1 <= int(s[1]):\n            row[j] = '.'\n    i += 1\nfor el in row:\n    print(el, end='')",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "494",
    "title": "Дано список цілих чисел. Потрібно \"стиснути\" його, перемістивши всі ненульові елементи в ліву частину списку, не змінюючи їх порядок, а всі нулі - в праву частину. Порядок ненульових елементів змінювати не можна, додатковий список використовувати не можна, завдання потрібно виконати за один прохід по списку. Роздрукуйте отриманий список.",
    "inpdata": "6 0 3 0 5 0 0 4",
    "outdata": "6 3 5 4 0 0 0 0",
    "solution": "s = input().split() \nk = 0\nr = ''\nfor i in s:\n    if i == '0':\n        k += 1\n    else:\n        r += i + ' '\nprint(''.join(r) + '0 '*k)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "495",
    "title": "Вводиться рядок, який може мати пропуски на початку, між словами і у кінці. Пропусків може бути більше одного. Необхідно привести рядок до нормального вигляду, тобто видалити усі пропуски, а між словами залишити тільки один пропуск.",
    "inpdata": "      The   Zen     of     Python",
    "outdata": "The Zen of Python",
    "solution": "s = input().strip()\ns = ' '.join([el for el in s.split(' ') if el.strip()])\nprint(s)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "496",
    "title": "Напишіть програму, яка приймає на вхід список чисел і число (в окремих рядках), після чого виводить всі позиції через пропуск, на яких це число зустрічається в переданому списку (позиції у списку нумеруються з 1). Позиції повинні бути виведені в порядку зростання. Якщо число не знайдено в списку, потрібно вивести рядок \"None\" (без лапок, з великої літери).",
    "inpdata": "5 7 3 4 9 8 4 7 4\n4",
    "outdata": "4 7 9",
    "solution": "s = input().split()\nn = int(input())\nresult = []\nfor i in range(len(s)):\n    if n == int(s[i]):\n        result.append(i + 1)\nif result:\n    out = sorted(result)\n    for item in out:\n        print(item, end=' ')\nelse:\n    print('None')",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "497",
    "title": "Напишіть програму, яка знаходить усі позиції входження підрядка B у рядок A. На першому рядку міститься вхідний рядок, на другому рядку введення вказаний підрядок, позиції якого потрібно знайти. Рядки складаються з символів англійського алфавіту. Програма має вивести позиції входження підрядка B у рядок A (індексація починається з 1), розділені пропуском або число -1 в разі, коли підрядок не знайдено.",
    "inpdata": "abacabadaba\naba\nabc\nd",
    "outdata": "0 4 8\n-1",
    "solution": "s = input()\nout = input()\nresult = []\ni = 0\nwhile i < len(s):\n    item = s.find(out, i)\n    if item != -1 and item not in result:\n        result.append(item)\n    i += 1\nif result == []:\n    print('-1')\nelse:\n    for item in result:\n        print(item, end=' ')",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "498",
    "title": "Кодування довжин послідовностей - це базовий алгоритм стиснення даних. Реалізуйте алгоритм дешифрування (декодування) рядків, закодованих за допомогою одного з найпростіших варіантів кодування довжин послідовностей. На вхід алгоритму подається рядок, що містить цифри і символи англійського алфавіту. Цей рядок розбивається на так звані серії (послідовності), які кодуються парою число-символ або просто символ (в такому випадку число вважається рівним одиниці). Результат повинен містити ці серії в тому ж порядку, що вони і зустрічаються в заданому рядку, при цьому кожна серія розгортається в послідовність символів відповідної довжини. Наприклад, закодований рядок \"3ab4c2CaB\" розбивається на серії \"3a\", \"b\", \"4c\", \"2C\", \"a\", \"B\", після чого, перетворюючи серії, отримуємо початковий розкодований рядок \"aaabccccCCaB\".",
    "inpdata": "3ab4c2CaB\n10a3b2c4DFj5h",
    "outdata": "aaabccccCCaB\naaaaaaaaaabbbccDDDDFjhhhhh",
    "solution": "data = input() \nt, temp, result = '', [], ''\nfor i in range(len(data)):\n        if data[i].isdigit():\n            t += data[i]\n        if data[i].isalpha() and data[i-1].isdigit():\n            temp.append((data[i], int(t)))\n            t = ''\n        elif data[i].isalpha() and not data[i-1].isdigit():\n            temp.append((data[i], 1))\nfor item in temp:\n    result += item[0] * item[1] \nprint(result)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "499",
    "title": "Напишіть програму, яка отримує на вхід чотирьохзначне додатне десяткове число та генерує з цифр цього числа мінімально можливе чотирьохзначне число та максимально можливе чотирьохзначне число. У першому рядку задано одне чотирьохзначне число. Виведіть у другому рядку два числа - найменше чотирьохзначне число та найбільше чотирьохзначне число, які можна отримати з цифр даного числа. Числа розділяйте одним пропуском.",
    "inpdata": "1390\n1010\n5173",
    "outdata": "1039 9310\n1001 1100\n1357 7531",
    "solution": "numbers = list(input())\nnumbers_sorted = sorted(numbers)\nnumbers_sorted_reverse = sorted(numbers, reverse=True)\nif '0' in numbers_sorted:\n    for i in range(len(numbers_sorted)):\n        if numbers_sorted [i]!= '0':\n            numbers_sorted.insert(0, numbers_sorted.pop(i))\n            break    \nmin_number = ''.join(numbers_sorted)\nmax_number = ''.join(numbers_sorted_reverse)\nprint(min_number, max_number)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "500",
    "title": "Вводиться послідовність цілих чисел у вигляді як у вхідних даних і перетвоюється у список списків, тобто у список, кожен елемент якого також є списком. Впорядкуйте цей список по другому елементу кожного списку і виведіть впорядкований список.",
    "inpdata": "1 2 3,2 1 3,4 0 1",
    "outdata": "[[1, 2, 3], [2, 1, 3], [4, 0, 1]]\n[[4, 0, 1], [2, 1, 3], [1, 2, 3]]",
    "solution": "numbers = [list(map(int, i.split())) for i in input().split(',')] \nprint(numbers)\nnumbers.sort(key=lambda x: x[1])\nprint(numbers)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "501",
    "title": "У трьох автобусах розсадили дітей так, що їх кількість в різних автобусах різна. Яку найменшу кількість дітей потрібно пересадити, щоб у кожному автобусі їх було порівно? У першому рядку задано три натуральних числа, не більших за 100 - кількість дітей у першому, другому та третьому автобусах. Виведіть одне число - найменшу кількість дітей, яких потрібно пересадити. Якщо це зробити не можливо, то виведіть \"NO SOLUTIONS\".",
    "inpdata": "9 10 10\n2 5 8",
    "outdata": "NO SOLUTIONS\n3",
    "solution": "children = input().split(' ')\nsum_children = transfer = 0 \nfor number in children:\n    sum_children += int(number)\nif sum_children % 3 == 0:\n    averages_children = sum_children // 3\n    for number in children:\n        transfer += abs(int(number) - averages_children)\n    print(transfer // 2)\nelse:\n    print('NO SOLUTIONS')",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "502",
    "title": "Напишіть програму, яка знайде максимально можливе число, яке можна отримати після видалення однієї цифри. Перший рядок містить одне ціле число n (10 ≤ n ≤ 2025). Виведіть у другому рядку максимально можливе число, яке можна отримати після видалення однієї цифри.",
    "inpdata": "4378\n1095\n2000",
    "outdata": "478\n195\n200",
    "solution": "number = list(input())\nmy_temp_list = []\nfor item in range(len(number)):\n    my_temp_list.append(''.join(number[:item] + number[item + 1:]))\nprint(sorted(my_temp_list)[-1])",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "503",
    "title": "У римській системі числення для позначення чисел використовуються наступні символи (праворуч записані числа, яким вони відповідають в десятковій системі числення): I = 1, V = 5, X = 10, L = 50, C = 100, D = 500, M = 1000. Будемо використовувати варіант, в якому числа 4, 9, 40, 90, 400 і 900 записуються як віднімання з більшого числа меншого: IV, IX, XL, XC, CD і CM, відповідно. Напишіть програму, яка переводить число з римської в десяткову систему числення. Користувач вводить рядок, що містить число, закодоване в римській системі числення. Гарантується, що число менше 4000. Програма має вивести рядок, що містить число в десятковій системі числення, відповідне введеному.",
    "inpdata": "MCMLXXXI\nXXI\nIV",
    "outdata": "1981\n21\n4",
    "solution": "s = input()\nnumeral_map = tuple(zip(\n    (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1),\n    ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I')\n))\ni = result = 0\nfor integer, numeral in numeral_map:\n    while s[i:i + len(numeral)] == numeral:\n        result += integer\n        i += len(numeral)\nprint(result)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "504",
    "title": "Анаграма - переставлення літер у слові, завдяки чому утворюється нове значення слова. Напишіть програму, яка перевіряє, чи є два введених слова анаграмами. Програма повинна вивести True в разі, якщо введені слова є анаграмами, і False в інших випадках. Слово може складатися тільки з англійських символів. Регістр букв не повинен впливати на відповідь.",
    "inpdata": "restful\nfluster\nforty-five\nover-fifty\nanagram\nnaganra",
    "outdata": "True\nTrue\nFalse",
    "solution": "one_word = input().lower()\ntwo_word = input().lower()\none_list = list(one_word)\ntwo_list = list(two_word)\none_list.sort()\ntwo_list.sort()\nflag = True\nposition = 0\nif len(one_word) != len(two_word):\n    flag = False\nelse:\n    while position < len(one_word):\n        if one_list[position] == two_list[position]:\n            position += 1\n        else:\n            flag = False\n            break\nprint(flag)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "505",
    "title": "Магічний квадрат - це квадратна таблиця n x n, заповнена цілими числами таким чином, що сума чисел у кожному рядку, кожному стовпчику і на обох діагоналях однакова. Напишіть програму, яка отримує послідовність чисел у форматі як у вхідних даних, з яких утворюється двовимірна таблиця (список списків) цілочисельних елементів і перевірте чи є вона магічним квадратом. Програма має вивести True чи False відповідно.",
    "inpdata": "1 2 3,4 5 6,7 8 9\n4 9 2,3 5 7,8 1 6\n7 12 1 14,2 13 8 11,16 3 10 5,9 6 15 4\n23 28 21,22 24 26,27 20 25\n16 23 17,78 32 21,17 16 15\n4 3 8,9 5 1,2 7 6",
    "outdata": "False\nTrue\nTrue\nTrue\nFalse\nTrue",
    "solution": "matrix = [list(map(int, i.split())) for i in input().split(',')] \nsize_matrix = len(matrix[0])\nsum_list = []\n#Vertical:\nfor col in range(size_matrix):\n    sum_list.append(sum(row[col] for row in matrix))\n#Horizontal\nsum_list.extend([sum(line) for line in matrix])\n#Diagonals\ndiagonal_main = 0\nfor i in range(0, size_matrix):\n    diagonal_main += matrix[i][i]\nsum_list.append(diagonal_main)  \ndiagonal_indirect = 0\nfor i in range(size_matrix-1,-1,-1):\n    diagonal_indirect += matrix[i][i]\nsum_list.append(diagonal_indirect)\nif len(set(sum_list)) > 1:\n    print(False)\nelse:\n    print(True)",
    "chapter": "списки і кортежі",
    "level": "високий"
  },
  {
    "id": "506",
    "title": "Створіть словник з інформацією про пошукові системи, в якому ключі – назви пошукових систем, а значення – частка їхнього використання у світі на даний момент (дійсне число). Надрукуйте елементи словника як у вихідних даних. Елементи у словнику невпорядковані.",
    "inpdata": "Немає",
    "outdata": "Yahoo!: 2.09\nGoogle: 90.15\nBing: 3.23\nBaidu: 2.2",
    "solution": "searches = {'Yahoo!': 2.09, 'Google': 90.15, 'Bing': 3.23, 'Baidu': 2.20}\nfor k, v in searches.items():\n    print(k + ':', v)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "507",
    "title": "Створіть словник зі списками добрих справ на сьогодні і на завтра. Надрукуйте із словника добрі справи, які плануєш зробити сьогодні і взавтра.",
    "inpdata": "Немає",
    "outdata": "today:\nMake a compliment to a friend\nCall your grandparents\nEmbrace parents\ntomorrow:\nFeed the birds in the park\nGive unnecessary things to those who need them\nSmile",
    "solution": "good_deeds = {'today': ['Make a compliment to a friend', 'Call your grandparents', 'Embrace parents'], 'tomorrow': ['Feed the birds in the park', 'Give unnecessary things to those who need them', 'Smile']}\nfor day, deeds in good_deeds.items():\n    print(day + ':')\n    for deed in deeds:\n        print(deed)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "508",
    "title": "Припустимо, що у нас є словник, в якому ключі є ідентифікаторами, а значення – іменами користувачів. Напишіть програму, яка виводить вітальне повідомлення користувачу на основі його ідентифікатора. Якщо ідентифікатор відсутній у словнику, виводиться вітання для усіх користувачів.",
    "inpdata": "232\n550\n190\n500",
    "outdata": "Hi, Alice!\nHi, Bob!\nHi, Jack!\nHi, to all!",
    "solution": "name_for_userid = {\n232: 'Alice',\n550: 'Bob',\n190: 'Jack',\n}\nuserid = int(input())\nprint('Hi, {0:}!'.format(name_for_userid.get(userid, 'to all')))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "509",
    "title": "Ви створюєте пригодницьку гру і використовуєте для зберігання предметів гравця словник, у якому ключі - це назви предметів, значення - кількість одиниць кожної із речей. Виведіть повідомлення про усі речі гравця як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "Equipment:\n3 key\n1 mace\n24 gold coin\n1 lantern\n10 stone\nTotal number of things: 39",
    "solution": "things = {'key': 3, 'mace': 1, 'gold coin': 24, 'lantern': 1, 'stone': 10}\ntotal = 0\nprint('Equipment:')\nfor thing in things:\n    print(things[thing], thing)\n    total += things[thing]\nprint('Total number of things:', total)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "510",
    "title": "Напишіть програму для сортування за зростанням (за алфавітом) словника за ключами. Словник зберігає пари ключ-значення у вигляді \"назва фільму: рік релізу\". Інформація виводиться як у вихідних даних: сортування має бути проведено за назвами фільмів.",
    "inpdata": "Немає",
    "outdata": "('Avengers: Endgame', 2019) ('Guardians of the Galaxy', 2014) ('Iron Man', 2008) ('Thor', 2011)",
    "solution": "marvel = {'Iron Man': 2008, 'Thor': 2011, 'Guardians of the Galaxy': 2014, 'Avengers: Endgame': 2019} \np = sorted(marvel.items())\nprint(*p)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "511",
    "title": "Напишіть програму для сортування за спаданням (порядок, зворотний алфавітному) словника за ключами. Словник зберігає пари ключ-значення у вигляді \"країна: столиця\". Інформація виводиться як у вихідних даних: сортування має бути проведено за назвами країн.",
    "inpdata": "Немає",
    "outdata": "[('Ukraine', 'Kyiv'), ('France', 'Paris'), ('Denmark', 'Copenhagen'), ('China', 'Beijing'), ('Canada', 'Ottawa')]",
    "solution": "countries = {'Canada': 'Ottawa', 'Denmark': 'Copenhagen', 'China': 'Beijing', 'Ukraine': 'Kyiv', 'France': 'Paris'}\nm = sorted(countries.items(), reverse=True)\nprint(m)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "512",
    "title": "Надрукуйте елементи словника, де ключі - це числа від 1 до n (обидва числа включно), а значення - квадрати ключів. n – ціле число, яке вводить користувач.",
    "inpdata": "15",
    "outdata": "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225}",
    "solution": "n = int(input())\nd = {k:k**2 for k in range(1, n + 1)}\nprint(d)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "513",
    "title": "Створіть словник, в кому ключі – назви днів тижня, а значення - цілі числа, що позначають порядковий номер дня тижня від 0 до 6. Надрукуйте назву дня за введеним порядковим номером дня. Якщо введений номер виходить за межі, програма жодних повідомлень не друкує і не повідомляє про помилку.",
    "inpdata": "3\n0",
    "outdata": "Wednesday\nSunday",
    "solution": "days = {\n    'Sunday': 0,\n    'Monday': 1,\n    'Tuesday': 2,\n    'Wednesday': 3,\n    'Thursday': 4,\n    'Friday': 5,\n    'Saturday': 6\n}\nday = int(input())\nif day >= 0 and day < 7:\n    print(*[k for k, v in days.items() if day == v])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "514",
    "title": "Створіть словник у якому ключами є назви жанрів комп’ютерних ігор, а значеннями - назва конкретної гри даного жанру. Виведіть вміст словника як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "simulations: Euro Track Simulator\nadventure: Myst\nrts: Kingdom Two Crowns\naction: Grand Theft Auto\nsports: FIFA",
    "solution": "games = {'simulations': 'Euro Track Simulator', 'adventure': 'Myst', 'rts': 'Kingdom Two Crowns', 'action': 'Grand Theft Auto', 'sports': 'FIFA'}\nfor dict_key, dict_value in games.items():\n    print(dict_key + ':', dict_value)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "515",
    "title": "Дано словник, у якому ключами є назви платних застосунків для платформи Android, а значеннями - їх ціна (дійсне число, два знаки після десяткової крапки). Надрукуйте із словника через кому з пропуском максимальну і мінімальну ціни для застосунків.",
    "inpdata": "Немає",
    "outdata": "179.99, 5.0",
    "solution": "top_paid_apps = {'Minecraft': 123.50, 'Torque': 41.37, 'Rocket Rogues: Ultimate': 18.99, 'Grand Theft Auto: San Andreas': 179.99, 'Evertale': 5.00}\nresult = list(sorted(top_paid_apps.values()))\nprint(result[-1], result[0], sep=', ')",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "516",
    "title": "Напишіть програму для створення словника із введеного рядка символів для підрахунку кількості символів.",
    "inpdata": "Lorem ipsum dolor sit amet",
    "outdata": "{'L': 1, 'o': 3, 'r': 2, 'e': 2, 'm': 3, ' ': 4, 'i': 2, 'p': 1, 's': 2, 'u': 1, 'd': 1, 'l': 1, 't': 2, 'a': 1}",
    "solution": "s = input()\nd = {}\nfor c in s:\n    d[c] = s.count(c)\nprint(d)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "517",
    "title": "Створіть словник, у якому ключі - імена відомих програмістів, а значення - їхні дати народження у форматі dd/mm/yyyy. Напишіть програму, яка за введеним ім’ям відомого інформатика друкує його дату народження або у відсутності такого - відповідне повідомлення як у вихідних даних.",
    "inpdata": "Ada Lovelace\nJack Dorsey",
    "outdata": "Ada Lovelace's birthday is 10/12/1815.\nSadly, we don't have Jack Dorsey's birthday.",
    "solution": "birthdays = {\n    'Dennis Ritchie': '09/09/1941',\n    'Mark Zuckerberg': '14/05/1984',\n    'Ada Lovelace': '10/12/1815',\n    'Guido van Rossum': '31/10/1956',\n    'Linus Torvalds': '28/12/1969'\n    }\nname = input()\nif name in birthdays:\n    print('{}\\'s birthday is {}.'.format(name, birthdays[name]))\nelse:\n    print('Sadly, we don\\'t have {}\\'s birthday.'.format(name))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "518",
    "title": "Створіть словник, що містить назви продуктів в уявному холодильнику. Найменування їжі будуть ключами, а відповідне значення кожного продукту харчування має бути значенням-рядком, що описує їжу. Після введення користувачем назви продукту, виведіть повідомлення про наявність або відсутність його у холодильнику.",
    "inpdata": "butter\nmilk",
    "outdata": "butter is a dairy product with high butterfat content\nmilk wasn't found in the fridge",
    "solution": "food_sought = input()\nfridge = {'butter': 'is a dairy product with high butterfat content', 'sour cream': 'is a dairy product obtained by fermenting regular cream with certain kinds of lactic acid bacteria', 'cheese': 'is a dairy product derived from milk'}\nif food_sought in fridge:\n    print(food_sought, fridge[food_sought])\nelse:\n    print('{0:} wasn\\'t found in the fridge'.format(food_sought))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "519",
    "title": "Напишіть програму, яка приймає рядок символів, і обчислює кількість букв і цифр.",
    "inpdata": "Project Gutenberg offers over 59,000 free eBooks",
    "outdata": "LETTERS 36\nDIGITS 5",
    "solution": "d = {'DIGITS': 0, 'LETTERS': 0}\nfor c in input():\n    if c.isdigit():\n        d['DIGITS'] += 1\n    elif c.isalpha():\n        d['LETTERS'] += 1\nprint('LETTERS', d['LETTERS'])\nprint('DIGITS', d['DIGITS'])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "520",
    "title": "Напишіть програму, яка приймає рядок символів, і обчислює кількість великих та малих літер.",
    "inpdata": "The quick brown FOX jumps over a lazy DOG",
    "outdata": "UPPER CASE 7\nLOWER CASE 26",
    "solution": "d = {'UPPER CASE': 0, 'LOWER CASE': 0}\nfor c in input():\n    if c.isupper():\n        d['UPPER CASE'] += 1\n    elif c.islower():\n        d['LOWER CASE'] += 1\nprint('UPPER CASE', d['UPPER CASE'])\nprint('LOWER CASE', d['LOWER CASE'])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "521",
    "title": "Створіть словник із даними про студентів: ключі - імена студентів, значення - бали для кожного. Програма повинна визначити середній бал і вивести імена студентів, чий бал вище середнього.",
    "inpdata": "Немає",
    "outdata": "Alex\nBarbara",
    "solution": "students = {'Alex': 10, 'Barbara': 11, 'Jack': 9, 'Den': 7}\ns = 0\nfor name in students:\n    point = students[name]\n    s += point\navrg = s / len(students)\nfor name in students:\n    if students[name] > avrg:\n        print(name)",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "522",
    "title": "Напишіть програму для підрахунку кількості символів (символьної частоти) у введеному рядку.",
    "inpdata": "google",
    "outdata": "g 2\no 2\nl 1\ne 1",
    "solution": "s = input()\nd = {}\nfor letter in s:\n    keys = d.keys()\n    if letter in keys:\n        d[letter] += 1\n    else:\n        d[letter] = 1\nfor k in d:\n    print(k, d[k])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "523",
    "title": "Створіть англо-німецький словник з назвою e2g і виведіть його вміст на екран.",
    "inpdata": "Немає",
    "outdata": "stork: storch\nhawk: falke\nwoodpecker: specht\nowl: eule",
    "solution": "e2g = {'stork': 'storch', 'hawk': 'falke', 'woodpecker': 'specht', 'owl': 'eule'}\nfor key in e2g:\n    print('{0:}: {1:}'.format(key, e2g[key]))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "524",
    "title": "Словники можуть використовуватися для моделювання справжнього словника. Оберіть кілька термінів з програмування (або із іншої області), які ви знаєте на цей момент. Використайте ці слова як ключі словника, а їх визначення - як значення. Виведіть кожне слово і його визначення у спеціально відформатованому вигляді як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "variable\n\ta symbolic name associated with a value and whose associated value may be changed\ntype\n\tis a classification of data which tells the compiler or interpreter how the programmer intends to use the data\nprogram\n\ta collection of instructions that performs a specific task when executed by a computer",
    "solution": "definitions = {\n    'variable':\n        'a symbolic name associated with a value and whose associated value may be changed',\n    'type':\n        'is a classification of data which tells the compiler or interpreter how the programmer intends to use the data',\n    'program':\n        'a collection of instructions that performs a specific task when executed by a computer'\n}\nfor key in definitions:\n    print('{0:s}\\n\\t{1:s}'.format(key, definitions[key]))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "525",
    "title": "Cтворіть словник з річками і регіонами, територією яких вони протікають. Виведіть повідомлення із назвами річки і регіону, як у вихідних даних, для усіх елементів словника, враховуючи те, що у повідомлення підставляються назви річок і територій із словника.",
    "inpdata": "Немає",
    "outdata": "The Amazon runs through South America.\nThe Odra runs through Central Europe.\nThe Ganges runs through South Asia.",
    "solution": "rivers = {'Amazon': 'South America', 'Odra': 'Central Europe', 'Ganges': 'South Asia'}\nfor key in rivers:\n    print('The {0:s} runs through {1:s}.'.format(key, rivers[key]))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "526",
    "title": "Створіть словник з назвами мов програмування (ключі) та іменами розробників цих мов (значення). Виведіть по черзі для усіх елементів словника повідомлення як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "My favorite programming language is JavaSript. It was created by Brendan Eich.\nMy favorite programming language is Python. It was created by Guido van Rossum.\nMy favorite programming language is Ruby. It was created by Yukihiro Matsumoto.\nMy favorite programming language is PHP. It was created by Rasmus Lerdorf.",
    "solution": "programming_languages = {\n    'JavaSript': 'Brendan Eich',\n    'Python': 'Guido van Rossum',\n    'Ruby': 'Yukihiro Matsumoto',\n    'PHP': 'Rasmus Lerdorf'\n}\nfor key in programming_languages:\n    print('My favorite programming language is {0:s}. It was created by {1:s}.'.format(key, programming_languages[key]))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "527",
    "title": "Використайте словник для виведення представлення букви, яку вводить користувач, у символах азбуки Морзе. Передбачте у програмі обробку малих і великих букв.",
    "inpdata": "D\nf",
    "outdata": "-..\n..-.",
    "solution": "morse = {\n    'A': '.-',\n    'B': '-...',\n    'C': '-.-.',\n    'D': '-..',\n    'E': '.',\n    'F': '..-.',\n    'G': '--.',\n    'H': '....',\n    'I': '..',\n    'J': '.---',\n    'K': '-.-',\n    'L': '.-..',\n    'M': '--',\n    'N': '-.',\n    'O': '---',\n    'P': '.--.',\n    'Q': '--.-',\n    'R': '.-.',\n    'S': '...',\n    'T': '-',\n    'U': '..-',\n    'V': '...-',\n    'W': '.--',\n    'X': '-..-',\n    'Y': '-.--',\n    'Z': '--..'\n}\nsymbol = input().upper()\nprint(morse[symbol])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "528",
    "title": "Створіть кілька словників, імена яких - це клички домашніх тварин. У кожному словнику збережіть інформацію про вид домашнього улюбленця та ім’я власника. Збережіть словники в списку з ім’ям pets. Виведіть повідомленя як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "Jim is the owner of a pet - a cat.\nAlex is the owner of a pet - a dog.\nElena is the owner of a pet - a parrot.",
    "solution": "cliff = {'pet': 'cat', 'owner': 'Jim'}\nrikki = {'pet': 'dog', 'owner': 'Alex'}\nnorton = {'pet': 'parrot', 'owner': 'Elena'}\npets = [cliff, rikki, norton]\nfor key in pets:\n    print('{0:} is the owner of a pet - a {1:}.'.format(key['owner'], key['pet']))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "529",
    "title": "Створіть словник для зберігання інформації про міста. Використайте назви міст в якості ключів словника. Створіть словник з інформацією про кожне місто: включіть в нього країну, в якій розташоване місто, приблизну чисельність населення і один цікавий факт про місто. Виведіть назву кожного міста і всю збережену інформацію про нього як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "Rome:\n\tCountry: Italy\n\tPopulation: 2868000 people\n\tFact: Rome is one of the oldest cities in the world, the capital of Ancient Rome. Therefore, Rome is often called the \"eternal city\".\nCanberra:\n\tCountry: Australia\n\tPopulation: 381448 people\n\tFact: The design of Canberra was based on the concept of a garden city, which includes significant areas of natural vegetation, which earned for Canberra the title of \"bush capital\" (translated from the English \"forest capital\").\nToronto:\n\tCountry: Canada\n\tPopulation: 2503281 people\n\tFact: In the world of professional sports, the city is the most famous hockey team of Toronto Maple Leafs. The city holds the nickname of the \"hockey universe center\".",
    "solution": "cities = {\n    'Rome': {\n                'country': 'Italy',\n                'population': 2868000,\n                'fact': 'Rome is one of the oldest cities in the world, the capital of Ancient Rome. Therefore, Rome is often called the \"eternal city\".'\n            },\n    'Canberra': {\n                'country': 'Australia',\n                'population': 381448,\n                'fact': 'The design of Canberra was based on the concept of a garden city, which includes significant areas of natural vegetation, which earned for Canberra the title of \"bush capital\" (translated from the English \"forest capital\").'\n            },\n    'Toronto': {\n                'country': 'Canada',\n                'population': 2503281,\n                'fact': 'In the world of professional sports, the city is the most famous hockey team of Toronto Maple Leafs. The city holds the nickname of the \"hockey universe center\".'\n            }\n}\nfor key in cities:\n    print('{0:}:\\n\\tCountry: {1:}\\n\\tPopulation: {2:} people\\n\\tFact: {3:}'.format(key, cities[key]['country'], cities[key]['population'], cities[key]['fact']))",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "530",
    "title": "Створити словник, у кому ключами є назви команд Національної баскетбольної асоціації (NBA) у північній Америці, а значеннями - списки, на зразок, [Всього ігор, Перемог, Нічиїх, Поразок, Всього очок]. Значення списку - це цілі числа, які обираються довільно. Надрукуйте інформацію про кожну команду як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "BOSTON CELTICS 3 2 0 1 8\nNEW YORK KNICKS 10 3 3 4 19\nINDIANA PACERS 4 2 2 0 11\nMIAMI HEAT 12 2 5 5 9\nATLANTA HAWKS 5 2 2 1 10\nCHICAGO BULLS 25 10 9 6 38",
    "solution": "teams = {'BOSTON CELTICS': [3, 2, 0, 1, 8], 'NEW YORK KNICKS': [10, 3, 3, 4, 19], 'INDIANA PACERS': [4, 2, 2, 0, 11], 'MIAMI HEAT': [12, 2, 5, 5, 9], 'ATLANTA HAWKS': [5, 2, 2, 1, 10], 'CHICAGO BULLS': [25, 10, 9, 6, 38]}\nfor key in teams:\n    print(key, *teams[key])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "531",
    "title": "Дано місяць і рік для двох дат (наприклад, 12.2014 і 6.2019). Користувач вводить ще одну дату (місяць і рік). Визначити, чи належить третя дата діапазону від першої дати до другої включно. Результатом роботи програми має бути повідомлення \"YES\" або \"NO\".",
    "inpdata": "2018\n5",
    "outdata": "YES",
    "solution": "d1 = {'year': 2014, 'month': 12}\nd2 = {'year': 2019, 'month': 6}\ndu = {}\ndu['year'] = int(input())\ndu['month'] = int(input())\nif d1['year'] < du['year'] and du['year'] < d2['year']:\n    print('YES')\nelif du['year'] == d1['year']:\n    if du['month'] >= d1['month']:\n        print('YES')\n    else:\n        print('NO')\nelif du['year'] == d2['year']:\n    if du['month'] <= d2['month']:\n        print('YES')\n    else:\n        print('NO')\nelse:\n    print('NO')",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "532",
    "title": "Написати програму, в якій зберігаються дані про товари, їх кількість і ціну. При запуску програми ця інформація виводиться на екран. Далі користувачеві має пропонуватися вводити номера товарів і їх нову кількість. Введення даних має завершуватися, якщо користувач вводить обумовлений символ (наприклад, нуль). Після цього всі дані про товари повинні знову виводитися на екран. Якщо номер товару відсутній, необхідно вивести відповідне повідомлення як у вихідних даних.",
    "inpdata": "9\nproduct missing\n2\n10\n0",
    "outdata": "1 Core-i3-4330 9 4500\n2 Core i5-4670K 3 8500\n3 AMD FX-6300 6 3700\n4 Pentium G3220 8 2100\n5 Core i5-3450 5 6400\n1 Core-i3-4330 9 4500\n2 Core i5-4670K 10 8500\n3 AMD FX-6300 6 3700\n4 Pentium G3220 8 2100\n5 Core i5-3450 5 6400",
    "solution": "goods = {\n         '1': ['Core-i3-4330', 9, 4500], \n         '2': ['Core i5-4670K', 3, 8500], \n         '3': ['AMD FX-6300', 6, 3700],\n         '4': ['Pentium G3220', 8, 2100],\n         '5': ['Core i5-3450', 5, 6400]\n}\nfor i in goods:\n    print(i, goods[i][0], goods[i][1], goods[i][2])\nwhile True:\n    n = input()\n    if n != '0':\n        if n > '5':\n            print('product missing')\n        else:\n            qty = int(input())\n            goods[n][1] = qty\n    else: \n        break\nfor i in goods:\n    print(i, goods[i][0], goods[i][1], goods[i][2])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "533",
    "title": "Дано словник, в якому ключі - імена та прізвища, записані через пропуск, відомих розробників мов програмування, а значення - назви мов програмування. Надрукуйте назву мови за введеним ім’ям або прізвищем її розробника.",
    "inpdata": "Gosling\nDennis",
    "outdata": "Java\nC",
    "solution": "languages = {\n    'Dennis Ritchie': 'C',\n    'Bjarne Stroustrup': 'C++',\n    'Guido van Rossum': 'Python',\n    'James Arthur Gosling': 'Java'\n    }\nname = input()\nprint(*[v for k, v in languages.items() if name in k])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "534",
    "title": "Змоделюйте аркуш елетронної таблиці на основі словника. Створіть порожній словник для зберігання значень комірок аркушу електронної таблиці. Заповніть словник кількома значеннями: в одному рядку вводиться адреса комірки у форматі A1, де A - назва стовпця, 1 - номер рядка, і, через пропуск, значення, яке необхідно зберегти в комірці. Надрукуйте «комірки» словника з їхніми значеннями.",
    "inpdata": "A1 300\nB1 2050\nB2 Python",
    "outdata": "('A', '1') 300\n('B', '1') 2050\n('B', '2') Python",
    "solution": "sheet = {}\nfor i in range(3):\n    sell, value = input().split()\n    sheet[(sell[0], sell[1])] = value\nfor item in sheet:\n    print(item, sheet[item])",
    "chapter": "словники і множини",
    "level": "початковий"
  },
  {
    "id": "535",
    "title": "Напишіть програму для видалення дублікатів зі списку цілих чисел.",
    "inpdata": "10 5 11 2 3 5 8 9 3 4 2",
    "outdata": "2 3 4 5 8 9 10 11",
    "solution": "numbers = set([int(i) for i in input().split()])\nprint(*numbers)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "536",
    "title": "Даний список цілих чисел. Визначте кількість різних значень.",
    "inpdata": "1 3 4 5 6 5 1 9",
    "outdata": "6",
    "solution": "print(len(set(input().split())))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "537",
    "title": "Дано список словників. Кожен словники має 2 пари елементів: ключ \"name\" і значення імені студента, ключ \"points\" і значення - список балів з різних дисциплін (цілі двоцифрові числа). Надрукуйте найменші значення балів, отримані кожним студентом, в один рядок з пропуском.",
    "inpdata": "Немає",
    "outdata": "45 60 30 49",
    "solution": "students = [\n{'name':'Alex', 'points': [50, 65, 45, 78]},\n{'name':'Barbara', 'points': [68, 62, 60, 75]},\n{'name':'Jack', 'points': [30, 40, 35, 55]},\n{'name':'Dennis', 'points': [65, 72, 49, 52]}\n]\nmin_point = [min(item['points']) for item in students]\nprint(*min_point)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "538",
    "title": "Дано два списки чисел. Порахуйте, скільки унікальних цифр міститься в обох з них.",
    "inpdata": "1 6 3 5 6\n10 12 6 5 1 4",
    "outdata": "3",
    "solution": "print(len(set(input().split()) & set(input().split())))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "539",
    "title": "Дано два словники, в яких ключами є малі букви латинського алфавіту, а значеннями - цілі числа. В першому словнику можуть зустрічатися ключі чи значення, які присутні в другому словнику, або навпаки. Наприклад, вміст словників може бути наступний: a = {'x' : 1, 'y' : 2, 'z' : 3}, b = {'w' : 10, 'x' : 11, 'y' : 2}. Надрукуйте спільні ключі для обох словників в одному рядку через пропуск.",
    "inpdata": "Немає",
    "outdata": "y x",
    "solution": "a = {\n'x' : 1,\n'y' : 2,\n'z' : 3\n}\nb = {\n'w' : 10,\n'x' : 11,\n'y' : 2\n}\nprint(*(a.keys() & b.keys()))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "540",
    "title": "Дано два словники, в яких ключами є малі букви латинського алфавіту, а значеннями - цілі числа. В першому словнику можуть зустрічатися ключі чи значення, які присутні в другому словнику, або навпаки. Наприклад, вміст словників може бути наступний: a = {'x' : 1, 'y' : 2, 'z' : 3}, b = {'w' : 10, 'x' : 11, 'y' : 2}. Надрукуйте ключі, які присутні в першому словнику, але яких немає в другому, в одному рядку через пропуск.",
    "inpdata": "Немає",
    "outdata": "z",
    "solution": "a = {\n'x' : 1,\n'y' : 2,\n'z' : 3\n}\nb = {\n'w' : 10,\n'x' : 11,\n'y' : 2\n}\nprint(*(a.keys() - b.keys()))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "541",
    "title": "Дано два словники, в яких ключами є малі букви латинського алфавіту, а значеннями - цілі числа. В першому словнику можуть зустрічатися ключі чи значення, які присутні в другому словнику, або навпаки. Наприклад, вміст словників може бути наступний: a = {'x' : 1, 'y' : 2, 'z' : 3}, b = {'w' : 10, 'x' : 11, 'y' : 2}. Надрукуйте спільні пари «ключ-значення» для обох словників у форматі як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "('y', 2)",
    "solution": "a = {\n'x' : 1,\n'y' : 2,\n'z' : 3\n}\nb = {\n'w' : 10,\n'x' : 11,\n'y' : 2\n}\nprint(*(a.items() & b.items()))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "542",
    "title": "Дано три словники, в яких ключами є малі букви латинського алфавіту, а значеннями - цілі числа. Ключі у всіх словниках – різні, їх є по 3 в кожному словнику. Об’єднайте всі три словники в один і виведіть його вміст. Підказка. скористайтеся оператором \"**\", що використовується для об’єднання довільної кількості словників (Python 3.5+).",
    "inpdata": "Немає",
    "outdata": "{'x': 1, 'y': 2, 'z': 3, 'w': 10, 'f': 11, 'g': 2, 'n': 10, 'm': 11, 'e': 2}",
    "solution": "a = {'x' : 1, 'y' : 2, 'z' : 3}\nb = {'w' : 10, 'f' : 11, 'g' : 2}\nc = {'n' : 10, 'm' : 11, 'e' : 2}\nd = {**a, **b, **c}\nprint(d)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "543",
    "title": "Напишіть програму для обчислення частоти слів у введеному рядку. Виведення має бути у порядку, що зворотний буквенно-цифровому порядку.",
    "inpdata": "The five boxing wizards jump quickly",
    "outdata": "wizards: 1\nquickly: 1\njump: 1\nfive: 1\nboxing: 1\nThe: 1",
    "solution": "freq = {}   \nfor word in input().split():\n    freq[word] = freq.get(word, 0) + 1\nwords = freq.keys()\nfor w in sorted(words, reverse=True):\n    print(w + ':', freq[w])",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "544",
    "title": "Напишіть програму, яка підраховує і роздруковує кількість появ кожного символу у введеному рядку.",
    "inpdata": "abcabcdfghj",
    "outdata": "a, 2\nb, 2\nc, 2\nd, 1\nf, 1\ng, 1\nh, 1\nj, 1",
    "solution": "d = {}\nfor c in input():\n    d[c] = d.get(c, 0) + 1\nprint('\\n'.join(['{0:}, {1:}'.format(k, v) for k, v in d.items()]))\n",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "545",
    "title": "Створіть словник, який відображає ідентифікатори акцій на біржі. Ключами словника є ідентифікатори акцій, а значеннями - дійсні числа - ціни акцій. Надрукуйте ціни акцій для мінімального і максимального значення ціни відповідно та їх ідентифікатори.",
    "inpdata": "Немає",
    "outdata": "10.75 FB\n612.78 AAPL",
    "solution": "prices = {\n'ACME': 45.23,\n'AAPL': 612.78,\n'IBM': 205.55,\n'HPQ': 37.20,\n'FB': 10.75\n}\nmin_price = min(zip(prices.values(), prices.keys()))\nprint(*min_price)\nmax_price = max(zip(prices.values(), prices.keys()))\nprint(*max_price)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "546",
    "title": "Створіть словник, який відображає ідентифікатори акцій на біржі. Ключами словника є ідентифікатори акцій, а значеннями - дійсні числа - ціни акцій. Надрукуйте ціни акцій та ідентифікатори у порядку зростання ціни.",
    "inpdata": "Немає",
    "outdata": "10.75 FB\n37.2 HPQ\n45.23 ACME\n205.55 IBM\n612.78 AAPL",
    "solution": "prices = {\n'ACME': 45.23,\n'AAPL': 612.78,\n'IBM': 205.55,\n'HPQ': 37.20,\n'FB': 10.75\n}\nprices_sorted = sorted(zip(prices.values(), prices.keys()))\nfor item in prices_sorted:\n    print(item[0], item[1])",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "547",
    "title": "Створіть словник, який відображає ідентифікатори акцій на біржі. Ключами словника є ідентифікатори акцій, а значеннями - дійсні числа - ціни акцій. На основі цього словника створіть програмно словник, який містить значення цін акцій, які більше якогось введеного цілого значення n, і виведіть елементи другого словника.",
    "inpdata": "200",
    "outdata": "AAPL 612.78\nIBM 205.55",
    "solution": "prices = {\n'ACME': 45.23,\n'AAPL': 612.78,\n'IBM': 205.55,\n'HPQ': 37.20,\n'FB': 10.75\n}\nn = int(input())\nprices_other = { key:value for key, value in prices.items() if value > n }\nfor k, v in prices_other.items():\n    print(k, v)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "548",
    "title": "Створіть словник, який відображає ідентифікатори акцій на біржі. Ключами словника є ідентифікатори акцій, а значеннями - дійсні числа - ціни акцій. На основі цього словника створіть програмно словник із значеннями акцій технологічних компаній.",
    "inpdata": "Немає",
    "outdata": "AAPL 612.78\nIBM 205.55\nHPQ 37.2",
    "solution": "prices = {\n'ACME': 45.23,\n'AAPL': 612.78,\n'IBM': 205.55,\n'HPQ': 37.20,\n'FB': 10.75\n}\ntech_names = { 'AAPL', 'IBM', 'HPQ', 'MSFT' }\nprices_tech = { key:value for key,value in prices.items() if key in tech_names }\nfor k, v in prices_tech.items():\n    print(k, v)\n",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "549",
    "title": "В рядку записаний текст. Словом вважається послідовність непробільних символів, які йдуть підряд, слова розділені одним або більшим числом пропуском або символами кінця рядка. Для кожного слова з цього тексту підрахуйте, скільки разів воно зустрічалося в цьому тексті раніше.",
    "inpdata": "var list set tuple list tuple tuple dict var",
    "outdata": "0 0 0 0 1 1 2 0 1",
    "solution": "words = {}\nresult = []\nfor word in input().split():\n    if word in words:\n        words[word] += 1\n    else:\n        words.setdefault(word, 0)\n    result.append(words[word])\nprint(*result)  ",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "550",
    "title": "Напишіть програму для сортування за зростанням словника за значеннями. Словник зберігає пари ключ-значення у вигляді \"країна: столиця\". Інформація виводиться як у вихідних даних: сортування має бути проведено за назвами столиць. Примітка. При використанні метода sorted, можна застосувати як ключ лямбда-функцію на зразок key=lambda x: x[1].",
    "inpdata": "Немає",
    "outdata": "[('China', 'Beijing'), ('Denmark', 'Copenhagen'), ('Ukraine', 'Kyiv'), ('Canada', 'Ottawa'), ('France', 'Paris')]",
    "solution": "countries = {'Canada': 'Ottawa', 'Denmark': 'Copenhagen', 'China': 'Beijing', 'Ukraine': 'Kyiv', 'France': 'Paris'}\nm = sorted(countries.items(), key=lambda x: x[1])\nprint(m)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "551",
    "title": "Напишіть програму для сортування за спаданням словника за значеннями. Словник зберігає пари ключ-значення у вигляді \"країна: столиця\". Інформація виводиться як у вихідних даних: сортування має бути проведено за назвами столиць у порядку, протилежному алфавітному. Примітка. При використанні метода sorted, можна застосувати як ключ лямбда-функцію на зразок key=lambda x: x[1].",
    "inpdata": "Немає",
    "outdata": "[('France', 'Paris'), ('Canada', 'Ottawa'), ('Ukraine', 'Kyiv'), ('Denmark', 'Copenhagen'), ('China', 'Beijing')]",
    "solution": "countries = {'Canada': 'Ottawa', 'Denmark': 'Copenhagen', 'China': 'Beijing', 'Ukraine': 'Kyiv', 'France': 'Paris'}\nm = sorted(countries.items(), key=lambda x: x[1], reverse=True)\nprint(m)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "552",
    "title": "Дано словник, у якому ключами є назви 10 карпатських вершин, а значеннями - їх висота у метрах. Елементи у словнику невпорядковані. Напишіть програму для виведення висоти трьох найвищих гір. Примітка. При використанні метода sorted, можна застосувати як ключ лямбда-функцію на зразок key=lambda x: x[1].",
    "inpdata": "Немає",
    "outdata": "Hoverla: 2061 m\nBrebenescul: 2032 m\nPip Ivan Chernogirsky (Chorna gora): 2028 m",
    "solution": "carpathians = {'Breskul': 1911, 'Brebenescul': 2032, 'Turkul': 1933, 'Petros': 2020, 'Menchul': 1998, 'Hoverla': 2061, 'Pip Ivan Chernogirsky (Chorna gora)': 2028, 'Pip Ivan Marmarossky': 1936, 'Gutin Tomnatyk': 2018, 'Rebra': 2001}\ntop_mountains = list(sorted(carpathians.items(), key=lambda x: x[1], reverse=True))[:3]\nfor mountain in top_mountains:\n    print(mountain[0] + ':', mountain[1], 'm')",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "553",
    "title": "Дано словник, в якому ключами назви країн-чемпіонів світу з футболу, а значеннями - список років, в які вони ставали чемпіонами. Елементи у словнику і у списку невпорядковані. Напишіть програму для впорядкування значень років в алфавітному порядку і виведення словника.",
    "inpdata": "Немає",
    "outdata": "{'Brazil': [1958, 1962, 1970, 1994, 2002], 'England': [1966], 'Italy': [1934, 1938, 1982, 2006], 'Spain': [2010], 'Germany': [1954, 1974, 1990, 2014], 'France': [1998, 2018], 'Uruguay': [1930, 1950], 'Argentina': [1978, 1986]}",
    "solution": "champions = {'Brazil': [1958, 2002, 1970, 1962, 1994], 'England': [1966], 'Italy': [2006, 1934, 1938, 1982], 'Spain': [2010], 'Germany': [1974, 1990, 2014, 1954], 'France': [1998, 2018], 'Uruguay': [1950, 1930], 'Argentina': [1978, 1986]}\nsorted_champions = {team: sorted(values) for team, values in champions.items()}\nprint(sorted_champions)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "554",
    "title": "Дано словник, в якому ключами є ідентифікатори абітурієнтів у форматі \"S x\": літера S, пропуски, x - порядковий номер абітурієнта, а значеннями - список назв навчальних предметів, з яких абітурієнт буде здавати екзамен. Напишіть програму для друку створеного словника і словника, в якому видалені пропуски із ключів.",
    "inpdata": "Немає",
    "outdata": "{'S  001': ['Math', 'Computer Science'], 'S   002': ['Math', 'English'], 'S   003': ['Philosophy', 'English', 'Physical training']}\n{'S001': ['Math', 'Computer Science'], 'S002': ['Math', 'English'], 'S003': ['Philosophy', 'English', 'Physical training']}",
    "solution": "students = {'S  001': ['Math', 'Computer Science'], 'S   002': ['Math', 'English'], 'S   003': ['Philosophy', 'English', 'Physical training']} \nprint(students)\nresults = {}\nfor student, subject in students.items():\n    if student not in results:\n        results.setdefault(student.replace(' ', ''), subject)  \nprint(results)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "555",
    "title": "Дано словник, у якому ключами є назви фруктів, а значеннями - список значень у вигляді [Білки (г), Жири (г), Вуглеводи (г), Ккал/100 г]. Елементи у словнику невпорядковані. Напишіть програму для виведення номера елемента, ключа і значення елемента у словнику як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "1 Apricots   0.9 0 10.5 46\n2 Grape      0.4 0 17.5 69\n3 Orange     0.9 0 8.4 38\n4 Ananas     0.4 0 11.8 48\n5 Apples     0.4 0 11.3 46\n6 Pear       0.4 0 10.7 42\n7 Kiwi       0.8 0 8.1 47",
    "solution": "fruits = {'Apricots': [0.9, 0, 10.5, 46], 'Grape': [0.4, 0, 17.5, 69], 'Orange': [0.9, 0, 8.4, 38], 'Ananas': [0.4, 0, 11.8, 48], 'Apples': [0.4, 0, 11.3, 46], 'Pear': [0.4, 0, 10.7, 42], 'Kiwi': [0.8, 0, 8.1, 47]}\nfor count, (fruit, proof) in enumerate(fruits.items(), 1):\n    print(count, fruit.ljust(10), *proof)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "556",
    "title": "Дано словник, що складається з пар слів. Кожне слово є синонімом до парного йому слова. Всі слова в словнику різні. Для даного слова визначте його синонім. Програма отримує на вхід кількість пар синонімів n. Далі йде n рядків, кожен рядок містить рівно два слова-синоніми. Після цього вводиться одне слово. Програма повинна вивести синонім до даного слова.",
    "inpdata": "3\nSolar Heliac\nDay Daytime\nArrive Occur\nHeliac",
    "outdata": "Solar",
    "solution": "n = int(input())\nsynonyms = {}\nfor item in range(n):\n    key, value = input().split()\n    synonyms[key] = value\n    synonyms[value] = key\nprint(synonyms[input()])",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "557",
    "title": "У вхідному рядку записана послідовність чисел через пропуск. Для кожного числа виведіть слово \"YES\" (в окремому рядку), якщо це число раніше зустрічалося в послідовності або \"NO\", якщо не зустрічалося. Вводиться список чисел. Всі числа списку знаходяться на одному рядку. Для зберігання значень використайте словник.",
    "inpdata": "4 6 1 8 4 9 0 1",
    "outdata": "NO\nNO\nNO\nNO\nYES\nNO\nNO\nYES",
    "solution": "numbers = [int(i) for i in input().split()]\nmeetings = {}\nfor number in numbers:\n    if number in meetings:\n        print(meetings[number])\n    else:\n        meetings.setdefault(number, 'YES')\n        print('NO')",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "558",
    "title": "Вводиться кількість слів у словнику. Словник складається з пар слів. Кожне слово є синонімом іншого слова. Всі слова в словнику різні. Після введення словника вводиться ще одне слово. Знайти синонім для нього.",
    "inpdata": "3\namazing extraordinary\nbeautiful magnificent\ndelicious savory\nextraordinary",
    "outdata": "amazing",
    "solution": "n = int(input())\ni = 0\ndata = {}\nwhile i < n:\n    s = input().split()\n    if s[0] not in data:\n        data.setdefault(s[0], s[1])\n    else:\n        data[s[0]] = s[1]\n    i += 1\nword = input()\nfor k, v in data.items():\n    if v == word:\n        print(k)  \n    elif k == word:\n        print(v)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "559",
    "title": "На вхід програми подається послідовність чисел від 1 до 9, що закінчується нулем. Всього буде введено не більше 100000 чисел. Підрахуйте в цій послідовності кількість одиниць, кількість двійок, кількість трійок і т. д. і надрукуйте результат. У вихідних даних завжди має бути 9 чисел.",
    "inpdata": "1 1 4 1 5 8 6 3 5 1 0",
    "outdata": "4 0 1 1 2 1 0 1 0",
    "solution": "s = input().split()\ndata = {'1': 0, '2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0, '9': 0}\nfor i in s[:-1]:\n    data[i] += 1\nr = []\nfor d, k in data.items():\n    r.append(k)\nprint(' '.join(map(str, r)))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "560",
    "title": "Дано текст англійською мовою. Крім англійських букв, в ньому можуть зустрічатися пропуски і розділові знаки. Надрукуйте відомості про те, скільки яких букв зустрічається в цьому тексті (вивести 26 чисел). При підрахунку великі та малі літери не розрізняються.",
    "inpdata": "Hello world!",
    "outdata": "0 0 0 1 1 0 0 1 0 0 0 3 0 0 2 0 0 1 0 0 0 0 1 0 0 0",
    "solution": "s = input()\ndata = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0, 'g': 0, 'h': 0, 'i': 0, 'j': 0, 'k': 0, 'l': 0, 'm': 0, 'n': 0, 'o' :0, 'p': 0, 'q': 0, 'r': 0, 's': 0, 't': 0, 'u': 0, 'v': 0, 'w': 0, 'x': 0, 'y': 0, 'z': 0}\nfor i in s:\n    if i.isalpha():\n        el = i.lower()\n        data[el] += 1\nr = []    \nfor d, k in data.items():\n    r.append(k)\nprint(' '.join(map(str, r)))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "561",
    "title": "Потрібно написати програму, яка здійснює перетворення з однієї одиниці вимірювання довжини в інші. Повинні підтримуватись: милі (1 mile = 1609 m), ярди (1 yard = 0.9144 m), фути (1 foot = 30.48 cm), дюйми (1 inch = 2.54 cm), кілометри (1 km = 1000 m), метри (m), сантиметри (1 cm = 0.01 m), міліметри (1 mm = 0.001 m). Використовуйте саме зазначені в формулюванні завдання одиниці виміру з вказаною точністю. Вводиться один рядок з фразою такого виду: \"<number> <unit_from> in <unit_to>\". Програма має вивести дробове число в експоненційному форматі, з точністю рівно два знаки після десяткової крапки.",
    "inpdata": "15.5 foot in mile\n15.5 mile in km\n15.5 mile in inch",
    "outdata": "2.94e-03\n2.49e+01\n9.82e+05",
    "solution": "length_unit = {\n                'mile': [1609, 'm'],\n                'yard': [0.9144, 'm'],\n                'foot': [0.3048, 'm'],\n                'inch': [0.0254, 'm'],\n                'km': [1000, 'm'],\n                'm': [1, 'm'],\n                'cm': [0.01, 'm'],\n                'mm': [0.001, 'm']\n              }\nnumber_unit_from_in_unit_to = input().split(' ') \nnumber = float(number_unit_from_in_unit_to[0])\nunit_from = number_unit_from_in_unit_to[1]\nunit_to = number_unit_from_in_unit_to[3]\nresult = number * length_unit[unit_from][0] / length_unit[unit_to][0]\nprint('{0:.2e}'.format(result))",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "562",
    "title": "Напишіть програму, яка приймає послідовність чисел і визначає, чи всі числа відрізняються один від одного чи ні. Використовувати цикли не можна.",
    "inpdata": "1 4 5 0 2 4\n1 6 9 10",
    "outdata": "duplicate list\nis unique sequence",
    "solution": "numbers = [int(i) for i in input().split()]\nnumbers_set = set(numbers)\nif len(numbers) > len(numbers_set):\n    print('duplicate list')\nelse:\n    print('is unique sequence')",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "563",
    "title": "Вводиться текст в одному рядку. Для кожного слова тексту підрахуйте кількість його входжень перед ним.",
    "inpdata": "one two one two three two four three",
    "outdata": "0 0 1 1 0 2 0 1",
    "solution": "data = {}\nk = 1\ns = input().split()\nfor word in s:\n    if word not in data:\n        data.setdefault(word, k)\n    else:\n        data[word] += 1 \n    print(data[word]-1, end=' ')",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "564",
    "title": "Вводяться n рядків зі скороченими назвами країн і повними назвами міст кожної країни, після цього вводяться m рядків з назвами міст. Напишіть програму, яка для кожного міста друкує скорочену назву країну, в якій місто знаходиться.",
    "inpdata": "5\nUA Kyiv Zhytomyr Ternopil Dnipro\nJP Tokyo Osaka Kyoto\nCA Montreal Toronto Ottawa\nUSA Boston Pittsburgh Washington Seattle\nUK London Edinburgh Cardiff Belfast\n3\nSeattle\nLondon\nKyiv",
    "outdata": "USA\nUK\nUA",
    "solution": "n = int(input())\ni = 0\ndata = {}\nwhile i < n:\n    s = input().split()\n    if s[0] not in data:\n        data.setdefault(s[0], s[1:])\n    i += 1\nm = int(input())\nj = 0\nc = []\nwhile j < m:\n    c.append(input())\n    j += 1\nfor el in c:\n    for country, cities in data.items():\n        if el in cities:\n            print(country)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "565",
    "title": "У першому рядку вводиться кількість рядків, потім задаються самі рядки слів, розділених пропусками. Виведіть слово, яке у рядках зустрічається найчастіше. Якщо таких слів декілька, надрукуйте те, що розміщується вище в алфавітному порядку.",
    "inpdata": "2\napple orange banana\nbanana orange",
    "outdata": "banana",
    "solution": "n = int(input())\ni = 0\ndata = {}\nk = 1\nwhile i < n:\n    s = input().split()\n    for j in s:\n        if j not in data:\n            data.setdefault(j, k)\n        else:\n            data[j] += 1\n    i += 1\nh = 0\nres = ''\nfor el, value in sorted(data.items()):\n    if value > h:\n        res = el\n        h = value\nprint(res)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "566",
    "title": "Напишіть програму для підрахунку повторюваних символів у введеному рядку.",
    "inpdata": "the quick brown fox jumps over the lazy dog",
    "outdata": "t 2\nh 2\ne 3\n  8\nu 2\nr 2\no 4",
    "solution": "string_words = input()\nletters = {}\nfor item in string_words:\n    letters.update({item: string_words.count(item)})\nfor item in letters:\n    result = letters[item]\n    if result > 1:\n        print(item, result)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "567",
    "title": "Дано дві послідовності цілих чисел. Надрукуйте числа, які присутні в обох послідовностях.",
    "inpdata": "1 5 8 0 2 9\n8 3 6 7 1",
    "outdata": "8 1",
    "solution": "setx = set(int(i) for i in input().split())\nsety = set(int(i) for i in input().split())\nsetz = setx & sety\nprint(*setz)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "568",
    "title": "Дано дві послідовності цілих чисел. Надрукуйте нову послідовність, яка об’єднує числа, що присутні в обох послідовностях, без дублікатів.",
    "inpdata": "1 5 8 0 2 9\n8 3 6 7 1",
    "outdata": "0 1 2 3 5 6 7 8 9",
    "solution": "setx = set(int(i) for i in input().split())\nsety = set(int(i) for i in input().split())\nsetz = setx | sety\nprint(*setz)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "569",
    "title": "Дано список значень різних типів даних. Створіть словник із значеннями списку як ключами, і назвами відповідного типу даних як значеннями словника. У словнику можуть бути присутні дані одного типу. Надрукуйте вміст словника як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "<class 'int'> 1952 1000000\n<class 'float'> 10.45 5.5\n<class 'complex'> (2+3j)\n<class 'bool'> False\n<class 'str'> pythonguide.pp.ua\n<class 'tuple'> (1, -6)\n<class 'list'> [3, 15]\n<class 'dict'> {'Class C': ['Volkswagen Golf', 'Ford Focus'], 'Class F': ['Audi A8', 'Bentley', 'Maybach'], 'E': ['Toyota Camry']} {}\n<class 'NoneType'> None",
    "solution": "datatypes = {}\ndata = [1952, 10.45, 5.5, 2+3j, False, 'pythonguide.pp.ua', (1, -6), [3, 15], {'Class C': ['Volkswagen Golf', 'Ford Focus'], 'Class F': ['Audi A8', 'Bentley', 'Maybach'], 'E': ['Toyota Camry']}, None, {}, 1000000]\nfor item in data:\n    t = type(item)\n    if t not in datatypes:\n        datatypes.setdefault(t, [item])\n    else:\n        datatypes[t] += [item]\nfor t, item in datatypes.items():\n    print(t, *item)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "570",
    "title": "Дано послідовність цілих чисел. Для кожного числа надрукуйте слово \"YES\" (в окремому рядку), якщо це число вже зустрічалось в послідовності, і надрукуйте \"NO\", якщо воно ще не було виявлено. Для зберігання значень використайте множину",
    "inpdata": "1 4 5 2 10 15 4 10 3",
    "outdata": "NO\nNO\nNO\nNO\nNO\nNO\nYES\nYES\nNO",
    "solution": "numbers = [int(i) for i in input().split()]\noccur_before = set()\nfor num in numbers:\n    if num in occur_before:\n        print('YES')\n    else:\n        print('NO')\n        occur_before.add(num)",
    "chapter": "словники і множини",
    "level": "середній"
  },
  {
    "id": "571",
    "title": "Напишіть програму, яка зможе підрахувати слова у введеному рядку, розділені пропуском і вивести отриману статистику: для кожного унікального слова обчислити число його повторень (без урахування регістру), слова не повинні повторюватися, порядок слів довільний.",
    "inpdata": "a bb acD bb abc ac BCD a",
    "outdata": "a 2\nbb 2\nacd 1\nabc 1\nac 1\nbcd 1",
    "solution": "s = input().lower().split()\nresult = {}\nfor item in s:\n    if item not in result:\n        result.setdefault(item, 1)\n    else:\n        result[item] += 1\nfor item in result:\n    print(item, result[item])",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "572",
    "title": "Напишіть програму, яка приймає на вхід список ігор футбольних команд з результатом матчу і виводить зведену таблицю результатів всіх матчів. За перемогу команді нараховується 3 очки, за поразку - 0, за нічию - 1. Формат введення наступний: у першому рядку вказано ціле число n - кількість завершених ігор. Після цього йде n рядків, в яких записані результати гри в наступному форматі: \"1_команда;забито_1_командою;2_команда;забито_2_командою\". Результати виведення програми необхідно оформити наступним чином:\n\"Команда: Всього_ігор Перемог Нічиїх Поразок Всього_очок\". Конкретний приклад введення-виведення наведено у вхідних і вихідних даних. Порядок виведення команд довільний.",
    "inpdata": "4\nUkraine;2;France;1\nItaly;1;Germany;3\nFrance;0;Italy;0\nGermany;2;Ukraine;0",
    "outdata": "Ukraine: 2 1 0 1 3\nFrance: 2 0 1 1 1\nItaly: 2 0 1 1 1\nGermany: 2 2 0 0 6",
    "solution": "soccer = {}\nfor i in range(int(input())):\n    first_team, p_first_team, second_team, p_second_team = input().strip().split(';')\n    for team in (first_team, second_team):\n        if team not in soccer:\n            soccer[team] = [0, 0, 0, 0, 0]\n    if p_first_team > p_second_team:\n        soccer[first_team][0] += 1 \n        soccer[first_team][1] += 1\n        soccer[first_team][4] += 3\n        soccer[second_team][0] += 1\n        soccer[second_team][3] += 1\n        soccer[second_team][4] += 0\n    elif p_first_team < p_second_team:\n        soccer[first_team][0] += 1 \n        soccer[first_team][3] += 1\n        soccer[first_team][4] += 0\n        soccer[second_team][0] += 1\n        soccer[second_team][1] += 1\n        soccer[second_team][4] += 3\n    elif p_first_team == p_second_team:\n        soccer[first_team][0] += 1 \n        soccer[first_team][2] += 1\n        soccer[first_team][4] += 1  \n        soccer[second_team][0] += 1\n        soccer[second_team][2] += 1\n        soccer[second_team][4] += 1\nfor item in soccer:\n    print(item + ':', *soccer[item])",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "573",
    "title": "Дано два списки чисел. Знайдіть всі числа, що зустрічаються як в першому, так і другому списках, і надрукуйте їх у порядку зростання.",
    "inpdata": "2 5 8 11 10 9\n11 3 7 6 8 5",
    "outdata": "5 8 11",
    "solution": "print(*sorted(set(input().split()) & set(input().split()), key=int))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "574",
    "title": "Напишіть програму, яка вміє шифрувати і розшифровувати використовуючи шифр підстановки. Програма приймає на вхід два рядки однакової довжини, у першому рядку записані символи початкового алфавіту, у другому рядку - символи кінцевого алфавіту (шифр підстановки), після чого йде рядок, який потрібно зашифрувати переданим шифром підстановки, і ще один рядок, який потрібно розшифрувати. Нехай, наприклад, на вхід програми передано в окремих рядках: \"abcd\", \"*d%#\", \"abacabadaba\", \"#*%*d*%\". Це означає, що символ \"a\" вхідного повідомлення замінюється на символ \"*\" в шифрі, \"b\" замінюється на \"d\", \"c\" - на \"%\" і \"d\" - на \"#\". Потрібно зашифрувати рядок \"abacabadaba\" і розшифрувати рядок \"#*%*d*%\" за допомогою цього шифру. Отримуємо наступні рядки, які і передаємо на виведення програми: \"*d*%*d*#*d*\", \"dacabac\".",
    "inpdata": "abcd\n1234\nababcdcd\n44332211",
    "outdata": "12123434\nddccbbaa",
    "solution": "alphabet = input()\nkey = input()\ncypher = input()\ndecrypt = input()\nsymbols = {}\nresult_cypher = ''\nresult_decrypt = ''\nsymbols = {alphabet[i]: key[i] for i in range(len(alphabet))}\nfor item in cypher:\n    if item in symbols:\n        result_cypher += symbols[item]\nprint(result_cypher.strip())\nfor item in decrypt:\n    for key in symbols.items():\n        if key[1] == item:\n            result_decrypt += key[0]\nprint(result_decrypt.strip())",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "575",
    "title": "Дано ціле число n, за яким слідують n рядків тексту. Надрукуйте кількість різних слів, які з’являються у тексті. Для цього ми визначаємо, що слово - це послідовність символів, що не містить пропусків. Слова розділені одним або декількома пропусками або символами нового рядка. Знаки пунктуації є частиною слова в цьому визначенні.",
    "inpdata": "3\nA fool is a person who thinks he's smarter than me.\nYet wolves are more noble sheep, it is difficult for them to imagine their life without the latter. And the sheep?! It's shame to say!\nOnly when he left the chariot, everyone understood that it was a coachman.",
    "outdata": "43",
    "solution": "words = set()\nfor i in range(int(input())):\n    words.update(input().split())\nprint(len(words))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "576",
    "title": "Дано список цілих чисел, який може містити до 100000 чисел. Визначте, скільки в ньому зустрічається різних чисел.",
    "inpdata": "2 5 7 7 9 0 3 4\n3 3 4 4 5 1",
    "outdata": "7\n4",
    "solution": "numbers = len(set([int(i) for i in input().split()]))\nprint(numbers)",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "577",
    "title": "Дано послідовність слів, розділених комами. Надрукуйте унікальні слова у лексикографічному порядку як у вихідних даних.",
    "inpdata": "abc,abc,bac,aca",
    "outdata": "abc,aca,bac",
    "solution": "items = input()\nwords = [word for word in items.split(',')]\nprint(','.join(sorted(list(set(words)))))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "578",
    "title": "Напишіть програму для пошуку загальних елементів з двох введених рядків слів.",
    "inpdata": "Red Green Orange White\nBlack Green White Pink",
    "outdata": "White Green",
    "solution": "words1= [i for i in input().split()]\nwords2 = [i for i in input().split()]\nprint(*(set(words1) & set(words2)))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "579",
    "title": "Напишіть програму для пошуку загальних елементів з двох введених рядків слів.",
    "inpdata": "Немає",
    "outdata": "('jacket', 2200.56)\n('boots', 1179.99)\n('trousers', 843.38)",
    "solution": "shops = {'jacket': 2200.56, 'cap': 235.75, 'trousers': 843.38, 'boots': 1179.99, 'socks': 11.25}\nresults = []\nfor k in sorted(shops, key=shops.get, reverse=True):\n    results += [(k, shops[k])]\nprint('\\n'.join(map(str, results[:3])))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "580",
    "title": "Дано дві послідовності цілих чисел. Необхідно надрукувати обидві послідовності з числами, які відсутні в іншій послідовності.",
    "inpdata": "1 3 4 5 8 9 12\n3 4 7 8 12",
    "outdata": "1 5 9\n7",
    "solution": "n1 = set([int(i) for i in input().split()])\nn2 = set([int(i) for i in input().split()])\nprint(*n1.difference(n2))\nprint(*n2.difference(n1))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "581",
    "title": "Дано рядок тексту, в якому слова розділені пррпусками. Надрукуйте всі слова, які зустрічаються в тексті, та їхні частоти як у вихідних даних.",
    "inpdata": "one two three one four five seven ten seven one",
    "outdata": "('one', 3) ('four', 1) ('seven', 2) ('ten', 1) ('three', 1) ('two', 1) ('five', 1)",
    "solution": "string_words = input()\nword_list = string_words.split()\nword_freq = [word_list.count(n) for n in word_list]\nprint(*set(zip(word_list, word_freq)))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "582",
    "title": "Дано два списки чисел, які можуть містити до 100000 чисел кожен. Порахуйте, скільки чисел міститься одночасно як в першому списку, так і в другому списках. Вводяться два списки цілих чисел. Всі числа кожного списку знаходяться на окремому рядку.",
    "inpdata": "3 5 8\n5 2 3",
    "outdata": "2",
    "solution": "numbers1 = [int(i) for i in input().split()]\nnumbers2 = [int(i) for i in input().split()]\nprint(len(set(numbers1) & set(numbers2)))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "583",
    "title": "Дано два списки чисел, які можуть містити до 10000 чисел кожен. Виведіть всі числа, які входять як в перший, так і в другий список в порядку зростання. Вводяться два списки цілих чисел. Всі числа кожного списку знаходяться на окремому рядку.",
    "inpdata": "4 6 8 9\n1 9 3 6",
    "outdata": "6 9",
    "solution": "numbers1 = [int(i) for i in input().split()]\nnumbers2 = [int(i) for i in input().split()]\nprint(*sorted(set(numbers1) & set(numbers2), key=int))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "584",
    "title": "Напишіть програму, яка приймає на вхід список цілих чисел, розділених пропуском, і виводить на екран значення, які повторюються в ньому більш ніж один раз. При виведенні числа не повинні повторюватися, порядок виведення може бути довільним.",
    "inpdata": "4 6 10 14 6 9 10 11",
    "outdata": "6 10",
    "solution": "result = {}\ns = input().split()\nfor item in s:\n    if item not in result:\n        result.setdefault(item, 1)\n    else:\n        result[item] += 1\nfor item in result:\n    if result[item] > 1:\n        print(item, end=' ')",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "585",
    "title": "Дано рядок слів, розділених пропусками. Надрукуйте довжину найдовшого слова.",
    "inpdata": "aaa aaaaa aa a aaaaa",
    "outdata": "5",
    "solution": "string_words = input().split()\nwords = {}\nfor word in string_words:\n    if word not in words:\n        words.setdefault(word, len(word))\nprint(sorted(words.items(), key=lambda x: x[1])[-1][1])",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "586",
    "title": "Дано список країн і міст кожної країни. Потім подані назви міст. Для кожного міста вкажіть, в якій країні воно знаходиться. Програма отримує на вхід кількість країн n. Далі йде n рядків, кожен рядок починається з назви країни, потім йдуть назви міст цієї країни. У наступному рядку записано число m, далі йдуть m запитів - назви якихось m міст, перерахованих вище. Для кожного із запиту виведіть назву країни, в якій знаходиться дане місто.",
    "inpdata": "2\nUkraine Kyiv Kharkiv Lviv\nEngland London Liverpool Manchester Bristol\n3\nKyiv\nLondon\nLviv",
    "outdata": "Ukraine\nEngland\nUkraine",
    "solution": "n = int(input())        \ncountries = {}\nfor i in range(n):\n    country, *cities = input().split()\n    for city in cities:\n        countries[city] = country        \nm = int(input())\nfor i in range(m):\n    print(countries[input()])",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "587",
    "title": "Користувачем вводяться наступні дані: у першому рядку міститься кількість рядків n, а потім - вводяться n рядків слів. Надрукуйте слово, яке в тексті зустрічається найчастіше. Якщо таких слів є декілька, надрукуйте слово, яке в алфавітному порядку розташоване раніше.",
    "inpdata": "3\neditor detective baker scientist\nsinger teacher\nteacher scientist",
    "outdata": "scientist",
    "solution": "c = {}\nfor i in range(int(input())):\n    line = input().split()\n    for word in line:\n        c[word] = c.get(word, 0) + 1\nmax_count = max(c.values())\nmost_frequent = [k for k, v in c.items() if v == max_count]\nprint(min(most_frequent))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "588",
    "title": "Напишіть програму, яка виводить число в стилі LCD-калькулятора. На вхід програми подається послідовність цифр, яку потрібно вивести на екран в спеціальному стилі. Розмір всіх цифр 4 символу в ширину і 7 символів у висоту. Між цифрами повинен бути один порожній стовпець. Перед першою цифрою не повинно бути пропусків. Виведені цифри повинні бути обведені рамочкою, в кутах якої знаходиться символ \"x\", горизонтальна лінія створюється з символу \"-\", а вертикальна - з символу вертикальної риски \"|\". Користувач вводить рядок - послідовність цифр, а програма має вивести 9 рядків, що містять цифри, записані в зазначеному форматі.",
    "inpdata": "0123456789\n123\n4",
    "outdata": "x--------------------------------------------------x\n| --        --   --        --   --   --   --   --  |\n||  |    |    |    | |  | |    |       | |  | |  | |\n||  |    |    |    | |  | |    |       | |  | |  | |\n|           --   --   --   --   --        --   --  |\n||  |    | |       |    |    | |  |    | |  |    | |\n||  |    | |       |    |    | |  |    | |  |    | |\n| --        --   --        --   --        --   --  |\nx--------------------------------------------------x\nx---------------x\n|      --   --  |\n|   |    |    | |\n|   |    |    | |\n|      --   --  |\n|   | |       | |\n|   | |       | |\n|      --   --  |\nx---------------x\nx-----x\n|     |\n||  | |\n||  | |\n| --  |\n|   | |\n|   | |\n|     |\nx-----x",
    "solution": "a1 = ' -- '\na2 = '|  |'\na3 = '    '\na4 = '   |'\na5 = '|   '\nlcd = { '0': [a1, a2, a2, a3, a2, a2, a1],\n        '1': [a3, a4, a4, a3, a4, a4, a3],\n        '2': [a1, a4, a4, a1, a5, a5, a1],\n        '3': [a1, a4, a4, a1, a4, a4, a1],\n        '4': [a3, a2, a2, a1, a4, a4, a3],\n        '5': [a1, a5, a5, a1, a4, a4, a1],\n        '6': [a1, a5, a5, a1, a2, a2, a1],\n        '7': [a1, a4, a4, a3, a4, a4, a3],\n        '8': [a1, a2, a2, a1, a2, a2, a1],\n        '9': [a1, a2, a2, a1, a4, a4, a1]\n      }\nnumbers = input()\nprint('x' + '-'*4*len(numbers)+'-'*(len(numbers)) + 'x')     \nfor i in range(7):  \n        print('|', end='')\n        for item in numbers:    \n            val = lcd.get(item)\n            print(val[i] + ' ', end='')\n        print('|')\nprint('x' + '-'*4*len(numbers)+'-'*(len(numbers)) + 'x')",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "589",
    "title": "Комп’ютерний вірус атакував файлову систему суперкомп’ютера і пошкодив контроль прав доступу до файлів. Для кожного файлу є відомий набір операцій, які можуть бути застосовані до нього: писати (W), читати (R), виконати (X). Перший рядок містить число n - кількість файлів, що містяться у файловій системі. Наступні n рядків містять імена файлів і дозволені операції з ними, розділені пропусками. Наступний рядок містить ціле число m - кількість операцій з файлами. В наступних m рядках записані операції, які виконуються над файлами. До одного файлу можна звертатися багато разів. Для кожного запиту програма повинна надрукувати \"OK\", якщо запитана операція з файлом є можливою, або \"Access denied\", якщо операцію виконати неможливо.",
    "inpdata": "4\nhelloworld.py R X\npinglog W R\nscripts R\ngoodluck X W R\n5\nread scripts\nwrite helloworld.py\nexecute scripts\nread pinglog\nwrite pinglog",
    "outdata": "OK\nAccess denied\nAccess denied\nOK\nOK",
    "solution": "n = int(input())\ndata = {}\nfor i in range(n):\n    name_file, *name_rwx = input().split()\n    if name_file not in data:\n        data.setdefault(name_file, name_rwx)\nm = int(input())\nrwx = {'read': 'R', 'write': 'W', 'execute': 'X'}\nfor j in range(m):\n    action, name_file = input().split()\n    if name_file in data:\n        if rwx[action] in data[name_file]:\n            print('OK')\n        else:\n            print('Access denied')",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "590",
    "title": "На шаховій дошці стоїть кінь. Відзначте положення коня на дошці і всі клітинки, які б’є кінь. Клітинку, де стоїть кінь, відзначте буквою \"K\", клітинки, які б’є кінь, відзначте символами \"*\", решта клітинок заповніть крапками. Програма отримує на вхід координати коня на шаховій дошці в шаховій нотації, тобто, у вигляді \"e2\", де спочатку записується номер стовпця (буква від \"a\" до \"h\", зліва направо), потім номер рядка (цифра від 1 до 8, знизу догори). Виведіть на екран зображення шахової дошки як у вихідних даних.",
    "inpdata": "e4",
    "outdata": ". . . . . . . .\n. . . . . . . .\n. . . * . * . .\n. . * . . . * .\n. . . . K . . .\n. . * . . . * .\n. . . * . * . .\n. . . . . . . .",
    "solution": "cols = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}\ncoords = input()\ny, x = cols[coords[0]], 8-int(coords[1])\nchessboard = [['.' for j in range(8)] for i in range(8)]\nchessboard[x][y] = 'K'\nfor i in range(8):\n    for j in range(8):\n        dx = abs(i - x)\n        dy = abs(j - y)\n        if dx == 1 and dy == 2 or dx == 2 and dy == 1:\n            chessboard[i][j] = '*'\nfor i in range(8):\n    print(' '.join(chessboard[i]))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "591",
    "title": "На шаховій дошці стоїть ферзь. Відзначте положення ферзя на дошці і всі клітинки, які б’є ферзь. Клітинку, де стоїть ферзь, відзначте буквою \"Q\", клітинки, які б’є ферзь, відзначте символами \"*\", решта клітинок заповніть крапками. Програма отримує на вхід координати ферзя на шаховій дошці в шаховій нотації, тобто, у вигляді \"e2\", де спочатку записується номер стовпця (буква від \"a\" до \"h\", зліва направо), потім номер рядка (цифра від 1 до 8, знизу догори). Виведіть на екран зображення шахової дошки як у вихідних даних.",
    "inpdata": "f3",
    "outdata": "* . . . . * . .\n. * . . . * . .\n. . * . . * . .\n. . . * . * . *\n. . . . * * * .\n* * * * * Q * *\n. . . . * * * .\n. . . * . * . *",
    "solution": "cols = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}\ncoords = input()\ny, x = cols[coords[0]], 8-int(coords[1])\nchessboard = [['.' for j in range(8)] for i in range(8)]\nfor i in range(8):\n    for j in range(8):\n        dx = abs(i - x)\n        dy = abs(j - y)\n        if dx == dy or i == x or j == y:\n            chessboard[i][j] = '*'\nchessboard[x][y] = 'Q'\nfor i in range(8):\n    print(' '.join(chessboard[i]))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "592",
    "title": "На шаховій дошці стоїть слон. Відзначте положення слона на дошці і всі клітинки, які б’є слон. Клітинку, де стоїть слон, відзначте буквою \"B\", клітинки, які б’є слон, відзначте символами \"*\", решта клітинок заповніть крапками. Програма отримує на вхід координати слона на шаховій дошці в шаховій нотації, тобто, у вигляді \"e2\", де спочатку записується номер стовпця (буква від \"a\" до \"h\", зліва направо), потім номер рядка (цифра від 1 до 8, знизу догори). Виведіть на екран зображення шахової дошки як у вихідних даних.",
    "inpdata": "g4",
    "outdata": ". . * . . . . .\n. . . * . . . .\n. . . . * . . .\n. . . . . * . *\n. . . . . . B .\n. . . . . * . *\n. . . . * . . .\n. . . * . . . .",
    "solution": "cols = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}\ncoords = input()\ny, x = cols[coords[0]], 8-int(coords[1])\nchessboard = [['.' for j in range(8)] for i in range(8)]\nfor i in range(8):\n    for j in range(8):\n        dx = abs(i - x)\n        dy = abs(j - y)\n        if dx == dy:\n            chessboard[i][j] = '*'\nchessboard[x][y] = 'B'\nfor i in range(8):\n    print(' '.join(chessboard[i]))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "593",
    "title": "На шаховій дошці стоїть тура. Відзначте положення тури на дошці і всі клітинки, які б’є тура. Клітинку, де стоїть тура, відзначте буквою \"R\", клітинки, які б’є тура, відзначте символами \"*\", решта клітинок заповніть крапками. Програма отримує на вхід координати тури на шаховій дошці в шаховій нотації, тобто, у вигляді \"e2\", де спочатку записується номер стовпця (буква від \"a\" до \"h\", зліва направо), потім номер рядка (цифра від 1 до 8, знизу догори). Виведіть на екран зображення шахової дошки як у вихідних даних.",
    "inpdata": "h5",
    "outdata": ". . . . . . . *\n. . . . . . . *\n. . . . . . . *\n* * * * * * * R\n. . . . . . . *\n. . . . . . . *\n. . . . . . . *\n. . . . . . . *",
    "solution": "cols = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}\ncoords = input()\ny, x = cols[coords[0]], 8-int(coords[1])\nchessboard = [['.' for j in range(8)] for i in range(8)]\nfor i in range(8):\n    for j in range(8):\n        if i == x or j == y:\n            chessboard[i][j] = '*'\nchessboard[x][y] = 'R'\nfor i in range(8):\n    print(' '.join(chessboard[i]))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "594",
    "title": "На шаховій дошці стоїть король. Відзначте положення короля на дошці і всі клітинки, які б’є король. Клітинку, де стоїть король, відзначте буквою \"K\", клітинки, які б’є король, відзначте символами \"*\", решта клітинок заповніть крапками. Програма отримує на вхід координати короля на шаховій дошці в шаховій нотації, тобто, у вигляді \"e2\", де спочатку записується номер стовпця (буква від \"a\" до \"h\", зліва направо), потім номер рядка (цифра від 1 до 8, знизу догори). Виведіть на екран зображення шахової дошки як у вихідних даних.",
    "inpdata": "c5",
    "outdata": ". . . . . . . .\n. . . . . . . .\n. * * * . . . .\n. * K * . . . .\n. * * * . . . .\n. . . . . . . .\n. . . . . . . .\n. . . . . . . .",
    "solution": "cols = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}\ncoords = input()\ny, x = cols[coords[0]], 8-int(coords[1])\nchessboard = [['.' for j in range(8)] for i in range(8)]\nfor i in range(8):\n    for j in range(8):\n        dx = abs(i - x)\n        dy = abs(j - y)\n        if dx <= 1 and dy <= 1:\n            chessboard[i][j] = '*'\nchessboard[x][y] = 'K'\nfor i in range(8):\n    print(' '.join(chessboard[i]))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "595",
    "title": "Програма отримує на вхід координати певної клітинки на шаховій дошці в шаховій нотації, тобто, у вигляді \"e2\", де спочатку записується номер стовпця (буква від \"a\" до \"h\", зліва направо), потім номер рядка (цифра від 1 до 8, знизу догори). Виведіть на екран зображення шахової дошки, в якому вказаний колір клітинки: \"B\" (чорний колір) або \"W\" (білий колір).",
    "inpdata": "b6",
    "outdata": ". . . . . . . .\n. . . . . . . .\n. B . . . . . .\n. . . . . . . .\n. . . . . . . .\n. . . . . . . .\n. . . . . . . .\n. . . . . . . .",
    "solution": "cols = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}\ncoords = input()\ny, x = cols[coords[0]], 8-int(coords[1])\nchessboard = [['.' for j in range(8)] for i in range(8)]\nif (x + y) % 2 == 0:\n    chessboard[x][y] = 'W'\nelse:\n    chessboard[x][y] = 'B'\nfor i in range(8):\n    print(' '.join(chessboard[i]))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "596",
    "title": "Двоє друзів вирішили здійснити влітку сходження в гори Карпати. Кожен з них зібрав свій рюкзак речей. Перевірте, які речі присутні в обох рюкзаках друзів, які є лише в першому рюкзаку, але не має в другому і, навпаки, є в другому і відсутні в першому. Дано два словники, у яких ключами є назви речей, а значеннями - кількості речей. Надрукуйте назви речей і їх кількості, які пристутні в обох рюкзаках друзів, лише в першому рюкзаку і лише в другому рюкзаку.",
    "inpdata": "Немає",
    "outdata": "In both:\nfirst aid kit 1\nlighter 2\nsunglasses 1\ntrousers 2\nhygienic set 1\nflashlight 1\nfootwear 2\nsocks 3\nsleeping bag 1\n\nOnly in the first:\nwater jacket 1\ncap 1\ndishes 2\nwoolen gloves 1\ntent 1\n\nOnly in the other:\nbatteries 4\nponcho 1\nt-shirts 3",
    "solution": "backpack1 = {'sleeping bag': 1, 'tent': 1, 'footwear': 2, 'socks': 3, 'trousers': 2, 'water jacket': 1, 'woolen gloves': 1, 'cap': 1, 'sunglasses': 1, 'flashlight': 1, 'hygienic set': 1, 'dishes': 2, 'first aid kit': 1, 'lighter': 2} \nbackpack2 = {'sleeping bag': 1, 'footwear': 2, 'socks': 3, 'trousers': 2, 'poncho': 1, 't-shirts': 3, 'sunglasses': 1, 'flashlight': 1, 'batteries': 4, 'hygienic set': 1, 'first aid kit': 1, 'lighter': 2} \nprint('In both:')\nfor (key, value) in set(backpack1.items()) & set(backpack2.items()):\n    print(key, value)\nprint('\\nOnly in the first:')\nfor (key, value) in set(backpack1.items()) - set(backpack2.items()):\n    print(key, value)\nprint('\\nOnly in the other:')\nfor (key, value) in set(backpack2.items()) - set(backpack1.items()):\n    print(key, value)",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "597",
    "title": "У римській системі числення для позначення чисел використовуються наступні символи (праворуч записані числа, яким вони відповідають в десятковій системі числення): I = 1, V = 5, X = 10, L = 50, C = 100, D = 500, M = 1000. Будемо використовувати варіант, в якому числа 4, 9, 40, 90, 400 і 900 записуються як віднімання від більшого числа меншого: IV, IX, XL, XC, CD і CM, відповідно. Напишіть програму, яка за введеним натуральним числом n (0 < n < 4000) виведе рядок, що містить число, закодоване в римській системі числення.",
    "inpdata": "2022\n11\n1",
    "outdata": "MMXXII\nXI\nI",
    "solution": "number = int(input())\nnumerals = {1:'I', 4:'IV', 5:'V', 9:'IX', 10:'X', 40:'XL', 50:'L',\n       90:'XC', 100:'C', 400:'CD', 500:'D', 900:'CM', 1000:'M'}\nresult = ''\nfor value, numeral in sorted(numerals.items(), reverse=True):\n    while number >= value:\n        result += numeral\n        number -= value\nprint(result)",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "598",
    "title": "На вхід програми подається рядок, що містить слова, розділені пропуском. Програма повинна вивести статистику довжин слів в отриманому рядку, від меншої довжини слова до більшої. Словом вважається послідовність довільних символів, оточена пропусками або межами рядка. Зауважте, що розділові знаки також відносяться до слова. Користувач вводить один рядок, що містить послідовності англійських символів і знаків пунктуації, розділені пропуском. Для кожної довжини слова, що зустрічається в заданому рядку, потрібно вказати кількість слів з такою довжиною у форматі \"довжина: кількість\". Статистика повинна виводитися в порядку збільшення довжини.",
    "inpdata": "Errors should never pass silently.",
    "outdata": "4: 1\n5: 1\n6: 2\n9: 1",
    "solution": "text = input() \npopulation = {}\npos_start = 0\npos_finish = 0\ni = 0\nfor i in range(0, len(text)):\n    if text[i] == ' ' or i + 1 == len(text):\n        pos_finish = i\n        if i + 1 == len(text): \n            pos_finish = i + 1\n        tl = len(text[pos_start:pos_finish])\n        if tl not in population:\n            population.setdefault(tl, 1)\n        else:\n            population[tl] += 1\n        pos_start = i + 1\nfor i in sorted(population): \n    print('{0}: {1}'.format(i, population[i]))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "599",
    "title": "На вхід програми подається рядок, який містить одне ціле число n - кількість англійських слів у англійсько-латинському словнику, за якими йдуть n перекладів цих слів. Кожен запис міститься в окремому рядку, що містить перше англійське слово, потім дефіс, оточений пропусками, а потім розділений комами список з перекладами цього англійського слова на латинській мові. Всі слова складаються лише з англійських літер. Переклади сортуються в лексикографічному порядку. Порядок англійських слів у словнику також лексикографічний. Надрукуйте відповідний латинсько-англійський словник у тому ж форматі (кількість слів та їхні переклади). Зокрема, першим у рядку слів має бути лексикографічно мінімальний переклад латинського слова, потім другого в цьому порядку і т. д. Англійські слова в кожному рядку також слід сортувати лексикографічно.",
    "inpdata": "3\napple - malum, pomum, popula\nfruit - baca, bacca, popum\npunishment - malum, multa",
    "outdata": "7\nbaca - fruit\nbacca - fruit\nmalum - apple, punishment\nmulta - punishment\npomum - apple\npopula - apple\npopum - fruit",
    "solution": "n = int(input())\nel = ''\ndata = {}\nk = 0\nfor i in range(n):\n    s = input().split()\n    for j in range(2, len(s)):\n        el = s[j].strip(',')\n        if el not in data:\n            data.setdefault(el, [s[0]])\n            k += 1\n        else:\n            data[el].append(s[0])\nprint(k)\nfor key in sorted(data):\n    print(key, '- ', end='')\n    if type(data[key]) == list:\n        for item in data[key]:\n            if item == data[key][-1]:\n                print(item.strip(', '))\n            else:\n                print(item, end=', ')\n    else:\n        print(data[key])",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "600",
    "title": "Дано текст в рядку. Виведіть слово, яке в цьому тексті зустрічається найчастіше. Якщо таких слів кілька, виведіть те, яке менше в лексикографічному порядку.",
    "inpdata": "Tokyo Seoul London Sofia Tokyo Sydney London",
    "outdata": "London",
    "solution": "line = input().split()\nwords = {}\nfor word in line:\n    if word in words:\n        words[word] += 1\n    else:\n        words.setdefault(word, 1)\nprint(max(sorted(words.items(), key=lambda x: x[0]), key=lambda k: k[1])[0])",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "601",
    "title": "Кожен з n школярів деякої школи знає m мов. Визначте, які мови знають всі школярі і мови, які знає хоча б один з школярів. Перший рядок вхідних даних містить кількість школярів n. Далі йде n чисел m, після кожного з чисел йде m рядків, що містять назви мов, які знає i-й школяр. Довжина назв мов не перевищує 1000 символів, кількість різних мов не більше 1000 (1 ≤ n ≤ 1000, 1 ≤ m ≤ 500). У першому рядку виведіть кількість мов, які знають усі школярі. Починаючи з другого рядка - список таких мов. Потім - кількість мов, які знає хоча б один школяр, на наступних рядках - список таких мов.",
    "inpdata": "3\n3\nUkrainian\nEnglish\nPolish\n2\nUkrainian\nEnglish\n1\nEnglish",
    "outdata": "1\nEnglish\n3\nEnglish\nPolish\nUkrainian",
    "solution": "students = [{input() for j in range(int(input()))} for i in range(int(input()))]\neveryone, someone = set.intersection(*students), set.union(*students)\nprint(len(everyone), *sorted(everyone), sep='\\n')\nprint(len(someone), *sorted(someone), sep='\\n')",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "602",
    "title": "Напишіть програму, яка для двох послідовностей, що складаються з натуральних чисел, що не перевершують n, буде визначати, які числа зустрічаються в кожній з послідовностей, а які з чисел від 1 до n - в жодній з них. Спочатку на вхід програмі подається число n (1 ≤ n ≤ 255). У другому рядку вхідних даних знаходяться елементи першої послідовності, у третьому рядку - елементи другої послідовності. Виведіть у першому рядку в порядку зростання без повторень числа, які зустрічаються в кожній з послідовностей, а у другому рядку - в порядку зростання числа від 1 до 255, які не зустрічаються в жодній з них.",
    "inpdata": "7\n3 2 4 5 2\n2 7 4 3 4 2",
    "outdata": "2 3 4\n1 6",
    "solution": "n = int(input())\nbasic = set([i for i in range(1, n + 1)])\nn1 = set([int(i) for i in input().split()])\nn2 = set([int(i) for i in input().split()])\nprint(*sorted(n1 & n2))\nn1.update(n2)\nprint(*sorted(basic - n1))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "603",
    "title": "Вчителька задала Оленці домашнє завдання - в заданому тексті розставити наголоси в словах, після чого доручила Сашку перевірити це домашнє завдання. Сашко дуже погано знайомий з цією темою, тому він знайшов словник, в якому зазначено, як ставляться наголоси в словах. На жаль, в цьому словнику присутні не всі слова. Сашко вирішив, що в словах, яких немає в словнику, він буде вважати, що Оленка поставила наголоси правильно, якщо в цьому слові Оленкою поставлений рівно один наголос. Виявилося, що в деяких словах наголос може бути поставлений більше, ніж одним способом. Сашко вирішив, що в цьому випадку якщо те, як Оленка поставила наголос, відповідає одному з наведених в словнику варіантів, він буде зараховувати це як правильне розставлення наголосів, а якщо не відповідає, то як помилку. Дано словник, яким користувався Сашко і домашнє завдання, здане Оленкою. Ваше завдання - визначити кількість помилок, яку в цьому завданні нарахує Сашко. Вводиться спочатку число n - кількість слів у словнику (0 ≤ n ≤ 20000). Далі йде n рядків зі словами із словника. Кожне слово складається не більше ніж з 30 символів. Всі слова складаються з маленьких і великих латинських букв. У кожному слові велика одна буква - та, на яку потрапляє наголос. Слова в словнику розташовані в алфавітному порядку. Якщо є кілька можливостей розстановки наголосів в одному й тому самому слові, то ці варіанти в словнику йдуть в довільному порядку. Далі йде вправа, виконана Оленкою. Вправа є рядком тексту, сумарним обсягом не більше 300000 символів. Рядок складається з слів, які розділяються між собою рівно одним пропуском. Довжина кожного слова не перевищує 30 символів. Всі слова складаються з маленьких і великих латинських букв (великими позначені ті букви, над якими Оленка поставила наголос). Оленка могла помилково в якомусь слові поставити більше одного наголосу або не поставити наголоси зовсім. Виведіть кількість помилок в тексті, що написала Оленка, які знайде Сашко. Примітки. В слові \"cannot\", відповідно до словника можливо два варіанти розстановки наголосів. Ці варіанти в словнику можуть бути перераховані в будь-якому порядку (тобто як спочатку \"cAnnot\", а потім \"cannOt\", так і навпаки). Дві помилки, вчинені Оленкою - це слова \"be\" (наголос взагалі не поставлено) і \"fouNd\" (наголос поставлено неправильно). Слово \"thE\" відсутнє в словнику, але оскільки в ньому Оленка поставила рівно один наголос, є правильним. Неправильно розставлені наголоси у всіх словах, крім \"The\" (воно відсутнє в словнику, в ньому поставлено рівно один наголос). В інших словах або ударні всі букви (в слові \"PAGE\"), або не поставлено жодного наголосу.",
    "inpdata": "4\ncAnnot\ncannOt\nfOund\npAge\nthE pAge cAnnot be found",
    "outdata": "2",
    "solution": "n = int(input())\naccents = {}\nfor i in range(n):\n    word = input()\n    basic_view = word.lower()\n    if basic_view not in accents:\n        accents[basic_view] = set()\n    accents[basic_view].add(word)\nerrors = 0\nrow = input().split()\nfor word in row:\n    basic_view = word.lower()\n    if (basic_view in accents and word not in accents[basic_view]\n            or len([letter for letter in word if letter.isupper()]) != 1):\n        errors += 1\nprint(errors)",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "604",
    "title": "Вводиться число n, за яким слідують n рядків тексту. Напишіть програму, яка друкує всі слова, що зустрічаються в тексті, по одному на рядок, і їхню кількість входжень у текст. Слова повинні бути відсортовані в порядку спадання відповідно до їх кількості, і всі слова при однаковому числі входжень у текст повинні бути надруковані в лексикографічному порядку. Вказівка. Після того, як ви створите словник усіх слів, вам захочеться впорядкувати його по частоті слова. Бажаного можна домогтися, якщо створити список, елементами якого будуть кортежі з двох елементів: частота зустрічальності слова і саме слово. Наприклад, [(2, 'hi'), (1, 'what'), (3, 'is')]. Тоді стандартне сортування буде сортувати список кортежів, при цьому кортежі порівнюються по першому елементу, а якщо ці елементи рівні - то по другому.",
    "inpdata": "9\nhi\nhi\nwhat is your name\nmy name is bond\njames bond\nmy name is damme\nvan damme\nclaude van damme\njean claude van damme",
    "outdata": "damme 4\nis 3\nname 3\nvan 3\nbond 2\nclaude 2\nhi 2\nmy 2\njames 1\njean 1\nwhat 1\nyour 1",
    "solution": "n = int(input())\ndata = {}\nfor i in range(n):\n    s = input().split()\n    for word in s:\n        if word not in data:\n            data.setdefault(word, 1)\n        else:\n            data[word] += 1\nfrequency = []\nfor word, c in data.items():\n    frequency.append([-c, word])\nfor c, word in sorted(frequency):\n     print(word, abs(c))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "605",
    "title": "Сашко і Оленка грають в гру. Сашко загадав натуральне число від 1 до n. Оленка намагається вгадати це число, для цього вона називає деякі послідовності натуральних чисел. Сашко відповідає Оленці \"YES\", якщо серед названих нею чисел є задумане або \"NO\" в іншому випадку. Після декількох заданих питань Оленка заплуталася в тому, які питання вона задавала і які відповіді отримала і просить вас допомогти їй визначити, які числа міг задумати Сашко. Перший рядок вхідних даних містить число n - найбільше число, яке міг загадати Сашко. Далі йдуть рядки, які містять питання Оленки. Кожен рядок представляє собою набір чисел, розділених пропусками. Після кожного рядка з питанням йде відповідь Сашка: \"YES\" або \"NO\". Нарешті, останній рядок вхідних даних містить одне слово \"HELP\". Ви повинні вивести (через пропуск, в порядку зростання) всі числа, які міг задумати Сашко.",
    "inpdata": "12\n1 2 3 5 7 9\nYES\n3 7 9 11 12\nNO\nHELP",
    "outdata": "1 2 5",
    "solution": "n = int(input())\nnumbers = set(range(1, n + 1))\nwhile True:\n    guess = input()\n    if guess == 'HELP':\n        break\n    guess = {int(i) for i in guess.split()}\n    answer = input()\n    if answer == 'YES':\n        numbers &= guess\n    else:\n        numbers -= guess\nprint(*sorted(numbers))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "606",
    "title": "Сашко і Оленка продовжують грати в гру, але Сашко почав шахраювати. На кожне з питань Оленки він вибирає такий варіант відповіді \"YES\" або \"NO\", щоб послідовність можливих задуманих чисел залишалася якомога більшою. Наприклад, якщо Сашко задумав число від 1 до 5, а Оленка запитала про числа 1 і 2, то Сашко відповість \"NO\", а якщо Оленка запитає про 1, 2, 3, то Сашко відповість \"YES\". Якщо ж Оленка в своєму питанні перераховує рівно половину з задуманих чисел, то Сашко завжди відповідає \"NO\". Нарешті, Сашко при відповіді враховує всі попередні питання Оленки і свої відповіді на них, тобто множина можливих задуманих чисел зменшується. Вам дано послідовність питань Оленки. Наведіть відповіді Сашка на них. Перший рядок вхідних даних містить число n - найбільше число, яке міг загадати Сашко. Далі йдуть рядки, які містять питання Оленки. Кожен рядок представляє собою набір чисел, розділених пропусками. Останній рядок вхідних даних містить одне слово \"HELP\". Для кожного питання Оленки виведіть відповідь Сашка на це питання. Після цього виведіть (через пропуск, в порядку зростання) всі числа, які міг би загадати Сашко після відповіді на всі питання Оленки.",
    "inpdata": "8\n1 2 3 5 6\n2 3 7 8\nHELP",
    "outdata": "YES\nNO\n1 5 6",
    "solution": "n = int(input())\nnumbers = set(range(1, n + 1))\nwhile True:\n    guess = input()\n    if guess == 'HELP':\n        break\n    guess = {int(i) for i in guess.split()}\n    if len(numbers & guess) > len(numbers) / 2:\n        print('YES')\n        numbers &= guess\n    else:\n        print('NO')\n        numbers -= guess     \nprint(*sorted(numbers))",
    "chapter": "словники і множини",
    "level": "високий"
  },
  {
    "id": "607",
    "title": "Напишіть функцію, яка отримує ім’я і друкує вітальне повідомлення.",
    "inpdata": "Alex",
    "outdata": "Hello, Alex",
    "solution": "def say_hello(name):\n    return 'Hello, ' + name\nprint(say_hello(input()))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "608",
    "title": "Напишіть функцію, яка отримує рядок і ціле число n та повертає n копій заданого рядка.",
    "inpdata": "I love coding\n3",
    "outdata": "I love codingI love codingI love coding",
    "solution": "def larger_string(s, n):\n    return s * n\nrow = input()\nn = int(input())\nprint(larger_string(row, n))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "609",
    "title": "Напишіть функцію для обчислення суми двох цілих чисел.",
    "inpdata": "2 5",
    "outdata": "7",
    "solution": "def my_sum(a, b):\n    return a + b\na, b = map(int, input().split())    \nprint(my_sum(a, b))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "610",
    "title": "Напишіть функцію для перетворення цілого числа в рядок.",
    "inpdata": "8",
    "outdata": "'8'",
    "solution": "def int_to_str(number):\n    return str(number)\nprint(int_to_str(int(input())))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "611",
    "title": "Напишіть функцію для отримання рядка з перших n символів іншого рядка. Якщо довжина рядка менше n, поверніть початковий рядок.",
    "inpdata": "5\nJava\n2\nJava",
    "outdata": "Java\nJa",
    "solution": "def first_n(n, s):\n    if len(s) <= n:\n        return s\n    return s[:n]\nn = int(input())\ns = input()\nprint(first_n(n, s))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "612",
    "title": "Напишіть функцію для визначення більшого з двох цілих чисел без використання вбудованої функції max(). Якщо числа рівні, то вивести повідомлення \"equal\".",
    "inpdata": "12 56\n11 4\n3 3",
    "outdata": "56\n11\nequal",
    "solution": "def compare(a, b):\n    if a > b:\n        return a\n    elif b > a:\n        return b\n    return 'equal'\na, b = map(int, input().split())\nprint(compare(a, b))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "613",
    "title": "Напишіть функцію для визначення найбільшого з трьох цілих чисел з використанянм вбудованої функції max().",
    "inpdata": "1 2 2\n12 8 35\n1 1 1",
    "outdata": "2\n35\n1",
    "solution": "def compare(a, b, c):\n    return max(max(a, b), c)\na, b, c = map(int, input().split())\nprint(compare(a, b, c)",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "614",
    "title": "Напишіть функцію, яка перевіряє, чи існує трикутник із введеними сторонами a, b, c.",
    "inpdata": "2 2 1\n1 2 4",
    "outdata": "True\nFalse",
    "solution": "def is_triangle_exists(a, b, c):\n    if a + b > c and a + c > b and b + c > a:\n        return True\n    return False\na, b, c = map(float, input().split())\nprint(is_triangle_exists(a, b, c))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "615",
    "title": "Напишіть функцію, яка отримує два слова, об’єднує їх за допомогою пропуску і друкує результат об’єднання.",
    "inpdata": "Hello\nWorld",
    "outdata": "Hello World",
    "solution": "def concatenate(a, b):\n    return a + ' ' +  b\na = input()\nb = input()    \nprint(concatenate(a, b))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "616",
    "title": "Напишіть функцію, яка отримує 3 аргументи: перші 2 - числа, третій - операція (\"+\", \"-\", \"*\", \"/\"), яка повинна бути проведена над ними. У випадку невідомої операції, функція повертає рядок \"Unknown\" operation. Результатом має бути дійсне число з двома знаками після десяткової крапки.",
    "inpdata": "3\n8\n+",
    "outdata": "11.00",
    "solution": "def is_arithmetic(a, b, operation):\n    if operation == '+':\n        return a + b\n    elif operation == '-':\n        return a - b\n    elif operation == '*':\n        return a * b\n    elif operation == '/':\n        return a / b\n    else:\n        return 'Unknown operation'\na = float(input())\nb = float(input())\naction = input()\nresult = is_arithmetic(a, b, action)\nprint(format(result, '.2f'))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "617",
    "title": "Напишіть функцію, яка перевіряє, чи подана послідовність порожня чи ні.",
    "inpdata": "Різні типи послідовностей (список, кортеж, словник)",
    "outdata": "True чи False",
    "solution": "def is_empty(item): \n    return len(item) == 0\ntypes = ['', [], [1, 2, 3], {1: 'one'}, {}, (1, 2), ()]\nfor item in types:\n    print(is_empty(item))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "618",
    "title": "Напишіть функцію, яка до введеного рядка на початку додає рядок \"Is\". Якщо даний рядок вже починається з \"Is\", то початковий рядок виводиться без змін.",
    "inpdata": "list\nIs empty",
    "outdata": "Is list\nIs empty",
    "solution": "def is_beginning(s):\n  if len(s) >= 2 and s[:2] == 'Is':\n    return s\n  return 'Is ' + s\nprint(is_beginning(input()))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "619",
    "title": "Напишіть функцію для перевірки того, чи введена літера є голосною чи приголосною.",
    "inpdata": "c\ne",
    "outdata": "False\nTrue",
    "solution": "def is_vowel(char):\n    all_vowels = 'aeiou'\n    return char in all_vowels\nprint(is_vowel(input()))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "620",
    "title": "Напишіть функцію для створення позначок тегів HTML навколо введених рядків. Функція отримує назву тега HTML і рядок, який необхідно помістити у відповідні теги.",
    "inpdata": "strong Python",
    "outdata": "<strong>Python</strong>",
    "solution": "def add_tag(tag, element):\n    return '<{0}>{1}</{0}>'.format(tag, element)\ntag, element = map(str, input().split())\nprint(add_tag(tag, element))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "621",
    "title": "Напишіть функцію, яка приймає два слова в якості вхідних даних, і надрукуйте найдовше слово. Якщо слова мають однакову довжину, то функція повинна надрукувати слова в окремих рядках.",
    "inpdata": "five three",
    "outdata": "three",
    "solution": "def max_len(a, b):\n    lena = len(a)\n    lenb = len(b)\n    if lena > lenb:\n        return a\n    elif lenb > lena:\n        return b\n    else:\n        return a + '\n' + b\na, b = map(str, input().split()) \nprint(max_len(a, b))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "622",
    "title": "Напишіть функцію, яка повертає назву пори року для введеного значення номера місяця.",
    "inpdata": "6\n2\n9\n3\n15",
    "outdata": "summer\nwinter\nautumn\nspring\nunknown",
    "solution": "def get_season(month):\n    if month in (12, 1, 2):\n        return 'winter'\n    elif month in (3, 4, 5):\n        return 'spring'\n    elif month in (6, 7, 8):\n        return 'summer'\n    elif month in (9, 10, 11):\n        return 'autumn'\nprint(get_season(int(input())))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "623",
    "title": "Напишіть функцію, яка повертає зі списку найменше і найбільше числа.",
    "inpdata": "61 9 -5 23 15 44 31 10 -14 7 8",
    "outdata": "(-14, 44)",
    "solution": "def max_num_in_list(items):\n    m = sorted(items)\n    return m[-1]\nitems = list(map(int, input().split()))\nprint(max_num_in_list(items))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "624",
    "title": "Напишіть функцію для вставки рядка всередину іншого рядка.",
    "inpdata": "[] Python\n<<>> HTML\nqwerty 123",
    "outdata": "[Python]\n<<HTML>>\nqwe123rty",
    "solution": "def insert_string_middle(s, word):\n    mid = len(s) // 2\n    return s[:mid] + word + s[mid:]\ns, word = map(str, input().split())\nprint(insert_string_middle(s, word)",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "625",
    "title": "Напишіть функцію для перетворення літер введеного рядка у великі, якщо він містить принаймні n великих літер в перших m символах. Спочатку вводиться сам рядок, а в з нового рядка - числа n і m.",
    "inpdata": "Python\n1 3\nRuby\n2 2",
    "outdata": "PYTHON\nRuby",
    "solution": "def to_uppercase(s, n=2, m=4):\n    num_upper = 0\n    for letter in s[:m]: \n        if letter.upper() == letter:\n            num_upper += 1\n    if num_upper >= n:\n        return s.upper()\n    return s\ns = input()\nn, m = map(int, input().split())   \nprint(to_uppercase(s, n, m))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "626",
    "title": "Напишіть функцію для створення гістограми (наприклад, у вигляді \"*\") із заданого списку цілих чисел як у вихідних даних. Формат введення списку чисел як у вхідних даних.",
    "inpdata": "2,7,1,4,2,3,9,3",
    "outdata": "**\n*******\n*\n****\n**\n***\n*********\n***",
    "solution": "def histogram(li):\n    for i in li:\n        print('*' * i)\nnumbers = list(map(int, input().split(',')))\nhistogram(numbers)",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "627",
    "title": "Напишіть функцію, яка приймає ціле число і друкує інформацію про парність чи непарність числа.",
    "inpdata": "2\n9",
    "outdata": "True\nFalse",
    "solution": "def check(number):\n    if number % 2 == 0:\n        return True\n    return False\nprint(check(int(input())))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "628",
    "title": "Напишіть функцію для друку парних чисел із заданої послідовності цілих чисел.",
    "inpdata": "32 4 7 9 11 13 15 8",
    "outdata": "32 4 8",
    "solution": "def even(items):\n    return list(i for i in items if i % 2 == 0)\nitems = list(map(int, input().split()))\nprint(*even(items))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "629",
    "title": "Напишіть функцію для підрахунку суми всіх елементів у списку цілих чисел.",
    "inpdata": "1 10 4 8 11 5 2",
    "outdata": "41",
    "solution": "def sum_list(items):\n    sum_numbers = 0\n    for x in items:\n        sum_numbers += x\n    return sum_numbers\nitems = list(map(int, input().split()))\nprint(sum_list(items))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "630",
    "title": "Напишіть функцію для підрахунку добутку усіх елементів у списку цілих чисел.",
    "inpdata": "1 10 4 8 11 5 2",
    "outdata": "35200",
    "solution": "def multiply(numbers):  \n    total = 1\n    for x in numbers:\n        total *= x  \n    return total   \nitems = list(map(int, input().split()))\nprint(multiply(items))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "631",
    "title": "Напишіть функцію для створення і друку словника, в якому ключі - цілі числа від 1 до n включно, а значення - квадрати цих чисел.",
    "inpdata": "10",
    "outdata": "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}",
    "solution": "def print_dict(n):\n    d = dict()\n    for i in range(1, n + 1):\n        d[i] = i**2\n    return d\nprint(print_dict(int(input()))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "632",
    "title": "Напишіть функцію для створення і друку списку, в якому значення - квадрати цілих чисел від 1 до n включно.",
    "inpdata": "5",
    "outdata": "[1, 4, 9, 16, 25]",
    "solution": "def print_list(n):\n    li = list()\n    for i in range(1, n + 1):\n        li.append(i**2)\n    return li\nprint(print_list(int(input())))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "633",
    "title": "Напишіть функцію, яка може генерувати та друкувати кортеж зі значеннями квадратів чисел від 1 до n включно.",
    "inpdata": "6",
    "outdata": "(1, 4, 9, 16, 25, 36)",
    "solution": "def print_tuple(n):\n    li = list()\n    for i in range(1, n + 1):\n        li.append(i**2)\n    return tuple(li)\nprint(print_tuple(int(input())))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "634",
    "title": "Python має вбудовану функцію __doc__ для друку документації для всіх вбудованих функцій. Наприклад, для доступу до документації функції abs(), слід використати такий запис: print(input.__doc__). Напишіть функцію для обчислення квадрата цілого числа. В тілі функції додайте багаторядковий коментар про те, що робить функція. Викличте функцію і перегляньте її документацію.",
    "inpdata": "9",
    "outdata": "81\nReturn the square value of the input number.\n    The input number must be integer.\n ",
    "solution": "def square(number):\n    '''Return the square value of the input number.\n    The input number must be integer.\n    '''\n    return number ** 2\nprint(square(int(input())))\nprint(square.__doc__)",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "635",
    "title": "Напишіть функцію, яка приймає послідовність чисел як у вхідних даних і створює список лише з першого та останнього елементів.",
    "inpdata": "5 16 72 29 11 217 112",
    "outdata": "[5, 112]",
    "solution": "def create_list(li):\n    linew = []\n    first, *mid, last = li\n    linew.append(first)\n    linew.append(last)\n    return linew\nli = map(int, input().split()) \nprint(create_list(li))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "636",
    "title": "Напишіть програму, і створіть в ній дві функції. Перша з них - приймає послідовність цілих чисел і повертає список. Друга - повертає новий список, що містить всі елементи першого списку без дублікатів.",
    "inpdata": "5 16 5 29 11 217 11",
    "outdata": "[5, 11, 16, 217, 29]",
    "solution": "def create_list(row):\n    li = list(map(int, row.split()))\n    return li\ndef del_duplicate(li):\n    return list(set(li))\nrow = input()\nli = create_list(row)\nprint(del_duplicate(li))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "637",
    "title": "Напишіть функцію, яка отримує рядок слів, розділених пропуском. Надрукуйте рядок слів у звороному порядку.",
    "inpdata": "one two three",
    "outdata": "three two one",
    "solution": "def reverse_word(w):\n  return ' '.join(w.split()[::-1]) \nprint(reverse_word(input()))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "638",
    "title": "Напишіть функцію, яка приймає послідовність цілих чисел та ціле число n, що вводяться на окремих рядках. Функція повертає True, якщо вказане число знаходиться всередині списку, або False у протилежному випадку.",
    "inpdata": "3 6 9 10 23 14\n23",
    "outdata": "True",
    "solution": "def in_the_list(row, number):\n    li = list(map(int, row.split()))\n    if number in li:\n        return True\n    return False\nrow = input() \nnumber = int(input())\nprint(in_the_list(row, number))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "639",
    "title": "Напишіть функцію, яка об’єднує всі елементи послідовності, введені через пропуск, в рядок, де елементи вже розділені комою і одним пропуском, і повертає його як у вихідних даних.",
    "inpdata": "Python Ruby C Go Java JavaScript",
    "outdata": "Python, Ruby, C, Go, Java, JavaScript",
    "solution": "def concatenate_data(items):\n    return ', '.join(list(map(str, items)))\nitems = list(map(str, input().split()))\nprint(concatenate_data(items))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "640",
    "title": "Напишіть функцію для визначення суми трьох цілих чисел. Якщо будь-які два значення однакові, необхідно вивести нуль.",
    "inpdata": "1 2 3\n1 2 2",
    "outdata": "6\n0",
    "solution": "def sum_set(a, b, c):\n    if len({a, b, c}) < 3:\n        return 0\n    return a + b + c\na, b, c = map(int, input().split())\nprint(sum_set(a, b, c))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "641",
    "title": "Напишіть функцію для перевірки наявності одного списку у іншому списку. Cписки містять принаймні по одному елементу.",
    "inpdata": "2 6 8 4 9 1\n4 9\n2 6 8 4 9 1\n9 4",
    "outdata": "True\nFalse",
    "solution": "def list_in_list(li1, li2):\n    c = 0\n    for i in range(len(li1)):\n        if li1[i:len(li2) + i] == li2:\n            c += 1    \n    return True if c > 0 else False\nli1 = list(input().split())\nli2 = list(input().split())\nprint(list_in_list(li1, li2))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "642",
    "title": "Напишіть функцію, яка приймає послідовність слів, розділених за допомогою дефісу і друкує слова в послідовності, розділеній за допомогою дефісу, після сортування за алфавітом.",
    "inpdata": "one-two-three-four-five-six-seven",
    "outdata": "five-four-one-seven-six-three-two",
    "solution": "def sorting(s):\n    return '-'.join(i for i in sorted(s.split('-')))\nprint(sorting(input()))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "643",
    "title": "Напишіть функцію, щоб вилучити певні символи із введеного рядка. Спочатку вводиться початковий рядок, а далі з нового рядка символи, які необхідно вилучити з початкового рядка. Результатом має бути новий рядок без вилучених символів.",
    "inpdata": "I did, did I?\nd?",
    "outdata": "I i, i I",
    "solution": "def replace_char(s, c):\n    result = s\n    for x in c:\n        result = result.replace(x, '')\n    return result\ns = input()\nc = input()   \nprint(replace_char(s, c))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "644",
    "title": "Дано два дійсних числа x і y. Напишіть функцію для перевірки, чи належить точка з координатами (x, y) квадрату (включаючи його межу), що має розміри 2 х 2 клітинки і розташований в початку системи координат. Якщо точка належить квадрату, виведіть слово \"YES\", інакше виведіть слово \"NO\". Функція не повинна містити інструкцію \"якщо\".",
    "inpdata": "2\n-1\n1\n1",
    "outdata": "NO\nYES",
    "solution": "def is_point_in_square(x, y):\n    return (x >= -1) and (x <= 1) and (y >= -1) and (y <= 1)\nx = float(input())\ny = float(input())\nresult = is_point_in_square(x, y)\nif result:\n    print('YES')\nelse:\n    print('NO')",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "645",
    "title": "Дано два дійсних числа x і y. Напишіть функцію для перевірки, чи належить точка з координатами (x, y) ромбу (включаючи його межу), що має розміри 1 х 1 клітинки і розташований в початку системи координат. Якщо точка належить ромбу, виведіть слово \"YES\", інакше виведіть слово \"NO\". Функція не повинна містити інструкцію \"якщо\".",
    "inpdata": "1\n1\n-0.6\n0.3",
    "outdata": "NO\nYES",
    "solution": "def is_point_in_square(x, y):\n    return abs(x) + abs(y) <= 1\nx = float(input())\ny = float(input())\nresult = is_point_in_square(x, y)\nif result:\n    print('YES')\nelse:\n    print('NO')",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "646",
    "title": "Дано п’ять дійсних чисел: x, y, xc, yc, r. Напишіть функцію для перевірки, чи належить точка (x, y) колу з центром (xc, yc) і радіусом r. Якщо точка належить колу, виведіть слово \"YES\", інакше виведіть слово \"NO\". Функція не повинна містити інструкцію \"якщо\".",
    "inpdata": "0\n0\n2\n2\n3\n1\n1\n4\n5\n3",
    "outdata": "YES\nNO",
    "solution": "def is_point_in_circle(x, y, xc, yc, r):\n    return (x-xc)**2 + (y-yc)**2 <= r**2\nx = float(input())\ny = float(input())\nxc = float(input())\nyc = float(input())\nr = float(input())\nresult = is_point_in_circle(x, y, xc, yc, r)\nif result:\n    print('YES')\nelse:\n    print('NO')",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "647",
    "title": "Надрукуйте найменше з трьох введених чисел без використання вбудованої функції min(). Для цього напишіть першу функцію, яка повертає найменше число з двох заданих. У другій функції реалізуйте використання першої функції для визначення найменшого значення серед трьох чисел.",
    "inpdata": "5 8 11\n12 12 24\n1 1 1",
    "outdata": "5\n12\n1",
    "solution": "def min_of_two(a, b):\n    if a < b:\n        return a\n    return b\ndef min_of_three(a, b, c):\n    return min_of_two(a, min_of_two(b, c))\na, b, c = map(int, input().split())\nprint(min_of_three(a, b, c))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "648",
    "title": "Дано чотири дійсних числа: x1, y1, x2, y2. Напишіть функцію distance(x1, y1, x2, y2), яка обчислює відстань між точкою (x1, y1) і (x2, y2). Введіть чотири дійсних числа і виведіть результат роботи цієї функції.",
    "inpdata": "0\n0\n1\n1",
    "outdata": "1.41421",
    "solution": "def distance(x1, y1, x2, y2):\n    return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5\nx1 = float(input())\ny1 = float(input())\nx2 = float(input())\ny2 = float(input())\nprint(round(distance(x1, y1, x2, y2), 5))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "649",
    "title": "Напишіть функцію, яка отримує рядок і обчислює кількість великих та нижніх букв в ньому і друкує результат як у вихідних даних - спочатку кількість великих, а потім кількість малих літер.",
    "inpdata": "Was it a car or a cat I saw?",
    "outdata": "2\n17",
    "solution": "def case_letters(s):\n    d = {'UPPER_CASE': 0, 'LOWER_CASE': 0}\n    for c in s:\n        if c.isupper():\n           d['UPPER_CASE'] += 1\n        elif c.islower():\n           d['LOWER_CASE'] += 1\n    return str(d['UPPER_CASE']) + '\\n' + str(d['LOWER_CASE'])\ns = input()\nprint(case_letters(s))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "650",
    "title": "Напишіть функцію для підрахунку входжень кожного слова в певному реченні.",
    "inpdata": "the quick brown fox jumps over the lazy dog",
    "outdata": "{'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}",
    "solution": "def word_count(s):\n    counts = dict()\n    words = s.split()\n    for word in words:\n        if word in counts:\n            counts[word] += 1\n        else:\n            counts[word] = 1\n    return counts\nprint(word_count(input()))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "651",
    "title": "Напишіть функцію - простий лічильник відвідувань, яка отримує в циклі (до тих пір, поки не буде введено 0) логін. Якщо логін новий, то лічильник збільшується на одиницю, якщо логін вже був, то лічильник відвідувань також збільшується на одиницю, а число унікальних відвідувачів залишається незмінним. На екран має виводитися кількість відвідувань і кількість унікальних користувачів.",
    "inpdata": "Barbara\nAlex56\nAlex56\nBarbara\n0",
    "outdata": "1 1\n2 2\n3 2\n4 2\n5 2\n0",
    "solution": "def hits_counter():\n    c = 0\n    hits = set() \n    while True:\n        login = input()\n        if login != '0':\n            hits.add(login)\n            c += 1\n            print(c, len(hits))\n        else: \n            break\nhits_counter()",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "652",
    "title": "Напишіть функцію, яка друкує усі слова із списку, довжина яких перевищує n.",
    "inpdata": "Denmark England Estonia France Greece Romania Ukraine\n6",
    "outdata": "Denmark England Estonia Romania Ukraine",
    "solution": "def long_words(s, n):\n    word_len = []\n    txt = s.split()\n    for word in txt:\n        if len(word) > n:\n            word_len.append(word)\n    return word_len\t\ns = input()\nn = int(input())\nprint(*long_words(s, n))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "653",
    "title": "Напишіть функцію, яка приймає два списки та повертає True, якщо у них є щонайменше один спільний елемент.",
    "inpdata": "1 2 3 4 5\n6 7 8 9 0\n1 two three four five 6 seven 8 9 ten\nfive hundred",
    "outdata": "False\nTrue",
    "solution": "def common_lists(li1, li2):\n    result = False\n    for x in li1:\n        for y in li2:\n            if x == y:\n                result = True\n    return result\nli1 = list(input().split())\nli2 = list(input().split())\nprint(common_lists(li1, li2))",
    "chapter": "функції",
    "level": "початковий"
  },
  {
    "id": "654",
    "title": "Напишіть функцію для визначення, чи рік високосний чи ні.",
    "inpdata": "2023\n2020",
    "outdata": "False\nTrue",
    "solution": "def is_leap(year):\n    if year % 400 == 0:\n        return True\n    if year % 100 != 0 and year % 4 == 0:\n        return True\nprint(is_leap(int(input())))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "655",
    "title": "Напишіть функцію, яка приймає слово у нижньому регістрі і повертає слово з першою великою буквою. Введіть рядок слів через пропуск у нижньому регістрі і застосуйте створену функцію для отримання результату як у вихідних даних.",
    "inpdata": "jived fox nymph grabs quick waltz",
    "outdata": "Jived Fox Nymph Grabs Quick Waltz",
    "solution": "def capitalize(word):\n    first_letter_small = word[0]\n    first_letter_big = chr(ord(first_letter_small) - ord('a') + ord('A'))\n    return first_letter_big + word[1:]\nsource = input().split()\nres = []\nfor word in source:\n    res.append(capitalize(word))\nprint(' '.join(res))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "656",
    "title": "Вкладник розмістив суму розміром n грн. в банку. Визначте, яку суму отримає вкладник через m років, якщо відсоткова ставка складає p% в рік. Дані вводяться в порядку n, p, m як у вхідних даних.",
    "inpdata": "5000\n18\n2",
    "outdata": "6800.00",
    "solution": "def calculate(present_value, year_interest_rate, year):\n    f = present_value * (1 + year_interest_rate / 100 * year)\n    return format(f, '.2f')\npresent_value = float(input())\nyear_interest_rate = float(input())\nyear = int(input())\nprint(calculate(present_value, year_interest_rate, year))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "657",
    "title": "Дано дійсне додатне число a і ціле число n, яке може набувати додатних і від’ємних значень. Напишіть функцію для обчислення a^n. Стандартною функцією піднесення до степеня і оператором \"**\" користуватися не можна.",
    "inpdata": "2\n1\n2\n-1",
    "outdata": "2.0\n0.5",
    "solution": "def is_power(a, n):\n    res = 1\n    for i in range(abs(n)):\n        res *= a\n    if n >= 0:\n        return res\n    else:\n        return 1 / res\nprint(is_power(float(input()), int(input())))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "658",
    "title": "Напишіть функцію, яка отримує значення середньомісячної кількості опадів по місяцях (в мм) і повертає загальний обсяг опадів протягом року, середньорічну кількість опадів, назви місяців та значення з найвищим та найменшим числом опадів протягом року.",
    "inpdata": "22 22 24 49 72 98 101 82 51 40 36 24",
    "outdata": "(621.0, 51.75, (101.0, 'July'), (22.0, 'January'))",
    "solution": "def rainfall(monthly_list):\n    month = {1: 'January',\n             2: 'February',\n             3: 'March',\n             4: 'April',\n             5: 'May',\n             6: 'June',\n             7: 'July',\n             8: 'August',\n             9: 'September',\n             10: 'October',\n             11: 'November',\n             12: 'December'             \n    }\n    total_rainfall = sum(monthly_list)\n    average_amount_rainfall = total_rainfall / len(monthly_list)\n    month_highest_rainfall = (max(monthly_list), month[monthly_list.index(max(monthly_list)) + 1])\n    month_lowest_rainfall = (min(monthly_list), month[monthly_list.index(min(monthly_list)) + 1])\n    return total_rainfall, average_amount_rainfall, month_highest_rainfall, month_lowest_rainfall \nmonthly_list = list(map(float, input().split()))\nprint(rainfall(monthly_list))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "659",
    "title": "Написати функцію для перевірки правильності введеної дати. Функція приймає 3 аргументи - день, місяць та рік і повертає True, якщо така дата є в календарі, і False в протилежному випадку.",
    "inpdata": "04\n03\n2029\n33\n11\n2019",
    "outdata": "True\nFalse",
    "solution": "def is_year_leap(year):\n    if year % 400 == 0:\n        return True\n    if year % 4 == 0 and year % 100 != 0:\n        return True\n    return False\ndef correct_date(day, month, year):\n    day_in_month = {1: 31,\n                    2: 29 if is_year_leap(year) else 28,\n                    3: 31,\n                    4: 30,\n                    5: 31,\n                    6: 30,\n                    7: 31,\n                    8: 31,\n                    9: 30,\n                    10: 31,\n                    11: 30,\n                    12: 31}\n    if (1 <= month) and (month <= 12) and (1 <= day) and (day <= day_in_month[month]):\n        return True\n    return False\nday = int(input())\nmonth = int(input())\nyear = int(input())\nprint(correct_date(day, month, year))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "660",
    "title": "Напишіть функцію для перевірки, чи є число ідеальним чи ні. Примітка. У теорії чисел ідеальне число - це додатне ціле число, яке дорівнює сумі власних додатних дільників, тобто сумі додатних дільників, виключаючи саме число. Відповідно, ідеальне число - це число, що дорівнює половині суми всіх додатних дільників (включаючи саме число). Наприклад: перше ідеальне число - 6, оскільки 1, 2 і 3 - це правильні додатні дільники, а 1 + 2 + 3 = 6. Відповідно, число 6 дорівнює половині суми всіх його додатних дільників: (1 + 2 + 3 + 6) / 2 = 6. Наступне ідеальне число - 28 = 1 + 2 + 4 + 7 + 14. Далі ідуть ідеальні числа 496 і 8128.",
    "inpdata": "6\n28\n25",
    "outdata": "True\nTrue\nFalse",
    "solution": "def perfect_number(n):\n    sum = 0\n    for x in range(1, n):\n        if n % x == 0:\n            sum += x\n    return sum == n\nprint(perfect_number(int(input())))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "661",
    "title": "На стадіоні є три категорії місць для сидіння: місця класу A коштують a грошових одиниць, місця класу B коштують b грошових одиниць, а місця класу C - c грошових одиниць. Напишіть першу функцію, яка запитує скільки продано квитків на кожний клас місць, і другу функцію, яка відображає суму отриманого доходу від продажу квитків на кожен клас окремо і загалом. Формати введення і виведення такі, як у вхідних і вихідних даних.",
    "inpdata": "A\n20.50\n45\nB\n15.75\n30\nC\n10.55\n15",
    "outdata": "({'A': 922.5, 'B': 472.5, 'C': 158.25}, 1553.25)",
    "solution": "def total_tickets(tickets):\n    result = {}\n    total = 0\n    for cl in tickets:\n        s = tickets[cl][0] * tickets[cl][1]\n        total += s\n        result[cl] = s\n    return result, total\n\ndef add_tickets():\n    tickets = {'A': [0.0, 0], 'B': [0.0, 0], 'C': [0.0, 0]}\n    for i in tickets:\n        cl = input().upper()\n        price = float(input())\n        k = int(input()) \n        tickets[cl][0] = price\n        tickets[cl][1] = k\n    return tickets\nprint(total_tickets(add_tickets()))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "662",
    "title": "Напишіть функцію, яка отримує послідовність балів (цілі числа) і повертає буквенну інтерпретацію числових балів на основі наступної шкали оцінок: 90-100 - A, 80-89 - B, 70-79 - C, 60-69 - D, нижче 60 - F.",
    "inpdata": "60 80 64 45 35 87 90 95 91 64 78",
    "outdata": "{'A': [90, 95, 91], 'B': [80, 87], 'C': [78], 'D': [60, 64, 64], 'F': [45, 35]}",
    "solution": "def grade(points):\n    grades = {'A': [], 'B': [], 'C': [], 'D': [], 'F': []}\n    for point in points:\n        if 90 <= point:\n            grades['A'].append(point)\n        elif 80 <= point and point <= 89:\n            grades['B'].append(point)\n        elif 70 <= point and point <= 79:\n            grades['C'].append(point)\n        elif 60 <= point and point <= 69:\n            grades['D'].append(point)\n        elif point < 60:\n            grades['F'].append(point)\n    return grades\npoints = list(map(int, input().split()))\nprint(grade(points))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "663",
    "title": "Напишіть функцію, яка перевіряє, чи рядок є паліндром чи ні. Регістр літер, пропуски і знаки пунктуації не враховувати. Примітка. Паліндром - це слово, фраза або послідовність, яка читається так само як зліва направо, так і справа наліво.",
    "inpdata": "Level\nNo 'x' in Nixon\n\"Was it a car or a cat I saw?\"\nA man, a plan, a canal, Panama!\npalindrome",
    "outdata": "True\nTrue\nTrue\nTrue\nFalse",
    "solution": "def p(s):\n    r = ''\n    r = ''.join(s.split()).lower()\n    r = r.translate(str.maketrans('', '', '\\'\"?.,;:!\\\\'))\n    return r == r[::-1]\nprint(p(input()))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "664",
    "title": "Напишіть функцію для сортування рядка в алфавітному порядку без врахування регістру літер.",
    "inpdata": "JavaScript\nPython",
    "outdata": "aaciJprStv\nhnoPty",
    "solution": "def lexicographi_sort(s):\n    return sorted(sorted(s), key=str.lower)\nprint(''.join(lexicographi_sort(input())))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "665",
    "title": "Напишіть функцію для сортування рядка в порядку, протилежному алфавітному, без врахування регістру літер.",
    "inpdata": "Ruby",
    "outdata": "yuRb",
    "solution": "def reverse_lexicographi_sort(s):\n    return sorted(sorted(s), key=str.lower, reverse=True)\nprint(''.join(reverse_lexicographi_sort(input())))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "666",
    "title": "Напишіть функцію для сортування рядка слів, розділених пропусками, за довжиною слів в порядку зростання.",
    "inpdata": "Ruby Python Go JavaScript Java",
    "outdata": "Go Java Ruby Python JavaScript",
    "solution": "def by_len_sort(s):\n    return sorted(sorted(s), key=len)\ns = input().split()    \nprint(' '.join(by_len_sort(s)))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "667",
    "title": "Напишіть функцію для сортування рядка слів, розділених пропусками, за довжиною слів в порядку зменшення.",
    "inpdata": "Ruby Python Go JavaScript Java",
    "outdata": "JavaScript Python Java Ruby Go",
    "solution": "def by_len_sort(s):\n    return sorted(sorted(s), key=len, reverse=True)\ns = input().split()    \nprint(' '.join(by_len_sort(s))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "668",
    "title": "Напишіть функцію, яка створює комбінацію із двох послідовностей цілих чисел, впорядковану за зростанням.",
    "inpdata": "1 4 0 12 4 5\n24 1 2 10 8",
    "outdata": "0 1 1 2 4 4 5 8 10 12 24",
    "solution": "def combine_integer_lists(a, b):\n    return sorted(a + b, key=int)\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nprint(combine_integer_lists(a, b))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "669",
    "title": "Напишіть функцію, яка створює комбінацію двох послідовностей таким чином як у вихідних даних.",
    "inpdata": "1 2 3 4 5\na b c d e",
    "outdata": "1 a 2 b 3 c 4 d 5 e",
    "solution": "def combine_lists(a, b):\n    len_a = len(a)\n    len_b = len(b)\n    if len_a < len_b:\n        limit = len_a\n    else:\n        limit = len_b\n    i = 0\n    r = []\n    while i < limit:\n        r.append(a[i])\n        r.append(b[i])\n        i += 1\n    return r\na = input().split()\nb = input().split()\nprint(*combine_lists(a, b))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "670",
    "title": "Дано список кортежів, кожен з яких містить два значення: назва фільму (рядок) і рейтинг (дійсне число). Напишіть функцію(ї) для сортування кортежів в порядку зростання рейтингу.",
    "inpdata": "Список із кортежів",
    "outdata": "[('Captain Marvel', 7.0), ('Aladdin', 7.4), ('Toy Story 4', 8.2), ('Avengers: Endgame', 8.7)]",
    "solution": "def last(n): \n    return n[-1]\ndef sort_list_last(tuples):\n  return sorted(tuples, key=last)\nimdb = [('Avengers: Endgame', 8.7), ('Aladdin', 7.4), ('Toy Story 4', 8.2), ('Captain Marvel', 7.0)]\nprint(sort_list_last(imdb))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "671",
    "title": "Напишіть функцію для обчислення факторіала заданого числа.",
    "inpdata": "5",
    "outdata": "120",
    "solution": "def fact(x):\n    if x == 0:\n        return 1\n    return x * fact(x - 1)\nprint(fact(int(input())))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "672",
    "title": "Напишіть функцію для \"перевертання\" кожного слова у введеному тексті.",
    "inpdata": "poT tops\noN ,nomel on nolem",
    "outdata": "Top spot\nNo lemon, no melon",
    "solution": "def reverse_string_words(text):\n    text = text.split()\n    result = []\n    for item in text:\n        result.append(item[::-1])\n    return result\nprint(*reverse_string_words(input()))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "673",
    "title": "Напишіть функцію для перевірки, чи є даний рядок анаграмою іншого рядка. Букви початкового рядка використовуються одноразово і враховується регістр літер. Примітка. Анаграма - переставлення літер у слові, завдяки чому утворюється нове значення слова.",
    "inpdata": "eleven plus two\ntwelve plus one\nI am Lord Voldemort\ntom marVoLo rIddle\nForty five\nover fifty",
    "outdata": "True\nTrue\nFalse",
    "solution": "def is_anagram(a, b):\n    list_a = [i for i in a if i.isalpha()]\n    list_a.sort()\n    list_b = [i for i in b if i.isalpha()]\n    list_b.sort()\n    return (list_a == list_b)\na = input()\nb = input()\nprint(is_anagram(a, b))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "674",
    "title": "Напишіть функцію для знаходження кількість повторень елементів у послідовності, які вводяться через кому в один рядок, і виведіть список пар \"елемент- кількість повторень\" в порядку спадання кількості повторень як у вихідних даних.",
    "inpdata": "1,2,3,4,3,3,2,4,5,6,1,2,3,4,6,1,2,3,4,6,6",
    "outdata": "[(3, 5), (2, 4), (4, 4), (6, 4), (1, 3), (5, 1)]",
    "solution": "def majority_element(num_list):\n    result = {}\n    for i in num_list:\n        if i not in result:\n            result.setdefault(i, 0)        \n        result[i] += 1\n    return sorted(result.items(), key=lambda x: x[1], reverse=True)\nnumbers = list(map(int, input().split(',')))\nprint(majority_element(numbers))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "675",
    "title": "Напишіть функцію для перевірки чи є послідовність цілих чисел арифметичною прогресією чи ні. Примітка. У математиці арифметична прогресія або арифметична послідовність - це послідовність чисел, в якій різниця між послідовними членами є постійною. Наприклад, послідовність 5, 7, 9, 11, 13, 15,... є арифметичною прогресією із загальною різницею 2.",
    "inpdata": "5 7 9 11\n5 7 10 12",
    "outdata": "True\nFalse",
    "solution": "def is_arithmetic(row):\n    li = list(map(int, row.split()))\n    delta = li[1] - li[0]\n    for index in range(len(li) - 1):\n        if not (li[index + 1] - li[index] == delta):\n             return False\n    return True\nrow = input()\nprint(is_arithmetic(row))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "676",
    "title": "Напишіть функцію для перевірки чи є послідовність чисел геометричної прогресією чи ні. Примітка. У математиці геометрична прогресія або геометрична послідовність є послідовністю чисел, де кожний елемент після першого знайдений шляхом множення попереднього на фіксовану, ненульову кількість, що називається загальним співвідношенням. Наприклад, послідовність 2, 6, 18, 54,... є геометричною прогресією з загальним співвідношенням 3. Аналогічно, 10, 5, 2.5, 1.25,... є геометричною послідовністю з загальним співвідношенням 1/2.",
    "inpdata": "2 6 18 54\n10 5 2.5 1.25\n5 8 9 11",
    "outdata": "True\nTrue\nFalse",
    "solution": "def is_geometric(row):\n    li = list(map(float, row.split()))\n    if len(li) <= 1:\n        return True\n    ratio = li[1]/float(li[0])\n    for i in range(1, len(li)):\n        if li[i]/float(li[i-1]) != ratio: \n            return False\n    return True \nrow = input()\nprint(is_geometric(row))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "677",
    "title": "Напишіть лямбда-функцію для визначення кореня квадратного з цілого числа.",
    "inpdata": "25\n2",
    "outdata": "5.00\n1.41",
    "solution": "def lambda_sqrt(n):\n    return (lambda x: x**0.5)(n)\nprint(format(lambda_sqrt(int(input())), '.2f'))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "678",
    "title": "Напишіть лямбда-функцію, яка повертає значення куба цілого числа.",
    "inpdata": "12\n4",
    "outdata": "1728\n64",
    "solution": "def lambda_cube(n):\n    return (lambda x: x*x*x)(n)\nprint(format(lambda_cube(int(input()))))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "679",
    "title": "Напишіть функцію, яка виконує ділення двох цілих чисел (числа вводяться в одному рядку через пропуск.). Необхідно написати програму, яка запускає цю функцію, і, у разі помилки (ділення на нуль), генерується виняток ZeroDivisionError і виводить його ім’я як у вихідних даних. В разі успішної дії ділення, має виводитись результат і повідомлення \"OK\". У будь-якому випадку в кінці роботи програми виводиться повідомлення \"Done\".",
    "inpdata": "10 4\n5 0",
    "outdata": "2.5\nOK\nDone\nZeroDivisionError\nDone",
    "solution": "def foo(a, b):\n    return a / b\na, b = map(int, input().split())   \ntry:\n    print(foo(a, b))\nexcept ZeroDivisionError:\n    print(\"ZeroDivisionError\")\nelse:\n    print('OK')\nfinally:\n    print('Done')",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "680",
    "title": "Напишіть функцію, яка приймає три рядки в якості аргументів: start_message, error_message, end_message. Функція повинна запитувати у користувача введення до тих пір, поки не буде введено ціле число (рядок, який конвертується функцією int без помилок). Перед першим запитом введення повинен бути виведене значення start_message, після кожного помилкового введення потрібно виводити значення рядка error_message і при вдалому введенні потрібно вивести рядок end_message і повернути отримане ціле число з функції. Кожне повідомлення повинно знаходитися на окремому рядку. Гарантовано, що в якийсь момент користувачем буде введено ціле число.",
    "inpdata": "Input int number:\nfive\nWrong value. Input int number:\n5",
    "outdata": "5\nThank you.",
    "solution": "def get_int(start_message, error_message, end_message):\n    print(start_message)\n    while True:\n        try:\n            number = int(input())\n        except:     \n            print(error_message)\n        else:\n            print(number)\n            return end_message\nresult = get_int('Input int number:', 'Wrong value. Input int number:', 'Thank you.')\nprint(result)",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "681",
    "title": "Дано список цілих чисел, в якому зустрічаються однакові значення. Напишіть функцію для друку цього списку після видалення всіх однакових значень.",
    "inpdata": "45 67 23 45 111 67 12 55",
    "outdata": "45 67 23 111 12 55",
    "solution": "def remove_duplicate(li):\n    newli = []\n    seen = set()\n    for item in li:\n        if item not in seen:\n            seen.add(item)\n            newli.append(item)\n    return newli\nli = list(map(int, input().split()))\nprint(remove_duplicate(li))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "682",
    "title": "Напишіть функцію для отримання всіх можливих двозначних комбінації літер із рядка цифр (від 1 до 9). Для розв’язування задачі використайте словник: string_maps = {'1': 'abc', '2': 'def', '3': 'ghi', '4': 'jkl', '5': 'mno', '6': 'pqrs', '7': 'tuv', '8': 'wxy', '9': 'z'}.",
    "inpdata": "12\n11",
    "outdata": "['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']\n['aa', 'ab', 'ac', 'ba', 'bb', 'bc', 'ca', 'cb', 'cc']",
    "solution": "def letter_combinations(digits):\n    if digits == \"\":\n        return []\n    string_maps = {\n        '1': 'abc',\n        '2': 'def',\n        '3': 'ghi',\n        '4': 'jkl',\n        '5': 'mno',\n        '6': 'pqrs',\n        '7': 'tuv',\n        '8': 'wxy',\n        '9': 'z'\n    }\n    result = ['']\n    for num in digits:\n        temp = []\n        for an in result:\n            for char in string_maps[num]:\n                temp.append(an + char)\n        result = temp\n    return result\ndigit_string = input()\nprint(letter_combinations(digit_string))",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "683",
    "title": "Напишіть функцію для виконання рядка, що містить код Python. Реалізуйте функцію разом із конструкцією try/except, яка має відпрацювати як у вихідних даних.",
    "inpdata": "print('Hello, World!')\nprint(36+51)\nprint(2 + 'a')",
    "outdata": "Hello, World!\nSuccessfully\nDone\n87\nSuccessfully\nDone\nNot fulfilled\nDone",
    "solution": "def execute_code(code):\n    try:\n        exec(code)\n    except Exception:\n        print('Not fulfilled')\n    else:\n        print('Successfully')\n    finally:\n        print('Done')\nexecute_code(input())",
    "chapter": "функції",
    "level": "середній"
  },
  {
    "id": "684",
    "title": "Напишіть функцію для перевірки, чи є рядок \"панграмою\" чи ні. Примітка. Панграма - фраза, вислів або текст в якому присутні всі літери абетки принаймні по одному разу. Наприклад: \"How vexingly quick daft zebras jump\" (30 літер), \"The five boxing wizards jump quickly\" (31 літера), \"Cwm fjord bank glyphs vext quiz\" (26 літер), \"The quick brown fox jumps over the lazy dog\" (35 літер).",
    "inpdata": "Cwm fjord bank glyphs vext quiz\nHow vexingly quick daft zebras jump\nMr Jock, TV quiz PhD, bags few lynx",
    "outdata": "True\nTrue\nTrue",
    "solution": "def is_pangram(sentence):\n    return not (set('abcdefghijklmnopqrstuvwxyz') - set(sentence.lower()))\nprint(is_pangram(input()))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "685",
    "title": "Напишіть програму, яка обчислює площі трикутника, круга і прямокутника, реалізувавши для кожної фігури окрему функцію. Напишіть окрему функцію, яка визначає, площу якої фігури необхідно обчислити, тобто отримує назву фігури і вхідні дані (дійсні числа) для обчислення площі. З деякими вхідними даними триктуник може не існувати, тому реалізуйте ще одну функцію для перевірки існування трикутника.",
    "inpdata": "triangle\n1 0 1\ncircle\n5\nrectangle\n2 7\ntriangle\n2 2 1",
    "outdata": "triangle does not exist\n78.50\n14.00\n0.97",
    "solution": "def circle(r):\n    p = 3.14\n    return p * r**2\n \ndef rectangle(a, b):\n    return a * b\n \ndef triangle(a, b, c):\n    p = (a + b + c) / 2\n    return (p * (p - a) * (p - b) * (p - c)) ** 0.5\n\ndef is_triangle_exists(a, b, c):\n    if a + b > c and a + c > b and b + c > a:\n        return True\n    return False\n    \ndef choice(figure):\n    result = 0\n    if figure == 'triangle':\n        a, b, c = map(float, input().split())\n        if is_triangle_exists(a, b, c):\n            result = triangle(a, b, c)\n        else:\n            return 'triangle does not exist'\n    elif figure == 'rectangle':\n        a, b = map(float, input().split())\n        result = rectangle(a, b)\n    elif figure == 'circle':\n        r = float(input())\n        result = circle(r)\n    return format(result, '.2f')\nprint(choice(input()))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "686",
    "title": "Напишіть функцію, яка виводить перші n рядків трикутника Паскаля. Примітка. Трикутник Паскаля - це арифметична та геометрична фігура, описана Блезом Паскалем. Ряди трикутника Паскаля умовно пронумеровані згори, починаючи з нульового. Кожне число в кожному ряді одержуємо, додавши два числа, розміщені вгорі (зліва і справа). Якщо зліва або справа немає числа, підставляємо нуль на його місце.",
    "inpdata": "5",
    "outdata": "[1]\n[1, 1]\n[1, 2, 1]\n[1, 3, 3, 1]\n[1, 4, 6, 4, 1]",
    "solution": "def pascal_triangle(n):\n    trow = [1]\n    y = [0]\n    for x in range(max(n, 0)):\n        print(trow)\n        trow = [l + r for l, r in zip(trow + y, y + trow)]\n    return n >= 1\npascal_triangle(int(input()))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "687",
    "title": "Напишіть функцію для вирішення класичної давньої китайської головоломки: дано кількість голів n та лап m серед курчат та кроликів на фермі. Скільки курчат і кроликів на фермі?",
    "inpdata": "5 12\n3 4",
    "outdata": "4 1\nNO SOLUTIONS! NO SOLUTIONS!",
    "solution": "def solve(numheads, numlegs):\n    ns = 'NO SOLUTIONS!'\n    for i in range(numheads + 1):\n        j = numheads - i\n        if 2*i + 4*j == numlegs:\n            return i, j\n    return ns, ns\nnumheads, numlegs = map(int, input().split())\nsolutions = solve(numheads, numlegs)\nprint(*solutions)",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "688",
    "title": "Напишіть функцію для створення всіх можливих перестановок елементів з послідовності різних цілих чисел.",
    "inpdata": "1 2 3",
    "outdata": "[[3, 2, 1], [2, 3, 1], [2, 1, 3], [3, 1, 2], [1, 3, 2], [1, 2, 3]]",
    "solution": "def permute(numbers):\n    result_perms = [[]]\n    for n in numbers:\n        new_perms = []\n        for perm in result_perms:\n            for i in range(len(perm)+1):\n                new_perms.append(perm[:i] + [n] + perm[i:])\n                result_perms = new_perms\n    return result_perms\nnumbers = list(map(int, input().split()))\nprint(permute(numbers))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "689",
    "title": "Напишіть програму, яка друкує наступний день для певної дати як у вихідних даних у форматі рррр-мм-дд. Напишіть окремі функції для обробки даних, які вводить користувач і використайте їх у програмі.",
    "inpdata": "31 8 2019\n28 2 2020",
    "outdata": "2019-9-1\n2020-2-29",
    "solution": "def is_leap(year):\n    leap_year = False\n    if year % 400 == 0:\n        leap_year = True\n    elif year % 100 == 0:\n        leap_year = False\n    elif (year % 4 == 0):\n        leap_year = True\n    return leap_year\n    \ndef days_in_month(month, year):\n    days_in_month = 30\n    if month in (1, 3, 5, 7, 8, 10, 12):\n        days_in_month = 31\n    elif month == 2:\n        if is_leap(year):\n            days_in_month = 29\n        else:\n            days_in_month = 28\n    return days_in_month\n\ndef next_date(day, month, year):\n    if day < days_in_month(month, year):\n        day += 1\n    else:\n        day = 1\n        if month == 12:\n            month = 1\n            year += 1\n        else:\n            month += 1\n    return '{2:}-{1:}-{0:}'.format(day, month, year)\n\nday, month, year = map(int, input().split())\nprint(next_date(day, month, year))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "690",
    "title": "Напишіть програму, яка друкує попередній день для певної дати як у вихідних даних у форматі рррр-мм-дд. Напишіть окремі функції для обробки даних, які вводить користувач і використайте їх у програмі.",
    "inpdata": "1 3 2019\n1 1 2020\n1 9 2019",
    "outdata": "2019-2-28\n2019-12-31\n2019-8-31",
    "solution": "def is_leap(year):\n    leap_year = False\n    if year % 400 == 0:\n        leap_year = True\n    elif year % 100 == 0:\n        leap_year = False\n    elif (year % 4 == 0):\n        leap_year = True\n    return leap_year\n    \ndef days_in_month(month, year):\n    days_in_month = 30\n    if month in (1, 3, 5, 7, 8, 10, 12):\n        days_in_month = 31\n    elif month == 2:\n        if is_leap(year):\n            days_in_month = 29\n        else:\n            days_in_month = 28\n    return days_in_month\n\ndef previous_date(day, month, year):\n    if month == 1 and day == 1:\n        day = 31\n        month = 12\n        year -= 1\n    elif month == 3 and day == 1 and is_leap(year):\n        day = 29\n        month -= 1\n    elif month == 3 and day == 1 and (not(is_leap(year))):\n        day = 28\n        month -= 1\n    elif month in (3, 5, 7, 10, 12) and day == 1:\n        day = 30\n        month -= 1\n    elif month in (2, 4, 6, 8, 9, 11) and day == 1:\n        day = 31\n        month -= 1\n    else:\n        day -= 1\n    return '{2:}-{1:}-{0:}'.format(day, month, year)\nday, month, year = map(int, input().split())\nprint(previous_date(day, month, year))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "691",
    "title": "Магічний квадрат - це квадратна таблиця n x n, заповнена цілими числами таким чином, що сума чисел у кожному рядку, кожному стовпчику і на обох діагоналях однакова. Напишіть функцію, яка отримує послідовність чисел у форматі як у вхідних даних, з яких утворюється двовимірна таблиця (список списків) цілочисельних елементів і перевірте чи є вона магічним квадратом. Результатом має бути True чи False відповідно.",
    "inpdata": "1 2 3,4 5 6,7 8 9\n4 9 2,3 5 7,8 1 6\n7 12 1 14,2 13 8 11,16 3 10 5,9 6 15 4\n23 28 21,22 24 26,27 20 25\n16 23 17,78 32 21,17 16 15\n4 3 8,9 5 1,2 7 6",
    "outdata": "False\nTrue\nTrue\nTrue\nFalse\nTrue",
    "solution": "def magic_square(matrix):\n    size_matrix = len(matrix[0])\n    sum_list = []\n    #Vertical:\n    for col in range(size_matrix):\n        sum_list.append(sum(row[col] for row in matrix))\n    #Horizontal\n    sum_list.extend([sum(line) for line in matrix])\n    #Diagonals\n    diagonal_main = 0\n    for i in range(0, size_matrix):\n        diagonal_main += matrix[i][i]\n    sum_list.append(diagonal_main)  \n    diagonal_indirect = 0\n    for i in range(size_matrix-1,-1,-1):\n        diagonal_indirect += matrix[i][i]\n    sum_list.append(diagonal_indirect)\n    if len(set(sum_list)) > 1:\n        return False\n    else:\n        return True\n\nmatrix = [list(map(int, i.split())) for i in input().split(',')] \nprint(magic_square(matrix))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "692",
    "title": "Напишіть функцію для перетворення кольору у форматі RGB у колір HSV. Користувач вводить три числа в одному рядку через пропуск - значення для червоного, зеленого та синього кольорів відповідно (значення кожного з чисел знаходяться в межах від 0 до 255 включно). Функція отримує ці три числа і виводить значення кольору у форматі HSV з форматуванням як у вихідних даних. Примітка. Колірна модель RGB (червоний, зелений, синій) зберігає окремі значення для червоного, зеленого та синього кольорів. Колірна модель HSV (відтінок, насиченість, значення), також відома як HSB (відтінок, насиченість, яскравість), часто використовується художниками, тому що часто природніше думати про кольори з точки зору тону та насиченості, ніж з точки зору поєднання компонентів кольору.",
    "inpdata": "0 220 0\n45 101 116",
    "outdata": "120° 100.0% 86.3%\n193° 61.2% 45.5%",
    "solution": "def rgb_to_hsv(r, g, b):\n    degree_sign= u'\N{DEGREE SIGN}'\n    r, g, b = r/255.0, g/255.0, b/255.0\n    mx = max(r, g, b)\n    mn = min(r, g, b)\n    df = mx-mn\n    if mx == mn:\n        h = 0\n    elif mx == r:\n        h = (60 * ((g-b)/df) + 360) % 360\n    elif mx == g:\n        h = (60 * ((b-r)/df) + 120) % 360\n    elif mx == b:\n        h = (60 * ((r-g)/df) + 240) % 360\n    if mx == 0:\n        s = 0\n    else:\n        s = df/mx\n    v = mx\n    return '{0:.0f}{3:} {1:.1%} {2:.1%}'.format(h, s, v, degree_sign)\nvalues = tuple(map(int, input().split()))\nprint(rgb_to_hsv(*values))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "693",
    "title": "Напишіть рекурсивну функцію, яка обчислює суму цілих чисел a і b. З арифметичних операцій використовується тільки додавання одиниці і віднімання одиниці.",
    "inpdata": "2\n9\n2\n-5\n3\n0",
    "outdata": "11\n-3\n3",
    "solution": "def sum_recursively(a, b):\n    if a == 0:\n        return b\n    return sum_recursively(a - 1, b + 1)    \nprint(sum_recursively(int(input()), int(input())))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "694",
    "title": "Напишіть рекурсивну функцію для обчислення суми списку цілих чисел.",
    "inpdata": "1 4 7 90 45 23 16",
    "outdata": "186",
    "solution": "def list_sum_recursively(numbers):\n    if len(numbers) == 1:\n        return numbers[0]\n    return numbers[0] + list_sum_recursively(numbers[1:])\nnumbers = list(map(int, input().split()))\nprint(list_sum_recursively(numbers))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "695",
    "title": "Дано послідовність чисел, що завершується числом 0 (саме число 0 в послідовність не входить, а служить як ознака її закінчення). Напишіть рекурсивну функцію, яка обчислює суму всіх цих чисел, не використовуючи цикл.",
    "inpdata": "3\n7\n4\n1\n0",
    "outdata": "15",
    "solution": "def sum_numbers(s=0):\n    n = int(input())\n    if n != 0:\n        return sum_numbers(s + n)\n    return s\nprint(sum_numbers())",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "696",
    "title": "Значення елемента послідовності Фібоначчі обчислюється на основі такої формули: f(n) = 0, якщо n = 0, f(n) = 1, якщо n = 1, f(n) = f(n-1) + f(n-2), якщо n > 1. Напишіть функцію для друку n елементів послідовності f(n) через кому в одному рядку. Примітка. Послідовність Фібоначчі - це послідовність чисел, де наступне число у послідовності є сумою попередніх двох чисел: 1, 1, 2, 3, 5, 8, 13,....",
    "inpdata": "7",
    "outdata": "1 1 2 3 5 8 13",
    "solution": "def fibonacci():\n    num = int(input())\n    i = 1\n    if num == 0:\n        fib = []\n    elif num == 1:\n        fib = [1]\n    elif num == 2:\n        fib = [1,1]\n    elif num > 2:\n        fib = [1,1]\n        while i < (num - 1):\n            fib.append(fib[i] + fib[i-1])\n            i += 1\n    return fib\nprint(*fibonacci())",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "697",
    "title": "Дано послідовність цілих чисел, що закінчується числом 0. Напишіть рекурсивну функцію, яка друкує цю послідовність в зворотному порядку. При розв’язуванні цього завдання не можна користуватися списками.",
    "inpdata": "4\n2\n7\n0",
    "outdata": "0\n7\n2\n4",
    "solution": "def is_reverse():\n    x = int(input())\n    if x != 0:\n        is_reverse()\n    print(x)\nis_reverse()",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "698",
    "title": "Напишіть функцію для обчислення результату піднесення числа a до степеня b, які вводяться в одному рядку через пропуск (a і b - цілі числа). Використайте рекурентне співідношення: a^n= a * a^(n-1). Використовувати цикли і вбудовану функцію pow() не можна.",
    "inpdata": "9 2\n3 6\n2 0",
    "outdata": "81\n729\n1",
    "solution": "def is_power(a,b):\n    if b == 0:\n        return 1\n    elif a == 0:\n        return 0\n    elif b == 1:\n        return a\n    else:\n        return a * is_power(a, b - 1)\na, b = map(int, input().split())\nprint(is_power(a, b))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "699",
    "title": "Напишіть функцію, яка для заданого натурального числа n (n > 0) генерує послідовність чисел, описану в гіпотезі Коллатц: якщо n парне, то ділимо його навпіл, якщо непарне, то множимо на 3 і додаємо 1. З підсумком обчислення знову проробляємо цю операцію до тих пір, поки в результаті не отримаємо число 1. Наприклад, для числа n = 17 послідовність обчислень виглядає наступним чином: 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1.",
    "inpdata": "17\n5\n2",
    "outdata": "17 52 26 13 40 20 10 5 16 8 4 2 1\n5 16 8 4 2 1\n2 1",
    "solution": "def collatz(number):\n    if number == 1:\n        return number\n    result = ''\n    result += str(number) + ' ' \n    while number != 1:\n        if number % 2 == 0:\n            number /= 2\n        else:\n            number *= 3\n            number += 1\n        result += str(round(number)) + ' '\n    return result.rstrip()\nnumber = int(input())\nprint(collatz(number))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "700",
    "title": "Ханойська вежа - одна з широко відомих головоломок, умова якої полягає в наступному: є три стержня (пронумеруємо їх числами 1, 2 і 3). На першому стержні знаходиться n кілець з радіусами від 1 до n. Кільця відсортовані по радіусу, і найбільше кільце лежить нижче всіх. Вам потрібно знайти і записати алгоритм перенесення всіх n кілець з першого стержня на третій за такими правилами: за один хід можна переносити тільки одне кільце; не можна класти більше кільце на менше. Програма повинна вивести на екран найкоротшу послідовність дій, необхідну для того, щоб перенести всі кільця з першого стержня на третій. Користувач вводить рядок, що містить додатне ціле число n. Програма має вивести порядок дій для вирішення головоломки. Кожна дія записується на окремому рядку. Дія записується в форматі \"номер стержня, з якого знімаємо кільце\" - \"номер стержня, на який надягаємо кільце\".",
    "inpdata": "2",
    "outdata": "1 - 2\n1 - 3\n2 - 3",
    "solution": "def hanoi(n, source, middle, target):\n    if n == 0:\n        return\n    else:\n        hanoi(n - 1, source, target, middle)\n        print('{0} - {1}'.format(source, target))\n        hanoi(n - 1, middle, source, target)\nn = int(input())\nif n > 0:\n    hanoi(n, '1', '2', '3')",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "701",
    "title": "Напишіть функцію, яка з послідовності додатних цілих чисел складає мінімальне і максимальне числа як у вихідних даних.",
    "inpdata": "2 0 509 23\n45 0 14 8 1",
    "outdata": "('2023509', '5092320')\n('1014458', '8451410')",
    "solution": "def create_max_and_min_number(numbers):\n    n_sorted = sorted(numbers)\n    n_sorted_reverse = sorted(numbers, reverse=True)\n    if '0' in n_sorted:\n        for i in range(len(n_sorted)):\n            if n_sorted [i] != '0':\n                n_sorted.insert(0, n_sorted.pop(i))\n                break    \n    min_n = ''.join(n_sorted)\n    max_n = ''.join(n_sorted_reverse)\n    return min_n, max_n\nnumbers = input().split()\nprint(create_max_and_min_number(numbers))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "702",
    "title": "Напишіть функцію для перетворення цілого числа в десятковій системі числення в рядок в будь-якій системі числення. В першому рядку вводиться число в десятковій нотації, через пропуск вказується основа системи числення, в якій необхідно число представити.",
    "inpdata": "1981 16\n23 3\n43 2",
    "outdata": "7BD\n212\n101011",
    "solution": "def to_string_from_notation(n, base):\n    hex_string = \"0123456789ABCDEF\"\n    if n < base:\n        return hex_string[n]\n    return to_string_from_notation(n // base, base) + hex_string[n % base]\nn, base = map(int, input().split())\nprint(to_string_from_notation(n, base))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "703",
    "title": "У римській системі числення для позначення чисел використовуються наступні символи (праворуч записані числа, яким вони відповідають в десятковій системі числення): I = 1, V = 5, X = 10, L = 50, C = 100, D = 500, M = 1000. Будемо використовувати варіант, в якому числа 4, 9, 40, 90, 400 і 900 записуються як віднімання від більшого числа меншого: IV, IX, XL, XC, CD і CM, відповідно. Напишіть функцію у програмі, яка переводить число з римської в десяткову систему числення. На вхід програми подається рядок, що містить число, закодоване в римській системі числення. Гарантується, що число менше 4000. Необхідно надрукувати рядок, що містить число в десятковій системі числення, відповідне введеному.",
    "inpdata": "MCMLXXXI\nXX\nIX",
    "outdata": "1981\n20\n9",
    "solution": "s = input()\nnumeral_map = tuple(zip(\n    (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1),\n    ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I')\n))\ndef roman_to_int(n):\n    i = result = 0\n    for integer, numeral in numeral_map:\n        while n[i:i + len(numeral)] == numeral:\n            result += integer\n            i += len(numeral)\n    return result\nprint(roman_to_int(s))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "704",
    "title": "Напишіть програму, яка шифрує повідомлення з використанням шифру Цезаря. Шифр Цезаря полягає в заміні кожного літерного символу вхідного рядка на символ, що знаходиться на кілька позицій ліворуч або праворуч його в алфавіті. На першому рядку вказується зсув шифрування: ціле число. Додатне число відповідає зсуву праворуч. На другому рядку вказується непорожній рядок-фраза для шифрування. Результатом роботи програми має бути надрукована зашифрована послідовність. Нелітерні символи мають виводитись без змін і програма має зберігати регістр: великі літери після змін мають лишатись великими, маленькі літери після змін мають лишатись маленькими. Для розв’язування задачі напишіть дві функції: функцію валідації ключа шифрування і функцію шифрування шифром Цезаря.",
    "inpdata": "key: 13\nplaintext: HELLO\nkey: 12\nplaintext: world, say hello!\nkey: -2\nplaintext: azy\nkey: 1 2",
    "outdata": "ciphertext: URYYB\nciphertext: iadxp, emk tqxxa!\nciphertext: yxw\nkey invalid",
    "solution": "# функція валідації ключа шифрування\ndef is_number(key):\n    n = len(key)\n    m = 0\n    if ord(key[0]) == 45:\n        m = 1\n    for i in range(m, n):\n        if ord(key[i]) < 48 or ord(key[i]) > 57:\n            return False\n    return True\n\n# функція шифрування шифром Цезаря\ndef caesar(p, k):\n    n = len(p)\n    print('ciphertext: ', end='');\n    for i in range(n):\n        c = ord(p[i]) + (k % 26)\n        if p[i] >= 'a' and p[i] <= 'z':\n            if c >= 97 and c <= 122:\n                print('{0:}'.format(chr(c)), end='') \n            else:\n                print('{0:}'.format(chr(c - 26)), end='') \n        elif p[i] >= 'A' and p[i] <= 'Z':\n            if c >= 65 and c <= 90:\n                print('{0:}'.format(chr(c)), end='')               \n            else:\n                print('{0:}'.format(chr(c - 26)), end='') \n        else:\n            print('{0:}'.format(p[i]), end='')    \n    print()\n\n# основна програма\nk = input('key: ')\nif is_number(k):\n    p = input('plaintext: ')\n    k = int(k)\n    caesar(p, k)\nelse:\n    print('key invalid')",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "705",
    "title": "Напишіть програму, яка шифрує повідомлення за допомогою шифру Віженера. Шифр Віженера є покращеним варіантом шифру Цезаря. Шифрування у ньому відбувається шляхом використання послідовності ключів (або ключового слова). Наприклад, якби сам Віженер хотів конфіденційно сказати комусь \"HELLO\" із використанням ключового слова, наприклад, \"ABC\", він би зашифрував \"H\" за допомогою ключа 0 (тобто \"A\"), \"E\" - за допомогою ключа 1 (тобто \"B\"), а першу букву \"L\" - за допомогою ключа 2 (тобто \"C\"). На цьому етапі в нього б закінчились букви у ключовому слові, і тому він знову використав би частину ключового слова, щоб зашифрувати другу \"L\" ключем 0 (тобто \"A\"), а букву \"O\" - ключем 1 (тобто \"B\"). Отже, він написав би \"HELLO\" як \"HFNLP\". Ключ шифру key має складатись виключно з літерних символів і застосовувати шифр Віженера потрібно виключно до літерних символів. Інші символи (цифри, спеціальні символи, пробіли, пунктуаційні знаки тощо) мають виводитись без змін. Для розв’язування задачі напишіть дві функції: функцію валідації ключа шифрування і функцію шифрування шифром Віженера.",
    "inpdata": "key: baz\nplaintext: BaRFoo\nkey: a12",
    "outdata": "ciphertext: CaQGon\nkey invalid",
    "solution": "# функція валідації ключа шифрування\ndef is_letters(key):\n    n = len(key)\n    for i in range(n):\n        if ord(key[i]) < 65:\n            return False\n        elif ord(key[i]) > 90 and ord(key[i]) < 97:\n            return False\n        elif ord(key[i]) > 122:\n            return False\n    return True\n\n# функція шифрування шифром Віженера\ndef vigenere(p, k):\n    n = len(p)\n    kl = len(k)\n    temp = 0\n    print('ciphertext: ', end='')\n    for i in range(n):\n        j = (i - temp) % kl\n        if p[i] >= 'a' and p[i] <= 'z':\n            kj = ord(k[j].lower())\n            c = ord(p[i]) + (kj - 97) % 26\n            if c >= 97 and c <= 122:\n                print('{0:}'.format(chr(c)), end='') \n            else:\n                print('{0:}'.format(chr(c - 26)), end='')\n        elif p[i] >= 'A' and p[i] <= 'Z':\n        \n            kj = ord(k[j].upper())\n            c = ord(p[i]) + (kj - 65) % 26\n            if c >= 65 and c <= 90:\n                print('{0:}'.format(chr(c)), end='')     \n            else:\n                print('{0:}'.format(chr(c - 26)), end='') \n        else:\n            temp += 1\n            print('{0:}'.format(p[i]), end='')    \n    print()\n      \n# основна програма\nk = input('key: ')\nif is_letters(k):\n    p = input('plaintext: ')\n    vigenere(p, k)\nelse:\n    print('key invalid')",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "706",
    "title": "У кожної кредитної картки є номер, який надрукований на ній, а також інший номер, вбудований у магнітну стрічку із зворотного боку картки. Цей номер також зберігається у певній базі даних для того, щоб коли вашою карткою розраховуються за покупку, банк знав, з якого рахунку cписувати гроші. У світі багато людей з кредитними картками, і тому ці номери доволі великі: American Express використовує номери із 15 розрядів, MasterCard - з 16, Visa - з 13 або 16. Ці розряди - десяткові (від 0 до 9). Номери кредитних карт мають певну структуру. Номери карток American Express починаються з 34 чи 37; номери карт MasterCard починаються з 51, 52, 53, 54 чи 55 (формально, вони можуть починатись і з деяких інших чисел, але ми не звертатимемо на це уваги в межах нашої задачі); номери карт Visa починаються з 4. Також номери карт мають вбудовану у них контрольну суму, що обраховується за допомогою математичної формули. Тож яка це секретна формула? Більшість карток використовують алгоритм, створений Гансом Петером Луном з IBM (Алгоритм Луна ). Відповідно до цього алгоритму, ви можете перевірити, чи номер кредитної картки є синтаксично коректним, наступним чином. Рядки довжиною 1 або менше не є дійсними. Пропуски дозволені для введення, але їх необхідно видалити перед перевіркою. Усі інші нецифрові символи заборонені. Приклад 1: дійсний номер кредитної картки 4539 1488 0343 6467. Перший крок алгоритму Луна - це подвоєння кожної другої цифри, починаючи справа: 4_3_ 1_8_ 0_4_ 6_6_. Якщо подвоєння числа є числом, що перевищує 9, необхідно відняти 9 від добутку. Результати нашого подвоєння, розставлені на свої місця: 8569 2478 0383 3437. Далі необхідно підсумувати всі цифри: 8+5+6+9+2+4+7+8+0+3+8+3+3+4+3+7 = 80. Якщо сума націло ділиться на 10, то число дійсне. Цей номер дійсний! Приклад 2: недійсний номер кредитної картки 8273 1232 7352 0569. Подвоєння кожної другої цифри, починаючи справа: 7253 2262 5312 0539. Сума цифр\n7+2+5+3+2+2+6+2+5+3+1+2+0+5+3+9 = 57. 57 націло не ділиться на 10, тому це число недійсне. Напишіть функцію(ї) для валідації номера кредитної картки за алгоритмом Луна і виведення приналежності картки для трьох компаній (American Express, MasterCard, Visa) як у вихідних даних. У разі некоректності номера або невідповідності переліченим компаніям, вивести повідомлення \"INVALID\".",
    "inpdata": "4003600000000014\n5105105105105100\n378282246310005\n4111111111111113",
    "outdata": "Visa\nMasterCard\nAmerican Express\nINVALID",
    "solution": "def card_transform(ncard):\n    ncard = ''.join(ncard.split())\n    lncard = len(ncard)\n    return ncard, lncard\n      \ndef luhn(ncard):\n    ncard, lncard = card_transform(ncard)\n    discharges_pair = [int(i) * 2 if int(i) <= 4 else int(i) * 2 - 9 for i in ncard[lncard-2::-2]]\n    discharges_odd = [int(i) for i in ncard[lncard-1::-2]]\n    sum_numbers_card = sum(discharges_pair) + sum(discharges_odd)\n    return True if sum_numbers_card % 10 == 0 else False\n\ndef card_validate(ncard):\n    ncard, lncard = card_transform(ncard)\n    if lncard <= 1 or not(ncard.isdigit()):\n        return False\n    else:\n        if luhn(ncard):\n            if lncard == 15 and ncard[:2] in ('34', '37'):\n                return 'American Express'\n            elif lncard == 16 and ncard[:2] in ('51', '52', '53', '54', '55'):\n                return 'MasterCard'\n            elif (lncard == 13 or lncard == 16) and ncard[0] == '4':\n                return 'Visa'\n            return False\n        return False\n        \nncard = input()\nresult = card_validate(ncard)\nif result:\n    print(result)\nelse:\n    print('INVALID')",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "707",
    "title": "Реалізуйте програму, яка буде емулювати роботу з просторами імен. Необхідно реалізувати підтримку створення просторів імен і додавання в них змінних. У цьому завданні у кожного простору імен є унікальний текстовий ідентифікатор - його ім’я. Програмі на вхід подаються такі запити: \"create <namespace> <parent>\" - створити новий простір імен з ім'ям <namespace> всередині простору <parent>; \"add <namespace> <var>\" - додати в простір <namespace> змінну <var>; \"get <namespace> <var>\" - отримати ім'я простору, з якого буде взята змінна <var> при запиті з простору <namespace>, або None, якщо такого простору не існує. У першому рядку дано число n (1 ≤ n ≤ 100) - кількість запитів. У кожному з наступних n рядків дано по одному запиту. Запити виконуються в порядку, в якому вони дані у вхідних даних. Імена простору імен і імена змінних являють собою рядки довжини не більше 10, що складаються з малих латинських букв. Для кожного запиту get виведіть в окремому рядку його результат. Детальніше про алгоритм розв'язування задачі читайте в повному тексті умови задачі.",
    "inpdata": "9\nadd global a\ncreate foo global\nadd foo b\nget foo a\nget foo c\ncreate bar foo\nadd bar a\nget bar a\nget bar b",
    "outdata": "global\nNone\nbar\nfoo",
    "solution": "space = {'global': {'parent': None, 'vars': []}}\ndef create(namesp, arg):\n    if namesp not in space:\n        space.setdefault(namesp, {'parent': arg, 'vars': []})    \ndef add(namesp, arg):\n        space[namesp]['vars'].append(arg)\ndef get(namesp, arg):\n    for item in space:\n        if item == namesp and arg in space[namesp]['vars']:\n            return namesp\n        elif item == namesp and arg not in space[namesp]['vars']:\n            res = get(space[namesp]['parent'], arg)\n            if res != None:\n                return res\nn = int(input())\nfor i in range(n):\n    cmd, namesp, arg = input().split()\n    if cmd == 'create':\n        create(namesp, arg)\n    elif cmd == 'add':\n        add(namesp, arg)\n    elif cmd == 'get':\n        print(get(namesp, arg))",
    "chapter": "функції",
    "level": "високий"
  },
  {
    "id": "708",
    "title": "Напишіть програму, щоб отримати версію Python, яку ви використовуєте: рядок, що містить номер версії інтерпретатора Python плюс додаткову інформацію про номер збірки та використаний компілятор. Цей рядок відображається під час запуску інтерактивного інтерпретатора. Використайте модуль sys.",
    "inpdata": "Немає",
    "outdata": "3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)]",
    "solution": "import sys\nprint(sys.version)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "709",
    "title": "Напишіть програму для виведення опису вбудованої функції Python. Імпортуйте модуль pydoc для розв’язування поставленої задачі. Для прикладу, роздрукуйте опис функції pow().",
    "inpdata": "Немає",
    "outdata": "Equivalent to x**y (with two arguments) or x**y % z (with three arguments)\n\nSome types, such as ints, are able to use a more efficient algorithm when\ninvoked using the three argument form.",
    "solution": "import pydoc\nprint(pydoc.getdoc(pow))  # print(pow.__doc__)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "710",
    "title": "Напишіть програму для друку інформації про модуль, наприклад, про math. Примітка. Спочатку модуль необхідно імпортувати.",
    "inpdata": "Немає",
    "outdata": "Список методів модуля",
    "solution": "import math            \nmath_info = dir(math)  \nprint(math_info)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "711",
    "title": "Напишіть програму, щоб отримати назву, платформу та інформацію про випуск операційної системи. Використайте імпорт модулів platform і os.",
    "inpdata": "Немає",
    "outdata": "nt\nWindows\n10",
    "solution": "import platform\nimport os\nprint(os.name)\nprint(platform.system())\nprint(platform.release())",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "712",
    "title": "Напишіть програму, яка друкує значення системного часу. Використайте модуль time.",
    "inpdata": "Немає",
    "outdata": "Fri Jul 26 19:02:02 2019",
    "solution": "import time\nprint(time.ctime())",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "713",
    "title": "Напишіть програму, щоб відобразити поточні дату й час як у вихідних даних. Використайте модуль datetime.",
    "inpdata": "Немає",
    "outdata": "2018-08-05 18:39:04",
    "solution": "import datetime\nnow = datetime.datetime.now()\nprint(now.strftime('%Y-%m-%d %H:%M:%S'))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "714",
    "title": "Напишіть програму, яка друкує поточне ім’я користувача в системі. Використайте модуль os.",
    "inpdata": "Немає",
    "outdata": "user",
    "solution": "import os\nprint(os.getlogin())",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "715",
    "title": "Напишіть програму для друку календаря певного місяця у році. Використайте модуль calendar.",
    "inpdata": "2019\n3",
    "outdata": "     March 2019\nMo Tu We Th Fr Sa Su\n             1  2  3\n 4  5  6  7  8  9 10\n11 12 13 14 15 16 17\n18 19 20 21 22 23 24\n25 26 27 28 29 30 31",
    "solution": "import calendar\ny = int(input())\nm = int(input())\nprint(calendar.month(y, m))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "716",
    "title": "Обчисліть n! і надрукуйте обчислене значення. Використайте модуль math.",
    "inpdata": "15",
    "outdata": "1307674368000",
    "solution": "import math\nprint(math.factorial(int(input())))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "717",
    "title": "Напишіть програму для обчислення найбільшого спільного дільника (GCD) з двох натуральних чисел. Використайте модуль math.",
    "inpdata": "144\n64",
    "outdata": "16",
    "solution": "from math import gcd\na = int(input())\nb = int(input())\nprint(gcd(a, b))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "718",
    "title": "Напишіть програму python, щоб отримати шлях і ім’я файла, який наразі виконується. Використайте модуль os.",
    "inpdata": "Немає",
    "outdata": "C:\Python36\wc.py",
    "solution": "import os\nprint(os.path.realpath(__file__))\nprint(os.path.abspath(__file__))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "719",
    "title": "Напишіть програму, яка створює список файлів з поточного каталогу, використовуючи символи підстановки. Використайте модуль glob.",
    "inpdata": "1*.*\n??.py",
    "outdata": "['1234.py']\n['f1.py']",
    "solution": "import glob\nfile_extention = input()\nfile_list = glob.glob(file_extention)\nprint(file_list)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "720",
    "title": "Напишіть програму для перевірки існування файла в поточному каталозі. Використайте модуль os.",
    "inpdata": "my.py\ninput.txt",
    "outdata": "False\nTrue",
    "solution": "import os\nfilename = input()\nprint(os.path.isfile(filename))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "721",
    "title": "Напишіть програму для отримання списку усіх файлів і каталогів у поточному каталозі. Використайте модуль os.",
    "inpdata": "Немає",
    "outdata": "Список файлів і каталогів в поточному каталозі",
    "solution": "import os\nprint(os.listdir(os.getcwd()))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "722",
    "title": "Напишіть програму, яка визначає обсяг об’єкта в байтах. Використайте модуль sys.",
    "inpdata": "Python",
    "outdata": "55 bytes",
    "solution": "import sys\ns = input()\nprint(str(sys.getsizeof(s)) + ' bytes')",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "723",
    "title": "Напишіть програму для друку характеристик числових типів Python. Використайте модуль os.",
    "inpdata": "Немає",
    "outdata": "Значення числових типів",
    "solution": "import sys\nprint('Float: ', sys.float_info)\nprint('Integer: ', sys.int_info)\nprint('Maximum integer: ', sys.maxsize)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "724",
    "title": "Напишіть програму для перемішування та друку введеної послідовності. Використайте модуль random.",
    "inpdata": "Yellow Pink Green Red Black White",
    "outdata": "Pink Yellow White Green Black Red",
    "solution": "import random\ndef my_shuffle(items):\n    random.shuffle(items)\n    return items\nitems = input().split() \nprint(*my_shuffle(items))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "725",
    "title": "Напишіть програму, щоб надрукувати на екрані вміст вказаного файла, розміщеного в поточному каталозі.",
    "inpdata": "Файл input.txt з вмістом\nPython\nRuby\nC++\nC\nJava",
    "outdata": "Python\nRuby\nC++\nC\nJava",
    "solution": "filename = input()\nwith open(filename, 'r') as f:\n    print(f.read())",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "726",
    "title": "Напишіть програму для підрахунку кількості кожного символу у текстовому файлі без врахування регістру літер, використавши модуль collections. Для \"гарного\" друку використайте модуль pprint.",
    "inpdata": "input.txt",
    "outdata": "Counter({'\\n': 4,\n         'y': 2,\n         'c': 2,\n         '+': 2,\n         'a': 2,\n         'p': 1,\n         't': 1,\n         'h': 1,\n         'o': 1,\n         'n': 1,\n         'r': 1,\n         'u': 1,\n         'b': 1,\n         'j': 1,\n         'v': 1})",
    "solution": "import collections\nimport pprint\nfilename = input()\nwith open(filename, 'r') as file:\n  count = collections.Counter(file.read().lower())\n  value = pprint.pformat(count)\nprint(value)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "727",
    "title": "Напишіть функцію, яка друкує випадкове ціле число від n до m включно.",
    "inpdata": "1\n1000",
    "outdata": "338",
    "solution": "import random\ndef get_random_number(n, m):\n    return random.randrange(n, m + 1)\nn = int(input())\nm = int(input())\nprint(get_random_number(n, m))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "728",
    "title": "Напишіть програму для розрахунку відстані між двома точками земної кулі (у прикладі обчислюється відстань між Пекіном і Києвом), використовуючи широту та довготу, які подані в десяткових градусах (дані візьміть із сайту dateandtime.info). Використайте формулу для визначення відстані: відстань = 6371.032 ? arccos(sin(x1) ? sin(x2) + cos(x1) ? cos(x2) ? cos(y1 - y2)), де значення 6371,032 - це середній радіус Землі у кілометрах. Врахуйте, що тригонометричні функції Python імпортуються з модуля math і працюють з радіанами.",
    "inpdata": "Input coordinates of two points.\nStarting latitude: 39.9075000\nEnding longitude: 116.3972300\nStarting latitude: 50.4546600\nEnding longitude: 30.5238000",
    "outdata": "The distance is 6449.78 km.",
    "solution": "from math import radians, sin, cos, acos\n\nprint('Input coordinates of two points.')\nx1 = radians(float(input('Starting latitude: ')))\ny1 = radians(float(input('Ending longitude: ')))\nx2 = radians(float(input('Starting latitude: ')))\ny2 = radians(float(input('Ending longitude: ')))\n\ndist = 6371.01 * acos(sin(x1)*sin(x2) + cos(x1)*cos(x2)*cos(y1-y2))\nprint('The distance is {0:.2f} km.'.format(dist))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "729",
    "title": "Дано додатне дійсне число n. Виведіть його дробову і цілу частину. Використайте модуль math.",
    "inpdata": "7.9\n5.8",
    "outdata": "(0.9000000000000004, 7.0)\n(0.7999999999999998, 5.0)",
    "solution": "import math \nn = float(input())\nprint(math.modf(n))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "730",
    "title": "Напишіть програму, яка форматує текст, показаний у вихідних даних, із шириною n. Використайте модуль textwrap.",
    "inpdata": "35",
    "outdata": "Python is a widely used high-level,\ngeneral-purpose, interpreted,\ndynamic programming language. Its\ndesign philosophy emphasizes code\nreadability, and its syntax allows\nprogrammers to express concepts in\nfewer lines of code than possible\nin languages such as C++ or Java.",
    "solution": "import textwrap\nn = int(input())\nsample_text = '''Python is a widely used high-level, general-purpose, interpreted, dynamic programming language. Its design philosophy emphasizes code readability, and its syntax allows programmers to express concepts in fewer lines of code than possible in languages such as C++ or Java.'''\nprint(textwrap.fill(sample_text, width=n))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "731",
    "title": "Напишіть програму для зчитування файла рядок за рядком та зберігання рядків у списку.",
    "inpdata": "Файл input.txt з вмістом\nPython\nRuby\nC++\nC\nJava\nGO",
    "outdata": "['Python\\n', 'Ruby\\n', 'C++\\n', 'C\\n', 'Java\\n', 'GO']",
    "solution": "filename = input()\nwith open(filename, 'r') as file:\n    lines = [line for line in file]\nprint(lines)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "732",
    "title": "Напишіть програму для підрахунку кількості рядків у текстовому файлі.",
    "inpdata": "Файл input.txt з вмістом\nPython\nRuby\nC++\nC\nJava\nGO",
    "outdata": "6",
    "solution": "filename = input()\nwith open(filename, 'r') as file:\n    lines = file.readlines()\nprint(len(lines))",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "733",
    "title": "У вхідному файлі записана один текстовий рядок, який може містити пропуски. Запишіть цей рядок в зворотному порядку у інший файл.",
    "inpdata": "Файл input.txt з вмістом\nhello world",
    "outdata": "Файл output.txt з вмістом\ndlrow olleh",
    "solution": "with open('input.txt', 'r') as file:\n    data = file.read()\n    result = data.strip('\\n')[::-1]        \nwith open('output.txt', 'w') as file:\n    file.write(result)",
    "chapter": "файли і модулі",
    "level": "початковий"
  },
  {
    "id": "734",
    "title": "У вхідному файлі записано два цілих числа, які можуть бути розділені пропусками і кінцями рядків. Виведіть у вихідний файл їх суму.",
    "inpdata": "Файл input.txt з вмістом\n  2\n\n 2",
    "outdata": "Файл output.txt з вмістом\n4",
    "solution": "with open('input.txt', 'r') as file:\n    data = file.read()\n    result = 0\n    for i in data.split():\n        result += int(i)\nwith open('output.txt', 'w') as file:\n    file.write(str(result))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "735",
    "title": "Запишіть рядки вхідного файла в зворотному порядку у інший файл. Останній рядок вхідного файлу обов’язково закінчується символом \\n.",
    "inpdata": "Файл input.txt з вмістом\nPython\nJava\nC++\nC\nRuby",
    "outdata": "Файл output.txt з вмістом\nRuby\nC\nC++\nJava\nPython",
    "solution": "with open('input.txt', 'r') as filein, open('output.txt', 'w') as fileout:\n    lines = filein.readlines()\n    for line in lines[::-1]:\n        result = line.strip('\\n')        \n        print(result, file=fileout)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "736",
    "title": "Запишіть увесь вміст вхідного файла в зворотному порядку у інший файл. Останній рядок вхідного файлу обов’язково закінчується символом \\n.",
    "inpdata": "Файл input.txt з вмістом\nPython\nJava\nC++\nC\nRuby",
    "outdata": "Файл output.txt з вмістом\nybuR\nC\n++C\navaJ\nnohtyP",
    "solution": "with open('input.txt', 'r') as filein, open('output.txt', 'w') as fileout:\n    lines = filein.readlines()\n    for line in lines[::-1]:\n        result = line.strip('\\n')[::-1]        \n        print(result, file=fileout)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "737",
    "title": "Напишіть програму для перевірки, чи містить введений рядок усі літери англійського алфавіту. Використайте модуль string, для отримання рядкових констант.",
    "inpdata": "The quick brown fox jumps over the lazy dog",
    "outdata": "True",
    "solution": "import string\nalphabet = set(string.ascii_lowercase)\ns = input()\nprint(set(s.lower()) >= alphabet)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "738",
    "title": "Напишіть програму, яка відкриває вказаний текстовий файл, а потім відображає список всіх унікальних слів, знайдених у файлі.",
    "inpdata": "input.txt",
    "outdata": "Список унікальних слів з файлу input.txt",
    "solution": "def unique_words_from_file(filename):\n    with open(filename, 'r') as file:\n        unique_words = set()\n        lines = file.readlines()\n        for line in lines:\n            word = line.rstrip('\\n')\n            unique_words.add(word)\n    return unique_words\nfilename = input()\nprint(unique_words_from_file(filename))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "739",
    "title": "Напишіть програму для обчислення найменшого спільного кратного (LCM) двох натуральних чисел. Використайте модуль fractions.",
    "inpdata": "15 17",
    "outdata": "255",
    "solution": "from fractions import gcd\ndef my_lcm(x, y):\n    return (x * y) // gcd(x,y)\na, b = map(int, input().split())\nprint(my_lcm(a, b))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "740",
    "title": "Напишіть програму для друку дати й часу на поточний момент у різних форматах як у вихідних даних. Використайте модулі time і datetime.",
    "inpdata": "Немає",
    "outdata": "Current date and time: 2019-07-26 21:00:41.004061\nCurrent year: 2019\nMonth of year: July\nWeek number of the year: 29\nWeekday of the week: 5\nDay of year: 207\nDay of the month: 26\nDay of week: Friday",
    "solution": "import time\nimport datetime\nprint('Current date and time:', datetime.datetime.now())\nprint('Current year:', datetime.date.today().strftime('%Y'))\nprint('Month of year:', datetime.date.today().strftime('%B'))\nprint('Week number of the year:', datetime.date.today().strftime('%W'))\nprint('Weekday of the week:', datetime.date.today().strftime('%w'))\nprint('Day of year:', datetime.date.today().strftime('%j'))\nprint('Day of the month:', datetime.date.today().strftime('%d'))\nprint('Day of week:', datetime.date.today().strftime('%A'))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "741",
    "title": "Напишіть програму для сортування словника пар \"будівля-висота\" за значеннями і ключами (в порядку зростання і спадання). Використайте модуль operator.",
    "inpdata": "Немає",
    "outdata": "[('Burj Khalifa', 828), ('Shanghai Tower', 632), ('Abraj Al Bait', 601)]\n[('Abraj Al Bait', 601), ('Shanghai Tower', 632), ('Burj Khalifa', 828)]\n[('Abraj Al Bait', 601), ('Burj Khalifa', 828), ('Shanghai Tower', 632)]\n[('Shanghai Tower', 632), ('Burj Khalifa', 828), ('Abraj Al Bait', 601)]",
    "solution": "import operator\nsubjects = {'Burj Khalifa': 828, 'Abraj Al Bait': 601, 'Shanghai Tower': 632}\nsorted_subjects = sorted(subjects.items(), key=operator.itemgetter(1), reverse=True)\nprint(sorted_subjects)\nsorted_subjects = sorted(subjects.items(), key=operator.itemgetter(1))\nprint(sorted_subjects)\nsorted_subjects = sorted(subjects.items(), key=operator.itemgetter(0))\nprint(sorted_subjects)\nsorted_subjects = sorted(subjects.items(), key=operator.itemgetter(0), reverse=True)\nprint(sorted_subjects)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "742",
    "title": "Один з астрологів визначає щасливі і нещасливі дні так: він записує підряд число, номер місяця і рік. В отриманому числі додає всі цифри, в новому отриманому числі знову додає всі цифри і так далі, доки чергова сума цифр не стане однозначним числом. Це число і характеризує щасливість дня. Дата зберігається в форматі ррррммдд у файлі. Збережіть рядок, який містить одне число, що визначає щасливість дати, у інший файл.",
    "inpdata": "Файл input.txt з вмістом\n20000101",
    "outdata": "Файл output.txt з вмістом\n4",
    "solution": "with open('input.txt', 'r') as file:\n    data = file.readline()\n    number = data    \n    while len(number) > 1: \n        s = 0\n        for i in number:\n            s += int(i)\n        number = str(s)\nwith open('output.txt', 'w') as file:\n    file.write(number)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "743",
    "title": "Напишіть програму для перевірки правильності пароля, введеного користувачем. Пароль має задовільняти таким вимогам: не менше 1 букви з проміжку [a-z] та 1 букви з порміжку [A-Z], принаймні 1 число з проміжку [0-9], не менше 1 символу з [$#@], мінімальна довжина 8 символів, максимальна довжина 12 символів. Використайте модуль re.",
    "inpdata": "12$FGasEr9\nqwerty\n45Da#0",
    "outdata": "Valid\nInvalid\nInvalid",
    "solution": "import re\npassword = input()\ndef valid_password(password):\n    result = True\n    if len(password) < 8 or len(password) > 12:\n        result = False\n    elif not re.search('[a-z]', password):\n        result = False\n    elif not re.search('[0-9]', password):\n        result = False\n    elif not re.search('[A-Z]', password):\n        result = False\n    elif not re.search('[$#@]', password):\n        result = False\n    elif re.search('\s', password):\n        result = False\n    return result\nif valid_password(password):\n    print('Valid')\nelse:\n    print('Invalid')",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "744",
    "title": "За правилами числа округлюються до найближчого цілого числа, а якщо дробова частина числа дорівнює 0.5, то число округляється вгору. Дано невід’ємне число x, яке необхідно округлити за цими правилами. Зверніть увагу, що функція round() не підходить для цього завдання! Використайте функції ceil() і floor() з математичного модуля math.",
    "inpdata": "3.4\n10.6",
    "outdata": "3\n11",
    "solution": "import math\na = float(input())\nb = math.ceil(a)\nif b - a <= 0.5:\n    print(math.ceil(a))\nelse:\n    print(math.floor(a))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "745",
    "title": "Напишіть програму для отримання списку лише файлів в поточному каталозі.",
    "inpdata": "Немає",
    "outdata": "Список файлів в поточному каталозі",
    "solution": "import os\nfiles_list = [f for f in os.listdir(os.getcwd()) if os.path.isfile(os.path.join(os.getcwd(), f))]\nprint(files_list)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "746",
    "title": "Напишіть програму, щоб отримати аргументи командного рядка (ім’я скрипту, кількість аргументів, аргументи), передані сценарію. Використайте модуль sys.",
    "inpdata": "C:\\Python36>python f1.py one two 3 four 5 6",
    "outdata": "Name/path of the script: f1.py\nNumber of arguments: 7\nArguments list: ['f1.py', 'one', 'two', '3', 'four', '5', '6']",
    "solution": "import sys\nscript_name = sys.argv[0]\nargs = sys.argv[1:]\nprint('Name/path of the script:', script_name)\nprint('Number of arguments:', len(sys.argv))\nprint('Arguments list:',str(sys.argv))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "747",
    "title": "Напишіть програму для зчитування випадкового рядка з текстового файла.",
    "inpdata": "Файл input.txt з вмістом\nPython\nRuby\nC++\nC\nJava\nGO",
    "outdata": "Java",
    "solution": "import random\ndef random_line(filename):\n    lines = open(filename, 'r').read().splitlines()\n    return random.choice(lines)\nfilename = input()   \nprint(random_line(filename))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "748",
    "title": "Напишіть програму для друку випадкової вибірки слів із текстового файла. Кількість слів має бути також випадковою в межах кількості рядків у файлі. Слова зберігаються у файлі на окремих рядках.",
    "inpdata": "Файл input.txt з вмістом\nPython\nRuby\nC++\nC\nJava",
    "outdata": "Java\nPython\nC++",
    "solution": "import random\nwith open('input.txt', 'rt') as file:\n    words = file.readlines()\nwords = [w.rstrip() for w in words]\nn = random.randint(1, len(words))\nfor w in random.sample(words, n):\n    print(w)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "749",
    "title": "Напишіть програму для розрахунку кількості днів між двома датами, використовуючи модуль datetime.",
    "inpdata": "2018\n8\n1\n2019\n3\n4",
    "outdata": "215",
    "solution": "from datetime import date\nfirst_year = int(input())\nfirst_month = int(input())\nfirst_day = int(input())\nfirst_date = date(first_year, first_month, first_day)\nlast_year = int(input())\nlast_month = int(input())\nlast_day = int(input())\nlast_date = date(last_year, last_month, last_day)\ndelta = last_date - first_date\nprint(delta.days)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "750",
    "title": "Напишіть програму для сортування файлів певного типу за датою в поточному каталозі. Тип файла вводиться у форматі як у вхідних даних.",
    "inpdata": "*.py",
    "outdata": "exercises.py\nnamespace.py\nsome_module.py\n1234.py\nlocales_print.py\nbottle.py",
    "solution": "import glob\nimport os\nextension = input()\nfiles = glob.glob(extension)\nfiles.sort(key=os.path.getmtime)\nprint('\\n'.join(files))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "751",
    "title": "Напишіть функцію для перевірки правильності введеної дати. Функція приймає 3 аргументи - день, місяць та рік і повертає True, якщо така дата є в календарі, і False в протилежному випадку. Використайте модуль datetime і конструкцію try/except.",
    "inpdata": "04\n03\n2029\n33\n11\n2019",
    "outdata": "True\nFalse",
    "solution": "def date_cheat(day, month, year):\n    import datetime\n    try:\n        datetime.date(year, month, day)\n    except ValueError:\n        return False\n    else:\n        return True\nday = int(input())\nmonth = int(input())\nyear = int(input())\nprint(date_cheat(day, month, year))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "752",
    "title": "Напишіть програму, щоб отримати дату/час створення та зміни файла в поточному каталозі. Використайте модулі os і time.",
    "inpdata": "input.txt",
    "outdata": "Last modified: Fri Jul 26 16:56:10 2019\nCreated: Tue Nov 13 17:05:54 2018",
    "solution": "import os, time\nfilename = input()\nprint('Last modified: {}'.format(time.ctime(os.path.getmtime(filename))))\nprint('Created: {}'.format(time.ctime(os.path.getctime(filename))))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "753",
    "title": "Напишіть програму для генерації всіх перестановок списку як у вихідних даних. Використайте модуль itertools.",
    "inpdata": "1 4 5",
    "outdata": "[(1, 4, 5), (1, 5, 4), (4, 1, 5), (4, 5, 1), (5, 1, 4), (5, 4, 1)]",
    "solution": "import itertools\nitems = map(int, input().split())\nprint(list(itertools.permutations(items)))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "754",
    "title": "Напишіть програму, яка обчислює і друкує час виконання (у секундах) для деякого фрагменту коду на Python, наприклад, для сумування чисел від 1 до n. Використайте модуль time.",
    "inpdata": "1000000",
    "outdata": "Required time to calculate sum of 1 to 1000000 (sum = 500000500000) is:    0.044 seconds.",
    "solution": "import time\ndef sum_of_n_numbers(n):\n    start_time = time.time()\n    s = 0\n    for i in range(1, n + 1):\n        s += i\n    end_time = time.time()\n    return s, end_time-start_time\n\nn = int(input())\nprint('Required time to calculate sum of 1 to {0:d} (sum = {1:d}) is: {2:8.3f} seconds.'.format(n, sum_of_n_numbers(n)[0], sum_of_n_numbers(n)[1]))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "755",
    "title": "Напишіть функцію для читання перших n рядків файлу.",
    "inpdata": "input.txt\n2",
    "outdata": "['Python\\n', 'Ruby\\n']",
    "solution": "def read_n_lines(fname, n_of_lines):\n    list_of_lines = []\n    with open(fname, 'r') as f:\n        for i in range(n_of_lines):\n            list_of_lines.append(f.readline())\n    return list_of_lines\nfilename = input()\nn = int(input())  \nprint(read_n_lines(filename, n))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "756",
    "title": "Напишіть функцію для додавання до текстового файла рядка в кінець файла і виведення вмісту файла.",
    "inpdata": "input.txt\nGO",
    "outdata": "Python\nRuby\nC++\nC\nJava\nGO",
    "solution": "def append_to_file(filename, s):\n    with open(filename, 'a') as file:\n        file.write(s)\n    with open(filename, 'r') as file:\n        data = file.read()\n        print(data)\nfilename = input()\ns = input()\nappend_to_file(filename, s)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "757",
    "title": "Напишіть програму для зчитування останніх n рядків файла.",
    "inpdata": "input.txt\n3",
    "outdata": "C\nJava\nGO",
    "solution": "def rlines(f, n):\n    with open(f, 'r') as file:\n        for line in (file.readlines()[-n:]):\n            print(line.strip())\nfilename = input()\nn = int(input())\nrlines(filename, n)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "758",
    "title": "Напишіть функцію для підрахунку частоти слів у файлі.",
    "inpdata": "input.txt",
    "outdata": "{'Python': 1, 'Ruby': 1, 'C++': 1, 'C': 1, 'Java': 1, 'GO': 1}",
    "solution": "def count_words(filename):\n    with open(filename, 'r') as file:\n        text = file.read()\n        words = text.split()\n    wordscount = {}\n    for word in words:\n        wordscount[word] = words.count(word)\n    return wordscount\nfilename = input()\nprint(count_words(filename))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "759",
    "title": "Дано текстовий файл, що містить рядки цілих чисел, по одному в рядку. Напишіть функцію, яка зчитує всі числа, що зберігаються у файлі, та обчислює їх суму.",
    "inpdata": "input.txt",
    "outdata": "45",
    "solution": "def sum_numbers_in_file(filename):\n    with open(filename, 'r') as file:\n        total = 0\n        numbers = file.readlines()\n        for number in numbers:\n            item = int(number.rstrip('\\n'))\n            total += item\n    return total\nfilename = input()       \nprint(sum_numbers_in_file(filename))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "760",
    "title": "Дано текстовий файл, що містить рядки дійсних чисел, по одному в рядку. Напишіть функцію, яка зчитує всі числа, що зберігаються у файлі, та обчислює їх середнє значення. Результат має виводитись із двома знаками після десяткової крапки.",
    "inpdata": "input.txt",
    "outdata": "7.78",
    "solution": "def average_numbers_in_file(filename):\n    with open(filename, 'r') as file:\n        total = 0\n        i = 0\n        numbers = file.readlines()\n        for number in numbers:\n            item = float(number.rstrip('\\n'))\n            total += item\n            i += 1\n    return total / i\nfilename = input()       \nprint(format(average_numbers_in_file(filename), '.2f'))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "761",
    "title": "Напишіть програму для запису послідовності у текстовий файл і зчитування її з файлу.",
    "inpdata": "Python Ruby C++ C Java Go JavaScript",
    "outdata": "Python\nRuby\nC++\nC\nJava\nGo\nJavaScript",
    "solution": "items = input().split()\nwith open('output.txt', 'w') as file:\n    for item in items:\n        file.write('{0:}\\n'.format(item))\nwith open('output.txt', 'r') as file:\n    print(file.read())",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "762",
    "title": "Напишіть програму для копіювання вмісту тектового файлу в інший текстовий файл.",
    "inpdata": "input.txt\noutput.txt",
    "outdata": "Немає",
    "solution": "def from_file_to_file(filename1, filename2):\n    with open(filename1, 'r') as rfile:\n        lines = rfile.read()\n    with open(filename2, 'w') as wfile:\n        wfile.write(lines)\nfilename1 = input()\nfilename2 = input()\nfrom_file_to_file(filename1, filename2)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "763",
    "title": "Текстовий файл містить список номерів рахунків компанії. Кожен номер рахунку має всім цифр, наприклад, 56588459. Напишіть програму, яка визначає чи є номер, введений користувачем, у файлі. Якщо номер у списку, друкується відповідне повідомлення, що номер дійсний. Якщо номер відсутній у списку, програма виводить повідомлення про те, що номер недійсний.",
    "inpdata": "input.txt\n46221213\ninput.txt\n12345678",
    "outdata": "found\nnot found",
    "solution": "def numbers_from_file_to_list(lines):\n    accounts_list = []\n    index = 0\n    for line in lines:\n        line = line.rstrip('\\n')\n        accounts_list.append(line)\n    return accounts_list\ndef valid_accounts(accounts_list, user_number):\n    if user_number in accounts_list:\n        return 'found'\n    return 'not found'\nfilename = input()\nuser_number = input()\nwith open(filename, 'r') as file:\n    lines = file.readlines()\n    accounts_list = numbers_from_file_to_list(lines)\n    print(valid_accounts(accounts_list, user_number))",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "764",
    "title": "Напишіть функцію для друку вмісту текстового файла порядково. На початку кожного надрукованого рядка має бути номер рядка, а потім - двокрапка як у вихідних даних. Нумерація рядків починається з 1.",
    "inpdata": "input.txt",
    "outdata": "1 : Python\n2 : Ruby\n3 : C++\n4 : C\n5 : Java\n6 : GO",
    "solution": "def read_file(filename):\n    with open(filename, 'r') as file:\n        lines = file.readlines()\n        line_number = 1\n        for line in lines: \n            print(line_number, ':', line.strip())\n            line_number += 1\nfilename = input()       \nread_file(filename)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "765",
    "title": "Визначте, чи є у вхідному файлі символ n. Запишіть слово \"YES\" або \"NO\" у вихідний файл. Вхідний файл може бути дуже великим, тому зчитувати файл потрібно посимвольно.",
    "inpdata": "Файл input.txt з вмістом\nCимвол n, який шукається",
    "outdata": "Файл output.txt з вмістом YES чи NO",
    "solution": "n = input()\nwith open('input.txt', 'r') as filein, open('output.txt', 'w') as fileout:\n    result = False \n    c = None\n    while c != '':\n        c = filein.read(1)\n        if c == n:    \n            result = True\n            break\n    if result:\n        print('YES', file=fileout)\n    else:\n        print('NO', file=fileout)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "766",
    "title": "Дано відомості про найпопулярніші виші серед абітурієнтів за кількістю заяв від вступників. Напишіть функцію, яка записує цю інформацію порядково у текстовий файл у форматі \"назва вишу, кількість заяв від вступників\". Спочатку користувач вказує ім’я файла і кількість вишів n, після чого вводяться дані як у вхідних даних.",
    "inpdata": "rating.txt\n3\nKyiv National Taras Shevchenko University\n42354\nLviv Ivan Franko National University\n37380\nNational Technical University of Ukraine \"Igor Sikorsky Kiev Polytechnic Institute\"\n36371",
    "outdata": "Файл rating.txt з вмістом\nKyiv National Taras Shevchenko University, 42354\nLviv Ivan Franko National University, 37380\nNational Technical University of Ukraine \"Igor Sikorsky Kiev Polytechnic Institute\", 36371",
    "solution": "def top_universities(filename, n):\n    with open(filename, 'w') as file:\n        for i in range(n):\n            university = input()\n            entrants = int(input())\n            print(university + ',', str(entrants), file=file)\nfilename = input() \nn = int(input())\ntop_universities(filename, n)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "767",
    "title": "Напишіть функцію, яка обробляє винятки IOError, які виникають при відкритті файла.",
    "inpdata": "input.txt\n123456.py",
    "outdata": "OK\nDone\nCaught the I/O error\nDone",
    "solution": "def error_open_file(filename):\n    try:\n        file = open(filename, 'r')\n    except IOError as e:\n        print('Caught the I/O error')\n    else:\n        file.close()\n        print('OK')\n    finally:\n        print('Done')\nfilename = input()\nerror_open_file(filename)",
    "chapter": "файли і модулі",
    "level": "середній"
  },
  {
    "id": "768",
    "title": "Ціна товару позначена в гривнях з точністю до копійок, тобто дійсним числом з двома цифрами після десяткової крапки. Запишіть у дві цілочисельні змінні вартість товару у вигляді цілого числа гривень і цілого числа копійок і виведіть їх. При вирішенні цього завдання не можна користуватися умовними інструкціями і циклами. Примітка. При роботі з числами з плаваючою крапкою (тобто float) в результаті обчислень можна отримати не зовсім той результат, на який очікуємо, наприклад, number = 0.1 + 0.1 + 0.1, то при використанні команди print(number) результатом буде число 0.30000000000000004. Для розв’язування поданої задачі використайте вбудований у Python модуль decimal.",
    "inpdata": "24.45\n3.5\n102.55",
    "outdata": "24 45\n3 50\n102 55",
    "solution": "from decimal import Decimal\nprice = Decimal(input())\nu = int(price)\nc = int(round(int(price * 100) % 100) + 0.5)\nprint(u, c)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "769",
    "title": "Зчитайте рядки у вхідному файлі і запишіть у вихідний файл ті рядки, які є найдовшими у вхідному файлі, не змінюючи їх порядок.",
    "inpdata": "Файл input.txt з вмістом\nThree\nThirty eight\nSeven\nSix\nThirty three",
    "outdata": "Файл output.txt з вмістом\nThirty eight\nThirty three",
    "solution": "with open('input.txt', 'r') as filein, open('output.txt', 'w') as fileout:\n    lines = filein.readlines()\n    long_line = max(lines, key=len).strip('\\n')\n    for line in lines:\n        result = line.strip('\\n')        \n        if len(long_line) == len(result):    \t\n            print(result, file=fileout)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "770",
    "title": "Напишіть функцію для зчитування рядків з текстового файла і видалення у зчитаних рядках символів нового рядка \\n.",
    "inpdata": "input.txt",
    "outdata": "['Python', 'Ruby', 'C++', 'C', 'Java', 'GO']",
    "solution": "def remove_newlines(filename):\n    lines = open(filename, 'r').readlines()\n    return [line.rstrip('\\n') for line in lines]\nfilename = input()\nprint(remove_newlines(filename))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "771",
    "title": "Створіть дві функції: перша генерує n випадкових цифр для лотереї з діапазону від 0 до 9 включно, а друга функція отримує згенеровані цифри і записує у файл на окремих рядках.",
    "inpdata": "lottery.txt\n5",
    "outdata": "Файл lottery.txt з вмістом\n3\n5\n1\n3\n7",
    "solution": "import random\ndef lottery(n):\n    lottery_numbers = []\n    for i in range(n):\n        lottery_numbers.append(random.randrange(0, 10))\n    return lottery_numbers\ndef lottery_number_to_file(filename, lottery_numbers):\n    with open(filename, 'w') as file:\n        for number in lottery_numbers:\n            print(number, file=file)\nfilename = input()\nn = int(input())\nlottery_number_to_file(filename, lottery(n))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "772",
    "title": "Напишіть програму, яка визначає розмір файла в поточному каталозі і друкує значення в байтах. Якщо файла із вказаним ім’ям немає, генерується виняток.",
    "inpdata": "f1.py\ninput.txt\n14.py",
    "outdata": "f1.py 39737 Bytes\ninput.txt 6 Bytes\nTypeError: not file",
    "solution": "import os\nfile_name = input()\npath = os.path.abspath(file_name)\nif not os.path.isfile(path):\n    raise TypeError('not file')\nelse:\n    file_size = os.path.getsize(path)\n    print('{0:} {1:} Bytes'.format(file_name, file_size))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "773",
    "title": "Кодування довжин послідовностей - це базовий алгоритм стиснення даних. Реалізуйте найпростіший його варіант. На вхід алгоритму подається рядок, що містить символи латинського алфавіту. Цей рядок розбивається на групи однакових символів, що йдуть підряд (\"серії\"). Кожна серія характеризується періодичним символом і кількістю повторень. Саме ця інформація і записується в код: спочатку пишеться довжина серії повторюваних символів, потім сам символ. У серій довжиною в один символ кількість повторень будемо опускати. Наприклад, розглянемо рядок \"aaabccccCCaB\". Розкладемо його на серії: \"aaa\", \"b\", \"cccc\", \"CC\", \"a\", \"B\". Після чого закодуємо серії і отримаємо підсумковий рядок, який і будемо вважати результатом роботи алгоритму: \"3ab4c2CaB\". Для розв’язування задачі використайте модуль itertools.",
    "inpdata": "aaabccccCCaB",
    "outdata": "3ab4c2CaB",
    "solution": "import itertools\ndata = input()\ngroups = []\nuniquekeys = []\nfor k, g in itertools.groupby(data, None):\n    groups.append(list(g))      \n    uniquekeys.append(k)\nresult = ''\nfor item in groups:\n    length_group = len(item)\n    if length_group > 1:\n        result += str(length_group) + item[0]\n    else:\n        result += item[0]\nprint(result)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "774",
    "title": "У текстовому файлі порядково записані адреси електронної пошти у форматі user@company.com. Напишіть функцію, яка друкує імена користувача і компанії вказаної адреси електронної пошти. Використайте модуль re.",
    "inpdata": "input.txt",
    "outdata": "[('sddret1996', 'gmail'), ('protuas', 'yahoo'), ('gendalf15', 'gmail')]",
    "solution": "import re\ndef read_lines_from_file():\n    filename = input()\n    with open(filename, 'r') as file:\n        lines = file.readlines()\n    return lines\ndef parse_email_from_file(lines):\n    data = []\n    pattern_name = \"(\w+)@((\w+\.)+(com))\"\n    pattern_company = \"(\w+)@(\w+)\.(com)\"\n    for line in lines:\n        item = line.strip()\n        name = re.match(pattern_name, item)\n        company = re.match(pattern_company, item)\n        data.append((name.group(1), company.group(2)))\n    return data           \nprint(parse_email_from_file(read_lines_from_file()))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "775",
    "title": "У текстовому файлі записаний текст, в якому зустрічаються адреси електронної пошти у форматі user@company.com. Напишіть функцію, яка шукає усі адреси електронної пошти у тексті файла. Використайте модуль re.",
    "inpdata": "input.txt",
    "outdata": "{'alex99@gmail.com', 'gethamg19@gmail.com', 'neera@gmail.com'}",
    "solution": "import re\ndef read_lines_from_file():\n    filename = input()\n    with open(filename, 'r') as file:\n        lines = file.readlines()\n    return lines\ndef parse_email_from_file(lines):\n    emails = set()\n    for line in lines:\n        item = line.strip()\n        data = re.findall('\S+@\S+?\.\S{2,3}', item)\n        for el in data: \n            emails.add(el)\n    return emails   \nprint(parse_email_from_file(read_lines_from_file()))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "776",
    "title": "Місяцю з n днів відповідає лінійна таблиця елементів, в якій робочий день позначено 1, а неробочий - 0. Скласти алгоритм, який підраховує: кількість тижнів в місяці; кількість робочих днів в кожному з тижнів місяця. Примітка. Тижнем будемо називати довільну не порожню множину одиниць між двома послідовними нулями або обмежену нулем праворуч (якщо місяць починається з робочого дня), або обмежену нулем ліворуч (якщо місяць не закінчується робочим днем). У вхідному файлі перший рядок містить ціле n - кількість днів, а в наступному рядку n чисел, які визначають робочі і неробочі дні (1 ≤ n ≤ 1000000). У вихідному файлі у першому рядку виведіть одне число k, яке визначає кількість тижнів, в наступному рядку k чисел, які визначають кількість робочих днів.",
    "inpdata": "Файл input.txt з вмістом\n5\n1 1 0 1 0",
    "outdata": "Файл output.txt з вмістом\n2\n2 1",
    "solution": "with open('input.txt', 'r') as file:\n    data = file.readlines()\n    days = ''.join(data[1].strip().split(' '))\n    k = 0 # кількість робочих днів    \n    workdays = []\n    for day in days:\n        if day == '1':\n            k += 1\n        elif day == '0' and k != 0:\n            workdays.append(k)\n            k = 0 \n    if k != 0:\n        workdays.append(k)        \nwith open('output.txt', 'w', encoding='utf-8') as file:\n        file.write('{}\\n'.format(str(len(workdays)))) # кількість тижнів\n        for item in workdays:\n            file.write('{} '.format(str(item)))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "777",
    "title": "Напишіть функцію, яка записує у текстовий файл рядок випадкових цілих чисел. Кожне випадкове число повинно бути в діапазоні від 1 до 1000. Користувач вказує n - кількість випадкових чисел, які файл буде зберігати.",
    "inpdata": "output.txt\n3",
    "outdata": "Файл output.txt має містити 3 випадкові числа з діапазону від 1 до 1000 включно",
    "solution": "import random\ndef random_numbers_write_to_file(filename, n):\n    with open(filename, 'w') as file:\n        for i in range(n):\n            number = random.randrange(1, 1001)\n            number = str(number)\n            file.write(number)\n            file.write('\\n')\nfilename = input()       \nn = int(input())\nrandom_numbers_write_to_file(filename, n)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "778",
    "title": "Напишіть програму для гри \"Вгадай число\". Комп’ютер випадковим чином \"загадує\" число із певного, наперед заданого, діапазону, а користувач має його відгадати.",
    "inpdata": "Guess the number: 45\nGuess the number: 89",
    "outdata": "My number is more\nCongratulations! Number guessed!",
    "solution": "from random import randint\na = randint(1, 100)\nb = int(input('Guess the number: '))\nwhile a != b:\n    if a > b:\n        print('My number is more')\n    else:\n        print('My number is less')\n    b = int(input('Guess the number: ')) \nprint('Congratulations! Number guessed!')",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "779",
    "title": "Напишіть програму для розрахунку вашого віку в поточному році для введеної дати народження. Використайте модуль datetime.",
    "inpdata": "1981\n4\n3",
    "outdata": "38",
    "solution": "from datetime import date\ndef how_old_are_you(date_of_birth):\n    today = date.today()\n    return today.year - date_of_birth.year - ((today.month, today.day) < (date_of_birth.month, date_of_birth.day))\nyear = int(input())\nmonth = int(input())\nday = int(input())\nprint(how_old_are_you(date(year, month, day)))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "780",
    "title": "У вхідному файлі записаний текст. Словом вважається послідовність непробільних символів, що йдуть підряд, слова розділені одним або більшим числом пропусків або символами кінця рядка. Визначте, скільки різних слів міститься в цьому тексті.",
    "inpdata": "Вхідний файл input.txt з вмістом\nShe sells sea shells on the sea shore;\nThe shells that she sells are sea shells I'm sure.\nSo if she sells sea shells on the sea shore,\nI'm sure that the shells are sea shore shells.",
    "outdata": "19",
    "solution": "with open('input.txt', 'r') as file:\n    lines = file.readlines()\nwords = {}\nfor line in lines:\n    for word in line.split():\n        if word not in words:\n            words.setdefault(word, 1)\nprint(len(words))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "781",
    "title": "Напишіть програму для знаходження у текстовому файлі найдовшого слова.",
    "inpdata": "Вхідний файл input.txt з вмістом\nPython\nRuby\nC++\nC\nJava\nGO",
    "outdata": "Python",
    "solution": "filename = input()\nwith open(filename, 'r') as file:\n    words = {}\n    for line in file.readlines():\n        line = line.split()\n        words.update({len(w): w for w in line})\nprint(words[max(words.keys())])",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "782",
    "title": "Напишіть програму для створення паролів, яка дозволяє створювати k паролів довжини n з цифр та малих і велих англійських букв. На вхід програми дані вводяться в порядку n і k.",
    "inpdata": "5\n3",
    "outdata": "KdSsv\n5u8nF\nYQjG2",
    "solution": "import random \nchars = 'abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\nlength = int(input())\nk = int(input())\nfor p in range(k):\n    password = ''\n    for c in range(length):\n        password += random.choice(chars)\n    print(password)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "783",
    "title": "Напишіть програму для визначення різниці часу між двома датами: вказаною (минулою чи майбутньою) і поточною. Використайте модуль datetime. Дата вказується у двох рядках: у першому - \"Рік Місяць День\", у другому - \"Години Хвилини Секунди\". Усі значення вводяться через пропуск як у вхідних даних.",
    "inpdata": "2020 7 26\n22 04 00",
    "outdata": "365 days, 23 hours, 59 minutes, 54 seconds",
    "solution": "from datetime import datetime, time\n\ndef date_diff_in_seconds(dt2, dt1):\n    timedelta = abs(dt2 - dt1)\n    return timedelta.days * 24 * 3600 + timedelta.seconds\n  \ndef dhms_from_seconds(seconds):\n    minutes, seconds = divmod(seconds, 60)\n    hours, minutes = divmod(minutes, 60)\n    days, hours = divmod(hours, 24)\n    return (days, hours, minutes, seconds)\n\nd = input().split()\nt = input().split()\ndate1 = datetime.strptime('-'.join(d) + ' ' + ':'.join(t), '%Y-%m-%d %H:%M:%S')\ndate2 = datetime.now()\nresult = dhms_from_seconds(date_diff_in_seconds(date2, date1))\nprint('{0:} days, {1:} hours, {2:} minutes, {3:} seconds'.format(result[0], result[1], result[2], result[3]))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "784",
    "title": "Дано два текстові файли: в першому записані в рядках назви мов програмування, а у іншому на відповідних рядках - рейтинги цих мов у відсотках. Напишіть програму для об’єднання кожного рядка з першого файлу з відповідним рядком у другому файлі. Об’єднанані рядки необхідно вивести на екран і, водночас, в такому вигляді як у вихідних даних, записати у третій текстовий файл.",
    "inpdata": "input.txt\noutput.txt\nrating.txt",
    "outdata": "Python 10.9\nRuby 2.9\nC++ 6.5\nC 1.6\nJava 17.8\nGO 1.8",
    "solution": "filename1 = input()\nfilename2 = input()\nfilename3 = input()\nwith open(filename1, 'r') as f1, open(filename2, 'r') as f2, open(filename3, 'w') as f3:\n    for lines in zip(f1, f2):\n        lang = lines[0].strip()\n        rate = lines[1].strip()\n        print(lang, rate)\n        print(lang, rate, file=f3)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "785",
    "title": "Напишіть програму для сортування даних про студентів, які записані у рядках файла через кому і пропуск у форматі: ім’я (рядок), вік (ціле число), зріст (дійсне число, два символи після десяткової крапки). Виконайте сортування за зростом в порядку зростання. Використайте модуль operator.",
    "inpdata": "input.txt",
    "outdata": "[('Alex', '17', '179.50'), ('Tom', '19', '180.10'), ('John', '20', '181.00')]",
    "solution": "from operator import itemgetter\ndef read_lines_from_file():\n    filename = input()\n    with open(filename, 'r') as file:\n        lines = file.readlines()\n    return lines\ndef sorting(lines):    \n    data = []\n    for line in lines:\n        item = line.strip()\n        data.append(tuple(item.split(', ')))\n    return sorted(data, key=itemgetter(1))\nlines = read_lines_from_file()\nprint(sorting(lines))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "786",
    "title": "Відомості про учня, записані у файлі input.txt, складаються з його прізвища і назви класу (рік навчання і буква без пропуску), а також оцінок, отриманих за семестр, у форматі: \"Прізвище Клас Оцінки\". Число оцінок в різних класах може бути різним. Запишіть у файл output.txt прізвища тих учнів, середній бал яких більше, ніж 6.",
    "inpdata": "Вхідний файл input.txt з вмістом\nBarnes 9A 4 5 7 2 3 2\nDavidson 10A 7 7 5\nClifford 11B 11 10 8 9 7\nRamacey 8A 5 6 6 5\nWhite 7A 8 5 5 8 9\nPorter 11A 11 8\nDean 10B 3 4 5 4 5\nGate 11A 6 5 3 4 3 5",
    "outdata": "Вихідний файл output.txt з вмістом\nDavidson\nClifford\nWhite\nPorter",
    "solution": "with open('input.txt', 'r') as outfile, open('output.txt', 'w') as infile:\n    lines = outfile.readlines()\n    for line in lines:\n        item = line.split()\n        points = list(map(int, item[2:]))\n        average = sum(points) / len(points)\n        if average > 6:\n            print(item[0], file=infile, end='\\n')",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "787",
    "title": "У вхідному файлі записаний текст. Словом вважається послідовність непробільних символів, що йдуть підряд, слова розділені одним або більшим числом пропусків або символами кінця рядка. Для кожного слова з цього тексту підрахуйте, скільки разів воно зустрічалося в цьому тексті раніше.",
    "inpdata": "Вхідний файл input.txt з вмістом\nShe sells sea shells on the sea shore;\nThe shells that she sells are sea shells I'm sure.\nSo if she sells sea shells on the sea shore,\nI'm sure that the shells are sea shore shells.",
    "outdata": "0 0 0 0 0 0 1 0 0 1 0 0 1 0 2 2 0 0 0 0 1 2 3 3 1 1 4 0 1 0 1 2 4 1 5 0 0",
    "solution": "with open('input.txt', 'r') as file:\n    lines = file.readlines()\nwords = {}\nresult = []\nfor line in lines:\n    for word in line.split():\n        if word in words:\n            words[word] += 1\n        else:\n            words.setdefault(word, 0)\n        result.append(words[word])\nprint(*result)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "788",
    "title": "Напишіть функцію, яка вибирає випадкове слово з переліку слів із словника SOWPODS (завантажити з http://norvig.com/ngrams/sowpods.txt). Кожен рядок у файлі містить одне слово.",
    "inpdata": "sowpods.txt",
    "outdata": "MACAHUBA",
    "solution": "import random\ndef get_word_from_sowpods(filename):\n    words = []\n    with open(filename, 'r') as file:\n        line = file.readline().strip()\n        words.append(line)\n        while line:\n            line = file.readline().strip()\n            words.append(line)\n        random_index = random.randint(0, len(words))\n    return words[random_index]\nfilename = input()\nprint(get_word_from_sowpods(filename))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "789",
    "title": "Деякий банк хоче впровадити систему управління рахунками клієнтів, що підтримує такі операції: поповнення рахунку клієнта, зняття грошей з рахунку, запит залишку коштів на рахунку, переказ грошей між рахунками клієнтів, нарахування відсотків всім клієнтам. Вам необхідно реалізувати таку систему. Клієнти банку ідентифікуються іменами (унікальний рядок, що не містить пропусків). Спочатку у банку немає жодного клієнта. Як тільки для клієнта проводиться операція поповнення рахунку, зняття або переказу грошей, йому заводиться рахунок з нульовим балансом. Всі подальші операції проводяться тільки з цим рахунком. Сума на рахунку може бути як додатною, так і від’ємною, при цьому завжди є цілим числом. Вхідний файл містить послідовність операцій. Можливі такі операції: 1) \"DEPOSIT name sum\" - зарахувати суму sum на рахунок клієнта name. Якщо у клієнта немає рахунку, то рахунок створюється. 2) \"WITHDRAW name sum\" - зняти кошти sum з рахунку клієнта name. Якщо у клієнта немає рахунку, то рахунок створюється. 3) \"BALANCE name\" - дізнатися залишок коштів на рахунку клієнта name. 4) \"TRANSFER name1 name2 sum\" - перевести суму sum з рахунку клієнта name1 на рахунок клієнта name2. Якщо у будь-якого клієнта немає рахунку, то йому створюється рахунок. 5) \"INCOME p\" - нарахувати всім клієнтам, у яких відкриті рахунки, p% від суми на рахунку. Відсотки нараховуються тільки клієнтам з додатним залишком на рахунку, якщо у клієнта залишок від’ємний, то його рахунок не змінюється. Після нарахування відсотків сума на рахунку залишається цілою, тобто нараховується тільки ціле число грошових одиниць. Дробова частина нарахованих відсотків відкидається. Для кожного запиту \"BALANCE\" програма повинна вивести залишок на рахунку даного клієнта. Якщо ж у клієнта із запитуваним ім’ям не відкритий рахунок в банку, виведіть \"ERROR\".",
    "inpdata": "Вхідний файл input.txt з вмістом\nDEPOSIT Sasha 100\nINCOME 5\nBALANCE Sasha\nTRANSFER Sasha Elena 50\nWITHDRAW Elena 100\nBALANCE Elena\nBALANCE Iryna",
    "outdata": "105\n-50\nERROR",
    "solution": "def deposit(name, amount):\n    if name not in transactions:\n        transactions.setdefault(name, 0)    \n    transactions[name] += int(amount)\n    \ndef withdraw(name, amount):\n    if name not in transactions:\n        transactions.setdefault(name, 0)    \n    transactions[name] -= int(amount)\n \ndef balance(name):\n    if name not in transactions:\n        return 'ERROR'\n    else:\n        return transactions[name]\n\ndef transfer(from_name, to_name, amount):\n    if from_name not in transactions:\n        transactions.setdefault(from_name, 0)    \n    if to_name not in transactions:\n        transactions.setdefault(to_name, 0)    \n    \n    transfer_amount = int(amount)\n    transactions[from_name] -= transfer_amount\n    transactions[to_name] += transfer_amount\n\ndef income(rate):\n    for client in transactions:\n        if transactions[client]  > 0:\n            transactions[client] += int(transactions[client] * (int(rate) / 100 ))    \n\ntransactions = {}\n\nwith open('input.txt', 'r') as file:\n    lines = file.readlines()\n\nfor line in lines:\n    transaction, *account = line.split()\n\n    if transaction == 'DEPOSIT':\n        deposit(account[0], account[1])\n\n    if transaction == 'WITHDRAW':\n        withdraw(account[0], account[1])\n\n    if transaction == 'BALANCE':\n        print(balance(account[0]))\n  \n    if transaction == 'TRANSFER':\n        transfer(account[0], account[1], account[2])\n    \n    if transaction == 'INCOME':\n        income(account[0])",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "790",
    "title": "Як відомо, в США президент обирається не прямим голосуванням, а шляхом дворівневого голосування. Спочатку проводяться вибори в кожному штаті і визначається переможець виборів в даному штаті. Потім проводяться державні вибори: на цих виборах кожен штат має певну кількість голосів - число вибірників від цього штату. На практиці, всі виборці від штату голосують відповідно до результатів голосування в межах штату, тобто на заключній стадії виборів в голосуванні беруть участь штати, що мають різне число голосів. Вам відомо за кого проголосував кожен штат і скільки голосів було віддано даними штатом. Підведіть підсумки виборів: для кожного з учасника голосування визначте число відданих за нього голосів. Кожен рядок вхідного файлу містить прізвище кандидата, за якого віддають голоси виборці цього штату, потім через пропуск йде кількість голосів, які віддали за цього кандидата. Виведіть прізвища всіх кандидатів в лексикографічному порядку, потім, через пропуск, кількість відданих за них голосів.",
    "inpdata": "Вхідний файл input.txt з текстом\nBiden 10\nBiden 5\nTrump 9\nTrump 8\nBiden 1",
    "outdata": "Biden 16\nTrump 17",
    "solution": "with open('input.txt', 'r') as file:\n    lines = file.readlines()\ncandidats = {}\nfor line in lines:\n    candidat, vote = line.split()\n    if candidat in candidats:\n        candidats[candidat] += int(vote)\n    else:\n        candidats.setdefault(candidat, int(vote))\nfor k in sorted(candidats.keys()):\n    print(k, candidats[k])",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "791",
    "title": "Дано базу даних про продажі деякого інтернет-магазину. Кожен рядок вхідного файлу є записом виду \"Покупець Товар Кількість\", де \"Покупець\" - ім’я покупця (рядок без пропусків), \"Товар\" - назва товару (рядок без пропусків), \"Кількість\" - кількість придбаних одиниць товару. Створіть список всіх покупців, а для кожного покупця підрахуйте кількість придбаних ним одиниць кожного виду товарів. Вводяться відомості про покупки в зазначеному форматі як у вхідних даних. Виведіть список всіх покупців в лексикографічному порядку, після імені кожного покупця виведіть двокрапка, потім виведіть список назв всіх придбаних даними покупцем товарів в лексикографічному порядку, після назви кожного товару виведіть кількість одиниць товару, придбаних даними покупцем. Інформація про кожен товар виводиться в окремому рядку.",
    "inpdata": "Вхідний файл input.txt з текстом\nSasha paper 10\nIryna pens 5\nSasha marker 3\nSasha paper 7\nIryna envelope 20\nSasha envelope 5",
    "outdata": "Iryna:\nenvelope 20\npens 5\nSasha:\nenvelope 5\nmarker 3\npaper 17",
    "solution": "with open('input.txt', 'r') as file:\n    lines = file.readlines()\n\nclients = {}\n\nfor line in lines:\n    client, thing, value = line.split()\n    if client not in clients:\n        clients.setdefault(client, {})\n\n    item = clients[client].get(thing)\n    if item:\n        clients[client].update({thing: item + int(value)})\n    else:\n        clients[client].update({thing: int(value)})\n\nfor client in sorted(clients):\n    print(client + ':')\n    for thing in sorted(clients[client]):\n        print(thing, clients[client][thing])",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "792",
    "title": "Дано текст у файлі. Виведіть всі слова, що зустрічаються в тексті, по одному на кожен рядок. Слова повинні бути відсортовані за спаданням їх кількості появи в тексті, а при однаковій частоті появи - в лексикографічному порядку. Примітка. Після того, як ви створите словник усіх слів, вам захочеться впорядкувати його по частоті слова. Бажаного можна домогтися, якщо створити список, елементами якого будуть кортежі з двох елементів: частота зустрічальності слова і саме слово. Наприклад, [(2, 'hi'), (1, 'what'), (3, 'is')]. Тоді стандартне сортування буде сортувати список кортежів, при цьому кортежі порівнюються по першому елементу, а якщо ці елементи рівні - то по другому.",
    "inpdata": "Вхідний файл input.txt з текстом\nhi\nhi\nwhat is your name\nmy name is bond\njames bond\nmy name is damme\nvan damme\nclaude van damme\njean claude van damme",
    "outdata": "damme\nis\nname\nvan\nbond\nclaude\nhi\nmy\njames\njean\nwhat\nyour",
    "solution": "with open('input.txt', 'r') as file:\n    lines = file.readlines()\ndata = {}\nfor line in lines:\n    for word in line.split():\n        if word not in data:\n            data.setdefault(word, 1)\n        else:\n            data[word] += 1\nfrequency = []\nfor word, c in data.items():\n    frequency.append([-c, word])\nfor c, word in sorted(frequency):\n     print(word)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "793",
    "title": "\"Камінь, ножиці, папір\" - популярна гра руками, відома в багатьох країнах і часто використовується для жеребкування. Напишіть програму, яка визначає переможця у грі комп’ютера та людини, за наступним алгоритмом: 1. Комп’ютер «загадує» ціле випадкове число в діапазоні від 0 до 2. 2. Гравець робить свій вибір, уводячи число 0, 1 або 2. 3. Виводиться повідомлення про вибір комп’ютера та вибір гравця. 4. За правилами гри визначається переможець. 5. Виводиться повідомлення про перемогу або нічию.",
    "inpdata": "0 stone\n1 scissors\n2 paper\n0-1-2 -> 2\nСontinue? (y/n) y\n0-1-2 -> 1\nСontinue? (y/n) n",
    "outdata": "Computer chose paper\ndraw\nComputer chose paper\nyou won!\nThanks for game!",
    "solution": "from random import randint\nchoice = ['stone', 'scissors', 'paper']\nfor i in range(3):\n    print(i, choice[i])\ngame = 'y'\nwhile game != 'n':\n    comp = randint(0, 2)    \n    x = int(input('0-1-2 -> '))\n    your_choice = choice[x]\n    comp_choice = choice[comp]\n    print('Computer chose', comp_choice)\n    if comp == 0:\n        if x == 0:\n            print('draw')\n        elif x == 1:\n            print('computer won')\n        else:\n            print('you won!')\n    elif comp == 1:\n        if x == 1:\n            print('draw')\n        elif x == 2:\n            print('computer won')\n        else:\n            print('you won!')\n    elif comp == 2:\n        if x == 2:\n            print('draw')\n        elif x == 0:\n            print('')\n        else:\n            print('you won!')\n    game = input('Сontinue? (y/n) ')\nprint('Thanks for game!')",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "794",
    "title": "Напишіть програму, яка зчитує вміст текстового файлу, підраховує кількість появи кожного слова (неперервний рядок символів) у файлі і записує в інший файл як у вихідних даних.",
    "inpdata": "Текстовий файл input.txt з довільним текстом",
    "outdata": "Текстовий файл output.txt з подібним змістом\nyou 2\ndon't 1\nknow 1\nabout 2\nme 1\nwithout 2",
    "solution": "def read_lines_from_file():\n    filename = input()    \n    with open(filename, 'r') as file:\n        lines = file.readlines()\n        return lines\ndef count_words(lines):\n    word_frequency = {}\n    for line in lines:\n        words = line.split()\n        for word in words:\n            word = word.lower()\n            if word not in word_frequency:\n                word_frequency[word] = 0\n            word_frequency[word] += 1\n    return word_frequency\nprint(count_words(read_lines_from_file()))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "795",
    "title": "Вам запропонували створити програму, яка допоможе у перевірці робіт теоретичного іспиту з правил дорожнього руху. Іспит складається з 20 варіантів запитань, в кожному з яких відповідями є лише одне значення із списку: A, B, C, D. Програма повинна прочитати відповіді студента на кожне з 20 питань з текстового файлу (відповіді розташовуються на окремих рядках). Після того, як відповіді були прочитані з файлу, програма повинна відображати повідомлення про те, чи студент пройшов іспит чи не пройшов його (необхідно правильно відповісти на 15 з 20 питань, щоб скласти іспит). Після цього має відображатися загальна кількість правильних відповідей на запитання, кількість неправильних відповідей та список із зазначенням номерів запитань, на які відповідь була неправильною.",
    "inpdata": "input1.txt\ninput2.txt",
    "outdata": "You failed\nCorrectly answerd question is 7\nIncorrectly answerd question is 13\nWrong answers 2 3 5 8 9 10 11 12 13 14 17 18 19\nYou passed\nCorrectly answerd question is 17\nIncorrectly answerd question is 3\nWrong answers 7 13 19",
    "solution": "def correct_answers():\n    correct_list = ['A', 'C', 'A', 'A', 'D', 'B', 'C', 'A', 'C', 'B',\n                       'A', 'D', 'C', 'A', 'D', 'C', 'B', 'B', 'D', 'A']\n    return correct_list\ndef open_answers(filename):\n    answers_list = []\n    with open(filename, 'r') as file:\n        lines = file.readlines()\n        for line in lines:\n            line = line.rstrip('\\n')\n            answers_list.append(line)\n    return answers_list\ndef check(correct_list, answers_list):\n    count = 0\n    wrong_answers = []\n    for i in range(20):\n        if correct_list[i] == answers_list[i]:\n            count += 1\n        else:\n            wrong_answers.append(i+1)\n    if count < 15:\n        print('You failed')\n    else:\n        print('You passed')\n    print('Correctly answerd question is', count)\n    print('Incorrectly answerd question is', 20 - count)\n    print('Wrong answers', *wrong_answers)\nfilename = input()\ncorrect_list = correct_answers()\nanswers_list = open_answers(filename)\ncheck(correct_list, answers_list)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "796",
    "title": "В олімпіаді з інформатики брало участь кілька осіб. Переможцем олімпіади стає людина, яка набрала найбільше балів. Переможці визначаються незалежно по кожному класу. Визначте кількість балів, яку набрав переможець в кожному класі. Гарантується, що в кожному класі був хоча б один учасник. Інформація про результати олімпіади записана у файлі, кожен рядок якого має вигляд: прізвище ім’я клас бал. Прізвище та ім’я - текстові рядки, що не містять пропусків. Клас - одне з трьох чисел 9, 10, 11. Бал - ціле число від 0 до 100. У інший файл запишіть три числа в одному рядку через пропуск: бали переможця олімпіади з 9 класу, з 10 класу, з 11 класу.",
    "inpdata": "Файл input.txt з вмістом\nAlbert Einstein 9 90\nErnest Rutherford 10 91\nLev Landau 11 92\nEnrico Fermi 9 93",
    "outdata": "Файл output.txt з вмістом\n93 91 92",
    "solution": "with open('input.txt', 'r', encoding='utf-8') as filein, open('output.txt', 'w') as fileout:  \n    results = {}\n    for line in filein:\n        firstname, secondname, grade, mark = line.split()\n        if int(grade) not in results:\n            results[int(grade)] = [int(mark)]\n        else:\n            results[int(grade)].append(int(mark))\n    result = ''\n    for k, v in sorted(results.items(), key=lambda x: x[0]):\n        result += str(max(v)) + ' '\n    print(result.rstrip(), file=fileout, end='')",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "797",
    "title": "В олімпіаді з інформатики брало участь кілька осіб. Гарантується, що в кожному класі був хоча б один учасник. Визначте і запишіть у файл середні бали учасників олімпіади в 9 класі, в 10 класі, в 11 класі. Інформація про результати олімпіади записана у файлі, кожен рядок якого має вигляд: прізвище ім’я клас бал. Прізвище та ім’я - текстові рядки, що не містять пропусків. Клас - одне з трьох чисел 9, 10, 11. Бал - ціле число від 0 до 100.",
    "inpdata": "Файл input.txt з вмістом\nAlbert Einstein 9 90\nErnest Rutherford 10 91\nLev Landau 11 92\nEnrico Fermi 9 93",
    "outdata": "Файл output.txt з вмістом\n91.5 91.0 92.0",
    "solution": "with open('input.txt', 'r', encoding='utf-8') as filein, open('output.txt', 'w') as fileout:  \n    results = {}\n    for line in filein:\n        firstname, secondname, grade, mark = line.split()\n        if int(grade) not in results:\n            results[int(grade)] = [int(mark)]\n        else:\n            results[int(grade)].append(int(mark))\n    result = ''\n    for k, v in sorted(results.items(), key=lambda x: x[0]):\n        result += str(sum(v) / len(v)) + ' '\n    print(result.rstrip(), file=fileout, end=' ')",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "798",
    "title": "В олімпіаді з інформатики брало участь кілька осіб. Визначте кількість школярів, які стали переможцями в кожному класі. Переможцями оголошуються всі, хто набрав найбільшу кількість балів по даному класу. Гарантується, що в кожному класі був хоча б один учасник. Запишіть у файл три числа в одному рядку через пропуск: кількість переможців олімпіади з 9 класу, з 10 класу, з 11 класу.",
    "inpdata": "Файл input.txt з вмістом\nAlbert Einstein 9 90\nNiels Bohr 9 93\nErnest Rutherford 10 91\nLev Landau 11 92\nEnrico Fermi 9 93\nIvan Puluj 10 91",
    "outdata": "Файл output.txt з вмістом\n2 2 1",
    "solution": "with open('input.txt', 'r', encoding='utf-8') as filein, open('output.txt', 'w') as fileout:  \n    results = {}\n    for line in filein:\n        firstname, secondname, grade, mark = line.split()\n        if int(grade) not in results:\n            results[int(grade)] = [int(mark)]\n        else:\n            results[int(grade)].append(int(mark))\n    result = ''\n    for k, v in sorted(results.items(), key=lambda x: x[0]):\n        result += str(v.count(max(v))) + ' '\n    print(result.rstrip(), file=fileout, end=' ')",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "799",
    "title": "В олімпіаді з інформатики брало участь кілька осіб. Залік в олімпіаді проводиться без поділу на класи. Запишіть у файл прізвище та ім’я переможця олімпіади. Якщо таких декілька - виведіть тільки їх кількість.",
    "inpdata": "Файл input.txt з вмістом\nAlbert Einstein 9 92\nNiels Bohr 9 93\nErnest Rutherford 10 95\nLev Landau 11 92\nEnrico Fermi 9 95\nIvan Puluj 10 91",
    "outdata": "Файл output.txt з вмістом\n2",
    "solution": "with open('input.txt', 'r') as filein, open('output.txt', 'w') as fileout:  \n    result = ''\n    winners = {}\n    for line in filein:\n        firstname, secondname, grade, mark = line.strip().split()\n        fullname = firstname + ' ' + secondname\n        winners[fullname] = int(mark)\n    marks_list = sorted([winners[k] for k in winners])\n    c = marks_list.count(marks_list[-1])\n    if c == 1:\n        for k, v in winners.items():\n            if v == marks_list[-1]:\n                result = k\n    else:\n        result = str(c)\n    print(result, file=fileout)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "800",
    "title": "Напишіть програму, яка зчитує вміст двох текстових файлів і друкує списки слів, які задовільняють наступним умовам: які з’являються в обох файлах; які з’являються у першому файлі, але не в другому; які з’являються у другому файлі, але не у першому; які з’являються в першому або другому файлі, але не в обох одночасно.",
    "inpdata": "input.txt\noutput.txt",
    "outdata": "In both files: список слів, що з’являються в обох файлах\nAppear in the first file but not the second: список слів, які з'являються у першому файлі, але не в другому\nAppear in the second file but not the first file: список слів, які з'являються у другому файлі, але не у першому\nAppear in either the first or second file but not both: список слів, які з'являються в першому або другому файлі, але не в обох одночасно",
    "solution": "def read_lines_from_files():\n    filename1 = input()    \n    filename2 = input()\n    with open(filename1, 'r') as f1, open(filename2, 'r') as f2:\n        lines1 = f1.readlines()\n        lines2 = f2.readlines()\n        return lines1, lines2\ndef set_on(lines):\n    words_set = set()\n    for line in lines:\n        words = line.split()\n        for word in words:\n            words_set.add(word)\n    return words_set\n        \ndef selection_words(lines1, lines2):\n    words_set1 = set_on(lines1)\n    words_set2 = set_on(lines2)\n    print('In both files:', words_set1 & words_set2)\n    print('Appear in the first file but not the second:', words_set1 - words_set2)\n    print('Appear in the second file but not the first file:', words_set2 - words_set1)\n    print('Appear in either the first or second file but not both:', words_set1 ^ words_set2)\n\nlines1, lines2 = read_lines_from_files()\nselection_words(lines1, lines2)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "801",
    "title": "Дано файл з таблицею у форматі TSV (значення, розділені табуляцією) з інформацією про зріст школярів різних класів. Напишіть програму, яка прочитає цей файл і підрахує для кожного класу середній зріст учня. Файл складається з набору рядків, кожна з яких представляє собою три поля: \"Клас Прізвище Зріст\". Клас позначається тільки числом. Літери в назві класу не використовуються. Номер класу може бути від 1 до 11 включно. У тексті прізвища немає пропусків, а в якості зросту використовується ціле число, але при підрахунку середнього потрібно обчислити значення у вигляді дійсного числа. Виводити інформацію про середнє значення зросту слід в порядку зростання номера класу (для класів з першого по одинадцятий). Якщо про якийсь клас немає інформації, необхідно вивести навпроти нього \"тире\" як у вихідних даних.",
    "inpdata": "Вхідний файл input.txt з таблицею у форматі TSV (значення, розділені табуляцією) з трьома полями: Клас Прізвище Зріст",
    "outdata": "1 124.75\n2 129.33\n3 134.44\n4 139.00\n5 144.88\n6 155.75\n7 164.00\n8 165.90\n9 170.20\n10 170.50",
    "solution": "height = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}\nresult = height.copy()\nwith open('input.txt', 'r') as f:\n    tsv = []\n    for line in f:\n        tsv.append(line.strip().split('\t'))\n    for i in range(len(tsv)):\n        for j in range(len(tsv[i])):\n            if int(tsv[i][0]) in height:\n                height[int(tsv[i][0])] += 1\n                result[int(tsv[i][0])] += int(tsv[i][2])\n    for i in range(1, len(result)+1):\n        if result[i] != 0:\n            print('{0:} {1:.2f}'.format(i, float(result[i]/height[i])))\n        else:\n            print(i, '-', '')",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "802",
    "title": "Зашифруйте текст у текстовому файлі шифром Цезаря, при цьому символи першого рядка файла повинні циклічно зміщуватися на 1, другого рядка - на 2, третього рядка - на три і т. д. У кожному рядку містяться різні символи, які можуть бути розділені пропусками. Шифрувати потрібно тільки великі і малі букви латинського алфавіту. Програма повинна записати шифровані рядки у інший файл.",
    "inpdata": "Файл input.txt з вмістом\nSuccess consists of going from failure to failure without loss of enthusiasm\nYou miss 100% of the shots you do not take\nIt is not the strongest of the species that survives, nor the most intelligent, but the one most responsive to change\nFall seven times and stand up eight\nThere are no shortcuts to any place worth going",
    "outdata": "Файл output.txt з вмістом\nTvddftt dpotjtut pg hpjoh gspn gbjmvsf up gbjmvsf xjuipvu mptt pg fouivtjbtn\nAqw okuu 100% qh vjg ujqvu aqw fq pqv vcmg\nLw lv qrw wkh vwurqjhvw ri wkh vshflhv wkdw vxuylyhv, qru wkh prvw lqwhooljhqw, exw wkh rqh prvw uhvsrqvlyh wr fkdqjh\nJepp wizir xmqiw erh wxerh yt imklx\nYmjwj fwj st xmtwyhzyx yt fsd uqfhj btwym ltnsl",
    "solution": "alphabet = ''.join(map(chr, range(ord('a'), ord('z') + 1)))       \ndef encode_words_from_line_in_file(line, i):\n    sentence_words = []\n    words = line.strip('\n').split()   \n    for word in words:\n        letters_word = []\n        for letter in word:\n            c = letter\n            if c.isalpha():\n                if c.isupper():\n                    c = c.lower()\n                    encode_letter = alphabet[(alphabet.index(c) + i) % len(alphabet)]\n                    encode_letter = encode_letter.upper()\n                else:\n                    encode_letter = alphabet[(alphabet.index(c) + i) % len(alphabet)]\n                letters_word.append(encode_letter)\n            else:\n                letters_word.append(c)\n        sentence_words.append(''.join(letters_word))\n    return sentence_words\n\nwith open('input.txt', 'r') as filein, open('output.txt', 'w') as fileout:     \n    i = 1\n    for line in filein:\n        result = encode_words_from_line_in_file(line, i)\n        print(' '.join(result), file=fileout)\n        i += 1",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "803",
    "title": "Дано файл, що містить слова, записані на окремих рядках. Слова можуть повторюватися. Надрукуйте з файла список слів на основі першого символу слова в лексикографічному порядку у вигляді як у вихідних даних.",
    "inpdata": "Файл input.txt з текстом",
    "outdata": "a: ask\nb: be\nc: come call\nd: do\nf: find feel\ng: get go give\nh: have\nk: know\nl: look leave\nm: make\ns: say see seem\nt: take think tell\nu: use\nw: want work",
    "solution": "word_list = []\nwith open(\"input.txt\", \"r\") as infile:\n    for line in infile:\n        word = line.strip()\n        if word not in word_list:\n            word_list.append(word)\nresult = {item:[] for item in set(item[0] for item in word_list)}\nfor item in word_list: \n    result[item[0]].append(item)\nfor k, v in sorted(result.items(), key=lambda x: x[0]):\n    print(k + ':', *v)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "804",
    "title": "При обробці тексту часто потрібно \"почистити\" текст перед тим, як робити з ним якісь інші дії. Наприклад, якщо ви хочете підрахувати кількість входжень слів в тексті, для спрощення завдання перед початком підрахунку можна подбати про те, щоб весь текст був записаний в нижньому регістрі (або у верхньому) і з нього були вилучені всі знаки пунктуації. Також можна розбити текст на послідовності слів. Виконайте таку нормалізацію тексту на прикладі тексту з першої частини першого розділу книги \"Дон Кіхот\" Мігеля де Сервантеса Сааведри, який можна звантажити із проекту gutenberg.org (http://www.gutenberg.org/cache/epub/996/pg996.txt). Для виконання завдання, спочатку завантажте текстовий файл, що містить текст книги, далі скопіюйте із завантаженого файла перший розділ у новий файл з назвою quixote.txt. Прочитайте дані із текстового файла quixote.txt і потурбуйтеся про те, щоб всі символи були приведені до одного регістру, видаліть всі знаки пунктуації і запишіть слова по одному на рядок у інший текстовий файл з ім’ям quixote_clean.txt.",
    "inpdata": "Вхідний файл quixote.txt з початковим текстом",
    "outdata": "Вихідний файл quixote_clean.txt з нормалізованим текстом",
    "solution": "# не замінюйте нічого, але видаляйте символи, які відображаються в третьому рядку.\npunct = str.maketrans(\"\", \"\", \"!.,:;-?\")\nwith open(\"quixote.txt\", 'r') as infile, open(\"quixote_clean.txt\", \"w\") as outfile:\n    for line in infile:\n        # перетворити в нижній регістр\n        cleaned_line = line.lower()\n        # видалити знаки пунктуації\n        cleaned_line = cleaned_line.translate(punct)\n        # розділити на слова\n        words = cleaned_line.split()\n        cleaned_words = \"\\n\".join(words)\n        # записати всі слова по одному на рядок файла\n        outfile.write(cleaned_words)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "805",
    "title": "Необхідно підрахувати кількість входжень слів в тексті першої частини першого розділу книги \"Дон Кіхот\" Мігеля де Сервантеса Сааведри, який можна звантажити із проекту gutenberg.org (http://www.gutenberg.org/cache/epub/996/pg996.txt). Для спрощення завдання, скористайтеся чистим файлом quixote_clean.txt з попереднього завдання. Використайте словник для підрахунку входжень кожного слова, а потім виведіть слова і кількості входжень (5 пар), які зустрічаються в тексті найчастіше і найменшу кількість разів у форматі як у вихідних даних.",
    "inpdata": "Вхідний файл quixote_clean.txt з нормалізованим текстом",
    "outdata": "Most common words:\n('of', 88)\n('and', 79)\n('the', 70)\n('he', 68)\n('to', 65)\n\nLeast common words:\n('treats', 1)\n('pursuits', 1)\n('donquixote', 1)\n('manchain', 1)\n('desire', 1)",
    "solution": "quixote_words = []\nwith open('quixote_clean.txt', 'r') as infile:\n    for word in infile:\n        if word.strip():\n            quixote_words.append(word.strip())\nword_count = {}\nfor word in quixote_words:\n    count = word_count.setdefault(word, 0)\n    count += 1\n    word_count[word] += 1\nword_list = list(word_count.items())\nword_list.sort(key=lambda x: x[1])\nprint('Most common words:')\nfor word in reversed(word_list[-5:]):\n    print(word)\nprint('\\nLeast common words:')\nfor word in word_list[:5]:\n    print(word)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "806",
    "title": "У вхідному файлі задано 5 цілих чисел як у вхідних даних. Зчитайте ці числа з файлу, і запишіть один рядок - результат аналізу у інший файл, згідно наступних умов: якщо однакові 5 чисел, то вивести \"Impossible\", інакше, якщо однакові 4, то вивести \"Four of a Kind\", інакше, якщо однакові 3 и 2, то вивести \"Full House\", інакше, якщо є 5 послідовних, то вивести \"Straight\", інакше, якщо однакові 3, то вивести \"Three of a Kind\", інакше, якщо однакові 2 і 2, то вивести \"Two Pairs\", інакше, якщо однакові 2, то вивести \"One Pair\", інакше, вивести \"Nothing\".",
    "inpdata": "1 3 9 3 2\n1 5 5 4 4\n10 11 12 13 1",
    "outdata": "One Pair\nTwo Pairs\nNothing",
    "solution": "with open('input.txt', 'r') as file:\n    lines = file.readlines() \n    data = lines[0].strip().split(' ')\n    data1 = [int(i) for i in data]\n    winner = []\n    current = []\n    for i in data1:\n        if i not in current:\n            winner.append(data1.count(i))\n            current.append(i)\nflag = True\ndata1.sort()\n\nif len(winner) == 5 and (abs(int(data1[1]) - int(data1[0])) == 1) and (abs(int(data1[2]) - int(data1[1])) == 1) and (abs(int(data1[3]) - int(data1[2])) == 1) and (abs(int(data1[4]) - int(data1[3])) == 1): \n   r = 'Straight'\n   flag = False\nif 5 in winner and len(winner) == 1:\n    r = 'Impossible'\n    flag = False\nif 4 in winner and len(winner) == 2:\n    r = 'Four of a Kind'\n    flag = False\nif (3 in winner) and (2 in winner) and len(winner) == 2:\n    r = 'Full House'\n    flag = False\nif 3 in winner and len(winner) > 2:\n    r = 'Three of a Kind'\n    flag = False\nif winner.count(2) == 2:\n    r = 'Two Pairs'\n    flag = False\nif (winner.count(2) == 1) and (winner.count(3) == 0):\n    r = 'One Pair'\n    flag = False\nif flag:\n   r = 'Nothing'\n   \nwith open('output.txt', 'w') as file:\n    file.write(r)",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "807",
    "title": "Аналіз файлів - невід’ємна частина роботи з ними. Іноді виникає необхідність підрахувати кількість рядків або слів в тексті. З цим завданням ефективно справляється команда wc в Linux. Звернувшись до man-сторінки утиліти wc, ви побачите, що ключі командного рядка вирішують наступні завдання. З ключем \"-c\" утиліта підраховує байти у файлі, а з ключем -m вона підраховує символи (деякі символи Unicode можуть складатися з двох і більше байтів). Ключі \"-l\" і \"-w\", відповідно, обчислюють кількість рядків і кільість слів. Крім того, якщо файл заданий, утиліта читає і обробляє файл, а при його відсутності, використовується stdin (стандартне введення в консолі). Напишіть свою версію утиліти wc, щоб реалізувати окремо як підрахунок байтів, символів, рядків і слів при читанні з файлів і стандартного введення. Формат використання утиліти в консолі наступний: \"python утиліта.py файл ключі\" або \"python утиліта.py ключі\". У випадку використання стандратного введення, щоб завершити введення, використовуйте сполучення клавіш Ctrl+D або Ctrl+Z.",
    "inpdata": "C:\Python36>python wc.py input.txt -l -w –c\nC:\Python36>python wc.py -l -w -c\nPython\nRuby\n^Z",
    "outdata": "File has 1386 characters\nFile has 279 words\nFile has 93 lines\nFile has 12 characters\nFile has 2 words\nFile has 2 lines",
    "solution": "import sys\ndef main():\n    line_count = 0\n    word_count = 0\n    char_count = 0\n    filename = None\n    options = None\n    if len(sys.argv) > 1:\n        params = sys.argv[1:]\n        if params[0].startswith('-'):\n            options = params\n        elif params[1].startswith('-'):\n            filename = params[0]\n            file_mode = 'r'\n            options = params[1:]\n \n    if '-c' in options:\n        file_mode = 'rb'\n        \n    if filename:\n        infile = open('input.txt', file_mode)\n    else:\n        infile = sys.stdin\n     \n    with infile:\n        for line in infile:\n            line_count += 1\n            char_count += len(line)\n            words = line.split()\n            word_count += len(words)\n    \n    if ('-c' in options) or ('-m' in options):\n        print('File has {} characters'.format(char_count))\n    if '-w' in options:\n        print('File has {} words'.format(word_count))\n    if \"-l\" in options:\n        print('File has {} lines'.format(line_count))\n    \nif __name__ == '__main__':\n    main()",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "808",
    "title": "Напишіть програму для гри \"Вгадай слово\". Програма зчитує із файла формату json слова і їх означення і пропонує користувачу прочитати означення, щоб відгадати слово. Користувач може обрати 4 варіанти: відгадати літеру, записати слово повністю, використати підказку (відкриється одна літера) або вийти з програми. Якщо не обирати вихід з програми, програма виконується до відгадування всього слова і в кінці виводить кількість використаних підказок.",
    "inpdata": "Перегляньте демонстрацію роботи програми",
    "outdata": "Перегляньте демонстрацію роботи програми",
    "solution": "import random\nimport json\n\ndef formatted_clues(h):\n    if h >= 11 and n <= 14:\n        return 'prompts'\n    else:\n        t = h % 10\n        if t == 0 or (t >= 5 and t <= 9):\n            return 'prompts'\n        if t == 1:\n            return 'hint'\n        if t >= 2 and t <= 4:\n            return 'hints'\n\ndef change_the_word(c):\n    for i in range(len(word)):\n        if c == word[i]:\n            letters.pop(i)\n            letters.insert(i, c)\n            \ndef python_json_file_to_dict(file_path):\n    try:\n        with open(file_path, 'r', encoding=\"utf-8\") as file_object:\n            data = json.load(file_object)\n            return data    \n    except FileNotFoundError:\n        print(\"File \" + file_path + \"  not found.\")\n        return False \nwords = python_json_file_to_dict('guess_json.json')\n\nif words:\n    choice = str(random.randint(1, len(words)))\n    word = words[choice][0]\n    answer = words[choice][1]\n    hints = set(word)\n    letters = ['_' for c in range(len(word))]\n    fully = '' \n    h = 0\n    print('Guess the word: {0:}.'.format(answer))\n    while True:\n        if '_' not in letters or fully == word:\n            break\n        for letter in letters:\n            print(letter, end=' ')\n        n = input('\\nChoose: enter the letter (1), the word completely (2), get the hint (3), exit (4)? Answer: ').strip()\n        if n == '1':\n            c = input('Enter the letter: ').strip().lower()\n            change_the_word(c)\n            hints.remove(c)\n        elif n == '2':\n            fully = input('The word completely: ').strip().lower()\n        elif n == '3':\n            hint_letter = random.choice(tuple(hints))\n            change_the_word(hint_letter)\n            hints.remove(hint_letter)\n            h += 1\n        elif n == '4':\n            break  \n    if n != '4':\n        message = formatted_clues(h)\n        print('You guessed the word \"{0:}\", using the {1:} {2:}.'.format(word, h, message))\n        print('{0:} - {1:}.'.format(word.title(), answer))",
    "chapter": "файли і модулі",
    "level": "високий"
  },
  {
    "id": "809",
    "title": "Напишіть клас з назвою Circle для обчислення площі круга за введеним радіусом. Клас Circle має містити метод, який обчислює площу круга.",
    "inpdata": "3",
    "outdata": "28.26",
    "solution": "class Circle():\n    def __init__(self, r):\n        self.radius = r\n\n    def area(self):\n        return (self.radius**2) * 3.14\n\nr = int(input())\ncircle = Circle(r)\nprint(circle.area())",
    "chapter": "ООП",
    "level": "початковий"
  },
  {
    "id": "810",
    "title": "Напишіть клас під назвою Rectangle для визначення площі прямокутника за введеними довжиною та шириною сторін. Клас прямокутника має містити метод, який обчислює площу прямокутника.",
    "inpdata": "2\n3",
    "outdata": "6",
    "solution": "class Rectangle():\n    def __init__(self, l, w):\n        self.length = l\n        self.width  = w\n\n    def area(self):\n        return self.length * self.width\na = int(input())\nb = int(input())\nrect = Rectangle(a, b)\nprint(rect.area())",
    "chapter": "ООП",
    "level": "початковий"
  },
  {
    "id": "811",
    "title": "Напишіть клас з назвою Circle, який містить два методи: для обчислення площі круга та довжину кола за введеним радіусом.",
    "inpdata": "8",
    "outdata": "200.96\n50.24",
    "solution": "class Circle():\n    def __init__(self, r):\n        self.radius = r\n\n    def area(self):\n        return (self.radius**2) * 3.14\n    \n    def perimeter(self):\n        return 2 * self.radius * 3.14\nr = int(input())\ncircle = Circle(r)\nprint(circle.area())\nprint(circle.perimeter())",
    "chapter": "ООП",
    "level": "початковий"
  },
  {
    "id": "812",
    "title": "Напишіть клас, який має як мінімум два методи: перший - отримати рядок з вводу консолі, другий - друкувати рядок у верхньому регістрі.",
    "inpdata": "python",
    "outdata": "PYTHON",
    "solution": "class InputOutputString:\n    def __init__(self):\n        self.s = ''\n\n    def get_string(self):\n        self.s = input()\n\n    def print_string(self):\n        print(self.s.upper())\n\ns = InputOutputString()\ns.get_string()\ns.print_string()",
    "chapter": "ООП",
    "level": "початковий"
  },
  {
    "id": "813",
    "title": "Змоделюйте роботу онлайн-магазину. a. Напишіть клас з ім’ям Shop(). Метод __init__() класу Shop() повинен містити два атрибути: shop_name і store_type. Створіть метод describe_shop(), який виводить два атрибути, і метод open_shop(), який виводить повідомлення про те, що онлайн-магазин відкритий. Створіть на основі класу екземпляр з ім’ям store. Виведіть два атрибути окремо, потім викличте обидва методи. b. Створіть ще один екземпляр класу, викличте для нього метод describe_shop(). c. Додайте атрибут number_of_units зі значенням за замовчуванням 0; він представляє кількість видів товару у магазині. Виведіть значення number_of_units, а потім змініть number_of_units і виведіть знову для store. d. Додайте метод з ім’ям set_number_of_units(), що дозволяє задати кількість видів товару. Викличте метод з новим числом, знову виведіть значення. Додайте метод з ім’ям increment_number_of_units(), який збільшує кількість видів товару на задану величину. Викличте цей метод для store. e. Напишіть клас Discount(), що успадковує від класу Shop(). Додайте атрибут з ім’ям discount_products для зберігання списку товарів, на які встановлена знижка. Напишіть метод get_discounts_ptoducts, який виводить цей список. Створіть екземпляр store_discount і викличте цей метод. f. Додатково. Збережіть код класу Shop() у модулі. Створіть окремий файл, що імпортує клас Shop(). Створіть екземпляр all_store і викличте один з методів Shop(), щоб перевірити, що команда import працює вірно. У вихідних даних наведений можливий варіант результатів виконання завдань.",
    "inpdata": "Немає",
    "outdata": "a)\nRozetka\nishop\nRozetka\nishop\n3000000\nThe store is open.\nb)\nITbox\nishop\n20000\nc)\n3000000\n3000001\nd)\nRozetka\nishop\n3900000\nRozetka\nishop\n3901200\ne)\nmotherboards\nsolid state drives\nmonitors",
    "solution": "class Shop():\n    def __init__(self, shop_name, store_type, number_of_units = 0):\n        self.number_of_units = number_of_units\n        self.shop_name = shop_name\n        self.store_type = store_type\n    def describe_shop(self):\n        print(self.shop_name)\n        print(self.store_type)\n        print(self.number_of_units)\n    def open_shop(self):\n        print('The store is open.')\n    def set_number_of_units(self, number_of_units):\n        self.number_of_units = number_of_units\n    def increment_number_of_units(self, add):\n        self.number_of_units += add\n\nclass Discount(Shop):\n    def __init__(self, discount_products = ['motherboards', 'solid state drives', 'monitors']):\n        self.discount_products = discount_products\n    def get_discounts_ptoducts(self):\n        for products in self.discount_products:\n            print(products)\nstore = Shop('Rozetka', 'ishop', 3000000)\nstore.describe_shop()\nstore.open_shop()\nprint(store.shop_name)\nprint(store.store_type)\nstore1 = Shop('ITbox', 'ishop', 20000)\nstore1.describe_shop()\nstore.set_number_of_units(3900000)\nstore.describe_shop()\nstore.increment_number_of_units(100000)\nstore.describe_shop()\nstore_discount = Discount()\nstore_discount.get_discounts_ptoducts()",
    "chapter": "ООП",
    "level": "середній"
  },
  {
    "id": "814",
    "title": "Напишіть клас Bank для опису простих операції з вашим банківським рахунком: покласти на рахунок, зняти з рахунку, переглянути рахунок. При створенні екземпляру класу, екземпляр отримує атрибут __balance з певним значенням. Клас повинен містити методи для додавання коштів на рахунок і знімання з рахунку, за умови, що на рахунку достатньо коштів.",
    "inpdata": "Немає",
    "outdata": "I open a bank account\nI deposit to your account:\n5000\nOn the account: 5000.00\nI withdraw from your bank account:\n4200\nOn the account: 800.00\nI open a bank account\nI deposit to your account:\n1000\nOn the account: 1000.00\nI withdraw from your bank account:\n1200\nError: not enough money\nOn the account: 1000.00",
    "solution": "class Bank:\n    def __init__(self, balance):\n        self.__balance = 0.0\n\n    def balance(self):\n        return format(self.__balance, '.2f')\n        \n    def deposit(self, amount):\n        self.__balance += amount\n\n    def withdraw(self, amount):\n        if self.__balance >= amount:\n            self.__balance -= amount\n        else:\n            print('Error: not enough money')\nsaving = Bank(0)\nprint('I open a bank account')\nprint('I deposit to your account:')\npay = float(input())\nsaving.deposit(pay)\nprint('On the account:', format(saving.balance()))\nprint('I withdraw from your bank account:')\ncash = float(input())\nsaving.withdraw(cash)\nprint('On the account:', format(saving.balance()))",
    "chapter": "ООП",
    "level": "середній"
  },
  {
    "id": "815",
    "title": "Змоделюйте облік користувачів на сайті. a. Створіть клас з ім’ям User. Створіть два атрибути first_name і last_name, а потім ще кілька атрибутів, які зазвичай зберігаються у профілі користувача. Напишіть метод describe_user який виводить повне ім’я користувача. Створіть ще один метод greeting_user() для виведення персонального вітання для користувача. Викличте обидва методи для користувача. b. Додайте атрибут login_attempts (спроби входу в обліковий запис) у клас User. Напишіть метод increment_login_attempts(), що збільшує значення login_attempts на 1. Напишіть інший метод з ім’ям reset_login_attempts(), обнуляє значення login_attempts. Створіть екземпляр класу User і викличте increment_login_attempts() кілька разів. Виведіть значення login_attempts, щоб переконатися у тому, що значення було змінено правильно, а потім викличте reset_login_attempts(). Знову виведіть login_attempts і переконайтеся у тому, що значення обнулилося. c. Адміністратор - особливий різновид користувача. Напишіть клас з ім’ям Admin, що успадковує від класу User. Додайте атрибут privileges для зберігання списку рядків виду \"Allowed to add message\", \"Allowed to delete users\", \"Allowed to ban users\" і т. д. Напишіть метод show_privileges() для виведення набору привілеїв адміністратора. Створіть екземпляр класу Admin і викличте метод. e. Напишіть клас Privileges. Клас повинен містити всього один атрибут privileges зі списком, який треба забрати із класу Admin. Водночас, необхідно перемістити метод show_privileges() у клас Privileges із класу Admin. Створіть екземпляр priv як атрибут класу Admin. Створіть новий екземпляр класу Admin і використайте метод для виведення списку привілеїв. f. Додатково. Збережіть клас User в одному модулі, а класи Privileges і Admin у іншому модулі. В окремому файлі створіть екземпляр класу Admin і викличте метод show_privileges(), щоб перевірити, що все працює вірно. У вихідних даних наведений можливий варіант результатів виконання завдань.",
    "inpdata": "Немає",
    "outdata": "a)\nBilbo Baggins\nHello, Bilbo Baggins\nb)\n3\n0\nc), d)\nAllowed to add message\nAllowed to delete users\nAllowed to ban users",
    "solution": "class User():\n    def __init__(self, first_name, last_name, login_attempts = 0):\n        self.first_name = first_name\n        self.last_name = last_name\n        self.full_name = ''\n        self.login_attempts = login_attempts \n    def describe_user(self):\n        self.full_name = self.first_name + ' ' + self.last_name\n        print(self.full_name)\n    def greeting_user(self):\n        print('Hello,', self.full_name)\n    def increment_login_attempts(self):\n        self.login_attempts += 1\n    def reset_login_attempts(self):\n        self.login_attempts = 0\nclass Admin(User):\n    def __init__(self):\n        self.priv = Privileges()\n\nclass Privileges():\n    def __init__(self, privileges = ['Allowed to add message', 'Allowed to delete users', 'Allowed to ban users']):\n        self.privileges = privileges\n    def show_privileges(self):\n        for p in self.privileges:\n            print(p)\n        \nuser1 = User('Bilbo', 'Baggins')\nuser1.describe_user()  \nuser1.greeting_user() \nuser1.increment_login_attempts()  \nuser1.increment_login_attempts() \nuser1.increment_login_attempts() \nprint(user1.login_attempts )\nuser1.reset_login_attempts() \nprint(user1.login_attempts)\nadmin = Admin()\nadmin.priv.show_privileges()",
    "chapter": "ООП",
    "level": "середній"
  },
  {
    "id": "816",
    "title": "Напишіть клас Coin, який описує монету, яку можна підкидати. При створенні екземпляру класу, екземпляр отримує атрибут __sideup зі значенням heads або tails. У класі визначте метод toss, який випадково визначає результат підкидання монети - орел чи решка. Створіть екземпляр класу і виведіть на екран n підкидань монети.",
    "inpdata": "3",
    "outdata": "Tails\nHeads\nTails",
    "solution": "import random\n\nclass Coin:\n\n    def __init__(self):\n        self.__sideup = 'Heads'\n    \n    @property\n    def sideup(self):\n        return self.__sideup\n    \n    @sideup.setter\n    def sideup(self, sideup):\n        self.__sideup = sideup\n        \n    def toss(self):\n        if random.randint(0, 1) == 0:\n            self.__sideup = 'Heads'\n        else:\n            self.__sideup = 'Tails'\n\nmy_coin = Coin()\nn = int(input())\nfor count in range(n):\n    my_coin.toss()\n    print(my_coin.sideup)",
    "chapter": "ООП",
    "level": "середній"
  },
  {
    "id": "817",
    "title": "Напишіть клас Car, який надає для створених екземплярів такі атрибути даних автомобіля: марку виготовлення автомобіля, модель автомобіля, рік автомобіля, швидкість (початкове значення 0). Клас також повинен мати наступні методи: accelerate (метод повинен щоразу додавати 5 до значення атрибуту даних про швидкість), brake (метод повинен віднімати 5 від значення атрибута даних швидкості кожного разу, коли він викликається), get_speed (метод повинен повернути поточну швидкість). Створіть екземпляр класу Car і викличте метод accelerate п’ять разів. Після кожного виклику методу accelerate отримайте поточну швидкість автомобіля і надрукуйте її значення. Потім викличте метод brake п’ять разів. Після кожного виклику методу brake отримайте поточну швидкість автомобіля та надрукуйте її значення.",
    "inpdata": "Немає",
    "outdata": "Characteristics of the car:\nCitroen c3 2018\nCar accelerates:\nCurrent speed: 5\nCurrent speed: 10\nCurrent speed: 15\nCurrent speed: 20\nCurrent speed: 25\nCar slows down:\nCurrent speed: 20\nCurrent speed: 15\nCurrent speed: 10\nCurrent speed: 5\nCurrent speed: 0\nCar stopped",
    "solution": "class Car:\n    def __init__(self, make, model, year):\n        self.__make = make\n        self.__model = model\n        self.__year = year\n        self.__speed = 0\n    \n    @property\n    def make(self):\n        return self.__make\n\n    @make.setter\n    def make(self, make):\n        self.__make = make\n    \n    @property\n    def model(self):\n        return self.__model    \n    \n    @model.setter\n    def model(self, model):\n        self.__model = model\n    \n    @property\n    def year(self):\n        return self.__year\n\n    @year.setter\n    def year(self, year):\n        self.__year = year\n        \n    @property\n    def speed(self):\n        return self.__speed\n\n    @speed.setter\n    def speed(self, speed):\n        self.__speed = speed        \n   \n    def accelerate(self):\n        self.__speed += 5\n        \n    def brake(self):\n        self.__speed -=5\n        \nmy_car = Car('Citroen', 'c3', 2018)\nprint('Characteristics of the car:')\nprint(my_car.make, my_car.model, my_car.year)\nprint('Car accelerates:')\nfor i in range(5):\n    my_car.accelerate()\n    print('Current speed:', my_car.speed)\nprint('Car slows down:')\nfor i in range(5):\n    my_car.brake()\n    print('Current speed:', my_car.speed)\nprint('Car stopped')",
    "chapter": "ООП",
    "level": "середній"
  },
  {
    "id": "818",
    "title": "Реалізуйте клас MoneyBox для роботи з віртуальною скарбничкою. Кожна скарбничка має обмежену місткість, яка виражається цілим числом n - кількістю монет, які можна покласти в скарбничку. Клас повинен підтримувати інформацію про кількість монет в скарбничці, надавати можливість додавати монети в скарбничку і дізнаватися, чи можна додати в скарбничку ще якусь кількість монет, не перевищуючи її місткість. При створенні скарбнички, число монет в ній дорівнює 0. Дані вводиться користувачем в такому порядку: n - місткість скарбнички, m - скільки монет поклали в скарбничку, k - кількість монет, які хочуть покласти в скарбничку. Результатом має бути одне з двох значень: True чи False. Для детальнішого розуміння структури класу перегляньте умову до задачі повністю.",
    "inpdata": "10\n6\n3\n10\n6\n5",
    "outdata": "True\nFalse",
    "solution": "class MoneyBox:\n    def __init__(self, capacity):\n        self.capacity = capacity\n    def can_add(self, v):\n        if self.capacity >= v:\n            return True\n        else:\n            return False\n    def add(self, v):\n        if self.can_add(v):\n            self.capacity -= v\n        \ncapacity = int(input())\ncoins = int(input())\nget_coins = int(input())\n\ncoin = MoneyBox(capacity)\ncoin.add(coins)\nprint(coin.can_add(get_coins))",
    "chapter": "ООП",
    "level": "середній"
  },
  {
    "id": "819",
    "title": "Напишіть клас Dog, який має три атрибути класу: mammal (ссавець), nature (характер) і breed (порода), та два атрибути ексземпляра: name (кличка) і age (вік). Створіть екземпляри трьох нових собак, кожна з яких різного віку. Визначте у класі Dog метод для виведення значень атрибутів екземпляру - імені та віку конкретної собаки. За потреби, додайте кілька інших методів, які визначають поведінку собаки (подавання голосу тощо). Напишіть кілька класів, які унаслідуються від батьківського класу Dog, що описують конкретні породи собак. Визначте для цих класів атрибути nature і breed відповідно, включіть у класи по одному методу, що визначає поведінку конкретної породи собаки. Створіть батьківський клас Pets, що створює список ваших домашніх улюбленців. У підсумку, надрукуйте інформацію про ваших домашніх тварин, на зразок, як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "I have 3 dogs.\nToby is 4. Kind Golden Retriever breed dog.\nCharlie is 6. Tireless Jack Russell Terrier breed dog.\nRocky is 7. Obedient ordinary breed dog.\nAnd they're all mammals, of course.",
    "solution": "class Pets:\n    dogs = []\n    def __init__(self, dogs):\n        self.dogs = dogs\n        \nclass Dog:\n    species = 'mammal'\n    nature = 'obedient'\n    breed = 'ordinary'    \n    \n    def __init__(self, name, age):\n        self.name = name\n        self.age = age\n    \n    def description(self):\n        return '{} is {} years old'.format(self.name, self.age)\n    \n    def speak(self, sound):\n        return '{} says {}'.format(self.name, sound)\n\nclass GoldenRetriever(Dog):\n    nature = 'kind'  \n    breed = 'Golden Retriever'    \n    def run(self, speed):\n        return '{} runs {}'.format(self.name, speed)\n     \nclass JackRussellTerrier(Dog):\n    nature = 'tireless'\n    breed = 'Jack Russell Terrier'\n    def run(self, speed):\n        return '{} runs {}'.format(self.name, speed)\n    \nmy_dogs = [\n    GoldenRetriever('Toby', 4), \n    JackRussellTerrier('Charlie', 6), \n    Dog('Rocky', 7)\n]\n\nmy_pets = Pets(my_dogs)\n  \nprint('I have {} dogs.'.format(len(my_pets.dogs)))\nfor dog in my_pets.dogs:  \n    print('{} is {}. {} {} breed dog.'.format(dog.name, dog.age, dog.nature.title(), dog.breed))\nprint('And they\\'re all {}s, of course.'.format(dog.species))",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "820",
    "title": "Дано послідовність цілих чисел. Необхідно її обробити і вивести на екран суму першої п’ятірки чисел із цієї послідовності, потім суму другої п’ятірки, і т. д. Але послідовність не дається відразу загалом. З плином часу до вас надходять її послідовні частини. Наприклад, спочатку перші три елементи, потім наступні шість, потім наступні два і т. д. Реалізуйте клас Buffer, який буде накопичувати в собі елементи послідовності і виводити суму п’ятірок послідовних елементів у міру їх накопичення. Однією з вимог до класу є те, що він не повинен зберігати в собі більше елементів, ніж йому дійсно необхідно, тобто, він не повинен зберігати елементи, які вже увійшли в п’ятірку, для якої була виведена сума. Перегляньте умову задачі повністю для розуміння структури класу.",
    "inpdata": "1 2 3\n4 5 6\n7 8 9 10\n1 1 1 1 1 1 1 1 1 1 1",
    "outdata": "[1, 2, 3]\n15\n[6]\n40\n[]\n5\n5\n[1]",
    "solution": "class Buffer:\n    def __init__(self):\n        self.numbers = []\n        self.result = 0\n        self.temp = []\n        \n    def add(self, a):\n        for item in a:\n            self.numbers.append(item)\n        while len(self.numbers) >= 5:\n            self.result = sum(self.numbers[:5])\n            self.numbers = self.numbers[5:]\n            self.temp.append(self.result)\n        for item in self.temp[:]:\n            print(item)\n        self.temp = []\n\n    def get_current_part(self):\n        return self.numbers\nbuf = Buffer()   \nwhile True: \n    items = list(map(int, input().split()))\n    if items == []: \n        break\n    buf.add(items)\n    print(buf.get_current_part())",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "821",
    "title": "Напишіть клас-виняток, на основі вбудованого в Python класу ValueError(). Клас буде представляти перевірку певного імені на основі його довжини. Якщо довжина введеного імені є меншою 10, то має генеруватися виняток як у вихідних даних. У інших випадках нічого не виводиться.",
    "inpdata": "Eyjafjallajokul\nEtna",
    "outdata": "NameTooShortError: Etna",
    "solution": "class NameTooShortError(ValueError):\n    pass\n    \ndef validate(name):\n    if len(name) < 10:\n        raise NameTooShortError(name)\nvalidate(input())",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "822",
    "title": "Напишіть клас Animal, який при створенні екземпляру надає йому атрибут виду тварини species. Клас має містити метод, який виводить інформацію про вид тварини, і метод, який виводить характерний звук для даного виду тварини. Створіть два класи Dog і Cat, які успадковуються від класу Animal (є підкласами для Animal). У кожному з підкласів реалізуйте виклик конструктора надкласу з передачею йому назви виду тварини. Також, у підкласах реалізуйте методи, які перевизначають метод надкласу для відтворення характерного звуку для конкретного виду тварини. Визначте окрему функцію show_animal_info, яка приймає об’єкт (екземпляр класу) як аргумент і викликає його методи show_species і make_sound, якщо це тварина, а інакше - виводиться відповідне повідомлення як у вихідних даних.",
    "inpdata": "Немає",
    "outdata": "I'm an - ordinary animal\nGrrr!\nI'm an - dog\nWoof! Woof!\nI'm an - cat\nMeow!\nBook this is not an animal!",
    "solution": "class Animal:\n    def __init__(self, species):\n        self.__species = species\n    def show_species(self):\n        print('I\\'m an -', self.__species)\n    def make_sound(self):\n        print('Grrr!')\n\nclass Dog(Animal):\n    def __init__(self):\n        Animal.__init__(self, 'dog')\n    def make_sound(self):\n        print('Woof! Woof!')\n\nclass Cat(Animal):\n    def __init__(self):\n        Animal.__init__(self, 'cat')\n    def make_sound(self):\n        print('Meow!')\n\ndef show_animal_info(creature):\n    if isinstance(creature, Animal):\n        creature.show_species()\n        creature.make_sound()\n    else:\n        print('{} this is not an animal!'.format(creature))\n\nanimal = Animal('ordinary animal')\ndog = Dog()\ncat = Cat()\nshow_animal_info(animal)\nshow_animal_info(dog)\nshow_animal_info(cat)\nshow_animal_info('Book')",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "823",
    "title": "Визначте спеціальний клас винятку, який приймає рядок повідомлення про помилку як атрибут. Випробуйте роботу класу на винятку \"ділення на нуль\", використайте конструкцію try/except як у вихідних даних.",
    "inpdata": "8\n4\n3\n0",
    "outdata": "2.0\nOK\nDone\ndivision by zero\nDone",
    "solution": "class MyError(Exception):\n    \"\"\"My own exception class\n\n    Attributes:\n        msg  -- explanation of the error\n    \"\"\"\n    def __init__(self, msg):\n        self.msg = msg\na = int(input())\nb = int(input())\ntry:\n    print(a / b)\nexcept Exception as e:\n    error = MyError(e)\n    print(error)\nelse:\n    print('OK')\nfinally:\n    print('Done')",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "824",
    "title": "Напишіть клас для реалізації функціоналу вбудованої функції pow(x, n).",
    "inpdata": "2\n-3\n2\n6\n81\n0",
    "outdata": "0.125\n64\n1",
    "solution": "class MyPow:\n    def my_pow(self, x, n):\n        if not n:\n            return 1\n        if n > 1:\n            return eval('{}{}'.format(x, '*{}'.format(x)*(n-1)))\n        if n < 1:\n            return eval('1/({}{})'.format(x, '*{}'.format(x) * (-n - 1)))\np = MyPow()\nx = int(input())\nn = int(input())   \nprint(p.my_pow(x, n))",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "825",
    "title": "Напишіть клас для перетворення десяткового числа в число в римській системі числення.",
    "inpdata": "111\n99\n25",
    "outdata": "XCIX\nCXI\nXXV",
    "solution": "class ConvertToRoman:\n    def int_to_roman(self, number):\n        d = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]\n        s = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']\n        roman_number = ''\n        i = 0\n        while number > 0:\n            for _ in range(number // d[i]):\n                roman_number += s[i]\n                number -= d[i]\n            i += 1\n        return roman_number\nn = int(input())\nroman = ConvertToRoman()\nprint(roman.int_to_roman(n))",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "826",
    "title": "Напишіть клас для перетворення числа в римській системі числення у десяткове число.",
    "inpdata": "MMCMLXXVI\nLLL\nIX",
    "outdata": "2976\n150\n9",
    "solution": "class ConvertFromRoman:\n    def roman_to_int(self, s):\n        roman_val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n        int_val = 0\n        for i in range(len(s)):\n            if i > 0 and roman_val[s[i]] > roman_val[s[i - 1]]:\n                int_val += roman_val[s[i]] - 2 * roman_val[s[i - 1]]\n            else:\n                int_val += roman_val[s[i]]\n        return int_val\ndec = ConvertFromRoman()\ns = input()\nprint(dec.roman_to_int(s))",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "827",
    "title": "Напишіть клас, який визначає правильність розстановки рядка дужок \"(\", \")\", \"{\", \"}\", \"[\" та \"]\". Ці дужки повинні бути розташованими у правильному порядку, наприклад порядок \"()\" і \"() [] {}\" правильний, але \"[)\", \"({[)]\" і \"{{{\" є неправильними порядками.",
    "inpdata": "(){}[]\n()[{)}\n()",
    "outdata": "True\nFalse\nTrue",
    "solution": "class Brackets:\n   def is_valid_parenthese(self, s):\n        stack, c = [], {'(': ')', '{': '}', '[': ']'}\n        for parenthese in s:\n            if parenthese in c:\n                stack.append(parenthese)\n            elif len(stack) == 0 or c[stack.pop()] != parenthese:\n                return False\n        return len(stack) == 0\n\nb = Brackets()\ns = input()\nprint(b.is_valid_parenthese(s))",
    "chapter": "ООП",
    "level": "високий"
  },
  {
    "id": "828",
    "title": "Напишіть клас, щоб отримати всі можливі унікальні підмножини зі списку цілих чисел.",
    "inpdata": "1 2 3",
    "outdata": "[[], [3], [2], [2, 3], [1], [1, 3], [1, 2], [1, 2, 3]]",
    "solution": "class Combinations:\n    def sub_sets(self, items):\n        return self.sub_sets_recur([], sorted(set(items)))\n    \n    def sub_sets_recur(self, current, items):\n        if items:\n            return self.sub_sets_recur(current, items[1:]) + self.sub_sets_recur(current + [items[0]], items[1:])\n        return [current]\nс = Сombinations()\nitems = list(map(int, input().split()))\nprint(с.sub_sets(items))",
    "chapter": "ООП",
    "level": "високий"
  }
]