Matematikte bu sorudan ilham aldı .

Sorun

Let ndoğal sayı ≥ 2. Kendinden nfarklı olan en büyük bölenini al nve onu çıkar n. Elinize geçene kadar tekrarlayın 1.

Soru

1Belirli bir sayıya ulaşmak için kaç adım gerekiyor n ≥ 2?

Detaylı Örnek

Let n = 30.

En büyük bölen:

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

Ulaşmak için 6 adım sürer 1.

Giriş

• Girdi bir tamsayıdır n, burada n ≥ 2.
• Programınız, dilin maksimum tamsayı değerine kadar olan girişi desteklemelidir.

Çıktı

• Gibi basitçe adımların sayısını çıktı 6.
• Lider / takip eden boşluklar veya yeni satırlar iyi durumda.

Örnekler

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

Gereksinimler

• STDINKomut satırı argümanlarından, işlev parametreleri olarak veya en yakın eşdeğerden girdi alabilirsiniz .
• Bir program veya işlev yazabilirsiniz. Adsız bir işlevse, lütfen onu nasıl çağıracağınıza dair bir örnek ekleyin.
• Bu kod golf , bayt cinsinden kazanılan cevapların çok kısa olması.
• Standart boşluklara izin verilmez.

Bu seri OEIS'de de bulunabilir: A064097

Tarafından endüktif tanımlanan bir yarı-logaritma a(1) = 0ve a(p) = 1 + a(p-1)eğer pasal ve olduğunu a(n*m) = a(n) + a(m)eğer m,n > 1.

Jöle , 9 bayt

ÆṪÐĿÆFL€S

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Arka fon

A064097 dizisinin tanımı şu anlama gelir:

By Euler ürün formülü

nerede φ totient belirtir ve p sadece asal sayılar üzerinde değişir.

Her ikisini birleştirerek mülkü çıkardık

burada ω belirgin asal faktör sayısını gösterir , n .

Elde edilen formül k + 1 kez uygulanırsa, k yeterince büyük olur, böylece φ ^{k + 1} (n) = 1 olur ,

Bu özellikten formülü elde ettik.

son eşitlik olduğu için ω (1) = 0'dır .

Nasıl çalışır

ÆṪÐĿÆ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 bayt

Kod:

[DÒ¦P-¼D#]¾

Açıklama:

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

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .

Pyth, 11 bayt

fq1=-Q/QhPQ

Test odası

Basit bir tekrarlama-gerçek döngüsüne kadar.

Açıklama:

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 bayt

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

Bu son test davasını yakın zamanda bitirmeyecek ...

Alternatif olarak, burada döndüren bir 48 bayt var Trueyerine 1için n=2:

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

Jöle , 10 bayt

ÆfḊPạµÐĿi2

Çevrimiçi deneyin! veya çoğu test vakasını doğrulayın . Son test durumları yerel olarak hızla bitiyor.

Nasıl çalışır

Æ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

• @ MartinBüttner sayesinde 14 bayt kurtarıldı

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

Bu , birleşik olarak verilen girişi ve ondalık biçimde verilen çıkışı varsayar . Eğer bu kabul edilebilir değilse 6 bayt daha fazlasını yapabiliriz:

Retina , 18

• @ MartinBüttner sayesinde 8 bayt kurtarıldı

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

Çevrimiçi deneyin - tüm test kodlarını tek seferde çalıştırmak için 1. satır eklendi.

Ne yazık ki bu hesaplamalar için unary kullanır, bu nedenle 2016 ^155'in girişi pratik değildir.

• İlk aşama (2 satır), ondalık girişi basit bir 1s dizesi olarak unary'e dönüştürür.
• İkinci aşama (1 satır), regex eşleştirme gruplarını kullanarak n'nin en büyük faktörünü hesaplar ve bunları n'den ayırır ve etkili bir şekilde çıkarır. Bu regex, sayıyı olabildiğince azaltmak için gereken sayıda eşleşecek. Düzenli eşleşmelerin sayısı, adımların sayısı olacaktır ve bu aşamada verilir.

Pyth - 15 14 13 bayt

Özel kasa 1beni gerçekten öldürüyor.

tl.u-N/Nh+PN2

Burada çevrimiçi deneyin .

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

6 bayt düzenle, teşekkürler @ l4m2

(* 4 grev hala 4)

Özyinelemeli fonksiyonu

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

Daha az golf oynadı

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
}

Ölçek

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 bayt

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

Adsız bir işlev aynı byte'ı alır:

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

Bu, özyinelemeli bir işlev olarak tanımlamanın çok basit bir uygulamasıdır.

Octave, 59 58 55 bayt

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

Stewie Griffin sayesinde güncellendi, 1 bayt kurtarıldı

Daha fazla güncelleme, kontrol sırasındaki çarpanlara ayırma sonucunu kullanarak üç bayt daha tasarruf edin

Örnek çalışır:

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 bayt

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

Kullanımı:

Prelude> f 30
Prelude> 6

Liste oluşturmaktan dolayı büyük sayılar için biraz verimsiz olabilir.

Julia, 56 50 45 39 bayt

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

Bu bir tamsayıyı kabul eden ve bir tamsayı döndüren özyinelemeli bir işlevdir.

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

Çevrimiçi deneyin! (tüm test durumlarını içerir)

Martin Büttner sayesinde 6 bayt, Dennis sayesinde 11 bayt kaydedildi!

PowerShell v2 +, 81 bayt

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

Kaba kuvvet brutest.

Girdi alır $a, eşit veya daha küçük forolana kadar bir döngüye girer . Her döngü , bir divisor ( ) buluncaya kadar geri sayım yapan başka bir döngüden geçer . En kötüsü, bir bölen olarak buluruz . Yaptığımızda sayacımızı arttır, bölenimizi çıkar ve iç döngüden kopmaya başla. Sonunda, dış döngünün yanlış olduğu (yani, ulaştığı ) bir duruma ulaşacağız , bu yüzden çıktı ve çıkın.$a1for$a!($a%$i$i=1$j$a-=$i$i=0$a1$j

Dikkat : Bu özellikle asal sayılar daha büyük sayılar için uzun zaman alacaktır . 100.000.000 giriş, Core i5 dizüstü bilgisayarımda ~ 35 saniye sürüyor. Düzenleme - sadece [int]::MaxValue(2 ^ 32-1) ile test edildi ve ~ 27 dakika sürdü. Değil çok kötü, herhalde.

Matlab, 58 bayt

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

Japt , 12 bayt (rekabet etmeyen)

@!(UµUk Å×}a

Çevrimiçi test edin! Rekabetçi değil çünkü meydan okuma yapıldıktan sonra eklenen birçok özellik kullanıyor.

Nasıl çalışır

@   !(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

Bu teknik 05AB1E cevabından ilham almıştır . Kullanılan önceki bir sürüm ²¤(2'ye bastır, ilk iki öğeyi kes), Åçünkü bunun yerine bir bayt daha kısa s1 (not boşluğu); Sadece bu bir 2 ekler çünkü gerçeği sonra gerçekleşen ucundan gelen dizi ve dilim başında tüm verilen test durumlarda çalışır olsa da, aslında, herhangi bir tek kompozit sayıda başarısız olur.

Python 3, 75, 70 , 67 bayt.

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]

Bu oldukça yalındır bir özyinelemeli çözümdür. Yüksek sayıdaki test durumları için ÇOK uzun zaman alır.

> <>, 32 bayt

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

Giriş numarasını, nyığında bekler .

Bu program yığındaki dizinin tamamını oluşturur. Yol tek sayı olarak 1isimli 2zaman sekansı inşa durur 2ulaşılır. Bu aynı zamanda yığının boyutunun +1 adımlarının sayısı yerine adım sayısına eşit olmasına neden olur.

Ruby, 43 bayt

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

En küçük sayı bulun iöyle ki xböler x-ive ulaşana kadar Recurse 1.

Haskell, 67 bayt

İşte kod:

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

İşte Haskell'in harika olmasının bir nedeni:

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
  ]

Evet, Haskell'de -->buna eşdeğer olarak tanımlayabilirsiniz ==.

Matlab, 107 bayt

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

• Rekabet etmeyen, bu benim son gönderimin yinelemeli çevirisi değil, bir başka doğrudan cebirsel yöntem, tüm asal faktörlerin tüm ikili kayıtlarını özetliyor, açıklamak için belirsiz.
• Vaktim olduğunda bunu daha çok golf oynayacağım.

MATL, 17 16 bayt

`tttYfl)/-tq]vnq

Çevrimiçi Deneyin

açıklama

        % 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 bayt

1 bayt @Alchymist tarafından kapalı golf.

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

F (x, & y) olarak adlandırın, burada x giriş, y ise çıkışdır.

Julia, 39 36 bayt

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

Çevrimiçi deneyin!

Clojure, 116 104 bayt

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

Katları bulmak için bir aralığı filtreleyerek -12 bayt, ardından lasten iyisini elde etmek için birini kullanarak

Temel olarak problemi sadece OP tarafından tanımlandığı gibi çözen saf çözüm. Ne yazık ki, yalnızca en büyük böleni bulmak, kullanılan baytların yarısı kadar sürer. En azından buradan golf oynamak için çok yerim olmalı.

Pregolfed ve 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 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

{                                 }   # 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 bayt

L?tbhy-b*F+1tPb0

Çevrimiçi deneyin! ( y.vSonunda işlev çağrısı içindir)

Orijinal 17 bayt:

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

Çevrimiçi deneyin! ( y.vSonunda işlev çağrısı içindir)

(Bu soruyu aslında bu Pyth programı ile cevapladım.)

Pyke, 11 bayt (rekabetçi olmayan)

D3Phf-oRr;o

Bu, bir gotodan sonra ortaya çıkan bir istisna varsa, durumu gotodan önceki durumuna (değişken tanımları hariç) geri yükleyen ve devam eden yeni bir davranış kullanır. Bu durumda, aşağıdaki python koduna eşdeğerdir:

# 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

Bunların hepsi Pyke'i bir süre döngü yapmadan kullanmak mümkün - yay goto!

Burada dene!

JavaScript (ES6), 70 54 bayt

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

Sağlanan özyinelemeli formülü uygulanması, ancak şimdi bölen de bulmak için özyinelemeyi kullanmak için güncellendi.

Perl, 57 + 1 ( -pbayrak) = 58 bayt

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

Kullanımı:

> 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 bayt

#(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))

kullanan for :when, en böleni bulmak için, birden büyük böyle bir değer bulunana kadar döngüler.