Статья Автор: Щурова Ольга

ЕГЭ 5

Автомат обрабатывает натуральное число N по следующему алгоритму:

1. Строится двоичная запись числа N.

2. Удаляется первая слева единица и все следующие непосредственно за ней нули. Если после этого в числе не остаётся цифр, результат этого действия считается равным нулю.

3. Полученное число переводится в десятичную запись.

4. Новое число вычитается из исходного, полученная разность выводится на экран.

Пример. Дано число N = 11. Алгоритм работает следующим образом.

1. Двоичная запись числа N: 1011.

2. Удаляется первая единица и следующий за ней ноль: 11.

3. Десятичное значение полученного числа 3.

4. На экран выводится число 11 – 3 = 8.

Сколько разных значений будет показано на экране автомата при последовательном вводе всех натуральных чисел от 100 до 3000?

def f(n):
    n2=bin(n)[2:]
    pb=n2.find('1')
    pe=n2.find('1',pb+1)
    n2=n2[:pb]+n2[pe:]
    if n2=='': n2=0
    else: n2=int(n2,2)
    return n-n2


ans_m=set()

for n in range(100,3001):
    ans_m.add(f(n))
    
print(len(ans_m))

Автомат обрабатывает натуральное число N по следующему алгоритму:

1. Строится двоичная запись числа N.

2. Запись «переворачивается», то есть читается справа налево. Если при этом появляются ведущие нули, они отбрасываются.

3. Полученное число переводится в десятичную запись и выводится на экран.

Пример. Дано число N = 58. Алгоритм работает следующим образом.

1. Двоичная запись числа N: 111010.

2. Запись справа налево: 10111 (ведущий ноль отброшен).

3. На экран выводится десятичное значение полученного числа 23.

Какое наибольшее число, не превышающее 100, после обработки автоматом даёт результат 11?

def f(n):
    n2=bin(n)[2:]
    n2=n2[::-1]
    n2=n2[n2.index('1'):]
    return int(n2,2)

#print(f(58))
ans=[]

for x in range(1,101):
    if f(x)==11: ans.append(x)
    
print(max(ans))

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.

1. Строится двоичная запись числа N.

2. К этой записи дописываются справа ещё два разряда по следующему правилу:

а) складываются все цифры двоичной записи числа N, и остаток от деления суммы на 2 дописывается в конец числа (справа). Например, запись 11100 преобразуется в запись 111001;

б) над этой записью производятся те же действия — справа дописывается остаток от деления суммы её цифр на 2.

Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа N) является двоичной записью искомого числа R.

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

def g(s):
    A=[int(x) for x in s]
    return str(sum(A)%2)



def f(n):
    n2=bin(n)[2:]
    n2+=g(n2)
    n2+=g(n2)
    return int(n2,2)

ans=[]

for x in range(1,100000):
    R=f(x)
    if R>55: ans.append(R)
    
print(min(ans))

Алгоритм получает на вход натуральное число N > 1 и строит по нему новое число R следующим образом:

1. Вычисляется сумма чётных цифр в десятичной записи числа N. Если чётных цифр в записи нет, сумма считается равной нулю.

2. Вычисляется сумма цифр, стоящих на чётных местах в десятичной записи числа N без ведущих нулей. Места отсчитываются слева направо (от старших разрядов к младшим, начиная с единицы). Если число однозначное (цифр на чётных местах нет), сумма считается равной нулю.

3. Результатом работы алгоритма становится модуль разности полученных двух сумм.

Пример. Дано число N = 2021. Алгоритм работает следующим образом:

1. Чётные цифры в записи: 2, 0, 2, их сумма равна 4.

2. Цифры на чётных местах: 0, 1, их сумма равна 1.

3. Модуль разности полученных сумм равен 3.

Результат работы алгоритма R = 3.

При каком наименьшем N в результате работы алгоритма получится R = 11?

def g1(A):
    su=0
    for x in A:
        if x%2==0: su+=x
    return su

def g2(A):
    su=0
    for x in range(1,len(A),2):
        su+=A[x]
    return su
    


def f(n):
    A=[int(x) for x in str(n)]
    a=g1(A)
    b=g2(A)
    return abs(a-b)

#print(f(2021))


for x in range(2,1000):
    R=f(x)
    if R==11:
        print(x)
        break

Автомат получает на вход четырёхзначное число. По этому числу строится новое число по следующим правилам.

1. Складываются отдельно первая и вторая цифры, вторая и третья цифры, а также третья и четвёртая цифры.

2. Из полученных трёх чисел выбираются два наибольших и записываются друг за другом в порядке неубывания без разделителей.

Пример. Исходное число: 9575. Суммы: 9 + 5 = 14; 5 + 7 = 12; 7 + 5 = 12. Наибольшие суммы: 14, 12. Результат: 1214.

Укажите наименьшее число, при обработке которого автомат выдаёт результат 1418.

def f(n):
    mas=[n[0]+n[1],n[1]+n[2],n[2]+n[3]]
    mx=max(mas)
    del mas[mas.index(mx)]
    mx2=max(mas)
    return int(str(mx2)+str(mx))
    
 
for n in range(1000,9999+1):
  A=[int(x) for x in str(n)]
  if f(A)==1418:
      print(n)
      break

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.

1) Строится двоичная запись числа N.

2) К этой записи дописываются справа ещё два разряда по следующему правилу:

а) если N чётное, в конец числа (справа) дописывается сначала ноль, а затем единица.

б)если N нечётное, справа дописывается сначала единица, а затем ноль.

Например, двоичная запись 100 числа 4 будет преобразована в 10001, а двоичная запись 111 числа 7 будет преобразована в 11110.

Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа N) является двоичной записью числа R — результата работы данного алгоритма.

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

def f(n):
    n2=bin(n)[2:]
    if n2[-1]=='0': n2+='01'
    else: n2+='10'
    return int(n2,2)

A=[10**5]*100000
for N in range(1,10001):
    R=f(N)
    if R>102: A[N]=R
    
print(min(A))
print(f(26))

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.

1) Строится двоичная запись числа N.

2) К этой записи дописываются справа ещё два разряда по следующему правилу:

б) над этой записью производятся те же действия – справа дописывается остаток от деления суммы её цифр на 2.

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

def sum_digits(ns):
    nm=[int(x) for x in ns]
    return sum(nm)

def f5(n):
    n2=bin(n)[2:]
    n2+=str(sum_digits(n2)%2)
    n2+=str(sum_digits(n2)%2)
    return int(n2,2)

A=[]
for n in range(1,100001):
    R=f5(n)
    if R>83: A.append(R)
        
print(min(A))

Алгоритм получает на вход натуральное число N > 1 и строит по нему новое число R следующим образом:

1. Если исходное число кратно 2, оно делится на 2, в противном случае из него вычитается 1.

2. Если полученное на предыдущем шаге число кратно 3, оно делится на 3, в противном случае из него вычитается 1.

3. Если полученное на предыдущем шаге число кратно 7, оно делится на 7, в противном случае из него вычитается 1.

4. Число, полученное на шаге 3, считается результатом работы алгоритма.

Пример. Дано число N = 44. Алгоритм работает следующим образом:

1. Число 44 кратно 2, оно делится на 2, получается 22.

2. Число 22 не кратно 3, из него вычитается 1, получается 21.

3. Число 21 кратно 7, оно делится на 7, получается 3.

4. Результат работы алгоритма R = 3.

Сколько существует различных натуральных чисел N, при обработке которых получится R = 1?

def f5(n):
    if n%2==0: n//=2
    else: n-=1
    if n%3==0: n//=3
    else: n-=1
    if n%7==0: n//=7
    else: n-=1
    return n

#print(f5(44))
cnt=0

for n in range(2,1000):
    R=f5(n)
    if R==1: 
        cnt+=1
    
print(cnt)

Чтобы оставить комментарий нужна авторизация

Печать