DEV Community: André Plöger

Finding Double Existence and Applying Luhn's Algorithm

André Plöger — Fri, 11 Oct 2024 19:50:50 +0000

In this article, we will address two engaging tasks from the Perl Weekly Challenge #290: checking for double existence in an array and implementing Luhn's Algorithm for validation. We'll implement solutions in both Perl and Go.

Double Existence
Luhn's Algorithm
Conclusion

Double Existence

The first task involves finding if there exist two indices $i and $j such that:

1. $i != $j
2. 0 <= ($i, $j) < scalar @ints
3. $ints[i] = 2 * $ints[j]

Task Description

Input: An array of integers, @ints.

Output: true if the condition is met; otherwise, false.

Examples:

Input: @ints = (6, 2, 3, 3)
Output: true

For $i = 0, $j = 2
$ints[$i] = 6 => 2 * 3 =>  2 * $ints[$j]

Input: @ints = (3, 1, 4, 13)
Output: false

Input: @ints = (2, 1, 4, 2)
Output: true

For $i = 2, $j = 3
$ints[$i] = 4 => 2 * 2 =>  2 * $ints[$j]

Solution

Perl Implementation
In the Perl implementation, we use a hash to track seen integers and check if either half or double of the current number exists in the hash.

sub double_exist {
    my %seen;

    foreach my $num (@_) {
        return 1 if exists $seen{$num / 2} || exists $seen{$num * 2};
        $seen{$num} = 1;
    }

    return 0;
}

Go Implementation
The Go implementation follows a similar logic, using a map to keep track of unique integers.

func doubleExist(ints []int) bool {
    seen := make(map[int]bool)

    for _, num := range ints {
        if (num%2 == 0 && seen[num/2]) || seen[num*2] {
            return true
        }
        seen[num] = true
    }

    return false
}

Luhn's Algorithm

The second task involves implementing Luhn's Algorithm to validate a string of digits, ignoring non-digit characters. The last digit is considered separately as the payload.

Task Description

You are given a string str containing digits (and possibly other characters which can be ignored). The last digit is considered as the payload and handled separately.

Counting from the right, double the value of the first, third, etc., of the remaining digits.
For each value now greater than 9, sum its digits.
The correct check digit is the one that, when added to the sum of all values, brings the total modulo 10 to zero.

Return true if the payload equals the correct check digit; otherwise, return false.

Examples:

Input: "17893729974"
Output: true

Payload is 4.

Digits from the right:

7 * 2 = 14, sum = 5
9 = 9
9 * 2 = 18, sum = 9
2 = 2
7 * 2 = 14, sum = 5
3 = 3
9 * 2 = 18, sum = 9
8 = 8
7 * 2 = 14, sum = 5
1 = 1

Sum of all values = 56, so 4 must be added to bring the total mod 10 to zero. The payload is indeed 4.

Input: "4137 8947 1175 5904"
Output: true

Input: "4137 8974 1175 5904"
Output: false

Solution

Perl Implementation
The Perl implementation processes the input string to ignore non-digit characters, then applies Luhn's algorithm to validate the number.

sub luhn_check {
    my ($str) = @_;
    $str =~ s/[^0-9]//g;

    my $payload = substr($str, -1);
    my $sum = 0;
    my $length = length($str);

    for (my $i = 0; $i < $length - 1; $i++) {
        my $digit = substr($str, $length - 2 - $i, 1);
        if ($i % 2 == 0) {
            $digit *= 2;
            $digit -= 9 if $digit > 9;
        }
        $sum += $digit;
    }

    my $check_digit = (10 - ($sum % 10)) % 10;

    return $payload == $check_digit ? 1 : 0;
}

Go Implementation
The Go version implements the same logic, utilizing the unicode package to filter out non-digit characters.

func luhnCheck(str string) bool {
    sum := 0
    payload := 0
    digits := []int{}

    for _, char := range str {
        if unicode.IsDigit(char) {
            digit := int(char - '0')
            digits = append(digits, digit)
        }
    }

    if len(digits) == 0 {
        return false
    }

    payload = digits[len(digits)-1]

    for i := 0; i < len(digits)-1; i++ {
        digit := digits[i]
        if (len(digits)-2-i)%2 == 0 {
            digit *= 2
            if digit > 9 {
                digit -= 9
            }
        }
        sum += digit
    }

    checkDigit := (10 - (sum % 10)) % 10

    return payload == checkDigit
}

Conclusion

In this article, we explored two interesting programming challenges: finding double existence in an array and implementing Luhn's Algorithm for validation. These tasks highlight how different programming languages can tackle similar problems with their own unique approaches. I hope these examples inspire you to delve deeper into both Perl and Go!

You can find the complete code, including tests, on GitHub.

Data Transformations: Third Maximum and Jumbled Letters

André Plöger — Sat, 05 Oct 2024 01:43:45 +0000

In this article, we will address two engaging tasks from the Perl Weekly Challenge #289: finding the third distinct maximum in an array and scrambling the letters of words in a text while keeping the first and last letters in place. We'll implement solutions in both Perl and Go.

Third Maximum
Jumbled Letters
Conclusion

Third Maximum

The first task involves finding the third distinct maximum in a given array of integers. If the third maximum doesn't exist, the function should return the maximum number.

Task Description

Input: An array of integers, @ints.

Output: The third distinct maximum or the maximum number if the third maximum doesn't exist.

Examples

Input: @ints = (5, 6, 4, 1)
Output: 4
(The distinct maximums are 6, 5, and 4.)
Input: @ints = (4, 5)
Output: 5
(The third maximum doesn't exist.)
Input: @ints = (1, 2, 2, 3)
Output: 1
(The distinct maximums are 3, 2, and 1.)

Solution

Perl Implementation

In this implementation, we create a set of unique values and then sort them in descending order to easily find the third maximum.

sub third_maximum {
    my @ints = @_;

    my %unique = map { $_ => 1 } @ints;
    my @distinct = sort { $b <=> $a } keys %unique;

    return @distinct >= 3 ? $distinct[2] : $distinct[0];
}

Go Implementation

The Go implementation follows a similar logic, using a map to capture unique integers and then sorting them.

func thirdMax(ints []int) (int, error) {
    if len(ints) == 0 {
        return 0, errors.New("input slice is empty")
    }

    unique := make(map[int]struct{})
    for _, num := range ints {
        unique[num] = struct{}{}
    }

    numsSorted := make([]int, 0, len(unique))
    for num := range unique {
        numsSorted = append(numsSorted, num)
    }

    sort.Slice(numsSorted, func(i, j int) bool {
        return numsSorted[i] > numsSorted[j]
    })

    if len(numsSorted) >= 3 {
        return numsSorted[2], nil
    }
    return numsSorted[0], nil
}

Jumbled Letters

The second task involves scrambling the letters of each word in a given text while ensuring that the first and last letters remain in place. Whitespace and punctuation should also be preserved.

Task Description

Input: A text string.

Output: A jumbled version of the input text.

Examples

Input: "According to a research at Cambridge University, it doesn't matter in what order the letters in a word are."
Output: (e.g.) "Acordnig to a reserach at Cmbraidge Uinversity, it dsoen't mtater in waht oder the ltteers in a wrod are." (The letters in each word are randomly rearranged, with the first and last letters unchanged.)

Solution

Perl Implementation

For this task, we define two functions:

jumble_word: This function takes a word as input and scrambles the letters in the middle, while keeping the first and last letters intact. If the word is 3 letters or fewer, it is returned unchanged. For shuffling he letters we use Perl's List::Util module.
jumble_text: This function processes a full text string, splitting it into words while preserving whitespace and punctuation. It applies the jumble_word function to each word, ensuring that only the words are scrambled.

use List::Util 'shuffle';

sub jumble_word {
    my ($word) = @_;

    return $word if length($word) <= 3;

    my $middle  = substr($word, 1, -1);
    my @m_chars = split('', $middle);
    @m_chars    = shuffle(@m_chars);

    my $subst = join('', @m_chars);
    substr($word, 1, -1, $subst);

    return $word;
}

sub jumble_text {
    my ($text) = @_;

    my @tokens = split(/(\W+|_)/, $text);

    for my $token (@tokens) {
        if ($token =~ /^[A-Za-z]+$/) {
            $token = jumble_word($token);
        }
    }

    return join('', @tokens);
}

Go Implementation

The Go implementation adopts a similar approach, utilizing the math/rand package for shuffling the letters,

package main

import (
    "math/rand"
    "regexp"
    "strings"
    "time"
)

func jumbleWord(word string) string {
    if len(word) <= 3 {
        return word
    }

    middle := word[1 : len(word)-1]
    chars := []rune(middle)

    rand.Seed(time.Now().UnixNano())
    rand.Shuffle(len(chars), func(i, j int) {
        chars[i], chars[j] = chars[j], chars[i]
    })

    return string(word[0]) + string(chars) + string(word[len(word)-1])
}

func jumbleText(text string) string {
    re := regexp.MustCompile(`(\W+|_)`)
    tokens := re.Split(text, -1)
    nonWordTokens := re.FindAllString(text, -1)

    var result []string

    for i, token := range tokens {
        if isAlpha(token) {
            result = append(result, jumbleWord(token))
        }
        if i < len(nonWordTokens) {
            result = append(result, nonWordTokens[i])
        }
    }

    return strings.Join(result, "")
}

func isAlpha(s string) bool {
    re := regexp.MustCompile(`^[A-Za-z]+$`)
    return re.MatchString(s)
}

Conclusion

In this article, we explored two fun coding challenges: finding the third distinct maximum in an array and scrambling letters in a text. These tasks illustrate how different programming languages approach similar problems, each with its own strengths and methodologies. I hope these examples inspire you to tackle similar challenges and explore the capabilities of Perl and Go further!

You can find the complete code, including tests, on GitHub.

Diving Deep: Recursive Solutions for Palindromes and Contiguous Blocks

André Plöger — Wed, 25 Sep 2024 20:15:51 +0000

In this article, we will tackle two tasks from the Perl Weekly Challenge #288: finding the closest palindrome and determining the size of the largest contiguous block in a matrix. Both solutions will be implemented recursively in Perl and Go.

Closest Palindrome
Contiguous Block
Conclusion

Closest Palindrome

The first task is to find the closest palindrome that does not include itself.

The closest palindrome is defined as the one that minimizes the absolute difference between two integers.

If there are multiple candidates, the smallest one should be returned.

Task Description

Input: A string, $str, which represents an integer.

Output: The closest palindrome as a string.

Examples

Input: "123"
Output: "121"
Input: "2"
Output: "1"
There are two closest palindromes: "1" and "3". Therefore, we return the smallest "1".
Input: "1400"
Output: "1441"
Input: "1001"
Output: "999"

Solution

Perl Implementation

In this implementation, we utilize a recursive approach to find the closest palindrome that is not equal to the original number. The recursive function explores both lower and upper bounds around the original number:

It checks if the current candidates (lower and upper) are valid palindromes (and not equal to the original).
If neither candidate is valid, the function recursively decrements the lower candidate and increments the upper candidate until it finds a valid palindrome.

This recursive strategy effectively narrows down the search space, ensuring that we identify the closest palindrome while adhering to the problem's constraints.

sub is_palindrome {
    my ($num) = @_;
    return $num eq reverse($num);
}

sub find_closest {
    my ($lower, $upper, $original) = @_;
    return $lower if is_palindrome($lower) && $lower != $original;
    return $upper if is_palindrome($upper) && $upper != $original;
    return find_closest($lower - 1, $upper + 1, $original) if $lower > 0;
    return $upper + 1;
}

sub closest_palindrome {
    my ($str) = @_;
    my $num = int($str);
    return find_closest($num - 1, $num + 1, $num);
}

Go Implementation

The Go implementation follows a similar recursive strategy. It also checks the candidates around the original number, using recursion to adjust the bounds until a valid palindrome is found.

package main

import (
    "strconv"
)

func isPalindrome(num int) bool {
    reversed := 0
    original := num

    for num > 0 {
        digit := num % 10
        reversed = reversed*10 + digit
        num /= 10
    }

    return original == reversed
}

func findClosest(lower, upper, original int) string {
    switch {
        case isPalindrome(lower) && lower != original:
            return strconv.Itoa(lower)
        case isPalindrome(upper) && upper != original:
            return strconv.Itoa(upper)
        case lower > 0:
            return findClosest(lower-1, upper+1, original)
        default:
            return strconv.Itoa(upper + 1)
    }
}

func closestPalindrome(str string) string {
    num, _ := strconv.Atoi(str)
    return findClosest(num-1, num+1, num)
}

Contiguous Block

The second task is to determine the size of the largest contiguous block in a given matrix, where all cells contain either x or o.

A contiguous block consists of elements containing the same symbol that share an edge (not just a corner) with other elements in the block, creating a connected area.

Task Description

Input: A rectangular matrix containing x and o.

Output: The size of the largest contiguous block.

Examples

Input:

    [
        ['x', 'x', 'x', 'x', 'o'],
        ['x', 'o', 'o', 'o', 'o'],
        ['x', 'o', 'o', 'o', 'o'],
        ['x', 'x', 'x', 'o', 'o'],
    ]

Output: 11
There is a block of 9 contiguous cells containing x and a block of 11 contiguous cells containing o.

Input:

    [
        ['x', 'x', 'x', 'x', 'x'],
        ['x', 'o', 'o', 'o', 'o'],
        ['x', 'x', 'x', 'x', 'o'],
        ['x', 'o', 'o', 'o', 'o'],
    ]

Output: 11
There is a block of 11 contiguous cells containing x and a block of 9 contiguous cells containing o.

Input:

    [
        ['x', 'x', 'x', 'o', 'o'],
        ['o', 'o', 'o', 'x', 'x'],
        ['o', 'x', 'x', 'o', 'o'],
        ['o', 'o', 'o', 'x', 'x'],
    ]

Output: 7
There is a block of 7 contiguous cells containing o, two other 2-cell blocks of o, three 2-cell blocks of x and one 3-cell block of x.

Solution

Perl Implementation

In this implementation, we utilize a recursive depth-first search (DFS) approach to determine the size of the largest contiguous block in a matrix. The main function initializes a visited matrix to track which cells have been explored. It iterates through each cell, invoking the recursive DFS function whenever it encounters an unvisited cell.

The DFS function explores all four possible directions (up, down, left, right) from the current cell. It counts the size of the contiguous block by recursively calling itself on neighboring cells that share the same symbol and have not been visited. This recursive method effectively aggregates the size of the block while ensuring that each cell is only counted once.

sub largest_contiguous_block {
    my ($matrix) = @_;
    my $rows = @$matrix;
    my $cols = @{$matrix->[0]};
    my @visited = map { [(0) x $cols] } 1..$rows;

    my $max_size = 0;

    for my $r (0 .. $rows - 1) {
        for my $c (0 .. $cols - 1) {
            my $symbol = $matrix->[$r][$c];
            my $size = dfs($matrix, \@visited, $r, $c, $symbol);
            $max_size = $size if $size > $max_size;
        }
    }

    return $max_size;
}

sub dfs {
    my ($matrix, $visited, $row, $col, $symbol) = @_;

    return 0 if $row < 0 || $row >= @$matrix || $col < 0 || $col >= @{$matrix->[0]}
                || $visited->[$row][$col] || $matrix->[$row][$col] ne $symbol;

    $visited->[$row][$col] = 1;
    my $count = 1;

    $count += dfs($matrix, $visited, $row + 1, $col, $symbol);
    $count += dfs($matrix, $visited, $row - 1, $col, $symbol);
    $count += dfs($matrix, $visited, $row, $col + 1, $symbol);
    $count += dfs($matrix, $visited, $row, $col - 1, $symbol);

    return $count;
}

Go Implementation

The Go implementation mirrors this recursive DFS strategy. It similarly traverses the matrix and uses recursion to explore contiguous cells with the same symbol.

package main

func largestContiguousBlock(matrix [][]rune) int {
    rows := len(matrix)
    if rows == 0 {
        return 0
    }
    cols := len(matrix[0])
    visited := make([][]bool, rows)
    for i := range visited {
        visited[i] = make([]bool, cols)
    }

    maxSize := 0

    for r := 0; r < rows; r++ {
        for c := 0; c < cols; c++ {
            symbol := matrix[r][c]
            size := dfs(matrix, visited, r, c, symbol)
            if size > maxSize {
                maxSize = size
            }
        }
    }

    return maxSize
}

func dfs(matrix [][]rune, visited [][]bool, row, col int, symbol rune) int {
    if row < 0 || row >= len(matrix) || col < 0 || col >= len(matrix[0]) ||
        visited[row][col] || matrix[row][col] != symbol {
        return 0
    }

    visited[row][col] = true
    count := 1

    count += dfs(matrix, visited, row+1, col, symbol)
    count += dfs(matrix, visited, row-1, col, symbol)
    count += dfs(matrix, visited, row, col+1, symbol)
    count += dfs(matrix, visited, row, col-1, symbol)

    return count
}

Conclusion

In this article, we explored two intriguing challenges from the Perl Weekly Challenge #288: finding the closest palindrome and determining the size of the largest contiguous block in a matrix.

For the first task, both the Perl and Go implementations effectively utilized recursion to navigate around the original number, ensuring the closest palindrome was found efficiently.

In the second task, the recursive depth-first search approach in both languages allowed for a thorough exploration of the matrix, resulting in an accurate count of the largest contiguous block of identical symbols.

These challenges highlight the versatility of recursion as a powerful tool in solving algorithmic problems, showcasing its effectiveness in both Perl and Go. If you're interested in further exploration or have any questions, feel free to reach out!

You can find the complete code, including tests, on GitHub.

Exploring Password Strength and Number Validation in Perl and Go

André Plöger — Mon, 23 Sep 2024 15:15:41 +0000

In this article, I will tackle two challenges from the Perl Weekly Challenge #287: strengthening weak passwords and validating numbers. I will provide solutions for both tasks, showcasing implementations in Perl and Go.

Strengthening Weak Passwords
Validating Numbers
Conclusion

Strengthening Weak Passwords

The first task is to determine the minimum number of changes needed to make a password strong. The criteria for a strong password are:

It has at least 6 characters.
It contains at least one lowercase letter, one uppercase letter, and one digit.
It does not contain three consecutive identical characters.

Examples

Input: "a" → Output: 5
Input: "aB2" → Output: 3
Input: "PaaSW0rd" → Output: 0
Input: "Paaasw0rd" → Output: 1
Input: "aaaaa" → Output: 2

The Solution

Perl Implementation

#!/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 < 6) ? max(6 - $length, $types_needed) : $types_needed + $repeats;
}

1;

Tests for the Perl Implementation

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();

Go Implementation

package main

import (
    "regexp"
)

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

    for i := 1; i < len(password); i++ {
        if password[i] == password[i-1] {
            count++
        } else {
            repeats += count / 3
            count = 1
        }
    }
    repeats += count / 3
    return repeats
}

func minimumStepsToStrongPassword(password string) int {
    length := len(password)

    // Use regex to check for character types
    hasLower := regexp.MustCompile(`[a-z]`).MatchString(password)
    hasUpper := regexp.MustCompile(`[A-Z]`).MatchString(password)
    hasDigit := regexp.MustCompile(`\d`).MatchString(password)

    // Calculate the number of types needed
    typesNeeded := boolToInt(!hasLower) + boolToInt(!hasUpper) + boolToInt(!hasDigit)

    repeats := countRepeats(password)

    // Return the minimum steps based on the length of the password
    if length < 6 {
        return max(6-length, typesNeeded)
    }
    return typesNeeded + repeats
}


func boolToInt(b bool) int {
    if b {
        return 1
    }
    return 0
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

Tests for the Go Implementation

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)
        }
    }
}

Validating Numbers

The second task involves validating numbers. The goal is to determine whether a given string represents a valid number. The criteria for a valid number are:

An integer optionally followed by exponential notation.
A decimal number optionally followed by exponential notation.
An integer may optionally have a sign (- or +) followed by digits.

Examples

Input: "1" → Output: true
Input: "a" → Output: false
Input: "." → Output: false
Input: "1.2e4.2" → Output: false
Input: "-1." → Output: true
Input: "+1E-8" → Output: true
Input: ".44" → Output: true

The Solution

Perl Implementation

#!/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 for the Perl Implementation

#!/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();

Go Implementation

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 for the Go Implementation

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

These solutions provide effective methods for evaluating password strength and validating the correctness of numbers. The complete code for both tasks is available on GitHub.

DEV Community: André Plöger

Finding Double Existence and Applying Luhn's Algorithm

Table of Contents

Double Existence

Task Description

Solution

Luhn's Algorithm

Task Description

Solution

Conclusion

Data Transformations: Third Maximum and Jumbled Letters

Table of Contents

Third Maximum

Task Description

Examples

Solution

Perl Implementation

Go Implementation

Jumbled Letters

Task Description

Examples

Solution

Perl Implementation

Go Implementation

Conclusion

Diving Deep: Recursive Solutions for Palindromes and Contiguous Blocks

Table of Contents

Closest Palindrome

Task Description

Examples

Solution

Perl Implementation

Go Implementation

Contiguous Block

Task Description

Examples

Solution

Perl Implementation

Go Implementation

Conclusion

Exploring Password Strength and Number Validation in Perl and Go

Table of Contents

Strengthening Weak Passwords

Examples

The Solution

Perl Implementation

Tests for the Perl Implementation

Go Implementation

Tests for the Go Implementation

Validating Numbers

Examples

The Solution

Perl Implementation

Tests for the Perl Implementation

Go Implementation

Tests for the Go Implementation

Conclusion