매주 월요일 자정 PST에 게시 할 일련의 퍼즐 중 두 번째입니다. 첫 번째 퍼즐은 여기에 있습니다.

문맥:

독점 억만 장자는 세계 최고의 밝고 프로그래머를 유치하기 위해 게임 쇼를 만들었습니다. 월요일 자정이 시작되면 월요일에는 지원자 풀에서 한 사람을 선택하여 주중 참가자로 선택하고 게임을 제공합니다. 이번 주 행운의 참가자입니다.

이번 주 게임 :

호스트는 10,000 개의 디지털 봉투 스택에 대한 API 액세스를 제공합니다. 이 봉투는 무작위로 정렬되며 그 안에 1 달러에서 10,000 달러 사이의 달러 값을 포함합니다 (두 봉투에 동일한 달러 값이 포함되어 있지 않음).

당신은 당신의 처분에 4 명령이 있습니다 :

1. Read () : 스택 상단의 봉투에서 달러 수치를 읽습니다.

2. Take () : 봉투에있는 달러 그림을 게임 쇼 지갑에 추가하고 봉투를 스택에서 빼냅니다.

3. 통과 () : 스택 상단의 봉투를 튀어 나옵니다.

4. Oracle (M) : 스택에서 다음 M 봉투의 평균값을 반환합니다 (현재 읽을 수있는 봉투는 포함하지 않음).

규칙:

1. 봉투에 Pass ()를 사용하면 돈이 영원히 손실됩니다.

2. $ X가 들어있는 봉투에서 Take ()를 사용하는 경우 그 시점부터는 $ $가 들어있는 봉투에서 Take ()를 사용할 수 없습니다. 이 봉투 중 하나의 Take ()는 지갑에 $ 0를 추가합니다.

3. T 턴에 Oracle (M)을 사용하면 봉투 T + 1에서 T + M의 평균이 반환됩니다. T + M을 돌릴 때까지 Oracle ()이 비활성화됩니다.

최대한의 돈으로 게임을 끝내는 알고리즘을 작성하십시오.

Python으로 알고리즘을 작성하는 경우 @Maltysen에서 제공하는이 컨트롤러를 사용하십시오. https://gist.github.com/livinginformation/70ae3f2a57ecba4387b5

참고 1 :이 경우 "최대"는 N> = 1000이 실행 된 후 지갑의 중앙값을 의미합니다. 나는 틀린 것으로 입증되고 싶지만 N이 무한대로 증가함에 따라 주어진 알고리즘의 중간 값이 수렴 할 것으로 기대합니다. 평균을 최대한 최대화하려고 노력하십시오. 그러나 평균이 중간 값보다 작은 N에 의해 ​​평균이 제거 될 가능성이 더 높습니다.

참고 2 :이 퍼즐의 이전 부분에 대한 모든 솔루션이 여기에서 유효하므로 다시 게시하면 가치가 거의 없습니다. 파트 II에서는 이전 퍼즐의 알고리즘 개선 만 고려됩니다.

편집 : 메타에 대한 이 게시물 에 비추어 상 조건이 제거되었습니다 .

그루비 $ 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).

오라클이 마지막에 없어도 이전 퍼즐에 대해 @orlp의 솔루션 을 (간신히) 구타해야합니다 .

C #-803.603 달러-> 804.760 달러 (Oracle 포함)

부트 스트랩 코드

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

크레딧은 Reto Koradi에 속합니다 ( /codegolf//a/54181/30910 )

편집 : Oracle의 기본 사용이 구현되었습니다. 다음 오라클이 임계 값을 초과하여 사용하려면 현재 엔벨로프를 Oracle 인덱스의 인덱스로 확장하십시오. 이것은 자주 맞지는 않지만 IT는 개선입니다 ;-)

파이썬-$ 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=[]

C #-$ 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);
    }
}

그리고 내 게임 클래스, 매우 추악한 게임 클래스는 오라클이 허용되는지 여부조차 확인하지 않지만 Oracle (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();
    }
}

자바, $ 804,991

점수는 1001 라운드입니다. 이 답변과 Stephan Schinkel 's 사이에 전화하기에는 너무 가깝습니다 .

이것은 동일한 엔트로피 기반 계산을 사용하여 지불금을 계산한다는 점에서 이전 과제의 대답을 기반으로합니다. 가장 큰 차이점은 이제 단순히 봉투를 한 쌍 (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;
        }
    }
}

비트 코인 주소 : 1BVBs9ZEP8YY4EpV868nxi2R23YfL7hdMq

파이썬 3-$ 615570

실제로 오라클을 사용하지 않습니다 ... 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 봉투 증가한지 확인합니다.

파이썬, 87,424

여기에 간단하고 쉬운 알고리즘 인 행운의 일곱이 있습니다.

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

test(LuckyNumber7)

기본적으로 read ()를 문자열로 변환하고 7이 있는지 확인합니다. 있으면 봉투가 필요합니다. 그렇지 않으면 통과합니다.

평균 81,000 정도이며 추적하지 못했습니다.