O objetivo deste desafio é escrever um programa em que o comprimento dos três seguintes seja exatamente o mesmo:

• o comprimento do código fonte
• o comprimento da saída impressa na saída padrão
• a duração dos avisos do compilador gerados com o compilador (não modificado) de sua escolha

O vencedor é o código mais curto para atender aos três critérios e deve ter pelo menos 1 caractere.

Para apimentar as coisas, se a saída tiver menos de três caracteres diferentes, será adicionada uma penalidade de 5 pontos ao comprimento de cada um (então +10 se apenas um tipo, +5 para dois).

(As novas linhas contam com 1 ou 2 caracteres, a escolha é sua, mas deve ser consistente com todos os três critérios. Os espaços em branco à esquerda e à direita são ignorados em todas as linhas nos três critérios)

_{Em caso de pontuação igual, quem imprime o resultado mais interessante (em vez de lixo) é o vencedor.}

Bash, 23 caracteres

Erro:

bash: /: Is a directory

Fonte:

echo       $0-$01234;/;

Resultado:

/bin/bash-/bin/bash1234

Brainf * ck, 32 caracteres

Este código é executado por cerca de 3 segundos e para e exibe o seguinte erro e saída.

Erro:

bff: out of memory (-2058691272)

Fonte:

+++++[......-]..+[>>>>>>>>>>>>-]

Saída: (Hexdump)

0505 0505 0505 0404 0404 0404 0303 0303
0303 0202 0202 0202 0101 0101 0101 0000

C, 35 caracteres

Atenção:

b.c:1:30: warning: division by zero

Origem e Saída:

main(){system("cat "__FILE__)/0;;;}

PHP, 50 caracteres

Atenção:

PHP Warning:  Division by zero in /tmp/3 on line 1

Origem e Saída:

<?php echo (0/0).''.file_get_contents(__FILE__);?>

C - 48 caracteres

main(i){while(++i<49)putchar(i);putchar('\z');}

Nota: inclui uma nova linha final (estilo Unix).

Saída de gcc a.cleituras:

a.c:1:41: warning: unknown escape sequence '\z'

A saída a.outé principalmente de caracteres não imprimíveis, então aqui está o que parece depois de passar pelo hexdump:

00000000: 0203 0405 0607 0809 0A0B 0C0D 0E0F 1011  ................
00000010: 1213 1415 1617 1819 1A1B 1C1D 1E1F 2021  .............. !
00000020: 2223 2425 2627 2829 2A2B 2C2D 2E2F 307A  "#$%&'()*+,-./0z

JavaScript, 63 66

!function x(){console.log(x+'...');eval(Array(33).join('$'))}()

A saída é:

function x(){console.log(x+'...');eval(Array(33).join('$'))}...

No Chrome, o erro é:

ReferenceError: $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ is not defined

Visual Basic .NET, 185

Puxa, vbcé bem detalhado com seus avisos de compilação. De qualquer forma, o código é este:

Public Module Main
    Public Sub Main()
        Console.WriteLine(New String("a"c,185))
    End Sub

    Public Function A()
        'This is actually just padding.
        'Hi
    End Function
End Module

(Observe que eles devem ser tabulações, não espaços.)

A saída é esta:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

E o aviso do compilador é este:

warning BC42105: Function 'A' doesn't return a value on all code paths. A null reference exception could occur at run time when the result is used.

    End Function
    ~~~~~~~~~~~~

(Desta vez, são quatro espaços, não tabulações.)

Zsh , 20 bytes

<<<   $-$_$_$_$_$_
[

O problema que enfrentamos aqui é mencionado no comentário acima: Zsh imprime o nome do programa além do número da linha antes de cada erro. A solução aqui usa um nome de arquivo de um caractere para abusar disso. Eu o envolvi em um script auxiliar para mostrar exatamente o que é impresso e usado wc -cno stderr, stdout e no arquivo de origem.

Saída: 569Xcatcatcatcatcatseguida por uma nova linha
Erros: s:[:2: ']' expectedseguidos por uma nova linha

EDIT: Solução alternativa de 20 bytes sem restrição de arquivo:

<<<$-$-$-$-$_>&1 >&2

Experimente online!

Zsh , zsh -x, 10 bytes

<<<$_$_$_

-xflag habilita o xtrace. Isso novamente requer um nome de arquivo com um único caractere. Experimente online!

Zsh zsh -JNTwEDY , 12 bytes

<<<$->&1 >&2

-flagResposta mais curta, sem necessidade de nome de arquivo. Define mais sinalizadores e $-imprime todos eles. Experimente online!

JavaScript (Firefox 54), 34 bytes

alert((f=function(x)1234)(56)+f+f)

Saídas:

1234function(x)1234function(x)1234

E envia este aviso ao console do navegador:

expression closures are deprecated

Parece isso na minha cópia do Firefox Developer Edition (54.0a2). Também pode funcionar em outras versões do Firefox.

Ruby, 48 caracteres

IO=1;puts ?a*48;# let's make it 48 bytes long :)

Saídas

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

Avisa

r.rb:1: warning: already initialized constant IO

(o arquivo é r.rb, eu removi o caminho, se você executá-lo no irb, você receberá (irb): 1: warning ...)

Existe o método warn no Ruby, mas ele apenas envia seus argumentos para $ stderr, fazendo com que pareça menos um aviso.

Python, 57 bytes

Outros intérpretes podem exibir o aviso de maneira diferente. Isso foi testado apenas para funcionar no TIO.

from warnings import*
print("prt"*19)
warn("Warning...!")

Experimente online

Resultado

prtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprt

Atenção

.code.tio:3: UserWarning: Warning...!
  warn("Warning...!")

Observe que os espaços à esquerda não são contados na contagem de bytes. Se os espaços à esquerda não fossem ignorados, isso poderia ser feito em 51 bytes.

Javascript (ES6), 32 30 bytes

Screen(console.log(Function));

impressões

ƒ Function() { [native code] }

no Chrome e depois lança

TypeError: Illegal constructor

Minha solução original de 32 bytes:

(x=y=>console.log(x+!0+10)||z)()

primeiro, imprime

y=>console.log(x+!0+10)||ztrue10

E lança o erro

ReferenceError: z is not defined

VBA, 39 bytes

Não tenho certeza se isso se qualifica, dada a restrição do compilador, mas:

Entrada: (na janela imediata)

For i=1 To 39:a=a & Chr(i):Next:Print a

* _{A saída inclui caracteres não imprimíveis que não são exibidos bem nesta janela.}

Perl 6 , 10 bytes

dd say 1e9

Experimente online!

Imprime 1000000000em STDOUT e Bool::Trueem STDERR. Ambos produzem uma nova linha final, mas os espaços em branco finais são ignorados nesse desafio. ddé uma função de depuração específica do Rakudo