แรงบันดาลใจจากรากดิจิตอลตัวเลขรากที่สำคัญของตัวเลขคือจำนวนที่ปรากฏเมื่อคุณนำปัจจัยสำคัญของตัวเลขเพิ่มเข้าด้วยกันและทำซ้ำกระบวนการตามจำนวนผลลัพธ์ต่อเนื่องจนกว่าคุณจะจบลงด้วยจำนวนเฉพาะ ( ซึ่งมีตัวเองเป็นปัจจัยสำคัญเท่านั้นและเป็นรากของตัวเองที่สำคัญของตัวเอง) นายกแฟคทอเรียลของ 4 คือ 4 ในขณะที่ 2 * 2 = 2 + 2 และนี่เป็นเพียงรากที่ไม่สำคัญเฉพาะของจำนวนเต็มมากกว่า 1 (ซึ่งเป็นอีกกรณีพิเศษเนื่องจากไม่มีปัจจัยสำคัญ) ลำดับ OEIS ที่เกิดขึ้นจากราก factoral สำคัญคือA029908

ตัวอย่างเช่นรูต factoral ที่สำคัญของ 24 คือ:

24=2*2*2*3

2+2+2+3=9=3*3

3+3=6=2*3

2+3=5, and the only prime factor of 5 is 5.  Therefore, the prime factoral root of 24 is 5.  

งานของคุณ:

เขียนโปรแกรมหรือฟังก์ชั่นที่ค้นหารูทแฟคทอเรียลของจำนวนเต็มอินพุท

การป้อนข้อมูล:

จำนวนเต็มป้อนวิธีการที่เหมาะสมระหว่าง 2 ถึงจำนวนเต็มที่ใหญ่ที่สุดภาษาของคุณจะสนับสนุน (รวม) ไม่อนุญาตให้เลือกภาษาที่มีขนาดเต็มจำนวนสูงสุดต่ำเกินไปอย่างไม่สมเหตุสมผล (และละเมิดช่องโหว่มาตรฐานนี้ด้วย )

เอาท์พุท:

จำนวนเต็มซึ่งเป็นรูตสำคัญของอินพุต

กรณีทดสอบ:

4   -> 4
24  -> 5
11  -> 11
250 -> 17

เกณฑ์การให้คะแนน:

นี่คือโค้ดกอล์ฟคะแนนต่ำสุดเป็นไบต์ชนะ!

05AB1E , 3 ไบต์

FÒO

ลองออนไลน์!

คำอธิบาย:

FÒO   
F    Loops <input> times + 1
 Ò   List of prime factors w/ duplicates
  O  Total sum of the list
     -- implicit output

Haskell , 61 ไบต์

import Data.Numbers.Primes
until=<<((==)=<<)$sum.primeFactors

ลองออนไลน์!

คำอธิบาย

until=<<((==)=<<)ใช้เวลาการทำงานfและนำไปใช้กับการป้อนข้อมูลxจนถึงจุดแก้ไขถึงนั่นคือเท่ากับf x ส่งคืนรายการปัจจัยหลักของตัวเลขให้ผลรวมของรายการตัวเลขxprimeFactorssum

แต่เดี๋ยวก่อนทำไม until=<<((==)=<<) ถึงทำงานและดูแปลก ๆ

ถ้าเราสมมติf=sum.primeFactorsความหมายที่เป็นธรรมชาติมากขึ้นก็until(\x->f x==x)fคือuntilจะใช้คำกริยา (ฟังก์ชั่นที่ส่งกลับบูลีน) ซึ่งเป็นฟังก์ชันที่มีอินพุตและผลตอบแทนประเภทเดียวกัน (เช่นInt -> Int) และค่าของประเภทนี้แล้วจึงใช้ฟังก์ชันกับ ค่าจนกว่าเพรดิเคตจะเป็นจริง

until(\x->f x==x)fเป็นเช่นเดียวกับuntil(\x->(==)(f x)x)fและเป็นมันถือได้ว่าg (h x) xเป็นเช่นเดียวกับที่เราได้รับ(g=<<h)x until(\x->((==)=<<f)x)fหลังจากที่กทพแปลงuntil((==)=<<f)fนี้จะกลายเป็น แต่ถ้าตอนนี้เรารักษา(==)=<<เป็นฟังก์ชั่นซึ่งจะนำไปใช้กับfเราจะเห็นได้ว่าuntil(((==)=<<)f)fเป็นอีกครั้งในรูปแบบg (h x) xที่มีg=until, h=((==)=<<)และดังนั้นจึงสามารถนำมาเขียนใหม่เพื่อx=f (until=<<((==)=<<))fการใช้ตัว$ดำเนินการเพื่อกำจัดวงเล็บด้านนอกและการแทนที่fด้วยsum.primeFactorsผลลัพธ์จะได้คำตอบจากด้านบน

Husk , 4 ไบต์

ω(Σp

ลองออนไลน์!

คำอธิบาย:

ω(   -- apply the following function until the result no longer changes (fixpoint)
  Σ  -- sum
   p -- the list of primefactors

Pyth , 3 ไบต์

usP

ลองที่นี่

คำอธิบาย:

usPGQ The trailing GQ is implicit
  PG  Get prime factors
 s    Sum
u   Q Repeat until returned value no longer unique starting with the input

Python 2 , 84 ไบต์

f=lambda n,d=2:n>1and(n%d and f(n,d+1)or d+f(n/d))
i=input()
exec'i=f(i);'*i
print i

ลองออนไลน์!

Java 8, 175 144 142 141 ไบต์

n->{for(int i,t=n,x;;n=t){for(i=2;i<t;t=t%i++<1?0:t);if(t>1|n<5)return n;for(t=0,i=1;i++<n;)for(;n%i<1;n/=i,t+=x)for(x=i;x>9;x/=10)t+=x%10;}}

-1 ขอบคุณไบต์@Nevay

แตกต่างจากไบต์เดียวในภาษากอล์ฟบางภาษา Java ค่อนข้างละเอียดสำหรับการตรวจสอบเฉพาะ, ปัจจัยหลัก, ผลรวมหลักและดังนั้นฉันเดาว่าน้อยกว่า 200 ไม่โทรมเกินไป
สามารถมีแนวโน้มมากที่สุดยังคงแข็งแรงเล่นกอล์ฟโดยการรวมลูปและไม่ได้ใช้วิธีการเวียนเกิดแยกออกจากกันเป็นจำนวนหลัก

คำอธิบาย:

ลองที่นี่

n->{                // Method with integer as both parameter and return-type
  for(int i,        //  Index-integer `i`
          t=n,      //  Temp integer `t`, starting at the input `n`
          x;        //  Temp integer `x`
      ;             //  Loop (1) indefinitely
      n=t){         //    After every iteration, replace `n` with the value `t`
    for(i=2;        //   Reset `i` to 2
        i<t;        //   Inner loop (2) from 2 to `t` (exclusive)
        t=t%i++<1?  //    If `t` is divisible by `i`:
           0        //     Set `t` to 0
          :         //    Else:
           t        //     Leave `t` the same
    );              //   End of inner loop (2)
    if(t>1          //   If `t` is not 0 (it means it's a prime),
       |n<5)        //   or if `n` is below 5 (for edge-cases `4` and 'prime' `1`)
      return n;     //    Return `n` as result
    for(t=0,        //   Reset `t` to 0
        i=1;        //   Reset `i` to 1
        i++<n;)     //   Inner loop (3) from 2 to `n` (inclusive)
      for(;n%i<1;   //    Inner loop (4) as long as `n` is divisible by `i`
          n/=i,     //      After every iteration: Divide `n` by `i`,
          t+=x)     //      and increase `t` by `x`
        for(x=i;    //     Reset `x` to `i`
            x>9;    //     Inner loop (5) as long as `x` contains more than 1 digit
            x/=10)  //       After every iteration, remove the trailing digit
          t+=n%10;  //      Increase `t` with the trailing digit of `n`
                    //     End of inner loop (5) (implicit / single-line body)
                    //    End of inner loop (4) (implicit / single-line body)
                    //   End of inner loop (3) (implicit / single-line body)
  }                 //  End of loop (1)
}                   // End of method

เยลลี่ 5 ไบต์

ÆfS$¡

คำอธิบาย:

Æf    list of prime factors
  S   sum
   $¡ repeat n times

ลองออนไลน์!

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

{+`(\1|\b11+?\B)+$
$1;$#1$*
;

เข้าและส่งออกในเอก

ลองออนไลน์! (ทำการแปลงทศนิยม / unary เพื่อความสะดวก)

คำอธิบาย

{+`(\1|\b11+?\B)+$
$1;$#1$*

{สั่ง Retina เพื่อเรียกใช้โปรแกรมทั้งหมดในวงจนผ่านเต็มล้มเหลวในการแก้ไขสตริงคือจนกว่าจะมีการจุดคงที่จะมาถึง ดังนั้นโปรแกรมคำนวณหนึ่งขั้นตอนของการสรุปปัจจัยสำคัญของค่าปัจจุบัน

ขั้นตอนนี้เองคำนวณการแยกตัวประกอบสำคัญของอินพุต +คล้ายกับ{แต่ลูปเพียงขั้นตอนนี้จนกว่ามันจะหยุดการเปลี่ยนแปลงสตริง regex พยายามจับคู่การเรียกใช้สุดท้ายของ1s โดยจับคู่ substring เดียวกันซ้ำ ๆ (เช่นตัวคูณ) \1วิธีนี้จะทำเป็นบิตซับซ้อนเนื่องจากการอ้างอิงไปข้างหน้า ในการทำซ้ำครั้งแรกกลุ่ม1ยังไม่ได้จับอะไรเลยจึง\1ล้มเหลวอย่างไม่มีเงื่อนไข แต่เราต้องจับคู่\b11+?\Bซึ่งเป็นสตริงย่อยที่เล็กที่สุดที่เป็นไปได้ซึ่งเริ่มต้นที่จุดเริ่มต้นของการรันมีอย่างน้อยสอง1s และไม่ครอบคลุมการรันทั้งหมด \bซ้ำที่ตามมาจะไม่สามารถที่จะใช้ทางเลือกนี้อีกครั้งเนื่องจาก ดังนั้นในการทำซ้ำทั้งหมดเรากำลังจับคู่\1คือสตริงย่อยเดียวกันซ้ำแล้วซ้ำอีก กระบวนการนี้จะต้องกดจุดสิ้นสุดของสตริงอย่างแม่นยำ ( $) เพื่อให้แน่ใจว่าเราได้บันทึกและตัวหารจริง ประโยชน์ของการใช้วิธีการที่ค่อนข้างยุ่งยากนี้เป็นกลุ่มที่1จะได้รับใช้ว่าn / dครั้งคือสิ่งที่ยังคงอยู่หลังจากการแบ่งออกหารd

เราแทนที่การแข่งขันนี้ด้วยd ( $1), การแยก;และn / d ( $#1$*ซึ่งแทรก$#1สำเนาของ1, ซึ่ง$#1เป็นจำนวนการจับที่ทำโดยกลุ่ม1)

กระบวนการนี้จะหยุดลงเมื่อการเรียกใช้ครั้งสุดท้ายในสตริงนั้นเป็นตัวการสำคัญเพราะ regex จะไม่ตรงกันอีกต่อไป

;

ทั้งหมดที่เราต้องทำเพื่อหาจำนวนเฉพาะคือลบตัวคั่นทั้งหมด

โอห์ม v2 , 4 ไบต์

·ΘoΣ

ลองออนไลน์!

คำอธิบาย:

·Θ    evaluate the block until the result returned has already been seen
   Σ  sum
  o   the full prime factorization

ที่จริงแล้ว 7 ไบต์

⌠w♂πΣ⌡Y

ลองออนไลน์!

คำอธิบาย:

⌠w♂πΣ⌡Y
⌠    ⌡Y  do this until output stops changing (fixed-point combinator)
 w         factor into [prime, exponent] pairs
  ♂π       product of each pair
    Σ      sum of products

R + pracma , 53 ไบต์

function(n){for(i in 1:n)n=sum(pracma::factors(n))
n}

ลองออนไลน์! (R-ซอ)

R ไม่ได้มีปัจจัยสำคัญในตัว แต่แพคเกจจำนวนมาก ( pracma, numbersฯลฯ ) ทำเพื่อฉันเลือกระยะสั้นสิ่งอำนวยความสะดวกอย่างใดอย่างหนึ่ง

เยลลี่ขนาด 6 ไบต์

คำตอบนี้จะใช้อย่างใดอย่างหนึ่งวุ้นหลาย builtins repeat until the results are no longer uniqueตัวประกอบที่สำคัญและรวดเร็วสำหรับ

ÆfSµÐL

ลองออนไลน์!

MATL , 6 ไบต์

ใช้แนวคิดของ scottinet ในการวนซ้ำมากกว่าที่ต้องการ ขอขอบคุณShaggyที่ชี้ให้เห็นข้อผิดพลาดตอนนี้ได้รับการแก้ไข

t:"Yfs

ลองออนไลน์!

คำอธิบาย

t       % Take input (implicit). Duplicate
:"      % Do the following that many times
  Yf    %   Array of prime factors
  s     %   Sum of array
        % End (implicit). Display (implicit)

PowerShellขนาด 124 ไบต์

function f($a){for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}}}
for($x=$args[0];$l-ne$x){$l=$x;$x=(f($x))-join'+'|iex}$x

ลองออนไลน์!

PowerShell ไม่มี built-in ตัวแยกตัวประกอบสำคัญดังนั้นจึงใช้รหัสจากคำตอบของฉันกับเพื่อนตัวคูณตัวประกอบ (บรรทัดบนสุด) เพื่อทำการคำนวณการแยกตัวประกอบ

บรรทัดที่สองคือเนื้อของโปรแกรมนี้ เราจะใช้ข้อมูลจาก$argsเข้าไป$xแล้วforห่วงจน$lเป็น-nOT equal $xไป การทำซ้ำครั้งแรก$lคือ$nullและ$xเป็นจำนวนเต็มดังนั้นเราจะวนซ้ำอย่างน้อยหนึ่งครั้ง)

ภายในวงเราตั้งค่าของเรา$l = $xเพื่อตรวจสอบว่าเราตีปลายวงหรือไม่ จากนั้นเราก็จะได้รับปัจจัยของ$xกับf($x), -joinผู้ร่วมกับ+และ|iexพวกเขา (สั้นInvoke-Expressionและคล้ายกับeval) มันถูกเก็บไว้ใน$xนั้น ดังนั้นเราจึงกดปุ่ม "จบ" ซึ่งการแยกตัวประกอบที่สำคัญรวมกันกลับมาเป็นของตัวเอง จากนั้นเราก็วาง$xบนท่อและเอาท์พุทเป็นนัย

Mathematica, 35 ไบต์

#//.x_:>Tr[1##&@@@FactorInteger@x]&

ลองออนไลน์!

(คณิตศาสตร์ไม่รองรับTrฉันต้องใช้มันเอง)

Ruby , 63 ไบต์

->n{n.times{n=n.prime_division.map{|x|x.reduce:*}.sum};n}

ลองออนไลน์!

ใช้-rprimeธง 6 ไบต์จะทำให้การใช้งานของนายกรัฐมนตรี # prime_division

prime_divisionส่งคืนคู่ของ[prime, exponent](ตัวอย่างเช่นสำหรับ 24 เรามีปัจจัยที่[2, 2, 2, 3]ให้มัน[[2, 3], [3, 1]]) ในแต่ละขั้นตอนเราแค่คูณสมาชิกของคู่เหล่านั้นเข้าด้วยกันและรวมผลลัพธ์

Javascript (ES6), 63 ไบต์

f=n=>(q=(p=(m,x)=>m<x?0:m%x?p(m,x+1):x+p(m/x,x))(n,2))^n?f(q):q

<input id=i type=number min=0 value=0 oninput="o.innerText=f(i.value)">
<p id=o></p>

Ungolfed:

f=n=>(                  // Recursive function `f`
    p=(m,x=2)=>(        //   Recursive function `p`, used to sum prime factors
        m<x?            //     If m (the number to be factored) is less than x (the current
            0           //     iteration), return 0
        :m%x?           //     Else if m doesn't divide x
            p(m,x+1)    //     run the next iteration
        :               //     Else (if m divides x)
            x+p(m/x,x)  //     Divide m by x and repeat the current iteration
    ),
    q=p(n),             //   Set q to the sum of the prime factors of n
    q^n?                //   If q != n then
        f(q)            //     repeat f with q
    :                   //   else
        q               //     return q
)

Java 8, 101 ไบต์

n->{for(int i=n;i-->0;n=f(n,2));return n;}int f(int n,int d){return n>1?n%d>0?f(n,d+1):d+f(n/d,2):0;}

ท่าเรือ@ovsที่น่าตื่นตาตื่นใจงูหลาม 2 คำตอบ

คำอธิบาย:

ลองที่นี่

n->{                  // Method with integer as both parameter and return-type
  for(int i=n;i-->0;  //  Loop the input amount of times
    n=f(n,2)          //   And change `n` that many times with a separate method call
  );                  //  End of loop
  return n;           //  Then return the integer `n` as result
}                     // End of method

int f(int n,int d){   // Separated method with 2 integer parameters and integer return-type
                      // (`d` is 2 when we initially call this recursive-method)
  return n>1?         //  If input `n` is larger than 1:
    n%d>0?            //   And it's not divisible by `d`:
     f(n,d+1)         //    Do a recursive-call with `n, d+1`
    :                 //   Else:
     d                //    Sum `d` with
      +f(n/d,2)       //    a recursive call with `n/d, 2`
   :                  //  Else:
    0;                //   Simply return 0
}                     // End of separated method