Dans cet article, je vais aborder deux défis du Perl Weekly Challenge #287 : renforcer les mots de passe faibles et valider les chiffres. Je fournirai des solutions pour les deux tâches, en présentant les implémentations en Perl et Go.

Table des matières

1. Renforcement des mots de passe faibles
2. Validation des numéros
3. Conclusion

Renforcer les mots de passe faibles

La première tâche consiste à déterminer le nombre minimum de modifications nécessaires pour rendre un mot de passe fort. Les critères d'un mot de passe fort sont :

1. Il comporte au moins 6 caractères.
2. Il contient au moins une lettre minuscule, une lettre majuscule et un chiffre.
3. Il ne contient pas trois caractères identiques consécutifs.

Exemples

• Entrée : « a » → Sortie : 5
• Entrée : "aB2" → Sortie : 3
• Entrée : "PaaSW0rd" → Sortie : 0
• Entrée : « Paaasw0rd » → Sortie : 1
• Entrée : "aaaaa" → Sortie : 2

La solution

Implémentation Perl

#!/usr/bin/perl
use strict;
use warnings;
use List::Util 'max';

# Function to count groups of three or more repeating characters
sub count_repeats {
    my ($str) = @_;
    my $repeats = 0;

    # Find repeating characters and count the required changes
    while ($str =~ /(.)\1{2,}/g) {
        $repeats  = int(length($&) / 3);
    }

    return $repeats;
}

# Function to calculate the minimum steps to create a strong password
sub minimum_steps_to_strong_password {
    my ($str) = @_;
    my $length = length($str);

    # Check if the password contains the required character types
    my $has_lower = $str =~ /[a-z]/;
    my $has_upper = $str =~ /[A-Z]/;
    my $has_digit = $str =~ /\d/;

    # Calculate the number of types needed
    my $types_needed = !$has_lower   !$has_upper   !$has_digit;
    my $repeats = count_repeats($str);

    # Return the minimum steps based on the length of the password
    return ($length 




  
  
  Tests pour l'implémentation Perl




use strict;
use warnings;
use Test::More;
require "./ch-1.pl";

my @tests = (
    ["a", 5],
    ["aB2", 3],
    ["PaaSW0rd", 0],
    ["Paaasw0rd", 1],
    ["aaaaa", 2],
);

foreach my $test (@tests) {
    my ($input, $expected) = @$test;
    my $result = minimum_steps_to_strong_password($input);
    is($result, $expected, "Input: '$input'");
}

done_testing();





  
  
  Aller à la mise en œuvre




package main

import (
    "regexp"
)

func countRepeats(password string) int {
    repeats := 0
    count := 1

    for i := 1; i  b {
        return a
    }
    return b
}





  
  
  Tests pour l'implémentation Go




package main

import (
    "testing"
)

func TestMinimumStepsToStrongPassword(t *testing.T) {
    tests := []struct {
        password string
        expected int
    }{
        {"a", 5},
        {"aB2", 3},
        {"PaaSW0rd", 0},
        {"Paaasw0rd", 1},
        {"aaaaa", 2},
    }

    for _, test := range tests {
        result := minimumStepsToStrongPassword(test.password)
        if result != test.expected {
            t.Errorf("For password '%s', expected %d but got %d", test.password, test.expected, result)
        }
    }
}






  
  
  Validation des numéros


La deuxième tâche consiste à valider des chiffres. Le but est de déterminer si une chaîne donnée représente un nombre valide. Les critères pour un numéro valide sont :

Un entier éventuellement suivi d'une notation exponentielle.
Un nombre décimal éventuellement suivi d'une notation exponentielle.
Un entier peut éventuellement avoir un signe (- ou ) suivi de chiffres.

  
  
  Exemples

• Entrée : "1" → Sortie : vrai
• Entrée : "a" → Sortie : faux
• Saisir: "." → Sortie : faux
• Entrée : "1.2e4.2" → Sortie : faux
• Entrée : "-1." → Sortie : vrai
• Entrée : " 1E-8" → Sortie : vrai
• Entrée : ".44" → Sortie : vrai

La solution

Implémentation Perl

#!/usr/bin/perl
use strict;
use warnings;

sub is_valid_number {
    my ($str) = @_;

    # Regex for valid numbers
    my $regex = qr{
        ^            # Start of the string
        [ -]?        # Optional sign
        (?:          # Start of the number group
            \d       # Integer: at least one digit
            (?:      # Start of the optional decimal part
                \.   # Decimal point
                \d*  # Followed by zero or more digits
            )?       # Group is optional
            |        # or
            \.       # Just a decimal point
            \d       # Followed by one or more digits
        )            # End of the number group
        (?:          # Start of the optional exponent group
            [eE]     # 'e' or 'E'
            [ -]?    # Optional sign
            \d       # Followed by one or more digits
        )?           # Exponent is optional
        $            # End of the string
    }x;

    # Return 1 for valid, 0 for invalid
    return $str =~ $regex ? 1 : 0;
}

1;

Tests pour l'implémentation Perl

#!/usr/bin/perl
use strict;
use warnings;
use Test::More;

require './ch-2.pl';

# Define test cases
my @test_cases = (
    ["1", 1, 'Valid integer'],
    ["a", 0, 'Invalid input'],
    [".", 0, 'Single dot'],
    ["1.2e4.2", 0, 'Invalid exponent'],
    ["-1.", 1, 'Valid decimal'],
    [" 1E-8", 1, 'Valid scientific notation'],
    [".44", 1, 'Valid decimal starting with dot'],
);

# Loop through test cases and run tests
foreach my $case (@test_cases) {
    my $result = is_valid_number($case->[0]);
    is($result, $case->[1], $case->[2]);
}

done_testing();

Aller à la mise en œuvre

package main

import (
    "regexp"
)

// isValidNumber checks if the given string is a valid number.
func isValidNumber(str string) bool {
    regex := `^[ -]?((\d (\.\d*)?)|(\.\d ))([eE][ -]?\d )?$`
    matched, _ := regexp.MatchString(regex, str)
    return matched
}

Tests pour l'implémentation Go

package main

import (
    "testing"
)

func TestIsValidNumber(t *testing.T) {
    testCases := []struct {
        input    string
        expected bool
    }{
        {"1", true},
        {"a", false},
        {".", false},
        {"1.2e4.2", false},
        {"-1.", true},
        {" 1E-8", true},
        {".44", true},
    }

    for _, tc := range testCases {
        result := isValidNumber(tc.input)
        if result != tc.expected {
            t.Errorf("isValidNumber(%q) = %v; expected %v", tc.input, result, tc.expected)
        }
    }
}

Conclusion

Ces solutions fournissent des méthodes efficaces pour évaluer la force des mots de passe et valider l'exactitude des chiffres. Le code complet des deux tâches est disponible sur GitHub.