Напишите короткую программу по 196-му алгоритму . Алгоритм начинается с целого числа, а затем добавляет обратный к нему, пока не будет достигнут палиндром.

например

input = 5280
5280 + 0825 = 6105
6105 + 5016 = 11121
11121 + 12111 = 23232
output = 23232

вход

целое число, которое не является числом Лирхрела (то есть, оно в конечном итоге дает палиндром по этому алгоритму, а не продолжается бесконечно)

Выход

палиндром достиг.

APL (22 символа)

{a≡⌽a←⍕(⍎⍵)+⍎⌽⍵:a⋄∇a}⍞

Это работает в Dyalog APL. Вот объяснение справа налево:

• { ... }⍞: Получить ввод от пользователя в виде символов ( ⍞) и передать его нашей функции ( { ... }).
• Внутри прямой функции ( ⋄разделяет операторы, поэтому мы смотрим на них слева направо):
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: Оцените ( ⍎) правильный аргумент ( ⍵) reverse ( ⌽) и добавьте его в оценочную версию самого правильного аргумента. Затем отформатируйте результат ( ⍕т. Е. Задайте его символьное представление), присвойте ←его переменной a() и, наконец, проверьте, aэквивалентен ли обратный результат a(т. Е. Является aли палиндром?). Если это правда, вернуть a; иначе...
  • ∇a: aОбратная связь с нашей функцией ( ∇неявная ссылка на себя).

Пример:

      {a≡⌽a←⍕(⍎⍵)+⍎⌽⍵:a⋄∇a}⍞
412371
585585

GolfScript, 29 символов

~]{{.`.-1%.@={;0}{~+1}if}do}%

Выбранный комментарий

Мясо программы - это do, конечно, петля. Так что я просто расскажу об этом.

1. .` копирует число и делает его строковым
2. .-1% копирует эту строковую версию и переворачивает ее.
3. .@ копирует обратную версию и переносит оригинальную не полностью измененную версию на передний план.

Так, например, число 5280. На этом этапе, стек: 5280 "0825" "0825" "5280". Этап настроен для сравнения. (После сравнения стопка будет оставлена 5280 "0825"вне зависимости от того, какие --- элементы для сравнения были удалены.)

1. Если строка и обратное совпадают, нам не нужна перевернутая строка, поэтому просто вытолкните ее ( ;) и верните 0 (чтобы завершить doцикл).
2. Если они не совпадают, то оцените ( ~) обратную строку (чтобы сделать ее числом), добавьте ( +) это к исходному номеру и верните 1 (чтобы продолжить doцикл).

Python 2, 55 байт

Следующее предложение JPvdMerwe:

n=input()
while`n`!=`n`[::-1]:n+=int(`n`[::-1])
print n

Python 2, 62:

n=raw_input()
while n!=n[::-1]:n=`int(n)+int(n[::-1])`
print n

Рубин - 56 символов

x,r=gets
x="#{x.to_i+r.to_i}"until x==r=x.reverse
puts x

Просто тренирую свои навыки Pyth, а не серьезного соперника.

Pyth, 16 байт

L?bqb_by`+vbi_bTyz

Эквивалент Python 3:

y=lambda b:b if b==b[::-1] else y(str(eval(b)+int(b[::-1],10)))
print y(input())

J 25 ^{27 31}

f=:(+g)^:(~:g=.|.&.":)^:_
e.g.
f 5280
23232

CJam, 22 21 байт

CJam был создан после того, как был задан этот вопрос, поэтому технически это неверное представление. Но я нашел вопрос интересным, так что здесь идет:

r{__W%:X=0{~X~+s1}?}g

Объяснение:

r{                 }g    "Read the input number as string and enter a while-do loop";
  __                     "Make 2 copies of the string number";
    W%:X                 "Reverse the second and store it in X";
        =                "Check if the number is already palindrome";
         0{      }?      "Put 0 on stack if it is palindrome, else, run the code block";
           ~             "Convert the string to int";
            X~           "Put the reverse string on stack and convert it to int too";
              +s         "Add the two numbers and covert back the result to string";

Основная логика заключается в том, что на каждой итерации while вы сначала проверяете, достигнут ли палиндром или нет. Если нет, добавьте обратный номер. Довольно много, что алгоритм!

Попробуйте онлайн здесь

Это реальный соперник, так как J существует уже несколько десятилетий.

J (16 байт)

(+^:~:|.&.":)^:_

Это глагол, поэтому его можно присвоить переменной в сеансе J и использовать следующим образом:

   f =. (+^:~:|.&.":)^:_
   f 5280
23232

Как это работает:

(+^:~:|.&.":)^:_
 +^:~:           add if unequal
      |.&.":     reverse under string format
 +^:~:|.&.":     add reverse unless a palindrome
(           )^:_ repeat until unchanged

Python: 66

n=input()
while 1:
 r=int(`n`[::-1])
 if n==r:break
 n+=r
print n

Perl, 40 символов

$_=<>;$_+=$r while$_!=($r=reverse);print

Скала 82

def p(n:Int):Int={val s=n.toString.reverse.toInt
if(n==s)n else p(n+s)}
p(readInt)

JAGL Alpha 1.2 - 19, 21 со стандартным

Не спорю , просто получаю некоторый опыт работы с моим языком
Ожидает число от stdin

T~d{DddgCi+dgdC=n}uSP

объяснение

T~                       Get a line of input, and eval to an integer
  d                      Duplicate (for first round)
   {Ddd                  Drop last and duplicate twice
       gCi               Convert to string, reverse, and convert back to integer
          +d             Add to original and duplicate
            gdC          Convert to string, duplicate, reverse
               =n}       If it isn't a palindrome, keep going
                  uSP    Run until palindrome reached, then print output number

05AB1E , 7 байтов (не конкурирует)

Не конкурирует , так как язык задним числом.

Код:

[DÂQ#Â+

Объяснение:

[        # Infinite loop.
 DÂ      # Duplicate and bifurcate (which duplicates it and reverses the duplicate).
   Q#    # If the number and the number reversed are equal, break.
     Â+  # Add the reversed number to the initial number.

Использует кодировку CP-1252 . Попробуйте онлайн! ,

Брахилог , 8 байт

↔?|↔;?+↰

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

Несколько похоже на одну из первых программ на брахилоге, которую я видел и был заинтригован из вступительного видео на брахилоге .

?↔?.|↔;?+↰.  (initial ? and the .s are implicit)

?↔?          % If the input and its reverse are the same,
   .         %   then the input is the output
    |↔;?+↰   % Or, add the input and its reverse, and call this predicate recursively
          .  % The result of that is the output

PHP - 54 48 символов

<?for($s=`cat`;$s!=$r=strrev($s);$s+=$r);echo$s;

Тест:

$ php 196.php <<< 5280
23232

Баш (64)

X=`rev<<<$1|sed s/^0*//`;[ $1 = $X ]&&echo $1||. $0 $(($1+$X))

Вызов с: bash <имя файла> <номер>

C # - 103 99 символов

public int P(int i)
{
    var r = int.Parse(new string(i.ToString().Reverse().ToArray())));
    return r == i ? i : P(i + r);        
}

C # никогда не преуспевает в гольфе. Элегантно, но многословно.

В Q (39 символов)

f:{while[x<>g:"I"$reverse -3!x;x+:g];x}

Пример использования:

q)f 5280
23232

Редактировать:

До 34 сейчас, то же использование:

{while[x<>g:"I"$(|) -3!x;x+:g];x} 5280

r=input()
while 1:
    r=`r`
    if r==r[::-1]:
      break
    else:
      r=int(r)+int(r[::-1])

print r

Желе , 9 байт (не конкурирует)

Очень простой ответ, просто для задачи кодирования на эзотерическом языке.

ṚḌ+µŒḂ¬$¿

ṚḌ        : take the argument, reverse (and vectorize) it
  +µ      : add both
    ŒḂ¬$¿ : while the result isn't a palindrome

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

Если этот ответ будет неясным или неправильным на любом уровне, не стесняйтесь указывать на него.

Спасибо Деннису за помощь в разработке этого первого небольшого фрагмента кода.

Python. 85 символов:

s,i=str,int;rs=lambda q:s(q)[::-1];n=i(input());
while rs(n)!=s(n):n+=i(rs(n));print n

Если вы не хотите выводить данные на каждой итерации:

s,i=str,int;rs=lambda q:s(q)[::-1];n=i(input());
while rs(n)!=s(n):n+=i(rs(n))
print n

(на один символ меньше)

Windows PowerShell (63)

for($a=+"$input";-join"$a"[99..0]-ne$a){$a+=-join"$a"[99..0]}$a

Я до сих пор ненавижу, что нет простого способа перевернуть строку.

Haskell 89 87 символов

r=read.reverse.show
main=getLine>>=print.head.filter(\x->x==r x).iterate(\x->x+r x).read

Несколько читаемая версия:

myFind p = head . filter p
rev = read . reverse . show
isPalindrome x = x == rev x
next x = x + rev x
sequence196 = iterate next
palindrome196 = myFind isPalindrome . sequence196

main = getLine >>= print . palindrome196 . read

Версия для гольфа была создана путем ручного встраивания и переименования оставшихся функций в имена отдельных персонажей.

befunge, 57 байт

"KCTS"4(&:0\v
\T\a*+\:0`jv>:a%\a/
0:+_v#-TD2$<^\
  @.<

хотя код находится в сетке 4x19, так можно назвать его 76.

• первая строка инициализируется и читает входной номер
• вторая строка обратный первый номер в стеке и положить его во второй позиции стека.
• а третья строка проверяет, является ли число палиндромом.

C ++ TMP (256 символов)

#include<cstdio>
#define Y(A,B,C,D)template<int N>struct A<C,D>{enum{v=B};};
#define Z(A)template<int N,int M>struct A{enum{v=
#define n 5194
Z(R)R<N/10,M*10+N%10>::v};};Y(R,N,0,N)Z(S)S<N+M,R<N+M,0>::v>::v};};Y(S,N,N,N)main(){printf("%d",S<n+R<n,0>::v,0>::v);}

Эта версия может быть немного сокращена, но трудно получить ответ из 256 символов. Вот версия без гольфа:

#include <iostream>

template<size_t N>
class Reverse
{
    template<size_t M, size_t R>
    struct Inner
    {
        enum { value = Inner<M/10, R*10 + M%10>::value };
    };

    template<size_t R>
    struct Inner<0, R>
    {
        enum { value = R };
    };

public:
    enum { value = Inner<N, 0>::value };
};

template<size_t N>
class OneNineSix
{
    template<size_t M, size_t R=Reverse<M>::value>
    struct Inner
    {
        enum { value = OneNineSix<M + R>::value };
    };

    template<size_t M>
    struct Inner<M, M>
    {
        enum { value = M };
    };

public:
    enum { value = Inner<N + Reverse<N>::value>::value };
};

int main()
{
    const size_t N = 4123;

    std::cout << OneNineSix<N>::value << std::endl;
}

Пайк, 13 байт (неконкурентный)

D`_b]D$XIsr)h

Попробуй это здесь!

 `_b          -     int(reversed(str(num))
D   ]         -    [num, ^]
     D        -   _ = ^
      $       -  delta(^)
       XI     - if ^:
         s    -  num = sum(_)
          r   -  goto_start()
            h - _[0]

Добавить ++ , 57 байт

L,BDbRBv
D,f,@,1]A+
D,g,@,1]A=
D,h,@,{f}A{g}Q{h}
L,{h}2/i

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

Как это работает

L,	; Create a function 'lambda 1'
	; Example argument:   [5280]
    BD	; Digits;     STACK = [[5 2 8 0]]
    bR	; Reverse;    STACK = [[0 8 2 5]]
    Bv	; Undigits;   STACK = [825]

D,f,@,	; Define a monadic function 'f'
	; Example argument:         [5280]
    1]	; Call 'lambda 1';  STACK = [825]
    A+	; Add the argument; STACK = [6105]

D,g,@,	; Define a monadic function 'g'
	; Example argument:          [5280]
    1]	; Call 'lambda 1';   STACK = [825]
    A=	; Equal to argument; STACK = [0]

D,h,@,	; Define a monadic function 'h'
	; Example argument:  [5280]
   {f}	; Call 'f';  STACK = [6105]
   A{g}	; If 'g'...
   Q	;   Return
   {h}	; Else call 'h'

L,	; Define a function, 'lambda 2'
	; Example argument: [5280]
   {h}	; Call 'h'; STACK = [46464]
   2/i	; Halve;    STACK = [23232]

Powershell, 63 62 байта

-1 байт благодаря @AdmBorkBork

param($m)for(;$m-$s;$m=-join"$s"[-1..-"$s".Length]){$s+=$m};$s

Тестовый скрипт:

$f = {
param($m)for(;$m-$s;$m=-join"$s"[-1..-"$s".Length]){$s+=$m};$s
}

&$f 5280

GNU dc, 46 байтов

Требуется GNU dc, мин. Версия 1.4 (для Rкоманд).

[O~3RO*+rd0<R]sR[+lfx]sg[ddO~rd0<R+d3R!=g]dsfx

Вход и выход, как обычно, расположены на верху стека. Требуется удивительное количество кода для обратного преобразования цифр в DC (если я не пропустил что-то, что далеко не невозможно). У него есть числовой диапазон, который будет хорошо работать с такими входными данными (например, которые будут переполнены 32-битной беззнаковой арифметикой):

• 89 ⇒ 8,813,200,023,188
• 8997 ⇒ 16 668 488 486 661
• 10677 ⇒ 4,668,731,596,684,224,866,951,378,664

объяснение

# Reverse digits, starting after first digit extracted
[O~3RO*+r d0<R]sR

# Recursion helper - add and recurse
[+ lfx]sg

# Main recursive function
[dd O~r d0<R+ d3R !=g]dsfx

R , 193 109 105 байт

-84 байта благодаря Джузеппе! -4 до свидания благодаря JayCe!

function(x){"-"=utf8ToInt
S=strtoi
"!"=rev
while({z=paste(S(x)+S(intToUtf8(!-x),10));any(-z!=!-z)})x=z
z}

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