尋找雙重存在並應用 Luhn 演算法

在本文中，我們將解決 Perl Weekly Challenge #290 中的兩個引人入勝的任務：檢查數組中是否存在雙重存在並實現 Luhn 演算法進行驗證。我們將在 Perl 和 Go 中實現解決方案。

目錄

• 雙重存在
• 盧恩演算法
• 結論

雙重存在

第一個任務涉及尋找是否存在兩個索引 $i 和 $j 使得：

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

任務說明

輸入： 整數數組，@ints。

輸出： 若符合條件則為 true；否則，錯誤。

範例：

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]

解決方案

Perl 實作
在 Perl 實作中，我們使用哈希來追蹤看到的整數，並檢查哈希中是否存在當前數字的一半或兩倍。

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 實作
Go 實作遵循類似的邏輯，使用映射來追蹤唯一整數。

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
}

盧恩演算法

第二個任務涉及實施 Luhn 演算法來驗證數字字串，忽略非數字字元。最後一位數字被單獨視為有效負載。

任務說明

給你一個字串 str ，其中包含數字（可能還有其他可以忽略的字元）。最後一位數字被視為有效負載並單獨處理。

1. 從右邊數起，將剩餘數字的第一個、第三個等的值加倍。
2. 對於現在大於 9 的每個值，將其數字相加。
3. 正確的校驗位是當加到所有值的總和時，使總模 10 為零。

如果有效負載等於正確的校驗位，則傳回 true；否則，傳回 false。

範例：

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

解決方案

Perl 實作
Perl 實作處理輸入字串以忽略非數字字符，然後應用 Luhn 演算法來驗證數字。

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 實作
Go 版本實現了相同的邏輯，利用 unicode 包過濾掉非數字字元。

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
}

結論

在本文中，我們探討了兩個有趣的程式設計挑戰：尋找陣列中的雙重存在以及實作 Luhn 演算法進行驗證。這些任務強調了不同的程式語言如何用自己獨特的方法解決類似的問題。我希望這些範例能激勵您更深入地研究 Perl 和 Go！

您可以在 GitHub 上找到完整的程式碼，包括測試。

以上是尋找雙重存在並應用 Luhn 演算法的詳細內容。更多資訊請關注PHP中文網其他相關文章！