Hello Codeforces!

On Dec/27/2021 17:35 (Moscow time) Educational Codeforces Round 120 (Rated for Div. 2) will start.

Series of Educational Rounds continue being held as Harbour.Space University initiative! You can read the details about the cooperation between Harbour.Space University and Codeforces in the blog post.

This round will be **rated for the participants with rating lower than 2100**. It will be held on extended ICPC rules. The penalty for each incorrect submission until the submission with a full solution is 10 minutes. After the end of the contest you will have 12 hours to hack any solution you want. You will have access to copy any solution and test it locally.

You will be given **6 or 7 problems** and **2 hours** to solve them.

The problems were invented and prepared by Adilbek adedalic Dalabaev, Vladimir vovuh Petrov, Ivan BledDest Androsov, Maksim Neon Mescheryakov, Roman Roms Glazov and me. Also huge thanks to Mike MikeMirzayanov Mirzayanov for great systems Polygon and Codeforces.

Good luck to all the participants!

**UPD:** Editorial is out

It's rare that an official blog was posted 36 minutes ago and there are no upvotes.

I've pretended to be expert. But still I have ambition to be expert and never lose hope. Wishes to positive delta.

I've pretended to be specialist. But still I have ambition to be specialist and never lose hope. Wishes to positive delta.

You are candidate master, aren't you ?

UPD : Please don't downvote me x)

Last educational round in year, makes me feel nervous ...

19 educational rounds this year. We hope more in 2022 INSHAALLAH.

"INSHAALLAH" get your religion out of codeforces. If not, then here you go, I just made a religion I follow. It's total opposite of yours and I'm gonna shout its catchphrase. FUCKALLAH.

Right I said that. THAT was exactly for the inshallah and whatever the fuck the comment I replied to was saying. Now I know you religious cunts won't stop with your shit, so I better give it to you the same trashy way you do here.

orrrrrrr you can go and solve some problems and focus on getting better at cp since ur just wasting ur time and offending other people at the same time. time to grow up g

Just like you don't need permission to scream ALLAHALLAHALLAH anywhere, I don't need permission to do what I wanna do as well. Is it that hard to get, g?

nobody is telling u what u can and can't do. ig u can say were teaching u the manners which muslims learn at the age of 6.

screaming that probably needs permission, its not even permitted in islam because it could possibly bother the surrounding people. does it make u happy to make anonymous accounts and look ignorant, or do u show these comments to someone seeking their approval cuz its real sad either way <3

notice how u just attacked our religion in the worst possible way and all the muslim commenters replied with respect. u can learn a thing or two from us. allah yahdeek

All comments under this blog have more downvotes than upvotes

lighthearted memeFirst of all, happy holidays and a Happy New year!

lighthearted meme, for real this timehello community

For you — yes, it is

What's the bullying? Let's upvote him! Use all your fake accounts for this good deed.

I want to be in this rare moment, down vote me too!

1 upvote = $1 for poor kids in africa

Segment tree is very indian

Who let the downvotes out? I promise this is not a rickroll

Not a single comment (votes > 0).

a kid is spamming downvotes from fake accounts, i wonder how lonely he is and how he is enjoying this

Instead of downvoting, do programming !

lol why so many dislikes

Downvotes, Downvotes everywhere

Enjoyed problem C, very interesting. But It took me 3 tries to accept this porblem, but anyway I love it

OHHH! GOD ! I will become Master ??!! It only took two contests to go from expert to Master（maybe）and that's CRAZY!!!

So why you guys want to downvote evry comment? Ok, that's fine.

congratulation!! hopefully one day i will become green :')

Thanks bro. I hope it will happen soon

Great, congratulations, i'm still trying really hard to reach specialist.

You didn't become Master finally ...

Yep. I'm getting so frustrated now. 2095 what the fuck

Hope next time you will reach it ...

What about the idea that every upvote's or downvote's value is function of current rating, contribution and account creation date?

May be it is non-democratic..

It's strange how you don't do any significant change in the code and still expect it to get accepted each time.

6 wrong submission on C.

Wrong on pretest 2 forces ;)

I initialized my answer as 1e9 instead of 1e18 (because I had my INF defined at 1e9) and it gave wrong answer on test 4. Checked my algorithm 4 times but never ever thought of checking the value of INF. After checking tourist, did I find out that my algorithm was exactly the same as his and then I noticed his INF then I changed mine and boom Happy New Year! Damn, this sucks man, no more this small of a mistake may make my delta negative. No more 1e9s. You live, you learn I guess.

Hi, I looked at tourist solution as well but I don't understand one part. May I ask why do we calculate the extra decrement step as follow?

`cur += (diff + t) / (t + 1)`

I get the

`diff / (t + 1)`

part but what does the`t / (t + 1)`

represent?We need to calculate ceil(diff/(t+1)), and it is well-known that ceil(diff/(t+1)) = floor((diff+t) / (t+1)).

Thanks for your reply, that is an interesting properties! Do you know where can I find more reading/proving on this relationship? Quick google search yielded nothing :(

Hey i was struggling with the C..and i gone through your comment and i have did the same kind of error..now its accepted

Can someone give a hint on task D please?

Find number of strings where first position where it differs from original string is ith

and last such position is jth.

My solution to the problem D. https://codeforces.com/blog/entry/98410

Could you have a look at my code? I think I've done something similar.

If it's not too much trouble. Thanks

SpoilerInputExpected OutputYour OutputFixed now. Thanks!

Can problem C be solved with binary search on number of moves??

That's right.

i was not able to implement parity function successfully :( Thanks

It can be done without binary search in O(n). You can look at my 2nd submission. The idea is that we can reduce the smallest number by 1 x times and make the largest b numbers equal to that smallest number (after reduction) such that the total sum is less than k. We can iterate over b from 0 to n — 1 and find out x in constant time (with some precomputation of a prefix sum array) so that it follows the Sum <= k rule. And then just take the minimum of all such b + x.

Since the input has to be sorted it is O(nlogn)

Ohh yes. I dont know how I missed that. Thanks for correcting me.

Yes. I did it this way. See my solution

Yeah but you should make some observations at first.

that's what i am saying to myself after not getting AC i should have spend more time on my notebook rather than trying to implement it quickly Thanks

some number X of I operation only for smallest element, second operations for Y of biggest numbers. so iterate on Y from 0 to n-1 and find minimal X with binary search.

You can find minimal X in constant time (if you precompute the prefix sums array) using a simple formula. I did it so.

ll X = max((a[0] * b + a[0] + b + (r — k)) / (b + 1), 0LL); why you add b before (r-k)? because in division you round up?

I solved it using binary search .

But after the contest :(

https://codeforces.com/contest/1622/submission/140825675

My solution to the problem D. https://codeforces.com/blog/entry/98410

Loved the E!

chef's kisshow to solve C

Binary search

Actually it works also without binary search. Observe that there are at most n-1 copy steps, and all decrease comes before the copies.

Then we can iterate the number of copy steps from n-1..0, and foreach one calc the number of needed decreases in O(1).

Looks like O(n), but since we first need to sort the input it is O(nlogn)

Actually my solution is the same. I just use binsry search to calculate the decreases(though I know that it can be abtained in O(1))

Nicely Explained bro...thnx for comments in yur code. Helped a lot

Why do div1 players in official standings?

Thanks for short and clear statements!

Can someone help me understanding what I did wrong in solution C? 140802492

I made chances array which indicates chances that will be required by decreasing small element by some amount and changing all elements from i to n — 1 for i in [1, n) and took minimum of them.

set a4=a3=1;//step = 1;

decrease a4 by one, and get a4=0. //step = 1+1=2

3.choose a7 and decrease in by one** 3 time**; //prev step = 2+3=5

4.choose 4 elements a6,a8,a9,a10 and equal them a7; // here isn't

4 steps? prev 5+ this 4?as in every step we can choose just 2, ai and aj? so according to their explanation, the answer is 9. but how did they come up with 7?

We try to decrease lowest element and flip highest elements. For given case after sorting we get 1 1 1 2 2 3 6 6 8 10 and required value is 1. One solution is -2 1 1 2 2 3 -2 -2 -2 -2 and get sum as -1. Here we decreased first element by 1 3 times and changed last four elements to -2 using first value so 7 operations

Your submission gives

`-2`

when I used the following input:Oh thanks for clarifying should have used max with 0 when I finding chances. Thanks for taking time to find the issue. It is accepted now[submission:140828937]

Just curious , why the constraints were set for a O(n^2) or maybe O(n*k) solution for D? Is there any solution that relies on this small constraints (like maybe a dp)? I could only come up with O(n) solution.

can you please elaborate your solution for problem D.

I did in the following way, not exactly dp but combinatorics. Let i and j be two indices I want to find the number of string which exist such that prefix upto i and suffix upto j is same as that of the original string, then s[i+1] can not be equal to the original value, and s[j-1] can not be equal to the original value. so s[i+1] and s[j-1] remain fixed and number of 1 between i+1 and j-1 has to be <=k. then we need to shuffle (j-1)-(i+1)+1-2 characters in the usual combinatorics fashion and add the answer for all i and j.

Great explanation Got it thanks:).

The number of 1 between i+1 and j-1 has to be equal to k right ? So that we can shuffle the substring. Why <=k?

if you have a string containing k ones... you can always shuffle a substring of it containing less than k ones... then also we can pretend we have shuffled that substring with k ones. Actually, if you use exactly equal to k, you will not consider the above case and will undercount.

Yeah there is straightforward soln to it in $$$O(n^{2})$$$

SpoilerFind number of strings where first position where it differs from original string is ith and last such position is jth

my submission

KOVAL_ IS A CHEATER!!!!!!!!!140792053 140792490

please reject his submissions MikeMirzayanov

Alien-level coding skills

How to solve C using binary search?

Suppose that you have to complete

`x`

operations. How this operations will look? Firstly you decreases minimal value, secondly all remain operations you spend for replacing maximal values by new minimal value. We can sort all elements, then you decreases begin and replace some suffix. You can try different suffix length from`0`

to`min(x,n-1)`

and for all possible length calculate sum in`O(1)`

. 140781854Thanks a lot.I was having exact same idea but couldn't implement it during the contest.Seems like binary search wasn't a intended solution for this problem

I had the same binary search idea. The thing is: if you fix the number X of operations of the first type (decrease min value), in O(1) with math you can find how many replace operations you will need to have the sum <= k. I actually coded the binary search, but something was wrong. Then I realized this idea which leads to an O(n) solution.

The code: https://codeforces.com/contest/1622/submission/140778410

PS: the if inside the main loop is the number of 2nd type operations needed.

Can someone give me a counter-example for my approach to C?

1) Sort the array

2) For every index $$$i$$$, we will copy the value of the smallest member i.e $$$arr[1]$$$ from $$$i+1$$$ to $$$n$$$, but before copying we will find the minimum decrements, $$$d_i$$$ in $$$arr[1]$$$ that are needed so the constraint of sum $$$ \le k$$$ is satisfied

To be precise, let $$$m$$$ be the smallest member, then for every index $$$1\le i\le n$$$ we find smallest non-negative $$$d_i$$$ such that-

$$$prefixsum[i]-d_i + (n-i)*(m-d_i) \le k$$$

where $$$prefixsum[i]$$$ is the sum from $$$1$$$ to $$$i$$$ in the original sorted array

Overall, the answer will be minimum of all the $$$d_i + n - i$$$ over all $$$i$$$ because we do $$$d_i$$$ decrements and $$$n-i$$$ copy steps.

Here is my submission. Gives WA on test 2.

EDIT:

I found the error, int x = -1/2 will give x=0 and not x=-1. I had an implementation bug. My code failed for the following case-

5 6

1 4 1 1 1

Your submission sounds quite close to mine. I also WA on test 2 before I added ans = min(ans, sum-k), where you only do decrements and no copy steps.

If we solve this equation di can never be zero.

So the case where di is zero i.e no decrement operation and all set operations is not covered?

Counter example:

Your solution gives 3, but I think the correct answer is 4.

Thanks bro ur a genius.

After 7 wrong submissions finally got to see Happy new Year

I solved C without binary search (more of like greedy approach)

First of all the main observation is we should always decrease the smallest element and then make some greater elements of array equal to the smallest element.

Now simply brute force over the total number of values which you will make equal to the smallest element (suppose it is x) and the smallest element is decreased to a value y

then,

we know

sum of remaining elements + x*y <=k

calculate sum of remaining elements using 2 pointer or prefix sum (your choice)

and brute force over all values of x from 0 to n-1

and take minimum over all values

for more clarity look at the submission 140822105

Your submission 140822073 to problem D matches with 14 others submission. Didn't even bother to change variable names 140820526 140820106 140820061 140818753 140818368 140817941 140816493 140815737 140815061 140814699 140809415 140806767 140801839 140820649 Request to MikeMirzayanov to Kindly skip these copied solutions

Bro I didn't gave contest I just solved it

I wasn't able to solve D by myself so I saw my friends submission and submitted the same.

Bro . Thanks for your Approach i solved it by myself after reading your comment. The only case i was failing is when val % y == 0 i didnt thought about it :_;

Here are my solutions for Problems A-D, you can check it out, since edu editorials take time, they come after hacking phase usually.

when I pressed sumbit for problem D, notification of contest end appears then I couldn't submit and get contest is over.

I got pretest passed on 18:36 UTC+2 :(

I want to know what is wrong with my approach for problem c

submissionYour text to link here...

My approach:-

sort the array

taking subarray from index 1 to $$$i$$$.

finding then how much should $$$ar[0]$$$ be decremented so that after replacing $$$i+1$$$ to $$$n-1$$$ index with the decremented number the sum is $$$<=k$$$

for this I used following equation Let $$$S$$$ denote the sum of number from index 1 to $$$i$$$

then $$$S + (n-i)*x<=K$$$ where x is the number to which all the remaining numbers will be changed into.

Found optimum $$$x$$$ from the above inequality and got the number of moves to do the said changes. Took minimum of all.

I've posted almost the same comment, I got WA on test 2 with this approach as well

yup saw just now.

If you get yours resolved please ping me

If we solve this equation x can never be zero.

So the case where x is zero i.e no decrement operation and all set operations is not covered?

$$$X$$$ from above inequality floor($$$(K-S)/(n-i)$$$) therefore it can become 0.

I found the error, int x = -1/2 will give x=0 and not x=-1. I had an implementation bug. My code failed for the following case-

5 6

1 4 1 1 1

in my code I took care of that.

I handled the negative separately.

Hey, can anyone look at my submission for C and tell me why my code fails. It fails on some testcase number 2571 so I can't see the testcase, but I can't figure out what's wrong with my approach.

Code

Approach: Sort array a. Take l = LLONG_MIN, h = a[0]. Then binary search on the values that I need to decrease the smallest number to. So my countMoves() function counts the moves if I transform a[0] to mid and then assign the new value to the largest numbers from the end until sum > k. If the number of moves are better than previous best, I increase l to mid + 1, else I decrease h to mid — 1.

Because the function countMoves() for value between the range is not monotonically increasing or decreasing. Instead it is [ decreasing -> increasing ]. So you need to modify your.binary search accordingly.

I can't figure out how to modify my binary search according to that, could you help me out

Binary Search Complete Code Explained . I have explained in best way possible. For anyone looking for solution using binary search.

Unsure why my binary search solution for C isn't working. Could someone please take a look?

Try this testcase

Can you give me some hints about how to solve problem 1622E - Math Test?

Maximizing the absolute value is kinda hard, so let's use the fact that there are at most $$$10$$$ students. For each student, there are two ways to evaluate the absolute value in their contribution to the answer: either $$$x_i - r_i$$$, or $$$r_i - x_i$$$. You can iterate on $$$2^n$$$ different ways to evaluate the absolute values, and then maximizing the answer without absolute values becomes much easier (use Contribution to the Sum technique).

Thank you! Solved with your hint 140833798

how to prove that this will correspond to a valid answer (for the max answer atleast) because for some permutations to maximize the sum even though you "force" a student to score lower than expected from the bitmask, you might still assign a permutation that makes the student score higher than expected or vice versa

I'm not able to figure out full proof, but maybe proof is based on statement that if we can't get answer for this algorithm, which provide maximum possible answer, then we can't get any other answer. Looks like need to assume that we can get correct answer for permutation with less result, which satisfies constrains for module expansion. Then with several number of swaps of two elements in permutation we can get maximum answer — contradiction.

For some bitmasks it's true that final setup may not correspond to the definition of that bitmask. But it will give some value, which is less than or equal to one of the valid setups for the bitmask, which is equal to current bitmask with its invalid bits flipped. Let's say based on the value of bitmask, we assumed that for some student,

Xcontributespositivelyand question scores contributenegatively. But we ended up withX <= score(1) + ... + score(M). But since,X — (score(1) + ... + score(M)) <= 0 <= (score(1) + ... + score(M)) — X, if we will flip all such invalid bits, we will end up with some larger or equal value which corresponds to one of the correct solutions of flipped bitmask.Now let's say maximum value occurs with some bitmask in a valid way. When we process that bitmask, we generate maximum possible answer, due to

X's are fixed and if we distribute scores according to sorted list of correctly answered questions. Our distribution itself may be invalid, but since we know that mathematically this is the largest possible answer according to our formula, and it is less than or equal to some valid answer. This means that we will find our maximum value when we will process the bitmask which results in that maximum value.Deleted.

Thanks to everybody who joined the stream! Specifically, thanks to TimmyThinMints for streaming with me, to BledDest and tourist for helping us with F, and everybody else for joining in! I very much enjoyed the problems, especially working with everybody to figure out F.

Update: link to stream: https://www.youtube.com/watch?v=RM96b68TPv8

I used the idea you shared in your stream to solve C, but got stuck on test case 2. This is my submission with some comments : 140832114. Can you help to point out where the error is? Thanks!

Try

The optimal move is to convert 9 to 1 in

onemove, making the sum as $$$(1 + 1 + 3 \leq 8)$$$ but your output is 5.Oh, I think I see what went wrong now. When fixing the number of largest elements to be replaced, call it T, the correct approach is that we first replace the T largest elements with a[0] (the smallest) without modifying a[0]. We should do the replacement first because it is possible that we do not even need to decrease a[0], just like your counter example.

What I did in my incorrect solution was to decrease a[0] first, then do the replacement.

Thanks! This counter example really helped:)

finally will be expert.thanks for the contest

If anyone is looking for video Solutions,Here they are(for A-D)

Its one thing to copy someone elses code... Its another thing when you include their watermark

Links for proof:

https://codeforces.com/contest/1622/submission/140830587

https://codeforces.com/contest/1622/submission/140830801

https://codeforces.com/contest/1622/submission/140830622

Are you unhappy about something? Giving credit to the original author (rather than stripping out this information) was surely the right thing to do and I don't see anything wrong with that.

I would be happy but I know they did this so someone would hack the solution and then they would use that hack against me.

.

Here is my guess of your code:

cntis the number of 'big numbers' you want to set to a small value.cnt+1means the 'big numbers' and the minimum number in the array. All of the 'cnt+1' numbers will have the same value of the minimum number after the 'set' operation.totalis the total sum of the unchanged numbers.(total-k)is the reduction amount needed to satisfy the requirement of the final sum of the array being <= k.(total-k)/(cnt+1)is the reduction amount per element, element which changed.(total-k+cnt)/(cnt+1)is the rounding up of the above division.cnt + (total-k)/(cnt+1)is the total number of operations needed. The first term accounts for the number of 'big numbers' being set to the value of the new minimum. Each 'big number' requires one operation. The second term is the number of operations required for bringing down the minimum element into an even lower minimum if necessary.140835874 Can someone tell me what im doing wrong for problem C. The above code fails in the 4th test case(It's too large so can't paste it here ,sry ).

My approach is for every prefix of the array(sorted in decreasing order), what is the maximum value, the smallest number can be reduced to and then assign it to all the numbers in the prefix so that the sum becomes less than or equal to k. Of all such values im finding the one with min operations. Thanks :)

use

not

Binary Search Complete Code Explained . I have explained in best way possible. For anyone looking for solution using binary search.

If anyone would like a solution for problem C, here it is :

Solution for **C. Set or Decrease** https://codeforces.com/contest/1622/problem/CFirst of all, let $$$A$$$ be the array sorted (from indices $$$1$$$ to $$$N$$$).

It is pretty obvious that we should first reduce the minimum (of the array), and then copy this value to the other elements of the array.

Let us denote $$$X$$$ the number of times we reduced by $$$-1$$$ the minimum (let's call it $$$M$$$), and $$$Y$$$ the number of elements assigned to this value.

After that, what are the $$$Y$$$ optimal elements to choose ? Since we want to make the difference between before and after bigger, the $$$Y$$$ elements to choose are the $$$Y$$$ biggest elements of the array.

Let's calculate the sum of the elements after the operations : in fact, it is

$$$(A_1 - X) + A_2 + \ldots + A_{N-Y} + (A_1 - X) + (A_1-X) + \ldots + (A_1-X) $$$

Now, notice that $Y$ can be up to $$$N$$$, so let's iterate on $$$Y$$$ and look what will happen :

First, $$$\sum_{k=2}^{N-Y} A_k$$$ can be easily calculated by precomputing prefix-sums, so let's note this sum as $$$S$$$.

Let's not forget our goal, i.e. find the least $$$X$$$ that satisfy the inequality

$$$S + (Y+1)(A_1-X) <= K$$$, where $$$K$$$ is the bound. Now, let's manipulate the inequality :

. Thus, we calculated the optimal $X$ in $$$O(1)$$$, which is $$$\left \lceil{\frac{S-K}{Y+1} + A_1}\right \rceil $$$.

This algorithm works in $$$O(N)$$$, with prefix-sums and iteration on $$$Y$$$.

Hope you liked my explanation !

Could anyone give me some advice please?

I could finish A,B,C in 30 minutes, however I could not work out problem D.

Maybe I can not solve such math problems,

could you please share some blogs or documents for me?

Solve problems in Archive with difficulty >= 1800 with tags "Math" and "Combinatorics"

hey! why my O(n*log^2(n)) solution for B is getting TLE? link:- https://codeforces.com/contest/1622/submission/140858246

I'm not getting what you have done! But, this could be easily solvable by assigning numbers from

1 to xto the non-decreasing sorted order of disliked song andx+ 1 to nthe non-decreasing sorted order of liked songs.yeah that can be done but why TLE? O(n*logn) should pass

lower_bound(set) is slower than set.lower_bound try to fix it

Can someone explain how can correct output of any testcase be 0 for problem D, I have seen some testcases in hacks and couldn't figure out why the correct output is 0.

It happens when the actual solution is a multiple of MOD.

Oh right, stupid me. Thanks !

Can anyone explain how D can be done in O(n^2), they are checking for cnt[1] <= k and also what is the relation with the boundary elements to be 1 or 0?

For any substring to be shuffled, if the boundary element of this substring(right most) is not changed, no matter how much we shuffle all other elements, all the resulting substrings have been already counted during shuffling of substring which occured before(if current substring is not the first one to be shuffled). Therefore for generation of new strings boundary element must be changed. But this is O(N) solution using two pointers. I still don't get how to solve this in O(N^2).

In problem D changed (x — y) % MOD, to (x — y + MOD * MOD) % MOD, and got AC. What a stupid mistake

I can't solve problem F by thinking for a long time. I hope fast editorial.

+1, why and how to proof (the size of answers) $$$\approx n$$$?

SecondTrhead's livestream, with tourist and bleddest help through the chat helped me understanding the solution:

https://youtu.be/RM96b68TPv8?t=2366

I joined a few days back and participated in yesterday's round 120 and solved one question with successful submission but my rating has not increased. Could someone please tell the reason as I am joined just a few days back.

The ratings have not been updated yet! Im sure in a few minutes it will tho

It's confusing that $$$n$$$ in problem D is only $$$5000$$$, for there is an obvious $$$O(n)$$$ solution using simple inclusion and exclusion.

Maybe the purpose of that is to confuse contestants.

It was an educational round for the participants rated lower than 2100. Their opinion about what is "obvious" and "simple" may naturally differ from yours. I would check the official editorial to see what was supposed to be the intended solution.

Moreover, with a 12 hours hacking stage, there's always a risk that somebody may come up with a very evil hack, exploiting cache misses or branch mispredictions to significantly reduce performance. So setting excessively tight time limits and/or constraints for any problem is dangerous in this contest format.

I agree with the first one. However, $$$n=5000$$$ is obvious not for $$$O(n)$$$ but for $$$O(n^2)$$$.

O(n)? What about n choose r? It is at least O(n log n) right? Am I missing something?

PS: just saw your code, you just used one fast exponentiation for the precalculations, forgot about this idea, it is actually O(n)

Ah, you can calculate the factorials and their inversions in $$$O(n+\log\mathit{mod})$$$ time. You can see my submission 140805732.

When will the editorial be available? Also, how can the answer be 0 in problem D? I don't undestand... please, help!

We have to print

`answer % 998244353`

. So if the actual answer is a multiple of 998244353, then the printed answer will be 0.It happens when the actual solution is a multiple of MOD.

Is the editorial out?? If not when can we expect it? Thank you.

Auto comment: topic has been updated by awoo (previous revision, new revision, compare).