Inspiriert von dieser Frage bei Mathematics .

Das Problem

Sei neine natürliche Zahl ≥ 2. Nehmen Sie den größten Teiler von n- der sich von nselbst unterscheidet - und subtrahieren Sie ihn von n. Wiederholen, bis Sie bekommen 1.

Die Frage

Wie viele Schritte tut , es zu erreichen nehmen 1für eine bestimmte Anzahl n ≥ 2.

Ausführliches Beispiel

Lassen n = 30.

Der größte Teiler von:

1.   30 is 15  -->  30 - 15 = 15
2.   15 is  5  -->  15 -  5 = 10
3.   10 is  5  -->  10 -  5 =  5
4.    5 is  1  -->   5 -  1 =  4
5.    4 is  2  -->   4 -  2 =  2
6.    2 is  1  -->   2 -  1 =  1

Es dauert 6 Schritte zu erreichen 1.

Eingang

• Eingabe ist eine ganze Zahl n, wobei n ≥ 2.
• Ihr Programm sollte die Eingabe bis zum maximalen Ganzzahlwert der Sprache unterstützen.

Ausgabe

• Geben Sie einfach die Anzahl der Schritte wie 6.
• Führende / nachfolgende Leerzeichen oder Zeilenumbrüche sind in Ordnung.

Beispiele

f(5)        --> 3
f(30)       --> 6
f(31)       --> 7
f(32)       --> 5
f(100)      --> 8
f(200)      --> 9
f(2016^155) --> 2015

Bedarf

• Sie können Eingaben von STDINBefehlszeilenargumenten als Funktionsparameter oder von der nächstgelegenen Entsprechung erhalten.
• Sie können ein Programm oder eine Funktion schreiben. Wenn es sich um eine anonyme Funktion handelt, geben Sie bitte ein Beispiel für den Aufruf an.
• Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.
• Standardlücken sind nicht zulässig.

Diese Serie gibt es auch bei OEIS: A064097

Ein durch a(1) = 0und a(p) = 1 + a(p-1)if induktiv definierter Quasi-Logarithmus pist prim und a(n*m) = a(n) + a(m)if m,n > 1.

Gelee , 9 Bytes

ÆṪÐĿÆFL€S

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

Hintergrund

Die Definition der Sequenz A064097 impliziert dies

Nach der Produktformel von Euler

wobei φ die Euler'sche Totientenfunktion bezeichnet und p nur über Primzahlen variiert.

Wir kombinieren beides und leiten daraus das Grundstück ab

wobei ω die Anzahl der verschiedenen Primfaktoren von n bezeichnet .

Wendet man die resultierende Formel k + 1 mal an, wobei k groß genug ist, dass φ ^{k + 1} (n) = 1 ist , so erhält man

Aus dieser Eigenschaft erhalten wir die Formel

wo die letzte Gleichheit gilt, weil ω (1) = 0 .

Wie es funktioniert

ÆṪÐĿÆFL€S  Main link. Argument: n

  ÐĿ       Repeatedly apply the link to the left until the results are no longer
           unique, and return the list of unique results.
ÆṪ           Apply Euler's totient function.
           Since φ(1) = 1, This computes φ-towers until 1 is reached.
    ÆF     Break each resulting integer into [prime, exponent] pairs.
      L€   Compute the length of each list.
           This counts the number of distinct prime factors.
        S  Add the results.

05AB1E , 13 11 Bytes

Code:

[DÒ¦P-¼D#]¾

Erläuterung:

[        ]   # An infinite loop and...
       D#        break out of the loop when the value is equal to 1.
 D           # Duplicate top of the stack (or in the beginning: duplicate input).
  Ò          # Get the prime factors, in the form [2, 3, 5]
   ¦         # Remove the first prime factor (the smallest one), in order to get 
               the largest product.
    P        # Take the product, [3, 5] -> 15, [] -> 1.
     -       # Substract from the current value.
      ¼      # Add one to the counting variable.
          ¾  # Push the counting variable and implicitly print that value.

Verwendet CP-1252- Codierung. Probieren Sie es online! .

Pyth, 11 Bytes

fq1=-Q/QhPQ

Testsuite

Eine einfache Wiederholungsschleife.

Erläuterung:

fq1=-Q/QhPQ
               Implicit: Q = eval(input())
f              Apply the following function until it is truthy,
               incrementing T each time starting at 1:
         PQ    Take the prime factorization of Q
        h      Take its first element, the smallest factor of Q
      /Q       Divide Q by that, giving Q's largest factor
    -Q         Subtract the result from Q
   =           Assign Q to that value
 q1            Check if Q is now 1.

Python 2, 50 49 Bytes

f=lambda n,k=1:2/n or n%(n-k)and f(n,k+1)or-~f(k)

Dies wird den letzten Testfall nicht in Kürze beenden ...

Alternativ ist hier ein 48-Byte, das Trueanstelle von 1for zurückgibt n=2:

f=lambda n,k=1:n<3or n%(n-k)and f(n,k+1)or-~f(k)

Gelee , 10 Bytes

ÆfḊPạµÐĿi2

Probieren Sie es online! oder überprüfen Sie die meisten Testfälle . Die letzten Testfälle enden schnell vor Ort.

Wie es funktioniert

ÆfḊPạµÐĿi2  Main link. Argument: n (integer)

Æf          Factorize n, yielding a list of primes, [] for 1, or [0] for 0.
  Ḋ         Dequeue; remove the first (smallest) element.
   P        Take the product.
            This yields the largest proper divisor if n > 1, 1 if n < 2.
    ạ       Yield the abs. value of the difference of the divisor (or 1) and n.
     µ      Convert the chain to the left into a link.
      ÐĿ    Repeatedly execute the link until the results are no longer unique.
            Collect all intermediate results in a list.
            For each starting value of n, the last results are 2 -> 1 -> 0 (-> 1).
        i2  Compute the 1-based index of 2.

Retina , 12

• 14 Bytes gespart dank @ MartinBüttner

(1 +) (? = \ 1 + $)

Dies setzt voraus, dass die Eingabe unär und die Ausgabe dezimal erfolgt. Wenn dies nicht akzeptabel ist, können wir dies für weitere 6 Bytes tun:

Retina , 18

• 8 Bytes gespart dank @ MartinBüttner

. +
$ *
(1 +) (? = \ 1 + $)

Online testen - Erste Zeile hinzugefügt, um alle Testfälle auf einmal auszuführen.

Leider wird für die Berechnungen eine Einzahl verwendet, sodass die Eingabe von 2016 ¹⁵⁵ nicht praktikabel ist.

• Die erste Stufe (2 Zeilen) konvertiert einfach die Dezimaleingabe in eine unäre Zeichenfolge von 1s
• Die zweite Stufe (1 Zeile) berechnet den größten Faktor von n unter Verwendung von Regex-Übereinstimmungsgruppen und sieht danach aus und subtrahiert ihn effektiv von n. Dieser reguläre Ausdruck passt so oft wie nötig, um die Anzahl so weit wie möglich zu verringern. Die Anzahl der Regex-Übereinstimmungen entspricht der Anzahl der Schritte und wird von dieser Stufe ausgegeben.

Pyth - 15 14 13 Bytes

Ein spezielles Gehäuse 1bringt mich um.

tl.u-N/Nh+PN2

Probieren Sie es hier online aus .

tl                One minus the length of
 .u               Cumulative fixed point operator implicitly on input
  -N              N -
   /N             N /
    h             Smallest prime factor
     +PN2         Prime factorization of lambda var, with two added to work with 1

JavaScript (ES6), * 44 38

Bearbeiten Sie 6 Bytes gespeichert dank @ l4m2

(* 4 gestrichen ist noch 4)

Rekursive Funktion

f=(n,d=n)=>n>1?n%--d?f(n,d):f(n-d)+1:0

Weniger golfen

f=(n, d=n-1)=>{
  if (n>1)
    if(n % d != 0)
      return f(n, d-1) // same number, try a smaller divisor
    else
      return f(n-d)+1  // reduce number, increment step, repeat
  else
    return 0
}

Prüfung

f=(n,d=n)=>n>1?n%--d?f(n,d):f(n-d)+1:0

console.log=x=>O.textContent+=x+'\n';

[5,30,31,32,100,200].forEach(x=>console.log(x+' -> '+f(x)))

<pre id=O></pre>

Mathematica, 36 Bytes

f@1=0;f@n_:=f[n-Divisors[n][[-2]]]+1

Eine unbenannte Funktion benötigt dieselben Bytes:

If[#<2,0,#0[#-Divisors[#][[-2]]]+1]&

Dies ist eine sehr einfache Implementierung der Definition als rekursive Funktion.

Oktave, 59 58 55 Bytes

function r=f(x)r=0;while(x-=x/factor(x)(1));r++;end;end

Dank Stewie Griffin aktualisiert und 1 Byte gespart

Weitere Aktualisierung, um drei weitere Bytes zu sparen, indem das Ergebnis der Faktorisierung bei der Überprüfung verwendet wird.

Probeläufe:

octave:41> f(5)
ans =  3
octave:42> f(30)
ans =  6
octave:43> f(31)
ans =  7
octave:44> f(32)
ans =  5
octave:45> f(100)
ans =  8
octave:46> f(200)
ans =  9

Haskell, 59 Bytes

f 1=0;f n=1+(f$n-(last$filter(\x->n`mod`x==0)[1..n`div`2]))

Verwendungszweck:

Prelude> f 30
Prelude> 6

Bei großen Zahlen kann dies ein wenig ineffizient sein, da die Liste erstellt wird.

Julia, 56 50 45 39 Bytes

f(n)=n>1&&f(n-n÷first(factor(n))[1])+1

Dies ist eine rekursive Funktion, die eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt.

Ungolfed:

function f(n)
    if n < 2
        # No decrementing necessary
        return 0
    else
        # As Dennis showed in his Jelly answer, we don't need to
        # divide by the smallest prime factor; any prime factor
        # will do. Since `factor` returns a `Dict` which isn't
        # sorted, `first` doesn't always get the smallest, and
        # that's okay.
        return f(n - n ÷ first(factor(n))[1]) + 1
    end
end

Probieren Sie es online! (beinhaltet alle Testfälle)

6 Bytes gespart dank Martin Büttner und 11 dank Dennis!

PowerShell v2 +, 81 Byte

param($a)for(;$a-gt1){for($i=$a-1;$i-gt0;$i--){if(!($a%$i)){$j++;$a-=$i;$i=0}}}$j

Brutalste Gewalt.

Übernimmt die Eingabe $a, tritt in eine forSchleife ein, bis $akleiner oder gleich ist 1. In jeder Schleife durchlaufen wir eine andere forSchleife, von der abwärts gezählt wird, $abis wir einen Divisor ( !($a%$i) finden. Im schlimmsten Fall werden wir $i=1als Teiler finden. Wenn wir dies tun, erhöhen Sie unseren Zähler $j, subtrahieren unseren Divisor $a-=$iund $i=0brechen aus der inneren Schleife aus. Irgendwann werden wir einen Zustand erreichen, in dem die äußere Schleife falsch ist (dh erreicht $ahat 1), also ausgeben $jund beenden.

Achtung : Dies wird eine dauern lange Zeit auf eine größere Anzahl, insbesondere Primzahlen. Die Eingabe von 100.000.000 dauert auf meinem Core i5-Laptop ~ 35 Sekunden. Bearbeiten - gerade mit [int]::MaxValue(2 ^ 32-1) getestet , und es dauerte ~ 27 Minuten. Nicht zu schlecht, nehme ich an .

Matlab, 58 Bytes

function p=l(a),p=0;if(a-1),p=1+l(a-a/min(factor(a)));end

Japt , 12 Bytes (nicht konkurrierend)

@!(UµUk Å×}a

Online testen! Nicht konkurrierend, da es eine Reihe von Funktionen verwendet, die nach dem Posten der Herausforderung hinzugefügt wurden.

Wie es funktioniert

@   !(Uµ Uk Å  ×   }a
XYZ{!(U-=Uk s1 r*1 }a
                       // Implicit: U = input integer
XYZ{               }a  // Return the smallest non-negative integer X which returns
                       // a truthy value when run through this function:
         Uk            //   Take the prime factorization of U.
            s1         //   Slice off the first item.
                       //   Now we have all but the smallest prime factor of U.
               r*1     //   Reduce the result by multiplication, starting at 1.
                       //   This takes the product of the array, which is the
                       //   largest divisor of U.
      U-=              //   Subtract the result from U.
    !(                 //   Return !U (which is basically U == 0).
                       //   Since we started at 0, U == 1 after 1 less iteration than
                       //   the desired result. U == 0 works because the smallest
                       //   divisor of 1 is 1, so the next term after 1 is 0.
                       // Implicit: output result of last expression

Diese Technik wurde von der 05AB1E-Antwort inspiriert . Eine frühere Version verwendet ²¤(Push a 2, Slice off der ersten beiden Elemente) anstelle von, Åweil es ein Byte kürzer ist als s1 (Note Trailing Space); Ich erkannte erst nach der Tatsache, dass, da dies eine 2 an das Ende des Arrays und die Slices von Anfang an anfügt , es in der Tat auf einer ungeraden zusammengesetzten Zahl fehlschlägt, obwohl es auf allen gegebenen Testfällen funktioniert.

Python 3, 75, 70 , 67 Bytes.

g=lambda x,y=0:y*(x<2)or[g(x-z,y+1)for z in range(1,x)if x%z<1][-1]

Dies ist eine ziemlich einfache rekursive Lösung. Bei den vielen Testfällen dauert es SEHR lange.

> <> 32 Bytes

<\?=2:-$@:$/:
1-$:@@:@%?!\
;/ln

Erwartet die eingegebene Nummer nauf dem Stapel.

Dieses Programm erstellt die vollständige Sequenz auf dem Stapel. Die einzige Zahl, zu der es führen kann, 1ist 2, dass die Erstellung der Sequenz beendet wird, wenn sie 2erreicht ist. Dies bewirkt auch, dass die Größe des Stapels der Anzahl der Schritte entspricht und nicht der Anzahl der Schritte +1.

Ruby, 43 Bytes

f=->x{x<2?0:1+f[(1..x).find{|i|x%(x-i)<1}]}

Finden Sie die kleinste Zahl i, die sich xteilt, x-iund wiederholen Sie den Vorgang, bis wir sie erreichen 1.

Haskell, 67 Bytes

Hier ist der Code:

a&b|b<2=0|a==b=1+2&(b-1)|mod b a<1=1+2&(b-div b a)|1<2=(a+1)&b
(2&)

Und hier ist ein Grund, warum Haskell großartig ist:

f = (2&)

(-->) :: Eq a => a -> a -> Bool
(-->) = (==)

h=[f(5)        --> 3
  ,f(30)       --> 6
  ,f(31)       --> 7
  ,f(32)       --> 5
  ,f(100)      --> 8
  ,f(200)      --> 9
  ,f(2016^155) --> 2015
  ]

Ja, in Haskell können Sie festlegen -->, dass es äquivalent zu ist ==.

Matlab, 107 Bytes

a=input('');b=factor(a-isprime(a));c=log2(a);while(max(b)>1),b=max(factor(max(b)-1));c=c+1;end,disp(fix(c))

• Nicht konkurrierend, dies ist nicht die iterative Übersetzung meines letzten Beitrags, sondern nur eine weitere direkte algerbraische Methode. Sie fasst alle Binärlogs aller Primfaktoren zusammen und ist irgendwie mehrdeutig zu veranschaulichen.
• Ich werde mehr Golf spielen, wenn ich Zeit habe.

MATL, 17 16 Bytes

`tttYfl)/-tq]vnq

Probieren Sie es online

Erläuterung

        % Implicitly grab input
`       % Do while loop
    ttt % Make three copies of top stack element
    Yf  % Compute all prime factors
    l)  % Grab the smallest one
    /   % Divide by this to get the biggest divisor
    -   % Subtract the biggest divisor
    t   % Duplicate the result
    q   % Subtract one (causes loop to terminate when the value is 1). This
        % is functionally equivalent to doing 1> (since the input will always be positive) 
        % with fewer bytes
]       % End do...while loop
v       % Vertically concatenate stack contents (consumes entire stack)
n       % Determine length of the result
q       % Subtract 1 from the length
        % Implicitly display result

C99, 62 61 Bytes

1 Byte von @Alchymist abgegolft.

f(a,c,b)long*c,a,b;{for(*c=0,b=a;a^1;a%--b||(++*c,b=a-=b));}  

Rufen Sie als f (x, & y) auf, wobei x die Eingabe und y die Ausgabe ist.

Julia, 39 36 Bytes

\(n,k=2)=n%k>0?n>1&&n\-~k:\(n-n/k)+1

Probieren Sie es online!

Clojure, 116 104 Bytes

(fn[n](loop[m n t 1](let[s(- m(last(filter #(=(rem m %)0)(range 1 m))))](if(< s 2)t(recur s (inc t))))))

-12 Bytes, indem ein Bereich gefiltert wird, um ein Vielfaches zu finden, und dann lasteins verwendet wird, um das größte zu erhalten

Naive Lösung, die das vom OP beschriebene Problem im Grunde nur löst. Leider nimmt das Finden des größten Divisors allein etwa die Hälfte der verwendeten Bytes in Anspruch. Zumindest sollte ich von hier aus viel Platz zum Golfen haben.

Vorgolfed und Test:

(defn great-divider [n]
  ; Filter a range to find multiples, then take the last one to get the largest
  (last
     (filter #(= (rem n %) 0)
             (range 1 n))))

(defn sub-great-divide [n]
  (loop [m n
         step 1]
    (let [g-d (great-divider m) ; Find greatest divisor of m
          diff (- m g-d)] ; Find the difference
      (println m " is " g-d " --> " m " - " g-d " = " diff)
      (if (< diff 2)
        step
        (recur diff (inc step))))))

(sub-great-divide 30)

30  is  15  -->  30  -  15  =  15
15  is  5  -->  15  -  5  =  10
10  is  5  -->  10  -  5  =  5
5  is  1  -->  5  -  1  =  4
4  is  2  -->  4  -  2  =  2
2  is  1  -->  2  -  1  =  1
6

Perl 6 , 35 Bytes

{+({$_ -first $_%%*,[R,] ^$_}...1)}

Probieren Sie es online!

Wie es funktioniert

{                                 }   # A bare block lambda.
                    [R,] ^$_          # Construct range from arg minus 1, down to 0.
        first $_%%*,                  # Get first element that is a divisor of the arg.
    $_ -                              # Subtract it from the arg.
   {                        }...1     # Do this iteratively, until 1 is reached.
 +(                              )    # Return the number of values generated this way.

Pyth, 17 16 Bytes

L?tbhy-b*F+1tPb0

Probieren Sie es online! (Das y.vam Ende ist für den Funktionsaufruf)

Ursprüngliche 17 Bytes:

L?tb+1y-b*F+1tPb0

Probieren Sie es online! (Das y.vam Ende ist für den Funktionsaufruf)

(Diese Frage habe ich tatsächlich mit diesem Pyth-Programm beantwortet.)

Pyke, 11 Bytes (nicht konkurrierend)

D3Phf-oRr;o

Dies verwendet ein neues Verhalten, bei dem, wenn nach einem Sprung eine Ausnahme ausgelöst wird, der Zustand vor dem Sprung wiederhergestellt wird (mit Ausnahme von Variablendefinitionen) und fortgesetzt wird. In diesem Fall entspricht es dem folgenden Python-Code:

# Implicit input and variable setup
inp = input()
o = 0
# End implicit
try:
    while 1:
        inp -= factors(inp)[0] # If factors is called on the value 1, it returns an empty
                               # list which when the first element tries to be accessed
                               # raises an exception
        o += 1 # Using `o` returns the current value of `o` and increments it
except:
    print o # This in effect gets the number of times the loop went

Dies ist alles mit Pyke ohne eine while-Schleife möglich - na los!

Probieren Sie es hier aus!

JavaScript (ES6), 70 54 Bytes

f=(n,i=2)=>n<i?0:n%i?f(n,i+1):n>i?f(i)+f(n/i):1+f(n-1)

Implementierung der bereitgestellten rekursiven Formel, die jetzt aktualisiert wurde, um mithilfe der Rekursion auch den Divisor zu finden.

Perl, 57 + 1 ( -pFlag) = 58 Bytes

$n=$_;$n-=$n/(grep!($n%$_),2..$n/2,$n)[0],$\++while$n>1}{

Verwendungszweck:

> echo 31 | perl -pe '$n=$_;$n-=$n/(grep!($n%$_),2..$n/2,$n)[0],$\++while$n>1}{'

Ungolfed:

while (<>) {
# code above added by -p
    # $_ has input value
    # $\ has undef (or 0)
    my $n = $_;
    while ($n > 1) {
        my $d = 1;
        for (2 .. ($n / 2)) {
            if ($n % $_ == 0) {
                $d = $n / $_;
                last;
            }
        }
        $n -= $d;
        $\++;
    }
} {
# code below added by -p
    print;  # prints $_ (undef here) and $\
}

Clojure, 98 96 Bytes

#(loop[n % i -1](if n(recur(first(for[j(range(dec n)0 -1):when(=(mod n j)0)](- n j)))(inc i))i))

Verwendet for :when, um den größten Divisor zu finden, Schleifen, bis kein größerer Wert als eins gefunden wird.