Ошибка.
Попробуйте повторить позже
На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.
- Строится двоичная запись числа N.
- К этой записи дописываются ещё несколько разрядов по следующему правилу: если N чётное, то к нему справа дописывается , если N нечетное – слева дописывается и справа ;
- Результат переводится в десятичную систему и выводится на экран.
Пример. Дано число N = . Алгоритм работает следующим образом:
- Двоичная запись числа N: .
- Число нечетное, следовательно слева дописываем , справа .
- На экран выводится число .
В результате работы автомата на экране появилось число, большее . Для какого наименьшего значения N данная ситуация возможна?
for i in range(1, 10000): if i % 2 == 0: i1 = bin(i)[2:] + ’01’ else: i1 = ’11’ + bin(i)[2:] + ’0’ if int(i1, 2) > 1021: print(i) break
Ошибка.
Попробуйте повторить позже
На вход алгоритма подаётся натуральное число . Алгоритм строит по нему новое число следующим образом.
1) Строится двоичная запись числа .
2) Эта запись изменяется по следующим правилам:
Если сумма цифр в двоичной записи числа четная, то справа дописывается , а первые два левых разряда заменяются на ;
Если сумма цифр в двоичной записи числа нечетная, то справа дописывается , а первые два левых разряда заменяются на ;
Например, запись преобразуется в .
Полученная таким образом запись (в ней на один разряд больше, чем в записи исходного числа ) является двоичной записью искомого числа .
Укажите максимальное число , для которого результат работы алгоритма меньше . В ответе это число запишите в десятичной системе.
for i in range(2, 24): x = bin(i)[2:] if x.count("1") % 2 == 0: x = "10" + x[2:] + "0" else: x = "11" + x[2:] + "1" if int(x, 2) < 24: print(i)
Ошибка.
Попробуйте повторить позже
МС получает на вход натуральное число и строит по нему новое число следующим образом:
- Строится двоичная запись числа .
- Подсчитывается количество нулей и единиц в полученной записи. Если их количество одинаково, в конец записи добавляется её последняя цифра. В противном случае в конец записи добавляется цифра, которая встречается реже.
- Шаг повторяется еще два раза.
- Результат переводится в десятичную систему счисления.
При каком наибольшем исходном числе в результате работы алгоритма получается нечетное число, которое делится на ?
Решение 1
for i in range(1023, 1, -1): s = bin(i)[2:] # Внизу отказ от ИВ s += s[-1] * (s.count(’0’) == s.count(’1’)) + \ ’1’ * (s.count(’1’) < s.count(’0’)) + ’0’ * (s.count(’0’) < s.count(’1’)) s += s[-1] * (s.count(’0’) == s.count(’1’)) + \ ’1’ * (s.count(’1’) < s.count(’0’)) + ’0’ * (s.count(’0’) < s.count(’1’)) s += s[-1] * (s.count(’0’) == s.count(’1’)) + \ ’1’ * (s.count(’1’) < s.count(’0’)) + ’0’ * (s.count(’0’) < s.count(’1’)) if int(s, 2) % 2 != 0 and int(s, 2) % 7 == 0: print(i) break
Решение 2
for i in range(1023, 1, -1): s = bin(i)[2:] for j in range(3): k = s.count(’1’) - s.count(’0’) if (k < 0): s += ’1’ elif (k > 0): s += ’0’ else: s += s[-1] if int(s, 2) % 2 != 0 and int(s, 2) % 7 == 0: print(i) break
Ошибка.
Попробуйте повторить позже
Автомат обрабатывает натуральное число N по следующему алгоритму:
1. Строится двоичная запись числа .
2. Складываются все цифры полученной двоичной записи. В конец записи (справа) дописывается остаток от деления полученной суммы на .
3. Предыдущий пункт повторяется для записи с добавленной цифрой.
4. Результат переводится в десятичную систему и выводится на экран.
Пример. Дано число . Алгоритм работает следующим образом:
1. Двоичная запись числа .
2. Сумма цифр двоичной записи , остаток от деления на равен , новая запись .
3. Сумма цифр полученной записи , остаток от деления на равен , новая запись .
4. На экран выводится число .
Какое наименьшее число, большее вашего балла на ЕГЭ (), может появится на экране в результате работы автомата?
for i in range(1000000): s = bin(i)[2::] s += str(s.count(’1’) % 2) s += str(s.count(’1’) % 2) if int(s, 2) > 100: print(int(s, 2)) break
Аналитическое решение:
Имеется число . Все числа в двоичной записи складываются и добавляется остаток от деления на 2 этой суммы, то есть цифра 0 или 1, значит если сумма чётна, то дописываем 0, иначе 1. Если мы дописали единичку, то количество единиц увеличится на 1, а значит, что после этого сумма будет чётна, и уже в следующем пункте мы допишем нолик. Если мы дописали ноль, то сумма числа не меняется, а значит в следующем пункте мы также допишем нолик. Значит число в 2 СС заканчивается на 00 или 10.
Нам необходимо найти число, большее, чем 100, которое в 2 СС заканчивается на 00 или 10. Будем перебирать с минимального.
Подойдет ли число ? Нет, оно кончается на 01.
Подойдет ли число ? Да, так как оно заканчивается на 10. Значит это и есть наш ответ.
Ошибка.
Попробуйте повторить позже
Автомат обрабатывает натуральное число по следующему алгоритму:
- Строится двоичная запись числа .
- Складываются все цифры полученной двоичной записи. В конец записи (справа) дописывается остаток от деления суммы на .
- Предыдущий пункт повторяется для записи с добавленной цифрой.
- Результат переводится в десятичную систему и выводится на экран.
Пример. Дано число . Алгоритм работает следующим образом:
- Двоичная запись числа .
- Сумма цифр двоичной записи , остаток от деления на равен , новая запись .
- Сумма цифр полученной записи , остаток от деления на равен , новая запись .
- На экран выводится число .
Какое наименьшее число, большее , может появиться на экране в результате работы автомата??
for i in range(1000000): s = bin(i)[2:] s += str(s.count(’1’) % 2) s += str(s.count(’1’) % 2) if int(s, 2) > 1024: print(int(s, 2)) break
Ошибка.
Попробуйте повторить позже
На вход алгоритма подаётся натуральное число . Алгоритм строит по нему новое число следующим образом.
- Строится двоичная запись числа .
- Складываются все цифры полученной двоичной записи. В конец записи (справа) дописывается остаток от деления суммы цифр на .
- Предыдущий пункт повторяется для записи с добавленной цифрой.
- Результат переводится в десятичную систему и выводится на экран.
Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа ) является двоичной записью искомого числа .
Укажите такое наименьшее число , которое превышает и может являться результатом работы этого алгоритма. В ответе это число запишите в десятичной системе счисления.
s = bin(i)[2::]
s += str(s.count(’1’) % 2)
s += str(s.count(’1’) % 2)
if int(s, 2) > 50:
print(int(s, 2))
break
Ошибка.
Попробуйте повторить позже
На вход алгоритма подаётся натуральное число . Алгоритм строит по нему новое число следующим
образом.
- Строится двоичная запись числа .
- Складываются все цифры двоичной записи, и остаток от деления суммы цифр на дописывается в конец числа (справа). Например, запись преобразуется в запись ;
- Шаг повторяется еще один раз. Например, запись преобразуется в запись ;
Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа ) является двоичной записью искомого числа .
Укажите минимальное число , которое превышает и может являться результатом работы алгоритма. В ответе это число запишите в десятичной системе.
for i in range(1, 1000000): s = bin(i)[2:] s += str(s.count(’1’) % 2) s += str(s.count(’1’) % 2) if int(s, 2) > 166: print(int(s, 2)) break
Ошибка.
Попробуйте повторить позже
Алгоритм получает на вход натуральное число и строит по нему новое число следующим образом:
- Строится двоичная запись числа .
- В конец записи (справа) дописывается конъюнкция двух правых крайних цифр двоичной записи числа .
- В конец записи (справа) дописывается конъюнкция двух левых крайних цифр двоичной записи числа .
- Результат переводится в десятичную систему.
Пример. Дано число . Алгоритм работает следующим образом:
- Двоичная запись числа .
- Конъюнкция двух правых крайних цифр , новая запись .
- Конъюнкция двух левых крайних цифр , новая запись .
- Результат работы алгоритма .
При каком наименьшем числе в результате работы алгоритма получится ? В ответе запишите это число в десятичной системе счисления.
for i in range(2, 10000): s = bin(i)[2:] s += str(int(s[-2]) & int(s[-1])) s += str(int(s[0]) & int(s[1])) if int(s, 2) > 55: print(i) break
Ошибка.
Попробуйте повторить позже
Алгоритм получает на вход натуральное число и строит по нему новое число следующим образом:
- Строится двоичная запись числа .
- В этой записи последний встречаемый ноль заменяется на первые две цифры полученной записи. Если нуля нет в записи числа, алгоритм аварийно завершается.
- Запись записывается справа налево (в обратную сторону).
- Результат переводится в десятичную систему счисления.
Для скольких значений в результате работы алгоритма получится число ?
Решение 1
ans = 0 for i in range(2, 10000): s = bin(i)[2:] if s.count(’0’) > 0: ind = ’’ for j in range(len(s) - 1, -1, -1): if s[j] == ’0’: ind = j break x = s[:ind] + s[0] + s[1] + s[ind + 1:] x = x[::-1] if int(x, 2) == 255: ans += 1 print(ans)
Решение 2
ans = 0 for i in range(2, 10000): s = bin(i)[2:] if s.count(’0’) > 0: s = s[::-1].replace(’0’, s[0:2][::-1], 1) if int(s, 2) == 255: ans += 1 print(ans)
Ошибка.
Попробуйте повторить позже
Автомат обрабатывает натуральное число по следующему алгоритму:
- Строится восьмибитная двоичная запись числа .
- Удаляется последняя цифра двоичной записи.
- Запись «переворачивается», то есть читается справа налево.
- Полученное число переводится в десятичную запись и выводится на экран.
Каково наименьшее число, меньшее , которое после обработки автоматом не изменится?
for i in range(1, 100): s = ’0’ * (8 - len(bin(i)[2:])) + bin(i)[2:] s = s[:len(s) - 1] s = s[::-1] if int(s, 2) == i: print(i) break
Ошибка.
Попробуйте повторить позже
Автомат обрабатывает натуральное число по следующему алгоритму:
1) Строится восьмибитная двоичная запись числа .
2) Инвертируются разряды исходного числа (0 заменяется на 1, 1 на 0).
3) К полученному двоичному числу прибавляют единицу.
4) Полученное число переводится в десятичную систему счисления.
Для какого числа N результат работы алгоритма равен 130?
for i in range(1, 128): s = ’0’ * (8 - len(bin(i)[2::])) + bin(i)[2::] x = ’’ for j in range(len(s)): if s[j] == ’1’: x += ’0’ else: x += ’1’ if (int(x, 2) + 1) == 130: print(i)
Аналитическое решение:
Необходимо найти такое , что после работы алгоритма мы получим 130. Давайте размотаем алгоритм с конца: в конце алгоритм добавляет единицу, а значит отнимём её и получим число . В 2 СС это число выглядит так . Инвертируем биты обратно, получим число , ведущий ноль не отбрасываем, так как алгоритм строил восьмибитную(то есть состояющую из 8 цифр в двоичной СС) запись. Значит изначальное число равнялось .
Ошибка.
Попробуйте повторить позже
Автомат Алиса-007 обрабатывает натуральное число N по следующему алгоритму:
1) Строится двоичная запись числа N.
2) Запись «переворачивается», то есть читается справа налево. Если при этом появляются ведущие нули, они отбрасываются.
3) Полученное число переводится в десятичную запись и выводится на экран. Какое наименьшее число, превышающее 765, после обработки автоматом даёт результат 23?
s = bin(i)[2::]
s = str(int(s[::-1]))
if int(s, 2) == 23:
print(i)
break
Ошибка.
Попробуйте повторить позже
На вход алгоритма подаётся натуральное число . Алгоритм строит по нему новое число следующим образом.
- Строится двоичная запись числа .
- К этой записи дописывается (дублируется) последняя цифра.
- Затем справа дописывается , если в двоичном коде числа чётное число единиц, и , если нечётное.
- К полученному результату справа дописывается , если количество единиц получившегося числа нечётно, иначе дописывается .
Полученная таким образом запись (в ней на три разряда больше, чем в записи исходного числа ) является двоичной записью искомого числа . Укажите минимальное число , после обработки которого автомат получает число, большее . В ответе это число запишите в десятичной системе.
for n in range(1, 1000): r = bin(n)[2:] r += r[-1] if bin(n)[2:].count(’1’) % 2 == 0: r += ’0’ else: r += ’1’ if r.count(’1’) % 2 == 0: r += ’0’ else: r += ’1’ if int(r, 2) > 120: print(n) break
Ошибка.
Попробуйте повторить позже
На вход алгоритма подаётся натуральное число . Алгоритм строит по нему новое число следующим образом.
- Строится двоичная запись числа .
- К этой записи справа дописывается единица.
- Затем справа дописывается бит чётности: , если в двоичном коде полученного числа чётное число единиц, и , если нечётное.
- К полученному результату дописывается ещё один бит чётности.
Полученная таким образом запись (в ней на три разряда больше, чем в записи исходного числа ) является двоичной записью искомого числа . Какое минимальное число , большее , может быть получено в результате работы автомата?
Решение программой:
for i in range(1, 1000000): s = bin(i)[2::] s += ’1’ if s.count(’1’) % 2 == 0: s += ’0’ else: s += ’1’ # второй if не нужен, потому что всегда будет дописываться 0 # подумайте почему) if s.count(’1’) % 2 == 0: s += ’0’ else: s += ’1’ if int(s, 2) > 212: print(int(s, 2)) break
Аналитическое решение:
Каким бы не было число, на втором шаге к нему всегда дописывается единица, так что давайте называть это число «изначальным».
Если изначальное число имеет чётное количество единиц, то после добавления нуля количество единиц не изменится, а потому на следующем шаге также добавится ноль. Итого к числу допишут два нуля.
Если изначально число имеет нечётное количество единиц, то после добавления единицы количество единиц увеличится на , что означает, что количество единиц станет чётным числом, а значит на следующем шаге уже будут добавлять ноль. Итого к числу допишут единицу и ноль.
Значит мы будем проверять только числа, которые кончаются на или .
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число ? В двоичной СС оно выглядит как . Так что вполне возможно. Если откинем последние три цифры, то у нас останется число , добавим к нему единицу и получим число , у него чётное число единиц, а значит после работы алгоритма к нему дописали бы два нуля, но мы откинули , а значит это не то число, которое нам нужно.
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число ? В двоичной СС оно выглядит как . Так что вполне возможно. Если откинем последние три цифры, то у нас останется число , добавим к нему единицу и получим число , у него нечётное число единиц, а значит после работы алгоритма к нему дописали бы единицу и ноль, но мы откинули , а значит это не то число, которое нам нужно.
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число ? В двоичной СС оно выглядит как . Так что вполне возможно. Если откинем последние три цифры, то у нас останется число , добавим к нему единицу и получим число , у него нечётное число единиц, а значит после работы алгоритма к нему дописали бы единицу и ноль, а мы откинули как раз , значит – это интересующее нас число.
Ошибка.
Попробуйте повторить позже
Автомат обрабатывает натуральное число по следующему алгоритму:
- Строится двоичная запись числа .
- В конец двоичной записи добавляются две цифры: — если четное, — если нечетное.
- Результат переводится в десятичную систему, затем от числа отнимается минимальное количество бит, которым можно закодировать чисел.
- Полученное число выводится на экран.
Пример. Дано число Алгоритм работает следующим образом:
- Двоичная запись числа
- В конец добавляются цифры , так как — четное число. Получается .
- Результат переводится в десятичную систему. . От отнимается число , так как это минимальное количество бит, которым можно закодировать чисел.
- На экран выводится 221.
Укажите минимальное , при котором автомат выведет на экран число .
for i in range(10000): s = bin(i)[2::] if i % 2 == 0: s += ’11’ else: s += ’00’ x = int(s, 2) - len(bin(i-1)[2::]) # n - натуральные # Например, n = 5 # 000 = 1; 001 = 2; 010 = 3; # 011 = 4; 100 = 5 if x == 126: print(i)
Ошибка.
Попробуйте повторить позже
На вход алгоритма "КХЪ" подаётся натуральное число Алгоритм строит по нему новое число следующим образом:
1. Строится двоичная запись числа
2. В конец двоичной записи дописываются две первые цифры этой записи в обратном порядке.
3. В начало двоичной записи дописывается единица.
4. Результат переводится в десятичную систему и выводится на экран.
Пример. Дано число Алгоритм работает следующим образом:
1. Двоичная запись числа .
2. В конец записи добавляются цифры – первые две цифры в обратном порядке (сначала вторая, затем первая), получается .
3. В начало записи добавляется цифра , получается .
4. На экран выводится число .
Полученная таким образом запись является искомым числом Укажите минимальное число которое превышает число и может являться результатом работы данного алгоритма. В ответе это число запишите в десятичной системе счисления.
s = bin(i)[2::]
s += s[1] + s[0]
s = ’1’ + s
if int(s, 2) > 50:
print(int(s, 2))
break
Ошибка.
Попробуйте повторить позже
Алгоритм получает на вход натуральное число и строит по нему новое число R следующим образом.
1) Число N переводим в двоичную запись.
2) К этой записи справа дописывается один разряд по следующему правилу: если количество единиц в двоичной записи числа больше количества нулей, то справа дописывается единица, иначе дописывается 0.
3) К полученной записи повторно применяется алгоритм из п.2.
Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа N) является двоичной записью искомого числа R.
Укажите наибольшее число R, меньшее 99, которое может быть получено в результате работы данного алгоритма. В ответе это число запишите в десятичной системе счисления.
for i in range(1, 1000): s = bin(i)[2::] if s.count(’1’) > s.count(’0’): s += ’1’ else: s += ’0’ if s.count(’1’) > s.count(’0’): s += ’1’ else: s += ’0’ if int(s, 2) < 99: print(int(s, 2))
Аналитическое решение:
Заметим, что алгоритм добавляет ту цифру, которых больше у числа (если количество равно, то добавляется нуль). Если у числа было какое-то количество нулей и какое-то количество единиц, то добавляя какую-то цифру, их количество только увеличивается, а значит и на следующем шаге добавят эту же цифру. Значит к числу добавят или .
Нам нужно найти наибольшее число , которое могли получить после работы данного алгоритма. Могло ли получиться число ? Нет, так как оно кончается на 10, а мы знаем, что такое число не могло получиться после этого алгоритма.
Могло ли получиться число ? Нет, так как оно кончается на 01, а мы знаем, что такое число не могло получиться после этого алгоритма.
Могло ли получиться число ? Такое число могло получиться после этого алгоритма, но давайте проверим какое число тогда было бы без добавленных нулей – если уберём два нуля, то получим число , количество нулей больше, чем количество единиц, а значит к такому числу после работы алгоритма действительно добавляются два нуля, а значит 96 это наибольшее , которое могли получить после работы алгоритма.
Ошибка.
Попробуйте повторить позже
На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом:
1)Строится двоичная запись числа N.
2)К этой записи дописываются справа ещё два разряда по следующему правилу:
а)Дописывается справа бит чётности: 0, если в двоичном коде числа N было чётное число единиц, и 1, если нечётное;
б)К полученному результату дописывается ещё один бит чётности
Полученная таким образом запись (в ней на два разряда больше, чем в записи исходного числа N) является двоичной записью искомого числа R.
Укажите минимальное число N, после обработки которого с помощью этого алгоритма получается число, большее, чем 78. В ответе это число запишите в десятичной системе.
for i in range(1, 1000): s = bin(i)[2::] if s.count(’1’) % 2 == 0: s += ’0’ else: s += ’1’ if s.count(’1’) % 2 == 0: s += ’0’ else: s += ’1’ if int(s, 2) > 78: print(i) break
Аналитическое решение:
Если изначальное число имеет чётное количество единиц, то после добавления нуля количество единиц не изменится, а потому на следующем шаге также добавится ноль. Итого к числу допишут два нуля.
Если изначально число имеет нечётное количество единиц, то после добавления единицы количество единиц увеличится на 1, что означает, что количество единиц станет чётным числом, а значит на следующем шаге уже будут добавлять ноль. Итого к числу допишут единицу и ноль.
Значит мы будем проверять только числа, которые кончаются на или .
Могло ли получиться число ? Нет, в двоичной СС оно выглядит как , а значит получиться после алгоритма не могло.
Могло ли получиться число 80? В двоичной СС оно выглядит как . Так что вполне возможно. Если откинем последние две цифры, то у нас останется число , у него чётное число единиц, а значит после работы алгоритма к нему дописали бы два нуля, но это как раз те самые цифры, которые мы откинули, значит и есть искомое число.
Ошибка.
Попробуйте повторить позже
Алгоритм получает на вход натуральное число и строит по нему новое число следующим образом:
- Строится двоичная запись числа .
- В конец записи (справа) дописывается вторая слева цифра двоичной записи.
- В конец записи (справа) дописывается вторая справа цифра двоичной записи числа .
- Результат переводится в десятичную систему.
Пример. Дано число . Алгоритм работает следующим образом:
- Двоичная запись числа .
- Вторая слева цифра , новая запись .
- Вторая справа цифра , новая запись .
- Результат работы алгоритма .
При каком наибольшем числе в результате работы алгоритма получится ? В ответе запишите это число в десятичной системе счисления.
ans = 0 for i in range(2, 1000): s = bin(i)[2::] x = s x += s[1] + s[-2] if int(x, 2) < 90: ans = i print(ans)
Ошибка.
Попробуйте повторить позже
Алгоритм получает на вход натуральное число и строит по нему новое число R следующим образом:
1. Строится двоичная запись числа .
2. Вместо последней (самой правой) двоичной цифры дважды записывается вторая слева цифра двоичной записи.
3. Результат переводится в десятичную систему.
Пример. Дано число . Алгоритм работает следующим образом:
1. Двоичная запись числа .
2. Вторая слева цифра , единица в конце записи заменяется на два нуля, новая запись .
3. Результат работы алгоритма .
При каком наименьшем числе в результате работы алгоритма получится ? В ответе запишите это число в десятичной системе счисления.
Решение №1
Переведем . Не совпадают.
Переведем . Не совпадают.
Переведем . Совпали. Обрубим последние цифры и припишем . .
Решение №2
for i in range(6, 1000): s = bin(i)[2::] s = s[:len(s) - 1] s += s[1] * 2 if int(s, 2) > 48: print(i) break