Monikulmio

warning: value assigned to `point` is never read
  --> input/code.rs:18:13
   |
18 |     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};
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<String> = vec!();
    for _rownum in 0..height {
        grid.push(".".repeat(width));
    }

    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].replace_range((point.1)..(point.1+1), "*");

        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 range1 = match point.0 > previouspoint.0 {
                    true => (previouspoint.0+1)..point.0,
                    false => (point.0+1)..previouspoint.0,
                };
                for rownum in range1 {
                    grid[rownum].replace_range((point.1)..(point.1+1), "|");
                }
            } else if dy == 0 {
                let range = match point.1 > previouspoint.1 {
                    true => (previouspoint.1+1)..(point.1),
                    false => (point.1+1)..(previouspoint.1),
                };
                grid[point.0].replace_range(range, "=".repeat(dx.abs() as usize - 1).as_str());
            } else {
                let kulmakerroin = dy/dx;
                if kulmakerroin == 1 {
                    let rangey = match point.0 > previouspoint.0 {
                        true => (previouspoint.0+1)..point.0,
                        false => (point.0+1)..previouspoint.0,
                    };

                    for rownum in rangey {
                        let x = previouspoint.1+1+(rownum-previouspoint.0)*(kulmakerroin as usize);
                        grid[rownum].replace_range((x-1)..x, (92 as char).to_string().as_str())
                    }
                } else {
                    let rangey = match point.0 > previouspoint.0 {
                        true => (previouspoint.0+1)..point.0,
                        false => (point.0+1)..previouspoint.0,
                    };

                    for rownum in rangey {
                        let x = previouspoint.1+1-(rownum-previouspoint.0);
                        grid[rownum].replace_range((x-1)..x, "/");
                    }
                }
            }
        } else {
            firstpoint = point;
        }

        previouspoint = point;
    }

    for rownum in 0..height {
        println!("{}", grid[rownum]);
    }
}

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

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;
}

Test 1 (public)

Verdict: ACCEPTED

Test 2 (public)

Verdict: ACCEPTED

Test 3 (public)

Verdict: ACCEPTED

Test 4 (public)

Verdict: ACCEPTED

Test 5 (public)

Verdict: ACCEPTED

Test 6 (public)

Verdict: ACCEPTED

Test 7 (public)

Verdict: ACCEPTED

Test 8 (public)

Verdict: ACCEPTED

Test 9 (public)

Verdict: ACCEPTED

Test 10 (public)

Verdict: ACCEPTED