^{สิ่งนี้แตกต่างจากMy Word ที่สามารถเอาชนะ Word ของคุณได้เนื่องจากมีความซับซ้อนน้อยกว่าและต้องการให้คุณคำนวณเท่านั้นและไม่เปรียบเทียบมัน}

ในการค้นหารูทดิจิทัลใช้ตัวเลขทั้งหมดของตัวเลขเพิ่มและทำซ้ำจนกว่าคุณจะได้รับตัวเลขหนึ่งหลัก ตัวอย่างเช่นถ้าตัวเลขเป็น12345คุณจะต้องเพิ่ม1, 2, 3, 4และได้รับ5 15จากนั้นคุณจะเพิ่ม1และให้คุณ56

งานของคุณ

ได้รับจำนวนเต็มN (0 <= N <= 10000) ผ่านSTDINพิมพ์รากดิจิตอลN

กรณีทดสอบ

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

จำไว้ว่านี่คือcode-golfดังนั้นโค้ดที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

Pyke 1 ไบต์

s

ลองที่นี่!

ใช้รูทดิจิทัลของอินพุต

เยลลี่ , 7 5 4 3 ไบต์

ḃ9Ṫ

TryItOnline! หรือกรณีทดสอบทั้งหมด

อย่างไร?

รากดิจิตอลเป็นที่รู้จักกันที่จะปฏิบัติตามสูตร (n-1) 9% + 1
นี่เป็นตัวเลขเดียวกับหลักสุดท้ายในฐาน bijective 9
(และเนื่องจากการใช้งาน0ḃ9=[]และ[]Ṫ=0สิ่งนี้จะจัดการกับกรณีขอบของศูนย์)

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

JavaScript (ES6), 16 10 ไบต์

n=>--n%9+1

กรณีทดสอบ

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 ไบต์

9X\

ลองออนไลน์!

(คำตอบที่ถูกลบไปแล้วจำนวนมาก) พยายามใช้ modulo 9 เพื่อให้ได้ผลลัพธ์ นี้เป็นทางลัดที่ดี แต่น่าเสียดายที่ไม่ได้ผลสำหรับหลายรายการ 9. MATL [1, n]มีฟังก์ชั่นสำหรับการโมดูโลในช่วงเวลา การใช้โมดูโล่นี้เรามี1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1ฯลฯ คำตอบนี้ใช้อินพุทโมดูโลเก้าโดยใช้โมดูโล่แบบกำหนดเองนี้

Mathematica, 27 11 ไบต์

Mod[#,9,1]&

Mathematica Modใช้พารามิเตอร์ที่สามเป็นออฟเซ็ตของช่วงผลลัพธ์ของโมดูโล สิ่งนี้หลีกเลี่ยงการลดอินพุตและการเพิ่มเอาต์พุต

Python 16 16ไบต์

+4 ไบต์เพื่อจัดการกรณีขอบเป็นศูนย์

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

repl.it

Julia ขนาด 12 ไบต์

!n=mod1(n,9)

หรือ

n->mod1(n,9)

mod1เป็นอีกทางเลือกกับผู้modที่แมปกับช่วงแทน[1, n][0, n)

PHP, 15 ไบต์

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

PHP รุ่นก่อนหน้า, 55 ไบต์

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

Haskell, 35 34 ไบต์

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

ลองใช้กับ Ideone

คำอธิบาย:

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 ไบต์

รวมถึง +2 สำหรับ -lp

ให้อินพุตบน STDIN

root.pl <<< 123

root.pl

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

นี่เป็นโซลูชันที่น่าเบื่อที่มีให้ในหลายภาษาแล้ว แต่อย่างน้อยรุ่นนี้0ก็รองรับเช่นกัน

สิ่งที่น่าสนใจกว่าคือการเพิ่มสิ่งที่เกิดขึ้นจริงซ้ำ ๆ (แม้ว่าจะอยู่ในลำดับอื่น ๆ ) จริงๆแล้วมีความยาวเพียง 1 ไบต์:

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

R, 72 67 29 ไบต์

แก้ไข: ขอบคุณ @rturnbull สำหรับการลบสองไบต์

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

เรติน่า 7 ไบต์

{`.
*
.

ลองออนไลน์!

ฉันเห็นโซลูชันทางคณิตศาสตร์มากมาย แต่ใน Retina วิธีการที่ตรงไปตรงมาดูเหมือนจะดีที่สุด

คำอธิบาย

{`ทำให้โปรแกรมทั้งหมดทำงานในลูปจนกว่าสตริงจะไม่เปลี่ยนอีกต่อไป การวนซ้ำประกอบด้วยสองขั้นตอน:

.
*

แปลงตัวเลขแต่ละหลักเป็นเอก

.

นับจำนวนตัวอักษร (= แปลงจำนวนยูนารีให้เป็นทศนิยม)

วิธีนี้ใช้งานได้เนื่องจากการแปลงแต่ละหลักให้เป็นเอกเทศโดยไม่มีตัวคั่นระหว่างตัวเลขจะสร้างหมายเลขแบบเอกนารีเดียวซึ่งเท่ากับผลรวมของตัวเลขทั้งหมด

Brachylogขนาด 9 ไบต์

#0|@e+:0&

ลองออนไลน์!

คำอธิบาย

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

ทางเลือกวิธี 11 ไบต์

: ผม: {@ + e} I # 0

อันนี้ใช้ meta-predicate i - Iterateเพื่อเรียกIเวลาเพรดิเคต{@e+}บนอินพุต สิ่งนี้จะลองใช้ค่าIจาก0ถึงอนันต์จนกว่าจะทำให้ค่าผลลัพธ์iเป็นตัวเลขหลักเดียวซึ่งทำให้#0เป็นจริง

JavaScript (ES6), 41 38 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ Bassdrop Cumberwubwubwub

รับและส่งคืนสตริง

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

กรณีทดสอบ

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 ไบต์

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

ล่าม

คำอธิบาย:

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)

ขอบคุณ 8478 (Martin Ender) สำหรับ -6 ไบต์

CJam, 6 ไบต์

ri(9%)

แนะนำโดย 8478 (Martin Ender) ล่าม

ฉันกำลังคิดเกี่ยวกับมัน แต่มาร์ตินเพิ่งได้รับก่อนที่ฉัน คำอธิบาย:

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

Java 7, 63 ไบต์

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

ฟังก์ชั่นวนซ้ำซึ่งเพิ่งได้รับตัวเลขด้วย mod / div ไม่มีอะไรแฟนซี

พอร์ตราคาถูก

ของJonathan Allanจะเป็น 28 ไบต์ที่เลวทรามต่ำช้า:

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

Python 2, 54 51 ไบต์

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

ขอบคุณ Oliver และ Karl Napf ที่ช่วยฉันประหยัด 3 ไบต์

Python ขนาด 45 ไบต์

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

รับอาร์กิวเมนต์เป็นสตริง

05AB1E , 6 ไบต์

[SODg#

ลองออนไลน์!

คำอธิบาย

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

C, 64 29 ไบต์

พอร์ต C จากคำตอบของJonathan Allan (พร้อมกรณีพิเศษ 0)

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

รหัส 64 ไบต์ก่อนหน้า:

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

qใช้เวลาผลรวมไขว้และfทำซ้ำการรวมกันข้ามจนหลักเดียว

เรติน่า 15 ไบต์

.+
$*
1{9}\B

1

ลองออนไลน์! (บรรทัดแรกเปิดใช้งานชุดทดสอบที่แยกบรรทัดด้วยฟีด)

คำอธิบาย

.+
$*

แปลงอินพุตเป็น unary

(1{9})*\B

รับโมดูโล่แบบ 1 ตัวโดยการลบเก้าที่มีอักขระอย่างน้อยหนึ่งตัวขึ้นไป

1

นับจำนวน 1s ที่เหลือเพื่อแปลงกลับเป็นทศนิยม

Perl 6 , 29 ไบต์

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

ขยาย:

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

ปัจจัย , 24

สมาร์ท , Mathyคำตอบ

[ neg bitnot 9 mod 1 + ]

63สำหรับโซลูชันวนซ้ำแบบโง่:

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

เขาวงกต 8 ไบต์

?(_9%)!@

ใช้สมการ(n-1)%9+1:

• ? อ่านอินพุตเป็นทศนิยมและส่งไปที่สแต็ก
• ( ลดค่าส่วนบนสุดของสแต็ก
• _ ดันศูนย์บนด้านบนของสแต็ก
• 9 ดันด้านบนของสแต็คที่ผุดคูณ 10 หลัก (ในกรณีนี้ 9)
• % ปรากฏ y, ปรากฏ x, กด x% y
• ) เพิ่มชั้นบนสุดของสแต็ก
• ! ดึงส่วนบนสุดของสแต็กออกมาวางเป็นสตริงทศนิยม
• @ ยุติโปรแกรม

Pyth - 7 4 6 7 ไบต์

ไม่ใช่คำตอบที่ดีที่สุด แต่ก็ยังมีคำตอบอยู่พอสมควร:

|ejQ9 9

เช่นเดียวกับรุ่นก่อนหน้านี้ แต่การจัดการกรณีของทวีคูณของ 9 ใช้ตรรกะหรือ

รุ่นนี้ล้มเหลวในการทดสอบ 45 ครั้ง :

ejQ9

คำอธิบาย:

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

ลองที่นี่

ลองรุ่นก่อนหน้าที่นี่!

โซลูชันก่อนหน้า:

&Qh%tQ9

คำอธิบาย :

    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

คุณได้รับเชิญให้ลองที่นี่ !

APL (Dyalog) , 15 9 ไบต์ไบต์

××1+9|-∘1

ลองออนไลน์!

Hexagony, 19 15 ไบต์

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

อ่านเพิ่มเติม:

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

ลองออนไลน์!

-3 ไบต์โดยใช้วิธีการที่ต่างกันทำให้ 0 edge case เป็นเรื่องเล็กน้อย
-1 ไบต์โดยแก้ไขบั๊กเคส 0 edge

การใช้สูตร ((n-1) mod 9) + 1 เหมือนโซลูชันอื่น ๆ มากมายเช่นกัน

K (oK) , 9 ไบต์

วิธีการแก้:

(+/.:'$)/

ลองออนไลน์!

คำอธิบาย:

ตรงไปตรงมาสุด แบ่งจำนวนออกเป็นตัวเลขและสรุปผล - ทำสิ่งนี้จนกว่าผลลัพธ์จะมาบรรจบกัน:

(+/.:'$)/ / 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 ไบต์ (SBCS บน Keg wiki)

¿;9%1+

คำอธิบาย:

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

ทับทิมขนาด 12 ไบต์

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