Eres Desmond Hume Durante los últimos 3 años, usted y su compañero, Kelvin, han sido esclavos de una computadora que requiere que se ingrese una secuencia muy específica cada 108 minutos para salvar el mundo.

4 8 15 16 23 42

Su compañero murió hace 40 días (debido a un desafortunado accidente que involucró la cabeza de Kelvin y una gran roca), y no tiene con quién hablar. Nadie que ingrese los números por usted. Nadie para romper la monotonía. Al principio no fue tan malo, pero ya no puedes soportar el silencio. Y si tienes que escuchar "Make Your Own Kind Of Music" una vez más, vas a gritar.

Usted decide que necesita salir. Escapar. Decides que construirás una balsa y navegarás fuera de la isla. Pero luego te das cuenta de las malas noticias: estás atrapado aquí. Necesitas seguir salvando al mundo.

Pero luego te das cuenta de las buenas noticias: ¡eres un programador! ¡Puedes automatizar salvar el mundo! Emocionado, corres hacia la computadora y, usando tus habilidades confiables de Python, creas un script rápido para ingresar los números por ti.

import time

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

Rápido, simple, confiable, corto y fácil. Todo lo que debería ser un buen script de Python. Pero luego, cuando intentas probarlo, obtienes un error.

Bad command or file name.

Huh, extraño Oh bueno, intentemos c ++.

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

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

¡No! C ++ tampoco se encuentra. Prueba todos los idiomas que se te ocurran. Javascript, Ruby, Perl, PHP, C #. Nada. Esta computadora fue hecha antes de todos los idiomas populares del día.

El reto

Debe escribir un programa que:

1) Imprima exactamente esto: "4 8 15 16 23 42" (sin comillas)

2) Espere un tiempo entre 104 y 108 minutos. (De acuerdo con The Lost Wiki )

3) Repita para siempre. (O hasta que te des cuenta de que todo esto es una estafa elaborada, y que estás atrapado en un limbo extraño debido a la escritura perezosa y a hacer preguntas para las que no tienes respuestas. ¡Gracias JJ Abrams!)

Sin embargo, hay un inconveniente: DEBE usar un lenguaje que la computadora en la estación de cisne realmente sea capaz de ejecutar. Asumiendo que

A) La computadora estaba actualizada en el momento de la construcción,

B) No ha habido actualizaciones para el software de las computadoras, y

C) No hay conexión a Internet disponible (lo que significa que no puede descargar Golfscript ...),

y haciendo nuestra mejor conjetura para la fecha de construcción de The Swan Station, (Nuevamente, The Lost Wiki ) .

Esto significa que debe usar un idioma que se lanzó por primera vez el 31 de diciembre de 1977 o antes.

Algunas aclaraciones de reglas:

• Incluir bibliotecas está bien, pero se aplica la misma regla (las bibliotecas deben ser anteriores a 1977).

• No tiene que preocuparse por la compatibilidad del sistema operativo.

• Si usa system, o sus idiomas equivalentes, debe probar que cualquier comando del sistema que use hubiera estado disponible antes de 1978. Un artículo de Wikipedia es probablemente la mejor manera de probar esto.

• No importa cuándo inicie el programa, siempre que termine en un patrón de impresión alterna y de suspensión. (print-sleep-print-sleep ... y sleep-print-sleep-print ... son aceptables).

Este es Code-Golf, por lo que la respuesta más corta en bytes gana.

APL , 28 24 25 24 bytes

Esto funcionó en APL * PLUS de STSC y en SharpAPL de IPSA en 1977, y aunque los APL modernos tienen un montón de nuevas características, esto todavía funciona en todos los APL principales hoy en día:

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

La primera línea imprime la suma acumulativa de los números mostrados, que son los números requeridos. La segunda línea d e l ays 6360 segundos (106 minutos), y luego toma la signum de que (1, obviamente), y va a esa línea (es decir, la anterior, número-impresión de uno).

Sin embargo, APL \ 360 (el APL para IBM System / 360 ) de 1966 en realidad lo supera en un byte (probado en el emulador gratuito IBM / 370 ):

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

El I-beam del sueño (" IBM " - ¿entiendes?) Toma el tiempo de espera en segundos de ¹ ⁄ ₃₀₀ ^th de segundo, por lo que esperamos 19 × 10 ⁵ jiffies = 105 minutos y 33 ¹ ⁄ ₃ segundo.

MUMPS - 30 caracteres, alrededor de 1966 (estándar ANSI primero en 1977)

Mi primer intento de golf de código, ¡aquí vamos!

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

MUMPS sigue siendo un lenguaje popular para el software EHR, creado por el Hospital General de Massachusetts en Boston. La implementación más conocida es Epic Systems en Verona, WI.

TECO, 53 bytes

TECO (Text [anteriormente Tape] Editor and Corrector) es un editor de texto que se originó en 1962. También se puede utilizar para ejecutar programas independientes. Es el editor de vanguardia para PDP, VAXen, etc.

Según el manual de TECO, el ^Hcomando da la hora del día. Asegúrese de verificar su sistema operativo y fuente de alimentación, ya que la unidad de tiempo puede variar según su máquina:

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)

El siguiente programa funciona en sistemas donde la hora del día se mide en segundos / 2:

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

Tenga en cuenta que ^Hy $debe ingresarse presionando, respectivamente, CONTROL-H y ESCAPE.

Los números en el programa se pueden ajustar para las siguientes máquinas:

   (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 bytes

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

C, 54 52 bytes

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

FORTRAN 66 ( 108 98 Bytes)

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

Es cierto que la computadora en cuestión tenía el compilador FORTRAN, ya que dominaba los campos científicos y de ingeniería en la época. Nací 18 años después del año homónimo, pero durante mi programa de matemáticas en la universidad aprendimos FORTRAN. Una divertida lección que aprendimos a programar en tarjetas perforadas. No es tan fácil formatearlo correctamente aquí, debe haber 6 espacios en blanco antes de cada comando y solo pude encontrar una referencia a la función Sleep para Fortran 77, pero ya debería haber existido en Fortran IV y 66.

PD: Podríamos eliminar un byte usando la etiqueta 1 en lugar de la etiqueta 42.

PPS: si la computadora en cuestión usa tarjetas perforadas para la entrada del programa, no tiene suerte y los bytes ya no importan: D.

MacLisp, 47 46 bytes

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

Todas las construcciones tomadas del manual de referencia de 1974 (PDF) . Sin embargo, no lo probé ya que no tengo un intérprete de MacLisp.

Altair Basic

Por supuesto, Desmond y Kelvin habrían tenido un Altair 8800 (o un emulador) solo por diversión. Altair Basic (de un tipo llamado Bill Gates, de una pequeña empresa emergente de dos hombres llamada Micro-Soft) chilla con un lanzamiento en 1975.

Desmond necesitaría afinar un poco para garantizar que el FORbucle interno dure un minuto. En aquel entonces, todos sabían que los bucles ocupados estaban mal, ¡pero todos los usaban!

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

Como alternativa, Desmond podría instalar la placa 88-RTC (montado a partir de componentes !: http://www.classiccmp.org/altair32/pdf/88-virtc.pdf ) y obtener acceso a través de las interrupciones a un reloj de tiempo real corriendo La línea de alimentación o cristal interno.

Tendría que escribir una rutina de interrupción para manejar la entrada del reloj, que a su vez podría actualizar un puerto, digamos que cada 59 segundos se pone a tierra por un segundo, y luego subir alto.

Altair Basic tenía una WAITfunción, por lo que el código se simplificaría a algo como lo siguiente (no pude encontrar una lista de puertos, así que elegí 125 con la esperanza de que no se usara):

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

Esta fue en realidad una pequeña pregunta divertida, volviendo a algunas computadoras realmente rudimentarias. ¡La paciencia que debieron tener esos veteranos (incluyéndome a mí)!

Ensamblador PDP-11 para Unix System 6 - 73 68 74 caracteres

Hablando de los años 70, ¡es obligatorio honrar a Unix y al hardware donde todo comenzó!

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

Puede ejecutarlo fácilmente aquí (pero primero debe redescubrir las alegrías de usar edpara insertar el texto; en mi caso específico, incluso tuve que descubrir cómo editar realmente el texto en él :)).

Ensamblado se convierte en 108 bytes.

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

LOGOTIPO, 61 bytes (posiblemente) o 48 bytes (probablemente no)

Desafortunadamente, no he logrado encontrar una copia en línea de The LOGO System: Preliminary Manual (1967) de BBN, ni ninguna referencia del MIT Logo Group (1960 +). El logotipo de Apple de LCSI es demasiado reciente (~ 1980). Sin embargo, según los libros en línea, alguna variación de lo siguiente probablemente funcionó en ese momento. Tenga en cuenta que WAIT 60 espera durante 1 segundo, no 60.

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

Podemos hacer un poco mejor con la optimización de llamadas de cola, aunque esto probablemente no estaba disponible en ese momento.

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

CBM BASIC 1.0, 52 38 caracteres, tokenizado a 45 31 bytes

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

CBM BASIC 1.0 se introdujo con el Commodore PET en octubre de 1977. Los comandos normalmente se mostrarían en mayúsculas y caracteres gráficos CBM, pero los he enumerado aquí en minúsculas + mayúsculas por razones de facilidad (¡tanto mío como tuyo! :-) ) Tenga en cuenta también que ^ en realidad se mostrará como ↑. Destokenizado, después de enumerar esto con LISTesto daría como resultado:

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

El 6502 del PET funcionó a 1MHz, por lo que esto debería tomar alrededor de 105 minutos más o menos para completar.

Editar : Me di cuenta de que los bucles anidados no eran realmente necesarios y había calculado mal mis tokens. Todavía no es suficiente para ganar (y demasiado tarde, para arrancar), pero al menos es mejor.

Pascal - 107 95 bytes

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

Versión sin golf:

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.

Adelante , 50 bytes

Aunque FORTH-79 es la primera versión estandarizada, el lenguaje estaba en desarrollo a partir de 1968, y era utilizable en el IBM 1130. Se utilizó en otros sistemas también antes de que llegara 1977. Puedo investigar un poco más para asegurarme de que todas estas palabras estén disponibles, pero estoy bastante seguro de que es lo suficientemente básico como para haber existido para entonces. Todos estaban disponibles por FORTH-79, seguro.

Bucles para siempre, esperando 6420000 milisegundos entre la impresión de cadenas. No se imprime nueva línea.

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

Smalltalk, 95 (o 68 si se permite una escapatoria)

Ha estado presente desde 1972

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

Sin experiencia con este, lo vi en wikipedia: P
Busqué en línea cómo hacer un bucle y retrasarlo, la sintaxis debería ser correcta pero no pudo encontrar una manera de ejecutarla.

Posible escapatoria

Debe imprimir la secuencia cada 108 minutos, pero no indica que tiene que ser 108 minutos.
Esto podría acortar el código

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

El código imprimirá la secuencia sin intervalo, por lo que está garantizado que también se imprimirá después de 108 minutos.

SAS, 82 75 69

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

No es un lenguaje típico de golf, pero creo que califica para este desafío, suponiendo que file stdoutfuera válido en el SAS de 1977.

Mejoras:

• data _null_;-> data;guarda 7 caracteres (y ahora produce un conjunto de datos vacío e imprime en stdout).
• Reemplazado bucle do-while con goto: guarda 6 caracteres

Thompson shell, 1971 (1973 para comando de suspensión)

43 bytes

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

Dado que el shell Bourne, aunque existía en 1977, no estaba en una versión lanzada de Unix hasta la v7 en 1979. El shell original de Unix no tenía ningún comando de control de bucle sofisticado. (Si desea finalizar un ciclo, puede usar el ifcomando para omitir el goto).

C, 50 bytes

Más corto que la otra solución C, y por lo tanto no es un duplicado. De hecho, escribí esto antes de notar el comentario (casi) idéntico de Digital Trauma sobre la otra solución C.

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

COBOL, 240 bytes

Sí, el espacio en blanco líder es significativo. Compila y corre como cobc -x save.cob; ./save. (La -xopción produce un archivo ejecutable en lugar de una biblioteca compartida y, por lo tanto, no creo que deba contarse).

       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 queremos ser aburridos, podemos agregar la --freeopción de compilación para el código de formato libre, luego 158 + 6 = 164 bytes, pero es poco probable que funcione en el '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.

ALGOL 60/68 / W, 74 47 50 bytes

Ejecute este programa completo con a68g save.a68, usando algol68g.

ALGOL no tiene una manera integrada de dormir, pero podemos ejecutar esencialmente /bin/sleep:

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

Vieja respuesta:

ALGOL no tiene un sueño incorporado, por lo que podemos abusar de lo pingque seguramente está en Unix del tiempo (idea de aquí ) para 74 69 bytes .

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