6 or 7

As a replier, I replied.

In educational rounds, all problems have the same weight.

+67 to get pupil

Prophet.

one

A was a 2D problem

i think if you are smart enough to rewrite gpt solutions in your coding style instead of just changing variables, you are likely not getting caught. the best you can do today is have fun solving contests

not only you

not only you

sort quotients increasing, remainders decreasing.

Here's where you fucked up. If you can't match a remainder to the lowest remaining quotient, you discard the high remainder but don't discard the low quotient.

keep track of your quotient index. Then iterate through your remainders (largest to smallest) if you have a match, increase your quotient index and add to answer, otherwise do nothing

My implementation is horrible for D (quite sure there exists some better implementation). But the primary idea was the greedy pairing of I(V / X).

they said there was a guarunteed solution

"there exists at least one way to choose l and r for each action and reorder the elements at the end so that a becomes equal to b"

The input testcases will contain only those where it's possible to do exactly n operations.

Actually, I quite like this kind of problem, especially for someone like me who can't solve problem F. It allows me to focus on enumerating the prefix and suffix scenarios of the question mark sequence without overthinking.

I would say D is quite good problem, no DS, no some obscure algorithm, no gpt.
Also it encourages good programming practice, the cleaner you write the easier to debug your logic.

GuessForces.

I know the pain !! I guess perhaps the admin can help with this problem??

Thinking about how to include more elements in a single operation. This value is equal to the smaller of the number of non-zero elements in the array and the sum of the array minus (n-1) (ensuring that there are numbers left to add in the remaining n-1 operations).

We can easily do it using binary search. We first count all the non zero elements of array B. Let's term this value nz. This way we know our answer x will always be 1 <= x <= nz. Now we simply binary search on the value of x.

For any "mid" which is a candidate answer of x:

sum(b[1...n]) — mid >= n — 1 should always be satisfied. Why? This is because if x is a genuine candidate answer, then there should at least be 1 operation of length x hence we see if the remaining difference is greater than n — 1. Because is no way we can increase the sum less than n — 1 in exactly n — 1 operations. 351013821

if sum of all elements == n then ans is 1; else we have to check, How many positions we can fill in one operation with non-zero elements. (as we can form a from b by shifting also)

The "dumb" solution would be: * sort the b ascending * start filling the a greedily — go through the b and choose l/r for every element, like this: l=i, r=n, for every i-th element record b[i] pairs * note the 1st such recorded pair is the longest one * the above is the greedy filling, which may end up in less then n rounds, lets say we have extra unused rounds (extra = n — number of pairs) and we need to distribute them somehow * now going in the pairs array in reverse, reduce the length of the pair to 1, deducting the reduced length from extra * once extra == 0, the 1st pair is the longest one

yes

please share idea of C !!!

A, B, C, E, F could all be implemented in like < 40 lines without try-harding

if you look it is very simple once you get a simple math observation (that observation too is a maths fact only)

C is pretty standard binary search on answer. For x = q*y + r, we know that y > r. Also, if some no. of removals is possible then less no. of removals than that is always possible, so the partition point can be binary searched.

If we sort both q and r arrays, then it's obvious that taking a small prefix of both is good because smaller values of q and r will ensure that x and y remain <= k. Additionally, for each choice of r, we can take y = r + 1, as that will result in smallest possible values of x and y. If we were to test for an answer take, then we take take length prefixes of q and r arrays (after sorting) and pair them in reverse so that i-th largest r matches up with i-th smallest q. This minimizes the x value.

You can check my impl: 351181458