Dada una lista finita, devuelva una lista de todos sus prefijos, incluida una lista vacía, en orden ascendente de su longitud.

(Básicamente implementando la función Haskell inits).

Detalles

• La lista de entrada contiene números (u otro tipo si es más conveniente).
• El resultado debe ser una lista de listas .
• El envío puede, pero no tiene que ser una función, se puede usar cualquier E / S predeterminada .
• Hay una respuesta CW para todas las soluciones triviales .

Ejemplo

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

Editar: Sin embargo, un byte más corto con un escaneo completamente diferente.

Una función anónima que supera ligeramente la importación trivial.

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

Pruébalo en línea!

• Usos =<<para la abreviatura (scanr(\_->init)=<<id) l = scanr(\_->init) l l.
• Escanea una lista lde derecha a izquierda, recogiendo resultados intermedios con la función \_->init.
• Esa función ignora los elementos escaneados (solo se usan para obtener la longitud total correcta para los resultados recopilados), por lo que realmente se repite aplicando inital valor inicial del escaneo, que también es l.

brainfuck , 21 12 bytes

-9 bytes gracias a Arnauld que sugiere el separador en ÿlugar de las nuevas líneas

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

Pruébalo en línea!

Toma bytes a través de STDIN sin bytes nulos e imprime una serie de prefijos separados por el ÿcarácter con un ÿcarácter inicial . Por ejemplo, para la entrada Prefixes, la salida es ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes.

Para facilitar la lectura, aquí hay una versión con nuevas líneas .

Explicación:

-              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 bytes

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

Pruébalo en línea!

¿Cómo?

+--- 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 para todas las entradas triviales

Limpio , 19 bytes

La versión de Haskell también funciona en Clean.

import StdLib
inits

Pruébalo en línea!

Haskell , 22 bytes

import Data.List
inits

Pruébalo en línea!

Prólogo (SWI) , 6 bytes

prefix

Pruébalo en línea!

Jalea , 3 bytes

ṭṖƤ

Pruébalo en línea!

Cómo funciona

ṭṖƤ  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 bytes

²£¯Y

Pruébalo en línea!

Explicación:

²       :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 bytes

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

Pruébalo en línea!

Para explicar:

En Perl 6 se puede envolver un operador entre corchetes como una forma alternativa de escribir una reducción de la lista. [+] @arrayDevuelve la suma de los elementos @array, [*] @arrayretorna el producto, etc. También puede preceder al operador con una barra invertida para hacer una reducción "triangular", que algunas lenguas llaman "exploración". Así que [\+] @arraydevuelve una lista que consiste en el primer elemento de@array , luego la suma de los dos primeros elementos, luego la suma de los primeros tres elementos, etc.

Aquí [\,] @_hay una reducción triangular sobre la matriz de entrada @_utilizando el operador de construcción de lista ,. Por lo tanto, se evalúa en una lista de listas: el primer elemento de @_, los dos primeros elementos de @_, etc. Eso es casi lo que se necesita, pero el problema requiere primero una lista vacía. Entonces, el primer elemento de la lista de retorno es una lista literalmente vacía (),, luego la reducción sobre la lista de entrada se aplana con el resto de la lista de retorno |.

Python 2 , 32 bytes

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

Pruébalo en línea!

R , 40 39 bytes

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

Pruébalo en línea!

-1 byte gracias a digEmAll

La salida del listtipo de R es un poco extraña; utiliza indexación secuencial, por ejemplo, la salida para

list(1,2) es

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

En cambio, tomar la entrada como un vector proporciona un formato de salida más ordenado, aunque las entradas no son técnicamente lists.

JavaScript, 36 bytes

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

Pruébalo en línea!

Mathematica 22 21 bytes

^{-1 byte gracias a Misha Lavrov !}

{}~FoldList@Append~#&

Pura función. Toma una lista como entrada y devuelve una lista de listas como salida. Creo que esta es la solución más corta posible.

Casco , 2 bytes

Θḣ

Obtiene todos los ḣeads y luego antecede Θ(en este caso []):

Pruébalo en línea!

^{(necesita anotaciones de tipo para la lista vacía: ¡ Pruébelo en línea! )}

J , 5 bytes

a:,<\

Pruébalo en línea!

PowerShell , 65 bytes

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

Pruébalo en línea!

PowerShell desenrolla útilmente listas de listas cuando Write-Outputocurre el valor predeterminado al finalizar el programa, por lo que obtiene un elemento por línea. Tack en un-join',' para ver mejor la lista de listas, convirtiendo las listas internas en cadenas.

(Ab) utiliza el hecho de que intentar generar una matriz vacía (por ejemplo, @()) no produce ninguna salida, por lo que una entrada de matriz vacía solo tiene ''como salida, ya que no $a[0..$_]dará como resultado nada. También arrojará algunos mensajes de error espectaculares.

K (ngn / k) , 8 bytes

,\(,!0),

Pruébalo en línea!

Lisp común , 39 bytes

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

Pruébalo en línea!

Explicación

(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 bytes

De hecho, tengo dos respuestas bastante similares para esto, ambas de la misma longitud. Ambos toman una secuencia genéricas como parámetro.

Primera solución

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

Pruébalo en línea!

Seq.take toma el primero n elementos de la secuencia. Seq.initcrea una nueva secuencia con un recuento (en este caso) de la longitud de la secuencia smás 1, y para cada elemento de la secuencia toma los primeros nelementos ens .

Segunda solución:

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

Similar a antes, excepto que crea una secuencia de 0 a la longitud de s . Luego toma esa cantidad de elementos de s.

¡Prueba esto en línea también!

MATL, 15 12 bytes

3 bytes guardados gracias a @Giuseppe

vin:"G@:)]Xh

Pruébalo en MATL Online .

Debido a la forma en que MATL muestra la salida, no puede ver explícitamente la matriz vacía en la matriz de celdas. aquí hay una versión que muestra la salida un poco más explícitamente.

Explicación

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 bytes

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

Carbón de leña , 6 bytes

Ｅθ…θκθ

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

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

Es posible, a un costo de 1 byte, pedirle a Charcoal que imprima una n+1matriz de elementos que incluye la entrada como su último elemento, pero la salida es la misma, aunque la posición del cursor sería diferente si luego imprimiera algo más.

05AB1E , 3 bytes

η¯š

Explicación:

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

Pruébalo en línea!

RAD , 7 bytes

(⊂⍬),,\

Pruébalo en línea!

Esto también funciona en Dyalog APL como una función.

¿Cómo?

Esto funciona igual para APL y RAD, dada su estrecha relación.

• (⊂⍬) la matriz vacía
• , antepuesto a
• ,\ los prefijos (que excluyen la matriz vacía).

Groovy , 37 bytes

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

Pruébalo en línea!

Japt , 5 bytes

Êò@¯Y

Pruébalo en línea!

brainfuck , 43 bytes

Tome una lista de caracteres no nulos como entrada y devuelva todos los prefijos separados por nueva línea. Requiere doble infinito o cinta de envoltura.

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 39 bytes

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

Pruébalo en línea!

F # (Mono) , 45 bytes

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

Pruébalo en línea!

No estoy totalmente seguro de si esto es válido, pero parece que sigue la misma sintaxis "lambda anónima" que he usado en varios otros idiomas.

Java 8+ , 86 77 bytes

^{-9 bytes gracias a Kevin Cruijssen (deshacerse de la importación)!}

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

Pruébalo en línea!

Alternativa, 65 bytes

Lo siguiente imprimirá los resultados en stdout (debido a Olivier Grégoire ):

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

Pruébalo en línea

Brachylog , 9 bytes

a₀ᶠ~b.hĖ∧

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Explicación:

->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
  }
}