Tâche:

À partir d’une entrée entière, déterminez s’il s’agit ou non d’un nombre Cyclops.

Qu'est-ce qu'un numéro de cyclope, vous pouvez demander? Eh bien, c'est un nombre dont la représentation binaire n'en a qu'un 0au centre!

Cas de 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

Contribution:

• Un nombre entier ou équivalent. ( int, long, decimal, Etc.)

• Supposons que si l’évaluation de l’entrée entraîne un dépassement d’entier ou d’autres problèmes indésirables, cette entrée n’a pas à être évaluée.

Sortie:

• Vérité ou fausseté.

• La sortie Vérité / Falsie doit respecter les spécifications de la langue utilisée pour la vérité / la fausseté. (par exemple, C a 0la valeur false, non nul la valeur true)

Règles du challenge:

• Une entrée inférieure à 0 est supposée être une fausseté et ne doit donc pas être évaluée.

• Si la longueur de la représentation binaire du nombre est paire, le nombre ne peut pas être un nombre cyclope.

Règles générales:

• C'est du code-golf , donc les réponses les plus courtes en octets sont gagnantes !.

• Les failles par défaut sont interdites.

• Les règles standard s'appliquent à votre réponse avec les règles d'E / S par défaut .

Il s’agit de mon premier défi de programmation de puzzles et de code de programmation , alors tout commentaire sur la façon dont je devrais m'améliorer serait très apprécié!

Japt, 8 octets

1¥¢q0 äè

Courez en ligne

Explication:

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'idée est de scinder la chaîne binaire en 0, ce qui donnerait deux éléments s'il n'y en a qu'un 0. Ensuite, nous voyons si le premier élément correspond au second pour s’assurer qu’il est palindromique. Si la chaîne binaire contient plusieurs 0s, alors la réduction renverrait un tableau à plusieurs éléments et la ==1condition échouerait . Si la chaîne binaire en contient un 0, mais n'est pas palindromique, äèelle reviendra 0car bcontient des 0correspondances de a.

Python 2 , 30 octets

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

Essayez-le en ligne!

Notez que 2*n^2*n+3c’est le xor au niveau du bit 2*net 2*n+3, car c’est la priorité de l’opérateur Python.

Code machine x86, 17 octets

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

Les octets ci-dessus définissent une fonction qui accepte une valeur d’entrée entière de 32 bits (dans le EDIregistre pour cet exemple, suivant une convention d’appel System V commune, mais vous pouvez en fait choisir à peu près tout le registre d’entrée de votre choix sans affecter la taille du résultat. code) et renvoie un résultat (dans le EAXregistre) indiquant si la valeur entrée est un nombre Cyclops.

L'entrée est supposée être un entier non signé, car les règles de challenge stipulent que nous pouvons ignorer les valeurs négatives.

La logique de décision est empruntée à la réponse de Neil : puisqu'un nombre Cyclops a la forme $n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$ , nous pouvons utiliser une série d'opérations de bricolage pour vérifier l'entrée.

Remarque: La valeur de retour est vérité / fausseté, mais la sémantique est inversée, de telle sorte que la fonction retourne faussement pour un nombre Cyclops. Je prétends que c'est légal parce que le code machine n'a pas de "spécifications pour la vérité / la fausseté", qui est l'exigence dans la question (Voir ci-dessous pour une version alternative si vous pensez que c'est de la triche.)

En mnémonique du langage d'assemblage, il s'agit de:

; 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

Essayez-le en ligne!

Comme promis, si vous pensez qu'il est trompeur d'inverser la sémantique de la vérité / falsification même dans un code machine où il n'y a pas de normes ou de conventions réelles, ajoutez trois octets supplémentaires, pour un total de 21 octets :

; 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 première moitié de ce code est identique à l'original (en suivant les imulinstructions). Le leaest presque identique, mais au lieu d’ajouter une constante 2, il n’ajoute qu’une constante 1. C’est parce que l’ incinstruction suivante incrémente la valeur dans le EAXregistre de 1 afin de définir les drapeaux. Si le drapeau "zéro" est défini, l' setzinstruction sera définie ALsur 1; sinon, ALsera mis à 0. Il s'agit de la manière standard pour un compilateur C de générer du code machine pour renvoyer un bool.

Changer la constante ajoutée dans l' leainstruction ne change évidemment pas la taille du code, et l' incinstruction est très petite (1 octet seulement), mais l' setzinstruction est plutôt imposante avec 3 octets. Malheureusement, je ne peux pas penser à une manière plus courte de l'écrire.

Regex (ECMAScript), 60 58 57 60 58 octets

L'entrée $n$ est unaire, comme la longueur d'une chaîne de xs.

AVERTISSEMENT SPOILER : Pour la racine carrée, cette expression rationnelle utilise une variante de l’algorithme de multiplication généralisée, qui n’est pas évidente et qui pourrait constituer un casse-tête enrichissant à résoudre par vous-même. Pour plus d'informations, voir l'explication de cette forme d'algorithme dans Rechercher un numéro Rocco .

-2 octets en permettant de revenir en arrière dans la recherche de $z$
-1 octet grâce à Grimy , en recherchant $z$ du plus petit au plus grand au lieu de l'inverse
+3 octets pour gérer zéro
-2 octets en déplaçant la capture de la racine carrée en dehors du regard

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

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Peut-être que c'est correct, peut-être.

Merci Grimy, 1 octet enregistré.

JavaScript (Node.js) , 32 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 34 octets

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

Essayez-le en ligne!

Perl 6 , 23 octets

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

Essayez-le en ligne!

Solution basée sur regex

Japt , 25 19 10 9 octets

¢êÅ©1¶¢èT

Merci à @Shaggy pour -1 octet

Essayez-le en ligne!

Mathematica (langage Wolfram), 32 31 octets

1 octet économisé grâce à J42161217!

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

Essayez-le en ligne!

Fonction pure prenant un entier en entrée et renvoyant Trueou False. Basé sur le fait (amusant de prouver!) Qu'un nombre nest Cyclope si et seulement si nplus la racine carrée de n/2plus 2arrondit à une puissance impaire de 2. (On peut remplacer Floorpar soit Ceilingou Roundtant que l'on remplace également +2par +1.) Retourne Trueen entrée 0.

Ruby , 24 octets

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

Essayez-le en ligne!

Japt, 8 octets

¢ðT ¥¢Êz

Merci à Luis Felipe de Jesus Munoz pour avoir corrigé ma soumission!

Essayez-le en ligne!

Ancienne solution à base de regex, 15 octets

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

Retourne 1 pour vrai, 0 pour faux.

Essayez-le en ligne!

Gelée ,  8  7 octets

-1 grâce à Erik the Outgolfer (utilisez isPalindrome intégré à la ŒḂplace de ⁼Ṛ$)

B¬ŒḂ⁼SƊ

Un lien monadique acceptant un entier qui donne 1(vérité) ou 0(falsey).

Essayez-le en ligne!

Comment?

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 octets

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

Essayez-le en ligne!

Regex (ECMAScript), 53 47 octets

-6 octets grâce à Deadcode et Grimy

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

Essayez-le en ligne!

Brachylog , 8 octets

ḃD↔Dḍ×ᵐ≠

C'est un prédicat qui réussit si son entrée est un nombre Cyclops et échoue si son entrée n'est pas un nombre Cyclops. Succès / échec est le concept le plus fondamental de vérité / falsey dans Brachylog.

Essayez-le en ligne! Ou trouvez toutes les sorties de vérité jusqu’à 10000 .

Explication

          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

Cela ne réussit que lorsqu'un numéro Cyclops est attribué, car:

• Si la représentation binaire n'est pas un palindrome, D↔Déchouera. dans ce qui suit, on peut supposer que c'est un palindrome.
• S'il y a plus d'un zéro, les deux moitiés contiendront au moins un zéro. Les produits seront donc tous deux nuls et ×ᵐ≠échoueront.
• S'il n'y a pas de zéro, les deux moitiés n'en contiennent que des uns. Les produits ne feront donc qu'un, et ×ᵐ≠échoueront.
• Cela laisse le cas où il y a exactement un zéro; puisque nous savons déjà que nous avons un palindrome, ce doit être le bit central. Il apparaîtra dans une moitié, le produit de cette moitié sera alors nul; l'autre moitié contiendra toutes les unités, son produit n'en sera donc qu'un. Ensuite, nous avons 1 ≠ 0, ×ᵐ≠réussit et le prédicat entier réussit.

Ruby , 27 à 24 octets

Convertir en binaire et vérifier avec une expression régulière. Retourne 0si vrai, nilsi faux.

-3 octets grâce à GB .

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

Essayez-le en ligne!

Pour deux octets de plus, il existe un portage direct de la solution Python:

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

05AB1E , 8 (ou 9) octets

bD0¢sÂQ*

Essayez-le en ligne ou vérifiez tous les cas de test .

Retourne 1si vérité; 0ou tout autre nombre positif autre que 1falsey. Dans 05AB1E seulement, la 1vérité et tout le reste sont falsey, mais je ne suis pas sûr s'il s'agit d'une sortie autorisée ou si la sortie doit comporter deux valeurs cohérentes et uniques. Si le second, un fin Θpeut être ajouté pour que toutes les sorties autres que 1deviennent 0:

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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)

Une approche arithmétique serait de 10 octets:

LoD<s·>*Iå

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Calcule 2 nombres:

Deux fois la puissance de 4 la plus proche
>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 plus la racine carrée de la puissance de 4 la plus proche
>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

Puis soustrayez le deuxième nombre du premier:

>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

Et comparez ce résultat avec le nombre d'origine

Ancienne méthode

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

Commencez par le log-base-2 de A1 et arrondissez-le au nombre pair le plus proche, puis ajoutez 1.

Créez ensuite une chaîne de autant de "1"s et remplacez le caractère du milieu par un "0"pour créer un nombre Cyclops avec une longueur binaire toujours impaire, égale à ou inférieure à la longueur binaire de A1.

Ensuite, comparez-le avec la représentation binaire de A1

R , 37 33 octets

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

Essayez-le en ligne!

R n’ayant pas de fonction intégrée pour la conversion en binaire, j’ai simplement utilisé l’une des formules d’OEIS pour calculer une liste de termes à partir de la séquence.

n<-0:xgénère une liste généreuse de valeurs de départ. 2*4^(n<-0:x^2)-2^n-1)est la formule d'OEIS, puis il vérifie si l'entrée apparaît dans cette séquence à l'aide de %in%.

-2 octets pour ne pas avoir à gérer des entrées négatives. -2 octets en rappelant que je peux changer <-pour =.

C (gcc), 26 octets

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

Essayez-le en ligne!

La réponse du port de Neil . Repose sur le classement des opérations défini par l'implémentation.

C ++ (clang), 38 octets

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

Essayez-le en ligne!

Ne peut pas omettre les types en C ++, ne peut pas omettre le retour dans Clang, sinon identique.

C (gcc) ,  29 28  27 octets

1 octet enregistré grâce à @ceilingcat

Un port de la réponse JS de 21 octets par @tsh .

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

Essayez-le en ligne!

J , 22 19 17 15 14 octets

-3 octets grâce à BolceBussiere!

-4 octets grâce à ngn!

-1 octet grâce à Traws!

J , 14 octets

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

Essayez-le en ligne!

Gelée , 9 octets

BŒḂaB¬S=1

Essayez-le en ligne!

Attaché , 22 octets

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

Essayez-le en ligne!

Des alternatives

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

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

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

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

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

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

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

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

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

Retina 0.8.2 , 38 37 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Edit: Après clarification, la solution précédente ne gérait pas le zéro correctement. Explication:

.+
$*

Convertir de décimal à unaire.

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

Convertissez des unaires en binaires, en utilisant la méthode du wiki Retina.

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

Recherchez le même nombre de 1s avant et après le 0, ou une chaîne vide (comment la conversion ci-dessus traite-t-elle zéro).

Lot, 39 37 octets

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

-6 octets grâce à @Chronocidal.

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

Effectue 3 contrôles:

• Longueur impaire

ISEVEN(LOG(A1,2))

• Le personnage du milieu est 0

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

• Il y a un seul 0

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

Regex (ECMAScript), 65 59 57 58 octets

+1 octet pour gérer 0 correctement

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

Essayez-le en ligne!

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

VBA, 41 36 octets

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

Exécuter dans la fenêtre Immediate, avec la déclaration explicite désactivée. L'entrée est la cellule A1de la feuille active. Sorties True / False dans la fenêtre immédiate.

Utilise la même logique que ma réponse Excel pour trouver le nombre de Cyclops du même nombre de bits (ou un bit plus court s'il existe un nombre pair!), Puis le compare à l'entrée.

Enregistre quelques octets lors du calcul des nombres Cyclops en les réduisant à la forme y = 2x^2 - x - 1(où x = n-1pour le nième nombre Cyclops, ou x = 2^Int(Log([A1])/Log(4))pour trouver le plus grand nombre Cyclops avec un nombre de bits inférieur ou égal) et en stockant x dans une variable

(-5 octets grâce à Taylor Scott !)

PHP , 74 octets

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

Essayez-le en ligne!

Approche totalement naïve et non mathématique, juste des chaînes.

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

Ou 60 octets basés sur l'algorithme de @ Chronocidal ci-dessus .

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

Essayez-le en ligne!

Haskell, 82 octets

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

Et un port de la solution Python de xnor:

Haskell, 47 octets

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