एक ऐसा फ़ंक्शन कैसे बनाया जाए जो किसी संख्या को बायक्टेक्टीव हेक्साविजिज़िमल में परिवर्तित करता है?

Question

शायद मैं गणित में इतना अच्छा नहीं हूं, लेकिन मुझे एक संख्या को शुद्ध वर्णमाला Bijective Hexavigesimal में बदलने में समस्या आ रही है जैसे माइक्रोसॉफ्ट एक्सेल/ओपनऑफिस कैल्क इसे कैसे करता है।

यहाँ मेरी कोड का एक संस्करण है, लेकिन मुझे उत्पादन मैं जरूरत नहीं दिया:

 

    var toHexvg = function(a){ 
    var x=''; 
    var let="_abcdefghijklmnopqrstuvwxyz"; 
    var len=let.length; 
    var b=a; 
    var cnt=0; 
    var y = Array(); 
    do{ 
     a=(a-(a%len))/len; 
     cnt++; 
    }while(a!=0) 
    a=b; 
    var vnt=0; 
    do{ 
     b+=Math.pow((len),vnt)*Math.floor(a/Math.pow((len),vnt+1)); 
     vnt++; 
    }while(vnt!=cnt) 
    var c=b; 
    do{ 
     y.unshift(c%len); 
     c=(c-(c%len))/len; 
    }while(c!=0) 
    for(var i in y)x+=let[y[i]]; 
    return x; 
    } 

मेरे प्रयासों प्राप्त कर सकते हैं का सबसे अच्छा उत्पादन होता है: a b c d ... y z ba bb bc - हालांकि नहीं वास्तविक कोड ऊपर। अनुमानित आउटपुट a b c ... y z aa ab ac ... zz aaa aab aac ... zzzzz aaaaaa aaaaab होने का अनुमान है, आपको तस्वीर मिलती है।

असल में, मेरी समस्या फ़ंक्शन के बजाय 'गणित' करने पर अधिक है। आखिरकार मेरा सवाल यह है कि: माइक्रोसॉफ्ट एक्सेल की तरह, [माना जाता है] अनंत तक, हेक्साविजिसेमल रूपांतरण में गणित कैसे करें।

और यदि संभव हो, तो एक स्रोत कोड, अग्रिम धन्यवाद।

Answer 1

ठीक है, मेरे प्रयास है, यह मानते हुए आप अनुक्रम "एक" के साथ शुरू करना चाहते हैं (0 पेश करता है) और जा रहा:

a, b, c, ..., y, z, aa, ab, ac, ..., zy, zz, aaa, aab, ... 

यह काम करता है और उम्मीद है कि कुछ समझ में आता है। फैशनेबल लाइन नहीं है, क्योंकि यह गणितीय अधिक भावना के लिए 0, आदि रिक्त स्ट्रिंग के प्रतिनिधित्व करने के लिए और फिर "एक" 1 होगा

alpha = "abcdefghijklmnopqrstuvwxyz"; 

function hex(a) { 
    // First figure out how many digits there are. 
    a += 1; // This line is funky 
    c = 0; 
    var x = 1;  
    while (a >= x) { 
    c++; 
    a -= x; 
    x *= 26; 
    } 

    // Now you can do normal base conversion. 
    var s = ""; 
    for (var i = 0; i < c; i++) { 
    s = alpha.charAt(a % 26) + s; 
    a = Math.floor(a/26); 
    } 

    return s; 
} 

हालांकि बना देता है, अगर आप बस उन्हें प्रिंट की योजना बना रहे क्रम में, कहीं अधिक कुशल तरीके हैं। उदाहरण के लिए, रिकर्सन और/या उपसर्ग और सामान का उपयोग करना।

Answer 2

a0 का प्रतिनिधित्व करता है, और z25 का प्रतिनिधित्व करता है। तो z के बाद संख्या 26 है, जो 1*26 + 0 है, इसलिए ba सही है। (और zzzzz के बाद नंबर baaaaa है।)

Answer 3

मैं कैसे एक सूत्र से इस पर काम करने के लिए समझ में नहीं आता है, लेकिन मैं थोड़ी देर के लिए के साथ चारों ओर मूर्ख बनाया और सचमुच का अनुरोध किया स्तंभ संख्या तक गिनती करने के लिए निम्नलिखित कलन विधि के साथ आया था:

var getAlpha = (function() { 
    var alphas = [null, "a"], 
     highest = [1]; 

    return function(decNum) { 
     if (alphas[decNum]) 
      return alphas[decNum]; 

     var d, 
      next, 
      carry, 
      i = alphas.length; 

     for(; i <= decNum; i++) { 
      next = ""; 
      carry = true; 
      for(d = 0; d < highest.length; d++){ 
       if (carry) { 
        if (highest[d] === 26) { 
         highest[d] = 1; 
        } else { 
         highest[d]++; 
         carry = false; 
        } 
       } 
       next = String.fromCharCode(
          highest[d] + 96) 
        + next; 
      } 
      if (carry) { 
       highest.push(1); 
       next = "a" + next; 
      } 
      alphas[i] = next; 
     } 

     return alphas[decNum]; 
    }; 
})(); 


alert(getAlpha(27));  // "aa" 
alert(getAlpha(100000)); // "eqxd" 

डेमो: http://jsfiddle.net/6SE2f/1/

highest सरणी प्रति "अंक" (तत्व 0 कम से कम महत्वपूर्ण "अंक") के साथ एक सरणी तत्व के साथ वर्तमान उच्चतम संख्या रखता है।

जब मैंने उपरोक्त शुरू किया, तो गणना के बाद प्रत्येक मूल्य को कैश करने के लिए एक अच्छा विचार लग रहा था, यदि एक ही मूल्य फिर से अनुरोध किया गया था, तो समय बचाने के लिए, लेकिन अभ्यास में (क्रोम के साथ) 1,000,000 वें की गणना करने में केवल 3 सेकंड लग गए मान (bdwgn) और 10,000,000 वें मूल्य (uvxxk) की गणना करने के लिए लगभग 20 सेकंड। कैशिंग हटाने के साथ 10,000,000 वें मूल्य में लगभग 14 सेकंड लग गए।

Answer 4

हालांकि @ user826788 पहले से ही एक कामकाजी कोड पोस्ट कर चुका है (जो कि एक तिहाई तेज भी है), मैं अपना खुद का काम पोस्ट करूंगा, मैंने यहां पोस्ट ढूंढने से पहले किया था (जैसा कि मुझे "हेक्साविजिसेमल" शब्द नहीं पता था)। हालांकि इसमें दूसरे तरीके के लिए समारोह भी शामिल है।ध्यान दें कि मैं एक = 1 का उपयोग के रूप में मैं इसका इस्तेमाल

aa) first 
ab) second 

से प्रारंभिक सूची तत्व कन्वर्ट करने के लिए

<ol type="a" start="27"> 
<li>first</li> 
<li>second</li> 
</ol> 

रहे हैं:

function linum2int(input) { 
    input = input.replace(/[^A-Za-z]/, ''); 
    output = 0; 
    for (i = 0; i < input.length; i++) { 
     output = output * 26 + parseInt(input.substr(i, 1), 26 + 10) - 9; 
    } 
    console.log('linum', output); 
    return output; 
} 

function int2linum(input) { 

    var zeros = 0; 
    var next = input; 
    var generation = 0; 
    while (next >= 27) { 
     next = (next - 1)/26 - (next - 1) % 26/26; 
     zeros += next * Math.pow(27, generation); 
     generation++; 
    } 
    output = (input + zeros).toString(27).replace(/./g, function ($0) { 
     return '_abcdefghijklmnopqrstuvwxyz'.charAt(parseInt($0, 27)); 
    }); 
    return output; 
} 

linum2int("aa"); // 27 
int2linum(27); // "aa" 

Answer 5

बस this code पहले आज रात लिख समाप्त, और मैं यह सवाल जानने के लिए कि इस सवाल को जानने के लिए इस सवाल को मिला। यहां यह है (यदि किसी को इसका उपयोग करने जैसा लगता है):

/** 
* Convert an integer to bijective hexavigesimal notation (alphabetic base-26). 
* 
* @param {Number} int - A positive integer above zero 
* @return {String} The number's value expressed in uppercased bijective base-26 
*/ 
function bijectiveBase26(int){ 
    const sequence = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
    const length  = sequence.length; 

    if(int <= 0)  return int; 
    if(int <= length) return sequence[int - 1]; 


    let index = (int % length) || length; 
    let result = [sequence[index - 1]]; 

    while((int = Math.floor((int - 1)/length)) > 0){ 
     index = (int % length) || length; 
     result.push(sequence[index - 1]); 
    } 

    return result.reverse().join("") 
}