สิ่งนี้ขึ้นอยู่กับความท้าทายนี้และความคิดของ Geobits / CarpetPython เพื่อปรับปรุง:

รักษาระยะห่างของคุณ!

สำหรับความท้าทายนี้ระยะห่างระหว่างตัวเลขสองจำนวนจะถูกวัดบนลูปดังนั้นเช่นระยะห่างระหว่าง 0 ถึง 999 คือ 1 สิ่งนี้ควรป้องกันกลยุทธ์เช่นการเลือกหมายเลขต่ำสุดหรือสูงที่สุดเสมอจากการชนะเกือบทุกครั้ง การเปลี่ยนแปลงอื่น ๆ เท่านั้นคือจำนวนต่ำสุดที่สามารถเลือกได้คือ 0 แทน 1

ฉันจะสรุปได้ที่นี่:

• เขียนฟังก์ชั่นใน Java, Python หรือ Ruby ที่มีอาร์กิวเมนต์สามตัว:
  • จำนวนรอบที่เล่นจนถึง
  • จำนวนผู้เล่น
  • ตัวเลขที่เลือกในรอบก่อนหน้านี้เป็นอาร์เรย์ของสตริงที่คั่นด้วยช่องว่าง
• มันควรจะกลับจำนวนเต็มตั้งแต่ 0 ถึง 999 รวม
• คะแนนสำหรับโปรแกรมในแต่ละรอบคือผลรวมของสแควร์รูทของระยะทางไปยังหมายเลขที่แต่ละโปรแกรมอื่นเลือก
• โปรแกรมที่มีคะแนนสูงสุดหลังจากชนะ 100 รอบ
• หนึ่งคำตอบต่อคน

โปรแกรมควบคุมอยู่ที่นี่:

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

ลีดเดอร์บอร์ด

NumberOne โดย TheBestOne เป็นผู้ชนะ

• NumberOne - 9700
• NumberOnePlusFourNineNine - 9623
• ประวัติศาสตร์โบราณ - 9425
• FindCampers - 9259
• WowThisGameIsSoDeep - 9069
• ตัวอย่าง - 9014
• การก่อวินาศกรรม - 8545

เห็นได้ชัดว่าการก่อวินาศกรรมค่ายของฉัน ... เอ่อ (?) ทำงานได้ไม่ดีนัก

นี่คือผลการแข่งขันเต็มรูปแบบ: https://github.com/KSFTmh/src/blob/master/results-3

ฉันคิดว่ามันแตกต่างกันพอที่จะไม่ซ้ำซ้อน

นี่เป็นครั้งแรกที่ฉันถามคำถามเกี่ยวกับการแลกเปลี่ยนแบบสแต็กดังนั้นแจ้งให้ฉันทราบหากฉันทำอะไรผิด

Python 2, Sampler

รายการนี้จะขึ้นอยู่กับรหัสเดียวกันสำหรับการรักษาระยะห่างของคุณเข้าเก็บตัวอย่าง ฉันหวังว่ามันจะดีขึ้นที่นี่โดยที่ไม่มีข้อได้เปรียบ 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;
}

ตรรกะนั้นง่ายมาก หากไม่มีใครพบอัลกอริทึมจริงซึ่งพิจารณาคะแนนก่อนหน้านี้คำตอบนี้ได้รับการปรับให้เหมาะสม

ตอนนี้เรานับระยะทางเป็นวงกลมระยะทางสูงสุดของจุดสองจุดใด ๆ สามารถเป็น 500 ได้ตอนนี้หากทุกรายการกำลังสร้างตัวเลขสุ่ม . แต่มีอย่างน้อย 1 รายการที่สร้างคำตอบคงที่ซึ่งเป็นระยะทางสูงสุดเกือบ คะแนนทำให้คะแนนในความโปรดปรานของ 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 - 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

ฉันวิเคราะห์เกมเป็นเวลา 10 ปีในคลัสเตอร์ 1 ล้านคอร์และพบทางออกที่ดีที่สุด

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

Extrapolator Circilinear ทับทิม

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