बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala · पाठ

foldLeft और foldRight

संग्रहों को एक मान में समेटें।

पाठ 3, कुल 4 में से13 चरण

foldLeft और foldRight, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

संग्रह को फ़ोल्ड करना

फ़ोल्डिंग संचायक के साथ तत्वों को बार-बार मिलाकर किसी संग्रह को एकल मान में समेटती है।

आपने जो संचायक पैटर्न सीखा है, fold उसी का अमूर्त रूप है। रिकर्सिव सहायक स्वयं लिखने के बजाय आप एक शुरुआती मान और संयोजन फ़ंक्शन देते हैं।

foldLeft की मूल बातें

foldLeft एक प्रारंभिक संचायक और (acc, element) फ़ंक्शन लेता है और संग्रह को बाएँ से दाएँ देखता है।

हर चरण में यह संचायक को फ़ंक्शन के परिणाम से बदल देता है।

val xs = List(1, 2, 3, 4)
val total = xs.foldLeft(0)((acc, x) => acc + x)

@main def run(): Unit =
  println(total)  // 10

foldLeft का संयोजन

foldLeft बाईं ओर से कोष्ठक लगाता है। seed z के साथ List(1, 2, 3) के लिए यह f(f(f(z, 1), 2), 3) निकालता है।

संचायक बायाँ आर्ग्यूमेंट होता है, इसलिए सूची में दाईं ओर बढ़ते हुए परिणाम जमा होता जाता है।

// List(1, 2, 3).foldLeft(0)(_ + _)
// = ((0 + 1) + 2) + 3
// = 6

foldRight की मूल बातें

foldRight भी तत्वों को मिलाता है, लेकिन दाईं ओर से शुरू करता है।

इसका फ़ंक्शन (element, acc) लेता है, जिसमें element बाईं ओर और संचायक दाईं ओर होता है।

val xs = List(1, 2, 3, 4)
val total = xs.foldRight(0)((x, acc) => x + acc)

@main def run(): Unit =
  println(total)  // 10

foldRight का संयोजन

foldRight दाईं ओर से कोष्ठक लगाता है। seed z के साथ List(1, 2, 3) के लिए यह f(1, f(2, f(3, z))) निकालता है।

seed सबसे दाईं ओर रहता है और सूची को अंत से भीतर की ओर जोड़ा जाता है।

// List(1, 2, 3).foldRight(0)(_ + _)
// = 1 + (2 + (3 + 0))
// = 6

दिशा कब महत्वपूर्ण होती है

sum या product जैसे एसोसिएटिव और कम्यूटेटिव ऑपरेशन में दोनों फ़ोल्ड एक ही उत्तर देते हैं।

घटाव या सूची बनाने जैसे गैर-कम्यूटेटिव ऑपरेशन में दिशा परिणाम बदल देती है। सोच-समझकर चुनें।

val xs = List(1, 2, 3)
val l = xs.foldLeft(0)(_ - _)   // ((0-1)-2)-3 = -6
val r = xs.foldRight(0)(_ - _)  // 1-(2-(3-0)) = 2

@main def run(): Unit =
  println((l, r))  // (-6, 2)

सूची बनाना

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

यह क्रम बनाए रखते हुए हर तत्व को मैप करता है।

val xs = List(1, 2, 3)
val doubled = xs.foldRight(List.empty[Int]) { (x, acc) =>
  (x * 2) :: acc
}

@main def run(): Unit =
  println(doubled)  // List(2, 4, 6)

foldLeft क्रम उलटता है

यदि आप foldLeft से सूची बनाकर तत्वों को आगे जोड़ते हैं, तो परिणाम उलटे क्रम में आता है, क्योंकि दाईं ओर बढ़ते समय तत्व पहले आगे जोड़े जाते हैं।

कभी-कभी यही परिणाम आपको चाहिए होता है।

val xs = List(1, 2, 3)
val rev = xs.foldLeft(List.empty[Int]) { (acc, x) =>
  x :: acc
}

@main def run(): Unit =
  println(rev)  // List(3, 2, 1)

स्टैक सुरक्षा

foldLeft टेल रिकर्सिव है और लूप की तरह चलता है, इसलिए यह बहुत बड़े संग्रह पर सुरक्षित है।

List पर foldRight टेल रिकर्सिव नहीं है और बहुत लंबी सूचियों में स्टैक ओवरफ़्लो कर सकता है। जब दाएँ से बाएँ क्रम आवश्यक न हो, तो foldLeft को प्राथमिकता दें।

// Safe even for millions of elements:
val n = (1 to 1000000).foldLeft(0L)(_ + _)

// foldRight on a long List risks StackOverflowError

परिणाम का प्रकार बदलना

संचायक का प्रकार तत्वों के प्रकार से अलग हो सकता है।

यहाँ हम पूर्णांकों की सूची को स्ट्रिंग में फ़ोल्ड करते हैं, इसलिए seed खाली स्ट्रिंग है और हर चरण में कुछ जोड़ा जाता है।

फ़ोल्ड का प्रकार seed से निर्धारित होता है।

val xs = List(1, 2, 3)
val s = xs.foldLeft("")((acc, x) => acc + x.toString)

@main def run(): Unit =
  println(s)  // "123"

फ़ोल्ड: हर काम का औज़ार

सूची के कई ऑपरेशन fold के विशेष रूप हैं: sum, product, length, max, map, filter, reverse।

इनके पीछे मौजूद fold को पहचानने से आप हाथ से लिखे रिकर्शन के बजाय संक्षिप्त, घोषणात्मक कोड लिख सकते हैं।

val xs = List(4, 1, 7, 3)
val maxV = xs.foldLeft(Int.MinValue)(_ max _)
val len  = xs.foldLeft(0)((acc, _) => acc + 1)

@main def run(): Unit =
  println((maxV, len))  // (7, 4)

त्वरित जाँच

फ़ोल्ड की दिशा और seed की स्थिति के बारे में विचार करें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावृत्ति

foldLeft संचायक को बाईं ओर रखते हुए बाएँ से दाएँ चलता है और ((z op a) op b) op c निकालता है। यह टेल रिकर्सिव और स्टैक-सुरक्षित है।

foldRight seed को दाईं ओर रखते हुए दाएँ से बाएँ चलता है और a op (b op (c op z)) निकालता है। यह क्रम बनाए रखते हुए सूची बनाने के लिए उपयुक्त है, लेकिन लंबी सूचियों में स्टैक ओवरफ़्लो कर सकता है।

seed परिणाम का प्रकार निर्धारित करता है, इसलिए फ़ोल्ड किसी संग्रह को किसी भी मान में बदल सकते हैं।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Scala सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 143

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “foldLeft और foldRight” पाठ निःशुल्क है?

हाँ—“foldLeft और foldRight” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“foldLeft और foldRight” में मैं क्या सीखूँगा?

संग्रहों को एक मान में समेटें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“foldLeft और foldRight” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ