任务

A-Z使用您自己喜欢的方案，仅使用零和一来对完全由大写字母（）组成的字符串进行编码。但是规则不是那么简单！

规则

1. 您的程序/函数必须正确处理长度为8的任何有效输入字符串。
2. 所有输入的结果长度必须相同。
3. 对于不同的输入，结果必须是不同的。
4. 结果必须尽可能短。
5. 结果必须为零一平衡（具有与零相似的数目）。他们不必相等（即完全平衡），但是您的分数将因此受到惩罚。

您不必提供解码您的编码的程序/功能。

输入输出

• 您可以决定接受任何一组26个不同的可打印ASCII字符代替A-Z。
• 您可以决定输出任意一对不同的可打印ASCII字符来代替0和1。
• 您不允许输出整数而不是位字符串，因为它可能有前导零，并且不清楚您是否确实满足规则2。
• 如果决定偏离默认值（A-Z输入和01输出），则必须在提交中指定输入/输出字符集。

计分

• 基本分数：代码大小，如果程序为空，则为1。
• 罚则
  • 长度处罚：相乘 1.5 ** (encoded length - 42)
  • 矮个没有奖金。42是字母大小为26的8长度字符串的完美平衡编码的最小长度。
  • 不平衡的惩罚：乘以2 ** max(abs(ones - zeros) for every valid input of length 8)，其中ones和zeros分别是每个输出中1和0的计数。
  • 您的提交必须显示最坏情况的示例（输入/输出）或惩罚值的理论解释。
• 最低分获胜。

提交示例

假设的esolang，0字节，得分74733.8906

这是一个假设的esolang，其中一个空程序以二进制形式打印输入字符的所有ASCII码。

例如，如果您提供AAAAAAAA输入，程序将1000001连续打印8次，即10000011000001100000110000011000001100000110000011000001。

输入的字母选择为CEFGIJKLMNQRSTUVXYZabcdefh。这样，所有字符都将转换为二进制的七位数字，并且每个字符的零一计数仅相差一个（转换为二进制时，它们全部具有三个1和四个0，反之亦然）。

输出长度始终为56，最坏情况下的不平衡发生在输入上，如CCCCCCCC，其中零比1多出现8次。

因此，此提交的分数是1.5 ** (56 - 42) * 2 ** 8 == 74733.8906。

Stax，11字节，0罚分，得分11

该程序[0-9A-P]用于输入和[01]输出。

ö■▄←·ï↨≡⌐╠H

在线运行和调试 -单击运行按钮以启动。前四个测试用例以毫秒为单位运行。第五秒。千禧年第六。

该程序的相应ascii表示形式是this。

A$21*,26|bD|N

它严重依赖于|N指令，该指令获取数组的后续排列。

A$21*           "10" repeated 21 times
     ,26|b      get input and decode it as a base 26 number
          D|N    ... that many times get the next lexicographic permutation

所有输出都是初始字符串的排列。它有21个零和21个零。因此，所有输出均为42个字符，并且完全平衡。

果冻，19字节

O_65ḅ26ị2Ḷ¤x21¤Œ!Q¤

在线尝试！

说明

O_65ḅ26ị2Ḷ¤x21¤Œ!Q¤  Main Link
O                    Take the character code of each character
 _65                 Subtract 65 (the code of "A")
    ḅ26              Convert to base 26
       ị             Get the <left-arg>th element of:
        2Ḷ¤x21¤Œ!Q¤  All balanced strings of length 42:
        2Ḷ           range(2) == [0, 1]
           x21       stretch 21 ([0, 0, ..., 0, 1, 1, ..., 1])
               Œ!    all permutations
                 Q   deduplicate

Pyth，20 19 14个字节，最大差异：0，长度：64，得分：149636.5528 142154.7251 104745.5869

sm@S.{.p*`T4xG

在线尝试！

使用小写字母（[a-z]）而不是大写字母。可以使用大写替换G为rG1，以2字节为代价。

我可以翻译HyperNeutrino 的Python 3答案以获得更好的分数，但是坦率地说，我想要一个切实可行的答案。

Python 2中，779个 645字节，最大（DIFF）= 0，长度= 48，分数= 7346.95

def f(s):
 a,b=0,""
 for i in s:a=a*26+ord(i)-65
 a+=56*252**4
 for i in range(5):b=bin((int("4lnk28t9vtqgfrpfda9uyfrjhcjwjvno6aec2nwegi0g4mnublc05dher8fjm4s5gh55lu87a4itmc74t6tozcsfdbxkg82frwljy0wam1jht98g2j0bma021v5d48pwq0fklv0n1ltrxft1fpk5gt5mx5fj4p2mjqqpvcylt1xayxf1iwdmyoxgfvl7oui1oo6147bm9rqpqut9ns8hhjc77t3pqy48otovrsm1t4mmleumspkuef66ma1vi0l4mtkwaeeizuvvds9fro3vhc0mrn6ox17rdpk7xw747qf28934u5jci5q1qj81i7dyf7rf0x7hb19xm93xhxsgh4w8ifs6fhynsddbo9j938ewfvhjlbpiz50n5hanmno6c89blyx50e89z7vjq2ho2r2u2wwyu4q18kv4fi1nhmfbgjbnkdayr5kblaped4fo5u97bi9a67d89irxa0r9cinmnohfgjmh5fhkcr33",36)>>a%252*10)&1023)[2:].rjust(10,"0")+b;a/=252
 return b[2:]

在线尝试！

幻数 4lnk28t9vtqgfrpfda9uyfrjhcjwjvno6aec2nwegi0g4mnublc05dher8fjm4s5gh55lu87a4itmc74t6tozcsfdbxkg82frwljy0wam1jht98g2j0bma021v5d48pwq0fklv0n1ltrxft1fpk5gt5mx5fj4p2mjqqpvcylt1xayxf1iwdmyoxgfvl7oui1oo6147bm9rqpqut9ns8hhjc77t3pqy48otovrsm1t4mmleumspkuef66ma1vi0l4mtkwaeeizuvvds9fro3vhc0mrn6ox17rdpk7xw747qf28934u5jci5q1qj81i7dyf7rf0x7hb19xm93xhxsgh4w8ifs6fhynsddbo9j938ewfvhjlbpiz50n5hanmno6c89blyx50e89z7vjq2ho2r2u2wwyu4q18kv4fi1nhmfbgjbnkdayr5kblaped4fo5u97bi9a67d89irxa0r9cinmnohfgjmh5fhkcr33（基数为36）或其十进制等值382136276621246556626597379364678993894472503063952720559883124988542417847157286833446006767955087631166943136913765901237281892296575754126024183763829277879554548743231384272055945084065681774297483130020386641869860456147616177702938121538230311395513497506285733567467605871232294046704309941152721616618474501854355102646152223338484615876165254236449912858255665248186687952137487016925761633237335983620006273901509768720506129789443353730706676483647298576692613113269388239830925662977837917272690235355742330377154505179476767457756888107428475384947712227312747517748632498691058764154580934614231152483398774630508576533263098942260213967880819240793990219283490212843120923539516962682466148372296338428497778127570401190309339992457562121354271对5 0秒和5 1秒的所有252个排列进行编码。

该算法首先将其转换A-Z为0-25基数为26的数字，然后添加56*252**4。

然后，该数字将转换为5位以252为基的数字，并用5 0s和5 1s 的相应排列替换。

之后，删除前2位，保证为01。然后，我们将字符串编码为48位字符串，该字符串恰好由24 0秒和24 1秒组成。

JavaScript（ES8），得分22186.623779296875

f=
s=>s.replace(/./g,(c,i)=>(i%2*127^c.charCodeAt()).toString(2).padStart(7,0))

<input oninput=o.textContent=f(this.value)><pre id=o>

对于偶数长度的输入，始终输出3.5 *的零和一，因此只支付1.5 ** 14的罚款。支持的字符：'+-.3569:<GKMNSUVYZ\cefijlqrtx。

果冻，16字节

42ɠO%ḅ26ịœcH$ạ‘Ṭ

用途+,-./0123456789:;<=>?@ABCD输入，并返回1和0的列表。

这会尝试在内存中建立一个538,257,874,440个组合的列表，因此您将需要大量RAM才能按原样运行它...

在线尝试！（可测试；输入长度3，输出长度18）

怎么运行的

42ɠO%ḅ26ịœcH$ạ‘Ṭ  Main link. No arguments.

42                Set the argument and the return value to 42.
  ɠ               Read one line from STDIN.
   O              Ordinal; map ['+', ..., 'D'] to [43, ..., 69].
    %             Take the code points modulo 42, mapping [43, ..., 69] to
                  [1, ..., 26].
     ḅ26          Convert the result from base 26 to integer.
            $     Combine the two links to the left into a monadic chain.
           H          Halve; yield 21.
         œc           Generate all 21-combinations of [1, ..., 42].
                  There are 538,257,874,440 of these combinations. The first
                  269,128,937,220 begin with a 1.
        ị         Retrieve the combination at the index to the left.
                  [26, 26, 26, 26, 26, 26, 26, 26] in bijective base 26 equals
                  217,180,147,158 in decimal, so the retrieved combination will
                  begin with a 1.
              ‘   Increment; yield 43.
             ạ    Absolute difference; map [1, ..., 42] to [42, ..., 1].
                  The combination now begins with a 42.
               Ṭ  Untruth; turn the combination into a Boolean list, with 1's
                  at the specified indices and 0's elsewhere.
                  Since the maximum of the combination is 42, this list will have
                  exactly 42 items, 21 of which will be 1's.

Python 3中，985个 135字节，最大DIFF 0，长度42，得分135

lambda s:C(int(s,26),21,20)
B=lambda x,y:y<1or-~x*B(x+1,y-1)//y
def C(n,o,z):p=B(o,z);x=n>=p;return z+1and[x]+C(n-p*x,o-x,z-1+x)or[1]*o

在线尝试！

由Bubbler提供

取消程式码：

import math

def binomial(x, y):
    return math.factorial(x) // math.factorial(y) // math.factorial(x - y)

def string_to_int(input_str):
    result = 0
    for i in range(0,8):
        result += (ord(input_str[i])-65)%26 * pow(26,i)
    return result

def counting_function(target, ones, zeros):
    if zeros > 0:
        position = binomial(ones+zeros-1,zeros-1)
    else:
        position = 1
    if target > position:
        if ones > 0:
            print("1", end='')
            ones -= 1
            counting_function(target-position,ones,zeros)
    else:
        if zeros > 0:
            print("0", end='')
            zeros -= 1
            counting_function(target,ones,zeros)
        elif ones > 0:
            print("1", end='')
            ones -= 1
            counting_function(target,ones,zeros)

input_str = input("Input string (A-Z): ")
input_int = string_to_int(input_str)+1
target = input_int
ones = 21
zeros = 21
counting_function(target, ones, zeros)
print("")

由于其他方法似乎效率很低，因此我尝试了一种时间最优的方法。在N位编码中它是O（N），这是big-O最佳的。

提示：试着想到帕斯卡的三角形（此图显示了它）

样本输出：

Input:  AAAAAAAA
Output: 000000000000000000000111111111111111111111

Input:  ZZZZZZZZ
Output: 011001000000011010011000111010110110111110

执行时间：<0.013 s（对于所有输入大致恒定）

Perl 5、55个字节，最大差异0，长度42，得分56 55

这可以工作，但是会花费很长时间，但是可行的（ZZZZZZZZ在我的计算机上花费了2.5天）。内存没问题。

用途A-Z作为输入，1并A为编码字符。它们始终完美平衡。跳过26^7 = 8031810176表示少于8个字符的字符串的第一个平衡组合，但这没关系，因为有538257874440可用的字符串，并且我使用208827064575和208827064575 + 8031810176 < 538257874440。

但是，实际上它“计数”到目标组合，这将花费很长时间。这就是为什么在TIO链接中我仅使用了太短的输入字符串（也支持）来证明输出正确的原因。将比AAAAAATIO超时之前的工作量更多。ZZZZZZZZ应该26^3 = 17576慢几倍。

#!/usr/bin/perl -ap
$_=1x21 .($i=A)x21;s/(A*)(1*)1A/$2$1A1/ until"@F"eq$i++

在线尝试！

解码器几乎相同：

#!/usr/bin/perl -ap
$_=1x21 .($\=A)x21;s/(A*)(1*)1A/$2$1A1/,$\++until"@F"eq$_}{

在线尝试！

> <>，75个字节，最大差异0，长度42，得分75

0i:0(?v'A'-$dd+*+!
.")1+.\1+:0$:2%:}:@-2,@+$bl"
[ab+-?\$:?vv~3
~~]>n<v$-1<>

在线尝试！

公平的警告，即使是平凡的情况，这也将花费非常 非常长的时间AAAAAAAA。遍历计数器的每个二进制表示，直到达到（输入的基数26表示）第21个二进制数1。如果您想对程序进行某种程度的测试，则可以将ab+第三行的替换为1仅返回一个的第n个二进制数1，请在线尝试！

Python 3，75个字节，最大差异0，长度42，分数112

lambda s:sorted({*permutations("01"*21)})[int(s,26)]
from itertools import*

在线尝试！

由于内存限制，这仅在理论上有效。有538257874440长度42和不同的均衡0-1串208827064575可能的输入，所以一些可能的输出的将不被使用。

-37字节感谢@recursive

C ++，146字节，最大长度42，0不平衡，得分146

#include<algorithm>
long long i,s;int f(char*I,char*O){for(O[i=42]=s=0;i--;i<8?s=s*26+I[i]:0)O[i]=i%2|48;for(;s--;)std::next_permutation(O,O+42);}

适用于任何连续的26个字符，但警告它运行了不可接受的时间