Sonlu bir liste verildiğinde, boş bir liste de dahil olmak üzere tüm öneklerinin uzunluğunu artan bir sırayla döndürün.

(Temel olarak Haskell işlevini uygulamak inits.)

ayrıntılar

• Giriş listesi, sayılar (veya daha uygunsa başka bir tür) içerir.
• Çıktı bir liste listesi olmalıdır .
• Gönderme bir işlev olmak zorunda olabilir, ancak herhangi bir varsayılan G / Ç kullanılabilir.
• Tüm önemsiz çözümler için bir CW cevabı var .

Örnek

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

Düzenleme: Tamamen farklı bir tarama ile henüz bir bayt daha kısa.

Önemsiz ithalatı hafifçe yenen isimsiz bir işlev.

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

Çevrimiçi deneyin!

• =<<Kısaltma için kullanır (scanr(\_->init)=<<id) l = scanr(\_->init) l l.
• Listeden lsağdan sola tarar , işlevle ara sonuçları toplar \_->init.
• Bu işlev, taranan öğeleri dikkate almaz (yalnızca toplanan sonuçlar için doğru toplam uzunluğu elde etmek için kullanılırlar), bu nedenle init, taramanın başlangıç ​​değerine de başvurmayı gerçekten yineler l.

brainfuck , 21 12 bayt

Arnauld sayesinde -9 bayt ÿ, yeni satırlar yerine ayırıcıyı önerdi

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

Çevrimiçi deneyin!

STDIN aracılığıyla boş bayt içermeyen baytları alır ve ÿkarakterin baş ÿkarakteriyle ayrılmış bir dizi önekini yazdırır . Örneğin, giriş Prefixesiçin çıktı ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes.

Okunabilirlik için, burada bunun yerine yeni satırları olan bir sürüm .

Açıklama:

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

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

Çevrimiçi deneyin!

Nasıl?

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

Tüm önemsiz girişler için CW

Temiz , 19 bayt

Haskell sürümü de Temiz olarak çalışır.

import StdLib
inits

Çevrimiçi deneyin!

Haskell , 22 bayt

import Data.List
inits

Çevrimiçi deneyin!

Prolog (SWI) , 6 bayt

prefix

Çevrimiçi deneyin!

Jöle , 3 bayt

ṭṖƤ

Çevrimiçi deneyin!

Nasıl çalışır

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

²£¯Y

Çevrimiçi deneyin!

Açıklama:

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

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

Çevrimiçi deneyin!

Açıklamak için:

Perl 6'da, bir operatörü köşeli parantez içinde liste azaltma yazmanın alternatif bir yolu olarak sarabilirsiniz. [+] @arraydöner elemanların toplamı @array, [*] @arrayürünü, vb Ayrıca bazı diller dediğimiz bir "üçgen" azaltma yapmak için önlerine operatöre öncesinde yapabilirsiniz döndürür "tarama". Böylece [\+] @arrayilk öğenin @array, sonra ilk iki öğenin toplamının, sonra ilk üç öğenin toplamının vb.

İşte [\,] @_girdi dizisi üzerinde üçgen azalma olduğu @_liste inşaat operatörü kullanılarak ,. Bu yüzden listelerin bir listesini değerlendirir: ilk öğe @_, ilk iki öğe @_, vb. Neredeyse gerekli olan budur ancak sorun ilk önce boş bir liste gerektirir. Böylece, geri dönüş listesinin ilk elemanı değişmez bir boş listedir (),, daha sonra giriş listesindeki azalma, geri dönüş listesinin geri kalanı ile düzleştirilir |.

Python 2,32 bayt

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

Çevrimiçi deneyin!

R , 40 39 bayt

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

Çevrimiçi deneyin!

DigEmAll sayesinde -1 bayt

R'nin listtürünün çıktısı biraz garip; sıralı indeksleme kullanır, örneğin

list(1,2) olduğu

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

Girdiyi bir vektör olarak almak , daha sonra girdilerin teknik olarak lists olmamasına rağmen daha temiz bir çıktı formatı verir .

JavaScript, 36 bayt

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

Çevrimiçi deneyin!

Mathematica, 22 21 bayt

^{Misha Lavrov sayesinde -1 bayt !}

{}~FoldList@Append~#&

Saf işlevi. Listeyi girdi olarak alır ve listeler halinde çıktı olarak döndürür. Bunun mümkün olan en kısa çözüm olduğuna inanıyorum.

Kabuğu , 2 bayt

Θḣ

Bütün ḣkızları alır ve sonra hazırlar Θ(bu durumda []):

Çevrimiçi deneyin!

^{(boş liste için açıklama eklemesi gerekiyor: Çevrimiçi deneyin! )}

J , 5 bayt

a:,<\

Çevrimiçi deneyin!

PowerShell , 65 bayt

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

Çevrimiçi deneyin!

PowerShell , varsayılan program bitiminde gerçekleştiğinde liste listelerini yararlı bir şekilde kaldırır Write-Output, böylece her satıra bir öğe alırsınız. Üstüne atmak-join','İç listeleri dizgelere dönüştürerek liste listesini daha iyi görmek için .

(Ab), boş bir dizi (örneğin @()) çıktısını almaya çalışmanın çıktı vermemesi gerçeğini kullanır , bu nedenle boş bir dizi girişinin , sonuç hiçbir sonuç vermeyeceğinden '', çıktı gibi olmasını sağlar $a[0..$_]. Aynı zamanda bazı muhteşem hata mesajları atıyor.

K (ngn / k) , 8 bayt

,\(,!0),

Çevrimiçi deneyin!

Ortak Lisp , 39 bayt

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

Çevrimiçi deneyin!

açıklama

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

Aslında ikisi de aynı uzunlukta olan iki benzer cevabım var. Her ikisi de sparametre olarak genel bir sekans alır .

İlk çözüm:

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

Çevrimiçi deneyin!

Seq.takendizinin ilk elemanlarını alır . Seq.initdizi sartı 1 uzunluğunun sayımıyla (bu durumda) yeni bir dizi oluşturur ve dizideki her öğe için ilk nöğeleri alır .s .

İkinci çözüm:

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

Daha önce olduğu gibi, 0'dan 0'a kadar bir dizi oluşturur s. Sonra bu sayı elemanlarını alır.s .

Bunu da çevrimiçi deneyin!

Matl, 15 12 bayt

@Giuseppe sayesinde 3 bayt kurtarıldı

vin:"G@:)]Xh

MATL Online'da deneyin .

MATL'nin çıktıyı görüntülemesi nedeniyle, boş diziyi açıkça hücre dizisinde göremezsiniz. İşte çıktıyı biraz daha açık bir şekilde gösteren sürüm.

açıklama

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 bayt

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

Kömür , 6 bayt

Ｅθ…θκθ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

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

Charcoal'dan bir baskı almasını istemek 1 byte pahasına mümkündür. n+1 , girişi son öğesi olarak içeren -element dizisini , ancak imleç konumu daha sonra başka bir şey yazdırmaya devam ederseniz, imleç konumu farklı olmasına rağmen, .

05AB1E , 3 bayt

η¯š

Açıklama:

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

Çevrimiçi deneyin!

RAD , 7 bayt

(⊂⍬),,\

Çevrimiçi deneyin!

Bu aynı zamanda Dyalog APL'de bir fonksiyon olarak da çalışır.

Nasıl?

Bu, yakın ilişkileri göz önüne alındığında hem APL hem RAD için aynı şekilde çalışır.

• (⊂⍬) boş dizi
• , için hazır
• ,\ önek (boş diziyi hariç tutar.)

Harika , 37 bayt

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

Çevrimiçi deneyin!

Japt , 5 bayt

Êò@¯Y

Çevrimiçi deneyin!

brainfuck , 43 bayt

Boş olmayan karakterlerin listesini girdi olarak alın ve tüm önekleri newline ile ayırarak döndürür. Çift sonsuz veya sarma bandı gerektirir.

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

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 39 bayt

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

Çevrimiçi deneyin!

F # (Mono) , 45 bayt

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

Çevrimiçi deneyin!

Bunun geçerli olup olmadığından tam olarak emin değilim, ancak diğer dillerde de kullandığım aynı “anonim lambda” sözdizimini izliyor gibi görünüyor.

Java 8+ , 86 77 bayt

^{-9 byte Kevin Cruijssen sayesinde (ithalattan kurtulmak)!}

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

Çevrimiçi deneyin!

Alternatif, 65 bayt

Aşağıdakiler stdout'a sonuçları basacaktır ( Olivier Grégoire nedeniyle ):

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

Çevrimiçi deneyin

Brachylog , 9 bayt

a₀ᶠ~b.hĖ∧

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Açıklama:

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