मोर्स डिकोड गोल्फ

24

मैं रिक्त स्थानों की बढ़ती घृणा से चिंतित हो गया हूं और इस उत्तर ने मुझे यह सुनिश्चित करने के लिए प्रेरित किया है कि मोर्स कोड व्हाट्सएप के इस कपटपूर्ण हटाने से सुरक्षित है।

इसलिए, आपका कार्य एक ऐसा प्रोग्राम बनाना होगा, जो हटाए गए सभी स्थानों के साथ मोर्स कोड का सफलतापूर्वक अनुवाद कर सके।

मोर्स कोड

नियम:

  1. इनपुट एक स्ट्रिंग होगा जिसमें केवल डैश और डॉट्स (ASCII 2D और 2E) होंगे। आउटपुट किसी अन्य वर्ण वाले इनपुट के लिए अपरिभाषित है। इनपुट (स्टडिन, टेक्स्ट फ़ाइल, प्रॉम्प्ट उपयोगकर्ता, जो भी हो) प्राप्त करने के लिए अपनी पसंद की भाषा के लिए सुविधाजनक किसी भी विधि का उपयोग करने के लिए स्वतंत्र महसूस करें। आप मान सकते हैं कि मोर्स कोड इनपुट में केवल अक्षर AZ होते हैं, और मिलान संख्या या विराम चिह्न की आवश्यकता नहीं होती है।

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

  3. मानक कमियां पर सभी प्रतिबंध एक अपवाद के साथ लागू होते हैं जैसा कि ऊपर उल्लेख किया गया है, यदि आप वास्तव में चाहते हैं तो इंटरनेट कनेक्शन के माध्यम से आवश्यकता 2 में संदर्भित शब्दकोश फ़ाइल तक पहुंच सकते हैं। URL छोटा होना स्वीकार्य है, मेरा मानना ​​है कि goo.gl/46I35Z संभवतः सबसे छोटा है।

  4. यह कोड गोल्फ, सबसे छोटा कोड जीत है।

नोट: Pastebin पर डिक्शनरी फ़ाइल पोस्ट करने से विंडोज स्टाइल 0A 0E सीक्वेंस के सभी लाइन एंडिंग्स बदल गए। आपका कार्यक्रम 0A केवल, 0E केवल या 0A 0E के साथ लाइन अंत मान सकता है।

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

इनपुट:

......-...-.. ---। ----- ...-..- ..

आउटपुट में होना चाहिए:

नमस्ते दुनिया

इनपुट:

...-। ----- .... ----- ... - .. - ... --- .. - ...-.... ... - ...-.. ---- ... -। ----....-।।

आउटपुट में होना चाहिए:

प्रोग्रामिंग पहेली और कोड गोल्फ

इनपुट:

-..... - ...-...-.. -।। ....---- --- .... ---- ..-.- --.. --- -। .... --- ...-...-......-... --- ... --- ..-- ---।

आउटपुट में होना चाहिए:

तेज, भूरी लोमडी आलसी कुत्ते के उपर कूद गई

code-golf  morse 
— Comintern
स्रोत
3
आप के बीच AN (.- -.)और कैसे बता सकते हैं EG (. --.)?
— १
2
@ Sieg - आउटपुट को तब वैध डिकोडिंग दोनों को शामिल करना होगा।
— कोमिन्टर्न
1
@ डेनिस - आह ... मैं शर्त लगाता हूं कि या तो पास्टिबिन या मेरे ब्राउज़र ने ऐसा किया। मेरी स्रोत फ़ाइल उनके पास नहीं है। आप लाइन परिसीमन को एक उपयुक्त सिस्टम में बदल सकते हैं, कोई अन्य परिवर्तन नहीं। जब मैं अपने फ़ोन पर नहीं होता, तो मैं इस प्रश्न को संपादित करता हूँ।
— कॉमिंटर
2
@ फालो सही व्यवहार है। ध्यान दें कि समस्या कहती है कि आपके आउटपुट में "हैलो वर्ल्ड" शामिल होना चाहिए , न कि यह उसी तक सीमित है। इसे सभी वैध डिकोडिंग को प्रिंट करना चाहिए।
— हॉब्स
2
(लगभग काव्य, वास्तव में)
— हॉब्स

जवाबों:

5

रूबी, 210

(1..(g=gets).size).map{|x|puts IO.read(?d).split.repeated_permutation(x).select{|p|p.join.gsub(/./,Hash[(?a..?z).zip"(;=/%513':07*)29@-+&,4.<>?".bytes.map{|b|('%b'%(b-35))[1,7].tr'01','.-'}])==g}.map{|r|r*' '}}

यदि "ओवर-गोल्फिंग" के रूप में ऐसी प्रथा मौजूद है, तो मुझे संदेह है कि मैंने इस समय के आसपास भाग लिया है। यह समाधान सभी शब्दों के बार-बार होने वाले क्रमपरिवर्तन के सरणी को इनपुट 1 की लंबाई से लंबाई तक उत्पन्न करता है । यह देखते हुए कि शब्दकोश फ़ाइल में "a" सबसे छोटा शब्द है और इसका कोड दो वर्ण लंबा है, यह इनपुट के आधे आकार तक की लंबाई के क्रमपरिवर्तन को उत्पन्न करने के लिए पर्याप्त होता, लेकिन /2इस डोमेन में शब्दशः के लिए तालमेल है तो मैंने मना कर दिया।

एक बार क्रमपरिवर्तन सरणी उत्पन्न हो गई है ( NB : यह लंबवत उदाहरण इनपुट के मामले में लंबाई 45404 104 है), प्रत्येक क्रमपरिवर्तन सारणी को समाप्‍त किया गया है, और इसके अल्फ़ाबेटिक वर्णों को उनके मोर्स के समकक्षों के बजाय सुविधाजनक (Regexp, Hash)संस्करण के माध्यम से बदल दिया गया है #gsubतरीका; यदि यह स्ट्रिंग इनपुट के बराबर है तो हमें एक वैध डिकोडिंग मिली है।

शब्दकोश को "d" नामक फ़ाइल से पढ़ा जाता है (कई बार), और इनपुट में एक नई रेखा नहीं होनी चाहिए।

उदाहरण रन (एक शब्दकोष के साथ, जो ब्रह्मांड की गर्मी से मृत्यु से पहले कार्यक्रम को लड़ने का मौका देगा)

$ cat d
puzzles
and
code
dummy
golf
programming
$ echo -n .--..-.-----..-..-----..-.--..--...---..--...-.......--.-..-.-.----...--.---.-....-. | ruby morse.rb
programming puzzles and code golf
^C
— व्हिस्की से तीन अगर
स्रोत
5

हास्केल, 296 वर्ण

  • शब्दकोश फ़ाइल: "d" नाम की एक पाठ फ़ाइल होनी चाहिए
  • इनपुट: स्टडिन, एक अनुगामी न्यूलाइन हो सकता है लेकिन कोई आंतरिक व्हाट्सएप नहीं
main=do f<-readFile"d";getLine>>=mapM(putStrLn.unwords).(words f&)
i!""=[i]
(i:j)!(p:q)|i==p=j!q
_!_=[]
_&""=[[]]
d&i=do
w<-d
j<-i!(w>>=((replicate 97"X"++words".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --..")!!).fromEnum)
n<-d&j
[w:n]

तत्वों की व्याख्या:

  • mainशब्दकोश को पढ़ता है, स्टड को पढ़ता है, निष्पादित करता है &, और &उपयुक्त व्हाट्सएप के आउटपुट को प्रारूपित करता है ।
  • (replicate 97"X"++words".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --..")!!)(परिभाषा के अंदर एक अभिव्यक्ति &) एक सूची है जिसके सूचकांक वर्ण कोड हैं (97 कोड है 'a') और मूल्य मोर्स अनुक्रम हैं।
  • !(इनफ़िक्स ऑपरेटर के रूप में नामित एक फ़ंक्शन) एक उपसर्ग के खिलाफ एक स्ट्रिंग से मेल खाता है; यदि उपसर्ग मौजूद है, तो वह शेष को एक तत्व सूची (सूची में सफलता) में देता है, अन्यथा खाली सूची (सूची में गड़बड़ी में विफलता)

  • &"nondeterministic" निष्पादन के लिए सूची का उपयोग करता है; यह

    1. d(एक शब्दकोश शब्द) की एक प्रविष्टि उठाता है ,
    2. !उस शब्द के मोर्स रूप से मेल करने के लिए उपयोग करता है ( w>>=((…)!!).fromEnum, जो इसके बराबर है concatMap (((…)!!) . fromEnum) w) इनपुट स्ट्रिंग के खिलाफ i,
    3. कॉल स्वयं ( d&j) शेष स्ट्रिंग से मेल खाने के लिए, और
    4. शब्दों की एक सूची के रूप में संभावित परिणाम देता है w:n, सूची में मोनड [w:n](जो छोटा, ठोस के बराबर है return (w:n))।

    ध्यान दें कि लाइन 6 के बाद हर लाइन लाइन 6 doपर शुरू की गई अभिव्यक्ति का हिस्सा है ; यह एक ही पंक्ति में अर्धविराम का उपयोग करने के समान ही वर्ण लेता है, लेकिन अधिक पठनीय है, हालांकि आप इसे केवल एक कार्यक्रम में एक बार कर सकते हैं।

यह कार्यक्रम बेहद धीमा है। यह प्रत्येक पैटर्न मैच में उन्हें फिर से जोड़ने के बजाय सूची में मूल के बगल में morsified शब्दों को संग्रहीत करके (और थोड़ा लंबा) आसानी से बनाया जा सकता है। अगली बात यह है कि मोर्स प्रतीकों (2-एरी ट्राइ ) द्वारा बाइनरी ट्री में शब्दों को संग्रहीत किया जाए ताकि अनावश्यक शाखाओं की कोशिश से बचा जा सके।

इसे थोड़ा छोटा किया जा सकता है यदि डिक्शनरी फाइल में अप्रयुक्त प्रतीक नहीं होते जैसे कि "-", इससे पहले replicate 97"X"++करने के पक्ष में हटाने की अनुमति देता .(-97+)है !!।

— केविन रीड
स्रोत
धिक्कार है बेटा, वह चतुर है। आप को +1।
— अलेक्जेंडर क्रैग्स
1
क्या आप जानते हैं कि (+(-97))इसे फिर से लिखा जा सकता है (-97+)?
— गर्वित हैकेलर
आपको h की तीसरी परिभाषा को हटा देना चाहिए और इसके बजाय |0<1=[]दूसरी परिभाषा में जोड़ना चाहिए
— गर्वित हैकेलर
2
interact12 वर्णों का उपयोग करें और जीतें। interact$unlines.map unwords.(words f&)
— gxtaillon
1
आप को बदलने के लिए सक्षम होना चाहिए concatMapके साथ>>=
— गर्व haskeller
3

अजगर - 363 345

कोड:

D,P='-.';U,N='-.-','.-.'
def s(b,i):
 if i=='':print b
 for w in open('d').read().split():
  C=''.join([dict(zip('abcdefghijklmnopqrstuvwxyz-\'23',[P+D,D+3*P,U+P,'-..',P,D+N,'--.',4*P,2*P,P+3*D,U,N+P,2*D,D+P,D*3,'.--.',D+U,N,P*3,D,'..-',3*P+D,'.--','-..-',U+D,'--..']+['']*4))[c]for c in w]);L=len(C)
  if i[:L]==C:s(b+' '+w,i[L:])
s('',input())

स्पष्टीकरण:

शब्दकोश को "d" नामक एक सादे पाठ फ़ाइल के रूप में संग्रहीत किया जाना चाहिए।

D, P, Uऔर Nमोर्स लुकअप तालिका की एक छोटी परिभाषा के लिए बस कुछ सहायक चर हैं।

s(i)एक पुनरावर्ती कार्य है जो पहले अनुवादित संदेश भाग pऔर शेष कोड भाग के प्रत्येक मान्य अनुवाद को प्रिंट करता है i: यदि iखाली है, तो हम कोड के अंत तक पहुंच गए हैंb जिसमें संपूर्ण अनुवाद शामिल है, इस प्रकार हम printइसे बस । अन्यथा हम wशब्दकोश में प्रत्येक शब्द की जांच करते हैं d, इसे मोर्स कोड में अनुवाद करते हैं Cऔर, यदि शेष कोड के iसाथ शुरू होता है C, तो हम इस शब्द wको अनुवादित शुरुआत में जोड़ते हैं bऔर sशेष पर फ़ंक्शन को पुन: कॉल करते हैं ।

दक्षता पर ध्यान दें:

यह एक बहुत धीमा लेकिन गोल्फ संस्करण है। विशेष रूप से शब्दकोश लोड करना और dict(zip(...))प्रत्येक पुनरावृत्ति में (अधिक चर से बचने के लिए) मोर्स लुकिंग टेबल ( ) का निर्माण करना बहुत खर्च होता है। और डिक्शनरी में सभी शब्दों का एक बार पहले ही अनुवाद कर देना और मांग पर प्रत्येक पुनरावृत्ति में नहीं बल्कि अधिक कुशल होगा। ये विचार 40 से अधिक वर्णों के साथ निम्नलिखित संस्करण की ओर ले जाते हैं लेकिन महत्वपूर्ण गति:

d=open('d').read().split()
D,P='-.';U,N='-.-','.-.'
M=dict(zip('abcdefghijklmnopqrstuvwxyz-\'23',[P+D,D+3*P,U+P,'-..',P,D+N,'--.',4*P,2*P,P+3*D,U,N+P,2*D,D+P,D*3,'.--.',D+U,N,P*3,D,'..-',3*P+D,'.--','-..-',U+D,'--..']+['']*4))
T=[''.join([M[c]for c in w])for w in d]
def s(b,i):
 if i=='':print b
 for j,w in enumerate(d):
  C=T[j];L=len(C)
  if i[:L]==C:s(b+' '+w,i[L:])
s('',input())
— फ़ाल्को
स्रोत
आप की जगह 2 पात्रों को बचा सकता है .startswith(C)के साथ [:len(C)]==C।
— ग्रेग हेवगिल
वाह धन्यवाद! यह बहुत अजीब हो रहा है, क्योंकि प्रत्येक पुनरावृत्ति में पूरे शब्दकोश को लोड करना पात्रों को बचाता है - और एल्गोरिथ्म को एक बार फिर धीमा कर देता है।
— फल्को
@GregHewgill: हाँ, यही मैंने मूल रूप से किया है। मैंने केवल दोनों संस्करणों को संबोधित करने के लिए अपना उत्तर संपादित किया।
— फाल्को
1
आप शब्दों की लंबाई को कम करके शब्दकोश को छाँटकर और अधिक रोचक परिणाम (लंबे शब्द) उत्पन्न कर सकते हैं। d=sorted(open('d').read().split(),key=len,reverse=1)या, उस तरह से अपने शब्दकोश को पूर्व-छाँटकर बाहरी रूप से करें।
— ग्रेग हेवगिल
हेक, अगर आप डिक्शनरी फाइल को रिफॉर्मेट कर सकते हैं, तो इसे एक प्रीलिटेड पाइथन डिक्शनरी के रूप में फॉर्मेट करें और M=eval(open('d').read()):)
— ग्रेग हेविगेल
3

पर्ल (5.10+), 293 वर्ण

शब्दकोश फ़ाइल को "डी" के रूप में सहेजा जाना चाहिए (और यदि आप शब्दों के बीच सीआरएस नहीं चाहते हैं तो यूनिक्स प्रारूप में होना चाहिए), स्टड पर मॉर्स इनपुट, कोई अनुगामी नईलाइन के साथ (उपयोग करें) echo -n ) के साथ।

open D,d;chomp(@w=<D>);@m{a..z}=map{substr(sprintf("%b",-61+ord),1)=~y/01/.-/r}
'BUWI?OKMATJQDCLSZGE@FNHVXY'=~/./g;%w=map{$_,qr#^\Q@{[s/./$m{$&}/reg]}#}@w;
@a=[$i=<>];while(@a){say join$",@{$$_[1]}for grep!$$_[0],@a;
@a=map{$x=$_;map{$$x[0]=~$w{$_}?[substr($$x[0],$+[0]),[@{$$x[1]},$_]]:()}@w}@a}

(केवल स्वरूपण के लिए लाइनब्रेक)।

अघोषित कोड:

# Read the word list
open my $dictionary, '<', 'd';
chomp(my @words = <$dictionary>);

# Define morse characters
my %morse;
@morse{'a' .. 'z'} = map {
  $n = ord($_) - 61;
  $bits = sprintf "%b", $n;
  $bits =~ tr/01/.-/;
  substr $bits, 1;
} split //, 'BUWI?OKMATJQDCLSZGE@FNHVXY';

# Make a hash of words to regexes that match their morse representation
my %morse_words = map {
  my $morse_word = s/./$morse{$_}/reg;
  ($_ => qr/^\Q$morse_word/)
} @words;

# Read the input
my $input = <>;

# Initialize the state
my @candidates = ({ remaining => $input, words => [] });

while (@candidates) {
  # Print matches
  for my $solution (grep { $_->{remaining} eq '' } @candidates) {
    say join " ", @{ $solution->{words} }; 
  } 
  # Generate new solutions
  @candidates = map {
    my $candidate = $_;
    map {
      $candidate->{remaining} =~ $morse_words{$_}
        ? {
          remaining => substr( $candidate->{remaining}, $+[0] ),
          words => [ @{ $candidate->{words} }, $_ ],
        }
        : ()
    } @words
  } @candidates;
}

काम करने का ढंग:

मोर्स कोड प्रतीकों को बदलकर संग्रहीत किया जाता है "।" और "-" द्विआधारी अंकों में 0 और 1, एक "1" (ताकि प्रमुख डॉट्स ऊपर नहीं हो रहे हैं) को प्रस्तुत करते हुए, द्विआधारी संख्या को दशमलव में परिवर्तित करते हैं, और फिर चरित्र को 61 उच्च मान के साथ एन्कोडिंग करते हैं (जो मुझे सब मिलता है मुद्रण योग्य आकर्षण और कुछ भी नहीं है कि पीछे हटने की जरूरत है)।

मैंने इसे एक तरह की विभाजन समस्या के रूप में सोचा, और उसके आधार पर एक समाधान बनाया। शब्दकोश में प्रत्येक शब्द के लिए, यह एक रेगेक्स ऑब्जेक्ट का निर्माण करता है जो एक स्ट्रिंग की शुरुआत में उस शब्द के स्पेसलेस मोरस प्रतिनिधित्व का मिलान (और कैप्चर) करेगा। फिर यह एक ऐसी स्थिति बनाकर पहली खोज शुरू करता है जिसमें कोई शब्द नहीं है और पूरे इनपुट को "शेष इनपुट" के रूप में देखा जाता है। फिर यह शेष इनपुट की शुरुआत में मेल खाने वाले शब्दों की तलाश करके और नए राज्यों का निर्माण करता है, जो मिलान वाले शब्दों में शब्द जोड़ते हैं और शेष इनपुट से मोर्स को हटाते हैं। जिन राज्यों में कोई शेष इनपुट नहीं है वे सफल हैं और उनके शब्दों की सूची मुद्रित है। ऐसे राज्य जो किसी भी शब्द (सफल वाले सहित) से मेल नहीं खा सकते हैं, कोई भी बच्चा पैदा नहीं करता है।

ध्यान दें कि ungolfed संस्करण में राज्य पठनीयता के लिए hashes हैं; गोल्फ संस्करण में वे सरणियाँ हैं (छोटे कोड और कम मेमोरी खपत के लिए); स्लॉट [0]शेष इनपुट और स्लॉट है[1] मिलान किए गए शब्द हैं।

टीका

यह अधर्मी है। अगर वहाँ एक समाधान है कि मैं नहीं सोच रहा हूँ। मैंने मारपा (एक एली पार्सर को एक इनपुट स्ट्रिंग के लिए कई पर्स देने की क्षमता के साथ) का उपयोग करके निर्माण करने की कोशिश की, लेकिन सिर्फ व्याकरण का निर्माण करते हुए स्मृति से बाहर भाग गया। हो सकता है कि अगर मैंने BNF इनपुट के बजाय निचले स्तर के API का उपयोग किया हो ...

— हॉब्स
स्रोत
यदि मैं केविन रीड (इनपुट में कोई नई पंक्ति नहीं) के रूप में एक ही आवश्यकता जोड़ता हूं, तो मैं 7 वर्णों को हटाकर बचा सकता हूं chomp()। क्या मैं?
— हॉब्स
"सुविधाजनक किसी भी विधि का उपयोग करने के लिए स्वतंत्र महसूस करें"।
— कॉमिंटर
के ordबजाय के साथ 2 बाइट्स दाढ़ी ord$_। शेव 1 बाइट कहने के join$"बजायjoin" "
— Zaid
2

हास्केल - 418

डायनेमिक प्रोग्रामिंग द्वारा इस डिकिंग समस्या को कुशलता से हल किया जा सकता है। मुझे पता है कि यह एक कोडगोल्फ है, लेकिन मुझे तेज कोड पसंद है।

कहें कि हमारे पास इनपुट स्ट्रिंग है s, तो हम एक सरणी बनाते हैं dp, dp[i]सबस्ट्रिंग के सभी मान्य डिकोडिंग परिणामों की सूची है s[:i]। wशब्दकोश में प्रत्येक शब्द के लिए, पहले हम इसे एन्कोडिंग करते हैं mw, फिर हम अगर dp[i]से भाग की गणना कर सकते हैं । भवन की समय जटिलता है । अंत में, अंतिम तत्व, वह है जो हमें चाहिए।dp[i - length(mw)]s[i - length(mw):i] == mwdpO({count of words} {length of s} {max word length})dp[length(s)]

वास्तव में, हमें पूरे डिकोडिंग को प्रत्येक के तत्व के रूप में संग्रहीत करने की आवश्यकता नहीं है dp[i]। हमें जो चाहिए वह अंतिम डिकोडेड शब्द है। यह कार्यान्वयन को बहुत तेज करता है। मेरे i3 लैपटॉप पर "हैलो वर्ल्ड" केस को समाप्त करने में 2 सेकंड से भी कम समय लगा। प्रश्न में पोस्ट किए गए अन्य मामलों के लिए, प्रोग्राम बहुत अधिक उत्पादन के बाद भी व्यावहारिक रूप से समाप्त नहीं होगा।

गतिशील प्रोग्रामिंग तकनीक का उपयोग करके, हम वैध डिकोडिंग की संख्या की गणना कर सकते हैं । आप यहां कोड पा सकते हैं । परिणाम:

input: ......-...-..---.-----.-..-..-..
count: 403856

input: .--..-.-----..-..-----..-.--..--...---..--...-.......--.-..-.-.----...--.---.-....-.
count: 2889424682038128

input: -.....--.-..-..-.-.-.--....-.---.---...-.----..-.---..---.--....---...-..-.-......-...---..-.---..-----.
count: 4986181473975221635

Ungolfed

import Control.Monad

morseTable :: [(Char, String)]
morseTable = zip ['a'..'z'] $ words ".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.."

wordToMorse :: String -> Maybe String
wordToMorse xs = return . concat =<< mapM (`lookup` morseTable) xs

slice :: (Int, Int) -> [a] -> [a]
slice (start, end) = take (end - start) . drop start

decode :: String -> String -> IO ()
decode dict s = trace (length s) [] where
  dict' = [(w, maybe "x" id . wordToMorse $ w) | w <- lines dict]
  dp = flip map [0..length s] $ \i -> [(j, w) |
        (w, mw) <- dict', let j = i - length mw, j >= 0 && mw == slice (j, i) s]

  trace :: Int -> [String] -> IO ()
  trace 0 prefix = putStrLn . unwords $ prefix
  trace i prefix = sequence_ [trace j (w:prefix) | (j, w) <- dp !! i]

main :: IO ()
main = do
  ws <- readFile "wordlist.txt"
  decode ws =<< getLine

golfed

import Control.Monad
l=length
t=zip['a'..]$words".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.."
h s=return.concat=<<mapM(`lookup`t)s
f d s=g(l s)[]where g 0 p=putStrLn.unwords$p;g i p=sequence_[g j(w:p)|(j,w)<-map(\i->[(j,w)|(w,m)<-[(w,maybe"x"id.h$w)|w<-lines d],let j=i-l m,j>=0&&m==(take(i-j).drop j$s)])[0..l s]!!i]
main=do d<-readFile"d";f d=<<getLine
— रे
स्रोत
एक बहुत ही कुशल समाधान देखने के लिए खुशी है। अब मुझे इसे समझना है :)
— hobbs
2

PHP, 234 226 बाइट्स

function f($s,$r=""){$s?:print"$r
";foreach(file(d)as$w){for($i=+$m="";$p=@strpos(__etianmsurwdkgohvf_l_pjbxcyzq,$w[$i++]);)$m.=strtr(substr(decbin($p),1),10,"-.");0!==strpos($s,$m)?:g(substr($s,strlen($m)),$r.trim($w)." ");}}

पुनरावर्ती कार्य, एक फ़ाइल नाम से शब्दकोश लेता है d।
एक गैर-अक्षर वाले शब्दकोश में हर शब्द के लिए विफल।

यदि आप कोई फ़ाइल नाम का उपयोग कर सकते हैं define ("d","<filename>"); फ़ंक्शन को कॉल करने से पहले ।

तेजी से निष्पादन के लिए 2 या 3 बाइट्स जोड़ें:
निकालें $s?:print"$r\n";, $s!=$m?पहले 0!==और :print$r.$wपहले डालें ;}}।

टूट - फूट

function f($s,$r="")
{
    $s?:print"$r\n";            // if input is empty, print result
    foreach(file(d)as$w)        // loop through words
    {
        // translate to morse:
        for($i=+$m="";              // init morse to empty string, $i to 0
                                        // loop while character is in the string
            $p=@strpos(__etianmsurwdkgohvf_l_pjbxcyzq,$w[$i++])
        ;)
            $m.=                        // 4. append to word morse code
                strtr(
                    substr(
                        decbin($p)      // 1: convert position to base 2
                    ,1)                 // 2: substr: remove leading `1`
                ,10,"-.")               // 3. strtr: dot for 0, dash for 1
            ;
        0!==strpos($s,$m)           // if $s starts with $m
            ?:f(                        // recurse
                substr($s,strlen($m)),  // with rest of $s as input
                $r.trim($w)." "         // and $r + word + space as result
            )
        ;
    }
}
— टाइटस
स्रोत
1

ग्रोवी 377 337

r=[:];t={x='',p=''->r[s[0]]=p+x;s=s.substring(1);if(p.size()<3){t('.',p+x);t('-',p+x)}};s='-eishvuf-arl-wpjtndbxkcymgzqo--';t()
m=('d'as File).readLines().groupBy{it.collect{r.get(it,0)}.join()}
f={it,h=[]->it.size().times{i->k=it[0..i]
if(k in m){m[k].each{j->f(it.substring(i+1),h+[j])}}}
if(it.empty){println h.join(' ')}}
f(args[0])

टिप्पणियाँ

तानाशाह के नाम की फाइल होनी चाहिए d। मोर्स स्ट्रिंग कमांड लाइन द्वारा पारित किया जाता है। उदाहरण के लिए:

% groovy morse.groovy ......-...-..---.-----.-..-..-.. | grep 'hello world'
hello world

"मोर्स कोड कम्प्रेशन" के लिए मैं एक बाइनरी ट्री का उपयोग कर रहा हूँ

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