^{Це відрізняється від " Моє слово" - це може вибити ваше Слово, оскільки воно менш складне і вимагає лише обчислити його, а не порівнювати їх.}

Щоб знайти цифровий корінь, візьміть усі цифри числа, додайте їх і повторюйте, поки не отримаєте одноцифрове число. Наприклад, якщо номер був 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

Пам'ятайте, що це код-гольф , тому виграє код з найменшою кількістю байтів.

Пайк, 1 байт

s

Спробуйте тут!

Бере цифровий корінь вводу

Желе , 7 5 4 3 байт

ḃ9Ṫ

СпробуйтеItOnline! або всі тестові випадки

Як?

Як відомо, цифровий корінь відповідає формулі (n-1)% 9 + 1.
Це те саме, що і остання цифра в біективній базі 9
(і завдяки застосуванню, що 0ḃ9=[]і []Ṫ=0цим обробляє крайній випадок нуля).

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

JavaScript (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і т. Д. Ця відповідь просто приймає вхідний модуль дев'ять, використовуючи цей власний модуль.

Математика, 27 11 байт

Mod[#,9,1]&

Mathematica's Modприймає третій параметр як зміщення отриманого діапазону модуля. Це дозволяє уникнути зменшення введення та збільшення виходу.

Пітон, 16 20 байт

+4 байти для обробки крайового випадку нуля.

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

repl.it

Джулія, 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;

Haskell, 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

Perl, 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 байт

Редагування: Дякуємо @rturnbull за те, що голили два байти.

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

Сітківка , 7 байт

{`.
*
.

Спробуйте в Інтернеті!

Я бачу багато математичних рішень, але у Retina прямо підхід здається найкращим.

Пояснення

{`змушує всю програму працювати в циклі, поки рядок більше не змінюється. Петля складається з двох етапів:

.
*

Перетворіть кожну цифру в одинакову.

.

Порахуйте кількість символів (= перетворіть одинарне число в десяткове).

Це працює, тому що перетворення кожної цифри в одинарну без роздільника між цифрами створює єдине одинарне число, яке дорівнює сумі всіх цифр.

Брахілог , 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істинним.

JavaScript (ES6), 41 38 байт

Збережено 3 байти, завдяки Bassdrop Cumberwubwubwub

Бере і повертає рядок.

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)

Завдяки 8478 (Мартін Ендер) за -6 байт.

CJam, 6 байт

ri(9%)

Запропоновано 8478 (Мартін Ендер). Перекладач

Я думав про це, але Мартін якраз це отримав перед собою. Пояснення:

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

Java 7, 63 bytes

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

Recursive function which just gets digits with mod/div. Nothing fancy.

Cheap port

of Jonathan Allan's would be a measly 28 bytes:

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

Python 2, 54 51 bytes

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

Thanks to Oliver and Karl Napf for helping me save 3 bytes

Python, 45 bytes

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

Takes the argument as a string.

05AB1E, 6 bytes

[SODg#

Try it online!

Explanation

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

C, 64 29 bytes

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}