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

Резултати

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=[]):

        self._face_filter = face_filter

        self.deck_cards = []

        self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']

        self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]

        if len(self._face_filter) != 0:

            self.__faces = self._face_filter

        for suit in self.__suits:

            for face in self.__faces:

                self.deck_cards.append(Card(suit, face))

    def cut(self):

        cut_pivot = random.randint(1, len(self.deck_cards) - 1)

        self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]

    def shuffle(self):

        random.shuffle(self.deck_cards)

    def get_cards(self):

        return self.deck_cards

class Player:

    def __init__(self):

        self.player_cards = []

    def get_cards(self):

        return self.player_cards

class Game(Deck):

    def __init__(self, number_of_players, dealing_direction, dealing_instructions):

        self.number_of_players = number_of_players

        self.dealing_direction = dealing_direction.lower()

        self.dealing_instructions = dealing_instructions

        self.deck = Deck()

        self.players = []

        for _player in range(number_of_players):

            self.players.append(Player())

    def get_players(self):

        return self.players

    def prepare_deck(self):

        for player in self.players:

            while len(player.player_cards) != 0:

                self.deck.deck_cards.append(player.player_cards.pop())

        self.deck.shuffle()

        self.deck.cut()

    def deal(self, player):

        pivot = self.players.index(player)

        self.players = self.players[pivot:] + self.players[:pivot]

        if self.dealing_direction == "rtl":

            first_elem = self.players.pop(0)

            self.players.reverse()

            self.players.insert(0, first_elem)

        for number_of_cards in self.dealing_instructions:

            for player in self.players:

                for elem in range(number_of_cards):

                    player.player_cards.append(self.deck.deck_cards.pop(0))

    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))

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

...............
----------------------------------------------------------------------
Ran 15 tests in 0.164s

OK

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

Йоан обнови решението на 13.11.2022 05:40 (преди над 2 години)

+import random

+class Card:

+    def __init__(self, suit, face):

+        self.suit = suit

Бих използвал protected имена на атрибути като тези, които не използваш извън класа - self._suit
Георгикоментира преди над 2 години

+        self.face = face

+    def get_suit(self):

+        return self.suit

+    def get_face(self):

+        return self.face

+class Deck:

+    def __init__(self, face_filter=[]):

+        self.__face_filter = face_filter

Обикновено __ се използва, ако наистина искаш да кажеш на някого, че не трябва да го пипа, както и в случаите, в които искаш да предотвратиш конфликт на имена при наследяване. Тук е напълно достатъчно да използваш енда  _.
Георгикоментира преди над 2 години

+        self.deck_cards = []

+        self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']

+        self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]

+        if len(self.__face_filter) == 0:

Можеш да се опиташ да обединиш тези два почти идентични бока, като репдварително подготвиш променлива с всички лица.
Георгикоментира преди над 2 години

+            for suit in self.__suits:

+                for face in self.__faces:

+                    self.deck_cards.append(Card(suit, face))

+        else:

+            for suit in self.__suits:

+                for face in self.__face_filter:

+                    self.deck_cards.append(Card(suit, face))

+    def cut(self):

+        cut_pivot = random.randint(1, 51)

Не всички тестета ще имат точно толкова карти. Вземи броя динамично.
Георгикоментира преди над 2 години

+        self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]

+    def shuffle(self):

+        random.shuffle(self.deck_cards)

+    def get_cards(self):

+        return self.deck_cards

+class Player:

+    def __init__(self):

+        self.player_cards = []

+    def get_cards(self):

+        return self.player_cards

+class Game(Deck):

+    def __init__(self, number_of_players, dealing_direction, dealing_instructions):

+        self.number_of_players = number_of_players

+        self.dealing_direction = dealing_direction.lower()

+        self.dealing_instructions = dealing_instructions

+        self.deck = Deck()

+        self.players = []

+        for player in range(number_of_players):

Когато една променлива не ти трябва, използвай _, както е по конвенция.
Георгикоментира преди над 2 години

+            self.players.append(Player())

+    def get_players(self):

+        return self.players  # proizvolen?

Това е частен случай на произволен ред, така че е валидно ;)
Георгикоментира преди над 2 години

+    def prepare_deck(self):

+        for player in self.players:

+            while len(player.player_cards) != 0:

+                self.deck.deck_cards.append(player.player_cards.pop())

+        self.deck.shuffle()

+        self.deck.cut()

+    def deal(self, player):

+        pivot = self.players.index(player)

+        self.players = self.players[pivot:] + self.players[:pivot]

+        if self.dealing_direction == "rtl":

+            first_elem = self.players.pop(0)

+            self.players.reverse()

+            self.players.insert(0, first_elem)

+        for number_of_cards in self.dealing_instructions:

+            for player in self.players:

+                for elem in range(number_of_cards):

+                    player.player_cards.append(self.deck.deck_cards.pop())

+    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))

Йоан обнови решението на 13.11.2022 17:11 (преди над 2 години)

 import random

 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=[]):

-        self.__face_filter = face_filter

+        self._face_filter = face_filter

         self.deck_cards = []

         self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']

         self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]

-        if len(self.__face_filter) == 0:

+        if len(self._face_filter) != 0:

+            self.__faces = self._face_filter

             for suit in self.__suits:

Грешка в индентацията на for цикъла
Йоан Христовкоментира преди над 2 години

                 for face in self.__faces:

                     self.deck_cards.append(Card(suit, face))

-        else:

-            for suit in self.__suits:

-                for face in self.__face_filter:

-                    self.deck_cards.append(Card(suit, face))

     def cut(self):

-        cut_pivot = random.randint(1, 51)

+        cut_pivot = random.randint(1, len(self.deck_cards) - 1)

         self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]

     def shuffle(self):

         random.shuffle(self.deck_cards)

     def get_cards(self):

         return self.deck_cards

 class Player:

     def __init__(self):

         self.player_cards = []

     def get_cards(self):

         return self.player_cards

 class Game(Deck):

     def __init__(self, number_of_players, dealing_direction, dealing_instructions):

         self.number_of_players = number_of_players

         self.dealing_direction = dealing_direction.lower()

         self.dealing_instructions = dealing_instructions

         self.deck = Deck()

         self.players = []

-        for player in range(number_of_players):

+        for _player in range(number_of_players):

             self.players.append(Player())

     def get_players(self):

-        return self.players  # proizvolen?

+        return self.players

     def prepare_deck(self):

         for player in self.players:

             while len(player.player_cards) != 0:

                 self.deck.deck_cards.append(player.player_cards.pop())

         self.deck.shuffle()

         self.deck.cut()

     def deal(self, player):

         pivot = self.players.index(player)

         self.players = self.players[pivot:] + self.players[:pivot]

         if self.dealing_direction == "rtl":

             first_elem = self.players.pop(0)

             self.players.reverse()

             self.players.insert(0, first_elem)

         for number_of_cards in self.dealing_instructions:

             for player in self.players:

                 for elem in range(number_of_cards):

                     player.player_cards.append(self.deck.deck_cards.pop())

     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))

Направих промени спрямо коментарите и трябва всичко да е гучи джапанка🧐

Публикувано преди над 2 години

Йоан обнови решението на 14.11.2022 19:50 (преди над 2 години)

 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=[]):

         self._face_filter = face_filter

         self.deck_cards = []

         self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']

         self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]

         if len(self._face_filter) != 0:

             self.__faces = self._face_filter

-            for suit in self.__suits:

-                for face in self.__faces:

-                    self.deck_cards.append(Card(suit, face))

+        for suit in self.__suits:

+            for face in self.__faces:

+                self.deck_cards.append(Card(suit, face))

     def cut(self):

         cut_pivot = random.randint(1, len(self.deck_cards) - 1)

         self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]

     def shuffle(self):

         random.shuffle(self.deck_cards)

     def get_cards(self):

         return self.deck_cards

 class Player:

     def __init__(self):

         self.player_cards = []

     def get_cards(self):

         return self.player_cards

 class Game(Deck):

     def __init__(self, number_of_players, dealing_direction, dealing_instructions):

         self.number_of_players = number_of_players

         self.dealing_direction = dealing_direction.lower()

         self.dealing_instructions = dealing_instructions

         self.deck = Deck()

         self.players = []

         for _player in range(number_of_players):

             self.players.append(Player())

     def get_players(self):

         return self.players

     def prepare_deck(self):

         for player in self.players:

             while len(player.player_cards) != 0:

                 self.deck.deck_cards.append(player.player_cards.pop())

         self.deck.shuffle()

         self.deck.cut()

     def deal(self, player):

         pivot = self.players.index(player)

         self.players = self.players[pivot:] + self.players[:pivot]

         if self.dealing_direction == "rtl":

             first_elem = self.players.pop(0)

             self.players.reverse()

             self.players.insert(0, first_elem)

         for number_of_cards in self.dealing_instructions:

             for player in self.players:

                 for elem in range(number_of_cards):

                     player.player_cards.append(self.deck.deck_cards.pop())

     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))

Йоан обнови решението на 15.11.2022 12:57 (преди над 2 години)

 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=[]):

         self._face_filter = face_filter

         self.deck_cards = []

         self.__suits = ['clubs', 'diamonds', 'hearts', 'spades']

         self.__faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]

         if len(self._face_filter) != 0:

             self.__faces = self._face_filter

         for suit in self.__suits:

             for face in self.__faces:

                 self.deck_cards.append(Card(suit, face))

     def cut(self):

         cut_pivot = random.randint(1, len(self.deck_cards) - 1)

         self.deck_cards = self.deck_cards[cut_pivot:] + self.deck_cards[:cut_pivot]

     def shuffle(self):

         random.shuffle(self.deck_cards)

     def get_cards(self):

         return self.deck_cards

 class Player:

     def __init__(self):

         self.player_cards = []

     def get_cards(self):

         return self.player_cards

 class Game(Deck):

     def __init__(self, number_of_players, dealing_direction, dealing_instructions):

         self.number_of_players = number_of_players

         self.dealing_direction = dealing_direction.lower()

         self.dealing_instructions = dealing_instructions

         self.deck = Deck()

         self.players = []

         for _player in range(number_of_players):

             self.players.append(Player())

     def get_players(self):

         return self.players

     def prepare_deck(self):

         for player in self.players:

             while len(player.player_cards) != 0:

                 self.deck.deck_cards.append(player.player_cards.pop())

         self.deck.shuffle()

         self.deck.cut()

     def deal(self, player):

         pivot = self.players.index(player)

         self.players = self.players[pivot:] + self.players[:pivot]

         if self.dealing_direction == "rtl":

             first_elem = self.players.pop(0)

             self.players.reverse()

             self.players.insert(0, first_elem)

         for number_of_cards in self.dealing_instructions:

             for player in self.players:

                 for elem in range(number_of_cards):

-                    player.player_cards.append(self.deck.deck_cards.pop())

+                    player.player_cards.append(self.deck.deck_cards.pop(0))

     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))

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

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

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

Резултати

Код

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

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

Йоан обнови решението на 13.11.2022 05:40 (преди над 2 години)

Йоан обнови решението на 13.11.2022 17:11 (преди над 2 години)

Йоан обнови решението на 14.11.2022 19:50 (преди над 2 години)

Йоан обнови решението на 15.11.2022 12:57 (преди над 2 години)