Напишите программу, которая читает из 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нет.

А вот и К:

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

• 0::'``- Считать в ( 0::) строку для каждой строки ( ') из консоли ( `это дескриптор файла для этого).
• .:'- Преобразуйте ( .:) каждую ( ') строку в число.
• _vs/|- Переверните пару чисел так, чтобы основание было перед числом, и затем вставьте ( /) базовую функцию расширения _vs(«вектор из скаляра») между ними.
• a~|a:- Присвойте это результирующее расширение a, а затем проверьте, соответствует ли amatch ( ~) его reverse ( |). Опять же, 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

APL (20)

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

Выходы 0или 1, например:

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

Объяснение:

• ⎕{... }⎕: прочитать два числа, передать их функции. ⍵это первое число и ⍺второе число.
• ⌊1+⍺⍟⍵: floor(1+⍺ log ⍵), количество цифр, необходимое для представления ⍵в базе ⍺.
• ⍺/⍨: база для каждой цифры, поэтому ⍺повторяется число, которое мы только что рассчитали.
• ⍵⊤⍨: представлять ⍵в заданной базе (используя числа, поэтому она работает для всех значений ⍺).
• ≡∘⌽⍨: посмотреть, равен ли результат обратному.

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когда не будет найден и палиндром ничего , если еще.

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

Примечание :

• $_ является текущим буфером строки и пуст в начале.
• $=является зарезервированной переменной, первоначально используемой для строчной печати, это счетчик строк. Таким образом, эта переменная является целым числом , любое вычисление этого приведет к усеченному целому числу, как если бы оно int()использовалось.
• $- был использован для развлечения, просто чтобы не использовать традиционные буквы ... (немного больше запутывания) ...

Mathematica 77 43

IntegerDigits[n,b]представляет n как список цифр в базе b. Каждая цифра base-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

вернется

Неверно (* (потому что {11, 13, 15, 11, 14, 1}! = {1, 14, 11, 15, 13, 11}) *)

True (* (потому что {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. Правда, когда число - палиндром, Ложь, если нет.

Рубин - 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 без стандартного ввода / вывода)

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, король читаемых гольфов (golves?) (А также некоторых не очень удобочитаемых).

Функция Perl 6 (без стандартного ввода / вывода), 22 байта

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

Попробуйте онлайн!

дг - 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

С 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 не поддерживается :)

Хаскелл - 59

Несколько изменений в ответе Макса Рида.

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

Pyth , 4 байта

_IjF

Попробуйте здесь или проверьте набор тестов (занимает ~ 10-15 секунд).

постоянный ток, 39 байт

Длина палиндрома, конечно ( 33₁₂).

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

Число и основание должны быть на вершине стека (в текущей базе номеров); число должно быть не менее 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