Herausforderung Problem 5 mit Python: Lambda ... Gehen Sie nicht tief in den Einzeiler hinein ... Nicht

Problem 5 herausfordern, das ein Softwareentwickler in 1 Stunde lösen sollte In dem Kommentar gab mir podhmo einen Einzeiler. Vielen Dank. (Siehe Originalartikel für das tatsächliche Produkt.)

Ich konnte die Bedeutung überhaupt nicht verstehen, selbst wenn ich sie mir ansah, also versuchte ich, sie aufzubrechen und in eine Form zu bringen, die ich verstehen konnte.

Ein völlig unklarer Fluss von Anfang an

(lambda f: (lambda x: x(x))(lambda y: f(lambda v: y(y)(v))))

Ich kann das runde und runde Gefühl fühlen, aber ... es ist ein Rätsel. Wenn Sie versuchen, Google so wie es ist, scheint es ein Y-Kombinator zu sein. Es scheint, dass Sie als anonyme Funktion wiederkehren können. Es tut uns leid. Ich werde dich jetzt durchlassen. Weil meine Augen sich umdrehten.

Ich gab ihm einen Namen, damit ich ihn verstehen konnte

Ist es so

• Der Kernteil ist Kopie.
• Wie kann ich einen Y-Kombinator bekommen? Denk an.
• Üben Sie, die Karte zu ändern, um die Einschlussnotation aufzulisten.

c=(lambda xs:
	[ [xs[0]] ] if len(xs) <= 1 else
    __import__("itertools").chain(
        [ [xs[0], ""] + y for y in c(xs[1:]) ],
        [ [xs[0], " + "] + y for y in c(xs[1:]) ],
        [ [xs[0], " - "] + y for y in c(xs[1:]) ]
    )
)

print( "\n".join(
            [   x for x in
                [   "".join(str(y) for y in z )
                        for z in c(range(1, 10 ) )
                ]
                if eval(x) == 100
            ]
       )
)

• In Funktion c, die einen Iterator einer Liste aller Zeichenkombinationen zurückgibt
• Bereich anwenden (1,10)
• Von den kombinierten Saiten
• Diejenigen, die bei der Bewertung 100 sein werden
• drucken

Bedeutet das? Ich fragte mich, ob ich das zuerst tun würde, aber ich wusste nicht, was ich tun sollte. Ich habe viel gelernt.

Apropos...

Sie können eine rekursive Funktion in ~~ def einfügen, aber Sie können sie nicht in Lambda ~~ einfügen

Es scheint ~~. ~~ Es ist geschafft. Siehe unten.

Die folgende Definition von c in q_5_1 mit def hat gut funktioniert.

def q_5_1():
    def c(xs):
        return ([[xs[0]]] if len(xs) <= 1 else
                                  __import__("itertools").chain(
                                      [[xs[0], ""] + y for y in c(xs[1:])],
                                      [[xs[0], " + "] + y for y in c(xs[1:])],
                                      [[xs[0], " - "] + y for y in c(xs[1:])]
                                )
                )
    print("\n".join(
            [   x for x in
                [   "".join(str(y) for y in z )
                        for z in c(range(1, 10 ) )
                ]
                if eval(x) == 100
            ]
        )
    )

q_5_1()

Als ich versuchte, dasselbe mit Lambda zu tun, funktionierte es nicht.

def pr(x):
    print x
    
q_5_2=(lambda:
    (lambda c=(lambda xs:
            [[xs[0]]] if len(xs) <= 1 else
            __import__("itertools").chain(
                [[xs[0], ""] + y for y in c(xs[1:])],
                [[xs[0], " + "] + y for y in c(xs[1:])],
                [[xs[0], " - "] + y for y in c(xs[1:])]
            )
        ):
            pr( "\n".join(
                    [   x for x in
                        [   "".join(str(y) for y in z )
                                for z in c(range(1, 10 ) )
                        ]
                        if eval(x) == 100
                    ]
                )
            )
    )()
)

q_5_2()

Ich war wütend auf "NameError: globaler Name 'c' ist nicht definiert". Bedeutet das, dass Sie sich nicht in Lambda nennen können, weil sich die Argumente auf die äußere Umgebung beziehen ... Gibt es einen Y-Kombinator oder etwas in diesem Bereich?

Es ist jedoch eine großartige Lehre Gottes, komplizierte Dinge in einfache Funktionen zu unterteilen. Daher ist dies vorerst möglicherweise kein Problem.

• Es war erledigt.

# coding: utf-8

do = box = lambda *x : x
switch = unbox = lambda x : x[-1]
otherwise = True

q_5_2=( lambda :
        ( lambda c = ( lambda xs :
          ( lambda f : f( f, xs ) )(lambda f, xs :
              switch(
                   len(xs) <= 1 and do( [[xs[0]]] ) 
                or otherwise    and do( __import__("itertools").chain(
                                       [[xs[0], ""] + y for y in f( f, xs[1:])],
                                       [[xs[0], " + "] + y for y in f( f, xs[1:])],
                                       [[xs[0], " - "] + y for y in f( f, xs[1:])]
                                       )
                                      )
             )
            )
          ):
            print( "\n".join(
                [ x for x in
                  [ "".join(str(y) for y in z )
                    for z in c(range(1, 10 ) )
                  ]
                  if eval(x) == 100
                ]
               )
            )
         )()
    )

q_5_2()

Genauer gesagt:

python

# coding: utf-8

do = box = lambda *x : x
switch = unbox = lambda x : x[-1]
otherwise = True

q_5_2 = lambda : (
    lambda c = lambda xs , f = lambda f, xs :
                            switch(
                                len(xs) <= 1 and do( [[xs[0]]] ) 
                                or otherwise and do( __import__("itertools").chain(
                                        [[xs[0], ""] + y for y in f( f, xs[1:])],
                                        [[xs[0], " + "] + y for y in f( f, xs[1:])],
                                        [[xs[0], " - "] + y for y in f( f, xs[1:])]
                                    )
                                )
                            )
            
            : f( f, xs ) 
        :
        print( "\n".join(
                [ x for x in
                    [ "".join(str(y) for y in z )
                        for z in c(range(1, 10 ) )
                    ]
                        if eval(x) == 100
                ]
            )
        )
    )()
    

q_5_2()