それは非常に簡単です：プログラムまたは関数は次のテキストを生成する必要があります。

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

— durron597
ソース

ケーシングは正確でなければならないと思いますか？

— -EnragedTanker

@crayzeedudeはい、それは一種のポイントです

— -durron597

わかった。明確にするだけです。：p

— EnragedTanker

1

@CarpetPythonサンドボックスではこれについていくつかの議論がありましたが、最終的には、プレイフィールドをTRULYレベルにする方法はないと判断しました。とにかく、空白と不眠症が最高のスコアを持っていることに注意してください！

— 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

ます。だからブレインファックの答えを除いて、それは比較的一定です

— ...-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のみを使用しています。つまり、1バイトのビットを操作して結果を出力します。

— 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文字値を文字に変換して（既に存在する演算子を使用して）演算子を作成しb、:演算子で評価することにより、演算子と演算子を削除できることに気付きました。次の演算子と一緒に解析する必要があるため、演算子でこれを行うのは少し難しいことがわかりました。これを解決するには、文字を生成してからcharacter を生成および評価し、前の2つの文字を文字列に連結して適切に評価できるようにしました。c~:c:c+:c

第二に、私が~導入した演算子には、便利な新しいオーバーロードされたバリアントがあることに気付きました。数値を指定すると、ビット単位の補数が生成されます。これを数値の後に続けて2回使用することで、ソースにトークンブレークを導入して計算結果を得ることができず、数値を区切るために使用されるスペースをで置き換えることができます~~。

最終結果は最後に15バイトのコードになりますが、このコストは14個中2個の一意の文字を削除する利点をはるかに上回っています。

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

私が使用していた2つ未満の演算子を使用することはできませんが、それでも少数の一意の文字が必要でした。したがって、次のステップは数字を削除することでした。各10進数が実際に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~~

— Runer112
ソース

さて、今私は感銘を受けました。基数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空白プログラムを作成する必要があります。2位には4134で十分

— -durron597

16

空白、1157 937バイト* 3一意= 3471 2811

ポピュラー（？）リクエストにより、ホワイトスペースソリューションを投稿しています。

必要なコードを減らすために、文字列全体を1つの2進数（バイトごとに7ビット）としてハードコーディングしました。単純なループで文字を抽出し、印刷します。

filebin.caのソースコード。

注：仕様は、任意の大きな整数を許容するが、公式ページでHaskellのインタプリタが 20ビットに制限されます。たとえば、github / hostilefork / whitespacesでこのルビーインタープリターを使用します。

空白プログラムを作成する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の2進数を直接入力できます。

古いコード、スコアは悪いが、より興味深い

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

この空白プログラム自体はかなり単純ですが、ゴルフの最適化には3つの方法があります。

lul重複する文字がある場合にスタックを複製するために使用します
ltl文字を直接プッシュするよりも短い場合、スタックのn番目のエントリを複製するために使用します
すべてのバイトを97（mod 128）だけシフトダウンし、2進数を小さくします

人間が読めるホワイトスペースコードを実際のホワイトスペースプログラムに変換する単純なルビースクリプト（ファイル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

— ブルートレンジ
ソース

末尾の改行はオプションであり、印刷しないことで数文字を保存できます。

— durron597

おかげで、変更しました。元々、Haskellインタープリターがデバッグ出力を追加したため、これを含めましたが、ルビーの場合はきれいに見えます。

— ブルトレンジ

7

Ruby 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とwhitespaceの例は、いくつかの説明とともに印象的なスコアを獲得しました。健全な言語で整頓されたコードを使用することのボーナスがあっても、それを補うにはあまりにも大げさです!!! たぶん、あなたは長さ+ユニークなスコアリングコンテストに再参加することができます。

— 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に変換して出力するために必要な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演算子にヒットすると、2行目に移動し、>演算子にヒットしてループに進みます。そのたびに、ベース5エンコードをベース10アスキー値に変換して出力します。スタックに値がなくなると、?演算子はスキップし;てプログラムが終了します。

— 背の高い
ソース

5

7、273バイト×7ユニークバイト= 1911、非競合（言語postdatesチャレンジ）

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

古いコード、スコアは悪いが、より興味深い

Ruby 144バイト* 39一意= 5616

Brainfuck、1264バイト* 7一意= 8848

> <>（魚）-578バイト* 8一意= 4624

説明

7、273バイト×7ユニークバイト= 1911、非競合（言語postdatesチャレンジ）

Python 2、163 147 145 143バイト* 35 36 35 unique = 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