Der Hauptfrosch 🐸

44

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).

Arnaud
quelle
3
3 Schleife ist [3 5 9 6 3] und 19 Schleife ist [19 37 73 145 116 87 58 29 57 38 19]
Arnaud
8
Coole Collatz-Variante.
Arthur
3
Wenn wir nicht beweisen können, dass der Frosch immer zu 3oder kommt 19, können wir Punkt 2 im Algorithmus ändern, um zu sagen, dass, wenn der Frosch in eine Schleife eingetreten ist (auf eine Position gestoßen ist, die er zuvor gesehen hat), er das Springen beendet und die kleinste zurückgibt Mitglied dieser Schleife.
Jeppe Stig Nielsen
4
@ PyRulez Wenn es das erreicht, sollten Sie wahrscheinlich das OP mitteilen.
mbomb007
3
@KeyuGan Vielleicht ist das eine gute Sache, über die man auf Math.SE schreiben kann.
mbomb007

Antworten:

16

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!

TFeld
quelle
1
while~16&n!=3Speichert ein Byte.
Lynn
6
Oh, ~16&n-3sogar funktioniert!
Lynn
12

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!

Steadybox
quelle
5
Lieben Sie total das Spiel mit dem Wort Frosch und Ihren Variablen. +1.
rayryeng - Wiedereinsetzung von Monica
10

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.

Martin Ender
quelle
1
Ist das nicht 1$'dasselbe wie $_?
Neil
4
@ Neil Ja ......
Martin Ender
8

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.
Zgarb
quelle
8

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.
Dennis
quelle
7

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:

Benchmark

Keyu Gan
quelle
3
Spaß Tatsache: Dieser Code würde für eine größere Anzahl nicht funktionieren wie 10000000010damaximum number of iterations is 2^16 (= 65536)
J42161217
1
Ein etwas kürzerer Weg, um nach 3 und 19 #//.i:Except[3|19]:>If[PrimeQ@i,2i-1,i-#&@@Last@FactorInteger@i]&
Misha Lavrov
@MishaLavrov aber das Ergebnis ist falsch?
Keyu Gan
@KeyuGan Für mich ergeben die beiden Funktionen für die Ganzzahlen 1 bis 1000 genau das gleiche Ergebnis.
Misha Lavrov
1
Möglicherweise liegt das Problem darin, dass beim Kopieren und Einfügen aus den Kommentaren nicht druckbare Zeichen eingefügt werden, was manchmal vorkommt.
Mischa Lawrow
6

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
Emigna
quelle
4
+1 für im Quellcode einen tatsächlichen Frosch mit
Arnaud
Für 57991 mehr als 1 Minute
RosLuP
@ RosLup: Du bist besser dran, sehr lange Testfälle offline laufen zu lassen;)
Emigna
5

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

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)
Arnauld
quelle
1
Smart, mit 57%nund n%38statt n==3|n==19. 1 Byte in meiner Java-Antwort auch gespeichert , also danke!
Kevin Cruijssen
In Ideone 57991-Eingabe generieren prog.js: 2: 26 InternalError: zu viel Rekursion
RosLuP
In tio 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 print (f (57991)) Erzeugt Stopp-Programm wird nicht ausgegeben, scheint mir
RosLuP 20.10.17
1
@RosLuP Dies ist eine Code-Golf-Herausforderung ohne besondere Einschränkungen. Der derzeitige Konsens ist, dass Geschwindigkeits- oder Speicherbeschränkungen (wie z. B. die Größe des Aufrufstapels) ignoriert werden können, sofern in der Frage nicht ausdrücklich etwas anderes angegeben ist. Ich nehme an, dass die 1000000-Grenze nur informativ ist, da die Sequenz darüber hinaus nicht getestet wurde. Im Übrigen ist Ihre 70-Byte-Lösung vollkommen in Ordnung und für eine Code-Golf-Herausforderung wahrscheinlich relevanter als die 93-Byte-Version.
Arnauld
4

Jelly , 23 19 Bytes

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

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

Probieren Sie es online!

user202729
quelle
1
Ḥ’$_Æf$ÆP?Ṫµḟ3,19$¿Verwenden Sie stattdessen eine while-Schleife und einige Nachbestellungen
Meilen
4

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!

ovs
quelle
1
…n*(n&~16==3)or…Spart 2 Bytes.
Lynn
Für Eingabe 57991 sys.setrecursionlimit (20000)
RosLuP,
4

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)
Luis Mendo
quelle
4

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.

Eiserner Gremlin
quelle
Hallo und willkommen auf der Seite. Sie benötigen keine Zeilenumbrüche und Leerzeichen für Pattern Guards. Sie können auch verwendet werden 1>0für die Truemeiste Zeit aber oft ist es vielleicht besser sein , um eine Zuordnung zu verwenden, zum Beispiel c<-z n.
Weizen-Zauberer
1
[x|x<-[b-1,b-2..1],rem b x==0]ist auch kurz als reverse[x|x<-[1..(b-1)],brem x==0].
Weizen-Zauberer
2
Und eine letzte Sache, wenn Sie das Haskell-Golfen diskutieren möchten, können Sie sich uns in Of Monads and Men anschließen .
Weizen-Zauberer
3

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!

Okx
quelle
3

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!

Giuseppe
quelle
3

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
Kevin Cruijssen
quelle
1
1 Charakter fehlt ein C # -Polyglot :(
Ian H.
@IanH. Hehe, ja, das ist normalerweise der Fall: n=>statt n->. Und manchmal Klein- / Großbuchstaben. ;)
Kevin Cruijssen
1
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;}
Nevay
@Nevay Danke! Ich wusste nur, dass es möglich sein sollte, die Schleifen zu kombinieren, konnte es aber nicht herausfinden. Satte 40 Bytes gespart dank dir!
Kevin Cruijssen
3

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
Justin Mariner
quelle
2

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!

Dennis
quelle
Für 57991 Eingabe war 1 Minute nicht ausreichend
RosLuP
1

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.
Mr. Xcoder
quelle
1

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.

AdmBorkBork
quelle
1

APL (Dyalog Unicode) , 113 90 59 Bytes

CY 'dfns'
g←{1pco ⍵:f(2×⍵)-1f⍵-⊃⌽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×⍵)-1f⍵-⊃⌽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 ⍵
J. Sallé
quelle
1

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.

RosLuP
quelle
0

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!

Felipe Nardi Batista
quelle