函数式编程和逻辑？

Question

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

标题：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

学习一门全新的语言（即哈斯克尔（SASL dialect）或计划（Lisp dialect）如果你知道Java的解决（Algol dialect））比学习同一语言家族的新方言更难（例如，如果你知道Scheme，你就会了解Ruby或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这样的编程语言。