Vous êtes Desmond Hume. Au cours des 3 dernières années, vous et votre partenaire, Kelvin, avez été esclaves d'un ordinateur qui nécessite de saisir une séquence très spécifique toutes les 108 minutes pour sauver le monde.

4 8 15 16 23 42

Votre partenaire est décédé il y a 40 jours (à cause d'un malheureux accident impliquant la tête de Kelvin et un gros rocher) et vous n'avez personne à qui parler. Personne pour entrer les numéros pour vous. Personne pour briser la monotonie. Au début, ce n'était pas si grave, mais vous ne pouvez plus gérer le silence. Et si vous devez écouter "Créer votre propre genre de musique" une fois de plus, vous allez crier.

Vous décidez que vous devez sortir. Pour échapper à. Vous décidez de construire un radeau et de naviguer au large de l'île. Mais alors vous réalisez la mauvaise nouvelle: vous êtes coincé ici. Vous devez continuer à sauver le monde.

Mais alors vous réalisez la bonne nouvelle: vous êtes un programmeur! Vous pouvez automatiser sauver le monde! Excité, vous vous précipitez sur votre ordinateur et, grâce à votre savoir-faire python, vous créez un script rapide qui vous permet de saisir les chiffres.

import time

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

Rapide, simple, fiable, court et facile. Tout ce qu'un bon script Python devrait être. Mais ensuite, lorsque vous essayez de le tester, vous obtenez une erreur.

Bad command or file name.

Hein, étrange. Oh bien, essayons c ++.

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

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

Non! C ++ n'est pas trouvé non plus. Vous essayez toutes les langues auxquelles vous pouvez penser. Javascript, Ruby, Perl, PHP, C #. Rien. Cet ordinateur a été fabriqué avant toutes les langues populaires du jour.

Le défi

Vous devez écrire un programme qui va:

1) Imprimez exactement ceci: "4 8 15 16 23 42" (sans guillemets)

2) Attendez quelque temps entre 104 et 108 minutes. (Selon le wiki perdu )

3) Répétez pour toujours. (Ou jusqu'à ce que vous réalisiez que tout cela est une arnaque complexe, et que vous êtes bloqué dans un vide étrange dû à une écriture paresseuse et à des questions pour lesquelles vous n'avez pas de réponse. Merci, JJ Abrams!)

Cependant, il y a un problème: vous DEVEZ utiliser une langue que l'ordinateur de la station swan serait réellement capable de faire fonctionner. En admettant que

A) L’ordinateur était à jour au moment de la construction,

B) Il n'y a eu aucune mise à jour du logiciel de l'ordinateur et

C) Il n'y a pas de connexion Internet disponible (ce qui signifie que vous ne pouvez pas télécharger Golfscript ...),

et en nous prononçant au mieux pour la date de construction de The Swan Station, (Encore une fois, The Lost Wiki. )

Cela signifie que vous devez utiliser une langue qui a été publiée pour la première fois le ou avant le 31 décembre 1977.

Quelques précisions sur les règles:

• L'inclusion de bibliothèques est acceptable, mais la même règle s'applique (les bibliothèques doivent être antérieures à 1977).

• Vous n'avez pas à vous soucier de la compatibilité du système d'exploitation.

• Si vous utilisez systemou l'équivalent dans vos langues, vous devez prouver que toutes les commandes système que vous utilisez auraient été disponibles avant 1978. Un article de Wikipédia est probablement le meilleur moyen de le prouver.

• Peu importe le moment où vous démarrez le programme, dans la mesure où il finit par alterner impression et sommeil. (print-sleep-print-sleep ... et sleep-print-sleep-print ... sont acceptables.)

C'est Code-Golf, donc la réponse la plus courte en octets est gagnante.

APL , 28 24 25 24 octets

Cela a fonctionné dans les APL * PLUS de STSC et dans SharpAPL d'IPSA en 1977, et bien que les APL modernes offrent une multitude de nouvelles fonctionnalités, cela fonctionne encore aujourd'hui sur tous les principaux APL:

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

La première ligne imprime la somme cumulée des nombres affichés, qui sont les nombres requis. La deuxième ligne d e l ays 6360 secondes (106 minutes), puis tire le signum de ce (1, évidemment), et se dirige vers cette ligne ( par exemple la précédente, à impression numéro un).

Cependant, APL \ 360 (l’APL pour IBM System / 360 ) à partir de 1966 le bat en réalité d’un octet (testé sur l’ émulateur libre IBM / 370 ):

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

Le rayon de sommeil I (" IBM " - l'obtenir?) Prend un temps d' attente de ¹ ⁄ ₃₀₀ ^ème de seconde, nous attendons donc 19 × 10 ⁵ jiffies = 105 minutes et 33 ¹ ⁄ ₃ secondes.

MUMPS - 30 caractères, vers 1966 (Première norme ANSI en 1977)

Ma première tentative de code golf, c'est parti!

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

MUMPS est toujours un langage populaire pour le logiciel de DSE, créé par le Massachusetts General Hospital à Boston. L'implémentation la plus connue est Epic Systems à Vérone, WI.

TECO, 53 octets

TECO (éditeur et correcteur de texte [auparavant sur bande]) est un éditeur de texte datant de 1962. Il peut également être utilisé pour exécuter des programmes autonomes. C'est l'éditeur de pointe pour PDP, VAXen, etc.

Selon le manuel TECO, la ^Hcommande donne l'heure du jour. Assurez-vous de vérifier votre système d'exploitation et votre alimentation, l'unité de temps pouvant varier en fonction de votre machine:

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)

Le programme suivant fonctionne sur les systèmes où l'heure de la journée est mesurée en secondes / 2:

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

Notez que ^Het $doit être entré en frappant, respectivement, CONTROL-H et ESCAPE.

Les nombres dans le programme peuvent être ajustés pour les machines suivantes:

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

Bourne shell, 47 45 octets

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

C, 54 52 octets

main(){while(1)puts("4 8 15 16 23 42"),sleep(6360);}

FORTRAN 66 ( 108 98 octets)

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

Il est certain que l’ordinateur en question avait le compilateur FORTRAN, car il dominait les domaines scientifiques et techniques de l’époque. Je suis né 18 ans après l'année éponyme, mais lors de mon programme de mathématiques à l'université, nous avons appris le Fortran. Une conférence amusante nous avons appris comment programmer des cartes perforées. Ce n'est pas si facile de le formater correctement ici, il devrait y avoir 6 espaces vides avant chaque commande et je ne pouvais trouver qu'une référence à la fonction Sleep pour Fortran 77 mais elle aurait déjà existé dans Fortran IV et 66.

PS: Nous pourrions supprimer un octet en utilisant l’étiquette 1 au lieu de l’étiquette 42.

PPS: Si l'ordinateur en question utilise des cartes à perforer pour la saisie de programme, vous n'avez pas de chance et les octets n'ont plus d'importance: D.

MacLisp, 47 46 octets

(do()(())(print"4 8 15 16 23 42")(sleep 6360))

Toutes les constructions sont tirées du manuel de référence de 1974 (PDF) . Pas testé, car je n'ai pas d'interprète MacLisp.

Altair Basic

Desmond et Kelvin auraient certainement eu un Altair 8800 (ou un émulateur) juste pour le fun. Altair Basic (d'un certain Bill Gates, de quelque petite start-up à deux personnes appelée Micro-Soft) fait son entrée en force avec une sortie en 1975.

Desmond aurait besoin d'ajuster un peu pour que la FORboucle interne dure une minute. À l'époque, tout le monde savait que les boucles occupées étaient fausses, mais tout le monde les utilisait!

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

En guise d'alternative, Desmond pourrait installer la carte 88-RTC (assemblée à partir de composants!: Http://www.classiccmp.org/altair32/pdf/88-virtc.pdf ) et avoir accès à une horloge temps réel en interrompant les interruptions. la ligne électrique ou le cristal interne.

Il aurait besoin d'écrire une routine d'interruption pour gérer l'entrée d'horloge, ce qui pourrait à son tour mettre à jour un port, disons toutes les 59 secondes, mettre à terre pendant une seconde, puis augmenter.

Altair Basic avait une WAITfonction, donc le code serait simplifié comme suit (je ne pouvais pas trouver une liste de ports, alors j'ai simplement choisi 125 dans l'espoir qu'elle ne soit pas utilisée):

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

C'était en fait une petite question amusante, remontant dans des ordinateurs vraiment rudimentaires. La patience que ces anciens (y compris moi) ont dû avoir!

Assembleur PDP-11 pour Unix System 6 - 73 68 74 caractères

À propos des années 70, il est impératif d'honorer Unix et le matériel où tout a commencé!

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

Vous pouvez facilement l'exécuter ici (mais vous devez d'abord redécouvrir les joies de l' edinsertion de texte - dans mon cas particulier, j'ai même dû découvrir comment modifier le texte qu'il contient :)).

Assemblé, il devient 108 octets.

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

LOGO, 61 octets (éventuellement) ou 48 octets (probablement pas)

Malheureusement, je n'ai pas réussi à trouver une copie en ligne de The LOGO System: Manuel préliminaire (1967) de BBN, ni aucune référence du MIT Logo Group (1960s +). Le logo Apple par LCSI est un peu trop récent (~ 1980). Toutefois, sur la base de livres en ligne, certaines des variantes suivantes ont probablement fonctionné à l’époque. Notez que WAIT 60 attend 1 seconde, pas 60.

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

Nous pouvons faire un peu mieux avec l’optimisation de l’appel final, même si cette option n’était probablement pas disponible à l’époque.

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

CBM BASIC 1.0, 52 38 caractères, numérotés en un nombre total de 45 à 31 octets

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

CBM BASIC 1.0 a été introduit avec le Commodore PET en octobre 1977. Les commandes sont normalement affichées en majuscules et en caractères graphiques CBM, mais je les ai énumérées ici en minuscules + majuscules pour plus de facilité (les miennes comme les vôtres!) :-) ). Notez également que le ^ serait en fait affiché comme ↑. Détokenized, après avoir énuméré ceci avec LISTceci, il en résulterait:

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

Le 6502 du PET fonctionnait à 1 MHz. Cela devrait donc durer environ 105 minutes.

Edit : Réalisé que les boucles imbriquées n'étaient pas vraiment nécessaires et j'avais mal calculé mes jetons. Encore pas assez pour gagner (et trop tard pour démarrer), mais au moins c'est mieux.

Pascal - 107 95 octets

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

Version non-golfée:

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ème , 50 octets

Bien que FORTH-79 soit la première version normalisée, le langage était en développement à partir de 1968 et était utilisable sur IBM 1130. Il était également utilisé sur d’autres systèmes avant 1977. Je ferai peut-être un peu plus de recherches pour vérifier que ces mots étaient tous disponibles, mais je suis à peu près sûr que cela est suffisamment fondamental pour exister à ce moment-là. Ceux-ci étaient tous disponibles par FORTH-79, à coup sûr.

Boucle pour toujours, en attendant 6420000 millisecondes entre l’impression de chaîne. Aucune nouvelle ligne n'est imprimée.

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

Smalltalk, 95 (ou 68 si une échappatoire est autorisée)

Été autour depuis 1972

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

Aucune expérience avec celui-ci, vu sur Wikipédia: P
Regardé en ligne comment faire pour boucler et retarder, la syntaxe devrait être correcte, mais n'a pas pu trouver un moyen de l'exécuter.

Échappatoire possible

La séquence doit être imprimée toutes les 108 minutes, mais cela n’indique pas qu’elle doit durer 108 minutes.
Cela pourrait rendre le code plus court

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

Code imprimera la séquence sans intervalle, il est donc garanti qu’elle sera imprimée aussi après 108 minutes.

SAS, 82 75 69

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

Ce n'est pas une langue de golf typique, mais je pense que cela répond à ce défi, à supposer qu'il file stdoutsoit valable dans les SAS de 1977.

Améliorations:

• data _null_;-> data;enregistre 7 caractères (et produit maintenant un jeu de données vide ainsi qu’une impression sur stdout).
• Boucle do-while remplacée par goto - enregistre 6 caractères

Coquille de Thompson, 1971 (1973 pour la commande de sommeil)

43 octets

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

Depuis le shell Bourne, même s’il existait en 1977, il n’a été publié dans la version 7 d’Unix qu’en 1979. Le shell Unix original ne comportait aucune commande de contrôle de boucle sophistiquée. (Si vous souhaitez mettre fin à une boucle, vous pouvez utiliser la ifcommande pour ignorer le goto.)

C, 50 octets

Plus court que l'autre solution C, et donc pas un doublon. En fait, j'ai écrit ceci avant de remarquer le commentaire (presque) identique de Digital Trauma sur l'autre solution C.

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

COBOL, 240 octets

Oui, les principaux espaces sont significatifs. Compiler et courir comme cobc -x save.cob; ./save. (L' -xoption produit un exécutable par opposition à une lib partagée et je ne pense donc pas qu'il faille la compter.)

       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.

Si nous voulons être ennuyeux, nous pouvons ajouter l' --freeoption de compilation pour le code au format libre, puis 158 + 6 = 164 octets, mais il est peu probable que cela fonctionne à nouveau en 1977.

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.

ALGOL 60/68 / W, 74 47 50 octets

Exécutez ce programme complet avec a68g save.a68, using algol68g.

ALGOL n'a pas de méthode intégrée pour dormir, mais nous pouvons exécuter essentiellement /bin/sleep:

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

Ancienne réponse:

ALGOL ne possède pas de sommeil intégré, nous pouvons donc abuser de pingce qui est sûrement un Unix du temps (idée à partir d’ ici ) de 74 69 octets .

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