AFAIR eps > 0

As Swistakk noticed previous information was misleading. You actually NEED 30 POINTS TO CLASSIFY.

"Unlike every other Code Jam Round, there is no limit on the number of potential advancers from the Qualification Round. You will advance to Round 1 if you earn at least 30 points, regardless of your penalty time. You may wish to review Visible Verdict Test Sets versus Hidden Verdict Test Sets and optimistic scoring; it doesn't hurt to score some extra points just in case!"

You can read more at the Code Jam FAQ

That tells you that you need to practice precise implementation.

Ok so I modified the Codejam CSS I used last year, here you can find the new CSS code for use in Stylish this year: https://pastebin.com/jd3jGPmL.

Improvements:

• All problems are visible in the scoreboard.
• Coding area takes 20% of space only (to make submissions by copy&paste possible).
• Removes/shrinks a few unnecessary elements.

Feel free to modify it.

P.S. as far as I understand, they've deliberately hidden the last problem (.hideDesktop in CSS) on all devices wider than 1175px, it is not like it is not shown because there is no space.

I used last year style of Mukundan Senthil (I don't remember where I got it) and had no problem with it. Now I modified it a bit and now it isn't so awful as it was

22" screen examle

1200px width screen

Install with stylus/tampermonkey, you know it better than me. CSS

I'd say it's also creating physical pain.

for linux

mkfifo pipe
python2 local_testing_tool.py 0 < pipe | ./your_solution > pipe
python2 local_testing_tool.py 1 < pipe | ./your_solution > pipe
python2 local_testing_tool.py 2 < pipe | ./your_solution > pipe

no output = AC

if you want to see your output:

python2 local_testing_tool.py 0 < pipe | ./your_solution | tee pipe

What the hell, guys?
I don't like nor google neither codejam, but they provide testing tool for interactive problems (nice ones, IMHO) and it works perfectly and lets you to debug locally without ANY actions from your side. Nobody else provide interactors, you have to code it yourself. Usually it is easy, but takes time and has tedious implementation
For running it simply download testing tool and then:

mkfifo input output

python testing_tool.py 2 > input < output  

And in another console

./E < input > output

To see any output just print it in stderr. As it was mentioned earlier no output of interactor means AC, otherwise it prints WA and message what went wrong. Just run several times it and submit it to gcj

I think that windows also supports pipes, but has no ideas how to do it. Or just use wsl

They are influenced by codeforces recent rounds

Likely to make it easier for newbies to analyze their output, and not to make them confuse between input and output when they paste a test with multiple test cases. (I'm against this though)

Yes, you will qualify the round.

What the hell are you doing? This is an ongoing contest. If it were up to me I'd instantly ban you for this.

Edit: Apparently collaboration is allowed, but sharing codes is discouraged, so still don't paste codes.

Round 2 would probably require a good knowledge of algorithms and fast implementation as only 4.5k participants get selected. So, maybe 1600-1800+

I solved the first 4 questions correctly, good for you now stfu.

By Hall's, if there is a diagonal where no number appears exactly N-1 times, then you can construct a grid with it.

Therefore, I generate the lexicographically smallest valid diagonal with recursive backtracking. After that, I forcibly place every number if some instance of that number appears on the diagonal with bipartite matching. After that, I place the remaining numbers in increasing order.

I think that is close to intended except for the case with $$$n+2$$$ and $$$n^2-2$$$ that you clearly messed up. I have something similar, but a bit different construction for three numbers (frequencies in my code are n-2, 1, 1) and I have also a case when there are two numbers appearing $$$c$$$ and $$$n-c$$$ times for any $$$2 \le c \le n-2$$$ (but $$$c=2$$$ will serve your purpose) which is significantly easier than the case with three numbers.

EDIT: OK, seeing the explanation of xiaowuc1 I don't think that caseology was intended solution :P.

I had the same construction for cases 1-3. I couldn't figure out 4. Also, another thing to note is you can't represent all numbers in $$$[n+3, n^2-3]$$$ by picking three numbers that appear $$$x$$$, $$$1$$$ and $$$n-x-1$$$ times.

For eg. there is no such representation for $$$n = 4, k = 10$$$.

Good news is all these numbers can be represented by picking $$$2$$$ numbers, one appearing $$$2$$$ times and other appearing $$$n-2$$$ times. So, you can use the square obtained from case 4 here.

I think your code is automatically doing this, so it should be fine.

For me randomized greedy swaps worked well for almost all cases. I started with a random cyclic shift matrix with 1s on the diagonal if $$$k < n^2/2$$$ or with $$$n$$$s if $$$k > n^2/2$$$ and swapped greedily, minimizing the difference of the trace with $$$k$$$.

Surprisingly, it did not work for $$$k \in {n+2,n^2-2}$$$ when $$$n$$$ is odd. Had to come up with a construction for that. Also the impossible case is $$$n=3 k=5$$$.

If we use $$$T$$$ distinct values on the diagonal and each of these values has multiplicity at least $$$T$$$, then each square determined by a segment of identical values on the diagonal can accommodate the remaining matching for all the other $$$T - 1$$$ values, by a simple construction (basically each time we start out with a square of side at least $$$T$$$ with only one diagonal filled and we add $$$T - 1$$$ more diagonals in cyclical fashion).

It turns out that the values of $$$K$$$ that cannot be represented in this manner exist only for $$$N <= 8$$$ $$$(*)$$$ and those can be brute-forced $$$(**)$$$.

This solution has no pen-on-paper caseology, but $$$(*)$$$ and $$$(**)$$$, although intuitive to me, were leaps of faith and had to be tested, so the code is probably significantly longer.

Oh thank God ! I freaked out thinking it's just me

Rather than down voting my comment is there any one who can really help out. Please?

I scan through symmetric pairs $$$(i, N + 1 - i)$$$. Note that if the two values are different, they stay different after any allowed transformation, and if they are equal — they stay equal. So I simply query the pairs and save the rsut, and then at 11th, 21th, ... queries I recheck one of the "equal" pairs if it has changed (1 query), and if it has, I update all the known "equal" pairs. Similarly is done for "different" pairs.

I found such a construction for type 3 (assuming n is odd). It works as follows when n is odd and k=n+2:

1. First create the diagonal: n-2 first values are 1's and 2 last values are 2's.
2. In the upper-left (n-2)x(n-2) subgrid add 2 after every 1 and then add a diagonal pattern 3,4,...,n starting from rows 1,2,3,...
3. In the upper-right 2*(n-2) subgrid add two vertical patterns 3,4,...,n starting from the two last rows.
4. In the lower-left (n-2)*2 subgrid add two horizontal patterns 3,4,...,n starting from the first column and second last column.
5. In the lower-right 2*2 subgrid add two 1's.

In all steps the subgrid is circular, i.e., after the last row/column comes the first row/column. For example, the construction for n=7 and k=9 is here:

1237654
7124365
4312576
6541237
2765143
3456721
5673412

i did this too but still TLE.

static void solve(int b) throws  IOException {
       if(b!=10){throw new RuntimeException("Wrong Answer");}
    StringBuilder sb=new StringBuilder();
    for(int i=0;i<10;i++){
        out.write(i+1+"\n");
    out.flush();
    String s=read();
    if (s.charAt(0) == 'N') {
				throw new RuntimeException("Wrong Answer");
			}
    sb.append(s.charAt(0));
    }
   out.write(sb.toString());
   out.flush();
   return;
  }

  public static void main(String args[]) throws  IOException {
      assign();
      Scanner ss=new Scanner(System.in);
    int t=ss.nextInt(),b=ss.nextInt();
    for (int ks = 1; ks <= t; ks++) {
     
      solve(b);
      String s1=read();
      //if(s1.charAt(0)=='N'){System.exit(0);}
      if (s1.charAt(0) == 'N') {
				throw new RuntimeException("Wrong Answer");
			}
    }
    
  }

I have the same problem, only attempting to solve testcase 1. If i play the judge manually, it works. Why do I get TLE?

import sys

def solve(b):
    sol = [None] * b
    for i in range(b):
        print(i)
        sys.stdout.flush()
        sol[i] = input()
    print("".join(sol))
    sys.stdout.flush()
    judge_respons = input()
    if judge_respons == "N":
        sys.exit()

T ,B = [int(x) for x in (input().split())]
for _ in range(T):
    solve(B)

why don't you put it inside the sopiler tag?

From the analysis:

• show that all values for K between N and N^2 are possible with these constraints. (Note: you have to be a little careful with N = 3).

In N=3 I think there are some exceptions you need to handle(like K=5, which is like you said only possible with 1 1 3 / 2 2 1), otherwise if (n-2) > 1 (which is True for any N>3, you can prove it.

If I understand correctly, they're fixing only(!) the values on the main diagonal. But you are fixing some additional values which are clearly not on the diagonal.

You do not keep track of the initial ordering (after sorting, the order of events may differ from the order in the input). In your code, you store the index i of every pair, so instead of concat, you can write ss[ind] = 'J' or ss[ind] = 'C' respectively, where ind = v[i].second.second.

Probably, there's some plagiarism checking or similar thing going on and thus the results aren't technically "finalized". But according to the rules you have qualified.

I found this one https://vstrimaitis.github.io/google_codejam_stats

the array changes just before you get answer to the first query so you can assume that the first change is after 10-th query.

Can I participate in Round 1B if I did not participate in qualification round and 1A?

"I hope that this means that they can consider slightly increasing the number of finalists, to maybe say 50 like before!" — that would certainly be an interesting idea

So that now I will be outside top-50 instead of top-25? No thanks, being outside top-25 is embarassing enough.

But to be honest, I believe that the number of finalists won't be changed, because the rules for this year were already established.