मेरे पास यह छोटा प्रोग्राम है जो इनपुट सकारात्मक या नकारात्मक है या नहीं, इस पर निर्भर करता है कि त्रिकोण को आगे या पीछे प्रिंट करता है। यह पूरी तरह से काम करता है, हर लूप के अंत को छोड़कर यह शून्य प्रिंट करता है। मैंने लूप की सीमा को बदलने की कोशिश की, लेकिन हर बार जब मैं ऐसा करता हूं तो यह त्रिकोण के आकार को प्रभावित करता है। इस के लिए कोई भी समाधान है? कृपया नीचे दिए गए कोड को खोजें।

(defun triangle(k) 
    (cond ((or(not(integerp k)) (= k 0)) '("invalid number; please enter a positive or a negative integer"))
          ((< k -1) 
             (loop for x from k to -1 do
                 (loop for y from k to -1 do 
                       (if (< y x) 
                           (princ #\Space)
                           (princ '*) 
                       ) 
                     
                  ) 
                (terpri)
              )
          )  
        
         ((or (= k 1) (= k -1)) '*) 
         (t(loop  for x from 0 to k do 
               (loop for y from 0 to k do  
                 (if (< x y)    
                     (princ '*) 
                 )
                ) 
                (terpri)
           ) 
         ) 
    ) 
)
0
abdcg 2 नवम्बर 2020, 23:04

2 जवाब

सबसे बढ़िया उत्तर
(defun triangle (k) 
  (cond ((or (not (integerp k))
             (= k 0))
         '("invalid number; please enter a positive or a negative integer"))
        ((< k -1) 
         (loop for x from k to -1 do
               (loop for y from k to -1 do 
                     (if (< y x) 
                         (princ #\Space)
                       (princ '*))) 
                (terpri)))
        ((or (= k 1) (= k -1))
         '*) 
        (t
         (loop for x from 0 to k do 
               (loop for y from 0 to k do  
                     (if (< x y)    
                         (princ '*))) 
               (terpri))))
  (values))

उदाहरण:

CL-USER 8 > (triangle 3)
***
**
*


CL-USER 9 > 
2
Rainer Joswig 3 नवम्बर 2020, 00:42

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

(defun mk-tri (n)
  (when (plusp n)
    (loop for i from 1 to n
          collect (nconc (loop repeat i collect #\*)
                         (loop repeat (- n i) collect #\space)))))

(defun print-field (field)
  (format t "~{~{~a~}~%~}" field))

(print-field (mk-tri 5))
;; *    
;; **   
;; ***  
;; **** 
;; *****

(defun invert-v (data)
  (reverse data))

(print-field (invert-v (mk-tri 5)))
;; *****
;; **** 
;; ***  
;; **   
;; *    

(defun invert-h (data)
  (mapcar #'reverse data))

(print-field (invert-h (mk-tri 5)))
;;     *
;;    **
;;   ***
;;  ****
;; *****

यह आपको पूरी तरह से स्वतंत्रता का नया स्तर देगा, जैसे आप पैटर्न ड्राइंग के लिए इस छोटे टूलकिट की कल्पना कर सकते हैं:

(defun concat-v (d1 d2)
  (append d1 d2))

(defun concat-h (d1 d2)
  (mapcar #'append d1 d2))

(defun repeat-v (n data)
  (reduce #'concat-v (loop repeat n collect data)))

(defun repeat-h (n data)
  (reduce #'concat-h (loop repeat n collect data)))

(let* ((tri (mk-tri 5))
       (tri2 (concat-v tri (invert-v tri)))
       (rect (concat-h tri2 (invert-h tri2))))
  (print-field (repeat-v 2 (repeat-h 3 rect))))
;; *        **        **        *
;; **      ****      ****      **
;; ***    ******    ******    ***
;; ****  ********  ********  ****
;; ******************************
;; ******************************
;; ****  ********  ********  ****
;; ***    ******    ******    ***
;; **      ****      ****      **
;; *        **        **        *
;; *        **        **        *
;; **      ****      ****      **
;; ***    ******    ******    ***
;; ****  ********  ********  ****
;; ******************************
;; ******************************
;; ****  ********  ********  ****
;; ***    ******    ******    ***
;; **      ****      ****      **
;; *        **        **        *
1
leetwinski 3 नवम्बर 2020, 15:11