Desafío:

Dada una lista de listas no enteras de enteros, devuelva una lista de tuplas de la siguiente forma: Primera lista de tuplas que comienzan con cada elemento de la primera lista seguido del primer elemento de cada lista posterior, por lo que la i-ésima tupla debería ser [ith element of first list, first element of second list, ... , first element of last list]. Por ejemplo:

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

Luego haga tuplas de la forma [last element of first list, ith element of second list, first element of third list, ..., first element of last list], por lo que en nuestro ejemplo esto sería:

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

Continúe con cada lista restante, hasta llegar 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]]

La salida completa es la siguiente:

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

Algunas repeticiones para una buena medida:

• Si desea que la entrada sea listas de cadenas o listas de enteros positivos, está bien. La pregunta es sobre manipular listas, no sobre lo que hay en las listas.
• La entrada y salida pueden estar en cualquier formato aceptable .
• Se permite un programa completo o una función.
• Las lagunas estándar no están permitidas por defecto.
• Esta pregunta es el código de golf, por lo que gana el conteo de bytes más bajo.

Ejemplos:

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

Si alguien tiene un mejor título, avíseme.

JavaScript (ES6), 59 bytes

Espera una lista de listas de enteros positivos .

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

Pruébalo en línea!

¿Cómo?

En cada iteración:

• Producimos una nueva lista que consta del primer elemento de cada lista.
• Eliminamos el primer elemento de la primera lista que contiene al menos 2 elementos y repetimos el proceso. O detenemos la recursividad si no existe dicha lista.

Python 2 , 62 bytes

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

Pruébalo en línea!

Usando la idea pop de Chas Brown inspirada en la presentación de JS de Arnauld .

Python 2 , 68 bytes

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

Pruébalo en línea!

Muta los primeros elementos de las listas para contener los valores deseados. El [[0,0]]+es un truco feo para imprimir los primeros valores iniciales.

Jalea , 15 bytes

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

Pruébalo en línea! (el pie de página muestra la lista real devuelta en lugar de una representación Jelly)

¿Cómo?

Índices en el producto cartesiano de las listas en los puntos requeridos ...

ẈṚṪ×€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) falla para entradas con listas de longitud uno (no final); pero tal vez ṣ1T$puede ser reemplazado por otra cosa?

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

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

Pruébalo en línea!

utiliza ideas de la respuesta de @ H.PWiz

{ } funcionar con argumento x

#:' longitud de cada

| contrarrestar

! todas las tuplas de índice para una matriz con esas dimensiones como columnas en una matriz (lista de listas)

| contrarrestar

+ transponer

|\ corriendo maxima

? único

x@'/: use cada tupla a la derecha como índices en las listas correspondientes de x

Carbón , 33 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｉ

Convierta los enteros en cadenas antes de imprimir implícitamente utilizando el formato de salida predeterminado para las listas, que es cada elemento en su propia línea, y las listas anidadas a doble espacio.

Ｅ⊕ΣＥθ⊖Ｌι

Tome la suma de las longitudes de las listas y reste la longitud de la lista de listas. Luego pase de 0 a este valor inclusive.

Ｅθ§λ

Asigne sobre la lista de listas e indexe en cada lista.

⌈⟦⁰⌊⟦⊖Ｌλ

Sujete el índice a 0 y al último índice de la lista. (Los corchetes están implícitos).

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

Después de la primera lista, reste las longitudes decrementadas de todas las listas anteriores del índice más externo. (Esto no funciona para la primera lista porque la longitud de las listas está vacía y la suma no es un número).

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

Pruébalo en línea!

Este es un puerto de Python del excelente algoritmo Javascript de Arnauld .

APL (Dyalog Classic) , 32 30 27 bytes

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

Pruébalo en línea!

programa completo, la entrada es desde el teclado ( ⎕)

para []salidas de entrada [[]](sus equivalentes APL son 0⍴⊂⍬y ,⊂⍬)

asume la unicidad de los números en la entrada

JavaScript (ES6), 58 54 bytes

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

Después de más de 14 intentos de descifrar mi código (eliminando todas las instancias de los bucles while, pushy concat), llegué a una iteración algorítmicamente similar a la respuesta de @ Arnauld , ¡no es sorprendente dado lo sucinto que es!

Acepta una lista de listas de enteros positivos. Pruébalo en línea!

58 bytes

Para 1 byte más, reemplazar s = y.shift()con y.shift(s = 1)debería manejar todos los enteros (presumiblemente, ya que no lo he probado personalmente).

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

58 bytes

Versión de bonificación, con una ligera reorganización:

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

Explicación

Las primeras versiones del código intentaron modificar un clon de (una matriz de) los primeros elementos de cada matriz, pero el paso adicional de inicializar esa matriz fue costoso ... hasta que me di cuenta de que el mapeo sobre los primeros elementos de cada matriz era aproximadamente la "única" operación necesaria si cambio las matrices originales.

Utiliza una bandera booleana para verificar si alguna matriz ha sido desplazada (es decir, acortada) todavía. Golfed la verificación condicional más abajo al observar que JS coacciona matrices con un valor numérico como su único elemento en ese número, mientras coacciona matrices con múltiples valores como 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 bytes ( SBCS )

Gracias por señalar un byte innecesario.

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

Pruébalo en línea!

{∪⌈\,⍉⍳≢¨⍵}genera listas para indexar en la entrada. p.ej(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 longitud de cada lista en la entrada

,⍉⍳crea todas las combinaciones de números hasta su entrada. p.ej2 3 -> (0 0) (1 0) (0 1) (1 1) (0 2) (1 2)

⌈\: escanear con el máximo. por ejemplo, el ejemplo anterior ahora sería(0 0) (1 0) (1 1) (1 1) (1 2) (1 2)

∪: eliminar duplicados

⊃¨¨⊂ realiza la indexación, teniendo en cuenta la profundidad de cualquiera de los argumentos

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

Pruébalo en línea!