टेलीग्राफी गोल्फ: डिकोड बॉडोट कोड

31

पृष्ठभूमि

1870 में Bamile Baudot ने Baudot Code का आविष्कार किया , टेलीग्राफी के लिए एक निश्चित लंबाई का वर्ण एन्कोडिंग। उन्होंने कोड को केवल पांच कुंजी के साथ एक मैनुअल कीबोर्ड से दर्ज किया गया था; दो बाएं हाथ से संचालित हैं और तीन दाहिने हाथ से:

Baudot 5-कुंजी कीबोर्ड

दाईं तर्जनी, मध्य और अनामिका क्रमशः I , II और III कुंजी संचालित करती हैं, और बाईं तर्जनी और मध्य अंगुलियाँ IV और Ⅴ का संचालन करती हैं । (इसके बाद मैं उनके पश्चिमी अरबी अंकों का उपयोग करूंगा, अर्थात 1 , 5 के माध्यम से ।) वर्णों को जीवा के रूप में दर्ज किया गया है। उदाहरण के लिए, "C" अक्षर दर्ज करने के लिए, ऑपरेटर 1 , 3 और 4 दबाता हैएक साथ चाबियाँ, जिसमें एक घूर्णन ब्रश हाथ अनुक्रम में प्रत्येक कुंजी को पढ़ता है और एक वर्तमान को प्रसारित करता है या, कुंजी के लिए उदास नहीं, वर्तमान नहीं। परिणाम, आधुनिक शब्दों में, 5-बिट कम-महत्वपूर्ण-बिट-पहले बाइनरी एन्कोडिंग है, जिसमें हमारा उदाहरण, "C," के रूप में एन्कोड किया गया है 10110।

5 बिट्स ??

आप सोच रहे होंगे कि 5 बिट्स, जो कि अधिकांश 32 अद्वितीय प्रतीकों को व्यक्त कर सकते हैं, विराम चिह्न के बिना कुछ भी कहने के लिए सभी अंग्रेजी अक्षरों और अंकों के लिए पर्याप्त नहीं है। Baudot ने अपनी आस्तीन ऊपर चलाई थी, हालांकि: उनका चरित्र सेट वास्तव में दो अलग-अलग सेट हैं: पत्र और आंकड़े , और उन्होंने उनके बीच स्विच करने के लिए दो विशेष कोड परिभाषित किए। लेटर शिफ्ट , जो लेटर्स मोड में बदल जाता है, अकेले 5 कुंजी ( 00001) दबाकर सक्रिय हो जाता है , और चित्रा शिफ्ट 4 कुंजी ( 00010) के साथ सक्रिय हो जाती है ।

चुनौती

आपकी चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है जो बॉडोट कोड प्रसारण को डिकोड करता है।

एक असली ट्रांसमिशन कुछ इनिशियलाइज़ेशन बिट्स के साथ शुरू होगा, साथ ही प्रत्येक कैरेक्टर के पहले और बाद में एक शुरुआत और थोड़ा सा रुक जाएगा, लेकिन हम उन्हें छोड़ देंगे और केवल प्रत्येक कैरेक्टर के लिए 5 यूनीक बिट्स की चिंता करेंगे। इनपुट और आउटपुट प्रारूप नीचे चर्चा की गई है।

बॉडोट का कोड

बॉडोट कोड के दो अलग-अलग संस्करण हैं: कॉन्टिनेंटल और यूके हम यूके संस्करण का उपयोग कर रहे हैं, जिसमें बॉडोट के मूल फ्रेंच से "ud" जैसे अक्षर शामिल नहीं हैं। हम यूके संस्करण के सभी प्रतीकों को भी छोड़ने जा रहे हैं जो मुद्रण योग्य ASCII वर्णों में से नहीं हैं। आपको केवल नीचे दी गई तालिका में पात्रों को डीकोड करना होगा, जिनमें से सभी मुद्रण योग्य ASCII वर्ण हैं अंतिम तालिका नियंत्रण वर्णों को छोड़कर जो तालिका के नीचे बताए गए हैं।

"Ltr" कॉलम वर्ण मोड में वर्ण दिखाता है और "Fig" चित्र मोड वर्ण दिखाता है:

        Encoding             Encoding
Ltr Fig  12345       Ltr Fig  12345
--- --- --------     --- --- --------
 A   1   10000        P   +   11111
 B   8   00110        Q   /   10111
 C   9   10110        R   -   00111
 D   0   11110        S       00101
 E   2   01000        T       10101
 F       01110        U   4   10100
 G   7   01010        V   '   11101
 H       11010        W   ?   01101
 I       01100        X       01001
 J   6   10010        Y   3   00100
 K   (   10011        Z   :   11001
 L   =   11011        -   .   10001
 M   )   01011        ER  ER  00011
 N       01111        FS  SP  00010
 O   5   11100        SP  LS  00001
 /       11000

दाहिने कॉलम में अंतिम तीन पंक्तियाँ नियंत्रण वर्ण हैं:

  • ERहै मिटाना । Baudot की टेलीग्राफी मशीनें पाठक को यह बताने के लिए कि इस चरित्र के लिए तारांकन चिह्न जैसा प्रतीक प्रिंट करेगा कि पूर्ववर्ती चरित्र को अनदेखा कर दिया जाना चाहिए, लेकिन हम पाठक के लिए भी अच्छे होंगे और वास्तव में पूर्ववर्ती चरित्र को छोड़ना (प्रिंट नहीं करना) चाहते हैं । यह लेटर और फिगर मोड दोनों में समान है।

  • FSहै चित्रा शिफ्ट । यह लेटर्स से लेकर फिगर तक सेट किए गए कैरेक्टर को स्विच करता है। यदि डिकोडर पहले से ही चित्रा मोड में है, तो एफएस को एक स्पेस ( SP"Ltr" कॉलम में एर्गो) के रूप में माना जाता है । जब डिकोडर फिगर मोड में होता है तो यह एलएस कैरेक्टर मिलने तक फिगर मोड में रहता है।

  • LSहै पत्र शिफ्ट । यह फिगर से लेटर्स पर सेट कैरेक्टर को स्विच करता है। यदि डिकोडर पहले से ही लेटर मोड में है, तो एलएस को स्पेस के रूप में माना जाता है । जब लेटर मोड में डिकोडर लेटर मोड में रहता है जब तक कि FS वर्ण प्राप्त नहीं होता है।

डिकोडर हमेशा लेटर मोड में शुरू होता है।

यहाँ चित्र शिफ्ट, लेटर शिफ्ट और स्पेस के साथ एक उदाहरण दिया गया है:

01011 10000 00100 00001 00010 10000 11100 00001 10101 11010
  M     A     Y   LS/SP FS/SP   1     5   LS/SP   T     H

इससे संदेश मिलता है MAY 15TH। जैसा कि आप देख सकते हैं, पहला 00001(लेटर शिफ्ट / स्पेस) वर्ण स्पेस के रूप में कार्य करता है, क्योंकि डिकोडर पहले से ही लेटर मोड में है। अगला वर्ण, 00010(चित्रा शिफ्ट / स्पेस) डिकोडर को प्रिंट करने के लिए चित्रा मोड में स्विच करता है 15। फिर फिर से 00001प्रकट होता है, लेकिन इस बार यह डिकोडर शिफ्ट के रूप में कार्य करता है ताकि डिकोडर को लेटर मोड में वापस रखा जा सके।

आपकी सुविधा के लिए, यहाँ एक प्रारूप में वर्ण हैं जो किसी संपादक में पचाने के लिए आसान है, कोड द्वारा क्रमबद्ध किया गया है:

A,1,10000|E,2,01000|/,,11000|Y,3,00100|U,4,10100|I,,01100|O,5,11100|FS,SP,00010|J,6,10010|G,7,01010|H,,11010|B,8,00110|C,9,10110|F,,01110|D,0,11110|SP,LS,00001|-,.,10001|X,,01001|Z,:,11001|S,,00101|T,,10101|W,?,01101|V,',11101|ER,ER,00011|K,(,10011|M,),01011|L,=,11011|R,-,00111|Q,/,10111|N,,01111|P,+,11111

इनपुट

इनपुट कम से कम महत्वपूर्ण-बिट-पहले क्रम में एक स्ट्रिंग, सरणी, या बिट्स की सूची होगी। प्रत्येक चरित्र को 5 बिट्स के एक पंचक द्वारा दर्शाया जाएगा। बिट्स किसी भी उचित प्रारूप में हो सकते हैं, उदाहरण के लिए, एक द्विआधारी स्ट्रिंग, 0एस और 1एस की एक सरणी , "0"और "1" पात्रों की एक स्ट्रिंग , एक बहुत बड़ी संख्या, आदि, जब तक यह सीधे प्रसारण के बिट्स के लिए मैप करता है।

प्रत्येक प्रसारण में कम से कम एक मुद्रण योग्य पंचक और अधिकतम 255 पंचक (मुद्रण योग्य या अन्यथा), यानी 5–1,275 बिट्स सम्मिलित होंगे।

इनपुट में केवल दो अनुमत अपवादों के साथ ट्रांसमिशन के बिट्स हो सकते हैं : 0स्ट्रिंग इनपुट के लिए किसी भी संख्या में अग्रणी या अनुगामी बिट्स और / या, ट्रांसमिशन के लिए एक एकल अनुगामी न्यूलाइन जोड़ा जा सकता है। प्रत्येक पंचक के पहले या बाद में अग्रणी या अनुगामी बिट्स या वर्ण जोड़े नहीं जा सकते हैं , अर्थात आप प्रत्येक पंचक को 8 बिट्स में नहीं रख सकते हैं (या प्रत्येक पंचक को एक संख्या में एकल संख्या के रूप में ले सकते हैं - जब तक कि आपकी भाषा में 5-बिट पूर्णांक प्रकार या अलग नहीं है किसी भी अतिरिक्त बिट्स के साथ पंचक, जैसे "01111\n11100"।

नोट और किनारे के मामले

  1. ट्रांसमिशन में ऊपर तालिका में केवल "Ltr" और "अंजीर" कॉलम के पात्र होंगे। आप कभी भी उदाहरण 01110के लिए चित्रा मोड में प्राप्त नहीं करेंगे , क्योंकि यह "अंजीर" कॉलम से अनुपस्थित है।

  2. यह माना जाता है कि डिकोडर हमेशा एक ट्रांसमिशन की शुरुआत में लेटर मोड में होगा। हालाँकि, पहला वर्ण चित्र मोड में तुरंत स्विच करने के लिए FS वर्ण हो सकता है।

  3. जब डिकोडर लेटर मोड में होता है, तो वह एक LS कैरेक्टर प्राप्त कर सकता है, और जब वह फिगर मोड में होता है, तो वह FS कैरेक्टर प्राप्त कर सकता है। या तो घटना में एक स्पेस कैरेक्टर प्रिंट होना चाहिए (आउटपुट देखें)।

  4. ईआर चरित्र एक ट्रांसमिशन में पहला चरित्र कभी नहीं होगा, न ही यह कभी भी एक एलएस, एफएस, या किसी अन्य ईआर का तुरंत पालन करेगा।

  5. एक एफएस चरित्र तुरंत एक एलएस चरित्र का पालन कर सकता है और इसके विपरीत।

  6. किसी भी ट्रांसमिशन में न तो एलएस और न ही एफएस चरित्र अंतिम चरित्र होगा।

  7. /और -वर्ण या तो पत्र मोड (कोड में प्राप्त किया जा सकता है 11000और 10001, क्रमशः) या चित्रा मोड ( 10111 और 00111)।

उत्पादन

आउटपुट किसी भी उचित प्रारूप में हो सकता है, सबसे उचित ASCII (या UTF-8, जिसके लिए सभी प्रस्तुत वर्ण ASCII के समान हैं)। यदि आपका आउटपुट किसी अन्य एन्कोडिंग या स्वरूप में है, तो कृपया अपने उत्तर में इंगित करें।

टिप्पणियाँ

  • अंतरिक्ष चरित्र (देखें 3. ऊपर) एक ASCII स्थान (0x20) या आपके एन्कोडिंग के समतुल्य होना चाहिए, अर्थात जब आप स्पेस बार दबाते हैं तो आपको क्या मिलता है।

जीतना

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

प्रतिबंध

  • मानक खामियों को मना किया जाता है।

  • अनुगामी रिक्त स्थान और / या एकल अनुगामी न्यूलाइन की अनुमति है। रिक्त स्थान या अन्य वर्ण (जो संचरण का हिस्सा नहीं हैं) अस्वीकृत हैं।

  • आप किसी भी अंतर्निहित या लाइब्रेरी फ़ंक्शंस का उपयोग नहीं कर सकते हैं जो बॉडोट कोड (या इसके किसी वंशज, जैसे मरे कोड, आईटीए -1, आदि) को डिकोड करता है।

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

Input: 001101000010100111101110010101
Output: BAUDOT
Input: 11010010001001100011110111101111100
Output: HELLO
Input: 01011100000010000001000101000011100000011010111010
Output: MAY 15TH
Input: 0001000100010000001000001011101110011100101010010110101010001111100101
Output: 32 FOOTSTEPS
Input: 10110000110101011100111100001111011010000001101110
Output: GOLF
Input: 000100011000001111100000100010110111001100010110010000111111
Output: 8D =( :P
Input: 0000100001000010000100010001111011111011000011100010001
Output (4 leading spaces):     -/=/-
code-golf  binary  decode 
— जॉर्डन
स्रोत
— जॉर्डन
1
नोट: मैंने हाथ से परीक्षण के मामलों को एनकोड किया; यदि आपको ऐसा कुछ दिखाई देता है जो गलत लगता है तो कृपया बोलें।
— जॉर्डन
1
कोड तालिका और साथ में पचाने के लिए, कोड 00010को SPपत्र मोड, और FSआंकड़ा मोड में सूचीबद्ध किया गया है । विवरण के अनुसार, यदि हम लेटर मोड में हैं और हमें कोड प्राप्त होता है 00010, तो हमें फिगर मोड में शिफ्ट हो जाना चाहिए, लेकिन तालिका में मान दूसरे तरीके से प्रतीत होते हैं। इसके अलावा, इसके विपरीत 00001।
— सोक
3
यह आदमी बहुत चालाक था, मैं टेलीग्राफी में इस्तेमाल होने वाले संपीड़न के बारे में कभी नहीं जानता था। इतिहास सबक आदमी के लिए धन्यवाद।
— मैजिक ऑक्टोपस उर्फ़
4
@carusocomputing अधिकार ?? Baudot में प्राथमिक विद्यालय से परे कोई औपचारिक शिक्षा नहीं थी, लेकिन न केवल उन्होंने Baudot Code का आविष्कार किया, उन्होंने एक बहुसंकेतन प्रणाली का आविष्कार किया जिसने चार ऑपरेटरों को एक साथ एक टेलीग्राफ लाइन का उपयोग करने की अनुमति दी। मुझे यह १ ९ १ ९ का पैम्फलेट मिला जो उनके आविष्कारों का कुछ विस्तार से वर्णन करता है सुपर दिलचस्प: samhallas.co.uk/repository/telegraph/b6_baudot_multiplex.pdf
— जॉर्डन

जवाबों:

6

पायथ, 98 97 95 93 90 83 80 बाइट्स

कोड में अनपेक्षित वर्ण हैं, इसलिए यहां एक प्रतिवर्ती xxdहेक्सडंप है:

00000000: 753f 7133 4a69 4832 5047 2b47 3f3c 334a  u?q3JiH2PG+G?<3J
00000010: 4040 6332 2e22 275a 75ae 5751 fb4e 3cd7  @@c2."'Zu.WQ.N<.
00000020: 02ce 8719 aac1 e0e0 fe1f 09e5 85bc a767  ...............g
00000030: 8e0c 1f47 508a cad1 1acb b26f 951e e5d6  ...GP......o....
00000040: 225a 4a2a 5c20 715a 3d5a 744a 637a 356b  "ZJ*\ qZ=ZtJcz5k

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

काफी लंबा है, लेकिन लुकअप तालिका में अधिकांश आधे स्थान होते हैं।

117 बाइट्स के लिए, यहाँ unprintables के बिना एक ही बात है (जरूरतों ISO-8859-1, हालांकि):

u?q3JiH2PG+G?<3J@@c2."'Zu®WQûN<×\x02Î\x87\x19ªÁààþ\x1f\tå\x85¼§g\x8e\x0c\x1fGP\x8aÊÑ\x1a˲o\x95\x1eåÖ"ZJ*\ qZ=ZtJcz5k

या, लुकअप टेबल पर कोई संपीड़न के साथ 93 बाइट्स के लिए:

u?q3JiH2PG+G?<3J@@c2"OVDPYSBREXGMIWFNA-JKUTCQ/ZHL5'0+3;8-2;7);?;;1.6(4;9/;:;="ZJ*\ qZ=ZtJcz5k
— PurkkaKoodari
स्रोत
5

जावास्क्रिप्ट (ईएस 6), 160 158 153 बाइट्स

let f =
    
s=>s.replace(/.{5}/g,s=>(n='0b'+s-1)<2?m-n?(m^=1,''):' ':"? !YSBREXGMIWFNA-JKUTCQ/ZHLOVDP? ?!3 8-2 7) ?  1.6(4 9/ : =5'0+"[n+m*32],m=0).replace(/.!/g,'')

console.log(f("001101000010100111101110010101"));
console.log(f("11010010001001100011110111101111100"));
console.log(f("01011100000010000001000101000011100000011010111010"));
console.log(f("0001000100010000001000001011101110011100101010010110101010001111100101"));
console.log(f("10110000110101011100111100001111011010000001101110"));
console.log(f("000100011000001111100000100010110111001100010110010000111111"));
console.log(f("0000100001000010000100010001111011111011000011100010001"));
स्निपेट का विस्तार करें

— Arnauld
स्रोत
5

बैच, 306 304 बाइट्स

@echo off
set/pc=
set r=
set d=! !!YSBREXGMIWFNA-JKUTCQ/ZHLOVDP!! !3!8-2!7)!?!!1.6(4!9/!:!=5'0+
set s=2
:l
set/an=(s^&32)+0%c:~,2%%%6*8+0x%c:~2,3%%%14
set c=%c:~5%
if %n%==%s% set/as^^=35&goto l
call set r=%%r%%%%d:~%n%,1%%
if %r:~-1%==! set r=%r:~,-2%&goto l
if not "%c%"=="" goto l
echo %r%

STDIN पर इनपुट लेता है। चूंकि बैच में कोई बाइनरी रूपांतरण नहीं है, इसलिए मुझे ऑक्टल और हेक्स रूपांतरण का उपयोग करके इसे नकली करना होगा।

  • पहले दो अंक ऑक्टल से परिवर्तित होते हैं (मैं दशमलव का उपयोग नहीं कर सकता क्योंकि पहला अंक हो सकता है 0)। संभावित मान हैं 00, 01, 10और 11। बाद के दो मूल्य है 8और 9लेकिन मैं चाहता हूँ 2या 3तो मैं शेष सापेक्ष ले 6।
  • अंतिम तीन अंक हेक्साडेसिमल से परिवर्तित होते हैं। अंक 14या तो या 252वांछित मूल्य हैं, मैं शेष मोदुलो 14( 252=14*18) को लेता हूं ।
  • c कोडित स्ट्रिंग है
  • r अब तक का परिणाम है
  • d डिकोडिंग ऐरे है
  • s सूचकांक की स्थिति को बदलने वाले वर्ण का सूचकांक (शिफ्ट स्टेट को ध्यान में रखते हुए) है
  • nबाइनरी डिकोड प्लस बिट 5 है s, जो या तो शिफ्ट स्टेट के बराबर है, जिस स्थिति में शिफ्ट स्टेट को टॉगल किया जाता है, या अगले कैरेक्टर को खोजने के लिए डिकोडिंग एरे में इंडेक्स (या मिटाने के लिए) है!
— नील
स्रोत
3

PHP, 206 बाइट्स

foreach(str_split($argv[1],5)as$s)($k="# f*YSBREXGMIWFNA-JKUTCQ/ZHLOVDP#l *3#8-2#7)#?##1.6(4#9/#:#=5'0+"[32*$f+bindec($s)])=="*"?array_pop($a):($k=="f"?$f=1:($k=="l"?$f=0:($k=="#"?:$a[]=$k)));echo join($a);
— जार्ग हुल्सरमन
स्रोत
2

चिप , 1069 बाइट्स

यह एक बड़ी बात है, लेकिन लिखने में काफी मजा आया।

इनपुट को "1"'s "0"' और ' स्ट्रिंग ' के रूप में लेता है । (हालांकि यह वास्तव में केवल कम बिट पर दिखता है।)

 AZZZZ,-o.AZZZZ  AZZZZ,o-.AZZZZ
*\\\\\]oo[\/\\\**//\\\]oo[/\\\\*
*\\\\/]oo[\/\\/**//\\/]oo[/\\\/*
*\\\//]oo[\/\//**//\//]oo[/\\//*
*\\\/\]oo[\/\/\**//\/\]oo[/\\/\*
*\\//\]oo[\///\**////\]oo[/\//\*
*\\///]oo[\////**/////]oo[/\///*
*\\/\/]oo[\//\/**///\/]oo[/\/\/*
*\\/\\]oo[\//\\**///\\]oo[/\/\\*
=
        o--------K-----o
      ,oo.   z---+~S  ,oo.
     ,LooR. !ZZZZ'   ,LooR.
    ,LLooRR.        ,LLooRR.
   ,LLLooRRR.      ,LLLooRRR.
  ,LLLLooRRRR.    ,LLLLooRRRR.
 ,LLLLLooRRRRR.  ,LLLLLooRRRRR. ,~Z
,LLLLLLooRRRRRR.,LLLLLLooRRRRRR.>m'
|||||||oo||||||||||||||oo||||||)/Rz.
xxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxx\^-^S
x)x))))))))))))xx)))))))))))))xx\g
xx)xxxxxxxxxxxxxxxxxxxxxxxxxxx))\f
xxxxxx))xxxxxxxxxxxxx)))))))))xx\e
xx)x))x)xxxxx))x)))))xxxxxxx)))x\d
xx))x))xxx)))xxxxx)))xxxx)))xx)x\c
xx)xx)xx))x))x)xx)xx)xx))x))x)xx\b
x)))))))x)xx)xxxx)x)xx)x)xx)xx)x\a
x)x)x))))))x)x))x)))x)))xx))x))x/f
x)x)x))))))x)x)xxx)xxxxxxxx)x)xx/e
xxxxxxxx))xxxxxx))))x)))xxx)x))x/d
xxxxx))xxxxx)x)xxx)xxx))xx))xx)x/c
xxx)xxx)xxxx)x)xxxxxx))xxx))x))x/b
x)xxx)x)x)xx)xxxxx))x)))xx))xxxx/a

इसे ऑनलाइन आज़माएं!

नोट: इरेज़र ASCII बैकस्पेस कैरेक्टर ( \x08) का उपयोग करता है , जिसका अर्थ है कि वे TIO में मज़ेदार दिखेंगे, लेकिन वे कहते हैं, xterm में ठीक दिखते हैं।

बुनियादी संरचना

शीर्ष पर, =रेखा के ऊपर , इनपुट डिकोडर है। यह इनपुट को 32 अलग-अलग संकेतों में से एक में बदल देता है। ये नीचे के लोगों के oऊपर भेजे =गए हैं।

की त्रिकोणीय पहाड़ों Lकी और R'सिर्फ कॉलम के लिए अलग-अलग पंक्तियों से पैटर्न बारी बारी से। नीचे का ग्रिड प्रत्येक कॉलम को उसके आउटपुट कैरेक्टर में बदल देता है। अज्ञात संकेतों के लिए, एनयूएल (\x00 ) का उत्पादन किया जाता है। विशेष पारियों के लिए, एक चरित्र को प्रिंट करने के बजाय, सही पर थोड़ा बूँदें मोड को बदल देती हैं।

दो पहाड़ों के बीच की चीज़ जैसी केबल-कार प्रत्येक पंचक के बीच किसी भी मुद्रण को दबा देती है, अन्यथा, यह सभी अतिव्यापी पंचक को भी डिकोड करने का प्रयास करेगा। !अपने लिए यह देखने के लिए स्थान के साथ प्रतिस्थापित करने का प्रयास करें। (क्रिया मोड में चल रहा है -vयहाँ भी रुचि हो सकती है।)

मुझे यकीन नहीं है कि इस समय इसे छोटा कैसे बनाया जाए; यह पहले से ही अपने आकार के लिए काफी सघन है।

— Phlarx
स्रोत
0

GNU sed, 334 + 1 = 335 बाइट्स

-rझंडे के लिए +1 बाइट । STDIN पर इनपुट लेता है।

पुरानी चुनौतियों को देखते हुए मुझे लगा कि यह सेड के साथ बहुत आसान होगा, और अभ्यास के लिए अच्छा होगा। मैंने किसी भी संपीड़न का प्रयास नहीं किया है, इसलिए लुकअप तालिका आधे से अधिक कोड है।

s|.*|#@&;01000E211000/%00100Y310100U401100I%11100O500010f 10010J601010G711010H%00110B810110C901110F%00001 l10001-.01001X%11001Z:00101S%10101T%01101W?11101V'00011<<10011K(01011M)11011L=00111R-10111Q/01111N%11111P+10000A111110D0|
:
s/@([01]{5})(.*;.*\1)(..)/\3@\2\3/
t
s/@;.*//
s/#f /@/
s/@ l/#/
s/#(.)./\1#/
s/@.(.)/\1@/
t
s/.<|[#@]//g

इसे ऑनलाइन आज़माएं!

व्याख्या

कोड दो चरणों में काम करता है: सबसे पहले, यह लुकअप टेबल से संबंधित दो वर्णों (अक्षर और आकृति) के साथ 5 बाइनरी अंकों के प्रत्येक रन को बदलता है। लुकअप टेबल प्रारूप the में है… जहां digit एक बाइनरी अंक है और 𝐅 और is क्रमशः एक ही अक्षर और आकृति है। %लापता पात्रों के लिए खड़ा है (यह न्यूलाइन के अलावा कोई भी चरित्र हो सकता है)। FS/SPद्वारा दर्शाया गया है f<space>और SP/LSहै <space>l। ERद्वारा दर्शाया गया है <<।

फिर यह मौजूदा मोड के #लिए "कर्सर" के साथ प्रत्येक जोड़ी के माध्यम से कदम - पत्र मोड के लिए, @आंकड़ा मोड के लिए। #कर्सर जोड़ी का दूसरा चरित्र दूर करता है और फिर अगले जोड़ी के लिए अग्रिम, और @पहले और अग्रिम निकाल देता है। दूसरे शब्दों में, #A1B8बन जाता है A#B8और फिर AB#, और @A1B8बन जाता है 1@B8और फिर 18@। जब #कर्सर का सामना f<space>होता है तो वह इसे हटा देता है और @कर्सर के साथ खुद को बदल देता है , और जब @सामना करता है तो इसके विपरीत <space>l।

जब कोई जोड़ा नहीं रहता है, तो अंतिम कर्सर को किसी भी वर्ण के साथ हटा दिया जाता है <।

# Setup: Append a lookup table to the line.
# Also prepends "#" and "@" which we'll use as "cursors" later.
s|.*|#@&;01000E211000/%00100Y310100U401100I%11100O500010f 10010J601010G711010H%00110B810110C901110F%00001 l10001-.01001X%11001Z:00101S%10101T%01101W?11101V'00011<<10011K(01011M)11011L=00111R-10111Q/01111N%11111P+10000A111110D0|

# Phase 1
:
  # Using "@" as a "cursor", substitute for each run of 5 binary digits the
  # two corresponding characters from the lookup table.
  s/@([01]{5})(.*;.*\1)(..)/\3@\2\3/
  t   # Loop (branch to `:`) as long as substitutions are made.

s/@;.*//       # Delete the "@" and lookup table

# Phase 2
s/#f /@/       # FS (f ) in letter mode (#); delete and switch to figure mode (@ cursor).
s/@ l/#/       # LS ( l) in figure mode (@); delete and switch to letter mode (# cursor).
s/#(.)./\1#/   # Letter mode; replace pair with first of pair; advance cursor.
s/@.(.)/\1@/   # Figure mode; replace pair with second of pair; advance cursor.
t              # If any substitutions were made, branch (loop) to `:`.

# Teardown
s/.<|[#@]//g   # Delete characters followed by < (ER) and cursor.
— जॉर्डन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.