Python ծրագիր՝ տողի բոլոր հնարավոր հատվածները ստանալու համար K շարքի կտրվածքով

Այս հոդվածում օգտատերը կհասկանա, թե ինչպես կարելի է ստանալ տողի բոլոր հնարավոր հատվածները Python ծրագրի K թվի հատվածների համար: Այս հոդվածում ներկայացված են երկու տարբեր օրինակներ։ Մենք կկիրառենք կրկնման մոտեցում՝ ցանկալի արդյունքի հասնելու համար: Երկրորդ օրինակում մենք կօգտագործենք itertools.combinations մոտեցումը՝ կտրված տողը ստանալու համար:

Հաշվարկը ցույց տալու համար բերենք օրինակ: Հասկանալու նպատակով տրված են հետևյալ օրինակները, և մենք մեկ առ մեկ կանցնենք հաշվարկման գործընթացին:

Օրինակ 1. Գտեք տողի բոլոր հնարավոր հատվածները K թվի կտորների համար՝ օգտագործելով կրկնվող մոտեցումը:

Ալգորիթմ

Քայլ 1. Բացեք Jupyter Notebook-ը Anaconda-ի հուշում և սկսեք գրել կոդը դրա բջիջում:

Քայլ 2. Օգտագործեք «get_all_slices» ֆունկցիան, այն վերցնում է մուտքագրման տողը (տողը) և հատվածների քանակը «(k)»: Այն նախաստորագրելու է դատարկ «հատված [[ ]]» ցուցակը՝ արդյունքները պահելու համար:

Քայլ 3. Ֆունկցիան ստուգում է, եթե k > տողի երկարությունը (n):

Քայլ 4. i-ի համար միջակայքում(k)` կրկնությունների վրա հիմնված լուծում տողի բոլոր հնարավոր հատվածները ստեղծելու համար:

Քայլ 5. միջակայքը(k) ստեղծում է թվերի հաջորդականություն 0-ից մինչև k-1:

Քայլ 6. new_slices=[]. սկզբնավորեք դատարկ ցուցակ, որը կոչվում է new_slices արտաքին օղակի յուրաքանչյուր կրկնության մեջ: Սա կպահի նոր ստեղծված հատվածները ընթացիկ կրկնության համար:

Քայլ 7. slice_list-ի համար հատվածներով. սա ներդիր հանգույց է, որը կրկնվում է նախորդ կրկնության առկա հատվածների վրա:

Քայլ 8. Մնացած_երկարությունը=len(string) - sum(map(len, slice_list)): Հաշվում է տողի մնացած երկարությունը գոյություն ունեցող հատվածների երկարությունները վերցնելուց հետո:

Քայլ 9. Օգտագործում է քարտեզ (len, slice_list)՝ առանձին հատվածների երկարությունների ցանկը ստանալու և դրանց գումարը ստանալու համար:

Քայլ 10. Ստացեք մնացած երկարությունը՝ հանելով այս գումարը տողի ընդհանուր երկարությունից:

Քայլ 11. j-ի համար տիրույթում (1, մնացած_երկարություն + 1). այն կստեղծի բոլոր հնարավոր երկարությունները (j) նոր հատվածի համար: Այն կսկսվի 1-ից և կհասնի մնացած_երկարության:

Քայլ 12. new_slices.append(slice_list + [string[:j]]): Կցեք նոր հատված new_slices ցուցակին: Այն կմիավորի ընթացիկ հատվածների ցանկը (slice_list) նոր հատվածի հետ, որը ստեղծվել է տողը 0-ից մինչև j կտրատելու միջոցով:

Քայլ 13.slices=new_slices. Ընթացիկ կրկնության համար բոլոր հատվածները ստեղծելուց հետո, այնուհետև slices փոփոխականը թարմացվում է new_slices ցուցակով: Սա թույլ կտա հաջորդ կրկնությունը հիմնվել նոր շերտերի վրա:

Քայլ 14. Վերջապես, վերջնական հատվածների ցանկը կպարունակի տողի բոլոր հատվածները կտրվածքների տրված քանակի համար (k):

Քայլ 15. Արդյունքում ֆունկցիան վերադարձնում է հատվածների ցանկը:

Կոդ կտրատած տողի համար

Օրինակ

def get_all_slices_iteration(string, k):
    slices = [[]]
    for i in range(k):
        new_slices = []
        for slice_list in slices:
            remaining_length = len(string) - sum(map(len, slice_list))
            for j in range(1, remaining_length + 1):
                new_slices.append(slice_list + [string[:j]])
        slices = new_slices
    
    return slices

# Example 
input_string = "welcome"
num_slices = 3
result = get_all_slices_iteration(input_string, num_slices)
# Print the result
for slice_list in result:
    print(slice_list)

Դիտելով արդյունքը - Օրինակ 1

Այս մոտեցումը կրկնակի կտրվածքով կստեղծի հատվածներ՝ ընդլայնելով նախորդ կրկնությունից առկա հատվածները: Այն կարող է հաշվարկվել տողի մնացած երկարությունը և կառաջացնի բոլոր հնարավոր երկարությունները նոր հատվածի համար յուրաքանչյուր կրկնության մեջ՝ գնալով կառուցելով բոլոր սպասված հատվածները:

Արդյունք

['w', 'w', 'w']
['w', 'w', 'we']
['w', 'w', 'wel']
['w', 'w', 'welc']
['w', 'w', 'welco']
['w', 'we', 'w']
['w', 'we', 'we']
['w', 'we', 'wel']
['w', 'we', 'welc']
['w', 'wel', 'w']
['w', 'wel', 'we']
['w', 'wel', 'wel']
['w', 'welc', 'w']
['w', 'welc', 'we']
['w', 'welco', 'w']
['we', 'w', 'w']
['we', 'w', 'we']
['we', 'w', 'wel']
['we', 'w', 'welc']
['we', 'we', 'w']
['we', 'we', 'we']
['we', 'we', 'wel']
['we', 'wel', 'w']
['we', 'wel', 'we']
['we', 'welc', 'w']
['wel', 'w', 'w']
['wel', 'w', 'we']
['wel', 'w', 'wel']
['wel', 'we', 'w']
['wel', 'we', 'we']
['wel', 'wel', 'w']
['welc', 'w', 'w']
['welc', 'w', 'we']
['welc', 'we', 'w']
['welco', 'w', 'w']

Օրինակ 2. «itertool.combinational» մոտեցման միջոցով գտնելով տողի բոլոր հնարավոր հատվածները K թվի կտորների համար:

Կոդի բացատրության և ձևավորման քայլեր

Քայլ 1. Բացեք Jupyter Notebook-ը Anaconda-ի հուշում և սկսեք գրել կոդը դրա բջիջում:

Քայլ 2. Օգտագործեք «get_all_slices» ֆունկցիան, այն վերցնում է մուտքագրման տողը (տողը) և հատվածների քանակը «(k)»: Այն նախաստորագրելու է դատարկ «հատված []» ցուցակը՝ արդյունքները պահելու համար:

Քայլ 3. Այնուհետև ֆունկցիան ստուգում է, արդյոք k > տողի երկարությունը (n): Եթե այո, այն վերադարձնում է դատարկ հատվածների ցուցակը:

Քայլ 4. Արտաքին օղակը կկրկնվի 1-ից մինչև k-1, որը կներկայացնի նախածանցի նիշերի քանակը:

Քայլ 5. Ներքին օղակը կկրկնվի 1-ից մինչև n-1, որը կներկայացնի վերջածանցի նիշերի քանակը:

Քայլ 6. նախածանցի և ածանցի երկարությունների յուրաքանչյուր համակցությունից այն կամփոփվի մինչև տողի երկարությունը (n):

Քայլ 7. Ներածման տողից հանեք նախածանցներն ու վերջածանցները:

Քայլ 8. Կցեք դրանք որպես ցուցակ հատվածների ցանկին:

Քայլ 9. Օգտագործեք itertools.combinations ֆունկցիան՝ 1-ից n-1 ինդեքսների բոլոր համակցությունները ստեղծելու համար:

Քայլ 10. Կրկնեք այս համակցությունների վրա և ստեղծեք հատվածների ցուցակներ՝ բաժանելով այն տողը, որը հիմնված կլինի ընտրված ցուցանիշների վրա:

Քայլ 11. Հավաքեք բոլոր հատվածների կազմաձևերը կտորների ցանկում և վերադարձրեք այն որպես վերջնական արդյունք:

Կոդ itertool.combinational մոտեցման համար

Օրինակ

import itertools

def gt_combinations(string, k):
    slices = []
    for combo in itertools.combinations(range(1, len(string)), k - 1):
        indices = [0] + list(combo) + [len(string)]
        slice_list = [string[indices[i]:indices[i + 1]] for i in range(k)]
        slices.append(slice_list)
    
    return slices

# Example
ist = "welcome"
nt = 3
result = gt_combinations (ist, nt)

# Print the result
for slice_list in result:
    print(slice_list)

Արդյունքի դիտում - Օրինակ 2

Արդյունքը տեսնելու համար բացեք loactionfile.html բրաուզերում: Այժմ սեղմեք կոճակը՝ օգտատիրոջ ընթացիկ գտնվելու վայրը գտնելու համար: Կոորդինատները ցուցադրվում են html էջում։

Արդյունք

['w', 'e', 'lcome']
['w', 'el', 'come']
['w', 'elc', 'ome']
['w', 'elco', 'me']
['w', 'elcom', 'e']
['we', 'l', 'come']
['we', 'lc', 'ome']
['we', 'lco', 'me']
['we', 'lcom', 'e']
['wel', 'c', 'ome']
['wel', 'co', 'me']
['wel', 'com', 'e']
['welc', 'o', 'me']
['welc', 'om', 'e']
['welco', 'm', 'e']

Այս հոդվածում երկու մոտեցումների կիրառմամբ էլ հասնում է նույն արդյունքը, սակայն իրականացման եղանակը տարբեր է: Առաջին մոտեցումը օգտագործում է կրկնություն, երկրորդ մոտեցումը օգտագործում է itertools.combinations ֆունկցիան, որը կստեղծի ինդեքսների բոլոր համակցությունները տողը կտրելու համար: Մենք կարող ենք ընտրել ցանկացած մոտեցում, որը համապատասխանում է մեր պահանջներին կամ նախասիրություններին: