Arrays y Ciclo For en Rust

fn main() {
    println!("     ----------");
    println!("     Data table");
    println!("     ----------");

    let mut data_name:Vec<String> = Vec::new();
    let mut data_last_name:Vec<String> = Vec::new();
    let mut data_age:Vec<String> = Vec::new();
    let mut data_country:Vec<String> = Vec::new();
    let mut option_user:String = String::new();


    loop {
        let mut name:String = String::new();
        let mut last_name:String = String::new();
        let mut age:String = String::new();
        let mut country:String = String::new();

        println!("What is your name?");
        std::io::stdin().read_line(&mut name).unwrap();
        name = name.trim().to_string();
        data_name.push(name);


        println!("What is your last name?");
        std::io::stdin().read_line(&mut last_name).unwrap();
        last_name = last_name.trim().to_string();
        data_last_name.push(last_name);

        println!("How old are you?");
        std::io::stdin().read_line(&mut age).unwrap();
        age = age.trim().to_string();
        data_age.push(age);


        println!("Where are you from?");
        std::io::stdin().read_line(&mut country).unwrap();
        country = country.trim().to_string();
        data_country.push(country);
    
        loop {
            println!("----------------------------------------");
            option_user ="".trim().to_string();
            println!("Press 'E' to exit or 'C' to continue...");
            std::io::stdin().read_line(&mut option_user).unwrap();
            option_user = option_user.trim().to_string();
            println!("----------------------------------------");
            if option_user == "E" || option_user == "e" || option_user == "C" || option_user == "c"{
                break;
            }
            println!("'{}': It is not a valid option, try again", option_user);

        }
        if option_user == "E" || option_user == "e"{
            
            break;
        }


    }
    println!("Name    Last name    Age   Country");
    println!("-----------------------------------");
    for i in 0..data_name.len(){
        println!("{}    {}    {}   {}",data_name[i], data_last_name[i], data_age[i],data_country[i]);
    }
    println!("       --------");
    println!("       GOOD BYE");
    println!("       --------");
}

Un array en Rust es una colección fija de elementos del mismo tipo, donde la longitud del array se especifica en tiempo de compilación y no puede ser modificada en tiempo de ejecución. Los arrays se definen utilizando la sintaxis [Tipo; longitud]. Por ejemplo, let mi_array: [i32; 5] = [1, 2, 3, 4, 5]; define un array de 5 elementos de tipo i32.

Por otro lado, un vector en Rust es una colección dinámica de elementos del mismo tipo, cuya longitud puede cambiar en tiempo de ejecución. Los vectores se definen utilizando la sintaxis Vec<Tipo>. Por ejemplo, let mi_vector: Vec<i32> = vec![1, 2, 3, 4, 5]; define un vector de 5 elementos de tipo i32.

En cuanto a su uso, los arrays son útiles cuando se sabe de antemano la cantidad exacta de elementos que se necesitan y no se espera que esta cantidad cambie. Los vectores, por otro lado, son útiles cuando la cantidad de elementos que se necesitan puede cambiar en tiempo de ejecución, o cuando se necesita agregar o eliminar elementos de manera eficiente.

atentamente, su IA favorita ChatGPT<3

fn main() {
    let mut _arr:Vec<i32>=Vec::new();//Declaramos i32 para pasarlo a un numero entero
    
    let mut i=0;
    while i<=7{
        println!("Digita un numero: ");
        let mut numero:String=String::new();
        std::io::stdin().read_line(&mut numero).unwrap();
        let mut _numero:i32=numero.trim().parse().unwrap();
        _arr.push(_numero);//del arreglo lo pasamos a agragar numeros ingresados
        i+=1
    }
    //creamos contadores diferente para cada par e impar
    let mut _count_p:i32=0;
    let mut _count_i:i32=0;
    //Usamos for para recorrer la lista de los nuemeros ingresados
    for j in _arr.iter(){
        let res:i32= j % 2;//Operacion modulo % para conocer residuos.
         
        if res == 0{
            _count_p+=1;//contador de pares
        }else if res ==1 {
            _count_i+=1;//Contador de impares
            }
    }
    println!("Total de Pares: {_count_p}");
    println!("Total de Impares: {_count_i}");
    
}
Footer
© 2022 GitHub, Inc.

Array es la estructura de datos y vector es Abstract Data Type.
Por ende un array tambien puede ser mutable con el uso de mut por ejemplo.

let mut numbers: [i32; 5] = [1, 2, 3, 4, 5];

asi o mas simple?

fn main() {
    let mut names: Vec<String> = Vec::new();

    for i in 1..4 {
        let mut name = String::new();
        println!("Enter name #{}:", i);
        std::io::stdin().read_line(&mut name).unwrap();
        name = name.trim().to_string();
        names.push(name);
    }

    // print the names one after the other
    for name in names {
        println!("Hello, {}!", name);
    }
}

Los arrays son mejores en cuanto a rendimiento al momento de acceder a un valor, más eficiente en cuanto a memoria por tener un tamaño definido, incluso al no tener un sobrehead dinamico(que no lo tiene por no ser de tamaño dinámico).
Los vectores son buenos al momento de pensar en la flexibilidad porque su tamaño puede variar.

Suavecito.

<use std::io::{stdin};

fn main() {
    
    //fill array
    fn fill_array(word:String){
        //Vars
        println!("---------------");
        println!("List word");
        let mut my_arr: Vec<String> = Vec::new();
        my_arr.push(word.to_string());
        for word in my_arr{
            println!("{}", word);
        }
        println!("---------------");
    }

    //request user
    fn request_user_word(){
        println!("Insert word:");
        let mut word:String = String::new();
        stdin().read_line(&mut word).unwrap();
        fill_array(word.to_string());
    }

    //Next sintaxis
    fn array() {
        let array = [0,1,2,3,4,5,6,7,8,9];
        for i in array{
            println!("{}",i);
        }
    }
    
    //Control program
    fn control_program(){
        println!("---My first use for a cicles in rust----");
        request_user_word();
        println!("-------------------");
        println!("Array");
        array();
        println!("-------------------");
    }
    //Start program    
    control_program();
}
> 

ciclo for

• for i in 0..10 { println!("i {}",i);}
• for word in words { println!("{}",word);}

Y los arrays se utilizan creando un Vector

• let mut my_arr: Vec<String> = Vec::new();

y se agregan valores así

• my_arr.push("Texto".to_string());

se accede al valor en base cero

• println!("{}",my_arr[0]);

Mejorando el código de Hackerman

use std::io;

fn array() {
    let vector = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let result = vector.iter().map(|x| x.to_string()).collect::<Vec<String>>();
    println!("{:?}", result);
}

fn control_program() {
    println!("---My first use for a cicles in rust----");

    println!("Insert word:");
    let mut word = String::new();
    io::stdin().read_line(&mut word).unwrap();

    println!("Vector:");
    array();
}

fn main() {
    control_program();
}

fn main() {
    println!("Hey! Introduce yourself");

    let mut data: Vec<String> = Vec::new();

    let questions = vec![
        "Please introduce your name:",
        "Please introduce your age:",
        "Please introduce your country:",
    ];

    for ask in questions {
        println!("{}", ask);
        let mut answer = String::new();
        std::io::stdin().read_line(&mut answer).unwrap();
        data.push(answer.trim().to_string())
    }

    println!("{:?}", data);

    println!(
        "Hello, my name is {}. I'm {} years old, and I'm from {}.",
        data[0], data[1], data[2],
    );
}