2048-rust.rs

game.rs

fn add_number_bad_way(board: Vec<Vec<i32>>, point: Vec<i32>, number: i32) -> Vec<Vec<i32>> {
    return board.iter().enumerate().map(|(column_index, line)| {
        return line.iter().enumerate().map(|(line_index, value)| {
            if column_index as i32 == point[0] && line_index as i32 == point[1] {
                return number;
            }
            return *value;
        }).collect();
    }).collect();
}

fn add_number(board: Vec<Vec<i32>>, point: Vec<i32>, number: i32) -> Vec<Vec<i32>> {
    let line = &board[point[0] as usize];

    let new_line = [
        &line[..point[1] as usize],
        &[number],
        &line[point[1] as usize + 1..]
    ].concat();

    return [
        &board[..point[0] as usize],
        &[new_line],
        &board[point[0] as usize +1..]
    ].concat();
}

fn return_index_to_column(column_idx: i32, vector: Vec<i32>) -> Vec<Vec<i32>> {
    return vector
        .iter()
        .enumerate()
        .fold([].to_vec(), |returned_value, (idx, value)| {
            if *value != 0 {
                return returned_value;
            }
            let new_value = [column_idx, idx as i32].to_vec();
            return [&returned_value[..], &[new_value]].concat();
        });
}

fn get_empty_blocks(board: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    return board
        .iter()
        .enumerate()
        .fold([].to_vec(), |returned_value, (column_idx, line)| -> Vec<Vec<i32>> {
            let line_empty_blocks = return_index_to_column(column_idx as i32, line.to_vec());
            return [&returned_value[..], &line_empty_blocks].concat();
        });
}

tests.rs

#[test]
fn test_return_index_to_column() {
    let column = return_index_to_column(2, [1,0,0,1].to_vec());
    assert!(column[0][0] == 2 && column[0][1] == 1);
    assert!(column[1][0] == 2 && column[1][1] == 2);
}

#[test]
fn test_return_index_to_board() {
    let board = vec![
        vec![2, 0, 2, 4],
        vec![8, 16, 0, 4],
        vec![32, 16, 16, 16],
        vec![8, 32, 0, 16],
    ];

    let indexes = get_empty_blocks(board);
    assert!(indexes[0][0] == 0 && indexes[0][1] == 1);
    assert!(indexes[1][0] == 1 && indexes[1][1] == 2);
    assert!(indexes[2][0] == 3 && indexes[2][1] == 2);
}

#[test]
fn test_add_number_bad_way() {
    let board = vec![
        vec![2,0,2,4],
        vec![8,16,0,4],
        vec![32,16,16,16],
        vec![8,32,0,16]
    ];

    let new_block = add_number_bad_way(board, vec![1,2], 2);
    assert!(new_block[1][2] == 2);
}

#[test]
fn test_add_number_bad_way() {
    let board = vec![
        vec![2,0,2,4],
        vec![8,16,0,4],
        vec![32,16,16,16],
        vec![8,32,0,16]
    ];

    let new_block = add_number(board, vec![1,2], 2);
    assert!(new_block[1][2] == 2);
}