Scrivi programmi che producono errori di runtime pazzi, oscuri, ridicoli o semplicemente pazzeschi. Offuscamento e golfitude (mancanza) non richiesti.

• le soluzioni che sembrano funzionare bene sono migliori.
• le soluzioni che sembrano rompersi in un modo ma romperne un altro sono migliori.
• le soluzioni non deterministiche sono migliori fintanto che sono riproducibili a volte.
• le soluzioni a lunga distanza tra causa dell'errore e manifestazione sono migliori.
• punti bonus per la produzione di errori che dovrebbero essere impossibili.
• punti bonus per errori che causano l'arresto anomalo del runtime (come errori del segmento python) o del sistema operativo.

L'unità di punteggio deve essere votata.

Addendum 1

Anche i comportamenti scorretti del compilatore vanno bene.

Il PHP obbligatorio (che comunque non è stato fissato al 5.4):

<?::

Uscite:

Errore di analisi: errore di sintassi, T_PAAMAYIM_NEKUDOTAYIM imprevisto sulla riga 1

Whaa?

Errore di compilazione Gcc:

int main()
{
        long long long a;
}

errore: long long long è troppo lungo per GCC

Prompt dei comandi di Windows

If you're happy and you know it clap your hands!

Produzione:

felice era inaspettato in questo momento.

PHP

$ cat error.php 
<?php
function echo_string(string $string) {
    echo $string;
}
echo_string("Hello, world!");
$ php error.php 
PHP Catchable fatal error:  Argument 1 passed to echo_string() must be an instance of string, string given, called in error.php on line 5 and defined in error.php on line 2

Non puoi passare una stringa a una funzione, devi invece passare una stringa!

Aggiornamento: questo codice NON è un errore in PHP 7. Passa con il mouse su / fai clic / tocca uno spoiler per verificare perché (contiene spoiler su come funziona il codice).

Una nuova funzionalità nota come dichiarazioni di tipo scalare è stata aggiunta in PHP 7. Questa funzione consente di utilizzare tipi scalari nelle dichiarazioni di funzioni.

bash

$ echo "Hello, world!"
bash: !": event not found

E penseresti che bash accetterebbe un semplice "Ciao, mondo!" programma.

Python 2.7

# Look I'm actually coding: see my happy face?
print ':)'

Genera piuttosto inutile:

SyntaxError: encoding problem: with BOM

Come può un semplice commento generare un errore?

matematica

Quando si utilizza Mathematica per creare output grafici, a volte si generano messaggi di errore formattati in base alle specifiche utilizzate nel programma stesso. Ecco un esempio banale.

Rotate[f/0, .6]

Calcolatrice grafica TI-89

L'ho scoperto quando ho appreso la differenziazione implicita nel calcolo del liceo. Se inserisci:

d(xy+x=0,x)

Ottieni quanto segue:

1 = 0

Con questo avvertimento, stampato in minuscole lettere nella parte inferiore dello schermo:

Warning: May produce false equation

Questo accade perché xynon è interpretato come x * y, ma piuttosto come il proprio simbolo, xy.

Stranamente, se lo fai d(xy=0,x), ricevi 0 = 0lo stesso avvertimento.

Puoi far esplodere il cervello del compilatore Haskell:

C:\Windows\system32>ghci
...
Prelude> :set -XExistentialQuantification
Prelude> data Foo = forall a. Foo a
Prelude> let foo f = 1 where Foo a = f

<interactive>:4:21:
    My brain just exploded
    I can't handle pattern bindings for existential or GADT data constructors.
    Instead, use a case-expression, or do-notation, to unpack the constructor.
    In the pattern: Foo a
    In a pattern binding: Foo a = f
    In an equation for `foo':
        foo f
          = 1
          where
              Foo a = f
Prelude>

Rubino

Abuso di regole.

class StandardError

  def to_s
    words = File.open('/usr/share/dict/words'){|f|f.readlines.map &:chop}.sample(100)
    words.last.capitalize!
    super.gsub(/\w+/){words.pop}
  end

  to_s(3)

end

Se eseguito su OSX, produce, ad es

$ ruby weird_runtime_error.rb 
weird_runtime_error.rb:9:in `to_s': Sculpturation contingence explicate tappet(phonendoscope ethopoeia nannandrous) (ArgumentError)
    from weird_runtime_error.rb:9:in `<class:StandardError>'
    from weird_runtime_error.rb:1:in `<main>'

Prompt di DOS

c:\>make love

ti dà

Fatal Error: 'love' does not exist. Don't know how to make it.

Ci siamo imbattuti in questo mentre stavo cercando di insultare il mio computer per non essere collaborativo. Mi ha reso un po 'triste per un po' fino a quando ho scoperto che questo succede solo se l'amore non esiste. Se esiste, lo farà volentieri.

Bash (errore Quine)

Questo errore è un quine in Bash!

$ bash: bash:: command not found...
bash: bash:: command not found...

Ovviamente devi avere il pertinente locale(inglese qui).

CSH

Uno cshscherzo davvero classico :

% make fire?
make: No match.

Bash: ricostruzione accurata di un raro messaggio di errore storico

echo -ne $(tail -n +257 /usr/src/linux*/drivers/char/lp.c | head -1 | cut -d '"' -f 2 | sed 's/%d/0/')

Produzione:

lp0 on fire

Richiede che il sorgente del kernel Linux sia decompresso nella solita posizione.

Curiosità: una volta ho ricevuto questo messaggio sul serio, quando eseguivo una vecchia stampante a nastro.

C (++)

Se gli errori in fase di compilazione contano, eccone uno (supponendo un file chiamato "crash.c").

#include "crash.c"

int main(){ return 0; }

Riempie lo schermo al momento della compilazione (avere Ctrl-C pronto)

                 from crash.c:1,
                 from crash.c:1:
crash.c:3:1: error: redefinition of ‘main’
crash.c:3:1: note: previous definition of ‘main’ was here
In file included from crash.c:1:0,
                 from crash.c:1,
                 from crash.c:1,

Un altro frammento che si adatta perfettamente (nessun avvertimento sotto -Walle illustra la meravigliosa sicurezza del tipo di C </s>

#include <stdio.h>
int i;

int main(){
  sprintf(NULL, "%s", (char *) (void *) (1/i));
  return 0;
}

Eseguendolo dà:

Floating point exception (core dumped)

Rubino

Sembra strano che ciò possa accadere in un linguaggio di alto livello.

$*<<$*<<$**$/

produce

ArgumentError: recursive array join

Questo è molto vecchio, ma per coloro che ricordano BCPL,

GET "LIBHDR"

LET START() = VALOF 
$8
        RESULTIS 0
$)

si lamenterebbe

$8
 ^
"( ) or 8 expected"

R

Questo non è tecnicamente un errore ma un avvertimento, ma è comunque ridicolo e si verifica per ragioni completamente esoteriche.

[[EDIT]] Sembra che la causa di alcune parti degli avvisi divertenti risieda in RStudio anziché in R di per sé, quindi è meno interessante di quanto pensassi. Il primo esempio, ad esempio plot(1:2, NotAGraphicalParameter = "ignore.me"), è comunque riproducibile in R "nudo" ed è abbastanza divertente da solo. [[/ EDIT]]

> plot(1:2, NotAGraphicalParameter = "ignore.me")
# produces a nice scatterplot with two points, [1,1] and [2,2]
Warning messages:
1: In plot.window(...) :
  "NotAGraphicalParameter" is not a graphical parameter
2: In plot.xy(xy, type, ...) :
  "NotAGraphicalParameter" is not a graphical parameter
3: In axis(side = side, at = at, labels = labels, ...) :
  "NotAGraphicalParameter" is not a graphical parameter
4: In axis(side = side, at = at, labels = labels, ...) :
  "NotAGraphicalParameter" is not a graphical parameter
5: In box(...) : "NotAGraphicalParameter" is not a graphical parameter
6: In title(...) : "NotAGraphicalParameter" is not a graphical parameter
> plot(2:3)
# another nice scatterplot: [2,2] and [3,3] 
# but there should be nothing wrong this time!
# however ...
There were 12 warnings (use warnings() to see them)
> warnings()
Warning messages:
1: "NotAGraphicalParameter" is not a graphical parameter
2: "NotAGraphicalParameter" is not a graphical parameter
3: "NotAGraphicalParameter" is not a graphical parameter
4: "NotAGraphicalParameter" is not a graphical parameter
5: "NotAGraphicalParameter" is not a graphical parameter
6: "NotAGraphicalParameter" is not a graphical parameter
7: "NotAGraphicalParameter" is not a graphical parameter
8: "NotAGraphicalParameter" is not a graphical parameter
9: "NotAGraphicalParameter" is not a graphical parameter
10: "NotAGraphicalParameter" is not a graphical parameter
11: "NotAGraphicalParameter" is not a graphical parameter
12: "NotAGraphicalParameter" is not a graphical parameter
# but let's try once more:
> plot(2:3)
# yup. no warnings this time. we had to do it twice

È come se R ricordi i nostri insulti. Ma non per molto.

Non riesco davvero a spiegare perché questo accada, ma è riproducibile. In realtà si verifica ogni volta che si fornisce un "parametro non grafico" al diagramma 1, quindi si esegue un diagramma 2 in un modo completamente impeccabile. È particolarmente divertente ricevere 12 avvisi "non un parametro grafico" per il secondo grafico ma solo 6 per il primo. Un'altra cosa divertente è che se si fornisce "non un parametro grafico" con un valore NULL, non viene generata alcuna condizione:

plot(1:2, Nonsense=NULL)
# no warnings
# however
plot(1:2, Nonsense="gibberish")
# gives the usual 6-pack of warnings

E per diventare ancora più ridicoli, disegniamo alcune linee in cima alla trama precedentemente disegnata:

plot(1:2)
# you will see the number of warnings growing with each line:
lines(1:2, 1:2, mumbo = 1)
lines(1:2, 1:2, jumbo = 2)
lines(1:2, 1:2, bimbo = 3)
lines(1:2, 1:2, cucaracha = 4)
lines(1:2, 1:2, karaoke = 5)
lines(1:2, 1:2, radiogaga = 6)
lines(1:2, 1:2, reptiles = 7)
lines(1:2, 1:2, cowsonmoon = 8)
lines(1:2, 1:2, stainlessSteelLadderToTheMoon = 9)
lines(1:2, 1:2, frambuesa = 10)
lines(1:2, 1:2, fresa = 11)
lines(1:2, 1:2, limonYNada = 12)
lines(1:2, 1:2, slingsAndArrows = 13)
# ... and now you have 25 warnings:
warnings()

Warning messages:
1: "mumbo" is not a graphical parameter
2: "jumbo" is not a graphical parameter
3: "bimbo" is not a graphical parameter
4: "cucaracha" is not a graphical parameter
5: "karaoke" is not a graphical parameter
6: "radiogaga" is not a graphical parameter
7: "reptiles" is not a graphical parameter
8: "cowsonmoon" is not a graphical parameter
9: "stainlessSteelLadderToTheMoon" is not a graphical parameter
10: "frambuesa" is not a graphical parameter
11: "fresa" is not a graphical parameter
12: "limonYNada" is not a graphical parameter
13: "mumbo" is not a graphical parameter
14: "jumbo" is not a graphical parameter
15: "bimbo" is not a graphical parameter
16: "cucaracha" is not a graphical parameter
17: "karaoke" is not a graphical parameter
18: "radiogaga" is not a graphical parameter
19: "reptiles" is not a graphical parameter
20: "cowsonmoon" is not a graphical parameter
21: "stainlessSteelLadderToTheMoon" is not a graphical parameter
22: "frambuesa" is not a graphical parameter
23: "fresa" is not a graphical parameter
24: "limonYNada" is not a graphical parameter
25: In plot.xy(xy.coords(x, y), type = type, ...) :
  "slingsAndArrows" is not a graphical parameter

Questo dovrebbe non vincere alla grande a meno che non ci sia giustizia.

Script di comando di Windows

ATTENZIONE, questa è una bomba a forcella!

Ciò genererà domande inutili sull'uscita se si tenta di chiudere la console in alcun modo.

%0|%0|%0

bonus:

• Renderà il sistema praticamente inutilizzabile fino al riavvio
• Impedisce di uscire dalla sceneggiatura, il che dovrebbe essere impossibile

q ti insulta

q)`u#1 1
'u-fail
q)

`` u # `` dice qche ogni elemento in un elenco è unico (quindi può costruire una sorta di indice basato sull'hash, presumibilmente). questo è ciò che accade quando in realtà non è vero.

Che ne dici di errori di ottimizzazione del compilatore:

#include <stdio.h>

#define N 4

int main(void)
{
    int sum;
    int i;
    int arr[N];

    for (i = 0, sum = 0; i < N; i++, arr[i] = sum) {
        sum += arr[i];
    }
    printf("%d\n", sum);
    return 0;
}

Questo è specifico di gcc> = 4.7. Compila e funziona bene congcc -O0 -Wall . Compilare con gcc -O2 -Wallma risulta in un inf-loop.

Nota anche come gcc vede il problema per i più piccoli N, ad esN = 3 :

test.c:11:38: warning: array subscript is above array bounds [-Warray-bounds]
  for (i = 0, sum = 0; i < N; i++, arr[i] = sum) {
                                       ^
test.c:12:13: warning: 'arr[0]' is used uninitialized in this function [-Wuninitialized]
  sum += arr[i];
         ^

A proposito, questo è stato preso da una segnalazione di bug, tuttavia non riesco a ricordare il numero di bug.

Mi è sempre piaciuta questa stranezza in APL:

      ⍝ ovviamente un errore di sintassi
      {(]} 3  
ERRORE DI SINTASSI
      {(]} 3

      ⍝ ma:
      {(]} 1 ÷ 0
ERRORE DOMINIO
      {(]} 1 ÷ 0 

      ⍝ funziona anche con funzioni definite staticamente
      ∇z ← fx
[1] z ← [{]} x
[2] ∇
      f 1 ÷ 0
ERRORE DOMINIO
      f 1 ÷ 0
     ∧
      f 3
ERRORE DI SINTASSI
f [1] z ← [{]} x     

Analizza pigramente l'interno delle funzioni!

PHP

<?php
[][] = 42;

[]è usato per spingere elementi. Tuttavia, se lo usi per l'array letterale, il PHP fa un pazzo messaggio di errore, anche se lo assegni per spingere. Richiede PHP> = 5.4, come in precedenza non si potevano avere valori letterali di array indicizzati.

Produzione:

Errore irreversibile : impossibile utilizzare [] per la lettura in [...] [...] alla riga 2

Pitone

Blocchi nidificati

for a in range(26):
 for b in range(26):
  for c in range(26):
   for d in range(26):
    for e in range(26):
     for f in range(26):
      for g in range(26):
       for h in range(26):
        for i in range(26):
         for j in range(26):
          for k in range(26):
           for l in range(26):
            for m in range(26):
             for n in range(26):
              for o in range(26):
               for p in range(26):
                for q in range(26):
                 for r in range(26):
                  for s in range(26):
                   for t in range(26):
                    for u in range(26):
                     for v in range(26):
                      for w in range(26):
                       for x in range(26):
                        for y in range(26):
                         for z in range(26):
                          print a

Python 2.7: SystemError: too many statically nested blocks

Elenchi autoreferenziali

def printList(myList):
    for element in myList:
        if isinstance(element, list):
            printList(myList)
        else:
            print(element)

a = []
a.append(a)
printList(a)

Python 2.7

Vero non è una costante

Il problema nell'esempio seguente è quello in Python 2.7 Truee Falsenon sono costanti. E Truee Falsepuò essere automaticamente castato su 1e 0:

True=False
a=10/True

Traceback (most recent call last):
  File "/home/moose/.config/pluma/tools/new-tool-2", line 11, in <module>
    exec(sys.stdin.read())
  File "<string>", line 2, in <module>
ZeroDivisionError: integer division or modulo by zero

Python 2.7:

Intendation

def f(n):
    if n <= 1:
        return n
    else:
        return f(n-1)+f(n-2)

Ricevi l'errore?

Traceback (most recent call last):
  File "/home/moose/.config/pluma/tools/new-tool-2", line 11, in <module>
    exec(sys.stdin.read())
  File "<string>", line 4
    else:
       ^
SyntaxError: invalid syntax

Mescolare schede e spazi era ok in Python 2.7 ... ma attenzione al livello di rientro!

Inizierò:

#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
    }

    void doSomethingDiabolical()
    {
        delete this;
    }

    virtual void breakHorribly()
    {
        cout << "still alive" << endl;
        doSomethingDiabolical();
        cout << "still alive" << endl;
    }
};

class B : public A
{
public:
    B() : A()
    {
    }

    void breakHorribly()
    {
        cout << "still alive" << endl;
        ((A *) this)->breakHorribly();
        cout << "still alive" << endl;
        doSomethingDiabolical();
        cout << "still alive" << endl;
        breakHorribly();
        cout << "dead" << endl;
    }
};

int main()
{
    jane();
}

void jane()
{
    cout << "still alive" << endl;
    A * o = new B;
    cout << "still alive" << endl;
    o->breakHorribly();
}

Qualche ipotesi sul perché questo programma si arresti in modo anomalo? : D

Vedi janerun: http://ideone.com/gtaZ3

bash

L'ho preso oggi quando ho provato a scoprire se è possibile proteggere il sistema rm -rf /.

mkdir /tmp/a
mkdir /tmp/a/b
sudo mount --bind /tmp/a /tmp/a/b
rm -rf /tmp/a

Il messaggio di errore con LANG=C:

rm: WARNING: Circular directory structure.
This almost certainly means that you have a corrupted file system.
NOTIFY YOUR SYSTEM MANAGER.
The following directory is part of the cycle:
  '/tmp/a/b'

R

Un altro che non è ridicolo e, di nuovo, un avvertimento piuttosto che un errore, ma comunque carino:

> sapply(as.list(-1:-51), log)
 [1] NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
[20] NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
[39] NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
There were 50 or more warnings (use warnings() to see the first 50)

Mi piace l'ultimo bit: 50 o più :)

E gli avvisi reali:

1: In lapply(X = X, FUN = FUN, ...) : NaNs produced
2: In lapply(X = X, FUN = FUN, ...) : NaNs produced
....
50: In lapply(X = X, FUN = FUN, ...) : NaNs produced

FUN = FUN!

CPython

import ctypes
import sys
(ctypes.c_char * sys.getsizeof(None)).from_address(id(None))[:4] = '\x00' * 4

Il risultato:

Fatal Python error: deallocating None

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

Bash - errore di fuga controintuitivo

echo "this should definitely work!!!11!"

ritorna

-bash: !11: event not found

(l'espansione della cronologia sulla riga di comando non è impedita da virgolette doppie)

Bonus:

echo "I don't know what's gone wrong!! !echo is usually pretty foolproof!-1"

È improbabile che l'output sia quello che ci si aspetta. Premi su per ottenere di nuovo il comando e nota che è cambiato da quello che hai digitato. Se si preme su e si immette un paio di volte, è probabile che l'output inizi a sembrare piuttosto orribile. Provalo tu stesso.

C # - Generatore di Fibonacci ricorsivo e pigro

static void Main()
{
    Console.WriteLine(string.Join(",", fib().Take(141)));
    Console.ReadLine();
}

static IEnumerable<decimal> fib(decimal n = 0, decimal m = 1)
{
    if (n == 0)
    {
        yield return 0;
        yield return 1;
    }
    while (true)
    {
        yield return n + m;
        foreach(var x in fib(m, n+m))
        {
            yield return x;
        }
    }
}

Questo codice sembra a posto, vero? Un generatore di Fibonacci abbastanza semplice, speziato con qualche ricorsione e enumerazione pigra. Dovrebbe funzionare.

No! L'esecuzione di questo causerà un OverflowException. Questo perché stiamo usando il decimale e il 141 ° numero di Fibonacci (~ 8.1E28) supera il valore massimo del decimale (~ 7.9E28).

L'int, tuttavia, non genera una OverflowException quando si supera il valore massimo. Invece, come previsto, trabocca a un valore negativo. Quindi se sostituiamo int invece con i decimali, come nel seguente codice, dovrebbe funzionare, giusto?

static void Main()
{
    Console.WriteLine(string.Join(",", fib().Take(141)));
    Console.ReadLine();
}

static IEnumerable<int> fib(int n = 0, int m = 1)
{
    if (n == 0)
    {
        yield return 0;
        yield return 1;
    }
    while (true)
    {
        yield return n + m;
        foreach(var x in fib(m, n+m).ToList())
        {
            yield return x;
        }
    }
}

Se leggi il codice dovrebbe essere ovvio il motivo per cui non funzionerà. Se non l'hai fatto ... Non ho semplicemente cambiato il tipo da decimale a int; Ho anche nascosto una chiamata a ToList () nell'istruzione foreach. Ciò costringerà l'enumeratore a essere valutato con entusiasmo. Ciò causerà non 141 ricorsioni, ma invece un numero infinito di ricorsioni. In realtà, molto prima che colpisca l'infinito, ovviamente traboccerà lo stack, facendo sì che il runtime lanci StackOverflowException. (bonus: questa eccezione non può essere rilevata, quindi si bloccherà il runtime)