Sắp xếp danh sách các số trên tính toán

Viết một thuật ngữ trên phép tính lambda thuần túy mà khi áp dụng vào danh sách các số được mã hóa của nhà thờ , trả về nó với các số được sắp xếp theo thứ tự tăng dần hoặc giảm dần. Danh sách và số của nhà thờ phải được mã hóa thành các nếp gấp cho các ADT thông thường của họ:

-- Usual ADTs for Lists and Nats (in Haskell, for example)
data List a = Cons a (List a) | Nil
data Nat a  = Succ (Nat a) | Zero

-- Their respective folds are the λ-calculus representation used on this challenge
church_list = (λ c n . (c ... (c ... (c ... n))))
church_num  = (λ succ zero . (succ (succ (succ ... zero))))

Ví dụ đầu vào:

(λ cons nil .
    (cons (λ f x . (f x))                         -- 1
    (cons (λ f x . (f (f (f (f (f (f (f x)))))))) -- 7
    (cons (λ f x . (f (f x)))                     -- 2
    (cons (λ f x . (f (f (f x))))                 -- 3
    nil)))))

Ví dụ đầu ra:

(λ cons nil . 
    (cons (λ f x . (f x))                         -- 1
    (cons (λ f x . (f (f x)))                     -- 2
    (cons (λ f x . (f (f (f x))))                 -- 3
    (cons (λ f x . (f (f (f (f (f (f (f x)))))))) -- 7
    nil)))))

Điểm của bài nộp sẽ được tính như sau:

score(x)    = 1
score(λx.t) = score(t) + 1
score(t s)  = score(t) + score(s) + 1

Điểm số thấp nhất chiến thắng.

Tôi đã xoay sở để đánh bại dấu ấn của riêng mình:

sort = λabcd.a(λef.f(λghi.g(λj.h(λkl.kj(ikl)))(hi))e(λgh.h))
       (λe.d)(λe.b(λf.e(f(λghi.hg)(λgh.cfh))))

Tuy nhiên, có một cảnh báo - thuật ngữ này phải nhận được một đối số bổ sung với kích thước tối đa của các tự nhiên được xem xét. Ví dụ: sort 4 [1,7,3,6,5]sẽ trả về [1,3], bỏ qua mọi thứ ở trên hoặc bằng 4. Tất nhiên, bạn chỉ có thể cung cấp vô hạn (nghĩa là, tổ hợp Y):

sort = λbcd.(λfx.f(x x))(λfx.f(x x))(λef.f(λghi.g(λj.h(λkl.kj(ikl)))
       (hi))e(λgh.h))(λe.d)(λe.b(λf.e(f(λghi.hg)(λgh.cfh))))

Và nó sẽ sắp xếp bất kỳ danh sách các số tự nhiên, nhưng thuật ngữ này rõ ràng không còn có dạng bình thường nữa.

121 ký tự / điểm 91

sort = λabc.a(λdefg.f(d(λhij.j(λkl.k(λmn.mhi)l)(h(λkl.l)i))
       (λhi.i(λjk.bd(jhk))(bd(h(λjk.j(λlm.m)k)c))))e)(λde.e)
       (λde.d(λfg.g)e)c

Nó ở dạng bình thường và có thể được thực hiện ngắn hơn bằng cách nâng các biểu hiện phụ thông thường.

Đây là một triển khai của một loại chèn:

let nil =       \f x.x in
let cons = \h t.\f x.f h (t f x) in
let 0 =       \f x.x in
let succ = \n.\f x.f (n f x) in
let None =    \a b.b in
let Some = \x.\a b.a x in
let pred = \n.n (\opt.opt (\m.Some(succ m)) (Some 0)) None in
let optpred = \opt.opt pred None in
let - = \m n.n optpred (Some m) in
let < = \m n.\trueval falseval.- m n (\diff.falseval) trueval in
let pair = \x y.\f.f x y in
let snd = \p.p (\x y.y) in
let insert = \n l.snd (l (\h recpair.recpair (\rawtail insertedtail.
  let rawlist = cons h rawtail in
    pair rawlist (< h n (cons h insertedtail) (cons n rawlist))))
  (pair nil (cons n nil))) in
\l.l insert nil

Ở đây, pred ntrả về một phần tử của option nat: pred 0is Nonewhile pred (n+1)is Some n. Sau đó, - m ntrả về một phần tử option natlà Some (m-n)if m>=nhoặc Noneif m<n; và < m ntrả về một boolean. Cuối cùng, insertsử dụng một hàm nội bộ trả về một cặp trong đó f l = (l, insert n l)(một phương thức khá điển hình để lấy phần đuôi của danh sách được chuyển đến đệ quy cùng với giá trị đệ quy).

Bây giờ, một số ghi chú cho công việc chơi golf trong tương lai: thực sự nil, 0, Nonetình cờ lại là cùng một chức năng chính thức (và nó cũng xuất hiện trong snd). Sau đó, tôi chắc chắn sẽ xem xét thực hiện giảm beta trên các letbáo cáo (tất nhiên đó là đường cú pháp thông thường let a = x in ycó nghĩa là (\a.y)xvà do đó có điểmscore(x) + score(y) + 2 ) để xem trường hợp nào làm như vậy sẽ làm giảm điểm - điều chắc chắn nhất đối với các ràng buộc đó là chỉ sử dụng một lần.

Sau đó sẽ đến những thứ phức tạp hơn: ví dụ, tôi chỉ nhận thấy rằng chính thức pred = pair (pair (\m.Some(succ m)) (Some 0)) None, optpred = pair pred None, - = \m.pair optpred (Some m), định nghĩa chức năng sắp xếp số tiền pair insert nil, vv mà có thể rút ngắn tỉ số nhẹ.