एसिमेट्रिकल कोथ: कैच द कैट

अद्यतन : gist-files को अपडेट किया जाता है (नए सबमिसिसिस सहित) कंट्रोलर के रूप में। Java एक्सेप्शन (केवल त्रुटियां) को नहीं पकड़ता है। यह अब त्रुटियों और अपवादों को पकड़ता है और उन्हें प्रिंट भी करता है।

इस चुनौती में दो धागे होते हैं, यह बिल्ली का धागा है, यहाँ पकड़ने वाला धागा मिल सकता है ।

कंट्रोलर को यहां से डाउनलोड किया जा सकता है ।

यह एक विषम KOTH है: प्रत्येक सबमिशन एक बिल्ली या एक पकड़ने वाला है । प्रत्येक बिल्ली और पकड़ने वाले की जोड़ी के बीच खेल होते हैं। बिल्लियों और पकड़ने वालों की अलग-अलग रैंकिंग है।

कैचर

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

यदि आपका तरीका एक अमान्य चाल पैदा करता है, तो आपका सबमिशन अयोग्य हो जाएगा। इस कदम को अमान्य माना जाता है, यदि आपकी मंजिल पर पहले से ही एक बाल्टी है या इस कदम को अनुमति नहीं है / गंतव्य पर पहले से ही कब्जा कर लिया गया है (एक बिल्ली के रूप में), या अगर पहले से ही एक बाल्टी / बिल्ली (एक पकड़ने वाले के रूप में) है। आप दिए गए कार्यों के साथ हाथ से पहले जाँच कर सकते हैं।

आपका सबमिशन काफी तेजी से काम करना चाहिए। यदि आपकी विधि प्रत्येक चरण के लिए 200ms से अधिक समय लेती है तो यह भी अयोग्य हो जाएगा। (अधिमानतः बहुत कम ...)

कार्यक्रमों को चरणों के बीच जानकारी संग्रहीत करने की अनुमति है।

प्रस्तुतियाँ

आप जितने चाहें उतने सबमिशन बना सकते हैं।
कृपया आपके द्वारा पहले से सबमिट की गई सबमिशन में बहुत फेरबदल न करें।
कृपया एक नए उत्तर में प्रत्येक प्रस्तुतियाँ।
प्रत्येक जमा को अधिमानतः यह अद्वितीय नाम होना चाहिए।
सबमिशन में आपकी कक्षा का कोड और साथ ही एक विवरण होना चाहिए जो हमें बताता है कि आपका सबमिशन कैसे काम करता है।
स्वचालित सिंटैक्स हाइलाइटिंग प्राप्त करने के लिए आप अपने सोर्सकोड की रेखा को लिख सकते हैं।

स्कोरिंग

सभी बिल्लियां सभी कैचर्स के खिलाफ एक ही समय में प्रतिस्पर्धा करेंगी । मैं वर्तमान स्कोर को बार-बार अपडेट करने की कोशिश करूंगा, विजेताओं का निर्धारण तब होगा जब गतिविधि कम हो जाएगी।

यह चुनौती इस पुराने फ़्लैश खेल से प्रेरित है

धन्यवाद @PhiNotPi परीक्षण और कुछ रचनात्मक प्रतिक्रिया देने के लिए।

वर्तमान स्कोर (प्रति जोड़ी 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

मुझे लगता है कि इस तरह की चुनौती पुलिस और लुटेरों के लिए है।

— SuperJedi224

4

@flawr मैं उन सभी चुनौतियों के लिए CnR टैग का विस्तार करने के पक्ष में हूं जिसमें दो प्रतिकूल उप-चुनौतियां शामिल हैं (और इस पर टैग के रूप में उस और KotH दोनों का उपयोग करना)। CnR टैग विकी उस शैली में हमारे सामने आने वाली चुनौतियों के बहुत से प्रभावित है। (इसके अलावा, आपने पुलिस और लुटेरों को गलत तरीके से गोल किया है;))

— मार्टिन एंडर

1

बिल्लियों को अपने तरीकों के माध्यम से कैचर्स की प्रतिक्रियाओं को आयात करने main.Controller, कॉल करने getCatchers()और अनुकरण / तोड़फोड़ करने से रोकता है takeTurn?

— लेजियम मैमल 978

12

@ लीजनमोनमल 978 स्पोर्ट्समैनशिप।

— मार्टिन एंडर

2

@ Faersum क्या यह मदद करता है ? (काला (

— सम्मान

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

सर्पिल तरीके से चलती है। यह

शीर्ष-बाएं सर्कल में जाने की कोशिश करता है
यदि संभव न हो तो शीर्ष दाएं घेरे में जाने की कोशिश करता है
यदि संभव न हो, तो सही सर्कल में जाने की कोशिश करता है
यदि संभव न हो, तो नीचे दायें चक्र में जाने की कोशिश करता है
यदि संभव न हो, तो नीचे बाएँ वृत्त पर जाने का प्रयास करता है

स्पिरालकैट बनाम एगेमोनॉन:

स्पिरालकैट बनाम एगैमोनॉन

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]है सीमा से बाहर रहने के लिए फेरबदल करना (जो इस स्थिति में नहीं होना चाहिए)।

— दोपहर

@ फ़्लावर, दमन। शब्दों का गरीब विकल्प। मेरा मतलब था कि यह बिल्ली बहुत बुद्धिमान नहीं है। कभी-कभी, यह बिल्ली शीर्ष बाएँ वृत्त और नीचे दाएँ वृत्त के बीच भी वैकल्पिक होती है, जब कोई रास्ता निकलता है ...

— Spikatrix

@flawr, क्या मुझे उपयोग करना है turns[i%6]? मेरा मतलब है, takeTurnअगर बिल्ली को अवरुद्ध किया जाता है, तो उसे बुलाया नहीं जाएगा?

— स्पिकैट्रिक्स

नहीं मुझे लगा कि आपका मतलब है कि आपको कार्यक्रम में बग का सामना करना पड़ा इसलिए मैं संभावित कारणों की तलाश कर रहा था। लेकिन तुम सही, स्पष्ट रूप से (यदि सब कुछ कर रहे हैं है सही) i>=6कभी नहीं करना चाहिए।

— दोष

2

RabidCat

RabidCat में हाइड्रोफोबिया है, इसलिए वह पानी की बाल्टियों से डरता है। वह निकटतम को पाता है और विपरीत दिशा में भागता है।

RabidCat बनाम ForwordCatcher:

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

}

— कैन
स्रोत

वाह, वास्तव में CloseCatcher द्वारा बर्बाद हो गया है

— Cain

2

ChoiceCat

हर संभव नई बिल्ली की स्थिति के लिए हम इसकी अच्छाई की जांच करते हैं और सबसे अच्छे को चुनते हैं। अच्छाई दो सर्वश्रेष्ठ पड़ोसी कोशिकाओं का कार्य है जो उस स्थिति की तुलना में बिल्ली की स्थिति से दूर हैं जिनके स्कोर की हम गणना करते हैं। हम केवल दो कोशिकाओं का उपयोग करते हैं क्योंकि एक को अवरुद्ध किया जा सकता है और बिल्ली को दूर होने के लिए केवल एक और की आवश्यकता होती है। हमारा कार्य एक महान और एक बुरे की तुलना में दो काफी अच्छी कोशिकाओं को प्राथमिकता देता है। बाल्टी के साथ पदों में 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
स्रोत

असममित KOTH: बिल्ली को पकड़ें (कैट थ्रेड)

एसिमेट्रिकल कोथ: कैच द कैट

कैचर

बिल्ली

ग्रिड

खेल

नियंत्रक

प्रस्तुतियाँ

स्कोरिंग

वर्तमान स्कोर (प्रति जोड़ी 100 खेल)

FreeCat

दीजकस्ट्रा की बिल्ली

MaxCat

SpiralCat

RabidCat

ChoiceCat

StupidRightCat

RandCat

StraightCat