বড় ছবি পেতে হাস্কেল কোডের টুকরো একত্রিত করা

Question

এই কোডটি আমি কোথাও এসেছি কিন্তু এটি কীভাবে কাজ করে তা জানতে চাই:

    findIndices :: (a -> Bool) -> [a] -> [Int]
    findIndices _ [] = []
    findIndices pred xs = map fst (filter (pred . snd) (zip [0..] xs))

আউটপুট: FindIndices (== 0) [1,2,0,3,0] == [2,4] , যেখানে পূর্ববর্তী (== 0) এবং xs [1,2,0,3,0]

আমি আমার কিছু বোঝাপড়া প্রদর্শন করব:

    (zip [0..] xs)

উপরের লাইনটি যা করে তা হ'ল তালিকার প্রতিটি কিছুর জন্য সূচকগুলি। উপরে বর্ণিত ইনপুটটির জন্য, এটি দেখতে এরকম হবে: [(0,1), (1,2), (2,0), (3,3), (4,0)]

    (pred . snd)

আমি দেখতে পেয়েছি যে এর অর্থ পূর্বের (এসএনডি (এক্স)) এর মতো কিছু। আমার প্রশ্ন, এক্সটি কি জিপ লাইন থেকে তৈরি তালিকা? আমি হ্যাঁর দিকে ঝুঁকছি তবে আমার অনুমানটি খুব কম।

এর পরে, fst এবং snd সম্পর্কে আমার বোঝা। আমি জানি

    fst(1,2) = 1 

এবং

    snd(1,2) = 2

এই 2 টি আদেশটি কোডটিতে কীভাবে বোঝায়?

ফিল্টার সম্পর্কে আমার বোঝা হ'ল এটি শর্তের সাথে মেলে এমন আইটেমগুলির একটি তালিকা ফেরত দেয়। এই ক্ষেত্রে,

    listBiggerThen5 = filter (>5) [1,2,3,4,5,6,7,8,9,10]

[6,7,8,9,10] দেবে

আমার মানচিত্রের বোঝাপড়াটি হ'ল এটি তালিকার প্রতিটি আইটেমের জন্য একটি ফাংশন প্রয়োগ করে। এই ক্ষেত্রে,

    times4 :: Int -> Int
    times4 x = x * 4
    listTimes4 = map times4 [1,2,3,4,5]

[4,8,12,16,20] দেবে

এটি সামগ্রিকভাবে কীভাবে কাজ করে? আমি মনে করি আমি এ পর্যন্ত যা জানি আমি তার মধ্যে ব্যাপক ছিলাম তবে টুকরাগুলি একসাথে রাখতে পারি না। কেউ আমাকে সাহায্য করতে পারেন?

Comments

আমি কেবল এই প্রশ্নটি পড়ে বিরল আনন্দ বলে বলতে চাই। আমরা পেয়েছি "হেক এই কোডটি কীভাবে কাজ করে?" প্রশ্নগুলি ঘন ঘন, তবে খুব কমই জিজ্ঞাসাবাদী কী করে এবং ইতিমধ্যে বুঝতে পারে না তার এই স্তরের ব্যাখ্যা দিয়ে। এটি আপনার যে ফাঁকগুলি রয়েছে তার ঠিক সম্পর্কে একটি ভাল, লক্ষ্যযুক্ত উত্তর লিখতে সত্যই মজাদার করে তোলে।

— ড্যানিয়েল ওয়াগনার

আপনাকে ধন্যবাদ ড্যানিয়েল! আমি এই সমস্যায় অনেক সময় ব্যয় করেছি এবং সে কারণেই আমার যা প্রয়োজন তার সাহায্য করতে পারি।

— শ্রীমান গৌতম

আমি যোগ করতে চাই যে @ উইলনেস উত্তরটি কাজ করে। এটি চোখে আরও সহজ এবং সহজে বোঝা যায়।

— শ্রীমান গৌতম

Answer 1

হাস্কেলে আমরা বলতে চাই, প্রকারগুলি অনুসরণ করুন । প্রকৃতপক্ষে টুকরাগুলি সংযোগ করে যেন তারের মাধ্যমে প্রকারের সাথে একই রকম হয়:

(প্রথমত, ফাংশন রচনাটি হ'ল:

   (f >>> g) x  =  (g . f) x  =        g (f x)
   (f >>> g)    =  (g . f)    =  \x -> g (f x)

এবং ফাংশন রচনার ধরণের অনুমানের নিয়মটি হ'ল:

    f        :: a -> b                   --      x  :: a
          g  ::      b -> c              --    f x  :: b
   -------------------------             -- g (f x) :: c
    f >>> g  :: a ->      c
    g  .  f  :: a ->      c

এখন,)

findIndices :: (b -> Bool) -> [b] -> [Int]
findIndices pred  = \xs -> map fst ( filter (pred . snd) ( zip [0..] xs ))
                  =        map fst . filter (pred . snd) . zip [0..]
                  =  zip [0..]  >>>  filter (snd >>> pred)  >>>  map fst
---------------------------------------------------------------------------
zip :: [a] ->          [b]        ->        [(a,  b)]
zip  [0..] ::          [b]        ->        [(Int,b)]
---------------------------------------------------------------------------
        snd           :: (a,b) -> b
                pred  ::          b -> Bool
       ------------------------------------
       (snd >>> pred) :: (a,b)      -> Bool
---------------------------------------------------------------------------
filter ::               (t          -> Bool) -> [t]   -> [t]
filter (snd >>> pred) ::                      [(a,b)] -> [(a,b)]
filter (snd >>> pred) ::                    [(Int,b)] -> [(Int,b)]
---------------------------------------------------------------------------
    fst ::                                   (a,   b) -> a
map     ::                                  (t        -> s) -> [t] -> [s]
map fst ::                                                 [(a,b)] -> [a]
map fst ::                                               [(Int,b)] -> [Int]

সুতরাং, সামগ্রিকভাবে,

zip  [0..] ::          [b]        ->        [(Int,b)]
filter (snd >>> pred) ::                    [(Int,b)] -> [(Int,b)]
map fst ::                                               [(Int,b)] -> [Int]
---------------------------------------------------------------------------
findIndices pred ::    [b] ->                                         [Int]

আপনি জিজ্ঞাসা করেছেন, এই টুকরাগুলি একসাথে কীভাবে খাপ খায়?

এই হল কিভাবে.

---

সঙ্গে তালিকা comprehensions , আপনার ফাংশন হিসাবে লেখা হয়

findIndices pred xs = [ i | (i,x) <- zip [0..] xs, pred x ]

সিউডোকোডে যা পড়ে:

"ফলাফলের তালিকা রয়েছে iপ্রত্যেকের জন্য (i,x)এ zip [0..] xsযেমন যে pred xঝুলিতে" ।

এটি nদীর্ঘ - দীর্ঘ ঘুরিয়ে দিয়ে এটি করে

xs = [a,b,...,z] = [a] ++ [b] ++ ... ++ [z]

মধ্যে

  [0 | pred a] ++ [1 | pred b] ++ ... ++ [n-1 | pred z]

যেখানে [a | True]হয় [a]এবং [a | False]হয় []।

Comments

আপনি আপনার ভোট মানুষ পেয়েছেন। ধন্যবাদ!

— শ্রীমান গৌতম

Answer 2

আমি দেখতে পেলাম যে এর অর্থ কিছু একটা pred (snd (x))। আমার প্রশ্ন, এক্সটি কি জিপ লাইন থেকে তৈরি তালিকা? আমি হ্যাঁর দিকে ঝুঁকছি তবে আমার অনুমানটি খুব কম।

ভাল pred . snd, মানে \x -> pred (snd x)। সুতরাং এটি মূলত এমন একটি ফাংশন তৈরি করে যা একটি উপাদানকে মানচিত্র xকরে pred (snd x)।

এর অর্থ হ'ল অভিব্যক্তিটি এমন দেখাচ্ছে:

filter (\x -> pred (snd x)) (zip [0..] xs)

এখানে xএকটি 2-tuple দ্বারা উত্পাদিত হয় zip। তাই যাতে জানতে তাহলে (0, 1), (1,2), (2, 0), ইত্যাদি ফলাফলে অপরিবর্তিত রাখা হয়, snd xএই 2-tuples (তাই দ্বিতীয় উপাদান গ্রহণ করা হবে 1, 2, 0, ইত্যাদি), এবং চেক যদি predTha উপাদান বা সন্তুষ্ট নয়। যদি এটি সন্তুষ্ট হয় তবে এটি উপাদানটি ধরে রাখতে পারে, অন্যথায় element উপাদানটি (2-টিপল) ফিল্টার আউট করা হয়।

তাই আপনি যদি (== 0)হয় predicate, তারপর filter (pred . snd) (zip [0..] xs)2-tuples উপস্থিত থাকবে [(2, 0), (4, 0)]।

তবে এখন ফলাফলটি 2-টিউপলগুলির একটি তালিকা। আমরা যদি সূচকগুলি চাই তবে আমাদের কোনওভাবে 2-টিউপল এবং এই 2-টিউপসগুলির দ্বিতীয় উপাদান থেকে মুক্তি পাওয়া দরকার। আমরা fst :: (a, b) -> aএটির জন্য ব্যবহার করি: এটি তার প্রথম উপাদানটিতে একটি 2-টিপল মানচিত্র করে। সুতরাং একটি তালিকার জন্য [(2, 0), (4, 0)], map fst [(2, 0), (4, 0)]ফিরে আসবে [2, 4]।

Comments

আরে উইলেম, কী দুর্দান্ত ব্যাখ্যা! আমি এখন পুরো কোডটি বুঝতে পেরেছি। ধন্যবাদ জনাব!

— শ্রীমান গৌতম