Примітка. Незабаром буде опубліковано опитування для улюбленого спільноти

У цьому KoTH мета - бути останнім живим ботом. Монети будуть розміщені у випадкових місцях, і ваш бот повинен отримати монети першими. Якщо бот натрапив на іншого бота, бот з більшою кількістю монет виграє, а інший бот гине. Детальніше нижче.

Типи монет

Буде 2 види монет: золота та срібна. Золото додає 5 монет міцності бота, а срібло - 2. Коли монета зібрана, інша монета розміщується на іншому місці на дошці. У будь-який момент часу на арені є одна золота і чотири срібних монети.

Зіткнення ботів

У випадку, коли два боти намагаються зайняти один і той же простір, той, у якого більше монет, залишиться, а той, у якого менше, буде… ні. Бот, який виграє, набере 85% монет опонентів (Закруглені). Якщо вони пов'язані, обидва гинуть. Якщо три або більше намагаються зайняти один і той же простір, виграє найпотужніший і отримує 85% усіх монет інших ботів. У випадку, якщо найпотужніший бот - краватка, всі боти гинуть, хто намагався увійти в космос.

Арена

Довжина сторони арени обчислюється за допомогою 4 + botCount. При розміщенні ботів на початку гри вибираються випадкові місця. Система гарантує, що жоден бот не запускається в одному просторі або поруч один з одним. Монети генеруються випадковим чином, виключаючи квадрат 3 по 3 на кожному боті. Якщо бота знайшли поза ареною, він вмирає миттєво. Арена починається з (0,0), або Північно-Західного, у лівому верхньому куті, і розташування бота завжди є цілим числом.

Ваш бот

Ваш бот повинен бути функцією на будь-якій об'єктно-орієнтованій мові, що має масиви, цілі числа, рядки та функції. Зауважте, що всі подання будуть перетворені на Javascript, щоб зробити речі простішими. Щоб зберігати інформацію між рухами, використовуйте botNotes.storeData(key, value)та botNotes.getData(key, value). Ви не можете зберігати або отримувати доступ до даних будь-яким іншим способом, крім того, який надається через параметри та botNotes. Ви повинні створити функцію , яка при виклику, повертає рядок north, east, south, west, або none. Існує 3 аргументи для функції:

• Об'єкт з чотирма цілими числами ( locationX, locationY, coins, arenaLength), ваше місце свого перебування, ваші монети, а довжина арени

• Багатовимірний масив з координатами X і Y інших ботів та їх кількістю монет, наприклад,[[0,5,4],[4,7,1],[7,4,12]]

• Масив із переліченими місцями монет (золото завжди перше)

Це виклик короля пагорба, заборонені стандартні лазівки . Ваша функція буде виконуватися кілька тисяч разів, кожен раз дозволяючи один "Move". Зауважте, що якщо гра перевищує 20 000 ходів , виграє бот з найбільшою кількістю монет. Це буде зроблено 8000 разів, щоб усунути випадковість.

Чат: https://chat.stackexchange.com/rooms/81347/gold-collectors-koth

Призи:

Перше місце:
улюбленість спільноти у 100 балів : відповідь у 15 балів

Переможці:

Перше місце: TBTPTGCBCBA
Друге місце: Big King Little Hill
Третє місце: потенційно переможене
четверте місце: ввічливий недалекоглядний п'яний бот
П'яте місце: монета безпеки

BaitBot - JavaScript Node.JS

Навіщо турбуватися переслідувати чи бігати, якщо ніколи не можеш зловити? Натомість BaitBot знаходить найближчу монету і чекає, коли слабший бот також підійде до неї. Коли вони обидва суміжні, baitBot йде за монету, припускаючи, що і слабший бот. Якщо baitBot чекає і підходить сильніший бот, він просто хапає монету і скачує. Спробуй мене!

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

}

Потенційно переможний | JavaScript

Кращим кольором для цього бота є #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];
}

.

Грубе пояснення

Я відмовляюся у спробі оновити пояснення формул. Коефіцієнти постійно змінюються, і так важко постійно уточнювати пояснення. Тож я просто поясню загальний принцип.

Кожна монета та кожен бот генерують силове поле з певним потенціалом. Я просто додаю потенціали з усього разом, і бот потім йде туди, де потенціал найнижчий. (Очевидно, ця ідея вкрадена у фізики.)

Я використовую два види потенціалів. Перший - це псевдогравітаційний (який діє в будь-якому діапазоні), з Доє «сила» поля, і при такому виборі знака, потенціал є привабливим. Гтут (і скрізь) це відстань в метриці таксомотора,г = | x₁ - x₂ | + | y₁ - y₂ | .

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

Я використовую k = 40 для золотих монет і k = 10 для срібних монет. n - кількість ботів, які ближче до певної монети, ніж ми. В іншому випадку ми абсолютно ігноруємо інших ботів (якщо ми заважаємо сильнішому боту, ми тікаємо, але це все). Я ціную золотих монет більше, ніж вони коштують, бо в іншому випадку боти, які йдуть насамперед після золота, весь час били мене.

Другий потенціал - це експоненціально занепад (який ефективно діє лише на дуже малих відстанях). Це породжується іншими, переважно більш потужними, ботами.

Вони дають поле з Ця сила непомірно сильна на дальності 0-1, але на більших відстанях майже не знижується. (Відстань + 1 означає різання сили на 1/20.)

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

Ми, як правило, не нападаємо на інших ботів навмисно (звичайно, якщо вони заважають нам, і ми наступаємо на них, це їхня вина), але є можливість зробити це. Якщо деякі жорсткі умови будуть виконані, ми можемо перейти в режим полювання , зосереджуючись на одному боті. Щоб увійти в режим полювання:

1. У нас повинно бути не менше 25 монет. (Нам потрібно спочатку дістати кілька монет.)
2. Вони повинні мати максимум (у нас - 5 монет ) і не менше 10 монет. (Ми не хочемо полювати на когось, хто хапає одну монету і раптом стає більш потужним, і ми також не хочемо переслідувати ботів з нульовими монетами.)
3. Ми повинні відставати від поточного провідного бота принаймні на 1/10 його монет. (Щоб полювати на щось, вам пощастить, тому немає потреби дарувати гарну позицію лише для того, щоб спробувати нашу удачу.)
4. Ми не повинні знаходитись на охороні (див. Нижче).

Якщо все це задоволено, активується режим полювання. Протягом наступних 10 раундів загнаний бот випромінює лише потенціал

$$U = -150 e^{-r}.$$ Після закінчення цих 10 патронів ми переходимо до охолодження, під час якого ми можемо знову не перейти в режим полювання. (Це означає, щоб не допустити, щоб ми нескінченно і безрезультатно переслідували одного бота, а всі інші радісно захоплювали монети.) Захоплення охоти складає 20 патронів, коли у нас є 25 монет, і збільшується на 20 монет за кожне подвоєння цього. (Іншими словами, припинення дії - це20(1 + log2(c / 25)).) (Ми використовуємо це тому, що в кінцевій грі всі мисливські боти, швидше за все, мертві, і тому будь-яке полювання буде, ймовірно, марним. Через це ми хочемо обмежити витрачений час. Але іноді щасливий пізній- Ігрове харчування може змінити все, тому ми зберігаємо можливість.)

Нарешті, всю арену розміщують у нескінченному потенційному колодязі, що запобігає втечі бота.

Алгоритм навчання першого роду | JavaScript (Node.js)

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

Спробуйте в Інтернеті!

Ви коли-небудь бачили ті часові проміжки навчання алгоритмів навчання грати в гру? Вони часто рухаються майже безладно в перші кілька поколінь ...

Великий король Маленький пагорб | JavaScript

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

Спробуйте в Інтернеті!

Big King Little Hill приймає рішення на основі "зон контролю". Він буде переслідувати лише монети, які знаходяться в зоні контролю, тобто він зможе дістатися до монети раніше, ніж зможе будь-який інший бот. Коли в його зоні управління немає монет, вона замість цього рухається, щоб максимально збільшити розмір зони контролю. Великий Кінг Літл Хілл обчислює зону контролю кожного з 5 можливих рухів і надає перевагу рухам, які максимально збільшують розмір зони контролю. Таким чином Big King Little Hill зрештою досягає локального максимуму (маленького пагорба) контролю і чекає, коли в його зоні буде створена монета. Крім того, Big King Little Hill відкидає будь-який крок, який може призвести до його смерті, якщо не буде альтернативи.

Big King Little Hill - песиміст (він вважає за краще термін реаліст), оскільки не турбується оскаржувати будь-яку монету, яку не запевняють. Це також пацифіст, оскільки він не переслідує більш слабких ботів у будь-якому сенсі (хоча він може наступити на одного, якщо їм заважатимуть). Нарешті, Big King Little Hill - боягуз, який не загрожує власному життю за будь-яку винагороду, якщо цього абсолютно не доведеться.

Монета безпеки | JavaScript

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

Цей бот прямує прямо до зваженої монети (значення / відстань), від якої не може померти, досягнувши одночасно або після іншого бота. Якщо немає справжньої монети з цим властивістю, вона сидить там, де це бот, тепер рухається у випадковому безпечному напрямку (безпека означає, що якщо бот рухається до неї, захисна монета не може зіткнутися. Це дозволяє боту міняти місця іншим ботом, якщо безпосередньо поруч із ним), зваженим у напрямку до центру арени.

Бот, який грає в гру обережно, але може бути агресивним | JavaScript

Бажаний колір: #F24100

Примітка: Хоча цей бот зайняв 1-е місце, це пов’язано з об'єднанням з "Феодальним дворянством" наприкінці та з'їданням його за більше монет. Інакше цей бот був би 3-м. Якщо вас цікавлять боти, які є більш потужними в індивідуальному порядку, огляньте потенційно переможні та Big King Little Hill .

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") намагається прийняти найкраще можливе рішення, генеруючи бал за кожен можливий хід, і вибирає хід з вищим балом за кожен хід.

Система підрахунків балів має багато деталей, які розвиваються з початку виклику. Їх можна загалом описати так:

• Чим ближче монети до можливого руху, тим більше балів отримує рух. Якщо на монеті немає інших можливих учасників, оцінка буде ще вище. Якщо на монеті є інші можливі учасники, оцінка знижується.
• Якщо інший бот близький до можливого ходу і має менше монет, залежно від фази гри, це може означати більше балів за цей хід. Тому "TBTPTGCBCBA" випадково з'їдає декілька інших ботів у кожній грі.
• Якщо інший бот близький до можливого ходу з рівними або кількома очками, цей хід отримує достатньо негативної оцінки, щоб уникнути смерті. Звичайно, можуть бути випадки, що всі можливі рухи погані і смерті не уникнути, але це дуже рідко.
• Існує механізм відстеження кількості ботів посеред плати протягом останніх 20 оборотів. Якщо середній показник досить низький, всі рухи в бік монет у середині отримують більше балів, а якщо середнє значення високе, то всі рухи в бік монет у середині отримують нижчий бал. Цей механізм дозволяє уникнути конфліктів із «феодальною знаттю». Оскільки "феодальний дворянин" завжди знаходиться посередині (якщо його не переслідують), середня кількість ботів посередині зростає, а "TBTPTGCBCBA" розуміє уникати середини, якщо є кращий варіант поза середньої площі. Якщо "феодальний дворянин" помирає, середнє знижується, а "TBTPTGCBCBA" розуміє, що може використовувати середину.
• Є деякі фактори, які динамічно змінюються залежно від фази гри (виявляється з числа живих ботів), ці фактори впливають на бал у кожному з вищезазначених пунктів.
• Цей бот має особливі здібності. З часом він втомлюється від егоїзму «феодальної знаті» та утиску селян. У потрібний момент воно підніметься, щоб покласти край неприємній системі феодалізму. Успішна спроба не тільки допомагає бідним селянам, але й забезпечує більший шанс на виграш завдяки монетам, узятим у «феодальної знаті».

Антикапіталіст | Javascript

Не має стимулу йти за монетами, але намагається розмістити себе рівно між двома найбагатшими ботами з однаковою сумою грошей, сподіваючись, вони полюють на нього і врешті-решт схоплять його одночасно, взявши з собою двох капіталістів, коли він помре . Не активно чинить опір отримання монет, тому він може стати більш соковитою мішенню.

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

GUT, JavaScript

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_\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_{\text{object}}}{c_{\text{me}}}$$

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

_{Назвемо цю корекційну частину модифікованою бетаніанової динамікою (MOBD) .}

Кінетичну енергію ми також можемо знайти як:

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

Тепер ми можемо розрахувати дію:

$$\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}$$

Отже, лагранжанин нашого бота в полі «монета-бот»:

$$\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}{dt} \frac{\partial \mathcal{L}}{\partial \dot{x}} = \frac{\partial \mathcal{L}}{\partial x}$$

і:

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

Тому:

$$\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 \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\limits_n \frac{200k_n}{c_{\text{me}}} \left(x - x_n\right) e^{k_n^2 - 100(x-x_n)^2}$$

І також:

$$\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 \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\limits_n \frac{200k_n}{c_{\text{me}}} \left(y - y_n\right) e^{k_n^2 - 100(y-y_n)^2}$$

Тепер нам не потрібно йти далі: ми просто дивимось на напрямок загального прискорення:

$$\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}$$

І просто так, ми об’єднали монети та боти. Де моя Нобелівська премія?

Золотанки, JavaScript (Node.js)

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

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

  return mymove
}

Спробуйте в Інтернеті!

Просто замикається на місці золотої монети і щоразу рухається до неї. (Завдяки боту "B33-L1N3" @ Mayube для оригінального коду, який він використовував, хоча ледве будь-який з них залишається.)

Алгоритм навчання третього роду | JavaScript (Node.js)

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

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

Спробуйте в Інтернеті!

Після кількох поколінь навчання, цей бот дізнався, що залишати арену = погано

B33-L1N3 | JavaScript (Node.js)

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

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

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

Спробуйте в Інтернеті!

Робить білайн для найближчої монети

Livin 'on the Edge, JavaScript

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

Цей, хто чув край арени, є небезпечним місцем. Не знаючи страху, він невтомно обводить дошку за годинниковою стрілкою, лише в сантиметрах від певної смерті, яка чекає за кордоном, сподіваючись, що жоден інший бот не наважиться просунутися так близько до краю краю.

Пошкодження, JavaScript (Node.js)

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

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

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

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

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

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

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

  if (!done)
    dir = 'none'


  return dir
}

Спробуйте в Інтернеті!

Один останній бот на основі катамарі на сьогодні, цього разу з небагато пам’яті. Завдяки @BetaDecay за пропозицію імені - безумовно, кумедніше ім’я, ніж моє simplePredictorKatamari.

Намагається розібратися, як боти рухалися в останню чергу, і, виходячи з цього, прогнозує, куди вони спробують рухатись наприкінці цього повороту (якщо припустити, що вони продовжуватимуть рухатися в тому ж напрямку).

(Завдяки @ fəˈnɛtɪk, за те, що я помітив, що я називав неправильне ім’я функції у botNotes та @ OMᗺ за те, що помітив помилку в базовому коді.)

Протон | JavaScript

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

Всі монети (включаючи ті, що їх тримають інші боти) випромінюють силу до Protonbot. Виходячи з цієї сили, вона нарощує швидкість і відскакує від стін (одразу обертається, потрапляючи на межу). Якщо він опиняється поруч з ботом або монетою, яку він може споживати, Сильна ядерна сила бере на себе і вона рухається до споживання, скидаючи всю швидкість, коли це робить.

Не так сліпо | JavaScript (Node.js)

Важлива примітка: Цей підхід не є повністю моїм, і на нього було дано відповідь у подібному питанні . Не забудьте проголосувати і за цю відповідь.

Ви коли-небудь чули про алгоритм A * просування маршрутів? ось. Він створює найкращий шлях від однієї точки до менш цінної монети (оскільки всі йдуть за найціннішою, ніхто не збирається за меншу) і намагається не зіткнутися з будь-яким іншим користувачем.

Очікує наступних параметрів:

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

Трус | Пітон 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)

Уникайте ботів з більшою кількістю грошей, якщо це можливо. В іншому випадку візьміть гроші, які лежать навколо.

Бот для погони за дикими гусками, Javascript

Бот, який дуже добре ухиляється від інших ботів, але дуже погано отримує монети.

---

Алгоритм:

1. Якщо сусідніх ботів немає, не повертайте жодних
2. Інакше:
   1. Не повертайте жодного з випадковим шансом 1/500 шансу (це призначено для запобігання застоям).
   2. Визначте, до яких просторів можна переміщатись (тобто всередині арени, а не займає інший бот)
   3. Поверніть один навмання

---

Код:

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

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

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

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

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

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

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

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

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

Спробуйте в Інтернеті!

Примітка до програм Redwolf:

Цей бот може викликати дуже довгі раунди. Я взяв деякі свободи, щоб запобігти застоям, але не перевіряв, чи справді вони ефективні. Якщо під час тестування цей бот стає проблемою, будь ласка, нехай його дискваліфікують.

KatamariWithValues, JavaScript (Node.js) ,

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

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

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

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

  if (!done)
    dir = 'none'

  return dir
}

Спробуйте в Інтернеті!

(Дякуємо @ OMᗺ за те, що вказав на помилку в оригінальному коді, на якому ґрунтувався.)

Намагається рости, "поїдаючи" ботів з меншою кількістю монет, ніж сама. Якщо це неможливо (такого бота немає), то шукає найближчу монету.

Ця версія має невеликі зміни, щоб (а) надавати більше переваг золотим монетам, ніж срібним монетам - з ризиком того, що пошук більш віддалених золотих монет може призвести до вартості життя бота або призведе до переслідування за золотом дурня (б) пропустити ботів з 0 монет - не потрібно витрачати час на переслідування за ними.