नोट: समुदाय के पसंदीदा के लिए सर्वेक्षण जल्द ही जारी किया जाएगा

इस KoTH में, उद्देश्य जीवित रहने वाले अंतिम बॉट होना है। सिक्के यादृच्छिक क्षेत्रों में रखे जाएंगे, और आपके बॉट को पहले सिक्के प्राप्त करने होंगे। यदि एक बॉट दूसरे बॉट में चलता है, तो बॉट अधिक सिक्के जीतता है, और दूसरा बॉट मर जाता है। अधिक विवरण नीचे।

सिक्के के प्रकार

2 प्रकार के सिक्के होंगे: सोना और चांदी। सोना बॉट की ताकत में 5 सिक्के जोड़ता है, और चांदी 2 जोड़ता है। एक बार एक सिक्का एकत्र करने के बाद, दूसरे सिक्के को बोर्ड पर दूसरे स्थान पर रखा जाता है। किसी भी समय, अखाड़े में एक सोने का सिक्का और चार चांदी के सिक्के हैं।

टक्कर मार दी

एक ही स्थान पर कब्जा करने की कोशिश करने वाले दो बॉट की स्थिति में, अधिक सिक्कों वाला व्यक्ति रहेगा, और कम इच्छा वाले व्यक्ति ... नहीं। जीतने वाले बॉट को 85% प्रतिद्वंद्वी सिक्के (गोल ऊपर) प्राप्त होंगे। यदि वे बंधे होते हैं, तो दोनों मर जाते हैं। यदि तीन या अधिक एक ही स्थान पर कब्जा करने की कोशिश करते हैं, तो सबसे शक्तिशाली जीतता है, और अन्य सभी बॉट के सिक्कों का 85% प्राप्त करता है। इस घटना में कि सबसे शक्तिशाली बॉट एक टाई है, सभी बॉट मर जाते हैं जिन्होंने अंतरिक्ष में प्रवेश करने की कोशिश की।

अखाड़ा

क्षेत्र की लंबाई के साथ गणना की जाती है 4 + botCount। खेल की शुरुआत में बॉट्स रखते समय, यादृच्छिक स्थानों को चुना जाता है। प्रणाली यह सुनिश्चित करती है कि कोई बॉट एक ही स्थान पर, या एक दूसरे के बगल में शुरू न हो। सिक्के प्रत्येक बॉट पर केंद्रित 3 से 3 वर्ग को छोड़कर, यादृच्छिक रूप से उत्पन्न होते हैं। यदि अखाड़े के बाहर एक बॉट पाया जाता है, तो यह तुरंत मर जाता है। ऊपरी बाएँ कोने में अखाड़ा शुरू होता है (0,0), या उत्तर-पश्चिम में, और एक बॉट का स्थान हमेशा एक पूर्णांक होता है।

आपका बॉट

आपका बॉट किसी भी ऑब्जेक्ट ओरिएंटेड भाषा में एक फ़ंक्शन होना चाहिए, जिसमें एरे, पूर्णांक, स्ट्रिंग्स और फ़ंक्शन हैं। ध्यान दें कि चीजों को सरल बनाने के लिए सभी सबमिशन को जावास्क्रिप्ट में बदल दिया जाएगा। चाल, उपयोग botNotes.storeData(key, value)और के बीच जानकारी संग्रहीत करने के लिए botNotes.getData(key, value)। आप डेटा को किसी भी तरह से स्टोर या एक्सेस नहीं कर सकते हैं, इसके अलावा जो मापदंडों और के माध्यम से प्रदान किया जाता है botNotes। आप एक समारोह है कि, जब कहा जाता है, एक स्ट्रिंग रिटर्न बनाना चाहिए north, east, south, westया, none। समारोह के लिए 3 तर्क होंगे:

चार पूर्णांक (के साथ एक वस्तु locationX, locationY, coins, arenaLength), अपने वर्तमान स्थान, अपने सिक्के, और मैदान की लंबाई
एक्स और वाई के साथ एक बहुआयामी सरणी अन्य बॉट के निर्देशांक, और उनके सिक्के की गिनती, पूर्व-[[0,5,4],[4,7,1],[7,4,12]]
सूचीबद्ध सिक्के स्थानों के साथ एक सरणी (सोना हमेशा पहले होता है)

यह पहाड़ी चुनौती का एक राजा है, मानक Loopholes निषिद्ध है। आपका फ़ंक्शन कई हजार बार चलाया जाएगा, हर बार एक "मूव" की अनुमति दी जाएगी। ध्यान दें कि यदि खेल 20,000 चालों से अधिक है , तो सबसे अधिक सिक्कों वाला बॉट जीतता है। यादृच्छिकता को दूर करने के लिए यह 8,000 बार किया जाएगा।

टोकन: https://chat.stackexchange.com/rooms/81347/gold-collectors-koth

पुरस्कार:

पहला स्थान: 100-पॉइंट बाउंटी
समुदाय पसंदीदा: 15-पॉइंट स्वीकृत उत्तर

विजेता:

पहला स्थान: टीबीटीपीटीजीसीबीसीबीए
दूसरा स्थान: बिग किंग लिटिल हिल
तीसरा स्थान: संभावित रूप से विक्टरियस
चौथा स्थान: विनम्र पास-दृष्टि वाले नशे में बॉट
पांचवें स्थान: सुरक्षा सिक्का

king-of-the-hill

— Redwolf कार्यक्रम
स्रोत

6

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

— लकोनी

21

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

— स्किड्सदेव

2

इसका एक संस्करण जहां आप स्थिति के बजाय त्वरण को नियंत्रित करते हैं वह बहुत अच्छा होगा।

— एकोजी

12

हर किसी के लिए: पहले से ही बहुत सारी टिप्पणियां हैं। बेकार टिप्पणी जैसे "+1, अच्छा बॉट" न छोड़ें , और यदि यह बेमानी है तो कृपया अपनी टिप्पणी हटा दें । हम एक सामान्य प्रश्नोत्तर साइट नहीं हैं, लेकिन कोई भी सैकड़ों कमांड पढ़ना पसंद नहीं करता है।

— user202729

5

(मेरे अपने प्रश्न के अनुसार): चैट में एनपी के अनुसार, यह बाद की बात है: सभी बॉट चलते हैं, फिर सभी टकराव हल हो जाते हैं, फिर सभी सिक्का पिकअप होते हैं, फिर सभी नए सिक्के रखे जाते हैं।

— ब्राडकास्ट

26

बैटबोट - जावास्क्रिप्ट नोड.जेएस

अगर आप कभी पकड़ नहीं सकते तो पीछा करना या भागना क्यों परेशान करते हैं? इसके बजाय, बैटबॉट सबसे पास का सिक्का ढूंढता है और कमजोर बॉट का इंतजार भी करता है। जब वे दोनों आसन्न होते हैं, तो बिटबोट सिक्का के लिए चला जाता है, यह मानते हुए कि कमजोर बॉट भी होगा। यदि बैटबॉट प्रतीक्षा कर रहा है और एक मजबूत बॉट पहुंचता है, तो वह बस सिक्का और स्केडैडल्स को पकड़ लेता है। मुझे आजमाओ!

function baitBot(me, others, coins) {
  let directions = ['none','east','south','west','north']
  function distanceTo(a) {
    return (Math.abs(a[0] - me.locationX) + Math.abs(a[1] - me.locationY))
  }
  function distanceBetween(a, b){
    return (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]))
  }
  function adjacentDir(a) {
    //0 = no, 1,2,3,4 = ESWN
    if(distanceTo(a) == 1) {
      if(a[0] > me.locationX){ return 1}
      else if(a[0] < me.locationX) {return 3}
      else if(a[1] > me.locationY) {return 2}
      else{ return 4}
    }
    else {return 0}
  }
  function edibility(a) {
    return me.coins - a[2]
  }

  //Find nearest coin and get next to it
  let closestCoin = coins.sort((a,b) => distanceTo(a) - distanceTo(b))[0]
  if(distanceTo(closestCoin) > 1) {
    if(closestCoin[0] > me.locationX){ return 'east'}
    else if(closestCoin[0] < me.locationX){ return 'west'}
    else if(closestCoin[1] < me.locationY){ return 'north'}
    else if(closestCoin[1] > me.locationY){ return 'south'}
  }

  //If we're next to a coin and there's a threat close, just grab it
  let nearestThreat = others.filter(a => edibility(a) < 0).sort((a,b) => distanceBetween(a, closestCoin) - distanceBetween(b, closestCoin))[0]
  if(nearestThreat && distanceBetween(nearestThreat, closestCoin) <= 2) {
    return directions[adjacentDir(closestCoin)]
  }



  //Otherwise, wait until there's a target also next to the coin. If none are close, just take it
  let targets = others.filter(a => edibility(a) > 0 && distanceBetween(closestCoin, a) <= 3)
  targets.sort((a,b) => distanceBetween(a, closestCoin) - distanceBetween(b, closestCoin))
  if(targets.length > 0 && distanceBetween(targets[0], closestCoin) > 1){
    return directions[0]
  }
  return directions[adjacentDir(closestCoin)]

}

— कैन
स्रोत

1

हा, यह एक साफ विचार है, मुझे यह पसंद है।

— सूंदर

यह दृष्टिकोण बहुत अच्छा है ... नहीं, बहुत अच्छा है

— Redwolf कार्यक्रम

1

बैटबॉट की जरूरत nearestThreat && distanceTo(nearestThreat)सिर्फ इसके बजाय है distanceTo(nearestThreat)। कोई खतरा नहीं होने पर यह विफल हो जाता है।

— रेडवुल्फ कार्यक्रम

1

हाँ, nearestThreatहै undefinedयदि अन्य सभी बॉट तुम्हारा की तुलना में अधिक अंक हैं।

— Night2

1

खैर, मुझे [10] Bot Bait Bot tired of this world, and jumped off its edgeमेरे इवेंट लॉग में नोटिस मिलता है

— रेडवॉल्फ प्रोग्राम्स

17

संभावित रूप से विजयी | जावास्क्रिप्ट

इस बॉट के लिए पसंदीदा रंग है #1600a6।

function (me, others, coins)
{
    let huntingTimer = botNotes.getData("huntingTimer");
    let huntedIndex = botNotes.getData("huntedIndex");
    if(!huntingTimer)
    huntingTimer = 0;
    else if(huntingTimer >0)
    huntingTimer--;
    else if(huntingTimer == -1)
    huntingTimer = Math.ceil(20*(1+Math.log2(me.coins/25)));
    else
    huntingTimer++;

    function distanceFromMe(X, Y) { return Math.abs(me.locationX - X) + Math.abs(me.locationY - Y); }

    function U(x, y)
    {
    function distance(X, Y) { return Math.abs(X-x) + Math.abs(Y-y); }
    function gravitation(k, X, Y) { return - k / ( distance(X, Y) + .2 ); }
    function exponential(k, q, X, Y) { return - 5*k * Math.exp(- q * distance(X,Y)); }

    // No going away from the arena.
    if(!((0 <= x) && (x < me.arenaLength) && (0 <= y) && (y < me.arenaLength)))
    {
        return Infinity;
    }

    let reachability = [1, 1, 1, 1, 1];
    let distances = coins.map(c => distanceFromMe(c[0], c[1]));
    for(let i = 0; i < others.length; i++)
    {
        for(let coin = 0; coin < 5; coin++)
            reachability[coin] += (Math.abs(others[i][0] - coins[coin][0]) + Math.abs(others[i][1] - coins[coin][1])) < distances[coin];
    }

    let potential = gravitation(40, coins[0][0], coins[0][1]) / (reachability[0]); // Gold

    // Silver
    for(let i = 1; i < 5; i++)
    {
        potential += gravitation(10, coins[i][0], coins[i][1]) / (reachability[i]);
    }

    others.sort((a, b) => b[2] - a[2]);

    // Other bots
    for(let i = 0; i < others.length; i++)
    {
        if(
            ((Math.abs(me.locationX - others[i][0]) + Math.abs(me.locationY - others[i][1])) < 3) &&
            (huntingTimer == 0) &&
            (me.coins > 25) && 
            (me.coins < (others[0][2]*.9)) &&
            (others[i][2] < me.coins-5) && (others[i][2] >= 10)
        )
        {
            huntingTimer = -10;
            huntedIndex = i;
        }

        if((huntingTimer < 0) && (huntedIndex == i))
           potential += exponential(30, 1, others[i][0], others[i][1]);

        if(others[i][2] >= me.coins)
        {
        // Otherwise, they could eat us, and we will avoid them.
        potential += exponential(-1400, 3, others[i][0], others[i][1]);
        }
    }

    return potential;
    }

    // All possible squares we can move to, with their names.
    let movements = [
    [ "north", U(me.locationX, me.locationY - 1)],
    [ "south", U(me.locationX, me.locationY + 1)],
    [ "east", U(me.locationX + 1, me.locationY)],
    [ "west", U(me.locationX - 1, me.locationY)],
    [ "none", U(me.locationX, me.locationY)]
    ];

    botNotes.storeData("huntingTimer", huntingTimer);
    botNotes.storeData("huntedIndex", huntedIndex);

    // Sort them according to the potential U and go wherever the potential is lowest.
    movements.sort((a, b) => a[1] - b[1]);
    return movements[0][0];
}

(मैला स्वरूपण के लिए क्षमा याचना, इस साइट के लिए 4 रिक्त स्थान इंडेंटेशन टैब का उपयोग करने के मेरे रिवाज के साथ अच्छी तरह से नहीं जाता है।)

किसी तरह स्पष्टीकरण

मैं यहाँ सूत्रों के स्पष्टीकरण को अद्यतन करने के प्रयास में इस्तीफा देता हूँ। गुणांक लगातार बदल रहे हैं और स्पष्टीकरण को बनाए रखना कठिन है। तो मैं सिर्फ सामान्य सिद्धांत की व्याख्या करूंगा।

प्रत्येक सिक्का और प्रत्येक बॉट कुछ क्षमता के साथ एक बल क्षेत्र उत्पन्न करता है। मैं बस हर चीज से क्षमता जोड़ता हूं और बॉट फिर जहां भी क्षमता सबसे कम है, वहां जाता है। (जाहिर है कि यह विचार भौतिकी से चुराया गया है।)

मैं दो तरह की संभावनाओं का उपयोग करता हूं। पहला एक छद्म गुरुत्वाकर्षण वाला (जो किसी भी सीमा पर कार्य करता है), कश्मीर एक क्षेत्र के "शक्ति" है, और, संकेत के इस विकल्प के साथ, संभावित आकर्षक है। यहाँ r (और हर जगह) टेक्सी मेट्रिक में दूरी है, r = | x₁ - x₂ | + | y₂ - y₂ | ।

यू = - \frac{क}{आर + \frac{1}{5}} \cdot \frac{1}{1 + n} ।

$U = - \frac{k}{r + \frac 1 5} \cdot \frac{1}{1 + n}.$

मैं सोने के सिक्कों के लिए k = 40 और चांदी के सिक्कों के लिए k = 10 का उपयोग करता हूं । n बॉट्स की संख्या है जो हम से विशेष सिक्के के करीब हैं। अन्यथा, हम अन्य बॉट्स को बिल्कुल अनदेखा करते हैं (यदि हम एक मजबूत बॉट के रास्ते में आते हैं, तो हम भाग जाते हैं, लेकिन यह है)। मैं सोने के सिक्कों को उनके मूल्य से अधिक मूल्य देता हूं क्योंकि अन्यथा बॉट जो मुख्य रूप से सोने के बाद हर समय मुझे हराते हैं।

दूसरी क्षमता एक घातीय क्षय है (जो प्रभावी रूप से केवल बहुत कम दूरी पर कार्य करता है)। यह अन्य, मुख्य रूप से अधिक शक्तिशाली, बॉट द्वारा उत्पन्न होता है।

ये साथ एक क्षेत्र का उत्पादन करते हैं यह बल 0-1 की सीमा में निषेधात्मक रूप से मजबूत है, लेकिन बड़ी दूरी पर लगभग कुछ भी नहीं होने का फैसला करता है। (दूरी + 1 का अर्थ है 1/20 में बल काटना।)

यू = - 5 \times 1400 इ^{- 3 आर} ।

$U = -5 \times 1400 e^{-3r}.$

हम आम तौर पर अन्य बॉट्स पर जानबूझकर हमला नहीं करते हैं (बेशक अगर वे हमारे रास्ते में आते हैं और हम उन पर कदम रखते हैं, तो यह उनकी गलती है), लेकिन ऐसा करने की संभावना है। यदि कुछ कठोर शर्तें पूरी हो जाती हैं, तो हम एक ही बॉट पर ध्यान केंद्रित करते हुए शिकार मोड में प्रवेश कर सकते हैं । शिकार मोड में प्रवेश करने के लिए:

हमारे पास कम से कम 25 सिक्के होने चाहिए। (हमें पहले कुछ सिक्के प्राप्त करने की आवश्यकता है।)
उनके पास अधिकतम (हमारे सिक्के - 5) सिक्के और कम से कम 10 सिक्के होने चाहिए। (हम किसी ऐसे व्यक्ति का शिकार नहीं करना चाहते हैं जो एक सिक्के को पकड़ता है और अचानक अधिक शक्तिशाली है, और हम शून्य-सिक्के के बॉट का भी पीछा नहीं करना चाहते हैं।)
हमें वर्तमान में अग्रणी बॉट के पीछे कम से कम 1/10 उसके सिक्कों से पिछड़ना चाहिए। (आपको किसी चीज़ का शिकार करने के लिए भाग्यशाली होने की ज़रूरत है, इसलिए हमारी किस्मत आज़माने के लिए एक अच्छी स्थिति देने की ज़रूरत नहीं है।)
हमें शिकार कोल्डडाउन पर नहीं होना चाहिए (नीचे देखें)।

यदि ये सभी संतुष्ट हैं, तो शिकार मोड सक्रिय है। अगले 10 राउंड के लिए, शिकार किए गए बॉट केवल संभावित उत्सर्जन करते हैं इन 10 राउंड के बीत जाने के बाद, हम शिकार कोल्डाउन में प्रवेश करते हैं, जिसके दौरान हम फिर से शिकार मोड में प्रवेश नहीं कर सकते हैं। (यह कि हमें एक बॉट का पीछा करने से रोकना चाहिए और एक-एक बॉट का पीछा करना चाहिए, जबकि अन्य सभी प्रसन्नतापूर्वक सिक्कों को पकड़ते हैं।) जब हमारे पास 25 सिक्के होते हैं, तो शिकार का कोल्ड 20 चक्कर लगाता है, और उसके दोगुने प्रति 20 सिक्कों की वृद्धि होती है। (दूसरे शब्दों में, cooldown है ।) (हम इसका उपयोग करते हैं क्योंकि एंडगेम में, सभी शिकार करने वाले बॉट सबसे अधिक संभावित मृत हैं, और इसलिए किसी भी शिकार में सबसे अधिक संभावना व्यर्थ होगी। इस वजह से, हम व्यर्थ समय को सीमित करना चाहते हैं। लेकिन कभी-कभी, एक भाग्यशाली देर से खेल खाने से सब कुछ बदल सकता है, इसलिए हम संभावना रखते हैं।)

यू = - 150 इ^{- आर} ।

$U = -150 e^{-r}.$ 20(1 + log2(c / 25))

अंत में, पूरे क्षेत्र को एक असीम क्षमता वाले कुएं में रखा जाता है जो बॉट को भागने से रोकता है।

— Ramillies
स्रोत

मुझे लगता है कि यह बॉट शायद मेरे भारित आंदोलन को भी मात देता है।

— f --n

@ f @n—tɪk - तो मैं: - करता हूं। मुझे लगता है कि यह एक दूसरे बॉट को काफी बेहतर तरीके से संभाल सकता है। (इसके अलावा यह एक आसन्न वर्ग में एक सिक्का द्वारा "अंधा" नहीं किया गया है।) लेकिन मैंने आपको निश्चित रूप से +1 दिया क्योंकि मैं इस विचार का बहुत बड़ा प्रशंसक हूं।

— रामलीज

क्या आप इसके लिए कम से कम कार्रवाई के सिद्धांत को लागू कर सकते हैं?

— बीटा डेके

@ बेताडे: मैं काफी डरता हूं, पथरी इस तरह की समस्याओं का सामना करने के लिए अच्छी प्रतिक्रिया नहीं देती है। यहां तक कि निरंतर मामले में यह तुच्छ नहीं होगा (वेग के निश्चित परिमाण के कारण), लेकिन यह कुछ ध्रुवीय निर्देशांक जादू के बाद संभव हो सकता है जो मुझे लगता है।

— रामलीज

4

यह अच्छा है। मुझे यकीन नहीं है कि जोखिम नीरसता से दूरी से संबंधित है, हालांकि ऐसा लगता है कि एक खतरा 2 रिक्त स्थान है जो आपको एक आसन्न से मारने की अधिक संभावना है, क्योंकि बाद के मामले में आप में से एक को टक्कर होने के लिए स्थिर रहने की आवश्यकता होती है।

— Cain

16

फर्स्ट जेन लर्निंग एल्गोरिथम | जावास्क्रिप्ट (Node.js)

function run() {
	return ['north','east','south','west'][(Math.random()*4)|0];
}

इसे ऑनलाइन आज़माएं!

क्या आपने कभी गेम खेलने के लिए सीखने के एल्गोरिदम के उन टाइमलैप्स को देखा है? वे अक्सर पहले कुछ पीढ़ियों में लगभग यादृच्छिक रूप से आगे बढ़ते हैं ...

— Skidsdev
स्रोत

LOL ... यह अभी भी काम कर सकता है!

— रेडवॉल्फ कार्यक्रम

2

अधिकांश लर्निंग एल्गोरिदम पहले कुछ पुनरावृत्तियों के लिए शाब्दिक रूप से यादृच्छिक रूप से काम करते हैं, न कि लगभग यादृच्छिक रूप से।

— f --n 16tɪk 16

अंदाज़ा लगाओ? इस बॉट को औसतन लगभग 0.22 सिक्के प्रति राउंड मिले!

— रेडवुल्फ कार्यक्रम

16

बिग किंग लिटिल हिल | जावास्क्रिप्ट

function BigKingLittleHill(me, enemies, coins) {

	
	// Is a move safe to execute?
	function isItSafe(x){
			let loc = [x[0] + me.locationX,x[1] + me.locationY];
			return loc[0] >= 0 && loc[0] < me.arenaLength
			&& loc[1] >= 0 && loc[1] < me.arenaLength
			&& enemies
					.filter(enemy => me.coins <= enemy[2])
					.filter(enemy => getDist(enemy,loc) == 1).length === 0;
	}

	
	// Dumb conversion of relative coord to direction string
	function coordToString(coord){
		if (coord[0] == 0 && coord[1] == 0) return 'none';
		if (Math.abs(coord[0]) > Math.abs(coord[1]))
			return coord[0] < 0 ? 'west' : 'east';
		return coord[1] < 0 ? 'north' : 'south';
	}
	
	
	// Calculate a square's zone of control
	function getZOC(x) {
		let n = 0;
		for(let i = 0; i < me.arenaLength;i++){
			for(let j = 0; j < me.arenaLength;j++){
				if (doesAControlB(x, [i,j])) n++;
			}
		}
		return n;
	}
	
	function doesAControlB(a, b) {
		return getEnemyDist(b) > getDist(a, b);
	}
  
	// Distance to nearest enemy
	function getEnemyDist(x) {
			return enemies.filter(enemy => enemy[2] >= me.coins/50).map(enemy => getWeightedDist(enemy, x)).reduce((accumulator, current) => Math.min(accumulator, current));
	}
  
	// Weights distance by whether enemy is weaker or stronger
	function getWeightedDist(enemy, pos) {
		return getDist(enemy, pos) + (enemy[2] < me.coins ? 1 : 0);
	}
  
	function getDist(a, b){
		return (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]))
	}
	
	//check whether there are coins in our Zone of Control, if yes move towards the closest one
	let loc = [me.locationX,me.locationY];
	let sortedCoins = coins.sort((a,b) => getDist(loc,a) - getDist(loc,b));
	for (let coin of sortedCoins) {
		if (doesAControlB(loc,coin)){
			return coordToString([coin[0] - loc[0],coin[1] - loc[1]]);
		}
	}
	
	//sort moves by how they increase our Zone of Control
	northZOC = [[0,-1], getZOC([loc[0],loc[1]-1])];
	southZOC = [[0,1], getZOC([loc[0],loc[1]+1])];
	westZOC = [[-1,0], getZOC([loc[0]-1,loc[1]])];
	eastZOC = [[1,0], getZOC([loc[0]+1,loc[1]])];
	noneZOC = [[0,0], getZOC([loc[0],loc[1]])];
	let moves = [northZOC,southZOC,westZOC,eastZOC,noneZOC].sort((a,b) => b[1] - a[1]);
	
	//check whether these moves are safe and make the highest priority safe move
	for (let move of moves) {
		if (isItSafe(move[0])) { 
			return coordToString(move[0]);
		}
	}
	//no moves are safe (uh oh!), return the highest priority
	return coordToString(moves[0][0])
}

इसे ऑनलाइन आज़माएं!

बिग किंग लिटिल हिल "नियंत्रण के क्षेत्रों" के आधार पर निर्णय लेता है। यह केवल उन सिक्कों का पीछा करेगा जो इसके नियंत्रण के क्षेत्र में हैं अर्थात यह किसी अन्य बॉट से पहले सिक्के तक पहुंच सकता है। जब इसके नियंत्रण के क्षेत्र में कोई सिक्के नहीं होते हैं, तो इसके नियंत्रण के क्षेत्र के आकार को अधिकतम करने के लिए आगे बढ़ता है। बिग किंग लिटिल हिल अपने 5 संभावित चालों में से प्रत्येक के नियंत्रण के क्षेत्र की गणना करता है और उन चालों का पक्ष लेता है जो उसके नियंत्रण के क्षेत्र के आकार को अधिकतम करते हैं। इस तरह, बिग किंग लिटिल हिल अंततः नियंत्रण के एक स्थानीय अधिकतम (छोटी पहाड़ी) पर पहुंच जाता है और अपने क्षेत्र के भीतर एक सिक्के के उत्पन्न होने का इंतजार करता है। इसके अतिरिक्त, बिग किंग लिटिल हिल किसी भी कदम को खारिज कर देता है, जिसके परिणामस्वरूप उसकी मृत्यु हो सकती है जब तक कि कोई विकल्प न हो।

बिग किंग लिटिल हिल एक निराशावादी है (यह शब्द यथार्थवादी शब्द को पसंद करता है) क्योंकि यह किसी भी सिक्के को लेने के लिए परेशान नहीं करता है जो इसे प्राप्त करने का आश्वासन नहीं है। यह भी एक शांतिवादी है कि यह किसी भी मायने में कमजोर बॉट का पीछा नहीं करता है (हालांकि अगर वे रास्ते में मिलते हैं तो यह एक कदम हो सकता है)। अंत में, बिग किंग लिटिल हिल एक कायर है जो किसी भी इनाम के लिए अपने स्वयं के जीवन को खतरे में नहीं डालेगा जब तक कि यह पूरी तरह से न हो।

— माइक निकोल्स
स्रोत

1

PPCG में आपका स्वागत है! यह एक बहुत अच्छा बॉट = डी

— लुइस फेलिप डी जेउस मुनोज़

यह मैं एक बॉट के लिए सोच रहा था। बहुत बढ़िया।

— जो।

10

सुरक्षा सिक्का | जावास्क्रिप्ट

SafetyCoin=(myself,others,coins)=>{
  x=myself.locationX;
  y=myself.locationY;
  power=myself.coins;
  arenaSize=myself.arenaLength;
  dist=0;
  optimalCoin=7;
  optimalDist=11*arenaSize;
  for(i=0;i<coins.length;i++){
    enemyDist=3*arenaSize;
    dist=Math.abs(x-coins[i][0])+Math.abs(y-coins[i][1])
    for(j=0;j<others.length;j++){
      if(i==0){
        if(others[j][2]+5>=power){
          enemyDist=Math.min(enemyDist,Math.abs(others[j][0]-coins[i][0])+Math.abs(others[j][1]-coins[i][1]))
        }
      }
      else{
        if(others[j][2]+2>=power){
          enemyDist=Math.min(enemyDist,Math.abs(others[j][0]-coins[i][0])+Math.abs(others[j][1]-coins[i][1]))
        }
      }

    }
    if(enemyDist>dist){
      if(i==0){
        if(dist/5<optimalDist){
          optimalDist=dist/5;
          optimalCoin=i;
        }
      }
      else{
        if(dist/2<optimalDist){
          optimalDist=dist/2;
          optimalCoin=i;
        }
      }
    }
  }
  if(optimalCoin==7){
    safeDir=15;
    if(x==0){safeDir-=8;}
    if(x==arenaSize-1){safeDir-=2;}
    if(y==0){safeDir-=1;}
    if(y==arenaSize-1){safeDir-=4;}
    for(i=0;i<others.length;i++){
      if(others[i][2]>=power){
        if(Math.abs(x-others[i][0])+Math.abs(y-others[i][1])==2){
          if(x-others[i][0]>0){safeDir-=8;}
          if(x-others[i][0]<0){safeDir-=2;}
          if(y-others[i][1]>0){safeDir-=1;}
          if(y-others[i][1]<0){safeDir-=4;}
        }
      }
    }
    directions=["north","east","south","west"];
    if(safeDir!=0){
      tmp="";
      tmp+="0".repeat(Math.max(Math.sqrt(arenaSize)/2|0,y-(arenaSize/2|0)));
      tmp+="2".repeat(Math.max(Math.sqrt(arenaSize)/2|0,(arenaSize/2|0)-y));
      tmp+="1".repeat(Math.max(Math.sqrt(arenaSize)/2|0,(arenaSize/2|0)-x));
      tmp+="3".repeat(Math.max(Math.sqrt(arenaSize)/2|0,x-(arenaSize/2|0)));
      rnd=tmp[Math.random()*tmp.length|0];
      while(!(2**rnd&safeDir)){rnd=tmp[Math.random()*tmp.length|0];}
      return directions[rnd];
    }
    return "none";//the only safe move is not to play :P
  }
  distX=coins[optimalCoin][0]-x;
  distY=coins[optimalCoin][1]-y;
  if(Math.abs(distX)>Math.abs(distY)){
    if(distX>0){return "east";}
    else{return "west";}
  }
  else{
    if(distY>0){return "south";}
    else{return "north";}
  }
}

यह बॉट एक भारित मूल्यवान सिक्के (मूल्य / दूरी) की ओर सीधा होता है, जो एक ही समय पर या किसी अन्य बॉट के बाद पहुंचने से नहीं मर सकता है। यदि इस संपत्ति के पास कोई वैध सिक्का नहीं है, तो ~~यह बैठता है कि यह~~ बॉट है जो अब एक यादृच्छिक सुरक्षित दिशा में चलता है (सुरक्षा का मतलब है कि अगर कोई बॉट इसकी ओर बढ़ता है, तो सुरक्षा सिक्का टकरा नहीं सकता है। यह बॉट को दूसरे बॉट के साथ स्थानों को स्वैप करने की अनुमति देता है। इसके तुरंत बाद), अखाड़े के केंद्र की ओर भारित।

— fənɛtɪk
स्रोत

1

हुह, यह वास्तव में जीत सकता है। हालांकि, बहुत सारे बॉट हैं

— रेडवॉल्फ प्रोग्राम्स

इस विधि में अधिक समस्याएं होंगी अधिक असमान रूप से दुश्मन के बॉट उच्च या समान मूल्य के साथ रखे जाते हैं।

— f --n

1

ठीक है, वे शायद सभी को उनके / सोने के सिक्के के निकटतम सिक्के के लिए एक बीलाइन बना रहे होंगे।

— रेडवुल्फ कार्यक्रम

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

— f --n 18tɪk

और यह ज्यादातर भाग्य है, क्योंकि जिस स्थान पर सिक्के उत्पन्न होते हैं, वह बेतरतीब ढंग से तय किया जाता है

— Redwolf प्रोग्राम्स

10

खेल खेलने वाले बॉट सावधानी से लेकिन आक्रामक हो सकते हैं | जावास्क्रिप्ट

पसंदीदा रंग: #F24100

नोट: हालांकि इस बॉट ने 1 स्थान लिया है, यह अंत में "फ्यूडल नोबल" के साथ मिलकर और अधिक सिक्कों के लिए उसे खाने के कारण है। अन्यथा यह बॉट 3 होता। यदि आप ऐसे बॉट्स में रुचि रखते हैं जो व्यक्तिगत रूप से अधिक शक्तिशाली हैं, तो संभावित रूप से विक्टोरियस और बिग किंग लिटिल हिल चेकआउट करें ।

function (me, monsters, coins) {
    var i, monstersCount = monsters.length, phaseSize = Math.round((me.arenaLength - 4) / 4),
        center = (me.arenaLength - 1) / 2, centerSize = me.arenaLength / 4,
        centerMin = center - centerSize, centerMax = center + centerSize, centerMonsters = 0, centerMonstersAvg = null,
        end = 2e4, apocalypse = end - ((me.arenaLength * 2) + 20), mode = null;

    var getDistance = function (x1, y1, x2, y2) {
        return (Math.abs(x1 - x2) + Math.abs(y1 - y2)) + 1;
    };

    var isAtCenter = function (x, y) {
        return (x > centerMin && x < centerMax && y > centerMin && y < centerMax);
    };

    var round = botNotes.getData('round');
    if (round === null || !round) round = 0;
    round++;
    botNotes.storeData('round', round);

    var isApocalypse = (round >= apocalypse && round <= end);
    if (isApocalypse) {
        mode = botNotes.getData('mode');
        if (mode === null || !mode) mode = 1;
    }

    for (i = 0; i < monstersCount; i++) if (isAtCenter(monsters[i][0], monsters[i][1])) centerMonsters++;

    var lc = botNotes.getData('lc');
    if (lc === null || !lc) lc = [];
    if (lc.length >= 20) lc.shift();
    lc.push(centerMonsters);
    botNotes.storeData('lc', lc);

    if (lc.length >= 20) {
        centerMonstersAvg = 0;
        for (i = 0; i < lc.length; i++) centerMonstersAvg += lc[i];
        centerMonstersAvg = centerMonstersAvg / lc.length;
    }

    var getScore = function (x, y) {
        var score = 0, i, chaseFactor = 0.75, coinFactor = 1;

        if (monstersCount < phaseSize) {
            chaseFactor = 0;
            coinFactor = 0.25;
        } else if (monstersCount < phaseSize * 2) {
            chaseFactor = 0;
            coinFactor = 0.5;
        } else if (monstersCount < phaseSize * 3) {
            chaseFactor = 0.5;
            coinFactor = 0.75;
        }

        if (isApocalypse) {
            if (mode === 1) {
                var centerDistance = getDistance(x, y, center, center);
                if (centerDistance <= 3) {
                    mode = 2;
                } else {
                    score += 5000 / (centerDistance / 10);
                }
            }
            if (mode === 2) chaseFactor = 1000;
        }

        for (i = 0; i < monstersCount; i++) {
            var monsterCoins = monsters[i][2], monsterDistance = getDistance(x, y, monsters[i][0], monsters[i][1]);
            if (me.coins > monsterCoins && monsterDistance <= 3) {
                score += (Math.min(5, monsterCoins) * chaseFactor) / monsterDistance;
            } else if (me.coins <= monsterCoins && monsterDistance <= 3) {
                score -= (monsterDistance === 3 ? 50 : 10000);
            }
        }

        for (i = 0; i < coins.length; i++) {
            var coinDistance = getDistance(x, y, coins[i][0], coins[i][1]),
                coinDistanceCenter = getDistance(center, center, coins[i][0], coins[i][1]),
                coinValue = (i === 0 ? 250 : 100), coinCloserMonsters = 0;

            for (var j = 0; j < monstersCount; j++) {
                var coinMonsterDistance = getDistance(monsters[j][0], monsters[j][1], coins[i][0], coins[i][1]);
                monsterCoins = monsters[j][2];

                if (
                    (coinMonsterDistance < coinDistance && monsterCoins >= me.coins / 2) ||
                    (coinMonsterDistance <= coinDistance && monsterCoins >= me.coins)
                ) {
                    coinCloserMonsters++;
                }
            }

            var coinMonsterFactor = (100 - ((100 / monstersCount) * coinCloserMonsters)) / 100;
            if (coinMonsterFactor < 1) coinMonsterFactor *= coinFactor;
            if (coinMonsterFactor >= 1) coinMonsterFactor *= 15;
            score += ((coinValue * coinMonsterFactor) / coinDistance) + (centerMonstersAvg === null || centerMonstersAvg > 1.75 ? -1 * (50 / coinDistanceCenter) : 200 / coinDistanceCenter);
        }

        return score + Math.random();
    };

    var possibleMoves = [{x: 0, y: 0, c: 'none'}];
    if (me.locationX > 0) possibleMoves.push({x: -1, y: 0, c: 'west'});
    if (me.locationY > 0) possibleMoves.push({x: -0, y: -1, c: 'north'});
    if (me.locationX < me.arenaLength - 1) possibleMoves.push({x: 1, y: 0, c: 'east'});
    if (me.locationY < me.arenaLength - 1) possibleMoves.push({x: 0, y: 1, c: 'south'});

    var topCommand, topScore = null;
    for (i = 0; i < possibleMoves.length; i++) {
        var score = getScore(me.locationX + possibleMoves[i].x, me.locationY + possibleMoves[i].y);
        if (topScore === null || score > topScore) {
            topScore = score;
            topCommand = possibleMoves[i].c;
        }
    }

    if (isApocalypse) botNotes.storeData('mode', mode);

    return topCommand;
}

यह बॉट (उर्फ "टीबीटीपीटीजीसीबीसीबीए") प्रत्येक संभव कदम के लिए एक स्कोर उत्पन्न करके सर्वोत्तम निर्णय लेने की कोशिश करता है और प्रत्येक मोड़ के लिए उच्च स्कोर के साथ चाल का चयन करता है।

स्कोरिंग प्रणाली में कई विवरण हैं जो चुनौती की शुरुआत के बाद से विकसित हुए हैं। उन्हें आम तौर पर इस तरह वर्णित किया जा सकता है:

सिक्के जितना संभव हो उतने ही नजदीक आते हैं, उतना ही अधिक चलता है। यदि किसी अन्य संभावित प्रतियोगी के पास कोई सिक्का नहीं है, तो स्कोर और भी अधिक बढ़ जाता है। यदि एक सिक्के में अन्य संभावित प्रतियोगी हैं, तो स्कोर कम हो जाता है।
यदि कोई अन्य बोट एक संभावित कदम के करीब है और इसमें कम सिक्के हैं, तो खेल के चरण के आधार पर, इसका मतलब उस चाल के लिए अधिक स्कोर हो सकता है। तो यह "टीबीटीपीटीजीसीबीसीबीए" के लिए प्रत्येक खेल में कुछ अन्य बॉट खाने के लिए आकस्मिक है।
यदि एक और बॉट बराबर या अधिक अंक के साथ एक संभावित कदम के करीब है, तो यह सुनिश्चित करने के लिए कि नकारात्मक मौत हो जाती है, इस कदम को पर्याप्त नकारात्मक अंक मिलता है। बेशक कुछ मामले हो सकते हैं कि सभी संभावित चालें खराब हैं और मृत्यु से बचा नहीं जा सकता है, लेकिन यह बहुत दुर्लभ है।
पिछले 20 बारी के लिए बोर्ड के बीच में बॉट की संख्या पर नज़र रखने के लिए एक तंत्र है। यदि औसत पर्याप्त कम है, तो मध्य में सिक्कों की ओर सभी को अधिक अंक मिलते हैं और यदि औसत अधिक है, तो सभी मध्य में सिक्कों की ओर बढ़ते हैं, कम स्कोर प्राप्त करते हैं। यह तंत्र "फ्यूडल नोबल" के साथ संघर्ष से बचने की अनुमति देता है। चूंकि "फ्यूडल नोबल" हमेशा मध्य में होता है (जब तक कि इसका पीछा नहीं किया जा रहा है), मध्य में बॉट की औसत संख्या बढ़ जाती है और "टीबीटीपीटीजीसीबीसीबीए" मध्य क्षेत्र के बाहर एक बेहतर विकल्प होने पर मध्य से बचने के लिए समझता है। यदि "फ्यूडल नोबल" मर जाता है, तो औसत नीचे चला जाता है और "टीबीटीपीटीजीसीबीसीबीए" समझता है कि यह बीच का उपयोग कर सकता है।
कुछ कारक हैं जो खेल के चरण के आधार पर गतिशील रूप से बदलते हैं (जीवित बॉट की संख्या से पता चला), ये कारक उपरोक्त प्रत्येक आइटम में स्कोरिंग को प्रभावित करते हैं।
इस बॉट में एक विशेष क्षमता है। समय के साथ यह "फ्यूडल नोबल" के स्वार्थ और किसानों के उत्पीड़न से थक गया। सही समय पर, यह अप्रिय सामंतवाद प्रणाली को समाप्त करने के लिए उठेगा। एक सफल प्रयास न केवल गरीब किसानों की मदद करता है, बल्कि "फ्यूडल नोबल" से लिए गए सिक्कों के कारण उच्च जीत का मौका भी प्रदान करता है।

— Night2
स्रोत

यह एक बहुत अधिक लगता है ... दूसरों की तुलना में बुद्धिमान

— रेडवॉल्फ कार्यक्रम

5

मुझे राक्षसों का हिस्सा पसंद है

— रेडवुल्फ प्रोग्राम्स

9

द एंटीकैटलिस्ट | जावास्क्रिप्ट

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

function antiCapitalist(me, capitalists, coins){

    function acquireTargets(capitalists){
        capitalists.sort((a, b) => a[2] < b[2]);
        let previousCapitalist;
        for(let i in capitalists){
            let capitalist = capitalists[i];

            if(capitalist[2] === 0){
                return false;
            }
            if(previousCapitalist && capitalist[2] === previousCapitalist[2]){
                return [previousCapitalist, capitalist];
            }

            previousCapitalist = capitalist;
        }

        return false;
    }

    function move(){
        const targets = acquireTargets(capitalists);
        if(!targets){
            return 'none';
        }

        const coordinates = [Math.floor((targets[0][0] + targets[1][0]) / 2), Math.floor((targets[0][1] + targets[1][1]) / 2)];
        if(me.locationX !== coordinates[0]){
            return me.locationX < coordinates[0] ? 'east' : 'west';
        }
        else if(me.locationX !== coordinates[1]){
            return me.locationY < coordinates[1] ? 'south' : 'north';
        }
        else {
            return 'none';
        }
    }

    return move();
}

— माइकल कुन्स्ट
स्रोत

9

GUT, जावास्क्रिप्ट

function gut(me, others, coins) {
    // Prepare values for the calculation
    var x = me.locationX;
    var y = me.locationY;
    var cMe = me.coins+1;
    var arenaLen = me.arenaLength;

    var objects = [];

    // Add bots to objects
    for (var i = 0; i < others.length; i++) {
        objects.push([others[i][0],others[i][1],others[i][2]/cMe]);
    }

    // Add coins to objects
    for (var j = 0; j < coins.length; j++) {
        var coinVal = 0;

        if (j == 0) {
            // Gold has a higher coin value
            coinVal = -10;
        } else {
            // Silver has a lower coin value
            coinVal = -5;
        }

        objects.push([coins[j][0],coins[j][1],coinVal/cMe]);
    }

    // Perform the calculation
    // x acceleration
    var x_acceleration = 0;

    for (var k=0; k < objects.length; k++) {
        var kval = objects[k][2];
        var xval = objects[k][0];

        x_acceleration += 200*kval/cMe*(x-xval)*Math.exp(Math.pow(kval,2)-50*Math.pow(x-xval,2));
    }

    // y acceleration
    var y_acceleration = 0;

    for (var l=0; l < objects.length; l++) {
        var kval = objects[l][2];
        var yval = objects[l][1];

        y_acceleration += 200*kval/cMe*(y-yval)*Math.exp(Math.pow(kval,2)-50*Math.pow(y-yval,2));
    }

    // Compare the values
    if (Math.abs(y_acceleration)>Math.abs(x_acceleration)) {
        if (y_acceleration < 0) {
            // Don't fall off the edge
            if (y>0) {
                return "north";
            } else {
                return "none";
            }
        } else {
            if (y<arenaLen-1) {
                return "south";
            } else {
                return "none";
            }
        }
    } else if (Math.abs(y_acceleration)<Math.abs(x_acceleration)) {
        if (x_acceleration < 0) {
            if (x>0) {
                return "west";
            } else {
                return "none";
            }
        } else {
            if (x<arenaLen-1) {
                return "east";
            } else {
                return "none";
            }
        }
    } else {
        return "none";
    }
}

संभावित रूप से विक्टोरियस के साथ हमें दो फ़ील्ड मिले हैं: बॉट फ़ील्ड और सिक्का फ़ील्ड। हालाँकि, प्रकृति उस जटिल नहीं है। ग्रैंड यूनिफाइड थ्योरी का निर्माण करने के लिए दो क्षेत्रों को एकजुट करने का समय है ।

सबसे पहले, हमें कार्य करने की आवश्यकता है कि क्षेत्र की क्षमता क्या है। अपने स्वयं के बॉट को मानते हुए क्षेत्र को किसी भी तरह से प्रभावित नहीं किया जाता है, हम इसे इस प्रकार लिख सकते हैं:

वी = \underset{n}{Σ} क_{n} (इ^{क_{n}^{2} - 100 (एक्स - {एक्स}_{n})^{2}} + इ^{क_{n}^{2} - 100 (y - y_{n})^{2}})

$V = \sum_\limits{n} k_n\left(e^{k_n^2-100(x-x_n)^2}+e^{k_n^2-100(y-y_n)^2}\right)$

$k_n$ $(x_n, y_n)$

वस्तु की सापेक्ष संपत्ति की गणना इस तरह की जाती है:

क = \frac{{सी}_{वस्तु}}{{सी}_{मुझे}}

$k = \frac{c_{\text{object}}}{c_{\text{me}}}$

$c$ $c_{\text{me}} = c_{\text{self}} + 1$ $c_{\text{self}}$

_{आइए, संशोधित बेटेनियन डायनेमिक्स (MOBD) के इस सुधार भाग को कॉल करें ।}

हम इस प्रकार गतिज ऊर्जा भी प्राप्त कर सकते हैं:

टी = \frac{1}{2} {सी}_{मुझे} ({\dot{एक्स}}^{2} + {\dot{y}}^{2})

$T = \frac{1}{2}c_{\text{me}}(\dot{x}^2 + \dot{y}^2)$

अब हम कार्रवाई की गणना कर सकते हैं:

\begin{aligned} Action & = \int_{a}^{b} (T - V) d t \\ = \int_{a}^{b} (\frac{1}{2} c_{me} ({\dot{x}}^{2} + {\dot{y}}^{2}) - \sum_{n} k_{n} (e^{k_{n}^{2} - 100 (x - x_{n})^{2}} + e^{k_{n}^{2} - 100 (y - y_{n})^{2}})) d t \end{aligned}

$\begin{align}\text{Action} &= \int^b_a (T-V)dt\\&=\int^b_a \left(\frac{1}{2}c_{\text{me}}(\dot{x}^2 + \dot{y}^2) - \sum_\limits{n} k_n\left(e^{k_n^2-100(x-x_n)^2}+e^{k_n^2-100(y-y_n)^2}\right)\right) dt\end{align}$

और इसलिए सिक्का-बॉट क्षेत्र में हमारे बॉट का लैग्रैजियन है:

L = \frac{1}{2} c_{me} ({\dot{x}}^{2} + {\dot{y}}^{2}) - \sum_{n} k_{n} (e^{k_{n}^{2} - 100 (x - x_{n})^{2}} + e^{k_{n}^{2} - 100 (y - y_{n})^{2}})

$\mathcal{L} = \frac{1}{2}c_{\text{me}}(\dot{x}^2 + \dot{y}^2) - \sum_\limits{n} k_n\left(e^{k_n^2-100(x-x_n)^2}+e^{k_n^2-100(y-y_n)^2}\right)$

अब हमें Euler-Lagrange समीकरणों को हल करने की आवश्यकता है:

\frac{d}{d t} \frac{\partial L}{\partial \dot{x}} = \frac{\partial L}{\partial x}

$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{x}} = \frac{\partial \mathcal{L}}{\partial x}$

तथा:

\frac{d}{d t} \frac{\partial L}{\partial \dot{y}} = \frac{\partial L}{\partial y}

$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{y}} = \frac{\partial \mathcal{L}}{\partial y}$

इसलिए:

\frac{d}{d t} \frac{\partial L}{\partial \dot{x}} = \frac{d}{d t} [c_{me} \dot{x}] = c_{me} \ddot{x}

$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{x}} = \frac{d}{dt} \left[c_{\text{me}}\dot{x}\right] = c_{\text{me}}\ddot{x}$

\frac{\partial एल}{\partial एक्स} = \underset{n}{Σ} 200 क_{n} (एक्स - {एक्स}_{n}) इ^{क_{n}^{2} - 100 (एक्स - {एक्स}_{n})^{2}}

$\frac{\partial \mathcal{L}}{\partial x} = \sum\limits_n 200 k_n \left(x - x_n\right) e^{k_n^2 - 100(x-x_n)^2}$

\Rightarrow \ddot{एक्स} = \underset{n}{Σ} \frac{200 क_{n}}{{सी}_{मुझे}} (एक्स - {एक्स}_{n}) इ^{क_{n}^{2} - 100 (एक्स - {एक्स}_{n})^{2}}

$\Rightarrow \ddot{x} = \sum\limits_n \frac{200k_n}{c_{\text{me}}} \left(x - x_n\right) e^{k_n^2 - 100(x-x_n)^2}$

और भी:

\frac{घ}{घ टी} \frac{\partial एल}{\partial \dot{y}} = \frac{घ}{घ टी} [{सी}_{मुझे} \dot{y}] = {सी}_{मुझे} \ddot{y}

$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{y}} = \frac{d}{dt} \left[c_{\text{me}}\dot{y}\right] = c_{\text{me}}\ddot{y}$

\frac{\partial एल}{\partial y} = \underset{n}{Σ} 200 क_{n} (y - y_{n}) इ^{क_{n}^{2} - 100 (y - y_{n})^{2}}

$\frac{\partial \mathcal{L}}{\partial y} = \sum\limits_n 200 k_n \left(y - y_n\right) e^{k_n^2 - 100(y-y_n)^2}$

\Rightarrow \ddot{y} = \underset{n}{Σ} \frac{200 क_{n}}{{सी}_{मुझे}} (y - y_{n}) इ^{क_{n}^{2} - 100 (y - y_{n})^{2}}

$\Rightarrow \ddot{y} = \sum\limits_n \frac{200k_n}{c_{\text{me}}} \left(y - y_n\right) e^{k_n^2 - 100(y-y_n)^2}$

अब हमें और आगे जाने की जरूरत नहीं है: हम सिर्फ समग्र त्वरण की दिशा देखते हैं:

उत्पादन = {\begin{cases} उत्तर & अगर \ddot{y} < 0 तथा | \ddot{y} | > | \ddot{एक्स} | \\ दक्षिण & अगर \ddot{y} > 0 तथा | \ddot{y} | > | \ddot{एक्स} | \\ पश्चिम & अगर \ddot{एक्स} < 0 तथा | \ddot{एक्स} | > | \ddot{y} | \\ पूर्व & अगर \ddot{एक्स} > 0 तथा | \ddot{एक्स} | > | \ddot{y} | \\ कोई नहीं & अगर | \ddot{y} | = | \ddot{एक्स} | \end{cases}

$\text{output} = \begin{cases}\text{north} &\text{if }\ddot{y}<0 \text{ and } |\ddot{y}|>|\ddot{x}| \\ & \\ \text{south} &\text{if }\ddot{y}>0 \text{ and } |\ddot{y}|>|\ddot{x}| \\ & \\ \text{west} &\text{if }\ddot{x}<0 \text{ and } |\ddot{x}|>|\ddot{y}| \\ & \\ \text{east} &\text{if }\ddot{x}>0 \text{ and } |\ddot{x}|>|\ddot{y}| \\ & \\ \text{none} &\text{if }|\ddot{y}|=|\ddot{x}|\end{cases}$

और ऐसे ही, हमने सिक्कों और बॉट्स को एक कर दिया है। मेरा नोबेल पुरस्कार कहाँ है?

— बीटा डिके
स्रोत

5

आपका नोबेल पुरस्कार मेल में खो गया था, लेकिन हम आपको इसके बदले एमी पुरस्कार दे सकते थे

— Redwolf प्रोग्राम्स

1

लगता है कि इस चुनौती में भौतिकी लोकप्रिय होने लगी है। :-D। और निश्चित रूप से मैं बहुत उत्सुक हूं कि यह कितना अच्छा होगा।

— रामिलिज़

1

(वैसे, आप Euler-Lagrange समीकरणों से परेशानी को बचा सकते थे, क्योंकि वे जाने-माने तथ्य को कम करते हैं कि F = c_me a - grad U :-)।)

— Ramillies

@Ramillies मेह, इसे इस तरह से करने में अधिक मज़ा आया: D

— बीटा डेके

1

क्या आप सुनिश्चित हैं कि आप कुछ और के सिक्कों का उपयोग करना चाहते हैं? आप बिना किसी सिक्के के शुरू करते हैं ... और हर जगह NaN के साथ, आपको कोई भी प्राप्त होने की संभावना नहीं है।

— रामलीज

8

गोल्डीलॉक्स, जावास्क्रिप्ट (Node.js)

function goldilocks(me, others, coins) {
  let target = coins[0]; // Gold
  let x = target[0] - me.locationX;
  let y = target[1] - me.locationY;

  mymove = 'none'
  if (Math.abs(x) <= Math.abs(y) && x != 0)
    mymove = x < 0 ? 'west' : 'east'
  else if (y != 0)
    mymove = y < 0 ? 'north' : 'south'

  return mymove
}

इसे ऑनलाइन आज़माएं!

बस सोने के सिक्के के स्थान पर ताला लगाता है और हर बार उसकी ओर बढ़ता है। (मूल कोड के लिए @ मेयूब के 'B33-L1N3' बॉट के लिए इसका उपयोग किया जाता है, हालांकि इसके बारे में बमुश्किल कोई बात नहीं है।)

— सुन्दर
स्रोत

यह एक बहुत अच्छा, सरल बॉट है। मुझें यह पसंद है।

— Redwolf

2

वैसे, मैं इस बॉट को अपने नियंत्रक के लिए परीक्षण के रूप में उपयोग कर रहा हूं: (:

— रेडवॉल्फ प्रोग्राम्स

8

तीसरा जनरल लर्निंग एल्गोरिथम | जावास्क्रिप्ट (Node.js)

function run(me) {
	options = [];
	if (me.locationX > 0) options.push('west');
	if (me.locationY > 0) options.push('north');
	if (me.locationX < me.arenaLength) options.push('east');
	if (me.locationY < me.arenaLength) options.push('south');

	return options[Math.floor(Math.random() * options.length)];
}

इसे ऑनलाइन आज़माएं!

सीखने की कुछ पीढ़ियों के बाद, इस बॉट ने सीखा है कि अखाड़ा छोड़ना = बुरा होना

— Skidsdev
स्रोत

ओह अच्छा। मैंने सुना है कि इसे "प्राकृतिक चयन" कहा जाता है

— रेडवॉल्फ प्रोग्राम्स

5

दूसरा जीन कहां है

— लुइस फेलिप डी जीसस मुनोज

11

@LuisfelipeDejesusMunoz उन्होंने अखाड़ा छोड़ दिया।

— जो।

नियंत्रक डिबगिंग के लिए यह एक अच्छा बॉट है

— रेडवॉल्फ प्रोग्राम्स

3

ओह, वैसे, अखाड़ा 0 से शुरू होता है, इसलिए यह होना चाहिए arenaLength - 1। इसने आपके बॉट को कई बार काफी

— हद तक

7

B33-L1N3 | जावास्क्रिप्ट (Node.js)

function(me, others, coins) {
	// Do nothing if there aren't any coins
	if (coins.length == 0) return 'none';
	// Sort by distance using Pythagoras' Theorem
	coins = coins.sort((a, b) => (a[0] ** 2 + a[1] ** 2) - (b[0] ** 2 + b[1] ** 2));
	// Closest coin
	let target = coins[0];
	let x = target[0];
	let y = target[1];

	// Util function for movement
	function move(pos, type) {
		let moveTypes = { X: ['east', 'west'], Y: ['south', 'north'] };
		if (pos > me['location'+type]) return moveTypes[type][0];
		else return moveTypes[type][1];
	}

	// Move the shortest distance first
	if (x < y && x != me.locationX) return move(x, 'X');
	else if (y != me.locationY) return move(y, 'Y');
}

इसे ऑनलाइन आज़माएं!

निकटतम सिक्के के लिए एक बीलाइन बनाता है

— Skidsdev
स्रोत

ओह, मुझे लगा कि B33-L1N3 किसी तरह का मॉडल नंबर था

— Redwolf Programs

नाम के लिए +1

— कैन

let coins = ...Uncaught SyntaxError: Identifier 'coins' has already been declared

— Night2

डिलीटlet

— Redwolf प्रोग्राम्स

5

Livin 'एज, जावास्क्रिप्ट पर

function LivinOnTheEdge (myself, others, coins) {
  x = myself.locationX;
  y = myself.locationY;
  xymax = myself.arenaLength - 1;
  if (x < xymax && y == 0) {
      return 'east';
    } else if (y < xymax && x == xymax) {
      return 'south';
    } else if (x > 0 && y == xymax) {
      return 'west';
  } else {
    return 'north';
  }
}

यह एक अखाड़ा के किनारे सुना एक खतरनाक जगह है। बिना किसी डर के यह जानने के लिए कि यह बोर्ड की घड़ी की दिशा में केवल एक इंच की दूरी पर है, सीमा के पीछे इंतजार कर रहा है, उम्मीद करता है कि कोई अन्य बॉट किनारे के आसपास के क्षेत्र में इतनी दूर जाने की हिम्मत नहीं करेगा।

— Laikoni
स्रोत

1

यह अच्छी तरह से समाप्त नहीं होगा यदि एक और बॉट बनाया गया था जिसमें 1 और सिक्का था, और सीमा को विपरीत दिशा में गश्त किया था: (

— रेडवॉल्फ कार्यक्रम

8

मैं एक सीमा नियंत्रण मजाक बनाऊंगा, लेकिन मैं @BetaDecay

— Redwolf प्रोग्राम्स

5

डैमसी, जावास्क्रिप्ट (Node.js)

function damacy(me, others, coin) {
  let xdist = t => Math.abs(t[0] - me.locationX)
  let ydist = t => Math.abs(t[1] - me.locationY)
  function distanceCompare(a, b, aWt, bWt) {
    aWt = aWt || 1
    bWt = bWt || 1
    return (xdist(a) + ydist(a)) / aWt - (xdist(b) + ydist(b)) / bWt
  }
  function hasThreat(loc) {
    let threat = others.filter(b => b[0] == loc[0] && b[1] == loc[1] && b[2] >= me.coins)
    return (threat.length > 0)
  }
  function inArena(loc) {  // probably unnecessary for this bot
    return loc[0] >= 0 && loc[1] >= 0 && loc[0] < me.arenaLength && loc[1] < me.arenaLength
  }
  function sortedCoins() {
    coinsWithValues = coin.map((coords, i) => coords.concat((i == 0) ? 5 : 2))
    coinsWithValues.sort((a, b) => distanceCompare(a, b, a[2], b[2]))
    return coinsWithValues.map(c => c.slice(0, 2))
  }
  othersPrev = botNotes.getData('kata_others_pos')
  botNotes.storeData('kata_others_pos', others)
  if (othersPrev) {

    for(let i = 0; i < others.length; i++) {
      let bot = others[i]

      let matchingBots = othersPrev.filter(function (b) {
        let diff = Math.abs(b[0] - bot[0]) + Math.abs(b[1] - bot[1])
        if (diff >= 2)
          return false // bot can't have jumped
        return [0, 2, 5].includes(bot[2] - b[2])
      })

      if (matchingBots.length > 0) {
        let botPrev = matchingBots.shift()
        // remove matched bot so it doesn't get matched again later
        othersPrev = othersPrev.filter(b => b[0] != botPrev[0] || b[1] != botPrev[1])
        bot[0] = Math.min(Math.max(bot[0] + bot[0] - botPrev[0], 0), me.arenaLength-1)
        bot[1] = Math.min(Math.max(bot[1] + bot[1] - botPrev[1], 0), me.arenaLength-1)
      }
    }
  }

  let eatables = others.filter(b => b[2] < me.coins && b[2] > 0)
  let targets
  if (eatables.length > 0) {
    targets = eatables.sort(distanceCompare)
  }
  else {
    targets = sortedCoins()
  }

  let done, newLoc, dir
  while (!done && targets.length > 0) {
    t = targets.shift()
    if ((xdist(t) <= ydist(t) || ydist(t) == 0) && xdist(t) != 0) {
      let xmove = Math.sign(t[0] - me.locationX)
      dir = xmove < 0 ? 'west' : 'east'
      newLoc = [me.locationX + xmove, me.locationY]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }

    if (!done) {
      let ymove = Math.sign(t[1] - me.locationY)
      dir = ['north', 'none', 'south'][ymove + 1]
      newLoc = [me.locationX, me.locationY + ymove]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }
  }

  if (!done)
    dir = 'none'


  return dir
}

इसे ऑनलाइन आज़माएं!

आज के लिए एक आखिरी कटमारी-आधारित वनस्पति, इस बार थोड़ी सी स्मृति के साथ। नाम सुझाव के लिए @BetaDecay को धन्यवाद - निश्चित रूप से मेरे से अधिक मजेदार नाम simplePredictorKatamari।

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

(@ F Thanksnɛtɪk के लिए धन्यवाद, ध्यान दें कि मैं बॉटनोट्स में गलत फ़ंक्शन नाम को कॉल कर रहा था, और आधार कोड में बग को नोट करने के लिए @ OM and को।)

— सुन्दर
स्रोत

यह शायद अभी एकमात्र ऐसा है जो दूसरों को सिर्फ भाग्यशाली होने के बाहर पकड़ सकता है।

— कैन

क्या बॉट्नोट्स को "स्टोरटाटा" नहीं माना जाता है जो सेटडाटा नहीं है?

— f --nɪtɪk

@ f @n bugtɪk देखें, पहले से ही एक बगफिक्स की जरूरत है! :) धन्यवाद, अब सही।

— सूंदर

आप के aWt = 1साथ params में प्रतिस्थापित करना चाहिए aWt, और aWt = aWt || 1नीचे (उसी के साथ bWt) डाल दिया । यह त्रुटियों को रोकता है।

— Redwolf 14

5

प्रोटॉन | जावास्क्रिप्ट

Proton=(myself,others,coins)=>{
  x=myself.locationX;
  y=myself.locationY;
  power=myself.coins;
  arenaSize=myself.arenaLength;
  forceX=0;
  forceY=0;
  prevState=botNotes.getData("proton_velocity");
  if(prevState){
    velocity=prevState[0];
    direction=prevState[1];
  }
  else{
    velocity=0;
    direction=0;
  }
  for(i=0;i<coins.length;i++){
    if(Math.abs(x-coins[i][0])+Math.abs(y-coins[i][1])==1){
      velocity=0;
      direction=0;
      botNotes.storeData("proton_velocity",[velocity,direction]);
      if(x-coins[i][0]==1){return "west";}
      if(coins[i][0]-x==1){return "east";}
      if(y-coins[i][1]==1){return "north";}
      if(coins[i][1]-y==1){return "south";}
    }
    else{
      dist=Math.sqrt(Math.pow(x-coins[i][0],2)+Math.pow(y-coins[i][1],2));
      if(i==0){
        forceX+=(x-coins[i][0])*5/Math.pow(dist,3);
        forceY+=(y-coins[i][1])*5/Math.pow(dist,3);
      }
      else{
        forceX+=(x-coins[i][0])*2/Math.pow(dist,3);
        forceY+=(y-coins[i][1])*2/Math.pow(dist,3);
      }
    }
  }
  for(i=0;i<others.length;i++){
    if(Math.abs(x-others[i][0])+Math.abs(y-others[i][1])==1&&power>others[i][2]){
      velocity=0;
      direction=0;
      botNotes.storeData("proton_velocity",[velocity,direction]);
      if(x-others[i][0]==1){return "west";}
      if(others[i][0]-x==1){return "east";}
      if(y-others[i][1]==1){return "north";}
      if(others[i][1]-y==1){return "south";}
    }
    else{
      dist=Math.sqrt(Math.pow(x-others[i][0],2)+Math.pow(y-others[i][1],2));
      forceX+=(x-others[i][0])*others[i][2]/Math.pow(dist,3);
      forceY+=(y-others[i][1])*others[i][2]/Math.pow(dist,3);
    }
  }
  vX=velocity*Math.cos(direction)+10*forceX/Math.max(1,power);
  vY=velocity*Math.sin(direction)+10*forceY/Math.max(1,power);
  velocity=Math.sqrt(vX*vX+vY*vY);
  if(velocity==0){return "none"}
  retval="none";
  if(Math.abs(vX)>Math.abs(vY)){
    if(vX>0){
      if(x<arenaSize-1){retval="east";}
      else{vX=-vX;retval="west";}
    }
    else{
      if(x>0){retval="west";}
      else{vX=-vX;retval="east";}
    }
  }
  else{
    if(vY>0){
      if(y<arenaSize-1){retval="south";}
      else{vY=-vY;retval="north";}
    }
    else{
      if(y>0){retval="north";}
      else{vY=-vY;retval="south";}
    }
  }
  direction=Math.atan2(-vY,vX);
  botNotes.storeData("proton_velocity",[velocity,direction]);
  return retval;
}

सभी सिक्के (अन्य बॉट द्वारा रखे गए सहित) प्रोटॉनबोट के प्रति प्रतिकारक बल का उत्सर्जन करते हैं। इस बल के आधार पर, यह वेग बनाता है और दीवारों से टकराता है (एक सीमा से टकराने पर तुरंत मुड़ता है)। यदि यह किसी बॉट या सिक्के के बगल में समाप्त हो जाता है, तो यह उपभोग कर सकता है, मजबूत परमाणु बल खत्म हो जाता है और यह ऐसा करने के लिए सभी वेग को छोड़ देता है, इसका उपभोग करने के लिए आगे बढ़ता है।

— fənɛtɪk
स्रोत

हम्म, परमाणु भौतिकी ने खजाने के लिए आवेदन किया? यह किसी भी दिन विज्ञान चैनल धड़कता है!

— रेडवॉल्फ प्रोग्राम्स

आप प्रतिस्थापित करने की आवश्यकता sinके साथ Math.sin, cosके साथ Math.cos, और इतने पर

— Redwolf कार्यक्रम

4

ऐसा नहीं है ब्लाइंडली | जावास्क्रिप्ट (Node.js)

महत्वपूर्ण नोट: यह दृष्टिकोण पूरी तरह से मेरा नहीं है और एक समान प्रश्न में उत्तर दिया गया है । उस उत्तर को भी वोट देना सुनिश्चित करें।

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

मापदंडों का अनुसरण करने की अपेक्षा करता है:

AI({locationX: 3, locationY: 1, arenaLength: [5,5]}, [[2,1],[2,2], ...],[[1,2],[3,1], ...])

शायद मैं ऐसा करता हूं जो अन्य बॉट का शिकार करता है

function AI(me, others, coins){
    var h = (a,b) => Math.abs(a[0] -b[0]) + Math.abs(a[1] -b[1])
    var s = JSON.stringify;
    var p = JSON.parse;
    var walls = others.slice(0,2).map(s);
    var start = [me.locationX, me.locationY];
    var goal = coins.pop();
    var is_closed = {};
    is_closed[s(start)] = 0;
    var open = [s(start)];
    var came_from = {};
    var gs = {};
    gs[s(start)] = 0;
    var fs = {};
    fs[s(start)] = h(start, goal);
    var cur;
    while (open.length) {
        var best;
        var bestf = Infinity;
        for (var i = 0; i < open.length; ++i) {
            if (fs[open[i]] < bestf) {
                bestf = fs[open[i]];
                best = i;
            }
        }
        cur = p(open.splice(best, 1)[0]);
        is_closed[s(cur)] = 1;
        if (s(cur) == s(goal)) break;
        for (var d of [[0, 1], [0, -1], [1, 0], [-1, 0]]) {
            var next = [cur[0] + d[0], cur[1] + d[1]];
            if (next[0] < 0 || next[0] >= me.arenaLength[0] ||
                next[1] < 0 || next[1] >= me.arenaLength[1]) {
                continue;
            }
            if (is_closed[s(next)]) continue;
            if (open.indexOf(s(next)) == -1) open.push(s(next));
            var is_wall = walls.indexOf(s(next)) > -1;
            var g = gs[s(cur)] + 1 + 10000 * is_wall;
            if (gs[s(next)] != undefined && g > gs[s(next)]) continue;
            came_from[s(next)] = cur;
            gs[s(next)] = g;
            fs[s(next)] = g + h(next, goal);
        }
    }
    var path = [cur];
    while (came_from[s(cur)] != undefined) {
        cur = came_from[s(cur)];
        path.push(cur);
    }
    var c = path[path.length - 1];
    var n = path[path.length - 2];
    if(n){
        if (n[0] < c[0]) {
            return "west";
        } else if (n[0] > c[0]) {
            return "east";
        } else if (n[1] < c[1]) {
            return "north";
        } else {
            return "south";
        }
    }else{
        return "none";
    }
}

— लुइस फेलिप डी जीसस मुनोज
स्रोत

1

वाह ... पहले से ही एक pathfinding एल्गोरिथ्म? यह केवल 3 घंटे है!

— रेडवुल्फ प्रोग्राम्स

@RedwolfPrograms जैसा कि मैंने कहा, यह एक और समान चुनौती से कॉपी किया गया है। बस इसे इस एक के अनुकूल बनाने की जरूरत है।

— लुइस फेलिप डी जीसस मुनोज

मेरे एल्गोरिदम जो भी सिक्कों के लिए जाते हैं वे जाने के लिए सबसे सुरक्षित हैं।

— f --n 17tɪk 17

4

कायर | अजगर २

import random

def move(me, others, coins):
    target = (me.locationX, me.locationY)

    # Identify the dangerous opponents.
    threats = [i for i, value in enumerate(others[2]) if value >= me.coins]

    # If no one scary is nearby, find a nearby coin.
    safe = True
    for x, y in self.coins:
        distance = abs(me.locationX - x) + abs(me.locationY - y)
        safe = True
        for i in threats:
            if abs(others[0][i] - x) + abs(others[1][i] - y) <= distance:
                safe = False
                break

        if safe:
            target = (x, y)
            break

    # Otherwise, just try not to die.
    if not safe:
        certain = []
        possible = []
        for x, y in [
            (me.locationX, me.locationY),
            (me.locationX + 1, me.locationY),
            (me.locationX - 1, me.locationY),
            (me.locationX, me.locationY + 1),
            (me.locationX, me.locationY - 1),
        ]:
            # Don't jump off the board.
            if x < 0 or y < 0 or x == me.arenaLength or y == me.arenaLength:
                continue

            # Check if we can get away safely.
            for i in threats:
                if abs(others[0][i] - x) + abs(others[1][i] - y) <= 1:
                    break
            else:
                certain.append((x, y))

            # Check if we can take a spot someone is leaving.
            for i in threats:
                if others[0][i] = x and others[1][i] == y:
                    for i in threats:
                        if abs(others[0][i] - x) + abs(others[1][i] - y) == 1:
                            break
                    else:
                        possible.append((x, y))

        if certain:
            target = random.choice(certain)
        elif possible:
            target = random.choice(possible)
        # Otherwise, we're doomed, so stay still and pray.

    directions = []
    x, y = target
    if x < me.locationX:
        directions.append('west')
    if x > me.locationX:
        directions.append('east')
    if y < me.locationY:
        directions.append('north')
    if y > me.locationY:
        directions.append('south')
    if not directions:
        directions.append('none')

    return random.choice(directions)

यदि संभव हो तो अधिक पैसे वाले बॉट से बचें। अन्यथा, चारों ओर पड़े हुए पैसे को पकड़ो।

— स्मृति सहायक
स्रोत

यह सबसे बुनियादी बॉट है जिसमें जीतने का मौका है

— रेडवॉल्फ प्रोग्राम्स

4

जंगली हंस चेस बॉट, जावास्क्रिप्ट

एक बॉट जो वास्तव में अन्य बॉट्स को चकमा देने में अच्छा है, लेकिन सिक्के प्राप्त करने में बहुत बुरा है।

कलन विधि:

यदि आसन्न बॉट नहीं हैं, तो कोई भी वापस न करें
अन्यथा:
1. यादृच्छिक मौका 1/500 मौका के साथ कोई नहीं लौटें (यह गतिरोध को रोकने के लिए है)।
2. निर्धारित करें कि किन स्थानों पर जाना सुरक्षित है (यानी अखाड़े के अंदर और दूसरे बॉट पर कब्जा नहीं)
3. यादृच्छिक पर एक लौटें

कोड:

function wildGooseChase(me, others, coins){
    x = me.locationX;
    y = me.locationY;

    dirs = {};
    dirs[(x+1)+" "+y] = "east";
    dirs[(x-1)+" "+y] = "west";
    dirs[x+" "+(y+1)] = "south";
    dirs[x+" "+(y-1)] = "north";

    mov = {};
    mov["east"] = [x+1,y];
    mov["west"] = [x-1,y];
    mov["north"] = [x,y-1];
    mov["south"] = [x,y+1]; 

    possibleDirs = ["east","west","north","south"];

    for (i = 0; i < others.length; i++){
        if (others[i][0]+" "+others[i][1] in dirs){
            possibleDirs.splice(possibleDirs.indexOf(dirs[others[i][0]+" "+others[i][1]]),1);
        }
    }

    if (possibleDirs.length == 4 || Math.floor(Math.random() * 500) == 0){
        return "none"
    }

    for (i = 0; i < possibleDirs.length; i++){
        if (mov[possibleDirs[i]][0] == me.arenaLength || mov[possibleDirs[i]][0] < 0 
        || mov[possibleDirs[i]][1] == me.arenaLength || mov[possibleDirs[i]][1] < 0){
            var index = possibleDirs.indexOf(possibleDirs[i]);
            if (index != -1) {
                possibleDirs.splice(index, 1);
                i--;
            }
        }
    }

    if (possibleDirs.length == 0){
         return "none";
    }

    return possibleDirs[Math.floor(Math.random() * possibleDirs.length)];
}

इसे ऑनलाइन आज़माएं!

Redwolf कार्यक्रमों पर ध्यान दें:

इस बॉट में बहुत लंबे दौर का कारण बनने की क्षमता है। मैंने गतिरोध को रोकने के लिए कुछ स्वतंत्रताएं ली हैं, लेकिन वास्तव में प्रभावी होने पर परीक्षण नहीं किया है। यदि यह बॉट परीक्षण के दौरान एक समस्या बन जाता है, तो कृपया इसे अयोग्य घोषित करने के लिए स्वतंत्र महसूस करें।

— जाचरी कपास
स्रोत

टिप्पणी के लिए धन्यवाद। यदि पीछा करते हुए पर्याप्त सिक्के एकत्र करने के लिए होता है, तो एक विशेषज्ञ के पास एक अच्छा मौका होता है

— रेडवुल्फ प्रोग्राम्स

मुझे यह पसंद हे। यह लगभग शिकार रोबोट के लिए चारा की तरह है

— बीटा डिके

4

कटामारीविथाल्यूस, जावास्क्रिप्ट (Node.js) ,

function katamariWithValues(me, others, coin) {
  let xdist = t => Math.abs(t[0] - me.locationX)
  let ydist = t => Math.abs(t[1] - me.locationY)
  function distanceCompare(a, b, aWt = 1, bWt = 1) {
    return (xdist(a) + ydist(a)) / aWt - (xdist(b) + ydist(b)) / bWt
  }
  function hasThreat(loc) {
    let threat = others.filter(b => b[0] == loc[0] && b[1] == loc[1] && b[2] >= me.coins)
    return (threat.length > 0)
  }
  function inArena(loc) {  // probably unnecessary for this bot
    return loc[0] >= 0 && loc[1] >= 0 && loc[0] < me.arenaLength && loc[1] < me.arenaLength
  }
  function sortedCoins() {
    coinsWithValues = coin.map((coords, i) => coords.concat((i == 0) ? 5 : 2))
    coinsWithValues.sort((a, b) => distanceCompare(a, b, a[2], b[2]))
    return coinsWithValues.map(c => c.slice(0, 2))
  }

  let eatables = others.filter(b => b[2] < me.coins && b[2] > 0)
  let targets
  if (eatables.length > 0) {
    targets = eatables.sort(distanceCompare)
  }
  else {
    targets = sortedCoins()
  }

  let done, newLoc, dir
  while (!done && targets.length > 0) {
    t = targets.shift()
    if ((xdist(t) <= ydist(t) || ydist(t) == 0) && xdist(t) != 0) {
      let xmove = Math.sign(t[0] - me.locationX)
      dir = xmove < 0 ? 'west' : 'east'
      newLoc = [me.locationX + xmove, me.locationY]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }

    if (!done) {
      let ymove = Math.sign(t[1] - me.locationY)
      dir = ['north', 'none', 'south'][ymove + 1]
      newLoc = [me.locationX, me.locationY + ymove]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }
  }

  if (!done)
    dir = 'none'

  return dir
}

इसे ऑनलाइन आज़माएं!

(मूल कोड में एक बग को इंगित करने के लिए @ OMᗺ के लिए धन्यवाद जो इस पर आधारित था।)

खुद से कम सिक्कों वाले "बॉट" खाने से बढ़ने की कोशिश करता है। यदि यह संभव नहीं है (ऐसा कोई बॉट मौजूद नहीं है), तो निकटतम सिक्के की तलाश करता है।

इस संस्करण में चांदी के सिक्कों की तुलना में (a) सोने के सिक्कों को अधिक तरजीह दी गई है - इस जोखिम के साथ कि अधिक दूर के सोने के सिक्के की मांग करना बॉट के जीवन की लागत को समाप्त कर सकता है या मूर्ख के सोने के बाद पीछा करने के लिए नेतृत्व कर सकता है (b) बॉट को छोड़ दें 0 सिक्के - उन लोगों के बाद का समय बर्बाद करने की कोई जरूरत नहीं है।

— सुन्दर
स्रोत

एक स्मार्ट शिकारी ... अच्छा, यह और भी बेहतर है!

— रेडवॉल्फ कार्यक्रम

@RedwolfPrograms चलो आशा करते हैं! :)

— sundar

इस डैमसी को बुलाया जाना चाहिए;)

— बीटा

1

@BetaDecay विश किया।

— सूंदर

4

विनम्र निकट दृष्टि नशे में बॉट | जावास्क्रिप्ट

function politeNearSightedDrunkBot(me, others, coins) {
  let directions = ['none','east','south','west','north']
  let drunkennessCoefficient = .2
  let nearSightedness = me.arenaLength - others.length + 2
  //drawCircle(me.locationX, me.locationY, nearSightedness*squareSize)

  function randomInt(a) {
    return Math.floor(Math.random() * a);
  }
  function getRandomDirection() {
    return ['east', 'west', 'north', 'south'][randomInt(4)]
  }

  function distanceTo(a) {
    return (Math.abs(a[0] - me.locationX) + Math.abs(a[1] - me.locationY))
  }
  function distanceBetween(a, b){
    return (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]))
  }
  function isTargetSafe(a) {
    for (let i = 0; i < others.length; i++) {
      if (others[i][2] >= me.coins && distanceBetween(a, others[i]) <= distanceTo(a)) {
        return false //unnecessary loop, but I don't want to split out into a function
      }
    }
    return true
  }
  function amISafe() {
    for (let i = 0; i < others.length; i++) {
      if (others[i][2] >= me.coins && distanceTo(others[i]) == 1) {
        /*let num = botNotes.getData('turnsSpentAdjacentToEnemy')
        if (!num) {
          console.log('politeNearSightedDrunkBot: Woops!')
          botNotes.storeData('turnsSpentAdjacentToEnemy', 1)
        } else if (num == 1) {
          console.log('politeNearSightedDrunkBot: \'Scuse me...')
          botNotes.storeData('turnsSpentAdjacentToEnemy', 2)
        } else if (num == 2) {
          console.log('politeNearSightedDrunkBot: D\'ye mind?')
          botNotes.storeData('turnsSpentAdjacentToEnemy', 3)
        } else if (num == 3) {
          console.log('politeNearSightedDrunkBot: Bugger off!')
        }*/
        return false
      }
    }
    return true
  }
  function getSafeDirections() {
    let candidates = {'none': true, 'east': true, 'south': true, 'west': true, 'north': true}
    if (me.locationY == 0) {
      candidates['north'] = false
    } else if (me.locationY == me.arenaLength - 1) {
      candidates['south'] = false
    }
    if (me.locationX == 0) {
      candidates['west'] = false
    } else if (me.locationX == me.arenaLength - 1) {
      candidates['east'] = false
    }
    if (!amISafe()) {
      candidates['none'] = false
    }/* else {
      botNotes.storeData('turnsSpentAdjacentToEnemy', 0)
    }*/
    if (candidates['north'] && !isTargetSafe([me.locationX, me.locationY-1])) {
      candidates['north'] = false
    }
    if (candidates['south'] && !isTargetSafe([me.locationX, me.locationY+1])) {
      candidates['south'] = false
    }
    if (candidates['west'] && !isTargetSafe([me.locationX-1, me.locationY])) {
      candidates['west'] = false
    }
    if (candidates['east'] && !isTargetSafe([me.locationX+1, me.locationY])) {
      candidates['east'] = false
    }
    if (candidates['none']) {
    }
    return candidates
  }
  function getSafeCoins() {
    let safestCoins = []
    let coinSizes = [5, 2, 2, 2, 2]
    for (let i = 0; i < coins.length; i++) {
      let distanceToThisCoin = distanceTo(coins[i])
      if (distanceToThisCoin < nearSightedness && isTargetSafe(coins[i])) {
        safestCoins.push([coins[i][0], coins[i][1], coinSizes[i], distanceToThisCoin])
        //alert('Coin at (' + coins[i][0] + ', ' + coins[i][1] + ') is safe!')
      }
    }
    if (safestCoins.length == 0) {
      //alert('No safe coins!')
    }
    return safestCoins
  }

  function getAdditiveBestDirectionToTargets(targets) {
    let candidates = {'east': 0, 'south': 0, 'west': 0, 'north': 0}
    for (let i = 0; i < targets.length; i++) {
      if (targets[i][0] < me.locationX) { 
        candidates['west'] = candidates['west'] + targets[i][2]/targets[i][3]
      } else if (targets[i][0] > me.locationX) {
        candidates['east'] = candidates['east'] + targets[i][2]/targets[i][3]
      }
      if (targets[i][1] > me.locationY) { 
        candidates['south'] = candidates['south'] + targets[i][2]/targets[i][3]
      } else if (targets[i][1] < me.locationY) {
        candidates['north'] = candidates['north'] + targets[i][2]/targets[i][3]
      }
    }
    for (let key in candidates) {
      //alert(key + ': ' + candidates[key])
    }
    return candidates
  }

    let targetCoins = getSafeCoins()
    let safeDirections = getSafeDirections()
    let chosenDir = null
    if (targetCoins.length > 0) {
      //alert('Coins found! Exactly ' + targetCoins.length)
      let weightedDirections = getAdditiveBestDirectionToTargets(targetCoins)
      let bestOptionWeight = 0
      let choices = []
      for (let key in safeDirections) {
        if (safeDirections[key] && key != 'none') {
          if (weightedDirections[key] == bestOptionWeight) {
            choices.push(key)
          } else if (weightedDirections[key] > bestOptionWeight) {
            choices = [key]
            bestOptionWeight = weightedDirections[key]
          }
        }
      }
      if (choices.length > 0) {
        //alert('Picking from choices, ' + choices.length + ' options and best weight is ' + bestOptionWeight)
        chosenDir = choices[randomInt(choices.length)]
      } else {
        //alert('No safe choices!')
      }
    } else {
      let lastDir = botNotes.getData('direction') || 'none'
      if (safeDirections[lastDir] && Math.random() >= drunkennessCoefficient) {
        chosenDir = lastDir
      }
    }

    if (!chosenDir) {
      //alert('indecisive!')
      let choices = []
      for (key in safeDirections) {
        if (safeDirections[key]) {
          choices.push(key)
        }
      }
      if (choices.length > 0) {
        chosenDir = choices[randomInt(choices.length)]
      } else {
        chosenDir = getRandomDirection()
      }
    }

    botNotes.storeData('direction', chosenDir)
    //alert('Moving ' + chosenDir)
    return chosenDir
}

आस-पास के सिक्कों को लेने के लिए डगमगाते हैं, लेकिन बेतरतीब ढंग से हर बार दिशाओं को बदलते हैं। क्या वह किसी में टकराव से बचने के लिए कर सकता है, लेकिन वह ... जुझारू ... जब उत्तेजित हो जाता है। प्रतियोगिता के शुरू होते ही शांत हो जाता है।

कुछ डिबगिंग की आवश्यकता हो सकती है, जब नियंत्रक पूरी तरह से हो जाता है तो मैं इस पर काम करूंगा।

— एनपी
स्रोत

3

हम्म, यह बार उठाता है, फिर उस पर नशे में हो जाता है

— रेडवॉल्फ कार्यक्रम 21

4

भारित मोशन | जावास्क्रिप्ट

WeightedMotion=(myself,others,coins)=>{
  x=myself.locationX;
  y=myself.locationY;
  power=myself.coins;
  arenaSize=myself.arenaLength;
  dirX=0;
  dirY=0;
  for(i=0;i<coins.length;i++){
    if(i==0){
      dirX+=5/(x-coins[i][0]);
      dirY+=5/(y-coins[i][1]);
    }
    else{
      dirX+=2/(x-coins[i][0]);
      dirY+=2/(y-coins[i][1]);
    }
  }
  for(i=0; i<others.length;i++){
    dirX+=(power-others[i][2])/(2*(x-others[i][0]));
    dirY+=(power-others[i][2])/(2*(y-others[i][1]));
  }
  if(Math.abs(dirX)>Math.abs(dirY)){
    if(dirX>0){
      if(x>0){return "west";}
      else{
        if(dirY>0){if(y>0)return "north";}
        else if(dirY<0){if(y<arenaSize-1)return "south";}
      }
    }
    else if(x<arenaSize-1){return "east";}
    else{
      if(dirY>0){if(y>0)return "north";}
      else if(dirY<0){if(y<arenaSize-1)return "south";}
    }
  }
  else{
    if(dirY>0){
      if(y>0){return "north";}
      else{
        if(dirX>0){if(x>0)return "west";}
        else if(dirX<0){if(x<arenaSize-1)return "east";}
      }
    }
    else if(y<arenaSize-1){return "south";}
    else{
      if(dirX>0){if(x>0)return "west";}
      else if(dirX<0){if(x<arenaSize-1){return "east";}
    }
  }
  return "none";
}

बोर्ड के किनारे से भागने से बचने के दौरान इसे उस दिशा में ले जाया जाता है, जिसने उच्चतम मूल्य निर्धारित किया है।

मूल्य की गणना इस तरह की जाती है:

सिक्का = सिक्के की शक्ति / दूरी
बॉट = बॉट की शक्ति में अंतर / 2 * बॉट की दूरी

— fənɛtɪk
स्रोत

1

ठीक है, यह एक बहुत बढ़िया बॉट जैसा दिखता है। दिशाओं की जांच करना सुनिश्चित करें, क्योंकि यह वास्तविक नुकसान होगा यदि आपका बॉट सिक्कों से दूर भागने में एक मास्टर था : (

— रेडवुल्फ प्रोग्राम्स

खैर, अभी भी। मुझे अच्छा लग रहा है, है ना?

— रेडवॉल्फ प्रोग्राम्स

खैर, इसे पोस्ट करें! यह छोटे, तेज़ बॉट्स के लिए बनेगा जो इस समय बड़ी मात्रा में मौजूद हैं।

— रेडवुल्फ प्रोग्राम्स

for(i=0;i<6;i++){कुल 5 सिक्के हैं, 1 सोना और 4 चांदी। आपका पाश 0 से 5 पर 6 बार चल रहा है

— Night2

3

अंधे | जावास्क्रिप्ट (Node.js)

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

function(myself, others, coins){
    mx = myself.locationX
    my = myself.locationY
    l="west"
    r="east"
    u="north"
    d="south"
    n="none"

    if(coins.length == 0)
        return n

    var closestCoin = coins.sort(a=>Math.sqrt(Math.pow(mx-a[0],2) + Math.pow(my-a[1],2))).pop()
    cx = closestCoin[0]
    cy = closestCoin[1]

    return mx>cx?l:mx<cx?r:my>cy?u:my<cy?d:n
}

— लुइस फेलिप डी जीसस मुनोज
स्रोत

हम्म, यह काम कर सकता है क्योंकि अन्य बॉट मुख्य रूप से सोने की मांग कर रहे हैं, संभवतः आपको बिना किसी लड़ाई के रजत प्राप्त करने के लिए छोड़

— देगा

3

सामंती महान | जावास्क्रिप्ट

पसंदीदा रंग: #268299

function (noble, peasants, coins) {
    var center = (noble.arenaLength - 1) / 2, centerSize = noble.arenaLength / 4, peasantsCount = peasants.length,
        centerMin = center - centerSize, centerMax = center + centerSize, apocalypse = 2e4 - ((noble.arenaLength * 2) + 20), inDanger = false;

    var round = botNotes.getData('round');
    if (round === null || !round) round = 0;
    round++;
    botNotes.storeData('round', round);

    var getDistance = function (x1, y1, x2, y2) {
        return (Math.abs(x1 - x2) + Math.abs(y1 - y2)) + 1;
    };

    var isAtCenter = function (x, y) {
        return (x > centerMin && x < centerMax && y > centerMin && y < centerMax);
    };

    var getScore = function (x, y) {
        var score = 0, i, centerFactor = 10;

        for (i = 0; i < peasantsCount; i++) {
            var peasantCoins = peasants[i][2], peasantDistance = getDistance(x, y, peasants[i][0], peasants[i][1]);

            if (noble.coins > peasantCoins && isAtCenter(x, y)) {
                score += Math.min(100, peasantCoins) / peasantDistance;
            } else if (noble.coins <= peasantCoins && peasantDistance <= 3) {
                score -= (peasantDistance === 3 ? 50 : 2000);
                inDanger = true;
            }
        }

        for (i = 0; i < coins.length; i++) {
            if (isAtCenter(coins[i][0], coins[i][1])) {
                var coinDistance = getDistance(x, y, coins[i][0], coins[i][1]),
                    coinValue = (i === 0 ? 500 : 200),
                    coinCloserPeasants = 1;

                for (var j = 0; j < peasantsCount; j++) {
                    var coinPeasantDistance = getDistance(peasants[j][0], peasants[j][1], coins[i][0], coins[i][1]);
                    if (coinPeasantDistance <= coinDistance && peasants[j][2] >= noble.coins) coinCloserPeasants++;
                }

                score += (coinValue / coinCloserPeasants) / (coinDistance / 3);
            }
        }

        if (round >= apocalypse) centerFactor = 1000;
        score -= getDistance(x, y, center, center) * centerFactor;

        return score;
    };

    var possibleMoves = [{x: 0, y: 0, c: 'none'}];
    if (noble.locationX > 0) possibleMoves.push({x: -1, y: 0, c: 'west'});
    if (noble.locationY > 0) possibleMoves.push({x: -0, y: -1, c: 'north'});
    if (noble.locationX < noble.arenaLength - 1) possibleMoves.push({x: 1, y: 0, c: 'east'});
    if (noble.locationY < noble.arenaLength - 1) possibleMoves.push({x: 0, y: 1, c: 'south'});

    var topCommand, topScore = null;
    for (var i = 0; i < possibleMoves.length; i++) {
        var score = getScore(noble.locationX + possibleMoves[i].x, noble.locationY + possibleMoves[i].y);
        if (topScore === null || score > topScore) {
            topScore = score;
            topCommand = possibleMoves[i].c;
        }
    }

    if (round >= apocalypse) {
        var dg = botNotes.getData('dg');
        if (dg === null || !dg) dg = [];
        if (dg.length >= 20) dg.shift();
        dg.push(inDanger);
        botNotes.storeData('dg', dg);
        if (dg.length >= 20) {
            var itsTime = true;
            for (i = 0; i < dg.length; i++) if (!dg[i]) itsTime = false;
            if (itsTime) return 'none';
        }
    }

    return topCommand;
}

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

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

— Night2
स्रोत

2

क्वांटम ज्ञान बॉट | जावास्क्रिप्ट

function quantumGnatBot(me, others, coins) {
  let quantumCoefficient = .2
  let turn = botNotes.getData('turn')
  botNotes.storeData('turn', turn+1)
  botNotes.storeData('test', [2, 5, 7])
  botNotes.getData('test')
  let dG = {'none': [0, 0, -2, -2], 'east': [1, 0, me.arenaLength-1, -2], 'south': [0, 1, -2, me.arenaLength-1], 'west': [-1, 0, 0, -2], 'north': [0, -1, -2, 0]}

  function randomInt(a) {
    return Math.floor(Math.random() * a);
  }
  function getRandomDirection() {
    return ['east', 'west', 'north', 'south'][randomInt(4)]
  }
  function distanceBetween(a, b){
    return (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]))
  }
  function isTargetSafe(a) {
    for (let i = 0; i < others.length; i++) {
      if (others[i][2] >= me.coins && distanceBetween(a, others[i]) <= 1) {
        return false
      }
    }
    return true
  }
  function isEnemySquare(a) {
    for (let i = 0; i < others.length; i++) {
      if (distanceBetween(a, others[i]) == 0) {
        return true
      }
    }
    return false
  }
  function getSafeDirections() {
    let candidates = {'none': true, 'east': true, 'south': true, 'west': true, 'north': true}
    for (let key in dG) {
      if (me.locationX == dG[key][2] || me.locationY == dG[key][3] || !isTargetSafe([me.locationX+dG[key][0], me.locationY+dG[key][1]])) {
        candidates[key] = false
      }
    }
    //alert('Safe: ' + candidates['north'] + ', ' + candidates['east'] + ', ' + candidates['south'] + ', ' + candidates['west'])
    return candidates
  }
  function getThreatDirections() {
    let candidates = {'none': false, 'east': false, 'south': false, 'west': false, 'north': false}
    for (let key in dG) {
      if (isEnemySquare([me.locationX+dG[key][0], me.locationY+dG[key][1]])) {
        candidates[key] = true
      }
    }
    return candidates
  }
  function getTargetDirections() {
    let targetBot = null
    let candidates = {'none': false, 'east': false, 'south': false, 'west': false, 'north': false}
    for (let i = 0; i < others.length; i++) {
      if (distanceBetween([me.locationX, me.locationY], others[i]) > 2 && (!targetBot || targetBot[2] < others[i][2])) {
        targetBot = others[i]
      }
    }
    if (targetBot[0] < me.locationX) {
      candidates['west'] = true
    } else if (targetBot[0] > me.locationX) {
      candidates['east'] = true
    }
    if (targetBot[1] > me.locationY) {
      candidates['south'] = true
    } else if (targetBot[1] < me.locationY) {
      candidates['north'] = true
    } 
    //alert('Chasing ' + targetBot[0] + ', ' + targetBot[1] + ' (' + targetBot[2] + ')')
    //alert('Path: ' + candidates['north'] + ', ' + candidates['east'] + ', ' + candidates['south'] + ', ' + candidates['west'])
    return candidates
  }

  let safeDirections = getSafeDirections()
  let threatDirections = getThreatDirections()
  let targetDirections = getTargetDirections()
  let chosenDir = null
  let choices = []
  for (key in safeDirections) {
    if (safeDirections[key] && targetDirections[key]) {
      choices.push(key)
    }
  }
  if (choices.length == 0) {
    //alert('Best options are blocked...')
    for (key in safeDirections) {
      if (safeDirections[key]) {
        choices.push(key)
      }
    }
  }
  for (key in threatDirections) {
    if (threatDirections[key] && Math.random() < quantumCoefficient) {
      //alert('Chance for quantum swap!')
      choices.push(key)
    }
  }
  if (choices.length > 0) {
    chosenDir = choices[randomInt(choices.length)]
  } else {
    //alert('No options? Guess we spin the wheel.')
    chosenDir = getRandomDirection()
  }

  return chosenDir
}

यह कष्टप्रद बॉट स्वाट हो जाने के बिना सबसे मजबूत बॉट के चारों ओर गूंजने की कोशिश करता है और इसके शिकार होने की कोशिश करने वालों के माध्यम से चरणबद्ध होने की थोड़ी संभावना है। यह दो सबसे शक्तिशाली बॉट्स को निकटता में खींचने की प्रवृत्ति है ...;)

— एनपी
स्रोत

यदि वह एक उपयुक्त लक्ष्य नहीं खोज सकता है getTargetDirections(), तो दिलचस्प चीजें होने लगती हैं। (जैसे undefined has no property 0त्रुटि के कारण सब कुछ तोड़ना ।)

— रामलीज

2

सेवानिवृत्त आईसीई एजेंट, जावास्क्रिप्ट

पसंदीदा रंग: indianred

function(me, others, coins) {
    me.arenaLength = me.arenaLength - 1;
    // Calculate the average coin value of bots
    var avg = 2;

    for (var i = 0; i < others.length; i++) {
    avg += others[i][2];
    }

    avg /= others.length;

    // Find nearest coins
    var min = [];
    var min_distance = 100000
    for (var j = 0; j < coins.length; j++) {
    var distance = Math.sqrt(Math.pow(me.locationX - coins[j][0],2) + Math.pow(me.locationY - coins[j][1],2));
    if (distance < min_distance) {
        min_distance = distance;
        min = coins[j];
    }
    }

    if (me.coins <= avg || min_distance < 5) {
    // If own coinage is lower than the average or a coin is very close, find some coins

    // Move straight to the nearest coin
    if (me.locationY != min[1]) {
        if (me.locationY - min[1] > 0) {
        return "north";
        } else {
        return "south";
        }
    } else {
        if (me.locationX - min[0] > 0) {
        return "west";
        } else {
        return "east";
        }
    }
    } else {
        // You have enough money to eat most bots
        // Find the weakest bot
        var weakling = [];
        var weakling_money = 1000000;

        for (var k = 0; k < others.length; k++) {
            if (others[k][2] < weakling_money) {
                weakling_money = others[k][2];
                weakling = others[k];
            }
        }

        // Move to the weakest bot
        if (me.locationY != weakling[1]) {
            if (me.locationY - weakling[1] > 0) {
                return "north";
            } else {
                return "south";
            }
        } else {
            if (me.locationX - weakling[0] > 0) {
                return "west";
            } else {
                return "east";
            }
        }
    }
}

अब सेवानिवृत्त, यह आईसीई एजेंट मानवता के बारे में कड़वा है। नतीजतन, रिटायर्ड ICE अब सबसे कमजोर बॉट को निशाना बनाता है, जबकि इसके सिक्के का मूल्य औसत से ऊपर है (ICE पॉलिसी के अनुसार)।

— बीटा डिके
स्रोत

2

लालची-पीछा | हास्केल

पसंदीदा रंग: #62bda4

import Data.List

f x y c _ bs _
  | [bx,by,_]:_ <- sortByDist x y $ filter ((c>).last) bs = toDir (bx-x,by-y)
f x y _ _ _ cs
  | [cx,cy,_]:_ <- sortByDist x y cs = toDir (cx-x,cy-y)
f _ _ _ _ _ _ = "none"


sortByDist x y = sortOn (\[bx,by,_]-> abs (bx-x) + abs (by-y))

toDir (dx,dy)
  | dx > 0 = "east"
  | dx < 0 = "west"
  | dy > 0 = "south"
  | dy < 0 = "north"
  | otherwise = "none"

इसे ऑनलाइन आज़माएं! ^*

सुंदर सरल रणनीति, पहले निर्णय से चुनती है:

यदि कम सिक्कों के साथ बॉट्स हैं: निकटतम उठाएं और उसकी ओर बढ़ें
अगर सिक्के हैं: निकटतम उठाओ और उसकी ओर बढ़ें
डिफ़ॉल्ट: रहना

बॉट केवल संभावित मजबूत बॉट्स की परवाह किए बिना अन्य बॉट्स या सिक्कों को पकड़ने की कोशिश करता है जो इसे पकड़ने की कोशिश कर सकते हैं।

_{* मैं वास्तव में जावास्क्रिप्ट नहीं जानता, लेकिन मैंने Google के साथ काम किया (गलत हो सकता है): इसे ऑनलाइन आज़माएं!}

— ბიმო
स्रोत

6

मुझे आश्चर्य है कि वह कैसे हेकेल को जेएस में अनुवाद करने जा रहा है

— लुइस फेलिप डी जेउस मुनोज

3

@LuisfelipeDejesusMunoz: हाँ मुझे भी। लेकिन सौभाग्य से, यह बहुत परिष्कृत कोड नहीं है।

— ।

@LuisfelipeDejesusMunoz बस कुछ पार्सिंग के साथ Node.JS और process.open(या child_process.spawn, या समान) का उपयोग करें ।

— user202729

@LuisfelipeDejesusMunoz: मैंने इसका अनुवाद करने की कोशिश की और एक लिंक जोड़ा, लेकिन मुझे जावास्क्रिप्ट लिखने में बहुत आत्मविश्वास नहीं है, इसलिए यह छोटी गाड़ी हो सकती है।

— ।

4

@LuisfelipeDejesusMunoz यह एक बात होगी अगर यह एक 10,000 लाइन एअर इंडिया सीखने का कार्यक्रम था, लेकिन मुझे लगता है कि मैं इसे प्रबंधित कर सकता हूं: (:

— रेडवॉल्फ कार्यक्रम

1

सिक्का चुंबक | जावास्क्रिप्ट

CoinMagnet=(myself,others,coins)=>{
  x=myself.locationX;
  y=myself.locationY;
  power=myself.coins;
  arenaSize=myself.arenaLength;
  dirX=0;
  dirY=0;
  for(i=0;i<coins.length;i++){
    if(i==0){
      dirX+=(coins[i][0]-x)*3
      dirY+=(coins[i][1]-y)*3
    }
    dirX+=(coins[i][0]-x)*2
    dirY+=(coins[i][1]-y)*2
  }
  for(i=0;i<others.length;i++){
    dirX+=Math.ceil(0.85*others[i][2])*(others[i][0]-x)
    dirX+=Math.ceil(0.85*others[i][2])*(others[i][1]-y)
  }
  if(Math.abs(dirX)>Math.abs(dirY)){
    if(dirX>0){return "east";}
    else{return "west";}
  }
  else if(dirY!=0){
    if(dirY>0){return "south";}
    else{return "north";}
  }
  return "none";
}

यह बॉट गूंगा है, यह सबसे परिचित सिक्कों की दिशा में है। इसमें ऐसे सिक्के शामिल हैं जो इसे प्राप्त नहीं कर सकते क्योंकि अन्य बॉट में स्वयं की तुलना में अधिक शक्ति है।

— fənɛtɪk
स्रोत

1

ICE Agent | जावास्क्रिप्ट

function(me, others, coins) {
    me.arenaLength = me.arenaLength - 1;
    // Calculate the average coin value of bots
    var avg = 2;

    for (var i = 0; i < others.length; i++) {
        avg += others[i][2];
    }

    avg /= others.length;

    // Find nearest coins
    var min = [];
    var min_distance = 100000
    for (var j = 0; j < coins.length; j++) {
        var distance = Math.sqrt(Math.pow(me.locationX - coins[j][0],2) + Math.pow(me.locationY - coins[j][1],2));
        if (distance < min_distance) {
            min_distance = distance;
            min = coins[j];
        }
    }

    if (me.coins <= avg || min_distance < 5) {
        // If own coinage is lower than the average or a coin is very close, find some coins

        // Move straight to the nearest coin
        if (me.locationY != min[1]) {
            if (me.locationY - min[1] > 0) {
                return "north";
            } else {
                return "south";
            }
        } else {
            if (me.locationX - min[0] > 0) {
                return "west";
            } else {
                return "east";
            }
        }
    } else {
        // You have enough money to eat most bots
        // Check if already on border
        if (me.locationX == 0 || me.locationX == me.arenaLength || me.locationY == 0 || me.locationY == me.arenaLength) {
            // Move anticlockwise around the border
            if (me.locationX == 0 && me.locationY != 0 && me.locationY != me.arenaLength) {
                return "south";
            }
            if (me.locationX == 0 && me.locationY == 0) {
                return "south";
            }

            if (me.locationY == me.arenaLength && me.locationX != 0 && me.locationX != me.arenaLength) {
                return "east";
            }
            if (me.locationX == 0 && me.locationY == me.arenaLength) {
                return "east";
            }

            if (me.locationX == me.arenaLength && me.locationY != 0 && me.locationY != me.arenaLength) {
                return "north";
            }
            if (me.locationX == me.arenaLength && me.locationY == me.arenaLength) {
                return "north";
            }

            if (me.locationY == 0 && me.locationX != 0 && me.locationX != me.arenaLength) {
                return "west";
            }
            if (me.locationX == me.arenaLength && me.locationY == 0) {
                return "west";
            }
        } else {
            // Find the nearest border and move to it
            if (me.locationX <= me.arenaLength - me.locationX) {
                // Move to left border
                return "west";
            } else {
                // Move to right border
                return "east";
            }
        }
    }
}

यदि गश्त नहीं की जा रही है तो सीमा का क्या मतलब है? आईसीई सीमा के चारों ओर एंटीलॉकवाइज चलता है, जो किसी भी बॉट को उठाता है जो उसके रास्ते में भटक जाता है।

इससे पहले कि वह ऐसा कर सके, उसे पहले अन्य बॉट्स खाने में सक्षम होना चाहिए। उस कारण से, ICE, सभी बॉट्स के औसत से ऊपर अपने सिक्के रखता है।

_{अपने माता-पिता से बच्चों को चोरी करने की गारंटी ™}

— बीटा डिके
स्रोत

अगर यह इतना प्रासंगिक नहीं होता तो यह और भी मज़ेदार होता

— डॉन

1

एक्स मार्क्स द स्पॉट | जावास्क्रिप्ट

function(me, others, coins){
    if (me.locationY != 0) {
        // If not on X axis
        if (others.every(other => other[1]==me.locationY-1)) {
            // If any in my way
            if (!others.every(other => other[0]==me.locationX-1)) {
                if (me.locationX != 0) {
                    // If no one to my left and not on edge of board
                    return "west"
                } else {
                    return "none"
                }
            } else if (!others.some(other => other[0]==me.locationX+1)) {
                if (me.locationX != me.arenaLength-1) {
                    // If no one to my right and not on edge of board
                    return "east"
                } else {
                    return "none"
                }
            } else {
                // I'm surrounded
                return "none"
            }
        } else {
            // No one in my way
            return "north"
        }
    } else {
        // If on the x axis
        if (!others.some(other => Math.abs(other[0]-me.locationX)==1 && other[1] == me.locationY)) {
            // If no one next to me
            move = ["east","west"][Math.floor(Math.random()*2)]

            // Prevent from falling off the board
            if (move == "east" && me.locationX == me.arenaLength-1) {
                return "west"
            } else if (move == "west" && me.locationX == 0) {
                return "east"
            } else {
                return move
            }
        } else {
            // I'm surrounded
            return "none"
        }
    }
}

एक्स स्पॉट को चिह्नित करता है, इसलिए सभी सोना एक्स अक्ष पर होना चाहिए, है ना? मेरा बॉट y = 0 लाइन के लिए एक बीलाइन बनाता है, फिर वहाँ रहता है, बेतरतीब ढंग से घूम रहा है।

— बीटा डिके
स्रोत

हुह, वास्तव में एक दिलचस्प तरीका है

— रेडवॉल्फ कार्यक्रम

1

जेएस (...) में पायथन (2, दुर्भाग्य से) दुभाषिया

— 16:20 पर user202729

1

कि यह देखते हुए The arena starts at (0,0) in the upper left corner, क्या आप वाकई ले जाना चाहते हैं southपाने के लिए y=0?

— AdmBorkBork

@AdmBorkBork धन्यवाद, जो खराब हो सकता था

— बीटा

1

Firebird

    function(me,others,coins) {
        var x = me.locationX;
        var y = me.locationY;
        var safe = [true, true, true, true];
        var threats = [];
        var targets = [];
        var opps = [];

        var meTo = (loc) => (Math.abs(x - loc[0]) + Math.abs(y - loc[1]));
        var inSquare = (loc, r) => (Math.abs(loc[0] - x) <= r && Math.abs(loc[1] - y) <= r);
        var distance = (from, loc) => (Math.abs(from[0] - loc[0]) + Math.abs(from[1] - loc[1]));
        var attackRange = (from, check, r) => {
            for (var i = 0; i < check.length; i++) {
                if (distance(check[i], from) == (r || 1)) {
                    return true;
                }
            }
            return false;
        };
        var dirStr = (dir) => (['north','east','south','west'][dir]);

        var i, n, o, p;
        for (i = 0; i < others.length; i++) {
            o = others[i];
            if (o[2] >= me.coins) {
                threats.push(o);
            } else {
                targets.push([o[0], o[1], Math.floor(o[2] * 0.55)]);
            }
        }
        for (i = 1; i < 5; i++) {
            targets.push([coins[i][0], coins[i][1], 2]);
        }
        targets.push([coins[0][0], coins[0][1], 5]);
        if (y === 0 || attackRange([x, y - 1], threats)) {
            safe[0] = false;
        }
        if (x == me.arenaLength - 1 || attackRange([x + 1, y], threats)) {
            safe[1] = false;
        }
        if (y == me.arenaLength - 1 || attackRange([x, y + 1], threats)) {
            safe[2] = false;
        }
        if (x === 0 || attackRange([x - 1, y], threats)) {
            safe[3] = false;
        }
        if (safe.includes(false)) {
            if (!(safe[0]) && safe[2]) {
               opps.push(2);
            }
            if (!(safe[1]) && safe[3]) {
                opps.push(3);
            }
            if (!(safe[2]) && safe[0]) {
                opps.push(0);
            }
            if (!(safe[3]) && safe[1]) {
                opps.push(1);
            }
        } else {
            targets.sort((a,b)=>(meTo(a) - meTo(b)));
            o = targets[0];
            if (o[0] == x) {
                if (o[1] < y) {
                    return 'north';
                } else {
                    return 'south';
                }
            } else if (o[1] == y) {
                if (o[0] < x) {
                    return 'west';
                } else {
                    return 'east';
                }
            } else if (Math.abs(o[0] - x) < Math.abs(o[1] - y)) {
                if (o[1] < y) {
                    return 'north';
                } else {
                    return 'south';
                }
            } else if (Math.abs(o[0] - x) > Math.abs(o[1] - y)) {
                if (o[0] < x) {
                    return 'west';
                } else {
                    return 'east';
                }
            }
        }
        console.log(safe[opps[0]]);
        var lx, ly;
        for (i = 0; i < opps.length; i++) {
            if (opps[i] === 0) {
                lx = x;
                ly = y - 1;
            }
            if (opps[i] == 1) {
                lx = x + 1;
                ly = y;
            }
            if (opps[i] == 2) {
                lx = x;
                ly = y + 1;
            }
            if (opps[i] == 3) {
                lx = x - 1;
                ly = y;
            }
            if (attackRange([lx, ly], targets, 0)) {
                return dirStr(opps[i]);
            }
        }
        return dirStr(opps[0]);
    }

पूरी तरह से पहले की तुलना में अधिक घातक होने के लिए पुर्नोत्थान (:

— Redwolf कार्यक्रम
स्रोत

2

एक बॉट का मेरा पूर्ण

— परित्याग

यह उन्हें निशाना नहीं बना रहा है, यह उनसे बच रहा है

— Redwolf प्रोग्राम्स

ओह सॉरी, मुझे गलत समझा गया

— बीटा डेके

1

उ० — पथ-य | जावास्क्रिप्ट

इस बॉट के लिए पसंदीदा रंग है #0077b3।

 run: function (me, others, coins)
{
    var X_INDEX = 0;
    var Y_INDEX = 1;
    var COIN_INDEX = 2;

    var GOLD_POINTS = 5;
    var SILVER_POINTS = 2;

    var NORTH = 0;
    var SOUTH = 1;
    var WEST = 2;
    var EAST = 3;
    var IDLE = 4;
    var MOVE_COMMANDS_COUNT = IDLE+1;

    var MAP_TYPE_BLANK = 0;
    var MAP_TYPE_BOT = 1;
    var MAP_TYPE_GOLD_COIN = 2;
    var MAP_TYPE_SILVER_COIN = 3;

    var MIDGAME_THRESHOLD = 25;

    var PATH_FINDING_MAX_STEPS = 10000;
    var offsets = [[0,-1],[1,0],[0,1],[-1,0]];

function randInt(min,max)
    {
        return  Math.floor(Math.random() * ((max - min) + 1)) + min;
    }


    /**
     * Find a path using a*, returns the direction to take from the starting position coupled with a metric describing the cost of the path
     */
function pathFind(startX,startY,targetX,targetY,map,mapSize)
    {
        var i;
        var j;

        // shuffleIndecies to make path selection slightly random
        var indecies = [0,1,2,3];
        var shuffleIndecies = new Array(4);
        for (j=0;j<4;j++)
        {
            var randomIndex = randInt(0,3-j);
            shuffleIndecies[j] = indecies[randomIndex];
            indecies[randomIndex] = indecies[0];
            var lastElementIndex = 4-j-1;
            indecies[0] = indecies[lastElementIndex];
        }

        // A*
        if (!(startX===targetX && startY===targetY))
        {

            var tileX = new Array(PATH_FINDING_MAX_STEPS);
            var tileY = new Array(PATH_FINDING_MAX_STEPS);
             var fscore = new Array(PATH_FINDING_MAX_STEPS);
             var gscore = new Array(PATH_FINDING_MAX_STEPS);
             var openList = new Array(PATH_FINDING_MAX_STEPS);
             var tileParent = new Array(PATH_FINDING_MAX_STEPS);
             var tileIsClosed = new Array(mapSize);

             for (i = 0;i<PATH_FINDING_MAX_STEPS;i++)
             {
                 tileX[i]=0;
                 tileY[i]=0;
                 fscore[i]=0;
                 gscore[i]=0;
                 openList[i]=0;
                 tileParent[i]=0;
             }


             for (i = 0;i<mapSize;i++)
             {
                 var newArray = new Array(mapSize);
                 tileIsClosed[i] = newArray;
                 for (j = 0;j<mapSize;j++)
                 {
                     tileIsClosed[i][j] = 0;
                 }
             }

             var currentIndex = -1;     

            var openListSize=1;
            var tileId=1;

            tileX[0]=targetX;
            tileY[0]=targetY;
            fscore[0]=1;
            gscore[0]=map[targetX][targetY].negativeWeight;



            do
            {
              var currentBestIndex=-1;
              var currentBestScore=2147483647;
              //  Look for the lowest F cost square on the open list
              for (var ii=0;ii<openListSize;ii++)
              {
                if (fscore[openList[ii]]<currentBestScore)
                {
                  currentBestScore=fscore[openList[ii]];
                  currentBestIndex=ii;
                }
              }
              if (currentBestIndex===-1)
              {
                break;
              }
              currentIndex=openList[currentBestIndex];
              var currentTileX=tileX[currentIndex];
              var currentTileY=tileY[currentIndex];

              // found path
              if (startX===currentTileX && startY===currentTileY)
              {
                break;
              }

              // if not in closed list
              if (tileIsClosed[currentTileX][currentTileY]===0)
              {
                    // Switch it to the closed list.
                    tileIsClosed[currentTileX][currentTileY]=1;
                    // remove from openlist
                    openList[currentBestIndex]=openList[--openListSize];   

                    // add neighbours to the open list if necessary
                    for (j=0;j<4;j++)
                    {
                        i = shuffleIndecies[j];

                        var surroundingCurrentTileX=currentTileX+offsets[i][0];
                        var surroundingCurrentTileY=currentTileY+offsets[i][1];
                        if (surroundingCurrentTileX>=0 && surroundingCurrentTileX<mapSize &&
                            surroundingCurrentTileY>=0 && surroundingCurrentTileY<mapSize )
                        {
                          tileX[tileId]=surroundingCurrentTileX;
                          tileY[tileId]=surroundingCurrentTileY;

                          var surroundingCurrentGscore=gscore[currentIndex] + map[surroundingCurrentTileX][surroundingCurrentTileY].negativeWeight;
                          gscore[tileId]=surroundingCurrentGscore;
                          fscore[tileId]=surroundingCurrentGscore+Math.abs( surroundingCurrentTileX-startX)+Math.abs( surroundingCurrentTileY-startY);
                          tileParent[tileId]=currentIndex;
                          openList[openListSize++]=tileId++;
                        }
                    }
              }
              else
              {
              // remove from openlist
              openList[currentBestIndex]=openList[--openListSize];    
              }
            } while(true);

            if (tileX[tileParent[currentIndex]]<startX) return {moveDirection:WEST, pathLength:currentIndex, pathScore:gscore[currentIndex]+currentIndex/4};
            else if (tileX[tileParent[currentIndex]]>startX) return {moveDirection:EAST, pathLength:currentIndex, pathScore:gscore[currentIndex]+currentIndex/4};
            else if (tileY[tileParent[currentIndex]]<startY) return {moveDirection:NORTH, pathLength:currentIndex, pathScore:gscore[currentIndex]+currentIndex/4};
            else if (tileY[tileParent[currentIndex]]>startY) return {moveDirection:SOUTH, pathLength:currentIndex, pathScore:gscore[currentIndex]+currentIndex/4};
        }
        console.log("Path finding failed");
        return {moveDirection:IDLE, pathLength:0, pathScore:2147483647};
     }

function process(info,bots,coins)
    {
        var i;
        var j;
        var k;
        var x;
        var y;

        // initialise map
        var mapSize = info.arenaLength;
        var map = new Array(mapSize);
        for (i = 0;i < info.arenaLength;i++)
        {
            var newArray = new Array(info.arenaLength);
            map[i] =  newArray;
            for (j = 0;j < mapSize;j++)
            {
                map[i][j] = {type:MAP_TYPE_BLANK, coins: 0 , negativeWeight:i===0||i===mapSize-1||j===0||j===mapSize-1?3:1};
            }
        }

        // populate map with bots
        for (i = 0 ; i<bots.length;i++)
        {
            map[bots[i][X_INDEX]][bots[i][Y_INDEX]].type = MAP_TYPE_BOT;
            map[bots[i][X_INDEX]][bots[i][Y_INDEX]].coins = bots[i][COIN_INDEX];

            for (j=-1;j<2;j++)
            {
                x = bots[i][X_INDEX] + j;
                if (x>=0 && x < mapSize)
                {
                    for(k=-1;k<2;k++)
                    {
                        if (Math.abs((k+j)%2) === 1)
                        {
                            y = bots[i][Y_INDEX] + k;
                            if (y>=0 && y< mapSize )
                            {
                                // are we adjacent the bot or potentially will be?
                                if (Math.abs(info.locationX-x)<=1 && Math.abs(info.locationY-y)<=1)
                                {
                                    // make the cell significantly less attractive when the bot is stronger than us, or
                                    // make the cell slightly more attactive when the bot is weaker than us, or
                                    // not change if the bot has no coins
                                    map[x][y].negativeWeight+= bots[i][COIN_INDEX] >= info.coins?100000:(bots[i][COIN_INDEX]===0?0:-1);
                                }
                                // another bot is not a direct threat/target
                                else
                                {
                                    // make the cell moderately less attractive when the bot is stronger than us, or
                                    // make the cell slightly more attactive when the bot is weaker than us, or
                                    // not change if the bot has no coins
                                    map[x][y].negativeWeight+= bots[i][COIN_INDEX] >= info.coins?3:(bots[i][COIN_INDEX]===0?0:-1);
                                }
                            }
                        }
                    }
                }
            }
        }

        // populate map with coins
        for (i = 0 ; i<coins.length;i++)
        {
            map[coins[i][X_INDEX]][coins[i][Y_INDEX]].type = i === 0?MAP_TYPE_GOLD_COIN:MAP_TYPE_SILVER_COIN;
            map[coins[i][X_INDEX]][coins[i][Y_INDEX]].coins = i === 0?GOLD_POINTS:SILVER_POINTS;

            // check to see whether bots are adjacent to the coin
            for (j=-1;j<2;j++)
            {
                x = coins[i][X_INDEX] + j;
                if (x>=0 && x < mapSize)
                {
                    for(k=-1;k<2;k++)
                    {
                        if ((k+j)%2 === 1)
                        {
                            y = coins[i][Y_INDEX] + k;
                            if (y>=0 && y< mapSize )
                            {
                                if (map[x][y].type === MAP_TYPE_BOT)
                                {
                                    // this coin looks like a trap as a stronger bot is adjacent to it
                                    if (map[x][y].coins >= info.coins)
                                    {
                                        map[coins[i][X_INDEX]][coins[i][Y_INDEX]].negativeWeight+=100000;
                                    }
                                    else
                                    {
                                        // are we adjacent the coin? we might be able to kill another bot if it trys to get the coin
                                        if (Math.abs(info.locationX-coins[i][X_INDEX])<=1 && Math.abs(info.locationY-coins[i][Y_INDEX])<=1)
                                        {
                                            map[coins[i][X_INDEX]][coins[i][Y_INDEX]].negativeWeight+=-20;
                                        }
                                        // another bot is likely to get this coin... make it less attractive
                                        else
                                        {
                                            map[coins[i][X_INDEX]][coins[i][Y_INDEX]].negativeWeight=+100;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // add the coin attractiveness, more for gold coins
            map[coins[i][X_INDEX]][coins[i][Y_INDEX]].negativeWeight += i === 0?-20:-10;
        }


        var pathBest = {moveDirection:IDLE, pathLength: 2147483647, pathScore: 2147483647};

        if (info.coins > MIDGAME_THRESHOLD)
        {
            var viableCoinCount =0;
            var viableCoins = new Array(5); 


            // find coins that are reachable before any other bot
            outer1:
            for (j = 0 ; j<coins.length;j++)
            {
                var contention = 0;

                var myDistanceToCoin = Math.abs(info.locationX-coins[j][X_INDEX]) + Math.abs(info.locationY-coins[j][Y_INDEX]);

                for (i = 0 ; i<bots.length;i++)
                {
                    var dist = Math.abs(bots[i][X_INDEX]-coins[j][X_INDEX]) + Math.abs(bots[i][Y_INDEX]-coins[j][Y_INDEX]);
                    if (dist < myDistanceToCoin)
                    {
                        continue outer1;
                    }
                }
                viableCoins[viableCoinCount++] = j;
            }

            // no coins are reachable before another bot so find the cell that is furthest away from any bot and head there
            if (viableCoinCount ===0)
            {
                var mostIsolatedCellX = mapSize/2;
                var mostIsolatedCellY = mapSize/2;
                var mostIsolatedCellMinBotDistance = 0;

                for (x=5;x<mapSize-5;x++)
                {
                    for (y=5;y<mapSize-5;y++)
                    {
                        if (x!= info.locationX && y!=info.locationY)
                        {

                            // ignore coin attractiveness
                            map[x][y].negativeWeight = map[x][y].negativeWeight<-4?map[x][y].negativeWeight:1;


                            var currentCellMinBotDistance = 2147483647;

                            for (i = 0 ; i<bots.length;i++)
                            {
                                var dist = Math.abs(bots[i][X_INDEX]-x) + Math.abs(bots[i][Y_INDEX]-y) + Math.abs(info.locationX-x) + Math.abs(info.locationY-y);
                                if (dist < currentCellMinBotDistance )
                                {
                                    {
                                        currentCellMinBotDistance = dist;                           
                                        if (currentCellMinBotDistance>mostIsolatedCellMinBotDistance)
                                        {
                                            mostIsolatedCellMinBotDistance = currentCellMinBotDistance;
                                            mostIsolatedCellX=x;
                                            mostIsolatedCellY=y;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                // attempt to find path to most isolated cell
                pathBest = pathFind(info.locationX, info.locationY, mostIsolatedCellX,mostIsolatedCellY, map, mapSize);
            }

            // attempt to find paths to each viable coin, keeping the best result
            for (i = 0 ; i<viableCoinCount;i++)
            {
                var path = pathFind(info.locationX, info.locationY, coins[viableCoins[i]][X_INDEX],coins[viableCoins[i]][Y_INDEX], map, mapSize);
                if (path.pathScore < pathBest.pathScore)
                {
                    pathBest = path;
                }
            }
        }
        else
        {
            // attempt to find paths to each coin, keeping the best result
            for (i = 0 ; i<coins.length;i++)
            {
                var path = pathFind(info.locationX, info.locationY, coins[i][X_INDEX],coins[i][Y_INDEX], map, mapSize);
                if (path.pathScore < pathBest.pathScore)
                {
                    pathBest = path;
                }
            }
        }


        var move = IDLE;
        if (pathBest.pathLength === 2147483647)
        {
            outer:
            for (i=0;i<MOVE_COMMANDS_COUNT;i++)
            {
                switch (i)
                {
                    case NORTH:
                        if (info.locationY-1 < 0)
                        {
                            continue;
                        }
                        move = i;
                        break outer;
                    case SOUTH:
                        if (info.locationY+1 === info.arenaLength)
                        {
                            continue;
                        }
                        move = i;
                        break outer;
                    case WEST:
                        if (info.locationX-1 < 0)
                        {
                            continue;
                        }
                        move = i;
                        break outer;
                    case EAST:
                        if (info.locationX+1 === info.arenaLength)
                        {
                            continue;
                        }
                        move = i;
                        break outer;
                    case IDLE:
                        move = i;
                        break;
                    default:
                }
            }
        }
        else
        {
            move = pathBest.moveDirection;
        }

        switch (move)
        {
        case NORTH:
            return "north";
        case SOUTH:
            return "south";
        case EAST:
            return "east";
        case WEST:
            return "west";
        default:
            return "none";
        }
    }
    return process(me, others, coins);
}

यह बॉट पथ डिसेब्रोबिलिटीज के नक्शे के साथ युग्मित पथ का उपयोग करता है जिससे बॉट्स हमसे बच सकते हैं, उन सिक्कों के लिए जा सकते हैं जो करीब हैं, ट्रैप नहीं और कम से कम जोखिम भरा है।

यह जीतने की जगह के लिए एक दावेदार नहीं लगता है, लेकिन यह अपनी पकड़ रखता है और मैच के अंत में जीवित रहेगा यदि यह प्रारंभिक हाथापाई से बच जाता है।

बॉट के पास अब मिड-टू-लेट गेम स्ट्रैटेजी है जो सिक्कों को नजरअंदाज करती है, यह अन्य बॉट्स से पहले नहीं पहुंच सकता है और यदि किसी भी सिक्के पर नहीं जा सकता है तो निकटतम सेल में जाता है जो अन्य सभी बॉट्स से दूर है जो खुद से ज्यादा मजबूत हैं।

अब उसके पास जीतने का मौका है।

ध्यान दें भद्दा कोड के लिए खेद है, मैं अपने आप यह जावा से परिवर्तित कर दिया है

— Moogie
स्रोत

18 घंटे से लेकर नियत तारीख तक जल्द ही किसी भी कीड़े और / या अपडेट प्राप्त करना सुनिश्चित करें!

— रेडवुल्फ प्रोग्राम्स

@RedwolfPrograms क्या आपने बग देखा है? यदि ऐसा है तो कृपया मुझे बताएं ताकि मैं सही कर सकूं। धन्यवाद

— Moogie

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

— Redwolf Programs

गोल्ड कलेक्टर को

सिक्के के प्रकार

टक्कर मार दी

अखाड़ा

आपका बॉट

बैटबोट - जावास्क्रिप्ट नोड.जेएस

संभावित रूप से विजयी | जावास्क्रिप्ट

किसी तरह स्पष्टीकरण

फर्स्ट जेन लर्निंग एल्गोरिथम | जावास्क्रिप्ट (Node.js)

बिग किंग लिटिल हिल | जावास्क्रिप्ट

सुरक्षा सिक्का | जावास्क्रिप्ट

खेल खेलने वाले बॉट सावधानी से लेकिन आक्रामक हो सकते हैं | जावास्क्रिप्ट

द एंटीकैटलिस्ट | जावास्क्रिप्ट

GUT, जावास्क्रिप्ट

गोल्डीलॉक्स, जावास्क्रिप्ट (Node.js)

तीसरा जनरल लर्निंग एल्गोरिथम | जावास्क्रिप्ट (Node.js)

B33-L1N3 | जावास्क्रिप्ट (Node.js)

Livin 'एज, जावास्क्रिप्ट पर

डैमसी, जावास्क्रिप्ट (Node.js)

प्रोटॉन | जावास्क्रिप्ट

ऐसा नहीं है ब्लाइंडली | जावास्क्रिप्ट (Node.js)

कायर | अजगर २

जंगली हंस चेस बॉट, जावास्क्रिप्ट

कटामारीविथाल्यूस, जावास्क्रिप्ट (Node.js) ,

विनम्र निकट दृष्टि नशे में बॉट | जावास्क्रिप्ट

भारित मोशन | जावास्क्रिप्ट

अंधे | जावास्क्रिप्ट (Node.js)

सामंती महान | जावास्क्रिप्ट

क्वांटम ज्ञान बॉट | जावास्क्रिप्ट

सेवानिवृत्त आईसीई एजेंट, जावास्क्रिप्ट

लालची-पीछा | हास्केल

सिक्का चुंबक | जावास्क्रिप्ट

ICE Agent | जावास्क्रिप्ट

एक्स मार्क्स द स्पॉट | जावास्क्रिप्ट

Firebird

उ० — पथ-य | जावास्क्रिप्ट