Một hàm (hoặc chương trình) nhận đầu vào và cung cấp đầu ra có thể được gọi là có chu kỳ nếu gọi hàm trên đầu ra của chính nó liên tục đạt đến số ban đầu. Ví dụ, lấy chức năng sau:

Input:  n    1 2 3 4 5 6
Output: f(n) 5 7 1 3 4 9

Nếu chúng ta bắt đầu với n=1, f(n)=5, f(f(n))=f(5)=4, f(f(f(n)))=f(4)=3, f(f(f(f(n))))=f(3)=1.

Điều này được viết (1 5 4 3). Vì có 4 số duy nhất trong vòng lặp này, đây là một chu kỳ có độ dài 4.

Thách thức của bạn là viết một chương trình hoặc chức năng có chu kỳ ở mọi độ dài có thể. Nghĩa là, phải có một chu kỳ dài 1, dài 2, v.v.

Ngoài ra, chức năng / chương trình của bạn phải từ số nguyên dương sang số nguyên dương và nó phải là tính từ , nghĩa là phải có chính xác một giá trị đầu vào cho mỗi giá trị đầu ra có thể, trên tất cả các số nguyên dương. Nói cách khác, hàm / chương trình phải tính toán một phép tính của các số nguyên dương.

Chi tiết: Bất kỳ hệ thống đầu vào / đầu ra tiêu chuẩn nào đều được cho phép, bao gồm STDIN, STDOUT, đối số chức năng, trả về, v.v ... Các lỗ hổng tiêu chuẩn bị cấm.

Bạn không cần phải lo lắng về các giới hạn của các loại dữ liệu của mình - các thuộc tính trên chỉ cần giữ theo giả định rằng một inthoặc floatcó thể giữ bất kỳ giá trị nào, chẳng hạn.

Không có hạn chế nào đối với hành vi của hàm đối với các đầu vào không phải là số nguyên dương và các đầu vào / đầu ra đó sẽ bị bỏ qua.

Ghi điểm là mã golf theo byte, mã ngắn nhất sẽ thắng.

Bình thường, 11 8 byte

.<W-0zz1

Nhiều nhàm chán hơn câu trả lời trước đây của tôi.

Mỗi số có chứa một bản đồ 0 chữ số cho chính nó. Bất kỳ số nào khác ánh xạ tới số có các chữ số của nó được xoay bởi 1. Vì vậy, ví dụ:

1 -> 1
10 -> 10
15 -> 51 -> 15
104 -> 104
123 -> 231 -> 312 -> 123

Python 2, 56 55 54 byte

n=input()
a=b=1
while a+b<=n:a+=b;b+=1
print(n+~a)%b+a

Đây là 21 đầu ra đầu tiên:

[1, 3, 2, 6, 4, 5, 10, 7, 8, 9, 15, 11, 12, 13, 14, 21, 16, 17, 18, 19, 20]

Mô hình là rõ ràng nếu chúng ta chia danh sách thành nhiều phần như vậy:

 1    2  3    4  5  6    7  8  9  10    11  12  13  14  15    16  17  18  19  20  21
[1]  [3, 2]  [6, 4, 5]  [10, 7, 8, 9]  [15, 11, 12, 13, 14]  [21, 16, 17, 18, 19, 20]

Bình thường, 25 byte

+hK/*J/h@h*8tQ2 2tJ2%-QKJ

Đây là trình tự tương tự như @ Sp3000, nhưng với dạng đóng. Hình thức đóng là:

Python3, 40 byte

n=input();print([n[1:]+n[0],n]['0'in n])

Mỗi số có chứa một bản đồ 0 chữ số cho chính nó. Bất kỳ số nào khác ánh xạ tới số có các chữ số của nó được xoay bởi 1. Vì vậy, ví dụ:

1 -> 1
10 -> 10
15 -> 51 -> 15
104 -> 104
123 -> 231 -> 312 -> 123

Hồng ngọc, 22 + 1 = 23

Với cờ dòng lệnh -p, chạy

~/(.)(.?)/
$_=$1+$'+$2

Khi được đưa vào dưới dạng một chuỗi đại diện cho một số (không có dòng mới ở cuối), nó sẽ giữ chữ số đầu tiên không đổi, sau đó xoay phần còn lại, do đó 1234sẽ trở thành 1342.

Điều này có thể giảm xuống còn 21 ký tự $_=$1+$'+$2if/(.)(.)/, nhưng in cảnh báo.

Hồng ngọc, 16 + 1 = 17

Với cờ dòng lệnh -p, chạy

$_=$_[/.0*$/]+$`

Đây là một chức năng phức tạp hơn so với câu trả lời khác của tôi, nhưng tình cờ có thể chơi được nhiều hơn (và chịu được các dòng mới). Nó lấy chữ số khác không cuối cùng của đầu vào, cộng với bất kỳ số 0 nào và di chuyển nó đến đầu số. Vì vậy, 9010300trở thành 3009010. Bất kỳ số nào có n chữ số khác không sẽ là một phần của chu kỳ n dài.

Đầu vào là một chuỗi trong bất kỳ cơ sở nào thông qua STDIN, đầu ra là một chuỗi trong cơ sở đó.

Con trăn, 43

Các nghịch đảo của hàm Sp3000 của , thực hiện đệ quy.

f=lambda n,k=1:n>k and k+f(n-k,k+1)or n%k+1

Hàm này là một chu kỳ, theo sau là hai chu kỳ, sau đó là ba chu kỳ, ...

(1)(2 3)(4 5 6)(7 8 9 10)(11 12 13 14 15)...

Các hoạt n%k+1động như một kmô-đun trên các số 1..k. Để tìm sự phù hợp kđể sử dụng, hãy chuyển mọi thứ xuống k=1, sau đó k=2, và cứ thế, cho đến khi n<=k.

Bình thường, 15 byte

Câu trả lời ngắn nhất cho đến nay sử dụng các phép toán số thay vì các phép toán chuỗi.

.|.&Q_=.&_=x/Q2

    Q                input
            /Q2      input div 2
           x   Q     that XOR input
          =          assign that to Q
         _           negate that
       .&       Q    that AND Q
      =              assign that to Q
     _               negate that
  .&                 input AND that
.|               Q   that OR Q

Tác dụng của hàm này đối với biểu diễn nhị phân là mở rộng khối 1 bên phải sang 0 tiếp theo; hoặc nếu không có 0, để đặt lại về 1:

10010110100000 ↦  
10010110110000 ↦  
10010110111000 ↦  
10010110111100 ↦  
10010110111110 ↦  
10010110111111 ↦
10010110100000  

Pyth, 26 byte, biến thể vui nhộn

.|.&Q_h.&/Q2+Qy=.&/Q2_h.|y

    Q                           input
         /Q2                    input div 2
             Q                  input
                  /Q2           input div 2
                         yQ     twice input
                       .|  Q    that OR input
                     _h         NOT that
                .&              (input div 2) AND that
               =                assign that to Q
              y                 twice that
            +                   input plus that
       .&                       (input div 2) AND that
     _h                         NOT that
  .&                            input AND that
.|                          Q   that OR Q

Thực hiện đồng thời thao tác trên cho tất cả các khối 1 giây, không chỉ một khối ngoài cùng bên phải vẫn chỉ sử dụng các phép toán bitwise và số học.

1000010001001 ↦
1100011001101 ↦
1110011101001 ↦
1111010001101 ↦
1000011001001 ↦
1100011101101 ↦
1110010001001 ↦
1111011001101 ↦
1000011101001 ↦
1100010001101 ↦
1110011001001 ↦
1111011101101 ↦
1000010001001

Swift 1,2, 66 byte

func a(b:Int){var c=0,t=1,n=b
while n>c{n-=c;t+=c++}
print(n%c+t)}

Input:  1,   2, 3,  4, 5, 6,   7, 8, 9, 10,   11, 12, 13, 14, 15
Output: 1,   3, 2,  5, 6, 4,   8, 9, 10, 7,   12, 13, 14, 15, 11

Brachylog , 5 byte

∋0&|↺

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

Cổng câu trả lời Pyth của @ orlp. Xuất hiện đơn giản và gọn gàng:

∋0    % If input contains a 0 (since input is a single number, "contains" ∋ treats it as an array 
      %   of its digits, so this means "if any of input's digits are 0")
&     % Then output is the input
|     % Otherwise
↺     % Circularly shift the input once, and unify that with the output

Ban đầu tôi muốn port giải pháp Python của Sp3000, nhưng nó đã chiếm tới 23 byte :

⟧∋B-₁⟦++₁A≤?;A--₁;B%;A+

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

JavaScript (ES6), 43 byte

f=(n,i=1,j=1)=>n>j?f(n,++i,j+i):n++<j?n:n-i

Matlab (189)

  function u=f(n),if(~n|n==1)u=n;else,u=n;y=factor(n);z=y(y~=2);if ~isempty(z),t=y(y~=max(y));if isempty(t),u=y(end)*2^(nnz(y)-1);else,g=max(t);e=primes(g*2);u=n/g*e(find(e==g)+1);end,end,end

• Chức năng:

  Ánh xạ bất kỳ số nguyên nào theo các thừa số nguyên tố của nó, nếu số đó bằng 0 hoặc được nhân thành 2 hoặc 1, thì số đó được ánh xạ tới chính nó, nếu không, chúng tôi chọn hệ số nguyên tố lớn nhất của số này, sau đó chúng tôi tăng các yếu tố nguyên tố khác nhau còn lại gần nhất hệ số nguyên tố lớn hơn cho đến khi chúng ta đạt được số biggest_prime^ntrong đó ntổng của tất cả các số mũ của tất cả các yếu tố, một khi chúng ta đạt được số tiền đó, chúng ta chuyển sang max_prime*2^(n-1)và chúng ta tái tạo lại cùng một chu kỳ.

Matlab (137)

  function u=h(n),if(~n|n==1)u=n;else,u=n;y=factor(n);z=y(y~=2);if~isempty(z),e=nnz(y);f=nnz(z);if(~mod(e,f)&e-f)u=n/2^(e-f);else,u=u*2;end

• Một cách tiếp cận hơi giống nhau, nhân dần dần bất kỳ số nào không bằng {0,1,2 ^ n} 2cho đến khi chúng ta vấp phải một số mũ 2chia hết cho số mũ của các thừa số nguyên tố khác. sau đó chúng ta di chuyển đến đầu chu kỳ chia cho 2^(sum of exponents of other primes). các tê khác được ánh xạ đến chính họ.