İnternet koptu. DDoS saldırıları artık yaygın ve yaygın. İnterneti kontrol altına almak ve onarmak size kalmıştır.

Her bot, bu ağdaki 20 düğümü kontrol edecektir. Her düğüm ya aktif veya güvenlidir , bir sahibi vardır ve 2'den başlayan bir gücü vardır. Her etkin düğüm diğer tüm etkin düğümlere bağlanır.

Her turda, tüm aktif düğümlerin güçleriyle bir liste alacaksınız. Sahip olduğunuz etkin düğümlerin her biri için:

1. Aktarmak istediğiniz etkin düğümü atayın bütün gücü, ya
2. Tasarruf edin ve gücünü artırın

Sonra aşağıdakiler sırayla olur :

1. Gücünü korumayı seçen bir Düğüm, gücünü 1 arttırır.
2. Güçlerini aktarmayı seçen tüm düğümler aynı anda tüm güçlerini yeni düğüme aktarır.
3. Bir düğüm bir düşman düğümünden kuvvet aktarılırsa bir saldırı gerçekleşir. Eğer bir düşman sahibi topluca orijinal sahipten (ve diğer tüm saldırganlardan) daha fazla güç aktarırsa, o düşman yeni sahip olur. Bu düğümün gücü daha sonra saldırganın gücü olur. Güç için bir kravat varsa, sahibi rastgele seçilecektir.
4. Herhangi bir güçsüz bırakılan tüm düğümler güvenli kabul edilir ve sahibine 1 puan verir.

100 turluk 100 oyundan sonra, tüm oyunlarda en güvenli düğümlere sahip olan sahibi kazanır. DÜZENLEME: Son 1900 dönüşünün işe yaramadığı için 2000'den 100 tura değiştirdim

IO

Aşağıdaki gibi aktif düğümlerin listesine (komut satırı argümanları aracılığıyla) geçirilirsiniz:

F20 F4 E7 E2 E20 F2

F düğümün dostça bir düğüm olduğunu belirtir ve E olduğunu ve düğümün düşman olduğunu belirtir.

Dost düğümlerinizin her biri için aşağıdakine benzer bir işlem (STDOUT aracılığıyla) döndürmelisiniz:

0,0 1,3 5,0

Yukarıdaki, ilk düğümün gücünü artırmak, dördüncü düğüme saldırmak için ikinci düğümünüzü kullanmak istediğiniz anlamına gelir ve son düğümünüz, gücünü ilk düğüme aktarır (ve kimse saldırmazsa, güvenli bir düğüm haline gelecektir) ).

Geri döndükten sonra programınız kapanmalıdır.

sayı tahtası

akümülatör 3240 puan aldı

klas 2370 puan aldı

dumbot 2262 puan aldı

random_bot 1603 puan aldı

smarter_random_bot 1319 puan aldı

steady_bot 1097 puan aldı

Denetleyiciyi burada bulabilirsiniz: https://github.com/nathanmerrill/NetAttack

Akümülatör, Python

Hadi bu partiyi başlatalım! Gönderim hem Python 2 hem de Python 3 üzerinde çalışmalıdır.

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

Fikir gerçekten basit. Düğümlerimi artan güç sırasına göre numaralandırmaya başlıyorum ve güçlü yönlerin toplamını koruyorum. Toplam en zayıf düşman düğümünün gücünü aştığında (olası bir artış için +1), bu düğüme saldırır ve havuzdan kaldırırım, toplamı sıfırlar ve devam ederim. Sonunda, en güçlü düğümler saldıracak birini bulamazsa, daha fazla güç toplarlar.

EDIT: Akümülatör şimdi biraz daha akıllı. Her zaman en zayıf düşman düğümüne saldırmak yerine, gücü, bunu yapabilene kadar biriktirir ve daha sonra bu güçle yapabileceği en güçlü serbest düğüme saldırır. Ayrıca, sonunda hala düşman varsa, atanmamış düğümler, gücünü en aza indirmeye karar vermesi durumunda kalan en zayıf düşmana saldırır.

Şık, 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, kendi düğümlerini güç temelinde 3 kategoriye ayırır ve her düğüm kendi kategorisine göre hareket eder.

• Her güçlü düğüm, yenebileceği rastgele bir düşman düğümüne saldırır.
• Her orta düğüm zayıf düğüm çiftini destekler.
• Her zayıf düğüm kendini destekler.

Akümülatöre ve iki numune botuna karşı sonuç:

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 herhangi bir düşünce veya strateji olmadan saldırır. Ana hedef, başlangıçta çok sayıda güvenli düğüm sağlamaktır. Bu botun akümülatör ile sonsuz bir döngü oluşturduğunu unutmayın.

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

• Düşmanların büyük düğümleri pekiştirmeyeceğini varsayar: En büyük dost düğüm, bu varsayım altında yenebileceği en güçlü düşmana saldırır.
• En zayıf hedefe saldırı olacağını varsayar: En büyük ikinci dost düğüm her turda en zayıf dost düğüme gider.
• Çok fazla serbest güç istiyor: Diğer düğümler bekliyor.