Thử thách

Cho bất kỳ số nguyên dương nào được hỗ trợ bởi ngôn ngữ của bạn:

1. Lấy đầu vào và chia thành hai nửa. Đối với tất cả các bộ phận trong chương trình này, nếu đầu vào là số lẻ, làm tròn một nửa lên và một nửa xuống (ví dụ: 7 -> 3,4không 7 -> 3.5,3.5).
2. Chia một nửa số, sau đó lấy số lớn hơn của hai nửa mới này và thêm nó trở lại số chưa chia. Vd: 3,4 -> (1,2),4 -> 1,6hoặc 3,4 -> 3,(2,2) -> 5,2.
3. Lặp lại bước 2 cho đến khi bạn đạt được một bộ bạn đã thấy trước đó. Vd : 5 -> 3,2 -> (1,2),2 -> 1,4 -> 1,(2,2) -> 3,2. Vì chúng ta đã thấy 3,2trước đây, chúng ta có thể ngừng lặp lại. Bạn có thể hoàn toàn cạn kiệt một ngăn xếp trong quá trình làm điều này. Vd : 5 -> 3,2 -> (1,2),2 -> 1,4 -> (0,1),4 -> 0,5.
4. Xuất ra mỗi cặp trong vòng lặp (tức là ở trên không có các bước trung gian, từ lần xuất hiện đầu tiên của cặp cho đến lần thứ hai, nhưng không bao gồm lần thứ hai). Vd : 3,2 -> 1,4. Nếu đầu vào được bao gồm, không xuất đầu ra 0với nó - 5 -> 3,2 -> 1,4, không 0,5 -> 3,2 -> 1,4.
5. Lặp lại các bước 1-4 bằng cách tách các cặp khác nhau.

Tôi / O

Đầu vào là một số nguyên dương lớn hơn 1và nhỏ hơn số nguyên tối đa được hỗ trợ bởi ngôn ngữ của bạn hoặc số nguyên tối đa sẽ không làm sập máy tính, tùy theo giá trị nào nhỏ hơn.

Đầu ra là các vòng lặp ở trên trong bất kỳ định dạng nào bạn muốn (chuỗi, danh sách, mảng, v.v.). Trailing trắng không gian được cho phép.

Không xuất ra cùng một vòng lặp hai lần, cũng không phải các phiên bản khác nhau của cùng một vòng lặp. Ví dụ: 2 -> 1,1và 1,1 -> 2cả hai vòng lặp hợp lệ, nhưng chúng mô tả cùng một vòng lặp, bắt đầu tại các điểm khác nhau trên vòng lặp. Tương tự như vậy, hai vòng lặp giống hệt nhau nhưng đi theo thứ tự ngược lại không nên xuất ra. Vd: 3 -> 1,2 -> 2,1và 3 -> 2,1 -> 1,2là cùng một vòng lặp, nhưng chúng đi theo hướng ngược lại với nhau.

Bạn có thể sử dụng bất kỳ dấu phân cách nào để phân biệt giữa các cặp, giữa mỗi số trong các cặp và giữa mỗi vòng lặp, với điều kiện chúng là ba ký tự hoặc chuỗi riêng biệt. Ở trên, tôi chia các số bằng dấu phẩy, các cặp sử dụng ->và các vòng lặp sử dụng các hướng dẫn nhàm chán. Trong các ví dụ dưới đây, tôi sẽ sử dụng dấu ngoặc đơn quanh mỗi cặp, dấu phẩy giữa mỗi số trong một cặp và các dòng mới giữa mỗi vòng lặp.

Ví dụ

Tín dụng vào mã @ WheatWizard để sửa danh sách ví dụ của tôi. Như tôi đã nói trong một bản thảo trước đó, tôi chắc chắn rằng tôi đã bỏ lỡ một vài thứ kể từ khi tôi làm nó bằng tay, nhưng cậu bé là tôi thiếu một số.

Đầu vào: 2
Đầu ra:(2)(1,1)

Đầu vào: 3
Đầu ra:

(3)(1,2)
(1,2)(2,1)
(3)(1,2)(2,1)

Đầu vào: 4
Đầu ra:

(4)(2,2)(1,3)
(1,3)(3,1)
(4)(2,2)(1,3)(3,1)
(4)(2,2)(3,1)(1,3)
(3,1)(1,3)
(4)(2,2)(3,1)

Đầu vào: 5

Đầu ra:

(5)(2,3)(1,4)
(1,4)(3,2)
(2,3)(1,4)(3,2)(4,1)
(5)(2,3)(1,4)(3,2)(4,1)
(2,3)(4,1)
(5)(2,3)(4,1)

Đầu vào: 6

Đầu ra:

(6)(3,3)(1,5)
(1,5)(4,2)(2,4)
(4,2)(2,4)
(1,5)(4,2)(5,1)(2,4)
(4,2)(5,1)(2,4)
(6)(3,3)(1,5)(4,2)(5,1)
(6)(3,3)(5,1)(2,4)(1,5)
(2,4)(1,5)(4,2)
(5,1)(2,4)(1,5)(4,2)
(2,4)(4,2)
(5,1)(2,4)(4,2)
(6)(3,3)(5,1)

Đầu vào: 7

Đầu ra:

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

Chấm điểm

Đây là môn đánh gôn , vì vậy số byte thấp nhất sẽ thắng.

Đây là thử thách đầu tiên của tôi ở đây, vì vậy mọi phản hồi sẽ được đánh giá rất cao. Liên kết với hộp cát ở đây .

Một sự thật thú vị: Tôi đã chán một ngày và chơi với những mẩu bút chì nhỏ ngẫu nhiên theo cách này và cuối cùng nhận thấy rằng tôi có thể tiếp tục đi theo những vòng lặp này. Vì một số lý do, phản ứng đầu tiên của tôi là tại đây, đây sẽ là một thử thách lớn cho môn đánh gôn.

Sạch , 267 ... 167 byte

import StdEnv
f s l|any((==)s)l=[dropWhile((<>)s)l]#[h,t:_]=s
|1>h*t=f[max h t]l=f[h/2,(h+1)/2+t](l++[s])++(f[(t+1)/2+h,t/2](l++[s]))
@n=removeDup(f[n/2,(n+1)/2][[n]])

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

Ung dung:

loops num
    = removeDup (half (divide num) [[num]])
where
    divide num
        = [num/2, (num+1)/2]
    half [_, 0] list
        = list
    half [0, _] list
        = list
    half [a, b] list
        | isMember [a, b] list
            = [dropWhile ((<>) [a, b]) list]
        # [u, v: _]
            = divide a
        # [x, y: _]
            = divide b
        = (half [u, v+b] (list ++ [a, b])) ++ (half [a+y, x] (list ++ [a, b]))

Haskell , 227 203 byte

17 byte được lưu nhờ vào Οurous

(%)=div
u x|odd x=x%2+1|1>0=x%2
[0,b]!l=[b]!l
[b,0]!l=[b]!l
t!l|elem t l=[dropWhile(/=t)l]
t@[a,b]!l|q<-l++[t]=[a%2,u a+b]!q++[u b+a,b%2]!q
f x|q<-[x%2,u x]![[x]]=[a|(a,b)<-zip q[0..],notElem a$take b q]

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