Transformations de données : troisième maximum et lettres confuses

Dans cet article, nous aborderons deux tâches intéressantes du Perl Weekly Challenge #289 : trouver le troisième maximum distinct dans un tableau et brouiller les lettres des mots dans un texte tout en gardant le première et dernière lettres en place. Nous mettrons en œuvre des solutions en Perl et Go.

Table des matières

1. Troisième maximum
2. Lettres mélangées
3. Conclusion

Troisième maximum

La première tâche consiste à trouver le troisième maximum distinct dans un tableau d'entiers donné. Si le troisième maximum n'existe pas, la fonction doit renvoyer le nombre maximum.

Description de la tâche

Entrée : Un tableau d'entiers, @ints.

Sortie : Le troisième maximum distinct ou le nombre maximum si le troisième maximum n'existe pas.

Exemples

• Entrée : @ints = (5, 6, 4, 1)
  Sortie : 4
  (Les maximums distincts sont 6, 5 et 4.)

• Entrée : @ints = (4, 5)
  Sortie : 5
  (Le troisième maximum n'existe pas.)

• Entrée : @ints = (1, 2, 2, 3)
  Sortie : 1
  (Les maximums distincts sont 3, 2 et 1.)

Solution

Implémentation Perl

Dans cette implémentation, nous créons un ensemble de valeurs uniques, puis les trions par ordre décroissant pour trouver facilement le troisième 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];
}

Aller à la mise en œuvre

L'implémentation Go suit une logique similaire, utilisant une carte pour capturer des entiers uniques puis les trier.

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
}

.

Lettres mélangées

La deuxième tâche consiste à brouiller les lettres de chaque mot dans un texte donné tout en veillant à ce que la première et la dernière lettre restent en place. Les espaces et la ponctuation doivent également être préservés.

Description de la tâche

Entrée : Une chaîne de texte.

Sortie : Une version confuse du texte saisi.

Exemples

• Entrée : "Selon une recherche menée à l'Université de Cambridge, l'ordre dans lequel se trouvent les lettres d'un mot n'a pas d'importance."
• Sortie : (par exemple) "D'après une recherche à l'Université Cmbraidge, cela n'a aucune importance quant à ce que sont les lettres dans un mot." (Les lettres de chaque mot sont réorganisées de manière aléatoire, la première et la dernière lettre étant inchangées.)

Solution

Implémentation Perl

Pour cette tâche, nous définissons deux fonctions :

1. jumble_word : Cette fonction prend un mot en entrée et brouille les lettres au milieu, tout en gardant intactes la première et la dernière lettre. Si le mot comporte 3 lettres ou moins, il est renvoyé inchangé. Pour mélanger les lettres, nous utilisons le module Perl's List::Util.
2. jumble_text : Cette fonction traite une chaîne de texte intégral, la divisant en mots tout en préservant les espaces et la ponctuation. Il applique la fonction jumble_word à chaque mot, garantissant que seuls les mots sont brouillés.

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

.

Aller à la mise en œuvre

L'implémentation Go adopte une approche similaire, en utilisant le package math/rand pour mélanger les lettres,

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

Dans cet article, nous avons exploré deux défis de codage amusants : trouver le troisième maximum distinct dans un tableau et brouiller les lettres dans un texte. Ces tâches illustrent comment différents langages de programmation abordent des problèmes similaires, chacun avec ses propres atouts et méthodologies. J'espère que ces exemples vous inciteront à relever des défis similaires et à explorer les capacités de Perl et d'aller plus loin !

Vous pouvez trouver le code complet, y compris les tests, sur GitHub.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!