Создание 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

(определить (сборка строки 2d столбец) (строка списка сборки (лямбда (x) (столбец списка сборки (лямбда (y) (список (+ x 1) (+ y 1))))))

Answer 3

Я не могу ответить на ваш вопрос как есть, потому что я не понимаю, как вложенные списки должны работать для> 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))

Answer 4

Код:

(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)))