숫자의 자릿수 차이 합계 계산


39

8675309와 같은 음이 아닌 정수를 취하고 모든 인접 숫자 쌍 간의 차이의 절대 값을 계산하십시오.

들어 8675309우리가 얻을 |8-6| = 2, |6-7| = 1, |7-5| = 2, |5-3| = 2, |3-0| = 3, |0-9| = 9. 이 결과를 함께 묶으면 음수가 아닌 다른 정수가 더 작아집니다 212239. 프로세스를 반복하여 제공 11016한 후, 0115어느 자리,뿐만 간소화를 기록하지 않는 것이 관례 115가되고, 04또는 4더 감소 될 수 없다. 이 모든 값을 합하면 우리는 얻을 수 8675309 + 212239 + 11016 + 115 + 4 = 8898683있습니다.

자릿수 차이 합 (또는 DDS)을 숫자의 자릿수 차이를 반복하여 가져 와서 새 숫자를 만든 다음 모든 결과 숫자를 원본에 추가하는이 작업으로 정의 해 보겠습니다.

해당 DDS 시퀀스에서 처음 20 개의 값은 다음과 같습니다.

N   DDS(N)
0   0
1   1
2   2
3   3
4   4
5   5
6   6
7   7
8   8
9   9
10  11
11  11
12  13
13  15
14  17
15  19
16  21
17  23
18  25
19  27

다음은 그래프가 매우 흥미로운 첫 번째 10000 값입니다 .

DDS 10000 플롯

특히 1000 또는 100으로 플롯 할 때 동일하게 보이기 때문에 :

DDS 1000 플롯

DDS 100 플롯

(나는 그것을 치과 의사의 계단 이라고 부를 것이다 ...)

도전

음수가 아닌 정수를 사용하여 DDS 값을 인쇄하거나 반환하는 프로그램 또는 함수를 작성하십시오. 예를 들어 입력이 8675309이면 출력은이어야합니다 8898683.

바이트 단위의 가장 짧은 코드가 이깁니다.


치과 의사의 계단?
Martijn

12
@MartijnR 치과 의사의 계단.
캘빈의 취미

@ Calvin'sHobbies 치열 교정의 계단?
Beta Decay

1
@BetaDecay 치과 의사 의 계단.
Alex A.

답변:


11

피스, 17

s.ui.aM-VJjNTtJTQ

여기에서 시도 하거나 Test Suite를 실행하십시오.

설명:

s.u            Q   # Cumulative reduce, i.e. getting the intermediate values of each reduce
                     step and returning them as a list, then sum the list
   i ... T         # Convert the resulting list of numbers into a base 10 number
   .aM             # Get the absolute value of each element of ...
      -VJjNTtJ     # Perform vector subtraction on the lists given by
        JjNT       # assign J the number we currently have converted to its base 10 digits
            tJ     # and J[1:]. e.x. for 123 we get J = [1,2,3] then we do
                   # zip(J,J[1:]) which gives [[1,2],[2,3]] then element wise subtract
                   # to get [-1, -1]

이것이 무슨 언어 지? 너무 비밀스러운! T_T은
asgs

1
@asgs PPCG에 오신 것을 환영합니다. :) Pyth라고 합니다 . Github 페이지 에서 통역사와 문서를 찾을 수 있습니다 . 이 언어의 사용자의 대부분은에 물어 주시기 바랍니다에 대해 질문이 그렇다면,이 사이트에 활성 채팅 또는 그 전용 룸 :
FryAmTheEggman

17

파이썬 2, 73

다행히 문자열 작업을 피할 수있었습니다.

t=lambda n:n>9and abs(n%10-n/10%10)+10*t(n/10)
g=lambda n:n and n+g(t(n))

g 답을 계산하는 함수입니다.


4
이 흑 마법은 무엇입니까?!
Beta Decay

7
@BetaDecay 나는 그것이 "수학"이라고 생각합니다.
lirtosiast

파이썬을 잘 알지 못하지만 한 번의 히트로 나머지 용어를 두 용어에 모두 적용 할 수 있습니까? 즉, ? (n-n/10)%10와 동일 하게 작동합니다 n%10-n/10%10. 아니면 어쩌면 (9*n/10)%10?
Glen O

@GlenO 파이썬에서, %나머지가 아닌 진정한 모듈러스 연산자이므로 작동하지 않습니다.
feersum

15

Matlab, 101105 바이트

감사 @beaker에 많은 그의 제안을 사용하기 위해 polyval대신하는 경우 base2dec. 그것은 나를 허용했다

  • 4 바이트를 절약하십시오.
  • 임의의 기본 (아래 참조)으로 일반화를 크게 단순화하고 22 바이트를 절약하십시오. 그리고 무엇보다도
  • 일반적인 경우의 코드가 잘못되었음을 인식하는 데 도움이되었습니다 (앞의 0은 제거되지 않았습니다). 코드와 그래프가 이제 정확합니다.

암호:

function y=f(y)
x=+num2str(y);while numel(x)>1
x=polyval(abs(diff(x)),10);y=y+x;x=+dec2base(x,10);end

예:

>> f(8675309)
ans =
     8898683

보너스 : 임의의 기준

작은 일반화를 사용하면 반드시 소수가 아닌 임의의 숫자를 사용할 수 있습니다.

  • 2 ~ 10, 108104 바이트의 임의 기준

    function y=f(y,b)
    x=+dec2base(y,b);while numel(x)>1
    x=polyval(abs(diff(x)),b);y=y+x;x=+dec2base(x,b);end
    

    이에베이스 만까지 작동하는 이유는 10matlab에의 것입니다 dec2base기능을 사용하는 숫자는 0, 1, ..., 9, A, B, ...,과에서 문자 (ASCII) 코드에서 점프 거기 9에를 A.

  • 36 2 내지 임의 염기 124 146 바이트

    에서 점프 9로는 A위의 요구에 특별 대우라고. 최대베이스는 36Matlab의 dec2base기능에 따른 것입니다.

    function y=f(y,b)
    x=+dec2base(y,b);x(x>57)=x(x>57)-7;while numel(x)>1
    x=abs(diff(x));x=x(find(x,1):end);y=y+polyval(x,b);end
    

치과 의사의 계단이 다른 기지를 찾는 방법입니다.

여기에 이미지 설명을 입력하십시오 여기에 이미지 설명을 입력하십시오 여기에 이미지 설명을 입력하십시오 여기에 이미지 설명을 입력하십시오 여기에 이미지 설명을 입력하십시오 여기에 이미지 설명을 입력하십시오


1
이것이 내가 한 것입니다 ... 또 다른 대답 LOL을 생각할 시간입니다. +1.
rayryeng-복원 모니카

@rayryeng :-) 감사합니다
Luis Mendo

@BetaDecay 감사합니다! :-) 그들은 정말 예쁘다
Luis Mendo

11

CJam, 22 21 바이트

ri_{\s2ew::-:zsi_@+}h

이 프로그램은 기본적으로 허용되는 오류와 함께 종료됩니다 .

Java 인터프리터를 사용하면 STDERR을 닫아 오류를 억제 할 수 있습니다. CJam 인터프리터 에서이 코드를 온라인으로 시도 하면 마지막 행 앞의 모든 출력을 무시하십시오.

원본 개정판의 오류를 지적한 @ Sp3000에게 감사합니다.

1 바이트를 골라 낸 @ MartinBüttner에게 감사합니다.

예제 실행

$ cjam digit-difference.cjam 2>&- <<< 8675309     
8898683

작동 원리

ri_   e# Read an integer (I) from STDIN and push a copy (A).
{     e# Do:
  \   e#   Swap I on top of A.
  s   e#   Cast I to string.
      e#   For example, 123 -> "123".
  2ew e#   Push the overlapping slices of length 2 (pair of adjacent digits).
  ::- e#   Replace each pair by its difference.
  :z  e#   Apply absolute value to each difference.
  si  e#   Cast to string, then to integer. This is the new I.
      e#   For example, [1 2 3] -> "123" -> 123.
  _   e#   Push a copy of I.
  @   e#   Rotate A on top of the copy of I.
  +   e#   Add I to A, updating A.
}h    e# While A is truthy, repeat the loop.

확인하면 A 는 항상 진실합니다 h. 그러나, 일단 내가 한 자리 정수이며, 2ew이에 호출 된 배열을 소모 후 오류로 실패합니다. 이렇게하면 원하는 결과 만 스택에 남기고 종료하기 전에 인쇄됩니다.


2
7 분 평면에 게시 : O
Calvin 's Hobbies

10

미로 , 176 134 127 119 103 97 88 82 79 76 72 바이트

1 바이트를 절약하고 2 개 더 길을 포장 한 Sp3000에 감사합니다.

이것은 아마도 단축 될 수 있지만, Java Matlab Python을 능가합니다 ...

?
_
)/:}+{:`};!
9       "
_ :}-"" :_10
;;{: `" "  :
  {  (_:/=%}
  0+;`"

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

이것은 오류와 함께 종료 되지만 오류 메시지는 STDERR에 기록됩니다 (TIO에서는이를 볼 수 없습니다).

구현은 매우 간단합니다. 현재 값을 누적 합계에 추가합니다. 현재 값이보다 큰 경우 9, 우리는 10 진수 (반복 된 div-mod를 통해)를 계산하고 절대 차이로부터 새로운 숫자를 형성합니다. 도착 9하거나 그 이하이면 누적 합계를 인쇄합니다.

현재 숫자의 자릿수는 보조 스택에서 수집되며 가장 큰 자릿수는 맨 위에 표시됩니다.

글쎄, abs(...)내가 여기에 화려한 구현은 새로운 솔루션에 비해 엄청나게 복잡한 것으로 판명되었습니다 ...이 골프를 더 끝낼 때 업데이트 된 설명을 추가 할 것입니다.


5

자바-300 바이트

골프 버전

static Long t=new Scanner(System.in).nextLong();static char[]c=t.toString().toCharArray();public static void main(String[]z){while(c.length>1)s();System.out.print(t);}static void s(){String s="";for(int i=0;i<c.length-1;)s+=Math.abs(c[i]-c[++i]);Long a=new Long(s);t+=a;c=a.toString().toCharArray();}

Ungolfed / 정식 버전

import java.util.Scanner;

public class DigitDifference {

    static Long t = new Scanner(System.in).nextLong();
    static char[] c = t.toString().toCharArray();

    public static void main(String[] args){
        while( c.length > 1 )
            s();
        System.out.print(t);
    }

    static void s(){
        String s="";
        for(int i = 0; i < c.length-1;)
            s += Math.abs(c[i]-c[++i]);
        Long a = new Long(s);
        t += a;
        c = a.toString().toCharArray();
    }
}

@Loovjo, 건배.
코더

1
PPCG에 오신 것을 환영합니다! 이것은 여전히 ​​많은 골프를 할 수 있습니다. 나는 논리를 많이 보지 않았지만 : 1) 실제로 별도의 기능이 필요하지 않기 때문에이 모든 것을 하나의 함수로 가져 오십시오 (또는 그 문제에 대한 전체 프로그램 / 클래스) 2) static당기고 난 후에 s를 제거하십시오 3)에서 그것들 (a+"")은 일반적으로와 동일 a.toString()하지만 더 짧습니다. 4) 단지 기능이라면 스캐너가 필요하지 않습니다. 간단히 입력으로 오래 걸리십시오.
Geobits

2
예를 들어, 많은 작업을 변경하지 않고 long f(long t){long a=t;char[]c;while((c=(a+"").toCharArray()).length>1){String s="";for(int i=0;i<c.length-1;)s+=Math.abs(c[i]-c[++i]);t+=a=new Long(s);}return t;}
주름을

2
@Geobits, 그것은 놀라운 친구였습니다. Code Golf를 처음 사용하므로 코드 효율성을 향상 시키려고합니다. Cherrs ..
코더

5

줄리아, 81 60 바이트

n->(s=n;while n>9 s+=n=int(join(abs(diff(["$n"...]))))end;s)

언 골프 드 :

function f(n::Int)
    # Initialize a sum to the input
    s = n

    while n > 9
        # Get absolute values of the pairwise differences of the
        # digits of n, join as a string, convert it to an integer,
        # and reassign n
        n = int(join(abs(diff(["$n"...]))))

        # ["$n"...] actually splits n as a string into a vector
        # of its characters, but the difference between ASCII
        # codes is the same as the difference between the numbers
        # so it works as expected

        # Add the new n to the running sum
        s += n
    end

    # Return the sum
    return s
end

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

feersum과 Glen O 덕분에 21 바이트 절약!


1
ndigits(n)>1다른 이유 가 n>9있습니까?
feersum

제안 : int(join(abs(diff(["$n"...]))))9 바이트를 절약합니다. n>9다른 9 바이트를 절약하려면 feersum에서 제안한대로 전환하십시오 . 한 단계 동안에 루프에서 모두 할당을 수행 (여분 지금 불필요한 세미콜론을 제거) 한 3 바이트 이상 저장 :n->(s=n;while n>9 s+=n=int(join(abs(diff(["$n"...]))))end;s)
글렌 O

@feersum 음. 감사!
Alex A.

@GlenO 굉장합니다, 감사합니다!
Alex A.

5

oK , 37 32 24 23 바이트

+/(10/{%x*x}1_-':.:'$)\

실제로 :

  +/(10/{%x*x}1_-':.:'$)\8675309
8898683

  (+/(10/{%x*x}1_-':.:'$)\)'!20
0 1 2 3 4 5 6 7 8 9 11 11 13 15 17 19 21 23 25 27

K5에는이 기능에 적합한 몇 가지 기능이 있습니다. "인코딩"및 "디코딩"은 기본 변환을 수행 할 수 있으며, 각 쌍 ( ':)은 목록에서 순차적 요소를 쌍으로 \묶고 고정 소수점 스캔 ( )은 중지 될 때까지 반복 시퀀스를 생성 할 수 있습니다. 작고 보기 흉한 사람. 그러나 원시적 요소 abs()가 없으면의 형태로보기 흉한 벌크가 발생한다 {(x;-x)x<0}'.

편집하다:

대신에 {(x;-x)x<0}'(약간 낭비) 시퀀스의 제곱의 제곱근을 취할 수 있습니다 ( {%x*x}5 바이트 절약).

편집 2 :

@maurinus의 APL 솔루션에서 영감을 얻은 "decode"( ((#$x)#10)\x)를 숫자 의 문자열 표현의 각 문자를 평가 하는 것으로 바꿀 수 있습니다 .:'$x! 또한 전체 표현의 암묵적인 형식을 사용하여 추가 문자를 절약 할 수 있습니다.


4

파이썬 2, 87 바이트

f=lambda n:n and n+f(int('0'+''.join(`abs(int(a)-int(b))`for a,b in zip(`n`,`n`[1:]))))

재귀 적으로 현재 숫자를 더하고 숫자 차이를 가져옵니다. 숫자와 문자열을 많이 변환합니다. 아마 향상 될 수 있습니다.


4

줄리아, 55 48 바이트

h=n->(n>9&&h(int(join(abs(diff(["$n"...]))))))+n

언 골프 드 :

function h(n)
  if n>9
    # If multiple digits, find the digit difference...
    digitdiff=int(join(abs(diff(["$n"...]))))
    # ... recurse the function...
    downsum=h(digitdiff)
    # ... and return the sum so far (working up from the bottom)
    return downsum+n
  else
    # If single digit, no further recursion, return the current number
    return n
  end
end

본질적으로 이것은 한 자릿수 수준으로 내려 가고 (자릿수 차이는 수행 할 수 없음), 재귀를 종료 할 때 레벨별로 다시 합산됩니다.


3

하스켈, 140 바이트

d 일을한다.

import Data.Char
d n=sum.m(read.m intToDigit).fst.span(/=[]).iterate s.m digitToInt.show$n
s l@(h:t)=snd$span(==0)$m abs$zipWith(-)l t
m=map

누구나 긴 변환 함수 가져 오기를 피하는 방법을 알고 있습니까?


intToDigit이다 toEnum.(+48)하고 digitToInt있다 (\i->fromEnum i-48). 목록 컨텍스트 s에서을 사용하여 무인 버전으로 전환 할 수도 있습니다 . 마지막 은 입니다. 음수가 아닌 정수로 작업하고 있기 때문입니다. =<<s=snd.span(==0).m abs.(zipWith(-)=<<tail)(==0)(<1)
nimi

... 아, 그리고 s포인트가 없으면 이름을 지정할 필요가 없습니다. 직접 호출 :iterate(snd.span ... tail))
nimi

... 내 첫 번째 의견에서 실수를 바로 잡는 것은 다시 나입니다 : =<<목록 컨텍스트가 아닌 함수 컨텍스트에서 사용됩니다. 죄송합니다.
nimi

훌륭한! 또한 GHC 확장을 사용하는 것이 일반적인 절차입니까? NoMonomorphismRestriction나도 d무의미 하게 할 것입니다 .
Leif Willerts

1
chrord에 모두 Data.Char있으므로을 (를) 생략 할 수 없습니다 import. 컴파일러 플래그도 바이트로 계산되므로 NoMonomorphismRestriction점수가 25 증가합니다.
nimi

3

K5, 50 바이트

+/{(r;x)@~r:.,/"0",{$(0;-r;r)@(~^r)+0<r:x-y}':$x}\

3

APL (22)

{⍵≤9:⍵⋄⍵+∇10⊥|2-/⍎¨⍕⍵}

설명:

  • ⍵≤9:⍵: ⍵ ≤ 9 인 경우 ⍵을 변경하지 않고 반환합니다.
  • ⍎¨⍕⍵: ⍵를 문자열로 변환 한 다음 각 문자를 평가하십시오.
  • 2-/: 인접한 두 숫자마다 빼기
  • |: 절대 값을 취하십시오
  • 10⊥: 배열을 10 진수로 바꿉니다.
  • ⍵+∇:이 새로운 값으로 함수를 재귀 적으로 호출하고 결과를 입력에 추가하십시오.

3

Mathematica, 72 69 65 바이트

Tr@FixedPointList[FromDigits@*Abs@*Differences@*IntegerDigits,#]&

나는 여기에 제안에 열려 있습니다.


Tr@FixedPointList[FromDigits@*Abs@*Differences@*IntegerDigits,#]&
alephalpha

@alephalpha 재미있는 개념, ... 추가 제로 만들기
LegionMammal978

2

자바 스크립트 ES6, 73 바이트

t=n=>(b=10,M=Math).ceil(n&&n+t((j=n=>n>9&&M.abs(n%b-n/b%b)+b*j(n/b))(n)))

이것은 더 짧아지지 않습니다 : / 더 많은 접근법을 시도 할 것이지만 이것은 지금까지 가장 짧은 방법입니다


할당하지 않고 익명 함수로 남겨두면 t여전히 유효하며 2 바이트를 절약합니다.
Patrick Roberts

@PatrickRoberts 예. 그러나 재귀를 사용하고 있으므로 이름을 지정해야합니다.
Downgoat

오, 충분히 공평 했어요
패트릭 로버츠

2

자바 스크립트 (ES6), 69

EcmaScript 6 호환 브라우저에서 아래 스 니펫을 테스트 해보십시오 (그러나 스프레드 연산자를 지원하지 않으므로 Chrome은 아님 ...) MS Edge?

f=n=>n&&(n+=r='',[...n].map(d=>(r+=d>p?d-p:p-d,p=d),p=n[0]),+n+f(+r))

function test()
{
  var i=+I.value
  O.innerHTML = i+' -> '+f(i) + '\n' + O.innerHTML 
}
<input id=I value=8675309><button onclick=test()>-></button>
<pre id=O></pre>

대안으로, 이제 EcmaScript 2016 (ES7), 67 바이트를 대상으로 하는 배열 이해 를 사용 합니다.

f=n=>n&&(n+=r='',p=n[0],[for(d of n)(r+=d>p?d-p:p-d,p=d)],+n+f(+r))

2

파이썬 3, 125 바이트

나는이 도전을 위해 그것을 사용하려고 때까지 내가 정규식의 곤란을 좋아하는 데 사용 ... re.findall('\d\d',s,overlapped=True)입니다 하지 에)

s=input()
p=int
x=p(s)
while p(s)>9:g=str(s);s=p(''.join(str(abs(p(g[i])-p(g[i+1])))for i in range(len(g)-1)));x+=s 
print(x)

건배 @Todd :)


1
대괄호와 최종 합계가 필요없는 목록이 아닌 정수에 대해 추가를 수행 할 수 있습니다. 's = p (input ())'을 사용하면 while 루프에서 int 변환을 제거하고 x에 대입 할 수 있습니다. 또한 g와 g [1 :]의 zip을 통한 루핑을 고려하면 바이트를 절약 할 수 있습니다.
Todd

1

J, 70 바이트

 +/([:10&#.[:(2|@:-/\])[:10&(]#:~[#~[:>.[^.])])`]@.(11&>)^:a:".(1!:1)3

0

C 162 바이트

골프 :

main(int argc,char **argv){char *c=argv[1];int u=atoi(c),d;do{while(c[1]!=0){*c=abs(*c-*(c+1))+48;c++;}*c=0;c=argv[1];d=atoi(c);u+=d;}while(d>9);printf("%d",u);}

언 골프 :

main(int argc, char **argv)
{
    char *c=argv[1];
    int u=atoi(c),d;

    do
    {
        while(c[1]!=0)
        {
            *c=abs(*c-*(c+1))+48;
            c++;
        }

        *c=0;
        c=argv[1];
        d=atoi(c);
        u+=d;
    }
    while(d>9);

    printf("%d\n",u);
}

0

R, 134 바이트

암호

f=function(x){z=x;while(z>9){n=seq(nchar(z));z=abs(diff(strtoi(substring(z,n,n))));z=sum(z*10**(rev(seq(length(z)))-1));x=x+z};cat(k)}

온라인으로 테스트하십시오 .

언 골프

f=function(x){
  z=x;
  while(z>9){
    n=seq(nchar(z));
    z=abs(diff(strtoi(substring(z,n,n))));
    z=sum(z*10**(rev(seq(length(z)))-1));
    x=x+z
  };
  cat(x)
}

다음은 f (1)에서 f (1m)까지의 "숫자의 차이 차이 합"계열 차이의 그림입니다. 내가 diff하는 것을 좋아하기 때문에.

플롯 코드

s <- seq(1,100000)
serie <- sapply(s,f)
plot(diff(ts(serie)),xlab="",ylab="")

0

MATLAB (141)(137)

편집 : @Andras 덕분에 4 바이트가 적습니다.

function[s j]=n(T,b,c),if(T/b>9),u=fix(T/10);[x e]=n(T,b*10,0);y=n(u,b,0);[w z]=n(u,b,c);s=abs(x-y);j=s+e+10*c*z;else,s=mod(T,10);j=s;end
  • 이것은 @LuisMendo의 대답을 능가하지는 않지만 실행 시간을 줄일 수 있습니다.이 문제를 해결하는 방법을 다양 화하려고 시도했을 것입니다.
  • 나는 그것을 더 줄일 수는 있지만 더 적은 시간 동안 갈수록 더 많은 바이트를 낭비하므로 다음과 같은 원리가 있습니다.

이 프로그램은 인라인 숫자 앞에 같은 행의 숫자를 합산합니다. 정수 나누기 "n / 10"log_10 (n) 번만 사용했으며 복잡도는 O (N)입니다.

만약 n= a b c d

a          b           c           d
   |a-b|       |b-c|       |c-d|
    ||a-b|-|b-c|| ||b-c|-|c-d||
   ....

내 프로그램은 다음을 계산합니다.

a+|a-b| + | |a-b|-|b-c| |  +  |  | |a-b|-|b-c| | - | |b-c|-|c-d| |  |
+10*(
b+|b-c| + | |b-c|-|c-d| |
+10*(
c+|c-d|
+10*(
d
)
)
)

용법:

  [a b]=n(13652,1,1)

a =

1

 b =

   16098

선택 사항 ,endfunction선언 을 생략하여 4 바이트를 절약 할 수 있습니다 .
Andras Deak

게시물의 문법을 수정하십시오. 당신이 한 말을 이해할 수 없습니다.
rayryeng-복원 모니카

0

프롤로그, 143 바이트

암호:

q(X,N):-X<9,N=0;A is abs(X mod 10-X//10 mod 10),Y is X//10,q(Y,M),N is A+M*10.
r(X,N):-X<9,N=X;q(X,Y),r(Y,M),N is X+M.
p(X):-r(X,N),write(N).

설명 :

q(X,N):-X<9,N=0;                                                         % If only one digit, the difference is 0
        A is abs(X mod 10-X//10 mod 10),Y is X//10,q(Y,M),N is A+M*10.   % Else, the difference is the difference between the last 2 digits + the recursive difference of the number without the last digit
r(X,N):-X<9,N=X;                                                         % If we only have 1 digit the final answer is that digit
        q(X,Y),r(Y,M),N is X+M.                                          % Else, the final answer is the current number + the recursive difference of that number
p(X):-r(X,N),write(N).         

q 는 숫자를 숫자 차이로 변환하는 계산을 수행합니다.
rq를 재귀 적으로 호출 하고 결과를 합산하여 Digit Difference Sum을 찾습니다.
p 는 진입 점입니다. 숫자를 취하고 r을 호출 하고 답을 인쇄합니다.

예:

>p(8675309).
8898683

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


0

PHP-198 바이트

<?$x=$t=$_GET['V'];function z($x){global$t;for($i=0;$i<strlen($x)-1;$i++){$z=str_split($x);$r.=str_replace('-','',$z[$i]-$z[$i+1]);}$r=ltrim($r,'0');$t+=$r;return strlen($r)>1?z($r):0;}z($x);echo$t;

언 골프

<?
$x=$t=$_GET['V']; // Gets the value from input
function z($x){
    global$t;
    for($i=0;$i<strlen($x)-1;$i++){
        $z=str_split($x); //Turns the string into an array
        $r.=str_replace('-','',$z[$i]-$z[$i+1]); // Sums the two values and removes the minus signal
    }
    $r=ltrim($r,'0'); // Remove trailing zeroes
    $t+=$r; // Adds to global var
    return strlen($r)>1?z($r):0; // Checks the size of the string. If >1, calls the function again
}

z($x);
echo$t;

0

펄 6 , 56 바이트

{[+] $_,{+.comb.rotor(2=>-1)».map((*-*).abs).join}…0} # 56 bytes

용법:

my &code = {...} # insert code from above

(180..190).map: &code;
# (259 258 259 260 261 262 263 264 265 266 280)

say code 8675309; # 8898683
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.