読者です 読者をやめる 読者になる 読者になる

anarchy golf - numof 1 bits in 0 to 255

Golf

id:yshl さんにならって鑑賞会。関数型の esolang ばっかりです。

Lazy K

http://golf.shinh.org/reveal.rb?numof+1+bits+in+0+to+255/irori/1240716651&lazy
"8" から始めて、文字列を倍々にしつつ前半部分から1を引いていきます。 
church数から1を引く関数がちょっとサイズ大きめ。

(lazy-def '(1- n)
  '(lambda (f z)
     (((n (lambda (g h) (h (g f)))) (lambda (x) z)) I)))

(lazy-def '(dbl lst)
  '(((lambda (x) (x x))
     (lambda (rec l)
       (if<= 256 (car l)
	     lst
	     (cons (1- (car l)) (rec rec (cdr l))))))
    lst))

(lazy-def '(main input) '(8 dbl (cons 56 input)))

(print-as-golf (laze 'main))
51b さん

http://golf.shinh.org/reveal.rb?numof+1+bits+in+0+to+255/51b/1240743932&lazy
http://d.hatena.ne.jp/yshl/20090429#1240985772
なるほどー。ビットを数える方法で私のより短くなるんだなあ。

Universal Lambda

http://golf.shinh.org/reveal.rb?numof+1+bits+in+0+to+255/irori/1240720054&lamb
処理系付属のアセンブラじゃなくて Lazy K のコンパイラを改造したものを使ってます。
アルゴリズムは Lazy K 版と同じ。

(lazy-def '(1- n)
  '(lambda (f z)
     (((n (lambda (g h) (h (g f)))) (lambda (x) z)) (lambda (x) x))))

(lazy-def '(dbl lst)
  '(((lambda (x) (x x))
     (lambda (rec l)
       (l (lambda (hd tl _)
	    (cons (1- hd) (rec rec tl)))
	  lst)))
    lst))

(lazy-def '(main input)
  '(input (lambda (hd) (hd dbl))))

(print-as-binary (shrink (laze 'main)))
(display "\x088")
hinoe さん

http://golf.shinh.org/reveal.rb?numof+1+bits+in+0+to+255/hinoe/1240735277&lamb
Universal Lambda の処理系についてきた逆アセンブラを使ってみると、

$lamd hinoe.lamb
(\a.a (\b c.c (b (\d e f.d e (d (\g h.g (e g h)) f)) (\d e f.f d e))))
"\b0

(゜Д゜)ナニコレ
整理してみるとこんな感じのようでした。うーんかっこいい。

# input = cons 8 (cons 48 nil)
succ n s z = s (n s z)
main input = input (\n s. s (n (\f hd tl. f hd (f (succ hd) tl))
                               cons))

これを Lazy K 用に書き換えてみたら、私や 51b さんの半分以下の長さになってしまったのでした。
http://golf.shinh.org/reveal.rb?numof+1+bits+in+0+to+255/irori%28translation+of+hinoe%27s+Universal+Lambda%29/1241191578&lazy

Grass

http://golf.shinh.org/reveal.rb?numof+1+bits+in+0+to+255/irori/1240736568&grass
例によって必要な文字を作るのが一番大変です。
Glidで書いています。

let 2 f x = f (f x)
let 4 = 2 2
let s4 = 4 Succ
let s16 = 4 s4
let f2 x = Succ (s4 (s16 (x ((4 x) W))))
let c181 = f2 (2 s16)
let c185 = s4 c181		(* '0' *)

let append_rec rec xs ys f = (rec rec) (xs f) (ys f)
let dbl fs = (append_rec append_rec) fs (fs Succ)

let 3 f x = f (f (f x))
let 8dbl = 3 2 dbl

let mapper_rec rec x f = (rec rec) (f x)
let mapper = mapper_rec mapper_rec

let seed = mapper c185

let flst = 8dbl seed

let _ = flst Out

Unlambda

http://golf.shinh.org/reveal.rb?numof+1+bits+in+0+to+255/irori/1240725910&unl
秘密の俺コンパイラを使用。アルゴリズムは Grass と似ています。
ASCII コードの演算ができないのでコードの半分以上を数字のテーブルが占めているのが悲しい…

(lazy-def '(mapper x)
  '(lambda (f) (mapper (x f))))

(lazy-def '(append fs1 fs2)
  '(lambda (f) (append (fs1 f) (fs2 f))))

(lazy-def '(dbl fs) '(append fs (cdr fs))

(lazy-def 'digits '(cons* #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 (lambda (f) #\8)))

(lazy-def 'flst '(c8 dbl (mapper digits)))

(lazy-def '(putc f) '(car f f))

(lazy-def 'main '(flst putc))