Escreva um programa que produz uma saída como:

1. Aparecem pelo menos três caracteres distintos.
2. O número de ocorrências de cada caractere é um múltiplo de 3.

Por exemplo, A TEA AT TEEé uma saída válido desde que cada um dos 4 caracteres distintos, A, E, Te (space), ocorre 3 vezes.

Obviamente, um desafio sobre o número 3 precisa ter um terceiro requisito. Assim:

3. O próprio programa também deve seguir os dois primeiros requisitos. (Isso significa que seu programa terá pelo menos 9 bytes.)

Você deve escrever um programa completo, não uma função. Certifique-se de mostrar a saída do seu programa na sua resposta.

Além disso, para manter as coisas interessantes, você é altamente incentivado:

• não usar comentários para atender ao requisito 3, se você puder ajudá-lo
• para produzir uma saída que não seja apenas uma sequência repetida 3 vezes
• para tornar a saída diferente do próprio programa (para idiomas que podem gerar automaticamente o conteúdo de seu próprio programa, você pode contribuir com este wiki da comunidade ).

Isso é código-golfe . O menor código em bytes vence.

Brain-Flak , Flakcats , Brain-Flueue , Brain-Flak Classic , Miniflak e Fλak 18 bytes

Ótimo comprovado!

((([()][()][()])))

Experimente online!

Explicação

Flak cerebral, Flueue cerebral, Miniflak e Fλak

   ([()][()][()]) Push -3
  (              ) Copy
 (                ) Copy

Isso imprime:

-3
-3
-3

(Existe uma nova linha à direita)

Brain-Flak Classic

O Brain-Flak Classic é a versão original do Brain-Flak e apresenta algumas diferenças importantes em relação ao Brain-Flak moderno. No BFC [...]imprime seu conteúdo em vez de negá-lo.

   [()] Print 1
       [()] Print 1
           [()] Print 1
  (            ) Push 3
 (              ) Push 3
(                ) Push 3

No final da execução, o conteúdo da pilha ( 3 3 3) é impresso.

Isso imprime:

1
1
1
3
3
3

(Existe uma nova linha à direita)

Flakcats

O Flakcats é bem diferente dos outros 4 flocos e estou surpreso que isso funcione no Flakcats. Os três operadores aqui são quase os mesmos que o Brain-Flak usa.

A principal diferença neste programa em particular entre o Flakcats é o (...)operador que no Flakcats é equivalente ao ([{}]...)Brain-Flak. Isso, no entanto, não faz diferença para nós, porque apanha zeros e, portanto, opera da mesma maneira que o Brain-Flak.

Aqui está o programa compilado no Brian-Flak:

([{}]([{}]([{}][()][()][()])))

Isso imprime:

-3
-3
-3

(Existe uma nova linha à direita)

Prova de Optimalidade em Brain-Flak e Miniflak

Esta não é uma prova formal, mas sim uma prova informal que precisaria ser expandida para se tornar mais rigorosa

Devido às restrições de que os programas Brain-Flak devem ser de seqüência equilibrada e o tamanho do programa deve ser um múltiplo de 3, qualquer envio válido deve ter um múltiplo de 6 de comprimento. Isso significa que qualquer solução menor que 18 deve ter o comprimento 12.

Devido às saídas que seguem a nova linha, a altura final da pilha deve ser um múltiplo de três ou quebraremos as restrições na saída.

Qualquer envio válido de tamanho 12 deve ter 2 tipos de chaves (se menos, violaria as restrições ao número de caracteres distintos e mais significaria mais de 12 caracteres). Como o programa produz saída, ele deve ser pressionado.

Isso nos deixa selecionar nosso outro conjunto de chaves. As opções são:

<...>/<>

Isso falha porque precisamos gerar "valor" para criar qualquer número diferente de zero. Devemos desistir de a ()para criar um número que torne impossível pressionar mais de duas vezes.

[...]/[]

Isso falha pelo mesmo motivo que o último falhou. As chaves quadradas são muito ruins em gerar valor. A []mônada pode criar valor, mas precisamos pressionar os números primeiro e, então, não temos parênteses suficientes para pressionar três vezes.

{...}/{}

Este é promissor, poderíamos criar um loop e usá-lo ()para enviar várias vezes, mas, infelizmente, não é possível.

Para que o loop termine, deve haver um zero na pilha em algum momento e, para que possamos ter a saída correta, devemos ter algo diferente de zero na pilha no final do programa. Como não temos []nem <>o zero no final do loop deve ser um zero implícito da parte inferior da pilha. Isso significa que o loop não pode adicionar novos números à pilha, tornando-a inútil.

Como nenhuma das opções de chaves pode criar um programa de comprimento 12, nenhuma pode existir.

Como o Miniflak é um subconjunto do Brain-Flak, qualquer programa Miniflak mais curto também seria um programa Brain-Flak mais curto e, portanto, não existe.

Prova de Optimalidade na Conduta Cerebral

Brain-Flueue é uma linguagem de piada baseada no Brain-Flak. Os dois são tão parecidos que seus intérpretes são idênticos em qualquer lugar, exceto em duas linhas. A diferença entre os dois é, como o nome sugere, o Brain-Flueue armazena seus dados em filas, enquanto o Brain-Flak armazena seus dados em pilhas.

Para começar, temos as mesmas restrições no tamanho do programa criadas pelo Brain-Flak, portanto, estamos procurando um programa de tamanho 12. Além disso, precisaremos de um (...)para criar qualquer saída e outro par. os pares <>e []não funcionam no Brain-Flueue exatamente pela mesma razão que não funcionam no Brain-Flak.

Agora sabemos que nosso programa deve consistir nos caracteres ((())){{{}}}.

Através dos mesmos métodos usados ​​na prova anterior, podemos demonstrar que deve haver um loop no programa final.

Agora, aqui é onde as provas diferem, porque o Brain-Flueue opera em filas, em vez de pilhas, o programa pode sair de um loop com valores na fila.

Para sair do loop, precisaremos de um zero na fila (ou uma fila vazia, mas se a fila estiver vazia, teremos o mesmo problema que o Brain-Flak), isso significa que teremos que abrir nosso programa ({})para criar o zero. Vamos precisar de um push dentro do loop para enviar o número necessário de itens para a fila. Também precisaremos enviar um número diferente de zero antes do loop, para que possamos inseri-lo; isso nos custará no mínimo absoluto (()). Agora usamos mais parênteses do que usamos.

Portanto, não existe um programa Brain-Flueue para executar a tarefa com 12 bytes e, além disso, nosso programa é ideal.

Solução ideal em Flakcats e Brain-Flak Classic

A solução a seguir é ideal no Flakcats e no Brain-Flak Classic.

((([][][])))

Explicação

    [][][] -3
 (((      ))) push 3 times

Soluções alternativas de Brain-Flak de 24 bytes

(<((<((<(())>)())>)())>)

Experimente online!

((<((<((<>)())>)())>)())

Experimente online!

((((((()()()){}){}){})))

Experimente online!

Geléia , 9 bytes

**‘‘‘888*

Um programa completo que imprime 700227072 , com 888 em cubos.

TryItOnline!

Quão?

**‘‘‘888* - Main link: no arguments
          - implicit L=R=0
*         - power       A = L ^ R = 1
  ‘       - increment   B = L + 1 = 1
 *        - power       C = A ^ B = 1
   ‘      - increment   D = C + 1 = 2
    ‘     - increment   E = D + 1 = 3
     888  - literal     F = 888
        * - power           F ^ E = 700227072

Poliglota de respostas puramente literais, 9 bytes

333111222

Esta é uma postagem do wiki da comunidade para coletar respostas que são apenas literais que o idioma em questão imprime automaticamente. Por ser um wiki da comunidade, fique à vontade para editá-lo para adicionar mais idiomas onde ele funciona.

Este programa trabalha em:

• PHP
• HTML (sem dúvida uma linguagem)
• Gelatina (e M )
• 7 (mais interessante, porque o programa é interpretado como dados e código; o primeiro 3imprime os dados, o restante do programa é uma manipulação inútil de pilha)
• CJam
• Japt
• Cenoura
• R (a tela R também gera [1] como metadados)
• RProgN
• Na verdade (apesar de realmente imprimir 2\n2\n2\n1\n1\n1\n3\n3\n3\n)
• ///
• Noodel
• TI-Basic
• SimpleTemplate
• ReRegex
• Casca
• Recurso (embora isso produza a string invertida)

Ignorando a nova linha final, isso é válido em mais alguns idiomas:

• 05AB1E
• 2sable
• GolfScript
• PowerShell
• m4 (qualquer versão, o programa é portátil)
• Pyth
• MATL
• Pip
• Stax
• Tinta
• Barril

A maioria dos links vai para Experimente Online!

C #, 114 111 118 102 bytes

Se não nos importamos em usar palavras adequadas: (102 bytes)

class CCcddiilMMmmnrrSSsttvvWWyy{static void Main(){{System.Console.Write(("A TEA AT TEE"));;;}}}///".

Se nos preocupamos com palavras adequadas: (120 bytes)

class erebeWyvern{static void Main(){int embedWildbanana;{System.Console.Write(("A TEA AT TEE"));;}}}///CC Myst mvcSMS".

Minha submissão original - não faz distinção entre maiúsculas e minúsculas: (113 bytes)

class EreBeWyvern{static void Main(){int embedwildbanana; {System.Console.Write(("A TEA AT TEE"));;}}}/// vyt".

Eu sei que o comentário não está realmente no espírito do CG, mas é tudo o que posso fazer em um período limitado de tempo, vou ver se consigo melhorá-lo ao longo do dia. Certamente devo obter pelo menos alguns pontos de bônus para que o aceno seja aventureiro.

Edit: Obrigado a roberto06 por pegar as cartas que faltam!

JavaScript, 36 33 bytes

alert(((alert|alert||333111222)))

Alertas 333111222. Isso funciona porque |converte os dois operandos em números inteiros de 32 bits e qualquer valor que não se pareça com um número inteiro (por exemplo, a função alert) é convertido em 0. 0|0é 0, então o ||operador retorna seu operando certo ou333111222

Mais algumas versões interessantes:

(a="(trelalert)\\\"")+alert(a+=a+=a)

Saídas (trelalert)\"(trelalert)\"(trelalert)\".

Uma solução usando .repeatteria o mesmo comprimento, graças ao compartilhamento aert:

alert("(trpp.all)\\\"".repeat(3.33))

quais saídas (trpp.all)\"(trpp.all)\"(trpp.all)\".

Aproveitando as barras invertidas extras para se livrar le p quase funciona:

a\x6cert("(trax.cc)\"".re\x70eat(6.00677))

Este sai (trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)".

CJam , 9 bytes

10,10,10,

Saídas 012345678901234567890123456789

Experimente online!

Explicação

10,       The range from 0 to 9
   10,    The range from 0 to 9
      10, The range from 0 to 9

brainfuck , 12 bytes

++[+...][][]

Ninguém disse que a produção tinha que ser curta. Isso produzirá 3 cópias de todos os caracteres ascii, exceto os 2 primeiros.

Você pode provar que isso é o mais curto possível. Você precisa produzir, portanto, precisa de 3 '.' é preciso haver saídas diferentes, portanto, você precisa de 3 [+ -] agora temos até 6. 9 caracteres devem ser impressos, o que significa adicionar mais 6 '.' ou adicionando um loop, que adicionará outros 6 caracteres.

Experimente online!

Python 2, 36 e 30 bytes

Como uma nova linha à direita não é permitida, provavelmente é o mais curto possível:

print"\\\""*3;print;print;3**3

Experimente online

Saídas \"três vezes, seguidas por três novas linhas.

Os programas abaixo não contam a nova linha à direita, portanto não são válidos.

27 bytes :

print"""printprint"""*3*3*3

Imprime 54 de cada caractere em print.

Experimente online

Mesmo comprimento, saída mais curta:

print"""printprint*3*3"""*3

Saídas printprint*3*3printprint*3*3printprint*3*3

24 bytes:

print~9;print~9;print~9;

Perl 6 , 15 bytes

.say;.say;.say;

Imprime seis caracteres distintos, três vezes cada:

(Qualquer)
(Qualquer)
(Qualquer)

Experimente online!

Como funciona

• Uma chamada de método simples opera no tópico atual $_,.
• $_começa como o objeto de tipo do tipo Any, que é sayimpresso como (Any).

C, 66 bytes

main(i){{for(i=0;i<3;i++){printf("""poop+fart=<3<3at0m=m0n""");}}}

Resultado

poop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0n    

Versão antiga 72 bytes

main(i){for(i=0;i<3;i++){printf("poop+fart=<3<3 at {\"0m=m0\"}" "\n");}}

JavaScript (ES6), 30 bytes

+alert((({alert}+{alert}+{})))

Saídas [object Object][object Object][object Object].

Funciona criando três objetos:

• os dois primeiros são do formato { "alert" : alert }usando a notação ES6{alert}

• o terceiro é um objeto vazio simples

Em seguida, ele é usado +para concatená-los juntos, e todos os três têm uma expressão idêntica à de uma string [object Object].

O líder +é inútil, presente apenas para preencher o número de +caracteres, mas é inofensivo para a saída do programa.

PKod , 9 bytes

sonsonson

Saídas: 111222333

Explicação:

Background: PKod has only one variable that you mess with, with the code
This variable starts with default value of 0

s  -  Add next char to the variable, and jump over it. 
n  -  Print numeric value of variable

o possui o código ASCII "111" em decimal. Assim, s adiciona 111 à variável e depois imprime o número. O primeiro "filho" faz 111 e imprime 111. Em seguida, faz 222 e imprime 222, finalmente faz 333 e imprime 333

Ruby , 12 bytes

p$@;p$@;p$@;

saídas

nil
nil
nil

Experimente online!

Para cumprir o segundo critério "encorajado", preciso de 15 caracteres:

p 1;p 3;p 1133;

produz

1
3
1133

Experimente online também!

Microscript II, 9 bytes

{{{~~~}}}

Explicação: Cria um bloco de código, mas não o invoca. Quando a execução termina, o conteúdo do registro principal (ou seja, esse bloco de código) é impresso implicitamente.

Hexagonia , 9 bytes

x!!xx@@!@

Experimente online!

Imprima 120120120. xpode ser substituído por f-m(102-109)

Explicação

  x ! ! 
 x x @ @
! @ . . .

O xx@@é apenas um preenchedor para cumprir as regras. O fluxo principal é salvo xna memória (com valor ASCII 120) e, em seguida, imprime-o como um número 3 vezes.

C, 111 bytes

(Observe como a contagem de bytes também é os três mesmos números. Uau. Você não pode fazer mais meta do que isso.)

#include<stdio.h>
#define b "<acdhlmoprsu>."
#define t "en"
main(){{{printf(("<acdhlmoprsu>." b b t t t));;;}}}

Impressões:

<acdhlmoprsu>.<acdhlmoprsu>.<acdhlmoprsu>.enenen

PHP , 33 bytes

<?=($s="<?;<?=;'".'"').($s).($s);

Optou por algo mais interessante do que o programa de 9 bytes sem tag PHP.

Saídas <?;<?=;'"<?;<?=;'"<?;<?=;'"

Experimente online!

99 , 15 bytes

9 9  9999
9
9
9

Ou seja, nove noves, três espaços e três alimentações de linha, a saída é -1110-1110-1110 .

Experimente online!

Quão?

9 9  9999 - V(9)=V(9)-V(9999)=1-1111=-1110
9         - print V(9)
9         - print V(9)
9         - print V(9)

Os dois espaços são tratados como um; esse terceiro espaço também pode ser um espaço à direita em qualquer linha.

Bash + coreutils, 15 9 bytes

id;id;id;

Experimente online!

Saída de amostra:

uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211

(Se você tentar fazer isso, ele imprimirá seu uid, gid, etc., três vezes.)

Se você quiser evitar repetir a mesma string três vezes (e também tiver a mesma saída para todos, diferente da minha primeira resposta), o melhor que encontrei para os utilitários bash + Unix tem 15 bytes:

dc<<<cczdzfzfdf

Experimente esta segunda versão online!

Resultado:

2
0
0
3
2
0
0
3
3
2
0
0

(Nenhuma nova linha no programa, 12 novas linhas na saída.)

Explicação do programa dc nesta resposta:

c Clears the stack.
Stack: (empty)

c Clears the stack.
Stack: (empty)

z Pushes the current size of the stack (0) onto the stack.
Stack: (top) 0

d Duplicates the item at the top of the stack.
Stack: (top) 0 0

z Pushes the current size of the stack (2) onto the stack.
Stack: (top) 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the first 3 lines of the output, 2 / 0 / 0 /)

z Pushes the current size of the stack (3) onto the stack.
Stack: (top) 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the next 4 lines of the output, 3 / 2 / 0 / 0 /)

d Duplicates the item at the top of the stack.
Stack: (top) 3 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the final 5 lines of the output, 3 / 3 / 2 / 0 / 0 /)

LOLCODE , 273 240 ( 360 286) bytes

HAI 1.2
I HAS A U
IM IN YR M UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "Y SUB.EK"
IM OUTTA YR M
IM IN YR T UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "Y SUB.EK"
IM OUTTA YR T
IM IN YR X UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IM"
IM OUTTA YR X
KTHXBYE

Observe a nova linha à direita e tente online . A segunda linha era mais ou menos arbitrária e pode ser substituída por um comando mais curto, mas eu apenas aprendi LOLCODE para esse quebra-cabeça. Como o número da versão é necessário na primeira linha, usei os números para adicionar loops de comprimento 1, 2 e 0 mod 3 para garantir que o número correto de caracteres seja impresso. A partir disso, eu simplesmente contei cada caractere (com esta ferramenta ). Se aparecer 0 mod 3 vezes, nenhuma ação será necessária. Se ele apareceu 1 mod 3 vezes, foi adicionado ao loop 1 e 2 para aparecer três vezes na saída. Se ele apareceu 2 mod 3 vezes, o personagem foi adicionado ao loop de 12. EDIT: substituindo o primeiroVISIBLE com uma tarefa (ainda inútil, mas necessária para ter 12 em vez de 11 novas linhas), consegui cortar 33 bytes.

Saída (60 bytes):

Y SUB.EK
Y SUB.EK
Y SUB.EK
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM

Observe a nova linha à direita.

O legal dessa solução, em comparação com as outras respostas, é que o Output pode ser facilmente manipulado para gerar um texto com algum significado. Exemplo (286 bytes com nova linha à direita):

HAI 1.2
I HAS A U
IM IN YR MW UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR MW
IM IN YR STA UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR STA
IM IN YR XURG UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IMO U R SWAG! "
IM OUTTA YR XURG
KTHXBYE

Experimente online. Saída (222 bytes com nova linha à direita):

YO SUB. EEEEK!
YO SUB. EEEEK!
YO SUB. EEEEK!
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 

Infelizmente, não sou tão bom com anagramas quanto pensei: ')

CONCHA

para brincar :) ( 9 bytes )

ls;ls;ls;

ou mais a sério ( 24 bytes )

sed s/./sed.g./g <<< edg

Resultado:

sed.g.sed.g.sed.g.

PHP, 24 bytes

<?=111?><?=222?><?=333?>

Lote, 36 21 bytes

@echo
@echo
@echo

Saídas

ECHO is on.
ECHO is on.
ECHO is on.

Editar: salvou 15 bytes graças a @ P.Ktinos.

Japonês, 9 bytes

000OoOoOo

Imprime undefinedundefinedundefined. Teste online!

Explicação

Esse código é transpilado para o seguinte JavaScript:

000,O.o(O.o(O.o()))

O.oé uma função que gera algo sem uma nova linha à direita. Quando não é apresentado nenhum argumento, ele imprime undefined, o que pode ser considerado um bug, mas é útil aqui. Também retorna undefined, para que todas as três chamadas sejam impressas undefined.

Tenho certeza que existem muitas outras maneiras de fazer isso ...

05AB1E , 9 bytes (acho que você poderia dizer que isso era um pedaço de PI)

-0 bytes graças a Emigna / ETHProductions, tornou a solução mais correta.

žqžqžq???

Versões alternativas:

ž[g-Q]ž[g-Q]ž[g-Q]???

[g-Q] - Pode colocar qualquer letra aQ aqui, desde que todas correspondam (veja abaixo).

Experimente online!

Explicado:

PI,PI,PI,SORT,JOIN,SORT,JOIN,SORT,JOIN.

Resultado:

...111111222333333333444555555555666777888999999999

A razão é de apenas 9 bytes é porque você não precisa dos tipos, apenas os coloquei para ajudar a ilustrar.

Resultado sem o {código:

3.1415926535897933.1415926535897933.141592653589793

Representações alternativas:

Os seguintes comandos podem ser usados ​​no lugar do PI:

ž 23  > žg       push current year
        žh       push [0-9]
        ži       push [a-zA-Z]
        žj       push [a-zA-Z0-9_]
        žk       push [z-aZ-A]
        žl       push [z-aZ-A9-0_]
        žm       push [9-0]
        žn       push [A-Za-z]
        žo       push [Z-Az-a]
        žp       push [Z-A]
        žq       push pi
        žr       push e
        žu       push ()<>[]{}
        žy       push 128
        žz       push 256
        žA       push 512
        žB       push 1024
        žC       push 2048
        žD       push 4096
        žE       push 8192
        žF       push 16384
        žG       push 32768
        žH       push 65536
        žI       push 2147483648
        žJ       push 4294967296
        žK       push [a-zA-Z0-9]
        žL       push [z-aZ-A9-0]
        žM       push aeiou
        žN       push bcdfghjklmnpqrstvwxyz
        žO       push aeiouy
        žP       push bcdfghjklmnpqrstvwxz
        žQ       push printable ASCII character set (32-128)

Cubix , 12 bytes

Uma resposta um pouco chata, na verdade. Saídas três 10s seguidas por novas linhas

N@N@NOoOoOo@

Experimente online! Mapeia para o cubo

    N @
    N @
N O o O o O o @
. . . . . . . .
    . .
    . .

NEmpurra 10 para a pilha
Oox3 Saídas 10 e a nova linha
@interrompe o programa

A inicial N@N@não foi atingida.

Pepe , 24 bytes

rEeEEeeEEErreEErreEEreEE

Experimente online!

O programa contém 6 r, 6 e 12 E.

Explicação:

rEeEEeeEEErreEErreEEreEE # full program

rEeEEeeEEE               # push '103' to the stack
          rreEErreEE     # output as int (r flag: preserve)
                    reEE # output as int

Resultado:

103103103

V , 9 bytes

12i12i12i

Experimente online!

Saídas 12i24 vezes:

12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i

Vim, 12 bytes

12i12i12i<ESC><ESC><ESC>

Emite o mesmo que a resposta V

empilhados , 24 bytes

''''   'putput'3*3*3*put

Experimente online! Produz 54cada um de p ue t.

Abaixo 93 , 9 bytes

...,,,@@@

TIO

Impressões 0 0 0(espaço à direita, seguido por 3 bytes nulos)

Como a pilha do Befunge é preenchida com 0s, podemos imprimir o caractere ASCII com esse valor e o próprio número inteiro. Como o Befunge imprime automaticamente um espaço após um número inteiro, ficamos com três caracteres distintos.

.imprime 0(espaço à direita), ,imprime um byte nulo e @termina o programa