4, 8, 15, 16, 23, 42

이 일련의 숫자를 무한대로 출력하는 프로그램을 작성하십시오. 그러나 Numbers는 소스 코드에 어디에나 나타나서는 안됩니다.

다음은 Numbers가 소스 코드에 나타나기 때문에 Numbers를 출력하는 유효한 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로 계산됩니다.

대체 기준이 제한에 포함되므로 다음과 같습니다.

• 이진 100은 4를 대체 할 수 없습니다.
• 8 진수 10은 8을 대체 할 수 없습니다.
• 16 진 F는 15를 대체 할 수 없습니다.

따라서 다음은 Numbers가 소스 코드에 표시되지 않기 때문에 Numbers를 출력하는 유효한 (매우 고무적이지는 않은) 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);
        }
    }
}

그 프로그램이 참고 '*'과 '&'달리 번호 4, 8, 소스 코드에서 나타나는 것이기 때문에, 정수 (42) 및 (38)로 대체된다.

"시퀀스를 무한대로 출력한다" 라는 정의는 해석하기 쉽다. 예를 들어, "무한대"가 작아 질 때까지 글리프를 더 작게 출력하는 프로그램이 유효합니다.

기본적으로 각 숫자를 하드 코딩하지 않는 방식으로 시퀀스를 생성 할 수 있다면 좋습니다.

• 그것을 공식으로 도출. 내 인상은 하나는 없지만 어쩌면 존재하거나 가짜 일 수 있습니다.
• 의사 랜덤 생성기 를 수정 하여 시퀀스를 반환합니다.

이것은 인기 콘테스트이므로 창의력을 발휘하십시오. 3 월 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의 제안에 따라 스크립트에는 숫자가 포함되지 않습니다.

펄

소스 코드에는 숨겨진 것이 없습니다. 아니. 코드가 작동하지 않으면 use re "eval";앞에 입력 하십시오 (Perl 5.18 필요).

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

스포일러 설명.

이것은 여러 비트 단위 연산을 사용하고 = ~ 연산자를 사용하여 정규식을 평가하는 간단한 Perl 프로그램입니다 . 정규식은 (? { 로 시작하고 })로 끝납니다 . Perl에서는 정규 표현식을 평가하면서 코드를 실행 합니다. 실제로 사용하지 않고 eval 을 사용할 수 있습니다. 그러나 일반적으로 문자열에서 정규 표현식을 평가할 때 보안상의 이유로 "eval"을 다시 사용해야합니다 (일부 구형 프로그램은 실제로 사용자로부터 정규 표현식을 사용함). 그러나 Perl 5.18 이전에는 지속적인 접힌 표현식을 일으키는 버그가 있음이 밝혀졌습니다 이 pragma 없이도 작동하려면-Perl 5.18을 사용하는 경우 use re "eval"을 입력하십시오.코드가 작동하기 전에. 그 외에도이 코드에는 그다지 많지 않습니다.

Brainfuck

나는 ASCII 예술에 너무 나쁘다!

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

여기에서 테스트하십시오 : http://ideone.com/kh3DYI

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

씨#

https://oeis.org/A130826의 공식 "stolen" : a (n)은 가장 작은 수이므로 (a (n) -n) / 3의 약수의 두 배가 첫 번째 n 번째 항을 제공합니다 Flavius-Josephus sieve에 의해 생성 된 서열의 차이.

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

씨#

N-1 다항식에 의해 N 개의 시퀀스의 임의의 시퀀스가 ​​생성 될 수 있다는 사실을 이용하여 숫자를 입력하면 많은 경고음과 numbers이 발생합니다. 참고로, 도출 된 다항식은

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

나는 각 수마다 BEEP 수가 감소함에 따라 장력 상승의 의미를 좋아했습니다.

그런 다음 경고음과 ops을 사용하여 요인을 계산할 수 있다고 생각했습니다.

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를 0으로 초기화 할 수 있습니다. 이 방법으로 코드에는 숫자 리터럴이 사용되지 않습니다. 기본 알고리즘은 동일합니다. 그러나 요소는 인라인으로 계산됩니다.

디

내 코드에서 숫자 4, 8, 15, 16, 23 또는 42를 사용할 수 없습니까? 문제 없습니다. 숫자를 전혀 사용하지 않습니다!

import std.stdio;

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

자바 스크립트 + 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>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);}}

하스켈, 1 LoC

import Data.Char; main = putStr $ unwords $ map (show . (+)(-ord 'D') . ord) $ cycle "HLST[n" 

나는 Haskell이 얼마나 멋진 지 보여주기 위해 읽기 쉬운 1 라이너를 사용하기로 결정했습니다. 또한, 경우에 대비 하여 모든 숫자 를 피하기로 결정했습니다 .

내장 된 게으른 평가 덕분에 Haskell은 무한히 긴 목록을 조작 (맵, 분할, 결합, 필터링 ...) 할 수 있습니다. 그것들을 만들기 위해 여러 내장 기능이 있습니다. 문자열은 문자 목록 일 뿐이므로, 긴 문자열은 Haskell에게 미스터리가 아닙니다.

매스 매 티카

아래에 나와 있는 주기적인 연속 분수 의 반복 부분 분모에 중점을 두어 질문에 대답 할 수 있습니다. 그것들은 우리가 필요로하는 것입니다.

결국, 그들은 우리가 생산하려고하는 종료되지 않는 시퀀스를 구성합니다 : 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

Mathematica 에서 주기적 연속 분율에 해당하는 2 차 비이성적 인

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

여기서 0은 암시 적 정수 부분을 나타냅니다.

작업을 반전시켜 확인할 수 있습니다.

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

4와 8은 도전 규칙 중 하나를 위반합니다. 부분 문자열 15은 추가 위반입니다. 규칙을 만족시키기 위해 2 차 비이성적 인 형식을 다시 지정할 수 있습니다.

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

가독성을 위해 줄 바꿈이 추가되었습니다. 이는 OEIS 시퀀스 A130826 의 처음 6 개 숫자라는 사실을 사용합니다 .

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을 포함하지 않는 적절한 초기화 5 분의 1을 찾을 수 있습니다.

파이썬 3 :

l = [3053, 937, -1396, -1757, -73]
while l[-1] != 66:
    l.append(l[-5] + l[-3] + l[-1])
while True:
    print(l[-6:-1])

자바 스크립트

좋은 숫자는 전혀 없습니다. 그러나 루프를 통과 할 때마다 시퀀스를 한 번 인쇄하는 대신 패스 당 한 번만 인쇄하십시오.

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}

C ( 54 50 문자)

골프는 최소한 재미 있기 때문에 골프 답변을 게시하고 있습니다.

main(a){while(printf("%d\n","gAELMT"[a++%6]-61));}

하스켈

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

편집 : 나는 또한 그의 두 번째 프로그램을 좋아했으며 2 차 비이성적 ;-) 의 Haskell 구현을 작성 했습니다 . 이 프로그램은 라이브러리와 agrif의 매직 넘버를 사용하여 시퀀스를 인쇄합니다.

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. 식의 값을 변경하지 않으면 서 숫자에서 허용되지 않는 숫자 시퀀스를 제거하는 요소를 찾는 것만으로도 충분합니다.

씨#

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에서 가져온 패턴을 사용했지만 숫자를 나타내는 고유 한 함수 집합을 만들기로 결정했습니다.

내가 만든 첫 번째 함수는 periodic ()입니다. 삼각 함수의 주기적 특성을 사용하여 6 개의 입력 번호를 반복하는 기능입니다. 다음과 같이 진행됩니다.

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

그런 다음 polynomial ()을 만듭니다. 다음 다항식을 사용합니다.

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

내 코드에서 일부 계수는 잃어버린 숫자를 숫자 중 하나로 포함하기 때문에 합계로 표시됩니다.

이 다항식은 다음과 같이 periodic () 출력을 적절한 손실 수로 변환합니다.

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

지속적으로 i를 늘리고 두 함수를 모두 통과함으로써 잃어버린 숫자가 무한대로 반복됩니다.

(참고 : 코드에서 float ()를 많이 사용합니다. 따라서 파이썬은 2/3 = 0 대신 부동 소수점 나누기를 수행합니다.)

이맥스 리스프 73 자

영원히 반복하는 가장 좋은 방법은? 주기적 목록!

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

그러나 더 많은 것이 있습니다!

? \ ^ D는 EOT에 문자를 삽입하는 좋은 방법이지만 파일을 제출하는 경우 리터럴 "\ ^ D"가 필요하지 않습니다. '?' 그 뒤에 실제 EOT 문자가 오므로 실제 필요한 문자 수를 63으로 줄입니다.

편집하다

나는 아직 실제 언어는 아니지만 기본적으로 코드 골프를위한 일련의 emacs lisp 매크로 인 "gel"을 연구하고있다. "gel"에서는 이것이 해결책입니다.

(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

계획 (가일)

(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) 존재하지 않는 2 차 비이성 화에 대해 무한 정확도를 지원하는 체계 구현이 필요합니다. 그래도 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).'
        ';
    }
}

비행기가 추락 할 때 승객의 비명

펄

#!/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;
}