Phục hồi sức mạnh từ sức mạnh chính


16

Có vẻ như nhiều người muốn có điều này, vì vậy bây giờ nó là phần tiếp theo của thử thách này !

Định nghĩa : công suất nguyên tố là số tự nhiên có thể được biểu thị dưới dạng p n trong đó p là số nguyên tố và n là số tự nhiên.

Nhiệm vụ : Cho công suất nguyên tố p n > 1, trả về công suất n.

Testcase :

input output
9     2
16    4
343   3
2687  1
59049 10

Ghi bàn : Đây là . Câu trả lời ngắn nhất trong byte thắng.


2
Lưu ý : Thử thách này có thể không quan trọng trong một số ngôn ngữ chơi gôn, nhưng nó không quá tầm thường đối với một số ngôn ngữ chính, cũng như ngôn ngữ của tháng 6 năm 2018, QBasic.
Erik the Outgolfer

Chúng ta có thể xuất True thay vì 1 không? Cách khác, float thay vì ints?
Jo King

1
@JoKing vâng, vâng.
Rò rỉ Nun

Câu trả lời:







3

dc , 50 41 byte

1si[dli1+dsi%0<X]dsXx[dli/dli<Y]sYdli<Yzp

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

Lấy đầu vào từ đỉnh ngăn xếp (trong TIO, đặt đầu vào trong tiêu đề để tải nó vào ngăn xếp trước khi thực hiện). Đầu ra cho thiết bị xuất chuẩn.

Giải trình

Đăng ký sử dụng:

i: ước số thử nghiệm hiện tại, trong khi Xđang chạy. Sau đó, số chia chúng tôi đã tìm thấy.

X: macro dli1+dsi%0<X, có hiệu ứng "tăng i, sau đó kiểm tra mô đun với giá trị trên ngăn xếp (sẽ là đầu vào ban đầu). Nếu không phải là 0, lặp lại".

Y: macro dli/dli<Y, có hiệu ứng "Thêm vào ngăn xếp một bản sao của đỉnh hiện tại của ngăn xếp, chia cho i. Lặp lại cho đến khi iđạt được."

Chương trình đầy đủ:

1si                 Initialize i
[dli1+dsi%0<X]dsXx  Define and run X
[dli/dli<Y]sY       Define Y
dli<Y               Run Y, but only if needed (if the input wasn't just i)
z                   The stack is i^n, i^(n-1), ... ,i, so print the stack depth

Tôi tìm thấy một giải pháp tốt hơn nhiều! Chỉnh sửa ngay bây giờ ...
Sophia Lechner

3

mặt , 86 byte

(%d@)\$*,c'$,io>Av"[""mN*c?*m1*mp*m%*s1"$pN1p:~+p1p%%Np?%~:=/NNp+?1?-%N1?%=p%'$i?w1'%>

Hoan hô, dài hơn Java!

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

Tôi đặc biệt thích thủ thuật sử dụng giá trị trả về của sscanf. Thông thường giá trị trả về sẽ bị loại bỏ, nhưng ở đây nó sẽ luôn là 1, vì chúng ta luôn đọc một số duy nhất làm đầu vào. Chúng ta có thể tận dụng điều này bằng cách gán giá trị trả về của nó cho biến 1, lưu 2 byte nếu không được yêu cầu để gán 1cho 1 rõ ràng.

(%d@)

\$*,c'$,io>  ( setup - assign $ to "%d", * to a number, o to stdout )
Av"[""mN*    ( set " to input and allocate space for N for int conversion )
c?*          ( calloc ?, starting it at zero - this will be the output )
m1*          ( allocate variable "1", which gets the value 1 eventually )
mp*m%*       ( p is the prime, % will be used to store N mod p )

s1"$pN       ( scan " into N with $ as format; also assigns 1 to 1 )

1p:~         ( begin loop, starting p at 1 )
  +p1p       ( increment p )
  %%Np       ( set % to N mod p )
?%~          ( repeat if the result is nonzero, so that we reach the factor )

:=           ( another loop to repeatedly divide N by p )
  /NNp       ( divide N by p in-place )
  +?1?       ( increment the counter )
  -%N1       ( reuse % as a temp variable to store N-1 )
?%=          ( repeat while N-1 is not 0 -- i.e. break when N = 1 )

p%'$i?       ( sprintf ? into ', reusing the input format string )
w1'%>        ( write to stdout )








2

Khoảng trắng, 141 byte

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  N
_Push_1][N
S S N
_Create_Label_LOOP_1][S S S T   N
_Push_1][T  S S S _Add][S N
S _Duplicate][S T   S S T   S N
_Copy_2nd_input][S N
T   _Swap_top_two][T    S T T   _Modulo][N
T   S S N
_If_0_Jump_to_Label_BREAK_1][N
S N
N
_Jump_to_Label_LOOP_1][N
S S S N
_Create_Label_BREAK_1][S S S N
_Push_0][S T    S S T   S N
_Copy_2nd_input][N
S S T   N
_Create_Label_LOOP_2][S N
S _Duplicate_input][S S S T N
_Push_1][T  S S T   _Subtract][N
T   S S S N
_If_0_Jump_to_Label_BREAK_2][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S S _Add][S N
T   _Swap_top_two][S T  S S T   S N
Copy_2nd_factor][T  S T S _Integer_divide][N
S N
T   N
_Jump_to_Label_LOOP_2][N
S S S S N
_Create_Label_BREAK_2][S N
N
_Discard_top][T N
S T _Print_as_number]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Dùng thử trực tuyến (chỉ với không gian thô, tab và dòng mới).

Giải thích bằng mã giả:

Integer n = STDIN as input
Integer f = 1
Start LOOP_1:
  f = f + 1
  if(n modulo-f == 0)
    Call function BREAK_1
  Go to next iteration of LOOP_1

function BREAK_1:
  Integer r = 0
  Start LOOP_2:
    if(n == 1)
      Call function BREAK_2
    r = r + 1
    n = n integer-divided by f
    Go to next iteration of LOOP_2

function BREAK_2:
  Print r as number to STDOUT
  Program stops with an error: Exit not defined

Chạy ví dụ: input = 9

Command    Explanation                    Stack           Heap    STDIN   STDOUT   STDERR

SSSN       Push 0                         [0]
SNS        Duplicate top (0)              [0,0]
TNTT       Read STDIN as number           [0]             {0:9}   9
TTT        Retrieve                       [9]             {0:9}
SSSTN      Push 1                         [9,1]           {0:9}
NSSN       Create Label_LOOP_1            [9,1]           {0:9}
 SSSTN     Push 1                         [9,1,1]         {0:9}
 TSSS      Add top two (1+1)              [9,2]           {0:9}
 SNS       Duplicate top (2)              [9,2,2]         {0:9}
 STSSTSN   Copy 2nd from top              [9,2,2,9]       {0:9}
 SNT       Swap top two                   [9,2,9,2]       {0:9}
 TSTT      Modulo top two (9%2)           [9,2,1]         {0:9}
 NTSSN     If 0: Jump to Label_BREAK_1    [9,2]           {0:9}
 NSNN      Jump to Label_LOOP_1           [9,2]           {0:9}

 SSSTN     Push 1                         [9,2,1]         {0:9}
 TSSS      Add top two (2+1)              [9,3]           {0:9}
 SNS       Duplicate top (3)              [9,3,3]         {0:9}
 STSSTSN   Copy 2nd                       [9,3,3,9]       {0:9}
 SNT       Swap top two                   [9,3,9,3]       {0:9}
 TSTT      Modulo top two (9%3)           [9,3,0]         {0:9}
 NTSSN     If 0: Jump to Label_BREAK_1    [9,3]           {0:9}
NSSSN      Create Label_BREAK_1           [9,3]           {0:9}
SSSN       Push 0                         [9,3,0]         {0:9}
STSSTSN    Copy 2nd from top              [9,3,0,9]       {0:9}
NSSTN      Create Label_LOOP_2            [9,3,0,9]       {0:9}
 SNS       Duplicate top (9)              [9,3,0,9,9]     {0:9}
 SSSTN     Push 1                         [9,3,0,9,9,1]   {0:9}
 TSST      Subtract top two (9-1)         [9,3,0,9,8]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,0,9]       {0:9}
 SNT       Swap top two                   [9,3,9,0]       {0:9}
 SSSTN     Push 1                         [9,3,9,0,1]     {0:9}
 TSSS      Add top two (0+1)              [9,3,9,1]       {0:9}
 SNT       Swap top two                   [9,3,1,9]       {0:9}
 STSSTSN   Copy 2nd from top              [9,3,1,9,3]     {0:9}
 TSTS      Integer-divide top two (9/3)   [9,3,1,3]       {0:9}
 NSNTN     Jump to Label_LOOP_2           [9,3,1,3]       {0:9}

 SNS       Duplicate top (3)              [9,3,1,3,3]     {0:9}
 SSSTN     Push 1                         [9,3,1,3,3,1]   {0:9}
 TSST      Subtract top two (3-1)         [9,3,1,3,2]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,1,3]       {0:9}
 SNT       Swap top two                   [9,3,3,1]       {0:9}
 SSSTN     Push 1                         [9,3,3,1,1]     {0:9}
 TSSS      Add top two (1+1)              [9,3,3,2]       {0:9}
 SNT       Swap top two                   [9,3,2,3]       {0:9}
 STSSTSN   Copy 2nd from top              [9,3,2,3,3]     {0:9}
 TSTS      Integer-divide top two (3/3)   [9,3,2,1]       {0:9}
 NSNTN     Jump to Label_LOOP_2           [9,3,2,1]       {0:9}

 SNS       Duplicate top (1)              [9,3,2,1,1]     {0:9}
 SSSTN     Push 1                         [9,3,2,1,1,1]   {0:9}
 TSST      Subtract top two (1-1)         [9,3,2,1,0]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,2,1]       {0:9}
NSSSSN     Create Label_BREAK_2           [9,3,2,1]       {0:9}
 SNN       Discard top                    [9,3,2]         {0:9}
 TNST      Print as integer               [9,3]           {0:9}           2
                                                                                    error

Chương trình dừng với một lỗi: Không tìm thấy lối ra.








1

Cjam, 5 byte

rimf,

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

Giải trình:

ri      take the input and convert it to an int
  mf    factors the input
    ,   take the length of the list

Nội tích thật tuyệt!


Đệ trình phải là chương trình hoặc chức năng theo mặc định và chúng tôi không coi đây là chức năng . Cả rimf,(chương trình đầy đủ) và {mf,}(chức năng) sẽ hợp lệ.
Dennis

@Dennis Vâng, tôi nghĩ rằng tôi hơi bối rối về điều đó. Tôi cũng đã xem iard stardard cho phép trước đây và tự hỏi về những gì tôi thực sự nên gửi ... Tôi thực sự muốn hỏi một câu hỏi về meta về điều đó. Nhưng bạn đã xác nhận điều đó, cảm ơn rất nhiều!
Chromium

1

QBasic, 51 byte

INPUT x
p=2
WHILE x/p>x\p
p=p+1
WEND
?LOG(x)/LOG(p)

Sử dụng thuật toán tương tự như giải pháp "Phục hồi nguyên tố" để tìm cơ sở, sau đó sử dụng quy tắc logarit để lấy số mũ:tôiog(pn)= =ntôiog(p).




0

Perl 6 , 36 byte

{round .log/log (2..*).first: $_%%*}

Tìm kiếm yếu tố đầu tiên (2..*).first: $_%%*, sau đó từ đó tính toán giá trị gần đúng (các bản ghi sẽ không nhận được chính xác) và làm tròn nó.

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





Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.