Wahnsinn: immer wieder dasselbe tun und unterschiedliche Ergebnisse erwarten.

Schreiben Sie ein Programm, das bei jeder Ausführung nur eine Ausnahme (Laufzeitfehler) auslöst. Die Herausforderung besteht darin, die Wahrscheinlichkeit zu haben, mehr als einen Absturz zu verursachen, ohne die Ausnahmen direkt aufzurufen (keine throwAnweisungen) und keine eingebauten Zufalls- oder CPU-Tick-Zählfunktionen zu verwenden.

• 10 Punkte für jeden möglichen Fehler.
• 25 Bonuspunkte, wenn der Fehler / Absturz bei einem anderen Prozess oder System auftritt.

Regeln

1. Antworten müssen angeben, welche Fehler möglich sind und wie sie generiert werden.
2. Der (integrierte) Zufallszahlengenerator des Systems kann nur verwendet werden, wenn bei jeder Programmausführung die gleiche Zahl verwendet wird.
3. Die Anzahl der Tics oder CPU-Zyklen kann nicht verwendet werden, es sei denn, sie werden relativ zum Start des Hauptprogrammthreads gezählt.
4. Multithreading ist zulässig (sofern nicht ausdrücklich empfohlen).

Bearbeiten 1

1. Die GUID-Erzeugung fällt unter den eingebauten Zufallszahlengenerator. Benutzerdefinierte "hausgemachte" GUID-Generierung ist zulässig.

2. Der Zugriff auf das Dateisystem ist für E / A von Dateien zulässig, es sei denn, dies geschieht unter Umgehung der Regeln (Lesen einer Datei mit zufälligen Bits oder Zeitstempel).

Bearbeiten 2

1. Wenn Sie den Geist der Herausforderung, verrückte Software zu entwickeln, anrufen abort()oder assert()verletzen, werden für diese Art des Scheiterns keine 10 Punkte vergeben.

Viel Glück!

Java, 400

Java ist mit vielen s und s gesegnet . Es gibt viele , die für den Betrieb einer einzelnen Klasse spezifisch sind. Als Beispiel für einen der extremsten Fälle gibt es mehr als 10 Sekunden (alle sind Unterklassen von ), die nur der Klasse gewidmet sind , und ich habe mir Zeit genommen, um den Code (fast) alle zu werfen.ExceptionErrorExceptionExceptionIllegalFormatExceptionFormatter

Meine aktuelle Antwort enthält 40 verschiedene Exceptions / Errors, die je nach Modulo System.nanoTime()mit einer ganzen Zahl zufällig ausgeführt werden .

Diese Methode kann nur zur Messung der abgelaufenen Zeit verwendet werden und steht in keinem Zusammenhang mit einem anderen Begriff der System- oder Wanduhrzeit. Der zurückgegebene Wert stellt Nanosekunden seit einer festgelegten, aber willkürlichen Ursprungszeit dar (möglicherweise in der Zukunft, sodass die Werte möglicherweise negativ sind). Derselbe Ursprung wird von allen Aufrufen dieser Methode in einer Instanz einer virtuellen Java-Maschine verwendet. Andere Instanzen virtueller Maschinen verwenden wahrscheinlich einen anderen Ursprung.

Die obige Methode sollte zulässig sein, da sie in den Fall "3. Kann die Anzahl der Tics oder CPU-Zyklen nicht verwenden, es sei denn, sie werden relativ zum Start des Hauptprogrammthreads gezählt" fällt .

Kompilierungsanleitung

Es wird dringend empfohlen , JRE / JDK oder OpenJDK von Oracle zum Ausführen des Codes zu verwenden. Andernfalls werden einige Ausnahmen möglicherweise nicht ausgelöst, da sich einige von ihnen auf die internen Details der Referenzimplementierung stützen und ich keinen zuverlässigen Fallback habe.

Der folgende Code wird erfolgreich kompiliert javac 1.7.0_11und erzeugt alle Ausnahmen am java 1.7.0_51.

1. Um diesen Code auszuführen, müssen Sie den folgenden Code in einen Unicode-fähigen Editor (z. B. Notepad ++) kopieren und einfügen und in UTF-16 speichern (Big-Endian oder Little-Endian spielen keine Rolle, solange die Stückliste geschrieben ist). .

2. Ändern Sie das Arbeitsverzeichnis ( cd) in das Verzeichnis, in dem der Quellcode gespeichert ist ( dies ist wichtig ).

3. Kompilieren Sie den Code mit dem folgenden Befehl:

   javac G19115.java -encoding "UTF-16"
   

4. Und führen Sie den Code aus:

   java G19115
   

Mein Code ist nicht destruktiv, da ich ihn auch auf meinem Computer testen möchte. Der "gefährlichste" Code ist das Löschen von ToBeRemoved.classDateien im aktuellen Ordner. Ansonsten berührt der Rest weder das Dateisystem noch das Netzwerk.

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);
    }
}

Liste der Ausnahmen und Fehler

In der in der switch-case-Anweisung angegebenen Reihenfolge. Insgesamt gibt es 37 Exceptions und 3 Errors.

1. PatternSyntaxException (via Bug-In Pattern, mit langweiligem Fall als Backup)
2. StringIndexOutOfBoundsException (via Bug-In Pattern, mit langweiligem Fall als Backup)
3. IllegalArgumentException (hilft mir, einen Fehler zu finden Pattern, mit langweiligem Fall als Backup)
4. StackOverflowError (über rekursive Implementierung in Pattern, mit langweiligem Fall als Backup)
5. NumberFormatException (zeigt, dass $in Patternvor dem Abschlusszeichen der letzten Zeile übereinstimmen kann)
6. IllegalStateException (über den Zugriff auf übereinstimmende Gruppen in, Matcherohne eine Übereinstimmung durchzuführen)
7. ArrayIndexOutOfBoundsException (zeigt verwirrendes Verhalten von split(String regex))
8. ConcurrentModificationException (über das Ändern einer Sammlung während einer For-Each-Schleife)
9. ArithmeticException (über ganzzahlige Division durch 0)
10. ExceptionInInitializerError (über das Verursachen Exceptionwährend der Initialisierung einer Klasse)
11. BufferOverflowException ( java.nio.*-spezifisch Exception)
12. BufferUnderflowException ( java.nio.*-spezifisch Exception)
13. InvalidMarkException ( java.nio.*-spezifisch Exception)
14. IndexOutOfBoundsException (über Verweis auf nicht vorhandene Erfassungsgruppe als Ersatz)
15. ClassCastException
16. NoSuchElementException
17. ArrayStoreException
18. IllegalThreadStateException
19. EmptyStackException ( java.util.Stack-spezifisch Exception)
20. NegativeArraySizeException
21. OutOfMemoryError (über langweilige Zuweisung eines großen Arrays)
22. Nicht unterstützte Zeichensatzausnahme
23. IllegalCharsetNameException (zeigt an, wann Charset.isSupported(String name)false oder throws zurückgegeben werden Exception)
24. NoClassDefFoundError (zeigt an, dass Klassen beim ersten Zugriff auf Methode / Konstruktor oder Feld geladen werden)
25. InputMismatchException ( java.util.Scanner-spezifisch Exception)
26. DuplicateFormatFlagsException (von hier bis 35 sind java.util.Formatter-spezifische Exceptions)
27. FormatFlagsConversionMismatchException (mit interessantem Beispiel für Formatsyntax)
28. IllegalFormatCodePointException
29. IllegalFormatConversionException
30. IllegalFormatFlagsException
31. IllegalFormatPrecisionException
32. IllegalFormatWidthException
33. MissingFormatArgumentException (mit interessantem Beispiel für Formatsyntax)
34. MissingFormatWidthException
35. UnknownFormatConversionException
36. IllformedLocaleException
37. NullPointerException
38. AccessControlException (zeigt an, dass die Standardeinstellung verwendet werden kann SecurityManager)
39. SecurityException (über den Aufruf des Konstruktors der ClassKlasse)
40. UnknownFormatFlagsException (zeigt, dass dies Exceptionin der Oracle-Implementierung nicht ausgelöst werden kann, keine Sicherung)

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

Das folgende Programm basiert auf 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");
    };
}

Die folgende Ausnahme würde zufällig auftreten

1. Debug Assertion ( Vector Subscript Out of Range)
2. Stapelüberlauf mit Infinite Recursion
3. Teilen durch Null durch Dividing by Zero
4. Out Of Memory von Allocating Huge Memory
5. Geschützte Ausnahme By Accessing NULL
6. Stackoverrun By overwriting stack
7. INT 3
8. und verwendet schließlich taskkill, um einen laufenden Benutzerprozess zu beenden

Perl

Unten sehen Sie ein Perl-Snippet, das mit einer beliebigen Anzahl von Perl-Nachrichten zur Kompilierungszeit stirbt. Es verwendet einen selbst gebrauten Pseudozufallszahlengenerator, um druckbare ASCII-Zeichen zu generieren, und versucht dann, diese als Perl auszuführen. Ich weiß nicht, wie viele Warnungen beim Kompilieren von Perl ausgegeben werden können, aber es gibt mindestens 30 solcher Fehler, die in verschiedenen Kombinationen auftreten können. Also, es sei denn, es ist ungültig, würde ich sagen, dass dieser Code eine Größenordnung mehr Punkte als die anderen Lösungen bekommt =)

#!/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;

Beispielausgabe von mehreren Läufen (durchsetzt mit Zeilenumbrüchen):

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) (Ohne Abbrechen oder Bestätigen)

Diese Lösung verwendet die aktuelle Prozess-ID, um zu bestimmen, wie ein Absturz erfolgen soll.

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]();
        }
    }
}

Der Prozess kann aufgrund folgender Gründe abgebrochen werden:

1. OutOfMemoryException (10)
2. StackOverflowException (10)
3. NullRefrenceException (10)
4. DivideByZeroException (10)
5. IndexOutOfRangeException (10)
6. Beim Herunterfahren werden andere Prozesse abnormal beendet. (10 + 25)

10x6 + 25 = 85

Bearbeiten

Nachdem das OP Assert und Abort nicht zugelassen hat, habe ich sie aus meiner Lösung entfernt, daher ist es mit allen gültigen zulässigen Methoden auf 85 gesunken.

Nicht sicher, ob dies qualifiziert ist ...

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;
}

Beide iund Elemente von psind nicht initialisiert, daher kann dies entweder dazu führen, dass:

1. Ein Segfault wenn i<0
2. Eine Gleitkomma-Ausnahme, wenn der iWert 0 ist
3. Ein Segfault, wenn cnach wiederholten Inkrementen größer als wirdi

Darüber hinaus kann dies dazu führen, dass eine vorhandene Anwendung (abhängig vom Wert von p[c]) mit einem SIGSEGV beendet wird oder nicht.

Beachten Sie, dass ich dies nicht getestet habe. Kommentieren Sie daher bitte, wenn dies nicht funktioniert

Funkelnd .

Haftungsausschluss: Ähnlich wie Abhijits wunderbare Lösung, aber:

1. Die Hauptursache für Wahnsinn ist, dass verwalteter Code durch eine Reihe hässlicher Hacks ein natives Implementierungsdetail erhält.

2. Dies erfordert kein ASLR, sondern nur eine dynamische Speicherzuweisung.

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;
}

Was dies bewirkt:

1. Das Programm ruft einen eigenen Interpreter ( spnBefehl) auf und gibt die Beschreibung eines leeren Arrays in eine Datei aus. Das Array wird dynamisch zugewiesen und die Beschreibung enthält die Speicheradresse.

2. Das Programm öffnet dann die Datei, analysiert die Beschreibung und erhält die Adresse als Ganzzahl. Es führt dann eine Art Hashing für den resultierenden Wert durch und führt eine der folgenden fehlerhaften Aktionen aus:

   1. Operationen mit nicht übereinstimmenden Typen. Logische Operatoren auf Nicht-Booleschen Werten (ja, die Sprache verbietet dies!), Modulo-Division von Gleitkommazahlen, Hinzufügen von zwei Zeichenfolgen (es gibt einen separaten Verkettungsoperator ..und das Hinzufügen von Zeichenfolgen ist eine Laufzeitausnahme)
   2. Aufrufen eines Strings als ob es eine Funktion wäre.
   3. Globale Konstanten können nicht nilder Sprachspezifikation entsprechen (dies hat mit einem Implementierungsdetail zu tun - es kann möglicherweise nicht von einem nicht existierenden globalen unterschieden werden). Wenn ein solches Symbol auftritt, wird ein Laufzeitfehler ausgelöst.

Python Code - Bashing Computer mit einer Fledermaus (bildlich gesprochen)

Ich bin zu faul, um das zu beenden, aber jemand, bitte nimm meine Idee und renne damit! Das Ziel hier ist es, eine wichtige Komponente Ihres Computers zu löschen und Ausnahmen für diesen Teil auszunutzen, bis Sie schließlich ganz / etc oder / usr / bin oder etwas Wichtiges wie das rm und zusehen, wie das Ganze abstürzt und brennt. Ich bin sicher, Sie können eine Menge "25 Punkte" erzielen, wenn alles abstürzt. :)

Ich habe es auf Linux-Maschinen ausgerichtet. Dies muss natürlich als Root ausgeführt werden, um maximalen Schaden zu verursachen. Wenn Sie es wiederholt ausführen, bleibt Ihr System komplett überfrachtet!

Ausnahmen:

1. ZeroDivisionError: Ganzzahlige Division oder Modulo durch Null
2. OSError: [Errno 2] Keine solche Datei oder kein solches Verzeichnis:
3. socket.gaierror: [Errno 8] Knotenname oder Servername angegeben oder nicht bekannt
4. Müssen Sie hier weitere hinzufügen

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

Für Ihren TI-84 Taschenrechner

:"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

Schwerwiegende Fehler (in Reihenfolge):

1. Archiv
2. Streit
3. Datentyp
4. Teilen Sie durch 0
5. Illegales Nest
6. Ungültige Abmessung
7. Etikette
8. Erinnerung
9. Nonreal Ans
10. Überlauf
11. Syntax
12. Nicht definiert
13. Variable

PHP-Code: 38 (+2) Zeichen, 5 Fehler, nicht abfangbar

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

Liste möglicher Fehler:

• Schwerwiegender Fehler: Die maximale Ausführungszeit von 'n' Sekunden in Zeile 1 ist
  
  for(;;)eine Endlosschleife

• Schwerwiegender Fehler: Die zulässige Speichergröße von 2097152 Bytes ist in Zeile 1 erschöpft (es wurde versucht, 884737 Bytes zuzuweisen).
  
  PHP hat eine php.iniDatei, und in einer Zeile steht, dass memory_limit=die maximale RAM-Nutzung in Bytes angegeben ist.
  Der Teil, in dem gesagt wird, $e.=$e++bedeutet, $edass das Ergebnis der Verkettung von sich selbst in jeder Iteration um 1 erhöht wird.
  

• Schwerwiegender Fehler: Klassenname muss ein gültiges Objekt oder eine Zeichenfolge in Zeile 1 sein.
  
  Klassen in PHP können entweder über den Klassennamen oder durch Speichern des Klassennamens als Zeichenfolge in einer Variablen oder durch Zuweisen einer neuen Instanz der Klasse und Aufrufen aufgerufen werden .
  Beispiel: $b='PDO';$a=new $b();$a::connect();$b::connect()-> Dies ist ein gültiger PHP-Code.
  Dieser Fehler tritt auf, weil er $esich nullin der ersten Iteration der for(;;)Schleife befindet.

• Fatal error: Funktionsname muss eine Zeichenfolge auf der Linie 1 sein
  Gleiche wie Klassen, sondern Funktionen haben eine Zeichenfolge (und sein $eist null) oder der Name der Funktion direkt (Beispiel: a())

• Schwerwiegender Fehler: Es können keine Verweise auf Elemente eines temporären Array-Ausdrucks in Zeile 1 erstellt werden.
  PHP verfügt über eine foreachSchleife, die alle Elemente in einem Array durchläuft. Das asSchlüsselwort wird verwendet , um den Namen der neuen Variablen , um anzuzeigen , verwendet , um eine Speicherung Kopie des Wertes des aktuellen Arrayindex.
  Bei der Verwendung von foreach($array as &$v)PHP wird eine Referenz erstellt , die &vor dem Variablennamen steht.

Es ist eine schwache Punktzahl (5 Fehler und ist nicht zu fangen) = 50 Punkte

PHP erlaubt es nicht, schwerwiegende Fehler abzufangen.

Unter Linux führt das Hinzufügen shutdown -P +0zwischen Backticks diesen Befehl aus (in diesem Fall wird das System abrupt heruntergefahren).

Dies führt dazu, dass alle Prozesse angehalten werden.

Nicht sicher, ob dies für den Bonus gültig ist oder nicht.

In 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();

Funktionen werden in einer nie endenden Schleife aufgerufen, wodurch der Interpreter abstürzt.