Recursion 如何在DrRacket中递归平铺有缺陷的棋盘

我有一个家庭作业的问题，这是真正困扰我现在，我可以使用一些帮助，如何实现它在DrRacket。我不希望代码，只是指导，因为我对DrRacket非常陌生

任务是实施这一短语：

如果n=0，则返回空平铺（平铺结构列表）。否则，在棋盘中央放置一个tromino（L形多米诺骨牌），使其覆盖棋盘上没有缺少平铺的三个象限，并平铺每个象限

使用给定的两个.rkt文件作为递归代码。我们被允许使用tromino.rkt中的任何函数

我们还被告知，编写代码时需要以下函数，因此我对每个函数的功能进行了描述：

（中间的瓷砖和行列）
当棋盘在指定的行和列中缺少磁贴时，此函数将生成单个磁贴结构，该结构表示放置在2n×2n棋盘中心的正确定向的tromino。请记住，行和列从零开始编号。这个函数为您做了很多工作：它计算出丢失单元格所在的象限，确定要放置在电路板中心的tromino的正确方向，以便不覆盖该象限，并返回一个表示该tromino在电路板上正确位置的平铺结构

（象限n行-列象限行-象限列中缺少单元格）
2n×2n棋盘被划分为四个象限，它们的索引方式与行和列的索引方式相同。具体而言，左上象限对应于 （象限行、象限列）设置为（0,0）。其他象限是（0，1）表示右上方，（1，0）表示左下方，（1，1）表示右下方。象限内的函数缺失单元格回答了以下问题：

放置由中心瓷砖生成的瓷砖后，该象限内缺失或覆盖单元格的象限（象限行、象限列）内的（行、列）坐标是多少

答案以两个坐标的列表形式给出，以每个象限的参考框架表示。例如，如果23×23电路板中缺少的单元位于第2行第5列，则在放置中心磁贴后，将调用四个

（象限3 2 5 0 0内缺少单元格）
（象限3 2 5 0 1内缺少单元格）
（象限3 2 5 1 0内缺少单元格）
（象限3 2 5 1 1内缺少单元格）

分别返回以下四个列表：

“（3）
“（21）
“（03）
"(0)

（升级平铺m象限行象限列）
给定2n×2n棋盘的四个2m×2m象限之一的平铺（即tromino平铺列表），其中m=n−1，此函数用于变换平铺中的所有平铺，以便其坐标指向整个棋盘

您将获得一个文件tromino.rkt，如下所示

#lang racket

(require racket/draw)

(define thickness 6)
(define offset (floor (/ thickness 2)))
(define one 100)
(define two (* 2 one))
(define a 0)
(define b one)
(define c (- two thickness))

(define (mirror coordinates)
  (map (lambda (z) (- one z thickness)) coordinates))

(define x-00 (list c c a a b b))
(define y-00 (list a c c b b a))
(define x-01 (mirror x-00))
(define y-01 y-00)
(define x-10 x-00)
(define y-10 (mirror y-00))
(define x-11 x-01)
(define y-11 y-10)

(define (make-tromino-path x y)
  (let ((p (new dc-path%)))
    (send p move-to (first x) (first y))
    (send p line-to (second x) (second y))
    (send p line-to (third x) (third y))
    (send p line-to (fourth x) (fourth y))
    (send p line-to (fifth x) (fifth y))
    (send p line-to (sixth x) (sixth y))
    (send p close)
      p))

(define tromino-path-00 (make-tromino-path x-00 y-00))
(define tromino-path-01 (make-tromino-path x-01 y-01))
(define tromino-path-10 (make-tromino-path x-10 y-10))
(define tromino-path-11 (make-tromino-path x-11 y-11))

(define (tromino-path missing-row missing-column)
  (cond ((and (= missing-row 0) (= missing-column 0)) tromino-path-00)
        ((and (= missing-row 0) (= missing-column 1)) tromino-path-01)
        ((and (= missing-row 1) (= missing-column 0)) tromino-path-10)
        ((and (= missing-row 1) (= missing-column 1)) tromino-path-11)
        (else (error 'tromino-path "Called with arguments ~a, ~a (must each be either 0 or 1)"
                 missing-row missing-column))))

(define (draw-board n dc)
  (cond ((= n 1)
         (begin
           (send dc set-smoothing 'unsmoothed)
           (send dc set-pen "white" 0 'solid)
           (send dc set-brush "white" 'solid)
           (send dc draw-rectangle 0 0 two two)
           (send dc set-pen "black" 0 'solid)
           (send dc set-brush "black" 'solid)
           (send dc draw-rectangle 0 0 one one)
           (send dc draw-rectangle one one one one)))
    (else
     (begin
       (draw-board (- n 1) dc)
       (let ((side (* one (expt 2 (- n 1)))))
         (send dc copy 0 0 side side side 0)
         (send dc copy 0 0 (* 2 side) side 0 side))))))


(struct tile (row column missing-cell-row missing-cell-column))

(define (show-tile t)
  (printf "(row ~a column ~a missing-cell-row ~a missing-cell-column ~a)\n"
          (tile-row t) (tile-column t)
          (tile-missing-cell-row t) (tile-missing-cell-column t)))

(define (quadrant n row column)
  (let ((half (lambda (n coordinate)
                (cond ((bitwise-bit-set? coordinate (- n 1)) 1)
                      (else 0)))))
    (list (half n row) (half n column))))

(define (center-tile n row column)
  (let ((q (quadrant n row column))
        (base (- (expt 2 (- n 1)) 1)))
      (tile (+ base (first q)) (+ base (second q)) (first q) (second q))))

(define (missing-cell-within-quadrant n row column quadrant-row quadrant-column)
  (let ((q (quadrant n row column))
        (base (- (expt 2 (- n 1)) 1))
        (sub-coordinate (lambda (coord quad)
                          (cond ((= quad 1) (- coord (expt 2 (- n 1))))
                                (else coord)))))
    (cond ((and (= (first q) quadrant-row) (= (second q) quadrant-column))
           (list (sub-coordinate row (first q))
                 (sub-coordinate column (second q))))
          (else (list (cond ((= 0 quadrant-row) base)
                            (else 0))
                      (cond ((= 0 quadrant-column) base)
                            (else 0)))))))

(define (upgrade-tiling tiling m quadrant-row quadrant-column)
  (let* ((shift (expt 2 m))
         (row-shift (* quadrant-row shift))
         (column-shift (* quadrant-column shift)))
    (map (lambda (t)
           (tile (+ (tile-row t) row-shift)
                 (+ (tile-column t) column-shift)
                 (tile-missing-cell-row t)
                 (tile-missing-cell-column t)))
         tiling)))


(define (make-tiling-png n tiles basename)
  (cond ((or (<= n 0) (empty? tiles))
         (printf "Warning: make-tiling-png called with n too small or an empty tiling. No picture produced\n"))
        (else
         (begin
           (define side (* (expt 2 n) one))
           (define bmap (make-bitmap side side))
           (define dc (new bitmap-dc% (bitmap bmap)))
           (draw-board n dc)
           (send dc set-pen "black" 1 'solid)
           (send dc set-brush "white" 'transparent)
           (send dc draw-rectangle 0 0 side side)
           (send dc set-pen (new pen% (color "red") (width thickness)
                                 (style 'solid) (cap 'projecting) (join 'miter)))
           (send dc set-brush "gray" 'solid)
           (send dc set-smoothing 'unsmoothed)
           (map (lambda (t) (send dc draw-path (tromino-path (tile-missing-cell-row t)
                                                             (tile-missing-cell-column t))
                                  (+ offset (* one (tile-column t)))
                                  (+ offset (* one (tile-row t)))))
                tiles)
           (send bmap save-file (string-append basename ".png") 'png)))))

(provide tile
         tile-row
         tile-column
         tile-missing-cell-row
         tile-missing-cell-column
         show-tile
         quadrant
         center-tile
         missing-cell-within-quadrant
         upgrade-tiling
         make-tiling-png)

我对其工作原理有一个非常好的概念，即将2n×2n棋盘分割为4个独立的象限，然后在棋盘的中心放置一个tromino，这样每个象限现在要么缺少一个单元格，要么有一个单元格被tromino的一部分覆盖。然后，调用递归函数平铺每个象限。最终目标是让代码运行，以便在my template.rkt文件末尾调用（make and show tiling）函数时生成所生成棋盘的图片

我想我只是变得非常困惑，因为在此之前我只学过Java和Python，而DrRacket的格式/语法与这些语言相去甚远。我完全被卡住了，所以除了为我编写代码之外，任何其他帮助都会受到极大的欢迎并被感激地接受

提前谢谢你

#lang racket

(require "./tromino.rkt")

(define test-tiling (list (tile 2 5 0 1)))
(make-tiling-png 3 test-tiling "test-tiling")

**; Your code replaces the null in the following definition**
(define (tile-board n row column)
  null) 

(define (make-and-show-tiling n row column)
  (make-tiling-png n
                   (tile-board n row column)
                   (format "tiling-~a-~a-~a" n row column)))

; Initially, these calls will produce no picture
; because tile-board returns an empty tiling
(make-and-show-tiling 1 1 1)
(make-and-show-tiling 2 0 0)
(make-and-show-tiling 3 5 2)
(make-and-show-tiling 3 6 2)
(make-and-show-tiling 4 5 10)
(make-and-show-tiling 5 24 21)