Scrivi un programma che legge dallo stdin due numeri interi, ciascuno con la nuova riga terminata, di seguito chiamato "numero" e "radix" e:

1. Consente di stampare qualsiasi messaggio fisso che si desidera se il numero è un palindromo in quella radice (ad esempio true, t, 1)
2. Consente di stampare qualsiasi messaggio fisso diverso che vuoi se il numero non è un palindromo in quella radice (ad esempio false, f, 0, etc.)
3. Questi messaggi devono essere gli stessi per ogni corsa, ma non ci sono regole su ciò che devono essere (qualunque sia la cosa migliore per il golf).
4. Si può presumere che l'input sia valido, due numeri interi positivi. "numero" non supererà 2147483647, "radix" non supererà 32767.
5. Non puoi utilizzare risorse esterne, ma puoi utilizzare qualsiasi funzione matematica inclusa per impostazione predefinita nella tua lingua.

Nota: una radice è solo la base del numero.

Esecuzioni campione:

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 caratteri) e K (19) doppia funzione

Le due lingue sono molto simili, sia in generale che in questo golf specifico. Ecco la J:

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

• ,~1- Aggiungi il numero 1 a se stesso, creando l'array 1 1.
• 1!:1- Leggi in due stringhe dalla tastiera ( 1!:1è da leggere, ed 1è l'handle / numero del file per l'input da tastiera).
• ". - Converti ogni stringa in un numero.
• #.^:_1~/- F~/ x,ysignifica trovare y F x. Il nostro Fè #.^:_1, che esegue l'espansione di base.
• (-:|.)- L'argomento match ( -:) è reverse ( |.)? 1per sì, 0per no.

Ed ecco la K:

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

• 0::'``- Leggi ( 0::) una stringa per ogni 'riga ( ) dalla console ( `è l'handle del file per questo).
• .:'- Converti ( .:) ogni ( ') stringa in un numero.
• _vs/|- Invertire la coppia di numeri, in modo che la radice sia davanti al numero, quindi inserire ( /) la funzione di espansione di base _vs("vettore dallo scalare") tra di loro.
• a~|a:- Assegna l'espansione risultante a a, quindi controlla se amatch ( ~) è il suo reverse ( |). Ancora una volta, 1per sì, 0per no.

GolfScript, 10 caratteri

~base.-1%=

Questo è facile per GolfScript se lo facciamo nel modo più semplice. L'output è 0/ 1per 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+⍺⍟⍵}⎕

Uscite 0o 1, ad esempio:

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

Spiegazione:

• ⎕{... }⎕: leggi due numeri, passali alla funzione. ⍵è il primo numero ed ⍺è il secondo numero.
• ⌊1+⍺⍟⍵: floor(1+⍺ log ⍵), numero di cifre necessarie per rappresentare ⍵in base ⍺.
• ⍺/⍨: la base per ogni cifra, quindi ⍺replicata dal numero che abbiamo appena calcolato.
• ⍵⊤⍨: rappresentano ⍵nella base data (usando i numeri, quindi funziona per tutti i valori di ⍺).
• ≡∘⌽⍨: vedi se il risultato è uguale al suo contrario.

Perl, 82 77 73 69 byte

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

I numeri di input sono previsti come righe di input di STDIN e il risultato è scritto come 1o 0, il primo significa che il primo numero è un palindromo nella sua rappresentazione della base data.

Modifica 1: L' uso $=salva alcuni byte, a causa della sua conversione interna in int.

Modifica 2: l'operatore smartmatch ~~confronta direttamente gli elementi dell'array, quindi non è necessaria la conversione in una stringa.

Modifica 3: ottimizzazione rimuovendo una variabile non necessaria.

65 byte : se la stringa vuota è consentita come output per false, gli ultimi quattro byte possono essere rimossi.

Versione Ungolfed

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

L'algoritmo memorizza le cifre del numero convertito in un array @a. Quindi la rappresentazione di stringa di questo array viene confrontata con l'array in ordine inverso. Gli spazi separano le cifre.

Javascript 87

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

nargomento è il numero, bargomento è la radice.

Salvia, 45 anni

Viene eseguito nel prompt interattivo

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

Stampa Truequando è un palindromo, stampa Falsealtrimenti

Perl 54 56 62

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

Essere testato:

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

Quindi questo output 1per truequando viene trovato un palindromo e nient'altro se non.

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 :

• $_ è il buffer di riga corrente ed è vuoto all'inizio.
• $=è una variabile riservata , originariamente utilizzata per la stampa di linee, questo è un contatore di linee. Quindi questa variabile è un numero intero , qualsiasi calcolo su questo comporterebbe un numero intero troncato come se int()fosse usato.
• $- è stato usato per divertimento, solo per non usare lettere tradizionali ... (un po 'più di offuscamento) ...

Mathematica 77 43

IntegerDigits[n,b]rappresenta n come un elenco di cifre nella base b. Ogni cifra di base b è espressa in modo decimale.

Ad esempio, 16781313 non è un palindromo nella base 17:

IntegerDigits[16781313, 17]

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

Tuttavia, è un palindromo nella base 16:

IntegerDigits[16781313, 16]

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

Se sono state inserite le coppie ordinate negli esempi precedenti,

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

sarebbe tornato

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

Vero (* (perché {1, 0, 0, 1, 0, 0, 1} è uguale a {1, 0, 0, 1, 0, 0, 1}) *)

Haskell (80 caratteri)

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

Chiamalo con pali $number $radix. Vero, quando il numero è un palindromo, falso in caso contrario.

Rubino - 76 caratteri

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 byte (22 senza stdin / out)

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

Provalo 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, re dei golf leggibili (golves?) (E anche alcuni non così leggibili).

Funzione Perl 6 (non stdin / stdout), 22 byte

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

Provalo online!

dg - 97 byte

Prova dg :

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

Ha spiegato:

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 non è supportato :)

Haskell - 59

Poche modifiche alla risposta di Max Ried.

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

Pyth , 4 byte

_IjF

Provalo qui o controlla una suite di test (dura circa 10-15 secondi).

dc, 39 byte

La lunghezza è ovviamente un palindromo ( 33₁₂).

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

Il numero e la radice dovrebbero essere in cima alla pila (nella base numerica corrente); il numero deve essere almeno 0 e radix deve essere almeno 2. L'output è tse è un palindromo e in fcaso contrario. Poiché non è specificato nella sfida, ho assunto che i numeri non abbiano mai zeri iniziali (quindi qualsiasi numero che termina in 0non può essere un palindromo).

Spiegazione

Come programma 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 byte

Esempio su desmos.com

k, il radix, è un input regolabile

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)

If f(x)=0, xè un palindromo in base k.

Perl 6 , 34 byte

-4 byte grazie a PhilH

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

Provalo online!

05AB1E ,  4  3 byte

вÂQ

Provalo online o verifica tutti i casi di test .

Spiegazione:

в      # 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 byte

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

Provalo online!

Corri giù

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.

Sulla base del fatto che per un palindromo, il retro del numero deve essere uguale al numero stesso.

Supponiamo di avere il numero di tre cifre ABC in qualche base. La moltiplicazione per base si tradurrà sempre in ABC0 e la divisione per base in AB con C come resto. Quindi per invertire il numero scegliamo la cifra più a destra dal numero originale e la inseriamo a destra nel numero invertito. Per fare spazio a quella cifra, moltiplichiamo prima il contrario per base.

Fondamentalmente:

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