Liên quan: Hàm phi (n) .

Thử thách của bạn là tính toán hàm phi lặp:

f(n) = number of iterations of φ for n to reach 1.

Trong trường hợp φlà Phi hàm Euler .

Liên quan đến OEIS .

Đây là biểu đồ của nó:

Quy tắc:

Mục tiêu của bạn là đầu ra f(n) từ n=2đến n=100.

Đây là mã golf, vì vậy mã ngắn nhất sẽ thắng.

Đây là các giá trị bạn có thể kiểm tra đối với:

1, 2, 2, 3, 2, 3, 3, 3, 3, 4, 3, 4, 3, 4, 4, 5, 3, 4, 4, 4, 4, 5, 4, 5, 4, 4, 4, 5, 4, 5, 5, 5, 5, 5, 4, 5, 4, 5, 5, 6, 4, 5, 5, 5, 5, 6, 5, 5, 5, 6, 5, 6, 4, 6, 5, 5, 5, 6, 5, 6, 5, 5, 6, 6, 5, 6, 6, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 6, 5, 6, 7, 5, 7, 5, 6, 6, 7, 5, 6, 6, 6, 6, 6, 6, 7, 5, 6, 6

Haskell , 53 52 byte

Cảm ơn nimi vì đã tiết kiệm 1 byte!

f<$>[2..100]
f 1=0
f n=1+f(sum[1|1<-gcd n<$>[1..n]])

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

sum[1|1<-gcd n<$>[1..n]]cho φ(n)(Lấy từ flawr , cảm ơn!)

flà một hàm đệ quy tính toán 1+φ(n)nếu n không 1và đầu ra 0nếu nlà1 , vì không có nhiều lần lặp lại để đạt được1

Cuối cùng f<$>[2..100]tạo một danh sách fáp dụng cho từng yếu tố của[2..100]

Haskell , 70 69 68 byte

Hàm (\n->sum[1|1<-gcd n<$>[1..n]])này là hàm toàn phần, mà chúng ta liên tục áp dụng trong hàm ẩn danh. Cảm ơn @laikoni cho -1 byte!

EDIT: Tôi vừa phát hiện ra @xnor đã sử dụng hàm tổng số chính xác này trong một thử thách trước đó .

length.fst.span(>1).iterate(\n->sum[1|1<-gcd n<$>[1..n]])<$>[2..100]

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

MATL , 16 15 byte

99:Q"@`_Zptq}x@

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

Giải trình

99:       % Push [1 2 ... 99]
Q         % Add 1 element-wise: gives [2 3 ... 100]
"         % For each k in that array
  @       %   Push k
  `       %   Do...while
    _Zp   %     Euler's totient function
     tq   %     Duplicate, subtract 1. This is the loop condition
  }       %   Finally (execute on loop exit)
  x       %     Delete
  @       %     Push latest k
          %   End (implicit)
          % End (implicit)
          % Display stack (implicit)

Phiên bản cũ, 16 byte

99:Qt"t_Zp]v&X<q

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

Giải trình

99:       % Push [1 2 ... 99]
Q         % Add 1 element-wise: gives [1 2 ... 100]
t"        % Duplicate. For each (i.e. do the following 100 times)
  t       %   Duplicate
  _Zp     %   Euler's totient function, element-wise
]         % End
v         % Concatenate vertically. Gives a 100×100 matrix
&X<       % Row index of the first minimizing entry for each column.
          % The minimum is guaranteed to be 1, because the number of
          % iterations is more than sufficient.
q         % Subtract 1. Display stack (implicit)

Thạch , 12 11 10 9 byte

³ḊÆṪÐĿ>1S

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

-1 byte nhờ HyperNeutrino!

-1 byte nhờ ông Xcoder!

-1 byte nhờ Dennis

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

³ḊÆṪÐĿ>1S - Main link. No arguments
³         - Yield 100
 Ḋ        - Dequeue. Creates the list [2, 3 ... 99, 100]
    ÐĿ    - For each element, while the results of the next function
          - aren't unique, collect the results...
  ÆṪ      -   Next function: Totient
      >1  - Greater than one?
        S - Sum the columns

Vì điều này được tạo ra bởi Dennis, tôi (có thể hiểu được) không biết tại sao nó lại hoạt động, chỉ là nó làm được.

APL (Dyalog) , 50 29 25 byte

Nhìn này, không có tích hợp!

4 byte được lưu nhờ @ H.PWiz

{⍵=1:0⋄1+∇+/1=⍵∨⍳⍵}¨1+⍳99

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

Làm sao?

Rõ ràng tôi đã đi cho công thức tổng thể lâu hơn (và khó hơn) trước tiên. Xem lịch sử sửa đổi.

⍳⍵- 1đển

⍵∨ - gcd với n

1= - bằng 1?

+/ - tổng hợp tất cả

Đây là toàn bộ. Tất cả phần còn lại là trình bao bọc cho việc đếm ( 1+∇) và áp dụng trên phạm vi 2..100( ¨1+⍳99).

Toán học, 44 byte

(i=-1;#+1//.x_:>EulerPhi[++i;x];i)&~Array~99

-10 byte từ @Misha Lavrov
-2 byte từ @ user202729

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

J REPL, 23 byte

<:#@(5&p:^:a:)"0|2+i.99

Tôi đã không kiểm tra, nhưng điều này có thể hoạt động trong J thông thường nếu bạn xác định nó là một danh từ (Tôi đã đánh gôn này trên điện thoại của tôi trên REPL).

Được xây dựng, yo.

Tôi muốn nói rằng có ít nhất 2-3 byte để tắt (từng cái một vì cách a:làm việc, phải sử dụng |như một noop, v.v.).

JavaScript (ES6), 115 ... 104 99 byte

Mã hóa cứng có thể ngắn hơn, nhưng hãy thử một cách tiếp cận toán học thuần túy.

f=n=>n>97?6:(P=(n,s=0)=>k--?P(n,s+(C=(a,b)=>b?C(b,a%b):a<2)(n,k)):s>1?1+P(k=s):1)(k=n+2)+' '+f(-~n)

console.log(f())

Python 2 , 80 byte

n,_=r=2,0;exec'r+=r[sum(k/n*k%n>n-2for k in range(n*n))]+1,;print r[n];n+=1;'*99

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

Python 2 , 82 byte

l=0,1
exec"n=len(l);p=2\nwhile n%p:p+=1\nl+=l[p-1]+l[n/p]-n%4%3/2,;print l[n];"*99

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

Điều này sử dụng các quan sát rằng:

• f(a*b) = f(a) + f(b) - 1, ngoại trừ -1được bỏ qua nếu avà bcả hai
• f(p) = f(p-1) + 1khi nào plà số nguyên tốf(2)=1

Những điều này ngụ ý rằng nếu ncó thừa số nguyên tố n = 2**a * 3**b * 5**c * 7**d * 11**e * ..., thì f(n) = max(a,1) + b + 2*c + 2*d + 3*e + ..., trong đó mỗi p>2nhân tố đóng góp f(p-1).

Tôi không chắc chắn nếu những điều này tiếp tục giữ quá khứ n=100, nhưng nếu có, họ đưa ra một cách để xác định và tính toán fmà không cần sử dụng φ.

Bong bóng , 49 byte

00000000: 5d88 0511 0020 0003 ab2c 024e ff64 e8a3  ].... ...,.N.d..
00000010: 379f 956b f05d 206c 0545 7274 743a b876  7..k.] l.Ertt:.v
00000020: 2267 27f9 9f4d 9b9d fc85 e7e6 994d 6eb0  "g'..M.......Mn.
00000030: 2b                                       +

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

PowerShell , 110 byte

$a=,0*101;2..100|%{$i=$_;for($z=$j=0;++$j-lt$i;$z+=$k-eq1){for($k=$j;$j%$k-or$i%$k;$k--){}};($a[$i]=$a[$z]+1)}

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

Phương pháp toán học.

Trên thực tế, nhìn qua nó, rất giống với câu trả lời C , nhưng được phát triển độc lập. Tạo một mảng 0s, vòng lặp từ 2đến 100, sau đó tính toán phibằng cách sử dụng gcdcông thức. Phần parens ở cuối cả hai lưu kết quả vào $avòng tiếp theo và đặt một bản sao trên đường ống dẫn đến kết quả đầu ra ẩn.

PowerShell, 112 byte

"122323333434344534444545444545555545455645555655565646555656556656665656565656656757566756666667566"-split'(.)'

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

Mã hóa cứng. Hồ-hum. Ngắn hơn tôi có thể có được một cách tiếp cận toán học khoảng 10-15 byte.

Python 2 , 83 byte

n=2
exec"print len(bin(n))-3+n%2-~n%9/8-(0x951a5fddc040419d4005<<19>>n&1);n+=1;"*99

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

Kết hợp một ước lượng heuristic với hằng số được mã hóa cứng để sửa từng ước tính là một -0hoặc -1.

Husk , 10 17 byte

mö←LU¡Sȯṁε⌋ḣtḣ100

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

Chỉnh sửa : +7 byte để thực sự ánh xạ hàm theo phạm vi được yêu cầu, trước khi nó chỉ là hàm tính toán A003434 .

Giải trình

Các tính toán sau A003434 :

←LU¡S(ṁ(ε⌋))ḣ -- takes a number as input, for example: 39
   ¡          -- iterate the following function on the input: [39,24,8,4,2,1,1,1..]
    S(     )ḣ --   with itself (x) and the range [1..x]..
      ṁ(  )   --   ..map and sum the following
        ε⌋    --     0 if gcd not 1 else 1
  U           -- longest unique prefix: [39,24,8,4,2,1]
 L            -- length: 6
←             -- decrement: 5

Phần m(....)ḣ100chỉ ánh xạ chức năng đó trong phạm vi [2..100], không chắc là tôi đã bỏ lỡ phần đó như thế nào trước đây: S

PHP, 98 byte

1,2,<?=join(',',str_split(unpack('H*','##3444E4DEEDEEUUEEVEUVUVVFUVVUfVfVVVVVegWVgVffgV')[1]))?>,6

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

Tôi đóng gói tất cả các chữ số thành một chuỗi nhị phân. Sau khi giải nén nó, chuyển đổi nó thành một mảng và sau đó hợp nhất lại mảng đó, tôi chỉ phải thêm 1,2 và nối thêm 6 vì chúng không phù hợp hoặc khiến mã điều khiển xuất hiện.

Perl 6 , 47 byte

map {($_,{+grep 1==* gcd $_,^$_}...1)-1},2..200

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

05AB1E , 11 byte

тL¦ε[DNs#sÕ

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

Giải trình

тL¦           # push range [2 ... 100]
   ε          # apply to each
    [         # start a loop
     D        # duplicate the current number
      N       # push the loop iteration counter
       s      # swap one copy of the current number to the top of the stack
        #     # if true, break the loop
         s    # swap the second copy of the current number to the top of the stack
          Õ   # calculate eulers totient

C, 112 byte

a[101];f(i,j,k,t){for(a[i=1]=0;i++<100;printf("%d ",a[i]=a[t]+1))for(t=j=0;++j<i;t+=k==1)for(k=j;j%k||i%k;k--);}

Ung dung:

a[101];
f(i,j,k,t){
    for(a[1]=0,i=2;i<=100;i++) {   // initialize
        for(t=j=0;++j<i;t+=k==1)   // count gcd(i, j) == 1 (t = phi(i))
            for(k=j;j%k||i%k;k--); // calculate k = gcd(i, j)
        printf("%d ",a[i]=a[t]+1); // print and store results
    }
}

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

Alumin , 87 byte

hhhhhdadtqdhcpkkmzyhqkhwzydqhhwdrdhhhwrysrshhwqdrybpkshehhhwrysrarhcpkksyhaydhehycpkkmr

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

Giải trình

hhhhhdadt      CONSTANT 100

RANGE FROM 100 to 0
q
  dhc
p

REMOVE 0 AND 1
kk

OVER EACH ELEMENT...
m
  zyh
  q
    kh
    wzyd
    q
      DUPLICATE TOP TWO ELEMENTS...
      hhwdrdhhhwrysrshhw
      GCD...
      qdryb
    p
    ks
    he
    hhhw
    ry
    s
    rarhc
  p
  IS IT ONE? IF SO TERMINATE (FIXPOINT)
  kksyhaydhehyc
p
kk
m
REVERSE THE VALUES
r

Pyth, 38 byte (không cạnh tranh)

.e-+1sl+1kb_jC"Éõ4ÕYHø\\uÊáÛ÷â¿"3

Hãy thử nó trên Herokuapp Pyth , vì nó không hoạt động trên TIO vì bất kỳ lý do gì.

Tôi không nghi ngờ gì về giải pháp Pyth rõ ràng nhỏ hơn, nhưng tôi muốn xem tôi có thể nhận được mã nhỏ như thế nào bằng cách nén chuỗi và tìm hiểu Pyth tôi đoán. Điều này sử dụng thực tế là giới hạn trên của chuỗi làlog2(n)+1 .

Giải trình

.e-+1sl+1kb_jC"Éõ4ÕYHø\\uÊáÛ÷â¿"3
             C"Éõ4ÕYHø\\uÊáÛ÷â¿"   interpret string as base 256 integer
            j                   3  convert to array of base 3 digits
           _                       invert sequence (original had leading 0s)
.e                                 map with enumeration (k=index, b=element)
       +1k                                   k+1
     sl                            floor(log(   ))
   +1                                             +1
  -       b                                         -b

Tôi đã nhận được chuỗi nén thông qua Ci_.e+1-sl+1ksb"122323333434344534444545444545555545455645555655565646555656556656665656565656656757566756666667566"3, điều này trái ngược với mã ở trên với một vài chuyển đổi loại.

Ohm v2 , 41 byte

“ ‽W3>€þΣÌιZ§Á HgüυH§u·β}Bā€ΣNπáÂUõÚ,3“8B

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

Theo nghĩa đen hoàn toàn được mã hóa ... Tôi thực sự đã lấy chuỗi ở trên, tước bỏ mọi thứ không phải là số, giải thích nó là cơ sở 8, sau đó biến nó thành biểu diễn số 255 cơ sở tích hợp của Ohm. Đó là những gì các trích dẫn làm. Sau đó, chương trình chỉ đơn giản biến nó thành cơ sở 8 một lần nữa.