Écrivez un programme qui lit depuis stdin deux entiers, chaque nouvelle ligne se terminant, ci-après appelé "nombre" et "radix", et:

1. Imprime tout message fixe que vous voulez si le nombre est un palindrome dans ce radix (par exemple true, t, 1)
2. Imprime différent message fixe que vous voulez si le numéro est un palindrome dans cette radix (par exemple false, f, 0, etc.)
3. Ces messages doivent être les mêmes pour chaque course, mais il n'y a pas de règles sur ce qu'ils doivent être (ce qui est le mieux pour le golf).
4. Vous pouvez supposer que l'entrée est valide, deux entiers positifs. "nombre" ne dépassera pas 2147483647, "radix" ne dépassera pas 32767.
5. Vous ne pouvez pas utiliser de ressources externes, mais vous pouvez utiliser n'importe quelle fonction mathématique incluse par défaut dans votre langue.

Remarque: un radix n'est que la base du nombre.

Exemples de cycles:

16
10
false

16
3
true

16
20
true

121
10
true

5
5
false

12346
12345
true

16781313
64
true

16781313
16
true

Double fonction J (23 caractères) et K (19)

Les deux langues sont très similaires, à la fois en général et dans ce golf spécifique. Voici le J:

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

• ,~1- Ajoutez le numéro 1 à lui-même, ce qui rend le tableau 1 1.
• 1!:1- Lire en deux chaînes à partir du clavier ( 1!:1est à lire, et 1est le descripteur / numéro de fichier pour la saisie au clavier).
• ". - Convertissez chaque chaîne en nombre.
• #.^:_1~/- F~/ x,ysignifie trouver y F x. Notre Fest #.^:_1, qui effectue l'expansion de la base.
• (-:|.)- L'argument correspond-il à ( -:) son inverse ( |.)? 1pour oui, 0pour non.

Et voici le K:

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

• 0::'``- Lisez dans ( 0::) une chaîne pour chaque 'ligne ( ) de la console ( `est le descripteur de fichier pour cela).
• .:'- Convertissez ( .:) chaque 'chaîne ( ) en nombre.
• _vs/|- Inversez la paire de nombres, de sorte que le radix soit devant le nombre, puis insérez ( /) la fonction d'expansion de base _vs("vecteur de scalaire") entre eux.
• a~|a:- Attribuez cette extension résultante à a, puis vérifiez si acorrespond ( ~) à son inverse ( |). Encore une fois, 1pour oui, 0pour non.

GolfScript, 10 caractères

~base.-1%=

C'est facile pour GolfScript si nous le faisons de manière simple. La sortie est 0/ 1pour 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+⍺⍟⍵}⎕

Sorties 0ou 1, par exemple:

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

Explication:

• ⎕{... }⎕: lisez deux nombres, passez-les à la fonction. ⍵est le premier nombre et ⍺le deuxième nombre.
• ⌊1+⍺⍟⍵: floor(1+⍺ log ⍵), nombre de chiffres nécessaires pour représenter ⍵en base ⍺.
• ⍺/⍨: la base de chaque chiffre, donc ⍺répliquée par le nombre que nous venons de calculer.
• ⍵⊤⍨: représenter ⍵dans la base donnée (en utilisant des nombres, donc cela fonctionne pour toutes les valeurs de ⍺).
• ≡∘⌽⍨: voir si le résultat est égal à son inverse.

Perl, 82 77 73 69 octets

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

Les nombres entrés sont attendus comme des lignes d'entrée de STDIN et le résultat est écrit comme 1ou 0, le premier signifiant que le premier nombre est un palindrome dans sa représentation de la base donnée.

Edit 1: Using $=enregistre quelques octets, en raison de sa conversion interne en int.

Edit 2: l' opérateur smartmatch ~~compare directement les éléments du tableau, ainsi la conversion en chaîne n'est pas nécessaire.

Edit 3: Optimisation en supprimant une variable inutile.

65 octets : si la chaîne vide est autorisée comme sortie pour false, les quatre derniers octets peuvent être supprimés.

Version non golfée

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

L'algorithme stocke les chiffres du nombre converti dans un tableau @a. Ensuite, la représentation sous forme de chaîne de ce tableau est comparée au tableau dans l'ordre inverse. Des espaces séparent les chiffres.

Javascript 87

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

nargument est le nombre, bargument est le radix.

Sauge, 45

S'exécute dans l'invite interactive

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

Imprime Truelorsqu'il s'agit d'un palindrome, imprime Falseautrement

Perl 54 56 62

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

Être testé:

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

va donner:

1

1


1

Donc, cette sortie 1pour truequand un palindrome est trouvé et rien d' autre.

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 :

• $_ est le tampon de ligne actuel et est vide au début.
• $=est une variable réservée , utilisée à l'origine pour l'impression de lignes, c'est un compteur de lignes. Donc, cette variable est un entier , tout calcul à ce sujet entraînerait un entier tronqué comme s'il int()était utilisé.
• $- a été utilisé pour le plaisir, juste pour ne pas utiliser les lettres traditionnelles ... (un peu plus d'obscurcissement) ...

Mathematica 77 43

IntegerDigits[n,b]représente n comme une liste de chiffres dans la base b. Chaque chiffre de base b est exprimé de manière décimale.

Par exemple, 16781313 n'est pas un palindrome en base 17:

IntegerDigits[16781313, 17]

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

Cependant, il est un palindrome en base 16:

IntegerDigits[16781313, 16]

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

Si les paires ordonnées dans les exemples ci-dessus ont été saisies,

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

retournerais

Faux (* (car {11, 13, 15, 11, 14, 1}! = {1, 14, 11, 15, 13, 11}) *)

Vrai (* (car {1, 0, 0, 1, 0, 0, 1} est égal à {1, 0, 0, 1, 0, 0, 1}) *)

Haskell (80 caractères)

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

Appelez-le avec pali $number $radix. Vrai, lorsque le nombre est un palindrome, Faux sinon.

Rubis - 76 caractères

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 octets (22 sans stdin / out)

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

Essayez-le en ligne!

  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, roi des golfs lisibles (golfeurs?) (Et aussi certains pas si lisibles).

Fonction Perl 6 (pas stdin / stdout), 22 octets

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

Essayez-le en ligne!

dg - 97 octets

Essayer dg :

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

Expliqué:

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'est pas pris en charge :)

Haskell - 59

Peu de changements dans la réponse de Max Ried.

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

Pyth , 4 octets

_IjF

Essayez-le ici ou consultez une suite de tests (prend environ 10 à 15 secondes).

dc, 39 octets

La longueur est bien sûr un palindrome ( 33₁₂).

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

Le numéro et le radix doivent se trouver en haut de la pile (dans la base numérique actuelle); le nombre doit être d'au moins 0 et le radix doit être d'au moins 2. La sortie est tsi c'est un palindrome et fsinon. Comme cela n'est pas spécifié dans le défi, j'ai supposé que les nombres n'ont jamais de zéros en tête (donc tout nombre se terminant par 0ne peut pas être un palindrome).

Explication

En programme complet:

#!/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 octets

Exemple sur desmos.com

k, le radix, est une entrée réglable

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, xest un palindrome de base k.

Perl 6 , 34 octets

-4 octets grâce à PhilH

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

Essayez-le en ligne!

05AB1E ,  4  3 octets

вÂQ

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

Fatigué

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.

Basé sur le fait que pour un palindrome, l'inverse du nombre doit être égal au nombre lui-même.

Supposons que vous ayez le numéro à trois chiffres ABC dans une base. En le multipliant par la base, vous obtiendrez toujours ABC0 et en le divisant par la base en AB avec C comme reste. Donc, pour inverser le nombre, nous choisissons le chiffre le plus à droite du numéro d'origine et l'insérons à droite sur le nombre inversé. Pour faire de la place à ce chiffre, nous multiplions l'inverse par la base au préalable.

Fondamentalement:

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