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 ³² -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

• Les failles standard sont interdites
• Les conversions et tests de bibliothèque intégrés sont autorisés
• C'est le code-golf , le gain de code le plus court!

Bonne chance et finalement joyeux anniversaire!

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

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

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

let f =

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

console.log(f(1 )) // Truthy
console.log(f(6 )) // Truthy
console.log(f(9 )) // Truthy
console.log(f(10)) // Falsey
console.log(f(12)) // Falsey
console.log(f(13)) // Falsey
console.log(f(14)) // Falsey
console.log(f(33)) // Truthy
console.log(f(44)) // Falsey

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~#&

Pyth - 13 octets

&_I.s.BQ`Z_I`

Suite de tests .

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.

Proton , 57 octets

a=>(b=c=>c==c[to by-1])(str(a))*b(bin(a)[2to].strip('0'))

Essayez-le en ligne!

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

Gelée , 8 octets

Bt0ŒḂaŒḂ

Essayez-le en ligne!

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

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 (f⍨X is XfX, where f is a composed function that reverses its right argument and matches with left)

Essayez-le en ligne!

Perl, 53 +3 (-pal) octets

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

essayez-le en ligne

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

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.

Mathematica, 70 octets

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

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

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

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!

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 ^ ³² -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!

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

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

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!

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.

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.

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