Cách mã hóa hoạt động

Đưa ra một danh sách các bit:

• Giữ một số nguyên tố (bắt đầu bằng 2)
• Có một danh sách
• Đối với mỗi bit trong đầu vào
  • Nếu nó giống với bit trước đó, hãy thêm số nguyên tố bạn đang giữ vào danh sách
  • Nếu nó khác, giữ nguyên tố tiếp theo và thêm nó vào danh sách
• Trả lại sản phẩm của tất cả các số trong danh sách của bạn
• Đối với bit đầu tiên, giả sử bit trước đó là 0

Lưu ý: các bước này chỉ nhằm mục đích minh họa, bạn không bắt buộc phải tuân theo chúng.

Ví dụ

Input: 001
hold 2

0:         add 2 to the list
0:         add 2 to the list
1: hold 3, add 3 to the list

list: 2,2,3
Output: 12

Input: 1101
hold 2

1: hold 3, add 3 to the list
1:         add 3 to the list
0: hold 5, add 5 to the list
1: hold 7, add 7 to the list

list: 3,3,5,7
Output: 315

Một số ví dụ khác:

000000000 -> 512
111111111 -> 19683
010101010 -> 223092870
101010101 -> 3234846615
011101101 -> 1891890
000101101010010000 -> 3847834029582062520

Thử thách

Viết một bộ mã hóa và bộ giải mã cho phương thức mã hóa này.

(Bộ giải mã đảo ngược quá trình của bộ mã hóa).

Đầu ra đầu vào

• Bộ mã hóa có thể lấy đầu vào ở bất kỳ định dạng hợp lý nào

• Bộ mã hóa phải xuất ra một số nguyên hoặc một chuỗi

• Bộ giải mã phải nhận đầu vào theo cùng định dạng mà bộ mã hóa mở ra

• Bộ giải mã phải xuất định dạng giống như bộ mã hóa làm đầu vào

Nói cách khác decoder( encoder( input ) ) === input

Ghi chú

• Bộ giải mã có thể cho rằng đầu vào của nó có thể giải mã được
• Câu trả lời của bạn chỉ có để đối phó với các số nguyên mà ngôn ngữ của bạn natively có thể hỗ trợ mà không sử dụng ( long, bigInt, vv), là hợp lý, nếu bạn ngôn ngữ duy nhất hỗ trợ ints lên đến 1, có thể xem xét lại đăng câu trả lời

Chấm điểm

Điểm của bạn là tổng độ dài tính bằng byte của bộ mã hóa và bộ giải mã.

Nếu bạn cần nhập một mô-đun, việc nhập chỉ có thể được tính một lần với điều kiện là bộ mã hóa và bộ giải mã của bạn có thể cùng tồn tại trong cùng một tệp và được sử dụng lại (như các hàm).

Lỗ hổng mặc định bị cấm.

Đây là môn đánh gôn, vì vậy điểm số ngắn nhất cho mọi ngôn ngữ sẽ chiến thắng.

05AB1E , 13 byte

Bộ mã hóa, 8 byte

0ì¥ĀηOØP

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

Giải trình

0ì          # prepend 0 to input
  ¥         # calculate deltas
   Ā        # truthify each
    η       # calculate prefixes
     O      # sum each
      Ø     # get the prime at that index
       P    # product

Bộ giải mã, 5 byte

Ò.ØÉJ

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

Giải trình

Ò       # get prime factors of input
 .Ø     # get their indices among the primes
   É    # check for oddness
    J   # join

Thạch , 17 byte

Bộ mã hóa (10 byte):

0;IA+\‘ÆNP

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

Bộ giải mã (7 byte):

ÆEĖŒṙḂ¬

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

Làm sao?

Mã hoá:

0;IA+\‘ÆNP - Link: list of integers (1s and 0s)  e.g. [1,1,1,1,0]
0;         - prepend a zero                           [0,1,1,1,1,0]
  I        - incremental differences                  [1,0,0,0,-1]
   A       - absolute values                          [1,0,0,0,1]
    +\     - cumulative reduce with addition          [1,1,1,1,2]
      ‘    - increment each of the results            [2,2,2,2,3]
       ÆN  - get the nth prime for each result        [3,3,3,3,5]
         P - product of the list                      405

Bộ giải mã:

ÆEĖŒṙḂ¬ - Link: integer         e.g. 405
ÆE      - prime exponent array       [0,4,1] (representing 2^0*3^4*5^1)
  Ė     - enumerate                  [[1,0],[2,4],[3,1]]
   Œṙ   - run-length decode          [2,2,2,2,3]
     Ḃ  - bit (mod 2)                [0,0,0,0,1]
      ¬ - logical NOT                [1,1,1,1,0]

JavaScript (ES6), 130 byte

Tôi / O: mảng bit ↔ số nguyên

Bộ mã hóa, 71 byte

a=>a.map(p=k=>r*=(g=i=>n%--i?g(i):i<2?n:g(++n))(n+=p^(p=k)),r=1,n=2)&&r

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

Bộ giải mã, 59 byte

D=(n,k=2,x=b=0)=>k>n?[]:n%k?D(n,k+1,1):[b^=x,...D(n/k,k,0)]

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

Java 10, 209 byte

Bộ mã hóa, 124 byte

s->{long p=48,P=2,r=1,n,i;for(int c:s.getBytes()){if(p!=(p=c))for(n=0;n<2;)for(n=++P,i=2;i<n;n=n%i++<1?0:n);r*=P;}return r;}

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

Giải trình:

s->{                // Method with String parameter and long return-type
  long p=48,        //  Previous character, starting at '0'
       P=2,         //  Current prime, starting at 2
       r=1,         //  Result, starting at 1
       n,i;         //  Temp-integers
  for(int c:s.getBytes()){
                    //  Loop over the digits of the input-String as bytes
    if(p!=(p=c))    //   If the current and previous digits are different
      for(n=0;      //    Reset `n` to 0
          n<2;)     //    And loop as long as `n` is still 0 or 1
        for(n=++P,  //     Increase `P` by 1 first with `++P`, and set `n` to this new `P`
            i=2;i<n;n=n%i++<1?0:n);
                    //     Check of the current `n` is a prime
                    //     If it remains the same it's a prime, if it becomes 0 or 1 not
    r*=P;}          //   Multiply the result by the current prime `P`
  return r;}        //  Return the result

Bộ giải mã, 85 byte

n->{var r="";for(long P=2,f=0,i=1;++i<=n;)for(;n%i<1;n/=P=i)r+=i!=P?f^=1:f;return r;}

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

Giải trình:

n->{                // Method with long parameter and String return-type
  var r="";         //  Result-String, starting empty
  for(long P=2,     //  Current prime, starting at 2
      f=0,          //  Flag integer, starting at 0
      i=1;++i<=n;)  //  Loop `i` in the range [2,`n`]
    for(;n%i<1;     //   Inner loop over the prime factors of `n`
        n/=P=i)     //     After every iteration: divide `n` by `i`,
                    //     and set `P` to `i` at the same time
      r+=i!=P?      //    If `i` and `P` are not the same
          f^=1      //     Append the opposite of the flag `f` (0→1; 1→0)
         :          //    Else:
          f;        //     Append the flag `f`
  return r;}        //  Return the result

Husk , 18 byte

Bộ mã hóa, 11 byte

Πmo!İp→∫Ẋ≠Θ

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

Bộ giải mã, 7 byte

mȯ¬%2ṗp

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

Chúng hoạt động như thế nào

Mã hoá:

Πmo! İp → ∫Ẋ ≠ - Chương trình đầy đủ. Lấy đầu vào từ CLA đầu tiên, đầu ra thành STDOUT.
          - Chuẩn bị một phần tử mặc định (0 trong trường hợp này).
        ≠ - Ánh xạ qua các cặp phần tử liền kề với ≠ (không bằng). Ở Husk,
              một số toán tử trả về những thứ hữu ích khác ngoài giá trị boolean.
              Ở đây, ≠ trả về sự khác biệt tuyệt đối giữa hai đối số của nó.
       ∫ - Số tiền tích lũy.
 mo - Ánh xạ hàm sau qua danh sách tổng:
    İp - Mang lại danh sách vô hạn các số nguyên tố.
   ! → - Và lập chỉ mục vào đó với tổng số hiện tại tăng.
Π - Lấy sản phẩm.

Bộ giải mã:

mȯ¬%2ṗp – Full program.
      p – Prime factorization.
mȯ      – Map the following function over the list of factors:
     ṗ    – Retrieve the index in  the list of primes.
   %2     – Modulo 2.
  ¬       – Logical NOT.

Python 2 , 234 193 174 byte

Bộ mã hóa, 116 101 97 byte:

Sử dụng định lý Wilson .

i=input()
P=n=x=r=1
while i:
 P*=n*n;n+=1
 if P%n:t=(i+[x]).index(x);i=i[t:];r*=n**t;x^=1
print r

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

Bộ giải mã, 118 92 77 byte:

i=input()
r=[]
n=x=1
while~-i:
 n+=1;x^=i%n<1
 while i%n<1:r+=x,;i/=n
print r

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

J , 34 byte

Lấy cảm hứng mạnh mẽ từ giải pháp Jelly của Jonathan Allan!

Bộ mã hóa: 23 byte

[:*/[:p:[:+/\2|@-~/\0,]

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

                    0,]  NB. prepend 0 to the input
             2  -~/\     NB. find the differences
              |@         NB. and their absolute values 
        [:+/\            NB. running sums
    [:p:                 NB. n-th prime
[:*/                     NB. product  

Tôi không thích những người nhiều dĩa nắp [:- nó phải được golfable.

Bộ giải mã: 11 byte

2|[:_1&p:q:

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

        q:    NB. prime factorization
  [:_1&p:      NB. find the number of primes smaller than n
2|             NB. modulo 2 

Thạch , 15 byte

Bộ mã hóa, 9 byte

0;ŒgL€ÆẸH

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

Bộ giải mã, 6 byte

Æf’ÆCḂ

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

C (gcc) , 180 184 byte

• Đã thêm bốn byte để các định dạng đầu ra khớp.

102 byte - Bộ mã hóa

p,r,i,m;e(char*_){for(m=0,p=1,i=2;*_;m=*_++-48,p*=i)if(*_-48-m)for(i++,r=2;r<i;i%r++||(r=2,i++));i=p;}

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

82 byte - Bộ giải mã

d(C){for(m=C%2,r=2+m,p=2;C>1;p++)if(C%p<1)p-r&&(m=!m,r=p),putchar(m+48),C/=p,p=1;}

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

Gol> <> , 29 + 39 = 68 byte

Bộ mã hóa, 29 byte

021IEh{$:}-Q$TP:SP?!t$|1k*3R!

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

Bộ giải mã, 39 byte

02I:MZ;:2k%:z}Q$TP:SP?!t$|1k,{{-z:N}3R!

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

Chúng hoạt động như thế nào

Encoder

021IEh{$:}-Q$TP:SP?!t$|1k*3R!

021                            Setup the stack as [last bit, current prime, current output]
   IEh                         Take input as int; if EOF, print top as number and halt
      {$:}-Q          |        If the next bit is different from the last bit...
            $                    Move the prime to the top
             T      t            Loop indefinitely...
              P:SP?!               Increment; if prime, skip `t` i.e. break
                     $           Move the prime to the correct position
                       1k*     Multiply the prime to the output
                          3R!  Skip 3 next commands (the init part)
                               Loop the entire program until EOF

---

Decoder

02I:MZ;:2k%:z}Q$TP:SP?!t$|1k,{{-z:N}3R!

02I                  Setup the stack as [last bit, current prime, encoded]
   :MZ;              If encoded == 1, halt
       :2k%          Compute encoded modulo prime
           :z}       Store NOT of the last at the bottom of the stack
              Q...|  Same as encoder's next-prime loop
1k,                  Divide encoded by prime (assume it is divisible)
   {{                Pull out the two bits at the bottom
     -z              Compute the next bit
       :N}           Print as number with newline, and move to the bottom
          3R!        Skip 3 init commands
                     Loop the entire program until finished

Sẽ tốt hơn nếu tôi có thể chơi gôn ở vòng lặp tiếp theo ...