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

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

Към профила на Николета Бейска

Резултати

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

Код

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return str(self._suit)
def get_face(self):
return str(self._face)
class Deck:
def __init__(self, face_filter=('2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A')):
self.cards = []
for face in face_filter:
for suit in ('clubs', 'diamonds', 'hearts', 'spades'):
self.cards.append(Card(suit, face))
def cut(self):
random_num = random.randint(0, len(self.cards)-1)
while random_num != 0:
to_remove = self.cards.pop(0)
self.cards.append(to_remove)
random_num -= 1
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.player_deck = Deck()
def get_cards(self):
return self.player_deck.get_cards()
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.players = []
self.number_of_players = number_of_players
self.dealing_directions = dealing_direction
self.dealing_instructions = dealing_instructions
while number_of_players != 0:
self.players.append(Player())
number_of_players -= 1
self.deck = Deck()
def get_players(self):
return self.players
def prepare_deck(self):
for player in players:
self.deck.cards.append(player.get_cards())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
copy_of_players = self.players[:]
if self.dealing_direction == 'rtl':
copy_of_players.reverse()
part_to_move = copy_of_players[:(len(copy_of_players) - copy_of_players.index(player))]
elif self.dealing_direction == 'ltr':
part_to_move = copy_of_players[:copy_of_players.index(player)]
del copy_of_players[:copy_of_players.index(player)]
copy_of_players.append(part_to_move)
for count_cards in self.dealing_instructions:
for player_to_deal in copy_of_players:
while count_cards != 0:
player_to_deal.player_deck.cards.append(self.deck.get_cards().pop(0))
count_cards -= 1
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
Game.deck = Deck(('7', '8', '9', 'J', 'Q', 'K', 'A'))
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', ('1', '1', '1', '1', '1'))

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

FE......EEE.E.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: 'Belot' object has no attribute 'dealing_direction'

======================================================================
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
NameError: name 'players' is not defined

======================================================================
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: 'Game' object has no attribute 'dealing_direction'

======================================================================
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
AttributeError: 'Game' object has no attribute 'dealing_direction'

======================================================================
ERROR: test_prepare_deck (test.TestGame)
Test preparing the deck for dealing.
----------------------------------------------------------------------
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
NameError: name 'players' is not defined

======================================================================
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: 'Poker' object has no attribute 'dealing_direction'

======================================================================
FAIL: test_correct_deck_init (test.TestBelot)
Test initialization with correct deck.
----------------------------------------------------------------------
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: Items in the second set but not the first:
('clubs', '2')
('clubs', '6')
('diamonds', '3')
('diamonds', '5')
('clubs', '3')
('hearts', '6')
('clubs', '5')
('hearts', '2')
('diamonds', '4')
('clubs', '4')
('hearts', '3')
('spades', '2')
('hearts', '5')
('spades', '6')
('hearts', '4')
('spades', '3')
('spades', '5')
('diamonds', '2')
('diamonds', '6')
('spades', '4')

----------------------------------------------------------------------
Ran 15 tests in 0.230s

FAILED (failures=1, errors=6)

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

Николета обнови решението на 13.11.2022 19:24 (преди над 1 година)

+class Card:
+
+ def __init__(self,suit,face):
+ self.suit = suit
+ self.face = face
+
+ def get_suit(self):
+ return str(self.suit)
+
+ def get_face(self):
+ return str(self.face)
+
+import random
+
+
+class Deck:
+
+ cards = []

Това е атрибут на класа, а не на инстанцията. Това значи, че всички интсанции на Deck ще споделят този атрибут. Ако инстанцирам 5 тестета, всичките им карти ще се озоват в един и същи обект, което значи, че твоят клас би поддържал само една единствена инстанция, иначе ще започне да се чупи. Правилният вариант е да го дефинираш като атрибут на инстанцията, както си направила в Card, например.

+
+ def __init__(self, face_filter = []):
+ for face in face_filter:
+ for suit in ('clubs','diamonds','hearts','spades'):
+ self.cards.append(Card(suit,face))
+
+ def cut(self):
+ random_num = random.randit(0,len(self.cards)-1)
+ for index in range(0,random_num):
+ to_remove = self.cards.pop(index)

Премахвайки карта от тестето, индекса, по който циклиш, вече не е това, което е бил. За да постигнеш това, което искаш, трябва винаги да вадиш първата карта, а не първата, втората, третата...

+ self.cards.append(to_remove)
+
+ def shuffle(self):
+ random.shuffle(self.cards)
+
+ def get_cards(self):
+ return self.cards
+
+
+class Player:
+
+ def __init__(self):
+ self.player_deck = Deck()
+
+ def get_cards(self):
+ return self.player_deck.get_cards()
+
+
+class Game:
+
+ players = []
+
+ def __init__(self,number_of_players,dealing_direction, dealing_instructions):
+ self.number_of_players = number_of_players
+ self.dealing_directions = dealing_direction
+ self.dealing_instructions = dealing_instructions
+ self.deck = Deck(('2','3','4','5','6','7','8','9','J','Q','K','A'))
+
+ def get_players(self):
+ return self.players
+
+ def prepare_deck(self):
+ for player in players:
+ self.deck.cards.append(player.get_cards())
+ self.deck.shuffle()
+ self.deck.cut()
+
+ def deal(self,player):
+ copy_of_players = self.players
+ if self.dealing_direction == 'rtr':
+ copy_of_players.reverse()
+ part_to_move = copy_of_players[:(len(copy_of_players) - copy_of_players.index(player))]
+ elif self.dealing_direction == 'ltr':
+ part_to_move = copy_of_players[:copy_of_players.index(player)]
+ del copy_of_players[:copy_of_players.index(player)]
+ copy_of_players.append(part_to_move)
+ for count_cards in self.dealing_instructions:
+ for player_to_deal in copy_of_players:
+ while count_cards != 0:
+ player_to_deal.player_deck.cards.append(self.deck.get_cards().pop(0))
+ count_cards -= 1
+
+ def get_deck(self):
+ return self.deck
+
+
+class Belot(Game):
+
+ def __init__(self):
+ super().__init__(4,'ltr',(2,3,3))
+ Game.deck = Deck(('7','8','9','J','Q','K','A'))
+
+
+class Poker(Game):
+
+ def __init__(self):
+ super().__init__(9,'rtr',('1','1','1','1','1'))
+

Николета обнови решението на 14.11.2022 19:46 (преди над 1 година)

+import random
class Card:
-
- def __init__(self,suit,face):
- self.suit = suit
- self.face = face
+ def __init__(self, suit, face):
+ self._suit = suit
+ self._face = face
+
def get_suit(self):
- return str(self.suit)
+ return str(self._suit)
def get_face(self):
- return str(self.face)
+ return str(self._face)
-import random
-
class Deck:
-
- cards = []
-
- def __init__(self, face_filter = []):
+
+ def __init__(self, face_filter=[]):
+ self.cards = []
for face in face_filter:
- for suit in ('clubs','diamonds','hearts','spades'):
- self.cards.append(Card(suit,face))
+ for suit in ('clubs', 'diamonds', 'hearts', 'spades'):
+ self.cards.append(Card(suit, face))
def cut(self):
- random_num = random.randit(0,len(self.cards)-1)
- for index in range(0,random_num):
- to_remove = self.cards.pop(index)
- self.cards.append(to_remove)
+ random_num = random.randit(len(self.cards)-1)
+ while random_num != 0:
+ to_remove = self.cards.pop(0)
+ self.cards.append(to_remove)
+ random_num -= 1
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
-
+
def __init__(self):
self.player_deck = Deck()
-
+
def get_cards(self):
return self.player_deck.get_cards()
class Game:
-
- players = []
-
- def __init__(self,number_of_players,dealing_direction, dealing_instructions):
+
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self.players = []
self.number_of_players = number_of_players
self.dealing_directions = dealing_direction
self.dealing_instructions = dealing_instructions
- self.deck = Deck(('2','3','4','5','6','7','8','9','J','Q','K','A'))
-
+ while number_of_players != 0:
+ self.players.append(Player())
+ number_of_players -= 1
+ self.deck = Deck(('2', '3', '4', '5', '6', '7', '8', '9', 'J', 'Q', 'K', 'A'))
+
def get_players(self):
return self.players
-
+
def prepare_deck(self):
for player in players:
self.deck.cards.append(player.get_cards())
self.deck.shuffle()
self.deck.cut()
-
- def deal(self,player):
- copy_of_players = self.players
- if self.dealing_direction == 'rtr':
+
+ def deal(self, player):
+ copy_of_players = self.players[:]
+ if self.dealing_direction == 'rtl':
copy_of_players.reverse()
part_to_move = copy_of_players[:(len(copy_of_players) - copy_of_players.index(player))]
elif self.dealing_direction == 'ltr':
part_to_move = copy_of_players[:copy_of_players.index(player)]
del copy_of_players[:copy_of_players.index(player)]
copy_of_players.append(part_to_move)
for count_cards in self.dealing_instructions:
for player_to_deal in copy_of_players:
while count_cards != 0:
player_to_deal.player_deck.cards.append(self.deck.get_cards().pop(0))
count_cards -= 1
-
+
def get_deck(self):
return self.deck
class Belot(Game):
-
+
def __init__(self):
- super().__init__(4,'ltr',(2,3,3))
- Game.deck = Deck(('7','8','9','J','Q','K','A'))
+ super().__init__(4, 'ltr', (2, 3, 3))
+ Game.deck = Deck(('7', '8', '9', 'J', 'Q', 'K', 'A'))
class Poker(Game):
-
+
def __init__(self):
- super().__init__(9,'rtr',('1','1','1','1','1'))
+ super().__init__(9, 'rtr', ('1', '1', '1', '1', '1'))

Николета обнови решението на 14.11.2022 19:47 (преди над 1 година)

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return str(self._suit)
def get_face(self):
return str(self._face)
class Deck:
def __init__(self, face_filter=[]):
self.cards = []
for face in face_filter:
for suit in ('clubs', 'diamonds', 'hearts', 'spades'):
self.cards.append(Card(suit, face))
def cut(self):
random_num = random.randit(len(self.cards)-1)
while random_num != 0:
to_remove = self.cards.pop(0)
self.cards.append(to_remove)
random_num -= 1
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.player_deck = Deck()
def get_cards(self):
return self.player_deck.get_cards()
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.players = []
self.number_of_players = number_of_players
self.dealing_directions = dealing_direction
self.dealing_instructions = dealing_instructions
while number_of_players != 0:
self.players.append(Player())
number_of_players -= 1
self.deck = Deck(('2', '3', '4', '5', '6', '7', '8', '9', 'J', 'Q', 'K', 'A'))
def get_players(self):
return self.players
def prepare_deck(self):
for player in players:
self.deck.cards.append(player.get_cards())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
copy_of_players = self.players[:]
if self.dealing_direction == 'rtl':
copy_of_players.reverse()
part_to_move = copy_of_players[:(len(copy_of_players) - copy_of_players.index(player))]
elif self.dealing_direction == 'ltr':
part_to_move = copy_of_players[:copy_of_players.index(player)]
del copy_of_players[:copy_of_players.index(player)]
copy_of_players.append(part_to_move)
for count_cards in self.dealing_instructions:
for player_to_deal in copy_of_players:
while count_cards != 0:
player_to_deal.player_deck.cards.append(self.deck.get_cards().pop(0))
count_cards -= 1
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
Game.deck = Deck(('7', '8', '9', 'J', 'Q', 'K', 'A'))
class Poker(Game):
def __init__(self):
- super().__init__(9, 'rtr', ('1', '1', '1', '1', '1'))
+ super().__init__(9, 'rtl', ('1', '1', '1', '1', '1'))

Николета обнови решението на 15.11.2022 17:28 (преди над 1 година)

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return str(self._suit)
def get_face(self):
return str(self._face)
class Deck:
- def __init__(self, face_filter=[]):
+ def __init__(self, face_filter=('2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A')):
self.cards = []
for face in face_filter:
for suit in ('clubs', 'diamonds', 'hearts', 'spades'):
self.cards.append(Card(suit, face))
def cut(self):
- random_num = random.randit(len(self.cards)-1)
+ random_num = random.randint(0, len(self.cards)-1)
while random_num != 0:
to_remove = self.cards.pop(0)
self.cards.append(to_remove)
random_num -= 1
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.player_deck = Deck()
def get_cards(self):
return self.player_deck.get_cards()
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.players = []
self.number_of_players = number_of_players
self.dealing_directions = dealing_direction
self.dealing_instructions = dealing_instructions
while number_of_players != 0:
self.players.append(Player())
number_of_players -= 1
- self.deck = Deck(('2', '3', '4', '5', '6', '7', '8', '9', 'J', 'Q', 'K', 'A'))
+ self.deck = Deck()
def get_players(self):
return self.players
def prepare_deck(self):
for player in players:
self.deck.cards.append(player.get_cards())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
copy_of_players = self.players[:]
if self.dealing_direction == 'rtl':
copy_of_players.reverse()
part_to_move = copy_of_players[:(len(copy_of_players) - copy_of_players.index(player))]
elif self.dealing_direction == 'ltr':
part_to_move = copy_of_players[:copy_of_players.index(player)]
del copy_of_players[:copy_of_players.index(player)]
copy_of_players.append(part_to_move)
for count_cards in self.dealing_instructions:
for player_to_deal in copy_of_players:
while count_cards != 0:
player_to_deal.player_deck.cards.append(self.deck.get_cards().pop(0))
count_cards -= 1
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
Game.deck = Deck(('7', '8', '9', 'J', 'Q', 'K', 'A'))
class Poker(Game):
def __init__(self):
- super().__init__(9, 'rtl', ('1', '1', '1', '1', '1'))
+ super().__init__(9, 'rtr', ('1', '1', '1', '1', '1'))
+

Николета обнови решението на 15.11.2022 17:29 (преди над 1 година)

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return str(self._suit)
def get_face(self):
return str(self._face)
class Deck:
def __init__(self, face_filter=('2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A')):
self.cards = []
for face in face_filter:
for suit in ('clubs', 'diamonds', 'hearts', 'spades'):
self.cards.append(Card(suit, face))
def cut(self):
random_num = random.randint(0, len(self.cards)-1)
while random_num != 0:
to_remove = self.cards.pop(0)
self.cards.append(to_remove)
random_num -= 1
def shuffle(self):
random.shuffle(self.cards)
def get_cards(self):
return self.cards
class Player:
def __init__(self):
self.player_deck = Deck()
def get_cards(self):
return self.player_deck.get_cards()
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self.players = []
self.number_of_players = number_of_players
self.dealing_directions = dealing_direction
self.dealing_instructions = dealing_instructions
while number_of_players != 0:
self.players.append(Player())
number_of_players -= 1
self.deck = Deck()
def get_players(self):
return self.players
def prepare_deck(self):
for player in players:
self.deck.cards.append(player.get_cards())
self.deck.shuffle()
self.deck.cut()
def deal(self, player):
copy_of_players = self.players[:]
if self.dealing_direction == 'rtl':
copy_of_players.reverse()
part_to_move = copy_of_players[:(len(copy_of_players) - copy_of_players.index(player))]
elif self.dealing_direction == 'ltr':
part_to_move = copy_of_players[:copy_of_players.index(player)]
del copy_of_players[:copy_of_players.index(player)]
copy_of_players.append(part_to_move)
for count_cards in self.dealing_instructions:
for player_to_deal in copy_of_players:
while count_cards != 0:
player_to_deal.player_deck.cards.append(self.deck.get_cards().pop(0))
count_cards -= 1
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
Game.deck = Deck(('7', '8', '9', 'J', 'Q', 'K', 'A'))
class Poker(Game):
def __init__(self):
- super().__init__(9, 'rtr', ('1', '1', '1', '1', '1'))
+ super().__init__(9, 'rtl', ('1', '1', '1', '1', '1'))