Примеры решений — №5

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи дописываются три последние двоичные цифры; б) если число N на 3 не делится, то остаток от деления умножается на 3, переводится в двоичную запись и дописывается в конец числа. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран. Например, для исходного числа 6₁₀ = 110₂ результатом является число 110110₂ = 54₁₀, а для исходного числа 4₁₀ = 100₂ — это число 10011₂ = 19₁₀. Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, ближайшее к 130.

Решение

# Алгоритм с двоичными числами:
# Если N делится на 3 → дописать три последние двоичные цифры
# Если не делится → остаток × 3, перевести в двоичную, дописать
def algo(N):
    b2 = bin(N)[2:]
    if N % 3 == 0:
        result = b2 + b2[-3:]
    else:
        rem = N % 3
        result = b2 + bin(rem * 3)[2:]
    return int(result, 2)
# Найти максимальное N, при котором R ближайшее к 130
best_N = 1
best_dist = abs(algo(1) - 130)
for N in range(1, 1000):
    R = algo(N)
    dist = abs(R - 130)
    if dist < best_dist or (dist == best_dist and N > best_N):
        best_dist = dist
        best_N = N
print(best_N)

Ответ:31

#53

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число чётное, то к двоичной записи числа слева дописывается 10; б) если число нечётное, то к двоичной записи числа слева дописывается 1 и справа дописывается 01. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 4₁₀ = 100₂ результатом является число 10100₂ = 20₁₀, а для исходного числа 5₁₀ = 101₂ это число 110101₂ = 53₁₀. Укажите минимальное число R, которое может быть результатом работы данного алгоритма, при условии, что N больше, чем 18. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами:
# Если N чётное → слева дописывается «10»
# Если N нечётное → слева «1», справа «01»
def algo(N):
    b2 = bin(N)[2:]
    if N % 2 == 0:
        result = '10' + b2
    else:
        result = '1' + b2 + '01'
    return int(result, 2)
# Найти минимальное R при N > 18
results = [algo(N) for N in range(19, 100000)]
print(min(results))

Ответ:84

#54

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи дописываются её три последние двоичные цифры; б) если число N на 3 не делится, то остаток от деления умножается на 3, переводится в двоичную запись и дописывается в конец числа. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 12₁₀ = 1100₂ результатом является число 1100100₂ = 100₁₀, а для исходного числа 4₁₀ = 100₂ это число 10011₂ = 19₁₀. Укажите минимальное число N, после обработки которого с помощью этого алгоритма получается число R, не меньшее 200.

Решение

# Алгоритм с двоичными числами:
# Если N делится на 3 → дописать три последние двоичные цифры
# Если не делится → остаток × 3, перевести в двоичную, дописать
def algo(N):
    b2 = bin(N)[2:]
    if N % 3 == 0:
        result = b2 + b2[-3:]
    else:
        rem = N % 3
        result = b2 + bin(rem * 3)[2:]
    return int(result, 2)
# Найти минимальное N, при котором R >= 200
for N in range(1, 10000):
    R = algo(N)
    if R >= 200:
        print(N)
        break

Ответ:26

#55

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи дописываются две последние троичные цифры; б) если число N на 3 не делится, то записывается сумма цифр получившейся троичной записи, эта сумма переводится в троичную систему счисления и дописывается в конец числа. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 11₁₀ = 102₃ результатом является число 10210₃ = 102₁₀, а для исходного числа 2₁₀ = 11₃ это число 11010₃ = 111₁₀. Укажите минимальное чётное число R, большее 220, которое может быть получено с помощью описанного алгоритма. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с троичными числами:
# Если N делится на 3 → дописать две последние троичные цифры
# Если не делится → сумма цифр, перевести в троичную, дописать
def to_base3(n):
    if n == 0:
        return '0'
    digits = []
    while n:
        digits.append(str(n % 3))
        n //= 3
    return ''.join(reversed(digits))
def algo(N):
    b3 = to_base3(N)
    if N % 3 == 0:
        result = b3 + b3[-2:]
    else:
        digit_sum = sum(int(d) for d in b3)
        result = b3 + to_base3(digit_sum)
    return int(result, 3)
# Найти минимальное чётное R > 220
results = [algo(N) for N in range(1, 100000)]
even_gt220 = [R for R in results if R > 220 and R % 2 == 0]
print(min(even_gt220))

Ответ:222

#56

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число чётное, то к двоичной записи числа слева дописывается 10; б) если число нечётное, то к двоичной записи числа слева дописывается 1 и справа дописывается 01. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 4₁₀ = 100₂ результатом является число 20₁₀ = 10100₂, а для исходного числа 5₁₀ = 101₂ это число 53₁₀ = 110101₂. Укажите максимальное число R, которое может быть результатом работы данного алгоритма, при условии, что N не больше 12. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами:
# Если N чётное → слева дописывается «10»
# Если N нечётное → слева «1», справа «01»
def algo(N):
    b2 = bin(N)[2:]
    if N % 2 == 0:
        result = '10' + b2
    else:
        result = '1' + b2 + '01'
    return int(result, 2)
# Найти максимальное R при N <= 12
results = [algo(N) for N in range(1, 13)]
print(max(results))

Ответ:109

#57

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если сумма цифр в двоичной записи числа чётная, то к этой записи справа дописывается 0, а затем два левых разряда заменяются на 10; б) если сумма цифр в двоичной записи числа нечётная, то к этой записи справа дописывается 1, а затем два левых разряда заменяются на 11. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 110₂ результатом является число 1000₂ = 8₁₀, а для исходного числа 4₁₀ = 100₂ это число 1101₂ = 13₁₀. Укажите минимальное число N, после обработки которого с помощью этого алгоритма получается число R, большее 19. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами:
# Если сумма цифр чётная → справа 0, два левых разряда → «10»
# Если нечётная → справа 1, два левых разряда → «11»
# Пример: N=6=110₂, сумма=2 (чётная) → 1100₂, два левых «10» → 1000₂=8
def algo(N):
    b2 = bin(N)[2:]
    s = b2.count('1')
    if s % 2 == 0:
        extended = b2 + '0'
        result = '10' + extended[2:]
    else:
        extended = b2 + '1'
        result = '11' + extended[2:]
    return int(result, 2)
# Найти минимальное N, при котором R > 19
for N in range(1, 10000):
    R = algo(N)
    if R > 19:
        print(N)
        break

Ответ:8

#58

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число чётное, то к двоичной записи числа слева дописывается 10; б) если число нечётное, то к двоичной записи числа слева дописывается 1 и справа дописывается 01. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 4₁₀ = 100₂ результатом является число 20₁₀ = 10100₂, а для исходного числа 5₁₀ = 101₂ это число 53₁₀ = 110101₂. Укажите максимальное число R, которое может быть результатом работы данного алгоритма, при условии, что N не больше 12. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами:
# Если N чётное → слева дописывается «10»
# Если N нечётное → слева «1», справа «01»
def algo(N):
    b2 = bin(N)[2:]
    if N % 2 == 0:
        result = '10' + b2
    else:
        result = '1' + b2 + '01'
    return int(result, 2)
# Найти максимальное R при N <= 12
results = [algo(N) for N in range(1, 13)]
print(max(results))

Ответ:109

#59

Условие

На вход алгоритма подаётся натуральное число N (N > 2). Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи дописываются две последние троичные цифры; б) если число N на 3 не делится, то остаток от деления умножается на 3, переводится в троичную систему и дописывается в конец числа. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 20₃ результатом является число 2020₃ = 60₁₀, а для исходного числа 4₁₀ = 11₃ это число 1110₃ = 39₁₀. Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число, не превышающее 150.

Решение

# Алгоритм с троичными числами (N > 2):
# Если N делится на 3 → дописать две последние троичные цифры
# Если не делится → остаток × 3, перевести в троичную, дописать
# Пример: N=6=20₃ → 2020₃=60; N=4=11₃ → 1110₃=39
def to_base3(n):
    if n == 0:
        return '0'
    digits = []
    while n:
        digits.append(str(n % 3))
        n //= 3
    return ''.join(reversed(digits))
def algo(N):
    b3 = to_base3(N)
    if N % 3 == 0:
        result = b3 + b3[-2:]
    else:
        rem = N % 3
        result = b3 + to_base3(rem * 3)
    return int(result, 3)
# Найти максимальное N (N > 2), при котором R <= 150
best_N = 0
for N in range(3, 10000):
    R = algo(N)
    if R <= 150:
        best_N = N
print(best_N)

Ответ:16

#510

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. К этой записи дописываются справа ещё два разряда по следующему правилу: а) складываются все цифры двоичной записи, и остаток от деления суммы на 2 дописывается в конец числа (справа). Например, запись 11100 преобразуется в запись 111001; б) над этой записью производятся те же действия – справа дописывается остаток от деления суммы цифр на 2. Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа N) является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 12₁₀ = 1100₂ результатом является число 110000₂ = 48₁₀, а для исходного числа 7₁₀ = 111₂ это число 11110₂ = 30₁₀. Укажите такое наименьшее число N, для которого результат работы алгоритма больше числа 253. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами (два бита чётности):
# Дописывается 2 бита: сначала остаток суммы цифр от 2,
# затем тот же процесс для расширенной записи.
# Пример: 12=1100₂ → 110000₂=48; 7=111₂ → 11110₂=30
def algo(N):
    b2 = bin(N)[2:]
    bit1 = b2.count('1') % 2
    b2_ext = b2 + str(bit1)
    bit2 = b2_ext.count('1') % 2
    result = b2_ext + str(bit2)
    return int(result, 2)
# Найти наименьшее N, при котором R > 253
for N in range(1, 100000):
    R = algo(N)
    if R > 253:
        print(N)
        break

Ответ:64

#511

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи дописываются три последние двоичные цифры; б) если число N на 3 не делится, то остаток от деления умножается на 3, переводится в двоичную запись и дописывается в конец числа. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран. Например, для исходного числа 12₁₀ = 1100₂ результатом является число 1100100₂ = 100₁₀, а для исходного числа 4₁₀ = 100₂ это число 10011₂ = 19₁₀.

Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее 130.

Решение

# Алгоритм с двоичными числами:
# Если N делится на 3 → дописать три последние двоичные цифры
# Если не делится → остаток × 3, перевести в двоичную, дописать
def algo(N):
    b2 = bin(N)[2:]
    if N % 3 == 0:
        result = b2 + b2[-3:]
    else:
        rem = N % 3
        result = b2 + bin(rem * 3)[2:]
    return int(result, 2)
# Найти максимальное N, при котором R < 130
best_N = 0
for N in range(1, 10000):
    R = algo(N)
    if R < 130:
        best_N = N
print(best_N)

Ответ:31

#512

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи дописываются две последние троичные цифры; б) если число N на 3 не делится, то остаток от деления умножается на 5, переводится в троичную запись и дописывается в конец числа. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран. Например, для исходного числа 11₁₀ = 102₃ результатом является число 102101₃ = 307₁₀, а для исходного числа 12₁₀ = 110₃ это число 11010₃ = 111₁₀.

Укажите минимальное число R, большее 150, которое может быть получено с помощью описанного алгоритма. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с троичными числами:
# Если N делится на 3 → дописать две последние троичные цифры
# Если не делится → остаток × 5, перевести в троичную, дописать
def to_base3(n):
    if n == 0:
        return '0'
    digits = []
    while n:
        digits.append(str(n % 3))
        n //= 3
    return ''.join(reversed(digits))
def algo(N):
    b3 = to_base3(N)
    if N % 3 == 0:
        result = b3 + b3[-2:]
    else:
        rem = N % 3
        result = b3 + to_base3(rem * 5)
    return int(result, 3)
# Найти минимальное R > 150
results = [algo(N) for N in range(1, 100000)]
gt150 = [R for R in results if R > 150]
print(min(gt150))

Ответ:162

#513

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то слева к нему приписывается «1», а справа «02»; б) если число N на 3 не делится, то остаток от деления на 3 умножается на 4, переводится в троичную запись и дописывается в конец числа. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 11₁₀ = 102₃ результатом является число 10222₃ = 107₁₀, а для исходного числа 12₁₀ = 110₃ это число 111002₃ = 353₁₀. Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее 100.

Решение

# Алгоритм с троичными числами:
# Если N делится на 3 → слева «1», справа «02»
# Если не делится → остаток × 4, перевести в троичную, дописать в конец
# Пример: N=11=102₃ → 10222₃=107; N=12=110₃ → 111002₃=353
def to_base3(n):
    if n == 0:
        return '0'
    digits = []
    while n:
        digits.append(str(n % 3))
        n //= 3
    return ''.join(reversed(digits))
def algo(N):
    b3 = to_base3(N)
    if N % 3 == 0:
        result = '1' + b3 + '02'
    else:
        rem = N % 3
        result = b3 + to_base3(rem * 4)
    return int(result, 3)
# Найти максимальное N, при котором R < 100
best_N = 0
for N in range(1, 10000):
    R = algo(N)
    if R < 100:
        best_N = N
print(best_N)

Ответ:10

#514

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то слева дописывается «1», а справа - «02». б) если число N на 3 не делится, то остаток от деления числа на 3 умножается на 4, переводится в троичную запись и дописывается в конец числа. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран. Например, для исходного числа 6₁₀ = 20₃ результатом является число 12002₃ = 137₁₀, а для исходного числа 12₁₀ = 110₃ результатом является число 111002₃ = 353₁₀.

Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее чем 199.

Решение

# Алгоритм с троичными числами:
# Если N делится на 3 → слева «1», справа «02»
# Если не делится → остаток × 4, перевести в троичную, дописать в конец
def to_base3(n):
    if n == 0:
        return '0'
    digits = []
    while n:
        digits.append(str(n % 3))
        n //= 3
    return ''.join(reversed(digits))
def algo(N):
    b3 = to_base3(N)
    if N % 3 == 0:
        result = '1' + b3 + '02'
    else:
        rem = N % 3
        result = b3 + to_base3(rem * 4)
    return int(result, 3)
# Найти максимальное N, при котором R < 199
best_N = 0
for N in range(1, 10000):
    R = algo(N)
    if R < 199:
        best_N = N
print(best_N)

Ответ:20

#515

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число чётное, то к двоичной записи числа слева дописывается 10; б) если число нечётное, то к двоичной записи числа слева дописывается 1 и справа дописывается 01 Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран. Например, для исходного числа 4₁₀ = 100₂ результатом является число 20₁₀ = 10100₂, а для исходного числа 5₁₀ = 101₂ это число 53₁₀ = 110101₂.

Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее, чем 30. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами:
# Если N чётное → слева дописывается «10»
# Если N нечётное → слева «1», справа «01»
def algo(N):
    b2 = bin(N)[2:]
    if N % 2 == 0:
        result = '10' + b2
    else:
        result = '1' + b2 + '01'
    return int(result, 2)
# Найти максимальное N, при котором R < 30
best_N = 0
for N in range(1, 10000):
    R = algo(N)
    if R < 30:
        best_N = N
print(best_N)

Ответ:6

#516

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число чётное, то к двоичной записи числа слева дописывается 10; б) если число нечётное, то к двоичной записи числа слева дописывается 1 и справа дописывается 01. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран. Например, для исходного числа 4₁₀ = 100₂ результатом является число 20₁₀ = 10100₂, а для исходного числа 5₁₀ = 101₂ это число 53₁₀ = 110101₂.

Укажите максимальное число R, которое может быть результатом работы данного алгоритма, при условии, что N не больше 12. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами:
# Если N чётное → слева дописывается «10»
# Если N нечётное → слева «1», справа «01»
def algo(N):
    b2 = bin(N)[2:]
    if N % 2 == 0:
        result = '10' + b2
    else:
        result = '1' + b2 + '01'
    return int(result, 2)
# Найти максимальное R при N <= 12
results = [algo(N) for N in range(1, 13)]
print(max(results))

Ответ:109

#5100

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N чётное, то к этой записи справа дописываются две последние двоичные цифры; б) если число N нечётное, то слева к этой записи дописывается 1, а справа дописывается 0. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 110₂ результатом является число 11010₂ = 26₁₀, а для исходного числа 5₁₀ = 101₂ это число 11010₂ = 26₁₀. Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее 100. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 1000):
    s = f(n)
    if n % 2 == 0:
        s = s + s[-2] + s[-1]
    else:
        s = '1' + s + '0'
    r = int(s, 2)
    if r < 100:
        d.append(n)
print(max(d))

Ответ:24

#5101

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N чётное, то слева к двоичной записи дописывается 10; б) если число N нечётное, то слева к двоичной записи дописывается 1, а справа дописывается 01. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 4₁₀ = 100₂ результатом является число 10100₂ = 20₁₀, а для исходного числа 5₁₀ = 101₂ это число 110101₂ = 53₁₀. Укажите максимальное число N, для которого результат работы алгоритма меньше 50. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 400):
    s = f(n)
    if n % 2 == 0:
        s = '10' + s
    else:
        s = '1' + s + '01'
    r = int(s, 2)
    if r < 50:
        d.append(n)
print(max(d))

Ответ:14

#5102

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи справа дописываются две последние троичные цифры; б) если число N на 3 не делится, то вычисляется сумма цифр троичной записи, полученная сумма переводится в троичную систему счисления и дописывается в конец числа. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 8₁₀ = 22₃ результатом является число 2211₃ = 76₁₀, а для исходного числа 9₁₀ = 100₃ это число 10000₃ = 81₁₀. Укажите минимальное нечётное число R, большее 250, которое может быть получено с помощью описанного алгоритма. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if n % 3 == 0:
        s = s + s[-2:]
    else:
        c = sum([int(x) for x in s])
        s = s + f(c)
    r = int(s, 3)
    if r > 250 and r % 2 != 0:
        d.append(r)
print(min(d))

Ответ:273

#5103

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи справа дописываются три последние двоичные цифры; б) если число N на 3 не делится, то остаток от деления N на 3 умножается на 3, переводится в двоичную систему счисления и дописывается в конец числа. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 110₂ результатом является число 110110₂ = 54₁₀, а для исходного числа 4₁₀ = 100₂ это число 10011₂ = 19₁₀. Укажите минимальное число N, после обработки которого с помощью этого алгоритма получается число R, не меньшее 160.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 500):
    s = f(n)
    if n % 3 == 0:
        s = s + s[-3:]
    else:
        ost = (n % 3) * 3
        s = s + f(ost)
    r = int(s, 2)
    if r >= 160:
        print(n)
        break

Ответ:20

#5104

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи справа дописываются три последние двоичные цифры; б) если число N на 3 не делится, то остаток от деления N на 3 умножается на 3, переводится в двоичную систему счисления и дописывается в конец числа. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 12₁₀ = 1100₂ результатом является число 1100100₂ = 100₁₀, а для исходного числа 5₁₀ = 101₂ это число 101110₂ = 46₁₀. Укажите максимальное число N, после обработки которого получается число R, ближайшее к 140. Если таких чисел несколько, выберите большее N.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 300):
    s = f(n)
    if n % 3 == 0:
        s = s + s[-3:]
    else:
        ost = (n % 3) * 3
        s = s + f(ost)
    r = int(s, 2)
    d.append([abs(r - 140), n])
d.sort()
print(d[0][1])

Ответ:34

#5105

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то к этой записи справа дописываются две последние троичные цифры; б) если число N на 3 не делится, то вычисляется сумма цифр троичной записи, умножается на 3, переводится в троичную систему счисления и дописывается в конец числа. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 11₁₀ = 102₃ результатом является число 10210₃ = 102₁₀, а для исходного числа 4₁₀ = 11₃ это число 1120₃ = 42₁₀. Укажите минимальное число R, большее 300 и кратное 5, которое может быть получено с помощью описанного алгоритма. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if n % 3 == 0:
        s = s + s[-2:]
    else:
        c = sum([int(x) for x in s]) * 3
        s = s + f(c)
    r = int(s, 3)
    if r > 300 and r % 5 == 0:
        d.append(r)
print(min(d))

Ответ:360

#5106

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N чётное, то слева к двоичной записи дописывается 11; б) если число N нечётное, то справа к двоичной записи дописывается 01. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 4₁₀ = 100₂ результатом является число 11100₂ = 28₁₀, а для исходного числа 5₁₀ = 101₂ это число 10101₂ = 21₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 20. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 21):
    s = f(n)
    if n % 2 == 0:
        s = '11' + s
    else:
        s = s + '01'
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:116

#5107

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N чётное, то слева к троичной записи дописывается цифра 2; б) если число N нечётное, то справа к троичной записи дважды дописывается её последняя цифра. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 20₃ результатом является число 220₃ = 24₁₀, а для исходного числа 5₁₀ = 12₃ это число 1222₃ = 53₁₀. Укажите максимальное число N, для которого результат работы алгоритма меньше 200. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 1000):
    s = f(n)
    if n % 2 == 0:
        s = '2' + s
    else:
        s = s + s[-1] + s[-1]
    r = int(s, 3)
    if r < 200:
        d.append(n)
print(max(d))

Ответ:36

#5108

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N делится на 3, то слева к этой записи дописывается 1; б) если число N на 3 не делится, то в конец записи дописывается троичная запись остатка от деления N на 3. Полученная таким образом запись является троичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 20₃ результатом является число 120₃ = 15₁₀, а для исходного числа 5₁₀ = 12₃ это число 122₃ = 17₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 30. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 31):
    s = f(n)
    if n % 3 == 0:
        s = '1' + s
    else:
        s = s + f(n % 3)
    r = int(s, 3)
    d.append(r)
print(max(d))

Ответ:111

#5109

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если число N чётное, то вычисляется сумма цифр двоичной записи числа N, эта сумма переводится в двоичную систему счисления и дописывается в конец записи; б) если число N нечётное, то справа к двоичной записи дописывается 11. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 110₂ сумма цифр равна 2, поэтому результатом является число 11010₂ = 26₁₀, а для исходного числа 5₁₀ = 101₂ это число 10111₂ = 23₁₀. Укажите минимальное число N, после обработки которого получается число R, большее 150.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 300):
    s = f(n)
    if n % 2 == 0:
        c = sum([int(x) for x in s])
        s = s + f(c)
    else:
        s = s + '11'
    r = int(s, 2)
    if r > 150:
        print(n)
        break

Ответ:30

#5110

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему число R следующим образом. 1. Строится двоичная запись числа N. 2. Если число N чётное, то в конец записи дописывается её первая цифра, затем последняя. Если число N нечётное, то слева дописывается 1, а справа дописывается 1. 3. Полученная запись является двоичной записью числа R.

Определите максимальное число N, для которого результат R меньше 120.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 500):
    s = f(n)
    if n % 2 == 0:
        s = s + s[0] + s[-1]
    else:
        s = '1' + s + '1'
    r = int(s, 2)
    if r < 120:
        d.append(n)
print(max(d))

Ответ:28

#5111

Условие

На вход алгоритма подаётся число N. Алгоритм строит число R. 1. Строится троичная запись числа N. 2. Если N делится на 3, то справа дописывается последняя цифра записи два раза. Иначе слева дописывается 2. 3. Полученное число — это троичная запись R.

Найдите минимальное число R, большее 200.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if n % 3 == 0:
        s = s + s[-1] + s[-1]
    else:
        s = '2' + s
    r = int(s, 3)
    if r > 200:
        d.append(r)
print(min(d))

Ответ:202

#5112

Условие

Алгоритм получает число N. 1. Строится двоичная запись. 2. Если число нечётное, к записи дописывается сумма её цифр в двоичной системе. Если чётное — слева дописывается 11. 3. Результат — число R.

Найдите максимальное R при N ≤ 25.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 26):
    s = f(n)
    if n % 2 != 0:
        c = sum(int(x) for x in s)
        s = s + f(c)
    else:
        s = '11' + s
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:188

#5113

Условие

Алгоритм принимает число N. 1. Переводит его в троичную систему. 2. Если сумма цифр делится на 2, справа дописывается эта сумма в троичной системе. Иначе слева дописывается 1. 3. Получается число R.

Найдите минимальное нечётное R, большее 150.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 2 == 0:
        s = s + f(c)
    else:
        s = '1' + s
    r = int(s, 3)
    if r > 150 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:163

#5114

Условие

Алгоритм получает число N. 1. Строится двоичная запись. 2. Если N делится на 3, дописываются последние 2 бита. Иначе справа дописывается двоичная запись остатка от деления. 3. Получается число R.

Найдите максимальное N, при котором R < 90.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 300):
    s = f(n)
    if n % 3 == 0:
        s = s + s[-2:]
    else:
        s = s + f(n % 3)
    r = int(s, 2)
    if r < 90:
        d.append(n)
print(max(d))

Ответ:43

#5115

Условие

Алгоритм принимает число N. 1. Переводит в троичную систему. 2. Если число чётное — слева дописывается 2. Если нечётное — справа дописывается сумма цифр. 3. Получается R.

Найдите минимальное R > 180.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if n % 2 == 0:
        s = '2' + s
    else:
        c = sum(int(x) for x in s)
        s = s + f(c)
    r = int(s, 3)
    if r > 180:
        d.append(r)
print(min(d))

Ответ:190

#5116

Условие

Алгоритм получает число N. 1. Строится двоичная запись. 2. Если сумма цифр чётная — справа дописывается 0. Иначе слева дописывается 1. 3. Получается число R.

Найдите максимальное R при N ≤ 40.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 41):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 2 == 0:
        s = s + '0'
    else:
        s = '1' + s
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:102

#5117

Условие

Алгоритм принимает число N. 1. Переводит его в троичную систему. 2. Если N делится на 3 — справа дописывается 0. Иначе — слева дописывается 1. 3. Получается число R.

Найдите минимальное R > 100.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 1000):
    s = f(n)
    if n % 3 == 0:
        s = s + '0'
    else:
        s = '1' + s
    r = int(s, 3)
    if r > 100:
        d.append(r)
print(min(d))

Ответ:108

#5118

Условие

Алгоритм получает число N. 1. Строится двоичная запись. 2. Если N чётное — справа дописывается 01. Если нечётное — слева дописывается 10. 3. Получается число R.

Найдите максимальное число N, при котором R < 200.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 200):
    s = f(n)
    if n % 2 == 0:
        s = s + '01'
    else:
        s = '10' + s
    r = int(s, 2)
    if r < 200:
        d.append(n)
print(max(d))

Ответ:63

#5119

Условие

Алгоритм получает число N. 1. Строится троичная запись. 2. Если сумма цифр нечётная — справа дописывается последняя цифра. Иначе — слева дописывается 2. 3. Получается число R.

Найдите минимальное R > 250.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 2 != 0:
        s = s + s[-1]
    else:
        s = '2' + s
    r = int(s, 3)
    if r > 250:
        d.append(r)
print(min(d))

Ответ:251

#5120

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если количество единиц в двоичной записи числа чётно, то в конец записи дописывается 10; б) если количество единиц в двоичной записи числа нечётно, то слева к записи дописывается 1. Полученная таким образом запись является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 6₁₀ = 110₂ результатом является число 11010₂ = 26₁₀, а для исходного числа 5₁₀ = 101₂ это число 1101₂ = 13₁₀. Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее 100.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if s.count('1') % 2 == 0:
        s = s + '10'
    else:
        s = '1' + s
    r = int(s, 2)
    if r < 100:
        d.append(n)
print(max(d))

Ответ:35

#5121

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R следующим образом. 1. Строится двоичная запись числа N. 2. Если количество нулей в этой записи чётно, то справа дописывается последняя цифра записи. 3. Если количество нулей в этой записи нечётно, то справа дописывается 11. Полученная запись считается двоичной записью числа R.

Например, для числа 4₁₀ = 100₂ получается число 10011₂ = 19₁₀, а для числа 10₁₀ = 1010₂ получается число 10100₂ = 20₁₀. Укажите минимальное нечётное число R, большее 130, которое может быть получено с помощью этого алгоритма.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if s.count('0') % 2 == 0:
        s = s + s[-1]
    else:
        s = s + '11'
    r = int(s, 2)
    if r > 130 and r % 2 != 0:
        d.append(r)
print(min(d))

Ответ:131

#5122

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему число R. 1. Строится троичная запись числа N. 2. Если сумма цифр этой записи кратна 3, то слева к записи дописывается цифра 2. 3. Если сумма цифр этой записи не кратна 3, то остаток от деления суммы цифр на 3 переводится в троичную систему счисления и дописывается справа. Полученная запись является троичной записью числа R.

Например, для числа 5₁₀ = 12₃ сумма цифр равна 3, поэтому получается число 212₃ = 23₁₀. А для числа 4₁₀ = 11₃ сумма цифр равна 2, поэтому получается число 112₃ = 14₁₀. Укажите минимальное число R, большее 170.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 3 == 0:
        s = '2' + s
    else:
        s = s + f(c % 3)
    r = int(s, 3)
    if r > 170:
        d.append(r)
print(min(d))

Ответ:175

#5123

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R следующим образом. 1. Строится двоичная запись числа N. 2. Если в этой записи единиц больше, чем нулей, то сумма цифр записи переводится в двоичную систему счисления и дописывается справа. 3. Если единиц не больше, чем нулей, то слева к записи дописывается 10. Полученная запись является двоичной записью числа R.

Например, для числа 7₁₀ = 111₂ сумма цифр равна 3, поэтому получается число 11111₂ = 31₁₀. Для числа 8₁₀ = 1000₂ получается число 101000₂ = 40₁₀. Укажите максимальное число R, которое может получиться при N, не превышающем 30.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 31):
    s = f(n)
    if s.count('1') > s.count('0'):
        c = sum([int(x) for x in s])
        s = s + f(c)
    else:
        s = '10' + s
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:244

#5124

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Если число N делится на 4, то справа к записи дописываются две её первые цифры. 3. Если число N на 4 не делится, то остаток от деления N на 4 переводится в троичную систему счисления и дописывается справа. Полученная запись является троичной записью числа R.

Например, для числа 8₁₀ = 22₃ получается число 2222₃ = 80₁₀, а для числа 6₁₀ = 20₃ остаток от деления на 4 равен 2, поэтому получается число 202₃ = 20₁₀. Укажите минимальное чётное число R, большее 220.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if n % 4 == 0:
        s = s + s[:2]
    else:
        s = s + f(n % 4)
    r = int(s, 3)
    if r > 220 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:224

#5125

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм выполняет следующие действия. 1. Строится двоичная запись числа N. 2. Если сумма цифр этой записи чётна, то слева к записи дописывается 11. 3. Если сумма цифр этой записи нечётна, то остаток от деления n на 2 увеличивается на 1, переводится в двоичную систему счисления и дописывается справа. Полученная запись считается двоичной записью числа R.

Например, для числа 6₁₀ = 110₂ сумма цифр равна 2, поэтому получается число 11110₂ = 30₁₀. Для числа 5₁₀ = 101₂ сумма цифр равна 2, поэтому получается число 11101₂ = 29₁₀. Укажите минимальное число N, для которого результат работы алгоритма будет не меньше 200.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 100000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 2 == 0:
        s = '11' + s
    else:
        s = s + f((n % 2) + 1)
    r = int(s, 2)
    if r >= 200:
        print(n)
        break

Ответ:33

#5126

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Записывается троичная запись числа N. 2. Если в этой записи есть хотя бы одна цифра 2, то справа дописывается ещё одна цифра 2. 3. Если цифры 2 в записи нет, то слева дописывается цифра 1. Полученная запись является троичной записью числа R.

Например, для числа 5₁₀ = 12₃ получается число 122₃ = 17₁₀, а для числа 4₁₀ = 11₃ получается число 111₃ = 13₁₀. Укажите максимальное число N, для которого число R меньше 150.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if '2' in s:
        s = s + '2'
    else:
        s = '1' + s
    r = int(s, 3)
    if r < 150:
        d.append(n)
print(max(d))

Ответ:49

#5127

Условие

На вход алгоритма подаётся натуральное число N. По нему строится новое число R. 1. Строится двоичная запись числа N. 2. Если количество единиц в записи кратно 3, то это количество переводится в двоичную систему счисления и дописывается справа. 3. Если количество единиц в записи не кратно 3, то слева к записи дописывается 1, а справа дописывается 0. Полученная запись является двоичной записью числа R.

Например, для числа 7₁₀ = 111₂ количество единиц равно 3, поэтому получается число 11111₂ = 31₁₀. Для числа 6₁₀ = 110₂ получается число 11100₂ = 28₁₀. Укажите минимальное число R, большее 260.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if s.count('1') % 3 == 0:
        s = s + f(s.count('1'))
    else:
        s = '1' + s + '0'
    r = int(s, 2)
    if r > 260:
        d.append(r)
print(min(d))

Ответ:271

#5128

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R следующим образом. 1. Строится троичная запись числа N. 2. Если сумма цифр этой записи нечётна, то справа дважды дописывается последняя цифра записи. 3. Если сумма цифр этой записи чётна, то остаток от деления n на 2 увеличивается на 1, переводится в троичную систему счисления и дописывается справа. Полученная запись считается троичной записью числа R.

Например, для числа 5₁₀ = 12₃ сумма цифр равна 3, поэтому получается число 1222₃ = 53₁₀. Для числа 6₁₀ = 20₃ сумма цифр равна 2, поэтому получается число 202₃ = 20₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 40.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 41):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 2 != 0:
        s = s + s[-1] + s[-1]
    else:
        s = s + f((n % 2) + 1)
    r = int(s, 3)
    d.append(r)
print(max(d))

Ответ:351

#5129

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Строится двоичная запись числа N. 2. Если N делится на 5, то справа к записи дописываются две её последние цифры. 3. Если N на 5 не делится, то остаток от деления N на 5 переводится в двоичную систему счисления и дописывается справа. Полученная запись является двоичной записью числа R.

Например, для числа 10₁₀ = 1010₂ получается число 101010₂ = 42₁₀. Для числа 6₁₀ = 110₂ остаток от деления на 5 равен 1, поэтому получается число 1101₂ = 13₁₀. Укажите максимальное число N, после обработки которого получается число R, ближайшее к 150. Если таких чисел несколько, выберите большее N.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if n % 5 == 0:
        s = s + s[-2:]
    else:
        s = s + f(n % 5)
    r = int(s, 2)
    d.append([abs(r - 150), -n, n])
d.sort()
print(d[0][2])

Ответ:37

#5130

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Записывается троичная запись числа N. 2. Если количество цифр 1 в записи чётно, то слева дописывается цифра 2. 3. Если количество цифр 1 в записи нечётно, то это количество переводится в троичную систему счисления и дописывается справа. Полученная запись является троичной записью числа R.

Например, для числа 4₁₀ = 11₃ количество единиц равно 2, поэтому получается число 211₃ = 22₁₀. Для числа 7₁₀ = 21₃ количество единиц равно 1, поэтому получается число 211₃ = 22₁₀. Укажите минимальное число R, большее 300 и кратное 4.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if s.count('1') % 2 == 0:
        s = '2' + s
    else:
        s = s + f(s.count('1'))
    r = int(s, 3)
    if r > 300 and r % 4 == 0:
        d.append(r)
print(min(d))

Ответ:304

#5131

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится двоичная запись числа N. 2. Если сумма цифр записи кратна 3, то справа дописывается 01. 3. Если сумма цифр записи не кратна 3, то к остатку от деления n на 3 прибавляется единица и эта сумма переводится в троичную систему счисления и дописывается слева. Полученная запись является двоичной записью числа R.

Например, для числа 7₁₀ = 111₂ сумма цифр равна 3, поэтому получается число 11101₂ = 29₁₀. Для числа 8₁₀ = 1000₂ сумма цифр равна 1, а N mod 3 = 2, поэтому получается число 111000₂ = 56₁₀. Укажите максимальное число N, для которого результат R меньше 180.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 3 == 0:
        s = s + '01'
    else:
        s = f((n % 3) + 1) + s
    r = int(s, 2)
    if r < 180:
        d.append(n)
print(max(d))

Ответ:60

#5132

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится троичная запись числа N. 2. Если количество нулей в записи нечётно, то слева дописывается цифра 1. 3. Если количество нулей в записи чётно, то справа дописывается цифра 2. Полученная запись считается троичной записью числа R.

Например, для числа 9₁₀ = 100₃ получается число 1100₃ = 36₁₀, а для числа 8₁₀ = 22₃ получается число 222₃ = 26₁₀. Укажите минимальное число N, после обработки которого получается число R, не меньшее 250.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 100000):
    s = f(n)
    if s.count('0') % 2 == 1:
        s = '1' + s
    else:
        s = s + '2'
    r = int(s, 3)
    if r >= 250:
        print(n)
        break

Ответ:82

#5133

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Находится двоичная запись числа N. 2. Если в этой записи ровно две единицы, то число N mod 3 увеличивается на 1, переводится в двоичную систему счисления и дописывается справа. 3. Если единиц не две, то слева дописывается 10, а справа дописывается 1. Полученная запись является двоичной записью числа R.

Например, для числа 10₁₀ = 1010₂ единиц две, а N mod 3 = 1, поэтому получается число 101010₂ = 42₁₀. Для числа 7₁₀ = 111₂ получается число 101111₂ = 47₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 50.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 51):
    s = f(n)
    if s.count('1') == 2:
        s = s + f((n % 3) + 1)
    else:
        s = '10' + s + '1'
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:357

#5134

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Если число N не делится на 3, то остаток от деления N на 3 переводится в троичную систему счисления и дописывается справа. 3. Если число N делится на 3, то последняя цифра троичной записи дописывается слева. Полученная запись является троичной записью числа R.

Например, для числа 5₁₀ = 12₃ остаток от деления на 3 равен 2, поэтому получается число 122₃ = 17₁₀. Для числа 6₁₀ = 20₃ получается число 220₃ = 24₁₀. Укажите минимальное нечётное число R, большее 200.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if n % 3 != 0:
        s = s + f(n % 3)
    else:
        s = s[-1] + s
    r = int(s, 3)
    if r > 200 and r % 2 != 0:
        d.append(r)
print(min(d))

Ответ:201

#5135

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится двоичная запись числа N. 2. Если нулей в записи больше, чем единиц, то справа дописывается 0. 3. Если нулей не больше, чем единиц, то количество нулей увеличивается на 1(справа дописывается нуль), переводится в двоичную систему счисления и дописывается справа. Полученная запись считается двоичной записью числа R.

Например, для числа 8₁₀ = 1000₂ нулей больше, чем единиц, поэтому получается число 10000₂ = 16₁₀. Для числа 7₁₀ = 111₂ нулей нет, поэтому справа дописывается 1 и получается число 1111₂ = 15₁₀. Укажите минимальное чётное число R, большее 140.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if s.count('0') > s.count('1'):
        s = s + '0'
    else:
        s = s + f(s.count('0') + 1)
    r = int(s, 2)
    if r > 140 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:144

#5136

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Если сумма цифр записи кратна 4, то эта сумма переводится в троичную систему счисления и дописывается справа. 3. Если сумма цифр записи не кратна 4, то к остатку от деления n на 3 прибавляется единица и эта сумма переводится в троичную систему счисления и дописывается слева. Полученная запись является троичной записью числа R.

Например, для числа 7₁₀ = 21₃ сумма цифр равна 3, поэтому получается число 321₃, а для числа 8₁₀ = 22₃ сумма цифр равна 4, поэтому получается число 2211₃. Укажите максимальное число N, для которого результат R меньше 500.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 4 == 0:
        s = s + f(c)
    else:
        s = f((n % 3) + 1) + s
    r = int(s, 3)
    if r < 500:
        d.append(n)
print(max(d))

Ответ:237

#5137

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Находится двоичная запись числа N. 2. Если N чётное, то количество единиц в записи переводится в двоичную систему счисления и дописывается справа. 3. Если N нечётное, то количество нулей увеличивается на 1, переводится в двоичную систему счисления и дописывается слева. Полученная запись считается двоичной записью числа R.

Например, для числа 10₁₀ = 1010₂ количество единиц равно 2, поэтому получается число 101010₂ = 42₁₀. Для числа 9₁₀ = 1001₂ количество нулей равно 2, поэтому получается число 111001₂ = 57₁₀. Укажите минимальное число R, большее 220.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 100000):
    s = f(n)
    if n % 2 == 0:
        s = s + f(s.count('1'))
    else:
        s = f(s.count('0') + 1) + s
    r = int(s, 2)
    if r > 220:
        d.append(r)
print(min(d))

Ответ:227

#5138

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Если количество цифр 2 в записи нечётно, то справа дописывается цифра 1. 3. Если количество цифр 2 в записи чётно, то остаток от деления n на 4 увеличивается на 1, переводится в троичную систему счисления и дописывается справа. Полученная запись является троичной записью числа R.

Например, для числа 8₁₀ = 22₃ количество цифр 2 равно 2, поэтому справа дописывается 3₁₀ = 10₃ и получается 2210₃. Для числа 5₁₀ = 12₃ количество цифр 2 равно 1, поэтому получается 121₃. Укажите максимальное число R, которое может быть получено при N, не превышающем 60.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 61):
    s = f(n)
    if s.count('2') % 2 == 1:
        s = s + '1'
    else:
        s = s + f((n % 4) + 1)
    r = int(s, 3)
    d.append(r)
print(max(d))

Ответ:535

#5139

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится двоичная запись числа N. 2. Если сумма цифр двоичной записи больше 3, то справа дописываются две последние цифры этой записи. 3. Если сумма цифр двоичной записи не больше 3, то слева дописывается 11. Полученная запись считается двоичной записью числа R.

Например, для числа 15₁₀ = 1111₂ сумма цифр равна 4, поэтому получается число 111111₂ = 63₁₀. Для числа 6₁₀ = 110₂ сумма цифр равна 2, поэтому получается число 11110₂ = 30₁₀. Укажите минимальное число N, после обработки которого получается число R, не меньшее 300.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 100000):
    s = f(n)
    if sum([int(x) for x in s]) > 3:
        s = s + s[-2:]
    else:
        s = '11' + s
    r = int(s, 2)
    if r >= 300:
        print(n)
        break

Ответ:64

#5140

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему число R следующим образом. 1. Строится двоичная запись числа N. 2. Если количество единиц в двоичной записи чётно, то справа к записи дописывается 10. 3. Если количество единиц в двоичной записи нечётно, то слева к записи дописывается её последняя цифра. Полученная запись является двоичной записью числа R.

Например, для числа 6₁₀ = 110₂ получается число 11010₂ = 26₁₀, а для числа 5₁₀ = 101₂ получается число 1101₂ = 13₁₀. Укажите максимальное число N, для которого результат работы алгоритма меньше 150.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if s.count('1') % 2 == 0:
        s = s + '10'
    else:
        s = s[-1] + s
    r = int(s, 2)
    if r < 150:
        d.append(n)
print(max(d))

Ответ:148

#5141

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Если сумма цифр троичной записи чётна, то справа к записи дважды дописывается её первая цифра. 3. Если сумма цифр троичной записи нечётна, то слева к записи дописывается цифра 2. Полученная запись считается троичной записью числа R.

Например, для числа 4₁₀ = 11₃ сумма цифр равна 2, поэтому получается число 1111₃ = 40₁₀. Для числа 5₁₀ = 12₃ сумма цифр равна 3, поэтому получается число 212₃ = 23₁₀. Укажите минимальное нечётное число R, большее 200.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    if sum([int(x) for x in s]) % 2 == 0:
        s = s + s[0] + s[0]
    else:
        s = '2' + s
    r = int(s, 3)
    if r > 200 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:201

#5142

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R следующим образом. 1. Строится двоичная запись числа N. 2. Если в записи нулей больше, чем единиц, то справа дописывается двоичная запись суммы цифр этой записи. 3. Если нулей не больше, чем единиц, то слева дописывается 10. Полученная запись является двоичной записью числа R.

Например, для числа 8₁₀ = 1000₂ сумма цифр равна 1, поэтому получается число 10001₂ = 17₁₀. Для числа 7₁₀ = 111₂ получается число 10111₂ = 23₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 40.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 41):
    s = f(n)
    if s.count('0') > s.count('1'):
        s = s + f(sum([int(x) for x in s]))
    else:
        s = '10' + s
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:167

#5143

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Если количество цифр 2 в троичной записи нечётно, то справа дописывается последняя цифра записи. 3. Если количество цифр 2 в троичной записи чётно, то справа дописывается троичная запись числа, равного количеству цифр 1, увеличенному на 1. Полученная запись является троичной записью числа R.

Например, для числа 5₁₀ = 12₃ количество двоек нечётно, поэтому получается число 122₃ = 17₁₀. Для числа 9₁₀ = 100₃ количество двоек равно 0, а количество единиц равно 1, поэтому получается число 1002₃ = 29₁₀. Укажите минимальное число N, при котором число R становится не меньше 250.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 10000):
    s = f(n)
    if s.count('2') % 2 == 1:
        s = s + s[-1]
    else:
        s = s + f(s.count('1') + 1)
    r = int(s, 3)
    if r >= 250:
        print(n)
        break

Ответ:28

#5144

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Записывается двоичная запись числа N. 2. Если сумма цифр двоичной записи кратна 3, то справа дописываются две последние цифры записи. 3. Если сумма цифр двоичной записи не кратна 3, то слева дописывается 1, а справа дописывается первая цифра записи. Полученная запись считается двоичной записью числа R.

Например, для числа 7₁₀ = 111₂ сумма цифр равна 3, поэтому получается число 11111₂ = 31₁₀. Для числа 8₁₀ = 1000₂ получается число 110001₂ = 49₁₀. Укажите минимальное чётное число R, большее 180.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if sum([int(x) for x in s]) % 3 == 0:
        s = s + s[-2:]
    else:
        s = '1' + s + s[0]
    r = int(s, 2)
    if r > 180 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:202

#5145

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Если количество нулей в троичной записи чётно, то слева дописывается цифра 1. 3. Если количество нулей в троичной записи нечётно, то справа дописываются две цифры 2. Полученная запись является троичной записью числа R.

Например, для числа 4₁₀ = 11₃ количество нулей равно 0, поэтому получается число 111₃ = 13₁₀. Для числа 9₁₀ = 100₃ количество нулей равно 2, поэтому получается число 1100₃ = 36₁₀. Укажите максимальное число N, для которого результат работы алгоритма меньше 300.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if s.count('0') % 2 == 0:
        s = '1' + s
    else:
        s = s + '22'
    r = int(s, 3)
    if r < 300:
        d.append(n)
print(max(d))

Ответ:80

#5146

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R следующим образом. 1. Строится двоичная запись числа N. 2. Если первая и последняя цифры записи совпадают, то справа дописывается 01. 3. Если первая и последняя цифры записи различны, то справа дописывается двоичная запись количества цифр в этой записи. Полученная запись является двоичной записью числа R.

Например, для числа 5₁₀ = 101₂ первая и последняя цифры совпадают, поэтому получается число 10101₂ = 21₁₀. Для числа 6₁₀ = 110₂ первая и последняя цифры различны, поэтому получается число 11011₂ = 27₁₀. Укажите максимальное число N, для которого число R является ближайшим к 220. Если таких чисел несколько, выберите большее N.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 200):
    s = f(n)
    if s[0] == s[-1]:
        s = s + '01'
    else:
        s = s + f(len(s))
    r = int(s, 2)
    d.append([abs(r - 220), -n, n])
d.sort()
print(d[0][2])

Ответ:55

#5147

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится троичная запись числа N. 2. Если сумма цифр троичной записи кратна 3, то слева к записи дописывается её последняя цифра. 3. Если сумма цифр троичной записи не кратна 3, то справа к записи дописывается её первая цифра. Полученная запись считается троичной записью числа R.

Например, для числа 6₁₀ = 20₃ сумма цифр равна 2, поэтому получается число 202₃ = 20₁₀. Для числа 9₁₀ = 100₃ сумма цифр равна 1, поэтому получается число 1001₃ = 28₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 60.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 61):
    s = f(n)
    if sum([int(x) for x in s]) % 3 == 0:
        s = s[-1] + s
    else:
        s = s + s[0]
    r = int(s, 3)
    d.append(r)
print(max(d))

Ответ:212

#5148

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится двоичная запись числа N. 2. Если в двоичной записи ровно две единицы, то слева дописывается 11. 3. Если единиц не две, то справа дважды дописывается последняя цифра записи. Полученная запись является двоичной записью числа R.

Например, для числа 10₁₀ = 1010₂ единиц две, поэтому получается число 111010₂ = 58₁₀. Для числа 7₁₀ = 111₂ получается число 11111₂ = 31₁₀. Укажите минимальное число R, большее 130.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if s.count('1') == 2:
        s = '11' + s
    else:
        s = s + s[-1] + s[-1]
    r = int(s, 2)
    if r > 130:
        d.append(r)
print(min(d))

Ответ:143

#5149

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Записывается троичная запись числа N. 2. Если в этой записи цифр 1 больше, чем цифр 2, то справа дописывается троичная запись суммы цифр записи. 3. Если цифр 1 не больше, чем цифр 2, то слева дописывается 2, а справа дописывается 1. Полученная запись считается троичной записью числа R.

Например, для числа 4₁₀ = 11₃ цифр 1 больше, чем цифр 2, поэтому получается число 112₃ = 14₁₀. Для числа 8₁₀ = 22₃ получается число 2221₃ = 79₁₀. Укажите максимальное число N, для которого результат работы алгоритма меньше 500.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if s.count('1') > s.count('2'):
        s = s + f(sum([int(x) for x in s]))
    else:
        s = '2' + s + '1'
    r = int(s, 3)
    if r < 500:
        d.append(n)
print(max(d))

Ответ:108

#5150

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится двоичная запись числа N. 2. Если количество нулей в двоичной записи нечётно, то слева к записи дописывается её первая цифра. 3. Если количество нулей в двоичной записи чётно, то справа дописывается 10. Полученная запись является двоичной записью числа R.

Например, для числа 8₁₀ = 1000₂ количество нулей равно 3, поэтому получается число 11000₂ = 24₁₀. Для числа 10₁₀ = 1010₂ количество нулей равно 2, поэтому получается число 101010₂ = 42₁₀. Укажите минимальное число N, при котором результат работы алгоритма становится не меньше 170.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 10000):
    s = f(n)
    if s.count('0') % 2 == 1:
        s = s[0] + s
    else:
        s = s + '10'
    r = int(s, 2)
    if r >= 170:
        print(n)
        break

Ответ:43

#5151

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Если сумма цифр записи больше 3, то справа дописывается троичная запись числа, равного количеству нулей записи, увеличенному на 1. 3. Если сумма цифр записи не больше 3, то слева дописывается 1. Полученная запись является троичной записью числа R.

Например, для числа 4₁₀ = 11₃ сумма цифр равна 2, поэтому получается число 111₃ = 13₁₀. Для числа 7₁₀ = 21₃ сумма цифр равна 3, поэтому получается число 121₃ = 16₁₀. Укажите минимальное число R, большее 140 и кратное 5.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if sum([int(x) for x in s]) > 3:
        s = s + f(s.count('0') + 1)
    else:
        s = '1' + s
    r = int(s, 3)
    if r > 140 and r % 5 == 0:
        d.append(r)
print(min(d))

Ответ:155

#5152

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Находится двоичная запись числа N. 2. Если нулей в записи нет, то справа дописывается 0. 3. Если нули в записи есть, то слева дописывается двоичная запись количества нулей. Полученная запись считается двоичной записью числа R.

Например, для числа 7₁₀ = 111₂ получается число 1110₂ = 14₁₀. Для числа 8₁₀ = 1000₂ количество нулей равно 3, поэтому получается число 111000₂ = 56₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 35.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 36):
    s = f(n)
    if s.count('0') == 0:
        s = s + '0'
    else:
        s = f(s.count('0')) + s
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:352

#5153

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Если первая цифра записи равна 1, то справа дописывается 2. 3. Если первая цифра записи не равна 1, то слева дописывается троичная запись суммы цифр этой записи. Полученная запись является троичной записью числа R.

Например, для числа 4₁₀ = 11₃ первая цифра равна 1, поэтому получается число 112₃ = 14₁₀. Для числа 8₁₀ = 22₃ сумма цифр равна 4, то есть 11₃, поэтому получается число 1122₃ = 44₁₀. Укажите максимальное число N, для которого результат работы алгоритма меньше 400.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if s[0] == '1':
        s = s + '2'
    else:
        s = f(sum([int(x) for x in s])) + s
    r = int(s, 3)
    if r < 400:
        d.append(n)
print(max(d))

Ответ:132

#5154

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R следующим образом. 1. Строится двоичная запись числа N. 2. Если количество единиц в записи чётно, то справа дописывается двоичная запись количества единиц. 3. Если количество единиц в записи нечётно, то слева дописывается 10. Полученная запись считается двоичной записью числа R.

Например, для числа 10₁₀ = 1010₂ количество единиц равно 2, поэтому получается число 101010₂ = 42₁₀. Для числа 7₁₀ = 111₂ получается число 10111₂ = 23₁₀. Укажите минимальное нечётное число R, большее 250.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if s.count('1') % 2 == 0:
        s = s + f(s.count('1'))
    else:
        s = '10' + s
    r = int(s, 2)
    if r > 250 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:323

#5155

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Если количество цифр 2 в записи чётно, то справа дописываются первая и последняя цифры записи. 3. Если количество цифр 2 в записи нечётно, то слева дописывается цифра 2. Полученная запись является троичной записью числа R.

Например, для числа 8₁₀ = 22₃ количество двоек равно 2, поэтому получается число 2222₃ = 80₁₀. Для числа 5₁₀ = 12₃ количество двоек равно 1, поэтому получается число 212₃ = 23₁₀. Укажите максимальное число N, для которого число R является ближайшим к 350. Если таких чисел несколько, выберите большее N.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 500):
    s = f(n)
    if s.count('2') % 2 == 0:
        s = s + s[0] + s[-1]
    else:
        s = '2' + s
    r = int(s, 3)
    d.append([abs(r - 350), -n, n])
d.sort()
print(d[0][2])

Ответ:39

#5156

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Находится двоичная запись числа N. 2. Если сумма цифр записи нечётна, то справа дописывается 11. 3. Если сумма цифр записи чётна, то слева дописывается последняя цифра записи. Полученная запись является двоичной записью числа R.

Например, для числа 7₁₀ = 111₂ сумма цифр равна 3, поэтому получается число 11111₂ = 31₁₀. Для числа 10₁₀ = 1010₂ сумма цифр равна 2, поэтому получается число 01010₂ = 10₁₀. Укажите максимальное число N, для которого результат работы алгоритма меньше 260.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 10000):
    s = f(n)
    if sum([int(x) for x in s]) % 2 == 1:
        s = s + '11'
    else:
        s = s[-1] + s
    r = int(s, 2)
    if r < 260:
        d.append(n)
print(max(d))

Ответ:258

#5157

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Если в записи есть хотя бы один ноль, то справа дописывается троичная запись количества нулей. 3. Если нулей в записи нет, то слева дописывается 1. Полученная запись считается троичной записью числа R.

Например, для числа 9₁₀ = 100₃ количество нулей равно 2, поэтому получается число 1002₃ = 29₁₀. Для числа 8₁₀ = 22₃ нулей нет, поэтому получается число 122₃ = 17₁₀. Укажите минимальное число N, при котором число R становится не меньше 280.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 10000):
    s = f(n)
    if s.count('0') > 0:
        s = s + f(s.count('0'))
    else:
        s = '1' + s
    r = int(s, 3)
    if r >= 280:
        print(n)
        break

Ответ:54

#5158

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится двоичная запись числа N. 2. Если длина этой записи чётна, то справа дописывается её первая цифра. 3. Если длина этой записи нечётна, то слева дописывается 11, а справа дописывается 0. Полученная запись является двоичной записью числа R.

Например, для числа 6₁₀ = 110₂ длина записи равна 3, поэтому получается число 11100₂ = 28₁₀. Для числа 10₁₀ = 1010₂ длина записи равна 4, поэтому получается число 10101₂ = 21₁₀. Укажите максимальное число R, которое может быть получено при N, не превышающем 50.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 51):
    s = f(n)
    if len(s) % 2 == 0:
        s = s + s[0]
    else:
        s = '11' + s + '0'
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:254

#5159

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Если сумма цифр троичной записи кратна 5, то справа дописывается цифра 2. 3. Если сумма цифр троичной записи не кратна 5, то слева дописывается первая цифра записи. Полученная запись является троичной записью числа R.

Например, для числа 8₁₀ = 22₃ сумма цифр равна 4, поэтому получается число 222₃ = 26₁₀. Для числа 17₁₀ = 122₃ сумма цифр равна 5, поэтому получается число 1222₃ = 53₁₀. Укажите минимальное чётное число R, большее 320.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 20000):
    s = f(n)
    if sum([int(x) for x in s]) % 5 == 0:
        s = s + '2'
    else:
        s = s[0] + s
    r = int(s, 3)
    if r > 320 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:324

#5160

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Вычисляется сумма цифр этой записи. 3. Если сумма цифр кратна 4, то эта сумма переводится в троичную систему счисления и дописывается справа к записи числа. 4. Если сумма цифр не кратна 4, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись считается троичной записью числа R.

Например, для числа 8₁₀ = 22₃ сумма цифр равна 4, поэтому получается число 2211₃ = 76₁₀. Для числа 10₁₀ = 101₃ сумма цифр равна 2, поэтому после удаления первой и последней цифр получается число 0₃ = 0₁₀. Укажите минимальное число R, большее 220. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 4 == 0:
        s = s + f(c)
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 3)
    if r > 220:
        d.append(r)
print(min(d))

Ответ:221

#5161

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится двоичная запись числа N. 2. Подсчитывается количество единиц в этой записи. 3. Находится целая часть среднего арифметического цифр записи. 4. Если количество единиц чётно, то число, равное целой части среднего арифметического, увеличенной на 1, переводится в двоичную систему счисления и дописывается слева к записи. 5. Если количество единиц нечётно, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается двоичной записью числа R.

Например, для числа 10₁₀ = 1010₂ количество единиц равно 2, среднее арифметическое цифр равно 0,5, его целая часть равна 0, поэтому получается число 11010₂ = 26₁₀. Укажите минимальное число N, для которого результат работы алгоритма будет не меньше 200.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 50000):
    s = f(n)
    c1 = s.count('1')
    avg = sum([int(x) for x in s]) // len(s)
    if c1 % 2 == 0:
        s = f(avg + 1) + s
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 2)
    if r >= 200:
        print(n)
        break

Ответ:72

#5162

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Рассматриваются только цифры записи, числовое значение которых больше 1. 3. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что условие не выполнено. 4. Если найденное значение существует и кратно 3, то оно переводится в систему счисления с основанием 4 и дописывается справа к записи. 5. Иначе из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 4.

Например, для числа 14₁₀ = 32₄ рассматриваются цифры 3 и 2, их среднее арифметическое равно 2,5, целая часть равна 2, поэтому запись сокращается до 2₄. Укажите минимальное чётное число R, большее 300. В ответе запишите его в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and (sum(a) // len(a)) % 3 == 0:
        s = s + f(sum(a) // len(a))
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 4)
    if r > 300 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:302

#5163

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится сумма цифр записи, числовое значение которых больше 2. 3. Если эта сумма ненулевая и кратна 5, то количество цифр записи, значение которых больше 2, переводится в систему счисления с основанием 5 и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается её первая цифра. Полученная запись является записью числа R в системе счисления с основанием 5.

Например, для числа 19₁₀ = 34₅ сумма цифр, больших 2, равна 7, поэтому справа дописывается первая цифра и получается число 343₅. Укажите максимальное число N, для которого число R меньше 600.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    c = sum([int(x) for x in s if int(x) > 2])
    k = len([x for x in s if int(x) > 2])
    if c != 0 and c % 5 == 0:
        s = f(k) + s
    else:
        s = s + s[0]
    r = int(s, 5)
    if r < 600:
        d.append(n)
print(max(d))

Ответ:119

#5164

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение кратно 4, то сумма всех цифр записи переводится в систему счисления с основанием 6 и дописывается справа. 4. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Например, для числа 24₁₀ = 40₆ среднее арифметическое цифр равно 2, поэтому первая цифра удаляется и получается 0₆. Укажите минимальное число R, большее 500.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 4 == 0:
        s = s + f(sum([int(x) for x in s]))
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 6)
    if r > 500:
        d.append(r)
print(min(d))

Ответ:501

#5165

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R следующим образом. 1. Строится запись числа N в системе счисления с основанием 4. 2. Подсчитывается количество цифр записи, числовое значение которых больше 2. 3. Находится целая часть среднего арифметического цифр записи, больших 2. Если таких цифр нет, считается, что условие не выполнено. 4. Если количество цифр, больших 2, нечётно, то найденное среднее арифметическое переводится в систему счисления с основанием 4 и дописывается слева к записи. 5. Иначе из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 4.

Укажите максимальное число R, меньшее 350, которое может быть получено с помощью этого алгоритма. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 2]
    if len(a) > 0 and len(a) % 2 == 1:
        s = f(sum(a) // len(a)) + s
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 4)
    if r < 350:
        d.append(r)
print(max(d))

Ответ:349

#5166

Условие

На вход алгоритма подаётся натуральное число N. По нему строится новое число R. 1. Строится троичная запись числа N. 2. Находится сумма всех цифр записи. 3. Если эта сумма кратна 5, то целая часть среднего арифметического всех цифр записи переводится в троичную систему счисления и дописывается слева к записи. 4. Если сумма не кратна 5, то справа к записи дважды дописывается её последняя цифра. Полученная запись является троичной записью числа R.

Укажите минимальное число N, после обработки которого получается число R, не меньшее 260.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 50000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 5 == 0:
        s = f(c // len(s)) + s
    else:
        s = s + s[-1] + s[-1]
    r = int(s, 3)
    if r >= 260:
        print(n)
        break

Ответ:29

#5167

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Рассматриваются только цифры записи, числовое значение которых больше 3. 3. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что условие не выполнено. 4. Если найденное значение существует и является чётным, то количество цифр записи, значение которых больше 3, переводится в систему счисления с основанием 5 и дописывается справа. 5. Иначе из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное число R, большее 450 и кратное 3.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 3]
    if len(a) > 0 and (sum(a) // len(a)) % 2 == 0:
        s = s + f(len(a))
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 5)
    if r > 450 and r % 3 == 0:
        d.append(r)
print(min(d))

Ответ:453

#5168

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится двоичная запись числа N. 2. Вычисляется сумма цифр этой записи. Если сумма цифр больше 3 и кратна 3, то эта сумма переводится в двоичную систему счисления и дописывается слева к записи. 3. Если условие не выполнено, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись является двоичной записью числа R.

Укажите максимальное число N, для которого результат работы алгоритма меньше 180.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c > 3 and c % 3 == 0:
        s = f(c) + s
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 2)
    if r < 180:
        d.append(n)
print(max(d))

Ответ:719

#5169

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Подсчитывается количество цифр записи, числовое значение которых больше 3. 3. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что условие не выполнено. 4. Если количество цифр, больших 3, положительно и чётно, то найденное среднее арифметическое переводится в систему счисления с основанием 6 и дописывается справа к записи. 5. Иначе слева к записи дописывается её первая цифра. Полученная запись является записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 700. В ответе запишите его в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 3]
    if len(a) > 0 and len(a) % 2 == 0:
        s = s + f(sum(a) // len(a))
    else:
        s = s[0] + s
    r = int(s, 6)
    if r > 700:
        d.append(r)
print(min(d))

Ответ:756

#5170

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение кратно 3, то число, равное сумме количества цифр 0 и количества цифр 3 в записи, переводится в систему счисления с основанием 4 и дописывается справа. 4. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 240 и кратное 5.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 3 == 0:
        s = s + f(s.count('0') + s.count('3'))
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 4)
    if r > 240 and r % 5 == 0:
        d.append(r)
print(min(d))

Ответ:245

#5171

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится сумма цифр записи, числовое значение которых больше 2. 3. Если эта сумма положительна и кратна 4, то она переводится в систему счисления с основанием 5 и дописывается слева к записи. 4. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 5.

Укажите минимальное число N, для которого результат работы алгоритма будет не меньше 520.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 50000):
    s = f(n)
    c = sum([int(x) for x in s if int(x) > 2])
    if c > 0 and c % 4 == 0:
        s = f(c) + s
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 5)
    if r >= 520:
        print(n)
        break

Ответ:29

#5172

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Подсчитывается количество цифр записи, числовое значение которых больше 1. 3. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что условие не выполнено. 4. Если количество цифр, больших 1, положительно и кратно 3, то найденное среднее арифметическое переводится в троичную систему счисления и дописывается справа к записи. 5. Если условие не выполнено, то справа к записи дописывается цифра 2. Полученная запись является троичной записью числа R.

Укажите максимальное число R, меньшее 200, которое может быть получено с помощью этого алгоритма.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and len(a) % 3 == 0:
        s = s + f(sum(a) // len(a))
    else:
        s = s + '2'
    r = int(s, 3)
    if r < 200:
        d.append(r)
print(max(d))

Ответ:197

#5173

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Вычисляется сумма всех цифр записи. 3. Если сумма цифр кратна 7, то последняя цифра записи, а затем троичная запись суммы цифр в системе счисления с основанием 6, дописываются слева к записи именно в таком порядке. 4. Если сумма цифр не кратна 7, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 1000.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 7 == 0:
        s = s[-1] + f(c) + s
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 6)
    if r > 1000:
        d.append(r)
print(min(d))

Ответ:1001

#5174

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Рассматриваются только цифры записи, числовое значение которых больше 2. 3. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что условие не выполнено. 4. Если найденное среднее арифметическое существует и кратно 5, то целая часть среднего арифметического всех цифр записи переводится в систему счисления с основанием 4 и дописывается справа. 5. Если условие не выполнено, то количество цифр 1 переводится в систему счисления с основанием 4 и дописывается слева к записи. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите максимальное число N, для которого число R меньше 500.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 2]
    if len(a) > 0 and (sum(a) // len(a)) % 5 == 0:
        s = s + f(sum([int(x) for x in s]) // len(s))
    else:
        s = f(s.count('1')) + s
    r = int(s, 4)
    if r < 500:
        d.append(n)
print(max(d))

Ответ:255

#5175

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Вычисляется сумма всех цифр записи. 3. Если эта сумма кратна 6, то число, равное количеству чётных цифр записи, переводится в систему счисления с основанием 5 и дописывается справа. 4. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное нечётное число R, большее 800.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    cnt = len([x for x in s if int(x) % 2 == 0])
    if sum([int(x) for x in s]) % 6 == 0:
        s = s + f(cnt)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 5)
    if r > 800 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:801

#5176

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение нечётно, то сумма всех цифр записи переводится в троичную систему счисления и дописывается слева. 4. Если условие не выполнено, то из записи удаляются две первые цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается троичной записью числа R.

Укажите минимальное число N, после обработки которого получается число R, не меньшее 190.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 50000):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 2 == 1:
        s = f(sum([int(x) for x in s])) + s
    else:
        if len(s) > 2:
            s = s[2:]
    r = int(s, 3)
    if r >= 190:
        print(n)
        break

Ответ:32

#5177

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Подсчитывается количество цифр записи, числовое значение которых больше 4. 3. Если это количество положительно и чётно, то количество цифр записи, числовое значение которых больше 2, переводится в систему счисления с основанием 6 и дописывается справа. 4. Если условие не выполнено, то справа к записи дописываются её первая и последняя цифры. Полученная запись является записью числа R в системе счисления с основанием 6.

Укажите максимальное число R, меньшее 900, которое может быть получено с помощью этого алгоритма.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    c1 = len([x for x in s if int(x) > 4])
    c2 = len([x for x in s if int(x) > 2])
    if c1 > 0 and c1 % 2 == 0:
        s = s + f(c2)
    else:
        s = s + s[0] + s[-1]
    r = int(s, 6)
    if r < 900:
        d.append(r)
print(max(d))

Ответ:888

#5178

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Рассматриваются только цифры записи, числовое значение которых больше 1. 3. Находится сумма этих цифр и целая часть их среднего арифметического. Если таких цифр нет, считается, что условие не выполнено. 4. Если сумма цифр, больших 1, положительна и кратна 5, то найденное среднее арифметическое переводится в систему счисления с основанием 4 и дописывается слева к записи. 5. Если условие не выполнено, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 260.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and sum(a) % 5 == 0:
        s = f(sum(a) // len(a)) + s
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 4)
    if r > 260:
        d.append(r)
print(min(d))

Ответ:261

#5179

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Рассматриваются только цифры записи, числовое значение которых больше 3. 3. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что условие не выполнено. 4. Если найденное среднее арифметическое существует и кратно 3, то число, равное количеству цифр 3 и 4 в записи, переводится в систему счисления с основанием 5 и дописывается слева. 5. Если условие не выполнено, то справа к записи дописывается целая часть среднего арифметического всех цифр записи, переведённая в систему счисления с основанием 5. Полученная запись является записью числа R в системе счисления с основанием 5.

Укажите максимальное число N, для которого число R меньше 1000.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 50000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 3]
    cnt = len([x for x in s if x == '3' or x == '4'])
    if len(a) > 0 and (sum(a) // len(a)) % 3 == 0:
        s = f(cnt) + s
    else:
        s = s + f(sum([int(x) for x in s]) // len(s))
    r = int(s, 5)
    if r < 1000:
        d.append(n)
print(max(d))

Ответ:900

#5180

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится троичная запись числа N. 2. Рассматриваются только цифры записи, числовое значение которых больше 1. 3. Если такие цифры есть и их сумма кратна 4, то эта сумма переводится в троичную систему счисления и дописывается справа к записи. 4. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение чётно, то слева к записи дописывается число, равное количеству цифр 1 в записи, увеличенному на 1 и переведённому в троичную систему счисления. 7. Если найденное значение нечётно, то справа к записи дописывается число, равное количеству цифр 2 в записи, увеличенному на 1 и переведённому в троичную систему счисления. Полученная запись считается троичной записью числа R.

Укажите минимальное число R, большее 250. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and sum(a) % 4 == 0:
        s = s + f(sum(a))
    else:
        if len(s) > 2:
            s = s[1:-1]
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 2 == 0:
        s = f(s.count('1') + 1) + s
    else:
        s = s + f(s.count('2') + 1)
    r = int(s, 3)
    if r > 250:
        d.append(r)
print(min(d))

Ответ:251

#5181

Условие

На вход алгоритма подаётся натуральное число N. По нему строится новое число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение кратно 3, то слева к записи дописывается число, равное количеству цифр записи со значением больше 2, увеличенному на 1 и переведённому в систему счисления с основанием 4. 4. Если условие не выполнено, то справа к записи дописывается её последняя цифра. 5. Для полученной записи находится сумма цифр со значением больше 1. 6. Если эта сумма положительна и кратна 5, то справа к записи дописывается эта сумма, переведённая в систему счисления с основанием 4. 7. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите максимальное число N, для которого результат работы алгоритма меньше 700. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 3 == 0:
        s = f(len([x for x in s if int(x) > 2]) + 1) + s
    else:
        s = s + s[-1]
    c = sum([int(x) for x in s if int(x) > 1])
    if c > 0 and c % 5 == 0:
        s = s + f(c)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 4)
    if r < 700:
        d.append(n)
print(max(d))

Ответ:4270

#5182

Условие

На вход алгоритма подаётся натуральное число N. По нему строится новое число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится сумма цифр записи, числовое значение которых больше 2. 3. Если эта сумма положительна и кратна 3, то число, равное трети этой суммы, переводится в систему счисления с основанием 5 и дописывается справа к записи. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение нечётно, то оно переводится в систему счисления с основанием 5 и дописывается слева к записи. 7. Если найденное значение чётно, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 5.

Укажите минимальное число N, для которого после выполнения алгоритма получается число R, не меньшее 600. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 5000):
    s = f(n)
    c = sum([int(x) for x in s if int(x) > 2])
    if c > 0 and c % 3 == 0:
        s = s + f(c // 3)
    else:
        s = '1' + s
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 2 == 1:
        s = f(avg) + s
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 5)
    if r >= 600:
        print(n)
        break

Ответ:27

#5183

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему число R. 1. Строится двоичная запись числа N. 2. Если количество единиц в записи кратно 3, то это количество переводится в двоичную систему счисления и дописывается справа. 3. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. 4. Для полученной записи подсчитывается количество нулей. 5. Если количество нулей чётно, то слева дописывается цифра 1. 6. Если количество нулей нечётно, то справа дописывается цифра 0. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 80. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 81):
    s = f(n)
    if s.count('1') % 3 == 0:
        s = s + f(s.count('1'))
    else:
        if len(s) > 2:
            s = s[1:-1]
    z = s.count('0')
    if z % 2 == 0:
        s = '1' + s
    else:
        s = s + '0'
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:1020

#5184

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Рассматриваются только цифры записи, числовое значение которых больше 3. 3. Если такие цифры есть и целая часть их среднего арифметического чётна, то сумма этих цифр переводится в систему счисления с основанием 6 и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается её первая цифра. 5. Для полученной записи находится сумма всех цифр. 6. Если эта сумма кратна 4, то справа дописывается число, равное четверти этой суммы и переведённое в систему счисления с основанием 6. 7. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите минимальное чётное число R, большее 900. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 3]
    if len(a) > 0 and (sum(a) // len(a)) % 2 == 0:
        s = f(sum(a)) + s
    else:
        s = s + s[0]
    c = sum([int(x) for x in s])
    if c % 4 == 0:
        s = s + f(c // 4)
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 6)
    if r > 900 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:902

#5185

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение чётно, то справа к записи дописывается число, равное количеству цифр 2, увеличенному на 1 и переведённому в троичную систему счисления. 4. Если условие не выполнено, то слева к записи дописывается цифра 2. 5. Для полученной записи находится сумма всех цифр, отличных от 0. 6. Если эта сумма кратна 4, то слева к записи дописывается число, равное половине этой суммы и переведённое в троичную систему счисления. 7. Если условие не выполнено, то из записи удаляются две первые цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается троичной записью числа R.

Укажите максимальное число N, для которого число R меньше 500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 2 == 0:
        s = s + f(s.count('2') + 1)
    else:
        s = '2' + s
    c = sum([int(x) for x in s if int(x) > 0])
    if c % 4 == 0:
        s = f(c // 2) + s
    else:
        if len(s) > 2:
            s = s[2:]
    r = int(s, 3)
    if r < 500:
        d.append(n)
print(max(d))

Ответ:4868

#5186

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Рассматриваются только цифры записи, числовое значение которых больше 1. 3. Если количество таких цифр нечётно, то справа к записи дописывается число, равное сумме этих цифр, увеличенной на 1 и переведённое в систему счисления с основанием 4. 4. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. 5. Для полученной записи находится целая часть среднего арифметического всех цифр. 6. Если найденное значение кратно 4, то оно, увеличенное на 1, переводится в систему счисления с основанием 4 и дописывается слева. 7. Если условие не выполнено, то справа дописывается число, равное количеству цифр 3, увеличенному на 1 и переведённое в систему счисления с основанием 4. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 700. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) % 2 == 1:
        s = s + f(sum(a) + 1)
    else:
        if len(s) > 1:
            s = s[:-1]
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 4 == 0:
        s = f(avg + 1) + s
    else:
        s = s + f(s.count('3') + 1)
    r = int(s, 4)
    if r > 700:
        d.append(r)
print(min(d))

Ответ:703

#5187

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится сумма всех цифр записи. 3. Если эта сумма положительна и кратна 4, то слева к записи дописывается цифра 2. 4. Если условие не выполнено, то справа к записи дописывается эта сумма, переведённая в систему счисления с основанием 5. 5. Для полученной записи рассматриваются только цифры со значением больше 3. 6. Если такие цифры есть и их сумма чётна, то справа к записи дописывается количество этих цифр, переведённое в систему счисления с основанием 5. 7. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 5.

Укажите минимальное число N, для которого после выполнения алгоритма получается число R, не меньшее 1000. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 5000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c > 0 and c % 4 == 0:
        s = '2' + s
    else:
        s = s + f(c)
    a = [int(x) for x in s if int(x) > 3]
    if len(a) > 0 and sum(a) % 2 == 0:
        s = s + f(len(a))
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 5)
    if r >= 1000:
        print(n)
        break

Ответ:9

#5188

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Строится двоичная запись числа N. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение равно 0, то справа к записи дописывается цифра 1. 4. Если найденное значение отлично от 0, то слева к записи дописывается цифра 1, а справа дописывается найденное значение, переведённое в двоичную систему счисления. 5. Для полученной записи подсчитывается количество единиц. 6. Если это количество кратно 4, то слева к записи дописывается это количество, переведённое в двоичную систему счисления. 7. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись является двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 90. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 91):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg == 0:
        s = s + '1'
    else:
        s = '1' + s + f(avg)
    c = s.count('1')
    if c % 4 == 0:
        s = f(c) + s
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:2303

#5189

Условие

На вход алгоритма подаётся натуральное число N. По нему строится новое число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Рассматриваются только цифры записи, числовое значение которых больше 2. 3. Если такие цифры есть и их сумма кратна 5, то число, равное пятой части этой суммы, переводится в систему счисления с основанием 6 и дописывается справа к записи. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение кратно 3, то справа к записи дописывается число, равное количеству цифр 0, увеличенному на 1 и переведённому в систему счисления с основанием 6. 7. Если условие не выполнено, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 650 и кратное 3. В ответе запишите его в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 2]
    if len(a) > 0 and sum(a) % 5 == 0:
        s = s + f(sum(a) // 5)
    else:
        s = '1' + s
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 3 == 0:
        s = s + f(s.count('0') + 1)
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 6)
    if r > 650 and r % 3 == 0:
        d.append(r)
print(min(d))

Ответ:651

#5190

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Подсчитывается количество цифр 2 в записи. 3. Если это количество положительно и чётно, то оно переводится в троичную систему счисления и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается цифра 1. 5. Для полученной записи рассматриваются все цифры, отличные от 0. 6. Находится целая часть среднего арифметического этих цифр. 7. Если найденное значение нечётно, то оно переводится в троичную систему счисления и дописывается справа к записи. 8. Если найденное значение чётно, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается троичной записью числа R.

Укажите максимальное число N, для которого число R меньше 400. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = s.count('2')
    if c > 0 and c % 2 == 0:
        s = f(c) + s
    else:
        s = s + '1'
    a = [int(x) for x in s if int(x) > 0]
    avg = sum(a) // len(a)
    if avg % 2 == 1:
        s = s + f(avg)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 3)
    if r < 400:
        d.append(n)
print(max(d))

Ответ:216

#5191

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Находится сумма цифр записи, числовое значение которых больше 2. 3. Если эта сумма положительна и чётна, то число, равное половине этой суммы, переводится в систему счисления с основанием 4 и дописывается справа к записи. 4. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. 5. Для полученной записи подсчитывается количество цифр 0. 6. Если это количество кратно 3, то слева к записи дописывается число, равное количеству нулей, увеличенному на 1 и переведённое в систему счисления с основанием 4. 7. Если условие не выполнено, то справа к записи дописывается длина записи, переведённая в систему счисления с основанием 4. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 500 и кратное 5. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum([int(x) for x in s if int(x) > 2])
    if c > 0 and c % 2 == 0:
        s = s + f(c // 2)
    else:
        if len(s) > 2:
            s = s[1:-1]
    z = s.count('0')
    if z % 3 == 0:
        s = f(z + 1) + s
    else:
        s = s + f(len(s))
    r = int(s, 4)
    if r > 500 and r % 5 == 0:
        d.append(r)
print(min(d))

Ответ:505

#5192

Условие

На вход алгоритма подаётся натуральное число N. Строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение чётно, то число, равное этому значению, увеличенному на 1, переводится в систему счисления с основанием 5 и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается число, равное количеству цифр 4, увеличенному на 1 и переведённое в систему счисления с основанием 5. 5. Для полученной записи находится сумма цифр со значением больше 1. 6. Если эта сумма положительна и кратна 3, то число, равное трети этой суммы, переводится в систему счисления с основанием 5 и дописывается справа. 7. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 5.

Укажите минимальное число N, после обработки которого получается число R, не меньшее 800. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 5000):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 2 == 0:
        s = f(avg + 1) + s
    else:
        s = s + f(s.count('4') + 1)
    c = sum([int(x) for x in s if int(x) > 1])
    if c > 0 and c % 3 == 0:
        s = s + f(c // 3)
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 5)
    if r >= 800:
        print(n)
        break

Ответ:33

#5193

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится двоичная запись числа N. 2. Подсчитывается количество нулей в записи. 3. Если это количество положительно и нечётно, то оно переводится в двоичную систему счисления и дописывается справа к записи. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение равно 1, то слева к записи дописывается количество единиц, переведённое в двоичную систему счисления. 7. Если условие не выполнено, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 120. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 121):
    s = f(n)
    z = s.count('0')
    if z > 0 and z % 2 == 1:
        s = s + f(z)
    else:
        s = '1' + s
    avg = sum([int(x) for x in s]) // len(s)
    if avg == 1:
        s = f(s.count('1')) + s
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:1023

#5194

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит новое число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Находится сумма цифр записи, числовое значение которых больше 3. 3. Если эта сумма положительна и кратна 4, то она переводится в систему счисления с основанием 6 и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается её последняя цифра. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение положительно и кратно 5, то оно переводится в систему счисления с основанием 6 и дописывается справа. 7. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 700. В ответе запишите его в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum([int(x) for x in s if int(x) > 3])
    if c > 0 and c % 4 == 0:
        s = f(c) + s
    else:
        s = s + s[-1]
    avg = sum([int(x) for x in s]) // len(s)
    if avg > 0 and avg % 5 == 0:
        s = s + f(avg)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 6)
    if r > 700:
        d.append(r)
print(min(d))

Ответ:705

#5195

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится троичная запись числа N. 2. Рассматриваются только цифры записи, числовое значение которых больше 1. 3. Если такие цифры есть и целая часть их среднего арифметического чётна, то сумма этих цифр переводится в троичную систему счисления и дописывается справа. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи находится сумма всех цифр. 6. Если эта сумма кратна 5, то слева к записи дописывается число, равное частному от деления этой суммы на 5, увеличенному на 1 и переведённое в троичную систему счисления. 7. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись является троичной записью числа R.

Укажите максимальное число N, для которого число R меньше 600. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and (sum(a) // len(a)) % 2 == 0:
        s = s + f(sum(a))
    else:
        s = '1' + s
    c = sum([int(x) for x in s])
    if c % 5 == 0:
        s = f(c // 5 + 1) + s
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 3)
    if r < 600:
        d.append(n)
print(max(d))

Ответ:4737

#5196

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Подсчитывается количество цифр 3 в записи. 3. Если это количество положительно и чётно, то число, равное этому количеству, увеличенному на 1, переводится в систему счисления с основанием 4 и дописывается справа. 4. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 5. Для полученной записи рассматриваются только цифры, отличные от 0. 6. Находится целая часть среднего арифметического этих цифр. 7. Если найденное значение положительно и кратно 3, то оно переводится в систему счисления с основанием 4 и дописывается слева. 8. Если условие не выполнено, то справа к записи дописывается число, равное количеству цифр 1, увеличенному на 1 и переведённое в систему счисления с основанием 4. Полученная запись является записью числа R в системе счисления с основанием 4.

Укажите минимальное чётное число R, большее 300. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = s.count('3')
    if c > 0 and c % 2 == 0:
        s = s + f(c + 1)
    else:
        if len(s) > 1:
            s = s[1:]
    a = [int(x) for x in s if int(x) > 0]
    avg = sum(a) // len(a)
    if avg > 0 and avg % 3 == 0:
        s = f(avg) + s
    else:
        s = s + f(s.count('1') + 1)
    r = int(s, 4)
    if r > 300 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:302

#5197

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится сумма всех цифр записи. 3. Если эта сумма кратна 7, то число, равное седьмой части суммы, переводится в систему счисления с основанием 5 и дописывается справа. 4. Если условие не выполнено, то из записи удаляются две первые цифры. Если длина записи меньше трёх символов, она не изменяется. 5. Для полученной записи рассматриваются только цифры со значением больше 2. 6. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что найденное значение равно 0. 7. Если найденное значение чётно, то слева к записи дописывается цифра 2. 8. Если найденное значение нечётно, то справа к записи дописывается это значение, переведённое в систему счисления с основанием 5. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное число N, для которого результат работы алгоритма будет не меньше 500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 5000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 7 == 0:
        s = s + f(c // 7)
    else:
        if len(s) > 2:
            s = s[2:]
    a = [int(x) for x in s if int(x) > 2]
    avg = sum(a) // len(a) if len(a) > 0 else 0
    if avg % 2 == 0:
        s = '2' + s
    else:
        s = s + f(avg)
    r = int(s, 5)
    if r >= 500:
        print(n)
        break

Ответ:23

#5198

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит число R. 1. Строится двоичная запись числа N. 2. Находится сумма всех единиц записи. 3. Если эта сумма кратна 4, то слева к записи дописывается длина записи, переведённая в двоичную систему счисления. 4. Если условие не выполнено, то справа к записи дописывается цифра 1. 5. Для полученной записи подсчитывается количество нулей. 6. Если это количество чётно, то справа к записи дописывается число, равное количеству нулей, увеличенному на 1 и переведённое в двоичную систему счисления. 7. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 100. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 101):
    s = f(n)
    c = sum([int(x) for x in s if int(x) > 0])
    if c % 4 == 0:
        s = f(len(s)) + s
    else:
        s = s + '1'
    z = s.count('0')
    if z % 2 == 0:
        s = s + f(z + 1)
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:1613

#5199

Условие

На вход алгоритма подаётся натуральное число N. По нему строится новое число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение нечётно, то оно переводится в систему счисления с основанием 6 и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается число, равное количеству цифр 5, увеличенному на 1 и переведённое в систему счисления с основанием 6. 5. Для полученной записи находится сумма цифр, числовое значение которых больше 3. 6. Если эта сумма положительна и кратна 3, то число, равное трети этой суммы, переводится в систему счисления с основанием 6 и дописывается справа. 7. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если в записи меньше трёх цифр, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 1000 и кратное 4. В ответе запишите его в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 2 == 1:
        s = f(avg) + s
    else:
        s = s + f(s.count('5') + 1)
    c = sum([int(x) for x in s if int(x) > 3])
    if c > 0 and c % 3 == 0:
        s = s + f(c // 3)
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 6)
    if r > 1000 and r % 4 == 0:
        d.append(r)
print(min(d))

Ответ:1008

#5200

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Рассматриваются только цифры записи, числовое значение которых больше 1. 3. Если такие цифры есть и их сумма кратна 3, то число, равное трети этой суммы, переводится в троичную систему счисления и дописывается справа к записи. 4. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной или двух цифр, она не изменяется. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение чётно, то слева к записи дописывается число, равное количеству цифр 1 в записи, увеличенному на 1 и переведённое в троичную систему счисления. 7. Если найденное значение нечётно, то справа к записи дописывается число, равное количеству цифр 2 в записи, увеличенному на 1 и переведённое в троичную систему счисления. Полученная запись считается троичной записью числа R.

Укажите минимальное чётное число R, большее 400. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and sum(a) % 3 == 0:
        s = s + f(sum(a) // 3)
    else:
        if len(s) > 2:
            s = s[1:]
    avg = sum([int(x) for x in s]) // len(s)
    if avg % 2 == 0:
        s = f(s.count('1') + 1) + s
    else:
        s = s + f(s.count('2') + 1)
    r = int(s, 3)
    if r > 400 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:426

#5201

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Находится сумма всех цифр записи. 3. Если эта сумма чётна, то число, равное половине суммы, переводится в систему счисления с основанием 4 и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается её последняя цифра. 5. Для полученной записи рассматриваются только цифры, числовое значение которых больше 1. 6. Находится целая часть среднего арифметического этих цифр. Если таких цифр нет, считается, что условие не выполнено. 7. Если найденное значение существует и нечётно, то оно переводится в систему счисления с основанием 4 и дописывается справа к записи. 8. Если условие не выполнено, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись является записью числа R в системе счисления с основанием 4.

Укажите максимальное число N, для которого результат работы алгоритма меньше 900. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum([int(x) for x in s])
    if c % 2 == 0:
        s = f(c // 2) + s
    else:
        s = s + s[-1]
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and (sum(a) // len(a)) % 2 == 1:
        s = s + f(sum(a) // len(a))
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 4)
    if r < 900:
        d.append(n)
print(max(d))

Ответ:3599

#5202

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Рассматриваются только цифры записи, числовое значение которых больше 2. 3. Если таких цифр положительное чётное количество, то число, равное этому количеству, увеличенному на 1, переводится в систему счисления с основанием 5 и дописывается справа к записи. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение положительно и кратно 3, то оно переводится в систему счисления с основанием 5 и дописывается слева к записи. 7. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное нечётное число R, большее 600. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 2]
    if len(a) > 0 and len(a) % 2 == 0:
        s = s + f(len(a) + 1)
    else:
        s = '1' + s
    avg = sum([int(x) for x in s]) // len(s)
    if avg > 0 and avg % 3 == 0:
        s = f(avg) + s
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 5)
    if r > 600 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:601

#5203

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Подсчитывается количество цифр 5 в записи. 3. Если это количество положительно и нечётно, то оно переводится в систему счисления с основанием 6 и дописывается справа к записи. 4. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 5. Для полученной записи находится сумма цифр, числовое значение которых больше 2. 6. Если эта сумма положительна и кратна 4, то число, равное четверти этой суммы, увеличенному на 1, переводится в систему счисления с основанием 6 и дописывается слева к записи. 7. Если условие не выполнено, то справа к записи дописывается её первая цифра. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите максимальное число R, которое может быть получено при N, не превышающем 70. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 71):
    s = f(n)
    if s.count('5') > 0 and s.count('5') % 2 == 1:
        s = s + f(s.count('5'))
    else:
        if len(s) > 1:
            s = s[1:]
    c = sum([int(x) for x in s if int(x) > 2])
    if c > 0 and c % 4 == 0:
        s = f(c // 4 + 1) + s
    else:
        s = s + s[0]
    r = int(s, 6)
    d.append(r)
print(max(d))

Ответ:4303

#5204

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Рассматриваются только цифры записи, числовое значение которых больше 1. 3. Если такие цифры есть и их сумма кратна 4, то эта сумма переводится в систему счисления с основанием 4 и дописывается справа к записи. 4. Если условие не выполнено, то слева к записи дописывается цифра 2. 5. Для полученной записи подсчитывается количество цифр 0. 6. Если это количество чётно, то справа к записи дописывается число, равное количеству нулей, увеличенному на 1 и переведённое в систему счисления с основанием 4. 7. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 500 и кратное 7. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and sum(a) % 4 == 0:
        s = s + f(sum(a))
    else:
        s = '2' + s
    z = s.count('0')
    if z % 2 == 0:
        s = s + f(z + 1)
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 4)
    if r > 500 and r % 7 == 0:
        d.append(r)
print(min(d))

Ответ:504

#5205

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится сумма цифр записи, числовое значение которых больше 2. 3. Если эта сумма положительна и кратна 4, то число, равное половине этой суммы, переводится в систему счисления с основанием 5 и дописывается слева к записи. 4. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение чётно, то справа к записи дописывается число, равное количеству цифр 4, увеличенному на 1 и переведённое в систему счисления с основанием 5. 7. Если условие не выполнено, то слева к записи дописывается цифра 2. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное число N, для которого после выполнения алгоритма получается число R, не меньшее 700. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s if int(x) > 2)
    if c > 0 and c % 4 == 0:
        s = f(c // 2) + s
    else:
        if len(s) > 1:
            s = s[:-1]
    avg = sum(map(int, s)) // len(s)
    if avg % 2 == 0:
        s = s + f(s.count('4') + 1)
    else:
        s = '2' + s
    r = int(s, 5)
    if r >= 700:
        print(n)
        break

Ответ:29

#5206

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Рассматриваются только цифры записи, числовое значение которых больше 3. 3. Если такие цифры есть и их сумма кратна 3, то справа к записи дописывается число, равное количеству этих цифр, увеличенному на 1 и переведённое в систему счисления с основанием 6. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи находится сумма всех её цифр. 6. Если эта сумма нечётна, то из записи удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. 7. Если условие не выполнено, то слева к записи дописывается число, равное половине этой суммы и переведённое в систему счисления с основанием 6. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите максимальное число R, которое может быть получено при N, не превышающем 90. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 91):
    s = f(n)
    a = [int(x) for x in s if int(x) > 3]
    if len(a) > 0 and sum(a) % 3 == 0:
        s = s + f(len(a) + 1)
    else:
        s = '1' + s
    c = sum(map(int, s))
    if c % 2 == 1:
        if len(s) > 2:
            s = s[1:-1]
    else:
        s = f(c // 2) + s
    r = int(s, 6)
    d.append(r)
print(max(d))

Ответ:8063

#5207

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение положительно и нечётно, то справа к записи дописывается число, равное этому значению, увеличенному на 1 и переведённое в систему счисления с основанием 4. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи рассматриваются только цифры, числовое значение которых больше 1. 6. Если таких цифр есть чётное количество, то слева к записи дописывается число, равное целой части среднего арифметического этих цифр и переведённое в систему счисления с основанием 4. 7. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 650 и кратное 3. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    avg = sum(map(int, s)) // len(s)
    if avg > 0 and avg % 2 == 1:
        s = s + f(avg + 1)
    else:
        s = '1' + s
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and len(a) % 2 == 0:
        s = f(sum(a) // len(a)) + s
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 4)
    if r > 650 and r % 3 == 0:
        d.append(r)
print(min(d))

Ответ:654

#5208

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Подсчитывается количество цифр 2 в записи. 3. Если это количество положительно и чётно, то слева к записи дописывается число, равное этому количеству, увеличенному на 1 и переведённое в троичную систему счисления. 4. Если условие не выполнено, то справа к записи дописывается цифра 1. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение чётно, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. 7. Если условие не выполнено, то справа к записи дописывается число, равное количеству цифр 1, увеличенному на 1 и переведённое в троичную систему счисления. Полученная запись считается троичной записью числа R.

Укажите максимальное число N, для которого число R меньше 800. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = s.count('2')
    if c > 0 and c % 2 == 0:
        s = f(c + 1) + s
    else:
        s = s + '1'
    avg = sum(map(int, s)) // len(s)
    if avg % 2 == 0:
        if len(s) > 2:
            s = s[:-2]
    else:
        s = s + f(s.count('1') + 1)
    r = int(s, 3)
    if r < 800:
        d.append(n)
print(max(d))

Ответ:2389

#5209

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится двоичная запись числа N. 2. Подсчитывается количество нулей в записи. 3. Если это количество положительно и кратно 3, то справа к записи дописывается это количество, переведённое в двоичную систему счисления. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи подсчитывается количество единиц. 6. Если это количество чётно, то слева к записи дописывается число, равное количеству единиц, увеличенному на 1 и переведённое в двоичную систему счисления. 7. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите минимальное чётное число R, большее 500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    z = s.count('0')
    if z > 0 and z % 3 == 0:
        s = s + f(z)
    else:
        s = '1' + s
    c = s.count('1')
    if c % 2 == 0:
        s = f(c + 1) + s
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 2)
    if r > 500 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:510

#5210

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение нечётно, то оно переводится в систему счисления с основанием 5 и дописывается слева к записи. 4. Если условие не выполнено, то справа к записи дописывается её последняя цифра. 5. Для полученной записи рассматриваются только цифры, числовое значение которых больше 1. 6. Если сумма этих цифр кратна 4, то справа к записи дописывается число, равное четверти этой суммы и переведённое в систему счисления с основанием 5. 7. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите максимальное число R, которое может быть получено при N, не превышающем 75. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 76):
    s = f(n)
    avg = sum(map(int, s)) // len(s)
    if avg % 2 == 1:
        s = f(avg) + s
    else:
        s = s + s[-1]
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and sum(a) % 4 == 0:
        s = s + f(sum(a) // 4)
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 5)
    d.append(r)
print(max(d))

Ответ:2243

#5211

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Находится сумма цифр записи, числовое значение которых больше 4. 3. Если эта сумма положительна и чётна, то число, равное половине этой суммы, переводится в систему счисления с основанием 6 и дописывается справа к записи. 4. Если условие не выполнено, то слева к записи дописывается цифра 2. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение положительно и кратно 3, то число, равное трети этого значения, увеличенному на 1, переводится в систему счисления с основанием 6 и дописывается слева к записи. 7. Если условие не выполнено, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите минимальное число N, для которого после выполнения алгоритма получается число R, не меньшее 1200. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s if int(x) > 4)
    if c > 0 and c % 2 == 0:
        s = s + f(c // 2)
    else:
        s = '2' + s
    avg = sum(map(int, s)) // len(s)
    if avg > 0 and avg % 3 == 0:
        s = f(avg // 3 + 1) + s
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 6)
    if r >= 1200:
        print(n)
        break

Ответ:65

#5212

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Рассматриваются только цифры записи, числовое значение которых больше 2. 3. Если такие цифры есть и их сумма кратна 3, то справа к записи дописывается число, равное количеству этих цифр и переведённое в систему счисления с основанием 4. 4. Если условие не выполнено, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 5. Для полученной записи подсчитывается количество цифр 0. 6. Если это количество нечётно, то слева к записи дописывается цифра 3. 7. Если условие не выполнено, то справа к записи дописывается число, равное количеству нулей, увеличенному на 1 и переведённое в систему счисления с основанием 4. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите максимальное число N, после обработки которого получается число R, ближайшее к 1000. Если таких чисел несколько, выберите большее N. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 2]
    if len(a) > 0 and sum(a) % 3 == 0:
        s = s + f(len(a))
    else:
        if len(s) > 1:
            s = s[1:]
    z = s.count('0')
    if z % 2 == 1:
        s = '3' + s
    else:
        s = s + f(z + 1)
    r = int(s, 4)
    d.append([abs(r - 1000), -n, n])
d.sort()
print(d[0][2])

Ответ:62

#5213

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Находится целая часть среднего арифметического всех цифр записи. 3. Если найденное значение чётно, то справа к записи дописывается число, равное этому значению, увеличенному на 1 и переведённое в троичную систему счисления. 4. Если условие не выполнено, то слева к записи дописывается цифра 2. 5. Для полученной записи находится сумма всех цифр, отличных от 0. 6. Если эта сумма кратна 4, то из записи удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. 7. Если условие не выполнено, то слева к записи дописывается число, равное количеству цифр 2, увеличенному на 1 и переведённое в троичную систему счисления. Полученная запись считается троичной записью числа R.

Укажите минимальное нечётное число R, большее 700. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    avg = sum(map(int, s)) // len(s)
    if avg % 2 == 0:
        s = s + f(avg + 1)
    else:
        s = '2' + s
    c = sum(int(x) for x in s if int(x) > 0)
    if c % 4 == 0:
        if len(s) > 2:
            s = s[1:-1]
    else:
        s = f(s.count('2') + 1) + s
    r = int(s, 3)
    if r > 700 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:707

#5214

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится двоичная запись числа N. 2. Если единиц в записи больше, чем нулей, то слева к записи дописывается 10. 3. Если условие не выполнено, то справа к записи дописывается число, равное количеству нулей, увеличенному на 1 и переведённое в двоичную систему счисления. 4. Для полученной записи находится целая часть среднего арифметического всех её цифр. 5. Если найденное значение равно 0, то справа к записи дописывается цифра 1. 6. Если найденное значение отлично от 0, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 110. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 111):
    s = f(n)
    if s.count('1') > s.count('0'):
        s = '10' + s
    else:
        s = s + f(s.count('0') + 1)
    avg = sum(map(int, s)) // len(s)
    if avg == 0:
        s = s + '1'
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 2)
    d.append(r)
print(max(d))

Ответ:1675

#5215

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 5. 2. Подсчитывается количество цифр 4 в записи. 3. Если это количество положительно и нечётно, то справа к записи дописывается число, равное количеству цифр 4, увеличенному на 1 и переведённое в систему счисления с основанием 5. 4. Если условие не выполнено, то слева к записи дописывается цифра 1. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение чётно, то слева к записи дописывается число, равное этому значению, увеличенному на 1 и переведённое в систему счисления с основанием 5. 7. Если условие не выполнено, то из записи удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное число R, большее 900 и кратное 4. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s.count('4') > 0 and s.count('4') % 2 == 1:
        s = s + f(s.count('4') + 1)
    else:
        s = '1' + s
    avg = sum(map(int, s)) // len(s)
    if avg % 2 == 0:
        s = f(avg + 1) + s
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 5)
    if r > 900 and r % 4 == 0:
        d.append(r)
print(min(d))

Ответ:904

#5216

Условие

На вход алгоритма подаётся натуральное число N. Из него строится число R. 1. Строится запись числа N в системе счисления с основанием 6. 2. Рассматриваются только цифры записи, числовое значение которых больше 3. 3. Если такие цифры есть и целая часть их среднего арифметического чётна, то слева к записи дописывается сумма этих цифр, переведённая в систему счисления с основанием 6. 4. Если условие не выполнено, то справа к записи дописывается её первая цифра. 5. Для полученной записи подсчитывается количество цифр 0. 6. Если это количество кратно 3, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. 7. Если условие не выполнено, то справа к записи дописывается число, равное количеству нулей, увеличенному на 1 и переведённое в систему счисления с основанием 6. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите максимальное число N, для которого результат работы алгоритма меньше 1500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 3]
    if len(a) > 0 and (sum(a) // len(a)) % 2 == 0:
        s = f(sum(a)) + s
    else:
        s = s + s[0]
    z = s.count('0')
    if z % 3 == 0:
        if len(s) > 2:
            s = s[:-2]
    else:
        s = s + f(z + 1)
    r = int(s, 6)
    if r < 1500:
        d.append(n)
print(max(d))

Ответ:4968

#5217

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится запись числа N в системе счисления с основанием 4. 2. Находится сумма всех цифр записи. 3. Если эта сумма кратна 3, то справа к записи дописывается число, равное трети этой суммы, увеличенной на 1 и переведённое в систему счисления с основанием 4. 4. Если условие не выполнено, то слева к записи дописывается цифра 2. 5. Для полученной записи рассматриваются только цифры, числовое значение которых больше 1. 6. Если таких цифр нечётное количество, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 7. Если условие не выполнено, то слева к записи дописывается число, равное количеству цифр 3, увеличенному на 1 и переведённое в систему счисления с основанием 4. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное число N, для которого после выполнения алгоритма получается число R, не меньшее 1000. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
for n in range(1, 5000):
    s = f(n)
    c = sum(map(int, s))
    if c % 3 == 0:
        s = s + f(c // 3 + 1)
    else:
        s = '2' + s
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and len(a) % 2 == 1:
        if len(s) > 1:
            s = s[1:]
    else:
        s = f(s.count('3') + 1) + s
    r = int(s, 4)
    if r >= 1000:
        print(n)
        break

Ответ:66

#5218

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится троичная запись числа N. 2. Подсчитывается количество цифр 1 в записи. 3. Если это количество чётно, то справа к записи дописывается число, равное количеству цифр 1, увеличенному на 1 и переведённое в троичную систему счисления. 4. Если условие не выполнено, то из записи удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. 5. Для полученной записи находится целая часть среднего арифметического всех её цифр. 6. Если найденное значение нечётно, то слева к записи дописывается цифра 1. 7. Если условие не выполнено, то справа к записи дописывается цифра 2. Полученная запись считается троичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 85. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 86):
    s = f(n)
    if s.count('1') % 2 == 0:
        s = s + f(s.count('1') + 1)
    else:
        if len(s) > 2:
            s = s[1:-1]
    avg = sum(map(int, s)) // len(s)
    if avg % 2 == 1:
        s = '1' + s
    else:
        s = s + '2'
    r = int(s, 3)
    d.append(r)
print(max(d))

Ответ:2279

#5219

Условие

На вход алгоритма подаётся натуральное число N. По нему строится число R. 1. Строится двоичная запись числа N. 2. Если длина записи чётна, то слева к записи дописывается цифра 1. 3. Если длина записи нечётна, то справа к записи дописывается цифра 0. 4. Для полученной записи подсчитывается количество единиц. 5. Если это количество кратно 3, то справа к записи дописывается число, равное трети количества единиц, увеличенной на 1 и переведённое в двоичную систему счисления. 6. Если условие не выполнено, то из записи удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите минимальное число R, большее 1000. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n = n // ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if len(s) % 2 == 0:
        s = '1' + s
    else:
        s = s + '0'
    c = s.count('1')
    if c % 3 == 0:
        s = s + f(c // 3 + 1)
    else:
        if len(s) > 2:
            s = s[:-2]
    r = int(s, 2)
    if r > 1000:
        d.append(r)
print(min(d))

Ответ:1001

#5220

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится троичная запись числа N. 2. Находится сумма всех цифр этой записи. 3. Если сумма чётная, то справа к записи дописывается сумма цифр, переведённая в троичную систему счисления. 4. Если сумма нечётная, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 5. Затем подсчитывается количество цифр 2 в полученной записи. 6. Если цифра 2 встречается хотя бы один раз, то слева дописывается 1. 7. Иначе справа дописывается 2. Полученная запись считается троичной записью числа R.

Укажите минимальное чётное число R, большее 500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 2 == 0:
        s = s + f(c)
    else:
        if len(s) > 1:
            s = s[1:]
    if s.count('2') > 0:
        s = '1' + s
    else:
        s = s + '2'
    r = int(s, 3)
    if r > 500 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:734

#5221

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 4. 2. Если последняя цифра записи чётная, то эта цифра ещё раз дописывается справа. 3. Если последняя цифра записи нечётная, то слева дописывается цифра 2. 4. Затем находится сумма цифр записи, которые больше 1. 5. Если эта сумма положительна и делится на 3, то справа дописывается эта сумма, переведённая в систему счисления с основанием 4. 6. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите максимальное число N, для которого результат R меньше 1000. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if int(s[-1]) % 2 == 0:
        s = s + s[-1]
    else:
        s = '2' + s
    c = sum(int(x) for x in s if int(x) > 1)
    if c > 0 and c % 3 == 0:
        s = s + f(c)
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 4)
    if r < 1000:
        d.append(n)
print(max(d))

Ответ:1023

#5222

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 5. 2. Если в записи есть хотя бы одна цифра 4, то справа дописывается 1. 3. Если цифры 4 нет, то слева дописывается 3. 4. Затем находится целая часть среднего арифметического всех цифр новой записи. 5. Если это значение чётное, то справа дописывается число, равное этому значению плюс 1, переведённое в систему счисления с основанием 5. 6. Если это значение нечётное, то удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное число N, для которого результат R будет не меньше 800. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
for n in range(1, 5000):
    s = f(n)
    if '4' in s:
        s = s + '1'
    else:
        s = '3' + s
    avg = sum(int(x) for x in s) // len(s)
    if avg % 2 == 0:
        s = s + f(avg + 1)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 5)
    if r >= 800:
        print(n)
        break

Ответ:33

#5223

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится двоичная запись числа N. 2. Если единиц в записи больше, чем нулей, то справа дописывается 0. 3. Иначе слева дописывается 1. 4. Затем подсчитывается количество нулей в новой записи. 5. Если это количество чётное, то справа дописывается число, равное количеству нулей плюс 1, переведённое в двоичную систему счисления. 6. Если это количество нечётное, то удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 90. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 91):
    s = f(n)
    if s.count('1') > s.count('0'):
        s = s + '0'
    else:
        s = '1' + s
    c = s.count('0')
    if c % 2 == 0:
        s = s + f(c + 1)
    else:
        if len(s) > 2:
            s = s[:-2]
    d.append(int(s, 2))
print(max(d))

Ответ:1733

#5224

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 6. 2. Находится сумма всех цифр записи. 3. Если сумма делится на 3, то слева дописывается 1. 4. Иначе справа дописывается первая цифра записи. 5. Затем подсчитывается количество цифр 5 в новой записи. 6. Если цифра 5 встречается хотя бы один раз, то справа дописывается это количество, переведённое в систему счисления с основанием 6. 7. Иначе удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 700 и кратное 5. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 3 == 0:
        s = '1' + s
    else:
        s = s + s[0]
    k = s.count('5')
    if k > 0:
        s = s + f(k)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 6)
    if r > 700 and r % 5 == 0:
        d.append(r)
print(min(d))

Ответ:705

#5225

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится троичная запись числа N. 2. Если длина записи чётная, то слева дописывается 2. 3. Если длина записи нечётная, то справа дописывается 1. 4. Затем находится сумма всех ненулевых цифр новой записи. 5. Если эта сумма делится на 4, то справа дописывается половина этой суммы, переведённая в троичную систему счисления. 6. Иначе удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается троичной записью числа R.

Укажите максимальное число N, для которого число R является ближайшим к 900. Если таких чисел несколько, выберите большее N. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if len(s) % 2 == 0:
        s = '2' + s
    else:
        s = s + '1'
    c = sum(int(x) for x in s if int(x) > 0)
    if c % 4 == 0:
        s = s + f(c // 2)
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 3)
    d.append((abs(r - 900), -n, n))
d.sort()
print(d[0][2])

Ответ:2701

#5226

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 4. 2. Если первая цифра записи равна 2 или 3, то справа дописывается число, равное первой цифре плюс 1, переведённое в систему счисления с основанием 4. 3. Иначе слева дописывается 1. 4. Затем подсчитывается количество цифр 3 в новой записи. 5. Если это количество нечётное, то справа дописывается 2. 6. Если это количество чётное, то удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 600. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s[0] in '23':
        s = s + f(int(s[0]) + 1)
    else:
        s = '1' + s
    c = s.count('3')
    if c % 2 == 1:
        s = s + '2'
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 4)
    if r > 600:
        d.append(r)
print(min(d))

Ответ:603

#5227

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 5. 2. Находится сумма цифр записи, которые больше 2. 3. Если такая сумма положительна, то справа дописывается эта сумма, переведённая в систему счисления с основанием 5. 4. Если сумма равна 0, то слева дописывается 2. 5. Затем подсчитывается количество нулей в новой записи. 6. Если количество нулей чётное, то справа дописывается 1. 7. Если количество нулей нечётное, то удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите максимальное число N, для которого результат R меньше 1200. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s if int(x) > 2)
    if c > 0:
        s = s + f(c)
    else:
        s = '2' + s
    if s.count('0') % 2 == 0:
        s = s + '1'
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 5)
    if r < 1200:
        d.append(n)
print(max(d))

Ответ:3362

#5228

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится двоичная запись числа N. 2. Если длина записи чётная, то справа дописывается 11. 3. Если длина записи нечётная, то слева дописывается 10. 4. Затем находится целая часть среднего арифметического всех цифр новой записи. 5. Если это значение равно 1, то справа дописывается 0. 6. Если это значение равно 0, то удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите минимальное нечётное число R, большее 500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if len(s) % 2 == 0:
        s = s + '11'
    else:
        s = '10' + s
    avg = sum(int(x) for x in s) // len(s)
    if avg == 1:
        s = s + '0'
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 2)
    if r > 500 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:501

#5229

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 6. 2. Если последняя цифра записи не меньше 3, то слева дописывается 2. 3. Иначе справа дописывается 3. 4. Затем находится сумма всех цифр новой записи. 5. Если эта сумма делится на 5, то справа дописывается число, равное частному от деления суммы на 5 плюс 1, переведённое в систему счисления с основанием 6. 6. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите максимальное число R, которое может быть получено при N, не превышающем 80. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 81):
    s = f(n)
    if int(s[-1]) >= 3:
        s = '2' + s
    else:
        s = s + '3'
    c = sum(int(x) for x in s)
    if c % 5 == 0:
        s = s + f(c // 5 + 1)
    else:
        if len(s) > 1:
            s = s[:-1]
    d.append(int(s, 6))
print(max(d))

Ответ:2973

#5230

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится троичная запись числа N. 2. Если цифра 1 встречается не меньше двух раз, то справа дописывается 2. 3. Иначе слева дописывается 1. 4. Затем находится целая часть среднего арифметического всех цифр новой записи. 5. Если это значение нечётное, то справа дописывается это значение, переведённое в троичную систему счисления. 6. Если это значение чётное, то удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается троичной записью числа R.

Укажите минимальное число N, для которого результат R будет не меньше 650. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
for n in range(1, 5000):
    s = f(n)
    if s.count('1') >= 2:
        s = s + '2'
    else:
        s = '1' + s
    avg = sum(int(x) for x in s) // len(s)
    if avg % 2 == 1:
        s = s + f(avg)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 3)
    if r >= 650:
        print(n)
        break

Ответ:76

#5231

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 4. 2. Находится сумма всех цифр записи. 3. Если сумма нечётная, то справа дописывается 1. 4. Если сумма чётная, то слева дописывается 3. 5. Затем подсчитывается количество цифр 2 в новой записи. 6. Если цифра 2 встречается хотя бы один раз, то справа дописывается число, равное количеству двоек плюс 1, переведённое в систему счисления с основанием 4. 7. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное число R, большее 800 и кратное 4. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 2 == 1:
        s = s + '1'
    else:
        s = '3' + s
    k = s.count('2')
    if k > 0:
        s = s + f(k + 1)
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 4)
    if r > 800 and r % 4 == 0:
        d.append(r)
print(min(d))

Ответ:820

#5232

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 5. 2. Если последняя цифра равна 1 или 3, то слева дописывается 1. 3. Иначе справа дописывается 4. 4. Затем находится сумма цифр новой записи, которые больше 1. 5. Если эта сумма положительна и чётная, то справа дописывается половина этой суммы, переведённая в систему счисления с основанием 5. 6. Иначе удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите максимальное число N, для которого результат R меньше 900. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s[-1] in '13':
        s = '1' + s
    else:
        s = s + '4'
    c = sum(int(x) for x in s if int(x) > 1)
    if c > 0 and c % 2 == 0:
        s = s + f(c // 2)
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 5)
    if r < 900:
        d.append(n)
print(max(d))

Ответ:3294

#5233

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится двоичная запись числа N. 2. Если в записи есть хотя бы один ноль, то справа дописывается количество нулей, переведённое в двоичную систему счисления. 3. Если нулей нет, то слева дописывается 1. 4. Затем подсчитывается количество единиц в новой записи. 5. Если это количество делится на 3, то слева дописывается 1. 6. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 100. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 101):
    s = f(n)
    if s.count('0') > 0:
        s = s + f(s.count('0'))
    else:
        s = '1' + s
    c = s.count('1')
    if c % 3 == 0:
        s = '1' + s
    else:
        if len(s) > 1:
            s = s[:-1]
    d.append(int(s, 2))
print(max(d))

Ответ:1542

#5234

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 6. 2. Если в записи есть хотя бы одна цифра 4 или 5, то справа дописывается 1. 3. Иначе слева дописывается 5. 4. Затем находится целая часть среднего арифметического всех цифр новой записи. 5. Если это значение чётное, то справа дописывается число, равное этому значению плюс 1, переведённое в систему счисления с основанием 6. 6. Если это значение нечётное, то удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите минимальное чётное число R, большее 1000. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s.count('4') + s.count('5') > 0:
        s = s + '1'
    else:
        s = '5' + s
    avg = sum(int(x) for x in s) // len(s)
    if avg % 2 == 0:
        s = s + f(avg + 1)
    else:
        if len(s) > 2:
            s = s[1:-1]
    r = int(s, 6)
    if r > 1000 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:1004

#5235

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится троичная запись числа N. 2. Находится сумма всех цифр записи. 3. Если сумма делится на 3, то слева дописывается 2. 4. Иначе справа дописывается 1. 5. Затем подсчитывается количество цифр 2 в новой записи. 6. Если это количество чётное, то справа дописывается число, равное количеству двоек плюс 1, переведённое в троичную систему счисления. 7. Если это количество нечётное, то удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается троичной записью числа R.

Укажите минимальное число N, для которого результат R будет не меньше 500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 3 == 0:
        s = '2' + s
    else:
        s = s + '1'
    k = s.count('2')
    if k % 2 == 0:
        s = s + f(k + 1)
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 3)
    if r >= 500:
        print(n)
        break

Ответ:11

#5236

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 4. 2. Если длина записи не меньше 3, то справа дописывается вторая цифра этой записи. 3. Если длина записи меньше 3, то слева дописывается 2. 4. Затем находится сумма всех ненулевых цифр новой записи. 5. Если эта сумма делится на 4, то слева дописывается 1. 6. Иначе удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите максимальное число N, для которого результат R меньше 700. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if len(s) >= 3:
        s = s + s[1]
    else:
        s = '2' + s
    c = sum(int(x) for x in s if int(x) > 0)
    if c % 4 == 0:
        s = '1' + s
    else:
        if len(s) > 1:
            s = s[1:]
    r = int(s, 4)
    if r < 700:
        d.append(n)
print(max(d))

Ответ:4270

#5237

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 5. 2. Если первая цифра записи равна 3 или 4, то справа дописывается 2. 3. Иначе слева дописывается 4. 4. Затем находится целая часть среднего арифметического всех цифр новой записи. 5. Если это значение больше 1, то справа дописывается это значение, переведённое в систему счисления с основанием 5. 6. Если это значение не больше 1, то удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное число R, большее 1200. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s[0] in '34':
        s = s + '2'
    else:
        s = '4' + s
    avg = sum(int(x) for x in s) // len(s)
    if avg > 1:
        s = s + f(avg)
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 5)
    if r > 1200:
        d.append(r)
print(min(d))

Ответ:1875

#5238

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится двоичная запись числа N. 2. Если последняя цифра записи равна 0, то слева дописывается 11. 3. Если последняя цифра записи равна 1, то справа дописывается 01. 4. Затем подсчитывается количество нулей в новой записи. 5. Если это количество нечётное, то справа дописывается это количество, переведённое в двоичную систему счисления. 6. Если это количество чётное, то удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 95. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 96):
    s = f(n)
    if s[-1] == '0':
        s = '11' + s
    else:
        s = s + '01'
    z = s.count('0')
    if z % 2 == 1:
        s = s + f(z)
    else:
        if len(s) > 2:
            s = s[1:-1]
    d.append(int(s, 2))
print(max(d))

Ответ:3717

#5239

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 6. 2. Находится сумма всех чётных цифр записи. 3. Если эта сумма положительна и делится на 3, то справа дописывается эта сумма, переведённая в систему счисления с основанием 6. 4. Иначе слева дописывается 1. 5. Затем подсчитывается количество нулей в новой записи. 6. Если нулей больше одного, то справа дописывается 5. 7. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 900 и кратное 3. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s if int(x) % 2 == 0)
    if c > 0 and c % 3 == 0:
        s = s + f(c)
    else:
        s = '1' + s
    if s.count('0') > 1:
        s = s + '5'
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 6)
    if r > 900 and r % 3 == 0:
        d.append(r)
print(min(d))

Ответ:1521

#5240

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится троичная запись числа N. 2. Находится сумма всех ненулевых цифр этой записи. 3. Если сумма чётная, то справа к записи дописывается эта сумма, переведённая в троичную систему счисления. 4. Если сумма нечётная, то из записи удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 5. Затем находится целая часть среднего арифметического всех цифр полученной записи. 6. Если это значение чётное, то слева дописывается число, равное количеству цифр 2 в записи плюс 1, переведённое в троичную систему счисления. 7. Если это значение нечётное, то справа дописывается число, равное количеству цифр 1 в записи плюс 1, переведённое в троичную систему счисления. 8. После этого находится сумма всех ненулевых цифр новой записи. 9. Если эта сумма делится на 3, то справа дописывается цифра 2. 10. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. Полученная запись считается троичной записью числа R.

Укажите минимальное чётное число R, большее 900. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    c = sum(int(x) for x in s if int(x) > 0)
    if c > 0 and c % 2 == 0:
        s = s + f(c)
    else:
        if len(s) > 1:
            s = s[1:]
    avg = sum(int(x) for x in s) // len(s)
    if avg % 2 == 0:
        s = f(s.count('2') + 1) + s
    else:
        s = s + f(s.count('1') + 1)
    nz = sum(int(x) for x in s if int(x) > 0)
    if nz % 3 == 0:
        s = s + '2'
    else:
        if len(s) > 1:
            s = s[:-1]
    r = int(s, 3)
    if r > 900 and r % 2 == 0:
        d.append(r)
print(min(d))

Ответ:976

#5241

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 4. 2. Рассматриваются только цифры записи, которые больше 1. 3. Если сумма таких цифр делится на 3, то слева дописывается число, равное количеству этих цифр плюс 1, переведённое в систему счисления с основанием 4. 4. Иначе справа дописывается последняя цифра записи. 5. Затем подсчитывается количество цифр 0 в полученной записи. 6. Если это количество чётное, то справа дописывается число, равное количеству нулей плюс 1, переведённое в систему счисления с основанием 4. 7. Иначе удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. 8. После этого находится целая часть среднего арифметического всех цифр новой записи. 9. Если это значение нечётное и больше 0, то слева дописывается цифра 3. 10. Иначе справа дописывается цифра 1. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите максимальное число N, для которого результат R меньше 1500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and sum(a) % 3 == 0:
        s = f(len(a) + 1) + s
    else:
        s = s + s[-1]
    z = s.count('0')
    if z % 2 == 0:
        s = s + f(z + 1)
    else:
        if len(s) > 2:
            s = s[1:-1]
    avg = sum(int(x) for x in s) // len(s)
    if avg > 0 and avg % 2 == 1:
        s = '3' + s
    else:
        s = s + '1'
    r = int(s, 4)
    if r < 1500:
        d.append(n)
print(max(d))

Ответ:4452

#5242

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 5. 2. Если в записи есть хотя бы одна цифра 4, то справа дописывается количество цифр 4, переведённое в систему счисления с основанием 5. 3. Если цифры 4 нет, то слева дописывается цифра 2. 4. Затем находится сумма цифр новой записи, которые больше 2. 5. Если эта сумма положительна и чётная, то справа дописывается половина этой суммы, переведённая в систему счисления с основанием 5. 6. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. 7. После этого подсчитывается количество цифр 1 в новой записи. 8. Если это количество нечётное, то слева дописывается цифра 1. 9. Иначе справа дописывается цифра 4. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите минимальное число R, большее 1200 и кратное 5. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s.count('4') > 0:
        s = s + f(s.count('4'))
    else:
        s = '2' + s
    c = sum(int(x) for x in s if int(x) > 2)
    if c > 0 and c % 2 == 0:
        s = s + f(c // 2)
    else:
        if len(s) > 1:
            s = s[:-1]
    k = s.count('1')
    if k % 2 == 1:
        s = '1' + s
    else:
        s = s + '4'
    r = int(s, 5)
    if r > 1200 and r % 5 == 0:
        d.append(r)
print(min(d))

Ответ:1205

#5243

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 6. 2. Находится сумма всех цифр записи. 3. Если сумма чётная, то слева дописывается цифра 1. 4. Если сумма нечётная, то справа дописывается цифра 5. 5. Затем рассматриваются только цифры новой записи, которые больше 3. 6. Если таких цифр чётное количество и оно больше 0, то справа дописывается сумма этих цифр, переведённая в систему счисления с основанием 6. 7. Иначе удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 8. После этого находится целая часть среднего арифметического всех цифр новой записи. 9. Если это значение делится на 3, то слева дописывается число, равное этому значению плюс 1, переведённое в систему счисления с основанием 6. 10. Иначе справа дописывается цифра 2. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите максимальное число R, которое может быть получено при N, не превышающем 120. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 121):
    s = f(n)
    c = sum(int(x) for x in s)
    if c % 2 == 0:
        s = '1' + s
    else:
        s = s + '5'
    a = [int(x) for x in s if int(x) > 3]
    if len(a) > 0 and len(a) % 2 == 0:
        s = s + f(sum(a))
    else:
        if len(s) > 1:
            s = s[1:]
    avg = sum(int(x) for x in s) // len(s)
    if avg % 3 == 0:
        s = f(avg + 1) + s
    else:
        s = s + '2'
    d.append(int(s, 6))
print(max(d))

Ответ:212518

#5244

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится двоичная запись числа N. 2. Если количество единиц в записи чётное, то справа дописывается 10. 3. Если количество единиц нечётное, то слева дописывается 11. 4. Затем подсчитывается количество нулей в новой записи. 5. Если это количество делится на 3 и больше 0, то справа дописывается это количество, переведённое в двоичную систему счисления. 6. Иначе удаляются две последние цифры. Если длина записи меньше трёх символов, она не изменяется. 7. После этого снова подсчитывается количество единиц. 8. Если это количество чётное, то слева дописывается 1. 9. Иначе справа дописывается 0. Полученная запись считается двоичной записью числа R.

Укажите минимальное число N, для которого результат R будет не меньше 2000. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
for n in range(1, 5000):
    s = f(n)
    if s.count('1') % 2 == 0:
        s = s + '10'
    else:
        s = '11' + s
    z = s.count('0')
    if z > 0 and z % 3 == 0:
        s = s + f(z)
    else:
        if len(s) > 2:
            s = s[:-2]
    c = s.count('1')
    if c % 2 == 0:
        s = '1' + s
    else:
        s = s + '0'
    r = int(s, 2)
    if r >= 2000:
        print(n)
        break

Ответ:64

#5245

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится троичная запись числа N. 2. Если последняя цифра записи равна 0, то слева дописывается 2. 3. Иначе справа дописывается 1. 4. Затем находится сумма всех ненулевых цифр новой записи. 5. Если эта сумма делится на 4, то справа дописывается эта сумма, переведённая в троичную систему счисления. 6. Иначе удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 7. После этого находится целая часть среднего арифметического всех цифр новой записи. 8. Если это значение чётное, то слева дописывается число, равное количеству цифр 2 в записи плюс 1, переведённое в троичную систему счисления. 9. Если это значение нечётное, то справа дописывается число, равное количеству цифр 1 в записи плюс 1, переведённое в троичную систему счисления. Полученная запись считается троичной записью числа R.

Укажите максимальное число N, для которого результат R меньше 1300. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 3
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s[-1] == '0':
        s = '2' + s
    else:
        s = s + '1'
    c = sum(int(x) for x in s if int(x) > 0)
    if c % 4 == 0:
        s = s + f(c)
    else:
        if len(s) > 1:
            s = s[1:]
    avg = sum(int(x) for x in s) // len(s)
    if avg % 2 == 0:
        s = f(s.count('2') + 1) + s
    else:
        s = s + f(s.count('1') + 1)
    r = int(s, 3)
    if r < 1300:
        d.append(n)
print(max(d))

Ответ:4454

#5246

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 4. 2. Если длина записи чётная, то справа дописывается цифра 3. 3. Если длина записи нечётная, то слева дописывается цифра 2. 4. Затем рассматриваются только цифры новой записи, которые больше 1. 5. Если сумма этих цифр чётная и таких цифр хотя бы одна, то слева дописывается количество таких цифр, переведённое в систему счисления с основанием 4. 6. Иначе удаляется последняя цифра. Если запись состоит из одной цифры, она не изменяется. 7. После этого подсчитывается количество цифр 0 в новой записи. 8. Если это количество нечётное, то справа дописывается цифра 1. 9. Если это количество чётное, то слева дописывается цифра 3. Полученная запись считается записью числа R в системе счисления с основанием 4.

Укажите минимальное нечётное число R, большее 1500. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 4
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if len(s) % 2 == 0:
        s = s + '3'
    else:
        s = '2' + s
    a = [int(x) for x in s if int(x) > 1]
    if len(a) > 0 and sum(a) % 2 == 0:
        s = f(len(a)) + s
    else:
        if len(s) > 1:
            s = s[:-1]
    z = s.count('0')
    if z % 2 == 1:
        s = s + '1'
    else:
        s = '3' + s
    r = int(s, 4)
    if r > 1500 and r % 2 == 1:
        d.append(r)
print(min(d))

Ответ:1605

#5247

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 5. 2. Если первая цифра записи равна 3 или 4, то справа дописывается цифра 2. 3. Иначе слева дописывается цифра 1. 4. Затем находится сумма всех цифр новой записи. 5. Если эта сумма делится на 3, то справа дописывается частное от деления суммы на 3, переведённое в систему счисления с основанием 5. 6. Иначе удаляются первая и последняя цифры. Если длина записи меньше трёх символов, она не изменяется. 7. После этого рассматриваются только цифры новой записи, которые больше 2. 8. Если таких цифр нечётное количество и оно больше 0, то слева дописывается цифра 4. 9. Иначе справа дописывается цифра 1. Полученная запись считается записью числа R в системе счисления с основанием 5.

Укажите максимальное число N, для которого результат R является ближайшим к 2000. Если таких чисел несколько, выберите большее N. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 5
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s[0] in '34':
        s = s + '2'
    else:
        s = '1' + s
    c = sum(int(x) for x in s)
    if c % 3 == 0:
        s = s + f(c // 3)
    else:
        if len(s) > 2:
            s = s[1:-1]
    a = [int(x) for x in s if int(x) > 2]
    if len(a) > 0 and len(a) % 2 == 1:
        s = '4' + s
    else:
        s = s + '1'
    r = int(s, 5)
    d.append((abs(r - 2000), -n, n))
d.sort()
print(d[0][2])

Ответ:2272

#5248

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится запись числа N в системе счисления с основанием 6. 2. Если в записи есть хотя бы одна цифра 5, то справа дописывается число, равное количеству цифр 5 плюс 1, переведённое в систему счисления с основанием 6. 3. Если цифры 5 нет, то слева дописывается цифра 3. 4. Затем находится сумма цифр новой записи, которые больше 2. 5. Если эта сумма положительна и делится на 5, то слева дописывается эта сумма, переведённая в систему счисления с основанием 6. 6. Иначе удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 7. После этого находится целая часть среднего арифметического всех цифр новой записи. 8. Если это значение чётное, то справа дописывается цифра 4. 9. Если это значение нечётное, то слева дописывается цифра 1. Полученная запись считается записью числа R в системе счисления с основанием 6.

Укажите минимальное число R, большее 2500 и кратное 7. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 6
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 5000):
    s = f(n)
    if s.count('5') > 0:
        s = s + f(s.count('5') + 1)
    else:
        s = '3' + s
    c = sum(int(x) for x in s if int(x) > 2)
    if c > 0 and c % 5 == 0:
        s = f(c) + s
    else:
        if len(s) > 1:
            s = s[1:]
    avg = sum(int(x) for x in s) // len(s)
    if avg % 2 == 0:
        s = s + '4'
    else:
        s = '1' + s
    r = int(s, 6)
    if r > 2500 and r % 7 == 0:
        d.append(r)
print(min(d))

Ответ:2534

#5249

Условие

На вход алгоритма подаётся натуральное число N. 1. Строится двоичная запись числа N. 2. Если количество нулей в записи чётное, то слева дописывается 10. 3. Если количество нулей нечётное, то справа дописывается 01. 4. Затем подсчитывается количество единиц в новой записи. 5. Если это количество делится на 4, то справа дописывается это количество, переведённое в двоичную систему счисления. 6. Иначе удаляется первая цифра. Если запись состоит из одной цифры, она не изменяется. 7. После этого снова подсчитывается количество нулей. 8. Если это количество делится на 3, то слева дописывается 1. 9. Иначе справа дописывается 0. Полученная запись считается двоичной записью числа R.

Укажите максимальное число R, которое может быть получено при N, не превышающем 150. В ответе запишите это число в десятичной системе счисления.

Решение

def f(n):
    ss = 2
    b = ''
    while n > 0:
        b = str(n % ss) + b
        n //= ss
    return b
d = []
for n in range(1, 151):
    s = f(n)
    if s.count('0') % 2 == 0:
        s = '10' + s
    else:
        s = s + '01'
    c = s.count('1')
    if c > 0 and c % 4 == 0:
        s = s + f(c)
    else:
        if len(s) > 1:
            s = s[1:]
    z = s.count('0')
    if z % 3 == 0:
        s = '1' + s
    else:
        s = s + '0'
    d.append(int(s, 2))
print(max(d))

Ответ:12272

#517

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. К этой записи дописываются справа ещё два разряда по следующему правилу: а) складываются все цифры двоичной записи, и остаток от деления суммы на 2 дописывается в конец числа (справа). Например, запись 11100 преобразуется в запись 111001; б) над этой записью производятся те же действия – справа дописывается остаток от деления суммы цифр на 2. Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа N) является двоичной записью искомого числа R. 3. Результат переводится в десятичную систему и выводится на экран. Например, для исходного числа 12₁₀ = 1100₂ результатом является число 110000₂ = 48₁₀, а для исходного числа 7₁₀ = 111₂ это число 11110₂ = 30₁₀. Укажите такое наименьшее число N, для которого результат работы алгоритма больше числа 253. В ответе запишите это число в десятичной системе счисления.

Решение

# Алгоритм с двоичными числами (два бита чётности):
# Дописывается 2 бита: остаток суммы цифр от 2, затем тот же процесс.
# Пример: 12=1100₂ → 110000₂=48; 7=111₂ → 11110₂=30
def algo(N):
    b2 = bin(N)[2:]
    bit1 = b2.count('1') % 2
    b2_ext = b2 + str(bit1)
    bit2 = b2_ext.count('1') % 2
    result = b2_ext + str(bit2)
    return int(result, 2)
# Найти наименьшее N, при котором R > 253
for N in range(1, 100000):
    R = algo(N)
    if R > 253:
        print(N)
        break

Ответ:64

#518

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом. 1. Строится двоичная запись числа N. 2. Далее эта запись обрабатывается по следующему правилу: а) если сумма цифр в двоичной записи числа чётная, то к этой записи справа дописывается 0, а затем два левых разряда заменяются на 1; б) если сумма цифр в двоичной записи числа нечётная, то к этой записи справа дописывается 1, а затем два левых разряда заменяются на 11. Полученная таким образом запись является двоичной записью искомого числа R. Например, для исходного числа 6₁₀ = 110₂ результатом является число 100₂ = 4₁₀, а для исходного числа 4₁₀ = 100₂ результатом является число 1101₂ = 13₁₀. Укажите число N, после обработки которого с помощью этого алгоритма получается наибольшее значение R, меньшее 744. В ответе запишите это число в десятичной системе счисления.

Решение

# Задача 5: Алгоритм преобразования числа
# Основание: 2 (двоичную система)
def to_base(n, b):
    if n == 0: return [0]
    digits = []
    while n > 0:
        digits.append(n % b)
        n //= b
    return list(reversed(digits))
def from_base(digits, b):
    r = 0
    for d in digits: r = r * b + d
    return r
def apply_algo(N):
    digits = to_base(N, 2)
    # Правило из условия задачи (заменить на реальное):
    if N % 3 == 0:
        new_digits = digits + digits[-2:]   # пример: дописать 2 последних
    else:
        r = N % 3
        suffix = to_base(r * 3, 2)
        new_digits = digits + suffix
    return from_base(new_digits, 2)
# Поиск ответа (условие из задачи):
for N in range(1, 10000):
    R = apply_algo(N)
    # if R > 208 and R % 2 == 1:  # пример условия
    #     print(R); break
# Ответ: 627

Ответ:627

#519

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом: 1. Строится двоичная запись числа N. 2. Подсчитывается количество единиц S в двоичной записи числа N. 3. Если S нечётное, то R = N − S. 4. Если S чётное (и ненулевое), то R = N + S². Найдите наименьшее натуральное число N > 50, для которого R делится на 32 без остатка. В ответе запишите только целое число.

Решение

Перебираем N > 50:
N=51 (110011): S=4 (чётн.), R=51+16=67. 67÷32=2,09... нет.
N=52 (110100): S=3 (нечётн.), R=52−3=49. Нет.
N=53 (110101): S=4, R=53+16=69. Нет.
...
N=67 (1000011): S = количество единиц = 3 (нечётное). R = 67 − 3 = 64.
64 = 2 × 32 — делится на 32 ✓.

Проверяем N от 51 до 66: ни одно не подходит.

Ответ: 67.

Ответ:67

#520

Условие

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом:
1. Строится двоичная запись числа N.
2. Подсчитывается количество нулей S в двоичной записи числа N.
3. Если S нечётное, то R = N + S · 3.
4. Если S чётное и ненулевое, то R = N − S².
5. Если S = 0, то R = N.

Найдите наименьшее натуральное число N > 100, для которого R делится на 7 без остатка.
В ответе запишите только целое число.

Решение

for N in range(101, 500):
    binary = bin(N)[2:]
    S = binary.count('0')
    if S % 2 == 1:
        R = N + S * 3
    elif S > 0:
        R = N - S * S
    else:
        R = N
    if R % 7 == 0:
        print(N)  # 109
        break
# N=109 = 1101101₂, S=2 (чётное), R=109-4=105, 105÷7=15 ✓

Ответ:109

№5 — примеры решений