En varias distros viene el servicio de impresora habilitado en el puerto 631, hasta es más podés entrar con el navegador de internet que tengas a mano para verificarlo...




B#

Bienvenido al foro, recordá que se te dió la orden que el prototipo de la función descifrarPalabra tiene que usar un puntero a una estructura:

#include <stdio.h>
#include <string.h>
 
struct palabra {
	char entrada[100];
	char resultado[100];
};
 
int esNumeroValido(char numeroEnLetra) {
	return (numeroEnLetra >= '0' && numeroEnLetra <= '5');
}
 
void descrifrarPalabra(struct palabra* mensaje) {
	if (!mensaje)
		return;
	int posicionDeLaLetraDelStringResultado = 0, posicionDeLaLetraDelStringEntrada = 0;
	// Continuar desde aca :)
}
 
int main(int argc, char* argv[]) {
	// Inicializar los strings en cero...
	struct palabra mensaje;
	memset(mensaje.entrada, 0, 100);
	memset(mensaje.resultado, 0, 100);
	printf("Descifrar palabra\n");
	printf("Ingrese la palabra cifrada: ");
	scanf("%s", mensaje.entrada);
	descrifrarPalabra(&mensaje);
	printf("Palabra descifrada: %s", mensaje.resultado);
	return 0;
}

B#

Podés utilizar Stable Diffusion en tu propio hardware sin vender tu número de telefono a nadie... Mi avatar de Messi Vegeta fue generado por la variante de openvino.

(stablediffusionopenvino) $ python demo.py --seed 1337 --num-inference-steps 50 --guidance-scale 7 --prompt "An emoji from Guy Fawkes hacking with a laptop, intricate, elegant, highly detailed, digital painting, sharp, focus, by artgerm and greg rutkowski"

14:48 minutos porque mi laptop está perezosa después...

(stablediffusionopenvino) $ python demo.py --seed 1337 --num-inference-steps 50 --guidance-scale 7 --prompt "A man wearing a mask of Guy Fawkes hacking with a laptop, intricate, elegant, highly detailed, digital painting, sharp, focus, by artgerm and greg rutkowski"

15:25 minutos después sigue perezosa...



Mismo prompt y otros 14:51 doritos después, pero con escala de guía a 12 en lugar de 7 para que supuestamente obedezca más...




B#

Bienvenido al foro, en este foro se resuelven y ayudan a las personas en base a lo que muestres lo que tengas ya hecho y se tratará de ayudar en base a tu código.


B#

Quisiera mencionar un par de detalles:

#include <iostream>
#include <ctime>
#include <cstdlib>
#include<stdlib.h>
#include<time.h>

Evitá el uso de las mismas librerías de C++ con C que definan lo mismo...

using namespace std;

Usar el namespace std de manera global tengo entendido que suele ser mala práctica, siempre es mejor considerar escribir la función con su namespace completo, por ejemplo:

std::cout << "Hola" << std::endl

Siempre recordá el uso del nombre de las variables en C++ debe tener notación húngara.

Ahora sí con respecto a tu función:

/* implementa aqui la funcion f_determina_ganador(int p_pc, int p_usuario)
   Esta funcion debe contener la logica para determinar cual de los dos ha ganado.
   Las reglas son: Piedra vence a tijera; Tijera vence a Papel; Papel vence Piedra.
   Devuelve un tipo de datos char que identifica al ganador: "Computadora" o "Jugador".
*/
char f_determina_ganador(int p_pc, int p_usuario)
{
    string ganador;
 
    if (p_pc = 1 && p_usuario = 2)
        ganador = "Jugador";
    else if (p_pc = 1 && p_usuario = 3)
        ganador = "Computadora";
    else if (p_pc = 2 && p_usuario = 1)
        ganador = "Computadora";
    else if (p_pc = 2 && p_usuario = 3)
        ganador = "Jugador";
    else if (p_pc = 3 && p_usuario = 1)
        ganador = "Jugador";
    else if (p_pc = 3 && p_usuario = 2)
        ganador = "Computadora";
    else
        ganador = "Empate";   
}

Recordá que char por si solo es simplemente un número entero con signo de 1 byte y no un string, aparte en cada if estás asignando los valores en lugar de compararlos (un signo igual es asignación, mientras que dos signos iguales es comparación).

enum
{
    WINNER_TYPE_PLAYER,
    WINNER_TYPE_COMPUTER,
    WINNER_TYPE_TIE,
};
 
enum
{
    OPTION_TYPE_STONE = 1,
    OPTION_TYPE_PAPER,
    OPTION_TYPE_SCISSOR,
    OPTION_TYPE_EXIT,
};
 
char f_determina_ganador(int p_pc, int p_usuario)
{
    char cWinner;
 
    if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_COMPUTER;
    else
        cWinner = WINNER_TYPE_TIE;
 
    return cWinner;    
}

Con respecto a la función f_muestra_ganador que te falta se puede usar un simple switch:

/* Implementa aquí la función f_muestra_ganador la misma toma como parámetro un tipo de datos char
   con el identificando el ganador. Debe mostrar la descripción indicando el ganador
*/
void f_muestra_ganador(char p_ganador)
{
    switch(p_ganador)
    {
    	case WINNER_TYPE_PLAYER:
    	    std::cout << "El ganador es: Jugador" << std::endl;
    	    break;
    	case WINNER_TYPE_COMPUTER:
    	    std::cout << "El ganador es: Computer" << std::endl;
    	    break;
    	case WINNER_TYPE_TIE:
    	    std::cout << "El ganador es: Empate" << std::endl;
    	    break;
    }
}

Te dejo el código completo que me funcionó a mi en Linux:

#include <cstdlib>
#include <ctime>
#include <iostream>
#include <random>
#include <string>
 
//Prototipado de las funciones o firma de las funciones
int f_opcion_de_la_pc();
void f_muestra_opciones_menu();
char f_determina_ganador(int pp_pc, int pp_usuario);
void f_muestra_ganador(char p_ganador);
 
enum
{
    WINNER_TYPE_PLAYER,
    WINNER_TYPE_COMPUTER,
    WINNER_TYPE_TIE,
};
 
enum
{
    OPTION_TYPE_STONE = 1,
    OPTION_TYPE_PAPER,
    OPTION_TYPE_SCISSOR,
    OPTION_TYPE_EXIT,
};
 
int main() {
 
    int iUserOption;
    int iPCOption;
 
    std::cout << " \t Bienvenidos al juego Piedra, papel y Tijera" << std::endl << std::endl;
    f_muestra_opciones_menu();
 
    /*  Captura la opcion seleccionada por el usuario.
    Valida que la opcion sea valida. Si es una entre 1 y 3, llama a la funcion
    f_iPCOption() captura el resultado y pasalo como parametro junto con la
    opcion tomada por el usuario a la funcion f_determina_ganador.
    Si el usuario elige la opcion 4, termina el programa.
*/
 
    std::cin >> iUserOption;
    if (iUserOption == OPTION_TYPE_EXIT)
        return 0;
 
    while (iUserOption < OPTION_TYPE_STONE || iUserOption > OPTION_TYPE_EXIT)
    {
        std::cout << "Esa opcion no esta disponible, intentelo otra vez." << std::endl;
 
        f_muestra_opciones_menu();
        std::cin >> iUserOption;
        if (iUserOption == OPTION_TYPE_EXIT)
            return 0;
    }
 
    iPCOption = f_opcion_de_la_pc();
 
    /* En la función f_muestra_ganador captura ganador que devuelve
       la funcion f_determina_ganador(int p_pc, int p_usuario)
       Muestra el mensaje: "El ganador es: " + ganador.
       Como un plus, pregunta si quiere seguir jugando y continua el juego
    */
    f_muestra_ganador(f_determina_ganador(iPCOption, iUserOption));
 
    return 0;
}
 
//Definicion de las funciones
void f_muestra_opciones_menu() {
    std::cout << "\t 1 - Piedra" << std::endl;
    std::cout << "\t 2 - Papel" << std::endl;
    std::cout << "\t 3 - Tijera" << std::endl;
    std::cout << "\t 4 - Salir" << std::endl;
 
    std::cout << "Elige tu opcion: ";
}
 
//Implementar aqui la funcion f_opcion_de_la_pc()
//Este funcion generara un numero aleatorio entre 1 y 3 y lo devolvera
int f_opcion_de_la_pc()
{
    std::default_random_engine generator;
    std::uniform_int_distribution<int> distribution(1,3);
 
    return distribution(generator);
}
 
/* implementa aqui la funcion f_determina_ganador(int p_pc, int p_usuario)
   Esta funcion debe contener la logica para determinar cual de los dos ha ganado.
   Las reglas son: Piedra vence a tijera; Tijera vence a Papel; Papel vence Piedra.
   Devuelve un tipo de datos char que identifica al ganador: "Computadora" o "Jugador".
*/
char f_determina_ganador(int p_pc, int p_usuario)
{
    char cWinner;
 
    if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_COMPUTER;
    else
        cWinner = WINNER_TYPE_TIE;
 
    return cWinner;    
}
 
 
/* Implementa aquí la función f_muestra_ganador la misma toma como parámetro un tipo de datos char
   con el identificando el ganador. Debe mostrar la descripción indicando el ganador
*/
void f_muestra_ganador(char p_ganador)
{
    switch(p_ganador)
    {
    	case WINNER_TYPE_PLAYER:
    	    std::cout << "El ganador es: Jugador" << std::endl;
    	    break;
    	case WINNER_TYPE_COMPUTER:
    	    std::cout << "El ganador es: Computer" << std::endl;
    	    break;
    	case WINNER_TYPE_TIE:
    	    std::cout << "El ganador es: Empate" << std::endl;
    	    break;
    }
}

B#

Habría que ver cuál es el backend del juego, si es Mono o IL2CPP y reversear el juego tomaría algo de tiempo para ver como funciona internamente.


B#

En C puro no tengo idea, pero sé que en el estandar de C++11 se agregó la posibilidad de utilizar funciones lambda.

https://learn.microsoft.com/en-us/cpp/cpp/lambda-expressions-in-cpp


B#

Hola, en el servidor de descargas del foro hay un par de ISOs de Windows, incluyendo una de Windows 7 de 64 bits.


B#

También podés especificarle al compilador GCC que compile en sintáxis tipo intel...

https://stackoverflow.com/questions/199966/how-do-you-use-gcc-to-generate-assembly-code-in-intel-syntax


B#

Al menos a mi me funciono lo siguiente:

shellcode.asm:

.section .text
.globl _start;
_start:
xor %eax, %eax
mov $1337,%eax
ret

Compilar a elf (opcional el --32 para 32 bits)

as --32 shellcode.asm -o shellcode.elf

Mirar el contenido del assembler:

objdump -d shellcode.elf

Exportar el contenido a secuencia de bytes:

objcopy -v -O binary shellcode.elf shellcode.bin

Comparar el contenido de los bytes con los bytes ensamblados:

xxd shellcode.bin

B#