Schreiben Sie das kürzeste Programm, um die Standardeingabe in Morsecode umzuwandeln . Zeichen, die nicht in der Tabelle enthalten sind, sollten so gedruckt werden, wie sie sind.

Golfscript - 74 Zeichen

Diese Antwort unterstützt nur Großbuchstaben und Ziffern. Die Buchstaben werden durch Zeilenumbrüche und die Wörter durch zwei Zeilenumbrüche getrennt

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

Analyse

    {}% funktioniert wie gewohnt wie eine Karte über dem Array
    . Schieben Sie eine Kopie des Zeichens auf den Stapel
    "ETIAN ..." Dies ist eine Nachschlagetabelle für Großbuchstaben
    ? Wie ein String. Find gibt den Index des Zeichens im String zurück
                  oder -1 wenn es nicht gefunden wird (dh es ist eine Ziffer)
    ) diesen Index erhöhen, so dass E => 2 T => 3 I => 4 usw. feststellen, dass, wenn die
                  char ist kein Großbuchstabe oder Leerzeichen, dies ist jetzt 0 (False)
    "? / '#! ..." Dies ist eine Nachschlagetabelle für die Ziffern. es wird in der verwendet werden
                  Umgekehrter Weg zur anderen Nachschlagetabelle.
    @ Ziehe die Kopie, die wir vom Saibling gemacht haben, nach oben auf den Stapel
    ))% 10 wandle die ASCII-Ziffer in eine Zahl um, indem du 2 addierst und Mod 10 nimmst.
                  Es ist wichtig, dies so zu tun, weil alle Großbuchstaben
                  Buchstaben treffen auch diesen Code, und wir müssen sicherstellen, dass sie fallen
                  im Bereich 0..9 oder der nächste Schritt schlägt fehl.
    = ziehe das n-te Zeichen aus dem String zB "Hallo" 1 = gibt "e"
    oder denken Sie daran, wenn die Suche in Großbuchstaben fehlschlägt, haben wir das Ergebnis 0
                  Die Ziffernsuche wird verwendet
    2base konvertiere zu Basis 2, also E => [1 0], T => [1 1], I => [1 0 0] usw.
    (; Pop die Vorderseite der Liste und werfen Sie es weg, so dass E => [0], T => [1]
    {! 45 +}% negieren jedes Bit und addieren 45, dies ergibt den ASCII-Wert von. und -
    n Newline trennt jedes Wort. Dies könnte 32 sein, wenn Sie wollten
                  Trennen Sie die Wörter mit Leerzeichen für 1 Strich

Golfscript - 85 Zeichen

Dies ist aufgrund der lockeren Anforderungen hier kürzer als meine SO-Antwort. Die Eingabe muss in Großbuchstaben / Ziffern erfolgen und die Interpunktionszeichen ".,?"

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

Da hier nicht einmal die Zeichensetzung erforderlich ist, kann ich die Antwort noch weiter kürzen

Meine Antwort von SO
Golfscript - 107 Zeichen

Zeilenumbruch am Ende der Eingabe wird nicht unterstützt, verwenden Sie also so etwas

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

Buchstaben sind Sonderfälle und werden in Kleinbuchstaben umgewandelt und in ihren Binärpositionen angeordnet. Alles andere erledigt eine Übersetzungstabelle

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

C # (213 Zeichen)

Ich bin sicher, das wird nicht lange dauern, aber zumindest habe ich die Technik zuerst hier!

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+"  ");}}}

Und in lesbarem Format:

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+" ");
        }
    }
}

Für eine kurze Erklärung ist die Zeichenfolge ein Haufen, in dem das linke Kind ein Punkt und das rechte Kind ein Bindestrich ist. Um den Brief zu erstellen, müssen Sie die Reihenfolge rückgängig machen und rückgängig machen.

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'

Haskell - 314 292 291 Zeichen

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

Eine benutzerfreundlichere Form:

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

Probelauf:

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

Zwischen zwei Buchstaben befindet sich ein Leerzeichen, zwischen zwei Wörtern ein Leerzeichen von sieben.

Nachsatz (310) (462) (414)(319) einschließlich (46) für die Tabelle.

Kombinierte Zahlen und Buchstaben mit ternärer Kodierung. 5 ternäre Ziffern passen in ein Byte! Dies eliminiert diese albernen Differenzschleifen und Sondergehäusenummern vollständig.

ASCII85 schneidet 1/3 jeder Tabelle. Und die Vereinfachung des Codes (endlich!) Kommt unter 400 zurück!

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

Beispielausgabe

Luser Dr00g!
. ---. . . . ---. . . . . ---. ---. . . ---. --- --- --- --- --- --- --- --- --- --- --- ---. !

Ungolfed und kommentiert. Darauf bin ich sehr stolz. Ich finde es elegant, die Zahlen die Arbeit machen zu lassen. :)

%!
%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

Die Tabellen (33) + (13) = (46)

So codieren die Zeichenfolgen die Tabelle. Jedes Byte steht für eine 5-stellige ternäre Zahl. Und die Bytes werden weiter in ASCII85 codiert (welches Postscript automatisch decodieren kann).

%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)

Rubin, 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}*''

Kodiert jede Ziffer in ein einzelnes Zeichen, wobei 1 ein Strich, 0 ein Punkt und eine führende 1 ein Markierungsbit ist (zuzüglich eines Versatzes, um die Druckbarkeit zu gewährleisten). Verwendet ASCII-Mathematik, um die Eingabezeichen als Nachschlageindizes zu verwenden.

VB.NET, 233 Bytes

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

Diese letzte Funktion ist böse.

Bearbeiten Einige Verbesserungen.

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

Lisp ( 532 466 Zeichen)

(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)))))

Dadurch werden Kleinbuchstaben codiert und Morsecodesequenzen mit einem nachgestellten Leerzeichen gedruckt

In Java 475 Zeichen.

    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){}}}

Übersetzt az, AZ und 0-9.

Bearbeiten:

Oder in 447 Zeichen, wenn Sie nichts dagegen haben, dass Java nach der Übersetzung einen Fehler auslöst.

    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){}}}

Perl6 (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}

Lesbare Version

# 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;
}

sed, 159 bytes

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

Wir fangen damit an, die gesamte Zeile zu verkleinern (da ykeine Konvertierungen ohne Berücksichtigung der Groß- und Kleinschreibung möglich sind). Subtrahieren Sie 10 Bytes, wenn nur Kleinbuchstaben eingegeben werden sollen. Dann vorverarbeiten wir die Ziffern 0, 2, 8und 9ihre endgültige Symbole zu emittieren.

Die Schleife generiert das letzte Symbol für jedes eingegebene Zeichen und übersetzt dann jedes Zeichen für die nächste Iteration. Dies ist gleichbedeutend mit dem Durchlaufen der dichotomen Suchtabelle , die im Wikipedia-Artikel angezeigt wird. Bei den Ziffern, die einer besonderen Behandlung bedurften, handelt es sich um Eltern, die nicht in unserer ASCII-Alphanumerik enthalten sind.

Die Schleife wird beendet, wenn alle Zeichen das Abschlusszeichen erreicht haben (nach 'e' oder 't').

Zum Beispiel wird der Brief kin drei Durchgängen transformiert:

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

Python 3, 99 Zeichen

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

Funktioniert in Groß- und Kleinschreibung.

C 162-160 Zeichen

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]);
}

(Ohne nicht signifikante Leerzeichen, keine nachgestellte Zeile)

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]);}

Mist eine Nachschlagetabelle, in der die Bitmuster der Zeichen Punkten und Strichen im Morsecode entsprechen. Zeichen [0-9A-Z]werden mit dieser Tabelle zum Morsen dekodiert (mit einem Leerzeichen nach dem Morsencode), andere Zeichen werden einfach unverändert durchgereicht.

Probelauf:

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

Perl (489 Zeichen)

%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"$_"}}}

Kann wie folgt über die Kommandozeile ausgeführt werden.

$ perl -e '$CODE' < textfile

Edit: Danke @tobyodavies für den Hinweis, dass meine ursprüngliche Lösung die Übersetzung rückwärts hatte!

PHP, 474 Zeichen

<?$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])];

Seine 462 Zeichen, wenn alle Eingaben in Großbuchstaben erfolgen:

<?$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])];

05AB1E , 81 Bytes (nicht konkurrierend)

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

Probieren Sie es online!

Konvertieren Sie Buchstabenmuster in Basis-3, Zahlenmuster in Basis-2, und verwenden Sie nullindizierte ASCII-Transliteration, um Punkte und Bindestriche zu erhalten. Funktioniert nicht mit Kleinbuchstaben.

Gelee , 50 Bytes

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

Ein vollständiges Programm, das eine mit Python formatierte Zeichenfolge als Befehlszeilenargument akzeptiert und eine durch Leerzeichen begrenzte Ausgabe ausgibt.

Probieren Sie es online!

Powershell, 142 Bytes

-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{$_}})

Weniger Golf-Testskript:

$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"
}

Ausgabe:

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

Hinweis: Die Ausgabe enthält nachgestellte Leerzeichen.

APL (NARS), 71 Zeichen, 142 Byte

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

Prüfung:

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

Jeder Buchstabe wird von einem Leerzeichen getrennt. Jedes Wort wird von drei Leerzeichen getrennt. Die Tabelle besteht aus einer alphanumerischen Zeichenfolge ⎕A,⎕Dund 16- 'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ᥃䴫쩸穼蚠'Bit-Zeichen, die in 8-Bit-Zeichen aufgeteilt sind und jeweils in Basis 3 mit umgekehrten Ziffern konvertiert werden.

05AB1E , 52 Bytes

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

Probieren Sie es online!

    •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

JavaScript (ES6), 184 Byte

In beiden Versionen werden Leerzeichen zwischen den Zeichen eingefügt. Konvertierungen 0-9 und az (ohne Berücksichtigung der Groß- und Kleinschreibung) werden konvertiert. Ein Leerzeichen wird in 3 umgewandelt.

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(" ")

Ersetzen Sie \ndurch ein Zeilenvorschubzeichen ( 0x0a). Einige nicht druckbare Zeichen werden aufgrund von SE nicht angezeigt. Wenn Sie in den Bearbeitungsmodus wechseln, wird dies angezeigt.

Hier ist das Hex:

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

Lesbare Version, 234 Bytes

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

Python 2, 283 274 Bytes

Ich habe eine alphanumerische Zeichenfolge erstellt, deren Platzierung in der Zeichenfolge die Darstellung des Morsecodes beschreibt. Ursprünglich wollte ich binär verwenden, 01wäre aber das gleiche wie 1. Also habe ich ternär mit - = 1und verwendet . = 2. Somit befindet sich das Zeichen in dieser Zeichenfolge cam Index 1121, seine Morsecodedarstellung ist --.-.

• Um Bytes zu sparen, habe ich Variablen für Leerzeichen, Bindestrich und Punkt erstellt.
• Dann habe ich die 'Decoder'-Zeichenfolge mit ein paar Ersetzungsanweisungen hart codiert, um Leerzeichen zu reduzieren.
• Der Teil der Funktion konvertiert einen Index in ein Array der ternären Ziffern
• Die andere Teilfunktion verwendet eine Zeichenfolge und konvertiert jedes Zeichen in Morsecode mit 3 Leerzeichen nach den Buchstaben und 7 (4 zusätzliche) zwischen den Wörtern

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())

Testgeschirr

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

Aktualisieren

• -9 [16-05-09] Integrierte die ternäre Rechenfunktion in die Hauptfunktion

[HINWEIS: Es gibt immer Leerzeichen am Ende, aber Leerzeichen stellen eine Pause dar, also bin ich Gast, das ist in Ordnung ]

PHP, 157 150 157 Bytes

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;

Nimmt Eingaben vom ersten Befehlszeilenargument entgegen. Keine Pause zwischen den Buchstaben. Laufen Sie mit -nr.

Nervenzusammenbruch

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

Schlagen Sie JavaScript, Python2, C, Ruby und sed. Ich bin froh.

4. Schritt: Mapping nicht zusammenführen, um Kleinbuchstaben ohne Verwendung von zu verarbeiten strtoupper.

vorherige Versionen:

Fehler bei Kleinbuchstaben; +12 Bytes zum Reparieren: Ersetzen $argv[1]durch strtoupper($argv[1]).

einfache Stringübersetzung, 254 Bytes

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

Geradeaus: Übersetzt den gesamten String auf einmal, Zeichen in Morsecode.
Speichern zu Datei auszuführen oder zu ersetzen <?=mit echound laufen mit -r.

Dezimalinterpretation von Morsecodes, 184 Bytes (-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;

erster Golfschritt: Morsecodes, die in Binärform codiert sind, mit einem zusätzlichen Leading 1, um führende Nullen zu erhalten. Durchläuft Zeichen und übersetzt sie einzeln. Laufen Sie mit -nr.

In Zeichen codierte Dezimalstellen, 157 Byte (-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;

zweites Golfen: Addiert 60 zum Dezimalwert und kodiert zum Zeichen.

Zusammengeführtes Mapping, 150 Bytes (-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;

drittes Golfspiel: Zusammenführung von Ziffern und Buchstaben zu einer einzigen Saite.

SmileBASIC, 194 190 Bytes

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