Решение на От ливадите до Лас Вегас (и назад) от Йоан Христов

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

Към профила на Йоан Христов

Резултати

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

Код

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=[]):
self._face_filter = face_filter
self.deck_cards = []
self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']
self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]
if len(self._face_filter) != 0:
self.__faces = self._face_filter
for suit in self.__suits:
for face in self.__faces:
self.deck_cards.append(Card(suit, face))
def cut(self):
cut_pivot = random.randint(1, len(self.deck_cards) - 1)
self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]
def shuffle(self):
random.shuffle(self.deck_cards)
def get_cards(self):
return self.deck_cards
class Player:
def __init__(self):
self.player_cards = []
def get_cards(self):
return self.player_cards
class Game(Deck):
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction.lower()
self.dealing_instructions = dealing_instructions
self.deck = Deck()
self.players = []
for _player in range(number_of_players):
self.players.append(Player())
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
while len(player.player_cards) != 0:
self.deck.deck_cards.append(player.player_cards.pop())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
pivot = self.players.index(player)
self.players = self.players[pivot:] + self.players[:pivot]
if self.dealing_direction == "rtl":
first_elem = self.players.pop(0)
self.players.reverse()
self.players.insert(0, first_elem)
for number_of_cards in self.dealing_instructions:
for player in self.players:
for elem in range(number_of_cards):
player.player_cards.append(self.deck.deck_cards.pop(0))
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, "ltr", (2, 3, 3))
self.deck = Deck(["7", "8", "9", "10", "J", "Q", "K", "A"])
class Poker(Game):
def __init__(self):
super().__init__(9, "rtl", (1, 1, 1, 1, 1))

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

...............
----------------------------------------------------------------------
Ran 15 tests in 0.164s

OK

История (4 версии и 8 коментара)

Йоан обнови решението на 13.11.2022 05:40 (преди над 1 година)

+import random
+
+class Card:
+ def __init__(self, suit, face):
+ self.suit = suit
+ self.face = face
+
+ def get_suit(self):
+ return self.suit
+
+ def get_face(self):
+ return self.face
+
+
+class Deck:
+ def __init__(self, face_filter=[]):
+ self.__face_filter = face_filter

Обикновено __ се използва, ако наистина искаш да кажеш на някого, че не трябва да го пипа, както и в случаите, в които искаш да предотвратиш конфликт на имена при наследяване. Тук е напълно достатъчно да използваш енда _.

+ self.deck_cards = []
+ self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']
+ self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]
+
+ if len(self.__face_filter) == 0:
+ for suit in self.__suits:
+ for face in self.__faces:
+ self.deck_cards.append(Card(suit, face))
+ else:
+ for suit in self.__suits:
+ for face in self.__face_filter:
+ self.deck_cards.append(Card(suit, face))
+
+ def cut(self):
+ cut_pivot = random.randint(1, 51)
+ self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]
+
+ def shuffle(self):
+ random.shuffle(self.deck_cards)
+
+ def get_cards(self):
+ return self.deck_cards
+
+
+class Player:
+ def __init__(self):
+ self.player_cards = []
+
+ def get_cards(self):
+ return self.player_cards
+
+
+class Game(Deck):
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self.number_of_players = number_of_players
+ self.dealing_direction = dealing_direction.lower()
+ self.dealing_instructions = dealing_instructions
+ self.deck = Deck()
+ self.players = []
+ for player in range(number_of_players):
+ self.players.append(Player())
+
+ def get_players(self):
+ return self.players # proizvolen?
+
+ def prepare_deck(self):
+ for player in self.players:
+ while len(player.player_cards) != 0:
+ self.deck.deck_cards.append(player.player_cards.pop())
+
+ self.deck.shuffle()
+ self.deck.cut()
+
+ def deal(self, player):
+ pivot = self.players.index(player)
+ self.players = self.players[pivot:] + self.players[:pivot]
+
+ if self.dealing_direction == "rtl":
+ first_elem = self.players.pop(0)
+ self.players.reverse()
+ self.players.insert(0, first_elem)
+
+ for number_of_cards in self.dealing_instructions:
+ for player in self.players:
+ for elem in range(number_of_cards):
+ player.player_cards.append(self.deck.deck_cards.pop())
+
+ def get_deck(self):
+ return self.deck
+
+
+class Belot(Game):
+ def __init__(self):
+ super().__init__(4, "ltr", (2, 3, 3))
+ self.deck = Deck(["7", "8", "9", "10", "J", "Q", "K", "A"])
+
+
+class Poker(Game):
+ def __init__(self):
+ super().__init__(9, "rtl", (1, 1, 1, 1, 1))

Йоан обнови решението на 13.11.2022 17:11 (преди над 1 година)

import random
class Card:
def __init__(self, suit, face):
- self.suit = suit
- self.face = face
+ self._suit = suit
+ self._face = face
def get_suit(self):
- return self.suit
+ return self._suit
def get_face(self):
- return self.face
+ return self._face
class Deck:
def __init__(self, face_filter=[]):
- self.__face_filter = face_filter
+ self._face_filter = face_filter
self.deck_cards = []
self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']
self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]
- if len(self.__face_filter) == 0:
+ if len(self._face_filter) != 0:
+ self.__faces = self._face_filter
for suit in self.__suits:
for face in self.__faces:
self.deck_cards.append(Card(suit, face))
- else:
- for suit in self.__suits:
- for face in self.__face_filter:
- self.deck_cards.append(Card(suit, face))
def cut(self):
- cut_pivot = random.randint(1, 51)
+ cut_pivot = random.randint(1, len(self.deck_cards) - 1)
self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]
def shuffle(self):
random.shuffle(self.deck_cards)
def get_cards(self):
return self.deck_cards
class Player:
def __init__(self):
self.player_cards = []
def get_cards(self):
return self.player_cards
class Game(Deck):
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction.lower()
self.dealing_instructions = dealing_instructions
self.deck = Deck()
self.players = []
- for player in range(number_of_players):
+ for _player in range(number_of_players):
self.players.append(Player())
def get_players(self):
- return self.players # proizvolen?
+ return self.players
def prepare_deck(self):
for player in self.players:
while len(player.player_cards) != 0:
self.deck.deck_cards.append(player.player_cards.pop())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
pivot = self.players.index(player)
self.players = self.players[pivot:] + self.players[:pivot]
if self.dealing_direction == "rtl":
first_elem = self.players.pop(0)
self.players.reverse()
self.players.insert(0, first_elem)
for number_of_cards in self.dealing_instructions:
for player in self.players:
for elem in range(number_of_cards):
player.player_cards.append(self.deck.deck_cards.pop())
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, "ltr", (2, 3, 3))
self.deck = Deck(["7", "8", "9", "10", "J", "Q", "K", "A"])
class Poker(Game):
def __init__(self):
super().__init__(9, "rtl", (1, 1, 1, 1, 1))

Йоан обнови решението на 14.11.2022 19:50 (преди над 1 година)

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=[]):
self._face_filter = face_filter
self.deck_cards = []
self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']
self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]
if len(self._face_filter) != 0:
self.__faces = self._face_filter
- for suit in self.__suits:
- for face in self.__faces:
- self.deck_cards.append(Card(suit, face))
+
+ for suit in self.__suits:
+ for face in self.__faces:
+ self.deck_cards.append(Card(suit, face))
def cut(self):
cut_pivot = random.randint(1, len(self.deck_cards) - 1)
self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]
def shuffle(self):
random.shuffle(self.deck_cards)
def get_cards(self):
return self.deck_cards
class Player:
def __init__(self):
self.player_cards = []
def get_cards(self):
return self.player_cards
class Game(Deck):
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction.lower()
self.dealing_instructions = dealing_instructions
self.deck = Deck()
self.players = []
for _player in range(number_of_players):
self.players.append(Player())
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
while len(player.player_cards) != 0:
self.deck.deck_cards.append(player.player_cards.pop())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
pivot = self.players.index(player)
self.players = self.players[pivot:] + self.players[:pivot]
if self.dealing_direction == "rtl":
first_elem = self.players.pop(0)
self.players.reverse()
self.players.insert(0, first_elem)
for number_of_cards in self.dealing_instructions:
for player in self.players:
for elem in range(number_of_cards):
player.player_cards.append(self.deck.deck_cards.pop())
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, "ltr", (2, 3, 3))
self.deck = Deck(["7", "8", "9", "10", "J", "Q", "K", "A"])
class Poker(Game):
def __init__(self):
super().__init__(9, "rtl", (1, 1, 1, 1, 1))

Йоан обнови решението на 15.11.2022 12:57 (преди над 1 година)

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=[]):
self._face_filter = face_filter
self.deck_cards = []
self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']
self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]
if len(self._face_filter) != 0:
self.__faces = self._face_filter
-
+
for suit in self.__suits:
for face in self.__faces:
self.deck_cards.append(Card(suit, face))
def cut(self):
cut_pivot = random.randint(1, len(self.deck_cards) - 1)
self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]
def shuffle(self):
random.shuffle(self.deck_cards)
def get_cards(self):
return self.deck_cards
class Player:
def __init__(self):
self.player_cards = []
def get_cards(self):
return self.player_cards
class Game(Deck):
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction.lower()
self.dealing_instructions = dealing_instructions
self.deck = Deck()
self.players = []
for _player in range(number_of_players):
self.players.append(Player())
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
while len(player.player_cards) != 0:
self.deck.deck_cards.append(player.player_cards.pop())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
pivot = self.players.index(player)
self.players = self.players[pivot:] + self.players[:pivot]
if self.dealing_direction == "rtl":
first_elem = self.players.pop(0)
self.players.reverse()
self.players.insert(0, first_elem)
for number_of_cards in self.dealing_instructions:
for player in self.players:
for elem in range(number_of_cards):
- player.player_cards.append(self.deck.deck_cards.pop())
+ player.player_cards.append(self.deck.deck_cards.pop(0))
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, "ltr", (2, 3, 3))
self.deck = Deck(["7", "8", "9", "10", "J", "Q", "K", "A"])
class Poker(Game):
def __init__(self):
super().__init__(9, "rtl", (1, 1, 1, 1, 1))