^{Questo è diverso da My Word può battere la tua Word in quanto è meno complessa e richiede solo di calcolarla e non confrontarla.}

Per trovare la radice digitale, prendi tutte le cifre di un numero, aggiungile e ripeti finché non ottieni un numero di una cifra. Ad esempio, se il numero fosse 12345, si dovrebbe aggiungere 1, 2, 3, 4, e 5, sempre 15. Quindi aggiungeresti 1e 5, dandoti 6.

Il tuo compito

Dato un intero N (0 <= N <= 10000) attraverso STDIN , stampare la radice numerica di N .

Casi test

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

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

Pyke, 1 byte

s

Provalo qui!

Accetta la radice digitale dell'input

Gelatina , 7 5 4 3 byte

ḃ9Ṫ

TryItOnline! o tutti i casi di test

Come?

La radice numerica si caratterizza per rispettare la formula (n-1) + 1% 9.
Questo è lo stesso dell'ultima cifra nella base biiettiva 9
(e grazie all'implementazione che 0ḃ9=[]e []Ṫ=0questo gestisce il caso limite di zero).

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

JavaScript (ES6), 16 10 byte

n=>--n%9+1

Casi 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 byte

9X\

Provalo online!

Molte (risposte ora eliminate) hanno provato a utilizzare il modulo 9 per ottenere il risultato. Questo è un ottimo collegamento, ma sfortunatamente non funziona per multipli di 9. MATL ha una funzione per modulo sull'intervallo [1, n]. Usando questo modulo, abbiamo 1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1, ecc. Questa risposta prende semplicemente l'input modulo nove usando questo modulo personalizzato.

Mathematica, 27 11 byte

Mod[#,9,1]&

Mathematica Modaccetta un terzo parametro come offset dell'intervallo risultante del modulo. Ciò evita il decremento dell'ingresso e l'incremento dell'uscita.

Python, 16 20 byte

+4 byte per gestire il caso limite pari a zero.

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

repl.it

Julia, 12 byte

!n=mod1(n,9)

o

n->mod1(n,9)

mod1è un'alternativa a modquale mappa dell'intervallo [1, n]anziché [0, n).

PHP, 15 byte

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

Versione precedente PHP, 55 byte

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

Haskell, 35 34 byte

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

Provalo su Ideone.

Spiegazione:

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 byte

Include +2 per -lp

Dare input su STDIN

root.pl <<< 123

root.pl

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

Questa è la soluzione noiosa che è già stata fornita in molte lingue, ma almeno questa versione supporta 0anche

Più interessante fare aggiunte ripetute reali (anche se in un altro ordine) è in realtà solo 1 byte più lungo:

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

R, 72 67 29 byte

Modifica: grazie a @rturnbull per la rasatura di due byte.

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

Retina , 7 byte

{`.
*
.

Provalo online!

Vedo molte soluzioni matematiche, ma in Retina l'approccio diretto sembra essere il migliore.

Spiegazione

{`rende l'intero programma eseguito in un ciclo fino a quando la stringa non cambia più. Il ciclo è costituito da due fasi:

.
*

Converti ogni cifra in unaria.

.

Contare il numero di caratteri (= convertire il numero unario in decimale).

Questo funziona perché la conversione di ogni cifra in unaria senza separatore tra le cifre crea un singolo numero unario che è uguale alla somma di tutte le cifre.

Brachylog , 9 byte

#0|@e+:0&

Provalo online!

Spiegazione

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

Approccio alternativo, 11 byte

: I: {@ e +} i # 0

Questo usa il meta-predicato i - Iterateper chiamare Ivolte il predicato {@e+}sull'input. Questo proverà valori da Ida 0a infinito fino a quando uno non lo farà in modo che l'output di isia una singola cifra che diventa #0vera.

JavaScript (ES6), 41 38 byte

Salvato 3 byte, grazie a Bassdrop Cumberwubwubwub

Prende e restituisce una stringa.

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

Casi 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 byte

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

Interprete

Spiegazione:

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)

Grazie a 8478 (Martin Ender) per -6 byte.

CJam, 6 byte

ri(9%)

Suggerito da 8478 (Martin Ender). Interprete

Ci stavo pensando, ma Martin me l'ha appena preso. Spiegazione:

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

Java 7, 63 byte

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

Funzione ricorsiva che ottiene solo cifre con mod / div. Nulla di bello.

Porto economico

di Jonathan Allan sarebbe un misero 28 byte:

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

Python 2, 54 51 byte

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

Grazie a Oliver e Karl Napf per avermi aiutato a salvare 3 byte

Python, 45 byte

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

Prende l'argomento come una stringa.

05AB1E , 6 byte

[SODg#

Provalo online!

Spiegazione

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

C, 64 29 byte

Porta C dalla risposta di Jonathan Allan (con il caso speciale 0).

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

Codice a 64 byte precedente:

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

qprende la somma incrociata e si fripete prendendo la somma incrociata fino a una singola cifra.

Retina , 15 byte

.+
$*
1{9}\B

1

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

Spiegazione

.+
$*

Converti input in unario.

(1{9})*\B

Prendi un modulo basato su 1 rimuovendo nove che hanno almeno un carattere in più dopo di loro.

1

Contare il numero rimanente di 1s per riconvertire in decimale.

Perl 6 , 29 byte

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

Allargato:

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

Fattore , 24

Risposta intelligente e mathica .

[ neg bitnot 9 mod 1 + ]

63 per soluzione iterativa muta:

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

Labirinto , 8 byte

?(_9%)!@

usando l'equazione (n-1)%9+1:

• ? legge l'input come decimale e lo inserisce nello stack
• ( decrementa la parte superiore della pila
• _ spinge uno zero in cima alla pila
• 9 spingere la parte superiore della pila spuntata per 10 volte la cifra (in questo caso, 9)
• % fa apparire y, fa apparire x, spinge x% y
• ) incrementa la parte superiore della pila
• ! apre la parte superiore dello stack e lo inserisce come una stringa decimale
• @ termina il programma

Pyth - 7 4 6 7 byte

Non il migliore, ma batte comunque una discreta quantità di risposte:

|ejQ9 9

Come la versione precedente, ma gestendo anche casi di multipli di 9, usando logico o.

Questa versione non supera il testcase 45 :

ejQ9

Spiegazione:

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

Provalo qui

Prova qui la versione precedente!

Soluzioni precedenti:

&Qh%tQ9

Spiegazione :

    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

Sei invitato a provarlo qui !

APL (Dyalog) , 15 9 byte byte

××1+9|-∘1

Provalo online!

Esagonia, 19 15 byte

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

Più leggibile:

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

Provalo online!

-3 byte adottando un approccio diverso, rendendo banale il caso 0 edge.
-1 byte correggendo il bug di 0 edge case

Utilizzando la formula ((n-1) mod 9) + 1 come molte altre soluzioni.

K (oK) , 9 byte

Soluzione:

(+/.:'$)/

Provalo online!

Spiegazione:

Super semplice. Dividi il numero in cifre e riassumi: fallo fino a quando il risultato non converge:

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

¿;9%1+

Spiegazione:

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

Rubino, 12 byte

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