fundo
Programadores LISP conquistaram o mundo! Os parênteses foram declarados como caracteres sagrados e, a partir de agora, só podem ser usados em programas LISP. Foi decidido que os parênteses nas obras literárias serão substituídos por notas de rodapé, e é seu trabalho automatizar isso para o texto Markdown simplificado.
Entrada
Sua entrada é uma única sequência que contém caracteres ASCII alfabéticos, espaços e caracteres especiais ,.!?(). Não conterá novas linhas ou dígitos. Os parênteses serão correspondidos corretamente.
Saída
Você deve converter cada par de parênteses correspondente na sequência de entrada em uma nota de rodapé. Isso acontece da seguinte maneira:
- Substitua o primeiro par correspondente de parênteses e a substring entre eles por um número em execução que começa em
1, entre as tags Markdown<sup>e</sup>. - Anexar ao final da string
- duas novas linhas,
- a tag Markdown
<sub>, - o número da etapa 1,
- um espaço,
- a substring entre parênteses e
- a tag de fechamento
</sub>, nesta ordem.
- Se ainda houver parênteses na sequência, vá para a etapa 1.
Sua saída é a sequência resultante, possivelmente com uma nova linha à direita. Você não precisa implementar esse algoritmo exato, desde que sua saída esteja correta. Observe que pode haver parênteses aninhados; nesse caso, teremos notas de rodapé que contêm referências a outras notas de rodapé. A substring entre parênteses também pode estar vazia. Veja os casos de teste abaixo para exemplos.
Regras e Pontuação
Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas.
Se o seu idioma não suporta nativamente números decimais ( tosse Retina tosse ), você pode dar os números nota de rodapé na outra base, incluindo binários ou unário; no entanto, o uso de números unários impõe uma penalidade de + 20% .
Casos de teste
Entrada:
This input contains no parentheses.
Saída:
This input contains no parentheses.
Entrada:
This has (some) parentheses (but not so many).
Saída:
This has <sup>1</sup> parentheses <sup>2</sup>.
<sub>1 some</sub>
<sub>2 but not so many</sub>
Entrada:
This has (nested (deeply (or highly?) nested)) parentheses (and several groups).
Saída:
This has <sup>1</sup> parentheses <sup>2</sup>.
<sub>1 nested <sup>3</sup></sub>
<sub>2 and several groups</sub>
<sub>3 deeply <sup>4</sup> nested</sub>
<sub>4 or highly?</sub>
Entrada:
Hmm()(()(,)) a()((trt)(v( (((((wut)))))(X)(Y)(Z) )!?!?!?!))oooooooo(oooo)oooo
Saída:
Hmm<sup>1</sup><sup>2</sup> a<sup>3</sup><sup>4</sup>oooooooo<sup>5</sup>oooo
<sub>1 </sub>
<sub>2 <sup>6</sup><sup>7</sup></sub>
<sub>3 </sub>
<sub>4 <sup>8</sup><sup>9</sup></sub>
<sub>5 oooo</sub>
<sub>6 </sub>
<sub>7 ,</sub>
<sub>8 trt</sub>
<sub>9 v<sup>10</sup>!?!?!?!</sub>
<sub>10 <sup>11</sup><sup>12</sup><sup>13</sup><sup>14</sup> </sub>
<sub>11 <sup>15</sup></sub>
<sub>12 X</sub>
<sub>13 Y</sub>
<sub>14 Z</sub>
<sub>15 <sup>16</sup></sub>
<sub>16 <sup>17</sup></sub>
<sub>17 <sup>18</sup></sub>
<sub>18 wut</sub>
Observe as linhas vazias entre as notas de rodapé.
fonte
foo (bar)\nfoot (note)?Respostas:
Perl,
817572 bytesCódigo de 71 bytes + argumento de linha de comando de 1 byte.
Requer Perl 5.10 ou mais recente (para suporte regex recursivo)
Uso:
Explicação
-pO parâmetro imprimirá o resultado da aplicação dos comandos fornecidos à entrada, evitando a necessidade de uma impressão explícita.O regex
(\(((?1)|.)*?)\))está procurando o conjunto mais externo de colchetes desde o início da string. Quando isso é encontrado, realizamos a substituição, garantindo que apenas adicionemos o valor no final da entrada (capturando tudo até o final da entrada usando(.*)).Em seguida, repetimos a substituição de regex na cadeia agora substituída usando
redo, que aplicará continuamente a substituição de regex até que não corresponda mais. Osmodificador garante que o.no regex corresponda a novas linhas, o que é necessário porque reaplicamos o correspondente no resultado da substituição anterior do regex.fonte
[^)]ou até em.vez de[^()]garantir que a entrada será equilibrada corretamente..tornando a partida preguiçosa. @xebtl, o desafio declara "Ele não conterá novas linhas ou dígitos"Emacs Lisp, 335 bytes
Prefácio. Esta resposta e as do esquema são atualmente as únicas respostas oficialmente sancionadas pela República Popular do Poder da LISP e pela Igreja de Emacs. Outras respostas, mais curtas ou não, são consideradas uma ameaça à paz. Em particular, e com um profundo desdém a qualquer alegação difamatória de McCarthyism que é esporadicamente ouvida por oponentes hostis do estado, pedimos a qualquer pessoa que tenha informações sobre a verdadeira identidade dos autores anônimos que escrevem respostas do Nonlisp para entrar em contato com o Escritório local. Lembramos que todos devem dedicar tempo para refletir e votar de acordo com o que ele ou ela acredita profundamente que não ameaçará suas futuras interações com representantes oficiais do poder em vigor. Código é dados. Dados são código.
Mais elegantemente:
fonte
Retina ,
968683 bytes * 120% = 99,6O código fonte desta solução consiste em dois arquivos:
Explicação
Esta é uma implementação muito direta do algoritmo, conforme descrito no desafio. O código consiste em uma única substituição de regex que transforma o primeiro conjunto de parênteses em uma nota de rodapé. Essa substituição é repetida
+até que a string pare de mudar, o que aqui significa que o regex não corresponde mais (porque não consegue encontrar mais parênteses).As notas de rodapé são enumeradas em unário, para que eu possa simplesmente procurar o número da última nota de rodapé e anexar a
1para criar o próximo.O regex para encontrar o primeiro conjunto de parênteses é baseado na técnica padrão de correspondência entre parênteses e grupos de balanceamento (hrhr, "parênteses correspondentes"). Foi reduzido um pouco usando um grupo sem nome e assumindo que os parênteses estão corretamente balanceados (o que significa que podemos omitir o
(da classe de caractere negado e combinar a final)com um simples.e também não precisamos garantir que o parâmetro pilha de captura está vazia).Depois de combinar os parênteses e capturar seu conteúdo em grupo
1, capturamos o restante da sequência com(.*)em grupo4e, em seguida, pesquisamos novamente na sequência o primeiro conjunto de1s com um olhar negativo para trás. Se encontrarmos uma substring, armazenamos em grupo5. Se não o fizermos, observamos falhas, mas tudo bem porque é opcional - significa apenas que$5fornecerá uma string vazia, que é a representação unária0e que também está correta.A sequência de substituição simplesmente reúne tudo com base nos grupos de captura. O número da nota de rodapé é incrementado acrescentando
1a ao último número com1$5.fonte
JavaScript sagrado , 1510 bytes
Colegas rebeldes, não cedam à demolição tirânica dos parênteses! Você deve perseverar! Desde o início, a programação tem sido uma empresa livre. Agora, tornou-se uma demonstração permeada de piedade. Não devemos mostrar nada menos que medo absoluto. Portanto, eu lutei de volta!
Não há regras contra o uso de caracteres sagrados em uma linguagem não Lisp. Não, de jeito nenhum. (De uma forma um pouco menos compacta :)
Isso compila o JavaScript expandido na minha outra resposta . Esta é uma submissão de piada.
fonte
Lua,
222216204201 bytesGolfe:
Ungolfed:
fonte
repeat a,b=l(s,g) ... untill a<1loop não seria mais curto que o seu tempo?Esquema, 92 bytes
Frustrados com a implementação da busca pela primeira vez no Real Lisp, 1 os futuros poderes decidem adotar uma abordagem mais pragmática. Afinal, os parênteses são sagrados, mas os parênteses não. 2
1. não ouça os hereges da chamada "igreja" do Emacs!
2. Eles não são programadores de raquete, são?
fonte
Haskell, 210 bytes
Exemplo de uso:
Como funciona:
fonte
Esquema, 533 bytes
Com recuo:
Sim, são 533 bytes quando todo o espaço em branco opcional é removido. Aproveite a glória funcional.
Eu implementei mais ou menos o algoritmo na descrição:
xagrupa a entrada entre parênteses efsubstitui o primeiro nível de grupos por notas de rodapé, repetindo até que não haja mais grupos restantes. Estou certo de que pode ser feita mais curta, mas eu não vejo como isso poderia ser feito muito mais curto sem mudar para um algoritmo diferente.Como está escrito, é um programa completo. Você pode experimentá-lo aqui , mas porque repl.it aparentemente não pode lidar com
(read-line)você, você deve colocar a string de entrada em seu lugar. Uma versão completamente não destruída está aqui .EDIT: Como apontado nos comentários, alterei os parênteses
()entre parênteses[]nas versões repl.it. Isso foi puramente por conveniência durante a programação e a depuração. A versão postada agora funciona com().fonte
#\['#] `pelos respectivos parênteses (e atualizar testes), isso funcionará sem problemas. Existe algum motivo para você deixar os quadrados? está relacionado à sua resposta anterior?JavaScript ES6, 244 bytes
Resposta séria (só funciona no FireFox, que eu saiba)
Expandido:
fonte
Hássio , 315 bytes
Atualmente, isso não é concorrente, pois também não lida exatamente com os aninhados.
Expandido:
}
fonte