Question

// L is a list and n is its length //

// we assume that n= 4**k , for k≥1//

Alg1(L,n)
  remove the smallest and largest element from L 
  if n-2 > (4**k)/2
  call Alg1(L, n-2)

不是它的功能，但它打算做什么？我不明白这个问题意味着“预期”，但我认为算法只是递归地删除列表中最大和最小的元素，直到4或3元素保留。

Answer 1

给定一个大小为4 ^ k的起始列表，这似乎是为n给出的定义所暗示的，alg1将提供的列表的大小减小为（（4 ^ k）/ 2 ）+ 2 for k＆gt; = 1.我同意@ Ctznkane525该算法未完全指定，因为它没有告诉我们返回值应该是什么。但是如果我们做出简单的假设，即每次n递减2时应从列表的末尾删除两个元素，我们就可以继续。因此，请考虑Clojure中的以下实现：

(defn exp [x n]
  (reduce * (repeat n x)))

(def k 1)

(defn alg1[l n]
  (println "k=" k "  n=" n "  l=" l)
  (if (> (- n 2) (/ (exp 4 k) 2))
    (recur (take (- n 2) l) (- n 2))
    l))

我在这里添加了代码来打印k，n和l的值，这样我们就可以看到每一步都会发生什么。

鉴于上述情况，我们将开始一些测试。我们将alg1作为(alg1 (take (exp 4 k) (iterate #(+ 1 %) 1)) (exp 4 k))调用，它只创建一个包含4 ^ k个元素的列表，并将其作为第一个参数传递给alg1，并传递4 ^ k作为第二个参数论点。所以这里：

user=> (def k 1)
#'user/k
user=> (alg1 (take (exp 4 k) (iterate #(+ 1 %) 1)) (exp 4 k))
k= 1   n= 4   l= (1 2 3 4)
(1 2 3 4)

因此，当k = 1并且列表定义为(1 2 3 4)时，函数立即返回，因为n-2 = 2，并且小于或等于（4 ^ k）/ 2，其中也是2。

让我们试试k = 2：

user=> (def k 2)
#'user/k
user=> (alg1 (take (exp 4 k) (iterate #(+ 1 %) 1)) (exp 4 k))
k= 2   n= 16   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
k= 2   n= 14   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14)
k= 2   n= 12   l= (1 2 3 4 5 6 7 8 9 10 11 12)
k= 2   n= 10   l= (1 2 3 4 5 6 7 8 9 10)
(1 2 3 4 5 6 7 8 9 10)

啊，这有点儿了。我们从n = 16开始，当然是4 ^ k = 4 ^ 2 = 16，并且开始列表是（1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16）。当alg1考虑这些值时，它发现n-2（14）大于（4 ^ 2）/ 2（8），因此它从列表末尾修剪两个元素并递归调用自身。在第二次迭代中，它发现n-2（12）大于8，因此它修剪另外两个元素并递归调用自身。这一直持续到n = 10，当alg1发现n-2（8）不再大于（4 ^ 2）/ 2（8）时，它返回列表(1 2 3 4 5 6 7 8 9 10)。

k = 3会发生什么？

user=> (def k 3)
#'user/k
user=> (alg1 (take (exp 4 k) (iterate #(+ 1 %) 1)) (exp 4 k))
k= 3   n= 64   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64)
k= 3   n= 62   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62)
k= 3   n= 60   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60)
k= 3   n= 58   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58)
k= 3   n= 56   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56)
k= 3   n= 54   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54)
k= 3   n= 52   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52)
k= 3   n= 50   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50)
k= 3   n= 48   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48)
k= 3   n= 46   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46)
k= 3   n= 44   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44)
k= 3   n= 42   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42)
k= 3   n= 40   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40)
k= 3   n= 38   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38)
k= 3   n= 36   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36)
k= 3   n= 34   l= (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34)
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34)

与上述类似的结果。在每次迭代中，从列表中修剪两个元素，直到达到算法中指定的条件，此时算法退出。

你可以继续提高k的值，构建参数，观察算法是否有效，但最后结果总是相似的：列表的大小减小到（（4 ^ k）/ 2）+ 2。

祝你好运。

这个伪代码打算做什么？

1 个答案: