Завдання:

З огляду на ціле число, з’ясуйте, чи є це число Циклопів.

Ви можете запитати число циклопів? Ну, це число, бінарне представлення якого лише одне 0в центрі!

Випробування:

Input | Output | Binary  | Explanation
--------------------------------------
0     | truthy | 0       | only one zero at "center"
1     | falsy  | 1       | contains no zeroes
5     | truthy | 101     | only one zero at center
9     | falsy  | 1001    | contains two zeroes (even though both are at the center)
10    | falsy  | 1010    | contains two zeroes
27    | truthy | 11011   | only one zero at center
85    | falsy  | 1010101 | contains three zeroes
101   | falsy  | 1100101 | contains three zeroes
111   | falsy  | 1101111 | only one zero, not at center
119   | truthy | 1110111 | only one zero at center

Вхід:

• Цілі чи еквівалентні типи. ( int, long, decimalІ т.д.)

• Припустимо, що якщо оцінка вхідних даних призводить до переповнення цілого чи інших небажаних проблем, тоді цей вхід не повинен оцінюватися.

Вихід:

• Істинна чи фальшива.

• Програма Truthy / Falsy повинна відповідати специфікаціям використовуваної мови для truthy / falsy. (наприклад, C має 0помилковий, ненульовий, як істинний)

Правила виклику:

• Вхідні дані, менші за 0, вважаються помилковими, і тому їх не потрібно оцінювати.

• Якщо довжина двійкового представлення числа є парною, то число не може бути числом Циклопа.

Загальні правила:

• Це код-гольф , тому найкоротший відповідь у байтах виграє !.

• Бійниці за замовчуванням заборонені.

• Для вашої відповіді застосовуються стандартні правила з типовими правилами вводу / виводу .

Це моя перша головоломка з програмуванням та кодом для гольфу , тому будь-які відгуки про те, як я повинен покращити, будуть дуже вдячні!

Japt, 8 байт

1¥¢q0 äè

Запустити його в Інтернеті

Пояснення:

1¥¢q0 äè   
                                                              119
  ¢          // Convert the input into a binary string        "1110111"
   q0        // Split the string on "0"                       ["111","111"]
      ä      // Reduce each item by:                            a     b
       è     //   Seeing how many times a is found in b       [1]
 1¥          // == 1; See if the result equals 1              True                                         

Ідея полягає в тому, щоб розділити двійковий рядок на 0, що дасть два елементи, якщо є лише один 0. Потім ми бачимо, чи відповідає перший елемент другому, щоб переконатися, що він паліндромний. Якщо двійковий рядок містить декілька 0s, то зменшення поверне багатошаровий масив, і це призведе до відмови ==1умови. Якщо двійковий рядок містить один 0, але не паліндромний, äèповернеться, 0оскільки bмістить 0відповідність a.

Python 2 , 30 байт

lambda n:(2*n^2*n+3)**2==8*n+9

Спробуйте в Інтернеті!

Зауважте, що 2*n^2*n+3це побітове значення xor 2*nі 2*n+3, тому що це пріоритет оператора Python.

машинний код x86, 17 байт

8D 47 01 31 F8 89 C2 F7 D2 0F AF C2 8D 44 78 02 C3

Вищеописані байти визначають функцію, яка приймає 32-бітне ціле вхідне значення (у EDIреєстрі для цього прикладу, дотримуючись загальної конвенції про виклик System V, але ви фактично можете вибрати майже будь-який вхідний регістр, який ви хотіли, не впливаючи на розмір отриманого код) і повертає результат (у EAXреєстрі), вказуючи, чи є вхідним значенням число Циклопа.

Вхід вважається цілим числом, яке не підписується, оскільки правила виклику вказують, що ми можемо ігнорувати негативні значення.

$n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$

Примітка: значення повернення є truthy / false, але семантика є зворотною, так що функція поверне помилкове число Циклопа. Я стверджую, що це законно, оскільки машинний код не має "специфікацій на truthy / falesy", що є вимогою у питанні. (Дивіться нижче про альтернативну версію, якщо ви думаєте, що це обман.)

У монемології мовної збірки це:

; EDI = input value
; EAX = output value (0 == Cyclops number)
8D 47 01           lea    eax, [edi + 1]          ; \ EAX = ((EDI + 1) ^ EDI)
31 F8              xor    eax, edi                ; /
89 C2              mov    edx, eax                ; \ EDX = ~EAX
F7 D2              not    edx                     ; /
0F AF C2           imul   eax, edx                ; EAX *= EDX
8D 44 78 02        lea    eax, [eax + edi*2 + 2]  ; EAX  = (EAX + (EDI * 2) + 2)
C3                 ret                            ; return, with EAX == 0 for Cyclops number

Спробуйте в Інтернеті!

Як було пообіцяно, якщо ви вважаєте, що це обман перевернути семантику truthy / falesy навіть у машинному коді, де немає реальних стандартів чи умов, тоді додайте ще три байти, загалом 21 байт :

; EDI = input value
; AL  = output value (1 == Cyclops number)
8D 47 01           lea    eax, [edi + 1]          ; \ EAX = ((EDI + 1) ^ EDI)
31 F8              xor    eax, edi                ; /
89 C2              mov    edx, eax                ; \ EDX = ~EAX
F7 D2              not    edx                     ; /
0F AF C2           imul   eax, edx                ; EAX *= EDX
8D 44 78 01        lea    eax, [eax + edi*2 + 1]  ; EAX  = (EAX + (EDI * 2) + 1)
40                 inc    eax                     ; EAX += 1
0F 94 C0           setz   al                      ; AL = ((EAX == 0) ? 1 : 0)
C3                 ret                            ; return, with AL == 1 for Cyclops number

Перша половина цього коду така сама, як оригінал (вниз через imulінструкцію). Це leaмайже те саме, але замість того, щоб додавати константу 2, вона додає лише константу 1. Це тому, що наступна incінструкція збільшує значення в EAXрегістрі на 1, щоб встановити прапори. Якщо встановлено прапор "нуль", setzінструкція встановить ALзначення 1; в іншому випадку ALбуде встановлено 0. Це стандартний спосіб, коли компілятор C генерує машинний код для повернення bool.

Зміна константи, доданої в leaінструкції, очевидно, не змінює розмір коду, і incінструкція дуже мала (всього 1 байт), але setzінструкція - це досить колосальні 3 байти. На жаль, я не можу придумати жоден коротший спосіб його написання.

Regex (ECMAScript), 60 58 57 60 58 байт

$n$x

ПОПЕРЕДЖЕННЯ СПОЙЛЕРА : Для квадратного кореня цей регекс використовує варіант узагальненого алгоритму множення, який не є очевидним і може стати корисною головоломкою для розробки самостійно. Для отримання додаткової інформації дивіться пояснення цієї форми алгоритму в « Знайти число Рокко» .

$z$
$z$

$z$$n=2(n-z)+\sqrt{z}+1$$n$

^(x*)(?!(x(xx)+)\2*$)(x(x*))(?=(?=(\4*)\5+$)\4*$\6)x\1$|^$

Спробуйте в Інтернеті!

^                 # N = tail
(x*)              # tail = Z, with the smallest value that satisfies the following
                  # assertions (which is no different from the largest value that
                  # would satisfy them, since no more than one value can do so);
                  # \1 = N - Z

(?!(x(xx)+)\2*$)  # Assert Z is a power of 2

# Assert Z is a perfect square, and take its square root
(x(x*))           # \4 = square root of Z; \5 = \4 - 1; tail = N - \1 - \4
(?=(\4*)\5+$)     # iff \4*\4 == Z, then the first match here must result in \6==0
(?=\4*$\6)        # test for divisibility by \4 and for \6==0 simultaneously

# Assert that N == \1*2 + \4 + 1. If this fails, then due to a golf optimization,
# the regex engine will backtrack into the capturing of \4, and try all smaller
# values to see if they are the square root of Z; all of these smaller values will
# fail, because the \4*\4==Z multiplication test only matches for one unique value
# of \4.
x\1$

|^$               # Match N==0, because the above algorithm does not

JavaScript (Node.js) , 20 байт

p=>~p==(p^=p+1)*~p/2

Спробуйте в Інтернеті!

Може, це правильно, можливо.

Дякую Гримі, 1 байт збережено.

JavaScript (Node.js) , 32 байти

f=(p,q)=>p&1?f(p/2,q+q|2):!(p^q)

Спробуйте в Інтернеті!

JavaScript (Node.js) , 34 байти

p=>/^(1*)0\1$/.test(p.toString(2))

Спробуйте в Інтернеті!

Perl 6 , 23 байти

{.base(2)~~/^(1*)0$0$/}

Спробуйте в Інтернеті!

Розчин на основі Regex

Japt , 25 19 10 9 байт

¢êÅ©1¶¢èT

Завдяки @Shaggy за -1 байт

Спробуйте в Інтернеті!

Математика (мова Вольфрама), 32 31 байт

1 байт збережено завдяки J42161217!

OddQ@Log2[#+Floor@Sqrt[#/2]+2]&

Спробуйте в Інтернеті!

Чиста функція, приймаючи ціле число в якості введення та повернення Trueабо False. Виходячи з того , (цікаво довести!) , Що число nє Циклоп тоді і тільки тоді , коли nплюс квадратний корінь n/2плюс 2раундів аж до непарного степеня 2. (можна замінити Floorабо Ceilingабо до Roundтих пір, один і замінює +2на +1.) Повертається Trueпри введенні 0.

Рубін , 24 байти

->x{x+x+2==(1+x^=x+1)*x}

Спробуйте в Інтернеті!

Japt, 8 байт

¢ðT ¥¢Êz

Дякую Луїсу Феліпе де Ісусу Муносу за те, що він виправив моє подання!

Спробуйте в Інтернеті!

Старий розчин на основі регулярних виразів, 15 байт

¤f/^(1*)0\1$/ l

Повертає 1 для істинного, 0 для помилкового.

Спробуйте в Інтернеті!

Желе ,  8  7 байт

-1 завдяки Еріку Поверху (використовуйте вбудований IsPalindrome ŒḂ, а не ⁼Ṛ$)

B¬ŒḂ⁼SƊ

Монадична посилання, що приймає ціле число, яке дає 1(тритух) або 0(фальси).

Спробуйте в Інтернеті!

Як?

B¬ŒḂ⁼SƊ - Link: integer             e.g. 1    9          13         119
B       - to base 2                      [1]  [1,0,0,1]  [1,1,0,1]  [1,1,1,0,1,1,1]
 ¬      - logical NOT (vectorises)       [0]  [0,1,1,0]  [0,0,1,0]  [0,0,0,1,0,0,0]
      Ɗ - last three links as a monad:
  ŒḂ    -   is a palindrome?             1    1          0          1
     S  -   sum                          0    2          1          1
    ⁼   -   equal?                       0    0          0          1

Haskell , 32 байти

f n=or[2*4^k-2^k-1==n|k<-[0..n]]

Спробуйте в Інтернеті!

Regex (ECMAScript), 53 47 байт

-6 байт завдяки Deadcode та Grimy

^((?=(x*?)(\2((x+)x(?=\5$))+x$))(?!\2{6})\3x)*$

Спробуйте в Інтернеті!

Брахілог , 8 байт

ḃD↔Dḍ×ᵐ≠

Це предикат, який досягає успіху, якщо його вхід є числом Циклопа, і невдалий, якщо його вхід не є числом Циклопа. Успіх / невдача - найважливіша концепція "truthy / falsey" у Брахілозі.

Спробуйте в Інтернеті! Або знайдіть усі надійні виводи до 10000 .

Пояснення

          Input is an integer
ḃ         Get its binary representation, a list of 1's and 0's
 D        Call that list D
  ↔       When reversed...
   D      It's the same value D
    ḍ     Dichotomize: break the list into two halves
          One of these halves should be all 1's; the other should contain the 0
     ×ᵐ   Get the product of each half
       ≠  Verify that the two products are not equal

Це досягається лише тоді, коли дається число Циклопа, оскільки:

• Якщо двійкове представлення не є паліндром, D↔Dбуде невдалим; далі ми можемо припустити, що це паліндром.
• Якщо більше одного нуля, обидві половини будуть містити щонайменше один нуль. Тож продукти будуть як нульовими, так і ×ᵐ≠виходять з ладу.
• Якщо немає нуля, обидві половинки будуть містити лише одну. Тож і продукти, і те, і інше, і ×ᵐ≠провалюються.
• Це залишає випадок, коли рівно один нуль; оскільки ми вже знаємо, що у нас є паліндром, це має бути центральним шматочком. Він з’явиться в одній половині, внаслідок чого продукт цієї половини буде нульовим; друга половина буде містити всі, тому її продукт буде одним. Тоді ми маємо 1 ≠ 0, ×ᵐ≠вдається, і весь предикат успішний.

Рубін , 27 24 байти

Перетворити на бінарне та перевірити за допомогою регулярного вираження. Повертає значення 0true, nilякщо false.

-3 байти завдяки ГБ .

->n{"%b"%n=~/^(1*)0\1$/}

Спробуйте в Інтернеті!

Ще на два байти є прямий порт рішення Python:

->n{(2*n^2*n+3)**2==8*n+9}

05AB1E , 8 (або 9) байт

bD0¢sÂQ*

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Повертається, 1якщо правда; 0або будь-яке додатне ціле число, окрім 1як фальси. У 05AB1E 1є лише правда, а все інше - фальси, але я не впевнений, чи це дозволений вихід, чи якщо вихід повинен мати два послідовних та унікальних значення. Якщо другий, Θможе бути доданий трейлінг, щоб усі виходи, крім того, 1стали 0:

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

b     # Convert the (implicit) input-integer to a binary-string
 D    # Duplicate it
  0¢  # Count the amount of 0s
 s    # Swap to get the binary again
  ÂQ  # Check if it's a palindrome
 *    # Multiply both (and output implicitly)

  Θ   # Optionally: check if this is truthy (==1),
      # resulting in truthy (1) or falsey (0)

Арифметичний підхід складе 10 байт:

LoD<s·>*Iå

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

$a(n) = (2^n-1)*(2*2^n+1)$

L        # Create a list in the range [1, (implicit) input-integer]
 o       # For each integer in the list, take 2 to the power this integer
  D<     # Create a copy, and decrease each value by 1
  s·     # Get the copied list again, and double each value
    >    # Then increase each value by 1
  *      # Multiply the numbers at the same indices in both lists
     Iå  # Check if the input-integer is in this list
         # (and output the result implicitly)

Excel, 97 63 байт

=A1=2*4^(ROUND(LOG(A1,4),0))-2^(ROUND(LOG(A1,4),0))-1

Обчислює 2 числа:

Двічі найближча сила 4
>Num|Binary|2*Power4|Binary
> 1| 1| 2* 1= 2| 10
> 2| 10| 2* 4= 8| 1000
> 4| 100| 2* 4= 8| 1000
> 20| 10100| 2*16=32|100000

1 Плюс квадратний корінь найближчої сили 4
>Num|Binary|1+√Power4|Binary
> 1| 1|1+ √1= 2| 10
> 2| 10|1+ √4= 3| 11
> 4| 100|1+ √4= 3| 11
> 20| 10100|1+ √16= 5| 101

Потім відніміть друге число від першого:

>Num|Binary|2*Power4|Binary|1+√Power4|Binary|a-b|Binary
> 1| 1| 2* 1= 2| 10|1+ √1= 2| 10| 0| 0
> 2| 10| 2* 4= 8| 1000|1+ √4= 3| 11| 5| 101
> 4| 100| 2* 4= 8| 1000|1+ √4= 3| 11| 5| 101
> 20| 10100| 2*16=32|100000|1+ √16= 5| 101| 27| 11011

І порівняйте цей результат з початковим числом

Старий метод

=DEC2BIN(A1)=REPLACE(REPT("1",1+2*INT(IFERROR(LOG(A1,2),0)/2)),1+IFERROR(LOG(A1,2),0)/2,1,"0")

Почніть з Log-base-2 з A1 і округляйте її до найближчого парного числа, а потім додайте 1.

Далі створіть рядок такої кількості "1"s, а середній символ замініть на a, "0"щоб створити число Циклопа з двійковою довжиною, яка завжди непарна, та ж, що або на 1 менше, ніж двійкова довжина A1

Потім порівняйте його з Бінарним поданням А1

R , 37 33 байт

(x=scan())%in%(2*4^(n=0:x)-2^n-1)

Спробуйте в Інтернеті!

R не має вбудованого для перетворення на бінарне, тому я просто використав одну з формул OEIS для обчислення списку термінів із послідовності.

n<-0:xстворює щедрий список вихідних значень. 2*4^(n<-0:x^2)-2^n-1)це формула від OEIS, а потім вона перевіряє, чи відображається вхід у цій послідовності, використовуючи %in%.

-2 байти, не обробляючи негативні входи. -2 байта, згадуючи , я можу змінити , <-щоб =.

C (gcc), 26 байт

f(n){n=~n==(n^=-~n)*~n/2;}

Спробуйте в Інтернеті!

Відповідь Порта Ніла . Покладається на визначене впровадженням упорядкування операцій.

C ++ (кланг), 38 байт

int f(int n){return~n==(n^=-~n)*~n/2;}

Спробуйте в Інтернеті!

Неможливо опустити типи в C ++, не можу опустити повернення в кланге, інакше ідентичне.

C (gcc) ,  29 28  27 байт

Збережено 1 байт завдяки @ceilingcat

Порт 21-байтової відповіді JS від @tsh .

f(p){p=2*~p==~(p=-~p^p)*p;}

Спробуйте в Інтернеті!

J , 22 19 17 15 14 байт

-3 байти завдяки BolceBussiere!

-4 байти завдяки ngn!

-1 байт завдяки Traws!

J , 14 байт

1=1#.(*:|.)@#:

Спробуйте в Інтернеті!

Желе , 9 байт

BŒḂaB¬S=1

Спробуйте в Інтернеті!

Attache , 22 байти

{Flip@_=_∧1=0~_}@Bin

Спробуйте в Інтернеті!

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

27 байт: {BitXor[2*_,2*_+3]^2=8*_+9}

27 байт: {BitXor@@(2*_+0'3)^2=8*_+9}

27 байт: {Palindromic@_∧1=0~_}@Bin

28 байт: {BitXor[...2*_+0'3]^2=8*_+9}

28 байт: {BitXor[…2*_+0'3]^2=8*_+9}

28 байт: {Same@@Bisect@_∧1=0~_}@Bin

29 байт: {_[#_/2|Floor]=0∧1=0~_}@Bin

30 байт: Same@Bin@{_+2^Floor[Log2@_/2]}

30 байт: {_[#_/2|Floor]=0and 1=0~_}@Bin

Сітківка 0,8.2 , 38 37 байт

.+
$*
+`^(1+)\1
$+0
10
1
^((1+)0\2)?$

Спробуйте в Інтернеті! Посилання включає тестові випадки. Редагувати: Після уточнення попереднє рішення неправильно обробляло нуль. Пояснення:

.+
$*

Перетворити з десяткової в одинарну.

+`^(1+)\1
$+0
10
1

Перетворити з унарного на бінарне, використовуючи метод із вікі Retina.

^((1+)0\2)?$

Перевірте наявність однакової кількості 1s до і після 0, або порожній рядок (саме так, як описано вище перетворення обробляє нуль).

Пакетна, 39 37 байт

@cmd/cset/a"m=%1^-~%1,!(m/2*(m+2)-%1)

$n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$$m = 2 ^ k - 1$$n = \lfloor \frac m 2 \rfloor ( m + 2 )$$n$

Excel, 101 107 байт

-6 байт завдяки @Chronocidal.

=AND(ISEVEN(LOG(A1,2)),MID(DEC2BIN(A1),LEN(DEC2BIN(A1))/2+1,1)="0",LEN(SUBSTITUTE(DEC2BIN(A1),1,))=1)

Виконує 3 перевірки:

• Непарна довжина

ISEVEN(LOG(A1,2))

• Середній характер є 0

MID(DEC2BIN(A1),LEN(DEC2BIN(A1))/2+1,1)="0"

• Є єдиний 0

LEN(SUBSTITUTE(DEC2BIN(A1),1,))=1

Regex (ECMAScript), 65 59 57 58 байт

+1 байт, щоб правильно обробити 0

^((((x*)xx)\3)x)?(?=(\1*)\2*(?=\4$)((x*)(?=\7$)x)*$)\1*$\5

Спробуйте в Інтернеті!

$(2^k - 1) (2^{k+1} + 1)$

VBA, 41 36 байт

x=2^Int([Log(A1,4)]):?[A1]=2*x^2-x-1

Запустіть у вікні «Негайне», виразну декларацію вимкнено. Вхід - клітинка A1активного аркуша. Виводить True / False до прямого вікна.

Використовує ту ж логіку, що і в моєму відповіді Excel, щоб знайти число Циклопів з однаковою кількістю біт (або на 1 біт коротше, якщо є парне число!), А потім порівнює цю інформацію з вхідним.

Зберігає деякі байти під час обчислення чисел Циклопа, зменшуючи їх до форми y = 2x^2 - x - 1(де x = n-1для n-го числа Циклопа, або x = 2^Int(Log([A1])/Log(4))щоб знайти найбільше число Циклопів із меншою або рівною кількістю біт) і зберігання x у змінній

(-5 байт завдяки Тейлору Скотту !)

PHP , 74 байти

function($x){return($c=strlen($a=decbin($x)))&1&&trim($a,1)===$a[$c/2|0];}

Спробуйте в Інтернеті!

Зовсім наївний нематематичний підхід, просто струни.

function cyclops( $x ) {
    $b = decbin( $x );     // convert to binary string (non-zero left padded)
    $l = strlen( $b );     // length of binary string
    $t = trim( $b, 1 );    // remove all 1's on either side
    $m = $b[ $l / 2 |0 ];  // get the middle "bit" of the binary string
    return 
        $l & 1 &&          // is binary string an odd length?
        $t === $m;         // is the middle char of the binary string the same as
                           // the string with left and right 1's removed? (can only be '0')
}

Або 60 байт на основі алгоритму @ Chronocidal вище .

function($x){return decbin($x)==str_pad(0,log($x,2)|1,1,2);}

Спробуйте в Інтернеті!

Хаскелл, 82 байти

import Text.Printf
(`all`[(==)<*>reverse,("0"==).filter(<'1')]).flip($).printf"%b"

І порт рішення Python xnor:

Haskell, 47 байт

import Data.Bits
\n->(2*n`xor`(2*n+3))^2==8*n+9