Bài tập

Mã hóa một chuỗi hoàn toàn bao gồm các chữ cái in hoa ( A-Z) chỉ sử dụng các số 0 và một, sử dụng lược đồ yêu thích của riêng bạn. Nhưng quy tắc không đơn giản!

Quy tắc

1. Chương trình / chức năng của bạn phải xử lý chính xác bất kỳ chuỗi đầu vào hợp lệ nào có độ dài 8 .
2. Các kết quả phải có cùng độ dài cho tất cả các đầu vào.
3. Các kết quả phải khác biệt cho đầu vào riêng biệt.
4. Kết quả phải càng ngắn càng tốt.
5. Các kết quả phải bằng không - một số dư (có số lượng tương tự với số không). Họ không cần phải bằng nhau (tức là cân bằng hoàn hảo), nhưng điểm của bạn sẽ bị phạt vì điều đó.

Bạn không phải cung cấp một chương trình / chức năng giải mã mã hóa của bạn.

Đầu vào và đầu ra

• Bạn có thể quyết định chấp nhận bất kỳ bộ 26 ký tự ASCII có thể in riêng biệt nào thay vì A-Z.
• Bạn có thể quyết định xuất bất kỳ cặp ký tự ASCII có thể in riêng biệt nào thay vì 0và 1.
• Bạn không được phép xuất một số nguyên thay vì một chuỗi bit, vì nó có thể có các số 0 đứng đầu và không rõ ràng nếu bạn thực sự đáp ứng quy tắc 2.
• Nếu bạn quyết định đi chệch khỏi mặc định ( A-Zđầu vào và 01đầu ra), bạn phải chỉ định các bộ ký tự đầu vào / đầu ra trong bài gửi của mình.

Chấm điểm

• Điểm cơ bản: Kích thước mã hoặc 1 nếu chương trình của bạn trống.
• Hình phạt
  • Hình phạt cho chiều dài: nhân lên 1.5 ** (encoded length - 42)
  • Không có tiền thưởng cho việc ngắn hơn; 42 là độ dài tối thiểu để mã hóa cân bằng hoàn hảo các chuỗi 8 độ dài với kích thước bảng chữ cái 26.
  • Hình phạt cho việc không cân bằng: nhân 2 ** max(abs(ones - zeros) for every valid input of length 8), trong đó onesvà zeroslần lượt là 1 và 0 trong mỗi đầu ra.
  • Việc gửi của bạn phải thể hiện một ví dụ trong trường hợp xấu nhất (đầu vào / đầu ra) hoặc giải thích lý thuyết về giá trị hình phạt.
• Điểm thấp nhất sẽ thắng.

Gửi ví dụ

Giả thuyết esolang, 0 byte, Điểm 74733.8906

Đây là một esolang giả thuyết, trong đó một chương trình trống in ra tất cả các mã ASCII của các ký tự đầu vào ở dạng nhị phân.

Ví dụ: nếu bạn cung cấp AAAAAAAAlàm đầu vào, chương trình sẽ in 10000018 lần liên tiếp, tức là 10000011000001100000110000011000001100000110000011000001.

Bảng chữ cái đầu vào được chọn là CEFGIJKLMNQRSTUVXYZabcdefh. Theo cách này, tất cả các ký tự được chuyển đổi thành bảy chữ số trong nhị phân và số không một chỉ khác nhau một ký tự (tất cả chúng đều có ba 1 và bốn 0 hoặc ngược lại khi được chuyển đổi thành nhị phân).

Độ dài đầu ra luôn là 56 và sự mất cân bằng trong trường hợp xấu nhất xảy ra trên các đầu vào như CCCCCCCC, trong đó các số 0 xuất hiện nhiều hơn 8 lần so với đầu vào.

Do đó, điểm của bài nộp này là 1.5 ** (56 - 42) * 2 ** 8 == 74733.8906.

Stax , 11 byte, 0 hình phạt, Điểm 11

Chương trình này sử dụng [0-9A-P]cho đầu vào và [01]đầu ra.

ö■▄←·ï↨≡⌐╠H

Chạy và gỡ lỗi trực tuyến - nhấp vào nút chạy để bắt đầu. Bốn trường hợp thử nghiệm đầu tiên chạy trong một phần nghìn giây. Thứ năm trong vài giây. Thứ sáu tính bằng milimet.

Đại diện ascii tương ứng của chương trình này là đây.

A$21*,26|bD|N

Nó dựa rất nhiều vào |Nhướng dẫn, được hoán vị tiếp theo của một mảng.

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

Tất cả các đầu ra là hoán vị của chuỗi ban đầu. Nó có 21 số không và 21 số. Do đó, tất cả các kết quả đầu ra là 42 ký tự và cân bằng hoàn hảo.

Thạch , 19 byte

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

Hãy thử trực tuyến!

Giải trình

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, Độ dài: 64, Điểm: 149636.5528 142154.7251 104745.5869

sm@S.{.p*`T4xG

Hãy thử trực tuyến!

Sử dụng bảng chữ cái viết thường ( [a-z]) thay vì chữ hoa. Có thể sử dụng chữ hoa bằng cách thay thế Gbằng rG1, với chi phí là 2 byte.

Tôi có thể đã dịch câu trả lời Python 3 của HyperNeutrino để có điểm cao hơn, nhưng thẳng thắn mà nói, tôi muốn một câu trả lời thực sự hiệu quả.

Python 2 , 779 645 byte, Max (Diff) = 0, Độ dài = 48, Điểm = 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:]

Hãy thử trực tuyến!

Số ma thuật 4lnk28t9vtqgfrpfda9uyfrjhcjwjvno6aec2nwegi0g4mnublc05dher8fjm4s5gh55lu87a4itmc74t6tozcsfdbxkg82frwljy0wam1jht98g2j0bma021v5d48pwq0fklv0n1ltrxft1fpk5gt5mx5fj4p2mjqqpvcylt1xayxf1iwdmyoxgfvl7oui1oo6147bm9rqpqut9ns8hhjc77t3pqy48otovrsm1t4mmleumspkuef66ma1vi0l4mtkwaeeizuvvds9fro3vhc0mrn6ox17rdpk7xw747qf28934u5jci5q1qj81i7dyf7rf0x7hb19xm93xhxsgh4w8ifs6fhynsddbo9j938ewfvhjlbpiz50n5hanmno6c89blyx50e89z7vjq2ho2r2u2wwyu4q18kv4fi1nhmfbgjbnkdayr5kblaped4fo5u97bi9a67d89irxa0r9cinmnohfgjmh5fhkcr33(trong cơ sở 36), hoặc tương đương thập phân của nó 382136276621246556626597379364678993894472503063952720559883124988542417847157286833446006767955087631166943136913765901237281892296575754126024183763829277879554548743231384272055945084065681774297483130020386641869860456147616177702938121538230311395513497506285733567467605871232294046704309941152721616618474501854355102646152223338484615876165254236449912858255665248186687952137487016925761633237335983620006273901509768720506129789443353730706676483647298576692613113269388239830925662977837917272690235355742330377154505179476767457756888107428475384947712227312747517748632498691058764154580934614231152483398774630508576533263098942260213967880819240793990219283490212843120923539516962682466148372296338428497778127570401190309339992457562121354271, mã hóa tất cả 252 hoán vị của 5 0giây và 5 1giây.

Thuật toán đầu tiên chuyển đổi A-Zthành 0-25và coi nó như một số cơ sở 26, sau đó thêm 56*252**4.

Sau đó, số được chuyển đổi thành số cơ bản gồm 5 chữ số và thay thế bằng hoán vị tương ứng là 5 0giây và 5 1giây.

Sau đó, xóa 2 bit đầu tiên, được đảm bảo 01. Sau đó, chúng tôi đã mã hóa chuỗi thành chuỗi 48 bit, bao gồm chính xác 24 0giây và 24 1giây.

JavaScript (ES8), điểm 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>

Đối với đầu vào độ dài chẵn, luôn luôn xuất 3,5 * số 0 và số 0, do đó, nó chỉ phải trả tiền phạt 1,5 ** 14. Nhân vật được hỗ trợ : '+-.3569:<GKMNSUVYZ\cefijlqrtx.

Thạch , 16 byte

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

Sử dụng +,-./0123456789:;<=>?@ABCDcho đầu vào và trả về một danh sách các số và số không.

Điều này cố gắng xây dựng danh sách 538.257.874.440 kết hợp trong bộ nhớ, vì vậy bạn sẽ cần một lượng RAM lớn để chạy nó như ...

Hãy thử trực tuyến! (có thể kiểm tra; chiều dài đầu vào 3, chiều dài đầu ra 18)

Làm thế nào nó hoạt động

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, Độ dài 42, điểm 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

Hãy thử trực tuyến!

Phép lịch sự của Bubbler

Mã bị đánh cắp:

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

Vì các cách tiếp cận khác có vẻ không hiệu quả, tôi đã cố gắng thực hiện một phương pháp tối ưu thời gian. Đó là O (N) trong mã hóa N bit, là tối ưu O lớn.

Gợi ý: hãy thử nghĩ về tam giác của Pascal cho cái này ( sơ đồ này cho thấy nó)

Đầu ra mẫu:

Input:  AAAAAAAA
Output: 000000000000000000000111111111111111111111

Input:  ZZZZZZZZ
Output: 011001000000011010011000111010110110111110

Thời gian thực hiện: <0,013 s (gần như không đổi cho tất cả các đầu vào)

Perl 5 , 55 byte, max diff 0, chiều dài 42, điểm 56 55

Điều này hoạt động nhưng sẽ mất nhiều thời gian nhưng có thể làm được ( ZZZZZZZZmất 2,5 ngày trên máy tính của tôi). Bộ nhớ không có vấn đề.

Sử dụng A-Znhư là đầu vào và 1và Alà nhân vật mã hóa. Chúng luôn được cân bằng hoàn hảo. Bỏ qua các 26^7 = 8031810176kết hợp cân bằng đầu tiên đại diện cho chuỗi ngắn hơn 8 ký tự, nhưng điều đó không sao vì có 538257874440sẵn và tôi sử dụng 208827064575và 208827064575 + 8031810176 < 538257874440.

Tuy nhiên, nó thực sự "tính" đến kết hợp mục tiêu sẽ mất rất nhiều thời gian. Đó là lý do tại sao trong liên kết TIO tôi chỉ sử dụng một chuỗi đầu vào quá ngắn (cũng được hỗ trợ) để chứng minh rằng đầu ra là chính xác. Sẽ hoạt động nhiều hơn một chút so với AAAAAAtrước khi TIO hết thời gian. ZZZZZZZZnên về 26^3 = 17576thời gian chậm hơn.

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

Hãy thử trực tuyến!

Bộ giải mã gần như giống nhau:

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

Hãy thử trực tuyến!

> <> , 75 byte, Max Diff 0, Độ dài 42, điểm 75

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

Hãy thử trực tuyến!

Cảnh báo Hội chợ, điều này sẽ mất rất rất rất nhiều thời gian để hoàn thành ngay cả đối với tầm thường AAAAAAAAnhư vậy. Chạy qua từng biểu diễn nhị phân của một bộ đếm cho đến khi 1đạt đến số nhị phân thứ hai (cơ sở 26 của đầu vào) với 21 giây. Nếu bạn muốn kiểm tra chương trình một chút, bạn có thể thay thế ab+dòng thứ ba 1sẽ trả về số nhị phân thứ n chỉ bằng một lần duy nhất 1, Hãy thử trực tuyến!

Python 3 , 75 byte, Max Diff 0, Độ dài 42, Điểm 112

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

Hãy thử trực tuyến!

Điều này chỉ hoạt động trong lý thuyết vì hạn chế bộ nhớ. Có 538257874440các chuỗi zero-one cân bằng riêng biệt có độ dài 42 và208827064575 các đầu vào có thể, do đó một số đầu ra có thể sẽ không được sử dụng.

-37 byte nhờ @recursive

C ++, 146 Byte, 42 maxlength, 0 mất cân bằng, điểm 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);}

Hoạt động cho bất kỳ 26 char liên tục, nhưng cảnh báo nó chạy một thời gian không thể chấp nhận