Datentransformationen: Drittes Maximum und durcheinandergebrachte Buchstaben

In diesem Artikel befassen wir uns mit zwei spannenden Aufgaben aus der Perl Weekly Challenge #289: das Finden des dritten eindeutigen Maximums in einem Array und das Verschlüsseln der Buchstaben von Wörtern in einem Text unter Beibehaltung des erster und letzter Buchstabe vorhanden. Wir implementieren Lösungen sowohl in Perl als auch in Go.

Inhaltsverzeichnis

1. Drittes Maximum
2. Durcheinandergebrachte Buchstaben
3. Fazit

Drittes Maximum

Die erste Aufgabe besteht darin, das dritte eindeutige Maximum in einem bestimmten Array von ganzen Zahlen zu finden. Wenn das dritte Maximum nicht existiert, sollte die Funktion die maximale Anzahl zurückgeben.

Aufgabenbeschreibung

Eingabe: Ein Array von Ganzzahlen, @ints.

Ausgabe: Das dritte eindeutige Maximum oder die maximale Anzahl, wenn das dritte Maximum nicht existiert.

Beispiele

• Eingabe: @ints = (5, 6, 4, 1)
  Ausgabe: 4
  (Die eindeutigen Höchstwerte sind 6, 5 und 4.)

• Eingabe: @ints = (4, 5)
  Ausgabe: 5
  (Das dritte Maximum existiert nicht.)

• Eingabe: @ints = (1, 2, 2, 3)
  Ausgabe: 1
  (Die eindeutigen Höchstwerte sind 3, 2 und 1.)

Lösung

Perl-Implementierung

In dieser Implementierung erstellen wir eine Reihe eindeutiger Werte und sortieren sie dann in absteigender Reihenfolge, um das dritte Maximum leicht zu finden.

sub third_maximum {
    my @ints = @_;

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

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

Gehen Sie zur Implementierung

Die Go-Implementierung folgt einer ähnlichen Logik und verwendet eine Karte, um eindeutige Ganzzahlen zu erfassen und sie dann zu sortieren.

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
}

.

Durcheinandergebrachte Buchstaben

Die zweite Aufgabe besteht darin, die Buchstaben jedes Wortes in einem bestimmten Text zu verschlüsseln und dabei sicherzustellen, dass der erste und der letzte Buchstabe an ihrem Platz bleiben. Leerzeichen und Satzzeichen sollten ebenfalls erhalten bleiben.

Aufgabenbeschreibung

Eingabe: Eine Textzeichenfolge.

Ausgabe:Eine durcheinandergebrachte Version des Eingabetextes.

Beispiele

• Eingabe: „Laut einer Studie der Universität Cambridge spielt es keine Rolle, in welcher Reihenfolge die Buchstaben in einem Wort stehen.“
• Ausgabe: (z. B.) „Laut einer Forschung an der University of Cambridge ist es nicht wichtig, was oder die Lteer in einem Wrod sind.“ (Die Buchstaben in jedem Wort werden zufällig neu angeordnet, wobei der erste und der letzte Buchstabe unverändert bleiben.)

Lösung

Perl-Implementierung

Für diese Aufgabe definieren wir zwei Funktionen:

1. jumble_word: Diese Funktion nimmt ein Wort als Eingabe und vermischt die Buchstaben in der Mitte, während der erste und der letzte Buchstabe intakt bleiben. Wenn das Wort aus 3 oder weniger Buchstaben besteht, wird es unverändert zurückgegeben. Zum Mischen der Buchstaben verwenden wir Perls List::Util-Modul.
2. jumble_text: Diese Funktion verarbeitet eine vollständige Textzeichenfolge, teilt sie in Wörter auf und behält dabei Leerzeichen und Satzzeichen bei. Es wendet die jumble_word-Funktion auf jedes Wort an und stellt so sicher, dass nur die Wörter verschlüsselt werden.

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

.

Gehen Sie zur Implementierung

Die Go-Implementierung verfolgt einen ähnlichen Ansatz und nutzt das math/rand-Paket zum Mischen der Buchstaben

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

.

Abschluss

In diesem Artikel haben wir zwei unterhaltsame Codierungsherausforderungen untersucht: das Finden des dritten eindeutigen Maximums in einem Array und das Verschlüsseln von Buchstaben in einem Text. Diese Aufgaben veranschaulichen, wie verschiedene Programmiersprachen ähnliche Probleme angehen, jede mit ihren eigenen Stärken und Methoden. Ich hoffe, diese Beispiele inspirieren Sie dazu, ähnliche Herausforderungen anzugehen und die Möglichkeiten von Perl und Go weiter zu erkunden!

Den vollständigen Code, einschließlich Tests, finden Sie auf GitHub.

Das obige ist der detaillierte Inhalt vonDatentransformationen: Drittes Maximum und durcheinandergebrachte Buchstaben. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!