Condicionales

Se pueden hacer asignaciones de variables con condicionales ternarios

let variable = if true { "Enabled" } else { "Disabled" };

fn main() {
    println!("Esta es tu última oportunidad. Después, ya no podrás echarte atrás. Si tomas la pastilla azul, fin de la historia. Despertarás en tu cama y creerás lo que quieras creerte. Si tomas la roja, te quedas en el País de las Maravillas y yo te enseñaré hasta dónde llega la madriguera de conejos. Recuerda lo único que te ofrezco es la verdad. Nada más.");
    println!("Qué pastilla tomarás? roja o azul?");

    let mut opcion: String = String::new();
    std::io::stdin().read_line(&mut opcion).unwrap();
    let pastilla: &str = opcion.trim();

    if pastilla == "roja" {
        println!("Muy bien, Neo. Sígueme....");
    } else if pastilla == "azul" {
        println!("Como prefieras. No nos veremos nunca mas....");
    } else {
        println!("Tal parece que no eres el Neo que pensábamos.");
    }
}

fn main() {
    let mut pill: String = String::new();
    println!("Do you want a blue pill or red pill?");
    std::io::stdin().read_line(&mut pill).unwrap();

    // lowercase the input to make it easier to compare
    pill = pill.to_lowercase();

    if pill == "blue\n" || pill == "b\n" {
        println!("You'll have free coffee forever!");
    } else if pill == "red\n" || pill == "r\n" {
        println!("You are going to live without coffee and code for life.");
    } else {
        println!("Game over. I'd suggest you start running.");
    }
}

En el instante 9:10. Esto se puede realizar por las propiedades de la logica. En particular el teorema shunting, que permite reemplazar una expresión lógica por otra equivalente

p => q => r
es equivalente a
p && q => r

Lease p => q como “Si p entonces q”. Si estas aprendiendo a programar eventualmente te servirá aprender lógica simbólica y sus propiedades. Con esta herramienta se puede escribir código más simples y además, probar formalmente que las condiciones son correctas.

use std::io;

fn main() {
    let pildora_roja: &str = "🔴";
    let pildora_azul: &str = "🔵";
    let mut opcion: String = String::new();

    println!("¿Cual pildora deseas tomar?");
    println!("1 - Pildora roja {}", pildora_roja);
    println!("2 - Pildora azul {}", pildora_azul);

    io::stdin().read_line(&mut opcion).unwrap();

    let op_int: u8 = opcion.trim().parse().unwrap();

    if op_int == 1 {
        println!("Elegiste la pildora {}", pildora_roja)
    } else if op_int == 2 {
        println!("Elegiste la pildora {}", pildora_azul)
    }else{
        println!("Opción invalida")
    }
}

Dejo mi aporte de lo que estuve probando

use chrono::prelude::*;

fn obtener_edad(ano_nacimiento: u32) -> u32 {
    let mut edad: u32 = 0;

    let utc_now: DateTime<Utc> = Utc::now();
    let ano_actual = utc_now.year() as u32;

    if ano_nacimiento > 0 {
        edad = ano_actual - ano_nacimiento as u32;
    }

    return edad;
}

fn es_mayor_edad(edad: u32) -> bool {
    return edad >= 18;
}

fn main() {

    println!("Ingrese su nombre");
    let mut nombre_input: String = String::new();
    std::io::stdin().read_line(&mut nombre_input).unwrap();
    nombre_input = nombre_input.trim().to_string().to_uppercase();

    println!("Ingrese su año de nacimiento: ");
    let mut ano_input: String = String::new();
    std::io::stdin().read_line(&mut ano_input).unwrap();
    let ano_nacimiento_int: u32 = ano_input.trim().parse().unwrap();
    let edad: u32 = obtener_edad(ano_nacimiento_int);

    if es_mayor_edad(edad) {
        println!("{} es mayor de edad", nombre_input);
    } else {
        println!("{} es menor de edad", nombre_input);
    }

    println!("Nombre: {} - Edad: {}", nombre_input, edad);
}

Reto

fn main(){
   pildoras();
}
fn pildoras(){
    println!("Hola bienvenido, que pastillas desea tomar, azul o roja?");
    let mut pastillas: String = String::new();
    std::io::stdin().read_line(&mut pastillas).unwrap();
    pastillas = pastillas.trim().to_lowercase();

    if pastillas == "azul"{
        println!("Felicidades, usted elijio pastillas azules")
    }
    else if pastillas == "roja"{
        println!("Felicidades, usted elijio pastillas rojas")
    }
    else{
        println!("Lo sentimos, no tenemos esa pastilla")
    }
    
}

Dato : Rust tiene un comando para formatear el codigo completamente, se logra con
$ rustfmt nombreArchivo .rs

Ejemplo:

fn main() {
//Obtener la edad desde la consola,
              println!("Introduce tu edad: ");
let mut edad: String = String::new(); 
 std::io::stdin().read_line(&mut edad).unwrap(); 


   let edad_int: u8 = edad.trim().parse().unwrap(); 

 if edad_int < 18 {
          println!("Eres menor de edad");
    }               else  {
      println!("Eres mayor de edad");
              }

println!("Hola  tiene {}", edad_int);
}

fn condicionales_reto() {
  println!("¿Qué píldora quieres tomar, la roja o la azul?: ");
  let mut pildora: String = String::new();
  std::io::stdin().read_line(&mut pildora).unwrap();

  if pildora.trim() == "roja" {
    println!("Quieres ir al mundo matrix");
  } else if pildora.trim() == "azul" {
    println!("Quieres ir al mundo neo");
  } else {
    println!("No es una decisión válida")
  }
}

fn main() {
    let name_nightclub:String = "Coco Bongo".to_string();

    println!("");
    println!("{}",name_nightclub);
    println!("----------");
    println!("");

    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();
    
    let age_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 {
        let year_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);       
    }
   
}

no olvidar identar… Asi todo el mundo sabe que pertenece a quien

Mi solución al reto

fn main() {
    println!("\"You must choose...\"");
    println!("It extends both of its hands and shows you two pills:");
    let mut valid_choice: bool = false;
    let mut choose_red: bool = false;
    let mut input: String = String::new();

    while !valid_choice {
        println!("On the left hand there is a red pill");
        println!("On the right hand there is a blue pill");
        println!("What option are you going to choose? (left/right)");
        std::io::stdin().read_line(&mut input).unwrap();
        input = input.trim().to_string();
        if input.eq_ignore_ascii_case("left") {
            choose_red = true;
            valid_choice = true;
        } else if input.eq_ignore_ascii_case("right") {
            choose_red = false;
            valid_choice = true;
        } else {
            valid_choice = false;
            println!("\"I wont let you go until you choose one of them\"");
        }
    }
    let pill: &str;
    let pill_consequence: &str;
    if choose_red {
        pill = "red";
        pill_consequence = "learn a potentially unsettling or life-changing truth";
    } else {
        pill = "blue";
        pill_consequence = "remaining in contented ignorance";
    }
    println!(
        "\"You choose the {} pill, now you will {}\"",
        pill, pill_consequence
    );
}

Aquí está mi solución al reto que propone el profesor:

fn main() {
    let pill_color: String = ask_user_for("Escoge la pildora (roja/azul): ");

    if pill_color == "roja" {
        println!("Entras a la Matrix!");
    } else if pill_color == "azul" {
        println!("Vuelves al \"mundo real\".");
    } else {
        println!("No es una opción válida.");
    }
}

fn ask_user_for(label: &str) -> String {
    let mut user_answer: String = String::new();
    println!("{}", label);
    std::io::stdin().read_line(&mut user_answer).unwrap();
    user_answer.trim().to_lowercase().to_string()
}

Re-usé la función que utilicé para el reto anterior, pero le agregue un .to_lowercase() para asegurarme de que el input del usuario siempre se convierta.

fn main() {
    println!("BIENVENIDO A LA MATRIX \n");
    println!("Digita color de Pildora Azul o Roja: ");
    let mut pil:String=String::new();
    std::io::stdin().read_line(&mut pil).unwrap();
    pil=pil.trim().to_lowercase();//.trim() elimina los espacios en blanco al inicio y fin. 

    if pil=="azul"{
        println!("Te va a ir a la Matrix");
    }
    else if pil=="rojo"{
            println!("Te va a ir al Mundo real.")
        }
    else{
        println!("Se va a destruir todo el universo. ");
    }
}

fn main() {
    println!("azul o rojo");

    let mut eleccion: String = String::new();
    std::io::stdin().read_line(&mut eleccion).unwrap();

    eleccion = eleccion.trim().to_lowercase();

    if eleccion == "azul" {
        println!("hola");
    } else if eleccion == "rojo" {
        println!("andate");
    }
    else {
        println!("Q");
    }
}

C O D I G O:

fn reto_02() {
    let mut opcion: String = String::new() ;
    println!("Favor escoja una opción:\n1. Píldora AZUL.\n2. Píldora ROJA.") ;
    std::io::stdin().read_line(&mut opcion).unwrap() ;

    match &*opcion.trim() {
        "1" => println!("Ud. sera enviado a la realidad física") ,
        "2" => println!("Ud. sera enviado de vuelta a la matrix") ,
        _ => println!("Favor ingrese una opción válida") ,
    } ;
}

E J E C U C I O N:

Favor escoja una opción:
1. Píldora AZUL.
2. Píldora ROJA.
2
Ud. sera enviado de vuelta a la matrix

Process finished with exit code 0

fn main() {
	let age_int: i8 = get_age();
	
	age_evaluator(age_int);
}

fn get_age() -> i8 {
	println!("Insert age: \n");

	let mut age : String = String::new();
	std::io::stdin().read_line(&mut age).unwrap();
	
	let age_int: i8 = age.trim().parse().unwrap();

	return age_int;
}

fn age_evaluator(age_int: i8) -> () {
	if age_int < 18 {
		println!("You are not old enough");
	} else {
		println!("You are old enough");
	}
}

    if pildora.to_lowercase() == "azul" {
        println!("Bienvenido a la matrix")
    } else if pildora.to_lowercase() == "roja" {
        println!("Seguro eres un agente")
    } else {
        println!("no sabes lo que estas haciendo")
    }