Est-ce un numéro de cyclope? "Personne ne sait!

66

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:


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é!

Tau
la source
25
Note: Ceci est A129868
tsh
35
+1 pour la référence de la culture pop tardive de 2800 ans dans le titre
Sanchises
quel est le nombre maximum à tester?
Serverfrog
@Serverfrog puisque je n'ai pas spécifié de limite, supposons que tout entier positif puisse être testé.
Tau
L'entrée binaire est-elle autorisée?
Qwertiy

Réponses:

11

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.

Oliver
la source
1
A pris mon cerveau pré-caféiné quelques secondes pour voir ce qui se passait ici! Bien fait. devrait également fonctionner.
Shaggy
1
Je ne connais pas Japt, mais si je comprends bien, les conséquences sont les suivantes: ¤= convertir en binaire; q0= divisé en 0; äèJe ne suis pas tout à fait sûr .. et le drapeau -Nconvertit les listes en NaN, mais laisse 0et 1le même. Pour la äèpartie , je peux voir que 119est [111,111]après la scission, ce qui äèchange à 1; et 85est [1,1,1,1]après la scission, qui äèdevient [1,1,1]. Pourriez-vous expliquer comment ça .ä("è")marche?
Kevin Cruijssen Le
2
@KevinCruijssen J'ai ajouté une explication. J'espère que ça aide.
Oliver
1
Est-ce que NaNFalsey est dans Japt? (si vous effectuez une if-else avec ce que la condition ne le se faire exécuter? « Truthy / sortie falsy doit répondre aux spécifications de la langue utilisée pour truthy / falsy ») Aussi les 2rendements 2que je doute est Falsey (mais peut - être si Japt est comme 05AB1E).
Jonathan Allan
1
JS suppose que tout entier autre que 0est considéré truthy ... Toutefois, si 2est de retour 2comme truthy, cette soumission peut devoir être retravaillé.
Tau
21

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.

Xnor
la source
1
Serait-il acceptable de retourner lambda n:(2*n^2*n+3)**2-8*n-9, avec une valeur de retour de 0pour les nombres de cyclopes?
Eric Duminil Le
2
Cela donne TRUEpourn = -1
user2390246
3
@ user2390246 ce problème n'est clairement pas destiné aux négatifs - s'il en était une, toutes les solutions acceptantes doivent être négatives (et la façon dont python implémente les entiers signifie qu'aucune solution ne devrait être acceptée en python)
DreamConspiracy
3
Les nombres négatifs @SolomonUcko sont généralement stockés dans une représentation en complément à deux. Considérons les premiers entiers de taille fixe (32 bits par exemple). Parmi les autres propriétés, TCR exige que le bit de poids fort soit 1 en nombres négatifs et 0 en positif. Cela exigerait immédiatement que toutes les sorties positives soient fausses. En python, le problème est encore plus grave. Les nombres négatifs ont implicitement une suite infinie de 1 dans la direction la plus significative. Bonne chance pour essayer de trouver le milieu de cela
DreamConspiracy
2
@ user2390246 Le problème a depuis été modifié pour préciser que notre code n'a pas besoin de fonctionner pour les négatifs. Il pourrait être traité pendant 2 octets en ajoutant >1.
Xnor
18

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=(2k+1)(2k-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.

Cody Gray
la source
4
C’est tellement rapide que je pense que cela mérite d’être démontré en testant tous les chiffres jusqu’à une valeur importante: essayez-le en ligne!
Deadcode
Il devrait en fait être encore plus rapide, @Deadcode. :-) La démonstration avec un assemblage en ligne ajoute une charge supplémentaire, mais mon vieux truc de sauter à une chaîne d'octets (voir, par exemple, cette réponse ) a cessé de fonctionner avec le compilateur de TIO et écrire du code pour imprimer les résultats directement dans l'assemblage est trop long. travailler pour s'embêter avec. Il s’agit toutefois d’un cas inhabituel dans lequel l’optimisation de la taille n’est pas incompatible avec l’optimisation de la vitesse. C’est à peu près la façon dont vous écrivez le code dans asm si vous visiez une vitesse supérieure à la taille.
Cody Grey
Par consensus, il n'est pas inacceptable de renvoyer un indicateur de statut dans une soumission asm codegolf.stackexchange.com/a/165020/84624 et stackoverflow.com/questions/48381234/… . Si c'est le cas, vous pourriez - d'après votre deuxième réponse.
640KB
9

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

zn=2(n-z)+z+1n

^(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
Deadcode
la source
OP a précisé que 0 devrait être la vérité, ce qui ne résout pas le problème pour le moment.
Grimmy
1
N'est-ce pas ^(1*)0\1$assez simple ?
Incarnation de l'Ignorance
4
@EmbodimentofIgnorance Seulement si l'entrée était en binaire. Cela banaliserait beaucoup de défis; Il est beaucoup plus intéressant d’utiliser systématiquement des entrées unaires, le cas échéant.
Deadcode
9

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!

tsh
la source
20
Grimmy
Test, pas de correspondance
edc65
1
@ edc65 Avez-vous découvert un test qui a échoué?
Tsh
2
@th .testnot.match
ASCII-only
@ ASCII seulement Wow, ça vous semble raisonnable ... Comment pouvez-vous lire ceci?
Tsh
7

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.

Greg Martin
la source
1
vous pouvez économiser 1 octet en utilisantLog2[#+Floor@Sqrt...
J42161217
et 1 de plus utilisant √()au lieu deSqrt[]
attinat
Le nombre d'octets est-il correct? TIO donne 32 octets pour le programme en cours.
mbomb007
@ mbomb007 aha, le TIO n'a pas incorporé les économies d'un octet de J42161217. Fixé.
Greg Martin
Y a-t-il une raison pour laquelle vous n'avez pas utilisé l'attinat proposé?
mbomb007
6

Ruby , 24 octets

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

Essayez-le en ligne!

GB
la source
Agréable. Il pourrait y avoir une version plus courte avec différentes assignations et priorités, mais je n’en ai trouvé aucune.
Eric Duminil
5

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!

Incarnation de l'ignorance
la source
Bien joué, je devrais vraiment apprendre les expressions régulières de temps en temps. :) +1
Quintec
1
@Quintec Regex est génial :)
Incarnation de Ignorance Le
Mise à jour: trouvé un moyen plus court :)
Quintec
1
8 octets
Luis felipe De jesus Munoz
1
@LuisfelipeDejesusMunoz Merci, c'est une très bonne utilisation de l' ==opérateur!
Incarnation de l'Ignorance
4

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
Jonathan Allan
la source
On dirait que vous avez réellement eu l'idée intelligente devant moi, mais son intelligence n'est pas évidente (elle Bċ0⁼1ȧŒḂest aussi de 8 octets), ⁼Ṛ$c'est la même chose que ŒḂpour -1. En outre, vous n'avez pas besoin de gérer les nombres négatifs.
Erik l'Outgolfer
Merci Erik, le palindrome intégré m'a glissé pour une raison quelconque!
Jonathan Allan
En fait, vous pouvez aussi utiliser ṚƑà sa place de nos jours, alors vous voudrez peut-être vous en souvenir comme ça (les plus importants Ƒ).
Erik l'Outgolfer
4

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!

H.PWiz
la source
Afin de commenter et de prouver votre regex (pas encore tout à fait), je l’ai réduite à 50 octets: ^((?=(x(x*?))(\3((x+)(?=\6$))+xx$))(?!\2{6})x\4)*$( Essayez-le en ligne! )
Deadcode
4

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.
DLosc
la source
3

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}
Eric Duminil
la source
@GB Merci beaucoup!
Eric Duminil Le
3

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:

une(n)=(2n-1)*(2*2n+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)
Kevin Cruijssen
la source
Avoir 1la vérité et tous les autres nombres comme fausseté est acceptable pour ce défi, car d'autres langues (par exemple, C et TI-BASIC) ont des définitions similaires vérité / fausseté (0 / différent de zéro pour les deux). Tant que ce qui est considéré comme de la vérité ou de la fausseté correspond aux spécificités de la langue, alors c'est un jeu juste.
Tau
3

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

Chronocide
la source
3

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 =.

utilisateur2390246
la source
3

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.

Grimmy
la source
1
Je préférerais que les réponses C ++ soient différenciées des réponses C en utilisant returnau lieu de l'exploit de la valeur de retour de l'accumulateur implicite, fragile et dépendant de la plate-forme.
Deadcode
2
Je voudrais aussi que les règles exigent le respect des normes, mais ce n’est pas le cas. Ne pas utiliser cela ne serait que du mauvais golf. C ++ (clang) nécessite le retour, ce qui fait 38 octets.
Grimmy
Ensuite, vous pouvez contourner cela en ayant C (gcc) et C ++ (clang) dans votre réponse au lieu de C (gcc) et C ++ (gcc). J'ai maintenant fait ça.
Deadcode
3

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!

Galen Ivanov
la source
1
#=1++/­­­­­­­
ngn le
1
(#=1++/)@(*|.)@#:
ngn le
1
1=1#.1-(*|.)@#:
NDGN
1
je ne sais pas assez pour l'utiliser, mais il est amusant d'apprendre du code des autres en essayant de le raccourcir
ngn
1
-1 octet1=1#.(*:|.)@#:
Traws
2

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

Conor O'Brien
la source
2

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).

Neil
la source
1

Lot, 39 37 octets

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

n=(2k+1)(2k-1-1)m=2k-1n=m2(m+2)n

Neil
la source
1

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
Wernisch
la source
1
Économisez 6 octets en changeant ISODD(LEN(DEC2BIN(A1)))pourISEVEN(LOG(A1,2))
Chronocidal
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!

(2k-1)(2k+1+1)

Grimmy
la source
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 !)

Chronocide
la source
1
Au lieu de convertir la base du journal en utilisant la division du journal, vous pouvez le changer directement en utilisant la [...]notation[(Log(A1,4)]
Taylor Scott
1

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!

640 Ko
la source
1

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
Joseph Sible
la source