Automatizza il salvataggio del mondo


63

Sei Desmond Hume. Negli ultimi 3 anni, tu e il tuo partner, Kelvin, siete stati schiavi di un computer che richiede l'inserimento di una sequenza molto specifica ogni 108 minuti per salvare il mondo.

4 8 15 16 23 42

Il tuo partner è morto 40 giorni fa (a causa di uno sfortunato incidente che ha coinvolto la testa di Kelvin e un grosso sasso) e non hai nessuno con cui parlare. Nessuno per inserire i numeri per te. Nessuno a rompere la monotonia. All'inizio non era poi così male, ma non puoi più gestire il silenzio. E se devi ascoltare "Crea il tuo genere di musica" ancora una volta, urlerai.

Decidi che devi uscire. Scappare. Decidi che costruirai una zattera e navigherai al largo dell'isola. Ma poi ti rendi conto delle cattive notizie: sei bloccato qui. Devi continuare a salvare il mondo.

Ma poi ti rendi conto della buona notizia: sei un programmatore! Puoi automatizzare il salvataggio del mondo! Entusiasta, corri al computer e, usando le tue fidate abilità di pitone, tiri fuori una breve sceneggiatura per inserire i numeri per te.

import time

while True:
    print "4 8 15 16 23 42"
    time.sleep(60 * 107)

Veloce, semplice, affidabile, breve e facile. Tutto ciò che dovrebbe essere un buon script Python. Ma poi, quando provi a provarlo, ricevi un errore.

Bad command or file name.

Eh, strano. Oh bene, proviamo c ++.

#include <iostream>
#include <unistd.h> 

int main()
{
    while (true)
    {
        std::cout << "4 8 15 16 23 42" << std::endl;
        sleep(60 * 107);
    }
}

No! Neanche C ++ è stato trovato. Provi ogni lingua che ti viene in mente. Javascript, Ruby, Perl, PHP, C #. Niente. Questo computer è stato realizzato prima di tutte le lingue popolari del giorno.

La sfida

Devi scrivere un programma che:

1) Stampa esattamente questo: "4 8 15 16 23 42" (senza virgolette)

2) Attendere qualche minuto tra 104 e 108 minuti. (Secondo The Lost Wiki )

3) Ripeti per sempre. (O fino a quando non ti rendi conto che questa è tutta una truffa elaborata e che sei bloccato in uno strano limbo a causa di una scrittura pigra e di porre domande per le quali non hai risposte. Grazie JJ Abrams!)

Tuttavia, c'è un problema: DEVI usare una lingua che il computer nella stazione del cigno sarebbe effettivamente in grado di eseguire. Supponendo che

A) Il computer era aggiornato al momento della costruzione,

B) Non ci sono stati aggiornamenti al software del computer e

C) Non è disponibile una connessione Internet (significa che non è possibile scaricare Golfscript ...),

e fare la nostra ipotesi migliore per la data di costruzione di The Swan Station, (Again, The Lost Wiki. )

Ciò significa che devi usare un linguaggio che è stato rilasciato la prima volta o prima del 31 dicembre 1977.


Alcuni chiarimenti sulle regole:

  • Includere le librerie è OK, ma si applica la stessa regola (le librerie devono essere pre-1977).

  • Non devi preoccuparti della compatibilità del sistema operativo.

  • Se usi system, o le tue lingue equivalenti, devi dimostrare che tutti i comandi di sistema che utilizzi sarebbero stati disponibili prima del 1978. Un articolo di Wikipedia è probabilmente il modo migliore per dimostrarlo.

  • Non importa quando avvii il programma, basta che finisca in uno schema di stampa e sonno alternati. (print-sleep-print-sleep ... e sleep-print-sleep-print ... sono entrambi accettabili.)

Questo è Code-Golf, quindi vince la risposta più breve in byte.


È necessaria una nuova riga alla fine di ogni output?
Mego

3
@Mego Sì, altrimenti i numeri non verrebbero effettivamente inseriti .
DJMcMayhem

Risposte:


11

APL , 28 24 25 24 byte

Questo ha funzionato in APL * PLUS di STSC e in SharpAPL di IPSA nel 1977, e mentre i moderni APL hanno un sacco di nuove funzionalità, questo sembra funzionare ancora su tutti i principali APL di oggi:

+\4 4 7 1 7 19
→×⎕DL 6360

La prima riga stampa la somma cumulativa dei numeri mostrati, che sono i numeri richiesti. La seconda linea d e l sem 6360 secondi (106 minuti), poi prende la signum di che (1, ovviamente), e va a quella linea (cioè il precedente, numero-stampa di uno).

Tuttavia, APL \ 360 (l'APL per IBM System / 360 ) dal 1966 in realtà lo batte di un byte (testato sull'emulatore IBM / 370 gratuito ):

+\4 4 7 1 7 19
5⌶19E5
→1

Il sonno I-beam ( " IBM " -? Ottenerlo) batte il tempo di attesa in jiffies di 1 / 300 ° di secondo, in modo da attendere 19 × 10 5 jiffies = 105 minuti e 33 1 / 3 secondi.


D'ora in poi darò tutte le mie misurazioni del tempo in kilojiffies e megajiffies.
Pavel,

+\⎕A⍳'EEHBHT'(if ⎕IO=0)
ngn,

@ngn APL * PLUS non ha ⎕A.
Adám,

@ Adám +\4 4 7 1 7 19allora?
ngn,

@ Adám ping ^
ngn

26

MUMPS - 30 caratteri, circa 1966 (standard ANSI prima nel 1977)

Il mio primo tentativo di code golf, eccoci qui!

f  w "4 8 15 16 23 42" h 6420

MUMPS è ancora una lingua popolare per il software EHR, creato dal Massachusetts General Hospital di Boston. L'implementazione più nota è Epic Systems a Verona, WI.


6
Ottimo lavoro! MUMPS è in realtà l'ideale per giocare a golf con il codice se vuoi entrare in quel particolare cerchio dell'Inferno ...

2
Se il mondo fosse in pericolo, potrei mettere "U 0" all'inizio ...
psr

5
@psr, cosa c'è di più importante: salvare il mondo o giocare a golf con il codice ?!
Andrew Robinson,

2
@psr Potresti spiegare la battuta a qualcuno che non ha mai sentito parlare di MUMPS prima? Non io, solo ... ipoteticamente. Nel caso qualcuno che non abbia sentito parlare di MUMPS si imbatte in questo. ;)
DJMcMayhem

3
@DJMcMayhem - L'istruzione write (la "W") scrive sul dispositivo di output corrente (il dispositivo corrente ha un valore globale che ti piaccia o no). Il dispositivo corrente sarà probabilmente l' output standard. Ma U 0 lo imposterebbe sull'output standard (ehm, di solito, ma andare su quello non sarebbe più divertente per nessuno).
psr

20

TECO, 53 byte

TECO (Text [precedentemente Tape] Editor and Corrector) è un editor di testo nato nel 1962. Può anche essere utilizzato per eseguire programmi autonomi. È l'editor all'avanguardia per PDP, VAXen, ecc.

Secondo il manuale TECO, il ^Hcomando indica l'ora del giorno. Assicurati di controllare il tuo sistema operativo e l'alimentatore, poiché l'unità di tempo può variare in base alla tua macchina:

OS/8:      ^H = 0
RT-11:     ^H = (seconds since midnight)/2
RSTS/E:    ^H = minutes until midnight
RSX-11:    ^H = (seconds since midnight)/2
VAX/VMS:   ^H = (seconds since midnight)/2
TOPS-10:   ^H = 60ths of a second since midnight
(or 50ths of a second where 50 Hz power is used)

Il seguente programma funziona su sistemi in cui l'ora del giorno viene misurata in secondi / 2:

I4 8 15 16 23 42
$<HT^HUA<^H-QAUDQD"L43200%D'QD-3180;>>

Si noti che ^He $dovrebbe essere inserito colpendo, rispettivamente, CONTROL-H ed ESCAPE.

I numeri nel programma possono essere regolati per le seguenti macchine:

   (number)        43200     3180
RSTS/E              1440      106
TOPS-10 60 Hz    5184000   381600
TOPS-10 50 Hz    4320000   318000
OS/8             goodbye, world...

20

Bourne shell, 47 45 byte

while echo 4 8 15 16 23 42;do sleep 6420;done

2
Battimi. Stavo cercando di trovare prove che sleeperano effettivamente disponibili allora - l'hai trovato? en.wikipedia.org/wiki/…
Digital Trauma

Puoi usare sleepcome whilecondizione. Salva 2 byte
ThinkChaos

@plg Che dormirebbe prima di emettere la sequenza numerica, che non sembra essere consentita (deve stampare la sequenza immediatamente dopo aver eseguito il programma, quindi dormire).
Maniglia della porta

5
Quindi si avvia il programma immediatamente dopo l'ultima immissione manuale dei numeri. ;)
Roger,

1
La versione 6 di Unix includeva il comando sleep (vedi man.cat-v.org/unix-6th/1/sleep ).
Matteo Italia,


13

FORTRAN 66 ( 108 98 byte)

      PROGRAM D 
2     WRITE (*,*) '4 8 15 16 23 42'
      CALL SLEEP(6420)
      GOTO 2
      END

È certo che il computer in questione aveva il compilatore FORTRAN, in quanto dominava i campi scientifici e ingegneristici dell'epoca. Sono nato 18 anni dopo l'omonimo anno, ma durante il mio programma di matematica all'università abbiamo imparato FORTRAN. Una lezione divertente che abbiamo imparato a programmare su schede perforate. Non è così facile formattarlo correttamente qui, ci dovrebbero essere 6 spazi vuoti prima di ogni comando e ho potuto trovare solo un riferimento alla funzione Sleep per Fortran 77 ma avrebbe dovuto esistere già in Fortran IV e 66.

PS: Potremmo eliminare un byte utilizzando l'etichetta 1 anziché l'etichetta 42.

PPS: Se il computer in questione utilizza schede perforate per l'input del programma, sei sfortunato e i byte non contano più: D.


@proudhaskeller No, le 7 colonne di sinistra sono riservate in modo da salvare solo un byte alla fine della riga 4.
frodoskywalker

1
Esatto, avrei solo un byte sicuro, ecco perché non l'ho cambiato;)
Bersaelor

3
Ah, lo spazio bianco obbligatorio mette una lacrima nostalgica nei miei occhi: D
Yves Klett

Puoi anche eliminare un byte sostituendolo 60*107con 80**2.
Segna il

Ok, ma poi si può anche usare 6420.
Bersaelor


10

Altair Basic

Di sicuro, Desmond e Kelvin avrebbero avuto un Altair 8800 (o un emulatore) solo per divertimento. Altair Basic (da un ragazzo di nome Bill Gates, di una piccola start-up di due uomini chiamata Micro-Soft) interviene con una versione del 1975.

Desmond dovrebbe sintonizzarsi un po 'per assicurarsi che il FORciclo interno duri un minuto. Allora, tutti sapevano che i loop occupati erano sbagliati, ma tutti li usavano!

1 REM ADJUST "D" AS REQUIRED
2 LET D = 1000
3 PRINT "4 8 15 16 23 42"
4 FOR A = 0 TO 105 * 60
5 REM THIS LOOP SHOULD LAST ONE MINUTE +/- 0.05 SECONDS
6 FOR B = 0 TO D
7 LET C = ATN(0.25)
8 NEXT
9 NEXT
10 GOTO 3

In alternativa, Desmond potrebbe installare la scheda 88-RTC (assemblata dai componenti !: http://www.classiccmp.org/altair32/pdf/88-virtc.pdf ) e ottenere l'accesso tramite interruzioni a un orologio in tempo reale che si avvia la linea elettrica o il cristallo interno.

Avrebbe bisogno di scrivere una routine di interrupt per gestire l'ingresso di clock, che a sua volta potrebbe aggiornare una porta, dire che ogni 59 secondi porta a terra per un secondo, quindi si alza in alto.

Altair Basic aveva una WAITfunzione, quindi il codice sarebbe stato semplificato in modo simile al seguente (non sono riuscito a trovare un elenco di porte, quindi ho scelto 125 nella speranza che non venisse utilizzato):

1 PRINT "4 8 15 16 23 42"
2 FOR A = 0 TO 105 * 60
3 WAIT 125,0
4 WAIT 125,255
5 NEXT
6 GOTO 1

Questa era in realtà una piccola domanda divertente, tornando in alcuni computer davvero rudimentali. La pazienza che avevano avuto quei vecchi (incluso me)!


2
Ah, loop occupati ... +1
Geobits

4
Hmm, Desmond, Altair ... C'è una lingua chiamata "Ezio" per caso?
Kroltan,

10

Assemblatore PDP-11 per Unix System 6 - 73 68 74 caratteri

Parlando degli anni '70, è obbligatorio onorare Unix e l'hardware da cui tutto è iniziato!

s:mov $1,r0
sys write;m;18
mov $6240.,r0
sys 43
br s
m:<4 8 15 16 23 42;>

Puoi facilmente eseguirlo qui (ma prima devi riscoprire le gioie dell'uso edper inserire il testo - nel mio caso specifico, ho anche dovuto scoprire come modificare effettivamente il testo in esso :)).

Assemblato diventa 108 byte.

# cat mini.as
s:mov $1,r0
sys write;m;18
mov $6240.,r0
sys 43
br s
m:<4 8 15 16 23 42;>
# as mini.as
# ls -l a.out mini.as
-rwxrwxrwx  1 root      108 Oct 10 12:36 a.out
-rw-rw-rw-  1 root       74 Oct 10 12:36 mini.as
# od -h a.out
0000000 0107 0022 0000 0000 0018 0000 0000 0000
0000020 15c0 0001 8904 0012 0010 15c0 0004 8923
0000040 01f7 2034 2038 3531 3120 2036 3332 3420
0000060 3b32 0000 0000 0000 0002 0000 0000 0000
0000100 0000
0000120 0000 0000 0073 0000 0000 0000 0002 0000
0000140 006d 0000 0000 0000 0002 0012
0000154 
# ./a.out
4 8 15 16 23 42;

1
Rimuovi \ n per 2 personaggi in meno, non ha detto che doveva essere in righe separate. :)
Andrew Robinson,

@AndrewRobinson: sembra un po 'ingiusto, tutto l'output che segue avrà i 4 bash insieme a 42 ... Potrei invece cambiare \ n (due caratteri) con un punto e virgola. Inoltre, msgè dispendioso, posso andare con m(radendo altri 4 byte).
Matteo Italia,

1
Risparmieresti una lettera e una parola di istruzione usando brinvece di jmp, vero? Inoltre, write richiede il descrittore di file in r0 - sembra che tu abbia 1 (o 2) in esso per il tuo primo ciclo, ma lo stai distruggendo con il tuo tempo di sonno.
Casuale 832,

@ Random832: wops, probabilmente ha funzionato quando l'ho provato perché ho usato 1 o 2 come tempo di sospensione per provare rapidamente se ha funzionato. Corretto su questo br, grazie a quello e ad altri trucchi (principalmente tagliando su spazi bianchi e usando ottale quando possibile) siamo arrivati ​​a 74 caratteri anche aggiungendo il primo mov.
Matteo Italia,

8

LOGO, 61 byte (possibilmente) o 48 byte (probabilmente no)

Sfortunatamente, non sono riuscito a trovare una copia online di The LOGO System: Preliminary Manual (1967) di BBN, o qualsiasi riferimento del MIT Logo Group (anni '60 +). Il logo Apple di LCSI è un po 'troppo recente (~ 1980). Tuttavia, sulla base di libri online, all'epoca probabilmente funzionavano alcune varianti delle seguenti. Nota che ATTENDERE 60 attende 1 secondo, non 60.

TO a
LABEL "l
PRINT [4 8 15 16 23 42]
WAIT 381600
GO "l
END
a

Possiamo fare un po 'meglio con l'ottimizzazione delle chiamate di coda, anche se probabilmente al momento non era disponibile.

TO a
PRINT [4 8 15 16 23 42]
WAIT 381600
a
END
a

3
TCO era assolutamente disponibile al momento. (Sì, lo so per esperienza.) Il TCO era la norma per Lisp (e poi Scheme); solo di recente è diventato esotico.
rici,

7

CBM BASIC 1.0, 52 38 caratteri, tokenizzato a 45 31 byte

1?"4 8 15 16 23 42":fOa=1to185^3:nE:rU

CBM BASIC 1.0 è stato introdotto con il PET Commodore nell'ottobre 1977. I comandi sarebbero normalmente mostrati in caratteri grafici maiuscoli e CBM, ma li ho elencati qui in minuscolo + maiuscolo per motivi di facilità (sia miei che tuoi! :-) ). Si noti inoltre che ^ verrebbe effettivamente visualizzato come ↑. Detokenized, dopo aver elencato questo con LISTquesto si tradurrebbe in:

1 PRINT "4 8 15 16 23 42":FOR A=1 TO 185^3:NEXT:RUN

Il 6502 del PET funzionava a 1 MHz, quindi il completamento dovrebbe richiedere circa 105 minuti.

Modifica : mi sono reso conto che i loop nidificati non erano realmente necessari e avevo calcolato male i miei token. Ancora non abbastanza per vincere (e troppo tardi, per l'avvio), ma almeno è meglio.


7

Pascal - 107 95 byte

PROGRAM S;USES CRT;BEGIN WHILE TRUE DO BEGIN WRITELN('4 8 15 16 23 42');DELAY(6300000);END;END.

Versione non golfata:

PROGRAM S;
USES CRT;
BEGIN
    WHILE TRUE DO
    BEGIN
        WRITELN('4 8 15 16 23 42');
        DELAY(6300000); { 105 minutes * 60 seconds * 1000 milisseconds }
    END;
END.

4

Avanti , 50 byte

Sebbene FORTH-79 sia la prima versione standardizzata, il linguaggio era in sviluppo a partire dal 1968 ed era utilizzabile su IBM 1130. Era utilizzato anche su altri sistemi prima del 1977. Potrei fare un po 'più di ricerca per assicurarmi che tutte queste parole fossero disponibili, ma sono abbastanza certo che questo sia abbastanza semplice da esistere da allora. Questi erano tutti disponibili da FORTH-79, di sicuro.

Cicli per sempre, in attesa 6420000 millisecondi tra la stampa di stringhe. Nessuna nuova riga viene stampata.

: F 0 1 DO 6420000 MS ." 4 8 15 16 23 42" LOOP ; F

4

Smalltalk, 95 (o 68 se è consentita la scappatoia)

È in circolazione dal 1972

|i|[i:=0.[i<5] whileTrue: [(Delay forSeconds: 6480) wait.Transcript show: '4 8 15 16 23 42'.]]fork

Nessuna esperienza con questo, l'ho visto su wikipedia: P
Ho cercato online come eseguire il loop e ritardare, la sintassi dovrebbe essere corretta ma non è stato possibile trovare un modo per eseguirlo.

Possibile scappatoia

Dovrebbe stampare la sequenza ogni 108 minuti, ma non indica che deve essere di 108 minuti.
Ciò potrebbe ridurre il codice

|i|[i:=0.[i<5] whileTrue: [Transcript show: '4 8 15 16 23 42'.]]fork

Il codice stamperà la sequenza senza intervalli, quindi è garantito che stamperà anche dopo 108 minuti.


9
Ma il problema dice Wait some time between 104 and 108 minutes, quindi non credo che la scappatoia sia possibile.
Matsjoyce,

@matsjoyce Ecco perché ne ho pubblicato uno con un timer e uno senza :)
Teun Pronk

3
Mentre la tua scappatoia non funziona per la sfida, mi chiedo se Desmond sarebbe in grado di cavarsela. Sono abbastanza sicuro che il computer non fa nulla a meno che non sia tra la finestra 104-108 minuti, quindi ignorerebbe semplicemente il "4 8 15 16 23 42" in più che viene inserito. Tuttavia, sono sicuro che Walt sarebbe molto confuso da tutti i numeri che qualcuno gli sta inviando. = D
DJMcMayhem

3

SAS, 82 75 69

data;
file stdout;
a:;
put "4 8 15 16 23 42";
a=sleep(6300,1);
goto a;
run;

Non è un tipico linguaggio del golf, ma penso che sia idoneo per questa sfida, supponendo che file stdoutfosse valido nel SAS dell'era del 1977.

miglioramenti:

  • data _null_;-> data;salva 7 caratteri (e ora produce un set di dati vuoto e stampa su stdout).
  • Sostituito loop do-while con goto - salva 6 caratteri

3

Thompson shell, 1971 (1973 per comando sleep)

43 byte

: x
echo 4 8 15 16 23 42
sleep 6480
goto x

Dal momento che la shell Bourne, sebbene esistesse nel 1977, non era in una versione rilasciata di Unix fino alla v7 del 1979. La shell Unix originale non aveva alcun comando di controllo loop fantasia. (Se si desidera terminare un ciclo, è possibile utilizzare il ifcomando per saltare il goto.)


Avrebbe avuto exec $0un piccolo risparmio goto?
Neil,

2

C, 50 byte

Più breve dell'altra soluzione C e quindi non un duplicato. In realtà l'ho scritto prima di notare il commento (quasi) identico di Digital Trauma sull'altra soluzione C.

main(){for(;;sleep(6240))puts("4 8 15 16 23 42");}

Direi che si tratta di una banale modifica / miglioramento rispetto all'altra soluzione, e quindi è un inganno. Che tu abbia visto o meno il commento prima di scrivere questo è irrilevante.
Mego

1

COBOL, 240 byte

Sì, lo spazio bianco principale è significativo. Compila ed esegui come cobc -x save.cob; ./save. (L' -xopzione produce un eseguibile anziché una lib condivisa e quindi non penso che debba essere contato.)

       IDENTIFICATION DIVISION.
       PROGRAM-ID.S.
       PROCEDURE DIVISION.
           PERFORM UNTIL 1<>1
              DISPLAY"4 8 15 16 23 42"
              CALL"C$SLEEP"USING BY CONTENT 6402
           END-PERFORM.
           GOBACK.

Se vogliamo essere noiosi, possiamo aggiungere l' --freeopzione di compilazione per il codice in formato libero, quindi 158 + 6 = 164 byte, ma è improbabile che funzioni nel '77.

IDENTIFICATION DIVISION.
PROGRAM-ID.S.
PROCEDURE DIVISION.
PERFORM UNTIL 1<>1
DISPLAY"4 8 15 16 23 42"
CALL"C$SLEEP"USING BY CONTENT 6402
END-PERFORM.
GOBACK.

1

ALGOL 60/68 / W, 74 47 50 byte

Esegui questo programma completo con a68g save.a68, usando algol68g.

ALGOL non ha un modo integrato di dormire ma possiamo eseguire essenzialmente /bin/sleep:

DO print("4 8 15 16 23 42");system("sleep 6380")OD

Vecchia risposta:

ALGOL non ha un sonno incorporato, quindi possiamo abusare pingche è sicuramente su un Unix del tempo (idea da qui ) per 74 69 byte .

DO print("4 8 15 16 23 42");system("ping 1.0 -c1 -w6240>/dev/null")OD

1
È intelligente! Si potrebbe dire che il programma è "sleep-ping". : P
DJMcMayhem

@DrGreenEggsandIronMan Ha!
cat

@DrGreenEggsandIronMan Dov'è la linea per dove systemva bene e non va bene? Stai bene, system("ping ...")ma la sfida dice che non posso usare systemda C per es. Comandi bash. ALGOL sta facendo la stampa, ma non ho un altro modo rispetto ping(8)o sleep(1)per dormire.
cat

Bene, quando ho scritto la sfida, ho cercato su Google e ho visto che bash è uscito nel 89, quindi ho pensato "Usare bash è barare!". Suppongo che il problema maggiore sia se funzionerebbe o meno system("sleep")su un sistema operativo da quel momento. Modifica il post.
DJMcMayhem

1
Non penso che ci fosse un ping per NCP. Internet non è passato a TCP / IP fino agli inizi degli anni '80 e la prima menzione della richiesta Echo ICMP sembra essere in RFC777, datata aprile 1981.
ninjalj,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.