Private & Protected в ООП

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

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

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

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

Към профила на Огнян Йончев

Резултати

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

Код

import random
card_suits = ["clubs", "diamonds", "hearts", "spades"]
card_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 get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=card_faces):
self.cards = []
self._face_filter = face_filter
for card_suit in card_suits:
for card_face in self._face_filter:
self.cards.append(Card(card_suit, card_face))
def cut(self):
if self.cards:
random_number = random.randrange(1, len(self.cards))
self.cards = self.cards[random_number:] + \
self.cards[:random_number]
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.cards = []
def get_cards(self):
return self.cards
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions, face_filter=card_faces):
self.deck = Deck(face_filter)
self.players = [Player() for _ in range(number_of_players)]
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction
self.dealing_instructions = dealing_instructions
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.cards.extend(player.get_cards())
player.cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
# Order the players in correct order.
index = self.players.index(player)
ordered_players = self.players[index:] + self.players[:index]
if self.dealing_direction == 'rtl':
# Leave the first player and reverse the rest.
ordered_players[1:] = reversed(ordered_players[1:])
# Give cards to players.
for give_cards in self.dealing_instructions:
for player in ordered_players:
for _ in range(give_cards):
player.get_cards().extend([self.deck.cards[0]])
self.deck.cards.pop(0)
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3),
['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.161s

OK

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

Огнян обнови решението на 12.11.2022 00:37 (преди над 1 година)

+import random
+
+card_suits = ["clubs", "diamonds", "hearts", "spades"]
+card_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 get_suit(self):
+ return self.suit
+
+ def get_face(self):
+ return self.face
+
+
+class Deck:
+ def __init__(self, face_filter=card_faces):
+ self.cards = []
+ self.face_filter = face_filter
+ for card_suit in card_suits:
+ for card_face in face_filter:
+ self.cards.append(Card(card_suit, card_face))
+
+ def cut(self):
+ random_number = random.randrange(len(self.cards))
+ new_cards = self.cards[random_number:]
+ new_cards.extend(self.cards[:random_number])
+ self.cards = new_cards
+
+ def shuffle(self):
+ random.shuffle(self.cards)
+
+ def get_cards(self):
+ return self.cards
+
+
+class Player:
+ def __init__(self):
+ self.cards = []
+
+ def get_cards(self):
+ return self.cards
+
+
+class Game:
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self.deck = Deck()
+ self.players = []
+ self.players.extend([Player() for _ in range(number_of_players)])
+
+ self.number_of_players = number_of_players
+ self.dealing_direction = dealing_direction
+ self.dealing_instructions = dealing_instructions
+
+ def get_players(self):
+ random_player = random.randrange(len(self.players))

Ако просто върнеш self.players пак изпълняваш условието ;) Все пак random_player може да е нула, което е частен, но валиден случай. Условието казва "произволен играч", защото няма как да дефинирам нищо конкретно без да ти казвам как да си пазиш играчите.

Георги
+ new_players = self.players[random_player:]
+ new_players.extend(self.players[:random_player])
+ return new_players
+
+ def prepare_deck(self):
+ for player in self.players:
+ self.deck.cards.extend([card for card in player.get_cards()])

А защо не просто self.deck.cards.extend(player.get_cards())? Ако се опасяваш, че ще получиш референция към елемента и искаш да го копираш, просто добави [:] отзад и готово.

Георги
+ player.cards = []
+ self.deck.shuffle()
+ self.deck.cut()
+
+ def deal(self, player):
+ # Order the players in correct order.
+ index = self.players.index(player)
+ ordered_players = self.players[index:]
+ ordered_players.extend(self.players[:index])
+
+ if self.dealing_direction == 'rtl':
+ ordered_players.reverse()
+
+ # Give cards to players.
+ for give_cards in self.dealing_instructions:
+ for player in ordered_players:
+ for _ in range(give_cards):
+ player.get_cards().extend([self.deck.cards[0]])
+ self.deck.cards.pop(0)
+
+ def get_deck(self):
+ return self.deck
+
+
+class Belot(Game):
+ def __init__(self, number_of_players=4, dealing_direction='ltr', dealing_instructions=(2, 3, 3)):
+ self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+ self.players = []
+ self.players.extend([Player() for _ in range(number_of_players)])
+
+ self.number_of_players = number_of_players
+ self.dealing_direction = dealing_direction
+ self.dealing_instructions = dealing_instructions
+
+
+class Poker(Game):
+ def __init__(self, number_of_players=9, dealing_direction='rtl', dealing_instructions=(1, 1, 1, 1, 1)):
+ self.deck = Deck()
+ self.players = []
+ self.players.extend([Player() for _ in range(number_of_players)])
+
+ self.number_of_players = number_of_players
+ self.dealing_direction = dealing_direction
+ self.dealing_instructions = dealing_instructions
+

Огнян обнови решението на 12.11.2022 18:36 (преди над 1 година)

import random
card_suits = ["clubs", "diamonds", "hearts", "spades"]
card_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
+ 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=card_faces):
self.cards = []
- self.face_filter = face_filter
+ self._face_filter = face_filter
for card_suit in card_suits:
- for card_face in face_filter:
+ for card_face in self._face_filter:
self.cards.append(Card(card_suit, card_face))
def cut(self):
- random_number = random.randrange(len(self.cards))
- new_cards = self.cards[random_number:]
- new_cards.extend(self.cards[:random_number])
- self.cards = new_cards
+ random_number = random.randrange(1, len(self.cards))
+ self.cards = self.cards[random_number:] + self.cards[:random_number]
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.cards = []
def get_cards(self):
return self.cards
class Game:
- def __init__(self, number_of_players, dealing_direction, dealing_instructions):
- self.deck = Deck()
- self.players = []
- self.players.extend([Player() for _ in range(number_of_players)])
-
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions, face_filter=card_faces):
+ self.deck = Deck(face_filter)
+ self.players = [Player() for _ in range(number_of_players)]
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction
self.dealing_instructions = dealing_instructions
def get_players(self):
- random_player = random.randrange(len(self.players))
- new_players = self.players[random_player:]
- new_players.extend(self.players[:random_player])
- return new_players
+ return self.players
def prepare_deck(self):
for player in self.players:
- self.deck.cards.extend([card for card in player.get_cards()])
+ self.deck.cards.extend(player.get_cards())
player.cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
# Order the players in correct order.
index = self.players.index(player)
- ordered_players = self.players[index:]
- ordered_players.extend(self.players[:index])
+ ordered_players = self.players[index:] + self.players[:index]
if self.dealing_direction == 'rtl':
ordered_players.reverse()
# Give cards to players.
for give_cards in self.dealing_instructions:
for player in ordered_players:
for _ in range(give_cards):
player.get_cards().extend([self.deck.cards[0]])
self.deck.cards.pop(0)
def get_deck(self):
return self.deck
class Belot(Game):
- def __init__(self, number_of_players=4, dealing_direction='ltr', dealing_instructions=(2, 3, 3)):
- self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
- self.players = []
- self.players.extend([Player() for _ in range(number_of_players)])
+ def __init__(self):
+ super().__init__(4, 'ltr', (2, 3, 3),
+ ['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
- self.number_of_players = number_of_players
- self.dealing_direction = dealing_direction
- self.dealing_instructions = dealing_instructions
-
class Poker(Game):
- def __init__(self, number_of_players=9, dealing_direction='rtl', dealing_instructions=(1, 1, 1, 1, 1)):
- self.deck = Deck()
- self.players = []
- self.players.extend([Player() for _ in range(number_of_players)])
-
- self.number_of_players = number_of_players
- self.dealing_direction = dealing_direction
- self.dealing_instructions = dealing_instructions
+ def __init__(self):
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

Огнян обнови решението на 12.11.2022 20:34 (преди над 1 година)

import random
card_suits = ["clubs", "diamonds", "hearts", "spades"]
card_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 get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, face_filter=card_faces):
self.cards = []
self._face_filter = face_filter
for card_suit in card_suits:
for card_face in self._face_filter:
self.cards.append(Card(card_suit, card_face))
def cut(self):
- random_number = random.randrange(1, len(self.cards))
- self.cards = self.cards[random_number:] + self.cards[:random_number]
+ if self.cards:
+ random_number = random.randrange(1, len(self.cards))
+ self.cards = self.cards[random_number:] + \
+ self.cards[:random_number]
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.cards = []
def get_cards(self):
return self.cards
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions, face_filter=card_faces):
self.deck = Deck(face_filter)
self.players = [Player() for _ in range(number_of_players)]
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction
self.dealing_instructions = dealing_instructions
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.cards.extend(player.get_cards())
player.cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
# Order the players in correct order.
index = self.players.index(player)
ordered_players = self.players[index:] + self.players[:index]
if self.dealing_direction == 'rtl':
- ordered_players.reverse()
+ # Leave the first player and reverse the rest.
+ ordered_players[1:] = reversed(ordered_players[1:])
# Give cards to players.
for give_cards in self.dealing_instructions:
for player in ordered_players:
for _ in range(give_cards):
player.get_cards().extend([self.deck.cards[0]])
self.deck.cards.pop(0)
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3),
['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))