^{이것은 내 단어 와 다릅니다. 단어 가 덜 복잡하고 단어 를 계산하고 비교하지 않아도되므로 단어를 이길 수 있습니다.}

디지털 근을 찾으려면 숫자의 모든 자릿수를 가져 와서 한 자리 숫자가 될 때까지 반복하십시오. 숫자가 있다면 예를 들어 12345, 당신은 추가 할 1, 2, 3, 4,과 5, 점점 15. 그런 다음 추가 할 수 1및 5당신을 제공,6 .

당신의 작업

정수 주어 N (0 <= N 을 통해 <= 10000) STDIN 의 디지털 인쇄 루트 N을 .

테스트 사례

1 -> 1
45 -> 9
341 -> 8
6801 -> 6
59613 -> 6
495106 -> 7

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

파이크, 1 바이트

s

여기 사용해보십시오!

입력의 디지털 루트를 취합니다

젤리 , 7 5 4 3 바이트

ḃ9Ṫ

TryItOnline! 또는 모든 테스트 사례

어떻게?

디지털 루트는 화학식 (N-1) + 1 % (9)을 준수하는 것으로 알려져있다.
이것은 bijective base 9의 마지막 숫자 와 같습니다 (
구현으로 인해 0의 모서리를 처리합니다).0ḃ9=[][]Ṫ=0

ḃ9Ṫ - Main link: n
ḃ9  - convert to bijective base 9 digits (a list)
  Ṫ - tail (get the last digit)

자바 스크립트 (ES6), 16 10 바이트

n=>--n%9+1

테스트 사례

let f =

n=>--n%9+1

console.log(f(1)); // -> 1
console.log(f(45)); // -> 9
console.log(f(341)); // -> 8
console.log(f(6801)); // -> 6
console.log(f(59613)); // -> 6
console.log(f(495106)); // -> 7

MATL , 3 바이트

9X\

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

많은 (현재 삭제 된 답변)은 모듈로 9를 사용하여 결과를 얻었습니다. 이것은 훌륭한 지름길이지만 불행히도 9의 배수에는 작동하지 않습니다. MATL에는 구간의 모듈로 기능이 [1, n]있습니다. 이 모듈로를 사용하면 우리는 1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1등 을 갖습니다 .이 답변은 단순히이 사용자 정의 모듈로를 사용하여 입력 모듈로 9를 가져옵니다.

수학, 27 11 바이트

Mod[#,9,1]&

Mathematica Mod는 모듈로의 결과 범위의 오프셋으로 세 번째 매개 변수를 사용합니다. 이렇게하면 입력을 줄이고 출력을 늘리지 않아도됩니다.

파이썬, 16 20 바이트

에지 케이스 0을 처리하기 위해 +4 바이트.

lambda n:n and~-n%9+1

반복

줄리아, 12 바이트

!n=mod1(n,9)

또는

n->mod1(n,9)

mod1대신에 mod범위에 매핑 되는 대안 [1, n]입니다 [0, n).

PHP, 15 바이트

<?=--$argn%9+1;

이전 버전 PHP, 55 바이트

$n=$argn;while($n>9)$n=array_sum(Str_split($n));echo$n;

하스켈, 35 34 바이트

until(<10)$sum.map(read.pure).show

Ideone에서 사용해보십시오.

설명:

until(<10)$sum.map(read.pure).show
                              show  -- convert int to string
               map(         ).      -- turn each char (digit) into
                        pure        --    a string 
                   read.            --    and then a number
           sum.                     -- sum up the list of numbers
until(<10)$                         -- repeat until the result is < 10

펄, 15 바이트

에 +2 포함 -lp

STDIN에 입력하십시오

root.pl <<< 123

root.pl

#!/usr/bin/perl -lp
$_&&=~-$_%9+1

이것은 이미 여러 언어로 제공하고있다 지루한 솔루션을하지만, 적어도이 버전의 지원 0도

실제 반복되는 덧셈을하는 것이 더 흥미로운 것은 (다른 순서로도) 실제로는 1 바이트 만 길다는 것입니다.

#!/usr/bin/perl -p
s%%$_+=chop%reg

R, 72 67 29 바이트

편집 : 2 바이트를 깎아 준 @rturnbull에게 감사드립니다.

n=scan();`if`(n%%9|!n,n%%9,9)

망막 , 7 바이트

{`.
*
.

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

많은 수학적 솔루션을 볼 수 있지만 Retina에서는 간단한 접근 방식이 최선의 방법 인 것 같습니다.

설명

{`문자열이 더 이상 변경되지 않을 때까지 전체 프로그램을 루프로 실행합니다. 루프는 두 단계로 구성됩니다.

.
*

각 숫자를 단항으로 변환하십시오.

.

문자 수를 세십시오 (= 단수를 10 진수로 변환).

이것은 숫자 사이에 구분 기호가없는 각 숫자를 단항으로 변환하면 모든 숫자의 합과 동일한 단일 단항 숫자가 생성되기 때문에 작동합니다.

Brachylog , 9 바이트

#0|@e+:0&

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

설명

#0            Input = Output = a digit
  |           OR
   @e         Split the input into a list of digits
     +        Sum
      :0&     Call this predicate recursively

대체 접근 방식, 11 바이트

: I : {@ e +} i # 0

이것은 메타 술어 를 사용하여 입력에서 술어 i - Iterate를 호출하는 I시간 {@e+}입니다. 이 값을 다할 것입니다 I에서 0하나의 출력이 너무을하게 될 때까지 무한대 i하게 한 자리입니다 #0사실.

자바 스크립트 (ES6), 41 38 바이트

Bassdrop Cumberwubwubwub 덕분에 3 바이트 절약

문자열을 가져 와서 반환합니다.

f=s=>s[1]?f(''+eval([...s].join`+`)):s

테스트 사례

f=s=>s[1]?f(''+eval([...s].join`+`)):s

console.log(f("1")); // -> 1
console.log(f("45")); // -> 9
console.log(f("341")); // -> 8
console.log(f("6801")); // -> 6
console.log(f("59613")); // -> 6
console.log(f("495106")); // -> 7

CJam , 19 13 바이트

r{:~:+_s\9>}g

통역사

설명:

r{:~:+_s\9>}g Code
r             Get token
 {:~:+_s\9>}  Block: :~:+_s\9>
   ~          Eval
  :           Map
     +        Add
    :         Map
      _       Duplicate
       s      Convert to string
        \     Swap
         9    9
          >   Greater than
            g Do while (pop)

-6 바이트에 대해 8478 (Martin Ender)에게 감사합니다.

CJam, 6 바이트

ri(9%)

8478 (Martin Ender)이 제안합니다. 통역사

나는 그것에 대해 생각하고 있었다. 그러나 Martin는 단지 나의 앞에 그것을 얻었다. 설명:

ri(9%) Code
r      Get token
 i     Convert to integer
  (    Decrement
   9   9
    %  Modulo
     ) Increment

자바 7, 63 바이트

int f(int n){int s=0;for(;n>0;n/=10)s+=n%10;return s>9?f(s):s;}

mod / div로 숫자를 얻는 재귀 함수. 멋진 것은 없습니다.

저렴한 포트

의 조나단 앨런의 순대 28 바이트가 될 것입니다 :

int f(int n){return~-n%9+1;}

파이썬 2, 54 51 바이트

i=input()
while~-len(i):i=`sum(map(int,i))`
print i 

3 바이트를 절약 할 수 있도록 도와 준 Oliver와 Karl Napf에게 감사합니다.

파이썬, 45 바이트

f=lambda x:x[1:]and f(`sum(map(int,x))`)or x

인수를 문자열로 사용합니다.

05AB1E , 6 바이트

[SODg#

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

설명

[        # infinite loop
 S       # split into digits
  O      # sum digits
   Dg#   # if length == 1: break

C, 64 29 바이트

C port from Jonathan Allan's answer (with special case 0).

f(i){return i>0?~-i%9+1:0;}

Previous 64 byte code:

q(i){return i>9?i%10+q(i/10):i;}
f(i){i=q(i);return i>9?f(i):i;}

q takes the cross sum and f repeats taking the cross sum until a single digit.

Retina, 15 bytes

.+
$*
1{9}\B

1

Try it online! (The first line enables a linefeed-separated test suite.)

Explanation

.+
$*

Convert input to unary.

(1{9})*\B

Take 1-based modulo by removing nines that have at least one more character after them.

1

Count the remaining number of 1s to convert back to decimal.

Perl 6, 29 bytes

{($_,*.comb.sum...10>*)[*-1]}

Expanded:

{ # bare block lambda with implicit parameter ｢$_｣
  ( # generate a sequence

    $_,         # starting with the input
    *.comb.sum  # Whatever lambda that splits into digits, and finds sum
    ...         # keep doing that
    10 > *      # until it is less than 10

  )[ * - 1 ] # get the last value
}

Factor, 24

Smart, mathy answer.

[ neg bitnot 9 mod 1 + ]

63 for dumb iterative solution:

[ [ dup 9 > ] [ number>string >array [ 48 - ] map sum ] while ]

Labyrinth, 8 bytes

?(_9%)!@

using the equation (n-1)%9+1:

• ? reads the input as decimal and pushes it to the stack
• ( decrements the top of the stack
• _ pushes a zero onto the top of the stack
• 9 push the top of the stack popped times 10 the digit (in this case, 9)
• % pops y, pops x, pushes x%y
• ) increments the top of the stack
• ! pops the top of the stack and out puts it as a decimal string
• @ terminates the program

Pyth - 7 4 6 7 bytes

Not the best one, but still beats a decent amount of answers:

|ejQ9 9

Like the previous version, but handling also cases of multiples of 9, using logical or.

This version fails the 45 testcase:

ejQ9

Explanation:

 jQ9  -> converting the input to base 9
e     -> taking the last digit

Try it here

Try the previous version here!

Previous solutions:

&Qh%tQ9

Explanation:

    tQ    -> tail: Q-1
   %tQ9   -> Modulo: (Q-1)%9
  h%tQ9   -> head: (Q-1)%9+1
&Qh%tQ9   -> Logical 'and' - takes the first null value. If Q is 0 - returns zero, otherwise returns the (Q-1)%9+1 expression result

You're invited to try it here!

APL (Dyalog), 15 9 bytes bytes

××1+9|-∘1

Try it online!

Hexagony, 19 15 bytes

.?<9{(/>!@!/)%' 

More Readable:

  . ? < 
 9 { ( /
> ! @ ! / 
 ) % ' .
  . . . 

Try it online!

-3 bytes by taking a different approach, making the 0 edge case trivial.
-1 byte by fixing 0 edge case bug

Using the formula ((n-1) mod 9) + 1 like a lot of other solutions aswell.

K (oK), 9 bytes

Solution:

(+/.:'$)/

Try it online!

Explanation:

Super straightforward. Break number into digits and sum up - do this until the result converges:

(+/.:'$)/ / the solution
(      )/ / do this until result converges
      $   / string, 1234 => "1234"
   .:'    / value each, "1234" => 1 2 3 4
 +/       / sum over, 1 2 3 4 => 10

Keg, 6 bytes(SBCS on Keg wiki)

¿;9%1+

Explanation:

¿#      Take implicit input
 ;9%1+# Digital Root Formula
# Implicit output

Ruby, 12 bytes

->n{~-n%9+1}