দ্রষ্টব্য: সম্প্রদায় প্রিয়দের জন্য জরিপটি শীঘ্রই প্রকাশ করা হবে

এই কোথিতে লক্ষ্য হ'ল বেঁচে থাকা শেষ বট হোক। কয়েনগুলি এলোমেলো জায়গায় স্থাপন করা হবে এবং আপনার বটটি অবশ্যই কয়েনগুলি প্রথমে পাওয়া উচিত। যদি একটি বট অন্য বোটে চলে যায় তবে আরও কয়েনযুক্ত বটটি জিততে থাকে এবং অন্য বটটি মারা যায়। নীচে আরও বিশদ।

মুদ্রার প্রকার

2 ধরণের মুদ্রা থাকবে: স্বর্ণ ও রৌপ্য। সোনার বটের শক্তিতে 5 টি কয়েন যুক্ত হয় এবং রৌপ্য 2 যোগ করে a যে কোনও সময়, আখরে একটি সোনার মুদ্রা এবং চারটি রৌপ্য মুদ্রা রয়েছে।

বট সংঘর্ষ

দুটি বট একই স্থান দখল করার চেষ্টা করার ইভেন্টে, আরও বেশি কয়েনযুক্ত একটি থাকবে এবং একটি কম ইচ্ছার সাথে থাকবে ... না। বিজয়ী বট প্রতিপক্ষের কয়েনের 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), আপনার বর্তমান অবস্থান, আপনার কয়েন, এবং Arena দৈর্ঘ্য
অন্যান্য বটের X এবং Y স্থানাঙ্কের সাথে একটি বহুমাত্রিক অ্যারে এবং তাদের মুদ্রার গণনা, প্রাক্তন-[[0,5,4],[4,7,1],[7,4,12]]
মুদ্রিত অবস্থানগুলির তালিকাভুক্ত একটি অ্যারে (স্বর্ণ সর্বদা প্রথম থাকে)

এটি হিল চ্যালেঞ্জের রাজা, স্ট্যান্ডার্ড লুফোলস নিষিদ্ধ। আপনার ফাংশনটি কয়েক হাজার বার সঞ্চালিত হবে, প্রতিটি সময় একজনকে "সরানোর" অনুমতি দেয়। মনে রাখবেন যে গেমটি 20,000 পদক্ষেপের বেশি হয়ে গেলে , সর্বাধিক কয়েনযুক্ত বট জয়ী হয়। এলোমেলোতা দূর করতে এটি 8,000 বার করা হবে।

চ্যাটরুম: https://chat.stackexchange.com/rooms/81347/gold-collectors-koth

পুরস্কার:

প্রথম স্থান: 100-পয়েন্ট অনুগ্রহী
সম্প্রদায় প্রিয়: 15-পয়েন্ট গৃহীত উত্তর

বিজয়ী:

প্রথম স্থান: টিবিটিপিটিজিসিবিসিবিএ
দ্বিতীয় স্থান: বড় কিং লিটল হিল
তৃতীয় স্থান: সম্ভাব্য বিজয়ী
চতুর্থ স্থান: ভদ্রতা নিকট-দর্শনীয় মাতাল বোত
পঞ্চম স্থান: সুরক্ষা মুদ্রা

king-of-the-hill

— রেডওয়ালফ প্রোগ্রামসমূহ
সূত্র

6

"নোট করুন যে সমস্ত সাবমিশনগুলি জাভাস্ক্রিপ্টে রূপান্তরিত হবে, জিনিসগুলি সহজ করার জন্য।" এটি কীভাবে কাজ করার কথা? আপনি কি রূপান্তর করেন?

— লাইকনি

21

কোনও কোথ শুধুমাত্র কোনও একক ভাষাকে বিশেষত জাভাস্ক্রিপ্ট হিসাবে বিস্তৃতভাবে ছড়িয়ে দেওয়া মঞ্জুরি দেওয়ার ক্ষেত্রে কোনও সমস্যা নেই। জাভাস্ক্রিপ্টের অস্পষ্টভাবে উত্তরগুলি "রূপান্তর" করার পরিবর্তে (সম্ভবত নিজের এবং হাতে) আপনার কেবলমাত্র জেএসের কাছে চ্যালেঞ্জ সীমাবদ্ধ করা উচিত। আমাদের অতীতে প্রচুর জাভা-কেবল এবং পাইথন-শুধুমাত্র কোথ ছিল।

— স্কিডদেব

2

এটির একটি সংস্করণ যেখানে আপনি অবস্থানের পরিবর্তে ত্বরণ নিয়ন্ত্রণ করেন এটি দুর্দান্ত cool

— আকোজি

12

সবার কাছে: ইতিমধ্যে অনেক মন্তব্য রয়েছে a "+1, দুর্দান্ত বট" এর মতো অকেজো মন্তব্যগুলি ফেলে রাখবেন না এবং দয়া করে আপনার মন্তব্যগুলি অপ্রয়োজনীয় হলে মুছে ফেলুন । আমরা একটি সাধারণ প্রশ্নোত্তর সাইট নই, তবে কেউ কেউ শত শত আদেশগুলি পড়তে পছন্দ করে না।

— ব্যবহারকারী 202729

5

(আমার নিজের প্রশ্নের কাছে): আড্ডায় এনপি অনুসারে, এটি পরবর্তী: সমস্ত বটগুলি সরানো হয়, তারপরে সমস্ত দ্বন্দ্ব মিটে যায়, তারপরে সমস্ত মুদ্রা পিকআপ হয়, তারপরে সমস্ত নতুন মুদ্রা স্থাপন করা হয়।

— ব্র্যাডিসি 9:58

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

হা, এটি একটি ঝরঝরে ধারণা, আমি এটি পছন্দ করি।

— সুন্দরের

এই

— পদ্ধতিরটি

1

বাইটবটের দরকার ন্যায়বিচারের nearestThreat && distanceTo(nearestThreat)চেয়ে distanceTo(nearestThreat)। হুমকি না থাকলে এটি ব্যর্থ হয়।

— রেডউল্ফ প্রোগ্রামগুলি

1

হ্যাঁ, nearestThreatহয় undefinedযদি সব অন্যান্য বট পুলিশের চেয়ে আরো পয়েন্ট আছে।

— রাত 2

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 টি স্পেস ইন্ডেন্টেশন আমার ট্যাবগুলি ব্যবহার করার পদ্ধতিতে ভাল যায় না))

রুক্ষ ব্যাখ্যা

সূত্রগুলির ব্যাখ্যা আপডেট করার প্রয়াসে আমি পদত্যাগ করছি। গুণাগুণগুলি ক্রমাগত পরিবর্তন করে চলেছে এবং ব্যাখ্যাটি আপ টু ডেট রাখা খুব কঠিন। সুতরাং আমি কেবল সাধারণ নীতিটি ব্যাখ্যা করব।

প্রতিটি মুদ্রা এবং প্রতিটি বট কিছু সম্ভাবনা সহ একটি বল ক্ষেত্র তৈরি করে। আমি কেবল সমস্ত কিছু থেকে একসাথে সম্ভাব্যতা যোগ করি এবং সম্ভাবনা সর্বনিম্ন যেখানেই বট যায় is (অবশ্যই এই ধারণা পদার্থবিজ্ঞান থেকে চুরি করা হয়েছে।)

আমি দুই ধরণের সম্ভাবনা ব্যবহার করি। প্রথমটি হ'ল সিউডো-মহাকর্ষীয় এক (যা কোনও পরিসীমাতে কাজ করে), ট একটি ক্ষেত্র এর "ক্ষমতা", এবং, চিহ্নের এই পছন্দ সঙ্গে, সম্ভাব্য আকর্ষণীয়। এখানে আর (এবং অন্য যে কোনও জায়গায়) ট্যাক্সিক্যাব মেট্রিকের দূরত্ব, r = | x₁ - x₂ | + | y₁ - y₂ | ।

U = - \frac{k}{r + \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 পরিসরে রেফারেন্সিয়ালি শক্তিশালী, তবে বড় দূরত্বে প্রায় কিছুই করার সিদ্ধান্ত নেয় না to (দূরত্ব + 1 এর অর্থ 1/20 এ বল কাটা।

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

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

আমরা সাধারণত অন্যান্য বটগুলিকে ইচ্ছাকৃতভাবে আক্রমণ করি না (অবশ্যই তারা যদি আমাদের পথে চলে যায় এবং আমরা তাদের উপর পা রাখি তবে এটি তাদের দোষ), তবে এটি করার সম্ভাবনা রয়েছে। যদি কিছু কঠোর শর্ত পূরণ হয়, তবে আমরা একক বটকে কেন্দ্র করে, শিকারের মোডে প্রবেশ করতে পারি । শিকারের মোডে প্রবেশ করতে:

আমাদের অবশ্যই কমপক্ষে 25 টি কয়েন থাকা উচিত। (আমাদের প্রথমে কিছু মুদ্রা নেওয়া দরকার))
তাদের অবশ্যই সর্বাধিক (আমাদের কয়েন - 5) মুদ্রা এবং কমপক্ষে 10 টি মুদ্রা থাকতে হবে। (আমরা এমন কোনও ব্যক্তির শিকার হতে চাই না যে একটি মুদ্রা ধরে ফেলে এবং হঠাৎ আরও শক্তিশালী এবং আমরা শূন্য-কয়েনের বটগুলিও অনুসরণ করতে চাই না))
আমাদের অবশ্যই বর্তমানে শীর্ষস্থানীয় বট থেকে তার কয়েনের কমপক্ষে 1/10 দ্বারা পিছিয়ে থাকতে হবে। (কোনও কিছুর খোঁজ করার জন্য আপনার ভাগ্যবান হওয়া দরকার, তাই কেবল আমাদের ভাগ্য চেষ্টা করার জন্য একটি ভাল অবস্থান দেওয়ার দরকার নেই))
আমাদের অবশ্যই শিকারের কলোডাউন এ থাকা উচিত নয় (নীচে দেখুন)।

এই সমস্ত সন্তুষ্ট হলে, শিকার মোড সক্রিয় করা হয়। পরবর্তী 10 রাউন্ডের জন্য, শিকার করা বট কেবলমাত্র সম্ভাব্য নির্গত করে এই 10 টি রাউন্ড অতিক্রান্ত হওয়ার পরে, আমরা শিকারের সমুদ্রসীমায় প্রবেশ করি, যার মধ্যে আমরা আবার শিকারের মোডে প্রবেশ করতে পারি না। (এটি আমাদের অবিরাম এবং নিরর্থকভাবে একটি বট তাড়ানোর সময় প্রতিরোধ করতে পারে যখন অন্য সমস্ত আনন্দের সাথে মুদ্রা দখল করে)) আমাদের কাছে 25 টি কয়েন রয়েছে যখন শিকারের সমুদ্রসীমা 20 রাউন্ড এবং এটির দ্বিগুণ হয়ে প্রতি 20 কয়েন বেড়ে যায়। (অন্য কথায়, কোলডাউনটি হয় )) (আমরা এটি ব্যবহার করি কারণ এন্ডগেমে, সমস্ত শিকারযোগ্য বটগুলি সম্ভবত মৃত, এবং তাই কোনও শিকার খুব সম্ভবত নিরর্থক হয়। এর কারণে, আমরা নষ্ট সময়কে সীমাবদ্ধ করতে চাই । তবে কখনও কখনও, দেরি-খেলায় দেরি করে খাওয়া সবকিছু বদলে দিতে পারে, তাই আমরা সম্ভাবনাটি রেখেছি)

U = - 150 e^{- r} .

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

অবশেষে, পুরো আখড়াটি একটি অসীম সম্ভাব্য কূপে স্থাপন করা হয়েছে যা বটকে পালাতে বাধা দেয়।

— Ramillies
সূত্র

আমি মনে করি এই বটটি সম্ভবত আমার ওজনে চলাফেরাকেও মারবে।

— fəˈnɛtɪk

@ fəˈnɛtɪk - তাই আমি :—)। আমি মনে করি যে এটি অন্য বটগুলি বেশ খানিকটা ভাল পরিচালনা করতে পারে। (এছাড়াও এটি সংলগ্ন স্কোয়ারে একটি মুদ্রা দ্বারা "অন্ধ" হয় নি)) তবে আমি অবশ্যই আপনাকে +1 দিয়েছি কারণ আমি এই ধারণার একটি বিশাল অনুরাগী।

— রমিলিজ

আপনি কি এটিতে ন্যূনতম পদক্ষেপের নীতিটি প্রয়োগ করতে পারেন?

— বিটা ক্ষয়

@ বেটাডেকে: পুরোপুরি আমি ভীত নই, ক্যালকুলাস এই জাতীয় জটিল সমস্যার পক্ষে ভাল প্রতিক্রিয়া জানায় না। এমনকি অবিচ্ছিন্ন ক্ষেত্রেও এটি তুচ্ছ হবে না (কারণ বেগের নির্দিষ্ট মাত্রার কারণে) তবে এটি অনুমান করা যায় যে কিছু পোলার স্থানাঙ্কের যাদু পরে এটি সম্ভব।

— রমিলিজ

4

এটি দুর্দান্ত। আমি নিশ্চিত নই যে ঝুঁকি দূরত্বের সাথে একঘেয়েভাবে জড়িত, যদিও এটি হুমকির মতো বলে মনে হচ্ছে 2 স্পেসের দূরে একটি সংলগ্নের চেয়ে আপনাকে মেরে ফেলার সম্ভাবনা বেশি, যেহেতু পরের ক্ষেত্রে আপনার একজনকে সংঘর্ষের জন্য স্থির থাকতে হবে।

— কেইন

16

প্রথম জেনারেল লার্নিং অ্যালগরিদম | জাভাস্ক্রিপ্ট (নোড.জেএস)

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

এটি অনলাইন চেষ্টা করুন!

আপনি কি কখনও খেলতে শেখার অ্যালগরিদম শেখার সেই টাইমল্যাপগুলি দেখেছেন? তারা প্রায়শই প্রথম কয়েক প্রজন্মের প্রায় এলোমেলোভাবে সরানো ...

— Skidsdev
সূত্র

LOL ... এটি এখনও কাজ করতে পারে!

— রেডউল্ফ প্রোগ্রামগুলি 8-10 ই

2

বেশিরভাগ শিখার অ্যালগরিদমগুলি প্রায় কয়েকটি এলোমেলোভাবে আক্ষরিকভাবে এলোমেলোভাবে কাজ করে, প্রায় এলোমেলোভাবে নয়।

— fəˈnɛtɪk

কি অনুমান? এই বটটি গড়ে প্রতি রাউন্ডে প্রায় 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

পিপিসিজিতে আপনাকে স্বাগতম! এটি খুব ভাল বট = ডি

— লুইস ফেলিপ দে জেসুস মুনোজ

এই আমি বট জন্য চিন্তা ছিল। সাবাশ.

— জো।

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";}
  }
}

এই বটটি সরাসরি একটি ভারী মূল্যবান মুদ্রা (মান / দূরত্ব) এর দিকে যায় যা এটি একই সাথে বা অন্য বোটের পরে পৌঁছতে পারে না। যদি এই সম্পত্তিটির সাথে কোনও বৈধ মুদ্রা ~~না থাকে তবে এটি যেখানে~~ বটটি এখন ~~এটি~~ এলোমেলো নিরাপদ দিকে চলে যায় (নিরাপত্তার অর্থ বটটি যদি তার দিকে এগিয়ে যায় তবে সুরক্ষা মুদ্রাটি সংঘর্ষে পড়তে পারে না This অবিলম্বে এটির পাশেই), আখড়ার কেন্দ্রের দিকে ভারিত।

— fənɛtɪk
সূত্র

1

হু, এটি আসলে জিততে পারে। যদিও, প্রচুর বট রয়েছে

— রেডউল্ফ প্রোগ্রামগুলি

এই পদ্ধতিতে আরও সমস্যা হবে যত বেশি অসমভাবে উচ্চ বা সমমানের মানযুক্ত শত্রু বট স্থাপন করা হবে।

— fəˈnɛtɪk

1

ঠিক আছে, তারা সম্ভবত তাদের নিকটবর্তী মুদ্রা / সোনার মুদ্রার জন্য একটি বাইনলাইন তৈরি করবে।

— রেডউল্ফ প্রোগ্রামগুলি

এটি কেবল তখনই ভাল করতে পারে যদি এটি শুরুতে কিছু মুদ্রা পাওয়ার ব্যবস্থা করে।

— fəˈnɛtɪk

এবং এটি বেশিরভাগ ক্ষেত্রে ভাগ্য, যেহেতু মুদ্রাগুলি উত্পন্ন স্থানটি এলোমেলোভাবে সিদ্ধান্ত নেওয়া হয়েছে

— রেডউল্ফ প্রোগ্রামগুলি

10

যে বটটি গেমটি সাবধানে খেলছে কিন্তু আক্রমণাত্মক হতে পারে | জাভাস্ক্রিপ্ট

পছন্দসই রঙ: #F24100

দ্রষ্টব্য: যদিও এই বটটি প্রথম স্থান অধিকার করেছে, এটি শেষে "সামন্ত নোবেল" এর সাথে দল বেঁধে দেওয়া হয়েছে এবং আরও মুদ্রার জন্য তাকে খাওয়ার কারণে এটি ঘটেছে। অন্যথায় এই বটটি 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;
}

এই বট (ওরফে "TBTPTGCBCBA") প্রতিটি সম্ভাব্য পদক্ষেপের জন্য একটি স্কোর তৈরি করে সর্বোত্তম সিদ্ধান্ত নেওয়ার চেষ্টা করে এবং প্রতিটি টার্নের জন্য উচ্চতর স্কোর সহ স্থানটি নির্বাচন করে।

স্কোরিং সিস্টেমে অনেকগুলি বিশদ রয়েছে যা চ্যালেঞ্জ শুরুর পর থেকেই বিবর্তিত হয়েছে। এগুলি সাধারণত এভাবে বর্ণিত হতে পারে:

মুদ্রাগুলি একটি সম্ভাব্য পদক্ষেপের কাছাকাছি, চালটি তত বেশি স্কোর পায়। যদি কোনও মুদ্রার অন্য কোনও সম্ভাব্য প্রতিযোগী না থাকে তবে স্কোর আরও বেশি হয়। যদি কোনও মুদ্রার অন্যান্য সম্ভাব্য প্রতিযোগী থাকে তবে স্কোর কম যায়।
যদি অন্য বট কোনও সম্ভাব্য পদক্ষেপের কাছাকাছি থাকে এবং গেমের ধাপের উপর নির্ভর করে কম মুদ্রা থাকে, তবে এটি সেই পদক্ষেপের জন্য আরও বেশি স্কোর বলতে পারে। সুতরাং "টিবিটিপিটিজিসিবিসিবিএ" প্রতিটি গেমের অন্যান্য কয়েকটি বট খাওয়া আরামদায়ক।
যদি অন্য বট সমান বা ততোধিক পয়েন্টের সাথে একটি সম্ভাব্য পদক্ষেপের খুব কাছাকাছি থাকে, তবে এই পদক্ষেপটি মৃত্যু এড়ানোর বিষয়টি নিশ্চিত করার জন্য যথেষ্ট নেতিবাচক স্কোর পায় অবশ্যই কিছু ক্ষেত্রে থাকতে পারে যে সমস্ত সম্ভাব্য পদক্ষেপ খারাপ এবং মৃত্যু এড়ানো যায় না, তবে এটি খুব বিরল।
বোর্ডের মাঝে শেষ 20 টি টার্নের জন্য বটের সংখ্যা ট্র্যাক করার ব্যবস্থা আছে। যদি গড় পর্যাপ্ত পরিমাণ কম হয় তবে মাঝের কয়েনের দিকে সমস্ত চাল আরও বেশি স্কোর পেতে পারে এবং যদি গড় উচ্চ হয় তবে মাঝের কয়েনের দিকে সমস্ত পদক্ষেপ কম স্কোর পায়। এই প্রক্রিয়া "সামন্ত নোবেল" এর সাথে দ্বন্দ্ব এড়াতে দেয়। যেহেতু "সামন্ত নোবেল" সর্বদা মাঝখানে থাকে (যদি তা ধাওয়া না করা হয়) তবে মাঝের বটগুলির গড় সংখ্যা উপরে যায় এবং "টিবিটিপিটিজিসিবিসিবিএ" মাঝারি অঞ্চলের বাইরে আরও ভাল বিকল্প থাকে তবে মাঝখানে এড়াতে বোঝে। যদি "সামন্ত নোবেল" মারা যায়, গড় নিচে নেমে যায় এবং "টিবিটিপিটিজিসিবিসিএ" বুঝতে পারে যে এটি মধ্যটি ব্যবহার করতে পারে।
গেমের পর্যায়ের (জীবিত বটের সংখ্যা থেকে সনাক্ত হওয়া) উপর ভিত্তি করে কিছু কারণ রয়েছে যা গতিশীলভাবে পরিবর্তিত হয়, এই উপাদানগুলি উপরের প্রতিটি আইটেমের স্কোরকে প্রভাবিত করে।
এই বট একটি বিশেষ ক্ষমতা আছে। সময়ের সাথে সাথে এটি "সামন্ত noble" এর স্বার্থপরতা এবং কৃষকদের অত্যাচারে ক্লান্ত হয়ে ওঠে। সঠিক মুহূর্তে, এটি অপ্রীতিকর সামন্ততন্ত্র ব্যবস্থার অবসান ঘটাতে উঠবে। একটি সফল প্রচেষ্টা কেবল দরিদ্র কৃষকদেরই সহায়তা করে না, "সামন্ত নোবেল" থেকে নেওয়া মুদ্রার কারণে এটি একটি উচ্চ জয়ের সুযোগও সরবরাহ করে।

— 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";
    }
}

সঙ্গে সম্ভাব্য বিজয়ী বট ক্ষেত্র ও মুদ্রা ক্ষেত্র: আমরা দুটি ক্ষেত্র পেয়েছেন। তবে, প্রকৃতি এতটা জটিল নয়। গ্র্যান্ড ইউনিফাইড থিওরি উত্পাদন করতে দুটি ক্ষেত্রকে একত্রিত করার সময় এসেছে ।

প্রথমত, আমাদের মাঠের সম্ভাবনা কী তা নিয়ে কাজ করা দরকার। আমাদের নিজস্ব বটটি কোনওভাবেই ক্ষেত্রকে প্রভাবিত করে না বলে ধরে নিই, আমরা এটিকে এইভাবে লিখতে পারি:

V = \sum_{n} k_{n} (e^{k_{n}^{2} - 100 (x - x_{n})^{2}} + e^{k_{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)$

অবজেক্টের আপেক্ষিক সম্পত্তিটিকে এভাবে গণনা করা হয়:

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

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

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

_{আসুন পরিবর্তিত বেতানীয় ডায়নামিক্স (এমওবিডি) এর এই সংশোধন অংশটি বলি ।}

আমরা গতিশক্তি হিসাবে যেমন খুঁজে পেতে পারি:

T = \frac{1}{2} c_{me} ({\dot{x}}^{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)$

আমাদের এখন এলিউর-ল্যাঞ্জরেজ সমীকরণগুলি সমাধান করতে হবে:

\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 L}{\partial x} = \sum_{n} 200 k_{n} (x - x_{n}) e^{k_{n}^{2} - 100 (x - x_{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{x} = \sum_{n} \frac{200 k_{n}}{c_{me}} (x - x_{n}) e^{k_{n}^{2} - 100 (x - x_{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{d}{d t} \frac{\partial L}{\partial \dot{y}} = \frac{d}{d t} [c_{me} \dot{y}] = c_{me} \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 L}{\partial y} = \sum_{n} 200 k_{n} (y - y_{n}) e^{k_{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} = \sum_{n} \frac{200 k_{n}}{c_{me}} (y - y_{n}) e^{k_{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}$

এখন আমাদের আর কিছু করার দরকার নেই: আমরা কেবল সামগ্রিক ত্বরণের দিকটি দেখি:

output = {\begin{cases} north & if \ddot{y} < 0 and | \ddot{y} | > | \ddot{x} | \\ south & if \ddot{y} > 0 and | \ddot{y} | > | \ddot{x} | \\ west & if \ddot{x} < 0 and | \ddot{x} | > | \ddot{y} | \\ east & if \ddot{x} > 0 and | \ddot{x} | > | \ddot{y} | \\ none & if | \ddot{y} | = | \ddot{x} | \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

আপনার নোবেল পুরস্কারটি মেইলে হারিয়ে গেছে, তবে আমরা এর পরিবর্তে আপনাকে একটি এ্যামি অ্যাওয়ার্ড দিতে পারলাম

— রেডউল্ফ প্রোগ্রামগুলি

1

দেখে মনে হচ্ছে পদার্থবিজ্ঞান এই চ্যালেঞ্জটিতে জনপ্রিয় হতে শুরু করে। :-D। এবং অবশ্যই আমি এটি সম্পর্কে কতটা কৌতূহল বোধ করছি।

— র‌্যামিলিজ

1

(যাইহোক, আপনি অউলার-ল্যাঞ্জরেজ সমীকরণগুলির সাথে ঝামেলা বাঁচাতে পারতেন, কারণ এগুলি F = c_me a = - গ্রেড ইউ :—) এর সুপরিচিত সত্যকে হ্রাস করে))

— র‌্যামিলিস

@ রমিলিস মেহ, এটি এভাবে করা আরও মজা পেয়েছিল: ডি

— বেটা ডেকে

1

আপনি কি নিশ্চিত যে আপনি অন্য কিছু / আপনার কয়েনের কে = কয়েন ব্যবহার করতে চান? আপনি কোনও মুদ্রা দিয়ে শুরু করেন না ... এবং সর্বত্র NaN দিয়ে, আপনার কোনও পাওয়ার সম্ভাবনা খুব বেশি নেই।

— র‌্যামিলিজ

8

গোল্ডিলোকস, জাভাস্ক্রিপ্ট (নোড.জেএস)

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
}

এটি অনলাইন চেষ্টা করুন!

সোনার মুদ্রার অবস্থানটি তালাবদ্ধ করে প্রতিবার এটির দিকে এগিয়ে যায়। (এটি ব্যবহৃত মূল কোডটির জন্য @ মায়ুবের 'বি 33-এল 1 এন 3' বটকে ধন্যবাদ, যদিও এর মধ্যে খুব কমই রয়ে গেছে))

— সুন্দর
সূত্র

এটি একটি দুর্দান্ত সুন্দর, সহজ বট। আমি এটা পছন্দ করি.

— রেডউল্ফ প্রোগ্রামগুলি

2

যাইহোক, আমি আমার কন্ট্রোলারের পরীক্ষার জন্য এই বোটটি ব্যবহার করছি (:

— রেডউলফ প্রোগ্রামগুলি

8

তৃতীয় জেনার্ন লার্নিং অ্যালগরিদম | জাভাস্ক্রিপ্ট (নোড.জেএস)

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

@ লুইসেলিপডিজেস মুনোজ তিনি আখড়া ছেড়ে গেছেন।

— জো।

এটি

— নিয়ামককে

3

ওহ, যাইহোক, আখড়াটি 0 থেকে শুরু হয়, সুতরাং এটি হওয়া উচিত arenaLength - 1। এটি আপনার বটটি বেশ কয়েকজনের কাছে বেশ কয়েকবার ন্যায্যভাবে হত্যা করেছে

— রেডউল্ফ প্রোগ্রামগুলি 9:58 18:58

7

বি 33-এল 1 এন 3 | জাভাস্ক্রিপ্ট (নোড.জেএস)

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
সূত্র

ওহ, আমি ভেবেছিলাম বি 33-এল 1 এন 3 মডেল সংখ্যার কিছু ছিল

— রেডওয়াল্ফ প্রোগ্রামগুলি

নামের জন্য +1

— কেইন

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

— রাত 2

let

— 18-28

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

আমি সীমান্ত নিয়ন্ত্রণের রসিকতা করব, তবে আমি সেটিকে

— @

5

ক্ষয়ক্ষতি, জাভাস্ক্রিপ্ট (নোড.জেএস)

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
}

এটি অনলাইন চেষ্টা করুন!

আজকের জন্য একটি শেষ কাঠামারি-ভিত্তিক বট, এবার একটু স্মৃতি নিয়ে। নাম প্রস্তাবের জন্য @ বেটাডেকে ধন্যবাদ - অবশ্যই আমার চেয়ে আরও মজাদার নাম simplePredictorKatamari।

শেষ মোড়ের মধ্যে বটগুলি কীভাবে স্থানান্তরিত হয়েছিল তা সনাক্ত করার চেষ্টা করে এবং তার ভিত্তিতে ভবিষ্যদ্বাণী করে যে তারা এই বাঁকটির শেষে কোথায় যাওয়ার চেষ্টা করবে (ধরে নিলে তারা একই দিকে এগিয়ে চলেছে)।

(@ Fəˈnɛtɪk কে ধন্যবাদ, বট নোটগুলিতে আমি ভুল ফাংশনটির নামটি কল করছি এবং বেস কোডে একটি বাগ লক্ষ্য করার জন্য @ ওএমᗺ-কে ধন্যবাদ জানাই।)

— সুন্দর
সূত্র

এই মুহূর্তে সম্ভবত এটিই একমাত্র ভাগ্যবান হওয়ার বাইরে অন্যকে ধরতে পারে।

— কেইন

বোটোটোটস কি "স্টোরডাটা" সেটটাটা না বলে মনে হচ্ছে?

— fəˈnɛtɪk

@ fəˈnɛtɪk দেখুন, ইতিমধ্যে একটি বাগফিক্স প্রয়োজন! :) ধন্যবাদ, এখন সংশোধন।

— সূর্যর

আপনার aWt = 1সাথে প্যারামগুলি প্রতিস্থাপন করা উচিত aWtএবং aWt = aWt || 1নীচে রাখা উচিত (একই সাথে bWt)। এটি ত্রুটিগুলি প্রতিরোধ করে।

— রেডউল্ফ প্রোগ্রামগুলি

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;
}

সমস্ত কয়েন (অন্যান্য বটগুলি ধারণ করে) প্রোটনবোটের দিকে একটি বিদ্বেষমূলক শক্তি নির্গত করে। এই শক্তির ভিত্তিতে, এটি বেগ তৈরি করে এবং দেয়ালগুলি বন্ধ করে দেয় (একটি সীমানা আঘাত করার সাথে সাথেই ঘুরিয়ে দেয়)। যদি এটি কোনও বট বা মুদ্রার পাশে শেষ হয় তবে এটি শক্তিশালী পারমাণবিক শক্তি গ্রহণ করে এবং এটি সেটিকে গ্রাস করতে চলে আসে, যখন এটি ঘটে তখন সমস্ত গতি ফেলে দেয় drop

— fənɛtɪk
সূত্র

হুম, পারমাণবিক পদার্থবিজ্ঞান কোষাগার শিকারে প্রয়োগ হয়েছে? এই যে কোনও দিন সায়েন্স চ্যানেলকে মারধর করে!

— রেডউল্ফ প্রোগ্রামগুলি 9:48

আপনি প্রতিস্থাপন করা প্রয়োজন sinসঙ্গে Math.sin, cosসঙ্গে Math.cos, ইত্যাদি

— Redwolf প্রোগ্রাম

4

এত অন্ধ | জাভাস্ক্রিপ্ট (নোড.জেএস)

গুরুত্বপূর্ণ দ্রষ্টব্য: এই পদ্ধতির সম্পূর্ণ আমার নয় এবং একই প্রশ্নের উত্তর দেওয়া হয়েছে । সেই উত্তরটিও ভোট দিতে ভুলবেন না।

হ্যাভ আপনি কি কখনও * প্যাথফাইন্ডিং অ্যালগরিদমের কথা শুনেছেন? এটা এখানে. এটি এক পয়েন্ট থেকে কম মূল্যবান মুদ্রার সর্বোত্তম পথ তৈরি করে (যেহেতু প্রত্যেকে সবচেয়ে মূল্যবান হিসাবে চলেছে, কেউই কম দামে যাচ্ছে না) এবং অন্য কোনও ব্যবহারকারীর সাথে সংঘর্ষ না করার চেষ্টা করে।

নিম্নলিখিত হিসাবে পরামিতি প্রত্যাশা:

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

বাহ ... ইতিমধ্যে একটি প্যাথফাইন্ডিং অ্যালগরিদম? এটি মাত্র 3 ঘন্টা হয়েছে!

— রেডউল্ফ প্রোগ্রামগুলি 8:58

@ রেডওলফ প্রোগ্রামগুলি যেমনটি আমি বলেছি, এটি অন্য অনুরূপ চ্যালেঞ্জ থেকে অনুলিপি করা হয়েছে। এটি কেবল এটির সাথে খাপ খাইয়ে নেওয়া দরকার।

— লুইস ফিলিপ দে জেসুস মুনোজ

আমার অ্যালগরিদমগুলি যে কোনও মুদ্রায় যেতে নিরাপদ for

— fəˈnɛtɪk

4

কাপুরুষ | পাইথন 2

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)];
}

অনলাইনে চেষ্টা করে দেখুন!

রেডওয়ल्फ প্রোগ্রামগুলিতে নোট:

এই বটটি খুব দীর্ঘ রাউন্ড তৈরির সম্ভাবনা রাখে। অচলাবস্থা রোধ করতে আমি কিছু স্বাধীনতা নিয়েছি, তবে সেগুলি যদি কার্যকর হয় তবে তা পরীক্ষা করে দেখিনি। যদি এই বোট পরীক্ষার সময় সমস্যা হয়ে থাকে তবে দয়া করে এটি অযোগ্যতা বোধ করবেন।

— জাচারি সুতি
সূত্র

নোটের জন্য ধন্যবাদ। কোনও বিশেষজ্ঞ ইভাডারের যথাযথ সুযোগ রয়েছে যদি তা তাড়া করার সময় পর্যাপ্ত কয়েন সংগ্রহ করার ঘটনা ঘটে

— রেডউল্ফ প্রোগ্রামস

আমি এই পছন্দ। এটি প্রায় শিকার রোবটদের টোপের মতো

— বিটা ডেকে

4

কাটামারি উইথভ্যালিজ, জাভাস্ক্রিপ্ট (নোড.জেএস) ,

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
}

এটি অনলাইন চেষ্টা করুন!

(এর ভিত্তিতে মূল কোডটিতে একটি বাগ চিহ্নিত করার জন্য @ ওএমকে ধন্যবাদ জানাই))

নিজের চেয়ে কম মুদ্রা সহ "খাওয়া" বটগুলি বাড়ানোর চেষ্টা করে। যদি এটি সম্ভব না হয় (এরূপ কোনও বট নেই), তবে নিকটস্থ মুদ্রাটি সন্ধান করুন।

এই সংস্করণটিতে ছোট ছোট চিহ্ন রয়েছে (ক) রৌপ্য মুদ্রার চেয়ে সোনার মুদ্রাগুলিকে বেশি অগ্রাধিকার দেবে - এই ঝুঁকির সাথে যে আরও বেশি দূরবর্তী সোনার মুদ্রা সন্ধান করা বটের জীবন ব্যয় করতে পারে বা বোকা স্বর্ণের পরে তাড়া করতে পরিচালিত করতে পারে (খ) বটগুলি এড়িয়ে চলবে 0 কয়েন - এর পরে ধাওয়া করতে সময় নষ্ট করার দরকার নেই।

— সুন্দর
সূত্র

একটি স্মার্ট শিকারী ... ভাল, এটি আরও ভাল!

— রেডউল্ফ প্রোগ্রামগুলি

রেডউल्फপ্রগ্রামসমূহ আসুন আশা করি! :)

— সূর্যর

এই ক্ষয়ক্ষতি বলা উচিত ছিল;)

— বিটা

1

@ বেটাডেকে উইশ মঞ্জুর করেছেন

— সুন্দরের

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
}

কাছাকাছি মুদ্রা বাছাই চারপাশে বিস্মিত, কিন্তু এলোমেলোভাবে প্রায়শই প্রায়শই দিক পরিবর্তন করে। কারও সাথে ধাক্কা এড়ানোর জন্য সে যা করতে পারে তা করে, তবে ক্রোধে ... সে যুদ্ধক্ষেত্র হয় ... প্রতিযোগিতা চলতে চলতে স্বাচ্ছন্দ্য বোধ করে।

কিছু ডিবাগিংয়ের প্রয়োজন হতে পারে, যখন কন্ট্রোলার সম্পূর্ণরূপে হয়ে যায় আমি এতে কাজ করব।

— দ্বারা NP
সূত্র

3

হুম, এটি বার উত্থাপন করে, তারপরে মাতাল হয়ে যায়

— রেডউল্ফ প্রোগ্রামগুলি

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

হ্যাঁ, এটি দেখতে দুর্দান্ত ভয়ঙ্কর বটের মতো। দিকনির্দেশগুলি পরীক্ষা করে দেখুন, যেহেতু এটি যদি আপনার বট কয়েন থেকে দূরে পালিয়ে যেতে পারা যায় তবে এটি আসল ক্ষতি হবে (:

— রেডউল্ফ প্রোগ্রামস

ভাল, এখনও। আমি সুন্দর হতে হবে, তাই না?

— রেডউল্ফ প্রোগ্রামগুলি 8:38

আচ্ছা, পোস্ট করুন! এটি ছোট, দ্রুত বটগুলির জন্য তৈরি করবে যা এই মুহুর্তে প্রচুর পরিমাণেও বিদ্যমান।

— রেডউল্ফ প্রোগ্রামগুলি

for(i=0;i<6;i++){এখানে মোট 5 টি কয়েন, 1 টি স্বর্ণ এবং 4 টি রৌপ্য রয়েছে। আপনার লুপটি 0 থেকে 5 পর্যন্ত 6 বার চলছে

— রাত 2

3

অন্ধ | জাভাস্ক্রিপ্ট (নোড.জেএস)

এটি অবশ্যই জিতবে না তবে কমপক্ষে অংশগ্রহণ করবে। প্রথমে কোএইচ চ্যালেঞ্জের চেষ্টা করুন। এটি কয়েনগুলি বাছাই করে নিকটতমটিতে যায়। তিনি খেলোয়াড়দের সন্ধান করেন না তাই অন্যের সাথে সংঘর্ষে নিলে সে যত্ন করে না।

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
}

এই বিরক্তিকর বটটি সোয়াটেটেড না হয়ে শক্তিশালী বটটির চারপাশে গুঞ্জন দেওয়ার চেষ্টা করে এবং যারা এটি শিকার করার চেষ্টা করে তাদের মাধ্যমে পর্যায়ক্রমে হওয়ার সামান্য সুযোগ রয়েছে। এটি দুটি সবচেয়ে শক্তিশালী বটকে কাছাকাছি আঁকানোর প্রবণতা রয়েছে ...;)

— দ্বারা NP
সূত্র

যদি তিনি কোনও উপযুক্ত লক্ষ্য খুঁজে না পান 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";
            }
        }
    }
}

অবসরপ্রাপ্ত, এই আইসিই এজেন্ট মানবতা সম্পর্কে তিক্ত। ফলস্বরূপ, অবসরপ্রাপ্ত আইসিই এখন মুদ্রার মানকে গড়ের (আইসিই নীতি অনুসারে) রাখার পরে দুর্বলতম বটকে লক্ষ্য করে targe

— বেটা ক্ষয়
সূত্র

2

লোভী-সাধনা | Haskell,

পছন্দসই রঙ: #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"

এটি অনলাইন চেষ্টা করুন! ^*

খুব সহজ কৌশল, এর থেকে প্রথম সিদ্ধান্তটি বেছে নেয়:

যদি কম মুদ্রা সহ বট থাকে: নিকটতম চয়ন করুন এবং এর দিকে এগিয়ে যান
যদি কয়েন থাকে: নিকটতম চয়ন করুন এবং এর দিকে এগিয়ে যান
ডিফল্ট: থাকা

বট কেবল সম্ভাব্য শক্তিশালী বটগুলির যত্ন না করেই অন্যান্য বট বা কয়েন ধরার চেষ্টা করে যা এটি ধরার চেষ্টা করতে পারে।

_{* আমি সত্যিই জাভাস্ক্রিপ্ট জানি না তবে আমি গুগলের সাথে জিনিসটি করেছি (ভুল হতে পারে): এটি অনলাইনে চেষ্টা করুন!}

— ბიმო
সূত্র

6

আমি অবাক হয়েছি কীভাবে তিনি হেসেলকে জেএস-এ অনুবাদ করতে যাচ্ছেন

— লুইস ফিলিপ দে জেসুস মুনোজ

3

@ লুইসেলিপডিজেসুস মুনোজ: হ্যাঁ আমাকেও। তবে ভাগ্যক্রমে, এটি খুব পরিশীলিত কোড নয়।

— 19

@ লুইসফেলিপডিজেসাস মুনোজ কেবল কিছু নোড.জেএস এবং process.open(বা child_process.spawn, বা অনুরূপ) কিছু পার্সিং ব্যবহার করুন।

— ব্যবহারকারী 202729

@ লুইসফেলিপজেজেসুস মুনোজ: আমি এটি অনুবাদ করার চেষ্টা করেছি এবং একটি লিঙ্ক যুক্ত করেছি, তবে জাভাস্ক্রিপ্ট লেখার বিষয়ে আমি খুব আত্মবিশ্বাসী বোধ করি না, তাই এটি বগি হতে পারে।

— 4

4

@ লুইসফেলিপজেজেসুস মুনোজ এটি 10,000,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

আইসিই এজেন্ট | জাভাস্ক্রিপ্ট

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";
            }
        }
    }
}

টহল না দিলে সীমান্তের কী অবস্থা? আইসিই সীমান্তের চারপাশে অ্যান্টলোকের দিকে অগ্রসর হয় এবং যে কোনও বটকে তার পথে প্রবেশ করে, তা তুলে দেয়।

এটি করার আগে, এটি আগে অন্যান্য বট খেতে সক্ষম হওয়া প্রয়োজন। যে কারণে আইসিই, এর মুদ্রাগুলি সমস্ত বটগুলির গড়ের উপরে রাখে।

_{বাচ্চাদের তাদের বাবা-মায়ের কাছ থেকে চুরি করার গ্যারান্টিযুক্ত ™}

— বেটা ক্ষয়
সূত্র

এটি এতটা প্রাসঙ্গিক না হলে এটি আরও মজার হবে

— ডন হাজার হাজার

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, দুর্ভাগ্যক্রমে) JS (...)

— ব্যবহারকারী অনুবাদক 202729

1

এটি দেওয়া The arena starts at (0,0) in the upper left corner, আপনি কি নিশ্চিত যে আপনি সেখানে যাওয়ার southজন্য সরানো চান y=0?

— অ্যাডমবর্কবার্ক

@ অ্যাডমবার্কবার্ক ধন্যবাদ, এটি খারাপ হতে পারে

— বিটা

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]);
    }

সম্পূর্ণরূপে পুনর্নির্মাণ করা আগের চেয়ে মারাত্মক হতে পারে (:

— রেডওয়ালফ প্রোগ্রামসমূহ
সূত্র

2

আমার এক

— বোটের

এটি তাদের লক্ষ্যবস্তু নয়,

— এগুলি

ওহ দুঃখিত, আমি ভুল বুঝেছি

— বেটা ডেক

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);
}

এই বটটি আমাদেরকে মেরে ফেলতে, ফাঁদগুলিতে নয়, কমপক্ষে ঝুঁকিপূর্ণ এমন মুদ্রার সন্ধান করতে পারে এমন বটগুলি এড়ানোর জন্য ঘরের আকাঙ্ক্ষাগুলির মানচিত্রের সাথে মিলিত পথ অনুসন্ধান করে।

এটি বিজয়ী স্থানের প্রতিদ্বন্দ্বী বলে মনে হয় না, তবে এটি নিজস্ব ধারণ করে এবং প্রাথমিক লড়াইয়ে বেঁচে থাকলে ম্যাচ শেষে বেঁচে থাকবে।

বটের এখন মাঝ থেকে দেরিতে গেম কৌশল রয়েছে যা কয়েনগুলিকে উপেক্ষা করে এটি অন্যান্য বটগুলির আগে পৌঁছতে পারে না এবং যদি কোনও মুদ্রায় যেতে না পারে তবে নিজের থেকে আরও শক্তিশালী সমস্ত অন্যান্য বট থেকে দূরে থাকা নিকটতম কক্ষে চলে যায়।

এটি এখন জয়ের একটি সুযোগ আছে।

ক্রপী কোডটির জন্য দুঃখিত, আমি জাভা থেকে এটি স্বয়ংক্রিয়ভাবে রূপান্তর করেছি Note

— Moogie
সূত্র

শিগগিরই যে কোনও বাগ এবং / বা আপডেটগুলি অবশ্যই নির্ধারিত তারিখের 18 ঘণ্টার আগে পেয়ে যাবেন!

— রেডউল্ফ প্রোগ্রামগুলি

@ রেডওলফ প্রোগ্রামগুলি আপনি কি কোনও বাগ পর্যবেক্ষণ করেছেন? যদি তাই হয় দয়া করে আমাকে জানান যাতে আমি সংশোধন করতে পারি। ধন্যবাদ

— মোগি

না, তবে আপনি কখনই জানেন না। কেবল দু'বার পরীক্ষা করে দেখুন, যেহেতু আমি একটি ভুল নম্বর, বা ভুল ফাংশন, বা আমার চেয়ে বেশিবার ভুল

— টাইপ

সোনার সংগ্রাহক

মুদ্রার প্রকার

বট সংঘর্ষ

রঙ্গভূমি

আপনার বট

বাইটবট - জাভাস্ক্রিপ্ট নোড.জেএস

সম্ভাব্য বিজয়ী | জাভাস্ক্রিপ্ট

রুক্ষ ব্যাখ্যা

প্রথম জেনারেল লার্নিং অ্যালগরিদম | জাভাস্ক্রিপ্ট (নোড.জেএস)

বড় কিং লিটল হিল | জাভাস্ক্রিপ্ট

সুরক্ষা মুদ্রা | জাভাস্ক্রিপ্ট

যে বটটি গেমটি সাবধানে খেলছে কিন্তু আক্রমণাত্মক হতে পারে | জাভাস্ক্রিপ্ট

এন্টি ক্যাপিটালিস্ট | জাভাস্ক্রিপ্ট

GUT, জাভাস্ক্রিপ্ট

গোল্ডিলোকস, জাভাস্ক্রিপ্ট (নোড.জেএস)

তৃতীয় জেনার্ন লার্নিং অ্যালগরিদম | জাভাস্ক্রিপ্ট (নোড.জেএস)

বি 33-এল 1 এন 3 | জাভাস্ক্রিপ্ট (নোড.জেএস)

জাভাস্ক্রিপ্ট প্রান্ত এ Livin '

ক্ষয়ক্ষতি, জাভাস্ক্রিপ্ট (নোড.জেএস)

প্রোটন | জাভাস্ক্রিপ্ট

এত অন্ধ | জাভাস্ক্রিপ্ট (নোড.জেএস)

কাপুরুষ | পাইথন 2

ওয়াইল্ড গুজ চেজ বট, জাভাস্ক্রিপ্ট

কাটামারি উইথভ্যালিজ, জাভাস্ক্রিপ্ট (নোড.জেএস) ,

ভদ্র নিকট-দর্শনীয় মাতাল বট | জাভাস্ক্রিপ্ট

ভারী গতি | জাভাস্ক্রিপ্ট

অন্ধ | জাভাস্ক্রিপ্ট (নোড.জেএস)

সামন্ত নোবেল | জাভাস্ক্রিপ্ট

কোয়ান্টাম জ্ঞাত বট | জাভাস্ক্রিপ্ট

অবসরপ্রাপ্ত আইসিই এজেন্ট, জাভাস্ক্রিপ্ট

লোভী-সাধনা | Haskell,

মুদ্রা চৌম্বক | জাভাস্ক্রিপ্ট

আইসিই এজেন্ট | জাভাস্ক্রিপ্ট

এক্স দাগ চিহ্নিত | জাভাস্ক্রিপ্ট

Firebird

এ-পাথ-ওয়াই | জাভাস্ক্রিপ্ট