Mục tiêu

Mã Morse thường được biểu diễn dưới dạng âm thanh. Đưa ra một luồng bit đại diện cho dù âm thanh được bật hay tắt, hãy dịch luồng thành chữ và số và khoảng trắng.

Cụ thể

• Luồng bit được phân tích dựa trên độ dài lặp lại các bit ON / OFF.
  • 1 bit ON là một dấu chấm
  • 3 bit ON là một dấu gạch ngang
  • 1 bit TẮT dấu chấm và dấu gạch ngang
  • 3 bit TẮT phân định các ký tự
  • 7 bit TẮT phân định các từ (dấu cách)
• Đầu vào có thể là một chuỗi hoặc mảng. Chỉ cho phép hai ký tự / giá trị duy nhất của sự lựa chọn của bạn trong đầu vào. (ví dụ: 0/1, đúng / sai, dấu phẩy / dấu cách)
• Đầu ra trả về một chuỗi hoặc được in thành đầu ra tiêu chuẩn.

Thí dụ

Input:    101010100010001011101010001011101010001110111011100000001011101110001110111011100010111010001011101010001110101
Analysis: \--H--/   E   \---L---/   \---L---/   \----O----/\-- --/\---W---/   \----O----/   \--R--/   \---L---/   \--D--/
Output:   HELLO WORLD

Giả định

• Luồng luôn bắt đầu và kết thúc với bit ON.
• Không có khoảng trắng hàng đầu hoặc dấu.
• Đầu vào luôn hợp lệ.
• Tất cả các chữ cái (không phân biệt chữ hoa chữ thường) và chữ số đều được hỗ trợ.

Các trường hợp thử nghiệm

101010100010001011101010001011101010001110111011100000001011101110001110111011100010111010001011101010001110101
HELLO WORLD

10100000001011100011101110000000101110000000101011101000101000101010001010101
I AM A FISH

1010111011101110001110111011101110111000101110111011101110001110111010101
2017

101010001110111011100010101
SOS

Chấm điểm

Đây là mã golf. Mã đếm byte thấp nhất vào thời điểm này vào tuần tới sẽ thắng.

APL (Dyalog) , 65 62 60 57 byte

-3 cảm ơn ngn.

Hàm tiền tố ngầm.

⎕CY'dfns'
morse'/|[-.]+'⎕S'&'∘(⊃∘'/. -'¨6|'1+|(00)+'⎕S 1)

Hãy thử trực tuyến! Header, f←và Footer chỉ để cho phép gọi hàm từ Input trong khi vẫn giữ số byte của TIO. Trong phiên APL bình thường (tương ứng với trường Nhập liệu của TIO), sẽ không cần thiết .

⎕CY'dfns' c op y các dfns Workspace (thư viện)

(Cách ) áp dụng chức năng ngầm này:
 '1+|(00)+'⎕S 1 PCRE S earch tìm kiếm 1 lần chạy và độ dài 0 lần chạy và trả
 6| lại phần chia độ dài của trận đấu khi chia
 ⊃∘'/. -'¨ cho 6 cho mỗi độ dài trận đấu, chọn ký tự tương ứng từ chuỗi này
'/|[-.]+'⎕S'&'∘ PCRE S tìm kiếm dấu gạch chéo và dấu gạch ngang / dấu chấm -bạn và trả lại những
morse bản dịch từ mã Morse sang văn bản thông thường

Python 2 , 142 135 byte

lambda s:''.join(' E-T----Z-Q---RSWU--2FH-V980NIMA--1CBYX-6--GDOK534PLJ-7'[int('0'+l.replace('111','3'),16)%57]for l in s.split('000'))

Hãy thử trực tuyến!

Giải trình:

Chia chuỗi thành các chữ cái trên 000( 0có nghĩa là không gian)

Thay thế từng 111có 3, và chuyển đổi thành cơ sở 16.

Sau đó, mỗi số được sửa đổi bởi 57, nó đưa ra một phạm vi 0..54, là chỉ số của ký tự hiện tại.

Phiên bản trước đã chuyển đổi sang cơ sở 3:

Python 2 , 273 252 247 byte

lambda s:''.join(chr(dict(zip([0,242,161,134,125,122,121,202,229,238,241]+[2]*7+[5,67,70,22,1,43,25,40,4,53,23,49,8,7,26,52,77,16,13,2,14,41,17,68,71,76],[32]+range(48,91)))[int('0'+l.replace('111','2').replace('0',''),3)])for l in s.split('000'))

Hãy thử trực tuyến!

Phiên bản trước đã chuyển đổi thành nhị phân:

Python 2 , 282 261 256 byte

lambda s:''.join(chr(dict(zip([0,489335,96119,22391,5495,1367,341,1877,7637,30581,122333]+[2]*7+[23,469,1885,117,1,349,477,85,5,6007,471,373,119,29,1911,1501,7639,93,21,7,87,343,375,1879,7543,1909],[32]+range(48,91)))[int('0'+l,2)])for l in s.split('000'))

Hãy thử trực tuyến!

Ruby , 123 byte

->s{s.split(/0000?/).map{|r|r[0]?"YE9_0IZTO_BHKU58V_GR_SFA__1_4NP_60X_____C__D_ML7WQ3__2__J"[r.to_i(2)%253%132%74]:" "}*""}

Hãy thử trực tuyến!

Tách chuỗi đầu vào trên giới hạn ký tự. Sử dụng 3 hoặc 4 bit TẮT để không gian được chuyển đổi thành chuỗi trống. Lấy giá trị cơ bản 2 của mỗi ký tự và đưa vào phạm vi hợp lý (dưới 60 giá trị có thể) bằng cách sử dụng modulo trên 3 phân chia liên tiếp.

Python , 175 168 byte

s=lambda t,f=''.join:f('; TEMNAIOGKDWRUS;;QZYCXBJP;L;FVH09;8;;;7;;;;;;;61;;;;;;;2;;;3;45'[int('1'+f('0'if j[1:]else j for j in i.split('0')),2)]for i in t.split('000'))

Đầu tiên chuyển đổi chuỗi thành danh sách chuỗi 0 (dấu gạch ngang) / 1 (dấu chấm), thêm tiền tố 1(để ngăn các số 0 đứng đầu và xử lý các khoảng trắng), sau đó chuyển đổi thành nhị phân.

Vì mỗi mã có độ dài không quá 5, kết quả nằm trong khoảng từ 0 đến 63 và có thể được liệt kê trong một chuỗi.

Thạch , 67 62 byte

ṣ0L€«2ḅ2“>.&" þ/7;=¥çı¿¢×ÆФ怌©¦Çß÷µ¬£®Ñ½ðȷñ‘iịØB;⁶¤
œṣ0ẋ3¤Ç€

Hãy thử trực tuyến!

Visual Basic .NET (.NET Core) , 252 byte

-7 byte nhờ @recursive

Function A(i)
For Each w In i.Split({"0000000"},0)
For Each l In w.Split({"000"},0)
Dim c=0
For Each p In l.Split("0")
c=c*2+1+p.Length\2
Next
A &="!ETIANMSURWDKGOHVF!L!PJBXCYZQ!!54!3!!!2!!!!!!!16!!!!!!!7!!!8!90"(c)
Next
A+=" "
Next
End Function

Hàm lấy một chuỗi 1s và 0s và trả về một chuỗi. (Trên thực tế, chỉ có 0cho OFFlà một yêu cầu khó khăn. Bất cứ điều gì không OFFđược giả định là ON).

Chuỗi ký tự là thiết lập mã Morse như một đống nhị phân ở dạng mảng. VB.NET cho phép bạn lập chỉ mục chuỗi dưới dạng mảng ký tự. Các \là số nguyên chia, lấy tiểu đống trái cho 1hay các tiểu đống phù hợp với 111.

Tôi đã sử dụng !làm khoảng trống khi không có giá trị trong vị trí heap đó. Chỉ cần điền đúng các chỉ số.

VB.NET cho phép bạn quay lại bằng cách gán một giá trị cho tên hàm (trong trường hợp này A). Tôi chỉ lặp đi lặp lại thực hiện nối chuỗi ( &) để xây dựng chuỗi đầu ra. Lần đầu tiên tôi cần sử dụng &vì sử dụng +để lại một null char hàng đầu, nhưng bất kỳ lúc nào tôi cũng có thể sử dụng +, hoạt động tương tự như &đối với chuỗi.

Hãy thử trực tuyến!

JavaScript (ES6), 170 131 byte

s=>s.split`000`.map(e=>'  ETIANMSURWDKGOHVF L PJBXCYZQ'[c=+`0b${1+e.replace(/0?(111|1)/g,d=>+(d>1))}`]||'473168290 5'[c%11]).join``

Nếu bạn thay đổi dấu chấm thành 0 và dấu gạch ngang thành 1s và tiền tố bằng 1, bạn sẽ nhận được số nhị phân, khi được chuyển đổi thành số thập phân sẽ cung cấp cho bạn:

1. Chữ cái: 2 - 18, 20 và 22 - 29.
   Chúng có thể được chuyển đổi thành các chữ cái chính xác bằng cách lập chỉ mục thành ' ETIANMSURWDKGOHVF L PJBXCYZQ'.
2. Các số: 32, 33, 35, 39, 47, 48, 56, 60, 62 và 63.
   Nếu chúng ta lấy các số này theo mô đun 11, chúng ta sẽ nhận được các số 0 - 8 và 10, có thể được chuyển đổi thành các số chính xác theo lập chỉ mục vào '473168290 5'.

Chương trình phân chia trên các ký tự, sau đó chuyển đổi từng ký tự thành dấu chấm và dấu gạch ngang, được chuyển đổi thành đầu ra thích hợp dựa trên các quy tắc trên.

Các trường hợp thử nghiệm:

let f=

s=>s.split`000`.map(e=>'  ETIANMSURWDKGOHVF L PJBXCYZQ'[c=+`0b${1+e.replace(/0?(111|1)/g,d=>+(d>1))}`]||'473168290 5'[c%11]).join``

console.log(f('101010100010001011101010001011101010001110111011100000001011101110001110111011100010111010001011101010001110101'))
console.log(f('10100000001011100011101110000000101110000000101011101000101000101010001010101'));
console.log(f('1010111011101110001110111011101110111000101110111011101110001110111010101'));
console.log(f('101010001110111011100010101'));

Python 2 , 127 byte

lambda s:''.join("IVMB  T  K 9LZF 1HWO3 GUS4 8 7A  E QR 26   NJX    Y0P 5D  C"[(int('0'+l)^2162146)%59]for l in s.split('000'))

Hãy thử trực tuyến!

Xây dựng giải pháp của TFeld bằng cách loại bỏ thay thế và bằng cách làm việc trong cơ sở 10, với chi phí của xor bitwise và chuỗi tham chiếu dài hơn.

PHP, 321 284 byte

Đã lưu 37 byte nhờ @ovs

$a=array_flip([242,161,134,125,122,121,202,229,238,241,5,67,70,22,1,43,25,40,4,53,23,49,8,7,26,52,77,16,13,2,14,41,17,68,71,76]);foreach(split('0000000',$argv[1])as$w){foreach(split('000',$w)as$m){echo($v=$a[base_convert(str_replace([111,0],[2,],$m),3,10)])>9?chr($v+55):$v;}echo' ';}  

Phiên bản trước (321 byte)

$a=array_flip([22222,12222,11222,11122,11112,11111,21111,22111,22211,22221,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]);foreach(split('0000000',$argv[1])as$w){foreach(split('000',$w)as$m){echo($v=$a[str_replace([111,0],[2,],$m)])>9?chr($v+55):$v;}echo' ';}

Hãy thử trực tuyến!

Phiên bản bị đánh cắp:

$a=array_flip(
// Building an array $a with every Morse letter representation (1=dot, 2=dash) and flip it
               [22222,12222,11222,11122,11112,
                // 01234
                11111,21111,22111,22211,22221,
                // 56789
                12,2111,2121,211,1,1121,221,
                // ABCDEFG
                1111,11,1222,212,1211,22,
                // HIJKLM
                21,222,1221,2212,121,111,2,
                // NOPQRST
                112,1112,122,2112,2122,2211]);
                // UVWXYZ
foreach (split('0000000', $argv[1]) as $w){
// for each word (separate with 7 consecutive zeroes)
    foreach (split('000',$w) as $m){
    // for each letter (separate with 3 consecutive zeroes)
        echo ($v = $a[str_replace([111,0],[2,],$m)]) > 9
        // Replace '111' with '2' and '0' with nothing and find $v, the corresponding entry in the array $a
            ? chr($v+55)
            // If > 9th element, then letter => echo the ASCII code equal to $v+55
            : $v;
            // Else echo $v
    }
    echo ' ';
    // Echo a space
}

Java (OpenJDK 8) , 370 byte

s->{String r="";for(String t:s.split("0000000")){for(String u:t.split("000"))for(int x[]={1,7,5,21,29,23,87,93,119,85,117,341,375,343,373,471,477,349,469,1877,1367,1909,1879,1501,1911,1885,7637,5495,7543,7639,6007,30581,22391,122333,96119,489335},i=x.length;i-->0;)if(u.equals(Long.toString(x[i],2)))r+="ETISNAURMHD5WVLKGFB64ZXPOC73YQJ82910".charAt(i);r+=" ";}return r;}

Hãy thử trực tuyến!

• 3 byte được lưu nhờ @Jeutnarg.

GNU sed , 261 + 1 = 262 byte

+1 byte cho -rcờ.

s/000/;/g
s/111/_/g
s/0//g
s/$/;:51111141111_3111__211___i1____6_11117__1118___119____10_____H1111V111_F11_1L1_11P1__1J1___B_111X_11_C_1_1Y_1__Z__11Q__1_S111U11_R1_1W1__D_11K_1_N__1G__1O___I11A1_M__E1T_/
:
s/([1_]+);(.*([^1_])\1)/\3\2/
t
y/i/1/
s/;/ /g
s/:.*//g

Hãy thử trực tuyến!

Giải trình

Đây là một giải pháp bảng tra cứu rất cơ bản.

Ba dòng đầu tiên biến đổi đầu vào để dấu gạch ngang là _s và dấu chấm là 1s. Đầu tiên, 000s được thay thế bằng ;, vì vậy các ký tự được phân tách bằng ;và các từ bằng ;;0. Sau đó111 s được thay thế bởi _và tất cả các 0s còn lại bị loại bỏ, để lại 1s cho các dấu chấm.

s/000/;/g
s/111/_/g
s/0//g

Dòng tiếp theo nối thêm bảng tra cứu. Nó có dạng cmcmcm...nơi clà một nhân vật và mlà chuỗi _s và 1s đại diện cho nó. iđược thay thế cho 1trong bảng cho định hướng. Vì các biểu thức chính quy trong sed luôn tham lam, nên bảng được sắp xếp từ mã dài nhất đến mã ngắn nhất (ví dụ:1_ khớp A1_thay vì i1____).

s/$/;:51111141111_3111__211___i1____6_11117__1118___119____10_____H1111V111_F11_1L1_11P1__1J1___B_111X_11_C_1_1Y_1__Z__11Q__1_S111U11_R1_1W1__D_11K_1_N__1G__1O___I11A1_M__E1T_/

Tiếp theo, trong một vòng lặp, mỗi chuỗi _ s và 1s (và tiếp theo ;) được thay thế bằng ký tự tương ứng:

:
s/([1_]+);(.*([^1_])\1)/\3\2/
t

Cuối cùng, dọn dẹp: is được thay thế bằng 1s, ;s còn lại là khoảng trắng và bảng tra cứu bị xóa:

y/i/1/
s/;/ /g
s/:.*//g

Thạch , 67 byte

ŒrḌṣ7ṣ€3ṣ€€1’H_4F€€ḅ3i@€€“ṗƙ⁶}zyȮẓŀȯ¦CFæ¢+ı(¥5ç1®¬ȷ4MÑÆ£Ç)×DGL‘ịØBK

Hãy thử trực tuyến!

JavaScript (ES6), 104 102 101 99 byte

s=>s.split`000`.map(n=>" _T__9VEFO0K7MX_CGS__LU1RYIJ845__Z_B_D6QP_3__AHNW2"[n*1741%8360%51]).join``

Các trường hợp thử nghiệm

let f =

s=>s.split`000`.map(n=>" _T__9VEFO0K7MX_CGS__LU1RYIJ845__Z_B_D6QP_3__AHNW2"[n*1741%8360%51]).join``

console.log(f("101010100010001011101010001011101010001110111011100000001011101110001110111011100010111010001011101010001110101"))
console.log(f("10100000001011100011101110000000101110000000101011101000101000101010001010101"))
console.log(f("1010111011101110001110111011101110111000101110111011101110001110111010101"))
console.log(f("101010001110111011100010101"))

Làm sao?

Vì chuyển đổi từ byte nhị phân sang chi phí thập phân, chúng tôi sử dụng hàm băm hoạt động trực tiếp trên các khối nhị phân được diễn giải trong cơ sở 10.

Thí dụ

dot dash dot dot = 101110101
101110101 * 1741 = 176032685841
176032685841 % 8360 = 3081
3081 % 51 = 21

--> The 21st character in the lookup table is 'L' (0-indexed).

Võng mạc , 144 138 130 103 byte

T`d`@#
^|@@@

 @?#
E
{T`L#@`R6_BI_Z5S1C_GD8__\L\HNF3P__7_`\w@#
T`589B-INPRSZ#@`490XYKT2\OVAMJWUQ_`\w##

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

T`d`@#

Thay đổi các chữ số nhị phân thành các ký tự khác vì 0 và 1 là đầu ra hợp lệ.

^|@@@
 

Chèn một khoảng trắng trước mỗi ký tự và hai khoảng trắng giữa các từ.

 @?#
E

Giả sử rằng tất cả các nhân vật là Es.

{T`L#@`R6_BI_Z5S1C_GD8__\L\HNF3P__7_`\w@#

Dịch tất cả các chữ cái giả sử rằng chúng sẽ được theo sau bởi một dấu chấm. Chẳng hạn, nếu chúng ta có E và chúng ta thấy một dấu chấm thứ hai (chúng ta đã tiêu thụ lần đầu tiên khi chúng ta chèn E) thì nó sẽ dịch thành I. Đối với các chữ cái chỉ có thể được theo sau một dấu gạch ngang, chúng được dịch theo đó giả định, và sau đó dấu gạch ngang được tiêu thụ bởi giai đoạn tiếp theo. Các chữ cái khác sẽ bị xóa (giữ Lchi phí một byte).

T`589B-INPRSZ#@`490XYKT2\OVAMJWUQ_`\w##

Nếu nó thực sự xảy ra rằng chúng thực sự được theo sau bởi một dấu gạch ngang, sau đó sửa chữa các dịch sai. Điều này cũng tiêu thụ dấu gạch ngang khi nó được giả định bởi giai đoạn trước. Cả hai bản dịch được lặp lại cho đến khi tất cả các dấu chấm và dấu gạch ngang được tiêu thụ.

Perl 5 , 241 + 1 ( -p) = 242 byte

%k=map{(23,469,1885,117,1,349,477,85,5,6007,471,373,119,29,1911,1501,7639,93,21,7,87,343,375,1879,7543,1909,489335,96119,22391,5495,1367,341,1877,7637,30581,122333)[$i++]=>$_}A..Z,0..9;map{$\.=$k{oct"0b$_"}for split/000/;$\.=$"}split/0{7}/}{

Hãy thử trực tuyến!

PHP, 181 + 1 byte

foreach(explode(_,strtr($argn. 0,[1110=>1,10=>0,"0000"=>_A,"00"=>_]))as$t)echo$t<A?~$t[-5]?(10+substr_count($t,0)*(1-2*$t[-5]))%10:__ETIANMSURWDKGOHVF_L_PJBXCYZQ[bindec("1$t")]:" ";

Chạy như ống với -nRhoặc thử trực tuyến .

ES6 , 268 byte

Sử dụng mã hóa ASCII sau khi ánh xạ từ biểu diễn cơ sở36 của morse sang vị trí chỉ mục. Không phải ngày chơi golf tốt nhất của tôi, nhưng chỉ mất khoảng 15 phút.

s=>s.split('00000').map(w=>String.fromCharCode.apply({},w.split('000').map(c=>"ahkn,225z,h9z,48n,11z,9h,1g5,5w5,nlh,2me5,,,,,,,,n,d1,1gd,39,1,9p,d9,2d,5,4mv,d3,ad,3b,t,1h3,15p,5w7,2l,l,7,2f,9j,af,1g7,1h1".split(',').indexOf(parseInt(c,2).toString(36))+48))).join(' ')

Dễ đọc hơn (kinda):

s=>
s
.split('00000')
.map(w=>
	String.fromCharCode.apply({},
		w.split('000')
			.map(c=>
				"ahkn,225z,h9z,48n,11z,9h,1g5,5w5,nlh,2me5,,,,,,,,n,d1,1gd,39,1,9p,d9,2d,5,4mv,d3,ad,3b,t,1h3,15p,5w7,2l,l,7,2f,9j,af,1g7,1h1"
				.split(',')
				.indexOf(
					parseInt(c,2).toString(36)
				)+48)
			)
	).join(' ')

Ngôn ngữ Wolfram (Mathicala) , 288 byte

Nghĩ về việc đọc dữ liệu dưới dạng nhị phân từ một tệp nhưng điều đó khó giải thích. Cơ sở 36 dường như là một cách thỏa hiệp tốt để lưu trữ dữ liệu một cách hiệu quả theo từ vựng.

Lấy một chuỗi 0 và 1 là đầu vào. Liệu một loạt các thay thế, bắt đầu với việc chạy 7 số không, sau đó là 3 lần, sau đó là các chữ cái nhị phân dài nhất xuống ngắn nhất. Thứ tự thay thế là quan trọng.

StringReplace[#,Thread@Rule[Join[{"0000000","000"},#~FromDigits~36~IntegerString~2&/@StringSplit@"ahkn 2me5 225z nlh h9z 5w7 5w5 5tj 4mv 48n 1h3 1h1 1gd 1g7 1g5 15p 11z d9 d3 d1 af ad 9p 9j 9h 3b 39 2l 2f 2d t n l 7 5 1"],Insert[Characters@" 09182Q7YJ3OZCX6P4GKBWLFV5MDRUHNASTIE","",2]]]&

Hãy thử trực tuyến!

Perl 5 , 195 byte

Mã 194 byte + 1 cho -p.

%h=map{$_,(A..Z,0..9)[$i++]}unpack"S26I2S7I","\xd5]u]\xddUw\xd7uww\xdd\xd7]WWwWwuwwwwwWwWUU\xd5uw\xdd\xdd";s/0{7}/ /g;s/(\d+?)(000|\b)/$h{oct"0b$1"}/ge

Tôi không thể làm việc này chỉ với một chuỗi nhị phân được đóng gói tiêu chuẩn, tôi phải thoát khỏi các ký tự byte cao hơn nếu không tôi sẽ ở trên 171, nếu có ai biết tôi đã bỏ lỡ điều gì, hoặc tại sao nó phá vỡ sẽ rất tuyệt !

Hãy thử trực tuyến!

Giải trình

Chuỗi nhị phân là một packed danh sách các số có liên quan đến các nhân vật morse ( 101011101- 349cho Fvv) và điều này được nén với các đoạn băng A..Z,0..9và sử dụng như một tra cứu. Các s///biểu thức thay thế tất cả các lần chạy bảy 0giây bằng khoảng trắng và sau đó tất cả các chữ số, được phân tách bằng 0ranh giới ba hoặc từ \b, bằng khóa tương ứng của chúng từ %hhàm băm.