ઉકેલાયેલ: અજગરની સળંગ સંખ્યા વચ્ચેનો તફાવત

Python સળંગ નંબરો વચ્ચેના તફાવતને લગતી મુખ્ય સમસ્યા એ છે કે બે સળંગ સંખ્યાઓ વચ્ચેનો તફાવત હંમેશા સરખો હોતો નથી. ઉદાહરણ તરીકે, જો તમારી પાસે સંખ્યાઓની સૂચિ છે [1, 2, 3], તો 1 અને 2 વચ્ચેનો તફાવત 1 છે, પરંતુ 2 અને 3 વચ્ચેનો તફાવત માત્ર 0.5 છે. મૂલ્યોમાં તફાવતની ગણતરી કરવાનો પ્રયાસ કરતી વખતે અથવા સતત કદના કદ પર આધાર રાખતા અલ્ગોરિધમનો ઉપયોગ કરતી વખતે આ મૂંઝવણનું કારણ બની શકે છે.

def consecutive_difference(nums): 
    diff = [] 
    for i in range(len(nums)-1): 
        diff.append(abs(nums[i] - nums[i+1])) 
    return diff 
  
# Driver code 
nums = [2, 4, 6, 8] 
print(consecutive_difference(nums))

# લાઇન 1: આ લીટી એક ફંક્શનને વ્યાખ્યાયિત કરે છે જેને સળંગ_ભેદ કહેવાય છે જે એક દલીલ, સંખ્યા લે છે.
# લાઇન 2: આ લાઇન ડિફ નામની ખાલી યાદી બનાવે છે.
# લાઇન 3: આ રેખા લૂપ માટે છે જે સંખ્યા ઓછા એકની લંબાઈ દ્વારા પુનરાવર્તિત થાય છે.
# લાઇન 4: આ રેખા ભિન્ન સૂચિમાં સંખ્યાઓમાં દરેક ઘટક વચ્ચેના તફાવતનું સંપૂર્ણ મૂલ્ય ઉમેરે છે.
# લાઇન 5: આ લાઇન સંખ્યાઓમાં સળંગ ઘટકો વચ્ચેના તમામ તફાવતો સાથે ભરાઈ ગયા પછી તફાવત સૂચિ પરત કરે છે.
# લાઇન 8: આ લાઇન 2, 4, 6 અને 8 ધરાવતી સૂચિની સમાન સંખ્યા તરીકે ઓળખાતા ચલ સેટ કરે છે.
# લાઇન 9: આ લાઇન સંખ્યાઓ પર સતત_ભેદ કૉલ કરવાના પરિણામને છાપે છે.

Python માં સૂચિમાં સળંગ નંબરો શોધો

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

આ કેવી રીતે કરી શકાય તેનું ઉદાહરણ અહીં છે:

સંખ્યાઓ = [1,2,3,4,5,6] # સંખ્યાઓની સૂચિ
સતત_સંખ્યા = [] # સળંગ નંબરો સંગ્રહવા માટેની યાદી
શ્રેણીમાં i માટે(len(numbers)-1): # યાદીમાંથી લૂપ કરો
જો (સંખ્યાઓ[i+1] – સંખ્યાઓ[i]) == 1: # તપાસો કે બે તત્વો વચ્ચેનો તફાવત 1 છે કે કેમ
consecutive_numbers.append(numbers[i]) # સળંગ નંબરોની યાદીમાં ઘટક ઉમેરો
consecutive_numbers.append(numbers[i+1]) # સળંગ નંબરોની યાદીમાં આગલું ઘટક ઉમેરો
પ્રિન્ટ(સતત_નંબરો) # સળંગ નંબરોની યાદી છાપો

સૂચિમાં સળંગ નંબરો વચ્ચેનો તફાવત મેળવો

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

યાદી_સંખ્યા = [1, 2, 3, 4]
તફાવતો = [y – x માટે x, ઝિપમાં y(સૂચિ_નંબરો[:-1], યાદી_નંબરો[1:])]
પ્રિન્ટ(તફાવત) # આઉટપુટ: [1, 1, 1]

સંબંધિત પોસ્ટ્સ:

પ્રતિક્રિયા આપો