AtCoder has returned with its Grand Contest 027 during the Sep 10 - Sep 16 week (problems, results, top 5 on the left, my screencast, analysis). There was a pretty tense fight for the second place with cospleermusora getting problem B accepted with less than a minute remaining; but tourist's victory was not really in doubt as he finished all problems with 25 minutes to spare. Congratulations to both!

I've really enjoyed solving problem D (the choice of constructive problems for this blog is becoming quite a pattern, isn't it?): you need to construct any 500 by 500 matrix of distinct positive integers up to 10

The second Open Cup stage, the Grand Prix of Udmurtia, followed on Sunday (results, top 5 on the left). Team Havka-papstvo had dug themselves into a hole thanks to having a lot of incorrect attempts, then marvelously escaped with just 8 minutes remaining by solving the most difficult problem. Congratulations on the victory!

The Grand Prix of Udmurtia was a pioneer of interactive problems in the past, and this incarnation had four of those, too. Problem E went like this: the judging program has a hidden string of 1000 digits, each either 0 or 1. In one query, you ask about a segment [

In my previous summary, I have mentioned another problem with segment queries: there's a hidden integer between 1 and 10

If the hidden number did not change, we would do a binary search: by querying the segment [1,

When the hidden number changes under the hood, we need to adapt this approach: now we go from [

So we will do the following: when the length

It's important to pick the right value of

Thanks for reading, and check back for more!

I've really enjoyed solving problem D (the choice of constructive problems for this blog is becoming quite a pattern, isn't it?): you need to construct any 500 by 500 matrix of distinct positive integers up to 10

^{15}, such that if we take any two vertically or horizontally adjacent numbers*a*,*b*in the matrix and compute max(*a*,*b*) mod min(*a*,*b*) we always get the same non-zero result.The second Open Cup stage, the Grand Prix of Udmurtia, followed on Sunday (results, top 5 on the left). Team Havka-papstvo had dug themselves into a hole thanks to having a lot of incorrect attempts, then marvelously escaped with just 8 minutes remaining by solving the most difficult problem. Congratulations on the victory!

The Grand Prix of Udmurtia was a pioneer of interactive problems in the past, and this incarnation had four of those, too. Problem E went like this: the judging program has a hidden string of 1000 digits, each either 0 or 1. In one query, you ask about a segment [

*l*,*r*], and the judging program returns one of the two things, each with probability 50%:- the number
*u*of 1s in the given segment - a uniformly chosen random integer between 0 and
*r*-*l*+1 that is*not*equal to*u*.

In my previous summary, I have mentioned another problem with segment queries: there's a hidden integer between 1 and 10

^{18}. You can make queries, and in one query you give a segment [*l*,*r*] and the judging program tells you whether the hidden number lies in that segment. In case it does, and your segment has length 1 (*l*=*r*), you win. After each query, the hidden number can change a bit — more precisely, by at most*k*=10. These changes do not depend on your queries — in each testcase the sequence of changes is always the same. You have at most 4500 queries to win.If the hidden number did not change, we would do a binary search: by querying the segment [1,

*m*] we can compare the hidden number with*m*, so if we knew that our number was within some segment [*a*,*b*] before our query, we would narrow it down to either [*a*,*m*] or [*m*+1,*b*] after this query, and determine our number after at most ceil(log(10^{18}))=60 queries.When the hidden number changes under the hood, we need to adapt this approach: now we go from [

*a*,*b*] to either [*a-k*,*m+k*] or [*m*+1-*k*,*b+k*]. When the segment [*a*,*b*] is big, this still divides it roughly in half, so we can proceed as before. However, when it becomes small, it will actually stop decreasing, and will never converge to a segment of length 1.So we will do the following: when the length

*b*-*a*+1 of the current segment is bigger than some boundary*b*, we will divide it in two using the above approach. And when it's*b*or less, we will just pick a random number*c*within the segment, and send [*c*,*c*] query. With probability of at least 1/*b*, we will win in this case. In case we don't, our candidate segment grows from [*a*,*b*] to [*a*-*k*,*b*+*k*], and we continue as before.It's important to pick the right value of

*b*: if it's too big, the probability of winning in each attempt of the second kind would be too low, and we won't always finish under 4500 queries. And if it's too small, it will take too many queries of the first kind between two queries of the second kind to reduce the segment size, and we would have too few queries of the second kind and also won't finish under 4500 queries. It's probably possible to find mathematically optimal value of b, or we can take a guess (I've used*b*=99 during the contest) and verify that it leads to good enough probability to finish under 4500 queries.Thanks for reading, and check back for more!