Đây là một mẫu khá phổ biến để sắp xếp các thuật toán:

def sort(l):
    while not is_sorted(l):
         choose indices i, j
         assert i < j
         if l[i] > l[j]:
             l[i], l[j] = l[j], l[i]

Các thuật toán này hoạt động tốt vì các chỉ số ivà jđược chọn cẩn thận, dựa trên trạng thái của danh sách l.

Tuy nhiên, điều gì sẽ xảy ra nếu chúng ta không thể nhìn thấy lvà phải chọn một cách mù quáng? Làm thế nào nhanh chóng chúng ta có thể sắp xếp danh sách sau đó?

Thử thách của bạn là viết một hàm tạo ra một cặp chỉ số ngẫu nhiên, chỉ với độ dài là l. Cụ thể, bạn phải xuất hai chỉ số i, j, với 0 <= i < j < len(l). Chức năng của bạn sẽ hoạt động trên bất kỳ độ dài nào của danh sách, nhưng nó sẽ được ghi vào danh sách có độ dài 100.

Điểm của bạn là số lựa chọn chỉ số trung bình cần thiết để sắp xếp danh sách xáo trộn ngẫu nhiên thống nhất theo mẫu trên, trong đó các chỉ số được chọn theo chức năng của bạn.

Tôi sẽ chấm điểm các bài nộp, lấy số lượng lựa chọn chỉ số trung bình trên 1000 thử nghiệm trên một danh sách được xáo trộn ngẫu nhiên thống nhất có độ dài 100 mà không có mục lặp lại.

Tôi bảo lưu quyền chạy thử nghiệm ít hơn nếu bài nộp rõ ràng không cạnh tranh hoặc không chấm dứt và tôi sẽ chạy nhiều thử nghiệm hơn để phân biệt các đối thủ cạnh tranh hàng đầu để tìm một người chiến thắng. Nếu nhiều lần gửi hàng đầu vẫn nằm trong phạm vi lỗi ở giới hạn tài nguyên tính toán của tôi, tôi sẽ tuyên bố gửi trước đó cho người chiến thắng, cho đến khi có thể mang lại các tài nguyên tính toán tiếp theo.

Đây là một chương trình tính điểm ví dụ, bằng Python:

import random
def is_sorted(l):
    for x in range(len(l)-1):
        if l[x] > l[x+1]:
            return False
    return True

def score(length, index_chooser):
    steps = 0
    l = list(range(length))
    random.shuffle(l)

    while not is_sorted(l):
        i, j = index_chooser(length)
        assert (i < j)
        if l[i] > l[j]:
            l[i], l[j] = l[j], l[i]
        steps += 1
    return steps

Hàm của bạn có thể không duy trì bất kỳ trạng thái có thể thay đổi nào, tương tác với các biến toàn cục, ảnh hưởng đến danh sách l, v.v. Đầu vào duy nhất của hàm phải là độ dài của danh sách lvà phải xuất ra một cặp số nguyên theo thứ tự trong phạm vi [0, len(l)-1](hoặc phù hợp với ngôn ngữ của bạn liệt kê danh sách). Hãy hỏi xem có gì được cho phép trong các bình luận không.

Đệ trình có thể bằng bất kỳ ngôn ngữ sử dụng miễn phí nào. Vui lòng bao gồm khai thác điểm nếu chưa được đăng cho ngôn ngữ của bạn. Bạn có thể đăng một số điểm tạm thời, nhưng tôi sẽ để lại nhận xét với số điểm chính thức.

Ghi điểm là số bước trung bình của một danh sách được sắp xếp trên danh sách được xáo trộn ngẫu nhiên có độ dài 100. Chúc may mắn.

Con trăn, điểm = 4508

def half_life_3(length):
    h = int(random.uniform(1, (length / 2) ** -3 ** -0.5) ** -3 ** 0.5)
    i = random.randrange(length - h)
    return i, i + h

Half-Life 3 xác nhận.

Con trăn, điểm = 11009

def bubble(length):
    i = random.randrange(length - 1)
    return i, i + 1

Rõ ràng một loại bong bóng ngẫu nhiên không làm tất cả tồi tệ hơn nhiều so với một loại bong bóng bình thường.

Phân phối tối ưu cho chiều dài nhỏ

Không có cách nào điều này có thể được mở rộng đến chiều dài 100, nhưng thật thú vị khi xem xét bằng mọi cách. Tôi đã tính toán các phân phối tối ưu cho các trường hợp nhỏ (độ dài 7) bằng cách sử dụng độ dốc và nhiều đại số ma trận. Các k thứ show cột xác suất của mỗi hoán đổi ở khoảng cách k .

length=1
score=0.0000

length=2
1.0000
score=0.5000

length=3
0.5000 0.0000
0.5000
score=2.8333

length=4
0.2957 0.0368 0.0000 
0.3351 0.0368 
0.2957 
score=7.5106

length=5
0.2019 0.0396 0.0000 0.0000 
0.2279 0.0613 0.0000 
0.2279 0.0396 
0.2019 
score=14.4544

length=6
0.1499 0.0362 0.0000 0.0000 0.0000 
0.1679 0.0558 0.0082 0.0000 
0.1721 0.0558 0.0000 
0.1679 0.0362 
0.1499 
score=23.4838

length=7
0.1168 0.0300 0.0041 0.0000 0.0000 0.0000 
0.1313 0.0443 0.0156 0.0000 0.0000 
0.1355 0.0450 0.0155 0.0000 
0.1355 0.0443 0.0041 
0.1313 0.0300 
0.1168 
score=34.4257

Điểm: 4627

def rand_step(n):
	step_size = random.choice([1, 1, 4, 16])
	
	if step_size > n - 1:
		step_size = 1 
	
	start = random.randint(0, n - step_size - 1)
	return (start, start + step_size)

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

Đầu ra các chỉ số ngẫu nhiên có khoảng cách xa nhau được chọn thống nhất từ [1,1,4,16]. Ý tưởng là có sự kết hợp của các giao dịch hoán đổi 1 bước với các giao dịch hoán đổi ở quy mô lớn hơn.

Tôi đã điều chỉnh bằng tay các giá trị này cho các danh sách có độ dài 100 và chúng có thể không còn tối ưu. Một số tìm kiếm máy có thể có thể tối ưu hóa phân phối theo khoảng cách cho chiến lược khoảng cách cặp ngẫu nhiên với lựa chọn khoảng cách.

Điểm: 28493

def x_and_y(l):
    x = random.choice(range(l))
    y = random.choice(range(l))
    while y == x and l != 1: y = random.choice(range(l))
    return sorted([x,y])

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

Giải pháp này chỉ chọn các giá trị riêng biệt cho xvà yngẫu nhiên từ phạm vi và trả về chúng theo thứ tự được sắp xếp. Theo như tôi có thể nói, điều này thực hiện tốt hơn so với việc chọn xsau đó chọn ytừ các giá trị còn lại.

Con trăn, điểm: 39525

def get_indices(l):
    x = random.choice(range(l-1))
    y = random.choice(range(x+1,l))
    return [x,y]

$[0, l-1)$$x$
$x$$[x+1, l)$$y$

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

Con trăn, điểm ≈ 5000

def exponentialDistance(n):
    epsilon = 0.25
    for dist in range(1, n):
        if random.random() < epsilon:
            break
    else:
        dist = 1
    low = random.randrange(0, n - dist)
    high = low + dist
    return low, high

Đã thử với một loạt các giá trị epsilon, 0,25 dường như là tốt nhất.

Điểm 8881

def segmentedShuffle(n):
    segments = 20
    segmentLength = (n - 1) // segments + 1

    if random.random() < 0.75:
        a = b = 0
        while a == b or a >= n or b >= n:
            segment = random.randrange(segments)
            a = random.randrange(segmentLength) + segment * segmentLength
            b = random.randrange(segmentLength) + segment * segmentLength
        return sorted([a, b])

    highSegment = random.randrange(1, segments)
    return highSegment * segmentLength - 1, highSegment * segmentLength

Một cách tiếp cận khác. Không tốt bằng, và nó chết khủng khiếp với chiều dài không chia hết cho số lượng phân khúc, nhưng vẫn vui vẻ để xây dựng.

Điểm: 4583

def rand_shell(l):
    steps = [1, 3, 5, 9, 17, 33, 65, 129]
    candidates = [(left, left + step)
            for (step, nstep) in zip(steps, steps[1:])
            for left in range(0, l - step)
            for i in range(nstep // step)
    ]
    return random.choice(candidates)

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

Tôi không biết tại sao. Tôi vừa thử các trình tự được liệt kê trên wikipedia artical cho shellsort . Và cái này có vẻ hoạt động tốt nhất. Nó nhận được số điểm tương tự với một xnor được đăng .

Con trăn 2 , 4871

import random
def index_chooser(length):
    e= random.choice([int(length/i) for i in range(4,length*3/4)])
    s =random.choice(range(length-e))
    return [s,s+e]
def score(length, index_chooser):
    steps = 0
    l = list(range(length))
    random.shuffle(l)
    while True:
        for x in range(length-1):
            if l[x] > l[x+1]:
                break
        else:
            return steps
        i, j = index_chooser(length)
        assert(i < j)
        if l[i] > l[j]:
            l[i], l[j] = l[j], l[i]
        steps += 1

print sum([score(100, index_chooser) for t in range(100)])

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