Snap Placement Papers 2026

Section 2: Logical Reasoning

Section 3: Technical MCQs

Section 4: Coding Problems

Question 16

Problem: Implement a simple image filter that applies a grayscale effect to an image.

Solution:

from PIL import Image
import numpy as np

def apply_grayscale(image_path, output_path):
    """
    Apply grayscale filter to an image.
    
    Args:
        image_path: Path to input image
        output_path: Path to save output image
    """
    # Open image
    img = Image.open(image_path)
    
    # Convert to RGB if not already
    if img.mode != 'RGB':
        img = img.convert('RGB')
    
    # Convert to numpy array
    img_array = np.array(img)
    
    # Apply grayscale: weighted average of RGB channels
    # Standard weights: 0.299*R + 0.587*G + 0.114*B
    grayscale = np.dot(img_array[..., :3], [0.299, 0.587, 0.114])
    
    # Convert back to 3-channel image
    grayscale_3d = np.stack([grayscale, grayscale, grayscale], axis=-1)
    
    # Convert to uint8
    grayscale_3d = grayscale_3d.astype(np.uint8)
    
    # Create and save image
    result = Image.fromarray(grayscale_3d)
    result.save(output_path)
    
    return result

# Alternative: Simple average method
def simple_grayscale(image_path, output_path):
    img = Image.open(image_path)
    
    # Create grayscale image
    grayscale = img.convert('L')
    
    # Save
    grayscale.save(output_path)
    
    return grayscale

# Test with a sample image
# apply_grayscale('input.jpg', 'output.jpg')

Time Complexity: O(width × height)
Space Complexity: O(width × height)

Question 17

Problem: Design a simple social media feed that shows posts from friends in reverse chronological order.

Solution:

from datetime import datetime
from typing import List, Dict
import heapq

class Post:
    def __init__(self, post_id: int, user_id: int, content: str, timestamp=None):
        self.post_id = post_id
        self.user_id = user_id
        self.content = content
        self.timestamp = timestamp or datetime.now()
        self.likes = 0
        self.comments = []
    
    def add_like(self):
        self.likes += 1
    
    def add_comment(self, comment):
        self.comments.append(comment)
    
    def __lt__(self, other):
        # For max-heap based on timestamp (most recent first)
        return self.timestamp > other.timestamp

class SocialMediaFeed:
    def __init__(self):
        self.posts = {}  # post_id -> Post
        self.user_posts = {}  # user_id -> list of post_ids
        self.friendships = {}  # user_id -> set of friend user_ids
    
    def add_post(self, user_id: int, content: str) -> int:
        """Add a new post and return post_id"""
        post_id = len(self.posts) + 1
        post = Post(post_id, user_id, content)
        
        self.posts[post_id] = post
        
        if user_id not in self.user_posts:
            self.user_posts[user_id] = []
        self.user_posts[user_id].append(post_id)
        
        return post_id
    
    def add_friend(self, user_id: int, friend_id: int):
        """Add friendship (bidirectional)"""
        if user_id not in self.friendships:
            self.friendships[user_id] = set()
        if friend_id not in self.friendships:
            self.friendships[friend_id] = set()
        
        self.friendships[user_id].add(friend_id)
        self.friendships[friend_id].add(user_id)
    
    def get_feed(self, user_id: int, limit: int = 10) -> List[Post]:
        """
        Get feed for user (posts from user and friends, most recent first)
        
        Args:
            user_id: User requesting feed
            limit: Maximum number of posts to return
        
        Returns:
            List of Post objects in reverse chronological order
        """
        # Get user's own posts
        user_post_ids = self.user_posts.get(user_id, [])
        
        # Get friends' posts
        friend_ids = self.friendships.get(user_id, set())
        friend_post_ids = []
        for friend_id in friend_ids:
            friend_post_ids.extend(self.user_posts.get(friend_id, []))
        
        # Combine all post IDs
        all_post_ids = user_post_ids + friend_post_ids
        
        # Get posts and sort by timestamp (most recent first)
        all_posts = [self.posts[pid] for pid in all_post_ids if pid in self.posts]
        all_posts.sort(key=lambda p: p.timestamp, reverse=True)
        
        return all_posts[:limit]
    
    def get_feed_efficient(self, user_id: int, limit: int = 10) -> List[Post]:
        """
        More efficient feed generation using max-heap.
        Useful when dealing with large numbers of posts.
        """
        friend_ids = self.friendships.get(user_id, set())
        friend_ids.add(user_id)  # Include user's own posts
        
        # Use heap to get most recent posts
        heap = []
        
        for uid in friend_ids:
            post_ids = self.user_posts.get(uid, [])
            for pid in post_ids:
                if pid in self.posts:
                    post = self.posts[pid]
                    heapq.heappush(heap, post)
                    
                    # Keep only top 'limit' posts
                    if len(heap) > limit:
                        heapq.heappop(heap)
        
        # Convert heap to sorted list (most recent first)
        result = sorted(heap, key=lambda p: p.timestamp, reverse=True)
        return result
    
    def like_post(self, post_id: int):
        """Like a post"""
        if post_id in self.posts:
            self.posts[post_id].add_like()
    
    def comment_on_post(self, post_id: int, comment: str):
        """Add comment to a post"""
        if post_id in self.posts:
            self.posts[post_id].add_comment(comment)

# Test
feed = SocialMediaFeed()

# Add users and posts
feed.add_post(1, "Hello world!")
feed.add_post(2, "Beautiful day!")
feed.add_post(1, "Working on a new project")

# Add friendships
feed.add_friend(1, 2)
feed.add_friend(1, 3)

# Get feed for user 1
user1_feed = feed.get_feed(1)
for post in user1_feed:
    print(f"User {post.user_id}: {post.content} ({post.timestamp})")

Time Complexity: O(n log k) for heap-based approach where n = total posts, k = limit
Space Complexity: O(n) for storing all posts

Question 18

Problem: Implement a simple rate limiter for API requests.

Solution:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests, window_seconds):
        """
        Args:
            max_requests: Maximum requests allowed in window
            window_seconds: Time window in seconds
        """
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = deque()  # Stores timestamps
    
    def allow_request(self, user_id=None):
        """
        Check if request should be allowed.
        
        Args:
            user_id: Optional user identifier for per-user rate limiting
        
        Returns:
            True if request allowed, False otherwise
        """
        current_time = time.time()
        
        # Remove old requests outside the window
        while self.requests and self.requests[0] <= current_time - self.window_seconds:
            self.requests.popleft()
        
        # Check if under limit
        if len(self.requests) < self.max_requests:
            self.requests.append(current_time)
            return True
        
        return False

# Token bucket implementation
class TokenBucketRateLimiter:
    def __init__(self, capacity, refill_rate):
        """
        Args:
            capacity: Maximum tokens in bucket
            refill_rate: Tokens added per second
        """
        self.capacity = capacity
        self.tokens = capacity
        self.refill_rate = refill_rate
        self.last_refill = time.time()
    
    def _refill(self):
        """Refill tokens based on elapsed time"""
        now = time.time()
        elapsed = now - self.last_refill
        self.tokens = min(
            self.capacity,
            self.tokens + elapsed * self.refill_rate
        )
        self.last_refill = now
    
    def allow_request(self, tokens_needed=1):
        """Check if request can be processed"""
        self._refill()
        
        if self.tokens >= tokens_needed:
            self.tokens -= tokens_needed
            return True
        return False

# Test
limiter = RateLimiter(max_requests=3, window_seconds=60)
print(limiter.allow_request())  # True
print(limiter.allow_request())  # True
print(limiter.allow_request())  # True
print(limiter.allow_request())  # False

bucket = TokenBucketRateLimiter(capacity=10, refill_rate=1)
print(bucket.allow_request())  # True

Time Complexity: O(1) for both implementations
Space Complexity: O(max_requests) for sliding window, O(1) for token bucket

Preparation Strategy for Snap 2026

Week 1-2: Coding Fundamentals

• Solve LeetCode medium problems
• Focus on: Arrays, Hash Maps, Strings, Trees
• Practice writing clean, efficient code

Week 3-4: Mobile & System Design

• Study mobile development basics
• Learn about real-time systems
• Understand computer vision concepts
• Read Snap's engineering blog

Week 5: Interview Preparation

• Mock interviews
• Prepare system design answers
• Study Snap's products and culture

Resources Recommended

1. Coding: LeetCode, focusing on medium problems
2. Mobile: Android/iOS development guides
3. System Design: Designing Data-Intensive Applications
4. Snap: Engineering blog, product updates

Frequently Asked Questions (FAQ)

Q1: What makes Snap different from other social media companies?

A: Snap focuses on camera-first communication, ephemeral content, and AR innovation rather than permanent social graphs.

Q2: Is mobile development experience required?

A: Highly beneficial but not strictly required. Understanding mobile constraints and patterns is important.

Q3: What is Snap's tech stack?

A: Android (Java/Kotlin), iOS (Swift), backend (Go, Java), and various ML/computer vision frameworks.

Q4: How important is computer vision knowledge?

A: Important for AR/ML roles, but general software engineering roles focus more on algorithms and systems.

Q5: What is the work culture like at Snap?

A: Fast-paced, innovative, with emphasis on creativity and technical excellence. They value "kind, smart, creative" people.

Q6: Does Snap hire remote employees?

A: Primarily office-based with some flexibility, but they emphasize in-person collaboration.

Q7: What should I know about Snap's products?

A: Understand Snapchat, Spectacles, Bitmoji, and their AR platform. Know their unique features like Stories and Lenses.

Q8: How can I prepare for the system design round?

A: Practice designing scalable mobile apps, real-time systems, and media processing pipelines.

Conclusion

Snap offers an exciting opportunity to work on cutting-edge camera technology and social communication products. Their interview process evaluates both strong coding skills and understanding of mobile systems and real-time communication. With solid preparation in algorithms, system design, and mobile development concepts, you can confidently approach the Snap 2026 recruitment process.

All the best for your Snap placement! 👻📸

Related Articles:

• Instagram Placement Papers 2026
• TikTok Placement Papers 2026
• Mobile Development Interview Guide

Last Updated: March 2026