SSL
Muchnik
6 EJERCICIOS RESUELTOS (Agradezco la colaboración de la Prof. Ana Díaz Bott)
CAP. 1: INTRODUCCIÓN A AFs Y APLICACIONES APLICACIONES * Ejercicio 1 * (pág.7) (a) SI (b) NO
* Ejercicio 2 * (pág.7) (a) SI (b) SI
* Ejercicio 3 * (pág.10) (a)
T 01+ 2 3+
a 1 3 -
b 2 -
(b) palabra aba: 0- => a => 1 => b => 2 => a => 3+ RECONOCE palabra a: 0- => a => 1+ RECONOCE cadena abab: 0- => a => 1 => => b => 2 => a => 3 => b => => ?? RECHAZA (no puede continuar) cadena baa: 0- => b => ?? RECHAZA (no puede continuar) cadena vacía: 0- => ε => ?? RECHAZA (el estado inicial no es final) cadena ab: 0- => a => 1 => b => 2 RECHAZA (el estado 2 no es final)
* Ejercicio 4 * (pág.11) ER = 01 + 10
* Ejercicio 5 * (pág.13) (a)
T a 0- 0 1 2 2+ -
b 1 1 -
(b) palabra ba: 0- => b => 1 => a => 2+ RECONOCE palabra abba: 0- => a => 0 => b => 1 => b => => 1 => a => 2+ RECONOCE palabra aaba: 0- => a => 0 => a => 0 => b => => 1 => a => 2+ RECONOCE palabra aabba: 0- => a => 0 => a => 0 => b => 1 => b => 1 => a => 2+ RECONOCE cadena a: 0- => a => => 0 => => ?? RECHAZA (el estado incial incial no es final) cadena ab: 0- => a => 0 => b => ?? RECHAZA (el estado 1 no es final) final)
* Ejercicio 7 * (pág.14) (a)
T a b c d 0-+ 0 0 0 0 (b) palabra a: 0- => a => 0+ RECONOCE palabra bcda: 0- => b => 0 => c => 0 => d => 0 => a => 0+ RECONOCE palabra ccc: 0- => c => 0 => c => 0 => => c => => 0+ RECONOCE palabra vacía: 0- => ε => 0+ RECONOCE
SSL
Muchnik
* Ejercicio 10 * (pág.15) (a) T a b 0- 1 1 2 2 3 3+ 2 (b) palabra aab: 0- => a => 1 => a => 2 => b=> 3+ RECONOCE palabra aabab: 0- => a => 1 => a => 2 => b => 3 => a => 2 => b => 3+ RECONOCE cadena a: 0- => a => 1 => ?? RECHAZA (el estado 1 no es final) cadena ba: 0- => b => ?? RECHAZA (no puede continuar)
* Ejercicio 12 * (pág.18) DF = ({0, 1, 2, 3}, {a, b,c}, TT, 0, {3}) TT a b c 01 1 1 1 2 2 2 2 3 3 3 3+ 3 3 3
donde la TT es:
* Ejercicio 13 * (pág.20) (a) DF = ({0,1,2,3}, {a,b,c}, TT, 0, {2,3}) TT a b c 01 4 4 1 4 3 2 2+ 4 4 4 3+ 3 4 4 4 4 4 4 (b) ER = ac + aba* (c) Describa las actividades de este AFD para todos los casos posibles.
* Ejercicio 14 * (pág.21) (a) Sea:
S= {+, -} D = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} O = {ASCII – (S, D)} TT S D O 01 2 3 1 3 2 3 2+ 3 2 3 3 3 3 3 (b) Recorra el Algoritmo 1 para la cadena –1234;
(c) Recorra el Algoritmo 1 para la cadena 12*34. (d) Opcional. (e) Opcional.
* Ejercicio 18 * (pág.22) -123,01234567,+1234123 Son palabras porque son una secuencia de caracteres que reoresentan los números enteros con y sin signo.
* Ejercicio 19 * (pág.23) No. Porque tienen un significado diferente. fdt marca el fin del texto y # marca el fin de cada cadena que debe ser procesada.
SSL
Muchnik
CAP. 2: AUTÓMATAS FINITOS CON PILA * Ejercicio 1 * (pág.27) a) No es un LR porque los caracteres del alfabeto son dependientes entre si; están en función de la variable n. b) Demuestre que las producciones dadas en el Ejemplo 1 generan a L1. Sea la cadena aabb: Sea la cadena ab: Sea la cadena aaabbb: S S S aSb ab Reconoce aSb aabb Reconoce aaSbb aaabbb Reconoce
* Ejercicio 4 *
(pág.28)
El ε significa que el AFP, estando en el estado 4 y no leyó ningún carácter, hace un pop del símbolo Z y pasa al estado 5 haciendo un push, primero de P y luego de R, quedando este último símbolo como nuevo tope de la pila.
* Ejercicio 5 * (pág.28) Reconocer por fin de la cadena significa que cuando detecta el fdc y la pila está vacía, transita al estado final. Reconocer por pila vacía significa que el conjunto de estados finales es vacío.
* Ejercicio 6 * (pág.28) SÍ.
* Ejercicio 8 * (pág.30) Elimina el símbolo que está en el tope de la pila.
* Ejercicio 9 * – – – – – – –
La 7-upla M = E = {e0, e1, A = {a,b} y A' = {R,$} e0 p0 = $ F = {e3} T es: TM e0,$ | e1,R | e2,R | e2,$ |
(pág.30)
(E, A, A', T, e0, p0, F), donde: e2, e3} fdc para indicar el final de la cadena.
a e1,R$ e1,RR
b e2,ε e2,ε
* Ejercicio 10 * (pág.30) a) e0,$ e1,R e1,R e1,R
=> => => =>
a a a b
=> => => =>
e1,R$ e1,RR e1,RR e2, ε
fdc
e3,$
SSL
Muchnik
e2,R => b => e2, ε e2,R => b => e2, ε e2,$ => fdc => e3,$ RECONOCE b) e0,$ => a => e1,R$ e1,R => a => e1,RR e1,R => b => e2, ε e2,R => b => e2, ε e2,$ => b => ?? (la pila está vacía, leyó una b y no tiene, en el tope de la pila, un símbolo R para sacar => RECHAZA
* Ejercicio 12 * (pág.31) – – – – – – –
La 7-upla M = (E, A, A', T, e0, p0, F), donde: E = {e0, e1, e2} A = {a,b} y fdc para indicar el final de la cadena. A' = {R,$} e0 p0 = $ F = { } T es: TM a b fdc e0,$ | e1,R$ e1,R | e1,RR e2,ε e2,R | e2,ε e2,$ | e2,ε
* Ejercicio 13 * (pág.31) a) e0,$ => a => e1,R$ e1,R => a => e1,RR e1,R => a => e1,RR e1,R => b => e2, ε e2,R => b => e2, ε e2,R => b => e2, ε e2,$ => fdc => e2, ε RECONOCE b) e0,$ => a => e1,R$ e1,R => a => e1,RR e1,R => b => e2, ε e2,R => b => e2, ε e2,$ => b => e2, ε ?? en la pila se hace un pop, por lo tanto, la pila no tiene ningún símbolo, se lee una b, sigue en el estado e2 pero no tiene símbolo para hacer otro pop => RECHAZA
* Ejercicio 15 * – – – – – – –
(pág.31)
La 7-upla M = (E, A, A', T, e0, p0, F), donde: E = {e0, e1, e2, e3} A = {a,b} y fdc para indicar el final de la cadena. A' = {R,$} e0 p0 = $ F = {e3} T es:
SSL
Muchnik
TM e0,$ e1,R e2,R e2,$
a | e1,R$ | e1,RR | |
b
fdc
e2,R e2,ε e3,$
* Ejercicio 16 * (pág.31) – – – – – – –
La 7-upla M = (E, A, A', T, e0, p0, F), donde: E = {e0, e1, e2, e3, e4} A = {a,b} y fdc para indicar el final de la cadena. A' = {R,$} e0 p0 = $ F = {e4} T es: TM a b fdc e0,$ | e1,$ e1,$ | e2,R$ e2,R | e2,RR e3,ε e3,R | e3,ε e3,$ | e4,$
* Ejercicio 17 * (pág.31) – – – – – – –
La 7-upla M = (E, A, A', T, e0, p0, F), donde: E = {e0, e1, e2, e3, e4, e5} A = {a,b} y fdc para indicar el final de la cadena. A' = {R,$} e0 p0 = $ F = {e5 } T es: TM a b fdc e0,$ | e1,R$ e1,R | e1,RR e2,R e2,R | e3,ε e3,R | e2,R e3,$ | e4,$ e5,$ e4,$ | e4,$ e5,$
* Ejercicio 18 * (pág.31) – – – – – – –
La 7-upla M = (E, A, A', T, e0, p0, F), donde: E = {e0, e1, e2} A = {a,b} y fdc para indicar el final de la cadena. A' = {R,Z,$} e0 p0 = $ F = {e2 } T es: TM a b fdc e0,$ | e1,R$ e1,Z$ e1,R | e1,RR e1,ε e1,Z | e1,ε e1,ZZ e1,$ | e1,R$ e1,Z$ e2,$
SSL
Muchnik
* Ejercicio 19 * (pág.32 ) (Ejemplo 6) La 7-upla M = (E, A, A', T, e0, p0, F), donde: – E = {e0, e1, e2, e3} – A = {4,+, *, (, )} y fdc para indicar el final de la cadena. – A' = {R,$} – e0 – p0 = $ – F = {e3 } – T es: _TM______ 4 e0,$ | e1,$ e0,R | e1,R e1,$ | e1,$ e1,R | e1,R e2,$ | e2,R | e3,$ |
+,* e0,$ e0,R e0,$ e0,R
( e0,R$ e0,RR
)
fdc e3,$
e2,ε e3,$ e2,ε
* Ejercicio 20 * (pág.32) a)
b) c) d)
e0,$ => ( => e0,R$ e0,R => ( => e0,RR e0,R => 4 => e1,R e1,R => ) => e2,ε e2,R => ) => e2,ε e2,$ => fdt => e3,$ RECONOCE 4 + 4 4 + 4 * (4 + (4)) e0,$ => 4 => e1,$ e1,$ => + => e0,$ e0,$ => ( => e0, R$ e0, R => ( => e0,RR e0,R => 4 => e1,R e1,R => ) => e2,ε e2,R => ) => e2,ε e2,$ => ) => ?? se lee un ), sigue en el estado e2 , la pila está vacía, por lo tanto no tiene símbolo para hacer un pop => RECHAZA
* Ejercicio 21 * (pág.32) Porque el lenguaje de las expresiones es un LF Infinito No Regular y, por lo tanto, no es posible encontrar una GR que permita describir a este lenguaje.
SSL
Muchnik
CAP. 3: INTRODUCCIÓN AL PROCESO DE COMPILACIÓN * Ejercicio 1 *
(pág.33)
Es un programa que convierte un programa fuente en otro.
* Ejercicio 2 *
(pág.33)
La marca de fin de archivo.
* Ejercicio 3 * (pág.33) Qué realicen la misma tarea.
* Ejercicio 4 * (pág.34) LEXEMA int WHILE ; while ( WHILE ; > ( 32 ) ) 2.46 ;
* Ejercicio 6 *
TOKEN palabraReservada Identificador caracterPuntuacion palabraReservada carácterPuntuación Identificador carácterPuntuación operador carácterPuntuación constante carácterPuntuación carácterPuntuación operador constante carácterPuntuación
(pág.34)
Desde la visión del programador, hay dos errores sintácticos: la doble declaración de la variable a(como int y como double) y el return 12 porque la función es void.
* Ejercicio 7 *
(pág.35)
Son tokens.
* Ejercicio 8 *
(pág.35)
La doble declaración de la variable a y el return 12.
* Ejercicio 9 *
(pág.36)
El alcance de una variable está dado por el contexto en el cual tiene validez. (por ejemplo: una variable local a una función, su alcance está limitado a la función, es decir, fuera de ella no existe).
* Ejercicio 10 *
(pág.37)
a) “Expresión es infija” por ejemplo, cuando un operador es binario debe estar entre dos operandos. b) ID es un noterminal. c) fin es una palabra reservada; Fin y finn son identificadores.
SSL
Muchnik
d) Significa que no hay que declarar a los identificadores porque son del único tipo de dato entero y tienen todos una longitud igual a 323 caracteres.
* Ejercicio 11 *
(pág.37) LEXEMA inicio leer ( a , b ) ; cc := a + ( b 2 ) ; escribir ( cc , a + 4 ) ; fin
* Ejercicio 12 *
TOKEN palabraReservada palabraReservada carácterPuntuación identificador carácterPuntuación identificador carácterPuntuación carácterPuntuación identificador asignación identificador operador carácterPuntuación identificador operador constante carácterPuntuación carácterPuntuación palabraReservada carácterPuntuación identificador carácterPuntuación identificador operador constante carácterPuntuación carácterPuntuación palabraReservada
(pág.38)
a) conjunto de noterminales:
, , , , , , , , , , . conjunto de terminales: a-z A -Z 0-9 inicio fin leer escribir + -:= ( ) , ;
conjunto de metasímbolos: < > -> uno de { } o una de b) Se produce un error léxico.
* Ejercicio 13 * a)
(pág.38)
conjunto de noterminales: , , , , , , , , , conjunto de terminales: inicio fin leer escribir := ; , ( ) conjunto de metasímbolos: < > -> { } |
SSL
Muchnik
b)
inicio leer (x,y); escribir (x-9, y +x); fin d) Los símbolos := No representan a un operador porque no pertenece al token asignación.
* Ejercicio 14 *
(pág.40)
a) una máquina virtual es una máquina que representa lo que hace una computadora y tiene su propio lenguaje de máquina. b) “en tiempo de compilación”: durante el proceso de compilación. c) “en tiempo de ejecución”: durante la ejecución del programa ejecutable. d) se compila el programa fuente. e) se ejecuta el programa objeto escrito en lenguaje de máquina. f) SÍ. Son equivalentes el programa que se compila y el programa que se ejecuta.
* Ejercicio 15 *
(pág.40)
SÍ. La genera la Gramática Léxica.
* Ejercicio 16 *
(pág.40)
4 caracteres que puedan actuar como centinelas para un identificador en Micro: - + : , *Ejercicio 18* (pág.41) Porque no pertenece al alfabeto (la gramática se construye sobre un alfabeto).
* Ejercicio 19 *
(pág.41)
abc identificador
* error léxico
* Ejercicio 20 *
(pág.41)
ab
identificador
a) los ignora b) forman parte del literalCadena c) ' ' '\n' son constantes carácter.
* Ejercicio 21 *
(pág.42)
a) contenido que queda en la Tabla de Símbolos una vez que el Análisis Léxico haya finalizado: inicio PR fin PR leer PR escribir PR a ID b ID b) Se fija en la TS.
* Ejercicio 28 *
(pág.47)
Aclaración: la numeración corresponde al orden en el cual se va armando el AAS.
SSL
Muchnik
(1)
(2) (29) FDT
(3) INICIO
(4)
(28) FIN
(5)
(12)
(6) ID (7) ASIGNACION (8) (11) PUNTOYCOMA
(9) (13) ESCRIBIR (14) PARENIZQUIERDO (15) (26)PARENDERECHO(27) PUNTOYCOMA
(10) CONSTANTE (16)
(19) COMA
(20)
(17) (21) (23) OPERADORADITIVO (24)
(18) ID
* Ejercicio 29 *
(22) ID
(25)CONSTANTE
(pág.47)
void Programa (void) { /* -> INICIO FIN */ Match(INICIO); ListaSentencias(); Match(FIN); }
* Ejercicio 34 *
(pág.50)
Match(), ProximoToken() y ErrorSintactico().
* Ejercicio 35 *
(pág.50)
a) inicio escribir(4); fin b) Objetivo() Programa() ListaSentencias() Sentencia() ListaExpresiones() Expresion() Primaria()
* Ejercicio 40 *
(pág.54)
En el parámetro: resultado es una variable de tipo puntero a un objeto de tipo REG_EXPRESION.
SSL
Muchnik
En la sentencia: significa que en lo apuntado por resultado (*resultado) guarde el contenido de la variable operandoIzq. Aquí el asterisco corresponde al operador indirección.
* Ejercicios Adicionales *
(pág.49)
void ListaExpresiones(void) { /* -> {COMA } */ Expresion(); /* la primera de la lista de expresiones */ while(1) { /* un ciclo indefinido */ switch(ProximoToken()) { case COMA: Match(COMA); Expresion(); /* procesa la secuencia opcional */ default: return; } /* fin-switch */ } /* fin-while */ } void Primaria(void) { /* -> ID | CONSTANTE | PARENIZQUIERDO PARENDERECHO */ TOKEN tok = ProximoToken(); switch(tok) { case ID: Match(ID); break; case CONSTANTE: Match(CONSTANTE); break; case PARENIZQUIERDO: Match(PARENIZQUIERDO); Expresion(); Match(PARENDERECHO); break; default: ErrorSintactico(tok); break; } /* fin-switch */ } void ListaIdentificadores (void) { /* -> { , } */ Match(ID); while (ProximoToken() == COMA) { Match(COMA); Match(ID); } }
SSL
Muchnik
Cap. 4: ANÁLISIS LÉXICO, ANÁLISIS SINTÁCTICO Y ANÁLISIS SEMÁNTICO * Ejercicio 1 *
(pág.57)
(XX, función, int, 1, double) (a, parámetro,double) (s, arreglo, 1, char, 12) (b, variable, double)
*
Ejercicio 2 *
(pág.58)
Identificadores, constantes (reales, enteras).
* Ejercicio 3 * a) b) c) d)
* Ejercicio 4 * a) b) c) d) e) f) g) h)
(pág.58)
V F F V
(pág.58)
SI NO SI SI SI NO SI NO
* Ejercicio 5 *
(pág.59)
El de ANSI C.
* Ejercicio 6 *
(pág.59)
El Scanner lee el primer carácter que es una / (barra), lee el sengundo carácter, si es una barra, entonces lee el tercer carácter, si este último es el símbolo +, entonces detecta el operador //+ y no necesita leer un próximo carácter; en caso de ser cualquier otro carácter, detecta el operador // y si después de leer el primer carácter (barra), el segundo es cualquier otro carácter, entonces detecta el operador /.
* Ejercicio 7 *
(pág.59)
Para facilitar el Análisis Sintáctico.
* Ejercicio 8 *
(pág.60)
a) En el primer caso, el Scanner retorna el tipo de constante numérica y la posición de esa constante guardada como secuencia de caracteres (sin convertir); en cambio, en el 2º caso, el Scanner debe realizar una conversión de la secuencia de caracteres que representan a la constante entera a su valor numérico y entonces retorna el tipo de constante numérica y el valor de la constante. b) por enumeración o con un número entero.
SSL
Muchnik
* Ejercicio 9 *
(pág.60)
(tipo, valor), o sea: (CONSTANTECARACTER, carácter)
* Ejercicio 10 *
(pág.61)
SÍ.
* Ejercicio 11 *
(pág.61)
SÍ.
* Ejercicio 12 *
(pág.61)
a) typedef PR, char PR, strings ID, [ CP (carácterpuntuación), 200 CONSTANTE, ] CP, [ CP, 32 CONSTANTE, ] CP, ; CP b) (strings, nombredetipo, arreglo, 2, char, 200, 32) Aclaración: nombredetipo será un valor que indique que strings no es el nombre de una variable sino el nombre de un tipo de dato.
* Ejercicio 13 *
(pág.61)
En literalCadena y como carácter constante.
* Ejercicio 14 * a) b) c) d) e)
(pág.62)
noterminales: inst. asignación identif. expr. terminales: posicion = inicial + velocidad axioma falta el ; (punto y coma) posicion = inicial + velocidad * 60; inst. asignación identif. = expr. ; posicion = expr. ; posicion = expr. + expr. ; posicion = identif. + expr. ; posicion = inicial + expr. ; posicion = inicial + expr. * expr. ; posicion = inicial + identif. * expr. ; posicion = inicial + velocidad * expr. ; posicion = inicial + velocidad * const. ;
const. * 60
posicion = inicial + identif. * 60;
* Ejercicio 17 *
(pág.66)
NO.
* Ejercicio 18 *
(pág.66)
En Pascal: variable no declarada, variable declarada con dos tipos distintos.. En ANSI C: función no definida, cuando en el lado izquierdo de una asignación aparece un valor constante (ejemplos: 1 = 3; 4++;).
* Ejercicio 19 *
(pág.66)
a) noterminales: listaExpresiones expresión terminales: num + * ; ( ) metasímbolos: : |
* Ejercicio 20 *
(pág.68)
Ejemplo: S -> aTbRba
|
aTbc
término
factor
SSL
* Ejercicio 21 *
Muchnik
(pág.69)
if ( ) β1 else
es α
β2 ε
* Ejercicio 22 *
(pág.69)
S -> aTbS’ S’ -> Rba | c T -> a | Ta R -> cR’ R’ -> ε | Rb
* Ejercicio 23 *
(pág.70)
-> ’ ’ -> ε | ’
* Ejercicio 24 *
(pág.70)
GIC 2: listaExpresiones: expresión listaExpresiones’ listaExpresiones’: ε | ; expresión listaExpresiones’ expresión: término expresión’ expresión’: ε | + término expresión’ término: factor término’ término’: ε | * factor término’ : num | ( expresión ) factor
* Ejercicio 25 *
(pág.71)
Primero(S) = Primero (aSe) {a}
U U
Primero(B) = Primero(bBe) {b}
U U
Primero(C) = Primero(cCe) {c}
U U
* Ejercicio 26 *
Primero(B) Primero(bBe) U Primero(C) {b} U Primero(cCe) U {c} U Primero(C) Primero(cCe) U Primero(d) {c} U {d} Primero(d) {d}
Primero(d) {d}
(pág.71)
Primero(S) = Primero(ABc) como A es un noterminal, por (2), entonces hay que calcular los conjuntos Primero para cada lado derecho de A: A -> a|ε esto implica que Primero(a) = {a} U Primero(ε) = {ε} pero como A puede generar ε, por (3), entonces Primero(S) depende de B (X2) y como B es un noterminal, por (2), hay que calcular los conjuntos Primero para cada lado derecho de B: B -> b|ε esto implica que Primero(b) = {b} U Primero(ε) = {ε} pero como B puede generar ε por (3), entonces Primero(S) depende de c, y como c es un terminal, por (1), Primero(c) = {c}. Por lo tanto: Primero(S) = {a,b,c}
SSL
Muchnik
* Ejercicio 27 * (pág.72) b) Porque no está descripto en la GIC. c) Porque no existe. * Ejercicio 28 *
(pág.73)
Predice (E1 -> T1 E2) = Primero(T1 E2) = { (, num } porque no contiene a ε y, por lo tanto, Predice coincide con Primero(T1 E2).
* Ejercicio 29 *
(pág.74)
Dos.
* Ejercicio 31 *
(pág.76)
a) noterminales: listaParéntesis, plista ) terminales: ( ε b) listaParéntesis plista ( listaParéntesis ( plista )
)
( ε ) ( ) c)
listaParéntesis plista ( listaParéntesis ) ( plista listaParéntesis ) ( ( listaParéntesis ) listaParéntesis ( ( plista) listaParéntesis )
)
* Ejercicio 33 * (pág.78) 1º) no es recursiva a izquierda; 2º) no tiene prefijo común.
* Ejercicio 37 *
(pág.83)
a) Detecta cada lexema y retorna el token correspondiente, en la medida que el Parser se lo solicita. b) Realiza el Análisis Sintáctico de la expresión en base a la GIC. c) Detecta que la primera constante es entera (int) y que la segunda constante es real (double), y realiza la conversión a double para poder hacer la operación de suma.
* Ejercicio 38 *
(pág.84)
a) Análisis Léxico: Detecta cada lexema y retorna el token correspondiente, en la medida que el Parser se lo solicita. No hay errores léxicos. b) Análisis Sintáctico: Analiza sintácticamente el bloque y no detecta errores sintácticos. c) Análisis Semántico: 1º) detecta que la variable a es entera (int); 2º) detecta que el valor constante 2 no es un valorL en la sentencia de asignación –detección del 1er. error; 3º) detecta que después de la sentencia de asignación hay una declaración de la variable b como real (double) y que la misma está fuera de lugar -detecta el 2º error; 4º) detecta que la variable b, en la sentencia de asignación, es un valorL (correcto) y que en la expresión 4++, 4 es un valor constante y se le aplica el operador incremento -detecta el 3er. error porque el operando debe ser un valorL.
SSL
* Ejercicio 39 *
Muchnik
(pág.84)
a) Análisis Léxico: Detecta cada lexema y retorna el token correspondiente, en la medida que el Parser se lo solicita. No hay errores léxicos. b) Análisis Sintáctico: Analiza sintácticamente el bloque y no detecta errores sintácticos. c) Análisis Semántico: Detecta que las variables a y b son enteras (int) y que c es una variable real (double); realiza la conversión correspondiente a double para poder hacer la operación de suma, luego quedará el resultado truncado (porque la suma se realiza double pero el resultado es int).
