Bir dizeyi Mors koduna dönüştürme [kapalı]

meydan

karakter sayısına göre en kısa kod, yalnızca alfabetik karakterler (üst ve alt harf), sayılar, virgül, dönemler ve soru işareti kullanarak bir dize girecek ve mors kodundaki dizenin bir temsilini döndürür. Mors kodu çıkışı , kısa bip (AKA 'dah') için bir çizgi ( - , ASCII 0x2D) ve kısa bip ( 'dit') için bir nokta ( . , ASCII 0x2E) oluşmalıdır.

her harf olmalıdır bir boşluk ( ' ' , ASCII 0x20) ile ayrılmış ve her kelime bir ileri çizgi ( / , ASCII 0x2F) ile ayrılmalıdır.

Mors kodu tablosu:

alt metin http://liranuna.com/junk/morse.gif

test kutuları:

Input:
    Hello world

Output:
    .... . .-.. .-.. --- / .-- --- .-. .-.. -..

Input:
    Hello, Stackoverflow.

Output:
    .... . .-.. .-.. --- --..-- / ... - .- -.-. -.- --- ...- . .-. ..-. .-.. --- .-- .-.-.-

kod sayısı giriş/çıkış (yani tam program) içerir.

57
tarihinde sordu LiraNuna 2009-08-30 02:54:30
kaynak

30 ответов

C (131 karakter)

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

mantığı while ve for döngülerinden tek bir for döngüsüne birleştirerek birkaç karakter daha ekledim ve c değişkeninin bildirimini main tanımına giriş parametresi olarak hareket ettirerek. strager'den ödünç aldığım bu ikinci teknik başka bir meydan okuma cevap .


GCC veya ASCII-sadece editörleri ile programı doğrulamak için çalışıyor olanlar için, aşağıdaki biraz daha uzun sürümü gerekebilir:

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

bu sürüm 17 karakter daha uzun (nispeten büyük bir 148 ağırlığında), aşağıdaki değişiklikler nedeniyle:

  • +4: getchar() ve putchar() yerine taşınabilir olmayan getch() ve putch()
  • + 6: ASCII olmayan karakterler yerine iki karakter için kaçış kodları
  • + 1: 32 yerine 0 uzay karakteri
  • +6: ( '\n' yani,) ASCII 32'den az karakterlerden çöp bastırmak için " c<0?1: " eklendi. Yine de !"#$%&'()*+[\]^_ ` {|}~ ya da ASCII 126'nın üstünde herhangi bir şeyden çöp alacaksınız.

bu olmalı kodunu tamamen Portatif hale getirin. Derleme ile:

gcc -std=c89 -funsigned-char morse.c

-std=c89 isteğe bağlıdır. -funsigned-char gerekli olsa da, virgül ve tam durdurma için çöp alacaksınız.


135 karakterler

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

bence, bu son sürüm çok daha görsel olarak çekici. Ve hayır, taşınabilir değil ve artık karşı korunmuyor sınır dışı giriş. Ayrıca oldukça kötü bir UI'YE sahiptir, karakter-karakter girişi alır ve Morse koduna dönüştürür ve no çıkış durumuna sahiptir ( Ctrl + Break ). Ancak güzel bir UI ile taşınabilir, sağlam kod bir gereklilik değildi.

kodun kısa bir açıklaması şöyle:

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

koddaki uzun dizedeki her karakter bir metin karakteri için kodlanmış Mors kodu içerir. Kodlanmış karakterin her bir biti bir çizgi veya bir nokta temsil eder. Tek bir çizgi temsil eder ve bir sıfır nokta temsil eder. En az önemli bit, Mors kodundaki ilk çizgi veya noktayı temsil eder. Son bir "bekçi" biti kodun uzunluğunu belirler. Yani, her kodlanmış karakterdeki en yüksek bit kod sonu temsil eder ve yazdırılmaz. Bu bekçi bit olmadan, sondaki noktalara sahip karakterler basılamadı düzgün.

örneğin,' L 'harfi Morse kodunda " .-.. " dir. Bunu ikili olarak temsil etmek için, en az önemli bit: 0010 ile başlayan 0, 1 ve iki 0'ya ihtiyacımız var. Biraz daha bir tane daha 1 Tack ve kodlanmış Mors Kodumuz var: 10010 veya ondalık 18. '4' karakterinin ASCII değeri olan 52 almak için + 34 ofsetini ekleyin. Yani kodlanmış karakter dizisi 33rd karakteri (dizin 32) olarak bir '4' vardır.

bu teknik, Acoolie'nin , strager ' karakterlerini kodlamak için kullanılan benzer (2) , Miles , pingw33n , Alec ve Andrea'nın çözümleri, ancak biraz daha basit, bit başına sadece bir işlem gerektirir (değişen / bölme), iki yerine (değişen/bölme ve decrementing).

Düzenle:

Uygulamaların geri kalanında okuduğumda, Alec ve Anon bu kodlama şemasıyla geldi-koruma bitini kullanarak-önce yaptım. Anon'un çözümü, Python'un bin işlevini kullanarak ve "0b" önekini ve [3:] ile guard bitini sıyırarak özellikle ilginçtir. Alec ve ben gibi döngü, anding ve vites değiştirme.

bonus olarak, bu sürüm aynı zamanda tire ( -....- ), eğik çizgi ( -..-. ), kolon ( ---... ), noktalı virgül ( -.-.-. ), eşittir ( -...- ) ve işareti ( .--.-. ). 8 bitlik karakterlere izin verildiği sürece, bu karakterlerin desteklenmesi için ekstra kod baytları gerekmez. Koduna uzunluk eklemeden bu sürümle daha fazla karakter desteklenemez (Morse yoksa İşaretler daha büyük/daha az kodları).

çünkü eski uygulamaları hala ilginç buluyorum ve metnin bu sürüme uygulanabilir bazı uyarılar var, bu yazının önceki içeriğini aşağıda bıraktım.


Tamam, muhtemelen, kullanıcı arayüzü emebilir, değil mi? Yani, strager dan borçlanma, gets() ile tamponlu, yankılanmış hat girişi sağlayan getch() yerini aldım , hangi tamponsuz, unechoed karakter girişi sağlar. Bu, yazdığınız her karakterin hemen ekranda Morse koduna çevrildiği anlamına gelir. Belki de bu harika. Artık stdin veya komut satırı argümanı ile çalışmıyor, ancak oldukça küçük.

referans için eski kodu aşağıda tuttum. İşte yeni.

sınır denetimi ile Yeni Kod, 171 karakter:

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+;[email protected]=0/8?F31,2:4BDE"
[c-31]-42):putch(47),putch(0);}

girin döngüyü kırar ve programdan çıkar.

yeni kod, sınır denetimi olmadan, 159 karakter:

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+;[email protected]=0/8?F31,2:4BDE"[c-31]-42):
putch(47),putch(0);}

Aşağıda bazı açıklama ile eski 196/177 kodunu izler:

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+;[email protected]=0/8?F31,2:4BDE"[c-44]-42):
putch(47),putch(0);}

bu, Andrea'nın Python cevabı ye dayanıyor ve bu cevaptaki mors kodunu oluşturmak için aynı tekniği kullanıyor. Ancak kodlanabilir karakterleri depolamak yerine birbiri ardına ve indekslerini bulduktan sonra, indeksleri birbiri ardına sakladım ve karakterle baktım ( e benzer şekilde daha önceki cevabım ). Bu, daha önceki uygulayıcılar için sorunlara neden olan sonuna yakın uzun boşlukları önler.

olarak önce , 127'den büyük bir karakter kullandım. ASCII dönüştürme-sadece 3 karakter ekler. Uzun dizenin ilk karakteri ile değiştirilmelidir \x9C . Bu sefer ofset gereklidir, aksi takdirde çok sayıda karakter 32'nin altındadır ve kaçış kodlarıyla temsil edilmelidir.

daha önce olduğu gibi, stdın yerine bir komut satırı argümanı işlemek 2 karakter ekler ve kodlar arasında gerçek bir boşluk karakteri kullanmak 1 karakter ekler.

Öte yandan, diğer rutinlerden bazıları kabul edilen aralık dışında girişle uğraşmaz [ ,.0-9\?A-Za-z]. Bu tür işlemler bu rutinden kaldırılırsa, toplam 177 karakter kadar düşük olan 19 karakter kaldırılabilir. Ancak bu yapılırsa ve geçersiz giriş bu programa beslenirse, çökebilir ve Yanabilir.

bu durumda kod olabilir:

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+;[email protected]=0/8?F31,2:4BDE"
[toupper(*p)-44]-42):putch(47),putch(0);}
70
cevap P Daddy 2017-05-23 15:17:02
kaynak

Morse kod Yazı Tipi kullanarak?

Console.Write(params[0]);
48
cevap johnc 2009-08-30 03:01:07
kaynak

Perl, 170 karakter (başarılı golfçü mauke biraz yardımı ile). Netlik için sarılmış; tüm yeni çizgiler çıkarılabilir.

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

Açıklama:

  1. Mors sözlük ayıklayın. Her sembol, iki karakter açısından tanımlanır; bu, değişmez nokta veya çizgi olabilir veya başka bir tanımlanmış karakterin değerine bir referans olabilir. E ve t dekoderi desyncing önlemek için kukla chars içeren; biz onları kaldıracağız sonraları.
  2. girişi okuyun ve biçimlendirin. "Hello world" ' "H E L L O / W O R L D"
  3. bir sonraki adım, giriş ve çıkış sözlüklerinin farklı olmasına bağlıdır, bu nedenle girişteki noktaları kullanılmayan bir char (dikey çubuk, | )
  4. hiçbir değiştirmeleri oluşana kadar, sözlükte değeri ile morse sözlüğünde oluşan girdideki herhangi bir karakter değiştirin.
  5. belirtilen kukla char kaldırmak Adım 1.
  6. çıktıyı yazdırın.

son sürümde, sözlük çalışma zamanı verimliliği için optimize edilmiştir:

  • tek sembollü karakterler (E ve T) ve iki sembollü karakterler (a, ı, M ve n) doğrudan tanımlanır ve bir geçişte çözülür.
  • üç sembollü karakterlerin hepsi iki sembollü karakter ve iki geçişte kod çözme, bir değişmez değer sembolü açısından tanımlanır.
  • dört sembollü karakterlerin tümü, iki iki sembol karakter açısından tanımlanır ve üç değiştirmeyle iki geçişte kod çözülür.
  • beş ve altı sembollü karakterler (sayılar ve noktalama işaretleri) sırasıyla dört veya beş değiştirmeyle üç geçişte çözülür.

golfed kodu yalnızca döngü başına bir karakterin yerini aldığından (bir kod karakterini kaydetmek için!) döngüler sayısı beş kat uzunluğu ile sınırlıdır giriş (sadece alfabetik kullanılıyorsa girişin uzunluğunun üç katı). Ancak s/// operasyonuna g ekleyerek, döngü sayısı üç ile sınırlıdır (yalnızca alfabetik kullanılıyorsa iki).

örnek dönüşüm:

Hello 123
H E L L O / 1 2 3
II .] AI AI M- / AO UM SM
.... . .-.. .-.. --- / .-M- .A-- I.--
.... . .-.. .-.. --- / .---- ..--- ...--
23
cevap hobbs 2011-02-08 12:07:41
kaynak

Python list comprehension, 159-character 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),

, benzer veri paketlemesini P Daddy's C olarak kullanır, ancak bitleri ters sırada saklamaz ve verileri aritmetik yerine çıkarmak için bin() kullanır. Boşlukların eşitsizlik kullanılarak tespit edildiğini de Unutmayın; her karakterin "virgülden daha az" bir boşluk olduğunu düşünür.

Python for döngü, 205 karakter dahil yeni hatlar

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,
16
cevap ACoolie 2017-05-23 15:24:23
kaynak

semboller için kompakt bir kodlamayla dolaşıyordum, ancak zaten kullanımda olan örtük ağaçlardan daha iyi olup olmadığını göremiyorum, bu yüzden başka birinin kullanabilmesi durumunda kodlamayı burada sunuyorum.

dizeyi düşünün:

 --..--..-.-.-..--...----.....-----.--/
Alt dizeler olarak gerekli tüm dizileri içeren

. , sembollerini ofset ve uzunluğa göre kodlayabiliriz:

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

ile uzay (yani kelime sınır) başlangıç ve son karakteri ('/') üzerinde biten. Eğer iyi bir yol görürseniz, bunu kullanmak için çekinmeyin.

kısa sembollerin çoğu elbette birkaç olası kodlamaya sahiptir.


P Daddy, bu hile nin daha kısa bir versiyonunu buldu (ve şimdi burada en azından bazı fazlalıkları görebiliyorum) ve güzel bir c uygulaması yaptım. Alec bir python uygulaması yaptı İlk (buggy ve eksik) sürümü ile . Hobbs, hiç anlamadığım oldukça kompakt bir perl sürümü yaptı.

7
cevap dmckee 2017-05-23 14:53:16
kaynak

J, 124 130 134 karakterler

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

J beats C! Harika!

kullanımı:

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

   '.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`[email protected]*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper 'Hello, Stackoverflow.'
.... . .-.. .-.. --- .-.-.- / ... - .- -.-. -.- --- ...- . .-. ..-. .-.. --- .-- --..-- 
6
cevap David 2010-05-12 18:36:43
kaynak

'3 Tek Liner: 172 karakter

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

(tranlation tablosunu unicode kod noktalarına kodlama. İyi çalışıyor ve Windows Vista makinemdeki testimde burada iyi görünüyor.)

bazı gereksiz boşluk ve parantez kaldırarak 184 karakter aşağı pare düzenlenmiş (liste comps gen exps yapma).

tekrar Düzenle: daha fazla boşluk, mümkün olduğunu bile bilmediğim kaldırıldı burada diğer cevapları görmeden önce-176'a kadar.

172 (woo woo!) ''kullanarak.katılmak yerine ".boşlukları ayrı ayrı birleştirin ve yapın. (duh!)

5
cevap Anon 2009-08-31 11:07:32
kaynak

C # 266 chars

131 char C çözümü C# ' 266 karakterine çevrildi:

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

daha okunabilir:

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) }));
}
5
cevap Jader Dias 2009-10-12 03:01:51
kaynak

Golfscript-106 karakter-komik karakter yok:)

girişin sonunda yeni satır desteklenmiyor, bu yüzden

gibi bir şey kullanın

echo -n Hello, Stackoverflow| ../golfscript.rb morse.gs

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

mektupları özel bir durumdur ve küçük harflere dönüştürülür ve ikili pozisyonlarında sipariş edilir.

Her şey bir çeviri tablosu

ile yapılır
5
cevap gnibbler 2009-11-10 01:00:23
kaynak

Python

eksik çözüm, ama belki birisi bunun dışında tam bir çözüm yapabilirsiniz. Rakamları veya noktalama işaretlerini işlemez, ancak sadece 154 karakter ağırlığında.

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))
4
cevap Alec 2009-08-30 04:46:29
kaynak

C (248 karakter)

başka bir ağaç tabanlı çözüm.

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

kaynak ağacında hatalar olabilir, çünkü wikipedia yanlış görünüyor ya da belki bir şeyi yanlış anladım.

3
cevap pingw33n 2009-08-30 15:53:18
kaynak

f#, 256 karakter

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

örneğin

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

-

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

tekniğimin şimdiye kadar benzersiz olabileceğini düşünüyorum. Fikir:

  • istediğimiz şeylerin çoğunu kapsayan bir ascıı aralığı var (0..Z)
  • bu aralıkta sadece 43 karakter var
  • böylece bir bit (çizgi veya nokta) artı bir 'sonraki kodlayabilirsiniz karakter '86 karakter aralığında
  • ascıı aralığı(32-117)tüm 'yazdırılabilir' ve bu 86-char aralığı
  • olarak hizmet verebilir
  • bu nedenle dize değişmez değeri
  • satırları boyunca bir tablo kodlar

biraz daha var, ama bu gist. Virgül, dönem ve boşluk 0 aralığında değildir..Z böylece 'maç'tarafından özel olarak ele alınırlar. 0 aralığında bazı 'kullanılmayan' karakterler..Z ( ' ; ' gibi) tabloda şu şekilde kullanılır Morse 'letters' olmayan diğer mors çevirilerinin sonekleri.

3
cevap Brian 2009-08-31 03:38:58
kaynak

işte bir konsol uygulaması olarak katkım 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

okunabilir hale getirmek için beyaz bir alan bıraktım. Toplam 1100 karakter. Komut satırından girişi, bir seferde bir satırı okuyacak ve karşılık gelen çıktıyı çıkış akışına geri gönderecektir. Sıkıştırılmış sürümü sadece 632 karakter ile, aşağıda.

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
3
cevap Kibbee 2009-09-01 03:41:13
kaynak

C (233 karakter)

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

bu stdin giriş alır. Komut satırından giriş almak 2 karakter ekler. Bunun yerine:

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

sen almak:

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

127'in üzerindeki karakterler için Windows-1252 kod sayfası kullanıyorum ve diğer insanların tarayıcılarında nasıl ortaya çıkacaklarını bilmiyorum. Tarayıcımda en azından (Google Chrome), iki karakterin ("@"ve "ı" arasında) fark ettim") görünmüyor. Tarayıcıdan kopyalayıp bir metin düzenleyicisine yapıştırırsanız, küçük kutular da olsa görünürler.

sadece ASCII dönüştürülebilir, ancak bu karakter sayısı 257 artan 24 karakter ekler. Bunu yapmak için, önce dizedeki her karakteri -64 ile dengeliyorum, 127'den büyük karakter sayısını en aza indiriyorum. Sonra \x XX karakterinin gerekli olduğu yerlerde kaçtığını değiştiriyorum. Bu değişir bu:

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

buna:

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

kodun daha güzel biçimlendirilmiş ve yorumlanmış bir versiyonu:

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

bu, Python uygulamalarının bir çift dışında her şeyi yener. Daha kısa olamayacağını düşünmeye devam ediyorum, ama sonra birkaç karakter daha tıraş etmenin bir yolunu buluyorum. İyileştirme için daha fazla yer bulabilecek biri varsa, bana bildirin.

Düzenle:

fark ettim ki, bu rutin ASCII 44'ün üzerindeki geçersiz karakterleri reddetmesine rağmen (her biri için sadece boş bir alan çıktı), bu değerin altındaki geçersiz karakterleri kontrol etmiyor. Bunların kontrol edilmesi için genel uzunluğa 5 karakter ekler, bunu değiştirme:

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

buna:

...c-32?c>90|c<44?35:"...
3
cevap P Daddy 2011-03-27 19:19:40
kaynak

REBOL (118 karakter)

kabaca 10 yaşındaki bir uygulama

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

alıntı: http://www.rebol.com/oneliners.html

(rakam yok) ve kelimeler sadece çift boşluklarla ayrılır:/ ...)

3
cevap onetom 2013-07-18 18:35:11
kaynak

Python (210 karakter)

bu Alec 'bir

dayalı komple bir çözümdür
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))
2
cevap Andrea Ambu 2017-05-23 14:53:16
kaynak

C, 338 chars

338 girinti ve tüm çıkarılabilir linebreaks kaldırıldı:

#define O putchar
#define W while
char*l="[email protected]@@@@[email protected]@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);
  }
}

bu, diğer insanların aldığı ağaç yaklaşımına dayanmıyor. Bunun yerine, l ilk önce 32 ile 95 bayt arasındaki tüm bayt uzunluklarını, bir karaktere iki bayt kodlar. Örnek olarak, D.. 3 ve e uzunluğunda . 1 uzunluğunda. Bu 011001 vererek, 011 ve 001 olarak kodlanmıştır. İçin daha fazla karakter kodlanabilir hale getirin ve kaçışlardan kaçının, 64 toplam eklenir, 1011001-89, ASCII Y. mors olmayan karakterlere 0 uzunluğu verilir. l nin ikinci yarısı ( 1 ile başlayan), bir nokta 1 ve bir çizgi 0 olan morse kodunun bitleridir. Yüksek ASCII girmekten kaçınmak için, bu veri 7 bit/bayt kodlanır.

kod ilk sanitises c , daha sonra c mors uzunluğu dışarı çalışır ( o ), daha sonra b , verilere bit dizini üretmek için önceki tüm karakterlerin uzunluklarını ekler.

son olarak, bitler, baskı noktaları ve tire döngüler.

uzunluk ' 7', bir boşlukla karşılaştığında a / yazdırmak için özel bir bayrak olarak kullanılır.

muhtemelen parantezleri çıkarmaktan Kaçınılacak bazı küçük kazançlar var, ancak bazı daha iyi sonuçlardan kurtuldum ve açım, bu yüzden...

2
cevap Jon Bright 2009-08-31 00:04:39
kaynak

C # Linq kullanarak (133 karakter)

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

Tamam, bu yüzden aldattım. Ayrıca bir sözlüğü aşağıdaki gibi tanımlamanız gerekir (karakterlerin sayılmasını rahatsız etmedi, çünkü bu beni oyundan çıkardı):

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

yine de, birisi daha özlü bir C# uygulaması sağlayabilir mi, bu da aynı zamanda anlaşılması ve bakımı kolaydır?

2
cevap DSO 2009-08-31 08:44:34
kaynak

Perl, 206 karakter, dmckee'nin fikrini kullanarak

bu gönderdiğim ilkinden daha uzun, ama yine de ilginç olduğunu düşünüyorum . Ve / veya korkunç. Henüz emin değilim. Bu, dmckee'nin kodlama fikrini ve etrafımda gördüğüm birkaç iyi fikri kullanır. Başlangıçta, "sabit bir dizede uzunluk/ofset" şeyinin, sabit bir dizeyi kullanan diğer çözümümdeki şemadan daha az veriye çıkamayacağını düşündüm char başına iki bayt (ve tüm yazdırılabilir bayt). Aslında verileri önemli ölçüde daha az (char başına bir bayt, artı indekslediğimiz 26-bit deseni depolamak için dört bayt) almayı başardım, ancak bunu yapmak için en iyi çabalarıma rağmen tekrar elde etmek için kod daha uzun. (Daha az karmaşık, IMO, ama yine de daha uzun).

yine de, 206 karakter; newlines ilk hariç çıkarılabilir.

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

Açıklama:

  • verilerine iki parça vardır. İlk dört bayt ( "427'151910920'" ) yalnızca ilk 26 bit kullanılsa da 32 bit mors kodu ( "--.-..-.-.-----.....--..--------" ) temsil eder. Bu "referans dizesi" dir.
  • veri dizesinin geri kalanı, her karakteri temsil eden referans dizesinin alt dizelerinin başlangıç konumunu ve uzunluğunu saklar-karakter başına bir bayt, sırayla (A ,B, ... Z, 0, 1, ... 9,".",",","?"). Değerler 23 * (uzunluk - 1) olarak kodlanmıştır) + pos ve kod çözücü bunu tersine çevirir. Son başlangıç noktası elbette 22'dir.
  • bu yüzden paketten çıkarma çalışmalarının yarısını ve üçüncü satırı (burada görüldüğü gibi) geri kalanını yapar, şimdi $m{'a'} = '.-' ve cetera ile bir karma var, bu yüzden geriye kalan tek şey girişin karakterlerini eşleştirmek, onları karmaya bakmak ve son satırın yaptığı çıktıyı biçimlendirmektir... perl'in girişteki yeni çizgiyi nasıl çıkaracağını söyleyen shebang'dan bazı yardımlarla, giriş satırlarını koyun $_ ve kod çalışırken tamamlandığında, $_ tekrar eklenen yeni satırlarla çıktıya geri yazın.
2
cevap hobbs 2009-09-01 03:04:17
kaynak

Python 2; 171 karakter

temelde andrea'nın çözüm ile aynı, ama tam bir program olarak, ve daha kısa yapmak için aptal hileler kullanarak.

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

(eklenen yeni hatlar kaldırılabilir)

veya bin() işlevini kullanmamayı tercih ederseniz, bunu 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'/',

(yine, eklenen yeni satırların hepsi kaldırılabilir)

2
cevap Miles 2017-05-23 15:24:23
kaynak

C89 (293 karakter)

diğer cevaplardan bazılarına dayanıyor.

Düzenle: ağacı küçültür (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);}}
1
cevap strager 2009-08-30 06:19:56
kaynak

dmckee'nin çalışmalarına dayanan ve Python'un ne kadar okunabilir olduğunu gösteren başka bir yaklaşım:

Python

244 karakter

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

Sınırlamalar:

  • dmckee'nin dize 'Y' karakterini kaçırdı ve eklemek için çok tembeldim. Bence sadece "??"bölüm ve ikinci dize değişmez
  • sonunda bir "-" ekleyin
  • koymuyor '/'kelimeler arasında; yine, tembel

en az karakterleri için çağrılan kurallar , en az bayt değil, yazdırılabilir ASCII karakterlerinin dışına çıkmaya istekli olsaydınız, arama tablolarımdan en az birini daha küçük hale getirebilirsiniz.

Düzenle: cesurca seçilmiş Unicode karakterlerini kullanırsam, ancak bunları kaynak dosyadaki ASCII içinde tutarsam, dekoder nedeniyle hala bir tad kısalır daha basit:

Python

240 karakter

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

ben de programın niyet çok daha net yapar düşünüyorum.

bunu UTF-8 olarak kaydettiyseniz, programın 185 karaktere ineceğini ve en kısa tam Python çözümünü ve ikincisini perl'ye dönüştüreceğini düşünüyorum. :- )

1
cevap Alec 2009-08-30 10:56:06
kaynak

işte mors kodunu kodlamanın üçüncü, tamamen farklı bir yolu:

Python

232 karakter

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

bunu bazı yazdırılabilir karakter kümesine eşlemenin bir yolunu bulabilirseniz, epeyce karakter kaydedebilirsiniz. Bu muhtemelen en çok doğrudan çözümümdür, ancak en okunabilir olup olmadığını bilmiyorum.

Tamam, şimdi yolunu boşa harcadım bu konuda çok fazla zaman.

1
cevap Alec 2009-08-30 22:41:33
kaynak

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]

örneğin, decode "-- --- .-. ... . -.-. --- -.. ." "MORSE CODE" döndürür .

bu program mükemmel makaleden alınan Morse kodu ile eğlenceli .

1
cevap namin 2009-09-03 15:38:46
kaynak

PHP

ben önceki PHP girişi biraz daha verimli olması modifiye. :)

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

Komodo, 2 satırdaki 380 karakter diyor-ekstra çizgi sadece okunabilirlik içindir. ; D Dizideki serpiştirilmiş 1s, bundan sonra manuel olarak dizi konumuna atlamak yerine, bu dizi konumunu verilerle doldurarak 2 bayt kaydetmek içindir.

birinci ve ikinci düşünün. Bu fark açıkça görülebilir. :)

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

sonuç, ancak, bu golf sahasında yapmadığımız içerikler boyunca döngü yerine dizi pozisyonlarını kullandığınız sürece.

sonuç: 578 karakter, 380 (198 karakter veya ~34.26% tasarruf).

1
cevap grimman 2017-05-23 15:24:27
kaynak

Bash , bir süre önce yazdığım bir senaryo (zaman damgası geçen yıl diyor) ağır bir 1661 karakter ağırlığında. Sadece eğlence için gerçekten:)

#!/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"
1
cevap Hiato 2010-03-20 16:54:45
kaynak

C89 (388 karakter)

bu virgül, fullstop ve sorgu henüz işlemediği için eksik.

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

okunabilirlik için sarılmış. Sadece iki linebreaks gereklidir (biri # define, birbiri ardına, bir boşluk olabilir). Birkaç standart dışı karakter ekledim, ancak 7-bit olmayan karakterler eklemedim.

0
cevap strager 2009-08-30 04:16:25
kaynak

C, 533 karakter

bazı yorumlardan tavsiye aldım ve stdin'e geçtim. Kabaca 70 karakter daha öldürdü.

#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);
}
0
cevap Will Bickford 2009-08-30 04:21:16
kaynak

C (381 karakter)

char*p[36]={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."};
main(){int c;while((c=tolower(getchar()))!=10)printf("%s ",c==46?".-.-.-":c==44?"--..--":c==63?"..--..":c==32?"/":*(p+(c-97)));}
0
cevap Andreas Grech 2009-08-30 05:10:57
kaynak

C , cmdline bağımsız değişkenleri kullanarak 448 bayt:

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 , stdın kullanarak 416 bayt:

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);}}
0
cevap Christoph 2009-08-30 05:46:42
kaynak

Diğer sorular language-agnostic code-golf