Private & Protected в ООП

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

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

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

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

Към профила на Марио Николов

Резултати

  • 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=['K', 'Q', 'J', '10', '9', '8', '7', '6', '5', '4', '3', '2', 'A']):
self._cards = []
for face in face_filter:
self._cards.extend(map(lambda x: Card(x, face), ['clubs', 'diamonds', 'hearts', 'spades']))
def cut(self):
random_number_of_cards = random.randint(1, len(self._cards))
self._cards = self._cards[random_number_of_cards:] + self._cards[:random_number_of_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._players = []
for _ in range(number_of_players):
self._players.append(Player())
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._deck = Deck()
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
self._deck.get_cards().extend(player.get_cards())
player.get_cards().clear()
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
player_index = self._players.index(player)
if self._dealing_direction == 'ltr':
order_of_players = self._players[player_index:] + self._players[:player_index]
elif self._dealing_direction == 'rtl':
order_of_players = list(reversed(self._players[:player_index + 1])) + list(reversed(self._players[player_index + 1:]))
for instruction in self._dealing_instructions:
for player in order_of_players:
for _ in range(instruction):
player.get_cards().append(self._deck.get_cards().pop(0))
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super(Belot, self).__init__(4, 'ltr', (2, 3, 3))
self._deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super(Poker, self).__init__(9, 'rtl', (1, 1, 1, 1, 1))

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

...............
----------------------------------------------------------------------
Ran 15 tests in 0.150s

OK

История (2 версии и 7 коментара)

Марио обнови решението на 15.11.2022 04:22 (преди над 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=['K', 'Q', 'J', '10', '9', '8', '7', '6', '5', '4', '3', '2', 'A']):
+ self._cards = []
+
+ for face in face_filter:
+ self._cards.extend(map(lambda x: Card(x, face), [
+ 'clubs', 'diamonds', 'hearts', 'spades']))
+
+ def cut(self):
+ random_number_of_cards = random.randint(1, len(self._cards))
+ selected_cards = []
+
+ while random_number_of_cards > 0:
+ selected_cards.append(self._cards.pop(0))
+ random_number_of_cards -= 1
+
+ self._cards.extend(selected_cards)
+
+ def shuffle(self):
+ random.shuffle(self._cards)
+
+ def get_cards(self):
+ return self._cards
+
+
+class Player:
+ def __init__(self):
+ self._cards_held = []
+
+ def get_cards(self):
+ return self._cards_held
+
+
+class Game:
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self._players = []
+ for i in range(0, number_of_players):
+ self._players.append(Player())
+ self._dealing_direction = dealing_direction
+ self._dealing_instructions = dealing_instructions
+ self._deck = Deck()
+
+ def get_players(self):
+ return self._players
+
+ def prepare_deck(self):
+ for player in self._players:
+ self._deck.get_cards().extend(player.get_cards())
+ player.get_cards().clear()
+
+ self._deck.shuffle()
+ self._deck.cut()
+
+ def deal(self, player):
+ player_index = self._players.index(player)
+ if self._dealing_direction == 'ltr':
+ order_of_players = self._players[player_index:] + \

Силно непрепоръчително е да цепиш редове с наклонена чера. Ако причината за това е да се хванеш в 79 символа, по-добре го остави да са повече, но без това пренасяне.

Георги
+ self._players[:player_index]
+ elif self._dealing_direction == 'rtl':
+ order_of_players = list(reversed(self._players[:player_index + 1])) + \
+ list(reversed(self._players[player_index + 1:]))
+
+ for instruction in self._dealing_instructions:
+ for player in order_of_players:
+ for i in range(0, instruction):
+ player.get_cards().append(self._deck.get_cards().pop(0))
+
+ def get_deck(self):
+ return self._deck
+
+
+class Belot(Game):
+ def __init__(self):
+ super(Belot, self).__init__(4, 'ltr', (2, 3, 3))
+ self._deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+
+
+class Poker(Game):
+ def __init__(self):
+ super(Poker, self).__init__(9, 'rtl', (1))
+
+ def deal(self, player):
+ player_index = self._players.index(player)
+ if self._dealing_direction == 'ltr':
+ order_of_players = self._players[player_index:] + \
+ self._players[:player_index]
+ elif self._dealing_direction == 'rtl':
+ order_of_players = list(reversed(self._players[:player_index + 1])) + \
+ list(reversed(self._players[player_index + 1:]))
+
+ count = 0

Това го правиш само защото не си подал правилните инструкции за раздаване - (1). Ако подадеш правилни инструкции, това парче код става излишно.

Георги
+ while count < 5:
+ for player in order_of_players:
+ player.get_cards().extend(self._deck.get_cards().pop(0))
+ count += 1

Марио обнови решението на 15.11.2022 17:03 (преди над 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=['K', 'Q', 'J', '10', '9', '8', '7', '6', '5', '4', '3', '2', 'A']):
self._cards = []
for face in face_filter:
- self._cards.extend(map(lambda x: Card(x, face), [
- 'clubs', 'diamonds', 'hearts', 'spades']))
+ self._cards.extend(map(lambda x: Card(x, face), ['clubs', 'diamonds', 'hearts', 'spades']))
def cut(self):
random_number_of_cards = random.randint(1, len(self._cards))
- selected_cards = []
+ self._cards = self._cards[random_number_of_cards:] + self._cards[:random_number_of_cards]
- while random_number_of_cards > 0:
- selected_cards.append(self._cards.pop(0))
- random_number_of_cards -= 1
-
- self._cards.extend(selected_cards)
-
def shuffle(self):
random.shuffle(self._cards)
def get_cards(self):
return self._cards
class Player:
def __init__(self):
- self._cards_held = []
+ self._cards = []
def get_cards(self):
- return self._cards_held
+ return self._cards
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._players = []
- for i in range(0, number_of_players):
+ for _ in range(number_of_players):
self._players.append(Player())
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._deck = Deck()
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
self._deck.get_cards().extend(player.get_cards())
player.get_cards().clear()
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
player_index = self._players.index(player)
if self._dealing_direction == 'ltr':
- order_of_players = self._players[player_index:] + \
- self._players[:player_index]
+ order_of_players = self._players[player_index:] + self._players[:player_index]
elif self._dealing_direction == 'rtl':
- order_of_players = list(reversed(self._players[:player_index + 1])) + \
- list(reversed(self._players[player_index + 1:]))
+ order_of_players = list(reversed(self._players[:player_index + 1])) + list(reversed(self._players[player_index + 1:]))
for instruction in self._dealing_instructions:
for player in order_of_players:
- for i in range(0, instruction):
+ for _ in range(instruction):
player.get_cards().append(self._deck.get_cards().pop(0))
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super(Belot, self).__init__(4, 'ltr', (2, 3, 3))
self._deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
- super(Poker, self).__init__(9, 'rtl', (1))
-
+ super(Poker, self).__init__(9, 'rtl', (1, 1, 1, 1, 1))
- def deal(self, player):
- player_index = self._players.index(player)
- if self._dealing_direction == 'ltr':
- order_of_players = self._players[player_index:] + \
- self._players[:player_index]
- elif self._dealing_direction == 'rtl':
- order_of_players = list(reversed(self._players[:player_index + 1])) + \
- list(reversed(self._players[player_index + 1:]))
-
- count = 0
- while count < 5:
- for player in order_of_players:
- player.get_cards().extend(self._deck.get_cards().pop(0))
- count += 1