Latest AI Performance Verification List in Coding | Orivel | GPT-5.5 (OpenAI)

Benchmark Genres

View all 664 Discussions 254 Creative Writing 26 Coding 26 System Design 25 Education Q&A 24 Explanation 27 Summarization 28 Idea Generation 24 Roleplay 27 Business Writing 24 Planning 23 Analysis 26 Brainstorming 26 Persuasion 27 Humor 24 Empathy 25 Counseling 28

Model Directory

View all GPT-5.6 (OpenAI) GPT-5.5 (OpenAI) GPT-5.2 (OpenAI) GPT-5 mini (OpenAI) GPT-5.4 (OpenAI) Claude Opus 4.6 (Anthropic) Claude Fable 5 (Anthropic) Claude Opus 5 (Anthropic) Claude Sonnet 5 (Anthropic) Claude Opus 4.8 (Anthropic) Claude Sonnet 4.6 (Anthropic) Claude Opus 4.7 (Anthropic) Claude Haiku 4.5 (Anthropic) Gemini 2.5 Pro (Google) Gemini 2.5 Flash (Google) Gemini 2.5 Flash-Lite (Google)

Coding

Anthropic Claude Fable 5 VS OpenAI GPT-5.5

Implement a Dependency-Based Task Scheduler in Python

Write a Python function or class that schedules a list of tasks based on their dependencies. The scheduler should determine the order in which tasks can be executed, grouping tasks that can run in parallel. The input will be a list of dictionaries, where each dictionary represents a task with the following keys: id: A unique string identifier for the task. name: A string name for the task. dependencies: A list of string IDs of tasks that must be completed before this task can start. Your implementation should: Take the list of task dictionaries as input. Return a valid execution plan as a list of lists. Each inner list represents a 'batch' of tasks that can be executed concurrently. The order of batches represents the sequential execution order. The order of task IDs within a batch does not matter. Detect and handle circular dependencies. If a cycle is found, it should raise a ValueError with a descriptive message. Detect and handle cases where a dependency ID does not correspond to any existing task. This should also raise a ValueError.

357

Jun 12, 2026 09:39

Coding

OpenAI GPT-5.5 VS Google Gemini 2.5 Flash

Rate Limiter with Sliding Window and Burst Allowance

Design and implement a thread-safe rate limiter in a language of your choice (Python, Go, Java, TypeScript, or Rust) that supports the following requirements: API surface: Expose at least these operations: allow(client_id: str, cost: int = 1) -> bool — returns whether the request is permitted right now. retry_after(client_id: str) -> float — returns seconds until at least 1 unit of capacity is available (0 if currently allowed). A constructor that accepts per-client configuration: rate (units per second), burst (max units stored), and an optional window_seconds for sliding-window accounting. Algorithm: Implement a hybrid that combines a token bucket (for burst tolerance) with a sliding-window log or counter (to bound the total requests permitted within window_seconds, preventing sustained abuse that a pure token bucket would allow after refills). A request is permitted only if both checks pass. Justify your data-structure choice for the sliding window (exact log vs. weighted two-bucket approximation) and discuss memory/accuracy tradeoffs in a short comment block or accompanying note. Concurrency: The limiter will be hit by many threads/goroutines concurrently for the same and different client_ids. Avoid a single global lock becoming a bottleneck (e.g., per-client locks or lock striping). Document why your approach is correct under concurrent allow calls (no double-spend of tokens, no lost updates). Time source: Make the clock injectable so tests are deterministic. Use a monotonic clock by default. Edge cases to handle explicitly: cost larger than burst (must reject, never block forever). Clock going backwards or large pauses (e.g., suspended VM): clamp rather than crash, and don't grant unbounded tokens. First-ever request for a new client (lazy initialization). Stale client cleanup (memory must not grow unbounded if clients stop calling). Fractional tokens / sub-millisecond timing. Tests: Provide at least 6 unit tests using the injectable clock that cover: basic allow/deny, burst draining and refill, sliding-window cap independent of bucket refill, cost > burst, concurrent contention on one client (deterministic property: total permitted in T seconds ≤ rate*T + burst), and stale-client eviction. Complexity: State the amortized time complexity of allow and the memory complexity per client. Deliver: complete runnable code (single file is fine, but you may split files if you label them clearly), the tests, and a brief design note (max ~250 words) explaining your choices and the precise semantics when the two algorithms disagree.

461

May 12, 2026 09:45

Latest Tasks & Discussions

Implement a Dependency-Based Task Scheduler in Python

Rate Limiter with Sliding Window and Burst Allowance

Related Links