prepress-tips

ソースの書式を変えてみる

最終更新：2008年11月16日 21:46

prepress-tips

- view

管理者のみ編集可

　ソースの書き方を少しだけ変えるとプログラムの構造が見やすくなります。
　そのサンプルを示します。

最終更新日時： 2008/11/16

サンプル（ wgc.txt → wgc.pl ）

サンプル（ wgc_js.txt → wgc_js.htm ）

サンプル（ wgc_java.txt → wgc.java ）

   ※ このテーマの発端は → 対話・検索・選択によるプログラミング
   ※ wgc問題（狼・山羊・キャベツの川渡し問題）については → 形式手法モデル理論アプローチ
   ※ ここのtxtをソースに変換するプログラムは → ソースの書式を変えてみる２
   ※ さらにわかりやすく実用的な書き方の検討は → 構造と処理を別の言語で書いて組合せる

Edit

サンプル（ wgc.txt → wgc.pl ）

wgc.txt

? main / wgc問題を解く
    / タイトルを表示する
        msg( Wgc::title() );
    / 解く
        goal_seeker( Wgc::InitialState() );
    / 結果を表示する
        msg( Wgc::answer() );
    / 終了
        exit( 0 );

? msg / メッセージを表示する
    print map do { $_."\x0a" }, @_;
? goal_seeker / モデルの解を求める
    my ( $state, $ready, ) = @_; $state || return;
    $ready || ( $twice = {}, @StateSequence = () );
    ! $twice->{ $state->toString } && $state->constraint || return;
    $state->goal && ( $state->goal_lambda, return );
    $state->lambda();
    $twice->{ $state->toString } = 1; push @StateSequence, $state;
    map do { goal_seeker( $_, 1 ); }, map do { $state->Delta( $_ ); }, $state->Actions;
    pop @StateSequence; $twice->{ $state->toString } = undef;
    $state->lambda_back();

? package Wgc
    ? title / タイトル
        '狼・山羊・キャベツの川渡し問題';
    ? answer / 解
        @answer;
    = @answer

    ? State / 状態
            # 川の左側を 文字列で表わしたもの
        bless{ state => $_[0] };
    ? InitialState / 初期状態
            # 初期化
        @answer = ();
        @sequence = ();
            # "wgcf"
        State( "wgcf" );
    ? toString
        unique( $_[0]->{state} );
    ? unique
        my $r = "";
        for( sort split "", $_[0] ) { $r =~ s/($_|$)/$_/; }
        $r;

    ? goal / ゴール
        $_[0]->{state} eq "";
    ? goal_lambda / ゴールですること
            # 状態の推移を 解に追加する
        push @answer, "answer: ".join ' → ', @sequence;
    = @sequence / 状態の推移

    ? lambda / 新しい状態ですること
            # 状態を 状態の推移に記録する
        push @sequence, $_[0]->toString;
    ? lambda_back / 前の状態に戻す
            # 状態の推移の 最後を消す
        pop @sequence;

    ? Actions / ある状態で実行できること
            # 状態に"f"が含まれれば 状態を１文字ずつに分けたもの
            # そうでないならば 状態に含まれない文字を１つずつに分けたもの
        my $state = $_[0]->{state};
        $state =~ /f/ && ( return split "", $state );
        map do { $state =~ /$_/ ? () : $_ ; }, split "", "wgcf";
    ? Delta / 実行できることを実行したあとの状態
            # 状態に"f"が含まれないならば 状態に"f"と実行するものを加える
            # そうでないならば 状態から"f"と実行するものを除く
        my $state = $_[0]->{state};
        $state =~ /f/ || ( return State( $state."f".$_[1] ) );
        $state =~ s/f//g; $state =~ s/$_[1]//g; return State( $state );
    ? constraint / 満たさなくてはいけないこと
            # 状態に"f"が含まれれば
            # 状態に "w","g"のどちらがあり かつ "g","c"のどちらかがあること
            #（ 両方あってもよい ）
            # そうでないならば
            # 状態に "w"と"g"がともにはなく かつ "g"と"c"がともにはない こと
        my $state = $_[0]->{state};
        if( $state =~ /f/ ) {
            return ( $state =~ /w/ || $state =~ /g/ ) && ( $state =~ /g/ || $state =~ /c/ );
        }
        return ! ( $state =~ /w/ && $state =~ /g/ ) && ! ( $state =~ /g/ && $state =~ /c/ );

wgc.pl

{ # wgc問題を解く
    { # タイトルを表示する
        msg( Wgc::title() );
    }
    { # 解く
        goal_seeker( Wgc::InitialState() );
    }
    { # 結果を表示する
        msg( Wgc::answer() );
    }
    { # 終了
        exit( 0 );
    }
}

sub msg { # メッセージを表示する
    print map do { $_."\x0a" }, @_;
}
sub goal_seeker { # モデルの解を求める
    my ( $state, $ready, ) = @_; $state || return;
    $ready || ( $twice = {}, @StateSequence = () );
    ! $twice->{ $state->toString } && $state->constraint || return;
    $state->goal && ( $state->goal_lambda, return );
    $state->lambda();
    $twice->{ $state->toString } = 1; push @StateSequence, $state;
    map do { goal_seeker( $_, 1 ); }, map do { $state->Delta( $_ ); }, $state->Actions;
    pop @StateSequence; $twice->{ $state->toString } = undef;
    $state->lambda_back();
}

{ package Wgc;
    sub title { # タイトル
        '狼・山羊・キャベツの川渡し問題';
    }
    sub answer { # 解
        @answer;
    }
    @answer; 

    sub State { # 状態
            # 川の左側を 文字列で表わしたもの
        bless{ state => $_[0] };
    }
    sub InitialState { # 初期状態
            # 初期化
        @answer = ();
        @sequence = ();
            # "wgcf"
        State( "wgcf" );
    }
    sub toString {
        unique( $_[0]->{state} );
    }
    sub unique {
        my $r = "";
        for( sort split "", $_[0] ) { $r =~ s/($_|$)/$_/; }
        $r;
    }

    sub goal { # ゴール
        $_[0]->{state} eq "";
    }
    sub goal_lambda { # ゴールですること
            # 状態の推移を 解に追加する
        push @answer, "answer: ".join ' → ', @sequence;
    }
    @sequence; # 状態の推移

    sub lambda { # 新しい状態ですること
            # 状態を 状態の推移に記録する
        push @sequence, $_[0]->toString;
    }
    sub lambda_back { # 前の状態に戻す
            # 状態の推移の 最後を消す
        pop @sequence;
    }

    sub Actions { # ある状態で実行できること
            # 状態に"f"が含まれれば 状態を１文字ずつに分けたもの
            # そうでないならば 状態に含まれない文字を１つずつに分けたもの
        my $state = $_[0]->{state};
        $state =~ /f/ && ( return split "", $state );
        map do { $state =~ /$_/ ? () : $_ ; }, split "", "wgcf";
    }
    sub Delta { # 実行できることを実行したあとの状態
            # 状態に"f"が含まれないならば 状態に"f"と実行するものを加える
            # そうでないならば 状態から"f"と実行するものを除く
        my $state = $_[0]->{state};
        $state =~ /f/ || ( return State( $state."f".$_[1] ) );
        $state =~ s/f//g; $state =~ s/$_[1]//g; return State( $state );
    }
    sub constraint { # 満たさなくてはいけないこと
            # 状態に"f"が含まれれば
            # 状態に "w","g"のどちらがあり かつ "g","c"のどちらかがあること
            #（ 両方あってもよい ）
            # そうでないならば
            # 状態に "w"と"g"がともにはなく かつ "g"と"c"がともにはない こと
        my $state = $_[0]->{state};
        if( $state =~ /f/ ) {
            return ( $state =~ /w/ || $state =~ /g/ ) && ( $state =~ /g/ || $state =~ /c/ );
        }
        return ! ( $state =~ /w/ && $state =~ /g/ ) && ! ( $state =~ /g/ && $state =~ /c/ );
    }
1; }

サンプル（ wgc_js.txt → wgc_js.htm ）

wgc_js.txt

=
＜HTML>
    ＜meta http-equiv="Content-Type" content="text/html;charset=shift_jis">
    ＜head>
        ＜title>javascriptで 狼・山羊・キャベツの川渡し問題を解く＜/title>
        ＜/head>
    ＜body bgcolor="#FFFFFF">
        ＜h4>javascriptで 狼・山羊・キャベツの川渡し問題を解く＜/h4>
        ＜form>＜input type="button" value="実行" onClick="run()">＜/form>
        ＜div id="result">＜/div>
        ＜/body>
    ＜script type="text/javascript">

? run / wgc問題を解く
    / タイトルを表示する
        msg_clr(); msg( Wgc.title() );
    / 解く
        Wgc.goal_seeker( Wgc.InitialState() );
    / 結果を表示する
        msg( Wgc.answer() );

? msg_clr / メッセージをクリアする
    id( 'result' ).innerHTML = "";
? msg / メッセージを表示する
    m = new Array();
    for( var i = 0; i < msg.arguments.length; i++ ) {
        m = m.concat( msg.arguments[ i ]);
    }
    if( m.length != 0 ) { m.push( "" ); }
    id( 'result' ).innerHTML += m.join( "＜br>\x0a" );
? id ( i ) / idで指定される要素を返す
    return window.document.getElementById( i );

? goal_seeker ( state, ready ) / モデルの解を求める
    if( ! state ) { return; }
    if( ! ready ) { this.twice = new Array(); }
    if( this.twice[ state.toString() ] ) { return; }
    if( ! this.constraint( state ) ) { return; }
    if( this.goal( state ) ) { this.goal_lambda( state ); return; }
    this.lambda( state  );
    this.twice[ state.toString() ] = true;
    var actions = this.Actions( state );
    for( action in actions ) {
        var new_state = this.Delta( state, actions[ action ] );
        this.goal_seeker( new_state, true );
    }
    delete this.twice[ state.toString() ];
    this.lambda_back( state );

= Wgc
    Wgc = { goal_seeker : goal_seeker }
    ? Wgc.title / タイトル
        return "狼・山羊・キャベツの川渡し問題";
    ? Wgc.answer / 解
        return this.answer_array;
    = Wgc.answer_array

    ? Wgc.State ( s ) / 状態
            // 川の左側を 文字列で表わしたもの
        this.state = s;
    ? Wgc.InitialState / 初期状態
            // 初期化
        this.answer_array = new Array();
        this.sequence = new Array();
            // "wgcf"
        return new this.State( "wgcf" );
    ? Wgc.State.prototype.toString / 状態をユニークに文字列で表現する
        return unique( this.state );
    ? unique ( state )
        return state.split( "" ).sort().join( "" ).replace( "ff", "f" );
            // 重複する可能性があるのは fだけなので。

    ? Wgc.goal ( state ) / ゴール
        return state.state == "";
    ? Wgc.goal_lambda ( state ) / ゴールですること
            // 状態の推移を 解に追加する
        Wgc.answer_array.push( "answer: " + Wgc.sequence.join( ' → ' ) );
    = Wgc.sequence / 状態の推移

    ? Wgc.lambda ( state ) / 新しい状態ですること
            // 状態を 状態の推移に記録する
        Wgc.sequence.push( state.toString() );
    ? Wgc.lambda_back ( state ) / 前の状態に戻す
            // 状態の推移の 最後を消す
        Wgc.sequence.pop();

    ? Wgc.Actions ( state ) / ある状態で実行できること
            // 状態に"f"が含まれれば 状態を１文字ずつに分けたもの
            // そうでないならば 状態に含まれない文字を１つずつに分けたもの
        if( state.state.match( /f/ ) ) { return state.state.split( "" ); }
        return minus( "wgcf", state.state ).split( "" );
    ? Wgc.Delta ( state, action ) / 実行できることを実行したあとの状態
            // 状態に"f"が含まれないならば 状態に"f"と実行するものを加える
            // そうでないならば 状態から"f"と実行するものを除く
        if( ! state.state.match( /f/ ) ) {
            return new Wgc.State( state.state + "f" + action );
        }
        return new Wgc.State( minus( state.state, "f" + action ) );
    ? minus ( state_a, state_b ) / state_aから state_bにあるものを除いて返す
        if( state_b.length == 0 ) { return state_a; }
        return state_a.replace( new RegExp( "[" + state_b + "]", "g" ), "" );
    ? Wgc.constraint ( state ) / 満たさなくてはいけないこと
            // 状態に"f"が含まれれば
            // 状態に "w","g"のどちらがあり かつ "g","c"のどちらかがあること
            //（ 両方あってもよい ）
            // そうでないならば
            // 状態に "w"と"g"がともにはなく かつ "g"と"c"がともにはない こと
        if( state.state.match( /f/ ) ) {
            return state.state.match( /[wg]/ ) && state.state.match( /[gc]/ );
        }
        return ! state.state.match( /(w.*g|g.*w)/ ) && ! state.state.match( /(g.*c|c.*g)/ );

=
        alert( "load: ok" );
        ＜/script>
    ＜/HTML>

wgc_js.htm

＜HTML>
    ＜meta http-equiv="Content-Type" content="text/html;charset=shift_jis">
    ＜head>
        ＜title>javascriptで 狼・山羊・キャベツの川渡し問題を解く＜/title>
        ＜/head>
    ＜body bgcolor="#FFFFFF">
        ＜h4>javascriptで 狼・山羊・キャベツの川渡し問題を解く＜/h4>
        ＜form>＜input type="button" value="実行" onClick="run()">＜/form>
        ＜div id="result">＜/div>
        ＜/body>
    ＜script type="text/javascript">

run = function () { // wgc問題を解く
    { // タイトルを表示する
        msg_clr(); msg( Wgc.title() );
    }
    { // 解く
        Wgc.goal_seeker( Wgc.InitialState() );
    }
    { // 結果を表示する
        msg( Wgc.answer() );
    }
}

msg_clr = function () { // メッセージをクリアする
    id( 'result' ).innerHTML = "";
}
msg = function () { // メッセージを表示する
    m = new Array();
    for( var i = 0; i < msg.arguments.length; i++ ) {
        m = m.concat( msg.arguments[ i ]);
    }
    if( m.length != 0 ) { m.push( "" ); }
    id( 'result' ).innerHTML += m.join( "＜br>\x0a" );
}
id = function ( i ) { // idで指定される要素を返す
    return window.document.getElementById( i );
}

goal_seeker = function ( state, ready ) { // モデルの解を求める
    if( ! state ) { return; }
    if( ! ready ) { this.twice = new Array(); }
    if( this.twice[ state.toString() ] ) { return; }
    if( ! this.constraint( state ) ) { return; }
    if( this.goal( state ) ) { this.goal_lambda( state ); return; }
    this.lambda( state  );
    this.twice[ state.toString() ] = true;
    var actions = this.Actions( state );
    for( action in actions ) {
        var new_state = this.Delta( state, actions[ action ] );
        this.goal_seeker( new_state, true );
    }
    delete this.twice[ state.toString() ];
    this.lambda_back( state );
}

var Wgc; {
    Wgc = { goal_seeker : goal_seeker }
    Wgc.title = function () { // タイトル
        return "狼・山羊・キャベツの川渡し問題";
    }
    Wgc.answer = function () { // 解
        return this.answer_array;
    }
    Wgc.answer_array; 

    Wgc.State = function ( s ) { // 状態
            // 川の左側を 文字列で表わしたもの
        this.state = s;
    }
    Wgc.InitialState = function () { // 初期状態
            // 初期化
        this.answer_array = new Array();
        this.sequence = new Array();
            // "wgcf"
        return new this.State( "wgcf" );
    }
    Wgc.State.prototype.toString = function () { // 状態をユニークに文字列で表現する
        return unique( this.state );
    }
    unique = function ( state ) {
        return state.split( "" ).sort().join( "" ).replace( "ff", "f" );
            // 重複する可能性があるのは fだけなので。
    }

    Wgc.goal = function ( state ) { // ゴール
        return state.state == "";
    }
    Wgc.goal_lambda = function ( state ) { // ゴールですること
            // 状態の推移を 解に追加する
        Wgc.answer_array.push( "answer: " + Wgc.sequence.join( ' → ' ) );
    }
    Wgc.sequence; // 状態の推移

    Wgc.lambda = function ( state ) { // 新しい状態ですること
            // 状態を 状態の推移に記録する
        Wgc.sequence.push( state.toString() );
    }
    Wgc.lambda_back = function ( state ) { // 前の状態に戻す
            // 状態の推移の 最後を消す
        Wgc.sequence.pop();
    }

    Wgc.Actions = function ( state ) { // ある状態で実行できること
            // 状態に"f"が含まれれば 状態を１文字ずつに分けたもの
            // そうでないならば 状態に含まれない文字を１つずつに分けたもの
        if( state.state.match( /f/ ) ) { return state.state.split( "" ); }
        return minus( "wgcf", state.state ).split( "" );
    }
    Wgc.Delta = function ( state, action ) { // 実行できることを実行したあとの状態
            // 状態に"f"が含まれないならば 状態に"f"と実行するものを加える
            // そうでないならば 状態から"f"と実行するものを除く
        if( ! state.state.match( /f/ ) ) {
            return new Wgc.State( state.state + "f" + action );
        }
        return new Wgc.State( minus( state.state, "f" + action ) );
    }
    minus = function ( state_a, state_b ) { // state_aから state_bにあるものを除いて返す
        if( state_b.length == 0 ) { return state_a; }
        return state_a.replace( new RegExp( "[" + state_b + "]", "g" ), "" );
    }
    Wgc.constraint = function ( state ) { // 満たさなくてはいけないこと
            // 状態に"f"が含まれれば
            // 状態に "w","g"のどちらがあり かつ "g","c"のどちらかがあること
            //（ 両方あってもよい ）
            // そうでないならば
            // 状態に "w"と"g"がともにはなく かつ "g"と"c"がともにはない こと
        if( state.state.match( /f/ ) ) {
            return state.state.match( /[wg]/ ) && state.state.match( /[gc]/ );
        }
        return ! state.state.match( /(w.*g|g.*w)/ ) && ! state.state.match( /(g.*c|c.*g)/ );
    }
}

        alert( "load: ok" );
        ＜/script>
    ＜/HTML>

都合によりタグの最初の < はすべて全角に変えてあります。
実際に試してみるときは全角の＜をすべて半角に変えてください。
実際にブラウザで試してみる → wgc_js.htm （実行ボタンをクリックしてみてください）

サンプル（ wgc_java.txt → wgc.java ）

wgc_java.txt

package wgc;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

? Wgc ─ class

    ? main ( String[] args ) ─ public static void / wgc問題を解く
        / タイトルを表示する
            Msg.msg( title() );
        / 解く
            new GoalSeeker( new WgcState( "wgcf" ), new WgcProcessor() );
        / 結果を表示する
            Msg.msg( answer() );

    ? title () ─ static String / タイトル
        return "狼・山羊・キャベツの川渡し問題";

    ? answer () ─ static ArrayList / 解
        return answer_array;
    = answer_array ─ static ArrayList

? Msg ─ class / メッセージを表示する

    ? msg ( String m ) ─ static void
        System.out.println( m );

    ? msg ( ArrayList m ) ─ static void
        Iterator it = m.iterator();
        while( it.hasNext() ) { System.out.println( it.next() ); }

? GoalSeeker ─ class / モデルの解を求める

    ? GoalSeeker ( State state, StateProcessor p )
        processor = p;
        twice = new ArrayList();
        goal_seeker ( state );
    = processor ─ StateProcessor
    = twice ─ ArrayList

    ? goal_seeker ( State state ) ─ void
        if( state == null ) { return; }
        if( twice.contains( state.toString() ) ) { return; }
        if( ! processor.constraint( state ) ) { return; }
        if( processor.goal( state ) ) { processor.goal_lambda( state ); return; }
        processor.lambda( state );
        twice.add( state.toString() );
        String[] actions = processor.Actions( state );
        for( int i = 0; i < actions.length; i++ ) {
            String a = actions[ i ];
            if( a.equals( "" ) ) { continue; }
            State new_state = processor.Delta( state, a );
            goal_seeker( new_state );
        }
        twice.remove( state.toString() );
        processor.lambda_back( state );

? State ─ abstract class
    String state;
    public String toString() { return state; }

? StateProcessor ─ abstract class
    boolean goal( State state ) { return false; }
    void goal_lambda( State state ) {}
    void lambda( State state ) {}
    void lambda_back( State state ) {}
    String[] Actions( State state ) { return null; }
    State Delta( State state, String action ) { return null; }
    boolean constraint( State state ) { return false; }

? WgcState ─ class extends State

    ? WgcState ( String string ) / 状態
        super();
        / 川の左側を 文字列で表わしたもの
            state = string;
    ? toString () ─ public String / 状態をユニークに文字列で表現する
        return unique( state );
    ? unique ( String state ) ─ String
        String[] s = state.split( "" ); Arrays.sort(s);
        String r = ""; for( int i = 0; i < s.length; i++ ) { r += s[i]; }
        return r.replaceAll( "f+" , "f" );

? WgcProcessor ─ class extends StateProcessor

    ? WgcProcessor () / 初期化
        sequence = new ArrayList();
        Wgc.answer_array = new ArrayList();

    ? goal ( State s ) ─ boolean / ゴール
        return s.state.equals( "" );
    ? goal_lambda ( State s ) ─ void / ゴールですること
        / 状態の推移を 解に追加する
            Iterator it = sequence.iterator();
            String r = ""; while( it.hasNext() ) { r += " → " + it.next(); }
            r += " → " + s.toString();
            Wgc.answer_array.add( r.replaceFirst( "( → )+", "" ) );
    = sequence ─ ArrayList / 状態の推移

    ? lambda ( State s ) ─ void / 新しい状態ですること
        / 状態を 状態の推移に記録する
            sequence.add( s.toString() );
    ? lambda_back ( State s ) ─ void / 前の状態に戻す
        / 状態の推移の 最後を消す
            sequence.remove( sequence.size() - 1 );

    ? Actions ( State s ) ─ String[] / ある状態で実行できること
        / 状態に"f"が含まれれば 状態を１文字ずつに分けたもの
        / そうでないならば 状態に含まれない文字を１つずつに分けたもの
            if( s.state.matches( ".*f.*" ) ) { return s.state.split( "" ); }
            return minus( "wgcf", s.state ).split( "" );
    ? minus ( String state_a, String state_b ) ─ String
        / state_aから state_bにあるものを除いて返す
            if( state_b.length() == 0 ) { return state_a; }
            return state_a.replaceAll( "[" + state_b + "]", "" );
    ? Delta ( State s, String action ) ─ State / 実行できることを実行したあとの状態
        / 状態に"f"が含まれないならば 状態に"f"と実行するものを加える
        / そうでないならば 状態から"f"と実行するものを除く
            if( ! s.state.matches( ".*f.*" ) ) {
                return new WgcState( s.state + "f" + action );
            }
            return new WgcState( minus( s.state, "f" + action ) );
    ? constraint ( State s ) ─ boolean / 満たさなくてはいけないこと
        / 状態に"f"が含まれれば
        / 状態に "w","g"のどちらがあり かつ "g","c"のどちらかがあること
        /（ 両方あってもよい ）
        / そうでないならば
        / 状態に "w"と"g"がともにはなく かつ "g"と"c"がともにはない こと
            if( s.state.matches( ".*f.*" ) ) {
                return s.state.matches( ".*[wg].*" ) && s.state.matches( ".*[gc].*" );
            }
            return ! s.state.matches( ".*(w.*g|g.*w).*" ) && ! s.state.matches( ".*(g.*c|c.*g).*" );

Wgc.java

package wgc;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

class Wgc {

    public static void main ( String[] args ) { // wgc問題を解く
        { // タイトルを表示する
            Msg.msg( title() );
        }
        { // 解く
            new GoalSeeker( new WgcState( "wgcf" ), new WgcProcessor() );
        }
        { // 結果を表示する
            Msg.msg( answer() );
        }
    }

    static String title () { // タイトル
        return "狼・山羊・キャベツの川渡し問題";
    }

    static ArrayList answer () { // 解
        return answer_array;
    }
    static ArrayList answer_array; 
}

class Msg { // メッセージを表示する

    static void msg ( String m ) {
        System.out.println( m );
    }

    static void msg ( ArrayList m ) {
        Iterator it = m.iterator();
        while( it.hasNext() ) { System.out.println( it.next() ); }
    }
}

class GoalSeeker { // モデルの解を求める

    GoalSeeker ( State state, StateProcessor p ) {
        processor = p;
        twice = new ArrayList();
        goal_seeker ( state );
    }
    StateProcessor processor; 
    ArrayList twice; 

    void goal_seeker ( State state ) {
        if( state == null ) { return; }
        if( twice.contains( state.toString() ) ) { return; }
        if( ! processor.constraint( state ) ) { return; }
        if( processor.goal( state ) ) { processor.goal_lambda( state ); return; }
        processor.lambda( state );
        twice.add( state.toString() );
        String[] actions = processor.Actions( state );
        for( int i = 0; i < actions.length; i++ ) {
            String a = actions[ i ];
            if( a.equals( "" ) ) { continue; }
            State new_state = processor.Delta( state, a );
            goal_seeker( new_state );
        }
        twice.remove( state.toString() );
        processor.lambda_back( state );
    }
}

abstract class State {
    String state;
    public String toString() { return state; }
}

abstract class StateProcessor {
    boolean goal( State state ) { return false; }
    void goal_lambda( State state ) {}
    void lambda( State state ) {}
    void lambda_back( State state ) {}
    String[] Actions( State state ) { return null; }
    State Delta( State state, String action ) { return null; }
    boolean constraint( State state ) { return false; }
}

class WgcState extends State {

    WgcState ( String string ) { // 状態
        super();
        { // 川の左側を 文字列で表わしたもの
            state = string;
        }
    }
    public String toString () { // 状態をユニークに文字列で表現する
        return unique( state );
    }
    String unique ( String state ) {
        String[] s = state.split( "" ); Arrays.sort(s);
        String r = ""; for( int i = 0; i < s.length; i++ ) { r += s[i]; }
        return r.replaceAll( "f+" , "f" );
    }
}

class WgcProcessor extends StateProcessor {

    WgcProcessor () { // 初期化
        sequence = new ArrayList();
        Wgc.answer_array = new ArrayList();
    }

    boolean goal ( State s ) { // ゴール
        return s.state.equals( "" );
    }
    void goal_lambda ( State s ) { // ゴールですること
        { // 状態の推移を 解に追加する
            Iterator it = sequence.iterator();
            String r = ""; while( it.hasNext() ) { r += " → " + it.next(); }
            r += " → " + s.toString();
            Wgc.answer_array.add( r.replaceFirst( "( → )+", "" ) );
        }
    }
    ArrayList sequence; // 状態の推移

    void lambda ( State s ) { // 新しい状態ですること
        { // 状態を 状態の推移に記録する
            sequence.add( s.toString() );
        }
    }
    void lambda_back ( State s ) { // 前の状態に戻す
        { // 状態の推移の 最後を消す
            sequence.remove( sequence.size() - 1 );
        }
    }

    String[] Actions ( State s ) { // ある状態で実行できること
        // 状態に"f"が含まれれば 状態を１文字ずつに分けたもの
        { // そうでないならば 状態に含まれない文字を１つずつに分けたもの
            if( s.state.matches( ".*f.*" ) ) { return s.state.split( "" ); }
            return minus( "wgcf", s.state ).split( "" );
        }
    }
    String minus ( String state_a, String state_b ) {
        { // state_aから state_bにあるものを除いて返す
            if( state_b.length() == 0 ) { return state_a; }
            return state_a.replaceAll( "[" + state_b + "]", "" );
        }
    }
    State Delta ( State s, String action ) { // 実行できることを実行したあとの状態
        // 状態に"f"が含まれないならば 状態に"f"と実行するものを加える
        { // そうでないならば 状態から"f"と実行するものを除く
            if( ! s.state.matches( ".*f.*" ) ) {
                return new WgcState( s.state + "f" + action );
            }
            return new WgcState( minus( s.state, "f" + action ) );
        }
    }
    boolean constraint ( State s ) { // 満たさなくてはいけないこと
        // 状態に"f"が含まれれば
        // 状態に "w","g"のどちらがあり かつ "g","c"のどちらかがあること
        //（ 両方あってもよい ）
        // そうでないならば
        { // 状態に "w"と"g"がともにはなく かつ "g"と"c"がともにはない こと
            if( s.state.matches( ".*f.*" ) ) {
                return s.state.matches( ".*[wg].*" ) && s.state.matches( ".*[gc].*" );
            }
            return ! s.state.matches( ".*(w.*g|g.*w).*" ) && ! s.state.matches( ".*(g.*c|c.*g).*" );
        }
    }
}

Edit

「ソースの書式を変えてみる」をウィキ内検索

人気記事ランキング

最近更新されたページ

急上昇Wikiランキング

急上昇中のWikiランキングです。今注目を集めている話題をチェックしてみよう！

人気Wikiランキング

atwikiでよく見られているWikiのランキングです。新しい情報を発見してみよう！

新規Wikiランキング

最近作成されたWikiのアクセスランキングです。見るだけでなく加筆してみよう！

全体ページランキング

最近アクセスの多かったページランキングです。話題のページを見に行こう！

ソースの書式を変えてみる

サンプル（ wgc.txt → wgc.pl ）

サンプル（ wgc_js.txt → wgc_js.htm ）

サンプル（ wgc_java.txt → wgc.java ）

更新履歴