Escriba un programa que lea de stdin dos enteros, cada línea nueva terminada, en lo sucesivo denominada "número" y "raíz", y:

1. Imprime cualquier mensaje fijo que desea si el número es un palíndromo en el que la base (por ejemplo true, t, 1)
2. Imprime cualquier mensaje fijo diferente que desea si el número no es un palíndromo en el que la base (por ejemplo false, f, 0, etc.)
3. Estos mensajes deben ser los mismos para cada carrera, pero no hay reglas sobre lo que deben ser (lo que sea mejor para jugar al golf).
4. Puede suponer que la entrada es válida, dos enteros positivos. "número" no excederá 2147483647, "radix" no excederá 32767.
5. No puede usar recursos externos, pero puede usar cualquier función matemática incluida por defecto en su idioma.

Nota: una raíz es solo la base del número.

Ejecuciones de muestra:

16
10
false

16
3
true

16
20
true

121
10
true

5
5
false

12346
12345
true

16781313
64
true

16781313
16
true

J (23 caracteres) y K (19) doble función

Los dos idiomas son muy similares, tanto en general como en este golf específico. Aquí está la J:

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

• ,~1- Agregue el número 1 a sí mismo, haciendo la matriz 1 1.
• 1!:1- Leer en dos cadenas desde el teclado ( 1!:1es para leer, y 1es el identificador / número de archivo para la entrada del teclado).
• ". - Convierte cada cadena en un número.
• #.^:_1~/- F~/ x,ysignifica encontrar y F x. Nuestro Fes #.^:_1, que realiza la expansión de base.
• (-:|.)- ¿El argumento coincide ( -:) con su reverso ( |.)? 1por si, 0por no.

Y aquí está la K:

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

• 0::'``- Lea en ( 0::) una cadena para cada ( ') línea de la consola ( `es el identificador de archivo para esto).
• .:'- Convierta ( .:) cada ( ') cadena en un número.
• _vs/|- Invierta el par de números, de modo que la raíz esté delante del número, y luego inserte ( /) la función de expansión de base _vs("vector de escalar") entre ellos.
• a~|a:- Asigne esta expansión resultante a a, y luego verifique si acoincide ( ~) con su inverso ( |). De nuevo, 1por sí, 0por no.

GolfScript, 10 caracteres

~base.-1%=

Es fácil para GolfScript si lo hacemos de manera directa. La salida es 0/ 1para falso / verdadero.

~       # 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+⍺⍟⍵}⎕

Salidas 0o 1, por ejemplo:

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

Explicación:

• ⎕{... }⎕: lee dos números, pásalos a la función. ⍵es el primer número y ⍺es el segundo número.
• ⌊1+⍺⍟⍵: floor(1+⍺ log ⍵), número de dígitos necesarios para representar ⍵en la base ⍺.
• ⍺/⍨: la base para cada dígito, ⍺replicado por el número que acabamos de calcular.
• ⍵⊤⍨: representa ⍵en la base dada (usando números, por lo que funciona para todos los valores de ⍺).
• ≡∘⌽⍨: ver si el resultado es igual a su reverso.

Perl, 82 77 73 69 bytes

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

Los números de entrada se esperan como líneas de entrada de STDIN y el resultado se escribe como 1o 0, el primero significa que el primer número es un palíndromo en su representación de la base dada.

Edición 1: el uso $=guarda algunos bytes, debido a su conversión interna a int.

Edición 2: el operador smartmatch ~~compara los elementos de la matriz directamente, por lo que no es necesaria la conversión a una cadena.

Edición 3: optimización mediante la eliminación de una variable innecesaria.

65 bytes : si la cadena vacía se permite como salida para false, los últimos cuatro bytes se pueden eliminar.

Versión sin golf

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

El algoritmo almacena los dígitos del número convertido en una matriz @a. Luego, la representación de cadena de esta matriz se compara con la matriz en orden inverso. Los espacios separan los 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 es el número, bargumento es la raíz.

Sabio, 45

Se ejecuta en el mensaje interactivo

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

Imprime Truecuando es un palíndromo, imprime lo Falsecontrario

Perl 54 56 62

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

Para ser probado:

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

daré:

1

1


1

Entonces esta salida 1para truecuando se encuentra un palíndromo y nada más.

No golfista:

$==<>;                            # 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 :

• $_ es el búfer de línea actual y está vacío al comienzo.
• $=es una variable reservada , utilizada originalmente para la impresión de líneas, es un contador de líneas. Entonces, esta variable es un número entero , cualquier cálculo en esto daría como resultado un número entero truncado como si int()se usara.
• $- se usaba por diversión, solo para no usar letras tradicionales ... (algo más de ofuscación) ...

Mathematica 77 43

IntegerDigits[n,b]representa n como una lista de dígitos en la base b. Cada dígito base-b se expresa decimalmente.

Por ejemplo, 16781313 no es un palíndromo en la base 17:

IntegerDigits[16781313, 17]

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

Sin embargo, es un palíndromo en la base 16:

IntegerDigits[16781313, 16]

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

Si se introdujeron los pares ordenados en los ejemplos anteriores,

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

volvería

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

Verdadero (* (porque {1, 0, 0, 1, 0, 0, 1} es 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)

Llámalo con pali $number $radix. Es cierto, cuando el número es un palíndromo, falso si no.

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 sin stdin / out)

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

Pruébalo en línea!

  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, rey de los campos de golf legibles (¿golves?) (Y también algunos no tan legibles).

Función Perl 6 (no stdin / stdout), 22 bytes

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

Pruébalo en línea!

dg - 97 bytes

Probar 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 no es compatible :)

Haskell - 59

Pocos cambios en la respuesta de Max Ried.

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

Pyth , 4 bytes

_IjF

Pruébelo aquí o eche un vistazo a un conjunto de pruebas (tarda unos 10-15 segundos).

cc, 39 bytes

La longitud es un palíndromo, por supuesto ( 33₁₂).

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

El número y la raíz deben estar en la parte superior de la pila (en la base de números actual); el número debe ser al menos 0 y la raíz debe ser al menos 2. La salida es tsi es un palíndromo y fsi no. Como no se especifica en el desafío, asumí que los números nunca tienen ceros a la izquierda (por lo que cualquier número que termine en 0no puede ser un palíndromo).

Explicación

Como un 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

Ejemplo en desmos.com

k, la raíz, es una entrada ajustable

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)

Si f(x)=0, xes un palíndromo en la base k.

Perl 6 , 34 bytes

-4 bytes gracias a PhilH

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

Pruébalo en línea!

05AB1E ,  4  3 bytes

вÂQ

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Pruébalo en línea!

En mal estado

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.

Basado en el hecho de que para un palíndromo, el reverso del número debe ser igual al número mismo.

Suponga que tiene el número ABC de tres dígitos en alguna base. Multiplicarlo por base siempre dará como resultado ABC0, y dividirlo por base en AB con C como resto. Entonces, para invertir el número, seleccionamos el dígito más a la derecha del número original y lo insertamos a la derecha en el número invertido. Para hacer espacio para ese dígito, multiplicamos el reverso por la base de antemano.

Básicamente:

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