Hatena::Groupcadr

わだばLisperになる このページをアンテナに追加 RSSフィード

2004 | 12 |
2005 | 01 | 02 | 07 | 10 | 11 |
2006 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2007 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2008 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2009 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2010 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2011 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 11 |

2008-04-11

QiでL-99 (P26 指定した個数を抜き出す組み合わせ)

| 08:14 | QiでL-99 (P26 指定した個数を抜き出す組み合わせ) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P26 指定した個数を抜き出す組み合わせ) - わだばLisperになる

Qiでは今迄あまり無名関数を使ってませんでしたが、(lambda (x) x)は、Qiでは、(/. X X)と書きます。/.をλと見立てているようなんですが…。

(combination 3 [a b c d e f])
\=> [[a b c] [a b d] [a b e] ... ]
\

(length (combination 3 (range 1 12)))
\=> 220
\

(define combination 
  0 Lst -> [ ] 
  1 Lst -> (map (/. X [X]) Lst)
  N Lst -> [ ] where (> N (length Lst))
  N [H | T] -> (append (map (/. X [H | X]) (combination (- N 1) T))
                       (combination N T)))

2008-04-10

QiでL-99 (P25 ランダムに並び換え)

| 02:36 | QiでL-99 (P25 ランダムに並び換え) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P25 ランダムに並び換え) - わだばLisperになる

(rnd-permu [a b c d e f])
\=> [e a d f c b]
\

(define rnd-permu
  U -> (rnd-select U (length U)))

2008-04-09

QiでL-99 (P24 ロトくじ)

| 00:35 | QiでL-99 (P24 ロトくじ) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P24 ロトくじ) - わだばLisperになる

Qiでも、もう少しでリスト篇が終わり!

(lotto-select 6 49)
\=> [29 5 24 18 23 2]
\

(define lotto-select
  N M -> (rnd-select (range 1 M) N))

2008-04-08

QiでL-99 (P23 ランダムに指定した個数の要素を選択)

| 05:07 | QiでL-99 (P23 ランダムに指定した個数の要素を選択) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P23 ランダムに指定した個数の要素を選択) - わだばLisperになる

今迄なんとなくQiっぽくなくなるかなと思ってあまりifを使ってきませんでしたが、Qiにもifはあります。

今回は、whereだけでは、lengthを2回呼ぶことになるのでifを使ってみました。

(rnd-select [a b c d e f g h] 3)  
\=> [g c e]
\

(define rnd-select
  [ ] _ -> [ ]
  Lst N -> (let Len (length Lst)
             (if (> N Len)
                 [ ]
                 (rnd-select* Lst N [ ] Len))))

(define rnd-select* 
  [ ] _ Acc _ -> Acc
  Lst N Acc Len -> Acc where (>= 0 N)
  Lst N Acc Len -> (let Pos (+ 1 (random Len))
                     (rnd-select* (remove-at Lst Pos)
                                  (- N 1)
                                  [(nth Pos Lst) | Acc]
                                  (- Len 1))))

2008-04-06

QiでL-99 (P22 指定した範囲の数列のリスト)

| 18:18 | QiでL-99 (P22 指定した範囲の数列のリスト) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P22 指定した範囲の数列のリスト) - わだばLisperになる

(range 0.5 10)
\=> [0.5 1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5]
\

(define range 
  Start End -> [ ] where (> Start End)
  Start End -> [Start | (range (+ 1 Start) End)])

2008-04-05

QiでL-99 (P21 指定した位置に要素を挿入する)

| 21:57 | QiでL-99 (P21 指定した位置に要素を挿入する) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P21 指定した位置に要素を挿入する) - わだばLisperになる

Qiにはバックトラックの構文もあって非決定性プログラミングの解説もチュートリアルにあります。

しかし説明が難しくて全然分からない(笑)

(insert-at alfa [a b c d] 2)
\=> [a alfa b c d]
\

(define insert-at
  Item [ ] _ -> [Item]
  Item Lst Pos -> [Item | Lst] where (>= 1 Pos)
  Item [H | T] Pos -> [H | (insert-at Item T (- Pos 1))])

2008-04-04

QiでL-99 (P20 指定した要素を削除)

| 00:42 | QiでL-99 (P20 指定した要素を削除) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P20 指定した要素を削除) - わだばLisperになる

若干ダレて来たような(;´Д`)…。

(remove-at [a b c d] 2)
\=> [a c d]
\

(define remove-at 
  [ ] _ -> [ ]
  X K -> X where (>= 0 K)
  [H | T] 1 -> T
  [H | T] K -> [H | (remove-at T (- K 1))])

2008-04-01

QiでL-99 (P19 指定した位置でローテーションさせる)

| 18:06 | QiでL-99  (P19 指定した位置でローテーションさせる) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99  (P19 指定した位置でローテーションさせる) - わだばLisperになる

今迄、Qiに1+とか、1-が備え付けで存在すると思っていましたが、なんとQiでは関数名を全部大文字で書くと、下層のCLの関数が直接呼べるんだそうで、1+はCLから呼んでいたのでした。また、DEFUNや、DEFMACROで下層のCLの関数も定義可能とのこと。

(my-rotate [a b c d e f g h] 3)
\=>  [d e f g h a b c]
\

(my-rotate [a b c d e f g h] -2)
\=> [g h a b c d e f]
\

(define my-rotate
  [ ] _ -> [ ]
  Lst N -> (xappend (split Lst (+ N (length Lst)))) where (> 0 N)
  Lst N -> (xappend (split Lst N)))

(define xappend
  [H T] -> (append T  H))

2008-03-28

QiでL-99 (P18 リストの範囲切り出し)

| 12:02 | QiでL-99 (P18 リストの範囲切り出し) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P18 リストの範囲切り出し) - わだばLisperになる

なんだか、ごちゃごちゃしてしまった…。

(slice [a b c d e f g h i j k] 3 7)
\=>[c d e f g]
\

(define slice 
  List Start End -> [ ] where (> Start End)
  List Start End -> (slice* List [ ] 1 Start End))

(define slice* 
  [ ] Acc _ _ _ -> (reverse Acc)
  [H | T] Acc End Start End -> (slice* [ ] [H | Acc] End Start End)
  [H | T] Acc Pos Start End 
   -> (slice* T [H | Acc] (1+ Pos) Start End) where (<= Start Pos)
  [_ | T] Acc Pos Start End 
   -> (slice* T Acc (1+ Pos) Start End))

\ 前回定義したsplitを使用したもの \
(define slice 
  List Start End -> [ ] where (> Start End)
  List Start End -> (let S (1- Start)
		      (head (split (head (tail (split List S))) 
				   (- End S)))))

2008-03-27

QiでL-99 (P17 指定した位置でリストを分割)

| 14:58 | QiでL-99 (P17 指定した位置でリストを分割) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P17 指定した位置でリストを分割) - わだばLisperになる

もっと綺麗に書けそうなんだけれども…。

(split [a b c d e f g h i k] 3)
\=> [[a b c] [d e f g h i k]]
\

(define split 
  Lst N -> (split* Lst [ ] N))

(define split* 
  Lst Acc Cnt -> [(reverse Acc) | [Lst]] where (or (empty? Lst) (> 1 Cnt))
  [H | T] Acc Cnt -> (split* T [H | Acc] (1- Cnt)))

2008-03-25

QiでL-99 (P16 周期Nで要素を間引く)

| 19:16 | QiでL-99 (P16 周期Nで要素を間引く) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P16 周期Nで要素を間引く) - わだばLisperになる

いくらなんでも、L-99ばっかりやり過ぎな気がしてきた(笑)

\(drop [a b c d e f g h i k] 3)
\=> [a b d e g h k]

(define drop
  X N -> (drop* X N 1))

(define drop* 
  [ ] _ _ -> [ ]
  [H | T] N Cnt -> (drop* T N 1) where (= N Cnt)
  [H | T] N Cnt -> [H | (drop* T N (1+ Cnt))])

2008-03-24

QiでL-99 (P15 各要素を任意の回数複製する)

| 12:02 | QiでL-99 (P15 各要素を任意の回数複製する) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P15 各要素を任意の回数複製する) - わだばLisperになる

carとcdrとifの条件分岐で書くより、Qiみたいな書法の方がすっきりして良いと思い始めました。CLでQi風に書けるマクロとか書いてみようかな。

(repli [a b c] 3)
\=> [a a a b b b c c c]
\

(define repli 
  [ ] _ -> [ ]
  [H | T] N -> (append (n-of N H) (repli T N)))

(define n-of 
  N Item -> [ ] where (>= 0 N)
  N Item -> [Item | (n-of (1- N) Item)])

2008-03-23

QiでL-99 (P14 各要素を2倍する)

| 10:54 | QiでL-99 (P14 各要素を2倍する) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P14 各要素を2倍する) - わだばLisperになる

割とQiは良いかもしれない…、と思いつつ、未だチュートリアルを開いて見ることさえしていない…。

(dupli [a b c d e])
\=> [a a b b c c d d e e]
\

(define dupli 
  [ ] -> [ ]
  [H | T] -> [H H | (dupli T)])

2008-03-21

QiでL-99 (P13 ランレングス圧縮 その3)

| 02:52 | QiでL-99 (P13 ランレングス圧縮 その3) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P13 ランレングス圧縮 その3) - わだばLisperになる

P10、P11、P13は続きものになっていて、P11はP10の結果を加工して解答するというもので、P13はP10を加工するのではなく直接リストを生成するという内容になっていますが、P11で直接リストを生成する方法で答えてしまいました(^^;

ということで、P11の名前を変更してP13として再掲載し、P11は新たに作り直してみました。

(encode-direct [a a a a b c c a a d e e e e])
\=>[[4 a] b [2 c] [2 a] d [4 e]]
\

(define encode-direct
    X -> (encode-direct* (pack X)))

(define encode-direct*
    [ ] -> [ ]
    [H | T] -> [(head H) | (encode-direct* T)] where (= 1 (length H))
    [H | T] -> [[(length H) (head H)] | (encode-direct* T)])


(encode-modified [a a a a b c c a a d e e e e])
\=>[[4 a] b [2 c] [2 a] d [4 e]]
\

(define encode-modified 
    X -> (encode-modified* (encode X)))

(define encode-modified*
    [ ] -> [ ]
    [[1 X] | T] -> [X | (encode-modified* T)]
    [H | T] -> [H | (encode-modified* T)])

2008-03-16

QiでL-99 (P12 ランレングス圧縮の伸長)

| 00:55 | QiでL-99 (P12 ランレングス圧縮の伸長) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P12 ランレングス圧縮の伸長) - わだばLisperになる

Qiでは、nthが0オリジンではなく、1オリジンというところにはまってしまいました。

(nth 0 ~)とかすると、処理系から返事がなくなってしまったりします。

(decode [[4 a] b [2 c] [2 a] d [4 e]])
\=> [[a a a a] [b] [c c] [a a] [d] [e e e e]]
\

(define decode
    [ ] -> [ ]
    [H | T] -> [(unpack* (nth 2 H) (nth 1 H) [ ]) | (decode T)] where (cons? H)
    [H | T] -> [[H] | (decode T)])

(define unpack*
    Item Cnt Acc -> Acc where (= 0 Cnt)
    Item Cnt Acc -> (unpack* Item (1- Cnt) [Item | Acc]))