Défi:

Étant donné une liste de listes d'entiers non vides, renvoyez une liste de tuples de la forme suivante: Première liste de tuples commençant par chaque élément de la première liste suivi du premier élément de chaque liste suivante, donc le ième tuple devrait être [ith element of first list, first element of second list, ... , first element of last list]. Par exemple:

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

Ensuite, faites des tuples du formulaire [last element of first list, ith element of second list, first element of third list, ..., first element of last list], donc dans notre exemple, ce serait:

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

Continuez avec chaque liste restante, jusqu'à ce que vous arriviez à [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 sortie complète est la suivante:

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

Certains passe-partout pour faire bonne mesure:

• Si vous voulez que l'entrée soit des listes de chaînes ou des listes d'entiers positifs, ça va. La question porte sur la manipulation des listes, pas sur le contenu des listes.
• L'entrée et la sortie peuvent être dans n'importe quel format acceptable .
• Un programme ou une fonction complète est autorisé.
• Les failles standard sont interdites par défaut.
• Cette question est le golf de code, donc le nombre d'octets le plus bas l'emporte.

Exemples:

[] => [[]] (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 quelqu'un a un meilleur titre, faites le moi savoir.

JavaScript (ES6), 59 octets

Attend une liste de listes d' entiers positifs .

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

Essayez-le en ligne!

Comment?

À chaque itération:

• Nous sortons une nouvelle liste composée du premier élément de chaque liste.
• Nous supprimons le premier élément de la première liste contenant au moins 2 éléments et répétons le processus. Ou nous arrêtons la récursivité si une telle liste n'existe pas.

Python 2 , 62 octets

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

Essayez-le en ligne!

En utilisant l'idée pop de Chas Brown inspirée de la soumission JS d' Arnauld .

Python 2 , 68 octets

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

Essayez-le en ligne!

Mute les premiers éléments des listes pour contenir les valeurs souhaitées. Le [[0,0]]+est un hack laid pour imprimer les premières valeurs initiales.

Gelée , 15 octets

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

Essayez-le en ligne! (le pied de page affiche la liste retournée réelle plutôt qu'une représentation Jelly)

Comment?

Index dans le produit cartésien des listes aux points requis ...

ẈṚṪ×€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 octets) échoue pour les entrées avec une longueur (non-fin) une liste; mais peut ṣ1T$-être peut-être remplacé par autre chose?

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

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

Essayez-le en ligne!

utilise les idées de la réponse de @ H.PWiz

{ } fonction avec argument x

#:' longueur de chacun

| inverser

! tous les tuples d'index pour un tableau avec ces dimensions sous forme de colonnes dans une matrice (liste de listes)

| inverser

+ transposer

|\ courir des maxima

? unique

x@'/: utiliser chaque tuple à droite comme indices dans les listes correspondantes de x

Fusain , 33 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｉ

Convertissez les entiers en chaînes avant d'imprimer implicitement en utilisant le format de sortie par défaut pour les listes, qui est chaque élément sur sa propre ligne, et les listes imbriquées à double interligne.

Ｅ⊕ΣＥθ⊖Ｌι

Prenez la somme des longueurs des listes et soustrayez la longueur de la liste des listes. Bouclez ensuite de 0 à cette valeur incluse.

Ｅθ§λ

Mappez sur la liste des listes et indexez-les dans chaque liste.

⌈⟦⁰⌊⟦⊖Ｌλ

Fixez l'index à 0 et au dernier index de la liste. (Les crochets de fermeture sont implicites.)

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

Après la première liste, soustrayez les longueurs décrémentées de toutes les listes précédentes de l'index le plus à l'extérieur. (Cela ne fonctionne pas pour la première liste car la longueur des listes est vide et la somme n'est pas un nombre.)

Python 2 , 72 octets

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

Essayez-le en ligne!

Il s'agit d'un port Python de l'excellent algorithme Javascript d' Arnauld .

APL (Dyalog Classic) , 32 30 27 octets

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

Essayez-le en ligne!

programme complet, la saisie se fait depuis le clavier ( ⎕)

pour les []sorties d' entrée [[]](leurs équivalents APL sont 0⍴⊂⍬et ,⊂⍬)

suppose l'unicité des nombres dans l'entrée

JavaScript (ES6), 58 54 octets

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

Après plus de 14 tentatives de lecture de mon code (en supprimant toutes les instances de boucles while push, et concat), je suis arrivé à une itération algorithmiquement similaire à la réponse de @ Arnauld , sans surprise étant donné sa brièveté!

Accepte une liste de listes d'entiers positifs. Essayez-le en ligne!

58 octets

Pour 1 octet de plus, le remplacement s = y.shift()par y.shift(s = 1)devrait gérer tous les entiers (probablement, car je ne l'ai pas personnellement testé).

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

58 octets

Version bonus, avec un léger réarrangement:

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

Explication

Les premières versions du code tentaient de modifier un clone (d'un tableau de) les premiers éléments de chaque tableau, mais l'étape supplémentaire d'initialisation de ce tableau était coûteuse ... jusqu'à ce que je réalise que le mappage sur les premiers éléments de chaque tableau était à peu près la "seule" opération nécessaire si je mute les tableaux d'origine.

Utilise un indicateur booléen pour vérifier si un tableau a encore été décalé (c'est-à-dire raccourci). Parcourez la vérification conditionnelle plus loin en observant que JS contraint les tableaux avec une valeur numérique comme seul élément dans ce nombre, tout en contraignant les tableaux avec plusieurs valeurs comme 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 octets ( SBCS )

Merci ngn d'avoir signalé un octet inutile

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

Essayez-le en ligne!

{∪⌈\,⍉⍳≢¨⍵}génère des listes à indexer dans l'entrée. par exemple(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 longueur de chaque liste en entrée

,⍉⍳crée toutes les combinaisons de nombres jusqu'à son entrée. par exemple2 3 -> (0 0) (1 0) (0 1) (1 1) (0 2) (1 2)

⌈\: scan avec maximum. par exemple l'exemple ci-dessus serait maintenant(0 0) (1 0) (1 1) (1 1) (1 2) (1 2)

∪: supprimer les doublons

⊃¨¨⊂ fait l'indexation, en étant conscient de la profondeur de chaque argument

Python 2 , 91 octets

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

Essayez-le en ligne!