Considere o fragmento de programa Java, abaixo. Ao ser execu...

Acho que essa questão deveria ser anulada, pois para a resposta dar 23, o método deveria retornar 0 quando val for 0, e isso não está especificado no código, sendo assim, quando val for 0, o código ainda irá continuar rodando recursivamente.

Resolvi assim:

                                                     op(5-1)                                     +        5        +                           op(5-2)
                                                      op(4)                                      +        5        +                            op(3)
                               op(4-1)                   +  4  +       op(4-2)           +        5        +                op(3-1) + 3 + op(3-2)
                                op(3)                     +  4  +         op(2)            +        5        +                  op(2) + 3 + op(1)
                     op(3-1) + 3 + op(3-2)        +  4  +           2                +        5        +                         2 + 3 + 1
                       op(2) + 3 + op(1)            +  4  +           2                +        5        +                               6
                               2+3+1                    +  4  +           2                +        5        +                               6      
                                   6                        +  4  +           2                +        5        +                               6

                                                                                         Resultado:  23.
                                                                                                 Gabarito:  A.
                                                        
                                                       
              
 

Para resolver uma questão como essa, tem que executá-la chamada por chamada até não haver mais chamadas recursivas. Omitirei o if para não poluir o código.

Chamando:

op(5): return op(4) + 5 + op(3);

op(4): return op(3) + 4 + op(2);

op(3): return op(2) + 3 + op(1);

op(2): return 2;

op(1): return 1;

Retornando (agora é só ir substituindo os valores, uma vez que obtivemos os valores raiz e não há mais chamadas recursivas):

op(3): return 2 + 3 + 1; // 6

op(4): return 6 + 4 + 2; // 12

op(5): return 12 + 5 + 6; // 23

Resposta: a) 23.