क्या यह वैध संशोधित UTF-8 है?

Question

UTF-8 एक चर-चौड़ाई प्रारूप में यूनिकोड कोडपॉइंट्स को एनकोड करने के लिए एक अपेक्षाकृत सरल तरीका है कि यह आसानी से कोड को भ्रमित नहीं करता है जो यूनिकोड के बारे में पता नहीं है।

UTF-8 का अवलोकन

• 1-0x7F की सीमा में बाइट्स, समावेशी, सामान्य रूप से मान्य हैं
• बिट पैटर्न के साथ बाइट्स को 10XX XXXXनिरंतरता बाइट्स माना जाता है, जिसमें छह कम से कम महत्वपूर्ण बिट्स का उपयोग कोडपॉइंट के भाग को एनकोड करने के लिए किया जाता है। जब तक वे पूर्ववर्ती बाइट से अपेक्षित नहीं होते, तब तक वे प्रकट नहीं होंगे।
• पैटर्न के साथ बाइट्स 110X XXXXबाद में एक निरंतरता बाइट की उम्मीद करते हैं
• पैटर्न के साथ बाइट्स 1110 XXXXदो निरंतरता बाइट्स की अपेक्षा करते हैं
• पैटर्न के साथ 1111 0XXXबाइट्स बाद में तीन निरंतरता बाइट्स की उम्मीद करते हैं
• अन्य सभी बाइट अमान्य हैं और UTF-8 स्ट्रीम में कहीं भी नहीं दिखनी चाहिए। 5, 6, और 7 बाइट क्लस्टर्स सिद्धांत में संभव हैं, लेकिन इस चुनौती के प्रयोजनों के लिए अनुमति नहीं दी जाएगी।

लंबे समय तक एनकोडिंग

UTF-8 के लिए यह भी आवश्यक है कि एक कोडपॉइंट को न्यूनतम बाइट्स के साथ दर्शाया जाए। कोई भी बाइट अनुक्रम जिसे कम बाइट्स के साथ दर्शाया जा सकता है, मान्य नहीं है। संशोधित UTF-8 नल वर्णों (U + 0000) के लिए इसमें एक अपवाद जोड़ता है, जिसे C0 80(हेक्स प्रतिनिधित्व) के रूप में दर्शाया जाना चाहिए , और इसके बजाय null बाइट्स को स्ट्रीम में कहीं भी प्रदर्शित करने के लिए अस्वीकृत करता है। (यह इसे शून्य-समाप्त स्ट्रिंग्स के साथ संगत बनाता है)

चुनौती

आपको एक कार्यक्रम बनाना है, जब बाइट्स की एक स्ट्रिंग दी जाती है, तो यह निर्धारित करेगा कि क्या वह स्ट्रिंग मान्य संशोधित UTF-8 का प्रतिनिधित्व करता है और यदि वैध और गलत तरीके से मान रखता है तो एक सत्य मान लौटाएगा। ध्यान दें कि आपको लंबे समय तक एन्कोडिंग और नल बाइट्स के लिए जांच करनी चाहिए (क्योंकि यह संशोधित यूटीएफ -8 है)। आपको UTF-8 मान को डीकोड करने की आवश्यकता नहीं है।

उदाहरण

41 42 43  ==> yes (all bytes are in the 0-0x7F range)
00 01 02  ==> no (there is a null byte in the stream)
80 7F 41  ==> no (there is a continuation byte without a starter byte)
D9 84 10  ==> yes (the correct number of continuation bytes follow a starter byte)
F0 81 82 41  ==> no (there are not enough continuation bytes after F0)
EF 8A A7 91  ==> no (too many continuation bytes)
E1 E1 01  ==> no (starter byte where a continuation byte is expected)
E0 80 87  ==> no (overlong encoding)
41 C0 80  ==> yes (null byte encoded with the only legal overlong encoding)
F8 42 43  ==> no (invalid byte 'F8')

नियम

• मानक नियम और खामियां लागू होती हैं
• इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकते हैं जब तक कि अहस्ताक्षरित बाइट रेंज (0-255) में सभी मूल्यों को पढ़ा जा सकता है।
  • आपको एक नल-समाप्त स्ट्रिंग के बजाय एक सरणी या फ़ाइल का उपयोग करने की आवश्यकता हो सकती है। आपको अशक्त बाइट्स पढ़ने में सक्षम होने की आवश्यकता है।
• सबसे छोटा कोड जीतता है!
• ध्यान दें कि यूटीएफ -8 को डिकोड करने के लिए बिल्डरों का उपयोग करना यहां दी गई आवश्यकताओं के अनुरूप होने की गारंटी नहीं है। आपको इसके आसपास काम करने और विशेष मामले बनाने की आवश्यकता हो सकती है।

संपादित करें: यूटीएफ -8 को डिकोड करने वाले बिल्डरों का उपयोग नहीं करने के लिए जोड़ा गया बोनस

EDIT2: केवल रुस्त उत्तर योग्य होने के कारण बोनस हटा दिया गया है और इसे परिभाषित करना अजीब है।

Comments

मैं इसके लिए इंतजार कर रहा हूं।

— 21

आप 0xF8-0xFF सीमा में अमान्य बाइट के साथ एक परीक्षण मामला जोड़ना चाह सकते हैं।

— अरनुलद

ऐसा लगता है कि सरोगेट्स (0xD800 - 0xDFFF) और 0x10FFFF से परे कोडपॉइंट की अनुमति है, "आधुनिक" UTF-8 कल्पना के विपरीत। मुझे लगता है कि इसे स्पष्ट किया जाना चाहिए, आदर्श रूप से अतिरिक्त परीक्षण मामलों के साथ।

— nwellnhof

अधिक उदाहरण सहायक होंगे

— उज्ज्वल

"0-0x7F की सीमा में बाइट्स, समावेशी, सामान्य रूप से मान्य हैं" क्या यह 1 से 0x7f माना जाता है?

— उज्ज्वल

Answer 1

अमृत , 69 बाइट्स

import String
&valid? replace replace(&1,<<0>>,"\xFF"),"\xC0\x80","0"

इसे ऑनलाइन आज़माएं!

अंतर्निहित स्ट्रिंग सत्यापन फ़ंक्शन का उपयोग करता है। अमृत ​​बाइनरी के रूप में इनपुट लेता है।

Answer 2

एपीएल (डायलॉग यूनिकोड) , 41 39 बाइट्स ^{एसबीसीएस}

बेनामी tacit उपसर्ग समारोह। एक यूनिकोड स्ट्रिंग को तर्क के रूप में लेता है जहां वर्ण कोड बिंदु इनपुट बाइट का प्रतिनिधित्व करते हैं।

{0::0⋄×⌊/'UTF-8'⎕UCS⍣2⎕UCS⍵}'À\x80'⎕R⎕A

इसे ऑनलाइन आज़माएं!

'À\x80'⎕R⎕A आर eplace C0 80अपरकेस साथ एक lphabet

{... } निम्नलिखित अनाम फ़ंक्शन लागू करें, जहां तर्क है ⍵:

 0:: यदि कोई त्रुटि होती है:

  0 शून्य लौटाओ

 ⋄ प्रयत्न:

  ⎕UCS⍵ स्ट्रिंग को कोड बिंदुओं में बदलें

  'UTF-8'⎕UCS⍣2 UTF-8 बाइट्स के रूप में व्याख्या करें और परिणामी टेक्स्ट को बाइट्स में बदलें

  ⌊/ सबसे कम बाइट (शून्य यदि एक शून्य बाइट मौजूद है, तो सकारात्मक है यदि नहीं, तो "अनंत" यदि खाली स्ट्रिंग है)

  × संकेत (शून्य शून्य बाइट मौजूद है, एक नहीं तो)

Comments

क्या यह वापसी सत्य नहीं होगी D9 C0 80 84 C0 80 10?

— नील

@ नील यह वास्तव में करता है। क्या यह गलत है क्योंकि हटाने C0 80से असंबंधित बाइट्स एक तरह से सटे हुए हैं जो वैध हैं, हालांकि वे अलग होने पर अमान्य हैं? संपादित करें: कोई बाइट लागत पर इसे ठीक करने के लिए अद्यतन किया गया।

— आदाम

मेरे चरित्र में कुछ आयतें सिर्फ आयतों या बक्से के रूप में आ रही हैं, क्या यह सामान्य है? लिनक्स में फ़ायरफ़ॉक्स में im। APL एक बहुत ही रोचक भाषा है।

— उज्ज्वल

@donbright मेरे अनुभव में, एपीएल अक्षर हमेशा सही ढंग से प्रस्तुत करते हैं, भले ही कभी-कभी खूबसूरती से कम हो, इसलिए वे बॉक्स शायद सिर्फ क्वाड एस होते हैं जिनमें से मुख्य कोड में चार होने चाहिए। इसे इस तरह प्रस्तुत करना चाहिए । और हाँ, एपीएल अद्भुत है, और बहुत मज़ा है। आप आसानी से और जल्दी से इसे भी सीख सकते हैं - बस एपीएल ऑर्चर्ड पर आ जाओ ।

— एडम

हाँ, वे quads हैं। धन्यवाद।

— उज्ज्वल

Answer 3

पायथन 2 , 104 102 बाइट्स

''.join(chr(int(c,16))for c in input().replace('00','-').replace('C0 80','0').split()).decode('utf-8')

इसे ऑनलाइन आज़माएं!

निर्गम कोड के माध्यम से आउटपुट

Answer 4

जंग - 191 बाइट्स 313 बाइट्स

मूल से नीचे प्रति टिप्पणी ठीक से काम नहीं किया। नया और बेहतर संस्करण। किसी भी पुस्तकालय का उपयोग नहीं किया जाता है, क्योंकि द माइटी रस्ट को आपके और आपके पुस्तकालयों की कोई आवश्यकता नहीं है। यह कोड एक स्टेट मशीन के साथ पैटर्न मिलान का उपयोग करता है। बेशर्मी से UTF8 युक्ति को बंद करके , इसे संदर्भ और चर्चा के माध्यम से जॉन स्कीट द्वारा खोजने के बाद , हम एक जंग मैच पैटर्न मैच ब्लॉक में चरित्र के लिए कल्पना लगभग चरित्र की नकल कर सकते हैं। अंत में, हम C0 80 के लिए बीफस्टर की विशेष Mutf8 आवश्यकता को वैध मानते हैं। Ungolfed:

/* http://www.unicode.org/versions/corrigendum1.html
 Code Points        1st Byte    2nd Byte    3rd Byte    4th Byte
U+0000..U+007F      00..7F           
U+0080..U+07FF      C2..DF      80..BF           
U+0800..U+0FFF      E0          A0..BF      80..BF       
U+1000..U+FFFF      E1..EF      80..BF      80..BF       
U+10000..U+3FFFF    F0          90..BF      80..BF      80..BF
U+40000..U+FFFFF    F1..F3      80..BF      80..BF      80..BF
U+100000..U+10FFFF  F4          80..8F      80..BF      80..BF
*/

let m=|v:&Vec<u8>|v.iter().fold(0, |s, b| match (s, b) {
        (0, 0x01..=0x7F) => 0,
        (0, 0xc2..=0xdf) => 1,
        (0, 0xe0) => 2,
        (0, 0xe1..=0xef) => 4,
        (0, 0xf0) => 5,
        (0, 0xf1..=0xf3) => 6,
        (0, 0xf4) => 7,
        (1, 0x80..=0xbf) => 0,
        (2, 0xa0..=0xbf) => 1,
        (4, 0x80..=0xbf) => 1,
        (5, 0x90..=0xbf) => 4,
        (6, 0x80..=0xbf) => 4,
        (7, 0x80..=0x8f) => 4,
        (0, 0xc0) => 8, // beefster mutf8 null
        (8, 0x80) => 0, // beefster mutf8 null
        _ => -1,
    })==0;

जंग के खेल के मैदान पर इसे आज़माएं

Comments

इसे मैन्युअल रूप से करने के लिए प्रॉप्स, लेकिन मुझे लगता है कि आपका ओवरलोड चेक गलत है।

— बीफस्टर

आपकी चुनौती, प्रिय महोदय, मुझे नकल करने के लिए उकसाते हैं, और मैं इस पत्र को आपको चुनौती देकर, मेरी बारी में, एक ऐसे आदमी पर ठीक करने के लिए समाप्त करता हूं, जो आपके प्रश्न को और अधिक स्पष्ट रूप से उजागर करेगा ( bit.ly/2T8tXhO )

— उज्ज्वल उज्ज्वल