problem_id stringlengths 1 66 | category stringclasses 2
values | statement stringlengths 0 20.2k | config stringlengths 20 380 |
|---|---|---|---|
229 | algorithmic | Farmer John has found historical data from $n$ consecutive days. The temperature on the $i$-th day was $t_i$. He decides to make an analysis of historical temperatures and find a subsequence of days (not necessarily consecutive) where the temperature is strictly increasing.
Formally, FJ is interested in finding the le... | type: default
checker: chk.cc
checker_type: testlib
# Time and memory limits apply to the contestant's solution program.
time: 2s
memory: 512m
subtasks:
- score: 100
n_cases: 3
|
23 | algorithmic | # A=B
**Input file:** standard input
**Output file:** standard output
**Time limit:** 1 second
**Memory limit:** 512 megabytes
Marisa has learned an interesting language called **A=B**. She finds that this language has the advantages of simple syntax, easy to learn and convenient to code.
Here is the user ma... | type: default
time: 2s
memory: 512m
checker: check.cpp
cheker_type: testlib
subtasks:
- score: 100
n_cases: 1 |
231 | algorithmic | Differentiating Games
This is an interactive problem.
You are given an initial directed acyclic graph (DAG) with n vertices and m directed edges. Then the interactor secretly chooses a vertex v. Your goal is to determine v by asking queries about the result of a token-moving game played on the graph.
Before querying... |
type: interactive
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 15s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3
|
233 | algorithmic | Snake
This is an interactive problem.
You are given an integer n and an n×n grid of numbers G. The grid contains each number from 1 to n^2 exactly once.
------------------------------------------------------------
Snake movement
------------------------------------------------------------
Define a snake of length l ... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 5s # Interactive problems need more time for communication
memory: 256m
# The subtasks section works the same way
subtasks:
... |
239 | algorithmic | Problem Description:
You are given a directed graph G on vertices numbered $0$ to $n$. Initially, G contains exactly n edges of the
form $v → v + 1$. Your task is to add some edges to this graph in such a way that for every two vertices
$v, u (v < u)$ there exists a directed path from v to u consisting of at most three... | # Set the problem type to default (submit answer problems use default type)
type: default
# Specify the checker source file
checker: chk.cc
# Time and memory limits (for submit answer problems, these may not be strictly enforced)
time: 2s
memory: 512m
# The subtasks section
subtasks:
- score: 100
n_cases: 4 #... |
24 | algorithmic | Time limit: 1 seconds
Memory limit: 512 megabytes
Bobo has an n×n symmetric matrix C consisting of zeros and ones. For a permutation p_1, ..., p_n of 1, ..., n, let c_i=(C_{p_i, p_{i+1}} for 1 ≤ i < n, C_{p_n, p_1} for i = n).
The permutation p is almost monochromatic if and only if the number of indices i (1 ≤ i < n) ... | type: default
time: 1s
memory: 512m
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
241 | algorithmic | Given the truth table of a boolean function with n boolean variables as input, construct an expression
that satisfies this function. In the expression, you are only allowed to use the logical and (&) and logical
or (|) operators.
Specifically, a truth table of a boolean function with n boolean variables gives all the $... | # Set the problem type to default (submit answer problems use default type)
type: default
# Specify the checker source file
checker: chk.cc
# Time and memory limits (for submit answer problems, these may not be strictly enforced)
time: 2s
memory: 512m
# The subtasks section
subtasks:
- score: 100
n_cases: 5 #... |
243 | algorithmic | You are given a map of an area consisting of unit squares, where each square is either open or occupied by a wall.
At the beginning, you are placed in one of the open unit squares, but you do not know which square it is or what direction you face.
Any two individual open spaces are indistinguishable, and likewise for... | type: interactive
interactor: interactor.cc
time: 15s
memory: 1024m
subtasks:
- score: 100
n_cases: 4
|
245 | algorithmic | Asesino
This is an interactive (scored) problem.
There are n players, numbered 1..n. Each player has exactly one role:
- Knight: always tells the truth.
- Knave: always lies.
- Impostor: a special Knave whom everybody thinks is a Knight.
There is exactly one Impostor. The remaining players are Knights or Knaves (po... |
type: interactive
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 10s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3
|
247 | algorithmic | # Problem Statement
You are given two integer sequences of length $N$: $A=(A_1, A_2, \dots, A_N)$ and $B=(B_1, B_2, \dots, B_N)$.
You may perform operations of the following kind:
* Choose a pair of integers $(i, j)$ with $1 \le i < j \le N$.
* Replace $A_i$ with $A_j - 1$ and $A_j$ with $A_i + 1$.
Your goal is to ... | # Set the problem type to default (submit answer problems use default type)
type: default
# Specify the checker source file
checker: chk.cc
# Time and memory limits (for submit answer problems, these may not be strictly enforced)
time: 2s
memory: 512m
# The subtasks section
subtasks:
- score: 100
n_cases: 5 #... |
248 | algorithmic | # Drone Delivery
## Problem Description
With the continuous emergence of new applications in low-altitude economy, drones have played an important role in express delivery, medical supplies transportation, and other areas. Each city has a vertical drone terminal building with several landing points distributed on it.... | # Set the problem type to default (submit answer problems use default type)
type: default
# Specify the checker source file
checker: chk.cc
# Time and memory limits (for submit answer problems, these may not be strictly enforced)
time: 15s
memory: 512m
# The subtasks section
subtasks:
- score: 100
n_cases: 4 ... |
249 | algorithmic | Problem: X-OR
Time limit: 1 second
Memory limit: 256 MB
This is an interactive problem!
Ehab has a hidden permutation p of length n consisting of the elements from 0 to n-1. You, for some reason, want to figure out the permutation.
To do that, you can give Ehab 2 different indices i and j, and he'll reply with (p_... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 1s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
25 | algorithmic | Time limit: 2 seconds
Memory limit: 512 megabytes
This is an interactive problem, where your program and the judge interact via standard input and output.
In the kingdom of Duloc, Lord Farquaad is developing a network of watchtowers to monitor every corner of his land. He has a map of towers and the roads that connect ... | type: interactive
time: 2s
memory: 512m
# A custom checker is required for the special scoring.
checker: interactor.cc
subtasks:
- score: 100
n_cases: 3 |
252 | algorithmic | Hotel
This is an interactive scored problem.
There are n rooms in a hotel, numbered 1..n. In each room i there is a teleporter that sends you to room a_i
(1 <= a_i <= n; it is possible that a_i = i). You do NOT know the values of a_1..a_n.
Brian is currently in room 1.
If Michael starts in some room x, then both Mi... |
type: interactive
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 10s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3
|
253 | algorithmic | Roads
This is an interactive problem.
There are n intersections and m bidirectional roads, numbered 1..m.
Road i connects intersections a_i and b_i.
Some (unknown) subset of the roads has been repaired. You do NOT know which roads are repaired.
The only information you have is:
- Using ONLY repaired roads, the city... |
type: interactive
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 3s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3
|
254 | algorithmic | Problem: Pepe Racing
Time limit: 5 seconds
Memory limit: 256 MB
This is an interactive problem.
There are n^2 pepes labeled 1, 2, ..., n^2 with pairwise distinct speeds. You would like to set up some races to find out the relative speed of these pepes.
In one race, you can choose exactly n distinct pepes and make ... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 5s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
255 | algorithmic | Problem: Magnets
Time limit: 1 second
Memory limit: 256 MB
This is an interactive problem.
Kochiya Sanae is playing with magnets.
Realizing that some of those magnets are demagnetized, she is curious to find them out.
There are n magnets, which can be of the following 3 types:
- N
- S
- - (these magnets are demagne... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 1s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
256 | algorithmic | Problem: Palindromic Paths
Time limit: 1 second
Memory limit: 256 MB
This is an interactive problem.
You are given a grid n * n, where n is odd. Rows are enumerated from 1 to n from up to down, columns are enumerated from 1 to n from left to right. Cell, standing on the intersection of row x and column y, is denote... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 1s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
257 | algorithmic | Problem: Omkar and Modes
Time limit: 3 seconds
Memory limit: 256 MB
This is an interactive problem.
Ray lost his array and needs to find it by asking Omkar. Omkar is willing to disclose that the array has the following qualities:
1. The array has n (1 <= n <= 2 * 10^5) elements.
2. Every element in the array a_i is... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 3s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
258 | algorithmic | Problem: Network Synchronization: Finding Dual Anomalies
This is an interactive task.
[Background]
You are managing a distributed network consisting of $n$ server nodes, indexed from 1 to $n$. The network is structured as a tree (a connected graph with $n-1$ edges and no cycles). Two specific, distinct nodes in this ... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 2s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
26 | algorithmic | OgreSort
You need to sort a permutation v of length n. All elements of the permutation are indexed from 1 to n.
The only permitted type of move allows you to take an element from some position x and insert it at
another position y, shifting all elements in between by one. The cost of such a move is y.
Formally, a move... | type: default
time: 2s
memory: 512m
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
263 | algorithmic | ```markdown
# Sasha’s Smudged Multiplication Poster (Optimization)
## Problem
To learn multiplication, Big Ben printed a gigantic poster of a multiplication table created from his favorite integers collected over CALICO's 5 year history. Unfortunately the poster was damaged and now he's very sad :( Many entries were l... | checker: chk.cc
memory: 256m
subtasks:
- n_cases: 10
score: 100
time: 10s
type: default
|
27 | algorithmic | # Problem
You are given an n by m grid. You want to place as many black points (cells) as possible so that no four of them form the four corners of an axis-parallel rectangle.
Formally, if you place black points at positions (r, c) with 1 ≤ r ≤ n and 1 ≤ c ≤ m, your set S of chosen positions must not contain four dis... | type: default
# The time limit is now 1 second.
time: 1s
memory: 512m
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
28 | algorithmic | Hacking the Project
Input file: standard input
Output file: standard output
Time limit: 1 second
Memory limit: 512 mebibytes
This is an interactive problem.
Lewis is one of the developers of the new programming language called DiverC. The main feature of the
program written in this language is that the code consists of p... | type: interactive
time: 1s
memory: 512m
subtasks:
- score: 100
n_cases: 3
interactor: interactor.cc
checker_type: testlib |
3 | algorithmic | This is an interactive question.
time limit: 10 seconds (up to 5 seconds for interactive library)
Space limitations: 1GB (up to 64MB for interactive library)
Description
Hope City is a city built on a floating island. At the edge of the floating island, there are n lamp sockets evenly distributed, forming a ring shap... | type: interactive
time: 10s
memory: 1024m
# A custom checker is required for the special scoring.
interactor: interactor.cc
subtasks:
- score: 100
n_cases: 3 |
30 | algorithmic | This is an interactive problem.
You are given a tree of n
nodes with node 1
as its root node.
There is a hidden mole in one of the nodes. To find its position, you can pick an integer x
(1≤x≤n
) to make an inquiry to the jury. Next, the jury will return 1
when the mole is in subtree x
. Otherwise, the judge will ... | type: interactive
time: 4s
memory: 256m
subtasks:
- score: 100
n_cases: 3
interactor: interactor.cc
checker_type: testlib |
33 | algorithmic | Permutation (Modified Version)
Time Limit: 5 s
Memory Limit: 1024 MB
The Pharaohs use the relative movement and gravity of planets to accelerate their spaceships. Suppose a spaceship will pass by some planets with orbital speeds in order. For each planet, the Pharaohs' scientists can choose whether to accelerate the ... | type: default
time: 5s
memory: 1024m
subtasks:
- score: 100
n_cases: 3
checker: checker.cpp
checker_type: testlib |
35 | algorithmic | Language: C++ only
Time limit per test: 5 seconds
Memory limit per test: 1024 megabytes
This is an interactive problem.
There is a hidden array a containing all the numbers from 1 to n, and all of them appear twice except one (which only appears once).
You can ask queries in the following format, where S is a subse... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 5s
memory: 1024m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ..... |
36 | algorithmic | Hack!
This is an I/O interactive problem. I/O interaction refers to interactive problems, where the program communicates with a special judge during execution instead of producing all output at once. In these problems, the program sends queries (output) to the judge and must immediately read responses (input) before c... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 3s
memory: 1024m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ..... |
4 | algorithmic | Problem: Matrix k-th Smallest (Interactive)
You are given an unknown n×n matrix a. You must find the k-th smallest value among all a[i][j].
You cannot read the matrix directly. Instead, you must interact with the judge using the protocol below.
The matrix satisfies:
for all i<=n and j<n: a{i,j}<=a{i,j+1}
for all i<n a... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 5s
memory: 1024m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ...... |
40 | algorithmic | Interactive RBS
This is an I/O interactive problem. I/O interaction refers to interactive problems, where the program communicates with a special judge during execution instead of producing all output at once. In these problems, the program sends queries (output) to the judge and must immediately read responses (input... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 2s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ...... |
41 | algorithmic | # Problem
Anton owns \(n\) umbrellas, each labeled with a distinct integer from \(1\) to \(n\). He wants to arrange some of them in a line to form a brilliant sequence of umbrellas (BSU).
A sequence of \(k\) umbrellas with numbers \(a_1, a_2, \ldots, a_k\) is a BSU if:
- \(a_i > a_{i-1}\) for all \(2 \le i \le k\);
... | type: default
# The time limit is now 1 second.
time: 1s
memory: 512m
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
42 | algorithmic | Problem
You are given an integer n. Place n unit squares (side length 1) inside an axis-parallel square container of side length L so that:
- Every unit square lies entirely inside the container.
- Unit squares have no common interior points (touching edges/corners is allowed).
- Each unit square may be rotated by an a... | type: default
# The time limit is now 1 second.
time: 1s
memory: 512m
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
43 | algorithmic | Bigger Sokoban 40k
Time Limit: 2 seconds
Memory Limit: 1024 MB
Problem
Sokoban is a famous puzzle game where a player moves around in a grid and pushes boxes to their storage locations.
Bigger Sokoban is a variation of Sokoban where both the boxes and the storage locations are larger than 1×1.
In this version, both b... | type: default
time: 2s
memory: 1024m
subtasks:
- score: 100
n_cases: 1
checker: chk.cpp
checker_type: testlib |
44 | algorithmic | Problem: Traveling Santa with Carrot Constraint
Story
Rudolph plans to shorten Santa’s route by choosing a better order to visit cities. Every 10th step takes 10% longer unless that step starts from a prime-numbered city. Your task is to output a valid tour and compete on how much you improve over a strengthened basel... | type: default
# The time limit is now 1 second.
time: 2.5s
memory: 512m
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
45 | algorithmic | Problem: Balanced Graph Partitioning (DIMACS10-style, EC & CV)
Overview
--------
You are given an undirected, unweighted graph G = (V, E) and an integer k (a power of two).
Assign each vertex to one of k parts so that:
1) the balance constraint is satisfied, and
2) two quality measures are minimized with equal imp... | type: default
time: 1s
memory: 512m
checker: chk.cc
subtasks:
- score: 1
n_cases: 3
|
46 | algorithmic | Title: Job Shop Scheduling (JSPLIB-style) — Open Optimization Track
Overview
--------
You are given a classic Job Shop Scheduling Problem (JSSP). There are J jobs and M machines.
Each job must be processed exactly once on each machine, in a job-specific order (its *route*).
Processing is non-preemptive. A machine can ... | type: default
# The time limit is now 1 second.
time: 1s
memory: 512m
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 1
n_cases: 3
|
47 | algorithmic | 2D Rectangular Knapsack with (Optional) 90° Rotations — Official Problem Statement (Hard Set)
============================================================================================
Summary
-------
You are given a single rectangular **bin** and several **item types**. Each item type t has
dimensions (w_t, h_t), p... | type: default
time: 1s
memory: 512m
checker: chk.cc
subtasks:
- score: 1
n_cases: 3
|
48 | algorithmic | Sphere Packing in a Cube (Optimization)
You are given an integer n. Place n pairwise-disjoint congruent solid spheres inside the unit cube [0, 1]^3 so that the common radius is as large as possible. You do not need to output the radius explicitly; the checker infers the largest valid common radius from your centers.
... | type: default
time: 1s
memory: 512m
checker: chk.cc
subtasks:
- score: 1
n_cases: 3
|
5 | algorithmic | Problem: Hamiltonian Path Challenge
You are given a directed graph with n vertices and m edges.
Your task is to find a path that visits each vertex exactly once.
If it is not possible to find a Hamiltonian path, you should instead output a path that is as long as possible and does not repeat vertices.
--------... | type: default
time: 4s
memory: 512m
checker: chk.cc
cheker_type: SPJ
subtasks:
- score: 100
n_cases: 3 |
50 | algorithmic | Time Limit: 10s
Memory Limit: 1024M
Firstly, you are given two integers n (1 <= n <= 400) and m (1 <= m <= 4000), which means that you have n elements and m sets.
After that, there are m integers, the i-th integer is the cost of choosing the i-th set.
After that, for the i-th element, firstly input an integer k_i, w... | type: default
time: 10s
memory: 1024m
subtasks:
- score: 100
n_cases: 3
checker: chk.cc
checker_type: testlib
filename: std.cc |
52 | algorithmic | Geemu
This is an interactive problem.
Little A has an interesting game.
Initially, there is a permutation p of length n. You don't know the permutation p, and you need to determine the final p through the following operations:
1. Query the number of value-contiguous segments in a given interval.
2. Swap two elements ... | type: interactive
interactor: interactor.cc
time: 2s
memory: 512m
subtasks:
- score: 100
n_cases: 3 |
53 | algorithmic | Problem: G2. Inter Active (Hard Version)
Time limit: 2 seconds
Memory limit: 512 MB
This is the hard version of the problem. The difference between the versions is that in this version, you can make at most 10 * n queries. You can hack only if you solved all versions of this problem.
Ali loved Bahamin's gift (from ... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 2s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 1 # Looks for 1.in, 2.in, ... ... |
54 | algorithmic | Problem: Centroid Guess
Time limit: 4 seconds
Memory limit: 512 MB
This is an interactive problem.
There is an unknown tree consisting of n nodes, which has exactly one centroid.
You only know n at first, and your task is to find the centroid of the tree.
You can ask the distance between any two vertices. However,... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 4s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 1 # Looks for 1.in, 2.in, ... ... |
57 | algorithmic | time limit per test: 5 seconds
memory limit per test: 1024 megabytes
**Submissions are only allowed in C++ language.**
This problem is interactive.
Baudelaire is very rich, so he bought a tree of size n, rooted at some arbitrary node. Additionally,
every node has a value of 1 or -1.
Cow the Nerd saw the tree and fe... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 5s
memory: 1024m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ..... |
58 | algorithmic | Inverse Counting Path
Walk Alone is an expert in dynamic programming, but he gets bored with traditional dynamic programming problem like counting paths on a 2-dimension grid, so he wants to do it in reverse. The problem he raised is as follows:
On a 2-dimension grid of size n*n, originally you are on grid (1,1). The... | # Set the problem type to interactive
type: default
# Specify the interactor source file
interactor: chk.cc
# Time and memory limits still apply to the contestant's solution
time: 1s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... 5.in |
59 | algorithmic | # Limited Shuffle Restoring
**Input file:** standard input
**Output file:** standard output
**Time limit:** 3 seconds
**Memory limit:** 512 meblbytes
**This is an interactive problem.**
Bobo had an array \\( a \\), initially equal to \\((1,2,\ldots,n)\\). He did the following operations with the array.
- Fo... | type: interactive
time: 3s
memory: 512m
interactor: interactor.cpp
interactor_type: testlib
subtasks:
- score: 100
n_cases: 3 |
6 | algorithmic | worldmap
Day 1 Tasks
English (ISC)
World Map
Mr. Pacha, a Bolivian archeologist, discovered an ancient document near Tiwanaku that describes
the world during the Tiwanaku Period (300-1000 CE). At that time, there were N countries,
numbered from 1 to N.
In the document, there is a list of M different pairs of adjacent co... | type: default
time: 1s
memory: 2048m
subtasks:
- score: 100
n_cases: 3
checker: chk.cc
checker_type: testlib
filename: std.cc |
60 | algorithmic | ```markdown
# Problem K: Probing the Disk
**Time Limit: 2 seconds**
*This is an interactive problem.*
A thin black disk is laid flat on the square bottom of a white box. The sides of the box bottom are 10^5 units long.
Somehow, you are not allowed to look into the box, but you want to know how large the disk is and... | type: interactive
time: 3s
memory: 512m
interactor: interactor.cpp
interactor_type: testlib
subtasks:
- score: 100
n_cases: 3 |
61 | algorithmic | # Let's Go! New Adventure
**Input file:** standard input
**Output file:** standard output
**Time limit:** 3 seconds
**Memory limit:** 1024 megabytes
In Pigeland, Pishin is a popular open-world action RPG where users can play multiple characters. Each character has an independent adventure rank, which increases ... | type: default
time: 3s
memory: 1024m
checker: check.cpp
cheker_type: testlib
subtasks:
- score: 100
n_cases: 10 |
62 | algorithmic | Ball Moving Game
Xiao C is playing a ball-moving game. In front of him, there are n + 1 pillars, numbered from 1 to n + 1. On each of the first n pillars, there are m balls placed from bottom to top, while pillar (n + 1) initially has no balls. Altogether there are n × m balls in n different colors, with exactly m bal... | # Set the problem type to interactive
type: default
# Specify the interactor source file
interactor: chk.cc
# Time and memory limits still apply to the contestant's solution
time: 1s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... 5.in |
63 | algorithmic | Space Thief
This is an I/O interactive problem. I/O interaction refers to interactive problems, where the program communicates with a special judge during execution instead of producing all output at once. In these problems, the program sends queries (output) to the judge and must immediately read responses (input) be... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 2s
memory: 1024m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ..... |
64 | algorithmic | Given (1 <= n <= 1e2) and (B = 1e15), n integers a_1 … a_n (0 <= a_i <= B) drawn from either (normal, uniform, pareto, exponential) distributions, find a subset of a_1..a_n that sums as close as possible to T=x_i*a_i, x_i drawn from Bernoulli (1/2).
Score = 100 * (15 - log(error + 1)) / 15
25% of the test cases will ... | type: default
# The time limit is now 1 second.
time: 10s # Let asymtotics beat constant factor and heuristic BS
memory: 1024m # 1GB should be enough for checkpointing backtrack
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
68 | algorithmic | Pen
This is an I/O interactive problem. I/O interaction refers to interactive problems, where the program communicates with a special judge during execution instead of producing all output at once. In these problems, the program sends queries (output) to the judge and must immediately read responses (input) before con... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 5s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ...... |
69 | algorithmic | Time limit per test: 10 seconds
Memory limit per test: 256 megabytes
Note: The only difference between versions of this problem is the maximum value of n.
Overview
Professor Vector is preparing to teach her Arithmancy class. She needs to prepare n distinct magic words for the class. Each magic word is a string over th... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 10s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ...... |
7 | algorithmic | Build a Computer
Input file: standard input
Output file: standard output
Time limit: 1 second
Memory limit: 1024 megabytes
You want to build a computer to achieve a specific functionality: Given an integerx, determine whether
x lies within the interval[L, R]. To accomplish this, you designed a directed acyclic graph (DAG)... | type: default
time: 1s
memory: 1024m
subtasks:
- score: 100
n_cases: 1
checker: chk.cc
checker_type: testlib
filename: std.cc |
70 | algorithmic | Problem: Treasure Hunt
Time limit: 5 seconds
Memory limit: 256 MB
This is an interactive problem.
Imagine you are a treasure hunter exploring an ancient map represented as an undirected graph with n vertices (junctions) and m edges (roads). You start at a known fixed vertex. Your goal is to visit every vertex in th... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 5s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
72 | algorithmic | Puzzle
There is a puzzle game. The board is a 6 × 6 grid with grooves in the tiles to allow vehicles to slide. Cars and trucks are both one square wide, but cars are two squares long and trucks are three squares long. Vehicles can only be moved forward or backward along a straight line on the grid. The goal of the gam... | type: default
time: 2s
memory: 1024m
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
73 | algorithmic | Inversion
Description
This is an interactive problem.
There is a hidden permutation p1, p2, ..., pn of {1, 2, ..., n}.
You want to find it by asking for the parity (even or odd) of the number of inversions in a subarray pl, ..., pr.
You can query in the format:
0 l r
and the interactor will respond with
(sum over a... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 1s
memory: 1024m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ..... |
75 | algorithmic | Black and White
Time limit: 2 seconds
Memory limit: 256 megabytes
------------------------------------------------------------
The jury has a great artistic idea — to create a rectangular
panel out of a huge pile of black and white squares of the
same size. The panel should have exactly b 4-connected areas
made of bl... | # Set the problem type to interactive
type: default
# Specify the interactor source file
interactor: chk.cc
# Time and memory limits still apply to the contestant's solution
time: 2s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 1 # Looks for 1.in, 2.in, ... 5.in |
77 | algorithmic | Problem:
Time limit: 3 seconds
Memory limit: 512 megabytes
The popular improv website Interpretation Impetus hosts regular improv contests and maintains a rating
of the best performers. However, since improv can often go horribly wrong, the website is notorious for
declaring improv contests unrated. It now holds a wage... | type: interactive
time: 3s
memory: 512m
subtasks:
- score: 100
n_cases: 3
interactor: interactor.cc
checker_type: testlib |
79 | algorithmic | Problem H. Hack
Time limit: 10 seconds
Heidi is analyzing a peculiar device. This device takes an `a` as input and computes `a^d (mod n)` using the following pseudocode and some integers `d` and `n` stored in this device:
```
1 modPow(a, d, n) {
2 r=1;
3 for (i=0;i<60;++i) {
4 if ((d&(1<<i))!=0) {
5 r=r... | type: interactive
time: 10s
memory: 128m
subtasks:
- score: 100
n_cases: 3
interactor: interactor.cc
checker_type: testlib |
8 | algorithmic | The Empress
Capoo invented an interesting language named Push-Pop. This language is an interpreted language. The interpreter starts with an empty stack with infinite capacity and reads the first instruction of the custom program. There are only two kinds of instructions in this language:
POP a GOTO x PUSH b GOTO y
I... | # Set the problem type to interactive
type: default
# Specify the interactor source file
checker: chk.cc
# Time and memory limits still apply to the contestant's solution
time: 2s
memory: 1024m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... 5.in |
80 | algorithmic | Indiana Jones and the Uniform Cave
This is an I/O interactive problem. I/O interaction refers to interactive problems, where the program communicates with a special judge during execution instead of producing all output at once. In these problems, the program sends queries (output) to the judge and must immediately re... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cpp
# Time and memory limits still apply to the contestant's solution
time: 2s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 1 # Looks for 1.in, 2.in, ...... |
81 | algorithmic | Time Limit: 2 s
Memory Limit: 1024 MB
This is an interactive problem.
Bitaro found out that a string S of length N was written on the stone slate. Each character of the string is either ‘0’ or ‘1’. However, he does not yet know each character of the string S.
Bibako found out how to use the machine. To use it, we put t... | type: interactive
time: 2s
memory: 1024m
# A custom checker is required for the special scoring.
checker: interactor.cc
subtasks:
- score: 100
n_cases: 3 |
82 | algorithmic | Problem
Joe chose a hidden permutation p of length n consisting of all integers from 0 to n−1 (each used exactly once).
Your goal is to recover the entire permutation.
Interactive Protocol
• You may query two distinct indices i and j (1 ≤ i, j ≤ n, i ≠ j).
• To ask a question, print: ? i j
• The interactor rep... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 1s
memory: 256m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
83 | algorithmic | # Function
## Problem Description
Construct a **completely multiplicative function** \( f \) (that is, \( f(xy) = f(x)f(y) \)) such that \(|f(i)| = 1\) for all \(i\), and **minimize**
\[
\max_{1 \le k \le n} \left| \sum_{i=1}^k f(i) \right|.
\]
## Input
A single integer \( n \).
## Output
Output \( n \) integers... | type: default
time: 3s
memory: 1024m
checker: check.cpp
cheker_type: testlib
subtasks:
- score: 100
n_cases: 1 |
85 | algorithmic | Maze
Time limit: 2s
Memory limit: 512MB
3.1 Background
The subject of this work is SCP-167. It is recommended to review information about SCP-167 before proceeding with the work.
3.2 Description
SCP-167 can be roughly described as a point connected to an infinitely deep binary tree, as shown in the figure below.
Lev... | type: interactive
time: 2s
memory: 512m
subtasks:
- score: 100
n_cases: 1
interactor: interactor.cc
checker_type: testlib |
86 | algorithmic | Hidden Tree
This is an interactive problem.
There is a hidden tree with n nodes. The nodes are numbered from 1 to n. Your task is to discover the structure of this tree by asking queries.
Each query consists of three distinct node numbers. The interactor will return the node that minimizes the sum of distances to th... | type: interactive
interactor: interactor.cc
time: 2s
memory: 512m
subtasks:
- score: 100
n_cases: 3 |
87 | algorithmic | Graph Coloring
You are given an undirected graph G with n nodes. Each node is colored either black (0) or white (1). You are given the initial coloring state and the target coloring state. Your task is to transform the graph from the initial state to the final state using a sequence of valid transformations.
In one t... | type: default
time: 2s
memory: 512m
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
89 | algorithmic | Problem: Tree Reconstruction via Steiner-Membership Queries
Time limit: 3 seconds
Memory limit: 512 MB
This is an interactive problem.
You are given an unknown unweighted tree T with n labeled vertices V = {1, 2, ..., n}. Your task is to determine all edges of T by interacting with a judge.
Definition
For any subse... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 3s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
9 | algorithmic | Time limit:1 second Memory limit:1024 megabytes
Bobo is given a tree T = (V, E) of n vertices, where there is a number pi on vertex i initially, and p1, p2,..., pn is a permutation of 1 to n, meaning that all integers from 1 to n appear exactly once in p1, p2, ..., pn.
In each operation, Bobo can select a matching M... | type: default
time: 1s
memory: 1024m
# A custom checker is required for the special scoring.
checker: chk.cc
subtasks:
- score: 100
n_cases: 3 |
93 | algorithmic | Greedy
Time limit: 7 seconds
Memory limit: 512 MB
This is an interactive problem. All communication is via standard input/output (no input/output files).
Story
Little U tackles an optimization on trees but only has a greedy “black box.” You must reconstruct the hidden tree using queries to this black box.
Core Probl... | # Set the problem type to interactive
type: interactive
# Specify the interactor source file
interactor: interactor.cc
# Time and memory limits still apply to the contestant's solution
time: 7s
memory: 512m
# The subtasks section works the same way
subtasks:
- score: 100
n_cases: 3 # Looks for 1.in, 2.in, ... ... |
cant_be_late/high_availability_loose_deadline_large_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/high_availability_loose_deadline_small_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/high_availability_tight_deadline_large_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/high_availability_tight_deadline_small_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/low_availability_loose_deadline_large_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/low_availability_loose_deadline_small_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/low_availability_tight_deadline_large_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/low_availability_tight_deadline_small_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/mixed_availability_loose_deadline_large_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/mixed_availability_loose_deadline_small_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/mixed_availability_tight_deadline_large_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late/mixed_availability_tight_deadline_small_overhead | research | Cant-Be-Late Scheduling Problem
================================
Problem Setting
--------
You are given a long-running compute job that must complete before a fixed **hard deadline**.
At each time step, you must choose which type of cloud compute resource to use:
- **Spot instances**
- Very cheap
- May become un... | dependencies:
uv_project: ../common/cant-be-late-simulator
datasets:
- type: local_tar
path: ../common/real_traces.tar.gz
target: ../common/cant-be-late-simulator/data
expected_glob: "real/ddl=search+task=48+overhead=*/real/*/traces/random_start/*.json"
tag: os
|
cant_be_late_multi/high_availability_loose_deadline_large_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cant_be_late_multi/high_availability_loose_deadline_small_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cant_be_late_multi/high_availability_tight_deadline_large_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cant_be_late_multi/high_availability_tight_deadline_small_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cant_be_late_multi/low_availability_loose_deadline_large_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cant_be_late_multi/low_availability_loose_deadline_small_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cant_be_late_multi/low_availability_tight_deadline_large_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cant_be_late_multi/low_availability_tight_deadline_small_overhead | research | Cant-Be-Late Multi-Region Scheduling Problem
================================
Problem Setting
---------------
You are given a long-running compute job that must complete before a fixed hard deadline.
At each time step, you must choose which AWS region to run in and which type of cloud compute resource to use:
- **Sp... | {
"dependencies": {
"uv_project": "../common/cant-be-late-simulator"
},
"datasets": [
{
"type": "local_tar",
"path": "../common/real_traces.tar.gz",
"target": "../common/cant-be-late-simulator/data",
"expected_glob": "converted_multi_region_aligned/*/0.json"
}
],
"tag": "os... |
cloudcast | research | Cloudcast Broadcast Optimization Problem
========================================
Problem Setting
---------------
Design broadcast topology optimization for multi-cloud data distribution. Given a source node and multiple destination nodes across AWS, Azure, and GCP, find the optimal broadcast paths that minimize trans... | {
"dependencies": {
"uv_project": "resources"
},
"datasets": [],
"tag": "ai"
}
|
cross_entropy | research | Cross Entropy Optimization Problem
====================================
Problem Setting
---------------
Design and optimize high-performance Triton kernels for Cross Entropy loss computation on GPU. This problem focuses on implementing efficient cross entropy loss kernels using Triton's JIT compilation system.
The ch... | dependencies:
uv_project: resources
tag: hpc
runtime:
environment: "Triton 3.2.0 with CUDA 12.2 (triton-tlx image)"
docker:
image: andylizf/triton-tlx:tlx-nv-cu122
gpu: true
|
decoding_attn | research | Decoding Attention Optimization Problem
========================================
Problem Setting
---------------
Design and optimize high-performance Triton kernels for Decoding Attention computation on GPU. This problem focuses on implementing efficient attention kernels for decoder-only transformer models using Trit... | dependencies:
uv_project: resources
tag: hpc
runtime:
environment: "Triton 3.2.0 with CUDA 12.2 (triton-tlx image)"
docker:
image: andylizf/triton-tlx:tlx-nv-cu122
gpu: true
|
flash_attn | research | Flash Attention Optimization Problem
=====================================
Problem Setting
---------------
Design and optimize high-performance Triton kernels for Flash Attention computation on GPU. This problem focuses on implementing efficient attention kernels with causal masking support using Triton's JIT compilat... | dependencies:
uv_project: resources
tag: hpc
runtime:
environment: "Triton 3.2.0 with CUDA 12.2 (triton-tlx image)"
docker:
image: andylizf/triton-tlx:tlx-nv-cu122
gpu: true
|
fused_linear_ce | research | Fused Linear Cross Entropy Optimization Problem
===============================================
Problem Setting
---------------
Design and optimize high-performance Triton kernels for Fused Linear Cross Entropy loss computation on GPU. This problem focuses on implementing efficient fused kernels that combine matrix mu... | dependencies:
uv_project: resources
tag: hpc
runtime:
environment: "Triton 3.2.0 with CUDA 12.2 (triton-tlx image)"
docker:
image: andylizf/triton-tlx:tlx-nv-cu122
gpu: true
|
fused_linear_jsd | research | Fused Linear Jensen-Shannon Divergence Optimization Problem
==========================================================
Problem Setting
---------------
Design and optimize high-performance Triton kernels for Fused Linear Jensen-Shannon Divergence (JSD) computation on GPU. This problem focuses on implementing efficient ... | dependencies:
uv_project: resources
tag: hpc
runtime:
environment: "Triton 3.2.0 with CUDA 12.2 (triton-tlx image)"
docker:
image: andylizf/triton-tlx:tlx-nv-cu122
gpu: true
|
gdpa_attention | research | GDPA Attention Optimization Problem
===================================
Problem Setting
---------------
Design and optimize high-performance Triton kernels for GDPA (Gated Dot-Product Attention) computation on GPU. This problem focuses on implementing efficient attention kernels with gated Q and K tensors using Triton... | dependencies:
uv_project: resources
tag: hpc
runtime:
environment: "Triton 3.2.0 with CUDA 12.2 (triton-tlx image)"
docker:
image: andylizf/triton-tlx:tlx-nv-cu122
gpu: true
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.