<<突然想开一个搞笑专题， 嘿嘿>>
弱智创意吧 ---- 记录一下有点意思但是毫无用处的小idea， 用于熟悉代码设计和开发~

今日题目 - 猜数游戏

规则

指定人数members（2 - 10）进行猜数游戏，游戏开始时系统给定一个随机整数item（0 - 10000），
提示猜数范围guess_range（第一次为0 - 10000），
之后第一个人开始输入一个数值guess_number进行猜数(输入”EOF“为退出游戏，其余人继续猜数)。
如果猜中，游戏结束，否则根据输入的guess_number生成新的参数范围，
即当前猜数范围到该guess_number的最小范围，即min(range_max - guess_number, guess_number - range_min)。
同时由此人输入下一个要猜测的目标数new_item。需要在新的参数范围内，可在边界上。然后由第二个人猜测，
依照此类规则，直到游戏结束。
游戏结束的条件：
  1. 当只剩1个人时，游戏结束
  2. 当目标数被猜到

输入：

1. 参与游戏的人数members
2. 用户输入的猜数数值guess_number
3. 用户输入的新目标值new_item

输出：

1. 每次用户输入前打印猜数范围guess_range
2. 用户退出时要打印退出的用户，并且下一轮不在进行猜数
3. 最后打印所有的目标数，需要具体到是第几个人、第几轮输入的。

注意事项：

1. 需要能识别异常输入
2. 需要考虑数据存储
3. 暂不考虑有很多轮的情况。默认都小于10轮。

python 代码示例

# coding: utf-8
import random
import re
import sys

"""
规则

指定人数members（2 - 10）进行猜数游戏，游戏开始时系统给定一个随机整数item（0 - 10000），
提示猜数范围guess_range（第一次为0 - 10000），
之后第一个人开始输入一个数值guess_number进行猜数(输入”EOF“为退出游戏，其余人继续猜数)。
如果猜中，游戏结束，否则根据输入的guess_number生成新的参数范围，
即当前猜数范围到该guess_number的最小范围，即min(range_max - guess_number, guess_number - range_min)。
同时由此人输入下一个要猜测的目标数new_item。需要在新的参数范围内，可在边界上。然后由第二个人猜测，
依照此类规则，直到游戏结束。
游戏结束的条件：
  1. 当只剩1个人时，游戏结束
  2. 当目标数被猜到
输入：

1. 参与游戏的人数members
2. 用户输入的猜数数值guess_number
3. 用户输入的新目标值new_item
输出：

1. 每次用户输入前打印猜数范围guess_range
2. 用户退出时要打印退出的用户，并且下一轮不在进行猜数
3. 最后打印所有的目标数，需要具体到是第几个人、第几轮输入的。
"""

"""
思路： 建立一个目标数值类，用户类
使用List来存储轮数 
"""

GUESS_RANGE_DEFAULT = [0, 10000]
number_re_compile = re.compile(r"^\d+$")
ITEM_MATCH = 0
INVALID = -1
ITEM_NOT_MATCH = 1
EXIT = 2


class Item(object):

    instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.instance:
            cls.instance = super().__new__(cls)
        return cls.instance

    def __init__(self, item=None, guess_range=None):
        self.item = item
        self.guess_range = guess_range

    def get_item(self):
        if not self.item:
            self.item = random.randint(*GUESS_RANGE_DEFAULT)
        return self.item

    def update_item(self, new_item):
        """
        如果新目标超过了当前范围，则不做更改，否则更新
        :param new_item:
        :return:
        """
        if self.guess_range[0] <= new_item <= self.guess_range[1]:
            self.item = new_item
            return True
        return False

    def get_range(self):
        if not self.guess_range:
            self.guess_range = GUESS_RANGE_DEFAULT
        return self.guess_range

    def update_guess_range(self, guess_number):
        """
        根据输入的新目标数来生成新的range
        :param guess_number: 新的目标数
        :return: None
        """
        guess_range = self.get_range()
        if self.get_item() < guess_number:
            self.guess_range = [guess_range[0], guess_number]
        else:
            self.guess_range = [guess_number, guess_range[1]]


class User(object):

    def __init__(self, index=1):
        self.index = index
        self.active = True
        self.user_items = []
        self.item = Item()

    def is_active(self):
        return self.active

    def get_user_name(self):
        return "第%s号玩家" % self.index

    def check_item(self, guess_member):
        guess_item = int(guess_member)
        if self.item.get_item() != guess_item:
            return False
        return True

    def input_guess_member(self, guess_member):
        if guess_member == "EOF":
            self.active = False
            return EXIT
        if not number_re_compile.match(guess_member):
            return INVALID

        # 如果猜测的值在这次给定的范围外，报错
        guess_member = int(guess_member)
        guess_range = self.item.get_range()
        if guess_member < guess_range[0] or guess_member > guess_range[1]:
            return INVALID

        # 校验通过后，存储当前的目标值和这次猜的数值
        self.user_items.append([self.item.get_item(), guess_member, "", ""])
        # 更新item的range
        self.item.update_guess_range(guess_member)
        return ITEM_MATCH if self.check_item(guess_member) else ITEM_NOT_MATCH

    def input_guess_item(self, new_item):
        if not number_re_compile.match(new_item):
            return INVALID
        self.user_items[-1][-2] = new_item
        self.user_items[-1][-1] = self.item.update_item(int(new_item))

    def print_result(self, round_number):
        if len(self.user_items) < round_number:
            print("SKIP: %s在%s轮未参加了游戏" % (self.get_user_name(), round_number))
        else:
            this_round_result = self.user_items[round_number - 1]
            print("JOIN: %s在%s轮参加了游戏，并且当时的目标值是%s, 同时他的猜测值是%s, 他给下一人指定的目标数是%s(是否有效：%s)" % (
                self.get_user_name(), round_number, this_round_result[0], this_round_result[1],
                this_round_result[2], this_round_result[3]
            ))


class GameProcess(object):

    def __init__(self):
        self.join_users = None
        self.total_round_number = 1
        self.users = []

    @staticmethod
    def print_help():
        print("游戏规则：")
        print("  0. 所有输入都是整数或者EOF")
        print("  1. 请输入参与人数，人数为2 - 10")
        print("  2. 轮到某个用户时，用户需要先猜一个数或者输入EOF退出")
        print("     如果没有猜中，则该用户需要输入一个新的目标数")
        print('\n')

    def init_join_users(self):
        members = input("请输入参与人数：")
        if not number_re_compile.match(members):
            print("输入非法，退出，请重启游戏")
            sys.exit(1)

        self.join_users = int(members)
        if self.join_users < 2 or self.join_users > 10:
            print("输入非法，参与人数需要为2-10人，请重启游戏")
            sys.exit(1)

    def init_game(self):
        # 初始化用户
        print('\n')
        print("------- 加载游戏 -------")
        for i in range(self.join_users):
            user = User(index=i+1)
            print("[INIT] %s加入游戏" % user.get_user_name())
            self.users.append(user)
        print("----------------------")

    @staticmethod
    def simple_user_guess(user):
        # 连续非法输入3次后默认捣乱退出
        invalid_number = 0
        has_guess_member = False
        while True:
            if invalid_number >= 3:
                user.input_guess_member("EOF")
                break
            if not has_guess_member:
                guess_result = user.input_guess_member(input(">>>>>>>>>>>>>>>> 请猜测目标值: "))

                # 当用户退出的时候，直接返回
                if guess_result == EXIT:
                    return False

                if guess_result == INVALID:
                    invalid_number += 1
                    print(">>>>>>>>>>>>>>>> 输入非法，请重新输入，如果到达3次，将会退出")
                    continue
                invalid_number = 0
                has_guess_member = True
                if guess_result == ITEM_MATCH:
                    return True

            if user.input_guess_item(input(">>>>>>>>>>>>>>>> 请输入新的目标值： ")) == INVALID:
                invalid_number += 1
                continue
            return False

    def process_game(self):
        # 使用while循环进行游戏， 只有游戏结束后才能退出
        has_game_over = False
        print('\n')
        while True:
            # 每一轮先检查是否需要结束游戏
            if has_game_over:
                break
            print(">>>>>>>> 开始第%s轮猜数游戏" % self.total_round_number)
            for user in [user for user in self.users if user.is_active()]:
                print('\n')
                print(">>>>>>>>>>>> %s开始猜数" % user.get_user_name())
                print(">>>>>>>>>>>> 当前范围: %s" % user.item.get_range())
                if self.simple_user_guess(user):
                    print(">>>>>>>>>>>> SUCCESS: %s猜中了" % user.get_user_name())
                    has_game_over = True
                    break
                # 检查是否只剩下一个人了，如果是，则剩下的人胜利
                if len([user for user in self.users if user.is_active()]) == 1:
                    print(">>>>>>>>>>>> SUCCESS: 由于参与人数只剩一个，游戏结束，胜利用户: %s，游戏结束" %
                          self.users[-1].get_user_name())
                    has_game_over = True
                    break

            self.total_round_number += 1

    def print_result(self):
        print('\n' * 3)
        print("=========结果解析=============")
        print("开始打印猜数过程")
        for round_number in range(1, self.total_round_number):
            for user in self.users:
                user.print_result(round_number)
        print("======================")

    def launch(self):
        self.print_help()
        self.init_join_users()
        self.init_game()
        self.process_game()
        self.print_result()


if __name__ == "__main__":
    GameProcess().launch()

每日趣图

微信图片_20230827143021.jpg