add syntax highlighted code blocks

Author: sebasptsch

competition/bytecode/prob.md

@@ -95,7 +95,7 @@ Additionally, every `<name>` consists of three lowercase letters exactly.
 ## Example
 
 Consider the following sequence of instructions.
-```
+```text
 JUMP str
 LABEL pqr
 JUMP end
@@ -128,7 +128,7 @@ The following instructions will be executed:
 At the end, the **namespace** contains the variables `a` with value `6` and `b` with value `8`.
 The **output register** contains the value `2`.
 Hence, the output in this case should be
-```
+```text
 14 2
 ```
 since the sum of all variables in the namespace is 14.

competition/comp.md

@@ -1,8 +1,8 @@
 ---toml
 [times]
-start = "2025-06-24T11:30:00+1000" # 11:30am AEST
+start = "2025-06-25T11:30:00+1000" # 11:30am AEST
 # start = "2025-05-24T12:00:00+1000"
-finish = "2025-06-24T03:30:00+1000" # 3:30pm AEST
+finish = "2025-06-25T03:30:00+1000" # 3:30pm AEST
 freeze = 60
 ---
 
@@ -12,18 +12,22 @@ ProgSoc @ TechFest
 
 ## Runsheet
 
-- 11:30 - Event start, teams set up
-- 12:00 - Competition start
-- 1:00 - Lunch comes (sandwiches/wraps)
-- 3:00 - Scoreboard freeze
-- 4:00 - Competition end, scoreboard unfreeze, announcing winners
+- 9:00 am - Set-up for organisers
+- 11:00 am - Competitors arrive and sign-in
+- 11:30 am - Questions open
+- 12:30 pm - Lunch arrives (Sandwiches)
+- 3:30 pm - Questions close, Verification of solutions
+- 3:50 pm - Winners announced
+- 4:00 pm - Event Concludes
 
 ## Solving questions
 
 Each question requires processing your generated problem input. Just as an example, here's a simple python program that reads a line from standard input and then prints it out again:
 
+```python
 line = input()
 print(line)
+```
 
 However, we've created a scaffold for each question that does that for you to make life easier.
 
@@ -35,12 +39,14 @@ To upload a file, make sure you're logged in, then you should have a submit butt
 
 There are 2 points systems:
 
-    The team with the most answered questions wins
-    If there is a tie, the second system is used:
+The team with the most answered questions wins
+If there is a tie, the second system is used:
 
-    Each time you answer a question, you get "points" for how many minutes passed between the beginning of the competition and when you solved it
-    Out of the tied teams, the team with the lowest total "points" wins
+Each time you answer a question, you get "points" for how many minutes passed between the beginning of the competition and when you solved it
+Out of the tied teams, the team with the lowest total "points" wins
 
 ## Prizes
 
-1st place: $1500 2nd place: $900 3rd place: $600
+1st place: $1500 
+2nd place: $900 
+3rd place: $600

competition/intervals/prob.md

@@ -53,7 +53,7 @@ The input will be a parenthesised expression containing intervals
 There will be whitespace in between any parenthesis, interval, or operator.
 
 For example,
-```
+```text
 ( ( ( 10-45 | 31-93 ) & ( 80-84 | 8-15 ) ) | ( ( 42-82 | 71-76 ) & ( 9-86 | 41-100 ) ) )
 ```
 
@@ -72,21 +72,21 @@ which is the **number of integers** that satisfy the given input expression.
 In this case, the integers that satisfy the above example input are
 10 to 14 (inclusive on both ends) and 42 to 83 (inclusive on both ends),
 meaning the answer is:
-```
+```text
 47
 ```
 
 ## Detailed Example
 
 Here's a detailed example to explain what this question is asking.
 Consider the following input.
-```
+```text
 ( ( ( 1-5 | 2-6 ) & ( 3-7 | 8-9 ) & ( 5-9 | 6-7 ) ) | ( ( 7-9 | 8-10 ) & ( 1-7 | 5-10 ) ) )
 ```
 To make it easier to read, let's format this over multiple lines,
 label each section of the expression,
 and rewrite the `&` and `|` symbols as `AND` and `OR` respectively.
-```
+```text
 (
   # Clause A:
   (

competition/lights/prob.md

@@ -17,7 +17,7 @@ Given the 3D positions and RGB hexcodes of several point light sources, find the
 
 ## Input Format
 Each line of the input represents a light source. Each line contains a hexcode (with hash) followed by 3 numbers representing the position all separated by spaces. For example:
-```
+```text
 #ff0000 1.0 2.0 3.0
 #00ff00 4.0 5.0 6.0
 ```

competition/manhattan/prob.md

@@ -48,7 +48,7 @@ A cost is incurred every single time you move from one building to another.
 ## Example
 
 Consider the following input prompt.
-```
+```text
 aaa eee
 aaa(0, 0, 0): bbb(4), ccc(5)
 bbb(0, 1, 1): aaa(3), ccc(2), eee(10)
@@ -71,7 +71,7 @@ The first line contains two space-separated names:
 the first being the building you start at, and the second being the building you end at.
 
 The rest of the lines are in the format of:
-```
+```text
 <building name>(<location coordinates>): [<building name>(<cost>)] ...
 ```
 
@@ -86,6 +86,6 @@ Your output will be a single integer, representing the cost of the shortest path
 from the given start building to the given end building.
 
 In the above example, it will be a single integer as follows.
-```
+```text
 13
 ```

competition/midi/prob.md

@@ -21,7 +21,7 @@ Each line represents a [MIDI message](https://www.mixagesoftware.com/en/midikit/
 * The two relevant MIDI opcodes are `0x8c` for note off and `0x9c` for note on.
 * The note number is an integer between 0 and 127.
 
-```
+```text
 0 156 60
 1000 140 60
 500 156 64

competition/potoroo/prob.md

@@ -36,12 +36,12 @@ A single integer representing the minimum number of tasty bush snacks you need t
 ## Example
 
 ### Input
-```
+```text
 1 0 2
 ```
 
 ### Output
-```
+```text
 5
 ```
 

competition/quantum-conveyor-belts/prob.md

@@ -44,7 +44,7 @@ Here's a small example to demonstrate the question being asked.
 Consider the following layout of conveyor belts and stations,
 where you start your journey in the `aaa` station.
 In this setup, there are only two kinds of letters that will appear: `x` and `y`.
-```
+```text
 aaa: drift(bbb); x(bbb, ccc); y(ccc)
 bbb: drift(); x(); y(ddd)
 ccc: drift(ddd); x(); y(bbb)
@@ -88,7 +88,7 @@ Meanwhile, if you press the `y` key, you will go back to `{bbb, ccc, ddd}`.
 In this example, there are no more new superpositions that can be reached.
 Thus, the only 4 reachable superpositions are `{aaa, bbb}`, `{bbb, ccc, ddd}`, `{ccc, ddd}`, and `{}`.
 This means that the there are **12 unreachable** superpositions, as follows:
-```
+```text
 {aaa}, {bbb}, {ccc}, {ddd},
 {aaa, ccc}, {aaa, ddd}, {bbb, ccc}, {bbb, ddd},
 {aaa, bbb, ccc}, {aaa, bbb, ddd}, {aaa, ccc, ddd}, {aaa, bbb, ccc, ddd}.
@@ -102,11 +102,11 @@ with each line in the input representing the outgoing conveyor belts from a sing
 The first line will always be the station (not superposition) that you start your journey in.
 
 The format of each line is as follows:
-```
+```text
 <station name>: drift(<comma-separated list of stations>); <letter>(<list of stations>); ...
 ```
 For example,
-```
+```text
 aju: drift(bkv); a(bkv, clw); b(clw)
 ```
 means that from the station `aju`, you can move to station `bkw` for free
@@ -125,7 +125,7 @@ If you press the `b` key in `aju`, you will end up in `clw`.
 ### Example
 
 Here's another example of the question input.
-```
+```text
 aju: drift(bkv); a(bkv, clw); b(clw)
 bkv: drift(dmx); a(bkv); b(bkv)
 clw: drift(); a(eny); b(bkv)
@@ -153,6 +153,6 @@ In the above example, there are 6 *reachable* superpositions:
 * `{bkv, clw, dmx, eny}`
 
 Therefore, in this example, there are 26 *unreachable* superpositions, and the output should be
-```
+```text
 26
 ```

competition/slime-chunk-farm/prob.md

@@ -22,7 +22,7 @@ It's up to you to help steve find the **smallest area of land** that contains at
 ## Input Format
 The input is a 100x100 grid of characters. Each character represents a chunk, which is a 16x16 area of land. A Slime chunk is denoted by an "**S**" while normal chunks are denoted by "**.**"
 
-```
+```text
 ...S.
 .S...
 .....

competition/time-traveler/prob.md

@@ -49,7 +49,7 @@ corresponding in the order by which the test cases were provided.
 In this example, `T` is `1`.
 The next two lines are thus part of the one and only test case in this example.
 Here, `N` is `9`, followed by a single line with 9 space-separated integers.
-```
+```text
 1
 9
 10 5 4 7 9 12 6 2 10
@@ -58,7 +58,7 @@ Here, `N` is `9`, followed by a single line with 9 space-separated integers.
 ### Output
 
 Here, the solution is a single line containing the solution of the one test case we are provided.
-```
+```text
 20
 ```