सरल दौड़ KoTH

Question

यह चुनौती आधिकारिक रूप से समाप्त हो गई है। आगे प्रस्तुतियाँ प्रतिस्पर्धी नहीं होंगी (लेकिन अभी भी स्वागत है!)। यहां स्कोर देखें

इस चुनौती में, सबमिशन ("बॉट्स") जावास्क्रिप्ट फ़ंक्शंस होने चाहिए जो अधिक से अधिक दौड़ जीतने की कोशिश करें। प्रत्येक दौड़ में, बॉट्स के पास सीमित मात्रा में ऊर्जा होगी जिसका उपयोग 100 इकाइयों की दूरी पर जितनी जल्दी हो सके यात्रा करने के लिए किया जाना चाहिए।

यांत्रिकी

प्रत्येक गेम में कई दौड़ शामिल होंगी, जो कई मोड़ से बनी होती हैं। प्रत्येक मोड़ में, बॉट आगे की यात्रा करने के लिए एक नॉनगेटिव दूरी का चयन करेंगे। भेजी जाने वाली ऊर्जा की मात्रा यात्रा की गई दूरी के वर्ग के बराबर है (और बॉट केवल यात्रा करेंगे जहां तक ​​उनकी ऊर्जा का स्तर अनुमति देता है यदि वे लंबी दूरी पर लौटते हैं)।

प्रत्येक दौड़ की शुरुआत में, बॉट की स्थिति 0. पर रीसेट हो जाती है। एक या एक से अधिक बॉट 100 इकाइयों की दूरी तक पहुंचने के बाद, दौड़ समाप्त हो जाएगी। ध्यान दें कि यदि कोई बॉट एक दूरी तय करता है जो इसे शुरू से 100 इकाइयों से आगे रखता है, तो यह केवल उतना ही आगे बढ़ेगा जितना कि जीतने के लिए आवश्यक है। सभी जातियों की शुरुआत में, बॉट्स को पिछली दौड़ से किसी भी शेष के अलावा 100 ऊर्जा प्राप्त होगी। वे पिछली दौड़ में यात्रा की गई प्रत्येक इकाई के लिए 1 ऊर्जा का बोनस भी प्राप्त करेंगे।

अंक

प्रत्येक दौड़ के अंत में, सभी बॉट्स को प्रत्येक दस इकाइयों के लिए एक अंक प्राप्त होगा जो उन्होंने यात्रा की है जब खेल समाप्त होता है (एक बिंदु के भिन्न सहित)। एक गेम के अंत में, बॉट सबसे अधिक अंक जीतता है।

क्योंकि यह संभावना है कि बॉट्स को निश्चित संख्या में दौड़ के लिए अनुकूलित किया जाएगा, इसमें 5 श्रेणियां होंगी जिनमें सभी बॉट प्रतिस्पर्धा करेंगे: 250 दौड़, 750 दौड़, 2500 दौड़, 7500 दौड़ और 25000 दौड़। एक बॉट का समग्र स्कोर इन श्रेणियों में से प्रत्येक में उनके औसत स्कोर प्रति दौड़ का योग होगा , जिससे उच्चतम संभव स्कोर 50 हो जाएगा।

इनपुट आउटपुट

बॉट्स को निम्न तर्क प्राप्त होंगे: dist(वर्तमान दौड़ में उन्होंने जो दूरी तय की है), energy(उनके पास botsजितनी ऊर्जा है), और अंतिम मोड़ के अंत तक अन्य सभी बॉट्स की दूरी की एक सरणी, जिसे फेरबदल किया गया प्रत्येक दौड़ का अंत), और storage, जो डिफ़ॉल्ट रूप से एक खाली वस्तु है और दौड़ के बीच जानकारी को संग्रहीत करने के लिए इस्तेमाल किया जा सकता है।

उदाहरण बॉट

अनुयायी औसत बॉट से आगे बढ़ने की कोशिश करेंगे, औसत राशि प्रति मोड़ से आगे बढ़ेगी।

{
    "Follower": function(dist, energy, bots, storage) {
        storage.turns = storage.turns || 0;

        if (Math.max(...bots))
            storage.avg = ((storage.avg || 0) * storage.turns++ + bots.reduce((a, b, i) => a + (b - storage.last[i]), 0) / bots.length) / storage.turns;

        storage.last = bots;

        return (bots.reduce((a, b) => a + b, 0) / bots.length + (storage.avg || 1)) - dist;
    }
}

नियंत्रक

// Each bot should be placed in this object

var bot_data = {
    "Follower": function(dist, energy, bots, storage) {
        storage.turns = storage.turns || 0;

        if (Math.max(...bots))
            storage.avg = ((storage.avg || 0) * storage.turns++ + bots.reduce((a, b, i) => a + (b - storage.last[i]), 0) / bots.length) / storage.turns;

        storage.last = bots;

        return (bots.reduce((a, b) => a + b, 0) / bots.length + (storage.avg || 1)) - dist;
    }
};

var games = 0;
var records = {};

// races: Number of races
// log: Array of bot names to log information about, or null for no logging
//   Per-turn logging will only happen in games with less than 10 races
//   Per-race logging will only happen in games with less than 100 races
// bold: Whether to use bold text when logging information

var run_game = function(races, log = [], bold = true) {
    var perf_now = performance.now();
    
    var bots = [];
    
    games++;

    for (let bot in bot_data)
        bots.push({
            name: bot,
            run: bot_data[bot]
        });

    var uids = new Array(bots.length);

    for (let i = 0; i < uids.length; i++)
        uids[i] = i;

    var race = 0;
    var turn = 0;

    for (let r = 0; r < races; r++) {
        race++;

        for (let j, i = 0; i < uids.length; i++) {
            j = Math.random() * (i + 1) | 0;
            [uids[i], uids[j]][uids[j], uids[i]];
        }

        for (let b, i = 0; i < bots.length; i++) {
            b = bots[i];

            bots[i] = {
                name: b.name,
                run: b.run,

                uid: uids[i],
                dist: 0,
                energy: (b.energy || 0) + 100,
                points: b.points || 0,

                storage: b.storage || {},

                next: 0,
                inactive: 0
            };
        }

        turn = 0;

        while ((bots.every(b => b.dist < 100) && bots.some(b => b.energy > 0 && b.inactive < 3))) {
            turn++;

            for (let b, i = 0; i < bots.length; i++) {
                b = bots[i];

                try {
                    b.next = b.run(
                        b.dist, b.energy,
                        bots.filter(o => o.uid != b.uid).map(o => o.dist),
                        b.storage
                    );

                    if (log && log.includes(b.name) && races < 10)
                        console.log("[" + race + ":" + turn + "] " + b.name + "(" + (Math.round(b.dist * 1000) / 1000) + "," + (Math.round(b.energy * 1000) / 1000) + "):", b.next);
                } catch(e) {
                    if (log && races < 10)
                        console.warn("[" + race + ":" + turn + "] " + b.name + ":\n" + (e.stack || e.message));

                    b.next = 0;
                }

                b.next = Number(b.next);

                if (Number.isNaN(b.next))
                    b.next = 0;

                b.next = Math.max(Math.min(b.next, 100 - b.dist, Math.sqrt(b.energy)), 0);

                if (!b.next)
                    b.inactive++;
            }

            for (let b, i = 0; i < bots.length; i++) {
                b = bots[i];

                b.dist += b.next;
                b.energy = Math.max(b.energy - b.next ** 2, 0);
            }
        }

        for (let b, i = 0; i < bots.length; i++) {
            b = bots[i];

            b.energy = b.energy + b.dist;
            b.points += b.dist / 10;
        }

        if (log && races < 100)
            console.log(
                (bold ? "%c" : "") + "Race " + race + ":\n" +
                (bold ? "%c" : "") + bots.map(b => b).sort((a, b) => b.dist - a.dist).map(
                    b => b.name.slice(0, 16) + " ".repeat(20 - Math.min(b.name.length, 16)) + (Math.round(b.dist * 1000) / 10000)
                ).join("\n"), ...(bold ? ["font-weight: bold;", ""] : [])
            );
    }

    for (let i = 0; i < bots.length; i++)
        records[bots[i].name] = (records[bots[i].name] || 0) + bots[i].points / races;
    
    if (log)
        console.log(
            (bold ? "%c" : "") + "Average Points/Race (" + races + " races, " + (Math.ceil((performance.now() - perf_now) * 1000) / 1000) + "ms):\n" +
            (bold ? "%c" : "") + bots.sort((a, b) => b.points - a.points).map(
                b => b.name.slice(0, 16) + " ".repeat(20 - Math.min(b.name.length, 16)) + (Math.round((b.points / races) * 10000) / 10000)
            ).join("\n"), ...(bold ? ["font-weight: bold;", ""] : [])
        );
};

// Print and clear records for average scores

var print_records = function(bold = true) {
    console.log(
        (bold ? "%c" : "") + "Sum of Average Points/Game:\n" +
        (bold ? "%c" : "") + Object.entries(records).sort((a, b) => b[1] - a[1]).map(
            b => b[0].slice(0, 16) + " ".repeat(20 - Math.min(b[0].length, 16)) + (Math.round(b[1] * 10000) / 10000)
        ).join("\n"), ...(bold ? ["font-weight: bold;", ""] : [])
    );
};

var clear_records = function() {
    records = {};
};

// Default race categories

run_game(250);
run_game(750);
run_game(2500);
run_game(7500);
run_game(25000);

print_records();

नियमों

• यदि कोई बॉट एक पंक्ति में तीन मोड़ के लिए नहीं चला है, तो एक दौड़ समाप्त हो जाएगी (स्कोर अभी भी गिना जाएगा)

• यदि कोई बॉट त्रुटि करता है, तो यह एक मोड़ खो देगा (यानी, स्थानांतरित नहीं होगा)

• बॉट नियंत्रक या अन्य बॉट्स के साथ छेड़छाड़ नहीं कर सकते हैं, या अन्यथा दुर्भावनापूर्ण हो सकते हैं

• बॉट उचित समय में चलना चाहिए

• बॉट निर्धारक होना चाहिए; कोई यादृच्छिकता नहीं है जब तक कि यह बॉट के तर्कों द्वारा वरीयता प्राप्त न हो

चैट: https://chat.stackexchange.com/rooms/112222/simple-race-koth

के कारण बॉट: शुक्रवार, 4 सितंबर, 12:00 UTC (08:00 EDT)

Answer 1

कम्पेसाटर

"सबऑप्टिमल" से व्युत्पन्न, कॉम्पेंसेटर स्पष्ट रूप से "होर्डे / बर्स्ट" रणनीति के लिए पूरा नहीं करता है, बल्कि यह स्वाभाविक रूप से इस ज्ञान के माध्यम से क्षतिपूर्ति करता है कि यदि यह पहले नहीं था, तो हो सकता है कि उसने पिछले मोड़ में अपनी सारी ऊर्जा का इस्तेमाल न किया हो। इसमें उम्मीद से ज्यादा ऊर्जा हो सकती है। ऊर्जा की आपूर्ति की इस अधिकता को भुनाने के लिए, यह बॉट अतिरिक्त ऊर्जा के आधे हिस्से का उपयोग करने की कोशिश करेगा और एक तेज दौड़ को मजबूर करेगा, लेकिन अन्य आधे को आरक्षित रखने के लिए और अधिक दौड़ के दौरान ऊर्जा अधिशेष के प्रभाव को बाहर निकालने के लिए।

यह अपने भाई (सबऑप्टिमल) की तुलना में थोड़ा बेहतर प्रदर्शन करता है, और इस सबमिशन के समय के रूप में, अन्य सभी बॉट्स से थोड़ा आगे निकलता है।

{
    "Compensator": function(dist, energy, bots, storage) {
        if ( dist == 0)
        {
          if (storage.targetStartingEnergy == undefined)
          {
            storage.targetStartingEnergy = energy;
            storage.nominalStartingEnergy = energy + 100;
          }
          else
          {
            if (energy <= storage.nominalStartingEnergy)
            {
              storage.targetStartingEnergy = energy;
            }
            else
            {
              storage.targetStartingEnergy = ((energy - storage.nominalStartingEnergy) * 0.5) +  storage.nominalStartingEnergy;
            }
          }

          if (storage.raceNumber == undefined)
          {
            storage.raceNumber = 1;
          }
          else
          {
            storage.raceNumber++;
          }

          storage.energyConsumptionRate = storage.targetStartingEnergy / 100;
        }

        let step = 0;

        if (storage.raceNumber == 1)
        {
          step = 1;
        }
        else
        {
          step = storage.energyConsumptionRate;
        }

        return step;
    }
}

Answer 2

मूल्य नियंत्रण

{
    "Rate control": function(distanceTravelled, energyLeft, _, s) {
        if (distanceTravelled === 0) {
            for (let i = 100; i > 0; --i) {
                if (10000 / i > energyLeft) {
                    s.travelSpeed = 100 / (i + 1);
                    break;
                }
            }
        }

        return s.travelSpeed;
    }
}

प्रत्येक राउंड फिनिश लाइन तक पहुंचने के लिए अपनी सभी ऊर्जा का उपयोग करता है। "धीमे और स्थिर" की तुलना में सख्ती से बेहतर है क्योंकि यह प्रविष्टि केवल 1 या अधिक ऊर्जा प्रति मोड़ का उपयोग करेगी, जबकि यह भी सुनिश्चित करेगी कि यह हमेशा अंत तक बना रहे। अकल्पित, लेकिन अभी भी काफी तेज है।

Answer 3

धीमी और स्थिर

{
    "Slow and steady": function() {
        return 1;
    }
}

बेसलाइन बॉट, जबकि मैं यह पता लगाने की कोशिश करता हूं कि इस चुनौती का क्या करना है। अगर यह किसी प्रकार का मेटा विकसित होता है तो यह बिल्कुल खोना शुरू नहीं करता है।

Answer 4

पूर्वगामी

{
    "precomputed": function(dist, energy, bots, storage) {
        if (dist === 0) {
            let movements = Array.from(new Array(100), _=>1)

            const totalEnergyConsumed = () => movements.reduce((a,c)=>a+c**2,0)
            let currentIndex = 0

            while(totalEnergyConsumed() < energy) {
                movements[currentIndex] += movements[currentIndex + 1]
                movements.splice(currentIndex + 1, 1)
                if (++currentIndex >= movements.length - 1) {
                    currentIndex = 0
                }
            }

            currentIndex = movements.length
            while(totalEnergyConsumed() > energy) {
                if(movements[currentIndex] > 1) {
                    movements[currentIndex]--
                    movements.push(1)
                } else {
                    currentIndex--
                }
            }

            storage.movements = {}
            movements.reduce((a,c)=>{storage.movements[a]=c;return a+c}, 0)
        }
        return storage.movements[dist]
    }
}

पूरी दौड़ के लिए लगभग एक ही गति से आगे बढ़ने के लिए पूर्ण पथ की गणना करके दौड़ शुरू करता है, जबकि अभी भी उपलब्ध सभी ऊर्जा का उपयोग कर रहा है

Answer 5

नव्वे

{
    "Ninety": function(dist, energy, bots, storage) {
        if (dist === 0) {
            for (let i = 90; i > 0; --i) {
                if (8100 / i > (energy - 10)) {
                    storage.travelSpeed = 90 / (i + 1);
                    break;
                }
            }
        }
        if (dist >= 89) {
            return 1;
        }

        return storage.travelSpeed;
    }
}

प्रति चक्कर 9 अंक पाने का लक्ष्य। मुझे यकीन नहीं है कि यह कितनी अच्छी तरह से करता है, लेकिन इसकी तुलना में तेजी से परिष्करण करने वाले बॉट्स के लिए अंक खोने की संभावना कम है (जैसा कि दर नियंत्रण की तुलना में, जो यह कांटा है)।

Answer 6

नाड़ी

"Pulse": function(dist, energy, bots, storage) {
    storage.round = storage.round ? storage.round+1 : 1;
    if(storage.round%500==0) return Math.max([...bots])+50
    return Math.floor(Math.sqrt(energy/100))
}

प्रत्येक चरण केवल 1% ऊर्जा का उपयोग करता है। प्रत्येक 500 मोड़, इस क्षण में पहले स्थान की दूरी लेता है, और इसे 50 पास जोड़ता है।

Answer 7

बॉक्स में जैक

इसकी ऊर्जा को तब तक बचाता है जब तक कि यह खेल को 40 चालों में हरा नहीं सकता, प्रति खेल औसत चालों की संख्या को नीचे लाता है।

{
    "Jack in the Box": function(dist, energy, bots, storage) {
        if (!dist) {
            if (energy >= 250) {
                storage.speed = energy / 100
            } else {
                storage.speed = .5
            }
        }
        return storage.speed
    }
}

अनाड़ी

सिम्पटन सिर्फ जीतना चाहता है :(

{
    "Simpleton": function(dist, energy, bots, storage) {
        return energy / (100 - dist)
    }
}

नियमित

स्टेडी हर बार एक ही राशि पर जाने की कोशिश करती है, लेकिन अतिरिक्त ऊर्जा होना पसंद नहीं करती है।

{
    "Steady": function(dist, energy, bots, storage) {
        storage.turns = storage.turns || 0
        storage.totalTurns = storage.totalTurns || 0
        storage.games = storage.games || 0
        storage.totalEnergyGained = storage.totalEnergyGained || 0
        storage.previousEnergy = storage.previousEnergy || 0
        if (!dist) {
            if (storage.games == 0) {
                storage.speed = 1
            } else {
                storage.totalTurns += storage.turns
                storage.turns = 0
                storage.speed = Math.sqrt(storage.totalEnergyGained / storage.totalTurns) + storage.previousEnergy / storage.totalTurns
            }
            storage.totalEnergyGained += energy - storage.previousEnergy
            storage.games++
        }
        storage.turns++;
        storage.previousEnergy = Math.max(energy - Math.max(Math.min(storage.speed, 100 - dist, Math.sqrt(energy)), 0) ** 2, 0)
        return storage.speed;
    }
}

Answer 8

इनकी

इष्टतम समाधान जहां अन्य रेसर को प्रभावित करने का कोई साधन नहीं है, यह सुनिश्चित करने के लिए कि आप दोनों को सबसे पहले अगले दौर में सबसे अधिक ऊर्जा प्राप्त करने और अपने विरोधियों के लिए ऊर्जा से इनकार करने के लिए अपनी सभी ऊर्जा का उपयोग करना है। इसके द्वारा, पहली दौड़ में 1.0 ऊर्जा प्रति टर्न खर्च करके और फिर बाद की दौड़ के लिए 2.0 प्रति टर्न खर्च करके (100 दूरी पर जीतने के लिए दी गई अतिरिक्त 100 ऊर्जा के कारण) प्राप्त किया जा सकता है।

यह बॉट की ऊर्जा / दौड़ की शुरुआत में यात्रा करने की दूरी की गणना करके प्राप्त किया जा सकता है, इस मूल्य को संग्रहीत करते हैं और फिर इस मूल्य को दौड़ के प्रत्येक मोड़ पर वापस करते हैं।

अब, जब हम जानते हैं कि इष्टतम समाधान प्रतिद्वंद्वी प्रभावों को प्रभावित करता है, तो हमें उन कार्यों पर विचार करने की आवश्यकता है जो प्रतिद्वंद्वी प्रदर्शन कर सकते हैं जो दूसरों को प्रभावित कर सकते हैं। इस खेल में, एकमात्र वास्तविक प्रभाव विजेता होने के द्वारा वर्तमान दौड़ के अंत को मजबूर करने की क्षमता है। चूंकि बॉट्स को ऊर्जा जमा करने और जमा करने की अनुमति है, वे ऊर्जा की खपत को कम करने और ऊर्जा उत्पादन को अधिकतम करने का निर्णय ले सकते हैं, किसी विशेष दौड़ के लिए कई अंक हासिल करने का मौका त्याग सकते हैं और इसके बजाय एक दौड़ में संचित बिंदुओं को खर्च करने के लिए अन्य बॉट पर हावी होते हैं और जीतते हैं दौड़। हालांकि यह रणनीति कुल मिलाकर उच्च अंक नहीं देती है, लेकिन यह उन बॉट्स को प्रभावित करती है जो 100 मोड़ के बाद दौड़ खत्म होने की उम्मीद कर रहे हैं। एक दौड़ की औसत बारी गिनती इस प्रकार कम हो जाती है। तो इस प्रभाव की भरपाई करने के लिए, एक उप-इष्टतम समाधान इष्टतम समाधान से एक कारक जोड़कर प्राप्त होता है जो बॉट्स के प्रभाव का अनुकरण करता है जो इस "होर्ड-फट" रणनीति का उपयोग करता है।

यह कारक तब तक गणना करने में सक्षम नहीं है जब तक कि बॉट अन्य सभी बॉट रणनीतियों को शामिल नहीं करता है और फिर कारक निर्धारित करने के लिए एक विश्लेषण कर रहा है। यह वास्तव में KoTH चुनौतियों की भावना में नहीं है और इसकी अनुमति नहीं दी जा सकती है। तो इस बॉट के लिए, जमावट की संख्या के आधार पर एक स्केलर में जमा करने और जोड़ने के समय एक सरल अनुभवजन्य विश्लेषण किया गया था, जो इस धारणा पर अधिक सबमिशन के रूप में कारक को बढ़ाएगा कि बाद के बॉट अधिक इंटरस्टिंग हो सकते हैं।

अंततः सूत्र है:

दूरी_पर_टर्न = शुरू_नेगी / ((रेस_डिस्टेंस + होर्ड_बर्स्ट_फैक्टर) * (1.0 + (number_of_bots - number_of_bots_at_submission) # 0.1)

{
    "Suboptimal": function(dist, energy, bots, storage) {
        if ( dist == 0)
        {
          storage.energyConsumptionRate = energy / ((100 + 10) * ( 1.0 + (bots.length - 26) * 0.1 ));
        }
        
        return storage.energyConsumptionRate;
    },
}

Answer 9

रॉबिन हुड

{
    "Robin Hood": function(dist, energy, bots, storage) {
        if (!dist)
            storage.move = [
                [100, 1],
                [200, Math.sqrt(192 / 49) - 0.00695],
                [10000 / 49, (100 / 49)]
            ].sort((a, b) => Math.abs(a[0] - energy) - Math.abs(b[0] - energy))[0][1];

        return storage.move;
    }
}

यह बॉट एक दौड़ में तीन चीजों में से एक करेगा:

• एक इकाई को प्रति मोड़ पर ले जाएं: यह प्रत्येक खेल की पहली दौड़ में किया जाता है ताकि यह सुनिश्चित किया जा सके कि इसकी पूरी 200 ऊर्जा इसकी आवश्यकता है
• प्रति मोड़ दो इकाइयों की तुलना में थोड़ा धीमी गति से आगे बढ़ें: यह हर दूसरे मोड़ पर किया जाता है और इसे ...
• प्रति इकाई दो इकाइयों की तुलना में थोड़ी तेज़ी से आगे बढ़ें: इससे वर्तमान प्रतियोगियों की तुलना में एक मोड़ तेजी से समाप्त होता है, और बस पिछले विजेताओं में से कुछ को ही रेखांकित करता है (हालांकि रेट कंट्रोल पोस्टिंग के सौवें बिंदु से आगे है)

Answer 10

एकत्र करनेवाला

{
    "Collector": function(dist, energy, bots, storage) {
        if (!dist) {
            if ("turns" in storage) {
                storage.avg = ((storage.avg * Math.max(storage.races++, 0)) + storage.turns) / Math.max(storage.races, 1);
            } else {
                storage.avg = 100;
                storage.races = -1;
            }
            
            storage.turns = 0;
            
            storage.move = (energy >= 10000 / (storage.avg | 0)) ? (100 / (storage.avg | 0)) : 0.5;
        }
        
        storage.turns++;
        
        return storage.move;
    }
}

कलेक्टर 0.5 यूनिट / टर्न की दर से गति करने में चूक जाएगा। यह ऊर्जा इकट्ठा करने के लिए इष्टतम है। यदि यह एक दौड़ की शुरुआत में भविष्यवाणी करता है कि यह औसत ऊर्जा के साथ टाई या हरा सकता है, तो वह ऐसा करने की कोशिश करेगा।

वर्तमान में दर नियंत्रण खो देता है, लेकिन नई रणनीतियों के लिए बेहतर अनुकूलन करने में सक्षम हो सकता है।

Answer 11

लालची / लालची

{
    "Greedy": function(dist, energy, bots, storage) {
        return energy > 100 ? 2 : 1;
    },
    "Greedier": function(dist, energy, bots, storage) {
        return dist + energy > 100 ? 2 : 1;
    },
}

लालची 2 इकाइयों को स्थानांतरित करेगा / अगर यह 100 से अधिक ऊर्जा पर है तो 1 यूनिट / मोड़ होगा। Greedier 2 इकाइयों को स्थानांतरित करेगा / यदि यह सोचता है कि यह संभवतः प्रत्येक छोर तक पर्याप्त ऊर्जा होगी अन्यथा 1 यूनिट / मोड़। ये सबसे सरल तरीके थे जो मैं किसी भी बोनस ऊर्जा का उपयोग करने के बारे में सोच सकता था जो बॉट के पास हो सकता है।

Answer 12

परिकलित स्प्रिंटर

परिकलित स्प्रिंटर अपने वर्तमान ईंधन के बचे होने के साथ ही पूरी गोद को चलाने की कोशिश करता है। भविष्य की दौड़ की योजना के लिए पर्याप्त स्मार्ट नहीं है, बस रन के लिए यहां आने के लिए खुश है।

{
    "Calculated Sprinter": function(dist, energy, bots, storage){
        var remaining = 100-dist;
        var energyLeftPerUnit = energy/remaining;
        return Math.sqrt(energyLeftPerUnit)
    }
}

Answer 13

(नया) तेजी

{
    "Accelerate": function(dist, energy, bots, storage) {
        return dist * 0.21 + 0.001;
    },
}

शांत हो जाओ, मैं बहुत ही सरल बॉट्स के साथ प्रयोग कर रहा हूं।

यह बॉट समझने में बहुत आसान है। यह शुरू में 0.001 की गति से चलता है और चतुष्कोणीय रूप से गति करता है।

Answer 14

मुझे रैंडमनेस पसंद है

{
    "I love Randomness": function(dist, energy, bots, storage) {
        storage.rand = Math.abs(dist ^ energy ^ storage.rand) + 1;
        return Math.abs(dist ^ energy ^ storage.rand) + 1;
    }
}

Answer 15

आश्चर्य / समय

"Timing": function(dist, energy, bots, storage) {
  storage.turns = storage.turns || 0;
  storage.games = storage.games || 0;
  storage.turns++;
  if(dist == 0) {
      storage.games++;
      estimated_game_length = Math.ceil( storage.turns / storage.games)+2;
      desired_speed = 100 / estimated_game_length;
      max_speed = Math.sqrt( energy / estimated_game_length);
      storage.speed = Math.min(desired_speed, max_speed);       
  }
  if(storage.games < 3)
      return storage.games;
  return storage.speed;
},
"Surprise": function(dist, energy, bots, storage) {
  storage.turns = storage.turns || 0;
  storage.games = storage.games || 0;
  storage.turns++;
  if(dist == 0) {
      storage.games++;
      estimated_game_length = Math.ceil( storage.turns / storage.games);
      desired_speed = 100 / (estimated_game_length - 3);
      max_speed = Math.sqrt( energy / estimated_game_length);
    if(desired_speed <= max_speed) {
      storage.speed = desired_speed;
    }
    else {
      storage.speed = Math.min(2, max_speed);
    }       
  }
  if(storage.games < 3)
       return storage.games;
  return storage.speed;
}

आम तौर पर लंबे समय तक चलने वाले गेम के आधार पर एक निश्चित गति की गणना करें। टाइमिंग तब निशान से टकराने की कोशिश करता है, जबकि सरप्राइज उसे हरा देने की कोशिश करता है।

इन दोनों के साथ परीक्षण चलाने के दौरान, यह स्पष्ट हो गया कि हमें संभवतः इस कोठ में मिलीभगत के बारे में नियमों की आवश्यकता है, हालांकि न्यूनतम बातचीत कर रहे हैं। आश्चर्य की बात यह है कि दौड़ की लंबाई कम करने के लिए अपने स्वयं के स्कोर का त्याग करके टिमिंग बहुत बेहतर कर सकता है, और इसे केवल निश्चित अंतराल पर ऐसा करने से और भी अधिक मदद कर सकता है जिसके बारे में टाइमिंग को पता है।

मैं अब इन शीनिगन्स को नहीं खींच रहा हूं क्योंकि मुझे लगता है कि वे आत्मा में नहीं हैं।

Answer 16

भांड

{
    "Mimic": function(dist, energy, bots, storage) {
        if (!dist) {
            storage.last = bots;
            storage.rand = energy ** 3;
            
            return energy / (100 - dist);
        }
        
        storage.rand = Math.abs(dist ^ dist ** 2 ^ energy ^ energy ** 3 ^ energy ** 5 ^ bots.reduce((s, b) => s + b, 0) ^ storage.rand * (2 ** 31)) / (2 ** 31);
        
        var result = bots.map((b, i) => b - storage.last[i])[storage.rand * bots.length | 0]; // Fix RNG
        
        storage.last = bots;
        
        return Math.max(Math.min(result, Math.sqrt(energy / ((100 - dist) / 4))), Math.sqrt(energy / ((100 - dist))));
    }
}

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

Answer 17

तेज और स्थिर नहीं

{
    "Fast and not steady": function() {
        return 99999999;
    }
}

Answer 18

धीमे से तेज़

{
    "Faster than Slow": function() {
        return 2;
    }
}

अगर आपको लगता है कि यह एक खराब बॉट है, तो नहीं।

Faster than Slow 48.951

Answer 19

पूरा का पूरा

संपूर्ण अंशों को पसंद नहीं करता है और हमेशा एक दूरी तय करेगा जो पूर्णांक है।

    "Whole": function(dist, energy, bots, storage) {
        if (dist == 0) {
            if (energy < 110) {
                storage.lambda = function(distance) {return 100 - distance - 1;}
                storage.step = 1
            }
            else {
                storage.lambda = function(distance) {return 200 - distance - 2;}
                storage.step = 2
            }
        }
        let expEnergyPast = storage.lambda(dist);
        if (expEnergyPast + (storage.step + 1) ** 2 <= energy) {
            return storage.step + 1;
        }
        return storage.step;
    }

```

Answer 20

उनचालीस

फोर-नाइन ने विनर और विनर 2 पर एक नज़र डाली और मान्यता दी कि जीत के लिए 49 टर्न जीतना 48 टर्न से बेहतर है। लेकिन चौथा-नौ आपके नियमों के अनुसार जीतना चाहता है। इसलिए चौदह-नाइन कई दौड़ जीतने के लिए अपनी औसत दूरी का त्याग नहीं करते हैं। लेकिन यह जीतने के लिए 49 से अधिक मोड़ कभी नहीं जाएगा।

    "fourty-nine": function(dist, energy, bots, storage) {
        if (dist == 0) {
            if (energy < 110) {
                storage.step = 1
            }
            else if(energy < 10000.0/49){
                storage.step = 2
            }
            else {
                storage.step = 100.0/49
            }
        }
        return storage.step;
    },

Answer 21

भविष्यवक्ता

{
    "Predictor": function(dist, energy, bots, storage) {
        if (!dist)
            if (energy == 100)
                storage.move = 1;
            else
                storage.move = (energy >= 10000 / (50 - bots.length * 0.25 | 0)) ? (100 / (50 - bots.length * 0.25 | 0)) : 1.3;

        return storage.move;
    }
}

भविष्यवक्ता मानता है कि जितने अधिक बॉट जोड़े जाते हैं, उतनी ही तेजी से जीतने के लिए जाने की आवश्यकता होती है। यह समय के साथ ऊर्जा एकत्र करता है, फिर बॉक्स में कलेक्टर या जैक के समान एक तरह से फिनिश लाइन की ओर जाता है।

Answer 22

DECISION3M8

UWUTM8 पर सुधार जो अलग तरह का काम करता है

यह अनुमान लगाने की कोशिश करता है कि कब कोई गतिमान है और अधिक अंक प्राप्त करने के लिए अधिक ऊर्जा का उपयोग करने की कोशिश करता है

"DECISION3M8": function(dist, energy, bots, storage) {
    const checkpointPer = 5;
    if (storage.turn == undefined) {
        storage.turn = 0;
    } else {
        storage.turn = storage.turn + 1;
    }
    
    if (dist === 0) {
        if (storage.round == undefined) {
            storage.round = 0;
        }
        storage.round = storage.round + 1;
        storage.turn = 0;
        storage.maxAtPreviouscheckpoint = 0;
        storage.predictedTurnsLeft = 100;
        storage.travelSpeed = Math.sqrt(energy / 50);
        
        if (energy == 100) {
            return 1;
        }
    } else if (storage.turn % checkpointPer == 0) {
        let maxAtCurrentTurn = Math.max( ...bots );
        let speederCheck = maxAtCurrentTurn / (storage.turn / checkpointPer) - storage.maxAtPreviouscheckpoint / ((storage.turn / checkpointPer) - 1);
        let speedOfSpeederPerTurn = maxAtCurrentTurn / storage.turn;
        if ((Math.abs(speederCheck) < 0.01) && (maxAtCurrentTurn > dist)) {
            //console.log(speederCheck);
            storage.predictedTurnsLeft = Math.ceil(100 / speedOfSpeederPerTurn) - (100 - storage.turn);
            storage.travelSpeed = Math.sqrt(energy / (storage.turn - speedOfSpeederPerTurn));
            //console.log(storage.predictedTurnsLeft);
        }
    }
    
    return storage.travelSpeed;
}

Answer 23

विजेता

विजेता आपके नियमों की परवाह नहीं करता है। विजेता अपने नियमों से खेलता है।

विजेता जितने संभव हो उतने दौड़ में (= 100 की दूरी पर अंत) जीतने की कोशिश करता है।

"Winner": function(dist, energy, bots, storage) {
        if (dist == 0) {
            if (energy < 10000.0/49) {
                storage.step= 0.5;
            }
            else {
                storage.step = 100.0/49;
            }
        }
        return storage.step;
    },
"Winner2": function(dist, energy, bots, storage) {
        if (dist == 0) {
            if (energy < 10000.0/48) {
                storage.step= 0.5;
            }
            else {
                storage.step = 100.0/48;
            }
        }
        return storage.step;
    },

```

Answer 24

UWUTM8

बस कई बॉट्स की तरह मैं जितनी जल्दी हो सके उतनी तेजी से खत्म करने की कोशिश करता है जितना कि यह मच ऊर्जा का उपयोग कर सकता है। यह भी विशिष्ट निशान पर खत्म करने की कोशिश नहीं करता है, लेकिन 9 अंक तक पहुंचने की कोशिश करता है

"UWUTM8": function(dist, energy, bots, storage) {
    if (dist === 0) {
        if (storage.round == undefined) {
            storage.round = 0;
        }
        storage.round = storage.round + 1;
        if (storage.round % 2500 == 0 || storage.round == 250 || storage.round == 750) {
            storage.travelSpeed = Math.sqrt(energy / 90)
        } else {
            storage.travelSpeed = Math.sqrt(energy / 100)
        }
    }

    return storage.travelSpeed;
}