Dato un elenco finito, restituisce un elenco di tutti i suoi prefissi, incluso un elenco vuoto, in ordine crescente della loro lunghezza.

(Fondamentalmente implementando la funzione Haskell inits.)

Dettagli

• L'elenco di input contiene numeri (o un altro tipo, se più conveniente).
• L'output deve essere un elenco di elenchi .
• L'invio può, ma non deve essere una funzione, è possibile utilizzare qualsiasi I / O predefinito .
• C'è una risposta in CW per tutte le soluzioni banali .

Esempio

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

Modifica: tuttavia un byte più breve con una scansione completamente diversa.

Una funzione anonima che batte leggermente la banale importazione.

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

Provalo online!

• Utilizza =<<per l'abbreviazione (scanr(\_->init)=<<id) l = scanr(\_->init) l l.
• Scansiona un elenco lda destra a sinistra, raccogliendo risultati intermedi con la funzione \_->init.
• Quella funzione ignora gli elementi scansionati (vengono utilizzati solo per ottenere la giusta lunghezza totale per i risultati raccolti), quindi itera davvero applicando inital valore iniziale della scansione, che è anche l.

brainfuck , 21 12 byte

-9 byte grazie ad Arnauld che suggerisce il separatore ÿanziché le nuove righe

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

Provalo online!

Acquisisce byte tramite STDIN senza byte null e stampa una serie di prefissi separati dal ÿcarattere con un ÿcarattere iniziale. Ad esempio, per l'input Prefixes, l'output è ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes.

Per leggibilità, ecco invece una versione con nuove righe .

Spiegazione:

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

Provalo online!

Come?

+--- 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 per tutte le voci banali

Pulito , 19 byte

La versione di Haskell funziona anche in Clean.

import StdLib
inits

Provalo online!

Haskell , 22 byte

import Data.List
inits

Provalo online!

Prolog (SWI) , 6 byte

prefix

Provalo online!

Gelatina , 3 byte

ṭṖƤ

Provalo online!

Come funziona

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

Provalo online!

Spiegazione:

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

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

Provalo online!

Spiegare:

In Perl 6 puoi racchiudere un operatore tra parentesi quadre come modo alternativo per scrivere una riduzione di elenco. [+] @arrayrestituisce la somma degli elementi @array, [*] @arrayrestituisce il prodotto, ecc. È inoltre possibile precedere l'operatore con una barra rovesciata per effettuare una riduzione "triangolare", che alcune lingue chiamano "scan". Quindi [\+] @arrayrestituisce un elenco composto dal primo elemento di @array, quindi dalla somma dei primi due elementi, quindi dalla somma dei primi tre elementi, ecc.

Ecco [\,] @_una riduzione triangolare sull'array di input @_utilizzando l'operatore di costruzione elenco ,. Quindi valuta un elenco di elenchi: il primo elemento di @_, i primi due elementi di @_, ecc. Questo è quasi ciò che è necessario, ma il problema richiede prima un singolo elenco vuoto. Quindi il primo elemento dell'elenco di ritorno è un elenco letterale vuoto (),, quindi la riduzione sull'elenco di input viene appiattita nel resto dell'elenco di ritorno con |.

Python 2 , 32 byte

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

Provalo online!

R , 40 39 byte

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

Provalo online!

-1 byte grazie a digEmAll

L'output del listtipo di R è un po 'strano; utilizza l'indicizzazione sequenziale, quindi ad esempio l'output per

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

Prendendo input come vettore si ottiene invece un formato di output più ordinato, anche se quindi gli input non sono tecnicamente lists.

JavaScript, 36 byte

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

Provalo online!

Mathematica, 22 21 byte

^{-1 byte grazie a Misha Lavrov !}

{}~FoldList@Append~#&

Funzione pura. Prende un elenco come input e restituisce un elenco di elenchi come output. Credo che questa sia la soluzione più breve possibile.

Buccia , 2 byte

Θḣ

Ottiene tutti gli ḣead e quindi antepone Θ(in questo caso []):

Provalo online!

^{(necessita di annotazione del tipo per elenco vuoto: provalo online! )}

J , 5 byte

a:,<\

Provalo online!

PowerShell , 65 byte

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

Provalo online!

PowerShell srotola in modo utile elenchi di elenchi quando l'impostazione predefinita si Write-Outputverifica al completamento del programma, in modo da ottenere un elemento per riga. Prova a -join','per vedere meglio la lista di liste, convertendo le liste interne in stringhe.

(Ab) usa il fatto che il tentativo di emettere un array vuoto (es., @()) Non produce alcun output, quindi un input di array vuoto ha ''come output, poiché non $a[0..$_]produrrà nulla. Emetterà anche alcuni spettacolari messaggi di errore.

K (ngn / k) , 8 byte

,\(,!0),

Provalo online!

Lisp comune , 39 byte

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

Provalo online!

Spiegazione

(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

In realtà ho due risposte abbastanza simili per questo, entrambe della stessa lunghezza. Entrambi prendono una sequenza generica scome parametro.

Prima soluzione:

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

Provalo online!

Seq.takeprende i primi nelementi della sequenza. Seq.initcrea una nuova sequenza con un conteggio (in questo caso) della lunghezza della sequenza spiù 1, e per ogni elemento della sequenza accetta i primi nelementi s.

Seconda soluzione:

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

Simile a prima, tranne per il fatto che crea una sequenza da 0 alla lunghezza di s. Quindi prende quel numero di elementi da s.

Prova anche questo online!

MATL, 15 12 byte

3 byte salvati grazie a @Giuseppe

vin:"G@:)]Xh

Provalo su MATL Online .

A causa del modo in cui MATL visualizza l'output, non è possibile visualizzare esplicitamente l'array vuoto nell'array di celle. Ecco una versione che mostra l'output un po 'più esplicitamente.

Spiegazione

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 byte

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

Carbone , 6 byte

Ｅθ…θκθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

È possibile al costo di 1 byte chiedere a Charcoal di stampare un n+1array di elementi che include l'input come ultimo elemento, ma l'output è lo stesso, anche se la posizione del cursore sarebbe diversa se si continuasse a stampare qualcos'altro.

05AB1E , 3 byte

η¯š

Spiegazione:

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

Provalo online!

RAD , 7 byte

(⊂⍬),,\

Provalo online!

Questo funziona anche in Dyalog APL come funzione.

Come?

Funziona allo stesso modo sia per APL che per RAD, data la loro stretta relazione.

• (⊂⍬) l'array vuoto
• , anteposto a
• ,\ i prefissi (che escludono l'array vuoto.)

Groovy , 37 byte

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

Provalo online!

Japt , 5 byte

Êò@¯Y

Provalo online!

Brainfuck , 43 byte

Prendi un elenco di caratteri non nulli come input e restituisce tutti i prefissi separati da newline. Richiede nastro doppio infinito o avvolgente.

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

Provalo online!

C # (compilatore interattivo Visual C #) , 39 byte

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

Provalo online!

F # (Mono) , 45 byte

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

Provalo online!

Non sono del tutto sicuro se questo sia valido, ma sembra che segua la stessa sintassi "anonima lambda" che ho usato in diverse altre lingue.

Java 8+ , 86 77 byte

^{-9 byte grazie a Kevin Cruijssen (liberarsi dell'importazione)!}

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

Provalo online!

Alternativa, 65 byte

Di seguito verranno stampati i risultati su stdout (a causa di Olivier Grégoire ):

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

Provalo online

Brachylog , 9 byte

a₀ᶠ~b.hĖ∧

Provalo online!

Spiegazione

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)

Rubino , 31 29 byte

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

Provalo online!

Spiegazione:

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