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-03-14

QiでL-99 (P11 連続する要素をランレングス圧縮する その2)

| 23:29 | QiでL-99 (P11 連続する要素をランレングス圧縮する その2) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P11 連続する要素をランレングス圧縮する その2) - わだばLisperになる

実は本家サイトのP-99はPrologの全問解答がありますが、L-99は解答が全部揃ってません。

そういう訳で、fixdapにてL-99の解答を作成するというプロジェクトを作成してみたんですが、良かったら投稿してみて下さい!

現在作成したCommon Lisp、Scheme、Arc、Qi等の解答例を少しずつアップしてみています。

(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* (pack X)))

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

2008-03-12

QiでL-99 (P10 連続する要素をランレングス圧縮する)

| 23:29 | QiでL-99 (P10 連続する要素をランレングス圧縮する) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P10 連続する要素をランレングス圧縮する) - わだばLisperになる

Qiのそこそこ普通のLISPとは違っていて、それでいてそんなに違っている訳でもないという辺が段々好きになって来たような、来ないような。

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

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

(define encode*
    [ ] -> [ ]
    [H | T] -> [[(length H) (head H)] | (encode* T)])

2008-03-11

QiでL-99 (P09 連続して現われる要素を纏める)

| 16:47 | QiでL-99 (P09 連続して現われる要素を纏める) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P09 連続して現われる要素を纏める) - わだばLisperになる

ちょっと複雑になると途端にどうしたら良いか分からなくなってしまいます。

そろそろチュートリアルをきちんと読まねば…。

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

(define pack
    [ ] -> [ ]
    X -> (pack* X [ ] [ ]))

(define pack*
    [ ] Acc Res -> (reverse (cons Acc Res))
    [H | T] Acc Res -> (pack* T (cons H Acc) Res) where (or (empty? Acc) (= H (head Acc)))
    Lst Acc Res -> (pack* Lst [ ] (cons Acc Res)))

2008-03-10

QiでL-99 (P08 連続して現われる要素を圧縮)

| 16:47 | QiでL-99 (P08 連続して現われる要素を圧縮) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P08 連続して現われる要素を圧縮) - わだばLisperになる

なんとなくで書いてみました。

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

(define compress
    [ ] -> [ ]
    [H T] -> [H] where (= H T)
    [H | [T | U]] -> (compress [T | U]) where (= H T)
    [H | T] -> [H | (compress T)])

QiでL-99 (P07 リストの平坦化)

| 01:39 | QiでL-99 (P07 リストの平坦化) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P07 リストの平坦化) - わだばLisperになる

今回は、flatten。Qiだと、どうなるのかいまいちはっきりしませんが、なんとなく解いてみました。

(flatten [1 2 3 4 [[2 [3] 1] 5 6 7 8]])

(define flatten
    [ ] -> [ ]
    [X | Y] -> (append (flatten X) (flatten Y)) where (cons? X)
    [X | Y] -> [X | (flatten Y)])

2008-03-08

QiでL-99 (P06 リストの中身が回文的かを調べる)

| 10:33 | QiでL-99 (P06 リストの中身が回文的かを調べる) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P06 リストの中身が回文的かを調べる) - わだばLisperになる

これまた普通に。Qiの述語命名規則的には、Schemeのように最後に?を付けるようなので、そういう雰囲気で。

また、真偽値は、trueとfalseになっています。

(palindrome? [x a m a x])
\-> true
\

(define palindrome? 
    X -> true where (= X (reverse X)))

2008-03-07

QiでL-99 (P05 リストを逆転させる)

| 14:39 | QiでL-99 (P05 リストを逆転させる) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P05 リストを逆転させる) - わだばLisperになる

これまた定番な感じで。

Qiには標準で、reverseがあります。

(rev [1 2 3 4])
\-> [4 3 2 1]
\

(define rev 
    [ ] -> [ ]
    [H | T] -> (append (rev T) [H]))

2008-03-06

QiでL-99 (P04 リストの要素の個数を数える)

| 10:58 | QiでL-99 (P04 リストの要素の個数を数える) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P04 リストの要素の個数を数える) - わだばLisperになる

これまた普通な書き方で。

Qiには備え付けでlengthがあるようです。

(len [1 2 3 4 5 6 7 8])
\-> 8
\

(define len
    [ ] -> 0
    [_ | T] -> (1+ (len T)))

QiでL-99 (P03 リストのK番目の要素を取り出す)

| 04:07 | QiでL-99 (P03 リストのK番目の要素を取り出す) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P03 リストのK番目の要素を取り出す) - わだばLisperになる

いまいちQiの流儀というかパターンマッチが分からず、普通のLISPみたいに書いてしまっていますが、これで良いんでしょうかねえ。

(element-at [a b c d e] 3)
\ -> c
\

(define element-at 
    List Pos -> [ ] where (or (< Pos 1) (< (length List) Pos))
    List Pos -> (element-at* List 1 Pos))

(define element-at*
    [ ] _ _ -> [ ]
    [X | _] Cnt Lim -> X where (= Cnt Lim)
    [_ | X] Cnt Lim -> (element-at* X (1+ Cnt) Lim))

2008-03-04

QiでL-99 (P02 最後の要素をリストにして返す)

| 18:50 | QiでL-99 (P02 最後の要素をリストにして返す) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P02 最後の要素をリストにして返す) - わだばLisperになる

そのうちこのブログはL-99ばっかりになりそうな予感が!

(last-but-one [1 2 3 4])
\-> [4]
\

(define last-but-one
    [] -> []
    [X | []] -> [X]
    [_ | X] -> (last-but-one X))

QiでL-99 (P01 リストの最後の要素)

| 18:49 | QiでL-99 (P01 リストの最後の要素) - わだばLisperになる を含むブックマーク はてなブックマーク - QiでL-99 (P01 リストの最後の要素) - わだばLisperになる

割と自分は一度に色んな物に手を出して全部失敗する口なのですが、その流れを継承してQiにも手を出してみることにしました。

Qiは…何か凄そうなLISPの方言みたいです。自分は良く分かっていません。

型の扱いとか、パターンマッチとか色々特徴はあるようです。

自分的にはProlog的なパターンマッチが面白そうだったので手を出してみました。

そういう意味では、TAOは、PrologとSmalltalkとLISPが合体しているので、TAOを使ってみたいもんだと思います。

ヤフオクとかにELISが出品されたりしないですかね(笑)

(last [1 2 3 4])
\-> 4 
\

(define last
    [] -> []
    [X | []] -> X
    [_ | X] -> (last X))