Los ciclos iterativos en Rust realmente rompen con el paradigma de sintaxis de programación en comparación con otros lenguajes.
Iteraciones en Rust
Si tienes algo de experiencia en PHP, Java, Javascript, C#, C++, o cualquier otro lenguaje, entenderás un ciclo iterativo como una repetición de un código N cantidad de veces. Rust no es la excepción, puedes declarar una iteración de una forma particular:
fnmain(){loop{println!("Ingrese 123 para detener el loop:");letmut number:String=String::new();std::io::stdin().read_line(&mut number).unwrap();let number_int:i32= number.trim().parse().unwrap();if number_int ==123{break;}}}
La palabra reservada loop crear un ciclo de iteraciones del código fuente en su interior. El ciclo se repetirá hasta encontrar un break.
En el anterior ejemplo, el ciclo se repite infinitas veces hasta que el usuario ingrese el número 123. Validamos el número ingresado con un if y, si este es correcto, finalizamos la ejecución del loop.
loop es una manera diferente de crear un ciclo iterativo. Es crucial que tengas los cuidados necesarios en tu algoritmo y que sea bien probado para no entrar en bucles infinitos y asegurar que el mismo tenga un punto de finalización.
Dato la linea con la que termina la ejecucion del programa puede no llevar ;
fn main(){let numero_1 =123;let numero_2 =123;let suma = numero_1 + numero_2; loop {//mostrar los dos numeros en consola println!("primer numero {}, segundo numero {}", numero_1, numero_2);//Obtener del usuario el numero que represnta la sumalet mut suma_usuario =String::new();std::io::stdin().read_line(&mut suma_usuario).unwrap();letsuma_usuario_int: i32 = suma_usuario.trim().parse().unwrap();if suma_usuario_int == suma { println!("La suma es correcta C:");break}else{ println!("La suma es incorrecta :C. Respuesta correcta: {}", suma)}}}
Datito de sytanxis, gracias!
por qué no? a mi no me dio problemas poniendole el ; en el break :o
Rust realmente rompe con los paradigmas de sintaxis de código en comparación a lenguajes como C, Java o Javascript, entre otros, que tienen mucho en común. Nunca había visto un loop con esa sintaxis en ningún lado.
No rompe con ningún paradigma por esto. C no lo escribe explícitamente pero el código que se compila si lo hace. En assembly cualquier procesador lo trabaja de este modo. No existe ninguna instrucción while en lenguaje máquina ni siquiera en procesadores del tipo CISC pero si podés loopear con un jump o goto (según procesador que uses) y luego realizar una comparación para salir del loop e ingresar a otra posición de memoria de código. Lo que pierden de vista muchos programadores de alto nivel es que el lenguaje es solo una herramienta, tarde o temprano todo termina convirtiéndose en lenguaje de máquina. Quizá hoy en día importa muy poco la cantidad de instrucciones que lleva una tarea o cuanto ocupa en memoria de código o como se trabaja ciertas variables para lograr una mayor velocidad de acceso porque las computadoras tienen capacidades que ya parecen infinitas para preocuparse por esas pequeñeces pero con la web3 volvemos a tener esas preocupaciones ya que toda operación involucra un costo o desperdicio de recursos, en solidity por ejemplo, por más que se parezca javascript cuesta sacarle la idea a los programadores que no es javascript, que tienen que cuidarse con los arrays, con los loops, con las variables. Acá con Rust recién empiezo por lo que no te puedo hablar con certeza de muchas cosas pero por lo que averigué se centra en eficiencia de memoria y velocidad, incluso como dijo el profesor para ser escrito en microcontroladores en donde sus capacidades son mucho más limitadas por lo que parece totalmente coherente que utilicen la estructura del assembly para hacerlo que es mucho más optimo en recursos y velocidad. Un profesor de la facultad me dijo una vez y me quedó grabado, que es totalmente ridículo que le digan a la gente que "no utilicen goto o jmp incondicionales" cuando en el fondo todo se traduce en eso solo que son sentencias que están reservadas para los que realmente entienden la arquitectura y saben por que, cómo y cuándo usarlo. En lo que es microcontroladores por ejemplo se usa la sentencia while(1) para generar el loop, ahora cual sería el motivo de que realmente se haga la comparación de si ese 1 es igual a true para ingresar? es un gasto innecesario de recursos, claro que un buen compilador lo entendería y lo haría como un loop pero hay muchas otras cosas que un compilador no vería y es bueno ayudarle a optimizar y en ese sentido encuentro que esta forma de Rust está buenisimo para una compilación mucho más optimizada, pero no es un cambio de paradigma sino que es la forma en la que siempre fueron las cosas y entender todas estas cosas del verdadero funcionamiento por detrás y saber cuando y como aplicarlas creo que es una de las bases que diferencia a un hobbista que sabe programar de un profesional que sabe programación. Acá en platzi todos estamos intentando de aprender a programar pero no debemos dejar la profesionalidad olvidada por eso y debemos luchar por intentar de alcanzarla.
es solo como un while(true){}
Mi respuesta al reto pasado fue diferente, almacene las repuesta directamente en una variable.
fn main(){ println!("Please, write your name: ");let mut name:String=String::new();std::io::stdin().read_line(&mut name).unwrap(); println!("Please, write your age: ");let mut age:String=String::new();std::io::stdin().read_line(&mut age).unwrap(); println!("Please, write the country where you come from?: ");let mut country:String=String::new();std::io::stdin().read_line(&mut country).unwrap(); println!("Please, write your hometown?: ");let mut hometown:String=String::new();std::io::stdin().read_line(&mut hometown).unwrap(); println!("Did you see the movie Matrix? Which pill would you take if you were in it, Red Pill or Blue Pill?: ");let mut pill:String=String::new();std::io::stdin().read_line(&mut pill).unwrap(); name = name.trim().to_string();letage_int: u8 = age.trim().parse().unwrap(); country = country.trim().to_string(); hometown = hometown.trim().to_string(); pill = pill.trim().to_string().to_lowercase();let response_age_validation =if age_int >=70{"You are Old. Take care of your health."}elseif age_int >=18{"You're a adult. Work hard, Fighting!!"}else{"You're young, High Five!!."};let response_pill_validation =if pill =="red pill"{"You preferred the reality of the Matrix. Enjoy it!!"}elseif pill =="blue pill"{"You like the truth, Live your adventure!!"}else{"Bad decision, what have you done?!."}; println!("Hi, Welcome {}.", name); println!("Your age is {} years. {}", age_int, response_age_validation); println!("You come from {} in {}, That's nice.", hometown, country); println!("You choose the {}. {}", pill, response_pill_validation);}
Muy buena solucion
Comparto mi codigo de registro a una fiesta, falta mejorar pero me parece bueno para comenzar.
fn main(){ loop {letname_nightclub:String="Coco Bongo".to_string(); println!(""); println!(" ----------"); println!(" {}",name_nightclub); println!(" ----------"); println!("");let mut option_user:String=String::new(); println!("Please enter your name...");let mut name:String=String::new();std::io::stdin().read_line(&mut name).unwrap(); name = name.trim().to_string(); println!("What country are you from {}?", name);let mut country:String=String::new();std::io::stdin().read_line(&mut country).unwrap(); country = country.trim().to_string(); println!("Please enter your age...");let mut age:String=String::new();std::io::stdin().read_line(&mut age).unwrap();letage_int:u8=age.trim().parse().unwrap();if age_int >=18{ println!(""); println!("Hello {} from {}, you are {} years old.",name,country,age_int); println!(""); println!(" Welcome to {}", name_nightclub);}else{letyear_return:u8 =18- age_int; println!(""); println!("Hello {} from {}, you are {} years old.",name,country,age_int); println!(""); println!(" Come back in {} years", year_return);} 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"{ println!(" GOOD BYE"); println!(" --------");break;}}}
fnmain(){loop{let num_2:i32=get_num();let num_1:i32=get_num();let result =sum_num(num_1, num_2);println!("[+] Sum -> : {}", result);println!("\n If you want to leave you must add a number greater than 4128: \n");if result >4128{println!("\n[-] Bye Bye! \n");break;}}}fnget_num()->i32{println!("Insert num_one: \n");letmut num :String=String::new();std::io::stdin().read_line(&mut num).unwrap();let num_int:i32= num.trim().parse().unwrap();return num_int;}fnsum_num(num_1:i32, num_2:i32)->i32{return num_1 + num_2;}
Deberías dejar la declaración de variables por fuera del loop, de resto esta super bien. Saludos.
fn main(){ println!(" Esta atent@ al diálogo, y responde los 3 interrogantes planteados, no los falles y serás nuestro Neo.=>;Matrix:Diálogo entre Morfeo y Neo para la Elección de la Píldora<=[Morfeo]:-BienvenidoNeo y sin duda adivinas que soy Morfeo.[Neo]:-Es un honor,Morfeo.[Morfeo]:-No, el honor es mío. Por favor, ven, siéntate.-Morfeo cierra la Puerta detrás de Trinity y se sienta luego de que Neo también se sentó-.[Morfeo]:-Imagino que te sientes un poco como Alicia cayendo por el agujero del conejo.[Neo]:-Mm, algo así.[Morfeo]:-Puedo verlo en tus ojos. Tienes la mirada de un hombre que acepta lo que ve
porque está esperando despertar. Irónicamente, hay algo de cierto. ¿Crees en el destino,Neo?"); let mut neo_cree_destino:String=String::new(); std::io::stdin().read_line(&mut neo_cree_destino).unwrap(); neo_cree_destino = neo_cree_destino.trim().to_string();if neo_cree_destino.to_lowercase()=="no"{ println!(" [Neo]:-No[Morfeo]:-¿Por qué no?[Neo]:-Porque no me gusta la idea de que no controlo mi vida.[Morfeo]:-Sé con exactitud de qué hablas. Déjame decirte qué haces aquí.Viniste por algo que sabes, no puedes explicarlo, pero lo sientes. Lo has sentido toda la vida. Que hay algo mal en el mundo. No sabes lo que es, pero ahí está como una astilla en tu mente, volviéndote loco y eso que percibes
te ha traído a mí. ¿Sabes de lo que estoy hablando?");}else{ println!(":'( Ah Neo, te gusta que te tengan su vida controlada!! No eres 'EL ELEGIDO' :'(");} let mut neo_respuesta:String=String::new(); std::io::stdin().read_line(&mut neo_respuesta).unwrap(); neo_respuesta = neo_respuesta.trim().to_string();if neo_respuesta.to_lowercase()=="de matrix"{ println!(" [Neo]:-DeMatrix.[Morfeo]:-¿Te gustaría saber qué es lo que es eso?Matrix está donde quiera, a nuestro alrededor. Aún ahora está en esta habitación. Puedes verla asomándote la ventana o encendiendo el televisor y la percibes al ir a
trabajar, al ir a la iglesia, al pagar impuestos. Es el mundo que han puesto
ante tus ojos para que no veas la verdad.-Neo acerca su torso un poco más para expresar su inquietud-.[Neo]:-¿Qué verdad?[Morfeo]:-Que eres un esclavo,Neo. Igual que los demás, naciste cautivo. Naciste en una prisión que no puedes probar, tocar ni oler. Una prisión para tu
mente. Por desgracia, nadie se le puede decir lo que Matrixes. Tendrás que verlo
por ti mismo.-En el climax de la charla ambos se acercan el uno al otro mientras continuan sentados-.[Morfeo]:-Es tu última oportunidad. Después ya no hay marcha atrás.-Por encima de la mesita que divide los sillones Morfeo muestra una píldora
de color azul que tenía escondida en su mano izquierda-.[Morfeo]:-Si tomas la píldora azul, termina la historia. Despiertas en tu cama y
crees lo que tú quieras creer.-Luego en su mano derecha descubre una píldora de color rojo-.[Morfeo]:-Con la roja te quedas en el país de las maravillas. Y te mostraré a dónde
llega el agujero del conejo.-Con las dos píldoras para elegir,Neo decide extender su brazo hacia la píldora roja, cuando su mano está bastante cerca-.[Morfeo]:-Recuerda, yo solo te ofrezco la verdad, nada más.");}else{ println!(":'( Ah Neo, No tienes IdeA!! No eres 'EL ELEGIDO' :'(");} let mut color_pildora_elegida:String=String::new(); std::io::stdin().read_line(&mut color_pildora_elegida).unwrap(); color_pildora_elegida = color_pildora_elegida.trim().to_string();if color_pildora_elegida.to_lowercase()=="roja"{ println!(" -Neo elije la pildora Roja y toma el vaso de agua que está en
la mesita, se pone la píldora en la boca y se la traga al tomar más de la mitad del
vaso de agua-.[Morfeo]:-¡Sígueme!");}elseif color_pildora_elegida.to_lowercase()=="azul"{ println!(" -termina la historia. NeoDespierta en su cama y
cree lo que quiera creer.");}else{ println!(":'(AhNeo,No tienes IdeA!!No eres 'EL ELEGIDO'.Seguiremos en la búsqueda del verdadero :'(");}}
Salida:
Esta atent@ al diálogo, y responde los 3 interrogantes planteados,
no los falles y serás nuestro Neo.
=>Matrix: Diálogo Morfeo y Neo para la Elección de la Píldora<=
[Morfeo]: -Bienvenido Neo y sin duda adivinas que soy Morfeo.
[Neo]: -Es un honor, Morfeo.
[Morfeo]: -No, el honor es mío. Por favor, ven, siéntate.
-Morfeo cierra la Puerta detrás de Trinity y se sienta luego de que Neo también se sentó-.
[Morfeo]: -Imagino que te sientes un poco como Alicia cayendo por el agujero del conejo.
[Neo]: -Mm, algo así.
[Morfeo]: - Puedo verlo en tus ojos. Tienes la mirada de un hombre que acepta lo que ve
porque está esperando despertar. Irónicamente, hay algo de cierto. ¿Crees en el destino,
Neo?
no
[Neo]: -No
[Morfeo]: -¿Por qué no?
[Neo]: -Porque no me gusta la idea de que no controlo mi vida.
[Morfeo]: -Sé con exactitud de qué hablas. Déjame decirte qué haces aquí.
Viniste por algo que sabes, no puedes explicarlo, pero lo sientes.
Lo has sentido toda la vida. Que hay algo mal en el mundo. No sabes lo que es,
pero ahí está como una astilla en tu mente, volviéndote loco y eso que percibes
te ha traído a mí. ¿Sabes de lo que estoy hablando?
de matrix
[Neo]: -De Matrix.
[Morfeo]: -¿Te gustaría saber qué es lo que es eso? Matrix está donde quiera,
a nuestro alrededor. Aún ahora está en esta habitación.
Puedes verla asomándote la ventana o encendiendo el televisor y la percibes al ir a
trabajar, al ir a la iglesia, al pagar impuestos. Es el mundo que han puesto
ante tus ojos para que no veas la verdad.
-Neo acerca su torso un poco más para expresar su inquietud-.
[Neo]: -¿Qué verdad?
[Morfeo]: -Que eres un esclavo, Neo. Igual que los demás, naciste cautivo.
Naciste en una prisión que no puedes probar, tocar ni oler. Una prisión para tu
mente. Por desgracia, nadie se le puede decir lo que Matrix es. Tendrás que verlo
por ti mismo.
-En el climax de la charla ambos se acercan el uno al otro mientras continuan sentados-.
[Morfeo]: -Es tu última oportunidad. Después ya no hay marcha atrás.
-Por encima de la mesita que divide los sillones Morfeo muestra una píldora
de color azul que tenía escondida en su mano izquierda-.
[Morfeo]: -Si tomas la píldora azul, termina la historia. Despiertas en tu cama y
crees lo que tú quieras creer.
-Luego en su mano derecha descubre una píldora de color rojo-.
[Morfeo]: -Con la roja te quedas en el país de las maravillas. Y te mostraré a dónde
llega el agujero del conejo.
-Con las dos píldoras para elegir, Neo decide extender su brazo hacia la píldora roja,
cuando su mano está bastante cerca-.
[Morfeo]: -Recuerda, yo solo te ofrezco la verdad, nada más.
roja
-Neo elije la pildora Roja y toma el vaso de agua que está en
la mesita, se pone la píldora en la boca y se la traga al tomar más de la mitad del
vaso de agua-.
[Morfeo]: -¡Sígueme!
Eureka!
palabra reservada* (no variable reservada)
Cuando dejo la declaración let mut suma_usuario = String::new() antes del loop me aparece el error:
thread 'main' panicked at 'Error al convertir resp.
: ParseIntError { kind: InvalidDigit }', main.rs:16:50
después de la segunda iteración. Si dejo la declaración dentro del loop ya no aparece. ¿A qué se debe?
Hola, ya se a que se debe el error... pero quiero que lo descubras tú, pon un print después del suma_usuario en ambos casos...
Vas a ver que dentro del bucle, la variable cambia siempre, fuera del bucle, la variable solo se instancia una vez.
Eso es porque dentro del bucle redefines y vacías la variable, fuera del bucle, le estás pasando siempre la misma variable, la cual ya tenia informacion 😌
Metí el reto de matrix dentro de un loop para que solo salga si se selecciona la roja. Funciona cuando es el primer valor que usas, pero si lo usas después de usar otra opción no se reescribe el valor de la variable... ¿alguien sabe qué pasa?
Aquí el código:
fn main(){loops();}fn loops(){let mut answer:String=String::new(); loop{ println!("Hello, Neo! Please choose either the red pill or the blue pill: ");std::io::stdin().read_line(&mut answer).unwrap(); answer = answer.trim().to_string();if answer =="red"{ println!("You choose the truth... Welcome to the Matrix...");break;}elseif answer =="blue"{ println!("You choose keep living in a lie...");}else{ println!("Please select one of the options");}}}
El let mut answer: String = String::new(); debe ir dentro del loop o se va a ir concatenando con cada iteracion
Estoy teniendo un problema con la impresión en pantalla ya que todas las impresiones se muestran al final de la ejecución exitosa del programa, alguien sabe a que se debe?
Muestranos tu codigo a ver 👀
Con la palabra reservada loopen Rust, podemos ejecutar codigo repetitivo para lograr un pogo de dinamismo en nuestros programas, es importante saber cuando se debe de dejar de ejecutar (si no quieres que muera tu máquina) y para ello se usa la palabra reservada break.
fn main(){ println!("Bienvenido neo, elige una píldora, la azul o la roja"); loop {let mut pildora =String::new();std::io::stdin().read_line(&mut pildora).unwrap(); pildora = pildora.to_lowercase().trim().to_string();if pildora !="azul"&& pildora !="roja"{ println!("En verdad crees que tienes otra opción?, no seas tonto, elige bien¡");continue;}if pildora =="azul"{ println!("Bienvenido a la matrix");}elseif pildora =="roja"{ println!("Bienvenido a la realidad");}break;}}```fn main(){ println!("Bienvenido neo, elige una píldora, la azul o la roja"); loop {let mut pildora =*String*::new(); std::io::stdin().read\_line(\&mut pildora).unwrap(); pildora = pildora.to\_lowercase().trim().to\_string();if pildora !="azul"&& pildora !="roja"{ println!("En verdad crees que tienes otra opción?, no seas tonto, elige bien¡");continue;}if pildora =="azul"{ println!("Bienvenido a la matrix");}elseif pildora =="roja"{ println!("Bienvenido a la realidad");}break;}}
loop:
Ejecuta un ciclo infinito hasta que explícitamente se use break para detenerlo.
No tiene condición de salida predeterminada.
Útil cuando quieres un ciclo que pueda controlarse manualmente.
while:
Ejecuta el ciclo mientras una condición sea verdadera.
Ideal para casos en los que no sabes cuántas veces se ejecutará el bucle, pero dependes de una condición para salir.
for:
Itera sobre colecciones o rangos de manera segura y eficiente.
Recomendado cuando tienes un número conocido de iteraciones o cuando iteras sobre una colección.
fn main(){ println!("Que pastilla tomaras? roja o azul?");let mut opcion:String=String::new();std::io::stdin().read_line(&mut opcion).unwrap();letpastilla:&str = opcion.trim();if pastilla =="roja"{ println!("Neo, conoces un Carpincho?");}elseif pastilla =="azul"{ println!("Neo, la vida es bella");}else{ println!("Neo, llueve en Buenos Aires");}}```fn main(){ println!("Que pastilla tomaras? roja o azul?");let mut opcion:String=String::new(); std::io::stdin().read\_line(\&mut opcion).unwrap();letpastilla: \&str = opcion.trim();if pastilla =="roja"{ println!("Neo, conoces un Carpincho?");}elseif pastilla =="azul"{ println!("Neo, la vida es bella");}else{ println!("Neo, llueve en Buenos Aires");}}
fn main(){ println!("Qué pastilla tomarás? roja o azul?");let mut opcion:String=String::new();std::io::stdin().read_line(&mut opcion).unwrap();letpastilla:&str = opcion.trim();if pastilla =="roja"{ println!("Neo, conoces un Carpincho?");}elseif pastilla =="azul"{ println!("Neo, la vida es bella");}else{ println!("Neo, llueve en Buenos Aires");}}```fn main(){ println!("Qué pastilla tomarás? roja o azul?");let mut opcion:String=String::new(); std::io::stdin().read\_line(\&mut opcion).unwrap();letpastilla: \&str = opcion.trim();if pastilla =="roja"{ println!("Neo, conoces un Carpincho?");}elseif pastilla =="azul"{ println!("Neo, la vida es bella");}else{ println!("Neo, llueve en Buenos Aires");}}
Yo lo realicé con el ejercicio de la píldora
fn main(){ loop { println!("Please choose between a pill, red or blue");let mut pill:String=String::new();std::io::stdin().read_line(&mut pill).unwrap(); pill = pill.trim().to_string();if pill =="red"{ println!("Hi, You choose {} pill, You're awakened !", pill);break;}elseif pill =="blue"{ println!("Hi, You choose {} pill, you will be sleep forever !", pill);break;}else{ println!("sorry, you decision is incorrect");}}}
solo por curiosidad puse este codigo
let mut numero :i128 =0; loop { numero = numero +1; println!("{}",numero)}
y en menos de 7 segundos ya habia iterado mas de 2.131.935 veces, esas son 304.562 veces por segundo, esto es normal?
increible!
use std::io::stdin;fn main(){let numero_1 =1325;let numero_2 =2344;let res_suma = numero_1 + numero_2;let mut suma_usuario =String::new();let mut int_suma_usuario: i64; loop { println!("Sin usar calculadora, cual sería el resultado de {} mas {}?",numero_1,numero_2);stdin().read_line(&mut suma_usuario).unwrap(); int_suma_usuario = suma_usuario.trim().parse().unwrap(); suma_usuario.clear();if int_suma_usuario == res_suma { println!("Correcto! Lo has conseguido!");break} println!("Lo siento, {} no es el resultado correcto, intenta nuevamente...",int_suma_usuario);}}
fn main(){ println!("Please, write your name: ");let mut name:String=String::new();std::io::stdin().read_line(&mut name).unwrap(); println!("Please, write your age: ");let mut age:String=String::new();std::io::stdin().read_line(&mut age).unwrap(); println!("Please, write the country where you come from?: ");let mut country:String=String::new();std::io::stdin().read_line(&mut country).unwrap(); println!("Please, write your hometown?: ");let mut hometown:String=String::new();std::io::stdin().read_line(&mut hometown).unwrap(); println!("Did you see the movie Matrix? Which pill would you take if you were in it, Red Pill or Blue Pill?: ");let mut pill:String=String::new();std::io::stdin().read_line(&mut pill).unwrap();letage_int: i8 = age.trim().parse().unwrap(); println!("what year were you born?: ");let mut year_birth: i16; loop {let mut question:String=String::new();std::io::stdin().read_line(&mut question).unwrap(); year_birth = question.trim().parse().unwrap();letcurrent_year: i16 =2022;let response_year_validation =ifi8::try_from(current_year - year_birth).unwrap()== age_int {break}else{"Are you sure? in that year were you born?! Check the year and write it again:"}; println!("{}",response_year_validation);} name = name.trim().to_string(); country = country.trim().to_string(); hometown = hometown.trim().to_string(); pill = pill.trim().to_string().to_lowercase();let response_age_validation =if age_int >=70{"You are Old. Take care of your health."}elseif age_int >=18{"You're a adult. Work hard, Fighting!!"}else{"You're young, High Five!!."};let response_pill_validation =if pill =="red pill"{"You preferred the reality of the Matrix. Enjoy it!!"}elseif pill =="blue pill"{"You like the truth, Live your adventure!!"}else{"Bad decision, what have you done?!."}; println!("Hi, Welcome {}.", name); println!("Your age is {} years. You born in {}. {}", age_int, year_birth, response_age_validation); println!("You come from {} in {}, That's nice.", hometown, country); println!("You choose the {}. {}", pill, response_pill_validation);}