Bu, bu zorluğa ve Geobits / CarpetPython'un bunu geliştirme fikrine dayanmaktadır:

Mesafeni koru!

Bu zorluk için, iki sayı arasındaki mesafe bir döngüde ölçülür, örneğin, 0 ile 999 arasındaki mesafe 1'dir. Bu, her zaman en düşük veya en yüksek sayıyı seçmek gibi stratejilerin neredeyse her seferinde kazanmasını engellemelidir. Diğer tek değişiklik seçilebilecek en düşük sayının 1 yerine 0 olması.

Burada özetleyeceğim:

• Java, Python veya Ruby'de üç argüman alan bir işlev yazın:
  • şu ana kadar oynanan raund sayısı
  • oyuncu sayısı
  • boşlukla ayrılmış dizeler dizisi olarak önceki turlarda seçilen sayılar
• 0 ile 999 arasında bir tam sayı döndürmelidir
• Her turdaki bir programın puanı, her bir programın seçtiği sayılara olan mesafelerin kare köklerinin toplamıdır
• 100 mermi sonrasında en yüksek puanı alan program kazanır.
• Kişi başına bir cevap

Kontrol programı burada:

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

Liderler Sıralaması

TheBestOne tarafından NumberOne kazanıyor.

• Numara Bir - 9700
• NumberOnePlusFourNineNine - 9623
• AncientHistorian - 9425
• Bulucuları - 9259
• WowThisGameIsSoDeep - 9069
• Örnekleyici - 9014
• SaborsCampers - 8545

Görünüşe göre, kampçı sabotaj ... er (?) Çok iyi çalışmıyor.

İşte tüm sonuçlar: https://github.com/KSFTmh/src/blob/master/results-3

Bence bu kopya olmayacak kadar farklı.

Bu arada, ilk kez Stack Exchange ile ilgili bir soru soruyorum, bu yüzden yanlış bir şey yapıp yapmadığımı bana bildirin.

Python 2, Örnekleyici

Bu giriş Mesafeyi koru, Örnekleyici girişi için aynı koda dayanmaktadır . Umarım burada 1 ve 999 avantajlarının olmadığı yerlerde daha iyi olur.

Bir yer listesinden, son dönüşü yok sayarak, son kullanılan sayılardan en uzak olanı seçin (diğer girişler yalnızca önceki dönüşe göre tahmin edilebilir).

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

OnePlusFourNineNine, Java

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

Mantık gerçekten çok basit. Birisi önceki puanları dikkate alan gerçek bir algoritma bulamazsa, bu cevap oldukça optimize edilmiştir.

Bir daire içindeki mesafeyi saydığımıza göre, herhangi iki noktanın maksimum mesafesi 500 olabilir. Şimdi tüm girişler rastgele sayılar üretiyorsa (veya bazı algoritmalara dayanarak sahte rasgele), bu cevap hiç de avantajlı olmazdı . Ancak, sürekli bir cevap üreten ve neredeyse maksimum mesafeye sahip en az 1 giriş vardır. Her turda sabit bir maksimum mesafe kaynağı olduğu için skor 500 lehine geliyor :)

AncientHistorian - Python

Bir öncekinden aynı algoritmadır, potansiyel puanları hesaplarken dairesel mesafeyi kullanır. Korkunç bir şekilde kaybettiğimden ve kontrolörün derlenmesini sağlayamadığım için, sadece önceki turlardan en kötüyü kullandığım yeni bir strateji deniyorum.

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)

Kampçılar hala kazanıyor. Bunun için herhangi bir öneriniz varsa bana bildirin.

FindCampers - Python 2

Son 10 turdaki tüm kampçıları bulun ve onlardan uzak durun. Tahmincilerin benden kaçmasını umuyorum. Şimdi eski seçimlerimi görmezden geleceğim.

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

Bir Numara, Java

İlk cevap. Önceki cevabımdan kopyalandı .

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

WowThisGameIsSoDeep, Java

Oyunu 10 yıl boyunca 1 milyon çekirdekli bir kümede analiz ettim ve en uygun çözümü buldum.

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

Daire dışı Extrapolator, 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