অসমৰ কোটৰ বিড়াল ধর

আপডেট : কন্ট্রোলআরজভা ব্যতিক্রম (কেবল ত্রুটিগুলি) ধরেনি বলে গিস্ট-ফাইলগুলি আপডেট করা হয়েছে (নতুন সাবমিসন সহ)। এটি এখন ত্রুটি এবং ব্যতিক্রমগুলি ধরে এবং এগুলি মুদ্রণ করে।

এই চ্যালেঞ্জটি দুটি থ্রেড নিয়ে গঠিত, এটি বিড়ালের থ্রেড, ক্যাচার থ্রেডটি এখানে পাওয়া যাবে ।

নিয়ামকটি এখানে ডাউনলোড করা যায় ।

এটি একটি অসম কৌতুক: প্রতিটি জমাটি হয় বিড়াল বা ক্যাচার । প্রতিটি বিড়াল এবং একটি ক্যাচারের প্রতিটি জুটির মধ্যে গেমস রয়েছে। বিড়াল এবং ক্যাচারদের পৃথক র‌্যাঙ্কিং রয়েছে।

ক্যাচার

ষড়ভুজ গ্রিডে একটি বিড়াল রয়েছে। আপনার কাজটি যত তাড়াতাড়ি সম্ভব এটি ধরা। প্রতি মুহুর্তে, আপনি বিড়ালটিকে সেখানে যেতে না দেওয়ার জন্য একটি গ্রিড সেলে একটি জলের বালতি রাখতে পারেন। তবে বিড়ালটি (সম্ভবত) সেই বোবা নয় এবং যখনই আপনি একটি বালতি রাখবেন, বিড়ালটি অন্য গ্রিড কোষে চলে যাবে। গ্রিড ষড়ভুজ হিসাবে, বিড়ালটি 6 টি ভিন্ন দিকে যেতে পারে। আপনার লক্ষ্য হ'ল বিড়ালটিকে জলের বালতি দিয়ে ঘিরে দেওয়া, তত দ্রুততর।

বিড়াল

আপনি জানেন যে ক্যাচার আপনার চারপাশে জলের বালতি রেখে আপনাকে ধরতে চায়। অবশ্যই আপনি এড়াতে চেষ্টা করুন, তবে আপনি যেমন একটি অলস বিড়াল (বিড়ালরা হলেন) আপনি ঠিক সেই সময় একটি পদক্ষেপ নিয়েছিলেন। এর অর্থ আপনি একই স্থানে থাকতে পারবেন না, তবে আপনাকে আশেপাশের ছয়টি দাগের একটিতে যেতে হবে। আপনি যখনই দেখবেন যে ক্যাচার একটি নতুন জলের বালতি রেখেছিল আপনি অন্য কোষে যান। অবশ্যই আপনি যতটা সম্ভব এড়ানোর চেষ্টা করুন।

গ্রিড

গ্রিডটি ষড়্ভুজাকৃতির, তবে আমাদের ষড়্ভুজাকৃতির ডেটা কাঠামো নেই বলে আমরা একটি 11 x 11বর্গক্ষেত্র 2 ডি অ্যারে নিয়েছি এবং ষড়ভুজীয় 'আচরণ' নকল করি যা বিড়ালটি কেবল 6 দিক দিয়ে যেতে পারে:

এখানে চিত্র বর্ণনা লিখুন

টপোলজিটি টোরয়েডাল, এর অর্থ যদি আপনি অ্যারের বাইরে 'সেল' করে কোনও কোষে পদক্ষেপ নেন, আপনি কেবল অ্যারের অন্য পাশের সংশ্লিষ্ট ঘরে স্থানান্তরিত হবেন।

খেলা

বিড়াল গ্রিডে দেওয়া অবস্থান থেকে শুরু হয়। ক্যাচারারটি প্রথম পদক্ষেপটি করতে পারে, তারপরে বিড়ালটিকে ধরা না দেওয়া পর্যন্ত বিড়াল এবং তার ক্যাচার বিকল্প চলাচল করে। পদক্ষেপের সংখ্যাটি সেই গেমের স্কোর। বিড়াল যতটা সম্ভব স্কোর পাওয়ার চেষ্টা করে, ক্যাচারটি যতটা সম্ভব কম স্কোর পাওয়ার চেষ্টা করে। আপনি যে সমস্ত গেমসে অংশ নিয়েছেন তার তুলনায় গড় যোগফলটি আপনার জমা দেওয়ার স্কোর হবে। দুটি পৃথক র‌্যাঙ্কিং রয়েছে, একটি বিড়ালের জন্য, একটি ক্যাচারদের জন্য।

নিয়ামক

প্রদত্ত নিয়ামকটি জাভাতে লেখা। ক্যাচার বা বিড়াল হিসাবে আপনার প্রত্যেকে জাভা ক্লাসটি সম্পূর্ণরূপে প্রয়োগ করতে হবে (ইতিমধ্যে কিছু প্রাথমিক উদাহরণ রয়েছে) এবং এটি playersপ্যাকেজে রাখুন (এবং কন্ট্রোলার ক্লাসে বিড়াল / ক্যাচারের তালিকা আপডেট করুন) তবে আপনি লিখতেও পারেন শ্রেণীর মধ্যে অতিরিক্ত ফাংশন। কন্ট্রোলার প্রতিটি সহজ বিড়াল / ক্যাচার ক্লাসের দুটি কাজের উদাহরণ সহ আসে।

ক্ষেত্রটি একটি 11 x 112D- intঅ্যারে যা ঘরের বর্তমান রাজ্যের মানগুলি সঞ্চয় করে। যদি কোনও ঘর খালি থাকে তবে এর মান থাকতে পারে 0, যদি একটি বিড়াল থাকে তবে এর মান থাকে -1এবং যদি বালতি থাকে তবে একটি থাকে 1।

আপনি ব্যবহার করতে পারেন এমন কয়েকটি প্রদত্ত ফাংশন রয়েছে: isValidMove()/ isValidPosition()আপনার পদক্ষেপ (বিড়াল) / অবস্থান (ক্যাচার) বৈধ কিনা তা যাচাই করার জন্য।

প্রতিবার এটি আপনার পালা, আপনার ফাংশন takeTurn()বলা হয়। যুক্তিটিতে বর্তমান গ্রিডের অনুলিপি রয়েছে যার একটিতে read(i,j)ঘর পড়ার মতো পদ্ধতি রয়েছে (i,j), পাশাপাশি isValidMove()/ isValidPosition()এটি আপনার উত্তরের বৈধতা পরীক্ষা করে। এটি টেরয়েডাল টপোলজির মোড়কেও পরিচালনা করে, এর অর্থ গ্রিডটি কেবলমাত্র 11 x 11 হলেও আপনি এখনও সেলটিতে প্রবেশ করতে পারবেন (-5,13)।

পদ্ধতিটি intদুটি উপাদানের একটি অ্যারে ফিরিয়ে আনবে, যা সম্ভাব্য পদক্ষেপের প্রতিনিধিত্ব করে। বিড়ালদের জন্য এগুলি {-1,1},{0,1},{-1,0},{1,0},{0,-1},{1,-1}যা বিড়ালটি কোথায় যেতে চায় তার তুলনামূলক অবস্থানকে প্রতিনিধিত্ব করে এবং ক্যাচাররা যেখানে তারা বালতি রাখতে চায় তার নিখুঁত স্থানাঙ্কগুলি ফিরিয়ে দেয় {i,j}।

যদি আপনার পদ্ধতিটি একটি অবৈধ পদক্ষেপ উত্পন্ন করে, আপনার জমাটি অযোগ্য ঘোষণা করা হবে। পদক্ষেপটি অবৈধ হিসাবে বিবেচিত হবে, যদি আপনার গন্তব্যটিতে ইতিমধ্যে একটি বালতি থাকে বা সরানোর অনুমতি নেই / গন্তব্য ইতিমধ্যে দখল করা হয়েছে (বিড়াল হিসাবে), বা ইতিমধ্যে যদি বালতি / বিড়াল (ক্যাচার হিসাবে) থাকে তবে। আপনি প্রদত্ত ফাংশনগুলির সাথে আগে এটি পরীক্ষা করতে পারেন।

আপনার জমা দেওয়ার পক্ষে যুক্তিসঙ্গত দ্রুত কাজ করা উচিত। যদি আপনার পদক্ষেপটি প্রতিটি পদক্ষেপের জন্য 200 মিটারের বেশি সময় নেয় তবে এটি অযোগ্যও হয়ে যাবে। (সম্ভবতঃ অনেক কম ...)

প্রোগ্রামগুলি ধাপগুলির মধ্যে তথ্য সংরক্ষণের অনুমতিপ্রাপ্ত।

জমা

আপনি চান যতগুলি জমা দিতে পারেন।
আপনি ইতিমধ্যে জমা দেওয়া জমাগুলি উল্লেখযোগ্যভাবে পরিবর্তন করবেন না দয়া করে।
প্রতিটি উত্তর জমা দিন দয়া করে একটি নতুন উত্তরে।
প্রতিটি জমা দেওয়ার পক্ষে এটির অনন্য নামটি থাকতে হবে।
জমা দেওয়ার ক্ষেত্রে আপনার শ্রেণীর কোডের পাশাপাশি একটি বিবরণ থাকতে হবে যা আমাদের জমা দেয় কীভাবে আমাদের জানায়।
স্বয়ংক্রিয় সিনট্যাক্স হাইলাইট করার জন্য আপনি আপনার সোর্সকোডের জন্য লাইফটি লিখতে পারেন ।

স্কোরিং

সমস্ত বিড়াল একই সংখ্যক বার সমস্ত ক্যাচারদের বিরুদ্ধে প্রতিদ্বন্দ্বিতা করবে । আমি বর্তমান স্কোরগুলি ঘন ঘন আপডেট করার চেষ্টা করব, ক্রিয়াকলাপ হ্রাস পেয়ে বিজয়ীরা নির্ধারিত হবে।

এই চ্যালেঞ্জটি এই পুরানো ফ্ল্যাশ গেম দ্বারা অনুপ্রাণিত

পরীক্ষামূলকভাবে কিছু গঠনমূলক মতামত দেওয়ার জন্য @ ফিলিপটপিকে ধন্যবাদ জানাই।

বর্তমান স্কোর (জুটি প্রতি 100 গেম)

Name              Score      Rank   Author

RandCatcher       191962     8      flawr   
StupidFill        212688     9      flawr
Achilles          77214      6      The E
Agamemnon         74896      5      The E
CloseCatcher      54776      4      randomra
ForwordCatcher    93814      7      MegaTom  
Dijkstra          47558      2      TheNumberOne
HexCatcher        48644      3      randomra
ChoiceCatcher     43834      1      randomra

RandCat            77490     9      flawr
StupidRightCat     81566     6      flawr
SpiralCat          93384     5      CoolGuy
StraightCat        80930     7      CoolGuy
FreeCat           106294     3      randomra
RabidCat           78616     8      cain
Dijkstra's Cat    115094     1      TheNumberOne
MaxCat             98400     4      Manu
ChoiceCat         113612     2      randomra

king-of-the-hill java hexagonal-grid

— flawr
সূত্র

1

আমি মনে করি এই ধরণের চ্যালেঞ্জ হ'ল পুলিশ-ডাকাতদের ট্যাগ।

— সুপারজেডি ২২৪

4

@ ফ্লোয়ার আমি দুটি প্রতিপক্ষের চ্যালেঞ্জের সাথে জড়িত সমস্ত চ্যালেঞ্জগুলির (এবং এটিতে এবং ট্যাগটি উভয়ই ট্যাগ হিসাবে ব্যবহার করে) সিএনআর ট্যাগ বাড়ানোর পক্ষে in সিএনআর ট্যাগ উইকি আমাদের সেই ধারার মধ্যে প্রথম দুটি চ্যালেঞ্জের দ্বারা খুব বেশি প্রভাবিত। (এছাড়াও, আপনি পুলিশ এবং ডাকাতদের ভুল উপায়ে পেয়েছেন;))

— মার্টিন এন্ডার

1

কী বিড়ালদের তাদের পদ্ধতিগুলির মাধ্যমে ক্যাচারার প্রতিক্রিয়াগুলি আমদানি main.Controller, কল করা getCatchers()এবং অনুকরণ / নাশকতা থেকে বাধা দেয় takeTurn?

— LegionMammal978

12

টুইটারে

— মার্টিন এন্ডার

2

@ ফেয়ারসাম এই সাহায্য করে? (কালো (রেস। নীল) বিন্দুগুলি একই কক্ষের প্রতিনিধিত্ব করে))

— flawr

5

FreeCat

ক্ষেত্রটি পরিবর্তিত না হলে 3 পদক্ষেপের পরে এটি সর্বাধিক সম্ভাব্য পাথ দেয় এমন পদক্ষেপটি চয়ন করে।

ফ্রিগেট বনাম অ্যাকিলিস:

ফ্রিগেট বনাম অ্যাকিলিস

package players;
/**
 * @author randomra
 */

import java.util.Arrays;

import main.Field;

public class FreeCat implements Cat {

    final int[][] turns = { { -1, 1 }, { 0, 1 }, { -1, 0 }, { 1, 0 },
            { 0, -1 }, { 1, -1 } };// all valid moves
    final int turnCheck = 3;

    public String getName() {
        return "FreeCat";
    }

    public int[] takeTurn(Field f) {

        int[] pos = f.findCat();
        int[] bestMove = { 0, 1 };
        int bestMoveCount = -1;
        for (int[] t : turns) {
            int[] currPos = { pos[0] + t[0], pos[1] + t[1] };
            int moveCount = free_count(currPos, turnCheck, f);
            if (moveCount > bestMoveCount) {
                bestMoveCount = moveCount;
                bestMove = t;
            }
        }
        return bestMove;
    }

    private int free_count(int[] pos, int turnsLeft, Field f) {
        if (f.isValidPosition(pos) || Arrays.equals(pos, f.findCat())) {
            if (turnsLeft == 0) {
                return 1;
            }
            int routeCount = 0;
            for (int[] t : turns) {
                int[] currPos = { pos[0] + t[0], pos[1] + t[1] };
                int moveCount = free_count(currPos, turnsLeft - 1, f);
                routeCount += moveCount;
            }
            return routeCount;
        }
        return 0;
    }
}

— randomra
সূত্র

3

ডিজকস্ট্রার বিড়াল

তিনি তাঁর মাস্টারের মাস্টার অ্যালগরিদম শিখেছেন এবং প্রয়োগ করেছেন। নোট করুন যে তিনি তার সম্পর্কিত ক্যাচারের ক্লাসের কয়েকটি পদ্ধতির উপর নির্ভরশীল।

ডিজকস্ট্রার বিড়াল বনাম হেক্সকাচার (আপডেট হওয়া দরকার):

এখানে চিত্র বর্ণনা লিখুন

package players;

import main.Field;
import players.Dijkstra; //Not needed import. Should already be available.

/**
 * @author TheNumberOne
 *
 * Escapes from the catcher.
 * Uses Dijkstras methods.
 */

public class DijkstrasCat implements Cat{

    private static final int[][] possibleMoves = {{-1,1},{0,1},{-1,0},{1,0},{0,-1},{1,-1}};
    @Override
    public String getName() {
        return "Dijkstra's Cat";
    }

    @Override
    public int[] takeTurn(Field f) {
        int[] me = f.findCat();
        int[] bestMove = {-1,1};
        int bestOpenness = Integer.MAX_VALUE;
        for (int[] move : possibleMoves){
            int[] newPos = Dijkstra.normalize(new int[]{me[0]+move[0],me[1]+move[1]});
            if (!f.isValidMove(move)){
                continue;
            }
            int openness = Dijkstra.openness(newPos, f, true)[1];
            if (openness < bestOpenness || (openness == bestOpenness && Math.random() < .5)){
                bestOpenness = openness;
                bestMove = move;
            }
        }
        return bestMove;
    }
}

তিনি কীভাবে কাজ করেন:

তিনি নিজের সম্পর্কে বোর্ডের স্থিতিস্থাপকতা হ্রাসকারী পদক্ষেপটি সন্ধান করার চেষ্টা করেন। আরও তথ্যের জন্য, সম্পর্কিত ক্যাচারের পোস্টটি দেখুন।

আপডেট সহ:

তিনি এখন পানির বালতিগুলি কখনও কখনও তৈরি হওয়া অদ্ভুত জ্যামিতিক আকারগুলি এড়িয়ে যান।

— এক নম্বর
সূত্র

3

MaxCat

আমি মিনিম্যাক্স অ্যালগরিদম বাস্তবায়নের চেষ্টা করেছি। তবে সীমিত সময় থাকায় এটি খুব ভাল পারফর্ম করে না। সম্পাদনা: এটি এখন মাল্টিথ্রেডিং ব্যবহার করে, তবে (কমপক্ষে আমার কম্পিউটারে) আমি গভীরতা আরও উচ্চতর করতে পারি না। অন্যথায় একটি সময়সীমা ঘটে। 6 বা ততোধিক কোর সহ একটি পিসি ব্যবহার করা, এই জমাটি আরও ভাল হবে :)

ম্যাকগ্যাট বনাম ডিজকস্ট্রা:

ম্যাকগ্যাট বনাম ডিজকস্ট্রা

package players;

import java.util.ArrayList;
import java.util.List;

import main.Field;

public class MaxCat implements Cat {
    final int[][] turns = { { -1, 1 }, { 0, 1 }, { -1, 0 }, { 1, 0 }, { 0, -1 }, { 1, -1 } };

    public String getName() {
        return "MaxCat";
    }

    public int[] takeTurn(Field f) {
        List<CatThread> threads = new ArrayList<>();
        int[] pos = f.findCat();
        for (int[] turn : turns) {
            if(f.read(pos[0]+turn[0], pos[1]+turn[1]) == Field.EMPTY){
                CatThread thread = new CatThread();
                thread.bestMove = turn;
                thread.field = new Field(f);
                thread.start();
                threads.add(thread);
            }
        }
        for (CatThread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {}
        }
        int best = Integer.MIN_VALUE;
        int[] bestMove = { -1, 1 };
        for (CatThread thread : threads) {
            if (thread.score > best) {
                best = thread.score;
                bestMove = thread.bestMove;
            }
        }
        return bestMove;
    }

    class CatThread extends Thread {
        private Field field;
        private int[] bestMove;
        private int score;
        private final int DEPTH = 3;

        @Override
        public void run() {
            score = max(DEPTH, Integer.MIN_VALUE, Integer.MAX_VALUE);       
        }

        int max(int depth, int alpha, int beta) {
            int pos[] = field.findCat();
            if (depth == 0 || field.isFinished()) {
                int moveCount = 0;
                for (int[] turn : turns) {
                    if(field.read(pos[0]+turn[0], pos[1]+turn[1]) == Field.EMPTY)
                        moveCount++;
                }
                return DEPTH-depth + moveCount;
            }
            int maxValue = alpha;
            for (int[] turn : turns) {
                if(field.read(pos[0]+turn[0], pos[1]+turn[1]) == Field.EMPTY) {
                    field.executeMove(turn);
                    int value = min(depth-1, maxValue, beta);
                    field.executeMove(new int[]{-turn[0], -turn[1]});
                    if (value > maxValue) {
                        maxValue = value;
                        if (maxValue >= beta)
                            break;
                    }
                }
            }
            return maxValue;
        }

        int min(int depth, int alpha, int beta) {
            if (depth == 0 || field.isFinished()) {
                int moveCount = 0;
                for (int[] turn : turns) {
                    int pos[] = field.findCat();
                    if(field.read(pos[0]+turn[0], pos[1]+turn[1]) == Field.EMPTY)
                        moveCount++;
                }   
                return -depth - moveCount;
            }
            int[][] f = field.field;
            int minValue = beta;
            List<int[]> moves = generateBucketMoves();
            for (int[] move : moves) {
                f[move[0]][move[1]] = Field.BUCKET;
                int value = max(depth-1, alpha, minValue);
                f[move[0]][move[1]] = Field.EMPTY;
                if (value < minValue) {
                    minValue = value;
                    if (minValue <= alpha)
                        break;
                }
            }
            return minValue;
        }

        private List<int[]> generateBucketMoves() {
            int[][] f = field.field;
            List<int[]> list = new ArrayList<>();
            for (int i = 0; i < f.length; i++) {
                for (int j = 0; j < f[i].length; j++) {
                    if (f[i][j] == Field.EMPTY) {
                        list.add(new int[]{i,j});
                    }
                }
            }
            return list;
        }
    }
}

— CommonGuy
সূত্র

আসলে আপনি Fieldজনসাধারণের নির্মাতা করতে পারেন । আমি দুঃখিত আমি এখনও ফাইলগুলি আপডেট করি নি, তবে আমরা এটি আগে আলোচনা করেছি!

— flawr

@ ফ্লোয়ার ওহ দুর্দান্ত, আপনাকে ধন্যবাদ!

— কমনগ্যুই

2

SpiralCat

একটি সর্পিল পথে সরানো s এটা

উপরের-বাম চেনাশোনাতে যাওয়ার চেষ্টা করে
সম্ভব না হলে উপরের ডান দিকের বৃত্তে যাওয়ার চেষ্টা করে
যদি সম্ভব না হয় তবে ডান বৃত্তে যাওয়ার চেষ্টা করে
যদি সম্ভব না হয় তবে নীচের ডান বৃত্তে যাওয়ার চেষ্টা করে t
যদি সম্ভব না হয় তবে নীচে বাম দিকের বৃত্তে যাওয়ার চেষ্টা করে

সর্পিলগেট বনাম আগামেমনন:

সর্পিলগেট বনাম আগামেমনন

package players;
/**
 * @author Cool Guy
 */

import main.Field;

public class SpiralCat implements Cat{
    public String getName(){
        return "SpiralCat";
    }
    public int[] takeTurn(Field f){
        int[][] turns = {{-1,1},{0,1},{1,0},{1,-1},{0,-1},{-1,0}};//all valid moves
        int[] move;
        int i = -1;
        do {
            i++;
            move = turns[i];
        } while(f.isValidMove(move) == false);
        return move;
    }
}

— Spikatrix
সূত্র

আপনি কি বাগগুলি সম্মুখীন হয়েছে জানেন? আমি শুধু পরিবর্তন চাই পরিবর্তনের হবে turns[i]থেকে turns[i%6]অর্ডার সীমার বাইরে এড়াতে (যা এই stuation ঘটতে উচিত নয়) হবে।

— flawr

@ ফ্লোয়ার, অভি। শব্দের দুর্বল পছন্দ। আমি বোঝাতে চেয়েছিলাম যে এই বিড়ালটি খুব বুদ্ধিমান নয়। অনেক সময়, এই বিড়ালটি বাইরে যাওয়ার সময়ও কেবল উপরের বাম বৃত্ত এবং নীচের ডান বৃত্তের মধ্যে

— পরিবর্তিত

@ ফ্লোয়ার, আমাকে কি ব্যবহার করতে হবে turns[i%6]? মানে, takeTurnবিড়াল আটকে থাকলে ডাকা হবে না, তাইনা?

— স্পিক্যাট্রিক্স

না আমি ভেবেছিলাম আপনি প্রোগ্রামটিতে কোনও বাগের মুখোমুখি হয়েছিলেন তাই আমি সম্ভাব্য কারণ অনুসন্ধান করছি। কিন্তু আপনি ঠিক আছে, স্পষ্টত (যদি সবকিছু হয় হয় সঠিক) i>=6ঘটতে না করা উচিত।

— flawr

2

RabidCat

রবিডটিজির হাইড্রোফোবিয়া রয়েছে, তাই তিনি পানির বালতিতে ভয় পান। তিনি নিকটতমটি খুঁজে পান এবং বিপরীত দিকে চালান।

রবিডগ্যাট বনাম ফোরওয়ার্ডগিচার:

rabidcat_vs_forwordcatcher

package players;

import java.util.Random;

import main.Field;

/**
* Run away from water buckets
* @author cain
*
*/

public class RabidCat implements Cat {

public RabidCat() {
}

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

@Override
public int[] takeTurn(Field f) {
    int[][] directions = {{-1,1},{0,1},{-1,0},{1,0},{0,-1},{1,-1}};

    //where am I?
    int[] position = {0,0};
    for(int i = 0; i < 12; i++){
        for(int j = 0; j < 12; j++){
            if(f.read(i,j) == -1){
                position[0] = i;
                position[1] = j;
            }
        }
    }

    //Find the closest water
    int direction = 0;
    for(int d = 0; d < 10; d++){
        if(f.read(position[0] + d, position[1] - d) == 1 && f.isValidMove(directions[0])){
            direction = 1;
            break;
        }
        if(f.read(position[0], position[1] - d) == 1 && f.isValidMove(directions[1])){
            direction = 2;
            break;
        }
        if(f.read(position[0] + d, position[1]) == 1 && f.isValidMove(directions[2])){
            direction = 3;
            break;
        }
        if(f.read(position[0] - d, position[1]) == 1 && f.isValidMove(directions[3])){
            direction = 4;
            break;
        }
        if(f.read(position[0], position[1] + d) == 1 && f.isValidMove(directions[4])){
            direction = 5;
            break;
        }
        if(f.read(position[0] - d, position[1] + d) == 1 && f.isValidMove(directions[5])){
            direction = 6;
            break;
        }
    }

    //If there is no water near, wander
    while(direction == 0){
        Random rand = new Random();
        direction = rand.nextInt(6) + 1;
        if(!f.isValidMove(directions[direction - 1])){
            direction = 0;
        }
    }
    return directions[direction - 1];
}

}

— কেইন
সূত্র

বাহ, সত্যিই ক্লোজগ্যাচারের সর্বনাশ হয়েছে

— কেইন

2

ChoiceCat

প্রতিটি সম্ভাব্য নতুন বিড়াল অবস্থানের জন্য আমরা এর সদ্ব্যবহার পরীক্ষা করি এবং সেরাটি চয়ন করি। সদর্থকতা হ'ল দুটি সেরা প্রতিবেশী কোষের কাজ যাঁরা আমাদের স্কোর গণনা করে সেই অবস্থানের চেয়ে বিড়ালের অবস্থান থেকে আরও দূরে। আমরা কেবলমাত্র দুটি কোষ ব্যবহার করি কারণ একটি ব্লক করা যেতে পারে এবং বিড়ালটিকে দূরে যেতে কেবল আরও একটির প্রয়োজন needs আমাদের ফাংশনটি একটি দুর্দান্ত এবং একটি খারাপের চেয়ে দুটি মোটামুটি ভাল কোষকে পছন্দ করে। বালতিযুক্ত পজিশনের স্কোর 0 থাকে এবং সর্বাধিক নিখরচায় সেলগুলিতে স্কোর 1 থাকে।

চয়েসকেট বর্তমান বিড়ালগুলির চেয়ে আরও ভাল স্কোর বলে মনে হচ্ছে।

চয়েসকিট বনাম চয়েস গুগল:

চয়েসকিট বনাম চয়েসগিচার

package players;
/**
 * @author randomra
 */
import java.util.Arrays;

import main.Field;

public class ChoiceCat implements Cat {

    private class Values {
        public final int size;
        private double[][] f;

        Values(int size) {
            this.size = size;
            f = new double[size][size];
        }

        public double read(int[] p) {
            int i = p[0];
            int j = p[1];
            i = (i % size + size) % size;
            j = (j % size + size) % size;
            return f[i][j];
        }

        private double write(int[] p, double v) {
            int i = p[0];
            int j = p[1];
            i = (i % size + size) % size;
            j = (j % size + size) % size;
            return f[i][j] = v;
        }
    }

    final int[][] turns = { { -1, 1 }, { 0, 1 }, { 1, 0 }, { 1, -1 },
            { 0, -1 }, { -1, 0 } };// all valid moves CW order
    final int stepCheck = 5;

    public String getName() {
        return "ChoiceCat";
    }

    public int[] takeTurn(Field f) {

        int[] pos = f.findCat();
        int[] bestMove = { 0, 1 };
        double bestMoveValue = -1;
        for (int[] t : turns) {
            int[] currPos = { pos[0] + t[0], pos[1] + t[1] };
            double moveValue = movePosValue(currPos, f);
            if (moveValue > bestMoveValue) {
                bestMoveValue = moveValue;
                bestMove = t;
            }
        }
        return bestMove;
    }

    private double movePosValue(int[] pos, Field f) {

        Values v = new Values(f.SIZE);

        for (int ring = stepCheck; ring >= 0; ring--) {
            for (int phase = 0; phase < 2; phase++) {
                for (int sidepos = 0; sidepos < Math.max(1, ring); sidepos++) {
                    for (int side = 0; side < 6; side++) {
                        int[] evalPos = new int[2];
                        for (int coord = 0; coord < 2; coord++) {
                            evalPos[coord] = pos[coord] + turns[side][coord]
                                    * sidepos + turns[(side + 1) % 6][coord]
                                    * (ring - sidepos);
                        }
                        if (phase == 0) {
                            if (ring == stepCheck) {
                                // on outmost ring, init value
                                v.write(evalPos, -1);
                            } else {
                                v.write(evalPos, posValue(evalPos, v, f));
                            }
                        } else {
                            // finalize position value for next turn
                            v.write(evalPos, -v.read(evalPos));
                        }
                    }
                }
            }
        }

        return -v.read(pos);
    }

    private double posValue(int[] pos, Values v, Field f) {
        if (f.read(pos[0], pos[1]) == Field.BUCKET) {
            return 0;
        }
        int count = 0;
        double[] product = new double[6];
        for (int[] t : turns) {
            int[] tPos = new int[] { pos[0] + t[0], pos[1] + t[1] };
            if (v.read(tPos) > 0) {
                product[count] = 1 - 1 / (v.read(tPos) + 1);
                count++;
            }
        }
        Arrays.sort(product);
        double fp = 1;
        for (int i = 0; i < Math.min(count,2); i++) {
            fp *= product[5-i];
        }
        double retValue = Math.min(count,2) + fp;
        return -retValue;
    }
}

— randomra
সূত্র

1

StupidRightCat

এটি কেবল নিয়ামক পরীক্ষার জন্য তৈরি হয়েছিল। যখনই সম্ভব বিড়াল ডানদিকে চলে যায়, অন্যথায় এলোমেলো পথে চলে।

package players;

import main.Field;

public class StupidRightCat implements Cat{
    public String getName(){
        return "StupidRightCat";
    }
    public int[] takeTurn(Field f){
        int[][] turns = {{-1,1},{0,1},{-1,0},{1,0},{0,-1},{1,-1}};//all valid moves
        int[] move;

        if(f.isValidMove(turns[3])){
            return turns[3];
        } else {
            do {
                move = turns[(int) (turns.length * Math.random())];
            } while(f.isValidMove(move)==false);
            return move;//chose one at random
        }
    }
}

— flawr
সূত্র

1

RandCat

এটি কেবল নিয়ামক পরীক্ষার জন্য তৈরি হয়েছিল। বিড়ালটি কেবল এলোমেলোভাবে চলে।

package players;

import main.Field;

public class RandCat implements Cat{
    public String getName(){
        return "RandCat";
    }
    public int[] takeTurn(Field f){
        int[][] turns = {{-1,1},{0,1},{-1,0},{1,0},{0,-1},{1,-1}};//all valid moves
        int[] move;
        do {
            move = turns[(int) (turns.length * Math.random())];
        } while(f.isValidMove(move)==false);
        return move;//chose one at random
    }
}

— flawr
সূত্র

1

StraightCat

এই বিড়াল সোজা সরানো।

শুরুতে, এটি একটি এলোমেলো দিক চয়ন করে এবং এই দিক পর্যন্ত চলতে থাকে যতক্ষণ না এটি ঘটতে পারে না, এটি ঘড়ির কাঁটার দিক দিয়ে দিকটি পরবর্তী বৈধ দিকে নিয়ে যায় এবং এই প্রক্রিয়াটি পুনরাবৃত্তি করে।

স্ট্রেটগেট বনাম আগামেমনন:

স্ট্রেটগেট বনাম আগামেমনন

package players;
/**
 * @author Cool Guy
 */

import main.Field;

public class StraightCat implements Cat{

    int lastDirection = -1; //Holds the last direction the cat moved
    public String getName(){
        return "StraightCat";
    }
    public int[] takeTurn(Field f){
        int[][] turns = {{-1,1},{0,1},{1,0},{1,-1},{0,-1},{-1,0}};//all valid moves

        if(lastDirection == -1)
          lastDirection = (int) (turns.length * Math.random());

        int[] move = turns[lastDirection];
        int i = lastDirection;

        while(true)
        {
            if(f.isValidMove(move))
                break;
            i = (i+1)%6;
            lastDirection = i;
            move = turns[i];
        }
        return move;
    }
}

— Spikatrix
সূত্র

অসম্পূর্ণ কোথার: বিড়াল ধরুন (বিড়ালের থ্রেড)

অসমৰ কোটৰ বিড়াল ধর

ক্যাচার

বিড়াল

গ্রিড

খেলা

নিয়ামক

জমা

স্কোরিং

বর্তমান স্কোর (জুটি প্রতি 100 গেম)

FreeCat

ডিজকস্ট্রার বিড়াল

MaxCat

SpiralCat

RabidCat

ChoiceCat

StupidRightCat

RandCat

StraightCat