Das deutsche Python-Forum

Code: Alles auswählen

def derive_terms(term):
    terms = []
    if term[-1]=="I":
        terms.append  (term + "U")
    terms.append (term + term[1:])
    for _ in range(len(term)):
        try:
            position = term.index("III",_)
            derived_term = term[:position] + "U" + term[position+3:]
            if not derived_term in terms:
                terms.append (derived_term)
        except ValueError:
            continue
    for _ in range(len(term)):
        try:
            position = term.index("UU",_)
            derived_term = term[:position] + term[position+2:]
            if not derived_term in terms:
                terms.append (derived_term)
        except ValueError:
            continue   
    return terms

Code: Alles auswählen

def derive_terms(term):
    terms = []
    #rule 1: If term ends with 'I' you may append 'U'
    if term[-1]=="I":
        terms.append(term + "U")
    #rule 2: You may repeat all characters that follow the preceding 'M'
    terms.append(term + term[1:])
    #rule 3: You may replace "III" with "U"
    for _ in range(len(term)):
        try:
            position = term.index("III",_)
            derived_term = term[:position] + "U" + term[position+3:]
            if not derived_term in terms:
                terms.append(derived_term)
        except ValueError:
            continue
    #rule 4: You may delete "UU"
    if term.find("UU")>0:
        position=term.find("UU")
        terms.append(term[:position]+term[position+2:])   
    return terms

Code: Alles auswählen

def derive_terms(term):
    terms = []
    #rule 1: If term ends with 'I' you may append 'U'
    if term.endswith("I"):
        terms.append(term + "U")
    #rule 2: You may repeat all characters that follow the preceding 'M'
    terms.append(term + term[1:])
    #rule 3: You may replace "III" with "U"
    position = 0
    while True:
        position = term.find("III", position)
        if position < 0:
            break
        derived_term = term[:position] + "U" + term[position + 3:]
        if derived_term not in terms:
            terms.append(derived_term)
        position += 1
    #rule 4: You may delete "UU"
    position = term.find("UU")
    if position >= 0:
        terms.append(term[:position] + term[position + 2:])
    return terms

Code: Alles auswählen

CALCULATION_DEPTHS = 3


class Term:

    def __init__(self, term, parents):
        self.term = term
        self.parents = parents
        self.childs = []
        print(self.term, self.parents)
        if len(self.parents) < CALCULATION_DEPTHS:
            self.create_childs()

    def create_childs(self):
        # rule 1: If term ends with 'I' you may append 'U'
        if self.term.endswith("I"):
            self.childs.append(Term(self.term + "U", self.parents + [self.term]))
        # rule 2: You may repeat all characters that follow the preceding 'M'
        self.childs.append(Term(self.term + self.term[1:], self.parents + [self.term]))
        # rule 3: You may replace "III" with "U"
        position = 0
        while True:
            position = self.term.find("III", position)
            if position < 0:
                break
            derived_term = self.term[:position] + "U" + self.term[position + 3:]
            if derived_term not in self.childs:
                self.childs.append(Term(derived_term, self.parents + [self.term]))
            position += 1
        # rule 4: You may delete "UU"
        position = self.term.find("UU")
        if position >= 0:
            self.childs.append(Term(self.term[:position] + self.term[position + 2:], self.parents + [self.term]))


def main():
    Term("MI", [])


if __name__ == '__main__':
    main()

Code: Alles auswählen

"""
REGEL I: Wenn Sie eine Kette besitzen, deren letzter Buchstabe I ist, können Sie am Schluss ein U zufügen.
REGEL II: Angenommen Sie haben Mx Dann können Sie Ihrer Sammlung Mxx zufügen.
REGEL III: Wenn in einer der Ketten Ihrer Sammlung III vorkommt, können Sie eine neue Kette mit U anstelle von III bilden.
REGEL IV: Wenn UU in einer Ihrer Ketten vorkommt, kann man es streichen.
"""
import re


def build_chain(chain, depth_level):

    if depth_level > 4:
        return

    # apply rule 1
    if chain.endswith("I"):
        build_chain(chain + "U", depth_level + 1)

    # apply rule 2
    build_chain(chain + chain[1:], depth_level + 1)

    # apply rule 3
    iii_start_positions = [start_pos.start() for start_pos in re.finditer("(?=III)", chain)]

    for iii_start_position in iii_start_positions:
        build_chain(chain[:iii_start_position] + "U" + chain[iii_start_position + 3 :], depth_level + 1)

    # apply rule 4
    uu_start_positions = [start_pos.start() for start_pos in re.finditer("(?=UU)", chain)]
    for uu_start_position in uu_start_positions:
        build_chain(chain[:uu_start_position] + chain[uu_start_position + 2 :], depth_level + 1)

    print("-" * depth_level + chain)


build_chain("MI", 0)

Code: Alles auswählen

"""
REGEL I: Wenn Sie eine Kette besitzen, deren letzter Buchstabe I ist, können Sie am Schluss ein U zufügen.
REGEL II: Angenommen Sie haben Mx Dann können Sie Ihrer Sammlung Mxx zufügen.
REGEL III: Wenn in einer der Ketten Ihrer Sammlung III vorkommt, können Sie eine neue Kette mit U anstelle von III bilden.
REGEL IV: Wenn UU in einer Ihrer Ketten vorkommt, kann man es streichen.
"""
import re
from anytree import Node, RenderTree


class ChainBuilder:
    def __call__(self, max_depth_level):
        self.max_depth_level = max_depth_level
        node = Node("MI")
        self.build_tree(node, 1)
        return node

    def build_tree(self, node, depth):
        if depth > self.max_depth_level:
            return

        self.find_children(node)
        for child in node.children:
            self.build_tree(child, depth + 1)

    def find_children(self, node):
        # apply rule 1
        if node.name.endswith("I"):
            Node(node.name + "U", parent=node)

        # apply rule 2
        Node(node.name + node.name[1:], parent=node)

        # apply rule 3
        iii_start_positions = [start_pos.start() for start_pos in re.finditer("(?=III)", node.name)]

        for iii_start_position in iii_start_positions:
            Node(node.name[:iii_start_position] + "U" + node.name[iii_start_position + 3 :], parent=node)

        # apply rule 4
        uu_start_positions = [start_pos.start() for start_pos in re.finditer("(?=UU)", node.name)]
        for uu_start_position in uu_start_positions:
            Node(node.name[:uu_start_position] + node.name[uu_start_position + 2 :], parent=node)


chain_builder = ChainBuilder()


for pre, _, node in RenderTree(chain_builder(4)):
    print(f"{pre}{node.name}")

Code: Alles auswählen

MI
├── MIU
│   └── MIUIU
│       └── MIUIUIUIU
│           └── MIUIUIUIUIUIUIUIU
└── MII
    ├── MIIU
    │   └── MIIUIIU
    │       └── MIIUIIUIIUIIU
    └── MIIII
        ├── MIIIIU
        │   ├── MIIIIUIIIIU
        │   ├── MUIU
        │   └── MIUU
        ├── MIIIIIIII
        │   ├── MIIIIIIIIU
        │   ├── MIIIIIIIIIIIIIIII
        │   ├── MUIIIII
        │   ├── MIUIIII
        │   ├── MIIUIII
        │   ├── MIIIUII
        │   ├── MIIIIUI
        │   └── MIIIIIU
        ├── MUI
        │   ├── MUIU
        │   └── MUIUI
        └── MIU
            └── MIUIU

Code: Alles auswählen

def build_tree(max_depth_level):
    node = Node("MI")
    build_sub_tree(node, max_depth_level)
    return node

def build_sub_tree(node, depth):
    if depth <= 0:
        return

    find_children(node)
    for child in node.children:
        build_sub_tree(child, depth - 1)

def find_children(node):
    # apply rule 1
    replace_all(node, "I$", "IU")

    # apply rule 2
    Node(node.name + node.name[1:], parent=node)

    # apply rule 3
    replace_all(node, "III", "U")

    # apply rule 4
    replace_all(node, "UU", "")

def replace_all(node, old, new):
    start_positions = (match.start() for match in re.finditer(f"(?={old})", node.name))
    for start_position in start_positions:
        Node(node.name[:start_position] + new + node.name[start_position + len(old) :], parent=node)