অসম কৌতুক: বিড়াল ধরুন (ক্যাচার থ্রেড)

17

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

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

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

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

এটি একটি অপ্রতিসম 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}।

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

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

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

জমা

  • আপনি চান যতগুলি জমা দিতে পারেন।
  • আপনি ইতিমধ্যে জমা দেওয়া জমাগুলি উল্লেখযোগ্যভাবে পরিবর্তন করবেন না দয়া করে।
  • প্রতিটি উত্তর জমা দিন দয়া করে একটি নতুন উত্তরে।
  • প্রতিটি জমা দেওয়ার পক্ষে এটির অনন্য নামটি থাকতে হবে।
  • জমা দেওয়ার ক্ষেত্রে আপনার শ্রেণীর কোড এবং সেই সাথে একটি বিবরণ থাকতে হবে যা আমাদের জমা দেয় কীভাবে আমাদের জানায় tells
  • <!-- language: lang-java -->স্বয়ংক্রিয় সিনট্যাক্স হাইলাইট করার জন্য আপনি আপনার সোর্সকোডের জন্য লাইনটি লিখতে পারেন ।

স্কোরিং

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

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

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

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

Name              Score      Rank   Author

RandCatcher       191674     8      flawr   
StupidFill        214246     9      flawr
Achilles          76820      6      The E
Agamemnon         74844      5      The E
CloseCatcher      54920      4      randomra
ForwordCatcher    94246      7      MegaTom  
Dijkstra          46500      2      TheNumberOne
HexCatcher        48832      3      randomra
ChoiceCatcher     43828      1      randomra

RandCat           77928      7      flawr
StupidRightCat    81794      6      flawr
SpiralCat         93868      5      CoolGuy
StraightCat       82452      9      CoolGuy
FreeCat           106304     3      randomra
RabidCat          77770      8      cain
Dijkstra's Cat    114670     1      TheNumberOne
MaxCat            97768      4      Manu
ChoiceCat         113356     2      randomra
king-of-the-hill  java  hexagonal-grid 
— flawr
সূত্র
কি প্রোগ্রাম অ্যানিমেশন করে তোলে?
— মেগাটম
অ্যানিমেশনটি কেবল জিইউআই ( PRINT_STEPS = trueফাইলের আরও বিশদ সেটিংস সেট করতে হবে এমন নিয়ামক শুরু করার সময় MyFrame.java)। তারপরে আমি এটি লিসেক্যাপ দিয়ে রেকর্ড করেছি এবং এটি জিআইএমপি-র সাথে সম্পাদনা করেছি । আপনার যদি আরও প্রশ্ন থাকে তবে জিজ্ঞাসা করুন!
— flawr
আপনি যদি নিয়ামকটিতে ব্যবহারকারী ইনপুট যুক্ত করেন তবে এটি জিইউআই এবং ইতিমধ্যে লিখিত বটগুলির সাথে একটি দুর্দান্ত সফ্টওয়্যার তৈরি করতে পারে। এটি দেখতে আকর্ষণীয় হবে যে নির্দিষ্ট বট কৌশলগুলি কীভাবে মানুষ ক্র্যাক / অপব্যবহার করতে পারে।
— এলোমেলো
এছাড়াও, আমার বট কি একই বটের বিপরীতে আরও ভাল মুভ-সিকোয়েন্স সন্ধানের জন্য আগের ম্যাচ থেকে তথ্য রাখতে পারে? আমি মনে করি না কারণ এটি আপনার আরও বেশি গোল করে। এটি কোনও নতুন বটের বিরুদ্ধে খেলছে কিনা তাও অনুমান করতে হবে, তাই চলমান ক্রমটিও গুরুত্বপূর্ণ matter
— এলোমেলো
1
বিড়ালদের স্কোরগুলি কেন অর্ডার দেওয়া হয়নি?
— স্পিক্যাট্রিক্স

উত্তর:

6

অ্যাকিলিস

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

অ্যাকিলিস বনাম র্যান্ডটেকশন

র্যান্ডক্যাট বনাম অচিলিস

package players;
/**
 * @author The E
 */
import main.*;



public class Achilles implements Catcher
{
    public Achilles() {

    }
    @Override
    public String getName() {

        return "Achilles";
    }

    @Override
    public int[] takeTurn(Field f) {
        try{
        if(f.read(0, f.SIZE-1)!=Field.BUCKET)
        {
            //Make the first line

            for(int j = 0; j<f.SIZE; j++)
            {
                if(f.read(0, j) == Field.EMPTY)
                {
                    return new int[]{0,j};
                }
            }
            return WasteGo(f);

        }
        else if (f.read(f.SIZE-1, 0)!=Field.BUCKET)
        {
            //Make the second line
            for(int i = 0; i<f.SIZE; i++)
            {
                if(f.read(i, 0) == Field.EMPTY)
                {
                    return new int[]{i,0};
                }
            }
            //The cat got in the way
            for(int j = 0; j<f.SIZE; j++)
            {
                if(f.read(1, j) == Field.EMPTY)
                {
                    return new int[]{1,j};
                }
            }
            return WasteGo(f);
        }
        else
        {
            return TrapCat(1,1,f.SIZE-1, f.SIZE-1, false, f);

        }
        }
        catch (Exception e)
        {
            return WasteGo(f);
        }
    }
    private int[] TrapCat(int i1, int j1, int i2, int j2, Boolean direction, Field f) {
        for(int a = 0; a<f.SIZE+10; a++)
        {
            if(direction)
            {

                int height = j2-j1+1;
                int row = j1 + height/2;
                for(int i = i1; i<=i2; i++)
                {
                    if(f.read(i, row)==Field.EMPTY)
                    {
                        return new int[]{i,row};
                    }
                }

                    //Done that Row
                    //Find cat
                    if(f.findCat()[1]>row)
                    {
                        //he's above the line
                        j1 = row+1;
                        direction = !direction;
                        //return TrapCat(i1, row+1, i2, j2, !direction, f);
                    }
                    else
                    {
                        //he's below the line
                        j2 = row - 1;
                        direction = !direction;
                        //return TrapCat(i1, j1, i2, row-1, !direction, f);
                    }


            }
            else
            {
                int bredth = i2-i1+1;
                int column = i1 + bredth/2;
                //Continue making the line
                for(int j = j1; j<=j2; j++)
                {
                    if(f.read(column,j)==Field.EMPTY)
                    {
                        return new int[]{column,j};
                    }
                }

                    //Done that Column
                    //Find cat
                    if(f.findCat()[0]>column)
                    {
                        //he's right of the line
                        i1 = column + 1;
                        direction = !direction;
                        //return TrapCat(column+1, j1, i2, j2, !direction, f);
                    }
                    else
                    {
                        //he's left of the line
                        i2 = column -1;
                        direction = !direction;
                        //return TrapCat(i1, j1, column-1, j2, !direction, f);
                    }

            }
        }
        return WasteGo(f);
    }
    private int[] WasteGo(Field f) {
        for (int i = 0; i<f.SIZE;i++)
        {
            for(int j=0;j<f.SIZE;j++)
            {
                if(f.read(i,j)==Field.EMPTY)
                {
                    return new int[]{i,j};
                }
            }
        }
        //Something drastic happened
        return new int[]{0,0};
    }



}
— euanjt
সূত্র
আচ্ছা এটি এখন কোনটি, অ্যাকিলিস না হেক্টর? (বা বিচ্ছিন্ন পরিচয়জনিত ব্যাধিযুক্ত কেউ? =)
— 15-15
@ ফ্লাওয়ার অ্যাকিলিস, আমি অর্ধেক পথটির মাধ্যমে নামটি পরিবর্তন করেছি (ক্যাচারার অ্যাকিলিস এবং বিড়াল হেক্টরের নামকরণ করা আরও ভাল) তবে জাভা পরিবর্তন করতে ভুলে গেছেন - আপনি যখন চায়ের পরে প্রোগ্রাম করবেন তখন কি হয় :(
— ইউয়ানজট
তবে হেক্টর বরং কুকুরের নাম হবে =) আপনার জমা দেওয়ার জন্য ধন্যবাদ Thanks আমি আশা করি আপনি কিছু মনে করবেন না যে আমি আপনার কোডটিতে 'উপস্থাপক' অন্তর্ভুক্ত করেছি।
— flawr
হ্যাঁ সমস্যা নেই। হেক্টর কুকুরের নামের মতো শোনাচ্ছে ...
— ই
আমি কেবল একটি সিমুলেশন চালিয়েছি (প্রতিটি জুটির জন্য 10000 গেমস) এবং অ্যাকিলিসকে অযোগ্য ঘোষণা করা হয়েছিল, বারবার স্ট্যাকওভারফ্লো এররের কারণে। আমার মনে হয় পুনরাবৃত্তিটি শেষ হয়নি: পেস্টবিন.
— com
5

অ্যাগামেনন

আগামেমনন বিড়ালদের অঞ্চলটিকে একটি উল্লম্ব রেখার সাথে অর্ধেকভাগে বিচ্ছিন্ন করে দেয় যতক্ষণ না বিড়ালটির ভিতরে যাওয়ার জন্য কেবল প্রস্থের 2 প্রস্থের একটি স্ট্রিপ থাকে, যেখানে সে বিড়ালটিকে আটকে দেয়।

র‌্যাডট্যাগ বনাম আগামেমনন:

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

package players;
/**
 * @author The E
 */
import main.*;



    public class Agamemnon implements Catcher {
        boolean up = true;
        @Override
        public String getName() {
            return "Agamemnon";
        }

        @Override
        public int[] takeTurn(Field f) {
            //First Make Line in column 1
            for(int j = 0; j<f.SIZE; j++)
            {
                if(f.read(0, j)==Field.EMPTY)
                {
                    return new int[]{0,j};
                }
            }
            //Then in column SIZE/2
            for(int j = 0; j<f.SIZE; j++)
            {
                if(f.read(f.SIZE/2, j)==Field.EMPTY)
                {
                    return new int[]{f.SIZE/2,j};
                }
            }
            //Then work out where the cat is
            int left, right;
            int cati = f.findCat()[0];
            if(cati<f.SIZE/2)
            {
                left = 1;
                right = f.SIZE/2-1;
            }
            else
            {
                left = f.SIZE/2+1;
                right = f.SIZE-1;
            }
            while(right-left>1)
            {
                //If the cat is not in a two width column
                //Split the area the cat is in in half
                int middleColumn = (left+right)/2;
                for(int j = 0; j<f.SIZE; j++)
                {
                    if(f.read(middleColumn, j)==Field.EMPTY)
                    {
                        return new int[]{middleColumn,j};
                    }
                }
                //If we got here we had finished that column
                //So update left and/or right
                if(cati<middleColumn)
                {
                    //he's left of the middle Column
                    right = middleColumn - 1;
                }
                else
                {
                    //he's right of the middle Column
                    left = middleColumn+1;
                }
                //Repeat
            }
            //Otherwise try to trap the cat
            //Make a line up and down on the opposite side of the cat
            int catj = f.findCat()[1];
            if(left!=right){
                if(cati==left)
                {
                    if(f.read(right, catj)==Field.EMPTY)
                    {
                        return new int[]{right, catj};
                    }
                    if(f.read(right, catj-1)==Field.EMPTY)
                    {
                        return new int[]{right, catj-1};
                    }
                    if(f.read(right, catj+1)==Field.EMPTY)
                    {
                        return new int[]{right, catj+1};
                    }


                }
                else
                {
                    if(f.read(left, catj)==Field.EMPTY)
                    {
                        return new int[]{left, catj};
                    }
                    if(f.read(left, catj-1)==Field.EMPTY)
                    {
                        return new int[]{left, catj-1};
                    }
                    if(f.read(left, catj+1)==Field.EMPTY)
                    {
                        return new int[]{left, catj+1};
                    }

                }
            }
            //Alternate between above and below
            if(up)
            {
                up = !up;
                if(f.read(cati, catj+1)==Field.EMPTY)
                {

                    return new int[]{cati, catj+1};
                }
            }
            up = !up;
            if(f.read(cati, catj-1)==Field.EMPTY)
            {

                return new int[]{cati, catj-1};
            }
            return WasteGo(f);
        }

        private int[] WasteGo(Field f) {
            for (int i = 0; i<f.SIZE;i++)
            {
                for(int j=0;j<f.SIZE;j++)
                {
                    if(f.read(i,j)==Field.EMPTY)
                    {
                        return new int[]{i,j};
                    }
                }
            }
            //Something drastic happened
            return new int[]{0,0};
        }
    }

এই ক্যাচারটি অ্যাকিলিসের চেয়ে ধারাবাহিকভাবে আরও ভালভাবে কাজ করে এবং আমার কাছে মনে হয় যে তিনি একটি নতুন উত্তর পাওয়ার জন্য যথেষ্ট আলাদা।

— euanjt
সূত্র
খুব সুন্দর সমাধান, আমি নিশ্চিত যে অ্যাকিলিস সর্বোত্তমের কাছাকাছি ছিল, তবে এখন আমি মনে করি এমনকি
— আগামেমননও
হ্যাঁ, আগামেমননের অ্যাকিলিসের তুলনায় আরও ভাল একটি শেষ গেম জালিয়াতি রয়েছে, তবে আমি নিশ্চিত যে কিছু টুইট রয়েছে ... এখন আমি চেষ্টা করব এবং একটি বিড়ালের উপর কাজ করব :)
— ইউয়ানজট
@ ফ্লাওয়ার খুব ক্ষুদ্র ক্ষুদ্রতর টুইটগুলি বিশেষ কিছু ক্ষেত্রে ধরা দ্রুত বাড়ানোর জন্য যুক্ত করেছে, এটি এখানে অ্যানিমেশনটিকে প্রভাবিত করে না (যদিও আমি মনে করি এটি সর্পিলগ্রিকের অ্যানিমেশনকে প্রভাবিত করতে পারে)
— ইউএনজট
প্রশ্ন! আপনি যদি একটি লাইন বন্ধ করতে চলেছেন তবে কি হবে তবে বিড়ালটি শেষ স্পটে দাঁড়িয়ে আছে?
— মিঃ লামা
@ মিঃল্লামা এটি পরবর্তী লাইনটি তৈরি করা শুরু করলেন যেন line লাইনটি ভরাট হয়ে গিয়েছিল (যেমন, বিড়ালটি আসলে একটি বালতি ছিল) - কোনও মোড়ের সর্বাধিক কার্যকর ব্যবহার নয় তবে খুব কমই ঘটে যে এটি সত্যিই গুরুত্ব দেয় না - বিড়ালটিকে তার পরের দিকে ঘুরতে হবে যাতে আমি আমার বালতিটি সেখানে রাখতে পারি
— ইউনজট
5

HexCatcher

যদি ক্যাচারটি 3 টি ইউনিটের পাশের একটি বৃহত ষড়্ভাগরের অভ্যন্তরে বিড়ালটি পেতে পারে যেখানে ষড়্ভুজের কোণগুলি ইতিমধ্যে বালতি দ্বারা দখল করা হয়েছে, তবে ক্যাচার এই বিড়ালটিকে এই অঞ্চলে রাখতে পারে এবং তাকে ধরে ফেলতে পারে। ষড়ভুজটি দেখতে এরকম দেখাচ্ছে:

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

এটি হেক্সগ্যাচার অর্জন করার চেষ্টা করে। এটি মানসিকভাবে এই বড় ষড়কোণগুলির সাথে ক্ষেত্রটিকে এমনভাবে টাইল করে দেয় যে প্রতিটি কোণার ঘরটি 3 টি বড় ষড়যন্ত্রের অংশ।

যদি বিড়ালের পাশে দুটি কোণকে সংযুক্ত করে বর্তমান অঞ্চলে বিড়ালটিকে রাখার সুযোগ থাকে তবে বটটি তা করবে। (উদাহরণস্বরূপ, বিড়ালটি যদি 7,5 এ থাকে তবে আমরা 6,6 এবং 8,5 কোষ এখনও দখল করে থাকলেও আমরা 7,6 বেছে নিই))

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

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

হিজটেকচার বনাম ডিজকস্ট্রাসগেট:

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

package players;
/**
 * @author randomra
 */
import main.Field;

public class HexCatcher implements Catcher {
    public String getName() {
        return "HexCatcher";
    }

    final int[][] o = { { -1, 1 }, { 0, 1 }, { -1, 0 }, { 1, 0 }, { 0, -1 },
            { 1, -1 } };// all valid moves
    final int[][] t = { { -2, 2 }, { 0, 2 }, { -2, 0 }, { 2, 0 }, { 0, -2 },
            { 2, -2 } };// all valid double moves in one direction
    final int[][] h = { { -1, 2 }, { -2, 1 }, { -1, -1 }, { 1, -2 }, { 2, -1 },
            { 1, 1 } };// all valid moves in not one direction
    int opp = 0;

    public int[] takeTurn(Field f) {
        int[] p = f.findCat();
        // center of the hexagon the cat is in
        int[] c = { ((int) p[0] / 3) * 3 + 1, ((int) p[1] / 3) * 3 + 1 };
        // change priority of catching direction at every turn
        opp = 1 - opp;

        // check missing corner piece next to cat
        for (int i = 0; i < 6; i++) {
            int ind = (i + opp * 3) % 6;
            boolean close = false;
            for (int k = 0; k < 6; k++) {
                if (c[0] + h[ind][0] == p[0] + o[k][0]
                        && c[1] + h[ind][1] == p[1] + o[k][1]) {
                    close = true;
                }
            }
            if (f.read(c[0] + h[ind][0], c[1] + h[ind][1]) == 0 && close) {
                return new int[] { c[0] + h[ind][0], c[1] + h[ind][1] };
            }
        }
        // cut off escape route if needed
        for (int i = 0; i < 6; i++) {
            int ind = (i + opp * 3) % 6;
            if (f.read(c[0] + o[ind][0], c[1] + o[ind][1]) == -1
                    && f.read(c[0] + t[ind][0], c[1] + t[ind][1]) == 0) {
                return new int[] { c[0] + t[ind][0], c[1] + t[ind][1] };
            }
        }
        // check any missing corner piece in the area
        for (int i = 0; i < 6; i++) {
            int ind = (i + opp * 3) % 6;
            if (f.read(c[0] + h[ind][0], c[1] + h[ind][1]) == 0) {
                return new int[] { c[0] + h[ind][0], c[1] + h[ind][1] };
            }
        }
        // choose an empty cell next to the cat
        for (int i = 0; i < 6; i++) {
            int ind = (i + opp * 3) % 6;
            if (f.read(p[0] + o[ind][0], p[1] + o[ind][1]) == 0) {
                return new int[] { p[0] + o[ind][0], p[1] + o[ind][1] };
            }
        }
        return null;
    }
}
— randomra
সূত্র
3

CloseCatcher

বিড়াল পরবর্তী পদক্ষেপে যেতে পারে এমন একটি অবস্থান বেছে নেয় Ch এটি এমন একটিটিকে বেছে নেয় যা বিড়ালের পক্ষে 3 টি পদক্ষেপের পরে সবচেয়ে সম্ভাব্য পাথ দেয় যদি এটি সেখানে চলে যায় এবং ক্ষেত্রটি পরিবর্তিত হয় না।

কোডটি আমার ক্যাট এন্ট্রি, ফ্রিটিকের সাথে প্রায় একই রকম , যা দিকটি খুব অনুরূপভাবে পছন্দ করে।

সর্পিলকিট বনাম ক্লোজগ্যাচার:

সর্পিলগেট বনাম ক্লোজগ্যাচার

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

import main.Field;
import java.util.Arrays;

public class CloseCatcher implements Catcher {
    public String getName() {
        return "CloseCatcher";
    }

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

    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;
            }
        }
        int[] bestPos = { pos[0] + bestMove[0], pos[1] + bestMove[1] };
        return bestPos;
    }

    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
সূত্র
ভাল +1। CloseCatcher সহজে ধারন StraightCat
— Spikatrix
3

Dijkstra

তিনি বিড়ালদের খুব পছন্দ করেন না (:v{ >

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

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

package players;

import main.Controller;
import main.Field;

import java.util.*;

/**
 * @author TheNumberOne
 *
 * Catches the cat.
 */

public class Dijkstra implements Catcher{

    private static final int[][][] CACHE;

    static {
        CACHE = new int[Controller.FIELD_SIZE][Controller.FIELD_SIZE][2];
        for (int x = 0; x < Controller.FIELD_SIZE; x++){
            for (int y = 0; y < Controller.FIELD_SIZE; y++){
                CACHE[x][y] = new int[]{x,y};
            }
        }
    }

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

    @Override
    public int[] takeTurn(Field f) {
        long startTime = System.nanoTime();

        final int[] theCat = f.findCat();
        int[] bestMove = {-1,1};
        int[] bestOpenness = {Integer.MAX_VALUE, 0};
        List<int[]> possiblePositions = new ArrayList<>();
        for (int x = 0; x < 11; x++){
            for (int y = 0; y < 11; y++){
                int[] pos = {x,y};
                if (f.isValidPosition(pos)){
                    possiblePositions.add(pos);
                }
            }
        }
        Collections.sort(possiblePositions, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return distance(o1, theCat) - distance(o2, theCat);
            }
        });
        for (int i = 0; i < possiblePositions.size() && System.nanoTime() - startTime < Controller.MAX_TURN_TIME/2; i++){
            int[] pos = possiblePositions.get(i);
            int before = f.field[pos[0]][pos[1]];
            f.placeBucket(pos);
            int[] openness = openness(theCat, f, true);
            if (openness[0] < bestOpenness[0] ||
                    (openness[0] == bestOpenness[0] &&
                            (openness[1] > bestOpenness[1])
                    )
                    ){
                bestOpenness = openness;
                bestMove = pos;
            }
            f.field[pos[0]][pos[1]] = before;
        }
        return bestMove;
    }


    /**
     *
     * @param pos The pos to calculate the openness of.
     * @param f The field to use.
     * @return Two integers. The first integer represents the number of reachable hexagons.
     * The second integer represents how strung out the squares are relative to the pos.
     */
    public static int[] openness(int[] pos, Field f, boolean catZeroWeight){
        Map<int[], Integer> lengths = new HashMap<>();
        PriorityQueue<int[]> open = new PriorityQueue<>(10,new Comparator<int[]>() {
            Map<int[], Integer> lengths;
            @Override
            public int compare(int[] o1, int[] o2) {
                return lengths.get(o1) - lengths.get(o2);
            }
            public Comparator<int[]> init(Map<int[], Integer> lengths){
                this.lengths = lengths;
                return this;
            }
        }.init(lengths));
        Set<int[]> closed = new HashSet<>();
        lengths.put(pos, catZeroWeight ? 0 : 6 - pointsAround(pos, f).size());
        open.add(pos);
        while (open.size() > 0){
            int[] top = open.remove();
            if (closed.contains(top)){
                continue;
            }
            closed.add(top);
            int l = lengths.get(top);
            List<int[]> pointsAround = pointsAround(top, f);

            for (ListIterator<int[]> iter = pointsAround.listIterator(); iter.hasNext();){
                int[] point = iter.next();
                if (closed.contains(point)){
                    iter.remove();
                }
            }

            for (int[] p : pointsAround){
                int length = l + 7 - pointsAround(p, f).size();
                if (lengths.containsKey(p)){
                    length = Math.min(length, lengths.get(p));
                }
                lengths.put(p, length);
                open.add(p);
            }
        }
        int sum = 0;
        for (int integer : lengths.values()){
            sum += integer;
        }
        return new int[]{lengths.size(),sum};
    }

    public static int distance(int[] p1, int[] p2){
        p2 = Arrays.copyOf(p2, 2);
        while (p2[0] < p1[0]){
            p2[0] += 11;
        }
        while (p2[1] < p2[0]){
            p2[1] += 11;
        }
        int lowestDistance = 0;
        for (int dx = 0; dx == 0; dx -= 11){
            for (int dy = 0; dy == 0; dy -= 11){
                lowestDistance = Math.min(lowestDistance,Math.min(Math.abs(p1[0]-p2[0]-dx),Math.min(Math.abs(p1[1]-p2[1]-dy),Math.abs(p1[0]+p1[1]-p2[0]-dx-p2[1]-dy))));
            }
        }
        return Math.min(Math.abs(p1[0]-p2[0]),Math.min(Math.abs(p1[1]-p2[1]),Math.abs(p1[0]+p1[1]-p2[0]-p2[1])));
    }

    public static int[] normalize(int[] p){
        return CACHE[(p[0]%11+11)%11][(p[1]%11+11)%11];
    }

    public static List<int[]> pointsAround(int[] p, Field f){
        int[] cat = f.findCat();
        List<int[]> locations = new ArrayList<>();
        for (int[] move : possibleMoves){
            int[] location = normalize(new int[]{p[0]+move[0], p[1] + move[1]});
            if (f.isValidPosition(location) || Arrays.equals(cat, location)){
                locations.add(location);
            }
        }
        return locations;
    }
}

তিনি কীভাবে বিড়ালটিকে ধরার চেষ্টা করছেন:

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

অকপটতা:

কোনও পজিশনের তুলনায় বোর্ডের উন্মুক্ততা হল সেই অবস্থান থেকে পৌঁছনীয় পজিশনের সংখ্যা।

Stringiness:

কোনও পজিশনের তুলনায় বোর্ডের স্ট্রাইনেসটি হ'ল পৌঁছনীয় অবস্থান এবং অবস্থানের মধ্যে দূরত্বগুলির যোগফল।

শেষ আপডেট সহ:

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

বাগ সংশোধন করা হয়েছে.

— এক নম্বর
সূত্র
এটি এ পর্যন্ত কাজ করে তা নিশ্চিত করতে পারে তবে এখন পর্যন্ত সবচেয়ে ধীর তবে এ পর্যন্ত অন্যতম সেরা আমি মনে করি। মোট 4406 পদক্ষেপের সময় র্যান্ডটিকের বিরুদ্ধে 100 গেমের জন্য 134 সেকেন্ডের প্রয়োজন! আমি মনে করি পরের কোনও একটিতে আমার পিসি রাতারাতি চালিয়ে যেতে হবে ... এটি কীভাবে কাজ করে তা সম্পর্কে কিছুটা বলতে পারেন?
— flawr
@ ফ্লোয়ার একটি বিবরণ যুক্ত করেছেন।
— দ্য নাম্বারওন
তবুও আমার পক্ষে কাজ করে না। আমাকে একটি ত্রুটি দেয়: error: cannot infer type arguments for PriorityQueue<>এই লাইনে PriorityQueue<int[]> open = new PriorityQueue<>(new Comparator<int[]>() {।
— স্পিক্যাট্রিক্স
@ কুলগুই আপনি জাভা 6 ব্যবহার করছেন? আমার মনে হয় আপনার জেডিকে আপডেট করা দরকার।
— TheNumberOne
কুলগুই আপনি int[]পরে দুটি খালি হীরার মধ্যে একটি রাখতে পারেন PriorityQueue।
— TheNumberOne
2

ForwordCatcher

বিড়ালের সামনে একটি বালতি রাখুন, বা যদি তা নেওয়া হয় তবে পিছনে রাখুন।

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

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

package players;

import main.Field;
import java.util.Arrays;

public class ForwordCatcher implements Catcher {
    public String getName() {
        return "ForwordCatcher";
    }

    private int[] lastPos = {0,0};

    public int[] takeTurn(Field f) {
        int[] temp = lastPos;
        int[] pos = f.findCat();
        lastPos = pos;
        int[] Move = {pos[0]*2-temp[0], pos[1]*2-temp[1]};
        if(f.isValidPosition(Move)){return Move;}
        if(f.isValidPosition(temp)){return temp;}
        Move[0] = pos[0];Move[1] = pos[1]+1;
        return Move;
    }
}
— MegaTom
সূত্র
1
বেশ কয়েকটি ত্রুটি রয়েছে, যা আমাকে এই ধারণার দিকে নিয়ে যায় যে আপনি আপনার প্রোগ্রামটি পরীক্ষা করেন নি। দয়া করে সেগুলি ঠিক করুন ...
— flawr
@ ফ্লোয়ার স্থির ত্রুটিগুলি সম্পর্কে দুঃখিত। আমি এটি পরীক্ষা করিনি এবং আমার জাভা ভাল হয় না।
— মেগাটম
সুন্দর, এখনও অবধি সবকিছু দ্রুত চালিত হয় তবে আমি এখনও নিশ্চিত নই যে এটি সর্বদা বৈধ পদক্ষেপ তৈরি করবে কিনা =)
— flawr
1
@ ফ্লোয়ার একটি বিড়ালের পিছনের স্থানটি ক্যাচারের জন্য সর্বদা খালি থাকবে :)
— TheNumberOne
2

ChoiceCatcher

আমার চয়েজগেট এন্ট্রি হিসাবে একই স্কোরিং প্রক্রিয়া ব্যবহার করে । একটি সামান্য পরিবর্তন আছে যা প্রথম কয়েকটি পদক্ষেপে প্রাসঙ্গিক কক্ষগুলি নির্বাচন করতে সহায়তা করে কারণ চয়েসকিট প্রথম কয়েকটি বালতি তাদের যত্ন করে না কারণ এটি হুমকি হিসাবে দেখেনি।

চয়েস গুগল বর্তমান ক্যাচারদের থেকে যথেষ্ট ভাল স্কোর বলে মনে হচ্ছে।

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

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

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

import main.Field;

public class ChoiceCatcher implements Catcher {

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

    @Override
    public int[] takeTurn(Field f) {
        int[] bestPos = null;
        double bestPosValue = Double.MAX_VALUE;
        for (int i = 0; i < f.SIZE; i++) {
            for (int j = 0; j < f.SIZE; j++) {
                if (f.read(i, j) == Field.EMPTY) {
                    Field myField = new Field(f);
                    myField.placeBucket(new int[] { i, j });
                    double posValue = catTurnValue(myField);
                    if (posValue < bestPosValue) {
                        bestPosValue = posValue;
                        bestPos = new int[] { i, j };
                    }
                }
            }
        }
        return bestPos;
    }

    private double catTurnValue(Field f) {

        int[] pos = f.findCat();
        double[] values = new double[6];
        int count=0;
        for (int[] t : turns) {
            int[] currPos = { pos[0] + t[0], pos[1] + t[1] };
            double moveValue = movePosValue(currPos, f);
            values[count++]=moveValue;
        }
        Arrays.sort(values);
        return values[5];
    }

    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;
        int maxRoutes = 2;
        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, maxRoutes); i++) {
            fp *= product[5 - i];
        }
        double fp2 = 1;
        for (int i = 0; i < Math.min(count, 6); i++) {
            fp2 *= product[5 - i];
        }
        double retValue = Math.min(count, maxRoutes) + fp;
        double retValue2 = Math.min(count, 6) + fp2;
        return -retValue - retValue2 / 1000000;
    }

}
— randomra
সূত্র
1

RandCatcher

এটি কেবলমাত্র নিয়ামকের পরীক্ষার জন্য তৈরি হয়েছিল এবং এলোমেলোভাবে বালতি রাখে (খুব অযোগ্যভাবে)।

package players;

import main.Field;

public class RandCatcher implements Catcher {
    public String getName(){
        return "RandCatcher";
    }
    public int[] takeTurn(Field f){
        int[] pos = {0,0};
        do {
            pos[0] = (int) (Math.random()*f.SIZE);
            pos[1] = (int) (Math.random()*f.SIZE);
        } while( f.isValidPosition(pos)==false );
        return pos;
    }

}
— flawr
সূত্র
1

StupidFillCatcher

এটি কেবল নিয়ামক পরীক্ষার জন্য তৈরি হয়েছিল। বিড়ালটিকে ধরা না দেওয়া পর্যন্ত এটি কলামে কলামটি পূর্ণ করে।

package players;

import main.Field;

public class StupidFillCatcher implements Catcher {
    public String getName(){
        return "StupidFillCatcher";
    }
    public int[] takeTurn(Field f){
        for(int i=0; i < f.SIZE; i++){
            for(int j=0; j < f.SIZE; j++){
                if(f.isValidPosition(new int[] {i,j})){
                    return new int[] {i,j};
                }
            }
        }
        return new int[] {0,0};
    }

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