Private & Protected в ООП

Програмиране с Python

Курс във Факултета по Математика и Информатика към СУ

Решение на От ливадите до Лас Вегас (и назад) от Йоан Бабулков

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

Към профила на Йоан Бабулков

Резултати

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

Код

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7',
'8', '9', '10', 'J', 'Q', 'K', 'A']
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def __repr__(self):
return f'{self._face} of {self._suit}'
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=faces):
self._face_filter = face_filter
self.cards = [Card(suit, face) for suit in suits for face in face_filter]
def cut(self):
random_section = random.randint(1, len(self.cards) - 1)
self.cards = self.cards[random_section:] + self.cards[:random_section]
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.hand_dealt = []
def get_cards(self):
return self.hand_dealt
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._number_of_players = number_of_players
self._dealing_direction = -1 if dealing_direction == "rtl" else 1
self._dealing_instructions = dealing_instructions
self._players = [Player() for _ in range(self._number_of_players)]
self._deck = Deck()
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
players_hand = player.get_cards().copy()
player.get_cards().clear()
self._deck.cards.extend(players_hand)
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
index = self._players.index(player)
for times in self._dealing_instructions:
for i in range(index, index + self._number_of_players * self._dealing_direction, self._dealing_direction):
for _ in range(times):
self._players[i % self._number_of_players].hand_dealt.append(self._deck.get_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(faces[5:])
class Poker(Game):
def __init__(self):
super().__init__(9, "rtl", (1, 1, 1, 1, 1))

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

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

OK

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

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

+import random
+
+suits = ['clubs', 'diamonds', 'hearts', 'spades']
+faces = ['2', '3', '4', '5', '6', '7',
+ '8', '9', '10', 'J', 'Q', 'K', 'A']
+
+
+class Card:
+
+ def __init__(self, suit, face):
+ self._suit = suit
+ self._face = face
+
+ def __repr__(self):
+ return f'{self._face} of {self._suit}'
+
+ def get_suit(self):
+ return self._suit
+
+ def get_face(self):
+ return self._face
+
+
+class Deck:
+
+ def __init__(self, face_filter=faces):
+ self._face_filter = face_filter
+ self.cards = [Card(suit, face) for suit in suits for face in face_filter]
+
+ def cut(self):
+ random_section = random.randint(1, 51)
+ self.cards = self.cards[random_section:] + self.cards[:random_section]
+
+ def shuffle(self):
+ random.shuffle(self.cards)
+
+ def get_cards(self):
+ return self.cards
+
+
+class Player:
+
+ def __init__(self):
+ self.hand_dealt = []
+
+ def get_cards(self):
+ hand = self.hand_dealt.copy()
+ self.hand_dealt.clear()
+ return hand
+
+
+class Game:
+
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self._number_of_players = number_of_players
+ self._dealing_direction = dealing_direction
+ self._dealing_instructions = dealing_instructions
+ self._players = [Player() for _ in range(self._number_of_players)]
+ self._deck = Deck()
+
+ def get_players(self):
+ return self._players
+
+ def prepare_deck(self):
+ for player in self._players:
+ self._deck.cards.extend(player.get_cards())
+
+ self._deck.shuffle()
+ self._deck.cut()
+
+ def deal(self, player):
+ index = self._players.index(player)
+ players_count = len(self._players)
+
+ for times in self._dealing_instructions:
+ for _ in range(times):
+ player.hand_dealt.append(self._deck.cards.pop())
+
+ if self._dealing_direction == "rtl":
+ for i in range(index - 1, index - players_count, -1):
+ for times in self._dealing_instructions:
+ for _ in range(times):
+ self._players[i].hand_dealt.append(self._deck.cards.pop())
+
+ elif self._dealing_direction == "ltr":
+ for i in range(index + 1, index + players_count):
+ for times in self._dealing_instructions:
+ for _ in range(times):
+ self._players[i % players_count].hand_dealt.append(self._deck.cards.pop())
+ return
+
+ def get_deck(self):
+ return self._deck
+
+
+class Belot(Game):
+
+ def __init__(self):
+ super().__init__(4, "ltr", (2, 3, 3))
+ self._deck = Deck(faces[5:])
+
+
+class Poker(Game):
+
+ def __init__(self):
+ super().__init__(9, "rtl", (1, 1, 1, 1, 1))

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

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7',
'8', '9', '10', 'J', 'Q', 'K', 'A']
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def __repr__(self):
return f'{self._face} of {self._suit}'
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=faces):
self._face_filter = face_filter
self.cards = [Card(suit, face) for suit in suits for face in face_filter]
def cut(self):
random_section = random.randint(1, 51)
self.cards = self.cards[random_section:] + self.cards[:random_section]
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.hand_dealt = []
def get_cards(self):
- hand = self.hand_dealt.copy()
- self.hand_dealt.clear()
- return hand
+ return self.hand_dealt
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._number_of_players = number_of_players
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._players = [Player() for _ in range(self._number_of_players)]
self._deck = Deck()
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
- self._deck.cards.extend(player.get_cards())
+ players_hand = player.get_cards().copy()
+ player.get_cards().clear()
+ self._deck.cards.extend(players_hand)
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
index = self._players.index(player)
players_count = len(self._players)
for times in self._dealing_instructions:
for _ in range(times):
player.hand_dealt.append(self._deck.cards.pop())
if self._dealing_direction == "rtl":
for i in range(index - 1, index - players_count, -1):
for times in self._dealing_instructions:
for _ in range(times):
self._players[i].hand_dealt.append(self._deck.cards.pop())
elif self._dealing_direction == "ltr":
for i in range(index + 1, index + players_count):
for times in self._dealing_instructions:
for _ in range(times):
self._players[i % players_count].hand_dealt.append(self._deck.cards.pop())
return
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super().__init__(4, "ltr", (2, 3, 3))
self._deck = Deck(faces[5:])
class Poker(Game):
def __init__(self):
super().__init__(9, "rtl", (1, 1, 1, 1, 1))

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

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7',
'8', '9', '10', 'J', 'Q', 'K', 'A']
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def __repr__(self):
return f'{self._face} of {self._suit}'
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=faces):
self._face_filter = face_filter
self.cards = [Card(suit, face) for suit in suits for face in face_filter]
def cut(self):
random_section = random.randint(1, 51)
self.cards = self.cards[random_section:] + self.cards[:random_section]
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.hand_dealt = []
def get_cards(self):
return self.hand_dealt
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._number_of_players = number_of_players
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._players = [Player() for _ in range(self._number_of_players)]
self._deck = Deck()
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
players_hand = player.get_cards().copy()
player.get_cards().clear()
self._deck.cards.extend(players_hand)
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
index = self._players.index(player)
players_count = len(self._players)
for times in self._dealing_instructions:
for _ in range(times):
player.hand_dealt.append(self._deck.cards.pop())
if self._dealing_direction == "rtl":
for i in range(index - 1, index - players_count, -1):
for times in self._dealing_instructions:
for _ in range(times):
self._players[i].hand_dealt.append(self._deck.cards.pop())
elif self._dealing_direction == "ltr":
for i in range(index + 1, index + players_count):
for times in self._dealing_instructions:
for _ in range(times):
self._players[i % players_count].hand_dealt.append(self._deck.cards.pop())
return
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super().__init__(4, "ltr", (2, 3, 3))
self._deck = Deck(faces[5:])
class Poker(Game):
def __init__(self):
- super().__init__(9, "rtl", (1, 1, 1, 1, 1))
+ super().__init__(9, "rtl", (1, 1, 1, 1, 1))

Имаш известни пропуски по раздаването. Моля прегледай си логиката. Ако не е ясно, виж коментариуте във форума по темата. Ако и тогава не е ясно, питай :)

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

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7',
'8', '9', '10', 'J', 'Q', 'K', 'A']
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def __repr__(self):
return f'{self._face} of {self._suit}'
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=faces):
self._face_filter = face_filter
self.cards = [Card(suit, face) for suit in suits for face in face_filter]
def cut(self):
- random_section = random.randint(1, 51)
+ random_section = random.randint(1, len(self.cards) - 1)
self.cards = self.cards[random_section:] + self.cards[:random_section]
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.hand_dealt = []
def get_cards(self):
return self.hand_dealt
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._number_of_players = number_of_players
- self._dealing_direction = dealing_direction
+ self._dealing_direction = -1 if dealing_direction == "rtl" else 1
self._dealing_instructions = dealing_instructions
self._players = [Player() for _ in range(self._number_of_players)]
self._deck = Deck()
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
players_hand = player.get_cards().copy()
player.get_cards().clear()
self._deck.cards.extend(players_hand)
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
index = self._players.index(player)
- players_count = len(self._players)
for times in self._dealing_instructions:
- for _ in range(times):
- player.hand_dealt.append(self._deck.cards.pop())
+ for i in range(index, index + self._number_of_players * self._dealing_direction, self._dealing_direction):
+ for _ in range(times):
+ self._players[i % self._number_of_players].hand_dealt.append(self._deck.get_cards().pop())
- if self._dealing_direction == "rtl":
- for i in range(index - 1, index - players_count, -1):
- for times in self._dealing_instructions:
- for _ in range(times):
- self._players[i].hand_dealt.append(self._deck.cards.pop())
-
- elif self._dealing_direction == "ltr":
- for i in range(index + 1, index + players_count):
- for times in self._dealing_instructions:
- for _ in range(times):
- self._players[i % players_count].hand_dealt.append(self._deck.cards.pop())
- return
-
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super().__init__(4, "ltr", (2, 3, 3))
self._deck = Deck(faces[5:])
class Poker(Game):
def __init__(self):
- super().__init__(9, "rtl", (1, 1, 1, 1, 1))
+ super().__init__(9, "rtl", (1, 1, 1, 1, 1))