algorithm

blogだけでは飽き足らず

επιστημη — Wed, 13 Aug 2008 22:16:00 GMT

夏も初めのごめんなさいあたりから
短期集中連載(?)してたマージ・ソートの「まとめ」をCodeZineに書きました。

マージ・ソート : 巨大データのソート法ての。
マージ・ソートのアルゴリズム解説とその実装を
VB, C#, C++/CLI でやらかしてます。

インスパイア元 → すごいひとです！
名著「アルゴリズムとデータ構造」をよこちょに置いて書いてました。
いやね、WPFとかWCFとかLINQとかXNAとか、みんなすごいなーと
思うんですよ。僕は新しいことに手を染めず、そこそこ枯れてきた頃に
美味しいとこだけ頂戴するばかりです。

もう幾度となく繰り返してることですが、近頃のビギナ(に限らんかな)は
本を読まなくなりました。大概のことはネット検索すりゃカタがつきます
しね。けども僕は本を大事にしたい。「アルゴリズムとデータ構造」はもう
30年以上前の解説書です。けども僕のプログラマ稼業でいちばん役に立った
本だし今でもときおり読み返します。

まぁ、そんな想いを若い人たちにちょっとでも伝えたくて、ほんのりカビ
臭いこんなネタを書いてみたりするわけね。

よろしく御贔屓のほどを。

名乗りを上げました

επιστημη — Wed, 13 Aug 2008 11:19:00 GMT

来る09/20はわんくま東京勉強会#24です。

ディレクターははつねさん、
僕はソートをネタとしたLT(Ligtening Talk)に手ぇ挙げちゃいました。
LTってやったことないのよねー。
短い尺で喋るのってドキドキです、
10分以上あるなら尺の調整が利くんですけど
わずか5分ですからね。きっちり練習しとかんと...

さて、肝心のネタですが、なんにしましょ。
あんまり語られてないポい「ヒープソート」
を5分で語ってみましょうかしら。

早速ネタ仕込み。Visual Studio立ち上げてごりごり書く。

template<typename T>
void Sift(T data[], int L, int R) {
int i = L;
int j = 2*i + 1;
T x = data[L];
if ( j < R && data[j] < data[j+1] ) ++j;
while ( j <= R && x < data[j] ) {
    data[i] = data[j];
    i = j;
    j = 2*j + 1;
    if ( j < R && data[j] < data[j+1] ) ++j;
}
data[i] = x;
}

/*
* ヒープソート
*/
template<typename T>
void Sort(T data[],int n) {
int L = n / 2;
int R = n - 1;
while ( L > 0 ) Sift(data, --L, R);
while ( R > 0 ) {
    T x = data[0];
    data[0] = data[R];
    data[R] = x;
    Sift(data, L, --R);
}
}

コードの解説したってつまんない。さーてこれをどうすべか。

※ 昨日帰りがけに立ち寄った本屋でなにげに手にした一冊にあったヒトコト:
　「スピーチなんかするな。ショーにしてしまえ」いぃことゆー♪

[追記] STL使うとシュウたん並みに脱力します。o<\_

#include <iostream>
#include <algorithm>

int main() {
int data[] = { 9, 7, 5, 3, 1, 8, 6, 4, 2, 0 };
std::make_heap(data, data+10); // ぶっちゃけ
std::sort_heap(data, data+10); // こんだけ。
for ( int i = 0; i < 10; ++i )
std::cout << data[i] << ' ';
}

状態遷移のテスト法(そのに)

επιστημη — Thu, 07 Aug 2008 11:48:00 GMT

状態遷移のテスト法のつづき。

遷移行列の積を求めるコードを書いてみた。

using System;
using System.Collections.Generic;

enum 状態 { 断, 弱, 中, 強 };
enum 事象 { 無, 電, 風 };

class Program {

const int 状態数 = 4;
const int 事象数 = 2;

    static List<List<事象>>[,] createMatrix() {
        return new List<List<事象>>[状態数, 状態数];
    }

    /*
     * ここがキモ! 遷移行列の積
     */
    static List<List<事象>>[,]
      multiplyMatrix(List<List<事象>>[,] m, 事象[,] e) {
        List<List<事象>>[,] result;
        result = createMatrix();
        for (int i = 0; i < 状態数; ++i) {
            for (int j = 0; j < 状態数; ++j) {
                for (int k = 0; k < 状態数; ++k) {
                    if (m[i, k] != null && e[k, j] != 事象.無) {
                        if (result[i, j] == null) {
                            result[i, j] = new List<List<事象>>();
                        }
                        foreach (List<事象> events in m[i, k]) {
                            List<事象> l = new List<事象>(events);
                            l.Add(e[k, j]);
                            result[i, j].Add(l);
                        }
                    }
                }
            }
        }
        return result;
    }

    // HTML - <table>形式で出力
    static void printMatrix(List<List<事象>>[,] mtx) {
        Console.WriteLine("<table border='1'><tbody>");
        for (int i = 0; i < 状態数; ++i) {
            Console.Write("<tr>");
            for (int j = 0; j < 状態数; ++j) {
                Console.Write("<td>");
                if (mtx[i, j] != null) {
                    bool first = true;
                    foreach (List<事象> events in mtx[i, j]) {
                        if (!first) {
                            Console.Write("<br />");
                        } else {
                            first = false;
                        }
                        foreach (事象 ev in events) {
                            Console.Write(ev.ToString());
                        }
                    }
                }
                Console.Write("</td>");
            }
            Console.WriteLine("</tr>");
        }
        Console.WriteLine("</tbody></table>");
    }

    static void Main() {
        // 単位行列を作る
        List<List<事象>>[,] E = createMatrix();
        for (int i = 0; i < 状態数; ++i) {
            for (int j = 0; j < 状態数; ++j) {
                if (i == j) {
                    E[i, j] = new List<List<事象>>();
                    E[i, j].Add(new List<事象>());
                }
            }
        }

        // 遷移行列を作る
        事象[,] T = new 事象[状態数, 状態数];
        for (int i = 0; i < 状態数; ++i) {
            for (int j = 0; j < 状態数; ++j) {
                T[i, j] = 事象.無;
            }
        }
        T[0, 0] = 事象.風;
        T[0, 1] = 事象.電;
        T[1, 0] = 事象.電;
        T[1, 2] = 事象.風;
        T[2, 0] = 事象.電;
        T[2, 3] = 事象.風;
        T[3, 0] = 事象.電;
        T[3, 1] = 事象.風;

        List<List<事象>>[,] result = E;
        // T^n (n=1..4) を求めてみゆぅ
        for (int i = 0; i < 4; ++i) {
            result = multiplyMatrix(result, T);
            printMatrix(result);
            Console.WriteLine();
        }
    }
}

これ使って T^4まで求めたぞ↓

風	電
電		風
電			風
電	風

風風電電	風電	電風
電風風電	電電		風風
電風風電	電電風風
電風風電	電電	風風

T^2

風風風電電風風電電電風電	風風電電電電	風電風	電風風
電風風風電風電電電風風電	電風電風電電風風風	電電風
電風風風電風電電電風風電	電風電風電電	電電風風風風
電風風風電風電電電風風電	電風電風電電	電電風	風風風

T^3

風風風風電電風風風電電風電風電風風風電電電電電電風電風電電風風電	風風風電電電風電風電電電電風電電電風風風	風風電風電電電風	風電風風
電風風風風電風風電電電風風風電風電風電電風電電電風風風電電電風電	電風風電風電風電電電電電風風電電	電風電風風電電風風風風風	電電風風
電風風風風電風風電電電風風風電風電風電電風電電電電電風電風風風電	電風風電風電風電電電電電風風電電	電風電風風電電風	電電風風風風風風
電風風風風電風風電電電風風風電風電風電電風電電電電電風電風風風電	電風風電風電風電電電電電風風電電風風風風	電風電風風電電風	電電風風

T^4

状態遷移のテスト法

επιστημη — Wed, 06 Aug 2008 12:11:00 GMT

僕の部屋には扇風機があります。
(簡略化して)ボタンは電源と風量のふたつだけ。
扇風機の状態は電源断/弱/中/強の４つ。

- 電源断で電源ボタン押すと弱に。
- 弱/中/強で電源ボタン押すと電源断に。
- 電源入った状態で風量ボタン押すと弱→中→強→弱...の順に切換。

そーすっと状態遷移表はこんなのができます。

	断	弱	中	強
電	→弱	→断	→断	→断
風	→断	→中	→強	→弱

こいつを基に遷移行列を作ります。
遷移行列てのはある状態からある状態に遷移させるのに必要な事象の行列。

	断	弱	中	強
断	風	電
弱	電		風
中	電			風
強	電	風

わかるよね。縦に並ぶのが今の状態、横に並ぶのが次の状態。
この表によると、弱から中にするには風ボタンを押せばいい。

さて、この遷移行列をTとし、T^2 (=T×T) を求めると:

	断	弱	中	強
断	風風+電電	風電	電風
弱	電風+風電	電電		風風
中	電風+風電	電電+風風
強	電風+風電	電電	風風

こんなのができます。
これは二回の操作で状態を遷移させるときの事象の列
すなわち操作の列が表になってます。
たとえば中状態から二回の操作で断にするには
電・風または風・電の順にボタンを押せばいい。

遷移行列の掛け算を繰り返して T^n (= T×T×T×....×T)
を求めると、n回の操作で状態を遷移させるときの操作の列
が得られます。

ってことは、だ。全自動"扇風機のボタン押しますぃーん"を用意して、
T^nの遷移行列に記されたとおりにボタンをn回押させ、
期待する状態に落ち着くかを検証すれば扇風機のテストができるわけっすね。

ややこしいUI操作や通信プロトコルなんかもこの戦略でテスト
できそうなんだよねー

のんちゃんのVBお勉強に協力する試み (3)

επιστημη — Tue, 22 Jul 2008 21:13:00 GMT

で、こいつが課題提出用ひながた。
ソートされたらいいな、をカタチにする。をパクらせていただきました。

Module non_SortExam

    ' Sortの中で呼びたい関数/サブルーチンが
    ' あるならここらへんに書いとく

    ' 課題:
    ' ここのナカミを埋めなさい
    '
    Sub Sort(ByVal data() As Integer)
      ' とりあえず組み込みメソッドでお茶を濁しておく
      Array.Sort(data)
    End Sub

    ' data() 内を0以上100未満の乱数で埋める
    Sub FillRandom(ByVal data() As Integer)
      Dim I As Integer
      Dim R As New Random
      For I = 0 To data.Length - 1
        data(I) = R.Next(100)
      Next
    End Sub

    ' data() が昇順にソートされているなら True を返す
    Function IsSorted(ByVal data() As Integer) As Boolean
      Dim I As Integer
      If data.Length = 0 OrElse data.Length = 1 Then
        Return True
      End If
      For I = 0 To data.Length - 2
        If data(I) > data(I + 1) Then
          Return False
        End If
      Next
      Return True
    End Function

    Sub Main()
      Dim data() As Integer
      Dim I As Integer
      Dim R As New Random
      For I = 0 To 9
        ReDim data(R.Next(100)) ' テケトーな大きさの配列を
        FillRandom(data) ' テケトーに埋める
        Console.Write("{0}回目 {1}個をソート...", I, data.Length)
        Sort(data)
        If IsSorted(data) Then
          Console.WriteLine("ソートされています")
        Else
          Console.WriteLine("ダメぢゃん!")
          End
        End If
      Next
      Console.WriteLine("よくできました!")
    End Sub

End Module

あるもーん♪

επιστημη — Fri, 18 Jul 2008 23:05:00 GMT

ネタ元 → 順列生成メソッド

STL/CLRの出番だぜ。

--- myutil.h ---
namespace MyUtil {
public ref class Algrithm {
public:
    static bool NextPermutation(String^% str);
};
}

--- myutil.cpp ---
#include <cliext/algorithm>
#include <cliext/vector>
#include "myutil.h"

namespace MyUtil {
bool Algrithm::NextPermutation(String^% str) {
    cliext::vector<Char> v(str->ToCharArray());
    bool result = cliext::next_permutation(v.begin(),v.end()); // あるもーん
    str = gcnew String(v.to_array());
    return result;
}
}

--- user.cs ---
using System;
using MyUtil;

class Program {
static void Main(string[] args) {
    string str = "ABCD";
    do {
      Console.WriteLine(str);
    } while ( Algrithm.NextPermutation(ref str) );
  }
}

娘の成長を見守る父

επιστημη — Fri, 18 Jul 2008 19:37:00 GMT

ネタ元→ うぐぐ・・・タイトルがうかびません・・・
ちょっとずつ、書き方が掴めてきてるみたいね、よしよし♪

えとね、その戦略ならこうすりゃいい。
まずこんな関数を作る:

　Function LesserIndex(data() As Integer, x As Integer, y As Integer) As Integer
　' data(x) < data(y) なら x, さもなくば y を返す

んでもって
Dim minIndex As Integer
minIndex = 0 ' 0から始めて
minIndex = LesserIndex(data, minIndex, 1) ' より小さい方のインデックスがminIndexにセットされる
minIndex = LesserIndex(data, minIndex, 2) ' より小さい方のインデックスがminIndexにセットされる

これでdata(minIndex)がいっちゃん小さいことになるから、
data(0)とdata(minIndex)を交換する。
data(0)がいちばん小さくなったので、0番目まではソートできた。

そしてもう一度。
ソートの済んだdata(0)を除外して同じことすれば
次に小さいdata()がどれかわかる。それとdata(1)を交換。
これで1番目まではソートできた。

そしてもう一度。
ソートの済んだdata(0)~data(1)を除外して同じことすれば
次に小さいdata()がどれかわかる。それとdata(2)を交換。
これで2番目まではソートできた。

...これを繰り返せば昇順にソートされます。
選択ソートのアルゴリズムね。

のんちゃんのVBお勉強に協力する試み (2)

επιστημη — Wed, 16 Jul 2008 22:23:00 GMT

のんちゃんのVBお勉強に協力する試み (1) のつづき。

さてさて、ヒントめいたのを書きつけておきましょか。

まず、「昇順(小さい順)にソートされた状態」とはなにか。
data(n) (n=0..N-1) において0以上N未満であるいかなるi,j に
対しても、i < j ならば data(i) <= data(j) が成り立つ
ってこと。
もっといえば隣り合うふたつのデータについて
data(i) <= data(i+1) が成り立つってことです。

ってことは、data(i)とdata(i+1)を比較し、
data(i) > data(i+1) となってる箇所があれば
その二つを交換すればいい。
この比較と交換をくまなく行って逆順すなわち
data(i) > data(i+1) がひとつも見つからなくなればソート完了。

「比較と交換をくまなく行う」これがバブルソートのキモです。
それじゃくまなく行うにはどうすりゃいいか、
左端(i=0)からひとつずつ順にやってきゃいいわな。
たとえば 1 3 2 1 から始めて左端から一回通してみよう。
( . の左右が比較してるとこ)

1.3 2 1
1 3.2 1 → 1 2 3 1 (ここで交換)
1 2 3.1 → 1 2 1 3 (ここで交換)

こうやって一回通すと一番大きな要素が右端に寄ってくれる。
けどもまだ完全にはソートされてない。なのでもう一回。
右端が最大になってるんだから最後の比較/交換の必要はない。

1.2 1 3
1 2.1 3 → 1 1 2 3
1 1 2 3 完了!

つまり、一回でも交換を行うとそれによって大小が狂うかも
しれんのでさらにもう一回左から比較/交換を行う。
一度も交換が行われなかったらそれがソート完了の証しとなるんやね。

負けるもんかが「ﾄﾃｰﾓ大きなヒントになってんだよ」てのは
くまなく行うを実現してるとこね。

マージソート残務処理

επιστημη — Fri, 11 Jul 2008 15:23:00 GMT

ネタ元 → その差歴然(おまけ)

inplace_merge があんまり知られてなかったみたい。
なので簡単なサンプル、inplace_merge 使ってマージ・ソートを書いてみた。

#include <algorithm>
#include <iterator>

// 単純選択ソート
template<typename Iterator>
void selection_sort(Iterator first, Iterator last) {
// たったこんだけでソートできる。STLらぶ♪
for (; first != last; ++first )
std::iter_swap(first, std::min_element(first,last));
}

// マージ・ソート
template<typename Iterator>
void merge_sort(Iterator first, Iterator last) {
const typename std::iterator_traits<Iterator>::difference_type
    threshold = 40; // ウチのマシンだとこのくらいがいっちゃん速い
std::iterator_traits<Iterator>::difference_type
    size = std::distance(first,last);
// 要素数が少ないときゃ単純選択ソートに切り替える
if ( size < threshold ) {
    selection_sort(first,last);
    return;
}
Iterator middle = first; std::advance(middle, size/2); // 中央
merge_sort(first, middle); // 前半[先頭,中央) をソート
merge_sort(middle,last);   // 後半[中央,末尾) をソート
std::inplace_merge(first,middle,last); // 前半と後半をマージ
}

// こっからおためし
#include <iostream>
#include <iomanip>
#include <vector>

int main() {
const int N = 50000;
std::vector<int> source(N);
for ( int i = 0; i < N; i++ ) source[i] = i;
std::random_shuffle(source.begin(), source.end());
merge_sort(source.begin(), source.end());
}

マージソートいちおー終結

επιστημη — Fri, 11 Jul 2008 13:46:00 GMT

テキストファイルに書かれた改行区切りの文字列群を昇順にソートします。

C#, VB.NET, C++/CLI のプロジェクトを詰め込みました。

[追記] ちょびっといぢりました。1MBを限度にメモリに読み込み、
ソートして書き出すことで連を減らしています。より高速になったかと。

風風風電電風風電電電風電	風風電電電電	風電風	電風風
電風風風電風電電電風風電	電風電風電電風風風	電電風
電風風風電風電電電風風電	電風電風電電	電電風風風風
電風風風電風電電電風風電	電風電風電電	電電風	風風風

風風風風電電風風風電電風電風電風風風電電電電電電風電風電電風風電	風風風電電電風電風電電電電風電電電風風風	風風電風電電電風	風電風風
電風風風風電風風電電電風風風電風電風電電風電電電風風風電電電風電	電風風電風電風電電電電電風風電電	電風電風風電電風風風風風	電電風風
電風風風風電風風電電電風風風電風電風電電風電電電電電風電風風風電	電風風電風電風電電電電電風風電電	電風電風風電電風	電電風風風風風風
電風風風風電風風電電電風風風電風電風電電風電電電電電風電風風風電	電風風電風電風電電電電電風風電電風風風風	電風電風風電電風	電電風風

	断	弱	中	強
断	風	電
弱	電		風
中	電			風
強	電	風

	断	弱	中	強
断	風	電
弱	電		風
中	電			風
強	電	風

	断	弱	中	強
断	風	電
弱	電		風
中	電			風
強	電	風