ম্যানচেস্টার একটি ডেটা স্ট্রিম এনকোড করে

Question

ম্যানচেস্টার কোডিং এমন একটি টেলিকম প্রোটোকল যা রেডিও যোগাযোগগুলিতে ব্যবহৃত হয় যা নিয়মিত বিরতিতে বিট ট্রানজিশনের গ্যারান্টি দেয় যাতে কোনও রিসিভার ডেটা থেকে ঘড়ির হার পুনরুদ্ধার করতে পারে। এটি বিটরেট দ্বিগুণ হয় তবে এটি কার্যকর এবং কার্যকর কার্যকর। এটি অপেশাদার রেডিও অপারেটরগুলি দ্বারা ব্যাপকভাবে ব্যবহৃত হয়।

ধারণাটি খুব সহজ: একটি হার্ডওয়্যার স্তরে, ঘড়ি এবং ডেটা লাইনগুলি কেবল একসাথে XORed হয়। সফ্টওয়্যারটিতে, এটি বিটগুলির ইনপুট প্রবাহকে ডাবল-রেট আউটপুট প্রবাহে রূপান্তর হিসাবে চিত্রিত করা হয়, প্রতিটি ইনপুট '1' কে '01' তে অনুবাদ করা হয় এবং প্রতিটি ইনপুট '0' '10' তে অনুবাদ করা হয়।

এটি একটি সহজ সমস্যা তবে এর বিটস্ট্রিম প্রকৃতির কারণে এটি প্রচুর বাস্তবায়নের জন্য উন্মুক্ত। অর্থাৎ এনকোডিংটি বাইট-বাই-বাইট প্রক্রিয়াটির পরিবর্তে ধারণাগতভাবে কিছুটা বাই-বিট প্রক্রিয়া। সুতরাং আমরা সকলেই এডিয়েননেসে একমত, ইনপুটটির কমপক্ষে উল্লেখযোগ্য বিটগুলি আউটপুটটির সর্বনিম্ন উল্লেখযোগ্য বাইট হয়ে যায়।

গল্ফিংয়ের সময়! একটি ফাংশন লিখুন যা বাইটগুলির একটি স্বেচ্ছাসেবী দৈর্ঘ্যের অ্যারে দেওয়া, ম্যানচেস্টার এনকোড করা সেই ডেটার একটি অ্যারে প্রদান করে।

ইনপুট এবং আউটপুটটিকে ছোট-এন্ডিয়ান হিসাবে বিবেচনা করা উচিত, প্রথমে কমপক্ষে উল্লেখযোগ্য বাইট এবং বিট স্ট্রিমের মধ্যে প্রথমে কমপক্ষে উল্লেখযোগ্য বিআইটি।

ASCII বিটস্ট্রিম অঙ্কন :

bit #      5 4 3 2 1 0                                5  4  3  2  1  0
IN ------- 1 0 1 0 1 1 ---> [manchester encoder] ---  01 10 01 10 01 01 ----> OUT

উদাহরণ :

Example 1 (hex):
       LSB              MSB     <-- least sig BYTE first
IN : [0x10, 0x02]  
OUT: [0xAA, 0xA9, 0xA6, 0xAA]  

Example 1 (binary):
      msb  lsb                      msb  lsb  <-- translated hex, so msb first
BIN: [00010000, 00000010]                     <-- least sig NIBBLE...
BIN: [10101010, 10101001, 10100110, 10101010] <-- becomes least sig BYTE
         LSB                           MSB

Example 2
IN :  [0xFF, 0x00, 0xAA, 0x55]  
OUT: [0x55, 0x55, 0xAA, 0xAA, 0x66, 0x66, 0x99, 0x99]

Example 3
IN : [0x12, 0x34, 0x56, 0x78, 0x90]  
OUT: [0xA6, 0xA9, 0x9A, 0xA5, 0x96, 0x99, 0x6A, 0x95, 0xAA, 0x69] 

Example 4
IN : [0x01, 0x02, 0x03, 0xF1, 0xF2, 0xF3]  
OUT: [0xA9, 0xAA, 0xA6, 0xAA, 0xA5, 0xAA, 0xA9, 0x55, 0xA6, 0x55, 0xA5, 0x55]

বিধি :

• সমাধানের জন্য আউটপুটকে ইনপুট রূপান্তর করতে শুধুমাত্র অ্যালগরিদম প্রয়োজন।
• ইনপুট এবং মুদ্রণ আউটপুট অর্জন সমাধানের প্রয়োজনীয় অংশ নয়, তবে এটি অন্তর্ভুক্ত থাকতে পারে। আপনার সমাধানটিতে অন্তর্ভুক্ত না করা থাকলে আপনি আপনার পরীক্ষা / প্রিন্ট কোড সরবরাহ করতে উত্সাহিত হন।
• ইনপুটটি 8-বিট বাইটের একটি অ্যারে (আপনার পছন্দের ভাষায় যা কিছু বোঝাতে পারে), কোনও পাঠ্য স্ট্রিং নয়। আপনার ভাষায় সুবিধাজনক হলে আপনি স্ট্রিং ফর্ম্যাট হিসাবে স্ট্রিং ব্যবহার করতে পারেন তবে মুদ্রণযোগ্য অক্ষরগুলি (অর্থাত্ 0xFF) সমর্থন করা আবশ্যক। প্রয়োজনে ইনপুটও একটি দৈর্ঘ্য নিতে পারে।
• আউটপুট জন্য মেমরি আপনার রুটিন দ্বারা বরাদ্দ করা আবশ্যক, সরবরাহ করা হয় না। সম্পাদনা: অপ্রয়োজনীয় প্রয়োজন
• আউটপুট 8-বিট বাইটের একটি অ্যারে এবং প্রয়োজনে দৈর্ঘ্যও।
• কমপক্ষে 16 কেবি ইনপুট সমর্থন করা উচিত
• পারফরম্যান্স খুব ভয়ঙ্কর হওয়া উচিত নয়: <16sB এর জন্য 10 গুলি
• সর্বনিম্ন-উল্লেখযোগ্য বাইট মেমরিতে প্রথম।

পার্শ্ব-চ্যানেল চ্যালেঞ্জ :

• আপনার কোডটি দ্রুত, আরও মেমরি দক্ষ, বা একটি ছোট বাইনারি উত্পাদন করে অন্য ব্যবহারকারীর জবাব চ্যালেঞ্জ করুন!

গল্ফিং পান! সবচেয়ে কম কোড জয়!

Comments

"আউটপুট জন্য মেমরি আপনার রুটিন দ্বারা বরাদ্দ করা আবশ্যক, সরবরাহ করা হয় না।" এটি বেশ অদ্ভুত প্রয়োজন বলে মনে হচ্ছে যেহেতু অনেক ভাষার সম্পূর্ণ স্বয়ংক্রিয়ভাবে মেমরির বরাদ্দ রয়েছে alloc

— আআআআআআআআআআআআআআআআআআ

পৃথিবীতে কী এমন উদ্ভট বিট অর্ডার ব্যবহার করতে পেরেছিল?

— পিটার টেলর

বিট অর্ডারটি যখন আপনি যে শারীরিক মাধ্যমটির জন্য ব্যবহৃত হয় তা বিবেচনা করে; এই অ্যালগরিদমটি বায়ু দিয়ে ভ্রমণকারী বিটগুলির একটি স্ট্রিমের জন্য। আমাদের এটিকে স্মৃতিতে সঞ্চয় করতে হবে এবং আমরা হেক্স এমএসবি-> এলএসবি লিখি তা ট্র্যাক করে রাখা কিছুটা জটিল করে তোলে।

— মির্মেকন

Answer 1

গল্ফস্ক্রিপ্ট ২৮ টি অক্ষর

{2{base}:|~4|43691-~256|~\}%

অপ্টিমাইজেশন অবলম্বন না করে সমতুল্য সংস্করণ:

{2base 4base 43691-~256base~\}%

কোডটি পূর্ণসংখ্যার অ্যারের হিসাবে ইনপুট গ্রহণ করে এবং ডিটো ফিরিয়ে দেয়।

অ্যারেতে প্রতিটি সংখ্যার জন্য সংখ্যাটি বেস 2 অ্যারে রূপে রূপান্তরিত হয়, এটি আবার কোনও সংখ্যায় ফিরে রূপান্তরিত হয় যেমন এটি বেস 4 হয়, এটি প্রতিটিটির মধ্যে 0 দিয়ে বিট ফাঁকা করার প্রভাব রাখে। 43691 এর পরে সংখ্যা থেকে বিয়োগ করা হয় এবং ফলাফলটি বাইনারি উল্টানো হয়, এটি 43690 (43690 = 0b10101010101010) থেকে সংখ্যাটি বিয়োগের সমতুল্য। এর পরে সংখ্যাটি 256 অ্যারেতে রূপান্তর করে দুটি ভাগে বিভক্ত করা হয়, অ্যারেটি পচে যায় এবং দুটি ফলাফলের ক্রমটি উল্টে যায় ver

উদাহরণ ইনপুট:

[1 2 3 241 242 243]

উদাহরণ আউটপুট:

[169 170 166 170 165 170 169 85 166 85 165 85]

Comments

এটি হাস্যকরভাবে সংক্ষিপ্ত, এবং খুব চালাক! যদিও এটি <10s পারফরম্যান্স পরামর্শে 16 কেবি পূরণ করছে বলে মনে হচ্ছে না, কমপক্ষে আমার জন্য; আপনার 16384 1 এর অ্যারে রূপান্তর করতে আমার ডুয়াল-কোর ম্যাকের উপরে 43 সেকেন্ড লাগে। তুলনায়, আমার বিশাল (2419 চর) অজগর বাস্তবায়ন 16KB এর জন্য 0.06s সময় নেয়।

— শ্রীমেকন

এটি আমার মেশিনে 5 সেকেন্ডেরও কম সময় নেয় (উইন 7), এবং এর বেশিরভাগটি অ্যারেটিকে টেক্সট আউটপুটে রূপান্তরিত করে, যা আমি আপনার প্রশ্নটি পড়েছি প্রয়োজনের অংশ নয়, তবে গল্ফস্ক্রিপ্ট কিছু বাদ দিয়ে স্বয়ংক্রিয়ভাবে করে ফেলে মৃত্যুদন্ড কার্যকর করার পরে স্ট্যাকের উপর। কোডটি প্রিন্টের পরিবর্তে কোডটি সহজেই ফলাফল ফেলে দিতে পারে (কোডের শেষে যুক্ত করুন)। আপনি যদি আউটপুটটি দেখতে চান (যদিও এটি প্রশ্ন ছদ্মবেশের অংশ নয়) আমি এটির গতি বাড়ানোর জন্য দুটি কৌশল জানি, এটি কোনও ফাইলে পুনর্নির্দেশ করুন এবং মুদ্রণ কমান্ডগুলি ব্যবহার করে এটি স্পষ্টভাবে ছোট খণ্ডে মুদ্রণ করুন:{2{base}:|~4|43691-~256|~p p}%

— আআআআআআআআআআআআআআআ

একটি উবুন্টু ভিএম (উইন্ডোজে) এ, আমি 16 কেবি এর জন্য 8 এস পাই। আরও ভাল সিপিইউ সহ একটি ম্যাকে এটি 1 মি 18 লেগেছিল। আমি অনুমান করতে চাই যে

— ওএসএক্সের

দেখে মনে হচ্ছে রুবি মুদ্রণটি আমার মেশিনে বিরক্তিকরভাবে ধীরে ধীরে চলছে। মুদ্রণ সহ কেবল 2s বন্ধ রয়েছে এবং রুবি 1.9 (এবং দেশীয় ওএসএক্স সংস্করণ সহ 5 এস)। এটা অধিকতর ভালো!

— mrmekon

Answer 2

সি - 224 টি অক্ষর

আমি বিশ্বাস করি যে বাদ পড়েছে মেমরির প্রয়োজনীয়তার বরাদ্দ সহ এটি কার্যকরী।

#include <stdlib.h>
int B(char i){int16_t n,o=0xFFFF;for(n=0;n<8;++n)o^=((((i>>n)&1)+1))<<(2*n);
return o;}char* M(char*i,int n){char*o=calloc(n+1,2),*p=o;do{int r=B(*i++);
*p++=0xFF&r;*p++=(0xFF00&r)>>8;}while(--n);return o;}

কোডের কার্যকারী অংশটি প্রতিটি চরিত্রের বিটের উপরে একটি লুপ, উল্লেখ করে ((বিট + 1) একচেটিয়া-বা 3) আউটপুট বিট পেয়ার, এবং সমস্ত কিছু সীমাবদ্ধ করার জন্য প্রচুর স্থানান্তর এবং মাস্কিং যুক্তি প্রয়োগ করে।

সি এর অভ্যাস হিসাবে এটি চরিত্র হিসাবে ডেটাতে কাজ করে। পরীক্ষার স্কোফোল্ড 0 বাইট গ্রহণ করবে না (কারণ গ তাদের সাথে স্ট্রিং শেষ হিসাবে গণ্য করে) তবে ওয়ার্কিং কোডের তেমন কোনও সীমাবদ্ধতা নেই।

বাইট রূপান্তর কাজের ইনলাইন অনুলিপি করে এটি আরও কিছুটা গল্ফ হতে পারে।

টেস্ট রান (উন্নত পরীক্ষার স্কোফোল্ড সহ):

$ gcc -g manchester_golf.c
$ ./a.out AB xyz U
'AB':
[ 0x41, 0x42 ]
[ 0xa9, 0x9a, 0xa6, 0x9a ]
'xyz':
[ 0x78, 0x79, 0x7a ]
[ 0x6a, 0x95, 0x69, 0x95, 0x66, 0x95 ]
'U':
[ 0x55 ]
[ 0x99, 0x99 ]

মন্তব্য করা হয়েছে, কম মেশিন নির্ভর, এবং পরীক্ষার স্কোফোল্ড সহ

/* manchester.c
 *
 * Manchester code a bit stream least significant bit first
 *
 * Manchester coding means that bits are expanded as {0,1} --> {10, 01}
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdint.h>
#include <string.h>

/* Caller must insure that out points to a valid, writable two byte
   buffer filled with 0xFF */
int16_t manByte(char i){
  int16_t n,o=0xFFFF;
  printf("Manchester coding byte 0x%hx...\n",i);
  for(n=0; n<CHAR_BIT; ++n)
    o ^= (
      (
       (
        (i>>n)&1) /* nth bit of i*/
       +1) /* +1 */
      ) <<(2*n) /* shifted up 2*n bits */ 
      ;
  printf("\tas 0x%hx\n",o);
  return o;
}

char* manBuf(const char*i, int n){
  char*o=calloc(n+1,2),*p=o;
  do{
    int16_t r=manByte(*i++);
    *p++= 0xFF&r;
    *p++=(0xFF00&r)>>8;
  } while(--n);
  return o;
}

void pbuf(FILE* f, char *buf, int len){
  int i;
  fprintf(f,"[");
  for(i=0; i<len-1; i++)
    fprintf(f," 0x%hhx,",buf[i]);
  fprintf(f," 0x%hhx ]\n",buf[len-1]);
}

int main(int argc, char**argv){
  int i;
  for(i=1; i<argc; i++){
    int l=strlen(argv[i]);
    char *o=manBuf(argv[i],l);
    printf("'%s':\n",argv[i]);
    pbuf(stdout,argv[i],l);
    pbuf(stdout,o,l*2);
    free(o);
  }
  return 0;
}

Answer 3

জে, 36

,@:(3 :'#.2 8$,(,.~-.)4|.y#:~8#2'"0)

ব্যাখ্যার বাহ্যরেখা ( রেফারেন্সের জন্য জে শব্দভাণ্ডার দেখুন ):

• ,@:(3 :'...'"0)প্রতিটি ইনপুট "বাইট" y হিসাবে y হিসাবে প্রয়োগ করে, যার ফলে দুটি করে বাইট (পূর্ণসংখ্যা) হয়। ফলাফল দ্বারা সমতল হয় ,।
• y#:~8#22 2 2 2 2 2 2 2 #: yy এর 8 টি কমপক্ষে উল্লেখযোগ্য বেস -2 সংখ্যার সমান , বা ভেক্টর।
• 4|. 4 পজিশনে ঘোরাফেরা করে সামনে এবং পিছনে 4 বিট অদলবদল করে।
• (,.~-.)3 :'(-. y) ,. y'আর্গুমেন্টের সাথে 'সেলাই করা' আর্গুমেন্টের সমতুল্য বা না (8 2 আকার ধারণ করে)।
• #.2 8$, বিট স্ট্রিম প্রদানের ফলকে সমতল করে, 8 টির 2 টি সারিতে পুনরায় আকার দেয় এবং বেস 2 থেকে রূপান্তর করে।

ব্যবহারের উদাহরণ (জে, ইন্টারেক্টিভ):

    ,@:(3 :'#.2 8$,(,.~-.)4|.y#:~8#2'"0) 1 2 3 241 242 243
,@:(3 :'#.2 8$,(,.~-.)4|.y#:~8#2'"0) 1 2 3 241 242 243
169 170 166 170 165 170 169 85 166 85 165 85

গতির তথ্য (জে, ইন্টারেক্টিভ):

   manchester =: ,@:(3 :'#.2 8$,(,.~-.)4|.y#:~8#2'"0)
manchester =: ,@:(3 :'#.2 8$,(,.~-.)4|.y#:~8#2'"0)
   data =: 256 | i. 16384
data =: 256 | i. 16384
   100 (6!:2) 'manchester data'
100 (6!:2) 'manchester data'
0.243138

16kb এর গড় সময়টি কেবলমাত্র 25 সেকেন্ডের অধীনে, ইন্টেল কোর ডুও 1.83Ghz বা এর অনুরূপ।

Answer 4

হাস্কেল, 76 টি অক্ষর

import Bits
z a=170-sum[a.&.p*p|p<-[1,2,4,8]]
y a=[z a,z$a`div`16]
m=(>>=y)

টেস্ট রান:

> testAll 
input      [10, 02]
encoded    [AA, A9, A6, AA]
  pass
input      [FF, 00, AA, 55]
encoded    [55, 55, AA, AA, 66, 66, 99, 99]
  pass
input      [12, 34, 56, 78, 90]
encoded    [A6, A9, 9A, A5, 96, 99, 6A, 95, AA, 69]
  pass
input      [01, 02, 03, F1, F2, F3]
encoded    [A9, AA, A6, AA, A5, AA, A9, 55, A6, 55, A5, 55]
  pass

পারফরম্যান্স অনুমান মধ্যে ভাল। আমার পুরানো ল্যাপটপটিতে 1 এমবিতে 1.2 ডলারে। এটি ক্ষতিগ্রস্থ হয় কারণ ইনপুটটি তালিকাতে এবং কোনও তালিকায় রূপান্তরিত হয়, তারপরে এটি হিসাবে প্রক্রিয়াজাত হয় ByteArray।

> dd bs=1m count=1 if=/dev/urandom | time ./2040-Manchester > /dev/null
1+0 records in
1+0 records out
1048576 bytes transferred in 1.339130 secs (783028 bytes/sec)
        1.20 real         1.18 user         0.01 sys

উৎস, 2040-Manchester.hs , কোড, পরীক্ষার, এবং একটি কমান্ড লাইন ফিল্টারের জন্য প্রধান ফাংশন অন্তর্ভুক্ত করা হয়েছে।

Answer 5

OCaml + ব্যাটারি, 138 117 টি অক্ষর

let m s=Char.(String.(of_enum[?chr(170-Enum.sum[?d land
p*p|p<-List:[1;2;4;8]?])|c<-enum s/@code;d<-List:[c;c/16]?]))

পরীক্ষা:

সঙ্গে

let hex s = String.(enum s/@(Char.code|-Printf.sprintf "%02x")|>List.of_enum|>join" ")

ফলাফলগুলি হ'ল:

m "\x12\x34\x56\x78\x90" |> hex;;
- : string = "a6 a9 9a a5 96 99 6a 95 aa 69"
m "\x10\x02" |> hex;;
- : string = "aa a9 a6 aa"
m "\xFF\x00\xAA\x55" |> hex;;
- : string = "55 55 aa aa 66 66 99 99"
m "\x12\x34\x56\x78\x90" |> hex;;
- : string = "a6 a9 9a a5 96 99 6a 95 aa 69"
m "\x01\x02\x03\xF1\xF2\xF3" |> hex;;  
- : string = "a9 aa a6 aa a5 aa a9 55 a6 55 a5 55"

একটি মানদণ্ড হিসাবে, এর সাথে:

let benchmark n =
  let t = Unix.gettimeofday() in
  assert(2*n == String.(length (m (create n))));
  Unix.gettimeofday() -. t

আমি পাই:

# benchmark 16_384;;
- : float = 0.115520954132080078

আমার ম্যাকবুক এ

Answer 6

পাইথন, 87 টি অক্ষর

Mসমস্যাটি অনুরোধ করা ফাংশন হয়। এটি Nপ্রতিটি বাচ্চাদের জন্য কল করে এবং সমস্ত কিছুকে তালিকায় ফিরিয়ে দেয়।

N=lambda x:170-(x&1|x*2&4|x*4&16|x*8&64)
M=lambda A:sum([[N(a),N(a>>4)]for a in A],[])

print map(hex,M([0x10,0x02]))
print map(hex,M([0xff,0x00,0xaa,0x55]))
print map(hex,M([0x12, 0x34, 0x56, 0x78, 0x90]))
print map(hex,M([0x01, 0x02, 0x03, 0xF1, 0xF2, 0xF3]))

উত্পন্ন

['0xaa', '0xa9', '0xa6', '0xaa']
['0x55', '0x55', '0xaa', '0xaa', '0x66', '0x66', '0x99', '0x99']
['0xa6', '0xa9', '0x9a', '0xa5', '0x96', '0x99', '0x6a', '0x95', '0xaa', '0x69']
['0xa9', '0xaa', '0xa6', '0xaa', '0xa5', '0xaa', '0xa9', '0x55', '0xa6', '0x55', '0xa5', '0x55']

Answer 7

এপিএল (ডায়ালগ প্রসারিত) , 22 বাইট

∊(⌽(2⍴256)⊤43690-4⊥⊤)¨

এটি অনলাইন চেষ্টা করুন!

গল্ফস্ক্রিপ্ট উত্তর পোর্ট।

∊(⌽(2⍴256)⊤43690-4⊥⊤)¨       Monadic train:
  ⌽(2⍴256)⊤43690-4⊥⊤         Define a helper function taking an integer n:
                    ⊤           Convert n to base 2. Monadic ⊤ is an Extended feature.
                  4⊥            Convert the result from base 4.
                                This puts the 1 digits of n 
                                in odd indices of the intermediate result.
            43960-              Subtract from 43690.
    (2⍴256)⊤                    Convert to 2 base-256 digits, corresponding to
                                nibbles of n.
  ⌽                            Reverse the order of these bytes.
 (                   )¨       Call the helper function for each element of the input
∊                             and flatten the results into a list.

Answer 8

সি, 164 বাইট

হেক্স বাইটের একটি সিরিজ নেয় এবং ম্যানচেস্টার বাইনারি স্ট্রিমে রূপান্তর করে।

#include <stdio.h>
main(int c,char **v){int i,b,x,j=0;while(++j<c{sscanf(v[j],"%x",&b);x=b^0xff;for(i=9;--i;){printf("%d%d",x&1,b&1);x=x>>1;b=b>>1;}printf("\n");}}

---

#include <stdio.h>
main(int c,char **v){
int i,b,x,j=0;
while(++j<c){
    sscanf(v[j],"%x",&b);
    x=b^0xff;
    for(i=9;--i;){
        printf("%d%d",x&1,b&1);
        x=x>>1;b=b>>1;}
    printf("\n");}}

---

টেস্ট:

./a.out 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0

আউটপুট:

1010101010101010
0110101010101010
1001101010101010
0101101010101010
1010011010101010
0110011010101010
1001011010101010
0101011010101010
1010100110101010
0110100110101010
1001100110101010
0101100110101010
1010010110101010
0110010110101010
1001010110101010
0101010110101010
1010101010101010
1010101001101010
1010101010011010
1010101001011010
1010101010100110
1010101001100110
1010101010010110
1010101001010110
1010101010101001
1010101001101001
1010101010011001
1010101001011001
1010101010100101
1010101001100101
1010101010010101
1010101001010101

---

16 কেবি পরীক্ষার ডেটা সেট জেনারেটর:

test_data.c:

#include <stdio.h>
void main()
{
int i=16*1024;
while(i--)
{
    printf("0x%02x ", i&0xFF);
}
printf("\n");
}

---

cc test_data.c -o test_data

1.6G আই 5 ডুয়াল কোর টাইম ট্রায়াল:

time ./a.out `./test_data` > test.out 
real    0m0.096s
user    0m0.090s
sys 0m0.011s

Comments

প্রথম প্রথম পোস্ট, কিন্তু আমরা সাধারণত আমাদের কোড অবলম্বন করার চেষ্টা করি না। সংক্ষিপ্ত হ্যাঁ, না পড়ার পক্ষে আরও কঠিন।

— আর

Answer 9

পিএইচপি, 156 বাইট

function f($i){foreach($i as$n){$b=str_split(str_replace([0,1,2],[2,'01',10],
str_pad(decbin($n),8,0,0)),8);$o[]=bindec($b[1]);$o[]=bindec($b[0]);}return$o;}

ইনপুট দেওয়া হয়েছে [0, 1, 2, 3, 4, 5], এটি ফিরে আসে:

[170, 170, 169, 170, 166, 170, 165, 170, 154, 170, 153, 170]

এটি 0.015 সেকেন্ডের মধ্যে 16 কিবি ডেটা এবং প্রায় 0.9 সেকেন্ডের মধ্যে 1 এমআইবি ডেটা এনকোড করে।

অবহেলিত কোড, অন্য একটি বাস্তবায়ন (দীর্ঘ এবং প্রায় দ্বিগুণ ধীর) এবং পরীক্ষার কেসগুলি গিথুবের আমার কোড-গল্ফ সমাধান পৃষ্ঠায় পাওয়া যাবে ।