Ashwin/slime chunk farm (#3)

* wipfeat: minecraft themed sliding window question

* fix: whitespace

* fix: add a reminder

* feat: generate

* feat: validate

* chore: format

* chore: reorganise functions

* tidying up

Author: VanillaViking

competition/slime-chunk-farm/Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "slime-chunk-farm"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+rand = "0.9.1"
+rand_chacha = "0.9.0"

competition/slime-chunk-farm/Cargo.toml

@@ -0,0 +1,34 @@
+---toml
+[fuzz]
+exec = ["cargo", "run", "--release", "--", "generate"]
+env = {}
+
+[judge]
+exec = ["cargo", "run", "--release", "--quiet", "--", "validate"]
+
+[problem]
+points = 10
+difficulty = 1
+---
+
+# 💡 Slime Chunk Farm
+
+Steve would like to build a brand new Slime farm in his world. Since slimes only spawn in designated **Slime chunks** (16m*16m area where slimes can be found), Steve will need to find a suitable location for his farm. 
+
+He's only gathered enough resources to convert 50 slime chunks into farms, and he would like for the chunks to be as close together as possible.
+
+It's up to you to help steve find the **smallest area of land** that contains atleast **50 slime chunks**!
+
+## 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 "**.**"
+
+```
+...S.
+.S...
+.....
+.S..S
+.S.S.
+```
+
+## Output Format
+Your output should be an integer representing the smallest area (in meters) in which 15 slime chunks could be found. (Remember that one chunk is (16*16) = 256 m^2)

competition/slime-chunk-farm/prob.md

@@ -0,0 +1,163 @@
+use std::{
+    cmp,
+    env::args,
+    hash::{DefaultHasher, Hash, Hasher},
+    io::stdin,
+    iter::Sum,
+    num::ParseIntError,
+    ops::{AddAssign, Mul},
+    process::exit,
+};
+
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaChaRng;
+
+const FARM_SIZE: u32 = 50;
+const GRID_SIZE: usize = 100;
+
+#[derive(Debug)]
+struct PrefixSum2D {
+    prefix: Vec<Vec<u32>>,
+}
+
+impl PrefixSum2D {
+    pub fn new(grid: &Vec<Vec<u32>>) -> Self {
+        let mut prefix = vec![vec![0; grid[0].len()]; grid.len()];
+
+        prefix[0][0] = grid[0][0];
+        for x in 1..grid[0].len() {
+            prefix[0][x] = prefix[0][x - 1] + grid[0][x];
+        }
+        for y in 1..grid.len() {
+            prefix[y][0] = prefix[y - 1][0] + grid[y][0];
+        }
+
+        for y in 1..grid.len() {
+            for x in 1..grid[0].len() {
+                prefix[y][x] =
+                    prefix[y - 1][x] + prefix[y][x - 1] - prefix[y - 1][x - 1] + grid[y][x];
+            }
+        }
+
+        Self { prefix }
+    }
+
+    // inclusive exclusive
+    pub fn get_subrange_sum(&self, topleft: (usize, usize), bottomright: (usize, usize)) -> u32 {
+        if bottomright.0 == 0 || bottomright.1 == 0 {
+            return 0;
+        }
+        let sub_sum = self.prefix[bottomright.0 - 1][bottomright.1 - 1];
+        if topleft.0 == 0 && topleft.1 == 0 {
+            return sub_sum;
+        } else if topleft.0 == 0 {
+            return sub_sum - self.prefix[bottomright.0 - 1][topleft.1 - 1];
+        } else if topleft.1 == 0 {
+            return sub_sum - self.prefix[topleft.0 - 1][bottomright.1 - 1];
+        }
+        sub_sum + self.prefix[topleft.0 - 1][topleft.1 - 1]
+            - self.prefix[topleft.0 - 1][bottomright.1 - 1]
+            - self.prefix[bottomright.0 - 1][topleft.1 - 1]
+    }
+}
+
+
+fn min_area_with_chunks(prefix_sum_world: &PrefixSum2D) -> u32 {
+    let mut min_chunk_area = u32::MAX;
+    for top in 0..prefix_sum_world.prefix.len() {
+        for bottom in (top + 1)..prefix_sum_world.prefix.len() {
+            for left in 0..prefix_sum_world.prefix[0].len() {
+                for right in (left + 1)..prefix_sum_world.prefix[0].len() {
+                    if prefix_sum_world.get_subrange_sum((top, left), (bottom, right)) >= FARM_SIZE
+                    {
+                        // dbg!((top, left));
+                        // dbg!((bottom, right));
+                        min_chunk_area =
+                            cmp::min(min_chunk_area, ((bottom - top) * (right - left)) as u32);
+                    }
+                }
+            }
+        }
+    }
+
+    (16 * 16) * dbg!(min_chunk_area)
+}
+
+fn generate(world: Vec<Vec<u32>>) -> String {
+    world
+        .iter()
+        .map(|row| row
+            .iter()
+            .map(|chunk| {
+                if *chunk == 0 {
+                    '.'
+                } else {
+                    'S'
+                }
+            })
+            .collect::<String>())
+        .collect::<Vec<String>>()
+        .join("\n")
+}
+
+fn main() {
+    let args: Vec<String> = args().collect();
+    assert_eq!(args.len(), 3);
+
+    let mut default_hasher = DefaultHasher::new();
+    args[2].hash(&mut default_hasher);
+    let seed = default_hasher.finish();
+
+    let mut rng = ChaChaRng::seed_from_u64(seed);
+
+    let mut world = vec![vec![0; GRID_SIZE]; GRID_SIZE];
+    // 10% chance of slime chunks
+    // 0: normal
+    // 1: slime chunk
+    for _ in 0..((((GRID_SIZE * GRID_SIZE) as f32) * 0.1) as usize) {
+        loop {
+            let x = rng.random_range(0..GRID_SIZE);
+            let y = rng.random_range(0..GRID_SIZE);
+            if world[y][x] == 0 {
+                world[y][x] = 1;
+                break;
+            }
+        }
+    }
+
+    let prefix_sum = PrefixSum2D::new(&world);
+
+    let solution = min_area_with_chunks(&prefix_sum);
+
+    match args[1].as_str() {
+        // If `fuzz`-ing, just output the prompt.
+        "generate" => {
+            println!("{}", generate(world))
+        }
+        "validate" => {
+            let mut buffer = String::new();
+            let _ = stdin().read_line(&mut buffer);
+            let input = buffer.trim().parse::<u32>();
+            if let Ok(val) = input {
+                if val == solution {
+                    exit(0);
+                } else if val > solution {
+                    eprintln!("Incorrect, Your number is too high.");
+                    exit(1);
+                } else {
+                    eprintln!("Incorrect, Your number is too low.");
+                    exit(1);
+                }
+            } else {
+                eprintln!("Invalid input. Expected a positive number.");
+                exit(1);
+            }
+        }
+        // In this case, there is only one "correct" answer.
+        // In debugging, this can be directly outputted.
+        "solution" => {
+            println!("{}", solution);
+        }
+        _ => panic!(),
+    }
+}