Traducteur de code Morse

32

É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.

Code Morse international

Alexandru
la source
1
Les lettres majuscules et minuscules sont-elles codées?
Joey Adams,
9
Pourriez-vous également fournir un exemple d'entrée et de sortie pour clarifier des détails comme l'espacement entre les mots?
Joey Adams
Eh bien, en Morse, il n'y a pas de différence entre les minuscules et les majuscules. Il n'y a pas de véritable symbole pour l'espace (c'est juste un silence 3/4 fois) donc je suppose qu'il devrait être traduit par un espace.
Shikiryu
@Joey: Les détails dépendent de vous.
Alexandru
Similaire à la question Stack Overflow Code Golf: code Morse .
dmckee

Réponses:

11

Golfscript - 74 caractères

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(;>{'.-'\=}%' '}%}%'/'*
gnibbler
la source
L'ordre de vos blocs de code confond ici le UserScript de George . Puis-je vous déranger pour réorganiser? Et j'aimerais le voir expliqué. Je reçois l'arbre implicite, mais le reste est un mystère pour moi.
dmckee
@dmckee, c'est fait. Le script de George a remarqué que mon décompte était de un, alors j'ai corrigé cela aussi
gnibbler
Exiger des votes positifs pour voir l'analyse ... boo! L'analyse est ce qui rend les réponses dignes des votes positifs!
Nick Larsen
@ Nick, ok je pense que c'est aussi court que possible, donc je vais travailler sur cette analyse
gnibbler
20

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.

Nick Larsen
la source
2
C'est la meilleure idée que j'ai vue jusqu'à présent.
Alexandru
Et puis j'ai lu le fil lié et j'ai remarqué que c'était loin d'être original.
Nick Larsen
1
Quand j'ai vu le 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=>..-.
gnibbler
Vous n'avez pas besoin d'espace dansString[] a
Cyoce
9

tr + sed (347)

tr a-z A-Z | sed 's/0/--O/g;s/1/.-O/g;s/2/.J/g;s/3/..W/g;s/4/.V/g;s/5/.H/g;
 s/6/-.H/g;s/7/-B/g;s/8/-Z/g;s/9/--G/g;s/X/-U/g;s/V/.U/g;s/U/.A/g;
 s/Q/-K/g;s/K/-A/g;s/A/.T/g;s/J/.O/g;s/O/-M/g;s/Y/-W/g;s/W/.M/g;
 s/M/-T/g;s/T/- /g;s/H/.S/g;s/B/-S/g;s/S/.I/g;s/L/.D/g;s/Z/-D/g;
 s/D/-I/g;s/I/.E/g;s/C/-R/g;s/F/.R/g;s/R/.N/g;s/P/.G/g;s/G/-N/g;
 s/N/-E/g;s/E/. /g'
Eelvex
la source
1
L'espace autour d'un tuyau pourrait également être éliminé ;-)
Yasir Arsanukaev
1
Oui, je ne compte pas ces espaces, je les imprime ici pour plus de clarté :)
Eelvex
2
Vous pouvez utiliser l'expansion d'accolade pour la raccourcir beaucoup ( /g;s/devient ,- plus un peu de surcharge).
Nabb
@nabb bonne idée.
Eelvex
1
Vous pouvez laisser tomber le tr, utilisez la ycommande de sed à la place
Hasturkun
6

Haskell - 314 292 291 caractères

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.

Yasir Arsanukaev
la source
Je viens de vérifier la question référencée par @dmckee "Code Golf: Morse code" et je n'ai pas trouvé de version Haskell. Je pense que moins de 314 serait possible.
Yasir Arsanukaev,
fromJust.elemIndex cpeut ê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=intercalateau début et en remplaçant les deux appels à intercalatepar i.
sepp2k
@ sepp2k: Bonne idée! Merci. J'ai aussi joué avec intercalateet j'ai sauvé 6 autres personnages! :-)
Yasir Arsanukaev
Vous pouvez également le faire 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).
sepp2k
@ sepp2k: La mise en ligne de 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.
Yasir Arsanukaev
4

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)
luser droog
la source
4

Rubis, 161

d=proc{|x|x>1?d[x/2]+".-"[x&1]:' '}
$><<$<.gets.bytes.map{|i|
e=i>64?"-@B4*:68,?5</.7>E20+193ACD"[(i&95)-65]:i>47?"gWOKIHX`df"[i-48]:nil
e ?d[e.ord-40]:i.chr}*''

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.

AShelly
la source
4

VB.NET, 233 octets

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
Adam Speight
la source
J'ai décidé d'ajouter +1 à cela parce que je ne me souviens pas avoir vu VB.net utilisé pour le golf.
mbomb007 du
3

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

tobyodavies
la source
3

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){}}}
jtjacques
la source
3

Perl6 (238)

my%h="A.-B-...C-.-.D-..E.F..-.G--.H....I..J.---K-.-L.-..M--N-.O---P.--.Q--.-R.-.S...T-U..-V...-W.--X-..-Y-.--Z--..0-----1.----2..---3...--4....-5.....6-....7--...8---..9----.".split(/<wb>/)[1..72];while$*IN.getc ->$c{print %h{$c.uc}||$c}

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;
}
Bruce Armstrong
la source
"J'obtiens un jeton supplémentaire au début et à la fin pour une raison quelconque": je ne connais pas Perl 6, mais je suppose que c'est parce que la chaîne vide correspond avant la première limite de mot et après la dernière.
msh210
2

sed, 159 octets

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 ynous 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, 8et 9d'é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 kse transforme en trois passes:

  1. k=> k-=>n-
  2. n-=> n.-=>t.-
  3. t.-=> t-.-=>-.-
Toby Speight
la source
2

Python 3, 99 caractères

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

Fonctionne en majuscules et minuscules.

Cormac
la source
2

C, 162 160 caractères

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

Mest 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
.- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----. 
Luciole
la source
Ce n'est pas 162 caractères ... veuillez poster la version golfée.
Cyoce
@Cyoce Désolé, je n'ai pas supprimé les espaces non significatifs car c'est un processus mécanique ennuyeux et ne fait que compliquer la lecture du code source, ce qui est (était?) Une pratique assez standard sur PPCG. Ajout d'une version avec un tel espace vide pour vous :).
FireFly
144 octets
plafondcat
1

Perl (489 caractères)

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

Daniel Standage
la source
1
Vous pouvez le réduire à 286 caractères:%c=qw(A .- B -... C -.-. D -.. E . F ..-. G --. H .... I .. J .--- K -.- L .-.. M -- N -. O --- P .--. Q --.- R .-. S ... T - U ..- V ...- W .-- X -..- Y -.-- Z --.. 1 .---- 2 ..--- 3 ...-- 4 ..--- 5 ..... 6 -.... 7 --... 8 ---.. 9 ----. 0 -----);while(<>){print($c{$_}||$_)for split//}
msh210
1

PHP, 474 caractères

<?$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])];
Kevin Brown
la source
Avec quelques astuces mineures qui peuvent être réduites à:<?$a=strtoupper(fgets(STDIN));$m=array(65=>12,2111,2121,211,1,1121,221,1111,11,1222,212,1211,22,21,222,1221,2212,121,111,2,112,1112,122,2112,2122,2211)+array(48=>22222,12222,11222,11122,11222,11111,21111,22111,22211,22221)+array(32=>' ');while($a[$i++])echo strtr($m[ord($a[$i])],12,'.-');
manatwork
1

05AB1E , 81 octets (non concurrent)

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

Essayez-le en ligne!

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.

Urne Magique De Pieuvre
la source
1

Gelée , 50 octets

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

Un programme complet acceptant une chaîne au format Python comme argument de ligne de commande qui imprime une sortie délimitée par des espaces.

Essayez-le en ligne!

Jonathan Allan
la source
1

Powershell, 142 octets

-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
la source
1
+mazzy+est un rembourrage effronté
Veskah
1

APL (NARS), 71 caractères, 142 octets

{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,⎕Det des caractères 16 bits 'ܨ㈍İᄧюᜪࠄᨳ䜏ഁᙂ᥃䴫쩸穼蚠'qu'ils divisent en caractères 8 bits chacun converti en base 3 avec des chiffres inversés.

RosLuP
la source
1

05AB1E , 52 octets

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

Essayez-le en ligne!

    •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
Dorian
la source
1

JavaScript (ES6), 184 octets

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 \npar 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

Ungolfed

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

Version lisible, 234 octets

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

Ungolfed

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
Naruyoko
la source
0

Python 2, 283 274 octets

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 01serait le même que 1. J'ai donc utilisé le ternaire avec - = 1et . = 2. Ainsi, le caractère cest à l'index 1121dans cette chaîne, sa représentation en code Morse est --.-.

  • Pour économiser des octets, j'ai créé des variables pour l'espace, le tiret et le point.
  • Ensuite, j'ai codé en dur la chaîne «décodeur» en utilisant quelques instructions de remplacement pour réduire les espaces.
  • La partie de la fonction convertit un index en un tableau de chiffres ternaires
  • L'autre fonction part prend une chaîne et convertit chaque caractère en code Morse avec 3 espaces après les lettres et 7 (4 supplémentaires) entre les mots
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

  • -9 [16-05-09] Incorporation de la fonction de calcul ternaire dans la fonction principale

[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 ]

NonlinearFruit
la source
0

PHP, 157 150 157 octets

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 echoet 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 1pour 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.

Titus
la source
0

SmileBASIC, 194 190 octets

INPUT S$WHILE""<S$B=INSTR(" ETIANMSURWDKGOHVFLPJBXCYZQ  54 3   2       16       7   8 90",S$[0])+1IF B THEN S=LOG(B,2)FOR I=0TO S-1?"._"[B-(1<<S)AND S>>I||0];:NEXT?" ";
?SHIFT(S$)*!B;
WEND
12Me21
la source