leetcode 394 parser

leetcode-394-recursive-descent.py

# problem in - https://leetcode.com/problems/decode-string/

import string

class Number(object):
    def __init__(self, i):
        self.unparsed = i
    def append(self, obj):
        self.unparsed += self.unparsed
    def value(self):
        return int(self.unparsed)

class Literal(object):
    def __init__(self, c):
        self.literal = c
    def append(self, obj):
        self.literal += obj.literal
    def __repr__(self):
        return ("<Literal '%s'>"  % self.literal)

class Nested(object):
    def __init__(self, children):
        self.children = children
    def append(self, child):
        self.children.append(child)
    def __repr__(self):
        return ("<Nested %s>" % self.children)

class Repeats(Nested):
    def __init__(self,children):
        super().__init__(children)
        self.repeats = 1
    def repeat(self, repeats):
        self.repeats = repeats
    def __repr__(self):
        return ("<Repeates %d X %s>" % (self.repeats, self.children))

def appendadjacent(items, obj):
    if items and type(items[-1]) == type(obj):
        items[-1].append(obj)
    else:
        items.append(obj)


def parseinner(it):
    items = []
    for c in it:
        if c == '[':
            result,closed = parseinner(it)
            if not closed:
                pass # weird
            # get the previous number
            if items and type(items[-1]) is Number:
                repeats = items.pop()
                result.repeat(repeats.value())
            items.append(result)
        elif c == ']':
            return (Repeats(items), True)
        elif c in string.digits:
            appendadjacent(items, Number(c)) 
        else:
            appendadjacent(items, Literal(c)) 
    return (items, False)

def parse(s):
    it = iter(s)
    return parseinner(it)[0]


s = "z1[y]zzz2[abc]"
e = "zyzzzabcabc"

s= "2[abc]3[cd]ef"
e = "abcabccdcdcdef"

print(parse(s))