Traduttore di codice Morse


32

Scrivi il programma più breve per trasformare l'input standard in codice Morse . I caratteri non presenti nella tabella devono essere stampati così come sono.

Codice Morse Internazionale


1
Le lettere maiuscole e minuscole sono codificate?
Joey Adams,

9
Inoltre, potresti fornire un input e un output di esempio per chiarire dettagli come la spaziatura tra le parole?
Joey Adams,

Bene, in Morse, non c'è differenza tra lettere minuscole e maiuscole. Non esiste un vero simbolo per lo spazio (è solo un silenzio di 3/4 volte) quindi immagino che dovrebbe essere tradotto come uno spazio.
Shikiryu,

@Joey: i dettagli dipendono da te.
Alexandru,

Simile alla domanda Stack Overflow Code Golf: codice Morse .
dmckee,

Risposte:


11

Golfscript - 74 caratteri

Questa risposta supporta solo lettere maiuscole e cifre. Le lettere sono separate da nuove righe e le parole sono separate da 2 nuove righe

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

Analisi

    {}% come al solito funziona come una mappa sull'array
    . spingere una copia del carattere nello stack
    "ETIAN ..." questa è una tabella di ricerca per i caratteri maiuscoli
    ? like a string.find restituisce l'indice del carattere nella stringa
                  o -1 se non viene trovato (ovvero è una cifra)
    ) incrementa tale indice in modo che E => 2 T => 3 I => 4 ecc. noti che se il
                  char non è una lettera maiuscola o uno spazio ora è 0 (False)
    "? / '#! ..." questa è una tabella di ricerca per le cifre. sarà utilizzato in
                  modo inverso all'altra tabella di ricerca.
    @ tira quella copia che abbiamo fatto del carattere in cima alla pila
    ))% 10 converti la cifra ASCII in un numero aggiungendo 2 e prendendo la mod 10.
                  È importante farlo in questo modo perché tutto in maiuscolo
                  anche le lettere colpiscono questo codice e dobbiamo assicurarci che cadano
                  nell'intervallo 0..9 o il passaggio successivo fallirà.
    = estrae l'ennesimo carattere dalla stringa, ad es. "Hello" 1 = dà "e"
    oppure ricorda se la ricerca in maiuscolo non riesce abbiamo un risultato 0, quindi
                  verrà utilizzata la ricerca delle cifre
    2 base convertita in base 2, quindi E => [1 0], T => [1 1], I => [1 0 0] ecc.
    (; fai apparire la parte anteriore dell'elenco e gettala via in modo che E => [0], T => [1]
    {! 45 +}% annulla ogni bit e aggiunge 45, questo dà un valore ASCII di. e -
    n newline separa ogni parola. questo potrebbe essere 32 se lo desideri
                  separare le parole con spazi per un costo di 1 colpo

Golfscript - 85 caratteri

Questo è più breve della mia risposta SO a causa dei requisiti rilassati qui L'ingresso deve essere in maiuscolo / cifre e i caratteri di punteggiatura ".,?"

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

Poiché la punteggiatura non è nemmeno richiesta qui, potrei accorciare ulteriormente la risposta

La mia risposta da SO
Golfscript - 107 caratteri

newline alla fine dell'input non è supportato, quindi usa qualcosa di simile

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

Le lettere sono un caso speciale, convertite in minuscolo e ordinate nelle loro posizioni binarie. Tutto il resto è fatto da una tabella di traduzione

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

L'ordine dei blocchi di codice qui confonde UserScript di George . Potrei disturbarti a riorganizzare? E vorrei vederlo spiegato. Ricevo l'albero implicito, ma il resto è un mistero per me.
Dmckee,

@dmckee, fatto. La sceneggiatura di George ha notato che il mio conto era fuori di uno, quindi ho risolto anche quello
gnibbler

Richiede voti positivi per vedere l'analisi ... boo! L'analisi è ciò che rende le risposte degne di nota!
Nick Larsen,

@Nick, ok penso che sia il più corto possibile, quindi lavorerò su quell'analisi
gnibbler,

20

C # (213 caratteri)

Sono sicuro che questo non durerà a lungo, ma almeno ho prima la tecnica qui!

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

E in formato leggibile:

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

Per una breve spiegazione, la stringa di caratteri è un heap in cui il bambino sinistro è un punto e il bambino destro è un trattino. Per costruire la lettera, attraversi il backup e inverti l'ordine.


2
Questa è la migliore idea che ho visto finora.
Alexandru,

E poi ho letto il thread collegato e ho notato che questo è tutt'altro che originale.
Nick Larsen,

1
Quando ho visto l'interno ETIAN..., ho pensato che funzionasse allo stesso modo del golfscript, ma hai un modo diverso di interpretare la stringa. Penso che sia equivalente, ma aggiungo 1 all'indice e utilizzo la rappresentazione binaria per ottenere i punti e i trattini per tutte le cifre dopo il 1 "iniziale, ad esempioF=>18=>0b10010=>..-.
gnibbler,

Non è necessario lo spazio inString[] a
Cyoce

9

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'

1
Anche lo spazio attorno a una pipa potrebbe essere eliminato ;-)
Yasir Arsanukaev il

1
Sì, non conto questi spazi, li
stampo

2
Potresti usare l'espansione del rinforzo per accorciarla molto ( /g;s/diventa ,- più un po 'di sovraccarico).
Nabb,

@nabb buona idea.
Eelvex,

1
Puoi rilasciare il tr, usa yinvece il comando di sed
Hasturkun,

6

Haskell - 314 292 291 caratteri

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

Un modulo più leggibile dall'utente:

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

Esecuzione di esempio:

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

C'è un singolo spazio tra due lettere e sette spazi tra due parole.


Ho appena verificato la domanda a cui fa riferimento @dmckee "Codice Golf: codice Morse" e non ho trovato una versione di Haskell. Penso che sarebbe più breve di 314.
Yasir Arsanukaev,

fromJust.elemIndex cpuò essere scritto come head.findIndices(==c). Questo è un personaggio in più, ma puoi quindi sbarazzartene import Data.Maybe, quindi risparmierai 17 caratteri in totale. Puoi anche salvare due caratteri rimuovendo lo spazio davanti alla stringa ogni volta che chiami intercalato. E altri pochi personaggi facendo i=intercalateall'inizio e sostituendo le due chiamate intercalatecon i.
sepp2k,

@ sepp2k: bella idea! Grazie. Ho anche giocato con intercalatee ho salvato altri 6 personaggi! :-)
Yasir Arsanukaev,

Puoi anche farlo w=words, il che salva un personaggio se non sbaglio. E invece di l c=...e map l, dovresti farlo map\c->...(non hai nemmeno bisogno di parentesi attorno alla lambda poiché c'è già una parentesi di chiusura in seguito).
sepp2k,

@ sepp2k: L'allineamento di l c=...mi ha salvato 1 personaggio, ma non potrei metterlo senza parentesi, solo come map(\c->...). Versione GHC 6.12.3.
Yasir Arsanukaev,

4

poscritto (310) (462) (414)(319) incluso (46) per la tabella.

Numeri e lettere combinati con una codifica ternaria. 5 cifre ternarie si adattano in un byte! Questo elimina completamente quei loop sciocchi di differenza e numeri di maiuscole speciali.

ASCII85 taglia 1/3 di ogni tabella. E semplificando il codice (finalmente!) Torna sotto i 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

Uscita campione

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

Ungolf e commentato. Sono molto orgoglioso di questo. Sento che è elegante, fa sì che i numeri facciano il lavoro. :)

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

Le tabelle (33) + (13) = (46)

Ecco come le stringhe codificano la tabella. Ogni byte rappresenta un numero ternario di 5 cifre. E i byte sono ulteriormente codificati in ASCII85 (che Postscript può decodificare automagicamente).

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

4

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

Codifica ogni cifra in un singolo carattere, dove 1 è trattino, 0 è punto, con un 1 iniziale come bit marker (più un offset per mantenerlo stampabile. Utilizza la matematica ASCII per utilizzare i caratteri di input come indici di ricerca.


4

VB.NET, 233 byte

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

L'ultima funzione è malvagia.

modifica Un paio di miglioramenti.

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

Ho deciso di fare +1 su questo perché non ricordo di aver mai visto VB.net usato per giocare a golf.
mbomb007,

3

Lisp ( 532 466 caratteri)

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

Questo codifica le lettere minuscole e le sequenze di codice morse vengono stampate con uno spazio finale


3

In Java, 475 caratteri.

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

Traduce az, AZ e 0-9.

Modificare:

O in 447 caratteri, se non ti dispiace Java che lancia un errore dopo la traduzione.

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

3

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}

Versione leggibile

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

"Ricevo un token in più all'inizio e alla fine per qualche motivo": non conosco Perl 6, ma immagino sia perché la stringa vuota corrisponde prima del limite della prima parola e dopo l'ultimo.
msh210

2

sed, 159 byte

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

Iniziamo ridimensionando l'intera linea (perché ynon è possibile effettuare conversioni senza distinzione tra maiuscole e minuscole); sottrarre 10 byte se dobbiamo solo gestire l'input in minuscolo. Quindi preelaboriamo le cifre 0,2 , 8e9 per emettere i loro simboli finali.

Il ciclo genera il simbolo finale per ciascun carattere di input, quindi traduce ciascun carattere per la successiva iterazione. Ciò equivale a camminare su tabella di ricerca dicotomica mostrata nell'articolo di Wikipedia; le cifre che necessitavano di un trattamento speciale possono avere genitori che non sono nei nostri caratteri alfanumerici ASCII.

Il ciclo termina quando tutti i caratteri hanno raggiunto lo spazio finale (dopo 'e' o 't').

Ad esempio, la lettera kviene trasformata in tre passaggi:

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

2

Python 3, 99 personaggi

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

Funziona in maiuscolo e minuscolo.


2

C, 162 160 caratteri

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

(Con spazi bianchi non significativi eliminati, nessuna nuova riga finale)

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è una tabella di ricerca in cui i bitpattern dei caratteri corrispondono a punti e trattini nel codice morse. Personaggi[0-9A-Z] vengono decodificati in morse usando questa tabella (con uno spazio aggiunto dopo il codice morse), gli altri personaggi vengono semplicemente passati invariati.

Esecuzione di esempio:

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

Non sono 162 caratteri ... pubblica la versione golf.
Cyoce,

@Cyoce Siamo spiacenti, non ho rimosso gli spazi bianchi non significativi dal momento che è un processo meccanico noioso e rende solo più difficile leggere il codice sorgente, che è (usato per essere?) Una pratica abbastanza standard su PPCG. Aggiunta una versione con tale spazio bianco per te :).
FireFly


1

Perl (489 caratteri)

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

Può essere eseguito dalla riga di comando in questo modo.

$ perl -e '$CODE' < textfile

Modifica: Grazie @tobyodavies per aver sottolineato che la mia soluzione originale aveva la traduzione al contrario!


1
È possibile ottenere questo fino a 286 caratteri:%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

1

PHP, 474 caratteri

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

I suoi 462 caratteri se tutti gli input sono in maiuscolo:

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

Con alcuni trucchi minori che possono essere ridotti a:<?$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

1

05AB1E , 81 byte (non concorrenti)

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

Provalo online!

Converti schemi di lettere in base-3, schemi di numeri in base-2, usa la traslitterazione ASCII indicizzata zero per ottenere punti e trattini. Non funziona in minuscolo.


1

Gelatina , 50 byte

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

Un programma completo che accetta una stringa formattata Python come argomento della riga di comando che stampa l'output delimitato da spazio.

Provalo online!


1

Powershell, 142 byte

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

Script di test meno golfato:

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

Produzione:

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

Nota: l'output contiene spazi finali.


1
+mazzy+è un'imbottitura sfacciata
Veskah

1

APL (NARS), 71 caratteri, 142 byte

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

test:

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

ogni lettera è separata da uno spazio, ogni parola sarebbe separata da 3 spazi. La tabella è costruita su stringa alfanumerica ⎕A,⎕De caratteri a 16 bit 'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ᥃䴫쩸穼蚠'divisi in caratteri a 8 bit ciascuno convertito in base 3 con cifre invertite.


1

05AB1E , 52 byte

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

Provalo 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

1

JavaScript (ES6), 184 byte

Per entrambe queste versioni, inseriranno spazi tra qualsiasi carattere. I convertiti 0-9 e az (senza distinzione tra maiuscole e minuscole) vengono convertiti. Uno spazio viene convertito in 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(" ")

Sostituisci \ncon un carattere di nuova riga ( 0x0a). Non mostra un paio di caratteri non stampabili a causa di SE. Andare in modalità modifica lo mostra.

Ecco l'esagono:

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

Versione leggibile, 234 byte

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

0

Python 2, 283 274 byte

Ho creato una stringa di caratteri alfanumerici in modo tale che il loro posizionamento nella stringa descriva la loro rappresentazione del codice Morse. Inizialmente avrei usato il binario, ma 01sarebbe stato lo stesso di 1. Quindi ho usato ternario con - = 1e . = 2. Quindi il carattere cè all'indice1121 in questa stringa, la sua rappresentazione in codice Morse è--.- .

  • Per salvare i byte, ho creato variabili per spazio, trattino e punto.
  • Quindi ho hardcoded la stringa 'decoder' usando un paio di istruzioni di sostituzione per ridurre gli spazi bianchi.
  • La parte della funzione converte un indice in un array di cifre ternarie
  • L'altra funzione parte prende una stringa e converte ogni carattere in codice Morse con 3 spazi dopo le lettere e 7 (4 extra) tra le parole
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())

Collaudare l'imbragatura

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

Aggiornare

  • -9 [16-05-09] Incorporata la funzione di calcolo ternaria nella funzione principale

[NOTA: c'è sempre spazio bianco in coda ma lo spazio bianco rappresenta una pausa, quindi io ospite va bene ]


0

PHP, 157 150 157 byte

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;

accetta input dal primo argomento della riga di comando. nessuna pausa tra le lettere. Corri con -nr.

abbattersi

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

Battere JavaScript, Python2, C, Ruby e sed. Sono felice.

4 ° passaggio: decomprimere la mappatura per gestire i caratteri minuscoli senza utilizzare strtoupper.

versione precedente:

non riesce per le lettere minuscole; +12 byte da correggere: sostituire $argv[1]con strtoupper($argv[1]).

traduzione semplice di stringhe, 254 byte

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

dritto: traduce l'intera stringa in una sola volta, carattere in codice morse.
Salva su file per eseguirlo o sostituirlo <?=con echoed eseguirlo -r.

interpretazione decimale dei codici morse, 184 byte (-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;

primo passo del golf: codici morse codificati in binario con un ulteriore vantaggio 1per preservare gli zero iniziali. Scorre i personaggi e li traduce uno per uno. Corri con -nr.

decimali codificati in caratteri, 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;

secondo golf: aggiunto 60 al valore decimale e codificato in carattere.

mappatura unita, 150 byte (-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;

terzo golf: mappatura unita per cifre e lettere in un'unica stringa.


0

SmileBASIC, 194 190 byte

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.