brain

We are given many independent ranges of integers. For each range $[l, r]$, we need to pick two different integers $x$ and $y$ inside this interval such that their least common multiple is also inside the same interval.

We are given a string of digits and allowed to delete characters anywhere we like, preserving order of the remaining ones. The goal is to transform the string into a special form called “good”.

We are given multiple independent queries, each asking whether a target number can be broken into four distinct positive integers.

We are given a directed structure over indices from 1 to n, where each index i has a value a[i] and a pointer b[i]. The pointer either leads to another index or is absent (represented by -1).

The village is a tree where each house is a node and each road is an edge of length one. Initially, every house has exactly one villager. We must reassign villagers so that every person moves to a different house, forming a permutation of nodes with no fixed points.

We are given an undirected graph where every edge enforces a linear constraint between its endpoints. Each vertex must be assigned a real value, and every edge says exactly what the sum of its two endpoint values must be. Black edges force a sum of 1, red edges force a sum of 2.

We are interacting with a hidden system that has chosen an integer threshold $C$ between 1 and $N$. We can think of the numbers from 1 to $N$ as positions on a line, and every time we pick a position, we are effectively “dyeing” hair with that color.

We are maintaining a dynamic multiset of 3D vectors, each vector representing the amounts of salt, pepper, and garlic powder in a bottle.

We are working with a tree where vertices are gradually removed in rounds. In one round, we are allowed to pick a single internal vertex $v$ and remove exactly $k$ of its current leaf neighbors. A vertex counts as a leaf if it has degree one in the current remaining graph.

The task is to transform a given string into a very specific recursively defined structure centered around the letter 'a'.

We are given an array and we are only allowed to delete a prefix, meaning we remove some number of elements from the front and keep the rest unchanged.

We are given a one-dimensional path from a shore to an island, where the sea between them is split into $n$ positions. Each position has a base depth $di$. Time progresses in discrete steps, and at each time the water level is uniformly shifted by a periodic tide function.

Stopped thinkingDo you like this personality?

We are given a complete permutation of numbers from 1 to $n cdot m$ arranged in an $n times m$ grid. From this grid we extract two small summaries: the set of row maxima and the set of column maxima.

We are given two strings of equal length, built from a small alphabet of 20 letters. We start with string A and want to transform it into string B using a specific operation. One operation works like this: pick a letter x.

We are given two integer arrays, and we want to construct a third array that can be obtained by deleting elements from both of them. In other words, we are looking for a sequence of values that appears in both arrays while preserving order in each.

We are given two binary strings of equal length. The goal is to transform the first string into the second using a very specific operation: pick a prefix, reverse it, and flip every bit inside it. Flipping means turning 0 into 1 and 1 into 0.

We are given a permutation of size $2n$. The task is to decide whether we can split the numbers into two disjoint sequences $a$ and $b$, each of length $n$, such that if we repeatedly simulate a specific “two-pointer merge” process starting from the heads of $a$ and $b$…

We are placing a multiset of values into a circular array of rooms. Each room contains exactly one item, and each item is either a regular chest with a reward value or a mimic that immediately stops the run when entered.

We are given a set of numbered discs from 1 to n, where larger numbers represent larger discs. These discs are initially split across m towers, and each tower already has its discs stacked in decreasing order of size from bottom to top.

We are given a string describing a cyclic opponent strategy in a rock-paper-scissors game. The opponent does not adapt; instead, they choose moves according to a fixed circular string. If they start at some position, they follow the string in order and wrap around forever.

We are working on a very large grid of size $2n times 2m$, but we only care about the white cells, those where the sum of coordinates is even. Among these white cells, some are dynamically toggled between available and unavailable across a sequence of updates.

We are given a short string consisting of lowercase letters and question marks. Each question mark can later be replaced by any lowercase letter. After replacements, we want to end up with a string that contains the fixed pattern "abacaba" as a substring exactly once.

We are choosing exactly $n$ flowers from $m$ available types, where each type can be used an unlimited number of times. The value of picking flowers is not linear per flower, instead each type behaves like a diminishing reward stream.

We are given a permutation of numbers from 1 to n, but the real object we care about is not the values themselves, it is their positions. Initially each position i forms a singleton set containing the value a[i].

Three numbers represent the sizes of three piles of stones. The interaction alternates between us and the opponent.

We are given a sequence of numbers, and we are allowed to swap any two positions, but only if those two positions currently form an inversion in the original array. An inversion is simply a pair of indices where the left value is strictly larger than the right value.

Stopped thinking

We are given a grid of integers, but the final goal is not to preserve these values exactly. Instead, we are allowed to only increase values, and we want to transform the grid into a configuration where every positive cell behaves like a “node” whose value equals how many of…

We are given an array and a very specific primitive operation: we can pick any position and rotate a block of three consecutive elements to the right. That means a local triple [x, y, z] becomes [z, x, y].

We are given a collection of books, each with a reading time and two independent preference flags, one for Alice and one for Bob.

We are trying to construct the smallest non-negative integer $x$ such that if we take a short consecutive block of numbers starting at $x$, specifically $x, x+1, dots, x+k$, and sum the digit sums of all of them, the total equals a given target $n$.

We are comparing two different ways of buying the same number of donuts, and for each way we want to know when it becomes strictly cheaper than the other. In the first shop, the price is linear: buying $x$ donuts costs exactly $a cdot x$.

We are given a binary string and two players who alternately remove exactly two adjacent characters from it. Each move deletes a contiguous pair, so the string shrinks by 2 characters each turn.

We are asked to construct an integer array of length n where every element is positive, does not exceed 1000, and satisfies a global restriction on sums: if we pick any three positions (they may coincide), the sum of two chosen elements is never equal to any element of the array.

We are given a hidden array of length $n$, already sorted in nondecreasing order, and containing at most $k le 25000$ distinct values. Our only way to inspect it is by querying a segment $[l,r]$.

We are given a line of positions, each containing a direction symbol that behaves like a deterministic local rule. From every starting position, a ball moves left or right according to its own symbol and the symbol of the neighbor it is interacting with.

We are given two types of cookies and two types of guests. The cookies are split into vanilla and chocolate counts, and guests also come in two behavioral types.

We are given a tree and two hidden distinct nodes inside it. We do not know which nodes they are, but we can interactively probe the tree by choosing any subset of nodes.

We are given an array of length $2n$. We are allowed to remove exactly two elements permanently. After that, the remaining $2n-2$ elements must be partitioned into pairs. Each pair is replaced by the sum of its two elements, producing an array $b$ of length $n-1$.

We are given a sequence of numbers and asked to choose a subsequence of fixed length $k$. Once we pick this subsequence, we alternate its elements into odd and even positions based on their order inside the subsequence, not their original positions in the array.

Each round is a two-player deterministic game played on a single integer. A round starts with a value $si$ on a board and a limit $ei$. Players alternate turns, and on each turn the current value $a$ must be replaced by either $a+1$ or $2a$.

The structure in this problem is a very specific rooted tree that grows level by level. Starting from a single node, each level expands every vertex depending on how many children it already has.

The structure we are working with is a rectangular grid where every cell is a junction and every boundary cell has a port attached to one of the two external systems. Each port is either red or blue.

We are asked to construct a set of grid cells on an infinite checkerboard, where each chosen cell is considered “gray”. The shape we build must behave like a graph: cells are vertices, and edges connect cells that share a side. The construction must satisfy three conditions.

We are playing an interactive game on a circular array of n positions. All positions start empty. On each turn, the player is allowed to pick a number k and activate any k positions.

We are given a sequence of numbers and a very specific way to reorder it. In one operation, we pick any element and either push it all the way to the front or all the way to the back of the array.

We are given a multiset of lowercase letters, initially written as a string $s$. From this multiset, some letters are discarded and the remaining letters are rearranged arbitrarily to form a new string $t$.

We are given an array where each position has a fixed “required parity”: even indices must contain even numbers, and odd indices must contain odd numbers.

Each input value can be viewed as a box labeled with an integer, and for every box we must choose two non-trivial divisors of that number.

We are given two arrays of equal length and a very specific transformation rule. Starting from the first array, we are allowed to repeatedly pick a split size and swap two equal-length blocks: the prefix of that size and the suffix of the same size.

We are given an unknown array of non-negative integers, each up to 64-bit range. We cannot see the array directly. Instead, we can query any subset of indices, and the judge returns the bitwise OR of the elements at those positions.

We are given a permutation, which means every number from 1 to n appears exactly once, just in some order. From this array we are allowed to delete elements and keep the remaining ones in the same relative order, forming a subsequence.

We are given a hidden arrangement of the numbers from 0 to n−1 placed at indices 1 through n. The only way to gain information is to choose two different positions and receive the bitwise OR of the values stored at those positions.

We are given an array $A$ of length $n$, but we cannot see it directly. Instead, we can ask queries: pick any subset of indices and the judge returns the maximum value of $A$ over those indices. Along with this hidden array, we are given $k$ special index sets $S1, S2, dots, Sk$.

We are given a rooted tree where each node carries two bits of information: an initial binary digit and a desired final binary digit.

We are given a sequence that always contains consecutive integers starting from 0 up to some number n. Each number is viewed in binary, and all numbers are conceptually padded with leading zeros so they share the same bit length.

We are given a starting number and a target number, and we are allowed to transform the starting value using a very specific set of operations.

Each input item is a small “edge gadget” consisting of two pearls, and each pearl has an integer color in the range $[0, 2^{20})$. The goal is to take all these $n$ gadgets and connect their endpoints into one single cycle that uses every pearl exactly once.

We are given a set of points on the plane, one of which is guaranteed to be the origin. From these points, we must keep exactly k points and delete the rest.

We are asked to construct a binary grid of size $n times m$, where each cell is either 0 or 1, under two simultaneous constraints that tightly couple rows and columns. Every row must contain exactly $a$ ones, and every column must contain exactly $b$ ones.

We are given several independent arrays, each with an even number of elements. For each array, we must decide whether it is possible to split all elements into disjoint pairs such that every number belongs to exactly one pair and each pair satisfies a compatibility rule.

We are asked to count how many strictly increasing sequences of length $k$, chosen from the integers $1$ to $n$, have a very strong invariance property under repeated modulo operations.

We are given a collection of moving objects on an infinite plane. Each object starts from a fixed point, has a fixed direction, and moves in a straight line with a fixed speed.

We are given a sequence of months laid out in order, where each month has a fixed length in days. If we flatten the calendar, each day becomes a single linear timeline, but each position still knows its position inside its month, from day 1 up to day $di$.

We are effectively given a partially known array of length $n$. The first half (rounded up) is explicitly provided, while the second half is completely uniform and equal to a constant value $x$. So after reading the input, the entire sequence is actually determined.

We are given a hidden integer $X$ in each game, but we are never allowed to see it directly. Instead, we can query any integer $Q$, and the judge returns $gcd(X, Q)$.

We are asked to construct a positive integer array of length $N$ whose total sum is exactly $S$. After building this array, we also choose an integer $K$ between $0$ and $S$.

We are given a row of boxes, each box hiding either a valuable gift or a stone. Exactly k boxes contain gifts, and every other box contains stones. The key structural property is about weights.

We are given a regular polygon with $2n$ vertices, all edges equal to 1. The polygon is convex, and we are allowed to rotate it freely. We must place it inside a square, also freely rotatable, such that every point of the polygon lies inside or on the square boundary.

We are working with a fixed geometric object: a regular polygon with $2n$ sides, each side having length 1. This polygon is convex and highly symmetric, so its shape is completely determined once we fix how it is oriented and scaled in the plane.

We are asked to split a given integer $n$ into exactly $k$ positive parts such that all parts share the same parity. This means we must choose either all odd numbers or all even numbers, and these $k$ numbers must sum exactly to $n$.

The task is about breaking a given integer into simpler building blocks, where each building block is a number that looks like a single non-zero digit followed only by zeros. These are numbers such as 7, 40, 900, or 3000.

We start with a number and repeatedly apply a very specific transformation: find its smallest divisor greater than 1, and add that value to the number. This operation changes the number itself, so the divisor we use may change at every step.

We are given several shrubs, each containing two independent piles of berries: red and blue. From these sources we want to form as many baskets as possible, where every basket must contain exactly $k$ berries.

We are given an array and allowed to insert additional values anywhere inside it, where every inserted value must stay within the same value range as the original array elements.

We are given a string made of lowercase letters and we are allowed to split all of its characters into exactly k non-empty groups. Inside each group, we can reorder characters arbitrarily, so each group is effectively just a multiset of letters that we later sort into a string.

The game world is a directed graph with up to 15 locations, each location containing a fixed number of pellets. From any location you can reach any other, so the graph is strongly connected.

We are given a row of shelves, each holding some number of books. The goal is to reach a state where every shelf has at most k books. We are allowed to modify the configuration using two operations.

We are given an undirected connected graph where vertices represent rooms and edges represent tunnels. Each tunnel already has a fixed value, and we must assign a value to every room.

We are given a supply of identical cards and we repeatedly build structures called pyramids. A pyramid of height 1 is the smallest possible structure, and every higher pyramid is built in layers: a taller pyramid consists of a smaller pyramid placed on top of a wider base made…

The system is a rooted tree of stations, where every node with children behaves like a router that forwards all incoming trains to exactly one of its children.

We are given a hidden initial configuration of a length-n array. Each position contains either one of three primary colors or is empty. We never observe this initial array directly. Instead, we observe a sequence of operations applied to it over time.

We are given several categories of projects, and for each category we know how many projects exist. From each category we choose some number of projects to place on a résumé, with the constraint that the total number of chosen projects is exactly $k$, and we cannot pick more…

We are given a directed graph on variables $x1, x2, dots, xn$. Each constraint $xj < xk$ behaves like an edge $j to k$, and a full assignment of real values satisfies the formula only if every edge points from a smaller value to a larger value.

We are given an unknown permutation of numbers from 1 to n. Instead of seeing it directly, we receive n−1 pieces of information, each piece being a multiset segment taken from the permutation.

We are given a connected undirected graph where each edge represents a road, but the roads do not yet have fixed costs. Instead, we are also given a list of prices, and we must assign exactly one price to each edge.

We are working with integers and modular arithmetic, but the structure becomes clearer if we think of the infinite number line as being colored by a periodic rule. For any integer $x$, we compute two values: first we take $x bmod a$, then reduce that result modulo $b$.

We are given a binary string and asked to embed it into a larger binary string while preserving order as a subsequence.

The process builds a permutation from left to right, but the choice at each step is not based on already placed numbers.

We are given a straight road modeled as integer points from 0 to n. Some of these points are special positions called safety islands, including both endpoints. Denis starts at 0 at time zero and wants to reach n as fast as possible.

We are given several independent arrays, and for each one we must reorder its elements into a sequence where the absolute differences between neighboring elements never decrease as we move from left to right.

We are building an infinite sequence by repeatedly selecting groups of three unused positive integers. Each group must satisfy a strict bitwise condition: the XOR of the three numbers is zero.

We are given a tree, and the problem asks us to think about a geometric construction that can be performed on it. Each vertex becomes a closed non-self-intersecting curve on a plane.

We are given four integers in non-decreasing order, and we need to choose three lengths from three separate intervals. The first length must come from the first interval, the second from the second interval, and the third from the third interval.

We are dealing with a hidden multiset of tiles where each tile carries a value from 1 to n. The hidden configuration can be thought of as an array of frequencies a₁, a₂, …, aₙ, where aᵢ is the number of tiles with value i.

We are given two strings. The first string represents a queue of characters that we will consume from the left. The second string is a target pattern.

Codeforces 1335E2: Three Blocks Palindrome (hard version)

Each cell in the grid behaves like a deterministic state in a directed graph. From every cell, there is exactly one outgoing edge pointing to one of its four neighbors, as dictated by the arrow in that cell.

We are given a multiset of student skills for each test case. From this pool we must form two disjoint groups of students, both of the same size, say $x$.