ইউনিকোড ইউটিএফ রূপান্তরকারী

17

ইউটিএফ এফএকিউতে প্রদত্ত অফিসিয়াল ইউনিকোড এনকোডিংগুলির মধ্যে সম্পূর্ণরূপে অনুবর্তী কনভার্টার তৈরির লক্ষ্য । এটি ইউনিকোডকে কেন্দ্র করেই দেওয়া হয়েছে, জড়িত এনকোডিংগুলির সর্বাধিক সম্ভব (যা সম্ভবত ইউটিএফ -8 হবে, যদি না আপনি এপিএলে প্রোগ্রাম না করেন) ব্যবহার করে আমি সর্বনিম্ন বাইট গণনা সহ উত্তরটি গ্রহণ করব। আমি দীর্ঘ পোস্টের জন্য ক্ষমাপ্রার্থী, তবে এটির অনেকগুলি এনকোডিংগুলি ব্যাখ্যা করছে যা অফিসিয়াল স্পেসিফিকেশন (পিডিএফ, বিভাগ 3.9 ডি 90 - ডি 92) , বা উইকিপিডিয়াতেও অ্যাক্সেস করতে পারে ।

বিশেষ উল্লেখ

যে কোনও সময়ে যদি আপনার পছন্দের ভাষাটি সঠিকভাবে কোনও চাহিদা পূরণ করতে না পারে তবে এটিকে এমন কিছু দিয়ে প্রতিস্থাপন করুন যা প্রদত্ত বিধিগুলির চেতনাকে আটকে দেয়। যেমন। প্রতিটি ভাষার অন্তর্নির্মিত অ্যারে, ফাংশন ইত্যাদি নেই not

  • স্ট্রিং লাইব্রেরি / ফাংশন, বা এনকোডিং লাইব্রেরি / ফাংশন ব্যবহার করছে না। এই কোড গল্ফের বিন্দুটি হ'ল বিট / বাইট ম্যানিপুলেশন ব্যবহার করে কনভার্টারটি প্রয়োগ করা। একটি অক্ষর বা বাইট অ্যারে হিসাবে তাদের ক্ষমতা তাদের নিজের স্ট্রিং ব্যবহার অনুমোদিত যদিও। ওহ, এবং কোনও ওএস কল নেই যা রূপান্তরটি সম্পাদন করে।

  • রূপান্তরকারী একটি ফাংশন যা তিনটি পরামিতি নেবে: এনকোডড ইনপুট স্ট্রিংকে উপস্থাপন করে একটি বাইট অ্যারে এবং সংখ্যার হিসাবে উপস্থাপিত "ইনপুট" এবং "আউটপুট" এনকোডিংগুলি। নির্বিচারে আমরা UTF-8, UTF-16, UTF-16BE, UTF-16LE, UTF-32, UTF-32BE, and UTF32LEসেই ক্রমে 0 থেকে 6 নম্বর নির্ধারণ করব । সংখ্যা হলে চেক করতে কোন প্রয়োজন নেই < 0বা > 6, আমরা এই পরামিতি সঠিক অনুমান হবে। রূপান্তরকারী পছন্দসই আউটপুট এনকোডিংয়ে একটি বৈধ বাইট অ্যারে প্রদান করবে।

  • আমরা U+0000স্ট্রিং টার্মিনেটর হিসাবে নাল অক্ষর ( ) ব্যবহার করব । এর পরে যে কোনও কিছুতেই কিছু আসে যায় না। আমরা ধরে নেব যে ইনপুট অ্যারেতে কোথাও নাল অক্ষর রয়েছে তাই আপনার বাউন্ডস চেক করার প্রয়োজন নেই।

  • অনুযায়ী প্রায়শই জিজ্ঞাসিত প্রশ্নাবলী , যদি ইনপুট বাইট অ্যারের তার ঘোষিত এনকোডিং-এর অবৈধ, আমরা একটি ত্রুটি সংকেত নয়। আমরা নিম্নলিখিত পদ্ধতির একটিতে এটি করব: প্রোগ্রামটি ক্র্যাশ করুন, একটি ব্যতিক্রম নিক্ষেপ করুন, নালটি ফিরুন বা এমন অ্যারে ফিরবেন যার প্রথম চারটি বাইট সমস্ত 0 (যাতে এটি U+0000প্রতিটি এনকোডিং হিসাবে স্বীকৃত হতে পারে )।

এনকোডিংস

অফিসিয়াল স্পেসিফিকেশন অবশ্যই অনুসরণ করা উচিত, তবে উইকিপিডিয়া এনকোডিংগুলির একটি ভাল (এবং যতদূর আমি সঠিক বিশ্বাস করি) সরবরাহ করে, এবং আমি এখানে তাদের সম্পূর্ণতার জন্য সংক্ষিপ্ত করব। নোট করুন যে ইউটিএফ -16 এবং ইউটিএফ -32 এর এন্ডিয়েনেসের জন্য বৈকল্পিক রয়েছে ।

UTF-32, UTF-32LE, UTF-32BE

সহজতম এনকোডিং, প্রতিটি কোড পয়েন্টটি কেবল তার সংখ্যাসূচক মানের সমান 4 বাইটে এনকোড করা হয়। এলই / বিই এন্ডিনিয়েন্সকে দেখায় (ছোট এন্ডিয়ান / বিগ এন্ডিয়ান))

UTF-16, UTF-16LE, UTF-16BE

এর কোড পয়েন্টগুলি U+0000 - U+FFFFএর সাংখ্যিক মানের সমান 2 বাইটে এনকোড করা আছে। বৃহত্তর মানগুলি এক জোড়া সারোগেট ব্যবহার করে এনকোড করা হয় যা থেকে সংরক্ষিত মানগুলি U+D800 - U+DFFF। এর চেয়ে বড় পয়েন্টগুলি এনকোড করতে U+FFFF, নিম্নলিখিত অ্যালগরিদম ব্যবহার করা যেতে পারে (নির্লজ্জভাবে উইকিপিডিয়া থেকে অনুলিপি করা ):

  • 0x010000 কোড পয়েন্ট থেকে বিয়োগ করা হয়, 0..0x0FFFF ব্যাপ্তিতে 20 বিট নম্বর রেখে।
  • প্রথম কোড ইউনিট বা সীসা সারোগেট দেওয়ার জন্য শীর্ষ দশ বিট (0..0x03FF পরিসরের একটি সংখ্যা) 0xD800 এ যুক্ত করা হয় যা 0xD800..0xDBFF এর পরিসীমাতে হবে [...]।
  • দ্বিতীয় কোড ইউনিট বা ট্রেইল সারোগেট দেওয়ার জন্য নিম্ন দশ বিট (০.০x03FF পরিসীমাতেও) 0xDC00 এ যুক্ত করা হয়, যা 0xDC00..0xDFFF পরিসরে হবে [...]।

হল UTF-8

থেকে কোড পয়েন্টগুলি U+0000 - U+007Fএর সংখ্যাগত মানের সমান 1 বাইট হিসাবে এনকোড করা আছে। থেকে U+0080 - U+07FFতারা এনকোডেড থাকে 110xxxxx 10xxxxxx, U+0800 - U+FFFFহয় 1110xxxx 10xxxxxx 10xxxxxx, উচ্চ মান 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx। xএর কোড বিন্দু সাংখ্যিক মান থেকে বিট।

BOM

বাইট-অর্ডার চিহ্ন (বিওএম, U+FEFF) সর্বশেষতা নির্দেশ করতে প্রথম কোড পয়েন্ট হিসাবে ব্যবহৃত হয়। বিওএম সম্পর্কিত প্রশ্নোত্তর নির্দেশিকা অনুসরণ করে , বিওএমটি নিম্নলিখিতভাবে ব্যবহৃত হবে: এটি itচ্ছিকUTF-8, UTF-16 and UTF-32 । যদি বিওএম অনুপস্থিত থাকে UTF-16বা UTF-32, এটি বড় এন্ডিয়ান বলে ধরে নেওয়া হয়। বিওএম অবশ্যই উপস্থিত হবে নাUTF-16LE, UTF-16BE, UTF-32LE and UTF-32BE ।

সাধারণ সমস্যাগুলি অবৈধ ইউটিএফ-এর কারণ

বিভিন্ন জিনিস বাইট সিকোয়েন্সটি অবৈধ ইউটিএফ হতে পারে।

  • ইউটিএফ -8 এবং ইউটিএফ -32: সরাসরি সরোগেট কোড পয়েন্ট ( U+D800 - U+DFFF), বা এর চেয়ে বেশি কোড পয়েন্ট এনকোডিং U+10FFFF।
  • ইউটিএফ -8: অনেকগুলি অবৈধ বাইট সিকোয়েন্স।
  • ইউটিএফ -16: অযৌক্তিক, বা অনুপযুক্ত জোড়যুক্ত সারোগেটগুলি।
  • বিওএম: এনকোডিং বিভাগে নির্দিষ্ট হিসাবে অবশ্যই ব্যবহার করা উচিত। নোট করুন যে আউটপুট আউট করার সময় UTF-16বা UTF-32(কোনও অন্তর্নিহিত অন্তর্নিহিততা নির্দিষ্ট করা হয়নি) আপনি বেছে নিতে পারেন, তবে অল্প ইন্ডিয়ান দিয়ে আপনাকে অবশ্যই বিওএম অন্তর্ভুক্ত করতে হবে ।

নোট করুন যে অ-অক্ষরগুলি এবং অ-নিযুক্ত কোড পয়েন্টগুলি (উভয় পৃথক পৃথক থেকে পৃথক) নিয়মিত অক্ষরের মতো আচরণ করা উচিত।

code-golf  unicode 
— DPenner1
সূত্র
"স্ট্রিং লাইব্রেরি / ফাংশন, বা এনকোডিং লাইব্রেরি / ফাংশন ব্যবহার করছেন না।" বাস্তব বিল্ট-ইনগুলি সম্পর্কে কী। এপিএলে ''⎕R''⍠'InEnc' 'UTF16BE' 'OutEnc' 'UTF8-BOM',।
— আদম
2
@ এনবিজেড তাদের যেহেতু অনুমতি দেওয়া হবে না যেহেতু এই চ্যালেঞ্জের মূল বিষয়টি তাদের দেওয়া আচরণটি বাস্তবায়ন করা।
— ডিপেনার 1
উত্তরদাতাদের জন্য নোট: আমি এই প্রশ্নটি কমবেশি ছেড়ে দিয়েছি, তবে সাম্প্রতিক পুনর্নবীকরণের আগ্রহের কারণে আগামী দিনে আমি উত্তরগুলি পেতে কিছুটা সময় নেব।
— ডিপেনার 1

উত্তর:

3

সি ++, (ইউটিএফ -8) 971 বাইট

#include<cstdint>
using u=uint8_t;using U=uint32_t;U i,o,x,b,m;U R(u*&p){x=*p++;if(!i){m=0;while(128>>m&x)++m;if(m>1)for(x&=127>>m;--m;)x=x<<6|((*p&192)-128?~0:*p++&63);return m?x=~0:x;}else if(i<3){x<<=8;x+=*p++;}else if(i<4){x+=*p++<<8;}else if(i<6){x<<=24;x+=*p++<<16;x+=*p++<<8;x+=*p++;}else{x+=*p++<<8;x+=*p++<<16;x+=*p++<<24;}return x;}U r(u*&p){U x0=R(p);if(i&&i<4&&x>>10==54)x=R(p)>>10==55?(x0<<10)+x-56613888:~0;if(!b++){if(x==65279)if(!i||i%3==1)r(p);else x=~0;else if(x==65534&&i==1)i=3,r(p);else if(x==4294836224&&i==4)i=6,r(p);}return x>1114111||x>>11==27?x=~0:x;}void w(U x,u*&p){if(!o){if(x<128)*p++=x;else{for(m=0;~63<<m&x;m+=6);for(*p++=~127>>m/6|x>>m;m;)*p++=128|x>>(m-=6)&63;}}else if(o<4&&x>65535)x-=65536,w(55296|x>>10,p),w(56320|x&1023,p);else if(o<3)*p++=x>>8,*p++=x;else if(o<4)*p++=x,*p++=x>>8;else if(o<6)*p++=x>>24,*p++=x>>16,*p++=x>>8,*p++=x;else*p++=x,*p++=x>>8,*p++=x>>16,*p++=x>>24;}int t(u*&p,u*&q){for(b=0,x=1;U(x+x);)w(r(p),q);return x;}

নীচের পঠনযোগ্য প্রোগ্রামটি নিম্নলিখিত পার্ল কমান্ডের মাধ্যমে ফিল্টার করে উপরের ফর্মটিতে ঘনীভূত করা যেতে পারে:

perl -p0 -e 's!//.*!!g;s/\s+/ /g;s/ \B|\B //g;s/0x[\da-f]+/hex($&)/ige;s/#include<[^<>]+>/\n$&\n/g;s/^\n+//mg'

উপরের আদেশ

  • মন্তব্য মুছে ফেলা
  • অপ্রয়োজনীয় সাদা স্থান সরিয়ে দেয়
  • হেক্সাডেসিমাল আক্ষরিককে দশমিক রূপান্তর করে
  • #includeলাইনের চারপাশে নিউলাইনগুলি পুনরুদ্ধার করে

পঠনযোগ্য কোড

#include <cstdint>
using u = uint8_t;
using U = uint32_t;

U   i,                          // input encoding
    o,                          // output encoding
    x,                          // last read value
    b,                          // char count(BOM only valid when b==0)
    m;                          // temporary variable for measuring UTF-8

//   Encodings:
// 0 UTF-8
// 1 UTF-16
// 2 UTF-16BE
// 3 UTF-16LE
// 4 UTF-32
// 5 UTF-32BE
// 6 UTF-32LE

// Read a character or UTF-16 surrogate
U R(u*& p) {
    x = *p++;
    if (!i) { // UTF-8
        m=0; while (128>>m&x) ++m; // how many bytes?
        if (m>1) for (x&=127>>m; --m; ) x = x<<6 | ((*p&192)-128?~0:*p++&63);
        return m ? x=~0 : x;
    } else if (i<3) { // UTF-16, UTF-16BE
        x<<=8; x+=*p++;
    } else if (i<4) { // UTF-16LE
        x+=*p++<<8;
    } else if (i<6) { // UTF-32, UTF-32BE
        x<<=24; x+=*p++<<16; x+=*p++<<8; x+=*p++;
    } else { // UTF-32LE
        x+=*p++<<8; x+=*p++<<16; x+=*p++<<24;
    }
    return x;
}

// Read a character, combining surrogates, processing BOM, and checking range
U r(u*& p) {
    U x0 = R(p);
    if (i && i<4 && x>>10==54)
        x = R(p)>>10==55 ? (x0<<10)+x-56613888: ~0; // 56613888 == 0xd800<<10 + 0xdc00 - 0x10000
    if (!b++) {                 // first char - is it BOM?
        if (x==0xFEFF)
            if (!i || i%3==1)
                r(p); // BOM in UTF-8 or UTF-16 or UTF-32 - ignore, and read next char
            else
                x = ~0; // not allowed in these modes
        else if (x==0xFFFE && i==1)
            i=3,r(p); // reversed BOM in UTF-16 - change to little-endian, and read next char
        else if (x==0xFFFE0000 && i==4)
            i=6,r(p); // reversed BOM in UTF-32 - change to little-endian, and read next char
    }
    return x>0x10ffff || x>>11==27 ? x=~0 : x;
}


// Write character(assumed in-range)
void w(U x, u*& p) {
    if (!o) { // UTF-8
        if (x<128) *p++=x;        // ASCII
        else {
            for (m=0; ~63<<m&x; m+=6); // how many bits?
            for (*p++=~127>>m/6|x>>m; m; ) *p++ = 128|x>>(m-=6)&63;
        }
    } else if (o<4 && x>65535)  // UTF-16 surrogate
        x-=65536, w(0xD800|x>>10,p), w(0xDC00|x&0x3FF,p);
    else if (o<3)  // UTF-16, UTF-16BE
        *p++=x>>8, *p++=x;
    else if (o<4)  // UTF-16LE
        *p++=x, *p++=x>>8;
    else if (o<6)  // UTF-32, UTF-32BE
        *p++=x>>24, *p++=x>>16, *p++=x>>8, *p++=x;
    else  // UTF-32LE
        *p++=x, *p++=x>>8, *p++=x>>16, *p++=x>>24;
}

// Transcode
int t(u*& p, u*& q)                  // input, output
{
    for (b=0,x=1;U(x+x);)    // exit condition is true only for x==-x, i.e. 0 and ~0
        w(r(p),q);
    return x;
}

ডাকা ফাংশনটি হ'ল t(), বৈশ্বিক ভেরিয়েবলগুলিতে iএবং oযথাক্রমে ইনপুট এবং আউটপুট এনকোডিংগুলি সহ এবং pইনপুটটির বাইটগুলিতে ইঙ্গিত করে, যা অবশ্যই নਾਲ-টার্মিনেট হওয়া উচিত । qআউটপুট বাফারকে নির্দেশ করে, যা ওভাররাইট করা হবে এবং ফলাফলের জন্য এটি অবশ্যই যথেষ্ট বড় হতে হবে - বাফারকে ছাড়িয়ে যাওয়ার কোনও চেষ্টা নেই।

আমি আশা করি কোড মন্তব্যগুলি যথেষ্ট ব্যাখ্যামূলক - নীচে জিজ্ঞাসা করুন যেগুলির মধ্যে একটি খুব ক্রিপ্টিক (তবে প্রথমে চেষ্টা করুন!)।

এই উত্তরটি বিকাশকালে আমি একটি যথেষ্ট পরীক্ষার স্যুট সংকলন করেছি; অন্যান্য প্রবেশকারীদের সুবিধার জন্য এবং নীচে আমার প্রয়োজনীয়তার ব্যাখ্যাটি নথিভুক্ত করার জন্য আমি এটি নীচে অন্তর্ভুক্ত করছি:

টেস্ট ফাংশন

#include <vector>
#include <iostream>

std::ostream& operator<<(std::ostream& out, const std::vector<u>& v)
{
    out << "{ ";
    for (int i: v) out << i << " ";
    out << "}";
    return out;
}

int test_read(int encoding, std::vector<u> input, U expected)
{
    b = 0;
    i = encoding;
    auto d = input.data();
    U actual = r(d);
    if (actual == expected) return 0;
    std::cerr << std::hex << "Decoding " << encoding << "; " << input << " gave " << actual
              << " instead of " << expected << std::endl;
    return 1;
}

int test_write(int encoding, U input, std::vector<u> expected)
{
    o = encoding;
    u buf[20], *p = buf;
    w(input, p);
    std::vector<u> actual(buf,p);
    if (expected == actual) return 0;
    std::cerr << std::hex << "Encoding " << encoding << "; " << input << " gave " << actual
              << " instead of " << expected << std::endl;
    return 1;
}

int test_transcode(int ienc, std::vector<u> input, int oenc, std::vector<u> expected)
{
    b = 0;
    i = ienc; o = oenc;
    u buf[200], *p = buf, *d = input.data();
    int result = t(d, p);
    std::vector<u> actual(buf,p);
    if (result ? expected.empty() : expected == actual) return 0;
    std::cerr << std::hex << "Encoding " << ienc << " to " << oenc << "; " << input << " gave " << actual
              << " instead of " << expected << std::endl;
    return 1;
}

পরীক্ষা স্যুট

static const U FAIL = ~0;
int main() {
    int e = 0;                        // error count
    // UTF-8
    e += test_read(0, { 128 }, FAIL); // unexpected continuation
    e += test_read(0, { 128, 1 }, FAIL);
    e += test_read(0, { 128, 128 }, FAIL);
    e += test_read(0, { 192, 192 }, FAIL); // start without continuation
    e += test_read(0, { 192, 0 }, FAIL);
    e += test_read(0, { 224, 0 }, FAIL);
    e += test_read(0, { 224, 192 }, FAIL);
    e += test_read(0, { 0xf4, 0x90, 128, 128 }, FAIL); // Unicode maximum+1

    e += test_read(0, { 127 }, 127);
    e += test_read(0, { 192, 129 }, 1); // We accept overlong UTF-8
    e += test_read(0, { 0xc2, 128 }, 128);
    e += test_read(0, { 224, 128, 129 }, 1);
    e += test_read(0, { 0xef, 128, 128 }, 0xF000);
    e += test_read(0, { 0xef, 191, 191 }, 0xFFFF);
    e += test_read(0, { 0xf4, 128, 128, 128 }, 0x100000);
    e += test_read(0, { 0xf4, 0x8f, 191, 191 }, 0x10FFFF); // Unicode maximum

    e += test_read(0, { 0xEF, 0xBB, 0xBF, 127 }, 127); // byte-order mark

    e += test_write(0, 0, { 0 });
    e += test_write(0, 127, { 127 });
    e += test_write(0, 128, { 0xc2, 128 });
    e += test_write(0, 255, { 0xc3, 191 });
    e += test_write(0, 0xFFFF, { 0xef, 191, 191 });
    e += test_write(0, 0x10FFFF, { 0xf4, 0x8f, 191, 191 });

    // UTF-16
    e += test_read(1, { 0, 1 }, 1);
    e += test_read(1, { 0xd8, 0, 0xdc, 1 }, 0x10001);
    e += test_read(1, { 0xdb, 0xff, 0xdf, 0xff }, 0x10ffff);

    e += test_read(1, { 0xd8, 0, 0xd8, 1 }, FAIL); // mismatched surrogate
    e += test_read(1, { 0xd8, 0, 0, 1 }, FAIL); // mismatched surrogate
    e += test_read(1, { 0xdc, 0 }, FAIL);

    e += test_write(1, 1, { 0, 1 });
    e += test_write(1, 256, { 1, 0 });
    e += test_write(1, 0xffff, { 255, 255 });
    e += test_write(1, 0x10001, { 0xd8, 0, 0xdc, 1 });
    e += test_write(1, 0x10ffff, { 0xdb, 0xff, 0xdf, 0xff });

    // UTF-16LE
    e += test_write(3, 1, { 1, 0 });
    e += test_write(3, 256, { 0, 1 });
    e += test_write(3, 0x10001, { 0, 0xd8, 1, 0xdc });
    e += test_write(3, 0x10fffe, { 0xff, 0xdb, 0xfe, 0xdf });

    // UTF-16 byte-order mark
    e += test_read(1, { 0xFE, 0xFF, 0x0, 1 }, 1); // byte-order mark
    e += test_read(1, { 0xFF, 0xFE, 1, 0x0 }, 1); // reversed byte-order mark
    // disallowed byte-order marks
    e += test_read(2, { 0xFE, 0xFF }, FAIL);
    e += test_read(3, { 0xFF, 0xFE }, FAIL);
    // reversed byte-order mark is an unassigned character - to be treated like regular character, according to question
    e += test_read(2, { 0xFF, 0xFE }, 0xfffe);
    e += test_read(3, { 0xFE, 0xFF }, 0xfffe);

    // UTF-32
    e += test_read(4, { 0, 0, 0, 1 }, 1);
    e += test_read(4, { 1, 0, 0, 0 }, FAIL);
    e += test_write(4, 1, { 0, 0, 0, 1 });
    e += test_write(4, 0x10203, { 0, 1, 2, 3 });

    // UTF-32LE
    e += test_read(6, { 0, 0, 0, 1 }, FAIL);
    e += test_read(6, { 1, 0, 0, 0 }, 1);

    // UTF-32 byte-order mark
    e += test_read(4, { 0, 0, 0xFE, 0xFF,  0, 0, 0, 1 }, 1); // byte-order mark
    e += test_read(4, { 0xFF, 0xFE, 0, 0,  1, 0, 0, 0 }, 1); // reversed byte-order mark
    // disallowed byte-order marks
    e += test_read(5, { 0, 0, 0xFE, 0xFF }, FAIL);
    e += test_read(5, { 0xFF, 0xFE, 0, 0 }, FAIL);
    e += test_read(6, { 0, 0, 0xFE, 0xFF }, FAIL);
    e += test_read(6, { 0xFF, 0xFE, 0, 0 }, FAIL);

    e += test_transcode(1, { 1, 2, 0xFE, 0xFF, 0, 0 }, // That's not a BOM; it's a zwnj when not the first char
                        1, { 1, 2, 0xFE, 0xFF, 0, 0 });
    e += test_transcode(1, { 0xFF, 0xFE, 1, 2, 0, 0 }, // reversed byte-order mark implies little-endian
                        1, { 2, 1, 0, 0 });
    e += test_transcode(4, { 0xFF, 0xFE, 0, 0, 1, 2, 0, 0, 0, 0 }, // reversed BOM means little-endian
                        4, { 0, 0, 2, 1, 0, 0, 0, 0 });
    e += test_transcode(1, { 0xdb, 0xff, 0xdf, 0xff, 0, 0 }, // U+10ffff UTF-16 to UTF-8
                        0, { 0xf4, 0x8f, 191, 191, 0 });

    return e;
}
— টবির গতি
সূত্র
ডাং .. সি ++ পাইথনকে পরাজিত করেছে।
— টিকটক
5

পাইথন - 1367 ইউটিএফ -8 অক্ষর

ঠিক আছে! এটি একটি অত্যন্ত কঠিন প্রশ্ন কারণ এটি সমস্ত স্পেসিফিকেশন বুঝতে এবং প্রয়োগ করতে নিখুঁতভাবে কাজ করেছিল, তবে আমি মনে করি যে আমার সঠিক বাস্তবায়ন হয়েছে।

O,P,Q,R=65536,128,b'\xff\xfe\x00\x00',63
def A(x,y):assert x;return y
def B(x):
    o,c=[],0
    for b in x:
        if c:c,v=c-1,A(127<b<192,v<<6)|(b-P)
        else:
            c,v=(b>127)+(b>223)+(b>239),b
            if b>127:v=A(191<b<248,b&(R>>c))
        o+=[v][c:]
    return o[o[0]in(65279,O-2):]
def C(k):
    def o(x,s=None):
        for a,b in zip(x[k::2],x[1-k::2]):
            d=a|(b<<8)
            if s!=None:yield(A(56319<d<57344,d-56320)|(s<<10))+O;s=None
            elif 55295<d<57344:s=A(s<1024,d-55296)
            else:yield d
    return o
def D(x):n=(2,3,1)[[Q[:2],Q[1::-1],x[:2]].index(x[:2])];return C(n&1)(x[n&2:])
E=lambda a,b,c,d:lambda x:[L|(l<<8)|(m<<16) for L,l,m in zip(x[a::4],x[b::4],x[c::4])]
def F(x):n,m=((1,4),(-1,4),(-1,0))[[Q,Q[::-1],x[:4]].index(x[:4])];return E(*range(4)[::n])(x[m:])
S=lambda x,s=0,a=255:(x>>s)&a
G=lambda e:(e,)if e<P else(192|S(e,6),P|(e&R))if e<2048 else(224|S(e,12),P|S(e,6,R),P|(e&R))if e<O else(240|S(e,18),P|S(e,12,R),P|S(e,6,R),P|(e&R))
H=lambda e:(S(e,8),S(e))if e<O else(216|S(e-O,18),S(e-O,10),220+S((e-O)&1023,8),S(e-O))
I=lambda e:(S(e),S(e,8))if e<O else(S(e-O,10),216|S(e-O,18),S(e-O),220+S((e-O)&1023,8))
J=lambda e:(S(e,24),S(e,16),S(e,8),S(e))
K=lambda e:(S(e),S(e,8),S(e,16),S(e,24))
convert=lambda d,i,o:bytes(sum(map(L[o],N(list(M[i](d)))),()))if d else d
L,M=[G,H,H,I,J,J,K],[B,D,C(1),C(0),F,E(3,2,1,0),E(0,1,2,3)]
N=lambda d:[A(-1<x<1114112 and x&~2047!=55296,x)for x in d]

convertফাংশনটি ডেটা 'বাইটস' অবজেক্ট, ইনপুট আইডি এবং আউটপুট আইডি গ্রহণ করে takes এটি কাজ করে বলে মনে হচ্ছে - যদিও অজগরটিকে এনকোডিংয়ে অনির্দিষ্ট করা অবস্থায় বিওএমগুলির কিছুটা ভাঙ্গা ব্যবহার বলে মনে হচ্ছে, সুতরাং পাইথনের বিল্টিন এনকোডিংটি 1 এবং 4 মোড পরীক্ষার জন্য কাজ করবে না।

মজাদার ঘটনা: আকারটি 555 16 বা 10101010101 2 ।

ডিকোডিংয়ের জন্য 773 টি অক্ষর, এনকোডিংয়ের জন্য 452, যাচাইকরণের জন্য 59 এবং বিবিধ অংশের জন্য 83।

— সেল স্কেগস
সূত্র
@ ট্র্যাংআউল: সাধারণত, তুচ্ছ সম্পাদনাগুলি (ভাষার ট্যাগিংয়ের মতো) উপর ভিত্তি করে তৈরি হয়।
— জ্যাচ গেটস
4
— বিড়াল
এই প্রশ্ন / উত্তর কোনও সম্প্রদায়ের sensকমত্য দেখায় না। পুরো নেটওয়ার্ক জুড়ে, এর মতো তুচ্ছ সম্পাদনাগুলি ভ্রূণুভূত হয়। <1000 বা> 1000 প্রতিনিধি ব্যবহারকারীদের এই সম্পাদনাগুলি করা উচিত নয় যতক্ষণ না তারা স্পষ্টভাবে সামগ্রী বা ফর্ম্যাটটি উন্নত করে। ভাষার ট্যাগ, একক শব্দ সংশোধন / পরিবর্তন ইত্যাদির মতো জিনিসগুলি সম্পাদনা করা ভাল @ @ ক্যাট
— জ্যাচ গেটস
আমি মনে করি আকার আর 0x555 :-( নয় is তবে আপনি ইনডেন্টদের জন্য একটি জায়গা ব্যবহারের স্ট্যান্ডার্ড পাইথন-গল্ফ টিপ ব্যবহার করে আরও কাছাকাছি আসতে পারেন
— টবি স্পাইট
@ টবিস্পাইট এটি এখন 0x557, আপনি ঠিক বলেছেন। এবং প্রকৃতপক্ষে, আমি ট্যাব ব্যবহার করেছি, যা পোস্ট করার জন্য স্পেসে রূপান্তরিত করতে হয়েছিল, তবে এখনও একটি চরিত্র হিসাবে গণ্য। আমি যখন দেখব আমি সুযোগ পেলে অন্য কয়েকটি চরিত্রকে অন্য কোনওভাবে শেভ করতে পারি কিনা।
— সেল স্কেগস
4

পাইথন 3, 1138 বাইট (UTF-8)

সুতরাং দেখা যাচ্ছে যে 14 ঘন্টা আন্তর্জাতিক ভ্রমণ একটি গল্ফ চ্যালেঞ্জ সমাপ্ত করার জন্য একটি দুর্দান্ত সুযোগ ...

রূপান্তর ফাংশন হয় C()। এই কল u(), v()এবং w()করা ডিকোড, এবং U(), V()এবং W()সঙ্কেতাক্ষরে লিখা, হল UTF-8, -16 ও -32 যথাক্রমে। কোনও এনকোডার কোনও বিওএম আউটপুট দেয় না, তবে ডিকোডারগুলির মধ্যে একটিই সঠিকভাবে পরিচালনা করবে। ত্রুটি শর্তগুলির ফলে একটি ব্যতিক্রম ঘটে (সাধারণত একটি ZeroDivisionError, "ডাই-হঠাৎ" ফাংশনের সৌজন্যে E())।

from struct import*
l=len
j=''.join
b=lambda c:[*bin(c)[2:]]
P,Q,i,o,z,Z='HI10><'
B=65279
O,F,H,L,X=1024,65536,55296,56320,57344
E=lambda:1/0
R=lambda y,e,c,n:unpack(([[z,Z][y[:n]==pack(Z+c,B)],e][l(e)])+c*(l(y)//n),y)
S=lambda d,e:B!=d[0]and d or e and E()or d[1:]
def u(y,d=(),p=0):
 while p<l(y):
  q=b(y[p])
  if l(q)>7:
   x=q.index(o);C=1<x<5and q[x+1:]or E();X=x+p;X>l(y)>E();p+=1
   while p<X:q=b(y[p]);C=l(q)>7and(i,o==q[:2])and(*C,*q[2:])or E();p+=1
   d=*d,int(j(C),2)
  else:d=*d,y[p];p+=1
 return S(d,0)
def T(p):
 q=b(p);C=()
 while l(q)not in(7,11,16,21):q=o,*q
 while l(q)>6:C=int(i+o+j(q[-6:]),2),*C;q=q[:-6]
 return bytes(p<128and[p]or[int(i*(7-l(q))+o+j(q),2),*C])
U=lambda c:b''.join(map(T,c))
def v(y,e=''):
 c=R(y,e,P,2);d=[];n=0
 while n<l(c)-1:h,a=c[n:n+2];D=[(h,a),(F+(h-H)*O+a-L,)][H<=h<L<=a<X];M=3-l(D);n+=M;d+=D[:M]
 if n<l(c):d=*d,c[n]
 return S(d,e)
V=lambda c,e=z:W(sum(map(lambda p:([H+(p-F)//O,L+(p-F)%O],[p])[p<F],c),[]),e,P)
w=lambda y,e='':S(R(y,e,Q,4),e)
W=lambda c,e=z,C=Q:pack(e+C*l(c),*c)
K=(u,U),(v,V),(v,V,z),(v,V,Z),(w,W),(w,W,z),(w,W,Z)
def C(y,f,t):f,_,*a=K[f];_,t,*b=K[t];return t(f(y,*a),*b)
— টিম পেডারিক
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.