4, 8, 15, 16, 23, 42

Escreva um programa que produz essa sequência de números infinitamente. No entanto, os números não devem aparecer no seu código-fonte em nenhum lugar.

O seguinte não é um programa Java válido para a saída do The Numbers porque o The Numbers aparece em seu código-fonte:

class TheNumbers {
    public static void main(String[] args) {
        for(int n = 0;;) System.out.println(
            n == 4 ? n = 8 :
            n == 8 ? n = 15 :
            n == 15 ? n = 16 :
            n == 16 ? n = 23 :
            n == 23 ? n = 42 : (n = 4)
        );
    }
}

A definição de "Os números não devem aparecer no seu código-fonte" é a seguinte:

• Você não deve usar o número 4.
• Você não deve usar o número 8.
• Você não deve usar o número 1 seguido pelo número 5.
• Você não deve usar o número 1 seguido pelo número 6.
• Você não deve usar o número 2 seguido pelo número 3.

Se seu idioma ignora certos caracteres que podem ser colocados entre os números, não é uma substituição válida. Por exemplo, se seu idioma interpreta o literal 1_5como 15, isso contará como o número 1 seguido pelo número 5.

Bases alternativas estão incluídas na restrição, por exemplo:

• O binário 100 não pode ser usado como um substituto para 4.
• O Octal 10 não pode ser usado como um substituto para 8.
• O hexadecimal F não pode ser usado como substituto de 15.

Portanto, a seguir, é um programa Java válido (mas não muito inspirado) para gerar saída do Numbers porque ele não aparece em seu código-fonte:

class TheNumbers {
    public static void main(String[] args) {
        for(int n = '*';;) {
            System.out.println(n -= '&');
            System.out.println(n *= 2);
            System.out.println(n += 7);
            System.out.println(++n);
            System.out.println(n += 7);
            System.out.println(n += 19);
        }
    }
}

Observe que nesse programa, '*'e '&'são substituídos os números inteiros 42 e 38, porque, caso contrário, os números 4 e 8 apareceriam em seu código-fonte.

A definição de "gera a sequência infinitamente" está aberta à interpretação. Assim, por exemplo, um programa que gera glifos cada vez menores até serem "infinitamente" pequenos seria válido.

Parabéns se você é capaz de gerar a sequência de alguma forma que não é basicamente codificar cada número.

• Derivando-o a uma fórmula. Minha impressão é que não existe, mas talvez exista ou possa ser falsificado.
• Corrigindo um gerador pseudo-aleatório para retornar a sequência.

Este é um concurso de popularidade, então seja criativo. A resposta com mais votos em 26 de março é a vencedora.

Java

Decidi adicionar outra entrada, pois ela é completamente diferente da minha primeira (que era mais como um exemplo).

Este programa calcula a média de uma matriz inserida pelo usuário ...

import java.util.Scanner;

public class Numbers {
    public static double getSum(int[] nums) {
        double sum = 0;
        if(nums.length > 0) {
            for(int i = 0; i <= nums.length; i++) {
                sum += nums[i];
            }
        }

        return sum;
    }

    public static double getAverage(int[] nums) { return getSum(nums) / nums.length; }
    public static long roundAverage(int[] nums) { return Math.round(getAverage(nums)); }

    private static void beginLoop(int[] nums) {
        if(nums == null) {
            return;
        }

        long avg = roundAverage(nums);
        System.out.println("enter nums for average");
        System.out.println("example:");
        System.out.print("array is " + nums[0]);
        for(int i = 1; i <= nums.length; i++) {
            System.out.print(", " + nums[i]);
        }

        System.out.println();
        System.out.println("avg is " + avg);
    }

    private static int[] example = { 1, 2, 7, 9, };

    public static void main(String[] args) {
        boolean done = false;
        while(!done) {
            try {
                int[] nums = example;
                beginLoop(nums);

                nums = getInput();
                if(nums == null) {
                    done = true;
                } else {
                    System.out.println("avg is " + getAverage(nums));
                }
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }

    static int[] getInput() {
        Scanner in = new Scanner(System.in);
        System.out.print("enter length of array to average or 0 to exit: ");
        int length = in.nextInt();
        if(length == 0) {
            return null;

        } else {
            int[] nums = new int[length];
            for(int i = 0; i <= nums.length; i++) {
                System.out.print("enter number for index " + i + ": ");
                nums[i] = in.nextInt();
            }
            return nums;
        }
    }
}

... ou faz?

java.lang.ArrayIndexOutOfBoundsException: 4
    em Numbers.getSum (Numbers.java:8)
    em Numbers.getAverage (Numbers.java:15)
    em Numbers.roundAverage (Numbers.java:16)
    em Numbers.beginLoop (Numbers.java:23)
    em Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    em Numbers.getSum (Numbers.java:8)
    em Numbers.getAverage (Numbers.java:15)
    em Numbers.roundAverage (Numbers.java:16)
    em Numbers.beginLoop (Numbers.java:23)
    em Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    em Numbers.getSum (Numbers.java:8)
    ...

Pitão

#!/usr/bin/python
lizt = ["SPOI",
        "LERS: Lo",
        "st begins with ",
        "a plane crash on",
        "a desert island and end",
        "s with its viewers stuck in limbo forever."
        ]

while True:
    for item in lizt:
        print len(item)

Editar: Conforme sugestão de nneonneo, o script agora não inclui dígitos.

Perl

Não há nada oculto no código fonte. Não. Se o código não funcionar, digite use re "eval";antes dele (obrigatório no Perl 5.18).

''=~('('.'?'.('{').(
'`'|'%').('['^'-').(
"\`"| '!').('`'|',')
.'"'. '\\' .'@'.('`'
|'.') .'=' .'('.('^'
^('`'       |"\*")).
','.("\:"& '=').','.
('^'^('`'| ('/'))).(
'^'^("\`"| '+')).','
.('^'^('`'|('/'))).(
'^'^('`'|'(')).','.(
'^'^('`'|',')).('^'^
("\`"|     '-')).','
.('^' ^('`' |'*')).(
'^'^( "\`"| (','))).
(')').     ';'.('['^
','). ('`'| ('(')).(
"\`"| ')'). ('`'|','
).('`'     |'%').'('
.'\\'.'$'.'|'."\=".(
'^'^('`'|'/'))."\)".
'\\'.'{'.'\\'."\$".(
"\["^ '/')       .((
'=')  ).+( '^'^('`'|
'.' ) ).(( (';'))).(
"\`"| '&').     ('`'
|'/') .('['^')') .((
'(')) .''. '\\'. '@'
.+(     '`'     |'.'
).')'.'\\'.'{'.('['^
'(').('`'|',').('`'|
'%').('`'|'%').('['^
'+'). '\\'.     '$'.
'_'.  '-'. '\\'. '$'
.+( ( '[') ^'/').';'
.'\\' .'$'      .''.
('['^ '/') .'='. (((
'\\') )).+ "\$". '_'
.((     ';'     )).+
'\\'.'$'.'_'.'='.'='
.('^'^('`'|'*')).'|'
.'|'.('['^'+').('['^
')'     ).(     '`'|
(( ')')) ) .('`' |((
'.'))).( '['^'/' ).+
(((     (((     '\\'
)) )))).'"'.('{' ^((
(( '[')))) ).''. (((
((       ((     '\\'
))))))).'"'.';'.('['
^'+').('['^')').('`'
|')').('`'|'.').('['
^+ '/').''.     '\\'
.+ '}'. +( "\["^ '+'
). ('[' ^"\)").( '`'
|+       ((     ')')
)).('`' |+ '.').('['
^'/').( (( '{'))^'['
).'\\'. ((       '"'
)).('!'^'+').('\\').
'"'.'\\'.'}'.(('!')^
'+').'"'.'}'.')');$:
='.'#madebyxfix#'.'=
^'~';$~='@'|"\(";#;#

Explicação em spoiler.

Este é um programa Perl simples que utiliza várias operações bit a bit e avalia a expressão regular usando o operador = ~ . O regex começa com (? { E termina com }) . No Perl, isso executa o código enquanto avalia a expressão regular - isso me permite usar eval sem realmente usá-lo. Normalmente, no entanto, antes do código para fazê-lo funcionar. Fora isso, não há muito mais para esse código. re "eval" é necessário, por razões de segurança, ao avaliar expressões regulares de strings (alguns programas mais antigos realmente pegavam expressões regulares do usuário) - mas acontece que antes do Perl 5.18 havia um bug que causava expressões dobradas constantes para trabalhar mesmo sem esse pragma - se você estiver usando o Perl 5.18, digite use re "eval";

Brainfuck

Eu sou tão ruim em arte ASCII!

++        ++++++++    +[>+>++    ++>++++
+<        <<-]>++>    >-           --<
<<        +[    >>    >.<.>++      ++.
<.        >-    --    ----.++      ++.
<.>---    -.+++++.         <.      >--
-/-./+    .<.>+.-/    -.++<<.      </]

Teste aqui: http://ideone.com/kh3DYI

Unix C

Existem muitos lugares para encontrar constantes numéricas.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <fcntl.h>
#include <pwd.h>
#include <netdb.h>

int main(void)
{
  int thenumbers[] = {
    S_IRGRP|S_IXGRP|S_IWOTH,
    ntohs(getservbyname("telnet", "tcp")->s_port),
    exp(M_E)-cos(M_PI),
    SIGTERM,
    CHAR_BIT,
    strlen(getpwuid(EXIT_SUCCESS)->pw_name)
  }, i=sizeof(thenumbers)/sizeof(*thenumbers);
  while(i--)
    printf("%d\n", thenumbers[i]);
  return main();
}

C #

A fórmula "roubada" de https://oeis.org/A130826 : a (n) é o menor número, de modo que o dobro do número de divisores de (a (n) -n) / 3 fornece o n-ésimo termo no primeiro diferenças da sequência produzida pela peneira Flavius-Josephus.

using System;
using System.Collections.Generic;
using System.Linq;

public static class LostNumberCalculator
{
    public static int GetNumber(int i)
    {
        int a = GetPairwiseDifferences(GetFlaviusJosephusSieveUpTo(100)).ElementAt(i);
        int b = FindSmallestNumberWithNDivisors(a / 2);
        return b * 3 + i + 1;
    }

    public static IEnumerable<int> GetFlaviusJosephusSieveUpTo(int max)
    {
        List<int> numbers = Enumerable.Range(1, max).ToList();

        for (int d = 2; d < max; d++)
        {
            List<int> newNumbers = new List<int>();
            for (int i = 0; i < numbers.Count; i++)
            {
                bool deleteNumber = (i + 1) % d == 0;
                if (!deleteNumber)
                {
                    newNumbers.Add(numbers[i]);
                }
            }
            numbers = newNumbers;
        }

        return numbers;
    }

    public static IEnumerable<int> GetPairwiseDifferences(IEnumerable<int> numbers)
    {
        var list = numbers.ToList();
        for (int i = 0; i < list.Count - 1; i++)
        {
            yield return list[i + 1] - list[i];
        }
    }

    public static int FindSmallestNumberWithNDivisors(int n)
    {
        for (int i = 1; i <= int.MaxValue; i++)
        {
            if (CountDivisors(i) == n)
            {
                return i;
            }
        }
        throw new ArgumentException("n is too large");
    }

    public static int CountDivisors(int number)
    {
        int divisors = 0;
        for (int i = 1; i <= number; i++)
        {
            if (number % i == 0)
            {
                divisors++;
            }
        }
        return divisors;
    }
}

class Program
{
    static void Main(string[] args)
    {
        while (true)
        {
            for (int i = 0; i < 6; i++)
            {
                int n = LostNumberCalculator.GetNumber(i);
                Console.WriteLine(n);
            }
        }
    }
}

C #

Usar o fato de que qualquer sequência de N elementos pode ser gerada por um polinômio N-1 e inserir os números envolveu muitos bipes e boops. Para referência, o polinômio I derivado é

( -9(X^5) +125(X^4) -585(X^3) +1075(X^2) -446(X) +160 ) / 40

Atribuí os fatores às variáveis ​​nomeadas para os números, por simplicidade;)

Primeira versão:

int BEEP,
// Magic numbers, do not touch.
four = -9,
eight = 125,
fifteen = -117*5, 
sixteen = 1075,
twenty_three = (-1-1337) /3,
forty_two = 320/2;


for(BEEP=0;;BEEP=++BEEP%6)
{
    Console.WriteLine( 0.025* (
        four *BEEP*BEEP*BEEP*BEEP*BEEP+ 
        eight *BEEP*BEEP*BEEP*BEEP+ 
        fifteen *BEEP*BEEP*BEEP+
        sixteen *BEEP*BEEP+
        twenty_three *BEEP+ 
        forty_two ));
}

Gostei da implicação do aumento da tensão, à medida que o número de BEEPs diminui após cada número.

Então imaginei que também poderia calcular os fatores usando bipes e boops:

int BEEEP=0, BEEP=++BEEEP ,BOOP=++BEEP,BLEEP=++BOOP+BEEP,

four = BOOP*-BOOP,
eight = BLEEP*BLEEP*BLEEP,
fifteen = BOOP*-(BOOP+(BEEP*BLEEP))*BLEEP*BOOP,
sixteen = BLEEP*BLEEP*(BOOP+(BLEEP*BEEP*BEEP*BEEP)),
twenty_three = BEEP*-((BLEEP*BOOP*BLEEP*BOOP)-BEEP),
forty_two = BEEP*BEEP*BEEP*BEEP*BEEP*BLEEP;

Foi um pouco exagerado depois disso ...

int BEEEP=default(int), BEEP=++BEEEP ,BOOP=++BEEP,BLEEP=++BOOP+BEEP;

for(--BEEEP;;BEEEP=++BEEEP%(BEEP*BOOP))
{
    Console.WriteLine(

    BOOP*(                       (BOOP*-BOOP)*BEEEP    *BEEEP*BEEEP*BEEEP    *BEEEP+(BLEEP*BLEEP*
    BLEEP)                       *BEEEP*      BEEEP*    BEEEP*                     BEEEP+
    (BOOP*                       -(BOOP+      (BEEP*    BLEEP)                    )*BLEEP
    *BOOP)                       *BEEEP*      BEEEP*    BEEEP+(BLEEP*BLEEP        *(BOOP+
    (BLEEP*                       BEEP*        BEEP*                 BEEP)))       *BEEEP*
    BEEEP+                       (BEEP*-(     (BLEEP                 *BOOP*         BLEEP
    *BOOP)                       -BEEP))      *BEEEP+                (BEEP*         BEEP*
    BEEP*BEEP*BEEP*BLEEP))/     (BEEP*((BEEP*BEEP*BEEP  *BEEP*BEEP*BEEP)-(        BEEP+BEEP))));
}

O uso do operador padrão em C # para tipos de valor permite a inicialização do BEEEP em zero. Dessa forma, nenhum literal numérico é usado no código. O algoritmo básico é o mesmo. mas os fatores são calculados em linha.

D

Não é permitido usar os números 4, 8, 15, 16, 23 ou 42 no meu código? Não tem problema, então não usarei números!

import std.stdio;

void main()
{
    while( true )
    {
        ( ',' - '('  ).writeln;
        ( '/' - '\'' ).writeln;
        ( '/' - ' '  ).writeln;
        ( '_' - 'O'  ).writeln;
        ( '^' - 'G'  ).writeln;
        ( '~' - 'T'  ).writeln;
    }
}

Javascript + HTML

Anti-golfe!

<!DOCTYPE html>
<html>
<head>
</head>
<body>
<pre>
/*hereIsTheDataPart~                    Es="5030000307000022
E2000000100000010000                    E5370000507000022200
E0010100001110000005                    E0337001010000102220
E0100010010111005033                    E7001010000102220010
E1010010111~33079900                    E1000111102221000001
E1110111~03037910100                    E0111102220010100001
E0111".replace(/~/g,                    E5);Zfillfillfillfil
Eqw=21;fq=2;fz=fq*2;                    Efl=fz*2;fm=fl*2;fw=
Efm+2; M=Math;functi                    Eon r(n,i,z){return 
Efunction(){l=i||'';                    E;for(m=0;m!=n;m++)l
E+=String.fromCharCo                    Ede(97+M.floor(M.ran
Edom()*26));return l                    E+(z||'')}};kb=r(fm,
E'/*','*'+'/');kc=r(                    Efw,'//');kd=r(20);Z
Eke=r(fw,'/*');kf=r(                    E20);kg=r(fw,'','*'+
E'/');kh=kf;ki=new Z                    EArray(21).join(' ')
E;x=[];for(n=35*ix;n                    E!=s.length;++n){x.Z
Epush(parseInt(s[n])                    E)};oo=function(){oZ
E+=z==1?kb():z==9?kc                    E():z==3?(ee.shift()
E||kd()):z==5?(y==0?                    Eke():(ee.shift()||Z
Ekf())):z==7?(y==(yl                    E-1)?kg():(ee.shift(
E)||kh())):z==0?ki:Z                    Epl.shift();}Ze=mc^2
EZthis=does*nothing;                    EZnor*does+this-haha
EZawkw0rd+space+fi11                    EZrunn1ng/out+of=stf
EZfjsddfkuhkarekhkhk                    777777777777777777*/
0;ix=typeof ix=="number"?(ix+1)%6:1;s=text();ee=[];pl=[];//2
0;q=function(n,m){return s.substr(n,m)};evl="";xl=20;yl=12//
0;while(s.length){c=s[0];m=1;if(c=='\n'){s=q(1);continue;}//
0;if(c=='E'){ev=q(0,xl);i=ev.indexOf('Z');ee.push(ev);//sd//
0;evl+=i==-1?ev.substr(1):ev.substr(1, i-1);}if(c=='0'){//sd
0;pl.push(q(0,xl*3),'','');m=3};s=q(xl*m);}eval(evl);o="";//
0;for(r=0;r!=5;++r){for(y=0;y!=yl;++y){for(n=0;n!=7;++n){//s
0;z=x[n+r*7];oo()}o+="\n"}}setTimeout(function(){text(o);//z
0;(function(){var space=' ____ ',garbage='asfdasr#@%$sdfgk';
0;var filler=space+garbage+space+garbage+space+garbage;//s//
0;})("test",1199119919191,new Date(),"xyz",30/11/1)//asdfsaf
0;eval(text());},1000);//askfdjlkasjhr,kajberksbhfsdmhbkjygk
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
</pre>
<script>
window.onload = function () {
setTimeout(function() {
    text = function (txt) { 
        pre = document.getElementsByTagName('pre')[0];
        if(!txt) {
            return pre.innerText;
        }
        pre.innerText = txt;
    }
    eval(text());
}, 1000);
}
</script>
</body>
</html>

O <pre>elemento exibe um número na sequência. Ele também contém todo o código necessário para chegar ao próximo número na sequência. Portanto, o <pre>é avaliado, o que resulta no texto da <pre>atualização para se parecer com o próximo número na sequência. Esse processo se repete indefinidamente.

Aqui está em ação!

C

Coloque seus óculos de sol em :-)

main(         i){char*s     ="*)2;,5p   7ii*dpi*t1p+"
"={pi       7,i)?1!'p)(a! (ii(**+)(o(,( '(p-7rr)=pp="
"/(('       (^r9e   n%){1 !ii):   a;pin     7,p+"
"{*sp       ;'*p*   op=p) in,**             i+)s"
"pf/=       (t=2/   *,'i% f+)0f7i=*%a       (rpn"
"p(p;       )ri=}   niipp   +}(ipi%*ti(     !{pi"
"+)sa       tp;}*   s;}+%         *n;==     cw-}"
"9{ii       i*(ai   a5n(a +fs;i   *1'7",    *p=s-
1;while(p=('T'^i)?++p:s){ for(i=1;55!=*     p;p++
)i+=(' '!=*   p);printf     ("%d ",i/       2);}}

Haskell, 1 LoC

import Data.Char; main = putStr $ unwords $ map (show . (+)(-ord 'D') . ord) $ cycle "HLST[n" 

Decidi optar por uma linha legível apenas para mostrar como Haskell é incrível. Além disso, decidi evitar todos os dígitos, apenas por precaução.

Graças à avaliação lenta embutida, o Haskell pode manipular (mapear, dividir, ingressar, filtrar ...) listas infinitamente longas. Ele ainda possui vários recursos internos para criá-los. Como uma string é apenas uma lista de caracteres, infinitamente longas também não são um mistério para Haskell.

Mathematica

Podemos responder à pergunta focando nos denominadores parciais repetidos da fração contínua periódica mostrada abaixo. Eles são o que precisamos.

Afinal, eles compreendem a sequência não terminante que estamos tentando produzir: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

Na Mathematica, obtém-se o irracional quadrático correspondente à fração contínua periódica por

FromContinuedFraction[{0, {4, 8, 15, 16, 23, 42}}]

onde 0 se refere à parte inteira implícita.

Podemos verificar invertendo a operação:

{0, {4, 8, 15, 16, 23, 42}}

Os 4 e 8 violam uma das regras do desafio. A substring 15é uma violação adicional. Podemos reformatar o irracional quadrático para satisfazer as regras.

{0, {4, 8, 15, 16, 23, 42}}

Agora pegamos a sequência de interesse:

Last[c]

{4, 8, 15, 16, 23, 42}

E imprima a lista para sempre ...

While[True, Print@Row[ContinuedFraction[(-3220235/5+Sqrt[(10611930613350/25)])/(61630/2)],"\t"]]

C / C ++

Usando apenas os personagens L, O, Se Trepetidamente nessa ordem:

int main(){for(;;)printf("%d %d %d %d %d %d\n",

    'L'-     'O'*'S'    &'T','L'  &'O'+'S'*
    'T',    'L'^  'O'  |'S'*        'T'&
    'L',    'O'*  'S'    &'T'/      'L'+
    'O',    'S'^  'T'      &'L',    'O'*
    'S'&'T'   +'L'+    'O'^'S'+     'T')   ;}

Java

Não consigo encontrar um padrão nessa sequência. Se não houver um padrão reconhecível, é melhor juntarmos alguns primos pequenos, enfiá-los no RNG interno do Java e encerrar o dia. Não vejo como isso poderia dar errado, mas, novamente, sou otimista :)

import java.util.Random;
public class LostNumbers {
    public static void main(String[] args) {
        long nut=2*((2*5*7)+1)*((2*2*3*((2*2*2*2*11)+3))+5)*
                   ((3*5*((2*3*3)+1)*((2*2*2*2*2*3)+1))+2L);
        int burner=2*2*2*5;
        while(true){
            Random dice = new Random(nut);
            for(int i=0;i<6;i++)
                System.out.print((dice.nextInt(burner)+3) + " "); // cross your fingers!
            System.out.println();
        }
    }
}

Bash one-liner

yes `curl -s "https://oeis.org/search?q=id:A$((130726+100))&fmt=text" |
grep %S | cut -d " " -f 3 | cut -d "," -f 1-6`

Quebra de linha adicionada para facilitar a leitura. (Ab) usa o fato de que estes são os seis primeiros números da sequência OEIS A130826 .

C usando nenhum número e nenhum valor de caractere

s(int x) { return x+x; }
p(int x) { return printf("%d ",x); }
main()
{
    for(;;){
    int a = s(p(s((s==s)+(p==p))));
    int b = a+s(a+p(a+a));
    putchar(b-s(p(b*a-b-s(p(s(s(p(b-(s==s))+p(b)))-(p==p))))));
    }
}

Eu gosto da ideia de usar a sequência

a[n+5] = a[n] + a[n+2] + a[n+4]

como nesta resposta . Foi encontrado através da pesquisa OEIS como sequência A122115 .

Se passarmos pela sequência ao contrário, encontraremos um quíntuplo de inicialização adequado que não contém 4, 8, 15, 16 ou 23.

Python3:

l = [3053, 937, -1396, -1757, -73]
while l[-1] != 66:
    l.append(l[-5] + l[-3] + l[-1])
while True:
    print(l[-6:-1])

Javascript

Nenhum número é uma boa jogada. Mas, em vez de imprimir a sequência uma vez por passagem no loop, imprima apenas uma vez o número por passagem.

t = "....A...B......CD......E..................FEDCBA";
b = k = --t.length;
do {
    console.log(p = t.indexOf(t[k]));
} while (k-=!!(p-k)||(k-b));

A parte inferior da sequência codifica os números a serem impressos e a parte superior da sequência codifica o próximo caractere a ser encontrado. Onde as duas partes se encontram (um único F) códigos redefinindo o ciclo.

Pitão

b=a=True;b<<=a;c=b<<a;d=c<<a;e=d<<a;f=e<<a
while a: print c,d,e-a,e,e+d-a,f+d+b

Operadores bit a bit e algumas contas simples.

Rubi

Gera os números incorporando a sequência igualmente mística 0, ∞, 9, 0, 36, 6, 6, 63 ;
Nada de bom pode vir disso.

(0..1/0.0).each{|i|puts"kw9ygp0".to_i(36)>>i%6*6&63}

C ( 54 50 caracteres)

Estou postando uma resposta de golfe, porque o golfe o torna divertido.

main(a){while(printf("%d\n","gAELMT"[a++%6]-61));}

Haskell

main = mapM_ (print . round . go) [0..]
  where
    go n = 22 - 19.2*cos t + 6*cos (2*t) - 5.3*cos (3*t) + 0.5*cos (5*t)
      where t = fromInteger (n `mod` 6) / 6 * pi

http://ideone.com/erQfcd

Edit: O que eu usei para gerar os coeficientes: https://gist.github.com/ion1/9578025

Edit: Eu realmente gostei do programa de Agrif e acabei escrevendo um equivalente Haskell enquanto descobri. Eu escolhi uma base diferente para o número mágico.

import Data.Fixed
main = mapM_ print (go (369971733/5272566705 :: Rational))
  where go n = d : go m where (d,m) = divMod' (59*n) 1

http://ideone.com/kzL6AK

Edit: Eu também gostei do seu segundo programa e acabei escrevendo uma implementação Haskell de irracionais quadráticos ;-). Usando a biblioteca e o número mágico do agrif, este programa imprimirá a sequência.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

main = F.mapM_ print xs
  where (_, xs) = qiToContinuedFraction n
        n = qi (-16101175) 1 265298265333750 770375

É assim que se pode procurar o número mágico com a ajuda da biblioteca:

> continuedFractionToQI (0, Cyc [] 4 [8,15,16,23,42])
qi (-644047) 1 424477224534 30815

O valor impresso representa o número (−644047 + 1 √424477224534)/30815. Tudo o que você precisa fazer é encontrar fatores que se livrem das seqüências de dígitos não permitidas nos números, sem alterar o valor da expressão.

C #

var magicSeed = -1803706451;
var lottery = new Random(magicSeed);
var hurleysNumbers = new List<int>();
for (int i = 0; i < 6; i++) hurleysNumbers.Add(lottery.Next(43));
while (true) Console.WriteLine(String.Join(",", hurleysNumbers));

Encontrei a semente depois de ouvir alguma estação de rádio em um vôo sobre o Pacífico.

Pitão

import math

def periodic(x):
    three_cycle = abs(math.sin(math.pi * \
        (x/float(3) + (math.cos(float(2)/float(3)*x*math.pi)-1)/9)))
    two_cycle = abs(math.sin(math.pi * x / float(2)))
    six_cycle = three_cycle + 2*two_cycle
    return round(six_cycle, 2) # Correct for tiny floating point errors

def polynomial(x):
    numerator = (312+100)*(x**5) - 3000*x*(x**3) + (7775+100)*(x**3) - \
        (7955+1000)*(x**2) + (3997+1)*x + 120
    denominator = float(30)
    return float(numerator)/denominator

def print_lost_number(x):
    lost_number = polynomial(periodic(float(x)))
    print(int(lost_number)) # Get rid of ugly .0's at the end

i=0
while (1):
    print_lost_number(i)
    i += 1

Enquanto muitas pessoas usavam padrões retirados do OEIS, decidi criar meu próprio conjunto de funções para representar os números.

A primeira função que criei foi periódica (). É uma função que repete a cada seis números de entrada usando as propriedades cíclicas das funções trigonométricas. É assim:

periodic(0) = 0
periodic(1) = 5/2
periodic(2) = 1
periodic(3) = 2
periodic(4) = 1/2
periodic(5) = 3
periodic(6) = 0
...

Então, eu crio polinomial (). Que usa o seguinte polinômio:

412x^5-3000x^4+7875x^3-8955x^2+3998x+120
----------------------------------------
                  30

(No meu código, alguns dos coeficientes são representados como somas porque contêm os números perdidos como um de seus dígitos.)

Esse polinômio converte a saída de periódico () em seu número perdido apropriado, assim:

polynomial(0)   = 4
polynomial(5/2) = 8
polynomial(1)   = 15
polynomial(2)   = 16
polynomial(1/2) = 23
polynomial(3)   = 42

Ao aumentar constantemente i e passar por ambas as funções, recebo os números perdidos repetindo infinitamente.

(Nota: Eu uso muito float () no código. Isso é para que o Python faça divisão de ponto flutuante em vez de dizer 2/3 = 0.)

Emacs Lisp 73 chars

A melhor maneira de fazer um loop para sempre? Uma lista cíclica!

(let((a'(?\^D?\^H?\^O?\^P?\^W?*)))(setcdr(last a)a)(while(print(pop a))))

Mas espere, tem mais!

? \ ^ D é a melhor maneira de inserir o caractere para EOT, no entanto, se eu estivesse apenas enviando um arquivo, não precisaria do literal "\ ^ D", apenas poderia inserir um '?' seguido por um caractere EOT real, diminuindo assim o número real de caracteres necessários para: 63

Editar

Eu tenho trabalhado em "gel", que ainda não é uma linguagem real, mas é basicamente uma série de macros emacs lisp para código golf. Em "gel", esta seria a solução:

(m a(~o ?\^D?\^H?\^O?\^P?\^W?*)(@(<^(^ a))(...)))

e sem a espera:

(m a(~o ?\^D?\^H?\^O?\^P?\^W?*)(@(<^(^ a))))

44 caracteres com boa entrada de caracteres. Seria 34 se não fosse por uma apresentação na web.

Julia

Ao pesquisar um tempo, encontrei uma maneira matemática de expressar a sequência por outras seqüências sem usar nenhum dos números (ou maneiras complicadas de usá-las):

L(n)=n==0?2:n==1?1:L(n-1)+L(n-2) #Lucas numbers.
O(n)=int(n*(n+1)*(n+2)/6)
S(n)=n in [O(i) for i=1:50]?0:1 #A014306
T(n)=begin k=ifloor(n/2);sum([L(i)*S(n+1-i) for i=1:k]) end #A025097

lost(n)=n>5?lost(n-1)+lost(n-3)+lost(n-5):(n+3)>5?T(n+3):-T(n+3) #A122115

[lost(i-2) for i=5:10]

Resultado:

6-element Array{Int64,1}:
  4
  8
 15
 16
 23
 42

C ++

Uma linguagem limpa e agradável como o C ++ pode permitir que você organize sua fonte de maneira organizada e altamente legível, e tem a vantagem de ser fácil de copiar manualmente, com o mínimo de ambiguidade.

Aqui a solução é alcançada usando apenas o número 1.

#include <iostream>

typedef long int lI;
auto &VV = std::cout;
std::string vv = " ";

int main() {
  for(lI UU; UU --> UU;) {
    lI l1=1l+1l;lI 
    ll=1l << l1;VV 
    << ll << vv;lI 
    Il=ll*l1;VV << 
    Il << vv;VV <<
    ll*ll-1l << vv;
    lI II=ll*ll;VV 
    << II << vv;VV 
    <<(II += Il-1l)
    << vv;VV << l1
    * (II-l1)<< vv;
  }
}

Teste: http://ideone.com/fuOdem

Esquema (Guile)

(let l ((x 179531901/2199535975))
  (let* ((b (* x 51)) (f (floor b)))
    (format #t "~a " f)
    (l (- b f))))

http://ideone.com/QBzuBC

Indiscutivelmente, isso quebra a regra "não codifique os números em outras bases", mas acho que é suficientemente obscuro para não contar. Como evidência dessa obscuridade, esses dois números mágicos na base 51 são:

26:27:21:9:18 / 6:19:6:19:6:19

Edit : Mesmo truque, representação diferente. Na verdade, gosto mais deste, uma vez que não depende de uma base escolhida arbitrariamente. No entanto, requer uma implementação de esquema com suporte de precisão infinita para irracionais quadráticos, que (AFAIK) não existe. Você pode implementá-lo em algo como o Mathematica.

(let l ((x (/ (+ -16101175 (sqrt 265298265333750)) 770375)))
  (let* ((b (/ 1 x)) (f (floor b)))
    (format #t "~a " f)
    (l (- b f))))

PHP

Eu pensei que era hora de alguém enviar uma resposta php, não a melhor, mas a mais divertida de qualquer maneira

while(true)
{
    $lost = array(
    "Aaah",
    "Aaaaaaah",
    "Aaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah");
    foreach ($lost as $a)
    {
        echo strlen($a).'
        ';
    }
}

os Ahs são os gritos dos passageiros enquanto o avião cai

Perl

#!/usr/bin/perl
use Math::Trig;

$alt = 2600;
$m   = 10 x 2;
$ip  = 1 - pi/100;
@candidates = (
    "Locke",
    "Hugo",
    "Sawyer",
    "Sayid Jarrah",
    "Jack Sh.",
    "Jin-Soo Kwon"
);

@lost = map {map{ $a+=ord; $a-=($a>$alt)?($r=$m,$m=-$ip*$m,$r):$z; }/./g; $a/100 }@candidates;
for(;;) {
    printf "%d\n",$_ for @lost;
}