Herausforderung:

Geben Sie bei einer Liste nicht leerer Listen von Ganzzahlen eine Liste von Tupeln der folgenden Form zurück: Tupel der ersten Liste beginnen mit jedem Element der ersten Liste, gefolgt vom ersten Element jeder nachfolgenden Liste, daher sollte das i-te Tupel sein [ith element of first list, first element of second list, ... , first element of last list]. Beispielsweise:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [[1, 4, 7], [2, 4, 7], [3, 4, 7], ...

Dann machen Sie Tupel der Form [last element of first list, ith element of second list, first element of third list, ..., first element of last list], also wäre dies in unserem Beispiel:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] =>  ..., [3, 4, 7], [3, 5, 7], [3, 6, 7], ...

Fahren Sie mit jeder verbleibenden Liste fort, bis Sie zu [last element of first list, ..., last element of second to last list, ith element of last list]:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => ..., [3, 6, 7], [3, 6, 8], [3, 6, 9]]

Die volle Ausgabe ist wie folgt:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => 
        [[1, 4, 7], [2, 4, 7], [3, 4, 7], [3, 5, 7], [3, 6, 7], [3, 6, 8], [3, 6, 9]]

Einige Boilerplate für ein gutes Maß:

• Wenn Sie möchten, dass die Eingabe Listen mit Zeichenfolgen oder Listen mit positiven Ganzzahlen enthält, ist dies in Ordnung. Die Frage betrifft das Manipulieren von Listen, nicht das, was in den Listen enthalten ist.
• Eingabe und Ausgabe können in jedem akzeptablen Format erfolgen .
• Es ist entweder ein vollständiges Programm oder eine vollständige Funktion zulässig.
• Standardlücken sind standardmäßig nicht zulässig.
• Diese Frage ist Code Golf, also gewinnt die niedrigste Bytezahl.

Beispiele:

[] => [[]] (or an error, thanks to ngn for correcting the output in this case)

[[1]] => [[1]]

[[1, 2], [3, 4], [5]] => [[1, 3, 5], [2, 3, 5], [2, 4, 5]]

[[1], [2], [5, 6], [3], [4]] => [[1, 2, 5, 3, 4], [1, 2, 6, 3, 4]]

[[1, 2, 3], [4, 5]] => [[1, 4], [2, 4], [3, 4], [3, 5]]

[[1, 2, 3], []] => unspecified behavior (can be an error)

[[3, 13, 6], [9, 2, 4], [5, 10, 8], [12, 1, 11], [7, 14]] => 
     [[3, 9, 5, 12, 7], [13, 9, 5, 12, 7], [6, 9, 5, 12, 7], [6, 2, 5, 12, 7], 
      [6, 4, 5, 12, 7], [6, 4, 10, 12, 7], [6, 4, 8, 12, 7], [6, 4, 8, 1, 7], 
      [6, 4, 8, 11, 7], [6, 4, 8, 11, 14]]  

[[16, 8, 4, 14, 6, 7, 10, 15], [11, 1, 12, 2, 19, 18, 9, 3], [13, 5, 17]] =>
    [[16, 11, 13], [8, 11, 13], [4, 11, 13], [14, 11, 13], [6, 11, 13], 
     [7, 11, 13], [10, 11, 13], [15, 11, 13], [15, 1, 13], [15, 12, 13], [15, 2, 13], 
     [15, 19, 13], [15, 18, 13], [15, 9, 13], [15, 3, 13], [15, 3, 5], [15, 3, 17]]

Wenn jemand einen besseren Titel hat, lass es mich wissen.

JavaScript (ES6), 59 Byte

Erwartet eine Liste mit Listen positiver Ganzzahlen.

f=a=>[a.map(a=>a[0]),...a.some(a=>a[1]&&a.shift())?f(a):[]]

Probieren Sie es online aus!

Wie?

Bei jeder Iteration:

• Wir geben eine neue Liste aus, die aus dem ersten Element jeder Liste besteht.
• Wir entfernen das erste Element der ersten Liste, das mindestens 2 Elemente enthält, und wiederholen den Vorgang. Oder wir stoppen die Rekursion, wenn keine solche Liste existiert.

Python 2 , 62 Bytes

lambda M:[zip(*M)[l.pop(0)*0]for l in M+[[1,1]]for _ in l[1:]]

Probieren Sie es online aus!

Verwendung von Chas Browns Pop-Idee, inspiriert von Arnauld's JS-Einreichung .

Python 2 , 68 Bytes

M=input()
for l in[[0,0]]+M:
 for x in l[1:]:l[0]=x;print zip(*M)[0]

Probieren Sie es online aus!

Mutiert die ersten Elemente der Listen, um die gewünschten Werte zu enthalten. Das [[0,0]]+ist ein hässlicher Hack, um die ersten Anfangswerte zu drucken.

Gelee , 15 Bytes

ẈṚṪ×€PƊƤFQṚCịŒp

Probieren Sie es online aus! (In der Fußzeile wird die tatsächlich zurückgegebene Liste anstelle einer Jelly-Darstellung angezeigt.)

Wie?

Indiziert in das kartesische Produkt der Listen an den erforderlichen Stellen ...

ẈṚṪ×€PƊƤFQṚCịŒp - Link: list of lists  e.g. [[6,8,4,9],[7,1,5],[3,2]]
Ẉ               - length of each            [4,3,2]
 Ṛ              - reverse                   [2,3,4]
       Ƥ        - for each prefix:             [2]      [2,3]      [2,3,4]
      Ɗ         -   last 3 links as a monad:
  Ṫ             -     tail (pop rightmost)     2        3          4
     P          -     product (of remaining)   1        2          6
    €           -     for €ach (range tail)    [1,2]    [1,2,3]    [1,2,3,4]   
   ×            -       multiply               [1,2]    [2,4,6]    [6,12,18,24]
        F       - flatten                   [1,2,2,4,6,6,12,18,24]
         Q      - de-duplicate              [1,2,4,6,12,18,24]
          Ṛ     - reverse                   [24,18,12,6,4,2,1]
           C    - complement (1-x)          [-23,-17,-11,-5,-3,-1,0]
             Œp - Cartesian product (of the input)
                -         -> [[6,7,3],[6,7,2],[6,1,3],[6,1,2],[6,5,3],[6,5,2],[8,7,3],[8,7,2],[8,1,3],[8,1,2],[8,5,3],[8,5,2],[4,7,3],[4,7,2],[4,1,3],[4,1,2],[4,5,3],[4,5,2],[9,7,3],[9,7,2],[9,1,3],[9,1,2],[9,5,3],[9,5,2]]
            ị   - index into (1-based & modular)
                -   indexes:      -23,                                            -17,                                            -11,                                             -5,             -3,             -1,     0
                -    values: [[6,7,3],                                        [8,7,3],                                        [4,7,3],                                        [9,7,3],        [9,1,3],        [9,5,3],[9,5,2]]
                -         -> [[6,7,3],[8,7,3],[4,7,3],[9,7,3],[9,1,3],[9,5,3],[9,5,2]]

ẈṚ’ṣ1T$¦ƬUṚị"€(14 Bytes) schlägt für Eingaben mit einer Liste (nicht nachlaufende Länge 1) fehl; aber vielleicht ṣ1T$kann durch etwas anderes ersetzt werden?

K (ngn / k) , 40 21 19 18 Bytes

{x@'/:?|\+|!|#:'x}

Probieren Sie es online aus!

verwendet Ideen aus der Antwort von @ H.PWiz

{ } Funktion mit Argument x

#:' Länge von jedem

| umkehren

! alle Indextupel für ein Array mit diesen Dimensionen als Spalten in einer Matrix (Liste der Listen)

| umkehren

+ transponieren

|\ laufende Maxima

? einzigartig

x@'/: Verwenden Sie jedes Tupel rechts als Indizes in den entsprechenden Listen von x

Holzkohle , 33 Bytes

ＩＥ⊕ΣＥθ⊖ＬιＥθ§λ⌈⟦⁰⌊⟦⊖Ｌλ⁻ι∧μΣＥ…θμ⊖Ｌν

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

Ｉ

Wandeln Sie die Ganzzahlen in Zeichenfolgen um, bevor Sie implizit mit dem Standardausgabeformat für Listen drucken, bei denen es sich um jedes Element in einer eigenen Zeile handelt, und für verschachtelte Listen mit doppeltem Abstand.

Ｅ⊕ΣＥθ⊖Ｌι

Nehmen Sie die Summe der Längen der Listen und subtrahieren Sie die Länge der Listenliste. Dann Schleife von 0 bis einschließlich dieses Wertes.

Ｅθ§λ

Ordnen Sie die Liste der Listen zu und indizieren Sie sie in jede Liste.

⌈⟦⁰⌊⟦⊖Ｌλ

Klemmen Sie den Index auf 0 und den letzten Index in der Liste. (Die schließenden Klammern sind impliziert.)

⁻ι∧μΣＥ…θμ⊖Ｌν

Subtrahieren Sie nach der ersten Liste die dekrementierten Längen aller vorherigen Listen vom äußersten Index. (Dies funktioniert nicht für die erste Liste, da die Länge der Listen leer ist und die Summe keine Zahl ist.)

Python 2 , 72 Bytes

f=lambda a:zip(*a)[:1]+(any(len(u)>1and u.pop(0)for u in a)and f(a)or[])

Probieren Sie es online aus!

Dies ist eine Python-Portierung von Arnauld 's exzellentem Javascript-Algorithmus.

APL (Dyalog Classic) , 32 30 27 Byte

1↓¨∪⊃{(⍵,¨⊃⍺),⍺,¨⍨⊢/⍵}/⌽0,⎕

Probieren Sie es online aus!

komplettes Programm, Eingabe erfolgt über die Tastatur ( ⎕)

eingabe []Ausgänge [[]](APL ihre Äquivalente sind 0⍴⊂⍬und ,⊂⍬)

setzt die Eindeutigkeit von Zahlen in der Eingabe voraus

JavaScript (ES6), 58 54 Byte

h=(x,s)=>[x.map(y=>s|y?y[0]:s=y.shift()),...s?h(x):[]]

Nach mehr als 14 Versuchen, meinen Code nach unten zu spielen (alle Instanzen von while-Schleifen entfernen push, und concat), kam ich zu einer Iteration, die algorithmisch der Antwort von @ Arnauld ähnelt , was angesichts der Prägnanz nicht überraschend ist!

Akzeptiert eine Liste mit Listen positiver Ganzzahlen. Probieren Sie es online aus!

58 Bytes

Für 1 weiteres Byte sollte das Ersetzen s = y.shift()durch y.shift(s = 1)alle Ganzzahlen verarbeiten (vermutlich, da ich es nicht persönlich getestet habe).

h=(x,s)=>[x.map(y=>!s/y[1]?s=y.shift():y[0]),...s?h(x):[]]

58 Bytes

Bonusversion mit leichter Neuordnung:

h=x=>[x.map(y=>s&&y[1]?y.shift(s=0):y[0],s=[]),...s||h(x)]

Erläuterung

Frühe Versionen des Codes versuchten, einen Klon (eines Arrays von) der ersten Elemente jedes Arrays zu modifizieren, aber der zusätzliche Schritt zum Initialisieren dieses Arrays war teuer ... bis mir klar wurde, dass die Zuordnung über die ersten Elemente jedes Arrays ungefähr war Die "einzige" Operation, die erforderlich ist, wenn ich die ursprünglichen Arrays mutiere.

Verwendet ein boolesches Flag, um zu überprüfen, ob ein Array noch verschoben (dh gekürzt) wurde. Golfen Sie die bedingte Überprüfung weiter nach unten, indem Sie beobachten, dass JS Arrays mit einem Zahlenwert als einzigem Element in diese Zahl zwingt, während Arrays mit mehreren Werten als NaN erzwungen werden.

var
h = (x, s) => 
    [
        x.map(y =>                 // map to first element of each array
            s|y                    // if s == 1 (i.e. an array has been shortened)
                                   // or the current array y has length == 1
                ? y[0]
                : s = y.shift()    // remove first element of y and set s to truthy
        ),
        ...s ? h(x) : []           // only concatenate a recurrence of the function if an array has had a value removed
    ]

APL (Dyalog) , 15 Bytes ( SBCS )

Vielen Dank, dass Sie auf ein unnötiges Byte hingewiesen haben

{∪⌈\,⍉⍳≢¨⍵}⊃¨¨⊂

Probieren Sie es online aus!

{∪⌈\,⍉⍳≢¨⍵}generiert Listen, die in die Eingabe indiziert werden sollen. z.B(1 2 3) (4 5 6) (7 8 9) -> (0 0 0) (1 0 0) (2 0 0) (2 1 0) (2 2 0) (2 2 1) (2 2 2)

≢¨⍵: die Länge jeder Liste in der Eingabe

,⍉⍳Erstellt alle Zahlenkombinationen bis zur Eingabe. z.B2 3 -> (0 0) (1 0) (0 1) (1 1) (0 2) (1 2)

⌈\: Scan mit Maximum. zB wäre das obige Beispiel jetzt(0 0) (1 0) (1 1) (1 1) (1 2) (1 2)

∪: Duplikate entfernen

⊃¨¨⊂ führt die Indizierung durch, wobei die Tiefe beider Argumente berücksichtigt wird

Python 2 , 91 Bytes

f=lambda a,p=():a and[p+(q,)+zip(*a)[0][1:]for q in a[0][p>():]]+f(a[1:],p+(a[0][-1],))or[]

Probieren Sie es online aus!