Escreva um programa que leia a partir de stdin dois números inteiros, cada nova linha terminada, a seguir denominada "number" e "radix" e:

1. Imprime qualquer mensagem fixa que quiser, se o número é um palíndromo em que radix (por exemplo true, t, 1)
2. Imprime qualquer mensagem fixa diferente você quiser se o número não é um palíndromo em que radix (por exemplo false, f, 0, etc.)
3. Essas mensagens devem ser as mesmas a cada corrida, mas não há regras sobre o que devem ser (o que é melhor para o golfe).
4. Você pode assumir que a entrada é válida, dois números inteiros positivos. "number" não excederá 2147483647, "radix" não excederá 32767.
5. Você não pode usar recursos externos, mas pode usar qualquer função matemática incluída por padrão no seu idioma.

Nota: uma raiz é apenas a base do número.

Amostras de execuções:

16
10
false

16
3
true

16
20
true

121
10
true

5
5
false

12346
12345
true

16781313
64
true

16781313
16
true

Recurso duplo J (23 caracteres) e K (19)

As duas línguas são muito semelhantes, tanto em geral como neste golfe específico. Aqui está o J:

(-:|.)#.^:_1~/".1!:1,~1

• ,~1- Anexe o número 1 a si mesmo, criando a matriz 1 1.
• 1!:1- Leia em duas seqüências de caracteres do teclado ( 1!:1é para ler e 1é o identificador / número do arquivo para entrada do teclado).
• ". - Converta cada string em um número.
• #.^:_1~/- F~/ x,ysignifica encontrar y F x. Nosso Fé #.^:_1, que realiza a expansão da base.
• (-:|.)- O argumento corresponde ( -:) ao seu reverso ( |.)? 1para sim, 0para não.

E aqui está o K:

a~|a:_vs/|.:'0::'``

• 0::'``- Leia ( 0::) uma string para cada ( ') linha do console ( `é o identificador de arquivo para isso).
• .:'- Converter ( .:) cada 'sequência ( ) em um número.
• _vs/|- Inverta o par de números, para que a raiz fique na frente do número e insira ( /) a função de expansão base _vs("vetor do escalar") entre eles.
• a~|a:- Atribua essa expansão resultante a ae verifique se acorresponde ( ~) ao seu reverso ( |). Novamente, 1para sim, 0para não.

GolfScript, 10 caracteres

~base.-1%=

Isso é fácil para o GolfScript, se o fizermos da maneira direta. A saída é 0/ 1para false / true.

~       # Take input and evaluate it (stack: num rdx)
base    # Fortunately the stack is in the correct order for
        # a base transformation (stack: b[])
.       # Duplicate top of stack (stack: b[] b[])
-1%     # Reverse array (stack: b[] brev[])
=       # Compare the elements

APL (20)

⎕{≡∘⌽⍨⍵⊤⍨⍺/⍨⌊1+⍺⍟⍵}⎕

Saídas 0ou 1, por exemplo:

      ⎕{≡∘⌽⍨⍵⊤⍨⍺/⍨⌊1+⍺⍟⍵}⎕
⎕:
      5
⎕:
      5
0
      ⎕{≡∘⌽⍨⍵⊤⍨⍺/⍨⌊1+⍺⍟⍵}⎕
⎕:
      16781313
⎕:
      64
1

Explicação:

• ⎕{... }⎕: leia dois números, passe-os para a função. ⍵é o primeiro número e ⍺é o segundo número.
• ⌊1+⍺⍟⍵: floor(1+⍺ log ⍵), número de dígitos necessários para representar ⍵na base ⍺.
• ⍺/⍨: a base para cada dígito, ⍺replicada pelo número que acabamos de calcular.
• ⍵⊤⍨: representa ⍵na base fornecida (usando números, portanto, funciona para todos os valores de ⍺).
• ≡∘⌽⍨: veja se o resultado é igual ao seu reverso.

Perl, 82 77 73 69 bytes

$==<>;$.=<>;push(@a,$=%$.),$=/=$.while$=;@b=reverse@a;print@a~~@b?1:0

Os números de entrada são esperados como linhas de entrada do STDIN e o resultado é escrito como 1ou 0, o primeiro significa que o primeiro número é um palíndromo em sua representação da base fornecida.

Editar 1: Usar $=salva alguns bytes, devido à sua conversão interna em int.

Edit 2: O operador smartmatch ~~compara os elementos da matriz diretamente, portanto, a conversão para uma string não é necessária.

Edit 3: Otimização removendo uma variável desnecessária.

65 bytes : se a sequência vazia for permitida como saída false, os últimos quatro bytes poderão ser removidos.

Versão ungolfed

$= = <>;
$. = <>;
while ($=) {
    push(@a, $= % $.);
    $= /= $.; # implicit int conversion by $=
}
@b = reverse @a;
print (@a ~~ @b) ? 1 : 0

O algoritmo armazena os dígitos do número convertido em uma matriz @a. Em seguida, a representação de string dessa matriz é comparada com a matriz na ordem inversa. Espaços separa os dígitos.

Javascript 87

function f(n,b){for(a=[];n;n=(n-r)/b)a.push(r=n%b);return a.join()==a.reverse().join()}

nargumento é o número, bargumento é a raiz.

Sálvia, 45

Executa no prompt interativo

A=Integer(input()).digits(input())
A==A[::-1]

Imprime Truequando é um palíndromo, imprime de Falseoutra forma

Perl 54 56 62

$==<>;$-=<>;while($=){$_.=$/.chr$=%$-+50;$=/=$-}say$_==reverse

Para ser testado:

for a in $'16\n3' $'16\n10' $'12346\n12345' $'12346\n12346' $'21\n11' $'170\n16';do
    perl -E <<<"$a" ' 
        $==<>;$-=<>;while($=){$_.=$/.chr$=%$-+50;$=/=$-}say$_==reverse
    '
  done

darei:

1

1


1

Portanto, essa saída é 1para truequando um palíndromo é encontrado e nada mais.

Ungolfing:

$==<>;                            # Stdin to `$=`  (value)
$-=<>;                            # Stdin to `$-`  (radix)
while ( $= ) {
    $_.= $/. chr ( $= % $- +50 ); # Add *separator*+ chr from next modulo to radix to `$_`
    $=/= $-                       # Divide value by radix
}
say $_ == reverse                 # Return test result

Nota :

• $_ é o buffer de linha atual e está vazio no início.
• $=é uma variável reservada , originalmente usada para impressão em linha, este é um contador de linha. Portanto, essa variável é um número inteiro , qualquer cálculo sobre isso resultaria em um número inteiro truncado como se int()fosse usado.
• $- foi usado para se divertir, só para não usar letras tradicionais ... (um pouco mais ofuscação) ...

Mathematica 77 43

IntegerDigits[n,b]representa n como uma lista de dígitos na base b. Cada dígito da base-b é expresso decimalmente.

Por exemplo, 16781313 não é um palíndromo na base 17:

IntegerDigits[16781313, 17]

{11, 13, 15, 11, 14, 1}

No entanto, é um palíndromo na base 16:

IntegerDigits[16781313, 16]

{1, 0, 0, 1, 0, 0, 1}

Se os pares ordenados nos exemplos acima foram inseridos,

(x=Input[]~IntegerDigits~Input[])==Reverse@x

retornaria

Falso (* (porque {11, 13, 15, 11, 14, 1}! = {1, 14, 11, 15, 13, 11}) *)

Verdadeiro (* (porque {1, 0, 0, 1, 0, 0, 1} é igual a {1, 0, 0, 1, 0, 0, 1}) *)

Haskell (80 caracteres)

tb 0 _=[]
tb x b=(tb(div x b)b)++[mod x b]
pali n r=(\x->(x==reverse x))(tb n r)

Ligue com pali $number $radix. Verdadeiro, quando número é um palíndromo, Falso, se não.

Ruby - 76 caracteres

f=->(n,b){n==0?[]:[n%b,*f.(n/b,b)]};d=f.(gets.to_i,gets.to_i);p d==d.reverse

Perl 6 , 27 bytes (22 sem stdin / out)

say (+get).base(get)~~.flip

Experimente online!

  get()                     # pulls a line of stdin
 +                          # numerificate
(      ).base(get())        # pull the radix and call base to 
                            #  convert to string with that base
                    ~~      # alias LHS to $_ and smartmatch to
                      .flip # reverse of the string in $_

Perl6, rei dos golfe legíveis (giros?) (E também alguns não tão legíveis).

Função Perl 6 (não stdin / stdout), 22 bytes

{$^a.base($^b)~~.flip}

Experimente online!

dg - 97 bytes

Experimentando dg :

n,r=map int$input!.split!
a=list!
while n=>
 a.append$chr(n%r)
 n//=r
print$a==(list$reversed a)

Explicado:

n, r=map int $ input!.split!      # convert to int the string from input
a = list!                         # ! calls a function without args
while n =>
 a.append $ chr (n % r)           # append the modulus
 n //= r                          # integer division
print $ a == (list $ reversed a)  # check for palindrome list

C, 140 132

int x,r,d[32],i=0,j=0,m=1;main(){scanf("%d %d",&x,&r);for(;x;i++)d[i]=x%r,x/=r;i--;for(j=i;j;j--)if(d[j]-d[i-j])m=0;printf("%d",m);}

• radix 1 não é suportado :)

Haskell - 59

Poucas alterações na resposta de Max Ried.

0%_=[]
x%b=x`mod`b:((x`div`b)%b)
p=((reverse>>=(==)).).(%)

Pitão , 4 bytes

_IjF

Experimente aqui ou confira uma suíte de testes (leva de 10 a 15 segundos).

dc, 39 bytes

O comprimento é um palíndromo, é claro ( 33₁₂).

[[t]pq]sgod[O~laO*+sad0<r]dsrx+la=g[f]p

O número e a raiz devem estar no topo da pilha (na base numérica atual); número deve ser pelo menos 0 e raiz deve ser pelo menos 2. Saída é tse for um palíndromo e fse não for. Como não está especificado no desafio, presumi que os números nunca tenham zeros à esquerda (portanto, qualquer número terminado em 0não pode ser um palíndromo).

Explicação

Como um programa completo:

#!/usr/bin/dc

# read input
??

# success message
[[t]pq]sg

# set output radix
o

# keep a copy unmodified
d

# reverse the digits into register a
[O~ laO*+sa d0<r]dsrx

# eat the zero left on stack, and compare stored copy to a
+ la=g

# failure message
[f]p

LaTeX, 165 bytes

Exemplo em desmos.com

k, o radical, é uma entrada ajustável

b=\floor \left(\log _k\left(\floor \left(x\right)\right)\right)
f\left(x\right)=k^bx-x-\left(k^2-1\right)\sum _{n=1}^bk^{\left(b-n\right)}\floor \left(xk^{-n}\right)

Se f(x)=0, xé um palíndromo na base k.

Perl 6 , 34 bytes

-4 bytes graças a PhilH

{@(polymod $^a: $^b xx*)~~[R,] $_}

Experimente online!

05AB1E ,  4  3 bytes

вÂQ

Experimente online ou verifique todos os casos de teste .

Explicação:

в      # The first (implicit) input converted to base second (implicit) input
       #  i.e. 12345 and 12346 → [1,1]
       #  i.e. 10 and 16 → [1,6]
 Â     # Bifurcate the value (short for duplicate & reverse)
       #  i.e. [1,1] → [1,1] and [1,1]
       #  i.e. [1,6] → [1,6] and [6,1]
  Q    # Check if they are still the same, and thus a palindrome
       #  i.e. [1,1] and [1,1] → 1
       #  i.e. [1,6] and [6,1] → 0

C (gcc) , 79 bytes

n,r,m;main(o){for(scanf("%d %d",&n,&r),o=n;n;n/=r)m=m*r+n%r;printf("%d",m==o);}

Experimente online!

Atropelar

n,r,m;main(o){
for(scanf("%d %d",&n,&r),       Read the number and the radix.
o=n;                            ...and save the number in o
n;                              Loop while n is non-zero
n/=r)                           Divide by radix to remove right-most digit.
m=m*r+n%r;                      Multiply m by radix to make room for a digit
                                and add the digit.
printf("%d",m==o);}             Print whether we have a palindrome or not.

Com base no fato de que para um palíndromo, o reverso do número deve ser igual ao próprio número.

Suponha que você tenha o número de três dígitos ABC em alguma base. Multiplicá-lo pela base sempre resultará em ABC0 e dividi-lo pela base em AB com C como restante. Portanto, para reverter o número, selecionamos o dígito mais à direita do número original e o inserimos à direita no número invertido. Para abrir espaço para esse dígito, multiplicamos o reverso pela base com antecedência.

Basicamente:

n       rev
ABC     0
AB      C
AB      C0
A       CB
A       CB0
0       CBA