정렬 알고리즘에 대한 일반적인 패턴은 다음과 같습니다.

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]

이 알고리즘은 인덱스 때문에 잘 작동 i및 j목록의 상태에 따라 신중하게 선택됩니다 l.

그러나 우리가 볼 수없고 l맹목적으로 선택해야한다면 어떨까요? 그러면 목록을 얼마나 빨리 정렬 할 수 있습니까?

당신의 도전은 길이가 주어진 임의의 인덱스 쌍을 출력하는 함수를 작성하는 것입니다 l. 특히을 사용 i, j하여 두 개의 인덱스를 출력해야합니다 0 <= i < j < len(l). 함수는 모든 길이의 목록에서 작동하지만 길이 100의 목록에서 점수가 매겨집니다.

점수는 위의 패턴에 따라 균일하게 무작위로 섞인 목록을 정렬하는 데 필요한 평균 인덱스 선택 수입니다. 여기서 인덱스는 함수에 따라 선택됩니다.

나는 반복적으로 참가하지 않고 길이가 100으로 균일하게 무작위로 섞인 목록에서 1000 회 이상의 시험 선택의 평균 수를 취하여 제출 점수를 매길 것입니다.

제출이 명백히 비 경쟁적이거나 종료되지 않은 경우, 더 적은 재판을 진행할 권리를 보유하며, 최고의 경쟁사를 선정하여 단일 우승자를 찾기 위해 더 많은 재판을 진행할 것입니다. 계산 리소스 한도에서 여러 개의 상위 제출이 오류 한계 내에 남아있는 경우 추가 계산 리소스를 사용할 수있을 때까지 이전 제출을 승자로 선언합니다.

다음은 파이썬에서 채점 프로그램의 예입니다.

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

함수는 변경 가능한 상태를 유지하지 못하고 전역 변수와 상호 작용하고 목록에 영향을 줄 수 있습니다 l. 함수의 유일한 입력은 목록의 길이 l여야하며 범위의 정렬 된 정수 쌍을 출력해야합니다[0, len(l)-1] (또는 언어에 적합) 목록 색인 생성). 의견에 무엇이 허용되는지 물어보십시오.

제출물은 무료 언어로 제공 될 수 있습니다. 귀하의 언어로 아직 게시되지 않은 채점 하네스를 포함하십시오. 잠정 점수를 게시 할 수는 있지만 공식 점수에 대해서는 의견을 남기겠습니다.

스코어링은 길이가 100으로 균일하게 무작위로 섞인 목록에서 정렬 된 목록까지의 평균 단계 수입니다. 행운을 빈다.

파이썬, 점수 = 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

반감기 3 확인.

파이썬, 점수 = 11009

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

분명히 무작위 버블 정렬은 일반적인 버블 정렬보다 그다지 나쁘지 않습니다.

작은 길이에 대한 최적 분포

이것이 길이 100으로 확장 될 수있는 방법은 없지만 어쨌든 살펴 보는 것은 흥미 롭습니다. 그래디언트 디센트와 많은 행렬 대수를 사용하여 작은 경우 (길이 ≤ 7)에 대한 최적 분포를 계산했습니다. K 칼럼 쇼 번째 거리에서 서로 교환 확률 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

점수 : 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)

온라인으로 사용해보십시오!

거리가 균등하게 선택된 랜덤 인덱스를 출력합니다. [1,1,4,16] 합니다. 아이디어는 더 큰 규모의 스왑과 1 단계 스왑을 혼합하는 것입니다.

길이 100의 목록에 대해이 값을 수동으로 조정했으며 최적의 값과는 거리가 멀습니다. 일부 기계 검색은 임의 거리-선택된 거리 전략을 위해 거리에 따른 분포를 최적화 할 수 있습니다.

점수 : 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])

온라인으로 사용해보십시오!

이 솔루션은 단지에 대해서는 다른 값을 선택 x하고 y무작위로 범위 및 정렬 된 순서로 반환 그들로부터. 내가 알 수있는 한, 이것은 나머지 값에서 x선택 y하고 선택하는 것보다 성능이 좋습니다 .

파이썬, 점수 : 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$

온라인으로 사용해보십시오.

파이썬, ≈ 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

많은 엡실론 값으로 시도하면 0.25가 가장 좋습니다.

≈ 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

다른 접근법. 그다지 좋지는 않으며, 세그먼트 수로 나눌 수는 없지만 여전히 재미있게 지낼 수 있습니다.

점수 : 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)

온라인으로 사용해보십시오!

왜 그런지 모르겠습니다. 방금 wikipedia artical에 나열된 시퀀스를 shellsort 용으로 시도했습니다 . 그리고 이것은 가장 잘 작동하는 것 같습니다. 그것은 하나의 xnor 게시 와 비슷한 점수를 얻습니다 .

파이썬 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)])

온라인으로 사용해보십시오!