Напишите программу, которая проверяет, является ли целое число степенью 2.

Пример ввода:

8

Образец вывода:

Yes

Пример ввода:

10

Образец вывода:

No

Правила:

• Не используйте +, -операции.

• Используйте какой-нибудь поток ввода, чтобы получить число. Входные данные не должны изначально храниться в переменной.

• Самый короткий код (в байтах) выигрывает.

Вы можете использовать любой ответ «ложь / ложь» (например, true/ false). Вы можете предположить, что номер ввода больше, чем 0.

GolfScript, 6 символов, без уменьшений

~.3/&!

Вот решение, которое не использует x & (x-1)метод в любой форме. Он использует x & (x/3)вместо этого. ;-) Выводит, 0если false, 1если true.

Объяснение:

• ~ обнуляет входную строку, чтобы превратить ее в число,
• .дублирует его (для последующего &),
• 3/ делит его на три (обрезая),
• & вычисляет побитовое И деленного значения с оригиналом, которое будет равно нулю тогда и только тогда, когда входное значение равно нулю или степени два (т. е. установлен не более одного бита), и
• ! логически отрицает это, отображая ноль в одно, а все остальные значения в ноль.

Заметки:

• Согласно разъясненным правилам, ноль не является допустимым вводом , поэтому этот код в порядке, даже если он выводит, 1если ввод равен нулю.

• Если разрешен оператор декремента GolfScript (, то достаточно 5-символьного решения, ~.(&! размещенного aditsu . Однако, похоже, что это противоречит духу правил , если не букве.

• Я придумал эту x & (x/3)хитрость несколько лет назад в списке рассылки Fun With Perl. (Я уверен, что я не первый, кто обнаружил это, но я (заново) изобрел его самостоятельно.) Вот ссылка на оригинальный пост , включая доказательство того, что он действительно работает.

APL (7)

Да, это 7 байтов . Предположим на данный момент, что я использую кодовую страницу IBM 907 вместо Unicode, и тогда каждый символ является байтом :)

0=1|2⍟⎕

т.е. 0 = mod(log(input(),2),1)

GolfScript, 11 (для 1 (true) и 0 (false))

.,{2\?}%?0>

Поместите число в стек и затем бегите.

GolfScript, 22 (для Да / Нет)

.,{2\?}%?0>'Yes''No'if

Мне нравится, как преобразование 1/ 0в Yes/ Noзанимает столько же кода, сколько и сам вызов: D

Предупреждение: ЧРЕЗВЫЧАЙНО неэффективно;) Он отлично работает для чисел до 10000, но как только вы достигнете такого высокого уровня, вы начнете замечать небольшое отставание.

Объяснение:

• .,: превращается nв n 0..n( .дубликат, ,диапазон 0..n)
• {2\?}: к силе 2
• %: отобразить "мощность 2" на "0..n", чтобы оно стало n [1 2 4 8 16 ...]
• ?0>: проверяет, содержит ли массив число (0 больше индекса)

Mathematica 28

Numerator[Input[]~Log~2]==1

Для целых степеней 2, числитель логарифма с основанием 2 будет 1 (это означает, что логарифм является дробной единицей).

Здесь мы немного изменим функцию, чтобы отобразить предполагаемый ввод. Мы используем #вместо Input[]и добавить, &чтобы определить чистую функцию. Он возвращает тот же ответ, который будет возвращен, если пользователь введет число в вышеуказанной функции.

    Numerator[#~Log~2] == 1 &[1024]
    Numerator[#~Log~2] == 1 &[17]

Правда
ложь

Тестирование нескольких номеров одновременно.

    Numerator[#~Log~2] == 1 &&/@{64,8,7,0}

{True, True, False, False}

Perl 6 (17 символов)

say get.log(2)%%1

Эта программа получает строку из getфункции STDIN , вычисляет логарифм с основанием 2 на нем ( log(2)) и проверяет, делится ли результат на 1 ( %%1где %%делится на оператор). Не так коротко, как решение GolfScript, но я нахожу это приемлемым (GolfScript все равно выигрывает), но намного быстрее (даже учитывая, что Perl 6 сейчас медленный).

~ $ perl6 -e 'say get.log(2)%%1'
256
True
~ $ perl6 -e 'say get.log(2)%%1'
255
False

Октава ( 15 23)

РЕДАКТИРОВАТЬ: Обновлено из-за требования ввода пользователя;

~mod(log2(input('')),1)

Позволяет пользователю ввести значение и вывести 1 для true, 0 для false.

Протестировано в Octave, должно работать и в Matlab.

Р, 13 11

Основано на решении Perl. Возвращает FALSEили TRUE.

!log2(i)%%1

Параметр iпредставляет входную переменную.

Альтернативная версия с пользовательским вводом:

!log2(scan())%%1

GolfScript, 5

Выходы 1 для истины, 0 для ложных. Основано на идее user3142747:

~.(&!

Примечание: (это декремент, надеюсь, он не считается как -:).
Если это так (и комментарии ОП предполагают, что это возможно), пожалуйста, обратитесь к решению Илмари Каронена .
Для вывода Y / N добавьте 'NY'1/=в конце (еще 7 байтов).

Python, 31

print 3>bin(input()).rfind('1')

С, 48

main(x){scanf("%i",&x);puts(x&~(x*~0)?"F":"T");}

Я решил использовать другой подход, основанный на подсчете численности населения или поперечной сумме числа (число 1-бит). Идея состоит в том, что все степени двух имеют ровно один 1бит, а никакое другое число не имеет. Я добавил версию JavaScript, потому что нашел ее забавной, хотя она, безусловно, не выиграет ни одного соревнования по гольфу.

J, 14 15 символов (выходы 0 или 1)

1=##~#:".1!:1]1

JavaScript, 76 символов (выводит true или false)

alert((~~prompt()).toString(2).split("").map(Number).filter(Boolean).length)

Зажим , 9 8 7

!%lnxWO

Читает число из стандартного ввода.

Объяснение:

Начнем с, Z= 0, W= 2и O= 1. Это позволяет размещать Wи Oрядом друг с другом, тогда как использование 2и 1будет интерпретироваться как число 21 без разделительного пробела (нежелательный дополнительный символ). В Clip функция modulo ( %) работает vс нецелыми числами, поэтому, чтобы определить, является ли какое-либо значение целым числом, вы проверяете, является ли vmod 1 = 0. Используя синтаксис Clip, это записывается как =0%v1. Тем не менее, поскольку булевы значения хранятся как 1(или что-то еще), и 0проверка, что-то равно, 0просто «не» это. Для этого у Клипа есть !оператор. В моем коде vесть lnx2. xэто вход от стандартного ввода,nпреобразует строку в число и labявляется основой bжурнала a. Программа поэтому переводит (более читабельно) в 0 = ((log base 2 of parseInt(readLine)) mod 1).

Примеры:

8

выходы

1

а также

10

выходы

0

Редактировать 1: заменить 0, 1и 2с Z, Oи W.

Изменить 2: заменено =Zна !.

Также:

Пиф , 5

Сжимает версию Clip еще больше, так как Pyth имеет Q для уже оцененного ввода и функцию log2 (a) вместо обычного log (a, b).

!%lQ1

Javascript (37)

a=prompt();while(a>1)a/=2;alert(a==1)

Простой скрипт, который просто делит на 2 несколько раз и проверяет остаток.

Математика (21)

IntegerQ@Log2@Input[]

Без ввода это немного короче

IntegerQ@Log2[8]

Правда

IntegerQ@Log2[7]

Ложь

JavaScript, 41 40 символов

l=Math.log;alert(l(prompt())/l(2)%1==0);

Как это работает: вы берете логарифм по основанию 2, используя l(prompt()) / l(2), и если этот результат по модулю 1 равен нулю, то это степень 2.

Например: взяв логарифм 8 на основе 2, вы получите 3. 3 modulo 1равно 0, так что это возвращает истину.

Взяв логарифм 7 на основании 2, вы получите 2.807354922057604. 2.807354922057604 modulo 1равно 0.807354922057604, так что это возвращает ложь.

JavaScript, 35

Работает на байты.

alert((+prompt()).toString(2)%9==1)

46-символьная версия , работает для 16-битных чисел.

x=(+prompt()).toString(2)%99;alert(x==1|x==10)

Трюк работает в большинстве динамических языков.

Объяснение: Преобразовать число в основание 2, интерпретировать эту строку как основание 10, выполнить по модулю 9, чтобы получить сумму цифр, которая должна быть 1.

Perl 5.10+, 13 + 1 = 14 символов

say!($_&$_/3)

Использует тот же метод из старого потока FWP, что и моя запись GolfScript . Печатает, 1если на входе есть степень двойки, а в противном случае - пустая строка.

Нужно бежать с perl -nE; n стоит один дополнительный символ , в общей сложности 14 символов. Кроме того, вот 18-символьная версия, которая не нуждается в n:

say!(($_=<>)&$_/3)

питон 3, 38

print(1==bin(int(input())).count('1'))

питон, 32

Тем не менее, код не работает в каждой версии.

print 1==bin(input()).count('1')

Обратите внимание, что решение работает и для 0 (выведите False).

Рубин - 17 символов (четвертая попытка)

p /.1/!~'%b'%gets

Мой лучший результат - это слияние ответа @ steenslag с моим собственным. Ниже приведены мои предыдущие попытки.

Рубин - 19 символов (третья попытка)

p /10*1/!~'%b'%gets

Рубин - 22 символа (вторая попытка)

p !('%b'%gets)[/10*1/]

Рубин - 24 символа (первая попытка)

p !!('%b'%gets=~/^10*$/)

К / Кона ( 24 17)

d:{(+/(2_vs x))~1

Возвращает 1, если истина, и 0, если ложь. Любая степень 2 имеет один бит, равный 1:

2_vs'_(2^'(!10))
(,1
1 0
1 0 0
1 0 0 0
1 0 0 0 0
1 0 0 0 0 0
1 0 0 0 0 0 0
1 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0)

(это распечатывает все степени 2 (от 0 до 9) в двоичном виде)

Итак, я суммирую все компоненты двоичного выражения xи посмотрим, равно ли оно 1; если да, то x=2^nнет.

... знал, что могу сделать его меньше

C # (54 символа)

 Math.Log(int.Parse(Console.ReadLine()),2)%1==0?"Y":"N"

Ребму (9 символов)

z?MOl2A 1

Тест

>> rebmu/args [z?MOl2A 1] 7
== false

>> rebmu/args [z?MOl2A 1] 8 
== true

>> rebmu/args [z?MOl2A 1] 9 
== false

Rebmu - сжатый диалект Rebol. Код по сути:

z? mo l2 a 1  ; zero? mod log-2 input 1

альтернатива

14 символов - у Ребму нет разбитого по кусочкам И ~

z?AND~aTIddA 3

В Реболе:

zero? a & to-integer a / 3

GTB , 46 байт

2→P`N[@N=Pg;1P^2→P@P>1E90g;2]l;2~"NO"&l;1"YES"

Python, 35

print bin(input()).strip('0')=='b1'

Не использует не только +/- операции, но и любые математические операции, кроме преобразования в двоичную форму.

Другие вещи (интересные, но не для конкурса):

У меня также есть версия регулярного выражения (61) :

import re;print re.match(r'^0b10+$',bin(input())) is not None

(Идея нравится, но функция импорта и сопоставления делает ее слишком длинной)

И хорошая, но скучная битовая версия операций (31) :

x=input();print x and not x&~-x

(да, он короче, но для декремента используется ~ -x - операция)

Python 2,7 ( 30 29 39 37)

РЕДАКТИРОВАТЬ: Обновлено из-за требования ввода пользователя;

a=input()
while a>1:a/=2.
print a==1

Грубая сила, попробуйте разделить до = 1 (успех) или <1 (неудача)

Python (33)

print int(bin(input())[3:]or 0)<1

Руби, 33 , 28 , 25

p /.1/!~gets.to_i.to_s(2)

APL (12 для 0/1, 27 для да / нет)

≠/A=2*0,ιA←⍞ 

или, если мы должны вывести текст:

3↑(3x≠/A=2*0,ιA←⍞)↓'YESNO '

Прочитайте в A. Сформируйте вектор 0..A, затем вектор 2 ⁰ ..2 ^A (да, это намного больше, чем необходимо), затем вектор, сравнивающий A с каждым из них (в результате получается вектор из 0 и самое большее один 1), затем xor это (в APL нет оператора xor, но ≠, примененный к логическим значениям, будет действовать как единое целое.) Теперь у нас есть 0 или 1.

Чтобы получить ДА или НЕТ: умножьте 0 или 1 на 3, отбросьте это количество символов из «ДА», а затем возьмите первые 3 символа.

C 65 байт

main(k){scanf("%i",&k);while(k&&!(k%2))k/=2;puts(k==1?"T":"F");}

Хаскелл ( 52 50)

k n=elem n$map(2^)[1..n]
main=interact$show.k.read