This content originally appeared on DEV Community and was authored by André Plöger
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
- 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::Utilmodule. - 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.
This content originally appeared on DEV Community and was authored by André Plöger
André Plöger | Sciencx (2024-10-05T01:43:45+00:00) Data Transformations: Third Maximum and Jumbled Letters. Retrieved from https://www.scien.cx/2024/10/05/data-transformations-third-maximum-and-jumbled-letters/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.