Процесс найма

<?php

declare(strict_types=1);

/**
 * Task: Design a rate limiter for an API
 *
 * Requirements:
 * - Limit requests per user per time window
 * - Support configurable limits
 * - Thread-safe (concurrent requests)
 * - Efficient memory usage
 */

interface RateLimiter
{
    /**
     * Check if a request is allowed for a given identifier.
     * Returns true if allowed, false if rate limit exceeded.
     */
    public function isAllowed(string $identifier): bool;

    /**
     * Get remaining requests for a given identifier.
     */
    public function getRemaining(string $identifier): int;
}

/**
 * Sliding window rate limiter implementation.
 * Provides smooth rate limiting without burst issues.
 */
final class SlidingWindowRateLimiter implements RateLimiter
{
    public function __construct(
        private readonly \Redis $redis,
        private readonly int $maxRequests,
        private readonly int $windowSeconds,
    ) {}

    public function isAllowed(string $identifier): bool
    {
        $key = sprintf('rate_limit:%s', $identifier);
        $now = microtime(true);
        $windowStart = $now - $this->windowSeconds;

        // Use Redis sorted set for sliding window
        $pipe = $this->redis->multi(\Redis::PIPELINE);

        // Remove expired entries
        $pipe->zRemRangeByScore($key, '-inf', (string) $windowStart);

        // Count current entries in window
        $pipe->zCard($key);

        // Add current request
        $pipe->zAdd($key, $now, sprintf('%s:%f', $identifier, $now));

        // Set TTL for automatic cleanup
        $pipe->expire($key, $this->windowSeconds);

        $results = $pipe->exec();
        $currentCount = $results[1];

        return $currentCount < $this->maxRequests;
    }

    public function getRemaining(string $identifier): int
    {
        $key = sprintf('rate_limit:%s', $identifier);
        $now = microtime(true);
        $windowStart = $now - $this->windowSeconds;

        // Clean up and count
        $this->redis->zRemRangeByScore($key, '-inf', (string) $windowStart);
        $currentCount = $this->redis->zCard($key);

        return max(0, $this->maxRequests - $currentCount);
    }
}

package ratelimit

import (
	"context"
	"fmt"
	"time"

	"github.com/redis/go-redis/v9"
)

// RateLimiter checks if a request is allowed for a given identifier.
type RateLimiter interface {
	IsAllowed(ctx context.Context, identifier string) (bool, error)
	GetRemaining(ctx context.Context, identifier string) (int, error)
}

// SlidingWindowRateLimiter provides smooth rate limiting without burst issues.
type SlidingWindowRateLimiter struct {
	rdb           *redis.Client
	maxRequests   int64
	windowSeconds int64
}

func NewSlidingWindowRateLimiter(rdb *redis.Client, maxRequests, windowSec int64) *SlidingWindowRateLimiter {
	return &SlidingWindowRateLimiter{rdb: rdb, maxRequests: maxRequests, windowSeconds: windowSec}
}

func (r *SlidingWindowRateLimiter) IsAllowed(ctx context.Context, identifier string) (bool, error) {
	key := fmt.Sprintf("rate_limit:%s", identifier)
	now := float64(time.Now().UnixMicro()) / 1e6
	windowStart := now - float64(r.windowSeconds)

	pipe := r.rdb.Pipeline()

	// Remove expired entries
	pipe.ZRemRangeByScore(ctx, key, "-inf", fmt.Sprintf("%f", windowStart))

	// Count current entries in window
	countCmd := pipe.ZCard(ctx, key)

	// Add current request
	member := fmt.Sprintf("%s:%f", identifier, now)
	pipe.ZAdd(ctx, key, redis.Z{Score: now, Member: member})

	// Set TTL for automatic cleanup
	pipe.Expire(ctx, key, time.Duration(r.windowSeconds)*time.Second)

	if _, err := pipe.Exec(ctx); err != nil {
		return false, fmt.Errorf("rate limit check: %w", err)
	}

	return countCmd.Val() < r.maxRequests, nil
}

func (r *SlidingWindowRateLimiter) GetRemaining(ctx context.Context, identifier string) (int, error) {
	key := fmt.Sprintf("rate_limit:%s", identifier)
	now := float64(time.Now().UnixMicro()) / 1e6
	windowStart := now - float64(r.windowSeconds)

	r.rdb.ZRemRangeByScore(ctx, key, "-inf", fmt.Sprintf("%f", windowStart))
	count, err := r.rdb.ZCard(ctx, key).Result()
	if err != nil {
		return 0, fmt.Errorf("get remaining: %w", err)
	}

	remaining := r.maxRequests - count
	if remaining < 0 {
		remaining = 0
	}
	return int(remaining), nil
}

using StackExchange.Redis;

namespace RateLimiting;

/// Task: Design a rate limiter for an API
///
/// Requirements:
/// - Limit requests per user per time window
/// - Support configurable limits
/// - Thread-safe (concurrent requests)
/// - Efficient memory usage
public interface IRateLimiter
{
    // Returns true if allowed, false if rate limit exceeded.
    Task<bool> IsAllowedAsync(string identifier);

    Task<int> GetRemainingAsync(string identifier);
}

/// Sliding window rate limiter implementation.
/// Provides smooth rate limiting without burst issues.
public sealed class SlidingWindowRateLimiter(
    IDatabase redis,
    int maxRequests,
    int windowSeconds) : IRateLimiter
{
    public async Task<bool> IsAllowedAsync(string identifier)
    {
        var key = $"rate_limit:{identifier}";
        var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000d;
        var windowStart = now - windowSeconds;

        // Use Redis sorted set for sliding window.
        // A batch pipelines the commands into a single round trip.
        var batch = redis.CreateBatch();

        // Remove expired entries
        _ = batch.SortedSetRemoveRangeByScoreAsync(key, double.NegativeInfinity, windowStart);

        // Count current entries in window
        var countTask = batch.SortedSetLengthAsync(key);

        // Add current request
        _ = batch.SortedSetAddAsync(key, $"{identifier}:{now}", now);

        // Set TTL for automatic cleanup
        _ = batch.KeyExpireAsync(key, TimeSpan.FromSeconds(windowSeconds));

        batch.Execute();

        return await countTask < maxRequests;
    }

    public async Task<int> GetRemainingAsync(string identifier)
    {
        var key = $"rate_limit:{identifier}";
        var windowStart = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000d - windowSeconds;

        // Clean up and count
        await redis.SortedSetRemoveRangeByScoreAsync(key, double.NegativeInfinity, windowStart);
        var currentCount = await redis.SortedSetLengthAsync(key);

        return (int)Math.Max(0, maxRequests - currentCount);
    }
}

import time
from dataclasses import dataclass
from typing import Protocol

from redis.asyncio import Redis

class RateLimiter(Protocol):
    """Task: Design a rate limiter for an API

    Requirements:
    - Limit requests per user per time window
    - Support configurable limits
    - Safe under concurrent requests
    - Efficient memory usage
    """

    # Returns True if allowed, False if rate limit exceeded.
    async def is_allowed(self, identifier: str) -> bool: ...

    async def get_remaining(self, identifier: str) -> int: ...

@dataclass(frozen=True, slots=True)
class SlidingWindowRateLimiter:
    """Sliding window rate limiter implementation.

    Provides smooth rate limiting without burst issues.
    """

    redis: Redis
    max_requests: int
    window_seconds: int

    async def is_allowed(self, identifier: str) -> bool:
        key = f"rate_limit:{identifier}"
        now = time.time()
        window_start = now - self.window_seconds

        # Use Redis sorted set for sliding window
        async with self.redis.pipeline(transaction=True) as pipe:
            # Remove expired entries
            pipe.zremrangebyscore(key, "-inf", window_start)

            # Count current entries in window
            pipe.zcard(key)

            # Add current request
            pipe.zadd(key, {f"{identifier}:{now}": now})

            # Set TTL for automatic cleanup
            pipe.expire(key, self.window_seconds)

            results = await pipe.execute()

        current_count: int = results[1]

        return current_count < self.max_requests

    async def get_remaining(self, identifier: str) -> int:
        key = f"rate_limit:{identifier}"
        window_start = time.time() - self.window_seconds

        # Clean up and count
        await self.redis.zremrangebyscore(key, "-inf", window_start)
        current_count = await self.redis.zcard(key)

        return max(0, self.max_requests - current_count)

<?php

declare(strict_types=1);

/**
 * Example: High-level design sketch for URL Shortener
 * This is how you might think about components during an interview
 */

// Step 1: Define the API contract
final class UrlShortenerController
{
    public function __construct(
        private readonly UrlShortenerService $service,
    ) {}

    /**
     * POST /api/urls
     * Create a short URL
     */
    public function shorten(Request $request): JsonResponse
    {
        $command = new ShortenUrlCommand(
            originalUrl: $request->get('url'),
            userId: $request->getUserId(),
            customAlias: $request->get('alias'), // optional
            ttlDays: $request->get('ttl', 365),
        );

        $result = $this->service->shorten($command);

        return new JsonResponse([
            'short_url' => $result->getShortUrl(),
            'original_url' => $result->getOriginalUrl(),
            'expires_at' => $result->getExpiresAt()->format('c'),
        ], 201);
    }

    /**
     * GET /{code}
     * Redirect to original URL
     */
    public function redirect(string $code): RedirectResponse
    {
        $url = $this->service->resolve($code);

        if ($url === null) {
            throw new NotFoundException('Short URL not found');
        }

        // Track analytics asynchronously
        $this->service->trackClick($code);

        return new RedirectResponse($url, 301);
    }
}

// Step 2: Service layer with key decisions documented
final class UrlShortenerService
{
    /**
     * Key design decisions to discuss:
     * 1. ID generation: Base62 encoding of auto-increment vs random
     * 2. Storage: SQL for metadata, cache for hot URLs
     * 3. Analytics: async via message queue (not blocking redirect)
     * 4. Custom aliases: separate table with uniqueness constraint
     */
    public function __construct(
        private readonly UrlRepository $repository,
        private readonly CacheInterface $cache,
        private readonly MessageQueue $queue,
        private readonly IdGenerator $idGenerator,
    ) {}
}

package shortener

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

// Step 1: Define the API contract

// ShortenRequest represents POST /api/urls body.
type ShortenRequest struct {
	URL         string `json:"url"`
	CustomAlias string `json:"alias,omitempty"`
	TTLDays     int    `json:"ttl,omitempty"`
}

// URLHandler handles HTTP requests for the URL shortener.
type URLHandler struct {
	service *URLShortenerService
}

// Shorten creates a short URL (POST /api/urls).
func (h *URLHandler) Shorten(w http.ResponseWriter, r *http.Request) {
	var req ShortenRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "invalid request", http.StatusBadRequest)
		return
	}

	result, err := h.service.Shorten(r.Context(), ShortenCommand{
		OriginalURL: req.URL,
		UserID:      r.Header.Get("X-User-ID"),
		CustomAlias: req.CustomAlias,
		TTLDays:     req.TTLDays,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(result)
}

// Redirect resolves a short code and redirects (GET /{code}).
func (h *URLHandler) Redirect(w http.ResponseWriter, r *http.Request) {
	code := r.PathValue("code")
	url, err := h.service.Resolve(r.Context(), code)
	if err != nil || url == "" {
		http.NotFound(w, r)
		return
	}

	// Track analytics asynchronously
	go h.service.TrackClick(context.Background(), code)

	http.Redirect(w, r, url, http.StatusMovedPermanently)
}

// Step 2: Service layer with key decisions documented

// URLShortenerService contains the core business logic.
// Key design decisions to discuss:
// 1. ID generation: Base62 encoding of distributed counter vs random
// 2. Storage: SQL for metadata, cache for hot URLs
// 3. Analytics: async via message queue (not blocking redirect)
// 4. Custom aliases: separate table with uniqueness constraint
type URLShortenerService struct {
	repo    URLRepository
	cache   Cache
	queue   MessageQueue
	idGen   IDGenerator
}

using Microsoft.AspNetCore.Mvc;

namespace Shortener;

/// Example: High-level design sketch for URL Shortener
/// This is how you might think about components during an interview

// Step 1: Define the API contract

/// POST /api/urls body.
public sealed record ShortenRequest(string Url, string? Alias, int? Ttl);

public sealed record ShortenUrlCommand(
    string OriginalUrl,
    string UserId,
    string? CustomAlias, // optional
    int TtlDays);

[ApiController]
public sealed class UrlShortenerController(UrlShortenerService service) : ControllerBase
{
    /// POST /api/urls
    /// Create a short URL
    [HttpPost("/api/urls")]
    public async Task<IActionResult> Shorten([FromBody] ShortenRequest request)
    {
        var command = new ShortenUrlCommand(
            OriginalUrl: request.Url,
            UserId: Request.Headers["X-User-ID"].ToString(),
            CustomAlias: request.Alias,
            TtlDays: request.Ttl ?? 365);

        var result = await service.ShortenAsync(command);

        return Created(result.ShortUrl, new
        {
            short_url = result.ShortUrl,
            original_url = result.OriginalUrl,
            expires_at = result.ExpiresAt.ToString("O"),
        });
    }

    /// GET /{code}
    /// Redirect to original URL
    [HttpGet("/{code}")]
    public async Task<IActionResult> Redirect(string code)
    {
        // Nullable reference types make the "not found" branch explicit
        string? url = await service.ResolveAsync(code);

        if (url is null)
        {
            return NotFound("Short URL not found");
        }

        // Track analytics asynchronously
        _ = service.TrackClickAsync(code);

        return RedirectPermanent(url);
    }
}

// Step 2: Service layer with key decisions documented

/// Key design decisions to discuss:
/// 1. ID generation: Base62 encoding of auto-increment vs random
/// 2. Storage: SQL for metadata, cache for hot URLs
/// 3. Analytics: async via message queue (not blocking redirect)
/// 4. Custom aliases: separate table with uniqueness constraint
public sealed class UrlShortenerService(
    IUrlRepository repository,
    IUrlCache cache,
    IMessageQueue queue,
    IIdGenerator idGenerator)
{
}

import asyncio
from dataclasses import dataclass

from fastapi import APIRouter, HTTPException, Request
from fastapi.responses import RedirectResponse
from pydantic import BaseModel

# Example: High-level design sketch for URL Shortener
# This is how you might think about components during an interview

# Step 1: Define the API contract

class ShortenRequest(BaseModel):
    """POST /api/urls body."""

    url: str
    alias: str | None = None  # optional
    ttl: int = 365

@dataclass(frozen=True, slots=True)
class ShortenUrlCommand:
    original_url: str
    user_id: str
    custom_alias: str | None
    ttl_days: int

router = APIRouter()
service: "UrlShortenerService"

@router.post("/api/urls", status_code=201)
async def shorten(payload: ShortenRequest, request: Request) -> dict[str, str]:
    """POST /api/urls — create a short URL."""
    command = ShortenUrlCommand(
        original_url=payload.url,
        user_id=request.headers.get("X-User-ID", ""),
        custom_alias=payload.alias,
        ttl_days=payload.ttl,
    )

    result = await service.shorten(command)

    return {
        "short_url": result.short_url,
        "original_url": result.original_url,
        "expires_at": result.expires_at.isoformat(),
    }

@router.get("/{code}")
async def redirect(code: str) -> RedirectResponse:
    """GET /{code} — redirect to original URL."""
    url = await service.resolve(code)

    if url is None:
        raise HTTPException(status_code=404, detail="Short URL not found")

    # Track analytics asynchronously
    asyncio.create_task(service.track_click(code))

    return RedirectResponse(url, status_code=301)

# Step 2: Service layer with key decisions documented

@dataclass(frozen=True, slots=True)
class UrlShortenerService:
    """Key design decisions to discuss:

    1. ID generation: Base62 encoding of auto-increment vs random
    2. Storage: SQL for metadata, cache for hot URLs
    3. Analytics: async via message queue (not blocking redirect)
    4. Custom aliases: separate table with uniqueness constraint
    """

    repository: UrlRepository
    cache: Cache
    queue: MessageQueue
    id_generator: IdGenerator