Desafio C#

Analisando listas com list patterns

Enunciado

Crie um método que receba um array de inteiros e use list patterns para identificar: se está vazio, se tem um elemento, se começa com 0 e termina com 0, se é uma sequência de três elementos crescentes, ou qualquer outro caso. Imprima uma descrição para cada array testado.

Requisitos

  • Use list patterns com [], [var x], [0, .., 0] e [var a, var b, var c] com condição a < b && b < c.
  • Inclua um caso padrão para arrays que não se encaixam.
  • Teste pelo menos quatro arrays diferentes, incluindo um vazio e um de três elementos crescentes.
  • O programa deve compilar e rodar sem erros.

Código inicial

using System;

public class Program
{
    public static void Main()
    {
        int[][] arrays = {
            new int[0],
            new[] { 5 },
            new[] { 0, 1, 2, 0 },
            new[] { 1, 2, 3 },
            new[] { 9, 8, 7 }
        };

        // Seu código aqui
    }
}

Saída esperada

Array vazio
Um elemento: 5
Começa e termina com 0
Três elementos crescentes: 1, 2, 3
Outro caso: [9, 8, 7]
Ver dica

Use array switch { [] => ..., [var x] => ..., [0, .., 0] => ..., [var a, var b, var c] when a < b && b < c => ..., _ => ... }.

Mostrar solução 
using System;

public class Program
{
    public static void Main()
    {
        int[][] arrays = {
            new int[0],
            new[] { 5 },
            new[] { 0, 1, 2, 0 },
            new[] { 1, 2, 3 },
            new[] { 9, 8, 7 }
        };

        foreach (var array in arrays)
        {
            // Switch expression com list patterns
            string descricao = array switch
            {
                [] => "Array vazio",
                [var x] => $"Um elemento: {x}",
                [0, .., 0] => "Começa e termina com 0",
                [var a, var b, var c] when a < b && b < c => $"Três elementos crescentes: {a}, {b}, {c}",
                _ => $"Outro caso: [{string.Join(", ", array)}]"
            };

            Console.WriteLine(descricao);
        }
    }
}

Passo a passo

  1. Criamos um array de arrays (int[][]) com cinco casos de teste.
  2. No foreach, usamos uma switch expression que testa o array atual.
  3. O padrão [] corresponde a um array vazio.
  4. O padrão [var x] corresponde a um array com exatamente um elemento, capturando-o em x.
  5. O padrão [0, .., 0] corresponde a arrays que começam e terminam com 0, ignorando o miolo com ...
  6. O padrão [var a, var b, var c] when a < b && b < c captura três elementos e usa uma cláusula when para exigir que sejam crescentes.
  7. O padrão _ é o fallback para arrays que não se encaixam em nenhum caso anterior.
  8. Cada caso retorna uma string descritiva, que é impressa no console.

Por que funciona

List patterns permitem casar sequências por posição e quantidade. O padrão .. (slice pattern) ignora zero ou mais elementos, o que é útil para verificar apenas as extremidades. A cláusula when adiciona uma condição extra após a correspondência estrutural. A switch expression avalia os casos em ordem e retorna o primeiro que corresponder.

Erros comuns

  • Ordem dos casos: se [var a, var b, var c] viesse antes de [0, .., 0], um array [0, 1, 2, 0] não casaria com três elementos, mas se fosse [0, 1, 0] casaria com ambos. Coloque padrões mais específicos primeiro.
  • Esquecer o when: sem a condição a < b && b < c, o padrão [var a, var b, var c] casaria com qualquer array de três elementos, incluindo [9, 8, 7].
  • Usar .. fora de list patterns: .. só é válido dentro de list patterns; em outros contextos, use Range (array[1..^1]).
  • Tentar usar list patterns em List<T> sem Count e indexador: list patterns funcionam com tipos que têm Length ou Count e um indexador this[int]. List<T> atende, mas arrays são mais diretos.

Outra forma de resolver

Usar if/else com list patterns:

if (array is []) Console.WriteLine("Array vazio");
else if (array is [var x]) Console.WriteLine($"Um elemento: {x}");
// ...

A switch expression é preferível por ser mais concisa e expressar a intenção de classificação.

Saída esperada

Array vazio
Um elemento: 5
Começa e termina com 0
Três elementos crescentes: 1, 2, 3
Outro caso: [9, 8, 7]