函数式编程和逻辑？ [关闭]

Question

我必须解决函数式编程的一个练习。我通过迭代方案解决了，我想使用递归但不知道转换？有人可以帮我吗？

Title：N个和N个人，我会做的事情，工作表现j A [i] [j]。找到计划中的工作分配，以便获得最大的绩效？

这里是代码使用循环圈

(define (Bai15 N)
(define i 0)
(define j 0)
(define k 0)
(define t 0)
(define ii 0)
(define jj 0)
(define dem 0)
(define MaTrix (make-vector N))
(define Result (make-vector N))
(define Test (make-vector N))
(define Max 0)
(display "a.Nhap ma trận X[1..N][1..N]:")
(newline)
(newline)
(while (< i N)
     (set! (vector-ref MaTrix i) (make-vector N))
     (set! i (+ i 1))
)
(set! i 0)
(while (< i N)
       (set! k (vector-ref MaTrix i))
       (while (< j N)
             (display "X[")
             (display i)
             (display "][")
             (display j)
             (display "]= ")
             (set! (vector-ref k j) (read))
             (set! j (+ j 1))
       )
       (newline)
       (set! j 0)
       (set! i (+ i 1))
 )
 (newline)
 (set! i 0)
 (set! j 0)
 (while (< i N)
        (set! k (vector-ref MaTrix i))
        (while (< j N)
               (display (vector-ref k j))
               (display " ")
               (set! j (+ j 1))
        )
        (newline)
        (set! j 0)
        (set! i (+ i 1))
  )

  (set! i 0)
  (while (< i N)
        (set! (vector-ref Result i) -1)
        (set! i (+ i 1))
  )
  (set! i 0)
  (while (< i N)
         (set! (vector-ref Test i) -1)
         (set! i (+ i 1))
  )
  (set! i 0)
  (while (< i N)
         (display (vector-ref Test i))
         (set! i (+ i 1))
  )
  (newline)
  (set! k 0)
  (set! i 0)
  (set! j 0)
  (set! t 0)
  (set! dem 0)

  (while (< t N)
      (if (and (not (= t 0)) (= i 0))
         (set! jj t)
         (set! jj 0))
     (while (>= (vector-ref Test jj) 0)
            (set! jj (+ jj 1))
     )
     (display "jj: ")
     (display jj)
     (newline)
     (display "i: ")
     (display i)
     (newline)
     (set! k (+ (vector-ref (vector-ref MaTrix i) jj) k))
     (display "k: ")
     (display k)
     (newline)
     (set! (vector-ref Test jj) i)
     (set! ii 0)
     (display "Test: ")
     (while (< ii N)
            (display (vector-ref Test ii))
            (display " ")
            (set! ii (+ ii 1))
     )
     (newline)
     (set! dem (+ dem 1))
     (if (= dem N)
         (begin
           (if (> k Max)
            (begin
               (set! Max k)
               (display "Max: ")
               (display Max)
               (newline)
               (set! ii 0)
               (display "Result: ")
               (while (< ii N)
                      (set! (vector-ref Result ii) (vector-ref Test ii))
                      (display (vector-ref Result ii))
                      (display " ")
                      (set! ii (+ ii 1))
                )
               (newline)
               (set! i 0)
               (while (< i N)
                      (set! (vector-ref Test i) -1)
                      (set! i (+ i 1))
                )
                (set! i 0)
                (set! dem 0)
                (set! k 0)
                (set! t (+ t 1))))
          (begin
           (set! i 0)
               (while (< i N)
                      (set! (vector-ref Test i) -1)
                      (set! i (+ i 1))
                )
                (set! i 0)
                (set! dem 0)
                (set! k 0)
                (set! t (+ t 1))))
         (begin
          (set! i (+ i 1))
          ))
  )
  (newline)
  (display "Divide the work plan: ")
  (newline)
  (set! i 0)
  (while (< i N)
       (display "Job ")
       (display (+ i 1))
       (display " - People ")
       (display (+ (vector-ref Result i) 1))
       (display " work")
       (newline)
       (set! i (+ i 1))
  )
  (display "Effective: ")
  (display Max)                                 
 )

我想用递归和逻辑编程来解决

Answer 1

学习一门全新的语言（即 Haskell (SASL dialect) 或 Scheme (Lisp dialect)，如果您了解 Java (Algol dialect)）比学习同一语言家族的新方言（即学习 Ruby如果你知道 Scheme，你就会知道 Java 或 Common Lisp）

看来你已经证明你确实可以用任何语言写Fortran。

while 在 Scheme 中不存在，但由于我也编写 Algol 方言，所以我知道它应该如何工作。我猜它的定义是这样的：

(define-syntax while 
  (syntax-rules ()
    ((_ expr body ...)
     (let loop () 
       (cond (expr body ... (loop)) 
             (else 'undefined-return))))))

您的代码还有很多 (set! (vector-ref ...) new-value) 不起作用。修复此问题后，代码仍然无法正常工作。

仅将项目转换为功能性并非易事。从一个问题开始并开始使用分而治之的方法将其分成几部分要容易得多。并非所有代码都可以正常工作，因为这意味着您不能有输出也不能输入。相反，您尝试将display 和read 保留在它自己的程序中。

使用数组是一种优化手段。按照设计，它们在 Scheme 中不起作用。函数数组会生成一个新数组，而在更改元素时保持旧数组不变。我知道 Racket 有这样的数组，但没有 Scheme。最好是回避列表。

您在代码中使用define 初始化计数器并在检查某个限制时在while 中增加它的全局值的模式。为此，您可以使用命名为let，例如。在这段代码中，列出了列表。

(define N 10)
(define init-list (let zero-loop ((n N) (acc '()))
                    (if (zero? n)
                        acc ; return the accumulated list
                        (zero-loop (- n 1) (cons 0 acc))))) ; ==> undefine, init-list is (0 0 ...) 

(let lol ((n N)) (acc '())
  (if (zero? n)
      acc
      (lol (- n 1) (cons init-list acc)))) ; ==> ((0 0 0...) ...)

我不确定你的程序应该做什么，所以我会在这里停下来。您必须开始在 Scheme 中编写 Scheme。如果您对此有疑问，您应该从教程开始。或许可以关注SICP video 的讲座，或者如果你真的想变得更好，请完成SICP books exercises。在视频讲座中，您将学习如何制作像 Prolog 这样的编程语言。