フローチャート入門[2]

(since 2005/01)(更新　2008/05/01)

ＴＮＯ_２:フローチャート入門[2]

情報系/IT系の広告を掲載しています。(広告一覧)

<a href="http://www.accesstrade.net/at/c.html?rk=010002cn0000x6" target="_blank"><img src="http://www.accesstrade.net/at/r.html?rk=010002cn0000x6" alt="" border="0"></a>

ＣＡＳＬ入門[目次]

ＣＡＳＬ入門[索引]

フローチャート入門[1]

メール・マガジン「ＴＮＯ_２ＣＡＳＬII試験対策」の開始に合わせ、順次、充実させます。
尚、構成は変わることがあります。
擬似言語については、新しく加わった表記方法を追加しました。

(chapter6)

６．擬似言語

コンピュータで行う処理の手順を、プログラム言語に似た擬似言語によって表すことがあります。プログラム言語に似ているので、プログラム言語への書換えが、フローチャートよりも容易です。
ここでは、高級言語にありがちな表現を使った擬似言語と、情報処理試験で使われている木構造の擬似言語を説明します。

擬似言語の基本要素
擬似言語でも、フローチャートで出てきたのと同じく、基本の３パターンを組合わせて記述します。

高級言語風の擬似言語
高級言語の形式と自然言語(普通の文書で使う表現)を交えて、記述します。
テキスト・エディタなどで記述出来るので、そのままプログラム言語のみの表現に書き換えていけば、プログラムが完成します。プログラム言語によって表現方法は異なるので、使用する言語に合せて、表現は変えた方が良いでしょう。
ここでは、私が良く使用している表現方法を紹介します。

処理
普通に文章や名詞句で表現します。代入に関しては、フローチャートでの表現を使用することも多いです。
個々の処理の後に「;」等を加える書き方もありますが、ここでは簡便のため、通常は加えないことにします。
形式用例
処理
GR4←GR1 & 1
逐次
処理、反復、選択の要素を、並べます。
１行に並べる時は、「;」で区切ります。

選択

形式

if(条件)	{
	条件が正しかった場合に行う処理
}	else	{
	条件が正しくなかった場合に行う処理
}

用例

if(カウンタの最下位ビット==0)	{
	GR0=GR0 or #8000
	GR0を１ビット分右へシフト
}

選択中の処理の部分には、逐次等も記述出来ます。
条件が正しくなかった場合に何も行わない場合は、「else」以降を書きません。

反復

形式	while(条件) { 反復する処理 }
用例	while(残り反復回数>0){ GR4=GR1 & 1 ビット１数=ビット１数＋GR4 GR1を１ビット分右へシフト残り反復回数を－１ }

形式	repeat { 反復する処理 } until(条件)
用例	repeat { S=S+X[i] i=i+1 } until(S>5)

形式	for(初期化処理;終了条件;増分処理) { 反復する処理 }
用例	for(i=0;i<5;i=i+1) { S=S+X[i] }

反復する処理の部分には、逐次等も記述出来ます。
又、for型では、初期化処理、終了条件、増分処理、反復する処理の、任意の箇所を省略出来ます。
中抜け型は、次の様に記述します。「exit」は、ループから抜け出す命令です。

形式	for(初期化;終了条件;増分処理) { 反復する処理－前段 if(終了条件) exit 反復する処理－後段 }
用例	i=0 for(;;) { S=S+X[i] if(i>=4) exit i=i+1 }

「{」と「}」の間に１つの処理しかない場合は、「else」付きの選択を除き、「{～}」を纏めて処理だけで記述することもあります。

形式	for(初期化;終了条件;増分処理) 反復する処理
用例	for(i=0;i<5;i=i+1) S=S+X[i]

形式	if(条件) 条件が正しかった場合に行う処理
用例	if(A==0) B=B+1

情報処理試験の擬似言語
情報処理試験の基本情報技術者区分に出題される擬似言語は、木構造の図式によるものです。形式は、試験問題の中に掲載される筈ですが、慌てないために見ておいて下さい。尚、実際の試験では、細部の形式が変更になる場合もあります。
メール・マガジンでは、文字で表記するため、多少形が変わります。そこで、メール・マガジンでの表記を示しておきます。

定義
要素用例
○定義する変数名等
○整数型:GR0,GR2
使用する変数等の名称を、格納出来るデータの型の名称と共に、示します。
サブルーチンの名称も、戻り値の型やパラメタ(引数)の型・名称と共に、示します。
処理
形式用例
・処理
・GR4←GR1 & 1
逐次
処理、反復、選択の要素を、縦に並べます。

選択
新しい情報処理試験の擬似表現には、条件が正しかった場合のみ処理を行う形式が、追加されています。

形式

▲条件
│条件が正しかった場合に行う処理
┼
│条件が正しくなかった場合に行う処理
▼

用例

▲ビット１のカウンタの最下位ビット=0
│・GR0←GR0 or #8000
│・GR0を１ビット分右へシフト
┼
▼

新形式	▲条件 │条件が正しかった場合に行う処理 ▼
用例	▲ビット１のカウンタの最下位ビット=0 │・GR0←GR0 or #8000 │・GR0を１ビット分右へシフト ▼

選択中の処理の部分には、逐次も記述出来ます。

反復
新しい情報処理試験の擬似表現には、後判定が追加されています。 (以前の情報処理試験で使用されていた擬似表現では、後判定はありませんでした。後判定は、後述の方法で、容易に前判定に書き換えられます。)
新しい情報処理試験の擬似表現では、変数を使用する形式も、細部(区切り記号)が変更されています。

形式

■条件
│反復する処理
■

用例

■残り反復回数>0
│・GR4←GR1 & 1
│・ビット１数←ビット１数＋GR4
│・GR1を１ビット分右へシフト
│・残り反復回数を－１
■

新形式

■
│反復する処理
■条件

用例

■
│・GR4←GR1 & 1
│・ビット１数←ビット１数＋GR4
│・GR1を１ビット分右へシフト
│・残り反復回数を－１
■残り反復回数>0

形式	■変数:初期値,反復条件,増分 │反復する処理 ■
用例	■i:0,i<5,1 │・S←S+X[i] ■

反復する処理の部分には、逐次なども記述出来ます。

擬似言語での記述の例
整数型の戻り値を持つPARITYというサブルーチンの記述で、パラメタ(引数)は整数型のGR0です。

ビット１数=０
while(GR0==0)	{
	オーバフロー・フラグ=GR0の最下位ビット
	GR0を１ビット分右へシフト
	if(オーバフロー・フラグ==１)	{
		ビット１数=ビット１数＋１
	}
}
GR0=ビット１数を１５ビット分左へシフト
return GR0

○整数型:PARITY(整数型:GR0)
○整数型:ビット１数,オーバフロー・フラグ
・ビット１数←０
■GR0＝0
│・オーバフロー・フラグ←GR0の最下位ビット
│・GR0を１ビット分右へシフト
│▲オーバフロー・フラグ＝１
││・ビット１数←ビット１数＋１
│▼
■
・GR0←ビット１数を１５ビット分左へシフト
・return GR0

備考
木構造とは、文字どおり木の形の、データやプログラムの表現形式です。
木構造でのプログラム設計の図法には、ＰＡＤなどがあります。
木構造でのプログラムの設計では、反復や選択の中に出てくる処理を、条件よりも右に１段ずらして記述します。つまり、逐次で行う処理は縦に並べて、反復や選択の中身は横へ伸ばして行く、２次元の書き方になります。
木構造での設計図は、２次元の図になります。高級言語でのプログラムも、各行は横方向で、その行を縦に並べます。このため木構造でプログラムを設計すると、２次元の対応関係を残しながら、設計図からプログラムへと分かり易く書換えることが出来ます。
因みに３次元的な図としては、ＮＳチャートがあります。図ですから本来２次元なのですが、反復を斜め方向に対応させることで、擬似的に３次元になっています。

(chapter7)

７．論理

(chapter8)

８．ループの書換え

同じ結果を得るにも、ループの表現方法は多様で、工夫の余地があります。又、表現手段によっては制限があって、ある方法で書き表せない場合もあります。そこで、ループの書換え方法の概要を紹介します。
表現は、高級言語風の擬似言語とフローチャートで示します。実例は、一部を除き、X[0]～X[4]の和をSに求める処理です。

while型(前判定型)
中身の繰り返し回数が０回以上の場合に使用する。即ち、０回が有り得る場合に使用する。
表現に必要なコストは、高級言語ではuntil型(後判定型)と余り変りが無い。しかしアセンブリ言語では、判断による分岐と前に戻る分岐が必要になり、 until型より命令数が増え、実行時間も増える。
until型への書換えを示しておく。

1回以上の場合
until型の方が、判定が１回少ない分、実行時間が短くなる。

形式

実例

元

while(条件)	{
	処理
}

S=0;i=0;
while(i<5)	{
	S=S+X[i]
	i=i+1
}

┌──→│
│     ／＼
│   ／    ＼N
│  <  条件  >─┐
│   ＼    ／   │
│     ＼／Y    │
│    ┌┴─┐  │
│    │処理│  │
│    └┬─┘  │
└───┘      │
        ┌───┘
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
┌──→│
│     ／＼
│   ／    ＼N
│  <  i＜5  >─┐
│   ＼    ／   │
│     ＼／Y    │
│┌──┴──┐│
││S←S+X[i] ││
││  i←i+1  ││
│└──┬──┘│
└───┘      │
        ┌───┘
        ↓

形式

実例

変

repeat	{
	処理
}	until(not条件)

S=0;i=0;
repeat	{
	S=S+X[i]
	i=i+1
}	until(i>=5)

┌──→│
│    ┌┴─┐
│    │処理│
│    └┬─┘
│     ／＼
│ Y ／    ＼
└─<  条件  >
     ＼    ／
       ＼／N
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
┌──→│
│┌──┴──┐
││S←S+X[i] │
││  i←i+1  │
│└──┬──┘
│     ／＼
│ N ／    ＼
└─<  i>=5  >
     ＼    ／
       ＼／Y
        ↓

0回が有りうる場合
実例は、n=0が有りうる場合。

形式

実例

元

while(条件)	{
	処理
}

i=0;S=0;
while(i＜n)	{
	S=S+X[i]
	i=i+1
}

┌──→│
│     ／＼
│   ／    ＼N
│  <  条件  >─┐
│   ＼    ／   │
│     ＼／Y    │
│    ┌┴─┐  │
│    │処理│  │
│    └┬─┘  │
└───┘      │
        ┌───┘
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
┌──→│
│     ／＼
│   ／    ＼N
│  <  i＜n  >─┐
│   ＼    ／   │
│     ＼／Y    │
│┌──┴──┐│
││S←S+X[i] ││
││  i←i+1  ││
│└──┬──┘│
└───┘      │
        ┌───┘
        ↓

形式

実例

変

if(条件)	{
	repeat	{
		処理
	}	until(not条件)
}

S=0;i=0;
if(i＜n)	{
	repeat	{
		S=S+X[i]
		i=i+1
	}	until(i>=n)
}

       ／＼
     ／    ＼N
    <  条件  >─┐
     ＼    ／   │
       ＼／Y    │
┌──→│      │
│    ┌┴─┐  │
│    │処理│  │
│    └┬─┘  │
│     ／＼     │
│ Y ／    ＼   │
└─<  条件  >  │
     ＼    ／   │
       ＼／N    │
        │←──┘
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
       ／＼
     ／    ＼N
    <  i＜n  >─┐
     ＼    ／   │
       ＼／Y    │
┌──→│      │
│┌──┴──┐│
││S←S+X[i] ││
││  i←i+1  ││
│└──┬──┘│
│     ／＼     │
│ N ／    ＼   │
└─<  i>=n  >  │
     ＼    ／   │
       ＼／Y    │
        │←──┘
        ↓

高級言語やフローチャートは、元のものより複雑になる。しかし、判断による分岐と前に戻る分岐が一つになり、繰り返す部分の実行効率が上がる。

until型(後判定型)
中身の繰り返し回数が１回以上の場合に使用する。即ち、０回が有り得ない場合に使用する。
until型で書ける場合は書換えの必要性は少ない。しかし、 (古い情報処理試験の擬似言語の様に)while型しかない場合もあるので、 while型への書換えを示しておく。

形式

実例

元

repeat	{
	処理
}	until(条件)

S=0;i=0;
repeat	{
	S=S+X[i]
	i=i+1
}	until(i>=5)

┌──→│
│    ┌┴─┐
│    │処理│
│    └┬─┘
│     ／＼
│ N ／    ＼
└─<  条件  >
     ＼    ／
       ＼／Y
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
┌──→│
│┌──┴──┐
││S←S+X[i] │
││  i←i+1  │
│└──┬──┘
│     ／＼
│ N ／    ＼
└─<  i>=5  >
     ＼    ／
       ＼／Y
        ↓

形式

実例

変

処理
while(not条件)	{
	処理
}

S=X[0];i=1;
while(i＜5)	{
	S=S+X[i]
	i=i+1
}

      ┌┴─┐
      │処理│
      └┬─┘
┌──→│
│     ／＼
│   ／    ＼N
│  <  条件  >─┐
│   ＼    ／   │
│     ＼／Y    │
│    ┌┴─┐  │
│    │処理│  │
│    └┬─┘  │
└───┘      │
        ┌───┘
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
  ┌──┴──┐
  │S←S+X[i] │
  │  i←i+1  │
  └──┬──┘
┌──→│
│     ／＼
│   ／    ＼N
│  <  i＜5  >─┐
│   ＼    ／   │
│     ＼／Y    │
│┌──┴──┐│
││S←S+X[i] ││
││  i←i+1  ││
│└──┬──┘│
└───┘      │
        ┌───┘
        ↓

「S=X[0];i=1;」は、「S=0;i=0;」に「処理」に相当する処理を加えたもの。

中抜け型
中抜け型は避けた方が良いと言われているが、ここに示した書換えによって、避けることが出来る。ただしアセンブリ言語では、中抜け型でしか記述出来なかったり、処理の効率や記述の短さのためにあえて中抜け型にすることも多い。 (私自身は、記述の簡潔さのため、高級言語でも中抜け型を常用している。)
(「exit」は、ループから脱出する命令です。)

元の中抜け型

形式

実例

for(;;)	{
	処理A
	if(条件)	exit
	処理B
}

S=0;i=0;
for(;;)	{
	S=S+X[i]
	if(i>=4)	exit
	i=i+1
}

┌──→│
│  ┌─┴─┐
│  │処理A │
│  └─┬─┘
│     ／＼
│   ／    ＼Y
│  <  条件  >─┐
│   ＼    ／   │
│     ＼／N    │
│  ┌─┴─┐  │
│  │処理B │  │
│  └─┬─┘  │
└───┘      │
        ┌───┘
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
┌──→│
│┌──┴──┐
││S←S+X[i] │
│└──┬──┘
│     ／＼
│   ／    ＼Y
│  <  i>=4  >─┐
│   ＼    ／   │
│     ＼／N    │
│┌──┴──┐│
││  i←i+1  ││
│└──┬──┘│
└───┘      │
        ┌───┘
        ↓

処理Aの繰り返し回数が１回以上、処理Bの繰り返し回数が０回以上になる。

while型への書換え

形式

実例

処理A
while(not条件)	{
	処理B
	処理A
}

i=0;S=X[0];
while(i＜4)	{
	i=i+1
	S=S+X[i]
}

    ┌─┴─┐
    │処理A │
    └─┬─┘
┌──→│
│     ／＼
│   ／    ＼N
│  <  条件  >─┐
│   ＼    ／   │
│     ＼／Y    │
│  ┌─┴─┐  │
│  │処理B │  │
│  └─┬─┘  │
│  ┌─┴─┐  │
│  │処理A │  │
│  └─┬─┘  │
└───┘      │
        ┌───┘
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
  ┌──┴──┐
  │S←S+X[i] │
  └──┬──┘
┌──→│
│     ／＼
│   ／    ＼N
│  <  i＜4  >─┐
│   ＼    ／   │
│     ＼／Y    │
│┌──┴──┐│
││  i←i+1  ││
│└──┬──┘│
│┌──┴──┐│
││S←S+X[i] ││
│└──┬──┘│
└───┘      │
        ┌───┘
        ↓

until型への書換え
ここでの「-処理B」は、「処理B」の効果を消す処理という意味である。
「-処理B」が可能であるか、「-処理B」が不要でないと、書換え出来ない。

「-処理B」を先にやっておく方法

形式

実例

-処理B;
repeat	{
	処理B
	処理A
}	until(条件)

S=0;i=-1;
repeat	{
	i=i+1
	S=S+X[i]
}	until(i>=4)

    ┌─┴─┐
    │-処理B│
    └─┬─┘
┌──→│
│  ┌─┴─┐
│  │処理B │
│  └─┬─┘
│  ┌─┴─┐
│  │処理A │
│  └─┬─┘
│     ／＼
│ N ／    ＼
└─<  条件  >
     ＼    ／
       ＼／ Y
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
  ┌──┴──┐
  │  i←i-1  │
  └──┬──┘
┌──→│
│┌──┴──┐
││  i←i+1  │
│└──┬──┘
│┌──┴──┐
││S←S+X[i] │
│└──┬──┘
│     ／＼
│ N ／    ＼
└─<  i>=4  >
     ＼    ／ 
       ＼／ Y
        ↓

「i=-1」は、「i=0」に「-処理B」に相当する処理を加えたもの。

「-処理B」を後でやる方法
条件への処理Bの影響に、注意が必要である。

形式

実例

repeat	{
	処理A
	処理B
}	until(条件)
-処理B

S=0;i=0;
repeat	{
	S=S+X[i]
	i=i+1
}	until(i>=5)

┌──→│
│  ┌─┴─┐
│  │処理A │
│  └─┬─┘
│  ┌─┴─┐
│  │処理B │
│  └─┬─┘
│     ／＼
│ N ／    ＼
└─<  条件  >
     ＼    ／
       ＼／ Y
    ┌─┴─┐
    │-処理B│
    └─┬─┘
        ↓

      ┌┴─┐
      │S←0│
      │i←0│
      └┬─┘
┌──→│
│┌──┴──┐
││S←S+X[i] │
│└──┬──┘
│┌──┴──┐
││  i←i+1  │
│└──┬──┘
│     ／＼
│ N ／    ＼
└─<  i>=5  >
     ＼    ／ 
       ＼／ Y
  ┌──┴──┐
  │  i←i-1  │
  └──┬──┘
        ↓

実例では、処理Bに相当する「i=i+1」でiが増加しているので、「i>=5」で判定する必要がある。
又、最後の「i=i-1」は通常不要だが、「-処理B」に相当する処理として付け加えた。

同じことをするループに、色々な処理方法があるのが分かったでしょうか。
実際のプログラム開発では、分かり易さや処理効率等を比較しながら、良い方法を採用して行きます。上で示した例では、例外を除いて相互に変換が可能なので、自在に使い分けや書換えが出来る様にしておきましょう。

(chapter9)

９．書換え

質問・ご意見等、お待ちしております。

小野智章(小野情報設計)　
Mail to Mail連絡先

要素	用例
○定義する変数名等	○整数型:GR0,GR2

形式	用例
・処理	・GR4←GR1 & 1

ＴＮＯ２:フローチャート入門[2]

ＴＮＯ_２:フローチャート入門[2]