Mensajes

Hola.

Este es mi primer acercamiento al for asi que espero estar lo mas apegado a las normas del mismo (las cuales les di una leida breve a publicar esto), asi que inicio presentandome, soy estudiante del 1er semestre de ingenieria electrico electronica en mexico, y llevo como una de mis asignaturas programacion, nos dejaron un proyecto final el cual requiere que hagamos un programa en "C" el cual permita balancear una ecuacion quimica por medio de metodo algebraico y estoy atorado en una parte crucial del programa.

Inicialmente el metodo algebraico requiere que se le denomine a cada compuesto con una letra del abecedario, inicando de izquierda a derecha desde la "a", luego la "b" y asi sucesivamente, posterior a ello se tiene plantean ecuaciones igualando el numero de atomos en los reactivos y en los productos, se toma en cuenta la flecha de direccion de la ecuacion como el signo igual y el numero de ecuaciones sera igual al numero de elementos presente en la ecuacion sin repetir, quedando de la siguiente manera:

posteriormente se asigna un valor aleatorio a la variable que se repitamas (en este caso "a") pero de momento eso es secundario, realice un codigo que permite recopilar los datos de cada compuesto uno por uno, lo utilizare como funcion mas adelante, pero de momento lo que requiero es que compare los datos de los reactivos (que se guardan en arreglos de tipo struct) y se van a guardar en otro arreglo de tipo struct aunque no he logrado que se guarden siquiera los nombres de cada elemento sin repetirse.

los elementos que se registran primero se guandan en reactivos que como ya mencione es un arreglo de tipo struct, dentro de este se guarda cada elemento y la cantidad de el que haya
siendo el nombre del primer elemento del ejemplo
reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento=Na
y la cantidad de atomos
reactivos[indiceReactivos].elementos[indiceElemento].atomos=1
dejo el codigo a continuacon, procure comentarlo para que sea mas facil etender la maraña de codigo que hice  

Código [Seleccionar] Expandir

#include<stdio.h>
#include<string.h>
#include<ctype.h>


struct datosElemento
{
   char nombreElemento[3];
   int atomos;
};

struct reactivo
{
   char nombreReactivo[20];
   struct datosElemento elementos[120];
   char variableCoeficiente;
};

struct nombreEcuacones
{
   char ecuacion[3];
};




int main()
{
   struct reactivo reactivo1;
   struct reactivo reactivos[20];
   int ingresarMasReactivos=1, cantidadDeReactivos=0, indiceReactivos=0;

   int totalElementos=0, indiceEcuacion=0, indiceLector=0;
   int iguales=0; //aqui se tomara 1 como distintos y 2 como iguales

   struct nombreEcuacones ecuaciones[30];

   int longitudCadenaCompuesto;
   int indice=0, indiceElemento=-1, indiceNombreElemento=0;
   int cantidadElementosQuimicos=0;
   int banderaParentesis=0, cantidadElementosParentesis=0, multiplicadorAtomos=1, indiceTemporal=0;

   while(ingresarMasReactivos==1)
   {
       printf("\nIngresa un reactivo: ");
       gets(reactivos[cantidadDeReactivos].nombreReactivo);
       fflush(stdin);
       reactivos[cantidadDeReactivos].variableCoeficiente='a'+cantidadDeReactivos;//desde aqui asigno la letra solamante como referencia propia ;)
       cantidadDeReactivos++;
       printf("\nDesea ingresar otro reactivo? ( 1-Si, 2-No ) ");
       scanf("%i", &ingresarMasReactivos);
       fflush(stdin);

   }


   for(indiceReactivos=0; indiceReactivos<cantidadDeReactivos; indiceReactivos++)
   {
       indiceElemento=-1;
       longitudCadenaCompuesto=strlen(reactivos[indiceReactivos].nombreReactivo);

       for(indice=0; indice< longitudCadenaCompuesto; indice++)
       {
           if(isupper(reactivos[indiceReactivos].nombreReactivo[indice]))
           {
               indiceElemento++;
               reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento[0]=reactivos[indiceReactivos].nombreReactivo[indice];
               reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento[1]='\0';
               reactivos[indiceReactivos].elementos[indiceElemento].atomos=1; // Cada que se lee una mayuscula se aprovecha para inicializar la cantidad de atomos
                                                   // de ese elemento en una unidad

               //printf("%c\n",reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento[indiceNombreElemento]);

               if(banderaParentesis==1)    //banderaParentesis adquiere un valor de 1 cuando se lee un caracter '('
               {                           //Cada que se lee un nuevo reactivo (letra mayúscula)
                   cantidadElementosParentesis++;  //y la bandera parentesis esta activa se incrementa un contador
               }                                  //de la cantidad de elementos quimicos entre parentesis
           }
           if(islower(reactivos[indiceReactivos].nombreReactivo[indice]))
           {
               reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento[1]=reactivos[indiceReactivos].nombreReactivo[indice];
               reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento[2]='\0';
               //printf("%c\n",reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento[1]);
           }
           if(isdigit(reactivos[indiceReactivos].nombreReactivo[indice]))
           {
               reactivos[indiceReactivos].elementos[indiceElemento].atomos=reactivos[indiceReactivos].nombreReactivo[indice]-48;
               //printf("%i\n",reactivos[indiceReactivos].elementos[indiceElemento].atomos);
           }
           if(reactivos[indiceReactivos].nombreReactivo[indice]==40)   //Si se lee un caracter '('
           {
               banderaParentesis=1;    //banderaParentesis adquiere un valor de 1
           }
           if(reactivos[indiceReactivos].nombreReactivo[indice]==41)   ////Si se lee un caracter ')'
           {
               indice++;   //se incrementa indice para apuntar al elemento siguiente al parentesis que cierra
               multiplicadorAtomos=reactivos[indiceReactivos].nombreReactivo[indice]-48;   //multiplicador es igual al numero que sigue al perentesis
               for(indiceTemporal=0; indiceTemporal<cantidadElementosParentesis; indiceTemporal++)
               {   //Este ciclo recorre desde el elemento quimico actual hacia atras para cambiar los valores de atomos
                   //de los elementos quimicos que estaban entre parentesis
                   reactivos[indiceReactivos].elementos[indiceElemento-indiceTemporal].atomos=reactivos[indiceReactivos].elementos[indiceElemento-indiceTemporal].atomos*multiplicadorAtomos;
               }
               banderaParentesis=0;    //Despues de leer el ')' se reinician los valores de bandera
               cantidadElementosParentesis=0;  //y el cantidadElementosParentesis por si después hay otros
                                               //parentesis
           }


       }
       cantidadElementosQuimicos=indiceElemento;

       totalElementos=(totalElementos+(indiceElemento+1));//esta parte de total elementos la utilizo mas adelante en la "zona de igualacion"

       //aqui imprime los reactivos que se escribieron desglosados elemento por elemento y cantidad de atmos por cada elemento
       printf("\n***********\n");
       printf("Los elementos quimicos leidos son:\n");
       printf("el coeficiente del reactivo es: %c\n", reactivos[indiceReactivos].variableCoeficiente);
       for(indiceElemento=0; indiceElemento <= cantidadElementosQuimicos; indiceElemento++)
       {
           printf("Nombre del elemento: %s\n", reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento);
           printf("Cantidad de atomos: %i\n", reactivos[indiceReactivos].elementos[indiceElemento].atomos);
           printf("\n");
       }
       printf("\n=============================================================\n");
       printf("\n=============================================================\n");

   }
   //hasta aqui funciona bien el codigo



   //en esta zona intnto igualar lascadenas de casda elemento con los datos de los reactivos con las ecuaciones
   indiceReactivos=0;
   for(indiceReactivos=0; indiceReactivos<cantidadDeReactivos; indiceReactivos++)//este primer ciclo for recorre las filas del arreglo "reactivos"
   {
       for(indiceElemento=0; indiceElemento <= cantidadElementosQuimicos; indiceElemento++)//este segundo ciclo for recorre elemento por elemento
           {

               for(indiceEcuacion=0; indiceEcuacion<totalElementos; indiceEcuacion++)//este ciclo mas interno recorre el arreglo en busca de coincidencias
               {
                   iguales==0;//los tuve que igualar a 0 por que me daba valores raros despues
                   if(strcmp((reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento),ecuaciones[indiceEcuacion].ecuacion)!=0)//compara si son iguales o no
                       iguales=1;
                   else
                   {
                       iguales=2;
                   }

                   switch(iguales)//agregue el switchase para hacer esto mas eficiente, creo
                       {
                           case 1:
                               {
                                   strcpy(ecuaciones[indiceLector].ecuacion , reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento);//aqui en apariencia iguala, pero pàsa algo raro
                                   indiceLector++;
                                   indiceEcuacion==totalElementos;
                                   break;
                               }
                           case 2:
                               {
                                   printf("Ya se escribio: %s\n", reactivos[indiceReactivos].elementos[indiceElemento].nombreElemento);
                                   indiceEcuacion==totalElementos;
                                   break;
                               }
                           default:
                               {
                                   printf("KHE???");
                                   break;
                               }
                       }
               }
           }

   }
   printf("El ultimo valor de iguales fue: %i", iguales);
   printf("\n*************************************************************\n");
   for(indiceEcuacion=0; indiceEcuacion<9; indiceEcuacion++)//esto imprime 8posibles valores de las ecuaiones, aqui es donde me di cuenta de que algo no hice bien
       {
           printf("Elemento %i: %s\n", indiceEcuacion, ecuaciones[indiceEcuacion].ecuacion);
       }
   printf("\n*************************************************************\n");



   return 25;
}



Como pueden ver no soy muy diestro al programar pero hago lo que puedo, como ven en donde intento guardar es en
ecuaciones[indiceEcuacion].ecuacion
pero no logro hacerlo sin que se repita, cualquier comentario o sugerencia sera bienvenida.

de antemanto agradezco la ayuda y si algo es confuso diganme por que llevo 2 dias atorado en esta parte y ya hasta veo codigo en el cereal