建立2D清单

Question

寻找一个可以完成以下功能的函数：

   (foo 3 2) => '( ( (1 1) (1 2) (1 3) )
                   ( (2 1) (2 2) (2 3) ) )

DrRacket中是否有任何内置功能可以实现这一目标？

Answer 1

要在Racket中获取此类内容的主要工具是各种for循环。 假设您要创建一个基于列表的矩阵结构，那么这是获得它的一种方法：

#lang racket
(define (foo x y)
  (for/list ([i y])
    (for/list ([j x])
      (list (add1 i) (add1 j)))))

而且由于人们提出了一个更普遍的问题，即如何使foo创建任意维度的矩阵，因此这是一个通用版本，可以处理任意数量的参数，并且在调用(foo 3 2)时仍返回相同的结果：

#lang racket
(define (foo . xs)
  (let loop ([xs (reverse xs)] [r '()])
    (if (null? xs)
      (reverse r)
      (for/list ([i (car xs)])
        (loop (cdr xs) (cons (add1 i) r))))))

（请注意，在两种情况下，我都是基于0的简单迭代，并使用add1来获取所需的数字。另一种方法是替换

(for/list ([i x]) ... (add1 i) ...)

同

(for/list ([i (in-range 1 (add1 x)]) ... i ...)

）

Answer 2

（定义（build-2d行col）（构建列表行（lambda（x）（构建列表col（lambda（y）（列表（+ x 1）（+ y 1）））））））

Answer 3

码：

(define (foo-makey const max data)
  (let* ((i (length data))
         (newy (- max i))
         (newpair (cons const newy)))
    (if (= max i)
        data
        (foo-makey const max
                   (cons newpair data)))))

(define (foo-makex xmax ymax data)
  (let* ((i (length data))
         (newx (- xmax i)))        
    (if (= xmax i)
        data
        (foo-makex xmax ymax
                   (cons (foo-makey newx ymax '()) data)))))

(define (foo x y)
  (foo-makex y x '()))

输出：

> (foo 3 2)
'(((1 . 1) (1 . 2) (1 . 3)) ((2 . 1) (2 . 2) (2 . 3)))

Answer 4

我无法按原样回答您的问题，因为我不知道嵌套列表应如何用于> 2个参数。 AFAIK没有内置功能可以执行您想要的操作。

首先，这里有一些代码可生成没有嵌套列表的输出。 作为练习，请尝试调整代码以执行嵌套列表。 看看是否有办法使代码更有效。

;;can take in any number of arguments
(define (permutations . nums)
  (foldl
   (lambda (current-num acc)
     (append-map
      (lambda (list-in-acc)
        (for/list ((i (build-list current-num (curry + 1))))
          (append list-in-acc (list i))))
      acc))
   (list (list))
   (reverse nums)))

范例1：

> (permutations 3 2)
'((1 1) (1 2) (1 3) (2 1) (2 2) (2 3))

范例2：

> (permutations 10)
'((1) (2) (3) (4) (5) (6) (7) (8) (9) (10))

范例3：

> (permutations 2 3 4)
'((1 1 1)
  (1 1 2)
  (1 2 1)
  (1 2 2)
  (1 3 1)
  (1 3 2)
  (2 1 1)
  (2 1 2)
  (2 2 1)
  (2 2 2)
  (2 3 1)
  (2 3 2)
  (3 1 1)
  (3 1 2)
  (3 2 1)
  (3 2 2)
  (3 3 1)
  (3 3 2)
  (4 1 1)
  (4 1 2)
  (4 2 1)
  (4 2 2)
  (4 3 1)
  (4 3 2))