Mississippi

[BlackJack]

@Nocta: Ist auch nicht elegant, aber auch rekursiv:

Code: Alles auswählen

def group(xs, zs=''):
    if not xs:
        return ([zs] if zs else [])
    elif zs.startswith(xs[0]):
        return group(xs[1:], zs + xs[0])
    else:
        return ([zs] if zs else []) + group(xs[1:], xs[0])

[ms4py]

Fehlt nicht noch was rekursives?

Da war doch schon die Prolog-Lösung

[pillmuncher]

Vielleicht so? Also ohne Akkumulator?

Code: Alles auswählen

def group(cs, i=0, j=1):
    if j >= len(cs):
        return [cs[i:j]] if cs else []
    elif cs[i] == cs[j]:
        return group(cs, i, j+1)
    else:
        return [cs[i:j]] + group(cs, j, j+1)

Ich habe auch versucht das lazy zu machen, aber das Ergebnis ist zu schrecklich um es zu zeigen. Dann lieber nochmal iterativ:

Code: Alles auswählen

def group(cs):
    if cs:
        i = 0
        for j in xrange(1, len(cs)):
            if cs[i] != cs[j]:
                yield cs[i:j]
                i = j
        yield cs[i:]

Ich glaube, jetzt genügt's dann.

Gruß,
Mick.

[pillmuncher]

Oder doch nicht... Hier noch zwei Versionen mit anonymer rekursiver Funktion:

Code: Alles auswählen

def Y(r): return (lambda f: f(f))(lambda f: r(lambda *xs, **ys: f(f)(*xs, **ys)))

group1 = Y(
    lambda g:
        lambda cs, i=0, j=1:
                ([cs[i:j]] if cs else [])
            if j >= len(cs) else
                (g(cs, i, j+1) if cs[i] == cs[j] else [cs[i:j]] + g(cs, j, j+1))
)

def group2(cs):
    if not cs:
        return []
    return Y(
        lambda g:
            lambda s, c, *cs:
                    (g(s + c, *cs) if c in s else [s][:bool(s)] + g(c, *cs))
                if cs else 
                    ([s + c] if c in s else [s][:bool(s)] + [c])
    )('', *cs)

Ja, ich weiß, wenn man das gesehen hat möchte man sich am liebsten die Augen mit Seife auswaschen.

Danke im Übrigen an sma, der den Y-Kombinator in Python gebaut hat. Ich habe ihn ein wenig angepasst, damit man ihn mit den üblichen *args, **kwargs verwenden kann.

Gruß,
Mick.

[gerold]

Hallo Mik!

Dir ist es vielleicht nicht bewusst, dass ich Python gerne mag weil man sich bei Python "einfach und durchschaubar" auf die Fahne geschrieben hat. Das was du da mit Python anstellst, ist irgendwie die falsche Richtung. Ein "gutes" Python-Programm ist lesbar. Je lesbarer, desto besser. -- Es kann ruhig etwas länger sein und mit Kommentaren versehen werden. Hauptsache verständlich und leicht nachvollziehbar.

mfg
Gerold

[pillmuncher]

Das was du da mit Python anstellst, ist irgendwie die falsche Richtung.

Stimmt. Deswegen würde ich so etwas niemals im Ernst programmieren.

Gruß,
Mick.

[BlackJack]

Und etwas in C: http://paste.pocoo.org/show/150077/