프로그램을 인쇄하는 프로그램


13

도전

당신의 목표는 다른 프로그램을 인쇄하는 프로그램을 작성하는 것입니다. 인쇄 된 프로그램은 다른 프로그램을 인쇄해야하며 새 프로그램은 끝날 때까지 다른 프로그램을 인쇄해야합니다.

규칙

  1. 각 프로그램은 256 바이트 미만이어야합니다. (이것을 변경해야 할 경우 의견을 남겨주세요)
  2. 마지막 프로그램은 빈 프로그램이어야합니다.
  3. 한정된 수의 프로그램이 있어야하므로 프로그램은 엉망이 될 수 없습니다.
  4. 프로그램은 모두 같은 언어로 실행해야합니다.
  5. 입력이 허용되지 않습니다.
  6. 우승 프로그램은 가능한 많은 프로그램을 인쇄하고 자체를 세는 프로그램입니다.

행운을 빕니다!


최대 점수는 2^2048또는 3.2317e616입니다.
orlp

큰 점수를 쉽게 비교할 수 있도록하기 위해 a*10^b, 1<=a<10그리고 b자연수 형식으로 점수에 근사값을 포함 시키십시오 .
flawr

2
사실, 내 이전 계산이 잘못되었습니다. 프로그램이 바이트 단위 여야한다고 가정하면 가능한 최대 점수는 <댓글에 너무 긴 숫자> 또는 1.2673e614입니다.
orlp

답변:


20

CJam, 4.56 × 10 개 (526) 프로그램

2D#2b{"\256b_(256b:c'\s`_:(er`":T~{;38'ÿ*`{:T~{;63'ÿ*`{:T~{;88'ÿ*`{:T~{;114'ÿ*`{:T~{;140'ÿ*`{:T~{;166'ÿ*`{:T~{;192'ÿ*`{:T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}_~

실제 점수 : 254 219 + 254 192 + 254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 38 + 254 13 + 3

파일 크기 제한을 준수하려면 모든 프로그램을 ISO-8859-1 인코딩을 사용하여 저장해야합니다.

@ChrisDrost 덕분에 버그를 지적하고 중첩 접근법을 제안했습니다.

CJam 통역사 에서 온라인으로 사용해보십시오 .

254 (219) + 2 ≈ 4.56 × 10 (526) 프로그램

점수의 선분은 다음과 같은 훨씬 간단한 프로그램 1 로 달성 할 수 있습니다 .

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

이 프로그램을 실행하면 프로그램이 생성됩니다

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

이후 254 (219) - (1) 더 반복, 프로그램

{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

이 비어 있지 않은 마지막 프로그램은 오류 2 와 함께 종료되고 아무것도 인쇄하지 않습니다 (빈 프로그램).

작동 원리

문자열이 이미 스택에 있다고 가정하십시오.

{      e# Push a code block.
  \    e# Swap the string on top of the code block.
       e# This will cause a runtime error if there is no string on the stack.
  256b e# Convert the string (treated as a base-256 number) to integer (I).
  _(   e# Copy the integer and decrement the copy.
  256b e# Convert the integer into the array of its base-256 digits.
  :c   e# Cast each base-256 digit to character. Converts from array to string.
  '\s  e# Push a string that contains a single backslash.
  `    e# Push its string representation, i.e., the array ['" '\ '\ '"].
  _:(  e# Push a copy and decrement each character. Pushes ['! '[ '[ '!].
  er   e# Perform transliteration to replace "s with !s and \s with [s.
       e# This skips characters that require escaping.
  `    e# Push its string representation, i.e., surround it with double quotes.
  Q    e# Push an empty string.
  ?    e# Select the first string if I is non-zero, the empty string otherwise.
  \    e# Swap the selected string with the code block.
  "_~" e# Push that string on the stack.
}      e#
_~     e# Push a copy of the code block and execute it.
       e# The stack now contains the modified string, the original code block
       e# and the string "_~", producing an almost exact copy of the source.

(254 개) 192 ≈ 5.35 × 10 461 개 이상의 프로그램

이것은 상황이 약간 미쳐지는 곳입니다.

첫 번째 프로그램은 압축률이 높습니다. 빈 프로그램 대신에 위의 섹션에서 첫 번째 프로그램을 생성하는 유사한 프로그램을 작성함으로써 점수를 254 192 프로그램 3 향상시킬 수 있습니다 .

프로그램

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{"\256b_(256b:c'\s`_:(er`":T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}_~

이전 섹션의 첫 번째 프로그램과 유사하며 전자와 해당 출력을 254 192 반복 실행하면 후자가 생성됩니다.

문자열이 이미 스택에 있다고 가정하십시오.

{                           e# Push a code block.
  "\256b_(256b:c'\s`_:(er`" e# Push that string on the stack.
                            e# The characters inside it behave exactly as
                            e# they did in the previous section.
  :T~                       e# Save the string in T and evaluate it.
  {                         e# If the integer I is non-zero, keep the generated
                            e# string; else:
    ;                       e#   Pop the code block from the stack.
    219'ÿ*`                 e#   Push a string of 219 ÿ's (with double quotes).
    {Q?\"_~"}               e#   Push that block on the stack.
    s                       e#   Push its string representation.
    (\                      e#   Shift out the { and swap it with the tail.
    T                       e#   Push T.
  }?                        e#
  \                         e# Swap the selected string with the code block
                            e# or T with the tail of the code block.
  "_~"                      e# Push that string on the stack.
}                           e#
_~                          e# Push a copy of the code block and execute it.

무어 프로그램

이전 섹션의 첫 번째 프로그램은 여전히 ​​압축률이 높으므로 유사한 방법을 적용하고 254 166 회 반복 한 후에 위에서 언급 한 프로그램을 생성 하는 프로그램을 작성할 수 있습니다 .

우리는 255 바이트 한도에 도달 할 때까지 반복해서이 방법을 반복하면, 우리는 총 추가 254 166 + 254 140 + 254 114 + 254 88 개 + 254 63 개 + 254 38 개 + 254 13 + 1 ≈ 1.59 × 10 (399) 에 프로그램을 이전 섹션의 내용.


명확성을 위해 1 개의 줄 바꿈이 추가되었습니다.
2 단위의 메타에 대한 합의는 이 기본적으로 허용됩니다.
3 또는 0.0000000000000000000000000000000000000000000000000000000000000000000012 %



5

자바 스크립트, 1000 개 프로그램

x=999;
q=";alert(x=999?`q=${JSON.stringify(q)+q}`.split(x).join(x-1):``)";
alert(
    x ? `x=999;q=${JSON.stringify(q)+q}`.split(x).join(x-1) // basically .replaceAll(x, x-1)
      : ``
)

이것이 유효한지 여부는 세 번째 규칙을 이해하는 방법에 따라 다릅니다.


동일한 사본이 아닌 자체 소스 코드의 수정 된 버전을 인쇄하기 때문에 기술적 으로 문제 가되지 않습니다 . 그것은 명백히 quine-like 기술을 사용합니다. @TheTurtle의 설명이 필요하다고 생각합니다.
JohnE

5
@ JohnE와 Ypnypn 이것은 내가 상상 한 것과 같습니다. 작동합니다.
거북

6
여전히 코드 길이 제한보다 훨씬 낮습니다. 왜 999를 더 큰 것으로 바꾸지 않습니까?
DankMemes

4

루비, 1.628 × 10 ^ 237 프로그램

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;_="a=%#x-1;_=%p;puts _%%[a,_]if a";puts _%[a,_]if a

내 Perl 답변과 같은 접근 방식이지만 Ruby는 이미 큰 정수를 처리하기 때문에 16 진수로 저장하는 것이 더 쉽습니다.


루비, 9.277 × 10 ^ 90 프로그램

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;b=0xf;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-("%x"%a).length));_="a=%#x;b=%#x;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-('%%x'%%a).length));_=%p;puts _%%[a,b-1,_]if a";puts _%[a,b-1,_]if a

따라서이 시도는 이전의 quine-like와 약간 다른 변형이지만 모든 추가 기능으로 인해 다른 것보다 높은 곳에서는 숫자를 얻지 못합니다 ...하지만 다른 접근법을 시도하는 것이 흥미 롭습니다!


4

파이썬 2, 9.7 * 10 ^ 229 프로그램

O=0
if len(hex(O))<191:print"O=0x%x"%(O+1)+open(__file__).read()[-68:]

니스, 문자열 반복을 생각하지 않았습니다!
Dom Hastings

2

C, 2.2 * 10 ^ 177 프로그램

#define S(s)char*q=#s,n[]="#####################################################################################################";i;s
S(main(){while(n[i]==91)n[i++]=35;i==101?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})

완벽하지는 않지만 꽤 좋습니다. 정확히 255바이트 길이이며 동일한 길이의 프로그램을 생성합니다. 더 많은 프로그램을 얻기 위해 더 많은 것을 둘러 볼 수는 있지만 지금은 그대로 두겠습니다.

이 프로그램은 간단한 C 퀴즈를 기반으로합니다. 또한 char 배열의 가능한 모든 값을 계산하는 매우 간단한 계산 알고리즘이 n있습니다. 우리는 문자열의 순열만큼 많은 프로그램을 가지고 있습니다 n.

문자 범위는 #(= 35)에서 [= (91) 범위로 제한됩니다 . 왜냐하면 그들은 탈출해야하기 때문에 문자열 "이나 \문자열을 원하지 않기 때문입니다.

char 배열의 모든 값이 때 프로그램 생성은 종료 n이다 [. 그런 다음 간단한 더미 프로그램을 main(){}출력하며 자체적으로 아무것도 출력하지 않습니다.

#define  S(s) char *q = #s; /* have the source as a string */ \
char n[] = "#####################################################################################################"; \ 
int i; \
s /* the source itself */
S(main() {
    while(n[i]=='[') /* clear out highest value, so next array element be incremented */
        n[i++]='#'; 
    i==101 /* end of array reached? output dummy program */
        ? q = "main(){}"
        : n[i]++; /* count one up in the whole array */
    printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)", n, q);
})

그것이 작동해야한다는 데모로 방금 한계를 변경 했으므로 ASCII 코드 35와 문자 사이의 문자 36와 4 개의 배열 요소 만 사용했습니다.

결과 프로그램은

% echo > delim; find -iname 'program_*.c' | xargs -n1 cat delim

#define S(s)char*q=#s,n[]="####";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$###";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="###$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$##$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="####";i;s
S(main(){})

이것은 2^4 + 1 = 17다른 프로그램을 출력 합니다.

따라서 위의 프로그램은 ((91-35)+1)^101 + 1 = 57^101 + 1 ~= 2.2 * 10^177다른 프로그램을 출력 합니다. 이것이 중요하거나 계산이 올바른지 확실하지 않습니다.


1
이것에 관한 내용을 포함시켜 주 2.2 * 10^177시겠습니까 (비교하려는 사람들을 위해)?
flawr

이것을 계산하는 방법을
몰랐지만


1

펄, 1 × 10 ^ 163

그렇지 않으면 이것은 매우 기본적인 퀴네입니다. 가능한 적은 수의 문자로 줄이면 카운터가 아닌 동안 만 실행됩니다 0.

use bigint;$i=9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999||die;$_=<<'e';eval
print"use bigint;\$i=$i-1||die;\$_=<<'e';eval
${_}e
"
e

1

커먼 리스프, 10 (113) -1

(LET ((X
       99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999))
  (WHEN #1=(PLUSP X)
    #2=(SETF *PRINT-CIRCLE* T)
    #3=(PRINT (LIST 'LET `((X ,(1- X))) (LIST 'WHEN '#1# '#2# '#3#)))))
  • 113 개의 아홉이 있습니다.
  • 다음 프로그램은 112 9, 8이 뒤 따릅니다
  • 다음 프로그램은 112 9, 7이 있습니다
  • ...

9의 수 는 프린터가 도입 한 공간 을 고려 하여 최대 코드 크기 인 256으로 제한됩니다 .


1

펄, 1.4 * 10 ^ 225

use bignum;open$F,__FILE__;$_=<$F>;s/0x\w+/($&-1)->as_hex/e;0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff&&print

파이썬에 대한 비슷한 접근; 같은 결과!


0

> <> , 65534 (?) 프로그램

65533을 인쇄 할 수 있는지 아직 확인하지 않았으므로 65533 옆에 물음표를 추가했습니다 (믿어야 할 이유가 있음). 조금 더 시간이 있으면 테스트 방법을 알아낼 것입니다.

":?!;1-r00gol?!;a0.�

여기에서 온라인으로 사용해 볼 수 있습니다 .

이 프로그램의 요점은 맨 끝에 문자의 출력을 변경 한 다음 인쇄하기 전에 숫자 값을 줄입니다. 코드 끝에 문자의 ASCII 값이 65533이기 때문에 65534 프로그램을 얻었으므로 첫 번째 프로그램을 계산하면 65534입니다 (빈 프로그램을 65535으로 계산하면 추측합니다). "반환 된"마지막 프로그램은 아무것도 아닙니다. 문자 값이 0 일 때 간단히 종료됩니다.

모든 반복에 대해 문자를 인쇄 할 수 있다고 확신합니다.> <> 인쇄 가능한 문자 수에 대한 확실한 소스를 찾을 수 없지만 65533 바로 아래에 숫자가있는 문자가 있습니다.

이 구현에 문제가 있는지 알려주십시오. 출품작의 유효성에 대해 확신이 없습니다.


설명

나는 작은 따옴표를 사용하여> <> 위키에서 의사-퀸을 만들고 여기에서 한 번 언급 한 주석을 뻔뻔스럽게 도용했습니다.

":?!;1-r00gol?!;a0.�
"                     begins string parsing
 :?!;                 terminates program if final character is 0, numerically
     1-               decrements final character by 1
       r              reverses stack
        00g           grabs quotation mark (fancy way of putting " ")
           ol?!;      prints and terminates if stack is empty
                a0.   jumps back to o to loop 

따옴표 뒤에있는 모든 것을 문자로 구문 분석 한 다음 마지막 문자를 줄입니다. 거기서부터 올바른 순서로 인쇄하기 위해 스택을 뒤집고 따옴표를 스택에 넣은 다음 스택이 비워 질 때까지 인쇄합니다.


0

파이썬, 1 × 10 ^ 194 프로그램

n=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
if n:print open(__file__).read().replace(str(n),str(n-1))

대화식 repl이 아닌 파일에서 실행해야합니다 . 퀴네가 아닙니다.

3 바이트를 절약 할 수있게 해준 @The Turtle에게 감사합니다.
2 바이트를 절약하는 데 도움을 주신 @poke에게 감사드립니다.


@ 치즈 애호가 if n!=0중복됩니다. 당신은 단지 쓸 수 있습니다 if n.
거북

두 공간도 제거 할 수 있습니다. 인수 후 if n:replace인수 사이 .
찌를

0

배쉬, 52 프로그램

완전히 영감을받지 않았으며, 마지막에는 확실하게 견고합니다.

echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.