Hola, ¿que te parece esta manera?

int direccionamientoIndexado(char *operando)
{
    int i;
    char *cadena = NULL,c[2];
    char index[4][3] = { "X", "Y", "SP", "PC" };
    cadena = (char *)calloc(2,sizeof(char));
    for(i = 3;operando[i] != ']';i++)
    {
        sprintf(c,"%c",operando[i]);
        strcat(cadena,c);
    }
    printf("%s",cadena);
 
    for( i = 0; i < 4; i++ )
    {
        if( strcmp(cadena, index[i]) == 0 )
            return 1;
    }
       return 0;
}
 

De esa forma el IF se hace mas corto, solo que se agrega una variable de cadena para compararla en cada iteracion con tu variable "cadena", si es igual a una de ellas retorna 1, sino retorna 0.

Volviendo al tema principal, sabiendo que los numeros decimales son infinitos,  donde 0 = -infinito y 1 = +infinito, se puede decir que efectivamente estamos sumando infinitos por asi decirlo.

Yo estoy consciente de lo que dije simplemente, como los compañeros en los comentarios anteriores llegaron a la conclusion que 0.9999 = 1   y 0.0009 es = 0, y dado que en mi comentario principal hice la analogia de colocar a 0 = -infinito   y 1 = +infinito, fue que escribi eso, disculpen si no me estoy dando a entender bien. O quizas los comentarios anteriores estan erroneos cuando dicen que 0.9999 = 1?

entonces 0.9999999999 = 1, y 0.00000000000001 = 0, entonces por analogia deducimos que mas infinito es igual a que valor, y menos infinito es igual a que valor?

Hola debe ser cuando ejecutas strcat(cadena,c); a la primera vez le estas pasando en este caso 'P' que es lo que tiene la variable c en ese momento, pero cuando vuelva a ejecutarse strcat(cadena,c); en ese momento le estas pasando ahora "PC" que es lo que tiene la variable c despues, y por eso se repite 2 veces el primer caracter.

Corrijo: El error esta en que la primera vez se muestra lo que tiene la variable cadena en ese momento que es 'P', luego a la segunda iteracion le pasas a cadena la letra 'C', cuando muestres de nuevo el contenido de cadena se reflejara "PC", y por eso se ve que se repite la 'P' 2 veces, en todo caso la sentencia printf("%s",cadena); deberia ir fuera del ciclo for.

Leyendo por encima sobre Teoria de Conjuntos, George Cantor decia que existen infinitos mas grandes que otros, hasta que me percate de algo ( ojo, no se si esto lo explica él ), imaginense un rango entre 0 y 1, sabiendo que los numeros reales son inifinitos, se podria escribir 0.00000000009 y aun asi no llegaria a 0 al igual que 0.999999999 y no llegariamos a uno, entonces podemos decir que tanto 0 como 1 vienen a representar menos infinito y mas infinito respectivamente.



Espero que tengan alguna opinion respecto a esto =)

Disculpen, no me fije que ya se habia creado un topico parecido, cualquier administrador de esta sección del foro, que cierre este post, y de nuevo disculpen

Buenas noches amigos, abri este topico porque me entró una curiosidad, ustedes veran que el hombre a traves del tiempo con su manipulacion del computador ha logrado diseñar simuladores cada vez mas sorprendentes, y luego de ver el programa llamado "El juego de la vida" y la forma en que funciona me puse a pensar, ¿Seria posible contar con un computador con una cantidad de memoria lo suficientemente grande y diseñar un simulador con leyes parecidas al "Juego de la vida" y que se creasen condiciones ideales para que esos "puntos" (digamos que serian particula, por asi decirlo), y dejar que ese programa evolucione indefinidamente, hasta tal punto que se formen estructuras tan complicadas que simulen vidas primitivas dentro de ese universo, y aun mas adelante seres "inteligentes" , y mas sorprendente aun esos seres pudiesen crear herramientas, tales como una computadora y a su vez ellos hacer simuladores , y su simulaciones sucesivamente? Imagino que la cantidad de memoria seria abismal y contar con un tiempo exageradamente extenso, pero mi punto es ese, si teóricamente se pudiese diseñar algo asi ¿ No creen que nosotros provengamos de algun "Supercomputador" el cual nos simula, y a su vez ese ente que nos programo seria tambien simulado por un "Supercomputador" mas grande, y asi indefinidamente? Entonces yo llego a mi conclusion que cada ente en su universo local tiene un creador en universo superior, todo esto lo pense por mi analogia de como nuestro simulador podria diseñar otros simuladores.

Espero alguien tenga una idea al respecto a esto y me corrija en algo si estoy fallando en mi analisis =)

De C++ si conozco algunas cosas basicas como el cout, cin, new, delete, pero no me he dedicado a practicarla de lleno porque en la universidad nos tienen  trabajando con C y quiero enfocarme en ello, y del system, gracias por el consejo

Acabo de modificar mis funciones de modo que solo uso ahora un puntero que se ubica en el tope

void inicializarPila( Pila *miPila )   // Ya no es resetPila ;)
{
    miPila->tope = NULL;
}
 
int estaVacia( Pila *miPila )
{
    if( miPila->tope == NULL )
        return 1;
    else
        return 0;
}
 
void agregarValor( Pila *miPila, int valor )
{
    Nodo *nodo;
 
    nodo = (Nodo *)malloc(sizeof(Nodo));
    nodo->num = valor;
 
    if( estaVacia( miPila ) == 1 )
        nodo->sig = NULL;
    else
        nodo->sig = miPila->tope;
    miPila->tope = nodo;
}
 
void mostrarPila( Pila *miPila )
{
    Nodo *nodo;
 
    for( nodo = miPila->tope; nodo != NULL; nodo = nodo->sig )
        printf("%d\n", nodo->num);
}
 
int borrarTope( Pila *miPila )
{
    Nodo *nodo;
    int valor;
 
    nodo = miPila->tope;
    valor = nodo->num;
 
    miPila->tope = miPila->tope->sig;
    free(nodo);
 
    return valor;
}
 
void borrarTodo( Pila *miPila )
{
    while( miPila->tope != NULL )
    {
        Nodo *nodo;
        nodo = miPila->tope;
        miPila->tope = miPila->tope->sig;
        free(nodo);
    }
}