ઉકેલી: શબ્દમાળામાં સબસ્ટ્રિંગ સ્થિતિ શોધો

ઠીક છે, ચાલો હાસ્કેલમાં સ્ટ્રિંગમાં સબસ્ટ્રિંગ કેવી રીતે શોધવી તે શરૂ કરીએ.

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

આ હેતુ માટે, અમે બે બિલ્ટ-ઇન હાસ્કેલ કાર્યોનો લાભ લઈ શકીએ છીએ: `isPrefixOf` અને `tails`. `isPrefixOf` તપાસે છે કે શું સૂચિ અન્ય સૂચિનો ઉપસર્ગ છે અને `પૂંછડી` સૂચિના તમામ અંતિમ ભાગો જનરેટ કરે છે. ચોક્કસ તત્વની પ્રથમ ઘટનાની અનુક્રમણિકા મેળવવા માટે અમે `Data.List` માંથી `elemIndex` ફંક્શનનો પણ ઉપયોગ કરીશું.

અહીં સમસ્યાનો એક સરળ ઉકેલ છે:

import Data.List

findSubstring :: String -> String -> Maybe Int
findSubstring substr str = 
    elemIndex True $ map (isPrefixOf substr) (tails str)

કોડની કામગીરી

ફંક્શન `findSubstring` બે દલીલો લે છે, `substr` અને `str`, જે અમે શોધી રહ્યા છીએ તે સબસ્ટ્રિંગ અને સ્ટ્રિંગને અનુક્રમે અમે જોઈ રહ્યા છીએ.

  • સૌપ્રથમ, `પૂંછડીઓ str` `str` ના તમામ સંભવિત અંતો જનરેટ કરે છે. ઉદાહરણ તરીકે, “હેલો” શબ્દમાળાને જોતાં, `પૂંછડીઓ` [“hello”, “ello”, “llo”, “lo”, “o”, “”] જનરેટ કરશે.
  • આગળ, `નકશો (isPrefixOf substr)` ફંક્શન `isPrefixOf substr` ને `tails str` દ્વારા ઉત્પાદિત સૂચિના દરેક ઘટક પર લાગુ કરે છે. આ બુલિયન મૂલ્યોની સૂચિ આપે છે, દરેક સૂચવે છે કે શું `substr` મૂળ સૂચિમાં સંબંધિત તત્વનો ઉપસર્ગ છે.
  • છેલ્લે, `એલિમઇન્ડેક્સ ટ્રુ` એ `ટ્રુ`ની પ્રથમ ઘટના માટે બુલિયન્સની આ સૂચિ શોધે છે, જે `સ્ટ્ર`માં `સબસ્ટ્ર`ની સ્થિતિને અનુરૂપ છે, અને તેને `કદાચ` ડેટાટાઇપમાં આવરિત પરત કરે છે.

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

ડેટા.સૂચિ એ હેસ્કેલ લાઇબ્રેરી છે જે યાદીઓની હેરફેર માટે ઉપયોગી કાર્યોથી ભરપૂર છે. અન્ય વસ્તુઓની સાથે, તે `isPrefixOf`, `tails` અને `elemIndex` ફંક્શનની નિકાસ કરે છે જેનો અમે અમારા ઉકેલમાં ઉપયોગ કર્યો છે.

અમારા ઉકેલ માટે `isPrefixOf` કાર્ય ખાસ કરીને નિર્ણાયક છે. અમારું લક્ષ્ય સબસ્ટ્રિંગ દરેક સબલિસ્ટનો ઉપસર્ગ છે કે કેમ તે ચકાસીને, તે મૂળ સ્ટ્રિંગમાં અમારા સબસ્ટ્રિંગની દરેક સંભવિત શરૂઆતની સ્થિતિને આવશ્યકપણે તપાસે છે.

એક્સ્ટ્રાપોલેશન્સ અને વેરિએન્ટ્સ

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

ઉદાહરણ તરીકે, સબસ્ટ્રિંગની તમામ ઘટનાઓને બદલવા માટે, તમે લક્ષ્ય સબસ્ટ્રિંગની સ્થિતિ પર મૂળ સ્ટ્રિંગને તોડવાથી મેળવેલા હિસ્સામાં જોડાવા માટે Data.Listમાંથી `ઇન્ટરકેલેટ` નો ઉપયોગ કરી શકો છો.

તેની સહજ સરળતા અને અભિવ્યક્તિ હોવા છતાં, સ્ટ્રિંગ પ્રોસેસિંગ માટે હાસ્કેલનો અભિગમ સામાન્ય કાર્યોને સ્વચ્છ, વાંચી શકાય તેવા અને સંક્ષિપ્ત રીતે હલ કરવામાં કાર્યાત્મક પ્રોગ્રામિંગની શક્તિ દર્શાવે છે.

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

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