Sfida:

Nel linguaggio di programmazione che preferisci, spegni la macchina su cui è stato eseguito il tuo codice.

Regole

• Nessun arresto per esaurimento delle risorse (ad es. Forkbomb per forzare l'arresto)
• È possibile scrivere codice che funziona solo in un ambiente / sistema operativo specifico, se lo si desidera.
• Sono vietate le scappatoie standard

Questo è code-golf , quindi vince il minor numero di byte!

Assembly (x86 / x64, Linux, as) , 22 21 19 byte

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

Deve essere eseguito come root.

Ciò equivale a premere il pulsante di accensione e non è un modo sicuro per spegnere il PC. Assicurati di chiudere tutte le applicazioni aperte ed eseguire syncper svuotare tutti i buffer del file system prima di eseguire questo programma, per minimizzare almeno il rischio di corruzione dei file.

Prova

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

Seguito dall'oscurità.

Come funziona

int $0x80invoca un interrupt software. Funziona sia su x86 che x64, ma è ormai obsoleto da oltre un decennio e non dovrebbe essere usato nel codice di produzione. syscallinvece dovrebbe usare il codice x64 . x86 dovrebbe usare sysenter, ma è troppo ingombrante per il codice golf.

L'azione risultante dalla syscall dipende dai registri EAX - EDX, ESI ed EDI. Il Linux Reference Syscall mostra tutte le chiamate di sistema che sono disponibili via int $0x80.

Quando EAX contiene 0x58 (88) , viene chiamato il riavvio , che può anche essere utilizzato per spegnere, mettere in sospensione o ibernare il computer, nonché per cambiare kernel e disabilitare o abilitare la combinazione di tasti Ctrl - Alt - Canc .

All'inizio del programma - e compilando con aso gcc -nostdlib, possiamo assicurarci di essere effettivamente all'inizio del programma - la maggior parte dei registri è impostata su 0 . Questo include EAX, quindi possiamo usare mov $0x58, %alper impostare gli 8 bit inferiori di EAX su 0x58 , quindi impostando EAX stesso su 0x58 . Ciò consente di risparmiare due byte sopra l'azzeramento manuale del registro xor %eax, %eaxe un altro sopra il rettilineo mov $0x58, %eaxche codifica 0x58 in 32 bit.

I primi due argomenti da riavviare sono numeri magici, presumibilmente per impedire riavvii accidentali, e vengono letti dai registri EBX ed ECX. A meno che questi numeri non siano uguali a determinate costanti, il riavvio si rifiuta di eseguire qualsiasi azione.

• Il primo numero magico deve essere uguale a 0xfee1dead ( feel dead ), probabilmente riferito allo spegnimento / morte del PC.

• Il secondo numero magico può essere uguale a quattro diverse costanti, sebbene le ultime tre non funzionassero nelle versioni antiche di Linux. Tutti sembrano riferirsi alla successiva accensione / nascita del PC.

  • 0x28121969 rappresenta il compleanno di Linus Torvalds (28 dicembre 1969).

  • 0x05121996 rappresenta il compleanno di Patricia Torvalds (5 dicembre 1996).

  • 0x16041998 rappresenta il compleanno di Daniela Torvalds (16 aprile 1998).

  • 0x20112000 rappresenta il compleanno di Celeste Torvalds (20 novembre 2000).

  Patricia, Daniela e Celeste Torvalds sono le tre figlie di Linus Torvalds.

• Il registro EDX seleziona il tipo di "riavvio" desiderato. 0x4321fedc è RB_POWER_OFF , spegnendo il PC e spegnendolo.

• Infine, il valore del registro ESI viene ignorato per RB_POWER_OFF ; il valore del registro EDI viene ignorato interamente dal riavvio .

Versione alternativa, solo x64, 19 byte

Su x64, possiamo usare un syscall corretto per lo stesso conteggio byte.

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

Le uniche differenze risiedono nell'istruzione ( syscallvs int $0x80), nel valore di __NR_REBOOT ( 0xa9 vs 0x58 ) e nei registri coinvolti.

PowerShell, 13 byte

Stop-Computer

Abbastanza autoesplicativo? Non funziona su PowerShell core, quindi non funzionerà su PowerShell per Linux / MacOS (già provato su TIO :-D).

Bonus Garbage Submission, 12 byte

gcm s*r|iex

Nel mio test, questo funziona su Windows 2003 con PowerShell 2.0. Non funzionerà sulla maggior parte delle versioni più recenti e potrebbe non funzionare a seconda dei moduli installati. È abbastanza terribile!

Questo cerca nella lista dei comandi qualsiasi con il modello s*re quindi li esegue tutti! Per essere chiari, questo è pericoloso, non farlo!

Il trucco ovviamente è ottenere un elenco di comandi che non hanno parametri obbligatori, altrimenti PowerShell richiederà un valore.

Sulla mia macchina del 2003, i 3 comandi che restituisce sono:

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ì, avvia il salvaschermo di selezione, ma no, non attende il completamento prima del lancio Stop-Computer.

Questo approccio può funzionare su macchine più recenti, sempre a seconda dei moduli installati, ma il meglio che ho potuto fare su Windows 2012 e 2016 è stato di 14 byte :

gcm sto*er|iex

(e sì, certo, l'invio di winbatch funzionerà in PowerShell ed è più breve, ma .. non è divertente)

Lotto, 10 byte

Su Windows, questo sarebbe sufficiente

shutdown/s

Questo imposterà un arresto in un minuto.

In alternativa, come sottolinea @flashbang:

shutdown/p

Questo spegne immediatamente il computer.

codice macchina x86, Lenovo Z510, COM COM o Bootloader, 7 byte

BITS 16

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

Assemblato in B8 00 3C BA 04 18 EF

Sto sfruttando " Puoi scrivere codice che funziona solo in un ambiente / sistema operativo specifico, se lo desideri " al massimo livello: funzionerà solo su Lenovo Z510 ¹ .

Questo scrive SLP_TYPa << 10 | SLP_ENnel PM1a_CNTregistro ACPI, ho scaricato questi valori dalle tabelle ACPI mesi fa per una risposta sull'arresto (dove do un po 'di contesto al codice sopra).

Questo può essere eseguito sotto DOS come COM (basta scrivere i dati binari in un file e modificare l'estensione in "com") o come bootloader.
Per quest'ultimo scrivi la firma standard e fai attenzione ai problemi con il firmware moderno .

¹ Non strettamente vero, si spegnerà anche qualsiasi sistema che abbia la stessa configurazione ACPI.

Shell GRUB , 4 byte

golfed

halt

Comando: halt --no-apm

Il comando arresta il computer. Se viene specificata l'opzione --no-apm, non viene eseguita alcuna chiamata al BIOS APM. Altrimenti, il computer viene spento tramite APM.

indennità

Ecco una prova che shell di GRUB è davvero Tur n ing-complete (vedi commenti):

Codice macchina 65C02, 1 byte

Istruzione STP (0xDB):

STP arresta l'ingresso di clock del 65C02, arrestando efficacemente il 65C02 fino a quando non si verifica un ripristino hardware (ovvero il pin RES si abbassa). Ciò pone il 65C02 in uno stato di basso consumo. Ciò è utile per le applicazioni (circuiti) che richiedono un basso consumo energetico, ma STP è visto raramente diversamente.

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

xxd dump:

00000000: db                                       .

Matlab, 21 byte

system('shutdown -s')

Non ho provato questo (chiudere tutti i programmi per fare un riavvio a metà giornata non è davvero allettante), ma dovrebbe funzionare. . Questo funziona ...

Aggiungerò una breve spiegazione in seguito, il mio laptop è attualmente spento.

MATLAB, 11 byte

!shutdown/p

Un po 'simile all'approccio di Stewie Griffin . Tuttavia, MATLAB ha modi molto più brevi di invocare i comandi di sistema; in questo caso, !viene utilizzato. Windows non ha bisogno .exedi nomi di comandi, quindi anche questo è lasciato fuori. L' /opzione è ancora supportata (sto eseguendo Windows 10) e annulla la necessità di spazio. Le alternative sono:

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 byte

OPTION

Attiva un arresto che causa il riavvio di 3DS. Spero che questo conti.

Funziona nella versione più recente.

Bash, 7 6 byte

init 0

Supponendo che il programma sia eseguito come root.

Java, 101 98 62 42 byte

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

Come sottolineato da @Snowman, la domanda non specificava se fosse necessario un programma completo, quindi questo dovrebbe essere comunque accettabile.

Python 2, 29 byte

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

Funziona su sistemi Linux e necessita di privilegi di root.

Per Windows, 33 byte

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

Questo potrebbe essere il codice meno interessante o utile che abbia mai scritto.

Commodore 64, 11 byte

0 sys64738

Questo viene dal prompt di BASIC. O...

Commodore 64, 6502 assembly, 3 byte (assemblato), 16 byte (sorgente)

*=8000
JMP $FCE2

TI-Nspire CX CAS, 3 byte

" "+" "

sommando due stringhe vuote.

Su una versione precedente della calcolatrice, ciò causerebbe l'arresto anomalo del dispositivo e il riavvio (non c'è modo di spegnere un dispositivo senza riavviare a parte le combinazioni di pulsanti fisici).

Video di Adriweb

C ++, 51 40 byte

-11 byte grazie a Ingve !

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

Funziona solo in IncludeOS (v0.10.0-rc.1)

Test:

$ 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 byte

tell app "Finder" to shut down

Fa esattamente quello che dice: dice a Finder di spegnere il computer.

Tasto di scelta automatica, 11 10 byte

Salvataggio di un byte grazie a Gurupad Mamadapur

Shutdown,9

AHK Supporta un comando di spegnimento per impostazione predefinita. La 9è una bandiera, costituito da Shutdown=1+ PowerDown=8.

Codice macchina (x86, boot loader) 18 byte

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

Smontaggio:

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

Puoi testarlo nel debugger di Bochs con i seguenti comandi (dopo aver avviato la simulazione, avendo configurato un disco fisso):

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

Lo stesso codice macchina funzionerà anche come eseguibile DOS ( *.COM).

C #, 79 54 53 byte

Questo funziona su Windows.

79 byte :

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

53 byte , grazie a TheLethalCoder:

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

AutoIt, 11 byte

Shutdown(1)

La funzione di spegnimento ottiene la combinazione dei seguenti codici

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

Per lo spegnimento e lo spegnimento, ad esempio, il codice sarebbe 9 (spegnimento + spegnimento = 1 + 8 = 9).

Windows - NativeAPI, 212 byte

Ok, questa non è davvero la versione più breve. Ma forse interessante per alcuni. Ciò non verrà eseguito sul sottosistema Win32. Tuttavia verrà eseguito quando eseguito nel contesto dell'API nativo (come fa autochk.exe)

Codice

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

Costruire

Per compilare questo, utilizzare lo build.exestrumento WinDDK (con un sourcefile appropriato per NMAKE)

Oppure usa questi comandi per compilare e collegare:

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: questo genererà un eseguibile nativo x86. Modificare i bit appropriati se si desidera crearlo per un'architettura diversa.

Test

Per testare un eseguibile nativo devi eseguirlo prima che il sottosistema win32 venga caricato. Un modo comune per farlo è aggiungere l'eseguibile nella seguente chiave di registro:

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

avvertimento

In questo caso, tuttavia, è necessario disporre di un'opzione per modificare l'hive di registro del sistema operativo di destinazione da un altro sistema operativo. Dal momento che non sarai più in grado di avviare il sistema operativo di destinazione!

L'ho fatto su una VM in cui avrei potuto facilmente tornare a un'istantanea precedente!

Groovy, 23 byte

'shutdown /p'.execute()

La maggior parte delle shell Linux, 15 byte

# echo o>/p*/*ger

Potrebbe essere lungo 11 byte, se ti trovi nella /procdirectory:

# echo o>*ger

Questo è molto semplice (non ha effetti collaterali, come smontare filesystem o processi di uccisione) e piuttosto brutale.

Shell Android, 9 byte

reboot -p

AppleScript, 44 byte

tell application "Finder"
shut down
end tell

Non so come funziona la sintassi AppleScript o altro, quindi se qualcuno sa come accorciarlo, per favore, dillo.

Inoltre, lo sto facendo sul mio telefono a scuola ("hacking"), quindi non posso provarlo.

A 14 byte in meno (grazie a kindall) puoi dire

tell app "Finder" to shut down

J, 14 byte

2!:0'poweroff'

Funziona su sistemi Linux. 2!:0esegue la stringa in /bin/sh.

Clojure, 40 39 byte

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

-1 byte cambiando la bandiera da -sa /s, che mi ha permesso di liberarmi dello spazio.

Fondamentalmente la risposta Java.

Testare questo è stato divertente. Windows ha deciso di eseguire un aggiornamento del firmware sul mio Surface non appena si è spento. Ovviamente.

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

Node.js, 39 byte

Linux

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

AHK, 19 15 byte

Run,Shutdown -s

Funziona solo su Windows.

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

Rimosso 1 byte grazie a Snowman

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

Ciò dovrebbe arrestare il sistema per Windows

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

Ciò dovrebbe arrestare il sistema per Linux