ให้กำหนดลำดับที่: ลำดับ n หลักข้อสรุป (n-DSS) เป็นลำดับที่เริ่มต้นด้วยn หากหมายเลขที่ผ่านมาเป็นkแล้วจำนวนต่อไปคือk + หลักผลรวม (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 บาทรวมว่าเป็นจำนวนที่ได้รับปรากฏใน. นี้เรียกว่า "ฟังก์ชั่นโคลอมเบียผกผัน" และเป็นA036233 ยี่สิบคำแรกที่เริ่มต้นด้วย 1 คือ:

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ดังนั้นคำตอบที่สั้นที่สุดในแต่ละภาษาจะชนะ

Haskell , 104 64 63 ไบต์

(-26 ขอบคุณ H.PWiz เพิ่มเติม -14 ขอบคุณ Sriotchilism O'Zaic เพิ่มเติม -1 ขอบคุณ cole)

นี่คือฟังก์ชั่น

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

ลองออนไลน์!

คำอธิบาย:

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

ลำดับของฟังก์ชันผสมที่ส่งคืน y + ผลรวมดิจิตอลของ y แปลงเป็นสตริงก่อนจากนั้นจึงทำยิมนาสติก monad เพื่อรับผลรวมของตัวละครและหมายเลขดั้งเดิม (ขอบคุณ Cole)

<*>ผู้ประกอบการในบริบทนี้มีประเภทและความหมาย

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

เพื่อให้เราสามารถเขียนข้างต้นเป็น

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

สิ่งนี้read . pureจะแปลง a Charเป็นตัวเลขดังนั้น(+) . read . pure :: Char -> Int -> Intเพิ่มตัวเลขลงในค่าสะสม ค่านี้ถูกเตรียมใช้งานกับหมายเลขที่กำหนดในครึ่งหน้า

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

untilใช้ฟังก์ชันซ้ำกับผลลัพธ์ของมัน (ในกรณีนี้คือ y + ผลรวมดิจิตอล y) จนกระทั่งเป็นไปตามข้อกำหนดที่ระบุโดยฟังก์ชันในอาร์กิวเมนต์แรก สิ่งนี้ให้องค์ประกอบ y-DSS ที่เล็กที่สุดซึ่งมากกว่าหรือเท่ากับ x

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

รายการขี้เกียจที่ไม่มีที่สิ้นสุดของ y ซึ่งองค์ประกอบ y-DSS ที่เล็กที่สุด> = x เป็นจริง x ใช้สัญกรณ์รายการความเข้าใจของ Haskell (ซึ่งฉันก็ลืมไปซะทั้งหมดขอบคุณ)

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

องค์ประกอบแรกของรายการนั้นซึ่งเป็น y ที่เล็กที่สุดที่ตอบสนองความต้องการของความท้าทาย

Python 2 , 73 71 ไบต์

-2 ไบต์ขอบคุณที่เอริค

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

ลองออนไลน์!

Perl 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

Ruby , 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นี้ช่วยให้ increqsing nจนกว่าแรกiแง่ของnลำดับ -th iได้แก่ มันเพียงพอที่จะทดสอบiคำศัพท์สำหรับแต่ละลำดับเนื่องจากลำดับนั้นเพิ่มขึ้น

`         % 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)

Forth (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 (เนื่องจากผลรวมหลักคืออย่างน้อยเสมอ ดังนั้นการเพิ่มซ้ำของปริมาณประเภทนี้ไม่สามารถส่งผลให้ ค่าน้อยกว่า ) และตรวจสอบว่าอยู่ในคำศัพท์แรกของ -DSS หรือไม่ อย่างไรก็ตามใน Pyth โครงสร้างการไหลของการควบคุมที่มีอยู่ทำให้ง่ายต่อการสร้างคำศัพท์จนกว่าจะตรงตามเงื่อนไขบางประการแทนที่จะเป็นจำนวนคำที่แน่นอน$n$$k$$1$$n$$n$$n$$k$

เยลลี่ขนาด 9 ไบต์

DS+)i$ƬṖṪ

การเชื่อมโยงเอกยอมรับเป็นจำนวนเต็มบวกnที่ทำให้จำนวนเต็มบวกที่ผกผันของโคลอมเบียa(n)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

Python 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)])

ลองออนไลน์!

วิธีนี้ใช้ได้กับกรณีทดสอบทั้งหมดรวมทั้งรายการ 1..88 ทั้งหมดที่ได้รับจาก OEIS แต่ยังคงฉันไม่ได้ค่อนข้างแน่ใจว่ามันเป็นสรรพสิ่งที่ถูกต้อง (นี่เป็นหนึ่งในข้อร้องเรียนของฉันเกี่ยวกับการทดสอบหน่วยศาสนจักร :))

ภาษา Wolfram (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เพราะinputเป็นองค์ประกอบแรกของinputลำดับที่ ฉันไม่ได้พิสูจน์ทางเทคนิคว่าวิธีนี้ใช้ได้เสมอ แต่จะผ่านทุกกรณีทดสอบที่ฉันทดสอบ

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

ลองออนไลน์!

JavaScript ขนาด 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 แต่เสียค่าใช้จ่ายอีกหนึ่งไบต์

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

Forth (gforth) , 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 bytes) ชิ้นส่วน golfed คือ:

• การคำนวณผลรวมตัวเลข (-6)
• การล้างข้อมูลสุดท้าย (-1) โดยการพิมพ์ขยะไปยัง stdout (ไม่มีปัญหาเนื่องจากผลลัพธ์ถูกส่งคืนที่ด้านบนสุดของสแต็ก)

มันทำงานอย่างไร

: 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&}#)

ลองออนไลน์!

Gaiaขนาด 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

Gaiaขนาด 16 ไบต์

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

ลองออนไลน์!

ใช้การสังเกตที่ทำโดยนาย 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

Gaiaขนาด 16 ไบต์

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

ลองออนไลน์!

วิธีที่สามไม่ได้ใช้N-find, #แต่ยังคงอาศัยการสังเกตเช่นเดียวกับวิธีการกลาง ส่งคืนจำนวนเต็มแทนที่จะเป็นรายการ

Clojure , 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 ไบต์ แต่ผลลัพธ์ใน Stack Overflow สำหรับอินพุตที่ใหญ่กว่า (อาจจะทำให้ 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 # Interactive Compiler) , 75 ไบต์

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

ลองออนไลน์!

Husk , 14 10 ไบต์

^{-4 ขอบคุณ @ H.PWiz}

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 โดยการแปลงเป็นโปรแกรมเต็มรูปแบบซึ่งรับอินพุตแบบยูนารี

สิ่งนี้ให้ความรู้สึกนานเกินไปที่จะไม่สามารถเล่นกอล์ฟได้

Ungolfed

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

ลองออนไลน์!

-2 จากแมวป่า