総視聴再生時間43万分以上(2017年5月13日現在)の動画で基本情報技術者試験の過去問&キーワード解説!スキマ時間に動画!〜これじょIT〜

PR広告

平成29年度秋 基本情報技術者試験午後 問11 ソフトウェア開発(Java)|合格率アップ!動画解説!

次のJavaプログラムの説明及びプログラムを読んで、設問1~3に答えよ。

〔プログラムの説明〕

文字列の配列を要素にもつ配列で表現された表中の行を、並べ替えるプログラムである。表は行の配列として、行は文字列の配列として構成される。各行の指定した列が、指定した順序に並ぷように、行を並べ替える。

図1は、表の最左列の文字列を辞書順に、最左列の文字列が等しい行は右隣の列の文字列を数値とみなしたときに降順になるように並べ替えた例である。

平成29年度秋基本情報技術者試験午後過去問11

図1 並べ替えの例

クラス TableSorter は、表中の行を並べ替える機能を提供する。次のメソッドと入れ子クラス OrderBy をもつ。

(1) putSortOrder(String key、Comparatororder) - このクラスのメソッド sort で指定可能な順序を登録する。

key - 表を並べ替える順序を示すために使用する文字列(以下、順序指定子という)。

order - インタフェース Comparator 型のオブジェクトで、key で指定した順序指定子が示す順序を規定する。

(2) sort(String[][] table、final OrderBy... orderBys) - 条件として指定した列が指定した順序になるように、表中の行を並べ替える。条件は複数指定できる。並び順の決定には先に指定した条件が優先される。先に指定した条件で並び順が決まらない行については、後に指定した条件を加えて決定する。指定した全ての条件で順序が決まらない行については、並べ替える前の並び順を維持する。

table - 整列対象の表を格納した String 型の配列を要素にもつ配列を指定する。

orderBys - 条件を必要なだけ指定する。

クラス TableSorter の入れ子クラス OrderBy は並べ替えの条件を表すクラスである。フィールド key は順序指定子、フィールド col は比較対象の列の位置を示す数(行を表す String 型配列の添字)である。フィールド isReversed が false であれば、この条件が表す順序が順序指定子 key で指定されるオブジェクトのメソッド compare が返す大小関係での昇順で並べ替えることを意味し、trueであれば、降順で並べ替えることを意味する。

クラス TableSorterTester はテスト用のプログラムである。

実行結果を図2に示す。

apple 3 1,000

apple 2 300

banana 2 2,000

banana 1 300

cherry 1 1,000

図2 実行結果

【プログラム1】

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class TableSorter {
    private Map<a> orderMap = new HashMap<a>();
    
    public void putSortOrder(String key, Comparator order) {
        orderMap.put(key, order);
    }
    
    public void sort(String[][] table, final OrderBy... orderBys) {
        Arrays.sort(table, new Comparator<String[]>() {
            public int compare(String[] s1, String[] s2) {
                for (b) {
                    int order = orderMap.get(orderBy.key).
                                    compare(s1c, s2c);
                    if (order d 0) {
                        return e;
                    }
                }
                return 0;
            }
        });
    }
    
    public static class OrderBy {
        final String key;
        final int col;
        final boolean isReversed;
        
        public OrderBy(String key, int col) {
            this(key, col, false);
        }
        
        public OrderBy(String key, int col, boolean isReversed) {
            this.key = key;
            this.col = col;
            this.isReversed = isReversed;
        }
    }
}

【プログラム2】

import java.util.Comparator;

public class TableSorterTester {
    public static void main(String... args) {
        String[][] data = new String[][] {
            {"apple", "3", "1,000"},
            {"cherry", "1", "1,000"},
            {"banana", "1", "300"},
            {"banana", "2", "2,000"},
            {"apple", "2", "300"},
        };
        TableSorter sorter = new TableSorter();
        sorter.putSortOrder("lex", new Comparator<string>() {
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        sorter.putSortOrder("num", new Comparator<string>() {
            public int compare(String o1, String o2) {
                return new Integer(o1).compareTo(new Integer(o2));
            }
        });
        // α
        sorter.sort(data, new TableSorter.OrderBy("lex", 0), new TableSorter.OrderBy("num", 1, true));
        for (String[] row : data) {
            for(String col : row) {
                System.out.printf("%s ", col);
            }
            System.out.println();
        }
    }
}

設問1

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

a に関する解答群

  • ア:Character, Comparator<string>
  • イ:Character, String
  • ウ:String, Comparator<string>
  • エ:String, String

b に関する解答群

  • ア:int i = 0; i < orderBys.length; i++
  • イ:int i = 0; i < table.length; i++
  • ウ:OrderBy orderBy : orderBys
  • エ:String[] row : table

c に関する解答群

  • ア:.get(col)
  • イ:.get(orderBy.col)
  • ウ:[col]
  • エ:[orderBy.col]

d に関する解答群

  • ア:!=
  • イ:<
  • ウ:==
  • エ:>

e に関する解答群

  • ア:-order
  • イ:order
  • ウ:orderBy.isReversed ? -order : order
  • エ:orderBy.isReversed ? order : -order

設問1 解説

問題文よりプログラムの穴埋めをします。プログラムらしく該当箇所にコメントを入れました。

【プログラム1】

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class TableSorter {
    /*
     * a ウ String, Comparator 
     * orderMapの定義
     * orderMapはputSortOrderメソッド内で定義(put)されている
     * putSortOrderメソッドを見ると、第1引数はString型で、第2引数はComparatorである
     */
    private Map<String, Comparator>; orderMap = new HashMap<String, Comparator>();
    
    public void putSortOrder(String key, Comparator order) {
        // a 第1引数のkeyの型はString, 第2引数のorderの型はComparator
        orderMap.put(key, order);
    }
    
    public void sort(String[][] table, final OrderBy... orderBys) {
        Arrays.sort(table, new Comparator<String[]>;() {
            public int compare(String[] s1, String[] s2) {
                /*
                 * b ウ OrderBy orderBy : orderBys
                 * 問題文より(ソースを見ても)並び替えは複数対応している
                 * orderBysはOrderByクラス
                 * Javaではクラスをそのままループにすることが可能
                 */                 
                for (OrderBy orderBy : orderBys) {
                    int order = orderMap.get(orderBy.key).
                                    /*
                                     * c エ [orderBy.col]
                                     * ソートする際に、同じ列で比較する箇所
                                     * OrderByクラスより、列はcolという変数を利用
                                     * 例
                                     * apple 1 1,000とbanana 2 2,000を0列目で比較
                                     * orderBy.col = 0
                                     */
                                    compare(s1[orderBy.col], s2[orderBy.col]);
                    /*
                     * d ア !=
                     * 並び替えをするかどうかの判定
                     * orderは整数型
                     * compareメソッド返り値がorderとなる
                     * 負 第1引数が小さい
                     * 0 同じ数
                     * 正 第1引数が大きい
                     * 今回は同じ数じゃなければ並び替えするので「0じゃない」となる
                     */
                    if (order != 0) {
                        /*
                         * e ウ orderBy.isReversed ? -order : order
                         * 並び替えをしている箇所
                         * 三項演算子 ? を使っている
                         * trueの場合は:の左(-order)、falseの場合は:の右(order)が実行
                         * 問題文より
                         * isReversedがtrueが降順なので -order
                         * isReversedがfalseが昇順なので order
                        return orderBy.isReversed ? -order : order;
                    }
                }
                return 0;
            }
        });
    }
// 略
}

設問2

プログラム2のαで示した2行を次の2行と入れ替えて実行したとき、実行結果の1行目に出力される内容として正しい答えを、解答群の中から選べ。

sorter.sort(data, new TableSorter.OrderBy("lex", 2), new TableSorter.OrderBy("lex", 0));

解答群

  • ア:apple 2 300
  • イ:apple 3 1,000
  • ウ:banana 1 300
  • エ:banana 2 2,000
  • オ:cherry 1 1,000

設問2 解説

下記のプログラムは何をしようとしているのでしょうか?

sorter.sort(data, new TableSorter.OrderBy("lex", 2), new TableSorter.OrderBy("lex", 0));

TableSorter.OrderBy("lex", 2)

これは、第1引数が「lex」第2引数が2です。

OrderByメソッドで、引数が2つのものを見ると、プログラム1より

 public OrderBy(String key, int col) {
            this(key, col, false);
 }

第1引数 並び替えの設定

第2引数 対象列

であることがわかります。第3引数がない場合は、falseになり、これは「昇順」を意味します(問題文より)。

第1引数の"lex"とは何でしょう?プログラム2のsorter.putSortOrderを見ると

sorter.putSortOrder("lex", new Comparator<string>() {
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});

lexは文字列を比較(compareTo)していることがわかります。よって

sorter.sort(data, new TableSorter.OrderBy("lex", 2), new TableSorter.OrderBy("lex", 0));

は、「2列目を文字列で昇順」し、同じだった場合「0列目を文字列で昇順」とします。

平成29年度秋基本情報技術者試験午後過去問11

2列目を文字列で昇順ソートします。「1,000」「300」「2,000」を文字列として扱い、昇順にソートします。

文字列で昇順すると「1,000」「2,000」「300」の順になります。先頭の文字が「1」「2」「3」だからです。

「1,000」が同じなのでapple 3 1,000 と cherry 1 1,000は同じ並びになります。

次に0列目を文字列で昇順ソートします。appleとcherryだと、appleが先になります。

従って、答えは「イ apple 3 1,000」です!ちなみに結果は下記の通りです。

apple 3 1,000

cherry 1 1,000

banana 2 2,000

apple 2 300

banana 1 300

設問3

プログラム2のαで示した2行を次の8行と入れ替えて実行したとき、実行結果の3行目に出力される内容として正しい答えを、解答群の中から選べ。

sorter.putSortOrder("numC", new Comparator() {
    public int compare(String s1, String s2) {
        return new Integer(s1.replace(",", "")).compareTo(new Integer(s2.replace(",", "")));
    }
});
sorter.sort(data, new TableSorter.OrderBy("numC", 2), new TableSorter.OrderBy("lex", 0));

解答群

  • ア:apple 2 300
  • イ:apple 3 1,000
  • ウ:banana 1 300
  • エ:banana 2 2,000
  • オ:cherry 1 1,000

設問3 解説

設問3では「numC」という設定を追加しています。ソースを見ると下記のことをしています。

・カンマを外す 例 s1.replace(",", "")

・整数型で比較 例 new Integer(s1.replace(",", ""))

従って、カンマを外して数値として取扱いをしていることがわかります。

sorter.sort(data, new TableSorter.OrderBy("numC", 2), new TableSorter.OrderBy("lex", 0));

は、「2列名をカンマを外して数値で昇順し、同じ値だったら0列目を文字列で昇順する」という意味です。

2列目をカンマを外して数値で昇順ソートします。「1,000」「300」「2,000」を「1000」「300」「2000」と数値にし、昇順にソートします。

結果、「300」「1000」「2000」の順になります。先頭は

apple 2 300

banana 1 300

です。

次に0列目を文字列で昇順ソートします。appleとbananaだと、appleが先になります。従って

1行目 apple 2 300

2行目 banana 1 300

となります。続いて、2列は「1000」となるので

apple 3 1,000

cherry 1 1,000

です。

次に0列目を文字列で昇順ソートします。appleとcherryだと、appleが先になります。従って

3行目 apple 3 1,000

4行目 cherry 1 1,000

となります。正解は3行目なので「イ apple 3 1,000」です。最後に

banana 2 2,000

がきます。ソートの結果は下記の通りです。

apple 2 300

banana 1 300

apple 3 1,000

cherry 1 1,000

banana 2 2,000

PR広告

フェイスブックコメント

平成28年度秋 基本情報技術者試験 午後 テキスト・動画解説

平成28年度秋 基本情報技術者試験 午前 テキスト・動画解説

平成28年度春 基本情報技術者試験 午後 テキスト・動画解説

平成28年度春 基本情報技術者試験 午前 テキスト・動画解説

平成27年度秋 基本情報技術者試験 午後 テキスト・動画解説

平成27年度春 基本情報技術者試験 午後 テキスト・動画解説

平成27年度春 基本情報技術者試験 午前 テキスト・動画解説

平成26年度秋 基本情報技術者試験 午前 テキスト・動画解説

平成26年度春 基本情報技術者試験 午前 テキスト・動画解説