给定一些有限列表，以其长度的升序返回所有前缀的列表，包括一个空列表。

（基本实现Haskell函数inits。）

细节

• 输入列表包含数字（如果方便的话，还可以输入其他类型）。
• 输出必须是一个列表列表。
• 提交可以但不必一定是函数，可以使用任何默认的I / O。
• 有一个CW答案为所有平凡的解决方案。

例

[] -> [[]]
[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个字节

编辑：通过完全不同的扫描，又缩短了一个字节。

匿名函数略微影响了琐碎的导入。

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

在线尝试！

• 使用=<<的缩写(scanr(\_->init)=<<id) l = scanr(\_->init) l l。
• l从右到左扫描列表，使用函数收集中间结果\_->init。
• 该函数将忽略扫描通过的元素（它们仅用于获取所收集结果的正确总长度），因此实际上会迭代应用init到扫描的初始值（也就是）l。

Brainfuck，21 12字节

-9个字节，感谢Arnauld建议使用分隔符ÿ而不是换行符

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

在线尝试！

通过STDIN接收字节，不包含空字节，并打印一系列前缀，这些前缀由ÿ带有前导ÿ字符的字符分隔。例如，对于输入Prefixes，输出为ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes。

为了便于阅读，以下是带有换行符的版本。

说明：

-              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个字节

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

在线尝试！

怎么样？

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

干净的 19字节

Haskell版本也适用于Clean。

import StdLib
inits

在线尝试！

Haskell，22个字节

import Data.List
inits

在线尝试！

Prolog（SWI），6个字节

prefix

在线尝试！

果冻，3个字节

ṭṖƤ

在线尝试！

怎么运行的

ṭṖƤ  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个字节

²£¯Y

在线尝试！

说明：

²       :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个字节

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

在线尝试！

解释：

在Perl 6中，您可以将运算符括在方括号中，作为编写列表精简的另一种方法。 [+] @array返回中的元素之和@array，[*] @array返回乘积，等等。您还可以在运算符前面加上反斜杠以进行“三角形”归约，有些语言将其称为“扫描”。因此，[\+] @array返回一个列表，其中包含的第一个元素@array，然后是前两个元素的总和，然后是前三个元素的总和，依此类推。

这[\,] @_是@_使用列表构造运算符对输入数组进行的三角缩减,。因此，它求值为一个列表列表：的第一个元素@_，的前两个元素@_，等等。这几乎是必需的，但是问题首先需要一个空列表。所以返回列表的第一个元素是一个文字空列表(),，然后输入列表的约数用展平到返回列表的其余部分|。

Python 2，32字节

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

在线尝试！

R，40 39字节

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

在线尝试！

-1字节归功于digEmAll

R的list类型的输出有点奇怪；它使用顺序索引，因此，例如

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

取而代之的是将输入作为向量给出更整洁的输出格式，尽管从技术上讲输入不是lists。

JavaScript，36个字节

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

在线尝试！

Mathematica， 22 21字节

^{-1个字节感谢Misha Lavrov！}

{}~FoldList@Append~#&

纯功能。将列表作为输入，并返回列表作为输出。我相信这是最短的解决方案。

稻壳，2个字节

Θḣ

获取所有的ḣ珠，然后准备Θ（在这种情况下[]）：

在线尝试！

^{（需要为空列表键入注释：在线尝试！）}

J，5个字节

a:,<\

在线尝试！

PowerShell，65字节

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

在线尝试！

PowerShell的有益解开名单-的-列表时默认Write-Output发生在程序完成后，让你获得每个项目一行。钉上-join','看到列表中，列出了更好的，通过转换内部列表为字符串。

（ab）使用以下事实：尝试输出一个空数组（例如@()）将导致没有输出，因此一个空数组输入只是''作为输出，因为$a[0..$_]不会产生任何结果。它还会抛出一些异常的错误消息。

K（ngn / k），8个字节

,\(,!0),

在线尝试！

普通Lisp，39个字节

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

在线尝试！

说明

(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个字节

实际上，我有两个非常相似的答案，它们的长度相同。它们都采用通用序列s作为参数。

第一个解决方案：

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

在线尝试！

Seq.take接受n序列的第一个元素。Seq.init创建一个新序列，该序列的长度（在这种情况下）为序列的长度s加1，并且序列中的每个元素都采用中的第一个n元素s。

第二种解决方案：

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

与之前类似，不同之处在于它创建了一个从0到的长度的序列s。然后从中获取该数量的元素s。

也可以在线尝试！

MATL，15 12字节

@Giuseppe节省了3个字节

vin:"G@:)]Xh

在MATL Online上尝试。

由于MATL显示输出的方式，您无法在单元格数组中明确看到空数组。这是一个显示输出的版本。

说明

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字节

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

木炭，6个字节

Ｅθ…θκθ

在线尝试！链接是详细版本的代码。说明：

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

可能需要1个字节的费用来让Charcoal打印一个n+1-element数组，其中将输入作为最后一个元素，但输出是相同的，尽管如果您继续打印其他内容，则光标位置会有所不同。

05AB1E，3个字节

η¯š

说明：

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

在线尝试！

RAD，7个字节

(⊂⍬),,\

在线尝试！

这在Dyalog APL中也可以用作功能。

怎么样？

鉴于它们之间的密切关系，这对于APL和RAD都是一样的。

• (⊂⍬) 空数组
• , 前置于
• ,\ 前缀（不包括空数组）。

Groovy，37个字节

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

在线尝试！

Japt，5个字节

Êò@¯Y

在线尝试！

脑干，43字节

以非空字符列表作为输入，并返回所有以换行符分隔的前缀。需要无限双或包装带。

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

在线尝试！

C＃（Visual C＃交互式编译器），39字节

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

在线尝试！

F＃（单声道），45字节

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

在线尝试！

我不完全确定这是否有效，但似乎它遵循与我在其他几种语言中使用过的相同的“匿名lambda”语法。

Java 8 +，86 77字节

^{-9个字节感谢Kevin Cruijssen（摆脱了导入）！}

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

在线尝试！

备用，65个字节

下面将把结果打印到stdout（由于OlivierGrégoire）：

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

在线尝试

Brachylog，9个字节

a₀ᶠ~b.hĖ∧

在线尝试！

说明

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)

红宝石，31 29字节

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

在线尝试！

说明：

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