টিক-টাক-টো গেমস

15

এন ডি খেলার জন্য একটি ডিস্ট্রিমেন্টিক প্রোগ্রাম তৈরি করুনঅন্যান্য প্রতিযোগীদের সাথে টিক-টাক-টো ।

যখন আপনার nপ্রস্থ (প্রস্থ) এবং d(মাত্রা নম্বর) এই ব্যাপ্তিতে থাকবে তখন আপনার প্রোগ্রামটি কাজ করা উচিত :

n∈[3,∞)∩ℕ  ie a natural number greater than 2
d∈[2,∞)∩ℕ  ie a natural number greater than 1

n = 3; d = 2(3 2 অর্থাৎ 3 দ্বারা 3):

[][][]
[][][]
[][][]

n = 3; d = 3(3 3 অর্থাৎ 3 বাই 3 বাই 3):

[][][]
[][][]
[][][]

[][][]
[][][]
[][][]

[][][]
[][][]
[][][]

n = 6; d = 2(6 2 অর্থাৎ 6 দ্বারা 6):

[][][][][][]
[][][][][][]
[][][][][][]
[][][][][][]
[][][][][][]
[][][][][][]

ইত্যাদি।

ইনপুট:

ইনপুটটি STDIN এ হবে। ইনপুটটির প্রথম লাইনটি দুটি সংখ্যা nএবং dফর্মের হবেn,d ।

এরপরে স্থানাঙ্কের সমন্বয়ে একটি লাইন হবে যা চলমানগুলি নির্দিষ্ট করে। স্থানাঙ্ক আকারে তালিকাভুক্ত হবে: 1,1;2,2;3,3। উপরের বাম কোণটি মূল (2D এর জন্য 0,0)। সাধারণ ক্ষেত্রে, এই তালিকা মত হবে1,2,...,1,4;4,0,...,6,0;... যেখানে প্রথম সংখ্যাটি বাম-ডান-নেস, দ্বিতীয় আপ-ডাউন-নেস, তৃতীয় মাত্রার মধ্য দিয়ে তৃতীয় ইত্যাদি উপস্থাপন Xকরে হয় Oপ্রথম পালা, ....

এটি যদি প্রথম পদক্ষেপ হয় তবে ইনপুটটি 1 টি ফাঁকা লাইন অনুসরণ করে একটি নম্বর করবে।

ধারাবাহিকতার জন্য, ইনপুটটি সর্বদা একটি নতুন লাইনের সাথে শেষ হবে। নমুনা ইনপুট (\ n নতুন লাইন):

10,10\n0,0,0,0,0,0,0,0,0,0;0,2,3,4,5,6,7,8,9,0;0,1,2,3,4,5,6,7,8,9\n

প্রথম পদক্ষেপের জন্য:

10,10\n\n

কোথায় \n নিউলাইন চরিত্রটি।

আউটপুট:

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

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

দ্রষ্টব্য: কেবল বৈধ পদক্ষেপের অনুমতি রয়েছে।

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

সেখানে জয় পাওয়ার জন্য, একজন খেলোয়াড়ের অবশ্যই একটি লাইনের সাথে সংলগ্ন সমস্ত স্কোয়ার থাকতে হবে। অর্থাৎ, সেই খেলোয়াড়ের অবশ্যই থাকা উচিতn বিজয়ী হওয়ার জন্য অবশ্যই একটি লাইনে নড়াচড়া করতে হবে।

সংলগ্ন:

  • প্রতিটি টালি একটি পয়েন্ট; উদাহরণস্বরূপ (0,0,0,0,0) হল একটি পয়েন্টd=5
  • সংলগ্ন টাইলস টাইলস যেমন তারা একই ইউনিট ডি-কিউবে উভয় পয়েন্ট। অন্য কথায়, চেবিশেভ দূরত্ব টাইলগুলির মধ্যে 1।
  • অন্য কথায়, যদি একটি বিন্দু একটি বিন্দুটির pসাথে সংলগ্ন হয় qতবে pতার সাথে সংশ্লিষ্ট স্থানাঙ্কের প্রতিটি স্থানাঙ্ক qএটির চেয়ে আলাদা নয়। অতিরিক্তভাবে, অন্তত স্থানাঙ্ক জুটিতে ঠিক একের দ্বারা পৃথক হয়।

লাইনস:

  • লাইনগুলি ভেক্টর এবং একটি টাইল দ্বারা সংজ্ঞায়িত করা হয়। সমীকরণ দ্বারা আঘাত করা প্রতিটি টাইল একটি লাইন:p0 + t<some vector with the same number of coordinates as p0>

সিমুলেশন এবং জয়ের শর্তাবলী:

  • গ্রেডিংয়ের জন্য প্রস্তুত হলে আপনার উত্তরে জানিয়ে দিন State অর্থাৎ আপনার উত্তরটি সম্পন্ন হয়েছে কিনা তা স্পষ্টভাবে নির্দেশ করুন indicate

  • যদি আপনার উত্তরটি সম্পন্ন হিসাবে চিহ্নিত করা হয় তবে কোডটিতে সর্বশেষ সম্পাদনার পরে কমপক্ষে 24 ঘন্টা অবধি গ্রেড করা হবে না।

  • প্রোগ্রামগুলি অবশ্যই অফলাইনে কাজ করবে। যদি কোনও প্রোগ্রাম প্রতারণামূলক বলে প্রমাণিত হয় তবে এটি স্বয়ংক্রিয়ভাবে একটি স্কোর অর্জন -1করবে এবং এর পরে আর স্কোর করা হবে না। (কেউ কীভাবে তাদের প্রোগ্রামগুলি প্রতারণা করে শেষ করবে?)

  • যদি আপনার প্রোগ্রামটি অবৈধ আউটপুট উত্পাদন করে তবে তা অবিলম্বে গেমটির ক্ষতি হিসাবে গণ্য হবে

  • যদি আপনি প্রোগ্রামটি 1 মিনিটের পরে আউটপুট উত্পাদন করতে ব্যর্থ হন তবে তা অবিলম্বে গেমটির ক্ষতি হিসাবে গণ্য হবে। প্রয়োজনে, গতির জন্য অনুকূলিতকরণ। আমি অন্য কোনও প্রোগ্রামের পরীক্ষা বন্ধ করতে এক ঘন্টা অপেক্ষা করতে চাই না।

  • প্রতিটি প্রোগ্রামের অন্যান্য প্রোগ্রামের বিরুদ্ধে প্রত্যেকের জন্য দ্বিগুণ চলবে nসীমার মধ্যে [3,6]এবং প্রতিটি dসীমার মধ্যে [2,5]একবার হিসেবে Xএবং একবার যেমন O। এটি এক দফা।

  • প্রতিটি গেমের জন্য একটি প্রোগ্রাম জয়ী হয়, এটি +3তার স্কোর এ যায়। প্রোগ্রামটি যদি বেঁধে রাখা হয় (এক জিতে 1 জয় এবং 1 পরাজয় বা উভয় গেমের সাথে সম্পর্ক) তবে তা পায় +1। প্রোগ্রামটি যদি হারিয়ে যায় তবে তা +0(যেমন কোনও পরিবর্তন হয় না) পায় ।

  • সর্বোচ্চ স্কোর সহ প্রোগ্রামটি জিতল। যদি কোনও টাই থাকা উচিত, তবে সর্বনিম্ন হারানো গেমগুলির সাথে প্রোগ্রামটি (বাঁধা প্রতিযোগীদের মধ্যে) জিতেছে।

দ্রষ্টব্য: উত্তরের সংখ্যার উপর নির্ভর করে আমার পরীক্ষাগুলি চালাতে সাহায্যের প্রয়োজন হতে পারে।

শুভকামনা! এবং অনুকরণগুলি আপনার পক্ষে সর্বদা চলতে পারে!

tic-tac-toe  king-of-the-hill 
— জাস্টিন
সূত্র
উইন-চেকার চ্যালেঞ্জ। <---- এই চ্যালেঞ্জটি একটি নির্দিষ্ট গেম জিতেছে কিনা তা পরীক্ষা করার জন্য প্রোগ্রাম তৈরি করা। এটি এই চ্যালেঞ্জের সাথে খুব সম্পর্কিত।
— জাস্টিন 4
স্বয়ংসম্পূর্ণ ট্যাগ যা আপনি শুধু উদ্ভাবিত ট্যাগ শ্রেণীবিন্যাস করার কিছু যোগ করে না। আমি মনে করি আপনার এটি অপসারণ করা উচিত।
— হাওয়ার্ড
পছন্দ করুন আমি লক্ষ্য করেছি যে প্রচুর প্রশ্নের মধ্যে সেই সীমাবদ্ধতা ছিল, তাই আমি ভেবেছিলাম একটি ট্যাগ যথাযথ হবে।
— জাস্টিন
4
একটি অদ্ভুত খেলা। একমাত্র বিজয়ী পদক্ষেপ না খেলাই।
— জার্মানি_গুই
(w, x, y, z) একটি বৈধ আউটপুট ফর্ম্যাট?
— আলেকজান্ডার-ব্রেট

উত্তর:

2

পাইথন ঘ

import random as rand
import re

def generateMoves(width, dim):
    l = [0] * dim
    while existsNotX(l, width - 1):
        yield l[:]
        for i in range(dim):
            if l[i] < width - 1:
                l[i] += 1
                break
            else:
                l[i] = 0
    yield l

def existsNotX(l, x):
    for i in l:
        if i != x:
            return True
    return False

input_s = input()
dims, moves = None, None
#this is to allow input as a single paste, instead of ENTER inputting.
try:
    dims, moves = input_s.splitlines()
except ValueError:
    dims = input_s
    moves = input()

rand.seed(moves + dims)

dims = eval(dims) #change into tuple

moves = moves.split(';')
if len(moves[0]):
    moves = [eval(m) for m in moves] #change into tuples

output =[x for x in generateMoves(dims[0], dims[1]) if x not in moves]
print(re.sub('[^\\d,]', '', str(output[rand.randint(0, len(output))])))

এটি কেবল এলোমেলো আই। এটি এলোমেলোভাবে চালাবলীর বাইরে এমন একটি পদক্ষেপ নির্বাচন করে যা এখনও উপলব্ধ।

— জাস্টিন
সূত্র
2

পাইথন 2.7

এটি একটি কার্য-অগ্রগতি জমা যা আমি অন্যান্য উত্তরদাতাদের একটি কঙ্কাল / অনুপ্রেরণা দেওয়ার জন্য সরবরাহ করছি providing এটি প্রতিটি সম্ভাব্য বিজয়ী লাইন তালিকাভুক্ত করে কাজ করে, তারপরে কতটা মূল্যবান তা অনুসারে সেই লাইনটি স্কোর করতে কিছু হিউরিস্টিক প্রয়োগ করে। বর্তমানে হিউরিস্টিকটি ফাঁকা (অতি গোপনীয় কাজ)। আমি জয় এবং সংঘর্ষের ত্রুটি পরিচালনাও যুক্ত করেছি।

সমস্যার উপর নোট

কতটি বিজয়ী লাইন আছে? 1-মাত্রিক ক্ষেত্রে বিবেচনা করুন; এখানে 2 টি শীর্ষ, 1 প্রান্ত এবং 1 লাইন রয়েছে। ২ টি মাত্রায়, আমাদের 4 টি শীর্ষ দুটি লাইন এবং 4 টি প্রান্ত 2 * এন লাইনের সাথে যুক্ত হয়েছে n 3 মাত্রায়, আমাদের 8 টি উল্লম্ব 4 টি লাইন দ্বারা যুক্ত হয়েছে, 12 প্রান্তগুলি 6 * এন লাইনের সাথে যুক্ত হয়েছে, এবং 6 টি মুখ 3*n^2লাইনগুলিতে যুক্ত হয়েছে।

সাধারণভাবে, আমাদের একটি প্রান্তবিন্দু 0-পল, একটি প্রান্ত 1-পল, ইত্যাদি তারপর দিন কল দিন N(i)ই-মতকে এর বোঝাতে নম্বর, dমাত্রার সংখ্যা, এবং nপার্শ্ব দৈর্ঘ্য। তারপরে বিজয়ী লাইনের সংখ্যাটি0.5*sum(N(i)*n^i,i=0..d-1) ।

প্রতি উইকিপিডিয়া, N(i)=2^(d-i)*d!/(i!*(n-1)!)সুতরাং চূড়ান্ত সূত্রটি হ'ল:

sum(2^(d-i-1) n^i d! / (i! * (n-i)!),i=0..d-1)

যা উলফ্রাম | আলফা খুব পছন্দ করে না। এটি খুব তাড়াতাড়ি বড় হয়ে যায়, তাই আমার প্রোগ্রামটি d> 8-র জন্য পরিচালনাযোগ্য রানটাইম থাকার আশা করি না।

কিছু ফলাফল (বিন্যাস সম্পর্কে দুঃখিত:

d\n 0   1    2      3      4       5        6        7         8         9
0   1   1    1      1      1       1        1        1         1         1
1   2   4    6      8      10      12       14       16        18        20
2   4   11   26     47     74      107      146      191       242       299
3   8   40   120    272    520     888      1400     2080      2952      4040
4   16  117  492    1437   3372    6837     12492    21117     33612     50997
5   32  364  2016   7448   21280   51012    107744   206896    368928    620060
6   64  1093 8128   37969  131776  372709   908608   1979713   3951424   7352101
7   128 3280 32640  192032 807040  2687088  7548800  18640960  41611392  85656080
8   256 9834 130809 966714 4907769 19200234 62070009 173533434 432891129 985263594

ইনপুট / আউটপুট

এই মুহুর্তে, ইনপুটটি ইনপুট হিসাবে হওয়া দরকার: tictactoe.py <ret> n,d <ret> move;move <ret>- একাধিক লাইন নোট করুন এবং চূড়ান্ত নয়; ।

(x_1,x_2,x_3...)উদাহরণস্বরূপ আউটপুটটি দেখে মনে হচ্ছে :

tictactoe.py <ret> 6,5 <ret> <ret> => 0, 0, 0, 0, 0

tictactoe.py <ret> 6,5 <ret> 0,0,0,0,0;0,0,0,0,5 <ret> => 0, 0, 0, 5, 0

# Notes on terminology:
#
# - A hypercube is the region [0,n]^d
# - An i-facet is an i-dimensional facet of a hypercube,
#   which is to say, a 0-facet is a vertex, a 1-facet an
#   edge, a 2-facet a face, and so on.
# - Any tuple {0,n}^i is a vertex of an i-hypercube
#   which is why I've used vertex to describe such
#   tuples
# - A winning line is a set of n coordinates which joins
#   two opposite i-facets
# - i-facets are opposite if they differ in every co-
#   ordinate which defines them
#
# Test Data:
#  


import numpy
import itertools

def removeDuplicates(seq):
    noDupes = []
    [noDupes.append(i) for i in seq if not noDupes.count(i)]
    return noDupes 


def listPairedVertices (i,n):
    """
    listPairedVertices returns a list L of elements of {0,n}^i which has the
    property that for every l in L, there does not exist l' such that
    l+l' = {n}^i.
    """

    vertices = numpy.array([[b*(n-1)  for b in a] for a in [
        list(map(int,list(numpy.binary_repr(x,i)))) for x in range(2**i)
    ]])
    result = []
    while len(vertices)>1:
        for j in range(len(vertices)):
            if numpy.all(vertices[j] + vertices[0] == [n-1]*i):
                result.append(vertices[0])
                vertices=numpy.delete(vertices,[0,j],axis=0)
                break
    return result


def listSequences (d,l):
    """
    listSequences returns the subset of {0,1}^d having precisely n 1s.
    """
    return numpy.array([
        r for r in itertools.product([0,1],repeat=d) if sum(r)==l
    ])


def listPaddedConstants (s,n):
    """
    listPaddedConstants takes a sequence in {0,1}^d and returns a number in
    {0..n}^sum(s) padded by s
    """
    result = numpy.zeros([n**sum(s),len(s)],dtype=numpy.int)
    for i,x in enumerate([list(z) for z in 
        itertools.product(range(n),repeat=sum(s))]):
        for j in range(len(s)):
            if s[j]: result[i][j] = x.pop()
    return result


def listWinningVectorsForDimension(d,i,n):
    """
    List the winning lines joining opposite i-facets of the hypercube.

    An i-facet is defined by taking a vertex v and a sequence s, then forming 
    a co-ordinate C by padding v with zeroes in the positions indicated by s.
    If we consider s = s_0.e_0 + s_1+e_1... where the e_j are the canonical
    basis for R^d, then the formula of the i-facet is 
        C+x_0.s_0.e_0+x_1.s_1.e_1... 
    for all vectors x = (x_0,x_1...) in R^n

    We know that winning lines only start at integral positions, and that the
    value of a will only be needed when s_j is nonempty, so the start point S
    of a winning line is in fact determined by:
     + vertex v in {0,n}^(d-i), padded by s
     + a in R^i, padded by the complement of s, s'

    Having performed the following operations, the co-ordinates of the winning
    lines are abs(S-k*s') for k in [0..n-1]
    """
    vertices = listPairedVertices(d-i,n)
    sequences = listSequences(d,i)
    result = []
    for s in sequences:
        for v in vertices:
            C = [0]*d
            j = 0
            for index in range(d):
                if s[index]: C[index] = 0
                else: 
                    C[index] = v[j]
                    j+=1
            result += [
                [numpy.absolute(S-k*(numpy.absolute(s-1))) for k in range(n)] 
                    for S in [C+a for a in listPaddedConstants(s,n)]
            ]
    return result


def AllWinningLines (d,n):
    """
    has the structure [[x_1,x_2,x_3],[y_1,y_2,y_3]] where each l_k is a
    length-d co-ordinate
    """
    result = []
    for i in range(d):
        result += listWinningVectorsForDimension(d,i,n)
    return result


def movesAlreadyMade ():
    """
    Returns a list of co-ordinates of moves already made read from STDIN
    """
    parameters = raw_input()
    moves = raw_input()
    parameters = list(map(int,parameters.split(',')))
    moves = [map(int,a.split(',')) for a in moves.split(';')] \
        if moves != '' else []
    return {'n':parameters[0], 'd':parameters[1], 'moves':moves}

def scoreLine (moves, line, scores, n):
    """
    Gives each line a score based on whatever logic I choose
    """
    myMoves          = moves[0::2]
    theirMoves       = moves[1::2]
    if len(moves)%2: myMoves, theirMoves = theirMoves, myMoves

    lineHasMyMove    = 0
    lineHasTheirMove = 0
    score            = 0

    for coord in line:
        if coord.tolist() in myMoves: 
            lineHasMyMove += 1
            if coord.tolist() in theirMoves: raise Exception('Move clash')
        elif coord.tolist() in theirMoves: lineHasTheirMove += 1

    if lineHasMyMove == len(line):
        raise Exception('I have won')
    elif lineHasTheirMove == len(line):
        raise Exception('They have won')
    elif lineHasMyMove and lineHasTheirMove: 
        pass
    elif lineHasTheirMove == len(line)-1: 
        score = n**lineHasTheirMove
    else: 
        score = n**lineHasMyMove

    for coord in line:
        if coord.tolist() not in moves: 
            scores[tuple(coord)]+=score

def main():
    """
    Throw it all together
    """
    data      = movesAlreadyMade()
    dimension = data['d']
    length    = data['n']
    lines     = AllWinningLines(dimension, length)
    scores    = numpy.zeros([length]*dimension, dtype=numpy.int)

    try: [scoreLine(data['moves'], line, scores, length) for line in lines]
    except Exception as E:
            print 'ERROR: ' + E.args[0]
            return
    print ','.join(map(
        str,numpy.unravel_index(numpy.argmax(scores),scores.shape)
        ))


if __name__ == "__main__": main()

সম্পাদনা করুন: I / O এর জন্য যুক্তি যুক্ত করা হয়েছে। আমি বিশ্বাস করি এটি এখন চিহ্নিত করার জন্য প্রস্তুত

দ্রষ্টব্য যে এই মন্তব্যটি প্রথমে একটি স্থানধারক ছিল যা আমি মুছে ফেলেছি এবং মুছে ফেলেছি।

— আলেকজান্ডার-ব্রেট
সূত্র
1

পাইথন 2

import re
import itertools

input_s = raw_input()
dims, moves = None, None
#this is to allow input as a single paste, instead of ENTER inputting.
try:
    dims, moves = input_s.splitlines()
except ValueError:
    dims = input_s
    moves = raw_input()

dims = eval(dims) #change into tuple

moves = moves.split(';')
if len(moves[0]):
    moves = [eval(m) for m in moves] #change into tuples

allSpaces = [x for x in itertools.product(range(dims[0]), repeat=dims[1])]
move = None
for space in allSpaces:
    if space not in moves:
        move = space
        break
print(re.sub('[^\\d,]', '', str(move)))

বেশিরভাগ কোড হুবুহু কুইকুনাক্সের এলোমেলো এআই এর মতোই । এলোমেলোভাবে কোনও পদক্ষেপ নির্বাচন করার পরিবর্তে, এটি অভিধানের প্রথম দিকের চলটি বেছে নিয়েছে (অর্থাত (0,0, ... 0), তারপরে (0,0, ... 1), তারপরে (0,0, ... 2) ইত্যাদি))

এটি একটি চমত্কার জঞ্জাল কৌশল, তবে এটি প্রায়শই এলোমেলোভাবে খেলে।

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