^{Bu farklıdır senin Kelime dövebilecek Benim kelime daha az karmaşık olduğu gibi ve sadece hesaplandığını ve bunları karşılaştırmak değil gerektirir.}

Dijital kökü bulmak için, bir sayının tüm rakamlarını alın, ekleyin ve tek basamaklı bir sayı alana kadar tekrarlayın. Sayısıydı Örneğin, 12345ekleyebilir olur 1, 2, 3, 4, ve 5, elde 15. Daha sonra ekler 1ve 5verirsiniz 6.

Senin görevin

STDIN üzerinden N (0 <= N <= 10000) tamsayısı verildiğinde , N'nin dijital kökünü yazdırın .

Test senaryoları

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

Unutmayın, bu kod golfüdür , bu nedenle en az bayt içeren kod kazanır.

Pyke, 1 bayt

s

Burada deneyin!

Girişin dijital kökünü alır

Jöle , 7 5 4 3 bayt

ḃ9Ṫ

TryItOnline! veya tüm test senaryoları

Nasıl?

Dijital kök formül (n-1),% 9 + 1 uymak bilinmektedir.
Bu, iki temelli tabandaki 9 son basamağıyla aynıdır
(ve uygulama nedeniyle 0ḃ9=[]ve []Ṫ=0bu sıfırın kenarını ele alır).

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

JavaScript (ES6), 16 10 bayt

n=>--n%9+1

Test senaryoları

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 bayt

9X\

Çevrimiçi deneyin!

Sonucu almak için bir çok (şimdi silinen cevaplar) modulo 9'u kullanmayı denedi. Bu harika bir kısayoldur, ancak maalesef 9'un katları için işe yaramaz. MATL, aralıkta modulo için bir işleve sahiptir [1, n]. Bu modüloyu kullanarak 1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1, vb. Var . Bu cevap, bu özel modüloyu kullanarak girdi modülo dokuzunu alır.

Mathematica, 27 11 bayt

Mod[#,9,1]&

Mathematica's Modüçüncü bir parametreyi, sonuçtaki modulo aralığının bir ofseti olarak alır. Bu, girdinin azaltılmasını ve çıktının artırılmasını önler.

Python, 16 20 bayt

Kenarın sıfır olması için +4 bayt.

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

repl.it

Julia, 12 bayt

!n=mod1(n,9)

veya

n->mod1(n,9)

mod1yerine modaralıkla [1, n]eşlenen bir alternatiftir [0, n).

PHP, 15 Bayt

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

Önceki sürüm PHP, 55 Bayt

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

Haskell, 35 34 bayt

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

Ideone üzerinde deneyin.

Açıklama:

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 bayt

İçin +2 içerir -lp

STDIN'e giriş verin

root.pl <<< 123

root.pl

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

Bu zaten birçok dilde verilen sıkıcı bir çözümdür, ancak en azından bu sürüm destekliyor 0 de

Daha ilginç gerçek tekrarlı eklemeler yapmak (başka bir sırada olsa da) aslında sadece 1 bayt daha uzun:

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

R, 72 67 29 bayt

Düzenleme: İki baytın tıraş olması için @rturnbull'a teşekkürler.

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

Retina , 7 bayt

{`.
*
.

Çevrimiçi deneyin!

Pek çok matematiksel çözüm görüyorum, ancak Retina'da doğrudan yaklaşım en iyisi gibi görünüyor.

açıklama

{`dize artık değişmedikçe tüm programın bir döngü içinde çalışmasını sağlar. Döngü iki aşamadan oluşur:

.
*

Her basamağı tekli olarak dönüştürün.

.

Karakter sayısını sayın (= tekli sayıyı ondalık sayıya dönüştür).

Bu, her basamağı basamaklar arasında ayırıcı olmadan tek sayıya dönüştürmek, tüm basamakların toplamına eşit tek bir tek sayı oluşturması nedeniyle çalışır.

Brachylog , 9 bayt

#0|@e+:0&

Çevrimiçi deneyin!

açıklama

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

Alternatif yaklaşım, 11 bayt

I: {@ e +} i # 0

Bu , girdi üzerindeki yüklemin çarpımını i - Iterateçağırmak için meta yüklemi kullanır . Bu değerlerini çalışacağız dan biri çıkışı böylece onu yapana kadar sonsuza kılan tek bir rakamdır doğrudur.I{@e+}I0i#0

JavaScript (ES6), 41 38 bayt

Bassdrop Cumberwubwubwub sayesinde 3 bayt kaydedildi

Bir dize alır ve döndürür.

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

Test senaryoları

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 bayt

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

yorumlayıcı

Açıklama:

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)

-6 bayt için 8478'e (Martin Ender) teşekkürler.

CJam, 6 bayt

ri(9%)

8478 (Martin Ender) tarafından önerildi. yorumlayıcı

Bunu düşünüyordum, ama Martin benden önce aldı. Açıklama:

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

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}