Gagnez avec des igits

Défi hebdomadaire 303 : Solutions Python et Perl

Le défi hebdomadaire de Mohammad S. Anwar propose un exercice de codage régulier. Mes solutions, présentées ci-dessous, sont initialement conçues en Python puis adaptées en Perl. Cette double approche améliore la maîtrise du codage.

Défi 303 : Solutions

Tâche 1 : Générer des entiers pairs à 3 chiffres

Description de la tâche :

Étant donné une liste d'entiers positifs, générez tous les entiers uniques, même à 3 chiffres, qui peuvent être formés à l'aide des chiffres de la liste.

Solution Python :

Cette solution Python exploite la fonction itertools.permutations pour générer efficacement toutes les combinaisons possibles à 3 chiffres. Un ensemble est utilisé pour maintenir l’unicité.

from itertools import permutations

def three_digits_even(ints: list) -> list:
    solution = set()
    for p in permutations(ints, 3):
        num_str = "".join(map(str, p))
        num = int(num_str)
        if num >= 100 and num % 2 == 0 and num_str[0] != '0':
            solution.add(num)
    return sorted(list(solution))

Solution Perl :

L'équivalent Perl utilise le module Algorithm::Permute pour les permutations et un hachage pour garantir l'unicité.

use Algorithm::Permute;
sub three_digits_even {
    my @ints = @_;
    my %seen;
    my @result;
    my $p = Algorithm::Permute->new(\@ints, 3);
    while (my @perm = $p->next) {
        my $num_str = join('', @perm);
        my $num = $num_str;
        if ($num >= 100 and $num % 2 == 0 and $num_str !~ /^0/) {
            push @result, $num unless $seen{$num}++;
        }
    }
    return sort {$a <=> $b} @result;
}

Exemples :

<code># Python
print(three_digits_even([2, 1, 3, 0]))  # Output: [102, 120, 130, 132, 210, 230, 302, 310, 312, 320]
print(three_digits_even([2, 2, 8, 8, 2])) # Output: [222, 228, 282, 288, 822, 828, 882]

# Perl
print "@{[three_digits_even(2, 1, 3, 0)]}\n"; # Output: 102 120 130 132 210 230 302 310 312 320
print "@{[three_digits_even(2, 2, 8, 8, 2)]}\n"; # Output: 222 228 282 288 822 828 882</code>

Tâche 2 : Supprimer et gagner

Description de la tâche :

Étant donné un tableau d'entiers, trouvez le nombre maximum de points que vous pouvez gagner en supprimant à plusieurs reprises un élément, en gagnant sa valeur, puis en supprimant tous les éléments avec des valeurs inférieures et une de plus que l'élément supprimé.

Solution Python :

Cette solution Python utilise un Counter pour suivre les fréquences des éléments et utilise une fonction récursive pour explorer différentes stratégies de suppression.

from collections import Counter

def delete_and_earn(ints: list) -> int:
    freq = Counter(ints)
    return max_score(freq)

def max_score(freq: Counter) -> int:
    max_points = 0
    for num in list(freq): # Iterate through a copy to safely delete
        points = num * freq[num]
        new_freq = freq.copy()
        del new_freq[num]
        if num - 1 in new_freq:
            del new_freq[num - 1]
        if num + 1 in new_freq:
            del new_freq[num + 1]
        max_points = max(max_points, points + (0 if not new_freq else max_score(new_freq)))
    return max_points

Solution Perl :

La solution Perl reflète l'approche Python en utilisant un hachage pour le comptage de fréquence et une fonction récursive.

sub delete_and_earn {
    my %freq = map { $_ => 1 + $freq{$_} // 0 } @_;
    return max_score(\%freq);
}

sub max_score {
    my $freq = shift;
    my $max_points = 0;
    foreach my $num (keys %$freq) {
        my $points = $num * $freq->{$num};
        my %new_freq = %$freq;
        delete $new_freq{$num};
        delete $new_freq{$num - 1};
        delete $new_freq{$num + 1};
        $max_points = max($max_points, $points + (0 || max_score(\%new_freq)));
    }
    return $max_points;
}

sub max {
    return shift if @_ == 1;
    return $_[0] > $_[1] ? $_[0] : $_[1];
}

Exemples :

<code># Python
print(delete_and_earn([3, 4, 2]))  # Output: 6
print(delete_and_earn([2, 2, 3, 3, 3, 4])) # Output: 9

# Perl
print delete_and_earn(3, 4, 2), "\n";  # Output: 6
print delete_and_earn(2, 2, 3, 3, 3, 4), "\n"; # Output: 9</code>

Ces solutions démontrent des approches efficaces et claires pour résoudre les deux tâches du Défi hebdomadaire 303. L'utilisation de Python et de Perl met en évidence la nature transférable de la résolution algorithmique de problèmes à travers différents langages de programmation.

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!