Observe o trecho de código abaixo. algoritmo ALG; variáve...

Vamos entender como resolver a questão e chegar à alternativa correta.

Alternativa correta: C - 2

Para começar, analisaremos o trecho de código fornecido na questão.

O código é o seguinte:

<algoritmo> ALG;
    variáveis
        X: <lógico>;
        Y: <string>;
    início
        Y := 'MEC'; X := FALSO;
        <repetir>
            <imprimir>(Y);
            X := NÃO X;
        <até que> (NÃO X);
    fim.

Vamos analisar passo a passo:

1. Inicialização das Variáveis:
    Y é inicializada com o valor 'MEC'.
    X é inicializada com o valor FALSO.

2. Estrutura de Repetição:
A estrutura de repetição repetir ... até que executa seu bloco de código até que a condição especificada após até que se torne verdadeira.

Bloco de código dentro da repetição:
    imprimir(Y): vai imprimir o valor de Y.
    X := NÃO X: vai inverter o valor de X.

Condição de término:
A repetição termina quando a condição (NÃO X) for verdadeira.

Análise da execução:

1. Inicialmente, X = FALSO.
2. Entra no loop e imprime 'MEC'.
3. X := NÃO X, então X se torna VERDADEIRO.
4. Verifica a condição (NÃO X), ou seja, (NÃO VERDADEIRO) = FALSO. A condição não foi satisfeita, então continua no loop.
5. Imprime 'MEC' novamente.
6. X := NÃO X, então X se torna FALSO.
7. Verifica a condição (NÃO X), ou seja, (NÃO FALSO) = VERDADEIRO. Agora a condição é satisfeita e o loop termina.

Portanto, a variável Y será impressa 2 vezes, confirmando que a alternativa correta é a letra C.

Análise das alternativas incorretas:

A - 0: Está incorreta porque a variável Y é impressa pelo menos uma vez antes da repetição terminar.
B - 1: Está incorreta porque a repetição ocorre mais uma vez após a primeira impressão.
D - 3: Está incorreta porque o loop termina após a segunda impressão.
E - 4: Está incorreta porque o loop não se repete tantas vezes.

Espero que essa explicação tenha clarificado o funcionamento do algoritmo e as razões pelas quais a alternativa C é a correta. Se tiver mais dúvidas, estou à disposição para ajudar!

A primeira vez que o algoritmo chega ao loop repetir, é impresso "MEC" e x recebe o valor de "não x" que é TRUE (! FALSE = TRUE).
Como a instrução de repetição do loop é até que (Não X) o loop repete (até que (não X) equivale há até que (x == TRUE), ou seja para quando X for TRUE).
A segunda vez que o algoritmo entra no loop é impresso a segunda vez "MEC" e X recebe o valor TRUE.
Finalmente o algortimo termina.

Não entendi Bernardo. Se a primeira vez que X passa no loop ele recebe TRUE, então deveria já sair do Loop não? Já que x:Não X => x==TRUE. Ou seja Y seria impresso somente uma vez. Estou certo?

É isso mesmo Diguinho. Você deduziu corretamente parte da questão. A primeira vez que o loop é executado X assume valor TRUE. O problema é que a condicional de Parada é (NÃO X) ou seja, para que esta expressão seja validade (=TRUE), X deve ser FALSE. Por isso o Loop é executado novamente, X passa a ser FALSE e quando chega na condição de parada, (NÃO X) -> (NÃO FALSE) -> TRUE!

Pessoal o Y SÓ VAI SER IMPRESSO UMA VEZ, o próprio X está sendo utilizado como teste lógico e ele está sendo alterado dentro da estrutura de repetição:

Ao entrar na estrutura de repetição X = NÃO X, ou seja X = TRUE o While vai ser NÃO X, ou seja enquanto (NÃO X = FALSE)

repetir 
    imprimir("MEC")
    X = TRUE
até que (FALSE)

Quem quiser testar em C#:

repetir
  imprimir(Y);
  X:=NÃO X;
até que (NÃO X);

O Laço é sempre executado ao menos uma vez e é finalizado apenas quando a condição "(NÃO X)" for verdadeira.

Nessa questão, X começa como "Falso", na primeira interação o valor de X é modificado para "Verdadeiro", porém o que deve ser verdadeiro para sair é "(NÃO X)". Dessa forma será realizada uma segunda interação, e ao fim do laço, agora com o valor de X igual a "Falso" o laço é finalizado.