非常简单：您的程序或函数应生成以下文本：

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
source

我假设外壳必须精确？

— EnragedTanker

@crayzeedude是的，这很重要

— durron597

好的。只是澄清一下。：p

— EnragedTanker

1

@CarpetPython在沙箱中对此进行了一些辩论，最终我决定没有办法真正达到公平的竞争环境。请注意，无论如何，空白和失眠的得分最高！

— durron597

2

正如我在某处所写的那样，如果我们假设使用更多字节来补偿较少的唯一字符，其行为类似于将数字转换为不同的基数，则近似为bytecount~Log(X,unique)，其中X表示此问题的常数。因此，唯一^ bytecount〜常量。计算此分数（log2）得出

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

。因此，除了

— 脑力激荡的

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̷̰̀ĥ̷̳
source

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，并将其编码为程序中的十进制数。然后，程序将该数字转换回以123为基数，并将每个以123为基数的数字映射回一个字符。因为很难解释为什么程序处于当前状态，所以我将解释它的每个版本。

这是第一个版本中程序结尾的样子：

...2068438725 123b:c

这将以最直接的方式实施该策略。该数字通常以10为底进行编码，然后转换回123，然后将每个123数字映射回一个字符。但这使用了4个唯一的非数字字符，并且由于不必使用简单易懂的代码，因此能够摆脱其中的任何一个字符可能都值得大笔投资。

首先，我意识到，我可以摆脱的b和:在运行时创建它们作为自己ASCII字符值转换回一个字符（与已存在的运营商c运营商），并与他们评估~操作。事实证明，使用:运算符执行此操作有些棘手，因为必须将其与以下c运算符一起解析。我通过产生字符解决了这个:和c，然后生产和评估的字符+，其中前两个字符连接成字符串:c，然后可以适当的评估。

其次，我意识到~刚刚介绍的运算符有一个方便的新重载变量：给定数字时，它会产生按位补码。通过在数字后连续两次使用此符号，我可以在源中引入令牌中断，而不会产生任何计算效果，允许我使用来代替用于分隔数字的空格~~。

最终结果是最后增加了15个字节的代码，但是从14个字符中消除了2个唯一字符的好处大大超过了此成本。这是第一个版本末尾与第二个版本末尾的比较：

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

使用少于我使用的两个运算符是不可能的，但是我仍然希望更少的唯一字符。因此，下一步就是消除数字。通过更改数字的编码，使每个十进制数字实际上都是以5为基数的数字，我有可能消除6-9的数字。在消除prgoram末尾的任何内容之前，它看起来像这样：

...4010014400 10b5b123b:c

如前所述，消除空间很容易。但是b，:和c不会那么容易，因为他们的性格码98，58和99分别。这些都包含标记为要消除的数字，因此我不得不寻找方法来导出它们。字符值不包含5-9的唯一有用的数字运算符是减，增，乘和加。

对于98，我最初使用100~~40c~40c~，它会递减100两次。但是后来我意识到我可以再使用该~运算符，因为按位补码使我得到负数，当它们相加时，我就可以模拟减法。因此，我然后使用了100~~1~43c~，它加上100和-2且小2个字节。因为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
source

好吧，现在我印象深刻。以6为底的数字，以7为底的数字等如何与以5为底的数字进行比较？

— durron597 2015年

@ 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

空格，1157 937字节* 3唯一= 3471 2811

根据Popular（？）请求，我要发布空白解决方案。

为了减少所需的代码，我将整个字符串硬编码为一个二进制数（每个字节7位）。一个简单的循环提取字符并打印出来。

filebin.ca上的源代码。

注意： 规范允许使用任意大整数，但是官方页面上的Haskell解释器仅限于20位。例如，在github / hostilefork / whitespaces上使用此ruby解释器。

用于创建空白程序的ruby脚本（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上的旧代码。

我用于创建程序的ruby脚本（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个条目（如果其长度小于直接推入char的长度）
将所有字节向下移97（mod 128），使二进制数更小

一个简单的ruby脚本，将我可读的空白代码转换为实际的空白程序（读取文件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

— 蓝橙
source

尾随换行符是可选的，您可以通过不打印来保存一些字符。

— durron597 2015年

谢谢，改变了它。最初，我之所以包含它，是因为Haskell解释器添加了一些调试输出，但是对于ruby，它看起来很干净。

— blutorange 2015年

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

有时候最简单的就是最好的。

— 超级汤姆
source

您不会在数据中使用任何简化形式。cjam和空白示例得到了令人印象深刻的分数以及一些解释。即使使用理智的语言使用整洁的代码有好处，但弥补它的理由太多了！！！也许您可以重新参加长度+独特的计分比赛。

— Jose_X 2015年

6

Brainfuck，1264字节* 7唯一= 8848

是的，这是一个糟糕的成绩。

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

— mbomb007
source

我发现它可以使用更少的唯一字符，但长度是10795，次5 = 53975.

— mbomb007

您可以这样做，但+.不确定它会更小。

— captncraig 2015年

仅使用+，.我得到15018 * 2 = 30,036。

— captncraig 2015年

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

我的分数没有我希望的那么有竞争力，但是我认为这个解决方案仍然足够有趣。

说明

代码的第一部分是数字0-4的长字符串，它表示字符串中每个字符的3位5进制表示。其余代码利用了pFish 中的运算符，该运算符使您可以在程序运行时编辑程序的源代码。通过使用该运算符，我能够生成将基数5的字符转换回基数10并输出它们所必需的Fish代码，然后在解释器到达末尾之前将该代码放回到文件的开头的源代码中。线和环绕。当解释器到达该行的末尾时，代码已修改为如下所示：

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运算符时，它下降到第二行，击中>运算符并继续循环，每次将以5为底的编码转换回以10为底的ascii值，然后输出该值。当堆栈上没有更多值时，?操作员将跳至，;程序将结束。

— 最高的
source

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

说明

空格，1157 937字节* 3唯一= 3471 2811

旧代码，得分更差，但更有趣

红宝石144字节* 39唯一= 5616

Brainfuck，1264字节* 7唯一= 8848

> <>（鱼）-578字节* 8个唯一值= 4624

说明

7，273字节×7个独特字节= 1911，非竞争性（语言晚于挑战）

Python 2中，163 147 145 143个字节× 35 36 35独特= 5705 5292 5220 5005

编辑：

Python 2，14508 11700 11088 10164 9486 9746 7860 145字节* 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