मोर्स कोड अनुवादक

Question

मानक इनपुट को मोर्स कोड में बदलने के लिए सबसे छोटा प्रोग्राम लिखें । तालिका में वर्णों को मुद्रित नहीं किया जाना चाहिए जैसा कि वे हैं।

Comments

क्या कैपिटल और लोअरकेस दोनों अक्षर एन्कोडेड हैं?

— जॉय एडम्स

इसके अलावा, क्या आप शब्दों के बीच रिक्ति जैसे विवरण को स्पष्ट करने के लिए एक नमूना इनपुट और आउटपुट प्रदान कर सकते हैं?

— जॉय एडम्स

ठीक है, मोर्स में, निचले और ऊपरी मामले में कोई अंतर नहीं है। अंतरिक्ष के लिए कोई वास्तविक प्रतीक नहीं है (यह सिर्फ 3/4 बार मौन है) इसलिए मुझे लगता है कि इसे अंतरिक्ष के रूप में अनुवादित किया जाना चाहिए।

— शिकिरु

@ जॉय: विवरण आपके ऊपर है।

— एलेक्जेंड्रू

स्टैक ओवरफ्लो प्रश्न कोड गोल्फ के समान: मोर्स कोड ।

— dmckee

Answer 1

गोल्फस्क्रिप्ट - 74 वर्ण

यह उत्तर केवल अपरकेस और अंकों का समर्थन करता है। अक्षरों को नई कहानियों से अलग किया जाता है और शब्दों को 2 नई लाइनों से अलग किया जाता है

{." ETIANMSURWDKGOHVF L PJBXCYZQ"?)"?/'#! 08<>"@))10%=or 2base(;{!45+}%n}%

विश्लेषण

    {}% सरणी पर नक्शे की तरह सामान्य रूप से काम करता है
    । स्टैक पर चार की एक प्रति धक्का
    "ETIAN ..." यह अपरकेस वर्णों के लिए एक लुकअप तालिका है
    ? जैसे एक string.find स्ट्रिंग में चार का सूचकांक देता है
                  या -1 अगर यह नहीं मिला है (यानी यह एक अंक है)
    ) उस सूचकांक को बढ़ाएँ तो E => 2 T => 3 I => 4 आदि सूचना है कि यदि
                  char एक बड़ा अक्षर या स्थान नहीं है यह अब 0 है (गलत)
    "? / '# ...!" यह अंकों की एक खोज तालिका है। में इसका उपयोग किया जाएगा
                  अन्य लुकअप टेबल के लिए रिवर्स तरीका।
    @ हम उस प्रति को खींचते हैं जो हमने स्टैक के शीर्ष पर चार से बनाई है
    ))% 10 अभिसरण अंक को 2 में जोड़कर और 10 mod लेकर संख्या में परिवर्तित करें।
                  यह इस तरह से करना महत्वपूर्ण है क्योंकि सभी अपरकेस
                  पत्र इस कोड को भी हिट करते हैं, और हमें यह सुनिश्चित करने की आवश्यकता है कि वे गिर जाएं
                  सीमा में 0..9 या अगला चरण विफल हो जाएगा।
    = स्ट्रिंग से nth चार खींचो जैसे "हेलो" 1 = "ई" देता है
    या याद रखें कि अपरकेस लुकअप विफल होने पर हमारे पास 0 परिणाम है, इसलिए
                  डिजिट लुकअप का उपयोग किया जाएगा
    2बेस को बेस 2 में परिवर्तित करें ताकि E => [1 0], T => [1 1], I => [1 1 0] आदि।
    (), सूची के सामने वाले हिस्से को हटा दें और इसे दूर फेंक दें ताकि E => [0], T => [1]
    {! ४५ +}% प्रत्येक बिट को नकारात्मक करते हैं और ४५ जोड़ते हैं, इससे एससीआई मूल्य प्राप्त होता है। तथा -
    n न्यूलाइन प्रत्येक शब्द को अलग करता है। यदि आप चाहते हैं तो यह 32 हो सकता है
                  1 स्ट्रोक की लागत के लिए रिक्त स्थान के साथ शब्दों को अलग करें

गोल्फस्क्रिप्ट - 85 वर्ण

यह मेरे एसओ के उत्तर की अपेक्षा कम है, क्योंकि यहां आराम की आवश्यकताएं हैं। इनपुट अपरकेस / अंक और अंकन वर्ण "होना चाहिए।"? "

{." ETIANMSURWDKGOHVF!L!PJBXCYZQ"?)"UsL?/'#! 08<>"@".,?"58,48>+?=or
2base(;{!45+}%n}%

चूंकि यहां विराम चिह्न की आवश्यकता नहीं है, इसलिए मैं उत्तर को और भी छोटा कर सकता हूं

एसओ गोल्फस्क्रिप्ट से मेरा जवाब
- 107 वर्ण

इनपुट के अंत में newline समर्थित नहीं है, इसलिए कुछ इस तरह का उपयोग करें

echo -n Hello, Codegolfers| ../golfscript.rb morse.gs

पत्र एक विशेष मामला है और लोअरकेस में परिवर्तित हो जाता है और अपने बाइनरी पदों में क्रमबद्ध होता है। बाकी सब कुछ अनुवाद तालिका द्वारा किया जाता है

' '/{{.32|"!etianmsurwdkgohvf!l!pjbxcyzq"?)"UsL?/'#! 08<>"@".,?0123456789"?=or
2base(;>{'.-'\=}%' '}%}%'/'*

Comments

यहां आपके कोड ब्लॉक का क्रम जॉर्ज के यूजरस्क्रिप्ट को भ्रमित कर रहा है । क्या मैं आपको पुनर्व्यवस्थित करने के लिए परेशान कर सकता हूं? और मैं होता यह समझाया देखना पसंद है। मुझे निहित पेड़ मिलता है, लेकिन बाकी सब मेरे लिए एक रहस्य है।

— dmckee

@ मार्की, किया। जॉर्ज की स्क्रिप्ट पर ध्यान दिया गया कि मेरी गिनती एक के बाद एक थी, इसलिए मैंने यह भी तय किया कि

— gnibbler

विश्लेषण को देखने के लिए आवश्यक अप्रोच ... बू! विश्लेषण वह है जो उत्थान के लायक उत्तर देता है!

— निक लार्सन

@ ठीक है, मुझे लगता है कि यह उतना छोटा है जितना मैं इसे प्राप्त कर सकता हूं, इसलिए मुझे उस विश्लेषण पर काम करना होगा

— gnibbler

Answer 2

C # (213 वर्ण)

मुझे यकीन है कि यह अभ्यस्त लंबे समय तक नहीं रहेगा, लेकिन कम से कम मुझे पहले यहां तकनीक मिली थी!

class P{static void Main(string[] a){foreach(var t in a[0]){var c="";for(int i=" ETIANMSURWDKGOHVF L PJBXCYZQ  54 3   2       16       7   8 90".IndexOf(t);i>0;i/=2)c="-."[i--%2]+c;System.Console.Write(c+"  ");}}}

और पठनीय प्रारूप में:

class P
{
    static void Main(string[] a)
    {   
        foreach(var t in a[0])
        {
            var c="";
            for(int i=" ETIANMSURWDKGOHVF L PJBXCYZQ  54 3   2       16       7   8 90".IndexOf(t);i>0;i/=2)c="-."[i--%2]+c;
            System.Console.Write(c+" ");
        }
    }
}

एक संक्षिप्त विवरण के लिए, वर्णों का तार एक ढेर है जिसमें बाएं बच्चा एक बिंदु है और दायां बच्चा एक डैश है। पत्र का निर्माण करने के लिए, आप पीछे की ओर बढ़ते हैं और क्रम को उलट देते हैं।

Comments

यह सबसे अच्छा विचार है जिसे मैंने अब तक देखा है।

— अलेक्जेंड्रू

और फिर मैंने लिंक किए गए धागे को पढ़ा और देखा कि यह मूल से बहुत दूर है।

— निक लार्सन २ Nick

जब मैंने ETIAN...वहां देखा , तो मैंने मान लिया कि यह गोल्फस्क्रिप्ट के समान काम करता है, लेकिन आपके पास स्ट्रिंग की व्याख्या करने का एक अलग तरीका है। मुझे लगता है कि यह समतुल्य है, लेकिन मैं सूचकांक में 1 जोड़ता हूं और प्रमुख 1 "के बाद सभी अंकों के लिए डॉट्स और डैश प्राप्त करने के लिए बाइनरी प्रतिनिधित्व का उपयोग करता F=>18=>0b10010=>..-.

— हूं।

आपको स्थान की आवश्यकता नहीं हैString[] a

— Cyoce

Answer 3

tr + sed (347)

tr a-z A-Z | sed 's/0/--O/g;s/1/.-O/g;s/2/.J/g;s/3/..W/g;s/4/.V/g;s/5/.H/g;
 s/6/-.H/g;s/7/-B/g;s/8/-Z/g;s/9/--G/g;s/X/-U/g;s/V/.U/g;s/U/.A/g;
 s/Q/-K/g;s/K/-A/g;s/A/.T/g;s/J/.O/g;s/O/-M/g;s/Y/-W/g;s/W/.M/g;
 s/M/-T/g;s/T/- /g;s/H/.S/g;s/B/-S/g;s/S/.I/g;s/L/.D/g;s/Z/-D/g;
 s/D/-I/g;s/I/.E/g;s/C/-R/g;s/F/.R/g;s/R/.N/g;s/P/.G/g;s/G/-N/g;
 s/N/-E/g;s/E/. /g'

Comments

पाइप के आस-पास की जगह को भी खत्म किया जा सकता है ;-)

— यासिर अरसानुकेव

हां, मैं उन जगहों की गिनती नहीं कर रहा हूं, मैं सिर्फ उन्हें यहां स्पष्टता के लिए प्रिंट करता हूं :)

— इलेक्स

आप इसे बहुत छोटा करने के लिए ब्रेस विस्तार का उपयोग कर सकते हैं ( /g;s/बन जाता है ,- प्लस ओवरहेड का एक सा)।

— नब

@ नबब सुविचार।

— 18

आप tr छोड़ सकते हैं, yइसके बजाय sed की कमांड का उपयोग कर सकते हैं

— Hasturkun

Answer 4

हास्केल - 314 292 291 अक्षर

import Data.List
i=intercalate
m=i"       ".map(i" ".map(\c->words".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----."!!(head.findIndices(==c)$['a'..'z']++['0'..'9']))).words

---

एक अधिक उपयोगकर्ता पठनीय रूप:

tbl :: [String]
tbl = words ".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----."

lookupChar :: Char -> String
lookupChar c = tbl !! (fromJust . elemIndex c $ ['a'..'z'] ++ ['0'..'9'])

encWord :: String -> String
encWord = intercalate " " . map lookupChar

encSent :: String -> String
encSent = intercalate "       " . map encWord . words

नमूना रन:

*Main> m "welcome humans"
".-- . .-.. -.-. --- -- .       .... ..- -- .- -. ..."

दो अक्षरों के बीच एक एकल व्हाट्सएप और दो शब्दों के बीच सात व्हाट्सएप हैं।

Comments

बस @dmckee "कोड गोल्फ: मोर्स कोड" द्वारा संदर्भित प्रश्न की जाँच की और एक हास्केल संस्करण नहीं मिला। मुझे लगता है, 314 से कम संभव होगा।

— यासिर अरसानुकेव

fromJust.elemIndex cके रूप में लिखा जा सकता है head.findIndices(==c)। यह एक चरित्र अधिक है, लेकिन आप तब छुटकारा पा सकते हैं import Data.Maybe, इसलिए आप कुल 17 वर्णों को बचाएंगे। जब भी आप कॉल करते हैं, तो हर बार स्ट्रिंग के सामने के स्थान को हटाकर आप दो वर्णों को भी सहेज सकते हैं। और i=intercalateशुरुआत में कर और दो कॉल की जगह के intercalateसाथ एक और कुछ अक्षर i।

— sepp2k

@ sepp2k: अच्छा विचार है! धन्यवाद। मैंने साथ निभाया intercalateऔर अन्य 6 पात्रों को बचाया है! :-)

— यासिर अरसानुकेव 16

आप भी कर सकते हैं w=words, जो एक चरित्र को बचाता है अगर मैं गलत नहीं हूं। और के बजाय l c=...और map l, आपको क्या करना चाहिए map\c->...(आप भी लैम्ब्डा के आसपास कोष्ठक की जरूरत नहीं है वहाँ पहले से ही वैसे भी जब से एक बंद कोष्ठक बाद में)।

— 17

@ sepp2k: इनलाइनिंग l c=...ने मुझे 1 किरदार को बचाए रखा, लेकिन मैं इसे बिना परन्स के नहीं रख सका, जैसा कि map(\c->...)। जीएचसी संस्करण 6.12.3।

— यासिर अर्सानुकेव

Answer 5

परिशिष्ट भाग (310) (462) (414)(319) सहित (46) तालिका के लिए।

एक टर्नरी एन्कोडिंग के साथ संयुक्त संख्या और अक्षर। एक बाइट में 5 टर्नरी अंक फिट होते हैं! यह उन मूर्खतापूर्ण अंतर छोरों को समाप्त करता है, और विशेष-आवरण संख्या पूरी तरह से।

ASCII85 प्रत्येक तालिका का 1/3 भाग काटता है। और कोड को सरल करना (अंत में!) 400 के तहत वापस हो जाता है!

errordict/undefined{pop( )dup 0 4 3 roll put print{}}put<</*{{[exch/@ cvx]cvx 1
index 1 add}forall pop}def/C{<~#:VD<!AP07"A]ga#R),'7h?+2(./s-9e6~>*}def/#{load
exec}/P{print}0{}1{(.)P}2{(---)P}/S{( )P}48<~o'u/0b'A;]L7n~>* 65 C 97 C/@{5{dup
3 mod # S 3 idiv}repeat # S S S}>>begin{(%stdin)(r)file read not{exit}if #}loop

नमूना उत्पादन

Luser Dr00g!
। ---। । । । ---। । । । । ---। ---। । । ---। --- --- --- --- --- --- --- --- --- --- --- !

असहमति और टिप्पणी की। मुझे इस पर बहुत गर्व है। मुझे लगता है कि यह सुरुचिपूर्ण है, जिससे नंबर काम करते हैं। :)

%!
%Morse Code Translator (Simplified)

%if `load` signals /undefined in /#{load exec},
%  pop --load--,
%  print the char,
%  leave dummy object for `exec` to find
errordict/undefined{pop( )dup 0 4 3 roll put print{}}put

<<
%create int->proc pairs
%from initial int and string values
/*{{[exch/@ cvx]cvx 1 index 1 add}forall pop}def

%the alpha map is applied to Upper and Lower case
/C{<~#:VD<!AP07"A]ga#R),'7h?+2(./s-9e6~>*}def
65 C 97 C

%the number map
48<~o'u/0b'A;]L7n~>*

/#{load exec}  %execute a number
/P{print}

0{}       % 0: nop
1{(.)P}   % 1: '.' dit
2{(---)P} % 2: '---' dah
/S{( )P}  % S: space

%execute a morse sequence, from the table
/@{5{dup 3 mod # S 3 idiv}repeat # S S S}
>>begin

%read and execute each char from stdin
{(%stdin)(r)file read not{exit}if #}loop

टेबल (33) + (13) = (46)

यहां बताया गया है कि स्ट्रिंग्स टेबल को कैसे एनकोड करती है। प्रत्येक बाइट एक 5-अंकीय टर्नेरी संख्या का प्रतिनिधित्व करता है। और बाइट्स को ASCII85 में एन्कोड किया गया है (जो पोस्टस्क्रिप्ट स्वचालित रूप से डिकोड कर सकता है)।

%The Morse Table in Ternary Encoding
% 3  ^4 ^3 ^2 ^1 ^0
%    81 27  9  3  1                 Dec  Hex  dc ->ASCII85
%   ---------------                 ---  ---  ---
% A            2  1            6+1    7    7  7 256*41+256*50+256*14+
% B      1  1  1  2      27+ 9+3+2   41   29  d85%n85/d85%n85/d85%n85/d85%n85/n
% C      1  2  1  2      27+18+3+2   50   32  2 25 53 35 27  chr(x+33)
% D         1  1  2          9+3+2   14    E  #  :  V  D  <
% E               1              1    1    1
% F      1  2  1  1      27+18+3+1   49   31
% G         1  2  2          9+6+2   17   11  0 32 47 15 22
% H      1  1  1  1      27+ 9+3+1   40   28  !  A  P  0  7
% I            1  1            3+1    4    4
% J      2  2  2  1      54+18+6+1   79   4F
% K         2  1  2         18+3+2   23   17  1 32 60 70 64
% L      1  1  2  1      27+ 9+6+1   43   2B  "  A  ]  g  a
% M            2  2            6+2    8    8
% N            1  2            3+2    5    5
% O         2  2  2         18+6+2   26   1A  2 49 8 11 6
% P      1  2  2  1      27+18+6+1   52   34  #  R )  , '
% Q      2  1  2  2      54+ 9+6+2   71   47
% R         1  2  1          9+6+1   16   10
% S         1  1  1          9+3+1   13    D  22 71 30 10 17
% T               2              2    2    2   7  h  ?  +  2
% U         2  1  1         18+3+1   22   16
% V      2  1  1  1      54+ 9+3+1   67   43
% W         2  2  1         18+6+1   25   19  7 13 14 82 12
% X      2  1  1  2      54+ 9+3+2   68   44  (  .  /  s  -
% Y      2  2  1  2      54+18+3+2   77   4D  77 256*44+256*256*
% Z      1  1  2  2      27+ 9+6+2   44   2C  24 68 21 [23 36]
%                                              9  e  6 [ 8  E] (omit final 2)
% 0   2  2  2  2  2  162+54+18+6+2  242   F2
% 1   2  2  2  2  1  162+54+18+6+1  241   F1
% 2   2  2  2  1  1  162+54+18+3+1  238   EE  78 6 84 14 15
% 3   2  2  1  1  1  162+54+ 9+3+1  229   E5   o '  u  /  0
% 4   2  1  1  1  1  162+27+ 9+3+1  202   CA
% 5   1  1  1  1  1   81+27+ 9+3+1  121   79
% 6   1  1  1  1  2   81+27+ 9+3+2  122   7A  65 6 32 26 60
% 7   1  1  1  2  2   81+27+ 9+6+2  125   7D   b '  A  ;  ]
% 8   1  1  2  2  2   81+27+18+6+2  134   86  134 256*161+256*256*
% 9   1  2  2  2  2   81+54+18+6+2  161   A1  43 22 77 [50 40]
%                                              L  7  n [ S  I] (omit final 2)

Answer 6

रूबी, 161

d=proc{|x|x>1?d[x/2]+".-"[x&1]:' '}
$><<$<.gets.bytes.map{|i|
e=i>64?"-@B4*:68,?5</.7>E20+193ACD"[(i&95)-65]:i>47?"gWOKIHX`df"[i-48]:nil
e ?d[e.ord-40]:i.chr}*''

प्रत्येक अंक को एक एकल चार्ट में एनकोड करता है, जहां 1 डैश है, 0 एक डॉट बिट के रूप में अग्रणी 1 के साथ डॉट है (प्लस इसे प्रिंट करने योग्य रखने के लिए एक ऑफसेट है। इनपुट चार्ट का उपयोग लुकिंग सूचकांकों के रूप में उपयोग करने के लिए ASCII गणित का उपयोग करता है।

Answer 7

VB.NET, 233 बाइट्स

Module Module1
 Sub Main(a$())
   For Each c In a(0)
     Dim i = "ETIANMSURWDKGOHVF L PJBXCYZQ  54 3   2       16       7   8 90".IndexOf(c)
     If c <> " " And i >= 0 Then
       Console.Write("{0} ", Morse(i))
     Else
       Console.Write(c)
     End If
   Next
End Sub

Function Morse(i) As String
  Dim b = Math.Log(i) / Math.Log(2)
  Return (From m In MorseSeq(If(Double.IsInfinity(b), 0, b)) Order By m.Length)(i)
End Function

Function MorseSeq(i) As IEnumerable(Of String)
  Return If(i < 0, {}, From n In ".-" From m In MorseSeq(i - 1).DefaultIfEmpty
                       Select n & m)
End Function
End Module

वह अंतिम कार्य बुराई है।

कुछ सुधार संपादित करें ।

Function Morse(i) As String
  Return (From m In MorseSeq(i) Order By m.Length)(i)
End Function

Function MorseSeq(i) As IEnumerable(Of String)
  Return If(i=0,{".","-"},From n In".-"From m In MorseSeq(i>>1) Select n & m)
End Function

Comments

मैंने इसे +1 करने का निर्णय लिया क्योंकि मैं कभी भी याद नहीं रख सकता कि वीबीईटी को गोल्फ के लिए इस्तेमाल किया जाता है।

— mbomb007

Answer 8

लिस्प ( 532 466 वर्ण)

(loop(princ(let((c(read-char)))(case c(#\a".- ")(#\b"-... ")(#\c"-.-. ")(#\d"-.. ")(#\e". ")(#\f"..-. ")(#\g"--. ")(#\h".... ")(#\i".. ")(#\j".--- ")(#\k"-.- ")(#\l".-.. ")(#\m"-- ")(#\n"-. ")(#\o"--- ")(#\p".--. ")(#\q"--.- ")(#\r".-. ")(#\s"... ")(#\t"- ")(#\u"..- ")(#\v"...- ")(#\w".-- ")(#\x"-..- ")(#\y"-.-- ")(#\z"--.. ")(#\1".---- ")(#\2"..--- ")(#\3"...-- ")(#\4"....- ")(#\5"..... ")(#\6"-.... ")(#\7"--... ")(#\8"---.. ")(#\9"----. ")(#\0"----- ")(t c)))))

यह कम केस लेटर्स को एनकोड करता है, और मोर्स कोड सीक्वेंस एक ट्रेलिंग स्पेस के साथ प्रिंट होते हैं

Answer 9

जावा में, 475 वर्ण।

    import java.io.*;class M{public static void main(String[]b){String s,t="-",m=t+t,o=m+t,z="",e=".",i=e+e,p=t+e,a=e+t,n=i+e,c[]={o+m,a+o,i+o,n+m,n+a,n+i,p+n,m+n,o+i,o+p,z,z,z,z,z,z,z,a,t+n,p+p,t+i,e,i+p,m+e,n+e,i,e+o,p+t,a+i,m,p,o,a+p,m+a,e+p,n,t,i+t,n+t,e+m,p+a,p+m,m+i};BufferedReader r=new BufferedReader(new InputStreamReader(System.in));try{s=r.readLine().toUpperCase();for(int j=48;j<91;j++)s=s.replace(z+(char)j,c[j-48]+" ");System.out.println(s);}catch(Exception x){}}}

Az, AZ और 0-9 का अनुवाद करता है।

संपादित करें:

या 447 वर्णों में, अगर आपको अनुवाद के बाद जावा को कोई त्रुटि नहीं आती है।

    import java.io.*;class M{static{String s,t="-",m=t+t,o=m+t,z="",e=".",i=e+e,p=t+e,a=e+t,n=i+e,c[]={o+m,a+o,i+o,n+m,n+a,n+i,p+n,m+n,o+i,o+p,z,z,z,z,z,z,z,a,t+n,p+p,t+i,e,i+p,m+e,n+e,i,e+o,p+t,a+i,m,p,o,a+p,m+a,e+p,n,t,i+t,n+t,e+m,p+a,p+m,m+i};BufferedReader r=new BufferedReader(new InputStreamReader(System.in));try{s=r.readLine().toUpperCase();for(int j=48;j<91;j++)s=s.replace(z+(char)j,c[j-48]+" ");System.out.println(s);}catch(Exception x){}}}

Answer 10

पर्ल 6 (238)

my%h="A.-B-...C-.-.D-..E.F..-.G--.H....I..J.---K-.-L.-..M--N-.O---P.--.Q--.-R.-.S...T-U..-V...-W.--X-..-Y-.--Z--..0-----1.----2..---3...--4....-5.....6-....7--...8---..9----.".split(/<wb>/)[1..72];while$*IN.getc ->$c{print %h{$c.uc}||$c}

पठनीय संस्करण

# Split string on word breaks to create a hash
# I get an extra token at the beginning and end for some reason
# [1..72] is a slice without the extra pieces
my %h = "A.-B-...C-.-.D-..E.F..-.G--.H....I..J.---K-.-L.-..M--N-.O---P.--.Q--.-R.-.S...T-U..-V...-W.--X-..-Y-.--Z--..0-----1.----2..---3...--4....-5.....6-....7--...8---..9----."
    .split(/<wb>/)[1..72];

# For each character in STDIN, print either the looked up value, or itself
while $*IN.getc -> $c {
    print %h{$c.uc} || $c;
}

Comments

"मुझे किसी कारण से शुरुआत और अंत में एक अतिरिक्त टोकन मिलता है": मुझे पर्ल 6 नहीं पता है, लेकिन मुझे लगता है कि यह होगा क्योंकि पहले शब्द सीमा से पहले और पिछले एक के बाद खाली स्ट्रिंग मेल खाता है।

— msh210

Answer 11

सेड, 159 बाइट्स

s/.*/\L&/
s/[02]/&-/g
s/[89]/&./g
:
s/[b-ilnprsz5-9]/&./g
s/[ajkmoqt-y0-4]/&-/g
y/abcdefghijklmnopqrstuvwxyz0123456789/edri umsewnrttmwkai isadkgojuvhhbzoo/
t

हम पूरी लाइन डाउनकेस करके शुरू करते हैं (क्योंकि yकेस- इनसेन्सिटिव रूपांतरण नहीं कर सकते हैं); 10 बाइट घटाना अगर हम केवल लोअर केस इनपुट संभाल रहे हैं। फिर हम अंक preprocess 0, 2, 8और 9उनके अंतिम प्रतीकों फेंकना।

लूप प्रत्येक इनपुट चरित्र के लिए अंतिम प्रतीक उत्पन्न करता है, फिर अगले पुनरावृत्ति के लिए प्रत्येक वर्ण का अनुवाद करता है। यह द्विबीजपत्री खोज तालिका के चलने के बराबर है विकिपीडिया लेख में दर्शाई गई ; जिन अंकों के लिए विशेष उपचार की आवश्यकता होती है, वे माता-पिता के लिए देखे जा सकते हैं जो हमारे ASCII वर्णमाला में नहीं हैं।

जब सभी वर्ण समाप्ति स्थान ('ई' या 'टी' के बाद) तक पहुँच जाते हैं तो लूप समाप्त हो जाता है।

उदाहरण के लिए, पत्र kको तीन पास में बदल दिया गया है:

1. k=> k-=>n-
2. n-=> n.-=>t.-
3. t.-=> t-.-=>-.-

Answer 12

अजगर 3, 99 वर्ण

lambda a:print(*[str(ord('ӆҼzࢤpࢮ࠿yࡊoࡀѡÔÞÝࢭÓӅһѢ'[ord(c)%32])).translate(' -.'*18)for c in a])

ऊपरी और निचले हिस्से पर काम करता है।

Answer 13

सी, 162 160 चार्ट

char M[256] = "_^\\XP@ACGO       &15)\"4+0$>-2'%/6;*(#,8.9=3", v;
main(c) {
  for (;
         c = getchar(), v = M[c + 208 & 255] - 32, ~c;
         putchar(v-1? c : 32))
    for (; v > 1; v /= 2) putchar(".-"[v & 1]);
}

(गैर-महत्वपूर्ण व्हाट्सएप छीनने के साथ, कोई अनुगामी न्यूलाइन नहीं)

char M[256]="_^\\XP@ACGO       &15)\"4+0$>-2'%/6;*(#,8.9=3",v;main(c){for(;c=getchar(),v=M[c+208&255]-32,~c;putchar(v-1?c:32))for(;v>1;v/=2)putchar(".-"[v&1]);}

Mएक लुकअप टेबल है, जहां पात्रों के बिटपैटर्न मोर कोड में डॉट्स और डैश के अनुरूप होते हैं। [0-9A-Z]इस तालिका का उपयोग करके वर्णों को मोर्स में डिकोड किया जाता है (मोर्स कोड के बाद संलग्न एक स्थान के साथ), अन्य पात्रों को बस बदल दिया जाता है।

नमूना रन:

HELLO WORLD
.... . .-.. .-.. ---  .-- --- .-. .-.. -.. 
hello world
hello world
ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
.- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----. 

Comments

यह 162 चार्ट नहीं है ... कृपया गोल्फ संस्करण को पोस्ट करें।

— साइओस

@Cyoce क्षमा करें, मैंने गैर-महत्वपूर्ण व्हाट्सएप को नहीं छीना है क्योंकि यह एक उबाऊ यांत्रिक प्रक्रिया है और केवल स्रोत कोड को पढ़ना कठिन बनाता है, जो कि (पीपीसीजी पर) काफी मानक अभ्यास है। ऐसे व्हाट्सएप वाले वर्जन को आपके लिए छीन लिया गया :)।

— फायरफली

144 बाइट्स

— छत

Answer 14

पर्ल (489 वर्ण)

%c=("A"=>".-","B"=>"-...","C"=>"-.-.","D"=>"-..","E"=>".","F"=>"..-.","G"=>"--.","H"=>"....","I"=>"..","J"=>".---","K"=>"-.-","L"=>".-..","M"=>"--","N"=>"-.","O"=>"---","P"=>".--.","Q"=>"--.-","R"=>".-.","S"=>"...","T"=>"-","U"=>"..-","V"=>"...-","W"=>".--","X"=>"-..-","Y"=>"-.--","Z"=>"--..",1=>".----",2=>"..---",3=>"...--",4=>"..---",5=>".....",6=>"-....",7=>"--...",8=>"---..",9=>"----.",0=>"-----");while(<>){foreach(split(//)){if(exists($c{$_})){printf"%s ",$c{$_}}else{print"$_"}}}

कमांड लाइन के माध्यम से ऐसा किया जा सकता है।

$ perl -e '$CODE' < textfile

संपादित करें: यह इंगित करने के लिए धन्यवाद @tobyodavies कि मेरे मूल समाधान में अनुवाद पीछे था!

Comments

आप इसे 286 वर्णों तक प्राप्त कर सकते हैं:%c=qw(A .- B -... C -.-. D -.. E . F ..-. G --. H .... I .. J .--- K -.- L .-.. M -- N -. O --- P .--. Q --.- R .-. S ... T - U ..- V ...- W .-- X -..- Y -.-- Z --.. 1 .---- 2 ..--- 3 ...-- 4 ..--- 5 ..... 6 -.... 7 --... 8 ---.. 9 ----. 0 -----);while(<>){print($c{$_}||$_)for split//}

— msh210 20

Answer 15

PHP, 474 वर्ण

<?$a=strtoupper(fgets(STDIN));$m=array(65=>".-",66=>"-...",67=>"-.-.",68=>"-..",69=>".",70=>"..-.",71=>"--.",72=>"....",73=>"..",74=>".---",75=>"-.-",76=>".-..",77=>"--",78=>"-.",79=>"---",80=>".--.",81=>"--.-",82=>".-.",83=>"...",84=>"-",85=>"..-",86=>"...-",87=>".--",88=>"-..-",89=>"-.--",90=>"--..",49=>".----",50=>"..---",51=>"...--",52=>"..---",53=>".....",54=>"-....",55=>"--...",56=>"---..",57=>"----.",48=>"-----",32=>" ");while($i++<strlen($a))echo$m[ord($a[$i])];

सभी इनपुट अपरकेस में हैं, तो इसके 462 अक्षर:

<?$a=fgets(STDIN);$m=array(65=>".-",66=>"-...",67=>"-.-.",68=>"-..",69=>".",70=>"..-.",71=>"--.",72=>"....",73=>"..",74=>".---",75=>"-.-",76=>".-..",77=>"--",78=>"-.",79=>"---",80=>".--.",81=>"--.-",82=>".-.",83=>"...",84=>"-",85=>"..-",86=>"...-",87=>".--",88=>"-..-",89=>"-.--",90=>"--..",49=>".----",50=>"..---",51=>"...--",52=>"..---",53=>".....",54=>"-....",55=>"--...",56=>"---..",57=>"----.",48=>"-----",32=>" ");while($i++<strlen($a))echo$m[ord($a[$i])];

Comments

कुछ छोटी-मोटी तरकीबों से जिन्हें कम किया जा सकता है:<?$a=strtoupper(fgets(STDIN));$m=array(65=>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)+array(48=>22222,12222,11222,11122,11222,11111,21111,22111,22211,22221)+array(32=>' ');while($a[$i++])echo strtr($m[ord($a[$i])],12,'.-');

— manatwork

Answer 16

05AB1E , 81 बाइट्स (गैर-प्रतिस्पर्धात्मक)

Çvy©58‹i®58-•6V%·,Õo•2B5ôsè}®64›i®64-•4…·]ÑUZ“×\ó$9™¹“ÌLÈÎ%´•3B4ôsè}"012"".- "‡})

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

पत्र पैटर्न को आधार -3 में परिवर्तित करें, संख्या पैटर्न को आधार -2 तक, पीरियड और हाइजीन को प्राप्त करने के लिए शून्य अनुक्रमित एससिआई लिप्यंतरण का उपयोग करें। लोअरकेस पर काम नहीं करता है।

Answer 17

जेली , 50 बाइट्स

“¤⁵©ḤọḌṄ’B‘s5;“ḄẇɗÞI/QẊṂjỵr’Œ?ḃ2¤ṖṖƊ⁺ị⁾.-;
ØBiịÇ)K

एक पूर्ण कार्यक्रम पायथन स्वरूपित स्ट्रिंग को एक कमांड लाइन तर्क के रूप में स्वीकार करता है जो अंतरिक्ष सीमांकित आउटपुट प्रिंट करता है।

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

Answer 18

पॉवर्सशेल, 142 बाइट्स

-join($args|% t*y|%{if($_-match'\w'){for($d='ihfbZJKMQY+mazzy+0;?3,>5:.H7<1/9@E42-6B8CG='[$_-48]-42;$d-1){'.-'[$d%2]
$d=$d-shr1}' '}else{$_}})

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

-join(
    $args|% toCharArray|%{
        if($_-match'\w'){
            for($d='ihfbZJKMQY+mazzy+0;?3,>5:.H7<1/9@E42-6B8CG='[$_-48]-42;$d-1){
                '.-'[$d%2]
                $d=$d-shr1
            }
            ' '
        }else{
            $_
        }
    }
)

}

@(
    ,("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----. ")
    ,("HELLO WORLD", ".... . .-.. .-.. ---  .-- --- .-. .-.. -.. ")
    ,("#$%^&","#$%^&")
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result"
}

आउटपुट:

True: .- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----.
True: .... . .-.. .-.. ---  .-- --- .-. .-.. -..
True: #$%^&

नोट: आउटपुट में अनुगामी स्थान होते हैं।

Comments

+mazzy+कुछ

— गन्दा

Answer 19

एपीएल (एनएआरएस), 71 वर्ण, 142 बाइट्स

{36≥y←⍵⍳⍨⎕A,⎕D:'•-'[0∼⍨⌽(5⍴3)⊤y⊃∊(2⍴256)∘⊤¨⎕AV⍳'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ᥃䴫쩸穼蚠']⋄⍵}

परीक्षा:

  q←{36≥y←⍵⍳⍨⎕A,⎕D:'•-'[0∼⍨⌽(5⍴3)⊤y⊃∊(2⍴256)∘⊤¨⎕AV⍳'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ᥃䴫쩸穼蚠']⋄⍵}
  q¨'0123456789'
----- •---- ••--- •••-- ••••- ••••• -•••• --••• ---•• ----• 
  q¨"HELLO WORLD"
•••• • •-•• •-•• ---   •-- --- •-• •-•• -••  

प्रत्येक अक्षर एक स्थान से अलग हो जाता है, प्रत्येक शब्द 3 स्थानों से अलग हो जाएगा। तालिका अल्फ़ान्यूमेरिक स्ट्रिंग ⎕A,⎕Dऔर 16bit वर्णों पर निर्मित होती है, जिसे 'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ᥃䴫쩸穼蚠'वे 8 वर्णों में विभाजित करते हैं जो प्रत्येक आधार 3 में उलटे अंकों के साथ परिवर्तित होते हैं।

Answer 20

05AB1E , 52 बाइट्स

Ažh«•1Ju&àøΘn₆δβαLmSÂZΘ=+BD1
 ÷ΓùwÒмVšh•… .-ÅвJ#ðδJ‡

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

    •1Ju&àøΘn₆δβαLmSÂZΘ=+BD1
    ÷ΓùwÒмVšh•                push compressed number 
              … .-ÅвJ#        convert to custom base " .-"
                      ðδJ     append a space to each morse code
Ažh«                     ‡    transliterate

Answer 21

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

इन दोनों संस्करणों के लिए, वे किसी भी वर्ण के बीच रिक्त स्थान डालेंगे। धर्मान्तरित 0-9 और az (केस असंवेदनशील) परिवर्तित होते हैं। एक स्थान 3 में परिवर्तित हो जाता है।

s=>s.split("").map(e=>isNaN(d=parseInt(e.toLowerCase(),36))?e:`_OGCA@PX\\^\r\n  `.charCodeAt(d).toString(2).substr(1).split("").map(e=>".-"[e]).join("")).join(" ")

\nएक नया चरित्र ( 0x0a) के साथ बदलें । यह एसई की वजह से गैर-वर्णों के एक जोड़े को नहीं दिखा रहा है। एडिट मोड में जाने से पता चलता है।

यहाँ हेक्स है:

73 3d 3e 73 2e 73 70 6c 69 74 28 22 22 29 2e 6d 61 70 28 65 3d 3e 69 73 4e 61 4e 28 64 3d 70 61 72 73 65 49 6e 74 28 65 2e 74 6f 4c 6f 77 65 72 43 61 73 65 28 29 2c 33 36 29 29 3f 65 3a 60 5f 4f 47 43 41 40 50 58 5c 5c 5e 05 18 1a 0c 02 12 0e 10 04 17 5c 72 14 07 06 0f 16 1d 0a 08 03 09 11 0b 19 1b 1c 60 2e 63 68 61 72 43 6f 64 65 41 74 28 64 29 2e 74 6f 53 74 72 69 6e 67 28 32 29 2e 73 75 62 73 74 72 28 31 29 2e 73 70 6c 69 74 28 22 22 29 2e 6d 61 70 28 65 3d 3e 22 2e 2d 22 5b 65 5d 29 2e 6a 6f 69 6e 28 22 22 29 29 2e 6a 6f 69 6e 28 22 20 22 29

Ungolfed

s=>            //declare anonymous function
s.split("")    //split into array of characters
.map(          //for each character
e=>            //declare anonymous function
 isNaN(        //is the character not in range 0-9a-zA-Z
  d=parseInt(e.toLowerCase(),36)
               //take it as base 36(digits are 0-9a-z) and assign to d
 )?e:          //if outside range, return as is
 `_OGCA@PX\\^\r\n  `
               //table of the morse code as binary as code point with leading 1
 .charCodeAt(d)//get the corresponding code
 .toString(2)  //convert to binary, 0=., 1=-, with an extra 1 bit
 .substr(1)    //remove the extra 1 bit
 .split("")    //split into each bit
 .map(         //for each bit
  e=>          //declare anonymous function
  ".-"         //the corresponding symbol for bits
  [e]          //get it
 )
 .join("")     //join the bits
)
.join(" ")     //join the characters with a space between each character

पठनीय संस्करण, 234 बाइट्स

s=>s.split("").map(e=>isNaN(d=parseInt(e.toLowerCase(),36))?e:[95,79,71,67,65,64,80,88,92,94,5,24,26,12,2,18,14,16,4,23,13,20,7,6,15,22,29,10,8,3,9,17,11,25,27,28][d].toString(2).substr(1).split("").map(e=>".-"[e]).join("")).join(" ")

Ungolfed

s=>            //declare anonymous function
s.split("")    //split into array of characters
.map(          //for each character
e=>            //declare anonymous function
 isNaN(        //is the character not in range 0-9a-zA-Z
  d=parseInt(e.toLowerCase(),36)
               //take it as base 36(digits are 0-9a-z) and assign to d
 )?e:          //if outside range, return as is
 [95,79,71,67,65,64,80,88,92,94,
   5,24,26,12, 2,18,14,16, 4,23,
  13,20, 7, 6,15,22,29,10, 8, 3,
   9,17,11,25,27,28]
               //table of the morse code as binary with leading 1
 [d]           //get the corresponding code
 .toString(2)  //convert to binary, 0=., 1=-, with an extra 1 bit
 .substr(1)    //remove the extra 1 bit
 .split("")    //split into each bit
 .map(         //for each bit
  e=>          //declare anonymous function
  ".-"         //the corresponding symbol for bits
  [e]          //get it
 )
 .join("")     //join the bits
)
.join(" ")     //join the characters with a space between each character

Answer 22

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

मैंने अल्फ़ान्यूमेरिक्स की एक स्ट्रिंग बनाई, जैसे कि स्ट्रिंग में उनका प्लेसमेंट उनके मोर्स कोड प्रतिनिधित्व का वर्णन करता है। मूल रूप से मैं बाइनरी का उपयोग करने जा रहा था, लेकिन 01जैसा होगा वैसा ही होगा 1। इसलिए मैंने टर्नरी का इस्तेमाल किया - = 1और . = 2। इस प्रकार चरित्र इस स्ट्रिंग cमें सूचकांक 1121में है, इसका मोर्स कोड प्रतिनिधित्व है --.-।

• बाइट्स को बचाने के लिए, मैंने स्पेस, डैश और डॉट के लिए वैरिएबल बनाए।
• फिर मैंने व्हॉट्सएप को कम करने के लिए एक जोड़े की जगह बयानों का उपयोग करके 'डिकोडर' स्ट्रिंग को हार्ड कोडित किया।
• फ़ंक्शन का हिस्सा एक इंडेक्स को टर्नेरी अंकों की एक सरणी में परिवर्तित करता है
• अन्य भाग फ़ंक्शन एक स्ट्रिंग लेता है और प्रत्येक अक्षर को अक्षरों और 7 (4 अतिरिक्त) शब्दों के बीच 3 रिक्त स्थान के साथ मोर्स कोड में परिवर्तित करता है

q,d,D=" .-"
s=" TE MN AI.OG KD.WR US-.QZ.YC XB- JP  L. F VH---.09  8..7--  6---.1--  2..3  45".replace(D,d*3).replace(d,q*4)
lambda n:''.join(''.join([0,D,d][i]for i in [s.index(c)//3**i%3 for i in range(5)if s.index(c)//3**i!=0][::-1])+q*3 if c!=q else q*4for c in n.upper())

दोहन ​​परीक्षण

print(f("Hi")=="....   ..   ")
print(f("Hello")=="....   .   .-..   .-..   ---   ")
print(f("Hello World")=="....   .   .-..   .-..   ---       .--   ---   .-.   .-..   -..   ")
print(f("To be or not to be")=="-   ---       -...   .       ---   .-.       -.   ---   -       -   ---       -...   .   ")
print(f("3 14 15")=="...--       .----   ....-       .----   .....   ")

अद्यतन करें

• -9 [१६-०५-०९] मुख्य समारोह में टर्नरी गणना समारोह को शामिल किया

[नोट: हमेशा सफेद स्थान पीछे रहता है लेकिन सफेद स्थान एक ठहराव का प्रतिनिधित्व करता है, इसलिए मैं अतिथि हूं जो ठीक है ]

Answer 23

PHP, 157 150 157 बाइट्स

for(;$d=ord($c=$argv[1][$i++]);)echo ctype_alnum($c)?strtr(substr(decbin(ord($d>64?".CTRH@ZF\DUGXABEVOJL?K[ISQP"[$d&31]:"]muy{|ld`^"[$c])-48),1),10,".-"):$c;

पहले कमांड लाइन तर्क से इनपुट लेता है। अक्षरों के बीच कोई ठहराव नहीं। साथ दौड़ो-nr ।

टूट - फूट

for(;$d=ord($c=$argv[1][$i++]);)    # loop through input characters
    echo                                # print ...
    ctype_alnum($c)                     # if char is alphanumeric:
    ?   strtr(
        substr(
        decbin(                         
            ord($d>64                   # 1. map char to char-encoded morse
            ?".CTRH@ZF\DUGXABEVOJL?K[ISQP"[$d&31]
            :"]muy{|ld`^"[$c]
            )-60                        # 2. subtract 60 from ordinal value
        )                               # 3. decbin: convert to base 2
        ,1)                             # 4. substr: skip leading `1`
        ,10,".-")                       # 5. strtr: translate binary digits to dash/dot
    :$c;                                # not alphanumeric: no conversion

बीटिंग जावास्क्रिप्ट, पायथन 2, सी, रूबी और सेड। में खुश हूँ।

चौथा चरण: बिना उपयोग किए लोअरकेस वर्णों को संभालने के लिए मैपिंग को अन-मर्ज करना strtoupper।

पिछला संस्करण:

लोअरकेस अक्षरों के लिए असफल; +12 बाइट्स को ठीक करने के लिए: $argv[1]साथ बदलें strtoupper($argv[1])।

सरल स्ट्रिंग अनुवाद, 254 बाइट्स

<?=strtr($argv[1],["-----",".----","..---","...--","....-",".....","-....","--...","---..","----.",A=>".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]);

सीधे आगे: एक बार में पूरे स्ट्रिंग का अनुवाद करता है, चरित्र को मोर्स कोड।
फ़ाइल को निष्पादित या बदलने के लिए सहेजें<?= साथ echoचलाने और साथ चलाने के-r ।

मॉर्स कोड की दशमलव व्याख्या, 184 बाइट्स (-70)

for(;""<$c=$argv[1][$i++];)echo($m=[32,48,56,60,62,63,47,39,35,33,A=>6,23,21,11,3,29,9,31,7,24,10,27,4,5,8,25,18,13,15,2,14,30,12,22,20,19][$c])?strtr(substr(decbin($m),1),10,".-"):$c;

पहला गोल्फिंग चरण: मोर्स कोड एक अतिरिक्त अग्रणी के साथ बाइनरी में एन्कोड किया गया 1 करता है जिससे लीडिंग जीरो को संरक्षित किया जा सकता है। पात्रों के माध्यम से लूप्स और एक-एक करके उनका अनुवाद करते हैं। साथ चलाना -nr।

दशमलव, चरित्र को 157 बाइट्स के लिए एन्कोड किया गया (-27)

for(;""<$c=$argv[1][$i++];)echo ctype_alnum($c)?strtr(substr(decbin(ord("@"<$c?"CTRH@ZF\DUGXABEVOJL?K[ISQP"[ord($c)-65]:"]muy{|ld`^"[$c])-60),1),10,".-"):$c;

दूसरा गोल्फिंग: दशमलव मान में 60 जोड़ा गया और चरित्र को एन्कोड किया गया।

विलय मानचित्रण, 150 बाइट्स (-7)

for(;""<$c=$argv[1][$i++];)echo ctype_alnum($c)?strtr(substr(decbin(ord("]muy{|ld`^8901234CTRH@ZF\DUGXABEVOJL?K[ISQP"[ord($c)-48])-60),1),10,".-"):$c;

तीसरा गोल्फिंग: अंकों और अक्षरों के लिए एकल स्ट्रिंग में मर्जिंग मैपिंग।

Answer 24

SmileBASIC, 194 190 बाइट्स

INPUT S$WHILE""<S$B=INSTR(" ETIANMSURWDKGOHVFLPJBXCYZQ  54 3   2       16       7   8 90",S$[0])+1IF B THEN S=LOG(B,2)FOR I=0TO S-1?"._"[B-(1<<S)AND S>>I||0];:NEXT?" ";
?SHIFT(S$)*!B;
WEND