4, 8, 15, 16, 23, 42

Schreiben Sie ein Programm, das diese Zahlenfolge unendlich ausgibt. Die Zahlen dürfen jedoch nirgendwo in Ihrem Quellcode vorkommen.

Folgendes ist kein gültiges Java-Programm zur Ausgabe von The Numbers, da The Numbers im Quellcode enthalten sind:

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

Die Definition von "Die Zahlen dürfen nicht in Ihrem Quellcode vorkommen" lautet wie folgt:

• Sie dürfen die Ziffer 4 nicht verwenden.
• Sie dürfen die Ziffer 8 nicht verwenden.
• Sie dürfen nicht die Ziffer 1 gefolgt von der Ziffer 5 verwenden.
• Sie dürfen nicht die Ziffer 1 gefolgt von der Ziffer 6 verwenden.
• Sie dürfen nicht die Ziffer 2 gefolgt von der Ziffer 3 verwenden.

Wenn Ihre Sprache bestimmte Zeichen ignoriert, die zwischen den Ziffern stehen können, ist dies keine gültige Ersetzung. Wenn Ihre Sprache beispielsweise das Literal 1_5als interpretiert 15, zählt dies als die Ziffer 1, gefolgt von der Ziffer 5.

Alternative Basen sind in der Einschränkung enthalten, zum Beispiel:

• Binär 100 kann nicht als Ersatz für 4 verwendet werden.
• Oktal 10 kann nicht als Ersatz für 8 verwendet werden.
• Hexadezimal F kann nicht als Ersatz für 15 verwendet werden.

Daher ist Folgendes ein gültiges (aber nicht sehr inspiriertes) Java-Programm zur Ausgabe von The Numbers, da The Numbers nicht im Quellcode enthalten sind:

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

Beachten Sie, dass in diesem Programm '*'und '&'für die ganzen Zahlen 42 und 38 ersetzt werden, da sonst die Ziffern 4 und 8 in seinem Quellcode erscheinen würden.

Die Definition von "gibt die Sequenz unendlich aus" kann interpretiert werden. So wäre beispielsweise ein Programm gültig, das Glyphen ausgibt, die kleiner werden, bis sie "unendlich" klein sind.

Ein dickes Lob, wenn Sie in der Lage sind, die Sequenz auf eine Weise zu generieren, die im Grunde nicht jede Zahl hart codiert.

• Ableiten zu einer Formel. Mein Eindruck ist, dass es keinen gibt, aber vielleicht gibt es ihn oder er kann gefälscht werden.
• Behebung eines Pseudozufallsgenerators zur Rückgabe der Sequenz.

Dies ist ein Beliebtheitswettbewerb, also sei kreativ. Die Antwort mit den meisten Stimmen am 26. März ist der Gewinner.

Java

Ich habe mich entschlossen, einen weiteren Eintrag hinzuzufügen, da dieser völlig anders ist als der erste (eher ein Beispiel).

Dieses Programm berechnet den Durchschnitt eines vom Benutzer eingegebenen Arrays ...

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

... oder doch?

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

Python

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

Bearbeiten: Gemäß dem Vorschlag von Nneonneo enthält das Skript jetzt keine Ziffern mehr.

Perl

Im Quellcode ist nichts versteckt. Nee. Wenn der Code nicht funktioniert, geben Sie ihn use re "eval";vorher ein (erforderlich in Perl 5.18).

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

Erklärung im Spoiler.

Dies ist ein einfaches Perl-Programm, das mehrere bitweise Operationen verwendet und den regulären Ausdruck mit dem Operator = ~ auswertet . Der reguläre Ausdruck beginnt mit (? { Und endet mit }) . In Perl wird Code ausgeführt, während reguläre Ausdrücke ausgewertet werden. Auf diese Weise kann ich eval verwenden, ohne es tatsächlich zu verwenden. Normalerweise ist jedoch aus Sicherheitsgründen eine erneute " Auswertung " erforderlich, wenn reguläre Ausdrücke aus Zeichenfolgen ausgewertet werden (einige ältere Programme haben tatsächlich reguläre Ausdrücke vom Benutzer übernommen) - es hat sich jedoch herausgestellt, dass es vor Perl 5.18 einen Fehler gab, der konstant gefaltete Ausdrücke verursachte Sie können auch ohne dieses Pragma arbeiten. Wenn Sie Perl 5.18 verwenden, geben Sie use re "eval" ein.vor dem Code, damit es funktioniert. Abgesehen davon gibt es an diesem Code nicht viel anderes.

Brainfuck

Ich bin so schlecht in ASCII-Kunst!

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

Testen Sie es hier: http://ideone.com/kh3DYI

Unix C

Es gibt viele Stellen, an denen numerische Konstanten gefunden werden können.

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

Von https://oeis.org/A130826 "gestohlene" Formel : a (n) ist die kleinste Zahl, sodass die doppelte Anzahl von Teilern von (a (n) -n) / 3 den n-ten Term im ersten ergibt Unterschiede der vom Flavius-Josephus-Sieb erzeugten Reihenfolge.

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 #

Unter Verwendung der Tatsache, dass eine beliebige Folge von N Elementen durch ein N-1-Polynom erzeugt werden kann und die Eingabe der Zahlen viele Pieptöne und Boops erforderlich macht. Als Referenz ist das abgeleitete Polynom I

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

Der Einfachheit halber habe ich die Faktoren den für die Zahlen genannten Variablen zugewiesen;)

Erste Version:

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

Ich mochte die Implikation einer steigenden Spannung, da die Anzahl der Signaltöne nach jeder Nummer abnimmt.

Dann dachte ich, ich könnte die Faktoren auch mit Piepton und Boops berechnen:

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;

Ging danach ein wenig über Bord ...

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

Die Verwendung des Standardoperators in C # für Werttypen ermöglicht die Initialisierung von BEEEP auf Null. Auf diese Weise werden im Code keine numerischen Literale verwendet. Der grundlegende Algorithmus ist der gleiche. Die Faktoren werden jedoch inline berechnet.

D

Darf ich in meinem Code nicht die Nummern 4, 8, 15, 16, 23 oder 42 verwenden? Kein Problem, dann verwende ich gar keine Zahlen!

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>

Das <pre>Element zeigt eine Nummer in der Sequenz an. Es enthält auch den gesamten Code, der erforderlich ist, um zur nächsten Nummer in der Sequenz zu gelangen. Das <pre>wird also ausgewertet, was dazu führt, dass der Text der <pre>Aktualisierung der nächsten Nummer in der Sequenz ähnelt. Dieser Vorgang wiederholt sich endlos.

Hier ist es in Aktion!

C

Zieh deine Schutzbrille an :-)

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" 

Ich habe mich für einen lesbaren Einzeiler entschieden, um zu zeigen, wie großartig Haskell ist. Außerdem habe ich beschlossen, alle Ziffern zu vermeiden , nur für den Fall.

Dank der integrierten verzögerten Auswertung kann Haskell unendlich lange Listen bearbeiten (zuordnen, teilen, verbinden, filtern ...). Es hat sogar mehrere integrierte Funktionen, um sie zu erstellen. Da eine Zeichenfolge nur eine Liste von Zeichen ist, sind unendlich lange Zeichenfolgen auch für Haskell kein Geheimnis.

Mathematica

Wir können die Frage beantworten, indem wir uns auf die sich wiederholenden Teilnenner der unten gezeigten periodischen fortgesetzten Fraktion konzentrieren . Sie sind das, was wir brauchen.

Immerhin enthalten sie die nicht terminierende Sequenz, die wir zu produzieren versuchen: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

In Mathematica erhält man das quadratische Irrationale , das dem periodischen fortgesetzten Bruch von entspricht

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

wobei sich die 0 auf den impliziten ganzzahligen Teil bezieht.

Wir können überprüfen, indem wir die Operation umkehren:

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

Die 4 und 8 verletzen eine der Regeln der Herausforderung. Die Teilzeichenfolge 15ist eine zusätzliche Verletzung. Wir können das quadratische Irrationale neu formatieren, um die Regeln zu erfüllen.

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

Nun greifen wir die Sequenz von Interesse auf:

Last[c]

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

Und die Liste für immer ausdrucken ...

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

C / C ++

Mit nur die Zeichen L, O, Sund Twiederholt in dieser Reihenfolge:

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

Ich kann in dieser Sequenz kein Muster finden. Wenn es kein erkennbares Muster gibt, können wir genauso gut ein paar kleine Primzahlen zusammenwerfen, sie in Javas eingebautes RNG stopfen und es einen Tag nennen. Ich sehe nicht ein, wie das möglicherweise schief gehen könnte, aber andererseits bin ich ein Optimist :)

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 Einzeiler

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`

Zeilenumbruch zur besseren Lesbarkeit hinzugefügt. Es (ab) verwendet die Tatsache, dass dies die ersten sechs Nummern der OEIS-Sequenz A130826 sind .

C Verwenden Sie überhaupt keine Zahlen und keine Zeichenwerte

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

Mir gefällt die Idee, die Sequenz zu verwenden

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

wie in dieser Antwort . Gefunden über die OEIS-Suche als Sequenz A122115 .

Wenn wir die Reihenfolge in umgekehrter Reihenfolge durchgehen, finden wir ein passendes Initialisierungs-Fünffach, das nicht 4, 8, 15, 16 oder 23 enthält.

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

Überhaupt keine Zahlen sind ein guter Schachzug. Anstatt die Sequenz einmal pro Durchgang durch die Schleife zu drucken, drucken Sie nur eine Nummer pro Durchgang.

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

Der untere Teil der Zeichenfolge kodiert die zu druckenden Zahlen und der obere Teil der Zeichenfolge kodiert das nächste zu suchende Zeichen. Wo die beiden Teile (einen einzigen F) Code treffen, wird der Zyklus zurückgesetzt.

Python

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

Bitweise Operatoren und ein paar einfache Berechnungen.

Rubin

Erzeugt die Zahlen durch Einbetten der gleichermaßen mystischen Folge 0, ∞, 9, 0, 36, 6, 6, 63 ;
Daraus kann kein Gutes entstehen.

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

C ( 54 50 Zeichen)

Ich schreibe eine Golfantwort, weil Golf wenigstens Spaß macht.

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

Bearbeiten: Was ich verwendet habe, um die Koeffizienten zu generieren: https://gist.github.com/ion1/9578025

Edit: Ich mochte das Programm von agrif sehr und habe am Ende ein Haskell-Äquivalent geschrieben, als ich es herausgefunden habe. Ich habe eine andere Basis für die magische Zahl gewählt.

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: Ich mochte auch sein zweites Programm und schrieb am Ende eine Haskell-Implementierung von quadratischen Irrationalen ;-). Unter Verwendung der Bibliothek und der magischen Nummer des agrif druckt dieses Programm die Sequenz.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

So könnte man mit Hilfe der Bibliothek nach der magischen Zahl suchen:

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

Der aufgedruckte Wert steht für die Nummer (−644047 + 1 √424477224534)/30815. Alles, was Sie tun müssen, ist, Faktoren zu finden, die nicht zugelassene Ziffernfolgen in den Zahlen beseitigen, ohne den Wert des Ausdrucks zu ändern.

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

Ich fand den Samen, nachdem ich bei einem Flug über den Pazifik einen Radiosender gehört hatte.

Python

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

Während viele Leute Muster aus OEIS verwendeten, entschloss ich mich, meine eigenen Funktionen zu erstellen, um die Zahlen darzustellen.

Die erste Funktion, die ich erstellt habe, war periodic (). Es handelt sich um eine Funktion, die alle sechs Eingangsnummern unter Verwendung der zyklischen Eigenschaften der Triggerfunktionen wiederholt. Es geht so:

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

Dann erstelle ich ein Polynom (). Das verwendet das folgende Polynom:

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

(In meinem Code werden einige der Koeffizienten als Summen dargestellt, da sie die verlorenen Zahlen als eine ihrer Ziffern enthalten.)

Dieses Polynom konvertiert die Ausgabe von periodic () in die richtige verlorene Zahl wie folgt:

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

Durch ständiges Erhöhen von i und Durchlaufen beider Funktionen werden die verlorenen Zahlen unendlich oft wiederholt.

(Hinweis: Ich verwende float () häufig im Code. Dies ist der Grund, warum Python die Gleitkommadivision durchführt, anstatt 2/3 = 0 zu sagen.)

Emacs Lisp 73 Zeichen

Der beste Weg, um für immer zu loopen? Eine zyklische Liste!

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

Aber warte, es gibt noch mehr!

? \ ^ D ist die gute Möglichkeit, das Zeichen für EOT einzufügen. Wenn ich jedoch nur eine Datei einreiche, würde ich das wörtliche "\ ^ D" nicht benötigen. Ich könnte einfach ein '?' gefolgt von einem tatsächlichen EOT-Zeichen, wodurch sich die tatsächliche Anzahl der benötigten Zeichen auf 63 verringert

Bearbeiten

Ich habe an "Gel" gearbeitet, das noch keine echte Sprache ist, aber im Grunde genommen eine Reihe von Emacs-Lisp-Makros für Codegolf. In "Gel" wäre dies die Lösung:

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

und ohne zu warten:

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

44 Zeichen mit schöner Zeicheneingabe. Wäre 34, wenn es sich nicht um eine Web-Einreichung handeln würde.

Julia

Nach einer Weile habe ich einen mathematischen Weg gefunden, um die Sequenz durch andere Sequenzen auszudrücken, ohne eine der Zahlen zu verwenden (oder knifflige Wege, sie zu verwenden):

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]

Ausgabe:

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

C ++

Eine schöne, saubere Sprache wie C ++ kann es Ihnen ermöglichen, Ihren Quellcode auf eine übersichtliche und gut lesbare Weise zu gestalten, und hat den Vorteil, dass Sie ihn mit minimaler Mehrdeutigkeit einfach von Hand kopieren können.

Hier wird die Lösung nur mit der Nummer 1 erreicht.

#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

Möglicherweise verstößt dies gegen die Regel "Zahlen nicht in andere Basen kodieren", aber ich denke, es ist dunkel genug, dass es nicht zählt. Als Beweis für diese Dunkelheit sind diese beiden magischen Zahlen in der Basis 51:

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

Edit : Gleicher Trick, andere Darstellung. Eigentlich mag ich das mehr, da es nicht auf eine willkürlich gewählte Basis ankommt. Es erfordert jedoch eine Schemaimplementierung mit unendlich genauer Unterstützung für quadratische Irrationalen, die (AFAIK) nicht existiert. Sie könnten es jedoch in etwas wie Mathematica implementieren.

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

PHP

Ich dachte, es wäre an der Zeit, dass jemand eine PHP-Antwort einreicht, nicht die beste, aber trotzdem eine unterhaltsame

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

Die Ahs sind die Schreie der Passagiere, als das Flugzeug abstürzt

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