Решение на От ливадите до Лас Вегас (и назад) от Александър Стоилов

Обратно към всички решения

Към профила на Александър Стоилов

Резултати

  • 10 точки от тестове
  • 0 бонус точки
  • 10 точки общо
  • 15 успешни тест(а)
  • 0 неуспешни тест(а)

Код

from random import shuffle as rand_shuffle

Не би имало конфликт. from random import shuffle представя shuffle като глобално име, а shuffle в Deck е метод на класа и в глобалния скоуп е Deck.shuffle, така че би било наред.

from typing import List
CUT_CARD_COUNTER = 3
CARD_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
BELOT_FACES = ['7', '8', '9', '10', 'J', 'Q', 'K', 'A']
POKER_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
CARD_SUITES = ['clubs', 'diamonds', 'hearts', 'spades']
DEALING_DIRECTIONS = {
"LEFT_TO_RIGHT": "ltr",
"RIGHT_TO_LEFT": "rtl",
}
class Card:
def __init__(self, suit: str, face: str) -> None:
self._set_suit(suit)
self._set_face(face)
def _set_suit(self, suit):
if suit in CARD_SUITES:
self._suit = suit
else:
raise ValueError("Unfitting card suit given.")
def _set_face(self, face):
if face in CARD_FACES:
self.face = face
else:
raise ValueError("Unfitting card face given.")
# def __str__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
# def __repr__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
def get_suit(self) -> str:
return self._suit
def get_face(self) -> str:
return self.face
class Deck:
def __init__(self, face_filter: list[str] = []) -> None:
self._cards = []
if face_filter != []:
self._set_cards(face_filter)
else:
self._set_cards(CARD_FACES)
def _set_cards(self, face_filter):
self._cards.clear()
for card_face in face_filter:
if card_face in CARD_FACES:
for card_suit in CARD_SUITES:
self._cards.append(Card(card_suit, card_face))
else:
raise ValueError("Unfitting card face processed.")
def __len__(self) -> int:
return len(self._cards)
# def __str__(self) -> str:
# return f'Deck cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Deck cards: {self._cards}'
def add_card(self, card: Card):
self._cards.append(card)
def cut(self):
cut_counter = min(CUT_CARD_COUNTER, len(self._cards) - 1)
while cut_counter > 0:
self._cards.append(self._cards.pop(0))
cut_counter -= 1
def shuffle(self):
rand_shuffle(self._cards)
def get_cards(self):
return self._cards
class Player:
def __init__(self) -> None:
self._cards = []
def remove_card(self, card: Card):
self._cards.remove(card)
def add_card(self, card: Card):
self._cards.append(card)
def set_cards(self, cards: List[Card]):
self._cards = cards
def get_cards(self):
return self._cards
# def __str__(self) -> str:
# return f'Player cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Player cards: {self._cards}'
class Game:
def __init__(self, number_of_players: int, dealing_direction: str, dealing_instructions: tuple[int]) -> None:
self._set_players(number_of_players)
self._set_dealing_direction(dealing_direction)
self._set_dealing_instructions(dealing_instructions)
self._set_full_deck()
def _set_players(self, number_of_players):
self._number_of_players = number_of_players
self._players = []
for _ in range(number_of_players):
self._players.append(Player())
def _set_dealing_direction(self, dealing_direction):
if dealing_direction in DEALING_DIRECTIONS.values():
self.dealing_direction = dealing_direction
else:
raise ValueError("Unfitting dealing direction given.")
def _set_dealing_instructions(self, dealing_instructions):
self._dealing_instructions = dealing_instructions
def _set_full_deck(self):
self._deck = Deck(CARD_FACES)
def set_face_filtered_deck(self, face_filter):
self._deck = Deck(face_filter)
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
while player.get_cards():
self._deck.add_card(player.get_cards().pop(0))
self._deck.shuffle()
self._deck.cut()
def get_players_to_serve_ordered(self, player: Player):
idx = self._players.index(player)
pre = self._players[:idx]
post = self._players[idx:]
players_to_serve_order = []
if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
players_to_serve_order = post + pre
elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
else:
raise ValueError("Unfitting dealing direction processed.")
return players_to_serve_order
def deal(self, player: Player):
players_to_serve_ordered = self.get_players_to_serve_ordered(player)
players_cards = {player: [] for player in players_to_serve_ordered}
for iteration in self._dealing_instructions:
for _player in players_to_serve_ordered:
for _ in range(iteration):
players_cards[_player].append(self._deck.get_cards().pop(0))
for player, cards in players_cards.items():
self._players[self._players.index(player)].set_cards(cards)
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self) -> None:
super().__init__(4, 'ltr', (2, 3, 3))
self.set_face_filtered_deck(BELOT_FACES)
class Poker(Game):
def __init__(self) -> None:
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.set_face_filtered_deck(POKER_FACES)
# ----------------------------------- DEBUG ZONE -------------------------------------
'''
def printer(game, cnt: int, *args):
print()
print(cnt, '//')
print('deck:', game.get_deck())
print('dupl:', [dupl for dupl in game.get_deck().get_cards()
if game.get_deck().get_cards().count(dupl) > 1])
print('size of deck:', len(game.get_deck()))
print(*args)
deck = Deck()
print(-10, deck.get_cards())
print(-10, len(deck.get_cards()))
game = Game(2, 'ltr', (2,))
players = game.get_players()
game.prepare_deck()
game.deal(players[0])
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
game.prepare_deck()
game.deal(players[1])
belot = Belot()
players = belot.get_players()
printer(belot, 0)
belot.prepare_deck()
printer(belot, 1)
belot.deal(players[0])
printer(belot, 2, 'belot.players:', belot.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
belot.prepare_deck()
printer(belot, 3, 'belot.players:', belot.get_players())
belot.deal(players[1])
printer(belot, 4, 'belot.players:', belot.get_players())
belot.prepare_deck()
printer(belot, 5, 'belot.players:', belot.get_players())
belot.deal(players[3])
printer(belot, 6, 'belot.players:', belot.get_players())
del belot
poker = Poker()
players = poker.get_players()
printer(poker, 0)
poker.prepare_deck()
printer(poker, 1)
poker.deal(players[0])
printer(poker, 2, 'poker.players:', poker.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
poker.prepare_deck()
printer(poker, 3, 'poker.players:', poker.get_players())
poker.deal(players[1])
printer(poker, 4, 'poker.players:', poker.get_players())
del poker
'''

Лог от изпълнението

...............
----------------------------------------------------------------------
Ran 15 tests in 0.182s

OK

История (5 версии и 9 коментара)

Александър обнови решението на 14.11.2022 21:07 (преди над 1 година)

+from random import shuffle as rand_shuffle
+from typing import List
+
+CUT_CARD_COUNTER = 3
+
+CARD_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+BELOT_FACES = ['7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+POKER_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+
+CARD_SUITES = ['clubs', 'diamonds', 'hearts', 'spades']
+
+DEALING_DIRECTIONS = {
+ "LEFT_TO_RIGHT": "ltr",
+ "RIGHT_TO_LEFT": "rtl",
+}
+
+
+class Card:
+
+ def __init__(self, suit: str, face: str) -> None:
+ self._set_suit(suit)
+ self._set_face(face)
+
+ def _set_suit(self, suit):
+ if suit in CARD_SUITES:
+ self._suit = suit
+ else:
+ raise ValueError("Unfitting card suit given.")
+
+ def _set_face(self, face):
+ if face in CARD_FACES:
+ self.face = face
+ else:
+ raise ValueError("Unfitting card face given.")
+
+ def __str__(self) -> str:
+ return f'{self.face} of {self._suit.capitalize()}'
+
+ def __repr__(self) -> str:
+ return f'{self.face} of {self._suit.capitalize()}'
+
+ def get_suit(self) -> str:
+ return self._suit
+
+ def get_face(self) -> str:
+ return self.face
+
+
+class Deck:
+
+ def __init__(self, face_filter: list[str] = []) -> None:
+ self._cards = []
+ self._set_cards(face_filter)
+
+ def _set_cards(self, face_filter):
+ self._cards.clear()
+ for card_face in face_filter:
+ if card_face in CARD_FACES:
+ for card_suit in CARD_SUITES:
+ self._cards.append(Card(card_suit, card_face))
+ else:
+ raise ValueError("Unfitting card face processed.")
+
+ def __len__(self) -> int:
+ return len(self._cards)
+
+ def __str__(self) -> str:
+ return f'Deck cards: {self._cards}'
+
+ def __repr__(self) -> str:
+ return f'Deck cards: {self._cards}'
+
+ def add_card(self, card: Card):
+ self._cards.append(card)
+
+ def cut(self):
+ cut_counter = min(CUT_CARD_COUNTER, len(self._cards) - 1)
+ while cut_counter > 0:
+ self._cards.append(self._cards.pop(0))
+ cut_counter -= 1
+
+ def shuffle(self):
+ rand_shuffle(self._cards)
+
+ def get_cards(self):
+ return self._cards
+
+
+class Player:
+
+ def __init__(self) -> None:
+ self._cards = []
+
+ def remove_card(self, card: Card):
+ self._cards.remove(card)
+
+ def add_card(self, card: Card):
+ self._cards.append(card)
+
+ def set_cards(self, cards: List[Card]):
+ self._cards = cards
+
+ def get_cards(self):
+ return self._cards
+
+ def __str__(self) -> str:
+ return f'Player cards: {self._cards}'
+
+ def __repr__(self) -> str:
+ return f'Player cards: {self._cards}'
+
+
+class Game:
+ def __init__(self, number_of_players: int, dealing_direction: str, dealing_instructions: tuple[int]) -> None:
+ self._set_players(number_of_players)
+ self._set_dealing_direction(dealing_direction)
+ self._set_dealing_instructions(dealing_instructions)
+ self._set_empty_deck()
+
+ def _set_players(self, number_of_players):
+ self._number_of_players = number_of_players
+ self._players = []
+ for _ in range(number_of_players):
+ self._players.append(Player())
+
+ def _set_dealing_direction(self, dealing_direction):
+ if dealing_direction in DEALING_DIRECTIONS.values():
+ self.dealing_direction = dealing_direction
+ else:
+ raise ValueError("Unfitting dealing direction given.")
+
+ def _set_dealing_instructions(self, dealing_instructions):
+ self._dealing_instructions = dealing_instructions
+
+ def _set_empty_deck(self):
+ self._deck = Deck()
+
+ def set_face_filtered_deck(self, face_filter):
+ self._deck = Deck(face_filter)
+
+ def get_players(self):
+ return self._players
+
+ def prepare_deck(self):
+ for player in self._players:
+ while player.get_cards():
+ self._deck.add_card(player.get_cards().pop(0))
+ self._deck.shuffle()
+ self._deck.cut()
+
+ def deal(self, player: Player):
+
+ def get_players_to_serve_ordered():
+ idx = self._players.index(player)
+ pre = self._players[:idx]
+ post = self._players[idx:]
+ players_to_serve_order = []
+ if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
+ players_to_serve_order = post + pre
+ elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
+ players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
+ else:
+ raise ValueError("Unfitting dealing direction processed.")
+ return players_to_serve_order
+
+ players_to_serve_ordered = get_players_to_serve_ordered()
+ players_cards = {player: [] for player in players_to_serve_ordered}
+
+ for iteration in self._dealing_instructions:
+ for cur_player_idx in range(len(players_to_serve_ordered)):
+ player = players_to_serve_ordered[cur_player_idx]
+ for _ in range(iteration):
+ players_cards[player].append(self._deck.get_cards().pop(0))
+
+ for player, cards in players_cards.items():
+ self._players[self._players.index(player)].set_cards(cards)
+
+ def get_deck(self):
+ return self._deck
+
+
+class Belot(Game):
+ def __init__(self) -> None:
+ super().__init__(4, 'ltr', (2, 3, 3))
+ self.set_face_filtered_deck(BELOT_FACES)
+
+
+class Poker(Game):
+ def __init__(self) -> None:
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
+ self.set_face_filtered_deck(POKER_FACES)
+
+
+# ----------------------------------- DEBUG ZONE -------------------------------------
+'''
+def printer(game, cnt: int, *args):
+ print()
+ print(cnt, '//')
+ print('deck:', game.get_deck())
+ print('dupl:', [dupl for dupl in game.get_deck().get_cards()
+ if game.get_deck().get_cards().count(dupl) > 1])
+ print('size of deck:', len(game.get_deck()))
+ print(*args)
+
+
+belot = Belot()
+players = belot.get_players()
+printer(belot, 0)
+belot.prepare_deck()
+printer(belot, 1)
+belot.deal(players[0])
+printer(belot, 2, 'belot.players:', belot.get_players())
+# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
+belot.prepare_deck()
+printer(belot, 3, 'belot.players:', belot.get_players())
+belot.deal(players[1])
+printer(belot, 4, 'belot.players:', belot.get_players())
+belot.prepare_deck()
+printer(belot, 5, 'belot.players:', belot.get_players())
+belot.deal(players[3])
+printer(belot, 6, 'belot.players:', belot.get_players())
+del belot
+
+# poker = Poker()
+# players = poker.get_players()
+# printer(poker, 0)
+# poker.prepare_deck()
+# printer(poker, 1)
+# poker.deal(players[0])
+# printer(poker, 2, 'poker.players:', poker.get_players())
+# # Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
+# poker.prepare_deck()
+# printer(poker, 3, 'poker.players:', poker.get_players())
+# poker.deal(players[1])
+# printer(poker, 4, 'poker.players:', poker.get_players())
+# del poker
+'''

Александър обнови решението на 14.11.2022 21:14 (преди над 1 година)

from random import shuffle as rand_shuffle
from typing import List
CUT_CARD_COUNTER = 3
CARD_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
BELOT_FACES = ['7', '8', '9', '10', 'J', 'Q', 'K', 'A']
POKER_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
CARD_SUITES = ['clubs', 'diamonds', 'hearts', 'spades']
DEALING_DIRECTIONS = {
"LEFT_TO_RIGHT": "ltr",
"RIGHT_TO_LEFT": "rtl",
}
class Card:
def __init__(self, suit: str, face: str) -> None:
self._set_suit(suit)
self._set_face(face)
def _set_suit(self, suit):
if suit in CARD_SUITES:
self._suit = suit
else:
raise ValueError("Unfitting card suit given.")
def _set_face(self, face):
if face in CARD_FACES:
self.face = face
else:
raise ValueError("Unfitting card face given.")
- def __str__(self) -> str:
- return f'{self.face} of {self._suit.capitalize()}'
+ # def __str__(self) -> str:
+ # return f'{self.face} of {self._suit.capitalize()}'
- def __repr__(self) -> str:
- return f'{self.face} of {self._suit.capitalize()}'
+ # def __repr__(self) -> str:
+ # return f'{self.face} of {self._suit.capitalize()}'
def get_suit(self) -> str:
return self._suit
def get_face(self) -> str:
return self.face
class Deck:
def __init__(self, face_filter: list[str] = []) -> None:
self._cards = []
self._set_cards(face_filter)
def _set_cards(self, face_filter):
self._cards.clear()
for card_face in face_filter:
if card_face in CARD_FACES:
for card_suit in CARD_SUITES:
self._cards.append(Card(card_suit, card_face))
else:
raise ValueError("Unfitting card face processed.")
def __len__(self) -> int:
return len(self._cards)
- def __str__(self) -> str:
- return f'Deck cards: {self._cards}'
+ # def __str__(self) -> str:
+ # return f'Deck cards: {self._cards}'
- def __repr__(self) -> str:
- return f'Deck cards: {self._cards}'
+ # def __repr__(self) -> str:
+ # return f'Deck cards: {self._cards}'
def add_card(self, card: Card):
self._cards.append(card)
def cut(self):
cut_counter = min(CUT_CARD_COUNTER, len(self._cards) - 1)
while cut_counter > 0:
self._cards.append(self._cards.pop(0))
cut_counter -= 1
def shuffle(self):
rand_shuffle(self._cards)
def get_cards(self):
return self._cards
class Player:
def __init__(self) -> None:
self._cards = []
def remove_card(self, card: Card):
self._cards.remove(card)
def add_card(self, card: Card):
self._cards.append(card)
def set_cards(self, cards: List[Card]):
self._cards = cards
def get_cards(self):
return self._cards
- def __str__(self) -> str:
- return f'Player cards: {self._cards}'
+ # def __str__(self) -> str:
+ # return f'Player cards: {self._cards}'
- def __repr__(self) -> str:
- return f'Player cards: {self._cards}'
+ # def __repr__(self) -> str:
+ # return f'Player cards: {self._cards}'
class Game:
def __init__(self, number_of_players: int, dealing_direction: str, dealing_instructions: tuple[int]) -> None:
self._set_players(number_of_players)
self._set_dealing_direction(dealing_direction)
self._set_dealing_instructions(dealing_instructions)
- self._set_empty_deck()
+ self._set_full_deck()
def _set_players(self, number_of_players):
self._number_of_players = number_of_players
self._players = []
for _ in range(number_of_players):
self._players.append(Player())
def _set_dealing_direction(self, dealing_direction):
if dealing_direction in DEALING_DIRECTIONS.values():
self.dealing_direction = dealing_direction
else:
raise ValueError("Unfitting dealing direction given.")
def _set_dealing_instructions(self, dealing_instructions):
self._dealing_instructions = dealing_instructions
- def _set_empty_deck(self):
- self._deck = Deck()
+ def _set_full_deck(self):
+ self._deck = Deck(CARD_FACES)
def set_face_filtered_deck(self, face_filter):
self._deck = Deck(face_filter)
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
while player.get_cards():
self._deck.add_card(player.get_cards().pop(0))
self._deck.shuffle()
self._deck.cut()
def deal(self, player: Player):
def get_players_to_serve_ordered():
idx = self._players.index(player)
pre = self._players[:idx]
post = self._players[idx:]
players_to_serve_order = []
if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
players_to_serve_order = post + pre
elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
else:
raise ValueError("Unfitting dealing direction processed.")
return players_to_serve_order
players_to_serve_ordered = get_players_to_serve_ordered()
players_cards = {player: [] for player in players_to_serve_ordered}
for iteration in self._dealing_instructions:
for cur_player_idx in range(len(players_to_serve_ordered)):
player = players_to_serve_ordered[cur_player_idx]
for _ in range(iteration):
players_cards[player].append(self._deck.get_cards().pop(0))
for player, cards in players_cards.items():
self._players[self._players.index(player)].set_cards(cards)
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self) -> None:
super().__init__(4, 'ltr', (2, 3, 3))
self.set_face_filtered_deck(BELOT_FACES)
class Poker(Game):
def __init__(self) -> None:
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.set_face_filtered_deck(POKER_FACES)
# ----------------------------------- DEBUG ZONE -------------------------------------
'''
def printer(game, cnt: int, *args):
print()
print(cnt, '//')
print('deck:', game.get_deck())
print('dupl:', [dupl for dupl in game.get_deck().get_cards()
if game.get_deck().get_cards().count(dupl) > 1])
print('size of deck:', len(game.get_deck()))
print(*args)
belot = Belot()
players = belot.get_players()
printer(belot, 0)
belot.prepare_deck()
printer(belot, 1)
belot.deal(players[0])
printer(belot, 2, 'belot.players:', belot.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
belot.prepare_deck()
printer(belot, 3, 'belot.players:', belot.get_players())
belot.deal(players[1])
printer(belot, 4, 'belot.players:', belot.get_players())
belot.prepare_deck()
printer(belot, 5, 'belot.players:', belot.get_players())
belot.deal(players[3])
printer(belot, 6, 'belot.players:', belot.get_players())
del belot
-# poker = Poker()
-# players = poker.get_players()
-# printer(poker, 0)
-# poker.prepare_deck()
-# printer(poker, 1)
-# poker.deal(players[0])
-# printer(poker, 2, 'poker.players:', poker.get_players())
-# # Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
-# poker.prepare_deck()
-# printer(poker, 3, 'poker.players:', poker.get_players())
-# poker.deal(players[1])
-# printer(poker, 4, 'poker.players:', poker.get_players())
-# del poker
+poker = Poker()
+players = poker.get_players()
+printer(poker, 0)
+poker.prepare_deck()
+printer(poker, 1)
+poker.deal(players[0])
+printer(poker, 2, 'poker.players:', poker.get_players())
+# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
+poker.prepare_deck()
+printer(poker, 3, 'poker.players:', poker.get_players())
+poker.deal(players[1])
+printer(poker, 4, 'poker.players:', poker.get_players())
+del poker
'''

Александър обнови решението на 14.11.2022 21:19 (преди над 1 година)

from random import shuffle as rand_shuffle
from typing import List
CUT_CARD_COUNTER = 3
CARD_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
BELOT_FACES = ['7', '8', '9', '10', 'J', 'Q', 'K', 'A']
POKER_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
CARD_SUITES = ['clubs', 'diamonds', 'hearts', 'spades']
DEALING_DIRECTIONS = {
"LEFT_TO_RIGHT": "ltr",
"RIGHT_TO_LEFT": "rtl",
}
class Card:
def __init__(self, suit: str, face: str) -> None:
self._set_suit(suit)
self._set_face(face)
def _set_suit(self, suit):
if suit in CARD_SUITES:
self._suit = suit
else:
raise ValueError("Unfitting card suit given.")
def _set_face(self, face):
if face in CARD_FACES:
self.face = face
else:
raise ValueError("Unfitting card face given.")
# def __str__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
# def __repr__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
def get_suit(self) -> str:
return self._suit
def get_face(self) -> str:
return self.face
class Deck:
def __init__(self, face_filter: list[str] = []) -> None:
self._cards = []
self._set_cards(face_filter)

Моля подсигури се, че дори да инстанцирам класа без филтър, инстанцията пак ще има карти - стандартно тесте от 52 карти.
Тестовете ни очакват Deck да може да работи самостоятелно, дори да не го наследяваш.

def _set_cards(self, face_filter):
self._cards.clear()
for card_face in face_filter:
if card_face in CARD_FACES:
for card_suit in CARD_SUITES:
self._cards.append(Card(card_suit, card_face))
else:
raise ValueError("Unfitting card face processed.")
def __len__(self) -> int:
return len(self._cards)
# def __str__(self) -> str:
# return f'Deck cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Deck cards: {self._cards}'
def add_card(self, card: Card):
self._cards.append(card)
def cut(self):
cut_counter = min(CUT_CARD_COUNTER, len(self._cards) - 1)
while cut_counter > 0:
self._cards.append(self._cards.pop(0))
cut_counter -= 1
def shuffle(self):
rand_shuffle(self._cards)
def get_cards(self):
return self._cards
class Player:
def __init__(self) -> None:
self._cards = []
def remove_card(self, card: Card):
self._cards.remove(card)
def add_card(self, card: Card):
self._cards.append(card)
def set_cards(self, cards: List[Card]):
self._cards = cards
def get_cards(self):
return self._cards
# def __str__(self) -> str:
# return f'Player cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Player cards: {self._cards}'
class Game:
def __init__(self, number_of_players: int, dealing_direction: str, dealing_instructions: tuple[int]) -> None:
self._set_players(number_of_players)
self._set_dealing_direction(dealing_direction)
self._set_dealing_instructions(dealing_instructions)
self._set_full_deck()
def _set_players(self, number_of_players):
self._number_of_players = number_of_players
self._players = []
for _ in range(number_of_players):
self._players.append(Player())
def _set_dealing_direction(self, dealing_direction):
if dealing_direction in DEALING_DIRECTIONS.values():
self.dealing_direction = dealing_direction
else:
raise ValueError("Unfitting dealing direction given.")
def _set_dealing_instructions(self, dealing_instructions):
self._dealing_instructions = dealing_instructions
def _set_full_deck(self):
self._deck = Deck(CARD_FACES)
def set_face_filtered_deck(self, face_filter):
self._deck = Deck(face_filter)
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
while player.get_cards():
self._deck.add_card(player.get_cards().pop(0))
self._deck.shuffle()
self._deck.cut()
def deal(self, player: Player):
def get_players_to_serve_ordered():

Това по-добре го направи метод на класа. Хем е по-четимо, хем не се дефинира при всяка раздаване, хем можеш да го използваш и извън тази функция.

idx = self._players.index(player)
pre = self._players[:idx]
post = self._players[idx:]
players_to_serve_order = []
if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
players_to_serve_order = post + pre
elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
else:
raise ValueError("Unfitting dealing direction processed.")
return players_to_serve_order
players_to_serve_ordered = get_players_to_serve_ordered()
players_cards = {player: [] for player in players_to_serve_ordered}
for iteration in self._dealing_instructions:
for cur_player_idx in range(len(players_to_serve_ordered)):
player = players_to_serve_ordered[cur_player_idx]
for _ in range(iteration):
players_cards[player].append(self._deck.get_cards().pop(0))
for player, cards in players_cards.items():
self._players[self._players.index(player)].set_cards(cards)
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self) -> None:
super().__init__(4, 'ltr', (2, 3, 3))
self.set_face_filtered_deck(BELOT_FACES)
class Poker(Game):
def __init__(self) -> None:
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.set_face_filtered_deck(POKER_FACES)
# ----------------------------------- DEBUG ZONE -------------------------------------
'''
def printer(game, cnt: int, *args):
print()
print(cnt, '//')
print('deck:', game.get_deck())
print('dupl:', [dupl for dupl in game.get_deck().get_cards()
if game.get_deck().get_cards().count(dupl) > 1])
print('size of deck:', len(game.get_deck()))
print(*args)
+game = Game(2, 'ltr', (2,))
+players = game.get_players()
+game.prepare_deck()
+game.deal(players[0])
+# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
+game.prepare_deck()
+game.deal(players[1])
+
belot = Belot()
players = belot.get_players()
printer(belot, 0)
belot.prepare_deck()
printer(belot, 1)
belot.deal(players[0])
printer(belot, 2, 'belot.players:', belot.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
belot.prepare_deck()
printer(belot, 3, 'belot.players:', belot.get_players())
belot.deal(players[1])
printer(belot, 4, 'belot.players:', belot.get_players())
belot.prepare_deck()
printer(belot, 5, 'belot.players:', belot.get_players())
belot.deal(players[3])
printer(belot, 6, 'belot.players:', belot.get_players())
del belot
poker = Poker()
players = poker.get_players()
printer(poker, 0)
poker.prepare_deck()
printer(poker, 1)
poker.deal(players[0])
printer(poker, 2, 'poker.players:', poker.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
poker.prepare_deck()
printer(poker, 3, 'poker.players:', poker.get_players())
poker.deal(players[1])
printer(poker, 4, 'poker.players:', poker.get_players())
del poker
'''

Александър обнови решението на 15.11.2022 16:41 (преди над 1 година)

from random import shuffle as rand_shuffle
from typing import List
CUT_CARD_COUNTER = 3
CARD_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
BELOT_FACES = ['7', '8', '9', '10', 'J', 'Q', 'K', 'A']
POKER_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
CARD_SUITES = ['clubs', 'diamonds', 'hearts', 'spades']
DEALING_DIRECTIONS = {
"LEFT_TO_RIGHT": "ltr",
"RIGHT_TO_LEFT": "rtl",
}
class Card:
def __init__(self, suit: str, face: str) -> None:
self._set_suit(suit)
self._set_face(face)
def _set_suit(self, suit):
if suit in CARD_SUITES:
self._suit = suit
else:
raise ValueError("Unfitting card suit given.")
def _set_face(self, face):
if face in CARD_FACES:
self.face = face
else:
raise ValueError("Unfitting card face given.")
# def __str__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
# def __repr__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
def get_suit(self) -> str:
return self._suit
def get_face(self) -> str:
return self.face
class Deck:
def __init__(self, face_filter: list[str] = []) -> None:
self._cards = []
- self._set_cards(face_filter)
+ if face_filter != []:
+ self._set_cards(face_filter)
+ else:
+ self._set_cards(CARD_FACES)
def _set_cards(self, face_filter):
self._cards.clear()
for card_face in face_filter:
if card_face in CARD_FACES:
for card_suit in CARD_SUITES:
self._cards.append(Card(card_suit, card_face))
else:
raise ValueError("Unfitting card face processed.")
def __len__(self) -> int:
return len(self._cards)
# def __str__(self) -> str:
# return f'Deck cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Deck cards: {self._cards}'
def add_card(self, card: Card):
self._cards.append(card)
def cut(self):
cut_counter = min(CUT_CARD_COUNTER, len(self._cards) - 1)
while cut_counter > 0:
self._cards.append(self._cards.pop(0))
cut_counter -= 1
def shuffle(self):
rand_shuffle(self._cards)
def get_cards(self):
return self._cards
class Player:
def __init__(self) -> None:
self._cards = []
def remove_card(self, card: Card):
self._cards.remove(card)
def add_card(self, card: Card):
self._cards.append(card)
def set_cards(self, cards: List[Card]):
self._cards = cards
def get_cards(self):
return self._cards
# def __str__(self) -> str:
# return f'Player cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Player cards: {self._cards}'
class Game:
def __init__(self, number_of_players: int, dealing_direction: str, dealing_instructions: tuple[int]) -> None:
self._set_players(number_of_players)
self._set_dealing_direction(dealing_direction)
self._set_dealing_instructions(dealing_instructions)
self._set_full_deck()
def _set_players(self, number_of_players):
self._number_of_players = number_of_players
self._players = []
for _ in range(number_of_players):
self._players.append(Player())
def _set_dealing_direction(self, dealing_direction):
if dealing_direction in DEALING_DIRECTIONS.values():
self.dealing_direction = dealing_direction
else:
raise ValueError("Unfitting dealing direction given.")
def _set_dealing_instructions(self, dealing_instructions):
self._dealing_instructions = dealing_instructions
def _set_full_deck(self):
self._deck = Deck(CARD_FACES)
def set_face_filtered_deck(self, face_filter):
self._deck = Deck(face_filter)
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
while player.get_cards():
self._deck.add_card(player.get_cards().pop(0))
self._deck.shuffle()
self._deck.cut()
+ def get_players_to_serve_ordered(self, player: Player):
+ idx = self._players.index(player)
+ pre = self._players[:idx]
+ post = self._players[idx:]
+ players_to_serve_order = []
+ if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
+ players_to_serve_order = post + pre
+ elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
+ players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
+ else:
+ raise ValueError("Unfitting dealing direction processed.")
+ return players_to_serve_order
+
def deal(self, player: Player):
- def get_players_to_serve_ordered():
- idx = self._players.index(player)
- pre = self._players[:idx]
- post = self._players[idx:]
- players_to_serve_order = []
- if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
- players_to_serve_order = post + pre
- elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
- players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
- else:
- raise ValueError("Unfitting dealing direction processed.")
- return players_to_serve_order
-
- players_to_serve_ordered = get_players_to_serve_ordered()
+ players_to_serve_ordered = self.get_players_to_serve_ordered(player)
players_cards = {player: [] for player in players_to_serve_ordered}
for iteration in self._dealing_instructions:
- for cur_player_idx in range(len(players_to_serve_ordered)):
- player = players_to_serve_ordered[cur_player_idx]
+ for player in players_to_serve_ordered:
for _ in range(iteration):
players_cards[player].append(self._deck.get_cards().pop(0))
for player, cards in players_cards.items():
self._players[self._players.index(player)].set_cards(cards)
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self) -> None:
super().__init__(4, 'ltr', (2, 3, 3))
self.set_face_filtered_deck(BELOT_FACES)
class Poker(Game):
def __init__(self) -> None:
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.set_face_filtered_deck(POKER_FACES)
# ----------------------------------- DEBUG ZONE -------------------------------------
'''
def printer(game, cnt: int, *args):
print()
print(cnt, '//')
print('deck:', game.get_deck())
print('dupl:', [dupl for dupl in game.get_deck().get_cards()
if game.get_deck().get_cards().count(dupl) > 1])
print('size of deck:', len(game.get_deck()))
print(*args)
game = Game(2, 'ltr', (2,))
players = game.get_players()
game.prepare_deck()
game.deal(players[0])
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
game.prepare_deck()
game.deal(players[1])
belot = Belot()
players = belot.get_players()
printer(belot, 0)
belot.prepare_deck()
printer(belot, 1)
belot.deal(players[0])
printer(belot, 2, 'belot.players:', belot.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
belot.prepare_deck()
printer(belot, 3, 'belot.players:', belot.get_players())
belot.deal(players[1])
printer(belot, 4, 'belot.players:', belot.get_players())
belot.prepare_deck()
printer(belot, 5, 'belot.players:', belot.get_players())
belot.deal(players[3])
printer(belot, 6, 'belot.players:', belot.get_players())
del belot
poker = Poker()
players = poker.get_players()
printer(poker, 0)
poker.prepare_deck()
printer(poker, 1)
poker.deal(players[0])
printer(poker, 2, 'poker.players:', poker.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
poker.prepare_deck()
printer(poker, 3, 'poker.players:', poker.get_players())
poker.deal(players[1])
printer(poker, 4, 'poker.players:', poker.get_players())
del poker
'''

Александър обнови решението на 15.11.2022 16:50 (преди над 1 година)

from random import shuffle as rand_shuffle

Не би имало конфликт. from random import shuffle представя shuffle като глобално име, а shuffle в Deck е метод на класа и в глобалния скоуп е Deck.shuffle, така че би било наред.

from typing import List
CUT_CARD_COUNTER = 3
CARD_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
BELOT_FACES = ['7', '8', '9', '10', 'J', 'Q', 'K', 'A']
POKER_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
CARD_SUITES = ['clubs', 'diamonds', 'hearts', 'spades']
DEALING_DIRECTIONS = {
"LEFT_TO_RIGHT": "ltr",
"RIGHT_TO_LEFT": "rtl",
}
class Card:
def __init__(self, suit: str, face: str) -> None:
self._set_suit(suit)
self._set_face(face)
def _set_suit(self, suit):
if suit in CARD_SUITES:
self._suit = suit
else:
raise ValueError("Unfitting card suit given.")
def _set_face(self, face):
if face in CARD_FACES:
self.face = face
else:
raise ValueError("Unfitting card face given.")
# def __str__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
# def __repr__(self) -> str:
# return f'{self.face} of {self._suit.capitalize()}'
def get_suit(self) -> str:
return self._suit
def get_face(self) -> str:
return self.face
class Deck:
def __init__(self, face_filter: list[str] = []) -> None:
self._cards = []
if face_filter != []:
self._set_cards(face_filter)
else:
self._set_cards(CARD_FACES)
def _set_cards(self, face_filter):
self._cards.clear()
for card_face in face_filter:
if card_face in CARD_FACES:
for card_suit in CARD_SUITES:
self._cards.append(Card(card_suit, card_face))
else:
raise ValueError("Unfitting card face processed.")
def __len__(self) -> int:
return len(self._cards)
# def __str__(self) -> str:
# return f'Deck cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Deck cards: {self._cards}'
def add_card(self, card: Card):
self._cards.append(card)
def cut(self):
cut_counter = min(CUT_CARD_COUNTER, len(self._cards) - 1)
while cut_counter > 0:
self._cards.append(self._cards.pop(0))
cut_counter -= 1
def shuffle(self):
rand_shuffle(self._cards)
def get_cards(self):
return self._cards
class Player:
def __init__(self) -> None:
self._cards = []
def remove_card(self, card: Card):
self._cards.remove(card)
def add_card(self, card: Card):
self._cards.append(card)
def set_cards(self, cards: List[Card]):
self._cards = cards
def get_cards(self):
return self._cards
# def __str__(self) -> str:
# return f'Player cards: {self._cards}'
# def __repr__(self) -> str:
# return f'Player cards: {self._cards}'
class Game:
def __init__(self, number_of_players: int, dealing_direction: str, dealing_instructions: tuple[int]) -> None:
self._set_players(number_of_players)
self._set_dealing_direction(dealing_direction)
self._set_dealing_instructions(dealing_instructions)
self._set_full_deck()
def _set_players(self, number_of_players):
self._number_of_players = number_of_players
self._players = []
for _ in range(number_of_players):
self._players.append(Player())
def _set_dealing_direction(self, dealing_direction):
if dealing_direction in DEALING_DIRECTIONS.values():
self.dealing_direction = dealing_direction
else:
raise ValueError("Unfitting dealing direction given.")
def _set_dealing_instructions(self, dealing_instructions):
self._dealing_instructions = dealing_instructions
def _set_full_deck(self):
self._deck = Deck(CARD_FACES)
def set_face_filtered_deck(self, face_filter):
self._deck = Deck(face_filter)
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
while player.get_cards():
self._deck.add_card(player.get_cards().pop(0))
self._deck.shuffle()
self._deck.cut()
def get_players_to_serve_ordered(self, player: Player):
idx = self._players.index(player)
pre = self._players[:idx]
post = self._players[idx:]
players_to_serve_order = []
if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
players_to_serve_order = post + pre
elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
else:
raise ValueError("Unfitting dealing direction processed.")
return players_to_serve_order
def deal(self, player: Player):
players_to_serve_ordered = self.get_players_to_serve_ordered(player)
players_cards = {player: [] for player in players_to_serve_ordered}
for iteration in self._dealing_instructions:
- for player in players_to_serve_ordered:
+ for _player in players_to_serve_ordered:
for _ in range(iteration):
- players_cards[player].append(self._deck.get_cards().pop(0))
+ players_cards[_player].append(self._deck.get_cards().pop(0))
for player, cards in players_cards.items():
self._players[self._players.index(player)].set_cards(cards)
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self) -> None:
super().__init__(4, 'ltr', (2, 3, 3))
self.set_face_filtered_deck(BELOT_FACES)
class Poker(Game):
def __init__(self) -> None:
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.set_face_filtered_deck(POKER_FACES)
# ----------------------------------- DEBUG ZONE -------------------------------------
'''
def printer(game, cnt: int, *args):
print()
print(cnt, '//')
print('deck:', game.get_deck())
print('dupl:', [dupl for dupl in game.get_deck().get_cards()
if game.get_deck().get_cards().count(dupl) > 1])
print('size of deck:', len(game.get_deck()))
print(*args)
+
+deck = Deck()
+print(-10, deck.get_cards())
+print(-10, len(deck.get_cards()))
game = Game(2, 'ltr', (2,))
players = game.get_players()
game.prepare_deck()
game.deal(players[0])
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
game.prepare_deck()
game.deal(players[1])
belot = Belot()
players = belot.get_players()
printer(belot, 0)
belot.prepare_deck()
printer(belot, 1)
belot.deal(players[0])
printer(belot, 2, 'belot.players:', belot.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
belot.prepare_deck()
printer(belot, 3, 'belot.players:', belot.get_players())
belot.deal(players[1])
printer(belot, 4, 'belot.players:', belot.get_players())
belot.prepare_deck()
printer(belot, 5, 'belot.players:', belot.get_players())
belot.deal(players[3])
printer(belot, 6, 'belot.players:', belot.get_players())
del belot
poker = Poker()
players = poker.get_players()
printer(poker, 0)
poker.prepare_deck()
printer(poker, 1)
poker.deal(players[0])
printer(poker, 2, 'poker.players:', poker.get_players())
# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
poker.prepare_deck()
printer(poker, 3, 'poker.players:', poker.get_players())
poker.deal(players[1])
printer(poker, 4, 'poker.players:', poker.get_players())
del poker
'''