P Pr Pref Pref Prefi Prefixo Prefixo Prefixos


34

Dada uma lista finita, retorne uma lista de todos os seus prefixos, incluindo uma lista vazia, em ordem crescente de comprimento.

(Basicamente implementando a função Haskell inits.)

Detalhes

  • A lista de entrada contém números (ou outro tipo, se for mais conveniente).
  • A saída deve ser uma lista de listas .
  • O envio pode, mas não precisa ser uma função, qualquer E / S padrão pode ser usada.
  • Existe uma resposta CW para todas as soluções triviais .

Exemplo

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

Se um idioma não definir nenhum tipo, exceto caracteres, posso receber a entrada como uma sequência e separar a entrada por novas linhas, no caso de um programa completo?
NieDzejkob

@NieDzejkob Não tenho certeza de que consenso existe para este caso, mas a resposta de Brainfuck parece fazer algo assim.
flawr

Podemos esperar que a lista seja terminada em nulo?

É especialmente comum em C / C ++, sendo o principal o uso de strings.

@ Rogem Se é tão comum, acho que permitir é razoável.
flawr

Respostas:


15

Haskell , 20 bytes

Editar: No entanto, um byte mais curto com uma verificação completamente diferente.

Uma função anônima superando ligeiramente a importação trivial.

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

Experimente online!

  • Usa =<<para a abreviação (scanr(\_->init)=<<id) l = scanr(\_->init) l l.
  • Digitaliza uma lista lda direita para a esquerda, coletando resultados intermediários com a função \_->init.
  • Essa função ignora os elementos varridos (eles são usados ​​apenas para obter o comprimento total correto para os resultados coletados); portanto, ele realmente se aplica initao valor inicial da varredura, o que também é l.

13

brainfuck , 21 12 bytes

-9 bytes graças a Arnauld sugerindo o separador em ÿvez de novas linhas

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

Experimente online!

Toma bytes por STDIN sem bytes nulos e imprime uma série de prefixos separados pelo ÿcaractere com um ÿcaractere à esquerda . Por exemplo, para a entrada Prefixes, a saída é ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes.

Para facilitar a leitura, aqui está uma versão com novas linhas .

Explicação:

-              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

1
Isso funciona apenas em implementações BF com células de quebra automática não assinadas de 8 bits.
Dev

11

JavaScript (ES6), 33 bytes

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

Experimente online!

Quão?

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

uau, isso é um nível totalmente novo de explicação de código, trabalho incrível: O
Brian H.

@BrianH. Obrigado! Tarefas simples são boas oportunidades para escrever explicações detalhadas que não podem ser apresentadas em código mais denso.
Arnauld

Você fez isso à mão? ou você recebeu ajuda de algum software estranho sobre o qual eu nunca ouvi falar?
101318 Brian H.

2
Apenas o Notepad ++ com alguma edição no modo de coluna .
Arnauld


6

Gelatina , 3 bytes

ṭṖƤ

Experimente online!

Como funciona

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


6

Perl 6 , 13 bytes

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

Experimente online!

Explicar:

No Perl 6, você pode agrupar um operador entre colchetes como uma maneira alternativa de escrever uma redução de lista. [+] @arrayretorna a soma dos elementos @array, [*] @arrayretorna o produto etc. Você também pode preceder o operador com uma barra invertida para fazer uma redução "triangular", que alguns idiomas chamam de "varredura". Então, [\+] @arrayretorna uma lista que consiste no primeiro elemento de@array , em seguida, a soma dos dois primeiros elementos, a soma dos três primeiros elementos etc.

Aqui [\,] @_está uma redução triangular sobre a matriz de entrada @_usando o operador de construção de lista ,. Portanto, ele avalia uma lista de listas: o primeiro elemento de @_, os dois primeiros elementos de @_etc. Isso é quase o necessário, mas o problema exige uma única lista vazia primeiro. Portanto, o primeiro elemento da lista de retorno é uma lista literal vazia (),, e a redução sobre a lista de entrada é achatada no restante da lista de retorno com |.


2
O_o o que está acontecendo aqui
somente ASCII



5

R , 40 39 bytes

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

Experimente online!

-1 byte graças a digEmAll

A saída do listtipo R é um pouco estranha; ele usa indexação sequencial; portanto, por exemplo, a saída para

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

A entrada como vetor fornece um formato de saída mais limpo, embora as entradas não sejam tecnicamente lists.



@digEmAll thanks!
21418 Giuseppe


4

Mathematica, 22 21 bytes

-1 byte graças a Misha Lavrov !

{}~FoldList@Append~#&

Função pura. Pega uma lista como entrada e retorna uma lista de listas como saída. Eu acredito que esta é a solução mais curta possível.


Podemos escrever a mesma solução de forma mais compacta que {}~FoldList@Append~#&.
Misha Lavrov

@MishaLavrov Thanks! Não pensei em usar a forma de 1 + 2 argumentos com curry dessa maneira.
LegionMammal978



3

PowerShell , 65 bytes

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

Experimente online!

O PowerShell desenrola útil listas de listas quando o padrão Write-Outputocorre na conclusão do programa, para que você obtenha um item por linha. Prenda a -join','para ver melhor a lista de listas, convertendo as listas internas em seqüências de caracteres.

(Ab) usa o fato de que a tentativa de saída de uma matriz vazia (por exemplo, @()) resulta em nenhuma saída; portanto, uma entrada de matriz vazia apenas tem ''como saída, uma vez que $a[0..$_]isso resultará em nada. Ele também emitirá algumas mensagens de erro espetaculares.


Envolvê-lo em parênteses, em vez de atribuí-lo, economiza 20 bytes . A menos que você não pense que isso conta como retornando uma lista de listas. Eu sempre fui confusa nessa distinção.
Veskah

@veskah Sim, isso é quase o que eu tinha antes da minha edição desta versão. O problema da sua solução ou da minha solução anterior - ela não retorna uma lista de listas. TIO1 vs TIO2
AdmBorkBork

3

K (ngn / k) , 8 bytes

,\(,!0),

Experimente online!


1
Isso é algum tipo de vodu. ,\(,()),no K4. Juntando-se ao nulo alistado junto à entrada alistada? howsitwork?
Streetster 07/12

1
@streetster ()é uma lista vazia. (,()),xanexa-o a x. finalmente ,\ faz uma varredura concat. o xé omitido para formar uma composição. observe que o final ,é diádico; portanto, é "concat", não "alistado".
NGN

1
@streetster em k4 pode ser um byte mais curta: 1_',\0,mas meu analisador não é inteligente o suficiente para lidar com isso ...
NGN

3

Lisp comum , 39 bytes

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

Experimente online!

Explicação

(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

3

F #, 53 bytes

Na verdade, tenho duas respostas bastante semelhantes para isso, ambas do mesmo tamanho. Ambos pegam uma sequência genéricas como parâmetro.

Primeira solução:

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

Experimente online!

Seq.takepega os primeiros nelementos da sequência. Seq.initcria uma nova sequência com uma contagem (nesse caso) do comprimento da sequência smais 1 e, para cada elemento da sequência, recebe os primeiros nelementos s.

Segunda solução:

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

Semelhante a antes, exceto que cria uma sequência de 0 ao comprimento de s. Então pega esse número de elementos de s.

Experimente isso online também!


fun s->Seq.map(fun n->Seq.take n s){0..Seq.length s} salva 1 byte
Modalidade de Ignorância

3

MATL, 15 12 bytes

3 bytes salvos graças a @Giuseppe

vin:"G@:)]Xh

Experimente no MATL Online .

Devido à maneira como o MATL exibe a saída, você não pode ver explicitamente a matriz vazia na matriz de células. Aqui está uma versão que mostra a saída um pouco mais explicitamente.

Explicação

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

use em vvez de []. E não :usa 1como o primeiro argumento padrão? Portanto, isso pode ser vin:"G@:)]Xhde 12 bytes.
Giuseppe

@Giuseppe Thanks! Meu MATL está um pouco enferrujado, parece :(
Suever


2

Carvão , 6 bytes

Eθ…θκθ

Experimente online! Link é a versão detalhada do código. Explicação:

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

É possível, a um custo de 1 byte, solicitar ao Charcoal para imprimir uma n+1matriz de elementos que inclua a entrada como seu último elemento, mas a saída é a mesma, embora a posição do cursor seja diferente se você imprimir outra coisa.



2

RAD , 7 bytes

(⊂⍬),,\

Experimente online!

Isso também funciona no Dyalog APL como uma função.

Quão?

Isso funciona da mesma forma para o APL e o RAD, dada a sua estreita relação.

  • (⊂⍬) a matriz vazia
  • , anexado a
  • ,\ os prefixos (que excluem a matriz vazia).



2

brainfuck , 43 bytes

Pegue uma lista de caracteres não nulos como entrada e retorne todos os prefixos separados por nova linha. Requer fita dupla-infinita ou de embrulho.

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

Experimente online!


Outra resposta me superou em mais da metade, porque não pensei em imprimir durante a leitura. Obviamente, esse método não funcionará com a impressão de sufixos crescentes.
usar o seguinte comando

40 bytes com alguma reorganização
Jo King

2

C # (compilador interativo do Visual C #) , 39 bytes

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

Experimente online!


Você precisa incluir o uso System.Linq; no seu bytecount. E parece que parte da sua lógica de saída está na saída das matrizes. Porque a matriz vazia apenas retorna a matriz vazia.
LiefdeWen

@LiefdeWen - meu entendimento é que, como esse intérprete inclui uma referência a System.Linq, não preciso incluir isso na contagem de bytes. Minha submissão seria considerada um idioma diferente do que digamos .NET Core. github.com/dotnet/roslyn/wiki/C%23-Interactive-Walkthrough - Você mencionou a impressão, que é uma questão separada, gostaria de obter clareza sobre isso primeiro.
quer

No que diz respeito à impressão, aqui está uma versão que basicamente despeja o resultado no console - tio.run/##XY29CsIwGEX3PEXGBGKhtVt/… - não tão bonito com certeza! A pergunta que tenho é quando é aceitável a utilização Arrayvs IListvs IEnumerable.
quer

2

F # (Mono) , 45 bytes

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

Experimente online!

Não tenho muita certeza se isso é válido, mas parece que segue a mesma sintaxe "anônima lambda" que pareço usada em vários outros idiomas.


2

Java 8+ , 86 77 bytes

-9 bytes graças a Kevin Cruijssen (livrar-se da importação)!

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

Experimente online!

Alternativa, 65 bytes

A seguir, os resultados serão impressos no stdout (devido a Olivier Grégoire ):

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

Experimente online


Você pode jogar com 77 bytes usando apenas java.util.stream.IntStreamdiretamente e soltar a importação.
Kevin Cruijssen

@KevinCruijssen: Oh, obrigado! Eu nem sabia que isso era possível, isso certamente é útil (pelo menos para fins de golfe).
ბიმო

x->{for(int i=0;i<=x.size();)System.out.println(x.subList(0,i++));}( 67 bytes ). Isso é impresso em vez de usar fluxos. A impressão geralmente é a maneira mais curta de produzir estruturas complexas.
Olivier Grégoire

@ OlivierGrégoire: Nesse caso, você provavelmente pode se safar, System.out.printpois a saída ainda é inequívoca.
ბიმო

@ BMO De fato, isso seria possível!
Olivier Grégoire

2

Braquilog , 9 bytes

a₀ᶠ~b.hĖ∧

Experimente online!

Explicação

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)

2

Ruby , 31 29 bytes

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

Experimente online!

Explicação:

->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
  }
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.