Find The K-th Lucky Number

Find The K-th Lucky Number - Problem

We know that 4 and 7 are lucky digits. Also, a number is called lucky if it contains only lucky digits.

You are given an integer k, return the k-th lucky number represented as a string.

Note: Lucky numbers are ordered as: 4, 7, 44, 47, 74, 77, 444, 447, 474, 477, 744, 747, 774, 777, ...

Input & Output

Example 1 — Basic Case

$ Input: k = 4

› Output: "47"

💡 Note: Lucky numbers in order: 4(1st), 7(2nd), 44(3rd), 47(4th). The 4th lucky number is "47".

Example 2 — Single Digit

$ Input: k = 1

› Output: "4"

💡 Note: The very first lucky number is "4".

Example 3 — Larger Number

$ Input: k = 8

› Output: "447"

💡 Note: Lucky numbers: 4, 7, 44, 47, 74, 77, 444, 447. The 8th is "447".

Constraints

1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is that lucky numbers follow a binary pattern where each position can be either '4' or '7'. The optimal approach uses mathematical mapping: find the length of the k-th number, calculate its position within that length, and convert the binary representation to lucky digits (0→4, 1→7). Time: O(log k), Space: O(log k).

Common Approaches

✓ BFS Level Generation

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

Generate lucky numbers level by level using a queue. First generate all 1-digit, then 2-digit, and so on until we reach the k-th number.

Generate All Lucky Numbers

⏱️ Time: O(2^log k) Space: O(log k)

Start with empty string and recursively generate all lucky numbers by appending '4' and '7'. Keep track of count until we reach k.

Mathematical Pattern (Binary Mapping)

⏱️ Time: O(log k) Space: O(log k)

Observe that lucky numbers follow binary pattern: 1st=4(0), 2nd=7(1), 3rd=44(00), 4th=47(01). We can directly calculate the k-th lucky number using binary representation.

BFS Level Generation — Algorithm Steps

Start with queue containing '4' and '7'
For each level, generate next level by appending '4' and '7'
Count numbers until we reach k

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with ['4', '7']

Process Level by Level

Pop from front, add children to back

Count Until k

Return when count reaches k

Code -

solution.c — C

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

typedef struct {
    char data[1000][20];
    int front;
    int rear;
    int size;
} Queue;

void initQueue(Queue* q) {
    q->front = 0;
    q->rear = -1;
    q->size = 0;
}

void enqueue(Queue* q, const char* str) {
    q->rear = (q->rear + 1) % 1000;
    strcpy(q->data[q->rear], str);
    q->size++;
}

char* dequeue(Queue* q) {
    if (q->size == 0) return NULL;
    
    char* result = q->data[q->front];
    q->front = (q->front + 1) % 1000;
    q->size--;
    return result;
}

char* solution(int k) {
    Queue queue;
    initQueue(&queue);
    
    enqueue(&queue, "4");
    enqueue(&queue, "7");
    
    int count = 0;
    static char result[20];
    
    while (queue.size > 0) {
        char* current = dequeue(&queue);
        count++;
        
        if (count == k) {
            strcpy(result, current);
            return result;
        }
        
        char next4[20], next7[20];
        sprintf(next4, "%s4", current);
        sprintf(next7, "%s7", current);
        
        enqueue(&queue, next4);
        enqueue(&queue, next7);
    }
    
    return "";
}

int main() {
    int k;
    scanf("%d", &k);
    printf("%s\n", solution(k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

We generate exactly k lucky numbers in order

⚡ Linearithmic

Space Complexity

O(k)

Queue can contain up to k numbers at any time

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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

BFS Level Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler