Écrivez le programme le plus court pour transformer l'entrée standard en code Morse . Les caractères ne figurant pas dans le tableau doivent être imprimés tels quels.
Écrivez le programme le plus court pour transformer l'entrée standard en code Morse . Les caractères ne figurant pas dans le tableau doivent être imprimés tels quels.
Réponses:
Cette réponse ne prend en charge que les majuscules et les chiffres. Les lettres sont séparées par des retours à la ligne et les mots sont séparés par 2 retours à la ligne
{." ETIANMSURWDKGOHVF L PJBXCYZQ"?)"?/'#! 08<>"@))10%=or 2base(;{!45+}%n}%
Une analyse
{}% comme d'habitude fonctionne comme une carte sur le tableau . poussez une copie du caractère sur la pile "ETIAN ..." ceci est une table de correspondance pour les caractères majuscules ? comme un string.find renvoie l'index du caractère dans la chaîne ou -1 s'il n'est pas trouvé (c'est-à-dire qu'il s'agit d'un chiffre) ) incrémenter cet indice pour que E => 2 T => 3 I => 4 etc. notez que si le char n'est pas une lettre majuscule ou un espace, c'est maintenant 0 (Faux) "? / '#! ..." ceci est une table de recherche pour les chiffres. il sera utilisé dans le sens inverse à l'autre table de recherche. @ tirez cette copie que nous avons faite du caractère en haut de la pile ))% 10 convertit le chiffre ascii en nombre en ajoutant 2 et en prenant le mod 10. Il est important de le faire de cette façon, car tous les majuscules les lettres frappent aussi ce code, et nous devons nous assurer qu'elles tombent dans la plage 0..9 ou l'étape suivante échouera. = extraire le nième caractère de la chaîne, par exemple "Bonjour" 1 = donne "e" ou souvenez-vous que si la recherche en majuscules échoue, nous avons un résultat 0, donc la recherche de chiffres sera utilisée 2base convertit en base 2 donc E => [1 0], T => [1 1], I => [1 0 0] etc. (; éclatez le début de la liste et jetez-la pour que E => [0], T => [1] {! 45 +}% annule chaque bit et ajoute 45, ce qui donne une valeur ascii de. et - n une nouvelle ligne sépare chaque mot. cela pourrait être 32 si vous vouliez séparez les mots par des espaces pour un coût de 1 coup
Golfscript - 85 caractères
Ceci est plus court que ma réponse SO en raison des exigences assouplies ici. L'entrée doit être en majuscules / chiffres et les caractères de ponctuation ".,?"
{." ETIANMSURWDKGOHVF!L!PJBXCYZQ"?)"UsL?/'#! 08<>"@".,?"58,48>+?=or
2base(;{!45+}%n}%
Comme la ponctuation n'est même pas requise ici, je peux raccourcir encore plus la réponse
Ma réponse de SO
Golfscript - 107 caractères
la nouvelle ligne à la fin de l'entrée n'est pas prise en charge, utilisez donc quelque chose comme ceci
echo -n Hello, Codegolfers| ../golfscript.rb morse.gs
Les lettres sont un cas spécial et converties en minuscules et ordonnées dans leurs positions binaires. Tout le reste est fait par une table de traduction
' '/{{.32|"!etianmsurwdkgohvf!l!pjbxcyzq"?)"UsL?/'#! 08<>"@".,?0123456789"?=or
2base(;>{'.-'\=}%' '}%}%'/'*
C # (213 caractères)
Je suis sûr que cela ne durera pas longtemps, mais au moins j'ai eu la technique ici en premier!
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+" ");}}}
Et dans un format lisible:
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+" ");
}
}
}
Pour une brève explication, la chaîne de caractères est un tas dans lequel l'enfant gauche est un point et l'enfant droit est un tiret. Pour construire la lettre, vous remontez et inversez l'ordre.
ETIAN...
dedans, j'ai supposé qu'il fonctionnait de la même manière que le golfscript, mais vous avez une façon différente d'interpréter la corde. Je pense que c'est équivalent mais j'ajoute 1 à l'index et j'utilise la représentation binaire pour obtenir les points et les tirets pour tous les chiffres après le 1 "par exempleF=>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/
devient ,
- plus un peu de surcharge).
y
commande de sed à la place
import Data.List
i=intercalate
m=i" ".map(i" ".map(\c->words".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----."!!(head.findIndices(==c)$['a'..'z']++['0'..'9']))).words
Un formulaire plus lisible par l'utilisateur:
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
Échantillon échantillon:
*Main> m "welcome humans"
".-- . .-.. -.-. --- -- . .... ..- -- .- -. ..."
Il y a un seul espace entre deux lettres et sept espaces entre deux mots.
fromJust.elemIndex c
peut être écrit comme head.findIndices(==c)
. C'est un personnage de plus, mais vous pouvez ensuite vous en débarrasser import Data.Maybe
, vous économiserez donc 17 caractères au total. Vous pouvez également enregistrer deux caractères en supprimant l'espace devant la chaîne chaque fois que vous appelez intercaler. Et encore quelques personnages en faisant i=intercalate
au début et en remplaçant les deux appels à intercalate
par i
.
intercalate
et j'ai sauvé 6 autres personnages! :-)
w=words
, ce qui enregistre un personnage si je ne me trompe pas. Et au lieu de l c=...
et map l
, vous devriez le faire map\c->...
(vous n'avez même pas besoin de parens autour du lambda car il y a déjà une paren de fermeture après tout).
l c=...
m'a sauvé 1 caractère, mais je ne pouvais pas le mettre sans parens, seulement comme map(\c->...)
. GHC version 6.12.3.
Postscript (310) (462) (414)(319) dont (46) pour le tableau.
Chiffres et lettres combinés avec un codage ternaire. 5 chiffres ternaires tiennent dans un octet! Cela élimine complètement ces boucles de différence stupides et les nombres de casse spéciale.
ASCII85 coupe 1/3 de chaque table. Et simplifier le code (enfin!) Revient sous 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
Exemple de sortie
Luser Dr00g! . ---. . . . ---. . . . . ---. ---. . . ---. --- --- --- --- --- --- --- --- --- --- --- --- ---. !
Non golfé et commenté. Je suis très fier de celui-ci. Je pense que c'est élégant, que les chiffres font le travail. :)
%!
%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
Les tableaux (33) + (13) = (46)
Voici comment les chaînes codent la table. Chaque octet représente un nombre ternaire à 5 chiffres. Et les octets sont encore encodés en ASCII85 (que le postscript peut décoder automatiquement).
%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}*''
Encode chaque chiffre en un seul caractère, où 1 est un tiret, 0 est un point, avec un 1 en tête comme bit de marqueur (plus un décalage pour le garder imprimable. Utilise les mathématiques ASCII pour utiliser les caractères d'entrée comme indices de recherche.
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
Cette dernière fonction est mauvaise.
modifier Quelques améliorations.
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 caractères)
(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)))))
Cela encode les lettres minuscules et les séquences de code morse sont imprimées avec un espace de fin
En Java, 475 caractères.
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){}}}
Traduit az, AZ et 0-9.
Modifier:
Ou en 447 caractères, si cela ne vous dérange pas que Java lance une erreur après la traduction.
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}
Version lisible
# 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
Nous commençons par réduire la ligne entière (parce que y
nous ne pouvons pas faire de conversions insensibles à la casse); soustrayez 10 octets si nous ne devons gérer que les entrées en minuscules. Ensuite , nous prétraiter les chiffres 0
, 2
, 8
et 9
d'émettre leurs symboles finaux.
La boucle génère le symbole final pour chaque caractère saisi, puis traduit chaque caractère pour l'itération suivante. Cela équivaut à remonter le tableau de recherche dichotomique présenté dans l'article Wikipedia; les chiffres qui nécessitaient un traitement spécial peuvent être considérés comme ayant des parents qui ne sont pas dans nos alphanumériques ASCII.
La boucle se termine lorsque tous les caractères ont atteint l'espace de terminaison (après «e» ou «t»).
Par exemple, la lettre k
se transforme en trois passes:
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]);
}
(Avec des espaces non significatifs supprimés, pas de nouvelle ligne de fin)
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
est une table de correspondance où les motifs binaires des caractères correspondent aux points et tirets du code morse. Les caractères [0-9A-Z]
sont décodés en morse à l'aide de ce tableau (avec un espace ajouté après le code morse), les autres caractères sont simplement transmis sans modification.
Échantillon échantillon:
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"$_"}}}
Peut être exécuté via la ligne de commande comme ça.
$ perl -e '$CODE' < textfile
Edit: Merci @tobyodavies d'avoir souligné que ma solution d'origine avait la traduction à l'envers!
%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])];
Ses 462 caractères si toutes les entrées sont en majuscules:
<?$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"".- "‡})
Convertissez les modèles de lettres en base-3, les modèles de nombres en base-2, utilisez la translittération ascii indexée zéro pour accéder aux points et aux tirets. Ne fonctionne pas en minuscules.
-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 de test moins 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"
}
Sortie:
True: .- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----.
True: .... . .-.. .-.. --- .-- --- .-. .-.. -..
True: #$%^&
Remarque: La sortie contient des espaces de fin.
+mazzy+
est un rembourrage effronté
{36≥y←⍵⍳⍨⎕A,⎕D:'•-'[0∼⍨⌽(5⍴3)⊤y⊃∊(2⍴256)∘⊤¨⎕AV⍳'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ䴫쩸穼蚠']⋄⍵}
tester:
q←{36≥y←⍵⍳⍨⎕A,⎕D:'•-'[0∼⍨⌽(5⍴3)⊤y⊃∊(2⍴256)∘⊤¨⎕AV⍳'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ䴫쩸穼蚠']⋄⍵}
q¨'0123456789'
----- •---- ••--- •••-- ••••- ••••• -•••• --••• ---•• ----•
q¨"HELLO WORLD"
•••• • •-•• •-•• --- •-- --- •-• •-•• -••
chaque lettre est séparée d'un espace, chaque mot serait séparé de 3 espaces. Le tableau est construit sur une chaîne alphanumérique ⎕A,⎕D
et des caractères 16 bits 'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ䴫쩸穼蚠'
qu'ils divisent en caractères 8 bits chacun converti en base 3 avec des chiffres inversés.
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
Pour ces deux versions, ils mettront des espaces entre les caractères. Les conversions 0-9 et az (insensible à la casse) sont converties. Un espace est converti 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(" ")
Remplacez \n
par un caractère de nouvelle ligne ( 0x0a
). Il n'affiche pas quelques caractères non imprimables à cause de SE. Passer en mode édition le montre.
Voici l'hexagone:
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
J'ai créé une chaîne alphanumérique de telle sorte que leur placement dans la chaîne décrit leur représentation en code Morse. À l'origine, j'allais utiliser le binaire, mais ce 01
serait le même que 1
. J'ai donc utilisé le ternaire avec - = 1
et . = 2
. Ainsi, le caractère c
est à l'index 1121
dans cette chaîne, sa représentation en code Morse est --.-
.
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())
Harnais de test
print(f("Hi")==".... .. ")
print(f("Hello")==".... . .-.. .-.. --- ")
print(f("Hello World")==".... . .-.. .-.. --- .-- --- .-. .-.. -.. ")
print(f("To be or not to be")=="- --- -... . --- .-. -. --- - - --- -... . ")
print(f("3 14 15")=="...-- .---- ....- .---- ..... ")
Mise à jour
[REMARQUE: Il y a toujours un espace blanc à la fin, mais l'espace blanc représente une pause, donc je vous invite, c'est ok ]
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;
prend l'entrée du premier argument de ligne de commande. pas de pause entre les lettres. Courez avec -nr
.
panne
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
Battre JavaScript, Python2, C, Ruby et sed. Je suis heureux.
4ème étape: dé-fusionner le mappage pour gérer les caractères en minuscules sans utiliser strtoupper
.
Versions précédentes:
échec pour les lettres minuscules; +12 octets à corriger: remplacer $argv[1]
par strtoupper($argv[1])
.
traduction de chaîne simple, 254 octets
<?=strtr($argv[1],["-----",".----","..---","...--","....-",".....","-....","--...","---..","----.",A=>".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]);
simple: traduit la chaîne entière à la fois, caractère en morse.
Enregistrer dans un fichier pour exécuter ou remplacer <?=
par echo
et exécuter avec -r
.
interprétation décimale des codes morse, 184 octets (-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;
première étape de golf: codes morse codés en binaire avec un début supplémentaire 1
pour conserver les zéros de tête. Boucle à travers les caractères et les traduit un par un. Courez avec -nr
.
décimales codées en caractère, 157 octets (-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;
deuxième golf: ajouté 60 à la valeur décimale et encodé en caractère.
mappage fusionné, 150 octets (-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;
troisième golf: mappage fusionné des chiffres et des lettres sur une seule chaîne.