Esta pergunta faz parte de uma série de desafios de aniversário do Brain-flak projetados para comemorar o primeiro aniversário do Brain-Flak. Você pode encontrar mais informações sobre o aniversário de Brain-Flak aqui .
Hoje é o primeiro aniversário da Brain-Flak! Então pensei em fazer uma festa surpresa de aniversário. Então, no seu idioma favorito, imprima
Surprise!
Happy Birthday, Brain-Flak!
(Espaço em branco à direita é permitido)
Como sempre, os programas devem ser jogados de golfe. No entanto, como os programas Brain-Flak são feitos entre parênteses, ele não contará nenhum parêntese na sua fonte contra você. (Os personagens ()[]<>{}
não contam para o total de bytes), mas devem ser equilibrados para não perturbar Brain-Flak.
Regras
Aqui está um detalhamento das regras
Os colchetes na sua fonte devem estar equilibrados. Esses são os parênteses do seu programa que devem ser divididos pela seguinte gramática:
S -> SS | (S) | [S] | <S> | {S} | E
Onde
E
está a string vazia.Ou seja, uma sequência equilibrada é a concatenação de duas seqüências equilibradas, chaves ao redor de uma sequência equilibrada ou a sequência vazia.
A pontuação de um programa é o número de bytes sem colchetes.
Seu objetivo deve ser minimizar sua pontuação no idioma que você escolher.
As regras padrão se aplicam para que você possa escrever um programa completo ou uma função.
no caso de um empate bruto, a contagem de bytes atua como desempate
Certamente, haverá soluções de zero byte em alguns idiomas ( parênteses , inferno , parênteses , glifo , linguagem ). Tente encontrar maneiras de jogar bem em idiomas onde essa não é uma tarefa trivial.
fonte
><
considerado equilibrado ou os aparelhos precisam estar na ordem correta (<>
)?Respostas:
Python 2 ,
39373634 bytes-1 graças a dzaima
-2 graças a Erik, o Outgolfer
Experimente online!
Personagens relevantes:
Explicação
Este programa constrói a string:
Isso é feito convertendo uma longa sequência de parênteses em códigos de caracteres. Depois que a string é criada, ela é executada.
Constrói a corda com o esqueleto:
Isso divide a string
{}
e mapeia cada seção para o código de caractere correspondente ao seu comprimento. Podemos então construir toda a cadeia de caracteres por um custo de zero bytes.fonte
()
em torno dax
para salvar 2.Haskell (antes de GHC 8.4), (
10119 7767 76267540 bytes), pontuação15 1410Experimente online!
A última linha define uma função anônima
(<>)'y'pred(:)
. Ligue com(<>)'y'pred(:)()
para produzir a sequência.Edit: Um enorme agradecimento a @ Ørjan Johansen por sugerir passar as funções auxiliares como parâmetros em vez de declará-las, economizando quatro bytes de pontuação!
Os bytes sem colchetes são
Como funciona?
Uma cadeia de caracteres
"wxy"
em Haskell é açúcar sintático para uma lista de caracteres['w','x','y']
, o que mais uma vez é o açúcar sintático para a construção posterior com o operador contras:
e a lista vazia:'w':'x':'y':[]
. Ao definir,(<<>>)=(:)
produzimos a mesma string escrevendo'w'<<>>('x'<<>>('y'<<>>[]))
.Porque caracteres são ordenados, podemos calcular o antecessor de cada caractere com uma função chamada
pred
. Usando apenas o caractere'y'
epred
, a sequência se tornapred(pred 'y')<<>>(pred 'y'<<>>('y'<<>>[]))
. Ao definir(<>)=pred
e(<><>)='y'
podemos representar a sequência usando apenas colchetes:(<>)((<>)(<><>))<<>>((<>)(<><>)<<>>((<><>)<<>>[]))
No entanto, no final, não queremos uma string, mas uma função retornando uma string; portanto, definimos nosso operador contras
(<<>>) x xs ()=x:xs
. (Obviamente, comx
exs
substituídos por identificadores usando apenas colchetes:)(<<>>)(<>)(<><>)()=(<>):(<><>)
. Deste jeito,((<>)((<>)(<><>))<<>>((<>)(<><>)<<>>((<><>)<<>>[])())())
é uma função do tipo
() -> String
e, ao anexar um final,()
produz a sequência original:((<>)((<>)(<><>))<<>>((<>)(<><>)<<>>((<><>)<<>>[])())())()
Usando este método conseguimos uma solução com pontuação 15. No entanto, podemos condensar as três declarações em um declarando uma função que leva quatro argumentos:
'z'
,pred
,(:)
e()
para chamar.A função a seguir
encode
codifica uma string com caracteres menores ou iguais a'y'
este modo: (Por quêy
? Porque é o maior caractere"Surprise!\nHappy Birthday, Brain-Flak!"
e, portanto, produz a menor representação. Agradecemos novamente a Ørjan Johansen por apontar isso).Experimente online!
fonte
'z'
na verdade não ocorre na sequência da meta, acho que você pode reduzir o desempatador da contagem de bytes usando'y'
.(<<<>>>)(<><>)(<>)(<<>>)()=...;(<<<>>>)'y'pred(:)
Retina , 59 - 24 = 35 bytes
Experimente online! Em comparação, a solução chata leva 38 bytes.
fonte
Geléia ,
76 bytesDentro do
“”
você precisa colocar a saída deste programa Jelly:-1 byte graças a Jonathan Allan (nova linha permitida à direita)
Existem 53127666317289661939246122975355844970973062889031671423309402549417051416384149 80886139013 (nós chamaremos isso
n
)()
s entre“”
.Explicação :
fonte
Linguagem , 0 bytes
Apenas 10024793746353848520175158940670214213802394805963081469362831141755126591573942436182287015467334956253918417576118983828148929806934751198148656645940502264502520032312455157880058174845907554602116807351044784410936407102892289953027884533102082518964744402664917253792543505897552998982122997648280947470217067174451441654554437678556775097996646071948 bytes feitos de suportes equilibradas.
Programa Python 3 para gerar minha versão favorita, com tempo e memória suficientes:
fonte
Haskell , (
1200613485 bytes), pontuação1817EDITAR:
toEnum
versão funcionasse sem extensões, movendotoEnum
para a função principal, ao custo de a$
.Use como
putStrLn$(<<>>)()
.Experimente online!
onde
...
é a sequência de resultados da seguinte expressão:Os únicos caracteres não balanceados são
A seguinte variante (13484 bytes) tem pontuação 16, exceto que precisa da
ExtendedDefaultRules
extensão do GHC e, portanto, só funciona no GHCi por padrão. (A menos que você goste de montes de avisos, também deseja-fdefer-type-errors
e-Wno-deferred-type-errors
por algum motivo.)Experimente online!
Como funciona
<>
são caracteres legais do operador. Além disso, se entre parênteses, eles podem ser usados para qualquer valor, não apenas para funções de dois argumentos.(<<>>)
na segunda linha é a função principal, é necessário um único argumento fictício()
e retorna a sequência final.<>
pega duas listas e acrescenta o comprimento do segundo ao primeiro (na segunda versão, também convertendo o comprimento em um caractere.) Os operadores são deixados associativos por padrão, portanto, isso é facilmente vinculado.[]
com<>
.()<>[]
caracteres balanceados - e depois (na versão principal) mapeandotoEnum
a lista resultante.fonte
Japt ,
1914131098 bytesonde a string no começo é:
A contagem total de bytes é "apenas"
669433943354, para que você possa experimentá-lo online!Explicação
O método real usado é explicado em outras respostas: Divida em
<>
, mapeie cada execução de parênteses parachr(len(x))
, junte-se novamente na sequência vazia. Aqui, é o golfe que é a parte divertida.Antes de "jogar golfe", o código original pode parecer
que é uma descrição bastante literal:
"...".split("<>").map(Z => Z.length.toChar()).join("")
agora precisamos minimizar os caracteres que não estão entre colchetes. Quão? Bem, primeiro podemos jogar golfe de verdade:Isso representa aproximadamente
"...".split("<>").map(Z => Z.length).map(Z => Z.toChar()).join()
.Agora podemos abusar da maneira confusa de Japt tratar parênteses.
(
representa subir um nível, como na maioria dos idiomas, mas)
representa descer dois níveis (um espaço desce um nível), o que significa que podemos otimizar o código para:Esse código funciona da mesma forma que o acima, mas usa dois caracteres a menos que não sejam de colchetes.
Além disso, se um operador for a primeira entrada de uma função, ele será transformado em uma sequência para que a função possa decidir o que fazer com ela. Isso significa que podemos evitar as aspas se apenas tornarmos cada parêntese de 1 byte mais curto e dividirmos
>
(com alguma disposição inteligente para cancelar o resultado>)
no código):Isso nos poupa mais dois bytes, pois tiramos duas aspas.
fonte
Haskell , (
1965 313118073 bytes), pontuação31 2319Experimente online! Uso: A última linha é uma função anônima.
f
Ligue -o a, por exemplo, e ligue comf()
.Os 19 bytes sem colchetes são
além de uma nova linha à direita.
Versão Score 23 (3131 bytes):
Experimente online! Os 23 bytes sem colchetes são
Versão do Score 31 (1965 bytes):
Experimente online!
Depois que todos os colchetes são removidos, esses 31 bytes permanecem:
Como funciona?
['\n'..'~']
gera a lista de todos os caracteres da nova linha na~
qual inclui todos os caracteres ASCII imprimíveis.(<<>>)
é um identificador escolhido para ter zero bytes sob a regra de pontuação fornecida.(<<>>)=['\n'..'~']++(<<>>)
produz, assim, uma repetição infinita da lista de caracteres.Na segunda linha,
zip"> ... "(<<>>)
fecha uma longa sequência de colchetes com a sequência infinita, produzindo uma lista de tuplas com um caractere de colchete no primeiro componente e algum caractere ASCII no segundo. Para cada tupla nesta lista, verificamos se ele corresponde ao padrão('{'{-}-},(<>))
, ou seja, se ele tem um{
colchete como primeiro componente.{- ... -}
é um comentário in-line em Haskell, assim'{'{-}-}
como uma versão equilibrada de'{'
. Se a correspondência for bem-sucedida, o segundo componente da tupla é vinculado ao identificador(<>)
e adicionado à construção da string por meio da compreensão da lista. FinalmenteputStr
imprime a string.putStr[(<>)|('{'{-}-},(<>))<-zip"> ... "(<<>>)]
A impressão direta da sequência é de 46 bytes:
fonte
HTML, 37 bytes
fonte
<br>
tag como esta:Surprise!<br>Happy Birthday, Brain-Flak!
<br>
é um byte a mais, já que<p>
eu experimentei antes de postar. Parece um pouco melhor. Eu não uso nenhuma tag de fechamento<p>
.05AB1E , 24 bytes
Usa a codificação 05AB1E . Experimente online!
fonte
Pitão,
4⃠3⃠2 bytesRiscar4 não é regular 4 se você usar ozalgoUnicode magicAgradecemos a Roman Gräf e Neil por economizar 1 byte.
O código é
Cl(()()()
…()()())
onde o parêntese externo contém41505989310382548390036033574496753883572705382055993299460470741732071419050117038172961
cópias concatenadas de()
. (O Stack Exchange não me permitiu publicar o código completo.)Cria uma tupla (
(
…)
) de tuplas vazias (()
), pega o comprimento (l
) e converte-o em uma string de base 256 (C
).fonte
h
você não poder adicionar outro par de colchetes?h
duas posições para a direita e ele ainda iria funcionar perfeitamente ;-)Japt , 6687 bytes, pontuação 5
Experimente online!
Isso é semelhante ao da minha outra resposta em japonês , mas usa matrizes aninhadas em vez de uma string. As coisas boas sobre matrizes aninhadas (além do fato de que defini-las não ocupam bytes) são que elas são pré-organizadas, para que você não precise fazer divisões
<>
mágicas ou decodificar número base 256, ou qualquer coisa assim. A lógica real é justa.map(X => X.length).map(X => String.fromCharCode(X)).join("")
.fonte
Chip , 553 + 3 = 556 bytes, pontuação 127 + 3 = 130
+3 para arg
-w
. Experimente online!Os bytes sem colchetes são
Sem Golfe / Desequilibrado:
Como você pode ver, o código original usa apenas colchetes do lado direito, portanto, todos os colchetes do lado esquerdo servem apenas para balanceamento. No decorrer da elaboração desta solução, encontrei no Chip uma representação muito mais densa das cordas que tive nas minhas respostas anteriores, por exemplo, olá mundo , e por isso as atualizei também.
Como funciona:
O bit pendurado à esquerda produz um pulso de 1 ciclo para começar. Esse pulso viaja ao longo do pulso de disparo a
Z
uma taxa de 1 por ciclo, o que fornece o tempo. Quando cada umZ
está ligado, é coluna correspondente produz o código ASCII do caractere em que o índice, que, em seguida, recebe a saída por os elementosa
por meio deg
(um por cada bit do byte de saída, excepto o bith
que é sempre 0). Quando concluído, ot
final da execução.A codificação ASCII é simples:
)
meio 1 ex
meio 0. No entanto, a parte inferior 5 linhas são na sua maioriax
, de modo que os bits invertido na solução final, de forma eficaz trocando os dois símbolos.Essa é a melhor pontuação possível?
Eu duvido. No mínimo, eu acho que nós precisamos a seguinte: 1 cada
a
meiog
, uma vez que esses são os bits de saída ativos, 1*
ou similares para fornecer um sinal de partida, 1t
para terminar a execução, 36Z
s ouz
s para o tempo limite de cada letra, eo comando arg-w
. Isso tudo soma 48 pontos.Acima desse mínimo teórico, minha solução possui 7 novas linhas, uma segunda
*
, uma extraZ
e 73x
s.fonte
C, 9265 bytes, pontuação 37
Veja como funciona online .
C, 8589934626 bytes, pontuação 34
Onde
STRING
é a mesma literal de cadeia grande usada no exemplo acima, exceto que ela tem duas diferenças no meio da cadeia de caracteres em que há uma substring<>
. Logo antes<
, existem 4294962688[
caracteres adicionais e logo depois>
existem 4294962688]
caracteres adicionais .O programa funcionará sob as seguintes premissas:
INT_MAX é 2 ^ 31-1 e INT_MIN é -2 ^ 31.
Compilado com comportamento de quebra automática para aritmética assinada. (-fwrapv)
A função strspn é capaz de processar 4294962689 caracteres por vez.
O compilador é capaz de compilar uma cadeia de caracteres literal composta por 8589934592 caracteres.
Essas suposições são possíveis em arquiteturas modernas de 64 bits, em que o tipo int é 4 bytes e o tamanho size_t é 8 bytes. A função strspn retorna o tipo size_t, e o mesmo tipo está relacionado ao limite interno para o tamanho máximo do objeto. O tipo size_t, com 8 bytes, satisfaria as duas últimas suposições.
Essa diferença nesta versão é que a variável i não precisa ser redefinida para 0, uma vez que envolve aproximadamente 0 após a impressão do último caractere.
fonte
Haskell , 9735 bytes, pontuação 9
Experimente online!
Os 9 bytes de pontuação são
Isso funciona nas versões atuais do Haskell (GHC 8.4 ou mais recente) em que
(<>)
estáPrelude
. Agradecemos a Ørjan Johansen por apontar que isso interrompe minha solução anterior, mas permite salvar outro byte de pontuação.Explicação
Como
(<>)
em duas listas é igual a(++)
, podemos representar uma string"abc"
como"a"<>"b"<>"c"
alternativa. Strings são listas de caracteres, portanto,['a']<>['b']<>['c']
denota a mesma string. Agora, como na resposta anterior, nós só queremos um único literal de caracteres, para que ficar com ele mais alto'c'
e representar os outros como antecessores do mesmo:[pred(pred 'c')]<>[pred 'c']<>['c']
. Finalmente, substituindo'c'
com(<><>)
o que é um identificador válido epred
com(<<>>)
, temos uma codificação da string"abc"
que consiste somente de parêntese equilibrada:[(<<>>)((<<>>)(<><>))]<>[(<<>>)(<><>)]<>[(<><>)]
.A função a seguir codifica uma sequência arbitrária dessa maneira:
Experimente online!
fonte
(<<>>)
é usado tantas vezes, acho que economizará muitos bytes se você trocar o nome pelo nome<>
(passando o último como um parâmetro extra).C # interativo, 45 bytes
Eu sei, é meio chato, mas se executado no C # interativo, produz a saída desejada - e, na verdade, duvido que exista uma maneira menor de resolver isso no C #.
No entanto, há uma maneira mais estilosa:
Mas isso tem 145 bytes de tamanho.
Com quebras de linha, fica assim:
Isso interpreta os colchetes como valores booleanos e, em seguida, como uma string.
Na verdade, eu não sou um jogador de código avançado, então qualquer sugestão é apreciada!
fonte
.Select(s =>
para cumprirS -> <S>
, você pode alterá-lo para.Select(/*<*/s =>
C# Interactive
, também acho que é interpretado em C # interativo, não compilado, mas ainda é considerado um programa \ scriptCJam , 6683 bytes, pontuação 3
Abreviei o código aqui para não bagunçar muito a página. Você pode ver o código completo no link do TIO. Os únicos caracteres que não estão entre colchetes são
,c%
.Experimente online!
Explicação
O programa começa pressionando uma matriz de matrizes de matrizes vazias. Cada sub-matriz contém um número de matrizes vazias correspondentes a um valor ASCII de um caractere na sequência desejada. Então, para cada sub
{...}%
-matriz ( ), ela obtém o comprimento da matriz (,
) e lança esse comprimento para um caractere (c
).A sequência resultante é impressa implicitamente.
fonte
C,
6964 bytesExperimente on-line
Como eu fiz isso
*
por{}
,>
com<>
e<
com,[]
para que eles não sejam contados; agora, essa contagem de código é 1 por causa do caractere inicialS
.<>
, subtrai[]
, imprime a soma atual{}
e termina no final da string\0
.C, 49 bytes Experimentar online
fonte
p
gravar alguns bytes?Lua 5.3, 108097107033101 bytes, pontuação
2827Aqui,
REPLACE
é substituído por uma sequência 108097107033034 de caracteres livres. A string codifica os dados colocando{}
em determinadas posições-chave. O primeirogsub
substituirá a sequência pelos índices{}
s (por meio do grupo de captura vazio()
). O segundogsub
quebra essa sequência resultante em blocos de 3 dígitos e substitui cada bloco por sua representação ASCII.Observe que a sintaxe para cadeias brutas em Lua é (basicamente)
[[string contents]]
, o que é bastante útil na redução da pontuação.A string (sem escape) que estou gerando é
print"Surprise!\nHappy Birthday, Brain-Flak!"
. Substituir cada caractere pelo código ASCII decimal de três dígitos fornece112114105110116034083117114112114105115101033092110072097112112121032066105114116104100097121044032066114097105110045070108097107033034
. O código que eu uso só pode gerar sequências de números naturais crescentes (pelo menos 2 separados) que não começam com zeros iniciais. Portanto, esse número é dividido11, 2114, 105110, 1160340, 83117114, 112114105, 1151010330, 9211007209, 71121121210, 320661051141, 1610410009712, 10440320661140, 97105110045070, 108097107033034
. (Este último número é exatamente o tamanho doREPLACE
valor, pois a última correspondência do padrão fornecerá o índice da final}
, observando que os índices Lua começam em 1. Se o último número for ímpar, o padrão e a string terão para ser modificado um pouco, embora não seja difícil.)Na verdade, eu não gere e executei este programa porque é muito grande (embora teoricamente pudesse funcionar em uma máquina de 64 bits, não caberia no meu disco rígido).
Como prova de conceito, aqui está um pequeno programa que imprime
3
usando o mesmo princípio:Isso gera a cadeia de código
p"3"
através do número112034051034
via divisão11, 203, 405, 1034
.fonte
Pip , 6681 bytes, pontuação 3
(com muitos parênteses e alguns colchetes redigidos). Experimente online!
Construímos uma lista de listas, cada uma das quais contém
()
(nil) algumas vezes.#*
mapeia o operador de comprimento, resultando em uma lista de números.C
pega cada número como um código ASCII e o converte em um caractere. A lista de caracteres resultante é concatenada automaticamente e impressa.Feliz aniversário tardio, Brain-Flak!
fonte
Mathematica, 40 bytes
Função anônima. Não recebe entrada e retorna uma string como saída.
fonte
Geléia ,
1921 bytesNada de mais inteligente aqui, apenas uma compactação de dicionário + string do texto, além de uma nova linha à direita para remover uma inigualável
<
.Para uma abordagem verdadeiramente golfe, veja esta resposta de Erik, o Outgolfer.
Experimente online!
fonte
PHP, 42 bytes
Experimente online!
-5 bytes a solução chata
PHP, 60 bytes
Experimente online!
fonte
<?=""?>
Empilhadas , pontuação 23
Onde
...
está a sequência omitida. (Isso pode ser gerado com isso .)Experimente online!
Sim, não é tão criativo. Obtém o número de todos
<>
os se os converte em códigos de caracteres.fonte
Perl 5 , 3304 bytes, 16 pontos
Experimente online!
Usa a codificação de comprimento de execução da solução Python do @ HeebyJeebyMan.
fonte
Java, 140 bytes
Experimente on-line
fonte
C, 52 bytes, pontuação 46
Versão ingênua. Aqui está a versão otimizada .
fonte
Carvão , 37 bytes
Experimente online!
Apenas imprime a string.
fonte