इसे लें या छोड़ें: कंप्यूटर के लिए एक गेम शो


28

प्रसंग:

दुनिया के सबसे अच्छे और प्रतिभाशाली प्रोग्रामर को आकर्षित करने के लिए एक पुनरावर्ती अरबपति ने एक गेम शो बनाया है। आधी रात के स्ट्रोक पर, वह आवेदकों में से एक व्यक्ति को सप्ताह का प्रतियोगी होने के लिए चुनता है, और उन्हें एक खेल प्रदान करता है। आप इस सप्ताह भाग्यशाली प्रतियोगी हैं!

इस सप्ताह का खेल:

होस्ट आपको 10,000 डिजिटल लिफाफों के ढेर तक एपीआई पहुंच प्रदान करता है। ये लिफाफे बेतरतीब ढंग से छांटे जाते हैं, और उनके भीतर एक डॉलर मूल्य होता है, $ 1 और $ 10,000 के बीच (कोई दो लिफाफे समान डॉलर मूल्य नहीं होते हैं)।

आपके पास अपने निपटान में 3 कमांड हैं:

  1. पढ़ें (): स्टैक के शीर्ष पर लिफाफे में डॉलर का आंकड़ा पढ़ें।

  2. टेक (): अपने गेम शो वॉलेट में लिफाफे में डॉलर का आंकड़ा जोड़ें, और स्टैक से लिफाफे को पॉप करें।

  3. पास (): स्टैक के शीर्ष पर स्थित लिफाफे को बंद करें।

नियम:

  1. यदि आप एक लिफाफे पर पास () का उपयोग करते हैं, तो भीतर का पैसा हमेशा के लिए खो जाता है।

  2. यदि आप $ X वाले लिफाफे पर Take () का उपयोग करते हैं, तो उस बिंदु से आगे, आप कभी भी <$ X वाले लिफाफे पर Take () का उपयोग नहीं कर सकते हैं। इनमें से एक लिफाफे पर () को अपने बटुए में $ 0 जोड़ देंगे।

एक एल्गोरिथ्म लिखें जो गेम को अधिकतम धन राशि के साथ पूरा करता है।

यदि आप पाइथन में एक समाधान लिख रहे हैं, तो इस कंट्रोलर का उपयोग करने के लिए स्वतंत्र महसूस करें, एल्गोरिदम का परीक्षण करने के लिए @ माल्टीसेन: https://gist.github.com/Maltysen/5a4a33691cd603b9aeca

यदि आप नियंत्रक का उपयोग करते हैं, तो आप ग्लोबल्स तक नहीं पहुंच सकते हैं, आप केवल 3 प्रदान किए गए एपीआई कमांड और स्थानीय स्कोप वाले चर का उपयोग कर सकते हैं। (@ बीता डेके)

नोट: इस मामले में "मैक्सिमल" का अर्थ है एन> 50 रन के बाद आपके बटुए में औसत मूल्य। मैं उम्मीद करता हूं, हालांकि मैं गलत साबित होना पसंद करूंगा, कि किसी दिए गए एल्गोरिदम का औसत मूल्य एन के रूप में परिवर्तित हो जाएगा। इसके बजाय औसत को अधिकतम करने की कोशिश करने के लिए स्वतंत्र महसूस करें, लेकिन मुझे यह महसूस होता है कि माध्य की तुलना में एक छोटे से एन द्वारा फेंका जाने की संभावना अधिक है।

संपादित करें: आसान प्रसंस्करण के लिए लिफाफों की संख्या को 10k में बदल दिया, और टेक () को अधिक स्पष्ट कर दिया।

संपादित करें 2: मेटा पर इस पोस्ट के प्रकाश में, पुरस्कार की शर्त को हटा दिया गया है ।

वर्तमान उच्च स्कोर:

फीनोटपी - $ 805,479

रेटो कोराडी - $ 803,960

डेनिस - $ 770,272 (संशोधित)

एलेक्स एल। - $ 714,962 (संशोधित)


मैंने इस तरह से कार्यान्वित किया कि यह केवल गलत रिटर्न देता है। चूँकि आप इसे पढ़ सकते हैं इसलिए फेल लेने पर पूरे खेल को विफल करने का कोई वास्तविक बिंदु नहीं है ()
ओग्मुन

4
यदि कोई इसका उपयोग करना चाहता है, तो यहां नियंत्रक है जिसे मैं अपने एल्गोरिदम का परीक्षण करने के लिए उपयोग कर रहा हूं: gist.github.com/Maltysen/5a4a33691cd603e9aeca
माल्टीसेन

8
पुनश्च अच्छा सवाल और प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है :)
ट्रिकोप्लाक्स

3
@ मैलेटसेन मैंने आपके नियंत्रक को ओपी में डाल दिया, योगदान के लिए धन्यवाद!
लिविंगइनफॉर्मेशन

1
मुझे बिटकॉइन पुरस्कारों पर एक स्पष्ट नियम नहीं मिला, लेकिन वास्तविक विश्व पुरस्कारों पर कुछ मेटा चर्चा है जो लोग योगदान कर सकते हैं।
ट्राइकोप्लाक्स

जवाबों:


9

CJam, $ 87,143 $ 700,424 $ 720,327 $ 727,580 $ 770,272

{0:T:M;1e4:E,:)mr{RM>{RR(*MM)*-E0.032*220+R*<{ERM--:E;R:MT+:T;}{E(:E;}?}&}fRT}
[easi*]$easi2/=N

यह कार्यक्रम पूरे खेल को कई बार अनुकरण करता है और माध्यिका की गणना करता है।

कैसे चलाना है?

मैंने 100,001 टेस्ट रन बनाकर अपना सबमिशन किया है:

$ time java -jar cjam-0.6.5.jar take-it-or-leave-it.cjam 100001
770272

real    5m7.721s
user    5m15.334s
sys     0m0.570s

पहुंच

प्रत्येक लिफाफे के लिए, हम निम्नलिखित कार्य करते हैं:

  • लिफाफे को लेने से अनिवार्य रूप से खो जाने वाली राशि का अनुमान लगाएं

    यदि R सामग्री है और M अधिकतम लिया गया है, तो राशि को R (R-1) / 2 - M (M + 1) / 2 के रूप में अनुमानित किया जा सकता है , जो धन को सामग्री X के साथ सभी लिफाफे देता है। अंतराल (एम, आर) होते हैं।

    यदि कोई लिफाफा अभी तक पारित नहीं किया गया था, तो अनुमान सही होगा।

  • लिफाफे को पारित करके अनिवार्य रूप से खो जाने वाली धनराशि की गणना करें।

    यह बस लिफाफे में शामिल धन है।

  • जांचें कि क्या दोनों की भागफल 110 + 0.016E से कम है , जहां शेष लिफाफे की संख्या है (लिफाफे की गिनती नहीं है जो अब नहीं ली जा सकती)।

    यदि ऐसा है, तो लें। नहीं तो पास करो।


5
क्योंकि गोल्फिंग भाषा का उपयोग किसी भी तरह से मदद करता है। ; पी एल 1 एगो के लिए।
माल्टेसन

2
मैं पायथन क्लोन का उपयोग करके आपके परिणामों की नकल नहीं कर सकता: gist.github.com/orlp/f9b949d60c766430fe9c । आप $ 50,000 के आसपास स्कोर करते हैं। वह परिमाण का एक क्रम है।
orlp

1
@LivingInformation परीक्षण और त्रुटि। मैं वर्तमान में अनुमानों के बजाय सटीक राशि का उपयोग कर रहा हूं, लेकिन परिणामी कोड बहुत धीमा है।
डेनिस

2
इस उत्तर को मेरी तुलना में अधिक उत्थान की आवश्यकता है! यह अधिक चतुर, उच्च स्कोर है, और यहां तक ​​कि गोल्फ है!
एलेक्स एल

1
@LivingInformation यह मेरा पता है: 17uLHRfdD5JZ2QjSqPGQ1B12LoX4CgLGuV
डेनिस

7

अजगर, $ 680,646 $ 714,962

f = (float(len(stack)) / 10000)
step = 160
if f<0.5: step = 125
if f>0.9: step = 190
if read() < max_taken + step:
    take()
else:
    passe()

$ 125 और $ 190 के बीच आकार के चरणों में बड़ी और बड़ी मात्रा लेता है। एन = 10,000 के साथ दौड़ा और $ 714962 का एक पदक प्राप्त किया। ये चरण आकार परीक्षण और त्रुटि से आए और निश्चित रूप से इष्टतम नहीं हैं।

पूर्ण कोड, जिसमें @ माल्टेंस के नियंत्रक का एक संशोधित संस्करण शामिल है, जो एक बार चार्ट को प्रिंट करता है:

import random
N = 10000


def init_game():
    global stack, wallet, max_taken
    stack = list(range(1, 10001))
    random.shuffle(stack)
    wallet = max_taken = 0

def read():
    return stack[0]

def take():
    global wallet, max_taken
    amount = stack.pop(0)
    if amount > max_taken:
        wallet += amount
        max_taken = amount

def passe():
    stack.pop(0)

def test(algo):
    results = []
    for _ in range(N):
        init_game()
        for i in range(10000):
            algo()
        results += [wallet]
        output(wallet)
    import numpy
    print 'max: '
    output(max(results))
    print 'median: '
    output(numpy.median(results))
    print 'min: '
    output(min(results))

def output(n):
    print n
    result = ''
    for _ in range(int(n/20000)):
        result += '-'
    print result+'|'

def alg():
    f = (float(len(stack)) / 10000)
    step = 160
    if f<0.5: step = 125
    if f>0.9: step = 190
    if read() < max_taken + step:
        #if read()>max_taken: print read(), step, f
        take()
    else:
        passe()

test(alg)

BitCoin पता: 1CBzYPCFFBW1FX9sBTNNYUJyMxMcmL4BZ7

वाह ओपी दिया! धन्यवाद @LivingInformation!


1
नियंत्रक माल्टेसन है, मेरा नहीं।
orlp

2
की पुष्टि की। मैंने बस एक नियंत्रक स्थापित किया था, और आपके समाधान के लिए बहुत समान संख्याएं प्राप्त कीं। कड़ाई से बोलते हुए, मुझे लगता है कि आपको max_takenअपने कोड का मूल्य बनाए रखना होगा , क्योंकि यह आधिकारिक गेम एपीआई का हिस्सा नहीं है। लेकिन यह करने के लिए तुच्छ है।
रेटो कोराडी

1
हाँ, max_taken @ Maltysen के कंट्रोलर में है। यदि यह उपयोगी है तो मैं एक ब्लॉक में संपूर्ण समाधान (नियंत्रक + एल्गोरिथ्म) पोस्ट कर सकता हूं।
एलेक्स एल

यह वास्तव में कोई बड़ी बात नहीं है। लेकिन मुझे लगता है साफ दृष्टिकोण केवल उपयोग करने के लिए किया जाएगा read(), take()और pass()पोस्ट कोड में तरीकों, उन के बाद से सवाल में परिभाषा के आधार पर "अपने निपटान में 3 कमांड" कर रहे हैं।
रेटो कोराडी

@Reto मैं इस सवाल को संशोधित करने के लिए तैयार हूं कि जो कुछ भी आदेश सबसे अधिक समझ में आता है। पढ़ें, लो, और पास सभी 4 वर्ण थे, और फिटिंग महसूस हुई, लेकिन मैं सुझाव के लिए खुला हूं (उदाहरण के लिए, मैंने "पास" को "छोड़ने" के लिए बदल दिया है, क्योंकि मैंने पोस्ट को शीर्षक दिया है "इसे ले लो या छोड़ दो" ")।
लिविंगइनफॉर्मेशन

5

सी ++, $ 803,960

for (int iVal = 0; iVal < 10000; ++iVal)
{
    int val = game.read();
    if (val > maxVal &&
        val < 466.7f + 0.9352f * maxVal + 0.0275f * iVal)
    {
        maxVal = val;
        game.take();
    }
    else
    {
        game.pass();
    }
}

रिपोर्ट किया गया परिणाम 10,001 खेलों से मध्यमा है।


लगता है और जाँच, मैं इसे ले? या आपने स्थिरांक के लिए किसी प्रकार के इनपुट फ़ज़र का उपयोग किया है?
लिविंगइनफॉर्मेशन

मैंने स्थिरांक निर्धारित करने के लिए एक अनुकूलन एल्गोरिथ्म चलाया।
रेटो कोराडी

क्या आपको लगता है कि प्रत्येक बिंदु पर एक गतिशील गणना अधिक प्रभावी होगी, या आपको लगता है कि यह अधिकतम मूल्य है जो आप प्राप्त कर सकते हैं?
लिविंगइनफॉर्मेशन

मेरे पास यह मानने का कोई कारण नहीं है कि यह आदर्श रणनीति है। मुझे आशा है कि यह इन मापदंडों के साथ एक रैखिक कार्य के लिए अधिकतम है। मैं विभिन्न प्रकार के गैर-रैखिक शब्दों को अनुमति देने की कोशिश कर रहा हूं, लेकिन अभी तक कुछ भी बेहतर नहीं मिला है।
रेटो कोराडी

1
मैं इस बात की पुष्टि कर सकता हूं कि इसका अनुकरण करने से $ 800,000 से अधिक का सूचित स्कोर प्राप्त होता है।
orlp

3

सी ++, ~ $ 815,000

रेटो कोराडी के समाधान के आधार पर, लेकिन 100 से अधिक (वैध) लिफाफे छोड़ते समय एक अधिक परिष्कृत एल्गोरिदम पर स्विच करता है, यादृच्छिक क्रमपरिवर्तन को फेरबदल करता है और उनमें से सबसे भारी वृद्धि की गणना करता है। यह लिफाफा लेने और न लेने के परिणामों की तुलना करेगा, और लालच से सबसे अच्छा विकल्प का चयन करेगा।

#include <algorithm>
#include <iostream>
#include <vector>
#include <set>


void setmax(std::vector<int>& h, int i, int v) {
    while (i < h.size()) { h[i] = std::max(v, h[i]); i |= i + 1; }
}

int getmax(std::vector<int>& h, int n) {
    int m = 0;
    while (n > 0) { m = std::max(m, h[n-1]); n &= n - 1; }
    return m;
}

int his(const std::vector<int>& l, const std::vector<int>& rank) {
    std::vector<int> h(l.size());
    for (int i = 0; i < l.size(); ++i) {
        int r = rank[i];
        setmax(h, r, l[i] + getmax(h, r));
    }

    return getmax(h, l.size());
}

template<class RNG>
void shuffle(std::vector<int>& l, std::vector<int>& rank, RNG& rng) {
    for (int i = l.size() - 1; i > 0; --i) {
        int j = std::uniform_int_distribution<int>(0, i)(rng);
        std::swap(l[i], l[j]);
        std::swap(rank[i], rank[j]);
    }
}

std::random_device rnd;
std::mt19937_64 rng(rnd());

struct Algo {
    Algo(int N) {
        for (int i = 1; i < N + 1; ++i) left.insert(i);
        ival = maxval = 0;
    }

    static double get_p(int n) { return 1.2 / std::sqrt(8 + n) + 0.71; }

    bool should_take(int val) {
        ival++;
        auto it = left.find(val);
        if (it == left.end()) return false;

        if (left.size() > 100) {
            if (val > maxval && val < 466.7f + 0.9352f * maxval + 0.0275f * (ival - 1)) {
                maxval = val;
                left.erase(left.begin(), std::next(it));
                return true;
            }

            left.erase(it);
            return false;
        }

        take.assign(std::next(it), left.end());
        no_take.assign(left.begin(), it);
        no_take.insert(no_take.end(), std::next(it), left.end());
        take_rank.resize(take.size());
        no_take_rank.resize(no_take.size());
        for (int i = 0; i < take.size(); ++i) take_rank[i] = i;
        for (int i = 0; i < no_take.size(); ++i) no_take_rank[i] = i;

        double take_score, no_take_score;
        take_score = no_take_score = 0;
        for (int i = 0; i < 1000; ++i) {
            shuffle(take, take_rank, rng);
            shuffle(no_take, no_take_rank, rng);
            take_score += val + his(take, take_rank) * get_p(take.size());
            no_take_score += his(no_take, no_take_rank) * get_p(no_take.size());
        }

        if (take_score > no_take_score) {
            left.erase(left.begin(), std::next(it));
            return true;
        }

        left.erase(it);
        return false;
    }

    std::set<int> left;
    int ival, maxval;
    std::vector<int> take, no_take, take_rank, no_take_rank;
};


struct Game {
    Game(int N) : score_(0), max_taken(0) {
        for (int i = 1; i < N + 1; ++i) envelopes.push_back(i);
        std::shuffle(envelopes.begin(), envelopes.end(), rng);
    }

    int read() { return envelopes.back(); }
    bool done() { return envelopes.empty(); }
    int score() { return score_; }
    void pass() { envelopes.pop_back(); }

    void take() {
        if (read() > max_taken) {
            score_ += read();
            max_taken = read();
        }
        envelopes.pop_back();
    }

    int score_;
    int max_taken;
    std::vector<int> envelopes;
};


int main(int argc, char** argv) {
    std::vector<int> results;
    std::vector<int> max_results;
    int N = 10000;
    for (int i = 0; i < 1000; ++i) {
        std::cout << "Simulating game " << (i+1) << ".\n";
        Game game(N);
        Algo algo(N);

        while (!game.done()) {
            if (algo.should_take(game.read())) game.take();
            else game.pass();
        }
        results.push_back(game.score());
    }

    std::sort(results.begin(), results.end());
    std::cout << results[results.size()/2] << "\n";

    return 0;
}

दिलचस्प। इसने मेरे दिमाग को पार कर दिया था कि पिछले कुछ लिफाफों के लिए छोड़े गए मूल्यों को देखकर सुधार करना संभव है। मुझे लगता है कि आपने कटऑफ बिंदु के साथ खेला था जहां आप रणनीतियों को स्विच करते हैं? यदि आप पहले स्विच करते हैं तो क्या यह बहुत धीमा हो रहा है? या परिणाम वास्तव में खराब हो रहे हैं?
रेटो कोराडी

@RetoKoradi मैंने कटऑफ पॉइंट के साथ खेला था, और पहले कटऑफ दोनों बहुत धीमी और बदतर थी। बहुत ईमानदारी से आश्चर्य की बात नहीं, 100 लिफाफे में हम पहले से ही एक संभव 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000. से बाहर एक मात्र 1000 क्रमपरिवर्तन नमूने रहे हैं
orlp

3

जावा, $ 806,899

यह 2501 राउंड के ट्रायल से है। मैं अभी भी इसे अनुकूलित करने पर काम कर रहा हूं। मैंने दो कक्षाएं, एक आवरण और एक खिलाड़ी लिखा। रैपर खिलाड़ी को लिफाफे की संख्या (वास्तविक चीज़ के लिए हमेशा 10000) के takeQसाथ इंस्टेंट करता है, और फिर शीर्ष लिफाफे के मूल्य के साथ विधि को कॉल करता है । खिलाड़ी तब वापस लौटता है trueजब वे इसे लेते हैं, falseअगर वे इसे पास करते हैं।

खिलाड़ी

import java.lang.Math;

public class Player {
  public int[] V;

  public Player(int s) {
    V = new int[s];
    for (int i = 0; i < V.length; i++) {
      V[i] = i + 1;
    }
    // System.out.println();
  }

  public boolean takeQ(int x) {

    // System.out.println("look " + x);

    // http://www.programmingsimplified.com/java/source-code/java-program-for-binary-search
    int first = 0;
    int last = V.length - 1;
    int middle = (first + last) / 2;
    int search = x;

    while (first <= last) {
      if (V[middle] < search)
        first = middle + 1;
      else if (V[middle] == search)
        break;
      else
        last = middle - 1;

      middle = (first + last) / 2;
    }

    int i = middle;

    if (first > last) {
      // System.out.println(" PASS");
      return false; // value not found, so the envelope must not be in the list
                    // of acceptable ones
    }

    int[] newVp = new int[V.length - 1];
    for (int j = 0; j < i; j++) {
      newVp[j] = V[j];
    }
    for (int j = i + 1; j < V.length; j++) {
      newVp[j - 1] = V[j];
    }
    double pass = calcVal(newVp);
    int[] newVt = new int[V.length - i - 1];
    for (int j = i + 1; j < V.length; j++) {
      newVt[j - i - 1] = V[j];
    }
    double take = V[i] + calcVal(newVt);
    // System.out.println(" take " + take);
    // System.out.println(" pass " + pass);

    if (take > pass) {
      V = newVt;
      // System.out.println(" TAKE");
      return true;
    } else {
      V = newVp;
      // System.out.println(" PASS");
      return false;
    }
  }

  public double calcVal(int[] list) {
    double total = 0;
    for (int i : list) {
      total += i;
    }
    double ent = 0;
    for (int i : list) {
      if (i > 0) {
        ent -= i / total * Math.log(i / total);
      }
    }
    // System.out.println(" total " + total);
    // System.out.println(" entro " + Math.exp(ent));
    // System.out.println(" count " + list.length);
    return total * (Math.pow(Math.exp(ent), -0.5) * 4.0 / 3);
  }
}

आवरण

import java.lang.Math;
import java.util.Random;
import java.util.ArrayList;
import java.util.Collections;

public class Controller {
  public static void main(String[] args) {
    int size = 10000;
    int rounds = 2501;
    ArrayList<Integer> results = new ArrayList<Integer>();
    int[] envelopes = new int[size];
    for (int i = 0; i < envelopes.length; i++) {
      envelopes[i] = i + 1;
    }
    for (int round = 0; round < rounds; round++) {
      shuffleArray(envelopes);

      Player p = new Player(size);
      int cutoff = 0;
      int winnings = 0;
      for (int i = 0; i < envelopes.length; i++) {
        boolean take = p.takeQ(envelopes[i]);
        if (take && envelopes[i] >= cutoff) {
          winnings += envelopes[i];
          cutoff = envelopes[i];
        }
      }
      results.add(winnings);
    }
    Collections.sort(results);
    System.out.println(
        rounds + " rounds, median is " + results.get(results.size() / 2));
  }

  // stol... I mean borrowed from
  // http://stackoverflow.com/questions/1519736/random-shuffling-of-an-array
  static Random rnd = new Random();

  static void shuffleArray(int[] ar) {
    for (int i = ar.length - 1; i > 0; i--) {
      int index = rnd.nextInt(i + 1);
      // Simple swap
      int a = ar[index];
      ar[index] = ar[i];
      ar[i] = a;
    }
  }
}

मैं अनुकूलन खत्म करने के बाद एक और विस्तृत विवरण जल्द ही आ रहा हूं।

मुख्य विचार लिफाफे के एक सेट से खेल खेलने से इनाम का अनुमान लगाने में सक्षम होना है। यदि लिफाफे का वर्तमान सेट {2,4,5,7,8,9} है, और शीर्ष लिफाफा 5 है, तो दो विकल्प हैं:

  • 5 लें और {7,8,9} वाला गेम खेलें
  • 5 पास करें और {2,4,7,8,9} का गेम खेलें

यदि हम {7,8,9} के अपेक्षित इनाम की गणना करते हैं और इसे {2,4,7,8,9} के अपेक्षित इनाम से तुलना करते हैं, तो हम बता पाएंगे कि क्या 5 लेने के लायक है।

अब प्रश्न यह है कि {2,4,7,8,9} जैसे लिफाफे का एक सेट दिया गया है, अपेक्षित मूल्य क्या है? मैंने पाया कि अपेक्षित मूल्य सेट में कुल राशि के आनुपातिक लगता है, लेकिन लिफाफे की संख्या के वर्गमूल के आनुपातिक रूप से आनुपातिक है कि धन को विभाजित किया गया है। यह "पूरी तरह से" कई छोटे गेम खेलने से आया था जिसमें सभी लिफाफे लगभग समान मूल्य के होते हैं।

अगली समस्या यह है कि " लिफाफे की प्रभावी संख्या " कैसे निर्धारित की जाए । सभी मामलों में, लिफाफे की संख्या को ठीक से जाना जाता है, जो आपने देखा और किया है। {234,235,236} की तरह कुछ निश्चित रूप से तीन लिफाफे हैं, {231,232,233,234,235} निश्चित रूप से 5 है, लेकिन {1,2,234,235,236} को वास्तव में 3 के रूप में गिनना चाहिए और 5 नहीं, क्योंकि 1 और 2 लगभग बेकार हैं, और आप 234 पर कभी भी पास नहीं होंगे। आप बाद में 1 या 2 चुन सकते हैं। मुझे लिफाफे की प्रभावी संख्या निर्धारित करने के लिए शैनन एन्ट्रापी का उपयोग करने का विचार था।

मैंने अपनी गणना को उन स्थितियों पर लक्षित किया जहां लिफाफे के मूल्यों को कुछ अंतराल पर समान रूप से वितरित किया जाता है, जो कि खेल के दौरान होता है। अगर मैं {2,4,7,8,9} लेता हूं और इसे संभाव्यता वितरण के रूप में मानता हूं, तो इसकी एंट्री 1.50242 है। फिर मैं exp()4.49254 प्रभावी लिफाफे के रूप में प्राप्त करने के लिए करता हूं।

{2,4,7,8,9} से अनुमानित इनाम है 30 * 4.4925^-0.5 * 4/3 = 18.87

सटीक संख्या है 18.1167

यह एक सटीक अनुमान नहीं है, लेकिन मैं वास्तव में गर्व महसूस कर रहा हूं कि जब लिफाफे समान रूप से एक अंतराल पर वितरित किए जाते हैं तो यह डेटा को कितनी अच्छी तरह फिट करता है। मुझे सही गुणक का यकीन नहीं है (मैं अभी के लिए 4/3 का उपयोग कर रहा हूं) लेकिन यहां गुणक को छोड़कर एक डेटा तालिका है।

Set of Envelopes                    Total * (e^entropy)^-0.5      Actual Score

{1,2,3,4,5,6,7,8,9,10}              18.759                        25.473
{2,3,4,5,6,7,8,9,10,11}             21.657                        29.279
{3,4,5,6,7,8,9,10,11,12}            24.648                        33.125
{4,5,6,7,8,9,10,11,12,13}           27.687                        37.002
{5,6,7,8,9,10,11,12,13,14}          30.757                        40.945
{6,7,8,9,10,11,12,13,14,15}         33.846                        44.900
{7,8,9,10,11,12,13,14,15,16}        36.949                        48.871
{8,9,10,11,12,13,14,15,16,17}       40.062                        52.857
{9,10,11,12,13,14,15,16,17,18}      43.183                        56.848
{10,11,12,13,14,15,16,17,18,19}     46.311                        60.857

अपेक्षित और वास्तविक के बीच रैखिक प्रतिगमन 0.999994 के आर ^ 2 मूल्य देता है ।

इस उत्तर को सुधारने के लिए मेरा अगला कदम अनुमान में सुधार करना है जब लिफाफे की संख्या छोटी होने लगती है, जो तब होता है जब लिफाफे लगभग समान रूप से वितरित नहीं होते हैं और जब समस्या दानेदार होने लगती है।


संपादित करें: यदि इसे बिटकॉइन के योग्य समझा जाता है, तो मुझे सिर्फ एक पता मिला है 1PZ65cXxUEEcGwd7E8i7g6qmvLDGqZ5JWg। धन्यवाद! (यह यहाँ से था जब चुनौती लेखक पुरस्कार सौंप रहा था।)


संयोग से आपने 20k satoshi को 805,479 पर भेज दिया। संदर्भ के लिए, राशि को आपका स्कोर माना जाता था । मेरी गलती का आनंद लें :)
LivingInformation

क्या आप अधिक राउंड के साथ नंबर चला रहे होंगे? जो मैं देख रहा हूं, उसके आधार पर, बहुत भिन्नता है, और एक स्थिर माध्य प्राप्त करने के लिए 500 पर्याप्त नहीं है। अगर मैं केवल 500 राउंड चलाऊं तो मेरा स्कोर आपके बहुत करीब है, लेकिन यह सब इस बात पर निर्भर करता है कि यादृच्छिक संख्या कैसे घटती है। यदि मैंने एक चर बीज का उपयोग किया, और कुछ बार 500 रन किए, तो मैं शायद एक उच्च स्कोर प्राप्त कर सकता हूं।
रेटो कोराडी

@RetoKoradi मैं निश्चित रूप से अधिक राउंड करने जा रहा हूं।
PhiNotPi
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.