Data Transformations: Third Maximum and Jumbled Letters

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.

Table of Contents

1. Third Maximum
2. Jumbled Letters
3. 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:

1. 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.
2. 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.