Sfida:

Dato un elenco di elenchi di numeri interi non vuoti, restituisce un elenco di tuple del seguente modulo: Tuple del primo elenco che iniziano con ciascun elemento del primo elenco seguito dal primo elemento di ogni elenco successivo, quindi dovrebbe essere la prima tupla [ith element of first list, first element of second list, ... , first element of last list]. Per esempio:

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

Quindi fai tuple del modulo [last element of first list, ith element of second list, first element of third list, ..., first element of last list], quindi nel nostro esempio questo sarebbe:

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

Continua con tutti gli altri elenchi rimanenti, fino ad arrivare a [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]]

L'output completo è il seguente:

[[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]]

Qualche piastra di caldaia per una buona misura:

• Se vuoi che l'input sia un elenco di stringhe o un elenco di numeri interi positivi, va bene. La domanda riguarda la manipolazione degli elenchi, non ciò che è presente negli elenchi.
• L'input e l'output possono essere in qualsiasi formato accettabile .
• È consentito un programma o una funzione completi.
• Le scappatoie standard non sono consentite per impostazione predefinita.
• Questa domanda è il golf del codice, quindi vince il conteggio dei byte più basso.

Esempi:

[] => [[]] (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]]

Se qualcuno ha un titolo migliore, fammi sapere.

JavaScript (ES6), 59 byte

Si aspetta un elenco di elenchi di numeri interi positivi .

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

Provalo online!

Come?

Ad ogni iterazione:

• Viene prodotto un nuovo elenco costituito dal primo elemento di ciascun elenco.
• Rimuoviamo il primo elemento del primo elenco contenente almeno 2 elementi e ripetiamo il processo. Oppure interrompiamo la ricorsione se tale elenco non esiste.

Python 2 , 62 byte

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

Provalo online!

Utilizzando l'idea pop di Chas Brown ispirata alla presentazione di Arnauld JS .

Python 2 , 68 byte

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

Provalo online!

Muta i primi elementi degli elenchi per contenere i valori desiderati. Il [[0,0]]+è un brutto hack per stampare i valori iniziali primi.

Gelatina , 15 byte

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

Provalo online! (il piè di pagina visualizza l'elenco restituito effettivo anziché una rappresentazione Jelly)

Come?

Indici nel prodotto cartesiano delle liste nei punti richiesti ...

ẈṚṪ×€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 byte) ha esito negativo per gli input con elenchi di lunghezza uno (non finali); ma forse ṣ1T$può essere sostituito con qualcos'altro?

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

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

Provalo online!

usa idee dalla risposta di @ H.PWiz

{ } funzione con argomento x

#:' lunghezza di ciascuno

| inversione

! tutte le tuple di indice per un array con quelle dimensioni come colonne in una matrice (elenco di elenchi)

| inversione

+ trasporre

|\ corsa massimi

? unico

x@'/: usa ogni tupla a destra come indici negli elenchi corrispondenti da x

Carbone , 33 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｉ

Trasmetti i numeri interi alle stringhe prima di stampare in modo implicito utilizzando il formato di output predefinito per gli elenchi, che è ogni elemento sulla propria riga e gli elenchi nidificati a doppia spaziatura.

Ｅ⊕ΣＥθ⊖Ｌι

Prendi la somma delle lunghezze degli elenchi e sottrai la lunghezza dell'elenco di elenchi. Quindi loop da 0 a questo valore incluso.

Ｅθ§λ

Mappa sopra l'elenco di elenchi e indicizza in ciascun elenco.

⌈⟦⁰⌊⟦⊖Ｌλ

Blocca l'indice su 0 e l'ultimo indice nell'elenco. (Le parentesi di chiusura sono implicite.)

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

Dopo il primo elenco, sottrarre le lunghezze decrementate di tutti gli elenchi precedenti dall'indice più esterno. (Questo non funziona per il primo elenco perché la lunghezza degli elenchi è vuota e la somma non è un numero.)

Python 2 , 72 byte

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

Provalo online!

Questa è una porta Python dell'eccellente algoritmo Javascript di Arnauld .

APL (Dyalog Classic) , 32 30 27 byte

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

Provalo online!

programma completo, l'input proviene dalla tastiera ( ⎕)

per le []uscite di input [[]](i loro equivalenti APL sono 0⍴⊂⍬e ,⊂⍬)

presuppone l'univocità dei numeri nell'input

JavaScript (ES6), 58 54 byte

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

Dopo oltre 14 tentativi di giocare a golf il mio codice (rimuovendo tutte le istanze di while loop, pushe concat), sono arrivato a un'iterazione algoritmicamente simile alla risposta di @ Arnauld , non sorprende dato quanto sia conciso!

Accetta un elenco di elenchi di numeri interi positivi. Provalo online!

58 byte

Per 1 byte in più, la sostituzione s = y.shift()con y.shift(s = 1)dovrebbe gestire tutti i numeri interi (presumibilmente, poiché non l'ho testato personalmente).

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

58 byte

Versione bonus, con leggero riarrangiamento:

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

Spiegazione

Le prime versioni del codice hanno cercato di modificare un clone di (una matrice di) i primi elementi di ogni matrice, ma il passaggio aggiuntivo di inizializzazione di quella matrice era costoso ... fino a quando mi sono reso conto che la mappatura sui primi elementi di ogni matrice era approssimativamente l'operazione "unica" necessaria se muto gli array originali.

Utilizza un flag booleano per verificare se qualche array è stato spostato (ovvero accorciato) ancora. Mollato ulteriormente il controllo condizionale osservando che JS costringe matrici con un valore numerico come unico elemento in quel numero, mentre costringe matrici con valori multipli come NaN.

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 byte ( SBCS )

Grazie per aver segnalato un byte non necessario

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

Provalo online!

{∪⌈\,⍉⍳≢¨⍵}genera liste da indicizzare nell'input. per esempio(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)

≢¨⍵: la lunghezza di ciascun elenco nell'input

,⍉⍳crea tutte le combinazioni di numeri fino al suo input. per esempio2 3 -> (0 0) (1 0) (0 1) (1 1) (0 2) (1 2)

⌈\: scansiona al massimo. ad esempio l'esempio sopra sarebbe ora(0 0) (1 0) (1 1) (1 1) (1 2) (1 2)

∪: rimuove i duplicati

⊃¨¨⊂ fa l'indicizzazione, tenendo conto della profondità di entrambi gli argomenti

Python 2 , 91 byte

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[]

Provalo online!