Nombres palindromiques avec une torsion binaire

29

Attention: ce n'est PAS un défi "hé, dessinons un gâteau en art ASCII"! Continuez à lire;)

Il y a quelque temps, c'était mon anniversaire, j'ai 33 ans maintenant.

Il y a donc cette tradition sociale maladroite consistant à inviter la famille et les amis, à mettre des bougies numériques sur un gâteau, à chanter des chansons et à ouvrir des cadeaux.

   33   
--------

Au lieu de chiffres, je peux utiliser le système binaire pour mettre des bougies standard: j'en place 6 sur le gâteau et j'en allume deux.

 100001
--------

Je peux voir que les nombres décimaux et binaires de mon âge sont palindromiques!

Défi

Je veux savoir si un autre nombre peut être mis sur un gâteau avec des bougies et être palindromique, décimal et binaire.

Écrivez un programme / une fonction pour tester si un nombre est palindromique à la fois décimal et binaire. Mais attendez, il y a plus: en binaire, les zéros de tête comptent pour le test!

Contribution

Un nombre décimal x que je veux tester s'il est palindromique d'anniversaire avec 0 <x <2 32 -1 (oui, les gens dans ma dimension vivent très longtemps)

Sortie

Vrai s'il remplit exactement ces deux conditions, Falsey d'autre:

  • La représentation décimale du nombre est un palindrome standard
  • La représentation binaire du nombre est un palindrome standard, et l'ajout de zéros à gauche peut aider à cela

Cas de test

1 > 1 => Truthy
6 > 110 (0110) => Truthy
9 > 1001 => Truthy
10 > 1010 (01010) => Falsey, 10 is not palindromic
12 => 1100 (001100) => Falsey, 12 is not palindromic
13 => 1101 (...01101) => Falsey, neither 13 nor 1101 are palindromic
14 => 1110 (01110) => Falsey, 14 is not palindromic
33 > 100001 => Truthy
44 > 101100 (..0101100) => Falsey, 101100 is not palindromic
1342177280 > 1010000000000000000000000000000 (00000000000000000000000000001010000000000000000000000000000) => Falsey, 1342177280 is not palindromic (but the binary representation is)
297515792 > 10001101110111011101100010000 (000010001101110111011101100010000) => Truthy

Règles

Bonne chance et finalement joyeux anniversaire!

Goufalite
la source
Sandbox
Goufalite
6
Pourrait vouloir changer le titre car la partie anniversaire n'est pas pertinente.
NoOneIsHere
@NoOneIsHere bien le défi concerne les bougies sur un gâteau d'anniversaire. Il y a aussi la torsion de la représentation binaire donc ce n'est pas des "nombres palindromiques génériques". Si votre commentaire est voté, je proposerai un autre titre.
Goufalite
Ainsi, selon les règles, 0b01010000000000000000000000000000n'est-il pas palindromique car il faudrait ajouter plus de zéros et donc dépasser 2 ^ 32-1? Dans ce cas, il serait utile d'ajouter quelque chose comme 1342177280un cas de test falsey.
Cristian Lupascu
1
@ w0lf Je n'ai pas écrit de limite pour ajouter des zéros mais je comprends votre problème de débordement de pile;) De plus, il 1342177280n'est pas palindromique décimal donc Falsey. Montage
Goufalite

Réponses:

17

05AB1E , 7 octets

b0Ü‚DíQ

Essayez-le en ligne! ou comme suite de tests

Explication

b         # convert input to binary
 0Ü       # remove trailing zeroes
   ‚      # pair with input
    D     # duplicate
     í    # reverse each (in the copy)
      Q   # check for equality
Emigna
la source
Bifurcate n'a pas aidé?
Magic Octopus Urn
@MagicOctopusUrn: Malheureusement non, car je veux inverser chaque numéro de la liste et non la liste elle-même.
Emigna
11

Python 3 , 59 octets

lambda a:all(c==c[::-1]for c in[str(a),bin(a).strip('0b')])

Essayez-le en ligne!

-3 octets grâce à Rod
-3 octets grâce à Connor Johnston

HyperNeutrino
la source
1
l'utilisation de strip avec des chaînes supprimera les caractères simples: [bin (a) [2:]. strip ('0') => bin (a) .strip ('0b')] ( tio.run/… "Python 3 - Try It Online ")
Conner Johnston
@ConnerJohnston o cool, merci!
HyperNeutrino
8

JavaScript (ES6), 65 octets

Renvoie 0ou 1.

n=>(g=b=>[...s=n.toString(b)].reverse().join``==s)()&g(2,n/=n&-n)

Comment?

La fonction d'aide g () prend un entier b en entrée et teste si n est un palindrome en base b . Si b n'est pas spécifié, il convertit simplement n en une chaîne avant de le tester.

Nous nous débarrassons des zéros de fin dans la représentation binaire de n en isolant le 1 le moins significatif avec n&-net en divisant n par la quantité résultante.

Fait amusant: c'est vrai 0parce que c'est (0/0).toString(2)égal "NaN", ce qui est un palindrome. (Mais ce 0n'est pas une entrée valide de toute façon.)

Cas de test

Arnauld
la source
5

Mathematica, 52 49 octets

i=IntegerReverse;i@#==#&&!i[#,2,Range@#]~FreeQ~#&

Essayez-le sur Wolfram Sandbox

Usage

f = (i=IntegerReverse;i@#==#&&!i[#,2,Range@#]~FreeQ~#&);

f[6]

True

f /@ {9, 14, 33, 44}

{True, False, True, False}

Explication

i=IntegerReverse;i@#==#&&!i[#,2,Range@#]~FreeQ~#&

i=IntegerReverse                                   (* Set i to the integer reversing function. *)
                 i@#==#                            (* Check whether the input reversed is equal to input. *)
                       &&                          (* Logical AND *)
                          i[#,2,Range@#]           (* Generate the binary-reversed versions of input, whose lengths *)
                                                   (* (in binary) are `{1..<input>}` *) 
                                                   (* trim or pad 0s to match length *)
                                        ~FreeQ~#   (* Check whether the result is free of the original input *)
                         !                         (* Logical NOT *)

Version avec intégré PalindromeQ

PalindromeQ@#&&!IntegerReverse[#,2,Range@#]~FreeQ~#&
JungHwan Min
la source
4

Pyth - 13 octets

&_I.s.BQ`Z_I`

Suite de tests .

Maltysen
la source
Vous pouvez utiliser _MIet jQ2enregistrer 2 octets:_MI,.sjQ2Z`
Erik the Outgolfer
3

Japt , 14 octets

s ꬩ¢w n2 ¤ê¬

Testez-le en ligne!

Explication

 s ê¬ © ¢   w n2 ¤  ê¬
Us êq &&Us2 w n2 s2 êq   Ungolfed
                         Implicit: U = input integer
Us êq                    Convert U to a string and check if it's a palindrome.
        Us2 w            Convert U to binary and reverse. 
              n2 s2      Convert to a number, then back to binary, to remove extra 0s.
                    êq   Check if this is a palindrome.
      &&                 Return whether both of these conditions were met.
ETHproductions
la source
Entré avec quelques solutions similaires pour 13 octets: sêQ *(¢w)sêQetsêQ &¢w n sêQ
Shaggy
@Shaggy Merci, mais malheureusement, les deux échouent 297515792(le binaire inversé converti en décimal est tout simplement trop gros pour que JS puisse le gérer) ...
ETHproductions
2

APL, 27 31 octets

∧/(⌽≡⊢)∘⍕¨{⍵,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢⍵}

Comment ça marche? Utiliser 6 comme argument ...

      2⊥⍣¯1⊢6 ⍝ get the bit representation
1 1 0

      ⌽2⊥⍣¯1⊢6 ⍝ reverse it (if it's a palindrome, it doesn't matter)
0 1 1

      {⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6 ⍝ drop off the trailing (now leading 0's)
1 1

      6,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6 ⍝ enclose and concatenate the bits to the original number
┌─┬───┐
│6│1 1│
└─┴───┘

      (⌽≡⊢)∘⍕ ⍝ is a composition of
      ⍕ ⍝ convert to string and 
      (⌽≡⊢) ⍝ palindrome test

      (⌽≡⊢)∘⍕¨6,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6 ⍝ apply it to each of the original argument and the bit representation
  1 1

      ∧/(⌽≡⊢)∘⍕¨6,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6  ⍝ ∧/ tests for all 1's (truth)
  1

Essayez-le sur TryAPL.org

Brian Becker
la source
Selon les spécifications, 6 est censé être une bonne entrée, mais l'expression fournie renvoie false.
lstefano
Ah, les rats! C'est ce que j'obtiens pour ne pas avoir lu le problème dans son intégralité. Bonne prise. Je vous remercie! J'ai modifié avec une solution un peu plus longue, mais j'espère plus correcte.
Brian Becker
Bienvenue chez PPCG. Bon premier post! Malheureusement, votre soumission dans sa forme actuelle n'est ni un programme, ni une fonction. Pas de soucis cependant, vous pouvez en faire une fonction mais en laissant les accolades extérieures entourer tout le code.
Adám
Économisez trois octets: {(⌽¨≡⊢)⍕¨⍵,⊂(⌽↓⍨~⊥~)2⊥⍣¯1⊢⍵}(il est bon de fournir un lien pour exécuter toute la suite de tests)
Adám
1

Gelée , 8 octets

Bt0ŒḂaŒḂ

Essayez-le en ligne!

HyperNeutrino
la source
Vous voulez probablement ȧou aau lieu de µparce que sinon ce sera toujours vrai.
Erik the Outgolfer
@EriktheOutgolfer whoops thanks
HyperNeutrino
1

Brachylog , 7 octets

↔?ḃc↔.↔

Essayez-le en ligne!

Ça fait beaucoup de ...

Explication

Avec l'entrée et la sortie implicites, le code est: ?↔?ḃc↔.↔.

?↔?        The Input is a palindrome
   ḃ       Convert it to the list of its digits in binary
    c      Concatenate it into an integer
     ↔     Reverse it: this causes to remove the trailing 0's
      .↔.  The resulting number is also a palindrome
Fatalize
la source
1

APL (Dyalog Classic) , 26 octets

{≡∘⌽⍨⍕⍵,⍵,⍨(<\⊂⊢)⌽2⊥⍣¯1⊢⍵}

Explication

                  2⊥⍣¯1⊢⍵  encode  as binary
                          reverse
           (<\⊂⊢)          partition from first 1
      ⍵,⍵,⍨                prepend and append 
                         turn into text string
≡∘⌽⍨                       match text with its reverse (fX is XfX, where f is a composed function that reverses its right argument and matches with left)

Essayez-le en ligne!

Gil
la source
Ooh, vous avez joué au golf BB!
Adám
1

Perl, 53 +3 (-pal) octets

$_=sprintf"%b",$_;s/0+$//;$_="$_/@F"eq reverse"@F/$_"

essayez-le en ligne

Nahuel Fouilleul
la source
1

Pyt , 10 octets

Renvoie [1] si vrai, [0] si faux

ĐɓƖ₫áĐ₫=ʁ∧

Essayez-le en ligne!

Explication:

              Implicit input
Đ             Duplicate input
ɓ             Get input in binary (as string)
Ɩ             Cast to integer
₫             Reverse the digits (this removes any trailing zeroes)
á             Push the stack into a list
Đ             Duplicate the list
₫             Reverse the digits of each element of the list
=             Are the two lists equal element-wise
ʁ∧            Reduce the list by bitwise AND
mudkip201
la source
0

Rétine , 72 octets

.+
$*_;$&
+`(_+)\1
$+0
0_
_
0+;
;
+`\b(\w)((\w*)\1)?\b
$3
(\B;\B)|.*
$.1

Essayez-le en ligne! Le lien inclut des cas de test. Fonctionne en créant un doublon unaire du numéro d'origine, mais en utilisant _s pour qu'il ne soit pas confondu par exemple par une entrée de 11. Le nombre unaire est ensuite converti en "binaire" et les zéros de fin sont supprimés. Les palindromes sont ensuite tronqués successivement et la dernière étape vérifie s'il reste quelque chose.

Neil
la source
0

Mathematica, 70 octets

(P=PalindromeQ)[PadRight[#~IntegerDigits~2,#~IntegerExponent~2]]&&P@#&
J42161217
la source
0

Husk , 14 octets

¤&S=↔ȯ↓=0↔ḋ⁰d⁰

Essayez-le en ligne!

Non golfé / Explication

             d⁰  -- digits of input in decimal
          ḋ⁰)    -- digits of input in binary
         ↔       --   reverse
     (↓=0        --   and drop all leading zeros
¤&               -- test the two lists if
  S=↔            --   they're equal to their own reverse
ბიმო
la source
0

Gaia , 10 octets

ṙṭ@ḍ2⁻Πbṭ∧

Essayez-le en ligne!

Explication

Au lieu de vérifier avec les zéros de tête en binaire, je vérifie sans les zéros de fin.

ṙ           String representation of number
 ṭ          Is palindromic?
  @         Push input again
   ḍ        Prime factors
    2⁻      Remove all 2s
      Π     Product
       b    Convert to binary
        ṭ   Is palindromic?
         ∧  Logical and
Chat d'affaires
la source
0

C (gcc) , 105 octets

r(n,b){int s=0,c=n;for(;n;n/=b)s=s*b+n%b;return s==c;}
c;f(n){for(c=n;c%2<1;c/=2);return r(n,10)&r(c,2);}

Essayez-le en ligne!

Leaky Nun
la source
Vous pouvez remplacer les deux occurrences de return par n=. ( 95 octets. )
Jonathan Frech
Et vous pouvez supprimer la nouvelle ligne pour un octet supplémentaire enregistré.
Jonathan Frech
0

C # (.NET Core) , 130129179 173 + 23 octets

quelques petites choses, merci à Ed Marty d'avoir souligné que je dois vérifier autant de 0 rembourrés devant pour un palindrome. Et je dois m'assurer que je peux vérifier jusqu'à x ^ 32 -1.

x=>{var a=Convert.ToString(x,2);var b=x+"";Func<string,bool>p=z=>z.SequenceEqual(z.Reverse());return new int[a.Length].Select((_,z)=>p(new string('0',z)+a)).Any(z=>z)&p(b);}

Essayez-le en ligne!

Dennis.Verweij
la source
1
Vous pouvez supprimer l'espace entre returnet (pour 129 octets
M. Xcoder
Cela ne fonctionne que lors de l'ajout d'au plus un 0 en tête, mais le problème spécifie que plusieurs zéros en tête sont autorisés.
Ed Marty
@EdMarty qui a été géré, ainsi que le bug de débordement de pile.
Dennis.Verweij
il vous manque un using System;etusing System.Linq
LiefdeWen
ou est-ce les +23 octets?
LiefdeWen
0

Python 2 , 56 octets

lambda n:all(s==s[::-1]for s in(`n`,bin(n).strip("0b")))

Essayez-le en ligne!

Utilise la stripméthode de Python pour supprimer à la fois le début de la bin(..)sortie du 0b et les zéros de fin du nombre binaire (car ils auront toujours un bit correspondant).

Jonathan Frech
la source
0

Pyth , 25 22 19 18 17 octets

- 3 6 7 8 octets en apprenant davantage la langue

Ks_.Bsz&_IzqKs_`K

Explication:

Ks        Set K to the integer version of...
 _.BsJ    Reverse string of the binary input
&         And
 _Iz      Is the input equal to the reverse of itself?
 qKs_`K   Is K equal to int(the reverse of basically string(K))

Je suis sûr que cela peut être joué au golf, je vais y travailler.

Suite de tests

Stan Strum
la source
0

PHP, 69 + 1 octets

$q=trim(decbin($p=$argn),0);if(strrev($p)==$p&&strrev($q)==$q)echo$p;

Exécuter en tant que pipe avec -nR
Echoes l'entrée d'origine pour Vrai / Rien pour Falsey

Essayez-le en ligne!

Jo.
la source
0

Octave , 68 66 octets

@(x)all([d=num2str(x) b=deblank(['' dec2bin(x)-48])]==flip([b d]))

Essayez-le en ligne!

Offre initiale d'Octave.

Nous créons essentiellement un tableau contenant le nombre sous forme de chaîne décimale et le nombre sous forme de chaîne binaire avec les 0 de fin supprimés. Ensuite, nous créons un tableau avec le même pour les chaînes mais avec les nombres binaires et décimaux inversés. Enfin, les deux tableaux sont comparés et le résultat est soit vrai s'ils correspondent (les deux palindromes), soit faux s'ils ne le sont pas (l'un ou les deux ne sont pas des palindromes).


  • Enregistrez 2 octets en utilisant flipau lieu de fliplr.
Tom Carpenter
la source
0

APL2 (pas Dyalog), 36 octets

(N≡⌽N←⍕N)^∨/(((⌽B)⍳1)↓B)⍷B←(32⍴2)⊤N←

Soit d'abord B la représentation 32 bits de N:

B←(32⍴2)⊤N

Puis miroir B et trouver la position du 1er 1:

(⌽B)⍳1

Supprimez ensuite autant de positions de B. Cela préservera le nombre correct de 0 en tête.

Ensuite, effectuez FIND et une réduction OR pour voir si le B recadré contient son propre miroir.

Regardons maintenant N, la décimale. L'expression entre crochets la plus à gauche convertit N en un vecteur de caractères et vérifie si elle correspond à son propre miroir.

Enfin, un ET rejoint les deux contrôles.


Dans APL2, je ne peux pas faire une lambda soignée, j'ai donc écrit une doublure et inclus la flèche d'affectation. J'espère que ce n'est pas de la triche.

mappo
la source
1
Bienvenue chez PPCG!
Martin Ender
Bienvenue chez PPCG! Pour une version moins tricheuse, pouvez-vous ajouter un quad ( ) pour en faire un programme complet à la place? De plus, pouvez-vous raccourcir (N≡⌽N←⍕N)^∨/(B↓⍨1⍳⍨⌽B)⍷B←(32⍴2)⊤N←⎕?
Erik the Outgolfer le
Erik, merci d'avoir vérifié! Je suis sûr que cela pourrait être amélioré, mais je n'ai pas le squiggle ⍨ dans APL2.
mappo
0

Java 8, 105 104 octets

n->{String t=n+n.toString(n,2).replaceAll("0*$","")+n;return t.contains(new StringBuffer(t).reverse());}

Explication:

Essayez-le ici.

n->{                         // Method with Integer parameter and boolean return-type
  String t=n                 //  Create a String `t` starting with the input Integer
    +n.toString(n,2)         //  Append the binary representation of the input Integer,
      .replaceAll("0*$","")  //   with all trailing zeroes removed
    +n;                      //  Append the input Integer again
  return t.contains(new StringBuffer(t).reverse());
                             //  Return true if `t` is a palindrome
}                            // End of method
Kevin Cruijssen
la source