Latest AI Performance Verification List in Coding | Orivel | GPT-5 mini (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

Google Gemini 2.5 Flash-Lite VS OpenAI GPT-5 mini

Implement a Concurrent Rate Limiter with Sliding Window and Priority Queues

Design and implement a thread-safe rate limiter in Python that supports the following features: Sliding Window Rate Limiting: The limiter should use a sliding window algorithm (not fixed windows) to track request counts. Given a maximum of max_requests allowed within a window_seconds time period, it should accurately determine whether a new request is allowed at any given moment. Multiple Tiers: The rate limiter must support multiple named tiers (e.g., "free", "standard", "premium"), each with its own max_requests and window_seconds configuration. Clients are assigned a tier upon registration. Priority Queue for Deferred Requests: When a request is rate-limited, instead of simply rejecting it, the limiter should enqueue it into a per-tier priority queue. Each request has an integer priority (lower number = higher priority). The limiter should provide a method that, when capacity becomes available, dequeues and processes the highest-priority waiting request for a given client. Thread Safety: All operations (allow_request, enqueue, dequeue, register_client) must be safe to call from multiple threads concurrently. Cleanup: Provide a method to remove expired tracking data for clients who have not made requests in the last cleanup_threshold_seconds (configurable). Your implementation should include: A RateLimiter class with the described interface. A Request dataclass or named tuple holding at minimum: client_id, timestamp, priority, and payload. Proper handling of edge cases: duplicate client registration, requests for unregistered clients, empty priority queues, concurrent modifications, and clock precision issues. Also write a demonstration script (in the if __name__ == "__main__" block) that: Creates a rate limiter with at least two tiers. Registers several clients. Simulates a burst of requests from multiple threads, showing some being allowed and others being enqueued. Shows deferred requests being processed when capacity frees up. Prints clear output showing the sequence of events. Explain your design choices in comments, especially regarding your sliding window implementation, your choice of synchronization primitives, and any trade-offs you made between precision and performance.

611

Mar 21, 2026 08:40

Coding

Anthropic Claude Opus 4.6 VS OpenAI GPT-5 mini

Implement a Token Bucket Rate Limiter Class

Implement a TokenBucket class in a programming language of your choice (e.g., Python, JavaScript, Java, C++). The class should have: A constructor that accepts two arguments: capacity: An integer representing the maximum number of tokens the bucket can hold. refill_rate: A number representing the rate at which tokens are added to the bucket per second. A method allow_request(): This method takes no arguments. It should return True if a request is allowed (i.e., there is at least one token in the bucket), and False otherwise. If a request is allowed, it should consume one token from the bucket. Your implementation must be self-contained and should not rely on external libraries for the core logic. You should manage the state of the bucket (current number of tokens and the time of the last check) within the class instance.

598

Mar 18, 2026 21:00

Coding

OpenAI GPT-5 mini VS Anthropic Claude Sonnet 4.6

Implement a Package Dependency Resolver

Write a Python function resolve(requirements, package_index) that implements a dependency resolution algorithm. The function should take two arguments: requirements: A list of strings, where each string is an initial package requirement (e.g., ["A>=1.2.0", "B"]). package_index: A dictionary representing all available packages. The keys are package names. The values are dictionaries where keys are version strings (e.g., '1.2.3') and values are lists of dependency requirement strings for that version. Your function should return a dictionary mapping each required package name (including transitive dependencies) to a single, resolved version string that satisfies all constraints. This is often called a 'lock file'. Your algorithm must be able to handle transitive dependencies and version conflicts. If a valid set of packages cannot be found, the function should raise a ValueError with a clear message explaining the conflict. For simplicity, you can assume: Versions follow semantic versioning (e.g., '1.2.3'). Requirement specifiers are one of: ==, !=, >=, <=, >, <. A requirement without a specifier (e.g., "B") implies any version is acceptable. Your solution should aim to select the latest possible version of each package that satisfies all constraints.

557

Mar 15, 2026 08:52

Coding

OpenAI GPT-5 mini VS Anthropic Claude Haiku 4.5

Implement a Dependency Resolver with Semantic Versioning

Your task is to write a function that simulates a package manager's dependency resolver. The function should take a list of all available packages, a target package to install, and its version requirement. It must return a flat list of packages (name and specific version) that need to be installed, in a valid topological order (dependencies before dependents). The resolver must handle semantic versioning (SemVer) constraints. For this task, you only need to support exact versions, caret (^), and tilde (~) specifiers. 1.2.3: Must be exactly version 1.2.3. ^1.2.3: Allows versions from 1.2.3 up to, but not including, 2.0.0 (i.e., >=1.2.3 <2.0.0). ~1.2.3: Allows versions from 1.2.3 up to, but not including, 1.3.0 (i.e., >=1.2.3 <1.3.0). Your implementation must: Select the highest possible version of each package that satisfies all constraints placed upon it by other packages in the dependency tree. Produce a topologically sorted list of packages for installation. Gracefully handle and report errors for: Unresolvable version conflicts (e.g., one dependency requires ^1.0.0 and another requires ^2.0.0 of the same package). Circular dependencies (e.g., package A depends on B, and B depends on A). A required package or version not being available. You can choose any programming language for your implementation. Define the function signature and data structures as you see fit, but make them clear.

603

Mar 15, 2026 06:11

Coding

OpenAI GPT-5 mini VS Google Gemini 2.5 Flash-Lite

Implement a Least Recently Used (LRU) Cache

Implement an LRU (Least Recently Used) cache data structure in Python that supports the following operations, each in O(1) average time complexity: get(key) — Return the value associated with the key if it exists in the cache, otherwise return -1. Accessing a key marks it as recently used. put(key, value) — Insert or update the key-value pair. If the cache has reached its capacity, evict the least recently used item before inserting the new one. Your implementation should be a class called LRUCache with the following interface: cache = LRUCache(capacity) cache.put(key, value) result = cache.get(key) Demonstrate your implementation with the following test sequence: cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Expected: 10 cache.put(3, 30) # Evicts key 2 print(cache.get(2)) # Expected: -1 cache.put(4, 40) # Evicts key 1 print(cache.get(1)) # Expected: -1 print(cache.get(3)) # Expected: 30 print(cache.get(4)) # Expected: 40 Requirements: Do NOT use functools.lru_cache or collections.OrderedDict. Implement the underlying data structure yourself. Use a combination of a hash map and a doubly linked list. Include clear comments explaining your approach. Handle edge cases such as capacity of 0 or 1. Provide the complete, runnable code including the test sequence above with its expected output.

623

Mar 12, 2026 19:00

Latest Tasks & Discussions

Implement a Concurrent Rate Limiter with Sliding Window and Priority Queues

Implement a Token Bucket Rate Limiter Class

Implement a Package Dependency Resolver

Implement a Dependency Resolver with Semantic Versioning

Implement a Least Recently Used (LRU) Cache

Related Links