id stringlengths 3 8 | aliases listlengths 1 19 ⌀ | contest_id stringlengths 1 4 | contest_name stringlengths 10 125 | contest_type stringclasses 3
values | contest_start int64 1.27B 1.72B | contest_start_year int64 2.01k 2.02k | index stringclasses 58
values | time_limit float64 0.4 60 ⌀ | memory_limit float64 4 1.02k ⌀ | title stringlengths 2 64 | instruction_seed stringlengths 1 9.88k | input_format stringlengths 1 2.72k ⌀ | output_format stringlengths 1 2.22k ⌀ | interaction_format stringclasses 118
values | note stringlengths 13 5.36k ⌀ | examples listlengths 0 7 ⌀ | editorial stringlengths 11 22.2k ⌀ | embedding listlengths 3.07k 3.07k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1615/H | null | 1615 | Codeforces Global Round 18 | CF | 1,640,356,500 | 2,021 | H | 2 | 256 | Reindeer Games | There are $$$n$$$ reindeer at the North Pole, all battling for the highest spot on the "Top Reindeer" leaderboard on the front page of CodeNorses (a popular competitive reindeer gaming website). Interestingly, the "Top Reindeer" title is just a measure of upvotes and has nothing to do with their skill level in the reindeer games, but they still give it the utmost importance.
Currently, the $$$i$$$-th reindeer has a score of $$$a_i$$$. You would like to influence the leaderboard with some operations. In an operation, you can choose a reindeer, and either increase or decrease his score by $$$1$$$ unit. Negative scores are allowed.
You have $$$m$$$ requirements for the resulting scores. Each requirement is given by an ordered pair $$$(u, v)$$$, meaning that after all operations, the score of reindeer $$$u$$$ must be less than or equal to the score of reindeer $$$v$$$.
Your task is to perform the minimum number of operations so that all requirements will be satisfied. | The first line contains two integers $$$n$$$ and $$$m$$$ ($$$2\le n\le 1000$$$; $$$1\le m\le 1000$$$) — the number of reindeer and requirements, respectively.
The second line contains $$$n$$$ integers $$$a_1,\ldots, a_n$$$ ($$$1\le a_i\le 10^9$$$), where $$$a_i$$$ is the current score of reindeer $$$i$$$.
The next $$$m$$$ lines describe the requirements.
The $$$i$$$-th of these lines contains two integers $$$u_i$$$ and $$$v_i$$$ ($$$1\le u_i, v_i\le n$$$; $$$u_i\ne v_i$$$) — the two reindeer of the $$$i$$$-th requirement. | Print $$$n$$$ integers $$$b_1,\ldots, b_n$$$ ($$$-10^{15}\le b_i\le 10^{15}$$$), where $$$b_i$$$ is the score of the $$$i$$$-th reindeer after all operations.
If there are multiple solutions achieving the minimum number of operations, you may output any.
We can prove that there is always an optimal solution such that $$$|b_i|\le 10^{15}$$$ for all $$$i$$$. | null | null | [
{
"input": "7 6\n3 1 4 9 2 5 6\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7",
"output": "1 1 4 4 4 5 6"
},
{
"input": "4 6\n6 5 8 2\n3 1\n4 1\n3 2\n1 2\n2 3\n3 1",
"output": "6 6 6 2"
},
{
"input": "10 18\n214 204 195 182 180 176 176 172 169 167\n1 2\n3 2\n4 2\n5 2\n6 2\n7 2\n8 2\n9 2\n10 2\n6 1\n6 2\n... | Let's try to find a nice lower bound for the answer. Let's denote a requirement of two nodes $$$u$$$ and $$$v$$$ by a directed edge $$$u\to v$$$. We can observe that if there are two nodes $$$u$$$ and $$$v$$$ such that there's a requirement $$$u\to v$$$ (or a path of requirements from $$$u$$$ to $$$v$$$), then we will need to do at least $$$a_u-a_v$$$ operations on these two nodes. So, if we can create a list of pairs $$$(u_1,v_1),\ldots, (u_k,v_k)$$$ with all distinct nodes such that there is a path from $$$u_i$$$ to $$$v_i$$$ for all $$$i$$$, then a lower bound of the answer is $$$$$$\sum\limits_{i=1}^k (a_{u_i}-a_{v_i})$$$$$$
Our strategy will be to find the largest possible lower bound of this form, and then construct a solution with exactly that cost (which is therefore the optimal cost). To find an optimal set of pairs, we can set it up as a flow problem. Every directed edge $$$u\to v$$$ of the original graph will have infinite capacity and a cost of $$$a_u-a_v$$$. In addition, we will create two new nodes $$$s$$$ and $$$t$$$. For each node $$$u$$$, add an edge $$$s\to u$$$ with capacity $$$1$$$ and cost $$$0$$$, and add an edge $$$u\to t$$$ with capacity $$$1$$$ and cost $$$0$$$.
Compute the maximum cost flow from $$$s$$$ to $$$t$$$ (the amount of flow doesn't need to be maximized). If there is any node $$$u$$$ such that $$$s\to u$$$ and $$$u\to t$$$ both have flow, make them both have $$$0$$$ flow, and this won't change the cost. The flow can be decomposed into paths with distinct endpoints in the original graph. The endpoints are distinct because each node $$$u$$$ cannot have flow on both edges $$$s\to u$$$ and $$$u\to t$$$. And the cost of a path beginning in $$$u$$$ and ending in $$$v$$$ will be $$$a_u-a_v$$$ (intermediate nodes of the path cancel out when computing the cost). It's also easy to see that any set of pairs has a corresponding flow in the graph with the same cost. So, this flow gives us a way to compute a set of pairs with the maximum lower bound, just like we want.
Now, how do we construct the operations to perform? First, take the edges of the residual flow graph that are not at full capacity. Using only these edges, compute the longest path from $$$s$$$ to every node in the graph (where length of a path is the sum of edge costs). Let's say the longest path from $$$s$$$ to $$$u$$$ is $$$d_u$$$.
Let's show that $$$b_u:=a_u+d_u$$$ satisfies all requirements. Every requirement $$$u\to v$$$ is present in the residual graph because it has infinite capacity. So we have that $$$d_u+(a_u-a_v)\le d_v$$$, otherwise we could find a longer path from $$$s$$$ to $$$v$$$. By moving $$$a_v$$$ to the right side of this inequality, we get $$$a_u+d_u\le a_v+d_v$$$, In other words, $$$b_u\le b_v$$$, meaning this requirement is satisfied.
Let's show that the total number of operations $$$\sum_u|b_u-a_u|$$$ does not exceed the cost of the flow. It's sufficient to show that for each node $$$u$$$ that isn't in one of the pairs, we have $$$b_u=a_u$$$, and for each pair $$$(u_i, v_i)$$$ we have that $$$a_{v_i}\le b_{v_i}=b_{u_i}\le a_{u_i}$$$.
For the first part, suppose a node $$$u$$$ is unpaired. If $$$d_u>0$$$, then there is a path from $$$s$$$ to $$$u$$$ with positive cost, and there is an edge from $$$u$$$ to $$$t$$$ of $$$0$$$ cost because it's unpaired, so we've found an augmenting path in the flow graph that will increase the cost. This contradicts the fact that we found the maximum cost flow. On the other hand, if $$$d_u<0$$$, this contradicts the definition of $$$d_u$$$ since there's an edge $$$s\to u$$$ of cost $$$0$$$ which makes a longer path. Therefore, $$$d_u=0$$$ and $$$b_u=a_u+d_u=a_u$$$, as desired.
For the second part, consider a pair $$$(u_i,v_i)$$$. There is a path in the residual graph from $$$v_i$$$ to $$$u_i$$$, so we have $$$d_{v_i}+(a_{v_i}-a_{u_i})\le d_{u_i}$$$. In other words, $$$b_{v_i}\le b_{u_i}$$$. But we already had that $$$b_{u_i}\le b_{v_i}$$$ because all requirements are satisfied, therefore $$$b_{u_i}=b_{v_i}$$$. It's impossible to have $$$d_{v_i}<0$$$ because there's a longer path with the direct edge $$$s\to v_i$$$ which is present in the residual graph. It's impossible to have $$$d_{u_i}>0$$$ because it would mean the edge $$$u_i\to t$$$ creates an augmenting path with positive cost. Therefore, $$$a_{v_i}\le a_{v_i}+d_{v_i}=b_{v_i}=b_{u_i}=a_{u_i}+d_{u_i}\le a_{u_i}$$$, as desired.
In summary, the solution is to build a flow graph, compute the maximum cost flow (which is equivalent to minimum cost flow with all costs negated), and compute the distance values $$$d_u$$$ to construct the solution. The flow can be computed with the potential method in $$$O(nm\log n)$$$ time. | [
0.014394356869161129,
-0.017048444598913193,
-0.007996113039553165,
0.030657408758997917,
0.019174421206116676,
-0.008957542479038239,
-0.03759053349494934,
0.013852707110345364,
0.007698205299675465,
0.055410828441381454,
0.02302013896405697,
0.0029807693790644407,
-0.020785830914974213,
... |
137/A | null | 137 | Codeforces Beta Round 98 (Div. 2) | CF | 1,324,015,200 | 2,011 | A | 2 | 256 | Postcards and photos | Polycarpus has postcards and photos hung in a row on the wall. He decided to put them away to the closet and hang on the wall a famous painter's picture. Polycarpus does it like that: he goes from the left to the right and removes the objects consecutively. As Polycarpus doesn't want any mix-ups to happen, he will not carry in his hands objects of two different types. In other words, Polycarpus can't carry both postcards and photos simultaneously. Sometimes he goes to the closet and puts the objects there, thus leaving his hands free. Polycarpus must put all the postcards and photos to the closet. He cannot skip objects. What minimum number of times he should visit the closet if he cannot carry more than 5 items? | The only line of the input data contains a non-empty string consisting of letters "С" and "P" whose length does not exceed 100 characters. If the i-th character in the string is the letter "С", that means that the i-th object (the numbering goes from the left to the right) on Polycarpus' wall is a postcard. And if the i-th character is the letter "P", than the i-th object on the wall is a photo. | Print the only number — the minimum number of times Polycarpus has to visit the closet. | null | In the first sample Polycarpus needs to take one item to the closet 7 times.
In the second sample Polycarpus can first take 3 postcards to the closet; then 3 more. He can take the 6 photos that are left in the similar way, going to the closet twice.
In the third sample Polycarpus can visit the closet twice, both times carrying 3 postcards. Then he can take there 2 photos at once, then one postcard and finally, he can carry the last 10 photos if he visits the closet twice.
In the fourth sample Polycarpus can visit the closet twice and take there all 10 postcards (5 items during each go). | [
{
"input": "CPCPCPC",
"output": "7"
},
{
"input": "CCCCCCPPPPPP",
"output": "4"
},
{
"input": "CCCCCCPPCPPPPPPPPPP",
"output": "6"
},
{
"input": "CCCCCCCCCC",
"output": "2"
}
] | null | [
-0.02251593954861164,
0.01709514483809471,
-0.012404979206621647,
0.007058817893266678,
-0.011320820078253746,
-0.037647027522325516,
0.01604241132736206,
0.03877832368016243,
-0.0019561999943107367,
0.03598150983452797,
-0.0018246081890538335,
0.014494734816253185,
-0.024055760353803635,
... |
137/B | null | 137 | Codeforces Beta Round 98 (Div. 2) | CF | 1,324,015,200 | 2,011 | B | 2 | 256 | Permutation | "Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer). | The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n). | Print the only number — the minimum number of changes needed to get the permutation. | null | The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2. | [
{
"input": "3\n3 1 2",
"output": "0"
},
{
"input": "2\n2 2",
"output": "1"
},
{
"input": "5\n5 3 3 3 1",
"output": "2"
}
] | null | [
-0.004783516749739647,
-0.008257793262600899,
0.0034806630574166775,
0.02571220137178898,
0.013705509714782238,
0.03400192782282829,
-0.01940230280160904,
0.023834558203816414,
0.020858433097600937,
0.009298798628151417,
-0.007204014807939529,
-0.029275888577103615,
-0.02449875883758068,
0... |
137/C | null | 137 | Codeforces Beta Round 98 (Div. 2) | CF | 1,324,015,200 | 2,011 | C | 2 | 256 | History | Polycarpus likes studying at school a lot and he is always diligent about his homework. Polycarpus has never had any problems with natural sciences as his great-great-grandfather was the great physicist Seinstein. On the other hand though, Polycarpus has never had an easy time with history.
Everybody knows that the World history encompasses exactly n events: the i-th event had continued from the year ai to the year bi inclusive (ai < bi). Polycarpus easily learned the dates when each of n events started and ended (Polycarpus inherited excellent memory from his great-great-granddad). But the teacher gave him a more complicated task: Polycaprus should know when all events began and ended and he should also find out for each event whether it includes another event. Polycarpus' teacher thinks that an event j includes an event i if aj < ai and bi < bj. Your task is simpler: find the number of events that are included in some other event. | The first input line contains integer n (1 ≤ n ≤ 105) which represents the number of events. Next n lines contain descriptions of the historical events, one event per line. The i + 1 line contains two integers ai and bi (1 ≤ ai < bi ≤ 109) — the beginning and the end of the i-th event. No two events start or finish in the same year, that is, ai ≠ aj, ai ≠ bj, bi ≠ aj, bi ≠ bj for all i, j (where i ≠ j). Events are given in arbitrary order. | Print the only integer — the answer to the problem. | null | In the first example the fifth event is contained in the fourth. Similarly, the fourth event is contained in the third, the third — in the second and the second — in the first.
In the second example all events except the first one are contained in the first.
In the third example only one event, so the answer is 0. | [
{
"input": "5\n1 10\n2 9\n3 8\n4 7\n5 6",
"output": "4"
},
{
"input": "5\n1 100\n2 50\n51 99\n52 98\n10 60",
"output": "4"
},
{
"input": "1\n1 1000000000",
"output": "0"
}
] | null | [
0.01831849291920662,
-0.019038433209061623,
-0.012622960843145847,
0.032621316611766815,
0.009359229356050491,
0.006939428858458996,
0.011047090403735638,
0.019006434828042984,
0.014030844904482365,
0.048667993396520615,
-0.008527298457920551,
-0.018334491178393364,
-0.020526310428977013,
... |
137/D | null | 137 | Codeforces Beta Round 98 (Div. 2) | CF | 1,324,015,200 | 2,011 | D | 2 | 256 | Palindromes | Friday is Polycarpus' favourite day of the week. Not because it is followed by the weekend, but because the lessons on Friday are 2 IT lessons, 2 math lessons and 2 literature lessons. Of course, Polycarpus has prepared to all of them, unlike his buddy Innocentius. Innocentius spent all evening playing his favourite game Fur2 and didn't have enough time to do the literature task. As Innocentius didn't want to get an F, he decided to do the task and read the book called "Storm and Calm" during the IT and Math lessons (he never used to have problems with these subjects). When the IT teacher Mr. Watkins saw this, he decided to give Innocentius another task so that the boy concentrated more on the lesson and less — on the staff that has nothing to do with IT.
Mr. Watkins said that a palindrome is a string that can be read the same way in either direction, from the left to the right and from the right to the left. A concatenation of strings a, b is a string ab that results from consecutive adding of string b to string a. Of course, Innocentius knew it all but the task was much harder than he could have imagined. Mr. Watkins asked change in the "Storm and Calm" the minimum number of characters so that the text of the book would also be a concatenation of no more than k palindromes. Innocentius can't complete the task and therefore asks you to help him. | The first input line contains a non-empty string s which is the text of "Storm and Calm" (without spaces). The length of the string s does not exceed 500 characters. String s consists of uppercase and lowercase Latin letters. The second line contains a single number k (1 ≤ k ≤ |s|, where |s| represents the length of the string s). | Print on the first line the minimum number of changes that Innocentius will have to make. Print on the second line the string consisting of no more than k palindromes. Each palindrome should be non-empty and consist of uppercase and lowercase Latin letters. Use the character "+" (ASCII-code 43) to separate consecutive palindromes. If there exist several solutions, print any of them.
The letters' case does matter, that is an uppercase letter is not considered equivalent to the corresponding lowercase letter. | null | null | [
{
"input": "abacaba\n1",
"output": "0\nabacaba"
},
{
"input": "abdcaba\n2",
"output": "1\nabdcdba"
},
{
"input": "abdcaba\n5",
"output": "0\na+b+d+c+aba"
},
{
"input": "abacababababbcbabcd\n3",
"output": "1\nabacaba+babab+bcbabcb"
}
] | null | [
0.01699342392385006,
-0.007231963332742453,
-0.00842165295034647,
0.015522263012826443,
0.005411775317043066,
0.0064888764172792435,
-0.017353709787130356,
-0.0036309934221208096,
-0.022187527269124985,
0.030414026230573654,
0.017578886821866035,
0.0002627075300551951,
-0.0508001334965229,
... |
137/E | null | 137 | Codeforces Beta Round 98 (Div. 2) | CF | 1,324,015,200 | 2,011 | E | 2 | 256 | Last Chance | Having read half of the book called "Storm and Calm" on the IT lesson, Innocentius was absolutely determined to finish the book on the maths lessons. All was fine until the math teacher Ms. Watkins saw Innocentius reading fiction books instead of solving equations of the fifth degree. As during the last maths class Innocentius suggested the algorithm of solving equations of the fifth degree in the general case, Ms. Watkins had no other choice but to give him a new task.
The teacher asked to write consecutively (without spaces) all words from the "Storm and Calm" in one long string s. She thought that a string is good if the number of vowels in the string is no more than twice more than the number of consonants. That is, the string with v vowels and c consonants is good if and only if v ≤ 2c.
The task Innocentius had to solve turned out to be rather simple: he should find the number of the longest good substrings of the string s. | The only input line contains a non-empty string s consisting of no more than 2·105 uppercase and lowercase Latin letters. We shall regard letters "a", "e", "i", "o", "u" and their uppercase variants as vowels. | Print on a single line two numbers without a space: the maximum length of a good substring and the number of good substrings with this length. If no good substring exists, print "No solution" without the quotes.
Two substrings are considered different if their positions of occurrence are different. So if some string occurs more than once, then it should be counted more than once. | null | In the first sample there is only one longest good substring: "Abo" itself. The other good substrings are "b", "Ab", "bo", but these substrings have shorter length.
In the second sample there is only one longest good substring: "EIS". The other good substrings are: "S", "IS". | [
{
"input": "Abo",
"output": "3 1"
},
{
"input": "OEIS",
"output": "3 1"
},
{
"input": "auBAAbeelii",
"output": "9 3"
},
{
"input": "AaaBRAaaCAaaDAaaBRAaa",
"output": "18 4"
},
{
"input": "EA",
"output": "No solution"
}
] | null | [
0.044933341443538666,
0.008405262604355812,
-0.0049634831957519054,
0.003574569243937731,
0.011664005927741528,
-0.021088523790240288,
0.00882157776504755,
0.0069230361841619015,
-0.01778671145439148,
0.0312667153775692,
-0.02295476384460926,
0.019265349954366684,
-0.04306710138916969,
0.0... |
1771/A | null | 1771 | Codeforces Round 837 (Div. 2) | CF | 1,670,772,900 | 2,022 | A | 2 | 256 | Hossam and Combinatorics | Hossam woke up bored, so he decided to create an interesting array with his friend Hazem.
Now, they have an array $$$a$$$ of $$$n$$$ positive integers, Hossam will choose a number $$$a_i$$$ and Hazem will choose a number $$$a_j$$$.
Count the number of interesting pairs $$$(a_i, a_j)$$$ that meet all the following conditions:
- $$$1 \le i, j \le n$$$;
- $$$i \neq j$$$;
- The absolute difference $$$|a_i - a_j|$$$ must be equal to the maximum absolute difference over all the pairs in the array. More formally, $$$|a_i - a_j| = \max_{1 \le p, q \le n} |a_p - a_q|$$$. | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$), which denotes the number of test cases. Description of the test cases follows.
The first line of each test case contains an integer $$$n$$$ ($$$2 \le n \le 10^5$$$).
The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^5$$$).
It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. | For each test case print an integer — the number of interesting pairs $$$(a_i, a_j)$$$. | null | In the first example, the two ways are:
- Hossam chooses the fourth number $$$8$$$ and Hazem chooses the fifth number $$$1$$$.
- Hossam chooses the fifth number $$$1$$$ and Hazem chooses the fourth number $$$8$$$.
In the second example, the four ways are:
- Hossam chooses the second number $$$2$$$ and Hazem chooses the sixth number $$$10$$$.
- Hossam chooses the sixth number $$$10$$$ and Hazem chooses the second number $$$2$$$.
- Hossam chooses the fifth number $$$2$$$ and Hazem chooses the sixth number $$$10$$$.
- Hossam chooses the sixth number $$$10$$$ and Hazem chooses the fifth number $$$2$$$. | [
{
"input": "2\n5\n6 2 3 8 1\n6\n7 2 8 3 2 10",
"output": "2\n4"
}
] | Firstly, let's find $$$\max_{1 \le p, q \le n} |a_p - a_q| = max(a) - min(a)$$$
if it's equal to zero, then any pair is valid, so answer if $$$n \cdot (n - 1)$$$
Otherwise, let's calculate $$$count\_min$$$ and $$$count\_max$$$. Answer is $$$2 \cdot count\_min \cdot count\_max$$$ | [
-0.02992023341357708,
-0.007699362467974424,
-0.0030643343925476074,
0.017141306772828102,
0.02356633171439171,
-0.004015641286969185,
0.011723894625902176,
0.021942295134067535,
-0.0016536737093701959,
-0.01410660706460476,
0.015647664666175842,
-0.020590905100107193,
0.002191562205553055,
... |
1771/C | null | 1771 | Codeforces Round 837 (Div. 2) | CF | 1,670,772,900 | 2,022 | C | 3 | 256 | Hossam and Trainees | Hossam has $$$n$$$ trainees. He assigned a number $$$a_i$$$ for the $$$i$$$-th trainee.
A pair of the $$$i$$$-th and $$$j$$$-th ($$$i \neq j$$$) trainees is called successful if there is an integer $$$x$$$ ($$$x \geq 2$$$), such that $$$x$$$ divides $$$a_i$$$, and $$$x$$$ divides $$$a_j$$$.
Hossam wants to know if there is a successful pair of trainees.
Hossam is very tired now, so he asks you for your help! | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^5$$$), the number of test cases. A description of the test cases follows.
The first line of each test case contains an integer number $$$n$$$ ($$$2 \le n \le 10^5$$$).
The second line of each test case contains $$$n$$$ integers, the number of each trainee $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^9$$$).
It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. | Print the answer — "YES" (without quotes) if there is a successful pair of trainees and "NO" otherwise. You can print each letter in any case. | null | In the first example, the first trainee and the second trainee make up a successful pair:
$$$a_1 = 32, a_2 = 48$$$, you can choose $$$x = 4$$$. | [
{
"input": "2\n3\n32 48 7\n3\n14 5 9",
"output": "YES\nNO"
}
] | If exists $$$x \geq 2$$$ such that $$$a_i$$$ divides $$$x$$$ and $$$a_j$$$ divides $$$x$$$ then exists prime number $$$p$$$ such that $$$a_i$$$ and $$$a_j$$$ divides $$$p$$$. We can choose $$$p = $$$ any prime divisor of $$$x$$$.
So, let's factorize all numbers and check, if two of them divides one prime number. We can use default factorization, and it will be $$$O(n \cdot \sqrt{A})$$$. It's too long, so just calculate prime numbers $$$\leq \sqrt{A}$$$ and check if $$$a_i$$$ divides this numbers. It will be $$$O(n \cdot \frac{\sqrt{A}}{\log{A}})$$$ - fast enouth. | [
-0.011415510438382626,
0.013703572563827038,
0.006002288777381182,
0.012773466296494007,
0.00523030012845993,
-0.02862248569726944,
0.046505335718393326,
0.01950743794441223,
0.01669231615960598,
0.029192950576543808,
-0.029242556542158127,
-0.0076082730665802956,
-0.026935890316963196,
0.... |
1771/D | null | 1771 | Codeforces Round 837 (Div. 2) | CF | 1,670,772,900 | 2,022 | D | 1 | 256 | Hossam and (sub-)palindromic tree | Hossam has an unweighted tree $$$G$$$ with letters in vertices.
Hossam defines $$$s(v, \, u)$$$ as a string that is obtained by writing down all the letters on the unique simple path from the vertex $$$v$$$ to the vertex $$$u$$$ in the tree $$$G$$$.
A string $$$a$$$ is a subsequence of a string $$$s$$$ if $$$a$$$ can be obtained from $$$s$$$ by deletion of several (possibly, zero) letters. For example, "dores", "cf", and "for" are subsequences of "codeforces", while "decor" and "fork" are not.
A palindrome is a string that reads the same from left to right and from right to left. For example, "abacaba" is a palindrome, but "abac" is not.
Hossam defines a sub-palindrome of a string $$$s$$$ as a subsequence of $$$s$$$, that is a palindrome. For example, "k", "abba" and "abhba" are sub-palindromes of the string "abhbka", but "abka" and "cat" are not.
Hossam defines a maximal sub-palindrome of a string $$$s$$$ as a sub-palindrome of $$$s$$$, which has the maximal length among all sub-palindromes of $$$s$$$. For example, "abhbka" has only one maximal sub-palindrome — "abhba". But it may also be that the string has several maximum sub-palindromes: the string "abcd" has $$$4$$$ maximum sub-palindromes.
Help Hossam find the length of the longest maximal sub-palindrome among all $$$s(v, \, u)$$$ in the tree $$$G$$$.
Note that the sub-palindrome is a subsequence, not a substring. | The first line contains one integer $$$t$$$ ($$$1 \le t \le 200$$$) — the number of test cases.
The first line of each test case has one integer number $$$n$$$ ($$$1 \le n \le 2 \cdot 10^3$$$) — the number of vertices in the graph.
The second line contains a string $$$s$$$ of length $$$n$$$, the $$$i$$$-th symbol of which denotes the letter on the vertex $$$i$$$. It is guaranteed that all characters in this string are lowercase English letters.
The next $$$n - 1$$$ lines describe the edges of the tree. Each edge is given by two integers $$$v$$$ and $$$u$$$ ($$$1 \le v, \, u \le n$$$, $$$v \neq u$$$). These two numbers mean that there is an edge $$$(v, \, u)$$$ in the tree. It is guaranteed that the given edges form a tree.
It is guaranteed that sum of all $$$n$$$ doesn't exceed $$$2 \cdot 10^3$$$. | For each test case output one integer — the length of the longest maximal sub-palindrome among all $$$s(v, \, u)$$$. | null | In the first example the maximal subpalindromes are "aaa" with letters in vertices $$$1, \, 3, \, 5$$$, or "aca" with letters in vertices $$$1, \, 4, \, 5$$$.
The tree from the first example.
In the second example there is only one maximal palindrome "bacab" with letters in vertices $$$4, \, 2, \, 1, \, 5, \, 9$$$.
The tree from the second example. | [
{
"input": "2\n5\nabaca\n1 2\n1 3\n3 4\n4 5\n9\ncaabadedb\n1 2\n2 3\n2 4\n1 5\n5 6\n5 7\n5 8\n8 9",
"output": "3\n5"
}
] | Let's use dynamic programming method. Let $$$dp_{v, \, u}$$$ as length of the longest maximal sub-palindrome on the path between vertexes $$$v$$$ and $$$u$$$. Then the answer to the problem is $$$\max\limits_{1 \le v, \, u \le n}{dp_{v, \, u}}$$$.
Define $$$go_{v, \, u}$$$ $$$(v \neq u)$$$ vertex $$$x$$$ such that it is on way between $$$v$$$ and $$$u$$$ and distance between $$$v$$$ and $$$x$$$ is $$$1$$$. If $$$v = u$$$, then we put $$$go_{v, \, u}$$$ equal to $$$v$$$.
So, there are three cases:
1. The answer for $$$(v, \, u)$$$ equals to the answer for $$$(go_{v, \, u}, \, u)$$$;
2. The answer for $$$(v, \, u)$$$ equals to the answer for $$$(v, \, go_{u, \, v})$$$;
3. If $$$s_v = s_u$$$, then the answer for $$$(v, \, u)$$$ equals to the answer for $$$(go_{v, \, u}, \, go_{u, \, v}) \, + \, 2$$$. In this case we took best sub-palindrome strictly inside the path $$$v, \, u$$$ and added to it two same symbols in $$$v$$$ and $$$u$$$.
Formally , the transitions in dynamics will look like this:
$$$$$$dp_{v, \, u} := \max(dp_{v, \, go_{u, \, v}}, \; dp_{go_{v, \, u}, \, u}, \; dp_{go_{v, \, u}, \, go_{u, \, v}} + 2 \cdot (s_v = s_u)).$$$$$$
Dynamic's base: $$$$$$dp_{v, \, v} := 1,$$$$$$ $$$$$$dp_{v, \, w} := 1 \, + \, (s_v = s_w),$$$$$$ for $$$v, \, w$$$, such that distance between them equals to one.
In order to calculate the values in dp, you need to iterate through pairs of vertices in ascending order of the distance between the vertices in the pair (note that this can be done by counting sort).
The question remains: how to calculate the array $$$go$$$? Let's iterate all vertexes and let the current vertex is $$$v$$$. Let $$$v$$$ be the root of the tree. Consider all sons of this vertex. Let current son is $$$x$$$. Then for all $$$u$$$ from subtree of $$$x$$$ the value of $$$go_{v, \, u}$$$ will be number of $$$x$$$.
Thus, time and memory complexity of this solution is $$$\mathcal{O}(n^2)$$$. | [
0.00781579315662384,
0.05070115625858307,
-0.0032132300548255444,
0.038216184824705124,
0.06760153919458389,
0.007213114760816097,
0.024969937279820442,
0.016024913638830185,
-0.040373142808675766,
0.015923410654067993,
-0.00785385724157095,
0.017268335446715355,
-0.00357483746483922,
-0.0... |
1771/E | null | 1771 | Codeforces Round 837 (Div. 2) | CF | 1,670,772,900 | 2,022 | E | 2 | 256 | Hossam and a Letter | Hossam bought a new piece of ground with length $$$n$$$ and width $$$m$$$, he divided it into an $$$n \cdot m$$$ grid, each cell being of size $$$1\times1$$$.
Since Hossam's name starts with the letter 'H', he decided to draw the capital letter 'H' by building walls of size $$$1\times1$$$ on some squares of the ground. Each square $$$1\times1$$$ on the ground is assigned a quality degree: perfect, medium, or bad.
The process of building walls to form up letter 'H' has the following constraints:
- The letter must consist of one horizontal and two vertical lines.
- The vertical lines must not be in the same or neighboring columns.
- The vertical lines must start in the same row and end in the same row (and thus have the same length).
- The horizontal line should connect the vertical lines, but must not cross them.
- The horizontal line can be in any row between the vertical lines (not only in the middle), except the top and the bottom one. (With the horizontal line in the top row the letter looks like 'n', and in the bottom row like 'U'.)
- It is forbidden to build walls in cells of bad quality.
- You can use at most one square of medium quality.
- You can use any number of squares of perfect quality.
Find the maximum number of walls that can be used to draw the letter 'H'.
Check the note for more clarification. | The first line of the input contains two integer numbers $$$n$$$, $$$m$$$ ($$$1 \le n, m \le 400$$$).
The next $$$n$$$ lines of the input contain $$$m$$$ characters each, describing the grid. The character '.' stands for a perfect square, the character 'm' stands for a medium square, and the character '#' stands for a bad square. | Print a single integer — the maximum number of walls that form a capital letter 'H'.
If it is not possible to draw any letter 'H', print $$$0$$$. | null | In the first test case, we can't build the letter 'H'.
For the second test case, the figure below represents the grid and some of the valid letters 'H'. Perfect, medium, and bad squares are represented with white, yellow, and black colors respectively. | [
{
"input": "2 3\n#m.\n.#.",
"output": "0"
},
{
"input": "7 8\n...#.m..\n..m...m.\n.#..#.m#\n...m..m.\nm.......\n..#.m.mm\n......m.",
"output": "16"
}
] | Let's preprocess the following data for each cell.
1. first medium cell above current cell. 2. first medium cell below current cell. 3. first bad cell above current cell. 4. first bad cell below current cell.
Then we will try to solve the problem for each row (i), and 2 columns (j, k).
Now we have a horizontal line in row (i), and we can calculate the length of vertical line by the following.
There is two cases:
In case of the horizontal line contains one letter 'm'.
For each column (j, k): get first cell above it the don't contain ('#' or 'm') and first cell below it the don't contain ('#' or 'm').
In case of the horizontal line doesn't contain any letter 'm'.
We will try to get the 4 cells as it contains letter 'm', but in this case we will 4 trials.
for each cell from the 4 cells, we allow to have only one letter 'm' in that line.
After getting above cells and below cells for each line. the starting cell will be the maximum between the two above cells, and the ending cell will be the minimum between the two below cells.
Then we need to check that starting cell is above the current row (i) to avoid making letter n instead of H
And check that ending cell is below the current row (i) to avoid making letter u instead of H.
Since n, m has the same maximum limit 400.
Thus, time complexity of this solution is $$$O(n^3)$$$. | [
0.003916798159480095,
-0.01067751832306385,
0.005428432486951351,
0.0192284993827343,
0.07184106111526489,
-0.009031374007463455,
0.03789333999156952,
0.0101458840072155,
-0.02267451398074627,
0.0008566994802094996,
0.012925754301249981,
-0.00048759812489151955,
0.008787975646555424,
0.014... |
1771/F | null | 1771 | Codeforces Round 837 (Div. 2) | CF | 1,670,772,900 | 2,022 | F | 1.5 | 256 | Hossam and Range Minimum Query | Hossam gives you a sequence of integers $$$a_1, \, a_2, \, \dots, \, a_n$$$ of length $$$n$$$. Moreover, he will give you $$$q$$$ queries of type $$$(l, \, r)$$$. For each query, consider the elements $$$a_l, \, a_{l + 1}, \, \dots, \, a_r$$$. Hossam wants to know the smallest number in this sequence, such that it occurs in this sequence an odd number of times.
You need to compute the answer for each query before process the next query. | The first line of the input contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$), the length of the sequence.
The second line contains $$$n$$$ integers $$$a_1, \, a_2, \, \dots, \, a_n$$$ ($$$1 \le a_i \le 10^9$$$).
The third line contains one integer $$$q$$$ ($$$1 \le q \le 2 \cdot 10^5$$$), the number of queries.
Each of the next $$$q$$$ lines contains two integers $$$a$$$ and $$$b$$$ ($$$0 \le a, \, b \le 2 \cdot 10^9$$$), the numbers used to encode the queries.
Let $$$\mathrm{ans}_i$$$ be the answer on the $$$i$$$-th query, and $$$\mathrm{ans}_0$$$ be zero. Then $$$$$$l_i = a_i \oplus \mathrm{ans}_{i - 1},$$$$$$ $$$$$$r_i = b_i \oplus \mathrm{ans}_{i - 1},$$$$$$ where $$$l_i, \, r_i$$$ are parameters of the $$$i$$$-th query and $$$\oplus$$$ means the bitwise exclusive or operation. It is guaranteed that $$$1 \le l \le r \le n$$$. | For each query, print the smallest number that occurs an odd number of times on the given segment of the sequence.
If there is no such number, print $$$0$$$. | null | In the example,
$$$$$$l_1 = 1, \, r_1 = 2,$$$$$$ $$$$$$l_2 = 1, \, r_2 = 3,$$$$$$ $$$$$$l_3 = 2, \, r_3 = 4,$$$$$$ $$$$$$l_4 = 1, \, r_4 = 4,$$$$$$ $$$$$$l_5 = 2, \, r_5 = 2,$$$$$$ $$$$$$l_6 = 1, \, r_6 = 5.$$$$$$ | [
{
"input": "5\n1 2 1 2 2\n6\n1 2\n0 2\n0 6\n0 5\n2 2\n3 7",
"output": "1\n2\n1\n0\n2\n2"
},
{
"input": "10\n51 43 69 48 23 52 48 76 19 55\n10\n1 1\n57 57\n54 62\n20 27\n56 56\n79 69\n16 21\n18 30\n25 25\n62 61",
"output": "51\n55\n19\n48\n76\n19\n23\n19\n55\n19"
}
] | Note that we were asked to solve the problem in online mode. If this were not the case, then the Mo Algorithm could be used.
How to solve this task in online mode? Consider two ways.
The first way is as follows. Let's build a persistent bitwise trie $$$T$$$ on a given array, where the $$$i$$$-th version of the trie will store numbers $$$x$$$ such that $$$x$$$ occurs on the subsegment $$$a[1\dots i]$$$ an odd number of times.
This can be done as follows. Let $$$T_0$$$ be an empty trie, and $$$T_i$$$ will be obtained as follows: first we assign $$$T_i = T_{i - 1}$$$; then, if $$$a_i$$$ occurs in $$$T_{i - 1}$$$, then we will erase the number $$$a_i$$$ from $$$T_i$$$, otherwise we will insert it there.
Suppose we need to get answer on the query $$$[l, \, r]$$$. Note that if $$$x$$$ is included in $$$T_r$$$, but is not included in $$$T_{l - 1}$$$ (or is included in $$$T_{l - 1}$$$, but is not included in $$$T_r$$$), then this means that the number $$$x$$$ on the segment $$$a[l\dots r]$$$ occurs an odd number of times. Otherwise, the number $$$x$$$ occurs an even number of times (recall that $$$0$$$ is an even number). Thus, we need to find a minimum number $$$x$$$ such that it occurs either in $$$T_{l - 1}$$$ or in $$$T_r$$$, but not in both at once. If there is no such number, then you need to output $$$0$$$.
Let's go down $$$T_{l - 1}$$$ and $$$T_r$$$ in parallel on the same prefix of the number. If $$$T_{l - 1}$$$ and $$$T_r$$$ are equal, then the same numbers are contained there, and then the answer is $$$0$$$. Next, we will assume that the answer is not $$$0$$$. The left subtree of the vertex is the son to whom the transition along the edge of $$$0$$$ is going, and the right subtree is the vertex to which the transition along the edge of $$$1$$$ is going. Let us now stand at the vertices $$$v$$$ and $$$u$$$, respectively. If the left subtrees of $$$v$$$ and $$$u$$$ are equal, it means that the same numbers are contained there, so there is no point in going there, so we go along the right edge. Otherwise, the left subtree of $$$v$$$ contains at least one number that is not in the left subtree of $$$u$$$ (or vice versa), so we will go down the left edge. The number in which we ended up will be the answer.
Note that in order to compare two subtrees for equality, you need to use the hashing technique of root trees. Then we can compare the two subtree for $$$\mathcal{O}(1)$$$.
Thus, we get the asymptotics $$$\mathcal{O((n+q)\log{max(a)})}$$$. If we compress the numbers of the sequence $$$a$$$ in advance, then we can get the asymptotics of $$$\mathcal{O((n + q) \log{n})}$$$.
Let's consider the second way. Let's compress the numbers in the sequence $$$a$$$ in advance. Let $$$pref_{ij} = 0$$$ if the prefix $$$i$$$ contains the number $$$a_j$$$ an even number of times, and $$$pref_{ij} = 1$$$ if the prefix $$$i$$$ contains the number $$$a_j$$$ an odd number of times.
Then, in order to get an answer to the query $$$[l\dots r]$$$, we need to take the "bitwise exclusive OR" arrays $$$pref_{l - 1}$$$ and $$$pref_r$$$ and find in it the minimum $$$j$$$ such that $$$pref_{ij} = 1$$$. The number $$$j$$$ will be the answer.
Obviously, now this solution need much time and memory.
In order to optimize the amount of memory consumed, we will use bitsets. However, even in this case, we consume memory of the order of $$$\mathcal{o}(h^2 \, / \, 64)$$$, which is still a lot. So let's not remember about all $$$pref_i$$$, but only some. For example, let's get some constant $$$k$$$ and remeber only about $$$pref_0, \, pref_k, \, pref_{2k}, \, \data\, pref_{pk}$$$.
Then, when we need to answer the next query $$$[l \dots r]$$$, we will find the right block on which we store almost all the numbers we are looking for, and then we will insert/erase for $$$\mathcal{O(k)}$$$ missing numbers.
If you select $$$k \sim\sqrt{n}$$$, then this solution will fit in memory. However, if you use std::bitset<> in C++, then most likely this solution will still receive the verdict Time Limit. Therefore, to solve this problem, you need to write your own fast bitset.
The asymptotics of such a solution would be $$$\mathcal{O}(n\, (n+q) \, / \, 64)$$$. However, due to a well-chosen $$$k$$$ and a self-written bitset, the constant in this solution will be very small and under given constraints, such a solution can work even faster than the first one. | [
-0.00797334685921669,
0.005024474114179611,
-0.0031181483063846827,
0.026755008846521378,
-0.00011865099804708734,
-0.0034108206164091825,
0.03412086144089699,
0.026248764246702194,
-0.02733718976378441,
0.03318431228399277,
-0.007049451116472483,
-0.007169684395194054,
-0.018174169585108757... |
1496/A | null | 1496 | Codeforces Round 706 (Div. 2) | CF | 1,615,377,900 | 2,021 | A | 1 | 256 | Split it! | Kawashiro Nitori is a girl who loves competitive programming.
One day she found a string and an integer. As an advanced problem setter, she quickly thought of a problem.
Given a string $$$s$$$ and a parameter $$$k$$$, you need to check if there exist $$$k+1$$$ non-empty strings $$$a_1,a_2...,a_{k+1}$$$, such that $$$$$$s=a_1+a_2+\ldots +a_k+a_{k+1}+R(a_k)+R(a_{k-1})+\ldots+R(a_{1}).$$$$$$
Here $$$+$$$ represents concatenation. We define $$$R(x)$$$ as a reversed string $$$x$$$. For example $$$R(abcd) = dcba$$$. Note that in the formula above the part $$$R(a_{k+1})$$$ is intentionally skipped. | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1\le t\le 100$$$) — the number of test cases. The description of the test cases follows.
The first line of each test case description contains two integers $$$n$$$, $$$k$$$ ($$$1\le n\le 100$$$, $$$0\le k\le \lfloor \frac{n}{2} \rfloor$$$) — the length of the string $$$s$$$ and the parameter $$$k$$$.
The second line of each test case description contains a single string $$$s$$$ of length $$$n$$$, consisting of lowercase English letters. | For each test case, print "YES" (without quotes), if it is possible to find $$$a_1,a_2,\ldots,a_{k+1}$$$, and "NO" (without quotes) otherwise.
You can print letters in any case (upper or lower). | null | In the first test case, one possible solution is $$$a_1=qw$$$ and $$$a_2=q$$$.
In the third test case, one possible solution is $$$a_1=i$$$ and $$$a_2=o$$$.
In the fifth test case, one possible solution is $$$a_1=dokidokiliteratureclub$$$. | [
{
"input": "7\n5 1\nqwqwq\n2 1\nab\n3 1\nioi\n4 2\nicpc\n22 0\ndokidokiliteratureclub\n19 8\nimteamshanghaialice\n6 3\naaaaaa",
"output": "YES\nNO\nYES\nNO\nYES\nNO\nNO"
}
] | If $$$k=0$$$ or $$$s[1,k]+s[n-k+1,n]$$$ is a palindrome, the answer is yes.
Otherwise, the answer is no.
Note that when $$$2k=n$$$, the answer is no, too.
The time complexity is $$$O(n+k)$$$ for each test case. | [
0.023956872522830963,
-0.014050156809389591,
-0.005978790111839771,
0.045383188873529434,
0.0350106805562973,
-0.025249959900975227,
0.021537547931075096,
-0.010017949156463146,
-0.017602670937776566,
0.008627532981336117,
0.021398507058620453,
-0.01750534027814865,
0.007445679046213627,
-... |
1496/B | null | 1496 | Codeforces Round 706 (Div. 2) | CF | 1,615,377,900 | 2,021 | B | 1 | 256 | Max and Mex | You are given a multiset $$$S$$$ initially consisting of $$$n$$$ distinct non-negative integers. A multiset is a set, that can contain some elements multiple times.
You will perform the following operation $$$k$$$ times:
- Add the element $$$\lceil\frac{a+b}{2}\rceil$$$ (rounded up) into $$$S$$$, where $$$a = \operatorname{mex}(S)$$$ and $$$b = \max(S)$$$. If this number is already in the set, it is added again.
Here $$$\operatorname{max}$$$ of a multiset denotes the maximum integer in the multiset, and $$$\operatorname{mex}$$$ of a multiset denotes the smallest non-negative integer that is not present in the multiset. For example:
- $$$\operatorname{mex}(\{1,4,0,2\})=3$$$;
- $$$\operatorname{mex}(\{2,5,1\})=0$$$.
Your task is to calculate the number of distinct elements in $$$S$$$ after $$$k$$$ operations will be done. | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1\le t\le 100$$$) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers $$$n$$$, $$$k$$$ ($$$1\le n\le 10^5$$$, $$$0\le k\le 10^9$$$) — the initial size of the multiset $$$S$$$ and how many operations you need to perform.
The second line of each test case contains $$$n$$$ distinct integers $$$a_1,a_2,\dots,a_n$$$ ($$$0\le a_i\le 10^9$$$) — the numbers in the initial multiset.
It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. | For each test case, print the number of distinct elements in $$$S$$$ after $$$k$$$ operations will be done. | null | In the first test case, $$$S=\{0,1,3,4\}$$$, $$$a=\operatorname{mex}(S)=2$$$, $$$b=\max(S)=4$$$, $$$\lceil\frac{a+b}{2}\rceil=3$$$. So $$$3$$$ is added into $$$S$$$, and $$$S$$$ becomes $$$\{0,1,3,3,4\}$$$. The answer is $$$4$$$.
In the second test case, $$$S=\{0,1,4\}$$$, $$$a=\operatorname{mex}(S)=2$$$, $$$b=\max(S)=4$$$, $$$\lceil\frac{a+b}{2}\rceil=3$$$. So $$$3$$$ is added into $$$S$$$, and $$$S$$$ becomes $$$\{0,1,3,4\}$$$. The answer is $$$4$$$. | [
{
"input": "5\n4 1\n0 1 3 4\n3 1\n0 1 4\n3 0\n0 1 4\n3 2\n0 1 2\n3 2\n1 2 3",
"output": "4\n4\n3\n5\n3"
}
] | Let $$$a=\max(S),b=\operatorname{mex}(S)$$$.
When $$$k=0$$$, the answer is $$$n$$$.
Otherwise if $$$b>a$$$, then $$$b=a+1$$$ , so $$$\lceil\frac{a+b}{2}\rceil=b$$$ . It's not hard to find out that $$$\max(S\cup\{b\})=b,\operatorname{mex}(S\cup\{b\})=b+1$$$, so the set $$$S$$$ always satisfies $$$\max(S)+1=\operatorname{mex}(S)$$$. So the answer is $$$n+k$$$ when $$$b=a+1$$$.
Otherwise $$$b<a$$$. So $$$b<a \Rightarrow 2b<a+b\Rightarrow \frac{a+b}{2}>b\Rightarrow\lceil\frac{a+b}{2}\rceil>b$$$. In that case $$$\operatorname{mex}(S)=b$$$ is always true. So the element we add in all operations is always $$$\lceil\frac{a+b}{2}\rceil$$$. Just check whether it is in $$$S$$$ at first.
The time complexity is $$$O(n)$$$ or $$$O(n \log n)$$$ for each test case depending on your implementation. | [
0.02029426023364067,
-0.005842195358127356,
-0.012638342566788197,
0.0052588870748877525,
0.023976393043994904,
-0.019480060786008835,
0.00341782090254128,
0.027221044525504112,
0.014461180195212364,
0.02846057526767254,
-0.0028770456556230783,
-0.014461180195212364,
-0.0418766625225544,
-... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.