4, 8, 15, 16, 23, 42

Napisz program, który wypisze nieskończoną sekwencję liczb. Numery nie mogą jednak nigdzie pojawiać się w kodzie źródłowym.

Następujący program nie jest prawidłowym programem Java do wyświetlania liczb, ponieważ liczby pojawiają się w kodzie źródłowym:

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

Definicja „Numery nie mogą pojawiać się w kodzie źródłowym” jest następująca:

• Nie wolno używać cyfry 4.
• Nie wolno używać cyfry 8.
• Nie wolno używać cyfry 1, a następnie cyfry 5.
• Nie wolno używać cyfry 1, a następnie cyfry 6.
• Nie wolno używać cyfry 2, a następnie cyfry 3.

Jeśli Twój język ignoruje pewne znaki, które można umieścić między cyframi, nie jest to poprawne podstawienie. Na przykład, jeśli twój język interpretuje literał 1_5jako 15, będzie to liczone jako cyfra 1, a następnie cyfra 5.

Alternatywne zasady są objęte ograniczeniem, więc na przykład:

• Binarne 100 nie może być używane jako zamiennik 4.
• Octal 10 nie może być stosowany jako zamiennik 8.
• Szesnastkowy F nie może być stosowany jako zamiennik 15.

Dlatego poniżej przedstawiono poprawny (ale niezbyt zainspirowany) program Java do wyświetlania liczb, ponieważ liczby nie pojawiają się w kodzie źródłowym:

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

Zauważ, że w tym programie '*'i '&'są zastąpione liczbami całkowitymi 42 i 38, ponieważ w przeciwnym razie cyfry 4 i 8 pojawiłyby się w kodzie źródłowym.

Definicja „wyjścia sekwencji w nieskończoność” jest otwarta do interpretacji. Na przykład poprawny byłby program, który wypuszcza glify, które stają się mniejsze, aż stają się „nieskończenie” małe.

Kudos, jeśli jesteś w stanie wygenerować sekwencję w jakiś sposób, który nie jest zasadniczo zakodowany na stałe dla każdej liczby.

• Wyprowadzenie go do wzoru. Mam wrażenie, że nie ma jednego, ale może jest lub można go sfałszować.
• Naprawianie pseudolosowego generatora w celu zwrócenia sekwencji.

To konkurs popularności, więc bądź kreatywny. Odpowiedź z największą liczbą głosów 26 marca jest zwycięzcą.

Jawa

Postanowiłem dodać kolejny wpis, ponieważ jest on zupełnie inny niż mój pierwszy (który bardziej przypominał przykład).

Ten program oblicza średnią z tablicy wprowadzonej przez użytkownika ...

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

... czy to robi?

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

Pyton

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

Edycja: Zgodnie z sugestią Nneonneo, skrypt nie zawiera teraz cyfr.

Perl

W kodzie źródłowym nic nie jest ukryte. Nie. Jeśli kod nie działa, wpisz use re "eval";go wcześniej (wymagane w Perlu 5.18).

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

Wyjaśnienie w spoilerze.

Jest to prosty program w Perlu, który wykorzystuje wiele operacji bitowych i ocenia wyrażenie regularne za pomocą operatora = ~ . Wyrażenie regularne zaczyna się od (? { I kończy się na }) . W Perlu uruchamia to kod podczas oceny wyrażenia regularnego - pozwala mi to na użycie eval bez jego używania. Zwykle jednak „ ewaluacja ” jest wymagana ze względów bezpieczeństwa podczas oceny wyrażeń regularnych z ciągów (niektóre starsze programy faktycznie pobierały wyrażenia regularne od użytkownika) - ale okazuje się, że przed Perlem 5.18 był błąd powodujący stałe składanie wyrażeń pracować nawet bez tej pragmy - jeśli używasz Perla 5.18, wpisz use re "eval";przed kodem, aby działał. Poza tym ten kod nie ma wiele więcej.

Brainfuck

Jestem taka zła w sztuce ASCII!

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

Przetestuj tutaj: http://ideone.com/kh3DYI

Unix C

Istnieje wiele miejsc, w których można znaleźć stałe liczbowe.

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

DO#

Formuła „skradziona” z https://oeis.org/A130826 : a (n) to najmniejsza liczba taka, że ​​dwukrotność liczby dzielników (a (n) -n) / 3 daje n-ty termin w pierwszym różnice w sekwencji wytwarzanej przez sito Flavius-Josephus.

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

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

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

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

        return numbers;
    }

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

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

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

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

DO#

Wykorzystując fakt, że dowolną sekwencję N elementów można wygenerować przez wielomian N-1, a wprowadzanie liczb wiązało się z wieloma dźwiękami i buczeniami. Dla porównania pochodną wielomianową I jest

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

Dla uproszczenia przypisałem czynniki do zmiennych nazwanych liczbami;)

Pierwsza wersja:

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

Podobało mi się implikowanie rosnącego napięcia, gdy liczba BEEP spada po każdej liczbie.

Potem pomyślałem, że mogę też obliczyć czynniki za pomocą sygnału dźwiękowego i boopsa:

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;

Po tym trochę poszedł za burtę ...

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

Użycie domyślnego operatora w C # dla typów wartości pozwala na inicjalizację BEEEP do zera. W ten sposób w kodzie nie stosuje się literałów numerycznych. Podstawowy algorytm jest taki sam. ale współczynniki są obliczane liniowo.

re

Nie mogę używać cyfr 4, 8, 15, 16, 23 lub 42 w moim kodzie? Nie ma problemu, więc w ogóle nie będę używać liczb!

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>

<pre>Elementem wyświetla numer w sekwencji. Zawiera także cały kod niezbędny do przejścia do następnego numeru w sekwencji. Jest to więc <pre>eval'd, co powoduje, że tekst <pre>aktualizowanej wersji przypomina kolejną liczbę w sekwencji. Ten proces powtarza się bez końca.

Oto jest w akcji!

do

Załóż okulary zezujące :-)

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" 

Zdecydowałem się na czytelny jednowarstwowy, aby pokazać, jak niesamowity jest Haskell. Postanowiłem też unikać wszystkich cyfr, na wszelki wypadek.

Dzięki wbudowanej leniwej analizie Haskell może manipulować (mapować, dzielić, łączyć, filtrować ...) nieskończenie długimi listami. Ma nawet wiele wbudowanych do ich tworzenia. Ponieważ ciąg znaków jest tylko listą znaków, nieskończenie długie ciągi znaków również nie są tajemnicą dla Haskella.

Matematyka

Możemy odpowiedzieć na to pytanie, skupiając się na powtarzających się częściowych mianownikach okresowego ciągłego ułamka pokazanego poniżej. Są tym, czego potrzebujemy.

W końcu zawierają one sekwencję nie kończącą się, którą próbujemy stworzyć: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

W Mathematica uzyskuje się kwadratową irracjonalność odpowiadającą okresowej ciągłej części przez

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

gdzie 0 odnosi się do niejawnej części całkowitej.

Możemy to sprawdzić, odwracając operację:

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

4 i 8 naruszają jedną z zasad wyzwania. Podciąg 15stanowi dodatkowe naruszenie. Możemy sformatować kwadratowy irracjonalny, aby spełnić zasady.

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

Teraz chwytamy sekwencję zainteresowania:

Last[c]

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

I wydrukuj listę na zawsze ...

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

C / C ++

Korzystanie tylko znaki L, O, Si Twielokrotnie w tej kolejności:

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

Jawa

Nie mogę znaleźć wzoru w tej sekwencji. Jeśli nie ma rozpoznawalnego wzoru, równie dobrze możemy po prostu zrzucić kilka małych liczb pierwszych, wcisnąć je do wbudowanego RNG Javy i nazwać to dniem. Nie rozumiem, jak to mogło pójść nie tak, ale z drugiej strony jestem optymistą :)

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`

Dodano podział linii dla czytelności. (Ab) wykorzystuje fakt, że są to pierwsze sześć liczb OEIS Sekwencja A130826 .

C bez użycia liczb i bez wartości znaków

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

Podoba mi się pomysł użycia sekwencji

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

jak w tej odpowiedzi . Znalazłem go poprzez wyszukiwanie OEIS jako sekwencję A122115 .

Jeśli przejdziemy przez sekwencję w odwrotnej kolejności, znajdziemy odpowiedni pięciokrotność inicjalizacji, która nie zawiera 4, 8, 15, 16 lub 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

Żadne liczby to dobry ruch. Zamiast drukować sekwencję raz na przejście przez pętlę, drukuj tylko raz liczbę na przejście.

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

Dolna część łańcucha koduje liczby do wydrukowania, a górna część łańcucha koduje następny znak do znalezienia. Tam, gdzie dwie części spotykają się (jedna F), kody resetujące cykl.

Pyton

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

Operatory bitowe i prosta matematyka.

Rubin

Generuje liczby poprzez osadzenie równie mistycznej sekwencji 0, ∞, 9, 0, 36, 6, 6, 63 ;
Z tego nie może wynikać nic dobrego.

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

C ( 54 50 znaków)

Wysyłam odpowiedź na golfa, ponieważ gra w golfa przynajmniej sprawia przyjemność.

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

Edycja: Co użyłem do wygenerowania współczynników: https://gist.github.com/ion1/9578025

Edycja: Naprawdę podobał mi się program Agrif i skończyłem pisać ekwiwalent Haskell, jednocześnie go rozgryzając . Wybrałem inną bazę dla magicznej liczby.

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

Edycja: Podobał mi się również jego drugi program i skończyłem na napisaniu implementacji kwadratowej irracjonalności Haskella ;-). Korzystając z biblioteki i magicznej liczby agriza, program wydrukuje sekwencję.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

W ten sposób można szukać magicznej liczby za pomocą biblioteki:

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

Wydrukowana wartość oznacza liczbę (−644047 + 1 √424477224534)/30815. Wszystko, co musisz zrobić, to znaleźć czynniki, które pozbywają się niedozwolonych sekwencji cyfr w liczbach, nie zmieniając wartości wyrażenia.

DO#

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

Znalazłem ziarno po wysłuchaniu jakiejś stacji radiowej podczas lotu nad Pacyfikiem.

Pyton

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

Podczas gdy wiele osób używało wzorców zaczerpniętych z OEIS, postanowiłem stworzyć własny zestaw funkcji do reprezentowania liczb.

Pierwszą funkcją, którą utworzyłem, była periodic (). Jest to funkcja, która powtarza się co sześć liczb wejściowych przy użyciu cyklicznych właściwości funkcji triggera. Wygląda to tak:

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

Następnie tworzę polynomial (). Korzysta z następującego wielomianu:

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

(W moim kodzie niektóre współczynniki są reprezentowane jako sumy, ponieważ zawierają utracone liczby jako jedną z ich cyfr).

Ten wielomian konwertuje dane wyjściowe funkcji periodic () na odpowiednią liczbę utraconą, jak poniżej:

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

Przez ciągłe zwiększanie i i przekazywanie go przez obie funkcje, otrzymuję utracone liczby powtarzające się nieskończenie.

(Uwaga: często używam float () w kodzie. To dlatego Python dokonuje podziału zmiennoprzecinkowego zamiast np. 2/3 = 0.)

Emacs Lisp 73 znaków

Najlepszy sposób na zapętlenie na zawsze? Cykliczna lista!

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

Ale czekaj, jest więcej!

? \ ^ D to dobry sposób na wstawienie znaku dla EOT, jednak gdybym tylko przesyłał plik, nie potrzebowałbym dosłownego „\ ^ D”, mógłbym po prostu wstawić znak „?” po którym następuje rzeczywisty znak EOT, co zmniejsza rzeczywistą liczbę potrzebnych znaków do: 63

Edytować

Pracowałem nad „żelem”, który nie jest jeszcze prawdziwym językiem, ale jest w zasadzie serią makr emacs lisp dla kodu golfa. W „żelu” byłoby to rozwiązanie:

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

i bez czekania:

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

44 znaki z ładnym wprowadzaniem postaci. Wyniósłby 34, gdyby nie przesłanie przez Internet.

Julia

Badając chwilę, znalazłem matematyczny sposób wyrażenia sekwencji za pomocą innych sekwencji bez użycia żadnej liczby (lub trudnych sposobów ich użycia):

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]

Wynik:

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

C ++

Ładny, czysty język, taki jak C ++, pozwala na uporządkowanie źródła w czysty i czytelny sposób, a jego zaletą jest łatwość ręcznego kopiowania przy minimalnej dwuznaczności.

Tutaj rozwiązanie jest osiągane tylko za pomocą cyfry 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

System (podstęp)

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

http://ideone.com/QBzuBC

Prawdopodobnie łamie to zasadę „nie koduj liczb w innych bazach”, ale myślę, że jest na tyle niejasne, że się nie liczy. Na dowód tej niejasności te dwie magiczne liczby w bazie 51 to:

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

Edycja : Ta sama sztuczka, inna reprezentacja. Właściwie to jeszcze mi się podoba, ponieważ nie zależy to od arbitralnie wybranej bazy. Wymaga to jednak implementacji schematu z obsługą nieskończonej dokładności dla kwadratowych irracjonalnych, które (AFAIK) nie istnieją. Możesz jednak zaimplementować to w matematyce.

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

PHP

Myślałem, że nadszedł czas, aby ktoś przesłał odpowiedź php, nie najlepszą, ale i tak zabawną

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

Ahs to krzyki pasażerów podczas katastrofy samolotu

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