i downvoted both , problem C gave tle on pretest 4 and same logic passed in c++

Problem C seemed so simple yet turned out to be the most painful one. Just wouldnt work with Java

It will published later on...btw it is mentioned above...

Don't swear, It is bad

got runtime error 2 times because of this

This ruined my contest. Literally i got 4 runtime errors on pretest 2 for this reason. In the question it was mentioned if 2*n+1 moves are done then the game finishes. Also there were no pretests that had 2*n+1 moves to make it more clearer.

Same here.

salyg1n, green_gold_dog, ace5, bashkort. Isn't it a mistake on author's part? If so, can we manually set my current AC time to my first attempt in problem C? (As it would've been AC in first attempt without this issue)

Exactly spent 1.5 hr while submitting the same code as I can’t notice any error. The round should be unrated.

+1

Same thing here. I first tried submitting various java solutions only to get TLE. Same logic in C++ passed in first go.

Sounds like a skill issue to me.

Same issue.

My best guess is for test like #4 where T = 100000, the system judge does not generate the input data for next test in stdin fast enough after the previous test complete.

I tried to simulate stdin for 100000 tests each with n = 1 on local machine like below. It measured 185 msec. So the fact that test #4 always TLE in system tests suggest some kind of delay introduced by system test for Java submissions.

  static void simulateLargeNumOfTests() {
    long t0 = System.currentTimeMillis();
    {
      // Prepare stdin for 100000 tests each with n = 1 and mex 0.
      // In such case, an immediate -1 will follow after the input of each test.
      int T = 100000;
      StringBuilder sb = new StringBuilder();
      sb.append(T);
      sb.append('\n');
      for (int t = 1; t <= T; t++) {
        sb.append(1);
        sb.append('\n');
        sb.append(1 + RAND.nextInt(1000000000));
        sb.append('\n');
        sb.append(-1);
        sb.append('\n');
      }
      byte[] data = sb.toString().getBytes();
      InputStream fakeIn = new ByteArrayInputStream(data);
      System.setIn(fakeIn);
    }

    {
      MyScanner in = new MyScanner(true);
      int T = in.nextInt();
      OutputStream out = new BufferedOutputStream(System.out);
      for (int t = 1; t <= T; t++) {
        int n = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
          a[i] = in.nextInt();
        }
        solve(a, in, null, out);
      }
    }
    System.out.format("%d msec\n", System.currentTimeMillis() - t0);
    System.exit(0);
  }

After using a hack to workaround test #4 which always TLE in System Verdict, this submission https://mirror.codeforces.com/contest/1867/submission/223000398 is Accepted with runtime 1949 msec on test #6 where the input array has length 100000 and MEX 100000. It is unclear exactly how many IO interactions in test #6 as it depends on how greedily the Judge choose y each time.

Overall, the interactive IOs delays of problem C is too much for the given limit of T and timeout, and the problem is partially to do with the System Test. Problem C should either use a smaller limit like 10000 for T or a bigger timeout so to accept legit Java solutions without losing any generality of the problem.

same I almost wasted 30 minutes about thinking it and then I reread the question did it in 5 minutes and then went for e2 made the logic but guess what forgot to print ? in making query and didn't make it whole time I was thinking about my solution but the error was in my code :(

Completely ruined my contest. But it's my fault, I missed "Even".

what???i completely didn't realize n and k are both even even at this time!!! sad about this...

I don't know the completely trivial solution :(

Can you explain it?

How to progress from solution for E1 to E2?

maybe you should learn from SecondThread and profchi :)

Yes.

problem D : if a linear chain of size > k is connected to a k length cycle then how is possible to generate a pattern to get array B?

Actually, I think quite easy to kill random approaches for F, one can just construct a tree with all possible subtrees of size k except for 1 which random will find it hard to find.

Ackchyually, you must know that $$$n$$$ and $$$k$$$ would be even, when the problem is E1.

Where do you see bitwise operator that much. Xor in binary strings = flipping i-th digit. Problem A isn't about bitwise at all

Wait really? I didn't even see, I wasted up my time trying D :/

For Java as well

I use python and got TLE on problem B testcase 11, problem C testcase 4 with default input() method during the contest. But after adding

import sys 
input=sys.stdin.buffer.readline

They all passed the test.

A really frustrated experience for me though.

Yeah, that was very confusing

I don't think there was any ambiguity in the problem statement. The interaction guide says that after you output $$$x$$$, you should read an integer $$$y$$$. It never says that you should read $$$y$$$ only if the game is not already over or that you should read $$$y$$$ only if Bob is making a move: every time you output an $$$x$$$, you need to read a $$$y$$$.

It's particularly easy to get tripped up on interactive problems by making incorrect assumptions about the I/O format, which is why you should always read the interaction section of the statement carefully before beginning to implement your solution.

"To make a move, output an integer $$$x$$$ ($$$0 \le x \le 10^9$$$) — the number you want to add to the set $$$S$$$. $$$S$$$ must not contain $$$x$$$ at the time of the move. Then, read one integer $$$y$$$ ($$$−2 \le y \le 10^9$$$)."

Is it not clear that after every time you output $$$x$$$, you need to read in $$$y$$$?

Maybe these help:

• https://mirror.codeforces.com/blog/entry/16599
• https://mirror.codeforces.com/blog/entry/17842
• https://mirror.codeforces.com/blog/entry/66909

Solve more. Whole cp is just trying to see patterns of problems already solved by you in new problems.

It's okay man, I got WA two times on pA this contest also and I almost gave up and just quit. The point is that you need to keep calm and try observing some key observations. Also if div 2 is too hard you can try div 3, 4 and atcoder. GL!

According your code, I think when Nextmove = n; it will wrong. Like this: n = 2 a[] = 0 1 Step 1: A:2 B:1 Step 2: A:1 B:0 Step 3: A:0 B:-1 -> it need n+1 loops

Not necessarily, you can do this to k nodes without them being in a cycle, I will explain solution.

I just checked that every path from a non-zero element leads into a cycle of length $$$k$$$.