हास्केल, प्राकृतिक संख्या

Question

की सूची मैं हास्केल में एक निरपेक्ष नौसिखिया अभी तक समझने के लिए यह कैसे काम करता कोशिश कर रहा हूँ।

मैं ऐसे [1,2,3,4,5 ...] के रूप में पूर्णांकों का अपने ही आलसी सूची लिखना चाहते हैं।

लोगों की सूची के लिए मैं

ones = 1 : ones 

लिखा है और जब की कोशिश की, ठीक काम करता है:

*Main> take 10 ones 
[1,1,1,1,1,1,1,1,1,1] 

मैं कैसे पूर्णांकों को बढ़ाने के लिए एक ही कर सकते हैं?

मैं इस की कोशिश की है, लेकिन यह वास्तव में विफल रहता है:

int = 1 : head[ int + 1] 

और उसके बाद मैं एक विधि है कि दो धाराओं गुणा कैसे बना सकते हैं? जैसे:

mulstream s1 s2 = head[s1] * head[s2] : mulstream [tail s1] [tail s2] 

Answer 1

कारण है कि int = 1 : head [ int + 1] काम नहीं करता हैं:

• सिर एक भी तत्व दिखाए, लेकिन : आवश्यकताओं के दूसरा तर्क एक सूची होने के लिए।
• int + 1 एक सूची है और एक संख्या है, जो संभव नहीं है जोड़ने के लिए कोशिश करता है।

1 से अनंत तक की गिनती सूची बनाने के लिए सबसे आसान तरीका है [1..]

1 के अलावा अन्य चरणों में गणना करने के लिए आप [firstElement, secondElement ..] उपयोग कर सकते हैं, उदाहरण के लिए है [.. 1, 3]

रूप [x, f x, f (f x), f (f (f x)),...] के अनंत सूचियों आप iterate f x, उदा उपयोग कर सकते हैं पाने के लिए: सभी सकारात्मक अजीब पूर्णांकों की एक सूची बनाने के लिए iterate (*2) 1 सूची [1, 2, 4, 16,...] वापस कर देगा।

दो सूची के तत्वों में से प्रत्येक जोड़ी पर एक आपरेशन जोड़ो में लागू करने के लिए zipWith का उपयोग करें:

mulstream s1 s2 = zipWith (*) s1 s2 

इस परिभाषा अधिक संक्षिप्त बनाने के लिए आप बिंदु से मुक्त फार्म का उपयोग कर सकते हैं:

mulstream = zipWith (*) 

Answer 2

प्राकृतिक संख्याओं के लिए आपको मानचित्र का उपयोग करना होगा:

num1 = 1 : map (+1) num1 

या समझ:

num2 = 1 : [x+1 | x <- num2] 

या निश्चित रूप से:

num3 = [1..] 

Answer 3

वाक्य रचना langauge में इस बात के लिए नहीं है:

take 10 [1,2..] 

=> [1,2,3,4,5,6,7,8,9,10] 

तुम भी कर सकते हैं विभिन्न प्रगति:

take 10 [1,3..] 
=> [1,3,5,7,9,11,13,15,17,19] 

Answer 4

मैं मुझे यकीन नहीं है कि यह वही है जो आप पूछ रहे थे, लेकिन ऐसा लगता है कि आप चाहते थे किसी भी अन्य सूची पर भरोसा किए बिना, बढ़ती प्राकृतिक संख्याओं की एक सूची बनाने के लिए। तो, उस टोकन करके, आप चीजों की तरह

incr a = a : inrc (a+1) 
lst = inrc 1 

take 3 lst 
=> [1,2,3] 

यही कारण है, तकनीकी तौर पर, एक जमा समारोह (मेरा मानना ​​है कि) कहा जाता है और उसके बाद हम सभी 'lst'

के साथ आसानी से प्रयोग करने योग्य यह का एक विशेष मामला बनाने की थी क्या कर सकते हैं

तुम वहाँ से पागल हो जाना कर सकते हैं, जैसे काम करने:

lst = 1 : incr lst where incr a = (head a) + 1 : incr (tail a) 

take 3 lst 
=> [1,2,3] 

और इतने पर है, हालांकि यह है कि शायद कुछ सामान है कि आप अभ्यस्त अभी तक सीखा है पर निर्भर करता है (जहां) - ओ पी द्वारा पहचानने - लेकिन यह होना चाहिए अभी भी बहुत आसानी से पढ़ा है।

ओह, दाएं, और फिर सूची गुणा। ठीक है, आप zipWith (*) जैसा कि ऊपर उल्लेख उपयोग कर सकते हैं, या आप चक्र की तरह इस (इसे और अधिक मजेदार है एक नए अंदाज़ में कर सकता है, मुझ पर भरोसा :)

lmul a b = (head a * head b) : lmul (tail a) (tail b) 
safemul a b = take (minimum [len a, len b]) (lmul a b) 

safemul लिए कारण है, मुझे विश्वास है, तुम बाहर से पा सकते हैं समारोह के साथ प्रयोग कर रहा है, लेकिन इसे 'पूंछ' के साथ करना है। मुसीबत यह है कि, खाली सूची, मेल नहीं खाए गए सूचियों और इसी तरह के लिए कोई मामला नहीं है, इसलिए आपको या तो विभिन्न परिभाषाओं को एक साथ हैक करना होगा (lmul _ [] = []) या गार्ड का उपयोग करें और कहां और इसी तरह ... या ज़िप के साथ छड़ी :)