Інтернет не вдався. Нападів DDoS зараз широко розповсюджений та поширений. Ви повинні взяти під контроль та відремонтувати Інтернет.

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

Щоразу, ви отримаєте список всіх активних вузлів з їх силою. Для кожного з активних вузлів, якими ви володієте, ви:

1. Позначте активний вузол, на який потрібно передати всю силу, або
2. Збережіть і збільшуйте її силу

Тоді відбувається по порядку :

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

Після 100 ігор на 100 оборотів виграє власник з найбезпечнішими вузлами в усіх іграх. EDIT: Я змінив його з 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 балів

steady_bot отримав 1097 балів

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

Акумулятор, Python

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

EDIT: Акумулятор зараз трохи розумніший. Замість того, щоб завжди атакувати найслабший ворожий вузол, він накопичує силу, поки не міг би це зробити, а потім атакує найсильніший вільний вузол, який може з цією силою. Крім того, якщо в кінці ще залишилися вороги, будь-які непризначені вузли атакуватимуть самого слабкого ворога, що залишився, на всякий випадок, якщо він вирішить перенести сили.

Класний, 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(' '));
});

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