In JavaScript, is there a way to make 0.84729347293923 into an integer without using any string or regex manipulation?

Question

Given any number between 0 and 1, such as 0.84729347293923, is there a simple way to make it into 84729347293923 without string or regex manipulation? I can think of using a loop, which probably is no worse than using a string because it is O(n) with n being the number of digits. But is there a better way?

function getRandom() {
  let r = Math.random();
  while (Math.floor(r) !== r) r *= 10;
  return r;
}

for (let i = 0; i < 10; i++)
  console.log(getRandom());

Answer 1

Integers mod 1 = 0, non integers mod 1 != 0.

while ((r*=10) % 1);

Answer 2

Ok, just want to refactor my code (i realized that was bad so this is what i discovered to correctly get the value as you requested).

NOTE: As the question says that "given any number between 0 and 1", this solution only works for values between 0 and 1:

window.onload = ()=>{

    function getLen(num){
        
        let currentNumb = num;
        let integratedArray = [];
        let realLen = 0;

        /*While the number is not an integer, we will multiply the copy of the original
         *value by ten, and when the loop detects that the number is already an integer
         *the while simply breaks, in this process we are storing each transformations
         *of the number in an array called integratedArray*/
        while(!(Number.isInteger(currentNumb))){
            currentNumb *= 10;
            integratedArray.push(currentNumb);
        }

        /*We iterate over the array and compare each value of the array with an operation
         *in which the resultant value should be exactly the same as the actual item of the
         *array, in the case that both are equal we assign the var realLen to i, and
         *in case that the values were not the same, we simply breaks the loop, if the
         *values are not the same, this indicates that we found the "trash numbers", so
         *we simply skip them.*/
        for(let i = 0; i < integratedArray.length; i++){

            if(Math.floor(integratedArray[i]) === Math.floor(num * Math.pow(10, i + 1))){
                realLen = i;
            }else{
                break;
            }

        }

        return realLen;

    }

    //Get the float value of a number between 0 and 1 as an integer.
    function getShiftedNumber(num){

        //First we need the length to get the float part of the number as an integer
        const len = getLen(num);
        /*Once we have the length of the number we simply multiply the number by
         *(10) ^ numberLength, this eliminates the comma (,), or point (.), and
         *automatically transforms the number to an integer in this case a large integer*/
        return num * (Math.pow(10, len));

    }

    console.log(getShiftedNumber(0.84729347293923));

}

So the explanation is the next:

Because we want to convert this number without using any string, regex or any another thing, first we need to get the length of the number, this is a bit hard to do without using string conversions... so i did the function getLen for this purpose.

In the function getLen, we have 3 variables:

• currentNumb: This var is a copy of the original value (the original number), this value help us to found the length of the number and we can do some transforms to this value whitout changing the original reference of the number.

We need to multiply this value any times is needed to transform the number to an integer and then multiplyng this value by ten to ten. with the help of a while (this method makes the number a false integer).

NOTE: I saw "False integer" because when i was making the tests i realized that in the number is being adding more digits than normal... (Very very strange), so this stupid but important thing makes neccesary the filter of these "trash numbers", so later we proccess them.

• integratedArray: This array stores the values of the result of the first while operations, so the last number stored in this array is an integer, but this number is one of the "fake integers", so with this array we need to iterate later to compare what of those stored values are different to the original value multiplied by (10 * i + 1), so here is the hint:

In this case the first 12 values of this array are exactly the same with the operation of Math.floor(num * Math.pow(10, i + 1))), but in the 13th value of the array these values are not the same so... yes!, there are those "trash numbers" that we were searching for.

• realLen: This is the variable where we will store the real length of the number converting the float part of this number in an integer.

Answer 3

Some binary search approach:

Its useless if avarage length < 8;

It contains floating point issues.

But hey it is O(log n) with tons of wasted side computations - i guess if one counts them its event worse than just plain multiplication.

I prefer @chiliNUT answer. One line stamp.

function floatToIntBinarySearch(number){

   const max_safe_int_length = 16;
   const powers = [
                    1,
                    10,
                    100,
                    1000,
                    10000,
                    100000,
                    1000000,
                    10000000,
                    100000000,
                    1000000000,
                    10000000000,
                    100000000000,
                    1000000000000,
                    10000000000000,
                    100000000000000,
                    1000000000000000,
                    10000000000000000
                  ]
    let currentLength = 16
    let step = 16
    
    let _number = number * powers[currentLength]
    
    while(_number % 1 != 0 || (_number % 10 | 0) == 0){
       
       step /= 2 
       if( (_number % 10 | 0) == 0 && !(_number % 1 != 0)){
         
         currentLength =  currentLength - step;
       } else {
         
         currentLength = step + currentLength;
       }
       if(currentLength < 1 || currentLength > max_safe_int_length * 2) throw Error("length is weird: " + currentLength)
       
       _number = number * powers[currentLength]
       console.log(currentLength, _number)
       if(Number.isNaN(_number)) throw Error("isNaN: " + ((number + "").length - 2) + " maybe greater than 16?")
    }
    return number * powers[currentLength]
}
let randomPower = 10 ** (Math.random() * 10 | 0)
let test = (Math.random() * randomPower | 0) / randomPower
console.log(test)
console.log(floatToIntBinarySearch(test))