Нужна программа для вычитания чисел
Здравствуйте, хотел сделать программу которая будет бесконечно вычитать из числа A число B, где А =1000 а B =7
И должно получится 1000–7=993, 993–7=986, 986–7=979 и тд, но что то не могу разобраться с циклом, помогите
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
Ответы с готовыми решениями:
Программа для вычитания двух комплексных чисел
Написал программу для вычитания двух комплексных чисел,не работает. Помогите пожалуйста,я эти.
Программа для вычитания однобайтных чисел (Mplab)
Написать программу для вычитания однобайтных чисел в Mplab, сложение у меня получилось а вычитание.
Нужна программа для умножения чисел
Нужна программа для умножения n чисел (сколько чисел я задаю при вводе данных)!
Нужна программа для +, -, *, / и % для длинных чисел со знаком
Здравствуйте, парни. Нужна программа для реализации операций +, -, *, / и % для длинных чисел со.
Автоматизируй это!
7102 / 4606 / 1214
Регистрация: 30.03.2015
Сообщений: 13,216
Записей в блоге: 29
zxcKrolik, показывай до какого момента написал, просто даже интересно чего там можно не сделать.
36 / 51 / 11
Регистрация: 14.01.2021
Сообщений: 406
zxcKrolik,
1 2 3 4 5
A=1000 B=7 while A>0: if A-7>0:A-=7;print(A) else:break
Фанат Гуля?
Автоматизируй это!
7102 / 4606 / 1214
Регистрация: 30.03.2015
Сообщений: 13,216
Записей в блоге: 29
gray621, плохо.
636 / 476 / 179
Регистрация: 28.05.2012
Сообщений: 1,414
1 2 3 4 5 6 7
a, b = 1000, 7 while True: if a > 0: print(f' - = ') a -= b else: break
Am I evil? Yes, I am!
17052 / 9999 / 2763
Регистрация: 21.10.2017
Сообщений: 21,960
1 2 3 4 5 6 7 8
def foo(x): print(x) if x 7: return x foo(x - 7) foo(1000)
7908 / 4194 / 1808
Регистрация: 27.03.2020
Сообщений: 7,013
print(*list(range(1000,-1, -7)), sep = '\n')
Автоматизируй это!
7102 / 4606 / 1214
Регистрация: 30.03.2015
Сообщений: 13,216
Записей в блоге: 29
Gdez, iSmokeJC, Vigi, ладно, так и быть покажу, раз вы не читаете что
Сообщение от zxcKrolik 
сделать программу которая будет бесконечно вычитать из числа A число B
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
>>> def gen(a,b): . while True: . a-=b . yield a . >>> endless_generator = gen(1000,7) >>> for _ in range(10): . print(next(endless_generator)) . 993 986 979 972 965 958 951 944 937 930 # можно продолжать бесконечно, если ставить рейндж не 10, а просто в вечном цикле читать
Am I evil? Yes, I am!
17052 / 9999 / 2763
Регистрация: 21.10.2017
Сообщений: 21,960
Welemir1, бьем челом, прости неразумных падаванов!
3553 / 2156 / 568
Регистрация: 02.09.2015
Сообщений: 5,441
Вставлю свои пять копеек:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
In [1]: from itertools import count In [2]: for i in count(1000, -7): . print(i) . 1000 993 986 979 972 965 958 951 944 937 930 923 916 909 902 895 888 881 874 867 860 853 846 839 832 825 818 811 804 797 790 783 776 769 762 755 748 741 734 727 720 713 706 699 692 685 678 671 664 657 650 643 636 629 622 615 608 601 594 587 580 573 566 559 552 545 538 531 524 517 510 503 496 489 482 475 468 461 454 447 440 433 426 419 412 405 398 391 384 377 370 363 356 349 342 335 328 321 314 307 300 293 286 279 272 265 258 251 244 237 230 223 216 209 202 195 188 181 174 167 160 153 146 139 132 125 118 111 104 97 90 83 76 69 62 55 48 41 34 27 20 13 6 .
Перебор 2^30> чисел для рекурсии, вызовы 1000 рекурсий
Перебирать долго и возникают ошибки, поэтому есть ли панацея от этой болезни, но чтобы сохранить суть шаблонности выполнения этой задачи без поиска каких-то алгоритмов? Тот же перебор, но быстрее, без ошибок? Те же многочисленные рекурсии, но без ошибок?
"""Алгоритм вычисления значения функции F(n), где n — целое неотрицательное число, задан следующими соотношениями: F(0) = 0; F(n) = F(n − 1) + 1, если n нечётно; F(n) = F(n / 2), если n > 0 и при этом n чётно. Укажите количество таких значений n < 1 000 000 000 (~~2^30), для которых F(n) = 2.""" def F(n): if n == 0: return 0 else: return F(n-1) + 1 if n % 2 else F(n//2) c = 0 for n in range(100000000): if F(n) == 2: print(n) c += 1 print('count of n:', c) Заранее спасибо за ответ и извиняюсь за глупые вопросы. Желательно без сторонних библиотек, которые нужно скачивать.
Отслеживать
48.7k 17 17 золотых знаков 56 56 серебряных знаков 100 100 бронзовых знаков
задан 15 фев 2023 в 19:27
21 4 4 бронзовых знака
Намек хотите? 🙂 Посмотрите сюда: oeis.org/A000120
15 фев 2023 в 19:34
намеков не понимаю 0:
15 фев 2023 в 19:36
Жаль. Ну, разжуем. Сколько чисел из вашего диапазона в бинарном представлении содержат две единицы? Правда, это очень просто и быстро?
15 фев 2023 в 19:37
Дожую еще немного. 26*25/2+25 = 350 — и никакого программирования. Разве что print(350) 🙂
15 фев 2023 в 19:49
@Harry почему 26*25, когда в условии задачи 2^30?
16 фев 2023 в 8:42
2 ответа 2
Сортировка: Сброс на вариант по умолчанию
Итак, как, наконец, устаканили — требуется найти количество чисел до 100 миллионов (именно это значение задано в коде), в бинарном представлении которых ровно две единицы.
Что такое 100000000 в бинарном представлении - 101111101011110000100000000
Итого, нас интересуют все возможные размещения двух единиц в 26 знакоместах + количество чисел, начинающихся с 10 и у которых после этого идет только одна 1 на 25 знакомест. Т.е. 26*25/2 + 25 = 350.
Если все же миллиард, то он в бинарном представлении имеет вид 111011100110101100101000000000, так что теперь нас интересуют любые размещения двух единиц в 30 знакоместах (благо, начинается миллиард с 11), и получаем 30*29/2 = 435 таких чисел.
Все просто, никакого программирования 🙂
Но если очень хочется попрограммировать и вывести все эти числа.
int main(int argc, char * argv[]) < unsigned int n = 1000'000'000; int count = 0; for(int m = 1; m < 32; ++m) < unsigned int x = 1 n) break; for(int l = 0; l < m; ++l) < unsigned int y = x + (1 n) break; cout (y) > cout
И кстати! Откуда эти "1000 рекурсий" (я так понимаю, имеется в виду глубина)? До миллиарда максимальная глубина рекурсии — 59 для числа 805306367.
Отслеживать
ответ дан 16 фев 2023 в 10:07
219k 15 15 золотых знаков 120 120 серебряных знаков 230 230 бронзовых знаков
Ваша функция F(n) подсчитывает количество единиц в двоичном представлении числа. Соответственно вопрос о том, как быстро вычислить количество n таких, что F(n) == 2 эквивалентен вопросу о том, сколько существует пар чисел m,k m > k таких, что 2^m + 2^k < N
Количество цифр в двоичном представлении числа N равно floor(log2(N))+1
Нетрудно заметить, что в общем случае среди чисел такой длины найдутся числа, которые будут больше N . Например, число, состоящее из всех единиц - оно превосходит любое другое с таким же количеством цифр в двоичной записи.
Поэтому вычисление нужно разбить на две части. Сначала вычислить количество подходящих чисел, которые гарантированно меньше (то есть без единицы в старшем разряде) и затем посчитать количество подходящих чисел с единицей в старшем рязряде.
def fastF(n): m = math.floor(math.log2(n)) # 2^m 0: k = math.floor(math.log2(reminder)) + 1 else: k = 0 return int(count_m + k) Fast: 10 4 Fast: 100 21 Fast: 1000 45 Fast: 10000 89 Fast: 100000 136 Fast: 1000000000 435 Как написать 1000 7 на питоне
Все ранее рассматриваемые программы имели линейную структуру: все инструкции выполнялись последовательно одна за одной, каждая записанная инструкция обязательно выполняется.
Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид:
x = int(input()) if x > 0: print(x) else: print(-x)
В этой программе используется условная инструкция if (если). После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием. После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно, в нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием, и блок инструкций, который будет выполнен, если проверяемое условие неверно, в данном случае будет выведено значение -x .
Итак, условная инструкция в Питоне имеет следующий синтаксис:
if Условие: Блок инструкций 1 else: Блок инструкций 2
Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2 .
В условной инструкции может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением. Например, если дано число x и мы хотим заменить его на абсолютную величину x , то это можно сделать следующим образом:
x = int(input()) if x < 0: x = -x print(x)
В этом примере переменной x будет присвоено значение -x , но только в том случае, когда x
Для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.
Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц. кц в Кумире, begin. end в Паскале или фигурными скобками в Си.
2. Вложенные условные инструкции
Внутри условных инструкций можно использовать любые инструкции языка Питон, в том числе и условную инструкцию. Получаем вложенное ветвление – после одной развилки в ходе исполнения программы появляется другая развилка. При этом вложенные блоки имеют больший размер отступа (например, 8 пробелов). Покажем это на примере программы, которая по данным ненулевым числам x и y определяет, в какой из четвертей координатной плоскости находится точка (x,y):
x = int(input()) y = int(input()) if x > 0: if y > 0: # x > 0, y > 0 print("Первая четверть") else: # x > 0, y < 0 print("Четвертая четверть") else: if y >0: # x < 0, y >0 print("Вторая четверть") else: # x < 0, y < 0 print("Третья четверть")
В этом примере мы использовали комментарии – текст, который интерпретатор игнорирует. Комментариями в Питоне является символ # и весь текст после этого символа до конца строки.
3. Операторы сравнения
Как правило, в качестве проверяемого условия используется результат вычисления одного из следующих операторов сравнения: < Меньше — условие верно, если первый операнд меньше второго.
> Больше — условие верно, если первый операнд больше второго.
>= Больше или равно.
== Равенство. Условие верно, если два операнда равны.
!= Неравенство. Условие верно, если два операнда неравны.
Операторы сравнения в Питоне можно объединять в цепочки (в отличии от большинства других языков программирования, где для этого нужно использовать логические связки), например, или .
4. Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool . Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь). Если преобразовать логическое True к типу int , то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
4.1. Логические операторы
Иногда нужно проверить одновременно не одно, а несколько условий. Например, проверить, является ли данное число четным можно при помощи условия (n % 2 == 0) (остаток от деления n на 2 равен 0 ), а если необходимо проверить, что два данных целых числа n и m являются четными, необходимо проверить справедливость обоих условий: n % 2 == 0 и m % 2 == 0 , для чего их необходимо объединить при помощи оператора and (логическое И): n % 2 == 0 and m % 2 == 0 .
В Питоне существуют стандартные логические операторы: логическое И, логическое ИЛИ, логическое отрицание.
является бинарным оператором (то есть оператором с двумя операндами: левым и правым) и имеет вид and . Оператор and возвращает True тогда и только тогда, когда оба его операнда имеют значение True .
является бинарным оператором и возвращает True тогда и только тогда, когда хотя бы один операнд равен True . Оператор “логическое ИЛИ” имеет вид or .
(отрицание) является унарным (то есть с одним операндом) оператором и имеет вид not , за которым следует единственный операнд. Логическое НЕ возвращает True , если операнд равен False и наоборот.
Пример. Проверим, что хотя бы одно из чисел a или b оканчивается на 0:
15 40
a = int(input()) b = int(input()) if a % 10 == 0 or b % 10 == 0: print('YES') else: print('NO')
Проверим, что число a — положительное, а b — неотрицательное:
if a > 0 and not (b < 0):
Или можно вместо not (b < 0) записать (b >= 0) .
Срезы — Python: Списки
Работать с одиночными элементами вы уже умеете. Настало время перейти к очень интересному инструменту, который Python предоставляет для работы с целыми подмножествами элементов списка: к так называемым срезам (slices).
Синтаксис описания срезов
Срезы встроены в язык и снабжены своим собственным синтаксисом — настолько широко они используются. Срез записывается так же, как записывается обращение к элементу списка по индексу:
some_list[START:STOP:STEP] Всего у среза три параметра:
- START — индекс первого элемента в выборке
- STOP — индекс элемента списка, перед которым срез должен закончиться. Сам элемент с индексом STOP не будет входить в выборку
- STEP — шаг прироста выбираемых индексов
Математически говоря, во множество будут входить индексы элементов, которые будут выбраны:
Например, срез [3:20:5] означает выборку значений с индексами 3, 8, 13 и 18.
При этом любой из трех параметров среза может быть опущен и вместо соответствующего параметра будет выбрано некое значение по умолчанию:
- Умолчательный START означает «от начала списка»
- Умолчательный STOP означает «до конца списка включительно»
- Умолчательный STEP означает «брать каждый элемент»
Вот несколько примеров с разными наборами параметров:
- [:] или [::] — весь список
- [::2] — нечетные по порядку элементы
- [1::2] — четные по порядку элементы
- [::-1] — все элементы в обратном порядке
- [5:] — все элементы, начиная с шестого
- [:5] — все элементы, не доходя до шестого
- [-2:1:-1] — все элементы от предпоследнего до третьего в обратном порядке. Во всех случаях выборки от большего индекса к меньшему нужно указывать шаг
Срезы могут работать в двух режимах: собственно выборка и присваивание.
Выборка элементов
Срезы-выборки работают со списками, кортежами, строками. Результатом применения выборки всегда становится новое значение соответствующего типа — список, кортеж, строка:
'hello'[2:] # 'llo' (1, "foo", True, None)[2:] # (True, None) [1, 2, 3, 4, 5][2:] # [3, 4, 5] Сразу сделаем несколько замечаний по использованию выборок:
- Кортежи чаще всего содержат разнородные элементы, поэтому срезы для них менее полезны, чем распаковка и перепаковка: тяжело удерживать в голове типы элементов вместе с индексами
- При выборке по срезу [:] создается новая копия списка, поэтому именно так обычно список и копируют
- Срез порождает новый список или кортеж, но для каждого выбранного элемента копируется только ссылка
Присваивание срезу
В отличие от строк и кортежей списки могут изменяться по месту. Одним из вариантов модификации является присваивание срезу. Срезу с указанным шагом можно присвоить список, содержащий соответствующее количество новых элементов:
l = [1, 2, 3, 4, 5, 6] l[::2] = [0, 0, 0] print(l) # => [0, 2, 0, 4, 0, 6] Если вы попробуете присвоить срезу с шагом неверное количество элементов, то получите ошибку:
l = [1, 2, 3, 4] l[::2] = [5, 6, 7] # Traceback (most recent call last): # File "", line 1, in # ValueError: attempt to assign sequence of size 3 to extended slice of size 2 Если срез непрерывный, то есть шаг не указан и индексы идут подряд, то свободы нам дается больше. Такому срезу можно присвоить как больше элементов — тогда список вырастет, так и меньше, что приведет к урезанию списка:
l = [1, 2, 3] l[2:] = [4, 5] print(l) # => [1, 2, 4, 5] l[1:-1] = [100] print(l) # => [1, 100, 5] l[:] = [] print(l) # => [] Сначала список растет, потом уменьшается, а под конец вообще становится пустым — и все с помощью компактного, но мощного синтаксиса срезов.
Срезы-значения
Хоть срезы и имеют специальную поддержку со стороны синтаксиса, но мы можем создавать и использовать срезы сами по себе — как обычные значения.
Значение среза можно сконструировать с помощью функции slice :
first_two = slice(2) each_odd = slice(None, None, 2) print(each_odd) # => slice(None, None, 2) l = [1, 2, 3, 4, 5] print(l[first_two]) # => [1, 2] print(l[each_odd]) # => [1, 3, 5] Функция slice принимает от одного до трех параметров — те самые START , STOP и STEP . При вызове функции с одним параметром, функция вызывается с параметром STOP .
Если вы хотите пропустить один из параметров, то подставьте вместо него None . Также None можно использовать и в записи срезов в квадратных скобках — там он так же будет означать пропуск значения.
На месте параметров среза могут быть любые выражения, лишь бы эти выражения вычислялись в целые числа или None .
Соотношение START и STOP
В срезе элемент с индексом STOP не попадает в выборку, в отличие от элемента с индексом START .
У такого поведения есть одна особенность. Какой бы неотрицательный индекс n мы ни выбрали, для любого списка будет соблюдаться указанное равенство:
l == l[:n] + l[n:] Посмотрим на такой пример:
s = 'Hello!' print(s[:2] + s[2:]) # => 'Hello!' print(s[:4] + s[4:]) # => 'Hello!' print(s[:0] + s[0:] == s) # => True print(s[:100] + s[100:] == s) # => True Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях: