Sorting 按模式在方案中排序
帮点忙，伙计们。 如何根据特定的模式对列表进行排序 例如，对R、W、B的列表进行排序，其中R首先出现，然后是W，然后是B。 类似于Sorting 按模式在方案中排序,sorting,scheme,dutch-national-flag-problem,Sorting,Scheme,Dutch National Flag Problem,帮点忙，伙计们。 如何根据特定的模式对列表进行排序 例如，对R、W、B的列表进行排序，其中R首先出现，然后是W，然后是B。 类似于（sortf'（W R W B R W B B））到（R R W B B B） 非常感谢您的回答。查阅一下 (define sort-lookup '((R . 1)(W . 2)(B . 3))) (define (sort-proc a b) (< (cdr (assq a sort-lookup)) (cdr (assq b sort-lo
（sortf'（W R W B R W B B））（R R W B B B）(define sort-lookup '((R . 1)(W . 2)(B . 3)))
(define (sort-proc a b)
(< (cdr (assq a sort-lookup))
(cdr (assq b sort-lookup))))
(list-sort sort-proc '(W R W B R W B B))
（定义排序查找’（（R.1）（W.2）（B.3）））
（定义（排序过程a和b）
（<（cdr（关联排序查找））
（cdr（assq b排序查找）））
（列表排序过程’（W R W B R W B））
(define sort-lookup '((R . 1)(W . 2)(B . 3)))
(define (sort-proc a b)
(< (cdr (assq a sort-lookup))
(cdr (assq b sort-lookup))))
(list-sort sort-proc '(W R W B R W B B))
（定义排序查找’（（R.1）（W.2）（B.3）））
（定义（排序过程a和b）
（<（cdr（关联排序查找））
（cdr（assq b排序查找）））
（列表排序过程’（W R W B R W B））
Runnable R6RS（IronScheme）解决方案：您只需使用内置排序或现有排序，并使用自定义谓词
(define (follow-order lst)
(lambda (x y)
(let loop ((inner lst))
(cond ((null? inner) #f)
((equal? x (car inner)) #t)
((equal? y (car inner)) #f)
(else (loop (cdr inner)))))))
)；值50：（r w b）您只需使用内置排序或现有排序，然后使用自定义谓词
(define (follow-order lst)
(lambda (x y)
(let loop ((inner lst))
(cond ((null? inner) #f)
((equal? x (car inner)) #t)
((equal? y (car inner)) #f)
(else (loop (cdr inner)))))))
)；值50：（r w b）这是的功能版本。这是我的两分钱-使用
sortO（n log n）(define sortf
(let ((map '#hash((R . 0) (W . 1) (B . 2))))
(lambda (lst)
(sort lst
(lambda (x y) (<= (hash-ref map x) (hash-ref map y)))))))
(define (sortf lst)
(append (filter (lambda (x) (eq? x 'R)) lst)
(filter (lambda (x) (eq? x 'W)) lst)
(filter (lambda (x) (eq? x 'B)) lst)))
分区和O（3n）
复杂性：
(define (sortf lst)
(let-values (((reds others)
(partition (lambda (x) (eq? x 'R)) lst)))
(let-values (((whites blues)
(partition (lambda (x) (eq? x 'W)) others)))
(append reds whites blues))))
上述解决方案以函数式编程风格编写，创建了一个包含答案的新列表。如果我们将输入表示为一个向量，它允许通过索引引用元素，那么就可以构造一个最优的O（n）
，单程命令式解决方案。事实上，这就是问题最初的表述想要解决的方式：
(define (swap! vec i j)
(let ((tmp (vector-ref vec i)))
(vector-set! vec i (vector-ref vec j))
(vector-set! vec j tmp)))
(define (sortf vec)
(let loop ([i 0]
[p 0]
[k (sub1 (vector-length vec))])
(cond [(> i k) vec]
[(eq? (vector-ref vec i) 'R)
(swap! vec i p)
(loop (add1 i) (add1 p) k)]
[(eq? (vector-ref vec i) 'B)
(swap! vec i k)
(loop i p (sub1 k))]
[else (loop (add1 i) p k)])))
请注意，前面的解决方案会在适当的位置改变输入向量。它相当优雅，工作正常：
(sortf (vector 'W 'R 'W 'B 'R 'W 'B 'B 'R))
=> '#(R R R W W W B B B)
这是的功能版本。这是我的两分钱-使用sort
过程和O（n log n）
复杂性：
(define sortf
(let ((map '#hash((R . 0) (W . 1) (B . 2))))
(lambda (lst)
(sort lst
(lambda (x y) (<= (hash-ref map x) (hash-ref map y)))))))
(define (sortf lst)
(append (filter (lambda (x) (eq? x 'R)) lst)
(filter (lambda (x) (eq? x 'W)) lst)
(filter (lambda (x) (eq? x 'B)) lst)))
使用分区和O（3n）
复杂性：
(define (sortf lst)
(let-values (((reds others)
(partition (lambda (x) (eq? x 'R)) lst)))
(let-values (((whites blues)
(partition (lambda (x) (eq? x 'W)) others)))
(append reds whites blues))))
上述解决方案以函数式编程风格编写，创建了一个包含答案的新列表。如果我们将输入表示为一个向量，它允许通过索引引用元素，那么就可以构造一个最优的O（n）
，单程命令式解决方案。事实上，这就是问题最初的表述想要解决的方式：
(define (swap! vec i j)
(let ((tmp (vector-ref vec i)))
(vector-set! vec i (vector-ref vec j))
(vector-set! vec j tmp)))
(define (sortf vec)
(let loop ([i 0]
[p 0]
[k (sub1 (vector-length vec))])
(cond [(> i k) vec]
[(eq? (vector-ref vec i) 'R)
(swap! vec i p)
(loop (add1 i) (add1 p) k)]
[(eq? (vector-ref vec i) 'B)
(swap! vec i k)
(loop i p (sub1 k))]
[else (loop (add1 i) p k)])))
请注意，前面的解决方案会在适当的位置改变输入向量。它相当优雅，工作正常：
(sortf (vector 'W 'R 'W 'B 'R 'W 'B 'B 'R))
=> '#(R R R W W W B B B)
这是一种不使用排序
或更高阶函数的解决方案。（即完全没有乐趣）
这并不是真正的排序，但它解决了您的问题，而不使用排序命名let
和case
是此解决方案中最奇特的形式
除非不需要使用sort，否则我不会这样做。我认为它既优雅又容易理解
此解决方案是O（n）
，因此它可能比其他具有大量球的解决方案更快
#!r6rs
(import (rnrs base))
(define (sort-flag lst)
;; count iterates over lst and counts Rs, Ws, and Bs
(let count ((lst lst) (rs 0) (ws 0) (bs 0))
(if (null? lst)
;; When counting is done build makes a list of
;; Rs, Ws, and Bs using the frequency of the elements
;; The building is done in reverse making the loop a tail call
(let build ((symbols '(B W R))
(cnts (list bs ws rs))
(tail '()))
(if (null? symbols)
tail ;; result is done
(let ((element (car symbols)))
(let build-element ((cnt (car cnts))
(tail tail))
(if (= cnt 0)
(build (cdr symbols)
(cdr cnts)
tail)
(build-element (- cnt 1)
(cons element tail)))))))
(case (car lst)
((R) (count (cdr lst) (+ 1 rs) ws bs))
((W) (count (cdr lst) rs (+ 1 ws) bs))
((B) (count (cdr lst) rs ws (+ 1 bs)))))))
这是一种不使用排序
或更高阶函数的解决方案。（即完全没有乐趣）
这并不是真正的排序，但它解决了您的问题，而不使用排序命名let
和case
是此解决方案中最奇特的形式
除非不需要使用sort，否则我不会这样做。我认为它既优雅又容易理解
此解决方案是O（n）
，因此它可能比其他具有大量球的解决方案更快
#!r6rs
(import (rnrs base))
(define (sort-flag lst)
;; count iterates over lst and counts Rs, Ws, and Bs
(let count ((lst lst) (rs 0) (ws 0) (bs 0))
(if (null? lst)
;; When counting is done build makes a list of
;; Rs, Ws, and Bs using the frequency of the elements
;; The building is done in reverse making the loop a tail call
(let build ((symbols '(B W R))
(cnts (list bs ws rs))
(tail '()))
(if (null? symbols)
tail ;; result is done
(let ((element (car symbols)))
(let build-element ((cnt (car cnts))
(tail tail))
(if (= cnt 0)
(build (cdr symbols)
(cdr cnts)
tail)
(build-element (- cnt 1)
(cons element tail)))))))
(case (car lst)
((R) (count (cdr lst) (+ 1 rs) ws bs))
((W) (count (cdr lst) rs (+ 1 ws) bs))
((B) (count (cdr lst) rs ws (+ 1 bs)))))))
我看到你的分类了。但是你能给我一个使用car、cdr和一系列条件的实现，并把它放在一个定义中吗。我似乎不完全理解。大多数方案实现都有某种内置排序。它们有两个参数，要排序的数据结构和要排序的谓词。但是你能给我一个使用car、cdr和一系列条件的实现，并把它放在一个定义中吗。我似乎不完全理解。大多数方案实现都有某种内置排序。它们有两个参数，要排序的数据结构和要排序的谓词。非常感谢。但这会更简单吗？我的意思是只使用函数名（follow order lst）来执行函数，将排序与顺序相结合？比如：（follow’（wrwb R wb））当然，但对我来说，这似乎太具体了。（定义（跟随lst）（排序lst（跟随顺序）（RWB）））啊。还是谢谢，我真的理解你的实施。非常感谢。但这会更简单吗？我的意思是只使用函数名（follow order lst）来执行函数，将排序与顺序相结合？比如：（follow’（wrwb R wb））当然，但对我来说，这似乎太具体了。（定义（跟随lst）（排序lst（跟随顺序）（RWB）））啊。还是谢谢，我真的理解你的实现。你是在寻找一个只对R、W和B列表进行排序的特殊程序吗？OP正在尝试实现荷兰国旗问题的功能版本。这有点毫无意义，真正有趣的解决方案是在数组（或向量）上工作的，链表实现不会那么有效。。。或者，你是在寻找一种只对R、W和B的列表进行排序的特殊程序吗？OP正试图实现荷兰国旗问题的功能版本。这有点毫无意义，真正有趣的解决方案是在数组（或向量）上工作的，链表实现不会那么有效。。。或者雅致感兴趣的矢量版本在哪里？：）谢谢很高兴学习了几种实现方法。lol不知道这叫做荷兰国旗问题。@leppie，你看，矢量版本：）有趣的矢量版本在哪里？：）谢谢很高兴学习了几种实现方法。lol不知道这叫做d