Konwersja liczb dziesiętnych na sixagesimal (podstawa sześćdziesięciu) w javascript

Question

Jaki jest najlepszy sposób zamiany liczb dziesiętnych (podstawa dziesiąta) na liczbę sześćdziesiętną (podstawa sześćdziesiąta) reprezentowaną jako ciąg znaków przy użyciu cyfr 0-9, A-Z i a-x jako cyfr.

Mam zamiar kodu w javascript, ale każda pomoc jest doceniana.

Wykorzystanie Przykład:

>>decToSex(60); 
"10" 
>>decToSex(123); 
"23" 
>>decToSex(1000000); 
"4bke" 
>>decToSex(1234567.89); 
"5gu7.rO" 

Ostateczny kod Kiedyś, na podstawie odpowiedzi Paola:

var decToSex = function(){ 
    var decToSexMap = ['0','1','2','3','4','5','6','7','8','9', 
      'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z', 
      'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x']; 

    return function(number){ 

     var negative = ''; 
     if (number < 0){ 
      var negative = '-'; 
     } 

     number = number.toString().split('.'); 
     var integer = Math.abs(number[0]); 
     var fraction = number[1]; 
     var result = ''; 

     do { 
      result = decToSexMap[integer % 60] + result; 
      integer = parseInt(integer/60); 
     } while (integer > 0); 

     if (fraction){ 
      var decimalPlaces = fraction.toString().length; 
      result += '.'; 
      fraction = parseFloat('.' + fraction); 

      var x = 0; 
      do { 
       x++; 
       var res = (fraction * 60).toString().split('.'); 
       result = result + decToSexMap[res[0]]; 

       if (res[1]) { 
        fraction = parseFloat('.' + res[1]); 
       } 
       else { 
        break; 
       } 
      } while (x < decimalPlaces); 
     } 
     return negative + result; 
    } 
}(); 

Answer 1

Działa to z danymi z badań dostarczonych, ale pewnie chce uruchomić jeszcze kilka testów na nim:

<script> 
var convert = new Array(0,1,2,3,4,5,6,7,8,9,'A','B','C','D','E','F','G','H','I','J','K', 
         'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a', 
         'b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q', 
         'r','s','t','u','v','w','x'); 

function decToSex(num) { 
    var extract = num.toString().split('.'); 
    num = extract[0]; 
    var pieces = new Array(); 
    do { 
     pieces.push(convert[num % 60]); 
     num = parseInt(num/60); 
    } while (num > 0); 
    pieces = pieces.reverse(); 
    var rem = extract[1]; 
    if(rem) { 
     rem = parseFloat('.' + rem); 
     var x = 0; 
     var dec = new Array(); 
     do { 
      x++; 
      var res = (rem * 60).toString().split('.'); 
      dec.push(convert[res[0]]); 
      if(res[1]) { 
       rem = parseFloat('.' + res[1]); 
      } else { 
       break; 
      } 
     } while (x < 3); // work up to 3 decimal places, change for more. 
    } 
    var myResult = pieces.join(''); 
    if(dec) { 
     myResult += '.' + dec.join(''); 
    } 
    return myResult; 
} 

alert(decToSex(60)); 
alert(decToSex(123)); 
alert(decToSex(1000000)); 
alert(decToSex(1234567.89)); 
</script> 

Answer 2

Wystarczy wielokrotnie podzielić ją przez 60 lat, dopóki jesteś w lewo z zera. Za każdym razem chwyć moduł i przekonwertuj go na odpowiedni znak, a następnie dodaj do łańcucha wyjściowego.

Edit: Dla dziesiętnych, powiedzmy szukasz do 3 60decimal miejscach:

zacząć od 0.98765 (podstawa 10)

0.98765 * 60 -> 59.259 -> first post-decimal character is 59 converted to its 60decimal character, then carry the .259 
.259 * 60 -> 15.54 -> second char is 15 converted to its 60decimal character, then carry the .54 
.54 * 60 -> 32.4 -> round it this time (its the last char) -> last char is 32 as its 60dec char 

Więc 0,98765 (podstawa 10) staje 0. [59] [15] [32] (podstawa 60)

Answer 3

Start, dzieląc liczbę do liczby całkowitej i część ułamkowa.

Dla części całkowitej, weź moduł, aby pobrać najmniej znaczącą cyfrę, a następnie podziel przez 60 i powtórz.

Dla części ułamkowej, wielokrotnie pomnóż przez 60 i weź część całkowitą, aby otrzymać cyfry wyniku. Jeśli kiedykolwiek dojdziesz do zera, co jest mało prawdopodobne, skończysz. Bardziej prawdopodobne jest, że będziesz chciał zakończyć po wyodrębnieniu określonej liczby cyfr.

Answer 4

Na co warto, oto modyfikacja rozwiązania do konwersji dowolnej bazy do 64:

// Convert decimal into a base between 2 and 64 
var decToBase = function() { 
    var decToBaseMap = [ 
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 
     'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'Y', 'Z', 
     '+', '/']; 

    return function(number, base) { 

     if (base < 2 || base > 64) { 
      return "#base should be between 2 and 64#"; 
     } 

     var negative = ''; 
     if (number < 0) { 
      negative = '-'; 
     } 

     number = number.toString().split('.'); 
     var integer = Math.abs(number[0]); 
     var fraction = number[1]; 
     var result = ''; 

     do { 
      result = decToBaseMap[integer % base] + result; 
      integer = parseInt(integer/base, 10); 
     } while (integer > 0); 

     if (fraction) { 
      var decimalPlaces = fraction.toString().length; 
      result += '.'; 
      fraction = parseFloat('.' + fraction); 

      var x = 0; 
      do { 
       x++; 
       var res = (fraction * base).toString().split('.'); 
       result = result + decToBaseMap[res[0]]; 

       if (res[1]) { 
        fraction = parseFloat('.' + res[1]); 
       } 
       else { 
        break; 
       } 
      } while (x < decimalPlaces); 
     } 
     return negative + result; 
    }; 
}(); 

alert(decToBase(2011, 64)); // displays "VR" 

Można grać z nim tutaj: http://jsfiddle.net/kaicarver/d3Zn2/