^{Isso é diferente do que o My Word pode bater no seu Word , pois é menos complexo e requer apenas que você o calcule, e não os compare.}

Para encontrar a raiz digital, pegue todos os dígitos de um número, adicione-os e repita até obter um número de um dígito. Por exemplo, se o número era 12345, você gostaria de acrescentar 1, 2, 3, 4, e 5, recebendo 15. Você então adicionaria 1e 5, dando a você 6.

Sua tarefa

Dado um número inteiro N (0 <= N <= 10.000) através STDIN , imprimir a raiz digital do N .

Casos de teste

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

Lembre-se de que isso é código-golfe , portanto o código com o menor número de bytes vence.

Pyke, 1 byte

s

Experimente aqui!

Pega a raiz digital da entrada

Geléia , 7 5 4 3 bytes

ḃ9Ṫ

TryItOnline! ou todos os casos de teste

Quão?

A raiz digitais é conhecida a obedecer à fórmula (n-1)% 9 + 1.
É o mesmo que o último dígito na base bijetiva 9
(e devido à implementação que 0ḃ9=[]e []Ṫ=0isso lida com o caso de zero).

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

JavaScript (ES6), 16 10 bytes

n=>--n%9+1

Casos de teste

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 bytes

9X\

Experimente online!

Muitas (respostas agora excluídas) tentaram usar o módulo 9 para obter o resultado. Este é um ótimo atalho, mas infelizmente não funciona para múltiplos de 9. O MATL tem uma função para módulo no intervalo [1, n]. Usando este módulo, temos 1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1, etc. Essa resposta simplesmente pega o módulo de entrada nove usando esse módulo personalizado.

Mathematica, 27 11 bytes

Mod[#,9,1]&

O Mathematica Modusa um terceiro parâmetro como um deslocamento da faixa resultante do módulo. Isso evita diminuir a entrada e aumentar a saída.

Python, 16 20 bytes

+4 bytes para lidar com maiúsculas e minúsculas zero.

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

repl.it

Julia, 12 bytes

!n=mod1(n,9)

ou

n->mod1(n,9)

mod1é uma alternativa à modqual mapeia o intervalo em [1, n]vez de [0, n).

PHP, 15 bytes

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

Versão anterior PHP, 55 bytes

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

Haskell, 35 34 bytes

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

Try it on Ideone.

Explanation:

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 bytes

Includes +2 for -lp

Give input on STDIN

root.pl <<< 123

root.pl

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

This is the boring solution that has already been given in many languages, but at least this version supports 0 too

More interesting doing real repeated additions (though in another order) is in fact only 1 byte longer:

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

R, 72 67 29 bytes

Edit: Thanks to @rturnbull for shaving off two bytes.

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

Retina, 7 bytes

{`.
*
.

Try it online!

I see lots of mathematical solutions, but in Retina the straightforward approach seems to be the best one.

Explanation

{` makes the whole program run in a loop until the string doesn't change anymore. The loop consists of two stages:

.
*

Convert each digit to unary.

.

Count the number of characters (=convert the unary number to decimal).

This works because converting each digit to unary with no separator between digits creates a single unary number which is equal to the sum of all digits.

Brachylog, 9 bytes

#0|@e+:0&

Try it online!

Explanation

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

Alternative approach, 11 bytes

:I:{@e+}i#0

This one uses the meta-predicate i - Iterate to call I times the predicate {@e+} on the input. This will try values of I from 0 to infinity until one makes it so that the output of i is a single digit which makes #0 true.

JavaScript (ES6), 41 38 bytes

Saved 3 bytes, thanks to Bassdrop Cumberwubwubwub

Takes and returns a string.

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

Test cases

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 bytes

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

Interpreter

Explanation:

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)

Thanks to 8478 (Martin Ender) for -6 bytes.

CJam, 6 bytes

ri(9%)

Suggested by 8478 (Martin Ender). Interpreter

I was thinking about it, but Martin just got it before me. Explanation:

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

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Explicação

.+
$*

Converter entrada para unário.

(1{9})*\B

Tome um módulo baseado em 1 removendo noves que tenham pelo menos mais um caractere depois deles.

1

Conte o número restante de 1s para converter novamente em decimal.

Perl 6 , 29 bytes

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

Expandido:

{ # 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
}

Fator , 24

Resposta inteligente e matemática .

[ neg bitnot 9 mod 1 + ]

63 para solução iterativa burra:

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

Labirinto , 8 bytes

?(_9%)!@

usando a equação (n-1)%9+1:

• ? lê a entrada como decimal e a envia para a pilha
• ( diminui o topo da pilha
• _ coloca um zero no topo da pilha
• 9 empurre a parte superior da pilha estalada vezes 10 o dígito (neste caso, 9)
• % aparece y, aparece x, empurra x% y
• ) incrementa o topo da pilha
• ! aparece o topo da pilha e coloca-o como uma string decimal
• @ finaliza o programa

Pitão - 7 4 6 7 bytes

Não é a melhor, mas ainda supera uma quantidade decente de respostas:

|ejQ9 9

Como a versão anterior, mas também manipulando casos de múltiplos de 9, usando lógica ou.

Esta versão falha no 45 testcase :

ejQ9

Explicação:

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

Experimente aqui

Experimente a versão anterior aqui!

Soluções anteriores:

&Qh%tQ9

Explicação :

    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

Você está convidado a experimentar aqui !

APL (Dyalog) , 15 bytes de 9 bytes

××1+9|-∘1

Experimente online!

Hexagonia, 19 15 bytes

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

Mais legível:

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

Experimente online!

-3 bytes, adotando uma abordagem diferente, tornando o caso da aresta 0 trivial.
-1 byte corrigindo 0 erro de caso de borda

Usando a fórmula ((n-1) mod 9) + 1, como muitas outras soluções também.

K (oK) , 9 bytes

Solução:

(+/.:'$)/

Experimente online!

Explicação:

Super direto. Divida o número em dígitos e resuma - faça isso até o resultado convergir:

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

Barril , 6 bytes (SBCS no wiki do barril)

¿;9%1+

Explicação:

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

Ruby, 12 bytes

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