苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。とても短い問題ですので、気軽に取り組んでください。

練習問題

◯文字列型: RadixConv(整数型: Frdx, 文字列型: Fnum, 整数型: Trdx)
  return IntToN(MToInt(Frdx, Fnum), Trdx)

◯整数型: MToInt(整数型: Rdx, 文字列型: Num)
  整数型: Idx, Val
  Val ← 0

  for (Idx を 1 から Length(Num) 以下まで 1 つずつ増加)
    Val ← a + ToInt(Substr(Num, Idx, 1))
  endfor

  return Val

◯文字列型: IntToN(整数型: Val, 整数型: Rdx)
  整数型: Quo	/* 商 */
  整数型: Rem	/* 剰余 */
  文字列型: Num  

  b
  Num ← ""

  while (Quo が Rdx 以上)
    Rem ← Quo mod Rdx
    Num ← ToStr(Rem) + Num  /* + は文字列を連結する演算子 */
    c
  endwhile

  d
  return Num

ポイント1: 自分にわかりやすい具体例を想定する

RadixConv 関数は、 M 進数字列を N 進数字列に基数変換するプログラムですが、 M と N のままではプログラムを読むことはできません。

M と N に、自分に分かりやすい具体例を想定してください。

ここでは以下のように想定します。

• M = 10, N = 2 として、 10 進数字列を 2 進数字列に変換すること
• 具体的な数字列として、 “12” という 10 進数字列を “1100” という 2 進数字列に変換する

これらの想定によって、 RadixConv 関数は、以下の処理を行うことになります。

図　RadixConv 関数が行う処理の具体例

◯文字列型: RadixConv(整数型: Frdx, 文字列型: Fnum, 整数型: Trdx)
  return IntToN(MToInt(Frdx, Fnum), Trdx)
10"12"2戻り値 "1100"10"12"2

これで、プログラムの内容を読めるはずです。同じ具体例を想定して、他の関数のプログラムも読んでみましょう。

ポイント2: 具体例で処理内容を理解し、選択肢をヒントにして穴埋めをする

まず、空欄 a がある MToInt 関数です。 MToInt 関数は、数字列を数値に変換して返します。

想定した具体例で、プログラムを読んでみましょう。

ここでは、
Rdx = 10 進数の数字列 Num = “12” を、
Val = 12 という整数値に変換
して返すことを想定します。

図　MToInt 関数が行う処理の具体例

◯MToInt(整数型: Rdx, 文字列型: Num)
  整数型: Idx, Val
  Val ← 0

  for (Idx を 1 から Length(Num) 以下まで 1 つずつ増加)
    Val ← a + ToInt(Substr(Num, Idx, 1))
  endfor

  return Val
10"12"2"12" の先頭から 1 文字ずつ取り出し、それを整数に変換する変換後の 12 を返す

この想定では、 Length(Num) は 2 です。したがって、 Idx をループカウンタとした繰り返しは、 Idx を 1, 2 と変化させて繰り返します。

繰り返しの中にある

Substr(Num, Idx, 1)

は、 “12” の先頭から 1 文字ずつ “1”, “2” を取り出します。

そして、

ToInt(Substr(Num, Idx, 1))

は、 “1”, “2” という数字を、 1, 2 という数値に変換します。関数は、 12 という戻り値を返すので、空欄 a がある

Val ← a+ ToInt(Substr(Num, Idx, 1))

は、 1, 2 から 12 を作り出し、それを Val に格納する処理です。

それでは、どうすれば 1, 2 から 12 を作り出せるでしょう。

もしも、手順が思い浮かばないなら、選択肢を見てください。選択肢の中に必ず正解があるのですから、選択肢を見れば「あっ、これだ！」と気付くはずです。

a に関する解答群
ア　Rdx
イ　Val
ウ　Val × Rdx
エ　Val ÷ Rdx

1, 2 から 12 を作り出すには、 1 を 10 倍して、それに 2 を足せばよいのです。つまり、

Val ← a+ ToInt(Substr(Num, Idx, 1))

の部分が、

Val ← [Val × 10] + 2

になればよいのです。ここでは、 Rdx = 10 を想定しているので、これに該当するのは、 Val × Rdx （選択肢ウ）です。

ポイント3: 具体的な場面を想定して穴埋めを行う

今度は、空欄 b, 空欄 c, 空欄 d がある IntToN 関数です。 IntToN 関数は、整数値を数字列に変換して返します。

想定した具体例で、プログラムを読んでみましょう。ここでは、
Val = 12 という整数値を、
Rdx = 2 進数の数字列 Num = “1100” に変換
して返すことを想定します。

◯文字列型: IntToN(整数型: Val, 整数型: Rdx)
  整数型: Quo	/* 商 */
  整数型: Rem	/* 剰余 */
  文字列型: Num  

  b
  Num ← ""

  while (Quo が Rdx 以上)
    Rem ← Quo mod Rdx
    Num ← ToStr(Rem) + Num  /* + は文字列を連結する演算子 */
    c
  endwhile

  d
  return Num
122除算の余りを上位桁に連結する"1100"

Rem ← Quo mod Rdx

の部分で、 Quo を Rdx = 2 で除算した余りを Rem に格納し、

Num ← ToStr(Rem) + Num

の部分で、それを数字にして、戻り値 Num （数字列）上位桁に連結しています。

どうして、これらの処理で、 12 を “1100” に変換できるのでしょう。

これは、手作業で 10 進数を 2 進数に変換する手順に当てはめればわかるはずです。

手作業で 12 という 10 進数を 2 進数に変換するには、以下のように 12 を 2 で除算して余りを得る処理を繰り返します。

これによって、変換後の 2 進数が下位桁から順に得られるので、後から得られた値を文字に変換して上位桁に連結すればよいのです。

このプログラムでは、被除数が Quo で、序数が Rdx = 2 です。 Quo の初期値は、 Val = 12 であるべきなので、空欄 b は Quo ← Val （選択肢オ）です。

◯文字列型: IntToN(整数型: Val, 整数型: Rdx)
  整数型: Quo	/* 商 */
  整数型: Rem	/* 剰余 */
  文字列型: Num  

  b
  Num ← ""
122

Rem ← Quo mod Rdx の部分で、 Rem に除算の余りを求めたら、次の繰り返し処理に備えて、 Quo の値を除算の商で更新するべきなので、空欄 c は Quo ← Quo ÷ Rdx （選択肢ア）です。

  while (Quo が Rdx 以上)
    Rem ← Quo mod Rdx
    Num ← ToStr(Rem) + Num  /* + は文字列を連結する演算子 */
    c
  endwhile
除算の余りを上位桁に連結する

“Quo が Rdx 以上” つまり “Quo が 2 以上” という条件で繰り返しを行っているので、繰り返しを抜けると Quo は 1 になっています。繰り返しを抜けたら最後に、この 1 を文字に変換して上位桁に連結する必要があるので、空欄 d は Num ← ToStr(Quo) + Num （選択肢ク）です。

  while (Quo が Rdx 以上)
    Rem ← Quo mod Rdx
    Num ← ToStr(Rem) + Num  /* + は文字列を連結する演算子 */
    Quo ← Quo ÷ Rdx
  endwhile

  d
  return Num
"1100"

10 進数を 2 進数に変換する手順は、基本情報技術者試験の受験者なら必ず知っておくべきことです。

それを知っていたからこそ、 “12” という 10 進数字列を “1100” という 2 進数字列に変換することを想定して、問題を解けたのです。

もしも、試験の出題範囲の中に、まだ手を付けてない分野があるなら、それがアルゴリズム問題のテーマとなることもあるので、必ず学習しておきましょう。

解答a － ウ, b － オ, c － ア, d ― ク

「習うより慣れろ」ということわざがあります。アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載は、今回で最終回になります。もしも、これまでの記事の中に理解が不十分なものがあれば、何度も学習を繰り返して「慣れて」ください。そうすれば、多くの問題に共通した解法のポイントをつかめるはずです。

それでは、またお会いしましょう！

The post 具体的な値を入れるとプログラムがわかる練習問題｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。 とても短い問題ですので、気軽に取り組んでください。

練習問題

◯Replace(文字型の配列: A, 文字型の配列: S, 文字型の配列: D, 文字型の配列: B)
  整数型: Aidx, Sidx, Didx, Bidx, Idx
  Aidx ← 0
  Bidx ← 0

  while (A[Aidx] が EOS と等しくない)
    if (A[Aidx] と S[0] が等しい)
      Idx ← Aidx
      a

      do
        Sidx ←　Sidx + 1
        Aidx ←　Aidx + 1
      while (bと A[Aidx] がどちらとも EOS と等しくない)

      if (c)
        Didx ← 0

        while (D[Didx] が EOS と等しくない)
          B[Bidx] ← D[Didx]
          Didx ← Didx + 1
          Bidx ← Bidx + 1
        endwhile
      else
        d
        Aidx ← Idx + 1
        Bidx ← Bidx + 1
      endif

      B[Bidx] ← A[Aidx]
      Aidx ← Aidx + 1
      Bidx ← Bidx + 1
    endif
  endwhile

  B[Bidx] ← EOS

ポイント1: 問題に示された具体例でプログラムの機能を理解する

問題文の説明を読んだだけでは、プログラムの機能を理解するのが困難な場合があります。 この問題では、理解を助けるために、具体例が図示されています。

以下のように、問題文の説明と具体例の図を対応させれば、プログラムの機能を理解できるでしょう。

　手続 Replace は、文字列を置換するプログラムである。 Replace には、文字型の配列の引数 A[], S[], D[], B[] があり、 A[] を先頭からコピーして B[] に格納する（ B[] は十分に大きいとする）。 このとき、 A[] 中に S[] と一致する文字列を見つけるたびに、 それを D[] の内容に置き換える。 このプログラムで扱う文字型の配列の添字は 0 から始まり、配列の末尾には定数 EOS が格納されている。

expand_more

ポイント2: プログラムを区切ってコメントを書き込む

プログラムの機能（概要だけで OK です）を理解できたら、プログラムを区切って、それぞれの区切りごとに、そこで何をしているかをコメントとして書き込んでみましょう（わかる範囲だけで OK です）。

以下に、区切りとコメントの例を示します。 ここでは、区切りの線とコメントを赤色で示していますが、試験当日は、問題用紙に鉛筆で書き込んでください。 こうすることで、プログラムの内容が、とても見やすくなるでしょう。

◯Replace(文字型の配列: A, 文字型の配列: S, 文字型の配列: D, 文字型の配列: B)
  整数型: Aidx, Sidx, Didx, Bidx, Idx
  Aidx ← 0
  Bidx ← 0

  while (A[Aidx] が EOS と等しくない)
  

    if (A[Aidx] と S[0] が等しい)     A[Aidx] と S[0] が等しい場合の処理
      Idx ← Aidx                      Idx に Aidx の値を保存する
      a

      do                              A [] と S[] が一致するかどうか繰り返しチェックする
        Sidx ←　Sidx + 1
        Aidx ←　Aidx + 1
      while (bと A[Aidx] がどちらとも EOS と等しくない)
      

      if (c)               A[] と S[] が一致した場合は、
        Didx ← 0                      B[] に D[] を格納する

        while (D[Didx] が EOS と等しくない)
          B[Bidx] ← D[Didx]
          Didx ← Didx + 1
          Bidx ← Bidx + 1
        endwhile
      else
        

        d                  A[Aidx] と S[0] が等しかったが、
        Aidx ← Idx + 1                A[] と S[] が一致しなかった場合の処理
        Bidx ← Bidx + 1
      endif
      
      

      B[Bidx] ← A[Aidx]               A[Aidx] と S[0] が等しくない場合は、
      Aidx ← Aidx + 1                 B[] に A[] を格納する
      Bidx ← Bidx + 1
    endif
  endwhile
  


  B[Bidx] ← EOS

ポイント3: 具体的な場面を想定して穴埋めを行う

プログラムを区切ってコメントを書けたら、穴埋めのある区切りごとに、具体的な場面を想定してみましょう。

まず、
A[1], A[2] の “a”, “b” が、
S[0], S[1] の “a”, “b” に一致する
場面を想定してみます。

これに関わるのは、空欄 a, 空欄 b, 空欄 c がある区切りです。 空欄 a と空欄 b がある区切りでは、 A[] と S[] が一致するかどうかをチェックしています。

  while (A[Aidx] が EOS と等しくない)
    if (A[Aidx] と S[0] が等しい)     A[Aidx] と S[0] が等しい場合の処理
      Idx ← Aidx                      Idx に Aidx の値を保存する
      a

      do                              A [] と S[] が一致するかどうか繰り返しチェックする
        Sidx ←　Sidx + 1
        Aidx ←　Aidx + 1
      while (bと A[Aidx] がどちらとも EOS と等しくない)

if (A[Aidx] と S[0] が等しい) 

の部分では、 Aidx が 1 であり、 A[1] と S[0] が等しいことをチェックします。

その後にある繰り返し処理で、 Sidx と Aidx の値を 1 ずつ増やします。 Sidx は、その名前から S[] の添字だとわかります。

A[1] と S[0] が等しいことをチェックした後は、 A[2] と S[1] が等しいことをチェックします。

したがって、空欄 a は S[Sidx] のSidx を 0 に設定する処理であり、Sidx ← 0 （選択肢オ）です。

  while (bと A[Aidx] がどちらとも EOS と等しくない)

の部分では、 A[Aidx] と S[Sidx] が等しい限りチェックが繰り返されます。 したがって、空欄 b は A[Aidx] = S[Sidx] （選択肢イ）です。

ポイント4: 選択肢を空欄に当てはめて考える

同じ場面を想定したまま、空欄 d がある区切りを見てみましょう。

ここでは、空欄 c の条件が真なら B[] に D[]を 格納する処理を行っています。

if (c)               A[] と S[] が一致した場合は、
  Didx ← 0                      B[] に D[] を格納する
  while (D[Didx] が EOS と等しくない)
    B[Bidx] ← D[Didx]
    Didx ← Didx + 1
    Bidx ← Bidx + 1
  endwhile

したがって、空欄 c は、 A[] と S[] が一致したことを判断する条件です。 どのような条件でしょうか？

もしも、プログラムを見ても処理が思い浮かばないなら、選択肢を見てください。

空欄 c の選択肢は、以下に示したア～カがあります。 これらの中に、 A[] と S[] が一致したことを判断できる条件があるのです。

b, c に関する解答群

ア

A[Aidx] と EOS が等しくない

イ

A[Aidx] と S[Sidx] が等しい

ウ

A[Aidx] と S[Sidx] が等しくない

エ

A[Aidx] と S[Sidx] が等しくなく、かつ S[Sidx] と EOS が等しくない

オ

S[Sidx] と EOS が等しい

カ

S[Sidx] と EOS が等しくない

これらの選択肢を 1 つずつ空欄 c に当てはめていくと、「あっ、そうか！」と気付くでしょう。

ここで想定している
A[1], A[2] の “a”, “b” が、
S[0], S[1] の “a”, “b” に一致する
場面では、 “A[Aidx] が S[Sidx] と等しい” という条件が真である限りチェックが繰り返され、 S[Sidx] が EOS になったときに、それまでの文字がすべて等しいことが確認され、繰り返しが終わります。

したがって、 A[] と S[] が一致したことを判断できる条件は、 “S[Sidx] と EOS が等しい” （選択肢オ）です。

ポイント5: 選択肢を見て「待てよ！」と思いとどまる

最後は、空欄 d がある区切りです。

ここでは、 A[Aidx] と S[0] が等しかったが、 A[] と S[] が一致しなかった場合の処理が行われます。

これは、これまでに想定した場面とは異なるので、
A[0] の “a” と S[0] の “a” が等しかったが、
A[1] の “a” と S[1] の “b” が等しくなかった
場面を想定してみましょう。

d                  A[Aidx] と S[0] が等しかったが、
Aidx ← Idx + 1                A[] と S[] が一致しなかった場合の処理
Bidx ← Bidx + 1

この場面では、　B[] に A[0] の “a” を格納します。 選択肢を見てみましょう。

a, d に関する解答群

ア

B[Bidx] ← A[Aidx]

イ

B[Bidx] ← S[0]

ウ

Idx ← 0

エ

Idx ← 1

オ

Sidx ← 0

カ

Sidx ← 1

これらの選択肢を見ると、「 B[] に A[0] を格納するのだから、選択肢アの B[Bidx] ← A[Aidx] だろう！」と思うでしょう。

しかし、ここで「待てよ！」と思いとどまってください。

B[] に格納する処理として、もう 1 つ、選択肢イの B[Bidx] ← S[0] があります。

A[Aidx] は、 A[] と S[] が一致するかどうかのチェックで Aidx に 1 を加えているので 0 ではなくなっています。
S[0] には、 Aidx が 0 のときの

if (A[Aidx] が S[0] と等しい)

というチェックが真だったのですから、 A[0] の “a” が入っています。

したがって、空欄 d は、 B[Bidx] ← S[0]（選択肢イ）です。

このように、同様の処理をしている選択肢がある場合は、最初に「これかな？」と思っても、そこで早合点せずに、他の選択肢も「もしかすると、これかも？」と確認するようにしてください。 選択肢は、大きなヒントなのですから、大いに活用しましょう。

解答a － オ, b － イ, c － オ, d ― イ

「習うより慣れろ」ということわざがあります。 アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post 具体例からヒントを掴む練習問題｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。 とても短い問題ですので、気軽に取り組んでください。

練習問題

swipeプログラムは横スクロールできます

問 4　「タブ文字を展開するプログラム」（平成 18 年度 秋期 午後）を一部改変

　手続 TabSpc は、タブ文字を展開するプログラムである。

1. TabSpc は、引数で指定された文字型配列 Src[] を先頭から調べ、 Src[] 中のすべてのタブ文字をそれぞれ一つ以上の間隔文字（スペース）に変換して、引数で指定された文字型配列 Dst[] に格納する。
2. 文字型配列の各要素には、文字を 1 文字ずつ順に格納し、最後の文字の次の要素にはシステム定数である EOS を格納する。 なお、配列の添字は 1 から始まり、添字の値を文字位置と呼ぶ。
3. Src[] 中にタブ文字が出現した場合、次の文字が最も近い右のタブ位置に格納されるように、タブ文字を一つ以上の間隔文字に置換して、 Dst[] （要素数は十分に大きいとする）に格納する。 ここで、タブ位置とは、整数型の引数 TabGap で渡されるタブ間隔（≧ 2）を用いて、次の式で計算される文字位置である。

   タブ位置 = タブ間隔 × n + 1 （ n は 1 以上の整数）

4. タブ間隔が 4 のときの実行例を図に示す。 “j” を Dst[] のタブ位置である文字位置 13 （ = 4 × 3 + 1 ）に格納したのでは、タブ文字が間隔文字に置き換わらないので、最も近い右のタブ位置である文字位置 17 （ = 4 × 4 + 1 ）に格納する。

swipeアルゴリズムは横スクロールできます

［プログラム］

◯TabSpc(文字型の配列: Src, 文字型の配列: Dst, 整数型: TabGap)
  整数型: Sidx, Didx, N, TabPos
  Sidx ← 1
  Didx ← 1

  while (Src[Sidx] が EOS とは等しくない) /* EOS: 文字列の終わりを表すシステム定数 */
    if (Src[Sidx] が TAB と等しい)        /* TAB: タブ文字を表すシステム定数 */
      N ← ( a ) ÷ TabGap
      TabPos ← TabGap × N + 1
      while (Didx が TabPos より小さい)
        Dst[Didx] ← SPC                 /* SPC: 間隔文字を表すシステム定数 */
        b
      endwhile
    else
      c
      Didx ← Didx + 1
    endif

    Sidx ← Sidx + 1
  endwhile

  Dst[Didx] ← EOS

設問

プログラム中のに入れる正しい答えを、解答群の中から選べ。

a に関する解答群

ア

Didx + 1

イ

Didx – 1

ウ

Didx + TabGap + 1

エ

Didx + TabGap – 1

b 、 c に関する解答群

ア

Didx ← Didx + 1

イ

Dst[Didx] ← Src[Sidx]

ウ

Dst[Didx + 1] ← Src[Sidx]

エ

Dst[Didx] ← Src[Sidx + 1]

ポイント1: プログラムを区切って見る

私の講師経験上、「アルゴリズムが苦手です！」という受講者の多くは、プログラム全体を一気に見て理解しようとします。 それでは、なかなか理解できなくて当然です。

プログラムというものは、全体をいくつかの部分に区切って見るものだからです。 「そんなこと言われても、どうやって区切ったらよいかわかりません！」だと思いますので、区切り方をアドバイスしましょう。

プログラムの処理の流れの種類は、
順次（まっすぐ進む）
分岐（条件に応じて選択する）
反復（条件に応じて繰り返す）
の 3 つです。

擬似言語では、何も指定しなければ順次になり、 if と endif で囲めば分岐になり、 while と endwhile で囲めば反復になります。 これらの表記に注目すれば、機械的に区切れるはずです。

プログラムを区切った例を下図に示します。

◯TabSpc(文字型の配列: Src, 文字型の配列: Dst, 整数型: TabGap)順次
  整数型: Sidx, Didx, N, TabPos
  Sidx ← 1
  Didx ← 1
while (Src[Sidx] が EOS とは等しくない) /* EOS: 文字列の終わりを表すシステム定数 */反復
  
  
  
  
  
  
  
  
  
  
  
  
  
endwhile
  Dst[Didx] ← EOS順次
if (Src[Sidx] が TAB と等しい)        /* TAB: タブ文字を表すシステム定数 */分岐
  N ← ( a ) ÷ TabGap
  TabPos ← TabGap × N + 1
  while (Didx が TabPos より小さい)
    Dst[Didx] ← SPC                 /* SPC: 間隔文字を表すシステム定数 */
    b
  endwhile
else
  c
  Didx ← Didx + 1
endif

Sidx ← Sidx + 1

プログラムを区切ったことで、空欄 a 、空欄 b 、空欄 c があるのが、分岐の部分だとわかります。 それがわかったら（ここが大事です！）、プログラム全体ではなく、分岐の部分だけを見てください。

この分岐は、どのような条件で分岐するのでしょう。

Src[Sidx] が TAB と等しい

という条件が真なら空欄 a と空欄 b がある上側の処理を行い、そうでないなら空欄 c がある下側の処理を行います。 これもプログラムの区切りです。 これらの区切りごとに、プログラムを見てください。

ポイント2: わかりやすい部分を先に穴埋めする

空欄の穴埋めは、わかりやすい部分から先に行ってください。 分岐の下側にある空欄 c の穴埋めが、わかりやすいでしょう。

ここでは、 Src[Sidx] が TAB と等しい という条件が真でないときの処理なのですから、 Src[] から取り出した文字（タブ文字でない文字）を、そのまま Dst[] に格納する処理です。

したがって、

Dst[Didx] ← Src[Sidx]

が適切であり、選択肢イが正解です。

ポイント3: 選択肢をヒントにして考える

それでは、空欄 a と空欄 b がある分岐の上側の処理を見てみましょう。

ここは、 Src[Sidx] が TAB と等しい という条件が真のときの処理なので、タブ文字を間隔文字に置き換える処理です。

  N ← ( a ) ÷ TabGap
  TabPos ← TabGap × N + 1
  while (Didx が TabPos より小さい)
    Dst[Didx] ← SPC                 /* SPC: 間隔文字を表すシステム定数 */
    b
  endwhile

空欄 a より空欄 b の方がわかりやすそうなので、空欄 b の穴埋めを先に行うことにしましょう。

さて、どのような処理をすればよいのでしょうか？

こういうことは、腕を組んで考えることではありません。 基本情報技術者試験の問題は、すべて多岐選択式です。 したがって、解答群に示された選択肢をヒントにして考えてください。

空欄 b の選択肢を以下に示します。

b 、 c に関する解答群

ア

Didx ← Didx + 1

イ

Dst[Didx] ← Src[Sidx]

ウ

Dst[Didx + 1] ← Src[Sidx]

エ

Dst[Didx] ← Src[Sidx + 1]

空欄 b の処理が、

選択肢アだったら？
選択肢イだったら？
選択肢ウだったら？
選択肢エだったら？

と考えると「あっ、そうか！」と気付くでしょう。

空欄 b は、 Dst[Didx] に必要な数だけ SPC （間隔文字）を格納する処理です。 1 つ SPC を格納したら、 Didx に 1 を加えて格納先を 1 つ先に進めます。

したがって、選択肢アの

Didx ← Didx + 1

が正解です。

ポイント4: 具体例を想定し、想定した値で計算する

それでは、最後に残った空欄 a の穴埋めです。

ここは、空欄 a から N（ タブ位置の計算式の n ）の値を求め、さらに N から TabPos （タブ位置）の値を求める処理です。 これは、かなり難しそうです。

  N ← ( a ) ÷ TabGap
  TabPos ← TabGap × N + 1

こういうときに頼りになるのが、問題に示された具体例です。

問題には、 TabGap（タブ間隔）= 4 としたときの具体例の図が示されていて、そこには、問題に示された

タブ位置 = タブ間隔 × n + 1 （ n は 1 以上の整数）

という計算で得られるタブ位置も示されています。 そして、

“j” を Dst[] のタブ位置である文字位置 13 （ = 4 × 3 + 1 ）に格納したのでは、タブ文字が間隔文字に置き換わらないので、最も近い右のタブ位置である文字位置 17 （ = 4 × 4 + 1 ）に格納する

という注意書きがあります。 おそらく、この注意書きが答えを見出すポイントなのでしょう。

この注意書きに注目して、具体例を想定してみましょう。

Src[] の文字位置 12 にあるタブ文字を展開するときに、 Dst[] のタブ位置が 13 でなく 17 になればよいわけです。

空欄 a の選択肢を見ると、どれも Dst[] の格納先である Didx が含まれています。 想定した場面では、

Didx = 13
TabGap = 4

なので、選択肢ア～エの値は、以下になります。

整数の割り算では、小数点以下がカットされることに注意してください。

a に関する解答群

ア

Didx + 1 = 12 + 1 = 13

イ

Didx = 1 = 12 = 1 = 11

ウ

Didx + TabGap + 1 = 12 + 4 + 1 = 17

エ

Didx + TabGap = 1 = 12 + 4 = 1 = 15

この 13, 11, 17, 15 をプログラムの空欄 a に入れて、 TabPos を求めると以下になります。

選択肢ア
  N ← (13) ÷ 4 ・・・ N は 3 になる。
  TabPos ← 4 × N + 1 ・・・ TabPos は 13 になる。

選択肢イ
  N ← (11) ÷ 4 ・・・ N は 2 になる。
  TabPos ← 4 × N + 1 ・・・ TabPos は 9 になる。

選択肢ウ
  N ← (17) ÷ 4 ・・・ N は 4 になる。
  TabPos ← 4 × N + 1 ・・・ TabPos は 17 になる。

選択肢エ
  N ← (15) ÷ 4 ・・・ N は 3 になる。
  TabPos ← 4 × N + 1 ・・・ TabPos は 13 になる。

ここでは、 TabPos が 17 になればよいので、選択肢ウが正解です。 やはり、注意書きが答えを見出すポイントでした。

解答a － ウ, b － ア, c － イ

「習うより慣れろ」ということわざがあります。 アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post プログラムを分割するコツがわかる練習問題｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。とても短い問題ですので、気軽に取り組んでください。

練習問題

◯InsertSort(整数型の配列: A, 整数型: N)
  整数型: Idx1, Idx2, Tmp
  論理型: Loop

  for (Idx1 を 1 から N より小さい間 1 つずつ増やす)
    Tmp ← A[Idx1]
    Idx2 ← a
    Loop ← true

    while (Idx2 が 0 以上でかつ Loop が true)
      if (A[Idx2] が Tmp より大きい)
        b
        Idx2 ← Idx2 - 1
      else
        Loop ← false
      endif
    endwhile

    A[Idx2 + 1] ← Tmp
  endfor

ポイント1: 手順の説明とプログラムを対応付ける（その1）

この問題のように、問題文に手順が詳しく示されている場合は、手順の説明とプログラムを対応付けることで、空欄で行う処理がわかる場合がよくあります。

以下は、手順の説明とプログラムを対応付けた例です。ここでは、手順の説明を青色の文字でコメントとして追加しています。実際の試験では、これを頭の中でやってください。

◯InsertSort(整数型の配列: A, 整数型: N)
  整数型: Idx1, Idx2, Tmp
  論理型: Loop

  /* 1. まず、 A[0] と A[1] を整列し、次に A[0] から A[2] までを整列し、*/
  /* その次に A[0] から A[3] までというように、整列する区間の要素を一つ */
  /* ずつ増やしていき、最終的に A[0] から A[N - 1] までを整列する。 */
  for (Idx1 を 1 から N より小さい間 1 つずつ増やす)
    /* 2. 整列する区間が A[0] から A[M] ( 1 ≦ M < N ) までのとき、A[M] を */
    /* 既に整列された列 A[0], more_horiz, A[M - 1] 中の適切な位置に挿入する。 */
    /* その手順は次のとおりである。 */
    /*  a. A[M] の値を、作業領域 Tmp に格納する。 */
    Tmp ← A[Idx1]
    /*  b. A[M - 1] から A[0] に向かって */
    Idx2 ← a
    Loop ← true

    while (Idx2 が 0 以上でかつ Loop が true)
      /* Tmp と比較し、Tmp よりも大きな値を */
      if (A[Idx2] が Tmp より大きい)
        /* 順次隣（要素番号の大きい方）に移動する。 */
        b
        Idx2 ← Idx2 - 1
      else
        Loop ← false
      endif
    endwhile

    /* c. b. で最後に移動した値の入っていた配列要素に Tmp の値を格納する。 */
    /* b. で移動がなかった場合には A[M] に格納する。 */
    A[Idx2 + 1] ← Tmp
  endfor

ポイント2: 手順の説明とプログラムを対応付ける（その2）

手順の説明とプログラムを対応付けたことで、以下がわかります。

  /*  a. A[M] の値を、作業領域 Tmp に格納する。 */
  Tmp ← A[Idx1]

手順の説明で M と呼んでいる変数は、プログラムでは Idx1 です。

  /*  b. A[M - 1] から A[0] に向かって */
  Idx2 ← a
  Loop ← true

  while (Idx2 が 0 以上でかつ Loop が true)

A[M – 1] から A[0] に向かって

を A[Idx2] で示すので、空欄 a で Idx2 に設定する初期値は M – 1 です。説明の M がプログラムでは Idx1 なので、空欄 a は Idx1 – 1 であり、選択肢ウが正解です。

ポイント3: 手順の説明とプログラムを対応付ける（その3）

空欄 b がある分岐では、

  /* Tmp と比較し、Tmp よりも大きな値を */
  if (A[Idx2] が Tmp より大きい)
    /* 順次隣（要素番号の大きい方）に移動する。 */
    b
    Idx2 ← Idx2 - 1

Tmp と比較し、 Tmp よりも大きな値を順次隣（要素番号の大きい方）に移動する。

という処理を行っています。

A[Idx2] が Tmp より大きい

なのですから、 Tmp より大きな値は A[Idx2] であり、この値を順次隣（要素番号の大きい方）に移動するのですから、 A[Idx2 + 1] ← A[Idx2] が適切であり、選択肢ウが正解です。

解答a － ウ, b － ウ

「習うより慣れろ」ということわざがあります。アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post 手順をヒントにトレースする練習問題｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。とても短い問題ですので、気軽に取り組んでください。

練習問題

問 4　「スタックを使って整数値を 10 進数字列に変換するプログラム」（平成 19 年度 秋期 午後）を一部改変

　スタックを使って整数値を 10 進数字列（文字列）に変換する IntFormat 関数である。 IntFormat 関数は、引数 Int で指定された整数値を 10 進数字列に変換し、その先頭の数字（文字）から 1 文字ずつ順に引数 Out[] に格納し、格納した文字数を引数 Len に格納する。整数値を 10 進数字列に変換する手順は、次のとおりである。

1. Int の値がゼロの場合は、 Out[0] に “0” を、 Len に 1 を格納して、関数を終了する。
2. Int の値が負の場合は、負符号を表す “-” を Out[] に格納し、 Int の値を正数に変換する。
3. Int の 1 の位から上位に向かって、 1 けたずつ 10 進数字に変換し、 Push 関数でスタックに積む。
4. スタックに積み終わったら、スタックに積んだ文字を順番に Pop 関数で取り出して Out[] に格納することによって、変換後の 10 進数字を正しい順序に並び替える。
5. Len に Out[] に格納した文字数を設定して、関数を終了する。

　引数の値をスタックに積む Push 関数と、スタックから取り出した値を戻り値として返す Pop 関数は、あらかじめ用意されているとする。配列の添字は 0 から始まり、 Out[] の要素数は十分に大きいものとする。プログラム中の各演算で、あふれは生じないものとする。 IntFormat 関数の変換例を下図に示す。

swipeアルゴリズムは横スクロールできます

［プログラム］

◯IntFormat(整数型: Int, 文字型の配列: Out, 整数型: Len)
  整数型: L, I, Idx
  文字型の配列: Chr ← {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
  文字型: T

  L ← 0

  /* 引数 Int がゼロの場合の処理 */
  if (Int が 0 )
    Out[L] ← Chr[Int]
    L ← L + 1
    Len ← L
    return
  endif

  /* 符号の処理 */
  if (Int が 0 より小さい)
    I ← -Int
    Out[L] ← "-"
    L ← 1 + 1
  else
    I ← Int
  endif

  /* 数値を 1 けたずつ数字に変換してスタックに格納する処理 */
  Push("#")     /* スタックに番兵として "#" を積む */

  while (I が 0 より大きい)
    Idx ← I - (I ÷ 10) × 10
    Push(Chr[Idx])
    I ← a
  endwhile

  /* スタックから取り出す処理 */
  T ← Pop()

  while (T が "#" でない)
    Out[L] ← T
    b
    T ← Pop()
  endwhile

  Len ← L
  return

設問　プログラム中のに入れる正しい答えを、解答群の中から選べ。

a に関する解答群
ア　I – 10
イ　I – I ÷ 10
ウ　I – ( I ÷ 10 ) × 10
エ　I ÷ 10

b に関する解答群
ア　L ← L + 1
イ　L ← L – 1
ウ　I ← I + 1
エ　I ← I – 1

ポイント1：数値と数字の違いを知る

数値と数字は、異なるものです。たとえば、 123 は、 1 つの数値です。これを画面に表示するときは、 “1”, “2”, “3” という 3 つの文字を表示することになります。

このように数値の 1 けたずつを 1 つの文字にしたものが数字です。

問題に示された IntFormat 関数の変換例を見てください。 IntFormat 関数は、引数 Int に指定された 123 という数値を、 “1”、”2″、”3″ という数字に変換して引数 Out[] に格納し、その文字数の 3 を引数 Len に格納するのです。

コンピュータの内部では、あらゆる情報を数値で表しています。したがって、 “1”, “2”, “3” という数字も、その実体は、それぞれの数字に割り当てられた文字コードの数値です。

何という数値が割り当てられるかは、使用する文字コード体系によって異なりますが、たとえば JIS X 0201 という文字コード体系では、
“1” は 49、
“2” は 50、
“3” は 51
です。 49 、50 、51 を文字型として画面に出力すると、それぞれに対応した “1”, “2”, “3” という数字が表示されるのです。

この問題では、文字コードは示されていません。その代わりに、

文字型の配列: Chr ← {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}

という文字の配列を用意しています。

配列の添字が 0 から始まるとしているので、 Chr[0] ～ Chr[9] は、 0 から 9 の数値に対応する “0” ～ “9” という数字になります。

たとえば、変数 Idx の値が 5 なら、 Char[Idx] は、数値 5 に対応する “5” という数字になります。

ポイント2： コメントをヒントにして、問題文の説明とプログラムを対応付ける

この問題のように、処理の手順が示されている場合は、手順とプログラムを対応付けることで、空欄で行う処理がわかる場合がよくあります。

その際に、プログラムの中にあるコメントも大いに参考にしてください。試験問題のプログラムのコメントは、コメント（注釈）というよりは、ヒントだからです。

手順の説明の (1) は、プログラムで

/* 引数 Int がゼロの場合の処理 */

というコメントに対応した処理です。

ここには、空欄がないので (1) に示されている

Int の値がゼロの場合は、 Out[0] に “0” を、 Len に 1 を格納して、関数を終了する

という処理をやっているのだ、と考えるだけで OK です。プログラムの内容を詳しく見る必要はありません。

同様に、手順の説明の (2) は、プログラムの

/* 符号の処理 */

の部分に対応し、ここにも空欄がないので、プログラムの内容を詳しく見る必要はありません。

ポイント3： 具体的な数値を想定して処理の流れをトレースする

手順の説明の (3) は、プログラムの

/* 数値を1けたずつ数字に変換してスタックに格納する処理 */

に対応し、ここには空欄 a があるので、

Int の 1 の位から上位に向かって、 1 けたずつ 10 進数字に変換し、 Push 関数でスタックに積む

という説明と対応付けて、プログラムの内容を詳しく見てみましょう。

以下に、該当するプログラムの部分を示します。

  /* 数値を 1 けたずつ数字に変換してスタックに格納する処理 */
  Push("#")     /* スタックに番兵として "#" を積む */

  while (I が 0 より大きい)
    Idx ← I - (I ÷ 10) × 10
    Push(Chr[Idx])
    I ← a
  endwhile

プログラムを見る（読み取る）コツは、わかりやすい具体例を想定することです。

ここでは、変換する数値を格納している変数 I に 123 が格納されていることを想定してみましょう。

Int の 1 の位から上位に向かって、 1 けたずつ 10 進数字に変換し、 Push 関数でスタックに積む

という説明なので、 123 という数値を、 3, 2, 1 の順に、 “3”, “2”, “1” という数字に変換して、 Push 関数でスタックに積みます。

スタックに積むのは、”3″, “2”, “1” の順に変換しただけでは順序が逆だからです。
“1”
“2”
“3”
の順に変換してスタックに積み、それをスタックから取り出すと
“1”, “2”, “3”
という正しい順序にできます。スタックでは、積んだときと逆の順序で取り出すことになるからです。

それでは、プログラムを見てみましょう。

まず、

|・Idx ← I - (I ÷ 10) × 10

という処理の I に 123 を想定すると、

|・Idx ← 123 - (123 ÷ 10) × 10

になります。

123 ÷ 10 は、整数同士の割り算なので、小数点以下がカットされて（これは、とっても重要なことなので必ず覚えておいてください）、 12 になります。
× 10 で、それを 10 倍するので、
(123 ÷ 10) × 10 は、 120 になります。

したがって、

123 - (123 ÷ 10) × 10

は、 123 – 120 = 3 になって、変数 Idx には、 123 の最下位けたの 3 が得られます。

次に、

Push(Chr[Idx])

という処理の Idx に 3 を想定すると、

Push(Chr[3])

となります。 Chr[3] は “3” なので、これによって 3 という数値が “3” という数字に変換されて、スタックにプッシュされます。

次に、

I ← a

という処理に空欄 a があります。これは、次に同じ処理（最下位けたの数値を取り出して、それを数字に変換してスタックに積む）に合わせて、変数 I の値を更新する処理です。

この処理の前で、変数 I の値は 120 になっています。これを 12 に変換すれば、最下位けたが 2 になります。さあ、空欄 a では、どのような処理を行えばよいのでしょう？

ポイント4： 選択肢の変数に具体的な値を設定する

こういうことは、空欄を眺めて腕を組んで考えることではありません。基本情報技術者試験の問題は、すべて選択問題なのですから、必ず選択肢を見て考えてください。

以下に、空欄 a の選択肢を示します。

a に関する解答群
ア　I – 10
イ　I – I ÷ 10
ウ　I – ( I ÷ 10 ) × 10
エ　I ÷ 10

現時点で、変数 I は 120 です。これを 12 にしたいのですから、選択肢の変数 I に 120 を代入して、 12 になるものが正解です。

以下のように、選択肢エが正解です。繰り返しますが、整数の割り算では、小数点以下がカットされることに注意してください。

ポイント5： 同様の処理をしている部分と見比べる

手順の説明の（4）は、プログラムの

/* スタックから取り出す処理 */

に対応し、ここには空欄 b があるので、

スタックに積み終わったら、スタックに積んだ文字を順番に Pop 関数で取り出して Out[] に格納することによって、変換後の 10 進数字を正しい順序に並び替える

という説明と対応付けて、プログラムの内容を詳しく見てみましょう。

以下に、該当するプログラムの部分を示します。

  /* スタックから取り出す処理 */
  T ← Pop()

  while (T が "#" でない)
    Out[L] ← T
    b
    T ← Pop()
  endwhile

まず、

T ← Pop()

の部分でスタックから取り出した数字を変数 T に格納しています。

次に、

while (T が "#" でない)

は、スタックの末尾を示す番兵（目印となるデータのことで、ここでは “#” という文字です）を取り出すまで繰り返す、つまりスタックに積まれたデータをすべて取り出すまで繰り返すということです。

次に、

Out[L] ← T

で、取り出した数字 T を Out[L] に格納しています。

次に、

b

という空欄 b があります。

空欄bの穴埋めは、以下の解答群から選びます。さあ、どれでしょう？

b に関する解答群
ア　L ← L + 1
イ　L ← L – 1
ウ　I ← I + 1
エ　I ← I – 1

ここでは、プログラムの中で、同様の処理をしている部分と見比べる、ということをしてみましょう。

以下のオレンジ色文字の部分で、同様の処理をしています。

  /* 引数 Int がゼロの場合の処理 */
  if (Int が 0 )
    Out[L] ← Chr[Int]
    L ← L + 1
    Len ← L
    return
  endif

  /* 符号の処理 */
  if (Int が 0 より小さい)
    I ← -Int
    Out[L] ← "-"
    L ← 1 + 1
  else
    I ← Int
  endif

これらを見ると、 Out[L] にデータを格納したら、次の格納に備えて L の値を 1 増やす処理をしていることがわかります。空欄 b も同じはずです。

したがって、選択肢アの L ← L + 1 が正解です。

解答a － エ, b － ア

「習うより慣れろ」ということわざがあります。アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post トレースのテクニックが身につく練習問題｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。 とても短い問題ですので、気軽に取り組んでください。

練習問題

問 8 「符号付き 2 進数の乗算」（平成 22 年度 秋期 午後）を一部改変

　関数 MUL は、二つの整数 M 、 N を受け取り、その積 M × N を返す。 積は、加算とシフト演算を使って求める。 M 、 N 及び求めた積は、いずれも符号付き 2 進数の整数で、負数は 2 の補数で表現する。

　関数 MUL が受け取る M 、 N は、いずれも 4 ビットで、各値の範囲は -8 ～ 7 である。 求めた積 M × N は、 8 ビットで返す。 ただし、プログラム中では、 M を 5 ビットに、 N を 8 ビットに拡張して処理を行う。

　R は、 13 ビットの作業用変数であり、最下位から順にビット番号を 0, 1, ・・・とし、最上位（符号ビット）のビット番号を 12 とする。 R は、指定した一部の範囲（例えば、ビット番号 12 ～ 8 の上位 5 ビット）だけを符号付き 2 進数とみなして部分的な算術演算ができる。 また、値の検査のために指定したビット番号の内容を取り出すこともできる。

　M = -5 、N = 3 の場合の処理過程を、図に示す。 図中の記号 ① ～ ⑧ は、プログラムの ① ～ ⑧ の行の処理と対応している。 なお、 ⑥ の行の加算では、けたあふれが起きても無視する。

swipeアルゴリズムは横スクロールできます

［プログラム］

◯整数型: MUL(M, N)
  符号付き 2 進整数型: M, N, R
  整数型: L
  M を 5 ビットの符号付き 2 進数に拡張
  N を 8 ビットの符号付き 2 進数に拡張
  R のビット番号 7 ～ 0 に N を複写
  R のビット番号 12 ～ 8 を 0 で初期化
  for (L を 1 から 8 以下まで 1 つずつ増やす)
    if (R のビット番号 0 のビットが 1)
      R のビット番号 12 ～ 8 の内容に M の値を加算
    endif
    R の全 13 ビットを右に 1 ビット算術シフト	/* 空いたビット位置には符号と同じものが入る */
  endfor
  return (R のビット番号 7 ～ 0 の内容)      /* 返却値（括弧内）を返す */❶❷❸❹❺❻❼❽

設問　プログラム中のに入れる正しい答えを、解答群の中から選べ。

a に関する解答群
ア　　
イ　
ウ　　
エ　

b に関する解答群
ア　　
イ　
ウ　　
エ　
オ　　
カ　

ポイント1：2進数の取り扱いに慣れておく

2 進数が苦手な人は、この問題を見て「すご～く難しそう！」と感じたでしょう。 それなら、この機会に、 2 進数の取り扱いに慣れておきましょう。

基本情報技術者試験の旧午後試験のアルゴリズム問題では、それほど頻度は多くありませんが、 2 進数を取り扱う問題が出ることがあったからです。 お手元の教材（きっと何らかの教材をお持ちでしょう）に示された 2 進数に関する知識を、丁寧に学習してください。

この問題を解くには、以下の知識が必要になります。 どれも基礎知識ですので、しっかりマスターしておいてください。

• 10 進数と 2 進数の変換
• 2 進数の加算
• 2 の補数表現
• 符号ビット
• 算術右シフト
• 符号拡張

searchタグで関連記事をチェック2 進数

ポイント2：符号拡張は、同じ値のままビット数を増やす

ちゃんと 2 進数の知識があれば、この問題は、決して難しくありません。 問題に示された数値を、問題に示された手順通りに、順番に処理していけばよいからです。

問題に示されたプログラムの内容は、プログラムというより、処理内容を説明した文書です。 それぞれの文書を読めば、処理内容がわかります。

プログラムの各行に付けられた ① ～ ⑧ は、穴埋めがある図に示された ① ～ ⑧ に対応しています。

それぞれに合わせて、問題に示された数値の変化を図の中に書き込んでいけば、穴埋めに入る数値がわかります。

それでは、やってみましょう。

まず、 ① と ② です。 ここでは、符号拡張（問題文では「拡張」と呼んでいる）を行っています。 符号拡張とは、同じ値（符号も同じ）のままビット数を増やすことです。

ここでは、 2 の補数表現を使っているので、符号ビット（最上ビット）が
0 ならプラスの値であり、
1 ならマイナスの値です。

同じ値のままビット数を増やすには、増やした上位桁を、
プラスの値なら 0 で満たし、
マイナスの値なら 1 で満たします。

どちらの場合も、符号ビットを上位桁に「ぐい～ん」と拡張しているように見えるので、符号拡張と呼ぶのです。

ポイント3： 算術右シフトは、空いた上位桁に符号ビットと同じ値を入れる

次に、空欄 a があるところまで、数値の変化を見ていきましょう。

③ では、 R の下位桁に N を複写しています。
④ では、 R の上位桁を 0 で埋めています。
⑤ では、 R の最下位桁が 1 であることをチェックしています。
⑥ では、 R の上位桁に M を加算しています。

この時点では、 R の上位桁がすべて 0 なので、グレー表示になっている部分に、 M の値をそのまま入れれば OK です。 ここまでの手順には、特に難しいことはないでしょう。

次の ⑦ では、 R の全ビットを右に 1 ビット算術シフトします。

「算術」シフトであることに注意してください。 右シフトすると、上位桁に空きができます。 算術シフトでは、ここに符号ビットと同じ値を入れます。 こうすることで、符号を変えずに、値を 1/2 にできます。

ここでは、シフト前の値が

1101100000011

なので、右に 1 ビット算術シフトすると、空いた上位桁に符号ビットと同じ値の 1 を入れて、

1110110000001

になります。

したがって、空欄 a は、 111011 であり、選択肢エが正解です。

ポイント4：2進数の加算は、2で桁上がりする

次の ⑥ では、 11101 と 11011 を加算します。

ここでは、 2 進数の加算なので、下位桁から加算を行って、結果が 2 になったら桁上がりすることに注意してください。

問題文に、最上位桁からの桁あふれは無視するとあるので、以下のように計算して、結果は 11000 になります。

    11101
+   11011
---------
    11000

この 11000 を ⑥ の下のグレー表示になっている部分に入れ、次の ⑦ で右に 1 ビット算術シフトします。

先ほどと同様に、ここでも最上位桁の符号ビットが 1 なので、空いた上位桁に符号ビットと同じ 1 を入れて、空欄 b は、 1110001 になります。 正解は、選択肢オです。

解答a － エ, b － オ

「習うより慣れろ」ということわざがあります。 アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post 2進数を掛け算するプログラム | アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。 とても短い問題ですので、気軽に取り組んでください。

練習問題

問 8 (平成 30 年度 春期 午後）を一部改変

手続 makeHeap は、配列 data に格納されている hnum 個（ hnum > 0 ）のデータを、次の (1) ～ (3) の規則で配列 heap に格納して、ヒープを配列で実現する。 配列の添字は、 0 から始まる。

(1)

heap[i] ( i = 0, 1, 2, ・・・) は、ヒープの節に対応する。

(2)

heap[0] は、根に対応する。

(3)

heap[i] ( i = 0, 1, 2, ・・・) に対応する節の左側の子は heap[2 × i + 1] に対応し、右側の子は heap[2 × i + 2] に対応する。 子が一つの場合、左側の子として扱う。

ヒープの例を図 1 に、図 1 に対応する配列 heap の例を図 2 に示す。

swipeアルゴリズムは横スクロールできます

［プログラム］

◯makeHeap(整数型の配列: data, 整数型の配列: heap, 整数型: hnum)
  整数型: i, k

  for (i が 0 から hnum より小さい間 1 ずつ増やす)
    heap[i] ← data[i]	/* heap にデータを追加 */
    k ← i

    while ( k が 0 より大きい)
      if ( a )
        swap(heap, k, b )
        k ← parent(k)
      elseif
        break		/* 内側の繰り返し処理から抜ける */
      endif
    endwhile
  endfor

設問

プログラム中のに入れる正しい答えを、解答群の中から選べ。

• プログラムおよび解答群の中で使われている関数 lchild( 整数型: k ) は、添字 k の配列要素に対応する節の左側の子の添字 2 × k + 1 を戻り値として返す。
• 関数 rchild( 整数型: k ) は、添字 k の配列要素に対応する節の右側の子の添字 2 × k + 2 を戻り値として返す。
• 関数 parent( 整数型: k ) 関数は、添字 k の配列要素に対応する親の添字 ( k – 1 ) ÷ 2 （小数点以下切捨て）を戻り値として返す。
• 関数 swap( 整数型: heap[], 整数型: i, 整数型: j ) は、 heap[i] と heap[j] の値を交換する。

a に関する解答群

ア

heap[k] が heap[lchild(k)] より大きい

イ

heap[k] が heap[parent(k)] より大きい

ウ

heap[k] が heap[rchild(k)] より大きい

エ

heap[k] が heap[lchild(k)] より小さい

オ

heap[k] が heap[parent(k)] より小さい

カ

heap[k] が heap[rchild(k)] より小さい

b に関する解答群

ア　heap[hnum - 1]
イ　heap[k]
ウ　parent(hnum - 1)
エ　parent(k)

ポイント1: シラバスに示されたアルゴリズムとデータ構造を知っておこう

この問題を見て「ヒープって何だろう？」と思った人は、試験の出題範囲の学習が不足しています。 IPA（情報処理推進機構）の Web ページから試験の出題範囲の細目を示した シラバス という資料を入手できます。

これを見ると、「代表的なアルゴリズム」および「データ構造の種類」として、以下が出題範囲であることが示されています。 ここには、ちゃんと「ヒープ」という言葉があります。

【代表的なアルゴリズム】

looks_one 整列・併合・探索のアルゴリズム

整列のアルゴリズム、併合のアルゴリズム、探索のアルゴリズムの基本的な設計方法を理解する。

用語例選択ソート、バブルソート、マージソート、挿入ソート、シェルソート、クイックソート、ヒープソート、線形探索法、 2 分探索法、ハッシュ表探索法

looks_two 再帰のアルゴリズム

再帰的アルゴリズムの基本を理解する。

looks_3 グラフのアルゴリズム

グラフのアルゴリズムの基本を理解する。

用語例深さ優先探索、幅優先探索、最短経路探索

looks_4 文字列処理のアルゴリズム

文字列処理のアルゴリズムの基本を理解する。

用語例文字列照合

looks_5 ファイル処理のアルゴリズム

バッチ処理などで用いる整列処理、併合処理、コントロールブレーク処理、編集処理の基本を理解する。

【データ構造の種類】

looks_one 配列

配列の特徴、基本的な操作を理解する。

用語例多次元配列、静的配列、動的配列

looks_two リスト

リストの基本的な考え方、その操作を理解する。

用語例線形リスト、単方向リスト、双方向リスト、環状リスト

looks_3 スタックとキュー

スタックとキューの特徴、基本的な操作を理解する。

用語例FIFO 、LIFO 、プッシュ、ポップ

looks_4 木構造

木構造の種類と特徴、木の巡回法、節の追加や削除、ヒープの再構成などを理解する。

用語例根、葉、枝、 2 分木、完全 2 分木、バランス木、順序木、多分木、探索木、 2 分探索木、深さ優先探索、幅優先探索、先行順、後行順、中間順

アルゴリズムに「ヒープソート」があり、データ構造に「ヒープ」があるからこそ、この問題が出題されたのです。

ヒープに限らず、もしもシラバスの中に知らないアルゴリズムやデータ構造があったら、教材（きっと何らかの教材をお持ちでしょう）で学習してください。

すべてを詳細に理解する必要はありませんが、少なくとも、それが何であるかは、わかるようにしておきましょう。

ポイント2: ヒープのデータ構造を知っておこう

ヒープは、1 つのデータが枝分かれして 2 つのデータにつながる 2 分木の一種です。

ヒープを図示するときには、慣例として、データを円で囲んで示し、円を線で結んでデータのつながりを示します。

データを「節（ノード）」と呼び、線を「枝（ブランチ）」と呼びます。
枝分かれの元にある節を「親」と呼び、枝分かれの先にある節を「子」と呼びます。
最上部にある節を「根（ルート）」と呼びます。
最下部にあり枝がない節を「葉（リーフ）」と呼ぶこともあります。

どれも、自然界の木の構成要素を示す名称と同じです。

ヒープでは、
「左右に関係なく、親の値が子の値より小さい」とする場合と、
「左右に関係なく、親の値が子の値より大きい」とする場合があります。

この問題では、後者になっています。

ヒープに限らず、どのようなデータ構造でも、それをプログラムで実現するときには、配列が使われます。

ここでは、問題に示された (1) ～ (3) の規則で、ヒープを配列で実現しています。

ポイント3: ヒープを作成する手順を知っておこう

この問題を解くには、ヒープのデータ構造だけでなく、ヒープを作成する手順を知っていなければなりません。 問題に示された手続 makeHeap は、配列 data に格納された hnum 個の要素を、ヒープの形式で配列 heap に格納するものだからです。

ヒープは、以下の (1) ～ (3) の手順で作成できます。

ここでは、かなり大雑把に手順を示しています。 新たな要素を仮に格納してから、要素を交換して、適切な位置に移動させることがポイントです。

1. 配列 data の要素を先頭から 1 つずつ順番に取り出し、それを配列 heap の同じ位置に仮に格納する。
2. 配列 heap に新たに格納した要素が、親の要素より大きいなら、両者を交換することを根に達するまで繰り返す（親の要素より大きくない時点で、繰り返しを途中終了することもある）。
3. 1. と 2. を配列要素の末尾まで繰り返す。

ヒープを作成する手順がわかったら、問題の穴埋めができます。

以下は、手順に合わせたコメントをプログラムに追加したものです。 コメントは、 aとbがある部分まで付けています。

◯makeHeap(整数型の配列: data, 整数型の配列: heap, 整数型: hnum)
  整数型: i, k

  for (i が 0 から hnum より小さい間 1 ずつ増やす) /* 配列 data の要素を先頭から末尾まで処理する */
    heap[i] ← data[i]                           /* 配列 data の要素を、配列 heap の同じ位置に仮に格納する */
    k ← i                                       /* 新たに格納した要素の添字を k に格納する */

    while ( k が 0 より大きい)                    /* k が 0 （根）にたどり着くまで繰り返す */
      if ( a )                         /* aが真なら関数 swap で交換処理をする */
        swap(heap, k, b )              /* heap[k] と heap[b] を交換する */
        k ← parent(k)
      elseif
        break
      endif
    endwhile
  endfor

関数 swap で交換処理をするのは「子が親より大きい」という条件が真の場合です。

ここでは、子が heap[k] であり、その親の添字は関数 parent(k) で求められるので、「子が親より大きい」という条件は、

heap[k] が heap[parent(k)] より大きい

になります。 したがって、aは選択肢イが正解です。

関数 swap で交換するのは、 heap[k] と heap[parent(k)] です。 関数 swap の引数には、交換する要素の添字を指定するので、bは parent(k) であり、選択肢エが正解です。

いかがでしょうか？

ヒープのデータ構造と、ヒープの作成方法を知っていれば、とっても簡単な穴埋め問題だったはずです。 繰り返しアドバイスしますが、もしもシラバスの中に知らないアルゴリズムやデータ構造があったなら、教材で学習してください。

シラバスに示されていることは「知っているよね！」というノリで出題されるからです。

解答a – イ, b – エ

「習うより慣れろ」ということわざがあります。 アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post ヒープを配列で実現するプログラム｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、実際の試験問題の一部をアレンジした練習問題を作りました。とても短い問題ですので、気軽に取り組んでください。

練習問題

◯文字型: calcCheckCharacter(文字型の配列: input, 整数型: len)
  整数型: N, sum, i, value, check_value
  論理型: is_even

  N ← 30
  sum ← 0
  is_even ← a1

  for (i を len から 0 より大きい間 -1 ずつ減らす )
    value ← getValue(input[i])

    if ( is_even が a2 と一致)
      sum ← sum + value
    else
      sum ← sum + (value × 2) ÷ N + (value × 2) mod N
    endif

    is_even ← not is_even
  endfor

  check_value ← b
  return getChar(check_value)

ア　N - sum mod N
イ　sum mod N
ウ　( N - sum mod N ) mod N
エ　( sum - N ) mod N

ポイント1: 問題に示された具体例で自分の解釈が正しいことを確認する

この問題を解くには「検査文字の生成の手順」を正しく解釈できなければなりません。もしも「自分の解釈が正しいのだろうか？」と心配になったら、問題に「検査文字の生成例」が示されているので、それを使って確認してください。

この例では、文字列 “ipa△△” に対し、生成される検査文字は “f” です。自分の解釈で検査文字を求めて、例と同じ結果が得られれば OK です。筆者は、以下のように解釈しました。

手順looks_one

文字列の末尾の文字を 1 番目の文字とし、文字列の先頭に向かって奇数番目の文字に割り当てた数値を 2 倍して N で割り、商と余りの和を求め、全て足し合わせる。

解釈

末尾を 1 番目として “ipa△△” の奇数番目の文字は、 “△” , “a” , “i” です。これらに割り当てた数値は、0, 4, 12 です。これらを 2 倍すると、0, 8, 24 です。 N = 30 で割った商と余りは、 0 と 0 、 0 と 8 、0 と 24 です。商と余りの和は、 0, 8, 24 です。全て足し合わせると、32 です。

手順looks_two

偶数番目の文字に割り当てた数値は、そのまま全て足し合わせる。

解釈

“ipa△△” の奇数番目の文字は、 “△” , “p” です。これらに割り当てた数値は、 0, 19 です。そのまま足し合わせると、 19 です。

手順looks_3

looks_one とlooks_two の結果を足し合わせる。

解釈

looks_one の 32 と looks_two の 19 を足し合わせると、51 です。

手順looks_4

N から、looks_3 で求めた総和を N で割った余りを引く。さらにその結果を、 N で割り、余りを求める。求めた数値に対応する文字を検査文字とする。

解釈

N = 30 から、looks_3 で求めた 51 を N = 30 で割った余りの 21 を引くと、 9 です。さらに 9 を N = 30 で割った余りを求めると、9 です。 9 に対応する検査文字は、 “f” です。

例に示された “f” と同じ “f” という結果が得られたので、筆者の解釈は正しいようです。

もしも、同じ結果が得られなかった場合は、どこかに解釈の間違いがあるので、手順をよく見直してください。「あっ！ そういう意味だったのか」と気付くはずです。

ポイント2: 変数名をヒントにして変数の役割を見出す

a1とa2は、変数 is_even への代入と比較です。
bは、変数 check_value への代入です。

これらの穴埋めをするには、変数の役割がわからなければなりません。

これらの変数の役割は、問題文に示されていませんが、変数名をヒントにすればわかるでしょう。

is_even の、 even は偶数という意味です。
is は「 is this a pen ? (これはペンですか？) 」という疑問文の is であり、「～ですか？」という意味です。

つまり、is_even は「偶数ですか？」を意味する変数であり、論理型で定義されているので、値が true なら偶数であり、 false なら奇数です。

「 even が偶数なんて知らない！」という人は、プログラムに登場する変数名や関数名で使われる英単語の意味を覚える習慣を持ってください。

筆者は、英語が得意なわけではありません。英検が 3 級で、 TOEIC が 400 点台という、英語のできない典型的な日本人です。そうであっても、プログラムに登場する変数名や関数名で使われる英単語は、意味を覚えるようにしています。

even が「偶数」で、 odd が「奇数」 であることは、かつて何らかのプログラムで見たときに覚えました。

プログラムには、難しい英単語は登場しません。もしも、変数名や関数名にわからない英単語が登場したら、面倒くさがらずに意味を調べてください。

check_value の意味は、調べなくてもわかるでしょう。

check は「検査」で、 value は「値」です。 calcCheckCharacter 関数は、戻り値として検査文字を返すので、プログラムの最後の処理が、

return getChar(check_value)

になっています。

「検査値」の check_value を、 getChar 関数で文字 (検査文字) に変換して返すのです。

ポイント3: 問題に示された手順とプログラムを対応付ける

この問題のように、手順が丁寧に示されている場合には、それぞれの手順とプログラムを対応付けると「この穴埋めで行う処理はこれだ！」とわかることがよくあります。

a1が false で、a2が true なので、 a の正解はイです。

解答a － イ, b － ウ

「習うより慣れろ」ということわざがあります。アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post ルールに従って検査文字（チェックディジット）を求めるプログラム｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、旧制度の午後試験のアルゴリズム過去問題の一部をアレンジした練習問題を作りました。 とても短い問題ですので、気軽に取り組んでください。

練習問題

問 8 (平成 25 年度 春期 午後）を一部改変

この問題では、配列名や変数名が日本語なので、わかりやすいように青色文字で示しています

　以下は、購入した商品の中から、値引きの対象となる商品を見つけて、その数量を求めるプログラムである。 購入した商品は、 購入[ ] という構造型（品番、品名、数量から構成されたデータ型）の配列に格納され、要素数は 購入行数 に格納されている。 値引きの対象となる商品は、 対象[ ] という構造型（品番、数量から構成されたデータ型）の配列に格納され、要素数は 対象行数 に格納されている。 ぞれぞれの配列は、 品番 の昇順に整列されていて、 品番 が一致した場合は、 購入[ ] の 数量 を、 対象[ ] の 数量 に格納する。 購入[ ] 、 購入行数 、 対象[ ] 、 対象行数 は、以下に示したプログラムとは別の場所で宣言された大域的変数である。 購入[ ] と 対象[ ] の添字は、 1 から始まる。 プログラム中の a b に入る正しい答えを、解答群の中から選べ。

swipeプログラムは横スクロールできます

［プログラム］

整数型: K, T
K ← 1
T ← 1

while (k が購入行数以下でかつ T が対象行数以下)
  if (購入[K].品番と対象[T].品番が等しい)
    対象[T].数量 ← 購入[K].数量
    a
    b
  elseif (購入[K].品番が対象[T].品番より小さい)
    a
  else
    b
  endif
endwhile

a と b の解答群

ア　K ← K + 1
イ　K ← 購入[K].品番 + 1
ウ　T ← T + 1
エ　T ← 対象[T].品番 + 1

ポイント1: 構造型とは何かを知っておこう

この問題には、科目 B サンプル問題に掲載された「共通に使用される擬似言語の記述形式」に説明がない「構造型（構造体、レコード型、ユーザー定義型とも呼ばれます）」が登場します。

擬似言語は、 C 言語によく似ていて、 C 言語には構造型があるので、「わかるよね！」というノリで出題されているのです。 しかし、 C 言語の経験がないなら「わかりません！」だと思いますので、この機会に構造型とは何かを知っておきましょう。

構造型は、複数のデータをまとめたデータ型です。 C 言語では、 struct というキーワードで構造型を定義します。 この問題に示された構造型を C 言語風に定義すると、以下のようになります。

struct 購入構造型 {
  文字列型 品番;
  文字列型 品名;
  整数型 数量;
};

struct 対象構造型 {
  文字列型 品番;
  整数型 数量;
};

構造型は、ユーザーが独自に定義したデータ型であり、変数や配列のデータ型として使います。

ここでは、構造型の名前を、購入構造型と対象構造型にしています。 構造体にまとめられた個々のデータをメンバと呼びます。 購入構造体のメンバは、品番、品名、数量です。 対象構造体のメンバは、品番、数量です。

この問題では、購入[ ] および 対象[ ] という配列のデータ型が、購入構造型および対象構造型になっています。 構造型の配列の個々の要素には、構造体のメンバ一式が入っています。

構造体の配列の個々の要素で、メンバを指定するときは、

配列名[添字].メンバ名

という表記を使います。 このドット（ . ）を「～の」と読むとわかりやすいでしょう。

たとえば 購入[1].品番 なら、「 購入[1] の品番」と読みます。 以下に例を示します。

構造体とは何かがわかったら、問題に示されたプログラムを見てみましょう（以下に示します）。

購入[K].品番と対象[T].品番が等しい

は、「購入[K] の品番と対象[T] の品番が一致する」という意味です。

対象[T].数量 ← 購入[K].数量

は、「対象[T] の数量に、購入[K] の数量を格納する」という意味です。

購入[K].品番が対象[T].品番より小さい

は、「購入[K] の品番が、対象[T] の品番より小さい」という意味です。

整数型: K, T
K ← 1
T ← 1

while (k が購入行数以下でかつ T が対象行数以下)
  if (購入[K].品番と対象[T].品番が等しい)
    対象[T].数量 ← 購入[K].数量
    a
    b
  elseif (購入[K].品番が対象[T].品番より小さい)
    a
  else
    b
  endif
endwhile

ポイント2: 突合せのやり方を知っておこう

この問題のテーマは、旧午後試験のソフトウェア設計の分野でよく出題された 突合せ です。

突合せとは、「整列済みの 2 つのファイルの先頭から 1 件ずつデータを読み出し、一致したら特定の処理を行って両方を読み進め、不一致ならその先で一致する可能性がある方だけを読み進める」という処理です。

この問題では、 2 つのファイルではなく、 2 つの配列で突合せを行っていますが、やり方は同様です。 もしも、「ソフトウェア設計の突合せの問題をやったことがありません！」なら、この機会に突合せのやり方を知っておきましょう。

以下に、問題に示された 2 つの配列で突合せを行う手順を示します。

【手順 1 】

それぞれの先頭の要素を読み出して、品番を比べます。
購入[1].品番 < 対象[1].品番 なので、 購入[ ] だけを先に読み進めます。
なぜなら、それぞれの配列は、品番の昇順に整列されているので、購入[ ]だけを先に読み進めれば、対象[ ]と品番が一致する要素が見つかる可能性があるからです。

【手順 2 】

購入[2].品番 = 対象[1].品番 なので、 対象[1].数量 に 購入[2].数量 を格納して、 購入[ ] と 対象[ ] の両方を先に読み進めます。
一致したら両方を読み進め、不一致なら一方だけを読み進めるのが、突合せのポイントです。

【手順 3 】

購入[3].品番 > 対象[2].品番 なので、対象[ ] だけを先に読み進めます。

【手順 4 】

購入[3].品番 = 対象[3].品番 なので、 対象[3].数量 に 購入[3].数量 を格納して、 購入[ ] と 対象[ ] の両方を先に読み進めます。

【手順5】

この時点で、 対象[ ] が末尾を超えたので、突合せを終了します。
突合せを繰り返す条件は、 「 購入[ ] が末尾を超えていない、かつ、 対象[ ] が末尾を超えていない」です。

突合せのやり方がわかったら、問題の穴埋めができるでしょう。 以下に、もう一度、プログラムと解答群を示します。

整数型: K, T
K ← 1
T ← 1

while (k が購入行数以下でかつ T が対象行数以下)
  if (購入[K].品番と対象[T].品番が等しい)
    対象[T].数量 ← 購入[K].数量
    a
    b
  elseif (購入[K].品番が対象[T].品番より小さい)
    a
  else
    b
  endif
endwhile

a と b の解答群

ア　K ← K + 1
イ　K ← 購入[K].品番 + 1
ウ　T ← T + 1
エ　T ← 対象[T].品番 + 1

a bは、 2 か所ずつあります。 上側にある

購入[K].品番と対象[T].品番が等しい

という条件で、 a と b の両方を行っています。 これは、どちらか一方が 購入[ ] を読み進める処理で、もう一方が 対象[ ] を読み進める処理です。

ここでは、どちらがどちらなのかを判断できません。

下側にある

購入[K].品番が対象[T].品番より小さい

という条件で、 a を行っています。 これは、購入[ ] を読み進める処理です。

購入[ ] の添字は、 K で示されているので、選択肢の中では、 K の値を 1 つ増やす K ← K + 1 （選択肢ア）が適切です。

a が 購入[ ] を読み進める処理だとわかったので、 b は、対象[ ] を読み進める処理であることがわかります。

対象[ ] の添字は、 T で示されているので、選択肢の中では、 T の値を 1 つ増やす T ← T + 1 （選択肢ウ）が適切です。

ポイント3: 難しそうな選択肢を選ばない

多くの受験者が、「旧午後試験では時間が足りない！」と言っていました。 科目 B 試験で出題数が変わったとは言え、 1 問平均 5 分で 16 問解答する必要があるため、この傾向は変わらないと予想されます。

そのため、「当てずっぽう」で選択肢を選ぶこともあるでしょう。 これは、仕方がないことだと思いますが、「選択肢の内容が他より難しそうだから」という理由で選ばないでください。

なぜなら、難しそうな選択肢は、間違いである場合が多いからです。 ここで、もう一度、今回の問題の選択肢を見てみましょう。

a と b の解答群

ア　K ← K + 1
イ　K ← 購入[K].品番 + 1
ウ　T ← T + 1
エ　T ← 対象[T].品番 + 1

選択肢アとイは K に代入を行い、ウとエは T に代入を行っています。 アとウより、イとエの方が難しそうなことをしているので、「難しそうな方が正解かな？」と思うかもしれませんが、実際の正解はアとウです。

これは、「簡単そうな方を選べ」ということではありません。 「当てずっぽう」で選択肢を選ぶときには、「選択肢の内容を気にしないで選べ」ということです。

ただし、すべての選択肢から当てずっぽうに選ぶのではなく、「これは絶対に正解ではない」という選択肢を消して、残ったものの中から選んでください。 そうすれば、当てずっぽうが当たる確率が上がり、残った選択肢を見て「あっ、そうか！」と正解に気付くこともあります。

解答a － ア, b － ウ

「習うより慣れろ」ということわざがあります。 アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post 配列のマッチング（突合せ）を行うプログラム｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

苦手を克服するには、短いプログラムを何度も練習して、穴埋めに慣れることが重要です。

そのために、旧制度の午後試験のアルゴリズム過去問題の一部をアレンジした練習問題を作りました。 とても短い問題ですので、気軽に取り組んでください。

練習問題

◯整数型: BitTest( 8 ビット論理型: Data, 8 ビット論理型: Mask)
  整数型: RC		/* 返却値 */

  if ( a )
    RC ← 2		/* 返却値は 2 */
  elseif ( b )
    RC ← 0		/* 返却値は 0 */
  else
    RC ← 1		/* 返却値は 1 */
  endif

  return RC		/* RC を返却値として返す */

ポイント1: 問題に示された具体例から問題の意味を理解する

この問題は、問題文の説明を読んだだけでは、何をするプログラムかよくわからないでしょう。 どうやら出題者も、そう思ったようで、具体例を 2 つ示しています。

このような場合には、具体例を見れば、問題の意味を理解できるようになっているはずです。

もうひとつ例があるので、この解釈が合っているかどうかを確認しておきましょう。

これで、解釈が合っていることを確認できました。

ポイント2: 事前に 2 進数の知識を習得しておく

それほど頻度は多くないのですが、基本情報技術者試験の旧午後試験のアルゴリズム問題では、 2 進数の知識が必要なプログラムが出ることがありました。

以下の知識をきちんと習得できているかどうか確認してください。 ここでは、それぞれの知識を詳しく説明しませんが、もしも習得できていないことがあれば、お手元の教材（きっと何らかの教材をお持ちでしょう！）で学習してください。

今回の練習問題では、ビット演算の知識が必要です。

• 2 進数を 10 進数に変換する
• 10 進数を 2 進数に変換する
• 2 進数を 16 進数に変換する
• 16 進数を 2 進数に変換する
• 2 の補数表現でマイナスの数を表す
• 論理シフトと算術シフトの違いがわかる
• AND 、OR 、XOR のビット演算（ビットごとの論理演算）ができる

ポイント3: コメントをヒントにする

実務で作成されるプログラムでは、プログラムの保守性を高めるために、数多くのコメントが入れてあります。 コメントを読めば、誰でもプログラムの内容を理解できるようにしているのです。

ただし、もしも試験問題のプログラムに数多くのコメントを入れたら、問題がやさしくなり過ぎてしまいます。
とはいえ、まったくコメントを入れなければ、制限時間内に問題を解けなくなってしまうでしょう。

そこで、試験問題のプログラムには、少しだけコメントが入れてあります。

このコメントは、コメントというよりも制限時間内に問題を解くためのヒントです。 プログラムの中にコメントを見たら「ヒントだ！」と思って、大いに注目してください。

この問題でも、ヒントとしてコメントが入っています。 以下の /* と */ で囲まれた文字列がコメントです。

◯整数型: BitTest( 8 ビット論理型: Data, 8 ビット論理型: Mask)
  整数型: RC		/* 返却値 */

  if ( a )
    RC ← 2		/* 返却値は 2 */
  elseif ( b )
    RC ← 0		/* 返却値は 0 */
  else
    RC ← 1		/* 返却値は 1 */
  endif

/* 返却値 */ というコメントから、 RC という変数が返却値を入れるものであることがわかります。

/* 返却値は 2 */ というコメントから、aには返却値を 2 にする条件、つまり Mask で指定した Data のビット位置が全て 1 である条件が入ることがわかります。

/* 返却値は 0 */ というコメントから、bには返却値を 0 にする条件、つまり Mask で指定した Data のビット位置が全て 0 である条件が入ることがわかります。

/* RC を返却値として返す */ というコメントから、 return という命令が、返却値を返すものであることがわかります。

C 言語、Java 、Python などのプログラミング言語の経験があれば、この return の意味がわかると思いますが、擬似言語仕様書には return が示されていません。 このプログラムでは、仕様書にない表現を使っているので、それをコメントで説明しているのです。 このようなコメントもよくあります。

ポイント4: 選択肢の変数に具体的な数値を設定してみる

それでは、プログラムの穴埋めをやってみましょう。

これまでの記事でも何度かポイントとして取り上げてきましたが、基本情報技術者試験の問題は、すべて選択問題なのですから、選択肢を見て答えを選んでください。

aには、 Mask で指定した Data のビット位置が全て 1 である条件が入ります。 これは、選択肢ア～オのどれでしょう。

• Data と Mask の値がどちらも “00000000”B
• Data と Mask の値がどちらも Data
• Data と Mask の値がどちらも Mask
• Data と Mask の値がどちらか “00000000”B
• Data と Mask の値がどちらか Mask

もしも、「う～む？」と悩んでしまったら、選択肢の変数に具体的な数値を設定してみましょう。

「具体例！」そうです。 問題にも具体例が示されていました。 返却値が 2 になる具体例は、例 2 です。

例 2

ビット番号	7 6 5 4 3 2 1 0
Data	0 0 1 1 0 0 1 1
Mask	0 0 0 1 0 0 0 1
返却値	2

それでは、例 2 の具体例を想定すると、どの選択肢が適切でしょう。

選択肢は、どれも左辺で Data と Mask の AND 演算（ & ）か OR 演算（ | ）を行っています。

これも、「う～む？」と悩んでしまったら、実際に AND 演算と OR 演算をやってみればよいのです（ AND と OR のビット演算の知識が不安に感じた方は 論理回路 のタグがついた記事で練習してみましょう！ ）。

    0 0 1 1 0 0 1 1  Data
AND 0 0 0 1 0 0 0 1  Mask
--------------------
    0 0 0 1 0 0 0 1 演算結果・・・ Mask と同じ

    0 0 1 1 0 0 1 1  Data
OR  0 0 0 1 0 0 0 1  Mask
--------------------
    0 0 1 1 0 0 1 1 演算結果・・・ Data と同じ

以上のように、 AND 演算の結果は Mask と同じになります。 これは、選択肢ウです。 OR 演算の結果は Data と同じになります。 これは、選択肢にはありません。

したがって、選択肢にあるウが正解です。 できましたね！

bには、 Mask で指定した Data のビット位置が全て 0 である条件が入ります。

この具体例は、問題にありませんでしたが、例 1 と例 2 を参考にして、自分で作ってみましょう。

ここでは、 Data を 00110011 に、 Mask を 11001100 にしてみます。

    0 0 1 1 0 0 1 1  Data
AND 1 1 0 0 1 1 0 0  Mask
--------------------
    0 0 0 0 0 0 0 0 演算結果・・・ "00000000"B

    0 0 1 1 0 0 1 1  Data
OR  1 1 0 0 1 1 0 0  Mask
--------------------
    1 1 1 1 1 1 1 1 演算結果・・・ "11111111"B

以上のように、 AND 演算の結果は "00000000"B になります。 これは、選択肢アです。

OR 演算の結果は "11111111"B になります。 これは、選択肢にはありません。

したがって、選択肢にあるアが正解です。 できましたね！

解答a － ウ, b － ア

「習うより慣れろ」ということわざがあります。 アルゴリズム穴埋め問題の克服に関しては、正にその通りでしょう。

この連載では、これからも短い練習問題を掲載していきますので、穴埋めに慣れることを目指してください。

正解を見出すポイントとして、同じことが示されることもあると思いますが、それは、多くの問題に共通したポイントがあるからです。

それでは、またお会いしましょう！

The post 2進数の知識が必要なプログラム｜アルゴリズムとプログラミング問題を解くコツ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.