এটি ডটস এবং বক্সস (ওরফে পেন দ্য পিগ) এর জন্য পার্বত্য চ্যালেঞ্জের একজন রাজা। গেমটি সহজ, আপনার পালাটি খালি বেড়াতে কেবল একটি লাইন আঁকুন। প্রতিবার আপনি একটি বর্গ সম্পূর্ণ যখন আপনি একটি পয়েন্ট পাবেন। এছাড়াও, যেহেতু আমরা চ্যাম্পিয়নশিপ বিধি দ্বারা খেলছি , আপনি যদি আপনার টার্নে কমপক্ষে একটি বর্গক্ষেত্রটি সম্পন্ন করেন তবে আপনি অতিরিক্ত পালা পেতে পারেন। এটি একটি রাউন্ড রবিন টুর্নামেন্ট, যেখানে প্রতিটি বট একটি 9x9 গ্রিডে বার ~~বার~~ 12 বার খেলে । দুটি হেভিওয়েট শিরোনামের মধ্যে এই ম্যাচটি দেখুন, যেখানে চেইনক্ল্যাক্টরর কো-চ্যাম্পিয়ন এএসডিএফের শাসনকালের মাংস তৈরি করে:

বিধি

চলাচল প্রতি 0.5 দ্বিতীয় সময় সীমা।
অন্যান্য বটগুলিতে হস্তক্ষেপ করা হচ্ছে না।
এলোমেলোতার জন্য PigPen.random () এবং PigPen.random (int) ব্যবহার করুন।
ফাইলগুলিতে কোনও লেখা নেই।
প্রতিবার প্রতিপক্ষের পরিবর্তনগুলি (প্রতি 12 টি রাউন্ড) বট এবং তার সমস্ত অবিরাম ডেটা পুনরায় সেট করা হবে।

বট

প্রতিটি বট প্লেয়ার.জভা প্রসারিত করে:

package pigpen;

public abstract class Player {

public abstract int[] pick(Board board, int id, int round); 

}

Boardগেম বোর্ড, যা মূলত আপনাকে Penক্লাসে অ্যাক্সেস দেওয়ার জন্য পরিবেশন করে , এবং idএটি আপনার প্লেয়ারআইডি (আপনি প্রথম বা দ্বিতীয় হন কিনা তা আপনাকে roundজানায় ), একই প্রতিপক্ষের বিরুদ্ধে আপনার খেলাকে (1 বা 2) গোল করে বলে tells রিটার্ন মান হ'ল একটি int[], যেখানে প্রথম উপাদানটি পেনআইডিডিড (1-ইনডেক্সড), এবং দ্বিতীয় উপাদানটি হ'ল ফেনসআইডি (0-সূচকযুক্ত)। Pen.pick(int)এই রিটার্ন মানটি উত্পন্ন করার জন্য একটি সহজ উপায় দেখুন । উদাহরণস্বরূপ খেলোয়াড় এবং জাভাডকের জন্য গিথুব পৃষ্ঠাটি দেখুন । যেহেতু আমরা কেবল একটি স্কোয়ার গ্রিড ব্যবহার করছি হেক্সাগন সম্পর্কিত কোনও ফাংশন এবং ক্ষেত্র উপেক্ষা করুন।

কিভাবে চালানো যায়

গিথুব থেকে উত্স ডাউনলোড করুন।
আপনার নিয়ামক বট লিখুন (অন্তর্ভুক্ত package pigpen.playersকরা নিশ্চিত করুন ) এবং এটি src/ফোল্ডারে রেখে দিন;
সঙ্গে সংকলন javac -cp src/* -d . src/*.java। দিয়ে চালান java pigpen.Tournament 4 9 9 false(সর্বশেষ দুটি সংখ্যা গ্রিডের আকার সমন্বয় করতে পরিবর্তন করা যেতে পারে The আপনি trueযদি পিপি_রেকর্ড সফ্টওয়্যার ব্যবহার করতে চান তবে সর্বশেষ ভেরিয়েবলটি সেট করা উচিত ))

স্কোর

চেইন সংগ্রাহক: 72
Asdf: 57
অলসবোন: 51
ফিনিশার: 36
= লিনিয়ারপ্লেয়ার: 18
= পিছনের প্লেয়ার: 18
র্যান্ডমপ্লেয়ার: 0

আরো দেখুন:

দ্রষ্টব্য : এই গেমটি প্রতিযোগিতামূলক চ্যালেঞ্জ এবং সহজেই দ্রবণযোগ্য নয়, খেলোয়াড়দের একটি বাক্স শেষ করার জন্য অতিরিক্ত মোড় দেওয়ার কারণে।

এই চ্যালেঞ্জের বিষয়ে পরামর্শের জন্য নাথান মেরিল এবং ড্যারেল হফম্যানকে ধন্যবাদ!

আপডেটগুলি :

moves(int player)কোনও খেলোয়াড়ের করা প্রতিটি পদক্ষেপের একটি তালিকা পাওয়ার জন্য বোর্ড ক্লাসে একটি পদ্ধতি যুক্ত করা হয়েছে।

অনির্দিষ্ট অনুগ্রহ (100 টি উত্তর) :

প্রথম ব্যক্তি যিনি প্রতিটি রাউন্ডে জয়যুক্ত একটি সমাধান পোস্ট করেন এবং কৌশল ব্যবহার করেন (প্রতিপক্ষ কীভাবে খেলেন তা পর্যবেক্ষণের ভিত্তিতে প্লে সামঞ্জস্য করে)।

king-of-the-hill java

— geokavel
সূত্র

2

ধার্মিকতা। ফিনিশার ওয়ায়ায়েই ওপি! : পি

— এল'েন্ডিয়া স্টারম্যান

@ এল'েন্দিয়া স্টারম্যান লল, তিনি যা কিছু করেন তা একটি বেইনের সাথে একটি কলম শেষ করে দেওয়া হয়, বা অন্যথায় বেশিরভাগ বেড়া অবশিষ্ট রেখে একটি কলম বেছে নেয়। র্যান্ডমপ্লেয়ার কেবল এলোমেলো।

— জিওকাভেল

2

হ্যাঁ আমি জানি. এটি কেবলমাত্র চূড়ান্ত স্কোরটি 79-2 এবং র্যান্ডমপ্লেয়ার কেবল শেষ দুটি বক্স পেয়েছিল কারণ এটি করতে হয়েছিল। : পি

— এল'েন্ডিয়া স্টারম্যান

হ্যালো! আমি আমার নিজের বট বানাতে চাই, তবে আমার একটি প্রশ্ন আছে। Pen.BOTTOM সারি 0 কোল 0 এ পেনের মতো একই মানগুলি ফিরে আসবে? সারি 1 কোল 0 এ টপ?

— tuskiomi

@ টাস্ক হ্যাঁ, এটি হয়

— জিওকাভেল

6

অলস ব্যক্তি

এই বটটি অলস। তিনি একটি এলোমেলো স্পট এবং দিক বেছে নেন এবং খুব বেশি অগ্রসর না হয়ে সেই দিকেই এগিয়ে চলেছেন। সেখানে কেবলমাত্র দুটি মামলা রয়েছে যেখানে তিনি কিছু আলাদা করেন:

মাত্র 1 টি বেড়া দিয়ে একটি পেগ বন্ধ করে "অর্থোপার্জন করুন"
যদি বেড়া স্থাপন সম্ভব না হয় বা অন্য বটকে "অর্থোপার্জন" করতে দেয় তবে একটি নতুন স্থান এবং দিকনির্দেশ চয়ন করুন

package pigpen.players;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import pigpen.Board;
import pigpen.Pen;
import pigpen.PigPen;
import pigpen.Player;

public class Lazybones extends Player {
    private static class Fence {
        private static boolean isOk(Board board, boolean vertical, int row, int col) {
            if (vertical) {
                Pen left = board.getPenAt(row, col - 1);
                Pen right = board.getPenAt(row, col);
                if (left.id() < 0 && right.id() < 0 ||
                        left.fences()[Pen.RIGHT] > 0 ||
                        right.fences()[Pen.LEFT] > 0 ||
                        left.remaining() == 2 ||
                        right.remaining() == 2) {
                    return false;
                }
            } else {
                Pen top = board.getPenAt(row - 1, col);
                Pen bottom = board.getPenAt(row, col);
                if (top.id() < 0 && bottom.id() < 0 ||
                        top.fences()[Pen.BOTTOM] > 0 ||
                        bottom.fences()[Pen.TOP] > 0 ||
                        top.remaining() == 2 ||
                        bottom.remaining() == 2) {
                    return false;
                }
            }
            return true;
        }

        private static Fence pickRandom(Board board) {
            List<Fence> ok = new ArrayList<>();
            List<Fence> notOk = new ArrayList<>();
            for (int row = 0; row < board.rows; row ++) {
                for (int col = 0; col < board.cols; col ++) {
                    (isOk(board, false, row, col) ? ok : notOk)
                            .add(new Fence(false, row, col));
                    (isOk(board, true, row, col) ? ok : notOk)
                            .add(new Fence(true, row, col));
                }
                (isOk(board, true, row, board.cols) ? ok : notOk)
                        .add(new Fence(true, row, board.cols));
            }
            for (int col = 0; col < board.cols; col ++) {
                (isOk(board, false, board.rows, col) ? ok : notOk)
                        .add(new Fence(false, board.rows, col));
            }
            if (ok.isEmpty()) {
                return notOk.get(PigPen.random(notOk.size()));
            } else {
                return ok.get(PigPen.random(ok.size()));
            }
        }

        private final boolean vertical;
        private final int row;
        private final int col;

        public Fence(boolean vertical, int row, int col) {
            super();
            this.vertical = vertical;
            this.row = row;
            this.col = col;
        }

        private Fence next(Board board, boolean negative) {
            int newRow = vertical ? (negative ? row - 1 : row + 1) : row;
            int newCol = vertical ? col : (negative ? col - 1 : col + 1);
            if (isOk(board, vertical, newRow, newCol)) {
                return new Fence(vertical, newRow, newCol);
            } else {
                return null;
            }
        }

        private int[] getResult(Board board) {
            if (vertical) {
                if (col < board.cols) {
                    return board.getPenAt(row, col).pick(Pen.LEFT);
                } else {
                    return board.getPenAt(row, col - 1).pick(Pen.RIGHT);
                }
            } else {
                if (row < board.rows) {
                    return board.getPenAt(row, col).pick(Pen.TOP);
                } else {
                    return board.getPenAt(row - 1, col).pick(Pen.BOTTOM);
                }
            }
        }
    }

    private Fence lastFence = null;
    private boolean negative = false;

    @Override
    public int[] pick(Board board, int id, int round) {
        List<Pen> money = board.getList().stream()
                .filter(p -> p.remaining() == 1).collect(Collectors.toList());
        if (!money.isEmpty()) {
            return money.get(PigPen.random(money.size())).pick(Pen.TOP);
        }
        if (lastFence != null) {
            lastFence = lastFence.next(board, negative);
        }
        if (lastFence == null) {
            lastFence = Fence.pickRandom(board);
            negative = PigPen.random(2) == 0;
        }
        return lastFence.getResult(board);
    }
}

— Sleafar
সূত্র

বাহ, ভাল কাজ! লাজিবোনস ফিনিশারের মালিক (নতুন অ্যানিমেশন দেখুন)।

— জিওকাভেল

যাইহোক, ঠিক তেমনি সকলেই জানেন, প্রদত্ত কলমের বামদিকে কলম পাওয়ার আরও একটি উপায় হ'ল pen.n(Pen.LEFT)(প্রতিবেশী কাজ)।

— জিওকাভেল

এছাড়াও, আমি মনে করি এটি অপ্রয়োজনীয় মনে হয় যখন আপনি কোনও কলমের নীচের বেড়া এবং নীচের অংশের উপরের বেড়াটি পরীক্ষা করেন, তাদের একই মান থাকার নিশ্চয়তা দেওয়া হয়!

— জিওকাভেল

pick()পদ্ধতি এখন একটি আছে int roundতাই যদি আপনি যে যোগ করুন পারে, শেষে প্যারামিটার।

— জিওকাভেল

আমাকে উভয় বেড়া চেক করতে হবে, কারণ কোনও কলমের বস্তু বোর্ডের বাইরে থাকতে পারে (আইডি == -1)। একই কারণে আমি প্রতিবেশীর কাজটি ব্যবহার করতে পারি না।

— স্লেফার

6

ChainCollector

এই বট চেইন ¹ পছন্দ করে । তিনি তাদের যতটা সম্ভব চান wants কখনও কখনও তিনি এমনকি একটি বড় জয়ের জন্য একটি চেইনের একটি ছোট অংশ ত্যাগ করেন।

^{[1] একটি শৃঙ্খলে খোলা বেড়া দ্বারা সংযুক্ত কলম রয়েছে, যেখানে প্রতিটি কলমে 1 বা 2 টি খোলা বেড়া রয়েছে। যদি চেইনের অন্তর্ভুক্ত কোনও একক কলম শেষ করা যায় তবে চ্যাম্পিয়নশিপের নিয়মের কারণে পুরো চেইনটিও শেষ করা যায়।}

package pigpen.players;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.TreeMap;

import pigpen.Board;
import pigpen.Pen;
import pigpen.Player;

public class ChainCollector extends Player {
    private enum Direction {
        TOP, RIGHT, BOTTOM, LEFT;

        public Direction opposite() {
            return values()[(ordinal() + 2) % 4];
        }
    }

    private enum ChainEndType {
        OPEN, CLOSED, LOOP
    }

    private static class PenEx {
        private final int id;
        private final List<Fence> openFences = new ArrayList<>();
        private boolean used = false;

        public PenEx(int id) {
            super();
            this.id = id;
        }

        public void addOpenFence(Direction direction, PenEx child) {
            openFences.add(new Fence(this, direction, child));
            if (child != null) {
                child.openFences.add(new Fence(child, direction.opposite(), this));
            }
        }
    }

    private static class Fence {
        public final PenEx parent;
        public final Direction direction;
        public final PenEx child;

        public Fence(PenEx parent, Direction direction, PenEx child) {
            super();
            this.parent = parent;
            this.direction = direction;
            this.child = child;
        }

        public int[] getMove() {
            if (parent == null) {
                return new int[] { child.id, direction.opposite().ordinal() };
            } else {
                return new int[] { parent.id, direction.ordinal() };
            }
        }
    }

    private static class Moves {
        private final TreeMap<Integer, List<Fence>> map = new TreeMap<>();

        public void add(int score, Fence move) {
            List<Fence> list = map.get(score);
            if (list == null) {
                list = new ArrayList<>();
                map.put(score, list);
            }
            list.add(move);
        }

        public boolean isEmpty() {
            return map.isEmpty();
        }

        public boolean hasExactlyOne() {
            return map.size() == 1 && map.firstEntry().getValue().size() == 1;
        }

        public int getLowestScore() {
            return map.firstKey();
        }

        public int[] getLowMove() {
            return map.firstEntry().getValue().get(0).getMove();
        }

        public int[] getHighMove() {
            return map.lastEntry().getValue().get(0).getMove();
        }
    }

    private static class BoardEx {
        private final List<PenEx> pens = new ArrayList<>();
        private final Moves neutralMoves = new Moves();
        private final Moves finisherMoves = new Moves();
        private final Moves safeFinisherMoves = new Moves();
        private final Moves sacrificeMoves = new Moves();
        private final Moves badMoves = new Moves();

        public BoardEx(Board board) {
            super();
            PenEx[][] tmp = new PenEx[board.rows][board.cols];
            for (int row = 0; row < board.rows; ++row) {
                for (int col = 0; col < board.cols; ++col) {
                    Pen pen = board.getPenAt(row, col);
                    int[] fences = pen.fences();
                    PenEx penEx = new PenEx(pen.id());
                    tmp[row][col] = penEx;
                    pens.add(penEx);
                    if (fences[Pen.TOP] == 0) {
                        penEx.addOpenFence(Direction.TOP, row == 0 ? null : tmp[row - 1][col]);
                    }
                    if (row == board.rows - 1 && fences[Pen.BOTTOM] == 0) {
                        penEx.addOpenFence(Direction.BOTTOM, null);
                    }
                    if (fences[Pen.LEFT] == 0) {
                        penEx.addOpenFence(Direction.LEFT, col == 0 ? null : tmp[row][col - 1]);
                    }
                    if (col == board.cols - 1 && fences[Pen.RIGHT] == 0) {
                        penEx.addOpenFence(Direction.RIGHT, null);
                    }
                }
            }
        }

        private ChainEndType followChain(Fence begin, List<Fence> result) {
            Fence current = begin;
            for (;;) {
                current.parent.used = true;
                result.add(current);
                if (current.child == null) {
                    return ChainEndType.OPEN;
                }
                List<Fence> childFences = current.child.openFences;
                switch (childFences.size()) {
                    case 1:
                        current.child.used = true;
                        return ChainEndType.CLOSED;
                    case 2:
                        if (current.child == begin.parent) {
                            return ChainEndType.LOOP;
                        } else {
                            current = current.direction.opposite() == childFences.get(0).direction ?
                                    childFences.get(1) : childFences.get(0);
                        }
                        break;
                    case 3:
                    case 4:
                        return ChainEndType.OPEN;
                    default:
                        throw new IllegalStateException();
                }
            }
        }

        public void findChains() {
            for (PenEx pen : pens) {
                if (!pen.used && pen.openFences.size() > 0) {
                    if (pen.openFences.size() < 3) {
                        List<Fence> fences = new ArrayList<>();
                        ChainEndType type1 = pen.openFences.size() == 1 ?
                                ChainEndType.CLOSED : followChain(pen.openFences.get(1), fences);
                        if (type1 == ChainEndType.LOOP) {
                            badMoves.add(fences.size(), fences.get(0));
                        } else {
                            Collections.reverse(fences);
                            ChainEndType type2 = followChain(pen.openFences.get(0), fences);
                            if (type1 == ChainEndType.OPEN && type2 == ChainEndType.CLOSED) {
                                type1 = ChainEndType.CLOSED;
                                type2 = ChainEndType.OPEN;
                                Collections.reverse(fences);
                            }
                            if (type1 == ChainEndType.OPEN) {
                                badMoves.add(fences.size() - 1, fences.get(fences.size() / 2));
                            } else if (type2 == ChainEndType.CLOSED) {
                                finisherMoves.add(fences.size() + 1, fences.get(0));
                                if (fences.size() == 3) {
                                    sacrificeMoves.add(fences.size() + 1, fences.get(1));
                                } else {
                                    safeFinisherMoves.add(fences.size() + 1, fences.get(0));
                                }

                            } else {
                                finisherMoves.add(fences.size(), fences.get(0));
                                if (fences.size() == 2) {
                                    sacrificeMoves.add(fences.size(), fences.get(1));
                                } else {
                                    safeFinisherMoves.add(fences.size(), fences.get(0));
                                }
                            }
                        }
                    } else {
                        pen.used = true;
                        for (Fence fence : pen.openFences) {
                            if (fence.child == null || fence.child.openFences.size() > 2) {
                                neutralMoves.add(fence.child == null ? 0 : fence.child.openFences.size(), fence);
                            }
                        }
                    }
                }
            }
        }

        public int[] bestMove() {
            if (!neutralMoves.isEmpty()) {
                if (!finisherMoves.isEmpty()) {
                    return finisherMoves.getHighMove();
                }
                return neutralMoves.getHighMove();
            }
            if (!safeFinisherMoves.isEmpty()) {
                return safeFinisherMoves.getHighMove();
            }
            if (badMoves.isEmpty() && !finisherMoves.isEmpty()) {
                return finisherMoves.getHighMove();
            }
            if (!sacrificeMoves.isEmpty()) {
                if (sacrificeMoves.hasExactlyOne()) {
                    if (badMoves.getLowestScore() - sacrificeMoves.getLowestScore() >= 2) {
                        return sacrificeMoves.getLowMove();
                    } else {
                        return finisherMoves.getHighMove();
                    }
                } else {
                    return finisherMoves.getHighMove();
                }
            }
            if (!badMoves.isEmpty()) {
                return badMoves.getLowMove();
            }
            return null;
        }
    }

    @Override
    public int[] pick(Board board, int id, int round) {
        BoardEx boardEx = new BoardEx(board);
        boardEx.findChains();
        return boardEx.bestMove();
    }
}

— Sleafar
সূত্র

বাহ, আপনার প্রবেশের জন্য আপনাকে ধন্যবাদ। আমি নিচু হয়েছি যে কেউ আমার তৈরি প্রকল্পে এত বেশি সময় ব্যয় করেছে। আমি মনে করি যে এই বটটির প্রবর্তনটি এলোমেলো সংখ্যা জেনারেশনকে প্রভাবিত করেছে, যেমন এসডিএফ এখন সামান্য ব্যবধানে লাজিবোনকে দু'বার পরাজিত করে।

— জিওকাভেল

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

— স্লেফার

ভালো চিন্তা. আমি প্রতি ম্যাচআপে এটি 12 টি রাউন্ডে বাড়িয়েছি এবং এখন আপনি যেমন দেখতে পাচ্ছেন Asdf এর সামান্য প্রান্ত রয়েছে। এমনকি 100 রাউন্ডেও এটি লাজিবোনসের চেয়ে 13 টি বেশি গেম জিতেছে।

— জোকোভেল

3

চরম আঘাত

package pigpen.players;

import pigpen.*;

import java.util.*;

/**
 * Picks a Pen with only one fence remaining. 
 * Otherwise picks one with the most fences remaining
 */
public class Finisher extends Player implements Comparator<Pen> {


  public int[] pick(Board board, int id) {
     return Collections.max(board.getList(),this).pick(Pen.TOP);

  }

  @Override
  public int compare(Pen p1, Pen p2) {
    //1 remaining is best, all remaining is second.
    int r1 = p1.remaining();
    int r2 = p2.remaining();
    if(r1 == 1) r1 = 7;
    if(r2 == 1) r2 = 7;
    return Integer.compare(r1,r2);
 }


}

সর্বাধিক উপলভ্য বেড়া দিয়ে কলম বেছে নিতে তুলনাকারী ব্যবহার করে, তবে কেবল 1 টি বেড়া পাওয়া পেনের সাথে অগ্রাধিকার দেয়। (এই কোডটি হেক্সাগন মোডে কাজ করার অনুমতি দেওয়ার জন্য 5 টির পরিবর্তে 7 টি ব্যবহৃত হয়)

— geokavel
সূত্র

3

asdf

প্রতিটি বেড়াতে একটি স্কোর বরাদ্দ করে এবং তারপরে সেরাটিকে বাছাই করে। উদাহরণস্বরূপ: একটি খোলা বেড়ার সাথে একটি কলমের স্কোর 10 হয়, 2 টি খোলা বেড়ার সাথে একটি কলমের স্কোর -8 হয়।

দেখে মনে হচ্ছে লেজিবোনস একই রকম কৌশল ব্যবহার করে, কারণ এটি এই বটের সাথে সম্পর্কযুক্ত।

package pigpen.players;

import java.util.*;
import pigpen.*;

public class Asdf extends Player {
    private final List<Score> scores = new ArrayList<>();

    @Override
    public int[] pick(Board board, int id, int round) {
        scores.clear();
        List<Pen> pens = board.getList();

        pens.stream().filter(x -> !x.closed()).forEach((Pen p) -> evaluate(p));
        Optional<Score> best = scores.stream().max(Comparator.comparingInt(p -> p.points));

        if (best.isPresent()) {
            Score score = best.get();
            return score.pen.pick(score.fence);
        }
        return null;
    }

    private void evaluate(Pen pen) {
        int[] fences = pen.fences();
        for (int i = 0; i < fences.length; i++) {
            if (fences[i] == 0) {
                int points = getPoints(pen);
                Pen neighbour = pen.n(i);
                if (neighbour.id() != -1) {
                    points += getPoints(neighbour);
                }
                scores.add(new Score(pen, i, points));
            }
        }
    }

    private int getPoints(Pen pen) {
        switch (pen.remaining()) {
            case 1: return 10;
            case 2: return -1;
            case 3: return 1;
        }
        return 0;
    }

    class Score {
        private Pen pen;
        private int fence;
        private int points;

        Score(Pen pen, int fence, int points) {
            this.pen = pen;
            this.fence = fence;
            this.points = points;
        }
    }
}

— CommonGuy
সূত্র

এখানে স্কোর। এটি আকর্ষণীয় যে যে দ্বিতীয় হয় সে দ্বিগুণ পয়েন্ট পায়। অ্যাসডিএফ বনাম লাজিবোনস: 27 - 54; লাজিবোনস বনাম এএসডিএফ: 27 - 54

— জিওকাভেল

@ জোকাভেল হ্যাঁ, কারণ তখন বটগুলি "খারাপ মোড়" করতে বাধ্য হয়, যাতে প্রতিপক্ষ কোনও কলম বন্ধ করতে পারে।

— কমনগ্যুই

তাহলে কি এটিই সবচেয়ে ভাল সম্ভব অ্যালগরিদম?

— justhalf

@ আসরফাল্ফ এটি নয়, কারণ চ্যাম্পিয়নশিপে লোকেরা এই খেলাটি খেলে। আমি মনে করি এই অ্যালগরিদমগুলি অবশ্যই প্রসারিত হতে পারে। আরও তথ্যের জন্য আমি সরবরাহ করা লিঙ্কগুলি দেখুন।

— জিওকাভেল

0

LinearPlayer

package pigpen.players;

import pigpen.*;

/**
 * Picks the first available fence in the first available Pen
 */ 
public class LinearPlayer extends Player {


@Override
public int[] pick(Board board, int id) {
    for(int p = 1;p<=board.size;p++) {
        Pen pen = board.get(p);
            if(!pen.closed()) {
                int[] fences = pen.fences();
                    for(int i =0;i<fences.length;i++) {
                        if(fences[i] == 0) {
                            return new int[]{pen.id(),i};
                        }
                    }
                }
        }
    return new int[]{1,0};
    } 
}

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

— geokavel
সূত্র

0

BackwardPlayer

package pigpen.players;

import pigpen.*;

/**
 * Picks the first available fence in the last available Pen
 */
 public class BackwardPlayer extends Player {

public int[] pick(Board board, int id) {
    for(int i = board.size;i>0;i--) {
        Pen p = board.get(i);
        if(!p.closed()) {
            return p.pick(Pen.TOP);
        }
    }
    return new int[] {1,0};
}
}

এই কোডটি শর্টকাট পদ্ধতিটি Pen.pick(int)ফেরতের মান উত্পন্ন করতে ব্যবহার করে । উপরের বেড়াটি যদি অনুপলব্ধ থাকে তবে এটি ঘড়ির কাঁটার দিকে নিকটতম উপলব্ধ বেড়াটি বেছে নেবে।

— geokavel
সূত্র

0

RandomPlayer

package pigpen.players;

import pigpen.*;


/** 
 * Picks the first available fence in a random Pen 
 */
public class RandomPlayer extends Player {
    public int[] pick(Board board, int id) {
        int pen = PigPen.random(board.size)+1;
        return board.get(pen).pick(Pen.TOP);
    }
}

ব্যাকওয়ার্ডপ্লেয়ার হিসাবে একই ধারণা, কিন্তু এলোমেলোভাবে একটি কলম নির্বাচন করে। নোট করুন +1কারণ পেনগুলি 1-সূচকযুক্ত।

— geokavel
সূত্র

রাজা-পেন! (বিন্দু এবং বাক্স)

বিধি

বট

কিভাবে চালানো যায়

স্কোর

আরো দেখুন:

অনির্দিষ্ট অনুগ্রহ (100 টি উত্তর) :

অলস ব্যক্তি

ChainCollector

চরম আঘাত

asdf

LinearPlayer

BackwardPlayer

RandomPlayer