scala - How to compute inverse of a multi-map -

मेरे पास एक स्कला मानचित्र है: x: [b, c] y: [b, d, e] z: [d , एफ, जी, एच]

मैं इस मैप के व्यूअर को देखने के लिए चाहता हूं। बी: [x, y] c: [x] d: [x, z] और इसी तरह।

क्या इन परिवर्तनों के बीच में उपयोग किए बिना ऐसा करने का कोई तरीका है

यदि यह एक बहु-नक्शा नहीं है - तो निम्न कार्य करता है:

  typeMap.flatMap {case (k, v) = & gt; V.map (vv = & gt; (vv, k))}  

संपादित करें: मार्थ ने सही तरीके से बताया कि इसमें शामिल करने के लिए निश्चित जवाब। मेरा जवाब उनके मुकाबले थोड़ा और अधिक है क्योंकि मैं प्रत्येक चरण के माध्यम से जाने की कोशिश करता हूं और शैक्षिक उद्देश्यों के लिए फ्लैटमैप्स द्वारा उपलब्ध कराई गई जादू का उपयोग नहीं करता है, उसका अधिक सरल है:)

मैं आपके नोटेशन के बारे में अनिश्चित हूँ। मैं मानता हूं कि आपके पास कुछ ऐसा है:

  val myMap = नक्शा [टी सेट करें [टी]] (एक्स -> सेट (बी, सी), y - & gt; सेट (  

आप निम्नानुसार रिवर्स लुकअप प्राप्त कर सकते हैं:

Code> val instances = for {keyvalue & lt; - myMap.toList value & lt; - keyValue._2} उपज (मान, कुंजी वैल्यू।)

इस बिंदु पर, आपके उदाहरण चर एक है प्रकार की सूची:

  (b, x), (c, x), (b, y) ...  

यदि आप अब करते हैं :

  val समूहबद्धउपयोग = instances.groupBy (_._ 1)  

आप प्राप्त करें:

  b - & gt; ((बी, एक्स), (बी, वाई)), सी - & gt; ((सी, एक्स)), डी - & gt; (डी, वाई), (डी, जेड)) ...  

अब हम मूल्यों को कम करना चाहते हैं ताकि वे केवल प्रत्येक जोड़ी के दूसरे भाग को शामिल कर सकें। इसलिए हम करते हैं:

  val रिवर्स लुकअप = समूहबद्ध लुकअप.मैप (_._ 1 - & gt; _._ 2.map (_._ 2))  

कौन सा इसका अर्थ है कि हर जोड़ी के लिए हम मूल कुंजी को बनाए रखते हैं, लेकिन हम उन तर्कों की सूची को मैप करते हैं जो केवल जोड़ी का दूसरा मान है।

और वहां आपके पास आपका परिणाम है

(आप एक मध्यवर्ती परिणाम को निर्दिष्ट करने से बच सकते हैं, लेकिन मैंने सोचा था कि यह इस तरह स्पष्ट है)