KOTH bất đối xứng: Bắt mèo

CẬP NHẬT : Các tệp chính được cập nhật (bao gồm cả các tệp con mới) vì Trình điều khiển.java không bắt Ngoại lệ (chỉ có lỗi). Bây giờ nó bắt lỗi và ngoại lệ và cũng in chúng.

Thử thách này bao gồm hai chủ đề, đây là chủ đề con mèo, chủ đề bắt có thể được tìm thấy ở đây .

Bộ điều khiển có thể được tải xuống ở đây .

Đây là một KOTH bất đối xứng: Mỗi lần gửi là một con mèo hoặc một người bắt . Có những trò chơi giữa mỗi cặp của một con mèo và một người bắt. Những con mèo và những người bắt có bảng xếp hạng riêng biệt.

Bắt bóng

Có một con mèo trên lưới lục giác. Nhiệm vụ của bạn là bắt nó càng nhanh càng tốt. Mỗi lượt, bạn có thể đặt một xô nước trên một ô lưới để ngăn mèo không thể đến đó. Nhưng con mèo không (có lẽ) bị câm, và bất cứ khi nào bạn đặt một cái xô, con mèo sẽ di chuyển đến một ô lưới khác. Vì lưới là hình lục giác, con mèo có thể đi theo 6 hướng khác nhau. Mục tiêu của bạn là bao quanh con mèo bằng xô nước, càng nhanh càng tốt.

Con mèo

Bạn biết người bắt bóng muốn bắt bạn bằng cách đặt xô nước xung quanh bạn. Tất nhiên bạn cố gắng trốn tránh, nhưng vì bạn là một con mèo lười biếng (như mèo), bạn chính xác thực hiện một bước tại thời điểm đó. Điều này có nghĩa là bạn không thể ở cùng một nơi với bạn, nhưng bạn phải di chuyển đến một trong sáu điểm xung quanh. Bất cứ khi nào bạn thấy rằng người bắt được đặt một xô nước mới, bạn đi đến một tế bào khác. Tất nhiên bạn cố gắng trốn tránh càng lâu càng tốt.

Lưới

Lưới là hình lục giác, nhưng vì chúng tôi không có cấu trúc dữ liệu hình lục giác, chúng tôi lấy một 11 x 11mảng 2d vuông và bắt chước 'hành vi' hình lục giác mà con mèo chỉ có thể di chuyển theo 6 hướng:

Cấu trúc liên kết là hình xuyến, có nghĩa là nếu bạn bước vào một ô 'bên ngoài' của mảng, bạn sẽ chỉ được chuyển đến ô tương ứng ở phía bên kia của mảng.

Trò chơi

Con mèo bắt đầu ở vị trí nhất định trong lưới. Người bắt có thể thực hiện động tác đầu tiên, sau đó con mèo và người bắt nó thay phiên nhau di chuyển cho đến khi con mèo bị bắt. Số bước là số điểm cho trò chơi đó. Con mèo cố gắng để có được điểm số lớn nhất có thể, người bắt bóng cố gắng để có được điểm càng thấp càng tốt. Tổng số trung bình trên tất cả các trò chơi bạn tham gia sẽ là số điểm bạn gửi. Có hai bảng xếp hạng riêng biệt, một cho mèo, một cho người bắt.

Bộ điều khiển

Bộ điều khiển đã cho được viết bằng Java. Là một người bắt hoặc một con mèo, mỗi người phải hoàn thành một lớp Java (đã có một số ví dụ nguyên thủy) và đặt nó trong playersgói (và cập nhật danh sách các con mèo / người bắt trong lớp Trình điều khiển), nhưng bạn cũng có thể viết các chức năng bổ sung trong lớp đó. Bộ điều khiển đi kèm với mỗi hai ví dụ hoạt động của các lớp bắt / mèo đơn giản.

Trường là một mảng 11 x 112D- intlưu trữ các giá trị của trạng thái hiện tại của các ô. Nếu một ô trống, nó có giá trị 0, nếu có một con mèo thì nó có giá trị -1và nếu có một cái xô thì có a 1.

Có một số chức năng nhất định bạn có thể sử dụng: isValidMove()/ isValidPosition()là để kiểm tra xem di chuyển (con mèo) / vị trí (người bắt) của bạn có hợp lệ không.

Mỗi khi đến lượt của bạn, chức năng của bạn takeTurn()được gọi. Đối số chứa bản sao của lưới hiện tại và có các phương thức như read(i,j)để đọc ô tại (i,j), cũng như isValidMove()/ isValidPosition()kiểm tra tính hợp lệ của câu trả lời của bạn. Điều này cũng quản lý việc bao bọc cấu trúc liên kết hình xuyến, có nghĩa là ngay cả khi lưới chỉ có 11 x 11, bạn vẫn có thể truy cập vào ô (-5,13).

Phương thức sẽ trả về một intmảng gồm hai phần tử, đại diện cho các di chuyển có thể. Đối với những con mèo này là {-1,1},{0,1},{-1,0},{1,0},{0,-1},{1,-1}những vị trí đại diện cho vị trí tương đối của nơi con mèo muốn đi và người bắt trả lại tọa độ tuyệt đối của nơi chúng muốn đặt một cái xô {i,j}.

Nếu phương pháp của bạn tạo ra một động thái không hợp lệ, việc gửi của bạn sẽ bị loại. Di chuyển được coi là không hợp lệ, nếu tại điểm đến của bạn đã là một cái xô hoặc di chuyển không được phép / đích đã bị chiếm đóng (như một con mèo) hoặc nếu đã có một cái xô / con mèo (như một người bắt). Bạn có thể kiểm tra trước khi thực hiện với các chức năng nhất định.

Trình của bạn nên làm việc hợp lý nhanh chóng. Nếu phương pháp của bạn mất hơn 200ms cho mỗi bước thì nó cũng sẽ bị loại. (Tốt hơn là ít hơn nhiều ...)

Các chương trình được phép lưu trữ thông tin giữa các bước.

Đệ trình

• Bạn có thể thực hiện nhiều bài nộp như bạn muốn.
• Vui lòng không thay đổi đáng kể các bài nộp bạn đã gửi.
• Xin vui lòng mỗi bài nộp trong một câu trả lời mới.
• Mỗi bài nộp tốt nhất nên có tên duy nhất của nó.
• Việc gửi phải bao gồm mã của lớp của bạn cũng như một mô tả cho chúng tôi biết cách gửi của bạn hoạt động.
• Bạn có thể viết dòng trước <!-- language: lang-java -->mã nguồn của bạn để có được tô sáng cú pháp tự động.

Chấm điểm

Tất cả các con mèo sẽ cạnh tranh với tất cả những người bắt cùng một số lần. Tôi sẽ cố gắng cập nhật điểm số hiện tại thường xuyên, người chiến thắng sẽ được xác định khi hoạt động đã giảm.

Thử thách này được lấy cảm hứng từ trò chơi flash cũ này

Cảm ơn @PhiNotPi đã thử nghiệm và đưa ra một số phản hồi mang tính xây dựng.

Điểm hiện tại (100 trò chơi cho mỗi cặp)

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

FreeCat

Chọn cách di chuyển sẽ cung cấp cho nó các đường dẫn có thể nhất sau 3 bước nếu trường không thay đổi.

FreeCat vs Achilles:

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

Mèo của Dijkstra

Ông đã học và áp dụng thuật toán tổng thể của chủ mình. Lưu ý rằng anh ta phụ thuộc vào một số phương thức trong lớp người bắt tương ứng của mình.

Dijkstra's Cat vs Hexcatcher (cần cập nhật):

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

Cách anh ấy làm việc:

Anh ta cố gắng tìm ra động thái giảm thiểu sự nghiêm ngặt của hội đồng quản trị liên quan đến mình. Để biết thêm thông tin, xem bài đăng tương ứng.

Với bản cập nhật:

Bây giờ anh ấy tránh các hình dạng hình học kỳ lạ mà xô nước đôi khi hình thành.

MaxCat

Tôi đã thử thực hiện thuật toán Minimax. Tuy nhiên, nó không hoạt động tốt vì thời gian có hạn. Chỉnh sửa: Bây giờ nó sử dụng đa luồng, nhưng (ít nhất trên máy tính của tôi) Tôi không thể đặt độ sâu cao hơn nữa. Nếu không, thời gian chờ xảy ra. Sử dụng PC có 6 lõi trở lên, bài nộp này sẽ tốt hơn nhiều :)

MaxCat vs Dijkstra:

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

Xoắn ốc

Di chuyển một cách xoắn ốc. Nó

• Cố gắng di chuyển đến vòng tròn trên cùng bên trái
• Nếu không thể, cố gắng di chuyển đến vòng tròn trên cùng bên phải
• Nếu không thể, cố gắng di chuyển đến vòng tròn bên phải
• Nếu không thể, cố gắng di chuyển đến vòng tròn bên phải phía dưới
• Nếu không thể, cố gắng di chuyển đến vòng tròn bên trái phía dưới

Xoắn ốc vs Agamemnon:

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

RabidCat

RabidCat bị chứng sợ nước, vì vậy anh ta sợ xô nước. Anh ta tìm thấy cái gần nhất và chạy theo hướng ngược lại.

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

}

Lựa chọn

Đối với mọi vị trí mèo mới có thể, chúng tôi kiểm tra độ tốt của nó và chọn vị trí tốt nhất. Lòng tốt là chức năng của hai tế bào láng giềng tốt nhất ở xa vị trí con mèo hơn vị trí mà chúng ta tính toán. Chúng tôi chỉ sử dụng hai ô vì một ô có thể bị chặn và mèo chỉ cần một ô nữa để thoát ra. Chức năng của chúng tôi thích hai ô khá tốt hơn một ô lớn và một ô xấu. Vị trí có xô có điểm 0 và các ô tự do xa nhất có điểm 1.

ChoiceCat dường như ghi điểm tốt hơn những con mèo hiện tại.

Lựa chọn so với Lựa chọn:

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

St nguRightCat

Điều này đã được thực hiện chỉ để thử nghiệm bộ điều khiển. Con mèo di chuyển đúng bất cứ khi nào có thể, nếu không thì di chuyển theo hướng ngẫu nhiên.

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

RandCat

Điều này đã được thực hiện chỉ để thử nghiệm bộ điều khiển. Con mèo chỉ di chuyển ngẫu nhiên.

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

StraightCat

Con mèo này di chuyển thẳng.

Khi bắt đầu, nó chọn một hướng ngẫu nhiên và tiếp tục di chuyển theo hướng này cho đến khi không thể trong trường hợp đó, nó chuyển hướng theo chiều kim đồng hồ sang hướng hợp lệ tiếp theo và lặp lại quá trình này.

StraightCat vs Agamemnon:

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