Meta OA Real Question Review: Cloud Storage System - 4 Questions in 90 Minutes Complete Analysis

Problem Overview

This is a classic Meta OA problem that tests understanding of file system design and data structures. The entire problem is divided into 4 difficulty levels, progressively upgrading from basic file operations to complex user capacity management and file compression.

Recommended Time Allocation:

• Level 1: 15-20 minutes
• Level 2: 20-25 minutes
• Level 3: 25-30 minutes
• Level 4: 15-20 minutes

---

Level 1: Basic File Operations

Problem Requirements

Implement an in-memory cloud storage system supporting three basic operations:

1. add_file(self, name: str, size: int) -> bool - Add a new file to the storage system. Return True if successful, False if file already exists.

2. copy_file(self, name_from: str, name_to: str) -> bool - Copy file from name_from to name_to. Return False if source doesn't exist or destination already exists.

3. get_file_size(self, name: str) -> int | None - Return file size, or None if file doesn't exist.

Solution Approach

This is the most basic level - simply use a hash table (dictionary) to store files.

class CloudStorage:
    def __init__(self):
        self.files = {}
    
    def add_file(self, name: str, size: int) -> bool:
        if name in self.files:
            return False
        self.files[name] = size
        return True
    
    def copy_file(self, name_from: str, name_to: str) -> bool:
        if name_from not in self.files or name_to in self.files:
            return False
        self.files[name_to] = self.files[name_from]
        return True
    
    def get_file_size(self, name: str) -> int | None:
        return self.files.get(name)

Time Complexity

Operation	Time	Space
add_file	O(1)	O(1)
copy_file	O(1)	O(1)
get_file_size	O(1)	-

---

Level 2: Prefix-Suffix Search


Problem Requirements

Add file search functionality: find_file(self, prefix: str, suffix: str) -> list[str]

• Search for all files starting with prefix and ending with suffix
• Return format: ["<name_1>(<size_1>)", "<name_2>(<size_2>)", ...]
• Sort by file size descending, then by name lexicographic
• Return empty list if no matches

Solution Approach

def find_file(self, prefix: str, suffix: str) -> list[str]:
    result = [
        (name, self.files[name])
        for name in self.files
        if name.startswith(prefix) and name.endswith(suffix)
    ]
    result.sort(key=lambda x: (-x[1], x[0]))
    return [f"{name}({size})" for name, size in result]

Time Complexity

Operation	Time
Search	O(n·m)
Sort	O(k·log k)
Total	O(n·m + k·log k)

---

Level 3: User Capacity Management


Problem Requirements

Support multiple users with capacity limits:

1. add_user(self, user_id: str, capacity: int) -> bool - Add new user with allocated storage capacity.

2. add_file_by(self, user_id: str, name: str, size: int) -> int | None - User adds file, return remaining capacity or None if exceeds limit.

3. update_capacity(self, user_id: str, capacity: int) -> int | None - Update user capacity. Delete largest files if needed.

Solution Approach

def add_user(self, user_id: str, capacity: int) -> bool:
    if user_id in self.users:
        return False
    self.users[user_id] = capacity
    self.user_files[user_id] = {}
    return True

def add_file_by(self, user_id: str, name: str, size: int) -> int | None:
    if user_id not in self.users:
        return None
    used = sum(self.user_files[user_id].values())
    remaining = self.users[user_id] - used
    if size > remaining:
        return None
    self.user_files[user_id][name] = size
    self.files[name] = size
    return remaining - size

def update_capacity(self, user_id: str, capacity: int) -> int | None:
    if user_id not in self.users:
        return None
    self.users[user_id] = capacity
    used = sum(self.user_files[user_id].values())
    if used <= capacity:
        return 0
    
    files_list = sorted(
        self.user_files[user_id].items(),
        key=lambda x: (-x[1], x[0])
    )
    removed = 0
    for name, size in files_list:
        if used <= capacity:
            break
        del self.user_files[user_id][name]
        del self.files[name]
        used -= size
        removed += 1
    return removed

---

Level 4: File Compression


Problem Requirements

Add file compression functionality:

1. compress_file(self, name: str) -> bool - Compress file, size becomes half (floor division).

2. decompress_file(self, name: str) -> bool - Decompress file, restore original size.

Solution Approach

def compress_file(self, name: str) -> bool:
    if name not in self.files or self.is_compressed[name]:
        return False
    self.files[name] //= 2
    self.is_compressed[name] = True
    return True

def decompress_file(self, name: str) -> bool:
    if name not in self.files or not self.is_compressed[name]:
        return False
    self.files[name] = self.original_size[name]
    self.is_compressed[name] = False
    return True

---

Complete Implementation

class CloudStorage:
    def __init__(self):
        self.files = {}
        self.original_size = {}
        self.is_compressed = {}
        self.users = {}
        self.user_files = {}
    
    def add_file(self, name: str, size: int) -> bool:
        if name in self.files:
            return False
        self.files[name] = size
        self.original_size[name] = size
        self.is_compressed[name] = False
        return True
    
    def copy_file(self, name_from: str, name_to: str) -> bool:
        if name_from not in self.files or name_to in self.files:
            return False
        self.files[name_to] = self.files[name_from]
        self.original_size[name_to] = self.original_size[name_from]
        self.is_compressed[name_to] = self.is_compressed[name_from]
        return True
    
    def get_file_size(self, name: str) -> int | None:
        return self.files.get(name)
    
    def find_file(self, prefix: str, suffix: str) -> list[str]:
        result = [
            (name, self.files[name])
            for name in self.files
            if name.startswith(prefix) and name.endswith(suffix)
        ]
        result.sort(key=lambda x: (-x[1], x[0]))
        return [f"{name}({size})" for name, size in result]
    
    def add_user(self, user_id: str, capacity: int) -> bool:
        if user_id in self.users:
            return False
        self.users[user_id] = capacity
        self.user_files[user_id] = {}
        return True
    
    def add_file_by(self, user_id: str, name: str, size: int) -> int | None:
        if user_id not in self.users:
            return None
        used = sum(self.user_files[user_id].values())
        remaining = self.users[user_id] - used
        if size > remaining:
            return None
        self.user_files[user_id][name] = size
        self.files[name] = size
        self.original_size[name] = size
        self.is_compressed[name] = False
        return remaining - size
    
    def update_capacity(self, user_id: str, capacity: int) -> int | None:
        if user_id not in self.users:
            return None
        self.users[user_id] = capacity
        used = sum(self.user_files[user_id].values())
        if used <= capacity:
            return 0
        
        files_list = sorted(
            self.user_files[user_id].items(),
            key=lambda x: (-self.files[x[0]], x[0])
        )
        removed = 0
        for name, _ in files_list:
            if used <= capacity:
                break
            used -= self.files[name]
            del self.user_files[user_id][name]
            del self.files[name]
            removed += 1
        return removed
    
    def compress_file(self, name: str) -> bool:
        if name not in self.files or self.is_compressed[name]:
            return False
        self.files[name] //= 2
        self.is_compressed[name] = True
        return True
    
    def decompress_file(self, name: str) -> bool:
        if name not in self.files or not self.is_compressed[name]:
            return False
        self.files[name] = self.original_size[name]
        self.is_compressed[name] = False
        return True

---

On-Site Strategy

Time Management

Phase	Time	Task
0-5 min	5 min	Understand requirements
5-25 min	20 min	Complete Level 1-2
25-55 min	30 min	Complete Level 3
55-85 min	30 min	Complete Level 4 + Testing
85-90 min	5 min	Review and submit

Common Mistakes

❌ Capacity calculation error with compression
❌ Wrong sort order
❌ File ownership mix-up
❌ Missing edge cases

✅ Best Practices:

• Complete basic functionality first
• Test after each level
• Use clear variable names
• Handle all edge cases

---

🚀 Need Interview Help?

oavoservice provides professional OA/VO interview assistance.

👉 Contact WeChat: Coding0201