योजना: सूची

Question

से डुप्लिकेट किए गए नंबर निकालें मैं एन

(define (create-list . e) 
    e) 

दिए गए तर्कों के संख्या से एक सूची बनाने के लिए इस कोड को लिखा था लेकिन मैं इसे इस ब्लॉक के भीतर ही सूची से किसी भी दोहराया नंबर निकाल सकते हैं की जरूरत है।

मैंने घंटों की कोशिश की और खोज की है और अन्य ब्लॉकों पर कोड की दर्जनों लाइनों को रखे बिना समाधान नहीं मिल पा रहा है।

उदाहरण के लिए मान लीजिए कि मेरी इनपुट

(create-list . 2 2 3 5 5) 

मैं होने के लिए बनाई गई सूची की जरूरत है जाने '(2 से 3 5) और नहीं' (2 2 3 5 5) ...

आदेश संख्याओं का कोई फर्क नहीं पड़ता।

(define (create-list . e) (dedupe e)) 

मैं यह करने के एक बहुत सरल लेकिन शायद अक्षम रास्ता के बारे में सोच सकते हैं::

Answer 1

मूल रूप से, आप की तरह कुछ करने की ज़रूरत है

(define (dedupe e) 
    (if (null? e) '() 
     (cons (car e) (dedupe (filter (lambda (x) (not (equal? x (car e)))) 
            (cdr e)))))) 

आप मौजूदा कार्यों का उपयोग नहीं कर सकते जैसे filter, तो आप एक अपने आप बना सकते हैं:

(define (my-filter pred ls) 
    (cond ((null? ls) '()) 
     ((pred (car ls)) (cons (car ls) (my-filter pred (cdr ls)))) 
     (else (my-filter pred (cdr ls))))) 

Answer 2

सबसे कुशल (trave सूची को एक बार rsing) ऐसा करने का तरीका एक तत्व को परिभाषित करना है जो सूची तत्व-दर-तत्व के माध्यम से जाता है। फ़ंक्शन एक सूची संग्रहीत करता है कि कौन से तत्व पहले ही डी-डुप्ड सूची में हैं।

@ टिखॉन जेल्विस के इस समाधान का लाभ यह है कि सूची तत्वों को क्रमबद्ध करने के क्रम में होने की आवश्यकता नहीं है।

एक समारोह elem, जो कहते हैं अगर al का एक तत्व है यह देखते हुए:

(define (elem? a l) 
     (cond ((null? l) #f) 
      ((equal? a (car l)) #t) 
      (else (elem? a (cdr l))))) 

हम सूची पार कर सकते हैं, प्रत्येक तत्व भंडारण हम पहले नहीं देखा है:

(define (de_dupe l_remaining already_contains) 
    (cond ((null? l_remaining) already_contains) 
     ((elem? (car l_remaining) already_contains) (de_dupe (cdr l_remaining) already_contains)) 
     (else (de_dupe (cdr l_remaining) (cons (car l_remaining) already_contains))))) 

नोट : दक्षता के लिए, यह तत्वों को विपरीत क्रम में

Answer 3

यह एक तेज़ है:

(define (remove-duplicates l) 
    (cond ((null? l) 
     '()) 
     ((member (car l) (cdr l)) 
     (remove-duplicates (cdr l))) 
     (else 
     (cons (car l) (remove-duplicates (cdr l)))))) 

लेकिन फिर भी बेहतर, mit-योजना है जिसमें करता है आप अपनी ज़रुरत को नष्ट-डुप्लिकेट प्रदान करता है।

Answer 4

(define (delete x) 
(cond 
((null? x) x) 
((= (length x) 1) x) | ((null? (cdr x)) x) 
((= (car x) (cadr x)) (delete (cdr x))) 
(#t (cons (car x) (delete (cdr x)))) 
) 
)