How to generate random numbers in specific range and using specific numbers?

Example given numbers [7,8]; given range [100-900]; output must be one of them 777, 787, 788, 878, 877, 888 etc...

Help me

const randomGenerateNumber = (maxRange:number, minRange:number, numbers:number[]) => {
 //...what should i do in there??? Help me? Any Idea?
}

CodePudding user response：

I think you don't want random numbers. It seems that you want a set of numbers based on some rules. Random means something else.

If I understand well your question you want to generate all possible numbers containing only a set of digits from a range of numbers. Is this an accurate description?

If so, this is similar with what you want: Generate random numbers only with specific digits

Edit:

You are right, so you want only one number.

In javascript you could do something like this:

    function randomGenerateNumber(minRange, maxRange, digits){
        var num = 0;    
        //get a random number from your range
        len = Math.floor(Math.random() * (maxRange - minRange)   minRange);
        //get the lenght of that random number
        len = len.toString().length;
        
        //generate a number with that length using only your set of digits
        while(len--)
        {
           var temp = num * 10   digits[Math.floor(Math.random() * digits.length)];                     
           if(temp < maxRange)          
               num = temp;      
        }
            
        return num;
    }

//your testing case
minRange = 100
maxRange = 900
digits = [7,8];
console.log(randomGenerateNumber(minRange,maxRange,digits))

CodePudding user response：

i did it. Is there any improvement. Little bit messy.

const getRandomNumber = (min: number, max: number, numbers: number[]): number => {
  if (numbers.length === 9) {
    return Math.floor(Math.random() * (max - min   1)   min);
  }
  let result = '';

  //split maxDigits 100 => [1, 0, 0]
  const maxDigits = max
    .toString()
    .split('')
    .map(i => parseInt(i, 10));

  //split minDigits 100 => [1, 0, 0]
  const minDigits = min
    .toString()
    .split('')
    .map(i => parseInt(i, 10));

  //length of random number [minDigit, maxDigit] inclusive
  const randomDigit = Math.floor(Math.random() * (maxDigits.length - minDigits.length   1)   minDigits.length);

  let alreadyHigh = false;

  let alreadyLow = false;

  let equal = true;

  //4 conditions

  //1. minDigits.length === maxDigits.length
  //2. randomDigit === minDigits.length
  //3. randomDigit === maxDigits.length
  //4. randomDigit > minDigits.length && randomDigit < maxDigits.length

  for (let i = 0; i < randomDigit; i  ) {
    const numbersToUse = i === 0 ? numbers : [...numbers, 0];
    let availableNumbers = [];

    if (minDigits.length === maxDigits.length) {
      if (equal) {
        for (let k = 0; k < numbersToUse.length; k  ) {
          if (minDigits[i] > maxDigits[i]) {
            if (numbersToUse[k] >= 0 && numbersToUse[k] <= maxDigits[i]) {
              availableNumbers.push(numbersToUse[k]);
            }
          } else if (numbersToUse[k] >= minDigits[i] && numbersToUse[k] <= maxDigits[i]) {
            availableNumbers.push(numbersToUse[k]);
          } else {
            availableNumbers.push(maxDigits[i]);
          }
        }
      } else {
        if (!alreadyHigh) {
          for (let k = 0; k < numbersToUse.length; k  ) {
            if (numbersToUse[k] >= minDigits[i]) {
              availableNumbers.push(numbersToUse[k]);
            }
          }
        } else {
          availableNumbers = numbersToUse;
        }
      }
    } else if (randomDigit === minDigits.length) {
      if (!alreadyHigh) {
        for (let k = 0; k < numbersToUse.length; k  ) {
          if (numbersToUse[k] >= minDigits[i]) {
            availableNumbers.push(numbersToUse[k]);
          }
        }
      } else {
        availableNumbers = numbersToUse;
      }
    } else if (randomDigit === maxDigits.length) {
      if (!alreadyLow) {
        for (let k = 0; k < numbersToUse.length; k  ) {
          if (numbersToUse[k] <= maxDigits[i]) {
            availableNumbers.push(numbersToUse[k]);
          }
        }
      } else {
        availableNumbers = numbersToUse;
      }
    } else {
      availableNumbers = numbersToUse;
    }

    availableNumbers = [...new Set(availableNumbers)];
    const randomIndex = Math.floor(Math.random() * availableNumbers.length);
    result  = `${availableNumbers[randomIndex]}`;

    alreadyHigh = !alreadyHigh ? availableNumbers[randomIndex] > minDigits[i] : true;
    alreadyLow = !alreadyLow ? availableNumbers[randomIndex] < maxDigits[i] : true;
    equal = equal ? availableNumbers[randomIndex] === maxDigits[i] : false;
  }
  return parseInt(result, 10);
};