Интернет не удалось. DDoS-атаки сейчас широко распространены. Это зависит от вас, чтобы взять под контроль и восстановить Интернет.

Каждый бот будет контролировать 20 узлов в этой сети. Каждый узел активен или безопасен , имеет владельца и имеет силу, которая начинается с 2. Каждый активный узел связан со всеми другими активными узлами.

Каждый ход вы будете получать список всех активных узлов с указанием их силы. Для каждого активного узла, которым вы владеете, вы либо:

1. Назначить активный узел , который вы хотите перенести цельный силу, или
2. Сохранить и увеличить свою силу

Затем происходит следующее в порядке :

1. Узел, решивший сохранить свою силу, увеличит свою силу на 1.
2. Все узлы, решившие перенести свою силу, будут одновременно передавать всю свою силу новому узлу.
3. Если узлу была передана сила от вражеского узла, атака начнется. Если владелец противника коллективно передает больше силы, чем первоначальный владелец (и все остальные атакующие), тогда этот враг становится новым владельцем. Сила этого узла становится силой атакующего. Если есть сила для связи, то владелец будет выбран случайным образом.
4. Все узлы, оставшиеся без всякой силы, будут считаться безопасными и дают 1 очко владельцу.

После 100 игр по 100 ходов побеждает владелец с самыми безопасными узлами во всех играх. РЕДАКТИРОВАТЬ: я изменил его с 2000 до 100 витков, так как в итоге последние 1900 витков были бесполезны

IO

Вам будет передан список активных узлов (через аргументы командной строки), как показано ниже:

F20 F4 E7 E2 E20 F2

Fобозначает, что узел является дружественным узлом, и Eобозначает, что узел является врагом.

Для каждого из ваших дружественных узлов вы должны вернуть действие (через STDOUT), как показано ниже:

0,0 1,3 5,0

Выше будет означать, что вы хотите увеличить свою силу первого узла, использовать свой второй узел для атаки на четвертый узел, и ваш последний узел передаст свою силу первому узлу (и если никто не атакует его, он станет безопасным узлом ).

После возвращения ваша программа должна выйти.

Табло

Аккумулятор набрал 3240 баллов

классный получил 2370 баллов

Дамбот получил 2262 балла

random_bot получил 1603 балла

smarter_random_bot получил 1319 баллов

устойчивый бот получил 1097 баллов

Контроллер можно найти здесь: https://github.com/nathanmerrill/NetAttack

Аккумулятор, Питон

Давайте начнем эту вечеринку! Моя заявка должна работать как на Python 2 и Python 3.

import sys

inputs = [(i, x[0], int(x[1:])) for (i, x) in enumerate(sys.argv[1].split())]

own_nodes = sorted([(s,i) for (i,o,s) in inputs if o == 'F'])
targets = sorted([(s,i) for (i,o,s) in inputs if o == 'E'])

if targets:
    t_copy = targets[:]
    out = ""
    total_str = 0
    attackers = []
    for (s,i) in own_nodes:
        attackers += [i]
        if t_copy:
            total_str += s
            if t_copy[0][0] < total_str - 1:
                j = max([j for j in range(len(t_copy)) if t_copy[j][0] < total_str - 1])
                out += " ".join([str(k) + "," + str(t_copy[j][1]) for k in attackers]) + " "
                attackers = []
                total_str = 0
                t_copy = t_copy[:j] + t_copy[j+1:]
    if attackers:
        if t_copy:
            out += " ".join([str(k) + "," + str(t_copy[0][1]) for k in attackers])
        else:
            out += " ".join([str(k) + "," + str(attackers[0]) for k in attackers])
else:
    out = " ".join([str(i) + "," + str(own_nodes[0][1]) for (s,i) in own_nodes])

print(out.rstrip())
sys.stdout.flush()

Идея действительно проста. Я начинаю перечислять свои узлы в порядке возрастания силы, сохраняя текущую сумму сил. Когда сумма превышает силу самого слабого вражеского узла (+1 для возможного увеличения), я атакую ​​этот узел и удаляю его из пула, сбрасываю сумму и продолжаю. В конце концов, если самые сильные узлы не могут найти кого-то для атаки, они наберут больше силы.

РЕДАКТИРОВАТЬ: аккумулятор теперь немного умнее. Вместо того, чтобы всегда атаковать самый слабый вражеский узел, он накапливает силу до тех пор, пока он не может это сделать, а затем атакует самый сильный свободный узел, который он может с этой силой. Кроме того, если в конце все еще остаются враги, любые неназначенные узлы будут атаковать самого слабого из оставшихся врагов, на тот случай, если он решит перебросить свою силу.

Классный, Python3

import random, sys
f,e,p=[],[],[]
for si,s in enumerate(sys.argv[1].split()):
    if s[0]=='F': f+=[(int(s[1:]),si)]
    else: e+=[(int(s[1:]),si)]
f=sorted(f,key=lambda t:t[0]);r=4
f1,f2,f3=f[:len(f)//r],f[len(f)//r:len(f)//r*2],f[len(f)//r*2:]
for fa in f3:
    ea=[t for t in e if t[0]<fa[0]]
    p+=[(fa[1],random.choice(ea)[1])] if ea else [(fa[1],fa[1])]
for fd,fs in zip(f1,reversed(f2)):
    p+=[(fs[1],fd[1])]
    p+=[(fd[1],fd[1])]
if len(e)==0: p=[(fe[1],0) for fe in f]
for t in p: print(t[0],',',t[1],' ',sep='',end='')
sys.stdout.flush()

Бот делит свои собственные узлы на 3 категории в зависимости от силы, и каждый узел действует в соответствии со своей категорией.

• Каждый сильный узел атакует случайный вражеский узел, который он может победить.
• Каждый средний узел поддерживает свою слабую пару узлов.
• Каждый слабый узел поддерживает себя.

Результат против Аккумулятора и двух ботов:

smarter_random_bot got 1301 points
random_bot got 1841 points
Accumulator got 2178 points
Classy got 2580 points

Думбот, Нодейс

var input = process.argv.splice(2);
var regexp = new RegExp(" ", "gm");
input = String(input).split(regexp);
var nodes = [];
var targets = [];
for(var i = 0; i < input.length; i++){
    if(input[i].charAt(0) == "F")
        nodes.push(i);
    else
        targets.push(i);
}
var result = "";
var length = nodes.length;
for(var i = 0; i < length; i++){
    if(targets.length>0)
        result += nodes.shift() + "," + targets.shift() + " ";
    else
        result += nodes.shift() + ",0 ";
}
console.log(result);

Бот будет атаковать без какого-либо мышления или стратегии. Основная цель - обеспечить множество безопасных узлов в самом начале. Имейте в виду, что этот бот делает бесконечный цикл с аккумулятором.

SteadyBot, Node.js

(new Promise(function(resolve, reject) {
    var input = process.argv[2];
    if(input) {
        resolve(input);
    } else {
        process.stdin.once('data', function(data){
            resolve(data.toString());
        });
    }
})).then(function(input) {
    return input.trim().split(' ');
}).then(function(nodes) {
    var friends = [], enemies = [];
    nodes.forEach(function(value, index) {
        var data = { index: index, strength: parseInt(value.substring(1)) };
        if(value[0] === 'F') {
            friends.push(data);
        } else {
            enemies.push(data);
        }
    });

    function weaknessCompare(a, b) {
        return (a.strength > b.strength) ? -1 : ((a.strength < b.strength) ? 1 : 0);
    }

    friends.sort(weaknessCompare);
    enemies.sort(weaknessCompare);

    if(enemies.length === 0) {
        friends.forEach(function(friend) {
            friend.target = 0;
        });
    } else {
        if(friends.length > 0) {
            var strongest = friends[0];
            for(var i = 0; i < enemies.length; i++) {
                var enemy = enemies[i];
                if(enemy.strength + 1 < strongest.strength) {
                    strongest.target = enemy.index;
                    break;
                }
            };
        }
        if(friends.length > 1) {
            friends[1].target = friends[friends.length - 1].index;
        }
    }

    console.log(friends.map(function(friend) {
        return friend.index + ',' +
                (typeof friend.target === 'number' ? friend.target : friend.index);
    }).join(' '));
});

• Предполагается, что враги не будут укреплять большие узлы: самый большой дружественный узел атакует сильнейшего врага, которого он может победить при таком предположении.
• Предполагается, что самая слабая цель будет атакована: второй по величине дружественный узел перемещается в самый слабый дружественный узел каждый раунд.
• Хочет много свободной силы: другие узлы ждут.