이것은 이러한 도전과 그것을 개선하려는 Geobits / CarpetPython의 아이디어를 기반으로합니다.

거리를 유지해라!

이 문제의 경우 두 숫자 사이의 거리는 루프에서 측정되므로 예를 들어 0에서 999 사이의 거리는 1입니다. 이렇게하면 항상 가장 낮은 숫자 또는 가장 높은 숫자를 선택하는 것과 같은 전략이 거의 항상 승리하지 못합니다. 다른 변경 사항은 선택할 수있는 가장 낮은 숫자가 1이 아니라 0이라는 것입니다.

여기에 요약하겠습니다 :

• Java, Python 또는 Ruby에서 세 가지 인수를 취하는 함수를 작성하십시오.
  • 지금까지 플레이 한 라운드 수
  • 플레이어 수
  • 공백으로 구분 된 문자열의 배열로 이전 라운드에서 선택한 숫자
• 0에서 999까지의 정수를 반환해야합니다.
• 각 프로그램의 점수는 각 프로그램이 선택한 숫자에 대한 거리의 제곱근의 합입니다.
• 100 라운드 후 가장 높은 점수를 얻은 프로그램이 승리합니다.
• 한 사람당 하나의 답변

제어 프로그램은 다음과 같습니다.

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

리더 보드

TheBestOne의 NumberOne이 이겼습니다.

• 넘버원-9700
• 넘버원 플러스 포 나인 나인-9623
• 고대사-9425
• FindCampers-9259
• WowThisGameIsSoDeep-9069
• 샘플러-9014
• 사보타주 캠퍼스-8545

분명히, 나의 야영 자 파괴자 ... er (?)는 잘 작동하지 않습니다.

전체 결과는 다음과 같습니다. https://github.com/KSFTmh/src/blob/master/results-3

나는 이것이 중복되지 않을 정도로 다르다고 생각합니다.

그건 그렇고, 이번이 Stack Exchange에 대한 질문을 처음으로했기 때문에 내가 잘못하고 있는지 알려주십시오.

파이썬 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

넘버원 플러스 포 나인 나인, 자바

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

논리는 정말 간단합니다. 누군가가 이전 점수를 고려한 실제 알고리즘을 찾지 않으면이 답변은 상당히 최적화됩니다.

이제 원으로 거리를 세면, 두 점의 최대 거리는 500이 될 수 있습니다. 이제 모든 엔트리가 난수 (또는 알고리즘에 따라 의사 난수)를 생성했다면이 답변은 전혀 유리하지 않았을 것입니다 . 그러나 거의 최대 거리에 대한 정답을 생성하는 항목이 하나 이상 있습니다. 각 라운드에서 가능한 최대 거리의 고정 소스가 있기 때문에 점수는 500을 선호합니다. :)

고대사-파이썬

잠재적 점수를 계산할 때 원형 거리를 사용한다는 점을 제외하면 이전 알고리즘과 동일한 알고리즘입니다. 끔찍하게 잃어 컨트롤러를 컴파일 할 수 없으므로 이전 라운드에서 최악을 사용하는 새로운 전략을 시도하고 있습니다.

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-파이썬 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

넘버 원, 자바

첫 번째 대답. 이전 답변 에서 복사했습니다 .

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

와우 ThisGameIsSoDeep, 자바

백만 코어 클러스터에서 10 년 동안 게임을 분석 한 결과 최적의 솔루션을 찾았습니다.

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

원주 외삽 기, 루비

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