Javascript 将字符串解释为数字；将其重新编码为另一个基数

const interpret = (alphabet, str) => {
  
  let sum = 0;
  const base = alphabet.length;
  const maxInd = str.length - 1;
  
  for (let i = 0; i <= maxInd; i++) {
    
    // Simple to get value of char within alphabet - I know this is O(m * n) but not
    // concerned about that here
    const chrVal = alphabet.indexOf(str[i]);
    
    // Earlier characters count for more, same as how in the number 4278 the 4 represents
    // 4000, larger than the 2 which is 200, larger than the 7 which is 70, etc.
    const placeInd = maxInd - i;
    
    // The "place" value in `str`, same as how in the number 4278 the 4 is 1000s, 2 is
    // 100s, 7 is 10s, etc.
    const placeVal = base ** placeInd;
        
    // Overall the value contributed by this "place" in `str` is `placeVal` times the
    // value of the character in `str` at this place
    sum += placeVal * chrVal;
    
  }
  return sum;
  
};

const tests = [
  { alpha: '0123456789', str: '20' },
  { alpha: '0123456789', str: '119992' },
  { alpha: '0123456789', str: '0000119992' },
  { alpha: '0123456789abcdef', str: 'ff' },
  { alpha: '0123456789abcdef', str: 'beef' },
  { alpha: '0123456789abcdef', str: 'deadbeef' },
  { alpha: '0123456789abcdef', str: 'a0' },
  { alpha: '01', str: '100111100' },
  { alpha: '-+', str: '+--++++--' },
  { alpha: '~!@#', str: '@#!#' }, // Now there's no reason we can't do this
];
for (const test of tests) console.log(`interpret('${test.alpha}', '${test.str}') = ${interpret(test.alpha, test.str)}`);

const logBaseHandleLikelyIntegers = (base, num) => {
  const eps = 0.000000000000005;
  const rough = Math.log(num) / Math.log(base); // May have a floating point error
  
  // Try to correct floating point error when it looks like it should be an integer
  if (Math.floor(rough + eps) > rough) return Math.floor(rough) + 1;
  if (Math.ceil( rough - eps) < rough) return Math.floor(rough) - 1;
  
  return rough;
};

const uninterpret = (alpha, num) => {
  
  const base = alpha.length;
    
  // Use log where the base is the alphabet length to determine number of chars needed
  const digitsNeeded = Math.floor(logBaseHandleLikelyIntegers(base, num) + 1);
    
  let str = '';
  for (let p = digitsNeeded - 1; p >= 0; p--) {
    const pow = Math.pow(base, p);
    const div = Math.floor(num / pow);
    str += alpha[div];
    num -= pow * div;
  }
  
  return str;
  
};

const tests = [
  { alpha: '0123456789', num: 20 },
  { alpha: '0123456789', num: 119992 },
  { alpha: '0123456789abcdef', num: 255 },
  { alpha: '0123456789abcdef', num: 48879 },
  { alpha: '0123456789abcdef', num: 3735928559 },
  { alpha: '0123456789abcdef', num: 160 },
  { alpha: '01', num: 316 },
  { alpha: '-+', num: 316 },
  { alpha: '~!@#', num: 183 }, // Now there's no reason we can't do this
  { alpha: '0123456789', num: 1000 }, // Cases like this require an integer log result and necessitate the helper function
];
for (const test of tests) console.log(`uninterpret('${test.alpha}', '${test.num}') = ${uninterpret(test.alpha, test.num)}`);