^{Ceci est différent de My Word peut battre votre Word car il est moins complexe et vous oblige seulement à le calculer, et non à les comparer.}

Pour trouver la racine numérique, prenez tous les chiffres d'un nombre, ajoutez-les et répétez jusqu'à obtenir un numéro à un chiffre. Par exemple, si le nombre était 12345, vous devez ajouter 1, 2, 3, 4et 5, obtenir 15. Vous ajouteriez alors 1et 5, vous donnant 6.

Ta tâche

Compte tenu d' un nombre entier N (0 <= N <= 10 000) à travers STDIN , imprimer la racine numérique de N .

Cas de test

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

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le plus petit nombre d'octets l'emporte.

Pyke, 1 octet

s

Essayez-le ici!

Prend la racine numérique de l'entrée

Gelée , 7 5 4 3 octets

ḃ9Ṫ

TryItOnline! ou tous les cas de test

Comment?

La racine numérique est connue pour obéir à la formule (n-1)% 9 + 1.
Ceci est le même que le dernier chiffre dans la base bijective 9
(et en raison de la mise en œuvre que 0ḃ9=[]et []Ṫ=0ces manches du bord cas de zéro).

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

JavaScript (ES6), 16 10 octets

n=>--n%9+1

Cas de test

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 octets

9X\

Essayez-le en ligne!

Beaucoup de réponses (maintenant supprimées) ont essayé d'utiliser modulo 9 pour obtenir le résultat. C'est un excellent raccourci, mais ne fonctionne malheureusement pas pour les multiples de 9. MATL a une fonction pour modulo sur l'intervalle [1, n]. En utilisant ce modulo, nous avons 1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1, etc. Cette réponse prend simplement le modulo d'entrée neuf en utilisant ce modulo personnalisé.

Mathematica, 27 11 octets

Mod[#,9,1]&

Mathematica Modprend un troisième paramètre comme décalage de la plage résultante du modulo. Cela évite de décrémenter l'entrée et d'incrémenter la sortie.

Python, 16 20 octets

+4 octets pour gérer le cas de bord de zéro.

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

repl.it

Julia, 12 octets

!n=mod1(n,9)

ou

n->mod1(n,9)

mod1est une alternative à modlaquelle correspond à la plage [1, n]au lieu de [0, n).

PHP, 15 octets

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

Version précédente PHP, 55 octets

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

Haskell, 35 34 octets

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

Essayez-le sur Ideone.

Explication:

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 octets

Comprend +2 pour -lp

Donnez votre avis sur STDIN

root.pl <<< 123

root.pl

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

C'est la solution ennuyeuse qui a déjà été donnée dans de nombreuses langues, mais au moins cette version prend 0également en charge

Plus intéressant de faire des ajouts répétés réels (bien que dans un autre ordre) n'est en fait que de 1 octet de plus:

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

R, 72 67 29 octets

Edit: Merci à @rturnbull pour avoir rasé deux octets.

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

Rétine , 7 octets

{`.
*
.

Essayez-le en ligne!

Je vois beaucoup de solutions mathématiques, mais à Retina, l'approche directe semble être la meilleure.

Explication

{`fait exécuter le programme entier en boucle jusqu'à ce que la chaîne ne change plus. La boucle se compose de deux étapes:

.
*

Convertissez chaque chiffre en unaire.

.

Comptez le nombre de caractères (= convertissez le nombre unaire en décimal).

Cela fonctionne car la conversion de chaque chiffre en unaire sans séparateur entre les chiffres crée un seul nombre unaire qui est égal à la somme de tous les chiffres.

Brachylog , 9 octets

#0|@e+:0&

Essayez-le en ligne!

Explication

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

Approche alternative, 11 octets

: I: {@ e +} i # 0

Celui-ci utilise le méta-prédicat i - Iteratepour appeler Ifois le prédicat {@e+}sur l'entrée. Cela va essayer des valeurs de Ide 0à l'infini jusqu'à ce que l'on fasse en sorte que la sortie de isoit un seul chiffre qui soit #0vrai.

JavaScript (ES6), 41 38 octets

Enregistré 3 octets, grâce à Bassdrop Cumberwubwubwub

Prend et renvoie une chaîne.

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

Cas de test

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 octets

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

Interprète

Explication:

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)

Merci à 8478 (Martin Ender) pour -6 octets.

CJam, 6 octets

ri(9%)

Proposé par 8478 (Martin Ender). Interprète

J'y pensais, mais Martin vient de me le donner. Explication:

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

Java 7, 63 octets

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

Fonction récursive qui obtient juste des chiffres avec mod / div. Rien d'extraordinaire.

Port pas cher

de Jonathan Allan serait un maigre 28 octets:

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}