120 lines
4.4 KiB
Rust
120 lines
4.4 KiB
Rust
/*
|
|
* Crea un pequeño juego que consista en adivinar palabras en un número máximo de intentos:
|
|
* - El juego comienza proponiendo una palabra aleatoria incompleta
|
|
* - Por ejemplo "m_ur_d_v", y el número de intentos que le quedan
|
|
* - El usuario puede introducir únicamente una letra o una palabra (de la misma longitud que
|
|
* la palabra a adivinar)
|
|
* - Si escribe una letra y acierta, se muestra esa letra en la palabra. Si falla, se resta
|
|
* uno al número de intentos
|
|
* - Si escribe una resolución y acierta, finaliza el juego, en caso contrario, se resta uno
|
|
* al número de intentos
|
|
* - Si el contador de intentos llega a 0, el jugador pierde
|
|
* - La palabra debe ocultar de forma aleatoria letras, y nunca puede comenzar ocultando más del 60%
|
|
* - Puedes utilizar las palabras que quieras y el número de intentos que consideres
|
|
*/
|
|
|
|
use rand::Rng;
|
|
use std::io;
|
|
|
|
fn creapalabra(palabra: &str, vectorocultas: &mut Vec<usize>) -> String {
|
|
let vector: Vec<char> = palabra.chars().collect();
|
|
let mut vectorfinal: Vec<char> = Vec::new();
|
|
for (index, i) in vector.iter().enumerate() {
|
|
if vectorocultas.contains(&index) == false {
|
|
vectorfinal.push(*i);
|
|
} else {
|
|
vectorfinal.push('_');
|
|
}
|
|
}
|
|
let mut palabrafinal: String = String::from("");
|
|
for i in vectorfinal {
|
|
palabrafinal = palabrafinal + &i.to_string();
|
|
}
|
|
palabrafinal.to_string()
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
// api palabras aleatorias
|
|
let html: String = reqwest::get("https://clientes.api.greenborn.com.ar/public-random-word") // Se pasa el url o endpoint con el cual se interacturara
|
|
.await? // Hace que reqwest espere por la respuesta del servidor
|
|
.text() //Convierte el resultado en un String
|
|
.await?;
|
|
let vector: Vec<&str> = html.as_str().split("").collect();
|
|
let mut palabra: String = String::from("");
|
|
let mut vectorpalabra: Vec<&str> = Vec::new();
|
|
for i in vector.iter() {
|
|
if i != &"["
|
|
&& i.to_string() != "]"
|
|
&& i.is_empty() == false
|
|
&& i.chars().last().unwrap() != '"'
|
|
{
|
|
match *i {
|
|
"á" => "a",
|
|
"é" => "e",
|
|
"í" => "i",
|
|
"ó" => "o",
|
|
"ú" => "u",
|
|
_ => i,
|
|
};
|
|
palabra = palabra + i;
|
|
vectorpalabra.push(*i);
|
|
}
|
|
}
|
|
// Ya tenemos la palabra
|
|
// calcula el 60% de la palabra
|
|
let ocultas = palabra.len() * 6 / 10;
|
|
// los números de caracter que va a ocultar
|
|
let mut vectorocultas: Vec<usize> = Vec::new();
|
|
while vectorocultas.len() != ocultas {
|
|
let num = rand::thread_rng().gen_range(0..palabra.len());
|
|
if vectorocultas.contains(&num) == false {
|
|
vectorocultas.push(num);
|
|
}
|
|
}
|
|
let mut intentos: i32 = 10;
|
|
loop {
|
|
let mut entrada = String::from("");
|
|
println!("Intentos: {}", intentos);
|
|
println!("Palabra: {}", creapalabra(&palabra, &mut vectorocultas));
|
|
println!("Ingrese una letra o la solución: ");
|
|
let lector: io::Stdin = io::stdin();
|
|
lector.read_line(&mut entrada).expect("Fallo lectura");
|
|
let vectorentrada: Vec<char> = entrada.chars().collect();
|
|
if vectorentrada.len() == 2 {
|
|
// Si es una letra
|
|
vectorocultas.sort();
|
|
let clonevectorocultas: Vec<usize> = vectorocultas.clone();
|
|
for i in clonevectorocultas.iter() {
|
|
if vectorpalabra[*i].to_string() == vectorentrada[0].to_string() {
|
|
let index = vectorocultas.iter().position(|x| x == i).unwrap();
|
|
vectorocultas.remove(index);
|
|
break;
|
|
}
|
|
}
|
|
if clonevectorocultas.len() <= vectorocultas.len() {
|
|
intentos -= 1;
|
|
}
|
|
} else {
|
|
// Si es una palabra
|
|
if entrada.replace("\n", "") == palabra {
|
|
println!("Acertaste! La palabra era: {}", palabra);
|
|
break;
|
|
} else {
|
|
intentos -= 1;
|
|
}
|
|
}
|
|
|
|
if vectorocultas.len() == 0 {
|
|
println!("Acertaste! La palabra era: {}", palabra);
|
|
break;
|
|
}
|
|
|
|
if intentos == 0 {
|
|
println!("Perdiste! La palabra era: {}", palabra);
|
|
break;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|