これは、この課題とそれを改善するGeobits / CarpetPythonのアイデアに基づいています。

距離を置く！

この課題では、2つの数値間の距離はループで測定されるため、たとえば、0と999の間の距離は1です。これにより、常に最小または最大の数値を選択するような戦略がほぼ毎回勝つことを防ぐ必要があります。他の唯一の変更は、選択できる最小数が1ではなく0になったことです。

ここで要約します。

• 3つの引数を取る関数をJava、Python、またはRubyで記述します。
  • これまでに行われたラウンドの数
  • プレーヤーの数
  • スペースで区切られた文字列の配列として、前のラウンドで選択された数
• 0から999までの整数を返す必要があります
• 各ラウンドのプログラムのスコアは、他の各プログラムが選択した数値への距離の平方根の合計です
• 100ラウンド後に最高スコアを獲得したプログラムが勝利します。
• 1人につき1つの回答

制御プログラムはここにあります：

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

リーダーボード

TheBestOneによるNumberOneが勝利しています。

• NumberOne-9700
• NumberOnePlusFourNineNine-9623
• AncientHistorian-9425
• FindCampers-9259
• WowThisGameIsSoDeep-9069
• サンプラー-9014
• SabotageCampers-8545

どうやら、私のキャンピングカーサボタージュ... er（？）はあまりうまく機能しません。

以下が完全な結果です：https : //github.com/KSFTmh/src/blob/master/results-3

これは、重複しないように十分に異なると思います。

ちなみに、Stack Exchangeについて質問するのは今回が初めてなので、何か問題があった場合はお知らせください。

Python 2、サンプラー

このエントリーは、「キープ・ユア・ディスタンス、サンプラー・エントリー」と同じコードに基づいています。ここでは、1と999の利点が存在しない場合に、それがうまくいくことを願っています。

場所のリストから、最近使用した数字から最も離れた場所を選択し、前のターンを無視します（他のエントリは前のターンだけに基づいて予測する可能性があるため）。

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

Number OnePlusFourNineNine、Java

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

ロジックは本当にシンプルです。以前のスコアを考慮に入れる実際のアルゴリズムを誰かが見つけない限り、この答えはかなり最適化されています。

円内の距離を数えると、2点の最大距離は500になります。すべてのエントリが乱数（またはアルゴリズムに基づく疑似乱数）を生成している場合、この答えはまったく有利ではありませんでした。 。しかし、ほぼ最大の距離である一定の回答を生成する少なくとも1つのエントリがあります。各ラウンドで可能な最大距離の固定ソースがあるため、スコアは500に有利になります:)

AncientHistorian-Python

これは前のアルゴリズムと同じアルゴリズムですが、潜在的なスコアを計算するときは、円形距離を使用します。私はひどく負けており、コントローラーをコンパイルすることができないので、私は新しい戦略を試しているだけで、前回のラウンドの最悪のものを使用しています。

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)

キャンパーはまだ勝利しています。これについて何か提案があれば教えてください。

FindCampers-Python 2

過去10ラウンドのキャンパーをすべて見つけて、近づかないようにします。予測変数が私から実行されることを期待しています。私は今私の古い選択を無視します。

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

ナンバーワン、Java

最初の答え。以前の回答からコピーしました。

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

WowThisGameIsSoDeep、Java

100万コアのクラスターで10年間ゲームを分析し、最適なソリューションを見つけました。

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

周線形外挿、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