আসুন মেটা টিক-ট্যাক-টু খেলি!


38

মেটা টিক-ট্যাক-টো-এর খেল খেলতে দেয়!

এটি মেটা টিক-টাক-টো টুর্নামেন্ট। মেটা টিক-ট্যাক-টো এর নিয়মগুলি নিম্নরূপ:

  1. টিক-ট্যাক-টোয়ের নিয়মিত সমস্ত নিয়ম প্রযোজ্য।

  2. একটি করে মাস্টার বোর্ড করার জন্য নয়টি বোর্ড সাজানো আছে। তাই ভালো:

    0|1|2 || 0|1|2 || 0|1|2 
    ----- || ----- || ----- 
    3|4|5 || 3|4|5 || 3|4|5 
    ----- || ----- || ----- 
    6|7|8 || 6|7|8 || 6|7|8 
    ========================
    0|1|2 || 0|1|2 || 0|1|2 
    ----- || ----- || ----- 
    3|4|5 || 3|4|5 || 3|4|5 
    ----- || ----- || ----- 
    6|7|8 || 6|7|8 || 6|7|8 
    ========================
    0|1|2 || 0|1|2 || 0|1|2 
    ----- || ----- || ----- 
    3|4|5 || 3|4|5 || 3|4|5 
    ----- || ----- || ----- 
    6|7|8 || 6|7|8 || 6|7|8 
    

    বোর্ড 0 শীর্ষ বাম বোর্ডকে বোঝায়, বোর্ড 1 টি শীর্ষ মিডল বোর্ডকে বোঝায় ... এর মতো

    0|1|2
    -----
    3|4|5
    -----
    6|7|8
    

    যদি আমি বোর্ড 3 বলি, টাইল 4, তার মানে মাঝ বামে বোর্ডের কেন্দ্র টাইল।

  3. আপনাকে কেবলমাত্র ছোট বোর্ডগুলির মধ্যে একটিতে যাওয়ার অনুমতি দেওয়া হয়েছে।

  4. আপনি যদি একটি ছোট বোর্ড জিতেন তবে পুরো বোর্ডটি আপনার টাইল হিসাবে গণ্য হবে।

  5. কোনও একটি বোট এটি জয়ের আগে যদি বোর্ডগুলির মধ্যে একটি পূর্ণ হয়, তবে এটি নোবডি টাইল হিসাবে গণ্য।

  6. যে জিতবে মাস্টার বোর্ডের জয়!

তবে, একটি গুরুত্বপূর্ণ মোড় আছে। ধরা যাক আমি বোর্ড 7 এ যাই, টাইল 2। তার মানে আপনার পালা, আপনি কেবল বোর্ডে 2 যেতে পারেন Then তারপরে ধরে নেওয়া যাক আপনি বোর্ড 2, টাইল 5 এ যান my এখন আমার পালা, আমি কেবল বোর্ড 5 তে যেতে পারি ধরা যাক বোর্ড 1 টি পূর্ণ। (আর কোনও দাগ বাকী নেই, বা আমাদের মধ্যে ইতিমধ্যে একটি বোর্ড জিতেছে 1) এখন আমি যদি বোর্ড 5, টাইল 1 এ যাই তবে আপনি যে কোনও বোর্ডে যেতে পারেন।

এই নিয়মগুলি হিসাবে বিবেচনা করা যেতে পারে:

  1. পূর্ববর্তী প্লেয়ারের পজিশন অনুসারে আপনাকে অবশ্যই বোর্ডে খেলতে হবে।
    • এক্স বোর্ডে 2 খেললে, টাইল 5; হে বোর্ড 5 খেলতে হবে
  2. যদি লক্ষ্য বোর্ডটি পূর্ণ (একটি টাই) বা ইতিমধ্যে একটি বিজয়ী থাকে, পরবর্তী পদক্ষেপটি নিয়ন্ত্রণহীন।
  3. বিজয়ী সহ একটি বোর্ড খেলতে নাও পারা যায়, এমনকি একটি নিয়ন্ত্রণহীন পদক্ষেপেও।

এটি যদি কিছুটা বিভ্রান্ত হয় তবে আপনি এটি এখানে অনলাইনে চেষ্টা করতে পারেন ("প্রথম টাইল জয়" থেকে "এক সারি 3 টাইলস" এ স্যুইচ করার বিষয়টি নিশ্চিত করুন)

এখন এখানে চ্যালেঞ্জের নিয়ম রয়েছে।

  1. আপনার অবশ্যই একটি বট লিখতে হবে যা এই গেমটি খেলবে।

  2. বট 1 হ'ল এক্স, এবং এটি প্রথমে যেতে পারে। এটি এই কমান্ড লাইন আর্গুমেন্টের সাথে ডাকা হবে (বন্ধনীগুলির স্টাফ ছাড়াই):

    X         (whose turn)
    --------- (board 0)
    --------- (board 1)
    --------- (board 2)
    --------- (board 3)
    --------- (board 4)
    --------- (board 5)
    --------- (board 6)
    --------- (board 7)
    --------- (board 8)
    --------- (master board)
    xx        (last move)
    

    প্রথম চরিত্রটি বটটি কে প্রতিনিধিত্ব করে। এই ক্ষেত্রে, বট 1 এক্স হিসাবে খেলবে The পরবর্তী 9 টি লাইন 9 টি বোর্ডকে বোঝায়। 11 তম লাইনটি মাস্টার বোর্ডকে বোঝায়। "এক্সএক্স" হ'ল শেষ পদক্ষেপ। এখন, বট 1 টি অবশ্যই 0 এবং 8 এর মধ্যে দুটি সংখ্যা মুদ্রণ করবে আপনার নম্বরটি 1 টি আপনার বটটি যে বোর্ডে প্রবেশ করছে, এবং 2 নম্বরটি বোর্ডের টাইল। নিয়ামক এই পদক্ষেপের উপর নজর রাখবেন। বট 1 টি 38 টি প্রিন্ট বলি এখন বোর্ডটি এর মতো দেখাবে:

     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    ==========================
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |X ||  | |  ||  | |  
    ==========================
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    

    এবং bot2 এই আর্গুমেন্টের সাথে কল করা হবে:

    O
    ---------
    --------- 
    --------- 
    --------X 
    --------- 
    --------- 
    --------- 
    --------- 
    --------- 
    ---------
    38
    
  3. এখন বট 2 টি অবশ্যই বোর্ড 8 এ চলতে হবে (কারণ বট 1 টাইল 3 এ একটি এক্স রেখেছিল)। আসুন বলি বট 2 84 টি প্রিন্ট করে Now এখন বোর্ডটি এর মতো দেখাচ্ছে।

     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    ==========================
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |X ||  | |  ||  | |  
    ==========================
     | |  ||  | |  ||  | |  
    ----- || ----- || ----- 
     | |  ||  | |  ||  |O|  
    ----- || ----- || ----- 
     | |  ||  | |  ||  | |  
    

    এখন bot1 এই যুক্তি দিয়ে ডাকা হবে:

    X
    ---------
    --------- 
    --------- 
    --------X 
    --------- 
    --------- 
    --------- 
    --------- 
    ----0---- 
    ---------
    84
    
  4. এখন bot1 অবশ্যই বোর্ডে চলতে হবে ৪. তবে, বট 1 একটি দুষ্টু ছোট বট এবং বোর্ডে সরানোর সিদ্ধান্ত নিয়েছে It এটি '30' প্রিন্ট করে। বোর্ড মোটেই বদলায় না। মাস্টার বট এটিকে লক্ষ্য রাখে। এখন এই যুক্তি দিয়ে বট 2 কল করা হবে:

    O
    ---------
    --------- 
    --------- 
    --------X 
    --------- 
    --------- 
    --------- 
    --------- 
    ----0---- 
    ---------
    xx
    
  5. এখন বট 2 এটি যে কোনও জায়গায় যেতে পারে (অবশ্যই 38 এবং 84 বাদে)। কেউ একের পর এক 3 টি মাস্টার বোর্ড জিত না হওয়া পর্যন্ত এটি অব্যাহত থাকে। তারপরে, এখানে একটি দ্বিতীয় ম্যাচআপ রয়েছে যেখানে বট 2 এক্স এবং প্রথমে যেতে পারে।

  6. যতক্ষণ না প্রতিটি একক বট প্রতিটি অন্যান্য বট না খেলে এটি পুনরাবৃত্তি করে।

স্কোরিং

স্কোরিং এর মতো কাজ করে:

প্রতিটি ম্যাচের বিজয়ী 100 + number of open spotsপয়েন্ট পায় । এইভাবে, আপনার বটটি দ্রুত জিতলে এটি আরও মূল্যবান। আপনার বট প্রতিবারই একটি অবৈধ পদক্ষেপ নেয়, এটি 1 পয়েন্ট হারাবে। যদি 250 রাউন্ডের পরে, কোনও বট জিতেনি, প্রতিটি বট 10 পয়েন্ট হারিয়েছে এবং আমরা পরবর্তী রাউন্ডে যেতে চাই।


সমস্ত কিছু এমন একটি ডিরেক্টরিতে রাখা হবে যাতে এতে রয়েছে

  1. নিয়ামক বট এটি একটি সি ++ প্রোগ্রাম যা আমি লিখেছি। আপনি এখানে নিয়ামক বট উত্স কোডটি দেখতে পারেন আপনি যদি এমন কোনও কিছু নিয়ন্ত্রণকারীর সাথে সঠিক না দেখেন তবে আমাকে জানান।

  2. instructions.txtএই ফাইলটির নামের একটি পাঠ্য ফাইলটি এরকম কিছু দেখবে:

    [Total number of bots that are competing]
    
    [bot1Name] [bot1 command to run]
    [bot2Name] [bot2 command to run]
    ...
    
  3. প্রতিটি বট জন্য একটি ফোল্ডার। এই ফোল্ডারটি আপনার প্রোগ্রামটিকে (এটি কোনও স্ক্রিপ্ট বা বাইনারি হোক) এবং এক টেক্সট ফাইলকে ধরে রাখবে data.txtযা আপনার বটটি যা যা চায় পড়তে ও লিখতে পারে।

প্রযুক্তিগত বৈশিষ্ট্য এবং নিয়মের স্পষ্টতা

  • যে ফটোগুলি এর ফোল্ডারের ভিতরে নয় সেখান থেকে যে কোনও বট পড়তে / লিখতে চেষ্টা করে সে খেলা থেকে লাথি মারবে।

  • আপনার প্রোগ্রামটি অবশ্যই ইয়োসেমাইট চলমান ম্যাকবুকটিতে চালাতে সক্ষম হবে। বর্তমানে সমর্থিত ভাষা হ'ল পাইথন (২..9.৯ এবং ৩.৪.২), সি / সি ++, অবজেক্টি-সি, পার্ল, রুবি, বাশ, পিএইচপি, জাভা, সি #, জাভাস্ক্রিপ্ট এবং হাস্কেল। আরও অনেক কিছু রয়েছে, তবে এই মুহূর্তে আমি এখনই ভাবতে পারি। সময় বাড়ার সাথে সাথে আরও যুক্ত করব। আপনি যদি কোনও নির্দিষ্ট ভাষায় প্রতিযোগিতা করতে চান তবে আমাকে বার্তা দিন বা মন্তব্য করুন এবং সম্ভব হলে তালিকায় এটি যুক্ত করব add

  • যদি কোনও বোর্ড জিতে যায় তবে এখনও স্থান রয়েছে তবে আপনি এখনও খোলা জায়গাগুলির কোনওটিতে যেতে পারবেন না।

  • নোট করুন যে আপনার জমা দেওয়ার কার্যকারী ডিরেক্টরিটি সেই ডিরেক্টরিতে থাকবে যা নিয়ামক এবং অন্যান্য সমস্ত বট ধারণ করে, আপনার বটটি যে ডিরেক্টরিতে থাকে তা নয়।

  • দয়া করে আপনার নিয়ামক বট কোডটি সহ সঠিক কমান্ডটি সংকলন করতে (যদি প্রযোজ্য হয়) এবং আপনার বট চালানোর জন্য পোস্ট করুন। এর বেশিরভাগটি ওএস এক্স টার্মিনাল থেকে করা হবে যা একটি লিনাক্স টার্মিনালের সাথে মোটামুটি সমান।

  • বটস অবশ্যই এক সেকেন্ডের অধীনে সম্পূর্ণ করতে হবে। দুর্ভাগ্যক্রমে, আমি কন্ট্রোলার বটটিতে টাইমার যুক্ত করতে যথেষ্ট সক্ষম নই। তবে, আমি নিজেই বটগুলি সময় করব time


ফলাফল!

ঠিক আছে, আমি ঠিক ছিল। আমি মাস্টারবোর্ড পূর্ণ কিনা তা দেখতে কন্ট্রোলার বট চেক করতে ভুলে গেছি। যদি মাস্টারবোর্ডটি পূর্ণ থাকে, তবে প্রতিটি পদক্ষেপ অবৈধ, তবে এটি বটগুলিকে কল করতে থাকে, যার কারণেই সম্ভবত সেখানে অনেকগুলি অবৈধ পদক্ষেপ ছিল। আমি এখন এটি ঠিক আছে। সমস্ত বটগুলির সর্বাধিক বর্তমান সংস্করণ সহ সরকারী ফলাফল এখানে।

Bot 1, goodRandBot, has 1 wins and made 0 illegal moves, for a total of 133 points.
Bot 2, naiveBot, has 3 wins and made 48 illegal moves, for a total of 361 points.
Bot 3, depthBot, has 5 wins and made 0 illegal moves, for a total of 664 points.
Bot 4, middleBot, has 1 wins and made 20 illegal moves, for a total of 114 points.

With 4 bots, This program took 477.471 seconds to finish.

ডিপথ বট হলেন রাজকীয় চ্যাম্পিয়ন! কমপক্ষে, এখনই জন্য।


অন্যদিকে , আপনি কি কখনও ফায়ার এন্ড আইস (গেমারজটনেটের একটি পেম সংস্করণ ) এর দিকে নজর রেখেছেন - এর সাথে কিছু টিক-টাক-টু উপাদান রয়েছে ... যদিও এটি আমাকে লেখকের কথা মনে করিয়ে দেয় ।

9 টি পছন্দ এবং 40 মতামত। আমি অভিভূত!
লুভজো

5
আপনি বটের প্রতিক্রিয়া সময়টির সীমাবদ্ধতা রাখতে চাইতে পারেন বা ভবিষ্যতে সমস্ত সম্ভাব্য পদক্ষেপগুলি অনুসন্ধানের সময় বটগুলি প্রতি পদক্ষেপে 3 মিনিট সময় নিতে পারে।
লজিক নাইট

1
আমি পরবর্তী পদক্ষেপ সম্পর্কে কিছু বিধি স্পষ্টতা যোগ করেছি। আমার ডেটা ফর্ম্যাট এবং একটি নিয়ম সম্পর্কে উদ্বেগ আছে। প্রথম বিভাগ থেকে 5 বিধি বিধান করুন: "যদি কোনও বোর্ড পূরণ করা হয় তবে এটি নোবডি টাইল হিসাবে গণ্য হয়।" এটি কি কোনও বিজয়ী ছাড়াই পূর্ণ? অর্থাত্ যদি কেউ আগে টাইল জিতেন, এবং এটি ভরাট হয়ে যায় তবে তা কি নোবেডি টাইল? তদ্ব্যতীত, যদি বটগুলি রাষ্ট্রহীন হয়ে থাকে (তারা উপস্থিত হয়) রাষ্ট্রটি উত্তীর্ণ হয় তবে কোনও বোর্ডের বিজয়ী কীভাবে XXX000---সংক্রমণ হয়? বা এটি যে 'ও এটি প্রথম জিতেছে তার পরেও কেউ তা পায় না'?

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

উত্তর:


5

পাইথন ২.7, গভীরতা

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

class DepthPlayer:
    def __init__(self,depth):
        self.depth = depth

    def score(self,master,subs,last_move):
        total = 0
        for x in range(3):
            for y in range(3):
                c = master[3*y+x]
                if c == 0:
                    total += sum(subs[3*y+x])
                else:
                    total += c*10
                    for (dx,dy) in [(1,-1),(1,0),(0,1),(1,1)]:
                        if x+dx<=2 and 0<=y+dy<=2 and master[3*(y+dy)+(x+dx)] == c:
                            total += c*10
        if last_move is None or master[last_move[1]] != 0 or 0 not in subs[last_move[1]]:
            total += 5
        return total

    def winner(self,board):
        for y in range(3):
            row = board[3*y:3*y+3]
            if 0!=row[0]==row[1]==row[2]:
                return row[0]
        for x in range(3):
            col = board[x:9:3]
            if 0!=col[0]==col[1]==col[2]:
                return col[0]
        if 0!=board[0]==board[4]==board[8]:
            return board[0]
        if 0!=board[2]==board[4]==board[6]:
            return board[2]

        return 0

    def parse(self,input):
        lines = input.split('\n')
        team = lines[0]
        subs_str = lines[1:10]
        master_str = lines[10]
        last_move_str = lines[11]

        master = [1 if c==team else 0 if c=='-' else -1 for c in master_str]
        subs = [[1 if c==team else 0 if c=='-' else -1 for c in sub_str] for sub_str in subs_str]
        if last_move_str == 'xx':
            last_move = None

        else:
            last_move = [int(c) for c in last_move_str]
        return master,subs,last_move

    def alphabeta(self, master,subs,last_move, depth, alpha, beta, player):
        if depth == 0:
            return self.score(master,subs,last_move),None
        w = self.winner(master)
        if w != 0:
            return w*1000,None

        if player:
            v = -10000
            best = None
            for n_master,n_subs,n_last_move in self.all_moves(master,subs,last_move,1):
                nv,_ = self.alphabeta(n_master,n_subs,n_last_move, depth-1, alpha, beta, False)
                if nv>v:
                    v = nv
                    best = n_last_move
                alpha = max(alpha, v)
                if beta <= alpha:
                    break
            return v,best
        else:
            v = 10000
            best = None
            for n_master,n_subs,n_last_move in self.all_moves(master,subs,last_move,-1):
                nv,nb = self.alphabeta(n_master,n_subs,n_last_move, depth-1, alpha, beta, True)
                if nv<v:
                    v = nv
                    best = n_last_move
                beta = min(beta, v)
                if beta <= alpha:
                    break
            return v,best

    def make_move(self,master,subs,move,player):
        n_subs = [sub[:] for sub in subs]
        n_master = master[:]
        n_subs[move[0]][move[1]] = player
        if n_master[move[0]] == 0:
            n_master[move[0]] = self.winner(n_subs[move[0]])
        return n_master,n_subs,move

    def sub_moves(self,board):
        first = []
        second = []
        third = []
        for i in range(9):
            if board[i] != 0:
                continue
            y,x = divmod(i,3)
            c=-2
            if   x==0 and 0!=board[i+1]==board[i+2]>c: c=board[i+1]
            elif x==1 and 0!=board[i-1]==board[i+1]>c: c=board[i-1]
            elif x==2 and 0!=board[i-2]==board[i-1]>c: c=board[i-2]
            if   y==0 and 0!=board[i+3]==board[i+6]>c: c=board[i+3]
            elif y==1 and 0!=board[i-3]==board[i+3]>c: c=board[i-3]
            elif y==2 and 0!=board[i-6]==board[i-3]>c: c=board[i-6]
            if i in [0,4,8] and 0!=board[(i+4)%12]==board[(i+4)%12]>c: c=board[i-6]
            if i in [2,4,6] and 0!=board[6 if i==2 else i-2]==board[2 if i==6 else i+2]>c: c=board[i-6]

            if c==-2:   third.append(i)
            elif c==-1: second.append(i)
            else:       third.append(i)
        return first+second+third

    def all_moves(self,master,subs,last_move,player):
        if last_move is not None and master[last_move[1]]==0 and 0 in subs[last_move[1]]:
            for i in self.sub_moves(subs[last_move[1]]):
                yield self.make_move(master,subs,[last_move[1],i],player)

        else:
            for j in range(9):
                if master[j]==0 and 0 in subs[j]:
                    for i in self.sub_moves(subs[j]):
                        yield self.make_move(master,subs,[j,i],player)

    def move(self,master,subs,last_move):
        return self.alphabeta(master,subs,last_move, self.depth, -10000, 10000, True)[1]

    def run(self,input):
        result = self.move(*self.parse(input))
        if result:
            return str(result[0])+str(result[1])

def print_board(subs,player):
    string = ""
    for row in range(9):
        for sub in subs[row/3*3:row/3*3+3]:
            for c in sub[row%3*3:row%3*3+3]:
                string += "-XO"[c*(1 if player=='X' else -1)]
            string += ' '
        if row%3 == 2:
            string += '\n'
        string += '\n'
    print string

def to_string(master,subs,last_move,player):
    string = player+'\n'
    for sub in subs:
        for c in sub:
            string += "-XO"[c*(1 if player=='O' else -1)]
        string += '\n'
    for c in master:
        string += "-XO"[c*(1 if player=='O' else -1)]
    string += '\n'+str(last_move[0])+str(last_move[1])
    return string


import sys
command = '\n'.join(sys.argv[1:])
print DepthPlayer(8).run(command)

এটি চালানোর জন্য, আপনি সহজভাবে তা করতে পারেন python Depth.py <input>, যদিও আমি pypyএটির দ্রুতি হিসাবে গতি বাড়ানোর জন্য এটির পরামর্শ দিচ্ছি ।

এছাড়াও আমি জানি না আপনার সিস্টেমটি কত গতিযুক্ত তবে আপনি যদি প্রথমে যুক্তিটি DepthPlayerনির্দিষ্ট সময়ে চালিয়ে যেতে পারেন তবে উচ্চতর হতে একেবারে শেষের দিকে পরিবর্তন করতে পারেন (আমার সিস্টেমে এটি গভীরতার সাথে প্রায় সমস্ত জিনিস খুব দ্রুত সম্পন্ন করেছে) 7 বা 8, তবে কয়েকটি কেস ছিল যা সেকেন্ডের কাছাকাছি বা তার বেশি ছিল তাই আমি নিরাপদে এটি 6 তে সেট করে রেখেছি)।


অজগর sys.argvএকটি নতুন লাইন পৃথক স্ট্রিং ফিরে না। এটি এই ফর্ম্যাটে স্ট্রিংগুলির একটি তালিকা দেয়: ['Depth.py', 'X', '---------', '---------', ...]আমি এটি শেষ দুটি লাইন সম্পাদনা করে এটি ঠিক command = '\n'.join(sys.argv[1:]) print DepthPlayer(6).run(command)করেছি আশা করি আপনি আপত্তি করবেন না।
DJMcMayhem

@ ডিজেএমসিএমহেম ওহ ধন্যবাদ আমি এই শেষ লাইনের পরীক্ষা করিনি।
কেএসব

2

জাভা, নাইভ

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

import java.util.Arrays;

public class Naive {

    public static void main(String[] args) {

        char[][] board = new char[9][9];
        for (int i = 0; i < 9; i++) {
            board[i] = args[i + 1].toCharArray();
        }
        char[] metaBox = args[10].toCharArray();

        char a = args[0].charAt(0),
                b = (char) ('X' + 'O' - a);

        int legalBox = args[11].charAt(1) - '0';
        boolean legalAnywhere = legalBox == 'x' - '0';
        if (!legalAnywhere) {
            if (wins(board[legalBox], 'X') || wins(board[legalBox], 'O')) {
                legalAnywhere = true;
            }
        }
        a:
        if (!legalAnywhere) {
            for (int i = 0; i < 9; i++) {
                if (board[legalBox][i] == '-') {
                    break a;
                }
            }
            legalAnywhere = true;
        }

        if (legalAnywhere) {
            chooseMove(board, metaBox, a, b);
        } else {
            chooseMove(board, metaBox, a, b, legalBox);
        }
    }

    static boolean canWinWith(char[] box, char c) {
        for (int i = 0; i < 9; i++) {
            if (wins(box, i, c)) {
                return true;
            }
        }
        return false;
    }

    static boolean wins(char[] box, int move, char c) {
        char[] copy = Arrays.copyOf(box, 9);
        copy[move] = c;
        return wins(copy, c);
    }

    static boolean wins(char[] box, char c) {
        return (box[0] == c && box[1] == c && box[2] == c)
               || (box[3] == c && box[4] == c && box[5] == c)
               || (box[6] == c && box[7] == c && box[8] == c)
               || (box[0] == c && box[3] == c && box[6] == c)
               || (box[1] == c && box[4] == c && box[7] == c)
               || (box[2] == c && box[5] == c && box[8] == c)
               || (box[0] == c && box[4] == c && box[8] == c)
               || (box[2] == c && box[4] == c && box[6] == c);
    }

    static void endWith(int box, int i) {
        System.out.println("" + box + i);
        System.exit(0);
    }

    private static void chooseMove(char[][] board, char[] metaBox, char a, char b, int legalBox) {
        for (int i = 0; i < 9; i++) {
            if (wins(board[legalBox], i, a) && board[legalBox][i] == '-') {
                endWith(legalBox, i);
            }
        }
        for (int i = 0; i < 9; i++) {
            if (wins(board[legalBox], i, b) && board[legalBox][i] == '-') {
                endWith(legalBox, i);
            }
        }
        for (int i = 0; i < 9; i++) {
            if (board[legalBox][i] == '-') {
                if (!canWinWith(board[i], b)) {
                    endWith(legalBox, i);
                }
            }
        }
        for (int i = 0; i < 9; i++) {
            if (board[legalBox][i] == '-') {
                endWith(legalBox, i);
            }
        }
        throw new RuntimeException("No move chosen!");
    }

    private static void chooseMove(char[][] board, char[] metaBox, char a, char b) {
        for (int box = 0; box < 9; box++) {
            for (int i = 0; i < 9; i++) {
                if (wins(board[box], i, a) && board[box][i] == '-') {
                    endWith(box, i);
                }
            }
        }
        for (int box = 0; box < 9; box++) {
            for (int i = 0; i < 9; i++) {
                if (wins(board[box], i, b) && board[box][i] == '-') {
                    endWith(box, i);
                }
            }
        }
        for (int box = 0; box < 9; box++) {
            for (int i = 0; i < 9; i++) {
                if (board[box][i] == '-') {
                    if (!canWinWith(board[i], b)) {
                        endWith(box, i);
                    }
                }
            }
        }
        for (int box = 0; box < 9; box++) {
            for (int i = 0; i < 9; i++) {
                if (board[box][i] == '-') {
                    endWith(box, i);
                }
            }
        }
        throw new RuntimeException("No move chosen!");
    }
}

জাভা নুব হওয়ার জন্য আপনাকে আমাকে ক্ষমা করতে হবে, তবে আমি কীভাবে প্যারেন্ট ডিরেক্টরি থেকে এটি চালাব? আমার মূল ডিরেক্টরিতে Naive.classএকটি ডিরেক্টরি রয়েছে naiveBotinside
ডিজেএমসিএমহেম

@ ডিজেএমসিমেহেম আমার কোনও ম্যাকের অ্যাক্সেস নেই, তবে উইন্ডোতে আপনি কেবল java Naive <args>কমান্ডটি চালিয়ে যেতে পারেন , পরিবেশের ভেরিয়েবলগুলিতে পয়েন্টার অন্তর্ভুক্ত বলে ধরে নিবেন C:\Program Files\Java\jdk1.8.0\bin। আশা করি এটা কাজে লাগবে.
Ypnypn

ঠিক আছে, আমি এটি খুঁজে বের করব।
ডিজেএমসিহেম

@ ডিজেএমসিএমহেম যদি আপনি ইতিমধ্যে এটি সন্ধান না করেন তবে এটি java -classpath naiveBot Naive;)
কমনগ্যু

@Ypnypn যদি legalAnywhereসত্য হয় তবে আপনার জমাটি ব্যর্থ হয়েছে কারণ আপনি ইতিমধ্যে কোনও প্লেয়ার দ্বারা জিতে থাকা বোর্ডগুলি ব্যবহার করার চেষ্টা করছেন।
কমনগ্যু

2

পাইথন 2, মিডলবট

মিডলবট মধ্যম পছন্দ করে। কেন্দ্রীয় গেমটি (4) জেতার আগে, এটি প্রতিপক্ষকে বার বার মাঝারি খেলায় জোর করে, যতটা সম্ভব গেমের মধ্যবর্তী স্কোয়ারটি দখলের চেষ্টা করবে।
এটি হয়ে গেলে, এটি এটি যে কোনও গেম জিততে চেষ্টা করে, বা না হলে কেবল প্রথম উপলভ্য স্থানটি পূরণ করে (তার দেরী গেমটি নিয়ে কাজ করা দরকার, আমি মনে করি)

from random import randint
import sys
command_in = '\n'.join(sys.argv[1:])
class MiddleBot:

    def scan_in(self,the_game):

        lines = the_game.split('\n')
        self.us = lines[0]
        if self.us == 'X':
            self.them = 'O'
        else:
            self.them = 'X'
        self.games = lines[1:10]
        self.metagame = lines[10]
        self.last_move = lines[11]

        try:
            self.sub_board = int(self.last_move[1])
        except ValueError:
            self.sub_board = self.last_move[1]

    def empty(self,game,target):
        if self.games[int(game)][int(target)] == '-':
            self.emptycell = 1
        else: self.emptycell = 0

    def empty_fill(self,game):
        #checks for next empty space, fills it
        for k in xrange(0,8):
            self.empty(game,k)
            if self.emptycell == 1:
                self.first_empty_space = k
                break
            if self.emptycell == 0:
                game = randint(0,8)
                self.first_empty_space = 4


    def aim_for_target(self,game,target):
        if self.games[int(game)][int(target)] == '-':
            self.move = `game` + `target`
        else:
            self.empty_fill(game)
            self.move = `game` + `self.first_empty_space`


    #define all win conditions        
    win = [0]*8            
    win[0] = [0,1,2]
    win[1] = [3,4,5]
    win[2] = [6,7,8]
    win[3] = [0,3,6]
    win[4] = [1,4,7]
    win[5] = [2,5,8]
    win[6] = [0,4,8]
    win[7] = [2,4,6]

    #check if current board state is one move away from 'us' winning
    def aim_for_win(self,game):
            for k in xrange(0,len(self.win)):
                if self.games[self.sub_board][self.win[k][0]] == self.games[self.sub_board][self.win[k][1]] == self.us:
                    self.empty(self.sub_board,self.win[k][2])
                    if self.emptycell == 1:
                        self.move = `self.sub_board`+`self.win[k][2]`
                    else:
                        self.empty_fill(self.sub_board)
                        self.move = `self.sub_board`,`self.first_empty_space`
                elif self.games[self.sub_board][self.win[k][0]] == self.games[self.sub_board][self.win[k][2]] == self.us:
                    self.empty(self.sub_board,self.win[k][1])
                    if self.emptycell == 1:
                        self.move = `self.sub_board`+`self.win[k][1]`
                    else:
                        self.empty_fill(self.sub_board)
                        self.move = `self.sub_board`+`self.first_empty_space`
                elif self.games[self.sub_board][self.win[k][1]] == self.games[self.sub_board][self.win[k][2]] == self.us:
                    self.empty(self.sub_board,self.win[k][0])
                    if self.emptycell == 1:
                        self.move = `self.sub_board`+`self.win[k][0]`
                    else:
                        self.empty_fill(self.sub_board)
                        self.move = `self.sub_board`+`self.first_empty_space`
                else:
                    self.empty_fill(self.sub_board)
                    self.move = `self.sub_board`+`self.first_empty_space`


    def play(self):
        #If the middle board is not won, aim for the middle square of each board
        if self.metagame[4] == '-':
            if self.sub_board == 4 or self.sub_board == 'x':
                self.aim_for_target(4,4)
            else:
                self.aim_for_target(self.sub_board,4)
        else:
            #once the middle board is won, pretty much plays randomly, aiming to win if it can, otherwise just filling the first empty space in each subgame
            played = 0
            if self.sub_board == 'x':
                self.sub_board = randint(0,8)
            while played == 0:
                if self.metagame[int(self.sub_board)] == '-':
                    self.aim_for_win(self.sub_board)
                    played = 1
                else:
                    self.sub_board = randint(0,8)
        return self.move

    def run(self,game_board):
        self.scan_in(game_board)
        self.play()
        return self.move

print MiddleBot().run(command_in)      

এটি চালানোর জন্য, python MiddleBot.py <input>মনে হচ্ছে এটি সুখে আমার জন্য এক সেকেন্ডের অধীনে চলেছে, সুতরাং আশা করি এটিও আপনার পক্ষে হবে


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

ওহো! এখনই ঠিক করা উচিত। সেই পুনরাবৃত্তিতে 'xx' কেসটি পরীক্ষা করতে ভুলে গেছি, দুঃখিত!
লজিবিয়ানবিহাতেহাত

একটি সম্পাদনাও করেছেন - এটি যদি কোনও বিজয়ী ছাড়াই বোর্ড পূরণ করা হত এবং এটি সেখানে খেলতে বলা হয় তবে এটি ক্র্যাশ হবে
লজিশিয়ান উইথাহাট

0

আমার নিজের বট মিশ্রণে ফেলে দিতে পারে।

অজগর 2, গুডর্যান্ডমবট

import sys
from random import choice

args = sys.argv
if len(args) < 13:
    print ("I can't work with this!\n")
    sys.exit()

whoAmI = args[1];
masterBoard = list(args[11])
board = []
for i in range(2, 11):
    board.append(list(args[i]))

oppMove = args[12]

def findAllValidMoves(board, masterBoard):
    validMoves = []
    for row in range(9):
        if masterBoard[row] != '-':
            continue
        for col in range(len(board[row])):
            if board[row][col] == '-':
                validMoves.append(str(row) + str(col))
    return validMoves

validMoves = []
if oppMove == "xx" or masterBoard[int(oppMove[1])] != "-":
    validMoves = findAllValidMoves(board, masterBoard)    

else:
    row = int(oppMove[1])
    for col in range(len(board[row])):
        if board[row][col] == '-' and masterBoard[row] == "-":
            validMoves.append(str(row) + str(col))

if (validMoves == []):
    validMoves = findAllValidMoves(board, masterBoard)

print choice(validMoves)

যতক্ষণ না এটি বৈধ পদক্ষেপ হয় ততক্ষণ এই বট কোথায় যায় সেদিকে খেয়াল রাখে না। সমস্ত বৈধ পদক্ষেপ থেকে এলোমেলোভাবে বাছাই করে এবং 0অবৈধ চালগুলি গড়ে তোলে ।

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