O primeiro elemento está no índice 0 e o terceiro está no índice 2. Para o último, use radiacao.Length - 1.

Console.WriteLine($"Primeiro dia: {radiacao[0]} uR/h");
Console.WriteLine($"Terceiro dia: {radiacao[2]} uR/h");
Console.WriteLine($"Último dia: {radiacao[radiacao.Length - 1]} uR/h");

Use um for crescente começando em 0 e indo enquanto i < radiacao.Length. Para mostrar o número do dia, use i + 1.

for (int i = 0; i < radiacao.Length; i++)
{
    Console.WriteLine($"Dia {i + 1}: {radiacao[i]} uR/h");
}

Use um for decrescente. Ele começa em radiacao.Length - 1, continua enquanto i >= 0 e diminui com i--.

for (int i = radiacao.Length - 1; i >= 0; i--)
{
    Console.WriteLine($"Dia {i + 1}: {radiacao[i]} uR/h");
}

Use dois for: o primeiro para preencher o array lendo cada valor informado pelo usuário; o segundo para percorrer o array acumulando a soma. A média é a soma dividida por consumo.Length.

Tanto a soma quanto a média devem ser double para preservar as casas decimais.

declarar array consumo[5]

para i de 0 até 4
    ler consumo[i]

soma = 0
para i de 0 até 4
    soma = soma + consumo[i]

media = soma / consumo.Length
exibir "Média: " + media

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

double[] consumo = new double[5];

for (int i = 0; i < consumo.Length; i++)
{
    Console.Write("Dia " + (i + 1) + ": ");
    consumo[i] = Convert.ToDouble(Console.ReadLine());
}

double soma = 0;
for (int i = 0; i < consumo.Length; i++)
{
    soma += consumo[i];
}

double media = soma / consumo.Length;
Console.WriteLine("Média: " + media + " litros");

Inicialize maior = notas[0]. Percorra o array a partir do índice 1 (o índice 0 já foi usado como valor inicial). Para cada elemento, se ele for maior do que maior, atualize maior. Ao término do laço, maior conterá o maior valor do array.

ler notas[0..5]

maior = notas[0]
para i de 1 até 5
    se notas[i] > maior
        maior = notas[i]

exibir "Maior nota da redação: " + maior

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] notas = new int[6];

for (int i = 0; i < notas.Length; i++)
{
    Console.Write("Nota " + (i + 1) + ": ");
    notas[i] = Convert.ToInt32(Console.ReadLine());
}

int maior = notas[0];
for (int i = 1; i < notas.Length; i++)
{
    if (notas[i] > maior)
    {
        maior = notas[i];
    }
}

Console.WriteLine("Maior nota da redação: " + maior);

Este problema é muito parecido com o exercício anterior: você também precisa percorrer os valores para descobrir qual é o maior. A diferença é que agora não basta guardar apenas a pontuação; é necessário ter dois vetores para relacionar o nome do time com seus pontos.

Use dois arrays com o mesmo tamanho: string[] nomes e int[] pontos. O elemento de índice i em cada array corresponde ao mesmo time.

Para encontrar o campeão, não guarde o maior valor — guarde o índice do maior (indMaior). Comece com indMaior = 0 e atualize sempre que encontrar uma pontuação maior do que pontos[indMaior].

indMaior = 0
para i de 1 até 3
    se pontos[i] > pontos[indMaior]
        indMaior = i

exibir "Campeão: " + nomes[indMaior] + " com " + pontos[indMaior] + " pontos"

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

string[] nomes = { "Flamengo", "Palmeiras", "Atlético-MG", "Grêmio" };
int[] pontos = { 71, 68, 75, 60 };

int indMaior = 0;
for (int i = 1; i < pontos.Length; i++)
{
    if (pontos[i] > pontos[indMaior])
    {
        indMaior = i;
    }
}

Console.WriteLine("Campeão: " + nomes[indMaior] + " com " + pontos[indMaior] + " pontos");

O operador % (resto da divisão) permite verificar a paridade: se n % 2 == 0, o número é par; caso contrário, é ímpar. Declare dois contadores iniciados em zero e incremente o correto a cada iteração do laço.

declarar array numeros com 8 valores

pares = 0
impares = 0
para i de 0 até 7
    se numeros[i] % 2 == 0
        pares++
    senão
        impares++

exibir "Pares: " + pares
exibir "Ímpares: " + impares

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] numeros = { 12, 7, 4, 9, 10, 13, 8, 5 };

int pares = 0, impares = 0;

for (int i = 0; i < numeros.Length; i++)
{
    if (numeros[i] % 2 == 0)
        pares++;
    else
        impares++;
}

Console.WriteLine("Pares: "   + pares);
Console.WriteLine("Ímpares: " + impares);

Comece assumindo que é um palíndromo (bool palindromo = true). Percorra apenas os índices de 0 até v.Length / 2 - 1 (a primeira metade). Para cada posição i, compare v[i] com v[v.Length - 1 - i]. Se alguma comparação falhar, defina palindromo = false e interrompa o laço com break.

ler v[0..5]

palindromo = verdadeiro
para i de 0 até (v.Length / 2 - 1)
    se v[i] != v[v.Length - 1 - i]
        palindromo = falso
        parar

se palindromo
    exibir "É palíndromo."
senão
    exibir "Não é palíndromo."

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] v = new int[6];

for (int i = 0; i < v.Length; i++)
{
    Console.Write("Número " + (i + 1) + ": ");
    v[i] = Convert.ToInt32(Console.ReadLine());
}

bool palindromo = true;
for (int i = 0; i < v.Length / 2; i++)
{
    if (v[i] != v[v.Length - 1 - i])
    {
        palindromo = false;
        break;
    }
}

if (palindromo)
    Console.WriteLine("É palíndromo.");
else
    Console.WriteLine("Não é palíndromo.");

Um array pode funcionar como uma série de contadores. Declare int[] contagem = { 0, 0, 0, 0 }. Para cada nota lida, use um if/else if para decidir qual posição incrementar.

Verifique a faixa mais alta primeiro (>= 9) e desça até a mais baixa, ou use faixas bem delimitadas com &&.

int[] contagem = new int[4]  // zerado automaticamente

para cada nota lida
    se nota <= 4  → contagem[0]++
    se nota <= 6  → contagem[1]++
    se nota <= 8  → contagem[2]++
    senão          → contagem[3]++

exibir contagem[0], contagem[1], contagem[2], contagem[3]

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] contagem = new int[4];

for (int i = 0; i < 10; i++)
{
    Console.Write("Nota " + (i + 1) + ": ");
    int nota = Convert.ToInt32(Console.ReadLine());

    if (nota <= 4)
        contagem[0]++;
    else if (nota <= 6)
        contagem[1]++;
    else if (nota <= 8)
        contagem[2]++;
    else
        contagem[3]++;
}

Console.WriteLine("Insuficiente (0–4): " + contagem[0]);
Console.WriteLine("Regular (5–6): "      + contagem[1]);
Console.WriteLine("Bom (7–8): "          + contagem[2]);
Console.WriteLine("Ótimo (9–10): "       + contagem[3]);

A chave deste exercício é que cada elemento depende do elemento anterior: pot[i] = pot[i - 1] * 2. Por isso, atribua pot[0] = 2 antes do laço e comece o for a partir de i = 1. Sem o array, não seria possível calcular pot[6] sem ter calculado e guardado todos os anteriores.

pot[0] = 2
para i de 1 até 7
    pot[i] = pot[i - 1] * 2

para i de 0 até 7
    exibir "pot[" + i + "] = " + pot[i]

para i de 0 até 7
    se pot[i] > 100
        exibir "Primeiro acima de 100: " + pot[i] + " (posição " + i + ")"
        parar

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] pot = new int[8];
pot[0] = 2;
for (int i = 1; i < pot.Length; i++)
{
    pot[i] = pot[i - 1] * 2;
}

for (int i = 0; i < pot.Length; i++)
{
    Console.WriteLine("pot[" + i + "] = " + pot[i]);
}

for (int i = 0; i < pot.Length; i++)
{
    if (pot[i] > 100)
    {
        Console.WriteLine("Primeiro acima de 100: " + pot[i] + " (posição " + i + ")");
        break;
    }
}

A média só pode ser calculada depois que todos os HPs forem considerados. Por isso o array é indispensável: você precisa guardar os valores para fazer a segunda varredura de comparação.

Use dois arrays paralelos: nomes[i] e hp[i] guardam os dados do mesmo Pokémon. Ao encontrar um HP acima da média, use o mesmo índice i para acessar o nome correspondente.

declarar vetores nomes e hp

soma = 0
para i de 0 até hp.Length - 1 → soma += hp[i]
media = soma / hp.Length

exibir "Média de HP: " + media
para i de 0 até hp.Length - 1
    se hp[i] > media
        exibir nomes[i] + " (" + hp[i] + ")"

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

string[] nomes = { "Bulbasaur", "Charizard", "Pikachu", "Jigglypuff", "Snorlax",
                   "Gengar", "Machamp", "Onix", "Lapras", "Mewtwo" };
int[] hp = { 45, 78, 35, 115, 160, 60, 90, 35, 130, 106 };

double soma = 0;
for (int i = 0; i < hp.Length; i++)
    soma += hp[i];
double media = soma / hp.Length;

Console.WriteLine("Média de HP: " + media);
Console.WriteLine("Acima da média:");
for (int i = 0; i < nomes.Length; i++)
{
    if (hp[i] > media)
        Console.WriteLine("  " + nomes[i] + " (" + hp[i] + ")");
}

O deslocamento deve ser feito da direita para a esquerda: se você percorrer da esquerda para a direita, cada elemento sobrescreveria o próximo antes de ser copiado. O laço correto é:

for (int i = v.Length - 1; i > 0; i--)
{
    v[i] = v[i - 1];
}

Antes desse laço, salve v[v.Length - 1] em uma variável. Depois do laço, coloque essa variável em v[0].

ler v[0..4]
exibir "Antes: " + v

ultimo = v[v.Length - 1]
para i de (v.Length - 1) até 1, decrementando
    v[i] = v[i - 1]
v[0] = ultimo

exibir "Depois: " + v

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] v = new int[5];
for (int i = 0; i < v.Length; i++)
{
    Console.Write("Elemento " + (i + 1) + ": ");
    v[i] = Convert.ToInt32(Console.ReadLine());
}

Console.Write("Antes:  ");
for (int i = 0; i < v.Length; i++)
    Console.Write(v[i] + " ");
Console.WriteLine();

int ultimo = v[v.Length - 1];
for (int i = v.Length - 1; i > 0; i--)
{
    v[i] = v[i - 1];
}
v[0] = ultimo;

Console.Write("Depois: ");
for (int i = 0; i < v.Length; i++)
    Console.Write(v[i] + " ");
Console.WriteLine();

Para cada índice i (de 0 a 3), o elemento a[i] vai para a posição par do resultado e b[i] vai para a posição seguinte (ímpar). As posições pares são 0, 2, 4, 6 e as ímpares 1, 3, 5, 7 — exatamente 2*i e 2*i+1.

declarar a[4] e b[4]
declarar c[8]
para i de 0 até 3
    c[2 * i]     = a[i]
    c[2 * i + 1] = b[i]

exibir "Intercalado: " + c

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] a = { 1, 3, 5, 7 };
int[] b = { 2, 4, 6, 8 };

int[] c = new int[8];
for (int i = 0; i < 4; i++)
{
    c[2 * i]     = a[i];
    c[2 * i + 1] = b[i];
}

Console.Write("Intercalado: ");
for (int i = 0; i < c.Length; i++)
    Console.Write(c[i] + " ");
Console.WriteLine();

Para cada posição i, compare v[i] com todas as posições j onde j > i. Iniciar j em i + 1 evita comparar um elemento consigo mesmo e evita checar o mesmo par duas vezes.

Use uma variável bool encontrou = false. Ao encontrar a primeira duplicata, defina encontrou = true, salve o valor e use break para sair do laço interno. Use && !encontrou na condição do laço externo para sair também dele.

ler v[0..6]

encontrou = falso
duplicata = 0

para i de 0 até 6, enquanto !encontrou
    para j de (i+1) até 6
        se v[i] == v[j]
            duplicata = v[i]
            encontrou = verdadeiro
            parar laço interno

se encontrou
    exibir "Valor repetido: " + duplicata
senão
    exibir "Nenhum valor repetido."

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] v = new int[7];
for (int i = 0; i < v.Length; i++)
{
    Console.Write("Número " + (i + 1) + ": ");
    v[i] = Convert.ToInt32(Console.ReadLine());
}

bool encontrou = false;
int duplicata = 0;

for (int i = 0; i < v.Length && !encontrou; i++)
{
    for (int j = i + 1; j < v.Length; j++)
    {
        if (v[i] == v[j])
        {
            duplicata = v[i];
            encontrou = true;
            break;
        }
    }
}

if (encontrou)
    Console.WriteLine("Valor repetido: " + duplicata);
else
    Console.WriteLine("Nenhum valor repetido.");

Para calcular fib[i] você precisa de dois valores já guardados: fib[i-1] e fib[i-2]. Por isso o laço de construção começa em i = 2, após os dois valores iniciais serem atribuídos manualmente. Sem o array armazenando os elementos anteriores, o cálculo seria impossível.

fib[0] = 1
fib[1] = 1
para i de 2 até 9
    fib[i] = fib[i - 1] + fib[i - 2]

exibir "Sequência: "
para i de 0 até 9
    exibir fib[i] + " "

contador = 0
para i de 0 até 9
    se fib[i] < 30 → contador++

exibir "Menores que 30: " + contador

A solução será revelada em etapas. Tente completar cada passo antes de avançar.

int[] fib = new int[10];
fib[0] = 1;
fib[1] = 1;
for (int i = 2; i < fib.Length; i++)
{
    fib[i] = fib[i - 1] + fib[i - 2];
}

Console.Write("Sequência: ");
for (int i = 0; i < fib.Length; i++)
{
    Console.Write(fib[i] + " ");
}
Console.WriteLine();

int contador = 0;
for (int i = 0; i < fib.Length; i++)
{
    if (fib[i] < 30) contador++;
}
Console.WriteLine("Menores que 30: " + contador);