매우 간단합니다. 프로그램이나 함수는 다음 텍스트를 생성해야합니다.

Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.

파인 프린트

당신은 쓸 수 있습니다 프로그램이나 기능 , 문자열이나 STDOUT (또는 가장 가까운 대안)에 인쇄로 출력을 반환합니다. 선택적으로 출력에 단일 후행 줄 바꿈을 포함시킬 수 있습니다.

채점

코드의 바이트 수에 코드 의 고유 바이트 수를 곱한 값

최저 점수가 이깁니다.

예를 들어, 곱셈기가 매우 낮을 때 (각각 8과 3) 브레인 씨발이나 공백 응답이 큰 이점을 갖습니다. 그러나 일반적으로 해당 언어로 프로그램을 작성하면 훨씬 더 긴 코드가 생성되므로 이러한 이점을 무시할 수 있습니다.

더 이상 재미 있지 않은 표준 허점 은 금지되어 있습니다.

code-challenge string kolmogorov-complexity

— 듀론 597
소스

케이싱이 정확해야한다고 가정합니까?

— EnragedTanker

@crayzeedude 그렇습니다, 그것은 일종의 요점입니다

— durron597

좋구나. 명확하게. : p

— EnragedTanker

1

@CarpetPython 샌드 박스에서 이에 대한 토론이 있었으며 궁극적으로 경기장의 레벨을 올릴 방법이 없다고 결정했습니다. 여백과 불면증은 어쨌든 가장 높은 점수를받습니다!

— durron597

2

내가 어딘가에 쓴 것처럼, 우리가 덜 독특한 문자를 보상하기 위해 더 많은 바이트를 사용하는 것은 숫자를 다른베이스로 변환하는 것과 비슷하게 작동 bytecount~Log(X,unique)하지만 X는이 문제에 대해 일정합니다. 따라서 unique ^ bytecount ~ 상수입니다. 이 점수 (log2)를 계산하면가

python2_mbomb007 728, python2_carpetpython 744, ruby 756, Fish 825, Insomnia 1148, cjam 1277, whitespace 1484, brainfuck 3546

됩니다. 그래서 brainfuck 답변을 제외하고는 비교적 일정합니다 ...

— blutorange

7

불면증 , 575 바이트 * 4 = 2300

dyedd=dyyyye=d=yd=dddde=ded=deey=eyy=de=edd=eydyee=yeyy=yey==ddyee=eydee=y=eyeedd=dde=yddd=eede=yedde=eeyd==yeyy=yyddy=eyy=dy=dddye=dyey=ede=yddd=dde=de=yyye=yyye=ddyyy=dyy=yeyddy=eyyyde=eed=ddd=yd=edyyd=eeydd=yedd=eye=eee=eeyy=yyyedde=d=eyyyedy=d=yddyye==dyyede=ddd=eydd=yd=ddde==eeeeyy=yeyd=deyy=yyy=ydy=dy=dd=e=ey=dddddy=yeey=ey=eed=ddd=eedy=ddddde=ydeyy=edd=ydy=ddy=yeedd=ydde=dde=edyye=ded=yeed=dddddde=eedy=eyde=ydy=ydydd=eyydd=dd=dddd=ddyye=ydeey=ed=eeeye=y=ydydde=eyyd=eyee=dy=edeyed=dyed==eyyddey=dd=yddd=yddd=de=ddedy=eyydd=eeedy==eyyydeee=d=d=eydd=yey=dyy==yyyedy=

4자를 사용합니다 dye=.

솔루션 1b (게시되지 않음) : 783 바이트 * 3 = 2349

eeeeyeeyy=eeyy=yeyye=yyyeeyye=eeeye=yeyey=eyeyyy=eyy=eeyeye=yeyeyyy=yyeeye=yeyy=yey==yyeyeyeye=eyyey=y=yyyyyy=y=eyyeyyyyyyye=eeye=yyeeyye=eyeyeyyy==yeyy=yeyyyeyye=yyyeeyy==eeyyeee==eeyye=yyyyeyyeyyye=yyyyyyy=yeye=eyyyyy=eeye=eeyeeeeey=eyeye=eeee=yeyyye=eyyyyye=y=eeeyyy=eyyeyee=yyy=eyye=yeyeeee=yyeyeyyyy=eeyy=yyyyy=eyyyy=yyeeyye=e=eyyyyy=eyey==eyeyy=yyyyyeyeyeye=ye=yyyyyy==eeeeyy=yeye=yeyyey=yyy=eyyyeeeye==yeeyyeyy=e==yeeeyyyeyy=yeey=ey=eee=eyeyy=yyeeee=yeeyyyyy=yee=yeyyy=yeeeeyy=eyeeeeeye=eeeyy=yyeeeeyyye=yey=yyyyeeyye=yyyyyyy=yeee=eeeeyyeye=eyeeye=eeyyeyyy=eeyee=yyyyyeeyy=eee=eeyyeyyyyy=eeey=eyyeeyy=eyyeyyy=eeeeyeee=eeeye=y=yyyeyy=yyeeee=yyeyey=ey=eyyyyyeyyy=yeye==yeeyyyeyy=yeye=yyyyeeyy=eeeyyeeyyy=yeeyeyyy=eeyye=eee=eyyye==eyeyeyyyyy=e=eeyeeye=yeey=eyeyy=eyeye=ey=eyyeye=

3 자만 사용합니다 ey=.

해결 방법 1 : 826 바이트 * 3 = 2478

yoyoy~oyoyo~oyooyy~ooyyoyy~ooyyyyoy~~yoyyo~ooyoooyooo~yoyyo~oyoyoyyy~yyo~oyyoo~~ooooy~oyyyyy~oyoyoo~~oyyyoooyy~~oyoyooyyy~yyooo~yoyo~yoyyyyo~yooyo~y~yyoyyyooyy~oyyooy~ooyoy~oyyooy~ooyyo~yoyyoo~o~ooyo~yooyyoo~yoyoy~ooyyyyooo~oyoyyo~yyoyyyoo~yyo~yyooyyo~yoyyoooy~~yoyyyooyoyy~oyoyyy~yoooyyoy~yooyy~yooyyo~yyooyyoo~oyoyo~oyyy~oyyo~oyyoyo~oyyyoo~oyoyyoo~yooyo~ooooo~~yoyyoyyoyoo~yoyyooo~y~ooooy~yyyoy~ooooyyoyyoy~oyyoo~oyyoyo~yoyyyooy~oyooo~yoyyoyy~yyyyyo~oyooy~oyoyy~yoyyyoy~ooyoy~yoyyoooy~~oyyyo~ooooooy~yooyoyyoyo~yooyyo~oooyyo~yoyooyyo~oyyy~o~yooooy~oyoyyooooy~~yoyyooyyo~oy~yyyoyyyyy~yoyyyoy~yooo~oooy~oooooyyoyyyo~yoyyo~y~oooyyyoyoo~yyooooyoyy~y~oooyyyoy~~yoy~oyyoyoyyy~yoyyyyy~oyooo~yyyyooo~yooyyoy~yooyo~yoyyyo~yyoyyyo~o~ooooooyoy~oyoyyoy~yyoooo~ooooyy~oyoyoy~ooyyo~yyoooyo~yyyyyo~oyyo~yooyyooyyoy~~ooyyyyoyyy~ooyyo~yyooo~

3 자만 사용합니다 : yo~. 이를 생성하기 위해 프로그램이 사용됩니다.

현재 모든 프로그램은 명령 0, 1, 2, 6 만 사용합니다. 즉, 단일 바이트의 비트를 조작하여 결과를 인쇄합니다.

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
소스

19

CJam, 266 281 456 바이트 * 14 12 7 독특한 = 3724 3372 3192

온라인으로 사용해보십시오.

14301201124204202034420112034224204431020210101232301021240204310431312122132100240400222324402030223103420431324402222132223233141443401210314023001122320404112224314302132421403301243334313000011124244441400003310332301330220022110121411122100040310110020040121444302100143202204330334033211334242120304123121024200421121232100303121022431044444423243331440434010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

설명

내가 사용한 전략은 문자열의 각 문자를 기본 123 자리로 처리하고 프로그램에서 10 진수로 인코딩하는 것입니다. 그런 다음 프로그램은 해당 숫자를 다시베이스 123으로 변환하고 각베이스 -123 숫자를 문자로 다시 매핑합니다. 프로그램이 현재 상태에있는 이유를 설명하기 어렵 기 때문에 각 버전에 대해 설명하겠습니다.

첫 번째 버전에서 프로그램의 끝은 다음과 같습니다.

...2068438725 123b:c

이를 통해 가장 간단한 방법으로 전략을 구현합니다. 기본 10으로 정상적으로 인코딩 된 숫자는 기본 123으로 다시 변환되고 각 기본 123 자리는 문자로 다시 매핑됩니다. 그러나 이것은 숫자가 아닌 4 개의 고유 한 문자를 사용하며 그중 하나를 제거 할 수 있으면 덜 간단한 코드를 사용해야하기 때문에 크기가 적습니다.

먼저, ASCII 문자 값을 문자로 변환 된 ASCII 문자 값 (이미 존재하는 연산자로) 을 런타임에 작성하고 연산자로 평가 b하여 :연산자 와 연산자를 제거 할 수 있음을 깨달았습니다 . 다음 연산자 와 함께 구문 분석해야하기 때문에 연산자 로이 작업을 수행하는 데 약간 까다로운 것으로 나타났습니다 . 나는 문자를 생산하여이 문제를 해결 하고 다음 생산 및 특성 평가 문자열로 전 두 글자를 연결 한 다음 제대로 평가 될 수있다.c~:c:c+:c

둘째, ~방금 소개 한 연산자에 편리한 새로운 오버로드 변형이 있음을 깨달았습니다 . 숫자 다음에 이것을 두 번 연속으로 사용함으로써 결과 계산 효과없이 소스에 토큰 나누기를 도입하여 숫자를 구분하는 데 사용되는 공백을로 바꿀 수 있습니다 ~~.

최종 결과는 결국 15 바이트 이상의 코드이지만,이 비용은 14 개 중 2 개의 고유 한 문자를 제거함으로써 얻을 수있는 이점보다 훨씬 중요합니다. 다음은 첫 번째 버전의 끝과 두 번째 버전의 끝을 비교 한 것입니다.

...2068438725  123[ b  ][   :c    ]
...2068438725~~123~~98c~58c99c43c~~

내가 사용하고있는 2 연산자보다 적은 수를 사용하는 것은 불가능하지만 여전히 더 적은 고유 문자를 원했습니다. 다음 단계는 숫자를 제거하는 것이 었습니다. 숫자의 인코딩을 변경하여 각 십진수가 실제로 5 자릿수가되도록 숫자 6-9를 제거 할 수 있습니다. prgoram의 끝에서 아무것도 제거하기 전에 다음과 같이 보였습니다.

...4010014400 10b5b123b:c

앞에서 언급했듯이 공간을 쉽게 제거 할 수 있습니다. 그러나이 b, :그리고 c자신의 문자 코드는 한, 너무 쉽게되지 않을 것 98, 58그리고 99각각. 이들은 모두 제거 표시가 된 숫자를 포함하고 있었기 때문에 모든 것을 도출 할 수있는 방법을 찾아야했습니다. 문자 값이 5-9를 포함하지 않는 유용한 숫자 연산자는 감소, 증분, 곱하기 및 더하기뿐입니다.

에 대해 98처음에는을 사용 100~~40c~40c~했는데 100두 번 감소 했습니다. 그러나 ~비트 보수를 통해 음수를 얻을 수 있으므로 더할 때 빼기를 모방 할 수 있기 때문에 연산자를 다시 사용할 수 있다는 것을 깨달았습니다 . 그때 사용 그래서 100~~1~43c~, 이는 추가 100하고 -22 작은 바이트입니다. 를 들어 58, 내가 사용 44~~14~~43c~, 추가하는 44과 14. 그리고 99, 나는 100~~40c~감소 시켰습니다 100.

최종 결과는 상당히 크고 난독 처리되었지만 12 개 중 5 개의 고유 한 문자를 제거하면 큰 수와 처리 코드의 비용이 약간 더 컸습니다. 제거 :

...4010014400  10[      b      ][  5  ][     b     ]123[      b      ][            :c            ]
...4010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

— 런너 112
소스

좋아, 이제 감동 받았다. 기본 6 자리, 기본 7 자리 등을 기본 5 자리와 어떻게 비교합니까?

— durron597

@ durron597 그들은 정말 (내가 필요로하는 사업자의 문자 코드와 같이 계산이 쉬워하지 않는 98, 58그리고 99범위를 벗어난 여전히). 베이스를 늘리면 프로그램의 전체 크기가 8-10 % 감소하는데, 이는 새로운 고유 한 캐릭터를 통해 얻은 10-15 % 점수를 보충하기에 충분하지 않습니다. b마찬가지로 연산자를 다시 포함시키는 것은 가치가 없습니다.

— Runer112

숫자 x를 가지고 밑을 b로 바꾼다. 길이는 floor(log_b(x)+1)이며 b다른 기호 를 포함합니다 . 점수는 b*floor(log_b(x)+1)입니다. x는 주어진 큰 숫자이며, b에 대해 이것을 플로팅하면 최소값은 b = 3에 가깝습니다. 즉, 더 높은 염기 (로그)를 사용하면 길이가 약간 줄어들지 만 문자 세트의 크기는 선형으로 증가하므로 가치가 없습니다. 간단한 공백 프로그램을 만들었으나 4134 점을 얻었습니다.

— blutorange

@blutorange 공백 프로그램을 작성해야합니다. 4134면 충분합니다

— durron597

16

공백, 1157937 바이트 * 3 고유 = 3471 2811

인기있는 (?) 요청으로 공백 솔루션을 게시하고 있습니다.

필요한 코드를 줄이기 위해 전체 문자열을 하나의 이진수 (각 바이트 당 7 비트)로 하드 코딩했습니다. 간단한 루프는 문자를 추출하여 인쇄합니다.

filebin.ca의 소스 코드

참고 : 사양은 임의의 큰 정수를 허용 하지만 공식 페이지 의 Haskell 인터프리터 는 20 비트로 제한됩니다. 예를 들어, github / hostilefork / whitespaces에서이 루비 인터프리터를 사용하십시오 .

공백 프로그램을 작성하는 루비 스크립트 (l = WHITESPACE, t = TAB, u = NEWLINE, // 이후의 모든 것을 무시하고 파일에 씁니다 prog.h) :

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'

def b2ws(bin)
    bin.chars.map{|x|x=='0' ? "l" : "t"}.join
end
def d2ws(dec,pad=0)
    b2ws(dec.to_s(2).rjust(pad,'0'))
end

bin = str.reverse.chars.map do |x|
    "  " + d2ws(x.getbyte(0),7) + " // char <#{x=="\n" ? "LF" : x}>"
end
data = "lll // pushes string as one large number\n#{bin.join("\n")}\nu"

File.open('prog.h','w') do |fout|
    fout << data << "\n"
    fout << <<-eos

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu
    eos
end

예를 들어, 사람이 읽을 수있는 형태의 공백 프로그램. 실제 공백 프로그램으로 변환하는 간단한 스크립트는 아래를 참조하십시오.

lll // pushes string as one large number
  ltltttl // char <.>
  ttltltt // char <k>
  ttltttt // char <o>
  ttltttt // char <o>
  ttlttll // char <l>
  ltlllll // char < >
  ttllllt // char <a>
  ltlllll // char < >
  ttlltlt // char <e>
  ttlttlt // char <m>
  ltlllll // char < >
  ttllttt // char <g>
  ttltttl // char <n>
  ttltllt // char <i>
  tttlttl // char <v>
  ttltllt // char <i>
  ttllttt // char <g>
  ltlllll // char < >
  ltllltl // char <">
  ltlttll // char <,>
  tlllttt // char <G>
  tlltttt // char <O>
  tllltll // char <D>
  ltlllll // char < >
  tlttllt // char <Y>
  tlttltl // char <Z>
  tlllllt // char <A>
  tllttll // char <L>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltlllll // char < >
  tltlltl // char <R>
  tllltlt // char <E>
  tltlttl // char <V>
  tlltttt // char <O>
  ltlllll // char < >
  tltlltt // char <S>
  tltllll // char <P>
  tllttlt // char <M>
  tltltlt // char <U>
  tlltltl // char <J>
  ltlllll // char < >
  tlttlll // char <X>
  tlltttt // char <O>
  tlllttl // char <F>
  ltlllll // char < >
  tlltttl // char <N>
  tltlttt // char <W>
  tlltttt // char <O>
  tltlltl // char <R>
  tlllltl // char <B>
  ltlllll // char < >
  tlltltt // char <K>
  tlllltt // char <C>
  tlltllt // char <I>
  tltltlt // char <U>
  tltlllt // char <Q>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltllltl // char <">
  ltlllll // char < >
  ltttltl // char <:>
  ltltllt // char <)>
  ttlltlt // char <e>
  ttllltt // char <c>
  ttllllt // char <a>
  ttlltlt // char <e>
  tttllll // char <p>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttlt // char <m>
  ltlllll // char < >
  tttlltl // char <r>
  ttltttt // char <o>
  ttllttl // char <f>
  ltlllll // char < >
  ttttllt // char <y>
  ttlltll // char <d>
  tttlttt // char <w>
  ttltttt // char <o>
  tttlltl // char <r>
  ltlllll // char < >
  ttltttt // char <o>
  ttltttt // char <o>
  tttltll // char <t>
  ltlllll // char < >
  tttltll // char <t>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltltl // char <j>
  ltltlll // char <(>
  ltlllll // char < >
  ttlltll // char <d>
  ttlltlt // char <e>
  tttltll // char <t>
  ttltttt // char <o>
  tttltlt // char <u>
  tttlllt // char <q>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttll // char <l>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltttt // char <o>
  ttltllt // char <i>
  ttttlll // char <x>
  ttltttt // char <o>
  ttltttl // char <n>
  ttllltl // char <b>
  ttltttt // char <o>
  ltlllll // char < >
  ttltlll // char <h>
  tttltll // char <t>
  ttlltlt // char <e>
  ttllltl // char <b>
  ttllllt // char <a>
  ttttltl // char <z>
  ttltllt // char <i>
  ttlttll // char <l>
  tllltlt // char <E>
u

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu

기본적으로 출력 할 문자열은 긴 정수이므로 점수를 줄여야합니다.

숫자 x를 가지고 밑을 b로 바꾼다. 길이는 floor(log_b(x)+1)이며 b다른 기호 를 포함합니다 . 점수는 b*floor(log_b(x)+1)입니다. x주어진 큰 숫자이며, b에 대해 이것을 플롯하면 최소값이 거의 비슷합니다 b=3(그리고 b=2거의 좋습니다). 즉, 더 높은 염기 (로그)를 사용하면 길이가 약간 줄어들지 만 문자 세트의 크기는 선형으로 증가하므로 가치가 없습니다.

따라서 0/1 만있는 언어를 찾았지만 찾지 못했습니다. 공백이 있음을 기억하고 시도했습니다. 공백에서 0과 1을 사용하여 이진수를 직접 입력 할 수 있습니다.

오래된 코드, 더 나쁜 점수이지만 더 흥미로운

filebin의 이전 코드 .

프로그램을 만드는 데 사용한 루비 스크립트 (l = WHITESPACE, t = TAB, u = NEWLINE, //무시한 후에 는 파일에 씁니다 prog.h) :

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.' + "\n"

def shift(x)
    (x-97)%128
end

EOS = "lttltl" #26
STACK = []

bin = str.reverse.chars.map do |x|
    byte = shift(x.getbyte(0))
    rf = STACK.index(byte)
    STACK.unshift(byte)

    y = byte.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
    ph = "lll#{y}u" # pushing directly
    if rf
        bn = rf.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
        cp = "ltll#{bn}u" # copying from stack
    end

    if STACK.size>0 && STACK[0]==STACK[1]
        "lul // dup #{x.inspect}"
    elsif cp && cp.size < ph.size
        "#{cp} // copy <#{x.inspect}> (from #{rf})"
    else
        "#{ph} // push <#{x.inspect}> (#{shift(x.getbyte(0))})"
    end
end

File.open('prog.h','w') do |fout|
    fout << "ll#{EOS}u // push EOS" << "\n"
    fout << bin.join("\n") << "\n"
    fout << <<-eos
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  ll#{EOS}u // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu
    eos
end

예를 들어, 사람이 읽을 수있는 형태의 공백 프로그램. 실제 공백 프로그램으로 변환하는 간단한 스크립트는 아래를 참조하십시오.

lllttltlu // push EOS
llltltlltu // push <"\n"> (41)
llltllttltu // push <"."> (77)
llltltlu // push <"k"> (10)
llltttlu // push <"o"> (14)
lul // dup "o"
llltlttu // push <"l"> (11)
lllttttttu // push <" "> (63)
llllu // push <"a"> (0)
ltlltu // copy <" "> (from 1)
llltllu // push <"e"> (4)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
lllttlu // push <"g"> (6)
lllttltu // push <"n"> (13)
llltlllu // push <"i"> (8)
llltltltu // push <"v"> (21)
ltlltu // copy <"i"> (from 1)
lllttlu // push <"g"> (6)
ltllttlu // copy <" "> (from 6)
llltllllltu // push <"\""> (65)
llltlltlttu // push <","> (75)
lllttllttlu // push <"G"> (102)
lllttltttlu // push <"O"> (110)
lllttlllttu // push <"D"> (99)
ltlltltu // copy <" "> (from 5)
lllttttlllu // push <"Y"> (120)
lllttttlltu // push <"Z"> (121)
lllttlllllu // push <"A"> (96)
lllttltlttu // push <"L"> (107)
ltlltllu // copy <" "> (from 4)
lllttlltllu // push <"E"> (100)
lllttlltttu // push <"H"> (103)
llltttllttu // push <"T"> (115)
ltllttu // copy <" "> (from 3)
llltttllltu // push <"R"> (113)
ltlltllu // copy <"E"> (from 4)
llltttltltu // push <"V"> (117)
ltlltttlu // copy <"O"> (from 14)
ltlltllu // copy <" "> (from 4)
llltttlltlu // push <"S"> (114)
lllttlttttu // push <"P"> (111)
lllttlttllu // push <"M"> (108)
llltttltllu // push <"U"> (116)
lllttltlltu // push <"J"> (105)
ltlltltu // copy <" "> (from 5)
llltttltttu // push <"X"> (119)
ltlltlllu // copy <"O"> (from 8)
lllttlltltu // push <"F"> (101)
ltllttu // copy <" "> (from 3)
lllttlttltu // push <"N"> (109)
llltttlttlu // push <"W"> (118)
ltlltllu // copy <"O"> (from 4)
ltlltllltu // copy <"R"> (from 17)
lllttlllltu // push <"B"> (97)
ltlltltu // copy <" "> (from 5)
lllttltltlu // push <"K"> (106)
lllttllltlu // push <"C"> (98)
lllttltlllu // push <"I"> (104)
ltllttttu // copy <"U"> (from 15)
llltttllllu // push <"Q"> (112)
ltlltltu // copy <" "> (from 5)
ltllttlltu // copy <"E"> (from 25)
ltllttttlu // copy <"H"> (from 30)
ltllttttlu // copy <"T"> (from 30)
llltllllltu // push <"\""> (65)
ltlltllu // copy <" "> (from 4)
llltlttlltu // push <":"> (89)
llltlltlllu // push <")"> (72)
llltllu // push <"e"> (4)
llltlu // push <"c"> (2)
llllu // push <"a"> (0)
llltllu // push <"e"> (4)
lllttttu // push <"p"> (15)
ltlltttu // copy <" "> (from 7)
lllttlllu // push <"y"> (24)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
llltllltu // push <"r"> (17)
llltttlu // push <"o"> (14)
llltltu // push <"f"> (5)
ltllttu // copy <" "> (from 3)
ltllttlu // copy <"y"> (from 6)
lllttu // push <"d"> (3)
llltlttlu // push <"w"> (22)
llltttlu // push <"o"> (14)
ltlltttu // copy <"r"> (from 7)
ltlltltu // copy <" "> (from 5)
ltlltlu // copy <"o"> (from 2)
lul // dup "o"
llltllttu // push <"t"> (19)
ltllttu // copy <" "> (from 3)
ltlltu // copy <"t"> (from 1)
llltlltlu // push <"s"> (18)
llltltllu // push <"u"> (20)
llltlltu // push <"j"> (9)
llltllltttu // push <"("> (71)
ltlltltu // copy <" "> (from 5)
lllttu // push <"d"> (3)
llltllu // push <"e"> (4)
ltlltttu // copy <"t"> (from 7)
llltttlu // push <"o"> (14)
ltlltttu // copy <"u"> (from 7)
llltllllu // push <"q"> (16)
ltllttlu // copy <" "> (from 6)
lllttlllu // push <"y"> (24)
llltlttu // push <"l"> (11)
llltlltlu // push <"s"> (18)
ltlltltu // copy <"u"> (from 5)
llltttlu // push <"o"> (14)
llltlllu // push <"i"> (8)
llltltttu // push <"x"> (23)
ltlltlu // copy <"o"> (from 2)
lllttltu // push <"n"> (13)
llltu // push <"b"> (1)
ltlltlu // copy <"o"> (from 2)
ltlltlttu // copy <" "> (from 11)
llltttu // push <"h"> (7)
llltllttu // push <"t"> (19)
llltllu // push <"e"> (4)
llltu // push <"b"> (1)
llllu // push <"a"> (0)
lllttlltu // push <"z"> (25)
llltlllu // push <"i"> (8)
llltlttu // push <"l"> (11)
lllttlltllu // push <"E"> (100)
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  lllttltlu // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu

이 공백 프로그램 자체는 다소 단순하지만 세 가지 골프 최적화가 있습니다.

lul중복 문자가있을 때 스택을 복제하는 데 사용
ltl문자를 직접 푸시하는 것보다 짧은 경우 스택의 n 번째 항목을 복제하는 데 사용
모든 바이트를 97 (mod 128) 씩 아래로 이동하고 이진수를 작게 만듭니다.

사람이 읽을 수있는 공백 코드를 실제 공백 프로그램으로 변환하는 간단한 루비 스크립트 (파일 읽기 prog.h및 파일 쓰기 prog.ws) :

WHITESPACE = "l"
NEWLINE = "u"
TAB = "t"

File.open('prog.ws','w') do |fout|
    code = ""
    fin = File.read('prog.h')
    fin.each_line do |line|
        line.gsub!(/\/\/.*/,'')
        line.scan(/#{NEWLINE}|#{WHITESPACE}|#{TAB}/i) do |x|

            code << case x.downcase
            when NEWLINE.downcase
                "\n"
            when WHITESPACE.downcase
                " "
            when TAB.downcase
                "\t"
            else
                ""
            end
        end
    end
    fout << code
end

— blutorange
소스

후행 줄 바꿈은 선택 사항이므로 인쇄하지 않으면 몇 문자를 저장할 수 있습니다.

— durron597

고마워요 원래 Haskell 인터프리터가 디버그 출력을 추가했기 때문에 포함했지만 루비가 있으면 깨끗해 보입니다.

— blutorange

7

루비 144 바이트 * 39 고유 = 5616

puts"Elizabeth obnoxiously quoted (just too rowdy for my peace): \"#{'the quick brown fox jumps over the lazy dog,'.upcase}\" giving me a look."

때로는 가장 간단한 것이 가장 좋습니다.

— 메가 톰
소스

데이터에서 단순화를 사용하지 않습니다. Cjam 및 공백 예제는 몇 가지 설명과 함께 인상적인 점수를 받았습니다. 깔끔한 언어로 깔끔한 코드를 사용할 수있는 보너스에도 불구하고, 구성하기에는 너무 많은 근거가 있습니다 !!! 어쩌면 당신은 길이 + 고유 득점 대회 에 다시 들어갈 수 있습니다 .

— Jose_X

6

Brainfuck, 1264 바이트 * 7 고유 = 8848

네, 끔찍한 점수입니다.

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

— mbomb007
소스

더 적은 고유 문자를 사용할 수는 있지만 길이는 10795, 곱하기 5 = 53975입니다.

— mbomb007

당신은 그것이 +.더 작을 지 확실하지 않고 그것을 할 수 있습니다.

— captncraig

만 사용 +하고 .15018 * 2 =를 얻습니다 30,036.

— captncraig

6

> <> (물고기)-578 바이트 * 8 고유 = 4624

14121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p

내 점수는 기대했던 것만 큼 경쟁력이 없지만이 솔루션이 여전히 게시하기에 충분히 흥미 롭다고 생각했습니다.

설명

코드의 첫 번째 섹션은 문자열의 각 문자에 대해 3 자리 기본 5 표현을 나타내는 숫자 0-4의 긴 문자열입니다. 나머지 코드는 p프로그램을 실행하는 동안 프로그램의 소스 코드를 편집 할 수있는 Fish 연산자를 활용 합니다. 이 연산자를 사용하여 기본 5자를 다시 기본 10으로 변환하고 출력하는 데 필요한 피쉬 코드를 생성 한 다음 파일 시작 부분에서 소스 코드에 다시 삽입하여 인터프리터가 끝날 수 있습니다. 줄의 감싸고. 인터프리터가 줄 끝에 도달하면 코드는 다음과 같이 수정되었습니다.

v4121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p
>55**$5*++ol?!;

코드가 랩핑되어 v연산자를 때리면 두 번째 줄로 내려 가서 연산자를 때리고 >루프를 진행합니다. 매번 base 5 인코딩을 다시 base 10 ASCII 값으로 변환 한 다음 해당 값을 출력합니다. 스택에 더 이상 값이 없으면 ?연산자는로 건너 뛰고 ;프로그램은 종료됩니다.

— 가장 높은
소스

5

7 , 273 바이트 × 7 개의 고유 바이트 = 1911, 비경쟁 (언어 게시 날짜 문제)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

독특한 캐릭터를 유지

파인 프린트

채점

불면증 , 575 바이트 * 4 = 2300

솔루션 1b (게시되지 않음) : 783 바이트 * 3 = 2349

해결 방법 1 : 826 바이트 * 3 = 2478

CJam, 266 281 456 바이트 * 14 12 7 독특한 = 3724 3372 3192

설명

공백, 1157937 바이트 * 3 고유 = 3471 2811

오래된 코드, 더 나쁜 점수이지만 더 흥미로운

루비 144 바이트 * 39 고유 = 5616

Brainfuck, 1264 바이트 * 7 고유 = 8848

> <> (물고기)-578 바이트 * 8 고유 = 4624

설명

7 , 273 바이트 × 7 개의 고유 바이트 = 1911, 비경쟁 (언어 게시 날짜 문제)

파이썬 2 163 147 145 143 바이트 * 35 36 35 고유 = 5705 5292 5220 5005

편집 :

Python 2, 14508 11700 11088 10164 9486 9746 7860145 바이트 * 36 고유 = 5220

> <> (물고기) -138 바이트 * 65 고유 = 8970

05AB1E , 380 바이트 * 11 자 = 4180 점

Perl 6, 139 바이트 * 36 개의 고유 = 5004

Java 8, 141 바이트 * 64 개의 고유 문자 = 9,024

Perl 5 , 137 바이트 * 35 개의 고유 = 4795

Tcl , 345 바이트, 345 x 13 = 4485

Tcl , 337 바이트, 337 x 15 = 5055

Tcl , 329 바이트, 329 x 16 = 5264

Tcl , 333 바이트, 333 x 16 = 5328

Tcl , 148 바이트, 148 x 37 = 5476

Tcl , 277 바이트, 277 x 21 = 5817

Tcl , 371 바이트, 371 x 16 = 5936

Tcl , 401 바이트, 401 x 16 = 6416

Tcl , 403 바이트, 403 x 16 = 6448

Tcl , 433 바이트, 433 x 15 = 6495

Tcl , 473 바이트, 473 x 14 = 6622

Tcl , 133 바이트, 133 x 60 = 7980