હલ: યાદી સૉર્ટ છે કે કેમ તે તપાસો

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

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

##

સમસ્યા: યાદી સૉર્ટ છે કે કેમ તે તપાસી રહ્યું છે

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

હાસ્કેલમાં સૂચિને સૉર્ટ કરવામાં આવી છે કે કેમ તે તપાસવાની સૌથી સરળ રીત એ છે કે તેના સૉર્ટ કરેલ સંસ્કરણ સાથે તેની તુલના કરવી. હાસ્કેલ બિલ્ટ-ઇન ફંક્શન પૂરું પાડે છે, સૉર્ટ કરો, જેનો ઉપયોગ આપણે ચડતા ક્રમમાં સૂચિને સૉર્ટ કરવા માટે કરી શકીએ છીએ. જો સૂચિ સૉર્ટ કર્યા પછી સમાન રહે છે, તો અમે સુરક્ષિત રીતે નિષ્કર્ષ પર આવી શકીએ છીએ કે તે પહેલેથી જ સૉર્ટ કરવામાં આવી હતી. ચાલો જોઈએ કે આપણે આ કેવી રીતે કરી શકીએ:

import Data.List
isSorted :: (Ord a) => [a] -> Bool
isSorted xs = xs == sort xs

પરંતુ, આ પદ્ધતિ શ્રેષ્ઠ નથી કારણ કે તેને સંપૂર્ણ પ્રકારની સૂચિની જરૂર છે જે ખાસ કરીને મોટી સૂચિ માટે સમય અને સંસાધનોનો ઉપયોગ કરે છે.

##

ઉકેલ: ઑપ્ટિમાઇઝ કોડ

જો સંલગ્ન તત્વોની દરેક જોડી માટે, પ્રથમ એક બીજા કરતા ઓછી અથવા સમાન હોય તો સૂચિને સૉર્ટ કરવામાં આવે છે. આને અમલમાં મૂકવા માટે, અમે zipWith અને તમામ ફંક્શનનો સંયોજનમાં ઉપયોગ કરીશું. અહીં ઑપ્ટિમાઇઝ કોડ છે:

isSorted :: (Ord a) => [a] -> Bool
isSorted xs = all (uncurry (<=)) (zip xs (tail xs)) [/code] ઝિપ બે યાદીઓને જોડીની યાદીમાં જોડે છે, જ્યારે પૂંછડી પ્રથમ તત્વ છોડે છે અને બાકીનું પરત કરે છે. uncurry જોડી માટે બાઈનરી ઓપરેટર લાગુ કરે છે, અને યાદીમાંના તમામ ઘટકો માટે શરત ધરાવે છે કે કેમ તે તમામ તપાસે છે. અમારા કિસ્સામાં, શરત એ છે કે દરેક જોડી માટે, પ્રથમ તત્વ બીજા કરતા ઓછું અથવા સમાન હોવું જોઈએ.

##

કોડનું પગલું દ્વારા પગલું સમજૂતી

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

1. zip xs (પૂંછડી xs) સૂચિ [1,2,3,4] લેશે અને તેને જોડીની સૂચિમાં રૂપાંતરિત કરશે [(1,2),(2,3),(3,4)]. દરેક જોડી મૂળભૂત રીતે વર્તમાન તત્વ અને સૂચિમાં આગામી તત્વ છે.

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

3. આપણું અનુમાન અહીં છે (અનકરી (<=)). uncurry એક ફંક્શન અને ટ્યૂપલ લે છે, અને ફંક્શનને ટ્યૂપલના તત્વો પર લાગુ કરે છે. <= અહી આપણું કાર્ય છે, તેથી અનકરી (<=) એ એક ફંક્શન હશે જે ટ્યુપલ (a, b) લે છે અને જો a <= b તો True પરત કરે છે. સંભવિત રૂપે મોટી સૂચિઓ સાથે કામ કરતી વખતે આ અભિગમ અમને સમસ્યાને અસરકારક રીતે ઉકેલવામાં મદદ કરે છે, એક મજબૂત અને કાર્યક્ષમ ઉકેલ પ્રદાન કરે છે. હાસ્કેલમાં શૈલીની વાત કરીએ તો, ભાષા સ્વચ્છ અને સંક્ષિપ્ત કોડ લખવાનું પ્રોત્સાહન આપે છે. તેથી તમારા કોડને નાના, કંપોઝેબલ ફંક્શન્સ અને વાજબી વિભાગોમાં વિભાજિત અને અમૂર્ત કરવાની સારી શૈલી છે. હાસ્કેલ ખૂબ પ્રશંસા કરે છે કે તે તમને સુંદર, સ્પષ્ટ અને ઉચ્ચ-સ્તરનો કોડ લખવા દે છે.

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

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