Convertissez une chaîne en code Morse [fermé]
Le défi
le code le plus court par nombre de caractères, qui introduira une chaîne en utilisant seulement des caractères alphabétiques (majuscules et minuscules), des nombres, des virgules, des périodes et un point d'interrogation, et retourne une représentation de la chaîne en code Morse.
La sortie du code Morse doit se composer d'un tiret ( - , ASCII 0x2D) pour un long bip (AKA 'dah') et d'un point ( . , ASCII 0x2E) pour un bip court (AKA 'dit').
Chaque lettre doit être séparé par un espace ( ' ' , ASCII 0x20), et chaque mot doit être séparé par une barre oblique ( / , ASCII 0x2F).
le code Morse de la table:
alt texte http://liranuna.com/junk/morse.gif
cas types:
Input:
Hello world
Output:
.... . .-.. .-.. --- / .-- --- .-. .-.. -..
Input:
Hello, Stackoverflow.
Output:
.... . .-.. .-.. --- --..-- / ... - .- -.-. -.- --- ...- . .-. ..-. .-.. --- .-- .-.-.-
comprend les entrées/sorties (c'est-à-dire le programme complet).
30 réponses
C (131 caractères)
Oui, 13 1 !
main(c){for(;c=c?c:(c=toupper(getch())-32)?
"•ƒŒKa`^ZRBCEIQiw#S#nx(37+-2&@/4)'18=,*%.:0;?5"
[c-12]-34:-3;c/=2)putch(c/2?46-c%2:0);}
j'ai ajouté quelques caractères supplémentaires en combinant la logique des boucles while et for dans une seule boucle for , et en déplaçant la déclaration de la variable c dans la définition de main comme paramètre d'entrée. Cette dernière technique que j'ai empruntée à strager's réponse à un autre défi .
pour ceux qui essaient de vérifier le programme avec GCC ou avec des éditeurs ASCII seulement, vous pouvez avoir besoin de la version suivante, légèrement plus longue:
main(c){for(;c=c?c:(c=toupper(getchar())-32)?c<0?1:
"\x95#\x8CKa`^ZRBCEIQiw#S#nx(37+-2&@/4)'18=,*%.:0;?5"
[c-12]-34:-3;c/=2)putchar(c/2?46-c%2:32);}
cette version est de 17 caractères de plus (pesée à un comparativement énorme 148), en raison des changements suivants:
- +4:
getchar()etputchar()au lieu du non-portablegetch()etputch() - +6: Codes d'échappement pour deux des caractères au lieu de caractères non ASCII
- +1: 32 au lieu de 0 pour le caractère d'espace
- +6: ajouté "
c<0?1:" pour supprimer les déchets des caractères inférieurs à ascii 32 (à savoir, de'\n'). Vous obtiendrez tout de même des déchets de l'un des!"#$%&'()*+[\]^_` 1519210920", ou tout ce qui est au-dessus de ascii 126.
faire le code complètement portable. Compiler avec:
gcc -std=c89 -funsigned-char morse.c
le -std=c89 est facultatif. Le -funsigned-char est nécessaire, Cependant, ou vous obtiendrez des ordures pour virgule et arrêt complet.
135 caractères
c;main(){while(c=toupper(getch()))for(c=c-32?
"•ƒŒKa`^ZRBCEIQiw#S#nx(37+-2&@/4)'18=,*%.:0;?5"
[c-44]-34:-3;c;c/=2)putch(c/2?46-c%2:0);}
À mon avis, cette dernière version est beaucoup plus attrayant visuellement, trop. Et non, ce n'est pas portable, et il n'est plus protégé contre les hors-limites d'entrée. Il a également un assez mauvais UI, en prenant caractère par caractère entrée et de le convertir en code Morse et d'avoir Non sortie condition (vous devez cliquer sur Ctrl + Break ). Mais un code portable et robuste avec une interface conviviale n'était pas une exigence.
voici une brève explication du code:
main(c){
while(c = toupper(getch())) /* well, *sort of* an exit condition */
for(c =
c - 32 ? // effectively: "if not space character"
"•ƒŒKa`^ZRBCEIQiw#S#nx(37+-2&@/4)'18=,*%.:0;?5"[c - 44] - 34
/* This array contains a binary representation of the Morse Code
* for all characters between comma (ASCII 44) and capital Z.
* The values are offset by 34 to make them all representable
* without escape codes (as long as chars > 127 are allowed).
* See explanation after code for encoding format.
*/
: -3; /* if input char is space, c = -3
* this is chosen because -3 % 2 = -1 (and 46 - -1 = 47)
* and -3 / 2 / 2 = 0 (with integer truncation)
*/
c; /* continue loop while c != 0 */
c /= 2) /* shift down to the next bit */
putch(c / 2 ? /* this will be 0 if we're down to our guard bit */
46 - c % 2 /* We'll end up with 45 (-), 46 (.), or 47 (/).
* It's very convenient that the three characters
* we need for this exercise are all consecutive.
*/
: 0 /* we're at the guard bit, output blank space */
);
}
chaque caractère de la chaîne longue du code contient le code Morse encodé pour un caractère de texte. Chaque bit du caractère codé représente soit un tiret ou un point. Un représente un tableau de bord, et un zéro représente un point. Le bit le moins significatif représente le premier tiret ou point du code Morse. Un dernier bit" guard " détermine la longueur du code. C'est-à-dire que le bit le plus élevé dans chaque caractère encodé représente la fin du code et n'est pas imprimé. Sans ce bit de garde, les caractères avec des points de fuite ne pourraient pas être imprimés correctement.
par exemple, la lettre "L" est .-.. en code Morse. Pour représenter ceci en binaire, il faut un 0, un 1, et deux 0 supplémentaires, en commençant par le bit le moins significatif: 0010. Tack un plus 1 pour une garde peu, et nous avons codé en Morse Code: 10010, ou décimal 18. Ajoutez le + 34 offset pour obtenir 52, qui est la valeur ASCII du caractère '4'. Ainsi, le tableau de caractères encodés a un ' 4 ' comme 33ème caractère (index 32).
This la technique est similaire à celle utilisée pour encoder les caractères dans Acoolie's , strager's (2) , les solutions de Miles, de pingw33n, , D'Alec, et D'Andrea, , mais est légèrement plus simple, ne nécessitant qu'une opération par bit (déplacement/Division), plutôt que deux (déplacement/division et Décrémentation).
EDIT:
En lisant le reste des implémentations, je vois que Alec et Anon ont trouvé ce schéma d'encodage-en utilisant le bit de garde-avant moi. La solution d'Anon est particulièrement intéressante, en utilisant la fonctionbinde Python et en enlevant le préfixe"0b"et le bit de garde avec[3:], plutôt que looping, anding, and shifting, comme Alec et moi.
en bonus, cette version gère également le trait d'Union ( -....- ), la barre oblique ( -..-. ), le côlon ( ---... ), le point-virgule ( -.-.-. ), égale ( -...- ), et au signe ( .--.-. ). Aussi longtemps que les caractères de 8 bits sont autorisés, ces caractères n'ont pas besoin d'octets de code supplémentaires pour être pris en charge. Plus aucun caractère ne peut être supporté avec cette version sans ajouter de longueur au code (sauf S'il y a des Codes pour plus grand / moins que des signes).
parce que je trouve les anciennes implémentations toujours intéressantes, et le texte comporte quelques mises en garde applicables à cette version, j'ai laissé le contenu précédent de ce post ci-dessous.
OK, probablement, l'interface utilisateur peut être nulle, non? Donc, en empruntant à strager , j'ai remplacé gets() , qui fournit un tampon, l'entrée de ligne d'écho, avec getch() , qui fournit une entrée de caractère non tamponnée et non censurée. Cela signifie que chaque caractère que vous tapez est immédiatement traduit en code Morse sur l'écran. Peut-être que c'est cool. Il ne fonctionne plus avec stdin ou un argument en ligne de commande, mais il est sacrément petit.
j'ai gardé l'ancien code ci-dessous, à titre de référence. Voici le nouveau.
nouveau code, avec vérification des limites, 171 caractères:
W(i){i?W(--i/2),putch(46-i%2):0;}c;main(){while(c=toupper(getch())-13)
c=c-19?c>77|c<31?0:W("œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"
[c-31]-42):putch(47),putch(0);}
Enter coupe la boucle et sort du programme.
nouveau code, sans vérification des limites, 159 caractères:
W(i){i?W(--i/2),putch(46-i%2):0;}c;main(){while(c=toupper(getch())-13)
c=c-19?W("œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"[c-31]-42):
putch(47),putch(0);}
ci-dessous suit l'ancien code 196/177, avec quelques explications:
W(i){i?W(--i/2),putch(46-i%2):0;}main(){char*p,c,s[99];gets(s);
for(p=s;*p;)c=*p++,c=toupper(c),c=c-32?c>90|c<44?0:W(
"œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"[c-44]-42):
putch(47),putch(0);}
Ceci est basé sur Andrea Python réponse , en utilisant la même technique pour générer le code morse comme dans cette réponse. Mais au lieu de stocker les caractères codables on après l'autre et de trouver leurs index, j'ai stocké les index l'un après l'autre et les rechercher par caractère (semblable à ma réponse précédente ). Cela évite les longs trous près de la fin qui ont causé des problèmes pour les premiers réalisateurs.
comme avant , j'ai utilisé un caractère qui est supérieur à 127. La convertir en ASCII-ajoute seulement 3 caractères. Le premier caractère de la longue chaîne doit être remplacée par \x9C . L'offset est nécessaire cette fois, sinon un grand nombre de caractères est inférieur à 32, et doit être représenté avec des codes d'échappement.
comme avant, le traitement d'un argument de ligne de commande au lieu de stdin ajoute 2 caractères, et l'utilisation d'un caractère d'espace réel entre les codes ajoute 1 caractère.
d'un autre côté, certaines des autres routines ici ne traitent pas avec l'entrée en dehors de la gamme acceptée de [ ,.0-9\?A-Za-z]. Si une telle manipulation était supprimée de cette routine, alors 19 caractères pourraient être supprimés, ramenant le total à aussi peu que 177 caractères. Mais si cela est fait, et que des entrées invalides sont transmises à ce programme, il peut s'écraser et brûler.
le code dans ce cas pourrait être:
W(i){i?W(--i/2),putch(46-i%2):0;}main(){char*p,s[99];gets(s);
for(p=s;*p;p++)*p=*p-32?W(
"œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"
[toupper(*p)-44]-42):putch(47),putch(0);}
Perl, 170 caractères (avec un peu d'aide du golfeur accompli mauke ). Enveloppé pour plus de clarté; toutes les lignes sont amovibles.
$_=uc<>;y,. ,|/,;s/./$& /g;@m{A..Z,0..9,qw(| , ?)}=
".-NINNN..]IN-NII..AMN-AI---.M-ANMAA.I.-].AIAA-NANMMIOMAOUMSMSAH.B.MSOIONARZMIZ"
=~/../g;1while s![]\w|,?]!$m{$&}!;print
explication:
- extrait du dictionnaire morse. Chaque symbole est défini en termes de deux caractères, qui peuvent être soit des points littéraux ou des tirets, ou une référence à la valeur d'un autre caractère défini. E et T contiennent des jarres factices pour éviter de désyncroiser le décodeur; nous allons les enlever tard.
- lire et formater l'entrée.
"Hello world"devient"H E L L O / W O R L D" - l'étape suivante dépend du fait que les dictionnaires d'entrée et de sortie sont distincts, de sorte que tourner les points dans l'entrée vers un caractère non utilisé (barre verticale,
|) - remplacer tout car dans l'entrée qui se trouve dans le dictionnaire morse avec sa valeur dans le dictionnaire, jusqu'à ce qu'aucun remplacement ne se produit.
- supprimer le mannequin char mentionné à étape 1.
- Imprimer la sortie.
dans la version finale, le dictionnaire est optimisé pour l'efficacité d'exécution:
- tous les caractères à un symbole (E et T) et les caractères à deux symboles (A, I, M et N) sont définis directement et décodés en un seul passage.
- les caractères à trois symboles sont définis en termes de deux symboles et d'un symbole littéral, décodé en deux passes.
- les caractères à quatre symboles sont définis en termes de deux caractères à deux symboles, décodés en deux passes avec trois remplacements.
- les caractères à cinq et à six symboles (nombres et ponctuation) sont décodés en trois passes, avec respectivement quatre ou cinq remplacements.
depuis le code golfé remplace seulement un caractère par boucle (pour sauver un caractère de code!) le nombre de boucles est limité à cinq fois la longueur de l' d'entrée (trois fois la longueur de l'entrée, si seulement l'alphabet sont utilisées). Mais en ajoutant un g à l'opération s/// , le nombre de boucles est limité à trois (deux si on n'utilise que l'ordre alphabétique).
exemple de transformation:
Hello 123
H E L L O / 1 2 3
II .] AI AI M- / AO UM SM
.... . .-.. .-.. --- / .-M- .A-- I.--
.... . .-.. .-.. --- / .---- ..--- ...--
Python compréhension de liste, 159 caractères one-liner
for c in raw_input().upper():print c<","and"/"or bin(ord("•ƒwTaQIECBRZ^`šŒ#S#n|':<.2&9/6)(18?,*%+3-;=>"[ord(c)-44])-34)[3:].translate(" "*47+"/.-"+" "*206),
utilise l'empaquetage de données similaire à P l'implémentation C de Daddy , mais ne stocke pas les bits dans l'ordre inverse et utilise bin() pour extraire les données plutôt que l'arithmétique. Notez également que les espaces sont détectés en utilisant l'inégalité; il considère chaque caractère "inférieur à virgule" comme un espace.
Python for boucle, 205 caractères y compris les retours à la ligne
for a in raw_input().upper():
q='_ETIANMSURWDKGOHVF_L_PJBXCYZQ__54_3___2__+____16=/_____7___8_90'.find(a);s=''
while q>0:s='-.'[q%2]+s;q=~-q/2
print['/','--..--','..--..','.-.-.-',''][' ,?.'.find(a)]+s,
j'ai travaillé avec un codage compact pour les symboles, mais je ne vois pas si obtenir mieux que les arbres implicites déjà en usage, donc je présente le codage ici au cas où quelqu'un d'autre peut l'utiliser.
Considérez la chaîne:
--..--..-.-.-..--...----.....-----.--/
qui contient toutes les séquences nécessaires comme substrats. Nous pourrions coder les symboles par offset et longueur comme ceci:
ET RRRIIGGGJJJJ
--..--..-.-.-..--...----.....-----.--/
CCCC DD WWW 00000
,,,,,, AALLLL BBBB 11111
--..--..-.-.-..--...----.....-----.--/
?????? KKK MMSSS 22222
FFFF PPPP 33333
--..--..-.-.-..--...----.....-----.--/
UUU XXXX 44444
NN PPPP OOO 55555
--..--..-.-.-..--...----.....-----.--/
ZZZZ 66666
77777 YYYY
--..--..-.-.-..--...----.....-----.--/
...... 88888 HHHH
99999 VVVV QQQQ
--..--..-.-.-..--...----.....-----.--/
avec le espace (c.-à-d. limite des mots) commençant et se terminant sur le caractère final (le '/'). Se sentir libre de l'utiliser, si vous voyez une bonne façon.
la plupart des symboles courts ont plusieurs codages possibles, bien sûr.
P Daddy a trouvé une version plus courte de cette astuce (et je peux maintenant Voir au moins une partie de la redondance ici) et a fait une mise en œuvre de C nice. Alec a fait une implémentation python avec le premier (buggy et incomplète) de la version. Hobbs a fait une version perl assez compacte que je ne comprends pas du tout.
J, 124 130 134 caractères
'.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`dfggggggg-@B4*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper
J bat C! Génial!
Utilisation:
'.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`dfggggggg-@B4*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper 'Hello World'
.... . .-.. .-.. --- / .-- --- .-. .-.. -..
'.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`dfggggggg-@B4*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper 'Hello, Stackoverflow.'
.... . .-.. .-.. --- .-.-.- / ... - .- -.-. -.- --- ...- . .-. ..-. .-.. --- .-- --..--
Python 3 One Liner: 172 caractères
print(' '.join('/'if c==' 'else''.join('.'if x=='0'else'-'for x in bin(ord("ijÁĕÁÿïçãáàðøüþÁÁÁÁÁČÁÅ×ÚÌÂÒÎÐÄ×ÍÔÇÆÏÖÝÊÈÃÉÑËÙÛÜ"[ord(c)-44])-192)[3:])for c in input().upper()))
(Encoding the translation table into unicode code points. Fonctionne très bien, et ils s'affichent ici très bien dans mon test sur ma machine Windows Vista.)
modifié pour réduire à 184 caractères en supprimant certains espaces et crochets inutiles (ce qui rend la liste comps Gen exps).
éditer à nouveau: plus d'espaces supprimés que je ne savais même pas était possible avant de voir d'autres réponses ici - donc à 176.
éditer à nouveau vers le bas à 172 (woo woo!) en utilisant " ".rejoindre la place de ".joindre et faire les espaces séparément. (duh!)
C# 266 caractères
L'131 char C solution convertis en C# rendements 266 caractères:
foreach(var i in Encoding.ASCII.GetBytes(args[0].ToUpper())){var c=(int)i;for(c=(c-32!=0)?Encoding.ASCII.GetBytes("•ƒŒKa`^ZRBCEIQiw#S#nx(37+-2&@/4)'18=,*%.:0;?5")[c-44]-34:-3;c!=0;c/=2)Console.Write(Encoding.ASCII.GetChars(new byte[]{(byte)((c/2!=0)?46-c%2:0)}));}
qui est plus lisible comme:
foreach (var i in Encoding.ASCII.GetBytes(args[0].ToUpper()))
{
var c = (int)i;
for (c = ((c - 32) != 0) ? Encoding.ASCII.GetBytes("•ƒŒKa`^ZRBCEIQiw#S#nx(37+-2&@/4)'18=,*%.:0;?5")[c - 44] - 34 : -3
; c != 0
; c /= 2)
Console.Write(Encoding.ASCII.GetChars(new byte[] { (byte)((c / 2 != 0) ? 46 - c % 2 : 0) }));
}
Golfscript-106 chars-NO FUNNY CHARS:)
la nouvelle ligne à la fin de l'entrée n'est pas supportée, donc utilisez quelque chose comme ça
echo -n Hello, Stackoverflow| ../golfscript.rb morse.gs
' '/{{.32|"!etianmsurwdkgohvf!l!pjbxcyzq"?)"UsL?/'#! 08<>"@".,?0123456789"?=or
2base(;>{'.-'\=}%' '}%}%'/'*
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
Python
solution Incomplète, mais peut-être que quelqu'un peut apporter une solution complète. Ne gère pas les chiffres ou la ponctuation, mais pèse seulement 154 caractères.
def e(l):
i='_etianmsurwdkgohvf_l_pjbxcyzq'.find(l.lower());v=''
while i>0:v='-.'[i%2]+v;i=(i-1)/2;return v or '/'
def enc(s):return ' '.join(map(e,s))
C (248 caractères)
une autre solution basée sur l'arbre.
#define O putchar
char z[99],*t=
" ETINAMSDRGUKWOHBL~FCPJVX~YZQ~~54~3~~~2~~+~~~~16=/~~.~~7,~~8~90";c,p,i=0;
main(){gets(z);while(c=z[i++]){c-46?c-44?c:O(45):O(c);c=c>96?c-32:c;p=-1;
while(t[++p]!=c);for(;p;p/=2){O(45+p--%2);}c-32?O(32):(O(47),O(c));}}
pourrait être des erreurs dans l'arbre des sources parce que wikipedia semble avoir tort ou peut-être j'ai mal compris quelque chose.
F#, 256 caractères
let rec D i=if i=16 then" "else
let x=int"U*:+F8c]uWjGbJ0-0Dnmd0BiC5?o`h7f>9[1E=pr_".[i]-32
if x>43 then"-"+D(x-43)else"."+D x
let M(s:string)=s.ToUpper()|>Seq.fold(fun s c->s+match c with
|' '->"/ "|','->"--..-- "|'.'->".-.-.- "|_->D(int c-48))""
par exemple
M("Hello, Stack.") |> printfn "%s"
rendements
.... . .-.. .-.. --- --..-- / ... - .- -.-. -.- .-.-.-
je pense que ma technique peut être unique jusqu'à présent. L'idée est:
- il existe une gamme de chars ascii qui couvre la plupart de ce que nous voulons (0..Z)
- il n'y a que 43 chars dans cette gamme
- ainsi nous pouvons encoder un bit (tiret ou point) plus un ' Suivant "dans une gamme de 86 caractères
- la gamme ascii (32-117) est tout "imprimable" et peut servir de cette gamme de 86-char
- ainsi la chaîne littérale code une table de ce genre
il y a un peu plus, mais c'est l'essentiel. Virgule, Période, et l'espace ne sont pas dans la gamme 0..Z donc ils sont gérés spécialement par le "match". Quelques caractères "inutilisés" dans la gamme 0..Z (comme le ';') sont utilisés dans le tableau des suffixes d'autres traductions en morse qui ne sont pas des "lettres" en morse.
voici ma contribution en tant qu'application de console en VB.Net
Module MorseCodeConverter
Dim M() As String = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..", "-----", ".----", "..---", "...--", "....-", ".....", "-....", "--...", "---..", "----."}
Sub Main()
Dim I, O
Dim a, b
While True
I = Console.ReadLine()
O = ""
For Each a In I
b = AscW(UCase(a))
If b > 64 And b < 91 Then
O &= M(b - 65) & " "
ElseIf b > 47 And b < 58 Then
O &= M(b - 22) & " "
ElseIf b = 46 Then
O &= ".-.-.- "
ElseIf b = 44 Then
O &= "--..-- "
ElseIf b = 63 Then
O &= "..--.. "
Else
O &= "/"
End If
Next
Console.WriteLine(O)
End While
End Sub
End Module
j'ai laissé l'espace blanc pour le rendre lisible. Totalise 1 100 caractères. Il lit l'entrée de la ligne de commande, une ligne à la fois, et renvoie la sortie correspondante au flux de sortie. La version compressée est ci-dessous, avec seulement 632 caractères.
Module Q
Dim M() As String={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."}
Sub Main()
Dim I,O,a,b:While 1:I=Console.ReadLine():O="":For Each a In I:b=AscW(UCase(a)):If b>64 And b<91 Then:O &=M(b-65)&" ":ElseIf b>47 And b<58 Then:O &=M(b-22)&" ":ElseIf b=46 Then:O &=".-.-.- ":ElseIf b=44 Then:O &="--..-- ":ElseIf b=63 Then:O &= "..--.. ":Else:O &="/":End IF:Next:Console.WriteLine(O):End While
End Sub
End Module
C (233 caractères)
W(n,p){while(n--)putch(".-.-.--.--..--..-.....-----..../"[p++]);}main(){
char*p,c,s[99];gets(s);for(p=s;*p;){c=*p++;c=toupper(c);c=c>90?35:c-32?
"È#À#¶µ´³²±°¹¸·#####Ê#@i Že‘J•aEAv„…`q!j“d‰ƒˆ"[c-44]:63;c-35?
W(c>>5,c&31):0;putch(0);}}
ceci prend l'entrée de stdin. La saisie de la ligne de commande ajoute 2 caractères. Au lieu de:
...main(){char*p,c,s[99];gets(s);for(p=s;...
, vous obtenez:
...main(int i,char**s){char*p,c;for(p=s[1];...
j'utilise Windows-1252 page de code pour les caractères au-dessus de 127, et je ne suis pas sûr de savoir comment ils vont apparaître dans les navigateurs d'autres personnes. Je remarque que, dans mon navigateur (Google Chrome), deux des personnages (entre le "@" et "je") ne se montrent pas. Si vous copiez hors du navigateur et collez dans un éditeur de texte, cependant, ils apparaissent, bien que sous forme de petites boîtes.
il peut être converti en ASCII-seulement, mais cela ajoute 24 caractères, augmentant le nombre de caractères à 257. Pour ce faire, j'ai d'abord décalé chaque caractère de la chaîne par -64, minimisant le nombre de caractères qui sont supérieurs à 127. Puis je substitue \x XX le caractère échappe là où nécessaire. Il change ceci:
...c>90?35:c-32?"È#À#¶µ´³²±°¹¸·#####Ê#@i Že‘J•aEAv„…`q!j“d‰ƒˆ"[c-44]:63;
c-35?W(...
à ceci:
...c>90?99:c-32?"\x88#\x80#vutsrqpyxw#####\x8A#"151940920"PA)\xE0N%Q\nU!ODE 1
\xE1*S$ICH"[c-44]+64:63;c-99?W(...
Voici une version plus joliment formatée et commentée du code:
/* writes `n` characters from internal string to stdout, starting with
* index `p` */
W(n,p){
while(n--)
/* warning for using putch without declaring it */
putch(".-.-.--.--..--..-.....-----..../"[p++]);
/* dmckee noticed (http://tinyurl.com/n4eart) the overlap of the
* various morse codes and created a 37-character-length string that
* contained the morse code for every required character (except for
* space). You just have to know the start index and length of each
* one. With the same idea, I came up with this 32-character-length
* string. This not only saves 5 characters here, but means that I
* can encode the start indexes with only 5 bits below.
*
* The start and length of each character are as follows:
*
* A: 0,2 K: 1,3 U: 10,3 4: 18,5
* B: 16,4 L: 15,4 V: 19,4 5: 17,5
* C: 1,4 M: 5,2 W: 4,3 6: 16,5
* D: 9,3 N: 1,2 X: 9,4 7: 25,5
* E: 0,1 O: 22,3 Y: 3,4 8: 24,5
* F: 14,4 P: 4,4 Z: 8,4 9: 23,5
* G: 5,3 Q: 5,4 0: 22,5 .: 0,6
* H: 17,4 R: 0,3 1: 21,5 ,: 8,6
* I: 20,2 S: 17,3 2: 20,5 ?: 10,6
* J: 21,4 T: 1,1 3: 19,5
*/
}
main(){ /* yuck, but it compiles and runs */
char *p, c, s[99];
/* p is a pointer within the input string */
/* c saves from having to do `*p` all the time */
/* s is the buffer for the input string */
gets(s); /* warning for use without declaring */
for(p=s; *p;){ /* begin with start of input, go till null character */
c = *p++; /* grab *p into c, increment p.
* incrementing p here instead of in the for loop saves
* one character */
c=toupper(c); /* warning for use without declaring */
c = c > 90 ? 35 : c - 32 ?
"È#À#¶µ´³²±°¹¸·#####Ê#@i Že‘J•aEAv„…`q!j“d‰ƒˆ"[c - 44] : 63;
/**** OR, for the ASCII version ****/
c = c > 90 ? 99 : c - 32 ?
"\x88#\x80#vutsrqpyxw#####\x8A#"151950920"PA)\xE0N%Q\nU!ODE 1\xE1"
"*S$ICH"[c - 44] + 64 : 63;
/* Here's where it gets hairy.
*
* What I've done is encode the (start,length) values listed in the
* comment in the W function into one byte per character. The start
* index is encoded in the low 5 bits, and the length is encoded in
* the high 3 bits, so encoded_char = (char)(length << 5 | position).
* For the longer, ASCII-only version, 64 is subtracted from the
* encoded byte to reduce the necessity of costly \xXX representations.
*
* The character array includes encoded bytes covering the entire range
* of characters covered by the challenge, except for the space
* character, which is checked for separately. The covered range
* starts with comma, and ends with capital Z (the call to `toupper`
* above handles lowercase letters). Any characters not supported are
* represented by the "#" character, which is otherwise unused and is
* explicitly checked for later. Additionally, an explicit check is
* done here for any character above 'Z', which is changed to the
* equivalent of a "#" character.
*
* The encoded byte is retrieved from this array using the value of
* the current character minus 44 (since the first supported character
* is ASCII 44 and index 0 in the array). Finally, for the ASCII-only
* version, the offset of 64 is added back in.
*/
c - 35 ? W(c >> 5, c & 31) : 0;
/**** OR, for the ASCII version ****/
c - 99 ? W(c >> 5, c & 31) : 0;
/* Here's that explicit check for the "#" character, which, as
* mentioned above, is for characters which will be ignored, because
* they aren't supported. If c is 35 (or 99 for the ASCII version),
* then the expression before the ? evaluates to 0, or false, so the
* expression after the : is evaluated. Otherwise, the expression
* before the ? is non-zero, thus true, so the expression before
* the : is evaluated.
*
* This is equivalent to:
*
* if(c != 35) // or 99, for the ASCII version
* W(c >> 5, c & 31);
*
* but is shorter by 2 characters.
*/
putch(0);
/* This will output to the screen a blank space. Technically, it's not
* the same as a space character, but it looks like one, so I think I
* can get away with it. If a real space character is desired, this
* must be changed to `putch(32);`, which adds one character to the
* overall length.
} /* end for loop, continue with the rest of the input string */
} /* end main */
c'est mieux que tout ici sauf quelques implémentations Python. Je n'arrête pas de penser qu'il ne peut pas être plus court, mais je trouve un moyen de raser un peu plus de personnages. Si quelqu'un peut trouver d'autres améliorations, faites-le moi savoir.
EDIT:
j'ai remarqué que, bien que cette routine rejette tous les caractères invalides au-dessus de ASCII 44 (outputing juste un espace vide pour chacun), elle ne vérifie pas les caractères invalides au-dessous de cette valeur. Pour vérifier ces Ajoute 5 caractères à la longueur totale, en changeant ceci:
...c>90?35:c-32?"...
à ceci:
...c-32?c>90|c<44?35:"...
REBOL (118 caractères)
Un peu près 10 ans de mise en œuvre
foreach c ask""[l: index? find" etinamsdrgukwohblzfcpövxäqüyj"c while[l >= 2][prin pick"-."odd? l l: l / 2]prin" "]
Cité de: http://www.rebol.com/oneliners.html
(aucun chiffre cependant et les mots sont juste séparés par des espaces doubles :/ ...)
Python (210 caractères)
il s'agit d'une solution complète basée sur Alec 'S one
def e(l):
i=(' etianmsurwdkgohvf_l_pjbxcyzq__54_3___2%7s16%7s7___8_90%12s?%8s.%29s,'%tuple('_'*5)).find(l.lower());v=''
while i>0:v='-.'[i%2]+v;i=(i-1)/2
return v or '/'
def enc(s):return ' '.join(map(e,s))
C, 338 caractères
338 avec indentation et tous les linebreaks amovibles enlevés:
#define O putchar
#define W while
char*l="x@@@@@ppmmmmm@@FBdYcbcbSd[Kcd`(\b1g_<qCN:_'|D$W[QH0";
int c,b,o;
main(){
W(1){
W(c<32)
c=getchar()&127;
W(c>96)
c^=32;
c-=32;
o=l[c/2]-64;
b=203+(c&1?o>>3:0);
o=c&1?o&7:o>>3;
W(o>6)
O(47),o=0;
c/=2;
W(c--)
b+=(l[c]-64&7)+(l[c]-64>>3);
b=(((l[b/7]<<7)+l[b/7+1])<<(b%7))>>14-o;
W(o--)
O(b&(1<<o)?46:45);
O(32);
}
}
ce n'est pas basé sur l'approche de l'arbre que d'autres personnes ont adopté. Au lieu de cela, l code d'abord les longueurs de tous les octets entre 32 et 95 inclusivement, deux octets à un caractère. Comme un exemple, D à -.. pour une longueur de 3 et E est . pour une longueur de 1. Ceci est codé comme 011 et 001, donnant 011001. De rendre plus de caractères codables et éviter les échappées, 64 est alors ajouté au total, ce qui donne 1011001 - 89, ASCII Y. les caractères Non morse sont assignés une longueur de 0. La seconde moitié de l (commençant par 1 ) sont les bits du code morse lui-même, avec un point étant 1 et un tiret 0. Pour éviter d'aller dans le haut ASCII, ces données sont encodées 7 bits / octet.
le code assainit d'abord c , puis calcule la longueur en morse de c (en o ), puis additionne les longueurs de tous les caractères précédents pour produire b , l'index de bits dans les données.
enfin, il boucle à travers les bits, en imprimant des points et des tirets.
la longueur '7' est utilisée comme drapeau spécial pour imprimer a / lors de la rencontre avec un espace.
Il y a probablement quelques petits gains à partir de la suppression des crochets, mais je suis loin de certains des meilleurs résultats et je suis affamé...
C# à l'Aide de Linq (133 caractères)
static void Main()
{
Console.WriteLine(String.Join(" ", (from c in Console.ReadLine().ToUpper().ToCharArray()
select m[c]).ToArray()));
}
OK, donc j'ai triché. Vous devez également définir un dictionnaire comme suit (n'a pas pris la peine de compter les caractères, puisque cela me souffle hors du jeu):
static Dictionary<char, string> m = new Dictionary<char, string>() {
{'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', "----."},
{' ', "/"},
{'.', ".-.-.-"},
{',', "--..--"},
{'?', "..--.."},
};
encore, quelqu'un peut-il fournir un c# implémentation plus concise qui est aussi facile à comprendre et à maintenir que ceci?
Perl, 206 caractères, utilisant l'idée de dmckee
C'est plus long que le premier que j'ai soumis, mais je pense toujours que c'est intéressant . Et/ou terrible. Je ne suis pas encore sûr. Cela fait usage de l'idée de codage de dmckee, plus un couple d'autres bonnes idées que j'ai vu autour. Au départ, j'ai pensé que la chose "longueur / offset dans une chaîne fixe" ne pouvait pas sortir à moins de données que le schéma dans mon autre solution, qui utilise une chaîne fixe deux octets par caractère (et tous les octets imprimables, en plus). J'ai en fait réussi à obtenir les données à beaucoup moins (un octet par char, plus quatre octets pour stocker le modèle de 26 bits dans lequel nous indexons) mais le code pour le sortir à nouveau est plus long, malgré mes meilleurs efforts pour le golf. (Moins complexe, IMO, mais plus long de toute façon).
quoi qu'il en soit, 206 caractères; les lignes sont amovibles sauf la première.
#!perl -lp
($a,@b)=unpack"b32C*",
"427"151900920"SF1I.TN/G8XE0=\x002V7HMRfermlkjihgx75";
$a=~y/01/-./;@m{A..Z,0..9,qw(. , ?)}=map{substr$a,$_%23,1+$_/23}@b;
$_=join' ',map$m{uc$_}||"/",/./g
explication:
- il y a deux parties aux données. Les quatre premiers octets (
"427"151910920"") représentent 32 bits de code morse ("--.-..-.-.-----.....--..--------") bien que seuls les 26 premiers bits soient utilisés. C'est la "chaîne de référence". - le reste de la chaîne de données stocke la position de départ et la longueur des sous-chaînes de la chaîne de référence qui représentent chaque caractère -- un octet par caractère, dans l'ordre (A, b, ... Z, 0, 1,... 9,".", ",", "?"). Les valeurs sont codées comme 23 * (Longueur-1) + pos, et le décodeur inverse. Le dernier pos de départ est bien sûr 22.
- donc le déballage fait la moitié du travail d'extraction des données et la troisième ligne (comme vu ici) fait le reste, maintenant nous avons un hachage avec
$m{'a'} = '.-'et cetera, donc tout ce qui reste est de faire correspondre les caractères de l'entrée, les rechercher dans le hachage, et formater la sortie, ce que fait la dernière ligne... avec l'aide du shebang, qui dit à perl de supprimer la nouvelle ligne sur input, mettre des lignes d'input dans$_, et lorsque le code est terminé, écrivez$_de nouveau à la sortie avec de nouvelles lignes ajoutées à nouveau.
Python 2; 171 caractères
essentiellement le même que la solution D'Andrea , mais comme un programme complet, et en utilisant des trucs stupides pour le rendre plus court.
for c in raw_input().lower():print"".join(".-"[int(d)]for d in bin(
(' etianmsurwdkgohvf_l_pjbxcyzq__54_3___2%7s16%7s7___8_90%12s?%8s.%29s,'
%(('',)*5)).find(c))[3:])or'/',
(l'ajout de nouvelles lignes peuvent tous être supprimés)
ou, si vous préférez ne pas utiliser la fonction bin() en 2.6, nous pouvons le faire en 176:
for c in raw_input():C=lambda q:q>0and C(~-q/2)+'-.'[q%2]or'';print C(
(' etianmsurwdkgohvf_l_pjbxcyzq__54_3___2%7s16%7s7___8_90%12s?%8s.%29s,'%
(('',)*5)).find(c.lower()))or'/',
(encore une fois, les nouvelles lignes ajoutées peuvent toutes être enlevées)
C89 (293 caractères)
basé sur certaines des autres réponses.
EDIT: Réduit l'arbre (yay).
#define P putchar
char t['~']="~ETIANMSURWDKGOHVF~L~PJBXCYZQ~~54~3",o,q[9],Q=10;main(c){for(;Q;)t[
"&./7;=>KTr"[--Q]]="2167890?.,"[Q];while((c=getchar())>=0){c-=c<'{'&c>96?32:0;c-
10?c-32?0:P(47):P(10);for(o=1;o<'~';++o)if(t[o]==c){for(;o;o/=2)q[Q++]=45+(o--&1
);for(;Q;P(q[--Q]));break;}P(32);}}
Voici une autre approche, basée sur le travail de dmckee, démontrant à quel point Python est lisible:
Python
244 caractères
def h(l):p=2*ord(l.upper())-88;a,n=map(ord,"AF__GF__]E\E[EZEYEXEWEVEUETE__________CF__IBPDJDPBGAHDPC[DNBSDJCKDOBJBTCND`DKCQCHAHCZDSCLD??OD"[p:p+2]);return "--..--..-.-.-..--...----.....-----.-"[a-64:a+n-128]
def e(s):return ' '.join(map(h,s))
Limitations:
- la chaîne de caractères de dmckee a manqué le caractère "Y", et j'étais trop paresseux pour l'ajouter. Je pense que tu devrais juste changer le "??"une partie, et ajouter un "-" à la fin de la deuxième chaîne littérale
- il ne met pas '/' entre les mots; encore une fois, paresseux
comme les règles appelaient pour le moins caractères , pas le moins octets , vous pourriez faire au moins une de mes tables de recherche plus petite (de moitié) si vous étiez prêt à aller à l'extérieur des caractères ASCII imprimables.
EDIT: si j'utilise des caractères Unicode choisis naïvement mais que je les garde dans des ASCII échappés dans le fichier source, il devient quand même un peu plus court parce que le décodeur est plus simple:
Python
240 caractères
def h(l):a,n=divmod(ord(u'\x06_7_\xd0\xc9\xc2\xbb\xb4\xad\xa6\x9f\x98\x91_____\x14_AtJr2<s\xc1d\x89IQdH\x8ff\xe4Pz9;\xba\x88X_f'[ord(l.upper())-44]),7);return "--..--..-.-.-..--...----.....-----.-"[a:a+n]
def e(s):return ' '.join(map(h,s))
je pense que cela rend aussi l'intention du programme beaucoup plus claire.
si vous avez enregistré ceci comme UTF-8, je crois que le programme serait en baisse à 185 caractères, ce qui en fait la solution complète Python la plus courte, et la seconde seulement à Perl. :- )
Voici une troisième façon complètement différente d'encoder le code morse:
Python
232 caractères
def d(c):
o='';b=ord("Y_j_?><80 !#'/_____f_\x06\x11\x15\x05\x02\x15\t\x1c\x06\x1e\r\x12\x07\x05\x0f\x16\x1b\n\x08\x03\r\x18\x0e\x19\x01\x13"[ord(c.upper())-44])
while b!=1:o+='.-'[b&1];b/=2
return o
e=lambda s:' '.join(map(d,s))
Si vous pouvez trouver un moyen de la carte ce sur un ensemble de caractères imprimables, vous pourriez économiser un peu de caractères. C'est probablement ma solution la plus directe , mais je ne sais pas si c'est la plus lisible.
OK, maintenant j'ai gaspillé chemin trop de temps pour ça.
Haskell
type MorseCode = String
program :: String
program = "__5__4H___3VS__F___2 UI__L__+_ R__P___1JWAE"
++ "__6__=B__/_XD__C__YKN__7_Z__QG__8_ __9__0 OMT "
decode :: MorseCode -> String
decode = interpret program
where
interpret = head . foldl exec []
exec xs '_' = undefined : xs
exec (x:y:xs) c = branch : xs
where
branch (' ':ds) = c : decode ds
branch ('-':ds) = x ds
branch ('.':ds) = y ds
branch [] = [c]
par exemple, decode "-- --- .-. ... . -.-. --- -.. ." renvoie "MORSE CODE" .
ce programme est tiré de l'excellent article Fun with Morse Code .
PHP
j'ai modifié la entrée PHP précédente pour être légèrement plus efficace. :)
$a=array(32=>"/",44=>"--..--",1,".-.-.-",48=>"-----",".----","..---","...--","....-",".....","-....","--...","---..","----.",63=>"..--..",1,".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..");
foreach(str_split(strtoupper("hello world?"))as$k=>$v){echo $a[ord($v)]." ";}
Komodo dit 380 caractères sur 2 lignes - la ligne supplémentaire est juste pour la lisibilité. ;D Le 1s intercalé dans le tableau est juste pour sauver 2 bytes en remplissant la position du tableau avec des données au lieu de sauter manuellement à la position du tableau après cela.
l'examen de la première contre la seconde. Le la différence est clairement visible. :)
array(20=>"data",22=>"more data";
array(20=>"data",1,"more data";
le résultat final, cependant, est exactement aussi longtemps que vous utilisez les positions du réseau plutôt que la boucle à travers le contenu, ce que nous ne faisons pas sur ce terrain de golf.
résultat final: 578 caractères, jusqu'à 380 (198 caractères, soit environ 34,26% d'économies).
Bash , un script que j'ai écrit il y a un certain temps (horodatage dit l'année dernière) pesant à un fort 1661 caractères. Juste pour le fun :)
#!/bin/sh
txt=''
res=''
if [ "" == '' ]; then
read -se txt
else
txt=""
fi;
len=$(echo "$txt" | wc -c)
k=1
while [ "$k" -lt "$len" ]; do
case "$(expr substr "$txt" $k 1 | tr '[:upper:]' '[:lower:]')" in
'e') res="$res"'.' ;;
't') res="$res"'-' ;;
'i') res="$res"'..' ;;
'a') res="$res"'.-' ;;
'n') res="$res"'-.' ;;
'm') res="$res"'--' ;;
's') res="$res"'...' ;;
'u') res="$res"'..-' ;;
'r') res="$res"'.-.' ;;
'w') res="$res"'.--' ;;
'd') res="$res"'-..' ;;
'k') res="$res"'-.-' ;;
'g') res="$res"'--.' ;;
'o') res="$res"'---' ;;
'h') res="$res"'....' ;;
'v') res="$res"'...-' ;;
'f') res="$res"'..-.' ;;
'l') res="$res"'.-..' ;;
'p') res="$res"'.--.' ;;
'j') res="$res"'.---' ;;
'b') res="$res"'-...' ;;
'x') res="$res"'-..-' ;;
'c') res="$res"'-.-.' ;;
'y') res="$res"'-.--' ;;
'z') res="$res"'--..' ;;
'q') res="$res"'--.-' ;;
'5') res="$res"'.....' ;;
'4') res="$res"'....-' ;;
'3') res="$res"'...--' ;;
'2') res="$res"'..---' ;;
'1') res="$res"'.----' ;;
'6') res="$res"'-....' ;;
'7') res="$res"'--...' ;;
'8') res="$res"'---..' ;;
'9') res="$res"'----.' ;;
'0') res="$res"'-----' ;;
esac;
[ ! "$(expr substr "$txt" $k 1)" == " " ] && [ ! "$(expr substr "$txt" $(($k+1)) 1)" == ' ' ] && res="$res"' '
k=$(($k+1))
done;
echo "$res"
C89 (388 caractères)
C'est incomplète comme il ne gère pas la virgule, le point, et d'interroger encore.
#define P putchar
char q[10],Q,tree[]=
"EISH54V 3UF 2ARL + WP J 1TNDB6=X/ KC Y MGZ7 Q O 8 90";s2;e(x){q[Q++]
=x;}p(){for(;Q--;putchar(q[Q]));Q=0;}T(int x,char*t,int s){s2=s/2;return s?*t-x
?t[s2]-x?T(x,++t+s2,--s/2)?e(45):T(x,t,--s/2)?e(46):0:e(45):e(46):0;}main(c){
while((c=getchar())>=0){c-=c<123&&c>96?32:0;if(c==10)P(10);if(c==32)P(47);else
T(c,tree,sizeof(tree)),p();P(' ');}}
enveloppé pour plus de lisibilité. Seulement deux linebreaks sont nécessaires (un pour le #define, l'autre après, qui pourrait être un espace). J'ai ajouté quelques caractères non standard mais pas des non-7 bits.
C, 533 caractères
j'ai pris conseil de quelques commentaires et suis passé à stdin. Il a tué environ 70 autres personnages.
#include <stdio.h>
#include <ctype.h>
char *u[36] = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."};
main(){
char*v;int x;char o;
do{
o = toupper(getc(stdin));v=0;if(o>=65&&o<=90)v=u[o-'A'];if(o>=48&&o<=57)v=u[o-'0'+26];if(o==46)v=".-.-.-";if(o==44)v="--..--";if(o==63)v="..--..";if(o==32)v="/";if(v)printf("%s ", v);} while (o != EOF);
}
C (381 caractères)
char*p[36]={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."};
main(){int c;while((c=tolower(getchar()))!=10)printf("%s ",c==46?".-.-.-":c==44?"--..--":c==63?"..--..":c==32?"/":*(p+(c-97)));}
C , 448 octets utilisant les arguments cmdline:
char*a[]={".-.-.-","--..--","..--..","/",".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."},*k=".,? ",*s,*p,x;main(int _,char**v){for(;s=*++v;putchar(10))for(;x=*s++;){p=strchr(k,x);printf("%s ",p?a[p-k]:isdigit(x)?a[x-18]:isalpha(x=toupper(x))?a[x-61]:0);}}
C , 416 octets utilisant stdin:
char*a[]={".-.-.-","--..--","..--..","/",".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."},*k=".,? ",*p,x;main(){while((x=toupper(getchar()))-10){p=strchr(k,x);printf("%s ",p?a[p-k]:isdigit(x)?a[x-18]:isalpha(x)?a[x-61]:0);}}