数据结构-中土世界有四种生物

中土世界有四种生物：矮人 (Dwarves)、哈比人(Hobbits)、精灵( Elves)、和人类（Humans）。你想在霍比顿开一家餐厅，很快就会意识到这四种类型的餐厅都有非常具体的规则来规定他们可以和谁一起用餐，这就导致了……在你酒店的餐厅区域出现了有趣的占用情况。也就是说，您的桌子最多可以容纳7个人：当新客户到来时，他们会根据以下规则选择自己的桌子。

1.哈比人总是去最不拥挤的桌子，如果他们都坐满了，就会换一张新桌子。

2.精灵们会选择与精灵们一起去最近的桌子[到门口]；如果没有，他们将开始坐一张新桌子。

3.矮人会去最近的一张桌子，那里只有最少的精灵，如果他们都坐满了，就会开始一张新的桌子。

4.只要不是只有矮人、精灵或霍比特人，人类就会去最近的桌子，如果他们都坐满了，就会开始一张新的桌子。

o检查桌子是否已满：is_table_full（）

o检查桌子当前是否仅为精灵：is_elves_only（）

o查看桌子当前是否为矮人、霍比特人或精灵：is_dhe_only（）

o检查桌子当前的人数：get_total_diners（）

o检查桌子当前精灵的数量：get_elves（）

o根据上述规则，将精灵、人类、矮人或霍比特人添加到桌子中（如果桌子已满，则应返回null）：Add_Elf（）、Add_Human（u）、Add_Dwarf（）和Add_Hobbit（）。

o检查到饭店入口的距离（如果当前有n个桌子，则返回一个介于1（最近的桌子）和n（最远的桌子）之间的数字：get_distance（）

-您可以在距离门最远的位置增加一个新桌子（最初为空）：start_new_table（）

-您可以检索最不拥挤的桌子：get_least_crowded_table（）[如果是人满，请返回距离门最近的一张桌子][应该在时间O（1）内运行]

-您可以检索当前的桌子数：get_number_tables（）[应在时间O（1）内运行]

-您可以检索客户数：get_number_diners（）[应在时间O（1）内运行]

-您可以检索精灵、矮人、人类和霍比特人的数量：get_number_Elves（）、get_nummber_Humans（）、get_number_Dwarves（）

from Table import Table

"""
Restaurant Class
----------

#这个类代表管理桌子和进来的顾客的整个餐厅。
餐厅没有附加属性 - 您可以自由添加所需的任何属性。
请记住，支持餐厅的数据结构必须能够满足下面给出的功能的时间要求。 考虑哪种数据结构最好

该类还支持以下功能：
- __init__(self): 初始化餐厅
    - start_new_table(self) -> Table: 在餐厅开始一张新桌子
    - add_hobbit(self)：按照座位要求向餐厅添加一个霍比特人
    - add_elf(self)：按照座位要求添加一个精灵到餐厅
    - add_dwarf(self)：按照座位要求向餐厅添加一个矮人
    - add_human(self)：按照座位要求向餐厅添加一个人
    - get_least_crowded_table(self) -> Table：返回餐厅中最不拥挤的桌子。应该在 O(1) 时间内运行。
    - get_number_tables(self) -> int：返回餐厅的桌数。应该在 O(1) 时间内运行。
    - get_number_diners(self) -> int：返回餐厅的用餐者人数。应该在 O(1) 时间内运行。
    - get_number_hobbits(self) -> int：返回餐厅的霍比特人数量。应该在 O(1) 时间内运行。
    - get_number_elves(self) -> int：返回餐厅中精灵的数量。应该在 O(1) 时间内运行。
    - get_number_dwarves(self) -> int: 返回餐厅的矮人数量。应该在 O(1) 时间内运行。
    - get_number_humans(self) -> int：返回餐厅的人数。应该在 O(1) 时间内运行。
 
您的任务是完成以下注释标记的功能。
只要给定的保持相同，您就可以自由地向类添加属性和函数。
"""


class Restaurant:

# TODO: 在此处为您的数据结构添加您自己的属性

    def __init__(self):
        """
      完成 Restaurant 类的构造函数。
        """
       

    def start_new_table(self) -> Table:
        """
        在餐厅新建一张餐桌。
         :return: 创建的新桌子。
        """
        
    

    def add_hobbit(self) -> None:
        """
        在餐厅最不拥挤的餐桌上添加一个霍比特人。
         如果有多张桌子的用餐人数相同，
         把霍比特人放到离门最近的桌子上。 如果所有的
         桌子满了，开始一张新桌子。
        """

       
    def add_elf(self) -> None:
        """
        将精灵添加到最靠近门的第一张桌子
         只属于精灵。 如果这样的桌子不存在，则启动一个新桌
        """

       
    def add_dwarf(self) -> None:
        """
        在精灵最少的桌子上添加一个矮人。 如果多个桌子有
         等量的精灵，选择离门最近的一个。 如果没有这样桌子可以找到
或所有桌子都满了，开始一个新桌子。
        """

      
    def add_human(self) -> None:
        """
        将人类添加到最近的不是只有矮人的桌子上，
         仅限精灵或仅限霍比特人。 如果不存在这样的桌，则启动一个新桌。
        """

       
    def get_least_crowded_table(self) -> Table:
        """
        返回餐厅中最不拥挤的餐桌。
         如果有多张桌子的用餐人数相同，返回离门最近的桌子。
         （这应该在 O(1) 时间内运行。）
         :return: 餐厅里最不拥挤的桌子。 如果没有桌子，则返回 None。
        """

     
    def get_number_tables(self) -> int:
        """
       返回餐厅的桌子数量。
         这应该在 O(1) 时间内运行。
         :return: 餐厅的桌数。
        """

    def get_number_diners(self) -> int:
        """
        返回餐厅的用餐者总数。
         这应该在 O(1) 时间内运行。
         :return: 餐厅的用餐者总数。
        """

     
    def get_number_hobbits(self) -> int:
        """
       返回餐厅中的霍比特人总数。
         这应该在 O(1) 时间内运行。
         :return: 餐厅里的霍比特人总数。
        """

    def get_number_elves(self) -> int:
        """
        返回餐厅中精灵的总数。
         这应该在 O(1) 时间内运行。
         :return: 餐厅里的精灵总数。
        """

       
    def get_number_dwarves(self) -> int:
        """
       返回餐厅中的小矮人总数。
         这应该在 O(1) 时间内运行。
         :return: 餐厅里的小矮人总数。
        """

       
    def get_number_humans(self) -> int:
        """
       返回餐厅中的总人数。
         这应该在 O(1) 时间内运行。
         :return: 餐厅的总人数。
        """

       
    # TODO ：添加您需要的任何其他功能






"""
Table Class
----------

#这个类代表餐厅内的一张桌子。 

每个 Table 都有以下静态类属性：
    - capacity:可坐在餐桌旁的最大人数

每个桌子还具有以下实例属性：    
- distance: 桌子到门的距离。 最近的门距离为 1，下一个最接近的距离为 2，依此类推。
- hobbits: 坐在餐桌旁的霍比特人数量
- elves:坐在餐桌旁的精灵数量
- dwarves: 坐在餐桌旁的矮人数量    
- humans: 坐在餐桌旁的人类数量

该类还支持以下功能：
- __init__(self, distance, **kwargs): 初始化桌子到门的距离
  - is_table_full(self): 如果桌子已满，则返回 True，否则返回 False
- is_elves_only(self): 如果桌子只包含精灵，则返回 True    
- is_dhe_only(self): 如果表仅包含矮人、霍比特人或精灵，则返回 True
    - get_total_diners(self): 返回餐桌上的用餐者总数
    - get_elves(self): 返回餐桌上的精灵数量
    - get_distance(self): 返回从桌子到门的距离
- add_hobbit(self): 在桌子上添加一个霍比特人
    - add_elf(self): 在桌子上添加一个精灵
    - add_dwarf(self): 在桌子上添加一个矮人
    - add_human(self): 在桌子上添加一个人类
#"""


class Table:
    capacity: int = 7

# 这些是上面定义的实例属性。 随意添加您需要的任何额外属性。
    distance: int
    hobbits: int
    elves: int
    dwarves: int
    humans: int

    def __init__(self, distance: int, **kwargs) -> None:
        """
        Table 类的构造函数。
         :param distance：桌子到门的距离。
         :param kwargs: 要传递给构造函数的任何额外参数。.
        """
       

    def is_table_full(self) -> bool:
        """
        返回桌子是否已满。
         :return: 如果桌子已满，则返回 True，否则返回 False。
        """

      
    def is_elves_only(self) -> bool:
        """
        返回桌子是否只有精灵。
         桌上必须至少有一个精灵才能被视为仅限精灵。
         :return: 如果桌子只有精灵，则返回 True，否则返回 False。
        """

       
    def is_dhe_only(self) -> bool:
        """
        返回桌子是由矮人、霍比特人还是精灵组成的。
         请注意，至少有一个生物必须在桌子上才能被考虑
         仅限矮人、仅限霍比特人或仅限精灵。
         :return: 如果桌子只由矮人、霍比特人或精灵组成，则返回true。
        """

       
    def get_total_diners(self) -> int:
        """
        返回餐桌上用餐者的总数。
         :return: 餐桌上的用餐者总数。
        """

      
    def get_elves(self) -> int:
        """
        返回餐桌上精灵的数量。
         :return: 桌上精灵的数量。
        """

      
    def get_distance(self) -> int:
        """
        返回桌子到门的距离。
         :return: 桌子到门的距离。
        """

        
    def add_hobbit(self) -> None:
        """
       在桌子上添加一个霍比特人。
         如果桌子已经满了，这个函数应该什么都不做。
        """

        
    def add_elf(self) -> None:
        """
        将精灵添加到桌子中。
         如果桌已经满了，这个函数应该什么都不做。
        """

    def add_dwarf(self) -> None:
        """
       将一个矮人添加到桌子中。
         如果桌已经满了，这个函数应该什么都不做。
        """

       
    def add_human(self) -> None:
        """
        将人类添加到桌子中。
         如果桌已经满了，这个函数应该什么都不做。
        """

        




#测试
from Table import Table
from Restaurant import Restaurant

from unittest import TestCase


def assert_equal(got, expected, msg):  # type: ignore
    """
    Simple assert helper
    """
    assert expected == got, "[{}] Expected: {}, got: {}".format(msg, expected, got)  # type: ignore


class TableRestaurantTestSuite(TestCase):
    def test_table_sample(self):
        # Initialise a table with distance 1
        table = Table(1)
        assert_equal(table.get_distance(), 1, "Table distance is incorrect")

        # Add 5 hobbits to the table
        for _ in range(5):
            table.add_hobbit()

        # Check that the table has been updated correctly
        assert_equal(table.is_table_full(), False, "Table is not currently full")
        assert_equal(table.is_dhe_only(), True, "Table is currently DHE only")
        assert_equal(table.is_elves_only(), False, "Table is not currently elves only")
        assert_equal(table.get_total_diners(), 5, "Table total diners count is incorrect")
        assert_equal(table.get_elves(), 0, "Table elves count is incorrect")
        assert_equal(table.get_distance(), 1, "Table distance is incorrect")

        # Add an elf and a human to the table
        table.add_elf()
        table.add_human()

        # Check that the table has been updated correctly
        assert_equal(table.is_table_full(), True, "Table is currently full")
        assert_equal(table.is_dhe_only(), False, "Table is not currently DHE only")
        assert_equal(table.is_elves_only(), False, "Table is not currently elves only")
        assert_equal(table.get_total_diners(), 7, "Table total diners count is incorrect")
        assert_equal(table.get_elves(), 1, "Table elves count is incorrect")
        assert_equal(table.get_distance(), 1, "Table distance is incorrect")

    def test_restaurant_sample(self):
        # Initialise the restaurant and start a new table
        restaurant = Restaurant()
        restaurant.start_new_table()

        # Check that the restaurant has been initialised correctly
        assert_equal(restaurant.get_number_tables(), 1, "Restaurant number of tables is incorrect")
        assert_equal(restaurant.get_number_diners(), 0, "Restaurant number of diners is incorrect")
        assert_equal(restaurant.get_number_hobbits(), 0, "Restaurant number of hobbits is incorrect")
        assert_equal(restaurant.get_number_elves(), 0, "Restaurant number of elves is incorrect")
        assert_equal(restaurant.get_number_dwarves(), 0, "Restaurant number of dwarves is incorrect")
        assert_equal(restaurant.get_number_humans(), 0, "Restaurant number of humans is incorrect")
        assert_equal(
            restaurant.get_least_crowded_table().get_distance(),
            1,
            "Restaurant least crowded table distance is incorrect",
        )
        assert_equal(
            restaurant.get_least_crowded_table().get_elves(),
            0,
            "Restaurant least crowded table elves count is incorrect",
        )

        # Let's add some diners to the restaurant
        restaurant.add_dwarf()
        restaurant.add_hobbit()
        restaurant.add_elf()

        # The restaurant should look something like this:
        """
        Table 1   Table 2
        --------  -------
        | D Ho |  | E   |
        |      |  |     |
        |      |  |     |
        |      |  |     |
        --------  -------
        """

        # Check that the restaurant has been updated correctly
        assert_equal(restaurant.get_number_tables(), 2, "Restaurant number of tables is incorrect")
        assert_equal(restaurant.get_number_diners(), 3, "Restaurant number of diners is incorrect")
        assert_equal(restaurant.get_number_hobbits(), 1, "Restaurant number of hobbits is incorrect")
        assert_equal(restaurant.get_number_elves(), 1, "Restaurant number of elves is incorrect")
        assert_equal(restaurant.get_number_dwarves(), 1, "Restaurant number of dwarves is incorrect")
        assert_equal(restaurant.get_number_humans(), 0, "Restaurant number of humans is incorrect")
        assert_equal(
            restaurant.get_least_crowded_table().get_distance(),
            2,
            "Restaurant least crowded table distance is incorrect",
        )
        assert_equal(
            restaurant.get_least_crowded_table().get_elves(),
            1,
            "Restaurant least crowded table elves count is incorrect",
        )

        # Let's add some more diners to the restaurant
        restaurant.add_human()
        restaurant.add_hobbit()
        restaurant.add_elf()
        restaurant.add_dwarf()

        # The restaurant should look something like this:
        """
        Table 1   Table 2   Table 3
        --------  -------  -------
        | D Ho |  | E Ho|  | E   |
        | Hu D |  |     |  |     |
        |      |  |     |  |     |
        |      |  |     |  |     |
        --------  -------  -------
        """

        # Check that the restaurant has been updated correctly
        assert_equal(restaurant.get_number_tables(), 3, "Restaurant number of tables is incorrect")
        assert_equal(restaurant.get_number_diners(), 7, "Restaurant number of diners is incorrect")
        assert_equal(restaurant.get_number_hobbits(), 2, "Restaurant number of hobbits is incorrect")
        assert_equal(restaurant.get_number_elves(), 2, "Restaurant number of elves is incorrect")
        assert_equal(restaurant.get_number_dwarves(), 2, "Restaurant number of dwarves is incorrect")
        assert_equal(restaurant.get_number_humans(), 1, "Restaurant number of humans is incorrect")
        assert_equal(
            restaurant.get_least_crowded_table().get_distance(),
            3,
            "Restaurant least crowded table distance is incorrect",
        )
        assert_equal(
            restaurant.get_least_crowded_table().get_elves(),
            1,
            "Restaurant least crowded table elves count is incorrect",
        )

需要具体完善代码私我～