Implement Rand10() Using Rand7()

Implement Rand10() Using Rand7() - Problem

Given the API rand7() that generates a uniform random integer in the range [1, 7], write a function rand10() that generates a uniform random integer in the range [1, 10].

Requirements:

You can only call the API rand7()
You shouldn't call any other API
Please do not use a language's built-in random API

Each test case will have one internal argument n, the number of times that your implemented function rand10() will be called while testing. Note that this is not an argument passed to rand10().

Input & Output

Example 1 — Generate 5 random numbers

$ Input: n = 5

› Output: [7,2,10,3,8]

💡 Note: Function is called 5 times, each call returns a uniform random integer in [1,10]. Actual output will vary since it's random.

Example 2 — Generate 3 random numbers

$ Input: n = 3

› Output: [1,9,4]

💡 Note: Three independent calls to rand10(), each producing a value between 1 and 10 inclusive with equal probability.

Example 3 — Single call

$ Input: n = 1

› Output: [6]

💡 Note: Single call returns one random value. All values 1-10 have equal 10% probability.

Constraints

1 ≤ n ≤ 10⁵
Follow up: What is the expected value for the number of calls to rand7() function?
Could you minimize the number of calls to rand7()?

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8 a Amazon 6

The key insight is using rejection sampling to maintain uniform distribution. Generate numbers in range [1,49] using two rand7() calls, accept [1,40] and map to [1,10], reject [41,49] and retry. Best approach is rejection sampling with optimization. Time: O(1) expected, Space: O(1)

Common Approaches

✓ Backtracking

⏱️ Time: N/A Space: N/A

Naive Modulo Approach

⏱️ Time: O(1) Space: O(1)

Simply call rand7() and use modulo 10 plus 1. However, this creates bias since 7 doesn't divide evenly into 10.

Optimized Rejection Sampling

⏱️ Time: O(1) Space: O(1)

Instead of discarding rejected values completely, recursively use them to generate new random numbers, reducing the expected number of rand7() calls.

Rejection Sampling

⏱️ Time: O(1) Space: O(1)

Generate numbers in range [1,49] using two rand7() calls, then map to [1,10] uniformly. Reject values outside the mappable range and retry.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char chars[20];
    int k;
    int n;
    int indices[10];
    int finished;
} CombinationIterator;

void advance(CombinationIterator* ci) {
    int i = ci->k - 1;
    while (i >= 0 && ci->indices[i] == ci->n - ci->k + i) {
        i--;
    }
    
    if (i < 0) {
        ci->finished = 1;
        return;
    }
    
    ci->indices[i]++;
    for (int j = i + 1; j < ci->k; j++) {
        ci->indices[j] = ci->indices[j - 1] + 1;
    }
}

CombinationIterator* createIterator(const char* characters, int combinationLength) {
    CombinationIterator* ci = (CombinationIterator*)malloc(sizeof(CombinationIterator));
    strcpy(ci->chars, characters);
    ci->k = combinationLength;
    ci->n = strlen(characters);
    ci->finished = 0;
    
    for (int i = 0; i < combinationLength; i++) {
        ci->indices[i] = i;
    }
    
    return ci;
}

char* next(CombinationIterator* ci) {
    static char result[20];
    if (ci->finished) {
        result[0] = '\0';
        return result;
    }
    
    for (int i = 0; i < ci->k; i++) {
        result[i] = ci->chars[ci->indices[i]];
    }
    result[ci->k] = '\0';
    
    advance(ci);
    return result;
}

int hasNext(CombinationIterator* ci) {
    return !ci->finished;
}

void parseStringArray(const char* str, char operations[][20], int* count) {
    *count = 0;
    const char* start = strchr(str, '[');
    const char* end = strrchr(str, ']');
    if (!start || !end) return;
    
    start++; // Skip '['
    char temp[1000];
    strncpy(temp, start, end - start);
    temp[end - start] = '\0';
    
    char* token = strtok(temp, ",");
    while (token && *count < 100) {
        // Remove quotes and whitespace
        while (*token == ' ' || *token == '\t') token++;
        if (*token == '"') token++;
        char* endQuote = strrchr(token, '"');
        if (endQuote) *endQuote = '\0';
        
        strcpy(operations[*count], token);
        (*count)++;
        token = strtok(NULL, ",");
    }
}

int parseParameters(const char* str, char params[][2][20], int types[][2]) {
    int count = 0;
    const char* start = strchr(str, '[');
    const char* end = strrchr(str, ']');
    if (!start || !end) return 0;
    
    start++; // Skip outer '['
    
    int depth = 0;
    int paramStart = 0;
    for (int i = 0; i < (end - start); i++) {
        if (start[i] == '[') depth++;
        else if (start[i] == ']') depth--;
        else if (start[i] == ',' && depth == 0) {
            // Parse parameter array
            char paramStr[100];
            strncpy(paramStr, start + paramStart, i - paramStart);
            paramStr[i - paramStart] = '\0';
            
            // Find inner brackets
            char* innerStart = strchr(paramStr, '[');
            char* innerEnd = strrchr(paramStr, ']');
            if (innerStart && innerEnd) {
                innerStart++;
                *innerEnd = '\0';
                
                if (strlen(innerStart) > 0) {
                    char* token = strtok(innerStart, ",");
                    int paramIdx = 0;
                    while (token && paramIdx < 2) {
                        while (*token == ' ' || *token == '\t') token++;
                        if (*token == '"') {
                            token++;
                            char* endQuote = strrchr(token, '"');
                            if (endQuote) *endQuote = '\0';
                            strcpy(params[count][paramIdx], token);
                            types[count][paramIdx] = 0; // string
                        } else {
                            strcpy(params[count][paramIdx], token);
                            types[count][paramIdx] = 1; // int
                        }
                        paramIdx++;
                        token = strtok(NULL, ",");
                    }
                }
            }
            count++;
            paramStart = i + 1;
        }
    }
    
    // Handle last parameter
    if (paramStart < (end - start)) {
        char paramStr[100];
        strncpy(paramStr, start + paramStart, (end - start) - paramStart);
        paramStr[(end - start) - paramStart] = '\0';
        
        char* innerStart = strchr(paramStr, '[');
        char* innerEnd = strrchr(paramStr, ']');
        if (innerStart && innerEnd) {
            innerStart++;
            *innerEnd = '\0';
            
            if (strlen(innerStart) > 0) {
                char* token = strtok(innerStart, ",");
                int paramIdx = 0;
                while (token && paramIdx < 2) {
                    while (*token == ' ' || *token == '\t') token++;
                    if (*token == '"') {
                        token++;
                        char* endQuote = strrchr(token, '"');
                        if (endQuote) *endQuote = '\0';
                        strcpy(params[count][paramIdx], token);
                        types[count][paramIdx] = 0; // string
                    } else {
                        strcpy(params[count][paramIdx], token);
                        types[count][paramIdx] = 1; // int
                    }
                    paramIdx++;
                    token = strtok(NULL, ",");
                }
            }
        }
        count++;
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    char operations[100][20];
    int opCount;
    parseStringArray(line1, operations, &opCount);
    
    char params[100][2][20];
    int types[100][2];
    int paramCount = parseParameters(line2, params, types);
    
    printf("[");
    CombinationIterator* iterator = NULL;
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "CombinationIterator") == 0) {
            char* chars = params[i][0];
            int length = atoi(params[i][1]);
            iterator = createIterator(chars, length);
            printf("null");
        } else if (strcmp(operations[i], "next") == 0) {
            char* result = next(iterator);
            printf("\"%s\"", result);
        } else if (strcmp(operations[i], "hasNext") == 0) {
            int result = hasNext(iterator);
            printf("%s", result ? "true" : "false");
        }
    }
    printf("]\n");
    
    free(iterator);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

78.4K Views

Medium Frequency

~15 min Avg. Time

987 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler