Achtung: Dies ist KEINE "Hey, lass uns einen Kuchen in ASCII-Kunst zeichnen" -Herausforderung! Bitte lies weiter;)

Vor einiger Zeit hatte ich Geburtstag, jetzt bin ich 33 Jahre alt.

So gibt es diese unangenehme soziale Tradition, die darin besteht, Familie und Freunde einzuladen, zahlenmäßige Kerzen auf einen Kuchen zu setzen, Lieder zu singen und Geschenke zu öffnen.

   33   
--------

Anstelle von Zahlen kann ich das Binärsystem verwenden, um Standardkerzen zu setzen: Ich lege 6 davon auf den Kuchen und zünde zwei davon an.

 100001
--------

Ich kann sehen, dass sowohl Dezimal- als auch Binärzahlen meines Alters palindrom sind!

Herausforderung

Ich möchte wissen, ob eine andere Zahl mit Kerzen auf einen Kuchen gesetzt werden kann und palindromisch, dezimal und binär sein kann.

Schreiben Sie ein Programm / eine Funktion, um zu testen, ob eine Zahl sowohl dezimal als auch binär palindrom ist . Aber warten Sie, es gibt noch mehr: In Binärform zählen führende Nullen für den Test!

Eingang

Eine Dezimalzahl x, die ich testen möchte, ob es sich um eine Geburtstagspalindromie mit 0 <x <2 ³² -1 handelt. (Ja, die Menschen in meiner Dimension leben sehr lange.)

Ausgabe

Wahrheit, wenn es genau diese beiden Bedingungen erfüllt, Falsey sonst:

• Die dezimale Darstellung der Zahl ist ein Standardpalindrom
• Die binäre Darstellung der Zahl ist ein Standardpalindrom, und das Hinzufügen von führenden Nullen kann dabei hilfreich sein

Testfälle

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

Regeln

• Standardlücken sind nicht zulässig
• Integrierte Bibliothekskonvertierungen und -tests sind zulässig
• Das ist Code-Golf , der kürzeste Code-Gewinn!

Viel Glück und schließlich alles Gute zum Geburtstag!

05AB1E , 7 Bytes

b0Ü‚DíQ

Probieren Sie es online! oder als Test Suite

Erläuterung

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 Bytes

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

Probieren Sie es online!

-3 Bytes dank Rod
-3 Bytes dank Connor Johnston

JavaScript (ES6), 65 Byte

Rückgabe 0oder 1.

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

Wie?

Die Hilfsfunktion g () nimmt eine ganze Zahl b als Eingabe und testet, ob n ein Palindrom in der Basis b ist . Wenn b nicht angegeben ist, wird n vor dem Testen in eine Zeichenfolge konvertiert .

Wir gehen in der Binärdarstellung der nachfolgenden Nullen rid n durch Isolierung des niedrigstwertigen 1 mit n&-nund Dividieren n durch die sich ergebende Menge.

Lustige Tatsache: Es ist wahr, 0weil (0/0).toString(2)gleich "NaN", was ein Palindrom ist. (Aber0 Ist aber trotzdem keine gültige Eingabe.)

Testfälle

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 Bytes

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

Probieren Sie es auf Wolfram Sandbox

Verwendung

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

f[6]

True

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

{True, False, True, False}

Erläuterung

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 mit eingebautem PalindromeQ

PalindromeQ@#&&!IntegerReverse[#,2,Range@#]~FreeQ~#&

Pyth - 13 Bytes

&_I.s.BQ`Z_I`

Test Suite .

Japt , 14 Bytes

s ꬩ¢w n2 ¤ê¬

Online testen!

Erläuterung

 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 Bytes

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

Probieren Sie es online!

APL, 27 31 Bytes

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

Wie funktioniert es Mit 6 als 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

Versuchen Sie es auf TryAPL.org

Gelee , 8 Bytes

Bt0ŒḂaŒḂ

Probieren Sie es online!

Brachylog , 7 Bytes

↔?ḃc↔.↔

Probieren Sie es online!

Das ist eine Menge von ↔...

Erläuterung

Mit der impliziten Eingabe und Ausgabe lautet der Code: ?↔?ḃ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 Byte

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

Erläuterung

                  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)

Probieren Sie es online!

Perl, 53 +3 (-pal) Bytes

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

versuche es online

Pyt , 10 Bytes

Gibt [1] zurück, wenn wahr, [0], wenn falsch

ĐɓƖ₫áĐ₫=ʁ∧

Probieren Sie es online!

Erläuterung:

              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

Netzhaut , 72 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Funktioniert, indem ein unäres Duplikat der ursprünglichen Nummer erstellt wird, aber _s verwendet wird, damit es nicht durch z 11. B. eine Eingabe von verwechselt wird . Die unäre Zahl wird dann in "binär" umgewandelt und nachfolgende Nullen entfernt. Palindrome werden dann nacheinander abgeschnitten und die letzte Stufe prüft, ob noch etwas übrig ist.

Mathematica, 70 Bytes

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

Schale , 14 Bytes

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

Probieren Sie es online!

Ungolfed / Erklärung

             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 Bytes

ṙṭ@ḍ2⁻Πbṭ∧

Probieren Sie es online!

Erläuterung

Anstatt mit führenden Nullen in der Binärdatei zu prüfen, überprüfe ich ohne die nachfolgenden Nullen.

ṙ           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 Bytes

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

Probieren Sie es online!

C # (.NET Core) , 130 129 179 173 + 23 Bytes

Ein paar Dinge, danke an Ed Marty, der darauf hingewiesen hat, dass ich nach so vielen Nullen suchen muss, die vor einem Palindrom gepolstert sind. Und ich muss sicherstellen, dass ich bis zu x ^ ³² -1 überprüfen kann .

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

Probieren Sie es online!

Python 2 , 56 Bytes

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

Probieren Sie es online!

Verwendet die stripMethode von Python, um sowohl bin(..)die führenden 0b als auch die nachfolgenden Nullen der Ausgabe der Binärzahl zu entfernen (da diese immer ein übereinstimmendes Bit haben).

Pyth , 25 22 19 18 17 Bytes

- 3 6 7 8 Bytes durch weiteres Erlernen der Sprache

Ks_.Bsz&_IzqKs_`K

Erläuterung:

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

Ich bin mir sicher, dass man damit Golf spielen kann, daran werde ich arbeiten.

Test Suite

PHP, 69 + 1 Bytes

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

Laufen Sie als Pipe mit -nR
Echoes die ursprüngliche Eingabe für Wahrheit / nichts für Falsey

Probieren Sie es online!

Oktave , 68 66 Bytes

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

Probieren Sie es online!

Erstangebot von Octave.

Wir erstellen im Grunde genommen ein Array, das die Zahl als Dezimalzeichenfolge und die Zahl als Binärzeichenfolge enthält, wobei nachstehende Nullen entfernt werden. Dann erstellen wir ein Array mit denselben Zeichenfolgen, wobei jedoch die Binär- und Dezimalzahlen gespiegelt werden. Schließlich werden beide Arrays verglichen und das Ergebnis ist entweder wahr, wenn sie übereinstimmen (beide Palindrome) oder falsch, wenn sie nicht übereinstimmen (eines oder beide nicht Palindrome).

• Speichern Sie 2 Bytes mit flipanstelle von fliplr.

APL2 (nicht Dyalog), 36 Bytes

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

Zunächst sei B die 32-Bit-Darstellung von N:

B←(32⍴2)⊤N

Dann spiegle B und finde die Position der 1. 1:

(⌽B)⍳1

Lassen Sie dann so viele Stellen von B weg. Dadurch bleibt die korrekte Anzahl führender Nullen erhalten.

Führen Sie dann FIND und eine OR-REDUCTION durch, um festzustellen, ob das zugeschnittene B einen eigenen Spiegel enthält.

Betrachten wir nun N, die Dezimalstelle. Der am weitesten links stehende Ausdruck konvertiert N in einen Zeichenvektor und prüft, ob er seinem eigenen Spiegel entspricht.

Schließlich verbindet ein UND die beiden Prüfungen.

In APL2 kann ich kein ordentliches Lambda herstellen, also habe ich einen Einzeiler geschrieben und den Zuweisungspfeil eingefügt. Hoffe, das betrügt nicht.

Java 8, 105 104 Bytes

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

Erläuterung:

Probieren Sie es hier aus.

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