Задачи на целочисленное деление python

[ Сборник задач ] Тема 1. Целые числа

Любое целое число независимо от объема потребляемой памяти в языке Python представлено типом int. Напишете ли вы 22 или 2222222222222222222222222222222, оно все равно будет определяться как int, просто в памяти вашего устройства это значение будет занимать разную память. В других языках программирования целые числа принадлежат к разным типам данных.

К слову, в Python большие числа для наглядности можно разделять нижними подчеркиваниями и они по-прежнему будут интерпретироваться как тип int. Пример: можно написать 200000000 и запутаться в нулях, а есть и такой вариант: 200_000_000 (согласитесь, удобнее).

Числа в Python представлены в памяти вашего компьютера в двоичном коде и могут занимать разный объем памяти. Важно понимать: чем больше число, тем больше времени занимают любые операции с ним и тем больше памяти вычислительной машины требуется.

С целыми числами можно производить любые арифметические операции без ограничений. Их имеется 7 разновидностей:
– сложение (+);
– вычитание (—);
– умножение (*);
– деление (/);
– возведение в степень (**);
– деление по модулю (%), которое возвращает целочисленный остаток от деления (т.е. если 3 % 2, то получим остаток 1);
– целочисленное деление (//), которое возвращает целочисленный результат деления без дробной части (т.е. если 10 // 4, то получим 2).

Задача 1. Базовый уровень

Обозначьте порядок вычисления выражения по операциям: 11 * 2 ** 2 – 13 / 4 + 7. Какое целое число получим в итоге?

Сначала по приоритету возводим в степень (2 ** 2). Далее умножаем (11 * 4). Потом делим (13 / 4). Следом вычитаем (44 — 3.25). На последнем этапе применяем сложение (40.75 + 7). Получаем число с плавающей точкой 47.75. Если привести его к типу int, то результат равняется 47.Решение — Интерактивный режим

Задача 2. Базовый уровень

Сколько мегабайт памяти занимает число 3 ** 9090001? Для решения воспользуйтесь функцией getsizeof() из модуля sys.

Не торопитесь. Придется подождать около 10 секунд на вычисление выражения (в зависимости от мощности компьютера). Как известно, в одном килобайте – 1024 байт, а в одном мегабайте – 1024 Кб. Для вычисления объема занимаемой памяти воспользуемся функцией getsizeof() из модуля sys. Получим: sys.getsizeof(3 ** 9090001) / (1024 * 1024) = 1.83 Мб приблизительно.Решение — IDE

# 1. Импортируем функцию из модуля from sys import getsizeof # 2. Находим объем занимаемом памяти в Мегабайтах getsizeof(3 ** 9090001) / (1024 * 1024) # Результат: 1.8319969177246094

Задача 3. Базовый уровень

Используя стандартные арифметические операции представьте самое большое целое число из цифр 4, 4, 4 и приведите его значение.

Операция возведения в степень дает невероятно большое число, значение которого больше, чем атомов в известной Вселенной.Решение — Интерактивный режим

>>> 4 ** 4 ** 4 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

Задача 4. Базовый уровень

Какие из представленных выражений можно преобразовать в целое десятичное число за одну операцию: А) '123е'; Б) '91.4'; В) 524.345 ** 435345345311145345; Г) '7.1 + 4'; Д) '4' - 2; Е) '4 - 2'; Ж) '42' З) -12.12?

Чтобы получить ответ, необходимо каждое из выражений мысленно обернуть в функцию int(). Делать это на практике не рекомендуется, так как на пункте «В» ваш ПК намертво повиснет.

А) Строку преобразовать нельзя, так как в ней есть буквенный символ, не имеющий численного представления в десятичной системе счисления.
Решение — Интерактивный режим

>>> int('123е') # Получим ошибку ValueError

Б) Строку, имитирующую число с плавающей точкой к типу int преобразовать не получится.Решение — Интерактивный режим

>>> int('91.4') # Получим ошибку ValueError

В) Хоть число и имеет немыслимые размеры, при достаточном объеме памяти оно будет преобразовано к типу int;Решение — Интерактивный режим

>>> int(524.345 ** 435345345311145345) # Сначала вычисляется возведение в степень, а потом преобразование к целому числу 

Г) Это строка, которая неприводима к целому числу.Решение — Интерактивный режим

>>> int('7.1 + 4') # Получим ошибку ValueError 

Д, Е) Строку и число либо выражение внутри строки нельзя сделать целым числом.Решение — Интерактивный режим

>>> int('4' - 2) # Получим ошибку TypeError >>> int('4 - 2') # Получим ошибку ValueError

Ж) Если внутри строки имеются лишь числа, то Python без проблем сделает из них intРешение — Интерактивный режим

З) Число с плавающей точкой преобразуется в целое методом отсечения дробного остатка.Решение — Интерактивный режим

Следовательно, правильные ответы: В, Ж, З.

Задача 5. Базовый уровень

Напишите функцию pos_add(a, b), которая возвращает положительное значение сложения двух целых чисел.

Проверку на действительность аргументов производить не будем, т. к. в условии обозначено, что мы предоставляем только целые числа.

Оптимальный вариант – использовать встроенную функцию abs(), которая возвращает положительное число.
Решение — IDE

def pos_add(a, b): return abs(a + b) # Тесты print(pos_add(7, -3)) print(pos_add(7, -7)) print(pos_add(-2, -3))

Задача 6. Базовый уровень

Определите функцию foo(a), которая возвращает результат целочисленного и по модулю деления любого целого числа на -11.

Целочисленное деление – результат выполнения операции «//», а делению по модулю – операции «%». В Python имеется встроенная функция divmod(), принимающая число и делитель. Она возвращает пару чисел: результат целочисленного деления и остаток от деления. Нам уже предоставлен делитель «-11», поэтому результат следующий:Решение — IDE

def foo(a): return divmod(a, -11) # Тесты print(foo(22)) print(foo(-77)) print(foo(1))

Если вы не знакомы с функцией divmod(), то можно решить задачу так:Решение — IDE

def foo(a): return a // -11, a % -11 # Тесты print(foo(22)) print(foo(-77)) print(foo(1))

Задача 7. *Продвинутый уровень

Напишите функцию num_sum(a), принимающую любое значение. Если это целое число, то возвратить сумму его чисел. В противном случае возвращается фраза «Это не целое число».

Для решения потребуется функция abs(), которая преобразует отрицательное число в положительное и проверка принадлежности аргумента к типу int.

Главная проблема – булевы значения, которые (о чем не все знают) принадлежат к классу int в Пайтоне. По условию задачи нам годятся только целые числа, а True или False ими не являются. Следует провести и эту проверку.
Решение — IDE

def num_sum(a): # 1. Определяем принадлежность значения 'a' к целому числу, но не к булеву типу if isinstance(a, int) and not isinstance(a, bool): # 2. Преобразуем число в положительное, а потом - строку a_to_str = str(abs(a)) # 3. Задаем начальную сумму 0 s = 0 # 4. В цикле складываем все числа for i in a_to_str: s += int(i) return s return 'Это не целое число' # Тесты print(num_sum(-146)) print(num_sum('-11')) print(num_sum(True))

11 Это не целое число Это не целое число

Источник

Ctrl+Enter

Ошибка или опечатка? Выдели её, нажми Ctrl+Enter и коротко опиши, что не так. Это сделает наши материалы лучше!

Опасный поворот

Чтобы дать возможность извлечь пользу из данного материала людям разного уровня, применяется специальный знак для обозначения материала, необходимого для виртуозов.

Когда этот знак появляется в начале раздела, это предупреждает читателя об «опасном повороте». Не читайте этот блок без необходимости. Для большинства приложений такие детали не имеют значения.

Некоторые блоки настолько экзотичны, что они оценены двумя знаками опасного поворота. Всё, что было сказано о простом знаке опасного поворота, для этих случаев подходит вдвойне. Вам, вероятно, потребуется месячный опыт работы с питоном, прежде чем вы попытаетесь проникнуть в такие дважды опасные глубины питона. В действительности большинству людей никогда не потребуется знать питон в таких подробностях, даже если они пользуются им ежедневно. В конце концов, можно водить машину, не зная, как работает мотор.

Пишем простейшие программы

В предыдущем задании мы использовали Питон для простых разовых вычислений, используя интерактивный режим. Например, было задание вычислить длину гипотенузы прямоугольного треугольника по ее катетам. «Программа» эта выглядела так:

Неплохо для калькулятора, но совсем не универсально: если нужна другая гипотенуза, то нужно брать всё выражение и исправлять в нём отдельные числа. Эту программу можно написать по-другому:

Здесь мы используем переменные — бирки, которые можно повесить на различные (числовые, строковые и прочие) значения в памяти интерпретатора. В первой строке переменной a присваивается значение 179, затем переменной b присваивается значение 971, затем переменной c присваивается значение выражения, равному длине гипотенузы. И наконец в последней строчке мы выводим при помощи функции print получившееся значение.

Программа, которая получилась, длиннее и сложнее, чем та первая, из «калькулятора». Зачем эти сложности? Плюс в том, что значения a и b в такой программе можно брать и не из её кода, а например из того, что пользователь ввёл на клавиатуре. Получится удобный гипотенузный вычислятор: ты ему два числа, а он в ответ гипотенузу.

Переменные в питоне

В питоне же всё, с чем можно работать — это объекты в памяти интерпретатора. А переменные — это бирки, которые к этим объектам привязаны.

Некоторые объекты уже созданы заранее (например, объекты-целые числа от -5 до 255). Другие объекты создаются во время исполнения программы. После того, как объект создан, он живёт независимо от конкретных переменных, на него ссылающихся. Если на объект не ссылается ни одна переменная, то он со временем удаляется из памяти.

Проверка того, ссылаются ли две переменных на один и тот же объект, выполняется при помощи команды is .

Вот несколько примеров объектов и проверок на их совпадение.

>>> a = 123 >>> b = 123 >>> a is b True >>> b = 2 >>> a is b False >>> a = 321 >>> b = 320 + 1 >>> a is b False >>> a == b True

Вполне может быть, что будут существовать два объекта типа число с одним и тем же значением. Так всегда происходит, когда проверить, не создавал ли кто-нибудь ранее точно такой же объект, сложнее, чем создать заново новый. Поэтому нельзя сравнивать переменные при помощи is .

A: Гипотенуза

Даны два числа a и b. Выведите гипотенузу треугольника с заданными катетами.

В этой задаче необходимо прочитать два числа при помощи int(input()) . Вычислить гипотенузу. И вывести получившееся число при помощи функции print .

Источник

Целочисленная арифметика¶

Специальный символ, выполняющий арифметические вычисления. В выражении a * b символ * — оператор умножения, a и b — его операнды.

Оператор, принимающий два операнда, называется бинарным. Унарный оператор принимает один операнд. Пример унарного оператора: -1 .

Последовательность операторов и операндов, результат вычисления которой сводится к единственному значению. Простейшие выражения состоят из одного значения и не содержат операторов: 42 , «Hello, World!» . Пример более сложного выражения: 2 ** 32 — 1 .

Свойство оператора, влияющее на очередность его выполнения в выражении с несколькими различными операторами при отсутствии явного (с помощью скобок) указания на порядок их вычисления.

Например, результат выражения 2 + 2 * 2 — 6, поскольку приоритет операции умножения выше, чем приоритет операции сложения. Изменить порядок вычислений в выражении можно с помощью скобок:

последовательность выполнения операций (или направление вычисления), реализуемая когда операции имеют одинаковый приоритет и отсутствует явное (с помощью скобок) указание на очерёдность их выполнения.

Различают правую (справа налево) и левую (слева направо) ассоциативность. Пример оператора с левой ассоциативностью — оператор деления / . Так, выражение 8 // 4 // 2 эквивалентно (8 // 4) // 2 и его результат равен 1.

Пример оператора с правой ассоциативностью — оператор возведения в степень:

>>> 2 ** 2 ** 3 256 >>> 2 ** (2 ** 3) 256 >>> (2 ** 2) ** 3 64 

Арифметические операторы¶

В таблице приведены некоторые арифметические операторы языка Python в порядке уменьшения приоритета (операторы с наибольшим приоритетом расположены выше).

Источник