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


20

पहेली की एक श्रृंखला में यह दूसरा है जिसे मैं हर सोमवार मध्यरात्रि पीएसटी में पोस्ट करूंगा। पहली पहेली यहाँ स्थित है ।

प्रसंग:

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

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

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

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

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

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

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

  4. ओरेकल (एम): स्टैक में अगले एम लिफाफे का माध्य मान लौटाता है, न कि वह जिसमें आप वर्तमान में पढ़ सकते हैं ()।

नियम:

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

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

  3. यदि आप टर्न ओ पर ओरेकल (एम) का उपयोग करते हैं, तो T + M के माध्यम से T + 1 को लिफाफा दिया जाएगा। Oracle () T + M के चालू होने तक अक्षम है।

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

यदि आप पाइथन में अपना एल्गोरिथ्म लिख रहे हैं, तो @Maltysen द्वारा प्रदान किए गए इस नियंत्रक का उपयोग करने के लिए स्वतंत्र महसूस करें: https://gist.github.com/livinginformation/70ae3f2a57ecba4387b5

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

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

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


वाह, मैं विश्वास नहीं कर सकता मैं देख रहा हूँ: O
बीटा Decay

@ बिट्टा की घड़ी की टिक टिक! :)
LivingInformation

रार का क्या मतलब है? आप पहले से पढ़े गए सभी लिफाफों की एक टिकिया बनाकर अपना खुद का मुफ्त आभूषण बना सकते हैं। मैं क्या गलत हो रहा हूँ?
लुइस मेंडो

1
@LuisMendo अपनी खुद की टैली के साथ, आप केवल सभी शेष मूल्यों का मतलब जान सकते हैं। ओरेकल के साथ, आप अगले Mमूल्यों का मतलब प्राप्त कर सकते हैं , जहां आपको चुनना है M
रेटो कोराडी

1
चूँकि आपकी पिछली चुनौती के सभी समाधान भी इस चुनौती के मान्य समाधान हैं, तो क्या हम उन्हें संक्षेप में प्रस्तुत करने पर विचार कर सकते हैं?
रेटो कोराडी

जवाबों:


9

ग्रूवी $ 713337 $ 817829 $ 818227

बूटस्ट्रैप कोड:

class Instance {
    List values = new ArrayList(1..10000); {
        Collections.shuffle(values)
    }
    int i = 0
    int value = 0
    int max = 0
    int nextOracle = 0

    def pass() {
        if (i >= 10000)
            throw new NoSuchElementException()
        i++
    }

    def take() {
        if (i >= 10000)
            throw new NoSuchElementException()
        int v = values[i]
        if (v > max) {
            max = v
            value += v
        }
        i++
    }

    double oracle(int m) {
        if (m <= 0 || i < nextOracle || i + m >= 10000)
            throw new NoSuchElementException()

        nextOracle = i + m
        values.subList(i + 1, i + m + 1).stream().reduce { l, r -> r+l }.get() / m
    }

    int read() {
        if (i >= 10000)
            throw new NoSuchElementException()
        values[i]
    }
}

कलन विधि

double square(double v) { v * v }
final double factor = Math.pow(1.5, 1.1)
int attempts = 5000
(1..attempts).stream().parallel().mapToLong {
    def puzzle = new Instance()

    int[] memory = 1..10000 // We will remember every envelope
    int memStart = 0

    while (memStart < 10000 - 3) {
        int value = puzzle.read()
        int i = Arrays.binarySearch(memory, memStart, 10000, value) - memStart
        if (i < 0) { // We can't use the money
            puzzle.pass()
            continue
        }
        if (i == 0) { // Of course we take the lowest
            puzzle.take()
            memStart++
            continue
        }
        int remaining = Arrays.stream(memory, i + 1 + memStart, 10000).sum() // Money we could win if taken
        int losing = Arrays.stream(memory, memStart, memStart + i).sum() // Money we cna't win if taken
        if (value > losing) { // If we pass, we lose money automatically
            puzzle.take()
            memStart += i + 1
        } else if ((losing - value * 16 / 7) * square(Math.log(i)) > remaining / factor) {
            System.arraycopy(memory, memStart, memory, ++memStart, i)
            puzzle.pass()
        } else {
            puzzle.take()
            memStart += i + 1
        }
    }

    // It's broken down to last three elements
    List values = Arrays.copyOfRange(memory, 10000 - 3, 10000)
    while (!values.contains(puzzle.read())) // Skip values we can't use
        puzzle.pass()
    int value1 = puzzle.read()
    int value2 = puzzle.oracle(1)
    if (value1 == values.max() && (
            values.contains(value2)
            ? (value1 * 2 < values.sum() && values.min() == value2)
            : (value1 < values.min() / 2 + (values - [value1]).max())
            )) {
        puzzle.pass()
    }

    // Finish it
    while (puzzle.i < puzzle.values.size()) {
        puzzle.take()
    }

    puzzle.value as Long
}.sum() / attempts // Sum runs and average

मैं संभावित मूल्यों के साथ शेष मूल्यों की तुलना करता हूं। यह स्क्रिप्ट तेज़ नहीं है (प्रति 1000x सिमुलेशन में 1-मिनट लगता है) ... लेकिन यह एक साथ सिमुलेशन प्रदर्शन करेगा।

मुझे पता नहीं है कि मेरा एल्गोरिथ्म क्यों काम करता है, लेकिन यह सिर्फ परीक्षण और त्रुटि थी: गणितीय संचालन को एक साथ करना और स्थिरांक में हेरफेर करना। मैंने इसे स्कोर के उतार-चढ़ाव को कम करने के प्रयास में, वर्तमान स्कोर के लिए 5000x चलाया, (यह इटियन + के आधार पर $ 4000 है)।

यहां तक ​​कि अंत में ओरेकल के बिना, यह अभी भी होना चाहिए (बमुश्किल) पूर्व पहेली के लिए @ ऑरलपी का समाधान


7

C # - $ 803.603 अब -> $ 804.760 (ओरेकल के साथ)

बूटस्ट्रैप कोड

public static class ShuffleExtension
{
    private static Random rng = new Random();  

    public static void Shuffle<T>(this IList<T> list)  
    {  
        int n = list.Count;
        while (n > 1) {  
            n--;  
            int k = rng.Next(n + 1);  
            T value = list[k];  
            list[k] = list[n];  
            list[n] = value;  
        }  
    }
}

public class Puzzle
{
    public List<int> Values = new List<int>(10000);

    public Puzzle()
    {
        for ( int i = 1; i <= 10000; i++ )
        {
            Values.Add(i);
        }
        Values.Shuffle();
    }

    public int i = 0;
    public int value = 0;
    public int max = 0;
    public int nextOracle = 0;

    public void Pass() {
        if ( i >= Values.Count )
            throw new IndexOutOfRangeException();
        i++;
    }

    public void Take() {
        if (i >= Values.Count )
            throw new IndexOutOfRangeException();
        int v = Values[i];
        if (v > max) {
            max = v;
            value += v;
        }
        i++;
    }

    public double oracle(int m) {
    if (m <= 0) { 
        throw new IndexOutOfRangeException();
    }
    if ( i < nextOracle ) {
        throw new IndexOutOfRangeException();
    }
    if ( i + 1 + m > Values.Count ) {
        throw new IndexOutOfRangeException();
    }

    nextOracle = i + m;
    var oracleValues = new List<int>();
    for ( int l = 0; l < m; l++ )
    {
        oracleValues.Add(Values[i + 1 + l]);
    }
    return oracleValues.Average (v => v);
}

    public int Read() {
        if (i >= Values.Count )
            throw new IndexOutOfRangeException();
        return Values[i];
    }
}

खेल कोड:

    void Main()
{
    var m = 0;
    for ( int l = 0; l < 1000; l++ )
    {
        var game = new Puzzle();
        var maxVal = 0;
        var lastOracle = 0;
        var lastOracleValue = 0.0m;
        var oracleValueForIOf = 0;

        for ( int i = 0; i < 10000; i++ )
        {
            var val = game.Read();
            var oracleStep = 1;
            var canUseOracle = (i - lastOracle >= oracleStep) && i + oracleStep + 1 <= 10000;
            if ( canUseOracle )
            {
                var oracle = game.oracle(oracleStep);
                lastOracle = i;
                lastOracleValue = (decimal)oracle;
                oracleValueForIOf = i + 1;
            }
            if ( TakeTheMoney(val, maxVal, oracleValueForIOf, lastOracleValue, i) )
            {
                maxVal = val;
                game.Take();
            }
            else
            {
                game.Pass();
            }
        }
        m += game.value;
    }
    ((int)(m / 1000)).Dump();
}

private bool TakeTheMoney(int val, int maxVal, int oracleValueForIOf, decimal lastOracleValue, int i)
{
    if ( val > maxVal )
    {
        if ( oracleValueForIOf != i + 1
            &&
            (val < 466.7m + (0.9352m * maxVal) + (0.0275m * i))
            )
        {
            return true;
        }

        if (oracleValueForIOf == i + 1)
        {
            if ( val < 466.7m + (0.9352m * maxVal) + (0.0275m * i) )
            {
                return true;
            }
            if ( lastOracleValue > 466.7m + (0.9352m * val) + (0.0275m * i + 1) )
            {
                if ( val < 466.7m + (0.9352m * maxVal) + (0.0275m * i + 1) )
                {
                    return true;
                }
            }
        }
    }
    return false;
}

श्रेय रेटो कोराडी ( /codegolf//a/54181/30910 ) का है

संपादित करें: Oracle का मूल उपयोग कार्यान्वित किया गया। यदि अगला ओरेकल वर्तमान लिफाफे का विस्तार करने के लिए ओरेकल इंडेक्स के सूचकांक का उपयोग करने के लिए सीमा से ऊपर है। यह अक्सर हिट नहीं करता है लेकिन यह एक सुधार है ;-)


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

कृपया नीचे जाना बंद करें :) नोट संख्या 2 को मेरे सबमिशन के बाद जोड़ा गया था। और जैसा कि यह अन्य समाधानों की तुलना में अधिक प्रभावी है - मैंने इसे यहां पोस्ट किया है। मौजूदा समाधान को हरा करने के लिए ओरेकल का उपयोग करने की आवश्यकता नहीं है।
स्टीफ़न स्किंकेल

@StephanSchinkel यदि आप वर्तमान स्कोर को बेहतर बनाने के लिए ओरेकल को शामिल करने का प्रबंधन करते हैं तो मेरा उत्थान होगा। यहां तक ​​कि सिर्फ $ 1 से।
डोरस

@BetaDecay ऐसा क्या है जो समुदाय द्वारा फिर से डूब गया है? मैं सिर्फ op से सवाल का पालन किया। एक बार फिर नोट नंबर 2 को मेरे जमा करने के बाद जोड़ा गया।
Stephan Schinkel

क्विज़ के भाग I से समाधान का उपयोग नहीं करने के लिए।
Stephan Schinkel

4

अजगर - $ 74112

केवल तभी लें, यदि वर्तमान मूल्य अगले मूल्य से कम है (यानी आप दोनों को ले सकते हैं)।

def algo():
  try:
    o=oracle(1)
  except ValueError:
    take()
  r=read()
  if r>o:
    passe()
  else:
    take()

अजगर - (अभी भी मतलब की गणना)

यह उत्तर गणना करने के लिए बहुत लंबा लगता है। यह लगभग $ 670.000 $ तक पहुँच जाता है । मुझे याद है कि मैंने देखा प्रत्येक लिफाफा। हर बार जब मुझे कोई निर्णय लेना होता है, तो मैं शेष लिफाफों की दो सूची तैयार करता हूं, जो कि मैं अपने बटुए में संभावित रूप से जोड़ सकता हूं यदि मैं वर्तमान लिफाफा लेता हूं या क्रमशः छोड़ता हूं।

मैंने कोड का अनुकूलन नहीं किया।

def algo_2():
  global max_taken, past
  weight=0.92 #Empirically chosen.
  r=read()
  if len(past)==0:
    past.append(r)
    passe()
    return
  if r<max_taken:
    past.append(r)
    take() #the same as passe
    return
  coming=[x for x in range(1,10001) if x not in past and x>max_taken and x!=r ]
  comingIfTake=[x for x in range(1,10001) if x not in past and x>r ]
  if sum(coming)*weight<=sum(comingIfTake)+r:
    past.append(r)
    take()
  else:
    past.append(r)
    passe()

और init_game इस तरह शुरू होता है:

def init_game():
    global stack, wallet, max_taken, oracle_turns, past
    past=[]

3
यदि आप अतीत, आने वाले और आने वाले क्षेत्रों का प्रतिनिधित्व करने के लिए सेट का उपयोग करते हैं, और चौराहों का उपयोग करते हैं, तो आपका कोड बहुत तेज़ होगा।
नाथन मेरिल

4

सी # - $ 780.176

जांचें कि क्या अगला मान सभी शेष मूल्यों के निचले 5% के भीतर है। जैसे-जैसे हम अंत तक पहुँचते हैं और अधिक आराम करें।

public class Taker
{
    private List<int> remaining;
    private Game game;

    public Taker(Game game)
    {
        this.game = game;
        remaining = Enumerable.Range(1, game.Size + 100).ToList();
    }

    int score = 0;

    public int PlayGame()
    {
        for (int i = 0; i < game.Size; i++)
        {
            if (game.Read() < game.Max ||
                game.Read() > selectThreshold() ||
                doOracle()
                )
            {
                remaining.Remove(game.Read());
                game.Pass();
                continue;
            }
            remaining = remaining.SkipWhile(j => j < game.Read()).ToList();
            score += game.Take();
        }
        return score;
    }

    private bool doOracle()
    {
        return game.Oracle(1) < game.Read() &&
            game.Oracle(1) > game.Max;
    }

    private int selectThreshold()
    {
        int selector = (int)(remaining.Count * 0.05);
        return remaining.ElementAt(selector);
    }
}

और मेरे खेल वर्ग, बहुत बदसूरत, खेल वर्ग भी मान्य नहीं है अगर ओरेकल की अनुमति है, लेकिन जब से मैं केवल ओरेकल (1) का उपयोग करता हूं जो एक समस्या नहीं होनी चाहिए।

public class Game
{
    private int[] list;
    private int position = 0;
    private int max = 0;
    public int Max { get { return max; } }
    public int Size { get { return list.Length; } }

    public Game(int[] list)
    {
        this.list = list;
    }

    public int Read()
    {
        return list[position];
    }

    public int Take()
    {
        if (list[position] < max)
        {
            position++;
            return 0;
        }
        max = list[position];
        return list[position++];
    }

    public void Pass()
    {
        position++;
    }

    public int Oracle(int M)
    {
        int next = position + 1;
        M = Math.Max(0, Math.Min(M, list.Length - next));
        return new ArraySegment<int>(list, next, M).Sum();
    }
}

4

जावा, $ 804,991

स्कोर 1001 राउंड से है। यह शायद इस जवाब और स्टीफन शिंकेल के बीच कॉल करने के लिए बहुत करीब है

यह पिछली चुनौती में मेरे जवाब पर आधारित है, जिसमें यह अदायगी का अनुमान लगाने के लिए उसी एंट्रोपी-आधारित गणना का उपयोग करता है। मुख्य अंतर यह है कि यह अब केवल जोड़े (1 और 2, फिर 3 और 4, इत्यादि) में लिफाफे लेता है और टेक-टेक, टेक-पास, पास-टेक आदि के संभावित संयोजनों को देखता है, यह भी गणना करता है। सटीक अनुमानित स्कोर जब वैध लिफाफे की संख्या वास्तव में छोटी है।

"रैपर" जो मैंने लिखा है वह वास्तव में एक सच्चा आवरण नहीं है, यह सिर्फ Oracle(1)हर दूसरे दौर में एक फ़ंक्शन को कॉल करने के बजाय जोड़े में लिफाफे देता है ।

कुल मिलाकर, मैं कहूंगा कि बढ़ी हुई जटिलता के बावजूद, यह बॉट वास्तव में मेरे पिछले वाले से बेहतर नहीं है।

खिलाड़ी

import java.lang.Math;
public class Player2
{
    public int[] V;

    public Player2(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, int y)
    {
        //System.out.println("Look: " + x + " " + y);
        boolean [] move = new boolean[]{false,false};
        double max = 0;
        double val = 0;
        int[] nextV = V;

        ////System.out.println("look " + x);
        int i = find(V,x);
        if(i >= 0)  //if found
        {
            //try taking first envelope
            int[] newVt = takeSlice(V,i);
            //System.out.println("  T: " + ats(newVt));
            int j = find(newVt,y);
            if(j >= 0)
            {
                //try taking first and second
                int[] newVtt = takeSlice(newVt,j);
                val = x + y + calcVal(newVtt);
                //System.out.println("  TT: " + ats(newVtt) + " " + val);
                if(val > max)
                {
                    move = new boolean[]{true,true};
                    max = val;
                    nextV = newVtt;
                }
            }
            //try taking first and passing second
            int[] newVtp = passSlice(newVt,j);

            val = x + calcVal(newVtp);
            //System.out.println("  TP: " + ats(newVtp) + " " + val);
            if(val > max)
            {
                move = new boolean[]{true,false};
                max = val;
                nextV = newVtp;
            }
        }
        int[] newVp = passSlice(V,i);
        //System.out.println("  V: " + ats(V));
        //System.out.println("  P: " + ats(newVp));
        int j = find(newVp,y);
        if(j >= 0)
        {
            //try passing first and taking second
            int[] newVpt = takeSlice(newVp,j);
            val = y + calcVal(newVpt);
            //System.out.println("  PT: " + ats(newVpt) + " " + val);
            if(val > max)
            {
                move = new boolean[]{false,true};
                max = val;
                nextV = newVpt;
            }
        }
        //try taking first and passing second
        int[] newVpp = passSlice(newVp,j);

        val = calcVal(newVpp);
        //System.out.println("  PP: " + ats(newVpp) + " " + val);
        if(val > max)
        {
            move = new boolean[]{false,false};
            max = val;
            nextV = newVpp;
        }
        V = nextV;
        //System.out.println("  NEW: " + ats(V));
        return move;
    }

    public static String ats(int [] a)
    {
        String s = "";
        for(int i = 0; i < a.length; i++)
        {
            s += a[i] + ",";
        }
        return s;
    }

    public static int[] takeSlice (int[] list, int loc)
    {
        int [] newlist = new int[list.length - loc - 1];
        for(int j = loc + 1; j < list.length; j++)
        {
            newlist[j - loc - 1] = list[j];
        }
        return newlist;
    }

    public static int[] passSlice (int[] list, int loc)
    {
        int [] newlist = list;
        if(loc >= 0)
        {
            newlist = new int[list.length-1];
            for(int k = 0; k < loc; k++)
            {
                newlist[k] = list[k];
            }
            for(int k = loc + 1; k < list.length; k++)
            {
                newlist[k-1] = list[k];
            }
        }
        return newlist;
    }

    public static double calcVal(int [] list)
    {
        if(list.length < 8)
        {
            for(int i : list)
            {
                ////System.out.print(i + ",");
            }

                ////System.out.println();
            return computeMean(list);

        }
        return smoothEstimate(list);
    }

    public static double computeMean(int[] V)
    {
        if(V.length == 1)
        {
            return V[0];
        }
        else if(V.length > 1)
        {
            double[] Es = new double[V.length];
            for(int i = 0; i < V.length; i++)
            {
                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 = computeMean(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] + computeMean(newVt);
                if(take > pass)
                {
                    Es[i] = take;
                }
                else
                {
                    Es[i] = pass;
                }
            }
            double sum = 0;
            for(double d : Es)
            {
                sum += d;
            }
            return sum/V.length;
        }
        else
        {
            return 0;
        }
    }

    public static double smoothEstimate(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;// * 1.1287 + 0.05284);
    }

    public static int find(int[] list, int search)
    {
        int first  = 0;
        int last   = list.length - 1;
        int middle = (first + last)/2;

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

            middle = (first + last)/2;
        }

        if(first > last)
        {
            return -1;
        }
        return middle;
    }
}

नियंत्रक

import java.lang.Math;
import java.util.Random;
import java.util.ArrayList;
import java.util.Collections;
public class Controller2
{
    public static void main(String [] args)
    {
        int size = 10000;
        int rounds = 1001;
        ArrayList<Integer> results = new ArrayList<Integer>();
        for(int round = 0; round < rounds; round++)
        {
            int[] envelopes = new int[size];
            for(int i = 0; i<envelopes.length; i++)
            {
                envelopes[i] = i+1;
            }
            shuffleArray(envelopes);
            Player2 p = new Player2(size);
            int cutoff = 0;
            int winnings = 0;
            for(int i = 0; i<envelopes.length; i+=2)
            {
                boolean [] take = p.takeQ(envelopes[i],envelopes[i+1]);
                if(take[0] && envelopes[i] >= cutoff)
                {
                    winnings += envelopes[i];
                    cutoff = envelopes[i];
                }
                if(take[1] && envelopes[i+1] >= cutoff)
                {
                    winnings += envelopes[i+1];
                    cutoff = envelopes[i+1];
                }
            }
            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 void shuffleArray(int[] ar)
    {
        Random rnd = new Random();
        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;
        }
    }
}

बिटकॉइन पता: 1BVBs9ZEP8YY4EpV868nxi2R23YfL7hdqq


3

पायथन 3 - $ 615570

वास्तव में oracle ... Eh :) का उपयोग नहीं करता है

def algo():
    global prevs

    try:
        prevs.append(read())
    except NameError:
        prevs = [read()]

    if len(prevs) > 10000:
        prevs = [prevs[-1]]

    if read() < round(len(prevs),-1):
        take()
    else:
        passe()

सभी पिछले लिफाफों की एक सूची बनाता है और जांचता है कि क्या वर्तमान लिफाफा 10 लिफाफे के आवृत्तियों में पिछले लिफाफों की संख्या से कम है।


0

पायथन, 87,424

यहाँ एक सादा और आसान एल्गोरिदम है, भाग्यशाली सात।

def LuckyNumber7():
Test = read()
if "7" in str(Test):
    take()
else:
    passe()

test(LuckyNumber7)

मूल रूप से यह क्या करता है यह पढ़ा जाता है () एक स्ट्रिंग के लिए और जांचता है कि क्या इसमें सात हैं। यदि है, तो यह लिफाफा लेता है। यदि नहीं, तो यह इसे पारित करता है।

यह लगभग 81,000 है, मैं ट्रैक नहीं कर रहा था।


तो इससे पता चलता है कि भाग्य पर भरोसा करना एक सफल रणनीति नहीं है? ;)
रेटो कोराडी

@RetoKoradi Yep: D
The_Basset_Hound
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.