UTF-8 बाइट अनुक्रम की लंबाई

Question

यूटीएफ -8 बाइट अनुक्रम की लंबाई निर्धारित करें जो इसकी पहली बाइट दी गई है। निम्न तालिका से पता चलता है कि प्रत्येक संभावित लंबाई के लिए नक्शा कौन सा है:

  Range    Length
---------  ------
0x00-0x7F    1
0xC2-0xDF    2
0xE0-0xEF    3
0xF0-0xF4    4

_{तालिका में अंतराल पर नोट: 0x80-0xBF निरंतर बाइट्स हैं, 0xC0-0xC1 एक अतिरंजित, अमान्य अनुक्रम शुरू करेगा, 0xF5-0xFF का परिणाम Unicic अधिकतम से परे एक कोड बिंदु में होगा।}

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट और आउटपुट के रूप में UTF-8 बाइट अनुक्रम का पहला बाइट लेता है या अनुक्रम की लंबाई लौटाता है। I / O लचीला है। उदाहरण के लिए, इनपुट एक संख्या, 8-बिट वर्ण या एक-वर्ण स्ट्रिंग हो सकता है। आप मान सकते हैं कि पहला बाइट एक मान्य अनुक्रम का हिस्सा है और ऊपर की सीमाओं में से एक में आता है।

यह कोड गोल्फ है। बाइट्स में सबसे छोटा जवाब जीत जाता है।

परीक्षण के मामलों

0x00 => 1
0x41 => 1
0x7F => 1
0xC2 => 2
0xDF => 2
0xE0 => 3
0xEF => 3
0xF0 => 4
0xF4 => 4

Comments

क्या 8 बिट्स की सूची का इनपुट स्वीकार्य है?

— जोनाथन एलन

@JonathanAllan नहीं, जो कि I / O को बहुत दूर ले जाएगा।

— nwellnhof

Answer 1

फोर्थ, 6 बाइट्स

x-size

देख https://forth-standard.org/standard/xchar/X-SIZE

इनपुट और आउटपुट एक मानक फोर्थ मॉडल का अनुसरण करता है:

इनपुट

एक एकल बाइट UTF-8 "स्ट्रिंग" की मेमोरी पता + लंबाई (यानी 1)।

उत्पादन

यूटीएफ -8 अनुक्रम बाइट्स में लंबाई।

नमूना कोड

एक मेमोरी सेल में 0xF0 स्टोर करें , और एक्स-आकार का आह्वान करें:

variable v
0xF0 v !
v 1 x-size

परिणाम की जाँच करें:

.s <1> 4  ok

Comments

इस कार्य को tio.run/#forth-gforth में मानते हुए , क्या आप एक उदाहरण दिखा सकते हैं? मुझे समझ में नहीं आता है कि यदि आप बाइट 0xF0 है तो आप सिंगल-बाइट UTF-8 स्ट्रिंग कैसे कर सकते हैं।

— डेनिस

> क्या आप एक उदाहरण दिखा सकते हैं? मुझे समझ में नहीं आता है कि यदि आप बाइट 0xF0 है तो आप सिंगल-बाइट UTF-8 स्ट्रिंग कैसे कर सकते हैं। मैंने कुछ नमूना कोड प्रदर्शित किए हैं कि यह कैसे करना है। दुर्भाग्य से, gforth का TIO संस्करण यूनिकोड शब्दों का समर्थन नहीं करता है ("एक्स-आकार देखें" के अनुसार, यह केवल 1 वहां लौटने के लिए कठिन-कोडित है)।

— ज़ेप्लेन

समझा। यही कारण है कि मैं एक UTF-8 स्ट्रिंग नहीं कहूंगा, क्योंकि F0 अकेला एक अमान्य बाइट अनुक्रम है, जहां तक ​​UTF-8 का संबंध है।

— डेनिस

> जैसा कि F0 अकेला एक अमान्य बाइट अनुक्रम है (इसलिए मैंने उद्धरण में "स्ट्रिंग" शब्द डाला है), लेकिन यह कार्य विशेष रूप से पहले बाइट द्वारा अनुक्रम को पहचानने के बारे में है, और फोर्थ वास्तव में इसे अमान्य होने की परवाह नहीं करता है , जो इस समाधान को संभव बनाता है, बदले में।

— zeppelin

Answer 2

Z80Golf , 19 14 बाइट्स

00000000: 2f6f 3e10 37ed 6a3d 30fb ee07 c03c       /o>.7.j=0....<

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

-5 बाइट्स @ बब्बलर को धन्यवाद

इनपुट 0x41 के साथ उदाहरण! इसे ऑनलाइन आज़माएं! सभा

इनपुट के साथ उदाहरण 0xC2- इसे ऑनलाइन आज़माएं!

इनपुट के साथ उदाहरण 0xE0-इसे ऑनलाइन आज़माएं!

इनपुट के साथ उदाहरण 0xF4- इसे ऑनलाइन आज़माएं!

सभा:

;input: register a
;output: register a
byte_count:			;calculate 7^(log2(255^a))||1
	cpl			;xor 255
	ld l,a
	log2:
		ld	a,16
		scf
	log2loop:
		adc	hl,hl
		dec	a
		jr	nc,log2loop
	xor 7
	ret nz
	inc a

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

Comments

विधानसभा के साथ काम करने के लिए बैश टीआईओ का उपयोग करें , उदाहरण के लिए आसान उदाहरणों के साथ। लिंक में आपके समाधान का 15-बाइट संस्करण भी है। सुधार यहां हैं: xor 0xff -> cpl, की कोई जरूरत नहीं or a, jr nz, return -> ret nz, ld a,1 -> inc a।

— बबलर

Answer 3

सी (जीसीसी) , 39 बाइट्स

t(char x){x=(__builtin_clz(~x)-24)%7u;}

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

Comments

क्यों charऔर क्या नहीं int?

— R .. गिटहब स्टॉप हेल्पिंग ICE

@R .. क्योंकि उन्हें साइन एक्सटेंडेड मिलता है। उदाहरण के लिए ~(char)0xF0 == ~(int)0xFFFFFFF0(मान char = signed char, sizeof(int) == 4)

— user202729

आह, मान लिया गया है कि हस्ताक्षर किए गए हैं।

— आर .. गिटहब स्टॉप हेल्पिंग ICE

Answer 4

जेली ,  8  7 बाइट्स

+⁹BIITḢ

बाइट को पूर्णांक के रूप में स्वीकार करने वाला एक विचित्र लिंक।

इसे ऑनलाइन आज़माएं! या मूल्यांकन किए गए सभी इनपुट देखें।

यदि 8 बिट्स की सूची का एक इनपुट स्वीकार्य था, तो विधि केवल 6 बाइट्स है: 1;IITḢहालाँकि, इसे लचीला I / O बहुत दूर की बात करने के रूप में समझा गया है।

कैसे?

+⁹BIITḢ - Link: integer       e.g.: 127 (7f)            223 (df)            239 (ef)            244 (f4)
 ⁹      - literal 256
+       - add                       383                 479                 495                 500
  B     - to a list of bits         [1,0,1,1,1,1,1,1,1] [1,1,1,0,1,1,1,1,1] [1,1,1,1,0,1,1,1,1] [1,1,1,1,1,0,1,0,0]
   I    - increments                [-1,1,0,0,0,0,0,0]  [0,0,-1,1,0,0,0,0]  [0,0,0,-1,1,0,0,0]  [0,0,0,0,-1,1,-1,0]
    I   - increments                [2,-1,0,0,0,0,0]    [0,-1,2,-1,0,0,0]   [0,0,-1,2,-1,0,0]   [0,0,0,-1,2,-2,1]
     T  - truthy indices            [1,2]               [2,3,4]             [3,4,5]             [4,5,6,7]
      Ḣ - head                      1                   2                   3                   4

Answer 5

हास्केल , 28 बाइट्स

f x=sum[1|y<-"Áßï",x>y]+1

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

Answer 6

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

lambda x:1.4**(x/16-11)//1+1

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

Answer 7

जेली , 8 7 बाइट्स

»Ø⁷Ba\S

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

यह काम किस प्रकार करता है

»Ø⁷Ba\S  Main link. Argument: n (integer)

 Ø⁷      Yield 128.
»        Take the maximum of n and 128.
   B     Yield the array of binary digits.
    a\   Cumulatively reduce by AND, replacing 1's after the first 0 with 0's.
      S  Take the sum.

Answer 8

जावास्क्रिप्ट (Node.js) , 24 बाइट्स

x=>7^Math.log2(255^x)||1

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

Answer 9

रूबी , 27 23 बाइट्स

->x{2+x[7]+(x/16<=>14)}

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

Answer 10

चारकोल , 12 बाइट्स

Ｉ⌕⍘⌈⟦Ｎ¹²⁸⟧²0

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

     Ｎ          Input number
      ¹²⁸       Literal 128
   ⌈⟦    ⟧      Take the maximum
  ⍘       ²     Convert to base 2 as a string
 ⌕         0    Find the position of the first `0`
Ｉ               Cast to string
                Implicitly print

Answer 11

जेली , 7 बाइट्स

»Ø⁷Bi0’

मेरे 05AB1E उत्तर का पोर्ट ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

 Ø⁷        # Push 128
»          # Take the max of 128 and the input
   B       # Convert it to binary
    i0     # Get the 1-indexed first index of a 0
      ’    # Decrease it by 1 to make it 0-indexed (and output it implicitly)

Answer 12

पर्ल 6 , 18 बाइट्स

{7-msb(255-$_)||1}

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

उपयोगकर्ता 202029 के जावास्क्रिप्ट उत्तर का पोर्ट। जो कुछ भी विकल्प के साथ विकल्प:

(255-*).msb*6%34%7
-(255-*).msb%6%5+1

Answer 13

x86 विधानसभा, 11 बाइट्स

00000000 <f>:
   0:   f6 d1                   not    %cl
   2:   0f bd c1                bsr    %ecx,%eax
   5:   34 07                   xor    $0x7,%al
   7:   75 01                   jne    a <l1>
   9:   40                      inc    %eax
0000000a <l1>:
   a:   c3                      ret

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

उपयोगकर्ता 202029 के जावास्क्रिप्ट उत्तर का पोर्ट। Fastcall सम्मेलनों का उपयोग करता है।

Answer 14

भूलभुलैया , 35 बाइट्स

? 28& 16/ )!@!
:_1 ";_ _3&""2
   @1

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

कोड का अनवांटेड संस्करण:

?:_128&1!@
      ;
      _16/_3&2!@
            )
            !
            @

Answer 15

05AB1E , 8 7 बाइट्स

žy‚àb0k

पोर्ट ऑफ @ नील का चारकोल जवाब ।
-1 बाइट @ ग्रीम को धन्यवाद ।

पूर्णांक के रूप में इनपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

žy       # Push 128
  ‚      # Pair it with the (implicit) input-integer
   à     # Take the maximum of this pair (128 and input)
    b    # Convert it to a binary-string
     0k  # Get the 0-based first index of a "0" in this binary-string
         # (and output it implicitly as result)

Comments

s)के ‚लिए 7. अन्य जेली जवाब पोर्टिंग एक और 8 देता है:₁+b¥η€ËO

— Grimmy

@Grimy पता नहीं क्यों मैं ‚पहली जगह में नहीं था ..: S लेकिन -1 के लिए धन्यवाद।

— केविन क्रूज़सेन

Answer 16

सी, 31 बाइट्स

f(x){return(x-160>>20-x/16)+2;}

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

27 बाइट्स के साथ जीसीसी (-ओ 0)

f(x){x=(x-160>>20-x/16)+2;}

विकल्प, 31 और 33 बाइट्स

f(x){return(10>>15-x/16)+7>>2;}
f(x){return x/128-(-3>>15-x/16);}

अहा के साथ खेलने के दौरान मुझे ये भाव मिले! कुछ साल पहले superoptimizer ।