एक सर्कल पर अपनी दूरी बनाए रखें

Question

यह इस चुनौती पर आधारित है और इसे सुधारने के लिए जियोबिट्स / कारपेटपिथॉन का विचार:

अपनी दूरी बनाए रखो!

इस चुनौती के लिए, दो नंबरों के बीच की दूरी को एक लूप पर मापा जाता है, इसलिए, उदाहरण के लिए, 0 और 999 के बीच की दूरी 1 है। इससे रणनीतियों को हमेशा रोका जाना चाहिए जैसे कि सबसे कम या उच्चतम संख्या को लगभग हर बार जीतने से। केवल अन्य परिवर्तन यह है कि सबसे कम संख्या जिसे चुना जा सकता है वह 1 के बजाय अब 0 है।

मैं इसे यहाँ संक्षेप में बताऊंगा:

• जावा, पायथन, या रूबी में एक फ़ंक्शन लिखें जो तीन तर्क देता है:
  • अब तक खेले गए राउंड की संख्या
  • खिलाड़ियों की संख्या
  • पिछले दौर में चुने गए नंबर, अंतरिक्ष-अलग तारों के एक सरणी के रूप में
• इसे 0 से 999 तक पूर्णांक, समावेशी वापस करना चाहिए
• प्रत्येक राउंड के लिए एक प्रोग्राम का स्कोर उन दूरीओं के वर्गमूलों का योग होता है, जो एक दूसरे के द्वारा चुने गए प्रोग्राम की संख्याओं के लिए होती हैं
• 100 राउंड जीतने के बाद उच्चतम स्कोर वाला कार्यक्रम।
• प्रति व्यक्ति एक उत्तर

नियंत्रण कार्यक्रम यहाँ है:

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

लीडरबोर्ड

नंबर, TheBestOne द्वारा, जीत रहा है।

• नंबरऑन - 9700
• नंबरऑनप्लसफॉरनाइन - 9623
• प्राचीनहरिस्तानी - 9425
• FindCampers - 9259
• WowThisGameIsSoDeep - 9069
• सांपला - 9014
• सबोटेजकैम्पर्स - 8545

जाहिर है, मेरे टूरिस्ट तोड़फोड़ ... एर (?) बहुत अच्छी तरह से काम नहीं करता है।

यहां पूर्ण परिणाम दिए गए हैं: https://github.com/KSFTmh/src/blob/master/results-3

मुझे लगता है कि यह डुप्लिकेट न होने के लिए पर्याप्त है।

वैसे, यह मेरा पहली बार स्टैक एक्सचेंज पर एक सवाल पूछ रहा है, इसलिए मुझे बताएं कि क्या मैं कुछ गलत कर रहा हूं।

Comments

क्या हम वास्तव में इसी तरह का प्रश्न चाहते हैं?

— ऑप्टिमाइज़र

@Optimizer टिप्पणी में कुछ लोगों को लगता है कि यह एक अच्छा विचार था। मूल से उत्तर यहां बहुत अलग तरीके से काम करेंगे, इसलिए मुझे नहीं लगता कि यह एक डुप्लिकेट है।

— केएसएफटी

चुनौती का सुझाव देने का श्रेय @Geobits को जाना चाहिए। मैं बस उससे सहमत था।

— लॉज नाइट

Mmm। ऐसा लगता है कि एक निरंतर संख्या फिर से जीतती है। मैं उत्सुक हूं कि ऐसा क्यों है। क्या हम सवाल में 600 आउटपुट नंबर देख सकते हैं, या जीथब या पास्टबिन पर? मुझे संदेह है कि हमारे कुछ भविष्यवक्ताओं में बग हैं। संभवतः मेरा :-(

— लॉजिक नाइट

@CarpetPython एक साधारण बदलाव होगा कि इस दौर के अंकों के अलावा पिछले चारों ओर के बिंदुओं के बीच की दूरी।

— TheNumberOne

Answer 1

अजगर 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

Comments

ऐसा लगता है कि यह किसी की जीत है, लेकिन ऐसा इसलिए हो सकता है क्योंकि मैं नियंत्रक को सही नहीं मान रहा हूं और बाकी सभी दुर्घटनाग्रस्त हैं।

— KSFT

Answer 2

नंबर वनप्लसफॉरनाइन, जावा

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

तर्क वास्तव में सरल है। जब तक कोई वास्तविक एल्गोरिथ्म नहीं पाता है जो पिछले स्कोर को ध्यान में रखता है, यह उत्तर काफी अनुकूलित है।

अब जब हम एक सर्कल में दूरी की गणना करते हैं, तो किसी भी दो बिंदुओं की अधिकतम दूरी 500 हो सकती है। अब यदि सभी प्रविष्टियां यादृच्छिक संख्या (या कुछ एल्गोरिथ्म के आधार पर छद्म यादृच्छिक) उत्पन्न कर रही थीं, तो यह उत्तर किसी भी लाभ में नहीं होगा। । लेकिन कम से कम 1 प्रविष्टि है जो एक निरंतर उत्तर का उत्पादन करती है जो लगभग अधिकतम दूरी है। स्कोर 500 के पक्ष में आता है क्योंकि प्रत्येक दौर में अधिकतम दूरी का एक निश्चित स्रोत है :)

Comments

आपने मेरा उत्तर अनुकूलित कर दिया। ;)

— द न्यूम्बरऑन

@ TheBestOne haha

— ऑप्टिमाइज़र

Answer 3

प्राचीनहिस्टेरियन - पायथन

यह पिछले एक से एक ही एल्गोरिथ्म है, सिवाय इसके कि जब संभावित स्कोर की गणना की जाए तो यह गोलाकार दूरी का उपयोग करता है। चूंकि मैं बुरी तरह से हार रहा हूं और संकलन करने के लिए नियंत्रक नहीं मिल सकता है, मैं सिर्फ एक नई रणनीति की कोशिश कर रहा हूं, जहां मैं पिछले राउंड से सबसे खराब उपयोग करता हूं।

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

Comments

यह काम नहीं करता है। iका एक तत्व है scores.split(' '), जिसका अर्थ है कि यह एक स्ट्रिंग है, एक इंट नहीं।

— KSFT

@KSFT ओह शूट, मुझे वास्तव में परीक्षण करना चाहिए, अपडेट करना चाहिए।

— माल्टसेन

Answer 4

सबोटेजकैम्पर्स - पायथन

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)

कैंपर अभी भी जीत रहे हैं। अगर आपके पास इसके लिए कोई सुझाव है तो मुझे बताएं।

Answer 5

फाइंडकैम्पर्स - पायथन 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

Comments

Aww ... मैं उम्मीद कर रहा था कि जब मैं नाम

— देखूंगा तो कैंपरों की

जबरदस्त हंसी। मैं एक प्रविष्टि जोड़ सकता हूं जो शिविरार्थियों की तोड़फोड़ करेगा।

— जेमैक

दुर्भाग्य से, मैंने केवल प्रति व्यक्ति एक प्रविष्टि की अनुमति दी।

— केएसएफटी

मैंने सिर्फ खुद तोड़फोड़ करने वालों के लिए एक प्रविष्टि पोस्ट की।

— KSFT 16

मेरा काम नहीं करता है क्योंकि मुझे एहसास नहीं था कि पिछले परिणाम हल किए गए थे। कैंपर्स का पता कैसे चलता है?

— KSFT

Answer 6

नंबर एक, जावा

पहला जवाब। मेरे पिछले उत्तर से नकल की गई ।

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

Comments

ऐसा लगता है कि किसी ने सभी उत्तरों को ठुकरा दिया है।

— KSFT

Answer 7

WowThisGameIsSoDeep, जावा

मैंने 1 मिलियन-कोर क्लस्टर पर 10 साल के लिए खेल का विश्लेषण किया है और इष्टतम समाधान पाया है।

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

Comments

यह कोई कोड गोल्फ नहीं है

— ऑप्टिमाइज़र

वह समाधान इष्टतम नहीं है। यदि आप एक समान वितरण चाहते हैं, तो आपको उपयोग करना चाहिए Random.nextInt(int)।

— पीटर टेलर

यह हमेशा 1. वापस जाने के लिए लगता है

— KSFT

@KSFT मैंने इसका परीक्षण किया और कई अलग-अलग नंबर मिले। शायद यह सब के बाद तोड़फोड़ है?

— feersum

अहा! मैंने ठीक कर दिया! मैंने गलती से "WowThisGameIsSoDeep.py" टाइप कर दिया था, और इसे पायथन फाइल के रूप में चलाने की कोशिश कर रहा था।

— KSFT

Answer 8

सर्किलिनियर एक्सट्रैपोलॉटर, रूबी

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

Comments

यह यह त्रुटि दे रहा है:NoMethodError: undefined method `split' for #<Array:0x720f56e2> choose at CircilinearExtrapolator.rb:2

— KSFT

ओह, previous_choicesमानों की एक सरणी है ["1 6 500","2 8 503"]?

— हिस्टोक्रेट

यह है। क्या आपको लगता है कि यह कुछ और था? यदि नहीं, तो मैं शायद इसे चलाने के लिए कुछ गड़बड़ कर दिया।

— केएसएफटी

मुझे लगा कि यह सिर्फ एक फ्लैट स्ट्रिंग है, क्षमा करें। मैं संपादित करूँगा।

— हिस्टोक्रेट

संपादित। अब हर कोई जानता है कि मैंने इसे परीक्षण के बिना कुछ पोस्ट किया ...

— histocrat