campusvirtual.univalle.edu.

co

Primer Examen Parcial: Revisión del

intento
DINTEV

10–13 minutos

Comenzado el jueves, 10 de noviembre de 2022, 16:03

Estado Finalizado

Finalizado en jueves, 10 de noviembre de 2022, 17:32

Tiempo empleado 1 hora 28 minutos

Puntos 72,50/100,00

Calificación 3,63 de 5,00 (72,5%)

Información

Texto informativo

Consideración sobre la autoría del examen

 Al continuar con la presentación de este examen, declaro que soy
consciente de que cualquier tipo de fraude en los exámenes
es considerado como una falta grave en la Universidad.

Al enviar este examen virtual, doy expreso testimonio de que este

trabajo fue desarrollado completamente por mi, sin ayuda de
terceras personas, de acuerdo con las normas establecidas.

Particularmente doy fé que este examen lo desarrollé de forma

individual, usando mi conocimiento y las competencias que he
desarrollado como estudiante, en general, y como estudiante de
este curso en particular.

Del mismo modo, aseguro que no participé en ningún tipo de

fraude, ni a mi favor, ni a favor de otros durante el desarrollo de
este examen.

Consideraciones a tener en cuenta:

• Las preguntas son de exploración libre y tienen la posibilidad de

volver atrás. Sin embargo, se recomienda completar las
actividades en el orden que aparecen.

• Existen preguntas de selección múltiple con única respuesta, en

cuyo caso sólo suman puntos las respuestas correctas.

• También existen preguntas de selección múltiple con varias

respuestas, en cuyo caso suman puntos las respuestas correctas
y las incorrectas restarán puntos. Se sugiere no marcar aquellas
respuestas en las que no estén seguros para no desmejorar la
posible nota acumulada en las respuestas correctas.

Pregunta 1

Parcialmente correcta

Se puntúa 12,50 sobre 20,00

Enunciado de la pregunta

ESPECIFICACIÓN GRAMATICAL Y RECURSIÓN

La siguiente gramática representa las listas de parejas de símbolos

y números. Ej: ‘((x 5) (y 4) (z 3) )

<listaP> :: ({<Pareja>}*)

<Pareja>:: (Símbolo Número)

Seleccione la(s) opción(es) correcta(s) para representar la

gramática utilizando tipos de datos:

(define-datatype pareja pareja? (par (d1 symbol?) (d2 number?)

(rest listaP?)))

(define-datatype listaP listaP? (vacia) (extendida (p1 symbol?) (p2

number?) (resto pareja?)) )

(define-datatype pareja pareja? (par (d2 symbol?) (d1 number?)))

 (define-datatype listaP listaP? (vacia) (extendida (p1 pareja?) (p2
pareja?) (resto listaP?)) )

(define-datatype listaP listaP? (extendida (p1 symbol?) (p2

number?) (resto listaP?)) )

(define-datatype listaP listaP? (extendida (p pareja?) (resto

listaP?)) )

(define-datatype pareja pareja? (par (d1 number?) (d2 number?)))

(define-datatype listaP listaP? (vacia) (extendida (p pareja?) (resto

listaP?)) )

(define-datatype pareja pareja? (par (d1 number?) (d2 symbol?)))

(define-datatype pareja pareja? (numero (d1 symbol?)) (simbolo

(d2 number?)))

Se puntúa 0,25 sobre 1,00

La respuesta correcta es:

• (define-datatype listaP listaP? (vacia) (extendida (p pareja?) (resto

listaP?)) )

• (define-datatype pareja pareja? (par (d2 symbol?) (d1 number?)))

Dada una lista de parejas en sintaxis abstracta; la(s) siguiente(s)

función(es) retorna(n) la suma de los números de la lista de
parejas:
 (define sumaValores (lambda (l) (cond [(null? l) 0] [else (+
(leerPareja (car l)) (sumaValores (cdr l) ))])))

(define leerPareja (lambda (p) (cadr p)))

(define sumaValores (lambda (l) (cases listaP l (vacia () 0)

(extendida (p r) (+ (leerPareja p) (sumaValores r))))))

(define leerPareja (lambda (p) (car (cadr p))))

(define leerPareja (lambda (p) (car (cdr p))))

(define leerPareja (lambda (p) (cases pareja p (par (d1 d2) d1))))

(define sumaValores (lambda (l) (cases listaP l (vacia () 0)

(extendida (p r) (+ (cadr p) (sumaValores r))))))

(define leerPareja (lambda (p) (cases pareja p (par (d1 d2) d2))))

(define sumaValores (lambda (l) (cond [(null? l) 0] [else (+ (caar l)

(sumaValores (cdr l) ))])))

(define sumaValores (lambda (l) (cond [(null? l) 0] [else (+ (cadr l)

(sumaValores (cdr l) ))])))

Se puntúa 1,00 sobre 1,00

La respuesta correcta es:

• (define sumaValores (lambda (l) (cases listaP l (vacia () 0)

(extendida (p r) (+ (leerPareja p) (sumaValores r))))))

• (define leerPareja (lambda (p) (cases pareja p (par (d1 d2) d2))))
Pregunta 2

Correcta

Se puntúa 10,00 sobre 10,00

Enunciado de la pregunta

Utilice la siguiente gramática (la representación concreta en color

negro y abstracta en color rojo para responder las preguntas a
continuación)

<expresion>:= simbolo

var-exp (id)

                      := numero

                          numero-lit(num)

:= “set” simbolo “=” <expresion>

set-exp (id valor)

:= “void” “main” “(” {simbolo “=”

<expresion>} *  “)” “{“ <expresion> “}“

main-exp (ids exps body)

Utilizando define-datatype defina la gramática de expresión donde

los valores denotados son símbolos. Seleccione todas las que
apliquen (Cuidado!!! recuerde que algunas respuestas restan
puntos):

Retroalimentación

Respuesta correcta

Las respuestas correctas son: (define-datatype expresion

expresion?
; Variantes
), (var-exp (id symbol?)), (numero-lit (num number?)), (set-exp (id
symbol?) (valor expresion?)), (main-exp (ids (list-of symbol?) )
(exps (list-of expresion?)) (body expresion?)))

Pregunta 3

Correcta

Se puntúa 15,00 sobre 15,00

Enunciado de la pregunta

<expresion>:= simbolo

var-exp (id)

:= numero
 numero-lit(num)

:= “set” simbolo “=” <expresion>

set-exp (id valor)

:= “void” “main” “(” {simbolo “=”

<expresion> }* “)” “{“ <expresion> “}“

main-exp (ids exps body)

Utilizando el define-datatype para la gramática de arriba (la

representación concreta en color negro y abstracta en color
rojo ). ¿Cuál sería una entrada en sintaxis concreta
equivalente al ejecutar las siguientes invocaciones?

(main-exp

'(x y)

(list (numero-lit 4) (numero-lit 2))

(set-exp 'z

(main-exp '(w) (list (numero-lit 4))

(set-exp 'x (var-exp 'w))

)
Retroalimentación

Respuesta correcta

La respuesta correcta es: void main(x = 4 y =2){

set z = void main(w = 4){
set x = w
}
}

Pregunta 4

Correcta

Se puntúa 15,00 sobre 15,00

Enunciado de la pregunta

Dada la siguiente gramática, (la representación concreta en

color negro y abstracta en color rojo):

<expresion>:= simbolo

var-exp (id)

:= numero

numero-lit(num)

:= “set” simbolo “=” <expresion>

 set-exp (id valor)

:= “void” “main” “(” {simbolo “=”

<expresion> }* “)” “{“ <expresion> “}“

main-exp (ids exps body)

Genere una función Eval-expresion que recibe un árbol de

sintaxis abstracta de una expresión. La función debe evaluar toda
la expresión de la siguiente manera:

• Si la expresión es un var-exp retorne el símbolo de la variable

• Si la expresión es un numero-lit retorne el número

• Si la expresión es un set-exp retorne una lista cuyo primer

elemento es el símbolo seguida de la expresión debidamente
evaluada

• Si la expresión es un main-exp retorne una lista cuyo primer

elemento es la lista de símbolos ids, el segundo elemento es la
lista de expresiones exps en sintaxis abstracta, y el tercer
elemento es el body en sintaxis abstracta.

Seleccione todas aquellas que sean necesarias para construir la

función. Cuidado!!! existen respuesta(s) que suman puntos y
otra(s) que restan:

Retroalimentación
Respuesta correcta

Las respuestas correctas son: (define Eval-expresion

(lambda (exp)
(cases expresion exp
;Espacio para casos
))), (var-exp (id) id), (numero-lit (num) num), (set-exp (id valor) (list
id (Eval-expresion valor))), (main-exp (ids exps body)
(list ids exps body))

Pregunta 5

Incorrecta

Se puntúa 0,00 sobre 20,00

Enunciado de la pregunta

Asuma la creación de un interpretador con la siguiente gramática:

gramatica

Cuál de las siguientes representaciones de sintáxis abstracta se

genera el ejecutar el programa:

void main(){

variables

x = 3;
haga

variables

y = funcion (a;b) -> +[a;b] finFunc ;

haga

invocar y con (x ; *[x;2] ) finInv

finVar

finVar

Retroalimentación

Respuesta incorrecta.

La respuesta correcta es: #(struct:un-programa

#(struct:variableLocal-exp
(x)
(#(struct:numero-lit 3))
#(struct:variableLocal-exp
(y)
(#(struct:procedimiento-exp (a b) #(struct:primitiva-exp
#(struct:suma) #(struct:identificador-lit a) #(struct:identificador-lit
b))))
#(struct:proc-evaluacion-exp
 #(struct:identificador-lit y)
(#(struct:identificador-lit x) #(struct:primitiva-exp #(struct:multi)
#(struct:identificador-lit x) #(struct:numero-lit 2)))))))

Pregunta 6

Correcta

Se puntúa 20,00 sobre 20,00

Enunciado de la pregunta

Asuma la creación de un interpretador con la siguiente gramática:

gramatica

Que programa corresponde con la siguiente sintaxis abstracta:

#(struct:un-program

#(struct:variableLocal-exp

(f z)

(#(struct:procedimiento-exp

(a b c)

#(struct:primitiva-exp

#(struct:multi)

#(struct:primitiva-exp #(struct:suma) #(struct:identificador-lit a)

#(struct:identificador-lit b))

#(struct:identificador-lit c)))

#(struct:condicional-exp

#(struct:primitiva-exp #(struct:resta) #(struct:numero-lit 2)

#(struct:primitiva-exp #(struct:div) #(struct:numero-lit 4)
#(struct:numero-lit 2)))

#(struct:numero-lit 3)

#(struct:numero-lit 2)))

#(struct:proc-evaluacion-exp #(struct:identificador-lit f)
(#(struct:identificador-lit z) #(struct:numero-lit 4)))))

Retroalimentación

Respuesta correcta

La respuesta correcta es: void main(){

variables
f = funcion (a;b;c) -> *[+[a;b];c] finFunc ;
z = Si -[2;/[4;2]] entonces 3 sino 2 finSi;
haga

invocar f con (z ; 4 ) finInv

finVar
}