def render(templates: str, values: Dict[str, str]) -> str:
    ...

from typing import Dict, List, Tuple


def _search(string: str) -> Tuple[str, Tuple[int, int]]:
    """单次搜索模板串

    Args:
        string:     目标字符串

    Return:         模板串, 以及在原始字符串中的起止坐标
                    当字符串里不存在插值模板时返回空值.
                    例 ->           ('', (None, None))
    """
    i = 0
    s_list = list(string)
    s_len = len(s_list)
    _stack = []
    _temp = []
    _start = None
    _end = None

    while i < s_len:
        # 仅查找第一个模板串
        if _start is not None and _end is not None:
            break

        # 当栈里面的 { 符号数量大于等于 2 时,
        # 表示当前指针已经指向"变量"字符串, 所以
        # 需要开始记录
        if len(_stack) >= 2:
            _temp.append(s_list[i])

        # 检测连续两个字符是否为 -> {{
        if s_list[i] == "{":
            try:
                _next = s_list[i + 1]
            except IndexError:
                raise SyntaxError("格式不正确, 缺少 {")
            if _next == "{":
                _stack.append(s_list[i])
                _stack.append(s_list[i + 1])
                _temp.append(s_list[i])
                _temp.append(s_list[i + 1])
                _start = i
                i += 2
                continue
            else:
                # 不连续时仅添加
                _stack.append(s_list[i])

        # 消括号
        if s_list[i] == "}":
            # 消括号时, 如果辅助栈里剩余 2 个括号, 则
            # 表示当前指向的字符与下一个字符一定是 -> }
            # 即应当是一个连续的 }}, 否则格式不正确
            if len(_stack) == 2:
                try:
                    _next = s_list[i + 1]
                except IndexError:
                    raise SyntaxError("格式不正确, 缺少 }")
                # 栈里只剩下两个元素时, 一定要出现两个连续的
                # }} 否则格式不正确
                if _next != "}":
                    raise SyntaxError("格式不正确, 缺少 }")
                # 清空栈并记录结束坐标
                _stack.clear()
                i += 2
                _temp.append(_next)
                _end = i
                continue

            # 如果栈里存在元素就弹一个出来
            if _stack:
                _stack.pop()

        # 指针 + 1
        i += 1

    # 辅助栈不为空则说明格式不正确
    if _stack:
        raise SyntaxError("格式不正确, 缺少 }")

    return ("".join(_temp), (_start, _end))

def _var_name(temp_string: str) -> str:
    try:
        var = temp_string[2:-2]
    except IndexError:
        raise SyntaxError("格式不正确")
    return var.strip()

def _replace(string: str, k1: str, k2: str) -> str:
    """
    Args:

        string:     原始字符串
        k1:         被替换的子串
        k2:         替换后的子串

    """
    s_list = list(string)
    s_len = len(s_list)

    k1, k2 = str(k1), str(k2)
    k1_list, k2_list = list(k1), list(k2)
    k1_len, k2_len = len(k1_list), len(k2_list)

    res = list()

    i = 0
    _temp = 0
    while i < s_len:
        # i 指针指向的位置匹配到了 k1 的首元素
        # 从该位置向后匹配, 检测是否完全匹配
        if s_list[i] == k1_list[0]:
            for j in range(k1_len):
                if k1_list[j] == s_list[i + j]:
                    _temp += 1
                else:
                    break

        if _temp == k1_len:
            res.extend(k2_list)
            i += (k1_len - 1)
        else:
            res.append(s_list[i])

        i += 1
        _temp = 0

    return "".join(res)

def render(string: str, values: Dict[str, Tuple[str, int]]) -> str:
    """渲染模板字符串

    逻辑概要

        string = "my {{  name     }} is, {{ age }} !!"
        
        查找到第一个模板串 "{{  name     }}", 然后提取左串

            l_string = "my {{  name     }}"

        将左串替换后的结果增加到 s_list, 然后更新 _temp 为右串

            _temp = " is, {{ age }} !!"
        
        直至搜索不到模板串, 替换完毕.
    """
    s_list = list()
    _temp = string
    while True:
        # 查找模板串里的模板
        t_string, (i_start, i_end) = _search(_temp)
        if i_start is None or i_end is None:
            break

        # 取模板字符的具体值
        name = _var_name(t_string)
        if name not in values:
            raise ValueError(f"缺少关键字 {name}")
        value = str(values[name])

        # 截取左串(第一个搜索到的模板串), 将替换后的结果
        # 添加到 s_list, 然后更新 _temp 变量为右串(原始字符串剩余部分)
        l_string = _replace(_temp[: i_end], t_string, value)
        s_list.append(l_string)
        _temp = _temp[i_end:]

    s_list.append(_temp)
    return "".join(s_list)

strings = [
    "{{  name     }} is, {{ age }}",
    "my {{  name     }} is, {{ age }}",
    "{{  name     }} is, {{ age }} !!",
    "my {{  name     }} is, {{ age }} !!",
]
for string in strings:
    print(f'|{render(string, {"name": "nao", "age": 16})}|')

|nao is, 16|
|my nao is, 16|
|nao is, 16 !!|
|my nao is, 16 !!|

idx = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
tmp = "2 38 39 36 4 14 11 8 5 12 1 3 37 7 1 0 5 14 8 0".split(" ")
pwd = "".join([idx[int(index)] for index in tmp])
print(pwd)

def is_prime(x: int) -> bool:
    """check if is prime
    referencen link https://zhuanlan.zhihu.com/p/107300262"""
    if x == 2 or x == 3:
        return True
    if x % 6 != 1 and x % 6 != 5:
        return False
    for i in range(5, int(x ** 0.5) + 1, 6):
        if x % i == 0 or x % (i + 2) == 0:
            return False
    return True

def is_prime(x: int) -> bool:
    """check if is prime
    referencen link https://zhuanlan.zhihu.com/p/107300262"""
    if x == 2 or x == 3:
        return True
    if x % 6 != 1 and x % 6 != 5:
        return False
    for i in range(5, int(x ** 0.5) + 1, 6):
        if x % i == 0 or x % (i + 2) == 0:
            return False
    return True

def decrypt(arr: list) -> str:
    # 移除非素数
    arr = list(filter(lambda x: is_prime(x), arr))
    # 将数组中的每个数字按位右移8, 按 ascii 码表取对应的字符
    # 最后将字符数组拼接成字符串, 即可得到密码
    dec = "".join(list(map(lambda x: chr(x >> 8), arr)))
    return dec

def r(pwd, fr, to, by):
    return ''.join([pwd[i] for i in range(fr, to, by)])

>>> print(r(pwd, 0, 4, 1))
edac
>>> print(r(pwd, 4, 20, 2))
e76716c1
>>> print(r(pwd, 5, 30, 3))
1646561d3
>>> print(r(pwd, 5, 40, 4))
12b52d3fd
>>> print(r(pwd, 6, 40, 6))
711283
>>> print(r(pwd, 7, 8, 1))
e
>>> print(r(pwd, 10, 40, 3))
7bc5adfced
>>> print(r(pwd, 10, 40, 5))
7a6d85
>>> print(r(pwd, 15, 40, 6))
a2ffd
>>> print(r(pwd, 20, 40, 3))
61d3b5c

# 创建一个 40 长度的数组
_pwd = [ "" for _ in range(40) ]

# 
def decrypt(text, fr, to ,by):
    """text 就是执行 r 函数的输出结果"""
    for i, j in enumerate(range(fr, to, by)):
        _pwd[j] = text[i]

class Singleton(type):


    def __init__(cls, *args, **kwargs):
        """"""
        cls.__instance = None
        super().__init__(*args, **kwargs)


    def __call__(cls, *args, **kwargs):
        """"""
        if cls.__instance is None:
            cls.__instance = super().__call__(*args, **kwargs)
            return cls.__instance
        else:
            return cls.__instance


class Spam(metaclass=Singleton):

    ...

s1 = Spam()
s2 = Spam()
print(id(s1))
print(id(s2))

class Singleton(object):

    __instance = None

    def __init__(self):
        ...

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


class Spam(Singleton):

    ...

s1 = Spam()
s2 = Spam()
print(id(s1))
print(id(s2))

def singleton(cls):
    """使用闭包的方式实现一个单例装饰器"""

    __instance = {}

    def _create(*args, **kwargs):
        if cls not in __instance:
            __instance[cls] = cls(*args, **kwargs)
        return __instance[cls]
    
    return _create


@singleton
class Spam(object):
    ...


s1 = Spam()
s2 = Spam()
print(id(s1))
print(id(s2))

class Singleton(object):

    def __init__(self, cls):
        self.__cls = cls
        self.__instance = {}

    
    def __call__(self, *args, **kwargs):
        if self.__cls not in self.__instance:
            self.__instance[self.__cls] = self.__cls(*args, **kwargs)
        return self.__instance[self.__cls]


@Singleton
class Spam(object):
    ...


s1 = Spam()
s2 = Spam()
print(id(s1))
print(id(s2))

class Solution:
    def isValid(self, s: str) -> bool:
        # 字符串匹配成功的话其长度一定是偶数, 否则一定不成功
        # 这里可以先检查长度, 可以省略之后的步骤
        if len(s) % 2 != 0:
            return False

        # 辅助栈
        _stack = []
        # 对照表
        _map = {
            ")": "(",
            "]": "[",
            "}": "{"
        }
        for _char in list(s):
            if _char in "([{":
                _stack.append(_char)
            else:
                # 当遇到右括号时, 从栈顶弹出元素检测是否
                # 成对, 即是否闭合, 不成对则返回 False
                if _stack:
                    if _char in _map:
                        _top = _stack.pop()
                        if _map[_char] != _top:
                            return False
                else:
                    # 右括号溢出
                    return False
        # 这里要判断栈里是否还有元素
        # 有元素则说明该字符串匹配不成功
        return len(_stack) == 0