Hola, estoy probando el editor de texto Sublime Text 2 para hacer codigo de C++, aunque muchos diran que puedo usar cualquier IDE para facilitarme todo el proceso, es solo que quiero probar otras opciones =)... Ok, la cuestion es esta, me estuve guiando sobre como hacer el archivo .sublime-build, pero no se muy bien como pasarle parametros de manera optima, es decir, esto es lo que tengo:

{
	"cmd": ["g++ -Wall ${file_name} EmpleadoPorComision.cpp -o ${file_base_name} && ${file_base_name}.exe"],
  	"working_dir": "${file_path}",
  	"shell": true
}
 

Fijense como la cadena "EmpleadoPorComision.cpp" esta de manera que no parece optima en comparacion con ${file_name}, no se si exista algun parametro que se le pueda pasar para que reconozca todos los archivos .cpp de una carpeta especifica.

Otra duda, ¿Es factible tener un .sublime-build por cada proyecto que haga? de ser asi, ¿Puedo guardarlo en la misma carpeta del proyecto, o debo guardarlas siempre en la carpeta por defecto donde ella almacena todos los archivos .sublime-build?

A pesar que tengo mas dudas sobre el funcionamiento del editor, esperare que puedan ayudarme con estas que tengo por los momentos =).

Gracias.

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:

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;
        }
    }
}
 

Hola, no se si el titulo de este post sea el mas correcto, disculpen por eso xD. La cuestion es, investigando en wikipedia me tope con lo que se llama la Banda de Möbius ( http://es.wikipedia.org/wiki/Banda_de_M%C3%B6bius ) y me llamo la atencion ese fenomeno, luego recordando un post que hice hace mas de un mes tambien explicaron algo sobre eso, y se me ocurrio esto:

Si nuestro planeta estuviese rodeado por un anillo de tierra, y ud se encuentra en la época donde se pensaba que la tierra era plana, y para colmo fuese una persona ignorante de conocimiento sobre geometria y matematicas, camina en linea recta( percatandose que no se desvia usando por ejemplo una cuerda), al cabo de muchos dias, evidentemente llegarian al punto desde donde empezaron.

¿ Cómo explicaria ud lo que acaba de ocurrir, siendo una persona ignorante, que no conoce nada de matematicas ni geometria, si siempre camino en linea recta, y su cuerda evidentemente le confirma que asi lo hizo ?

Aqui dejo una imagen sobre lo que me refiero.

Me gustaria leer sus respuestas.

Saludos.

Cuando vemos una flor roja, lo que de verdad sucede es que ella absorbe todos los colores del espectro visible de luz menos el color en que la estamos observando sino que la refleja ( rebota ), por lo tanto al no ser este color parte de ella, lo mas lógico seria decir " Esa flor es de todos los colores menos roja "

Hola, a pesar de haber leido algo sobre infinito hay algo que no me cuadra, sabiendo que infinito es un valor excesivamente grande ( inimaginable ) y la expresion "infinito menos infinito" es una indeterminacion, y "X" puede ser una variable que puede tomar cualquier valor excesivamente grande y cuando hacemos "X - X = 0".

En el momento que tenemos a X, se podria decir que tiene un valor indefinido, mientras que no le demos un valor, por lo tanto de alguna manera debe poseer la naturaleza de infinito ( de indeterminacion ), pero si se puede aplicar "X - X", pero no "infinito menos infinito".

Quien tenga una explicacion a eso le agradeceria, aunque son nociones de matematicas que ya deberia tener claro, me confunde esa eculiaridad de X manteniendose sin valor definido si se puede resolver esa operacion mientras que infinito siendo tambien indefinido no se puede.

Hola que tal, hoy se me fue la luz y cuando trate de entrar de nuevo a navegar no podia acceder a la mayoria de las paginas web, en estos momentos uso Tor el cual es el unico que me permite poder acceder a todas las paginas ,ni chrome, ni firefox, ni internet explorer me permiten acceder a ellas, no se si sea que el router se desconfiguro, aunque ya lo configure como de fabrica y en realidad no se a que se deba esto =/ agradeceria mucho que me ayuden.

Hola, aqui les traigo un problema que estoy haciendo sobre, dado un laberinto de 12 x 12 usar la regla de la mano derecha para conseguir la salida del laberinto e indicar si hay salida o no, como tal el programa corre y si encuentra la salida, pero no se si lo esta haciendo de la mejor manera, he aqui el codigo:

#include <stdio.h>
#include <stdlib.h>     // Para usar funcion de limpiar pantalla
#include <windows.h>    // Para usar funcion de hacer pausa
#define TAM_FIL 12
#define TAM_COL 12
 
using namespace std;
 
typedef struct
{
    int estaEnInicio, estaEnFinal; //----- Para saber cuantas veces nuestro objeto ha estado en el inicio y si esta en el final
    char simbolo;
    int pos_x; //------------------------- Coordenada del objeto en X
    int pos_y; //------------------------- Coordenada del objeto en Y
}Objeto;
 
typedef struct
{
    // ----------------------------------- Simplemente para saber las coordenadas de los puntos X e Y de inicio y fin del laberinto ------------------------------------
 
    int ini_fil;
    int ini_col;
    int fin_fil;
    int fin_col;
}InformacionMapa;
 
void mostrarEstadoMapa( char laberinto[][TAM_COL] );
void recorrerLaberinto( char laberinto[][TAM_COL], InformacionMapa *punto, Objeto *obj );
 
int main( int argc, char* args[] )
{
 
    int cont_fil, cont_col;
 
    InformacionMapa mapa;
    mapa.ini_fil = 2;
    mapa.ini_col = 0;
    mapa.fin_fil = 4;
    mapa.fin_col = 11;
 
    Objeto obj;
    obj.simbolo = 'X';
    obj.estaEnInicio = 0;
    obj.estaEnFinal = 0;
    obj.pos_x = 2;
    obj.pos_y = 0;
 
    char laberinto[TAM_FIL][TAM_COL] = { '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
                                         '#', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', ' ', ' ', '#',
                                         ' ', ' ', '#', ' ', '#', ' ', '#', '#', '#', '#', ' ', '#',
                                         '#', '#', '#', ' ', '#', ' ', ' ', ' ', ' ', '#', ' ', '#',
                                         '#', ' ', ' ', ' ', ' ', '#', '#', '#', ' ', ' ', ' ', ' ',
                                         '#', '#', '#', '#', ' ', '#', ' ', '#', ' ', '#', ' ', '#',
                                         '#', ' ', ' ', '#', ' ', '#', ' ', '#', ' ', '#', ' ', '#',
                                         '#', '#', ' ', '#', ' ', '#', ' ', '#', ' ', '#', ' ', '#',
                                         '#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#', ' ', '#',
                                         '#', '#', '#', '#', '#', '#', ' ', '#', '#', '#', ' ', '#',
                                         '#', ' ', ' ', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', '#',
                                         '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'
                                       };
 
    recorrerLaberinto( laberinto, &mapa, &obj );
 
    getchar();
	return 0;
}
 
void mostrarEstadoMapa( char laberinto[][TAM_COL] )
{
    int cont_fil, cont_col;
 
    system("cls");
    for( cont_fil = 0; cont_fil < TAM_FIL; cont_fil++ )
    {
        for( cont_col = 0; cont_col < TAM_COL; cont_col++ )
        {
            printf("%c", laberinto[cont_fil][cont_col]);
            printf("  ");
        }
 
        printf("\n\n");
    }
    Sleep(500);
}
 
void recorrerLaberinto( char laberinto[][TAM_COL], InformacionMapa *mapa, Objeto *obj )
{
 
    if( obj->pos_x == mapa->ini_fil && obj->pos_y == mapa->ini_col )
        obj->estaEnInicio++;
    else if( obj->pos_x == mapa->fin_fil && obj->pos_y == mapa->fin_col )
        obj->estaEnFinal++;
 
    while( laberinto[4][11] != obj->simbolo && obj->estaEnInicio == 1 && !obj->estaEnFinal )
    {
        laberinto[obj->pos_x][obj->pos_y] = obj->simbolo;
 
        mostrarEstadoMapa( laberinto );
 
        if( laberinto[obj->pos_x][obj->pos_y + 1] != '#' && laberinto[obj->pos_x][obj->pos_y + 1] != obj->simbolo )
        {
            obj->pos_y++;
            recorrerLaberinto( laberinto, mapa, obj );
        }
        else if( laberinto[obj->pos_x + 1][obj->pos_y] != '#' && laberinto[obj->pos_x + 1][obj->pos_y] != obj->simbolo )
        {
            obj->pos_x++;
            recorrerLaberinto( laberinto, mapa, obj );
        }
        else if( laberinto[obj->pos_x - 1][obj->pos_y] != '#' && laberinto[obj->pos_x - 1][obj->pos_y] != obj->simbolo )
        {
            obj->pos_x--;
            recorrerLaberinto( laberinto, mapa, obj );
        }
        else if( laberinto[obj->pos_x][obj->pos_y - 1] != '#' && laberinto[obj->pos_x][obj->pos_y - 1] != obj->simbolo )
        {
            obj->pos_y--;
            recorrerLaberinto( laberinto, mapa, obj );
        }
        else if( laberinto[obj->pos_x][obj->pos_y - 1] != '#' )
        {
            obj->pos_y--;
            recorrerLaberinto( laberinto, mapa, obj );
        }
        else if( laberinto[obj->pos_x - 1][obj->pos_y] != '#' )
        {
            obj->pos_x--;
            recorrerLaberinto( laberinto, mapa, obj );
        }
        else if( laberinto[obj->pos_x + 1][obj->pos_y] != '#' )
        {
            obj->pos_x++;
            recorrerLaberinto( laberinto, mapa, obj );
        }
        else if( laberinto[obj->pos_x][obj->pos_y + 1] != '#' )
        {
            obj->pos_y++;
            recorrerLaberinto( laberinto, mapa, obj );
        }
 
    }
 
    if( obj->estaEnInicio > 1 )
        printf("\n\n\nNo hay salida en este laberinto.");
    if( obj->estaEnFinal )
        printf("\n\n\nFinal del laberinto encontrado");
}
 

Disculpen el exceso de if-else xD, debo mejorar esa parte.

Nota: Aun no lo he probado con un laberinto distinto con punto de partida y fin distintos.

---

He probado quitandole la salida y alli si que no hace la busqueda por todas las posibles rutas del laberinto, aunque se que esto seria un problema de backtracking, yo no soy muy experto cuando se trata de recursividad jeje

En este link http://www.stroustrup.com/bs_faq2.html exactamente como es el titulo del post, él explica que este ejemplo:

v[ i ] = i++;

Deberia evitarse ( segun lei ) porque el resultado es indefinido. Por como tengo entendido, como el operador esta en post-incremento, él asignaria el valor de "i" a la variable y luego se incrementa el valor de "i", ¿ O fue que entendi mal lo que quiso explicar el señor Stroustrup?
 

Hola, he estado practicando lo que ofrece SDL 2, y queria saber si alguno estaba interesado en aprender esta libreria, no soy experto en ella como tal, pero trato de aprender lo mas que ofrece, si alguno desea aprender me puede enviar un mensaje privado para pasarle mi correo.