Skip to main content
Talentd

Encode and Decode TinyURL - Solution & Explanation

MediumHash TableStringDesignHash Function9 min readAsked at: Amazon, Microsoft, Apple +6
Practice this problem

Problem Statement

Note: This is a companion problem to the System Design problem: Design TinyURL.

TinyURL is a URL shortening service where you enter a URL such as https://leetcode.com/problems/design-tinyurl and it returns a short URL such as http://tinyurl.com/4e9iAk. Design a class to encode a URL and decode a tiny URL.

There is no restriction on how your encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL and the tiny URL can be decoded to the original URL.

Implement the Solution class:

  • Solution() Initializes the object of the system.
  • String encode(String longUrl) Returns a tiny URL for the given longUrl.
  • String decode(String shortUrl) Returns the original long URL for the given shortUrl. It is guaranteed that the given shortUrl was encoded by the same object.

 

Example 1:

Input: url = "https://leetcode.com/problems/design-tinyurl"
Output: "https://leetcode.com/problems/design-tinyurl"

Explanation:
Solution obj = new Solution();
string tiny = obj.encode(url); // returns the encoded tiny url.
string ans = obj.decode(tiny); // returns the original url after decoding it.

 

Constraints:

  • 1 <= url.length <= 104
  • url is guranteed to be a valid URL.

Approach Overview

Problem Overview: Design a service similar to TinyURL that converts a long URL into a short one and restores the original URL later. The system must guarantee that encoding and decoding are consistent and efficient.

Approach 1: Hash Map with Incremental ID (O(1) time, O(n) space)

This design stores every long URL in a hash table and assigns it a unique numeric ID. Each time encode runs, increment a counter and map that ID to the original URL. The short URL becomes something like http://tinyurl.com/{id}. For decode, extract the ID from the short URL and perform a hash lookup to retrieve the original string. Both operations run in O(1) time because they rely on constant‑time hash table access, while storage grows linearly with the number of URLs, giving O(n) space.

The key idea is separating the short identifier from the stored data. The short URL only contains a compact key, while the mapping lives in memory or a database. This approach is simple and reliable for interview scenarios and demonstrates understanding of system design basics.

Approach 2: Base Conversion (Base62 Encoding) (O(1) time, O(n) space)

Instead of exposing a numeric ID directly, convert the counter value into a Base62 string using digits, lowercase letters, and uppercase letters. For example, an integer ID like 125 becomes a short code such as cb. This reduces the URL length significantly while keeping the mapping reversible. Encoding works by repeatedly dividing the ID by 62 and mapping remainders to characters. Decoding reverses the process by converting the Base62 string back into an integer and retrieving the original URL from the hash map.

This method still uses a hash table internally but improves aesthetics and scalability of the short URL. The conversion step runs in constant time because the encoded string length is small, keeping overall complexity at O(1) time for both operations and O(n) space for stored mappings. It also demonstrates knowledge of hash functions and compact identifier generation.

Recommended for interviews: The hash map approach proves you understand the core requirement—mapping a short key to a long URL with constant‑time lookup. Interviewers usually expect the Base62 variation next because real TinyURL services avoid raw numeric IDs. Showing both designs highlights practical thinking: the first ensures correctness, while the second improves usability and URL length.

Approach 1: Hash Map Approach

This approach utilizes a hash map (dictionary) where each long URL is stored along with a unique identifier that serves as the short URL.
This method involves two main operations:

  • Encoding: Generate a unique short URL for each long URL using a sequential counter. Store the mapping in the hash map.
  • Decoding: Retrieve the original URL using the short URL by referencing the hash map.

The encode method generates a 6-character random string for each long URL, stores this mapping in a dictionary, and returns the short URL. The decode method retrieves the original URL using the short URL by referencing the stored dictionary entries. Random generation ensures low collision chances.

Code

PythonJavaScript

Python

JavaScript

Complexity

Time Complexity: O(1) for both encode and decode operations.
Space Complexity: O(n), where n is the number of URLs encoded.

Try this approach in the editor →

Approach 2: Base Conversion Approach

This approach converts a unique identifier into a base62 string, which is used as the short URL.
Using this method involves several steps:

  • Encoding: Maintain a counter that increments with each URL encoding. Convert this counter using base62 encoding to derive the short URL.
  • Decoding: Use the base62 string to retrieve the original counter and access the mapped long URL.

This Python implementation utilizes a counter incremented on each URL encoding, converting it to a base62 string as the short URL. The original URL is fetched using this unique code during decoding.

Code

PythonJava

Python

Java

Complexity

Time Complexity: O(log n) for encoding as base conversion takes logn operations. O(1) for decoding.
Space Complexity: O(n), for storing the mappings.

Try this approach in the editor →

Approach 3: Default Approach

Code

PythonJavaC++Go

Python

Java

C++

Go

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Hash Map Approach

Time Complexity: O(1) for both encode and decode operations.
Space Complexity: O(n), where n is the number of URLs encoded.

Base Conversion Approach

Time Complexity: O(log n) for encoding as base conversion takes logn operations. O(1) for decoding.
Space Complexity: O(n), for storing the mappings.

Default Approach—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Hash Map with Incremental IDO(1) encode, O(1) decodeO(n)Simple implementation and common interview baseline for URL shortener design
Base62 Conversion with Hash MapO(1) encode, O(1) decodeO(n)When shorter, production-style URLs are required instead of sequential numeric IDs

Video Solution

Encode and Decode TinyURL - Leetcode 535 - Python • NeetCode • 24,456 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Encode and Decode TinyURL easy or hard?
Encode and Decode TinyURL is rated Medium difficulty on LeetCode. The core implementation is straightforward with a hash map, but interviewers may expect improvements like Base62 encoding, collision handling, or scalable key generation.
Encode and Decode TinyURL Python/Java solution
Typical solutions implement a class with two methods: encode and decode. Python versions often use a dictionary to map IDs to URLs, while Java versions use HashMap. Many implementations convert the numeric ID to a Base62 string to produce shorter URLs.
How to solve Encode and Decode TinyURL in O(1)?
Generate a unique identifier for each new URL and store a mapping between the identifier and the original string in a hash table. The short URL contains this identifier (often encoded in Base62). Encoding inserts the mapping in O(1), and decoding extracts the identifier and performs a constant-time lookup.
What is the best approach for Encode and Decode TinyURL?
The most practical approach uses a hash table that maps a generated short key to the original long URL. Each encode operation generates a unique ID, converts it to a short code (often Base62), and stores the mapping. Both encoding and decoding run in O(1) time with O(n) storage for all saved URLs.
Is Encode and Decode TinyURL asked at Google/Amazon/Meta?
URL shortener design problems appear frequently in interviews at large tech companies including Google, Amazon, and Meta. The question tests understanding of hash tables, string handling, and basic system design concepts like unique ID generation and efficient lookups.
What data structure is used in Encode and Decode TinyURL?
A hash table is the core data structure. It stores the relationship between a short key and the original URL so decoding can retrieve the correct value in constant time. Some implementations also use arrays or counters to generate unique IDs before encoding them.
What is the time complexity of Encode and Decode TinyURL?
Both encode and decode operations run in O(1) time on average when a hash table stores the mapping between short codes and original URLs. Space complexity is O(n) because every encoded URL must be stored to support future decoding.

Ready to solve this problem?

Practice Encode and Decode TinyURL with our built-in code editor and test cases.

Practice on FleetCode
Previous

Two Sum

Next

Longest Substring Without Repeating Characters