Lấy cảm hứng từ các gốc kỹ thuật số, gốc số nguyên tố của một số là số xuất hiện khi bạn lấy các thừa số nguyên tố của một số, cộng chúng lại với nhau và lặp lại quá trình trên số kết quả, tiếp tục cho đến khi bạn kết thúc với số nguyên tố ( trong đó có chính nó là yếu tố chính duy nhất của nó, và do đó là gốc thực tế chính của nó). Căn nguyên tố chính của 4 là 4, vì 2 * 2 = 2 + 2 và đây là gốc nguyên tố không phải là số nguyên tố duy nhất của một số nguyên lớn hơn 1 (là một trường hợp đặc biệt khác, vì nó không có thừa số nguyên tố). Trình tự OEIS được hình thành bởi các gốc thực tế chính là A029908 .

Ví dụ, gốc thực tế của 24 là:

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.  

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm tìm gốc gốc của số nguyên đầu vào.

Đầu vào:

Một số nguyên, đầu vào thông qua bất kỳ phương thức hợp lý nào, giữa 2 và số nguyên lớn nhất mà ngôn ngữ của bạn sẽ hỗ trợ (bao gồm). Cụ thể, không được phép chọn ngôn ngữ có kích thước số nguyên tối đa thấp một cách vô lý (và cũng vi phạm kẽ hở tiêu chuẩn này )

Đầu ra:

Một số nguyên, gốc thực tế của đầu vào.

Các trường hợp thử nghiệm:

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

Ghi điểm:

Đây là môn đánh gôn , điểm số thấp nhất tính bằng byte!

05AB1E , 3 byte

FÒO

Hãy thử trực tuyến!

Giải thích:

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

Haskell , 61 byte

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

Hãy thử trực tuyến!

Giải trình

until=<<((==)=<<)nhận một hàm fvà áp dụng nó cho đầu vào xcho đến khi đạt đến điểm sửa lỗi, f xbằng x. primeFactorstrả về danh sách các thừa số nguyên tố của một số, summang lại tổng của danh sách các số.

Nhưng chờ đã, tại sao until=<<((==)=<<) công việc và trông rất kỳ lạ?

Nếu chúng ta giả sử f=sum.primeFactors, một định nghĩa tự nhiên hơn sẽ là until(\x->f x==x)f, bởi vì untilcó một biến vị ngữ (một hàm trả về boolean), một hàm có cùng kiểu nhập và trả về (ví dụ Int -> Int) và giá trị của loại này, sau đó áp dụng hàm cho giá trị cho đến khi vị ngữ được hoàn thành.

until(\x->f x==x)flà giống như until(\x->(==)(f x)x)f, và như nó giữ g (h x) xgiống như (g=<<h)x, chúng ta nhận được until(\x->((==)=<<f)x)f. Sau khi chuyển đổi Eta , điều này trở thành until((==)=<<f)f. Nhưng nếu bây giờ chúng ta coi (==)=<<như là một hàm được áp dụng cho f, chúng ta có thể thấy đó until(((==)=<<)f)flà một lần nữa của biểu mẫu g (h x) x, với g=until, h=((==)=<<)và x=f, vì vậy nó có thể được viết lại (until=<<((==)=<<))f. Sử dụng $toán tử để loại bỏ các dấu ngoặc đơn bên ngoài và thay thế fbằng cách sum.primeFactorsmang lại giải pháp từ bên trên.

Husk , 4 byte

ω(Σp

Hãy thử trực tuyến!

Giải trình:

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

Bình thường , 3 byte

usP

Hãy thử nó ở đây.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Java 8, 175 144 142 141 byte

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 byte nhờ @Nevay .

Không giống như các byte đơn trong một số ngôn ngữ chơi gôn, Java khá dài dòng cho các kiểm tra chính, các thừa số nguyên tố, tổng số, và như vậy, vì vậy tôi đoán rằng dưới 200 không quá tồi tệ.
Nhiều khả năng vẫn có thể được đánh golf bằng cách kết hợp các vòng lặp và không sử dụng phương pháp đệ quy riêng cho tổng số chữ số .

Giải trình:

Hãy thử nó ở đây.

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

Thạch , 5 byte

ÆfS$¡

Giải thích:

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

Hãy thử trực tuyến!

Võng mạc , 30 byte

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

Đầu vào và đầu ra trong unary .

Hãy thử trực tuyến!(Thực hiện chuyển đổi thập phân / đơn phương cho thuận tiện.)

Giải trình

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

Các { Retina chạy toàn bộ chương trình trong một vòng lặp cho đến khi vượt qua hoàn toàn không sửa đổi chuỗi, tức là cho đến khi đạt được một điểm cố định. Do đó, chương trình tự tính toán một bước để tổng hợp các yếu tố chính của giá trị hiện tại.

Giai đoạn này tự tính toán hệ số nguyên tố của đầu vào. Điều +này tương tự {nhưng chỉ lặp lại giai đoạn này cho đến khi nó ngừng thay đổi chuỗi. Regex cố gắng khớp với lần chạy cuối cùng ) để đảm bảo chúng tôi đã bắt và ước số thực tế. Lợi ích của việc sử dụng phương pháp hơi khó này là nhóm sẽ được sử dụng chính xác1 s bằng cách lặp lại khớp với cùng một chuỗi con (tức là hệ số). Cách thức này được thực hiện là một chút phức tạp do tham chiếu về phía trước \1. Ở lần lặp đầu tiên, nhóm 1chưa bắt được gì, nên \1thất bại vô điều kiện. Thay vào đó, chúng ta phải khớp với \b11+?\Bchuỗi con nhỏ nhất có thể bắt đầu khi bắt đầu chạy, chứa ít nhất hai 1giây và không bao gồm toàn bộ hoạt động. Lặp đi lặp lại sau đó sẽ không thể sử dụng thay thế này một lần nữa, do \b. Vì vậy, trên tất cả các lần lặp tiếp theo, chúng tôi phù hợp\1, tức là cùng một chuỗi con lặp đi lặp lại. Quá trình này phải đánh vào cuối chuỗi chính xác ( .$1 n / d lần, tức là những gì còn lại sau khi chia ra số chia d

Chúng tôi thay thế trận đấu này bằng d ( $1), một phân tách ;và n / d ( $#1$*, chèn các $#1bản sao của1 , trong đó $#1số lượng ảnh chụp được thực hiện theo nhóm1 ).

Quá trình này dừng lại khi lần chạy cuối cùng trong chuỗi tự nó là một số nguyên tố, vì khi đó regex không còn phù hợp nữa.

;

Tất cả chúng ta cần làm để tổng hợp các số nguyên tố là loại bỏ tất cả các dấu phân cách.

Ohm v2 , 4 byte

·ΘoΣ

Hãy thử trực tuyến!

Giải trình:

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

Trên thực tế , 7 byte

⌠w♂πΣ⌡Y

Hãy thử trực tuyến!

Giải trình:

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

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

Hãy thử trực tuyến! (câu đố)

R không có thừa số nguyên tố được xây dựng trong, nhưng nhiều gói ( pracma, numbers, vv) làm, vì vậy tôi chọn một thuận tiện ngắn.

Thạch , 6 byte

Câu trả lời này sử dụng một trong nhiều nội dung tích hợp nguyên tố chính của Jelly và nhanh chóng repeat until the results are no longer unique.

ÆfSµÐL

Hãy thử trực tuyến!

TOÁN , 6 byte

Sử dụng ý tưởng của scottinet về việc lặp nhiều lần hơn mức cần thiết. Cũng cảm ơn Shaggy vì đã chỉ ra một sai lầm, bây giờ đã sửa chữa.

t:"Yfs

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

PowerShell không có bất kỳ yếu tố tích hợp nguyên tố chính nào, vì vậy, điều này sử dụng mã từ câu trả lời của tôi trên Prime Factors Buddies (dòng trên cùng) để thực hiện các phép tính nhân tố.

Dòng thứ hai là thịt của chương trình này. Chúng tôi có đầu vào từ $argsvào $x, sau đó forvòng lặp cho đến khi $llà -not equal để$x . (Lặp lại đầu tiên, $llà $nullvà$x là một số nguyên, vì vậy chúng tôi sẽ lặp lại ít nhất một lần).

Bên trong vòng lặp, chúng tôi đặt $l = $xmục tiêu xác định xem chúng tôi có kết thúc vòng lặp hay không. Sau đó, chúng tôi nhận được các yếu tố $xvới f($x), -joinnhững người cùng với +và |iexhọ (viết tắt Invoke-Expressionvà tương tự eval). Điều đó được lưu trữ trở lại vào $x. Do đó, chúng ta đã đạt đến "kết thúc" trong đó yếu tố chính được tổng hợp lại với nhau. Sau đó, chúng tôi chỉ cần đặt $xtrên đường ống và đầu ra là ẩn.

Toán học, 35 byte

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

Hãy thử trực tuyến!

(Toán học không hỗ trợ Tr . Tôi phải thực hiện thủ công)

Hồng ngọc , 63 byte

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

Hãy thử trực tuyến!

Sử dụng -rprimecờ cho +6 byte để sử dụng Prime # Prime_division .

prime_divisiontrả về các cặp [prime, exponent](ví dụ: trong 24 chúng ta có các yếu tố [2, 2, 2, 3]do đó cung cấp [[2, 3], [3, 1]]) vì vậy trong mỗi bước, chúng ta chỉ cần nhân các thành viên của các cặp đó lại với nhau và tổng hợp kết quả.

Javascript (ES6), 63 byte

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>

Ung dung:

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 byte

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;}

Cảng Câu trả lời Python 2 tuyệt vời @ovs .

Giải trình:

Hãy thử nó ở đây.

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