Você é Desmond Hume. Nos últimos 3 anos, você e seu parceiro, Kelvin, foram escravos de um computador que requer que uma sequência muito específica seja inserida a cada 108 minutos para salvar o mundo.

4 8 15 16 23 42

Seu parceiro morreu há 40 dias (devido a um acidente infeliz envolvendo a cabeça de Kelvin e uma grande pedra) e você não tem com quem conversar. Ninguém para inserir os números para você. Ninguém para quebrar a monotonia. No começo não foi tão ruim, mas você não aguenta mais o silêncio. E se você tiver que ouvir "Faça seu próprio tipo de música" mais uma vez, vai gritar.

Você decide que precisa sair. Escapar. Você decide construir uma jangada e sair da ilha. Mas então você percebe as más notícias: você está preso aqui. Você precisa continuar salvando o mundo.

Mas então você percebe as boas notícias: você é um programador! Você pode automatizar salvando o mundo! Animado, você corre para o computador e, usando suas habilidades confiáveis ​​em python, cria um script rápido para inserir os números para você.

import time

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

Rápido, simples, confiável, curto e fácil. Tudo o que um bom script python deve ser. Mas então, quando você tenta testá-lo, você recebe um erro.

Bad command or file name.

Estranho. Oh bem, vamos tentar c ++.

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

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

Não! C ++ também não foi encontrado. Você tenta todos os idiomas em que consegue pensar. Javascript, Ruby, Perl, PHP, C #. Nada. Este computador foi fabricado antes de todos os idiomas populares do dia.

O desafio

Você deve escrever um programa que:

1) Imprima exatamente isso: "4 8 15 16 23 42" (sem aspas)

2) Aguarde um tempo entre 104 e 108 minutos. (De acordo com o The Lost Wiki )

3) Repita para sempre. (Ou até você perceber que tudo isso é uma farsa elaborada e que você está preso em um limbo estranho devido a uma escrita preguiçosa e fazendo perguntas para as quais você não tem respostas. Obrigado JJ Abrams!)

No entanto, há um problema: você DEVE usar um idioma que o computador na estação de cisnes realmente seja capaz de executar. Assumindo que

A) O computador estava atualizado no momento da construção,

B) Não houve atualizações no software dos computadores e

C) Não há conexão à Internet disponível (o que significa que você não pode baixar o Golfscript ...),

e adivinhando a data de construção da Estação Swan (novamente, The Lost Wiki. )

Isso significa que você deve usar um idioma que foi lançado pela primeira vez em 31 de dezembro de 1977.

Alguns esclarecimentos sobre regras:

• A inclusão de bibliotecas é aceitável, mas a mesma regra se aplica (as bibliotecas devem ser anteriores a 1977).

• Você não precisa se preocupar com a compatibilidade do sistema operacional.

• Se você usa systemou seu idioma é equivalente, deve provar que qualquer comando do sistema que você usa estaria disponível antes de 1978. Um artigo da wikipedia é provavelmente a melhor maneira de provar isso.

• Não importa quando você inicia o programa, desde que ele termine em um padrão alternado de impressão e suspensão. (print-sleep-print-sleep ... e sleep-print-sleep-print ... são aceitáveis.)

Este é o Code-Golf, pelo que a resposta mais curta em bytes vence.

APL , 28 24 25 24 bytes

Isso funcionou no APL * PLUS da STSC e no SharpAPL da IPSA em 1977, e embora os APLs modernos tenham uma tonelada de novos recursos, isso ainda funciona em todos os principais APLs da atualidade:

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

A primeira linha imprime a soma cumulativa dos números mostrados, que são os números necessários. A segunda linha d e l ays 6360 segundos (106 minutos), em seguida, converte o signum de que (1, obviamente), e vai para que a linha (isto é, o anterior, o número-a imprimir um).

No entanto, o APL \ 360 (o APL para IBM System / 360 ) de 1966 na verdade supera-o em um byte (testado no emulador IBM / 370 gratuito ):

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

O sono I-beam ( " IBM " -? Obtê-lo) converte o tempo de espera em jiffies de ¹ / ₃₀₀ ^th de um segundo, então vamos esperar 19 × 10 ⁵ jiffies = 105 minutos e 33 ¹ / ₃ segundo.

MUMPS - 30 caracteres, por volta de 1966 (padrão ANSI pela primeira vez em 1977)

Minha primeira tentativa no código de golfe, aqui vamos nós!

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

O MUMPS ainda é um idioma popular para o software EHR, criado pelo Massachusetts General Hospital em Boston. A implementação mais conhecida é a Epic Systems em Verona, WI.

TECO, 53 bytes

O TECO (Editor e Corretor de Texto [anteriormente Fita]) é um editor de texto com origem em 1962. Também pode ser usado para executar programas independentes. É o editor de última geração para PDPs, VAXen, etc.

De acordo com o manual do TECO, o ^Hcomando indica a hora do dia. Verifique o sistema operacional e a fonte de alimentação, pois a unidade de tempo pode variar de acordo com a sua 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)

O programa a seguir funciona em sistemas em que a hora do dia é medida em segundos / 2:

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

Observe que ^He $deve ser inserido pressionando, respectivamente, CONTROL-H e ESCAPE.

Os números no programa podem ser ajustados para as seguintes 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...

Shell Bourne, 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

É certo que o computador em questão possuía o compilador FORTRAN, pois dominava os campos científicos e de engenharia da época. Nasci 18 anos após o ano homônimo, mas durante o meu programa de matemática na universidade aprendemos FORTRAN. Em uma palestra divertida, aprendemos a programar em cartões perfurados. Não é tão fácil formatá-lo corretamente aqui, deve haver 6 espaços em branco antes de cada comando e eu só consegui encontrar uma referência à função Sleep para o Fortran 77, mas ela já deveria existir no Fortran IV e 66.

PS: Podemos descartar um Byte usando o rótulo 1 em vez do rótulo 42.

PPS: Se o computador em questão usa cartões perfurados para a entrada do programa, você está sem sorte e os bytes não importam mais: D.

MacLisp, 47 46 bytes

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

Todas as construções retiradas do manual de referência de 1974 (PDF) . Não testei, pois não tenho um intérprete de MacLisp.

Altair Basic

Com certeza, Desmond e Kelvin teriam um Altair 8800 (ou um emulador) apenas por diversão. Altair Basic (de um cara chamado Bill Gates, de uma pequena start-up chamada Micro-Soft) entra em cena com um lançamento em 1975.

Desmond precisaria ajustar um pouco para garantir que o FORloop interno dure um minuto. Naquela época, todo mundo sabia que os loops ocupados estavam errados, mas todos os usavam!

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 poderia instalar a placa 88-RTC (montada a partir de componentes !: http://www.classiccmp.org/altair32/pdf/88-virtc.pdf ) e obter acesso através de interrupções a um relógio em tempo real correndo a linha de energia ou cristal interno.

Ele precisaria escrever uma rotina de interrupção para lidar com a entrada do relógio, que por sua vez poderia atualizar uma porta, digamos que a cada 59 segundos traga para o solo por um segundo e depois suba alto.

O Altair Basic tinha uma WAITfunção, então o código seria simplificado para algo como o seguinte (não consegui encontrar uma lista de portas, então escolhi 125 na esperança de que não fosse utilizado.):

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 foi realmente uma pequena pergunta divertida, voltando a alguns computadores realmente rudimentares. A paciência que os veteranos (inclusive eu) devem ter!

Montador PDP-11 para Sistema Unix 6 - 73 68 74 caracteres

Falando sobre os anos 70, é obrigatório homenagear o Unix e o hardware onde tudo começou!

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

Você pode executá-lo facilmente aqui (mas primeiro você precisa redescobrir as alegrias de usar edpara inserir o texto - no meu caso específico, eu até tive que descobrir como realmente editar o texto nele :)).

Montado, ele se torna 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;

LOGO, 61 bytes (possivelmente) ou 48 bytes (provavelmente não)

Infelizmente, não consegui encontrar uma cópia on-line do The LOGO System: Preliminary Manual (1967) da BBN, ou qualquer referência do MIT Logo Group (década de 1960 +). O logotipo da Apple por LCSI é um pouco recente (~ 1980). No entanto, com base em livros on-line, algumas variações dos itens a seguir provavelmente funcionaram na época. Observe que WAIT 60 aguarda 1 segundo, não 60.

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

Podemos melhorar um pouco a otimização da chamada de cauda, ​​embora isso provavelmente não estivesse disponível no momento.

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

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

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

O CBM BASIC 1.0 foi introduzido com o Commodore PET em outubro de 1977. Os comandos normalmente seriam mostrados em caracteres gráficos maiúsculos e CBM, mas os listei aqui em letras minúsculas + maiúsculas por uma questão de facilidade (tanto a minha quanto a sua! :-) ) Observe também que o ^ seria realmente exibido como ↑. Detokenized, depois de listar isso com LISTisso resultaria em:

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

O 6502 do PET funcionava a 1 MHz, por isso deve demorar cerca de 105 minutos para ser concluído.

Edit : Percebi que os loops aninhados não eram realmente necessários e eu calculei mal meus tokens. Ainda não é suficiente para vencer (e tarde demais, para inicializar), mas pelo menos é melhor.

Pascal - 107 95 bytes

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

Versão não destruída:

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.

Adiante , 50 bytes

Embora o FORTH-79 seja a versão padronizada mais antiga, o idioma estava em desenvolvimento a partir de 1968 e era utilizável no IBM 1130. Ele foi usado em outros sistemas também antes de 1977 chegar. Posso fazer um pouco mais de pesquisa para garantir que todas essas palavras estejam disponíveis, mas tenho quase certeza de que isso é básico o suficiente para ter existido até então. Todos estavam disponíveis no FORTH-79, com certeza.

Loops para sempre, aguardando 6420000 milissegundos entre a impressão em seqüência. Nenhuma nova linha é impressa.

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

Smalltalk, 95 (ou 68, se a brecha for permitida)

Existe desde 1972

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

Nenhuma experiência com este, vi na wikipedia: P
Pesquisei on-line como fazer loop e atrasar, a sintaxe deve estar correta, mas não foi possível encontrar uma maneira de executá-lo.

Possível brecha

Ele deve imprimir a sequência a cada 108 minutos, mas não indica que deve ter 108 minutos.
Isso poderia tornar o código mais curto

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

O código imprimirá a sequência sem intervalo, por isso é garantido que também será impresso após 108 minutos.

SAS, 82 75 69

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

Não é uma linguagem típica de golfe, mas acho que se qualifica para esse desafio, assumindo que isso file stdoutera válido no SAS da era de 1977.

Melhorias:

• data _null_;-> data;salva 7 caracteres (e agora produz um conjunto de dados vazio, além de imprimir em stdout).
• Loop do-while substituído por goto - salva 6 caracteres

Thompson shell, 1971 (1973 para comando do sono)

43 bytes

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

Desde que o shell Bourne, embora existisse em 1977, não estava em uma versão lançada do Unix até a v7 em 1979. O shell original do Unix não possuía nenhum comando de controle de loop sofisticado. (Se você quiser encerrar um loop, poderá usar o ifcomando para pular o goto.)

C, 50 bytes

Mais curto que a outra solução C e, portanto, não é uma duplicata. Na verdade, eu escrevi isso antes de perceber o comentário (quase) idêntico do Digital Trauma sobre a outra solução C.

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

COBOL, 240 bytes

Sim, o espaço em branco à esquerda é significativo. Compile e corra como cobc -x save.cob; ./save. (A -xopção produz um executável em vez de uma lib compartilhada e, portanto, acho que não precisa ser contada.)

       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 quisermos ser entediantes, podemos adicionar a --freeopção de compilação para código de formato livre, 158 + 6 = 164 bytes, mas é improvável que isso funcione em 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

Execute este programa completo com a68g save.a68, usando algol68g.

O ALGOL não possui uma maneira embutida de dormir, mas podemos executar essencialmente /bin/sleep:

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

Resposta antiga:

ALGOL não tem um sono embutido, então podemos abusar, o pingque certamente está em um Unix da época (idéia daqui ) por 74 69 bytes .

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