AoC &#Day Red-Nosed Reports (C# et Python)-Tutoriel Python-php.cn

AoC

La solution d'aujourd'hui était légèrement plus complexe que la veille, justifiant un peu plus de code, mais néanmoins assez simple.

Concepts de base de la solution :

Pour être valide, les conditions suivantes pour la partie 1 doivent être remplies :

Nous devons décider si les chiffres augmentent tous ou diminuent de l’un à l’autre.
l'écart entre les chiffres ne peut pas être supérieur à 3

Partie 1

var reports = File.ReadAllLines("./input1.txt")
    .Select(x => x.Split(" "))
    .ToList();

Part1(reports);

void Part1(List<string[]> input)
{
    var validReports = input
        .Select(report => report.Select(int.Parse).ToList())
        .Count(IsValidReport);

    Console.WriteLine(validReports);
}

bool IsValidReport(List<int> levels)
{
    // We don't care about the numbers, just wether going up or down, not both
    var isIncreasing = IsIncreasing(levels);
    var isDecreasing = IsDecreasing(levels);

    if (!isIncreasing && !isDecreasing) return false;

    // Check that all adjacent levels differ by at least 1 and at most 3
    for (var i = 0; i < levels.Count - 1; i++)
    {
        var diff = Math.Abs(levels[i + 1] - levels[i]);
        if (diff is < 1 or > 3)
        {
            return false;
        }
    }

    return true;
}

bool IsIncreasing(List<int> numbers)
{
    for (var i = 1; i < numbers.Count; i++)
    {
        if (numbers[i] < numbers[i - 1]) return false;
    }

    return true;
}

bool IsDecreasing(List<int> numbers)
{
    for (var i = 1; i < numbers.Count; i++)
    {
        if (numbers[i] > numbers[i - 1]) return false;
    }

    return true;
}

Copier après la connexion

Une explication simple est que nous utilisons LINQ pour analyser les numéros de chaîne en entiers avant de transmettre le rapport à notre méthode d'assistance IsValidReport().

Cette méthode vérifie si tous les nombres augmentent ou diminuent. Cela se fait en comparant les identifiants avec une liste ordonnée, cela prouvera que tous les nombres vont tous dans la même direction.

Une fois que nous savons qu'ils sont tous dans la même direction (pas le groupe), nous pouvons vérifier si chaque numéro est à moins de 3 chiffres l'un de l'autre. Utilisation de la méthode Math.Abs(), qui renvoie le nombre absolu, nous aidant à prendre en compte les chiffres négatifs.

Remarque : un nombre absolu est le nombre compris entre le nombre et zéro, c'est-à-dire -5 et 5 renverraient tous deux 5 ;

Partie 2

Pour la partie 2, nous avions des instructions légèrement plus complexes, mais cela semble plus difficile qu'il ne l'est.

La deuxième partie introduit la mise en garde concernant l'erreur humaine, avec le concept de base selon lequel vous devez savoir si vous pouvez supprimer un élément du rapport et il sera toujours considéré comme un rapport valide.

void Part2(List<string[]> input)
{
    var validReports = 0;

    foreach (var ints in input.Select(report => report.Select(int.Parse).ToList()))
    {
        // If valid as-is, count it
        if (IsValidReport(ints))
        {
            validReports++;
            continue;
        }

        // Check if removing any single level makes it valid
        if (ints.Select((t, i) => ints.Where((_, index) => index != i).ToList())
            .Any(IsValidReport))
        {
            validReports++;
        }
    }

    Console.WriteLine(validReports);
}

Copier après la connexion

Ici, nous maximisons la puissance de LINQ, en analysant les rapports de chaînes et en l'utilisant pour modifier le tableau ints. Nous modifions en parcourant le tableau et en supprimant l'élément actuel à l'index, modifiant ainsi le tableau d'entiers.

Une fois modifié, nous exécutons le rapport modifié via le validateur. Cela peut être fait en une seule fois en utilisant la méthode LINQ Select(), combinée avec Any() qui court-circuitera dès que la condition sera remplie (c'est-à-dire dès qu'un rapport modifié sera valide).

Pourquoi rechercher uniquement un seul rapport modifié valide ?

En effet, il indique que si un élément peut être supprimé, le rapport peut alors être considéré comme valide. Il ne précise pas un élément en particulier, donc dès que nous trouvons un élément correspondant qui, une fois supprimé, signifie que le rapport est valide, nous pouvons arrêter de regarder tous les autres.

Nous incrémentons ensuite le compteur validReports, pour garder une trace de nos rapports qui sont valides.

Voici ma tentative de conversion en Python :

def main():
    # Read the input file and split each line into a list of strings
    with open("./input1.txt") as file:
        reports = [line.split() for line in file]

    part1(reports)
    part2(reports)


def part1(reports):
    # Count valid reports using a list comprehension and the IsValidReport function

    valid_reports = 0
    for report in reports:
        levels = list(map(int, report))

        if is_valid_report(levels):
            valid_reports += 1

    print(valid_reports)


def part2(reports):
    valid_reports = 0

    for report in reports:
        ints = list(map(int, report))

        # If valid as-is, count it
        if is_valid_report(ints):
            valid_reports += 1
            continue

        # Check if removing any single level makes it valid
        valid_with_dampener = False

        # Iterate over each element in ints
        for i in range(len(ints)):
            # Create a new list without the element at index i
            modified_report = [x for j, x in enumerate(ints) if j != i]

            # Check if the modified report is valid
            if is_valid_report(modified_report):
                valid_with_dampener = True
                break

        if valid_with_dampener:
            valid_reports += 1

    print(valid_reports)


def is_valid_report(levels):
    # Check if the sequence is either all increasing or all decreasing
    is_increasing = is_increasing_sequence(levels)
    is_decreasing = is_decreasing_sequence(levels)

    if not is_increasing and not is_decreasing:
        return False

    # Check that all adjacent levels differ by at least 1 and at most 3
    for i in range(len(levels) - 1):
        diff = abs(levels[i + 1] - levels[i])
        if diff < 1 or diff > 3:
            return False

    return True


def is_increasing_sequence(numbers):
    for i in range(1, len(numbers)):
        if numbers[i] < numbers[i - 1]:
            return False
    return True


def is_decreasing_sequence(numbers):
    for i in range(1, len(numbers)):
        if numbers[i] > numbers[i - 1]:
            return False
    return True


if __name__ == "__main__":
    main()

Copier après la connexion

Pour une solution moins verbeuse, nous pourrions remplacer la boucle for interne de la partie 2 par la modification et la vérification , comme nous l'avons fait avec LINQ dans la solution C#, comme ceci :

var reports = File.ReadAllLines("./input1.txt")
    .Select(x => x.Split(" "))
    .ToList();

Part1(reports);

void Part1(List<string[]> input)
{
    var validReports = input
        .Select(report => report.Select(int.Parse).ToList())
        .Count(IsValidReport);

    Console.WriteLine(validReports);
}

bool IsValidReport(List<int> levels)
{
    // We don't care about the numbers, just wether going up or down, not both
    var isIncreasing = IsIncreasing(levels);
    var isDecreasing = IsDecreasing(levels);

    if (!isIncreasing && !isDecreasing) return false;

    // Check that all adjacent levels differ by at least 1 and at most 3
    for (var i = 0; i < levels.Count - 1; i++)
    {
        var diff = Math.Abs(levels[i + 1] - levels[i]);
        if (diff is < 1 or > 3)
        {
            return false;
        }
    }

    return true;
}

bool IsIncreasing(List<int> numbers)
{
    for (var i = 1; i < numbers.Count; i++)
    {
        if (numbers[i] < numbers[i - 1]) return false;
    }

    return true;
}

bool IsDecreasing(List<int> numbers)
{
    for (var i = 1; i < numbers.Count; i++)
    {
        if (numbers[i] > numbers[i - 1]) return false;
    }

    return true;
}

Copier après la connexion

Mais je pense que vous pouvez être d'accord, la méthode verbeuse avec des variables nommées plus joliment est beaucoup plus lisible.

Merci d'avoir lu, rejoignez-moi demain et, comme toujours, envoyez-moi un suivi sur Twitter

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!