4, 8, 15, 16, 23, 42

Scrivi un programma che emette questa sequenza di numeri all'infinito. Tuttavia, I numeri non devono apparire nel codice sorgente da nessuna parte.

Quanto segue non è un programma Java valido per l'output di The Numbers perché The Numbers appare nel suo codice sorgente:

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 definizione di "I numeri non deve apparire nel codice sorgente" è la seguente:

• Non è necessario utilizzare il numero 4.
• Non è necessario utilizzare il numero 8.
• Non è necessario utilizzare il numero 1 seguito dal numero 5.
• Non è necessario utilizzare il numero 1 seguito dal numero 6.
• Non è necessario utilizzare il numero 2 seguito dal numero 3.

Se la tua lingua ignora alcuni caratteri che possono essere inseriti tra i numeri, non è una sostituzione valida. Quindi, ad esempio, se la tua lingua interpreta il letterale 1_5come 15, questo conterebbe come il numero 1 seguito dal numero 5.

Le basi alternative sono incluse nella restrizione, quindi ad esempio:

• Binary 100 non può essere utilizzato come sostituto di 4.
• Il 10 ottobre non può essere utilizzato come sostituto di 8.
• La F esadecimale non può essere utilizzata come sostituto di 15.

Pertanto, il seguente è un programma Java valido (ma non molto ispirato) per l'output di The Numbers perché The Numbers non appare nel suo codice sorgente:

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

Si noti che in quel programma, '*'e '&'sono sostituiti con gli interi 42 e 38, perché altrimenti i numeri 4 e 8 apparirebbero nel suo codice sorgente.

La definizione di "emette la sequenza all'infinito" è aperta all'interpretazione. Quindi, per esempio, sarebbe valido un programma che produce glifi che diventano più piccoli fino a quando non sono "infinitamente" piccoli.

Complimenti se sei in grado di generare la sequenza in qualche modo che non è sostanzialmente codificante per ogni numero.

• Derivandolo a una formula. La mia impressione è che non ce n'è una ma forse c'è o può essere falsificata.
• Correzione di un generatore pseudo-casuale per restituire la sequenza.

Questo è un concorso di popolarità, quindi sii creativo. La risposta con il maggior numero di voti il ​​26 marzo è il vincitore.

Giava

Ho deciso di aggiungere un'altra voce poiché questa è completamente diversa dalla mia prima (che era più simile a un esempio).

Questo programma calcola la media di un array immesso dall'utente ...

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 fa?

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

Pitone

#!/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)

Modifica: come suggerito da nneonneo, lo script ora non include cifre.

Perl

Non c'è nulla nascosto nel codice sorgente. No. Se il codice non funziona, digita use re "eval";prima (richiesto in Perl 5.18).

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

Spiegazione nello spoiler.

Questo è un semplice programma Perl che fa uso di più operazioni bit a bit e valuta l'espressione regolare usando l' operatore = ~ . La regex inizia con (? { E termina con }) . In Perl, questo esegue il codice durante la valutazione delle espressioni regolari - questo mi permette di usare eval senza effettivamente usarlo. Normalmente, tuttavia, per ragioni di sicurezza è necessario rielaborare " valutazione" quando si valutano le espressioni regolari dalle stringhe (alcuni programmi meno recenti hanno effettivamente preso espressioni regolari dall'utente) - ma si scopre che prima di Perl 5.18 c'era un bug che causava espressioni piegate costanti per lavorare anche senza questo pragma - se si utilizza Perl 5.18, digitare use re "eval";prima del codice per farlo funzionare. A parte questo, non c'è molto altro in questo codice.

Brainfuck

Sono così cattivo all'arte ASCII!

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

Provalo qui: http://ideone.com/kh3DYI

Unix C

Ci sono molti posti dove trovare costanti numeriche.

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

Formula "rubata" da https://oeis.org/A130826 : a (n) è il numero più piccolo in modo tale che il doppio del numero di divisori di (a (n) -n) / 3 dia l'ennesimo termine nel primo differenze nella sequenza prodotta dal setaccio Flavio-Giuseppe Flavio.

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 il fatto che qualsiasi sequenza di N elementi può essere generata da un polinomio N-1 e inserendo i numeri è coinvolto un sacco di bip e boops. Per riferimento, il polinomio che ho derivato è

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

Ho assegnato i fattori alle variabili nominate per i numeri, per semplicità;)

Prima versione:

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

Mi è piaciuta la conseguenza dell'aumento della tensione poiché il numero di BEEP diminuisce dopo ogni numero.

Poi ho pensato di poter calcolare i fattori anche usando bip 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;

È andato un po 'fuori bordo dopo che ...

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

L'uso dell'operatore predefinito in C # per i tipi di valore consente l'inizializzazione di BEEEP a zero. In questo modo nel codice non vengono utilizzati valori letterali numerici. L'algoritmo di base è lo stesso. ma i fattori sono calcolati in linea.

D

Non è consentito utilizzare i numeri 4, 8, 15, 16, 23 o 42 nel mio codice? Nessun problema, quindi non userò affatto i numeri!

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>

L' <pre>elemento visualizza un numero nella sequenza. Contiene inoltre tutto il codice necessario per passare al numero successivo nella sequenza. Quindi <pre>viene valutato, il che si traduce nel testo <pre>dell'aggiornamento per assomigliare al numero successivo nella sequenza. Questo processo si ripete all'infinito.

Eccolo in azione!

C

Metti gli occhiali socchiusi :-)

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" 

Ho deciso di optare per un one-liner leggibile solo per mostrare quanto sia fantastico Haskell. Inoltre, ho deciso di evitare tutte le cifre, per ogni evenienza.

Grazie alla valutazione pigra integrata, Haskell può manipolare (mappare, dividere, unire, filtrare ...) elenchi infinitamente lunghi. Ha anche più built-in per crearli. Poiché una stringa è solo un elenco di caratteri, anche le stringhe infinitamente lunghe non sono un mistero per Haskell.

matematica

Possiamo rispondere alla domanda concentrandoci sui ripetitori denominatori parziali della frazione periodica continuata mostrata di seguito. Sono ciò di cui abbiamo bisogno.

Dopotutto, comprendono la sequenza non terminante che stiamo cercando di produrre: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

In Mathematica si ottiene l' irrazionale quadratica corrispondente alla frazione periodica continuata di

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

dove lo 0 si riferisce alla parte intera implicita.

Possiamo verificare invertendo l'operazione:

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

I 4 e gli 8 violano una delle regole della sfida. La sottostringa 15è un'ulteriore violazione. Possiamo riformattare l'irrazionale quadratica per soddisfare le regole.

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

Ora prendiamo la sequenza di interesse:

Last[c]

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

E stampa l'elenco per sempre ...

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

C / C ++

Usando solo i caratteri L, O, Se Tpiù volte in questo ordine:

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

Giava

Non riesco a trovare uno schema in quella sequenza. Se non esiste un modello riconoscibile, potremmo anche mettere insieme un mucchio di piccoli numeri primi, stiparli nel RNG incorporato di Java e chiamarlo un giorno. Non vedo come ciò possa andare storto, ma poi sono un ottimista :)

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`

Interruzione di riga aggiunta per leggibilità. (Ab) utilizza il fatto che questi sono i primi sei numeri della sequenza OEIS A130826 .

C senza usare numeri o valori di caratteri

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

Mi piace l'idea di usare la sequenza

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

come in questa risposta . Trovato attraverso la ricerca OEIS come sequenza A122115 .

Se analizziamo la sequenza al contrario, troveremo un quintuplo di inizializzazione adatto che non 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

Nessun numero è una buona mossa. Invece di stampare la sequenza una volta per passaggio attraverso il ciclo, stampa solo una volta il numero per passaggio.

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 inferiore della stringa codifica i numeri da stampare e la parte superiore della stringa codifica il carattere successivo da trovare. Dove le due parti incontrano (un singolo F) codici che reimpostano il ciclo.

Pitone

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

Operatori bit a bit e qualche semplice matematica.

Rubino

Genera i numeri incorporando la sequenza ugualmente mistica 0, ∞, 9, 0, 36, 6, 6, 63 ;
Nessun bene può venire da questo.

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

C ( 54 50 caratteri)

Sto postando una risposta per il golf perché il golf almeno lo rende divertente.

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

Modifica: cosa ho usato per generare i coefficienti: https://gist.github.com/ion1/9578025

Modifica: mi è piaciuto molto il programma di Agrif e ho finito per scrivere un equivalente di Haskell mentre lo capivo . Ho scelto una base diversa per il numero magico.

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

Modifica: Mi è piaciuto anche il suo secondo programma e ho finito per scrivere un'implementazione Haskell di quadratiche irrazionali ;-). Usando la libreria e il numero magico di agrif, questo programma stamperà la sequenza.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

Ecco come si potrebbe cercare il numero magico con l'aiuto della libreria:

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

Il valore stampato indica il numero (−644047 + 1 √424477224534)/30815. Tutto quello che devi fare è trovare i fattori che eliminano le sequenze di cifre non consentite nei numeri senza cambiare il valore dell'espressione.

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

Ho trovato il seme dopo aver ascoltato qualche stazione radio in un volo sopra il Pacifico.

Pitone

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

Mentre molte persone hanno utilizzato modelli presi da OEIS, ho deciso di creare il mio set di funzioni per rappresentare i numeri.

La prima funzione che ho creato era periodica (). È una funzione che si ripete ogni sei numeri di input usando le proprietà cicliche delle funzioni di trigger. Va così:

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

Quindi, creo polynomial (). Che utilizza il seguente polinomio:

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

(Nel mio codice, alcuni dei coefficienti sono rappresentati come somme perché contengono i numeri persi come una delle loro cifre.)

Questo polinomio converte l'output di periodic () nel suo numero perso corretto, in questo modo:

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

Aumentando costantemente i e passando attraverso entrambe le funzioni, ottengo la ripetizione infinita dei numeri persi.

(Nota: uso molto float () nel codice. In questo modo Python fa una divisione in virgola mobile invece di dire 2/3 = 0.)

Emacs Lisp 73 caratteri

Il modo migliore per girare per sempre? Un elenco ciclico!

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

Ma aspetta, c'è di più!

? \ ^ D è il modo carino per inserire il carattere per EOT, tuttavia se avessi appena inviato un file non avrei bisogno del letterale "\ ^ D", avrei potuto semplicemente inserire un '?' seguito da un carattere EOT effettivo, portando così il numero reale di caratteri necessari a: 63

modificare

Ho lavorato su "gel" che non è ancora un linguaggio reale, ma fondamentalmente è una serie di macro emacs lisp per il codice golf. In "gel" questa sarebbe la soluzione:

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

e senza l'attesa:

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

44 caratteri con un bel personaggio. Sarebbe 34 se non fosse una presentazione web.

Julia

Cercando un po 'ho trovato un modo matematico per esprimere la sequenza con altre sequenze senza usare nessuno dei numeri (o modi complicati per usarli):

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]

Produzione:

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

C ++

Un bel linguaggio pulito come C ++ può permetterti di disporre la tua fonte in modo pulito e altamente leggibile, e ha il vantaggio di essere facile da copiare a mano con la minima ambiguità.

Qui la soluzione viene raggiunta utilizzando solo il numero 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;
  }
}

Test: http://ideone.com/fuOdem

Schema (Guile)

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

http://ideone.com/QBzuBC

Probabilmente questo infrange la regola "non codificare i numeri in altre basi", ma penso che sia abbastanza oscuro da non contare. A riprova di questa oscurità, quei due numeri magici nella base 51 sono:

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

Modifica : stesso trucco, rappresentazione diversa. In realtà questo mi piace di più, dal momento che non dipende da una base scelta arbitrariamente. Tuttavia, richiede un'implementazione dello schema con supporto di precisione infinita per irrazionali quadratiche, che (AFAIK) non esiste. Tuttavia, potresti implementarlo in qualcosa come Mathematica.

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

PHP

Ho pensato che fosse ora che qualcuno inviasse una risposta php, non la migliore ma comunque divertente

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

gli Ah sono le urla dei passeggeri mentre l'aereo si schianta

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