डीडीओएस इंटरनेट से कैसे उबरें

Question

इंटरनेट विफल हो गया है। DDoS के हमले अब व्यापक और व्यापक हैं। इंटरनेट पर नियंत्रण रखना और उसकी मरम्मत करना आपके ऊपर है।

प्रत्येक बॉट इस नेटवर्क में 20 नोड्स को नियंत्रित करेगा। प्रत्येक नोड या तो सक्रिय या सुरक्षित है , एक मालिक है, और एक ताकत है, जो 2 से शुरू होती है। प्रत्येक सक्रिय नोड अन्य सभी सक्रिय नोड से जुड़ा हुआ है।

प्रत्येक मोड़ पर, आपको उनकी ताकत के साथ सभी सक्रिय नोड्स की एक सूची प्राप्त होगी। आपके द्वारा सक्रिय प्रत्येक नोड के लिए, आप या तो:

1. एक सक्रिय नोड नामित करें जिसे आप अपनी पूरी शक्ति को स्थानांतरित करना चाहते हैं , या
2. बचाओ और इसकी ताकत बढ़ाओ

तब निम्नलिखित क्रम में होता है :

1. अपनी ताकत को बचाने के लिए चुनने वाला एक नोड 1 से अपनी ताकत बढ़ाएगा।
2. अपनी शक्ति को स्थानांतरित करने के लिए चुनने वाले सभी नोड एक साथ अपनी पूरी ताकत को नए नोड में स्थानांतरित करेंगे।
3. अगर एक नोड को एक दुश्मन नोड से ताकत स्थानांतरित की गई थी, तो एक हमले को सुनिश्चित किया जाएगा। यदि कोई दुश्मन मालिक मूल मालिक (और सभी अन्य हमलावरों) की तुलना में सामूहिक रूप से अधिक ताकत स्थानांतरित करता है, तो वह दुश्मन नया मालिक बन जाता है। फिर उस नोड की ताकत हमलावर की ताकत बन जाती है। यदि ताकत के लिए एक टाई है, तो मालिक को यादृच्छिक रूप से चुना जाएगा।
4. बिना किसी ताकत के छोड़े गए सभी नोड्स को सुरक्षित माना जाएगा , और मालिक को 1 अंक दिया जाएगा।

100 गेम के 100 गेम के बाद, सभी गेम में सबसे सुरक्षित नोड्स के साथ मालिक जीतता है। EDIT: मैंने इसे 2000 से 100 मोड़ में बदल दिया, क्योंकि यह समाप्त हो गया कि पिछले 1900 मोड़ बेकार थे

आईओ

आपको निम्न की तरह सक्रिय नोड्स (कमांड लाइन आर्ग्स के माध्यम से) की सूची दी जाएगी।

F20 F4 E7 E2 E20 F2

Fनामित करता है कि नोड एक अनुकूल नोड है, और Eनामित करता है कि नोड एक दुश्मन है।

आपके प्रत्येक अनुकूल नोड के लिए, आपको निम्न की तरह एक क्रिया (STDOUT के माध्यम से) वापस करनी चाहिए:

0,0 1,3 5,0

उपरोक्त का मतलब यह होगा कि आप पहले नोड की अपनी ताकत बढ़ाना चाहते हैं, चौथे नोड पर हमला करने के लिए अपने दूसरे नोड का उपयोग करते हैं, और आपका आखिरी नोड अपनी ताकत को पहले नोड को स्थानांतरित कर देगा (और यदि कोई इस पर हमला नहीं करता है, तो यह एक सुरक्षित नोड बन जाएगा। )।

लौटने के बाद, आपका कार्यक्रम छोड़ देना चाहिए।

स्कोरबोर्ड

संचायक को 3240 अंक मिले

उत्तम को 2370 अंक मिले

डंबोट को 2262 अंक मिले

random_bot को 1603 अंक मिले

Short_random_bot को 1319 अंक मिले

स्थिर_बोट को 1097 अंक मिले

नियंत्रक यहां पाया जा सकता है: https://github.com/nathanmerrill/NetAttack

Comments

नियंत्रक विनिर्देश के साथ विरोधाभास करता है: "यदि कोई दुश्मन मालिक मूल मालिक की तुलना में सामूहिक रूप से अधिक ताकत स्थानांतरित करता है ..."। वर्तमान में यह बराबर या अधिक है ।

— रैंडम

@ रेखाचित्र: कल्पना में यह कहता है: यदि ताकत के लिए एक टाई है, तो मालिक को बेतरतीब ढंग से चुना जाएगा

— नाथन मेरिल

@NathanMerrill मुझे लगता है कि अगर हमलावर टाई करते हैं।

— बेतरतीब

अंतिम शेष नोड खेल के अंत तक इंतजार कर रहा है, है ना? उसे भागने का कोई रास्ता नहीं है?

— ऐनाबिस

@acbabis सही है, लेकिन मैं वास्तव में इसके लिए परीक्षण करता हूं और उस समय पर खेल को समय से पहले समाप्त करता हूं।

— नाथन मेरिल

Answer 1

संचयकर्ता, पायथन

आइये यह पार्टी शुरू करते हैं! मेरे सबमिशन को पायथन 2 और पायथन 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) की ताकत से अधिक हो जाती है, तो मैं उस नोड पर हमला करता हूं और इसे पूल से हटा देता हूं, योग को रीसेट करता हूं, और जारी रखता हूं। अंत में, अगर सबसे मजबूत नोड्स किसी पर हमला करने के लिए नहीं मिल सकते हैं, तो वे अधिक ताकत एकत्र करेंगे।

संपादित करें: Accumulator अब थोड़ा होशियार है। हमेशा सबसे कमजोर दुश्मन नोड पर हमला करने के बजाय, यह ताकत जमा करता है जब तक कि यह ऐसा नहीं कर सकता, और फिर उस ताकत के साथ सबसे मजबूत मुक्त नोड पर हमला कर सकता है। इसके अलावा, अगर अंत में अभी भी शत्रु बचे हैं, तो कोई भी असंबद्ध नोड सबसे कमजोर शेष दुश्मन पर हमला करेगा, बस अगर वह अपनी ताकत को स्थानांतरित करने का फैसला करता है।

Answer 2

उत्तम दर्जे का, पायथन 3

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

Answer 3

डंबोट, नॉडजस

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

बॉट बिना किसी सोच या रणनीति के हमला करेगा। मुख्य लक्ष्य शुरुआत में बहुत सारे सुरक्षित नोड सुनिश्चित करना है। ज्ञात हो कि यह बॉट संचायक के साथ एक अनंत लूप बनाता है।

Answer 4

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

• दुश्मनों को लगता है कि बड़े नोड्स को मजबूत नहीं करेगा: सबसे बड़ा अनुकूल नोड सबसे मजबूत दुश्मन पर हमला करता है जो इस धारणा के तहत हरा सकता है।
• मानता है कि सबसे कमजोर लक्ष्य पर हमला किया जाएगा: दूसरा सबसे बड़ा अनुकूल नोड प्रत्येक दौर में सबसे कमजोर अनुकूल नोड को स्थानांतरित करता है।
• बहुत सारी मुफ्त ताकत चाहता है: अन्य नोड्स इंतजार करते हैं।

Comments

मैं अनिश्चित क्यों हूं, लेकिन यह बॉट ठीक से नहीं लौट रहा है (यह एक खाली स्ट्रिंग प्रिंट करता है)। अन्य नोडज बॉट काम करता है, इसलिए मैं इसे देखने की सलाह दूंगा। मुझे यह भी उल्लेख करना चाहिए कि मैंने सिर्फ नोडज स्थापित किया है, और जब मैं जावास्क्रिप्ट को जानता हूं, तो मुझे नोडज के लिए कुछ विशेष याद आ रही हो सकती है।

— नाथन मेरिल

सर उठाने के लिए धन्यवाद। जब मैं करता हूं node SteadyBot.js F20 F4 E7 E2 E20 F2, यह मेरे लिए काम करता है। क्या आप मुझे वह इनपुट बता सकते हैं जिसके लिए यह विफल हो रहा है?

— ऐनाबिस

@NathanMerrill मैंने इसे स्टड के साथ काम करने के लिए फिर से लिखा था। आशा है कि इसे ठीक करता है। cat F20 F4 E7 E2 E20 F2 | node SteadyBot.js

— ऐनाबिस

@acbabis Input को एक बड़े तर्क के रूप में दिया गया है।

— बेतरतीब

@acbabis randomra सही है। आपको 1 बड़ा तर्क मिलने वाला है, सूची (जब तक, आपको C ++ की तरह कॉल नहीं मिलता है, इस स्थिति में, आपको 2 मिलेंगे)।

— नाथन मेरिल