As a tester, I knew that Monogon will be here for contribution:)

As a Digon you have my upvote

As a (first-time) tester, my name is not in the list :(

UPD: Now it is.

As a first time tester, can I get some contribution?

Monogon is Donald trump of code forces!

In your CV/Resume make sure to mention "Past Job Experience : Tested more than half of the CF rounds."

ORZ Ashishgup

And I wish all the best for all those who are going to give this round...

** Indian Round by Ashishgup

The game will be played between Ashishgup and FastestFinger , I guess.

forget about him if he is placed or not are u placed or not ? he is already a grandmaster and u are saying he is not placed , what are u saying please check to his linkedin profile !! you will say then awoo tourist vovuh and all those who are preparing contests for all of us are not placed !!

don't make any assumptions yourself !! attend the contest solve the problems !!

Hoping for a good round with good problem sets Ashishgup as always!! all the very best everyone !!

These guys have 100 hrs in a day!

:D

Yes.. After 4 days div3 will be held. See the codeforces calendar. You can add it with your google calendar. It's so helpful.

you're right, it's very OverPopulated

ah, whats an Indian round without a mandatory thread like this

Machaya bhai!!!

hrishabh314, dekh.

It's a trap.

you hope, but it's not possible that everyone will have a good rating.

Trying to get the contribution .....

I think it is a mistake. This announcement has wrongly been routed to that round. My guess is you won't find this announcement in today's round's contest materials.

Probably giving a contest from your account.

gl

Because most other reds are smart and decided not to waste time farming contribution.

rotavirus

(Also, since I'm not a setter/tester of this contest, this is veryyy irrelevant)

On last div2(not edu.) B's score was 1000 and C1's 750. Was C1 easier than B?

You don't trust scoring distribution nowadays. Especially not in Ashishgup's rounds.

A is trivial. Look at the number of submissions

I got 4 WA on A and almost kill myself when got AC

Lol

Seems like you're new to Ashishgup rounds

it should not contain almost any observations, just implementing what you're reading

Then people will say they were judged in A on the basis of typing speed and not thinking skill.

There should be some sort of idea involved , it can be very basic though for A .

Note : I solved A after more than 3000 people solved but i don't think it was not suitable for being A.

If I may offer my opinion as a tester, today's A is more prone to being WA'd by higher rated participants than lower rated participants, more CM+ testers went along the wrong route of divide then subtract than our specialist / expert or lower testers. Also I am curious what your solution was? The intended solution was min(n — 1, 2 + (n & 1)) (Odd -> Even -> 2 -> 1).

yep, this made me leave this contest also somewhat similar to this problem : https://leetcode.com/problems/minimum-number-of-days-to-eat-n-oranges/ .

A had literally 1 observation: if n is even, it can be reduced to 2 in 1 step. Also all the corner cases were already present in the samples.

Many other A's in div2s are like that (not direct implementation). Its better that way maybe as there is also a div 3

I know that feel

Spent 25 minutes and two WA on A

But somehow it was obvious for thousands of other contestants

Let's say the answer array named A. Use the value of A[1] (which is at first still unknown) as a pivot, ask the xor value between A[1] to the rest of the number, and keep those values. At this moment, you already asked n - 1 queries.

Then, look into your xor-s values, if there is at least two same xor result in different index (let's say index i and j), you can ask the and value of index i and j. The and value must be A[i] and A[j] since it is the same. Then conclude A[1] and the rest of the array. You only use in total n queries for this case.

If there is no same xor values, then the array must be a permutations of 0..n-1. To find the value of A[1], you can use the index which has the xor value 1 and 2 to A[1], let's say the index is id1 and id2. Then, ask and 1 id1 and and 1 id2. From here, you know the correct bits of A[1] except for the least 2 bits. For the most right bit (the least one), you can use the result of and 1 id2 since the difference must only occur in the 2-nd least bit. For the 2-nd most right bit, use the result of and 1 id1 since the difference must only occur in the least bit. Last, construct A[1] and conclude the rest. You only use in total n + 1 queries for this case.

It's clear that either there exists $$$a_i$$$ and $$$a_j$$$ that satisfy $$$a_i=a_j$$$, or $$$a$$$ is a permutation.

For each $$$i>1$$$, query the XOR of $$$a_1$$$ and $$$a_i$$$ and let it be $$$X_i$$$.

If there exists $$$X_i=X_j$$$ (this can be checked with $$$O(n)$$$ complexity), it's obvious that $$$a_i=a_j$$$, so we just need to query the OR of $$$a_i$$$ and $$$a_j$$$ to get $$$a_i$$$ and then work out the whole array.

Otherwise, as $$$a$$$ is a permutation and $$$n\ge4$$$, there certainly exists $$$a_{k_1}$$$ and $$$a_{k_2}$$$, where $$$a_{k_1}\oplus a_1 = 1$$$ and $$$a_{k_2}\oplus a_1 = 2$$$. We query the OR of $$$a_{k_1}$$$ and $$$a_1$$$, which is equal to $$$a_1$$$ except for the last bit. Then we query the And of $$$a_{k_2}$$$ and $$$a_1$$$, which is equal to $$$a_1$$$ at the last bit. And therefore $$$a_1$$$ can be calculated, so as the array.

You look at the point with maximum x, such that (x, x) is inside your circle. If any move from (x, x) loses, player 2 wins. After the first move, the state will be (0, k) and player 2 simply plays copy-cat, (k, k). This way we reach (x, x) when it's the first players turn, so he loses. In the other case, player 1 wins. I will let you find the proof and if you can't I will provide one

if N is even then ans is 2 else ans is 3 base case is for n=1,2,3

The question states that division by proper divisors is not allowed. So, it makes sense to keep the number even all the time. If you keep it even, you always can divide by its greatest proper divisor i.e. n/2.

When n is odd, decrease it by 1. When it is even, divide it by n/2 (the greatest proper divisor). This is the optimal strategy.

My guest is to solve with the case of n = 4, then find use the same code for the case n > 4, but I have not figured it out yet :((.

Actually, there is a method to deal with 1451E2 - Bitwise Queries (Hard Version) with no more than n queries and the contrast that n is a power of two is not needed.

Queries XOR 1 i for $$$2 \leq i \leq n$$$, the return value store in an array a.

If all elements in a are all disjoint, then the ans[1] must be the only number in [0, n - 1] which not appear in a~.(**not true**)

Else there must be at least one pair $$$2 \leq i,j \leq n, i \neq j$$$, such that a[i] == a[j], so query i, j, the return value will be ans[i], so ans[1] = ans[i] ^ a[j]

Then ans[i] = ans[1] ^ a[i] for $$$2 \leq i \leq n$$$.

Sadly, I had a handwrite mistake in my code and I'm not good at debugging Interaction problem, so I don't pass this problem in this contest.

UDP: sorry, my method have a bug, thanks to ExplodingFreeze