^{Esto es diferente de Mi Palabra puede golpear tu Palabra, ya que es menos compleja y solo requiere que la calcules y no la compares.}

Para encontrar la raíz digital, tome todos los dígitos de un número, agréguelos y repita hasta obtener un número de un dígito. Por ejemplo, si el número era 12345, añadiría 1, 2, 3, 4, y 5, conseguir 15. Luego agregarías 1y 5, dándote 6.

Tu tarea

Dado un número entero N (0 <= N <= 10.000) a través de STDIN , imprimir la raíz digital del N .

Casos de prueba

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

Recuerde, este es el código de golf , por lo que gana el código con el menor número de bytes.

Pyke, 1 byte

s

Pruébalo aquí!

Toma la raíz digital de la entrada

Gelatina , 7 5 4 3 bytes

ḃ9Ṫ

TryItOnline! o todos los casos de prueba

¿Cómo?

Se sabe que la raíz digital obedece la fórmula (n-1)% 9 + 1.
Este es el mismo que el último dígito de la base de biyectiva 9
(y debido a que la aplicación 0ḃ9=[]y []Ṫ=0crear el mango del borde de los casos de cero).

ḃ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 prueba

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\

Pruébalo en línea!

Muchos (respuestas ahora eliminadas) intentaron usar el módulo 9 para obtener el resultado. Este es un gran atajo, pero desafortunadamente no funciona para múltiplos de 9. MATL tiene una función para módulo en el intervalo [1, n]. Usando este módulo, tenemos 1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1, etc. Esta respuesta simplemente toma el módulo de entrada nueve usando este módulo personalizado.

Mathematica, 27 11 bytes

Mod[#,9,1]&

Mathematica Modtoma un tercer parámetro como un desplazamiento del rango resultante del módulo. Esto evita disminuir la entrada e incrementar la salida.

Python, 16 20 bytes

+4 bytes para manejar el caso de borde de cero.

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

repl.it

Julia, 12 bytes

!n=mod1(n,9)

o

n->mod1(n,9)

mod1es una alternativa a la modque se asigna el rango en [1, n]lugar de [0, n).

PHP, 15 bytes

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

Versión 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

Pruébalo en Ideone.

Explicación:

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

Incluye +2 para -lp

Dar entrada sobre STDIN

root.pl <<< 123

root.pl

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

Esta es la solución aburrida que ya se ha dado en muchos idiomas, pero al menos esta versión admite 0 también es

Más interesante hacer adiciones repetidas reales (aunque en otro orden) es, de hecho, solo 1 byte más:

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

R, 72 67 29 bytes

Editar: Gracias a @rturnbull por reducir dos bytes.

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

Retina , 7 bytes

{`.
*
.

Pruébalo en línea!

Veo muchas soluciones matemáticas, pero en Retina el enfoque directo parece ser el mejor.

Explicación

{`hace que todo el programa se ejecute en un bucle hasta que la cadena ya no cambie. El ciclo consta de dos etapas:

.
*

Convierte cada dígito a unario.

.

Cuente el número de caracteres (= convierta el número unario a decimal).

Esto funciona porque la conversión de cada dígito a unario sin separador entre dígitos crea un único número unario que es igual a la suma de todos los dígitos.

Brachylog , 9 bytes

#0|@e+:0&

Pruébalo en línea!

Explicación

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

Enfoque alternativo, 11 bytes

: I: {@ e +} i # 0

Éste usa el meta-predicado i - Iteratepara llamar a Iveces el predicado {@e+}en la entrada. Esto intentará valores de Idesde 0hasta el infinito hasta que uno lo haga de modo que la salida de isea ​​un solo dígito que sea #0verdadero.

JavaScript (ES6), 41 38 bytes

Guardado 3 bytes, gracias a Bassdrop Cumberwubwubwub

Toma y devuelve una cadena.

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

Casos de prueba

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

Interprete

Explicación:

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)

Gracias a 8478 (Martin Ender) por -6 bytes.

CJam, 6 bytes

ri(9%)

Sugerido por 8478 (Martin Ender). Interprete

Estaba pensando en eso, pero Martin acaba de enterarse antes que yo. Explicación:

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

Función recursiva que solo obtiene dígitos con mod / div. Nada sofisticado.

Puerto barato

de Jonathan Allan serían unos miserables 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 

Gracias a Oliver y Karl Napf por ayudarme a ahorrar 3 bytes.

Python, 45 bytes

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

Toma el argumento como una cadena.

05AB1E , 6 bytes

[SODg#

Pruébalo en línea!

Explicación

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

C, 64 29 bytes

C port de la respuesta de Jonathan Allan (con caso especial 0).

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

Código de 64 bytes anterior:

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

qtoma la suma cruzada y frepite tomando la suma cruzada hasta un solo dígito.

Retina , 15 bytes

.+
$*
1{9}\B

1

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

Explicación

.+
$*

Convierta la entrada a unario.

(1{9})*\B

Tome un módulo basado en 1 eliminando nueves que tengan al menos un carácter más después de ellos.

1

Cuente el número restante de 1s para convertir de nuevo a 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
}

Factor 24

Inteligente , mathy respuesta.

[ neg bitnot 9 mod 1 + ]

63 para una solución iterativa tonta:

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

Laberinto , 8 bytes

?(_9%)!@

usando la ecuación (n-1)%9+1:

• ? lee la entrada como decimal y la empuja a la pila
• ( disminuye la parte superior de la pila
• _ empuja un cero en la parte superior de la pila
• 9 empuje la parte superior de la pila reventada 10 veces el dígito (en este caso, 9)
• % aparece y, aparece x, empuja x% y
• ) incrementa la parte superior de la pila
• ! aparece la parte superior de la pila y la coloca como una cadena decimal
• @ termina el programa

Pyth - 7 4 6 7 bytes

No es la mejor, pero aún supera una buena cantidad de respuestas:

|ejQ9 9

Como la versión anterior, pero manejando también casos de múltiplos de 9, usando lógica o.

Esta versión falla el caso de prueba 45 :

ejQ9

Explicación:

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

Pruébalo aquí

¡Prueba la versión anterior aquí!

Soluciones anteriores:

&Qh%tQ9

Explicación :

    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

¡Estás invitado a probarlo aquí !

APL (Dyalog) , 15 bytes de 9 bytes

××1+9|-∘1

Pruébalo en línea!

Hexagonia 19 15 bytes

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

Más legible:

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

Pruébalo en línea!

-3 bytes adoptando un enfoque diferente, haciendo que el caso de borde 0 sea trivial.
-1 byte arreglando el error de caso de borde 0

Usando la fórmula ((n-1) mod 9) + 1 como muchas otras soluciones también.

K (oK) , 9 bytes

Solución:

(+/.:'$)/

Pruébalo en línea!

Explicación:

Súper sencillo. Divida el número en dígitos y resuma: haga esto hasta que el resultado converja:

(+/.:'$)/ / 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 en Keg wiki)

¿;9%1+

Explicación:

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

Rubí, 12 bytes.

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