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 값입니다 .

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

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

도전

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

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

피스, 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]

파이썬 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 답을 계산하는 함수입니다.

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
  

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

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이에 호출 된 배열을 소모 후 오류로 실패합니다. 이렇게하면 원하는 결과 만 스택에 남기고 종료하기 전에 인쇄됩니다.

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

자바-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();
    }
}

줄리아, 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 바이트 절약!

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! 또한 전체 표현의 암묵적인 형식을 사용하여 추가 문자를 절약 할 수 있습니다.

파이썬 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:]))))

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

줄리아, 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

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

하스켈, 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

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

K5, 50 바이트

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

APL (22)

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

설명:

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

Mathematica, 72 69 65 바이트

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

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

자바 스크립트 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)))

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

자바 스크립트 (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))

파이썬 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 :)

J, 70 바이트

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

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

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="")

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

프롤로그, 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 는 숫자를 숫자 차이로 변환하는 계산을 수행합니다.
r 은 q를 재귀 적으로 호출 하고 결과를 합산하여 Digit Difference Sum을 찾습니다.
p 는 진입 점입니다. 숫자를 취하고 r을 호출 하고 답을 인쇄합니다.

예:

>p(8675309).
8898683

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

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;

펄 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