ઉકેલાયેલ: અનામી કાર્ય

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

મુશ્કેલી

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

અનામિક કાર્યો સાથે ઉકેલ

[સ્યુડોકોડ લેંગ="હાસ્કેલ"]
આયાત Data.List
ક્વોલિફાઇડ ડેટા આયાત કરો. નકશા તરીકે નકશો

wordLengthCount :: [String] -> Map.Map Int Int
wordLengthCount = Map.fromListWith (+) . નકશો (x -> (લંબાઈ x, 1))
[/ સ્યુડોકોડ]

ચાલો સોલ્યુશનને અનપેક કરીએ, પગલું દ્વારા પગલું.

કોડની વિગતવાર સમજૂતી

પ્રથમ લીટીમાં, અમે જરૂરી પુસ્તકાલયો આયાત કરી રહ્યા છીએ. 'Data.List' લિસ્ટ મેનિપ્યુલેશન ફંક્શન્સ પ્રદાન કરે છે, જ્યારે 'Data.Map' અમને ડેટા પ્રકારની ઍક્સેસ આપે છે જેનો ઉપયોગ નકશા ડેટા સ્ટ્રક્ચરને અમલમાં કરવા માટે થઈ શકે છે.

ફંક્શન 'wordLengthCount' શબ્દો (શબ્દમાળાઓ) ની સૂચિને દલીલ તરીકે લે છે, અને એક નકશો આપે છે જેમાં દરેક શબ્દની લંબાઈની ઘટનાની ગણતરી હોય છે.

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

[સ્યુડોકોડ લેંગ="હાસ્કેલ"]
x -> (લંબાઈ x, 1)
[/ સ્યુડોકોડ]

લેમ્બડા ફંક્શન એક શબ્દને ઇનપુટ ('x') તરીકે લે છે, અને ટ્યુપલને આઉટપુટ કરે છે - શબ્દની લંબાઈ અને 1. આ ઑપરેશન સૂચિમાંના દરેક શબ્દ પર લાગુ થયા પછી, અમે ટ્યુપલ્સની સૂચિ સાથે સમાપ્ત થઈએ છીએ.

આગળ, આપણે 'Map.fromListWith' ફંક્શનનો ઉપયોગ કરીએ છીએ. 'fromListWith' ફંક્શન એ એક સરળ કાર્ય છે જે બાઈનરી ફંક્શન અને ટ્યુપલ્સની સૂચિ લે છે અને નકશો બનાવે છે.

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

હાસ્કેલ પુસ્તકાલયો અને કાર્યો

આ કોડમાં, અમે કેટલીક હાસ્કેલ લાઇબ્રેરીઓ અને કાર્યોનો લાભ લીધો છે. 'ડેટા.લિસ્ટ' અને 'ડેટા.મેપ' હાસ્કેલમાં ડેટા મેનીપ્યુલેશન અને સ્ટ્રક્ચર માટે પુસ્તકાલયો આવશ્યક છે. આ 'નકશો' અમારા કોડની જટિલતાને નોંધપાત્ર રીતે ઘટાડી, અમારી સૂચિમાંની દરેક આઇટમ પર અમારા અનામી કાર્યને લાગુ કરવામાં ફંક્શન નિમિત્ત હતું.

વધુમાં, આ 'fromListWith' 'Data.Map' ના ફંક્શનથી અમને અમારા ડેટાને શબ્દ લંબાઈ દ્વારા કાર્યક્ષમ રીતે જૂથબદ્ધ કરવા અને કુલ ઘટનાઓની ગણતરી કરવાની મંજૂરી મળી.

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

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

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

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