ソフトウェア概論A/B (2013/05/24)
Ver. 1.0

2013年5月24日

栗野俊一

kurino@math.cst.nihon-u.ac.jp

http://edu-gw2.math.cst.nihon-u.ac.jp/~kurino/2013/soft/soft.html

ソフトウェア概論 A/Bの2013年5月24日の資料

講義資料

当日の OHP 資料

当日のOHP資料です。

講義で利用するサンプルプログラム

サンプルファイル

20130517.zip

Download : sample-001.c ( SJIS 版 )

sample-001.c

/*
 * CDATE sample-001.c
 */

#include <stdio.h>
#include <string.h>

/*
 *	文字列に 1 を加えると.. ?
 *		文字の長さが短くなる (頭の部分がなくなる..)
 */

/*
 * main
 */

int main ( void ) {

  printf ( "abcde\n" );		/* 当然 「abcde」が表示される.. */
  printf ( "abcde\n" + 1 );	/* 文字列に 1 を加えるってどうゆうこと.. ? */
  printf ( "abcde\n" + 2 );
printf ( "abcde\n" + 1 + 1 );	/* ("abcde\n" + 1) + 1 => "bcde\n" + 1 => \
    "cde\n" */

  return 0;
}

sample-001.c の実行結果

C:\usr\c>sample-001
abcde
bcde
cde
cde
C:\usr\c>

Download : sample-002.c ( SJIS 版 )

sample-002.c

/*
 * 2013/05/24 sample-002.c
 */

#include <stdio.h>
#include <string.h>

/*
 *	void recursive ( char *string )
 *		char *string	指定した文字列からなる三角形を作る
 *			実行例
 *				recursive( "abc\n" );	
 *					->
 *						abc			"abc\n"
 *						bc			"bc\n"
 *						c			"c\n"
 *									"\n"
 *			再帰呼出しを利用
 */

void recursive ( char *string ) {

	if ( !strcmp ( string, "" ) ) {	/* もし空文字列 ( "" ) ならば */
		printf ( "" );				/* これで御仕舞い */
	} else {						/* そうでなければ、 */
		printf ( string );
		recursive ( string + 1 );	/* 再帰呼び出しする */
									/* +1 を忘れると悲惨な事に.. */
  }
}

/*
 * main
 */

int main ( void ) {

	recursive ( "abcdefg\n" );
	recursive ( "xyz\n" );

	return 0;
}

sample-002.c の実行結果

C:\usr\c>sample-002
abcdefg
bcdefg
cdefg
defg
efg
fg
g

xyz
yz
z

C:\usr\c>

Download : sample-003.c ( SJIS 版 )

sample-003.c

/*
 * 2013/05/24 sample-003.c
 */

#include <stdio.h>
#include <string.h>

/*
 * 再帰呼出しを利用して、"Hello, World\n" を沢山出力する
 */


/*
 *	void rec_hello ( char *count )
 *		char *count	文字列を指定し、その長さで、繰り返えし回数の指数を指定
 *			与えられた文字列の長さを n とすると 2^n 回だけ出力する
 */

void rec_hello ( char *count ) {

	if ( !strcmp ( count, "" ) ) {		/* カラッポなら.. */
		printf ( "Hello, World\n" );	/* 一つだけ表示してみる */
	} else {							/* そうでなければ.. */
		rec_hello ( count + 1 );		/* 二倍にして再帰よびだし */
		rec_hello ( count + 1 );
	}
}

/*
 *	main
 */

int main ( void ) {

	rec_hello ( "****" );	/* 2^4 = 16 回出力 */

	/* 2^10 = 1024 だから、 "**********" を与えれば... */

	return 0;
}

sample-003.c の実行結果

C:\usr\c>sample-003
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
Hello, World
C:\usr\c>

Download : sample-004.c ( SJIS 版 )

sample-004.c

/*
 * 2013/05/24 sample-004.c
 */

#include <stdio.h>
#include <string.h>

/*
 *	フィボナッチ数の計算
 */

/*
 *	void fib ( char *n )
 *		char *n		n の長さで何番目の項かを表す
 *			n 番目のフィボナッチ数だけ '*' を表示する
 */

void fib ( char *n ) {

	if ( !strcmp ( n, "" ) ) {			/* カラッポ(0)なら.. */
		printf ( "*" );					/* 一つだけ : fib(0) = 1 だから */
	} else if ( !strcmp ( n, "*" ) ) {	/* 一つ(1)なら */
		printf ( "*" );					/* 一つだけ : fib(1) = 1 だから */
	} else {							/* そうでなければ.. */
		fib ( n + 1 );					/* fib ( n - 1 ) と */
		fib ( n + 2 );					/* fib ( n - 2 ) だけだす */
	}
}

/*
 *	main
 */

int main ( void ) {

  printf ( "fib 3 : " );
  fib ( "***" );
  printf ( "\n" );

  printf ( "fib 5 : " );
  fib ( "*****" ); 
  printf ( "\n" );

  return 0;
}

sample-004.c の実行結果

C:\usr\c>sample-004
fib 3 : ***
fib 5 : ********
C:\usr\c>

Download : sample-005.c ( SJIS 版 )

sample-005.c

/*
 * DATE sample-005.c
 */

#include <stdio.h>
#include <string.h>		/* strcmp に必要 */
#include "s_turtle.h"	/* 亀プログラムの場合に必要 */

/*
 * 亀プログラム
 */

/*
 * void jump_n ( char *n )
 *		char *n		足跡の長さを表す
 *			指定された長さだけ現在向いている方向に足跡を残こさず跳ねる
 */

void jump_n ( char *n ) {

	if ( !strcmp ( n, "" ) ) {
		/* n が空文字列 ("") なら何もしない */
	} else {
		s_turtle_jump();	/* とりあえず、一歩跳ねる */
		jump_n ( n + 1 );	/* 文字列を短くして、再帰呼出し */
	}
}	

/*
 *	void move_n ( char *n )
 *
 *		char *n		足跡の長さを表す
 *			指定された長さだけ現在向いている方向に足跡を残して歩く
 */

void move_n ( char *n ) {

	if ( !strcmp ( n, "" ) ) {
		/* n が空文字列 ("") なら何もしない */
	} else {
		s_turtle_move();	/* とりあえず、一歩歩く */
		move_n ( n + 1 );	/* 文字列を短くして、再帰呼出し */
	}
}

/*
 *	void turn_n ( char *n )
 *
 *		現在向いている方向から時計回りに n * 45 度向きを変える
 */

void turn_n ( char *n ) {

	if ( !strcmp ( n, "" ) ) {
		/* n が空文字列 ("") なら何もしない */
	} else {
		s_turtle_turn();	/* とりあえず、45 度向きをかえる */
		turn_n ( n + 1 );	/* 文字列を短くして、再帰呼出し */
	}

}

/*
 *	void turn_90 ( void )
 *
 *		現在向いている方向から時計回りに 90 度向きを
 *			進行方向の「右」に向きを変える
 */

void turn_90 ( void ) {

	turn_n ( "12" );
}

/*
 *	void turn_180 ( void )
 *
 *		現在向いている方向から時計回りに 180 度向きを
 *			進行方向の「後ろ」に向きを変える
 */

void turn_180(void) {

	turn_n ( "1234" );
}

/*
 *	void turn_270 ( void )
 *
 *		現在向いている方向から時計回りに 270 度向きを
 *			進行方向の「左」に向きを変える
 */

void turn_270 ( void ) {

	turn_n ( "123456" );
}

/*
 *	void move_n_and_turn ( char *n )
 *
 *		現在向いている方向から n 歩進んで右を向く
 *			四角形の一辺を書く
 */

void move_n_and_turn ( char *n ) {

	 move_n ( n );

	/* 向きを変える */

	turn_90();
}

/*
 *	void draw_n_sqare( char *n );
 *
 *		一辺が n の長さの四角形を書く
 */

void draw_n_sqare( char *n ) {

	 /* 「長さ n の辺を書いて右を向く」という事を 4 回繰り返す */

	move_n_and_turn(n);
	move_n_and_turn(n);
	move_n_and_turn(n);
	move_n_and_turn(n);
}

/*
 * main
 */

int main ( void ) {

	/*
	 * 最初は真中 (0,0) で上を向いている
	 */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	/* 次の二行は失くてもよいが.. *.

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	return 0;
}

sample-005.c の実行結果

C:\usr\c>sample-005
key = '
', x = 4, y = -13
C:\usr\c>

Download : sample-006.c ( SJIS 版 )

sample-006.c

/*
 * 2013/05/24 sample-006.c
 */

/*
 * 文字「a」を出力する
 */

#include <stdio.h>

void main ( void ) {

	putchar ( 'a' );	/* 「a」という「文字」を画面に出力 */

}

sample-006.c の実行結果

C:\usr\c>sample-006
aC:\usr\c>

Download : sample-007.c ( SJIS 版 )

sample-007.c

/*
 * 2013/05/24 sample-007.c
 */

/*
 * 文字版「Hello, World」
 */

#include <stdio.h>

void main ( void ) {

	putchar ( 'H' );
	putchar ( 'e' );
	putchar ( 'l' );
	putchar ( 'l' );
	putchar ( 'o' );
	putchar ( ',' );

	putchar ( ' ' );		/* 空白の出力 */

	putchar ( 'W' );
	putchar ( 'o' );
	putchar ( 'r' );
	putchar ( 'l' );
	putchar ( 'd' );

	putchar ( '\n' );		/* 改行の出力 */

}

sample-007.c の実行結果

C:\usr\c>sample-007
Hello, World
C:\usr\c>

Download : sample-008.c ( SJIS 版 )

sample-008.c

/*
 * 2013/05/24 sample-008.c
 */

/*
 * エスケープコード (「\」)の利用
 */

#include <stdio.h>

void main ( void ) {

	 printf ( "「\\」 を出すには 「'\\\\'」とする ==> " );
	 putchar ( '\\' );
	 printf ( "\n" );

	 printf ( "「'」を出すには 「'\\''」とする ==> " );
	 putchar ( '\'' );
	 printf ( "\n" );

	 printf ( "「ビープ音」を出すには 「'\\a'」とする ==> " );
	 putchar ( '\a' );			/* ここで文字は表示されず、音が出る */
	 printf ( "\n" );

	 printf ( "「\"」を出すには 「'\"'」だけでよい ==> " );
	 putchar ( '"' );
	 printf ( "\n" );

}

sample-008.c の実行結果

C:\usr\c>sample-008
「\」 を出すには 「'\\'」とする ==> \
「'」を出すには 「'\''」とする ==> '
「ビープ音」を出すには 「'\a'」とする ==> 
「"」を出すには 「'"'」だけでよい ==> "
C:\usr\c>

Download : sample-009.c ( SJIS 版 )

sample-009.c

/*
 * 2013/05/24 sample-009.c
 */

/*
 * 文字列
 */

#include <stdio.h>

void main ( void ) {

	printf ( "文字列\n" );	/* 「文字列」+「改行」が表示される */

}

sample-009.c の実行結果

C:\usr\c>sample-009
文字列
C:\usr\c>

Download : sample-010.c ( SJIS 版 )

sample-010.c

/*
 * 2013/05/24 sample-010.c
 */

/*
 * 文字列の中のエスケープコード
 */

#include <stdio.h>

void main ( void ) {

	printf ( "エスケープコード(「\\」)の扱いは、基本文字と同じ\n" );
	printf ( "「\\」と出力したければ、「\\\\」とかけばよい\n" );
	printf ( "文字では「'」を出すのに「\\'」としたが文字列では「'」で良い\n" );
	printf ( "その代わりに文字列では「\"」を出すのには「\\\"」する必要がある\n" );

}

sample-010.c の実行結果

C:\usr\c>sample-010
エスケープコード(「\」)の扱いは、基本文字と同じ
「\」と出力したければ、「\\」とかけばよい
文字では「'」を出すのに「\'」としたが文字列では「'」で良い
その代わりに文字列では「"」を出すのには「\"」する必要がある
C:\usr\c>

Download : sample-011.c ( SJIS 版 )

sample-011.c

/*
 * 2013/05/24 sample-011.c
 */

/*
 * 文字列の計算
 */

#include <stdio.h>

void main ( void ) {

	printf ( "\"abc\" に 1 を加えると \"bc\" と同じになる ==> " );
	printf ( "abc" + 1 );	/* 「bc」と表示される */
	printf ( "\n" );

	printf ( "*\"abc\" と頭に 「*」をつけると先頭の文字 ('a') になる ==> " );
	putchar ( *"abc\n" ); /* 文字列「abc」の先頭の文字「a」が表示される */
	printf ( "\n" );

	printf ( "\"abc\"[2] とお尻に 「[数値]」をつけると「『数値』番目の文字」になる ==> " );
	/* だだし、先頭(1文字目) は 0 番目であり 「n 番目」は 「n + 1 文字目」になる */

	putchar ( "abc\n"[2] ); /* 文字列「abc」の 2 番目(2+1文字目) の文字「c」が表示される */
	printf ( "\n" );

	if ( "abc"[0] == 'b' ) {
		printf ( "\"abc\"[0] と 'b' は等しいです\n" );
		printf ( "実際 \"abc\"[0] は " );
		putchar ( "abc"[0] );
		printf ( "でした\n" );
	} else {
		printf ( "\"abc\"[0] と 'b' は等しくないです\n" );
		printf ( "実際 \"abc\"[0] は " );
		putchar ( "abc"[0] );
		printf ( "でした\n" );
	}

	if ( "abc"[1] == 'b' ) {
		printf ( "\"abc\"[1] と 'b' は等しいです\n" );
		printf ( "実際 \"abc\"[1] は " );
		putchar ( "abc"[1] );
		printf ( "でした\n" );
	} else {
		printf ( "\"abc\"[1] と 'b' は等しくないです\n" );
		printf ( "実際 \"abc\"[1] は " );
		putchar ( "abc"[1] );
		printf ( "でした\n" );
	}

	if ( "abc"[3] == '\0' ) {
		printf ( "\"abc\"[3] は EOS (\\0) が入っています\n" );
	} else {
		printf ( "\"abc\"[3] は EOS (\\9) が入っていません\n" );
	}

}

sample-011.c の実行結果

C:\usr\c>sample-011
"abc" に 1 を加えると "bc" と同じになる ==> bc
*"abc" と頭に 「*」をつけると先頭の文字 ('a') になる ==> a
"abc"[2] とお尻に 「[数値]」をつけると「『数値』番目の文字」になる ==> c
"abc"[0] と 'b' は等しくないです
実際 "abc"[0] は aでした
"abc"[1] と 'b' は等しいです
実際 "abc"[1] は bでした
"abc"[3] は EOS (\0) が入っています
C:\usr\c>

Download : sample-012.c ( SJIS 版 )

sample-012.c

/*
 * 2013/05/24 sample-012.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 *	void do_turtle ( char *program )
 *		char *program -- 亀命令列
 */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == 'm' ) { /* move 命令 !! */
		s_turtle_move();
	} else if ( *program == 'j' ) { /* jump 命令 !! */
		s_turtle_jump();
	} else if ( *program == 't' ) { /* turn 命令 !! */
		s_turtle_turn();
	} else {				/* その他 */
		/* 何だか解らないので無視する */
	}

	/*
	 * 残りの処理
	 */

	do_turtle ( program + 1 );	/* 再帰呼び出し */

  }
}



/*
 *
 */

int main ( void ) {

  do_turtle ( "mmmmmmttmmmmmmttmmmmmmttmmmmmmtt" ); /* 四角を書く */

do_turtle ( "mmmmmmmmmmmmttmmmmmmmmmmmmttmmmmmmmmmmmmttmmmmmmmmmmmmtt" ); \
    /* 四角を書く */

  return 0;
}

sample-012.c の実行結果

C:\usr\c>sample-012
C:\usr\c>

Download : sample-013.c ( SJIS 版 )

sample-013.c

/*
 * 2013/05/24 sample-013.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}




/*
 *
 */

int main ( void ) {

  do_turtle ( "6m2t6m2t6m2t6m2t" ); /* 四角を書く */

  do_turtle ( "6m6m2t6m6m2t6m6m2t6m6m2t" ); /* 四角を書く */

  return 0;
}

sample-013.c の実行結果

C:\usr\c>sample-013
C:\usr\c>

Download : sample-014.c ( SJIS 版 )

sample-014.c

/*
 * 2013/05/24 sample-014.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * void triangl_n ( char *length )
 *	char *length -- 辺の長さ
 *		指定した長さの辺を持つ三角形を書く
 */

void triangl_n ( char *length ) {

		/* / */
	do_turtle ( "t" );
	do_n_turtle ( "m", length );

		/* \ */
	do_turtle ( "2t" );
	do_n_turtle ( "m", length );

		/* _ */
	do_turtle ( "3t" );
	do_n_turtle ( "m", length );
	do_n_turtle ( "m", length );

		/**/
	do_turtle ( "2t" );

}



/*
 *
 */

int main ( void ) {

	triangl_n ( "123456" );			/* 三角を書く */
	triangl_n ( "123456789012" );	/* 三角を書く */

  return 0;
}

sample-014.c の実行結果

C:\usr\c>sample-014
C:\usr\c>

Download : sample-015.c ( SJIS 版 )

sample-015.c

/*
 * 2013/05/24 sample-015.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * void triangl_n ( char *length )
 *	char *length -- 辺の長さ
 *		指定した長さの辺を持つ三角形を書く
 */

void triangl_n ( char *length ) {

		/* / */
	do_turtle ( "t" );
	do_n_turtle ( "m", length );

		/* \ */
	do_turtle ( "2t" );
	do_n_turtle ( "m", length );

		/* _ */
	do_turtle ( "3t" );
	do_n_turtle ( "m", length );
	do_n_turtle ( "m", length );

		/**/
	do_turtle ( "2t" );

}



/*
 *
 */

void pinwheel_sub ( char *length, char *times ) {

	 if ( *times == EOS ) {
	 } else {
			/* 羽の柄 */
		do_n_turtle ( "m", "**" );

			/* 羽は三角形で書く */
		triangl_n ( length );

			/* 元の位置に戻る */
		do_turtle ( "4t" );
		do_n_turtle ( "j", "**" );
		do_turtle ( "4t" );

			/* 向きをかえる */
		do_turtle ( "2t" );

		pinwheel_sub ( length, times + 1 );
	 }

}

	/* 風車 */
void pinwheel ( char *length ) {

	pinwheel_sub ( length, "****" );	/* 4 回羽をかけば.. */

}

/*
 *
 */

int main ( void ) {

	pinwheel ( "********" );

  return 0;
}

sample-015.c の実行結果

C:\usr\c>sample-015
C:\usr\c>

Download : sample-016.c ( SJIS 版 )

sample-016.c

/*
 * 2013/05/24 sample-016.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}



/*
 * oct_sub ( char *length, char *times )
 *	八角形の length の長さと同じ長さ辺を times の長さ回だけ表示する
 */

void oct_sub ( char *length, char *times ) {

	 if ( *times == EOS ) {
	 } else {
		do_n_m_turtle ( "m", length, "**" );
		do_turtle ( "t" );

		oct_sub ( length, times + 1 );
	 }

}

	/* 八角形 */

void oct ( char *length ) {

	do_turtle ( "t" );
	do_n_turtle ( "j", length );
	do_turtle ( "7t" );
	do_n_m_turtle ( "j", length, "**" );
	do_turtle ( "3t" );

	oct_sub ( length, "********" );

	do_turtle ( "t" );
	do_n_m_turtle ( "j", length, "**" );
	do_turtle ( "t" );
	do_n_turtle ( "j", length );
	do_turtle ( "3t" );

}

/*
 *
 */

int main ( void ) {

	oct ( "********" );

	oct ( "****************" );

  return 0;
}

sample-016.c の実行結果

C:\usr\c>sample-016
C:\usr\c>

Download : sample-017.c ( SJIS 版 )

sample-017.c

/*
 * 2013/05/24 sample-017.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}


/*
 *	do_2power_turtle ( char *program, char *power )
 *		program の先頭の命令を 2 の power の長さのべき乗回だけ実行する
 */

void do_2power_turtle ( char *program, char *power ) {

	if ( *power == EOS ) {				/* 2^0 = 1 なので.. */
		do_n_turtle ( program, "*" );	/* 1 回だけ行う */
	} else {				   			/* 2^{n+1} = 2 * 2^n = 2^n + 2^n */
		do_2power_turtle ( program, power + 1 );
		do_2power_turtle ( program, power + 1 );
	}
}


/*
 *
 */

int main ( void ) {

	do_turtle ( "2t" );
	do_2power_turtle ( "m", "****" );
	do_turtle ( "2t" );
	do_2power_turtle ( "m", "****" );

	do_turtle ( "6t" );
	do_2power_turtle ( "m", "***" );
	do_turtle ( "6t" );
	do_2power_turtle ( "m", "***" );

	do_turtle ( "2t" );
	do_2power_turtle ( "m", "**" );
	do_turtle ( "2t" );
	do_2power_turtle ( "m", "**" );

	do_turtle ( "6t" );
	do_2power_turtle ( "m", "*" );
	do_turtle ( "6t" );
	do_2power_turtle ( "m", "*" );


  return 0;
}

sample-017.c の実行結果

C:\usr\c>sample-017
C:\usr\c>

Download : sample-018.c ( SJIS 版 )

sample-018.c

/*
 * 2013/05/24 sample-018.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}


/*
 *	do_2power_turtle ( char *program, char *power )
 *		program の先頭の命令を 2 の power の長さのべき乗回だけ実行する
 */

void do_2power_turtle ( char *program, char *power ) {

	if ( *power == EOS ) {				/* 2^0 = 1 なので.. */
		do_n_turtle ( program, "*" );	/* 1 回だけ行う */
	} else {				   			/* 2^{n+1} = 2 * 2^n = 2^n + 2^n */
		do_2power_turtle ( program, power + 1 );
		do_2power_turtle ( program, power + 1 );
	}
}


/*
 *	rec_figure ( char *length )
 *		length の長さだけの深さをもつ再帰的な図形
 */

void rec_figure ( char *length ) {

	if ( *length == EOS ) {
	} else {
		do_2power_turtle ( "m", length );
		do_turtle ( "2t" );
		rec_figure ( length + 1 );
		do_turtle ( "2t" );
		rec_figure ( length + 1 );
		do_turtle ( "2t" );
		rec_figure ( length + 1 );
		do_turtle ( "6t" );
		do_2power_turtle ( "j", length );
		do_turtle ( "4t" );
	}

}

/*
 *
 */

int main ( void ) {

	do_turtle ( "4t" );
	do_2power_turtle ( "j", "******" );
	do_turtle ( "4t" );

	rec_figure ( "******" );

  return 0;
}

sample-018.c の実行結果

C:\usr\c>sample-018
C:\usr\c>

Download : sample-019.c ( SJIS 版 )

sample-019.c

/*
 * 2013/05/24 sample-019.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}


/*
 *	do_2power_turtle ( char *program, char *power )
 *		program の先頭の命令を 2 の power の長さのべき乗回だけ実行する
 */

void do_2power_turtle ( char *program, char *power ) {

	if ( *power == EOS ) {				/* 2^0 = 1 なので.. */
		do_n_turtle ( program, "*" );	/* 1 回だけ行う */
	} else {				   			/* 2^{n+1} = 2 * 2^n = 2^n + 2^n */
		do_2power_turtle ( program, power + 1 );
		do_2power_turtle ( program, power + 1 );
	}
}


/*
 *	koch ( char *dim, char *length )
 *		char *dim -- 次元
 *		char *length -- 辺の長さ
 *			コッホ曲線 (Koch curve) を書く 
 */

void koch ( char *deep, char *length ) {

	if ( *deep == EOS ) {
		do_n_turtle ( "m", length );
	} else {
		koch ( deep + 1, length );
		do_n_turtle ( "t", "1" );
		koch ( deep + 1, length );
		do_n_turtle ( "t", "123456" );
		koch ( deep + 1, length );
		do_n_turtle ( "t", "1" );
		koch ( deep + 1, length );
	}

}

/*
 *
 */

int main ( void ) {

	do_2power_turtle ( "j", "123456" );
	do_turtle ( "4t" );

	koch ( "123", "12" );

	return 0;
}

sample-019.c の実行結果

C:\usr\c>sample-019
C:\usr\c>

講議中に作成したプログラム

p-001.c (SJIS)

p-001.c

void recursive ( char *string ) {

	if ( !strcmp ( string, "" ) ) {	/* もし空文字列 ( "" ) ならば */
		printf ( "" );				/* これで御仕舞い */
	} else {						/* そうでなければ、 */
		printf ( string );
		recursive ( string + 1 );	/* 再帰呼び出しする */
									/* +1 を忘れると悲惨な事に.. */
  }
}

/*
  recursive ( "abc\n" );
		->
	string = "abc\n"
  recursive ( string );
		->
	string = "abc\n"

	if ( !strcmp ( string, "" ) ) {
		printf ( "" );
	} else {
		printf ( string );
		recursive ( string + 1 );
	  }

		->

	if ( !strcmp ( "abc\n", "" ) ) {
		printf ( "" );
	} else {
		printf ( "abc\n" );
		recursive ( "abc\n" + 1 );
	  }

		->

		printf ( "abc\n" );
		recursive ( "bc\n" );	<= **

		->

		printf ( "abc\n" );

		printf ( "bc\n" );		<= **
		recursive ( "c\n" );

		->

		printf ( "abc\n" );
		printf ( "bc\n" );
		printf ( "c\n" );
		recursive ( "\n" );

		->

		printf ( "abc\n" );
		printf ( "bc\n" );
		printf ( "c\n" );
		printf ( "\n" );

		recursive ( "" );

		->

		printf ( "abc\n" );
		printf ( "bc\n" );
		printf ( "c\n" );
		printf ( "\n" );

		recursive ( string ); string = ""

		->

		printf ( "abc\n" );
		printf ( "bc\n" );
		printf ( "c\n" );
		printf ( "\n" );

		string = ""

	if ( !strcmp ( string, "" ) ) {
		printf ( "" );
	} else {
		printf ( string );
		recursive ( string + 1 );
	  }

		->

		printf ( "abc\n" );
		printf ( "bc\n" );
		printf ( "c\n" );
		printf ( "\n" );

	if ( !strcmp ( "", "" ) ) {
		printf ( "" );
	} else {
		printf ( "" );
		recursive ( "" + 1 );
	  }

		->

		printf ( "abc\n" );
		printf ( "bc\n" );
		printf ( "c\n" );
		printf ( "\n" );
		printf ( "" );

		->
-- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< --
		abc
		bc
		c

-- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< --

同様に、

		recursive ( "12345\n" );
		->
-- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< --
		12345
		1234
		123
		12
		1

-- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< --

となる事が予想できる。	
	   
*/

p-002.c (SJIS)

p-002.c

/*
 * 2013/05/24 sample-004.c
 */

#include <stdio.h>
#include <string.h>

/*
 *	フィボナッチ数の計算
 */

/*
 *	void fib ( char *n )
 *		char *n		n の長さで何番目の項かを表す
 *			n 番目のフィボナッチ数だけ '*' を表示する
 */

/*
 * 「*」の並びの個数を「数」と思っている
 * 		引数も、「*」の並びで、「数」を表現しているし、
 * 		結果も、「*」の並びで、「数」を表現している。
 */

void fib ( char *n ) {

	if ( !strcmp ( n, "" ) ) {			/* カラッポ(0)なら.. */
		printf ( "*" );					/* 一つだけ : fib(0) = 1 だから */
	} else if ( !strcmp ( n, "*" ) ) {	/* 一つ(1)なら */
		printf ( "*" );					/* 一つだけ : fib(1) = 1 だから */
	} else {							/* そうでなければ.. */
		fib ( n + 1 );					/* fib ( n - 1 ) と */
		fib ( n + 2 );					/* fib ( n - 2 ) だけだす */
	}
}

/*
 *	main
 */

int main ( void ) {

  printf ( "fib 3 : " );
  fib ( "***" );
  printf ( "\n" );

  printf ( "fib 5 : " );
  fib ( "*****" ); 
  printf ( "\n" );

  return 0;
}

/*
	フィボナッチ数列 fib(n)

fib(n) の定義
	fib(0) = 1
	fib(1) = 1
	fib(n+2) = fib(n+1) + fib(n)	( n >= 0  の時 )

	fib(2)	= fib(0+2)				(n=0)
			= fib(0+1)+fib(0)
			= fib(1)+fib(0)
			= 1+1
			= 2

	fib(3)	= fib(1+2)			(n=1)
			= fib(1+1)+fib(1)
			= fib(2)+fib(1)
			= 2 + 1
			= 3 ... ***


	fib(4)	= fib(2+2)			(n=2)
			= fib(2+1)+fib(2)
			= fib(3)+fib(2)
			= 3 + 2
			= 5

	fib(5)	= fib(3+2)			(n=3)
			= fib(3+1)+fib(3)
			= fib(4)+fib(3)
			= 5 + 3
			= 8 .. ********
	1,1,2,3,5,8

===========================

	fib(3) 計算

	fib("***");		このプログラムでは、* 個数が数なので、3 を *** で表す
		->
	fib(n);	n="***"
		->
	n="***"

	if ( !strcmp ( n, "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( n, "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( n + 1 );
		fib ( n + 2 );
	}

		->

	if ( !strcmp ( "***", "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( "***", "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( "***" + 1 );
		fib ( "***" + 2 );
	}

		->
	
		fib ( "***" + 1 );
		fib ( "***" + 2 );

		->
	
		fib ( "**" );		"***" -> "**" ( 3 -> 2 / 1 引いた )
		fib ( "*" );		"***" -> "*"  ( 3 -> 1 / 2 引いた )
				 fib("***") -> fib("**") fib("*") ( fib(3) -> fib(2), fib(1) );

		->
		fib ( n ); n = "**"
		fib ( "*" );
		->
		n = "**"

	if ( !strcmp ( n, "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( n, "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( n + 1 );
		fib ( n + 2 );
	}


		fib ( "*" );

		->

	if ( !strcmp ( "**", "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( "**", "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( "**" + 1 );
		fib ( "**" + 2 );
	}

	fib ( "*" );

		->

		fib ( "**" + 1 );
		fib ( "**" + 2 );

    	fib ( "*" );

		->

		fib ( "*" );		fib("**") -> fib("*") fib("") // fib(2) -> fib(1),fib0)
		fib ( "" );

    	fib ( "*" );
		->
		fib ( n ); n = "*"

		fib ( "" );
    	fib ( "*" );

		->
		n = "*"

	if ( !strcmp ( n, "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( n, "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( n + 1 );
		fib ( n + 2 );
	}

		fib ( "" );
    	fib ( "*" );

		->

	if ( !strcmp ( "*", "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( "*", "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( "*" + 1 );
		fib ( "*" + 2 );
	}

		fib ( "" );
    	fib ( "*" );

		->

		printf ( "*" );			fib("*") -> "*"

		fib ( "" );
    	fib ( "*" );

		->

		printf ( "*" );			fib("*") -> "*"
		fib ( "" );
		printf ( "*" );			fib("*") -> "*"

		->

		printf ( "*" );			fib("*") -> "*"
		fib ( "" );
		printf ( "*" );			fib("*") -> "*"
		->
		printf ( "*" );			fib("*") -> "*"
		fib ( n ); n = "";
		printf ( "*" );			fib("*") -> "*"
		->
		printf ( "*" );			fib("*") -> "*"

		n = ""
	if ( !strcmp ( n, "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( n, "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( n + 1 );
		fib ( n + 2 );
	}

		printf ( "*" );			fib("*") -> "*"

		->

		printf ( "*" );			fib("*") -> "*"

	if ( !strcmp ( "", "" ) ) {
		printf ( "*" );	
	} else if ( !strcmp ( "", "*" ) ) {
		printf ( "*" );	
	} else {
		fib ( "" + 1 );
		fib ( "" + 2 );
	}
		printf ( "*" );			fib("*") -> "*"

		->

		printf ( "*" );			fib("*") -> "*"		fib(1)=1
		printf ( "*" );			fib("") -> "*"		fib(0)=1
		printf ( "*" );			fib("*") -> "*"		fib(1)=1

		->
		***

*/

p-003.c (SJIS)

p-003.c

#include <stdio.h>

void main ( void ) {

    putchar ( 'H' );	/* <= 「H」という一文字を putchar で出力している */
	putchar ( 'e' );
	putchar ( 'l' );
	putchar ( 'l' );
	putchar ( 'o' );
	putchar ( ',' );

	putchar ( ' ' );		/* 空白の出力 */

	putchar ( 'W' );
	putchar ( 'o' );
	putchar ( 'r' );
	putchar ( 'l' );
	putchar ( 'd' );

	putchar ( '\n' );		/* 改行の出力 \n はこれで改行一文字を表す */

}

p-004.c (SJIS)

p-004.c

/*
 * 例題 : 文字列「abc」の後に改行を出力するプログラム
 */

#include <stdio.h>

int main(void) {

  putchar ( 'a' );	/* 文字「a」を出力 */
  putchar ( 'b' );	/* 同様に文字「b」を出力 */
  putchar ( 'c' );	/* ここまでで、画面には「abc」が表示される */

  putchar ( '\n' );	/* これで、「改行」が付け加わる */

  return 0;
}

p-005.c (SJIS)

p-005.c

#include <stdio.h>

int main(void){

  printf ( "「" );

  putchar ( "abc"[1] );	/* { 'a', 'b', 'c', '\0' }[1] -> 'b' */

  printf ( "」\n" );

  /*
	結果は「b」になる
  */

  return 0;
}

p-006.c (SJIS)

p-006.c

#include <stdio.h>

int main(void){

  printf ( "「" );

  putchar ( "abc"[2] );	/* { 'a', 'b', 'c', '\0' }[2] -> 'c' */
  putchar ( "abc"[1] );	/* { 'a', 'b', 'c', '\0' }[1] -> 'b' */
  putchar ( "abc"[0] );	/* { 'a', 'b', 'c', '\0' }[0] -> 'a' */

  printf ( "」\n" );

  /*
	結果は「cba」になる
  */

  return 0;
}

p-007.c (SJIS)

p-007.c

#include <stdio.h>

int main(void){

  printf ( "「" );

  putchar ( *"abc" );	/* *"abc" == "abc"[0] */
  					/* 「文字列の前に 『*』をつけると先頭の文字が取り出せる */
  					/* *( "abc" + k ) == "abc"[k] */
  					/* *( "abc" + 1 ) == * ( "bc" ) == 'b' == "abc" [1] */

					/* 「*""」== 「 *{ '\0' }」 == '\0' */

  printf ( "」\n" );

  /*
	結果は「cba」になる
  */

  return 0;
}

p-008.c (SJIS)

p-008.c

#include <stdio.h>
#include <string.h>

void myprintf ( char *string ) {

  if ( !strcmp ( string, "" ) ) {	/* 空文字列なので、何もしない.. */
	/* 何もしない.. */
  } else {
	putchar ( *string );		/* 先頭の文字を一文字出力し.. */
	myprintf ( string + 1 );	/* 残りは、再帰呼出しで.. */
  }

}

int main(void) {

  myprintf ( "abc" );		/* 「abc」と画面に出す */

  myprintf ( "123\n" );		/* 「123」と改行を画面に出す */

  /* 結果的に、画面には「abc123」と改行が表示される.. (ようにしたい..) */

}

p-009.c (SJIS)

p-009.c

#include <stdio.h>

/*
 * strcmp を使わないので、#include <string.h> が不要になった..
 */

#define	EOS	'\0'			/* 以下、「EOS」と出たら、「'\0'」と思う */

void myprintf ( char *string ) {

  if ( *string == EOS ) {	/* 先頭が EOS なら、空文字列なので、何もしない.. */
	/*
	 !strcmp ( string, "" ) と *string == EOS は同じ意味
	C 言語では、「二つの物 (A,B) が等しい事を判定する」ために「A == B」を使う
	*/
	/* 何もしない.. */
  } else {
	putchar ( *string );		/* 先頭の文字を一文字出力し.. */
	myprintf ( string + 1 );	/* 残りは、再帰呼出しで.. */
  }

}

int main(void) {

  myprintf ( "abc" );		/* 「abc」と画面に出す */

  myprintf ( "123\n" );		/* 「123」と改行を画面に出す */

  /* 結果的に、画面には「abc123」と改行が表示される.. (ようにしたい..) */

}

p-010.c (SJIS)

p-010.c

/*
 * 2013/05/24 sample-012.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"

/*
 *
 */

#define	EOS	'\0'	/* EOS を '\0' と定義している .. */

/*
 * 亀プログラム
 *
 *	void do_turtle ( char *program )
 *		char *program -- 亀命令列
 */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* program が空文字列の時.. */
	/* 何もしない */
  } else {						/* 空文字列でなかった.. */

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 *		先頭の文字が
	 *			m -> 亀の移動命令
	 *			j -> 亀のハネる命令
	 *			t -> 亀の向きの変更命令
	 */

	if ( *program == 'm' ) { /* move 命令 !! */
		s_turtle_move();
	} else if ( *program == 'j' ) { /* jump 命令 !! */
		s_turtle_jump();
	} else if ( *program == 't' ) { /* turn 命令 !! */
		s_turtle_turn();
	} else {				/* その他 */
		/* 何だか解らないので無視する */
	}

	/*
	 * 残りの処理
	 */

	do_turtle ( program + 1 );	/* 再帰呼び出し */

  }
}



/*
 *
 */

int main ( void ) {

  do_turtle ( "mmmmmmttmmmmmmttmmmmmmttmmmmmmtt" ); /* 四角を書く */

  /*
	s_turtle_move();
	s_turtle_move();
	.. 6 回
	s_turtle_turn();
	s_turtle_turn();

	それを更に、四回

  */


  do_turtle ( "jjjjjj" );

  do_turtle ( "mmmmmmmmmttmmmmmmmmmttmmmmmmmmmttmmmmmmmmmtt" ); /* 四角を書く */

  return 0;
}

/*

void do_turtle ( char *program ) {

  if ( *program == EOS ) {} else {
	if ( *program == 'm' ) {	s_turtle_move();	} else 
	if ( *program == 'j' ) {	s_turtle_jump();	} else
	 if ( *program == 't' ) {	s_turtle_turn();	} else {}
 	do_turtle ( program + 1 );	/* 再帰呼び出し */
  }
}

	文字列の中の文字を、あたかも命令かのように実行できる

 */

p-011.c (SJIS)

p-011.c

/*
 * 2013/05/24 sample-013.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"

/*
 *
 */

#define	EOS	'\0'

/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '0' ) {				/* 「数字」の処理 */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}




/*
 *
 */

int main ( void ) {

  do_turtle ( "6m2t6m2t6m2t6m2t" ); /* 四角を書く */

  do_turtle ( "6m6m2t6m6m2t6m6m2t6m6m2t" ); /* 四角を書く */

  return 0;
}

/*
	do_turtle ( "m" );
		-> s_turtle_move() を一度だけ呼び出す ( program-012.c と同じ )

	do_turtle ( "5m" );
		program = "5m"
			do_n_turtle ( "m", "12345" );
				-> s_turtle_move() が 5 回呼ばれる
			do_turtle ( "" );
				-> 残りの部分を実行するが、空文字列なので、何もしない

*/

本日の課題

課題 20130524-01 : 自分のローマ字の名前を putchar で書きなさい

Download : 20130524-01.c ( SJIS 版 )

20130524-01.c

/*
 * CDATE FILENAME
 *
 *	putchar で自分の名前(ローマ字)を出力する
 */

#include <stdio.h>

/*
 *	main
 */

int main( void )
{

	/*
     * putchar を使って、自分名前を表示する
	 * 以下は "Kurino Shun-ichi" の場合
     */

	 putchar ( 'K' );
	 putchar ( 'u' );
	 putchar ( 'r' );
	 putchar ( 'i' );
	 putchar ( 'n' );
	 putchar ( 'o' );

	 putchar ( ' ' );

	 putchar ( 'S' );
	 putchar ( 'h' );
	 putchar ( 'u' );
	 putchar ( 'n' );
	 putchar ( '-' );
	 putchar ( 'c' );
	 putchar ( 'h' );
	 putchar ( 'i' );

	 putchar ( '\n' );

	 return 0;
}

20130524-01.c の実行結果

C:\usr\c\> 20130524-01-QQQQ
Kurino Shun-chi
C:\usr\c\>

ソフトウェア概論A/B (2013/05/24)Ver. 1.0

目次