Internet telah gagal. Serangan DDoS sekarang merajalela dan meluas. Terserah Anda untuk mengambil kendali dan memperbaiki internet.

Setiap bot akan mengontrol 20 node di jaringan ini. Setiap node aktif atau aman , memiliki pemilik, dan memiliki kekuatan, yang dimulai pada 2. Setiap node aktif terhubung ke semua node aktif lainnya.

Setiap belokan, Anda akan menerima daftar semua node aktif dengan kekuatan mereka. Untuk setiap node aktif yang Anda miliki, Anda:

1. Tentukan yang aktif simpul Anda inginkan untuk mentransfer seluruh kekuatan Anda, atau
2. Simpan dan tingkatkan kekuatannya

Kemudian hal berikut terjadi secara berurutan :

1. Node yang memilih untuk menyimpan kekuatannya akan meningkatkan kekuatannya sebesar 1.
2. Semua node memilih untuk mentransfer kekuatan mereka secara bersamaan akan mentransfer seluruh kekuatannya ke node baru.
3. Jika sebuah node mentransfer kekuatan dari node musuh, sebuah serangan akan terjadi. Jika pemilik musuh kolektif mentransfer kekuatan lebih dari pemilik aslinya (dan semua penyerang lainnya), maka musuh itu menjadi pemilik baru. Kekuatan simpul itu kemudian menjadi kekuatan penyerang. Jika ada dasi untuk kekuatan, maka pemilik akan dipilih secara acak.
4. Semua node yang tersisa tanpa kekuatan akan dianggap aman , dan memberikan 1 poin kepada pemilik.

Setelah 100 game dari 100 putaran, pemilik dengan simpul paling aman di semua game menang. EDIT: Saya mengubahnya dari 2000 menjadi 100 putaran, karena ternyata 1900 terakhir tidak berguna

IO

Anda akan melewati daftar node aktif (melalui arg baris perintah) seperti berikut:

F20 F4 E7 E2 E20 F2

F menunjuk bahwa node adalah node yang bersahabat, dan E menunjuk bahwa simpul tersebut adalah musuh.

Untuk setiap node ramah Anda, Anda harus mengembalikan tindakan (via STDOUT) seperti berikut:

0,0 1,3 5,0

Di atas akan berarti bahwa Anda ingin meningkatkan kekuatan simpul pertama, gunakan simpul kedua untuk menyerang simpul keempat, dan simpul terakhir Anda akan mentransfer kekuatan simpul pertama (dan jika tidak ada yang menyerang, simpul itu akan menjadi simpul yang aman) ).

Setelah kembali, program Anda harus berhenti.

Papan angka

akumulator mendapat 3240 poin

berkelas mendapat 2.370 poin

dumbot mendapat 2262 poin

random_bot mendapat 1603 poin

smarter_random_bot mendapat 1319 poin

stable_bot mendapat 1097 poin

Pengontrol dapat ditemukan di sini: https://github.com/nathanmerrill/NetAttack

Akumulator, Python

Mari mulai pesta ini! Kiriman saya harus berfungsi baik pada Python 2 dan 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()

Idenya sangat sederhana. Saya mulai menghitung node-node saya dalam urutan kekuatan yang meningkat, menjaga jumlah kekuatan yang berjalan. Ketika jumlah melebihi kekuatan simpul musuh terlemah (+1 untuk kemungkinan peningkatan), saya menyerang simpul itu dan menghapusnya dari kumpulan, mengatur ulang jumlah, dan melanjutkan. Pada akhirnya, jika node terkuat tidak dapat menemukan siapa pun untuk menyerang, mereka akan mengumpulkan lebih banyak kekuatan.

EDIT: Akumulator sekarang sedikit lebih pintar. Alih-alih selalu menyerang simpul musuh yang paling lemah, ia menumpuk kekuatan sampai ia bisa melakukannya, dan kemudian menyerang simpul bebas terkuat yang bisa dengan kekuatan itu. Juga, jika masih ada musuh yang tersisa di akhir, setiap node yang belum ditugaskan akan menyerang musuh yang tersisa paling lemah, kalau-kalau ia memutuskan untuk mentransfer kekuatannya.

Berkelas, 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()

Bot membagi node sendiri menjadi 3 kategori berdasarkan kekuatan dan setiap node bertindak sesuai dengan kategorinya.

• Setiap node kuat menyerang node musuh acak yang bisa dikalahkan.
• Setiap simpul tengah mendukung pasangan simpul lemah itu.
• Setiap node lemah mendukung dirinya sendiri.

Hasil terhadap Accumulator dan dua bot sampel:

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);

Bot akan menyerang tanpa berpikir atau strategi. Tujuan utamanya adalah memastikan banyak simpul aman tepat di awal. Ketahuilah bahwa bot ini membuat loop tak terbatas dengan akumulator.

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

• Menganggap musuh tidak akan memperkuat simpul besar: simpul ramah terbesar menyerang musuh terkuat yang bisa dikalahkan di bawah asumsi ini.
• Diasumsikan bahwa target terlemah akan diserang: node ramah terbesar kedua bergerak ke node ramah terlemah setiap putaran.
• Ingin banyak kekuatan gratis: Node lain menunggu.