^{Это отличается от того, что Мое Слово может разбить ваше Слово, поскольку оно менее сложно и требует только того, чтобы вы его вычисляли, а не сравнивали.}

Чтобы найти цифровой корень, возьмите все цифры числа, добавьте их и повторяйте, пока не получите однозначное число. Например, если номер был 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Ṫ

TryItOnline! или все тестовые случаи

Как?

Известно, что цифровой корень подчиняется формуле (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, и т. Д. Этот ответ просто принимает вход по модулю девять, используя этот пользовательский по модулю.

Mathematica, 27 11 байтов

Mod[#,9,1]&

Mathematica Modпринимает третий параметр в качестве смещения результирующего диапазона по модулю. Это позволяет избежать уменьшения входных данных и увеличения выходных данных.

Python, 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: {@} е + я # 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 байта

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

Python 2, 54 51 байт

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

Спасибо Оливеру и Карлу Напфу за помощь в экономии 3 байтов

Python, 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 из ответа Джонатана Аллана (с особым случаем 0).

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

Предыдущий 64-байтовый код:

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

qберет перекрестную сумму и fповторяет взятие перекрестной суммы до одной цифры.

Сетчатка , 15 байт

.+
$*
1{9}\B

1

Попробуйте онлайн! (Первая строка включает набор тестов, разделенных переводом строки.)

объяснение

.+
$*

Преобразовать ввод в унарный.

(1{9})*\B

Возьмите 1 на основе модуля, удалив девятки, которые имеют по крайней мере еще один символ после них.

1

Посчитайте оставшееся число 1, чтобы преобразовать обратно в десятичную.

Perl 6 , 29 байт

{($_,*.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
}

Фактор , 24

Умный , математический ответ.

[ neg bitnot 9 mod 1 + ]

63 для тупого итеративного решения:

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

Лабиринт , 8 байт

?(_9%)!@

используя уравнение (n-1)%9+1:

• ? читает входные данные как десятичные и помещает их в стек
• ( уменьшает вершину стека
• _ толкает ноль на вершину стека
• 9 нажмите верхнюю часть стопки раз 10 цифр (в данном случае 9)
• % всплывает у, всплывает х, толкает х% у
• ) увеличивает вершину стека
• ! выдвигает вершину стека и выводит ее как десятичную строку
• @ завершает программу

Pyth - 7 4 6 7 байт

Не самый лучший, но все же бьет приличное количество ответов:

|ejQ9 9

Как и в предыдущей версии, но обрабатывает также случаи, кратные 9, используя логические или.

Эта версия не проходит 45 тестов :

ejQ9

Объяснение:

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

Попробуй здесь

Попробуйте предыдущую версию здесь!

Предыдущие решения:

&Qh%tQ9

Пояснение :

    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

Вы приглашены попробовать это здесь !

APL (Dyalog) , 15 9 байт

××1+9|-∘1

Попробуйте онлайн!

Гексагония, 19 15 байт

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

Более читабельно:

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

Попробуйте онлайн!

-3 байта, используя другой подход, делая случай с краем 0 тривиальным.
-1 байт, исправляя ошибку в 0 краях

Используя формулу ((n-1) mod 9) + 1, как и многие другие решения.

K (ок) , 9 байт

Решение:

(+/.:'$)/

Попробуйте онлайн!

Объяснение:

Супер просто. Разбейте число на цифры и суммируйте - делайте это до тех пор, пока результат не сойдет:

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

Кег , 6 байтов (SBCS на Кеге вики)

¿;9%1+

Объяснение:

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

Рубин, 12 байт

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