Napisz krótki program dla algorytmu 196 . Algorytm zaczyna się od liczby całkowitej, a następnie dodaje odwrotność do momentu osiągnięcia palindromu.

na przykład

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

Wkład

liczba całkowita, która nie jest liczbą lyrchrela (tzn. ostatecznie daje palindrom w ramach tego algorytmu, zamiast kontynuować w nieskończoność)

Wydajność

dotarł palindrom.

APL (22 znaki)

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

Działa to w Dyalog APL. Oto wyjaśnienie od prawej do lewej:

• { ... }⍞: Uzyskaj dane wejściowe od użytkownika jako znaki ( ⍞) i wprowadź je do naszej funkcji ( { ... }).
• W ramach funkcji bezpośredniej ( ⋄rozdziela instrukcje, więc patrzymy na nie od lewej do prawej):
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: Oceń ( ⍎) ⍵odwrotność ( ⌽) odpowiedniego argumentu ( ) i dodaj to do sprawdzonej wersji samego argumentu. Następnie sformatuj wynik ( ⍕tj. Podaj jego reprezentację znaków), przypisz ( ←) to zmiennej a, a na końcu sprawdź, czy aodwrotność jest równoważna a(tj. Czy apalindrom?). Jeśli to prawda, wróć a; Inaczej...
  • ∇a: aWróć do naszej funkcji ( ∇to ukryte odniesienie).

Przykład:

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

GolfScript, 29 znaków

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

Wybrany komentarz

Mięsem programu jest dooczywiście pętla. Więc po prostu to omówię.

1. .` kopiuje numer i go strituje.
2. .-1% kopiuje tę wersję ciągu i odwraca ją.
3. .@ kopiuje wersję odwróconą i przenosi oryginalną wersję nieodwróconą na pierwszy plan.

Więc powiedzmy, że numer jest 5280. Na tym etapie, stos jest: 5280 "0825" "0825" "5280". Etap jest ustawiony do porównania. (Po porównaniu stos pozostanie 5280 "0825"bez względu na to, co --- przedmioty do porównania zostały usunięte).

1. Jeśli ciąg znaków i odwrotność są takie same, nie przejmujemy się ciągiem odwróconym, więc po prostu usuń go ( ;) i zwróć 0 (aby zakończyćdo pętlę).
2. Jeśli się nie zgadzają, oceń ( ~) odwrócony ciąg (aby był liczbą), dodaj ( +) to do pierwotnego numeru i zwróć 1 (aby kontynuować dopętlę).

Python 2, 55 bajtów

Zgodnie z sugestią 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

Rubin - 56 znaków

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

Po prostu ćwiczę moje umiejętności Pythona, a nie poważny kandydat.

Pyth, 16 bajtów

L?bqb_by`+vbi_bTyz

Odpowiednik 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 bajtów

CJam powstał po zadaniu tego pytania, więc technicznie jest to nieprawidłowe przesłanie. Ale pytanie uznałem za interesujące, więc oto:

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

Wyjaśnienie:

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";

Podstawowa logika polega na tym, że w każdej iteracji „do zrobienia” najpierw sprawdza się, czy palindrom został osiągnięty, czy nie. Jeśli nie, dodaj odwrotną liczbę. Prawie, jaki jest algorytm!

Wypróbuj online tutaj

To jest prawdziwy pretendent, odkąd J istnieje już od dziesięcioleci.

J (16 bajtów)

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

Jest to czasownik, więc można go przypisać do zmiennej w sesji J i używać w następujący sposób:

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

Jak to działa:

(+^:~:|.&.":)^:_
 +^:~:           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 znaków

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

Scala 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 ze standardowym

Nie kłócę się , tylko trochę doświadczenia z moim językiem
Oczekuje liczby od standardowego

T~d{DddgCi+dgdC=n}uSP

Wyjaśnienie

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 bajtów (niekonkurujące)

Nie konkuruje , ponieważ język jest późniejszy niż wyzwanie.

Kod:

[DÂQ#Â+

Wyjaśnienie:

[        # 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.

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

Brachylog , 8 bajtów

↔?|↔;?+↰

Wypróbuj online!

Nieco podobny do jednego z pierwszych programów Brachylog, które widziałem i byłem zaintrygowany, z wideo wprowadzającego Brachylog .

?↔?.|↔;?+↰.  (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 znaków

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

Test:

$ php 196.php <<< 5280
23232

Bash (64)

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

Zadzwoń za pomocą: bash <nazwa_pliku> <numer>

C # - 103 99 znaków

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

C # nigdy nie radzi sobie najlepiej w golfie. Elegancki, ale pełny.

W Q (39 znaków)

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

Przykładowe użycie:

q)f 5280
23232

Edytować:

Do 34 lat, to samo użycie:

{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

Galaretka , 9 bajtów (nie konkuruje)

Bardzo prosta odpowiedź, tylko na wyzwanie związane z kodowaniem w języku ezoterycznym.

ṚḌ+µŒḂ¬$¿

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

Wypróbuj online!

Jeśli ta odpowiedź będzie niejasna lub błędna na jakimkolwiek poziomie, możesz ją wskazać.

Dziękuję Dennisowi za pomoc przy tym pierwszym małym fragmencie kodu.

Pyton. 85 znaków:

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

Jeśli nie chcesz danych wyjściowych przy każdej iteracji:

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

(jeden mniej znaków)

Windows PowerShell (63)

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

Nadal nienawidzę tego, że nie ma łatwego sposobu na odwrócenie łańcucha.

Haskell 89 87 znaków

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

Nieco czytelna wersja:

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

Wersja do gry w golfa została stworzona przez ręczne wstawianie i zmianę nazw pozostałych funkcji na nazwy pojedynczych znaków.

befunge, 57 bajtów

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

chociaż kod jest umieszczony w siatce 4x19, więc można go nazwać 76.

• pierwsza linia inicjuje się i odczytuje numer wejściowy
• druga linia odwróć pierwszy numer na stosie i umieść go w drugiej pozycji stosu.
• a trzecia linia sprawdza, czy liczba jest palindromem.

C ++ TMP (256 znaków)

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

Tę wersję można nieco skrócić, ale odpowiedź na 256 znaków jest trudna do pominięcia. Oto wersja bez gry w golfa:

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

Pyke, 13 bajtów (niekonkurencyjny)

D`_b]D$XIsr)h

Wypróbuj tutaj!

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

Dodaj ++ , 57 bajtów

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

Wypróbuj online!

Jak to działa

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 bajty

-1 bajt dzięki @AdmBorkBork

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

Skrypt testowy:

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

&$f 5280

GNU dc, 46 bajtów

Wymaga GNU dc, wersja min 1.4 (do Rkomendy).

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

Wejścia i wyjścia są jak zwykle na szczycie stosu. Odwrócenie cyfr w dc wymaga zaskakująco dużej ilości kodu (chyba że czegoś mi brakuje, co jest dalekie od niemożliwego). Ma zakres liczbowy, dzięki któremu dobrze się zachowuje w przypadku takich danych wejściowych (które na przykład przepełnią arytmetykę 32-bitową bez znaku):

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

Wyjaśnienie

# 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 bajtów

-84 bajty dzięki Giuseppe! -4 pa dzięki JayCe!

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

Wypróbuj online!