การเข้ารหัสทำงานอย่างไร

รับรายการบิต:

• กดค้างไว้ (เริ่มต้นด้วย2)
• มีรายการ
• สำหรับแต่ละบิตในอินพุต
  • หากเป็นเช่นเดียวกับบิตก่อนหน้าให้เพิ่มไพรม์ที่คุณถืออยู่ในรายการ
  • ถ้ามันแตกต่างกันให้ถือนายกตัวถัดไปและเพิ่มเข้าไปในรายการ
• ส่งคืนผลิตภัณฑ์ของตัวเลขทั้งหมดในรายการของคุณ
• สำหรับบิตแรกสมมติว่าบิตก่อนหน้านี้คือ 0

หมายเหตุ: ขั้นตอนเหล่านี้มีวัตถุประสงค์เพื่อประกอบการอธิบายเท่านั้นคุณไม่จำเป็นต้องปฏิบัติตาม

ตัวอย่าง

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

ตัวอย่างเพิ่มเติม:

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

ท้าทาย

เขียนตัวเข้ารหัสและตัวถอดรหัสสำหรับวิธีการเข้ารหัสนี้

(ตัวถอดรหัสย้อนกลับกระบวนการของตัวเข้ารหัส)

อินพุต / เอาต์พุต

• ตัวเข้ารหัสสามารถรับอินพุตในรูปแบบที่เหมาะสม

• ตัวเข้ารหัสจะต้องแสดงผลเป็นจำนวนเต็มหรือสตริง

• ตัวถอดรหัสต้องใช้อินพุตในรูปแบบเดียวกับที่ตัวเข้ารหัสใช้

• ตัวถอดรหัสจะต้องส่งออกในรูปแบบเดียวกับที่ตัวเข้ารหัสใช้เป็นอินพุต

ในคำอื่น ๆ decoder( encoder( input ) ) === input

หมายเหตุ

• ตัวถอดรหัสอาจสมมติว่าอินพุตนั้นสามารถถอดรหัสได้
• คำตอบของคุณเท่านั้นที่มีการจัดการกับเลขที่ภาษาของคุณโดยกำเนิดสามารถรองรับโดยไม่ต้องใช้ ( long, bigIntฯลฯ ) จะเหมาะสมถ้าคุณรองรับเฉพาะภาษา ints ถึง 1 อาจจะพิจารณาการโพสต์คำตอบ

เกณฑ์การให้คะแนน

คะแนนของคุณคือผลรวมของความยาวเป็นไบต์ของตัวเข้ารหัสและตัวถอดรหัส

หากคุณต้องการนำเข้าโมดูลการนำเข้าสามารถนับได้เพียงครั้งเดียวโดยมีเงื่อนไขว่าตัวเข้ารหัสและตัวถอดรหัสของคุณสามารถอยู่ร่วมกันในไฟล์เดียวกันและนำมาใช้ซ้ำ (เช่นฟังก์ชั่น)

ช่องโหว่เริ่มต้นเป็นสิ่งต้องห้าม

นี่คือรหัสกอล์ฟเพื่อให้คะแนนสั้นที่สุดสำหรับทุกภาษาชนะ

05AB1E , 13 ไบต์

ตัวเข้ารหัส 8 ไบต์

0ì¥ĀηOØP

ลองออนไลน์!

คำอธิบาย

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

ถอดรหัส 5 ไบต์

Ò.ØÉJ

ลองออนไลน์!

คำอธิบาย

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

เยลลี่ขนาด 17 ไบต์

ตัวเข้ารหัส (10 ไบต์):

0;IA+\‘ÆNP

ลองออนไลน์!

ถอดรหัส (7 ไบต์):

ÆEĖŒṙḂ¬

ลองออนไลน์!

อย่างไร?

Encoder:

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

ถอดรหัส:

Æ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 ไบต์

I / O:อาร์เรย์ของบิต↔จำนวนเต็ม

ตัวเข้ารหัส 71 ไบต์

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

ลองออนไลน์!

ตัวถอดรหัส 59 ไบต์

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

ลองออนไลน์!

Java 10, 209 ไบต์

ตัวเข้ารหัส 124 ไบต์

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;}

ลองออนไลน์

คำอธิบาย:

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

ถอดรหัสขนาด 85 ไบต์

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;}

ลองออนไลน์

คำอธิบาย:

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 ไบต์

ตัวเข้ารหัส 11 ไบต์

Πmo!İp→∫Ẋ≠Θ

ลองออนไลน์!

ถอดรหัสขนาด 7 ไบต์

mȯ¬%2ṗp

ลองออนไลน์!

พวกเขาทำงานอย่างไร

Encoder:

Πmo! İp→∫Ẋ≠Θ - โปรแกรมเต็มรูปแบบ รับอินพุตจาก CLA แรกส่งออกไปยัง STDOUT
          Θ - เตรียมองค์ประกอบเริ่มต้น (0 ในกรณีนี้)
        Ẋ≠ - แผนที่เหนือคู่ขององค์ประกอบที่อยู่ติดกันด้วย≠ (ไม่เท่ากับ) ในแกลบ
              ผู้ประกอบการบางคนกลับสิ่งที่มีประโยชน์อื่น ๆ กว่าเพียงแค่ค่าบูลีน
              ที่นี่≠ส่งคืนความแตกต่างที่แน่นอนระหว่างอาร์กิวเมนต์สองตัว
       ∫ - ผลรวมสะสม
 mo - แมปฟังก์ชันต่อไปนี้เหนือรายการผลรวม:
    İp - ให้ผลลัพธ์จำนวนอนันต์ของจำนวนเฉพาะ
   ! → - และจัดทำดัชนีโดยเพิ่มผลรวมปัจจุบัน
Π - รับผลิตภัณฑ์

ถอดรหัส:

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 ไบต์

ตัวเข้ารหัส116 101 97 ไบต์:

ใช้ทฤษฎีบทของวิลสัน

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

ลองออนไลน์!

ตัวถอดรหัส118 92 77 ไบต์:

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

ลองออนไลน์!

J , 34 ไบต์

แรงบันดาลใจจากสารละลาย Jelly ของ Jonathan Allan!

ตัวเข้ารหัส: 23 ไบต์

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

ลองออนไลน์!

                    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  

ฉันไม่ชอบส้อมจำนวนมากเหล่านั้น[:- มันควรจะเล่นกอล์ฟได้

ถอดรหัส: 11 ไบต์

2|[:_1&p:q:

ลองออนไลน์!

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

เยลลี่ 15 ไบต์

ตัวเข้ารหัส 9 ไบต์

0;ŒgL€ÆẸH

ลองออนไลน์!

ถอดรหัสขนาด 6 ไบต์

Æf’ÆCḂ

ลองออนไลน์!

C (gcc) , 180 184 ไบต์

• เพิ่มสี่ไบต์เพื่อให้รูปแบบเอาต์พุตตรงกัน

102 ไบต์ - ตัวเข้ารหัส

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;}

ลองออนไลน์!

82 ไบต์ - ถอดรหัส

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;}

ลองออนไลน์!

Gol> <> , 29 + 39 = 68 ไบต์

ตัวเข้ารหัส 29 ไบต์

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

ลองออนไลน์!

ถอดรหัส 39 ไบต์

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

ลองออนไลน์!

วิธีการทำงานเหล่านี้

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

มันจะดีกว่านี้ถ้าฉันสามารถลงสนามลูปต่อไป