No interactive problem?

yo, how to be a tester?

I have actually been forced by cf admins to test all rounds :(

controversial but fair enough

what is the max rating, with which we can participate in div4?

lol sad

they usually say it in the announcement

no, the score table shows, the score you will get if you accept it at that time on your "first attempt".

in your scenario, the person will get a score which he would've if he accepted it at "1:59" on his first attempt, but because it isnt his first attempt, he will get additional penalty.

let's consider this as revenge :D

YES PLS.

Shut up, cheater

Bro wtf use a code formatter. Messing up your formatting will not fool the plag checker anyway.

Not too sure whom to ping for reporting suspicious accounts. shorya1835 Can you do something about this user ambarmishra19?

Skipped solutions, code obfuscation, Java TM, yet their editorial blogs have solutions in C++, etc.

Nice to meet you, fellow gentlemen.

C?

all problems LOL

C :skull:

i got it on both C and E1

Doesn't this question reduces to find minimum in odd and maximum at even index such that their absolute difference of index is maximum? Also further we can check that if max_at_even — min_at_odd + abs(odd_index — even_index) >= n-1, if this suffice then we can swap those elements?

i actually did that, but got wrong answer on pretest3, dont know what that test case??

gpt was able to solve d

for A neither was it explained when the string is sorted. Only in testcases you were shown that 1100 is not a sorted string.

these are my notes for C:

"""Alice wants to maximize, Bob wants to minimize. Result is cost + alternating sum of array. In a turn they can end the game or they can swap two values, which increases the cost. It is optimal for Alice if this is the maximum value she can achieve. Either because it is the absolute maximum or because it will decrease if she doesn't end. Vice versa for bob: End if absolute minimum or if it will increase if not end now. Swapping adds r-l (indices) to cost, so is in favor of Alice. Alice would want to swap a large value with high odd (0-indexed) index with a small value with low even (0-indexed). This increases sum and increases cost most. Bob can always undo the move of Alice. Alice can always undo the move of Bob. This is advantageous for Alice, because costs keep increasing. Therefore Bob will always terminate immediately. Alice only terminates immediately if swapping reduces the sum. Just need to determine if swapping once any two numbers increases the total value... Added value from swapping depends on left and right value and left and right index.

.... could not figure out how to compute cost efficienctly......
"""

From what I could think of.

There will only be 2 interation in total. Because bob will always end the game.

Now the problem is boiled down to how can alice make the best of this one chance she has.

1.She can either swap from max(odd)&min(even)+(take care of index cost as well)

1. if (min(odd)>max(even) then alice will swap with last most odd index to keep the max element with herself.

2. check if there is some random even and odd index pattern whose delta will be greatest.

How'd you fix the WA on test 3? I got the logic in 10 minutes but WA 3 was soul sucking.

did it

Try the Test Case

1
7
2 6 1 2 2 3 3

Correct Output Should be :- 8 (swap 2nd, 3rd elements) But Your code will give :- 6

I had to spend a lot of time to understand how the cyclic movements work in this problem, as if it were possible to make a more detailed description of how these shifts work, did the testers immediately understand how they work, it seems to me the only thing they do is write under each contest that THIS IS THE BEST CONTEST IN THE WORLD THAT I HAVE TESTED!!!

I think it has to do with the fact that for 2n points, pairing the first half and second half in any order is optimal. Assigning each segment an l and r does not change the optimal case. There must be at least n/2 "r" points on the right side of the median, otherwise there are more "l" points so by php at least one of them is unpaired. So we should be able to greedily pair segments with r to the right of the median with segments that have l to the left side of the median. If a segment has its r on the right and l on the left of the median, we can save it for later. At the end we can just pair the saved segments together. Is this right?

Let's say $$$n$$$ is even.

Then you have to choose $$$n/2$$$ $$$r$$$'s and $$$n/2$$$ $$$l$$$'s (independent) such that the answer, sum_choosen($$$r_i$$$) $$$-$$$ sum_choosen($$$l_i$$$), is maximum.

Another way of expressing that is as sum_choosen($$$l_i + r_i$$$) — sum_all($$$l_i$$$). Clearly, you have to choose the $$$n/2$$$ biggest $$$l_i + r_i$$$. That works because the choosen elements will cancel it's $$$l_i$$$'s substraction, leaving the original formula.

You can do it similarly if $$$n$$$ is odd.

can you run it on your machine for 1e7 to 1e8 .. and see if it finishes ? .. like don't take input and just make another loop outside

In fact the answer is x*2.

just switch to c++, your life will be much easier

You can always choose y = 2 . x now if x has k digits then x # y will become x . 10^k + 2 . x which is equal to x . (10^k + 2) and x + y = 3 . x as both of them has a common factor of x and 10^k + 2 is also divisible by 3 (as the sum of digits is 3) so x # y is always divisible by x + y

this is not going to work, i found a solution for this problem in youtube which solved in O(1) link, have a look at it once

import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        int t = scanner.nextInt();
        
        while (t-- > 0) {
            int x = scanner.nextInt();
            long y = 2L * x;
            System.out.println(y);
        }
        
        scanner.close();
    }
}

Not sure if correct, but I thought that the cyclic thing was more or less equivalent to swapping two values. (The third value is redundant, just pick another zero at the front or one from the end.) Then I used two pointers, one from the left (to find the first 1) and one from the right (to find the first zero). Swap values. Increment ans. Repeat until left >= right.