100sortRust

//Para Jogar de o comando no terminal:
//cargo new arrumeacasa
//Editar o cargo.toml e colocar abaixo de [dependencies]: 
//rand = "0.3.14"
//Copiar o codigo abaixo no src/main.rs
//Salvar e dar cargo run

extern crate rand;

use rand::Rng;
use std::io;

struct Game {
    board: [u32; 25],
    turn : u32,
}

fn main() {
    let mut game_ini = Game {
        board: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
        turn : 0,
    };
    
    while game_ini.turn != 25 {

        let nro_rand = sorteia_nro(game_ini.board);
        monta_tela(game_ini.board);

        loop {
            let input = pergunta_casa(nro_rand);
        
            let mut char = input.chars();
            let linha = char.nth(0);
            let linha_str: String = linha.into_iter().collect();
            let coluna = char.nth(0);
            let coluna_str: String = coluna.into_iter().collect();
            let linha_u: u32 = linha_str.trim().parse().expect("!");
            let coluna_u: u32 = coluna_str.trim().parse().expect("!");
        
             //calcular casa pela linha e coluna
            let x = (linha_u - 1) * 5;
            let ind = (coluna_u - 1) + x;
            let indx: usize = ind as usize; 
            let nro_na_casa =  game_ini.board[indx];
            if nro_na_casa == 0 {
                game_ini.board = board_set(game_ini.board, indx, nro_rand);
                game_ini.turn = game_ini.turn + 1;
                break;
            };
        }
    }
    monta_tela_final(game_ini.board);
    let soma_pontos = verifica_final(game_ini.board);
    println!("Voce fez : {}  Pontos", soma_pontos);
}

fn sorteia_nro (board: [u32; 25]) -> u32 {
    let mut numero;
    loop {
        numero = rand::thread_rng().gen_range(1, 100);
        let mut nao_tem = true;
        //verifica se existe nro na tabela
                for idx in 0..25 {
                    let nro = board[idx];
                    if nro == numero {
                        nao_tem = false;
                    } 
                }
        if nao_tem == true {break;}
    } 
    numero
}

fn monta_tela(b: [u32; 25]) {
    println!("    1    2    3    4    5");
    println!(" 1  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[0]), m_t_a(b[1]), m_t_a(b[2]), m_t_a(b[3]), m_t_a(b[4]));
    println!("  --------------------------");
    println!(" 2  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[5]), m_t_a(b[6]), m_t_a(b[7]), m_t_a(b[8]), m_t_a(b[9]));
    println!("  --------------------------");
    println!(" 3  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[10]), m_t_a(b[11]), m_t_a(b[12]), m_t_a(b[13]), m_t_a(b[14]));
    println!("  --------------------------");
    println!(" 4  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[15]), m_t_a(b[16]), m_t_a(b[17]), m_t_a(b[18]), m_t_a(b[19]));
    println!("  --------------------------");
    println!(" 5  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[20]), m_t_a(b[21]), m_t_a(b[22]), m_t_a(b[23]), m_t_a(b[24]));
    println!(" ");
    println!(" ");
}

fn m_t_a(nro: u32) -> String {
    if nro == 0 {
        let str: String = "--".to_string();
        str
    } else {
        let str: String = format!("{:>2}", nro).to_string();
        str
    }
}

fn monta_tela_final(b: [u32; 25]) {
    println!("    1    2    3    4    5");
    if verifica_linha(0, b) {
        println!(" 1  {:02} | {:02} | {:02} | {:02} | {:02}  *", m_t_a(b[0]), m_t_a(b[1]), m_t_a(b[2]), m_t_a(b[3]), m_t_a(b[4]));
        println!("  --------------------------");
        } else {
        println!(" 1  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[0]), m_t_a(b[1]), m_t_a(b[2]), m_t_a(b[3]), m_t_a(b[4]));
        println!("  --------------------------");
    };
    if verifica_linha(1, b) {
        println!(" 2  {:02} | {:02} | {:02} | {:02} | {:02}  *", m_t_a(b[5]), m_t_a(b[6]), m_t_a(b[7]), m_t_a(b[8]), m_t_a(b[9]));
        println!("  --------------------------");
        } else {
        println!(" 2  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[5]), m_t_a(b[6]), m_t_a(b[7]), m_t_a(b[8]), m_t_a(b[9]));
        println!("  --------------------------");
    };
    if verifica_linha(2, b) {
        println!(" 3  {:02} | {:02} | {:02} | {:02} | {:02}  *", m_t_a(b[10]), m_t_a(b[11]), m_t_a(b[12]), m_t_a(b[13]), m_t_a(b[14]));
        println!("  --------------------------");
        } else {
         println!(" 3  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[10]), m_t_a(b[11]), m_t_a(b[12]), m_t_a(b[13]), m_t_a(b[14]));
        println!("  --------------------------");       
    };
    if verifica_linha(3, b) {
        println!(" 4  {:02} | {:02} | {:02} | {:02} | {:02}  *", m_t_a(b[15]), m_t_a(b[16]), m_t_a(b[17]), m_t_a(b[18]), m_t_a(b[19]));
        println!("  --------------------------");
        } else {
        println!(" 4  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[15]), m_t_a(b[16]), m_t_a(b[17]), m_t_a(b[18]), m_t_a(b[19]));
        println!("  --------------------------");       
    };
    if verifica_linha(4, b) {
        println!(" 5  {:02} | {:02} | {:02} | {:02} | {:02}  *", m_t_a(b[20]), m_t_a(b[21]), m_t_a(b[22]), m_t_a(b[23]), m_t_a(b[24]));
        } else {
        println!(" 5  {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[20]), m_t_a(b[21]), m_t_a(b[22]), m_t_a(b[23]), m_t_a(b[24]));
    }
    let mut col_str: String = String::new();
    for i in 0..4 {
    if verifica_colun(i, b) {
        col_str = col_str + "    *";  
        } else {
        col_str = col_str + "     ";    
    };
    };
    println!("{}", col_str);
    println!(" ");
}

fn pergunta_casa(nro_sort: u32) -> String {
    let mut retorno: String ;
    loop {
    let mut entrada = String::new();
    println!("Escolha uma linha e uma coluna pro Numero: {}", nro_sort);

    io::stdin().read_line(&mut entrada)
        .expect("Falha ao ler entrada");
    
    retorno = entrada.chars().filter(|c| c.is_digit(10)&& *c >= '1' && *c <= '5').collect();

    if retorno.len() > 1 {
        retorno = retorno.chars().take(2).collect();
        break;
        }
    }
    retorno
}

fn board_set(board: [u32; 25], idx: usize, nro: u32) -> [u32; 25] {
    let mut new_board = board;
    new_board[idx] = nro;
    new_board
}

fn verifica_final(board: [u32; 25]) -> u32 {
    let mut valor = 0;
    for linhas in 0..4 {
        if verifica_linha(linhas, board){
            let indice_lin = linhas * 5;
            let il: usize = indice_lin as usize; 
            valor = valor + board[il] + board[il+1] + board[il+2] + board[il+3] + board[il+4] 
        }
    };
    for colunas in 0..4 {
        if verifica_colun(colunas, board){
            let ic: usize = colunas as usize;
            valor = valor + board[ic] + board[ic+5] + board[ic+10] + board[ic+15] + board[ic+20] 
        }
    }
    valor
}

fn verifica_linha(lin: u32, board: [u32; 25]) -> bool {
    let indice_ini = lin * 5;
    let indice_fin = indice_ini + 4;
    let mut is_sort = true;
    for i in indice_ini..indice_fin {
        let idx: usize = i as usize; 
        if board[idx+1] < board[idx] {
            is_sort = false;
            break;
        } 
    };
    is_sort
}

fn verifica_colun(col: u32, board: [u32; 25]) -> bool {
    let mut is_sort = true;
        for i in [0, 5, 10, 15].iter() {
            let ind = col + i;
            let idx: usize = ind as usize; 
            if board[idx+5] < board[idx] {
                is_sort = false;
                break;
            } 
        };
    is_sort
}