Йордан обнови решението на 25.11.2022 14:39 (преди над 1 година)
+FEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
+
+class ChessException(Exception):
+ """Chess exception"""
+ pass
+
+# r - black R-white
+# "R/r" - Rook (топ)
+# - "N/n" - Knight (кон) /използва се "N", а не "K", защото се припокриват с царя/
+# - "B/b" - Bishop (офицер)
+# - "Q/q" - Queen (дама)
+# - "K/k" - King (цар)
+# - "P/p" - Pawn (пешка)
+
+BLACK_FIGURES = ['r', 'n', 'b', 'k', 'q', 'p']
+WHITE_FIGURES = ['R', 'N', 'B', 'K', 'Q', 'P']
+
+class ChessPosition:
+ def __init__(self, fen):
+ self.__modified_fens = self.modify_fens(fen)
+ self.validateFen(fen)
+ self.__fen = fen
+
+ def validateFen(self, fen: str) -> bool:
+ #check whether two Kings are adjacent
+ ROW_SIZE = 8
+ bk_indices = [i for i, x in enumerate(fen) if x == "k"]
+ wk_indixies = [i for i, x in enumerate(fen) if x == "K"]
+
+ if len(bk_indices) != 1:
+ raise ChessException
+ if len(wk_indixies) != 1:
+ raise ChessException
+
+ bk_index = bk_indices[0]
+
+ neighbours = [bk_index - 1, bk_index + 1,
+ bk_index - ROW_SIZE, bk_index + ROW_SIZE,
+ bk_index - 1 - ROW_SIZE, bk_index - 1 + ROW_SIZE,
+ bk_index + 1 - ROW_SIZE, bk_index + 1 + ROW_SIZE]
+ #modify the fen for 3P4 -> ---P----
+ for neighbour in neighbours:
+ try:
+ if neighbour >= 0 and self.__modified_fens[neighbour] == 'K':
+ raise ChessException
+ except IndexError:
+ continue
+
+ #check for pawns
+ rows = fen.split('/')
+ if 'p' in rows[0] or 'p' in rows[-1]:
+ raise ChessException
+
+ if 'P' in rows[0] or 'P' in rows[-1]:
+ raise ChessException
+
+ def modify_fens(self, fenstr):
+ for el in fenstr:
+ if '1' <= el <= '8':
+ i = fenstr.index(el)
+ before = fenstr[0:i]
+ after = fenstr[i + 1:]
+ middle = int(el) * '-'
+ fenstr = before + middle + after
+ return fenstr
+
+ def get_white_score(self):
+ white_figures = list(filter(lambda x : x in WHITE_FIGURES, self.__fen))
+ return ChessScore(white_figures)
+
+ def get_black_score(self):
+ black_figures = list(filter(lambda x : x in BLACK_FIGURES, self.__fen))
+ return ChessScore(black_figures)
+
+ def white_is_winning(self):
+ white_chess_score = self.get_white_score()
+ black_chess_score = self.get_black_score()
+ return white_chess_score > black_chess_score
+
+ def black_is_winning(self):
+ white_chess_score = self.get_white_score()
+ black_chess_score = self.get_black_score()
+ return black_chess_score > white_chess_score
+
+ def is_equal(self):
+ white_chess_score = self.get_white_score()
+ black_chess_score = self.get_black_score()
+ return black_chess_score == white_chess_score
+
+ def __str__(self):
+ return self.__fen
+
+ def __len__(self):
+ return len(list(filter(lambda x : x in WHITE_FIGURES or x in BLACK_FIGURES, self.__fen)))
+
+ def __getitem__(self, index):
+ #A, B, C, ... -> horizontal
+ #8, 7, 6, ... -> vertical
+ board_values = { 8: 0, 7: 1, 6: 2, 5: 3, 4: 4, 3: 5, 2: 6, 1: 7}
+ horizontal = index[0]
+ vertical = int(index[1])
+
+ horizontal = ord(horizontal) - ord('A')
+ vertical = board_values[vertical]
+
+ board = self.__modified_fens.split('/')
+ return board[vertical][horizontal]
+
+
+class ChessScore:
+ def __init__(self, figures):
+ self._figures = figures
+ self.FIGURE_VALUES = {'r': 5, 'n': 3, 'b': 3, 'k': 4, 'q': 9, 'p': 1,
+ 'R': 5, 'N': 3, 'B': 3, 'K': 4, 'Q': 9, 'P': 1}
+ self.validate_figures()
+
+ def validate_figures(self):
+ for figure in self._figures:
+ if figure not in self.FIGURE_VALUES.keys():
+ raise ChessException
+
+ def __str__(self):
+ return str(sum(map(lambda x : self.FIGURE_VALUES[x], self._figures)))
+
+ def __int__(self):
+ return int(self.__str__())
+
+ def __gt__(self, other):
+ return int(self.__str__()) > int(other.__str__())
+
+ def __lt__(self, other):
+ return int(self.__str__()) < int(other.__str__())
+
+ def __eq__(self, other):
+ return int(self.__str__()) == int(other.__str__())
+
+ def __le__(self, other):
+ return int(self.__str__()) <= int(other.__str__())
+
+ def __ge__(self, other):
+ return int(self.__str__()) >= int(other.__str__())
+
+ def __ne__(self, other):
+ return int(self.__str__()) != int(other.__str__())
+
+ def __add__(self, other):
+ return int(self.__str__()) + int(other.__str__())
+
+ def __sub__(self, other):
+ return int(self.__str__()) - int(other.__str__())
Реално погледнато, методи на този клас не ти трябва. Да наследиш
Exceptionе достатъчно.Можеш да изградиш долния списък от горния, използвайки
str.lower, но и това е ок.тук трябва да е enumerate(self._modified_fen) защото подолу проверките са в modified_fen и така вече би работило добро
Можеш да приложиш
lowerна реда и да сравниш само с малки букви, за да спестиш два реда.Тук тирето е ок, но се подсигури, че когато попитам какво има на тази позиция, получавам отговора, който е дефиниран в условието.
Бих предпочел да подготвя речник, който съдържа fen в готов формат, така че тук просто да попитам какво има на конкретните координати, без да правя допълнителни проверки и модификации на координатите. Тази дефиниция с мапинга на индексите ми седи изкуствено. Обхождайки списъка отзад напред би постигнал същото, но без експлицитно дефиниране на съответствията.