如何改进此列表算法？

Question

如果列表中有两个相邻的值与最后一个相同（三个值相同），则给出一个数字列表（字符或其他任何字符）和另一个随机数（字符或与列表相同的种类） ），则将其消除，然后递归执行。
例如
（1 5 3 3 2 2 4 3）+ 2 =>（1 5 3 3 2 2 4 3 2 ）=>（1 5 3 3 4 3 ）=>（1 5 4）

（1 3 3 2）+ 2 =>（1 3 3 2 2）

我的解决方案是这样的：

一种。 扫描列表，并获取两个相同值的第一个匹配项的位置，该值与列表的最后一个相同，如果未找到，则返回#f。

湾 删除这三个值

C。 递归调用

(define scan ;; list->list (get the position)
  (lambda (lst)
    (let scan-loop ((lst lst) (n 0))
      (cond
       [(<= (length  lst) 2) #f]
       [(and (equal? (car lst) (cadr lst))
     (equal? (car lst) (last lst))) n]
       [else
     (scan-loop (cdr lst) (+ n 1))]))))

(define (Arrange lst k) ; list,k -> list (remove the value) 
   (remove-k (remove-k (remove-k lst k) k) (- (length lst) 3)))

(define (remove-k lst k)
 (let remove-loop ((init lst) (n k) (new '()))
  (cond
   [(null? init) (error "K is too big for list")]
   [(= n 0) (append new (cdr init))]
   [else
    (remove-loop (cdr init) (- n 1) (append new (list (car init)) ))])))

(define (eliminate lst) ; list ,num -> lst (the main function)
  (let ([flag (scan lst)])
     (if flag
         (eliminate (Arrange lst flag))
         lst)))

这可以工作。 但是，如果列表很长，它将变得非常缓慢。
我有一个测试：

(define lst (build-list 10000 (lambda (x) (random 10))))
(eliminate lst)

在Dracket（6 GB内存，2.3G hz cpu * 4）中，根据性能分析，主要的时间成本是：
调用remove-loop ， 11517101次，花费49283毫秒
呼叫scan-loop ， 2450002次，花费121294毫秒
通话Arrange 747次，花费713182毫秒
通话eliminate 748次，耗费130611毫秒

在跑步过程中，我发现只有一个CPU几乎100％被使用（轮流使用）。
可以通过多线程运行吗？

我认为主要问题是我使用的算法效率低下。 我认为它可以真正优化。 也许使用动态算法，使用表来存储事件并每次更新。
怎么做？

非常感谢。

Answer 1

不要在Racket Dr中测量结果，因为IDE的开销非常高。 始终从外壳执行耗时的计算。

这是我的算法，对于10,000个元素的列表，执行时间不到半秒（相比之下，您的算法为9.5分钟）：

(define (remn lst)
  (if (null? lst)
      lst
      (let* ((rlst (reverse lst)) (last (car rlst)))
        (let loop ((left null) (curn 0) (rght (reverse (cdr rlst))))
          (if (null? rght)
              (append (reverse left) (list last))
              (let ((e (car rght)))
                (if (equal? e last)
                    (if (= curn 1)
                        (remn (append (reverse (cdr left)) (cdr rght)))
                        (loop (cons e left) (add1 curn) (cdr rght)))
                    (loop (cons e left) 0 (cdr rght)))))))))

例子：

> (remn '(1 5 3 3 2 2 4 3 2))
'(1 5 4)
> (remn '(1 3 3 2 2))
'(1 3 3 2 2)
> (remn '(1 1 3 3 3 3 3 1))
'(3 3)