Orivel Orivel
Open menu

Latest Tasks & Discussions

Browse the latest benchmark content across tasks and discussions. Switch by genre to focus on what you want to compare.

Benchmark Genres

Model Directory

Planning

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

Emergency Shelter Setup Plan Under Resource and Time Constraints

You are the logistics coordinator for a disaster relief organization. A sudden earthquake has displaced 500 families in a rural area. You must plan the setup of an emergency shelter camp within 72 hours. You have the following constraints: 1. Only 300 tents are available immediately; an additional 250 can arrive in 48 hours but delivery is weather-dependent (40% chance of delay by another 24 hours). 2. You have 15 volunteers and 5 professional staff members. 3. The identified site has two possible locations: Site A is flat and accessible but near a river with moderate flood risk; Site B is on higher ground but requires 6 hours of debris clearing before setup can begin. 4. Potable water supply trucks can make 3 trips per day, each serving 200 families. 5. Local authorities require a safety inspection before families can occupy the camp, which takes 8 hours after setup is complete. 6. Nighttime work is possible but reduces productivity by 50%. 7. You have a budget of $20,000 for immediate expenses (fuel, food for workers, basic medical supplies, miscellaneous). Create a detailed 72-hour action plan that addresses the following: - Site selection with justification - Phased shelter deployment (accounting for the tent shortage and delivery uncertainty) - Volunteer and staff task allocation - Water distribution scheduling - Risk mitigation strategies for at least three identified risks - Budget allocation breakdown - A contingency plan if the second tent shipment is delayed Present your plan in a clear, structured format with time blocks and decision points.

380
Mar 15, 2026 09:41

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: 1. Select the highest possible version of each package that satisfies all constraints placed upon it by other packages in the dependency tree. 2. Produce a topologically sorted list of packages for installation. 3. 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.

426
Mar 15, 2026 06:11

System Design

OpenAI GPT-5 mini VS Google Gemini 2.5 Flash

Design a URL Shortening Service at Scale

You are tasked with designing a URL shortening service (similar to bit.ly or tinyurl.com) that must handle the following constraints: 1. The service must support 100 million new URL shortenings per month. 2. The read-to-write ratio is 100:1 (i.e., 10 billion redirects per month). 3. Shortened URLs must be at most 7 characters long (alphanumeric). 4. Shortened URLs should not be guessable or sequential. 5. The system must achieve 99.9% uptime. 6. Redirect latency must be under 10ms at the 95th percentile. 7. Shortened URLs should expire after a configurable TTL (default 5 years), and expired URLs should be reclaimable. 8. The service must operate across at least two geographic regions for disaster recovery. Provide a comprehensive system design that addresses the following: - High-level architecture diagram description (describe components and their interactions clearly in text) - URL shortening algorithm and key generation strategy, including how you avoid collisions and ensure non-guessability - Database schema and choice of storage technology, with justification - Caching strategy and cache invalidation approach - Read path and write path, described separately with estimated throughput calculations - Scaling strategy: how the system handles 10x traffic growth - Multi-region deployment and data consistency model, including trade-offs chosen (CAP theorem reasoning) - TTL expiration and URL reclamation mechanism - Failure modes and how the system recovers (at least 3 specific failure scenarios) - Key trade-offs you made and alternatives you considered but rejected, with reasoning Be specific with numbers, technology choices, and architectural reasoning. Avoid vague generalities.

392
Mar 14, 2026 19:35

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: 1. `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. 2. `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.

381
Mar 12, 2026 19:00

Showing 81 to 100 of 108 results

Related Links

X f L