Tarefa

Codifique uma string que consiste inteiramente de letras maiúsculas ( A-Z) usando apenas zeros e uns, usando seu próprio esquema favorito. Mas a regra não é tão simples!

Regras

1. Seu programa / função deve manipular corretamente qualquer sequência de entrada válida de comprimento 8 .
2. Os resultados devem ter o mesmo comprimento para todas as entradas.
3. Os resultados devem ser distintos para entradas distintas.
4. Os resultados devem ser tão curtos quanto possível.
5. Os resultados devem ser balanceados em zero um (ter um número semelhante ao dos zeros). Eles não precisam ser iguais (ou seja, perfeitamente equilibrados), mas sua pontuação será penalizada por isso.

Você não precisa fornecer um programa / função que decodifique sua codificação.

Entrada e saída

• Você pode optar por aceitar qualquer conjunto de 26 caracteres ASCII imprimíveis distintos em vez de A-Z.
• Você pode optar por imprimir qualquer par de caracteres ASCII imprimíveis distintos em vez de 0e 1.
• Você não tem permissão para gerar um número inteiro em vez de uma sequência de bits, pois pode ter zeros à esquerda e não está claro se você realmente cumpriu a regra 2.
• Se você decidir se desviar do padrão ( A-Zentrada e 01saída), deverá especificar os conjuntos de caracteres de entrada / saída no seu envio.

Pontuação

• Pontuação básica: tamanho do código ou 1 se o seu programa estiver vazio.
• Sanções
  • Pena por comprimento: multiplicar 1.5 ** (encoded length - 42)
  • Não há bônus por ser mais baixo; 42 é o comprimento mínimo para uma codificação perfeitamente equilibrada de cadeias de 8 comprimentos com tamanho de alfabeto 26.
  • Penalidade por desequilíbrio: multiplique 2 ** max(abs(ones - zeros) for every valid input of length 8), onde onese zerossão as contagens de 1 e 0 em cada saída, respectivamente.
  • Seu envio deve mostrar um exemplo de pior caso (entrada / saída) ou explicação teórica sobre o valor da penalidade.
• A pontuação mais baixa vence.

Submissão de exemplo

Esolang hipotético, 0 Bytes, Pontuação 74733.8906

Aqui está um esolang hipotético, em que um programa vazio imprime todos os códigos ASCII dos caracteres da entrada em binário.

Por exemplo, se você fornecer AAAAAAAAcomo entrada, o programa imprimirá 10000018 vezes seguidas, ou seja 10000011000001100000110000011000001100000110000011000001.

O alfabeto de entrada é escolhido para ser CEFGIJKLMNQRSTUVXYZabcdefh. Dessa forma, todos os caracteres são convertidos em sete dígitos em binário e a contagem de zero e um difere apenas um por caractere (todos eles têm três 1 e quatro 0 ou vice-versa quando convertidos em binário).

O comprimento da saída é sempre 56 e o ​​pior desequilíbrio ocorre nas entradas como CCCCCCCC, onde os zeros aparecem 8 vezes mais do que aqueles.

Portanto, a pontuação dessa submissão é 1.5 ** (56 - 42) * 2 ** 8 == 74733.8906.

Stax , 11 bytes, 0 de penalidade, Pontuação 11

Este programa usa [0-9A-P]para entrada e [01]saída.

ö■▄←·ï↨≡⌐╠H

Execute e depure on-line - clique no botão Executar para iniciar. Os quatro primeiros casos de teste são executados em milissegundos. O quinto em segundos. O sexto em milênios.

A representação ascii correspondente deste programa é essa.

A$21*,26|bD|N

Ele se apóia fortemente na |Ninstrução, que obtém a permutação subsequente de uma matriz.

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

Todas as saídas são permutações da string inicial. Tem 21 zeros e 21 uns. Portanto, todas as saídas têm 42 caracteres e são perfeitamente equilibradas.

Geléia , 19 bytes

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

Experimente online!

Explicação

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 bytes, Dif. Máximo: 0, Comprimento: 64, Pontuação: 149636.5528 142154.7251 104745.5869

sm@S.{.p*`T4xG

Experimente online!

Usa o alfabeto em minúsculas ( [a-z]) em vez de maiúsculas. Pode usar maiúsculas, substituindo Gpor rG1, ao custo de 2 bytes.

Eu poderia ter traduzido a resposta Python 3 do HyperNeutrino para obter uma pontuação melhor, mas, francamente, quero uma resposta que realmente funcione.

Python 2 , 779 645 bytes, Máx. (Dif.) = 0, Comprimento = 48, Pontuação = 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:]

Experimente online!

O número mágico 4lnk28t9vtqgfrpfda9uyfrjhcjwjvno6aec2nwegi0g4mnublc05dher8fjm4s5gh55lu87a4itmc74t6tozcsfdbxkg82frwljy0wam1jht98g2j0bma021v5d48pwq0fklv0n1ltrxft1fpk5gt5mx5fj4p2mjqqpvcylt1xayxf1iwdmyoxgfvl7oui1oo6147bm9rqpqut9ns8hhjc77t3pqy48otovrsm1t4mmleumspkuef66ma1vi0l4mtkwaeeizuvvds9fro3vhc0mrn6ox17rdpk7xw747qf28934u5jci5q1qj81i7dyf7rf0x7hb19xm93xhxsgh4w8ifs6fhynsddbo9j938ewfvhjlbpiz50n5hanmno6c89blyx50e89z7vjq2ho2r2u2wwyu4q18kv4fi1nhmfbgjbnkdayr5kblaped4fo5u97bi9a67d89irxa0r9cinmnohfgjmh5fhkcr33(na base 36), ou seu equivalente decimal 382136276621246556626597379364678993894472503063952720559883124988542417847157286833446006767955087631166943136913765901237281892296575754126024183763829277879554548743231384272055945084065681774297483130020386641869860456147616177702938121538230311395513497506285733567467605871232294046704309941152721616618474501854355102646152223338484615876165254236449912858255665248186687952137487016925761633237335983620006273901509768720506129789443353730706676483647298576692613113269388239830925662977837917272690235355742330377154505179476767457756888107428475384947712227312747517748632498691058764154580934614231152483398774630508576533263098942260213967880819240793990219283490212843120923539516962682466148372296338428497778127570401190309339992457562121354271, codifica todas as 252 permutações de 5 se 05 1s.

O algoritmo primeiros convertidos A-Zem 0-25e tratá-lo como um número base-26, em seguida, adicionar 56*252**4.

Em seguida, o número é convertido em um número base-252 de 5 dígitos e substitui pela permutação correspondente de 5 se 05 1s.

Depois disso, exclua os 2 primeiros bits, o que é garantido 01. Em seguida, codificamos a string em uma string de 48 bits, que consiste exatamente em 24 se 024 1s.

JavaScript (ES8), pontuação 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>

Para uma entrada de comprimento uniforme, sempre gera 3,5 * de zeros e uns, portanto, paga apenas a penalidade de 1,5 ** 14. Caracteres suportados: '+-.3569:<GKMNSUVYZ\cefijlqrtx.

Gelatina , 16 bytes

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

Usa +,-./0123456789:;<=>?@ABCDpara entrada e retorna uma lista de uns e zeros.

Isso tenta criar uma lista de 538.257.874.440 combinações na memória, portanto você precisará de uma grande quantidade de RAM para executá-la como está ...

Experimente online! (testável; comprimento de entrada 3, comprimento de saída 18)

Como funciona

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 bytes, Diferença máxima 0, Comprimento 42, pontuação 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

Experimente online!

Cortesia de Bubbler

Código não destruído:

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("")

Como outras abordagens parecem bastante ineficientes, tentei otimizar o tempo. É claramente O (N) em N bits de codificação, o que é grande-O ideal.

Dica: tente pensar no triângulo de Pascal para este ( este diagrama o revela)

Saídas de amostra:

Input:  AAAAAAAA
Output: 000000000000000000000111111111111111111111

Input:  ZZZZZZZZ
Output: 011001000000011010011000111010110110111110

Tempo de execução: <0,013 s (aproximadamente constante para todas as entradas)

Perl 5 , 55 bytes, diferença máxima 0, comprimento 42, pontuação 56 55

Isso funciona, mas levará um tempo longo, mas factível ( ZZZZZZZZlevou 2,5 dias no meu computador). Memória não é problema.

Utilizações A-Zcomo entrada e 1e Acomo caracteres de codificação. Eles estão sempre perfeitamente equilibrados. Ignora as primeiras 26^7 = 8031810176combinações balanceadas que representam cadeias menores que 8 caracteres, mas tudo bem, pois existem 538257874440disponíveis e eu uso 208827064575e 208827064575 + 8031810176 < 538257874440.

No entanto, ele "conta" até a combinação de alvos, que levará muito tempo. Por isso, no link TIO, usei apenas uma string de entrada muito curta (que também é suportada) para demonstrar que a saída está correta. Trabalhará um pouco mais do que AAAAAAantes do tempo limite do TIO. ZZZZZZZZdeve ser cerca de 26^3 = 17576vezes mais lento.

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

Experimente online!

O decodificador é quase o mesmo:

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

Experimente online!

> <> , 75 bytes, Diferença máxima 0, Comprimento 42, pontuação 75

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

Experimente online!

Aviso justo, isso levará muito, muito, muito tempo para ser concluído, mesmo no AAAAAAAAcaso trivial . Percorre cada representação binária de um contador até que o número binário (base 26 da entrada) 1seja alcançado com 21 s. Se você quiser testar um pouco o programa, substitua o ab+da terceira linha pela 1qual retornará o enésimo número binário com apenas um único 1, Experimente on-line!

Python 3 , 75 bytes, Dif. 0, Comprimento 42, Pontuação 112

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

Experimente online!

Isso só funciona em teoria devido a restrições de memória. Existem 538257874440strings zero-um balanceadas distintas de comprimento 42 e 208827064575entradas possíveis, portanto, algumas das saídas possíveis não serão usadas.

-37 bytes graças a @recursive

C ++, 146 bytes, 42 comprimento máximo, 0 desequilíbrio, pontuação 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);}

Funciona para qualquer caractere contínuo de 26 caracteres, mas avisa que demora um tempo inaceitável