टोन अवधि के आधार पर मोर्स कोड का अनुवाद करें

36

लक्ष्य

मोर्स कोड को अक्सर ध्वनि के रूप में दर्शाया जाता है। बिट्स की एक धारा को देखते हुए जो यह दर्शाता है कि ध्वनि चालू है या बंद है, धारा को अक्षरों और संख्याओं और स्थानों में अनुवाद करें।

अंतर्राष्ट्रीय मोर्स कोड

विशिष्ट तथ्य

  • बिट स्ट्रीम का विश्लेषण ON / OFF बिट्स को दोहराने की लंबाई के आधार पर किया जाता है।
    • 1 बिट एक बिंदी है
    • 3 बिट्स एक पानी का छींटा है
    • 1 बंद बिट्स डॉट्स और डैश को डीलिमिट करता है
    • 3 ऑफ बिट्स पात्रों को परिसीमित करते हैं
    • 7 ऑफ बिट्स शब्दों को परिसीमित करता है (स्थान)
  • इनपुट एक स्ट्रिंग या सरणी हो सकता है। इनपुट में आपकी पसंद के केवल दो विशिष्ट वर्ण / मान की अनुमति है। (उदा। 0/1, सत्य / असत्य, अल्पविराम / स्थान)
  • आउटपुट एक स्ट्रिंग लौटाता है या मानक आउटपुट पर मुद्रित होता है।

उदाहरण

Input:    101010100010001011101010001011101010001110111011100000001011101110001110111011100010111010001011101010001110101
Analysis: \--H--/   E   \---L---/   \---L---/   \----O----/\-- --/\---W---/   \----O----/   \--R--/   \---L---/   \--D--/
Output:   HELLO WORLD

मान्यताओं

  • धारा हमेशा एक बिट के साथ शुरू और समाप्त होती है।
  • कोई अग्रणी या अनुगामी व्हाट्सएप नहीं है।
  • इनपुट हमेशा मान्य होता है।
  • सभी पत्र (केस-असंवेदनशील) और अंक समर्थित हैं।

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

101010100010001011101010001011101010001110111011100000001011101110001110111011100010111010001011101010001110101
HELLO WORLD

10100000001011100011101110000000101110000000101011101000101000101010001010101
I AM A FISH

1010111011101110001110111011101110111000101110111011101110001110111010101
2017

101010001110111011100010101
SOS

स्कोरिंग

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

code-golf  morse 
— हाथ-ए-खाना
स्रोत
क्या आउटपुट में व्हॉट्सएप का अनुगमन हो सकता है?
— ब्रायन जे

जवाबों:

9

APL (Dyalog) , 65 62 60 57 बाइट्स

-3 ngn के लिए धन्यवाद।

टैसिट उपसर्ग फ़ंक्शन।

⎕CY'dfns'
morse'/|[-.]+'⎕S'&'∘(⊃∘'/. -'¨6|'1+|(00)+'⎕S 1)

इसे ऑनलाइन आज़माएं! f←टीआईओ के बाइट काउंट को बरकरार रखते हुए हेडर, और फुटर इनपुट से फ़ंक्शन को कॉल करने की अनुमति देने के लिए हैं। एक सामान्य एपीएल सत्र में (टीआईओ के इनपुट क्षेत्र के अनुरूप), इसकी आवश्यकता नहीं होगी ।

⎕CY'dfns' ग सेशन y dfns कार्यस्थान (पुस्तकालय)

(… ) इस tacit फ़ंक्शन को लागू करें:
 '1+|(00)+'⎕S 1 PCRE S earch 1-रन और समान-लंबाई 0-रन और वापसी मैच की लंबाई
 6| विभाजन शेष जब
 ⊃∘'/. -'¨ प्रत्येक मैच लंबाई के लिए 6 से विभाजित किया जाता है , तो इस स्ट्रिंग से संबंधित वर्ण चुनें
'/|[-.]+'⎕S'&'∘ PCRE S earch स्लैश और डैश डॉट -Runs और उन
morse अनुवादों को मोर्स कोड से नियमित पाठ में लौटाएं

— एडम
स्रोत
5
वाह, कभी नहीं पता था कि Dyalog में मोर्स कोड के लिए एक बेसिन था।
— ज़ाचारि
@ Zacharý dfns में कई, कई बिलियन हैं।
— निकोलगर्फ़
@ जाकारी हमेशा की जांच dfns !
— 9
आप पुराने संस्करण से लिंक कर रहे हैं।
— निकोलगर्फ़
एक बीएफ फ़ंक्शन ...> _ <, वाह।
— Zacharý
8

पायथन 2 , 142 135 बाइट्स

lambda s:''.join(' E-T----Z-Q---RSWU--2FH-V980NIMA--1CBYX-6--GDOK534PLJ-7'[int('0'+l.replace('111','3'),16)%57]for l in s.split('000'))

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

स्पष्टीकरण:

स्ट्रिंग को अक्षरों में विभाजित करता है 000( 0इस प्रकार स्थान का अर्थ है)

प्रत्येक के 111साथ बदलता है 3, और आधार 16 में परिवर्तित होता है।

फिर प्रत्येक संख्या को मॉडरेट किया जाता है 57, जो की एक सीमा देता है 0..54, जो वर्तमान चरित्र का सूचकांक है।

पिछला संस्करण जो बेस 3 में परिवर्तित हो गया है:

पायथन 2 , 273 252 247 बाइट्स

lambda s:''.join(chr(dict(zip([0,242,161,134,125,122,121,202,229,238,241]+[2]*7+[5,67,70,22,1,43,25,40,4,53,23,49,8,7,26,52,77,16,13,2,14,41,17,68,71,76],[32]+range(48,91)))[int('0'+l.replace('111','2').replace('0',''),3)])for l in s.split('000'))

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

पिछला संस्करण जो बाइनरी में परिवर्तित हो गया:

पायथन 2 , 282 261 256 बाइट्स

lambda s:''.join(chr(dict(zip([0,489335,96119,22391,5495,1367,341,1877,7637,30581,122333]+[2]*7+[23,469,1885,117,1,349,477,85,5,6007,471,373,119,29,1911,1501,7639,93,21,7,87,343,375,1879,7543,1909],[32]+range(48,91)))[int('0'+l,2)])for l in s.split('000'))

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

— TFeld
स्रोत
5

रूबी , 123 बाइट्स

->s{s.split(/0000?/).map{|r|r[0]?"YE9_0IZTO_BHKU58V_GR_SFA__1_4NP_60X_____C__D_ML7WQ3__2__J"[r.to_i(2)%253%132%74]:" "}*""}

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

वर्ण सीमा पर इनपुट स्ट्रिंग को विभाजित करें। 3 या 4 ऑफ बिट्स का उपयोग करें ताकि रिक्त स्थानों को रिक्त स्थान में बदल दिया जाए। प्रत्येक वर्ण का आधार 2 मान लें, और 3 क्रमिक विभाजनों पर मोडुलो का उपयोग करके एक उचित सीमा (60 से कम संभव मान) में लाएं।

— जीबी
स्रोत
बहुत अच्छी तरह से किया।
— मोनिका iamnotmaynard
2
मुझे यकीन है कि यह सभी मामलों के लिए काम करता है, लेकिन अगर आप 0?Regexp से हटा दें तो यह चार परीक्षण मामलों के लिए काम करता है।
— जॉर्डन
4

पायथन , 175 168 बाइट्स

s=lambda t,f=''.join:f('; TEMNAIOGKDWRUS;;QZYCXBJP;L;FVH09;8;;;7;;;;;;;61;;;;;;;2;;;3;45'[int('1'+f('0'if j[1:]else j for j in i.split('0')),2)]for i in t.split('000'))

पहले स्ट्रिंग को 0 (डैश) / 1 (डॉट) स्ट्रिंग की सूची में परिवर्तित करें, एक उपसर्ग जोड़ें 1(अग्रणी शून्य को रोकने और व्हाट्सएप से निपटने के लिए), फिर बाइनरी में कनवर्ट करें।

चूंकि प्रत्येक कोड की लंबाई 5 से अधिक नहीं है, इसलिए परिणाम 0 से 63 तक होता है और इसे एक स्ट्रिंग में सूचीबद्ध किया जा सकता है।

— कोलेरा सु
स्रोत
1
मुझे स्वतंत्र रूप से मूल रूप से एक ही समाधान मिला, लेकिन 169 बाइट्स:lambda s:''.join("_ TEMNAIOGKDWRUS__QZYCXBJP_L_FVH09_8___7_______61_______2___3_45"[int('1'+filter(int,l).replace('2','0'),2)]for l in s.replace('111','2').split('000'))
— एलेक्स वरगा
@AlexVarga पायथन 2 का अच्छा उपयोग filter!
— कोलेरा सु
3

जैली , 67 62 बाइट्स

ṣ0L€«2ḅ2“>.&" þ/7;=¥çı¿¢×ÆФ怌©¦Çß÷µ¬£®Ñ½ðȷñ‘iịØB;⁶¤
œṣ0ẋ3¤Ç€

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

— आउटग्रॉफर को एरिक करें
स्रोत
रुको, लिंक नंबरिंग चारों ओर लपेटता है?
— जच्चारी
@ Zacharý हाँ यह करता है, लाइन-लिंक में मॉड्यूलर सूचकांक हैं।
— निकोलग्राफ
3

Visual Basic .NET (.NET Core) , 252 बाइट्स

-7 बाइट्स @ धन्यवाद के लिए धन्यवाद

Function A(i)
For Each w In i.Split({"0000000"},0)
For Each l In w.Split({"000"},0)
Dim c=0
For Each p In l.Split("0")
c=c*2+1+p.Length\2
Next
A &="!ETIANMSURWDKGOHVF!L!PJBXCYZQ!!54!3!!!2!!!!!!!16!!!!!!!7!!!8!90"(c)
Next
A+=" "
Next
End Function

एक फ़ंक्शन जो 1s और 0s की स्ट्रिंग लेता है , और एक स्ट्रिंग लौटाता है। (वास्तव में, केवल के 0लिए OFFएक कठिन आवश्यकता है। कुछ भी नहीं OFFमाना जाता है ON)।

स्ट्रिंग शाब्दिक सरणी रूप में बाइनरी हीप के रूप में मोर्स कोड सेटअप है। VB.NET आपको वर्णों के सरणियों के रूप में स्ट्रिंग को अनुक्रमित करने देता है। \विभाजन पूर्णांक है, के लिए छोड़ दिया उप ढेर लेने 1या के लिए सही उप ढेर 111।

!जब उस ढेर स्थान में कोई मूल्य नहीं होता है तो मैं एक रिक्त के रूप में उपयोग करता था। केवल सूचकांकों को ठीक से पैड करना आवश्यक है।

VB.NET आपको फ़ंक्शन नाम (इस मामले में A) के लिए एक मान निर्दिष्ट करके वापस आने देता है । मैं सिर्फ iteratively स्ट्रिंग स्ट्रिंग ( &) उत्पादन आउटपुट स्ट्रिंग का निर्माण करने के लिए करते हैं। पहली बार मुझे उपयोग करने की आवश्यकता है &क्योंकि +एक अग्रणी अशक्त चार का उपयोग करते हुए , लेकिन किसी भी अन्य समय मैं उपयोग कर सकता हूं +, जो &स्ट्रिंग्स के समान व्यवहार करता है ।

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

— ब्रायन जे
स्रोत
1
आप 7 बाइट्स का उपयोग करके बचा सकते हैं "!ETIANMSURWDKGOHVF!L!PJBXCYZQ!!5473!!8290!!!!!16", और फिर उपयोग करके अनुक्रमित कर सकते हैं M(c-c\48*22), और फिर आप उपयोग न करके भी एक और 4 बचा सकते हैं M, लेकिन सिर्फ स्ट्रिंग शाब्दिक इनलाइन का उपयोग करके।
— पुनरावर्ती
@recursive मैं 4 बाइट ट्रिक समझता हूँ, मदद के लिए धन्यवाद! मुझे इंडेक्स को बदलने के तरीके को समझने में परेशानी हो रही है। यदि मैं स्ट्रिंग शाब्दिक को प्रतिस्थापित करता हूं, और फिर उपयोग करता M(c-c\48*22)हूं, तो मुझे 2017 के मामले में सूचकांक से बाहर कर दिया जाएगा। मुझे लगता है कि VB एक ही मिसाल पर विभाजन और गुणा करेगा; क्या मुझे एक कोष्ठक याद आ रहा है?
— ब्रायन जे
आप पूर्वता के बारे में सही हैं। या c\48*22तो होगा । यह स्ट्रिंग के अंत में "फोल्डिंग" द्वारा छोटा करने के लिए सशर्त रूप से 22 को घटाने का एक तरीका है । यदि वह आपके लिए काम नहीं कर रहा है, तो आप हमेशा दूसरे 2 बाइट्स के लिए पैरेंस को हटा सकते हैं । :)022cMA &=(" ")
— पुनरावर्ती
और फिर आप बदल सकते हैं &=करने के लिए +=, और एक अन्य दो रिक्त स्थान को हटा दें।
— पुनरावर्ती
@recursive ओह, दुआ! बहुत सारे अतिरिक्त परिंदे। प्लस में बदलने के साथ मुद्दा तब मेरे स्ट्रिंग की शुरुआत में एक प्रमुख अशक्त चरित्र है। शायद यह एक बड़ी बात नहीं है, हालांकि।
— ब्रायन जे
3

जावास्क्रिप्ट (ईएस 6), 170 131 बाइट्स

s=>s.split`000`.map(e=>'  ETIANMSURWDKGOHVF L PJBXCYZQ'[c=+`0b${1+e.replace(/0?(111|1)/g,d=>+(d>1))}`]||'473168290 5'[c%11]).join``

यह काम किस प्रकार करता है:

यदि आप डॉट्स को 0s में बदल देते हैं और डैश को 1s में बदल देते हैं, और 1 के साथ उपसर्ग करते हैं, तो आपको बाइनरी नंबर मिलते हैं, जो दशमलव में परिवर्तित होने पर आपको देता है:

  1. पत्र: २ - १ 18, २०, और २२ - २ ९।
    इन्हें अनुक्रमित करके सही अक्षरों में बदला जा सकता है ' ETIANMSURWDKGOHVF L PJBXCYZQ'।
  2. संख्याएँ: 32, 33, 35, 39, 47, 48, 56, 60, 62 और 63।
    यदि हम इन संख्याओं को मापांक 11 लेते हैं, तो हमें संख्याएँ 0 - 8 और 10 मिलती हैं, जिन्हें सही संख्याओं द्वारा परिवर्तित किया जा सकता है। में अनुक्रमण '473168290 5'।

कार्यक्रम वर्णों पर विभाजित होता है, फिर प्रत्येक चरित्र को डॉट्स और डैश में परिवर्तित करता है, जो उपरोक्त नियमों के आधार पर उपयुक्त आउटपुट में परिवर्तित हो जाते हैं।

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

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

— रिक हिचकॉक
स्रोत
3

पायथन 2 , 127 बाइट्स

lambda s:''.join("IVMB  T  K 9LZF 1HWO3 GUS4 8 7A  E QR 26   NJX    Y0P 5D  C"[(int('0'+l)^2162146)%59]for l in s.split('000'))

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

के बंद का निर्माण TFeld निकाल कर के समाधान की जगह और, आधार 10 में काम कर रहे एक बिटवाइज़ XOR की लागत और एक लंबे समय तक संदर्भ स्ट्रिंग में से।

— जो
स्रोत
2

PHP, 321 284 बाइट्स

@Ovs की बदौलत 37 बाइट्स बचाए

$a=array_flip([242,161,134,125,122,121,202,229,238,241,5,67,70,22,1,43,25,40,4,53,23,49,8,7,26,52,77,16,13,2,14,41,17,68,71,76]);foreach(split('0000000',$argv[1])as$w){foreach(split('000',$w)as$m){echo($v=$a[base_convert(str_replace([111,0],[2,],$m),3,10)])>9?chr($v+55):$v;}echo' ';}

पिछला संस्करण (321 बाइट्स)

$a=array_flip([22222,12222,11222,11122,11112,11111,21111,22111,22211,22221,12,2111,2121,211,1,1121,221,1111,11,1222,212,1211,22,21,222,1221,2212,121,111,2,112,1112,122,2112,2122,2211]);foreach(split('0000000',$argv[1])as$w){foreach(split('000',$w)as$m){echo($v=$a[str_replace([111,0],[2,],$m)])>9?chr($v+55):$v;}echo' ';}

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

Ungolfed संस्करण: 

$a=array_flip(
// Building an array $a with every Morse letter representation (1=dot, 2=dash) and flip it
               [22222,12222,11222,11122,11112,
                // 01234
                11111,21111,22111,22211,22221,
                // 56789
                12,2111,2121,211,1,1121,221,
                // ABCDEFG
                1111,11,1222,212,1211,22,
                // HIJKLM
                21,222,1221,2212,121,111,2,
                // NOPQRST
                112,1112,122,2112,2122,2211]);
                // UVWXYZ
foreach (split('0000000', $argv[1]) as $w){
// for each word (separate with 7 consecutive zeroes)
    foreach (split('000',$w) as $m){
    // for each letter (separate with 3 consecutive zeroes)
        echo ($v = $a[str_replace([111,0],[2,],$m)]) > 9
        // Replace '111' with '2' and '0' with nothing and find $v, the corresponding entry in the array $a
            ? chr($v+55)
            // If > 9th element, then letter => echo the ASCII code equal to $v+55
            : $v;
            // Else echo $v
    }
    echo ' ';
    // Echo a space
}
— roberto06
स्रोत
2

जावा (ओपनजेडके 8) , 370 बाइट्स

s->{String r="";for(String t:s.split("0000000")){for(String u:t.split("000"))for(int x[]={1,7,5,21,29,23,87,93,119,85,117,341,375,343,373,471,477,349,469,1877,1367,1909,1879,1501,1911,1885,7637,5495,7543,7639,6007,30581,22391,122333,96119,489335},i=x.length;i-->0;)if(u.equals(Long.toString(x[i],2)))r+="ETISNAURMHD5WVLKGFB64ZXPOC73YQJ82910".charAt(i);r+=" ";}return r;}

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

  • 3 बाइट्स @Jutnarg की बदौलत बच गए।
— ओलिवियर ग्रेजायर
स्रोत
1
Integer.toString (x [i], 2) के बजाय Long.toString (x [i], 2) का उपयोग करके कुछ शेव कर सकते हैं
— Jeutnarg
2

GNU sed , 261 + 1 = 262 बाइट्स

-rझंडे के लिए +1 बाइट ।

s/000/;/g
s/111/_/g
s/0//g
s/$/;:51111141111_3111__211___i1____6_11117__1118___119____10_____H1111V111_F11_1L1_11P1__1J1___B_111X_11_C_1_1Y_1__Z__11Q__1_S111U11_R1_1W1__D_11K_1_N__1G__1O___I11A1_M__E1T_/
:
s/([1_]+);(.*([^1_])\1)/\3\2/
t
y/i/1/
s/;/ /g
s/:.*//g

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

व्याख्या

यह एक बहुत ही बुनियादी खोज तालिका समाधान है।

पहली तीन लाइनें इनपुट को बदल देती हैं इसलिए डैश _s हैं और डॉट्स 1s हैं। सबसे पहले, 000एस को बदल दिया जाता है ;, इसलिए अक्षरों को ;शब्दों और शब्दों के द्वारा अलग किया जाता है ;;0। तब 111s द्वारा प्रतिस्थापित किया जाता है _और सभी शेष 0s को छोड़ दिया जाता है, 1डॉट्स के लिए छोड़ दिया जाता है ।

s/000/;/g
s/111/_/g
s/0//g

अगली पंक्ति लुकअप टेबल को जोड़ देती है। यह वह रूप लेता है cmcmcm...जहां cएक चरित्र है और mयह _एस और 1एस का प्रतिनिधित्व करने का अनुक्रम है। वितरण के लिए तालिका में iप्रतिस्थापित किया 1गया है। चूंकि सीड में नियमित अभिव्यक्तियाँ हमेशा लालची होती हैं, इसलिए तालिका को सबसे लंबे समय तक सबसे छोटे कोड से सॉर्ट किया जाता है (इसलिए इसके बजाय 1_मेल खाता A1_है i1____)।

s/$/;:51111141111_3111__211___i1____6_11117__1118___119____10_____H1111V111_F11_1L1_11P1__1J1___B_111X_11_C_1_1Y_1__Z__11Q__1_S111U11_R1_1W1__D_11K_1_N__1G__1O___I11A1_M__E1T_/

अगला, एक लूप में, _एस और 1एस (और बाद के ;) के प्रत्येक अनुक्रम को संबंधित वर्ण द्वारा प्रतिस्थापित किया जाता है:

:
s/([1_]+);(.*([^1_])\1)/\3\2/
t

अंत में, सफाई: iएस को एस के साथ बदल दिया जाता है 1, शेष ;एस रिक्त स्थान होते हैं, और लुकअप तालिका हटा दी जाती है:

y/i/1/
s/;/ /g
s/:.*//g
— जॉर्डन
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 104 102 101 99 बाइट्स

s=>s.split`000`.map(n=>" _T__9VEFO0K7MX_CGS__LU1RYIJ845__Z_B_D6QP_3__AHNW2"[n*1741%8360%51]).join``

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

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

कैसे?

क्योंकि बाइनरी से दशमलव लागत बाइट में परिवर्तित होने पर, हम एक हैश फ़ंक्शन का उपयोग करते हैं जो बेस 10 में व्याख्या किए गए बाइनरी ब्लॉक पर सीधे काम करता है।

उदाहरण

dot dash dot dot = 101110101
101110101 * 1741 = 176032685841
176032685841 % 8360 = 3081
3081 % 51 = 21

--> The 21st character in the lookup table is 'L' (0-indexed).
— Arnauld
स्रोत
मुझे यह एक-चरणीय दृष्टिकोण बहुत पसंद है। इन 37 आउटपुटों को एक छोटे से पर्याप्त कार्य के साथ आकार के हैश में फिट करने के लिए आपने कितनी बड़ी खोज की?
— jayprich
n*p%m0%m11≤पी<100001<मीटर0<100001<मीटर1<100
1

रेटिना , 144 138 130 103 बाइट्स

T`d`@#
^|@@@

 @?#
E
{T`L#@`R6_BI_Z5S1C_GD8__\L\HNF3P__7_`\w@#
T`589B-INPRSZ#@`490XYKT2\OVAMJWUQ_`\w##

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

T`d`@#

बाइनरी अंकों को अन्य वर्णों में बदलें क्योंकि 0 और 1 वैध आउटपुट हैं।

^|@@@

हर वर्ण से पहले एक स्थान और शब्दों के बीच दो स्थान डालें।

 @?#
E

मान लें कि सभी वर्ण ईएस हैं।

{T`L#@`R6_BI_Z5S1C_GD8__\L\HNF3P__7_`\w@#

सभी पत्रों का यह मानते हुए अनुवाद करें कि वे एक डॉट द्वारा पीछा किया जाएगा। उदाहरण के लिए, यदि हमारे पास एक ई है, और हम एक दूसरा डॉट देखते हैं (हमने ई को सम्मिलित करते समय पहली बार उपभोग किया है) तो यह एक I. के लिए अनुवाद करता है। पत्रों के लिए जो केवल कानूनी तौर पर एक डैश द्वारा पीछा किया जा सकता है, उनके साथ अनुवाद किया जाता है। धारणा, और फिर अगले चरण में डैश का सेवन किया जाता है। अन्य पत्र हटा दिए गए हैं ( Lएक बाइट की लागत रखते हुए )।

T`589B-INPRSZ#@`490XYKT2\OVAMJWUQ_`\w##

यदि यह ट्रांसपायर होता है कि वे वास्तव में एक डैश के बाद थे, तो मिस्ट्रेन्सेलेशन को ठीक करें। यह उस डैश का भी उपभोग करता है जब इसे पिछले चरण द्वारा ग्रहण किया गया था। दोनों अनुवादों को तब तक दोहराया जाता है जब तक सभी डॉट्स और डैश की खपत नहीं हो जाती।

— नील
स्रोत
0

ईएस 6 , 268 बाइट्स

एक सूचकांक स्थिति में मोर्स के एक बेस 36 प्रतिनिधित्व से मैपिंग के बाद ASCII एन्कोडिंग का उपयोग करता है। मेरा सबसे अच्छा गोल्फ दिन नहीं है, लेकिन इसमें केवल 15 मिनट लगते हैं।

s=>s.split('00000').map(w=>String.fromCharCode.apply({},w.split('000').map(c=>"ahkn,225z,h9z,48n,11z,9h,1g5,5w5,nlh,2me5,,,,,,,,n,d1,1gd,39,1,9p,d9,2d,5,4mv,d3,ad,3b,t,1h3,15p,5w7,2l,l,7,2f,9j,af,1g7,1h1".split(',').indexOf(parseInt(c,2).toString(36))+48))).join(' ')
स्निपेट का विस्तार करें

पढ़ने में आसान (थोड़े): 

s=>
s
.split('00000')
.map(w=>
	String.fromCharCode.apply({},
		w.split('000')
			.map(c=>
				"ahkn,225z,h9z,48n,11z,9h,1g5,5w5,nlh,2me5,,,,,,,,n,d1,1gd,39,1,9p,d9,2d,5,4mv,d3,ad,3b,t,1h3,15p,5w7,2l,l,7,2f,9j,af,1g7,1h1"
				.split(',')
				.indexOf(
					parseInt(c,2).toString(36)
				)+48)
			)
	).join(' ')
स्निपेट का विस्तार करें

— binarymax
स्रोत
0

वोल्फ्राम भाषा (गणितज्ञ) , 288 बाइट्स

एक फाइल से बाइनरी के रूप में डेटा में पढ़ने के बारे में सोचा, लेकिन यह समझाना मुश्किल हो जाता है। बेस 36 डेटा को कुशलतापूर्वक शाब्दिक रूप से संग्रहीत करने के लिए एक अच्छा समझौता तरीका लग रहा था।

इनपुट के रूप में 0 और 1 का एक स्ट्रिंग लेता है। 7 शून्य के रन के साथ शुरू होने वाले प्रतिस्थापन की एक श्रृंखला है, फिर 3 के रन, फिर सबसे कम समय के सबसे लंबे द्विआधारी अक्षर। प्रतिस्थापन का आदेश महत्वपूर्ण है।

StringReplace[#,Thread@Rule[Join[{"0000000","000"},#~FromDigits~36~IntegerString~2&/@StringSplit@"ahkn 2me5 225z nlh h9z 5w7 5w5 5tj 4mv 48n 1h3 1h1 1gd 1g7 1g5 15p 11z d9 d3 d1 af ad 9p 9j 9h 3b 39 2l 2f 2d t n l 7 5 1"],Insert[Characters@" 09182Q7YJ3OZCX6P4GKBWLFV5MDRUHNASTIE","",2]]]&

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

— केली लोडर
स्रोत
रुको, गणितज्ञ के पास एक मोर्स कोड बिल्ट-इन नहीं है?
— ज़ाचारि
अभी नहीं! मैंने जाँचा।
— केली लोल्डर
0

पर्ल 5 , 195 बाइट्स

194 बाइट्स कोड + 1 के लिए -p।

%h=map{$_,(A..Z,0..9)[$i++]}unpack"S26I2S7I","\xd5]u]\xddUw\xd7uww\xdd\xd7]WWwWwuwwwwwWwWUU\xd5uw\xdd\xdd";s/0{7}/ /g;s/(\d+?)(000|\b)/$h{oct"0b$1"}/ge

मैं इसे सिर्फ एक मानक पैक बाइनरी स्ट्रिंग के साथ काम नहीं कर सका, मुझे उच्च-बाइट चार्ट से बचना पड़ा अन्यथा मैं 171 पर होता, अगर किसी को पता है कि मैं क्या याद कर रहा हूं, या यह क्यों टूट रहा है तो यह बहुत अच्छा होगा !

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

व्याख्या

बाइनरी स्ट्रिंग एक है packएड संख्या कि मोर्स पात्रों से संबंधित की सूची ( 101011101- 349के लिए Fआदि) और यह सीमाओं के साथ ज़िप किया गया है A..Z,0..9और एक देखने के रूप में इस्तेमाल किया। s///भाव सात के सभी रन की जगह 0की जगह के साथ रों और उसके बाद अंकों के सभी रन, तीन से अलग किया 0या शब्द सीमाओं \b, से उनकी संगत कुंजी के साथ %hहैश।

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