Mạng không thể truy cập. Các cuộc tấn công DDoS hiện đang lan tràn và lan rộng. Tùy thuộc vào bạn để kiểm soát và sửa chữa internet.

Mỗi bot sẽ kiểm soát 20 nút trong mạng này. Mỗi nút đều hoạt động hoặc an toàn , có chủ sở hữu và có cường độ, bắt đầu từ 2. Mọi nút hoạt động được kết nối với tất cả các nút hoạt động khác.

Mỗi lượt, bạn sẽ nhận được một danh sách tất cả các nút hoạt động với sức mạnh của chúng. Đối với mỗi nút hoạt động mà bạn sở hữu, bạn cũng:

1. Chỉ định một nút hoạt động mà bạn muốn chuyển toàn bộ sức mạnh của mình sang, hoặc
2. Lưu và tăng sức mạnh của nó

Sau đó, những điều sau đây xảy ra theo thứ tự :

1. Một nút chọn để tiết kiệm sức mạnh của nó sẽ tăng sức mạnh của nó thêm 1.
2. Tất cả các nút chọn chuyển sức mạnh của họ sẽ đồng thời chuyển toàn bộ sức mạnh của họ sang nút mới.
3. Nếu một nút được chuyển sức mạnh từ một nút kẻ thù, một cuộc tấn công sẽ xảy ra. Nếu là kẻ thù chủ sở hữu cùng nhau chuyển nhiều sức mạnh hơn chủ sở hữu ban đầu (và tất cả những kẻ tấn công khác), thì kẻ thù đó sẽ trở thành chủ sở hữu mới. Sức mạnh của nút đó sau đó trở thành sức mạnh của kẻ tấn công. Nếu có một sự ràng buộc cho sức mạnh, thì chủ sở hữu sẽ được chọn ngẫu nhiên.
4. Tất cả các nút còn lại mà không có bất kỳ sức mạnh nào sẽ được coi là an toàn và cho 1 điểm cho chủ sở hữu.

Sau 100 trò chơi trong 100 lượt, chủ sở hữu có các nút an toàn nhất trong tất cả các trò chơi sẽ thắng. EDIT: Tôi đã thay đổi nó từ 2000 thành 100 lượt, vì cuối cùng 1900 lượt đó là vô dụng

Tôi

Bạn sẽ được thông qua danh sách các nút hoạt động (thông qua các dòng lệnh args) như sau:

F20 F4 E7 E2 E20 F2

F chỉ định rằng nút là một nút thân thiện và E chỉ định rằng nút đó là kẻ thù.

Đối với mỗi nút thân thiện của bạn, bạn nên trả về một hành động (thông qua STDOUT) như sau:

0,0 1,3 5,0

Ở trên có nghĩa là bạn muốn tăng sức mạnh của nút đầu tiên, hãy sử dụng nút thứ hai để tấn công nút thứ tư và nút cuối cùng của bạn sẽ chuyển sức mạnh của nó sang nút đầu tiên (và nếu không ai tấn công nó, nó sẽ trở thành nút an toàn ).

Sau khi trở về, chương trình của bạn nên bỏ.

Bảng điểm

người tích lũy được 3240 điểm

đẳng cấp đạt 2370 điểm

người câm có 2262 điểm

Random_bot nhận được 1603 điểm

smarter_random_bot đạt 1319 điểm

ổn định_bot nhận được 1097 điểm

Bộ điều khiển có thể được tìm thấy ở đây: https://github.com/nathanmerrill/NetAttack

Tích lũy, Python

Hãy bắt đầu bữa tiệc nào! Trình của tôi sẽ hoạt động cả trên Python 2 và 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()

Ý tưởng thực sự đơn giản. Tôi bắt đầu liệt kê các nút của mình theo thứ tự tăng dần sức mạnh, giữ cho tổng số điểm mạnh. Khi tổng vượt quá sức mạnh của nút kẻ thù yếu nhất (+1 để tăng khả năng), tôi tấn công nút đó và xóa nó khỏi nhóm, đặt lại tổng và tiếp tục. Cuối cùng, nếu các nút mạnh nhất không thể tìm thấy ai để tấn công, chúng sẽ thu thập thêm sức mạnh.

EDIT: Accumulator bây giờ thông minh hơn một chút. Thay vì luôn tấn công nút kẻ thù yếu nhất, nó tích lũy sức mạnh cho đến khi có thể làm được, và sau đó tấn công nút tự do mạnh nhất có thể với sức mạnh đó. Ngoài ra, nếu vẫn còn kẻ thù ở cuối, bất kỳ nút nào chưa được gán sẽ tấn công kẻ thù yếu nhất còn lại, chỉ trong trường hợp nó quyết định chuyển sức mạnh của nó đi.

Đẳng cấp, 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 chia các nút riêng của nó thành 3 loại dựa trên sức mạnh và mỗi nút hoạt động theo thể loại của nó.

• Mỗi nút mạnh tấn công một nút kẻ thù ngẫu nhiên mà nó có thể đánh bại.
• Mỗi nút giữa hỗ trợ cặp nút yếu.
• Mỗi nút yếu hỗ trợ chính nó.

Kết quả chống lại Accumulator và hai bot mẫu:

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

Đồ ngốc, 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 sẽ tấn công mà không cần bất kỳ suy nghĩ hay chiến lược nào. Mục tiêu chính là đảm bảo nhiều nút an toàn ngay từ đầu. Hãy lưu ý rằng bot này tạo một vòng lặp vô hạn với bộ tích lũy.

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

• Giả sử kẻ thù sẽ không củng cố các nút lớn: Nút thân thiện lớn nhất tấn công kẻ thù mạnh nhất mà nó có thể đánh bại theo giả định này.
• Giả sử rằng mục tiêu yếu nhất sẽ bị tấn công: Nút thân thiện lớn thứ hai di chuyển đến nút thân thiện yếu nhất mỗi vòng.
• Muốn có nhiều sức mạnh miễn phí: Các nút khác chờ đợi.