Julgue o item subsecutivo, a respeito de lógica e de estrutu...

Vejamos a codificação linha por linha para avaliação da afirmativa:

função avaliar( a, b )

início

na primeira e segunda linha são denominados o nome da função, os seus parâmetros (a,b) e o início

      ma <-a;

na terceira linha a variável "ma" recebe o valor contido na variável "a"

    se (ma < b) então ma <- b;

na quarta linha é utilizada uma estrutura de controle de fluxo ou condição chamada de "se, então", que neste caso verifica SE o valor contido em "ma" é MENOR que "b" caso seja verdade a comparação, ENTÃO a variável "ma" receberá o valor contido na variável "b"

    me <-a;

na quinta linha a variável "me" recebe o valor contido na variável "a"

    se (me > b) então me <- b;

na sexta linha é utilizada novamente a condição "se, então" que neste caso verifica SE o valor contido em "me" é MAIOR que "b"

caso seja verdade a comparação, ENTÃO a variável "me" receberá o valor contido na variável "b"

  resultado <- ( ma % me );

nesta etapa da linha 7 a variável "resultado" receberá o resto da divisão (representado pelo símbolo %) da variável "ma" pela variável "me", ou seja, "ma" será o dividendo e "me" será o divisor, e nos interessará ao final o resto dessa divisão

  se (resultado = 0)

        então retorne me

        senão avaliar(me, ma)

na linha 8, 9 e 10 será utilizada a estrutura se, então, senão, ou seja, SE for verdadeira a condição da linha 8 ENTÃO será executada a linha 9, SENÃO será executada a linha 10. Ou seja, SE o valor da variável "resultado" for igual a 0, ENTÃO a função retornará o valor contido na variável "me", SENÃO será chamada a função avaliar novamente (de forma recursiva) passando como parâmetros os valores das variáveis "me" e "ma"

fim

esta linha indica o final da função "avaliar"

escreva avaliar (120,30);

por fim, o programa é executado, ou seja, existe uma chamada para a função "avaliar" passando os valores 120 e 30 como parâmetros, e deseja-se que no final seja escrito o valor de retorno da função

A execução do código será:

função avaliar( a, b )              a última linha chama a função avaliar passando os parâmetros 120 e 30, ou seja, avaliar( 120, 30 )

início                          início da função

      ma <-a;                     ma = 120

      se (ma < b) então ma <- b;      120 < 30 = falso, não executa instrução então

      me <-a;                     me = 120 

      se (me > b) então me <- b;      120 > 30 = verdadeiro, executa instrução então, me = 30

  resultado <- ( ma % me );         resultado = 120 % 30, logo resultado = 0

  se (resultado = 0)               se resultado igual 0 = verdadeiro, executa a instrução então

        então retorne me            instrução então apenas retorna o valor de me que é igual a 30

        senão avaliar(me, ma)        não executa esta linha pois a condição se foi satisfeita

fim                            fim da função

escreva avaliar (120,30);           por fim é escrito em tela o valor 30

Retorna apenas o "me". Se fazer rápido erra a questão.

JUSTIFICATIVA CESPE: ERRADO.

No pseudocódigo apresentado:

a recebe 120

b recebe 30

ma recebe 120

se (120 é menor que 30) falso

me recebe 30

se (120 é maior que 30 ) verdadeiro

então me recebe 30

resultado recebe o resto da divisão de 120 por 30 ou seja resultado recebe 0

se resultado igual a 0 (verdadeiro) então retorne 30 resultado 30

Fonte: CESPE

JUSTIFICATIVA: ERRADO. No pseudocódigo apresentado:

a recebe 120

b recebe 30

ma recebe 120

se (120 é menor que 30) falso

me recebe 30

se (120 é maior que 30 ) verdadeiro

então me recebe 30

resultado recebe o resto da divisão de 120 por 30 ou seja resultado recebe 0

se resultado igual a 0 (verdadeiro)

então retorne 30

resultado 30

Pessoal, fica a dica: decorem os algoritmos mais comuns. Esse é o algoritmo de MDC, também chamado de algoritmo de Euclides. No meu caso a resolução foi bem fácil, pois já conheço o algoritmo, vi de cara que era ele (só li os detalhes pra ter certeza) e sabia que o retorno seria 30.

Na hora da prova isso economiza um tempo enorme, principalmente naqueles de ordenação e busca em arrays.