हैमिंग (7,4) का उपयोग करके सही त्रुटियां

19

हेमिंग (7,4) कोड 1950 तक वापस चला जाता है। इसके बाद रिचर्ड हैमिंग ने बेल लैब्स में गणितज्ञ के रूप में काम किया। हर शुक्रवार को हैमिंग ने गणना की एक श्रृंखला करने के लिए गणना मशीनों को सेट किया, और अगले सोमवार को परिणाम एकत्र किए। समता जांच का उपयोग करते हुए, ये मशीनें गणना के दौरान त्रुटियों का पता लगाने में सक्षम थीं। निराश, क्योंकि उन्हें अक्सर त्रुटि संदेश प्राप्त हुआ, हेमिंग ने त्रुटि का पता लगाने में सुधार करने का फैसला किया और प्रसिद्ध हैमिंग कोड की खोज की।

हेमिंग के यांत्रिकी (7,4)

हैमिंग कोड का लक्ष्य समता बिट्स का एक सेट बनाना है जो एक डेटा बिट में एक एकल-बिट त्रुटि (एक बिट फ़्लिप) को ओवरलैप करता है या एक समता बिट का पता लगाया और ठीक किया जा सकता है। केवल अगर कई त्रुटियां होती हैं, तो हेमिंग कोड मूल डेटा को पुनर्प्राप्त करने में विफल रहता है। यह एक त्रुटि को बिल्कुल भी नोटिस नहीं कर सकता है, या इसे गलत तरीके से भी सही कर सकता है। इसलिए इस चुनौती में हम केवल एकल-बिट त्रुटियों से निपटेंगे।

हेमिंग कोड के एक उदाहरण के रूप में, हम हेमिंग (7,4) कोड को देखेंगे। इसके अतिरिक्त 4 बिट डेटा के लिए d1, d2, d3, d4यह 3 समानता बिट्स का उपयोग करता है p1, p2, p3, जिनकी गणना निम्नलिखित समीकरणों का उपयोग करके की जाती है:

p1 = (d1 + d2 + d4) % 2
p2 = (d1 + d3 + d4) % 2
p3 = (d2 + d3 + d4) % 2

परिणामी कोडवर्ड (डेटा + समता बिट्स) फॉर्म का है p1 p2 d1 p3 d2 d3 d4।

त्रुटि का पता लगाना निम्न तरीके से काम करता है। आप समता बिट्स को पुनर्गणना करते हैं, और जांचते हैं कि क्या वे प्राप्त समानता बिट्स से मेल खाते हैं। निम्न तालिका में आप देख सकते हैं, कि एकल-बिट त्रुटि की प्रत्येक विविधता समता बिट्स के एक अलग मिलान का पैदावार देती है। इसलिए हर एक-बिट त्रुटि को स्थानीयकृत और सुधारा जा सकता है।

error in bit | p1 | p2 | d1 | p3 | d2 | d3 | d4 | no error
-------------|---------------------------------------------
p1 matches   | no | yes| no | yes| no | yes| no | yes
p2 matches   | yes| no | no | yes| yes| no | no | yes
p3 matches   | yes| yes| yes| no | no | no | no | yes

उदाहरण

अपना डेटा रहने दो 1011। समता बिट्स हैं p1 = 1 + 0 + 1 = 0, p2 = 1 + 1 + 1 = 1और p3 = 0 + 1 + 1 = 0। डेटा और समता बिट्स को मिलाएं और आपको कोडवर्ड मिलता है 0110011।

data bits   |   1 011
parity bits | 01 0
--------------------
codeword    | 0110011

ट्रांसमिशन या 6 बिट (= 3 डेटा बिट) की गणना के दौरान देता है। आप शब्द प्राप्त करते हैं 0110001। कथित तौर पर प्राप्त डेटा है 1001। आप समता बिट फिर से गणना p1 = 1 + 0 + 1 = 0, p2 = 1 + 0 + 1 = 0, p3 = 0 + 0 + 1 = 1। केवल p1कोडवर्ड की समता बिट्स से मेल खाता है 0110001। इसलिए एक त्रुटि हुई। उपरोक्त तालिका को देखते हुए, हमें बताता है कि त्रुटि हुई d3और आप मूल डेटा को पुनर्प्राप्त कर सकते हैं 1011।

चुनौती:

एक फ़ंक्शन या प्रोग्राम लिखें, जो एक शब्द (7 बिट्स) प्राप्त करता है, बिट्स में से एक गलत हो सकता है, और मूल डेटा को पुनर्प्राप्त कर सकता है। इनपुट (STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन तर्क के माध्यम से) प्रारूप एक स्ट्रिंग "0110001", एक सूची या एक सरणी [0, 1, 1, 0, 0, 0, 1]या MSB में पूर्णांक हो सकता है 0b0110001 = 49। जैसा कि ऊपर वर्णित है, इनपुट का क्रम है p1 p2 d1 p3 d2 d3 d4। आउटपुट (रिटर्न वैल्यू या STDOUT के माध्यम से) एक ही प्रारूप का होना चाहिए, लेकिन क्रम में d1 d2 d3 d4। केवल 4 डेटा बिट्स वापस / आउटपुट।

यह कोड-गोल्फ है। इसलिए सबसे छोटा कोड जीतता है।

परीक्षण के मामलों:

1110000 -> 1000  # no error
1100000 -> 1000  # error at 1st data bit
1111011 -> 1111  # error at 2nd data bit
0110001 -> 1011  # error at 3rd data bit (example)
1011011 -> 1010  # error at 4th data bit
0101001 -> 0001  # error at 1st parity bit
1010000 -> 1000  # error at 2nd parity bit
0100010 -> 0010  # error at 3rd parity bit

कोड स्निपेट दिखाएं

code-golf  error-correction  coding-theory 
— Jakube
स्रोत
1
क्या पहला डेटा बिट के बाद अंतिम समानता बिट दिया जाता है?
— xnor
2
@xnor गणितीय रूप से इससे कोई अंतर नहीं पड़ता है, जिस स्थिति में समता बिट्स हैं। ऐतिहासिक रूप से उन्हें दो की शक्तियों के पदों पर रखा गया है। उदाहरण के लिए आलोचनात्मक (15,11) पदों 1, 2, 4 और 8 में समता बिट है
— Jakube
4
@ xnor यदि आप [is_p3_wrong][is_p2_wrong][is_p1_wrong]आधार दो में लेते हैं तो यह शब्द में गलत बिट की स्थिति देता है। (प्रश्न में तालिका के आधार पर।) यह संभवतः कुछ एल्गोरिदम के लिए उपयोगी होगा।
— यादृच्छिक
बहुत अच्छा :) जब आप लिखते हैं "एक फ़ंक्शन या प्रोग्राम लिखें, जो एक शब्द (7 बिट्स) प्राप्त करता है, तो उनमें से एक गलत हो सकता है, [...]" मुझे लगता है कि आपका मतलब है कि बिट्स में से एक गलत हो सकता है लेकिन आप वास्तव में कहना है कि शब्दों में से एक हो सकता है।
@ लिम्बिक ज़रूर, ने इसे स्पष्ट किया।
— जकुबे

जवाबों:

6

ऑक्टेव, 70 66 55 बाइट्स

यह फ़ंक्शन Fडिकोडिंग मैट्रिक्स की स्थापना कर रहा है H, त्रुटि ढूंढ रहा है और त्रुटि की स्थिति को ठीक कर रहा है (यदि एक है)। फिर यह सही डेटा बिट्स लौटा रहा है। इनपुट एक मानक पंक्ति वेक्टर है।

@ जक्यूब ने सुझाव दिया कि मुझे मतलाब के बजाय ऑक्टेव का उपयोग करना चाहिए जहां आप अभिव्यक्तियों पर सूचकांकों का उपयोग कर सकते हैं, जिससे पूरी बात फिर से 11 बाइट्स छोटी हो जाती है:

F=@(c)xor(c,1:7==bi2de(mod(c*de2bi(1:7,3),2)))([3,5:7])

Matlab में सबसे छोटा समाधान निम्नलिखित है , क्योंकि आप सीधे भावों पर अनुक्रमण का उपयोग नहीं कर सकते हैं। (यह ऑक्टेव में भी काम करता है, निश्चित रूप से।) इसके अलावा / mod2 को बदलने में सक्षम था xor:

f=@(c)c([3,5:7]);F=@(c)f(xor(c,1:7==bi2de(mod(c*de2bi(1:7,3),2))))

पुराना:

f=@(c)c([3,5:7]);F=@(c)f(mod(c+(1:7==bi2de(mod(c*de2bi(1:7,3),2))),2))
— flawr
स्रोत
धन्यवाद, लेकिन यह काम नहीं करता है, दुर्भाग्य से आप केवल इस तरह चर का उपयोग कर सकते हैं ...
— दोष
1
नहीं स्थापित Matlab, मैं केवल इस्तेमाल किया http://octave-online.net/, जहां यह काम करता है। शायद भाषा बदल जाए?
— जक्यूब
ओह, मुझे पहले से ही संदेह था कि ऑक्टेव ऐसा कर सकता है, लेकिन फिर मैं निश्चित रूप से भाषा बदलने जा रहा हूं, बहुत-बहुत धन्यवाद!
— दोष
14

Piet 50x11 = 550

यहाँ छवि विवरण दर्ज करें

कोडेल आकार 15. आकार के बारे में बहुत चिंतित नहीं है, लेकिन यह सभी परीक्षणों को पारित कर दिया।

— captncraig
स्रोत
4
मैं इसके बजाय समस्या का संदर्भ दिया।
1
@ ऑप्टिमाइज़र "कोडेल आकार" अनिवार्य रूप से एक पिएट प्रोग्राम का आवर्धन कारक है। यहाँ, प्रत्येक तार्किक पिक्सेल (या कोडेल) को आसान दृश्यता बनाने के लिए 15x15 ब्लॉक तक विस्तारित किया गया है। यही मेरा मतलब है, न कि "कोड आकार"
— कैप्टनक्रिग
आह ..... मेरी बुर।
— ऑप्टिमाइज़र
8

पायथन, 79

f=lambda x,n=0,e=3:e&~-e and f(x,n+1,(n&8)*14^(n&4)*19^(n&2)*21^n%2*105^x)or~-n

सही पर कम से कम महत्वपूर्ण बिट के साथ संख्याओं के रूप में इनपुट और आउटपुट लें।

त्रुटि पुनर्प्राप्ति का प्रयास करने के बजाय, हम केवल n0 से 15 तक हर संभव संदेश को एन्कोड करने का प्रयास करते हैं जब तक कि हमें एक एन्कोडिंग नहीं मिलती है जो कि दिए गए से एक बिट दूर है। nजब तक यह काम करता है और इसे वापस नहीं करता तब तक पुनरावृत्ति बढ़ती रहती है। हालांकि कोई स्पष्ट समाप्ति नहीं है, यह 16 छोरों के भीतर समाप्त होना चाहिए।

अभिव्यक्ति (n&8)*14^(n&4)*19^(n&2)*21^n%2*105हैमिंग मैट्रिक्स बिटवाइज़ को लागू करती है।

एक त्रुटि के लिए जाँच करने के लिए, हम दिए गए संदेश को पाने के लिए एक संगणित के साथ जमा करते हैं e, और यह जाँचते हैं कि यह क्लासिक बिट-ट्रिक के साथ दो (या 0) की शक्ति है या नहीं e&~-e==0। लेकिन, हम वास्तव eमें एक लैम्ब्डा के भीतर वैरिएबल को असाइन नहीं कर सकते हैं , और हम इसे दो बार इस अभिव्यक्ति में संदर्भित करते हैं, इसलिए हम इसे अगले पुनरावर्ती चरण के लिए एक वैकल्पिक तर्क के रूप में पारित करने का हैक करते हैं।

— XNOR
स्रोत
7

जावास्क्रिप्ट (ईएस 6), 92 87 81

एमएसबी में पूर्णांक प्राप्त करना और वापस करना।
कार्यान्वयन सीधे @randomra टिप्पणी के बाद है:

  • calc p3wrong | P2wrong | p1wrong (लाइन 2,3,4)
  • गलत बिट (पंक्ति 1) को फ्लिप करने के लिए इसे बिट मास्क के रूप में उपयोग करें,
  • फिर बस डेटा बिट्स (अंतिम पंक्ति) पर लौटें
F=w=>(w^=128>>(
  (w^w*2^w*4^w/2)&4|
  (w/8^w^w*2^w/16)&2|
  (w/16^w/4^w^w/64)&1
))&7|w/2&8

Frefox / FireBug कंसोल में टेस्ट करें

;[0b1110000,0b1100000,0b1111011,0b0110001,
0b1011011,0b0101001,0b1010000,0b0100010]
.map(x=>x.toString(2)+'->'+F(x).toString(2))

उत्पादन

["1110000->1000", "1100000->1000", "1111011->1111", "110001->1011", "1011011->1010", "101001->1", "1010000->1000", "100010->10"]
— edc65
स्रोत
1
मैं वास्तव में आपके कॉम्पैक्ट बिटवाइज़ ऑपरेशन समाधान =) को पसंद करता हूं
— अक्षर
4

पायथन 2, 71

f=lambda i,b=3:i&7|i/2&8if chr(i)in'\0%*3<CLUZfip'else f(i^b/2,b*2)

कई अक्षर अप्रमाणित ASCII हैं, इसलिए यहां एक बचा हुआ संस्करण है:

f=lambda i,b=3:i&7|i/2&8if chr(i)in'\0\x0f\x16\x19%*3<CLUZfip\x7f'else f(i^b/2,b*2)

फ़ंक्शन में इनपुट और आउटपुट पूर्णांकों के रूप में किए जाते हैं।

मैं इस तथ्य का लाभ उठा रहा हूं कि वैध संदेशों की संख्या केवल 16 है, और उन सभी को हार्ड-कोडिंग करना है। तब तक मैं अलग-अलग बिट्स को फ़्लिप करने की कोशिश करता हूं, जब तक कि मुझे उनमें से एक नहीं मिलता।

— feersum
स्रोत
3

हास्केल, 152 बाइट्स

a(p,q,d,r,e,f,g)=b$(d+e)#p+2*(d+f)#q+4*(e+f)#r where b 3=(1-d,e,f,g);b 5=(d,1-e,f,g);b 6=(d,e,1-f,g);b 7=(d,e,f,g-1);b _=(d,e,f,g);x#y=abs$(x+g)`mod`2-y

उपयोग: a (1,1,1,1,0,1,1)जो आउटपुट(1,1,1,1)

सीधा समाधान: यदि p<x>मेल नहीं खाता है, तो <x>एक संख्या में बिट सेट करें । इस संख्या में है 3, 5, 6या 7, इसी फ्लिप d<y>।

— nimi
स्रोत
क्या आप अपने कोड को कॉल करने के तरीके (उदाहरण के लिए ideone.com जैसे ऑनलाइन कंपाइलर का उपयोग करके ) पर कुछ और निर्देश जोड़ सकते हैं ? मुझे हमेशा कुछ अजीब त्रुटियां होती हैं (बहुत संभावना है कि मेरी गलती)।
— 23
@ जाकुब: कोड को किसी फ़ाइल में सहेजें, कहें hamming.hsऔर इसे हास्केल REPL ghci में लोड करें ghci hamming.hs:। aऊपर वर्णित के रूप में फ़ंक्शन को कॉल करें । केवल ऑनलाइन Haskell दुभाषिया मैं के बारे में पता ( tryhaskell.org :) की आवश्यकता है कुछ और कोडlet a(p,q, ... 2-y in a (1,1,1,1,0,1,1)
— nimi
3

IA-32 मशीन कोड, 36 बाइट्स

Hexdump:

33 c0 40 91 a8 55 7a 02 d0 e1 a8 66 7a 03 c0 e1
02 a8 78 7a 03 c1 e1 04 d0 e9 32 c1 24 74 04 04
c0 e8 03 c3

समतुल्य सी कोड:

unsigned parity(unsigned x)
{
    if (x == 0)
        return 0;
    else
        return x & 1 ^ parity(x >> 1);
}

unsigned fix(unsigned x)
{
    unsigned e1, e2, e3, err_pos, data;
    e1 = parity(x & 0x55);
    e2 = parity(x & 0x66);
    e3 = parity(x & 0x78);
    err_pos = e1 + e2 * 2 + e3 * 4;
    x ^= 1 << err_pos >> 1;
    data = x;
    data &= 0x74;
    data += 4;
    data >>= 3;
    return data;
}

x86 CPU स्वचालित रूप से प्रत्येक मध्यवर्ती परिणाम की समता की गणना करता है। इसमें एक समर्पित निर्देश jpहै जो समानता के आधार पर कूदता है या नहीं कूदता है।

यह स्पष्ट रूप से चुनौती में निर्दिष्ट नहीं किया गया था, लेकिन कोडिंग की सुविधाजनक संपत्ति यह है कि आप समता बिट्स को एक द्विआधारी संख्या के रूप में व्याख्या कर सकते हैं, और यह संख्या इंगित करती है कि ट्रांसमिशन के दौरान कौन सा बिट खराब हो गया था। वास्तव में, यह संख्या 1-आधारित है, जिसमें 0 का अर्थ है कि कोई ट्रांसमिशन त्रुटियां नहीं थीं। यह 1 बायाँ err_posऔर फिर दायें द्वारा स्थानांतरित करके कार्यान्वित किया जाता है 1।

ट्रांसमिशन त्रुटि को ठीक करने के बाद, कोड आवश्यक क्रम में डेटा बिट्स की व्यवस्था करता है। कोड आकार के लिए अनुकूलित है, और यह पहली बार में अस्पष्ट हो सकता है कि यह कैसे काम करता है। यह व्याख्या करने के लिए, मैं द्वारा निरूपित a, b, c, dडेटा बिट्स, और से P, Qऔर Rसमता बिट। फिर:

    data = x;     // d  c  b  R  a  Q  P
    data &= 0x74; // d  c  b  0  a  0  0
    data += 4;    // d  c  b  a ~a  0  0
    data >>= 3;   // d  c  b  a

विधानसभा स्रोत ( fastcallसम्मेलन, इनपुट ecxऔर आउटपुट में eax):

    xor eax, eax;
    inc eax;
    xchg eax, ecx;

    test al, 0x55;
    jp skip1;
    shl cl, 1;

skip1:
    test al, 0x66;
    jp skip2;
    shl cl, 2;

skip2:
    test al, 0x78;
    jp skip3;
    shl ecx, 4;

skip3:
    shr cl, 1;
    xor al, cl;

    and al, 0x74;
    add al, 4;
    shr al, 3;

    ret;
— anatolyg
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.