# 4"16" 3//v\(@#/;\D"14"<;n4
#/*`3 afaaZ">;[77*,68*,@;'1,'1,q)(22)S# ␉␉␉␉ (
#yy␉;36!@
#`<` ␉
#=␉x
#<]+<[.>-]>[
#␉<
###xR+++++[D>+++++++L+++<-][<<<]>+.---.>][
#px%>~~~+␉+~*ttt*.x
#D>xU/-<+++L)
#R+.----.R␉>]|
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#|␉
print((eval("1\x2f2")and(9)or(13 ) )-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
###; console.log 39
""""#//
=begin␉//
#*/
#define␉z sizeof 'c'-1?"38":"37"
#include<stdio.h>
int main() /*/
#()`#`\'*/{puts(z);}/*'``
$'main'␉//
#-3o4o#$$$
<>"3"O.<␉>//
#
=end #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE) a>>>
#>27.say# /7Jn~15o|
#8␛dggi2␛`␉|1|6$//''25 =#print(17) ###^_^_LEintnd"3"z!]/}23!@/*///Z222999"26
␉é uma guia literal, ␛um caractere ESC literal; O Stack Exchange alteraria o programa de outra forma. Eu recomendo copiar o programa da caixa "entrada" do link TIO abaixo, se você quiser trabalhar nele.
Experimente online!
Pontuação VIP (Impressora Inteira Versátil): 0,01329
Atropelar
Este programa imprime 41 em brainf ***, 40 em Minimal-2D, 39 em CoffeeScript, 38 em C, 37 em C ++, 36 em labirinto, 35 em INTERCAL, 34 em trilho, 33 em incidente, 32 em turbilhão, 31 em SNUSP modular, 30 em espaço em branco, 29 em gatilho, 28 em Brain-Flak, 27 em Perl 6, 26 em 05AB1E, 25 em Pip, 24 em Thutu, 23 em hexagony, 22 em Underload, 21 em Nim, 20 em Prelude, 19 em Reng, 18 em Cardinal, 17 em Julia, 16 em Pyth, 15 em Haystack, 14 em Turtlèd, 13 em Ruby, 12 em Fission, 11 em Befunge-98, 10 em Befunge-93 , 9 em Perl 5, 8 em Retina, 7 em Japt, 6 em SMBF, 5 em Python 2, 4 em> <>, 3 em Minkolang, 2 em V / Vim e 1 em Python 3.
Verificação
A maioria dos idiomas é testada pelo driver de teste mostrado acima. Você pode testar o Reng aqui e o SNUSP Modular aqui ; eles produzem 19 e 31 respectivamente, conforme necessário.
O driver de teste foi atualizado para incluir o tokenizador, finalmente. Todo o código C é armazenado como argumento da perspectiva do Bash Script. Também alterei a saída para quebrar horizontalmente com um espaço à direita após cada token, em vez de sair verticalmente. Essa era apenas a minha preferência, para que correspondesse à saída de espaço em branco. Mas qualquer um pode mudar se achar que é muito confuso.
Também fiz um ajuste no Test Driver para lidar com o espaçamento das colunas do char UFT8 da Turtlèd no resumo. Esse desalinhamento estava me deixando louco! A “correção” é bastante hack-ish, uma vez que apenas procura um è e altera a largura da coluna nesse caso, mas faz o trabalho.
Explicação
Primeiro, quero dizer o quão incrível a Versatile Integer Printer da SnoringFrog snippet de código de pontuação de última postagem. Eu tenho calculado respostas antes de postar por um tempo, e isso me inspirou a mantê-lo pequeno. Acho que podemos vencer a resposta do @ sp3000 eventualmente.
Então comecei a trabalhar nessa resposta, tentando jogar o que pude e tive muito sucesso. Eu até tive uma resposta em um idioma diferente, com uma contagem total de bytes menor que # 40. Mas, quando tentei jogar golfe no Minimal-2D, tive que aprender BF para poder trabalhar melhor com seus derivados e, no processo, encontrei o recorde do @ Primo quebrando o Hello, World! . Eu me apaixonei pela elegância.
O Minimal-2D, ao que parece, não era eficiente o suficiente para utilizar a técnica de inicialização de fita usada pelo @Primo, mas sou da opinião agora que provavelmente seria muito pesado de qualquer forma. Afinal, estamos apenas tentando imprimir um número inteiro. Mas o @Primo me enviou o caminho para aprender a multiplicar em BF, que eu trouxe para o código do Minimal-2D.
Depois de tudo isso, reli o comentário do @ SnoringFrog sobre como incluir o BF e percebi que não apenas eu poderia fazê-lo, como também poderia usar grande parte do código 2D mínimo que eu tinha jogado na resposta do BF. Então eu procurei responder com BF, e aqui estamos nós.
Mais uma coisa antes de eu entrar nos detalhes. Houve algumas alterações que fiz por motivos não relacionados ao golfe. Primeiro, mudei a maior parte do código @SnoringFrog adicionado logo abaixo das linguagens 2D nas várias linhas superiores. Para mim, é um movimento estratégico de longo prazo para evitar que langs 2D atravessem o centro do poliglota, a fim de evitar erros futuros sempre que possível. O acerto de bytes foi baixo para essa mudança, então eu fui a favor.
Segundo, durante os vários re-fatores, aprendi que o Begunges e o Minkolang produzem um espaço à direita após as saídas numéricas e que essa foi a causa dos bytes nulos que vimos no Driver de Teste para esses idiomas. Eu os corrigi produzindo o valor da pilha como um código ascii (que não incluía o recurso de espaço à direita), em vez do valor diretamente. Também houve um pequeno byte atingido para essa alteração, mas agora a saída do Test Driver é tão uniforme. Como eu não poderia?
SM / BF
Vamos analisar rapidamente o básico. Estes são os únicos comandos válidos para SMBF e BF:
> Move the pointer to the right
< Move the pointer to the left
+ Increment the memory cell under the pointer
- Decrement the memory cell under the pointer
. Output the character signified by the cell at the pointer
, Input a character and store it in the cell at the pointer
[ Jump past the matching ] if the cell under the pointer is 0
] Jump back to the matching [ if the cell under the pointer is nonzero
Ambos os idiomas possuem uma fita de memória na qual os valores são armazenados e alterados. A única diferença do SMBF é que qualquer código que está sendo executado também é armazenado na fita de memória à esquerda do ponto de partida. Como o @SnoringFrog apontou, fazer com que o SMBF e o BF produzam resultados diferentes depende de mover o ponteiro da memória para a esquerda da origem. No intérprete BF de Tio, o ponteiro de memória é capaz de se mover para a esquerda da origem e encontrará 0 em vez dos códigos ascii do Polyglot que o SMBF vê. Aqui está um exemplo que pode ser executado no SMBF e no BF para exemplificar a diferença.
No início da poliglota, os Befunges exigem que a >segunda linha seja executada até a conclusão e o Perl6 exige que todos >sejam precedidos por a <. Então, o SM / BF começa com <>o ponteiro de memória na origem e, em seguida, atinge um [que salta alguns caracteres ofensivos dos dois idiomas para ]a 6ª linha.
Em seguida, incrementamos a célula de memória de origem para os dois idiomas e movemos o ponteiro de memória para a esquerda com +<. (Por convenção conversacional, chamaremos a célula de memória de origem como célula 0, células à direita da origem 1, 2, ... E células à esquerda -1, -2, ...). A célula -1 contém o código asci do último caractere na poliglota no SMBF e 0 no BF; portanto, quando o próximo [é encontrado, apenas o BF passa para o próximo ]enquanto o SMBF passa para o código.
À medida que o SMBF percorre, [.>-]ele imprime os 6 encontrados no final da poliglota e move o ponteiro da memória de volta para a célula 0, configurando seu valor novamente para zero para sair do ]. Para revisar, as fitas deste litro são: as células negativas do SMBF retêm a poliglota e são 0 e as células positivas retêm zero. As células negativas e positivas do BF mantêm zero, enquanto a célula de origem mantém 1.
Em seguida, >move o SMBF para a célula 1 e o BF de volta para a célula 0, permitindo que o BF insira seu bloco de código privado: [<+++++[>++++++++++<-][<<<]>+.---.>](removi os caracteres não BF disso). Aqui, voltamos à célula -1 e inicializamos nossa variável de controle de loop (célula -1) para um valor de 5. Em seguida, inserimos o loop em que adicionamos 10 à célula 0 e diminuímos a célula -1 cinco vezes antes de sair do loop em que estaremos apontando para a célula -1 com o valor 0.
Em seguida, encontramos o [<<<]ponto zero, para que o BF não passe por isso. O objetivo aqui é equilibrar um número de >s com os anteriores <para que o Perl6 não se engane.
Nesse ponto, a célula 0 é avaliada em 51. O valor ascii de 4 é 52, então movemos o ponteiro para a célula 0, adicione 1 e imprima o valor. E, finalmente, decrementamos a célula 0 de volta para o caractere ascii 1 e imprimimos novamente antes de definir o ponteiro de memória para a célula 1 (valor 0) para sair após o ].
SMBF e BF atingem o último [na linha 8 a seguir, enquanto ambos estão descansando em um valor 0. Portanto, os dois pulam o código Minimal-2D restante até que ]seja encontrado na linha 11. Mas isso é de curta duração, porque a linha 12 começa com outra [que leva os dois idiomas quase ao final do poliglota, onde não há instruções adicionais.
Refatores
Mínimo-2D
A reescrita do Minimal-2D foi principalmente para salvar alguns bytes de maneira semelhante ao truque de multiplicação do BF. Minimal-2D, no entanto, não possui os caracteres [e ]para controle de loop. Em vez disso, possui estes comandos:
/ Skips next instruction if the data pointer is set to 0.
U Tells the program to switch to the up direction of processing instructions.
D Tells the program to switch to the down direction of processing instructions.
L Tells the program to switch to the left direction of processing instructions.
R Tells the program to switch to the right direction of processing instructions.
Eles podem ser usados para produzir a mesma estrutura lógica, embora em uma mansão 2D, como a do BF. Por exemplo, BF's ++++++[>++++++<-]>.é equivalente a isso no Minimal-2D.
Aqui está uma versão simplificada do código do Minimal-2D no poliglota, com todo o código estranho removido e todo o lugar que contém os caracteres substituídos #.
###################D
###R+++++[D>+++++++L
###>
D>#U/-<+++L)
R+.----.R
A Dlinha 1 envia o ponteiro de instrução para baixo Lna linha 8 da poliglota que envia o ponteiro para a esquerda. Aqui, configuramos a variável de controle do loop (célula 0) para 7, movemos o ponteiro da memória para a célula 1 e inserimos um loop. No loop, adicionamos 3 à célula 1, diminuímos a célula 0 e verificamos se o valor da célula 0 ainda é zero. Caso contrário, adicionamos outros 8 à célula 1 e depois decrementamos e verificamos novamente. O resultado desse loop é que o valor da célula 1 é definido como 51 no final do loop (6 * 8 + 3).
Saímos do loop pulando o U, movendo o ponteiro de memória para a célula 1 e descendo então para a direita na linha 11 do poliglota. E, finalmente, aumentamos o valor de ascii para 4 e depois diminuímos para o valor de ascii para 0 antes de correr para a direita para finalizar o programa.
Retina
A Retina tinha muitos requisitos difíceis de trabalhar para todos os derivados do AM. Não gosta de consecutivos +ou incompatíveis ()ou []. Mas esses são realmente apenas requisitos para todas as outras linhas; portanto, muito do trabalho para BF, SMBF e Minimal-2D girava em torno de colocar a maior parte do código em linhas pares.
O byte comprometido apenas com Retina é o |final da linha 11. Para citar @ ais523 “a maioria das expressões regulares termina com | vai combinar com qualquer coisa ”. Sem isso, Retina retorna 0. Por que isso corrige, eu não sei. Não tive que me aprofundar muito em Retina, provavelmente porque tenho evitado a longa fila. Mas, como o Prelude, descobri que não preciso entender tanto quanto preciso entender como depurar, que neste caso consistia principalmente em excluir linhas (em múltiplos de 2) até encontrar a linha isso está causando a quebra. Imaginei essa correção com base no comentário de @ ais523 e fui recompensado. Eu sou legal demais para a escola, eu acho.
Cardeal
Acontece que eu gostei do posicionamento do @ SnoringFrog do Minimal-2D em relação ao código do Cardinal. É uma boa localização, considerando que o Cardinal não perturba a Retina, e parecia permitir alguma interligação com o Minimal-2D. Então, quando decidi transplantar o Minimal-2D até o 2D, levei o Cardinal para o passeio. Houve algumas mudanças cosméticas no Cardinal. Primeiro, joguei >quase o início de sua declaração #p x%>~~~+ +~*ttt*.xpara o Minimal-2D para alterar os ponteiros de memória dentro de seu loop / Segundo, mudei tudo para um caractere à direita para dar espaço ao Minimal-2D para sair do loop normalmente. O pnesta picada é para este preenchimento de caracteres.
Befunge / 98
Na verdade, os Befunges foram onde eu comecei tentando jogar golfe no poliglota, já que o refator C ++ alterou todos os outros códigos lang 2D, exceto este. Ao tentar descobrir que o WTF estava acontecendo neste código, encontrei isso na documentação do Begunge:
O .comando retira um valor da pilha e o gera como um número inteiro decimal, seguido por um espaço , um pouco como Forth. ,exibirá um valor, interpretará como o valor ASCII de um caractere e produzirá esse caractere ( não seguido por um espaço ) .
Santo Moley! Podemos limpar os bytes nulos na saída. Depois disso, tudo era apenas uma questão de descobrir como inserir valores maiores de asci e segregar o código. Befunge-98 tinha um código de salto ;dizendo-lhe para pular o [77*,68*,@no ;[77*,68*,@;'1,'1,q, que nos deu a segregação.
O Befunge-98 também tinha um comando ( ') para pegar o código ascii do próximo caractere. Portanto, '1,pega o código código ASCI do caractere 1, coloca-o na pilha e depois imprime o caractere ASCII para o valor mais alto da pilha com ,. Só preciso fazer isso duas vezes para imprimir 11 e soltar a qpara sair normalmente.
Befunge adequado é um pouco menos conveniente, mas apenas justo. Aqui temos que fazer um cálculo para colocar o código desejado na pilha. Felizmente, nossos códigos foram facilmente multiplicados por 7 * 7 e 6 * 8 antes do mesmo comando de saída ,. Então saímos de Befunge @antes que o código do irmão mais velho contaminasse a saída.
Minkolang
Depois de encontrar uma correção para os espaços de fuga do Befunge, fiquei muito empolgado com a idéia de encontrar uma correção de Minkolang também e a documentação de Minkolang dizia que o comando de saída usado até esse momento funcionava da mesma maneira que o intérprete de Befunge. OPor acaso, foi documentado como outro comando de saída, que não foi descrito como compartilhando esse princípio, então apenas tirei uma foto no escuro e tentei emitir a string"3" . Vitória perfeita.
> <>
Uma das primeiras coisas que observei ao mover o código 2D mínimo foi verificar se eu podia mover> <> junto com ele. Se eu ia lidar com o transversalismo poliglota 2D, eu lidaria com todas as transgressões. Basicamente, tive sorte em encontrar a solução de colocar ;n4 no final da linha 1 e \Dvoltar mais para a linha 1. BTW, eu não sabia que> <> poderia ser direcionado antes da resposta 40, pois está muito bem contido . Eu gostaria de pensar que isso poderia ser usado mais tarde para divergir> <> de outro idioma semelhante.
Perl6
Eu já falei sobre alguns dos <>problemas de balanceamento do Perl6 em outras partes desta resposta, por isso não vou repassar isso novamente. Mas quero ressaltar que mudei #>27.say#para a penúltima linha. Isso não tem um objetivo funcional nesta resposta. Na verdade, fiz esse movimento para satisfazer uma resposta diferente que acabei não usando nesta rodada. Decidi deixá-lo, pois pretendo postar essa resposta na minha próxima oportunidade e não queria me incomodar em desfazer e refazer.
Correções de bugs
05as1e
O 05as1e definitivamente não gostou do novo código Begunge tanto quanto da versão antiga. Suponho que seja o ,s, já que esse é o único personagem revolucionário. De qualquer forma, tive que "recuar ainda mais na linha dois para ocultar os comandos ofensivos, e sabia que eles "tinham que ir antes do caminho do código Befunge, pois "era um sim nos dois idiomas. (Posso apenas criar termos como sim-op, certo?) A bidimensionalidade da linha 2 é bastante rígida, mas pude deslocar o <caminho de código anterior ao Begunge pelo ". No <entanto, era um requisito do Perl6. (Ele deve ter <todos os >s precedentes .) Consegui soltar a <linha um em um local divinado por instinto e conhecimento prévio, resolvendo a discordância de 05ab1e e Perl6.
Turbilhão
As alterações Befunge na linha 2 adicionaram um extra 1ao poliglota antes da linha Incidente / Giro. Esse extra 1fez com que o Whirl começasse a apontar para as instruções erradas no volante. A primeira 1na diretiva de pré-processador do C / C ++ era apenas uma referência de número de linha no código, e isso poderia ser facilmente qualquer outro número de linha, então eu mudei isso arbitrariamente 4para satisfazer o Whirl.
Incidente
A cadeia de decodificação no final da poliglota é bem conhecida neste momento, então não vou entrar nela. Eu removi da string o que pude e adicionei os novos tokens necessários. Existem 2 caracteres de descriptografia que não estão nessa string, embora eu deva apontar. Em primeiro lugar, o segundo Rem #R+.----.R >]|é necessária aqui, porque é um ponto de fusão de partida, e que era mais seguro nesta linha porque já havia um ponto de título Fusão de partida na mesma direção. Segundo, o xin #= xé remover um token envolvido em um ␉␊#padrão, que se tornou mais comum.
Outras
Hexagony, Whitespace e Prelude todos tiveram os pequenos ajustes usuais, mas nada de especial que valha a pena falar.
Pensamentos finais
É tudo o que tenho para esta resposta. Para aqueles que procuram um ponto de partida para a próxima resposta, sugiro o mal. Parece viável, embora eu não tenha olhado muito de perto, mas suspeito que não seria muito difícil de integrar. Eu sei que ele tem um comando de salto que deve ajudar a ignorar a maior parte do poliglota. Boa sorte.
