स्कैला

Question

में एक सूची दोहराएं मैं एक स्कैला नोब हूं। मैंने सामान्य रूप से भाषा और कार्यात्मक प्रोग्रामिंग सीखने के लिए पहले अभ्यास के रूप में एक स्पाइडर सॉलिटेयर सॉल्वर लिखने का निर्णय लिया है।

मैं 1, 2, या 4 सूट वाले कार्ड के यादृच्छिक रूप से शफल डेक उत्पन्न करना चाहता हूं।

val numberOfSuits = 1 
(List("clubs", "diamonds", "hearts", "spades").take(numberOfSuits) * 4).take(4) 

जो

List("clubs", "clubs", "clubs", "clubs") 
List("clubs", "diamonds", "clubs", "diamonds") 
List("clubs", "diamonds", "hearts", "spades") 

लौटना चाहिए numberOfSuits के मूल्य पर निर्भर करता है, को छोड़कर कोई सूची "गुणा" आपरेशन है कि मैं मिल सकती है: यहाँ है कि मैं क्या के साथ आया है। क्या मुझे याद आया? शफल होने से पहले पूरा डेक उत्पन्न करने का कोई बेहतर तरीका है?

बीटीडब्ल्यू, मैं सूट के लिए गणना का उपयोग करने की योजना बना रहा हूं, लेकिन स्ट्रिंग के साथ अपना प्रश्न टाइप करना आसान था। मैं ऊपर उत्पन्न सूची लेता हूं और समझ के लिए उपयोग करता हूं, सूट पर फिर से भरता हूं और एक पूर्ण डेक उत्पन्न करने के लिए कार्ड "रैंक" की एक समान सूची लेता हूं।

Answer 1

आपको ऑब्जेक्ट List ऑब्जेक्ट के लिए स्केलैडोक देखना चाहिए। इसमें सूचियों के निर्माण के लिए दिलचस्प तरीकों के सभी शिष्टाचार हैं। उदाहरण के लिए, निम्नलिखित करता है वास्तव में क्या आप के लिए कोशिश कर रहे थे:

List.flatten(List.make(4, List("clubs", "diamonds", "hearts", "spades").take(numberOfSuits))).take(4) 

एक बहुत अच्छे कोड, हालांकि, इस (स्काला 2.7) होगा:

val suits = List("clubs", "diamonds", "hearts", "spades") 
List.tabulate(4, i => suits.apply(i % numberOfSuits)) 

स्काला 2.8 tabulate पर curried है, इसलिए सही वाक्यविन्यास होगा:

List.tabulate(4)(i => suits.apply(i % numberOfSuits)) 

Answer 2

सूचियों की एक निश्चित सूचियों फ़्लैट करें:

scala> List.fill(2)(List(1, 2, 3, 4)).flatten 
res18: List[Int] = List(1, 2, 3, 4, 1, 2, 3, 4) 

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

scala> Stream.continually(List(1, 2, 3, 4)).flatten.take(8).toList 
res19: List[Int] = List(1, 2, 3, 4, 1, 2, 3, 4) 

Answer 3

आप गुणा के बजाय एक संख्यात्मक अनुक्रम और flatMap विस्तार कर सकते हैं।

scala> (1 to 3).flatMap(_=>List(1,2,3,4).take(2)).take(4) 
res1: Seq[Int] = List(1, 2, 1, 2) 

यह 2.7.x में भी काम करता है।

---

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

class MultipliableList[T](l: List[T]) { 
    def *(n: Int) = (1 to n).flatMap(_=>l).toList 
} 
implicit def list2multipliable[T](l: List[T]) = new MultipliableList[T](l) 

और अब आप कर सकते हैं

scala> List(1,2,3)*4 
res2: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3) 

(आम तौर पर, इस तरह के implicits पुन: उपयोग करने के लिए, उन्हें एक वस्तु में घोषित करने और फिर अंतर्निहित रूपांतरण और स्कोप में संबंधित वर्ग प्राप्त करने के लिए MyObject._ आयात करें।)