Insanidade: fazer a mesma coisa repetidamente e esperar resultados diferentes.

Escreva um programa que apenas lança uma exceção (erro de tempo de execução) toda vez que é executado. O desafio é ter a probabilidade de produzir mais de uma falha, sem chamar as exceções diretamente (sem throwinstruções) e não usar funções internas ou aleatórias de contagem de ticks da CPU.

• 10 pontos para cada erro possível.
• 25 pontos de bônus se o erro / falha ocorrer em outro processo ou no sistema.

Regras

1. As respostas devem indicar quais erros são possíveis e como eles são gerados.
2. Não é possível usar o gerador de números aleatórios do sistema (interno), a menos que seja propagado com o mesmo número sempre que o programa for executado.
3. Não é possível usar o número de tiques ou ciclos da CPU, a menos que sejam contados relativamente ao início do encadeamento principal do programa.
4. Multithreading é permitido (se não for fornecido).

Editar 1

1. A geração de GUID se enquadra no gerador de números aleatórios interno. A geração de GUID "doméstico" personalizada é permitida.

2. É permitido acessar o sistema de arquivos para E / S de arquivos, exceto quando feito para ignorar as regras (leia um arquivo de bits aleatórios ou carimbo de data e hora).

Editar 2

1. Chamar abort()ou assert()violar o espírito do desafio de criar software insano e, portanto, não serão concedidos 10 pontos por esse modo de falha.

Boa sorte!

Java, 400

Java é abençoado (?) Com muitas Exceptions e Errors. Existem muitos Exceptions que são específicos para a operação de uma única classe. Como exemplo de um dos casos mais extremos, existem mais de 10 Exceptions (todos são subclasses de IllegalFormatException) dedicados apenas à Formatterclasse, e levei um tempo para fazer o código lançar (quase) todos eles.

Minha resposta atual apresenta 40 Exceptions / s diferentes Error, e eles são executados aleatoriamente, dependendo do módulo de System.nanoTime()algum número inteiro.

Esse método pode ser usado apenas para medir o tempo decorrido e não está relacionado a nenhuma outra noção de sistema ou hora do relógio de parede. O valor retornado representa nanossegundos desde algum tempo de origem fixo, mas arbitrário (talvez no futuro, portanto, os valores podem ser negativos). A mesma origem é usada por todas as chamadas deste método em uma instância de uma máquina virtual Java; outras instâncias de máquina virtual provavelmente usarão uma origem diferente.

O método acima deve ser permitido, uma vez que se enquadra no caso "3. Não é possível usar o número de ciclos de tiques ou de CPU, a menos que sejam contados relativamente ao início do segmento do programa principal" .

Instrução de compilação

O JRE / JDK ou OpenJDK da Oracle é altamente recomendado para executar o código. Caso contrário, algumas exceções podem não ser lançadas, pois algumas delas se baseiam nos detalhes internos da implementação de referência e eu não tenho um retorno confiável.

O código abaixo é compilado com êxito javac 1.7.0_11e produz todas as exceções ativadas java 1.7.0_51.

1. Para executar esse código, copie e cole o código abaixo em um editor compatível com Unicode (por exemplo, Notepad ++), salve-o em UTF-16 (Big-Endian ou Little-Endian não importa, desde que a BOM seja gravada) .

2. Mude o diretório de trabalho ( cd) para onde o código fonte é salvo ( isso é importante ).

3. Compile o código com o seguinte comando:

   javac G19115.java -encoding "UTF-16"
   

4. E execute o código:

   java G19115
   

Não há nada destrutivo no meu código, pois também quero testá-lo no meu computador. O código mais "perigoso" é excluir o ToBeRemoved.classarquivo na pasta atual. Fora isso, o resto não toca no sistema de arquivos ou na rede.

import java.util.*;
import java.util.regex.*;
import java.lang.reflect.*;
import java.text.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.security.*;

class G19115 {

    // The documentation says System.nanoTime() does not return actual time, but a relative
    // time to some fixed origin.
    private static int n = (int) ((System.nanoTime() % 40) + 40) % 40;

    @SuppressWarnings("deprecation")
    public static void main(String args[]) {

        /**
         * If the code is stated to be a bug, then it is only guaranteed to throw Exception on
         * Oracle's JVM (or OpenJDK). Even if you are running Oracle's JVM, there is no
         * guarantee it will throw Exception in all future releases future either (since bugs
         * might be fixed, classes might be reimplemented, and an asteroid might hit the earth,
         * in order from the least likely to most likely).
         */

        System.out.println(n);

        switch (n) {
            case 0:
                // Bug JDK-7080302
                // https://bugs.openjdk.java.net/browse/JDK-7080302
                // PatternSyntaxException
                System.out.println(Pattern.compile("a(\u0041\u0301\u0328)", Pattern.CANON_EQ));
                System.out.println(Pattern.compile("öö", Pattern.CANON_EQ));

                // Leave this boring pattern here just in case
                System.out.println(Pattern.compile("??+*"));
                break;
            case 1:
                // Bug JDK-6984178
                // https://bugs.openjdk.java.net/browse/JDK-6984178
                // StringIndexOutOfBoundsException
                System.out.println(new String(new char[42]).matches("(?:(?=(\\2|^))(?=(\\2\\3|^.))(?=(\\1))\\2)+."));

                // Leave this boring code here just in case
                System.out.println("".charAt(1));
                break;
            case 2:
                // IllegalArgumentException

                // Bug JDK-8035975
                // https://bugs.openjdk.java.net/browse/JDK-8035975
                // Should throw IllegalArgumentException... by documentation, but does not!
                System.out.println(Pattern.compile("pattern", 0xFFFFFFFF));

                // One that actually throws IllegalArgumentException
                System.out.println(new SimpleDateFormat("Nothing to see here"));
                break;
            case 3:
                // Bug JDK-6337993 (and many others...)
                // https://bugs.openjdk.java.net/browse/JDK-6337993
                // StackOverflowError
                StringBuffer buf = new StringBuffer(2000);
                for (int i = 0; i < 1000; i++) {
                    buf.append("xy");
                }
                System.out.println(buf.toString().matches("(x|y)*"));

                // Leave this boring code here just in case
                main(args);
                break;
            case 4:
                // NumberFormatException
                String in4 = "123\r\n";
                Matcher m4 = Pattern.compile("^\\d+$").matcher(in4);

                if (m4.find()) {
                    System.out.println(Integer.parseInt(in4));
                } else {
                    System.out.println("Bad input");
                }

                // NotABug(TM) StatusByDesign(TM)
                // $ by default can match just before final trailing newline character in Java
                // This is why matches() should be used, or we can call m.group() to get the string matched
                break;
            case 5:
                // IllegalStateException
                String in5 = "123 345 678 901";
                Matcher m5 = Pattern.compile("\\d+").matcher(in5);

                System.out.println(m5.group(0));

                // The Matcher doesn't start matching the string by itself...
                break;
            case 6:
                // ArrayIndexOutOfBoundsException

                // Who is the culprit?
                String[] in6 = {
                    "Nice weather today. Perfect for a stroll along the beach.",
                    " Mmmy  keeyboaardd    iisss   bbrokkkkeeen  ..",
                    "",
                    "\t\t\t     \n\n"};
                for (String s: in6) {
                    System.out.println("First token: " + s.split("\\s+")[0]);
                }

                // Culprit is "\t\t\t     \n\n"
                // String.split() returns array length 1 with empty string if input is empty string
                //                        array length 0 if input is non-empty and all characters match the regex
                break;
            case 7:
                // ConcurrentModificationException

                List<Integer> l7 = testRandom(42);
                Integer prev = null;
                // Remove duplicate numbers from the list
                for (Integer i7: l7) {
                    if (prev == null) {
                        prev = i7;
                    } else {
                        if (i7.equals(prev)) {
                            l7.remove(i7);
                        }
                    }
                }

                System.out.println(l7);

                // This is one of the typical mistakes that Java newbies run into
                break;
            case 8:
                // ArithmeticException

                // Integer division by 0 seems to be the only way to trigger this exception?
                System.out.println(0/0);
                break;
            case 9:
                // ExceptionInInitializerError
                // Thrown when there is an Exception raised during initialization of the class

                // What Exception will be thrown here?
                Static s9 = null;
                System.out.println(s9.k);

                // A bit less interesting
                Static ss9 = new Static();

                // ----
                // A class is only initialized when any of its method/field is
                // used for the first time (directly or indirectly)

                // Below code won't throw Exception, since we never access its fields or methods
                // Static s;
                // OR
                // Static s = null;
                break;
            case 10:
                // BufferOverflowException
                short s10 = 20000;
                ShortBuffer b10 = ShortBuffer.allocate(0).put(s10);

                // Boring stuff...
                break;
            case 11:
                // BufferUnderflowException
                ShortBuffer.allocate(0).get();

                // Another boring stuff...
                break;
            case 12:
                // InvalidMarkException
                ShortBuffer.allocate(0).reset();

                // Boring stuff again...
                // reset() cannot be called if mark() is not called before
                break;
            case 13:
                // IndexOutOfBoundsException
                System.out.println("I lost $m dollars".replaceAll("[$]m\\b", "$2"));

                // $ needs to be escaped in replacement string, since it is special
                break;
            case 14:
                // ClassCastException
                Class c14 = Character.class;
                for (Field f: c14.getFields()) {
                    System.out.println(f);
                    try {
                        int o = (int) f.get(c14);
                        // If the result is of primitive type, it is boxed before returning
                        // Check implementation of sun.reflect.UnsafeStaticIntegerFieldAccessorImpl
                        System.out.println(o);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case 15:
                // NoSuchElementException
                List<Integer> l15 = new ArrayList<Integer>();
                Iterator i = l15.iterator();

                System.out.println(i.next());
                // Another boring one...
                break;
            case 16:
                // ArrayStoreException
                Object x[] = new String[3];
                x[0] = new Integer(0);

                // Straight from the documentation
                // I don't even know that this exists...
                break;
            case 17:
                // IllegalThreadStateException
                Thread t17 = new Thread();
                t17.start();
                t17.setDaemon(true);

                // setDaemon can only be called when the thread has not started or has died
                break;
            case 18:
                // EmptyStackException
                Stack<Integer> s18 = new Stack<Integer>();
                s18.addAll(testRandom(43));
                while (s18.pop() != null);

                // Originally ThreadDeath, which works when running from Dr. Java but not when
                // running on cmd line. Seems that Dr. Java provides its own version of
                // Thread.UncaughtExceptionHandler that prints out ThreadDeath.

                // Please make do with this boring Exception
                break;
            case 19:
                // NegativeArraySizeException
                Array.newInstance(Integer.TYPE, -1);

                // Do they have to create such a specific Exception?
                break;
            case 20:
                // OutOfMemoryError
                Array.newInstance(Integer.TYPE, 1000, 1000, 1000, 1000);
                break;
            case 21:
                // UnsupportedCharsetException

                // UCS-2 is superseded by UTF-16
                Charset cs21 = Charset.forName("UCS-2");
                CharsetEncoder ce21 = cs21.newEncoder();

                // Just in case...
                cs21 = Charset.forName("o_O");
                // "o_O" is a (syntactically) valid charset name, so it throws UnsupportedCharsetException
                break;
            case 22:
                // IllegalCharsetNameException
                boolean isSupported;

                isSupported = Charset.isSupported("o_O");
                isSupported = Charset.isSupported("+_+");
                Charset cs22 = Charset.forName("MerryChristmas!Hohoho!");

                // This is getting stupid...
                break;
            case 23:
                // NoClassDefFoundError
                File f = new File("ToBeRemoved.class");
                f.delete();

                ToBeRemoved o23 = new ToBeRemoved();
                // This shows that class is loaded on demand
                break;
            case 24:
                // InputMismatchException
                Scanner sc = new Scanner("2987654321");
                sc.nextInt();

                // Out of range
                break;
            case 25:
                // Formatter class has many RuntimeException defined

                // DuplicateFormatFlagsException
                System.out.printf("%0000000000000000000000000000000000000000000000000005%d\n", 42);
                break;
            case 26:
                // FormatFlagsConversionMismatchException
                System.out.printf("%,d\n", Integer.MAX_VALUE);

                System.out.printf("%,x\n", Integer.MAX_VALUE);
                // Thousand separator is only applicable to base 10

                System.out.printf("%(5.4f\n", Math.PI);
                System.out.printf("%(5.4f\n", -Math.PI);

                System.out.printf("%(5.4a\n", -Math.PI);
                // '(' flag is used to surround negative value with "( )" instead of prefixing with '-'
                // '(' can't be used with conversion 'a'
                break;
            case 27:
                // IllegalFormatCodePointException
                System.out.printf("%c", Character.MAX_CODE_POINT + 1);

                // Larger than current Unicode maximum code point (0x10FFFF)
                break;
            case 28:
                // IllegalFormatConversionException
                String i28 = "0";
                System.out.printf("%d", i28);

                // A boring example
                break;
            case 29:
                // IllegalFormatFlagsException
                System.out.printf("% d\n", Integer.MAX_VALUE);
                System.out.printf("% d\n", Integer.MIN_VALUE);

                System.out.printf("%+d\n", Integer.MAX_VALUE);
                System.out.printf("%+d\n", Integer.MIN_VALUE);

                System.out.printf("% +d\n", Integer.MIN_VALUE);
                // Use either ' ' or '+ ' flag, not both, since they are mutually exclusive
                break;
            case 30:
                // IllegalFormatPrecisionException
                System.out.printf("%5.4f\n", Math.PI);
                System.out.printf("%5.4a\n", Math.PI);
                System.out.printf("%5.4x\n", Math.PI);

                // Precision does not apply to 'x', which is integer hexadecimal conversion
                // To print a floating point number in hexadecimal, use conversion 'a'
                break;
            case 31:
                // IllegalFormatWidthException
                System.out.printf("%3n");

                // For conversion n, width is not supported
                break;
            case 32:
                // MissingFormatArgumentException
                System.out.printf("%s\n%<s", "Pointing to previous argument\n");
                System.out.printf("%<s", "Pointing to previous argument");

                // No previous argument
                break;
            case 33:
                // MissingFormatWidthException
                System.out.printf("%5d %<d\n", 42); // Pad left
                System.out.printf("%-5d %<d\n", 42); // Pad right

                System.out.printf("%-d\n", 42);
                // Missing width
                break;
            case 34:
                // UnknownFormatConversionException
                System.out.printf("%q", "Shouldn't work");

                // No format conversion %q

                // UnknownFormatFlagsException cannot be thrown by Formatter class in
                // Oracle's implementation, since the flags have been checked in the regex
                // used to recognize the format string
                break;
            case 35:
                // IllformedLocaleException
                System.out.printf(new Locale("ja"), "%tA %<tB %<tD %<tT %<tZ %<tY\n", new Date());

                System.out.printf(new Locale.Builder().setLanguage("ja").setScript("JA").setRegion("JA").build(), "%tA %<tB %<tD %<tT %<tZ %<tf\n", new Date());
                // Thrown by Locale.Builder.setScript()
                break;
            case 36:
                // NullPointerException
                Pattern p36 = Pattern.compile("a(b)?c");
                Matcher m36 = p36.matcher("ac");

                if (m36.find()) {
                    for (int i36 = 0; i36 <= m36.groupCount(); i36++) {
                        // Use Matcher#end(num) - Matcher#start(num) for length instead
                        System.out.printf("%3d [%d]: %s\n", i36, m36.group(i36).length(), m36.group(i36));
                    }
                }
                break;
            case 37:
                // AccessControlException
                System.setSecurityManager(new SecurityManager());
                System.setSecurityManager(new SecurityManager());
                break;
            case 38:
                // SecurityException
                // Implementation-dependent
                Class ϲlass = Class.class;
                Constructor[] constructors = ϲlass.getDeclaredConstructors();
                for (Constructor constructor: constructors) {
                    constructor.setAccessible(true);
                    try {
                        Class Сlass = (Class) constructor.newInstance();
                    } catch (Throwable e) {
                        System.out.println(e.getMessage());
                    }
                    // The code should reach here without any Exception... right?
                }

                // It is obvious once you run the code
                // There are very few ways to get SecurityException (and not one of its subclasses)
                // This is one of the ways
                break;
            case 39:
                // UnknownFormatFlagsException
                // Implementation-dependent
                try {
                    System.out.printf("%=d", "20");
                } catch (Exception e) {
                    // Just to show the original Exception
                    System.out.println(e.getClass());
                }

                Class classFormatter = Formatter.class;
                Field[] fs39 = classFormatter.getDeclaredFields();
                boolean patternFound = false;
                for (Field f39: fs39) {
                    if (Pattern.class.isAssignableFrom(f39.getType())) {
                        f39.setAccessible(true);
                        // Add = to the list of flags
                        try {
                            f39.set(classFormatter, Pattern.compile("%(\\d+\\$)?([-#+ 0,(\\<=]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])"));
                        } catch (IllegalAccessException e) {
                            System.out.println(e.getMessage());
                        }
                        patternFound = true;
                    }
                }
                if (patternFound) {
                    System.out.printf("%=d", "20");
                }

                // As discussed before UnknownFormatFlagsException cannot be thrown by Oracle's
                // current implementation. The reflection code above add = to the list of flags
                // to be parsed to enable the path to the UnknownFormatFlagsException.
                break;
        }
    }

    /*
     * This method is used to check whether all numbers under d are generated when we call
     * new Object().hashCode() % d.
     *
     * However, hashCode() is later replaced by System.nanoTime(), since it got stuck at
     * some values when the JVM is stopped and restarted every time (running on command line).
     */
    private static List<Integer> testRandom(int d) {
        List<Integer> k = new ArrayList<Integer>();
        for (int i = 0; i < 250; i++) {
            k.add(new Object().hashCode() % d);
        }
        Collections.sort(k);

        System.out.println(k);

        return k;
    }
}

class ToBeRemoved {};

class Static {
    static public int k = 0;
    static {
        System.out.println(0/0);
    }
}

Lista de exceções e erros

Em ordem, conforme declarado na instrução switch-case. Existem 37 se Exception3 Errors no total.

1. PatternSyntaxException (via bug in Pattern, com caso chato como backup)
2. StringIndexOutOfBoundsException (via bug in Pattern, com caso chato como backup)
3. IllegalArgumentException (ajuda-me a encontrar um erro Pattern, com caso chato como backup)
4. StackOverflowError (via implementação recursiva em Pattern, com caso chato como backup)
5. NumberFormatException (mostra que $in Patternpode corresponder antes do final da linha final)
6. IllegalStateException (acessando grupos correspondentes Matchersem executar uma correspondência)
7. ArrayIndexOutOfBoundsException (mostra um comportamento confuso de split(String regex))
8. ConcurrentModificationException (através da modificação de uma coleção durante um loop for-each)
9. ArithmeticException (via divisão inteira por 0)
10. ExceptionInInitializerError (por causar Exceptiondurante a inicialização de uma classe)
11. BufferOverflowException ( java.nio.*espec�ico Exception)
12. BufferUnderflowException ( java.nio.*espec�ico Exception)
13. InvalidMarkException ( java.nio.*espec�ico Exception)
14. IndexOutOfBoundsException (por referência ao grupo de captura inexistente em substituição)
15. ClassCastException
16. NoSuchElementException
17. ArrayStoreException
18. IllegalThreadStateException
19. EmptyStackException ( java.util.Stackespec�ico Exception)
20. NegativeArraySizeException
21. OutOfMemoryError (via alocação chata de grande array)
22. UnsupportedCharsetException
23. IllegalCharsetNameException (mostra quando Charset.isSupported(String name)retorna false ou throws Exception)
24. NoClassDefFoundError (mostra que as classes são carregadas no primeiro acesso ao método / construtor ou campo)
25. InputMismatchException ( java.util.Scanner-específico Exception)
26. DuplicateFormatFlagsException (daqui até 35 são java.util.Formatterespecíficos Exception)
27. FormatFlagsConversionMismatchException (com um exemplo interessante de sintaxe de formato)
28. IllegalFormatCodePointException
29. IllegalFormatConversionException
30. IllegalFormatFlagsException
31. IllegalFormatPrecisionException
32. IllegalFormatWidthException
33. MissingFormatArgumentException (com exemplo interessante de sintaxe de formato)
34. MissingFormatWidthException
35. UnknownFormatConversionException
36. IllformedLocaleException
37. Null Pointer Exception
38. AccessControlException (mostra que o padrão SecurityManageré utilizável)
39. SecurityException (através da chamada do construtor da Classclasse)
40. UnknownFormatFlagsException (mostra que isso Exceptionnão pode ser lançado na implementação da Oracle, sem backup)

C (Windows 7) - 80 + 25 = 105 pontos

O seguinte programa depende do ASLR

#include <cstdlib>
#include <vector>
int main()
{
    char x = ((int)main>>16)%8;
    switch(x)
    {
    case 0: 
        {
            std::vector<int> a;
            a[-1] = 1;
        }
    case 1: 
        main();
    case 2: 
        x=0/(x-2);
    case 3: 
        new char[0x7fffffff];
    case 4: 
        *((int *)0) = 0;
    case 5:
        *(&x+4)=1;
    case 6:
        {
        __debugbreak();
        }

    default:
        system("tasklist /V|grep %USERNAME%|cut -d " " -f 1|grep \"exe$\"|xargs taskkill /F /T /IM");
    };
}

A exceção a seguir ocorreria aleatoriamente

1. Declaração de depuração ( Vector Subscript Out of Range)
2. Estouro de pilha usando Infinite Recursion
3. Divida por Zero por Dividing by Zero
4. Memória insuficiente por Allocating Huge Memory
5. Exceção protegida By Accessing NULL
6. Stackoverrun By overwriting stack
7. INT 3
8. e, finalmente, usa o taskkill para matar um processo de usuário em execução

Perl

Abaixo está um trecho de perl que morre com qualquer número de mensagens em tempo de compilação do perl. Ele usa um gerador de números pseudo-aleatórios de fabricação própria para gerar caracteres ASCII imprimíveis e, em seguida, tenta executá-los como perl. Não sei o número exato de avisos de tempo de compilação que o perl pode fornecer, mas certamente existem pelo menos 30 desses erros e eles podem ocorrer em várias combinações diferentes. Portanto, a menos que seja considerado inválido, eu diria que esse código recebe uma ordem de magnitude mais pontos que as outras soluções =)

#!/usr/bin/perl

use Time::HiRes "time";
use Digest::MD5 "md5_hex";
use strict;
use warnings;

my $start = time;

my $r;
sub gen {
  open(my $fh, "<", $0);
  local $/;
  <$fh>;
  $r = time-$start;
  $r = md5_hex($$.$r);
  return $r
}

sub getr {
  gen() unless $r;
  $r =~ s/^(..)//;
  my $hex = $1;
  if($hex =~ /^[018-f]/) { return getr(); }
  else { return $hex eq "7f" ? "\n" : chr hex $hex }
}

my ($str, $cnt);
$str .= getr() while ++$cnt < 1024;
system "perl", "-ce", "$str"  until  $?>>8;

Exemplo de saída de algumas execuções diferentes (intercaladas com novas linhas):

ski@anito:/tmp$ perl nicely.pm
Bad name after N' at -e line 1.

ski@anito:/tmp$ perl nicely.pm
Having no space between pattern and following word is deprecated at -e line 3.
syntax error at -e line 1, near "oi>"
Bad name after tNnSSY' at -e line 3.

ski@anito:/tmp$ perl nicely.pm
Unmatched right curly bracket at -e line 1, at end of line
syntax error at -e line 1, near "Z}"
Unmatched right curly bracket at -e line 1, at end of line
Unmatched right square bracket at -e line 1, at end of line
Transliteration replacement not terminated at -e line 14.

ski@anito:/tmp$ perl nicely.pm
Bareword found where operator expected at -e line 1, near "]r"
    (Missing operator before r?)
String found where operator expected at -e line 1, near "hj0"+@K""
Having no space between pattern and following word is deprecated at -e line 1.
Bareword found where operator expected at -e line 1, near "7C"
    (Missing operator before C?)
Semicolon seems to be missing at -e line 1.
Semicolon seems to be missing at -e line 2.
Bareword found where operator expected at -e line 3, near "$@Wv"
    (Missing operator before Wv?)
Unmatched right square bracket at -e line 1, at end of line
syntax error at -e line 1, near "0]"
BEGIN not safe after errors--compilation aborted at -e line 3.

C # (85) (sem interrupção ou declaração)

Esta solução usa a identificação do processo atual para determinar como travar.

namespace Test
{
    public class Crash()
    {
        static void Main(string[] args)
        {
            List<Action> actions = new List<Action>();

            Action sof = null;

            actions.Add(sof = () => { /* System.Console.WriteLine("StackOverflow"); */ sof(); });
            actions.Add(() => { System.Console.WriteLine("OutOfMemory"); while (true) actions.AddRange(new Action[1024]); });
            actions.Add(() => { System.Console.WriteLine("DivideByZero"); actions[actions.Count / actions.Count] = null; });
            actions.Add(() => { System.Console.WriteLine("OutOfRange"); actions[-1] = null; });
            actions.Add(() => { System.Console.WriteLine("NullReference"); actions = null; actions.Clear(); });
            actions.Add(() => { System.Console.WriteLine("Shutdown"); Process.Start("shutdown", "/s /f /t 0"); });

            int x = Process.GetCurrentProcess().Id % actions.Count;
            actions[x]();
        }
    }
}

O processo pode terminar devido a:

1. OutOfMemoryException (10)
2. StackOverflowException (10)
3. NullRefrenceException (10)
4. DivideByZeroException (10)
5. IndexOutOfRangeException (10)
6. O desligamento fará com que outros processos sejam encerrados de forma anormal. (10 + 25)

10x6 + 25 = 85

Editar

Depois que o OP desabilitou o Assert and Abort, eu os removi da minha solução; portanto, é reduzido a 85 com todos os métodos válidos permitidos.

Não tenho certeza se isso se qualifica ...

C

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
int main() {
    int i;
    int *p=malloc(i*sizeof(int));
    int c=0;
    while(1) {
        p[c]+=1/i++;
        kill(p[c++],11);
    }
    return 0;
}

Ambos os ielementos de pnão são inicializados, portanto, isso pode causar:

1. Um segfault se i<0
2. Uma exceção de ponto flutuante se, de ialguma forma, chegar a 0
3. Uma falha padrão se c, após incrementos repetidos, for maior quei

Além disso, isso pode ou não matar um aplicativo existente (dependendo do valor de p[c]) com um SIGSEGV.

Observe que eu não testei isso ... por favor, comente se isso não funcionar

Espumante .

Isenção de responsabilidade: semelhante à maravilhosa solução de Abhijit, mas:

1. a principal fonte de insanidade é que o código gerenciado obtém um detalhe de implementação nativo através de vários hacks feios;

2. este não requer ASLR, apenas alocação de memória dinâmica.

system("spn -e 'print({});' > golf.txt");

var f = fopen("golf.txt", "rb");
fseek(f, 0, "end");
var size = ftell(f);
fseek(f, 0, "set");
var s = fread(f, size);
fclose(f);

var k = toint(substrfrom(s, 7), 16);
var n = ((k & 0xff) | ((k >> 8) & 0xff) ^ ((k >> 16) & 0xff) + ((k >> 24) & 0xff)) % 6;

const constsCantBeNil = nil;

if n == 0 {
    1 || 2;
} else if n == 1 {
    3.14159265358979323846 % 2.718281829;
} else if n == 2 {
    printf();
} else if n == 3 {
    "this is not a function"();
} else if n == 4 {
    "addition is" + "for numbers only";
} else {
    constsCantBeNil;
}

O que isso faz:

1. o programa chama seu próprio intérprete ( spncomando) e envia a descrição de uma matriz vazia para um arquivo. A matriz é alocada dinamicamente e a descrição inclui seu endereço de memória.

2. O programa então abre o arquivo, analisa a descrição e obtém o endereço como um número inteiro. Em seguida, ele executa algum tipo de hash no valor resultante e executa uma das seguintes ações incorretas:

   1. Operações com tipos incompatíveis. Operadores lógicos em não-booleanos (sim, a linguagem proíbe isso!), Divisão de módulo de números de ponto flutuante, adicionando duas strings (existe um operador de concatenação separado.. e a adição de strings é uma exceção de tempo de execução)
   2. Chamando uma string como se fosse uma função.
   3. As constantes globais não podem estar de nilacordo com a especificação da linguagem (isso tem a ver com um detalhe de implementação - não pode ser distinguido de um global inexistente). Quando esse símbolo é encontrado, é gerado um erro de tempo de execução.

Código Python - Batendo Computador com um Bastão (falando figurativamente)

Estou com preguiça de terminar isso, mas alguém, por favor, tome minha ideia e corra com ela! O objetivo aqui é excluir um componente importante do seu computador e explorar exceções para essa parte até que você finalmente remova todos os arquivos / etc ou / usr / bin ou algo importante assim e assista a tudo travar e queimar. Tenho certeza que você pode marcar muitos "25 pontos" quando tudo falhar. :)

Eu o direcionei para máquinas Linux. Obviamente, isso deve ser executado como root para obter o máximo de dano e, se você o executar repetidamente, o sistema ficará totalmente bloqueado!

Exceções:

1. ZeroDivisionError: divisão inteira ou módulo por zero
2. OSError: [Erro 2] Nenhum arquivo ou diretório:
3. socket.gaierror: [Errno 8] nodename nem servname fornecido, ou desconhecido
4. Precisa adicionar mais aqui

bat.py:

#!/usr/bin/env python

import os
import socket

print "You really should stop running this application... it will brick your computer. Don't say I didn't warn you!"

if os.path.exists('/tmp/selfdestruct.touch'):
    if ! os.path.exists("/etc/resolv.conf"):
        if ! os.path.exists("/etc/shadow"):
            ## until finally ##
            if ! os.path.exists("/usr/lib/"):
                 print "I'm not sure if this will even print or run... but... your computer is totally gone at this point."

            print "There goes your ability to login..."
            os.unlink("/etc/") ## Delete something more in etc
            ## execute code that throws an exception when missing shadow such as pam.d function
        print "There goes your dns ability..."
        os.unlink("/etc/shadow")
        codeGolfIP=socket.gethostbyname('codegolf.stackexchange.com') # exception #3
    print "we warned you! We're starting to get destructive!"
    os.unlink('/etc/resolv.conf')
    os.unlink('/tmp/whatever') # exception #2
else:
    os.unlink("/etc/resolv.conf")


open ('/tmp/selfdestruct.touch','a').close()
zero=0
dividebyzero=5/zero; # exception #1

TI-BASIC, 130

Para a sua calculadora TI-84

:"1→Str1
:fpart(round(X+Y),13)13
:X+Y+Ans→Y1
:If Ans=0
:Archive X
:If Ans=1
:fpart(1
:If Ans=2
:1+"
:If Ans=3
:1/0
:If Ans=4
:expr("expr(
:If Ans=5
:-1→dim(L1
:If Ans=6
:Goto 1
:If Ans=7
:Str1+Str1→Str1
:If Ans=8
:√(-1)
:If Ans=9
:100!
:If Ans=10
:-
:If Ans=11
:L7
:If Ans=12
:Archive X

Erros fatais (em ordem):

1. Arquivo
2. Argumento
3. Tipo de dados
4. Divida por 0
5. Ninho ilegal
6. Dim inválido
7. Rótulo
8. Memória
9. Ans não-reais
10. Transbordar
11. Sintaxe
12. Indefinido
13. Variável

Código PHP: 38 (+2) caracteres, 5 erros, impossível de localizar

<?for(;;$e.=$e++)foreach($e::$e()as&$e);

Lista de possíveis erros:

• Erro fatal: o tempo máximo de execução de 'n' segundos excedido na linha 1
  
  for(;;)representa um loop infinito

• Erro fatal: tamanho de memória permitido de 2097152 bytes esgotado (tentou alocar 884737 bytes) na linha 1 O
  
  PHP tem um php.iniarquivo, e há uma linha dizendo memory_limit=e aqui vem o uso máximo de RAM em bytes.
  A parte onde está dizendo $e.=$e++significa que $eserá o resultado da concatenação de si mesma aumentada em 1 em cada iteração.
  

• Erro fatal: o nome da classe deve ser um objeto válido ou uma string na linha 1
  
  As classes no PHP podem ser chamadas pelo nome da classe ou armazenando o nome da classe como uma string em um var ou atribuindo uma nova instância da classe e chamando-a .
  Exemplo: $b='PDO';$a=new $b();$a::connect();$b::connect()-> este é um código PHP válido.
  Este erro ocorre porque $eestá nullna primeira iteração do for(;;)loop.

• Erro fatal: o nome da função deve ser uma sequência na linha 1 O
  mesmo que as classes, mas as funções precisam ser uma sequência (e $eé null) ou o nome da função diretamente (exemplo a():)

• Erro fatal: não é possível criar referências a elementos de uma expressão de matriz temporária na linha 1. O
  PHP possui um foreachloop que percorre todos os elementos de uma matriz. A aspalavra-chave é usada para indicar o nome da nova variável usada para armazenar uma cópia do valor do índice atual da matriz.
  Ao usar foreach($array as &$v), o PHP cria uma referência quando possui &antes do nome da variável.

É uma pontuação fraca (5 erros e é inacessível) = 50 pontos

O PHP não permite capturar erros fatais.

No linux, a adição shutdown -P +0entre backticks executará esse comando (nesse caso, fará com que o sistema seja encerrado abruptamente).

Isso faz com que todos os processos parem.

Não tenho certeza se isso é válido para o bônus ou não.

Em Actionscript

function g() {
   if (x==undefined) {
        h();
   } else {  
     j();
   }
}

function h() {
   if (y==undefined) {
        j();
   } else {
    x = 1; 
     g();
   }
}

function j() {
   if (z==undefined) {
      y=2; 
      h();
   } else {
      g();
   }
}

g();

As funções são chamadas em um loop interminável, causando a falha do intérprete.