Obviamente, o código do golfe tem tudo a ver com aproveitar ao máximo o código. Quem realmente se importa com o resultado real?

Embora tenhamos enfrentado um desafio pela maior taxa de entrada / saída , essa é uma exigência para a saída mais finita e determinística com comprimentos de código especificados. Ironicamente, esse desafio não é o código-golfe .

Regras:

1. Escreva três trechos independentes (não programas / funções completos).

2. Os trechos devem estar no mesmo idioma.

3. Pontuação é o número total de bytes gerados.

4. As saídas podem estar na forma de um resultado, STDOUT etc.

5. Os trechos não podem causar nenhum erro.

6. Os trechos podem causar diferentes formas de saída.

7. Caracteres de nova linha à direita não são contados.

8. O primeiro snippet deve ter 1 byte ou o comprimento mínimo que produz pelo menos 1 byte de saída.

9. O segundo snippet deve ter um byte a mais que isso.

10. O terceiro trecho deve ter dois bytes a mais que o primeiro.

gs2, 412 + 5,37 * 10 ⁹⁰² + 10 ^{10 903,1} bytes

1. fenvia 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzcomo uma 412sequência de bytes.

2. fôimprime todas as suas permutações, portanto, 412! * 412caracteres.

3. fôôimprime todas as permutações dessa lista de elementos 412 !, em que cada elemento possui 412 caracteres, portanto 412 * (412!)!bytes.

EDIT: Para colocar as coisas em perspectiva, isso é pelo menos

10^{100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

bytes, superando todas as outras respostas aqui até agora.

Pyth, 26 + 1140850688 + (> 4,37 × 10 ^20201781 )

Não tenho idéia se é possível calcular o comprimento exato da saída para o terceiro programa. Eu só posso dar limites. Irá imprimir algo entre 4.37 × 10^20201781e 1.25 × 10^20201790caracteres.

G
yG
yyG

Isso imprime:

abcdefghijklmnopqrstuvwxyz
['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']
[[], [''], ['a'], ['b'], ['c'], ..., ['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']]

O primeiro imprime o alfabeto, o segundo todos os subconjuntos do alfabeto e o terceiro os subconjuntos dos subconjuntos do alfabeto, que é uma lista de comprimento 2^(2^26) ~= 1.09 × 10^20201781.

Obviamente, nenhum computador será capaz de calcular essa grande lista e produzi-la.

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 bytes de saída

Para uma comparação mais fácil, isso é aproximadamente 7,3 * 10 ¹⁹ .

P
PP
Ke!

Impressões:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Bem, o último consiste em todas as permutações de [0 1 2 ... 19]com os números esmagados juntos. Eu não recomendaria experimentá-lo ... (Experimente como 4e!se fosse provar.)

Teste aqui: Programa 1 , Programa 2 , versão saudável do programa 3 .

Gelatina , 1,2 × 10 ²⁵⁶⁸ bytes de saída

ȷ
ȷ*
ȷ*!

Calcula 1000 , 1000 ¹⁰⁰⁰ e 1000 ^1000! .

Experimente online: primeiro programa | segundo programa | terceiro programa (modificado)

Para fins de contagem de bytes, ȷpode ser codificado como o byte 0xa0 na versão atual do Jelly .

Como funciona

No Jelly, ȷpode ser usado dentro de literais numéricos como o Python e(notação científica). Por exemplo, 3ȷ4retorna 30000 . Em notação científica da Jelly, os padrões coeficiente a 1 e os padrões expoente para 3 , por isso ȷ, 1ȷ3e 1000tudo devolver o mesmo número.

ȷ      Return 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
 *     Hook; compute 1000 ** 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
  !    Return 1000!.
 *     Fork; compute 1000 ** 1000!.

Hexagonia , 1 + 3 + 6 = 10 bytes de saída

Bem ... não é uma pontuação muito impressionante, mas pelo menos posso afirmar que é ideal. Com um único bytes, é impossível imprimir algo e terminar, então começamos com dois bytes:

!@

O código desdobrado é

 ! @
. . .
 . .

Isso imprime um byte e termina.

Para três bytes de código, podemos imprimir três bytes de saída. Por exemplo:

o!@

ou desdobrado:

 o !
@ . .
 . .

impressões 111. Qualquer letra minúscula de dpara zfunciona e imprime seu código de caractere. Essas são as únicas 23 maneiras de imprimir 3 bytes com 3 bytes de código.

Finalmente, para quatro bytes, existem 169 maneiras de imprimir 6 bytes. Como nenhum deles faz algo mais interessante (exceto o fluxo de controle ímpar) do que a solução direta, apresentarei que:

o!!@

Desdobrado:

 o !
! @ .
 . .

Você adivinhou. Imprime 111111.

Como sei se essas são ótimas? Eu adaptei o forçador bruto que escrevi para o catálogo de máquinas da verdade para procurar a saída finita máxima em 7000 ciclos (não acho que você possa escrever um castor ocupado com 4 bytes, que roda por 7000 ciclos, mas termina ainda mais tarde).

Sério, 2025409 bytes

1 byte:

N

(produz 11.756 bytes de saída)

2 bytes:

Nñ

Produz 153.717 bytes de saída

3 bytes:

9!!

Produz 1.859.936 bytes de saída

Sério ainda não apresenta itens como "todos os subconjuntos" ou "todas as combinações", portanto, a pontuação é relativamente baixa.

Python 3, 1 + 22 + 23 = 56

9
id
abs

Resultado

9
<built-in function id>
<built-in function abs>

Imprima 9 e depois a definição para ide abs.

Labirinto , 1 + 2 + 4 = 7 bytes

Outra pontuação baixa, que estou publicando principalmente porque provei que é ideal para o idioma.

Como o Hexagony, o Labyrinth não pode imprimir e terminar com um único byte; portanto, começamos com dois bytes:

!@

Imprime um zero e termina.

Por três bytes, não podemos vencer a solução ingênua:

!!@

Isso imprime dois bytes antes de terminar. Existem algumas outras opções, como imprimir -1com (!@ou ~!@ou ,!@. Existe uma solução bem legal que usa rotação de código fonte:

!>@

Isso imprime um zero e muda a fonte para se tornar @!>. Nesse ponto, ele atinge um beco sem saída, vira e executa !novamente no caminho de volta, antes de terminar.

Para quatro bytes, é um pouco mais divertido, porque a única maneira de imprimir 4 caracteres é usar o truque acima:

!!>@

Imprima dois zeros, mude para @!!>, imprima outros dois zeros.

Em todos esses casos, estou ignorando que você também pode imprimir um byte com \ou ., porque eles sempre imprimem exatamente um byte, enquanto !que imprimem pelo menos um e potencialmente vários.

Bash, 1726 bytes

(Corrigi-o agora. Por favor, considere a possibilidade de votar.)

1 byte :"

Saídas:

>

307 bytes: id

Saídas:

uid=501(geokavel) gid=20(staff) groups=20(staff),701(com.apple.sharepoint.group.1),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),33(_appstore),100(_lpoperator),204(_developer),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)

1418 bytes: zip (Imprime em STDOUT)

Copyright (c) 1990-2008 Info-ZIP - Digite 'zip "-L"' para licença de software.
Zip 3.0 (5 de julho de 2008). Uso:
zip [-options] [-b path] [-t mmddyyyy] [-n sufixos] [zipfile list] [-xi list]
  A ação padrão é adicionar ou substituir entradas zipfile da lista, que
  pode incluir o nome especial - para compactar a entrada padrão.
  Se o zipfile e a lista forem omitidos, o zip compacta stdin para stdout.
  -f freshen: apenas arquivos alterados -u update: apenas arquivos alterados ou novos
  -d excluir entradas no zipfile -m mover para zipfile (excluir arquivos do sistema operacional)
  -r recursão nos diretórios -j nomes de diretório indesejados (não registra)
  -0 armazena apenas -l converte LF em CR LF (-ll CR LF em LF)
  -1 comprime mais rápido -9 comprime melhor
  -q operação silenciosa -v operação detalhada / informações sobre a versão impressa
  -c adiciona comentários em uma linha -z adiciona comentário zipfile
  - @ lê os nomes de stdin -o torna o zipfile tão antigo quanto a última entrada
  -x exclui os seguintes nomes -i inclui apenas os seguintes nomes
  -F corrige o arquivo zip (-FF se esforça mais) -D não adiciona entradas de diretório
  -A ajusta exe auto-extraível -J Junk zipfile prefix (unzipsfx)
  -T integridade do arquivo zip de teste -X atributos do arquivo eXclude eXtra
  -y armazena links simbólicos como o link em vez do arquivo referenciado
  -e encrypt -n não compacta esses sufixos
  -h2 mostrar mais ajuda

MATL , 313

A versão atual do idioma ( 3.1.0 ) é usada, anterior a esse desafio.

1. Código (literal predefinido: produz o número 2, que é impresso implicitamente):

   H
   

   Saída (1 byte):

   2
   

2. Código (produz o número pi, que é impresso implicitamente com 15 casas decimais):

   YP
   

   Saída (17 bytes):

   3.141592653589793
   

3. Código (números de 1 a 99, que são impressos por padrão com espaços no meio):

    99:
   

   Saída (295 bytes):

   1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
   

Processando, 39 bytes

Determinístico

1 byte :

print(X);

Saídas 0 .

9 bytes :

print(PI);

Saídas 3.1415927

29 bytes :

print(P3D);

Saídas processing.opengl.PGraphics3D

Não determinístico,> = 129 bytes

> = 32 bytes:

print(g);

Saídas processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 bytes:

print( g);

Saídas processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 bytes: (Obrigado a @anOKsquirrel por esta sugestão.)

print(g,g);

Saídas

processing.awt.PGraphicsJava2D@ + [mem-address]
processing.awt.PGraphicsJava2D@ + [mem-address]

JavaScript, 1 + 3 + 18 = 18 22

Não é uma resposta muito interessante, mas provavelmente o melhor JavaScript é capaz.

alert(1)
alert(.1)
alert(1/9)

Adicionado 4 pontos graças a @UndefinedFunction !

Saídas como texto:

1
0.1
0.1111111111111111

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

Qualquer trecho menor que o comprimento 2 não pode ser emitido ou não pode finalizar sua saída.

No Befunge, .gera o valor superior da pilha como um número inteiro, seguido por um espaço. Um espaço não é uma nova linha; portanto, é incluído na contagem. Além disso, a pilha é "infinitamente" preenchida com zeros, portanto os programas produzem (respectivamente):

0 
0 0 
0 0 0 

SmileBASIC, 1 + 4 + 10 = 15 bytes

Programa 1:

A maneira mais curta de imprimir algo é com? (PRINT) e um único caractere. Pode ser um número ou um nome de variável e não importa, pois todos têm o mesmo comprimento.

?1
1

Programa 2:

Agora temos acesso a mais algumas coisas. A expressão mais longa que pode ser feita seria uma das constantes #Y, #L ou #R, que possuem os valores 128, 256 e 512, respectivamente. No entanto, em vez disso, uso uma vírgula para que (nesse caso) 3 espaços extras sejam impressos.

?1,
1   

Programa 3:

Com 3 caracteres, você pode escrever números de notação E:

?1E9
1000000000

HQ9 +, 71304

9

Imprime as letras de 11.884 caracteres de "99 garrafas de cerveja"

99

Imprime "99 garrafas de cerveja" duas vezes

999

Imprime "99 garrafas de cerveja" três vezes

Japão -Q, Saídas1.0123378918474279e+150 bytes

O número completo é

1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,568

bytes.

# 1

M

Saídas

{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}

Para 67 bytes. (Crédito para Shaggy)

# 2

LÆ

Saídas

[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]

que é 501 bytes.

(Crédito para @Shaggy)

# 3

;Eá

Produz todas as permutações dos 95 caracteres imprimíveis ASCII no formato ["...","...","..."...], que é

$1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,001$ bytes de saída.

Você pode obter uma quantidade infinita de bytes de saída se usar o -Fsinalizador em Japt. O que faz é que, se a última expressão do programa for avaliada como falsa, ela emitirá o valor especificado no sinalizador. Então eu acho que a pontuação para Japt -F"Insert Super Long String Here"é infinito.

Malbolge , 1 + 2 + 3 = 6 bytes

(=aN
(&a`M
(=a`_L

Experimente online: primeiro , segundo , terceiro

Saídas:

r
ll
xxx

Bruto forçado. Assume que \0não é um caractere de saída válido

Com \0:

cP
cbO
cbaN

Saídas:

\0
\0\0
\0\0\0

scg , 1 + 27 + 188 = 216

Primeiro:

1

Apenas imprime 1, pois a pilha é impressa no final do programa.

Segundo:

.d

Imprime informações de depuração, que devem ser assim:

Stack: []
Array Markers: []

Terceiro:

99r

adiciona 99 à pilha e usa a função range. Saídas 01234567891011 .... (este é um daqueles momentos em que desejo implementar a função fatorial. Não o fiz)

Marbelous 1 + 1 + 2 = 4 bytes de saída

Marbelous é interrompido aqui por ter instruções de dois bytes. Comentários inúteis ou espaços em branco desnecessários são as únicas maneiras de obter uma contagem de bytes ímpares.

imprima "A" e termine:

`A

imprima "B" e termine com um comentário EOL vazio

`B#

imprima "CD" e termine:

`C`D

Mathematica, 6 + 461 + 763 = 1230 1225 618 163 bytes de saída

%  (* -> Out[0] *)

?D  (* ->

D[f, x] gives the partial derivative ∂ f/∂ x. 
                                              n        n
D[f, {x, n}] gives the multiple derivative ∂  f/∂ x . 
D[f, x, y, …] differentiates f successively with respect to x, y, ….
D[f, {{x , x , …}}] for a scalar f
        1   2
     gives the vector derivative (∂ f/∂ x , ∂ f/∂ x , …). 
                                             1             2
D[f, {array}] gives a tensor derivative.

*)

?Do (* ->

Do[expr, {i   }] evaluates expr i    times. 
           max                   max
Do[expr, {i, i   }] evaluates expr with the variable i successively taking on the values 1 through i    (in steps of 1). 
              max                                                                                   max
Do[expr, {i, i   , i   }] starts with i = i   . 
              min   max                    min
Do[expr, {i, i   , i   , di}] uses steps di. 
              min   max
Do[expr, {i, {i , i , …}}] uses the successive values i , i , ….
               1   2                                     1   2
Do[expr, {i, i   , i   }, {j, j   , j   }, …] evaluates expr looping over different values of j, etc. for each i. 
              min   max        min   max

*)

Atualmente, os dois últimos usam Informationpara obter documentação sobre os símbolos, que podem gerar muitos bytes. Observe que isso foi executado na linha de comando 10.1 MathKernel.

Javascript, 72 bytes

Isso funciona no interpretador de linha de comando Mozilla JSShell Javascript.

1 byte: 1

Saídas 1

35 bytes: gc

Saídas

function gc() {
    [native code]
}

36 bytes: run

Saídas

function run() {
    [native code]
}

Oitava, 2818417 bytes

e

14 bytes para ans = 2.7183\n

pi

14 bytes para ans = 3.1416\n

doc

Exiba toda a documentação. 2818389 bytes, contados com dd Experimente online! porque evalcnão funcionou.

SmileBASIC 4, 1 + 13 + 15 = 29 bytes

Isso será semelhante à resposta SmileBASIC 3 do 12Me21, com alguns ajustes.

1

Como antes, a menor quantidade de código para produzir alguma saída é 2 bytes: ?( PRINT) e alguma expressão de byte único. O consenso é que PRINTfaz não produzir uma nova linha quando ele avança para a próxima linha, devido à forma como as obras de tela de texto. Portanto, isso resulta em um byte de saída.

?1
1

2

Com 3 bytes, podemos fazer algo diferente. O SB4 apresenta INSPECT, como alias ??, que imprime informações sobre um único valor. Se atribuirmos a ele uma string vazia, por exemplo, isso pode produzir muito mais saída do que o SB3. Isso nos dá 13 bytes.

??"
STRING: (0)""

3

Como temos 4 bytes para trabalhar, precisamos decidir o que devemos fazer para maximizar nossa produção. Ir com ??é uma aposta segura; temos apenas 2 bytes para usar em nossa expressão, mas a saída adicional de INSPECTé basicamente livre. Então, eu o uso para imprimir uma sequência de etiquetas. Isso é 15 bytes.

??@A
STRING: (2)"@A"

O total é 29 bytes.

Microscript II, 23 + 47 + 71 = 141 bytes

1: C

A stringification de continuações não é estritamente definida pelas especificações, mas na implementação de referência isso, executado por conta própria, gera uma string de 23 bytes.

<Continuation @t=\d\d\dus> (\d representa um dígito, cujo dígito varia).

No meu computador, pelo menos, isso sempre leva de 180 a 400 microssegundos para ser executado.

O primeiro uso que já tive para esta instrução.

2: CP

47 bytes de saída - a saída do primeiro duas vezes com uma nova linha no meio.

3: CPP

Bastante direto. 71 bytes de saída - a saída do primeiro três vezes com novas linhas no meio.

PowerShell, ~ 4300 bytes

Comprimento aproximado da saída, considerando o sistema em que é executado. Todos os trechos abaixo são determinísticos, pois se o mesmo estado inicial do computador fornecer o mesmo texto, apenas na prática o resultado poderá mudar de execução para execução.

Comprimento 1, 107 bytes

?

Este é um apelido para Where-Object. Ele exibirá um prompt do usuário solicitando informações adicionais:

cmdlet Where-Object at command pipeline position 1
Supply values for the following parameters:
Property: 

Comprimento 2, 113 bytes

rp

Este é um apelido para Remove-ItemProperty. Ele exibirá um prompt do usuário solicitando informações adicionais:

cmdlet Remove-ItemProperty at command pipeline position 1
Supply values for the following parameters:
Path[0]: 

Apenas um pouco mais que o snippet de comprimento 1.

Comprimento 3, ~ 4100 bytes

gps

Este é um alias para o Get-Processqual produzirá uma tabela formatada de todos os processos em execução no sistema:

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                                                          
-------  ------    -----      ----- -----   ------     -- -----------                                                                                
     85       8     1232       4452    46     0.14    544 armsvc                                                                                               
    151      10     6800       9888    39     0.58   5116 audiodg                                                                                              
    480      25     6060      17200   124     0.84   4536 AuthManSvr            
...

Javascript, 312 + 318 + 624 = 1254 bytes de saída

$
$$
$+$

As duas funções $e $$estão disponíveis em consoles de todos os principais navegadores, como atalhos para document.querySelectoredocument.querySelectorAll , respectivamente. Navegadores diferentes têm código nativo coagido a seqüências de caracteres um pouco diferentes entre si, e o IE usa JS simples em cada função, resultando em uma representação muito mais longa.

Para a contagem de bytes, estou usando o comprimento da representação de seqüência de caracteres de cada um, em vez da exibição do console às vezes modificada, para que o total de bytes seja, para cada um dos seguintes navegadores:

• Chrome: 56 + 57 + 112 = 225 bytes
• IE: 312 + 318 + 624 = 1254
• Firefox: 33 + 33 + 66 = 132

(Estou considerando que o resultado do IE seja a contagem "oficial" porque é a mais longa.)

Para ambientes de navegador que não são do console, as maiores saídas são as seguintes:

1
!1 // Or '{}' if being fed to a function instead of beginning a statement
Map

Duração dos resultados por navegador:

• Chrome: 1 + 5 (ou 15, se {}for utilizável) + 32 = 38 (ou 48) bytes
• IE: 1 + 5 (ou 15, se {}for utilizável) + 38 = 44 (ou 54)
• Firefox: 1 + 5 (ou 15, se {}for utilizável) + 36 = 42 (ou 52)

Esses dois conjuntos de entrada produzem a maior saída possível em todos esses navegadores e consoles. Para provar isso, vamos verificar todas as alternativas:

• Variáveis ​​existentes: podemos encontrar todas as variáveis ​​nativas disponíveis com no máximo três caracteres e Object.getOwnPropertyNames(window).filter(x=>x.length<=3), em seguida, mapelas em suas saídas de string para determinar as maiores. (Observe que em alguns navegadores como o Firefox, determinadas variáveis ​​especiais do console não podem ser acessadas dessa maneira, pois não são propriedade da janela.)
• JS tem um número limitado de tipos de literais que podem ser criados com tão poucos caracteres:
  • De acordo com a especificação, os números decimais devem ser um dígito decimal ( 1234567890) opcionalmente seguido por .mais dígitos decimais e / ou uma parte do expoente, ou ser .seguido por um ou mais dígitos decimais e, opcionalmente, uma parte do expoente. Outros tipos de números deve ser 0o, 0xou0b (ou formas em maiúsculas), seguido por um ou mais dígitos. Para nossos propósitos, podemos deduzir o seguinte:
    • Existem apenas dez números de caracteres únicos, que são os números inteiros de 0 a 9. Os únicos números de dois caracteres são números de 0 a 99 (0 a 9 adicionando um decimal depois) e os números de 0,1 a 0,9 omitindo o zero inicial . Os únicos números de três caracteres são 0-999, incluindo 0x0-0xf, 0o0-0o7, ​​0b0 e 0b1, o exponencial 1e1 a 9e9 (10 caracteres) e os números 0,1 a 9,9 e 0,01 a 0,99. Embora tecnicamente não seja um literal numérico, o NaN também pode ser referenciado em três caracteres.
  • Strings, matrizes e regexps, cada um dos quais pode ter no máximo apenas um único caractere de conteúdo. Uma matriz pode ser preenchida com $uma vírgula ou um número de um dígito. Matrizes com apenas um elemento são coagidas a strings como o próprio elemento. Matrizes vazias se tornam cadeias vazias.
  • Dependendo do ambiente, pode ou não ser possível criar objetos simples com três caracteres. Normalmente, {}sozinho no início de um script seria tratado como um gabinete em vez de criar um objeto. eval({})retorna indefinido, eval({$})retorna a $função. Não há caracteres suficientes para cercar o{} no ().
• Não há palavras-chave curtas o suficiente para usar. As palavras-chave if, in, do, new, for, try,var , e letque todos exigem um mínimo de dois outros personagens de usar, excedendo o limite.
• Operadores unários disponíveis incluem ~, +, -, !, ++, e --. Os operadores de dois caracteres podem ser usados ​​apenas com uma variável de caractere, da qual existe apenas um ($ ), que gera NaN. Os outros quatro operadores podem ser usados ​​com qualquer valor de um ou dois caracteres, dos quais existem:
  • Várias variáveis. (Em alguns consoles $, $_, $0, $1, $2, $3, $4, $, $$, $x). Quando utilizado com esses operadores, os resultados são limitados a -1, true, false, e NaN.
  • 109 números. Resultados: Inteiros -100 a 99, -0.9 através -0.1, true, false.
  • Cordas vazias. Resultados: -1, 0( -0torna-se 0no toString), true.
  • Os resultados de qualquer um dos valores de um caractere acima associados a um operador unário de um caractere. Novos resultados: Nenhum.
• Operadores binários utilizáveis (que deve ser um único caractere de ter espaço para os dois operandos) são +, -, *, /, %, <, >, &, |, ^. Eles só podem ser usados ​​com um valor de um caractere em cada lado. As opções para valores incluem $e números inteiros 0-9. Os resultados de todas as combinações destes incluem Infinity, alguns números e valores binários mencionados acima, e numerosas fracções que são forçados para cordas de 19 caracteres ou menos ( 1/7se 19 caracteres, ao contrário 1/9sugerido acima, que é de apenas 18), e a representação de texto $precedido ou seguido por um número inteiro de um dígito ou por si próprio.
• Por fim, todos os demais operadores e expressões: O operador membro .requer uma variável existente e um identificador referente a uma propriedade. Todos os usos deste aqui resultam em undefined. Ao redor de um valor, ( )retorna-o, assim como o atribui =. Usar ()ou `` para chamar um valor como uma função resulta em erros indefinidos ou com todos os valores disponíveis.

Somando tudo isso, há um total geral de 1651 saídas possíveis ao usar um console do Chrome. As saídas mais longas para um, dois e três caracteres são a partir de $, $$e $+$respectivamente.

dc , 2 + 5 + 18 = 25 bytes

1: Ffrendimentos ( Experimente online! ):

15

2: Fdfrendimentos ( Experimente online! ):

15
15

3: Fd^frendimentos ( Experimente online! )

437893890380859375

Nenhum dos quais é particularmente interessante, mas dcnão é realmente bom para cuspir pilhas de saída. Eu gosto que cada resposta se baseie na anterior. Enfim, Fé apenas o número 15;fimprime a pilha inteira; dduplica o topo da pilha; ^aumenta o topo da pilha para o poder da parte superior da pilha (nesse caso, 15 ^ 15). Não acredito que isso possa ser superado dc.

Ruby, 3 + 14 + 28 = 45 bytes

Por que eu fiz isso?

p

Impressões nil.

$>

Imprime #<IO:<STDOUT>>.

dup

Imprime algo ao longo das linhas de #<Object:0x0000000003610988>.

irb

Inicia uma instância do Interactive Ruby. Ao sair, o objeto retornado é #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>>para 121, mas como exige que você pressione ^Dou algo para realmente sair da instância irb, não tinha certeza se ele realmente contaria como uma solução em "3 bytes", por isso não estou na verdade, incluí-lo na partitura, a menos que seja aprovado.

Perl 6, 53 (17 + 18 + 18) bytes

e
-e
e*e

1. e saídas $e$ até 15 casas decimais
2. -e saídas $-e$ até 15 casas decimais
3. e*e saídas $e^2$, mas, estranhamente, fornece mais uma casa decimal

Encantos Rúnicos, 4.000.000 de bytes de saída

O primeiro programa é:

a@

Leva 2 bytes para: envie um valor para a pilha, imprima um valor da pilha e termine. Nesse caso, ele é impresso 10(embora qualquer valor inteiro de 0 a 16 também seja válido)

Para 3 bytes:

aY@

Prints 10000, Mais uma vez, apode ser de 1 a 16 inclusive (a fim de gerar mais saída do que o programa original, 0 é potencialmente válida sob outros operadores) e não há um monte de operadores que têm uma única entrada e produzem qualquer saída, saída muito menos longa . XCYZ:Esão as únicas opções reais. aY@é apenas o que resulta em mais saída.

P$!;

De acordo com a especificação da linguagem, isso é executado infinitamente. No entanto, como o intérprete possui um limite máximo de execução "ok, basta", essa é a saída mais alcançável em 4 caracteres (e o TIO interrompe a execução após ~ 130.000 bytes por exceder 128 kib) e como o intérprete define o idioma , isso trabalho. E embora eu tenha aumentado esse limite uma vez antes (de 10 mil etapas para 1 milhão), não pretendo mexer com isso tão cedo.

Maior?

Se eu invocar as três suposições que fiz aqui , com certeza.

`AA@

O que funciona para Ack(65,Ack(65,64)) , os quais não são valores terrivelmente grandes para serem inseridos na função Ackerman inicialmente - certamente menores que os 255 no post anterior - mas tudo bem, podemos chamar Ack duas vezes em 4 instruções.

E só Deus sabe o que será impresso.

_{Nota: Adesde então, a instrução foi transformada em Mathmeta-instrução, que consome 3 objetos na pilha: um caractere para qual instrução executar e, em seguida, duas entradas, x e y. Como tal, esse programa não faz nada, nem porque Anem @mapeia para uma função matemática e porque duas chamadas subsequentes resultam em um estouro de pilha.}