I am strongly against forbidding prewritten code, as you may guess :) I do not think it is fun to look at people implementing Dijkstra or modint

As for the difficulty level, it seems we were supposed to finish the 500pt problem in 20 minutes but we didn't really match the expectations :) Personally I was rushing too much as I felt I was behind, but in the end the only way to untangle the problem was to relax, admit that my strategy of going for the first idea was bad, and just finish the job carefully.

As for using prewritten code, I actually raised this point during one of the rounds we ran at the TCO when my suffix array template helped me quite a lot, and I think we agreed that prewritten code is fine. Here is one point for allowing it. Would you like the competitors to type their usual template for each problem from scratch, and if not, what would you allow to have: includes, defines, typedefs, sync_with_stdio(false), commented out freopens? It's not really obvious to me where to draw the line.

I'm personally against a rule banning prewritten code for three main reasons.

First, it incentivizes a form of cheating that is very hard to prevent at scale. Sure, this rule could have been enforced in the matches streamed a few days back, but it sounds like the organizers are hoping to expand this in order to make this format available to everyone. If this does occur, then presumably, matches generally will not be monitored by humans, making it extremely easy to copy in prewritten code, should you wish to do so. Moreover, this would be extremely hard to detect because with access only to the submission logs, there's no way to distinguish between thinking of a solution quickly and then typing, say, a segment tree from memory and taking more time to think of the solution but making it up by copying/pasting the same segment tree.

As a result, this policy would make the competition favor those willing to cheat, making it unfair to those abiding by the rules. I would imagine that this sort of cheating would be relatively common, especially because prewritten code is allowed in most programming contests, so many would just assume that it would be allowed here, too.

Second, a ban on prewritten code would make this format test the wrong set of skills. I can think of two ways that such a ban might be implemented, and I'll discuss each of them individually.

(a). Contestants might be able to reference prewritten code and type it up, but not to copy it in. This has two problems. First, it drastically increases the role typing speed would play in the competition, and second, it would actually further increase the need for thoughtful prewritten code because competitors with more concise library code would be at a substantial advantage. It is generally accepted that neither of these are skills we want to test on programming contests.

(b). Contestants would be banned from accessing all prewritten code. The aforementioned typing speed problem still exists here, but now, rather than testing conciseness of library code, the format would test memorization of algorithms. Obviously, this isn't a big problem for very basic things like modular arithmetic or Dijkstra's algorithm (and as far as I'm aware, most competitors don't use templates for these in the first place). It starts to be a problem once you get into things like segment trees, where most top competitors would be capable of coding them, but typing speed and accurate memorization start to play a significant role. Moreover, though, I would argue that a complete ban on prewritten code means that certain topics, such as FFT/NTT, various string data structures, and possibly certain flow algorithms, simply cannot appear on the competition at all because there's just too much code involved to memorize and regurgitate it all. (Or, if these do appear on the competition, the aforementioned issue of differentiating on the basis of memorization would still persist.)

One might say that this sort of ban exists at the IOI and similar competitions, but the difference is that speed does not play nearly as significant a role in those contests. (I also would marginally support the IOI transitioning to a notebook system similar to the ICPC's, but that's a separate debate.)

Third, a ban on prewritten code would make the competition less fun. There are three groups that this ban would affect:

(a). The competitors. Banning template code would make this format less fun for competitors because it would require them to memorize code for which they previously used a library and because it would force them to spend more time typing standard algorithms and less time thinking and coding the unique parts of each solution. Also, the precedent is generally for programming contests to allow prewritten code, so without any reason to believe otherwise, we should expect that most competitors would prefer for any new formats to be the same way.

(b). Competitive programmers spectating the event. Obviously, watching someone type up a standard algorithm won't be especially exciting to anyone who knows about algorithms themselves, so the competition will be less exciting for spectators with competitive programming experience.

(c). Spectators without a background in competitive programming. To start, I think this group will probably be very small--it takes some background in algorithms to have any chance of understanding the problems or what the competitors are doing. Other activities that attract spectators beyond the people who actually participate in the activity themselves are generally easy to understand with essentially no background information. For example, competitive Tetris has recently gathered a significant following on YouTube because even though most people watching don't fully understand the mechanics behind the game, they can generally follow the action and understand what's going on. In contrast, what happens during a programming contest is essentially impossible to follow without some understanding of the algorithms involved.

However, even if I'm wrong and some of these people do take to watching this format, I would argue that they're probably going to prefer a format without this ban because, given that they won't be able to follow the coding process, they will probably derive most of their entertainment from the commentary and the scoreboard. Therefore, we would prefer a format in which interesting things happen more frequently, which means that this ban is bad because it would slow down the pace of the competition.

Overall, therefore, I would argue that this format is better both for competition and for spectators without this ban.

Thanks for the feedback! We did have a little trouble with the stream setup to show multiple screens at once, but in the future, we're definitely planning to have picture-in-picture or something similar. Do you think that might improve the 2v2 stream, or is it still too crazy?

Regarding difficulty, it does seem like some hard problems, particularly the math ones, are harder to spectate. Do you think showing a stream of the contestants' faces and/or paper would help?

Personally, I think prewritten code is a necessary evil; different languages already have different standard libraries, so prewritten code helps to even that out. I think the best solution is to have a large public prewritten code repository that everyone can use, like https://github.com/bqi343/USACO. In Lockout in particular, banning prewritten code makes it more annoying for contestants because it's such a speed contest, and it's not obviously more interesting to spectate tourist typing boilerplate, as others have pointed out.