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.
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.
Respuestas:
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(;>{'.-'\=}%' '}%}%'/'*
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.
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=>..-.
String[] a
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'
/g;s/
convierte en ,
- más un poco de sobrecarga).
y
comando de sed en su lugar
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.
fromJust.elemIndex c
se 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=intercalate
al principio y reemplazando las dos llamadas intercalate
con i
.
intercalate
y he guardado otros 6 personajes! :-)
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).
l c=...
me salvó 1 personaje, pero no pude ponerlo sin parens, solo como map(\c->...)
. GHC versión 6.12.3.
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)
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.
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
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
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){}}}
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;
}
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 y
no 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
, 8
y9
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 k
se transforma en tres pases:
k
=> k-
=>n-
n-
=> n.-
=>t.-
t.-
=> t-.-
=>-.-
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]);}
M
es 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
.- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----.
%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!
%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//}
<?$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])];
<?$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,'.-');
Çvy©58‹i®58-•6V%·,Õo•2B5ôsè}®64›i®64-•4…·]ÑUZ“×\ó$9™¹“ÌLÈÎ%´•3B4ôsè}"012"".- "‡})
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.
-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.
+mazzy+
es un relleno descarado
{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,⎕D
y caracteres de 16 bits 'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ䴫쩸穼蚠'
que se dividen en caracteres de 8 bits , cada uno convertido en base 3 con dígitos invertidos.
Ažh«•1Ju&àøΘn₆δβαLmSÂZΘ=+BD1
÷ΓùwÒмVšh•… .-ÅвJ#ðδJ‡
•1Ju&àøΘn₆δβαLmSÂZΘ=+BD1
÷ΓùwÒмVšh• push compressed number
… .-ÅвJ# convert to custom base " .-"
ðδJ append a space to each morse code
Ažh« ‡ transliterate
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 \n
con 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
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
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(" ")
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
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 01
sería lo mismo que 1
. Entonces usé ternary con - = 1
y . = 2
. Por lo tanto, el carácter c
está en el índice 1121
de esta cadena, su representación del código Morse es --.-
.
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
[NOTA: siempre hay un espacio en blanco al final, pero el espacio en blanco representa una pausa, así que invito a que esté bien ]
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 echo
y 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 1
para 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.