Skillz Backend Engineer Role in Bangalore

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class RateLimiter {
    private final int maxRequests;
    private final long windowMs;
    private final ConcurrentHashMap<String, AtomicLong> counterMap = new ConcurrentHashMap<>();
    
    public RateLimiter(int maxRequests, long windowMs) {
        this.maxRequests = maxRequests;
        this.windowMs = windowMs;
    }
    
    public boolean allowRequest(String userId) {
        long now = System.currentTimeMillis();
        long windowKey = now / windowMs;
        String key = userId + ":" + windowKey;
        
        AtomicLong counter = counterMap.computeIfAbsent(key, k -> new AtomicLong(0));
        
        // Clean up old entries
        if (counterMap.size() > 1000) {
            counterMap.entrySet().removeIf(entry -> 
                Long.parseLong(entry.getKey().split(":")[1]) < (now / windowMs) - 2);
        }
        
        return counter.incrementAndGet() <= maxRequests;
    }
    
    public static void main(String[] args) throws InterruptedException {
        RateLimiter limiter = new RateLimiter(3, 1000);
        
        System.out.println(limiter.allowRequest("user1")); // true
        System.out.println(limiter.allowRequest("user1")); // true
        System.out.println(limiter.allowRequest("user1")); // true
        System.out.println(limiter.allowRequest("user1")); // false
        
        Thread.sleep(1000);
        System.out.println(limiter.allowRequest("user1")); // true (new window)
    }
}

import java.util.concurrent.*;
import java.util.*;

public class TTLCache<K, V> {
    private static class CacheEntry<V> {
        V value;
        long expiryTime;
        
        CacheEntry(V value, long ttlMs) {
            this.value = value;
            this.expiryTime = System.currentTimeMillis() + ttlMs;
        }
        
        boolean isExpired() {
            return System.currentTimeMillis() > expiryTime;
        }
    }
    
    private final ConcurrentHashMap<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService cleaner = Executors.newSingleThreadScheduledExecutor();
    
    public TTLCache() {
        cleaner.scheduleAtFixedRate(this::cleanExpired, 1, 1, TimeUnit.SECONDS);
    }
    
    public void put(K key, V value, long ttlMs) {
        cache.put(key, new CacheEntry<>(value, ttlMs));
    }
    
    public V get(K key) {
        CacheEntry<V> entry = cache.get(key);
        if (entry == null || entry.isExpired()) {
            cache.remove(key);
            return null;
        }
        return entry.value;
    }
    
    private void cleanExpired() {
        cache.entrySet().removeIf(entry -> entry.getValue().isExpired());
    }
    
    public static void main(String[] args) throws InterruptedException {
        TTLCache<String, String> cache = new TTLCache<>();
        
        cache.put("tournament", "active", 2000);
        System.out.println(cache.get("tournament")); // active
        
        Thread.sleep(2500);
        System.out.println(cache.get("tournament")); // null
    }
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        // Simulate processing tournament result
        time.Sleep(10 * time.Millisecond)
        results <- job * 2 // some processing
        fmt.Printf("Worker %d processed job %d\n", id, job)
    }
}

func main() {
    const numJobs = 1000
    const numWorkers = 10
    
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)
    
    var wg sync.WaitGroup
    
    // Start workers
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }
    
    // Send jobs
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)
    
    // Wait for all workers to finish
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // Collect results
    count := 0
    for result := range results {
        count++
        _ = result
    }
    
    fmt.Printf("Processed %d results\n", count)
}

import java.util.*;

interface ATMState {
    void insertCard();
    void ejectCard();
    void enterPin(int pin);
    void requestCash(int amount);
}

class ATM {
    private ATMState state;
    private int balance;
    private boolean cardInserted;
    private int enteredPin;
    
    public ATM(int initialBalance) {
        this.balance = initialBalance;
        this.state = new IdleState(this);
        this.cardInserted = false;
    }
    
    void setState(ATMState state) { this.state = state; }
    int getBalance() { return balance; }
    void setBalance(int balance) { this.balance = balance; }
    boolean isCardInserted() { return cardInserted; }
    void setCardInserted(boolean inserted) { this.cardInserted = inserted; }
    void setEnteredPin(int pin) { this.enteredPin = pin; }
    int getEnteredPin() { return enteredPin; }
    
    public void insertCard() { state.insertCard(); }
    public void ejectCard() { state.ejectCard(); }
    public void enterPin(int pin) { state.enterPin(pin); }
    public void requestCash(int amount) { state.requestCash(amount); }
}

class IdleState implements ATMState {
    private ATM atm;
    
    IdleState(ATM atm) { this.atm = atm; }
    
    public void insertCard() {
        System.out.println("Card inserted");
        atm.setCardInserted(true);
        atm.setState(new HasCardState(atm));
    }
    public void ejectCard() { System.out.println("No card to eject"); }
    public void enterPin(int pin) { System.out.println("Insert card first"); }
    public void requestCash(int amount) { System.out.println("Insert card first"); }
}

class HasCardState implements ATMState {
    private ATM atm;
    
    HasCardState(ATM atm) { this.atm = atm; }
    
    public void insertCard() { System.out.println("Card already inserted"); }
    public void ejectCard() {
        System.out.println("Card ejected");
        atm.setCardInserted(false);
        atm.setState(new IdleState(atm));
    }
    public void enterPin(int pin) {
        if (pin == 1234) {
            System.out.println("PIN correct");
            atm.setState(new AuthenticatedState(atm));
        } else {
            System.out.println("Wrong PIN");
            ejectCard();
        }
    }
    public void requestCash(int amount) { System.out.println("Enter PIN first"); }
}

class AuthenticatedState implements ATMState {
    private ATM atm;
    
    AuthenticatedState(ATM atm) { this.atm = atm; }
    
    public void insertCard() { System.out.println("Card already inserted"); }
    public void ejectCard() {
        System.out.println("Card ejected");
        atm.setCardInserted(false);
        atm.setState(new IdleState(atm));
    }
    public void enterPin(int pin) { System.out.println("PIN already entered"); }
    public void requestCash(int amount) {
        if (amount <= atm.getBalance()) {
            atm.setBalance(atm.getBalance() - amount);
            System.out.println("Withdrawn: " + amount + ", Remaining: " + atm.getBalance());
            ejectCard();
        } else {
            System.out.println("Insufficient balance");
            ejectCard();
        }
    }
}

public class ATMMachine {
    public static void main(String[] args) {
        ATM atm = new ATM(2000);
        atm.insertCard();
        atm.enterPin(1234);
        atm.requestCash(500);
    }
}

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.*;
import java.util.*;

public class DistributedCounter {
    private final AtomicLong counter = new AtomicLong(0);
    
    public long increment() {
        return counter.incrementAndGet();
    }
    
    public long get() {
        return counter.get();
    }
    
    public static void main(String[] args) throws InterruptedException {
        DistributedCounter counter = new DistributedCounter();
        int numThreads = 100;
        int incrementsPerThread = 1000;
        
        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
        CountDownLatch latch = new CountDownLatch(numThreads);
        
        for (int i = 0; i < numThreads; i++) {
            executor.submit(() -> {
                for (int j = 0; j < incrementsPerThread; j++) {
                    counter.increment();
                }
                latch.countDown();
            });
        }
        
        latch.await();
        executor.shutdown();
        
        System.out.println("Final counter: " + counter.get());
        System.out.println("Expected: " + (numThreads * incrementsPerThread));
    }
}