Python - Jumlah minimum aksara berturut-turut

Pengenalan

Dalam pengaturcaraan Python, tugas mencari jumlah minimum aksara berturut-turut dalam setiap rentetan boleh menjadi masalah biasa dalam aplikasi yang berbeza. Matlamatnya adalah untuk mengenal pasti subrentetan yang menghasilkan jumlah terkecil apabila mempertimbangkan nilai ASCII bagi aksaranya. Artikel ini meneroka cara yang berbeza untuk mendekati masalah menggunakan Python. Artikel ini mula-mula memperkenalkan kepentingan mencari jumlah minimum aksara berturut-turut dan kaitannya dalam menyelesaikan masalah praktikal. Ia menekankan kepentingan algoritma yang cekap dalam mengoptimumkan pengiraan jumlah minimum.

Python − Jumlah minimum aksara berturut-turut

Dalam pengaturcaraan Python, tugas mencari aksara bersebelahan lengkap terkecil dalam setiap rentetan melibatkan membezakan subrentetan dalam rentetan yang menghasilkan keseluruhan terkecil apabila mempertimbangkan nilai ASCII aksaranya. Matlamatnya adalah untuk menentukan subrentetan yang menghasilkan keseluruhan terkecil antara semua subrentetan yang mungkin.

Untuk menyelesaikan masalah ini, kami boleh menggunakan kaedah dan pendekatan yang berbeza dalam Python. Kaedah ini termasuk mengulangi melalui rentetan dan mengira bahagian integer subrentetan berturut-turut, membandingkannya dan menjejaki integer terkecil yang ditemui. Dengan mempertimbangkan nilai ASCII aksara dan melakukan pengiraan yang sesuai, adalah mungkin untuk mencari subrentetan yang menghasilkan integer terkecil.

Python menyediakan beberapa fungsi dan ciri terbina dalam yang memudahkan pelaksanaan kaedah ini. Fungsi seperti ord() boleh digunakan untuk mendapatkan nilai ASCII bagi sesuatu aksara, manakala gelung dan penyataan bersyarat membolehkan kami melelang melalui rentetan dan melakukan pengiraan yang diperlukan. Dengan menggunakan ciri ini, kami berjaya menyelesaikan masalah dan mendapatkan jumlah minimum aksara berturut-turut yang diperlukan.

Kaedah 1: Gunakan kekerasan

Pendekatan utama mungkin ialah strategi kekerasan yang terdiri daripada mengulang semua subrentetan berurutan yang mungkin dalam rentetan tertentu. Berikut adalah langkah-langkah untuk menyelesaikan masalah menggunakan kaedah ini:

Algoritma

Langkah 1:Mulakan jumlah_min yang berubah dengan nilai yang besar (cth. infiniti) untuk menjejaki jumlah minimum.

Langkah 2: Gunakan dua gelung bersarang untuk menyerlahkan semua subrentetan yang mungkin bagi rentetan yang diberikan. Gelung luar menentukan indeks permulaan subrentetan, dan gelung dalam menentukan indeks penamat.

Langkah 3: Gunakan fungsi sum() terbina dalam Python atau kira keseluruhan subrentetan semasa dengan menekankan subrentetan secara fizikal dan memasukkan nilai aksara. p>

Langkah 4: Bandingkan ensembel yang dikira dengan jumlah minimum semasa (min_sum). Jika integriti yang dikira adalah minimum, min_sum dinaikkan kepada integriti minimum yang tidak digunakan.

Langkah 5: Ulang langkah 3 dan 4 untuk semua subrentetan.

Langkah 6:Kembalikan jumlah minimum akhir (min_sum) sebagai hasilnya.

Contoh

def minimum_sum_of_consecutive_chars(string):
    min_sum = float('inf')
    length = len(string)

    for i in range(length):
        for j in range(i, length):
            substring = string[i:j+1]
            current_sum = sum(ord(c) for c in substring)
            min_sum = min(min_sum, current_sum)

    return min_sum

    
string = "abcde"
print(minimum_sum_of_consecutive_chars(string))

Output

97

Kaedah 2: Gunakan pengaturcaraan dinamik

Kaedah kedua menggunakan pengaturcaraan dinamik untuk menyelesaikan masalah jumlah minimum aksara berturut-turut dengan lebih cekap. Kaedah ini mengelakkan pengiraan berganda dengan menyimpan hasil submasalah dalam jadual ingatan. Berikut adalah langkah-langkah untuk melaksanakan pendekatan ini:

Algoritma

Langkah 1:Tentukan fungsi yang ditentukan pengguna. Tentukan panjang tali.

Langkah 2:Mulakan kes asas. Tetapkan memo[i][i] (komponen sudut ke sudut) kepada nilai ASCII bagi aksara pada senarai i dalam rentetan.

Langkah 3: Penekanan pada semua subrentetan panjang l dari 2 hingga panjang rentetan. Untuk setiap subrentetan, serlahkan semua senarai permulaan

Langkah 4: Kira jumlah subrentetan semasa dan kemas kini perenggan yang sepadan dalam jadual ingatan.

Langkah 5: Akhir sekali, kembalikan keseluruhan terkecil dari sudut kanan atas helaian memo.

Contoh

def minimum_sum_of_consecutive_chars(string):
    length = len(string)
    memo = [[0] * length for _ in range(length)]

    for i in range(length):
        memo[i][i] = ord(string[i])

    for l in range(2, length + 1):
        for i in range(length - l + 1):
            j = i + l - 1
            memo[i][j] = memo[i][j - 1] + ord(string[j])

    return min(memo[i][j] for i in range(length) for j in range(i, length))

  
string = "abcde"
print(minimum_sum_of_consecutive_chars(string))

Output

97

Kaedah 3: Gunakan tetingkap gelongsor

Kaedah ketiga, dipanggil kaedah tetingkap gelongsor, mengoptimumkan kaedah sebelumnya dan meningkatkan kecekapan dengan menghapuskan pengiraan berlebihan. Daripada mengulangi semua subrentetan yang mungkin, pendekatan ini mengekalkan tetingkap gelongsor yang mewakili subrentetan yang sedang dipertimbangkan. Berikut ialah langkah-langkah untuk melaksanakan pendekatan tetingkap gelongsor:

Algoritma

Langkah 1:Mulakan dua penunjuk, permulaan dan kesimpulan, pada permulaan rentetan.

Langkah 2: Mulakan jumlah_arus berubah untuk menjejaki jumlah tetingkap semasa.

Langkah 3: Mulakan jumlah_min dan jadikan ia tidak terhingga

Langkah 4: Kembalikan jumlah minimum (min_sum) sebagai hasilnya.

Contoh

def minimum_sum_of_consecutive_chars(string):
    start = 0
    end = 0
    length = len(string)
    current_sum = ord(string[0])
    min_sum = float('inf')

    while end < length:
        if current_sum < min_sum:
            min_sum = current_sum

        end += 1

        if end < length:
            current_sum += ord(string[end])

        while current_sum >= min_sum and start < end:
            current_sum -= ord(string[start])
            start += 1

    return min_sum

    
string = "abcde"
print(minimum_sum_of_consecutive_chars(string))

Output

97

Kesimpulan

Kami melihat tiga cara berbeza untuk memahami masalah aksara berturut-turut terkecil dalam Python. Kami membincangkan pendekatan kekangan kekerasan, pendekatan pengaturcaraan dinamik dan pendekatan tetingkap gelongsor. Setiap kaedah mempunyai langkah sendiri, pelaksanaan kod dan output, menunjukkan pendekatan algoritma yang berbeza untuk masalah. Dengan memahami kaedah ini, anda boleh memilih penyelesaian yang paling sesuai dengan keperluan khusus anda dan mengoptimumkan pengiraan aksara berturut-turut minimum dalam Python.

Atas ialah kandungan terperinci Python - Jumlah minimum aksara berturut-turut. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!