编写一个程序，从stdin读取两个整数，每个换行符终止，以下称为“ number”和“ radix”，并且：

1. 打印你想，如果数字是在基数回文任何固定的消息（例如true，t，1）
2. 打印你想，如果数字是不是在基数回文（例如，任何不同的固定信息false，f，0等）
3. 这些信息在每次跑步时都必须相同，但是没有关于它们必须是什么的规则（最好是打高尔夫球的规则）。
4. 您可以假设输入有效，两个正整数。“数字”不超过2147483647，“基数”不超过32767。
5. 您可能不会使用外部资源，但可能会使用语言默认包含的任何数学函数。

注意： 基数只是数字的基数。

样品运行：

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个字符）和K（19）双重功能

总体而言和特定的高尔夫运动中，两种语言非常相似。这是J：

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

• ,~1-将数字1附加到其自身，形成数组1 1。
• 1!:1-从键盘读取两个字符串（1!:1是要读取的，1是键盘输入的文件句柄/编号）。
• ". -将每个字符串转换为数字。
• #.^:_1~/- F~/ x,y意味着寻找y F x。我们的F是#.^:_1，它执行基本扩展。
• (-:|.)-参数是否匹配（-:）其反向（|.）？1是的，0没有。

这是K：

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

• 0::'``- 从控制台中的0::每一'行（）读入（）字符串（`是此文件的句柄）。
• .:'-将（.:）每个（'）字符串转换为数字。
• _vs/|-反转数字对，使基数位于数字的前面，然后在它们之间插入（/）基本展开函数_vs（“标量向量”）。
• a~|a:-将此结果扩展分配给a，然后检查其反向（）是否a匹配~（|）。再一次，1是的，0不是的。

GolfScript，10个字符

~base.-1%=

如果我们以简单的方式进行操作，那么对于GolfScript来说这是一个简单的方法。输出为0/ 1，代表假/真。

~       # 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

杀伤人员地雷（20）

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

输出0或1，例如：

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

说明：

• ⎕{... }⎕：读取两个数字，并将它们传递给函数。⍵是第一个数字，⍺是第二个数字。
• ⌊1+⍺⍟⍵：floor(1+⍺ log ⍵)，⍵以base 为单位表示所需的位数⍺。
• ⍺/⍨：每个数字的基数，因此⍺可以根据我们刚才计算的数字进行复制。
• ⍵⊤⍨：⍵以给定的基数表示（使用数字，因此适用于的所有值⍺）。
• ≡∘⌽⍨：查看结果是否等于其倒数。

Perl，82 77 73 69字节

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

输入数字应作为STDIN的输入行，结果写为1或0，前者表示第一个数字在表示给定碱基时是回文。

编辑1：使用$=节省一些字节，因为它内部转换为int。

编辑2： smartmatch运算符~~直接比较数组元素，因此不需要转换为字符串。

编辑3：通过删除不必要的变量进行优化。

65个字节：如果允许将空字符串作为输出false，则可以删除最后四个字节。

非高尔夫版本

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

该算法将转换后的数字的数字存储在数组中@a。然后将此数组的字符串表示形式与该数组的反向顺序进行比较。用空格分隔数字。

Javascript 87

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

n参数是数字，b参数是基数。

贤者，45

在交互式提示中运行

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

打印True时，它是一个回文，打印False，否则

Perl 54 56 62

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

要测试：

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

会给：

1

1


1

因此，此输出1用于true找到回文的时间，如果没有其他则什么也没有。

开球：

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

注意：

• $_ 是当前行缓冲区，开始时为空。
• $=是保留的变量，最初用于行打印，这是行计数器。因此，此变量是一个整数，对此进行的任何计算都会导致截断的整数，例如if int()。
• $- 被用来娱乐，只是不使用传统字母...（有些混淆）...

Mathematica 77 43

IntegerDigits[n,b]将n表示为以b为底的数字列表。每个基数b位数都用十进制表示。

例如，16781313不是以17为底的回文：

IntegerDigits[16781313, 17]

{11、13、15、11、14、1}

但是，这是基于16的回文。

IntegerDigits[16781313, 16]

{1，0，0，1，0，0，1}

如果输入了上述示例中的有序对，

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

会回来

False（*（因为{11，13，15，11，14，1}！= {1，14，11，15，13，11}）*）

真（*（因为{1、0、0、1、0、0、1}等于{1、0、0、1、0、0、1}）*）

Haskell（80个字符）

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

用调用pali $number $radix。如果数字是回文，则为true，否则为False。

红宝石-76个字符

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个字节（22个不带stdin / out）

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

在线尝试！

  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，可读高尔夫之王（手套？）（还有一些可读性不强）。

Perl 6函数（不是stdin / stdout），22个字节

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

在线尝试！

dg-97个字节

试用dg：

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

解释：

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

• 不支持基数1 ：）

哈斯克尔-59

几乎没有改变Max Ried的答案。

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

Pyth，4个字节

_IjF

在这里尝试或查看测试套件（大约需要10-15秒）。

dc，39个字节

长度当然是回文33₁₂。

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

数字和基数应位于堆栈的顶部（以当前数字为准）；number必须至少为0，并且基数必须至少为2。输出是t回文，f如果不是，则为。正如挑战中未指定的那样，我已经假设数字永远不会有前导零（因此，任何以结尾结尾的数字0都不能是回文）。

说明

作为完整程序：

#!/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个字节

在desmos.com上的示例

k基数是可调输入

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)

如果f(x)=0，x是在基地回文k。

Perl 6，34个字节

-4字节归功于PhilH

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

在线尝试！

05AB1E， 4  3 字节

вÂQ

在线尝试或验证所有测试用例。

说明：

в      # 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字节

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

在线尝试！

撞倒

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.

基于回文的事实，数字的倒数必须等于数字本身。

假设您以某个底数为三位数字ABC。将其乘以基数将始终得到ABC0，然后将其除以AB中的基数，其余为C。因此，要反转数字，我们从原始数字中选出最右边的数字，然后将其插入到反转数字的右侧。为了给该数字腾出空间，我们预先将反向乘以基数。

基本上：

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