Dada uma lista finita, retorne uma lista de todos os seus prefixos, incluindo uma lista vazia, em ordem crescente de comprimento.

(Basicamente implementando a função Haskell inits.)

Detalhes

• A lista de entrada contém números (ou outro tipo, se for mais conveniente).
• A saída deve ser uma lista de listas .
• O envio pode, mas não precisa ser uma função, qualquer E / S padrão pode ser usada.
• Existe uma resposta CW para todas as soluções triviais .

Exemplo

[] -> [[]]
[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: No entanto, um byte mais curto com uma verificação completamente diferente.

Uma função anônima superando ligeiramente a importação trivial.

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

Experimente online!

• Usa =<<para a abreviação (scanr(\_->init)=<<id) l = scanr(\_->init) l l.
• Digitaliza uma lista lda direita para a esquerda, coletando resultados intermediários com a função \_->init.
• Essa função ignora os elementos varridos (eles são usados ​​apenas para obter o comprimento total correto para os resultados coletados); portanto, ele realmente se aplica initao valor inicial da varredura, o que também é l.

brainfuck , 21 12 bytes

-9 bytes graças a Arnauld sugerindo o separador em ÿvez de novas linhas

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

Experimente online!

Toma bytes por STDIN sem bytes nulos e imprime uma série de prefixos separados pelo ÿcaractere com um ÿcaractere à esquerda . Por exemplo, para a entrada Prefixes, a saída é ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes.

Para facilitar a leitura, aqui está uma versão com novas linhas .

Explicação:

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

Experimente online!

Quão?

+--- 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 as entradas triviais

Limpo , 19 bytes

A versão Haskell também funciona no Clean.

import StdLib
inits

Experimente online!

Haskell , 22 bytes

import Data.List
inits

Experimente online!

Prolog (SWI) , 6 bytes

prefix

Experimente online!

Gelatina , 3 bytes

ṭṖƤ

Experimente online!

Como 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.

Japonês , 4 bytes

²£¯Y

Experimente online!

Explicação:

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

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

Experimente online!

Explicar:

No Perl 6, você pode agrupar um operador entre colchetes como uma maneira alternativa de escrever uma redução de lista. [+] @arrayretorna a soma dos elementos @array, [*] @arrayretorna o produto etc. Você também pode preceder o operador com uma barra invertida para fazer uma redução "triangular", que alguns idiomas chamam de "varredura". Então, [\+] @arrayretorna uma lista que consiste no primeiro elemento de@array , em seguida, a soma dos dois primeiros elementos, a soma dos três primeiros elementos etc.

Aqui [\,] @_está uma redução triangular sobre a matriz de entrada @_usando o operador de construção de lista ,. Portanto, ele avalia uma lista de listas: o primeiro elemento de @_, os dois primeiros elementos de @_etc. Isso é quase o necessário, mas o problema exige uma única lista vazia primeiro. Portanto, o primeiro elemento da lista de retorno é uma lista literal vazia (),, e a redução sobre a lista de entrada é achatada no restante da lista de retorno com |.

Python 2 , 32 bytes

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

Experimente online!

R , 40 39 bytes

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

Experimente online!

-1 byte graças a digEmAll

A saída do listtipo R é um pouco estranha; ele usa indexação sequencial; portanto, por exemplo, a saída para

list(1,2) é

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

A entrada como vetor fornece um formato de saída mais limpo, embora as entradas não sejam tecnicamente lists.

JavaScript, 36 bytes

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

Experimente online!

Mathematica, 22 21 bytes

^{-1 byte graças a Misha Lavrov !}

{}~FoldList@Append~#&

Função pura. Pega uma lista como entrada e retorna uma lista de listas como saída. Eu acredito que esta é a solução mais curta possível.

Casca , 2 bytes

Θḣ

Obtém todos os ḣeads e, em seguida, acrescenta Θ(neste caso[] ):

Experimente online!

^{(precisa de anotação de tipo para lista vazia: Experimente on-line! )}

J , 5 bytes

a:,<\

Experimente online!

PowerShell , 65 bytes

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

Experimente online!

O PowerShell desenrola útil listas de listas quando o padrão Write-Outputocorre na conclusão do programa, para que você obtenha um item por linha. Prenda a -join','para ver melhor a lista de listas, convertendo as listas internas em seqüências de caracteres.

(Ab) usa o fato de que a tentativa de saída de uma matriz vazia (por exemplo, @()) resulta em nenhuma saída; portanto, uma entrada de matriz vazia apenas tem ''como saída, uma vez que $a[0..$_]isso resultará em nada. Ele também emitirá algumas mensagens de erro espetaculares.

K (ngn / k) , 8 bytes

,\(,!0),

Experimente online!

Lisp comum , 39 bytes

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

Experimente online!

Explicação

(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

Na verdade, tenho duas respostas bastante semelhantes para isso, ambas do mesmo tamanho. Ambos pegam uma sequência genéricas como parâmetro.

Primeira solução:

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

Experimente online!

Seq.takepega os primeiros nelementos da sequência. Seq.initcria uma nova sequência com uma contagem (nesse caso) do comprimento da sequência smais 1 e, para cada elemento da sequência, recebe os primeiros nelementos s.

Segunda solução:

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

Semelhante a antes, exceto que cria uma sequência de 0 ao comprimento de s. Então pega esse número de elementos de s.

Experimente isso online também!

MATL, 15 12 bytes

3 bytes salvos graças a @Giuseppe

vin:"G@:)]Xh

Experimente no MATL Online .

Devido à maneira como o MATL exibe a saída, você não pode ver explicitamente a matriz vazia na matriz de células. Aqui está uma versão que mostra a saída um pouco mais explicitamente.

Explicação

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).

Carvão , 6 bytes

Ｅθ…θκθ

Experimente online! Link é a versão detalhada do código. Explicação:

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

É possível, a um custo de 1 byte, solicitar ao Charcoal para imprimir uma n+1matriz de elementos que inclua a entrada como seu último elemento, mas a saída é a mesma, embora a posição do cursor seja diferente se você imprimir outra coisa.

05AB1E , 3 bytes

η¯š

Explicação:

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

Experimente online!

RAD , 7 bytes

(⊂⍬),,\

Experimente online!

Isso também funciona no Dyalog APL como uma função.

Quão?

Isso funciona da mesma forma para o APL e o RAD, dada a sua estreita relação.

• (⊂⍬) a matriz vazia
• , anexado a
• ,\ os prefixos (que excluem a matriz vazia).

Groovy , 37 bytes

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

Experimente online!

Japt , 5 bytes

Êò@¯Y

Experimente online!

brainfuck , 43 bytes

Pegue uma lista de caracteres não nulos como entrada e retorne todos os prefixos separados por nova linha. Requer fita dupla-infinita ou de embrulho.

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

Experimente online!

C # (compilador interativo do Visual C #) , 39 bytes

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

Experimente online!

F # (Mono) , 45 bytes

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

Experimente online!

Não tenho muita certeza se isso é válido, mas parece que segue a mesma sintaxe "anônima lambda" que pareço usada em vários outros idiomas.

Java 8+ , 86 77 bytes

^{-9 bytes graças a Kevin Cruijssen (livrar-se da importação)!}

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

Experimente online!

Alternativa, 65 bytes

A seguir, os resultados serão impressos no stdout (devido a Olivier Grégoire ):

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

Experimente online

Braquilog , 9 bytes

a₀ᶠ~b.hĖ∧

Experimente online!

Explicação

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

Experimente online!

Explicação:

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