Merge pull request #9 from ProgSoc/unclosed-brackets-fix

Allow for possibility of no unclosed braces in unclosed-brackets

Author: jaspwr

competition/unclosed-brackets/prob.md

@@ -13,7 +13,38 @@ difficulty = 1
 
 # 📄 Unclosed Braces
 
-Given a snippet of C with unclosed curly braces (`{}`), determine the index of the first unclosed opening curly brace.
+You've been given a piece of spaghetti code written in C,
+which was probably a failed attempt at some code golfing.
+However, your manager isn't sure if this code is usable at all.
+They suspect that there are unclosed braces in this program,
+and they refuse to use a proper IDE to check.
 
-## Output Format
-Your output should be the index (with the first character being index 0) of the first unclosed opening curly brace.
+Your task is to take this code snippet and determine the index
+of the *first* unclosed opening curly brace.
+If there are no unclosed curly braces, then you can just tell your manager there are none.
+
+Note that newline characters (`\n`), carriage returns (`\r`) and other invisible ASCII characters
+are counted as a character.
+
+## Input
+
+Your input for this question is a code snippet which may or may not have an unclosed curly brace.
+
+## Output
+
+Your output for this question is either:
+* the index of the first unclosed opening curly brace, counting such that the very first character is at index 0, or
+* the word `none`, if there are no such unclosed curly braces.
+
+## Example
+
+Consider the following code snippet.
+
+```c
+#include <stdio.h>
+void f(){{printf("%d",1);}
+int main(){f();}
+```
+
+The first unclosed curly brace is on the second line, just before the `printf` call.
+The answer for this should be `27` (there is only a single `\n` for each newline).

competition/unclosed-brackets/src/main.rs

@@ -10,15 +10,15 @@ use rand_chacha::ChaChaRng;
 
 fn expression(rng: &mut impl Rng, depth: usize) -> String {
     if depth > 20 {
-        return format!("{}", rng.gen_range(1..=100));
+        return format!("{}", rng.random_range(1..=100));
     }
 
-    match rng.gen_range(0..6) {
+    match rng.random_range(0..6) {
         1 => {
             format!(
                 "{}{}{}",
                 expression(rng, depth + 1),
-                match rng.gen_range(0..4) {
+                match rng.random_range(0..4) {
                     0 => '+',
                     1 => '-',
                     2 => '*',
@@ -31,14 +31,14 @@ fn expression(rng: &mut impl Rng, depth: usize) -> String {
             format!("{{{}}}", expression(rng, depth + 1))
         }
         3 => {
-            let function = match rng.gen_range(0..3) {
+            let function = match rng.random_range(0..3) {
                 0 => "sin",
                 1 => "cos",
                 _ => "tan",
             };
             format!("{}({})", function, expression(rng, depth + 1))
         }
-        _ => format!("{}", rng.gen_range(1..=100)),
+        _ => format!("{}", rng.random_range(1..=100)),
     }
 }
 
@@ -47,11 +47,11 @@ fn statement(rng: &mut impl Rng, depth: usize) -> String {
         return format!("return {}; ", expression(rng, depth + 1));
     }
 
-    if rng.gen_bool(0.01) && depth > 5 {
+    if rng.random_bool(0.01) && depth > 5 {
         return format!("{{{}", statement(rng, depth + 1));
     }
 
-    match rng.gen_range(0..10) {
+    match rng.random_range(0..10) {
         0 => format!("int x={};", expression(rng, depth + 1)),
         1 => format!("printf(\"%d\",{});", expression(rng, depth + 1)),
         2 => format!(
@@ -67,7 +67,7 @@ fn statement(rng: &mut impl Rng, depth: usize) -> String {
         ),
         4 => format!(
             "for(int i=0;i<{};i++){{{}}}",
-            rng.gen_range(1..=10),
+            rng.random_range(1..=10),
             statement(rng, depth + 1)
         ),
         5 => format!(
@@ -80,24 +80,24 @@ fn statement(rng: &mut impl Rng, depth: usize) -> String {
 }
 
 fn function(rng: &mut impl Rng, depth: usize) -> String {
-    let body = (0..rng.gen_range(10..50))
+    let body = (0..rng.random_range(10..50))
         .map(|_| statement(rng, depth + 1))
         .collect::<Vec<_>>()
         .join("");
 
-    format!("void func_{}(){{{}}}", rng.gen_range(1..1000), body)
+    format!("void func_{}(){{{}}}", rng.random_range(1..1000), body)
 }
 
 fn program(rng: &mut impl Rng) -> String {
-    let functions = (0..rng.gen_range(100..200))
+    let functions = (0..rng.random_range(100..200))
         .map(|_| function(rng, 0))
         .collect::<Vec<_>>()
         .join("");
 
     format!(
         "#include <stdio.h>\n{}\nint main(){{func_{}();return 0;}}",
         functions,
-        rng.gen_range(1..=1000)
+        rng.random_range(1..=1000)
     )
 }
 
@@ -119,12 +119,7 @@ fn run(seed: u64, method: &str) {
     let mut rng = ChaChaRng::seed_from_u64(seed);
 
     let src = program(&mut rng);
-
-    let Some(solution) = solve(&src) else {
-        // Try again
-        run(seed.wrapping_add(1), method);
-        return;
-    };
+    let solution = solve(&src);
 
     match method {
         "generate" => {
@@ -134,18 +129,37 @@ fn run(seed: u64, method: &str) {
             // Reads from user input.
             let mut buffer = String::new();
             let _ = stdin().read_line(&mut buffer);
-            let Ok(input) = buffer.trim().parse::<usize>() else {
-                eprintln!("Invalid input, expected a positive integer.");
-                exit(1);
-            };
-
-            if input != solution {
-                eprintln!("Incorrect solution");
+            let provided_answer = buffer.trim();
+
+            if provided_answer == "none" {
+                match solution {
+                    None => {
+                        exit(0);
+                    }
+                    Some(_) => {
+                        eprintln!("Incorrect answer. There is an unclosed bracket.");
+                        exit(1);
+                    }
+                }
+            } else if let Some(solution_index) = solution {
+                let Ok(input) = provided_answer.parse::<usize>() else {
+                    eprintln!("Invalid input, Expected either 'none' or a positive integer.");
+                    exit(1);
+                };
+
+                if input == solution_index {
+                    exit(0);
+                } else {
+                    eprintln!("Incorrect solution");
+                    exit(1);
+                }
+            } else {
+                eprintln!("Invalid input. Expected either 'none' or a positive integer.");
                 exit(1);
             }
         }
         "solution" => {
-            println!("{}", solution);
+            println!("{:?}", solution);
         }
         _ => panic!(),
     }