Les escribo lo que me acuerdo de lo que tomaron hoy así queda asentado:
TEÓRICO
T1. Explicar en forma clara y concisa en que consisten los procesos de compilación y linkeado.
T2. Te daban dos números, uno en base octal y otro en decimal.. y tenías que pasarlos a binario y hacer no sé qué cuenta de complemento 2 (como verán este no lo hice, pero lo importante es que tomaron sistemas de numeración).
PRACTICO :
Te explicaban un sistema para realizar operaciones matemáticas que funcionaba de la siguiente manera:
Los números de una determinada operación van todos a la izquierda (operando) y el operador (+-*%) a la derecha.
Algunos ejemplos serian:
Original: 2+2
Codificado: 22+
Original: 2*7*8
Codificado: 278*
Etc.
La cuestión es que tenías que hacer una función llamada calculadora que tenía el siguiente prototipo:
int Calculadora (nodo **pila, char *trama, double *resultado)
Pila: Te daban la dirección del primer elemento de una pila, pasado por referencia.
La idea era usarlo como "memoria" mientras vas realizando las operaciones.
Trama: En la trama venia cargado un mensaje codificado de la forma explicada atrás, ej.
987+5645*56
Resultado: Bueno, acá obviamente cargabas el resultado de toda la operación.
Procedimiento:
La idea es que con el uso de la función de cola "push" (la cual tenías que desarrollar como parte del ejercicio) fueras metiendo los números que te llegaban en la trama, hasta que llegabas a un char que representaba una operación.
En ese punto resolvías esa operación para todos los números que habías llegado a almacenar en la cola, y guardabas el resultado en la cola.
Lo ideal era hacer la operación de a 2 operandos a la vez (que los sacabas de la cola con la funcion "pop"), reemplazar el resultado y volver a hacerla con 2 operandos más (el resultado anterior + uno nuevo).
Así hasta que en la cola te quedara 1 solo resultado final para esa operación.
Luego de eso, seguías leyendo la trama y "pusheando" los números en la cola hasta la siguiente operación, realizabas la operación, etc.
Así sucesivamente, hasta que en algún momento llegabas al final de string.
Cargabas el valor en la variable resultado pasada por referencia, y te ibas a tu casa
Eso fue todo, si bien el practico parece jodido al explicarlo fue bastante fácil.
Una vez que entendías lo que pedía el enunciado, bastaba saber manejar colas (y saberse las funciones push y pop), y saber hacer casteos y el pasaje de char a números.
Estaba al pedo y en un rato lo hice, este es mi aporte del mes (?
ACLARACION 1: Los numeros solo eran de una cifra (un char por numero) y las operaciones eran las 4 basicas (+-*/)
ACLARACION 2: Si bien la funcion aparece con el nombre de pila, para que todo fucione bien se debe trabajar con una cola.
Si se fijan la funcion "push" va insertando nodos al final, y "pop" retira los nodos del principio..
Si no se trabajara con una cola aparecerian errores en las operaciones no conmutativas.
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 30
typedef struct pNodo {
struct pNodo *sig;
double valor;
} pnodo;
void imprimir_pila(pnodo *pila);
int pop (pnodo **pila, double *popval);
int push (pnodo **pila, double pushval);
int Calculadora (pnodo **pila, char *trama, double *resultado);
int main () {
int n=0;
pnodo *pila=NULL;
char trama[MAX_SIZE]={'\0'};
double resultado;
printf ("\n** CALCULADORA ** \nIngrese la trama que desea procesar:\n");
fgets (trama,MAX_SIZE,stdin);
printf ("\nTrama ingresada: %s", trama);
if ((Calculadora ( &pila , trama , &resultado ))==1)
printf ("\nResultado: %f\n\n", resultado);
else printf ("\nError en el formato de la trama ingresada\n");
return 0;
}
int Calculadora (pnodo **pila, char *trama, double *resultado) {
int n=0,validacion=0;
double num1=0, num2=0;
while (trama[n]!='\0') {
/** CASO 1: IR AGREGANDO LOS NUMEROS DE 1 CIFRA EN LA COLA */
if ( (trama[n]>='0') && (trama[n]<='9') ) {
push (pila , (double)trama[n]-'0'); /** Mientras recibo numeros los voy agregando a la pila */
}
/** CASO 2: CUALQUIER COSA QUE NO SEA UN NUMERO, SI ES UNA OPERACION SE EFECTUA CON TODOS LOS NUMEROS CARGADOS EN LA COLA */
else {
if (!(*pila))
return 0; /** Validacion: Trama sin numeros */
while ((*pila)->sig!=NULL) { /** Quedarse en el while hasta que quede solo un elemento en la pila */
validacion=pop (pila,&num1);
validacion+=pop (pila,&num2);
if (validacion<2) {
return 0; /** Validacion: Ocurrio algun error al extraer los valores de la pila */
}
switch (trama[n]){
case '+':
push ( pila , num1+num2); /** Realizo la operacion indicada con 2 numeros */
break; /** y agrego el resultado a la pila */
case '-':
push ( pila , num1-num2);
break;
case '*':
push ( pila , num1*num2);
break;
case '/':
push ( pila , num1/num2);
break;
default:
return 0; /** Validacion: Caracter de operacion no identificado */
} //FIN DEL SWITCH//
}
}
n++; /** Incremento la variable que uso para recorrer la trama */
}
pop (pila, resultado); /** Cargo el ultimo elemento de la pila en la variable 'resultado' pasada por referencia */
return 1;
}
/*********** FUNCIONES DE PILA ***********/
int pop (pnodo **pila, double *popval) {
pnodo *temp;
if (pila) {
temp = *pila; /** Almaceno la posicion de me moria para liberarla luego */
*popval = (*pila)->valor; /** Guardo el dato */
*pila=(*pila)->sig; /** Corro el inicio de la pila al siguiente nodo */
free(temp); /** Libero la memoria del nodo */
return 1;
}
else
return 0; /** Validacion: Pila vacia */
}
int push (pnodo **pila, double pushval) {
pnodo *nuevo, *act;
nuevo = (pnodo*) malloc (sizeof(pnodo)); /** Reservo memoria para el nodo */
//printf ("\n%f",pushval);
if (!nuevo) {
printf ("\nNo hay memoria disponible");
return 0; /** Validacion: Error */
}
nuevo->valor=pushval; /** Cargo el dato en el nodo */
nuevo->sig=NULL;
act = *pila;
if (!(*pila)) {
*pila=nuevo;
return 1;
}
else {
while (act->sig!=NULL)
act=act->sig;
act->sig=nuevo;
return 1;
}
}
Asi como esta derecho al gcc, y obviamente puede fallar.. Si encuentran algun error me avisan
NOTA 1: No lo prueben con el compilador del foro porque el programa utiliza memoria dinamica y no va a funcar.
NOTA 2: Si quieren copiar el codigo directo de aca pueden hacer click en "citar" y lo copian de ahi.
![[-]](images/collapse.gif)
JulianD recibio 4 Gracias por este post
.gif "=)")
