4, 8, 15, 16, 23, 42

Tulis program yang menampilkan urutan angka ini tanpa batas. Namun, The Numbers tidak boleh muncul di kode sumber Anda di mana pun.

Berikut ini bukan program Java yang valid untuk menampilkan Angka karena Angka muncul dalam kode sumbernya:

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

Definisi "Bilangan tidak boleh muncul dalam kode sumber Anda" adalah sebagai berikut:

• Anda tidak boleh menggunakan angka 4.
• Anda tidak boleh menggunakan angka 8.
• Anda tidak boleh menggunakan angka 1 diikuti oleh angka 5.
• Anda tidak boleh menggunakan angka 1 diikuti oleh angka 6.
• Anda tidak boleh menggunakan angka 2 diikuti oleh angka 3.

Jika bahasa Anda mengabaikan karakter tertentu yang dapat ditempatkan di antara angka, itu bukan pengganti yang valid. Jadi misalnya jika bahasa Anda mengartikan literal 1_5sebagai 15, ini akan dihitung sebagai angka 1 diikuti oleh angka 5.

Basis alternatif termasuk dalam pembatasan, jadi misalnya:

• Biner 100 tidak dapat digunakan sebagai pengganti 4.
• Oktal 10 tidak dapat digunakan sebagai pengganti 8.
• Heksadesimal F tidak dapat digunakan sebagai pengganti 15.

Oleh karena itu, berikut ini adalah program Java yang valid (tetapi tidak sangat terinspirasi) untuk menampilkan The Numbers karena The Numbers tidak muncul dalam kode sumbernya:

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

Perhatikan bahwa dalam program itu, '*'dan '&'diganti untuk bilangan bulat 42 dan 38, karena jika tidak angka 4 dan 8 akan muncul dalam kode sumbernya.

Definisi "menghasilkan urutan tanpa batas" terbuka untuk interpretasi. Jadi, misalnya, sebuah program yang menghasilkan mesin terbang semakin kecil sampai mereka "tak terbatas" kecil akan valid.

Kudos jika Anda dapat menghasilkan urutan dalam beberapa cara yang pada dasarnya tidak mengkodekan setiap angka.

• Turunkan ke formula. Kesan saya adalah tidak ada satu tapi mungkin ada atau bisa dipalsukan.
• Memperbaiki generator pseudo-acak untuk mengembalikan urutan.

Ini adalah kontes popularitas, jadi jadilah kreatif. Jawaban dengan suara terbanyak pada tanggal 26 Maret adalah pemenangnya.

Jawa

Saya memutuskan untuk menambahkan entri lain karena ini benar-benar berbeda dari yang pertama (yang lebih mirip contoh).

Program ini menghitung rata-rata array yang dimasukkan oleh pengguna ...

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

... atau bukan?

java.lang.ArrayIndexOutOfBoundsException: 4
    di Numbers.getSum (Numbers.java:8)
    di Numbers.getAverage (Numbers.java:15)
    di Numbers.roundAverage (Numbers.java:16)
    di Numbers.beginLoop (Numbers.java:23)
    di Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    di Numbers.getSum (Numbers.java:8)
    di Numbers.getAverage (Numbers.java:15)
    di Numbers.roundAverage (Numbers.java:16)
    di Numbers.beginLoop (Numbers.java:23)
    di Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    di 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)

Sunting: Sesuai saran nneonneo, skrip sekarang tidak menyertakan digit.

Perl

Tidak ada yang disembunyikan dalam kode sumber. Nggak. Jika kode tidak berfungsi, ketikkan use re "eval";sebelumnya (diperlukan dalam Perl 5.18).

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

Penjelasan dalam spoiler.

Ini adalah program Perl sederhana yang memanfaatkan beberapa operasi bitwise, dan mengevaluasi ekspresi reguler menggunakan = ~ operator. Regex dimulai dengan (? { Dan diakhiri dengan }) . Di Perl, ini menjalankan kode sambil mengevaluasi ekspresi reguler - ini memungkinkan saya menggunakan eval tanpa benar-benar menggunakannya. Namun, biasanya "eval" diperlukan, untuk alasan keamanan, ketika mengevaluasi ekspresi reguler dari string (beberapa program lama benar-benar mengambil ekspresi reguler dari pengguna) - tetapi ternyata sebelum Perl 5.18 ada bug yang menyebabkan ekspresi terlipat konstan untuk bekerja bahkan tanpa pragma ini - jika Anda menggunakan Perl 5.18, ketik use re "eval";sebelum kode untuk membuatnya berfungsi. Selain itu, kode ini tidak banyak.

Brainfuck

Saya sangat buruk dalam seni ASCII!

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

Uji di sini: http://ideone.com/kh3DYI

Unix C

Ada banyak tempat untuk menemukan konstanta numerik.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <fcntl.h>
#include <pwd.h>
#include <netdb.h>

int main(void)
{
  int thenumbers[] = {
    S_IRGRP|S_IXGRP|S_IWOTH,
    ntohs(getservbyname("telnet", "tcp")->s_port),
    exp(M_E)-cos(M_PI),
    SIGTERM,
    CHAR_BIT,
    strlen(getpwuid(EXIT_SUCCESS)->pw_name)
  }, i=sizeof(thenumbers)/sizeof(*thenumbers);
  while(i--)
    printf("%d\n", thenumbers[i]);
  return main();
}

C #

Formula "dicuri" dari https://oeis.org/A130826 : a (n) adalah angka terkecil sehingga dua kali jumlah pembagi dari (a (n) -n) / 3 memberikan istilah ke-n pada yang pertama perbedaan urutan yang dihasilkan oleh saringan 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);
            }
        }
    }
}

C #

Menggunakan fakta bahwa setiap urutan elemen N dapat dihasilkan oleh polinomial N-1 dan memasukkan angka melibatkan banyak bunyi bip dan boops. Sebagai referensi, polinomial yang saya peroleh adalah

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

Saya menetapkan faktor ke variabel yang dinamai untuk angka, untuk kesederhanaan;)

Versi pertama:

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

Saya menyukai implikasi dari meningkatnya ketegangan karena jumlah BIP berkurang setelah setiap angka.

Lalu saya pikir saya bisa menghitung faktor-faktor menggunakan bunyi bip dan boops, juga:

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;

Pergi sedikit berlebihan setelah itu ...

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

Menggunakan operator default dalam C # untuk tipe nilai memungkinkan inisialisasi BEEEP ke nol. Dengan cara ini tidak ada literal numerik yang digunakan dalam kode. Algoritma dasarnya sama. tetapi faktor-faktornya dihitung sebaris.

D

Tidak diizinkan menggunakan angka 4, 8, 15, 16, 23, atau 42 dalam kode saya? Tidak masalah, maka saya tidak akan menggunakan angka sama sekali!

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>

The <pre>elemen menampilkan nomor dalam urutan. Ini juga berisi semua kode yang diperlukan untuk mendapatkan nomor berikutnya dalam urutan. Jadi <pre>ini dievaluasi, yang menghasilkan teks yang <pre>sedang diperbarui menyerupai angka berikutnya dalam urutan. Proses ini berulang tanpa henti.

Ini dia beraksi!

C

Dapatkan kacamata menyipitkan mata Anda di :-)

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" 

Saya memutuskan untuk menggunakan one-liner yang bisa dibaca hanya untuk menunjukkan betapa hebatnya Haskell. Juga, saya telah memutuskan untuk menghindari semua digit, untuk berjaga-jaga.

Berkat evaluasi malas bawaan, Haskell dapat memanipulasi (memetakan, membagi, bergabung, memfilter ...) daftar yang panjang tak terhingga. Bahkan memiliki beberapa built-in untuk membuatnya. Karena string hanyalah daftar karakter, string panjang yang tak terbatas juga bukan misteri bagi Haskell.

Mathematica

Kita dapat menjawab pertanyaan dengan memfokuskan pada penyebut parsial berulang dari fraksi lanjutan periodik yang ditunjukkan di bawah ini. Mereka adalah yang kita butuhkan.

Bagaimanapun, mereka terdiri dari urutan non-terminasi yang kami coba produksi: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

Dalam Mathematica seseorang memperoleh irasional kuadrat yang sesuai dengan pecahan lanjutan periodik oleh

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

di mana 0 mengacu pada bagian integer implisit.

Kami dapat memeriksa dengan membalikkan operasi:

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

4 dan 8 melanggar salah satu aturan tantangan. Substring 15merupakan pelanggaran tambahan. Kita dapat memformat ulang kuadrat irasional untuk memenuhi aturan.

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

Sekarang kita ambil urutan bunga:

Last[c]

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

Dan cetak daftar selamanya ...

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

C / C ++

Hanya menggunakan karakter L, O, Sdan Tberulang kali agar:

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

Saya tidak dapat menemukan pola dalam urutan itu. Jika tidak ada pola yang dapat dikenali, kita mungkin hanya perlu mengumpulkan sekelompok bilangan prima kecil, menjejalkannya ke dalam RNG bawaan Java, dan menyebutnya sehari. Saya tidak melihat bagaimana itu bisa salah, tapi sekali lagi, saya optimis :)

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 satu-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`

Line break ditambahkan untuk keterbacaan. Itu (ab) menggunakan fakta bahwa ini adalah enam angka pertama dari Urutan A130826 OEIS .

C tidak menggunakan angka sama sekali dan tidak ada nilai karakter

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

Saya suka gagasan menggunakan urutan

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

seperti pada jawaban ini . Menemukannya melalui Pencarian OEIS sebagai urutan A122115 .

Jika kita melewati urutan secara terbalik, kita akan menemukan sebuah inisialisasi kuintuple yang sesuai yang tidak mengandung 4, 8, 15, 16 atau 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

Tidak ada angka sama sekali adalah langkah yang baik. Tapi daripada mencetak urutan sekali per melewati loop, hanya mencetak sekali nomor per pass.

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

Bagian bawah string mengkode angka yang akan dicetak dan bagian atas string mengkode karakter berikutnya yang ditemukan. Di mana kedua bagian bertemu (satu F) kode mengatur ulang siklus.

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

Operator bitwise dan beberapa matematika sederhana.

Rubi

Menghasilkan Bilangan dengan menyematkan urutan mistis yang sama 0, ∞, 9, 0, 36, 6, 6, 63 ;
Tidak ada yang baik bisa datang dari ini.

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

C ( 54 50 karakter)

Saya memposting jawaban golf karena golf setidaknya membuatnya menyenangkan.

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

Sunting: Apa yang saya gunakan untuk menghasilkan koefisien: https://gist.github.com/ion1/9578025

Sunting: Saya sangat menyukai program agrif dan akhirnya menulis setara Haskell sambil mencari tahu. Saya memilih basis yang berbeda untuk angka ajaib.

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

Sunting: Saya juga menyukai program keduanya dan akhirnya menulis implementasi Haskell dari irasional kuadrat ;-). Menggunakan perpustakaan dan nomor sihir agrif, program ini akan mencetak urutannya.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

Ini adalah bagaimana seseorang dapat mencari angka ajaib dengan bantuan perpustakaan:

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

Nilai yang dicetak berarti nomor (−644047 + 1 √424477224534)/30815. Yang perlu Anda lakukan adalah menemukan faktor yang menghilangkan urutan digit yang tidak diizinkan dalam angka sementara tidak mengubah nilai ekspresi.

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

Saya menemukan benih setelah mendengarkan beberapa stasiun radio dalam penerbangan di Pasifik.

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

Sementara banyak orang menggunakan pola yang diambil dari OEIS, saya memutuskan untuk membuat serangkaian fungsi saya sendiri untuk mewakili angka.

Fungsi pertama yang saya buat adalah periodik (). Ini adalah fungsi yang mengulangi setiap enam angka input menggunakan sifat siklis dari fungsi trigonometri. Bunyinya seperti ini:

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

Lalu, saya membuat polinomial (). Itu menggunakan polinomial berikut:

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

(Dalam kode saya, beberapa koefisien direpresentasikan sebagai jumlah karena mengandung angka yang hilang sebagai salah satu dari digit mereka.)

Polinomial ini mengonversi output periodik () ke angka yang hilang, seperti ini:

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

Dengan terus meningkatkan i dan melewati kedua fungsi, saya mendapatkan angka yang hilang terulang tanpa batas.

(Catatan: Saya banyak menggunakan float () dalam kode. Ini adalah Python yang melakukan pembagian floating-point alih-alih dengan mengatakan 2/3 = 0.)

Emacs Lisp 73 karakter

Cara terbaik untuk mengulang selamanya? Daftar siklik!

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

Tapi tunggu, masih ada lagi!

? \ ^ D adalah cara yang bagus untuk menyisipkan char untuk EOT, namun jika saya hanya mengirim file saya tidak akan memerlukan literal "\ ^ D" Saya hanya bisa memasukkan '?' diikuti oleh karakter EOT yang sebenarnya, sehingga mengurangi jumlah karakter yang dibutuhkan hingga: 63

Sunting

Saya telah bekerja pada "gel" yang belum merupakan bahasa nyata, tetapi pada dasarnya adalah serangkaian macro emacs lisp untuk kode golf. Dalam "gel" ini akan menjadi solusinya:

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

dan tanpa menunggu:

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

44 karakter dengan entri karakter yang bagus. Akan menjadi 34 jika bukan karena itu pengiriman web.

Julia

Dengan meneliti beberapa saat saya menemukan cara matematika untuk mengekspresikan urutan dengan urutan lain tanpa menggunakan salah satu angka (atau cara rumit untuk menggunakannya):

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]

Keluaran:

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

C ++

Bahasa bersih yang bagus seperti C ++ dapat memungkinkan Anda untuk meletakkan sumber Anda dengan cara yang rapi dan mudah dibaca, dan memiliki keuntungan karena mudah disalin dengan tangan dengan ambiguitas minimum.

Di sini solusinya dicapai hanya dengan menggunakan angka 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;
  }
}

Uji: http://ideone.com/fuOdem

Skema (Tipu Daya)

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

http://ideone.com/QBzuBC

Bisa dibilang ini melanggar aturan "jangan menyandikan angka di pangkalan lain", tapi saya pikir itu cukup jelas sehingga tidak masuk hitungan. Sebagai bukti ketidakjelasan ini, dua angka ajaib di base 51 adalah:

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

Sunting : Trik yang sama, representasi yang berbeda. Saya sebenarnya lebih menyukai yang ini, karena tidak tergantung pada pangkalan yang dipilih secara sewenang-wenang. Namun, itu membutuhkan implementasi skema dengan dukungan akurasi tak terbatas untuk irasional kuadrat, yang (AFAIK) tidak ada. Anda bisa mengimplementasikannya dalam sesuatu seperti Mathematica.

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

PHP

Saya pikir sudah saatnya seseorang mengajukan jawaban php, bukan yang terbaik tetapi yang menyenangkan pula

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

Ahs adalah teriakan para penumpang saat pesawat jatuh

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