Pour une liste finie, retourne une liste de tous ses préfixes, y compris une liste vide, dans l'ordre croissant de leur longueur.

(Implémentation de la fonction Haskell inits.)

Détails

• La liste de saisie contient des nombres (ou un autre type si cela convient mieux).
• La sortie doit être une liste de listes .
• La soumission peut, mais ne doit pas nécessairement être une fonction, toutes les E / S par défaut peuvent être utilisées.
• Il existe une réponse CW pour toutes les solutions triviales .

Exemple

[] -> [[]]
[42] -> [[],[42]]
[1,2,3,4] -> [[], [1], [1,2], [1,2,3], [1,2,3,4]]
[4,3,2,1] -> [[], [4], [4,3], [4,3,2], [4,3,2,1]]

Haskell , 20 octets

Edit: Encore un octet plus court avec un scan complètement différent.

Une fonction anonyme battant légèrement l’importation triviale.

scanr(\_->init)=<<id

Essayez-le en ligne!

• Utilisations =<<pour l'abréviation (scanr(\_->init)=<<id) l = scanr(\_->init) l l.
• Parcourt une liste lde droite à gauche, en collectant des résultats intermédiaires avec la fonction \_->init.
• Cette fonction ignore les éléments analysés (ils ne sont utilisés que pour obtenir la longueur totale correcte pour les résultats collectés). Il est donc vraiment itéré de s’appliquer inità la valeur initiale de l’analyse, qui est également l.

brainfuck , 21 12 octets

-9 octets grâce à Arnauld qui a suggéré le séparateur ÿau lieu des sauts de ligne

-[[<]>[.>],]

Essayez-le en ligne!

Prend des octets via STDIN sans octets nuls et imprime une série de préfixes séparés par le ÿcaractère précédé d'un ÿcaractère. Par exemple, pour l'entrée Prefixes, la sortie est ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes.

Pour plus de lisibilité, voici une version avec des nouvelles lignes .

Explication:

-              Create a ÿ character in cell 0
 [        ,]   While input, starting with the ÿ
  [<]>           Go to the start of the string
      [.>]       Print the string
          ,      Append the input to the end of the string

JavaScript (ES6), 33 octets

a=>[b=[],...a.map(n=>b=[...b,n])]

Essayez-le en ligne!

Comment?

+--- a = input array
|
|       +--- initialize b to an empty array and include it as the first entry
|       |    of the output (whatever the input is)
|       |
|       |          +--- for each value n in a[]:
|       |          |
|       |          |        +--- append n to b[] and include this new array in
|       |          |        |    the final output
|       |          |        |
a => [b = [], ...a.map(n => b = [...b, n])]
               |                  |
               +---------+--------+
                         |
      spread syntax: expands all elements of
      the child array within the parent array

CW pour toutes les entrées triviales

Propre , 19 octets

La version Haskell fonctionne également dans Clean.

import StdLib
inits

Essayez-le en ligne!

Haskell , 22 octets

import Data.List
inits

Essayez-le en ligne!

Prolog (SWI) , 6 octets

prefix

Essayez-le en ligne!

Gelée , 3 octets

ṭṖƤ

Essayez-le en ligne!

Comment ça marche

ṭṖƤ  Main link. Argument: A

  Ƥ  Map the link to the left over all non-empty(!) prefixes of A.
 Ṗ       Pop; remove the last element.
ṭ    Tack; append A to the resulting list.

Japt , 4 octets

²£¯Y

Essayez-le en ligne!

Explication:

²       :Add an arbitrary extra item to the end of the array
 £      :For each item in the new array:
  ¯Y    : Get an array of the items that are before it

Perl 6 , 13 octets

{(),|[\,] @_}

Essayez-le en ligne!

Expliquer:

En Perl 6, vous pouvez placer un opérateur entre crochets comme moyen alternatif d’écrire une réduction de liste. [+] @arrayrenvoie la somme des éléments entrants @array, [*] @arrayrenvoie le produit, etc. Vous pouvez également faire précéder l'opérateur d'une barre oblique inverse pour créer une réduction "triangulaire", que certaines langues appellent "analyse". Donc, [\+] @arrayretourne une liste composée du premier élément de @array, puis de la somme des deux premiers éléments, puis de la somme des trois premiers éléments, etc.

Voici [\,] @_une réduction triangulaire sur le tableau d'entrée @_à l'aide de l'opérateur de construction de liste ,. Donc, il s’agit d’une liste de listes: le premier élément de @_, les deux premiers éléments de @_, etc. C’est presque ce dont nous avons besoin, mais le problème appelle d’abord une liste vide. Ainsi, le premier élément de la liste de retour est une liste vide littérale (),, puis la réduction sur la liste d'entrée est aplatie dans le reste de la liste de retour avec |.

Python 2 , 32 octets

f=lambda l:(l and f(l[:-1]))+[l]

Essayez-le en ligne!

R , 40 39 octets

function(L)lapply(0:length(L),head,x=L)

Essayez-le en ligne!

-1 octet grâce à digEmAll

La sortie du listtype de R est un peu bizarre; il utilise l'indexation séquentielle, de sorte que, par exemple, la sortie de

list(1,2) est

[[1]]                     # first list element
list()

[[2]]                     # second list element
[[2]][[1]]                # first element of second list element
[1] 1


[[3]]                     # third list element
[[3]][[1]]                # first element of third list element
[1] 1

[[3]][[2]]                # etc.
[1] 2

Prendre une entrée en tant que vecteur donne un format de sortie plus net, bien que les entrées ne soient pas techniquement lists.

JavaScript, 36 octets

a=>[...a,0].map((x,y)=>a.slice(0,y))

Essayez-le en ligne!

Mathematica, 22 21 octets

^{-1 octet grâce à Misha Lavrov !}

{}~FoldList@Append~#&

Fonction pure. Prend une liste en entrée et renvoie une liste de listes en sortie. Je crois que c'est la solution la plus courte possible.

Husk , 2 octets

Θḣ

Obtient tous les ḣeads et ensuite ajoute Θ(dans ce cas []):

Essayez-le en ligne!

^{(nécessite une annotation de type pour une liste vide: essayez-le en ligne! )}

J , 5 octets

a:,<\

Essayez-le en ligne!

PowerShell , 65 octets

param($a)'';$x=,0*($y=$a.count);0..--$y|%{$x[$_]=@($a[0..$_])};$x

Essayez-le en ligne!

PowerShell déroule utilement les listes de listes lorsque la valeur par défaut Write-Outputsurvient à la fin du programme. Vous obtenez ainsi un élément par ligne. Clique sur a -join','pour mieux voir la liste de listes, en convertissant les listes intérieures en chaînes.

(Ab) utilise le fait que toute tentative de sortie d'un tableau vide (par exemple @()) n'entraîne aucune sortie. Par conséquent, une entrée de tableau vide a simplement ''pour sortie, car elle $a[0..$_]n'aboutira à rien. Cela déclenchera également des messages d'erreur spectaculaires.

K (ngn / k) , 8 octets

,\(,!0),

Essayez-le en ligne!

Common Lisp , 39 octets

(defun f(l)`(,@(if l(f(butlast l))),l))

Essayez-le en ligne!

Explication

(defun f(l)                           )  ; Define a function f
           `(                        )   ; With the list (essentially capable of interpolation), containing:
             ,@                          ;     The value of, flattened to one level
               (if l              )      ;         If l is not the empty list (which is the representation of nil, i.e. the only falsy value)
                    (f(butlast l))       ;         Recurse with all of l but the tail
                                   ,l    ;     The value of l

F #, 53 octets

J'ai en fait deux réponses assez similaires pour cela, les deux de la même longueur. Ils prennent tous deux une séquence générique sen paramètre.

Première solution:

let i s=Seq.init(Seq.length s+1)(fun n->Seq.take n s)

Essayez-le en ligne!

Seq.takeprend les premiers néléments de la séquence. Seq.initcrée une nouvelle séquence avec un compte (dans ce cas) de la longueur de la séquence splus 1, et pour chaque élément de la séquence prend les premiers néléments dans s.

Deuxième solution:

let i s=Seq.map(fun n->Seq.take n s){0..Seq.length s}

Semblable à avant, sauf qu'il crée une séquence de 0 à la longueur de s. Puis prend ce nombre d'éléments de s.

Essayez ceci en ligne aussi!

MATL, 15 12 octets

3 octets sauvés grâce à @Giuseppe

vin:"G@:)]Xh

Essayez-le sur MATL Online .

En raison de la façon dont MATL affiche la sortie, vous ne pouvez pas voir explicitement le tableau vide dans le tableau de cellules. Voici une version qui montre la sortie un peu plus explicitement.

Explication

v       # Vertically concatenate the (empty) stack to create the array []
i       # Explicitly grab the input
n       # Compute the number of elements in the input (N)
:       # Create an array from [1, ..., N]
"       # Loop through this array
  G     # For each of these numbers, M
  @:    # Create an array from [1, ..., M]
  )     # Use this to index into the initial array
]       # End of the for loop
Xh      # Concatenate the entire stack into a cell array

SWI PROLOG 22 octets

i(X,Y):-append(X,_,Y).

charbon , 6 octets

Ｅθ…θκθ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

 θ      Input array
Ｅ       Map over elements
   θ    Input array
  …     Moulded to length
    κ   Current loop index
        Implicitly print each array double-spaced
     θ  Input array
        Implicitly print

Il est possible, avec un coût d'un octet, de demander à Charcoal d'imprimer un n+1tableau d'élément comportant le dernier élément en entrée, mais le résultat est identique, bien que la position du curseur soit différente si vous imprimez autre chose.

05AB1E , 3 octets

η¯š

Explication:

η    Prefixes
  š  Prepend
 ¯   Global array (empty by default)

Essayez-le en ligne!

RAD , 7 octets

(⊂⍬),,\

Essayez-le en ligne!

Cela fonctionne également dans Dyalog APL en tant que fonction.

Comment?

Cela fonctionne de la même manière pour APL et RAD, étant donné leur relation étroite.

• (⊂⍬) le tableau vide
• , préposé à
• ,\ les préfixes (qui excluent le tableau vide.)

Groovy , 37 octets

{x->(0..x.size()).collect{x[0..<it]}}

Essayez-le en ligne!

Japt , 5 octets

Êò@¯Y

Essayez-le en ligne!

brainfuck , 43 octets

Prend une liste de caractères non nuls en entrée et renvoie tous les préfixes séparés par une nouvelle ligne. Nécessite un ruban double-infini ou enveloppant.

,>-[+>,]<[-<]<<++++++++++[[<]>[.>]>[-<+>]<]

Essayez-le en ligne!

C # (compilateur interactif Visual C #) , 39 octets

x=>x.Select((_,i)=>x.Take(i)).Append(x)

Essayez-le en ligne!

F # (Mono) , 45 octets

fun x->List.mapi(fun i y->List.take i x)x@[x]

Essayez-le en ligne!

Je ne suis pas tout à fait sûr que cela soit valable, mais il semble que cela respecte la même syntaxe de "lambda anonyme" que celle que j'ai apparemment utilisée dans plusieurs autres langues.

Java 8+ , 86 77 octets

^{-9 octets grâce à Kevin Cruijssen (se débarrasser de l'importation)!}

x->java.util.stream.IntStream.range(0,x.size()+1).mapToObj(t->x.subList(0,t))

Essayez-le en ligne!

Alternative, 65 octets

Les personnes suivantes imprimeront les résultats sur la sortie standard (à cause d’ Olivier Grégoire ):

x->{for(int i=0;i<=x.size();)System.out.print(x.subList(0,i++));}

Essayez-le en ligne

Brachylog , 9 octets

a₀ᶠ~b.hĖ∧

Essayez-le en ligne!

Explication

a₀ᶠ           Find all prefixes of the input
   ~b         Add an element at the beginning of that list of prefixes
      hĖ      This element is the empty list
     .  ∧     (the list with the additional empty list is the output)

Ruby , 31 29 octets

->a{[a*i=0]+a.map{a[0,i+=1]}}

Essayez-le en ligne!

Explication:

->a{             # take array input a
  [a*i=0]+       # set i to 0 and add whatever comes next to [[]] (a*0 == [])
  a.map{         # for every element in a (basically do a.length times)
    a[0,i+=1]  # increment i and return the first i-1 elements of a to map
  }
}