Compito

Codifica una stringa che consiste interamente di alfabeti maiuscoli ( A-Z) usando solo zeri e quelli, usando il tuo schema preferito. Ma la regola non è così semplice!

Regole

1. Il programma / funzione deve gestire correttamente qualsiasi stringa di input valida di lunghezza 8 .
2. I risultati devono avere la stessa lunghezza per tutti gli input.
3. I risultati devono essere distinti per input distinti.
4. I risultati devono essere il più brevi possibile.
5. I risultati devono essere zero-uno bilanciati (avere un numero di quelli simili a quello degli zeri). Non devono essere uguali (cioè perfettamente bilanciati), ma il tuo punteggio sarà penalizzato per questo.

Non è necessario fornire un programma / funzione che decodifichi la codifica.

Ingresso e uscita

• Puoi decidere di accettare qualsiasi set di 26 caratteri ASCII stampabili distinti anziché A-Z.
• È possibile decidere di generare qualsiasi coppia di caratteri ASCII stampabili distinti anziché 0e 1.
• Non è consentito generare un numero intero anziché una stringa di bit, poiché potrebbe avere zeri iniziali e non è chiaro se si è effettivamente rispettati la regola 2.
• Se si decide di discostarsi dal valore predefinito ( A-Zinput e 01output), è necessario specificare i set di caratteri di input / output nell'invio.

punteggio

• Punteggio di base: dimensione del codice o 1 se il programma risulta essere vuoto.
• sanzioni
  • Penalità per lunghezza: moltiplicare 1.5 ** (encoded length - 42)
  • Non ci sono bonus per essere più brevi; 42 è la lunghezza minima per una codifica perfettamente bilanciata di stringhe di 8 lunghezze con dimensione alfabeto 26.
  • Penalità per essere sbilanciato: moltiplicare 2 ** max(abs(ones - zeros) for every valid input of length 8), dove onese zerossono i conteggi di 1 e 0 in ciascuna uscita, rispettivamente.
  • L'invio deve mostrare un esempio nel caso peggiore (input / output) o una spiegazione teorica sul valore della penalità.
• Vince il punteggio più basso.

Esempio di presentazione

Esolang ipotetico, 0 byte, punteggio 74733,8906

Ecco un ipotetico esolang, in cui un programma vuoto stampa tutti i codici ASCII dei caratteri di input in binario.

Ad esempio, se si fornisce AAAAAAAAcome input, il programma stamperà 10000018 volte di seguito, ad es 10000011000001100000110000011000001100000110000011000001.

L'alfabeto di input è scelto per essere CEFGIJKLMNQRSTUVXYZabcdefh. In questo modo, tutti i caratteri vengono convertiti in binari a sette cifre e i conteggi zero-one differiscono solo di uno per carattere (tutti hanno tre 1 e quattro 0 o viceversa quando convertiti in binario).

La lunghezza dell'uscita è sempre 56 e lo sbilanciamento nel caso peggiore si verifica sugli ingressi simili CCCCCCCC, dove gli zeri compaiono 8 volte più di quelli.

Pertanto, il punteggio di questa presentazione è 1.5 ** (56 - 42) * 2 ** 8 == 74733.8906.

Stax , 11 byte, 0 penalità, punteggio 11

Questo programma utilizza [0-9A-P]per l'input e [01]per l'output.

ö■▄←·ï↨≡⌐╠H

Esegui ed esegui il debug online : fai clic sul pulsante Esegui per iniziare. I primi quattro casi di test vengono eseguiti in millisecondi. Il quinto in pochi secondi. Il sesto in millennio.

La corrispondente rappresentazione ASCII di questo programma è questa.

A$21*,26|bD|N

Si appoggia fortemente sull'istruzione |N, che ottiene la successiva permutazione di un array.

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

Tutte le uscite sono permutazioni della stringa iniziale. Ha 21 zero e 21. Pertanto, tutte le uscite sono di 42 caratteri e perfettamente bilanciate.

Gelatina , 19 byte

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

Provalo online!

Spiegazione

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 byte, Max Diff: 0, Lunghezza: 64, Punteggio: 149636.5528 142154.7251 104745.5869

sm@S.{.p*`T4xG

Provalo online!

Utilizza l'alfabeto minuscolo ( [a-z]) anziché maiuscolo. Può utilizzare lettere maiuscole sostituendo Gcon rG1, al costo di 2 byte.

Avrei potuto tradurre la risposta Python 3 di HyperNeutrino per un punteggio migliore, ma francamente, voglio una risposta che funzioni davvero.

Python 2 , 779 645 byte, Max (Diff) = 0, Lunghezza = 48, Punteggio = 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:]

Provalo online!

Il numero magico 4lnk28t9vtqgfrpfda9uyfrjhcjwjvno6aec2nwegi0g4mnublc05dher8fjm4s5gh55lu87a4itmc74t6tozcsfdbxkg82frwljy0wam1jht98g2j0bma021v5d48pwq0fklv0n1ltrxft1fpk5gt5mx5fj4p2mjqqpvcylt1xayxf1iwdmyoxgfvl7oui1oo6147bm9rqpqut9ns8hhjc77t3pqy48otovrsm1t4mmleumspkuef66ma1vi0l4mtkwaeeizuvvds9fro3vhc0mrn6ox17rdpk7xw747qf28934u5jci5q1qj81i7dyf7rf0x7hb19xm93xhxsgh4w8ifs6fhynsddbo9j938ewfvhjlbpiz50n5hanmno6c89blyx50e89z7vjq2ho2r2u2wwyu4q18kv4fi1nhmfbgjbnkdayr5kblaped4fo5u97bi9a67d89irxa0r9cinmnohfgjmh5fhkcr33(nella base 36), o il suo equivalente decimale 382136276621246556626597379364678993894472503063952720559883124988542417847157286833446006767955087631166943136913765901237281892296575754126024183763829277879554548743231384272055945084065681774297483130020386641869860456147616177702938121538230311395513497506285733567467605871232294046704309941152721616618474501854355102646152223338484615876165254236449912858255665248186687952137487016925761633237335983620006273901509768720506129789443353730706676483647298576692613113269388239830925662977837917272690235355742330377154505179476767457756888107428475384947712227312747517748632498691058764154580934614231152483398774630508576533263098942260213967880819240793990219283490212843120923539516962682466148372296338428497778127570401190309339992457562121354271, codifica per tutte le 252 permutazioni di 5 se 05 1s.

L'algoritmo primi convertiti A-Zin 0-25e trattano come un numero in base 26, quindi aggiungere 56*252**4.

Quindi, il numero viene convertito in un numero di base 252 a 5 cifre e sostituisce con la permutazione corrispondente di 5 se 05 1s.

Successivamente, elimina i primi 2 bit, che è garantito 01. Quindi abbiamo codificato la stringa in una stringa a 48 bit, che consiste esattamente di 24 se 024 1s.

JavaScript (ES8), punteggio 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>

Per un input di lunghezza uniforme, genera sempre 3,5 * di zeri e uno, quindi paga solo la penalità di 1,5 ** 14. Caratteri supportati: '+-.3569:<GKMNSUVYZ\cefijlqrtx.

Gelatina , 16 byte

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

Utilizza +,-./0123456789:;<=>?@ABCDper l'input e restituisce un elenco di uno e zero.

Questo tenta di creare un elenco di 538.257.874.440 combinazioni in memoria, quindi avrai bisogno di una grande quantità di RAM per eseguirlo così com'è ...

Provalo online! (testabile; lunghezza input 3, lunghezza output 18)

Come funziona

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 byte, Max Diff 0, Lunghezza 42, punteggio 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

Provalo online!

Per gentile concessione di Bubbler

Codice non golfato:

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

Dato che altri approcci sembrano abbastanza inefficienti, ho cercato di renderlo ottimale nel tempo. È chiaramente O (N) in N bit di codifica, che è big-O ottimale.

Suggerimento: prova a pensare al triangolo di Pascal per questo ( questo diagramma lo rivela)

Output di esempio:

Input:  AAAAAAAA
Output: 000000000000000000000111111111111111111111

Input:  ZZZZZZZZ
Output: 011001000000011010011000111010110110111110

Tempo di esecuzione: <0,013 s (approssimativamente costante per tutti gli ingressi)

Perl 5 , 55 byte, max diff 0, lunghezza 42, punteggio 56 55

Funziona ma richiederà molto tempo, ma è possibile (impiegando ZZZZZZZZ2,5 giorni sul mio computer). La memoria non è un problema.

Usi A-Zcome input ed 1e Acome codifica dei caratteri. Sono sempre perfettamente bilanciati. Salta le prime 26^7 = 8031810176combinazioni bilanciate che rappresentano una stringa più corta di 8 caratteri, ma va bene dato che ci sono 538257874440disponibili e io uso 208827064575e 208827064575 + 8031810176 < 538257874440.

Tuttavia, in realtà "conta" fino alla combinazione target che richiederà molto tempo. Ecco perché nel collegamento TIO ho usato solo una stringa di input troppo corta (anch'essa supportata) per dimostrare che l'output è corretto. Funzionerà fino a un po 'di più rispetto a AAAAAAprima che TIO scada. ZZZZZZZZdovrebbe essere 26^3 = 17576volte più lento.

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

Provalo online!

Il decodificatore è quasi lo stesso:

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

Provalo online!

> <> , 75 byte, Max Diff 0, Lunghezza 42, punteggio 75

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

Provalo online!

Fair Warning, questo richiederà molto molto molto tempo per completare anche per la banale AAAAAAAAcaso. Scorre attraverso ciascuna rappresentazione binaria di un contatore fino al raggiungimento del numero binario di (base 26 rappresentazione dell'ingresso) con 21 1s. Se vuoi testare un po 'il programma, puoi sostituire quello ab+sulla terza riga con il 1quale restituirà l'ennesimo numero binario con un solo 1, Provalo online!

Python 3 , 75 byte, Max Diff 0, Lunghezza 42, Punteggio 112

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

Provalo online!

Funziona solo in teoria a causa di vincoli di memoria. Esistono 538257874440stringhe zero-one bilanciate distinte di lunghezza 42 e 208827064575possibili ingressi, quindi alcune delle possibili uscite non verranno utilizzate.

-37 byte grazie a @recursive

C ++, 146 byte, 42 lunghezza massima, 0 squilibrio, punteggio 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);}

Funziona con qualsiasi 26 caratteri continuo, ma avvisa che è inaccettabile