L'obiettivo di questa sfida è quello di scrivere un programma in cui la lunghezza dei tre seguenti sia esattamente la stessa:

• la lunghezza del codice sorgente
• la lunghezza dell'output che stampa sull'output standard
• la lunghezza degli avvisi del compilatore che genera con il compilatore (non modded) di tua scelta

Il vincitore è il codice più breve per soddisfare tutti e tre i criteri e deve essere lungo almeno 1 carattere.

Per rendere le cose più interessanti, se l'output ha meno di tre caratteri diversi, viene aggiunta una penalità di 5 punti alla lunghezza per ognuno (quindi +10 se solo un singolo tipo, +5 per due).

(Le nuove righe contano come 1 o 2 caratteri, a tua scelta, ma devono essere coerenti attraverso tutti e tre i criteri. Gli spazi bianchi iniziali e finali vengono ignorati in tutte le righe in tutti e tre i criteri)

_{In caso di punteggio uguale, quello che stampa il risultato più interessante (anziché spazzatura) è il vincitore.}

Bash, 23 personaggi

Errore:

bash: /: Is a directory

Fonte:

echo       $0-$01234;/;

Produzione:

/bin/bash-/bin/bash1234

Brainf * ck, 32 caratteri

Questo codice viene eseguito per circa 3 secondi e si arresta e visualizza il seguente errore e output.

Errore:

bff: out of memory (-2058691272)

Fonte:

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

Uscita: (Hexdump)

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

C, 35 caratteri

Avvertimento:

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

Fonte e uscita:

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

PHP, 50 caratteri

Avvertimento:

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

Fonte e uscita:

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

C - 48 caratteri

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

Nota: include una newline finale (stile Unix).

Uscita da gcc a.cletture:

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

L'output a.outè costituito principalmente da caratteri non stampabili, quindi ecco come appare dopo aver eseguito il piping tramite 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('$'))}()

L'output è:

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

In Chrome, l'errore è:

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

Visual Basic .NET, 185

Accidenti, vbcè piuttosto prolisso con i suoi avvertimenti sulla compilazione. Ad ogni modo, il codice è questo:

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

(Nota che dovrebbero essere tabulazioni, non spazi.)

L'output è questo:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

E l'avvertimento del compilatore è questo:

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
    ~~~~~~~~~~~~

(Questa volta, in realtà sono quattro spazi, non schede).

Zsh , 20 byte

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

Il problema che affrontiamo qui è accennato in un commento sopra: Zsh stampa il nome del programma oltre al numero di riga prima di ogni errore. La soluzione qui utilizza un nome di file di un carattere per abusare di questo. L'ho racchiuso in uno script di supporto per mostrare esattamente ciò che stampa e usato wc -csu stderr, stdout e sul file sorgente.

Output: 569Xcatcatcatcatcatseguito da una nuova riga
Errori: s:[:2: ']' expectedseguito da una nuova riga

EDIT: soluzione alternativa a 20 byte senza restrizione di file:

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

Provalo online!

Zsh , zsh -x, 10 byte

<<<$_$_$_

-xflag abilita xtrace. Ciò richiede di nuovo un nome file a carattere singolo. Provalo online!

Zsh zsh -JNTwEDY , 12 byte

<<<$->&1 >&2

-flagRisposta più breve senza requisiti di nome file. Imposta più bandiere e le $-stampa tutte. Provalo online!

JavaScript (Firefox 54), 34 byte

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

Uscite:

1234function(x)1234function(x)1234

E invia questo avviso alla console del browser:

expression closures are deprecated

Sembra che questo nella mia copia di Firefox Developer Edition (54.0a2). Potrebbe funzionare anche in altre versioni di Firefox.

Rubino, 48 caratteri

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

Uscite

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

avverte

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

(il file è r.rb, ho rimosso il percorso, se lo esegui da irb, otterrai (irb): 1: warning ...)

C'è il metodo warn in Ruby, ma restituisce i suoi argomenti a $ stderr, facendolo sembrare meno un avvertimento.

Python, 57 byte

Altri interpreti possono visualizzare l'avviso in modo diverso. Questo è stato testato solo per funzionare su TIO.

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

Provalo online

Produzione

prtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprtprt

avvertimento

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

Si noti che gli spazi iniziali non vengono conteggiati nel conteggio dei byte. Se gli spazi iniziali non fossero ignorati, ciò potrebbe essere fatto in 51 byte.

Javascript (ES6), 32 30 byte

Screen(console.log(Function));

stampe

ƒ Function() { [native code] }

in Chrome, quindi genera

TypeError: Illegal constructor

La mia soluzione originale a 32 byte:

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

in primo luogo, stampe

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

E genera l'errore

ReferenceError: z is not defined

VBA, 39 byte

Non sono sicuro se questo si qualifica, dato il vincolo del compilatore, ma:

Input: (nella finestra immediata)

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

* _{L'output include caratteri non stampabili che non giocano bene in questa finestra.}

Perl 6 , 10 byte

dd say 1e9

Provalo online!

Stampa 1000000000su STDOUT e Bool::Truesu STDERR. Entrambi producono una nuova riga finale, ma lo spazio bianco finale viene ignorato in questa sfida. ddè una funzione di debug specifica di Rakudo