Snap Placement Papers 2026 with Solutions

Meta Description: Prepare for Snap 2026 campus drive with latest placement papers, exam pattern analysis, and 20+ solved questions. Get ready to crack the camera company and social media leader's hiring process.

---

Snap Inc. is a technology company that creates innovative camera products and services that help people express themselves, live in the moment, learn about the world, and have fun together. Best known for Snapchat, the company's flagship product, Snap has pioneered ephemeral messaging, augmented reality lenses, and Stories format that has been widely adopted across social media. Founded in 2011 by Evan Spiegel, Bobby Murphy, and Reggie Brown, Snap continues to push boundaries in camera technology and social communication.

Snap's engineering culture emphasizes creativity, innovation, and building products that bring joy to users. If you're targeting Snap placements in 2026, this comprehensive guide with real placement paper questions and detailed solutions is your ultimate preparation resource.

---

Snap Hiring Pattern 2026

Eligibility Criteria

Parameter	Requirements
Degree	B.E./B.Tech/M.E./M.Tech/MCA/M.Sc (CS/IT)
Academic Requirement	Strong CS fundamentals; mobile development experience is a plus
Backlogs	No active backlogs
Gap Criteria	Flexible, evaluated case-by-case
Package	₹20-40 LPA (India) / $130K-200K (US)

Selection Process Overview

1. Online Assessment (90 minutes)
2. Technical Phone Screen (45-60 minutes)
3. Virtual Onsite - Coding Round (60 minutes)
4. Virtual Onsite - System Design (60 minutes)
5. Virtual Onsite - Behavioral (45 minutes)

Snap Online Assessment Pattern 2026

Section	Number of Questions	Time	Difficulty
Aptitude & Problem Solving	15	25 minutes	Medium
Technical MCQs	10	15 minutes	Medium-High
Coding Problems	2-3	50 minutes	High
Total	27-28	~90 mins	-

Note: Snap emphasizes mobile development, computer vision, and real-time systems.

---

Snap Placement Papers 2026 - Practice Questions

Section 1: Quantitative Aptitude

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