हास्केल सूची समझ में कुछ प्रतिस्थापन करें

Question

मेरे प्रश्न यह है कि यदि मैं Hello, today is a Nice Day!! जैसे स्ट्रिंग में डालता हूं तो मैं रिक्त स्थान और विराम चिह्न से कैसे छुटकारा पा सकता हूं और अपरकेस अक्षरों को लोअरकेस के साथ बदल सकता हूं?

मुझे पता है कि उन्हें कैसे हटाया जाए लेकिन उन्हें कैसे बदला जाए।

विराम चिह्न से छुटकारा पाने के लिए भी।

क्षमा करें मुझे नहीं पता कि तारों के साथ गड़बड़ कैसे करें, केवल संख्याएं।

testList xs = [if x = [,|.|?|!] then " " | x<-xs] 

Answer 1

import Data.Char 

आप अंतरिक्ष के लिए विराम चिह्न और अपर केस से पात्रों को लोअर केस में परिवर्तित करना चाहते हैं

यदि आप विराम चिह्न को हटाना चाहते हैं और वर्णों को ऊपरी मामले से कम मामले में परिवर्तित करना चाहते हैं:

testList2 xs = [toLower x | x<-xs, not (x `elem` ",.?!")] 

उदाहरण:

toLower' :: Char -> Char 
toLower' char 
    | isNotUppercase = char -- no change required 
    | otherwise = toEnum (codeChar + diffLowerUpperChar) -- char lowered 
    where 
     codeChar = fromEnum char -- each character has a numeric code 
     code_A = 65 
     code_Z = 90 
     code_a = 97 
     isNotUppercase = codeChar < code_A || codeChar > code_Z 
     diffLowerUpperChar = code_a - code_A 

Answer 2

विराम चिह्न से छुटकारा पाने के लिए आप इस एक

[x | x<-[1..10], x `mod` 2 == 0] 

की तरह एक फिल्टर का उपयोग कर सकते हैं "अगर" आप उपयोग कर रहे फ़िल्टर नहीं कर पाएंगे। एक सूची समझ के "मानचित्र" भाग में एक अगर डालने से केवल दो विकल्पों के बीच चयन करना होगा, लेकिन आप उन्हें वहां फ़िल्टर नहीं कर सकते हैं।

चीजों को लोअरकेस में परिवर्तित करने के लिए के रूप में, आप के रूप में अपनी ही चाल पहले से ही संख्या में हटा सकते हैं:

[x*2 | x <- [1..10]] 

Answer 3

मैं एक लंबे समय के लिए हास्केल में एक कोड लिखने के बिना किया गया है, लेकिन अगले चाहिए अमान्य वर्ण छोटे अक्षरों पर अपरकेस से पात्रों को दूर (उनमें एक रिक्ति से प्रतिस्थापित करें) और यह भी परिवर्तित:

import Data.Char 

replace invalid xs = [if elem x invalid then ' ' else toLower x | x <- xs] 

ही ऐसा करने का एक और तरीका है:

repl invalid [] = [] 
repl invalid (x:xs) | elem x invalid = ' ' : repl invalid xs 
        | otherwise  = toLower x : repl invalid xs 

आप इस तरह replace (या repl) फ़ंक्शन को कॉल कर सकते हैं:

replace ",.?!" "Hello, today is a Nice Day!!" 

ऊपर कोड प्राप्त होगा:

"hello today is a nice day " 

संपादित करें: मैं Data.Char से toLower समारोह का उपयोग कर रहा हास्केल में, लेकिन यदि आप इसे स्वयं लिखना चाहते हैं, तो स्टैक ओवरफ़्लो पर यहां देखें। उस सवाल से पहले पूछा गया है।

Answer 4

यहाँ मॉड्यूल आयात करने, fromEnum और toEnum का उपयोग कर जो वर्णों की अनुमति के लिए चयन करने के लिए बिना एक संस्करण है:

testList xs = 
    filter (\x -> elem (fromEnum x) ([97..122] ++ [32] ++ [48..57])) $ map toLower' xs 
    where toLower' x = if elem (fromEnum x) [65..90] 
          then toEnum (fromEnum x + 32)::Char 
          else x 

OUTPUT: 
*Main> testList "Hello, today is a Nice Day!!" 
"hello today is a nice day" 

एक मॉड्यूल-कम की जगह समारोह के लिए, कुछ इस तरह काम कर सकते हैं:

myReplace toReplace xs = map myReplace' xs where 
    myReplace' x 
    | elem (fromEnum x) [65..90] = toEnum (fromEnum x + 32)::Char 
    | elem x toReplace   = ' ' 
    | otherwise     = x 

OUTPUT: 
*Main> myReplace "!," "Hello, today is a Nice Day!! 123" 
"hello today is a nice day 123" 

Answer 5

आप Data.Char में कार्यों की जरूरत मिलेगा:

import Data.Char 

process str = [toLower c | c <- str , isAlpha c] 

हालांकि व्यक्तिगत रूप से, मुझे लगता है कि समारोह compositional दृष्टिकोण स्पष्ट है:

testList xs = [if x `elem` ",.?!" then ' ' else toLower x | x<-xs] 

उदाहरण:: testList "TeST,LiST!" == "test list "

process = map toLower . filter isAlpha