Implementando uma pilha

44

Não acredito que ainda não tenhamos isso. É uma das estruturas de dados mais importantes da programação, mas ainda assim simples o suficiente para implementá-lo em um código-golfe :

Desafio

Sua tarefa é implementar uma pilha que permita empurrar e estourar números, testar sua implementação e manter a E / S simples, usaremos a seguinte configuração:

  • A entrada será uma lista de números inteiros não negativos

Todo número inteiro positivo n indica um e todo indica um - descartando o elemento superior. 0 pop ()push(n)0pop()

  • A saída será a pilha resultante

Exemplo

Por exemplo, se :[12,3,0,101,11,1,0,0,14,0,28]

12[12]3[3,12]0 0[12]101[101,12]11[11,101,12]1[1,11,101,12]0 0[11,101,12]0 0[101,12]14[14,101,12]0 0[101,12]28.[28.,101,12]

A saída será:[28.,101,12]

Regras

  • A entrada será uma lista de números inteiros não negativos em qualquer formato de E / S padrão
    • você pode usar um número inteiro negativo para indicar o final de um fluxo de números inteiros
  • A saída será uma lista / matriz / .. da pilha resultante
    • Se você escolher onde o elemento principal estará (no início ou no final), a saída precisa ser consistente
    • a saída é flexível (por exemplo, números inteiros separados por novas linhas seriam bons), a única coisa que importa é a ordem
    • você pode usar um número inteiro negativo para indicar a parte inferior da pilha
  • Você está garantido que nunca haverá um quando a pilha estiver vazia0 0

Exemplos

[] -> []
[1] -> [1]
[1,0,2] -> [2]
[4,0,1,12] -> [12,1]
[8,3,1,2,3] -> [3,2,1,3,8]
[1,3,7,0,0,0] -> []
[13,0,13,10,1,0,1005,5,0,0,0] -> [13]
[12,3,0,101,11,1,0,0,14,0,28] -> [28,101,12]
code-golf  array-manipulation  stack  data-structures 
— ბიმო
fonte
12
Deve-se notar que, dadas as condições, não é necessário implementar a pilha.
— 31818 Jeff Zeitlin
Se você quiser que alguém realmente implemente uma pilha, pode precisar colocar algo na Sandbox.
— Mbomb007
@ mbomb007: É permitido: "sua escolha onde o elemento superior estará (no início ou no final)"
— #
@ mbomb007: Não seria mais difícil se você tivesse que reverter a entrada, seria? Além disso, se você considerar a configuração como uma pilha que define qual é a parte superior e a parte inferior e por que uma definição deve ser menos arbitrária?
— ბიმო
@ OMᗺ Porque a entrada se parece bastante com uma pilha / lista / array. Agora, todo o desafio é basicamente remover qualquer número seguido por um zero.
— mbomb007

Respostas:

19

MATL , 6 bytes

"@?@}x

Entrada é um vetor de linha de números.

A pilha final é mostrada de cabeça para baixo, com o elemento mais recente abaixo.

Experimente online! Ou verifique todos os casos de teste .

Explicação

"         % For each element in the input (implicit)
  @       %   Push current element
  ?       %   If non-zero (this consumes the current element)
    @     %     Push current element again
  }       %   Else
    x     %     Delete most recent element
          %   End (implicit)
          % End (implicit)
          % Display (implicit)
— Luis Mendo
fonte
13

Java (JDK 10) , 42 bytes

Como "[a] saída é flexível [...], a única coisa que importa é a ordem", isso altera a matriz de entrada em uma 0matriz terminada. Exemplo: [1,0,2]retornará o [2,0,2]que deve ser interpretado como = .[2,0,2][2]

a->{int s=0;for(int v:a)a[v>0?s++:--s]=v;}

Experimente online!

Versões prévias:

Java (JDK 10) , 60 bytes

l->{for(int i;(i=l.indexOf(0))>0;l.remove(i))l.remove(--i);}

Experimente online!

Créditos:

Se eu posso terminar o programa com erros: 55 bytes

(embora tudo esteja corretamente modificado)

l->{for(int i;;l.remove(--i))l.remove(i=l.indexOf(0));}

Experimente online!

— Olivier Grégoire
fonte
4
Isto é bastante impressionante. Você pode perder 1 byte usando, >0pois nunca haverá zero no início da lista (o que implicaria que o topo da pilha estivesse -1).
— OOBalance
@OOBalance De fato, eu não tinha pensado nisso., Obrigado!
— Olivier Grégoire
12

Sed, 17 bytes

:;s/[0-9]\+,0//;t

-3 bytes graças a @ OMᗺ, -1 graças a @eggyal

Como você nunca deve exibir uma lista vazia, você não precisa de nada além de uma máquina de estados finitos iterada. Expressões regulares são uma ferramenta para construir máquinas de estados finitos e sedpodem iterar. É uma partida feita no céu.

Recebe a entrada do stdin, da seguinte forma:

echo '[12,3,0,101,11,1,0,0,14,0,28]' | sed ':;s/[0-9]\+,0,//;t'

Produz a pilha no sentido inverso:

[12,101,28]

Pode ser menor em dois bytes se meu local sedentender inerentemente as classes de caracteres \d, mas não por algum motivo.

— Tacroy
fonte
1
Bem-vindo ao PPCG! Bom, o meu era mais longo (usando formato de entrada diferente) .. Btw. você pode usar um rótulo vazio, já que usa apenas 1 e como itera o processo, isso gé redundante - economizando 4 bytes: Experimente on-line!
— ბიმო
OG não é redundante! Isso faz com que a pior complexidade do tempo de execução dependa da profundidade dos pops seqüenciais, em vez do número de pops! Não que a eficiência é importante no golfe código :)
— Tacroy
1
Sua última frase responde à pergunta sobre redundância: P Btw. como você contou os bytes? Eu tenho 18, provavelmente você incluiu uma nova linha no final ou algo assim.
— ბიმო
Sim, era uma nova linha.
— Tacroy
1
Se o elemento final da entrada for 0, ele não será correspondido pelo seu regex.
— eggyal 28/07
12

PowerShell , 46 41 40 bytes

$args|%{$x,$a=&({1,$_+$a},{$a})[!$_]};$a

Experimente online!

Recebe entrada por meio de splatting, por exemplo $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @z, que no TIO se manifesta como argumentos separados.

$args|%{$x,$a=&({1,$_+$a},{$a})[!$_]};$a    # Full program
$args                                       # Take input via splatting
     |%{                            };      # Loop through each item
              &(              )[!$_]        # Pseudo-ternary, if input is 0 this is 1
        $x,$a=            {$a}              # ... which will pop the first item into $x
           $a=  { ,$_+$a}                   # Else, we append the first item
        $x   =   1                          # ... and drop a dummy value into $x
                                      $a    # Leave $a on pipeline; implicit output

-5 bytes graças ao mazzy.
Troca de -1 byte $_para1

— AdmBorkBork
fonte
Um splatting economiza 3 bytes $agrs? :)
— Mazzy
-2 bytes $args|%{$x,$a=&({$_,$_+$a},{$a})[!$_]};$a?
— Mazzy
1
@mazzy Sim, e tínhamos acabado de falar sobre respingos! Eu já esqueci! lol obrigado!
— AdmBorkBork 27/07
Não splatting ser .\implement-stack.ps1 @z(não $z), caso contrário, você está apenas passando um array como o primeiro único argumento /
— pinkfloydx33
@ pinkfloydx33 Sim. Erro de digitação da minha parte.
— AdmBorkBork
11

C (gcc) , 62 60 56 55 bytes

-2 -6 bytes graças a l4m2

-1 byte graças ao ceilingcat .

Usa a noção permitida de -1 matrizes finalizadas. f()chama a si próprio de forma recursiva, até ficar totalmente enrolado, e depois segue pela lista. rcontrola quantos números descartar antes de imprimir algo. Aumenta se o item atual for 0, diminui caso contrário. Se 0, não precisamos descartar e podemos imprimir o número.

r;f(int*l){~*l?f(l+1),*l?r?r--:printf("%d ",*l):r++:0;}

Experimente online!

— gastropner
fonte
f(l)int*l;=> f(int*l)?
— L4m2 28/07/19
@ l4m2 Ah, saúde! Provavelmente um remanescente de dias anteriores, mais carregados de variáveis.
— Gastropner 28/07/19
o r=0parece inútil
— l4m2
@ l4m2 Sim, boa captura.
— Gastropner 28/07/19
10

R , 45 bytes

o={};for(e in scan())o="if"(e,c(e,o),o[-1]);o

Experimente online!

  • -4 bytes graças a @ Giuseppe
— digEmAll
fonte
1
48 bytes - abusando Ftambém irá levá-lo a 48 bytes, mas este é imho mais limpo
— Giuseppe
Não sei como perdi a inversão if-else: facepalm: ... obrigado!
— digEmAll
— Giuseppe
1
Uma R+pryrea Reducesolução é 44 bytes
— jayce
@ JayCe: para ser sincero, prefiro manter a solução "base-R" ... mas fique à vontade para publicá-la como sua própria resposta! ;)
— digEmAll
9

Gelatina , 6 bytes

ṣ0Ṗ;¥/

Experimente online!

Como funciona

ṣ0Ṗ;¥/  Main link. Argument: A (array)

ṣ0      Split A at zeroes.
    ¥/  Left-reduce the resulting 2D array by this dyadic chain:
  Ṗ       Pop; discard the last element of the left argument.
   ;      Concatenate the result with the right argument.
— Dennis
fonte
Isso simulará três pops se houver três zeros consecutivos?
— WGroleau 28/07/19
Sim. [1,3,7,0,0,0], por exemplo, é dividido [[1,3,7],[],[],[]]e cada passo da redução esquerda é exibido no elemento da matriz esquerda.
— Dennis
9

Flak cerebral , 40 36 bytes

([]){{}{({}<>)<>}([]){{}<>}{}([])}<>

Experimente online!

Obrigado a @Nitrodon por -4 bytes.

Como o Brain-Flak já usa pilhas, este é um bom quebra-cabeça para o Brain-Flak.

([]){   while items on stack
    {}      pop stack count
    {       if top element is non-zero
        ({}<>)<> push it on the other stack
    }
    if we're here the stack is either empty or there's a 0 on the stack

    ([])    so, count the stack again
    {{}<>{}<>} if there are items left on the stack, pop the stack count and the last item of the other stack
    {} pop the zero or the stack count
    ([]) count the stack again for next round
}
<>  go to the output stack
— Dorian
fonte
2
Nesse caso específico, {{}<>{}<>}pode ser reduzido para {{}<>}.
— Nitrodon
@Nitrodon Obrigado. Você pode explicar por que isso ainda funciona? Ele não volta para a pilha de entrada no loop.
— Dorian
1
A parte superior da pilha de saída é garantida como diferente de zero, portanto o loop reduzido é executado 0 ou 2 vezes.
— Nitrodon
8

Wolfram Language (Mathematica) , 28 bytes

#//.{a___,b_,0,c___}:>{a,c}&

Experimente online!

— JungHwan Min
fonte
(isso só funciona porque "O padrão é ter padrões anteriores coincidir com seqüências mais curtas" , por isso não há necessidade de assegurar que bé diferente de zero.)
— user202729
@ user202729 Sim. A correspondência de padrões do Mathematica não é gananciosa, portanto, tenta corresponder o mais curto possível a___primeiro. Pode-se ver isso tentando ReplaceList[#, {a___, b_, 0, c___} :> {a, c}] &. Em uma nota relacionada, StringReplaceé realmente ganancioso, por isso esta submissão não iria trabalhar com StringReplace(com padrão como a___~~b_~~"0"~~c___)
— JungHwan Min
8

Python 2 , 48 bytes

s=[]
for x in input():s=([x]+s)[2*0**x:]
print s

Experimente online!

— xnor
fonte
Alguma chance de você explicar como isso funciona? Eu tenho tentado resolver isso pela última meia hora! Certamente 2*0**xsempre será 0. Obviamente estou perdendo alguma coisa.
— ElPedro
1
@ElPedro Não é zero quando x=0, caso em que é 2.
— xnor
Ah, entendo o que você quer dizer. Acho que estava procurando demais e perdendo o óbvio! Obrigado e ótima resposta.
— ElPedro
7

Espaço em branco , 89 bytes

[N
S S N
_Create_Label_LOOP_1][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve][S N
S _Duplicate_input][N
T   T   S 
_If_neg_Jump_to_Label_EXIT][S N
S _Duplicate_input][N
T   S T N
_If_0_Jump_to_Label_DROP][N
S N
N
_Jump_to_Label_LOOP_1][N
S S S N
_Create_Label_EXIT][S N
N
_Discard_top][N
S S S S N
_Create_Label_LOOP_2][T N
S T _Print_as_integer][S S S T  S T S N
_Push_10_newline][T N
S S _Print_as_character][N
S T S S N
_Jump_to_Label_LOOP_2][N
S S T   N
_Create_Label_DROP][S N
N
_Discard_top][S N
N
_Discard_top][N
S N
N
_Jump_to_Label_LOOP_1]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Separa a nova linha da lista de entradas -1para indicar que terminamos as entradas.

Experimente online .

Explicação em pseudo-código:

Start LOOP_1:
  Integer i = STDIN as integer
  If(i is negative):
    Call function EXIT
  If(i is 0):
    Call function DROP
  Go to next iteration of LOOP_1

function EXIT:
  Start LOOP_2:
    Pop and print top as integer
    Print newline
    Go to next iteration of LOOP_2

function DROP:
  Drop the top of the stack
  Go to next iteration of LOOP_1
— Kevin Cruijssen
fonte
6

JavaScript, 40 bytes

Saídas na ordem inversa.

a=>a.map(x=>x?o.push(x):o.pop(),o=[])&&o

Experimente online

1 byte salvo graças a Herman L .

— Shaggy
fonte
a=>a.map(x=>x?o.push(x):o.pop(),o=[])&&oé um byte menor
— Herman L
@HermanL: D'oh! Claro que é! Obrigado. Estava usando (un)shiftantes de detectar que a saída poderia ser revertida.
— 34
Isso funciona porque oé referenciado no retorno de chamada após ser definido no segundo argumento.
— Matth
6

05AB1E , 9 bytes

vy>i¨ëy)˜

Experimente online ou verifique todos os casos de teste .

Explicação:

v        # For-each of the items in the input-list:
 y>i     #  If the current item is 0:
  ¨      #   Pop the top item of the list
 ë       #  Else:
  y      #   Push the current item to the stack
   )     #   Wrap the entire stack into a list
         #    i.e. 12 → [12]
         #    i.e. [12] and 3 → [[12], 3]
    ˜    #   Flatten the stack
         #    i.e. [[12], 3] → [12, 3]
         # (and output the list implicitly after the loop)

Alternativa de 9 bytes :

vy_i\ëy])

Experimente on-line para verificar todos os casos de teste .

Explicação:

v        # For-each of the items in the input-list:
 y_i     #  If the current item is 0:
  \      #   Discard top item of the stack
 ë       #  Else:
  y      #   Push the current item to the stack
]        # Close both the if-else and for-each (short for `}}`)
 )       # Wrap the entire stack into a list (and output implicitly)

PS: Se a saída deveria ter sido revertida para corresponder aos casos de teste na descrição do desafio, podemos adicionar um final Rà segunda versão (portanto 10 bytes ), que reverte a lista. Experimente online ou verifique todos os casos de teste .

— Kevin Cruijssen
fonte
5

Retina 0.8.2 , 18 bytes

^
,
+1`,\d+,0

^,

Experimente online! O link inclui casos de teste. Explicação:

^
,

Prefixe um extra ,.

+1`,\d+,0

Processe todas as operações pop.

^,

Remova o ,se ainda estiver lá.

A reversão dos números custaria 8 bytes extras:

O^$`\d+
— Neil
fonte
O que simplesmente substitui todas as <number>, 0sub-listas por nada.
— user202729
5

Brain-Flak , 36 bytes

([]){{}{(({}<>))(<>)}{}<>{}<>([])}<>

Experimente online!

#Let's call the two stacks in and out

([]){{}                      ([])}    # while not in.empty()
       {        (  )}{}               # if in.peek() != 0
        (({}<>)) <>                   # a = in.pop; out.push(a); out.push(a)
                       <>{}<>         # out.pop()
                                  <>  # switch to out to be printed
— Riley
fonte
5

V , 10 bytes

ò/ 0⏎b2dw0

Experimente online!

Explicação

ò           " run the following, until an error occurs
 / 0⏎       " | goto next zero with space in front (errors if none)
     b      " | jump one word back (to the beginning of element to pop)
      2     " | twice (element & zero itself)
       dw   " | | delete word
         0  " | goto beginning of line

Equivalente no Vim , 16 bytes

qq/ 0⏎b2dw0@qq@q

Experimente online!

Explicação

Praticamente o mesmo, exceto gravar uma macro qe chamá-la recursivamente:

qq                " record macro q
  / 0⏎b2dw0       " same as in V
           @q     " recursively call q (aborts on error)
             q    " quit recording
              @q  " execute the macro q
— ბიმო
fonte
5

Java 10, 75 72 bytes

n->{var s="";for(int i:n)s=(s+","+i).replaceAll(",\\d+,0","");return s;}

Saídas separadas por vírgula. O topo da pilha é o último. Experimente online aqui .

Graças a Olivier Grégoire por jogar 2 bytes.

Por favor, verifique Kevin Cruijssen e respostas Java de Olivier Grégoire . Eles adotam uma abordagem baseada em lista, com o último superando o meu por uma margem arrumada.

Ungolfed:

n -> { // lambda taking an integer array as argument and returning a String
    var s = ""; // we'll be using a String to implement and output the stack
    for(int i : n) // loop through the array
        s = (s + "," + i) // append the next number
               .replaceAll(",\\d+,0", ""); // remove any number followed by a zero
    return s; // output the resulting stack
}
— OOBalance
fonte
Boa abordagem com Strings. Melhor do que minha abordagem ingênua com um Stackobjeto- real . +1 de mim.
— Kevin Cruijssen
1
n->{var s="";for(int i:n)s=(s+","+i).replaceAll(",\\d+,0$","");return s;}(73 bytes), mas coloca os ,números anteriores, não depois.
— Olivier Grégoire
1
n->{var s=""+n;for(int x:n)s=s.replaceFirst("\\d+, 0,? ?","");return s;}(72 bytes), utiliza uma lista, em vez de uma matriz e messes com a saída, pois pode retornar coisas como "[, 2]"
— Olivier Grégoire
@ OlivierGrégoire Nice. Podemos soltar o $para salvar um byte adicional, pois cada um 0que adicionamos é removido imediatamente.
— OOBalance
@ OlivierGrégoire Sua segunda abordagem também é interessante, mas acho que o formato de saída inconsistente pode invalidar a solução.
— OOBalance
5

GolfScript , 14 12 bytes

~{.{;}if}/]`

Experimente online!

~{.{;}if}/]` Full program, implicit input
~            Eval input
 {      }/   Foreach:
      if       If the value is truthy (!= 0):
  .              Push itself
   {;}         Else: pop the top value
          ]` Push as array representation
             Implicit output
— wastl
fonte
5

> <> , 25 bytes

i:?\~~
(0:/:^?
!?l:!<oan;

Experimente online! (a entrada deve ser escrita em ascii. caso contrário, use esta )

Como funciona

i:?\~~verifica 0, continua ~~a excluir a entrada anterior. caso contrário, desça para:

(0:/:^? que verifica -1 (não há mais entrada), depois encerra para excluir -1 e faz um loop:

!?l:!<oan; que gera cada número com uma nova linha e termina quando a pilha é esvaziada

— torcado
fonte
— Jo King
5

Casca , 6 bytes

Já que não há resposta Husk e esse é meu idioma favorito de golfe:

F`?:tø

Experimente online!

Explicação

F`?:tø  --
F    ø  -- foldl (reduce) with [] as the initial accumulator
 `      -- | flip arguments of
  ?:    -- | | if truthy: apply cons (prepend) to it
    t   -- | | else: return tail
        -- | : returns a function, either prepending the element or dropping 1 element

Solução alternativa, 6 bytes

Em vez de virar, também podemos reverter a lista e usar a dobra à direita: Ḟ?:tø↔

— ბიმო
fonte
5

brainfuck , 214 150 bytes

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

Lê a entrada como números separados por novas linhas. Isso deve incluir uma única nova linha à direita. Também não espera zeros à esquerda em cada número. Saída como uma lista separada de nova linha semelhante

Experimente online!

Explicação que não é realmente uma explicação, mas na verdade é apenas a versão em que eu estava trabalhando com os comentários e outras coisas que podem ou não ser úteis para ninguém

Stack format:
0 (0 \d*)*


>>,[
    Setup digit == '0' conditional
    >++++++
    [-<-------->]
    +
    <[
        Read digit != '0'
        Restore the char code
        cond1 is already 1 at this stage
        >+++++
        [-<++++++++>]
    ]>[
        Read digit == '0'
        -
        Pop previous value
        <<<[
            [-]<
        ]
        Skip next input (assumed to be newline)
        ,[-]
        Skip following loop by unsetting loop flag
        >>>>-
        <<
    ]

    Move to next stack frame
    >
    Set loop flag
    >+[
        Set bit used for conditional
        <<+
        Read next character
        <,
        Compare with '\n'
        ----------[
            Not '\n': restore the char code
            ++++++++++

            >-
        ]>[
            -
            == '\n': Leave as 0
            Unset loop flag
            >>-
            <
        ]

        Copy loop flag along
        >
        [- > + <]

        Move to loop flag of next stack frame
        >
    ]

    <<<
,]


Fill in with newlines
<<[
    Skip to the cell before this value
    [<]
    Put a newline in there
    ++++++++++
    Move to next value
    <
]

Now the tape has the exact values we need to output
>>[.>]
— Sasha
fonte
5

Braquilog , 21 bytes

~c₃Ckt[İ,0]≠∧C⟨hct⟩↰|

Experimente online!

-1 byte, e mais importante, isso parece uma maneira muito menos desajeitada de fazer isso. 

~c₃                     % Partition the input into 3 subarrays
   C                    % Call that array-of-arrays C
    kt[İ,0]             % Its second element should be of the form [Integer, 0]
           ≠            % And its elements shouldn't be equal (i.e. 
                        %   the Integer shouldn't be 0)
            ∧C⟨hct⟩     % Then, remove that [İ, 0] element from C
                   ↰    % And call this predicate recursively
                    |   % When the above fails (when it can't find a partition with 
                        %  [İ, 0] in it), then just output the input

Alternativa 21 byter: ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| Experimente online!

Código mais antigo:

22 bytes

∋0&b,1;?z{=|¬∋0&}ˢtᵐ↰|

Experimente online!

∋0           If input contains a 0, 
&b           Remove input's first element, getting list of "next" elements
,1           Append 1 to that to handle last element
;?z          Zip that with input
{      }ˢ    Select only zipped pairs where
 =|          both elements are equal (to keep 0s followed by 0s)
   ¬∋0&      or the pair doesn't contain a 0
             this removes both the (pairs containing the) value
              that is followed by a 0, and the 0 itself
tᵐ           Recover back the (filtered) input array elements from the zip
↰            Call this predicate recursively 
|            If input contains no 0s, input is the output
— sundar - Restabelecer Monica
fonte
5

Aviso: Muitas linhas se seguem. Você foi avisado.

CJam , 17 bytes

Código mais perigoso
(assume que os elementos da pilha podem ser separados apenas por espaços na saída e que a matriz de entrada pode ter qualquer forma que desejar)

q~{X0={;}X?}fX]S*

Experimente online!

Explicação

q                                    Reads input string
 ~                                   Instantly convert to array since the string is in the CJam format
  {        }fX                       For loop
   X0=                               If X (the array element currently being checked) is equal to 0
      {;}                            Pop the top element from the stack
         X                           Else push X onto the top of the stack
          ?                          If-Else flag
              ]                      Collate all stack elements into an array
               S*                    Put a space between each array element

Código alternativo nº 1, 27 bytes
(assume que os elementos da pilha precisam ser impressos no formato mostrado na pergunta e que a matriz de entrada pode ter a forma que desejar)

q~{X0={;}X?}fX]',S+*'[\+']+

Experimente online!

Explicação

q                                    Reads input string
 ~                                   Instantly convert to array since the string is in the CJam format
  {        }fX                       For loop
   X0=                               If X (the array element currently being checked) is equal to 0
      {;}                            Pop the top element from the stack
         X                           Else push X onto the top of the stack
          ?                          If-Else flag
              ]                      Collate stack items into an array
               ',S+                  Add together a comma and a space to create a delimiter
                   *                 Apply the delimiter to the stack
                    '[\+             Append left bracket to the left of the stack text
                        ']+          Append right bracket to the right of the stack text

Código alternativo nº 2, 24 bytes
(assume que os elementos da pilha podem ser agrupados na saída e que a matriz de entrada deve estar no formato exato mostrado na pergunta)

q',/~]S*~{X0={;}X?}fX]S*

Experimente online!

Explicação

q                        Read input string
 ',/                     Separate by commas (since commas are an invalid array delimiter in CJam)
    ~                    Turn string into an array of substrings that make up the array
     ]S*                 Add spaces in between input numbers to prevent collation in the array
        ~                Turn the string into a valid array representative of the original
         {        }fX    For loop
          X0=            If X (the array element currently being checked) is equal to 0
             {;}         Pop the top element from the stack
                X        Else push X onto the top of the stack
                 ?       If-Else flag
                     ]   Collate all stack elements into an array
                      S* Add a space between each element

Código mais seguro para isso, 34 bytes
(assume que os elementos da pilha precisam ser impressos no formato mostrado na pergunta e que a matriz de entrada deve estar no formato exato mostrado na pergunta)

q',/~]S*~{X0={;}X?}fX]',S+*'[\+']+

Experimente online!

Explicação

q                                      Read input string
 ',/                                   Separate by commas (since commas are an invalid array delimiter in CJam)
    ~                                  Turn string into an array of substrings that make up the array
     ]S*                               Add spaces in between input numbers to prevent collation in the array
        ~                              Turn the string into a valid array representative of the original
         {        }fX                  For loop
          X0=                          If X (the array element currently being checked) is equal to 0
             {;}                       Pop the top element from the stack
                X                      Else push X onto the top of the stack
                 ?                     If-Else flag
                     ]                 Collate stack items into an array
                      ',S+             Add together a comma and a space to create a delimiter
                          *            Apply the delimiter to the stack
                           '[\+        Append left bracket to the left of the stack text
                               ']+     Append right bracket to the right of the stack text

Agradecemos a @Jo King por apontar que aqueles com a saída ordenada são inválidos, pois coisas como [12]e [1,2]seriam indistinguíveis.

Agradecemos também a @Jo King, fornecendo uma alternativa muito adequada para as saídas agrupadas e cortando 9 bytes!

— Helen
fonte
1
O primeiro não é válido, pois você não pode dizer a diferença entre [12]e [1,2]. No entanto, a versão de 27 byte parece bem, embora você pode se livrar do espaço em branco e suportes para 18 bytes
— Jo rei
oh é claro que eu sou tão burro muito obrigado
— Helen
No entanto, seria provavelmente mais golfy para separar números por espaços em vez de vírgulas desde espaços usos ]S*(3), enquanto vírgulas usar ]',*(4)
— Helen
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.