인터넷이 실패했습니다. DDoS 공격은 이제 만연하고 널리 퍼져 있습니다. 인터넷을 통제하고 수리하는 것은 당신에게 달려 있습니다.

각 봇은이 네트워크에서 20 개의 노드를 제어합니다. 모든 노드는 active 또는 safe 이고 소유자가 있으며 강도는 2에서 시작합니다. 모든 활성 노드는 다른 모든 활성 노드에 연결됩니다.

턴마다, 당신은 그들의 힘을 가진 모든 활성 노드의 목록을 받게됩니다. 소유 한 각 활성 노드에 대해 다음 중 하나를 수행하십시오.

1. 전체 힘을 전달할 활성 노드를 지정 하거나
2. 저장하고 강도를 높이십시오

그런 다음 순서대로 발생합니다 .

1. 강도를 저장하기로 한 노드는 강도를 1 증가시킵니다.
2. 강도를 전송하기로 선택한 모든 노드는 동시에 전체 강도를 새 노드로 전송합니다.
3. 노드가 적의 노드에서 힘을 전달 받으면 공격이 발생합니다. 적의 소유자 가 원래의 소유자 (및 다른 모든 공격자)보다 더 많은 힘을 전수하면 해당 적이 새로운 소유자가됩니다. 그러면 해당 노드의 강도가 공격자의 강도가됩니다. 힘이 동점 인 경우 소유자가 무작위로 선택됩니다.
4. 강도가없는 모든 노드는 안전한 것으로 간주 되며 소유자에게 1 점을줍니다.

100 턴의 100 번의 게임 후 모든 게임에서 가장 안전한 노드를 가진 소유자가 승리합니다. 편집 : 마지막 1900 턴이 쓸모없는 결과로 2000에서 100 턴으로 변경했습니다.

IO

다음과 같이 활성 노드 목록 (명령 줄 args를 통해)이 전달됩니다.

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) 해당 노드를 공격하여 풀에서 제거하고 합을 재설정 한 후 계속합니다. 결국 가장 강한 노드가 공격 할 사람을 찾지 못하면 더 많은 힘을 모을 수 있습니다.

편집 : 누산기는 이제 조금 더 똑똑합니다. 항상 가장 약한 적의 노드를 공격하는 대신, 그렇게 할 때까지 힘을 축적 한 다음 그 힘으로 가능한 가장 강한 자유 노드를 공격합니다. 또한, 끝 부분에 여전히 적들이 남아 있다면, 할당되지 않은 노드는 힘을 양도하기로 결정한 경우에 대비하여 나머지 가장 약한 적을 공격합니다.

고급, 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

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

• 적들이 큰 노드를 강화하지 않는다고 가정합니다 : 가장 친한 노드는이 가정에서 이길 수있는 가장 강한 적을 공격합니다.
• 가장 약한 대상이 공격 받았다고 가정합니다. 두 번째로 큰 아군 노드는 매 라운드마다 가장 약한 아군 노드로 이동합니다.
• 많은 자유 힘을 원합니다 : 다른 노드는 기다립니다.