互联网失败。DDoS攻击现在非常普遍。由您决定控制和修复互联网。

每个漫游器将控制此网络中的20个节点。每个节点都是活动的或安全的，具有所有者，并且具有从2开始的强度。每个活动节点都连接到所有其他活动节点。

每转一圈，您将收到所有活动节点及其强度的列表。对于您拥有的每个活动节点，您可以：

1. 指定一个活动节点，您要将其全部力量转移到该节点，或
2. 保存并增强其强度

然后会发生以下情况，以便：

1. 选择保存其强度的节点将使其强度增加1。
2. 所有选择转移其强度的节点都将同时将其全部强度转移至新节点。
3. 如果一个节点从敌方节点转移了力量，则会发生攻击。如果敌方拥有者集体转移的力量大于原始拥有者（和所有其他攻击者），则该敌人将成为新拥有者。然后，该节点的强度变为攻击者的强度。如果实力并列，那么将随机选择所有者。
4. 所有没有任何强度的节点都将被视为安全节点，并向所有者分配1分。

在100个回合中进行100场比赛后，所有游戏中拥有最安全节点的所有者将获胜。编辑：我将其从2000更改为100转，因为最后1900转没用

IO

您将通过以下方式（通过命令行args）传递活动节点列表：

F20 F4 E7 E2 E20 F2

F指定该节点为友好节点，并E指定该节点为敌人。

对于每个友好节点，您都应通过以下方式返回操作（通过STDOUT）：

0,0 1,3 5,0

上面的意思是您想增加第一个节点的强度，使用第二个节点攻击第四个节点，最后一个节点将把它的强度传递给第一个节点（如果没有人攻击它，它将成为一个安全节点）。

返回后，您的程序应退出。

计分板

累计3240分

优雅得了2370分

dumbot获得2262分

random_bot获得1603分

smarter_random_bot获得1319分

stable_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表示可能增加）时，我攻击该节点并将其从池中删除，重置总和，然后继续。最后，如果最强的节点找不到要攻击的人，它们将收集更多的力量。

编辑：累加器现在更智能了。与其一直攻击最弱的敌人节点，不如先累积力量直到可以攻击，然后再以该力量攻击最强的自由节点。同样，如果最后还剩下敌人，那么任何未分配的节点都会攻击最弱的剩余敌人，以防万一它决定转移力量。

优雅，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类，每个节点根据其类别进行操作。

• 每个强节点都会攻击一个随机的敌方节点，并击败它。
• 每个中间节点都支持其弱节点对。
• 每个弱节点都支持自己。

针对Accumulator和两个示例bot的结果：

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

Dumbot，Nodejs

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

• 假设敌人不会加强大型节点：在此假设下，最大的友好节点攻击可以击败的最强敌人。
• 假定将攻击最弱的目标：第二回合的友好节点每轮移至最弱的友好节点。
• 想要大量的自由强度：其他节点等待。