Mensajes

Hola que tal, como dice el titulo queria saber si existe alguna libreria que trabajara multihilo en C, solo he encontrado la de <thread> pero es C++, gracias.

Hola, como decidi empezar a practicar C# .NET , de lo poco que he podido aprender aqui dejo un ejercicio resuelto de seleccion aleatoria por si a alguien le interesa:

Código (csharp) [Seleccionar] Expandir


using System;

namespace Prueba1
{
   /*
       Un asesino, cansado de elegir sus victimas de la manera habitual, decide hacer la seleccion de una manera mas especial
       para esto decide seleccionarlas aelatoriamente. Cree un programa que le permita agrupar a sus posibles victimas y asignarles
       un numero y que sea el programa quien decida a quien debe asesinar al momento de que le apetesca para esto debe tener en
       consideracion la siguiente condicion:
           *Una vez seleccionado una victima , el sistema debera omitir esta persona en la proxima busqueda,de manera que nunca salga
           la misma posicion dos veces.
    */
   class Program
   {
       static void Main(string[] args)
       {
           Console.WriteLine("--------------Asesino Serial--------------");
           Console.Write("Ingrese cuantas personas se asesinaran: ");
           int victimas = int.Parse(Console.ReadLine());
           
           Asesino asesino = new Asesino(victimas);

           while (asesino.cantVictimasAsesinada != victimas)
           {
               Console.WriteLine("Persona asesinada: {0}", asesino.asesinar());
           }
           
           Console.ReadLine();
       }
   }

   class Asesino
   {
       
       private int[] victimas;

       // Indica el numero de la victima cayo aleatoriamente
       private int victima;

       // LLevamos la cuenta de cuantas victimas han sido asesinadas
       private int victimasAsesinadas;
       public int cantVictimasAsesinada { get { return victimasAsesinadas; } }

       // Nuestro objeto que trabajara con variables aleatorias
       Random random;
       public Asesino(){ }
       public Asesino(int victimas)
       {

           victimasAsesinadas = 0;
           this.victimas = new int[victimas];
           for (int i = 0; i < this.victimas.Length; i++)
           {
               this.victimas[i] = i + 1;
           }

           random = new Random();
       }

       public int asesinar()
       {
           do
           {
               victima = random.Next(0, victimas.Length);
           } while (victimas[victima] == 0);

           // Establecemos la posicion de la casilla en 0 para indicar que la victima ya fue seleccionada
           victimas[victima] = 0;

           // Aumentamos el numero de victimas asesinadas
           victimasAsesinadas++;

           return victima + 1;
       }
   }
}


Amigo el error esta en que el codigo que te sugeri esta pensado para estar en una funcion, y "digito_romano" practicamente seria un arreglo donde se almacena cada digito que despues se pasaria a un arreglo que es donde estarian todos los numeros transformados, es decir, ejemplo:

Código (cpp) [Seleccionar] Expandir


void funcion( char romano[] )
{
    char digito_romano[4] = { 'I', 'I', 'I', '\0' };
    strcat(romano, digito_romano);
}


Porque como podras ver, cada vez que se ejecutaba el switch, todos los datos se volvian a escribir desde el principio en "digito_romano".

Ahora por la forma en que lo tienes, puedes usar una variable contadora que te lleve la posicion actual de cada casilla de tu arreglo digito_romano, asi donde iria digito_romano[ i ] o digito_romano[0], seria algo del tipo digito_romano[pos_digito++]. Y probablemente algunas instrucciones que estan alli quizas ya no sean necesarias.

Como te dije anteriormente en una nota, el resultado de los numeros romanos te va a salir de atras para adelante, eso lo acomodaras. Otra cosa inicializa tu arreglo "digito_romano" por eso es que arroja esos valores basuras y tu for(j) va hasta <= 2 no <= 3.



Saludo.

Tienes un contador inicializado en 0, y se introduce ejemplo el 376, entonces extraes el 6 en una variable y lo evaluas en el switch, la variable donde dice "cant_decimal" es donde va tu contador, en ese primer caso seria 0, y es correcto porque 6 pertenece a las unidades, y lo guardas en un vector de caracteres, luego haces lo mismo con el 7, en ese caso aumenta tu contador, y evaluas a 7 en la segunda fila que son las decenas otra vez con el switch y lo vas almacenando tambien en el vector de caracteres, y asi sucesivamente.

NOTA: Debes estar pendiente cuando guardes en el vector porque los numeros se almacenaran de atras para adelante.

376 = CCCLXXVI, si lo guardas a lo loco en el vector te saldra VILXXCCC.

No se si me he explicado bien.

Amigo asi mismo como tu dices, tienes 376 va a formar parte de la centena para lo cual le tocaria la fila[2], luego el 7 por ser decena le toca la fila[1] y el 6 le toca la fila[0] por ser unidad, solo necesitas un contador que te lleve la cuenta con cual fila vas a trabajar dependiendo del digito. Extraes el 3 lo evaluas y tienes CCC, ahora te deberia quedar 76, extraes el 7 y te da LXX, te queda ya solamentre el 6 por evaluar que le corresponderia VI.

Empiezas a extraer cada digito del numero ingresado, y lo asocias a cual fila pertenece:

2014: 4 por ser unidad lo evaluas en la primera fila, 1 por ser decena lo evaluas en la segunda fila , etc. Todo eso en caso que lo hagas con la matriz que te mostre.

Luego con un switch haces el procedimiento de evaluacion.

Código (cpp) [Seleccionar] Expandir


switch( numero )
   {
       case 1:
       case 2:
       case 3:
           for( i = 0; i < numero; i++ )
               digito_romano[i] = letras[cant_decimal][0];
       break;
       case 4:
           for( i = 0; i < 2; i++ )
               digito_romano[i] = letras[cant_decimal][i];
       break;
       case 5:
           digito_romano[0] = letras[cant_decimal][1];
           i++;
       break;
       case 6:
       case 7:
       case 8:
           digito_romano[0] = letras[cant_decimal][1];
           for( i = 1; i <= numero - 5; i++ )
               digito_romano[i] = letras[cant_decimal][0];
       break;
       case 9:
           digito_romano[0] = letras[cant_decimal][0];
           digito_romano[1] = letras[cant_decimal][2];
           i = 2;
       break;
   }
    digito_romano[i] = '\0';


A cada digito le harias ese proceso, fijate que la variable "cant_decimal", te indica si el digito es unidad, decena, centena, una vez guardado en "digito_romano", lo concatenas con el "digito_romano" equivalente de los demas digitos, y ya esta.

Fijate que las unidades, las decenas, centenas, etc, en los numeros romanos siguen un mismo patron

*De 1 a 3 se repite esa cantidad de veces el simbolo = I, II, III; X, XX, XXX, etc

*Al 4 se le resta la unidad al numero del medio = IV; XL; CD

*Luego el numero del medio = V, L, D

*Despues del 6 al 8 va el numero central mas las unidades correspondientes = VI, VII, VIII; LX, LXX, LXXX

* Al penultimo numero se le resta la unidad al siguiente aumento de digito = IX, XC, CM

* Por ultimo, el numero de digito adicional = X, C, M

Puedes crear una matriz que en cada fila almacene los caracteres dependiendo de la cantidad de digitos y puedes resolver.

Código (cpp) [Seleccionar] Expandir


char letras[4][3] = { 'I', 'V', 'X',
                     'X', 'L', 'C',
                     'C', 'D', 'M',
                     'M'};


Tienes razon, aunque imagino que para llegar a esas conclusiones debio hacer calculos matematicos con las sombras, por el triangulo recto que formaban estas.

desde la ignorancia incluso podemos afirmar que una línea recta se cruzará siempre con su punto de partida si es suficientemente larga.

Seria complicado visualizar eso, entonces lo mas probable seria imaginarse que la recta atraviesa una especie de portal invisible que el dios de portales de turno habria hecho para que pueda tocar su punto de partida.

Bueno, la tierra es plana, pero tiene 2 caras, si camino y no noto que caigo del plano, supondré que entre las caras de la tierra hay unos rodillos que mueven la superficie de la tierra, los cuales se mueven cuando camino, vaya la rendundancia...

Eso tambien lo pense, que tambien podria darse el caso que existiesen rodillos =)