Đưa ra một số danh sách hữu hạn, trả về một danh sách tất cả các tiền tố của nó, bao gồm cả một danh sách trống, theo thứ tự tăng dần theo chiều dài của chúng.

(Về cơ bản thực hiện chức năng Haskell inits.)

Chi tiết

• Danh sách đầu vào chứa số (hoặc loại khác nếu thuận tiện hơn).
• Đầu ra phải là một danh sách các danh sách .
• Việc gửi có thể, nhưng không phải là một chức năng, bất kỳ I / O mặc định nào cũng có thể được sử dụng.
• Có một câu trả lời CW cho tất cả các giải pháp tầm thường .

Thí dụ

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

Chỉnh sửa: Tuy nhiên, một byte ngắn hơn với một lần quét hoàn toàn khác.

Một chức năng ẩn danh hơi đánh bại việc nhập khẩu tầm thường.

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

Hãy thử trực tuyến!

• Sử dụng =<<cho viết tắt (scanr(\_->init)=<<id) l = scanr(\_->init) l l.
• Quét một danh sách ltừ phải sang trái, thu thập kết quả trung gian với chức năng \_->init.
• Hàm đó bỏ qua các phần tử được quét qua (chúng chỉ được sử dụng để có tổng độ dài phù hợp cho các kết quả được thu thập), do đó, thực sự lặp lại áp dụng initcho giá trị ban đầu của quá trình quét l.

Brainfuck , 21 12 byte

-9 byte nhờ Arnauld đề xuất dấu phân cách ÿthay vì dòng mới

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

Hãy thử trực tuyến!

Đưa byte qua STDIN không có byte rỗng và in một loạt các tiền tố được phân tách bằng ÿký tự có ÿký tự đầu . Ví dụ, đối với đầu vào Prefixes, đầu ra là ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes.

Để dễ đọc, đây là một phiên bản có dòng mới thay thế .

Giải trình:

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

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

Hãy thử trực tuyến!

Làm sao?

+--- 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 cho tất cả các mục tầm thường

Sạch , 19 byte

Phiên bản Haskell cũng hoạt động trong Clean.

import StdLib
inits

Hãy thử trực tuyến!

Haskell , 22 byte

import Data.List
inits

Hãy thử trực tuyến!

Prolog (SWI) , 6 byte

prefix

Hãy thử trực tuyến!

Thạch , 3 byte

ṭṖƤ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

²£¯Y

Hãy thử trực tuyến!

Giải trình:

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

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

Hãy thử trực tuyến!

Giải thích:

Trong Perl 6, bạn có thể bọc một toán tử trong ngoặc vuông như một cách thay thế để viết giảm danh sách. [+] @arraytrả về tổng của các phần tử trong @array, [*] @arraytrả về sản phẩm, v.v. Bạn cũng có thể đặt trước toán tử bằng dấu gạch chéo ngược để thực hiện giảm "tam giác", mà một số ngôn ngữ gọi là "quét". Vì vậy, [\+] @arraytrả về một danh sách bao gồm các yếu tố đầu tiên của@array , sau đó là tổng của hai phần tử đầu tiên, sau đó là tổng của ba phần tử đầu tiên, v.v.

Dưới đây [\,] @_là một giảm tam giác trên mảng đầu vào @_bằng cách sử dụng toán tử xây dựng danh sách ,. Vì vậy, nó đánh giá một danh sách các danh sách: yếu tố đầu tiên @_, hai yếu tố đầu tiên @_, v.v ... Đó gần như là những gì cần thiết, nhưng vấn đề trước tiên cần có một danh sách trống. Vì vậy, phần tử đầu tiên của danh sách trả về là một danh sách trống theo nghĩa đen (),, sau đó việc giảm danh sách đầu vào được làm phẳng vào phần còn lại của danh sách trả về với |.

Python 2 , 32 byte

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

Hãy thử trực tuyến!

R , 40 39 byte

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

Hãy thử trực tuyến!

-1 byte nhờ digEmAll

Đầu ra của R's list hơi lạ một chút; nó sử dụng lập chỉ mục tuần tự, ví dụ, đầu ra cho

list(1,2) Là

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

Lấy đầu vào làm vector thay vào đó sẽ cho định dạng đầu ra gọn gàng hơn, mặc dù sau đó các đầu vào không phải là kỹ thuật lists.

JavaScript, 36 byte

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

Hãy thử trực tuyến!

Toán học, 22 21 byte

^{-1 byte nhờ Misha Lavrov !}

{}~FoldList@Append~#&

Chức năng thuần túy. Lấy danh sách làm đầu vào và trả về danh sách danh sách làm đầu ra. Tôi tin rằng đây là giải pháp ngắn nhất có thể.

Husk , 2 byte

Θḣ

Nhận tất cả các hướng dẫn ḣvà sau đó trả trước Θ(trong trường hợp này []):

Hãy thử trực tuyến!

^{(cần chú thích loại cho danh sách trống: Dùng thử trực tuyến! )}

J , 5 byte

a:,<\

Hãy thử trực tuyến!

PowerShell , 65 byte

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

Hãy thử trực tuyến!

PowerShell giúp kiểm soát danh sách danh sách một cách hữu ích khi mặc định Write-Outputxảy ra khi hoàn thành chương trình, do đó bạn nhận được một mục trên mỗi dòng. Tack trên một-join',' để xem danh sách danh sách tốt hơn, bằng cách chuyển đổi danh sách bên trong thành chuỗi.

(Ab) sử dụng thực tế là việc cố gắng tạo ra một mảng trống (ví dụ @():) không dẫn đến kết quả đầu ra, do đó, một đầu vào mảng trống chỉ có ''đầu ra, vì $a[0..$_]sẽ không có kết quả gì. Nó cũng sẽ ném ra một số thông báo lỗi ngoạn mục.

K (ngn / k) , 8 byte

,\(,!0),

Hãy thử trực tuyến!

Lisp thông thường , 39 byte

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

Hãy thử trực tuyến!

Giải trình

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

Tôi thực sự đã có hai câu trả lời khá giống nhau cho điều này, cả hai cùng độ dài. Cả hai đều lấy một chuỗi chung slàm tham số.

Giải pháp đầu tiên:

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

Hãy thử trực tuyến!

Seq.takelấy các nyếu tố đầu tiên của chuỗi.Seq.inittạo ra một chuỗi mới với số đếm (trong trường hợp này) về độ dài của chuỗi scộng với 1 và với mỗi phần tử trong chuỗi sẽ lấy các nphần tử đầu tiên s.

Giải pháp thứ hai:

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

Tương tự như trước, ngoại trừ nó tạo ra một chuỗi từ 0 đến chiều dài của s . Sau đó lấy số lượng các yếu tố từ s.

Hãy thử trực tuyến này quá!

TOÁN, 15 12 byte

3 byte được lưu nhờ @Giuseppe

vin:"G@:)]Xh

Hãy thử nó tại MATL Online .

Do cách MATL hiển thị đầu ra, bạn không thể thấy rõ mảng trống trong mảng ô. Đây là một phiên bản cho thấy đầu ra rõ ràng hơn một chút.

Giải trình

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 PRITAL 22 byte

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

Than , 6 byte

Ｅθ…θκθ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Với chi phí 1 byte có thể yêu cầu Char than in một n+1mảng phân tầng bao gồm đầu vào là phần tử cuối cùng của nó, nhưng đầu ra là như nhau, mặc dù vị trí con trỏ sẽ khác nếu bạn tiếp tục in một thứ khác.

05AB1E , 3 byte

η¯š

Giải trình:

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

Hãy thử trực tuyến!

RAD , 7 byte

(⊂⍬),,\

Hãy thử trực tuyến!

Điều này cũng hoạt động trong Dyalog APL như là một chức năng.

Làm sao?

Điều này hoạt động giống nhau cho cả APL và RAD, do mối quan hệ chặt chẽ của chúng.

• (⊂⍬) mảng trống
• , dự kiến
• ,\ các tiền tố (loại trừ mảng trống.)

Groovy , 37 byte

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

Hãy thử trực tuyến!

Japt , 5 byte

Êò@¯Y

Hãy thử trực tuyến!

Brainfuck , 43 byte

Lấy danh sách các ký tự không null làm đầu vào và trả về tất cả các tiền tố được phân tách bằng dòng mới. Yêu cầu gấp đôi vô hạn hoặc băng quấn.

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

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 39 byte

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

Hãy thử trực tuyến!

F # (Mono) , 45 byte

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

Hãy thử trực tuyến!

Tôi không hoàn toàn chắc chắn nếu điều này là hợp lệ, nhưng có vẻ như nó tuân theo cú pháp "ẩn danh lambda" giống như tôi đã sử dụng trong một số ngôn ngữ khác.

Java 8+ , 86 77 byte

^{-9 byte nhờ Kevin Cruijssen (thoát khỏi quá trình nhập)!}

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

Hãy thử trực tuyến!

Thay thế, 65 byte

Sau đây sẽ in kết quả ra thiết bị xuất chuẩn (do Olivier Grégoire ):

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

Dùng thử trực tuyến

Brachylog , 9 byte

a₀ᶠ~b.hĖ∧

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Giải trình:

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