এটি নিন বা ছেড়ে দিন: কম্পিউটারের জন্য একটি গেম শো


28

প্রসঙ্গ:

একজন বিশিষ্ট বিলিয়নিয়ার বিশ্বের সেরা এবং উজ্জ্বল প্রোগ্রামারদের আকর্ষণ করার জন্য একটি গেম শো তৈরি করেছে। সোমবার মধ্যরাতের স্ট্রোকের সময়, তিনি আবেদনকারীদের পুল থেকে একজনকে সপ্তাহের প্রতিযোগী হতে বেছে নেন এবং তাদের একটি খেলা সরবরাহ করেন। আপনি এই সপ্তাহের ভাগ্যবান প্রতিযোগী!

এই সপ্তাহের খেলা:

হোস্ট আপনাকে 10,000 ডিজিটাল খামের স্ট্যাকের এপিআই অ্যাক্সেস সরবরাহ করে। এই খামগুলি এলোমেলোভাবে বাছাই করা হয় এবং এগুলির মধ্যে ডলারের মূল্য $ 1 এবং 10,000 ডলারের মধ্যে থাকে (কোনও দুটি খামে একই ডলারের মূল্য থাকে না)।

আপনার কাছে আপনার কাছে 3 টি কমান্ড রয়েছে:

  1. পড়ুন (): স্ট্যাকের শীর্ষে খামে ডলারের চিত্রটি পড়ুন।

  2. নিন (): আপনার গেম শো ওয়ালেটে খামে ডলারের চিত্র যোগ করুন এবং খামটিকে স্ট্যাকের বাইরে রেখে দিন।

  3. পাস (): স্ট্যাকের শীর্ষে খামটি পপ করুন।

নিয়ম:

  1. আপনি যদি একটি খামে পাস () ব্যবহার করেন তবে এর মধ্যে থাকা অর্থ চিরতরে নষ্ট হয়ে যাবে।

  2. আপনি যদি সেই জায়গা থেকে $ এক্সযুক্ত খামে টেক () ব্যবহার করেন তবে আপনি কখনই <$ এক্সযুক্ত খামে টেক () ব্যবহার করতে পারবেন না। এই খামগুলির মধ্যে একটিতে () নিন আপনার মানিব্যাগে $ 0 যুক্ত হবে।

একটি অ্যালগরিদম লিখুন যা সর্বাধিক অর্থের সাহায্যে গেমটি শেষ করে।

আপনি যদি পাইথনে কোনও সমাধান লিখছেন তবে @ মাল্টেসেনের সৌজন্যে অ্যালগরিদমগুলি পরীক্ষা করতে এই নিয়ামকটি নির্দ্বিধায় ব্যবহার করুন: https://gist.github.com/Maltysen/5a4a33691cd603e9aeca

আপনি যদি নিয়ামক ব্যবহার করেন তবে আপনি গ্লোবালগুলি অ্যাক্সেস করতে পারবেন না, আপনি কেবলমাত্র 3 সরবরাহিত এপিআই কমান্ড এবং স্থানীয় স্কোপযুক্ত ভেরিয়েবলগুলি ব্যবহার করতে পারেন। (@ বেটা ক্ষয়)

নোটস: এই ক্ষেত্রে "সর্বাধিক" এর অর্থ এন> 50 রান করার পরে আপনার মানিব্যাগের মাঝারি মান। আমি প্রত্যাশা করি, যদিও আমি ভুল প্রমাণিত হতে পছন্দ করব, যে প্রদত্ত অ্যালগরিদমের জন্য মধ্যমানের মান N বাড়ানোর সাথে সাথে অনন্ততায় রূপান্তরিত হবে। পরিবর্তে গড় সর্বাধিকতর চেষ্টা করার জন্য নির্দ্বিধায়, তবে আমার অনুভূতি আছে যে মাঝারিটির চেয়ে ছোট এন দ্বারা গড়টি ফেলে দেওয়ার সম্ভাবনা বেশি।

সম্পাদনা করুন: সহজ প্রক্রিয়াজাতকরণের জন্য খামের সংখ্যা 10 কে পরিবর্তন করে টেক () কে আরও স্পষ্ট করে তুলেছে।

সম্পাদনা 2: এই পোস্টের আলোকে পুরষ্কারের শর্তটি সরানো হয়েছে মেটা সম্পর্কিত ।

বর্তমান উচ্চ স্কোর:

PhiNotPi - 5 805,479

রেটো কোরাদি - 3 803,960

ডেনিস - 70 770,272 (সংশোধিত)

অ্যালেক্স এল। - 14 714,962 (সংশোধিত)


আমি এমনভাবে প্রয়োগ করেছি যাতে এটি কেবল মিথ্যা প্রত্যাবর্তন করে। যেহেতু আপনি এটি পড়তে পারেন সেখানে ব্যর্থ হওয়ার কারণে পুরো গেমটি ব্যর্থ করার আসল বিন্দু নেই ()
ওগানএম

4
যদি কেউ এটি ব্যবহার করতে চায় তবে আমি এখানে নিয়ন্ত্রক যা আমার অ্যালগরিদমগুলি পরীক্ষা করতে ব্যবহার করেছি: gist.github.com/Maltysen/5a4a33691cd603e9aeca
মালটিসেন

8
পিএস দুর্দান্ত প্রশ্ন এবং প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগত :)
ট্রাইকোপ্লেক্সে আপনাকে স্বাগতম

3
@ মালটিসেন আমি আপনার নিয়ামকটিকে ওপিতে রেখেছি, অবদানের জন্য ধন্যবাদ!
লিভিং ইনফরমেশন

1
আমি বিটকয়েন পুরষ্কারের একটি সুস্পষ্ট নিয়ম খুঁজে পাইনি, তবে বাস্তব বিশ্ব পুরষ্কারের জন্য কিছু মেটা আলোচনা রয়েছে যা লোকেরা অবদান রাখতে পারে।
ট্রাইকোপলাক্স

উত্তর:


9

সিজেম, $ 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

অভিগমন

প্রতিটি খামের জন্য, আমরা নিম্নলিখিতটি করি:

  • খামটি গ্রহণ করে অনিবার্যভাবে যে পরিমাণ অর্থ নষ্ট হবে তার অনুমান করুন।

    তাহলে আর সামগ্রী এবং এম সর্বোচ্চ যে গ্রহণ করা হয়েছে, পরিমাণ হিসাবে অনুমান করা যেতে পারে আর (আর-1) / 2 - এম (এম +1) / 2 , যা টাকা বিষয়বস্তু সঙ্গে সব খামে দেয় এক্স মধ্যে অন্তর (এম, আর) থাকে

    যদি কোনও খামে এখনও পাস না করা হয় তবে অনুমানটি নিখুঁত হবে।

  • খামটি পাস করার মাধ্যমে অনিবার্যভাবে যে পরিমাণ অর্থ নষ্ট হবে তা গণনা করুন।

    এটি কেবল খামে থাকা অর্থ is

  • উভয়ের ভাগফল 110 + 0.016E এর চেয়ে কম কিনা তা পরীক্ষা করুন , যেখানে E বাকী খামের সংখ্যা (এখন আর নেওয়া যাবে না এমন খামগুলি গণনা করা হচ্ছে না)।

    যদি তাই হয়, নিতে। অন্যথায়, পাস।


5
কারণ গল্ফিং ভাষা ব্যবহার করা যেকোন উপায়ে সহায়তা করে। ; পি +1 অ্যালগোয়ের জন্য।
মাল্টেসেন

2
আমি পাইথন ক্লোন ব্যবহার করে আপনার ফলাফলগুলি প্রতিলিপি করতে পারি না: gist.github.com/orlp/f9b949d60c766430fe9c । আপনি প্রায় 50,000 ডলার স্কোর। এটি প্রশস্ততার একটি অর্ডার অফ।
orlp

1
@ লিভিংইনফর্মেশন ট্রায়াল এবং ত্রুটি। আমি বর্তমানে অনুমানের পরিবর্তে সঠিক পরিমাণটি ব্যবহার করার দিকে লক্ষ্য করছি তবে ফলাফল কোডটি খুব ধীর।
ডেনিস

2
এই উত্তরটির চেয়ে আমার চেয়ে আরও বেশি উন্নতি প্রয়োজন! এটি আরও চালাক, স্কোরগুলি আরও বেশি, এবং এটিও গল্ফড!
অ্যালেক্স এল

1
@ লাইভিং ইনফরমেশন এটি আমার ঠিকানা: 17uLHRfdD5JZ2QjSqPGQ1B12LXX4CgLGuV
ডেনিস

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 নিয়ে দৌড়ে এবং 14 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)

বিটকয়েন ঠিকানা: 1CBzYPCFFBW1FX9sBTmNYUJyMxMcmL4BZ7

বাহ ওপি বিতরণ! ধন্যবাদ @ লাইভিং ইনফর্মেশন!


1
নিয়ামকটি আমার নয়, মালটিসেনের।
অরপাল

2
নিশ্চিত করেছে। আমি সবেমাত্র একটি নিয়ামক সেটআপ করেছি এবং আপনার সমাধানের জন্য খুব অনুরূপ সংখ্যা পেয়েছি। কড়া কথায় বলতে গেলে, আমি মনে করি আপনাকে max_takenনিজের কোডের মান বজায় রাখতে হবে, কারণ এটি অফিশিয়াল গেম এপিআইয়ের অংশ নয়। তবে তা করা তুচ্ছ।
রেটো কোরাডি

1
হ্যাঁ, ম্যাক্স_টেকেন @ মাল্টেসেনের নিয়ামকটিতে রয়েছে। যদি এটি দরকারী হয় তবে আমি একটি ব্লকে পুরো সমাধান (কন্ট্রোলার + অ্যালগোরিদম) পোস্ট করতে পারি।
অ্যালেক্স এল

এটি আসলে কোনও বড় বিষয় নয়। কিন্তু আমি মনে করি পরিষ্কার পদ্ধতির শুধুমাত্র ব্যবহার করতে হবে read(), take()এবং pass()পোস্ট কোডে পদ্ধতি, সেই থেকে প্রশ্নে সংজ্ঞা উপর ভিত্তি করে "আপনার নিষ্পত্তি 3 কমান্ড" হয়।
রেটো কোরাদি

@ রেটো আমি যে কোনও আদেশই সর্বাধিক অর্থবোধ করে প্রশ্নটি পুনর্বিবেচনা করতে প্রস্তুত। পড়ুন, নিন এবং পাসগুলি চারটি অক্ষর ছিল এবং উপযুক্ত মনে হয়েছিল, তবে আমি পরামর্শের জন্য উন্মুক্ত (উদাহরণস্বরূপ, আমি "পাস" কে "ছেড়ে" বদলানোর বিষয়টি বিবেচনা করেছি, কারণ আমি পোস্টটি শিরোনাম করেছি "এটি গ্রহণ করুন বা ছেড়ে দিন) ")।
লিভিংইনফরমেশন

5

সি ++, 3 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 গেমের মধ্যমা।


অনুমান করুন এবং যাচাই করুন, আমি কি এটি নিই? বা আপনি ধ্রুবকগুলির জন্য কোনও ধরণের ইনপুট ফઝર ব্যবহার করেছেন?
লিভিংইনফরমেশন

ধ্রুবকগুলি নির্ধারণ করতে আমি একটি অপ্টিমাইজেশন অ্যালগরিদম চালিয়েছি।
রেটো কোরাডি 0

আপনি কি মনে করেন যে প্রতিটি পয়েন্টে একটি গতিশীল গণনা আরও কার্যকর হবে, বা আপনি কি মনে করেন যে এটি আপনি যে সর্বোচ্চ মূল্য অর্জন করতে পারবেন তার কাছে পৌঁছেছে?
লিভিংইনফরমেশন

এটি আদর্শ কৌশল বলে আমার বিশ্বাস করার কোনও কারণ নেই have আমি আশা করি এই পরামিতিগুলির সাথে লিনিয়ার ফাংশনের পক্ষে এটি সর্বাধিক। আমি বিভিন্ন ধরণের অ-রৈখিক শর্তাদি মঞ্জুরি দেওয়ার চেষ্টা করছি, তবে এখনও পর্যন্ত এর চেয়ে ভাল কিছু পাওয়া যায় নি।
রেটো কোরাডি

1
আমি নিশ্চিত করতে পারি যে এটি সিমুলেট করা রিপোর্ট করা স্কোরটিকে $ 800,000 এর থেকে কিছুটা বেশি দেয়।
orlp 2'15

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;
}

মজাদার. এটি আমার মনকে অতিক্রম করেছিল যে শেষ কয়েকটি খামের জন্য রেখে যাওয়া মানগুলি দেখে উন্নত করা উচিত। আমি বুঝতে পারি আপনি কাট অফ পয়েন্টের সাথে খেলেন যেখানে আপনি কৌশলগুলি স্যুইচ করেন? আপনি যদি আগে স্যুইচ করেন তবে এটি কি খুব ধীর হয়ে যাচ্ছে? নাকি ফলাফল আসলে খারাপ হচ্ছে?
রেটো কোরাডি

@ রিটোকোরাদি আমি কাটফয়েন্ট পয়েন্ট নিয়ে খেলি, এবং এর আগের কাটঅফ উভয়ই খুব ধীর এবং খারাপ হয়ে যায়। খুব সত্যি বিস্ময়কর না, 100 খামে আমরা ইতিমধ্যে একটি সম্ভাব্য 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000. বাইরে একটি নিছক 1000 বিনিময়ের স্যাম্পলিং করছি
orlp

3

জাভা, 6 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 is হয় এবং শীর্ষ খামটি 5 হয় তবে দুটি সম্ভাবনা রয়েছে:

  • 5 নিন এবং একটি গেম খেলুন {7,8,9}
  • 5 পাস করুন এবং {2,4,7,8,9} একটি খেলা খেলুন

আমরা যদি {7,8,9 of এর প্রত্যাশিত পুরষ্কার গণনা করি এবং এটি 2,4,7,8,9 of এর প্রত্যাশিত পুরষ্কারের সাথে তুলনা করি, তবে 5 টি গ্রহণযোগ্য কিনা তা আমরা জানাতে সক্ষম হব।

এখন প্রশ্ন হল, en 2,4,7,8,9 এর মতো খামের সেট দেওয়া the প্রত্যাশিত মানটি কী? আমি খুঁজে পেয়েছিলাম প্রত্যাশিত মানটি সেটের মোট অর্থের সমানুপাতিক বলে মনে হচ্ছে, তবে যে পরিমাণ খামে টাকা বিভক্ত হয়েছে তার বিপরীতে আনুপাতিক সমানুপাতিক। এটি বেশ কয়েকটি ছোট গেম খেলে "নিখুঁতভাবে" এসেছে যার মধ্যে সমস্ত খামের প্রায় অভিন্ন মূল্য রয়েছে।

পরবর্তী সমস্যাটি কীভাবে " খামের কার্যকর সংখ্যা " নির্ধারণ করবেন । সব ক্ষেত্রেই, আপনি কী দেখেছেন এবং কী করেছেন সে সম্পর্কে নজর রেখে খামের সংখ্যাটি ঠিক জানা যায়। 4 234,235,236 Some এর মতো কিছু অবশ্যই তিনটি খাম, {231,232,233,234,235 definitely অবশ্যই 5, তবে 2 1,2,234,235,236 really অবশ্যই 3 হিসাবে গণনা করা উচিত এবং 5 টি খাম নয় কারণ 1 এবং 2 প্রায় মূল্যহীন, এবং আপনি কখনও 234 এ পাস করবেন না আপনি পরে 1 বা 2 বাছাই করতে পারেন আমার খামের কার্যকর সংখ্যা নির্ধারণের জন্য শ্যানন এনট্রপি ব্যবহার করার ধারণা ছিল।

আমি আমার গণনাগুলিকে এমন পরিস্থিতিতে লক্ষ্য করেছি যেখানে খামের মানগুলি কিছুটা বিরতিতে সমানভাবে বিতরণ করা হয়, যা খেলার সময় ঘটে। যদি আমি {2,4,7,8,9 take গ্রহণ করি এবং এটির সম্ভাবনা বন্টন হিসাবে বিবেচনা করি তবে এর এনট্রপিটি 1.50242। তারপরে আমি exp()খামের কার্যকর সংখ্যা হিসাবে 4.49254 পেতে পারি ।

{2,4,7,8,9} থেকে আনুমানিক পুরষ্কার 30 * 4.4925^-0.5 * 4/3 = 18.87

সঠিক সংখ্যাটি হ'ল 18.1167

এটি কোনও সঠিক অনুমান নয়, তবে খামগুলি যখন অন্তরালে সমানভাবে বিতরণ করা হয় তখন ডেটাটি ঠিক কতটা ফিট করে তা নিয়ে আমি আসলেই গর্বিত। আমি সঠিক গুণকটির বিষয়ে নিশ্চিত নই (আমি আপাতত 4/3 ব্যবহার করছি) তবে এখানে গুণকটি বাদ দিয়ে একটি ডাটা টেবিল দেওয়া হয়েছে is

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

লিনিয়ার রিগ্রেশন প্রত্যাশিত এবং প্রকৃত মধ্যে একটি দেয় আর ^ 2 0.999994 মান

এই উত্তরটির উন্নতি করার জন্য আমার পরবর্তী পদক্ষেপটি যখন এনভেলাপগুলির সংখ্যা কম পরিমাণে কমতে শুরু করে তখন অনুমানের উন্নতি করা হয়, যা হয় যখন খামগুলি প্রায় অভিন্নভাবে বিতরণ করা হয় না এবং যখন সমস্যাটি দানাদার হতে শুরু করে।


সম্পাদনা করুন: যদি এটি বিটকয়েনের যোগ্য হিসাবে বিবেচিত হয় তবে আমি ঠিক এখানে একটি ঠিকানা পেয়েছি 1PZ65cXxUEEcGwd7E8i7g6qmvLDGqZ5JWg। ধন্যবাদ! (চ্যালেঞ্জ লেখক যখন পুরষ্কার দিচ্ছিলেন তখন থেকেই এটি এখানে ছিল))


দুর্ঘটনাক্রমে আপনাকে 80k,479 এর উপরে 20k সাতোশি পাঠিয়েছে। রেফারেন্সের জন্য, পরিমাণ অনুমিত ছিল আপনার স্কোর । আমার ভুলটি উপভোগ করুন :)
লিভিং ইনফরমেশন

আপনি আরও রাউন্ড সহ সংখ্যা চলমান হবে? আমি যা দেখছি তার ভিত্তিতে, বেশ কিছুটা প্রকরণ রয়েছে এবং একটি স্থিতিশীল মিডিয়ান পাওয়ার জন্য 500 যথেষ্ট নয়। আমি মাত্র 500 রাউন্ড চালালে আমার স্কোরটি আপনার খুব কাছাকাছি, তবে এলোমেলো সংখ্যাগুলি কীভাবে পড়বে তার উপর নির্ভর করে এটি depends যদি আমি একটি পরিবর্তনশীল বীজ ব্যবহার করি এবং কয়েকবার 500 রান করি তবে আমি সম্ভবত উচ্চতর স্কোর পেতে পারি।
রেটো কোরাডি

@ রিটোকোরাদি আমি অবশ্যই আরও বেশি বৃত্তাকারে যাচ্ছি।
PhiNotPi
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.