Números palíndricos com um toque binário

29

Atenção: este NÃO é um desafio "ei, vamos desenhar um bolo na arte ASCII"! Por favor, continue lendo;)

Algum tempo atrás, era meu aniversário, agora tenho 33 anos.

Portanto, existe essa tradição social embaraçosa que consiste em convidar familiares e amigos, colocar velas numéricas em um bolo, cantar músicas e abrir presentes.

   33   
--------

Em vez de números, posso usar o sistema binário para colocar velas comuns: coloco 6 delas no bolo e acendo duas delas.

 100001
--------

Eu posso ver que os números decimais e binários da minha idade são palindrômicos!

Desafio

Quero saber se qualquer outro número pode ser colocado em um bolo com velas e ser palindrômico, decimal e binário.

Escrever uma função / programa para testar se um número é palíndromo em ambos decimal e binário. Mas espere, há mais: em zeros binários e principais contam para o teste!

Entrada

Um número decimal x que eu quero testar se for aniversário palindrômico com 0 <x <2 32 -1 (sim, as pessoas da minha dimensão vivem muito tempo)

Saída

Na verdade, se atender exatamente a essas duas condições, Falsey mais:

  • A representação decimal do número é um palíndromo padrão
  • A representação binária do número é um palíndromo padrão e a adição de zeros à esquerda pode ajudar com isso

Casos de teste

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

Regras

Boa sorte e, finalmente, feliz aniversário!

Goufalite
fonte
Sandbox
Goufalite
6
Pode querer alterar o título, pois a parte do aniversário é irrelavante.
NoOneIsHere
@NoOneIsHere bem, o desafio é sobre velas em um bolo de aniversário. Além disso, há uma distorção na representação binária, para que não sejam "números palindrômicos genéricos". Se o seu comentário for votado, apresentarei outro título.
Goufalite 16/08
Portanto, de acordo com as regras, 0b01010000000000000000000000000000não é palindrômico, pois exigiria que mais zeros fossem adicionados e, portanto, excedesse 2 ^ 32-1? Nesse caso, ajudaria a adicionar algo como 1342177280um caso de teste de Falsey.
Cristian Lupascu
11
@ w0lf Eu não escrevi um limite para adicionar zeros, mas entendo seu problema de estouro de pilha;) Além disso, 1342177280não é palindrômico decimal, então Falsey. Edição
Goufalite

Respostas:

17

05AB1E , 7 bytes

b0Ü‚DíQ

Experimente online! ou como um conjunto de testes

Explicação

b         # convert input to binary
 0Ü       # remove trailing zeroes
   ‚      # pair with input
    D     # duplicate
     í    # reverse each (in the copy)
      Q   # check for equality
Emigna
fonte
Bifurcado não ajudou?
Magic Octopus Urn
@MagicOctopusUrn: Infelizmente não, pois quero inverter cada número da lista e não a própria lista.
Emigna
11

Python 3 , 59 bytes

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

Experimente online!

-3 bytes graças a Rod
-3 bytes graças a Connor Johnston

HyperNeutrino
fonte
11
usar strip com strings removerá caracteres únicos: [bin (a) [2:]. strip ('0') => bin (a). strip ('0b')] ( tio.run/… "Python 3 - Experimente It Online ")
Conner Johnston
@ConnerJohnston o cool, obrigado!
HyperNeutrino
8

JavaScript (ES6), 65 bytes

Retorna 0ou 1.

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

Quão?

A função auxiliar g () pega um número inteiro b como entrada e testa se n é um palíndromo na base b . Se b não for especificado, ele apenas converte n em uma string antes de testá-la.

Nós se livrar dos zeros finais na representação binária de n isolando o menos significativo 1 com n&-ne dividindo n pela quantidade resultante.

Curiosidade: é verdade 0porque (0/0).toString(2)é igual "NaN", que é um palíndromo. (Mas 0não é uma entrada válida de qualquer maneira.)

Casos de teste

Arnauld
fonte
5

Mathematica, 52 49 bytes

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

Experimente na Wolfram Sandbox

Uso

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

f[6]

True

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

{True, False, True, False}

Explicação

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

Versão com builtin PalindromeQ

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

Pitão - 13 bytes

&_I.s.BQ`Z_I`

Conjunto de Teste .

Maltysen
fonte
Você pode usar _MIe jQ2salvar 2 bytes:_MI,.sjQ2Z`
Erik the Outgolfer
3

Japonês , 14 bytes

s ꬩ¢w n2 ¤ê¬

Teste online!

Explicação

 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
fonte
Veio com um par de soluções semelhantes para 13 bytes: sêQ *(¢w)sêQesêQ &¢w n sêQ
Salsicha
@Shaggy Graças, mas infelizmente aqueles ambos falham em 297515792(o binário invertida convertido em decimal é apenas grande demais para JS ao punho) ...
ETHproductions
2

APL, 27 31 bytes

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

Como é que isso funciona? Usando 6 como argumento ...

      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

Experimente no TryAPL.org

Brian Becker
fonte
De acordo com as especificações, 6 deve ser uma boa entrada, mas a expressão fornecida retorna false.
Lstefano 17/08/19
Ah, ratos! É isso que recebo por não ler o problema na íntegra. Boa pegada. obrigado! Alterei com uma solução um pouco mais longa, mas espero mais correta.
Brian Becker
Bem-vindo ao PPCG. Bom primeiro post! Infelizmente, seu envio em sua forma atual não é um programa nem uma função. No entanto, não se preocupe, você pode transformá-lo em uma função, mas permitindo que os colchetes externos incluam todo o código.
Adám 17/08/19
Salvar três bytes: {(⌽¨≡⊢)⍕¨⍵,⊂(⌽↓⍨~⊥~)2⊥⍣¯1⊢⍵}(é boa forma de fornecer um link para executar toda a suíte de teste)
Adám
1

Gelatina , 8 bytes

Bt0ŒḂaŒḂ

Experimente online!

HyperNeutrino
fonte
Você provavelmente quer ȧou anão, µporque, caso contrário, isso sempre será verdadeiro.
Erik the Outgolfer
@EriktheOutgolfer whoops thanks
HyperNeutrino
1

Braquilog , 7 bytes

↔?ḃc↔.↔

Experimente online!

Isso é um monte de ...

Explicação

Com a entrada e saída implícitas, o código é: ?↔?ḃ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
Fatalizar
fonte
1

APL (Dyalog Classic) , 26 bytes

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

Explicação

                  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)

Experimente online!

Gil
fonte
Ooh, seu BB fora de golfe!
Adám 22/08/19
1

Perl, 53 +3 (-pal) bytes

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

experimente online

Nahuel Fouilleul
fonte
1

Pyt , 10 bytes

Retorna [1] se verdadeiro, [0] se falso

ĐɓƖ₫áĐ₫=ʁ∧

Experimente online!

Explicação:

              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
fonte
0

Retina , 72 bytes

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

Experimente online! O link inclui casos de teste. Funciona criando uma duplicata unária do número original, mas usando _s para que não seja confundido com, por exemplo, uma entrada de 11. O número unário é então convertido em "binário" e os zeros à direita são removidos. Os palíndromos são truncados sucessivamente e o último estágio testa se resta alguma coisa.

Neil
fonte
0

Mathematica, 70 bytes

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

Casca , 14 bytes

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

Experimente online!

Ungolfed / Explicação

             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
ბიმო
fonte
0

Gaia , 10 bytes

ṙṭ@ḍ2⁻Πbṭ∧

Experimente online!

Explicação

Em vez de verificar com zeros à esquerda em binário, verifico sem os zeros à direita.

ṙ           String representation of number
 ṭ          Is palindromic?
  @         Push input again
   ḍ        Prime factors
    2⁻      Remove all 2s
      Π     Product
       b    Convert to binary
        ṭ   Is palindromic?
         ∧  Logical and
Gato de negócios
fonte
0

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

Experimente online!

Freira Furada
fonte
Você pode substituir as duas ocorrências de return por n=. ( 95 bytes ) .
Jonathan Frech
E você pode remover a nova linha para um byte adicional salvo.
Jonathan Frech
0

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

algumas coisas, obrigado a Ed Marty por apontar que preciso verificar o número de 0 preenchido na frente por um palíndromo. E eu preciso ter certeza de que posso verificar até 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);}

Experimente online!

Dennis.Verweij
fonte
11
Você pode remover o espaço entre returne (para 129 bytes
Sr. Xcoder
Isso funciona apenas ao adicionar no máximo um 0 inicial, mas o problema especifica que vários zeros iniciais são permitidos.
Ed Marty
@ EdMarty que foi manipulado, bem como o bug de estouro de pilha.
precisa saber é o seguinte
está faltando um using System;eusing System.Linq
LiefdeWen
ou são os +23 bytes?
Agradeço o seu contato
0

Python 2 , 56 bytes

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

Experimente online!

Usa o stripmétodo Python para remover os zeros iniciais da bin(..)saída 0b e os zeros finais do número binário (pois eles sempre terão um bit correspondente).

Jonathan Frech
fonte
0

Pitão , 25 22 19 18 17 bytes

- 3 6 7 8 bytes, aprendendo mais o idioma

Ks_.Bsz&_IzqKs_`K

Explicação:

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

Estou certo de que isso pode ser resolvido, vou trabalhar nisso.

Suíte de teste

Stan Strum
fonte
0

PHP, 69 + 1 bytes

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

Executar como tubo com -nR
Echoes a entrada original para truthy / nothing for falsey

Experimente online!

Jo.
fonte
0

Oitava , 68 66 bytes

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

Experimente online!

Oferta inicial da Octave.

Basicamente, criamos uma matriz que contém o número como uma string decimal e o número como uma string binária com os 0's removidos. Em seguida, criamos uma matriz com as mesmas strings, mas com os números binários e decimais invertidos. Finalmente, as duas matrizes são comparadas e o resultado é verdadeiro se corresponderem (ambos os palíndromos) ou falso se não corresponderem (um ou ambos não palíndromos).


  • Salve 2 bytes usando em flipvez de fliplr.
Tom Carpenter
fonte
0

APL2 (não Dyalog), 36 bytes

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

Primeiro, seja B a representação de 32 bits de N:

B←(32⍴2)⊤N

Então espelhe B e encontre a posição do 1º 1:

(⌽B)⍳1

Em seguida, descarte muitas posições de B. Isso preservará o número correto de 0s iniciais.

Em seguida, execute FIND e OR-REDUCTION para ver se o B recortado contém seu próprio espelho.

Agora vamos olhar para N, o decimal. A expressão entre colchetes mais à esquerda converte N em um vetor de caracteres e verifica se corresponde ao seu próprio espelho.

Finalmente, um AND une as duas verificações.


No APL2, não posso criar uma lambda elegante, então escrevi uma linha e incluí a seta de atribuição. Espero que isso não seja trapaça.

mappo
fonte
11
Bem-vindo ao PPCG!
Martin Ender
Bem-vindo ao PPCG! Para uma versão menos trapaceira, você pode acrescentar um quad ( ) para torná-lo um programa completo? Além disso, você é capaz de reduzir para (N≡⌽N←⍕N)^∨/(B↓⍨1⍳⍨⌽B)⍷B←(32⍴2)⊤N←⎕?
Erik the Outgolfer
Erik, obrigado por verificar! Tenho certeza de que isso poderia ser melhorado, mas não tenho o ⍨ squiggle no APL2.
Map
0

Java 8, 105 104 bytes

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

Explicação:

Experimente aqui.

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
fonte