Điều này dựa trên thử thách này và ý tưởng của Geobits / RugPython để cải thiện nó:

Giữ khoảng cách!

Đối với thử thách này, khoảng cách giữa hai số được đo trên một vòng lặp, vì vậy, ví dụ, khoảng cách giữa 0 và 999 là 1. Điều này sẽ ngăn các chiến lược như luôn luôn chọn số thấp nhất hoặc cao nhất chiến thắng gần như mọi lúc. Sự thay đổi duy nhất khác là số thấp nhất có thể được chọn bây giờ là 0 thay vì 1.

Tôi sẽ tóm tắt ở đây:

• Viết hàm bằng Java, Python hoặc Ruby có ba đối số:
  • số vòng đã chơi
  • số lượng người chơi
  • các số được chọn trong các vòng trước, dưới dạng một chuỗi các chuỗi được phân tách bằng dấu cách
• Nó sẽ trả về một số nguyên từ 0 đến 999, đã bao gồm
• Điểm cho một chương trình mỗi vòng là tổng số căn bậc hai của khoảng cách đến các số mà mỗi chương trình đã chọn
• Chương trình có số điểm cao nhất sau 100 vòng chiến thắng.
• Một câu trả lời cho mỗi người

Chương trình kiểm soát ở đây:

https://github.com/KSFTmh/src/

Bảng xếp hạng

NumberOne, bởi TheBestOne, đang chiến thắng.

• Số lượng - 9700
• SốOnePlusFourNineNine - 9623
• Cổ đại - 9425
• Bộ tìm kiếm - 9259
• Wow ThisGameIsSoDeep - 9069
• Bộ lấy mẫu - 9014
• SabotageCampers - 8545

Rõ ràng, kẻ phá hoại cắm trại của tôi ... er (?) Không hoạt động tốt.

Dưới đây là kết quả đầy đủ: https://github.com/KSFTmh/src/blob/master/results-3

Tôi nghĩ rằng điều này là đủ khác nhau để không bị trùng lặp.

Nhân tiện, đây là lần đầu tiên tôi đặt câu hỏi trên Stack Exchange, vì vậy hãy cho tôi biết nếu tôi làm sai điều gì.

Python 2, Sampler

Mục nhập này dựa trên cùng một mã cho Giữ khoảng cách, mục nhập Sampler . Tôi hy vọng nó sẽ làm tốt hơn ở đây khi không có lợi thế 1 và 999.

Trong danh sách các địa điểm, chọn địa điểm cách xa các số được sử dụng gần đây nhất, bỏ qua lượt trước đó (vì các mục khác có thể dự đoán dựa trên lượt trước đó).

def choose(turn, players, history):
    sample = map(int, (' '.join( history[-5:-1] )).split())
    def distance(x):
        return sum(min(1000-abs(x-y), abs(x-y))**0.5 for y in sample)
    score, place = max((distance(x), x) for x in range(1000))
    return place

Số OnePlusFourNineNine, Java

public static int choose(int round, int players, String[] args) {
    return 500;
}

Logic rất đơn giản. Trừ khi ai đó tìm thấy một thuật toán thực sự có thể xem xét các điểm trước đó, câu trả lời này khá tối ưu.

Bây giờ chúng ta đếm khoảng cách trong một vòng tròn, khoảng cách tối đa của hai điểm bất kỳ có thể là 500. Bây giờ nếu tất cả các mục nhập đang tạo số ngẫu nhiên (hoặc giả ngẫu nhiên dựa trên một số thuật toán), câu trả lời này hoàn toàn không có lợi thế . Nhưng có ít nhất 1 mục tạo ra một câu trả lời không đổi, khoảng cách gần như tối đa. Điểm số có lợi cho 500 vì có một khoảng cách cố định tối đa có thể có trong mỗi vòng :)

Cổ đại - Python

Nó là thuật toán tương tự từ thuật toán trước, ngoại trừ khi tính điểm tiềm năng, nó sử dụng khoảng cách vòng tròn. Vì tôi thua một cách khủng khiếp và không thể biên dịch được bộ điều khiển, tôi chỉ đang thử một chiến lược mới, nơi tôi sử dụng thứ tồi tệ nhất từ ​​các vòng trước.

def choose(round, players, scores):
    calc = lambda n, scores: sum([min(abs(int(i)-n), 1000-max(int(i),n)+min(int(i),n))**.5 for i in scores.split(' ')])
    return min(range(1000), key=lambda n: sum([calc(n, j) for j in scores[1:]])) if round>1 else 250

SabotageCampers - Python

def choose(rounds, players, previous):
    if rounds<3:
        return 1
    prevchoices=[int(i) for i in " ".join(previous[-5:]).split(" ")]
    remove=[]
    for i in prevchoices:
        if prevchoices.count(i)<3:
            remove.append(i)
    campers=[i for i in prevchoices if i not in remove]
    return random.choice(campers)

Các trại sinh vẫn chiến thắng. Hãy cho tôi biết nếu bạn có bất kỳ đề nghị cho việc này.

FindCampers - Python 2

Tìm tất cả các trại viên từ 10 vòng cuối cùng và tránh xa họ. Tôi hy vọng rằng những người dự đoán sẽ chạy từ tôi. Bây giờ tôi sẽ bỏ qua các lựa chọn cũ của tôi.

def choose(rounds, players, previous):
    from collections import Counter

    def distance(x, y):
        return min(1000 - abs(x-y), abs(x-y))

    pastRounds = list(map(lambda x: Counter(map(int, x.split())), previous))
    me = 751
    for (index, round) in enumerate(pastRounds):
        round.subtract((me,))
        pastRounds[index] = set(round.elements())
        campers = reduce(lambda x,y: x.intersection(y), pastRounds[max(1, index-9):index], pastRounds[max(0,index-10)])
        if campers:
            dist, me = max(min((distance(x, y), x) for y in campers) for x in range(1000))
        else:
            me = 751
    return me

Số một, Java

Câu trả lời đầu tiên. Sao chép từ câu trả lời trước của tôi .

public static int choose(int round, int players, String[] args) {
    return 1;
}

Wow ThisGameIsSoDeep, Java

Tôi đã phân tích trò chơi trong 10 năm trên cụm 1 triệu lõi và tìm ra giải pháp tối ưu.

public static int choose(int round, int players,String[]spam) { return(int)(Math.random()*1e3); }

Phép ngoại suy Circilinear, Ruby

def choose(round, players, previous_choices)
  previous_rounds = previous_choices.map{ |round| round.split.map(&:to_i) }
  optimal_past_choices = previous_rounds.map do |choices|
    (0..999).max_by { |i| choices.map{ |c| root_distance(i,c) }.inject(:+) }
  end
  if (last_round = optimal_past_choices.last)
    (last_round + average_delta(optimal_past_choices).round) % 1000
  else
    750
  end
end

def root_distance(i,j)
  dist = (i-j).abs
  dist = [dist, 1000 - dist].min
  dist ** 0.5
end

def directed_distance(i,j)
  dist = j - i
  if dist > 500
    dist - 1000
  elsif dist < -500
    dist + 1000
  else
    dist
  end
end

def average_delta(ary)
  ary.each_cons(2).map{ |x,y| directed_distance(x,y) }.inject(0,:+)/ary.count
end