कैसे आप ठीक ढंग से योजना में जोड़ो में मतभेद की गणना करते हैं?

वोट
2

नंबरों की सूची को देखते हुए, कहते हैं, (1 3 6 10 0), तुम कैसे की गणना करते मतभेद (एक्स मैं - एक्स i-1 ), बशर्ते आपके पास है कि एक्स -1 = 0?

(इस उदाहरण में परिणाम होना चाहिए (1 2 3 4 -10))

मैं इस समाधान मिल गया है सही होने के लिए:

(परिभाषित करते हैं (जोड़ो में -2 च init एल)
  (प्रथम 
   (foldl
    (Λ (एक्स एसीसी-डेटा)
      (जाने ([परिणाम-सूची (पहले एसीसी-डेटा)]
            [पिछला-x (दूसरा एसीसी-डेटा)])
        (सूची 
         (संलग्न परिणाम-सूची (सूची (fx पिछला-x)))
         एक्स))) 
    (खाली सूची 0)
    एल)))

(जोड़ो में-2 - 0 '(1 से 3 में 6 से 10 0))
;; => (1 2 3 4 -10)

हालांकि, मुझे लगता है कि हालांकि कोई कम लचीला समाधान और अधिक सुरुचिपूर्ण होना चाहिए। यह सिर्फ बदसूरत है।

मैं कार्यात्मक प्रोग्रामिंग करने के लिए नया हूँ और कोड पर किसी भी सुझाव सुनना पसंद करेंगे।

धन्यवाद।

12/03/2009 को 15:46
का स्रोत उपयोगकर्ता
अन्य भाषाओं में...                            


7 जवाब

वोट
2

mapकई तर्क लेता है। तो मैं सिर्फ क्या करना होगा

(define (butlast l)
  (reverse (cdr (reverse l))))
(let ((l '(0 1 3 6 10)))
  (map - l (cons 0 (butlast l)))

आप एक समारोह में यह लपेट के लिए चाहते हैं, कहते हैं कि

(define (pairwise-call f init l)
  (map f l (cons init (butlast l))))

इस कोर्स की है नहीं लिटिल स्कीमर मार्ग, लेकिन जिस तरह से है कि अपने आप प्रत्यावर्तन लेखन टाल। जिस तरह से आपको सबसे ज्यादा पसंद का चयन करें।

13/03/2009 को 15:36
का स्रोत उपयोगकर्ता

वोट
1

नक्शे के रूप में जल्द ही के रूप में कम से कम तर्क सूची, वैसे भी समाप्त हो रहा है खत्म नहीं करता है?

(परिभाषित करते हैं (जोड़ो में-कॉल मज़ा init-तत्व lst)
  (नक्शा मज़ा lst (विपक्ष init-तत्व lst)))

संपादित करें : jleedev मुझे सूचित करता है कि इस कम से कम एक योजना कार्यान्वयन में ऐसा नहीं है। के बाद से वहाँ कोई हे (1) एक सूची के अंत बंद काटना ऑपरेशन है यह थोड़ा कष्टप्रद है।

शायद हम उपयोग कर सकते हैं reduce:

(परिभाषित करते हैं (जोड़ो में-कॉल मज़ा init-तत्व lst)
  (रिवर्स (सीडीआर (कम करने (लैम्ब्डा (ab)
                          (संलग्न (सूची ख (- बी (कार एक))) (सीडीआर एक)))
                        (विपक्ष (सूची init-तत्व) lst)))))

(अस्वीकरण: त्वरित हैक, untested)

13/03/2009 को 15:53
का स्रोत उपयोगकर्ता

वोट
1

हास्केल मुझे इस्तेमाल करने के लिए कहता है zip;)

(define (zip-with f xs ys)
  (cond ((or (null? xs) (null? ys)) null)
        (else (cons (f (car xs) (car ys))
                    (zip-with f (cdr xs) (cdr ys))))))
(define (pairwise-diff lst) (zip-with - (cdr lst) lst))

(pairwise-diff (list 1 3 6 10 0))
; gives (2 3 4 -10)
13/03/2009 को 15:51
का स्रोत उपयोगकर्ता

वोट
1

शोधन के बाद और PLT योजना के अनुरूप ढलने कुर्सी के कोड , मुझे लगता है कि लगभग सही समाधान होगा:

(परिभाषित करते हैं (जोड़ो में लागू च l0 एल)
  (यदि (खाली? एल)
      '()
      (जाने ([एल 1 (प्रथम एल)])
        (विपक्ष (च एल 1 l0) (जोड़ो में लागू च एल 1 (बाकी एल))))))
12/03/2009 को 16:49
का स्रोत उपयोगकर्ता

वोट
1

मैं कुत्ते के वर्षों में इस योजना नहीं किया है, लेकिन यह मेरे लिए एक ठेठ छोटे lisper प्रकार समस्या के रूप में बनाता है।

मैं एक आधार परिभाषा के साथ शुरू किया था (कृपया कोष्ठक के misplacement उपेक्षा - मैं एक योजना दुभाषिया आसान नहीं है:

(define pairwise-diff
    (lambda (list)
      (cond
       ((null? list) '())
       ((atom? list) list)
       (t (pairwise-helper 0 list)))))

इस बातिल और परमाणु और उसके बाद प्रतिनिधियों एक सहायक के लिए मांस मामले की बकवास मामलों को संभालती है:

(define pairwise-helper
    (lambda (n list)
       (cond
         ((null? list) '())
         (t
            (let ([one (car list)])
               (cons (- one n) (pairwise-helper one (cdr list))))
         ))))

आप "अगर" का उपयोग कर इस पुनर्लेखन सकता है, लेकिन मैं cond उपयोग करने के लिए hardwired हूँ।

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

12/03/2009 को 16:12
का स्रोत उपयोगकर्ता

वोट
0
(define (f l res cur)
  (if (null? l)
    res
    (let ((next (car l)))
      (f (cdr l) (cons (- next cur) res) next))))

(define (do-work l)
  (reverse (f l '() 0)))

(do-work '(1 3 6 10 0))

==> (1 2 3 4 -10)
06/04/2009 को 13:43
का स्रोत उपयोगकर्ता

वोट
0

यह सबसे आसान तरीका है:

(define (solution ls)
  (let loop ((ls (cons 0 ls)))
    (let ((x (cadr ls)) (x_1 (car ls)))
      (if (null? (cddr ls)) (list (- x x_1))
          (cons (- x x_1) (loop (cdr ls)))))))

(display (equal? (solution '(1)) '(1))) (newline)
(display (equal? (solution '(1 5)) '(1 4))) (newline)
(display (equal? (solution '(1 3 6 10 0)) '(1 2 3 4 -10))) (newline)

उदाहरण से प्रत्येक के लिए कोड विस्तार लिखें देखने के लिए कि यह कैसे काम करता है।

आप में एफपी साथ शुरू हो रही रुचि रखते हैं, बाहर की जाँच करने के लिए प्रोग्राम डिजाइन करने के लिए कैसे सुनिश्चित करें। यकीन है कि यह लोगों के लिए लिखा है ब्रांड नई प्रोग्रामिंग करने के लिए, लेकिन यह भीतर अच्छा एफपी मुहावरों की टन है।

27/03/2009 को 19:36
का स्रोत उपयोगकर्ता

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more