Dies ist das zweite in einer Reihe von Rätseln, die ich jeden Montag um Mitternacht PST veröffentlichen werde. Das erste Puzzle befindet sich hier .

Kontext:

Ein zurückgezogener Milliardär hat eine Spielshow ins Leben gerufen, um die besten und intelligentesten Programmierer der Welt anzulocken. Montags um Mitternacht wählt er aus einem Pool von Bewerbern eine Person als Bewerber der Woche aus und stellt ihnen ein Spiel zur Verfügung. Sie sind der glückliche Kandidat dieser Woche!

Das Spiel dieser Woche:

Der Host bietet Ihnen API-Zugriff auf einen Stapel von 10.000 digitalen Umschlägen. Diese Umschläge sind nach dem Zufallsprinzip sortiert und enthalten einen Dollarwert zwischen 1 und 10.000 US-Dollar (keine zwei Umschläge enthalten denselben Dollarwert).

Sie haben 4 Befehle zur Verfügung:

1. Read (): Lesen Sie die Dollarzahl im Umschlag oben auf dem Stapel.

2. Take (): Fügen Sie die Dollar-Zahl in den Umschlag Ihrer Game-Show-Brieftasche hinzu und legen Sie den Umschlag vom Stapel.

3. Pass (): Nehmen Sie den Umschlag oben auf dem Stapel ab.

4. Oracle (M): Gibt den Mittelwert der nächsten M Umschläge im Stapel zurück, ohne denjenigen, den Sie aktuell lesen können ().

Die Regeln:

1. Wenn Sie Pass () für einen Umschlag verwenden, ist das darin enthaltene Geld für immer verloren.

2. Wenn Sie Take () für einen Umschlag verwenden, der $ X enthält, dürfen Sie Take () von diesem Punkt an niemals für einen Umschlag verwenden, der <$ X enthält. Nehmen Sie () auf einen dieser Umschläge, um Ihrem Portemonnaie $ 0 hinzuzufügen.

3. Wenn Sie in Runde T Oracle (M) verwenden, werden die Umschläge T + 1 bis T + M zurückgegeben. Oracle () ist bis zum Turn T + M deaktiviert.

Schreiben Sie einen Algorithmus, der das Spiel mit dem maximalen Geldbetrag beendet.

Wenn Sie Ihren Algorithmus in Python schreiben, können Sie diesen Controller von @Maltysen verwenden: https://gist.github.com/livinginformation/70ae3f2a57ecba4387b5

Anmerkungen 1: "Maximal" bedeutet in diesem Fall den Medianwert in Ihrer Brieftasche, nachdem N> = 1000 ausgeführt wurde. Ich gehe davon aus, dass der Medianwert für einen gegebenen Algorithmus konvergiert, wenn N auf unendlich ansteigt, obwohl ich mich gerne als falsch erweisen würde. Versuchen Sie stattdessen, den Mittelwert zu maximieren, aber ich habe das Gefühl, dass der Mittelwert mit größerer Wahrscheinlichkeit von einem kleinen N abgelöst wird als der Median.

Anmerkung 2: Da hier alle Lösungen für den vorherigen Teil dieses Puzzles gültig sind, hat das erneute Posten wenig Wert. Nur algorithmische Verbesserungen früherer Rätsel werden für Teil II berücksichtigt.

Bearbeiten: Die Preisbedingung wurde im Lichte dieses Beitrags auf Meta entfernt.

Groovy $ 713337 $ 817829 $ 818227

Bootstrap-Code:

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

Algorithmus

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

Ich vergleiche die verbleibenden Werte mit möglichen Werten. Dieses Skript ist nicht schnell (dauert 1 Minute pro 1000x Simulationen) ... aber es führt die Simulationen gleichzeitig durch.

Ich habe keine Ahnung, warum mein Algorithmus funktioniert, aber es war nur Versuch und Irrtum: mathematische Operationen zusammenfassen und die Konstanten manipulieren. Ich habe es 5000x für die aktuelle Punktzahl ausgeführt, um die Schwankungen der Punktzahl zu verringern (+/- $ 4000, abhängig von der Anzahl der Iterationen).

Auch ohne das Orakel am Ende sollte es die Lösung von @orlp für das vorherige Rätsel (kaum) schlagen .

C # - $ 803.603 jetzt -> $ 804.760 (mit Orakel)

Bootstrap-Code

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

Spielcode:

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

Guthaben gehört Reto Koradi ( /codegolf//a/54181/30910 )

Edit: Grundsätzliche Verwendung von Oracle implementiert. Wenn das nächste Orakel über dem zu verwendenden Schwellenwert liegt, erweitern Sie den aktuellen Umschlag auf den Index des Oracle-Index. Das kommt nicht oft vor, aber ES IST eine Verbesserung ;-)

Python - 74112 US-Dollar

Nur nehmen, wenn der aktuelle Wert kleiner als der nächste Wert ist (dh Sie können beide nehmen).

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

Python - (berechnet immer noch den Mittelwert)

Die Berechnung dieser Antwort dauert SEHR LANG. Es erreicht rund 670.000 $ . Ich erinnere mich an jeden Umschlag, den ich gesehen habe. Jedes Mal, wenn ich eine Entscheidung treffen muss, erstelle ich zwei Listen mit verbleibenden Umschlägen, die ich möglicherweise zu meiner Brieftasche hinzufügen könnte, wenn ich den aktuellen Umschlag nehme oder ihn lasse.

Ich habe den Code nicht optimiert.

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()

Und init_game startet so:

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

C # - $ 780.176

Überprüfen Sie, ob der nächste Wert innerhalb der unteren 5% aller verbleibenden Werte liegt. Entspanne dich, wenn wir am Ende sind.

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

Und meine Spielklasse, sehr hässlich, validiert nicht einmal, ob Orakel erlaubt ist, aber da ich nur Oracle (1) verwende, sollte das kein Problem sein.

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

Java, 804.991 US-Dollar

Das Ergebnis stammt aus 1001 Runden. Es ist wahrscheinlich zu eng, zwischen dieser Antwort und der von Stephan Schinkel zu sprechen .

Dies basiert auf meiner Antwort in der vorherigen Herausforderung, da dieselbe entropiebasierte Berechnung zur Schätzung der Auszahlungen verwendet wird. Der Hauptunterschied besteht darin, dass nur noch paarweise Briefumschläge (1 & 2, dann 3 & 4 usw.) eingelegt werden und die möglichen Kombinationen von Take-Take, Take-Pass, Pass-Take usw. betrachtet werden Genau geschätzte Punktzahl, wenn die Anzahl der gültigen Umschläge sehr gering ist.

Der "Wrapper", den ich geschrieben habe, ist kein echter Wrapper, er gibt nur paarweise Umschläge, anstatt Oracle(1)jede zweite Runde eine Funktion aufzurufen .

Insgesamt würde ich sagen, dass dieser Bot trotz der gestiegenen Komplexität nicht besser ist als mein vorheriger.

Spieler

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

Regler

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

Bitcoin-Adresse: 1BVBs9ZEP8YY4EpV868nxi2R23YfL7hdMq

Python 3 - $ 615570

Benutzt eigentlich nicht das Orakel ... 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()

Erstellt eine Liste aller vorherigen Umschläge und überprüft, ob der aktuelle Umschlag in Schritten von 10 Umschlägen kleiner als die Anzahl der vorherigen Umschläge ist.

Python, 87, 424

Hier ist ein einfacher Algorithmus, die glückliche Sieben.

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

test(LuckyNumber7)

Grundsätzlich konvertiert es read () in einen String und prüft, ob eine Sieben drin ist. Wenn ja, wird der Umschlag genommen. Wenn nicht, geht es vorbei.

Es liegt im Durchschnitt bei 81.000, ich habe den Überblick nicht behalten.