In this post, we answer some questions that participants have asked us.

**Q: Is there any way to bypass the **2^{64}-1** limit in Java or C++?**

**A:** Java has an arbitrary-precision library called java.math.BigInteger (and java.math.BigDecimal). Keep in mind though that problems used in official NOI contests usually won’t require the use of arbitrary-precision libraries. But we’re not preventing you from using them!

For C++, there is no built-in arbitrary-precision library, so it depends on the amount of “bypassing” you want. For example, you can simulate 128-bit integers by creating a class with two 64-bit integers, the first one representing the higher-order bits and the second the lower-order bits. If you want to use larger numbers, I suggest implementing your own arbitrary-precision arithmetic library.

**Q: What is the big O notation and why do I see it in editorials all the time?**

**A:** Roughly speaking, the big O notation expresses the speed of your program relative to the input size. In other words, it describes how quickly your program’s running increases as the input size increases. O(*f*(*n*)) roughly means that if the input size is *n*, then the running time grows approximately as *f*(*n*).

For another explanation, we recommend reading this. Also, don’t hesitate to ask us if you’re still having trouble understanding it!

**Q: What do you suggest for inputs where ***n*** is near the billions?**

**A:** For such problems, an *O*(*n*) solution would most likely not be accepted, due to the time limits. (Even a loop from 1 to *n* might not finish in time!) Try finding faster (sublinear) solutions, such as those that run in *O*(*√n*), *O*(log^{3}* n*), *O*(log* n*) or *O*(1) time (to name a few). Also, for *n* ≤ 10^{18}, some slower solutions, such as those that run in *O*(*√n*) time, become too slow for these time limits.

However, time complexities such as *O*(*n*) can be a bit misleading, because there is a hidden constant behind the *O*() notation. Also, using pure operation count as your basis for program speed isn’t necessarily more accurate either, because some operations are slower than others. For example, one division is much slower than one bit shift. It’s up to you to judge, and it takes some experience to get the hang of it.

**Q: What is “modulo”, and why do a lot of problem**

**s ask for the answer “modulo” some number?**

**A: **The result of the operation** **“*a* mod *b*” (read “*a* modulo *b*”) is simply the remainder when *a* is divided by *b* (here *b* is called the *modulus*). For example, 100 mod 3 = 1, 5 mod 100 = 5, 100 mod 5 = 0, and 0 mod 11 = 0.

Usually, a problem asks for the answer modulo some number so that the output size isn’t very large, and that computation can all be done without resorting to arbitrary-precision arithmetic. This is because of the following properties of the modulo operation (among others):

(*a* + *b*) mod *m* = ((*a* mod *m*) + (*b* mod *m*)) mod *m*

(*a* × *b*) mod *m* = ((*a* mod *m*) × (*b* mod *m*)) mod *m*

(*a* – *b*) mod *m* = ((*a* mod *m*) – (*b* mod *m*) + *m*) mod *m*

This means that intermediate values can be reduced modulo *m* safely as long as the operations involved are addition, subtraction, and multiplication (and possibly some other operations).

In C, C++, Java and Python, *a* mod *b* is written as `a % b`.

**Q: Why do a lot of problems use the modulus **10^{9}+7** if we could just use something else, for example **10^{9}**?**

**A:** 10^{9}+7 is prime, and a prime modulus is desirable in some cases:

1. Sometimes, if the modulus is 10^{9}, some important values become 0 for large inputs (or something trivial), making the problem a bit easier for those inputs. But usually when the modulus is prime, it doesn’t. For example, *n*! mod 10^{9} quickly becomes 0 as early as *n* = 40, but *n*! mod (10^{9}+7) is nonzero until *n* = 10^{9}+6.

2. You can “divide” modulo a prime by using modular inverses. Keep in mind though that modular inverses usually aren’t required in official NOI contests.

In some problems, the modulus plays a key role, and a problem can be very difficult with one modulus and easier with another. For example, if we ask you, given *n* ≤ 10^{6}, to compute *n*! mod *m* for some modulus *m*, then the problem is easy if *m* = 10^{9} but a bit harder if *m* = 10^{9}+7. So we recommend paying attention to the modulus.

**Q: How do I prepare for the NOI if I have limited knowledge on problem solving, algorithms and implementation?**

**A:** The best way to improve is to join online contests regularly. For example, HackerRank, Codeforces, CodeChef, etc. host programming contests regularly (for example, in weekly / monthly intervals). Check this link for a schedule of upcoming contests. Joining these contests is free!

If you have limited time, I suggest going through all past NOI problems (which are all hosted in our HackerRank NOI practice page) and solving as much as you can, preferably those you feel are standard stuff but you’re not familiar with. Remember that, being past NOI problems, these problems usually have their editorials available somewhere.

For standard stuff like graphs, data structures, standard algorithms, etc., we suggest you to learn them as soon as possible. You can’t rely on pure instinct all the time.

Finally, I suggest learning problem-solving and implementation skills simultaneously. As you encounter new algorithms/data structures, implement them immediately. Usually when you find tutorials, there are sample problems you can try them out with.

**Q: What resources would you recommend for learning?**

**A:** Aside from all the links given in the editorials of past NOI problems (of which there are a lot!), you may check this link for a list of tutorials and sample problems. You can find a lot of things to learn there. Be warned though that they aren’t listed in increasing order of difficulty, so I don’t suggest learning them in that order!

In general, you can try searching the web for any topic you hear about, and you might find a tutorial for that. Sometimes, especially in CodeChef long contests, we even look at research papers for solution (and problem) ideas!

But be sure you’re usually able to code brute-force solutions first! Don’t underestimate experience. You could be the most talented guy and yet fail at contests if you can’t code well enough.

Also, try setting a goal for yourself. For example, solve all NOI practice problems, or get some number of points in UVa Online Judge, or get to a certain rating in Codeforces/HackerRank/CodeChef, etc. During college I tried to get as many points in UVa as possible, and it helped me solve and train regularly.

You may also want to check out our previous posts to prepare for the NOI.