Doppelexistenz finden und Luhns Algorithmus anwenden

In diesem Artikel befassen wir uns mit zwei spannenden Aufgaben aus der Perl Weekly Challenge #290: Überprüfung auf Doppelexistenz in einem Array und Implementierung des Luhn-Algorithmus zur Validierung. Wir implementieren Lösungen sowohl in Perl als auch in Go.

Inhaltsverzeichnis

• Doppelexistenz
• Luhns Algorithmus
• Fazit

Doppelte Existenz

Die erste Aufgabe besteht darin, herauszufinden, ob es zwei Indizes $i und $j gibt, sodass:

1. $i != $j
2. 0 <= ($i, $j) < scalar @ints
3. $ints[i] = 2 * $ints[j]

Aufgabenbeschreibung

Eingabe: Ein Array von Ganzzahlen, @ints.

Ausgabe: wahr, wenn die Bedingung erfüllt ist; andernfalls falsch.

Beispiele:

Input: @ints = (6, 2, 3, 3)
Output: true

For $i = 0, $j = 2
$ints[$i] = 6 => 2 * 3 =>  2 * $ints[$j]

Input: @ints = (3, 1, 4, 13)
Output: false

Input: @ints = (2, 1, 4, 2)
Output: true

For $i = 2, $j = 3
$ints[$i] = 4 => 2 * 2 =>  2 * $ints[$j]

Lösung

Perl-Implementierung
In der Perl-Implementierung verwenden wir einen Hash, um gesehene Ganzzahlen zu verfolgen und zu prüfen, ob im Hash entweder die Hälfte oder das Doppelte der aktuellen Zahl vorhanden ist.

sub double_exist {
    my %seen;

    foreach my $num (@_) {
        return 1 if exists $seen{$num / 2} || exists $seen{$num * 2};
        $seen{$num} = 1;
    }

    return 0;
}

Go-Implementierung
Die Go-Implementierung folgt einer ähnlichen Logik und verwendet eine Karte, um eindeutige Ganzzahlen zu verfolgen.

func doubleExist(ints []int) bool {
    seen := make(map[int]bool)

    for _, num := range ints {
        if (num%2 == 0 && seen[num/2]) || seen[num*2] {
            return true
        }
        seen[num] = true
    }

    return false
}

Luhns Algorithmus

Die zweite Aufgabe besteht darin, den Luhn-Algorithmus zu implementieren, um eine Ziffernfolge zu validieren und dabei nichtstellige Zeichen zu ignorieren. Die letzte Ziffer wird separat als Nutzlast betrachtet.

Aufgabenbeschreibung

Sie erhalten eine Zeichenfolge str, die Ziffern (und möglicherweise andere Zeichen, die ignoriert werden können) enthält. Die letzte Ziffer gilt als Nutzlast und wird separat behandelt.

1. Zählen Sie von rechts, verdoppeln Sie den Wert der ersten, dritten usw. der verbleibenden Ziffern.
2. Summieren Sie für jeden Wert, der jetzt größer als 9 ist, seine Ziffern.
3. Die richtige Prüfziffer ist diejenige, die, wenn sie zur Summe aller Werte addiert wird, das Gesamtmodulo 10 auf Null bringt.

Gibt „true“ zurück, wenn die Nutzlast der richtigen Prüfziffer entspricht; Andernfalls geben Sie false zurück.

Beispiele:

Input: "17893729974"
Output: true

Payload is 4.

Digits from the right:

7 * 2 = 14, sum = 5
9 = 9
9 * 2 = 18, sum = 9
2 = 2
7 * 2 = 14, sum = 5
3 = 3
9 * 2 = 18, sum = 9
8 = 8
7 * 2 = 14, sum = 5
1 = 1

Sum of all values = 56, so 4 must be added to bring the total mod 10 to zero. The payload is indeed 4.

Input: "4137 8947 1175 5904"
Output: true

Input: "4137 8974 1175 5904"
Output: false

Lösung

Perl-Implementierung
Die Perl-Implementierung verarbeitet die Eingabezeichenfolge, um nicht-stellige Zeichen zu ignorieren, und wendet dann den Luhn-Algorithmus an, um die Zahl zu validieren.

sub luhn_check {
    my ($str) = @_;
    $str =~ s/[^0-9]//g;

    my $payload = substr($str, -1);
    my $sum = 0;
    my $length = length($str);

    for (my $i = 0; $i < $length - 1; $i++) {
        my $digit = substr($str, $length - 2 - $i, 1);
        if ($i % 2 == 0) {
            $digit *= 2;
            $digit -= 9 if $digit > 9;
        }
        $sum += $digit;
    }

    my $check_digit = (10 - ($sum % 10)) % 10;

    return $payload == $check_digit ? 1 : 0;
}

Go-Implementierung
Die Go-Version implementiert die gleiche Logik und nutzt das Unicode-Paket, um nicht-stellige Zeichen herauszufiltern.

func luhnCheck(str string) bool {
    sum := 0
    payload := 0
    digits := []int{}

    for _, char := range str {
        if unicode.IsDigit(char) {
            digit := int(char - '0')
            digits = append(digits, digit)
        }
    }

    if len(digits) == 0 {
        return false
    }

    payload = digits[len(digits)-1]

    for i := 0; i < len(digits)-1; i++ {
        digit := digits[i]
        if (len(digits)-2-i)%2 == 0 {
            digit *= 2
            if digit > 9 {
                digit -= 9
            }
        }
        sum += digit
    }

    checkDigit := (10 - (sum % 10)) % 10

    return payload == checkDigit
}

Abschluss

In diesem Artikel haben wir zwei interessante Programmierherausforderungen untersucht: die Suche nach Doppelexistenzen in einem Array und die Implementierung des Luhn-Algorithmus zur Validierung. Diese Aufgaben verdeutlichen, wie verschiedene Programmiersprachen ähnliche Probleme mit ihren eigenen, einzigartigen Ansätzen lösen können. Ich hoffe, diese Beispiele inspirieren Sie dazu, tiefer in Perl und Go einzutauchen!

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

Das obige ist der detaillierte Inhalt vonDoppelexistenz finden und Luhns Algorithmus anwenden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!