পাইথন 2 3, 141-15 = 126
def win(x,y):w([y]*x)
w=lambda b,f=print:not[f(r+1,c+1)for r,p in enumerate(b)for c in range(p)if(r+c)*w(b[:r]+[min(i,c)for i in b[r:]],max)]
ব্রুট-ফোর্স মিনিম্যাক্স অনুসন্ধান। প্রতিটি সম্ভাব্য পদক্ষেপের জন্য, আমরা পুনরাবৃত্তি করে দেখতে পারি যে আমরা সেই পদক্ষেপ নেওয়ার পরে প্রতিপক্ষ জিততে পারে কিনা। বেশ দুর্বলভাবে গল্ফড; অন্য কারও আরও ভাল করতে সক্ষম হওয়া উচিত। এটি এপিএলের একটি কাজের মতো অনুভব করে।
win
পাবলিক ইন্টারফেস। এটি বোর্ডের মাত্রা নেয়, এটিকে বোর্ডের উপস্থাপনায় রূপান্তরিত করে এবং এটিকে পাস করে w
।
w
মিনিম্যাক্স অ্যালগরিদম। এটি বোর্ডের স্থিতি নেয়, সমস্ত পদক্ষেপের চেষ্টা করে, একটি তালিকা তৈরি করে যার উপাদানগুলি বিজয়ী চলনের সাথে সামঞ্জস্য করে এবং তালিকাটি খালি থাকলে সত্যটি ফেরত দেয়। ডিফল্ট হিসাবে f=print
, তালিকা তৈরির বিজয়ী পদক্ষেপ মুদ্রণের একটি পার্শ্ব প্রতিক্রিয়া রয়েছে। বিজয়ী পদক্ষেপের একটি তালিকা ফিরে এলে ফাংশনটির নামটি আরও বোধগম্য হতে ব্যবহৃত হত, তবে তারপরে আমি not
স্থানটি বাঁচাতে তালিকার সামনে সরিয়ে নিয়েছি ।
for r,p in enumerate(b)for c in xrange(p) if(r+c)
: সমস্ত সম্ভাব্য পদক্ষেপের উপর Iterate। 1 1
কিছুটা বেস কেসকে সরল করে আইনী পদক্ষেপ হিসাবে বিবেচনা করা হয় না।
b[:r]+[min(i,c)for i in b[r:]]
: স্থানাঙ্ক r
এবং প্রতিনিধিত্বকারী পদক্ষেপের পরে বোর্ডের অবস্থা তৈরি করুন c
।
w(b[:r]+[min(i,c)for i in b[r:]],max)
: নতুন রাষ্ট্রটি একটি হারানো রাষ্ট্র কিনা তা দেখার জন্য পুনরাবৃত্তি করুন। max
সবচেয়ে সংক্ষিপ্ত ফাংশনটি আমি খুঁজে পেতে পারি যে এটি দুটি পূর্ণসংখ্যার যুক্তি গ্রহণ করবে এবং অভিযোগ করবে না।
f(r+1,c+1)
: f
মুদ্রিত হলে মুভটি মুদ্রণ করে। যাই হোক না কেন f
, এটি তালিকা দৈর্ঘ্যের প্যাড করার জন্য একটি মান উত্পাদন করে।
not [...]
: খালি তালিকার জন্য এবং অকার্যকর জন্য not
ফেরত ।True
False
মূল পাইথন 2 কোড, সম্পূর্ণরূপে নিরবচ্ছিন্ন, অনেক বড় ইনপুটগুলি পরিচালনা করতে মেমোয়েজেশন সহ:
def win(x, y):
for row, column in _win(Board([y]*x)):
print row+1, column+1
class MemoDict(dict):
def __init__(self, func):
self.memofunc = func
def __missing__(self, key):
self[key] = retval = self.memofunc(key)
return retval
def memoize(func):
return MemoDict(func).__getitem__
def _normalize(state):
state = tuple(state)
if 0 in state:
state = state[:state.index(0)]
return state
class Board(object):
def __init__(self, state):
self.state = _normalize(state)
def __eq__(self, other):
if not isinstance(other, Board):
return NotImplemented
return self.state == other.state
def __hash__(self):
return hash(self.state)
def after(self, move):
row, column = move
newstate = list(self.state)
for i in xrange(row, len(newstate)):
newstate[i] = min(newstate[i], column)
return Board(newstate)
def moves(self):
for row, pieces in enumerate(self.state):
for column in xrange(pieces):
if (row, column) != (0, 0):
yield row, column
def lost(self):
return self.state == (1,)
@memoize
def _win(board):
return [move for move in board.moves() if not _win(board.after(move))]
ডেমো:
>>> for i in xrange(7, 11):
... for j in xrange(7, 11):
... print 'Dimensions: {} by {}'.format(i, j)
... win(i, j)
...
Dimensions: 7 by 7
2 2
Dimensions: 7 by 8
3 3
Dimensions: 7 by 9
3 4
Dimensions: 7 by 10
2 3
Dimensions: 8 by 7
3 3
Dimensions: 8 by 8
2 2
Dimensions: 8 by 9
6 7
Dimensions: 8 by 10
4 9
5 6
Dimensions: 9 by 7
4 3
Dimensions: 9 by 8
7 6
Dimensions: 9 by 9
2 2
Dimensions: 9 by 10
7 8
9 5
Dimensions: 10 by 7
3 2
Dimensions: 10 by 8
6 5
9 4
Dimensions: 10 by 9
5 9
8 7
Dimensions: 10 by 10
2 2