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

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

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

Резултати

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

Код

from itertools import product
from random import randint, shuffle
Suit = ('clubs', 'diamonds', 'hearts', 'spades')
Face = tuple([str(num) for num in range(2, 11)] + ['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=Face):
self.cards = [Card(suit, face) for suit, face in product(Suit, face_filter)]
def cut(self):
random_index = randint(1, len(self.cards) - 1)
self.cards = self.cards[random_index:] + self.cards[:random_index]
def shuffle(self):
shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.hand = []
def get_cards(self):
return self.hand
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions): #self.deck will be overridden
self.number_of_players = number_of_players
self.direction = 1 if dealing_direction == 'rtl' else -1
self.dealing_instructions = dealing_instructions
self.players = [Player() for _ in range(number_of_players)]
self.deck = Deck()
def get_players(self):
random_index = randint(0, len(self.players) - 1)
return self.players[random_index:] + self.players[:random_index]
def prepare_deck(self):
self.deck.cards = [card for player in self.players for card in player.hand]
self.deck.cut()
self.deck.shuffle()
def deal(self, player):
index = self.players.index(player)
for cards_to_give in self.dealing_instructions:
for player in self.players[index::self.direction] + self.players[:index:self.direction]:
player.hand += self.deck.cards[0:cards_to_give]
self.deck.cards = self.deck.cards[cards_to_give:]
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))
self.deck = Deck()

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

.F......EFF...F
======================================================================
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
ValueError: empty range for randrange() (1, 0, -1)

======================================================================
FAIL: 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
AssertionError: {('hearts', '9'), ('clubs', 'A'), ('spades', 'K'), ('spades', 'A'), ('spades', 'Q'), ('clubs', 'K'), ('hearts', '10'), ('hearts', '8')} not found in ({('diamonds', '10'), ('spades', '8'), ('clubs', '10'), ('hearts', 'A'), ('clubs', '9'), ('diamonds', 'J'), ('spades', '7'), ('diamonds', 'Q')}, {('hearts', '9'), ('hearts', 'J'), ('clubs', 'A'), ('spades', 'J'), ('spades', 'Q'), ('diamonds', '7'), ('hearts', '10'), ('clubs', 'K')})

======================================================================
FAIL: 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
AssertionError: {('clubs', '4'), ('clubs', '10'), ('clubs', '7')} not found in ({('clubs', '9'), ('clubs', '3'), ('clubs', '6')}, {('spades', '7'), ('spades', '10'), ('spades', 'K')})

======================================================================
FAIL: 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
AssertionError: {('clubs', 'K'), ('clubs', '9'), ('clubs', '8')} not found in ({('clubs', '4'), ('clubs', '5'), ('clubs', 'J')}, {('spades', 'J'), ('spades', 'Q'), ('spades', '5')})

======================================================================
FAIL: 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
AssertionError: {('hearts', 'J'), ('clubs', '10'), ('spades', '7'), ('diamonds', '6'), ('hearts', '2')} not found in ({('clubs', '3'), ('clubs', 'Q'), ('hearts', 'K'), ('hearts', '4'), ('diamonds', '8')}, {('spades', 'K'), ('spades', '4'), ('diamonds', '3'), ('diamonds', 'Q'), ('hearts', '8')})

----------------------------------------------------------------------
Ran 15 tests in 0.173s

FAILED (failures=4, errors=1)

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

Мариян обнови решението на 07.11.2022 00:31 (преди над 1 година)

+import random
+import itertools
+
+Suit = ('clubs', 'diamonds', 'hearts', 'spades')
+Face = ('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=Face):
+ self.cards = [Card(suit, face)
+ for face, suit in itertools.product(face_filter, Suit)]
+
+ def cut(self):
+ random_index = random.randint(1, len(self.cards))
+ for i, card in enumerate(self.cards[:random_index - 1:-1]):
+ self.cards.pop(random_index + i)
+ self.cards.insert(0, card)
+ return self.cards
+
+ def shuffle(self):
+ random.shuffle(self.cards)
+ return self.cards
+
+ def get_cards(self):
+ return self.cards
+
+
+class Player:
+ def __init__(self):
+ self.cards = []
+
+ def give_cards(self, given_cards):
+ self.cards += given_cards
+
+ def get_cards(self):
+ return self.cards
+
+
+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
+ for _ in range(0, self.number_of_players):
+ self.players = [Player() for _ in range(self.number_of_players)]
+ self.deck = Deck() if isinstance(self, Poker) else Deck(
+ ['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+
+ def get_players(self):
+ return self.players
+
+ def prepare_deck(self):
+ self.deck.cut()
+ self.deck.shuffle()
+
+ def deal(self, player):
+ index = self.players.index(player)
+ direction = 1 if self.dealing_direction == 'rtl' else -1
+ player_sequence = self.players[index::direction] + self.players[:index:direction]
+ copy_deck = self.deck.cards
+ for cards_to_give in self.dealing_instructions:
+ for every_player in player_sequence:
+ every_player.cards += copy_deck[0:cards_to_give]
+ copy_deck = copy_deck[cards_to_give:]
+
+ def get_deck(self):
+ given_cards = self.number_of_players * sum(self.dealing_instructions)
+ return self.deck.cards[given_cards:] if given_cards < len(self.deck.cards) else []
+
+
+class Belot(Game):
+ def __init__(self):
+ super().__init__(4, 'ltr', (2, 3, 3))
+
+
+class Poker(Game):
+ def __init__(self):
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

Предполагам става дума за функциите, връщащи лист от обекти. Доколкото разбрах от уточненията трябва да върнем [<main.'вид обект' at 'адрес на обект'>, <main.'вид обект' at 'адрес на обект'>, ...], в това ли е проблема, че не трябва да връща такова нещо?

Имам ли правото да попитам за насока/съвет, понеже още не знам какво се очаква да бъде върнато като лист от обекти? Даже intellisense-a ми показва, че се връща лист от обекти от желания тип. Дълго време четох документация, но се опасявам, че повечето начини да се изкара лист от обекти са далеч от това, което се очаква : използване на repr, str, dict.values(), комбинации от, dict(), zip(), list() и още десетки други.

(ПС: Оправих леки неточности и сега абсолютно всеки гетър връща лист от желаните обекти - остава и да го връщат по начина, който се очаква)

Мариян обнови решението на 08.11.2022 00:24 (преди над 1 година)

import random
import itertools
Suit = ('clubs', 'diamonds', 'hearts', 'spades')
Face = ('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=Face):
self.cards = [Card(suit, face)
for face, suit in itertools.product(face_filter, Suit)]
def cut(self):
- random_index = random.randint(1, len(self.cards))
- for i, card in enumerate(self.cards[:random_index - 1:-1]):
- self.cards.pop(random_index + i)
- self.cards.insert(0, card)
+ random_index = random.randint(1, len(self.cards) - 1)
+ self.cards = self.cards[random_index:] + self.cards[:random_index]
return self.cards
def shuffle(self):
random.shuffle(self.cards)
return self.cards
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.cards = []
def give_cards(self, given_cards):
self.cards += given_cards
def get_cards(self):
return self.cards
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
- for _ in range(0, self.number_of_players):
- self.players = [Player() for _ in range(self.number_of_players)]
+ self.players = [Player() for _ in range(self.number_of_players)]
self.deck = Deck() if isinstance(self, Poker) else Deck(
['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+ self.given_cards = 0
def get_players(self):
- return self.players
+ random_index = random.randint(0, len(self.players) - 1)
+ return self.players[random_index:] + self.players[:random_index]
def prepare_deck(self):
+ self.given_cards = 0
self.deck.cut()
self.deck.shuffle()
def deal(self, player):
index = self.players.index(player)
direction = 1 if self.dealing_direction == 'rtl' else -1
- player_sequence = self.players[index::direction] + self.players[:index:direction]
copy_deck = self.deck.cards
for cards_to_give in self.dealing_instructions:
- for every_player in player_sequence:
+ for every_player in self.players[index::direction] + self.players[:index:direction]:
every_player.cards += copy_deck[0:cards_to_give]
copy_deck = copy_deck[cards_to_give:]
+ self.given_cards += cards_to_give
def get_deck(self):
- given_cards = self.number_of_players * sum(self.dealing_instructions)
- return self.deck.cards[given_cards:] if given_cards < len(self.deck.cards) else []
+ return self.deck.cards[self.given_cards:]
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
class Poker(Game):
def __init__(self):
- super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

Мариян обнови решението на 08.11.2022 01:09 (преди над 1 година)

import random
import itertools
Suit = ('clubs', 'diamonds', 'hearts', 'spades')
Face = ('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=Face):
self.cards = [Card(suit, face)
for face, suit in itertools.product(face_filter, Suit)]
def cut(self):
random_index = random.randint(1, len(self.cards) - 1)
self.cards = self.cards[random_index:] + self.cards[:random_index]
return self.cards
def shuffle(self):
random.shuffle(self.cards)
return self.cards
def get_cards(self):
return self.cards
+ def set_cards(self, cards):
+ self.cards = cards
+
class Player:
def __init__(self):
self.cards = []
def give_cards(self, given_cards):
self.cards += given_cards
def get_cards(self):
return self.cards
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() if isinstance(self, Poker) else Deck(
['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
self.given_cards = 0
def get_players(self):
random_index = random.randint(0, len(self.players) - 1)
return self.players[random_index:] + self.players[:random_index]
def prepare_deck(self):
self.given_cards = 0
self.deck.cut()
self.deck.shuffle()
def deal(self, player):
index = self.players.index(player)
direction = 1 if self.dealing_direction == 'rtl' else -1
copy_deck = self.deck.cards
for cards_to_give in self.dealing_instructions:
for every_player in self.players[index::direction] + self.players[:index:direction]:
every_player.cards += copy_deck[0:cards_to_give]
copy_deck = copy_deck[cards_to_give:]
self.given_cards += cards_to_give
def get_deck(self):
- return self.deck.cards[self.given_cards:]
+ current_deck = Deck()
+ current_deck.set_cards(self.deck.cards[self.given_cards:])
+ return current_deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

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

-import random
-import itertools
+from random import randint, shuffle
+from itertools import product
Suit = ('clubs', 'diamonds', 'hearts', 'spades')
-Face = ('2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A')
+Face = tuple([str(num) for num in range(2,11)] + ['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=Face):
- self.cards = [Card(suit, face)
- for face, suit in itertools.product(face_filter, Suit)]
+ self.cards = [Card(suit, face) for suit, face in product(Suit, face_filter)]
def cut(self):
- random_index = random.randint(1, len(self.cards) - 1)
+ random_index = randint(1, len(self.cards) - 1)
self.cards = self.cards[random_index:] + self.cards[:random_index]
- return self.cards
def shuffle(self):
- random.shuffle(self.cards)
- return self.cards
+ shuffle(self.cards)
def get_cards(self):
return self.cards
def set_cards(self, cards):
self.cards = cards
class Player:
def __init__(self):
- self.cards = []
+ self.hand = []
- def give_cards(self, given_cards):
- self.cards += given_cards
+ def give_cards(self, given_cards): # list of cards
+ self.hand += given_cards
def get_cards(self):
- return self.cards
+ return self.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.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() if isinstance(self, Poker) else Deck(
- ['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
- self.given_cards = 0
def get_players(self):
- random_index = random.randint(0, len(self.players) - 1)
+ random_index = randint(0, len(self.players) - 1)
return self.players[random_index:] + self.players[:random_index]
- def prepare_deck(self):
- self.given_cards = 0
+ def prepare_deck(self): #self.deck comes from child class
self.deck.cut()
self.deck.shuffle()
- def deal(self, player):
- index = self.players.index(player)
- direction = 1 if self.dealing_direction == 'rtl' else -1
- copy_deck = self.deck.cards
+ def deal(self, player): #self.deck comes from child class
+ index = self.players.index(player)
for cards_to_give in self.dealing_instructions:
- for every_player in self.players[index::direction] + self.players[:index:direction]:
- every_player.cards += copy_deck[0:cards_to_give]
- copy_deck = copy_deck[cards_to_give:]
- self.given_cards += cards_to_give
+ for every_player in self.players[index::self.direction] + self.players[:index:self.direction]:
+ given_cards = sum(len(player.hand) for player in self.players)
+ every_player.hand += self.deck.cards[given_cards:given_cards + cards_to_give]
- def get_deck(self):
+ def get_deck(self): #self.deck comes from child class
current_deck = Deck()

Грешно е да инстанцираш ново тесте всеки път, когато попитам да ми дадеш тестето.
Идеята на този метод е да ми даде достъп до вътрешността на инстанцията, за да мога да я изтествам.
В общи линии - инстанцирам Game, при което очаквам да го напълниш с тесте с карти. За да видя какви карти имаш, използвам този метод. След това, да речем, ще се опитам да раздам картите и на базата на информацията, която съм получил от този метод, мога да проверя дали играчите са получили правилните карти.

- current_deck.set_cards(self.deck.cards[self.given_cards:])
+ current_deck.set_cards(self.deck.cards[sum(len(player.hand) for player in self.players):])
return current_deck
class Belot(Game):
def __init__(self):
+ self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
super().__init__(4, 'ltr', (2, 3, 3))
class Poker(Game):
def __init__(self):
+ self.deck = Deck()
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

Мариян обнови решението на 12.11.2022 13:38 (преди над 1 година)

-from random import randint, shuffle
from itertools import product
+from random import randint, shuffle
Suit = ('clubs', 'diamonds', 'hearts', 'spades')
-Face = tuple([str(num) for num in range(2,11)] + ['J','Q','K','A'])
+Face = tuple([str(num) for num in range(2, 11)] + ['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=Face):
self.cards = [Card(suit, face) for suit, face in product(Suit, face_filter)]
def cut(self):
random_index = randint(1, len(self.cards) - 1)
self.cards = self.cards[random_index:] + self.cards[:random_index]
def shuffle(self):
shuffle(self.cards)
def get_cards(self):
return self.cards
- def set_cards(self, cards):
- self.cards = cards
-
class Player:
def __init__(self):
self.hand = []
- def give_cards(self, given_cards): # list of cards
- self.hand += given_cards
-
def get_cards(self):
return self.hand
class Game:
- def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions): #self.deck will be overridden
self.number_of_players = number_of_players
self.direction = 1 if dealing_direction == 'rtl' else -1
self.dealing_instructions = dealing_instructions
- self.players = [Player() for _ in range(self.number_of_players)]
+ self.players = [Player() for _ in range(number_of_players)]
+ self.deck = Deck()
def get_players(self):
random_index = randint(0, len(self.players) - 1)
return self.players[random_index:] + self.players[:random_index]
- def prepare_deck(self): #self.deck comes from child class
+ def prepare_deck(self):
+ self.deck.cards = [card for player in self.players for card in player.hand]
self.deck.cut()
self.deck.shuffle()
- def deal(self, player): #self.deck comes from child class
- index = self.players.index(player)
+ def deal(self, player):
+ index = self.players.index(player)
for cards_to_give in self.dealing_instructions:
- for every_player in self.players[index::self.direction] + self.players[:index:self.direction]:
- given_cards = sum(len(player.hand) for player in self.players)
- every_player.hand += self.deck.cards[given_cards:given_cards + cards_to_give]
+ for player in self.players[index::self.direction] + self.players[:index:self.direction]:
+ player.hand += self.deck.cards[0:cards_to_give]
+ self.deck.cards = self.deck.cards[cards_to_give:]
- def get_deck(self): #self.deck comes from child class
- current_deck = Deck()
- current_deck.set_cards(self.deck.cards[sum(len(player.hand) for player in self.players):])
- return current_deck
+ def get_deck(self):
+ return self.deck
class Belot(Game):
def __init__(self):
- self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
super().__init__(4, 'ltr', (2, 3, 3))
+ self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
- self.deck = Deck()
- super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
+ self.deck = Deck()