No APL, você pode escrever funções tácitas, chamadas de trens . Como eles funcionam é irrelevante para esse desafio. Aqui estão as diferentes maneiras pelas quais eles podem ser agrupados, usando ⍴
como função:
⍴ -> ⍴
⍴⍴ -> ⍴⍴
⍴⍴⍴ -> ⍴⍴⍴
⍴⍴⍴⍴ -> ⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴ -> ⍴⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴⍴ -> ⍴(⍴⍴(⍴⍴⍴))
...
O pedido permanece o mesmo. O procedimento é que, desde que haja estritamente mais de 3 funções, as últimas 3 funções serão agrupadas em uma função. Se encontrarmos um trem aninhado, parênteses o primeiro, antes de continuar. Aqui está o procedimento aplicado a ⍴⍴⍴⍴⍴⍴
:
Step 0: ⍴⍴⍴⍴⍴⍴
There are strictly more than 3 functions, repeat.
Step 1: ⍴⍴⍴(⍴⍴⍴)
There are strictly more than 3 functions, repeat.
Step 2: ⍴(⍴⍴(⍴⍴⍴))
There are 3 or less functions, we're done.
Aqui está o mesmo procedimento aplicado a ⍴⍴⍴(⍴⍴)⍴(⍴⍴⍴⍴(⍴⍴⍴))⍴⍴
:
Step 0: ⍴⍴⍴(⍴⍴)⍴(⍴⍴⍴⍴(⍴⍴⍴))⍴⍴
There are strictly more than 3 functions, repeat.
We have met a nested train, applying procedure to that first:
Step 0: ⍴⍴⍴⍴(⍴⍴⍴)
There are strictly more than 3 functions, repeat.
We have met a nested train, applying procedure to that first:
Step 0: ⍴⍴⍴
There are 3 or less functions, we're done.
Step 1: ⍴⍴(⍴⍴(⍴⍴⍴))
There are 3 or less functions, we're done.
Step 1: ⍴⍴⍴(⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴)
There are strictly more than 3 functions, repeat.
We have met a nested train, applying procedure to that first:
Step 0: ⍴⍴
There are 3 or less functions, we're done.
Step 2: ⍴⍴⍴((⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴))
There are strictly more than 3 functions, repeat.
Step 3: ⍴(⍴⍴((⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴)))
There are 3 functions or less, we're done.
Entrada
Para esse desafio, a entrada será simplificada. Isso significa que você pode escolher 2 caracteres diferentes para abrir e fechar parênteses e 1 caractere para funções, diferentes daqueles escolhidos para parênteses. Os caracteres que você escolher devem ser consistentes. A entrada não estará vazia e não conterá parênteses sem conteúdo (ou seja ()
).
Resultado
Novamente, você pode escolher 3 caracteres diferentes, 2 para parênteses e 1 para funções. Observe que eles não precisam ser iguais aos escolhidos para entrada, mas devem ser consistentes.
Regras
- Se houver parênteses que incluam apenas uma função dentro da entrada, você deverá removê-los na saída. Sua saída pode não conter parênteses desnecessários (por exemplo, incluir apenas uma função ou incluir toda a saída).
- Você não precisa implementar o algoritmo usado aqui, desde que sua solução seja válida para esse desafio.
- Entrada e saída são cadeias no formato explicado nas seções Entrada e Saída. A entrada terá pelo menos um caractere.
- É estritamente proibido usar as brechas padrão .
- Este é o código-golfe , por isso a resposta mais curta vence. No entanto, não haverá uma resposta aceita, pois essa é uma competição por idioma e para incentivar a resposta em idiomas nos quais essa tarefa resultaria em código mais longo em comparação com o código escrito em outros idiomas.
Casos de teste
Os caracteres usados aqui são ()⍴
, você deve substituí-los pelos caracteres escolhidos.
⍴ -> ⍴
⍴ -> ⍴
⍴⍴ -> ⍴⍴
⍴⍴⍴ -> ⍴⍴⍴
⍴⍴⍴⍴ -> ⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴ -> ⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴⍴))))))
⍴⍴⍴⍴⍴(⍴⍴⍴)⍴⍴(⍴(⍴⍴⍴)⍴⍴⍴)⍴⍴⍴ -> ⍴(⍴⍴(⍴⍴((⍴⍴⍴)⍴(⍴(⍴(⍴⍴⍴)(⍴⍴⍴))(⍴⍴⍴)))))
(⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴) -> (⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)
(⍴⍴⍴)(⍴⍴⍴)⍴⍴⍴ -> (⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)
⍴⍴(⍴)⍴⍴ -> ⍴⍴(⍴⍴⍴)
((⍴⍴)) -> ⍴⍴
⍴⍴((⍴⍴))⍴⍴ -> ⍴⍴((⍴⍴)⍴⍴)
Este desafio foi publicado na Sandbox. Se você tiver o privilégio necessário, poderá ver a postagem da sandbox aqui .
fonte
Respostas:
APL (Dyalog Classic) ,
71686563 bytesExperimente online!
Os personagens que eu escolhi para I / O são
'('
,')'
e'⍬'
.Esta solução é em si um trem de APL.
⍎
analisa a entrada como se fosse uma matriz aninhada - uma árvore com vetores numéricos vazios (⍬
) como folhas.O dfn (ie lambda -
{ }
) atravessa a árvore recursivamente e a converte em uma string entre parênteses. O argumento esquerdo⍺
controla se os parênteses devem ser adicionados ao nível atual, se necessário.O dfn lida com os seguintes casos com base no argumento correto:
se já é uma string (
⍵≡⍕⍵
), retorne-ase for
⍬
, devolva o char'⍬'
se for um singleton, basta ir mais fundo (
∇
é o símbolo de uma chamada recursiva)se o seu comprimento for ≤3, recorra para cada um dos itens e envolva-o,
()
se necessáriocaso contrário, recursione a cauda 3, prefixe tudo menos a 3 cauda e recue novamente
fonte
Python 2 ,
224208204 bytes-16 bytes graças ao Sr. Xcoder -4 bytes graças ao ovs
Experimente online! ou Experimente todos os casos de teste
O código pode ser dividido em 3 etapas principais:
Convertendo a entrada em uma lista aninhada e substituindo
(p)->p
. A função únicap
será substituída por uma lista vazia.Uma função recursiva para aplicar a regra "3 ou menos" na lista atual e chamar todas as sublistas.
Muitas substituições para formatar para o formato de saída desejado
fonte
((pp))
(oup((pp))p
).CJam , 56 bytes
Bate APL!
Experimente online!
Isso funciona (eu acho) e não tenho idéia do porquê ...
Caracteres de entrada são
][T
para()⍴
e caracteres de saída são][0
para()⍴
(sim, isso significa que eles são revertidos do que você esperaria; por exemplo, você pode passarTTT]TT[T]TTTT]TTT[[TT
).Visão geral de alto nível
O programa trabalha com a entrada para trás, porque é mais conveniente. Para analisar a entrada, aproveitamos o analisador do CJam - reverter e executar a entrada fornece a forma analisada (para trás) da entrada.
Em seguida, definimos um procedimento
K
.K
faz a maior parte do trabalho para a nossa submissão e funciona da seguinte maneira:K
a elas. O resultado deve ser outra matriz e, se essa matriz consistir em apenas um elemento, descompacte-o (isso elimina os parênteses redundantes).Ao aplicar
K
à entrada, obtemos a forma entre parênteses corretamente da entrada (a única coisa a ser observada é que, na verdade, envolvemos a entrada em uma lista de singleton e a desembrulhamos depois; a razão para isso é que queremos o trecho que descompacta os singletons para aplicar ao programa de nível superior, e não apenas às suas sub-matrizes). Depois, aplicamos uma formatação mínima para obter nosso resultado.Alguma explicação para bits de golfe
O golfe de que mais me orgulho é o uso
,
para realizar a verificação entre números inteiros e matrizes.,
gera o intervalo [0..n) . Como o único número inteiro que encontraremos é0
, isso sempre nos dá a lista vazia[]
, que é falsey.,
leva seu comprimento. Como todas as matrizes que encontramos serão vazias, isso sempre nos dá um número inteiro positivo, que é verdadeiro.Outro golfe que pode ser interessante é o método que eu uso para agrupar os três primeiros elementos da matriz; é um pouco semelhante ao meu envio "Turing complete language interpreter code golf" . O CJam não tem um caminho curto para dividir uma matriz em duas partes (você pode tentar dividir a primeira parte e depois a outra parte, mantendo a matriz e o índice originais na pilha, mas isso não funciona muito bem) , então o que eu faço é usar
3/
, que agrupa uma matriz em blocos de 3. Em seguida, posso sair do primeiro elemento(
, agrupar a matriz duas vezesaa
e, em seguida, anexar novamente ao início da lista\+
. O motivo pelo qual:~
agrupamos o array duas vezes é que precisamos remover uma camada , já que também agrupamos o restante do array em seções.fonte
JavaScript (ES6),
149146 bytesUsa
()p
, embora você use uma letra diferente, você pode simplesmente mudar op
texto no final.fonte