En este artículo, abordaré dos desafíos del Perl Weekly Challenge #287: fortalecer contraseñas débiles y validar números. Proporcionaré soluciones para ambas tareas, mostrando implementaciones en Perl y Go.

Tabla de contenido

1. Fortalecimiento de contraseñas débiles
2. Validación de números
3. Conclusión

Fortalecimiento de contraseñas débiles

La primera tarea es determinar la cantidad mínima de cambios necesarios para hacer que una contraseña sea segura. Los criterios para una contraseña segura son:

1. Tiene al menos 6 caracteres.
2. Contiene al menos una letra minúscula, una letra mayúscula y un dígito.
3. No contiene tres caracteres idénticos consecutivos.

Ejemplos

• Entrada: "a" → Salida: 5
• Entrada: "aB2" → Salida: 3
• Entrada: "PaaSW0rd" → Salida: 0
• Entrada: "Paaasw0rd" → Salida: 1
• Entrada: "aaaaa" → Salida: 2

La solución

Implementación de 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 




  
  
  Pruebas para la implementación de 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();





  
  
  Ir Implementación




package main

import (
    "regexp"
)

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

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





  
  
  Pruebas para la implementación de 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)
        }
    }
}






  
  
  Validación de números


La segunda tarea consiste en validar números. El objetivo es determinar si una cadena determinada representa un número válido. Los criterios para un número válido son:

Un número entero seguido opcionalmente de notación exponencial.
Un número decimal seguido opcionalmente de notación exponencial.
Un número entero puede tener opcionalmente un signo (- o ) seguido de dígitos.

  
  
  Ejemplos

• Entrada: "1" → Salida: verdadero
• Entrada: "a" → Salida: falso
• Aporte: "." → Salida: falso
• Entrada: "1.2e4.2" → Salida: falso
• Entrada: "-1." → Salida: verdadero
• Entrada: " 1E-8" → Salida: verdadero
• Entrada: ".44" → Salida: verdadero

La solución

Implementación de 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;

Pruebas para la implementación de 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();

Ir Implementación

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
}

Pruebas para la implementación de 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)
        }
    }
}

Conclusión

Estas soluciones proporcionan métodos eficaces para evaluar la seguridad de la contraseña y validar la exactitud de los números. El código completo para ambas tareas está disponible en GitHub.