La maggior parte delle tastiere per computer è dotata di una piccola luce a LED integrata, che indica la modalità di input corrente, controllata dal pulsante BLOC MAIUSC.

Il tuo compito è di battere le palpebre:

• Accendilo;
• Attendere 0,5 (+/- 0,1) secondi;
• Spegnilo di nuovo.

Le riprese video del LED lampeggiante sono molto apprezzate!

Regole

• Se lo desideri, puoi lampeggiare un LED diverso (ad esempio Blocco scorrimento, Blocco numeri, stato Wi-Fi ecc.), Ma deve essere fisicamente posizionato sulla tastiera;

• Se nella tua lingua manca un sleepcomando di un secondo , il tuo programma potrebbe usare un ritardo di 1 secondo, con una penalità di +2 byte (è per 0.);

• Il programma deve lampeggiare almeno una volta, ciò che accade dopo dipende da te, ovvero può continuare a lampeggiare (nel qual caso è necessario attendere lo stesso ritardo, prima di riaccenderlo), oppure interrompere ecc;

• Se il LED scelto è acceso per impostazione predefinita, sul tuo sistema, puoi presumere che sia stato esplicitamente spento (ad es. Manualmente), prima che il programma venga eseguito;

• Questo è code-golf , vince la risposta più breve in byte.

Classifica

var QUESTION_ID=110974,OVERRIDE_USER=61904;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Befunge (BEF32), 390 334 305 byte

Questo è davvero sciocco, ma finché questo sito accetta l'idea che l'interprete definisce la lingua , potrei anche abusare della regola. Questo codice funziona solo con l'implementazione Win32 Befunge-93 di Kevin Vigor, versione 1.01 (penso che sia l'unica versione disponibile). Puoi scaricare il binario qui .

p55p99+5p65*5p")"5p"M"3*"I~q"+\3*3445"|"2*"lm"2v
v"y"*3\*2"e/n"4\5"nnIn"*833*2"mn"4\7"nnIn"*833*<
>2*"yO"4"DJG"3*\2*55*3"T"4"DLG"3*\2*55*3"/~M"+\3*4446"~A"+4v
>+00p9p:v:"l'"*2"^D"4"l3"*2"^D"4"l"*54*2"^D"4"l"*2+94*2"^D"<
^1:g00-4_5"u1"*-:1+:1+"@"\0p"%"5*\0p"P"\0p@
Sleep kernel32.dll keybd_event user32.dll

Ora normalmente non ti aspetteresti che questo tipo di sfida sia possibile in un Befunge, ma BEF32 è una porta Win32 di una versione molto vecchia dell'implementazione di riferimento, e all'epoca non c'erano limiti che controllavano il pcomando (put). Questo in modo efficace ci consente di scrivere in qualsiasi posizione in memoria, il che alla fine ci consente di forzare l'interprete a eseguire codice macchina arbitrario.

Ora non possiamo effettivamente modificare nessuno del codice esistente, poiché la sezione .text dell'eseguibile non avrà autorizzazioni di scrittura. Tuttavia, possiamo ingannare il sistema nell'eseguire un indirizzo nella sezione .data, scrivendo quell'indirizzo nella atexittabella della libreria di runtime (almeno sospetto che sia quello che è). Il risultato finale è che il nostro codice viene eseguito automaticamente alla chiusura dell'interprete.

Ciò si basa sul fatto che l'eseguibile è caricato su un indirizzo fisso, quindi sappiamo esattamente dove si trova tutto nella memoria - presumibilmente non funzionerebbe se si superano le impostazioni ASLR predefinite . Si basa anche sul fatto che la sezione .data sia eseguibile, nonostante non abbia l'attributo eseguibile impostato, quindi molto probabilmente non funzionerebbe se si superano le impostazioni DEP predefinite .

Il codice stesso è essenzialmente una copia di Mego s' keybd_eventtecnica tradotto in codice macchina:

6823B84000         push "keybd_event"
682FB84000         push "user32.dll"
6810B84000         push "Sleep"
6816B84000         push "kernel32.dll"
BB02000000         mov  ebx,2
               initloop:
89C7               mov  edi,eax
FF1594D14000       call LoadLibraryA
50                 push eax
FF1590D14000       call GetProcAddressA
4B                 dec  ebx
75EE               jnz  initloop
89C6               mov  esi,eax
               flashloop:
6A00               push 0
6A01               push 1
6A45               push 69
6A14               push 20
FFD6               call esi
6A00               push 0
6A03               push 3
6A45               push 69
6A14               push 20
FFD6               call esi
68F4010000         push 500
FFD7               call edi
EBE3               jmp  flashloop

Questa versione del codice continua a lampeggiare per sempre (o almeno fino a quando non si interrompe il processo), dal momento che si è rivelato più facile giocare a golf di un singolo flash.

E poiché tutti pubblicano animazioni, questa è un'approssimazione di come appare sulla mia tastiera.

Tasto di scelta automatica, 29 26 byte

_{Grazie a @Dane per aver salvato 3 byte}

Loop{
Send,{VK14}
Sleep,500
}

Inizialmente ho scelto NumLockperché è un personaggio più corto di CapsLock. La GIF in basso riflette questa condizione. È lo stesso effetto del codice modificato sopra. Avrei potuto andare VK90sopra per rendere la GIF ancora accurata, ma l'allineamento con la sfida originale sembrava migliore.

In onore del commento di mbomb007 , ecco un messaggio in codice morse in 239 byte :

s:=000090901009011091100110090111109111901090190110901109091000091001101909101191000911190190109100001090191010919111901091011
Loop,123{
StringMid,c,s,A_Index,1
IfEqual,c,9
{
Sleep,2000
Continue
}
Send,{NumLock}
Sleep,%c%500
Send,{NumLock}
Sleep,500
}

Ecco i primi 30 secondi di quel messaggio:

GFA-Basic 3.51 (Atari ST),  61 56 43  35 byte

Questo codice farà lampeggiare per sempre il LED dell'unità floppy alla velocità richiesta ( PAUSE 25= pausa per 25/50 secondi).

Probabilmente questo sarebbe più breve durante il montaggio, ma non ho gli strumenti appropriati a portata di mano. Questa è la dimensione dell'elenco GFA-Basic una volta salvato in formato .LST e modificato manualmente per rimuovere spazi bianchi inutili, rinominare le istruzioni in stringhe più brevi e sostituirle CR+LFcon una semplice CR. Si noti che CRè richiesto un finale .

DO
i=i XOR2
SP &HFF8802,i
PA 25
LO

Si espanderà automaticamente a:

DO
  i=i XOR 2
  SPOKE &HFF8802,i
  PAUSE 25
LOOP

SPOKEè un sovralimentato POKEche per prima cosa mette il 68000 in modalità supervisore , in modo che sia consentito l'accesso alle aree di memoria ristrette (qui: l' indirizzo di scrittura del registro del soundchip YM2149, che è anche responsabile di alcuni altri I / O).

E sì: il LED si trova fisicamente sulla tastiera ... suppongo.

^{Non ho accesso a un vero ST in questo momento, quindi questo è solo un modello.}

pesce + ckb , 56 54 byte

while cd;echo rgb (random)|tee /d*/*/*/c*;sleep .5;end

Lampeggia tutta la mia tastiera in colori casuali, anche se il numero non è di 6 cifre esadecimali è un po 'limitato.

E sì, quel glob shell è potenzialmente pericoloso. Funziona su My Machine ™

Script bonus, 8 mesi dopo: passerà attraverso tutti i colori. Non golfato.

#!/usr/bin/fish
while true
        echo rgb (printf '%06x' (random 0 16777215)) | tee /dev/input/ckb*/cmd > /dev/null
        sleep 0.5
end

Bash + amixer, 45 byte

a() { amixer set Master toggle
}
a;sleep .5;a

Lampeggia la luce muta sulla mia tastiera.

C (Windows), 79 byte

#include<windows.h>
k(n){keybd_event(20,69,n,0);}f(){k(1);k(3);Sleep(500);f();}

Spiegazione

keybd_eventè una funzione (obsoleta) dell'API di Windows per inviare un evento tastiera (keyup o keydown). 20è il codice per il tasto BLOC MAIUSC, 69è il codice di scansione dell'hardware (non ho idea di cosa significhi) e 1significa keydown e 3significa keyup. Un keypress viene simulato inviando un evento keydown immediatamente seguito da un evento keyup. Viene premuto un tasto per attivare il blocco maiuscole, quindi il programma viene sospeso per 500 millisecondi, quindi viene inviato un altro tasto per disattivare il blocco maiuscole.

Grazie a Steadybox per un sacco di byte salvati

MATLAB, 146 136 70

Grazie a @Poke per la rimozione di 66 byte!

r=java.awt.Robot;while 1
r.keyPress(20)
r.keyRelease(20)
pause(.5);end

Questo utilizza la capacità di Matlab di chiamare le classi Java. La spia Bloc Num viene lampeggiata in un ciclo premendo e rilasciando programmaticamente Num Lock.

Video o non è successo .

codice macchina x86 per PC (es. file COM MS-DOS), 27 byte

Questo codice macchina (visualizzato qui con un rendering Unicode del solito CP437 del BIOS del PC) farà lampeggiare per sempre l'indicatore BLOC MAIUSC su un PC:

j@▼î▐j`Z░φεê╪εÇ≤♦╞♦◙Ç<☺t∩δ∙

Il codice è stato creato in modo che non contenga byte NULL e può quindi essere digitato con la tastiera (utilizzando il trucco Alt + XXX per caratteri estesi) per creare un file COM (ad esempio, utilizzando il COPY CON blink.comcomando in MS-DOS, nel qual caso il file di output dovrà contenere un 28 ^° byte spurio , il carattere ^Z(EOF) richiesto per interrompere l'operazione di copia).

L'effetto si ottiene inviando direttamente i comandi al controller della tastiera del PC (porta 60h) per impostare lo stato del LED (come effetto collaterale, potrebbe impostare i LED Num Lock e Scroll Lock su uno stato casuale non lampeggiante). Il tempismo, per ridurre al minimo il numero di istruzioni, si ottiene utilizzando il timer per il conto alla rovescia gestito dal BIOS all'indirizzo 0040:0040(diminuisce ogni 54.925 ms, con 9 cicli il ciclo di lampeggiamento è 494.3 ms, che è all'interno del margine consentito) - questo contatore viene normalmente utilizzato dal BIOS per arrestare il motore del disco floppy; poiché l'unità floppy non viene utilizzata dal programma e si presume che il codice venga eseguito in un ambiente a singola attività (ad es. DOS), la riproduzione con il timer del motore floppy non è un problema.

Il codice funziona bene con MS-DOS (provato con VirtualBox, dovrebbe funzionare anche su hardware reale, anche se non ho ancora avuto il tempo di creare una chiavetta USB MS-DOS avviabile per il test). Poiché non si basa su alcuna funzione del sistema operativo, può anche funzionare senza il sistema operativo (ad esempio, posizionandolo nel settore di avvio di un disco). Richiede almeno un processore 80186 per l'esecuzione, a causa delle istruzioni di "push immediato" utilizzate per abbreviare il codice di alcuni byte.

Codice sorgente assembly:

  PUSH 0x40               ; pushes 0x0040 (BIOS data segment) on the stack
  POP DS                  ; pops it into DS segment selector
  MOV SI, DS              ; copies DS to SI (timer counter is nicely placed at 40:40)
  PUSH 0x60               ; pushes 0x0060 (kbd controller port) on the stack
  POP DX                  ; pops it to DX
loop:
  MOV AL, 0xED            ; 8042 keyboard controller 'set mode indicators' command
  OUT DX, AL              ; outputs the command to the keyboard contr oller
  MOV AL, BL              ; copy BL register to AL
  OUT DX, AL              ; outputs LED state to keyboard controller
  XOR BL, 4               ; toggles bit 2 (CAPS LOCK) for next iteration
  MOV BYTE PTR[SI], 0x0A  ; sets floppy motor countdown timer to 10
wait:
  CMP BYTE PTR[SI], 0x01  ; checks if timer reached 1
  JE loop                 ; if yes, time for next iteration
  JMP wait                ; if not, checks again

Dump esadecimale del codice assemblato:

6A 40 1F 8C DE 6A 60 5A B0 ED EE 88 D8 EE 80 F3 04 C6 04 0A 80 3C 01 74 EF EB F9

Ecco il risultato in esecuzione sotto MS-DOS in VirtualBox (non funziona con DosBox, presumibilmente perché il controller della tastiera non è completamente emulato):

(scusate il video traballante).

SmileBASIC, 36 23 byte

XON MIC
WAIT 30XOFF MIC

Lampeggia la spia di stato del microfono. (video in arrivo)

Python2 - 108 byte

Fa il tasto maiuscolo. È interessante notare che questo in realtà accende solo il LED stesso senza influenzare la tastiera o premere il tasto. È possibile modificare il 4alla fine 2per fare numlock. 6fa entrambe le cose.

import fcntl,os,time;exec"fcntl.ioctl(os.open('/dev/console',os.O_NOCTTY),19250,%d);time.sleep(.5);"*2%(4,0)

shell + numlockx, 40 35 byte

[Salvato 5 byte grazie a Ryan.]

Lampeggia continuamente la luce NumLock su sistemi unixish.

numlockx toggle;sleep .5;exec sh $0

Lampeggiamento singolo, 33 byte

numlockx on;sleep .5;numlockx off

PowerShell , 71 byte

for(){(New-Object -c WScript.Shell).SendKeys('{NUMLOCK}');sleep -m 500}

Appunti

• Lampeggia per sempre
• Usa NUM LOCKper salvare un byte.

VBS, 75 byte

do
wscript.sleep 500
Createobject("wscript.shell").sendkeys"{numlock}"
loop

Lampeggia ripetutamente il tasto Bloc Num, in quanto numlock1 byte è più corto di capslock.

C #, 215 202 198 195 185 byte

Senza accorgermene ho fatto lo "stesso" codice di questa risposta di @Mego , vai a dare un'occhiata !.

[System.Runtime.InteropServices.DllImport("user32")]static extern void keybd_event(int v,int s,int f,int e);n=>{for(n=0;;System.Threading.Thread.Sleep(125))keybd_event(20,69,n++&2,0);};

Salvati 13 byte grazie a @Metoniem
Salvati 10 byte grazie a @VisualMelon

Ecco una versione completamente formattata che mostra che funziona:

class P
{
    [System.Runtime.InteropServices.DllImport("user32")]
    static extern void keybd_event(int v, int s, int f, int e);

    static void Main()
    {
        System.Action<int> a = n =>
        {
            for (n = 0; ; System.Threading.Thread.Sleep(125))
                keybd_event(20, 69, n++ & 2, 0);
        };

        a(0);
    }
}

Per il cambio di bonus divertente n++ & 2per n+=2 & 2e guardare il num lock e Caps Lock chiavi si alternano a lampeggiare e si spegne. Non ho idea del perché ciò accada perché non dovrebbe ma sembra "bello".

Java 7, 121 118 113 byte

void a()throws Exception{java.awt.Robot r=new java.awt.Robot();r.keyPress(20);r.delay(500);r.keyRelease(20);a();}

Una sola pressione e rilascio innesca semplicemente lo stato; non lo batte. Quindi potremmo anche farlo in loop e sembra che la ricorsione sia il modo più economico per farlo.

JavaScript, 82 byte

Il merito va a @FinW in realtà, ho appena cambiato la vecchia funzione con la nuova funzione freccia ES6 per salvare alcuni byte. E poiché non ho abbastanza punti per commentare, ho scritto una nuova risposta.

Modifica: parentesi cancellate per salvare altri 2 byte.

o=new ActiveXObject("WScript.Shell");setInterval(()=>o.SendKeys("{NUMLOCK}"),500);

Il suo codice sembrava così

o=new ActiveXObject("WScript.Shell");setInterval(function(){o.SendKeys("{NUMLOCK}")},500);

Scala, 84 83 78 byte

Modifica: salvato 1 byte grazie a @TheLethalCoder,

Ha suggerito di utilizzare 1>0al posto di true.

Modifica 2: 5 byte salvati grazie a @ Corvus_192,

Ha suggerito di usare la notazione infissa e di rilasciare le parentesi dopo il costruttore

while(1>0){val r=new java.awt.Robot;r keyPress 20;r keyRelease 20;r delay 500}

Ungolfed:

while(1>0) {
    val r=new java.awt.Robot()
    r.keyPress(20)
    r.keyRelease(20)
    r.delay(500)
}

Porta Scala standard della risposta Java di @Poke . Digita direttamente nel prompt dell'interprete Scala.

Un video lampeggia sia il mio LED BLOC MAIUSC che il mio OSD per l'avvio!

Terminale Linux, 8 + 11 = 19 byte

File f=1B 5B 33 71 1B 5B 30 71

native@shell:~$ pv f -q -L8

WAT?

Secondo ECMA-48 , 1Bavvia la sequenza di escape del controllo terminale.

Caps on = 1B 5B 33 71, quindi off =1B 5B 30 71

pv visualizzazione dei progressi

f file

-q silenzioso

-L8 8 byte / s = 0,5 secondi di ritardo

uso

Preparare

#Create file
echo "1B 5B 33 71 1B 5B 30 71"|xxd -r -p > f 

#Install progress view utility
sudo apt install pv

Ctrl+ Alt+ F6passa alla console nativa

correre pv f -q -L8

Ctrl+ Alt+ F7ritorna indietro

Bash + Xdotool, 36 byte

for((;;)){ xdotool key 66;sleep .5;}

Basta eseguirlo in una shell bash. Deve essere in un ambiente grafico. Ciclo infinito da qui . Modificato Num_Lock a 66 per salvare 6 byte e grazie a @Michael Kjörling per 2 byte.

xdotool , 20 byte

key -delay=500 66 66

Preme due volte il tasto 66 aka Caps Lock , con un ritardo di 500 ms tra la pressione del tasto.

Si noti che xdotool è un linguaggio di scripting; può essere eseguito da un file e supporta persino shebangs. Poiché il suo execcomando consente l'esecuzione di programmi esterni, è in grado di eseguire test di addizione e primalità, quindi soddisfa la nostra definizione di linguaggio di programmazione.

Prova

$ cat blink.xdo; echo
key -delay=500 66 66
$ xdotool blink.xdo

Python usando pyautogui: 126 143 115 103 byte

Grazie a @ nedla2004 per aver salvato 12 byte

from pyautogui import*
import time
while 1:keyDown('capslock');time.sleep(.5);keyUp('capslock')pslock')

Bash, 31 byte

xset led 1;sleep .5;xset -led 1

Funziona in X, senza accesso root! (Se non funziona per te, consulta la funzione init del codice seguente per assicurarti che xkbcomp sia configurato correttamente)

E uno script bonus per inviare qualsiasi codice morse attraverso il blocco maiuscole (non golfato):

unit=0.15
id=1
function init {
        file=/tmp/blink_tmp
        xkbcomp $DISPLAY $file
        sed -i 's/!allowExplicit/allowExplicit/' $file
        xkbcomp $file $DISPLAY &>/dev/null
        rm $file
}
if [[ -z $1 ]]; then
        echo "Usage : blink [message]"
        exit 1
fi
init
function finish {
        off
}

function on {
#su -c 'setleds -L +caps < /dev/console'
xset led $id
}
function off {
#su -c 'setleds -L -caps < /dev/console'
xset -led $id
}
function slp {
        sleep $(echo "$unit*$1" | bc)
}
function dot {
on
slp 1
off
slp 1
}
function dash {
on
slp 3
off
slp 1
}
function gap {
        slp 3
}
function morse {
        msg=$1
        for (( i=0; i<${#msg}; i++ )); do
                char=${msg:$i:1}
                if [[ $char == "-" ]]; then
                dash
                elif [[ $char == "." ]]; then
                dot
                elif [[ $char == "/" ]]; then
                gap
                fi
        done
}
while true; do
        morse $1
done

Esempio: blink "...././.-../.-../---//.--/---/.-./.-../-..///"

Bash + setleds , 43 byte

setleds -D +caps;sleep 0.5;setleds -D -caps

Abbastanza semplice. Utilizza setledsper attivare / disattivare la luce.

Bash, 103 byte

cd /sys/class/leds/asus\:\:kbd_backlight;while true;do echo 3;sleep .5;echo 0;sleep .5;done>brightness

Deve essere eseguito come root.

Il flashing dell'intera retroilluminazione della tastiera funziona? (video che verrà quando torno a casa)

JavaScript, 90 byte

o=new ActiveXObject("WScript.Shell");setInterval(function(){o.SendKeys("{NUMLOCK}")},500);

Richiede il ActiveXsignificato che funzionerà solo su IE ( tuttavia Edge non lo supporta). Lampeggia il tasto NUMLOCK perché, come con altre risposte, è più breve di CAPSLOCK o SCROLLLOCK.

Ungolfed

shell = new ActiveXObject("WScript.Shell");
setInterval(
    function(){
        shell.SendKeys("{NUMLOCK}")
    }
,500);

Bash, 33 byte

Ciò presuppone che Num-Lock sia attivo prima che venga eseguito. Passa offe onaltrimenti. Richiede numlockxovviamente il pacchetto;)

numlockx off;sleep .5;numlockx on

Modificare:

Ho visto che Alex Howansky ha già pubblicato questa soluzione, ma non l'ha contrassegnata con Bash e ho appena cercato "Bash" nel sito.

File batch (con l'aiuto di vbs), 74 + 2 = 76 byte

echo Createobject("wscript.shell").sendkeys"{numlock}">z.vbs&z&timeout 1&z

Parzialmente basato sulla risposta di Trelzevir .

.vbsè automaticamente incluso in PATHEXT.

Kotlin Script, 72 byte

Sebbene non sia il più piccolo, è comunque abbastanza buono. Sto amando la corsa di Kotlin per alcune cose, e questa è una di queste (più piccola di val r = java.awt.Robot () perché non abbiamo bisogno sia di r. Che di val r =. Tuttavia, è più lunga di MathLab)

java.awt.Robot().run{while(1>0){keyPress(20);keyRelease(20);delay(500)}}

Ungolfed:

java.awt.Robot().run {
    while(1>0) {
        keyPress(20)
        keyRelease(20)
        delay(500)
    }
}

Python3, 55 49 byte

Grazie @NoOneIsHere per -4 byte!

Questo include pacchetti: pyautogui e timemoduli
Codice:

while(1):pag.press("capslock");time.sleep(0.5)  

Grazie @NoOneIsHere per -4 byte!
La chiave in azione:

VBA, 82 byte

Anonimo VBE Funzione finestra immediata che non accetta input e infastidisce l'utente indefinitamente. Dipende dalla funzione sleep kernel32 di Windows dichiarata di seguito.

Dichiarazione sul sonno (Win-32)

Declare Sub Sleep Lib "kernel32" (ByVal M&)

Dichiarazione del sonno (Win-64, + 8 byte)

Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal M&)

Funzione finestra immediata VBE anonima

Do:SendKeys"{CAPSLOCK}":Sleep 500:DoEvents:Loop

Versione leggermente più divertente, 97 byte

Un insieme di subroutine reciprocamente ricorsive che infastidiscono indefinitamente l'utente

Sub A
Application.OnTime Now+5.8E-6,"B"
End Sub

Sub B
DoEvents
SendKeys"{CAPSLOCK}"
A
End Sub

Versione discutibile, 66 + 2 byte

Non sono sicuro se dover dichiarare una funzione da una dll conta come avere una funzione integrata, quindi, nel caso in cui non lo sia, ecco una versione da 66 + 2 byte che attende 1 secondo

Do:DoEvents:Application.Wait Now+#0:0:1#:SendKeys"{CAPSLOCK}":Loop