Categorías: Programación

Ejemplos de programacion 3 – ahorcado

Ejemplos de programacion 3 – ahorcado

En esta ocasion veremos la implentacion del juego del ahorcado en 5 lenguajes de programacion

Este programa permite al usuario intentar adivinar una palabra que el programa ha seleccionado de manera aleatoria de un conjunto predefinido de palabras. El usuario tiene un número limitado de intentos para adivinar la palabra, identificando una letra en cada intento.

C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

void imprimirPalabra(char palabra[], int longitud, 
char letrasAdivinadas[]) {
    for (int i = 0; i < longitud; i++) {
       if (strchr(letrasAdivinadas, palabra[i]) != NULL) {
           printf("%c ", palabra[i]);
       } else {
            printf("_ ");
       }
    }
    printf("\n");
}

int verificarGanador(char palabra[], int longitud, 
char letrasAdivinadas[]) {
    for (int i = 0; i < longitud; i++) {
        if (strchr(letrasAdivinadas, palabra[i]) == NULL) {
            return 0;
        }
    }
    return 1;
}

int main() {
char *palabras[] = {"programacion", "computadora", "juego",
 "lenguaje", "ahorcado"};
int numeroDePalabras = sizeof(palabras) / sizeof(char *);
srand(time(NULL));
char *palabraElegida = palabras[rand() % numeroDePalabras];

int longitud = strlen(palabraElegida);
char letrasAdivinadas[26] = {0}; 
// Almacena todas las letras adivinadas
int intentos = 10;
char adivinanza;
int ganador = 0;

printf("¡Bienvenido al juego del Ahorcado!\n");

while (intentos > 0 && !ganador) {
imprimirPalabra(palabraElegida, longitud, letrasAdivinadas);
printf("Adivina una letra: ");
scanf(" %c", &adivinanza);

if (strchr(letrasAdivinadas, adivinanza) == NULL) {
    strncat(letrasAdivinadas, &adivinanza, 1);
    if (strchr(palabraElegida, adivinanza) == NULL) {
        intentos--;
        printf("¡Incorrecto! Te quedan %d intentos.\n", 
               intentos);
    } else {
        printf("¡Correcto!\n");
    }
} else {
    printf("Ya has adivinado esa letra. ¡Intenta con otra!\n");
}

ganador = verificarGanador(palabraElegida, longitud, 
letrasAdivinadas);
}

if (ganador) {
printf("¡Felicidades! Has adivinado la palabra: %s\n",
       palabraElegida);
} else {
printf("¡Juego terminado! La palabra era: %s\n",
        palabraElegida);
}

return 0;
}

 

Python

import random

def imprimir_palabra(palabra, letras_adivinadas):
    for letra in palabra:
        if letra in letras_adivinadas:
            print(letra, end=" ")
        else:
            print("_", end=" ")
    print()

def verificar_ganador(palabra, letras_adivinadas):
    return all(letra in letras_adivinadas for letra in palabra)

def main():
    palabras = ["programacion", "computadora", "juego", 
    "lenguaje", "ahorcado"]
    palabra_elegida = random.choice(palabras)
    letras_adivinadas = set()
    intentos = 10

    print("¡Bienvenido al juego del Ahorcado!")
    
    while intentos > 0 and 
        not verificar_ganador(palabra_elegida, 
        letras_adivinadas):
        imprimir_palabra(palabra_elegida, letras_adivinadas)
        adivinanza = input("Adivina una letra: ").lower()

        if adivinanza not in letras_adivinadas:
            letras_adivinadas.add(adivinanza)
            if adivinanza not in palabra_elegida:
                intentos -= 1
                print(f"¡Incorrecto! Te quedan {intentos} intentos.")
            else:
                print("¡Correcto!")
        else:
            print("Ya has adivinado esa letra. ¡Intenta con otra!")

    if verificar_ganador(palabra_elegida, letras_adivinadas):
        print(f"¡Felicidades! Has adivinado la palabra: {palabra_elegida}")
    else:
        print(f"¡Juego terminado! La palabra era: {palabra_elegida}")

if __name__ == "__main__":
    main()
Explicación del código:
– **Importación y funciones**: Se utiliza `random` para seleccionar aleatoriamente una palabra de la lista `palabras`.Las funciones `imprimir_palabra` y `verificar_ganador` gestionan la visualización de la palabra y la comprobación de si el jugador ha ganado, respectivamente.- **Flujo principal**: Dentro de la función `main`, se manejan los intentos y se recoge la entrada del usuario para adivinar letras. Se utiliza un conjunto `letras_adivinadas` para almacenar las letras que el usuario ha intentado.- **Control de flujo**: El bucle continúa hasta que se agotan los intentos o el usuario adivina todas las letras de la palabra. Se proporcionan mensajes para guiar y responder al usuario durante el juego.Este código en Python es más conciso que la versión en C, gracias a las características del lenguaje que facilitan el manejo de cadenas y conjuntos, así como la iteración sobre colecciones.

 

Java

import java.util.Scanner;
import java.util.HashSet;
import java.util.Set;

public class Ahorcado {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] palabras = {"programacion", "computadora",
         "juego", "lenguaje", "ahorcado"};
        String palabraElegida = palabras[(int) (Math.random() * 
             palabras.length)];
        Set letrasAdivinadas = new HashSet<>();
        int intentos = 10;

        System.out.println("¡Bienvenido al juego del Ahorcado!");

        while (intentos > 0 && !verificarGanador(palabraElegida, 
              letrasAdivinadas)) {
            imprimirPalabra(palabraElegida, letrasAdivinadas);
            System.out.print("Adivina una letra: ");
            char adivinanza = scanner.nextLine().toLowerCase()
                 .charAt(0);

            if (!letrasAdivinadas.contains(adivinanza)) {
                letrasAdivinadas.add(adivinanza);
                if (palabraElegida.indexOf(adivinanza) == -1) {
                    intentos--;
                    System.out.println("¡Incorrecto! Te quedan " + 
                      intentos + " intentos.");
                } else {
                    System.out.println("¡Correcto!");
                }
            } else {
                System.out.println("Ya has adivinado esa letra. ¡Intenta con otra!");
            }
        }

        if (verificarGanador(palabraElegida, letrasAdivinadas)) {
            System.out.println("¡Felicidades! Has adivinado la palabra: " 
              + palabraElegida);
        } else {
            System.out.println("¡Juego terminado! La palabra era: " 
              + palabraElegida);
        }

        scanner.close();
    }

    private static void imprimirPalabra(String palabra, 
         Set letrasAdivinadas) {
        for (int i = 0; i < palabra.length(); i++) {
            char letra = palabra.charAt(i);
            if (letrasAdivinadas.contains(letra)) {
                System.out.print(letra + " ");
            } else {
                System.out.print("_ ");
            }
        }
        System.out.println();
    }

    private static boolean verificarGanador(String palabra,
        Set letrasAdivinadas) {
        for (int i = 0; i < palabra.length(); i++) {
            if (!letrasAdivinadas.contains(palabra.charAt(i))) {
                return false;
            }
        }
        return true;
    }
}

Explicación del código:

  • Clase y método main: El juego es implementado en la clase Ahorcado con el método main donde se ejecuta el juego.
  • Manejo de entradas: Utiliza un Scanner para leer la entrada del usuario desde la consola.
  • Ciclo del juego: Mantiene un bucle que se repite hasta que el usuario adivine la palabra o se quede sin intentos.
  • Manejo de letras adivinadas: Utiliza un conjunto HashSet para almacenar las letras que el usuario ha adivinado.
  • Verificación de la adivinanza: Comprueba si la letra adivinada está en la palabra o no, y actualiza los intentos restantes y las letras adivinadas.
  • Cierre de recursos: Al final del juego, cierra el Scanner para liberar recursos.

Este código proporciona una base sólida para el juego del ahorcado, con manejo de entradas, control de flujo y lógica de juego, adecuadamente adaptado al entorno y sintaxis de Java.

 

Javascript

const prompt = require('prompt-sync')({sigint: true}); 
// Necesario para Node.js, eliminar si se usa en un navegador

function imprimirPalabra(palabra, letrasAdivinadas) {
    let resultado = '';
    for (const letra of palabra) {
        resultado += letrasAdivinadas.has(letra) ? 
         `${letra} ` : '_ ';
    }
    console.log(resultado);
}

function verificarGanador(palabra, letrasAdivinadas) {
    for (const letra of palabra) {
        if (!letrasAdivinadas.has(letra)) {
            return false;
        }
    }
    return true;
}

function juegoAhorcado() {
    const palabras = ["programacion", "computadora", "juego",
        "lenguaje", "ahorcado"];
    const palabraElegida = palabras[Math.floor(Math.random() 
        * palabras.length)];
    const letrasAdivinadas = new Set();
    let intentos = 10;

    console.log("¡Bienvenido al juego del Ahorcado!");

    while (intentos > 0 && !verificarGanador(palabraElegida, 
        letrasAdivinadas)) {
        imprimirPalabra(palabraElegida, letrasAdivinadas);
        const adivinanza = prompt("Adivina una letra: ")
            .toLowerCase();

        if (!letrasAdivinadas.has(adivinanza)) {
            letrasAdivinadas.add(adivinanza);
            if (!palabraElegida.includes(adivinanza)) {
                intentos--;
                console.log(`¡Incorrecto! Te quedan ${intentos} intentos.`);
            } else {
                console.log("¡Correcto!");
            }
        } else {
            console.log("Ya has adivinado esa letra. ¡Intenta con otra!");
        }
    }

    if (verificarGanador(palabraElegida, letrasAdivinadas)) {
        console.log(`¡Felicidades! Has adivinado la palabra: ${palabraElegida}`);
    } else {
        console.log(`¡Juego terminado! La palabra era: ${palabraElegida}`);
    }
}

juegoAhorcado(); // Llama a la función para iniciar el juego

Explicación del código:

  • Entrada de Usuario: Utiliza el paquete prompt-sync para leer la entrada del usuario desde la línea de comandos en Node.js. Si deseas ejecutar este código en un navegador, puedes adaptar la entrada para usar prompt() que es nativo de los navegadores.
  • Lógica del Juego: Mantiene un conjunto de letrasAdivinadas y verifica la presencia de letras en la palabra seleccionada aleatoriamente de una lista de posibles palabras.
  • Impresión del Estado del Juego: La función imprimirPalabra muestra el estado actual de la palabra, revelando las letras adivinadas y manteniendo ocultas las que no se han adivinado.
  • Ciclo del Juego: Se repite hasta que el usuario se quede sin intentos o adivine la palabra completa.

Este script es un ejemplo simple y funcional del juego del ahorcado en JavaScript, adecuado para comprender el manejo de conjuntos y la interacción básica con el usuario en este lenguaje de programación.

 

GO

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
    "math/rand"
    "time"
)

func imprimirPalabra(palabra string, 
         letrasAdivinadas map[rune]bool) {
    for _, letra := range palabra {
        if letrasAdivinadas[letra] {
            fmt.Printf("%c ", letra)
        } else {
            fmt.Printf("_ ")
        }
    }
    fmt.Println()
}

func verificarGanador(palabra string, 
       letrasAdivinadas map[rune]bool) bool {
    for _, letra := range palabra {
        if !letrasAdivinadas[letra] {
            return false
        }
    }
    return true
}

func main() {
    palabras := []string{"programacion", "computadora", 
        "juego", "lenguaje", "ahorcado"}
    rand.Seed(time.Now().UnixNano())
    palabraElegida := palabras[rand.Intn(len(palabras))]
    letrasAdivinadas := make(map[rune]bool)
    intentos := 10

    scanner := bufio.NewScanner(os.Stdin)
    fmt.Println("¡Bienvenido al juego del Ahorcado!")

    for intentos > 0 && !verificarGanador(palabraElegida, 
         letrasAdivinadas) {
        imprimirPalabra(palabraElegida, letrasAdivinadas)
        fmt.Print("Adivina una letra: ")
        scanner.Scan()
        adivinanza := scanner.Text()
        adivinanza = strings.ToLower(adivinanza)

        if len(adivinanza) == 1 {
            letra := rune(adivinanza[0])
            if !letrasAdivinadas[letra] {
                letrasAdivinadas[letra] = true
                if !strings.ContainsRune(palabraElegida, 
                  letra) {
                    intentos--
                    fmt.Printf("¡Incorrecto! Te quedan %d intentos.\n", intentos)
                } else {
                    fmt.Println("¡Correcto!")
                }
            } else {
                fmt.Println("Ya has adivinado esa letra. ¡Intenta con otra!")
            }
        } else {
            fmt.Println("Por favor, introduce solo una letra.")
        }
    }

    if verificarGanador(palabraElegida, letrasAdivinadas) {
        fmt.Printf("¡Felicidades! Has adivinado la palabra: %s\n", palabraElegida)
    } else {
        fmt.Printf("¡Juego terminado! La palabra era: %s\n", 
          palabraElegida)
    }
}

Explicación del código en Go:

  • Importación de paquetes: Utiliza bufio, fmt, os, strings, math/rand y time para diversas funcionalidades como entrada/salida, manipulación de cadenas y generación de números aleatorios.
  • Funciones Auxiliares: Las funciones imprimirPalabra y verificarGanador manejan la visualización de la palabra actual y la comprobación de si se ha adivinado completamente, respectivamente.
  • Ciclo de Juego: El juego se ejecuta dentro de un bucle que continúa mientras el jugador tiene intentos y no ha adivinado la palabra.
  • Gestión de Entrada: La entrada del usuario se gestiona con un bufio.Scanner, permitiendo la captura de texto desde la consola. Se procesa para asegurar que el usuario solo introduzca una letra a la vez.
  • Control de Letras Adivinadas: Se utiliza un mapa map[rune]bool para rastrear las letras que el usuario ha adivinado, donde true indica que la letra ha sido adivinada.

Este programa es una implementación completa del juego del ahorcado en Go y ofrece una buena base para entender cómo manejar entrada/salida, cadenas, y estructuras de control en este lenguaje.

Mas ejemplos de programacion

Ejemplos de programacion

Ejemplos de programacion 2 – Ordenacion

Ejemplos de programacion 4 – Web Scraper

Ejemplos de programacion 5 – el juego de la vida

 

Ahora puedes descargar el ebook con los ejemplos de programacion de forma gratuita (por tiempo limitado)

Ejemplos de programacion

Una buena forma de introducirte en el mundo de la programacion es seguir ejemplos de codigo y seguir su funcionamiento para tener claro la sintaxis, los distintos tipos de datos, estructuras de control del codigo,etc

En este ebook os damos varios ejemplos de implementacion en varios lenguajes de programacion.

La idea es que veais la sintaxis y como se trabaja en varios lenguajes y tomar ideas en tus futuros proyectos de programacion

Los ejemplos los vamos a dar en 5 lenguajes de programación distintos: C, Python, Java, JavaScript y Go.

Compartir
Publicado por
Enrique Vicente
2 años hace