Executar assignació, print, if i while

INTRODUCCIÓ:

L’entrada d’aquest exercici és una llista d’arbres binaris d’strings, on cadascun representa una instrucció d’un llenguatge de programació molt simple que descrivim a continuació.

Les variables del llenguatge poden guardar dígits, és a dir, valors entre 0 i 9. Les expressions del llenguatge tenen variables, dígits, i els operadors + i , que treballen mòdul 10, de manera que el resultat d’avaluar un d’aquests operadors sobre dígits dona com a resultat un dígit. Per exemple, suposem que les variables x i y guarden valors 4 i 5, respectivament, i considerem l’expressió 3+x*2+y. Llavors, l’avaluació d’aquesta expressió serà 6.

Nota: Quan una expressió conté una variable que no ha estat assignada abans, suposem que té valor per defecte 0.

Com a tipus d’instruccions del llenguatge, tenim assignació, if, while, amb el significat habitual, print per a escriure l’avaluació d’una expressió per la sortida seguida de salt de línia, i també subllistes d’instruccions. Per a les expressions de la condició de if i while, es considera que es cumpleixen si s’avaluen a diferent de 0, és a dir, a qualsevol dels valors 1,…,9. Aquest és un exemple de programa:

x = 1
while (x) {
  if (2*x) {
    print(x)
    print(3*x)
  }
  x = x + 1
}
print(x)

El programa anterior té com a sortida:

Com hem mencionat al principi, l’entrada d’aquest exercici és una llista d’arbres que representen instruccions d’aquest llenguatge. Per a l’exemple anterior de programa, aquesta seria l’entrada en INLINEFORMAT:

=(x,1)
while(x,list(if(*(2,x),list(print(x),print(*(3,x)))),=(x,+(x,1)))
print(x)

I aquesta seria la mateixa entrada en VISUALFORMAT:

     =
     |
 ---- ----
|         |
x         1

                  while
                    |
                ---- ----
               |         |
               x        list
                         |
               ---------- ----------
              |                     |
              if                    =
              |                     |
      -------- --------         ---- ----
     |                 |       |         |
     *                list     x         +
     |                 |                 |
 ---- ----         ---- ----         ---- ----
|         |       |         |       |         |
2         x     print     print     x         1
                  |         |
              ----      ----
             |         |
             x         *
                       |
                   ---- ----
                  |         |
                  3         x

   print
     |
 ----
|
x

L’objectiu d’aquest exercici és que implementeu dues funcions, una funció que avalua una expressió del llenguatge, i una funció que simula una instrucció del llenguatge. Convindrà que la segona funció cridi a la primera quan sigui convenient. Aquestes son les capceleres:

// Pre:  t és un arbre no buit d'strings que representa una expressió correcta
//       sobre dígits i variables que guarden dígits, i els operadors +,* mòdul 10.
//       En particular, l'arrel de t és o bé +, o bé *, o bé un dígit, o bé una variable.
//       var2val és un mapeig de variables a dígits.
// Post: Retorna l'avaluació de l'expressió representada per t reemplaçant les variables
//       pels seus corresponents valors definits a var2val, o per 0 si no estan definides.
int evaluate(map<string,int> &var2val, BinTree<string> t);

// Pre:  t és un arbre no buit d'strings que representa una instrucció correcta
//       del llenguatge de programació descrit a l'enunciat.
//       En particular, o bé és l'arbre buit,
//       o bé la seva arrel és, o bé =, o bé print, o bé if, o bé while,
//       o bé list, cas en el cual, representa una subllista d'instruccions.
// Post: S'ha simulat l'execució d'aquesta instrucció, modificant var2val
//       i escrivint el que calgui per la sortida estandar,
//       d'acord a aquesta simulació.
void execute(map<string,int> &var2val, BinTree<string> t);

Fixeu-vos que l’enunciat d’aquest exercici ja ofereix uns fitxers que haureu d’utilitzar: main.cc, BinTree.hh, execute.hh. Us falta crear el fitxer execute.cc amb els corresponents includes i implementar-hi les dues funcions anteriors. Només cal que pugeu execute.cc al jutge.

Entrada

La primera linia de l’entrada descriu el format en el que es descriuen els arbres, o bé INLINEFORMAT o bé VISUALFORMAT. Després venen un nombre arbitrari d’instruccions representades per arbres. Fixeu-vos en que el programa que us oferim ja s’encarrega de llegir aquestes instruccions i mantenir un mapeig de variables a dígits amb el valor actual de les variables. Només cal que implementeu les dues funcions abans esmentades.

Nota: Els casos d’entrada s’han creat mirant de garantir que l’execució de les instruccions d’entrada acaben.

Sortida

La sortida conté el que seria la sortida esperada com a resultat d’executar les instruccions que venen descrites a l’entrada. Fixeu-vos en que el programa que us oferim ja s’encarrega de cridar a la vostra funció execute que alhora hauria de cridar a la funció evaluate quan calgui. Només cal que implementeu aquestes funcions de manera que simulin correctament el comportament de les instruccions, actualitzant el mapeig de variables a dígits correctament, i escrivint dígits per la sortida amb la instrucció print. Cadascun d’aquests dígits escrits ha de venir seguit d’un salt de línia.

Observació

Avaluació sobre 10 punts:

Solució lenta: 5 punts.
solució ràpida: 10 punts.

Entenem com a solució ràpida una que és correcta, de cost lineal i capaç de superar els jocs de proves públics i privats. Entenem com a solució lenta una que no és ràpida, però és correcta i capaç de superar els jocs de proves públics.

Informació del problema

Autoria: PRO2

Generació: 2026-01-25T14:56:29.867Z