মুদ্রা টসিং সময় ভ্রমণকারীদের

19

ভবিষ্যতে যখন টাইম ট্র্যাভেল (টিটি হিসাবে সংক্ষিপ্ত) সাধারণ হবে, মুদ্রা টসিং একটি গুরুতর মনের খেলাধুলায় পরিণত হবে। ভবিষ্যতের জন্য প্রস্তুত করার জন্য আমরা এমন প্রোগ্রামগুলির জন্য একটি প্রতিযোগিতা তৈরি করি যেখানে সময়গুলি ভ্রমণে প্রবেশের দৃষ্টিকোণ থেকে সত্যই ঘটে থাকে।

প্রতিযোগিতাটি একটি রাউন্ড-রবিন স্টাইলের কিং যা জাভা ক্লাসগুলির মধ্যে কয়েন টসিং ম্যাচ নিয়ে গঠিত Hill

মুদ্রা টসিং ম্যাচের নিয়ম

  • দুটি খেলোয়াড় এবং 100 রাউন্ড রয়েছে।
  • প্রতিটি রাউন্ডে একটি মুদ্রা ছোঁড়া হয় এবং ফলাফলের ভিত্তিতে খেলোয়াড়দের মধ্যে 1 পয়েন্ট স্কোর হয়। প্রতিটি খেলোয়াড়ের পয়েন্ট করার জন্য 50% সুযোগ রয়েছে।
  • টসিংয়ের পরে উভয় খেলোয়াড়ের লিভার টেনে সময় নিয়ন্ত্রণের সুযোগ রয়েছে।
  • যদি আপনি একটি নীল লিভারটি টানেন (স্টপ রিভার্ট করুন) লিভারটি ব্যবহৃত হয়েছিল বা তার আগের কোনও রাউন্ডে কোনও টিটি সম্ভব নয়। টিটি-র এই রাউন্ডগুলিতে যাওয়ার চেষ্টা করার কোনও প্রভাব নেই।
  • যদি আপনি একটি লাল লিভারটি (রিভার্টার) টানেন তবে আপনি সময়টিকে আগের রাউন্ডে ফিরিয়ে আনার চেষ্টা করবেন। যদি সফল হয় তবে প্রতিপক্ষের স্মৃতিটি নির্বাচিত রাউন্ডের আগে তার স্মৃতিতে ফিরে যাবে এবং নির্বাচিত রাউন্ড থেকে শুরু হওয়া কয়েন টসের ফলাফলও মুছে ফেলা হবে । টিটি সম্পর্কে আপনার প্রতিপক্ষের পক্ষে কেবলমাত্র সম্ভাব্য চিহ্ন এটির অব্যবহৃত লিভারের সংখ্যা হবে যা আবার ফিরে যাবে না।
  • ম্যাচের শুরুতে প্রতিটি খেলোয়াড়ের 5 টি নীল এবং 20 টি লাল অব্যবহৃত লিভার থাকে। এই লিভারগুলি টিটির দ্বারা প্রভাবিত হয় না।
  • 100 তম রাউন্ডের শেষে কোনও টিটি না ঘটলে গেমটি শেষ হয় এবং উচ্চতর স্কোর প্লেয়ার জিততে পারে।

বিস্তারিত

  • রাউন্ডের 1-ভিত্তিক সূচক রয়েছে (ফর্ম 1 থেকে 100)।
  • রাউন্ডের আগে xআপনাকে উপলভ্য নীল এবং লাল লিভারের সংখ্যা সরবরাহ করা হবে, মুদ্রাটি টস ফলাফল অবধি x(সমেত) এবং আপনার (সর্বশেষ) x-1তম রাউন্ডের স্মৃতিতে ফলাফল দেয় ।
  • রাউন্ডে একটি নীল লিভারটি xটানলে কোনও টিটি-র গোল হয়ে যায় xবা এর আগেও গন্তব্য থাকে (এটি একই টিউনটি একই রাউন্ডে ঘটলে এটি কোনও টিটি ব্লক করে)।
  • রাউন্ডে ফিরে যাওয়া xমানে পরবর্তী রাউন্ডটি গোল হবে x।
  • যদি উভয় খেলোয়াড়ই কোনও রাউন্ডের শেষে ফিরে যেতে পছন্দ করে তবে সময়টি পূর্বের গন্তব্যটিতে ফিরে যায় যা অবরুদ্ধ নয়। যে প্লেয়ার (গুলি) এই সময়টিতে ফিরে যাওয়ার চেষ্টা করেছেন তারা তাদের স্মৃতি রক্ষা করবেন।

প্রযুক্তিগত বিবরণ

  • প্রদত্ত বট ইন্টারফেস প্রয়োগ করে আপনার জাভা ক্লাসটি লিখতে হবে।
  • প্রকল্পে আপনার বট যোগ করুন।
  • Botফাইলটিতে থাকা আপনার বটের একটি উদাহরণ যুক্ত করুন Controller.java।
  • আপনার শ্রেণীর কলগুলির মধ্যে তথ্য রাখা উচিত নয় । (বেশিরভাগ ক্ষেত্রে finalফাংশনের বাইরে কেবলমাত্র ভেরিয়েবলগুলি এই প্রয়োজনীয়তাটি পূরণ করে))
  • আপনি memoryফিরে আসা Actionঅবজেক্টের ক্ষেত্রে নিয়ন্ত্রণকারীকে তথ্য দিতে পারেন । কোনও টিটি না ঘটলে পরের বারে এটি আপনাকে ফিরিয়ে দেওয়া হবে। যদি কোনও টিটি ঘটে তবে আপনি আগের মতোই স্মৃতি পাবেন।
  • ইতিহাসের স্ট্রিংয়ের স্কোর পেতে আপনি ক্লাসের 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

(কন্ট্রোলারটি বিড়াল ক্যাচার চ্যালেঞ্জের নিয়ন্ত্রকের উপর ভিত্তি করে তৈরি হয়েছে law

বোনাস: অনুরূপ ধারণার উপর ভিত্তি করে একটি দুর্দান্ত 6 মিনিটের চলচ্চিত্র ।

king-of-the-hill  java 
— randomra
সূত্র
1
এই বিধিটির অর্থ কী তা আমি বুঝতে পারি না। 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."একটি বৃত্তাকার মধ্য দিয়ে যাচ্ছে" কি?
— শুক্র
@ ফেয়ারসাম যদি আমি সঠিকভাবে বুঝতে পারি তবে নীল লিভারটি স্থায়ীভাবে বর্তমান রাউন্ডে (এবং এইভাবে সমস্ত পূর্ববর্তী রাউন্ডগুলিতে "লক করে" টানলে যাতে সময় ভ্রমণের ফলে ফলাফল পরিবর্তন করা যায় না। যদি আপনি নীল লিভারটি টানানোর চেয়ে আগের সময়ের জন্য যদি টিটি করার চেষ্টা করে তবে তারা তা করতে অক্ষম হবে।
— 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
@ দি নাম্বারওন হ্যাঁ, এলোমেলো উদাহরণ বট এটি করে।
— এলোমেলো

উত্তর:

12

বিশ্লেষক

এটি ভবিষ্যতের জন্য সেরা পূর্বাভাস দেওয়ার জন্য অতীতকে বিশ্লেষণ করে।

সম্পাদনা: নীল রঙের সময় এড়ানো যায়। কার্যকরভাবে নীল লিভার ব্যবহার করে। আরও কার্যকরভাবে লাল লিভার ব্যবহার করে। হ্যালোইন মরসুমের জন্য যোগ

সম্পাদনা: 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;
    }

}

স্কোর (২ নভেম্বর থেকে):

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
— এক নম্বর
সূত্র
1
চিত্তাকর্ষক! আপনার বট কার্যকরভাবে অবরোধ করে এবং সর্বোত্তম সময়ে ফিরে আসে। এটি একটি শীর্ষস্থানীয় করতে পারে এমন একটি বট তৈরি করা খুব শক্ত হতে চলেছে।
— টিএনটি
আমি নিশ্চিত নই যে এই বটটি গণ্ডগোলের জন্য এবং অন্য কোনও বটকে উত্সাহিত করার জন্য বিশেষভাবে নকশাকৃত এন্ট্রিগুলির একটি গোছা ব্যবহার না করেই এই বটটি থেমে যায়।
— মেগো
4

স্বদেশে ফেরার আকুলতা

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

পরীক্ষা করা হয়নি, কেবল একটি বট তৈরির চেষ্টা করা যা দ্রুত আটকাতে অসুবিধা তৈরি করে (কারণ এটি নির্ধারণ করে যে বেশিরভাগ এলোমেলোভাবে লাল লিভারটি কখন টানতে হবে) তবে এটি শালীন সিদ্ধান্ত নেয়।

সম্পাদনা: আমি এই নিয়মটি মিস করেছি:

যদি আপনি একটি নীল লিভারটি টানেন (স্টপারটি রিভার্ট করুন) round রাউন্ডটির মাধ্যমে আর কোনও টিটি সম্ভব নয়

এটিকে মনে হয় মেমোরি ব্যবহারের ভাল কারণ - যদি আপনি কোনও প্রদত্ত রাউন্ডে টিটি করার চেষ্টা মনে রাখেন তবে আপনি ব্যর্থ হয়ে থাকতে পারেন, তাই আপনার আর সেই রাউন্ডে টিটি করার চেষ্টা করা উচিত নয়। এটি এড়াতে চেষ্টা করতে আমার বট সম্পাদনা করুন।

— histocrat
সূত্র
4

আকাশবাণী

আমি নির্লজ্জভাবে বিশ্লেষকের কাছ থেকে কিছু কোড অনুলিপি করে রেখেছি (মেমরিটি পার্স করার জন্য)। এই জমাটি প্রথমে একটি নীল লিভারটি টানতে চেষ্টা করে এবং তারপরে আস্তে আস্তে তার সীসা তৈরি করে। আমি মনে করি এই বটটির পারফরম্যান্সটি কুৎসিত কোড তৈরি করে :)

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);
    }
}
— CommonGuy
সূত্র
সাবাশ! আমি জানতাম আমি আমার রেড লিভারের সাথে যথেষ্ট আক্রমণাত্মক হয়ে উঠছি না। এখন বিশ্লেষকের উন্নতি করতে। ;)
— TheNumberOne
3

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

}
— ঐ মেগো
সূত্র
2

লিটল টেন

লিটল টেন 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);
    }
}

সম্পাদনা: যান্ত্রিককে এখনই কিছুটা পরিবর্তন করেছেন যে নীল লিভারটি যখন টানা হয় তখন কী হয় তার ব্যাখ্যা পরিষ্কার হয়। কিছুটা পুনঃত্যাগ করে।

— টিঅ্যান্ডটি
সূত্র
1

এলোমেলো

এলোমেলো কৌশল নিম্নলিখিত:

  • 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);
    }
}
— randomra
সূত্র
1

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

}
— ঐ মেগো
সূত্র
1

খারাপ লোকসান

এই বটটি কোনও মেমরি ব্যবহার করে না এবং এটি আশ্চর্যজনকভাবে ভাল (তবে এটি বিশ্লেষক বা ওরাকলকে পরাস্ত করে না)।

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, "");
    }
}
— এক নম্বর
সূত্র
0

পুরানো স্কুল

এই বট কখনই কোনও পদক্ষেপ নেয় না কারণ ওল্ডস্কুল সময় ভ্রমণের ক্ষেত্রে বিশ্বাস করে না।

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);
    }
}
— randomra
সূত্র
0

দেজা ভু বট

এই বটটি সেই অঞ্চলে লাল টান এড়াতে যখন নীল টান দেয় তখন ট্র্যাক করার চেষ্টা করে। স্কোরের উল্লেখযোগ্য পিছনে থাকলে কেবল লাল লিভারগুলি টানবে।

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

}
— হামাগুড়ি দেয়
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.