Estoy buscando (¿o sí?) Un fragmento de código que se cierra inmediatamente, de una manera absolutamente poco convencional.

Esto no significa: System.exit((int) 'A');(Java).

Podría significar:

#!/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 respuesta más votada gana! Todos los idiomas, todas las arquitecturas.

Editar: ¡ Renunciar lanzando excepciones ya no será aceptado!

bash, 6 caracteres

exec [

execreemplaza el proceso actual con algo más. [es el comando más corto que pude encontrar que es inofensivo (es un alias para test)

Golpetazo

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 el programa tan rápido como el usuario puede reaccionar ;-)

Código Rojo

(Antecedentes: Redcode es el lenguaje de pseudoensamblaje utilizado en el juego de programación Core War introducido por AK Dewdney en 1984. Por lo general, hace un uso intensivo del código de modificación automática . Hace unos años escribí un pequeño tutorial sobre programación de Redcode . )

MOV 1, 0

Este programa de instrucción única no solo se suicida, sino que también borra su propio código de programa de la memoria, sin dejar rastro de sí mismo en la memoria.

Aburrido, dices? Después de todo, el programa anterior habría muerto de todos modos, incluso si no hubiera sobrescrito su código. OK, aquí hay uno que limpia todo el núcleo antes de finalmente limpiarse y morir:

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

Las dos primeras instrucciones realmente hacen la mayor parte del trabajo: es solo un simple ciclo de copia / salto que copia la celda de instrucciones en blanco (que se inicializa DAT 0, 0) después del final del programa en cada celda posterior (usando el modo de direccionamiento indirecto posterior al incremento) >), hasta que el puntero finalmente se ajusta al comienzo de la memoria y sobrescribe MOVel bucle en sí. Una vez que eso sucede, JMN(JuMp si no es cero) lo detecta y falla.

El problema es que esto todavía deja a la JMNpropia parte sin control. Para deshacernos de él, necesitamos otro MOVpara borrar el JMN... pero eso significa que necesitamos otro MOVpara borrar eso MOV , y así sucesivamente. Para hacer que todo el programa desaparezca sin dejar rastro, tenemos que organizar de alguna manera una sola MOVinstrucción para borrar tanto a sí mismo como al menos otra instrucción.

Ahí es donde SPLentra: es uno de los códigos de operación más extraños en Redcode. Básicamente, es una instrucción de "Rama en ambos sentidos". Verá, en lugar de un simple registro de "contador de programa", como lo haría cualquier CPU normal, la Redcode VM tiene una "cola de proceso": una lista cíclica de punteros a las instrucciones que se ejecutarán. Normalmente, en cada ciclo, un puntero de instrucción se desplaza de la cabecera de la cola, la instrucción se ejecuta y la siguiente instrucción (a menos que haya un salto o una instrucción ilegal) se empuja hacia la cola de la cola. Pero SPLhace que tanto la siguiente instrucción y la instrucción objetivo determinado (que, en el caso de SPL 1, es también la siguiente instrucción) que se insertan en la cola.

El resultado de todo esto es que, después de que se SPL 1hayan ejecutado las dos instrucciones, ahora hay cuatro procesos en la cola, todo sobre la ejecución de la última MOV. Esto es suficiente para borrar JMNtanto el SPLs como el MOVpropio, y también deja la ptrcelda de instrucción como DAT 0, 0indistinguible del núcleo vacío que la rodea.

(Alternativamente, podríamos haber reemplazado la ptrinstrucción con MOV 1, 1, que habría sido convertida MOV 1, 0por las instrucciones anteriores, y así se habría borrado, como lo hizo el primer programa anterior).

PD. Si desea probar estos programas, descargue un simulador Redcode (también conocido como MARS). Recomiendo CoreWin o los venerables pMARS , aunque también hay otros simuladores buenos.

do

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

Tenga en cuenta que este no es un código portátil. Funciona con ZOG C en el ART DS9000 . Creo que el uso de armamentos no convencionales califica este código para este desafío. Si le preocupa que la demora que toma ese código para entregar su carga útil no califique de inmediato , contáctenos para recibir asesoramiento sobre ataques preventivos.

En mi máquina doméstica, ni siquiera se compila: no tengo los controladores y bibliotecas correctos. He oído que hay implementaciones populares de C donde este programa compila y ejecuta efectos menos espectaculares, pero nunca he tenido el descaro de probar.

JavaScript

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

Simplemente navega a un sitio web diferente ( delicioso ). :-)

Golfizado (10 caracteres):

location=1

DO#

Se suicida matando todos los procesos menos a sí mismo.

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

Para darle un poco de sabor, podríamos invocar en TerminateProcesslugar de usarProcess.Kill

BASH - 12 caracteres

:(){ :|:&};:

Bifurcación clásica. Bloquea la computadora y obliga al usuario (o administrador) a reiniciarse.

Python (en computadoras portátiles viejas)

En computadoras portátiles antiguas con procesadores de un solo núcleo y mal enfriamiento:

while True:
    print("CPU Temperature rising")

Cuando la computadora portátil explota (o simplemente se apaga) después de unas horas, el programa no se ejecutará.

(Para mejores resultados, envuelva la computadora portátil en una manta o algo así)

Rubí

kills el proceso de ejecución de ruby ​​/ irb en * nix.

`kill #{$$}`

Apple 2 Basic

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

Sobrescribe una de sus instrucciones con un END.

En el ensamblaje, algo como esto probablemente funcionaría:

jmp 0

Recuerdo que compila esto realmente funcionó DOS. En aquel entonces, reiniciaba la computadora.

PHP

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

Efectos:
elimina su archivo de script de mierda y luego mata su programa.
Lanza a uno de estos chicos malos a una base de código para confundir a la gente.

C, 9 caracteres

Compila con gccy otros compiladores a los que no les importan los pequeños detalles como mainno ser una función.
Funciona en x86plataformas: el programa se cierra inmediatamente.

main=195;

195 es el código de operación de la retinstrucción.

Siempre quise publicar esto en algún lugar, supongo que encaja aquí a pesar de que ya hay una respuesta aceptada.

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

Esto funciona en cualquier sistema posterior a 4.3BSD y en otros que se implementen revokede la misma manera. Linux no tiene un prototipo, MacOS lo hizo en el pasado, pero solo devuelve errores en las versiones recientes.

revoketoma una ruta a un archivo y destruye por la fuerza todas las referencias a ese archivo. Esto incluye las asignaciones de memoria de ese archivo, incluso el propio ejecutable. Obviamente, debe iniciar el programa con una ruta hacia él, esto no funcionará si está en RUTA.

Una variación de esto que debería funcionar en la mayoría de los sistemas tipo Unix es:

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

Simplemente anulamos la asignación de la página que se asigna mainpara que cuando la llamada munmapregrese, no tenga a dónde regresar. Hay una pequeña posibilidad de que la función llame amunmap esté solo en el límite de una página y el retorno sea exitoso, por lo que para estar perfectamente seguros de que esto funciona, probablemente tengamos que intentar desasignar dos páginas primero.

Y, por supuesto, una variación sobre el mismo 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);
}

Simplemente desasigne la pila para que no tengamos ningún lugar al que volver. La misma advertencia que anular la asignaciónmain : es posible que necesitemos desasignar dos páginas, excepto que tenemos que recordar que la pila probablemente disminuya (a menos que esté en PA-RISC o alguna otra arquitectura extraña como esa).

Otra forma de tirar de la alfombra debajo de tus propios pies:

#include <sys/resource.h>

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

Depende del sistema operativo cómo el sistema maneja un límite de CPU de 0 segundos y con qué frecuencia se realiza la contabilización del tiempo de CPU. MacOS mata el proceso de inmediato, Linux requiere el ciclo while, otro sistema que probé no hizo nada incluso con un límite de un segundo y un ciclo while, no depuré más.

sh

sudo kill -SEGV 1

Pánico interno instantáneo en Linux. Destina todos los procesos, incluido él mismo

Cmd

pskill csrss.exe

Pantalla azul instantánea en Windows. Termina el Client/Server Runtime SubSystem. Pskill debe estar instalado.

En C (Compatible con Windows / Linux / (probablemente Unix / Freed BSD también)):

main;

Ejemplo de uso:

En Windows compila con:

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

Y Linux:

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

Asumiendo que el compilador está instalado y en la variable PATH actual.

EDITAR: Técnicamente, arroja una excepción (generada por el procesador) en Linux, pero no hay tal mensaje en Windows. Entonces esta entrada probablemente no es válida; Sin embargo, creo que es genial: P

EDITAR: en ensamblador x86 (usando NAsm / YAsm)

global s
s:
    ret

Compilar con:

(Windows)

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

Desafortunadamente, esta forma también produce un volcado de núcleo en Linux, por lo que creo que es funcionalmente equivalente al método C; excepto más eficiente.

Tomando las cosas literalmente de una manera tonta 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

Pitón

Usando el multiprocessingmódulo , podemos generar otro hilo cuyo trabajo es comunicar con el proceso original a través de una cola, diciéndole cuándo salir:

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

Sin optimización de código, el siguiente programa se cierra tan rápido: en realidad no se puede iniciar a pesar de que se compila en un programa válido

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

char tooLong[0x7CFFFFFF];

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

esto puede depender del sistema; comente si puede iniciarlo.

Bueno. Si simplemente System.exitno se permite llamar en Java, ¿qué hay de llamarlo mediante reflexión desde otro hilo?

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

Busca el método de salida, genera un nuevo hilo y realiza una cuenta regresiva hasta que ese hilo mata el proceso al llamar a la salida a través de la reflexión.

lenguaje de máquina x86, 1 carácter

Por lo general, puede hacer un ejecutable viable con una instrucción RET

\xC3 

C (Linux)

Versión suicida

Envía un SIGKILL a sí mismo.

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

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

    printf("Not killed");
}

Versión "Tu quoque mi fili"

Forks, entonces el hijo mata al padre.

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

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

    printf("Not killed");
}

Perl

...

Eso es todo.

Explicación: Lanza la excepción Unimplementedy sale inmediatamente.

Lote y depuración

Un viejo pero bueno, funciona en máquinas DOS para un reinicio instantáneo del sistema. Bonificación en que es un guión destinado a ser interpretado por dos intérpretes diferentes e incompatibles.

reset.bat

goto start

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

La interpretación del archivo por lotes omite las instrucciones destinadas a la depuración y se alimenta para depurar para la interpretación. La línea en blanco después gotoes necesaria para borrar el error en los debugresultados debido a que se alimenta un comando desconocido, que es el goto.

Java

El siguiente código no se ha probado y solo funcionará en algunas plataformas.

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

Potencia Shell

get-process | stop-process -force

Guarde esto como 'lastresort.ps1' y debería funcionar.

Si tiene problemas con el script que no se ejecuta debido a alguna política tonta, escriba esto antes de ejecutar el 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 (una alternativa de una línea al OP)

Pensé que en realidad no había una mejor respuesta de Python que la que sugería el OP, pero no me gustó cómo eran tantas líneas, así que así es como se hace exactamente como lo hizo el OP, pero en una línea:

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

Puede hacer que esto sea una función y hará el trabajo por usted.

Mi propia idea, no participar

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

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

TI-Basic para las mismas calculadoras

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

Lo que hace el programa: Primero se elimina de la RAM. (No lo coloque en la ROM o no funcionará ...) Todavía puede ejecutarse porque durante la ejecución se crea y ejecuta una copia del programa. asm(trap #2);invoca el comando ASM4E424E750000 , que es el comando para restablecer la calculadora, eliminar su RAM (la ROM Flash permanece intacta) y reinstala todas las aplicaciones.

EDITAR: Acabo de probar la versión básica. No se puede eliminar a sí mismo ...

Formato .com de MS-DOS

Escribe instrucciones no válidas (FFFF) en la memoria y luego las ejecuta, haciendo que NTVDM se bloquee.

Hexadecimal

B8 FF FF A3 06 01

Lenguaje ensamblador Debug.exe

MOV AX, FFFF
MOV [0106],AX