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

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

Към профила на Веселина Велкова

Резултати

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

Код

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=[]):
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'K', 'Q', 'J', 'A']
deck = [Card(suit, face) for suit in suits for face in faces]
self.filtered_deck = []

Ако предварително определиш списъка с всички карти, които трябва да инициализираш, няма да е нужно да обхождаш картите два пъти (един път да ги създадеш и още един път да ги филтрираш). И така работи, така че просто препоръка.

if face_filter:
for card in deck:
if card.get_face() in face_filter:
self.filtered_deck.append(card)
else:
self.filtered_deck = deck
def cut(self):
number = random.randrange(1, len(self.filtered_deck))
self.filtered_deck = self.filtered_deck[number:] + self.filtered_deck[:number]
return self.filtered_deck
def shuffle(self):
return random.shuffle(self.filtered_deck)
def get_cards(self):
return self.filtered_deck
def __getitem__(self, index):
return self.filtered_deck[index]
def __setitem__(self, index, value):
self.filtered_deck[index] = value
class Player:
def __init__(self):
self.deck = []
def get_cards(self):
return self.deck
def set_cards(self, list_of_cards):
self.deck.extend(list_of_cards)
return self.deck
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.number_of_players = number_of_players
if dealing_direction == 'ltr':
self.direction = 1
elif dealing_direction == 'rtl':
self.direction = -1
self.players = []
for i in range(self.number_of_players):
new_player = Player()
self.players.append(new_player)
self.instructions = dealing_instructions
self.deck_for_the_game = Deck()
def get_players(self):

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

return self.players
def prepare_deck(self):
for player in self.players:
while player.deck:
self.deck_for_the_game.append(player.deck[0])
player.deck.pop(0)
self.deck_for_the_game.shuffle()
self.deck_for_the_game.cut()
def pick_and_pop_cards(self, number):
picked_cards = []
for _ in range(number):
picked_cards.append(self.deck_for_the_game[0])
self.deck_for_the_game.pop(0)
return picked_cards
def deal(self, player):
key = self.players.index(player)
for _ in self.instructions:
number_of_cards = self.instructions[_]
if self.direction == 1:
for next_player in self.players[key::1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
for next_player in self.players[0:key:1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
elif self.direction == -1:
for next_player in self.players[key::-1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
for next_player in self.players[-1:key:-1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
def get_deck(self):
return self.deck_for_the_game
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
self.deck_for_the_game = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

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

.E......EEE...E
======================================================================
ERROR: test_correct_direction_and_players_deal (test.TestBelot)
Test dealing with correct direction and players.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
AttributeError: 'Deck' object has no attribute 'pop'

======================================================================
ERROR: test_collecting_cards_before_dealing (test.TestGame)
Test collecting the cards before a new deal.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
AttributeError: 'Deck' object has no attribute 'pop'

======================================================================
ERROR: test_dealing_ltr (test.TestGame)
Test dealing the cards left to right.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
AttributeError: 'Deck' object has no attribute 'pop'

======================================================================
ERROR: test_dealing_rtl (test.TestGame)
Test dealing the cards right to left.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
IndexError: tuple index out of range

======================================================================
ERROR: test_correct_direction_and_players_deal (test.TestPoker)
Test dealing with correct direction and players.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
AttributeError: 'Deck' object has no attribute 'pop'

----------------------------------------------------------------------
Ran 15 tests in 0.168s

FAILED (errors=5)

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

Веселина обнови решението на 14.11.2022 23:20 (преди над 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=None):
+ if face_filter is None:
+ face_filter = []
+ deck = [Card(suit, face) for suit in ['clubs', 'diamonds', 'hearts', 'spades'] for face in ['2', '3', '4', '5',
+ '6', '7', '8', '9',
+ '10', 'K', 'Q', 'J',
+ 'A']]
+ self.filtered_deck = []
+ if face_filter:
+ for card in deck:
+ if card.get_face() in face_filter:
+ self.filtered_deck.append(card)
+ else:
+ self.filtered_deck = deck
+
+ def cut(self):
+ number = random.randrange(1, len(self.filtered_deck))
+ cut_deck = []
+ for cards in self.filtered_deck:
+ if self.filtered_deck.index(cards) >= number:
+ cut_deck.append(cards)
+ for cards in self.filtered_deck:
+ if self.filtered_deck.index(cards) < number:
+ cut_deck.append(cards)
+ self.filtered_deck = cut_deck
+ return self.filtered_deck
+
+ def shuffle(self):
+ return random.shuffle(self.filtered_deck)
+
+ def get_cards(self):
+ return self.filtered_deck
+
+ def __getitem__(self, index):
+ return self.filtered_deck[index]
+
+ def __setitem__(self, index, value):
+ self.filtered_deck[index] = value
+
+
+class Player:
+ def __init__(self):
+ self.private_deck = []
+
+ def get_cards(self):
+ return self.private_deck
+
+ def set_cards(self, list_of_cards):
+ for card in list_of_cards:
+ self.private_deck.append(card)
+ return self.private_deck
+
+
+class Game:
+
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self.number_of_players = number_of_players
+ if dealing_direction == 'ltr':
+ self.direction = 1
+ elif dealing_direction == 'rtl':
+ self.direction = -1
+ self.instructions = dealing_instructions
+ self.deck_for_the_game = Deck()
+
+ def get_players(self):
+ players = []
+ for i in range(0, self.number_of_players):
+ new_player = Player()
+ players.append(new_player)
+ return players
+
+ def prepare_deck(self):
+ for player in self.get_players():
+ while player.private_deck:
+ self.deck_for_the_game.append(player.private_deck[0])
+ player.private_deck.pop(0)
+ self.deck_for_the_game.shuffle()
+ self.deck_for_the_game.cut()
+
+ def pick_and_pop_cards(self, number):
+ picked_cards = []
+ for _ in range(0, number):
+ picked_cards.append(self.deck_for_the_game[0])
+ self.deck_for_the_game.pop(0)
+ return picked_cards
+
+ def deal(self, player):
+ for _ in self.instructions:
+ number_of_cards = self.instructions[_]
+ if self.direction == 1:
+ for next_player in self.get_players()[player::1]:
+ next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
+ for next_player in self.get_players()[0:player:1]:
+ next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
+ elif self.direction == -1:
+ for next_player in self.get_players()[player::-1]:
+ next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
+ for next_player in self.get_players()[-1:player:-1]:
+ next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
+
+ def get_deck(self):
+ return self.deck_for_the_game
+
+
+class Belot(Game):
+ def __init__(self):
+ super().__init__(4, 'ltr', (2, 3, 3))
+ self.deck_for_the_game = 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 08:18 (преди над 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=None):
if face_filter is None:
face_filter = []
deck = [Card(suit, face) for suit in ['clubs', 'diamonds', 'hearts', 'spades'] for face in ['2', '3', '4', '5',
'6', '7', '8', '9',
'10', 'K', 'Q', 'J',
'A']]
self.filtered_deck = []

Ако предварително определиш списъка с всички карти, които трябва да инициализираш, няма да е нужно да обхождаш картите два пъти (един път да ги създадеш и още един път да ги филтрираш). И така работи, така че просто препоръка.

if face_filter:
for card in deck:
if card.get_face() in face_filter:
self.filtered_deck.append(card)
else:
self.filtered_deck = deck
def cut(self):
number = random.randrange(1, len(self.filtered_deck))
cut_deck = []
for cards in self.filtered_deck:
if self.filtered_deck.index(cards) >= number:
cut_deck.append(cards)
for cards in self.filtered_deck:
if self.filtered_deck.index(cards) < number:
cut_deck.append(cards)
self.filtered_deck = cut_deck
return self.filtered_deck
def shuffle(self):
return random.shuffle(self.filtered_deck)
def get_cards(self):
return self.filtered_deck
def __getitem__(self, index):
return self.filtered_deck[index]
def __setitem__(self, index, value):
self.filtered_deck[index] = value
class Player:
def __init__(self):
self.private_deck = []
def get_cards(self):
return self.private_deck
def set_cards(self, list_of_cards):
for card in list_of_cards:
self.private_deck.append(card)
return self.private_deck
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.number_of_players = number_of_players
if dealing_direction == 'ltr':
self.direction = 1
elif dealing_direction == 'rtl':
self.direction = -1
self.instructions = dealing_instructions
self.deck_for_the_game = Deck()
def get_players(self):

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

players = []
- for i in range(0, self.number_of_players):
+ for i in range(self.number_of_players):
new_player = Player()
players.append(new_player)
return players
def prepare_deck(self):
for player in self.get_players():
while player.private_deck:
self.deck_for_the_game.append(player.private_deck[0])
player.private_deck.pop(0)
self.deck_for_the_game.shuffle()
self.deck_for_the_game.cut()
def pick_and_pop_cards(self, number):
picked_cards = []
- for _ in range(0, number):
+ for _ in range(number):
picked_cards.append(self.deck_for_the_game[0])
self.deck_for_the_game.pop(0)
return picked_cards
def deal(self, player):
for _ in self.instructions:
number_of_cards = self.instructions[_]
if self.direction == 1:
for next_player in self.get_players()[player::1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
for next_player in self.get_players()[0:player:1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
elif self.direction == -1:
for next_player in self.get_players()[player::-1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
for next_player in self.get_players()[-1:player:-1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
def get_deck(self):
return self.deck_for_the_game
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
self.deck_for_the_game = 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 14:37 (преди над 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=None):
- if face_filter is None:
- face_filter = []
- deck = [Card(suit, face) for suit in ['clubs', 'diamonds', 'hearts', 'spades'] for face in ['2', '3', '4', '5',
- '6', '7', '8', '9',
- '10', 'K', 'Q', 'J',
- 'A']]
+ def __init__(self, face_filter=[]):
+ suits = ['clubs', 'diamonds', 'hearts', 'spades']
+ faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'K', 'Q', 'J', 'A']
+ deck = [Card(suit, face) for suit in suits for face in faces]
self.filtered_deck = []
if face_filter:
for card in deck:
if card.get_face() in face_filter:
self.filtered_deck.append(card)
else:
self.filtered_deck = deck
def cut(self):
number = random.randrange(1, len(self.filtered_deck))
- cut_deck = []
- for cards in self.filtered_deck:
- if self.filtered_deck.index(cards) >= number:
- cut_deck.append(cards)
- for cards in self.filtered_deck:
- if self.filtered_deck.index(cards) < number:
- cut_deck.append(cards)
- self.filtered_deck = cut_deck
+ self.filtered_deck = self.filtered_deck[number:] + self.filtered_deck[:number]
return self.filtered_deck
def shuffle(self):
return random.shuffle(self.filtered_deck)
def get_cards(self):
return self.filtered_deck
def __getitem__(self, index):
return self.filtered_deck[index]
def __setitem__(self, index, value):
self.filtered_deck[index] = value
class Player:
def __init__(self):
- self.private_deck = []
+ self.deck = []
def get_cards(self):
- return self.private_deck
+ return self.deck
def set_cards(self, list_of_cards):
- for card in list_of_cards:
- self.private_deck.append(card)
- return self.private_deck
+ self.deck.extend(list_of_cards)
+ return self.deck
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.number_of_players = number_of_players
if dealing_direction == 'ltr':
self.direction = 1
elif dealing_direction == 'rtl':
self.direction = -1
+ self.players = []
+ for i in range(self.number_of_players):
+ new_player = Player()
+ self.players.append(new_player)
self.instructions = dealing_instructions
self.deck_for_the_game = Deck()
def get_players(self):
- players = []
- for i in range(self.number_of_players):
- new_player = Player()
- players.append(new_player)
- return players
+ return self.players
def prepare_deck(self):
- for player in self.get_players():
- while player.private_deck:
- self.deck_for_the_game.append(player.private_deck[0])
- player.private_deck.pop(0)
+ for player in self.players:
+ while player.deck:
+ self.deck_for_the_game.append(player.deck[0])
+ player.deck.pop(0)
self.deck_for_the_game.shuffle()
self.deck_for_the_game.cut()
def pick_and_pop_cards(self, number):
picked_cards = []
for _ in range(number):
picked_cards.append(self.deck_for_the_game[0])
self.deck_for_the_game.pop(0)
return picked_cards
def deal(self, player):
+ key = self.players.index(player)
for _ in self.instructions:
number_of_cards = self.instructions[_]
if self.direction == 1:
- for next_player in self.get_players()[player::1]:
+ for next_player in self.players[key::1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
- for next_player in self.get_players()[0:player:1]:
+ for next_player in self.players[0:key:1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
elif self.direction == -1:
- for next_player in self.get_players()[player::-1]:
+ for next_player in self.players[key::-1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
- for next_player in self.get_players()[-1:player:-1]:
+ for next_player in self.players[-1:key:-1]:
next_player.set_cards(self.pick_and_pop_cards(number_of_cards))
def get_deck(self):
return self.deck_for_the_game
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
self.deck_for_the_game = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))