4, 8, 15, 16, 23, 42

Напишите программу, которая выводит эту последовательность чисел бесконечно. Тем не менее, номера не должны появляться в вашем исходном коде нигде.

Следующее не является допустимой программой Java для вывода чисел, потому что числа появляются в исходном коде:

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

Определение «Числа не должны появляться в вашем исходном коде» выглядит следующим образом:

• Вы не должны использовать цифру 4.
• Вы не должны использовать цифру 8.
• Вы не должны использовать цифру 1, а затем цифру 5.
• Вы не должны использовать цифру 1, а затем цифру 6.
• Вы не должны использовать цифру 2, а затем цифру 3.

Если ваш язык игнорирует определенные символы, которые могут быть помещены между цифрами, это недопустимая замена. Так, например, если ваш язык интерпретирует литерал 1_5как15 , это будет считаться цифрой 1, за которой следует цифра 5.

Альтернативные основания включены в ограничение, например:

• Binary 100 не может быть заменен 4.
• Восьмеричное 10 не может быть использовано вместо 8.
• Шестнадцатеричный F не может использоваться вместо 15.

Следовательно, следующее является допустимой (но не очень вдохновляющей) Java-программой для вывода чисел, поскольку числа не отображаются в исходном коде:

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

Обратите внимание, что в этой программе '*'и'&' заменены целые числа 42 и 38, поскольку в противном случае цифры 4 и 8 появятся в его исходном коде.

Определение «выводит последовательность бесконечно» открыто для интерпретации. Так, например, программа, которая выводит глифы, уменьшающиеся, пока они не становятся «бесконечно» маленькими, будет действительной.

Престижность, если вы можете сгенерировать последовательность каким-либо образом, который не в основном жестко кодирует каждое число.

• Вывести его в формулу. У меня сложилось впечатление, что нет ни одного, но, возможно, есть или это может быть подделано.
• Исправление псевдослучайного генератора для возврата последовательности.

Это конкурс популярности, так что будьте креативны. Ответ с наибольшим количеством голосов 26 марта - победитель.

Ява

Я решил добавить еще одну запись, поскольку она полностью отличается от моей первой (которая была больше похожа на пример).

Эта программа вычисляет среднее значение массива, введенного пользователем ...

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

... или это?

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

питон

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

Изменить: Согласно предложению nneonneo, скрипт теперь не содержит цифр.

Perl

В исходном коде ничего не скрыто. Нет. Если код не работает, напечатайте use re "eval";перед ним (требуется в Perl 5.18).

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

Пояснение в спойлере.

Это простая Perl-программа, которая использует несколько побитовых операций и оценивает регулярное выражение с помощью оператора = ~ . Регулярное выражение начинается с (? { И заканчивается }) . В Perl это выполняет код при оценке регулярного выражения - это позволяет мне использовать eval, фактически не используя его. Однако, как правило, перед вычислением он «вычисляется», для оценки регулярных выражений из строк требуется (некоторые старые программы фактически брали регулярные выражения у пользователя), но оказывается, что до Perl 5.18 существовала ошибка, приводившая к постоянным сложенным выражениям работать даже без этой прагмы - если вы используете Perl 5.18, наберите use re "eval"; чтобы заставить его работать. Кроме этого, в этом коде нет ничего другого.

Brainfuck

Я так плох в искусстве ASCII!

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

Проверьте это здесь: http://ideone.com/kh3DYI

Unix C

Есть много мест, где можно найти числовые константы.

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

Формула «украденная» из https://oeis.org/A130826 : a (n) - это наименьшее число, такое, что двойное число делителей (a (n) -n) / 3 дает n-й член в первом различия в последовательности, производимой ситом Флавий-Иосиф.

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 #

Использование того факта, что любая последовательность из N элементов может быть сгенерирована полиномом N-1, и ввод чисел требуют большого количества звуковых сигналов и повышений. Для справки, производный полином I

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

Я назначил факторы для переменных, названных по номерам, для простоты;)

Первая версия:

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

Мне понравилось проявление растущей напряженности, так как число ЗВУК уменьшается после каждого числа.

Затем я подумал, что могу рассчитать коэффициенты, используя звуковой сигнал и сигнал тоже:

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;

После этого ушел немного за борт ...

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

Использование оператора по умолчанию в C # для типов значений позволяет инициализировать BEEEP на ноль. Таким образом, никакие числовые литералы не используются в коде. Основной алгоритм такой же. но факторы рассчитываются в линию.

D

Не разрешается использовать цифры 4, 8, 15, 16, 23 или 42 в моем коде? Нет проблем, тогда я не буду использовать цифры вообще!

import std.stdio;

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

Javascript + HTML

Анти-гольф!

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

<pre>Элемент отображает число в последовательности. Он также содержит весь код, необходимый для перехода к следующему номеру в последовательности. Таким образом, <pre>is eval'd, в результате чего текст <pre>обновляется, чтобы напомнить следующий номер в последовательности. Этот процесс повторяется бесконечно.

Вот оно в действии!

С

Наденьте свои щурящиеся очки :-)

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" 

Я решил пойти на удобочитаемую однострочку, чтобы показать, какой классный Хаскелл. Кроме того, я решил избежать всех цифр, на всякий случай.

Благодаря встроенной ленивой оценке, Haskell может манипулировать (отображать, разбивать, объединять, фильтровать ...) бесконечно длинными списками. Он даже имеет несколько встроенных модулей для их создания. Поскольку строка - это просто список символов, бесконечно длинные строки также не являются загадкой для Хаскелла.

Mathematica

Мы можем ответить на этот вопрос, сосредоточившись на повторяющихся частичных знаменателях периодической непрерывной дроби, показанной ниже. Они то, что нам нужно.

В конце концов, они содержат бесконечную последовательность, которую мы пытаемся создать: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

В Mathematica можно получить квадратичное иррациональное значение, соответствующее периодической непрерывной дроби

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

где 0 относится к неявной целочисленной части.

Мы можем проверить, перевернув операцию:

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

4 и 8 нарушают одно из правил вызова. Подстрока 15является дополнительным нарушением. Мы можем переформатировать квадратичное иррациональное, чтобы удовлетворить правилам.

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

Теперь мы берем интересующую последовательность:

Last[c]

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

И напечатать список навсегда ...

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

C / C ++

Используя только символы L, O, Sи Tнесколько раз в таком порядке:

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 RNG и назвать его днем. Я не понимаю, как это может пойти не так, но опять же, я оптимист :)

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

Баш однострочный

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`

Добавлен разрыв строки для удобства чтения. Он (ab) использует тот факт, что это первые шесть чисел OEIS Sequence A130826 .

C не использует никаких чисел и никаких символьных значений

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

Мне нравится идея использования последовательности

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

как в этом ответе . Нашел это через Поиск OEIS как последовательность A122115 .

Если мы пройдем последовательность в обратном порядке, мы найдем подходящую пятерку инициализации, которая не содержит 4, 8, 15, 16 или 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

Без цифр это хороший ход. Но вместо того, чтобы печатать последовательность один раз за проход через цикл, печатайте только один раз за проход.

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

Нижняя часть строки кодирует числа для печати, а верхняя часть строки кодирует следующий символ для поиска. Там, где встречаются две части (один F) коды, сбрасывающие цикл.

питон

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

Побитовые операторы и некоторая простая математика.

Рубин

Генерирует числа путем вложения одинаково мистической последовательности 0, ∞, 9, 0, 36, 6, 6, 63 ;
Ничего хорошего из этого не получится.

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

С ( 54 50 символов)

Я публикую ответ по гольфу, потому что игра в гольф, по крайней мере, делает его веселым.

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

Изменить: Что я использовал для генерации коэффициентов: https://gist.github.com/ion1/9578025

Редактировать: мне действительно понравилась программа agrif, и в итоге я написал эквивалент на Haskell, пока разбирался с ним. Я выбрал другую базу для магического числа.

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

Редактировать: мне также понравилась его вторая программа, и в итоге я написал реализацию квадратичного иррационального числа в Haskell ;-). Используя библиотеку и магическое число Агрифа, эта программа напечатает последовательность.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

Вот как можно искать магическое число с помощью библиотеки:

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

Напечатанное значение обозначает номер (−644047 + 1 √424477224534)/30815. Все, что вам нужно сделать, - это найти факторы, которые избавляют от недопустимых последовательностей цифр в числах, не меняя значения выражения.

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

Я нашел семя после прослушивания какой-то радиостанции в полете над Тихим океаном.

питон

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

Хотя многие люди использовали шаблоны, взятые из OEIS, я решил создать свой собственный набор функций для представления чисел.

Первая функция, которую я создал, была period (). Это функция, которая повторяет каждые шесть входных чисел, используя циклические свойства функций триггера. Это выглядит так:

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

Затем я создаю полином (). Это использует следующий полином:

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

(В моем коде некоторые коэффициенты представлены в виде сумм, потому что они содержат потерянные числа в качестве одной из своих цифр.)

Этот полином преобразует вывод period () в правильное потерянное число, например так:

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

Постоянно увеличивая i и пропуская его через обе функции, я получаю потерянные числа, повторяющиеся бесконечно.

(Примечание: я часто использую float () в коде. Это так, Python делает деление с плавающей запятой вместо того, чтобы сказать 2/3 = 0.)

Emacs Lisp 73 символа

Лучший способ зациклить навсегда? Циклический список!

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

Но подождите, это еще не все!

? \ ^ D - это хороший способ вставить символ для EOT, однако, если бы я просто отправлял файл, мне не понадобился бы буквальный «\ ^ D», я мог бы просто вставить «?» за которым следует фактический символ EOT, таким образом, действительное число необходимых символов уменьшается до: 63

редактировать

Я работал над «gel», который пока не является реальным языком, но в основном представляет собой серию макросов emacs lisp для Code Golf. В «геле» это было бы решением:

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

и без ожидания:

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

44 символа с хорошим входом персонажа. Было бы 34, если бы не веб-представление.

Юля

Исследуя некоторое время, я нашел математический способ выразить последовательность другими последовательностями, не используя ни одного из чисел (или хитрых способов их использования):

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]

Выход:

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

C ++

Хороший чистый язык, такой как C ++, может позволить вам аккуратно и легко читать исходные тексты и имеет преимущество в том, что его легко скопировать вручную с минимальной двусмысленностью.

Здесь решение достигается с использованием только числа 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;
  }
}

Тест: http://ideone.com/fuOdem

Схема (Guile)

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

http://ideone.com/QBzuBC

Возможно, это нарушает правило «не кодировать числа в других базах», но я думаю, что оно настолько неясно, что не считается. В качестве доказательства этой неясности эти два магических числа в базе 51:

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

Изменить : тот же трюк, другое представление. Мне на самом деле нравится еще один, поскольку он не зависит от произвольно выбранной базы. Однако для этого требуется реализация схемы с поддержкой бесконечной точности для квадратичных иррациональных чисел, которых (AFAIK) не существует. Вы могли бы реализовать это в чем-то вроде Mathematica.

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

PHP

Я думал, что пришло время, когда кто-то отправил ответ php, не самый лучший, но в любом случае забавный.

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

Ас крики пассажиров, как самолет падает

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