आप 8-बिट बाइट्स को 6-बिट वर्णों में कैसे परिवर्तित करते हैं?

Question

मेरे पास बाइट्स की एक धारा को एक वर्ण एन्कोडिंग में परिवर्तित करने की एक विशिष्ट आवश्यकता है जो प्रति चरित्र 6-बिट्स होती है।

Here's an example: 

Input: 0x50 0x11 0xa0 

Character Table: 

010100 T 
000001 A 
000110 F 
100000 SPACE 


Output: "TAF " 

Logically I can understand how this works: 

Taking 0x50 0x11 0xa0 and showing as binary: 

01010000 00010001 10100000 

Which is "TAF ". 

इस प्रोग्रामेटिक रूप से (छद्म कोड या सी ++) करने का सबसे अच्छा तरीका क्या है। धन्यवाद!

Answer 1

ठीक है, हर 3 बाइट्स, आप चार अक्षरों के साथ समाप्त होते हैं। तो एक बात के लिए, यदि इनपुट तीन बाइट्स के एकाधिक नहीं है तो आपको क्या करना है, यह जानने की ज़रूरत है। (क्या इसमें बेस 64 की तरह कुछ प्रकार की पैडिंग है?)

तो मैं शायद बदले में प्रत्येक 3 बाइट्स ले जाऊंगा। सी #, जो शायद ज़रुरत पड़े लिए C :)

for (int i = 0; i < array.Length; i += 3) 
{ 
    // Top 6 bits of byte i 
    int value1 = array[i] >> 2; 
    // Bottom 2 bits of byte i, top 4 bits of byte i+1 
    int value2 = ((array[i] & 0x3) << 4) | (array[i + 1] >> 4); 
    // Bottom 4 bits of byte i+1, top 2 bits of byte i+2 
    int value3 = ((array[i + 1] & 0xf) << 2) | (array[i + 2] >> 6); 
    // Bottom 6 bits of byte i+2 
    int value4 = array[i + 2] & 0x3f; 

    // Now use value1...value4, e.g. putting them into a char array. 
    // You'll need to decode from the 6-bit number (0-63) to the character. 
} 

Answer 2

काफी पास छद्म कोड है अगर किसी को दिलचस्पी है में - एक और संस्करण है कि जैसे ही वे वहाँ दिखाई देते हैं के रूप में धारा से 6-बिट नंबर निकालता है। यही है, परिणाम तब भी प्राप्त किए जा सकते हैं जब कम से कम 3 बाइट वर्तमान में पढ़े जाते हैं। Unpadded धाराओं के लिए उपयोगी होगा।

कोड a पर n में संचयक की स्थिति बचाता है जो पिछले पढ़ने से संचयक में छोड़े गए बिट्स की संख्या को संग्रहीत करता है।

int n = 0; 
unsigned char a = 0; 
unsigned char b = 0; 
while (read_byte(&byte)) { 
    // save (6-n) most significant bits of input byte to proper position 
    // in accumulator 
    a |= (b >> (n + 2)) & (077 >> n); 
    store_6bit(a); 
    a = 0; 
    // save remaining least significant bits of input byte to proper 
    // position in accumulator 
    a |= (b << (4 - n)) & ((077 << (4 - n)) & 077); 
    if (n == 4) { 
     store_6bit(a); 
     a = 0; 
    } 
    n = (n + 2) % 6; 
}