Pinterest Placement Papers 2026

Section 2: Logical Reasoning

Section 3: Technical MCQs

Section 4: Coding Problems

Question 16

Problem: Implement a simple recommendation system that suggests items based on user similarity.

Solution:

from collections import defaultdict
import math

class SimpleRecommender:
    def __init__(self):
        # user -> item -> rating
        self.user_ratings = defaultdict(dict)
        # item -> list of users who rated it
        self.item_users = defaultdict(list)
    
    def add_rating(self, user_id, item_id, rating):
        """Add a user rating for an item"""
        self.user_ratings[user_id][item_id] = rating
        self.item_users[item_id].append(user_id)
    
    def cosine_similarity(self, user1, user2):
        """Calculate cosine similarity between two users"""
        ratings1 = self.user_ratings[user1]
        ratings2 = self.user_ratings[user2]
        
        # Find common items
        common_items = set(ratings1.keys()) & set(ratings2.keys())
        if not common_items:
            return 0
        
        # Calculate dot product and magnitudes
        dot_product = sum(ratings1[item] * ratings2[item] for item in common_items)
        magnitude1 = math.sqrt(sum(r**2 for r in ratings1.values()))
        magnitude2 = math.sqrt(sum(r**2 for r in ratings2.values()))
        
        if magnitude1 == 0 or magnitude2 == 0:
            return 0
        
        return dot_product / (magnitude1 * magnitude2)
    
    def get_similar_users(self, user_id, n=5):
        """Get n most similar users"""
        similarities = []
        for other_user in self.user_ratings:
            if other_user != user_id:
                similarity = self.cosine_similarity(user_id, other_user)
                similarities.append((other_user, similarity))
        
        # Sort by similarity (highest first)
        similarities.sort(key=lambda x: x[1], reverse=True)
        return similarities[:n]
    
    def recommend_items(self, user_id, n=10):
        """Recommend items for a user"""
        user_ratings = self.user_ratings[user_id]
        similar_users = self.get_similar_users(user_id, n=5)
        
        # Calculate weighted scores for items
        item_scores = defaultdict(float)
        item_similarity_sum = defaultdict(float)
        
        for similar_user, similarity in similar_users:
            if similarity <= 0:
                continue
            
            for item, rating in self.user_ratings[similar_user].items():
                # Skip items user has already rated
                if item in user_ratings:
                    continue
                
                item_scores[item] += similarity * rating
                item_similarity_sum[item] += similarity
        
        # Calculate predicted ratings
        predictions = []
        for item, score in item_scores.items():
            if item_similarity_sum[item] > 0:
                predicted_rating = score / item_similarity_sum[item]
                predictions.append((item, predicted_rating))
        
        # Sort by predicted rating
        predictions.sort(key=lambda x: x[1], reverse=True)
        return predictions[:n]

# Test
recommender = SimpleRecommender()

# Add some ratings
recommender.add_rating("user1", "item1", 5)
recommender.add_rating("user1", "item2", 3)
recommender.add_rating("user1", "item3", 4)

recommender.add_rating("user2", "item1", 4)
recommender.add_rating("user2", "item2", 2)
recommender.add_rating("user2", "item4", 5)

recommender.add_rating("user3", "item1", 2)
recommender.add_rating("user3", "item3", 5)
recommender.add_rating("user3", "item4", 4)

print("Similar users to user1:", recommender.get_similar_users("user1"))
print("Recommendations for user1:", recommender.recommend_items("user1"))

Time Complexity: O(U² × I) where U = number of users, I = average items per user
Space Complexity: O(U × I)

Question 17

Problem: Design a system to track trending pins based on save velocity.

Solution:

from datetime import datetime, timedelta
from collections import defaultdict, deque
import heapq

class TrendingTracker:
    def __init__(self, window_hours=24, check_interval_hours=1):
        """
        Args:
            window_hours: Time window for trending calculation
            check_interval_hours: How often to check for trending items
        """
        self.window_hours = window_hours
        self.check_interval_hours = check_interval_hours
        
        # pin_id -> deque of (timestamp, saves) in last window
        self.pin_history = defaultdict(deque)
        # pin_id -> total saves in current window
        self.pin_saves = defaultdict(int)
        # Last cleanup time
        self.last_cleanup = datetime.now()
    
    def record_save(self, pin_id, timestamp=None):
        """Record a save for a pin"""
        if timestamp is None:
            timestamp = datetime.now()
        
        # Add to history
        self.pin_history[pin_id].append((timestamp, 1))
        self.pin_saves[pin_id] += 1
        
        # Clean up old records periodically
        self._cleanup_if_needed()
    
    def _cleanup_if_needed(self):
        """Remove old records outside the window"""
        current_time = datetime.now()
        if (current_time - self.last_cleanup).total_seconds() < self.check_interval_hours * 3600:
            return
        
        cutoff = current_time - timedelta(hours=self.window_hours)
        
        for pin_id in list(self.pin_history.keys()):
            # Remove old entries
            while self.pin_history[pin_id] and self.pin_history[pin_id][0][0] < cutoff:
                old_timestamp, old_saves = self.pin_history[pin_id].popleft()
                self.pin_saves[pin_id] -= old_saves
            
            # Remove pin if no saves in window
            if not self.pin_history[pin_id]:
                del self.pin_history[pin_id]
                del self.pin_saves[pin_id]
        
        self.last_cleanup = current_time
    
    def get_trending_pins(self, n=10):
        """Get top n trending pins based on save velocity"""
        self._cleanup_if_needed()
        
        # Calculate save velocity (saves per hour)
        trending_scores = []
        current_time = datetime.now()
        
        for pin_id, history in self.pin_history.items():
            if not history:
                continue
            
            # Get time range of history
            oldest_time = history[0][0]
            newest_time = history[-1][0]
            
            time_range_hours = max(1, (newest_time - oldest_time).total_seconds() / 3600)
            
            # Calculate velocity
            total_saves = self.pin_saves[pin_id]
            velocity = total_saves / time_range_hours
            
            trending_scores.append((velocity, pin_id, total_saves))
        
        # Get top n by velocity
        trending_scores.sort(reverse=True)
        return trending_scores[:n]
    
    def batch_record_saves(self, pin_save_counts):
        """Record multiple saves at once"""
        current_time = datetime.now()
        for pin_id, count in pin_save_counts.items():
            self.pin_history[pin_id].append((current_time, count))
            self.pin_saves[pin_id] += count
        
        self._cleanup_if_needed()

# Optimized version for high volume
class OptimizedTrendingTracker:
    def __init__(self, window_hours=24, granularity_minutes=5):
        self.window_hours = window_hours
        self.granularity_minutes = granularity_minutes
        self.num_buckets = (window_hours * 60) // granularity_minutes
        
        # pin_id -> circular buffer of bucket counts
        self.pin_buckets = defaultdict(lambda: [0] * self.num_buckets)
        # Current bucket index
        self.current_bucket = 0
        self.last_update = datetime.now()
    
    def _get_bucket_index(self, timestamp):
        """Convert timestamp to bucket index"""
        minutes_since_epoch = int(timestamp.timestamp() / 60)
        return (minutes_since_epoch // self.granularity_minutes) % self.num_buckets
    
    def record_save(self, pin_id,

## Frequently Asked Questions

### What is the expected salary range for Pinterest placements in 2026?

Pinterest compensation typically includes a base salary plus performance-based incentives, and in many roles it may also include stock/RSUs depending on location and level. For 2026 hiring, candidates should expect competitive packages relative to other top product companies, with final offers varying by role (SWE, data, product, etc.), interview performance, and prior experience.

### Who is eligible to apply for Pinterest placement drives in 2026?

Eligibility generally depends on your degree (B.Tech/B.E./MCA/M.Sc.), graduation year (2026), and your ability to match the role requirements such as coding proficiency and relevant coursework. Many drives also require a strong academic record and prior projects/internships, especially for technical roles; for non-technical roles, portfolio and domain understanding matter more.

### How difficult are Pinterest placement papers and interviews compared to other big tech companies?

Pinterest interviews are usually considered moderately to highly competitive because they test both problem-solving fundamentals and practical engineering thinking. The difficulty often comes from a mix of coding accuracy, clean implementation, and the ability to explain trade-offs clearly during follow-up questions.

### What preparation tips work best for Pinterest placement papers 2026 with solutions?

Focus on mastering core DSA patterns (arrays/strings, hashing, two pointers, stacks/queues, trees/graphs, DP, and greedy) and practice writing optimal solutions under time constraints. Use “papers with solutions” to learn how to approach problems, then re-solve similar questions to build speed and confidence; also practice explaining your approach out loud.

### What are the typical interview rounds for Pinterest placements?

A common structure includes an initial coding assessment (online), followed by one or more technical rounds with coding and/or system design depending on the role. Many candidates also face behavioral/HR rounds to evaluate communication, ownership, teamwork, and alignment with Pinterest’s product culture.

### What common topics appear in Pinterest coding rounds and placement papers?

You can expect frequent questions from standard DSA categories such as dynamic programming, graph traversal/shortest paths, interval problems, and string manipulation. Many rounds also include problem-solving that requires careful edge-case handling, efficient complexity analysis, and sometimes data-structure design.

### How do I apply for Pinterest placements 2026 (and what should I prepare before applying)?

Apply through Pinterest’s official careers page or the relevant campus/partner hiring portal if available for your college. Before applying, ensure your resume highlights measurable projects, internships, and impact, and prepare a strong coding practice routine plus a portfolio of projects that demonstrate your engineering fundamentals.

### What is the selection rate for Pinterest placements, and how can I improve my chances?

The selection rate varies by year, role, and applicant pool, but it is generally competitive due to multiple screening stages and technical evaluation. To improve your chances, aim for high accuracy in coding, practice frequently asked patterns, strengthen your resume with relevant projects, and perform mock interviews to reduce mistakes and improve clarity during explanations.


**Verification first:** candidates describe these patterns across recent drives, but selection rules change each cycle. Confirm on the official recruitment portal rather than relying on any single year's account, and treat older figures as indicative only.