मैनचेस्टर एक डेटा स्ट्रीम को एनकोड करता है

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-बिट बाइट्स की एक सरणी है, और यदि आवश्यक हो तो एक लंबाई।
• कम से कम 16KB इनपुट का समर्थन करना चाहिए
• प्रदर्शन बहुत भयानक नहीं होना चाहिए: <10s 16KB के लिए
• स्मृति में पहले से महत्वपूर्ण बाइट।

साइड-चैनल चुनौती :

• अपने कोड को साबित करके किसी अन्य उपयोगकर्ता के जवाब को तेज़, अधिक मेमोरी कुशल, या एक छोटा बाइनरी पैदा करता है!

गोल्फ जाओ! सबसे छोटा कोड जीतता है!

Comments

"आउटपुट के लिए मेमोरी को आपकी दिनचर्या द्वारा आवंटित किया जाना चाहिए, प्रदान नहीं किया गया।" ऐसा लगता है कि काफी अजीब आवश्यकता है क्योंकि कई भाषाओं में पूरी तरह से स्वचालित मेमोरी आवंटन है।

— आआआआआआआआआआआ आआआआआआ आआआआआना

इस तरह के विचित्र सा आदेश का उपयोग करने के लिए पृथ्वी पर आपके पास क्या है?

— पीटर टेलर

जब आप इसके लिए उपयोग किए जाने वाले भौतिक माध्यम पर विचार करते हैं, तो बिट ऑर्डर समझ में आता है; यह एल्गोरिथ्म हवा के माध्यम से यात्रा करने वाले व्यक्तिगत बिट्स की एक धारा के लिए है। तथ्य यह है कि हमें इसे मेमोरी में स्टोर करना है, और हम हेक्स एमएसबी-> एलएसबी लिखते हैं, यह ट्रैक करने के लिए थोड़ा मुश्किल बना देता है।

— मर्मेकन

Answer 1

GolfScript 28 अक्षर

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

अनुकूलन के बिना समतुल्य संस्करण:

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

कोड पूर्णांक के एक सरणी के रूप में इनपुट स्वीकार करते हैं, और ditto वापस करते हैं।

सरणी में प्रत्येक संख्या के लिए संख्या को 2 सरणी रूप में परिवर्तित किया जाता है, फिर इसे वापस संख्या में बदल दिया जाता है जैसे कि यह आधार 4 था, इसमें प्रत्येक के बीच में 0 से बिट्स को बाहर करने का प्रभाव होता है। 43691 को तब संख्या से घटाया जाता है, और परिणाम द्विआधारी उल्टा होता है, यह संख्या 43690 (43690 = 0b10101010101010) से घटने के बराबर है। फिर संख्या को दो भागों में विभाजित करके इसे एक आधार 256 सरणी में बदल दिया जाता है, सरणी विघटित हो जाती है और दो परिणामी संख्याओं का क्रम उल्टा हो जाता है।

उदाहरण इनपुट:

[1 2 3 241 242 243]

उदाहरण आउटपुट:

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

Comments

यह बहुत ही हास्यास्पद है, और बहुत चालाक है! हालांकि यह 10K प्रदर्शन सुझाव में 16KB को पूरा करने के लिए नहीं लगता है, कम से कम मेरे लिए; तुम्हारा 16384 1 के एक सरणी में परिवर्तित करने के लिए मेरे दोहरे कोर मैक पर 43s लेता है। इसकी तुलना में, मेरे बड़े पैमाने पर (2419 चार) अजगर कार्यान्वयन 16KB के लिए 0.06s लेता है।

— mrmekon

मेरी मशीन (विन 7) पर इसे 5 सेकंड से भी कम समय लगता है, और इसमें से अधिकांश सरणी को टेक्स्ट आउटपुट में परिवर्तित कर रहा है, जहां तक ​​मैंने पढ़ा है कि आपका प्रश्न आवश्यकता का हिस्सा नहीं है, लेकिन गोल्फस्क्रिप्ट स्वचालित रूप से कुछ भी छोड़ देता है। निष्पादन के बाद ढेर पर। कोई केवल कोड को प्रिंट करने के बजाय परिणाम को छोड़ सकता है (कोड के अंत में जोड़ें)। यदि आप आउटपुट को देखना चाहते हैं (हालांकि यह प्रश्न चश्मा का हिस्सा नहीं है।) मुझे पता है कि इसे तेज करने के लिए दो तरकीबें हैं, इसे एक फाइल में रीडायरेक्ट करें, और प्रिंट कमांड्स का उपयोग करके इसे छोटे-छोटे विखंडों में स्पष्ट रूप से प्रिंट करें:{2{base}:|~4|43691-~256|~p p}%

— आआआआआआआआआआ

एक ubuntu vm (विंडोज़ पर) में, मुझे 16kb के लिए 8s मिलता है। एक बेहतर सीपीयू के साथ एक मैक पर यह 1m18 लिया। मुझे लगता है कि OSX के साथ जहाजों की तुलना में रूबी सिर्फ बहुत धीमी है

— gnibbler

ऐसा लगता है कि माणिक मुद्रण मेरी मशीन पर घृणित रूप से धीमा है। मुद्रण के साथ केवल 2s बंद और रूबी 1.9 (और देशी OSX संस्करण के साथ 5s)। यह ज़्यादा बेहतर है!

— mrmekon

Answer 2

c - 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) आउटपुट बिट पेयर है, और सब कुछ लाइन में लाने के लिए बहुत सारे शिफ्टिंग और मास्किंग लॉजिक अप्लाई करते हैं।

जैसा कि c का अभ्यस्त है, यह अक्षर के रूप में डेटा पर काम करता है। परीक्षण मचान 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#:~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 से परिवर्तित होता है।

उदाहरण का उपयोग (J, इंटरैक्टिव):

    ,@:(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

गति की जानकारी (J, संवादात्मक):

   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 का माध्य समय सिर्फ .25s, Intel Core Duo 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.2s में 1 एमबी। यह भुगतना पड़ता है क्योंकि इनपुट को सूची से परिवर्तित किया जाता है, बल्कि तब ए के रूप में संसाधित किया जाता है 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-मैनचेस्टर । एक कमांड लाइन फिल्टर के लिए कोड, परीक्षण और मुख्य कार्य शामिल हैं।

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

---

16kb परीक्षण डेटा सेट जनरेटर:

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 i5dual कोर समय परीक्षण:

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

Comments

अच्छी पहली पोस्ट, लेकिन हम आम तौर पर हमारे कोड को बाधित करने की कोशिश नहीं करते हैं। कम हाँ, पढ़ने के लिए मुश्किल नहीं।

— R

Answer 9

PHP, 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 KiB डेटा और लगभग 0.9 सेकंड में 1 MiB डेटा एनकोड करता है।

जीगोब पर मेरे कोड-गोल्फ सॉल्यूशन पेज पर अनगॉल्ड कोड, एक और कार्यान्वयन (अब और लगभग दो बार धीमा) और परीक्षण के मामले मिल सकते हैं ।