Javascript 如何创建一个函数，将一个数字转换为双射的六元小数？

也许我的数学还不够好，但我在将数字转换成纯字母顺序时遇到了问题，就像Microsoft Excel/OpenOffice Calc所做的那样

以下是我的代码版本，但没有提供我需要的输出：

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; } var toHexvg=函数（a）{ var x=“”； var let=“_abcdefghijklmnopqrstuvxyz”； var len=let.length； var b=a； var-cnt=0； var y=数组（）； 做{ a=（a-（a%len））/len； cnt++； }while（a！=0） a=b； var-vnt=0； 做{ b+=数学功率（（len），vnt）*数学层（a/数学功率（（len，vnt+1））； vnt++； }while（vnt！=cnt） var c=b； 做{ y、 未移位（c%长度）； c=（c-（c%len））/len； }而（c！=0） 对于（y中的var i）x+=让[y[i]]； 返回x； } 我的努力所能得到的最好结果是：

a b c d。。。y z ba bb bc

-虽然不是上面的实际代码。预期输出假定为

a b c。。。y z aa ab ac。。。zz aaa AAAB aac。。。zzzzz aaaaaaaaaaaab

，你明白了

基本上，我的问题更多的是做“数学”而不是函数。最终我的问题是：如何在六次极小转换中进行数学运算，直到一个[假定的]无穷大，就像微软的Excel一样

---

如果可能的话，一个源代码，提前谢谢。

a

代表

0

，而

z

代表

25

。因此

z

后面的数字是

26

，即

1*26+0

，因此

ba

是正确的。（并且

zzzzz

后面的数字是

baaaa

）

好的，我尝试一下，假设您希望序列以“a”（表示0）开始，然后继续：

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

这是可行的，希望能有一些意义。这里有一条时髦的线，因为从数学上讲，用空字符串表示0更有意义，然后“a”将是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;
}

alpha=“abcdefghijklmnopqrstuvxyz”；
函数十六进制（a）{
//首先计算出有多少位数字。
a+=1；//这行很时髦
c=0；
var x=1；
while（a>=x）{
C++；
a-=x；
x*=26；
}
//现在，您可以进行正常的基本转换。
var s=“”；
对于（变量i=0；i

---

然而，如果你打算简单地按顺序打印出来，有更有效的方法。例如，使用递归和/或前缀之类的东西。

我不知道如何从公式中计算出来，但我花了一段时间胡闹，想出了下面的算法，从字面上数到请求的列数：

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"

var getAlpha=（函数（）{
var alphas=[null，“a”]，
最高=[1]；
返回函数（decNum）{
if（alphas[decNum]）
返回字母[decNum]；
变量d，
下一个
携带，
i=字母长度；
对于（；i尽管@user826788已经发布了一个工作代码（比以前快了三分之一），我将发布我自己的工作，这是我在这里找到帖子之前所做的（因为我不知道“hexavigesimal”这个词）。但是它也包含了另一方面的函数。请注意，我使用a=1来转换起始列表元素

aa) first
ab) second

到


首先
第二

:

函数linum2int（输入）{
输入=输入。替换（/[^A-Za-z]/，“”）；
输出=0；
对于（i=0；i=27）{
next=（next-1）/26-（next-1）%26/26；
零+=下一代*数学功率（27，第二代）；
生成++；
}
输出=（输入+零）。toString（27）。替换（/。/g，函数（$0）{
返回''u abcdefghijklmnopqrstuvxyz'.charAt（parseInt（$0,27））；
});
返回输出；
}
linum2int（“aa”）；//27
int2linum（27）；/“aa”
今晚早些时候刚写完，我在寻找这个该死的东西的名字时发现了这个问题。这是（万一有人想用它）：

/**
*将整数转换为双射六进制表示法（字母基-26）。
*
*@param{Number}int-零上的正整数
*@return{String}以大写双射base-26表示的数字值
*/
函数bijectiveBase26（int）{
const sequence=“abcdefghijklmnopqrstuvxyz”；
常量长度=序列长度；
如果（int您可以通过递归实现这一点，如下所示：

const toBijective = n => (n > 26 ? toBijective(Math.floor((n - 1) / 26)) : "") + ((n % 26 || 26) + 9).toString(36);
// Parsing is not recursive
const parseBijective = str => str.split("").reverse().reduce((acc, x, i) => acc + ((parseInt(x, 36) - 9) * (26 ** i)), 0);

toBijective(1) // "a"
toBijective(27) // "aa"
toBijective(703) // "aaa"
toBijective(18279) // "aaaa"
toBijective(127341046141) // "overflow"

parseBijective("Overflow") // 127341046141

aa
没有什么意义。它是
00
。这个“数字”在
z
之后是
ba
，所以你的输出似乎是正确的。或者
\ucode>你的
0
，这似乎有点奇怪？嗯，对示例代码感到抱歉，我想我不应该发布它，我认为它使表达我的问题变得更复杂，哈哈……但是，我想我的底线是我需要一个输出y z aa ab a的代码nd不是y x ba bb…您可以说“”是0，但我需要的情况是输出的任何部分都不能包含任何“”…^^hmmm^[更正]：您可以说“'（下划线）是0，但我需要的情况是输出的任何部分都不能包含任何“'（下划线）…@nnnn：是的，我现在明白了。我错过了双射词部分，但维基百科很有帮助：）谢谢！谢谢你问这个问题-我也试着做同样的事情，并求助于谷歌。嗯，我猜，但如何编程以确保zzz旁边是aaaa….？就像Excel/Calc中的列一样…^^^^哦，恐怕我没有Excel Calc。我怀疑他们只是将第一个字母减少了一个。这不像=从0到z=25。系统在z之后进入aa。然后进入af
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"

/**
 * 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("")
}

const toBijective = n => (n > 26 ? toBijective(Math.floor((n - 1) / 26)) : "") + ((n % 26 || 26) + 9).toString(36);
// Parsing is not recursive
const parseBijective = str => str.split("").reverse().reduce((acc, x, i) => acc + ((parseInt(x, 36) - 9) * (26 ** i)), 0);

toBijective(1) // "a"
toBijective(27) // "aa"
toBijective(703) // "aaa"
toBijective(18279) // "aaaa"
toBijective(127341046141) // "overflow"

parseBijective("Overflow") // 127341046141