5.01 Запись числа в двоичной системе счисления

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа N необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем проверяем последнюю цифру (которая имеет индекс -1). Если это единица, заменяем её на 0, если ноль — на 1. Далее находим сумму цифр, которая в двоичной записи совпадает с количеством единиц, дописываем в конец остаток от её деления на 2. В завершение переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого результата выполнения алгоритма проверяем, больше ли он 187 и является ли минимальным среди полученных. Если условие выполняется, обновляем наименьшее значение R и сохраняем N. После завершения цикла выводим переменную N, которая соответствует наименьшей R, большей 187.

mn = 10 ** 10  # Минимальный результат > 187
ans = None  # Значение N, при котором получен минимальный результат

for n in range(1, 10000):  # Перебираем числа N от 1 до 9999 включительно
    s = bin(n)[2:]  # Перевод в двоичную систему

    if s[-1] == "1":  # Если последняя цифра 1
        s = s[:-1] + "0"  # Заменяем последнюю 1 на 0
    else:
        s = s[:-1] + "1"  # Заменяем последний 0 на 1

    a = s.count("1")  # Находим сумму цифр
    s += str(a % 2)  # Дописываем её в конец числа

    r = int(s, 2)  # Переводим в десятичную систему

    # Проверяем, что результат > 187, то есть подходит по условию, и меньше минимального
    if r > 187 and r < mn:
        mn = r
        ans = n
print(ans)

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа R необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем вычисляем количество единиц с помощью метода count. Если это количество чётное, дописываем справа 1, используя конкатенацию строк (оператор +). Если нечётное, дописываем 0. Повторяем те же действия для изменённой двоичной записи, переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения проверяем, превышает ли оно 250 и является ли минимальным среди полученных. Если условие выполняется, обновляем наименьшее значение. После завершения цикла выводим минимальный результат работы алгоритма, больший 250.

# Инициализация переменной для хранения минимального результата > 250
mn = 10 ** 10

for i in range(1, 1000):  # Перебираем числа N от 1 до 999 включительно
    s = bin(i)[2:]  # Перевод в двоичную систему

    # Вычисляем бит чётности
    if s.count("1") % 2 == 0:
        # Если количество единиц чётно, дописываем 1, иначе - 0
        s += "1"
    else:
        s += "0"

    # Повторяем предыдущий шаг, но уже для изменённой записи
    if s.count("1") % 2 == 0:
        s += "1"
    else:
        s += "0"

    r = int(s, 2)  # Переводим в десятичную систему
    # Проверяем, что результат > 250, то есть подходит по условию, и меньше минимального
    if r > 250 and r < mn:
        mn = r
print(mn)

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа N необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем вычисляем количество единиц с помощью метода count. Если это количество кратно трём, дописываем справа 0, используя конкатенацию строк (оператор +). Если некратно, дописываем 1. Повторяем те же действия для изменённой двоичной записи, переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения R проверяем указанное требование. Если условие выполняется, выводим N. В ответ запишем наибольшее выведенное число.

for n in range(1, 1000):  # Перебираем числа N от 1 до 999 включительно
    s = bin(n)[2:]  # Перевод в двоичную систему

    if s.count("1") % 3 == 0:
        # Если количество единиц кратно трём, дописываем 0, иначе - 1
        s += "0"
    else:
        s += "1"

    # Повторяем предыдущий шаг, но уже для изменённой записи
    if s.count("1") % 3 == 0:
        s += "0"
    else:
        s += "1"

    if int(s, 2) < 215:  # Получаем R
        # Последнее выведенное N будет наибольшим
        print(n)  # Выводим N

Решение программой

В условии задачи описан алгоритм, для поиска подходящего числа N необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью bin(), затем анализируем позиции цифр в этой записи, учитывая, что индексация в Python начинается с 0. С помощью генераторов сохраняем список цифр на четных и нечетных позициях. Считаем количество нулей и единиц на нужных позициях с помощью метода count() и находим их произведение.

Далее организуем перебор чисел N в цикле for. Для каждого полученного произведения проверяем, равно ли оно 16. Если условие выполняется, выводим текущее N и завершаем поиск.

for n in range(2, 200): # Перебираем все числа N от 2 до 199
    b = bin(n)[2:] # Получаем двоичную запись N (без префикса ’0b’)
    # Помним про итерацию в python с нуля
    ch = [b[i] for i in range(len(b)) if i % 2 != 0] # Сохраняем цифры на четных позициях
    nch = [b[i] for i in range(len(b)) if i % 2 == 0] # Сохраняем цифры на нечетных позициях
# Вычисляем количество нулей и единиц на нужных позициях и проверяем, что их произведение равно 16
    if ch.count(’0’)*nch.count(’1’) == 16:
        print(n) # Выводим текущее N
        break # Останавливаем цикл

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа N необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin. Чётность двоичного числа определяем по последнему разряду: если он равен 0 — число чётное, иначе нечётное. К полученной записи приписываем справа 1, если число чётное, или 0, если нечётное. Повторяем те же действия для изменённой двоичной записи, переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения проверяем, превышает ли оно 157 и является ли минимальным среди полученных. Если условие выполняется, обновляем наименьшее значение. После завершения цикла выводим минимальный результат работы алгоритма, больший 157.

# Инициализация переменной для хранения минимального результата > 157
mn = 10 ** 10

for i in range(1, 1000):  # Перебираем числа N от 1 до 999 включительно
    b = bin(i)[2:]  # Перевод в двоичную систему

    # Если двоичная запись оканчивается на 0, она является чётной
    # В таком случае допишем 1, иначе - 0
    if b[-1] == "0":
        b += "1"
    else:
        b += "0"

    # Повторяем предыдущий шаг, но уже для изменённой записи
    if b[-1] == "0":
        b += "1"
    else:
        b += "0"

    r = int(b, 2)  # Переводим в десятичную систему

    # Проверяем, что результат > 157, то есть подходит по условию, и меньше минимального
    if r > 157 and r < mn:
        mn = r
print(mn)

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа R необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем вычисляем количество единиц с помощью метода count. Если это количество чётное, дописываем слева 1, используя конкатенацию строк (оператор +). Если нечётное, дописываем 0. Повторяем те же действия для изменённой двоичной записи, переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения R проверяем, меньше ли оно 333 и является ли наибольшим среди полученных.. Если условие выполняется, обновляем наибольшее значение R. После завершения цикла выводим максимальное R.

# Инициализация переменной для хранения максимального результата < 333
mx = -10 ** 10

for i in range(1, 1000):  # Перебираем числа N от 1 до 999 включительно
    s = bin(i)[2:]  # Перевод в двоичную систему

    # Вычисляем бит чётности
    if s.count("1") % 2 == 0:
        # Если количество единиц чётно, в начало дописываем 1, иначе - 0
        s = "1" + s
    else:
        s = "0" + s

    # Повторяем предыдущий шаг, но уже для изменённой записи
    if s.count("1") % 2 == 0:
        s = "1" + s
    else:
        s = "0" + s

    r = int(s, 2)  # Переводим в десятичную систему

    # Проверяем, что результат < 333, то есть подходит по условию, и больше максимального
    if r < 333 and r > mx:
        mx = r
print(mx)

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа R необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем вычисляем количество нулей с помощью метода count. Если это количество чётное, дописываем слева 10, используя конкатенацию строк (оператор +). Если нечётное, дописываем 11 в конец. В завершение преобразуем полученную двоичную запись в десятичную систему, получив R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения проверяем, превышает ли оно 221 и является ли минимальным среди полученных. Если условие выполняется, обновляем наименьшее значение. После завершения цикла выводим минимальный результат работы алгоритма, больший 221.

# Инициализация переменной для хранения минимального результата > 221
mn = 10 ** 10

for i in range(1, 1000):  # Перебираем числа N от 1 до 999 включительно
    s = bin(i)[2:]  # Перевод в двоичную систему

    # Вычисляем бит чётности
    if s.count("0") % 2 == 0:
        # Если количество нулей чётно, дописываем слева 10,
        # иначе - 11 в конец
        s = "10" + s
    else:
        s += "11"

    r = int(s, 2)  # Переводим в десятичную систему

    # Проверяем, что результат > 221, то есть подходит по условию, и меньше минимального
    if r > 221 and r < mn:
        mn = r
print(mn)

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа N необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем выясняем, делится ли N на 3, используя оператор взятия остатка (%). Если делится, то есть остаток равен нулю, дописываем в конец двоичной записи первую и последнюю цифры. Если не делится, дописываем в начало последнюю и первую цифры. В завершение переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения R проверяем указанное требование. Если условие выполняется, добавляем N в список. В ответ запишем максимальное число из списка.

ans = []
for n in range(1, 1000):
    t = bin(n)[2:]  # Записываем двоичную запись числа
    if n % 3 == 0:
        # Если число n кратно 3, то добавляем справа от числа
        # сначала первую цифру числа, затем - последнюю
        t += t[0] + t[-1]
    else:
        t = t[-1] + t[0] + t  # В ином случае добавляем слева от числа
        # сначала последнюю цифру числа, затем - первую
    r = int(t, 2)  # Переводим число в десятичную систему счисления
    if r < 500:
        ans += [n]
print(max(ans))  # Выводим максимальное n

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа R необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем выясняем, делится ли N на 4, используя оператор взятия остатка (%). Если делится, то есть остаток равен нулю, дописываем в конец двоичной записи две последние цифры. Если не делится, умножаем на 3 остаток от деления N на 4, переводим в двоичную запись и дописываем в конец. В завершение переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения проверяем, превышает ли оно 76 и является ли минимальным среди полученных. Если условие выполняется, обновляем наименьшее значение. После завершения цикла выводим минимальный результат работы алгоритма, больший 76.

# Инициализация переменной для хранения минимального результата > 76
mn = 10 ** 10

for n in range(1, 1000):
    s = bin(n)[2:]  # переводим число в двоичную систему счисления
    if n % 4 == 0:
        # если число n делится на 4, то приписываем
        # две последние цифры s (двоичного числа) к числу s
        s += s[-2] + s[-1]
    if n % 4 != 0:  # если число не делится на 4
        k = (n % 4) * 3  # то умножаем остаток от деления исходного числа на 4
        s1 = bin(k)[2:]  # переводим остаток в двоичную сс
        s += s1  # дописываем этот остаток к двоичной записи числа

    r = int(s, 2)  # Переводим в десятичную систему

    # Проверяем, что результат > 76, то есть подходит по условию, и меньше минимального
    if r > 76 and r < mn:
        mn = r
print(mn)

Решение программой
В условии задачи описан алгоритм, для поиска подходящего числа R необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Сначала переводим число N в двоичную строку с помощью функции bin, затем выясняем, делится ли N на 2, используя оператор взятия остатка (%). Если делится, то есть остаток равен нулю, дописываем в конец двоичной записи две единицы. Если не делится, находим сумму цифр, которая в двоичной записи равна количеству единиц. Затем переводим это значение в двоичную форму и приписываем к исходной записи. В завершение переводим результат в десятичную систему счисления, получаем R.
Далее организуем перебор чисел N в цикле for. Для каждого полученного значения проверяем, превышает ли оно 140 и является ли минимальным среди полученных. Если условие выполняется, обновляем наименьшее значение. После завершения цикла выводим минимальный результат работы алгоритма, больший 140.

# Инициализация переменной для хранения минимального результата > 140
mn = 10 ** 10

for n in range(1, 1000):
    s = bin(n)[2:]  # переводим число в двоичную систему счисления
    if n % 2 == 0:
        # если n делится на 2, то приписываем две единицы
        s += "11"
    else:  # если число не делится на 2
        k = s.count("1")  # то считаем количество единиц в числе
        s1 = bin(k)[2:]  # переводим это количество в двоичную сс
        s += s1  # прибавляем это число к двоичной записи числа

    r = int(s, 2)  # Переводим в десятичную систему

    # Проверяем, что результат > 140, то есть подходит по условию, и меньше минимального
    if r > 140 and r < mn:
        mn = r
print(mn)

Решение программой

В условии задачи описан алгоритм, для поиска подходящего числа N необходимо «перевести» этот алгоритм с естественного языка на язык программирования Python. Первым делом переводим число N в двоичную строку с помощью функции bin. Далее заметим, что сумма цифр двоичной записи совпадает с количеством единиц в ней, так как цифр 2, 3 и более нет. Используя метод count, вычисляем сумму цифр (количество единиц), находим остаток от деления на 2 (% 2), дописываем в конец записи с помощью сложения строк. Повторяем то же самое для обновлённой записи. Осталось перевести результат в десятичную систему счисления, получив R.

Далее организуем перебор чисел N в цикле for. Для каждого полученного значения R проверяем, превышает ли оно 77. Если условие выполняется, выводим N и завершаем цикл, ведь нас интересует наименьшее N, а следующие значения N будут больше, так как цикл перебирает их по возрастанию.

for n in range(1000):  # Перебираем числа N от 0 до 999 включительно
    s = bin(n)[2:]  # Перевод в двоичную систему

    # Считаем количество единиц с помощью count,
    # находим остаток (% 2), дописываем в конец s
    s = s + str(s.count("1") % 2)
    s = s + str(s.count("1") % 2)  # Повторяем для обновлённой записи

    r = int(s, 2)  # Переводим в десятичную систему

    if r > 77:  # Проверяем, что полученное число больше 77
        print(n)  # Первое выведенное N будет минимальным
        break  # Завершаем цикл