チャレンジ

あなたの仕事は整数をASCII文字の文字列としてエンコードし、その文字列がランダムにシャッフルされた後にそれを正常にデコードすることです。

EncoderおよびDecoderと呼ばれる2つのプログラム/関数を作成します。

エンコーダー

• 入力：範囲整数。$n$$[0,2^{31}-1]$
• 出力：文字列のアスキー文字（必ずしも印刷可能ではありません）。$s$

デコーダ

• 入力：文字列ランダムな順列。$s'$$s$
• 出力：整数。$n$

得点

ましょである最大長ののすべての可能な値を横切る。エンコーダが非決定的に動作する場合（これは許可されています。以下を参照）、は発生する可能性ある最大長になります（おそらく）。$A$$s$$n$$A$$s$$\infty$

してみましょうあることの長さエンコーダバイトでの長さデコーダバイトインチ$L_E$$L_D$

スコアはです。$A\cdot(L_E+L_D)$

最優秀得点の提出に対して勝利が授与されます。

制限時間

単一のテストケースのエンコーダーとデコーダーの両方の実行時間には、1分というやや任意の時間制限があります（つまり、単一の値）。$n$

目標は、特定のプロパティを持つすべてのシーケンスを列挙することにより、ブルートフォースエンコーディングを見つけるソリューションを回避することです。あなたのソリューションがそれよりも賢い何かをするなら、それはおそらく時間の制約に適合し、有効と見なされます。同様に、ランダムに選択された値に対してTIOで機能する場合、有効と見なされます。それ以外の場合は、マシンでテストしますが、ソリューションが純粋なブルートフォースの場合、ほぼ確実に失敗することに注意してください。$n$

ルール

• エンコーダとデコーダはで記述する必要があり、同じ言語。
• デコーダを出力しなければならない正しい整数あらゆる可能な順列のためのの文字列のによって返さエンコーダ。$n$$s'$$s$
• エンコーダとデコーダはされていないに許さ株式情報（グローバル変数やファイルによって、例えば）どのような方法インチ
• エンコーダーの出力は確定的である必要はありません（つまり、エンコーダーが複数回実行される場合、同じ入力は異なる出力文字列を生成する可能性があります）が、デコーダーは常に正しい整数推測する必要があります。$n$n$n$
• エンコーダおよびデコーダは取り、整数を返すことができるに任意の便利な方法（例えば、もしの入力がされることが結構です、または）。$n$n = 14$n=14$14"14"[1,4]
• エンコーダ出力してもよいストリングのいずれかによって印刷の上にまたはによって返却文字列を、文字のリスト/配列または範囲内の整数のリスト/配列。そのノートデコーダは、入力としての順列受け取るで返されるエンコーダがストリング受け入れるべきであるので、において同じフォーマットとして。$s$[ 0 、127 ] S 、S 'のstdout $[0,127]$$s$$s'$$s$
• 標準的な抜け穴は禁止されています。
• 可能であれば、コードの仕組みと、主張するスコアが正しい理由を説明してください。

例

と仮定します。$n=14$

• エンコーダは、受信14入力として。出力される場合があります"qwerty"。
• デコーダは、の順列受信"qwerty"例えば、入力としての"tweyqr"。14（便利な形式で）出力する必要があります。

エンコーダは、戻ってきた可能性があり[113,119,101,114,116,121]、その場合に、同様にデコーダは、（例えば）を受信したであろう[116,119,101,121,113,114]。

エンコーダから返される文字列には、印刷できないASCII文字が含まれる場合があります（ただし、常に範囲内にあります[0x00, ..., 0x7F]）。

ゼリー、（17バイト+ 18バイト）×長さ6 = 210ポイント

b36µỤỤ +×3µŒ¿b3U +Ṣ

Ṣ：3_J
Ṣ％3Uḅ3œ？Çḅ36

オンラインでお試しください！ （または追加のデバッグ情報付き）

：定められた勝利条件を目指して、この課題を解決するために行くを持った、私は架空の代替勝利条件のために行くのは興味深いだろうと思っコード-ゴルフ出力の最小の可能な最大の長さは与えられました。

説明

エンコーディング

エンコードの最初のステップは、入力を基数36（b36）として表すことです。36 ⁶ = 2176782336> 2147483647であるため、結果には最大で6桁が含まれ、それぞれの範囲は0〜35です。

次に、我々は6つの含まれている表現にこれを変換する別の数字を。これには複数の可能なアルゴリズムがありますが、ここで使用されるものは、最小の桁に1、2番目に小さいのに2、3番目に小さいのに3を追加することです。これは、2桁が同じ場合、そのうちの1桁が任意に小さいと見なされるため、それらが異なることを意味します。そして明らかに、このアルゴリズムは2つの異なる数字を同じにすることはできません。Jellyでこれを表すために、Ụ（「値でインデックスを並べ替える」）を使用して、並べ替えられた順序でインデックスのリストを取得します。Ụ再びそれを反転させ、元の各要素をソートされた順序でその位置に効果的にマッピングします。そしてµ…+オリジナルを新しいリストに追加します。結果は、6つの入力数の表現である異なる 1-41の範囲内の数字（最小0 + 1、最大35 + 6）。

：我々は、次に、更に別の形態にこれを分割ソート（1-41範囲の桁のリスト、1から数字がでた720の可能な順列を表し720番号の横。Œ¿およびṢ順列番号とソートを抽出しますそれぞれリストします。）

最後に、1から720の数値を基数3（b3）に変換し、逆（U）にし、逆divmod（値文字mod 3は基数3桁で、3で割った値は1〜41桁です）。結果の可能な範囲は、最小で（1×3）+ 0 = 3、最大で（41×3）+ 2 = 125で、ASCIIの範囲内に収まります。すべてのコマンドがデータの適切なビットで動作することを確認するために、パッキングは×3and を介して行われます。（ここでは、順列を抽出する前に 3を乗算するという、ちょっとしたゴルフトリックがあります。これにより、グループ化文字に1バイトを費やす必要がなくなります。）+µ

ちなみに、ベース3の数値を逆にする理由は、1〜41の数値よりも桁数が少ないためです。（これ以上は持てません。n！> 3 ⁿの最小数は6をわずかに超えています。）ゼリーは、長さの異なる2つの数値を一致させるために、末尾のゼロを効果的に挿入します。末尾のゼロは数値の解釈に影響しますが、先頭のゼロは影響しません。そのため、逆を使用して、余分なゼロが答えを台無しにしないようにします。

デコード

デコードの最初のステップは、2つの数値（基数3の数値と1〜41の数値）を抽出することです。除算（:3）とモジュロ（%3）でそれぞれ簡単に数字を取得できますが、どの順序になっているかを知る方法はありますか？さて、1–41の数字はソートされた順番で数字を持ち、2つの数字の対応する位置の数字は同じ文字で保存されていました。したがって、1〜41の数字がシャッフルされた順序を（それらの相対的な値を見て）計算し、ベース3の数字が同じ方法でシャッフルされている必要があることを知ることができます。実際、ASCIIエンコードの文字は1〜41の数字と同じ方法で並べ替えられるため（これらはすべて明確であり、基数3の数字よりも重要です）、Ṣ。したがって、両方の抽出は、で始まりṢ、その後に、%3または必要:3に応じて続きます。

1〜41桁の数字は依然としてソートされた順序ですが、36を基数とする0〜35桁に戻るには非常に便利で簡潔な方法があります。最初から1を、2番目から2を、3番目から3を、というように続けます。Jellyでは、_J（ "subtract index"）でそれを行うことができます。

一方、デコードの他のブランチでは、基数3の数字を逆順に（U）に戻し、それを基数3から置換インデックスに変換しḅ3ます。

その後、2つのブランチをœ?Ç;で結合できます。œ?は、「この順列インデックスを指定して並べ替え」をÇ意味し、「上の行を適用した結果」を意味します。つまり、同じ入力で両方の行を別々に実行するようにJellyに指示します。

これで、元の数値の桁が36進数（による_J）で、元の順序（によるœ?）であるため、単にḅ3636を基数から単一の整数に変換することができます。

解説

TIO！上記のリンクでは、エンコードする数値として312699167を使用しています。基数36のこの数は[5, 6, 6, 8, 7, 35]であり、エンコードのすべての側面を示しています。35は、0〜127の範囲の制限をテストします。重複する6は、元のベース36の同一の数字の解像度をテストします。そして、数字がほとんど（完全ではない）ソートされているという事実は、順列番号が非常に小さく、ベースの36番号よりもはるかに少ない数字を与えているため、元に追加する前に逆にする必要があることを示しています。

ここにあるすべての定数がどのように組み合わされるかは本当に便利です。36 ^6ことだけでわずか 2合うように十分に高い^31を、3 ⁶だけでちょうど 6に適合するように十分に高い！と（36 + 6）×3だけであるだけ我々は128個の可能性に収まるように十分高いです。（ここでの最後の制約は最も厳密ではありません。1インデックスではなく0インデックスを使用して0〜2の範囲の文字を使用できるためです。それでも、37をベースとして使用するのに十分なスペースを確保するだけです。 36より）

ゼリー、（4 3バイト+ 6 5バイト）×長さ8 = 80 64ポイント

⁴

ṢŻIḅ⁴

オンラインでお試しください！

ゼリー、（2 1バイト+ 4 3バイト）×長さ10 = 60 40ポイント

Ä

ṢŻ私

オンラインでお試しください！

説明

解決策1

これは、他のほとんどの回答とは異なるアルゴリズムを使用しています。b⁴他の回答と同様に、値を16進数（）でエンコードしてから、累積合計（Ä）を取得します。各入力は異なる出力を明確に提供し（これらの操作は両方とも可逆であるため）、16進エンコードには最大8桁が含まれ、最大値は7（最後から8桁目）および15（最後から7桁目まで）最後の桁）、出力リストの最大数は7+（7×15）= 112で、質問に必要な127未満です。また、出力は必然的にソートされた順序になり、シャッフルを逆にすることができます。

デコーダーでは、最初にシャッフルを逆順に並べ替えます（Ṣ）。次に、ゼロを追加して（Ż）、連続するペアの差を取る（）ことにより、累積合計を逆にしIます。次に、16進数（ḅ⁴）から変換し直します。

解決策2

この質問により、入力を（おそらく10進数の）数字のリストとして受け取ることができるため、基本変換を削除するだけで「チート」できます。出力で使用される最大数は2 +（9×9）= 83になります（2999999999は範囲外であるため実際には82であり、最悪の入力は1999999999です）。結果として生じるエンコーディングは、この問題のエンコーディングが進むにつれてかなりひどいものになりますが、生成するのが非常に簡潔であるという利点があり、エンコーディングの冗長性を上回ります。

この答えは不正行為のように感じられるため、この問題の主な解決策ではありませんが、技術的にルールに準拠し、より良いスコアを生成するため、追加する価値があるようです。

解説

長さ8未満になるためのいくつかのアルゴリズムを念頭に置いていますが、長さ7のアルゴリズムを≤9バイト（非チート）または≤5バイト（チート）で実装できる可能性は低いようです。おそらくそれを行うための最良の方法です。（とにかく、楽しみのために、とにかく「エンコーディングの長さを最小にする」という代替案の解決策に挑戦するかもしれません。）

一部のソリューションとは異なり、ここでのベースとして16を使用することは重要ではありません。長さ8のソリューション（たとえば18）で機能する他の数値がたくさんあります。Jellyがそれを表す1バイトの方法を持っているため、最初のソリューションに16を選択しました。他の実行可能なベースは、プログラムから複数バイトを使用する必要があります。もちろん、2番目のソリューションでは、抜け穴を利用するために10をベースとして使用する必要があります。

@Dennisに、このアルゴリズムをさらに作成しやすくしたいくつかの新しいJellyコマンドを指摘してくれてありがとう。

シェークスピアプログラミング言語、10 *（264 + 494）= 8650 7910 7580

エンコーダー：264バイト

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Open mind.Be you nicer zero?You be the sum ofyou the product ofthe sum ofI a big big pig the sum ofa big big big big cat a big big pig.If soSpeak thy.Ford:You are the sum ofyou a cat.If soLet usAct I.

オンラインでお試しください！

デコーダー：494

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Open mind.Is you nicer a pig?If soRemember you.If soLet usAct I.Scene V:.Ford:Remember I.Ajax:Recall.Is you worse the sum ofPage twice the sum ofa big big cat a cat?If soYou be the difference betweenyou Page.If soOpen heart.If notlet usScene V.Scene X:.Ford:Recall.Ajax:Be I nicer zero?If soRemember I.If soLet usScene X.[Exit Ajax][Enter Page]Ford:You be the sum ofyou twice twice the sum ofa big big cat a pig.Let usAct I.

オンラインでお試しください！

これは事でした。

エンコーダーは、各桁を数字に数字のインデックスに12を掛けたものとしてエンコードします。デコーダーはすべての入力をFordのメモリに保存し、カウンターをループして出力し、カウンターよりも低い各桁を削除します* 12 + 10。

説明：

エンコーダー

,.Ajax,.Ford,.Act I:.Scene I:.      Boilerplate introducing the two characters
[Exeunt][Enter Ajax and Ford]       Enter the two characters Ajax and Ford
                                    Ford will be handling the input
                                    Ajax will be the counter
Ajax:Open mind.                     Set Ford to the next character of input
Be you nicer zero?                  Check if it is EOF
You be the sum of                   Set Ford to the sum of 
    you                             His original value (48 to 58)
    the product of                 
          the sum of               
              I                     Ajax's value
              a big big pig         Minus 4 (this handles the offset of 48)
          the sum of                Multiplied by
              a big big big big cat 2^4
              a big big pig.        + -2^2 = 12
                                    This essentially sets Ford to (F+12*(A-4))
If soSpeak thy.                      If not EOF, print Ford's value
Ford:You are the sum ofyou a cat.   Increment Ajax's value
If soLet usAct I.                   If not EOF, Repeat again.

デコーダ

,.Ajax,.Ford,.Page,.Act I:.Scene I:.  Boilerplate introducing three characters
                                      Ajax is the spare stack
                                      Ford is the storage stack
                                      Puck is the counter, increasing by 12
[Exeunt][Enter Ajax and Ford]            Enter Ajax and Ford onto the stage
Ajax:Open mind.                          Get the next character of input
Is you nicer a pig?                      If not EOF
If soRemember you.                         Store the value in Ford's memory
If soLet usAct I.                          And repeat the loop
Scene V:.                                Otherwise move to the next scene
Ford:Remember I.                         Store Ford's value (initially -1 from EOF) in Ajax's memory
Ajax:Recall.                             Get the next value from Ford's memory
Is you worse the sum of                  Is the value smaller than
        Puck                                  Puck's value
        twice the sum ofa big big cat a cat?  + 10 ?
                                              i.e. is it the next digit?
If soYou be the difference betweenyou Puck.   If so, subtract Puck's value from Ford
If soOpen heart.                              And print Ford's value
If notlet usScene V.                     If that was not the digit, repeat
Scene X:.
Ford:Recall.                             Get the next value from Ajax's memory
Ajax:Be I nicer zero?                    Until the -1
If soRemember I.                         Returning the values to Ford's memory
If soLet us Scene X.                     Repeat until Ajax's memory is exhausted
[Exit Ajax][Enter Page]                  Swap Ajax and Page
Ford:You be the sum of                   Set Puck's value to
              you                        Puck +   
              twice twice the sum of     2*2*(
                           a big big cat      4
                           a pig.             -1) = 12
Let usAct I.                             And start from the beginning again, having removed one number

Python 2.7、31 *（52 + 37）= 2759

エンコーダー（69 52バイト）：

lambda n:[chr(i)if n&(1<<i)else""for i in range(32)]

デコーダー（41 37バイト）：

lambda s:sum([1<<(ord(c))for c in s])

入力値のすべての非ゼロビットをascii値として保存します。ASCII文字の値には、設定されたビットの位置が格納されます。たとえば、値「a」は、97番目のビットが設定されていることを意味します。

@ Delfad0rのおかげでいくつかの改善

オンラインでお試しください！

スタックス、スコア8×（10 + 9）= 152

エンコーダー、10 バイト

Ç·MÉJ'♀τ│½

実行してデバッグする

16|E{i16*+m Full program, implicit input
16|E        Get hexadecimal digits
    {     m Map:
     i16*+    Add 16 * loop index
            Implicit output as string

エンコーダーは、文字列を昇順で出力します。

デコーダー、9 バイト

üL∟n╫k∞‼9

実行してデバッグする

o{16%m16|E Full program, implicit input
o          Sort string
 {16%m     Module each element by 16
      16|E Interpret as array of hex digits

05AB1E、8最大長*（8 + 7）バイト= 120

エンコーダー（8）

hεHN16*+

オンラインでお試しください！

デコーダー（7）

{16%hJH

オンラインでお試しください！

wastlおよびJonathanと同じ手法を使用します。

Python 3、8 *（45 + 38）= 664

エンコーダー（45バイト）：

lambda n:[16*i+(n>>4*i)%16 for i in range(8)]

デコーダー（38バイト）：

lambda l:sum(x%16<<x//16*4 for x in l)

オンラインでお試しください！

JavaScript（ES6）、8 *（40 + 32）= 576

$0$$8$

エンコーダー（40バイト）

E=(n,k=0)=>n?[k|n&15,...E(n>>4,k+16)]:[]

デコーダー（32バイト）

s=>s.map(c=>s|=c%16<<(c/4&~3))|s

デモ

オンラインでお試しください！

どうやって？

入力は4ビットの8つのブロックに分割され、各ブロックは16の可能な文字のうち1つでエンコードされます。最後のブロックの最上位ビットが設定されることはありません。

       3222222222211111111110000000000
bit:   0987654321098765432109876543210
       \_/\__/\__/\__/\__/\__/\__/\__/
block:  7  6   5   4   3   2   1   0

block #0 is encoded with char. 00 to 0F (NUL to SI)
block #1 is encoded with char. 10 to 1F (DLE to ES)
block #2 is encoded with char. 20 to 2F (' ' to '/')
block #3 is encoded with char. 30 to 3F ('0' to '?')
block #4 is encoded with char. 40 to 4F ('@' to 'O')
block #5 is encoded with char. 50 to 5F ('P' to '_')
block #6 is encoded with char. 60 to 6F ('`' to 'o')
block #7 is encoded with char. 70 to 77 ('p' to 'w')

ゼリー、（8 + 9）バイト * 8最大長= 136

b⁴+J’Ɗ⁴¡

エンコーダー（フッターはPythonが明確にするためにリストをフォーマットします）

Ṣ_J‘Ɗ⁴¡ḅ⁴

デコーダ

理論的には、最大長を6にすることは可能ですが、22バイト以下で実行できますか？

$\sum_{i=0}^{i=5}\binom{127+i}{127}=321402081< 2^{31}-1$

どうやって？

$2^{31}-1$7fffffff[7,15,15,15,15,15,15,15][7,15,15,15,15,15,15,15] + [0,16,32,48,64,80,96,112] = [7,31,47,63,79,95,111,127]

エンコーダー：

b⁴+J’Ɗ⁴¡ - Link: integer, n    e.g. 1234
 ⁴       - literal 16               16          
b        - convert to base          [4,13,2]
       ¡ - repeat...
      ⁴  - ...16 times:
     Ɗ   -   last 3 links as a monad:
   J     -     range of length        [1,2,3]     iter 2    iter 3    ...  iter 16
  +      -     add                    [5,15,5]   [5,16,7]   [5,17,9]  ...  [5,30,35]
    ’    -     decrement              [4,14,4]   [4,15,6]   [4,16,8]  ...  [4,29,34]
         -                                                                 [4,29,34]

デコーダー：

Ṣ_J‘Ɗ⁴¡ḅ⁴ - Link: list of integers   e.g. [29,34,4]
Ṣ         - sort                          [4,29,34]
      ¡   - repeat...
     ⁴    - ...16 times:
    Ɗ     -   last 3 links as a monad:
  J       -     range of length           [1,2,3]
 _        -     subtract                  [3,27,31]   [3,26,29]   [3,25,27]  ...  [3,12,1]
   ‘      -     increment                 [4,28,32]   [4,27,30]   [4,26,28]  ...  [4,13,2] 
        ⁴ - literal 16                    16
       ḅ  - from base                     1234

シェークスピアプログラミング言語、31 *（472 + 383 379 344）= 26505 26381 25296

前のスコア：16909322 *（246 + 217）= 7829016086

これはまだ非常に高いですが、私が今考えることができる最低です。

エンコーダー：

,.Ajax,.Ford,.Act I:.Scene I:.[Enter Ajax and Ford]Ajax:Remember a pig.Ford:Listen tothy.Scene V:.Ajax:Remember the remainder of the quotient betweenI a big cat.Ford:You be the quotient betweenyou a big cat.Be you nicer zero?If solet usScene V.Remember a pig.Scene X:.Ajax:Recall.Ford:Am I worse zero?If notremember I.If notlet usScene X.Ajax:You zero.Scene L:.Ford:Recall.Ajax:You be the sum ofyou a cat.Am I nicer zero?If sospeak thy.Am I worse zero?If notlet usScene L.

オンラインでお試しください！

デコーダ：

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:You cat.Ford:Open mind.Remember the sum ofyou I.Scene V:.Ajax:Am I nicer a cat?If soyou be twice you.Ford:If soyou be the sum ofyou a pig.If solet usScene V.[Exit Ford][Enter Page]Page:Recall.Ajax:Am I worse a cat?If notyou be the sum ofyou Ford.If notlet usAct I.Open heart

オンラインでお試しください！

基本的に、文字列にASCIIコード（n + 1）の文字が含まれている場合、n番目の2進数が設定されます。

Python 3（208バイト+ 200バイト）* 6長さ= 2448

オンラインでお試しください！（両方を含み、余分なバイトはそれらの間の改行です）。

空のリストを使用することにより、-4バイト（-24スコア）（より多くのものを0から開始できます）

エンコーダー（208バイト）

def E(n,h=128):
    T=lambda n,d:n*T(n+1,d-1)//d if d>1else d and n or 1
    d=l=0
    s=[]
    while n>=T(h,d):
        n-=T(h,d)
        d+=1
    for i in range(d):
        while n>=T(h-l,d+~i):
            n-=T(h-l,d+~i)
            l+=1
        s+=[l]
    return s

デコーダー（200バイト）

def D(s):
    T=lambda n,d:n*T(n+1,d-1)//d if d>1else d and n or 1
    s.sort()
    l=0
    d=len(s)
    n=sum(T(128,D)for D in range(d))
    for i in s:
        for j in range(l,i):
            n+=T(128-j,d-1)
        l=i
        d-=1
    return n

観察：

• シャッフルは、厳密に増加しない（つまりソートされた）リストの場合、可逆的に元に戻すことができます。

• 同じ長さの厳密に増加しない数値リストは、完全に順序付けることができます（Pythonの場合と同様）。

• リストを最初に長さ順に並べて、ソートされたすべてのリストの合計順序を形成するように定義できます。

• 私たちは、リスト内の唯一の有効値は整数であることを定義した場合我々は、これらのリストのインデックス可能なシーケンスを形成することが可能0に127包括的（すなわち長さを持つ有効なリストの有限な数が存在しますL）。

戦略：

• エンコーダー：数値を指定するとN、N有効な厳密に増加しないリストを見つけます。

• デコーダー：（シャッフルされた）有効なリストが与えられた場合、それをソートし、有効なリストのシーケンスでそのインデックスを返します。

一般的なコードの説明：

• T=lambda n,d:n*T(n+1,d-1)//d if d>1else d and n or 1

• 計算n番目d-simplex数を

  • 以下のためにd=0、常に1

  • 以下のためのd=1、n（長さのドット行のドット数n）

  • d=2$\sum_{i=1}^{n} i$n

  • d=3$\sum_{j=1}^n \sum_{i=1}^{j} i$n

エンコーダーの説明：

• def E(n,h=128): d=l=0、 s=[]

• n入力された番号であり、h「高い値」（すなわち、許容最大数+ 1）であり、d出力がされる長さで、s出力がされているl「低値」である（0から始まる、より後述しました）

• while n>=T(h,d):、n-=T(h,d)、d+=1

• T(h,d)有効な長さのdリストがあり、実際のインデックスの代わりに（indexにある）nリストに相対的なインデックスの場合、計算が簡単になるため、それに応じて減分します。これはまた、指定されたに対して正しいように（長さ）を調整します。[0]*d0ndn

• for i in range(d):

• 効果的に：「i+1リストのth番目の番号」

  • これは私が説明するところですl、「低い価値」

  • 番号がリストlに追加された後は、リストに追加できる数よりも少ない番号は（ソートされた状態を維持するため）リストに追加された最後の番号です。

  • while n>=T(h-l,d+~i):、n-=T(h-l,d+~i)、i+=1

  • この「桁」でnエンコードするには大きすぎる場合はl、それにn応じて調整し、増分しますl

  • s+=[l]

  • この「数字」でエンコードnしますl。

  • 最初は、h次に入力する「数字」のオプションがありますが、「数字」（に割り当てられているl）を入力h-lすると、次の「数字」のオプションに制限されます。

  • 最初はT(h,d)有効なリストがありましたが、l残りの「桁」の数を減らし、d-1有効な次の「桁」の数をに減らす「桁」を追加したh-lため、この後の有効なリストの数はT(h-l,d-1)

デコーダーの説明：

• def D(s):、s.sort()、l=0、d=len(s)

• s（シャッフルされた）入力リストなのでs.sort()、l「低値」（h「高値」は128バイトを節約するためのコード内の単なるリテラルです）、n出力番号、d長さです。

• n=sum(T(128,D)for D in range(d))

• nシーケンスのポイントに調整します[0]*length

• for i in s:

• 各桁について：

  • for j in range(l,i):、 n+=T(128-j,d-1)

  • nシーケンスのポイントに調整します[...prevdigits, thisdigit, 0...]

    • l=i：「低い値」を最新の数字に設定します

    • d-=1：数字を使用したため、長さを減らします

• return n：nすべての数字を調整した後、それが正しい数字になります。それを返します。

これが明確でない場合は申し訳ありませんが、オリジナルのゴルフ以外のデバッグバージョンはこちらです。オンラインでお試しください！、空のリストを使用しないため、このバージョンで使用されるすべての数値から1がオフになります

ルビー、（36 + 29バイト）* 8、スコア520

エンコード：

->n{(0..7).map{|x|(n>>x*=4)%16+x*4}}

オンラインでお試しください！

デコード：

->a{a.sum{|x|x%16<<(x/4&28)}}

オンラインでお試しください！

使い方：

数値は、4ビットのチャンクと3ビットのインデックスを使用してエンコードされます。

デコーダーは入力配列を取得し、すべてのニブルをその場所に再び配置します。

炭、スコア10 *（10 + 15）= 250。

小数を使用します。以前のベース16ベースのソリューションのスコアは328 296 264です。

印刷できない文字を出力する場合があります。特に、文字10は木炭への入力が難しい。

エンコーダー、10バイト：

⭆⮌Ｓ℅⁺Ｉι×χκ

オンラインでお試しください！リンクは、コードの詳細バージョンです。

デコーダー、15バイト：

ＩΣＥＳ×﹪℅ιχＸχ÷℅ιχ

オンラインでお試しください！リンクは、コードの詳細バージョンです。

整数のリストを使用したバージョンは360 296（16進数、10進数は310）のスコアを獲得します。

エンコーダー、19バイト：

ＮθＩＥ⁸⁺﹪÷θＸ¹⁶ι¹⁶×¹⁶ι

オンラインでお試しください！リンクは、コードの詳細バージョンです。

デコーダー、18バイト：

ＩΣＥＥ⁸Ｎ×﹪ι¹⁶Ｘ¹⁶÷ι¹⁶

オンラインでお試しください！リンクは、コードの詳細バージョンです。

印刷可能な文字スコア360を使用するバージョン（ベース16で416 384 368 だった）：

エンコーダー、19バイト：

⭆⮌Ｓ℅⁺Ｉι×χ⁺κ×⁵⊕׳÷κ⁵

オンラインでお試しください！リンクは、コードの詳細バージョンです。

デコーダー、17バイト：

Ｆθ⊞υ⌈Φθ¬№υκ⭆υ﹪℅ιχ

オンラインでお試しください！リンクは、コードの詳細バージョンです。

Brachylog、17 + 18バイト* 8長さ= 280

エンコーダー：

ḃ₁₆I∧7⟧₁;Iz₁~ḃ₁₆ᵐ

デコーダ：

ḃ₁₆I∧7⟧₁;Iz₁~ḃ₁₆ᵐp

エンコーダの最後にpを追加しても、効果はありません。デコーダーは、（シャッフルされた）結果を出力として配置し、入力に元の数を取得することによって実行されます。

（適切に実装された）累積合計述語がある場合、スコアは20に低下する可能性があります

オンラインでお試しください！

05AB1E、スコア：（2 + 2 バイト）* 11最大長= 44

エンコーダー（2 バイト）：

.¥

オンラインでお試しください。

デコーダー（2 バイト）：

{¥

オンラインでお試しください。

エンコーダーの入力とデコーダーの出力は、数字のリストです。

@ ais523の2番目のゼリー回答のポート。

説明：

.¥    # Undelta (automatically prepends a 0)
      #  i.e. [3,0,4,7,8,2,0,1,9] → [0,3,3,7,14,22,24,24,25,34]

{     # Sort
      #  i.e. [14,7,22,25,24,3,0,24,34,3] → [0,3,3,7,14,22,24,24,25,34]
 ¥    # Deltas
      #  i.e. [0,3,3,7,14,22,24,24,25,34] → [3,0,4,7,8,2,0,1,9]

.¥$2^{31}-1$

Gol> <>、8 *（14 + 13）= 216

エンコーダーオンラインでお試しください！、14バイト：

I8FfPSD8*L+o|;

デコーダーオンラインでお試しください！、13バイト：

iEh8SD4*2$X*+

これは印刷不能なASCII文字を出力する可能性があるため、デコーダーを混乱させるため、出力/入力に数字を使用するバージョンがあります。

エンコーダーオンラインでお試しください！、14バイト：

I8FfPSD8*L+N|;

デコーダーオンラインでお試しください！、13バイト：

IEh8SD4*2$X*+

エンコーディング：

エンコードは、指定された数値を8 x 4ビットチャンクに分割することで機能します。これらのチャンクは3ビット右にシフトされ、チャンクの元の場所が0から7の間の数字として最後に追加されます。したがって、エンコードは次のようになります。

0AAAABBB
 |__|    -> the original part of the number
     |_| -> the position of the chunk inside the original number 0 = LSB and 7 = MSB

Perl 6、10 *（10 + 12）= 340 220

エンコーダー：

{^@_ Z~@_}

デコーダ：

{.sort X%10}

オンラインでお試しください！

エンコーダー関数は、数字の0インデックスで各数字を圧縮します。次に、エンコーダは数値のリストをソートし、10のモジュロ、つまり数値の2番目の桁を取得します。

最大長は2 ³¹ -1なので、合計は10 です。

Haskell、10 *（23 + 51）= 740

値をエンコード、シャッフル、デコード、検証するプログラムを次に示します。オンラインで試してみてください！

エンコーダー、23バイト

zipWith((+).(10*))[0..]

オンラインでお試しください！

デコーダー、51バイト

map snd.sortOn fst.map(`divMod`10)
import Data.List

オンラインでお試しください！

説明

私たちは、小数点以下の桁として使用する入力を許可しているので、我々はそれを使用します。..エンコーダはして発生する各桁マップし10*index + digit、すべてのノートというdigitのがになり[0..9]、我々が使用することにより、上記逆転できるようにdivMod。インデックスと数字を復元した後は、インデックスで並べ替えて削除するだけです。

$2^{31} - 1 = 2147483647$$9 \cdot 9 = 81 < 128$

殻、10 *（7 + 8）= 150

$10 \cdot 9 = 90 < 128$N

エンコーダー、7バイト

zo+*10N

オンラインでお試しください！

デコーダー、8バイト

m→Ö←m‰10

オンラインでお試しください！

$L_E+L_D=36; A=8 \rightarrow 288$

d←{16⊥n-16×⍳≢n←⍵[⍋⍵]}
e←(⊢+16×⍳∘≢)16⊥⍣¯1⊢

オンラインでお試しください！（割り当てと改行用に5バイト余分に含まれています）。

用途 ⎕IO←0

どうやって：

(⊢+16×⍳∘≢)16⊥⍣¯1⊢ ⍝ Encoder; input 1234
          16⊥⍣¯1⊢ ⍝ Convert input to base 16 → 4 13 2
      ⍳∘≢          ⍝ [0..length of the list-1] → 0 1 2
   16×             ⍝ times 16 → 0 16 32
 ⊢+                ⍝ plus the original list → 4 29 34

{16⊥n-16×⍳≢n←⍵[⍋⍵]} ⍝ Decoder; input ⍵ → 34 4 29
              [⍋⍵]  ⍝ Grade ⍵ up → 2 0 1
             ⍵      ⍝ Index ⍵ with that list → 4 29 34
           n←       ⍝ assign that to n
      16×⍳≢         ⍝ 16×[0..length(n)-1] → 0 16 32
    n-              ⍝ subtract that from n → 4 13 2
 16⊥                ⍝ Decode from base 16 → 1234

PHP、8 *（44 + 53）= 776

エンコーダー、44バイト：

for(;$n=&$argn;$n>>=4)echo$n&15|16*$i++," ";

スペースで区切られた整数のリストを出力します。でパイプとして実行し-nRます。

4データビット（下位ニブル）と3重みビット（上位ニブル）で最大8バイト。

簡単に言えば、
各16進数字を独自の文字に入れ、バイトの上半分を使用して数字の位置を格納します。

例：

1457893891（0x56e5b203）に変わります
0x03、0x10、0x22、0x3b、0x45、0x5e、0x66、0x75
→3 16 34 59 69 94 102 117

デコーダー、53バイト：

while($i++<8)$n+=(15&$x=$argv[$i])<<($x>>4)*4;echo$n;

または

while($i++<8)$n+=(15&$x=$argv[$i])<<($x/4&~3);echo$n;

または

for(;$i<9;$x=$argv[++$i])$n+=$x%16<<($x/4&~3);echo$n;

コマンドライン引数から整数を取得します。で実行し-nrます。

オンラインで試してください。

Python 2、10 *（68 + 54）= 1220

e=lambda n:"".join(chr(int(`i`+j))for i,j in enumerate(`n`)if j<'L')
d=lambda s:int("".join(`ord(c)%10`for c in sorted(s)))

オンラインでお試しください！

編集：ポインターのジョーキングのおかげで-振り返ってみると、なぜ32で相殺されたのか分かりません。

NULバイト0x0の[スペース]（位置0、値0）で始まる単一の文字として、各場所の位置と値をエンコードします。

デコード：

• 文字列の並べ替え（Pythonは文字を順序値で並べ替えます）
• 各文字を順序値に変換します
• 各順序整数の最後の桁を取ります
• 整数を文字列に結合します
• 結合された文字列をintに変換します

C（gcc）、10 * 112 = 1120

c,i;e(i,s)char*s;{for(c=1;i;c+=10,i/=10)*s++=c+i%10;*s=0;}
d(char*s){for(i=0;c=*s++;i+=--c%10*pow(10,c/10));s=i;}

オンラインでお試しください！

グローバル変数を持っていますが、実際には2つの関数間で情報を渡していません。の変数宣言cは両方の関数で使用され、コード長を2バイト節約します。

3 5バイトのペナルティにのみ印刷可能なASCIIを使用するバージョンは次のとおりです。

c,i;e(i,s)char*s;{for(c=32;i;c+=10,i/=10)*s++=c+i%10;*s=0;}
d(char*s){for(i=0;c=*s++;i+=(c-=32)%10*pow(10,c/10));s=i;}

@ceilingcatに70ポイントの改善をありがとう。