Cette question implique de prendre des entrées en code Morse comme. (point) et - (symbole moins), avec des espaces pour séparer l'entrée. Votre tâche consiste à convertir le code en sortie standard. Vous pouvez supposer que la seule entrée contient des symboles de caractères trouvés dans l'alphabet International Morse Code, ici: http://en.wikipedia.org/wiki/Morse_code#Letters.2C_numbers.2C_punctuation .

Toutes les sorties doivent utiliser des lettres minuscules. Un double espace doit être interprété comme un espace de mots.

Exemple d'entrée:

. -..- .- -- .--. .-.. . .-.-.-  ... --- ...

Production:

example. sos

Le code le plus court après deux semaines gagne.

Mathematica 62

Mathematica nous permet de tricher

f=ToLowerCase@StringDrop[WolframAlpha[". .- "<>#,"Result"],2]&

f@"."
f@". -..- .- -- .--. .-.. . .-.-.-"
f@".... .- ...- .  -.-- --- ..-  -- --- --- . -..  - --- -.. .- -.-- ..--.."

e

exemple.

avez-vous hué aujourd'hui?

Les deux premiers symboles .et .-sont nécessaires pour interpréter correctement les petits codes.

Drat, j'espérais arriver ici avant l'arrivée des GolfScripters :-(

Anyhoo ...

C: 228 caractères:

char n,t,m[9],*c=" etianmsurwdkgohvf l pjbxcyzq  54 3   2& +    16=/   ( 7   8 90    $       ?_    \"  .    @   '  -        ;! )     ,    :";
main(){while(scanf("%s",m)>0){for(t=m[6]=n=0;m[n];n++)t+=t+1+(m[n]&1);putchar(c[t]);}}

J'ai pensé ajouter une explication sur la façon dont cela fonctionne.

Les données d'entrée sont analysées en fonction des données d'arborescence dans *c, qui peuvent être développées comme suit (en utilisant ·pour représenter un nœud vacant):

                     dot <-- (start) --> dash
                e                               t
        i               a               n               m
    s       u       r       w       d       k       g       o
  h   v   f   ·   l   ·   p   j   b   x   c   y   z   q   ·   ·
 5 4 · 3 · · · 2 & · + · · · · 1 6 = / · · · ( · 7 · · · 8 · 9 0
····$·······?_····"··.····@···'··-········;!·)·····,····:·······

En commençant en haut de l'arbre, descendez en vous déplaçant vers la gauche pour un point et vers la droite pour un tiret. Ensuite, affichez le caractère auquel vous vous trouvez à la fin de la chaîne d'entrée (c'est-à-dire lorsqu'un caractère d'espacement est rencontré). Ainsi, par exemple, trois points et un tiret vous amèneront à vvia e, iet s. Au lieu de vérifier explicitement les points (ASCII \x2e) et les tirets (ASCII \x2d), nous avons seulement besoin de vérifier le dernier bit ( m[n]&1), qui est 0 pour .et 1 pour -.

Six lignes suffisent pour tout coder sauf $, qui a 7 points / tirets:, ...-..-mais comme les données d'entrée sont garanties pour être valides, cela peut facilement être corrigé en tronquant l'entrée à 6 caractères ( m[6]=0) et en interprétant ...-..comme à la $place. Nous pouvons également supprimer les 7 derniers octets des données de l'arborescence, car ils sont tous vides et ne sont pas nécessaires si l'entrée est valide.

GolfScript ( 116 113 97 caractères)

Cela inclut les caractères non imprimables utilisés dans une table de recherche, donc je le donne en sortie xxd:

0000000: 6e2d 2720 272f 7b60 7b5c 6261 7365 2035
0000010: 3925 2210 a9cd 238d 57aa 8c17 d25c d31b
0000020: 432d 783e 277a 3823 e146 e833 6423 23ac
0000030: e72a 39d5 021c 4e33 3b30 3138 dc51 2044
0000040: 3aa7 d001 df4b 2032 333f 36ae 51c3 223d
0000050: 7d2b 5b35 2d34 5d2f 2b32 3333 257d 256e
0000060: 2b

Cela décode en un programme équivalent à

n-' '/{`{\base 59%"\x10\xA9\xCD#\x8DW\xAA\x8C\x17\xD2\\\xD3\eC-x>'z8#\xE1F\xE83d##\xAC\xE7*9\xD5\x02\x1CN3;018\xDCQ D:\xA7\xD0\x01\xDFK 23?6\xAEQ\xC3"=}+[5-4]/+233%}%n+

qui est essentiellement

n-' '/{`{\base 59%"MAGIC STRING"=}+[5-4]/+233%}%n+

Cela utilise un hachage parfait (non minimal) basé sur l'idée de base d' un algorithme optimal pour générer des fonctions de hachage parfaites minimales; Tchèque, Havas et Majewski; 1992 . Leur idée de base est que vous utilisez deux fonctions de hachage, f1et f2, avec une table de recherche g, et le hachage parfait est (g[f1(str)] + g[f2(str)]) % m(où mest le nombre de chaînes que nous souhaitons distinguer); la partie intelligente est la façon dont ils construisent g. Considérez toutes les valeurs f1(str)et les f2(str)chaînes strd'intérêt en tant que nœuds dans un graphique non orienté, et ajoutez un bord entre f1(str)etf2(str)pour chaque chaîne. Ils exigent non seulement que chaque arête soit distincte, mais que le graphe soit acyclique; alors c'est juste un DFS pour assigner des poids aux nœuds (c'est-à-dire pour remplir la table de recherche g) de telle sorte que chaque bord ait la somme requise.

Czech et al génèrent des fonctions aléatoires f1et f2qui sont exprimées via des tables de recherche, mais ce n'est clairement pas bon: j'ai cherché un hachage approprié en utilisant des conversions de base simples avec deux bases distinctes de -10 à 9. J'ai également assoupli l'exigence acyclique. Je ne voulais pas assigner les chaînes à des valeurs de 0 à 54, mais aux codes ASCII correspondants, donc plutôt que d'en prendre (g[f1(str)] + g[f2(str)]) % mje voulais (g[f1(str)] + g[f2(str)]) % Npour certains N > 'z'. Mais cela donne la liberté d'essayer divers Net de voir si l'un d'eux autorise une table de recherche valideg , qu'il y ait des cycles ou non. Contrairement à Czech et al, je me fiche que la recherche de la fonction de hachage parfaite soit O (n ^ 4).

Le graphique généré par -4baseet 5basemod 59est:

ce qui est assez sympa à part le plus gros composant connecté, qui a trois cycles de longueur 1. Il faut remonter N=233avant de pouvoir trouver celui gqui est cohérent.

C, 169 caractères

Je n'ai pas pu trouver une meilleure fonction de hachage ..

(J'ai posté le code non réduit, mais je l'ai compté réduit; pour réduire, faites simplement :%s/ //g | %j!dans vim, puis remettez l'espace dans la chaîne littérale.)

c, v = 1;

main() {
  while (c = getchar(), ~c)
    v = c < 33? putchar(
      "& etianmsurwdkgohvf.l.pjbxcyzq..54.3.;!2).+...,16=/:..(.7.?_8.9o\"...$...@...'..-"[v < 64? (v != 40)*v : v % 51 + 33]
    ), 1 : v * 2 + c % 2;
}

Essai

( morse.inest juste l'alphabet entier en morse sur des lignes séparées):

% clang morse.c && ./a.out </tmp/morse.in
abcdefghijklmnopqrstuvwxyzO123456789.,?'!/()&:;=+-_"$@
% ./a.out <<<'. -..- .- -- .--. .-.. . .-.-.-  ... --- ...'
example. sos

Explication

Celui-ci est assez simple. c < 33trouve un espacement / séparateur ( , \n, EOF, ...). c % 2traduit un point ou un tiret en un peu. L'idée est de créer un nombre unique pour chaque caractère simplement en l'interprétant comme un nombre binaire (après l'avoir préfixé avec 1 pour traiter la longueur variable) (cette interprétation est la v*2 + c%2partie). J'obtiens ensuite une LUT de 137 caractères, que j'ai compactée en hachant la valeur résultante ( v < 64? v : v % 51 + 33, constantes trouvées par essais et erreurs et en regardant la distribution et en essayant de trouver un énorme écart). Malheureusement, cette fonction de hachage a une seule collision, c'est pourquoi je dois cas particulier le 40 → '&'mappage.

R , 145 octets

Traduit un point en 2, un tiret en 1 et interprète le nombre en ternaire et prend le mod 89, ce qui donne un nombre unique que nous pouvons utiliser dans une table de hachage. La présence d'un 13 (111 base-3) signifie ajouter 1 car ASCII 13 ne fonctionne pas dans TIO.

cat(c(letters,0:9,".")[match(strtoi(chartr(".-","12",scan(,"",t=scan(,""))),3)%%89+1,utf8ToInt('DG,)62	5N*EHMAI.%"!4=@'))],sep='')

Essayez-le en ligne!

R , 236 octets (non concurrent)

Cela ne va pas être compétitif, mais cela nous permet de montrer quelque chose d'intéressant dans R: stocker l'arborescence du code Morse dans une structure de langage citée met la récupérer du code de points et de tirets très simplement en utilisant le fait qui [[peut être appliqué récursivement à listes. Par exemple, m[[c(2,2,3,2)]]récupère le point, le point, le tiret, le point ou "f".

m=quote(.(e(i(s(h(5,4),v(,3)),u(f,M(,2))),a(r(l,.(.(,.),)),w(p,j(,1)))),t(n(d(b(6),x),k(c,y)),m(g(z(7),q),o(D(8),S(9,0))))))
for(w in scan(,"",t=scan(,"")))
cat(chartr("MDS","-. ","if"(is.symbol(z<-m[[(utf8ToInt(w)==45)+2]]),z,z[[1]])))

Essayez-le en ligne!

Powershell, 193 octets

$n=1
-join("$args "|% t*y|%{if($_-32){$n=$n*2+($_-ne'.')}else{("  etianmsurwdkgohvf l pjbxcyzq  54 3   2& +~16=/   ( 7   8 90~~~?~ `"  .~@   '  -~~;! )~ ,~:~~~~$"-replace'~','    ')[$n]
$n=1}})

Script de test moins golfé:

$f = {

$n=1
-join(
    "$args "|% t*y|%{
        if($_-32){
            $n=$n*2+($_-ne'.')
        }else{
            ("  etianmsurwdkgohvf l pjbxcyzq  54 3   2& +~16=/   ( 7   8 90~~~?~ `"  .~@   '  -~~;! )~ ,~:~~~~$"-replace'~','    ')[$n]
            $n=1
        }
    }
)

}

@(
    ,("example. sos",". -..- .- -- .--. .-.. . .-.-.-  ... --- ...")
    ,("0123456789abcdefghijklmnopqrstuvwxyz","----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----. .- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --..")
    ,("hello world", ".... . .-.. .-.. ---  .-- --- .-. .-.. -..")
) | % {
    $expected,$s = $_
    $result = &$f $s
    "$($result-eq$expected): $result"
}

Production:

True: example. sos
True: 0123456789abcdefghijklmnopqrstuvwxyz
True: hello world

JavaScript (165 octets, implémentant uniquement quatre plans.)

n=''.replace(/\./g,1).replace(/-/g,0).split(' ')
l='|te|mnai|ogkdwrus|cöqzycxbjpälüfvh'.split('|')
r=''
for(i in n){r+=l[n[i].length][parseInt(n[i],2)]}
alert(r)

L'entrée doit être affectée à n, exécutez le code suivant pour obtenir la sortie:

n='. -..- .- -- .--. .-.. .'.replace(/\./g,1).replace(/-/g,0).split(' ')
l='|te|mnai|ogkdwrus|cöqzycxbjpälüfvh'.split('|')
r=''
for(i in n) {r+=l[n[i].length][parseInt(n[i],2)]}
alert(r)