सिक्का टॉसिंग समय यात्री

Question

भविष्य में जब Time Travel (TT के रूप में संक्षिप्त) सामान्य होगा, सिक्का उछालना एक गंभीर मन-खेल बन जाएगा। भविष्य की तैयारी के लिए हम उन कार्यक्रमों के लिए एक प्रतियोगिता बनाते हैं जहां समय यात्रा वास्तव में प्रविष्टियों के दृष्टिकोण से हो रही होगी।

प्रतियोगिता एक गोल-रॉबिन शैली की पहाड़ी है जिसमें राजा जावा कक्षाओं के बीच के मैच में सिक्का उछालता है।

सिक्के को उछालने के नियम

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

विवरण

• राउंड में 1-आधारित अनुक्रमण (1 से 100 तक) होता है।
• राउंड से पहले xआपको उपलब्ध नीले और लाल लीवर की संख्या प्रदान की जाती है, सिक्का टॉस के परिणाम तक x(समावेशी) और आपके (अंतिम) x-1वें राउंड की मेमोरी तक ।
• नीले रंग के लीवर को गोल में खींचना xकिसी भी टीटी को रोक देता है, जिसके पास xया उससे पहले एक राउंड पर गंतव्य होता है (यदि वह उसी सटीक राउंड पर भी होता है तो टीटी को ब्लॉक कर देता है)।
• राउंड में लौटने का xमतलब है कि अगला राउंड राउंड होगा x।
• यदि दोनों खिलाड़ी किसी दौर के अंत में वापस लौटने का समय चुनते हैं तो वह पहले वाले गंतव्य पर वापस आ जाता है जो अवरुद्ध नहीं है। खिलाड़ी (ओं) को जो इस समय वापस करने की कोशिश की उनकी स्मृति रखेंगे।

तकनीकी जानकारी

• आपको प्रदान किए गए बॉट इंटरफ़ेस को लागू करने वाला एक जावा वर्ग लिखना चाहिए।
• अपने बॉट को प्रोजेक्ट में जोड़ें।
• Botफ़ाइल में अपने बॉट का एक उदाहरण जोड़ें Controller.java।
• आपकी कक्षा को कॉल के बीच जानकारी नहीं रखनी चाहिए । (ज्यादातर मामलों में केवल finalकार्यों के बाहर चर होने से यह आवश्यकता पूरी हो जाती है।)
• आप memoryअपने लौटे Actionऑब्जेक्ट के क्षेत्र में नियंत्रक को जानकारी दे सकते हैं । अगर कोई टीटी नहीं हुआ तो यह आपको अगली बारी में वापस दिया जाएगा। यदि कोई TT होता है, तो आपको पहले की संबंधित मेमोरी प्राप्त होगी।
• आप इतिहास स्ट्रिंग का स्कोर प्राप्त करने के लिए कक्षा की totalScore()विधि का उपयोग कर सकते हैं Game।

मसविदा बनाना

• हर मोड़ पर आपकी takeTurn(...)पद्धति को 5 तर्कों के साथ कहा जाता है:

  • अप्रयुक्त नीले लीवर की संख्या
  • अप्रयुक्त लाल लीवर की संख्या
  • सिक्का उछालने का इतिहास, एक तार जिसमें 1 और 0 शामिल हैं, जो पिछले राउंड में आपकी जीत और हार को चिह्नित करता है। पहला पात्र पहले सिक्के को उछालने से मेल खाता है। (पहले दौर में स्ट्रिंग की लंबाई होगी 1।)
  • एक स्ट्रिंग, पिछले दौर से आपकी संग्रहीत मेमोरी
  • इस दौर के 1-आधारित सूचकांक

• हर मोड़ पर आपकी विधि में एक Actionवस्तु होती है

  • moveआपकी कार्रवाई का वर्णन करने वाले क्षेत्र में पूर्णांक :

    • 0 बिना किसी कार्यवाही के
    • -1 एक नीले लीवर को खींचने के लिए और टीटी को इस दौर से गुजरना
    • एक सकारात्मक पूर्णांक x, वर्तमान दौर से बड़ा नहीं है, एक लाल लीवर को खींचने के लिए और वापस दौर में वापस आने की कोशिश करेंx
    • अमान्य पूर्णांकों को माना जाता है 0।

  • इस दौर से अपनी स्मृति युक्त एक स्ट्रिंग जिसे आप संरक्षित करना चाहते हैं। ध्यान दें कि मेमोरी को स्टोर करना चुनौती का महत्वपूर्ण हिस्सा नहीं है । आप स्ट्रिंग में कोई उपयोगी डेटा संग्रहीत किए बिना अच्छी प्रविष्टियां कर सकते हैं। पहले दौर में स्ट्रिंग एक खाली स्ट्रिंग होगी।

• आपकी विधि को एक मैच में औसतन 10 राउंड प्रति राउंड से अधिक समय नहीं लेना चाहिए।

• अयोग्यता में समय-सीमा के परिणामों को नियमित रूप से विफल करना।

स्कोरिंग

• एक मैच जीतने पर 2 अंक मिलते हैं और एक ड्रॉ दोनों खिलाड़ियों के लिए 1 अंक कमाता है। नुकसान कोई अंक नहीं कमाता है।
• एक बॉट का स्कोर उसके द्वारा एकत्र किए गए अंकों की कुल संख्या होगी।
• प्रतियोगियों की प्रत्येक जोड़ी के बीच खेले जाने वाले मैचों की संख्या प्रविष्टियों की संख्या और उनकी गति पर निर्भर करेगी।

दो सरल उदाहरण बॉट उत्तर के रूप में पोस्ट किए जाते हैं।

नियंत्रक और पहले युगल बॉट यहां उपलब्ध हैं ।

3 नवंबर तक जमा किए गए बॉट के साथ परीक्षा परिणाम।:

कुल स्कोर:

Oldschool: 3163
Random: 5871
RegretBot: 5269
Nostalgia: 8601
Little Ten: 8772
Analyzer: 17746
NoRegretsBot: 5833
Oracle: 15539
Deja Vu: 5491
Bad Loser: 13715

^{(कंट्रोलर कैट कैचर चैलेंज के कंट्रोलर पर आधारित है । @flawr के लिए धन्यवाद। यह इसे आधार के रूप में प्रदान करता है।)}

बोनस: एक समान अवधारणा पर आधारित एक अच्छी 6 मिनट की फिल्म ।

Comments

मुझे समझ नहीं आ रहा है कि इस नियम का क्या मतलब है। If you pull a blue lever (revert stopper) no TT is possible through that round anymore. TT's attempting to go through the round will have no effect."एक दौर से गुजरना" क्या है?

— feersum

@ फैर्सम यदि मैं सही ढंग से समझूं, तो मौजूदा दौर (और इस तरह पिछले सभी दौर) में नीले रंग के लीवर को स्थायी रूप से खींच दिया जाता है ताकि परिणाम समय यात्रा द्वारा संशोधित न हो सकें। अगर किसी ने पहले टीटी की कोशिश की थी जब आपने नीले लीवर को खींचा था, तो वे करने में असमर्थ होंगे।

— PhiNotPi

@ Faersum @PhiNotPi सही है, क्या यह संस्करण स्पष्ट है? If you pull a blue lever (revert stopper) no TT is possible to the round the lever was used or any earlier round anymore. TT's attempting to go to these rounds will have no effect.

— रैंडम

जब आप लाल लीवर को खींचते हैं, तो क्या आप उसी दौर का चयन कर सकते हैं, जिस समय आप उस दौर के लिए सिक्का टॉस को फिर से चालू करेंगे?

— TheNumberOne

@ TheNumberOne हाँ, यही रैंडम उदाहरण बॉट करता है।

— रैंडम

Answer 1

विश्लेषक

यह भविष्य के लिए सबसे अच्छी भविष्यवाणी करने के लिए अतीत का विश्लेषण करता है।

संपादित करें: नीला लीवर वाले समय से बचा जाता है। नीले लीवर का प्रभावी ढंग से उपयोग करता है। अधिक प्रभावी ढंग से लाल लीवर का उपयोग करता है। हैलोवीन के मौसम के लिए जोड़ा गया दुपट्टा।

संपादित करें: 1 त्रुटि से बंद।

संपादित करें: बेहतर computeWinningProbabilityकार्य। अब लाल लीवर और नीले लीवर का उपयोग अधिक आक्रामक तरीके से करता है।

//Boo!
package bots;

import main.Action;
import main.Game;

import java.util.*;
import java.util.stream.Collectors;

/**
 * Created 10/24/15
 *
 * @author TheNumberOne
 */
public class Analyzer implements Bot{

    @Override
    public String getName(){
        return "Analyzer";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history,
                           String memory, int roundNumber) {
        /*System.out.println(Game.totalScore(history) + " : " + history);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }*/
        int roundsLeft = 100 - roundNumber;
        int myScore = (Game.totalScore(history) + roundNumber) / 2; //My number of wins.
        int enemyScore = roundNumber - myScore;                     //Enemy's number of wins.
        Map<Integer, Double> bestRounds = new HashMap<>();
        int timeLimit = 0;

        Scanner scanner = new Scanner(memory);
        if (scanner.hasNext()){     //No memory, first turn.
            boolean triedTimeTravel = scanner.nextBoolean();
            if (triedTimeTravel){
                int time = scanner.nextInt();
                if (roundNumber > time) {     //Failed.
                    timeLimit = time;
                }
            }
            timeLimit = Math.max(timeLimit, scanner.nextInt());
            int size = scanner.nextInt();
            for (int i = 0; i < size; i++) {
                bestRounds.put(scanner.nextInt(), scanner.nextDouble());
            }
        } else {
            bestRounds.put(1, 0.5);
        }

        clean(bestRounds, roundNumber, timeLimit);
        double winningProb = computeWinningProbability(myScore, enemyScore, roundsLeft);
        String newMemory = computeMemory(bestRounds, roundNumber, winningProb);

        if (winningProb >= new double[]{1.5, .75, .7, .65, .6, .55}[blue_levers]){ //Ensure success ... slowly.
            return getAction(-1, newMemory, timeLimit, roundNumber);
        }

        int bestRound = bestRound(bestRounds);
        double bestRoundProb = bestRounds.get(bestRound);

        if ((winningProb <= bestRoundProb - .05 || winningProb < .5 && bestRoundProb > winningProb) && red_levers > 0){
            return getAction(bestRound, newMemory, timeLimit, roundNumber);  //Let's find the best past.
        } else {
            return getAction(0, newMemory, timeLimit, roundNumber); //Let's wait it out :)
        }
    }

    //Should be combined with computeMemory.
    private static Action getAction(int actionNum, String newMemory, int timeLimit, int roundNumber){
        if (actionNum == -1){
            timeLimit = Math.max(timeLimit, roundNumber);
            newMemory = "false " + timeLimit + " " + newMemory;
            return new Action(actionNum, newMemory);
        }
        if (actionNum == 0){
            return new Action(actionNum, "false " + timeLimit + " " + newMemory);
        }
        if (actionNum > 0){
            return new Action(actionNum, "true " + actionNum + " " + timeLimit + " " + newMemory);
        }
        return null;
    }

    private static int bestRound(Map<Integer, Double> bestRounds) {
        int best = 0;           //If no previous rounds ... just go forward a round.
        double bestScore = -1;
        for (Map.Entry<Integer, Double> entry : bestRounds.entrySet()){
            if (entry.getValue() > bestScore){
                best = entry.getKey();
                bestScore = entry.getValue();
            }
        }
        return best;
    }

    private static String computeMemory(Map<Integer, Double> map, int roundNumber, double winningProb) {
        StringBuilder builder = new StringBuilder();
        builder.append(map.size() + 1).append(" ");
        for (Map.Entry<Integer, Double> entry : map.entrySet()){
            builder.append(entry.getKey()).append(" ").append(entry.getValue()).append(" ");
        }
        builder.append(roundNumber + 1).append(" ").append(winningProb);
        return builder.toString();
    }

    private static void clean(Map<Integer, Double> data, int round, int timeLimit) {
        data
                .entrySet()
                .stream()
                .filter(entry -> entry.getKey() > round || entry.getKey() <= timeLimit)
                .map(Map.Entry::getKey)
                .collect(Collectors.toList()).forEach(data::remove);
    }

    private static double computeWinningProbability(int myScore, int enemyScore, int roundsLeft){ //Too complex for IntelliJ
        int height = myScore - enemyScore;
        double total = 0.0;
        for (int i = Math.max(height - roundsLeft, 2); i <= height + roundsLeft; i += 2){
            total += prob(roundsLeft, height, i);
        }
        total += prob(roundsLeft, height, 0) / 2;
        return total;
    }

    private static double prob(int roundsLeft, int height, int i){
        double prob = 1;
        int up = i - height + (roundsLeft - Math.abs(i - height))/2;
        int down = roundsLeft - up;
        int r = roundsLeft;
        int p = roundsLeft;
        while (up > 1 || down > 1 || r > 1 || p > 0){  //Weird algorithm to avoid loss of precision.
            //Computes roundsLeft!/(2**roundsLeft*up!*down!)

            if ((prob >= 1.0 || r <= 1) && (up > 1 || down > 1 || p > 1)){
                if (p > 0){
                    p--;
                    prob /= 2;
                    continue;
                } else if (up > 1){
                    prob /= up--;
                    continue;
                } else if (down > 1){
                    prob /= down--;
                    continue;
                } else {
                    break;
                }
            }
            if (r > 1) {
                prob *= r--;
                continue;
            }
            break;
        }
        return prob;
    }

}

स्कोर (2 नवंबर से):

Total Scores:
Oldschool: 3096
Random: 5756
RegretBot: 5362
Nostalgia: 8843
Little Ten: 8929
Analyzer: 17764
NoRegretsBot: 5621
Oracle: 15528
Deja Vu: 5281
Bad Loser: 13820

Comments

प्रभावशाली! आपका बॉट प्रभावी रूप से ब्लॉक करता है और अनुकूलतम समय पर लौटता है। यह एक बॉट बनाने के लिए बहुत कठिन होने वाला है जो इस शीर्ष को बना सकता है।

— टीएनटी

मुझे यकीन नहीं है कि यह बॉट स्टॉपेबल है, विशेष रूप से इस बॉट के साथ गड़बड़ करने और किसी अन्य बॉट को बढ़ावा देने के लिए डिज़ाइन की गई प्रविष्टियों का एक गुच्छा का उपयोग किए बिना।

— मेगो

Answer 2

विषाद

package bots;

import main.Action;
import main.Game;

public class Nostalgia implements Bot {

    @Override
    public String getName() {
        return "Nostalgia";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history,
            String memory, int roundNumber) {

        int current_score = Game.totalScore(history);

        // wait until the end to use blue levers
        if (current_score > 0 && blue_levers >= (100 - roundNumber)) {
            return new Action(-1, memory);
        }

        // become increasingly likely to go back as the gap between the good old days
        // and the horrible present increases
        if (current_score < 0 && red_levers > 0) {
            //identify the best time to travel back to
            int best_score = -100;
            int good_old_days = 1;
            int past_score = 0;

            int unreachable_past = 0;
            if(memory != "") {
              unreachable_past = Integer.parseInt(memory, 10);
            }

            for(int i = unreachable_past; i<roundNumber ; i++) {
              if(history.charAt(i) == '1') {
                past_score += 1;
                if(past_score > best_score) {
                  best_score = past_score;
                  good_old_days = i + 1;
                }
              }
              else {
                past_score -= 1;
              }
            }
            if(roundNumber >= 95 || Math.random() < (best_score - current_score) / 100.0) {
              return new Action(good_old_days, Integer.toString(good_old_days));
            }
        }

        // if neither action was needed do nothing
        return new Action(0, memory);
    }
}

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

संपादित करें: मैंने इस नियम को याद किया:

यदि आप एक नीला लीवर (रिवर्ट स्टॉपर) खींचते हैं तो उस दौर में कोई टीटी संभव नहीं है

ऐसा लगता है कि स्मृति का उपयोग करने के लिए एक अच्छा कारण है - यदि आप टीटी को दिए गए दौर की कोशिश करना याद करते हैं, तो आप असफल हो सकते हैं, इसलिए आपको उस दौर में फिर से टीटी की कोशिश नहीं करनी चाहिए। इससे बचने की कोशिश करने के लिए मेरे बॉट को संपादित किया।

Answer 3

आकाशवाणी

मैंने बेशर्मी से एनालाइज़र (मेमोरी को पार्स करने के लिए) से कुछ कोड कॉपी किए। यह सबमिशन एक ब्लू लीवर को जल्दी खींचने की कोशिश करता है और फिर धीरे-धीरे उसकी बढ़त बनाता है। मुझे लगता है कि इस बॉट का प्रदर्शन बदसूरत कोड के लिए बनाता है :)

package bots;

import java.util.*;
import java.util.Map.Entry;
import main.*;

public class Oracle implements Bot {

    @Override
    public String getName() {
        return "Oracle";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history, String memory, int roundNumber) {
        int roundsLeft = 100 - roundNumber;
        Map<Integer, Integer> rounds = new HashMap<>();
        int myScore = (Game.totalScore(history) + roundNumber) / 2;
        int difference = myScore*2 - roundNumber;
        int highestBlockedRound = -1;
        int bestScore = 0;
        boolean hasUsedBlueLever = false;

        Scanner scanner = new Scanner(memory);
        if (scanner.hasNext()) {
            //timeTravel toRound highestBlockedRound hasUsedBlueLever bestScore rounds round1 percent1 round2 percent2 round3 percent3...
            boolean triedTravel = scanner.nextBoolean();
            int time = scanner.nextInt();
            if (triedTravel){
                if (roundNumber > time) {
                    highestBlockedRound = time;
                }
            }
            highestBlockedRound = Math.max(highestBlockedRound, scanner.nextInt());

            hasUsedBlueLever = scanner.nextBoolean();
            bestScore = scanner.nextInt();

            int size = scanner.nextInt();
            for (int i = 0; i < size && i < roundNumber; i++) {
                int number = scanner.nextInt();
                int diff = scanner.nextInt();
                if (number < roundNumber) {
                    rounds.put(number, diff);
                }
            }
        }
        rounds.put(roundNumber, difference);
        final int blockedRound = highestBlockedRound;

        int roundToRevert = 0;
        if (rounds.size() > 2) {
            Optional<Entry<Integer, Integer>> bestRound = rounds.entrySet()
                    .stream()
                    .filter(x -> x.getKey() >= blockedRound && x.getKey() <= roundNumber)
                    .sorted(Comparator
                        .comparingInt((Entry<Integer, Integer> x) -> x.getValue()*-1)
                        .thenComparingInt(x -> x.getKey()))
                    .findFirst();
            if (bestRound.isPresent()) {
                roundToRevert = bestRound.get().getKey();
            }
        }

        if (roundsLeft + Game.totalScore(history) <= 0 && red_levers > 0) {
            roundToRevert = highestBlockedRound+1;
        } else if (blue_levers > 0 && roundToRevert == roundNumber && ((hasUsedBlueLever && difference >= bestScore*1.5) || (!hasUsedBlueLever && difference > 1))) {
            roundToRevert = -1;
            hasUsedBlueLever = true;
            bestScore = difference;
            highestBlockedRound = roundNumber;
        } else if (red_levers > 0 && roundToRevert > 0 && rounds.get(roundToRevert) > difference+2) {
            roundToRevert += 1;
        } else {
            roundToRevert = 0;
        }

        StringBuilder sb = new StringBuilder();
        sb.append(roundToRevert > 0).append(' ');
        sb.append(roundToRevert).append(' ');
        sb.append(highestBlockedRound).append(' ');
        sb.append(hasUsedBlueLever).append(' ');
        sb.append(bestScore).append(' ');
        sb.append(rounds.size()).append(' ');
        rounds.entrySet().stream().forEach((entry) -> {
            sb.append(entry.getKey()).append(' ').append(entry.getValue()).append(' ');
        });
        String mem = sb.toString().trim();
        scanner.close();
        return new Action(roundToRevert, mem);
    }
}

Comments

बहुत बढ़िया! मुझे पता था कि मैं अपने लाल लीवर के साथ पर्याप्त आक्रामक नहीं था। अब विश्लेषक को सुधारने के लिए। ;)

— द न्यूम्बरऑन

Answer 4

RegretBot

हमारे जीवन के मैच के अंत में , हम अपनी पिछली विफलताओं पर पछतावा करते हैं, और उन्हें वापस जाने और उन्हें ठीक करने का प्रयास करते हैं।

package bots;

import main.Action;
import main.Game;

public final class RegretBot implements Bot {

    @Override
    public String getName() {
        return "RegretBot";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history, String memory, int roundNumber) {
        int actionNum = 0;
        if(roundNumber == 100) {
            // if it's the end of the game and we're losing, go back
            //  in time to the first loss, in hopes of doing better
            if(Game.totalScore(history)<=0 && red_levers > 0) {
                actionNum = history.indexOf("0")+1;
            }
            // if we're winning at the end, pull a blue lever if we can,
            //  to prevent our opponent from undoing our victory
            else if(blue_levers > 0) {
                actionNum = -1;
            }
        }
        // we don't need no stinkin' memory!
        return new Action(actionNum, null);
    }

}

Answer 5

छोटा दस

लिटिल टेन 10 की संख्या से 10 का गुणक है, और 10 के गुणक में होने वाले राउंड में वापस जाकर 10 से गुणा और विभाजित करता है।

package bots;

import main.Action;
import main.Game;

public class LittleTen implements Bot {

    @Override
    public String getName() {
        return "Little Ten";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history, String memory, int roundNumber) {
        int score = Game.totalScore(history);
        char c = history.charAt(history.length() - 1);
        if (memory.isEmpty())
            memory = "1";

        if (roundNumber == 100) {
            if (score >= 0)
                // We're tied or ahead by the end of the match. Prevent time
                // travel if we can; otherwise whatever happens happens.
                return new Action(blue_levers > 0 ? -1 : 0, memory);
            else {
                // Travel to earlier rounds the farther behind we are if we can
                // (of course using 10 as a reference)
                if (red_levers > 0) {
                    int i = Integer.parseInt(memory);
                    int round = score <= -10 ? i : 100 - ((100 - i) / (11 + (score <= -10 ? -10 : score)));
                    return new Action(round, memory);
                }
            }
        }
        else if (score >= 7 + roundNumber / 20 && blue_levers > 0) {
            // We're ahead; we don't want to lose our lead, especially if the
            // match is close to ending. But we don't want to use up our blue
            // levers too quickly.
            int choice = (int) (Math.random() * 100),
                bound = (roundNumber / 10 + 1) * 5 - ((6 - blue_levers) * 5 - 2);
            if (choice < bound) {
                memory = String.valueOf(roundNumber);
                return new Action(-1, memory);
            }
        }
        else if (score <= -3) {
            // Possibly use a red lever if we're falling too far behind
            if (red_levers > 0) {
                int choice = (int) (Math.random() * 100),
                    bound = score <= -11 ? 90 : 10 * (-3 - score + 1);
                if (choice < bound) {
                    // Check the first round that is the lower multiple of ten
                    // and decide if we've been successful up to that point; if
                    // so, travel back to that round, otherwise go back 10 more
                    int round = roundNumber / 10 * 10;
                    if (round < 10)
                        return new Action(1, memory);
                    String seq = history.substring(0, round-1);
                    int minRound = Integer.parseInt(memory);
                    while (Game.totalScore(seq) <= 0 && round > 10 && round > minRound) {
                        round -= 10;
                        seq = history.substring(0, round-1);
                    }
                    if (round == 0)
                        round = 1;
                    return new Action(round, memory);
                }
            }
        }
        return new Action(0, memory);
    }
}

संपादित करें: यांत्रिकी को अब थोड़ा बदल दिया है कि जब एक नीले लीवर को खींचा जाता है तो उसका स्पष्टीकरण स्पष्ट होता है। साथ ही थोड़ा रिबैलेंस भी किया।

Answer 6

बिना सोचे समझे

रैंडम की रणनीति निम्नलिखित है:

• यदि लीड में नीली लीवर है तो 10% मौका के साथ ब्लॉक करें
• यात्रा वापस 10% मौका के साथ एक बारी (पिछले दौर पुनः) यदि स्कोर में पीछे छोड़ दिया है और लाल लीवर है

package bots;

import main.Action;
import main.Game;

public class RandomBot implements Bot {

    @Override
    public String getName() {
        return "Random";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history,
            String memory, int roundNumber) {

        // if in the lead and has blocks left, blocks with a 10% chance
        if (Game.totalScore(history) > 0 && blue_levers > 0
                && Math.random() > 0.9) {
            return new Action(-1, null);
        }

        // if behind and has travels left, travel back the current step to
        // replay it with a 10% chance
        if (Game.totalScore(history) < 0 && red_levers > 0
                && Math.random() > 0.9) {
            return new Action(roundNumber, null);
        }

        // if neither action were needed do nothing
        return new Action(0, null);
    }
}

Answer 7

NoRegretsBot

package bots;

import main.Action;
import main.Game;

public final class NoRegretsBot implements Bot {

    @Override
    public String getName() {
        return "NoRegretsBot";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history, String memory, int roundNumber) {
        // every 20 turns, pull a blue lever to lock in the past
        // hopefully this will thwart some of those pesky time-travelers
        return new Action(roundNumber%20==0?-1:0, null);
    }

}

Answer 8

बुरा हारे

यह बॉट बिना मेमोरी का उपयोग करता है और आश्चर्यजनक रूप से अच्छा है (लेकिन यह एनालाइज़र या ओरेकल को हरा नहीं करता है)।

package main;

import bots.Bot;

/**
 * Created 11/2/15
 *
 * @author TheNumberOne
 */
public class BadLoser implements Bot{
    @Override
    public String getName() {
        return "Bad Loser";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history, String memory, int roundNumber) {
        if (history.contains("00") && red_levers > 0){       //Subtract a zero for better performance against
            return new Action(history.indexOf("00") + 1, "");// Analyzer and Nostalgia, and worse performance 
                                                             // against everything else.
        }
        int wins = 0;
        for (char c : history.toCharArray()){
            wins += c - '0';
        }
        if (wins >= new int[]{101, 51, 40, 30, 20, 10}[blue_levers]){
            return new Action(-1, "");
        }
        return new Action(0, "");
    }
}

Answer 9

पुराना स्कूल

यह बॉट कभी भी कोई कार्रवाई नहीं करता है क्योंकि ऑलडस्कूल समय यात्रा में विश्वास नहीं करता है।

package bots;

import main.Action;

public class OldschoolBot implements Bot {

    @Override
    public String getName() {
        return "Oldschool";
    }

    @Override
    public Action takeTurn(int blue_levers, int red_levers, String history,
            String memory, int roundNumber) {       
        // never tries to block or travel at all
        return new Action(0, null);
    }
}

Answer 10

देजा वु बॉट

यह बॉट उस क्षेत्र में रेड पुल से बचने के लिए नीले रंग को खींचने पर ट्रैक करने की कोशिश करता है। जब स्कोर में काफी पिछड़ जाएगा तभी लाल लीवर को खींचेगा।

package bots;

import main.*;

public class Dejavu implements Bot
{
    @Override
    public String getName()
    {
        return "Deja Vu";
    }

@Override
public Action takeTurn(int blue_levers, int red_levers, String history,
                       String memory, int roundNumber) {

    if(roundNumber == 1)
    {
        memory = "-1";
    }
    int[] blevers = getBlueLevers(memory);
    char[] hist = history.toCharArray();
    int ms = 0;
    int ts = 0;
    int rl = -1;
    boolean bl = false;
    boolean url = false;

    for(int i = 0; i < hist.length; i++)
    {
        switch(hist[i])
        {
            case '1':
            ms++;
            break;
            case '0':
            ts++;
            break;
        }
    }

    if(ts - ms >= 10)
    {   
        for(rl = hist.length - 1; ts - ms <= 5 && rl >= 0; rl--)
        {
            switch(hist[rl])
            {
                case '1':
                ms--;
                break;
                case '0':
                ts--;
                break;
            }
        }
        url = true;
    }

    if(ms - ts >= 7)
    {
        bl = true;
        url = false;
        memory += "," + roundNumber;
    }

    for(int i = 0; i < blevers.length; i++)
    {
        if(rl <= blevers[i])
        {
            rl = blevers[i] + 1;
        }
    }

    if(url)
    {
        return new Action(rl, memory);
    }
    else if(bl)
    {
        return new Action(-1, memory);
    }
    else
    {
        return new Action(0, memory);
    }              
}

private int[] getBlueLevers(String s)
{
    String[] b = s.split(",");

    int[] bl = new int[b.length];
    for(int i = 0; i < b.length; i++)
    {
        bl[i] = Integer.parseInt(b[i]);
    }

    return bl;
}

}