가자는 순서를 정의 다음 N 디지트 시퀀스를 합산 (N-DSS)의 서열이다로 시작하는지 N . 마지막 숫자가 k 이면 다음 숫자는 k + digit-sum (k) 입니다. 처음 몇 n-DSS는 다음과 같습니다.

1-DSS: 1, 2, 4, 8, 16, 23, 28, 38, 49, 62, 70...
2-DSS: 2, 4, 8, 16, 23, 28, 38, 49, 62, 70, 77...
3-DSS: 3, 6, 12, 15, 21, 24, 30, 33, 39, 51, 57...
4-DSS: 4, 8, 16, 23, 28, 38, 49, 62, 70, 77, 91...
5-DSS: 5, 10, 11, 13, 17, 25, 32, 37, 47, 58, 71...
6-DSS: 6, 12, 15, 21, 24, 30, 33, 39, 51, 57, 69...
7-DSS: 7, 14, 19, 29, 40, 44, 52, 59, 73, 83, 94...
8-DSS: 8, 16, 23, 28, 38, 49, 62, 70, 77, 91, 101...
9-DSS: 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99...

1의 경우 처음 몇 자리 숫자는 약간 다른 정의로 ​​인해 A004207 입니다. 3의 경우 A016052입니다 . 9, A016096에 대해 .

오늘날의 과제는 주어진 숫자가 나타나는 가장 낮은 n 자리 합계 시퀀스를 찾는 것입니다. 이것을 " Incol Colombian Function"이라고하며 A036233 입니다. 1로 시작하는 첫 20 개의 용어는 다음과 같습니다.

1, 1, 3, 1, 5, 3, 7, 1, 9, 5, 5, 3, 5, 7, 3, 1, 5, 9, 7, 20

다른 좋은 테스트 사례 :

117: 9
1008: 918

0보다 큰 정수만 처리하면되고 모든 표준 형식으로 입력 및 출력 할 수 있습니다. 평소와 같이 이것은 code-golf 이므로 각 언어에서 가장 짧은 답변이 이깁니다.

하스켈 , 104 64 63 바이트

(H.PWiz 덕분에 -26, Sriotchilism O'Zaic 덕분에 -14, 콜 덕분에 -1 추가)

이것은 기능입니다.

f x=[y|y<-[1..],x==until(>=x)(foldr((+).read.pure)<*>show)y]!!0

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

설명:

(foldr((+).read.pure)<*>show)

y + y의 디지털 합을 반환하는 복합 함수 시퀀스 먼저 문자열로 변환 한 다음 일부 모나드 체조를 수행하여 문자와 원래 숫자의 합계를 얻습니다 (콜에게 감사합니다).

<*>이와 관련 연산자 타입 정의를 갖는다

(<*>) :: (a -> b -> c) -> (a -> b) -> c
f <*> g = \x -> f x (g x)

위와 같이 쓸 수 있습니다.

\x -> foldr ((+) . read . pure) x (show x)

이것은 read . purea Char를 숫자 로 변환 하므로 (+) . read . pure :: Char -> Int -> Int숫자를 누적 값에 추가합니다. 이 값은 접기에서 주어진 숫자로 초기화됩니다.

until (>=x) {- digital sum function -} y

until첫 번째 인수에서 함수가 지정한 요구 사항을 충족 할 때까지 함수를 결과 (이 경우 y + digital sum y)에 반복적으로 적용합니다. 이것은 x보다 크거나 같은 가장 작은 y-DSS 요소를 제공합니다.

[y | y<-[1..]; x == {- smallest y-DSS element >= x -} ]

가장 작은 y-DSS 요소> = x가 실제로 x가되도록 y의 무한 게으른 목록. Haskell의 목록 이해 표기법을 사용합니다 (전혀 잊어 버렸습니다).

f x = {- aforementioned list -} !! 0

도전 과제의 요구 사항을 충족하는 가장 작은 y 인 목록의 첫 번째 요소입니다.

파이썬 2 , 73 71 바이트

Erik 덕분에 -2 바이트 .

n=input();k=K=1
while n-k:K+=k>n;k=[k+sum(map(int,`k`)),K][k>n]
print K

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

펄 6 , 44 바이트

->\a{+(1...{a∈($_,{$_+.comb.sum}...*>a)})}

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

입력이 포함 된 시퀀스를 찾을 때까지 모든 시퀀스를 확인하는 순진한 솔루션

설명:

->\a{                                    }  # Anonymous code block taking input as a
     +(1...{                           })   # Find the first number
            a∈(                       )     # Where the input is an element of
                                ...         # The sequence
               $_,                          # Starting with the current number
                  {            }   # Where each element is
                   $_+             # Is the previous element plus
                      .comb.sum    # The digit sum
                                   *>a      # Until the element is larger than the input

루비 , 51 바이트

->n{(1..n).find{|i|i+=i.digits.sum while i<n;i==n}}

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

젤리 , 11 바이트

D+ƒ$С€œi⁸Ḣ

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

전체 프로그램.

MATL , 18 바이트

`@G:"ttFYAs+]vG-}@

온라인으로 사용해보십시오! 또는 처음 20 개 값을 확인하십시오 .

설명

입력의 경우 첫 번째 시퀀스 의 첫 번째 항에 i포함될 n때까지 계속 증가 합니다 . 시퀀스가 증가하기 때문에 각 시퀀스에 대한 항 을 테스트하는 것으로 충분합니다 .inii

`         % Do...while
  @       %   Push iteration index, n. This is the firsrt term of the n-th sequence
  G:      %   Push [1 2 ... i], where i is the input
  "       %   For each (i.e., do the following i times)
    tt    %     Duplicate twice
    FYA   %     Convert to digits
    s     %     Sum
    +     %     Add to previous term. This produces a new term of the n-th sequence
  ]       %   End
  v       %   Concatenate all terms into a column vector
  G-      %   Subtract i, element-wise. This is the do...while loop condition (*).
}         % Finally (this is executed right before exiting the loop)
  @       %   Push current n. This is the output, to be displayed
          % End (implicit). A new iteration will start if all terms of (*) are nonzero
          % Display (implicit)

넷째 (gforth) , 106 바이트

: f
>r 0 begin 1+ dup begin dup i < while dup begin 10 /mod >r + r> ?dup 0= until repeat i = until rdrop
;

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

코드 설명

: f                \ start a new word definition
  >r               \ store the input on the return stack for easy access
  0                \ set up a counter
  begin            \ start an indefinite loop
    1+ dup         \ add 1 to the counter and duplicate
    begin          \ start a 2nd indefinite loop
      dup i <      \ check if current value is less than the input value
    while          \ if it is, continue with the inner loop
      dup          \ duplicate the current value
      begin        \ innermost loop, used to get the digit-wise sum of a number
        10 /mod    \ get quotient and remainder of dividing by 10
        >r + r>    \ add remainder to current list value
        ?dup 0=    \ check if quotient is 0
      until        \ end the innermost loop if it is
    repeat         \ go back to the beginning of the 2nd loop
    i =            \ check if the "last" value of the current list = the input value
  until            \ if it does, we're done
  rdrop            \ remove the input value from the return stack
;                  \ end the word definition    

Pyth , 13 바이트

fqQ.W<HQ+ssM`

여기에서 시도 하거나 테스트 스위트를 확인 하십시오 .

작동 원리

fqQ.W<HQ+ssM`     Full program. Takes input Q from STDIN, writes to STDOUT.
f{...}            Loop over 1,2,3,... and find the first number to yield truthy results when
                     applying the function {...} (whose variable is T = the current integer).
 qQ.W<HQ+ssM`     The function {...}, which will be analysed separately.
   .W             Functional while. While condition A is true, do B.
     <HQ          Cond. A (var: H - starts at T): Checks if H is less than Q.
        +ssM`     Func. B (var: G - G & H are the same): If A, G & H become G+digit sum(G)
                  The last value of this functional while will be the least possible number N
                  in the T-DSS that is greater than or equal to Q.
                  If N = Q, then Q ∈ T-DSS. Else (if N > Q), then Q ∉ T-DSS.
 q                That being said, check whether N == Q. 

대부분의 언어에서 자연수 세트를 반복하는 것이 더 쉬울 것 입니다. -DSS 의 첫 번째 항을 찾으십시오 (숫자 합계는 항상 이상이므로이 유형의 수량을 반복적으로 추가하면 (A)보다 작은 값 ) 및인지 확인 그 첫번째에 속하는 의 용어 -DSS. 그러나 Pyth에서는 사용 가능한 제어 흐름 구조를 통해 고정 된 수의 항이 아닌 특정 조건이 충족 될 때까지 항을 생성하기가 더 쉽습니다.$n$$k$$1$$n$$n$$n$$k$

젤리 , 9 바이트

DS+)i$ƬṖṪ

양의 정수 n를 받아들이는 monadic Link, 양의 정수 를 산출하는 a(n)Inverse Colombian of n.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

방법

효과적으로 우리는 거꾸로 일하면서 찾을 수 없을 때까지 더한 가치를 반복적으로 찾습니다.

DS+)i$ƬṖṪ - Link: integer n
      Ƭ   - Repeat until a fixed point, collecting up:
     $    -   last two links as a monad - f(n):
   )      -     left links as a monad for each - [g(x) for x in [1..n]]:
D         -       decimal digits of x
 S        -       sum
  +       -       add x
    i     -     first (1-indexed) index of n in that list, or 0 if no found
       Ṗ  - pop of the rightmost value (the zero)
        Ṫ - tail

사용 13예로서 ...

D  )  = [[1],[2],[3],[4],[5],[6],[7],[8],[9],[1,0],[1,1],[1,2],[1,3]]
 S    = [  1,  2,  3,  4,  5,  6,  7,  8,  9,    1,    2,    3,    4]
  +   = [  2,  4,  6,  8, 10, 12, 14, 16, 18,   11,   13,   15,   17]
    i 13 = .......................................... 11
    i 11 = .................................... 10
    i 10 = ............... 5
    i 5 = not found = 0 
    i 0 = not found = 0
    Ƭ -> [13, 11, 10, 5, 0]
    Ṗ =  [13, 11, 10, 5]
    Ṫ =               5

파이썬 2 , 85 바이트

f=lambda n,a=[]:n in a and a.index(n)or f(n,[k+sum(map(int,`k`))for k in a]+[len(a)])

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

이것은 모든 테스트 사례와 OEIS에 제공된 모든 1..88 항목에 확실히 적용됩니다. 하지만 여전히 꽤 그건 확실하지 않다 라도 유용 올바른. (이것은 단위 테스트 교회에 관한 나의 불만 중 하나입니다).

Wolfram Language (Mathematica) , 61 바이트

For[j=i,#>=j,j=j+Tr@IntegerDigits@j,j/.#->Return@i]~Do~{i,#}&

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

MathGolf , 13 바이트

╒môk(É∙Σ+=k/)

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

큰 도전! MathGolf의 암시 적 팝 동작 내에서 몇 가지 버그를 발견하여 솔루션에 1-2 바이트를 추가했습니다.

설명 (입력 )$3$

╒               range(1,n+1) ([1, 2, 3])
 mô             explicit map using 6 operators
   k(           push input-1 to TOS
     É          start block of length 3 (repeat input-1 times)
      ∙Σ+       triplicate TOS, take digit sum of top copy, and add that to second copy
                This transforms the array items to their respective sequences instead
                Array is now [1, 2, 4, 2, 4, 8, 3, 6, 12]
         =      get index of element in array (the index of 3 is 6)
          k/    divide by input (gives 2)
            )   increment (gives the correct answer 3)

이것이 항상 작동한다는 것을 증명하기 위해, 그것은 첫 번째 순서 의 첫 번째 요소 n <= input이기 때문에 쉽게 알 수 있습니다 . 기술적 으로이 솔루션이 항상 유효하다는 것을 입증하지는 못했지만 테스트 한 모든 테스트 사례를 통과합니다.inputinput

05AB1E , 13 바이트

L.ΔIGÐSO+})Iå

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

클린 , 86 바이트

import StdEnv
$n=hd[i\\i<-[1..]|n==while((>)n)(\j=j+sum[toInt d-48\\d<-:toString j])i]

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

넓히는:

$ n                    // function `$` of `n` is
 = hd [                // the first
   i                   // integer `i`
  \\                   // for
   i <- [1..]          // each integer from 1 upwards
  |                    // where 
   n ==                // `n` is equal to
   while ((>) n) (     // the highest value not more than `n` from
    \j = j + sum [     // `j` plus the sum of
      toInt d - 48     // the digital value
     \\                // for each
      d <-: toString j // digit in the string form of `j`
     ]                 // where `j` is the previous term
    )                  // of the sequence
   i                   // starting with term `i`
  ]

그것은 digitToInt d더 이상 나를 귀찮게toInt d-48

C (gcc) , 102 바이트

f(n,i,s){for(i=1;n^s;)for(s=i++;s<n;){char*p,j=0,l=asprintf(&p,"%d",s);for(;j<l;)s+=p[j++]-48;}n=~-i;}

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

자바 스크립트, 65 바이트

n=>eval('for(i=p=1;n-p;p=p>n?++i:p)for(j=p;j;j=j/10|0)p+=j%10;i')

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

C로도 작동하지만 1 바이트 더 비쌉니다.

C (gcc) , 66 바이트

i,p,j;f(n){for(i=p=1;n-p;p=p>n?++i:p)for(j=p;j;j/=10)p+=j%10;n=i;}

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

C # (Visual C # Interactive Compiler) , 83 , 82 바이트

n=>Enumerable.Range(1,n).First(x=>{for(;x<n;x+=(x+"").Sum(c=>c-48));return x==n;})

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

Japt , 15 14 바이트

input=output성가신 경우를 처리하는 삼항 !

@Ç?X±ìx:XÃøU}a

시도 해봐

@Ç?X±ìx:XÃøU}a     :Implicit input of integer U
@                  :A function taking an integer X as its argument
 Ç                 :  Map each Z in the range [0,U)
  ?                :    If Z>0
   X±              :      Increment X by
     ì             :      Convert X to digit array
      x            :      Reduce by addition
       :X          :    Else X
         Ã         :  End map
          øU       :  Contains U
            }      :End function
             a     :Return the first integer that returns true when passed through that function

cQuents , 18 바이트

#|1:#bN;A
=A?Z+UDZ

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

설명

=A?Z+UDZ      second line - helper function
               first input = A
               second input = n
=A            first term is A
  ?           mode=query, return true if n in sequence, false if n not in sequence
              each term in the sequence equals
   Z+          previous term +
     U   )                     sum (                          )
      D )                            digits (               )
       Z                                      previous term

#|1:#bN;A     main program
               first input = A  (user input)
               second input = n
#|1           n = 1
   :          mode=sequence, return the nth term in the sequence
    #     )   conditional - next term equals next N that evaluates to true
              N increments, any terms that evaluate to true are added to the sequence
               conditional (                      )
     b   )                   second line (      )
      N;A                                  N, A

4 번째 (2 번째) , 99 바이트

: f >r 0 begin 1+ dup begin dup i < while dup 20 for 10 /mod >r + r> next + repeat i = until r> . ;

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

reffu의 제출 과 거의 유사합니다 (106 바이트) . 골프 부품은 다음과 같습니다.

• 숫자 합계 계산 (-6)
• 쓰레기를 stdout에 인쇄하여 최종 정리 (-1). 결과는 스택 맨 위에 반환되므로 문제가 없습니다.

작동 원리

: dsum ( n -- n+digitsum ) \ Sub-function. Given n, add its digit sum to n.
  dup                      \ Copy n to form ( n m ) -> extract digits from m and add to n
  20 for                   \ Repeat 20 times (a 64-bit int is at most 20 digits)
    10 /mod >r + r>        \   n += m%10, m = m/10
  next + ;                 \ End loop and discard 0

: f ( n -- ans )    \ Main function.
  >r                \ Move n to the return stack, so it can be referenced using `i`
  0 begin 1+        \ Initialize counter and loop starting from 1
    dup begin       \   Copy the counter (v) and loop
      dup i < while \     break if v >= n
      dsum          \     v += digit sum of v
    repeat          \   End loop
  i = until         \ End loop if n == v
  r> . ;            \ Cleanup the return stack so the function can return correctly
                    \ `r> .` is one byte shorter than `rdrop`

숯 , 26 바이트

ＮθＷ¬№υθ«ＵＭυ⁺κΣκ⊞υ⊕Ｌυ»Ｉ⊕⌕υθ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. @ChasBrown의 알고리즘을 사용합니다. 그것이 유효하지 않은 것으로 판명되면 29 바이트 동안 :

ＮθＷ¬№υθ«≔⊕ＬυηＷ‹ηθ≧⁺Σηη⊞υη»ＩＬυ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 각 숫자 합산 시퀀스의 첫 번째 멤버를 계산하여 작동합니다 n. 설명:

Ｎθ

입력 n.

Ｗ¬№υθ«

가 포함 된 숫자 합산 시퀀스를 찾을 때까지 반복합니다 n.

≔⊕Ｌυη

다음 시퀀스는 지금까지 시퀀스 수보다 하나 이상으로 시작합니다.

Ｗ‹ηθ

시퀀스의 멤버가보다 작은 동안 루프합니다 n.

≧⁺Σηη

숫자 합을 추가하여 시퀀스의 다음 멤버를 가져옵니다.

⊞υη

최종 멤버를 목록으로 푸시하십시오.

»ＩＬυ

에 포함 된 것을 찾을 때까지 계산 된 목록 수를 인쇄하십시오 n.

빨강 , 103 바이트

func[n][m: 1 loop n[k: m until[if k = n[return m]s: k
foreach d to""k[s: s + d - 48]n < k: s]m: m + 1]]

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

CJam , 25 바이트

q~:T,{[){__Ab:++}T*]T&}#)

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

가이아 , 16 바이트

1⟨⟨:@<⟩⟨:Σ+⟩↺=⟩#

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

가장 작은 정수를 포함하는 목록을 반환합니다.

1⟨	      ⟩#	% find the first 1 positive integers where the following is truthy:
	     =		% DSS equal to the input?
  	    ↺		% while
  ⟨:@<⟩			% is less than the input
       ⟨:Σ+⟩		% add the digital sum to the counter

가이아 , 16 바이트

1⟨w@⟨:):Σ++⟩ₓĖ⟩#

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

Mr. Xcoder 의 관찰을 사용합니다 . 그것은 다른 것보다 짧지는 않지만 그럼에도 불구하고 흥미로운 접근법입니다.

1⟨	      ⟩#	% find the first 1 integers z where:
  	     Ė		% the input (n) is an element of
  w@⟨:):Σ++⟩ₓ		% the first n terms of the z-th Digital Sum Sequence

가이아 , 16 바이트

┅ẋ⟨@⟨:):Σ++⟩ₓĖ⟩∆

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

N-find,를 사용하지 않고 #여전히 중간 접근법과 동일한 관찰에 의존하는 세 번째 접근법 . 목록이 아닌 정수를 반환합니다.

클로저 , 106 바이트

#(loop[j 1 i 1](if(= j %)i(if(< j %)(recur(apply + j(for[c(str j)](-(int c)48)))i)(recur(inc i)(inc i)))))

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

이것은 99 바이트이지만 더 큰 입력에서 스택 오버플로가 발생합니다 (JVM을 조정하면 도움이 될 수 있음).

#((fn f[j i](if(= j %)i(if(< j %)(f(apply + j(for[c(str j)](-(int c)48)))i)(f(inc i)(inc i)))))1 1)

C # (Visual C # 대화식 컴파일러) , 75 바이트

n=>{int a=0,b=0;for(;b!=n;)for(b=++a;b<n;)b+=(b+"").Sum(x=>x-48);return a;}

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

껍질 , 14 10 바이트

^{@ H.PWiz 덕분에 -4}

V£⁰m¡SF+dN

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

잉크 , 130 127 바이트

-(l)
+(i)[+]->l
*(w)[{i}]
~temp n=w
-(o){n<i:
~n+=s(n)
->o
}{n>i:->w}{w}
==function s(n)
{n>9:
~return n%10+s(n/10)
}
~return n

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

• -3 bytes 단항 입력이 필요한 전체 프로그램으로 변환합니다.

골프를 치기에는 너무 오래 느낀다.

언 골프

// This program takes unary input. It passes through the same choice prompt as long as it recieves 1, and execution begins when it recieves 2
-(input_loop)
+(input_value)[+] -> input_loop                 // When this option (option 1) is selected, its read count is incremented. We can access this via the "input_value" variable. We then return to the prompt by going back to the "input_loop" gather
*(which_sequence)[{i}]                          // When this option (option 2) is selected, execution begins. Its read count also serves to keep track of which DSS we're checking.
~temp current_value = which_sequence            // The initial value for the n-DSS is n, of course.
-(sequence)                                     //
{current_value < input_value:                   // If we're still below the value we're looking for, we might find it.
    ~ current_value += digit_sum(current_value) // To get the next number, we add the current number's digit sum
    -> sequence                                 // Then we loop
}
{n > i: -> which_sequence}                      // If we get here, we're at or above our target number. If we're above it, we know it's the wrong sequence and move on to the next one by going back up to option 2. This increments its read count.
{which_sequence}                                // If we get here, we've found the target number, so we output the sequence's number.
// End of main stitch, program ends.

// A function to calculate the digit sum of a number
== function digit_sum(n) ==
{n > 9: // If given a number greater than 9, recurse
    ~ return (n % 10) + digit_sum(n / 10)
}
~ return n // Otherwise, return the input (it's a single digit)

C (gcc) , 80 79 78 바이트

i,j;r;v;f(n){for(r=v=n;i=--r;v=n-i?v:r)for(;i<n;)for(j=i;i+=j%10,j/=10;);n=v;}

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

ceilingcat에서 -2