Encode and Decode TinyURL - Practice Coding Problems

Encode and Decode TinyURL - Problem

TinyURL is a URL shortening service that transforms long web addresses into compact, shareable links. Imagine you have a lengthy URL like https://leetcode.com/problems/design-tinyurl and you want to share it on social media where character count matters. TinyURL converts it into something like http://tinyurl.com/4e9iAk.

Your task: Design a class that can both encode a long URL into a short URL and decode a short URL back to the original long URL.

Requirements:

Implement a Solution class with constructor, encode(longUrl), and decode(shortUrl) methods
The encoding algorithm is completely up to you - be creative!
Guarantee that any URL encoded by your system can be decoded back to the original
Handle multiple URLs and ensure each gets a unique short code

This problem tests your understanding of hash tables, string manipulation, and system design principles.

Input & Output

example_1.py — Basic Encoding and Decoding

$ Input: codec = Codec() originalUrl = "https://leetcode.com/problems/design-tinyurl" shortUrl = codec.encode(originalUrl) decodedUrl = codec.decode(shortUrl)

› Output: originalUrl: "https://leetcode.com/problems/design-tinyurl" shortUrl: "http://tinyurl.com/4e9iAk" (example) decodedUrl: "https://leetcode.com/problems/design-tinyurl"

💡 Note: The codec successfully encodes a long URL into a short URL and decodes it back to the original URL. The short URL format and code can vary based on implementation.

example_2.py — Duplicate URL Handling

$ Input: codec = Codec() url = "https://www.google.com" short1 = codec.encode(url) short2 = codec.encode(url) # Same URL again

› Output: short1: "http://tinyurl.com/xY2bv" short2: "http://tinyurl.com/xY2bv" short1 == short2: True

💡 Note: When the same long URL is encoded multiple times, the system should return the same short URL to avoid creating duplicates and save storage space.

example_3.py — Multiple Different URLs

$ Input: codec = Codec() urls = ["https://leetcode.com", "https://github.com", "https://stackoverflow.com"] shortUrls = [codec.encode(url) for url in urls] decodedUrls = [codec.decode(short) for short in shortUrls]

› Output: Original URLs: ["https://leetcode.com", "https://github.com", "https://stackoverflow.com"] Short URLs: ["http://tinyurl.com/aB3c", "http://tinyurl.com/dE4f", "http://tinyurl.com/gH5i"] Decoded URLs: ["https://leetcode.com", "https://github.com", "https://stackoverflow.com"]

💡 Note: Each unique URL gets its own unique short code, and all URLs can be successfully decoded back to their originals.

Visualization

Tap to expand

Understanding the Visualization

URL Arrives

A long URL comes in requesting to be shortened

Check Existing

System checks if this URL was already shortened before

Generate Code

If new, generate a unique random short code

Store Mapping

Save the bidirectional mapping in hash tables

Return Short URL

Provide the short URL with the generated code

Key Takeaway

🎯 Key Insight: The power of hash tables enables instant bidirectional lookup, making URL shortening services both fast and scalable. The system maintains data integrity by preventing duplicates while ensuring unique short codes for different URLs.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash table lookup and insertion are O(1) average case

✓ Linear Growth

Space Complexity

O(n)

Two hash tables storing n URL mappings each

⚡ Linearithmic Space

Constraints

1 ≤ longUrl.length ≤ 2048
longUrl is guaranteed to be a valid URL
The generated short URL should be as short as possible
Follow-up: How would you handle URL expiration, analytics, and rate limiting?
Consider collision handling if using hash-based approaches

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses two hash tables for bidirectional mapping: one from long URLs to short URLs, and another from short URLs to long URLs. This enables O(1) average case lookup time for both encoding and decoding operations. The key insight is generating unique short codes (using random strings, counters, or hash functions) while handling duplicates efficiently by checking existing mappings before creating new ones.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(n)	Store all URL pairs in a list and search linearly
Hash Table Mapping (Optimal)	O(1)	O(n)	Use two hash maps for bidirectional O(1) lookup

Brute Force (Linear Search) — Algorithm Steps

Maintain a list of (longUrl, shortUrl) pairs
For encoding: search entire list to check if URL exists
If exists, return existing short URL, otherwise create new pair
For decoding: search entire list to find matching short URL
Return corresponding long URL

Visualization

Tap to expand

Step-by-Step Walkthrough

Store URL Pairs

Each encoded URL is stored as a pair in a list

Linear Search

To find a URL, we must check every pair in sequence

Found Match

When we find the matching URL, return the corresponding pair

Code -

solution.c — C

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

#define MAX_URLS 1000
#define MAX_URL_LEN 2048

typedef struct {
    char longUrls[MAX_URLS][MAX_URL_LEN];
    char shortUrls[MAX_URLS][MAX_URL_LEN];
    int count;
} Codec;

Codec* codecCreate() {
    Codec* codec = (Codec*)malloc(sizeof(Codec));
    codec->count = 0;
    return codec;
}

char* encode(Codec* codec, char* longUrl) {
    // Check if URL already encoded
    for (int i = 0; i < codec->count; i++) {
        if (strcmp(codec->longUrls[i], longUrl) == 0) {
            char* result = (char*)malloc(MAX_URL_LEN);
            strcpy(result, codec->shortUrls[i]);
            return result;
        }
    }
    
    // Create new short URL
    char* shortUrl = (char*)malloc(MAX_URL_LEN);
    sprintf(shortUrl, "http://tinyurl.com/%d", codec->count);
    
    strcpy(codec->longUrls[codec->count], longUrl);
    strcpy(codec->shortUrls[codec->count], shortUrl);
    codec->count++;
    
    return shortUrl;
}

char* decode(Codec* codec, char* shortUrl) {
    // Search for matching short URL
    for (int i = 0; i < codec->count; i++) {
        if (strcmp(codec->shortUrls[i], shortUrl) == 0) {
            char* result = (char*)malloc(MAX_URL_LEN);
            strcpy(result, codec->longUrls[i]);
            return result;
        }
    }
    return NULL;
}

int main() {
    Codec* codec = codecCreate();
    char* url = "https://leetcode.com/problems/design-tinyurl";
    char* encoded = encode(codec, url);
    char* decoded = decode(codec, encoded);
    
    printf("Original: %s\n", url);
    printf("Encoded: %s\n", encoded);
    printf("Decoded: %s\n", decoded);
    
    free(encoded);
    free(decoded);
    free(codec);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each encode/decode operation requires searching through all n stored URLs

✓ Linear Growth

Space Complexity

O(n)

Need to store n URL pairs

⚡ Linearithmic Space

Constraints

1 ≤ longUrl.length ≤ 2048
longUrl is guaranteed to be a valid URL
The generated short URL should be as short as possible
Follow-up: How would you handle URL expiration, analytics, and rate limiting?
Consider collision handling if using hash-based approaches

68.3K Views

Medium Frequency

~15 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler