회문 반전 추가

반전 추가 과정은 생성 된 숫자가 회문이 될 때까지 숫자가 추가되는 곳입니다. 예를 들어 68로 시작하면 프로세스는 다음과 같습니다.

68 + 86 => 154 + 451 => 605 + 506 => 1111

보시다시피, 회문 번호에 도달하기 위해 3 번의 추가가 필요했습니다. 로 시작 89하려면 24 단계가 필요합니다 ( 여기서 세부 사항 참조 ).

회문에 도달하기 전에 수행 된 대부분의 단계에 대한 세계 기록은 261이며,이 1186060307891929990수는 10 ¹¹⁸ 보다 큰 수 를 생성합니다 . 그러나 회문을 얻을 수 없었던 숫자가 상당히 많았습니다. 이것을 라이 클렐 번호 라고 합니다 .

우리는 10 진법으로 일하고 있기 때문에 후보자라고 부를 수 있습니다. 왜냐하면이 숫자는 회문에 도달하지 않았다는 증거가 없기 때문입니다. 예를 들어, 가장 작은 10 진법 Lychrel 후보는 196 개이며 10 억 회 이상 반복되었습니다. 회문이 존재하면 10 ^{10 8.77} 보다 훨씬 큽니다 . 이에 비해, 많은 1이 원자에 새겨 져 있다면, 그것을 쓰기 위해서는 2.26772 × 10 ^588843575 원자의 가치가있는 원자가 필요합니다.

당신의 작업

정수 입력을 받고 회문에 도달하는 데 필요한 단계 수를 리턴하거나 인쇄하는 프로그램 또는 함수를 작성하십시오. 귀하는 Lychrel 후보를 다룰 필요가 없습니다 (즉, 귀하의 프로그램은 Lychrel 후보가 주어지면 오류를 발생 시키거나 영원히 실행될 수 있습니다).

테스트 사례 :

                  f(0) => 0
                 f(11) => 0
                 f(89) => 24
                f(286) => 23
          f(196196871) => 45
         f(1005499526) => 109
f(1186060307891929990) => 261

규칙

1. 표준 허점이 없습니다.

보너스

1. 형식화 된 각 추가 단계를 인쇄 n + rev(n) = m하면 점수에 0.75를 곱할 수 있습니다 . 단계 수보다 먼저 합계를 인쇄해야합니다.
2. 코드가 숫자가 리 크렐 후보인지 감지 할 수 있으면 점수에 0.85를 곱할 수 있습니다 . 이 경우 261 회 이상 반복되는 것이 라이 클렐 후보라고 가정하면 충분합니다. 아무 것도 반환하지 않거나 정답으로 오인 할 수없는 숫자 (예 : 0-261 범위에없는 문자열 또는 숫자)는 반환하지 마십시오. 오류는 유효한 출력으로 계산되지 않으며 (예 : 최대 재귀 깊이 초과) 감지에 사용할 수 없습니다.
3. 두 보너스를 모두 완료하면 0.6을 곱하십시오 .

이것은 code-golf 이므로 바이트 수가 가장 적습니다.

이 코드 스 니펫은 Python 3에서 두 가지 보너스가 모두 포함 된 예제 솔루션을 보여줍니다.

def do(n,c=0,s=''):
  m = str(n)
  o = m[::-1]
  if c > 261:
    return "Lychrel candidate"
  if m == o:
    print(s)
    return c
  else:
    d = int(m)+int(o)
    s+="%s + %s = %s"%(m,o,str(d))
    return do(d,c+1,s)

Pyth, 12 바이트

f_I`~+Qs_`Q0

온라인으로 사용해보십시오 : 데모 또는 테스트 장치

이것은 아주 새로운 기능을 사용합니다 (17 시간 만 사용).

설명

               implicit: Q = input number
f          0   repeat the following expression until it 
               evaluates to true and return the number of steps
         `Q       convert Q to string
        _         reverse the digits
       s          convert to int
     +Q           add Q
    ~             assign the result to Q
                  (this returns the old value of Q)
   `              convert the old value of Q to a string
 _I               and check if it's invariant under the operation reverse

편집하다:

코드를 약간 변경했습니다. 이전 버전은

fqKs_`Q~+QK0

동일한 바이트 수이지만 새로운 것은 더 시원합니다.

파이썬, 51

def f(n):r=int(str(n)[::-1]);return n-r and-~f(n+r)

Python 2 str()의 경우 리터럴에 L첨부되어있어 백틱을 대체 할 수 없습니다 long.

점수가 64 * 0.85 = 54.4 인 대체 버전은 다음과 같습니다 .

def f(n,c=262):r=int(str(n)[::-1]);return c*(n-r)and-~f(n+r,c-1)

점수가 88 * 0.6 = 52.8 인 Python 3 의 대체 버전 :

def f(n,c=262):r=int(str(n)[::-1]);return c*(n-r)and-~f(n+r,print(n,'+',r,'=',n+r)or~-c)

CJam, 23 22 20.4 바이트

ri{__sW%i+}261*]{s_W%=}#

코드의 길이는 24 바이트이며 Lychrel 후보의 경우 -1 을 인쇄합니다 .

온라인으로 사용해보십시오.

작동 원리

ri                       e# Read an integer from STDIN.
  {       }261*          e# Do the following 261 times:
   __                    e#   Push two copies of the integer on the stack.
     sW%i                e#   Cast to string, reverse and cast back to integer.
         +               e#   Add the copy and the reversed copy of the integer.
               ]         e# Wrap all 262 results in an array.
                {     }# e# Push the index of the first element such that:
                 s       e#   The string representation equals...
                  _W%=   e#   the reversed string representation.

경우 {}#에 성공, 인덱스는 단계의 수입니다. 반면에 배열에 회문이 포함되어 있지 않으면 -1{}# 을 누릅니다 .

자바, 200 * 0.6 = 120

import java.math.*;int f(BigInteger a){int s=-1;for(String b,c;(b=a+"").equals(c=new StringBuffer(b).reverse()+"")!=s++<999;)System.out.println(b+" + "+c+" = "+(a=a.add(new BigInteger(c))));return s;}

이것은 상자에 표시된 것과 동일한 역할을하지만 골프가 추가 된 간단한 루프입니다. 1000리치 렐 후보가 탐지 보너스를 받기 위해 반환 합니다. 나도 인쇄 할 수 없었 습니다. 많은 문자 (적어도 Java의 경우)에 대해 그 보너스도 걸렸습니다. 보너스 코드없이 내가 할 수있는 최선은 156 이었으므로 그만한 가치가있었습니다.

줄 바꿈과 함께 :

import java.math.*;
int f(BigInteger a){
    int s=-1;
    for(String b,c;(b=a+"").equals(c=new StringBuffer(b).reverse()+"")!=s++<999;)
        System.out.println(b+" + "+c+" = "+(a=a.add(new BigInteger(c))));
    return s;
}

기존 답변 : 171 * 0.85 = 145.35 바이트

import java.math.*;int f(BigInteger a){int s=-1;for(String b,c;(b=a+"").equals(c=new StringBuffer(b).reverse()+"")!=s++<262;)a=a.add(new BigInteger(c));return s>261?-1:s;}

루비, (80 + 2) * 0.6 = ~ 49.2

flags -nl로 실행

p (0..261).find{$_[b=$_.reverse]||puts($_+' + '+b+' = '+$_="#{$_.to_i+b.to_i}")}

출력은 다음과 같습니다

 $ ruby -nl lychrel.rb 
89
89 + 98 = 187
187 + 781 = 968
968 + 869 = 1837
1837 + 7381 = 9218
9218 + 8129 = 17347
17347 + 74371 = 91718
91718 + 81719 = 173437
173437 + 734371 = 907808
907808 + 808709 = 1716517
1716517 + 7156171 = 8872688
8872688 + 8862788 = 17735476
17735476 + 67453771 = 85189247
85189247 + 74298158 = 159487405
159487405 + 504784951 = 664272356
664272356 + 653272466 = 1317544822
1317544822 + 2284457131 = 3602001953
3602001953 + 3591002063 = 7193004016
7193004016 + 6104003917 = 13297007933
13297007933 + 33970079231 = 47267087164
47267087164 + 46178076274 = 93445163438
93445163438 + 83436154439 = 176881317877
176881317877 + 778713188671 = 955594506548
955594506548 + 845605495559 = 1801200002107
1801200002107 + 7012000021081 = 8813200023188
24

196이 주어지면 처음 261 개의 추가 단계를 인쇄 한 다음를 수행합니다 nil.

여기서 너무 까다로운 것은 없습니다. 우리는 $_(입력으로 초기화 된) 반전이 포함되어 있는지 확인합니다 . 동일한 크기이므로 같은 경우에만 가능합니다. 그렇다면 단계 번호를 인쇄하고 종료합니다. 그렇지 않으면 추가 단계를 표시하고 실행하여 새 값을 저장합니다 $_(안타깝게도 eval후행 0으로 반전 된 숫자를 해석하기 때문에 표시중인 문자열 만 볼 수는 없습니다) 8 진 리터럴로). puts루프가 계속되도록 잘못된 값을 반환합니다.

Pyth-19 바이트

while 루프와 카운터를 사용합니다. 이보다 더 작은 알고리즘이있을 수 있지만 이것은 매우 짧습니다.

Wnz_z=z`+szs_z=hZ;Z

여기에서 온라인으로 사용해보십시오 .

K, 25 바이트

#1_{~x~|x}{$. x,"+",|x}\$

매우 우아하지 않습니다. 전체 형태 ( {monad 1}{monad 2}\x)는 K가 일반 "while"루프와 동등하며, 첫 번째 모나드는 정지 조건이고 두 번째는 인수에 반복적으로 적용되는 함수 x입니다. 첫 번째 모나드 ( {~x~|x})는 고전적인 "is xa palindrome"문구의 부정입니다. 두 번째 모나드는 x와 x의 역을 나타내는 문자열을 연결하여 평가 한 다음 결과를 문자열로 다시 캐스팅합니다 $.

중간 결과를 보여주는 샘플 실행 :

  {~x~|x}{$. x,"+",|x}\$68
("68"
 "154"
 "605"
 "1111")

보너스 요청에 따라 포맷 된 출력을 수행하는 것은 매우 어색하고 상당한 양의 코드를 추가합니다.

CJam, 23 바이트

Wl{\)\__W%_@#\i@i+s\}g;

아직도 CJam에 며칠 밖에 걸리지 않았기 때문에 적어도 일부 전문가와 같은 범위에 있다는 것이 매우 기쁩니다. :) Martin의 문자열 비교 트릭을 사용하여 CJam 힌트에도 게시했습니다. 또한 Dennis의 솔루션을 살펴보고 문자열을 뒤집는 방법을 알아 냈습니다.

설명:

W    Initialize counter, will keep this at bottom of stack.
     Start counting at -1 because the counter will be incremented in the
     last pass through the loop, when the palindrome is detected.
l    Get input.
{    Start block of while loop.
\)\  Increment counter. Need to swap before/after because it's one below top of stack.
__   Copy current value twice. Need 3 copies in total:
       * one for reversal
       * one for comparison
       * one for addition with reverse
W%   Reverse value.
_    Copy the reverse value once because we need 2 copies:
       * one for comparison
       * one for addition with original value
@    Rotate one copy of original value to top.
#    Test for non-equality with reverse, using Martin's trick.
\i   Swap reverse value to top, and convert it to int.
@i   Rotate remaining copy of original value to top, and convert it to int.
+s   Add the values, and convert result to string.
\    Swap, so that comparison result is at top of stack for while loop test.
}g   End of while loop.
;    Current value sits at top of stack. Pop it, leaving only counter.

온라인 테스트

줄리아, 129120 바이트 * 0.6 = 72

i->(i=big(i);n=0;d=digits;while d(i)!=reverse(d(i))&&n<262 t=BigInt(join(d(i)));println(i," + ",t," = ",i+=t);n+=1end;n)

이것은 이름이없는 함수를 생성하여 정수를 입력으로 취하고 각 단계를 인쇄하는 동안 정수를 반환합니다. 리치 렐 후보는 262의 반환 값을 갖습니다.이를 호출하려면 다음과 같이 이름을 지정하십시오.f=i->... .

보너스와 관련된 코드를 생략하면이 솔루션은 84 바이트가됩니다.

언 골프 + 설명 :

function f(i)
    # Convert the input to a big integer
    i = big(i)

    # Initialize a step counter to 0
    n = 0

    # While the number is not a palindrome and we haven't exceeded 261 steps...
    while digits(i) != reverse(digits(i)) && n < 262

        # Get the reverse of the integer
        # Note that we aren't using reverse(); this is because digits()
        # returns an array of the digits in reverse order.
        t = BigInt(join(digits(i)))

        # Print the step and increment i
        println(i, " + ", t, " = ", i += t)

        # Count the step
        n += 1
    end

    # Return the number of steps or 262 for Lychrel candidates
    n
end

예 :

julia> f(286)
286 + 682 = 968
968 + 869 = 1837
1837 + 7381 = 9218
9218 + 8129 = 17347
17347 + 74371 = 91718
91718 + 81719 = 173437
173437 + 734371 = 907808
907808 + 808709 = 1716517
1716517 + 7156171 = 8872688
8872688 + 8862788 = 17735476
17735476 + 67453771 = 85189247
85189247 + 74298158 = 159487405
159487405 + 504784951 = 664272356
664272356 + 653272466 = 1317544822
1317544822 + 2284457131 = 3602001953
3602001953 + 3591002063 = 7193004016
7193004016 + 6104003917 = 13297007933
13297007933 + 33970079231 = 47267087164
47267087164 + 46178076274 = 93445163438
93445163438 + 83436154439 = 176881317877
176881317877 + 778713188671 = 955594506548
955594506548 + 845605495559 = 1801200002107
1801200002107 + 7012000021081 = 8813200023188
23

julia> f(1186060307891929990)
(steps omitted)
261

julia> f(196)
(steps omitted)
262

julia> f(11)
0

지오 비트 덕분에 2 바이트가 절약되었습니다!

CJam, 24 바이트

0q{__W%#}{_W%~\~+s\)\}w;

여기에서 테스트하십시오.

설명

0q     e# Push a zero (the counter) and read input.
{      e# While this block leaves something truthy on the stack...
  __   e#   Make two copies of the current number (as a string).
  W%   e#   Reverse the second copy.
  #    e#   Check that they are not equal.
}{     e# ... run this block.
  _W%  e#   Make a copy of the current number and reverse it.
  ~\~  e#   Evaluate both N and its reverse.
  +s   e#   Add them and turn the sum into a string.
  \)\  e#   Pull up the counter, increment it, and push it back down again.
}w
;      e# Discard the palindrome to leave the counter on the stack.

#문자열 불평등을 확인하는 데 사용할 수있는 이유에 대한 자세한 내용 은이 팁을 참조하십시오 .

하스켈, 66 53 바이트

r=reverse.show
f x|show x==r x=0|1<2=1+f(x+read(r x))

사용 예 :

*Main> map f [0,11,89,286,196196871,1005499526,1186060307891929990]
[0,0,24,23,45,109,261]

클로저, 94 바이트

(fn[x](#(let[r(bigint(apply str(reverse(str %1))))] (if(= %1 r)%2(recur(+ %1 r)(inc %2))))x 0))

이것이 골프를 코딩하는 첫 번째 시도이므로, 내가 잘못한 것을 말해주십시오.

공백이있는 경우 :

(fn [x]
(#(let [r (bigint (apply str (reverse (str %1))))]
  (if (= %1 r) %2 (recur (+ %1 r) (inc %2)))) x 0))

내부 함수의 간단한 재귀. 정수 %1와 색인 두 개의 인수가 필요 %2합니다. 경우 %1회문이다, 인덱스가 반환됩니다. 그렇지 않으면, 함수는 합계와 증분 된 인덱스로 자체를 호출합니다. 외부 함수는 인덱스를 0으로 초기화합니다.

샘플:

repl=> ((fn[x](#(let[r(bigint(apply str(reverse(str %1))))](if(= %1 r)%2(recur(+ %1 r)(inc %2))))x 0)) 1186060307891929990)
261

부스트 빌드, 304 바이트

실제로는 언어가 아닙니다. 여전히 시원합니다.

import sequence ;
import regex ;
rule r ( n ) {
m = "([0-9]?)" ;
return [ sequence.join [ sequence.reverse [ regex.match "$(m)$(m)$(m)$(m)$(m)$(m)$(m)$(m)$(m)" : $(n) ] ] : "" ] ;
}
rule x ( n ) {
i = 0 ;
while $(n) != [ r $(n) ] {
n = [ CALC $(n) + [ r $(n) ] ] ;
i = [ CALC $(i) + 1 ] ;
}
echo $(i) ;
}

문자열을 뒤집는 데 사용한 정교한 정규식 기반 해킹 외에는 매우 간단합니다.

루비, 44

f=->n{n==(r=n.to_s.reverse.to_i)?0:f[n+r]+1}

->람다 구문 에는 Ruby 1.9 이상이 필요 합니다.