Desafío:

En el lenguaje de programación que elija, apague la máquina en la que se ejecutó su código.

Reglas

• No se apaga por agotamiento de recursos (por ejemplo: forkbomb para forzar el apagado)
• Si lo desea, puede escribir código que solo funcione en un entorno / SO específico.
• Las lagunas estándar están prohibidas

Este es el código de golf , por lo tanto, gana la menor cantidad de bytes.

Ensamblaje (x86 / x64, Linux, as) , 22 21 19 bytes

mov  $0x58,       %al  # 2 bytes: b0 58
mov  $0xfee1dead, %ebx # 5 bytes: bb ad de e1 fe
mov  $0x28121969, %ecx # 5 bytes: b9 69 19 12 28
mov  $0x4321fedc, %edx # 5 bytes: ba dc fe 21 43
int  $0x80             # 2 bytes: cd 80

Debe ejecutarse como root.

Esto es equivalente a presionar el botón de encendido y no es una forma segura de apagar su PC. Asegúrese de cerrar todas las aplicaciones abiertas y ejecutar syncpara vaciar todos los búferes del sistema de archivos antes de ejecutar este programa, para al menos minimizar el riesgo de corrupción de archivos.

Prueba de funcionamiento

$ as -o poweroff.o poweroff.s
$ ld -o poweroff   poweroff.o
ld: warning: cannot find entry symbol _start; defaulting to 0000000000400078
$ sudo sh -c 'sync && ./poweroff'
root's password:

Seguido por la oscuridad.

Cómo funciona

int $0x80invoca una interrupción de software. Funciona tanto en x86 como en x64, pero ha quedado en desuso durante más de una década y no debe usarse en el código de producción. el código x64 debería usar syscallen su lugar. x86 debería usar sysenter, pero es demasiado engorroso para el golf de código.

La acción resultante de la llamada al sistema depende de los registros EAX - EDX, ESI y EDI. La Referencia de llamadas al sistema Linux muestra todas las llamadas al sistema que están disponibles a través de int $0x80.

Cuando EAX mantiene 0x58 (88) , se llama reiniciar , que también se puede usar para apagar, poner en suspensión o hibernar la computadora, así como para cambiar los núcleos y deshabilitar o habilitar la combinación de teclas Ctrl - Alt - Supr .

Al comienzo del programa, y ​​compilando con aso gcc -nostdlib, podemos asegurarnos de que estamos realmente al comienzo del programa, la mayoría de los registros se establecen en 0 . Esto incluye EAX, por lo que podemos usarlo mov $0x58, %alpara configurar los 8 bits inferiores de EAX en 0x58 , configurando así EAX en 0x58 . Esto ahorra dos bytes sobre xor %eax, %eaxla puesta a cero manual del registro con y uno más sobre el sencillo mov $0x58, %eaxque codifica 0x58 en 32 bits.

Los primeros dos argumentos para reiniciar son números mágicos, presumiblemente para evitar reinicios accidentales, y se leen de los registros EBX y ECX. A menos que estos números sean iguales a ciertas constantes, reiniciar se niega a realizar cualquier acción.

• El primer número mágico debe ser igual a 0xfee1dead ( sentirse muerto ), probablemente refiriéndose a la desconexión / muerte de la PC.

• El segundo número mágico puede ser igual a cuatro constantes diferentes, aunque los últimos tres no funcionaron en versiones antiguas de Linux. Todos ellos parecen referirse al encendido / nacimiento posterior de la PC.

  • 0x28121969 representa el cumpleaños de Linus Torvalds (28 de diciembre de 1969).

  • 0x05121996 representa el cumpleaños de Patricia Torvalds (5 de diciembre de 1996).

  • 0x16041998 representa el cumpleaños de Daniela Torvalds (16 de abril de 1998).

  • 0x20112000 representa el cumpleaños de Celeste Torvalds (20 de noviembre de 2000).

  Patricia, Daniela y Celeste Torvalds son las tres hijas de Linus Torvalds.

• El registro EDX selecciona el tipo de "reinicio" que queremos. 0x4321fedc es RB_POWER_OFF , apaga la PC y la apaga.

• Finalmente, el valor del registro ESI se ignora para RB_POWER_OFF ; el reinicio ignora por completo el valor del registro EDI .

Versión alternativa, solo x64, 19 bytes

En x64, podemos usar una llamada al sistema adecuada para el mismo recuento de bytes.

mov     $0xa9,       %al  # 2 bytes: b0 a9
mov     $0xfee1dead, %edi # 5 bytes: bf ad de e1 fe
mov     $0x28121969, %esi # 5 bytes: be 69 19 12 28
mov     $0x4321fedc, %edx # 5 bytes: ba dc fe 21 43
syscall                   # 2 bytes: 0f 05

Las únicas diferencias radican en la instrucción ( syscallvs int $0x80), el valor de __NR_REBOOT ( 0xa9 vs 0x58 ) y los registros involucrados.

PowerShell, 13 bytes

Stop-Computer

Bastante autoexplicativo? No funciona en el núcleo de PowerShell, por lo que no funcionará en PowerShell para Linux / MacOS (ya lo probé en TIO :-D).

Envío de basura extra, 12 bytes

gcm s*r|iex

En mis pruebas, esto funciona en Windows 2003 con PowerShell 2.0. No funcionará en la mayoría de las versiones más nuevas, y puede que no funcione dependiendo de qué módulos estén instalados. ¡Es bastante terrible!

¡Esto busca en la lista de comandos cualquiera con el patrón s*ry luego los ejecuta a todos! Para ser claros, esto es peligroso, ¡no hagas esto!

El truco, por supuesto, es obtener una lista de comandos que no tienen parámetros obligatorios, de lo contrario, PowerShell solicitará un valor.

En mi máquina 2003, los 3 comandos que devuelve son:

CommandType     Name                                                Definition                                         
-----------     ----                                                ----------                                         
Application     scrnsave.scr                                        C:\WINDOWS\system32\scrnsave.scr                   
Application     ssmarque.scr                                        C:\WINDOWS\system32\ssmarque.scr                   
Cmdlet          Stop-Computer                                       Stop-Computer [[-ComputerName] <String[]>] [[-Cr...

Sí, inicia el protector de pantalla de marquesina, pero no, no espera a que se complete antes de iniciarse Stop-Computer.

Este enfoque puede funcionar en máquinas más nuevas, nuevamente dependiendo de qué módulos estén instalados, pero lo mejor que pude hacer en Windows 2012 y 2016 fue 14 bytes :

gcm sto*er|iex

(y sí, claro, el envío de winbatch funcionará en PowerShell y es más corto, pero ... eso no es divertido)

Lote, 10 bytes.

En Windows, esto sería suficiente.

shutdown/s

Esto configurará un apagado en un minuto.

Alternativamente, como señala @flashbang:

shutdown/p

Esto apaga la computadora de inmediato.

Código de máquina x86, Lenovo Z510, DOS COM o Bootloader, 7 bytes

BITS 16

mov ax, (1 << 13) | (7 << 10)
mov dx, 1804h
out dx, ax

Ensamblado en B8 00 3C BA 04 18 EF

Estoy explotando " Se le permite escribir código que solo funciona en un entorno / SO específico, si lo desea " al máximo nivel: esto solo funcionará en Lenovo Z510 ¹ .

Esto escribe SLP_TYPa << 10 | SLP_ENen el PM1a_CNTregistro ACPI, volqué estos valores de las tablas ACPI hace meses para obtener una respuesta sobre el apagado (donde doy un poco de contexto al código anterior).

Esto se puede ejecutar en DOS como COM (simplemente escriba los datos binarios en un archivo y cambie la extensión a "com") o como un gestor de arranque.
Para este último, escriba la firma estándar y tenga cuidado con los problemas con el firmware moderno .

¹ No es estrictamente cierto, cualquier sistema que tenga la misma configuración ACPI también se apagará.

Shell GRUB , 4 bytes

Golfed

halt

Comando: detener --no-apm

El comando detiene la computadora. Si se especifica la opción --no-apm, no se realiza ninguna llamada APM BIOS. De lo contrario, la computadora se apaga usando APM.

Prima

Aquí está una prueba de que shell de GRUB es de hecho Tur n ing-completa (ver comentarios):

Código de máquina 65C02, 1 byte

Instrucción STP (0xDB):

STP detiene la entrada del reloj del 65C02, apagando efectivamente el 65C02 hasta que se produce un reinicio del hardware (es decir, el pin RES baja). Esto pone al 65C02 en un estado de baja potencia. Esto es útil para aplicaciones (circuitos) que requieren bajo consumo de energía, pero STP rara vez se ve de otra manera.

(Fuente: http://www.6502.org/tutorials/65c02opcodes.html )

volcado xxd:

00000000: db                                       .

Matlab, 21 bytes

system('shutdown -s')

No lo he intentado (cerrar todos los programas para reiniciar a mitad del día no es realmente tentador), pero debería funcionar. . Esto funciona...

Agregaré una breve explicación más tarde, mi computadora portátil está actualmente apagada.

MATLAB, 11 bytes

!shutdown/p

Algo similar al enfoque de Stewie Griffin . Sin embargo, MATLAB tiene formas mucho más cortas de invocar comandos del sistema; En este caso, !se utiliza. Windows no necesita .exenombres de comandos, por lo que también se omite. La /opción aún es compatible (estoy ejecutando Windows 10) y niega la necesidad de espacio. Las alternativas son:

system shutdown/p % 17 bytes; uses so-called 'command' syntax.
dos shutdown/p    % 14 bytes; the 'dos' command can be used just as well.

SmileBASIC, 14 11 6 bytes

OPTION

Activa un bloqueo que hace que el 3DS se reinicie. Espero que esto cuente.

Funciona en la versión más reciente.

Bash, 7 6 bytes

init 0

Suponiendo que el programa se ejecute como root.

Java, 101 98 62 42 bytes

()->{Runtime.getRuntime().exec("init 0");}

Como señaló @Snowman, la pregunta no especificaba si se necesitaba un programa completo, por lo que esto aún debería ser aceptable.

Python 2, 29 bytes

import os;os.system('init 0')

Funciona en sistemas Linux y necesita privilegios de root.

Para Windows, 33 bytes.

import os;os.system('shutdown/p')

Este podría ser el código menos interesante o útil que haya escrito.

Commodore 64, 11 bytes

0 sys64738

Esto es del indicador BÁSICO. O...

Commodore 64, ensamblaje 6502, 3 bytes (ensamblado), 16 bytes (fuente)

*=8000
JMP $FCE2

TI-Nspire CX CAS, 3 bytes

" "+" "

sumando dos cadenas vacías.

En una versión anterior de la calculadora, esto bloqueará el dispositivo y provocará que se reinicie (no hay forma de apagar un dispositivo sin reiniciarlo, aparte de las combinaciones de botones físicos).

Video de Adriweb

C ++, 51 40 bytes

-11 bytes gracias a Ingve !

#include<os>
int main(){OS::shutdown();}

Solo funciona en IncludeOS (v0.10.0-rc.1)

Prueba:

$ pwd
/home/simon/IncludeOS/examples/demo_service

$ cat service.cpp
#include<os>
int main(){OS::shutdown();}

$ mkdir build && cd build && cmake .. && make && cd ..
[...]

$ boot build/IncludeOS_example
[...]
================================================================================
================================================================================
 IncludeOS v0.10.0-rc.1-9-g151a2b9
 +--> Running [ IncludeOS minimal example ]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$

AppleScript, 30 bytes

tell app "Finder" to shut down

Hace exactamente lo que dice: le dice a Finder que apague la computadora.

AutoHotkey, 11 10 bytes

Salvó un byte gracias a Gurupad Mamadapur

Shutdown,9

AHK admite un comando de apagado de forma predeterminada. El 9es una bandera, que consiste en Shutdown=1+ PowerDown=8.

Código de máquina (x86, cargador de arranque) 18 bytes

b8 01 53 33 db cd 15 b8 07 53 bb 01 00 b9 03 00 cd 15

Desmontaje

mov ax, 0x5301 ; connect to real-mode APM services
xor bx, bx     ; device id 0 - APM BIOS
int 0x15       ; call APM
mov ax, 0x5307 ; set power state
mov bx, 0x0001 ; on all devices
mov cx, 0x0003 ; to Off
int 0x15       ; call APM

Puede probarlo en el depurador de Bochs con los siguientes comandos (después de iniciar la simulación, tener configurada alguna unidad de disco):

pb 0x7c00
c
setpmem 0x7c00 4 0x335301b8
setpmem 0x7c04 4 0xb815cddb
setpmem 0x7c08 4 0x01bb5307
setpmem 0x7c0c 4 0x0003b900
setpmem 0x7c10 2 0x15cd
c

Este mismo código de máquina también funcionará como un ejecutable de DOS ( *.COM).

C #, 79 54 53 bytes

Esto funciona en Windows.

79 bytes :

class _{static void Main(){System.Diagnostics.Process.Start("shutdown","/s");}}

53 bytes , gracias a TheLethalCoder:

_=>System.Diagnostics.Process.Start("shutdown","/s");

AutoIt, 11 bytes

Shutdown(1)

La función de apagado obtiene la combinación de los siguientes códigos

0 = Logoff
1 = Shutdown
2 = Reboot
4 = Force
8 = Power down
16= Force if hung
32= Standby
64= Hibernate

Para apagar y apagar, por ejemplo, el código sería 9 (apagado + apagado = 1 + 8 = 9).

Windows: NativeAPI, 212 bytes

Ok, esta no es realmente la versión más corta. Pero tal vez sea interesante para algunos. Esto no se ejecutará en el subsistema Win32. Sin embargo, se ejecutará cuando se ejecute dentro del contexto de la API nativa (como lo hace autochk.exe)

Código

#define WIN32_NO_STATUS
#include <windef.h>
#include <winnt.h>
#include <ntndk.h>
NTSTATUS main() {
RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE,TRUE,FALSE,NULL);
return ZwShutdownSystem(ShutdownPowerOff);
}

Construir

Para construir esto, use la build.exeherramienta WinDDK (con un sourcearchivo apropiado para NMAKE)

O use estos comandos para compilar y vincular:

cl /Gd /D_X86_ /showIncludes /I%DDK_INC_PATH% /I%CRT_INC_PATH% /c main.c
link /verbose /nodefaultlib /subsystem:native /machine:X86 /entry:NtProcessStartup@4 C:\WinDDK\7600.16385.1\lib\win7\i386\nt.lib C:\WinDDK\7600.16385.1\lib\win7\i386\ntdllp.lib C:\WinDDK\7600.16385.1\lib\win7\i386\BufferOverflow.lib .\main.obj 

Nota: Esto generará un ejecutable nativo x86. Cambie los bits apropiados si desea construir esto para una arquitectura diferente.

Prueba

Para probar un ejecutable nativo, debe ejecutarlo antes de cargar el subsistema win32. Una forma común de hacerlo es agregar el ejecutable en la siguiente clave de registro:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\BootExecute

Advertencia

Sin embargo, si hace esto, debe tener una opción para editar la sección de registro del sistema operativo de destino desde otro sistema operativo. ¡Ya no podrás iniciar el sistema operativo de destino!

¡Lo hice en una máquina virtual donde podría volver fácilmente a una instantánea anterior!

Groovy, 23 bytes

'shutdown /p'.execute()

La mayoría de los shells de Linux, 15 bytes

# echo o>/p*/*ger

Podría tener 11 bytes de longitud, si está en el /procdirectorio:

# echo o>*ger

Esto es muy sencillo (no tiene efectos secundarios, como desmontar sistemas de archivos o matar procesos) y bastante brutal.

Shell de Android, 9 bytes

reboot -p

AppleScript, 44 bytes

tell application "Finder"
shut down
end tell

No sé cómo funciona la sintaxis de AppleScript ni nada, así que si alguien sabe cómo acortar esto, por favor dígalo.

Además, estoy haciendo esto en mi teléfono en la escuela ("pirateo"), por lo que no puedo probarlo.

Con 14 bytes menos (gracias a kindall) puedes decir

tell app "Finder" to shut down

J, 14 bytes

2!:0'poweroff'

Funciona en sistemas Linux. 2!:0ejecuta la cadena en /bin/sh.

Clojure, 40 39 bytes

(.exec(Runtime/getRuntime)"shutdown/s")

-1 byte cambiando la bandera de -sa /s, lo que me permitió deshacerme del espacio.

Básicamente la respuesta de Java.

Probar esto fue divertido. Windows decidió hacer una actualización de firmware en mi Surface en el momento en que se cerró. Por supuesto.

(defn shutdown []
  (.exec (Runtime/getRuntime) "shutdown -s"))

Node.js, 39 bytes

Linux

require('child_process').exec('init 0')

AHK, 19 15 bytes

Run,Shutdown -s

Funciona solo en ventanas.

C ++, 48 47 (Windows) 46 45 (Linux) bytes

Eliminado 1 byte gracias a Snowman

#include<cstdlib>
main(){system("shutdown/p");}

Esto debería apagar el sistema para Windows

#include<cstdlib>
main(){system("poweroff");}

Esto debería apagar el sistema para Linux