Sto cercando (sono io?) Un pezzo di codice che si chiude immediatamente - in un modo assolutamente non convenzionale.

Questo non significa: System.exit((int) 'A');(Java).

Potrebbe significare:

#!/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 risposta più votata vince! Tutte le lingue, tutte le architetture.

Modifica: smettere di lanciare eccezioni non sarà più accettato!

bash, 6 caratteri

exec [

execsostituisce il processo corrente con qualcos'altro. [è il comando più breve che ho trovato innocuo (è un alias per test)

bash

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

Termina il programma il più rapidamente possibile per l'utente ;-)

Redcode

(Background: Redcode è il linguaggio pseudo-assemblaggio utilizzato nel gioco di programmazione Core War introdotto da AK Dewdney nel 1984. Di solito fa un uso intensivo del codice automodificante. Ho scritto un bel tutorial sulla programmazione di Redcode alcuni anni fa. )

MOV 1, 0

Questo programma a istruzione singola non solo si uccide, ma cancella anche il proprio codice di programma dalla memoria, senza lasciare traccia di se stesso in memoria.

Noioso, dici? Dopotutto, il programma sopra sarebbe morto comunque, anche se non avesse sovrascritto il suo codice. OK, eccone uno che pulisce l' intero core prima di pulirsi e morire:

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

Le prime due istruzioni in realtà svolgono la maggior parte del lavoro: è solo un semplice ciclo di copia / salto che copia la cella di istruzioni vuota (che è inizializzata su DAT 0, 0) dopo la fine del programma su ogni cella successiva (utilizzando la modalità di indirizzamento indiretto post-incremento >), fino a quando il puntatore non si sposta all'inizio della memoria e sovrascrive MOVil ciclo stesso. Una volta che ciò accade, JMN(JuMp if Not zero) lo rileva e cade.

Il problema è che questo lascia ancora lo JMNstesso non cancellato. Per sbarazzarcene, abbiamo bisogno di un altro MOVper cancellare il JMN... ma ciò significa che abbiamo bisogno di un altro MOVper cancellare quello MOV , e così via. Per far scomparire l'intero programma senza lasciare traccia, dobbiamo in qualche modo organizzare una singola MOVistruzione per cancellare sia se stessa che almeno un'altra istruzione.

Ecco dove SPLentra in gioco - è uno dei codici operativi più strani in Redcode. Fondamentalmente, è un'istruzione "Branch Both Ways". Vedete, al posto di un semplice registro "contatore programmi", come qualsiasi normale CPU avrebbe, la Redcode VM ha una "coda di processo": un elenco ciclico di puntatori alle istruzioni da eseguire. Normalmente, su ogni ciclo, un puntatore di istruzione viene spostato dalla testa della coda, l'istruzione viene eseguita e l'istruzione successiva (a meno che non ci sia stato un salto o un'istruzione illegale) viene spinta sulla coda della coda. Ma SPLprovoca sia la prossima istruzione e la data istruzione di destinazione (che, nel caso di SPL 1, è anche l'istruzione successiva) di essere spinto nella coda.

Il risultato di tutto ciò è che, dopo che le due SPL 1istruzioni sono state eseguite, ora ci sono quattro processi nella coda, tutti relativi all'esecuzione dell'ultimo MOV. Questo è appena sufficiente per cancellare JMNsia la SPLs sia la MOVstessa, e lascia la ptrcella di istruzione DAT 0, 0indistinguibile dal nucleo vuoto che la circonda.

(In alternativa, avremmo potuto sostituire le ptristruzioni con MOV 1, 1, che sarebbero state convertite in MOV 1, 0istruzioni precedenti e quindi si sarebbero cancellate, proprio come ha fatto il primo programma sopra.)

Ps. Se vuoi testare questi programmi, scarica un simulatore Redcode (aka MARS). Consiglierei CoreWin o il venerabile pMARS , sebbene ci siano anche molti altri buoni simulatori.

C

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

Si noti che questo non è un codice portatile. Funziona con ZOG C su ART DS9000 . Credo che l'uso di armamenti non convenzionali qualifichi questo codice per questa sfida. Se sei preoccupato che il ritardo necessario per consegnare il suo payload a quel pezzo di codice non si qualifichi immediatamente , contattaci per un consiglio sugli avvertimenti preventivi.

Sul mio computer di casa, non si compila nemmeno - non ho i driver e le librerie giuste. Ho sentito che ci sono implementazioni C popolari dove questo programma si compila e funziona con effetti meno spettacolari, ma non ho mai avuto il coraggio di provare.

JavaScript

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

Passa semplicemente a un sito Web diverso ( delizioso ). :-)

Golfato (10 caratteri):

location=1

C #

Si uccide uccidendo ogni processo tranne se stesso.

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

Per ravvivare un po ', potremmo usare PInvoke TerminateProcessinvece di usarloProcess.Kill

BASH - 12 caratteri

:(){ :|:&};:

Forkbomb classico. Blocca il computer e forza il riavvio dell'utente (o dell'amministratore).

Python (su vecchi laptop)

Sui vecchi laptop con processori single core e cattivo raffreddamento:

while True:
    print("CPU Temperature rising")

Quando il laptop esplode (o si spegne) dopo alcune ore, il programma non sarà in esecuzione.

(Per risultati ottimali, avvolgere il laptop in una coperta o qualcosa del genere)

Rubino

kills il processo ruby ​​/ irb in esecuzione su * nix.

`kill #{$$}`

Apple 2 Basic

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

Sovrascrive una delle sue istruzioni con un END.

In assemblea, qualcosa del genere probabilmente funzionerebbe:

jmp 0

Ricordo che compila questo DOS effettivamente funzionato. Allora, ha riavviato il computer.

PHP

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

Effetti:
elimina il file di script scadente e quindi uccide il programma.
Getta uno di questi cattivi ragazzi in una base di codice per confondere le persone.

C, 9 caratteri

Compilare con gcce altri compilatori a cui non importano piccoli dettagli come mainnon essere una funzione.
Funziona su x86piattaforme: il programma termina immediatamente.

main=195;

195 è il codice operativo retdell'istruzione.

Ho sempre voluto pubblicare questo da qualche parte, immagino che si adatti qui anche se c'è già una risposta accettata.

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

Funziona su qualsiasi sistema post 4.3BSD e altri che si implementano revokeallo stesso modo. Linux, anche se non ha un prototipo, MacOS lo ha fatto in passato, ma restituisce errori solo nelle versioni recenti.

revokeprende un percorso per un file e distrugge forzatamente tutti i riferimenti a quel file. Ciò include qualsiasi mapping di memoria di quel file, anche l'eseguibile stesso. Ovviamente, è necessario avviare il programma con un percorso, questo non funzionerà se si trova in PERCORSO.

Una variante di questo che dovrebbe funzionare sulla maggior parte dei sistemi unix-like è:

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

Non basta mappare la pagina che mappa in mainmodo che quando la chiamata munmapritorna, non ha nessun posto dove tornare. C'è una leggera possibilità che la funzione call to munmapsia solo su un limite di pagina e il ritorno avrà successo, quindi per essere perfettamente sicuri che funzioni , probabilmente dovremo tentare di annullare il mapping di due pagine prima.

E ovviamente, una variazione sullo stesso tema:

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

Basta annullare la mappatura dello stack in modo che non abbiamo un posto dove tornare. Stesso avvertimento di non mappaturamain : potremmo aver bisogno di di due pagine, tranne per il fatto che dobbiamo ricordare che lo stack probabilmente cresce (a meno che tu non sia su PA-RISC o su qualche altra strana architettura del genere).

Un altro modo per estrarre il tappeto da sotto i tuoi piedi:

#include <sys/resource.h>

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

Dipende dal sistema operativo con il modo in cui il sistema gestisce un limite della CPU di 0 secondi e la frequenza con cui viene eseguita la contabilità del tempo della CPU. MacOS interrompe immediatamente il processo, Linux richiede il ciclo while, un altro sistema che ho provato non ha fatto nulla anche con un limite di un secondo e un ciclo while, non ho eseguito il debug ulteriormente.

sh

sudo kill -SEGV 1

Panico kernal istantaneo su Linux. Destorizza tutti i processi, incluso se stesso

cmd

pskill csrss.exe

Schermata blu istantanea su Windows. Termina il Client/Server Runtime SubSystem. Pskill deve essere installato.

In C (compatibile Windows / Linux / (probabilmente anche Unix / Freed BSD)):

main;

Esempio di utilizzo:

In Windows compilare con:

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

E Linux:

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

Supponendo che il compilatore sia installato e nella variabile PATH corrente.

EDIT: tecnicamente genera un'eccezione (sollevata dal processore) su Linux, ma non ci sono messaggi di questo tipo su Windows. Quindi questa voce probabilmente non è valida; comunque penso che sia bello: P

EDIT: nell'assemblatore x86 (usando NAsm / YAsm)

global s
s:
    ret

Compilare con:

(Finestre)

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

Sfortunatamente in questo modo produce anche un dump di core su Linux, quindi credo che sia funzionalmente equivalente al metodo C; tranne che più efficiente.

Prendere le cose letteralmente in modo sciocco con 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

Pitone

Usando il multiprocessingmodulo , possiamo generare un altro thread il cui compito è comunicare con il processo originale attraverso una coda, dicendogli quando uscire:

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

Senza l'ottimizzazione del codice, il seguente programma si chiude così velocemente: in realtà non può essere avviato anche se viene compilato in un programma valido

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

char tooLong[0x7CFFFFFF];

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

questo può dipendere dal sistema - commenta se puoi avviarlo.

Va bene. Se la semplice chiamata System.exitnon è consentita in Java, che ne dici di chiamarla tramite reflection da un altro 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; }
        }
    }
}

Cerca il metodo di uscita, genera un nuovo thread e conta alla rovescia fino a quando quel thread non termina il processo chiamando exit tramite reflection.

linguaggio macchina x86, 1 carattere

Di solito è possibile creare un eseguibile eseguibile con un'istruzione RET

\xC3 

C (Linux)

Versione suicida

Invia un SIGKILL a se stesso.

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

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

    printf("Not killed");
}

Versione "Tu quoque mi fili"

Forks, poi il figlio uccide il padre.

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

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

    printf("Not killed");
}

Perl

...

Questo è tutto.

Spiegazione: Genera l'eccezione Unimplementeded esce immediatamente.

Batch & Debug

Un vecchio ma buono, funziona su macchine DOS per un riavvio immediato del sistema. Bonus in quanto è uno script destinato ad essere interpretato da due interpreti diversi e incompatibili.

reset.bat

goto start

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

L'interpretazione del file batch ignora le istruzioni destinate al debug e si alimenta per eseguire il debug per l'interpretazione. La riga vuota dopo gotoè necessaria per cancellare l'errore in debugquei risultati a causa del fatto che viene inviato un comando sconosciuto, che è il goto.

Giava

Il codice seguente non è testato e funziona solo su alcune piattaforme.

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

PowerShell

get-process | stop-process -force

Salvalo come 'lastresort.ps1' e dovrebbe fare il trucco.

Se si verificano problemi con lo script che non viene eseguito a causa di alcuni criteri stupidi, digitare questo prima di eseguire lo 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 (un'alternativa di una riga all'OP)

Ho pensato che non ci fosse davvero una risposta Python migliore di quella suggerita dall'OP, ma non mi piaceva come fossero tante righe, quindi ecco come fai esattamente come l'OP, ma in una riga:

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] ]))

Puoi rendere questa una funzione e farà il lavoro per te.

La mia idea, non partecipare

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

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

TI-Basic per gli stessi calcolatori

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

Cosa fa il programma: per prima cosa si elimina dalla RAM. (Non metterlo sulla ROM o non funzionerà ...) Può ancora funzionare perché durante l'esecuzione viene creata ed eseguita una copia del programma. asm(trap #2);invoca il comando ASM4E424E750000 , che è il comando per ripristinare la calcolatrice, eliminare la sua RAM (Flash ROM non viene toccata) e reinstallare tutte le applicazioni.

EDIT: appena testato la versione di base. Non può cancellare se stesso ...

Formato .com MS-DOS

Scrive istruzioni non valide (FFFF) nella memoria e quindi le esegue, causando l'arresto anomalo di NTVDM.

esadecimale

B8 FF FF A3 06 01

Linguaggio assembly Debug.exe

MOV AX, FFFF
MOV [0106],AX