C , 448 байт с использованием аргументов 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 байт с использованием 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);}}

C (381 символ)

char*p[36]={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."};
main(){int c;while((c=tolower(getchar()))!=10)printf("%s ",c==46?".-.-.-":c==44?"--..--":c==63?"..--..":c==32?"/":*(p+(c-97)));}

C89 (388 символов)

Это неполный , поскольку он не обрабатывает запятую, точку и запрос пока.

#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(' ');}}

Обернут для удобства чтения. Требуются только два разрыва строки (один для #define, один за другим, который может быть пробелом). Я добавил несколько нестандартных символов, но не стал добавлять не 7-битные.

C, 533 символа

Я послушался совета некоторых комментариев и переключился на стандартный ввод. Примерно убиты еще 70 символов.

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

Использование шрифта кода Морзе ?

Console.Write(params[0]);

Python 2; 171 символ

В основном то же самое, что решение Андреа , но как полная программа, и с использованием глупых уловок, чтобы сделать ее короче.

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'/',

(все добавленные символы новой строки могут быть удалены)

Или, если вы предпочитаете не использовать функцию bin () в 2.6, мы можем сделать это в 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'/',

(опять же, все добавленные символы новой строки могут быть удалены)

C89 (293 символа)

На основе некоторых других ответов.

РЕДАКТИРОВАТЬ: Уменьшить дерево (ура).

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

Понимание списка Python, 159-символьный однострочный

for c in raw_input().upper():print c<","and"/"or bin(ord("•ƒwTaQIECBRZ^`šŒ#S#n|':<.$402&9/6)(18?,*%+3-;=>"[ord(c)-44])-34)[3:].translate(" "*47+"/.-"+" "*206),

Использует упаковку данных, аналогичную реализации P Daddy на C , но не сохраняет биты в обратном порядке и использует bin () для извлечения данных, а не арифметические операции. Также обратите внимание, что пробелы обнаруживаются с использованием неравенства; он считает каждый символ «меньше запятой» как пробел.

Python для цикла , 205 символов, включая символы новой строки

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,

Я возился с компактным кодированием для символов, но я не вижу, есть ли что-нибудь лучше, чем уже используемые неявные деревья, поэтому я представляю код здесь на случай, если кто-то еще сможет его использовать.

Рассмотрим строку:

 --..--..-.-.-..--...----.....-----.--/

, которая содержит все необходимые последовательности как подстроки. Мы могли закодировать символы по смещению и длине следующим образом:

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

с пробелом (то есть границей слова), начинающимся и заканчивающимся на последнем символе ('/'). Не стесняйтесь использовать его, если видите хороший способ.

Большинство более коротких символов, конечно, имеют несколько возможных кодировок.

P Папа нашел более короткую версию этого трюка (и теперь я могу видеть по крайней мере, некоторая избыточность здесь) и сделал хорошую реализацию c. Алек выполнил реализацию Python с первой версией (с ошибками и неполной).

Python

Неполное решение, но, возможно, кто-то сможет сделать из него полное решение . Не обрабатывает цифры или знаки препинания, но занимает всего 154 символа.

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 символов)

Другое решение на основе дерева.

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

Могут быть ошибки в дереве исходных текстов, потому что wikipedia , похоже, ошибается, или, может быть, я неправильно понял что-то.

Perl, 170 символов (с небольшая помощь от опытного гольфиста мауке ). Для наглядности завернут; все символы новой строки удаляются.

$_=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

Пояснение:

1. Извлечь словарь Морзе. Каждый символ определяется в виде двух символов, которые могут быть буквальными точками или дефисами, или ссылкой на значение другого определенного символа. E и T содержат фиктивные символы, чтобы избежать рассинхронизации декодера; мы удалим их позже.
2. Прочтите и отформатируйте ввод. «Привет, мир» становится «ПРИВЕТ / МИР D»
3. Следующий шаг зависит от того, какие словари ввода и вывода различаются, поэтому замените точки во вводе на неиспользуемые символы (вертикальная черта, | )
4. Замените любой символ во входных данных, который встречается в словаре Морзе, на его значение в словаре, пока не произойдет замена.
5. Удалите фиктивный символ, упомянутый в шаге 1.
6. Распечатайте результат.

В окончательной версии словарь оптимизирован для повышения эффективности выполнения:

• Все односимвольные символы (E и T) и двухсимвольные символы (A, I, M и N) определены напрямую и декодировать за один проход.
• Все трехсимвольные символы определены в терминах двухсимвольного символа и буквального символа, декодируемого за два прохода.
• Все четырехсимвольные символы определены в терминах двух двухсимвольных символов, декодируемых за два проходит с тремя заменами.
• Пяти- и шестизначные символы (числа и знаки препинания) декодируются за три прохода с четырьмя или пятью заменами соответственно.

Так как код игры заменяет только один символ в цикле (чтобы сэкономить один символ кода!) количество циклов ограничено пятикратной длиной ввода (трехкратной длиной ввода, если используются только буквы). Но при добавлении g к операции s /// количество циклов ограничивается тремя (двумя, если используется только алфавит).

Пример преобразования:

Hello 123
H E L L O / 1 2 3
II .] AI AI M- / AO UM SM
.... . .-.. .-.. --- / .-M- .A-- I.--
.... . .-.. .-.. --- / .---- ..--- ...--

Вот мой вклад в качестве консольного приложения в 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

. Я оставил пустое пространство, чтобы его можно было читать. Всего 1100 знаков. Он будет читать ввод из командной строки по одной строке за раз и отправлять соответствующий вывод обратно в выходной поток. Ниже приведена сжатая версия, содержащая всего 632 символа.

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

Вот третий, совершенно другой способ кодирования кода Морзе:

Python

232 символа

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

Если вы можете придумать способ сопоставить это с некоторым набором печатаемых символов , вы можете сохранить довольно много символов. Это, вероятно, мое самое прямое решение, хотя я не знаю, наиболее читабельно ли оно.

Хорошо, теперь я потратил на это way слишком много времени.

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]

Например, decode "- --- .-. .... -.-. --- - ..." возвращает «КОД Морзе» .

Эта программа взята из прекрасной статьи Развлечения с азбукой Морзе .

Вот еще один подход, основанный на работе dmckee, демонстрирующий, насколько читабелен Python:

Python

244 символа

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

Ограничения:

• В строке dmckee отсутствует буква «Y» персонаж, и мне было лень его добавить. Я думаю, вам просто нужно изменить "??" часть и добавьте «-» в конце второго строкового литерала
• , он не помещает «/» между словами; опять же, ленивый

Поскольку правила требовали наименьшего количества символов , а не наименьшего байтов , вы могли бы уменьшить хотя бы одну из моих таблиц поиска (вдвое), если бы вы были готовы выходите за пределы печатаемых символов ASCII.

РЕДАКТИРОВАТЬ: Если я использую наивно выбранные символы Unicode, но просто сохраняю их в экранированном ASCII в исходном файле, он все еще становится немного короче, потому что декодер проще:

Python

240 символов

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

Я думаю, что это также делает цель программы намного более ясной.

Если вы сохранили это как UTF-8, я полагаю, что программа будет сокращена до 185 символов, что сделает ее самым коротким полным решением Python, уступающим только Perl. : -)

C # Использование Linq (133 символа)

    static void Main()
    {
        Console.WriteLine(String.Join(" ", (from c in Console.ReadLine().ToUpper().ToCharArray()
                                            select m[c]).ToArray()));
    }

Хорошо, я обманул. Вам также необходимо определить словарь следующим образом (не заморачиваться с подсчетом символов, поскольку это выбивает меня из игры):

    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', "----."},
            {' ', "/"},
            {'.', ".-.-.-"},
            {',', "--..--"},
            {'?', "..--.."},
        };

Тем не менее, может ли кто-нибудь предоставить более лаконичную реализацию C #, которую также легко понять и поддерживать как это?

C, 338 символов

338 с удаленными отступами и всеми съемными переносами строк:

#define O putchar
#define W while
char*l="x@@@@@ppmmmmm@@FBdYcbcbSd[Kcd`\31(\b1g_<qCN:_'|\25D$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);
  }
}

Это не основано на древовидном подходе, который использовали другие люди. Вместо этого l сначала кодирует длины всех байтов от 32 до 95 включительно, по два байта на символ. Например, D равно - .. для длины 3, а E равно. для длины 1. Это кодируется как 011 и 001, что дает 011001. Чтобы сделать больше символов кодируемыми и избежать экранирования, затем к общему количеству добавляется 64, что дает 1011001 - 89, ASCII Y. Неморзским символам присваивается длина из 0. Вторая половина l (начиная с \ 031 ) - это биты самого кода Морзе, точка - 1, а тире - 0. Чтобы избежать высоких значений ASCII, эти данные кодируются 7 бит на байт.

Код сначала очищает c ,

Python (210 символов)

Это полное решение, основанное на Алека

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

Python 3 One Liner: 172 characters

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 tranlation table into unicode code points. Works fine, and they display here fine in my test on my Windows Vista machine.)

Edited to pare down to 184 characters by removing some unnecessary spaces and brackets (making list comps gen exps).

Edit again: More spaces removed that I didn't even know was possible before seeing other answers here - so down to 176.

Edit again down to 172 (woo woo!) by using ' '.join instead of ''.join and doing the spaces separately. (duh!)

F #, 256 символов

let rec D i=if i=16 then" "else
 let x=int"U*:+F8c]uWjGbJ0-0Dnmd0BiC5?\4o`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))""

Например,

M("Hello, Stack.") |> printfn "%s"

дает

.... . .-.. .-.. --- --..-- / ... - .- -.-. -.- .-.-.-

Я думаю, что пока моя техника может быть уникальной. Идея такова:

• существует диапазон символов ascii, который охватывает большую часть того, что мы хотим (0..Z)
• в этом диапазоне всего 43 символа
• , поэтому мы можем кодировать один бит (тире или точка) плюс «следующий символ» в диапазоне 86 символов
• диапазон ascii (32-117) полностью «печатается» и может служить этим диапазоном из 86 символов
• , поэтому строковый литерал кодирует таблицу вдоль те строки

Это немного больше, но в этом суть. Запятая, точка и пробел не находятся в диапазоне 0..Z, поэтому они специально обрабатываются функцией match. Некоторые «неиспользуемые» символы в диапазоне 0..Z (например, «;») используются в таблице в качестве суффиксов других переводов Морзе, которые сами по себе не являются «буквами Морзе».

C (233 символа)

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

Принимает ввод со стандартного ввода. При вводе из командной строки добавляются 2 символа. Вместо:

...main(){char*p,c,s[99];gets(s);for(p=s;...

вы получите:

...main(int i,char**s){char*p,c;for(p=s[1];...

Я использую кодовую страницу Windows-1252 для символов выше 127, и я не уверен, как они будут отображаться в браузерах других людей. Я заметил, что, по крайней мере, в моем браузере (Google Chrome) два символа (между «@» и «i») не отображаются. Однако, если вы скопируете из браузера и вставите в текстовый редактор, они появятся, хотя и в виде маленьких прямоугольников.

Его можно преобразовать в формат только ASCII, но это добавляет 24 символа, увеличивая количество символов до 257 Для этого я сначала смещаю каждый символ в строке на -64, минимизируя количество символов, превышающих 127. Затем я заменяю символы \ x XX , где это необходимо. Он изменяет это:

...c>90?35:c-32?"È#À#¶µ´³²±°¹¸·#####Ê#@i Že‘J•aEAv„…`q!j“d‰ƒˆ"[c-44]:63;
c-35?W(...

на это:

...c>90?99:c-32?"\x88#\x80#vutsrqpyxw#####\x8A#\0PA)\xE0N%Q\nU!O\5\1\66DE 1
\xE1*S$ICH"[c-44]+64:63;c-99?W(...

Вот более красиво отформатированная и прокомментированная версия кода:

/* 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#\0PA)\xE0N%Q\nU!O\5\1\66DE 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 */

Это превосходит все здесь, за исключением пары реализаций Python. Я все думаю, что короче не может быть, но потом я нахожу способ избавиться от еще нескольких персонажей. Если кто-нибудь сможет найти еще возможности для улучшения, дайте мне знать.

EDIT:

Я заметил, что, хотя эта процедура отклоняет любые недопустимые символы выше ASCII 44 (выводит только пустое пространство для каждого из них), это не так. t проверьте наличие недопустимых символов ниже этого значения. Чтобы проверить это, к общей длине добавляется 5 символов, изменяя это:

...c>90?35:c-32?"...

на это:

...c-32?c>90|c<44?35:"...

Вы можете избежать копирования, если каждый уровень запрашивает пустой буфер у следующего нижнего уровня, а не выделяет его сам:

• Уровень приложения запрашивает буфер используя идею dmckee

  Это длиннее, чем первая, которую я представил, но я все же думаю интересной . И / или ужасно. Я еще не уверен. Здесь используется идея кодирования dmckee, а также пара других хороших идей, которые я видел. Сначала я думал, что «длина / смещение в фиксированной строке» не может дать меньше данных, чем схема в другом моем решении, которое использует фиксированные два байта на символ (и все байты для печати). На самом деле мне удалось сократить объем данных до значительно меньшего размера (один байт на символ плюс четыре байта для хранения 26-битного шаблона, который мы индексируем), но код для его повторного вывода длиннее, несмотря на все мои усилия. играть в гольф. (Менее сложно, ИМО, но все равно длиннее.)

  Так или иначе, 206 символов; новые строки можно удалить, кроме первого.

  #!perl -lp
  ($a,@b)=unpack"b32C*",
  "\264\202\317\0\31SF1\2I.T\33N/G\27\308XE0=\x002V7HMRfermlkjihgx\207\205";
  $a=~y/01/-./;@m{A..Z,0..9,qw(. , ?)}=map{substr$a,$_%23,1+$_/23}@b;
  $_=join' ',map$m{uc$_}||"/",/./g
  

  Пояснение:

  • Данные состоят из двух частей. Первые четыре байта ( "\ 264 \ 202 \ 317 \ 0" ) представляют 32 бита кода Морзе ( "--.-..-.-.----- .. ... - ..-------- "), хотя используются только первые 26 бит. Это «ссылочная строка».
  • В оставшейся части строки данных хранится начальная позиция и длина подстрок ссылочной строки, которые представляют каждый символ - по одному байту на символ в порядке (A, B, .. .Z, 0, 1, ... 9, ".", ",", "?"). Значения кодируются как 23 * (длина - 1) + pos, и декодер меняет это значение на обратное. Последняя начальная позиция, конечно же, 22.
  • Итак, распаковка выполняет половину работы по извлечению данных, а третья строка (как показано здесь) делает все остальное, теперь у нас есть хэш с $ m {'a '} =' .- ' и так далее, так что все, что осталось, - это сопоставить символы ввода, найти их в хэше и отформатировать вывод, что и делает последняя строка ... с некоторой помощью shebang, который сообщает perl об удалении новой строки на вводе, поместите строки ввода в $ _ , и когда код завершит выполнение, напишите $ _ обратно в вывод, снова добавив новые строки.

PHP

Я изменил предыдущую запись PHP , чтобы она была немного более эффективной. :)

$a=array(32=>"/",44=>"--..--",1,".-.-.-",48=>"-----",".----","..---","...--","....-",".....","-....","--...","---..","----.",63=>"..--..",1,".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..");
foreach(str_split(strtoupper("hello world?"))as$k=>$v){echo $a[ord($v)]." ";}

Komodo говорит, что 380 символов в 2 строках - дополнительная строка предназначена только для удобства чтения. ; D Перемежающиеся единицы в массиве предназначены просто для экономии 2 байтов, заполняя эту позицию массива данными вместо того, чтобы вручную переходить к позиции массива после этого.

Рассмотрим первое и второе. Разница хорошо видна. :)

array(20=>"data",22=>"more data";
array(20=>"data",1,"more data";

Конечный результат, однако, будет ровным до тех пор, пока вы используете позиции массива, а не перебираете содержимое, чего мы не делаем на этом поле для гольфа.

Конечный результат: 578 символов, вплоть до 380 (198 символов, или ~ 34,26% экономии).

C # 266 символов

Решение 131 символа C, переведенное на C #, дает 266 символов:

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+$6-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)}));}

, что более читается как:

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+$6-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 символов - БЕЗ ВЕСЕЛЫХ СИМВОЛОВ :)

новая строка в конце ввода не поддерживается, поэтому используйте что-то вроде этого

echo -n Здравствуйте, Stackoverflow | ../golfscript.rb morse.gs

' '/{{.32|"!etianmsurwdkgohvf!l!pjbxcyzq"?)"UsL?/'#! 08<>"@".,?0123456789"?=or
2base(;>{'.-'\=}%' '}%}%'/'*

Буквы - это особый случай, они преобразуются в нижний регистр и упорядочены в их двоичных позициях.
Все остальное делает таблица перевода

REBOL (118 символов)

Примерно Реализация 10-летней давности

foreach c ask""[l: index? find" etinamsdrgukwohblzfcpövxäqüyj"c while[l >= 2][prin pick"-."odd? l l: l / 2]prin" "]

Цитируется по: http://www.rebol.com/oneliners.html

(цифры отсутствуют, а слова просто разделяются двойными пробелами: / ...)

Bash, скрипт, который я написал некоторое время назад (по временной метке - в прошлом году), весом в 1661 символ. Просто для развлечения :)

#!/bin/sh
txt=''
res=''
if [ "$1" == '' ]; then
    read -se txt
else
    txt="$1"
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"

J, 124 130 134 символов

'.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`dfggggggg-@B4*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper

J лучше C! Потрясающие!

Использование:

   '.- /'{~;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.'
.... . .-.. .-.. --- .-.-.- / ... - .- -.-. -.- --- ...- . .-. ..-. .-.. --- .-- --..--