Der "Prime Frog" ist ein seltsames Tier, das zwischen ganzen Zahlen springt, bis es am 3. oder 19. ...

Ihr Programm sollte eine Ganzzahl nals Eingabe akzeptieren und das Ergebnis des folgenden Algorithmus ( 3oder 19) ausgeben .

Für eine bestimmte Ganzzahl n >= 2:

1. Sei fdie Position des Frosches. Es ist anfänglich auf eingestelltn
2. wenn f = 3oder f = 19: der Frosch springt nicht mehr - stoppen Sie das Programm und geben Sie es aus f.
3. wenn fist prime: der frosch springt zur position 2×f-1. Fahren Sie mit Schritt 2 fort.
4. if fist zusammengesetzt: sei dder fgrößte Primteiler. Der Frosch springt auf die Position f-d. Fahren Sie mit Schritt 2 fort.

Beispiele:

Ein Beispiel mit n = 5:

5 > 9 > 6 > 3 stop

Das Programm sollte ausgeben 3.

Ein weiteres Beispiel mit n = 23:

23 > 45 > 40 > 35 > 28 > 21 > 14 > 7 > 13 > 25 > 20 > 15 > 10 > 5 > 9 > 6 > 3 stop

Auch hier sollte das Programm ausgeben 3.

Testfälle:

10 => 3
74 => 19
94 => 3
417 => 3
991 => 19
9983 => 19

Sie können davon ausgehen 1 < n < 1000000(ich habe das Programmende auf diese Werte überprüft).

Python 2 , 101 93 92 90 88 87 85 Bytes

import sympy
n=input()
while~16&n-3:m=max(sympy.factorint(n));n-=[1-n,m][m<n]
print n

Probieren Sie es online!

C (gcc)  87  65 Bytes

i,k;f(n){for(i=n;i>1;)for(k=i;k%--i;);n=~16&n-3?f(n-k?:n+n-1):n;}

Probieren Sie es online!

Erläuterung:

i,k;
f(n)
{
    for (i=n; i>1;)              // Loop until `k` is prime (the largest positive
                                 // `i` inequal to `k` that divides `k` is 1).
        for (k=i; k%--i;);       // Find the largest factor `k`

    n =                          // Returning like this is undefined behaviour,
                                 // but happens to work with gcc. This can be
                                 // replaced with `return` at the cost of 4 bytes.

        ~16&n-3                  // If `n` is 3 or 19, this expression equals 0 and
                                 // the algorithm halts. Otherwise the function
                                 // calls itself to perform the next iteration.

        ? f(n-k ?: n+n-1)        // If `n-k` is non-zero, n is not prime.
                                 // In this case call `f` with the value of `n-k`.
                                 // (Omitting the second `n-k` between `?` and `:`
                                 // is a gcc extension)
                                 // Otherwise call `f` with `2*n-1`.

        : n;                     // All done, `n` is returned.
}

Portable Version (72 Bytes):

i,k;f(n){for(i=n;i>1;)for(k=i;k%--i;);return~16&n-3?f(n-k?n-k:n+n-1):n;}

Probieren Sie es online!

Mit passenderen Variablennamen:

f,r;o(g){for(f=g;f>1;)for(r=f;r%--f;);g=~16&g-3?o(g-r?:g+g-1):g;}

Probieren Sie es online!

Retina , 63 62 Bytes

Vielen Dank an Neil für das Speichern von 1 Byte.

{`^(11+)(?<!^\2+(11+))(?=\1+$)

^(?!(11+)\1+$|111$|1{19}$)1
$_

Probieren Sie es online!

Ein- und Ausgabe in Unary (die Testsuite verwendet aus Bequemlichkeitsgründen Dezimalzahlen). Diese Lösung wird für größere Eingaben unglaublich langsam. Der 9983Testfall läuft bei TIO ab.

Erläuterung

Aufgrund dessen {werden beide Programmphasen einfach in einer Schleife abgearbeitet, bis sie den String nicht mehr beeinflussen. Wir wechseln zwischen einem Stage Processing Composites und einem Stage Processing Primes. Auf diese Weise können wir eine tatsächliche Bedingung vermeiden (die in der Netzhaut nicht wirklich existiert). Wenn der aktuelle Wert für die Bühne falsch ist, tut die Bühne einfach nichts.

^(11+)(?<!^\2+(11+))(?=\1+$)

Dies verarbeitet Verbundstoffe. Wir stimmen einen potenziellen Divisor mit ab (11+), prüfen dann aber, ob er nicht mit zusammengesetzt ist (?<!^\2+(11+)), und berücksichtigen daher nur Primfaktoren. Aufgrund der Gier von +, priorisieren diese den größten Faktor. Dann überprüfen wir, ob dieser potentielle Teiler ein tatsächlicher Teiler ist, indem wir versuchen, den Rest der Zeichenkette mit Wiederholungen davon abzugleichen (?=\1+$). Dieser Teiler wird einfach aus der Zeichenkette entfernt, wodurch Sie etwas in unary subtrahieren.

^(?!(11+)\1+$|111$|1{19}$)1
$_

Dies verarbeitet Primzahlen mit Ausnahme von 3 und 19 . Der negative Lookahead stellt sicher, dass die Eingabe nicht zusammengesetzt ist, nicht 3 und nicht 19 . Dann passen wir eine einzelne an 1und ersetzen sie durch die gesamte Zeichenfolge. Dies ist eine unäre Form der Berechnung von n - 1 + n , die natürlich 2n-1 ist .

Sobald wir 3 oder 19 erreicht haben , kann keine der Stufen mit der Saite übereinstimmen und sie wird nicht mehr geändert.

Schale , 15 Bytes

Ω€p57§|o←DṠ-o→p

Probieren Sie es online!

Erläuterung

Ω€p57§|o←DṠ-o→p  Implicit input n.
Ω                Do this to n until
 €p57            you get a prime factor of 57 (which are 3 and 19):
            o→p   Take last element of the prime factors of n
          Ṡ-      and subtract it from n,
     §|           or if this gives 0 (so n is prime),
       o←D        double and decrement n.

Gelee , 12 Bytes

_ÆfṂoḤ’$µÐḶṂ

Probieren Sie es online!

Wie es funktioniert

_ÆfṂoḤ’$µÐḶṂ  Maink link. Argument: n

        µ     Combine the links to the left into a chain.
         ÐḶ   Repeatedly call the chain monadically until the results are no longer
              unique. Yield the loop, i.e., the first occurrence of the first
              repeated integer, up to and excluding the repetition.
              Let's call the argument of the chain k.
_Æf             Subtract all prime factors of k from k.
   Ṃ            Take the minimum of the differences. This yields 0 iff k is prime.
     Ḥ’$        Compute 2k-1.
    o           Take the logical OR of the results.
              The result is now a rotation of either [3, 5, 9, 6] or
              [19, 37, 73, 145, 116, 87, 58, 29, 57, 38].
          Ṃ   Take the minimum, yielding either 3 or 19.

Wolfram Language (Mathematica) , 6566 68 Bytes

#//.i:Except[3|19]:>If[PrimeQ@i,2i-1,i-#&@@Last@FactorInteger@i]&

• -1 Bytes, danke an Misha Lavrov!
• -2 Bytes, danke an Martin!

Probieren Sie es online!

Inspiriert von der Spitze . Grundsätzlich wird nur der Algorithmus neu erstellt.

//.ist RepeatedReplaceund /;ist Condition. Der Code wird also durch i_(eine einzelne Menge) ersetzt If[PrimeQ@i,2i-1,i-#&@@Last@FactorInteger@i], bis er i!=3&&!=19ausgewertet wird True.

Benchmark:

05AB1E , 19 18 17 Bytes

[ÐƵηfså#pi·<ëDfθ-

Probieren Sie es online!

Erläuterung

[      #            # loop until
 Ð   så             # a copy of the current value is contained in
  Ƶηf               # the unique prime factors of 171
        pi          # if the current value is prime
          ·<        # double and decrement
            ë   -   # else subtract
             Dfθ    # the largest prime factor of a copy of the current value

JavaScript (ES6), 73 71 69 Bytes

f=n=>57%n?f(n-(g=(k,d=1)=>++d<k?k%d?g(k,d):g(k/d):d<n?d:1-n)(n)):n%38

Testfälle

f=n=>57%n?f(n-(g=(k,d=1)=>++d<k?k%d?g(k,d):g(k/d):d<n?d:1-n)(n)):n%38

console.log('10   -> ' + f(10))   // 3
console.log('74   -> ' + f(74))   // 19
console.log('94   -> ' + f(94))   // 3
console.log('417  -> ' + f(417))  // 3
console.log('991  -> ' + f(991))  // 19
console.log('9983 -> ' + f(9983)) // 19

Formatiert und kommentiert

f = n =>                 // given n
  57 % n ?               // if n is neither 3, 19 or 57 (and assuming that n is > 1):
    f(                   //   do a recursive call to f() with:
      n -                //     n minus
      (g = (k, d = 1) => //     the result of the recursive function g():
        ++d < k ?        //       increment d; if d is less than k:
          k % d ?        //         if d is not a divisor of k:
            g(k, d)      //           recursive call to g() with k and d unchanged
          :              //         else:
            g(k / d)     //           recursive call to g() with k = k / d, d = 1
        :                //       else, d is now the highest prime divisor of n:
          d < n ?        //         if d is less than n:
            d            //           n is composite: return d, which results in f(n - d)
          :              //         else:
            1 - n        //           n is prime: return 1 - n, which results in f(2n - 1)
      )(n)               //     initial call to g()
    )                    //   end of recursive call to f()
  :                      // else:
    n % 38               //   return n % 38 (gives 19 as expected if n = 57)

Jelly , 23 19 Bytes

-4 Bytes von Meilen . Immer noch länger als 05AB1E.

Ḥ’$_Æf$ÆP?Ṫµḟ3,19$¿

Probieren Sie es online!

Python 2 , 110 105 103 101 Bytes

-2 Bytes dank @Lynn

f=lambda n,i=2,k=0:i/n and(n*(n&~16==3)or f((2*i-1,k-i)[k>0]))or n%i and f(n,i+1,k)or f(n/i,2,k or n)

Probieren Sie es online!

Python 2 , 116 112 105 Bytes

f=lambda n,i=2:i/n*i or n%i and f(n,i+1)or f(n/i)
n=input()
while~16&n-3:n=[2*n-1,n-f(n)][f(n)<n]
print n

Probieren Sie es online!

MATL , 22 21 Bytes

Vielen Dank an @ Giuseppe für das Entfernen von 1 Byte!

`tZp?Eq}tYfX>-]tI19h-

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

`           % Do...while
  t         %   Duplicate. Takes (implicit) input the first time
  Zp        %   Is it prime? 
  ?         %   If so
    Eq      %     Times 2, minus 1
  }         %   Else
    t       %     Duplicate
    YfX>-   %     Prime divisors, maximum, subtract
  ]         %   End
  t         %   Duplicate
  I19h      %   Push array [3 19]
  -         %   Subtract, element-wise. The result is truthy if and only if
            %   it doesn't contain any zero
            % End (implicit). Next iteraton if top of the stack is truthy
            % Display (implicit)

Haskell - 154 Bytes

f 3=3
f 19=19
f n
 |(c==[1])=f$2*n-1
 |True=f$n-head c
 where c=z n;v b=reverse[x|x<-[1..(b-1)],b`rem`x==0];z j=case v j of[1]->[1];s->filter((==[1]).v)$s

Vermutlich fehlen hier einige Golf-Tricks, dies ist mein erster Versuch, Haskell Golf zu spielen.

Neim , 17 16 Bytes

ͻY𝐏𝕚÷D𝐌Ξᚫ<#D𝐏𝐠𝕊

Erläuterung:

ͻ                   Start infinite loop
 D                  Duplicate
  Y                 Push 57
   𝐏                Prime factors: [3 19]
     𝕚              If the second-to-top of stack is in the list
      ÷             Break the loop
       D            Duplicate
        𝐌Ξᚫ<       If prime, double and decrement
            #D𝐏𝐠𝕊   Otherwise, subtract the largest prime factor

Probieren Sie es online!

R + Nummern , 102 bis 99 Bytes

function(n){while(!n%in%c(3,19))n="if"(isPrime(n),2*n-1,n-max(primeFactors(n)))
n}
library(numbers)

Probieren Sie es online!

R ist nicht für kurze Einbauten bekannt, und sogar die Pakete folgen diesem Beispiel!

Java 8, 140 135 134 94 Bytes

n->{for(int f,t,m=0;57%n>0;n=f>n?2*n-1:n-m)for(t=n,f=1;f++<t;)for(;t%f<1;t/=m=f);return n%38;}

-5 Bytes bei der Konvertierung der rekursiven Java 7-Methode in Java 8-Lambda mit Schleife.
-1 Byte implizit dank der JavaScript-Antwort von @Arnauld durch Ändern von n!=3&n!=19und return n;nach 57%n>0und return n%38;.
Ich denke, es sollte irgendwie möglich sein, die beiden Schleifen zu kombinieren und zu prüfen, ob nes sich um eine Primzahl handelt, und gleichzeitig den größten Primfaktor zu erhalten, aber ich kann es (noch) nicht herausfinden. Dies wird also die erste Version für den Moment sein.
-40 satte Bytes dank @Nevay, indem ich das tue, was ich nicht konnte: die Schleifen kombinieren, um sofort nach Primzahlen und dem größten Primfaktor zu suchen.

Erläuterung:

Probieren Sie es hier aus (wird sogar 999999in weniger als 1 Sekunde ausgeführt).

n->{                  // Method with integer as both parameter and return-type
  for(int f,          //  Flag-integer
          t,          //  Temp-integer
          m=1;        //  Max prime factor integer, starting at 0
      57%n>0;         //  Loop (1) as long as `n` is not 3, not 19 and not 57:
      n=f>n?          //    After every iteration: if `f` is larger than `n`:
         2*n-1        //     Change `n` to `2*n-1`
        :             //    Else:
         n-m)         //     Change `n` to `n-m`
    for(t=n,          //   Reset `t` to `n`
        f=1;          //   Reset `f` to 1
        f++<t;)       //   Inner loop (2) from 2 to `t` (inclusive)
      for(;t%f<1;     //    Inner loop (3) as long as `t` is divisible by `f`
        t/=m=f;       //     Set `m` to `f`, and set `t` to `t/f`
      );              //    End of inner loop (3)
                      //   End of inner loop (2) (implicit / single-line body)
                      //  End of loop (1) (implicit / single-line body)
  return n%38;        //  Return `n%38`, which is now either 3 or 19
}                     // End of method

Bash, 73 Bytes

((57%$1))&&$0 $[(x=$1-`factor $1|sed 's/.* //'`)?x:2*$1-1]||echo $[$1%38]

Probieren Sie es online! Leicht modifiziert, um mit TIO zu arbeiten.

Ruft rekursiv eine eigene Skriptdatei mit auf $0, die in TIO nicht funktioniert, da sie als ausgeführt werden muss./filename.sh . Akzeptiert Eingaben als Befehlszeilenargument.

Verwendet den gleichen Modulus-Trick wie die JS-Antwort von @ Arnauld .

Testfälle

$ for t in 5 23 10 74 94 417 991 9983;{ echo -n "$t -> "; ./prime-frog.sh $t; }
5 -> 3
23 -> 3
10 -> 3
74 -> 19
94 -> 3
417 -> 3
991 -> 19
9983 -> 19

Python 3 , 97 Bytes

f=lambda n:n*(n&-17==3)or f(n-max(k*all(n%k<k%j for j in range(2,k))for k in range(n+1))or 2*n-1)

Probieren Sie es online!

Pyth , 19 Bytes

.W!/P57H?P_ZtyZ-ZeP

Überprüfen Sie alle Testfälle!

Die Antwort von Husk hat mich dazu inspiriert, 2 Bytes ( ,3 19bis P57) zu sparen .

Wie das geht

.W! / P57H? P_ZtyZ-ZeP - Volles Programm.

.W - Funktioniert während. Während A (Wert) wahr ist, ist Wert = B (Wert). Liefert den letzten Wert.
    P57 - Die Primfaktoren von 57 ([3, 19]).
   / H - Zähle die Vorkommen des aktuellen Wertes.
  ! - Logisches NICHT. 0 -> Wahrheit, alles andere -> Falsch.
        P_Z - Wenn der aktuelle Wert prim ist, dann:
            tyZ - Verdoppeln Sie den aktuellen Wert und verringern Sie ihn.
               -ZeP - Andernfalls subtrahiere den maximalen Primfaktor des aktuellen Wertes von sich.
                     - Implizit drucken.

PowerShell , 150 bis 126 Byte

for($n="$args";57%$n){$a=$n;$d=for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}};if($n-in$d){$n+=$n-1}else{$n-=$d[-1]}}$n%38

Probieren Sie es online! (Warnung: langsam für größere Zahlen)

Iterative Methode. PowerShell verfügt über keine eingebauten Primfaktor-Funktionen. Daher ist dieser Code aus meiner Antwort auf Prime Factors Buddies entlehnt .

Erstens ist unsere forSchleife. Das Setup wird $nals Eingabewert festgelegt, und die Bedingung hält die Schleife so lange aufrecht, wie sie 57%$nnicht Null ist (danke an Arnauld für diesen Trick). Innerhalb der Schleife erhalten wir zunächst eine Liste der Primfaktoren von $a(set to $n). Dies ist der Code, der von Prime Factors Buddies entlehnt wurde. Wenn der Eingang $abereits prim ist, wird dies nur zurückgegeben $a(wichtig später). Das wird (möglicherweise nur $a) in gespeichert $d.

Weiter ist ein if/ elsebedingt. Zum ifTeil prüfen wir, ob das so $nist -in $d. Wenn es so ist, heißt das, dass $nes prim ist, also nehmen wir $n=2*$n-1oder $n+=$n-1. Ansonsten ist es zusammengesetzt, also müssen wir den größten Primfaktor finden. Das heißt, wir müssen den letzten [-1]von nehmen $dund diesen von $nmit subtrahieren $n-=. Dies funktioniert, weil wir eine Schleife ablaufen 2und somit das letzte Element von $dbereits das größte ist.

Sobald wir mit dem Looping fertig sind, platzieren wir $n%38(nochmals danke Arnauld) in der Pipeline und die Ausgabe ist implizit.

APL (Dyalog Unicode) , 113 90 59 Bytes

⎕CY 'dfns'
g←{1pco ⍵:f(2×⍵)-1⋄f⍵-⊃⌽3pco ⍵}
f←{⍵∊3 19:⍵⋄g ⍵}

Probieren Sie es online!

TIO arbeitet mit Werten bis zu ~ 3200. Auf meinem PC für den letzten Testfall getestet. Fügen Sie zum Testen von TIO einfach f valueam Ende des Codes hinzu. Gilt nicht mehr, danke an @ Adám, der darauf hingewiesen hat, dass mein Algorithmus für die Primalitätsprüfung wirklich schlecht war, und der mir Ersatz geliefert hat. auch für die 23 byte speichern.

Bearbeitet, um die Anzahl der Bytes zu korrigieren.

Wie es funktioniert

⎕CY 'dfns'                      # Imports every Defined Function, which is shorter than importing just the function I used (pco).

g←{1pco ⍵:f(2×⍵)-1⋄f⍵-⊃⌽3pco ⍵} 
g←                              # define g as
   1pco ⍵:                      # if the argument ⍵ is prime
          f(2×⍵)-1              # Call f over 2×⍵-1
                  ⋄f            # else, call f over
                    ⊃           # the first element of the
                      3pco ⍵    # list of prime factors of ⍵
                     ⌽          # reversed

f←{⍵∊3 19:⍵⋄g ⍵}
f←                              # Define f as
   ⍵     :                      # if the argument ⍵
    ∊                           # is in
     3 19                       # the list [3, 19]
          ⍵                     # return the argument ⍵
           ⋄                    # else
            g ⍵                 # call g over the argument ⍵

Axiom 93 Bytes

h(n)==(repeat(n=3 or n=19 or n<2=>break;prime? n=>(n:=2*n-1);n:=n-last(factors(n)).factor);n)

Prüfung:

(4) -> [[i,h(i)] for i in [10,74,94,417,991,9983]]
   (4)  [[10,3],[74,19],[94,3],[417,3],[991,19],[9983,19]]
                                                  Type: List List Integer

Es würde 68 Bytes Funktion geben

q x==(n<4=>3;n=19=>n;prime? n=>q(2*n-1);q(n-last(factors n).factor))

aber für n = 57991 (wenn ich mich recht erinnere) geht der reservierte Stapelplatz raus.

Python 2 , 93 Bytes

Port von TFelds Antwort ohne externe Bibliotheken.

n=input()
while~16&n-3:
 f=n;i=2
 while i<f:
	if f%i:i+=1
	else:f/=i
 n-=[1-n,f][f<n]
print n

Probieren Sie es online!