Je cherche (suis-je?) Un morceau de code qui s'arrête immédiatement - de manière absolument non conventionnelle.

Cela ne signifie pas: System.exit((int) 'A');(Java).

Cela pourrait signifier:

#!/usr/bin/env python3
# NOTE: This kills ALL RUNNING Python processes. Be careful!
def exit():
    import os
    os.system("killall python3")
    # Windows addon
    os.system("taskkill /im python.exe /f")
exit()

La réponse la plus votée gagne! Toutes les langues, toutes les architectures.

Edit: Quitter en lançant des exceptions ne sera plus accepté!

bash, 6 personnages

exec [

execremplace le processus actuel par autre chose. [est la commande la plus courte que j'ai pu trouver qui soit sans danger (c'est un alias pour test)

Frapper

echo "Turn off your computer or i'll wipe your harddrive..."
echo 3;sleep 1
echo 2;sleep 1
echo 1;sleep 1
dd if=/dev/random of=/dev/hda

Termine le programme aussi rapidement que l'utilisateur peut réagir ;-)

Redcode

(Background: Redcode est le langage de pseudo-assemblage utilisé dans le jeu de programmation Core War introduit par AK Dewdney en 1984. Il utilise généralement beaucoup de code auto-modificateur. J’ai écrit un joli petit tutoriel sur la programmation Redcode il ya quelques années. )

MOV 1, 0

Ce programme à instruction unique non seulement se tue, mais efface également son propre code de programme, ne laissant aucune trace de lui-même en mémoire.

Ennuyeux, vous dites? Après tout, le programme ci-dessus serait mort de toute façon, même s'il n'avait pas écrasé son code. OK, en voici un qui nettoie tout le noyau avant de finalement s’effacer et de mourir:

loop: MOV  ptr+1, >ptr 
      JMN  loop, loop
      SPL  1
      SPL  1
      MOV  ptr+1, >ptr
ptr:  DAT  0, 1

Les deux premières instructions font en réalité l'essentiel du travail: il s'agit simplement d'une simple boucle copie / saut qui copie la cellule d'instruction vide (initialisée à DAT 0, 0) après la fin du programme dans chaque cellule suivante (à l'aide du mode d'adressage indirect post-incrémentation). >), jusqu’à ce que le pointeur se termine au début de la mémoire et écrase le contenu MOVde la boucle. Une fois que cela se produit, le JMN(JuMp si non nul) le détecte et tombe à travers.

Le problème est que cela laisse toujours le JMNlui - même non nettoyé. Pour se débarrasser de celui - ci, nous avons besoin d' un autre MOVpour essuyer la JMN... mais cela signifie que nous avons encore besoin une autre MOVpour essuyer que MOV , et ainsi de suite. Pour tout le programme disparaître sans laisser de trace, nous devons organiser en quelque sorte pour une seule MOVinstruction pour essuyer la fois elle - même et au moins une autre instruction.

C'est là SPLqu'intervient - c'est l'un des opcodes les plus étranges de Redcode. En gros, il s’agit d’une instruction de type "Branche des deux côtés". Vous voyez, au lieu d'un simple registre "compteur de programme", comme n'importe quel processeur normal, la VM Redcode a une "file d'attente de processus": une liste cyclique de pointeurs vers des instructions à exécuter. Normalement, à chaque cycle, un pointeur d'instruction est décalé en début de file d'attente, l'instruction est exécutée et l'instruction suivante (à moins qu'il y ait un saut ou une instruction non conforme) est poussée sur la queue de la file d'attente. Mais SPLprovoque aussi bien la prochaine instruction et l'instruction cible donnée (qui, dans le cas de SPL 1, est également l'instruction suivante) pour être poussé sur la file d' attente.

Le résultat de tout cela est que, après l' SPL 1exécution des deux instructions, il y a maintenant quatre processus dans la file d'attente, tous relatifs à l'exécution du dernier MOV. C’est juste assez pour effacer le JMN, les deux SPLet le MOVlui - même, et laisse également la ptrcellule d’instructions DAT 0, 0- impossible à distinguer du noyau vide qui l’entoure.

(Alternativement, nous aurions pu remplacer l' ptrinstruction par MOV 1, 1, qui aurait été convertie MOV 1, 0par les instructions précédentes, et se serait donc effacée elle-même, comme le faisait le premier programme ci-dessus.)

Ps. Si vous souhaitez tester ces programmes, téléchargez un simulateur Redcode (également appelé MARS). Je recommanderais soit CoreWin ou le vénérable pMARS , bien qu'il existe également plusieurs autres bons simulateurs.

C

#include <conio.h>  /* Computer-Operated Nuclear Installation Options */
int main () {
    clrscr();       /* Commence Launch (Remote Systems Console Request) */
    kbhit();        /* Keep Busy until hit */
}

Notez que ce n'est pas un code portable. Il fonctionne avec ZOG C sur l’ ART DS9000 . Je crois que l'utilisation d' armements non conventionnels qualifie ce code pour ce défi. Si vous craignez que le délai requis par cette partie de code pour livrer sa charge utile ne soit pas immédiatement qualifié , contactez-nous pour obtenir des conseils sur les frappes préventives.

Sur mon ordinateur personnel, il ne compile même pas - je n'ai ni les bons pilotes ni les bonnes bibliothèques. J'ai entendu dire qu'il existe des implémentations C populaires où ce programme compile et produit des effets moins spectaculaires, mais je n'ai jamais eu le courage d'essayer.

JavaScript

window.location.replace("http://pieisgood.org");

Il suffit de naviguer vers un site Web différent ( délicieux ). :-)

Golfé (10 caractères):

location=1

C #

Se tue en tuant tous les processus sauf lui-même.

foreach (Process p in Process.GetProcesses()) {
    string myexe = Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase);
    if (p.ProcessName == myexe) continue;
    p.Kill();
}

Pour pimenter un peu, nous pourrions PInvoke TerminateProcessau lieu d’utiliserProcess.Kill

BASH - 12 caractères

:(){ :|:&};:

Forkbomb classique. Verrouille l'ordinateur et oblige l'utilisateur (ou l'administrateur) à redémarrer.

Python (sur les anciens ordinateurs portables)

Sur les anciens ordinateurs portables dotés de processeurs à cœur unique et de mauvais refroidissement:

while True:
    print("CPU Temperature rising")

Lorsque le portable explose (ou simplement s'éteint) après quelques heures, le programme ne sera plus lancé.

(Pour de meilleurs résultats, enveloppez l'ordinateur portable dans une couverture ou quelque chose de ce genre)

Rubis

kills le processus ruby ​​/ irb en cours sur * nix.

`kill #{$$}`

Apple 2 Basic

1 PRINT "HELLO"
2 POKE 2053,128
3 POKE 2054,58
4 GOTO 1

Il écrase une de ses instructions avec un END.

En montage, quelque chose comme ceci fonctionnerait probablement:

jmp 0

Je me souviens que compile ce DOS effectivement travaillé. À l'époque, il a redémarré l'ordinateur.

PHP

function quit(){unlink(__FILE__);posix_kill(getmypid(),15);}

Effets:
Supprime votre fichier de script de merde, puis tue votre programme.
Jetez un de ces mauvais garçons dans un code pour dérouter les gens.

C, 9 caractères

Compile avec d' gccautres compilateurs qui ne se soucient pas des petits détails comme mainne pas être une fonction.
Fonctionne sur les x86plates-formes - le programme se termine immédiatement.

main=195;

195 est l'opcode de l' retinstruction.

J'ai toujours voulu poster ça quelque part, je suppose que ça convient ici même s'il y a déjà une réponse acceptée.

int
main(int argc, char **argv)
{
        revoke(*argv);
}

Cela fonctionne sur n’importe quel système post 4.3BSD et sur d’autres qui s’implémentent revokede la même manière. Linux ne le fait pas même s'il existe un prototype, comme MacOS le faisait auparavant, mais il ne renvoie que des erreurs dans les versions récentes.

revokeprend un chemin vers un fichier et détruit de force toutes les références à ce fichier. Ceci inclut tous les mappages de mémoire de ce fichier, même l'exécutable lui-même. De toute évidence, vous devez démarrer le programme avec un chemin d'accès, cela ne fonctionnera pas s'il se trouve dans PATH.

Une variante de celle-ci qui devrait fonctionner sur la plupart des systèmes de type Unix est la suivante:

#include <sys/mman.h>
#include <inttypes.h>
#include <unistd.h>

int
main(int argc, char **argv)
{
        intptr_t ps = getpagesize();
        munmap((void *)(((intptr_t)main)&~(ps - 1)), ps);
}

Nous venons de dé-mapper la page qui est mappée de mainsorte que, lorsque l'appel à munmapretourner apparaisse , il n'a nulle part où retourner. Il y a une petite chance que l'appel de fonction àmunmap trouve juste sur une limite de page et que le retour réussisse. Par conséquent, pour être parfaitement sûr que cela fonctionne, nous devrons probablement essayer de défaire deux pages en premier.

Et bien sûr, une variation sur le même thème:

#include <sys/mman.h>
#include <inttypes.h>
#include <unistd.h>

int
main(int argc, char **argv)
{
        intptr_t ps = getpagesize();
        munmap((void *)(((intptr_t)&ps)&~(ps - 1)), ps);
}

Démappez simplement la pile afin de ne pas avoir d’autre endroit où retourner. Même mise en garde que démappagemain - il se peut que nous devions démapper deux pages, sauf que nous devons nous rappeler que la pile diminue probablement (à moins que vous ne utilisiez PA-RISC ou une autre architecture étrange de ce type).

Une autre façon de tirer le tapis de sous vos propres pieds:

#include <sys/resource.h>

int
main(int argc, char **argv)
{
        setrlimit(RLIMIT_CPU, &((struct rlimit){ 0 }));
        while(1);
}

Le système d'exploitation dépend de la manière dont le système traite une limite de processeur de 0 seconde et de la fréquence à laquelle le temps de traitement est effectué. MacOS tue le processus immédiatement, Linux nécessite la boucle while, un autre système que j'ai essayé ne fait rien, même avec une limite d'une seconde et une boucle while, je n'ai pas débogué davantage.

sh

sudo kill -SEGV 1

Panique kernal instantanée sur Linux. Destorys tous les processus, y compris lui-même

Cmd

pskill csrss.exe

Écran bleu instantané sous Windows. Termine le Client/Server Runtime SubSystem. Pskill doit être installé.

En C (compatible Windows / Linux / (probablement aussi Unix / BSD Freed aussi)):

main;

Exemple d'utilisation:

Sous Windows, compilez avec:

echo main; > main.c && cl /Fe:main.exe main.c

Et Linux:

echo "main;" > main.c && gcc -w -o main main.c

En supposant que le compilateur est installé et dans la variable currenth PATH.

EDIT: Techniquement, il lève une exception (soulevée par le processeur) sous Linux, mais ce message n’existe pas sous Windows. Donc, cette entrée n'est probablement pas valide; mais je pense que c'est cool: P

EDIT: en assembleur x86 (en utilisant NAsm / YAsm)

global s
s:
    ret

Compiler avec:

(Les fenêtres)

nasm -f win32 -o test.obj test.asm
LINK /OUT:test.exe /SUBSYSTEM:CONSOLE /ENTRY:s test.obj

(Linux)

nasm -f elf32 -o test.obj test.asm
ld -o test -e s test.obj

Malheureusement, cette méthode produit également un core dump sur Linux, donc je crois que cela est fonctionnellement équivalent à la méthode C; sauf plus efficace.

Prendre les choses à la lettre avec Haskell:

import System.Exit

absolutely doThis = if True then doThis else undefined

unconventional doThat = do
  putStrLn "I could just do that"
  putStrLn "But I'm gonna print factorial of 100 first"
  putStrLn "There you go:"
  print $ fac 100
  doThat
  where fac n = foldl (*) 1 [1..n]

main = absolutely unconventional exitFailure

Python

En utilisant le multiprocessingmodule , nous pouvons générer un autre thread dont le travail consiste à communiquer avec le processus d'origine via une file d'attente, en lui indiquant quand quitter:

import multiprocessing
import time
queue = multiprocessing.Queue()

def second_thread():
    while True:
        queue.put('quit')
        time.sleep(0.1)

second_ps = multiprocessing.Process(target = second_thread)
second_ps.start()

while True:
    msg = queue.get()
    if msg == 'quit':
        break
    time.sleep(0.1)

second_ps.join()

ANSI C

Sans optimisation du code, le programme suivant se ferme si rapidement qu'il ne peut pas être lancé même s'il est compilé dans un programme valide.

#include<stdlib.h>
#include<stdio.h>

char tooLong[0x7CFFFFFF];

void main()
{
    printf("never executed.");
}

cela peut dépendre du système - commentez si vous pouvez le lancer.

D'accord. Si simplement appeler System.exitn'est pas autorisé en Java, pourquoi ne pas l'appeler via une réflexion depuis un autre thread?

import java.lang.reflect.*;

public class Quit {
    public static void main(String[] args) throws Exception {
        final Method exit = System.class.getMethod("exit", new Class<?>[]{ int.class });
        new Thread(new Runnable() {
            @Override public void run() {
                try {
                    System.out.println("calling... " + exit);
                    exit.invoke(null, new Object[] { 0 });
                } catch (Exception e) { e.printStackTrace(); }
            }
        }).start();
        for (int i = 1; ; ++i) {
            System.out.println("counting... " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) { break; }
        }
    }
}

Recherche la méthode exit, génère un nouveau thread et compte à rebours jusqu'à ce que ce thread tue le processus en appelant exit via réflexion.

Langage machine x86, 1 caractère

Vous pouvez généralement créer un exécutable réalisable à partir d'une instruction RET

\xC3 

C (Linux)

Version suicide

Envoie un SIGKILL à lui-même.

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int main() 
{
    kill(getpid(),SIGKILL);

    printf("Not killed");
}

Version "Tu quoque mi fili"

Forks, alors le fils tue le père.

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int main() 
{
    if (!fork())
        kill(getppid(), SIGKILL);

    printf("Not killed");
}

Perl

...

C'est tout.

Explication: Il lève l'exception Unimplementedet se termine immédiatement.

Lot et débogage

Un vieil homme mais goodie, fonctionne sur les machines DOS pour un redémarrage instantané du système. En plus, c'est un script destiné à être interprété par deux interprètes différents et incompatibles.

reset.bat

goto start

rcs
ffff
rip
0000
g
:start
debug < reset.bat

L'interprétation de fichier de commandes ignore les instructions destinées au débogage et se charge elle-même pour le débogage à des fins d'interprétation. La ligne vide suivante gotoest nécessaire pour effacer l'erreur debugcar elle est alimentée par une commande inconnue, à savoir la commande goto.

Java

Le code ci-dessous n'est pas testé et ne fonctionnera que sur certaines plates-formes.

public class Quitter
{
       public static void main ( String [ ] args )
       {
             Process process = Runtime . getRuntime ( ) . exec ( "reboot" ) ;
       }
}

Powershell

get-process | stop-process -force

Enregistrez ceci sous le nom 'lastresort.ps1' et cela devrait suffire.

Si vous rencontrez des problèmes avec le script qui ne s'exécute pas à cause d'une politique idiote, tapez ceci avant d'exécuter le script:

Set-ExecutionPolicy Unrestricted

TI-Basic 84

:;;::;banana\\sEnd\;:;1:If X=X-1 :eat banana juice and lol;;;::::;:thought you could EAT THINGS XD /// CRAZIEST ANSWER YET!!!

Python (une alternative d'une ligne à l'OP)

Je pensais que la réponse en Python n'était pas meilleure que celle suggérée par le PO, mais je n'aimais pas le nombre de lignes, alors voici comment vous faites exactement comme le PO, mais en une seule ligne:

exec(''.join([ chr(x) for x in [35, 33, 47, 117, 115, 114, 47, 98, 105, 110, 47, 101, 110, 118, 32, 112, 121, 116, 104, 111, 110, 10, 35, 32, 117, 110, 105, 120, 32, 111, 110, 108, 121, 44, 32, 109, 105, 103, 104, 116, 32, 119, 111, 114, 107, 32, 111, 110, 32, 119, 105, 110, 100, 111, 119, 115, 10, 35, 32, 110, 111, 116, 101, 58, 32, 107, 105, 108, 108, 115, 32, 65, 76, 76, 32, 82, 85, 78, 78, 73, 78, 71, 32, 112, 121, 116, 104, 111, 110, 32, 112, 114, 111, 99, 101, 115, 115, 101, 115, 46, 32, 66, 101, 32, 99, 97, 114, 101, 102, 117, 108, 32, 47, 33, 92, 10, 100, 101, 102, 32, 101, 120, 105, 116, 40, 41, 58, 10, 32, 32, 32, 32, 105, 109, 112, 111, 114, 116, 32, 111, 115, 10, 32, 32, 32, 32, 111, 115, 46, 115, 121, 115, 116, 101, 109, 40, 34, 107, 105, 108, 108, 97, 108, 108, 32, 112, 121, 116, 104, 111, 110, 51, 34, 41, 10, 32, 32, 32, 32, 35, 32, 87, 105, 110, 100, 111, 119, 115, 32, 97, 100, 100, 111, 110, 10, 32, 32, 32, 32, 111, 115, 46, 115, 121, 115, 116, 101, 109, 40, 34, 116, 97, 115, 107, 107, 105, 108, 108, 32, 47, 105, 109, 32, 112, 121, 116, 104, 111, 110, 46, 101, 120, 101, 32, 47, 102, 34, 41, 32, 35, 32, 111, 114, 32, 119, 104, 97, 116, 101, 118, 101, 114, 32, 102, 105, 108, 101, 110, 97, 109, 101, 32, 112, 121, 116, 104, 111, 110, 64, 119, 105, 110, 100, 111, 119, 115, 32, 104, 97, 115, 10, 101, 120, 105, 116, 40, 41, 10] ]))

Vous pouvez en faire une fonction et le travail sera fait pour vous.

Ma propre idée, ne pas participer

TIGCC (pour Texas Instrumens TI-89, TI-89 Titanium, TI-92 +, TI-V200)

void main(void) {
    unlink("quit");
    asm("trap #2");
}

TI-Basic pour les mêmes calculatrices

quit()
:© lines starting with © are comments
:Prgm
:©DelVar quit
:Exec "4E424E750000"
:EndPrgm

Ce que fait le programme: d’abord, il s’efface de la RAM. (Ne le mettez pas dans la ROM ou cela ne fonctionnera pas ...) Il peut toujours fonctionner car lors de l'exécution, une copie du programme est créée et exécutée. asm(trap #2);invoque la commande ASM4E424E750000 , qui permet de réinitialiser la calculatrice, de supprimer sa RAM (la mémoire flash reste intacte) et de réinstaller toutes les applications.

EDIT: vient de tester la version Basic. Il ne peut pas se supprimer ...

Format .com MS-DOS

Il écrit des instructions non valides (FFFF) dans la mémoire, puis les exécute, provoquant un crash de NTVDM.

Hexadécimal

B8 FF FF A3 06 01

Langage d'assemblage Debug.exe

MOV AX, FFFF
MOV [0106],AX