4, 8, 15, 16, 23, 42

Escriba un programa que genere esta secuencia de números infinitamente. Sin embargo, The Numbers no debe aparecer en su código fuente en ninguna parte.

El siguiente no es un programa Java válido para generar The Numbers porque The Numbers aparece en su código fuente:

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)
        );
    }
}

La definición de "Los números no deben aparecer en su código fuente" es la siguiente:

• No debes usar el número 4.
• No debes usar el número 8.
• No debe usar el número 1 seguido del número 5.
• No debe usar el número 1 seguido del número 6.
• No debe usar el número 2 seguido del número 3.

Si su idioma ignora ciertos caracteres que se pueden colocar entre los números, no es una sustitución válida. Entonces, por ejemplo, si su idioma interpreta el literal 1_5como 15, esto contaría como el número 1 seguido del número 5.

Las bases alternativas se incluyen en la restricción, por ejemplo:

• Binary 100 no se puede usar como sustituto de 4.
• Octal 10 no puede usarse como sustituto del 8.
• El hexadecimal F no se puede usar como sustituto de 15.

Por lo tanto, el siguiente es un programa Java válido (pero no muy inspirado) para generar The Numbers porque The Numbers no aparece en su código fuente:

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);
        }
    }
}

Tenga en cuenta que en ese programa, '*'y '&'se sustituyen por los enteros 42 y 38, porque de lo contrario los números 4 y 8 aparecerían en su código fuente.

La definición de "genera la secuencia infinitamente" está abierta a interpretación. Entonces, por ejemplo, un programa que genera glifos cada vez más pequeños hasta que sean "infinitamente" pequeños sería válido.

Felicitaciones si puede generar la secuencia de alguna manera que no sea básicamente codificar cada número.

• Derivándolo a una fórmula. Mi impresión es que no hay una, pero tal vez la hay o puede ser falsa.
• Arreglando un generador pseudoaleatorio para devolver la secuencia.

Este es un concurso de popularidad, así que sé creativo. La respuesta con más votos el 26 de marzo es la ganadora.

Java

Decidí agregar otra entrada ya que esta es completamente diferente de la primera (que era más como un ejemplo).

Este programa calcula el promedio de una matriz ingresada por el usuario ...

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

... o lo hace?

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

Pitón

#!/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: según la sugerencia de nneonneo, el script ahora no incluye dígitos.

Perl

No hay nada oculto en el código fuente. No. Si el código no funciona, escriba use re "eval";antes (requerido en Perl 5.18).

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

Explicación en spoiler.

Este es un programa Perl simple que utiliza múltiples operaciones bit a bit y evalúa la expresión regular usando el operador = ~ . La expresión regular comienza con (? { Y termina con }) . En Perl, esto ejecuta código mientras evalúa la expresión regular; esto me permite usar eval sin usarlo realmente. Normalmente, sin embargo, se requiere re "evaluar" , por razones de seguridad, al evaluar expresiones regulares de cadenas (algunos programas más antiguos en realidad tomaron expresiones regulares del usuario), pero resulta que antes de Perl 5.18 había un error que causaba expresiones plegadas constantes para trabajar incluso sin este pragma: si está utilizando Perl 5.18, escriba use re "eval";antes del código para que funcione. Aparte de eso, no hay mucho más en este código.

Brainfuck

¡Soy tan malo en el arte ASCII!

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

Pruébelo aquí: http://ideone.com/kh3DYI

Unix C

Hay muchos 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#

Fórmula "robada" de https://oeis.org/A130826 : a (n) es el número más pequeño de tal manera que dos veces el número de divisores de (a (n) -n) / 3 da el enésimo término en el primer diferencias de la secuencia producida por el tamiz Flavio-Josefo.

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#

Usando el hecho de que cualquier secuencia de N elementos puede ser generada por un polinomio N-1 e ingresando los números involucraron muchos pitidos y boops. Como referencia, el polinomio I derivado es

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

Asigne los factores a las variables nombradas para los números, por simplicidad;)

Primera versión:

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 ));
}

Me gustó la implicación del aumento de la tensión a medida que el número de BEEP disminuye después de cada número.

Luego pensé que también podría calcular los factores usando pitidos y 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;

Fuimos un poco por la borda después de eso ...

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))));
}

El uso del operador predeterminado en C # para los tipos de valor permite la inicialización de BEEEP a cero. De esta manera, no se usan literales numéricos en el código. El algoritmo básico es el mismo. pero los factores se calculan en línea.

re

¿No está permitido usar los números 4, 8, 15, 16, 23 o 42 en mi código? ¡No hay problema, entonces no usaré números en absoluto!

import std.stdio;

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

Javascript + HTML

Anti-golf!

<!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>

El <pre>elemento muestra un número en la secuencia. También contiene todo el código necesario para llegar al siguiente número en la secuencia. Entonces <pre>se evalúa, lo que da como resultado que el texto de la <pre>actualización se parezca al siguiente número en la secuencia. Este proceso se repite sin cesar.

¡Aquí está en acción!

C

Ponte tus gafas entrecerradas :-)

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" 

He decidido optar por una frase legible solo para mostrar lo increíble que es Haskell. Además, he decidido evitar todos los dígitos, por si acaso.

Gracias a la evaluación perezosa incorporada, Haskell puede manipular (mapear, dividir, unir, filtrar ...) listas infinitamente largas muy bien. Incluso tiene múltiples elementos integrados para crearlos. Dado que una cadena es solo una lista de caracteres, las cadenas infinitamente largas tampoco son un misterio para Haskell.

Mathematica

Podemos responder la pregunta centrándonos en los denominadores parciales repetidos de la fracción continua periódica que se muestra a continuación. Son lo que necesitamos.

Después de todo, comprenden la secuencia sin terminación que estamos tratando de producir: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

En Mathematica se obtiene el irracional cuadrático correspondiente a la fracción continua periódica por

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

donde el 0 se refiere a la parte entera implícita.

Podemos verificar invirtiendo la operación:

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

Los 4 y 8 violan una de las reglas del desafío. La subcadena 15es una violación adicional. Podemos reformatear el cuadrático irracional para satisfacer las reglas.

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

Ahora tomamos la secuencia de interés:

Last[c]

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

E imprima la lista para siempre ...

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

C / C ++

Usando sólo los caracteres L, O, Sy Ten varias ocasiones en este orden:

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

No puedo encontrar un patrón en esa secuencia. Si no hay un patrón reconocible, podríamos simplemente juntar un montón de primos pequeños, meterlos en el RNG incorporado de Java y llamarlo un día. No veo cómo eso podría salir mal, pero de nuevo, soy optimista :)

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`

Salto de línea agregado para facilitar la lectura. (Ab) utiliza el hecho de que estos son los primeros seis números de la secuencia OEIS A130826 .

C sin usar ningún número y sin valores de caracteres

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))))));
    }
}

Me gusta la idea de usar la secuencia

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

como en esta respuesta . Lo encontré a través de la búsqueda OEIS como secuencia A122115 .

Si pasamos por la secuencia en reversa, encontraremos un quíntuple de inicialización adecuado que no contiene 4, 8, 15, 16 o 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

Sin números en absoluto es un buen movimiento. Pero en lugar de imprimir la secuencia una vez por pase a través del bucle, solo imprima una vez el número por pase.

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

La parte inferior de la cadena codifica los números para imprimir y la parte superior de la cadena codifica el siguiente carácter para encontrar. Donde las dos partes se encuentran (una sola F) códigos que restablecen el ciclo.

Pitón

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 y algunas matemáticas simples.

Rubí

Genera los números incrustando la secuencia igualmente mística 0, ∞, 9, 0, 36, 6, 6, 63 ;
Nada bueno puede venir de esto.

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

C ( 54 50 caracteres)

Estoy publicando una respuesta de golf porque jugar golf al menos lo hace 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

Editar: Lo que solía generar los coeficientes: https://gist.github.com/ion1/9578025

Editar: Realmente me gustó el programa de agrif y terminé escribiendo un equivalente de Haskell mientras lo descubría. Elegí una base diferente para el 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

Editar: También me gustó su segundo programa y terminé escribiendo una implementación de Haskell de irracionales cuadráticos ;-). Usando la biblioteca y el número mágico de agrif, este programa imprimirá la secuencia.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

Así es como se podría buscar el número mágico con la ayuda de la biblioteca:

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

El valor impreso representa el número (−644047 + 1 √424477224534)/30815. Todo lo que necesita hacer es encontrar factores que eliminen las secuencias de dígitos no permitidas en los números sin cambiar el valor de la expresión.

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

Encontré la semilla después de escuchar una estación de radio en un vuelo sobre el Pacífico.

Pitón

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

Si bien muchas personas usaron patrones tomados de OEIS, decidí crear mi propio conjunto de funciones para representar los números.

La primera función que creé fue periódica (). Es una función que se repite cada seis números de entrada utilizando las propiedades cíclicas de las funciones trigonométricas. Dice así:

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

Entonces, creo polinomio (). Que utiliza el siguiente polinomio:

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

(En mi código, algunos de los coeficientes se representan como sumas porque contienen los números perdidos como uno de sus dígitos).

Este polinomio convierte la salida de periodic () en su número perdido adecuado, de esta manera:

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

Al aumentar constantemente i y pasarlo por ambas funciones, obtengo los números perdidos que se repiten infinitamente.

(Nota: uso mucho float () en el código. Esto es para que Python haga la división de punto flotante en lugar de decir 2/3 = 0).

Emacs Lisp 73 caracteres

¿La mejor manera de recorrer para siempre? Una lista cíclica!

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

¡Pero espera hay mas!

? \ ^ D es la mejor manera de insertar el carácter para EOT, sin embargo, si solo estuviera enviando un archivo, no necesitaría el literal "\ ^ D", simplemente podría insertar un '?' seguido de un personaje EOT real, reduciendo así el número real de caracteres necesarios a: 63

Editar

He estado trabajando en "gel", que aún no es un lenguaje real, pero es básicamente una serie de macros de emacs lisp para golf de código. En "gel" esta sería la solución:

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

y sin esperar:

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

44 caracteres con buena entrada de personaje. Sería 34 si no fuera por ser un envío web.

Julia

Al investigar un tiempo, encontré una forma matemática de expresar la secuencia por otras secuencias sin usar ninguno de los números (o formas complicadas de usarlas):

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]

Salida:

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

C ++

Un lenguaje agradable y limpio como C ++ puede permitirle diseñar su fuente de una manera ordenada y altamente legible, y tiene la ventaja de ser fácil de copiar a mano con una mínima ambigüedad.

Aquí se alcanza la solución usando solo el 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;
  }
}

Prueba: 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

Podría decirse que esto rompe la regla de "no codificar los números en otras bases", pero creo que es lo suficientemente oscuro como para que no cuente. Como evidencia de esta oscuridad, esos dos números mágicos en la base 51 son:

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

Editar : mismo truco, representación diferente. De hecho, me gusta más, ya que no depende de una base elegida arbitrariamente. Sin embargo, requiere una implementación de esquema con soporte de precisión infinita para irracionales cuadráticos, que (AFAIK) no existe. Sin embargo, podría implementarlo en algo como Mathematica.

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

PHP

Pensé que era hora de que alguien enviara una respuesta php, no la mejor pero sí una divertida

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

los Ah son los gritos de los pasajeros cuando el avión se estrella

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