З огляду на деякий кінцевий список, поверніть список усіх його префіксів, включаючи порожній список, у порядку зростання їх довжини.

(В основному реалізація функції Haskell inits.)

Деталі

• Список вводу містить цифри (або більше, якщо це зручніше).
• Вихід повинен бути списком списків .
• Подання може, але не повинно бути функцією, можна використовувати будь-який ввід / вивід за замовчуванням .
• Існує відповідь 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.

мозковий ебать , 21 12 байт

-9 байт завдяки Арнольду запропонував роздільник ÿзамість нових рядків

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

Спробуйте в Інтернеті!

Бере байти через 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

Спробуйте в Інтернеті!

Хаскелл , 22 байти

import Data.List
inits

Спробуйте в Інтернеті!

Пролог (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

Приймаючи введення як вектор, натомість дає більш акуратний вихідний формат, хоча тоді введення технічно не є list.

JavaScript, 36 байт

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

Спробуйте в Інтернеті!

Математика, 22 21 байт

^{-1 байт дякую Міші Лаврову !}

{}~FoldList@Append~#&

Чиста функція. Приймає список як вхідний і повертає список списків як вихідний. Я вважаю, що це найкоротше можливе рішення.

Лушпиння , 2 байти

Θḣ

Отримує всі ḣEAD, а потім попередньо Θ(в цьому випадку []):

Спробуйте в Інтернеті!

^{(для порожнього списку потрібна примітка: Спробуйте в Інтернеті! )}

J , 5 байт

a:,<\

Спробуйте в Інтернеті!

PowerShell , 65 байт

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

Спробуйте в Інтернеті!

PowerShell корисно розгортає списки списків, коли за замовчуванням Write-Outputвідбувається по завершенні програми, тому ви отримуєте один елемент на рядок. Натисніть на a, -join','щоб краще переглянути список списків, перетворивши внутрішні списки в рядки.

(Ab) використовує той факт, що спроба вивести порожній масив (наприклад, @()) не призводить до відсутності виводу, тому порожній вхід масиву просто має ''як вихід, оскільки $a[0..$_]результат не призведе до нічого. Це також викине деякі вражаючі повідомлення про помилки.

K (нг / к) , 8 байт

,\(,!0),

Спробуйте в Інтернеті!

Лист звичайний , 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 байт

3 байти збережено завдяки @Giuseppe

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 байт можна попросити вугілля надрукувати n+1масив -елемент, який включає вхід як його останній елемент, але вихід такий же, хоча положення курсору було б іншим, якби потім ви надрукували щось інше.

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 # Interactive Compiler) , 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]

Спробуйте в Інтернеті!

Я не зовсім впевнений, що це дійсно, але здається, що він відповідає тому самому синтаксису "анонімного лямбда", який я, здається, використовував у кількох інших мовах.

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 (завдяки Олів’є Грегоаре ):

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

Спробуйте в Інтернеті

Брахілог , 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
  }
}