Stellen Sie die Leistung von der Hauptleistung wieder her

16

Es scheint, dass viele Leute dies gerne hätten, also ist es jetzt eine Fortsetzung dieser Herausforderung !

Definition : Eine Primzahl ist eine natürliche Zahl, die in der Form p n ausgedrückt werden kann, wobei p eine Primzahl und n eine natürliche Zahl ist.

Aufgabe : Gib bei einer Primzahl p n > 1 die Potenz n zurück.

Testfälle :

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

Wertung : Dies ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

code-golf  number  arithmetic  primes 
— Undichte Nonne
quelle
2
Hinweis : Diese Herausforderung ist in einigen Golfsprachen möglicherweise trivial, für einige gängige Sprachen jedoch nicht so trivial, ebenso wie für die Sprache von Juni 2018, QBasic.
— Erik der Outgolfer
Können wir True anstelle von 1 ausgeben? Alternativ schweben statt ints?
— Jo King
1
@JoKing ja, ja.
— Undichte Nonne
@EriktheOutgolfer Herausforderung angenommen : D
— DLosc

Antworten:

3

Gleichstrom , 50 41 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe vom oberen Rand des Stapels (in TIO setzen Sie die Eingabe in den Header, um sie vor der Ausführung auf den Stapel zu laden). Ausgänge auf Standardausgabe.

Erläuterung

Verwendete Register:

i: der aktuelle Testteiler, während Xläuft. Später haben wir den Divisor gefunden.

X: das Makro dli1+dsi%0<X, das den Effekt "Inkrementieren" hat i, dann den Modul mit dem Wert auf dem Stapel überprüfen (der die ursprüngliche Eingabe sein wird). Wenn er nicht Null ist, wiederholen Sie ".

Y: Das Makro dli/dli<Ymit dem Effekt "Dem Stapel eine Kopie der aktuellen Stapelspitze hinzufügen, geteilt durch i. Wiederholen, bis ierreicht ist."

Volles Programm:

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
— Sophia Lechner
quelle
Ich habe eine viel bessere Lösung gefunden! Lektorat jetzt ...
— Sophia Lechner
3

Gesicht , 86 Bytes

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

Hurra, länger als Java!

Probieren Sie es online!

Besonders mag ich den Trick, den Rückgabewert von zu verwenden sscanf. Normalerweise wird der Rückgabewert verworfen, aber hier ist er immer 1, weil wir immer eine einzelne Zahl als Eingabe lesen. Dies können wir ausnutzen, indem wir der Variablen ihren Rückgabewert 1zuweisen und die 2 Bytes speichern, die andernfalls für die 1explizite Zuweisung zu 1 erforderlich wären .

(%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 )
— Türknauf
quelle
2

Leerzeichen, 141 Bytes

[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]

Buchstaben S(Leerzeichen), T(Tabulator) und N(Zeilenumbruch) werden nur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Erklärung im Pseudocode:

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

Beispiellauf: 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

Programm stoppt mit Fehler: Kein Exit gefunden.

— Kevin Cruijssen
quelle
1

Cjam, 5 Bytes

rimf,

Probieren Sie es online!

Erläuterung:

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

Builtins sind großartig!

— Chrom
quelle
Einsendungen müssen standardmäßig Programme oder Funktionen sein, und wir betrachten dies nicht als eine Funktion . Sowohl rimf,(volles Programm) als auch {mf,}(Funktion) wären gültig.
— Dennis
@ Tennis Ja, ich denke, ich bin irgendwie verwirrt. Ich habe mir auch erlaubt stardard io angesehen und mich gefragt, was ich eigentlich einreichen soll ... eigentlich wollte ich eine Frage zu Meta dazu stellen. Aber du hast das bestätigt, also danke!
— Chromium
1

QBasic, 51 Bytes

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

lÖG(pn)=n⋅lÖG(p)

— DLosc
quelle
0

Perl 6 , 36 Bytes

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

Sucht nach dem ersten Faktor (2..*).first: $_%%*, berechnet dann von dort den ungefähren Wert (Protokolle erhalten ihn nicht genau) und rundet ihn.

Probieren Sie es online!

— Phil H
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.