Compito:

Dato un input intero, capire se si tratta o meno di un numero di ciclopi.

Cos'è un numero Cyclops, potresti chiedere? Bene, è un numero la cui rappresentazione binaria ne ha solo una 0al centro!

Casi test:

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

Ingresso:

• Un numero intero o tipi equivalenti. ( int, long, decimal, Etc.)

• Supponiamo che se la valutazione dell'input comporta un overflow di numeri interi o altri problemi indesiderati, quell'input non deve essere valutato.

Produzione:

• Verità o falsità.

• L'output di verità / falsità deve soddisfare le specifiche del linguaggio usato per verità / falsità. (ad es. C ha 0falso, diverso da zero come vero)

Regole della sfida:

• Si presuppone che un input inferiore a 0 sia falso e quindi non debba essere valutato.

• Se la lunghezza della rappresentazione binaria del numero è pari, il numero non può essere un numero Cyclope.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte !.

• Sono vietate le scappatoie predefinite .

• Le regole standard si applicano alla risposta con le regole I / O predefinite .

Questa è la mia prima sfida di programmazione di puzzle e code golf , quindi qualsiasi feedback su come dovrei migliorare sarebbe molto apprezzato!

Japt, 8 byte

1¥¢q0 äè

Eseguilo online

Spiegazione:

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                                         

L'idea è di dividere la stringa binaria in 0, che produrrebbe due elementi se ce n'è solo uno 0. Quindi vediamo se il primo elemento corrisponde al secondo per garantire che sia palindromico. Se la stringa binaria contiene più 0s, allora la riduzione restituirebbe un array multi-item e ciò non riuscirebbe a ==1soddisfare la condizione. Se la stringa binaria ne contiene una 0, ma non è palindromica, äèverrà restituita 0perché bcontiene 0corrispondenze di a.

Python 2 , 30 byte

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

Provalo online!

Nota che 2*n^2*n+3è il xor bit per bit di 2*ne 2*n+3, poiché questa è la precedenza dell'operatore di Python.

Codice macchina x86, 17 byte

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

I byte precedenti definiscono una funzione che accetta un valore di input intero a 32 bit (nel EDIregistro per questo esempio, seguendo una convenzione di chiamata System V comune, ma in realtà è possibile selezionare praticamente qualsiasi registro di input desiderato senza influire sulla dimensione del risultato codice) e restituisce un risultato (nel EAXregistro) che indica se il valore di input è un numero Cyclops.

Si presume che l'input sia un numero intero senza segno, poiché le regole della sfida indicano che possiamo ignorare i valori negativi.

La logica decisionale è presa in prestito dalla risposta di Neil : poiché un numero di Ciclope ha la forma , possiamo usare una serie di operazioni di bit-twiddling per controllare ingresso.$n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$

Nota: il valore restituito è verità / falsa, ma la semantica è invertita, in modo tale che la funzione restituisca la falsità per un numero Ciclope. Dichiaro che questo è legale perché il codice macchina non ha "specifiche per verità / falsità", che è il requisito nella domanda. (Vedi sotto per una versione alternativa se pensi che questo sia barare.)

Nella mnemonica del linguaggio assembly, questo è:

; 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

Provalo online!

Come promesso, se pensi che sia ingannevole invertire la semantica di verità / falsità anche nel codice macchina in cui non ci sono standard o convenzioni reali, quindi aggiungi altri tre byte, per un totale di 21 byte :

; 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

La prima metà di questo codice è la stessa dell'originale (giù attraverso le imulistruzioni). L' leaè quasi la stessa, ma invece di aggiungere una costante 2, ma aggiunge solo una costante 1. Questo è perché la seguente incistruzione incrementa il valore nel EAXregistro da 1 al fine di impostare i flag. Se è impostato il flag "zero", l' setzistruzione verrà impostata ALsu 1; in caso contrario, ALverrà impostato su 0. Questo è il modo standard in cui un compilatore C genererà il codice macchina per restituire a bool.

La modifica della costante aggiunta leanell'istruzione ovviamente non modifica la dimensione del codice e l' incistruzione è molto piccola (solo 1 byte), ma l' setzistruzione è piuttosto enorme di 3 byte. Sfortunatamente, non riesco a pensare a un modo più breve di scriverlo.

Regex (ECMAScript), 60 58 57 60 58 byte

L'ingresso è unario, come la lunghezza di una stringa di s.$n$x

SPOILER ATTENZIONE : Per la radice quadrata, questa regex utilizza una variante dell'algoritmo di moltiplicazione generalizzata, che non è ovvio e potrebbe essere un puzzle gratificante da elaborare da solo. Per ulteriori informazioni, vedere una spiegazione per questo modulo dell'algoritmo in Trova un numero Rocco .

-2 byte consentendo il backtracking nella ricerca di$z$ -1 byte grazie a Grimy , cercando dal più piccolo al più grande anziché viceversa +3 byte per gestire zero -2 byte spostando l'acquisizione radice quadrata all'esterno del lookaheadz
$z$

Funziona trovando , una potenza quadrata perfetta di 2 per la quale . Solo la più grande potenza quadrata perfetta di 2 non superiore a può soddisfarlo, ma a causa di un'ottimizzazione del golf, il regex prova tutti a partire dal più piccolo. Poiché ognuno corrisponde a un numero di ciclopi, solo il più grande può provocare una corrispondenza.$z$$n=2(n-z)+\sqrt{z}+1$$n$

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

Provalo online!

^                 # 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 byte

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

Provalo online!

Forse questo è corretto, forse.

Grazie Grimy, 1 byte salvato.

JavaScript (Node.js) , 32 byte

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

Provalo online!

JavaScript (Node.js) , 34 byte

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

Provalo online!

Perl 6 , 23 byte

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

Provalo online!

Soluzione basata su Regex

Japt , 25 19 10 9 byte

¢êÅ©1¶¢èT

Grazie a @Shaggy per -1 byte

Provalo online!

Mathematica (lingua Wolfram), 32 31 byte

1 byte salvato grazie a J42161217!

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

Provalo online!

Funzione pura che accetta un intero come input e che restituisce Trueo False. Sulla base del fatto (divertente da dimostrare!) Che un numero nè Ciclope se e solo se npiù la radice quadrata di n/2più viene 2arrotondata per difetto a una potenza dispari di 2. (Si può sostituire Floorcon uno Ceilingo Roundfino a quando si sostituisce anche +2con +1.) Ritorna Truesull'input 0.

Rubino , 24 byte

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

Provalo online!

Japt, 8 byte

¢ðT ¥¢Êz

Grazie a Luis felipe de Jesus Munoz per aver risolto la mia richiesta!

Provalo online!

Vecchia soluzione basata su regex, 15 byte

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

Restituisce 1 per vero, 0 per falso.

Provalo online!

Gelatina ,  8  7 byte

-1 grazie a Erik the Outgolfer (usa isPalindrome integrato ŒḂ, invece di ⁼Ṛ$)

B¬ŒḂ⁼SƊ

Un collegamento monadico che accetta un numero intero che produce 1(verità) o 0(falsità).

Provalo online!

Come?

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 byte

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

Provalo online!

Regex (ECMAScript), 53 47 byte

-6 byte grazie sia a Deadcode che a Grimy

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

Provalo online!

Brachylog , 8 byte

ḃD↔Dḍ×ᵐ≠

Questo è un predicato che ha successo se il suo input è un numero Cyclops e fallisce se il suo input non è un numero Cyclops. Il successo / fallimento è il concetto fondamentale di verità / falsità in Brachylog.

Provalo online! Oppure trova tutte le uscite veritiere fino a 10000 .

Spiegazione

          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

Questo ha successo solo quando viene dato un numero Cyclops, perché:

• Se la rappresentazione binaria non è un palindromo, D↔Dfallirà; in ciò che segue, possiamo supporre che sia un palindromo.
• Se è presente più di uno zero, entrambe le metà conterranno almeno uno zero. Quindi i prodotti saranno entrambi zero e ×ᵐ≠falliranno.
• Se non c'è zero, entrambe le metà conterranno solo quelle. Quindi i prodotti saranno entrambi uno e ×ᵐ≠falliranno.
• Ciò lascia il caso in cui esiste esattamente uno zero; poiché sappiamo già di avere un palindromo, questo deve essere il punto centrale. Apparirà a metà, facendo sì che il prodotto di quella metà sia zero; l'altra metà conterrà tutti quelli, quindi il suo prodotto sarà uno. Quindi abbiamo 1 ≠ 0, ha esito ×ᵐ≠positivo e l'intero predicato ha esito positivo.

Rubino , 27 24 byte

Converti in binario e verifica con una regex. Restituisce 0se vero, nilse falso.

-3 byte grazie a GB .

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

Provalo online!

Per altri due byte, c'è una porta diretta della soluzione Python:

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

05AB1E , 8 (o 9) byte

bD0¢sÂQ*

Provalo online o verifica tutti i casi di test .

Ritorna 1se vero; 0o qualsiasi numero intero positivo diverso da 1come falso. In 05AB1E 1è solo la verità e tutto il resto è falsa, ma non sono sicuro che si tratti di un output consentito o se l'output debba essere due valori coerenti e univoci. Se il secondo, è Θpossibile aggiungere un trailing in modo che tutti gli output diversi da quelli 1diventino 0:

Provalo online o verifica tutti i casi di test .

Spiegazione:

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)

Un approccio aritmetico sarebbe di 10 byte:

LoD<s·>*Iå

Provalo online o verifica tutti i casi di test .

Spiegazione:

$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 byte

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

Calcola 2 numeri:

Due volte la potenza più vicina di 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 Più la radice quadrata della Potenza più vicina di 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

Quindi sottrarre il secondo numero dal primo:

>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

E confronta questo risultato con il numero originale

Vecchio metodo

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

Inizia con Log-base-2 di A1 e arrotondalo per difetto al numero pari più vicino, quindi aggiungi 1.

Quindi crea una stringa di tanti "1"s e sostituisci il carattere medio con a "0"per creare un numero Cyclops con una lunghezza binaria sempre dispari e uguale o 1 in meno della lunghezza binaria di A1

Quindi, confrontalo con la rappresentazione binaria di A1

R , 37 33 byte

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

Provalo online!

R non ha un built-in per la conversione in binario, quindi ho semplicemente usato una delle formule di OEIS per calcolare un elenco di termini dalla sequenza.

n<-0:xgenera un generoso elenco di valori iniziali. 2*4^(n<-0:x^2)-2^n-1)è la formula di OEIS, quindi controlla se l'input appare in quella sequenza usando %in%.

-2 byte non dovendo gestire input negativi. -2 byte ricordando che posso passare <-a =.

C (gcc), 26 byte

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

Provalo online!

La risposta di Port of Neil . Si basa su un ordinamento delle operazioni definito dall'implementazione.

C ++ (clang), 38 byte

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

Provalo online!

Impossibile omettere i tipi in C ++, impossibile omettere il ritorno in clang, altrimenti identico.

C (gcc) ,  29 28  27 byte

Salvato 1 byte grazie a @ceilingcat

Una porta della risposta JS a 21 byte di @tsh .

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

Provalo online!

J , 22 19 17 15 14 byte

-3 byte grazie a BolceBussiere!

-4 byte grazie a ngn!

-1 byte grazie a Traws!

J , 14 byte

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

Provalo online!

Gelatina , 9 byte

BŒḂaB¬S=1

Provalo online!

Attache , 22 byte

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

Provalo online!

alternative

27 byte: {BitXor[2*_,2*_+3]^2=8*_+9}

27 byte: {BitXor@@(2*_+0'3)^2=8*_+9}

27 byte: {Palindromic@_∧1=0~_}@Bin

28 byte: {BitXor[...2*_+0'3]^2=8*_+9}

28 byte: {BitXor[…2*_+0'3]^2=8*_+9}

28 byte: {Same@@Bisect@_∧1=0~_}@Bin

29 byte: {_[#_/2|Floor]=0∧1=0~_}@Bin

30 byte: Same@Bin@{_+2^Floor[Log2@_/2]}

30 byte: {_[#_/2|Floor]=0and 1=0~_}@Bin

Retina 0.8.2 , 38 37 byte

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

Provalo online! Il link include casi di test. Modifica: dopo il chiarimento, la soluzione precedente non gestiva correttamente lo zero. Spiegazione:

.+
$*

Converti da decimale a unario.

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

Converti da unario a binario, usando il metodo dal wiki Retina.

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

Controlla lo stesso numero di 1s prima e dopo il 0, o una stringa vuota (che è il modo in cui la conversione sopra gestisce zero).

Lotto, 39 37 byte

@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 byte

-6 byte grazie a @Chronocidal.

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

Esegue 3 controlli:

• Lunghezza dispari

ISEVEN(LOG(A1,2))

• Il personaggio medio è 0

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

• C'è un singolo 0

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

Regex (ECMAScript), 65 59 57 58 byte

+1 byte per gestire 0 correttamente

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

Provalo online!

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

VBA, 41 36 byte

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

Esegui nella finestra immediata, con Dichiarazione esplicita disattivata. L'input è la cella A1del foglio attivo. Emette Vero / Falso nella finestra immediata.

Utilizza la stessa logica della mia risposta Excel per trovare il numero Cyclops dello stesso numero di bit (o 1 bit più corto se c'è un numero pari!) E quindi confronta quello con l'input.

Salva alcuni byte durante il calcolo dei numeri Ciclopi riducendoli alla forma y = 2x^2 - x - 1(dove x = n-1per l' ennesimo numero Ciclope o x = 2^Int(Log([A1])/Log(4))per trovare il numero Ciclope più grande con un numero di bit minore o uguale) e memorizzando x in una variabile

(-5 byte grazie a Taylor Scott !)

PHP , 74 byte

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

Provalo online!

Approccio non matematico totalmente ingenuo, solo stringhe.

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')
}

O 60 byte basati sull'algoritmo di @ Chronocidal sopra .

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

Provalo online!

Haskell, 82 byte

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

E una porta della soluzione Python di xnor:

Haskell, 47 byte

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