เป้าหมาย

รหัสมอร์สมักจะแสดงเป็นเสียง กำหนดกระแสของบิตที่แสดงว่าเสียงเปิดหรือปิดให้แปลสตรีมเป็นตัวอักษรและตัวเลขและช่องว่าง

ข้อมูลจำเพาะ

• สตรีมบิตถูกวิเคราะห์ตามความยาวของการทำซ้ำเปิด / ปิดบิต
  • 1 ON บิตคือจุด
  • 3 ON บิตเป็นเส้นประ
  • 1 OFF บิตจะกำหนดจุดและขีดกลาง
  • 3 OFF บิตคั่นอักขระ
  • 7 OFF บิตคั่นคำ (ช่องว่าง)
• อินพุตอาจเป็นสตริงหรืออาร์เรย์ อนุญาตให้ป้อนอักขระ / ค่าที่ไม่ซ้ำกันสองตัวเท่านั้นในอินพุต (เช่น 0/1, จริง / เท็จ, จุลภาค / ช่องว่าง)
• เอาต์พุตส่งคืนสตริงหรือถูกพิมพ์ไปที่เอาต์พุตมาตรฐาน

ตัวอย่าง

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

สมมติฐาน

• กระแสเริ่มต้นและสิ้นสุดด้วยบิตบนเสมอ
• ไม่มีช่องว่างนำหน้าหรือต่อท้าย
• อินพุตถูกต้องเสมอ
• รองรับตัวอักษรทั้งหมด (ตัวพิมพ์เล็กและตัวพิมพ์ใหญ่) และตัวเลข

กรณีทดสอบ

101010100010001011101010001011101010001110111011100000001011101110001110111011100010111010001011101010001110101
HELLO WORLD

10100000001011100011101110000000101110000000101011101000101000101010001010101
I AM A FISH

1010111011101110001110111011101110111000101110111011101110001110111010101
2017

101010001110111011100010101
SOS

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟ รหัสไบต์ต่ำสุดนับในสัปดาห์นี้จะเป็นผู้ชนะ

APL (Dyalog) , 65 62 60 57 ไบต์

-3 ขอบคุณ ngn

ฟังก์ชั่นนำหน้า Tacit

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

ลองออนไลน์! Header f←และ Footer เป็นเพียงการอนุญาตให้เรียกใช้ฟังก์ชันจากอินพุตขณะที่ยังคงรักษาจำนวนไบต์ของ TIO ในเซสชั่น APL ปกติ (ตรงกับช่องใส่ของ TIO) มันจะไม่เป็นที่ต้องการ

⎕CY'dfns' c op y the dfns workspace (ไลบรารี)

(... ) ใช้นี้ฟังก์ชั่นโดยปริยาย:
 '1+|(00)+'⎕S 1 PCRE S earch 1 วิ่งและแม้กระทั่งความยาว 0 วิ่งและผลตอบแทนการแข่งขันความยาว
 6| ส่วนที่เหลือเมื่อหารด้วย 6
 ⊃∘'/. -'¨ สำหรับระยะการแข่งขันแต่ละเลือกตัวอักษรที่สอดคล้องกันจากสายนี้
'/|[-.]+'⎕S'&'∘ PCRE S earch ทับและรีบ / จุด รันและส่งคืนการ
morse แปลเหล่านั้นจากรหัสมอร์สไปเป็นข้อความปกติ

Python 2 , 142 135 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

แยกสตริงออกเป็นตัวอักษรบน000( 0หมายถึงช่องว่าง)

แทนที่แต่ละ111ด้วย3และแปลงเป็นฐาน 16

จากนั้นแต่ละหมายเลขจะถูกมอดูด57ซึ่งให้ช่วง0..54ซึ่งเป็นดัชนีของอักขระปัจจุบัน

เวอร์ชันก่อนหน้านี้ที่แปลงเป็นฐาน 3:

Python 2 , 273 252 247 ไบต์

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

ลองออนไลน์!

เวอร์ชันก่อนหน้านี้ที่แปลงเป็นไบนารี:

Python 2 , 282 261 256 ไบต์

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

ลองออนไลน์!

Ruby , 123 ไบต์

->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]:" "}*""}

ลองออนไลน์!

แยกสตริงอินพุตตามจำนวนอักขระสูงสุด ใช้บิต 3 หรือ 4 OFF เพื่อให้มีการแปลงช่องว่างเป็นสตริงว่าง ใช้ค่าฐาน 2 ของตัวละครทุกตัวและนำมาในช่วงที่เหมาะสม (น้อยกว่า 60 ค่าที่เป็นไปได้) โดยใช้โมดูโล่ใน 3 ส่วนที่ต่อเนื่องกัน

Python , 175 168 ไบต์

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

ก่อนอื่นแปลงสตริงเป็นรายการของสตริง 0 (เส้นประ) / 1 (จุด) เพิ่มคำนำหน้า1(เพื่อป้องกันไม่ให้เลขศูนย์นำหน้าและจัดการกับช่องว่าง) จากนั้นแปลงเป็นไบนารี

เนื่องจากทุกรหัสมีความยาวไม่เกิน 5 ผลลัพธ์จะอยู่ในช่วงตั้งแต่ 0 ถึง 63 และสามารถแสดงรายการเป็นสตริงได้

เยลลี่ , 67 62 ไบต์

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

ลองออนไลน์!

Visual Basic .NET (.NET Core) , 252 ไบต์

-7 ไบต์ขอบคุณ @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

ฟังก์ชั่นที่รับสตริงของ1s และ0s และส่งคืนสตริง (อันที่จริงเพียง0สำหรับOFFเป็นความต้องการอย่างหนัก. สิ่งใดไม่ได้OFFจะถือว่าเป็นON)

สตริงตัวอักษรคือการตั้งค่ารหัสมอร์สเป็นฮีปไบนารีในรูปแบบอาร์เรย์ VB.NET ช่วยให้คุณสามารถจัดทำดัชนีสตริงเป็นอาร์เรย์ของอักขระ \เป็นจำนวนเต็มส่วนการกองย่อยซ้ายหรือกองย่อยที่เหมาะสมสำหรับ1111

ฉันใช้!เป็นค่าว่างเมื่อไม่มีค่าในจุดฮีพนั้น จำเป็นต้องมีการจัดทำดัชนีอย่างเหมาะสมเท่านั้น

VB.NET ช่วยให้คุณกลับมาโดยกำหนดค่าให้กับชื่อฟังก์ชั่น (ในกรณีนี้A) ฉันแค่ทำซ้ำ concatenations สตริง ( &) เพื่อสร้างสตริงออก ครั้งแรกที่ฉันต้องใช้&เพราะการใช้+ทิ้ง char char ชั้นนำ แต่เวลาอื่น ๆ ที่ฉันสามารถใช้+ซึ่งมีพฤติกรรมเช่นเดียวกับ&สตริง

ลองออนไลน์!

JavaScript (ES6), 170 131 ไบต์

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

หากคุณเปลี่ยนจุดเป็น 0 และขีดกลางเป็น 1s และนำหน้าด้วย 1 คุณจะได้รับเลขฐานสองซึ่งเมื่อแปลงเป็นทศนิยมให้คุณ:

1. ตัวอักษร: 2-18, 20, และ 22 - 29 เหล่านี้สามารถแปลงเป็นตัวอักษรที่ถูกต้องโดยการจัดทำดัชนีลงไป
   ' ETIANMSURWDKGOHVF L PJBXCYZQ'
2. ตัวเลข: 32, 33, 35, 39, 47, 48, 56, 60, 62, และ 63
   ถ้าเราใช้โมดูลัสตัวเลข 11 เหล่านี้เราจะได้ตัวเลข 0 - 8 และ 10 ซึ่งสามารถแปลงเป็นตัวเลขที่ถูกต้องโดย '473168290 5'จัดทำดัชนีลงไป

โปรแกรมแยกตัวอักษรจากนั้นแปลงอักขระแต่ละตัวเป็นจุดและขีดกลางซึ่งจะถูกแปลงเป็นเอาต์พุตที่เหมาะสมตามกฎข้างต้น

กรณีทดสอบ:

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 ไบต์

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

ลองออนไลน์!

การสร้างโซลูชันของTFeldโดยการแทนที่การแทนที่และการทำงานในฐาน 10 ด้วยค่าบิต xor และสตริงอ้างอิงที่ยาวกว่า

PHP, 321 284 ไบต์

บันทึกแล้ว 37 ไบต์ขอบคุณ @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' ';}  

รุ่นก่อนหน้า (321 ไบต์)

$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' ';}

ลองออนไลน์!

เวอร์ชันที่ไม่ถูกปรับแต่ง:

$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 ไบต์

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

ลองออนไลน์!

• บันทึก 3 ไบต์ด้วย @Jeutnarg

รุ่น GNU , 261 + 1 = 262 ไบต์

+1 ไบต์สำหรับการ-rตั้งค่าสถานะ

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

ลองออนไลน์!

คำอธิบาย

นี่เป็นโซลูชันตารางการค้นหาขั้นพื้นฐานมาก

สามบรรทัดแรกเปลี่ยนอินพุตดังนั้นเครื่องหมายขีดคั่นคือ_s และจุดต่างๆเป็น1s ครั้งแรก000ที่จะถูกแทนที่ด้วย;เพื่อให้ตัวอักษรมีการแยกออกจากกันและคำพูดโดย; ;;0จากนั้น111s จะถูกแทนที่ด้วย_และ0s ที่เหลือทั้งหมดจะถูกละทิ้งทิ้งไว้1สำหรับจุด

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

บรรทัดถัดไปจะผนวกตารางการค้นหาต่อท้าย มันใช้รูปแบบcmcmcm...ที่cเป็นตัวละครและmเป็นลำดับของ_s และ1s แทนมัน iถูกแทนที่1ในตารางเพื่อแก้ความกำกวม เนื่องจากนิพจน์ทั่วไปใน sed มีความโลภอยู่เสมอตารางจึงถูกเรียงลำดับจากรหัสที่ยาวที่สุดไปถึงสั้นที่สุด (เช่นการ1_จับคู่A1_แทน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_/

ถัดไปในลูปแต่ละลำดับของ_s และ1s (และลำดับถัดมา;) จะถูกแทนที่ด้วยอักขระที่เกี่ยวข้อง:

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

ในที่สุดการล้างข้อมูล: is จะถูกแทนที่ด้วย1s ส่วนที่เหลือ;คือช่องว่างและตารางการค้นหาจะถูกลบ:

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

เยลลี่ , 67 ไบต์

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

ลองออนไลน์!

JavaScript (ES6), 104 102 101 99 ไบต์

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

กรณีทดสอบ

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

อย่างไร?

เนื่องจากการแปลงจากไบนารี่ไบท์เป็นทศนิยมราคาเราใช้ฟังก์ชั่นแฮชซึ่งทำงานโดยตรงบนบล็อกไบนารี่ที่แปลในฐาน 10

ตัวอย่าง

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

เรตินา , 144 138 130 103 ไบต์

T`d`@#
^|@@@

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย:

T`d`@#

เปลี่ยนเลขฐานสองเป็นอักขระอื่นเนื่องจาก 0 และ 1 เป็นเอาต์พุตที่ถูกต้อง

^|@@@
 

แทรกช่องว่างหน้าอักขระทุกตัวและเว้นวรรคสองคำระหว่างคำ

 @?#
E

สมมติว่าตัวละครทั้งหมดเป็น Es

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

แปลตัวอักษรทั้งหมดที่สมมติว่าพวกเขาจะตามมาด้วยจุด ตัวอย่างเช่นถ้าเรามี E และเราเห็นจุดที่สอง (เราใช้ครั้งแรกเมื่อเราแทรก E) แล้วมันแปลเป็น I. สำหรับตัวอักษรที่สามารถตามด้วยเส้นประตามกฎหมายเท่านั้นพวกเขาจะถูกแปลด้วย สมมติฐานจากนั้นเส้นประจะถูกใช้ในขั้นตอนต่อไป ตัวอักษรอื่น ๆ จะถูกลบ (รักษาLต้นทุนเป็นไบต์)

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

หากมันปรากฏว่าพวกเขาอยู่ในความเป็นจริงตามด้วยเส้นประแล้วแก้ไขข้อผิดพลาด การทำเช่นนี้จะใช้เส้นประเมื่อถูกสันนิษฐานโดยขั้นตอนก่อนหน้า การแปลทั้งคู่จะทำซ้ำจนกว่าจะมีการใช้จุดและขีดกลางทั้งหมด

Perl 5 , 241 + 1 ( -p) = 242 ไบต์

%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}/}{

ลองออนไลน์!

PHP, 181 + 1 ไบต์

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")]:" ";

ทำงานเป็นท่อที่มี-nRหรือลองออนไลน์

ES6 , 268 ไบต์

ใช้การเข้ารหัส ASCII หลังจากการแมปจากการแสดง base36 ของมอร์สไปยังตำแหน่งดัชนี ไม่ใช่วันเล่นกอล์ฟที่ดีที่สุดของฉัน แต่ใช้เวลาประมาณ 15 นาทีเท่านั้น

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

ง่ายต่อการอ่าน (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(' ')

ภาษา Wolfram (Mathematica) , 288 ไบต์

คิดเกี่ยวกับการอ่านข้อมูลในรูปแบบไบนารี่จากไฟล์ แต่มันยากที่จะอธิบาย ฐาน 36 ดูเหมือนจะเป็นวิธีการประนีประนอมที่ดีในการจัดเก็บข้อมูลอย่างมีประสิทธิภาพ

รับค่าสตริงของ 0 และ 1 เป็นอินพุต ทำชุดของการแทนที่เริ่มต้นด้วยการรัน 7 ศูนย์จากนั้นเรียกใช้ 3 จากนั้นตัวอักษรไบนารีที่ยาวที่สุดลงไปที่สั้นที่สุด คำสั่งของการเปลี่ยนเป็นสิ่งสำคัญ

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

ลองออนไลน์!

Perl 5 , 195 ไบต์

194 รหัสไบต์ + 1 -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

ฉันไม่สามารถทำงานกับสตริงไบนารีที่อัดแน่นแบบมาตรฐานได้ฉันต้องหลบเลี่ยงตัวอักษรไบต์ที่สูงกว่ามิฉะนั้นฉันจะอยู่ที่ 171 หากใครรู้ว่าฉันพลาดอะไรไปหรือทำไมมันถึงแตก !

ลองออนไลน์!

คำอธิบาย

สตริงไบนารี่เป็นรายการpackedของตัวเลขที่เกี่ยวข้องกับตัวอักษรมอร์ส ( 101011101- 349สำหรับFฯลฯ ) และสิ่งนี้จะถูกซิปด้วยช่วงA..Z,0..9และใช้เป็นการค้นหา s///แสดงออกแทนที่วิ่งทั้งหมดเจ็ด0s ที่มีพื้นที่และจากนั้นวิ่งทั้งหมดของตัวเลขแยกสาม0หรือขอบเขตของคำ\bที่มีกุญแจสำคัญที่สอดคล้องกันของพวกเขาจาก%hกัญชา