インターネットが失敗しました。現在、DDoS攻撃はramp延し、広まっています。インターネットを制御し、修復するのはあなた次第です。

各ボットは、このネットワーク内の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

上記は、最初のノードの強度を増やし、2番目のノードを使用して4番目のノードを攻撃し、最後のノードがその強度を最初のノードに転送することを意味します（誰も攻撃しない場合、それは安全なノードになります）。

戻った後、プログラムは終了するはずです。

スコアボード

アキュムレーターは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）、そのノードを攻撃してプールから削除し、合計をリセットして続行します。最後に、最強のノードが攻撃する人を見つけることができない場合、より強力なノードを収集します。

編集：アキュムレータは少しスマートになりました。常に最も弱い敵ノードを攻撃する代わりに、攻撃できるまで強さを蓄積し、その強さでできる限り強力な空きノードを攻撃します。また、最後に敵が残っている場合、未割り当てのノードは、残りの最も弱い敵を攻撃します。念のため、その力を移すことにします。

上品、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と2つのサンプルボットに対する結果：

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

ダンボット、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(' '));
});

• 敵が大きなノードを強化しないと仮定します：最大の友好的なノードは、この仮定の下でそれが打つことができる最も強い敵を攻撃します。
• 最も弱いターゲットが攻撃されると仮定します。2番目に大きい友好的なノードは、各ラウンドで最も弱い友好的なノードに移動します。
• 多くの自由な強度が必要：他のノードは待機します。