Traductor de código Morse


32

Escriba el programa más corto para transformar la entrada estándar en código Morse . Los caracteres que no están en la tabla deben imprimirse tal como están.

Código Morse Internacional


1
¿Están codificadas las letras mayúsculas y minúsculas?
Joey Adams

99
Además, ¿podría proporcionar una entrada y salida de muestra para aclarar detalles como el espacio entre palabras?
Joey Adams

Bueno, en Morse, no hay diferencia entre mayúsculas y minúsculas. No hay un símbolo real para el espacio (es solo un silencio de 3/4 veces), así que supongo que debería traducirse como un espacio.
Shikiryu

@Joey: los detalles dependen de usted.
Alexandru

Similar a la pregunta de desbordamiento de pila Código Golf: código Morse .
dmckee

Respuestas:


11

Golfscript - 74 caracteres

Esta respuesta solo admite mayúsculas y dígitos. Las letras están separadas por líneas nuevas y las palabras están separadas por 2 líneas nuevas.

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

Análisis

    {}% como de costumbre funciona como un mapa sobre la matriz
    . empujar una copia del personaje a la pila
    "ETIAN ..." esta es una tabla de búsqueda para los caracteres en mayúscula
    ? como una cadena.find devuelve el índice del carácter en la cadena
                  o -1 si no se encuentra (es decir, es un dígito)
    ) incremente ese índice para que E => 2 T => 3 I => 4, etc.
                  char no es una letra mayúscula o espacio, ahora es 0 (Falso)
    "? / '#! ..." esta es una tabla de búsqueda para los dígitos. se usará en el
                  camino inverso a la otra tabla de búsqueda.
    @ tire de esa copia que hicimos del personaje hasta la parte superior de la pila
    ))% 10 convierte un dígito ascii a un número sumando 2 y tomando mod 10.
                  Es importante hacerlo de esta manera porque todas las mayúsculas
                  las letras también tocan este código, y debemos asegurarnos de que caigan
                  en el rango 0..9 o el siguiente paso fallará.
    = extraer el enésimo carácter de la cadena, por ejemplo, "Hola" 1 = da "e"
    o recuerde que si la búsqueda en mayúscula falla, tenemos un resultado de 0, entonces
                  se usará la búsqueda de dígitos
    2base convierte a base 2, por lo que E => [1 0], T => [1 1], I => [1 0 0] etc.
    (; abre el frente de la lista y deséchalo para que E => [0], T => [1]
    {! 45 +}% niega cada bit y agrega 45, esto da un valor ascii de. y -
    n nueva línea separa cada palabra. esto podría ser 32 si quisieras
                  separe las palabras con espacios por un costo de 1 trazo

Golfscript - 85 caracteres

Esto es más corto que mi respuesta SO debido a los requisitos relajados aquí. La entrada debe estar en mayúsculas / dígitos y los caracteres de puntuación ".,?"

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

Dado que la puntuación ni siquiera se requiere aquí, puedo acortar la respuesta aún más

Mi respuesta de SO
Golfscript - 107 caracteres

la nueva línea al final de la entrada no es compatible, así que use algo como esto

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

Las letras son un caso especial y se convierten a minúsculas y se ordenan en sus posiciones binarias. Todo lo demás se hace mediante una tabla de traducción.

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

El orden de los bloques de código aquí confunde el UserScript de George . ¿Podría molestarte para reorganizar? Y me gustaría gustaría verlo explicó. Me sale el árbol implícito, pero el resto es un misterio para mí.
dmckee

@dmckee, hecho. El guión de George notó mi cuenta era por uno, por lo que me fijo demasiado
gnibbler

Requerir votos a favor para ver el análisis ... boo! ¡El análisis es lo que hace que las respuestas valgan la pena!
Nick Larsen

@ Nick, bien creo que es tan corto como lo puedo conseguir, así que pondremos a trabajar en ese análisis
gnibbler

20

C # (213 caracteres)

Estoy seguro de que esto no durará mucho, pero al menos obtuve la técnica aquí primero.

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

Y en formato legible:

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

Para una breve explicación, la cadena de caracteres es un montón en el que el elemento secundario izquierdo es un punto y el elemento secundario derecho es un guión. Para construir la letra, retrocede e invierte el orden.


2
Esta es la mejor idea que he visto hasta ahora.
Alexandru

Y luego leí el hilo vinculado y noté que esto está lejos de ser original.
Nick Larsen

1
Cuando vi el contenido ETIAN...allí, supuse que funcionaba igual que el script de golf, pero tiene una forma diferente de interpretar la secuencia. Creo que es equivalente, pero agrego 1 al índice y uso la representación binaria para obtener los puntos y guiones para todos los dígitos después del 1 " F=>18=>0b10010=>..-.
inicial

No necesita el espacio enString[] 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
El espacio alrededor de una tubería también podría eliminarse ;-)
Yasir Arsanukaev

1
Sí, no estoy contando esos espacios, solo los
imprimo

2
Puede usar la expansión de llaves para acortarlo mucho (se /g;s/convierte en ,- más un poco de sobrecarga).
Nabb

@nabb buena idea.
Eelvex

1
Puedes soltar el tr, usar el ycomando de sed en su lugar
Hasturkun

6

Haskell - 314 292 291 caracteres

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

Una forma más legible por el usuario:

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

Ejecución de muestra:

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

Hay un solo espacio en blanco entre dos letras y siete espacios en blanco entre dos palabras.


Acabo de comprobar la pregunta a la que hace referencia @dmckee "Code Golf: código Morse" y no encontré una versión de Haskell. Creo que menos de 314 sería posible.
Yasir Arsanukaev

fromJust.elemIndex cse puede escribir como head.findIndices(==c). Ese es un personaje más, pero luego puede deshacerse de él import Data.Maybe, por lo que ahorrará 17 caracteres en total. También puede guardar dos caracteres eliminando el espacio delante de la cadena cada vez que llame a intercalate. Y otros pocos caracteres haciendo i=intercalateal principio y reemplazando las dos llamadas intercalatecon i.
sepp2k

@ sepp2k: ¡Buena idea! Gracias. ¡También jugué con intercalatey he guardado otros 6 personajes! :-)
Yasir Arsanukaev 01 de

También puedes hacerlo w=words, lo que ahorra un personaje si no me equivoco. Y en lugar de l c=...y map l, debería hacerlo map\c->...(ni siquiera necesita parens alrededor de la lambda ya que de todos modos ya hay un par de cierre después).
sepp2k

@ sepp2k: La alineación de l c=...me salvó 1 personaje, pero no pude ponerlo sin parens, solo como map(\c->...). GHC versión 6.12.3.
Yasir Arsanukaev

4

Posdata (310) (462) (414)(319) incluyendo (46) para la mesa.

Números y letras combinados con una codificación ternaria. ¡5 dígitos ternarios caben en un byte! Esto elimina esos bucles de diferencia tontos y los números de carcasa especial por completo.

ASCII85 corta 1/3 de cada tabla. Y simplificar el código (¡finalmente!) Vuelve a ser inferior a 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

Salida de muestra

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

Ungolfed y comentó. Estoy muy orgulloso de este. Siento que es elegante, haciendo que los números hagan el trabajo. :)

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

Las tablas (33) + (13) = (46)

Así es como las cadenas codifican la tabla. Cada byte representa un número ternario de 5 dígitos. Y los bytes se codifican aún más en ASCII85 (que PostScript puede decodificar automáticamente).

%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

Rubí, 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 cada dígito en un único carácter, donde 1 es un guión, 0 es un punto, con un 1 inicial como un bit marcador (más un desplazamiento para mantenerlo imprimible). Utiliza matemáticas ASCII para usar los caracteres de entrada como índices de búsqueda.


4

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

Esa última función es malvada.

editar Un par de mejoras.

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

Decidí hacer +1 en esto porque no recuerdo haber visto alguna vez VB.net utilizado para jugar al golf.
mbomb007

3

Lisp ( 532 466 caracteres)

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

Esto codifica letras minúsculas y las secuencias de código Morse se imprimen con un espacio final


3

En Java, 475 caracteres.

    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 y 0-9.

Editar:

O en 447 caracteres, si no le importa que Java arroje un error después de la traducción.

    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}

Versión legible

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

"Obtengo un token extra al principio y al final por alguna razón": no sé Perl 6, pero supongo que es porque la cadena vacía coincide antes del límite de la primera palabra y después del último.
msh210

2

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

Comenzamos reduciendo la línea completa (porque yno se pueden realizar conversiones que no distingan entre mayúsculas y minúsculas); reste 10 bytes si solo vamos a manejar la entrada en minúsculas. Luego preprocesar los dígitos 0, 2, 8y9 para emitir sus símbolos finales.

El bucle genera el símbolo final para cada carácter de entrada, luego traduce cada carácter para la siguiente iteración. Esto es equivalente a subir la tabla de búsqueda dicotómica muestra en el artículo de Wikipedia; Se puede ver que los dígitos que necesitaban un tratamiento especial tienen padres que no están en nuestros alfanuméricos ASCII.

El ciclo termina cuando todos los caracteres han alcanzado el espacio de terminación (después de 'e' o 't').

Por ejemplo, la carta kse transforma en tres pases:

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

2

Python 3, 99 caracteres

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

Funciona en mayúsculas y minúsculas.


2

C, 162 160 caracteres

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 espacios en blanco no significativos despojados, sin nueva línea final)

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

Mes una tabla de búsqueda donde los patrones de bits de los caracteres corresponden a puntos y guiones en el código morse. Caracteres[0-9A-Z] se decodifican en morse usando esta tabla (con un espacio agregado después del código morse), otros caracteres simplemente se pasan sin cambios.

Ejecución de muestra:

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

Eso no es 162 caracteres ... por favor publique la versión de golf.
Cyoce

@Cyoce Lo siento, no eliminé espacios en blanco no significativos ya que es un proceso mecánico aburrido y solo hace que sea más difícil leer el código fuente, que es (¿solía ser?) Una práctica bastante estándar en PPCG. Se agregó una versión con tal espacio en blanco despojado para usted :).
FireFly


1

Perl (489 caracteres)

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

Se puede ejecutar a través de la línea de comando de esta manera.

$ perl -e '$CODE' < textfile

Editar: ¡Gracias @tobyodavies por señalar que mi solución original tenía la traducción al revés!


1
Puede reducir esto a 286 caracteres:%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 caracteres

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

Sus 462 caracteres si toda la entrada está en mayúscula:

<?$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 algunos trucos menores que se pueden reducir 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 bytes (no competidor)

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

Pruébalo en línea!

Convierta patrones de letras a base-3, patrones de números a base-2, use transliteración ascii indexada a cero para llegar a puntos y guiones. No funciona en minúsculas.


1

Jalea , 50 bytes

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

Un programa completo que acepta una cadena con formato Python como argumento de línea de comando que imprime la salida delimitada por espacios.

Pruébalo en línea!


1

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

Menos guión de prueba de golf:

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

Salida:

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

Nota: La salida contiene espacios finales.


1
+mazzy+es un relleno descarado
Veskah

1

APL (NARS), 71 caracteres, 142 bytes

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

prueba:

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

cada letra está separada de un espacio, cada palabra estaría separada de 3 espacios. La tabla se basa en una cadena alfanumérica ⎕A,⎕Dy caracteres de 16 bits 'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ᥃䴫쩸穼蚠'que se dividen en caracteres de 8 bits , cada uno convertido en base 3 con dígitos invertidos.


1

05AB1E , 52 bytes

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

Pruébalo en línea!

    •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 bytes

Para ambas versiones, colocarán espacios entre los caracteres. Los conversos 0-9 y az (sin distinción entre mayúsculas y minúsculas) se convierten. Un espacio se convierte en 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(" ")

Reemplazar \ncon un carácter de nueva línea ( 0x0a). No muestra un par de caracteres no imprimibles debido a SE. Entrar en modo edición lo muestra.

Aquí está el hechizo:

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

Sin golf

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

Versión legible, 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(" ")

Sin golf

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 bytes

Creé una cadena de caracteres alfanuméricos de modo que su ubicación en la cadena describe su representación del código Morse. Originalmente iba a usar binario, pero 01sería lo mismo que 1. Entonces usé ternary con - = 1y . = 2. Por lo tanto, el carácter cestá en el índice 1121de esta cadena, su representación del código Morse es --.-.

  • Para guardar bytes, creé variables para espacio, guión y punto.
  • Luego codifiqué la cadena 'decodificador' usando un par de instrucciones de reemplazo para reducir el espacio en blanco.
  • La parte de la función convierte un índice en una matriz de dígitos ternarios.
  • La otra parte parte toma una cadena y convierte cada carácter en código Morse con 3 espacios después de las letras y 7 (4 extra) entre palabras
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())

Arnés de prueba

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

Actualizar

  • -9 [16-05-09] Incorpora la función de cálculo ternario en la función principal

[NOTA: siempre hay un espacio en blanco al final, pero el espacio en blanco representa una pausa, así que invito a que esté bien ]


0

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;

toma la entrada del primer argumento de la línea de comando. sin pausa entre letras. Corre con -nr.

Descompostura

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

Superando JavaScript, Python2, C, Ruby y sed. Estoy feliz.

4to paso: desagrupar la asignación para manejar caracteres en minúsculas sin usar strtoupper.

Versión anterior:

fallar en letras minúsculas; +12 bytes para arreglar: reemplazar $argv[1]constrtoupper($argv[1]) .

traducción de cadena simple, 254 bytes

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

sencillo: traduce toda la cadena a la vez, carácter a código morse.
Guardar en archivo para ejecutar o reemplazar <?=con echoy correr con -r.

interpretación decimal de códigos morse, 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;

primer paso de golf: códigos morse codificados en binario con una ventaja adicional 1para preservar los ceros a la izquierda. Recorre los personajes y los traduce uno por uno. Corre con -nr.

decimales codificados a caracteres, 157 bytes (-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;

segundo golf: agregado 60 al valor decimal y codificado al carácter.

mapeo combinado, 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;

tercer golf: mapeo combinado de dígitos y letras en una sola cadena.


0

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.