数据转换：第三大字母和混乱字母-Golang-PHP中文网

Data Transformations: Third Maximum and Jumbled Letters

在本文中，我们将解决 Perl Weekly Challenge #289 中的两个引人入胜的任务：找到数组中的第三个不同的最大值，并打乱文本中单词的字母，同时保留第一个和最后一个字母到位。我们将在 Perl 和 Go 中实现解决方案。

第三个最大值

第一个任务涉及在给定的整数数组中查找第三个不同的最大值。如果第三个最大值不存在，该函数应返回最大数。

任务描述

输入： 整数数组，@ints。

输出： 第三个不同的最大值或最大数（如果第三个最大值不存在）。

示例

输入： @ints = (5, 6, 4, 1)
输出： 4
（不同的最大值为 6、5 和 4。）
输入： @ints = (4, 5)
输出： 5
（第三个最大值不存在。）
输入： @ints = (1, 2, 2, 3)
输出： 1
（不同的最大值为 3、2 和 1。）

解决方案

Perl 实现

在此实现中，我们创建一组唯一值，然后按降序对它们进行排序，以便轻松找到第三个最大值。


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 实现遵循类似的逻辑，使用映射来捕获唯一整数，然后对它们进行排序。


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
}

登录后复制

混乱的字母

第二个任务涉及打乱给定文本中每个单词的字母，同时确保第一个和最后一个字母保持在原位。空格和标点符号也应该保留。

任务描述

输入： 文本字符串。

输出：输入文本的混乱版本。

示例

输入：“根据剑桥大学的一项研究，单词中字母的顺序并不重要。”
输出：（例如）“根据 Cmbraidge 大学的一项研究，它与某一行中的内容无关。” （每个单词中的字母随机重新排列，第一个和最后一个字母不变。）

解决方案

Perl 实现

对于此任务，我们定义两个函数：

jumble_word：此函数将一个单词作为输入，并打乱中间的字母，同时保持第一个和最后一个字母完整。如果单词不超过 3 个字母，则原样返回。为了打乱字母，我们使用 Perl 的 List::Util 模块。
jumble_text：此函数处理全文字符串，将其拆分为单词，同时保留空格和标点符号。它将 jumble_word 函数应用于每个单词，确保只有单词被打乱。


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 实现采用了类似的方法，利用 math/rand 包来打乱字母，


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

登录后复制