Mencari Kewujudan Berganda dan Menggunakan Algoritma Luhn

Dalam artikel ini, kami akan menangani dua tugasan yang menarik daripada Cabaran Mingguan Perl #290: menyemak kewujudan berganda dalam tatasusunan dan melaksanakan Algoritma Luhn untuk pengesahan. Kami akan melaksanakan penyelesaian dalam kedua-dua Perl dan Go.

Jadual Kandungan

• Kewujudan Berganda
• Algoritma Luhn
• Kesimpulan

Wujud Berganda

Tugas pertama melibatkan mencari jika wujud dua indeks $i dan $j supaya:

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

Penerangan Tugas

Input: Tatasusunan integer, @ints.

Output: benar jika syarat dipenuhi; jika tidak, palsu.

Contoh:

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]

Penyelesaian

Pelaksanaan Perl
Dalam pelaksanaan Perl, kami menggunakan cincang untuk menjejak integer yang dilihat dan menyemak sama ada separuh atau dua kali ganda daripada nombor semasa wujud dalam cincang.

sub double_exist {
    my %seen;

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

    return 0;
}

Perlaksanaan Go
Pelaksanaan Go mengikut logik yang serupa, menggunakan peta untuk menjejaki integer unik.

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
}

Algoritma Luhn

Tugas kedua melibatkan pelaksanaan Algoritma Luhn untuk mengesahkan rentetan digit, mengabaikan aksara bukan digit. Digit terakhir dianggap secara berasingan sebagai muatan.

Penerangan Tugas

Anda diberi rentetan str yang mengandungi digit (dan mungkin aksara lain yang boleh diabaikan). Digit terakhir dianggap sebagai muatan dan dikendalikan secara berasingan.

1. Mengira dari kanan, dua kali ganda nilai pertama, ketiga, dsb., daripada digit yang tinggal.
2. Untuk setiap nilai yang kini lebih besar daripada 9, jumlahkan digitnya.
3. Digit semakan yang betul ialah digit yang, apabila ditambah pada jumlah semua nilai, menjadikan jumlah modulo 10 kepada sifar.

Kembalikan benar jika muatan sama dengan digit cek yang betul; jika tidak, pulangkan palsu.

Contoh:

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

Penyelesaian

Pelaksanaan Perl
Pelaksanaan Perl memproses rentetan input untuk mengabaikan aksara bukan digit, kemudian menggunakan algoritma Luhn untuk mengesahkan nombor.

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

Perlaksanaan Go
Versi Go melaksanakan logik yang sama, menggunakan pakej unicode untuk menapis aksara bukan digit.

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
}

Kesimpulan

Dalam artikel ini, kami meneroka dua cabaran pengaturcaraan yang menarik: mencari kewujudan berganda dalam tatasusunan dan melaksanakan Algoritma Luhn untuk pengesahan. Tugas-tugas ini menyerlahkan bagaimana bahasa pengaturcaraan yang berbeza boleh menangani masalah yang sama dengan pendekatan unik mereka sendiri. Saya harap contoh ini memberi inspirasi kepada anda untuk mendalami kedua-dua Perl dan Go!

Anda boleh mendapatkan kod lengkap, termasuk ujian, di GitHub.

Atas ialah kandungan terperinci Mencari Kewujudan Berganda dan Menggunakan Algoritma Luhn. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!