ब्लाइंड रैंडम सॉर्ट

Question

एल्गोरिदम को सॉर्ट करने के लिए यहां एक बहुत ही सामान्य पैटर्न है:

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 की लंबाई की समान रूप से बेतरतीब ढंग से सूची में छँटाई सूची की औसत संख्या है। शुभकामनाएँ।

Comments

@JoKing वास्तव में - आपका सबमिशन एक वितरण है

— isaacg

आप परस्पर राज्य की अनुमति क्यों नहीं देते? इसकी अनुमति देने का मतलब है कि प्रस्तुतियाँ अपने एल्गोरिदम को बेहतर ढंग से ट्यून कर सकती हैं, क्योंकि यह उम्मीद करने के विपरीत है कि सही आइटम उठाए गए हैं।

— नाथन मेरिल

@NathanMerrill यदि उत्परिवर्तनीय स्थिति की अनुमति दी गई, तो विजेता केवल एक सॉर्टिंग नेटवर्क होगा जो पहले से ही एक अच्छी तरह से अध्ययन की गई समस्या है।

— एंडर्स कासोर्ग

@NathanMerrill यदि आप उस प्रश्न को पोस्ट करना चाहते हैं, तो स्वतंत्र महसूस करें। हालाँकि यह सवाल नहीं है।

— isaacg

@NathanMerrill ओह, निश्चित रूप से। चुनौती "डिजाइन सबसे अच्छा सॉर्टिंग नेटवर्क", जबकि एक दिलचस्प सवाल, सीएस अनुसंधान दुनिया में बहुत अध्ययन किया गया है। नतीजतन, सर्वश्रेष्ठ प्रस्तुतियाँ शायद शोध पत्रों के कार्यान्वयन से मिलकर बनेंगी, जैसे कि बैचर के बिटोनिक सॉर्ट। यहां मैंने जो सवाल पूछा है, वह मूल है जहां तक ​​मुझे पता है, और इसलिए नवाचार के लिए अधिक जगह होनी चाहिए।

— isaacg

Answer 1

पायथन, स्कोर = 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 तक बढ़ाया जा सकता है, लेकिन यह वैसे भी देखने के लिए दिलचस्प है। मैंने छोटे मामलों (लंबाई using 7) के लिए इष्टतम वितरण की गणना ढाल वंश और बहुत सारे मैट्रिक्स बीजगणित का उपयोग करके की है। कश्मीर वें स्तंभ शो दूरी पर प्रत्येक स्वैप की संभावना कश्मीर ।

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

Comments

आपका स्कोर:

— 11009

क्या आप अपने आधे जीवन की व्याख्या कर सकते हैं 3 जवाब थोड़ा सा? सूची के सामने की ओर यादृच्छिक संख्या को पूर्वाग्रह करने के लिए बिंदु है?

— मैक्स

छोटी लंबाई के लिए इष्टतम वितरण बहुत दिलचस्प हैं - मैं ध्यान देता हूं कि केंद्र की ओर पूर्वाग्रह करना उपयोगी है, खासकर बड़ी स्वैप दूरी के लिए।

— isaacg

@Max पूरी समस्या उपयोगी तरीकों से यादृच्छिक संख्याओं को पूर्वाग्रह करने के बारे में है; यह तरीका उपयोगी साबित हुआ। ध्यान दें कि hस्वैप किए गए तत्वों के बीच की दूरी है; यह आगे या पीछे का प्रतिनिधित्व नहीं करता है।

— एंडर्स कासोर्ग

आपका आधा जीवन स्कोर: 10000 नमूनों पर 4508।

— isaacg

Answer 2

स्कोर: 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 की सूचियों के लिए हाथ से जोड़ दिया, और वे इष्टतम से बहुत दूर हैं। कुछ मशीन खोज शायद यादृच्छिक-जोड़ी-साथ-चुनी-दूरी की रणनीति के लिए दूरी पर वितरण का अनुकूलन कर सकती है।

Comments

आपका स्कोर: 10,000 नमूनों पर 4627। यदि आप कुछ दिनों के बाद नेताओं के बीच हैं तो मैं इसे और नमूनों के साथ फिर से चलाऊंगा।

— isaacg

Answer 3

स्कोर: 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से बेहतर है तो शेष मूल्यों से चुनना ।

Comments

आपका स्कोर: 28493

— isaacg

Answer 4

पायथन, स्कोर: 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$

इसे ऑनलाइन आज़माएं।

Comments

आपका स्कोर:

— 39525

Answer 5

पायथन, स्कोर ≈ 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 सबसे अच्छा लगता है।

स्कोर Score 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

एक अलग दृष्टिकोण। उतना अच्छा नहीं है, और यह खंडों की संख्या से विभाज्य नहीं लंबाई के साथ बुरी तरह से मर जाता है, लेकिन अभी भी निर्माण करने के लिए मजेदार है।

Comments

आपके स्कोर: घातीय दूरी: ५०५५। खंडित फेरबदल:

— ०१

Answer 6

स्कोर: 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)

इसे ऑनलाइन आज़माएं!

मुझे पता नहीं क्यों। मैं सिर्फ गोले के लिए विकिपीडिया कलात्मक पर सूचीबद्ध दृश्यों की कोशिश की । और यह सबसे अच्छा काम करता है। यह पोस्ट किए गए एक्सनॉर के समान स्कोर प्राप्त करता है ।

Comments

आपका स्कोर: 10,000 नमूनों पर 4583। यदि आप कुछ दिनों में नेताओं के बीच हैं तो मैं इसे और नमूनों के साथ फिर से चलाऊंगा।

— isaacg

इसके अलावा, मैं एक तेज प्रोग्राम चला रहा हूं जो समान वितरण को सैंपल करता है, इसलिए मुझे और सैंपल मिल सकते हैं।

— isaacg

@isaacg बेहतर परीक्षण प्रदर्शन के लिए, candidatesएक वैश्विक चर के रूप में कार्य से बाहर जाना चाहिए।

— tsh

धन्यवाद, मैं जो कर रहा था, उससे कहीं ज्यादा तेज।

— isaacg

Answer 7

अजगर 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)])

इसे ऑनलाइन आज़माएं!

Comments

आपका स्कोर: 10000 नमूनों पर 4871

— इसहाक