Time Limit Exceeded is very intuitive and works the same way as in classical contests, so I didn't highlight is separately. You can, for example, get Memory Limit Exceeded by allocating purely classical resources, but that's classical so I didn't focus on that as well.

Yes, I like it quite a lot, too bad I'm not eligible for this contest :-P

I'll borrow a photo from https://twitter.com/frances_tibble/status/1026381426952990720:

I agree, the joke is strong with this one! So funny and pretty :D

Unless anyone shares last year's design I can take a picture of mine in several hours from now.

Edit: ok, nevermind :)

The original announcement has pointers to a variety of sources on quantum computing.

I've updated the post to include TLE as well, even though there is nothing specifically quantum about it.

Where do you run custom invocation from? I believe you have to use it from one of the Q# contests (I just tried running code from https://codeforces.com/contest/1115/customtest and it works), if you call it from https://codeforces.com/problemset/customtest it will not realize that it needs extra files (which contain the actual C# driver with the Main method).

Ah, this is a tricky case! This throws a ReleasedQubitsAreNotInZeroState exception, which is generally treated as a Runtime Error. The qubits you release are released in 0 state (obviously, since you haven't done anything with them). But the checker allocates some extra qubits to to test that your solution returns correct answer — and those are the ones which are released in non-zero state if your solution is incorrect. (This same code gets WA if submitted to A1, because in A1 the checker doesn't allocate and release extra qubits.)

I don't have a good way to distinguish ReleasedQubitsAreNotInZeroState caused by the solution vs caused by the checker because of incorrect solution. I'll think some more about it, but for now it will have to stay like this — some things that should be Wrong Answer produce Runtime Error instead :-(

Yes, Reset does a measurement followed by an X gate, if one is required, so it is also prohibited.

Yes, I think this time we calibrated the complexity much better — last time the fate of the T-shirts was decided in less than 24 hours, and now it doesn't seem to be the case.

It's hard to estimate, and not particularly useful — the total execution time of your program depends not only on the number of gates in your code but also on things like the number of qubits allocated (more qubits makes everything slower, since applying a gate requires updating more values).

Yes. To be more precise, to determine "a" state which you know with certainty it wasn't in.

the top 50 ranked participants will receive a Microsoft Quantum T-shirt!

The rules say we'll give them to top 50, so that's what we'll do. Right now it doesn't look like it will be necessary to solve all problems to get in top 50, but there is still time for this to change :-)

You have to find a state in which qubit is not on every trial; the number of rounds just tells you that it's not a single-shot experiment.

How did you solve it? I honestly cannot wait until the editorial is out.

I tried introducing qubits, I tried looking into QFT, I even found this specific problem (called trine states) but I had to use measurement operators not in Q#.

I suggested t-shirts for finding important bugs, but no, you can't — other than by making one for yourself or getting it from someone who was in top 50.

IntegerIncrementLE can be implemented pretty easily. The codes below are for adding/subtracting 1.

operation sub1 (x : Qubit[]) : Unit {
	for(i in 0..Length(x)-1) {
		Controlled X(x[0..i-1], x[i]);
	}
}
operation add1 (x : Qubit[]) : Unit {
	ApplyToEach(X, x);
	sub1(x);
	ApplyToEach(X, x);
}

I had so many TLEs on C3 trying to use IntegerIncrementLE. How did you manage to do it?

I ended up passing by abandoning that approach, and using three qubits that alternate between 100,010, and 001.

I tried something similar for B1. I just used the solution from the Katas for the W state with 3 qubits. I used the adjoint and measured, but wasn't sure if that would actually be a correct solution, since I might map the second state to something with 000 and measuring would give 000.

For C2, I hardcoded which periodicity based on the numbers. E.g. for 6 qubits, the possible are 1,2,3,4,5, but 2 is already 4-periodic, and 1 is already n periodic, so exclude them, and test for 3,4,5.

We're publishing the editorial here (it will take us some time to finish the descriptions for the harder problems — sorry about that!)

• A1: this is a perfectly intended solution — it's an A1 problem, after all :-) Well, the library function I used was PrepareUniformSuperposition because I'm too lazy to specify the coefficients explicitly :-) You can see the implementations of all library operations in this repo.
• B1: intended solution again :-) Admittedly, the reference solution did the prep manually (because I already had the code for W state in the katas, after that it's just a couple of phases), but since it's only a three-qubit state, library state preparation routines will also work.
• Reference solutions for C2 and C3 are already there in the editorial. In them I aimed to have hardcoding all solutions time out, but if you do something clever to optimize your solution it should pass — the exact nature of cleverness was not specified.

For B1, that's what I did, except I manually came up with the transformation to prepare the state (just a variation on A1, with some phase changes).

For C2, for each k between 0 and N/2, you can check if the k-prefix and k-suffix of the string are equal.

My first approach was checking periodicity for EVERY period, which TLEs.

For D4, I used IntegerIncrementLE — I'm curious if there's any other approach.

For D5 it's definitely possible to do without — I came up with a pretty neat recursive solution.

I hardcoded all periodic strings in a more compact way on C2. There are just a few conditions the qubits need to satisfy, starting with "if the first and last qubit are the same, it's periodic".

For C2, I literally brute-forced all possible values of P, doing something similar to my palindrome checker oracle (from the warmup round) to check pairs of bits for equality. I just allocated an ancilla qubit to store the result of each P. Then I just reused the OR oracle from the warmup round and the WithA operation. My solution ended up being an almost direct translation of the definition given in the problem statement.

EDIT: Well, basically this was the intended solution.