Lấy cảm hứng từ câu hỏi này tại Toán học .

Vấn đề

Hãy nlà một số tự nhiên ≥ 2. Lấy ước số lớn nhất của n- khác với nchính nó - và trừ nó đi n. Lặp lại cho đến khi bạn nhận được 1.

Câu hỏi

Cần bao nhiêu bước để đạt được 1một con số nhất định n ≥ 2.

Ví dụ chi tiết

Hãy để n = 30.

Ước số lớn nhất của:

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

Phải mất 6 bước để đạt được 1.

Đầu vào

• Đầu vào là một số nguyên n, trong đó n ≥ 2.
• Chương trình của bạn nên hỗ trợ đầu vào tối đa giá trị số nguyên tối đa của ngôn ngữ.

Đầu ra

• Đơn giản chỉ cần xuất số lượng các bước, như 6.
• Hàng đầu / dấu trắng hàng đầu hoặc dòng mới là tốt.

Ví dụ

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

Yêu cầu

• Bạn có thể nhận đầu vào từ STDIN, đối số dòng lệnh, dưới dạng tham số hàm hoặc từ tương đương gần nhất.
• Bạn có thể viết một chương trình hoặc một chức năng. Nếu đó là một hàm ẩn danh, vui lòng bao gồm một ví dụ về cách gọi nó.
• Đây là mã golf để câu trả lời ngắn nhất trong byte thắng.
• Sơ hở tiêu chuẩn là không được phép.

Loạt bài này cũng có thể được tìm thấy trên OEIS: A064097

Một quar-logarit được xác định theo quy nạp bởi a(1) = 0và a(p) = 1 + a(p-1)nếu plà số nguyên tố và a(n*m) = a(n) + a(m)nếu m,n > 1.

Thạch , 9 byte

ÆṪÐĿÆFL€S

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Lý lịch

Định nghĩa của chuỗi A064097 ngụ ý rằng

Theo công thức sản phẩm của Euler

trong đó φ biểu thị hàm tổng của Euler và p chỉ thay đổi theo số nguyên tố.

Kết hợp cả hai, chúng tôi suy ra tài sản

Trong đó ω biểu thị số lượng các thừa số nguyên tố riêng biệt của n .

Áp dụng công thức kết quả là k + 1 lần, mà k đủ lớn để φ ^{k + 1} (n) = 1 , chúng tôi nhận

Từ tài sản này, chúng tôi có được công thức

trong đó đẳng thức cuối cùng giữ vì ω (1) = 0 .

Làm thế nào nó hoạt động

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

Mã số:

[DÒ¦P-¼D#]¾

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Bình thường, 11 byte

fq1=-Q/QhPQ

Bộ kiểm tra

Một vòng lặp lặp lại đơn giản cho đến khi đúng.

Giải trình:

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 byte

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

Điều này sẽ không hoàn thành trường hợp thử nghiệm cuối cùng bất cứ lúc nào sớm ...

Ngoài ra, đây là một 48-byte mà trả Truethay vì 1cho n=2:

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

Thạch , 10 byte

ÆfḊPạµÐĿi2

Hãy thử trực tuyến! hoặc xác minh hầu hết các trường hợp thử nghiệm . Các trường hợp thử nghiệm cuối cùng kết thúc nhanh chóng cục bộ.

Làm thế nào nó hoạt động

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

Võng mạc , 12

• 14 byte được lưu nhờ vào @ MartinBüttner

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

Điều này giả định đầu vào được đưa ra trong unary và đầu ra được đưa ra trong thập phân. Nếu điều này không được chấp nhận thì chúng ta có thể làm điều này thêm 6 byte nữa:

Võng mạc , 18

• 8 byte được lưu nhờ @ MartinBüttner

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

Dùng thử trực tuyến - Dòng đầu tiên được thêm vào để chạy tất cả các thử nghiệm trong một lần.

Đáng buồn là điều này sử dụng unary cho các tính toán, vì vậy đầu vào của năm 2016 ¹⁵⁵ là không thực tế.

• Giai đoạn đầu tiên (2 dòng) chỉ đơn giản là chuyển đổi đầu vào thập phân thành đơn vị dưới dạng một chuỗi 1s
• Giai đoạn thứ hai (1 dòng) tính toán hệ số lớn nhất của n bằng cách sử dụng các nhóm khớp regex và lookbehinds và trừ nó một cách hiệu quả từ n. Regex này sẽ khớp nhiều lần nếu cần thiết để giảm số lượng càng nhiều càng tốt. Số lượng các trận đấu regex sẽ là số bước và được xuất theo giai đoạn này.

Pyth - 15 14 13 byte

Vỏ bọc đặc biệt 1thực sự đang giết chết tôi.

tl.u-N/Nh+PN2

Hãy thử trực tuyến tại đây .

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

Chỉnh sửa 6 byte được lưu cảm ơn @ l4m2

(* 4 tấn công vẫn là 4)

Hàm đệ quy

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

Ít chơi gôn

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
}

Kiểm tra

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>

Toán học, 36 byte

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

Một hàm không tên có cùng byte:

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

Đây là một triển khai rất đơn giản của định nghĩa như là một hàm đệ quy.

Octave, 59 58 55 byte

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

Cập nhật nhờ Stewie Griffin, tiết kiệm 1 byte

Cập nhật thêm, tiết kiệm thêm ba byte bằng cách sử dụng kết quả của phép nhân trong khi kiểm tra.

Chạy mẫu:

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 byte

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

Sử dụng:

Prelude> f 30
Prelude> 6

Nó có thể là một chút không hiệu quả cho số lượng lớn vì tạo ra danh sách.

Julia, 56 50 45 39 byte

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

Đây là một hàm đệ quy chấp nhận một số nguyên và trả về một số nguyên.

Ung dung:

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

Hãy thử trực tuyến! (bao gồm tất cả các trường hợp thử nghiệm)

Đã lưu 6 byte nhờ Martin Büttner và 11 nhờ 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

Tàn bạo nhất của lực lượng vũ phu.

Đưa đầu vào $a, nhập một forvòng lặp cho đến khi $anhỏ hơn hoặc bằng 1. Mỗi vòng lặp chúng ta đi qua một forvòng lặp khác đếm ngược $acho đến khi chúng ta tìm thấy một ước số ( !($a%$i). Tệ nhất, chúng ta sẽ tìm thấy $i=1như một ước số. Khi chúng tôi làm, tăng bộ đếm của chúng tôi $j, trừ đi số chia của chúng tôi $a-=$ivà thiết lập $i=0để thoát ra khỏi vòng lặp bên trong. Cuối cùng, chúng ta sẽ đạt được một điều kiện trong đó vòng lặp bên ngoài là sai (nghĩa là $ađã đạt được 1), do đó, đầu ra $jvà thoát.

Thận trọng : Điều này sẽ mất nhiều thời gian với số lượng lớn hơn, đặc biệt là các số nguyên tố. Đầu vào 100.000.000 mất ~ 35 giây trên máy tính xách tay Core i5 của tôi. Chỉnh sửa - vừa được thử nghiệm với [int]::MaxValue(2 ^ 32-1) và mất ~ 27 phút. Không quá tệ, tôi cho rằng.

Matlab, 58 byte

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

Japt , 12 byte (không cạnh tranh)

@!(UµUk Å×}a

Kiểm tra nó trực tuyến! Không cạnh tranh vì nó sử dụng một loạt các tính năng được thêm vào sau khi thử thách được đăng.

Làm thế nào nó hoạt động

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

Kỹ thuật này được lấy cảm hứng từ câu trả lời 05AB1E . Một phiên bản trước được sử dụng ²¤(đẩy 2, cắt hai mục đầu tiên) thay Åvì bởi vì nó ngắn hơn một byte so với s1 (ghi chú dấu cách); Tôi chỉ nhận ra sau khi thực tế là bởi vì điều này nối thêm 2 vào cuối mảng và các lát cắt từ đầu , nên thực tế nó không thành công với bất kỳ số tổng hợp lẻ nào, mặc dù nó hoạt động trên tất cả các trường hợp thử nghiệm đã cho.

Python 3, 75, 70 , 67 byte.

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]

Đây là một giải pháp đệ quy khá thẳng về phía trước. Phải mất một thời gian RẤT lâu cho các trường hợp thử nghiệm số lượng cao.

> <>, 32 byte

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

Yêu cầu số đầu vào n, trên ngăn xếp.

Chương trình này xây dựng chuỗi hoàn chỉnh trên ngăn xếp. Khi số lượng duy nhất có thể dẫn đến 1là 2, xây dựng chuỗi dừng lại khi 2đạt được. Điều này cũng làm cho kích thước của ngăn xếp bằng số bước, thay vì số bước +1.

Ruby, 43 byte

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

Tìm số nhỏ nhất isao cho xchia x-ivà lặp lại cho đến khi chúng ta đạt được 1.

Haskell, 67 byte

Đây là mã:

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

Và đây là một lý do tại sao Haskell tuyệt vời:

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
  ]

Có, trong Haskell bạn có thể xác định -->tương đương với ==.

Matlab, 107 byte

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

• Không cạnh tranh, đây không phải là bản dịch lặp đi lặp lại của lần gửi cuối cùng của tôi, chỉ là một phương pháp algerbraic trực tiếp khác, nó tổng hợp tất cả các bản ghi nhị phân của tất cả các yếu tố chính, không rõ ràng để minh họa.
• Tôi sẽ chơi golf này nhiều hơn khi tôi có thời gian.

MATL, 17 16 byte

`tttYfl)/-tq]vnq

Dùng thử trực tuyến

Giải trình

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

1 byte được chơi bởi @Alchymist.

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

Gọi là f (x, & y), trong đó x là đầu vào và y là đầu ra.

Julia, 39 36 byte

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

Hãy thử trực tuyến!

Clojure, 116 104 byte

(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 byte bằng cách lọc một phạm vi để tìm bội số, sau đó sử dụng một phạm vi để có được phạm vi lastlớn nhất

Giải pháp ngây thơ về cơ bản chỉ giải quyết vấn đề như được mô tả bởi OP. Thật không may, việc tìm ra ước số lớn nhất một mình chiếm tới một nửa số byte được sử dụng. Ít nhất tôi nên có nhiều chỗ để chơi gôn từ đây.

Pregolfed và kiểm tra:

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

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Bình thường, 17 16 byte

L?tbhy-b*F+1tPb0

Hãy thử trực tuyến! ( y.vCuối cùng là để gọi chức năng)

17 byte gốc:

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

Hãy thử trực tuyến! ( y.vCuối cùng là để gọi chức năng)

(Tôi thực sự đã trả lời câu hỏi đó với chương trình Pyth này.)

Pyke, 11 byte (không biên dịch)

D3Phf-oRr;o

Điều này sử dụng một hành vi mới trong đó nếu có một ngoại lệ được đưa ra sau một goto, nó sẽ khôi phục trạng thái từ trước goto (ngoại trừ các định nghĩa biến) và tiếp tục. Trong trường hợp này, nó tương đương với mã python sau:

# 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

Đây là tất cả có thể sử dụng Pyke mà không cần xây dựng vòng lặp while - yay goto!

Hãy thử nó ở đây!

JavaScript (ES6), 70 54 byte

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

Thực hiện công thức đệ quy được cung cấp, nhưng bây giờ được cập nhật để sử dụng đệ quy để tìm ước số.

Perl, 57 + 1 ( -pcờ) = 58 byte

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

Sử dụng:

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

Ung dung:

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 byte

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

sử dụng for :whenđể tìm ước số lớn nhất, các vòng lặp cho đến khi không tìm thấy giá trị nào lớn hơn giá trị đó.