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

Question

हर खिलाड़ी का एक नंबर होता है। क्या आप उन सब से सबसे दूर हो सकते हैं?

आवश्यकताएँ

जावा, पायथन 2 या रूबी फ़ंक्शन को लिखें, choose()जो तीन तर्क स्वीकार करता है:

• एक पूर्णांक - पहले से ही पूर्ण दौर की संख्या
• एक पूर्णांक - खिलाड़ियों की संख्या
• स्ट्रिंग्स की एक सरणी - प्रत्येक पिछले दौर के परिणाम
  • प्रत्येक स्ट्रिंग पूर्णांकों की एक अलग-अलग-अलग सूची होती है, जिसे सबसे कम से उच्चतम तक क्रमबद्ध किया जाता है

उदाहरण के लिए, choose(2, 4, ["4 93 93 174", "1 84 234 555"])इसका मतलब है:

• पहले से ही दो राउंड थे (यह तीसरा राउंड है)
• कुल चार खिलाड़ी हैं
• पहले दौर में, चुने गए नंबर 4, 93, 93, 174 थे
• दूसरे दौर में, चुने गए नंबर 1, 84, 234, 555 थे

आपको 1 से 999 (समावेशी) से पूरी संख्या वापस करनी होगी।

एक दूसरे खिलाड़ी के लिए, आपका स्कोर आपके नंबर और उनके बीच की दूरी का वर्गमूल है। दौर के लिए आपका स्कोर इन सभी अंकों का कुल है।

100 राउंड खेले जाएंगे। उच्चतम कुल स्कोर जीत!

नियम

• आपका कोड किसी भी I / O का उपयोग नहीं कर सकता है, जिसमें कंसोल, फाइलें, नेटवर्क आदि शामिल हैं।
• आप नियंत्रण कार्यक्रम या किसी अन्य खिलाड़ी के साथ हस्तक्षेप नहीं कर सकते।
• कार्यक्रम जो देखते हैं कि वे उपरोक्त नियमों का उल्लंघन करते हैं, को बाहर रखा जाएगा।
• किसी फ़ंक्शन की प्रत्येक कॉल को मेरे कंप्यूटर पर पांच सेकंड (इंटेल कोर आई 5 2450 एम के साथ 8 जीबी रैम) के तहत लेना चाहिए।
• यदि कोई प्रोग्राम एक अपवाद फेंकता है या एक अमान्य मान लौटाता है, तो इसे माना जाएगा जैसे कि यह 1 लौटा।
• प्रत्येक उपयोगकर्ता अधिकांश एक कार्यक्रम में प्रस्तुत कर सकता है।

विविध

• नियंत्रण कार्यक्रम GitHub पर है ।
• तीन अंतर्निहित खिलाड़ी हैं। वे इस उत्तर में पाए जा सकते हैं ।
• विजेता को 28 जनवरी को चुना जाएगा।

लीडरबोर्ड

विजेता कंजर्वेटर है ।

गैर-निरंतर रणनीति के साथ उच्चतम स्कोरिंग खिलाड़ी गुस्ताव का सम्माननीय उल्लेख ।

• कंजर्वेटर - 36226
• उच्च - 36115
• फ्लोरहुगर - 35880
• नंबरऑन - 35791
• ओवरस्टीमेटर - 35791
• गुस्ताव - 35484
• इतिहासकार - 35201
• सांपला - 34960
• इन्क्रीमेंटर - 34351
• जम्प राईटइन - 34074
• विक्रे - 34020
• किशोरी - 33907
• रांडु - 33891
• वेटलिफ्टर - 33682
• मिडिलमैन - 33647
• बाउंसइंटरवर्ड - 33529
• नैस्टमैथमेटिशियन - 33292
• जम्पर - 33244
• Copycat - 33049

पूरे परिणाम यहां देखे जा सकते हैं । (मैं पाठ रैपिंग को अक्षम करने की सलाह देता हूं।)

Comments

क्या मेरे पास यह बताने का कोई तरीका है कि उन पिछले दौरों में मेरा अपना नंबर था?

— मार्टिन एंडर

@ मार्टिनबटनर नंबर

— यपनप

मैं उन भाषाओं में से किसी को भी नहीं जानता :( क्या आप जावास्क्रिप्ट जोड़ सकते हैं? जैसे, इसे नोड के साथ चलाएं।

— Cilan

@Wobbuffet, मैं उनमें से किसी को भी नहीं जानता। मुझे पायथन में प्रवेश करने से नहीं रोका।

— मार्क

मुझे लगता है कि यह अधिक दिलचस्प होता अगर अंतरिक्ष एक सर्कल / लूप होता, ताकि 1 और 999 के बीच की दूरी 1. होती, जो कि "किनारों से" एक एकल संख्या को हर मोड़ का अनुमान लगाता "रहता, क्योंकि" किनारे "नहीं हैं" पार्क करने के लिए। स्पष्ट रूप से बहुत देर हो चुकी है, हालांकि अब बदल गया है;)

— जोबिट्स

Answer 1

पायथन, कंजर्वेटर

def choose(round, players, scores):
    return 999

चूँकि हर अपवाद 1 फेंकता है, यह उससे जितना संभव हो उतना दूर रहता है। निर्बल की कीमत पर अपना भाग्य बनाता है।

मजेदार तथ्य: मैंने इसे सुधारने के बारे में सोचा था, लेकिन एक कोने में छिपने से बेहतर तरीका नहीं मिल सकता था।

Comments

लगता है कि मैंने गलत कोना उठा लिया। :(

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

यह एक साधारण कारण के लिए अच्छा है: दूसरे आपसे दूरी को कम करने की कोशिश करते हैं। वे स्वचालित रूप से आपके स्कोर को बेहतर बनाएंगे। एक गेम चेंजर एक प्रतिद्वंद्वी होगा जो जितना संभव हो उतना आपके करीब आने की कोशिश करता है।

— मार्टिन थोमा

Eww ... पायथन में एक अर्धविराम?

— केएसएफटी

@KSFT हे, मैं अजगर पर कठोर हूँ, और मैं वैसे भी उस विशेषज्ञ के रूप में कभी नहीं रहा हूँ

— क्लैबचियो

Answer 2

नंबर एक, जावा

नाम इसे पूरी तरह से समझाता है।

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

Comments

क्यों गिरा वोट?

— TheNumberOne

मुझे विशेष रूप से यह पसंद है कि उपयोगकर्ता नाम कैसे प्रस्तुत करता है

— ब्रायन जे

Answer 3

पायथन, एंशिएंटहिस्टेरियन

दृढ़ विश्वास है कि भविष्य बिल्कुल अतीत की तरह होगा, लेकिन विश्वास करता है कि अंतिम दौर बहुत हालिया है, इसलिए यह सिर्फ 1 - 999 के माध्यम से लूप करता है और चुनता है कि पिछले दौर में सबसे अच्छा दौर क्या होगा। पहले 2 राउंड 500।

def choose(round, players, scores):
    calc = lambda n, scores: sum([abs(int(i)-n)**.5 for i in scores.split(' ')])
    return max(range(1, 1000), key=lambda n: sum([calc(n, j) for j in scores[1:]])) if round>1 else 500

Answer 4

पायथन, विक्रे

def choose(rounds, players, results):        
    if not results:
        return (id(0)/7)%999 + 1

    def best(array):
        score = lambda x: sum(abs(x-y)**.5 for y in array)
        m = max(score(x) for x in range(1, 1000))
        return [x for x in range(1, 1000) if score(x) == m]

    def second_best(array):
        array.extend(best(array))
        options = best(array)
        return options[(id(0)/7) % len(options)]

    results = [map(int, s.split()) for s in results]
    counts = {}

    for round_ in results:
        for number in round_:
            counts[number] = counts.get(number, 0) + 1

    most_common = sorted([(c, n) for n,c in counts.items()], reverse=True)
    to_avoid = [t[1] for t in most_common[:players]]

    return second_best(to_avoid)

संख्याओं की एक सूची बनाता है, जो अक्सर खेला जाता है, यह मानता है कि बाकी सभी लोग आशा के साथ खेलेंगे और ऑप्स के लिए खेलेंगे सूची में दिए गए दूसरे सर्वश्रेष्ठ विकल्प के ।

उदाहरण के लिए, यदि सबसे सामान्य संख्याएं हैं [1, 990, 999], तो विक्रि देने के लिए इष्टतम प्ले 200 सम्मिलित करता है [1, 200, 990, 999], फिर नए सरणी (जो 556 है) के लिए सबसे अच्छा विकल्प चुनता है।

Answer 5

जावा, ओवरस्टीमेटर

जैसा कि नाम से पता चलता है, यह कार्यक्रम मानता है कि अन्य सभी कार्यक्रम अंतिम दौर के आधार पर सर्वश्रेष्ठ उत्तर चुनकर "अच्छी तरह से" खेलने की कोशिश करेंगे - इसलिए यह "ओवरस्टीमेटर" हमेशा पिछले दौर के आधार पर सबसे खराब स्थिति को चुनता है ।

 public static int choose(int round, int players, String[] args) {
     String[] lastRoundStrings = args[args.length - 1].split(" ");
     int[] lastRound = new int[lastRoundStrings.length];
     int worstSelection = 0;
     for (int i = 0; i < lastRound.length; i++) {
         double worstScore = Double.MAX_VALUE;
         for (int j = 1; j < 999; j++) {
             double computedScore = score(j, lastRound);
             if (computedScore < worstScore) {
                 worstScore = computedScore;
                 worstSelection = j;
             }
         }
     }
     return worstSelection;
 }

 public static double score(int position, int[] otherPositions) {
     double total = 0;
     for (int i = 0; i < otherPositions.length; i++) {
         total += Math.sqrt(Math.abs(otherPositions[i] - position));
     }
     return total;
 }

Comments

यह कैसे आया एक निरंतर "1" खेला? क्या कोई बग था? माइंड यू, "1" खेलना काफी सफल साबित हुआ। :)

— एमिल

अफसोस की बात है कि कोड में एक बग है, हाँ - यह वास्तव में कभी भी स्कोर को पार्स नहीं करता है जो इसे अंतिम दौर से पढ़ता है। (लेकिन मुझे यह बहुत देर से पता चला और तब तक एक सबमिशन संपादित करना गलत लग रहा था, साथ ही साथ आप कहते हैं कि यह बहुत अच्छा कर रहा था ... जो भी हो: पी)

— एलेक्स वाकर

Answer 6

जावा - भारोत्तोलक

1-999 के माध्यम से पता लगाने के लिए कि प्रत्येक दौर के लिए सबसे अच्छा होगा। उन्हें पुनरावृत्ति के अनुसार वजन (हाल के दौर में अधिक वजन होता है), और इसका सबसे अच्छा समग्र अनुमान देता है। उम्मीद है कि यदि पैटर्न बाद के दौर में बनते हैं, तो यह उस पर लेने में सक्षम होगा।

संपादित करें: अब + Inf% अधिक पुनरावृत्ति के साथ! स्टोर करने / सहेजने / देखने में सक्षम नहीं होने के कारण आपने पिछले राउंड पर जो चुना वह एक ड्रैग है। अपने खुद के इनपुट को ध्यान में रखते हुए आपको गड़बड़ कर देता है जब दूसरों को यह पता लगाने की कोशिश की जाती है लोग करने जा रहे हैं। तो, यह गणना करते हैं! यह अब यह पता लगाने के लिए फिर से शुरू होगा कि उसने पिछले दौर में क्या चुना और अगले कदम की गणना करते समय उसे अनदेखा कर दिया।

ध्यान दें कि यह वास्तव में अंतिम मोड़ से केवल अपने स्वयं के इनपुट को अनदेखा करता है, लेकिन चूंकि यह सबसे अधिक भारित होता है, इसलिए यह ठीक काम करता है। यह थोड़ा और काम के साथ तय किया जा सकता है, लेकिन मैं लीडरबोर्ड की प्रतीक्षा करूंगा कि क्या इसकी आवश्यकता है।

int choose(int rounds, int players, String[] hist){
    if(rounds < 1)
        return 1;

    int lastChoice = choose(rounds-1,players,java.util.Arrays.copyOf(hist, hist.length-1));

    int[][] history = new int[hist.length][players];
    for(int i=0;i<hist.length;i++){
        String[] tokens = hist[i].split(" ");
        boolean flag = false;
        for(int j=0;j<tokens.length;j++){
            history[i][j] = Integer.parseInt(tokens[j]);
            if(i==history.length-1 && history[i][j]==lastChoice && !flag){
                flag = true;
                history[i][j] = -1;
            }
        }
    }

    double best = 0;
    int guess = 1;
    for(int i=1;i<1000;i++){
        double score = 0;
        for(int j=0;j<history.length;j++){
            double weight = (double)(j+1)/history.length;
            for(int k=0;k<history[j].length;k++){
                if(history[j][k] > 0)
                    score += Math.sqrt(Math.abs(history[j][k]-i)) * weight;
            }
        }
        if(score > best){
            best = score;
            guess = i;
        }
    }
    return guess;
}

Comments

नोट: यहां तक ​​कि 100 के दौर में, यह मेरे कुछ हद तक धीमी पीसी पर एक सेकंड के भीतर पूरा होता है। यदि किसी कारण से यह आपके लिए बहुत लंबा है, तो मुझे बताएं ताकि मैं पुनरावृत्ति को सीमित कर सकूं।

— ज्योबिट्स

यह मेरी मशीन पर भी बहुत तेज है।

— यपनीपं

Answer 7

रूबी, Copycat

पिछली बार जो भी जीता है, बस रिटर्न।

def choose r, p, hist
  last = hist.last.split.map &:to_i
  scores = last.map{|n| last.map{|m| (n-m).abs ** 0.5 }.inject :+ }
  last[scores.index scores.max]
end

Comments

यह पहले दौर के लिए क्या लौटाता है? ओह कोई बात नहीं। अपवादों की वापसी होगी 1.

— mbomb007

Answer 8

रूबी, जंप राईट.इन

def choose(round, players, args)
    return 500 if args.size == 0
    last_round = args[-1].split.map(&:to_i) + [1000]
    max_gap = 0
    last = 0
    move = 1
    last_round.each { |i|
        gap = i - last - 1
        if gap > max_gap
            max_gap = gap
            move = (i + last)/2
        end
        last = i
    }
    move
end

यह शायद सबसे सीधे-सीधे आगे की रणनीति है। यह अंतिम राउंड में सबसे बड़ा अंतर पाता है, और उस गैप के बीच में नंबर को सही चुनता है।

Comments

यह पहले दौर के लिए क्या लौटाता है? 1?

— mbomb007

@ mbomb007 ओह, मैं हमेशा इन पेसकी शुरुआती दौर को भूल जाता हूं। धन्यवाद, यह अब 500 लौटाता है।

— मार्टिन एंडर

Answer 9

गुस्ताव (पायथन 2)

यह एक बहुत ही सीधे आगे मेटा रणनीति है, बेशर्मी से मेरे पुराने उत्तरों में से एक की नकल की गई है एक समान कोठ चुनौती में में से एक। यह कुछ सरल रणनीतियों पर विचार करता है, यह देखता है कि उन्होंने पिछले सभी दौरों में कैसा प्रदर्शन किया होगा, और फिर अगले दौर के लिए उच्चतम स्कोरिंग का अनुसरण करेंगे।

def choose(k, N, h):
    if k<2: return 999
    H = [[int(x) for x in l.split()] for l in h]
    score = lambda x,l: sum(abs(x-y)**.5 for y in l)
    S = [range(1,1000)
         + [max(range(1,1000), key=lambda x: score(x, H[i-1]))]
         + [max(range(1,1000), key=lambda x: score(x, H[i-2]))]
         + [min(range(1,1000), key=lambda x: score(x, H[i-1]))]
         + [min(range(1,1000), key=lambda x: score(x, H[i-2]))]
         for i in range(2,k+1)]
    scores = [sum(score(s[j],l) for s,l in zip(S[:-1], H[2:]))
              for j in range(len(S[0]))]
    return max(zip(scores, S[-1]))[1]

मुझे अब एहसास हुआ कि एल्गोरिथ्म में अभी भी कुछ खामियां हैं। उदाहरण के लिए, यह "खुद का पीछा करना" रख सकता है क्योंकि यह विरोधियों के अपने स्वयं के चाल को अलग नहीं करता है। हालाँकि, मैं इसे अभी के लिए ऐसे ही छोड़ दूँगा।

Answer 10

अजगर, राजद

अब तक के सबसे अचंभित यादृच्छिक संख्या जनरेटर द्वारा चुने गए नंबर ।

def choose(round, players, scores):
    x = 15
    for i in range(round * players + 1):
        x = (x * 65539) % 2147483648
    y = int((x / 2147483648.0) * 999.0)+1
    return y

Answer 11

निम्नलिखित तीन कार्यक्रम अंतर्निहित हैं।

उच्च (रूबी)

def choose(round, players, args)
    return 990
end

इन्क्रीमेंटर (जावा)

public static int choose(int round, int players, String[] args) {
    return round * 10 + 5;
}

फ़्लोरहुगर (पायथन)

def choose(round, players, args):
    if len(args) == 0:
        return 10
    last = args[-1].split();

# next line from http://stackoverflow.com/a/7368801/3148067
    last = map(int, last)

    dist = 0
    for i in range(1, 999):
        if i in last:
            dist = 0
        else:
            dist = dist + 1
            if dist == 10:
                return i
    return 500

Answer 12

अजगर, सांपला

स्थानों की एक सूची में से, पिछली बारी की अनदेखी करते हुए, हाल ही में उपयोग किए गए नंबरों से सबसे दूर का चयन करें।

def choose(turn, players, history):
    sample = map(int, (' '.join( history[-5:-1] )).split())
    def distance(x): return sum(abs(x-y)**0.5 for y in sample)
    places = range(1, 1000, 13)
    score, place = max((distance(x), x) for x in places)
    return place

Answer 13

Java, BounceInwards

1 से शुरू होकर, यह उच्च और निम्न विकल्प के बीच उछलते हुए धीरे-धीरे 500 के करीब पहुंच जाता है।

public static int choose(int round, int players, String[] args) {
    return round%2 == 0 ? round * 5 : 1000 - round * 5;
}

Answer 14

NastyMathematician (Java)

अंतिम दो राउंड की जांच करता है (यदि सबसे अच्छी संख्या 70 और 80 थी, तो यह 90 का उत्पादन करेगा)। यह बुरा है क्योंकि यह अपने विरोधियों के खिलाफ जीतने के लिए यथासंभव उच्च संख्या लेने की कोशिश करता है।

public static int choose(int round, int players, String[] args) {
    if (round == 0) {
        return 999;
    }

    int[][] results = new int[args.length][players];

    // parse input
    for (int i = 0; i < args.length; i++) {
        String[] rounds = args[i].split(" ");
        for (int j = 0; j < rounds.length; j++) {
            results[i][j] = Integer.parseInt(rounds[j]);
        }
    }

    int bestNumber = 0;
    double bestScore = -1;

    // get the best number for the last round
    for (int i = 1; i < 1000; i++) {
        double score = 0;
        for (int result : results[results.length - 1]) {
            score += Math.sqrt(Math.abs(i - result));
        }
        if (score >= bestScore) {
            bestScore = score;
            bestNumber = i;
        }
    }

    if (round == 1) {
        return bestNumber;
    }

    int bestNumber2 = 0;
    double bestScore2 = -1;

    // get the best number for the second last round
    for (int i = 1; i < 1000; i++) {
        double score = 0;
        for (int result : results[results.length - 2]) {
            score += Math.sqrt(Math.abs(i - result));
        }
        if (score > bestScore2) {
            bestScore2 = score;
            bestNumber2 = i;
        }
    }

    // add the difference between last round and second last round to get this rounds best number
    int difference = bestNumber - bestNumber2;
    bestNumber = bestNumber + difference;

    return bestNumber > 999 ? 999 : bestNumber;
}

Answer 15

अजगर - मैं एक नाम नहीं सोचना चाहता ...

यदि पिछले राउंड्स में चुने गए अंकों का औसत 500 से कम है, तो यह 999 है। यह 1 अन्यथा चुनता है।

def choose(a,b,c):
    total=0
    for i in c:
        for j in i.split(" "):
            total+=int(i)
    average=total/(a*b)
    if average<500:
        return 999
    return 1

Answer 16

पायथन, मिडिलमैन (@clabacchio द्वारा संरक्षक के आधार पर)

def choose(round, players, scores):
    return 500;

जब मैंने देखा कि ऊपरी किनारे का स्कोर ऊंचा है (और निचले किनारे से आगे निकल गया है), मैंने सोचा कि क्या बीच में पकड़े जाने से बुरा कुछ हो सकता है।

Answer 17

जम्पर (रूबी)

def choose(round, players, args)
    495*(round%3)+5
end

नीचे, मध्य और शीर्ष के बीच वैकल्पिक। (5,500,995)