brain

We are given a hidden permutation of integers from 1 to $n$. The permutation is unknown, and our goal is to determine it.

The previous attempts failed for two reasons. First, the test harness was calling a solvecase function that either wasn’t defined in the scope, producing a NameError.

We are asked to construct an array of length $n$ containing non-zero integers such that if we replace each element by the sum of its neighbors, the resulting array is a permutation of the original array. For the endpoints, the "neighbor sum" is just the single adjacent element.

We are given an array of positive integers. Our goal is to "block" some elements in order to minimize a certain cost.

The problem asks us to minimize the absolute difference between two numbers after each has been XOR-ed with a single number $x$ that we are allowed to choose.

We are given two permutations a and b of the same length. The allowed operation is unusual: whenever we swap positions i and j, we must perform the same swap in both arrays simultaneously. This means we can never separate a[k] from b[k].

We are building a full $n times m$ rectangular grid using long thin bricks, where each brick is a $1 times k$ strip with $k ge 2$. Each brick must lie entirely either horizontally or vertically, and every cell of the grid must belong to exactly one brick.

Because every valve capacity is fixed at $10^{18}$, the valves never become a bottleneck. Any water that remains in tower $i$ after the wizard acts can always move completely into tower $i+1$. This changes the nature of the process dramatically.

We are asked to reconstruct an unknown tree with $n$ vertices and $n-1$ edges by interacting with a grader that allows two types of queries. The first query lets us assign arbitrary positive weights to the edges and returns the resulting diameter of the weighted tree.

Let the squares in the sequence be

We are asked to reconstruct a tree from a matrix of game outcomes. Each entry s[i][j] indicates whether the first player can force a win when the tree is rooted at vertex i and the coin starts at vertex j. A vertex can only move the coin to its children.

We are asked to reverse-engineer a hidden array of size $n$ that contains only $1$ and $-1$. Instead of being given the array itself, we are given the sorted list of prefix sums of the array. The prefix sum at position $i$ is the sum of the first $i$ elements of the array.

We are tasked with simulating a sequence of water towers, each containing an initial amount of water. In front of each tower stands a wizard who can convert a limited number of liters into wine.

We are given an array and we must split it into two subsequences, call them $s$ and $t$, covering every element exactly once while preserving relative order inside each subsequence.

We are given the distances from the root to the leaves of a binary tree, listed in DFS leaf order. Every internal vertex has exactly two children. One outgoing edge has weight 0 and the other has weight 1.

Alice and Bob each start with a wallet containing some number of coins. On every turn, the current player may either keep the wallets as they are or swap the two wallets. After that choice, they must remove exactly one coin from the wallet they currently hold.

The string consists only of '+' and '-'. We can interpret each character as a number: '+' becomes +1, and '-' becomes -1. We are allowed to split this sequence into any number of contiguous non-empty pieces.

We are asked to count the number of binary strings such that the total number of substrings containing exactly one 1 equals a given number n, and no such substring has length exceeding a given maximum k. A substring is simply a consecutive portion of the string.

We are given a rectangular grid where some cells are islands, some are open ocean, and some are underwater volcanoes. Thomas wants to sail in loops that fully encircle the island without stepping onto it.

We are given a 2D grid representing an island in the ocean. Each cell can be part of the island (), open ocean (.), or an underwater volcano (v). The island cells form a single contiguous shape not touching the grid edges.

We start with an empty sequence and gradually build a very large array using two kinds of operations. The first operation appends a single value to the end, effectively extending the sequence by one element.

We are asked to determine how many integers satisfy a set of constraints. Each test case consists of multiple constraints on a single integer $k$. The constraints fall into three categories: $k$ must be at least $x$, $k$ must be at most $x$, and $k$ must not equal $x$.

We are asked to simulate a two-step game played on an array of positive integers. The first player, Alice, can remove up to $k$ elements. She wants the final sum of the array to be as large as possible.

Consider sequences $(a_1, a_2, a_3, \dots)$ satisfying the recurrence $a_k = a_{k-1} - a_{k-2}$ for $k \ge 3$, with terms chosen from the set $1, \frac12, \frac13, \dots$.

This is a Type B problem, a proof of existence. The requirement is to show that for any placement of 650 points in a disk of radius 16, there exists at least one annulus of inner radius 2 and outer radius 3 containing at least 10 points.

We are given a grid of size $n times m$, each cell either containing a target represented by or empty represented by .. Shel has a shotgun that fires in one of four diagonal directions: right-down, left-down, left-up, or right-up.

The statement as written can only be meaningful if the second triangle has side lengths $\sin x$, $\sin y$, $\sin z$.

We have a two-player game on a rectangular grid with height h and width w. Alice’s chip starts at (xa, ya) and can move down, down-left, or down-right. Bob’s chip starts at (xb, yb) and moves up, up-left, or up-right.

We have an array a of length n. Another array b contains m values, where m is at least n. We are allowed to choose exactly n elements from b, then arrange those chosen elements in any order to form a new array c.

We are given an array of integers and a set of queries. Each query specifies a starting index s, a step size d, and a count k. For a query, we must sum k elements of the array taken at indices s, s+d, s+2d, ...

The task is to transform an initial arrangement of cats in boxes into a target arrangement using the fewest operations. Each box either contains a cat or is empty, and the initial state is given by a binary string s, while the target state is given by a binary string f.

We are given the four vertices of a square on a 2D coordinate plane. The points are presented in arbitrary order, so we do not know which point is the bottom-left corner, top-right corner, and so on. The square has two special properties.

Stepan needs to send a series of messages at strictly increasing moments in time. His phone starts with a finite charge, loses a constant amount per unit of time while it is on, and consumes a fixed cost if he turns it off and then back on.

We are given an array of integers, each between 1 and some maximum value $x$. We want to make every element equal using a special operation: select a contiguous subsegment of the array and a value $k$ not currently present in that subsegment, then replace every element in that…

We are given three strings of equal length, and we need to construct a template string such that the first two strings match the template while the third one does not. Each position in the template can be either lowercase or uppercase.

We are asked to construct an array of integers with a very specific property: the total number of its increasing subsequences should equal a given integer $X$.

We have a row of monsters, each with an attack value ai and a defense value di. Monocarp casts a berserk spell so that monsters attack their immediate neighbors each round.

We are given a set of sticks, each with a length that is a power of two. The input does not give the actual lengths directly but rather exponents $ai$ such that the stick's length is $2^{ai}$.

We are given several cities placed along a one-dimensional number line. Each city has a coordinate, and the coordinates are strictly increasing. For each city, there exists a unique "closest" city, meaning that no two cities are equally close to it.

We are given a tree with n nodes, each colored with some integer between 1 and n. The task is to count the number of simple paths of length at least two such that the first and last nodes have the same color, and no intermediate node shares this color.

We are given a row of slimes, each with a positive size. The slimes interact in a simple but constrained way: a slime can eat an adjacent slime if it is strictly larger, and upon eating, it grows by the eaten slime’s size.

We are given a binary string s of length n and a number k representing the maximum number of allowed operations. Each operation can either swap two characters of the string or remove all leading zeros and then reverse the string.

We are given a row of cells, each either containing a chip or empty. The goal is to move chips leftward into contiguous groups by repeatedly picking a chip and moving it into the closest empty cell to its left.

We are given an array c of positive integers and multiple queries asking whether certain subarrays of c are good.

We have a line with our character at position 0 and monsters positioned at some coordinates $xi$, each with health $ai$. Every second, we can fire up to $k$ bullets, reducing the health of monsters we choose.

We have a straight line with n points, each occupied by a ship. Some of these points already host harbours, each with an associated value. A ship at a point incurs a cost if it were to "move" to the next harbour to its right.

We are asked to model a stochastic process of repeatedly cutting a rectangular sheet of paper and discarding parts of it, and then compute the expected number of steps until its area falls below a threshold.

I can't write a correct editorial for Codeforces 1924F from the problem statement alone. This problem is a 3500-rated interactive problem with a highly nontrivial strategy.

We repeatedly perform the same fold on a square sheet. Every fold takes the current square, folds all four corners to its center, and produces a smaller square whose side length is multiplied by $1/sqrt2$.

We are working with strings made only from two types of parentheses, and we fix how many opening and closing brackets we must use. Each test case gives three numbers: how many '(' we must place, how many ')' we must place, and a target parameter k.

We are given a string s and two integers n and k. Conceptually, we are asked to check if every string of length n that can be built using the first k letters of the alphabet appears somewhere as a subsequence in s.

We have a graph on n children. Only m pairs are marked as friends, and each friendship edge has an initial weight f. The teacher performs exactly k excursions. During each excursion, one unordered pair of children is selected uniformly at random from all possible pairs.

We are asked to split an integer $x$ into exactly $n$ positive integers whose sum is $x$, in a way that maximizes the greatest common divisor of these integers. The input gives multiple test cases, each with values for $x$ and $n$.

We have a fixed $7 times 7$ board whose cells are either black or white. A configuration is considered bad if there exists a black cell whose four diagonal neighbors are also black. Such a pattern looks like an X centered at that cell.

We are asked to separate music from sleeping students in a dormitory modeled as a tree. Each vertex represents a room and contains one student of type P (partying), S (sleeping), or C (carefree).

We are given a set of non-negative integers and asked to partition them into groups so that within each group, no two numbers share a 1-bit in the same position across the first 31 bits.

Vladislav has a deck of cards numbered from 1 to n. He wants to arrange them in a sequence with a peculiar rule. First, he takes all odd numbers and lays them out in increasing order. Then he takes all numbers that are twice an odd number and lays them out in increasing order.

For every test case, we are given a number n. Vlad writes all integers from 1 through n on the board. Then each integer is replaced by the sum of its decimal digits. The task is to compute $$sum{i=1}^{n} text{digitSum}(i)$$ where digitSum(i) is the sum of the digits of i.

Place the isosceles triangle in coordinates as

The task is simple: for each string of length five consisting only of the letters A and B, determine which letter occurs more frequently. Each test case provides one such string, and we have multiple test cases to process.

We are given a very small binary image, typically at most 10 by 10 cells. Every cell is either empty or filled. The grid contains exactly one connected geometric figure formed by ones, and that figure is guaranteed to be either a perfect square or a centered triangle (upright…

We are given a one-dimensional strip of cells, where each cell contains a “paint charge” with a fixed radius. Activating a charge at position i does not just affect that cell, it paints a contiguous segment either extending left or extending right by exactly a[i] cells…

We need to build a permutation of the numbers from 1 to n such that every contiguous segment of length k has almost the same sum. More precisely, if we compute the sum of every window of length k, the largest and smallest of those sums may differ by at most 1.

We are asked to find a simple cycle in an undirected, weighted graph where the minimal edge in that cycle is as small as possible. The input is a series of graphs: each graph is described by the number of vertices, the number of edges, and a list of edges with weights.

The problem gives you an array of integers and a series of queries, each specifying a segment of that array. For each query, you are asked to find two positions within the segment such that the values at these positions are different.

We are given an array a that describes how a hidden string was built. For each position i, the value a[i] tells us how many times the character at position i has already appeared earlier in the string. If a[i] = 0, this character has never appeared before.

We are given two arrays, a and b, and an even integer k. We need to pick exactly k/2 elements from each array such that the multiset of chosen elements contains all integers from 1 to k.

We are given a small horizontal strip of cells, each of which can be black or white. Our goal is to make every cell white by repainting a single contiguous segment. The repainting operation turns every black cell in that segment white, and leaves white cells unchanged.

We are given a grid-like scarf made by interweaving horizontal threads with vertical threads. Each horizontal thread has a transparency coefficient, as does each vertical thread. When interwoven, the cell at row i and column j has transparency equal to a[i] + b[j].

Let

We are given a rectangle with sides $a$ and $b$, and we are asked whether it is possible to cut this rectangle along a line parallel to one of its sides into two smaller rectangles with integer dimensions, and then use these two pieces to form a rectangle that is different in…

We are asked to assemble an army from multiple races, each with a certain number of creatures. Each creature pair from the same race, if they are placed in different squads, contributes a fixed amount b to the army’s strength.

We are building a sequence starting from a fixed initial value, and each next value is determined by choosing between two operations. One operation increases the current value by a fixed step size y, and the other replaces the current value by its remainder when divided by y.

The problem gives us an array of integers and asks us to maximize the number of equal elements after adding a permutation of numbers from 1 to n to the array.

We are given a scenario in which students line up according to a repeating "first-$k$-th" pattern. The sequence starts with numbers $1$ to $k$, then reverses from $k-1$ down to $2$, and this whole block repeats every $2k-2$ positions.

Let the direction of the line used in the $i$-th projection be denoted by $\alpha_i$.

We are given an array of integers, and we may rearrange its elements in any order. The beauty of a particular arrangement is defined as the sum of differences between consecutive elements: $$(a2-a1)+(a3-a2)+cdots+(an-a{n-1})$$ Our task is to choose the ordering that produces…

We are given a binary template string $p$ of length $n$. We are asked to count how many binary strings $q$ of the same length are valid under a global consistency rule that is defined locally in a slightly indirect way.

For every binary pattern $p$, we define $f(p)$ as the minimum number of 1s in another binary string $q$ of the same length such that every position of $p$ can "justify" its value by looking at some interval of $q$ containing that position.

We start with the array $$[1,2,3,dots,n].$$ A value $k$ is fixed for the whole process. In one operation we choose a subsequence of length $2k+1$. Among those chosen elements, we delete the first $k$ and the last $k$, keeping only the middle one.

We are given a list of 2n positive integers, and we need to perform exactly n moves. Each move consists of picking two numbers from the list, adding the smaller of the two to our score, and removing both numbers from the list.

We are asked to count the number of ways to assemble a one-dimensional puzzle using four distinct types of tiles. Each tile has connections on the left and right, which can be a protrusion or a recess.

We are given an array of integers and two numbers, $x$ and $y$. A pair of indices $(i, j)$ with $i < j$ is considered "beautiful" if the sum of the two elements $ai + aj$ is divisible by $x$ and the difference $ai - aj$ is divisible by $y$.

We are given a chat with n participants, each identified by a unique number from 1 to n. The chat displays participants in a list ordered by activity, but each participant always sees themselves at the top of their own list.

The game begins with a list of integers. Anna moves first by reversing the digits of any number, which can increase or decrease its value depending on the digits. Sasha moves second by concatenating any two numbers, reducing the list size by one.

We are given an array of integers and we want to make all elements equal. We are allowed to perform at most one operation, which consists of picking a contiguous subarray and setting all its elements to some value.

We are given a single integer that represents the sum of three hidden lowercase letters. Each letter contributes its position in the alphabet, so a contributes 1, b contributes 2, and so on up to z contributing 26.

We are given several independent scenarios. In each scenario there is a line of containers, each holding some amount of water. We are allowed to move water, but only from a container on the left to a container on the right.

We are given a graph of platforms, where each platform has a level between 0 and H-1. Moving from one platform to another is only allowed along a passage and only if the levels match at that moment.

We are given a timeline of n steps, and m cats, each defined by the interval [li, ri] during which it appears. At each step, we can feed all cats present, but feeding a cat more than once will cause a loss.

We are asked to reconstruct rounds of a two-player card game from a shuffled discard pile. The game uses a 32-card deck with four suits (clubs, diamonds, hearts, spades) and ranks from 2 to 9. One suit is declared trump.

We are given an array that shrinks from both ends based on a sequence of instructions. At every step, before we remove anything, we must compute the product of all remaining elements modulo a fixed number $m$.

We have a mechanical countdown timer that displays a number with $n$ digits. Each second, the countdown decrements by one. The catch is that the decrement is not instantaneous across all digits.

The problem describes a sequence of events, called signs, that occur periodically. Each sign i has a period ai, meaning it happens every ai years: in years ai, 2 ai, 3 ai, and so on. The tribe is waiting for the apocalypse, which only happens when the signs occur sequentially.

We are given a one-dimensional path made of cells. Each cell is either empty, contains a coin, or is blocked by thorns. We start at the first cell, which is guaranteed to be empty, and we want to move to the right as far as possible while collecting coins.

We are given an $n times m$ grid representing a fortune cookie box. Each cell can either be empty or hold a single cookie of a specific shape: circle or square. Initially, all cells are empty. A sequence of $q$ operations fills certain cells with a specified shape.

The problem describes a robot navigating a toroidal grid, where the rows wrap cyclically. Each cell may contain a rock at time zero, and rocks move upwards by one row per unit of time.

We are asked to model Isaac's training across multiple running tracks. Each track consists of a number of equal-length sections, and each section completed increases his performance in a linearly decreasing manner.

We are given an array of integers, and we need to decide if we can reorder the array such that when we apply modulo operations consecutively from left to right, the final result is not zero.

Take the first test case: Tree structure: - If we remove vertex 1, the neighbors are [3,4]. - The previous solution connects 3-4 for cost 1, which is correct. - If we remove vertex 4, neighbors are [1,5].