수학에서이 질문에 영감을 얻었습니다 .

문제

n자연수로 하자 ≥ 2. 자신과 n다른 최대 제수를 n빼고에서 빼십시오 n. 얻을 때까지 반복하십시오 1.

질문

1주어진 숫자 에 도달하는 데 몇 걸음 걸립니까 n ≥ 2?

자세한 예

하자 n = 30.

가장 큰 제수 :

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

도달하려면 6 단계 가 필요 합니다1 .

입력

• 입력은 정수 n, 여기서 n ≥ 2.
• 프로그램은 언어의 최대 정수 값까지의 입력을 지원해야합니다.

산출

• 과 같은 단계 수를 간단히 출력하십시오 6.
• 공백 또는 줄 바꿈 선행 / 트레일이 좋습니다.

예

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

요구 사항

• STDIN, 명령 줄 인수, 함수 매개 변수 또는 가장 가까운 해당 항목에서 입력을 얻을 수 있습니다 .
• 프로그램이나 함수를 작성할 수 있습니다. 익명 함수 인 경우 호출 방법의 예를 포함하십시오.
• 이것은 코드 골프 이므로 바이트 단위의 최단 답변이 승리합니다.
• 표준 허점은 허용되지 않습니다.

이 시리즈는 OEIS에서도 볼 수 있습니다 : A064097

a(1) = 0및 a(p) = 1 + a(p-1)if p가 소수이고 a(n*m) = a(n) + a(m)if로 유도 적으로 정의 된 유사 로그 m,n > 1입니다.

젤리 , 9 바이트

ÆṪÐĿÆFL€S

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

배경

시퀀스의 정의 A064097는 것을 의미한다

으로 오일러의 제품 공식

여기서 φ는 오일러의 참을성있는 함수를 나타내고 p 는 소수에 대해서만 변합니다.

둘을 결합하여 우리는 재산을 추론합니다.

여기서 ω 는 n 의 고유 한 소수 요소의 수를 나타냅니다 .

인가 얻어진 화학식 K + 1 번, K가 충분히 크도록 φ ^{K + 1} (N) = 1 , 우리는 얻을

이 속성에서 우리는 공식을 얻습니다.

ω (1) = 0 이기 때문에 마지막 동등성이 유지 됩니다.

작동 원리

ÆṪÐĿÆ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 바이트

암호:

[DÒ¦P-¼D#]¾

설명:

[        ]   # 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 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

Pyth, 11 바이트

fq1=-Q/QhPQ

테스트 스위트

간단하게 반복 될 때까지 반복되는 루프.

설명:

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.

파이썬 2, 50 49 바이트

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

이것은 곧 마지막 테스트 케이스를 끝내지 않을 것입니다 ...

또한, 여기에 반환하는 48 바이트의 True대신 1에이 n=2:

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

젤리 , 10 바이트

ÆfḊPạµÐĿi2

온라인으로 사용해보십시오! 또는 대부분의 테스트 사례를 확인하십시오 . 마지막 테스트 사례는 로컬에서 빠르게 완료됩니다.

작동 원리

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

망막 , 12

• @ MartinBüttner 덕분에 14 바이트 절약

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

이것은 단항으로 주어진 입력 과 10 진수로 주어진 출력을 가정합니다 . 이것이 허용되지 않으면 6 바이트 이상이 가능합니다.

망막 , 18

• @ MartinBüttner 덕분에 8 바이트 절약

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

온라인으로 사용해보십시오-첫 번째 줄이 추가되어 모든 테스트 케이스를 한 번에 실행할 수 있습니다.

슬프게도 이것은 계산에 단항을 사용하므로 2016 ^155의 입력은 실용적이지 않습니다.

• 첫 번째 단계 (2 줄)는 단순히 십진수 입력을 1s 의 문자열로 단항으로 변환합니다.
• 두 번째 단계 (1 행)는 정규식 일치 그룹을 사용하여 n의 최대 계수를 계산하고 n을 찾아서 효과적으로 뺍니다. 이 정규식은 가능한 한 숫자를 줄이는 데 필요한 횟수만큼 일치합니다. 정규식 일치 횟수는 단계 수이며이 단계에서 출력됩니다.

Pyth- 15 14 13 바이트

특별한 케이싱 1은 정말로 나를 죽이고 있습니다.

tl.u-N/Nh+PN2

여기에서 온라인으로 사용해보십시오 .

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

@ l4m2 덕분에 저장된 6 바이트 편집

(* 4 타격은 여전히 ​​4입니다)

재귀 함수

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

덜 골프

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
}

테스트

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>

수학, 36 바이트

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

명명되지 않은 함수는 동일한 바이트를 사용합니다.

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

이것은 재귀 함수로서 정의를 매우 간단하게 구현 한 것입니다.

옥타브, 59 58 55 바이트

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

Stewie Griffin으로 업데이트되어 1 바이트 절약

추가 업데이트, while-check의 인수 분해 결과를 사용하여 3 바이트를 더 절약합니다.

샘플 실행 :

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

하스켈, 59 바이트

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

용법:

Prelude> f 30
Prelude> 6

목록을 생성하기 때문에 큰 숫자에는 약간 비효율적 일 수 있습니다.

줄리아, 56 50 45 39 바이트

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

정수를 받아들이고 정수를 반환하는 재귀 함수입니다.

언 골프 드 :

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

온라인으로 사용해보십시오! (모든 테스트 케이스 포함)

Martin Büttner 덕분에 6 바이트를 절약하고 Dennis 덕분에 11 바이트를 절약했습니다!

PowerShell v2 +, 81 바이트

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

무차별 대입

입력을 $a받고 보다 작거나 같을 for때까지 루프 $a를 시작 1합니다. 각 루프는 제수 ( )를 찾을 때까지 for카운트 다운되는 다른 루프를 거 $a칩니다 !($a%$i. 최악의 경우, $i=1제수로 찾을 수 있습니다. 우리가 할 때, counter를 증가시키고 $j, 약수를 빼고 내부 루프에서 벗어나도록 $a-=$i설정 $i=0하십시오. 결국 외부 루프가 거짓 (즉, $a도달 1) 상태에 도달 하므로 출력 $j하고 종료합니다.

주의 : 더 큰 숫자, 특히 소수에 대해서는 시간 이 오래 걸립니다. Core i5 랩톱에서 100,000,000을 입력하는 데 ~ 35 초가 걸립니다. 편집 -방금 [int]::MaxValue(2 ^ 32-1)으로 테스트 했으며 ~ 27 분이 걸렸습니다. 아니 너무 나쁜, 나는 가정한다.

Matlab, 58 바이트

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

Japt , 12 바이트 (비경쟁)

@!(UµUk Å×}a

온라인으로 테스트하십시오! 챌린지가 게시 된 후 추가 된 다양한 기능을 사용하기 때문에 비 경쟁적입니다.

작동 원리

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

이 기술은 05AB1E 답변 에서 영감을 받았습니다 . 이전 버전은 ²¤(2를 푸시하고 처음 두 항목을 슬라이스) 대신 Å1 바이트 더 짧기 때문에 s1 (후행 공백 참고); 나는 이것이 배열 의 끝에 2 와 처음부터 슬라이스를 추가하기 때문에 주어진 모든 테스트 사례에서 작동하지만 실제로 홀수의 복합 번호에서 실패 한다는 것을 깨달았습니다 .

파이썬 3, 75, 70 , 67 바이트.

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]

이것은 매우 간단한 재귀 솔루션입니다. 많은 수의 테스트 사례에는 매우 오랜 시간이 걸립니다.

> <>, 32 바이트

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

n스택 에서 입력 번호을 예상합니다 .

이 프로그램은 스택에서 전체 시퀀스를 작성합니다. 발생할 수있는 유일한 수가 1IS 2때, 순서를 구축 정지 2진행한다. 또한 스택 크기가 단계 수 +1이 아니라 단계 수와 동일하게합니다.

루비, 43 바이트

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

가장 작은 수 찾기 i등 그 x분할을 x-i우리가 도달 할 때까지 재귀 1.

하스켈, 67 바이트

코드는 다음과 같습니다.

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

그리고 Haskell이 최고인 이유는 다음과 같습니다.

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
  ]

예, Haskell에서는와 -->동일하도록 정의 할 수 있습니다 ==.

Matlab, 107 바이트

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

• 경쟁이 아닌, 이것은 마지막 제출의 반복적 인 번역이 아니며, 또 다른 직접 대 수법입니다. 모든 주요 요인의 모든 이진 로그를 요약하여 모호합니다.
• 시간이 있으면 더 골프를칩니다.

MATL, 17 16 바이트

`tttYfl)/-tq]vnq

온라인으로 사용해보십시오

설명

        % 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 바이트

@Alchymist가 1 바이트 골프를 쳤다.

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

f (x, & y)로 호출하십시오. 여기서 x는 입력이고 y는 출력입니다.

줄리아, 39 36 바이트

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

온라인으로 사용해보십시오!

Clojure에서, 116 104 바이트

(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 바이트는 범위를 필터링하여 배수를 찾은 다음 last하나를 사용 하여 가장 큰 것을 얻습니다.

기본적으로 OP에 설명 된대로 문제를 해결하는 순진한 솔루션입니다. 불행히도, 가장 큰 제수를 찾는 것은 사용 된 바이트의 절반을 차지합니다. 적어도 여기에서 골프를 할 공간이 많이 있어야합니다.

사전 골프 및 테스트 :

(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

펄 6 , 35 바이트

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

온라인으로 사용해보십시오!

작동 원리

{                                 }   # 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 바이트

L?tbhy-b*F+1tPb0

온라인으로 사용해보십시오! ( y.v끝 부분은 함수 호출을위한 것입니다)

원래 17 바이트 :

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

온라인으로 사용해보십시오! ( y.v끝 부분은 함수 호출을위한 것입니다)

(실제로이 Pyth 프로그램으로 그 질문에 대답했습니다.)

파이크, 11 바이트 (비경쟁)

D3Phf-oRr;o

goto 이후에 예외가 발생하면 goto 이전의 상태를 복원하고 (변수 정의 제외) 계속하는 새로운 동작을 사용합니다. 이 경우 다음 파이썬 코드와 같습니다.

# 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

이것은 while 루프 구조없이 파이크를 사용하여 가능합니다-yay goto!

여기 사용해보십시오!

자바 스크립트 (ES6), 70 54 바이트

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

제공된 재귀 공식을 구현했지만 이제 재귀를 사용하여 제수도 찾도록 업데이트되었습니다.

Perl, 57 + 1 ( -p플래그) = 58 바이트

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

용법:

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

언 골프 드 :

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 $\
}

클로저, 98 96 바이트

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

for :when가장 큰 제수를 찾는 데 사용 하고, 1보다 큰 값을 찾을 수 없을 때까지 반복합니다.