ভাঁজ পরে পোস্টপ্রসেসিং পদক্ষেপ ছাড়াই এই শব্দগুলি কার্যকর করা কি সম্ভব?

Question

রিয়েল ওয়ার্ল্ড হাস্কেল, প্রিন্টের ৪ র্থ অধ্যায়, পৃষ্ঠা 98 জিজ্ঞাসা wordsকরে যে ভাঁজগুলি ব্যবহার করে প্রয়োগ করা যেতে পারে, এবং এটি আমার প্রশ্নও:

এটা কি সম্ভব? তা না হলে কেন? যদি তা হয় তবে কীভাবে?

আমি নিম্নলিখিতটি নিয়ে এসেছি, যা এই ধারণাটির উপর ভিত্তি করে যে প্রতিটি অ-স্থান আউটপুট তালিকার সর্বশেষ শব্দের সাথে যুক্ত করা উচিত (এটি otherwiseপ্রহরীতে ঘটে ), এবং কোনও স্থানটি একটি এমপিপি শব্দ যুক্ত করার জন্য ট্রিগার করে should ইতিমধ্যে যদি না থাকে তবে আউটপুট তালিকা (এটি if- then- এ পরিচালনা করা হয় else)।

myWords :: String -> [String]
myWords = foldr step [[]]
  where
    step x yss@(y:ys)
      | x == ' ' = if y == "" then yss else "":yss
      | otherwise = (x:y):ys

স্পষ্টতই এই সমাধানটি ভুল, যেহেতু ইনপুট স্ট্রিংয়ের শীর্ষস্থানীয় স্থানগুলি স্ট্রিংয়ের আউটপুট তালিকার একটি নেতৃস্থানীয় খালি স্ট্রিংয়ের ফলাফল দেয়।

উপরের লিঙ্কে, আমি অন্যান্য পাঠকদের জন্য প্রস্তাবিত বেশ কয়েকটি সমাধান দেখেছি এবং তাদের মধ্যে অনেকগুলি আমার সমাধানের মতোই কাজ করে তবে তারা সাধারণত ভাঁজটির আউটপুট "পোস্ট-প্রসেস" করে থাকে, উদাহরণস্বরূপ tailযদি সেখানে থাকে তবে আইএনএন করে একটি খালি নেতৃস্থানীয় স্ট্রিং।

অন্যান্য পদ্ধতির টিউপলস (আসলে কেবল জোড়া) ব্যবহার করা হয়, যাতে ভাঁজটি জুটির সাথে কাজ করে এবং শীর্ষস্থানীয় / পিছনের স্থানগুলি ভালভাবে পরিচালনা করতে পারে।

এই সমস্ত পদ্ধতির মধ্যে, foldr(বা অন্য ভাঁজ, fww) বাক্সের বাইরে চূড়ান্ত আউটপুট সরবরাহ করে এমন ফাংশন নয়; এর সাথে সবসময় অন্য কিছু হয় আউটপুটটি কোনওভাবে সামঞ্জস্য করতে হয়।

অতএব আমি প্রাথমিক প্রশ্নে ফিরে যাই এবং জিজ্ঞাসা করি wordsযে ভাঁজগুলি ব্যবহার করে (এমনভাবে এটি সঠিকভাবে অনুসরণ / অগ্রণী / পুনরাবৃত্ত স্পেসগুলি পরিচালনা করে) কার্যকর করা সম্ভব কিনা ask দ্বারা ভাঁজ ব্যবহার আমি বলতে চাচ্ছি যে ভাঁজ ফাংশন দূরতম ফাংশন হতে হয়েছে:

myWords :: String -> [String]
myWords input = foldr step seed input

Answer 1

আমি যদি সঠিকভাবে বুঝতে পারি তবে আপনার প্রয়োজনীয়তার অন্তর্ভুক্ত

(1) words "a b c" == words " a b c" == ["a", "b", "c"]
(2) words "xa b c" == ["xa", "b", "c"] /= ["x", "a", "b", "c"] == words "x a b c"

এটি বোঝাতে পারে যে আমরা থাকতে পারি না

words = foldr step base

যে কোনও জন্য stepএবং base।

আসলে, আমাদের যদি তা ছিল, তবে

words "xa b c"
= def words and foldr
step 'x' (words "a b c")
= (1)
step 'x' (words " a b c")
= def words and foldr
words "x a b c"

এবং এটি বিপরীতে (2)।

আপনার অবশ্যই অবশ্যই পরে কিছু পোস্ট প্রসেসিং দরকার foldr।

Comments

আমি এই

— ভাষাটিকে

বা এমনকি ["xa"] == words "xa" == step 'x' (words "a") == step 'x' (words " a") == words "x a" == ["x", "a"], যা ভাঁজ উভয়ের দিকের জন্য একটি বৈধ যুক্তি হওয়ার সুবিধা রয়েছে

— 21:30

Answer 2

@ চির একটি দুর্দান্ত যুক্তি রয়েছে যা আপনি words"একটি" ভাঁজ ব্যবহার করে প্রয়োগ করতে পারবেন না , তবে আপনি ভাঁজ গুলি ব্যবহার করে বলেছিলেন ।

words = filterNull . words1
    where
    filterNull = foldr (\xs -> if null xs then id else (xs:)) []
    words1 = foldr (\c -> if c == ' ' then ([]:) else consHead c) []
    consHead c []       = [[c]]
    consHead c (xs:xss) = (c:xs):xss

বাইরের এবং অন্তঃস্থ উভয় ফাংশন ভাঁজ হয়। ;-)

Comments

আমি মনে করি আপনি কী বোঝাতে চেয়েছিলেন তা আপনি জানেন তবে পিক হওয়ার জন্য +1: পি

— এনরিকো মারিয়া ডি অ্যাঞ্জেলিস

Answer 3

হ্যাঁ. ঘটনাটি কিছুটা জটিল foldrতবে আপনি সিপিএসে ( কন্টিনিয়েনশন পাসিং স্টাইল ) বাস করে থাকলে আপনি একক এবং অন্য কিছুই ব্যবহার করে সঠিকভাবে এই কাজটি করতে পারেন । আমি আগে একটি বিশেষ ধরনের chunksOfফাংশন দেখিয়েছি ।

এই ধরণের ভাঁজগুলিতে আমাদের সংযোজক, সুতরাং ফলকের ফলাফলটি একটি ফাংশন এবং আমাদের এটি একটি পরিচয় ধরণের ইনপুটটিতে প্রয়োগ করতে হবে যাতে আমাদের চূড়ান্ত ফলাফল হয়। সুতরাং এটি একটি চূড়ান্ত প্রক্রিয়াজাতকরণ পর্যায় হিসাবে গণ্য হতে পারে বা না যেহেতু আমরা এখানে একটি একক ভাঁজ ব্যবহার করছি এবং এর ধরণটিতে ফাংশন অন্তর্ভুক্ত রয়েছে। বিতর্কের জন্য উন্মুক্ত :)

ws :: String -> [String]
ws str = foldr go sf str $ ""
         where
         sf :: String -> [String]
         sf s = if s == " " then [""] else [s]
         go :: Char -> (String -> [String]) -> (String -> [String])
         go c f = \pc -> let (s:ss) = f [c]
                         in case pc of
                            ""        -> dropWhile (== "") (s:ss)
                            otherwise -> case (pc == " ", s == "") of
                                         (False, False) -> (pc++s):ss
                                         (False, True)  -> (pc++s):ss
                                         (True, False)  -> "":s:ss
                                         (True, True)   -> s:ss

λ> ws "   a  b    c   "
["a","b","c"]

sf : শুরু করার জন্য প্রাথমিক ফাংশন মান।

go : পুনরাবৃত্তি ফাংশন

আমরা আমাদের পূর্ববর্তী অক্ষর pcএবং cপ্রতিটি ঘুরিয়ে কারেন্ট কারেক্টর উভয়ই থাকায় আমরা আসলে এখানে সিপিএসের শক্তিটি পুরোপুরি ব্যবহার করছি না । এটি chunksOfউল্লিখিত ফাংশনটিতে খুব দরকারী ছিল যখন প্রতিটি সময়ে উপাদানগুলির একটি আরোহণের ক্রমটি ভেঙে [Int]যায় un[[Int]]