1

我已经实现了一个问题，它从语法 (Vn;Vt;P;S) 中确定非生产性或不可访问的元素，其中 Vn - 变量集；Vt- 终端集和 P - 生产规则，以及 S - 开始符号。

;;; Defining a grammar
(defvar *VN* '(A B C D S)) ; non-terminal variables
(defvar *VT* '(k m n)) ; terminal
(defvar *P* '((S A B) ; set of production rules
              (S C D)
              (S A k)
              (A k)
              (B m)
              (B D m D)
              (C n)))

;;; FINDING PRODUCTIVE ELEMENTS

(defun PROD-STEP (VT P PRODS)
  ;;(format t "P = ~S~%" P)
  ;;(format t "PRODS = ~S~%" PRODS)
  (if (null P)
      PRODS
      (if (subsetp (rest (first P)) (union VT PRODS))
          (PROD-STEP VT (rest P) (union (cons (first (first P)) nil) PRODS))
          (PROD-STEP VT (rest P) PRODS))))

(defun PROD-AUX (VT P PRODS oldLength)
  (if (= (length PRODS) oldLength)
      PRODS
      (PROD-AUX VT P (PROD-STEP VT P PRODS) (length PRODS))))

(defun PROD (VT P)
    (PROD-AUX VT P nil -1))

;;; END OF FINDING PROD ELEMENTS

(trace PROD-STEP)
(trace PROD-AUX)
(trace PROD)
(PROD *VT* *P*)

;;; FINDING ACCESSIBLE ELEMENTS

(defun ACCESS-STEP (P ACC)
  ;;(format t "Pacc = ~S~%" P)
  ;;(format t "ACC = ~S~%" ACC)
  (if (null P)
      ACC
      (if (member (first (first P)) ACC)
          (ACCESS-STEP (rest P) (union (rest (first P)) ACC))
          (ACCESS-STEP (rest P) ACC))))

(defun ACCESS-AUX (P ACC oldLength)
  (if (= (length ACC) oldLength)
      ACC
      (ACCESS-AUX P (ACCESS-STEP P ACC) (length ACC))))

(defun ACCESS (P S)
  ;;(format t "Paccess = ~S~%" P)
  (ACCESS-AUX P (cons S nil) 0))

 ;;; END OF FINDING ACCESSIBLE ELEMENTS

(trace ACCESS-STEP)
(trace ACCESS-AUX)
(trace ACCESS)
(ACCESS *P* 'S)

;;; REMOVING INACCESSIBLE AND NOT PRODUCTIVE ELEMENTS

(defun BuildRules-AUX (VT ACCS PRODS P newP)
  ;;(format t "newP = ~S~%" newP)
  (if (null P)
      newP
      ;; VN' = (ACCESS(G) INTERSECT PROD(G))
      ;; VT' = (VT INTERSECT ACCESS(G))
      ;; DACA REGULA ESTE A->X, A = (first (first P)) SI X = (rest (first P))
      ;; VERIFICAM DACA A APARTINE VN' SI X APARTINE (VT' UNION VN')
      (if (and (member (first (first P)) (intersection PRODS ACCS))
               (subsetp (rest (first P))
                        (union (intersection ACCS PRODS)
                               (intersection VT ACCS))))
          (BuildRules-AUX VT ACCS PRODS (rest P) (union newP 
                                                        (cons (first P) nil)))
          (BuildRules-AUX VT ACCS PRODS (rest P) newP))))

(defun BuildRules (VT ACCS PRODS P)
  (BuildRules-AUX VT ACCS PRODS P nil))

(trace BuildRules-AUX)
(trace BuildRules)

(BuildRules *VT* (ACCESS *P* 'S) (PROD *VT* *P*)*P*)

(defun SIMPL-AUX (VN VT P S ACCS PRODS)
  (setq ACCS (ACCESS P S))
  (setq PRODS (PROD VT P))
  (if (and (null (set-difference (union VN VT) ACCS))
           (null (set-difference VN PRODS)))
      (cons VN (cons VT (cons P S)))
      (SIMPL-AUX (intersection ACCS PRODS)
                 (intersection VT ACCS)
                 (BuildRules VT ACCS PRODS P)
                 S
                 ACCS
                 PRODS)))

(defun SIMPL (VN VT P S)
  (SIMPL-AUX *VN* *VT* *P* 'S nil nil))

;;; END OF REMOVING INACCESSIBLE AND NOT PRODUCTIVE ELEMENTS

;;; GETTING THE RESULTS

(SIMPL *VN* *VT* *P* 'S)

但现在我坚持得到一些中间结果。

为了高效和易于访问，很明显我会使用PRODand ACCESS,

(PROD *VT* *P*) 
(ACCESS *P* 'S)

但我不确定如何获得一些中间结果：

  1. 非生产性
  2. 无法访问

因为我只有一个功能：

(BuildRules *VT* (ACCESS *P* 'S) (PROD *VT* *P*) *P*)

你能帮忙解决这个问题吗？

4

1 回答 1

0

您只需要使用build-rules仅过滤一种谓词的替换函数。顺便说一句，使用 可以写得更清楚remove-if-not。

于 2012-05-06T16:03:28.310 回答