ઉકેલાયેલ: સૂચિ પાયથોનમાં ડુપ્લિકેટનું નામ બદલો

સૂચિમાં ડુપ્લિકેટ્સનું નામ બદલવું એ ઉકેલવા માટે મુશ્કેલ સમસ્યા હોઈ શકે છે કારણ કે તમારે ડુપ્લિકેટ્સને ઓળખવાની જરૂર છે અને પછી તેનું નામ કેવી રીતે બદલવું તે નક્કી કરવું જરૂરી છે. જો સૂચિમાં ઘણા ઘટકો હોય અથવા જો ઘટકો જટિલ પદાર્થો હોય તો આ ખાસ કરીને પડકારરૂપ બની શકે છે. વધુમાં, ડુપ્લિકેટનું નામ બદલવા માટે તમારે તમારા કોડના અન્ય ભાગોને સંશોધિત કરવાની જરૂર પડી શકે છે જે તત્વોના મૂળ નામો પર આધાર રાખે છે જેથી તેઓ યોગ્ય રીતે કાર્ય કરવાનું ચાલુ રાખે.

def rename_duplicates(lst): 
    seen = set() 
    new_lst = [] 

    for item in lst: 
        if item not in seen: 
            seen.add(item) 
            new_lst.append(item) 
        else: 
            new_item = item + '_1'   # append a suffix to make it unique  

            while new_item in seen:   # increment the suffix until it's unique  
                suffix = int(new_item.split('_')[-1]) + 1   # get the last number and add one to it  
                new_item = '{}_{}'.format('_'.join(new_item.split('_')[:-1]), suffix)

            seen.add(new_item)     # add the newly created item to the set of seen items  
            new_lst.append(new_item)     # append the newly created item to the list

    return new

_lst

# આ કોડ rename_duplicates નામના ફંક્શનને વ્યાખ્યાયિત કરે છે જે સૂચિમાં દલીલ તરીકે લે છે.
def rename_duplicates(lst):

# તે પછી એક ખાલી સેટ બનાવે છે જેને જોયું કહેવાય છે અને ખાલી યાદીને new_lst કહેવાય છે.
જોયું = સેટ()
new_lst = []

# તે પછી સૂચિમાંની આઇટમ્સ દ્વારા પુનરાવર્તિત થાય છે અને તપાસે છે કે તે પહેલેથી જ જોયેલી વસ્તુઓના સેટમાં છે કે નહીં.
lst માં આઇટમ માટે:
જો આઇટમ જોઈ ન હોય તો: # જો તે ન હોય, તો તે તેને જોયેલી વસ્તુઓના સમૂહમાં ઉમેરે છે અને તેને નવી સૂચિમાં ઉમેરે છે.
જોયું. ઉમેરો(આઇટમ)
new_lst.append(item) # જો તે હોય, તો તે તેના નામમાં પ્રત્યય (દા.ત., '_1') ઉમેરીને તે વસ્તુનું એક અનન્ય સંસ્કરણ બનાવે છે અને તપાસે છે કે આ નવી બનાવેલી આઇટમ પહેલાથી જ જોયેલી વસ્તુઓના સમૂહમાં છે કે નહીં.

else: # જો એમ હોય, તો તે પ્રત્યયમાં વધારો કરે છે જ્યાં સુધી તે આઇટમના નામનું વણવપરાયેલ સંસ્કરણ શોધે છે અને આ નવી બનાવેલી આઇટમને તેના અમલના અંતે આ નવી સૂચિ પરત કરતા પહેલા જોયેલી વસ્તુઓના સેટ અને નવી સૂચિમાં ઉમેરે છે.

new_item = વસ્તુ + '_1'

જ્યારે નવી_આઇટમ જોવામાં આવે છે: અનન્ય સુધી # ઇન્ક્રીમેન્ટ પ્રત્યય

પ્રત્યય = int(new_item.split('_')[-1]) + 1 # છેલ્લો નંબર મેળવો અને તેમાં એક ઉમેરો

new_item = '{ }_{}'.format('_'.join(new_item.split('_')[:-1]), પ્રત્યય)

જોયું. ઉમેરો(નવું

Python માં યાદીઓ

પાયથોનમાં યાદીઓ સૌથી વધુ ઉપયોગમાં લેવાતા ડેટા સ્ટ્રક્ચર્સમાંની એક છે. તેનો ઉપયોગ વસ્તુઓના સંગ્રહને સંગ્રહિત કરવા માટે થાય છે, જે અન્ય સૂચિઓ સહિત કોઈપણ પ્રકારની હોઈ શકે છે. સૂચિઓ પરિવર્તનશીલ છે, એટલે કે તેઓ બનાવ્યા પછી બદલી શકાય છે. તેઓ ઈન્ડેક્સીંગ, સ્લાઈસિંગ અને કંકોટીનેશન જેવી કામગીરીને પણ સપોર્ટ કરે છે.

Python માં સૂચિ બનાવવા માટે, તમે ચોરસ કૌંસનો ઉપયોગ કરો છો અને દરેક આઇટમને અલ્પવિરામથી અલગ કરો છો:

મારી_સૂચિ = [1, 2, 3]

તમે તેમની અનુક્રમણિકાનો ઉપયોગ કરીને સૂચિમાં વ્યક્તિગત ઘટકોને ઍક્સેસ કરી શકો છો:
my_list[0] # વળતર 1
my_list[1] # વળતર 2
my_list[2] # વળતર 3

તમે સૂચિના અંતમાંથી ઘટકોને ઍક્સેસ કરવા માટે નકારાત્મક સૂચકાંકોનો પણ ઉપયોગ કરી શકો છો:

my_list[-1] # પરત કરે છે 3 (છેલ્લું ઘટક)

તમે append() પદ્ધતિનો ઉપયોગ કરીને સૂચિમાં વસ્તુઓ ઉમેરી શકો છો:

my_list.append(4) # યાદીના અંતમાં 4 ઉમેરે છે

તમે દૂર() અથવા પૉપ() પદ્ધતિઓનો ઉપયોગ કરીને સૂચિમાંથી વસ્તુઓને દૂર કરી શકો છો:

my_list.remove(3) # યાદીમાંથી 3 દૂર કરે છે

my_list.pop(2) # યાદીમાંથી 2 (ત્રીજું તત્વ) દૂર કરે છે અને પરત કરે છે

Python માં સૂચિમાં ડુપ્લિકેટ્સનું નામ બદલો

પાયથોનમાં સૂચિમાં ડુપ્લિકેટનું નામ બદલવું એ યાદીઓ સાથે કામ કરતી વખતે સામાન્ય કાર્ય છે. તેમાં અનન્ય મૂલ્યો સાથે સૂચિમાં ડુપ્લિકેટ ઘટકોને બદલવાનો સમાવેશ થાય છે. આ સેટ() ફંક્શનનો ઉપયોગ કરીને કરી શકાય છે, જે સૂચિમાંથી બધા ડુપ્લિકેટ ઘટકોને દૂર કરે છે અને માત્ર અનન્ય ઘટકો સાથે નવી સૂચિ પરત કરે છે. સેટ() ફંક્શનનો ઉપયોગ ડુપ્લિકેટનું નામ બદલવા માટે તેને નવા મૂલ્યો સાથે જૂના મૂલ્યોના મેપિંગ સાથે પ્રદાન કરીને પણ કરી શકાય છે. ઉદાહરણ તરીકે, જો તમારી પાસે સંખ્યાઓની સૂચિ છે અને તમે બધા ડુપ્લિકેટ્સને તેમના સંબંધિત ચોરસ સાથે બદલવા માંગો છો, તો તમે નીચેના કોડનો ઉપયોગ કરી શકો છો:

# એક ખાલી શબ્દકોશ બનાવો
મેપિંગ = {}

# મૂળ સૂચિ પર પુનરાવર્તન કરો
my_list માં આઇટમ માટે:
# તપાસો કે આઇટમ પહેલેથી જ શબ્દકોશમાં અસ્તિત્વમાં છે
જો આઇટમ મેપિંગમાં નથી:
# જો નહીં, તો તેને શબ્દકોશમાં ઉમેરો અને તેના ચોરસને મૂલ્ય તરીકે સોંપો
મેપિંગ[આઇટમ] = આઇટમ * આઇટમ

# ખાલી પરિણામ યાદી બનાવો
પરિણામ_સૂચિ = []

# મૂળ સૂચિ પર ફરીથી પુનરાવર્તિત કરો અને my_list માં i માટે શબ્દકોશમાંથી દરેક ઘટકને તેના ચોરસ દ્વારા બદલો: result_list.append(મેપિંગ[i])

# પ્રિન્ટ પરિણામ પ્રિન્ટ (પરિણામ_સૂચિ)