Monikulmio

warning: value assigned to `point` is never read
  --> input/code.rs:19:13
   |
19 |     let mut point = (0,0);
   |             ^^^^^
   |
   = help: maybe it is overwritten before being read?
   = note: `#[warn(unused_assignments)]` on by default

warning: 1 warning emitted

use std::{io, str::SplitAsciiWhitespace};
pub fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read input");
    
    let mut substringiter = input.split_ascii_whitespace();
    
    let height = parse(&mut substringiter);
    let width = parse(&mut substringiter);
    let mut grid: Vec<Vec<u8>> = vec!();
    let rowtext = ".".repeat(width);
    for _rownum in 0..height {
        grid.push(rowtext.as_bytes().to_vec());
    }

    let pointamount = parse(&mut substringiter);
    let mut previouspoint = (0, 0);
    let mut firstpoint = (0, 0);
    let mut point = (0,0);

    for index in 0..(pointamount+1) {
        if index != pointamount {
            point = get_point();
        } else {
            point = firstpoint;
        }

        grid[point.0][point.1] = 42;

        if index != 0 {
            let dy = point.0 as isize - previouspoint.0 as isize;
            let dx = point.1 as isize - previouspoint.1 as isize;

            if dx == 0 {
                let rangey = range(previouspoint.0, point.0);
                for rownum in rangey {
                    grid[rownum][point.1] = 124;
                }
            } else {
                let kulmakerroin = dy/dx;
                let character: u8 = match kulmakerroin {
                    1 => 92,
                    0 => 61,
                    -1 => 47,
                    _ => 0,
                };

                let rangex = range(previouspoint.1, point.1);

                for column in rangex {
                    let y = (previouspoint.0 as isize +(column as isize -previouspoint.1 as isize)*kulmakerroin) as usize;
                    grid[y][column] = character;
                }
            }
        } else {
            firstpoint = point;
        }

        previouspoint = point;
    }

    let startpoint = find_inside(&grid);
    dbg!(startpoint);

    fill(&mut grid, startpoint);

    printresult(&grid);
}

pub fn parse(iter: &mut SplitAsciiWhitespace) -> usize {
    let s = match iter.next() {
        Some(s) => s.parse().unwrap(),
        None => 0,
    };
    return s;
}

pub fn range(previouspointcoord: usize, pointcoord: usize) -> std::ops::Range<usize> {
    let range: std::ops::Range<usize> = match pointcoord > previouspointcoord {
        true => (previouspointcoord+1)..pointcoord,
        false => (pointcoord+1)..previouspointcoord,
    };
    return range;
}

pub fn get_point() -> (usize, usize) {
    let mut point = String::new();
    io::stdin().read_line(&mut point).expect("Failed to read input");

    let mut pointiter = point.split_ascii_whitespace();
    let y = parse(&mut pointiter)-1;
    let x = parse(&mut pointiter)-1;
    let output = (y, x);
    return output;
}

pub fn find_inside(grid: &Vec<Vec<u8>>) -> (usize, usize) {
    let mut output: (usize, usize) = (0, 0);
    let mut edges = 0;
    for rownum in 0..grid.len() {
        for colnum in 0..grid[rownum].len() {
            let char = grid[rownum][colnum];
            if char == 42 {
                break;
            }
            if char != 61 && char != 46 {
                edges += 1;
                if edges%2 == 1 {
                    if grid[rownum][colnum+1] == 46 {
                        output = (rownum, colnum+1);
                        break;
                }
                }
            }
        }
        if output != (0, 0) {
            break;
        }
    }
    return output;
}

pub fn fill(grid: &mut Vec<Vec<u8>>, point: (usize, usize)) {
    if grid[point.0][point.1] != 35 {
        if grid[point.0][point.1] == 46 {
            grid[point.0][point.1] = 35;
            fill(grid, (point.0-1, point.1));
            fill(grid, (point.0+1, point.1));
            fill(grid, (point.0, point.1-1));
            fill(grid, (point.0, point.1+1));
        }
    }
} 

pub fn printresult(grid: &Vec<Vec<u8>>) {
    let mut stringgrid: Vec<&str> = vec!();
    for row in grid {
        let charrow = &row[..];
        let s = match std::str::from_utf8(charrow) {
            Ok(v) => v,
            Err(_e) => panic!(),
        };
        stringgrid.push(s);
    }

    for row in stringgrid {
        println!("{}", row);
    }
}

Test 1 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    2,
    4,
)

Test 2 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    5,
    10,
)

Test 3 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    3,
    29,
)

Test 4 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    3,
    9,
)

Test 5 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    3,
    19,
)

Test 6 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    3,
    2,
)

Test 7 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    6,
    9,
)

Test 8 (public)

Verdict: RUNTIME ERROR

[input/code.rs:63] startpoint = (
    0,
    0,
)
thread 'main' panicked at input/code.rs:124:12:
index out of bounds: the len is 40 but the index is 18446744073709551615
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Test 9 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    3,
    8,
)

Test 10 (public)

Verdict: ACCEPTED

[input/code.rs:63] startpoint = (
    1,
    5,
)