อินเทอร์เน็ตล้มเหลว การจู่โจม 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 ได้ 2,262 คะแนน

random_bot ได้ 1603 คะแนน

smarter_random_bot ได้ 1,319 คะแนน

steady_bot ได้ 1,097 คะแนน

ตัวควบคุมสามารถพบได้ที่นี่: 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 สำหรับการเพิ่มขึ้นที่เป็นไปได้) ฉันโจมตีโหนดนั้นและลบออกจากพูลรีเซ็ตผลรวมและดำเนินการต่อ ในตอนท้ายถ้าโหนดที่แข็งแกร่งที่สุดไม่สามารถหาใครโจมตีพวกเขาจะรวบรวมความแข็งแกร่งมากขึ้น

แก้ไข:สะสมตอนนี้เป็นอย่างชาญฉลาด แทนที่จะโจมตีโหนดศัตรูที่อ่อนแอที่สุดเสมอมันจะรวบรวมพลังจนกว่าจะสามารถทำได้และจากนั้นจะโจมตีโหนดอิสระที่แข็งแกร่งที่สุดที่สามารถทำได้ด้วยความแข็งแกร่งนั้น นอกจากนี้หากยังมีศัตรูเหลือในตอนท้ายโหนดที่ไม่ได้กำหนดจะโจมตีศัตรูที่อ่อนแอที่สุดที่เหลืออยู่ในกรณีที่มันตัดสินใจที่จะถ่ายโอนความแข็งแกร่งของมันออกไป

Classy, ​​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 และบอทตัวอย่างทั้งสอง:

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

• สมมติว่าศัตรูไม่เสริมกำลังโหนดใหญ่ ๆ : โหนดใหญ่ที่สุดที่เป็นมิตรโจมตีศัตรูที่แข็งแกร่งที่สุดที่สามารถเอาชนะได้ภายใต้สมมติฐานนี้
• สมมติว่าเป้าหมายที่อ่อนแอที่สุดจะถูกโจมตี: โหนดที่ใหญ่ที่สุดอันดับสองจะย้ายไปยังโหนดที่อ่อนแอที่สุดในแต่ละรอบ
• ต้องการความอิสระมากมาย: โหนดอื่น ๆ รอ