I wrote a function in Arduino to generate random numbers with the same number of binary bits as the input. However, when using random() with calculated ranges, the output sometimes doesn't match the expected binary bit length. For example, with bitnum = 3, it generates 3 (11 in binary), which doesn't have 3 bits. I adjusted the range slightly, and it worked, but I don't understand why. I hope to learn the reason behind this behavior.

*This post will use interval notation to indicate ranges, such as [8, 15] or [2^(bitnum-1), 2^bitnum - 1].

I wrote a function related to binary numbers. When a positive integer is input into this function, it outputs a random integer whose binary representation has the same number of bits as the input. For example, if you input 4, the output will be a random number in the range [8, 15], which corresponds to the binary numbers 1000 and 1111.

Those familiar with binary should know that a binary number with bitnum bits has its decimal range falling between [2^(bitnum-1), 2^bitnum - 1]. Initially, I wrote the function as follows:

int DecimalNum(int bitnum)
{
  randomSeed(millis());
  int MAX = pow(2, bitnum);
  int mini = pow(2, bitnum - 1);
  int randomNum = random(mini, MAX);
  return randomNum;
}

I wrote int MAX = pow(2, bitnum); because I know there is a % calculation with MAX inside the random() function. When executing random(mini, MAX), the range of the random number will be [mini, MAX). To get the range [2^(bitnum-1), 2^bitnum - 1], I set MAX = pow(2, bitnum), which is equivalent to pow(2, bitnum) - 1 + 1. By doing so, I can achieve the range [2^(bitnum-1), 2^bitnum), which is equivalent to [2^(bitnum-1), 2^bitnum - 1].

However, something goes wrong. When the bitnum is 3, the random() function generates 3, which is 11 in binary. The number of binary bits does not match the required 3. That does not make sense. A similar issue also occurs when 4 generates 7 (111) and 5 generates 15 (1111).

I also read the source code of random, and here is my understanding:

howbig represents the upper limit, and howsmall represents the lower limit. The function long random(long howbig) handles random number generation when only the upper limit is provided (with the lower limit being zero). The line return random() % howbig; divides the random number by the upper limit and takes the remainder. Therefore, if you call random(a), the random number will fall within the range [0, a). The function long random(long howsmall, long howbig) handles random number generation when both the lower and upper limits are provided. The line long diff = howbig - howsmall; calculates the difference diff between the upper limit howbig and the lower limit howsmall. The line return random(diff) + howsmall; passes diff into long random(long howbig) to generate a random number within the range [0, diff), and then adds howsmall to shift the range to [howsmall, howbig). In short, the range of random(a, b) will be [a, b), which is exactly what I expected.

The code:

int MAX = pow(2, bitnum);
int mini = pow(2, bitnum - 1);

theoretically should not cause any errors.

While experimenting, I changed it to:

int MAX = pow(2, bitnum);
int mini = pow(2, bitnum - 1) + 1;

and, to my surprise, it worked. However, I don’t understand why this change made it work, and I’m eager to learn the reason behind it. That’s why I’m posting this question.

This function is part of a program called ‘The Game of Binary’. Here is the complete code of the program (again, it works). I hope it can help you understand my question. The hardware requires an LCD screen and two buttons as pull-up resistor switches. Also, five me for not writing comments, but don’t worry—the program is very simple.

I hope you can help me figure out why this unexpected behavior occurs.

The game of binary:

#include <Arduino_BuiltIn.h>

#include <LiquidCrystal_I2C.h>
#include <math.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);
const int ONE_BTN_PIN = 12;  
const int ZERO_BTN_PIN = 13; 
int ONE_BTN_State = 0;
int ZERO_BTN_State = 0;

void setup()
{
  pinMode(ONE_BTN_PIN, INPUT_PULLUP); pinMode(ZERO_BTN_PIN, INPUT_PULLUP);
  lcd.init();
  lcd.backlight();
  String message ="This is the game of binary.";
  lcd.setCursor(0,1); lcd.print("0 & 1 for skip");

  for(int i=0; i<=message.length();i++)
  {
    lcd.setCursor(0,0); lcd.print(message.substring(i+1,message.length())); lcd.print(" ");
    ONE_BTN_State = digitalRead(ONE_BTN_PIN); ZERO_BTN_State = digitalRead(ZERO_BTN_PIN);
    if(ONE_BTN_State == LOW && ZERO_BTN_State == LOW)
       break;
    delay(400);
  }
  lcd.clear();
  lcd.setCursor(0,0); lcd.print("   GAME START   ");
  delay(800);
  lcd.clear();
}

int DecimalNum(int bitnum)
{
  randomSeed(millis());
  int MAX = pow(2,bitnum);
  int mini = pow(2,bitnum-1)+1;
  int randomNum = random(mini, MAX);
  return randomNum;
}

String DecToBin(int bitnum, int qustion)
{
  String binaryString = "";
  for (int i = bitnum - 1; i >= 0; i--) 
  {
    binaryString += String((qustion >> i) & 1);
  }
  return binaryString;
}

String ReadAnswer(int bitnum)
{
  String ans = "";
  unsigned long startTime = millis();
  unsigned long timeLimit = 10000;

  for(int i = 16 - bitnum; i < 16; i++)
  {
    for(;;)
    {
      int timeLeft = (timeLimit - (millis() - startTime)) / 1000;
      lcd.setCursor(14, 0); lcd.print("  "); 
      lcd.setCursor(16 - String(timeLeft).length(), 0); lcd.print(timeLeft);
      ONE_BTN_State = digitalRead(ONE_BTN_PIN); ZERO_BTN_State = digitalRead(ZERO_BTN_PIN);
      if(ONE_BTN_State == HIGH && ZERO_BTN_State == HIGH)
        break;
    }
    for(;;)
    {
      int timeLeft = (timeLimit - (millis() - startTime)) / 1000;
      lcd.setCursor(14, 0); lcd.print("  "); 
      lcd.setCursor(16 - String(timeLeft).length(), 0); lcd.print(timeLeft);
      ONE_BTN_State = digitalRead(ONE_BTN_PIN); ZERO_BTN_State = digitalRead(ZERO_BTN_PIN);
      if(ONE_BTN_State == LOW && ZERO_BTN_State == HIGH)
      {
        lcd.setCursor(i, 1); lcd.print("1");
        ans += "1";
        break;
      }
      else if(ZERO_BTN_State == LOW && ONE_BTN_State == HIGH)
      {
        lcd.setCursor(i, 1); lcd.print("0");
        ans += "0";
        break;
      }
      if(millis() - startTime > timeLimit)
      {
        lcd.clear();
        lcd.setCursor(0, 1); lcd.print("      LOSE      ");
        loop();
      }
    }
  }
  return ans;
}

void loop()
{
  for(int level = 1; level <= 55; level++)
  {
    int bitnum[] = {2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7,
                    8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
                    10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11};
    int question = DecimalNum(bitnum[level - 1]);
    String Qans = DecToBin(bitnum[level - 1], question);
    lcd.setCursor(0, 0); lcd.print("LEVEL "); lcd.print(level);
    lcd.setCursor(0, 1); lcd.print(question);
    String Uans = ReadAnswer(bitnum[level - 1]);
    if(Uans != Qans)
    {
      lcd.setCursor(0, 1); lcd.print("      LOSE      ");
      loop();
      lcd.clear();
    }
    delay(1000);
    lcd.clear();
  }
}

the source code of random

extern "C" {
  #include "stdlib.h"
}

void randomSeed(unsigned long seed)
{
  if (seed != 0) {
    srandom(seed);
  }
}

long random(long howbig)
{
  if (howbig == 0) {
    return 0;
  }
  return random() % howbig;
}

long random(long howsmall, long howbig)
{
  if (howsmall >= howbig) {
    return howsmall;
  }
  long diff = howbig - howsmall;
  return random(diff) + howsmall;
}

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

unsigned int makeWord(unsigned int w) { return w; }
unsigned int makeWord(unsigned char h, unsigned char l) { return (h << 8) | l; }