Bối cảnh:

Một tỷ phú ẩn dật đã tạo ra một game show để thu hút các lập trình viên giỏi nhất và thông minh nhất thế giới. Vào thứ Hai vào lúc nửa đêm, anh ấy chọn một người trong nhóm ứng viên làm thí sinh của tuần và cung cấp cho họ một trò chơi. Bạn là thí sinh may mắn tuần này!

Trò chơi tuần này:

Máy chủ cung cấp cho bạn quyền truy cập API vào một chồng 10.000 phong bì kỹ thuật số. Những phong bì này được sắp xếp ngẫu nhiên và chứa trong chúng một giá trị đô la, từ 1 đến 10.000 đô la (không có hai phong bì chứa cùng một giá trị đô la).

Bạn có 3 lệnh theo ý của bạn:

1. Đọc (): Đọc số đô la trong phong bì ở đầu ngăn xếp.

2. Lấy (): Thêm hình đô la trong phong bì vào ví chương trình trò chơi của bạn và bật phong bì ra khỏi ngăn xếp.

3. Pass (): Bật tắt phong bì trên đỉnh của ngăn xếp.

Những quy định:

1. Nếu bạn sử dụng Pass () trên một phong bì, tiền trong đó sẽ bị mất vĩnh viễn.

2. Nếu bạn sử dụng Take () trên một phong bì chứa $ X, từ thời điểm đó trở đi, bạn không bao giờ có thể sử dụng Take () trên một phong bì chứa <$ X. Lấy () trên một trong những phong bì này sẽ thêm $ 0 vào ví của bạn.

Viết một thuật toán kết thúc trò chơi với số tiền tối đa.

Nếu bạn đang viết một giải pháp bằng Python, vui lòng sử dụng bộ điều khiển này để kiểm tra các thuật toán, lịch sự của @Maltysen: https://gist.github.com/Maltysen/5a4a33691cd603e9aeca

Nếu bạn sử dụng bộ điều khiển, bạn không thể truy cập toàn cục, bạn chỉ có thể sử dụng 3 lệnh API được cung cấp và các biến phạm vi cục bộ. (@Beta phân rã)

Lưu ý: "Tối đa" trong trường hợp này có nghĩa là giá trị trung bình trong ví của bạn sau khi N> 50 chạy. Tôi hy vọng, mặc dù tôi rất muốn được chứng minh là sai, rằng giá trị trung bình cho một thuật toán nhất định sẽ hội tụ khi N tăng lên vô cùng. Thay vào đó, hãy cố gắng tối đa hóa giá trị trung bình, nhưng tôi có cảm giác rằng giá trị trung bình có nhiều khả năng bị bỏ đi bởi một N nhỏ hơn so với trung bình.

Chỉnh sửa: đã thay đổi số lượng phong bì thành 10k để xử lý dễ dàng hơn và làm cho Take () rõ ràng hơn.

Chỉnh sửa 2: Điều kiện giải thưởng đã bị xóa, trong bài đăng này trên meta.

Điểm cao hiện tại:

PhiNotPi - $ 805.479

Reto Koradi - $ 803.960

Dennis - $ 770,272 (Sửa đổi)

Alex L. - $ 714.962 (Sửa đổi)

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

Chương trình này mô phỏng toàn bộ trò chơi nhiều lần và tính toán trung vị.

Cách chạy

Tôi đã ghi được bài nộp của mình bằng cách thực hiện 100.001 lượt chạy thử:

$ 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

Tiếp cận

Đối với mỗi phong bì, chúng tôi làm như sau:

• Ước tính số tiền chắc chắn sẽ bị mất bằng cách lấy phong bì.

  Nếu R là nội dung và M là mức tối đa đã được lấy, số tiền có thể được ước tính là R (R-1) / 2 - M (M + 1) / 2 , cung cấp cho tất cả các phong bì có nội dung X trong khoảng (M, R) chứa.

  Nếu chưa có phong bì nào được thông qua, ước tính sẽ hoàn hảo.

• Tính số tiền chắc chắn sẽ bị mất bằng cách chuyển phong bì.

  Đây chỉ đơn giản là số tiền mà phong bì chứa.

• Kiểm tra xem thương số của cả hai có nhỏ hơn 110 + 0,016E hay không , trong đó E là số lượng phong bì còn lại (không tính các phong bì không thể lấy được nữa).

  Nếu vậy, hãy lấy. Nếu không, vượt qua.

Con trăn, $ 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()

Có số tiền lớn hơn và lớn hơn trong các bước có kích thước từ $ 125 đến $ 190. Chạy với N = 10.000 và có trung bình $ 714962. Các kích thước bước này đến từ thử nghiệm và lỗi và chắc chắn là không tối ưu.

Mã đầy đủ, bao gồm phiên bản sửa đổi của bộ điều khiển của @ Maltysen in biểu đồ thanh trong khi nó chạy:

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)

Địa chỉ bitcoin: 1CBzYPCFFBW1FX9sBTmNYUJyMxMcmL4BZ7

Wow OP giao hàng! Cảm ơn @LivingIn information!

C ++, $ 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();
    }
}

Kết quả được báo cáo là trung vị từ 10.001 trò chơi.

C ++, ~ 815.000 đô la

Dựa trên giải pháp của Reto Koradi, nhưng chuyển sang một thuật toán phức tạp hơn một khi có 100 phong bì (hợp lệ) còn lại, xáo trộn các hoán vị ngẫu nhiên và tính toán sự gia tăng nặng nề nhất của chúng. Nó sẽ so sánh kết quả của việc lấy và không lấy phong bì, và sẽ tham lam chọn lựa chọn tốt nhất.

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

Java, $ 806.899

Đây là từ một thử nghiệm của 2501 vòng. Tôi vẫn đang làm việc để tối ưu hóa nó. Tôi đã viết hai lớp, một trình bao bọc và một người chơi. Trình bao bọc khởi tạo trình phát với số lượng phong bì (luôn là 10000 cho thực tế), sau đó gọi phương thức takeQvới giá trị của phong bì trên cùng. Người chơi sau đó trả lại truenếu họ lấy nó, falsenếu họ vượt qua nó.

Người chơi

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

Vỏ bánh

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

Một lời giải thích chi tiết hơn sẽ đến sớm, sau khi tôi hoàn thành việc tối ưu hóa.

Ý tưởng cốt lõi là có thể ước tính phần thưởng từ việc chơi trò chơi từ một bộ phong bì nhất định. Nếu bộ phong bì hiện tại là {2,4,5,7,8,9} và phong bì trên cùng là 5, thì có hai khả năng:

• Lấy số 5 và chơi một trò chơi với {7,8,9}
• Vượt qua 5 và chơi một trò chơi {2,4,7,8,9}

Nếu chúng ta tính toán phần thưởng dự kiến ​​là {7,8,9} và so sánh với phần thưởng dự kiến ​​là {2,4,7,8,9}, chúng ta sẽ có thể biết liệu lấy 5 có xứng đáng hay không.

Bây giờ câu hỏi là, đưa ra một bộ phong bì như {2,4,7,8,9} giá trị mong đợi là gì? Tôi thấy giá trị mong đợi dường như tỷ lệ thuận với tổng số tiền trong tập hợp, nhưng tỷ lệ nghịch với căn bậc hai của số lượng phong bì mà số tiền được chia thành. Điều này xuất phát từ việc "hoàn hảo" chơi một số trò chơi nhỏ trong đó tất cả các phong bì có giá trị gần như giống hệt nhau.

Vấn đề tiếp theo là làm thế nào để xác định " số lượng phong bì hiệu quả ". Trong mọi trường hợp, số lượng phong bì được biết chính xác bằng cách theo dõi những gì bạn đã thấy và thực hiện. Một cái gì đó như {234,235,236} chắc chắn là ba phong bì, {231,232,233,234,235} chắc chắn là 5, nhưng {1,2,234,235,236} thực sự nên được tính là 3 và không phải 5 phong bì vì 1 và 2 gần như không có giá trị sau này bạn có thể lấy 1 hoặc 2. Tôi có ý tưởng sử dụng entropy của Shannon để xác định số lượng phong bì hiệu quả.

Tôi đã nhắm mục tiêu tính toán của mình vào các tình huống trong đó các giá trị của phong bì được phân phối đồng đều trong một khoảng thời gian, đó là những gì xảy ra trong trò chơi. Nếu tôi lấy {2,4,7,8,9} và coi đó là phân phối xác suất, thì entropy của nó là 1.50242. Sau đó, tôi làm exp()để có được 4,49254 là số phong bì hiệu quả.

Phần thưởng ước tính từ {2,4,7,8,9} là 30 * 4.4925^-0.5 * 4/3 = 18.87

Con số chính xác là 18.1167.

Đây không phải là một ước tính chính xác, nhưng tôi thực sự tự hào về việc dữ liệu này phù hợp với dữ liệu như thế nào khi các phong bì được phân phối đồng đều trong một khoảng thời gian. Tôi không chắc chắn về số nhân chính xác (hiện tôi đang sử dụng 4/3) nhưng đây là bảng dữ liệu không bao gồm số nhân.

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

Hồi quy tuyến tính giữa dự kiến ​​và thực tế cho giá trị R ^ 2 là 0,999999 .

Bước tiếp theo của tôi để cải thiện câu trả lời này là cải thiện ước lượng khi số lượng phong bì bắt đầu nhỏ đi, đó là khi các phong bì không được phân phối đồng đều và khi vấn đề bắt đầu có dạng hạt.

Chỉnh sửa: Nếu điều này được coi là xứng đáng với bitcoin, tôi chỉ cần có một địa chỉ tại 1PZ65cXxUEEcGwd7E8i7g6qmvLDGqZ5JWg. Cảm ơn! (Đây là ở đây từ khi tác giả thách thức đang trao giải.)