-------------------------------------------------
/**
* 10. （基本選択法）
* 要素数10のint型配列aにデータが入っている。
* この配列要素を昇順に並べ替える。
* （参考：午前中のテキストp.63の基本選択法を使う）
*/
public class Quiz1708 {
public static void main(String[] args) {
int[] a = {50, 30, 90, 40, 100, 10, 20, 60, 80, 70, };
// 表示する
System.out.print("整列前 = ");
print(a);
// 整列する
sort(a);
// 表示する
System.out.print("整列後 = ");
print(a);
}
/**
* 指定された配列を昇順に並べ替える。
* @param a 配列
*/
static void sort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
// 最大値を持つ添字を探す
int maxIndex = 0; // 最大値を持つ添字
for (int j = 0; j < a.length - i - 1; j++) {
if (a[j] > a[maxIndex]) {
maxIndex = j;
}
}
// 最大値を持つ添字を範囲の最後と交換する
if (a[a.length - i - 1] < a[maxIndex]) {
int w = a[a.length - i - 1];
a[a.length - i - 1] = a[maxIndex];
a[maxIndex] = w;
}
}
}
/**
* 指定された配列aの各要素を並べて表示する。
* @param a 配列
*/
static void print(int[] a) {
System.out.print("[");
for (int i = 0; i < a.length - 1; i++) {
System.out.print(a[i] + ", ");
}
if (a.length > 0) {
System.out.print(a[a.length - 1]);
}
System.out.println("]");
}
}
/* 実行結果
整列前 = [50, 30, 90, 40, 100, 10, 20, 60, 80, 70, ]
整列後 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, ]
*/
-------------------------------------------------
/**
* 13. （文字列探索 － BM法） char型配列textにデータが入っている。
* この文字配列textの中に、パターン文字列(char型配列pattern)を探索する。
* あった場合は、patternの先頭文字と一致するtextの添字を返す。
* ない場合は、-1を返す。 （参考：午前中のテキストp.67のBM法を使う）
*/
public class Quiz1709 {
public static void main(String[] args) {
// テキスト
String textString = "PQACZXYZRXYZ";
char[] text = textString.toCharArray();
// パターン
String patternString = "XYZ";
char[] pattern = patternString.toCharArray();
// 表示する
System.out.println("テキスト = [" + textString + "]");
System.out.println("パターン = [" + patternString + "]");
// 探索する
int index = indexOf(text, pattern);
// 結果を表示する
System.out.print("index = " + index);
}
/**
* @param text
* @param pattern
* @return
*/
static int indexOf(char[] text, char[] pattern) {
// スキップ表を作る
int[] skip = new int[256];
// デフォルト値を設定する
for (int i = 0; i < skip.length; i++) {
skip[i] = pattern.length;
}
// スキップ数を設定する
for (int i = 0; i < pattern.length - 1; i++) {
skip[pattern[i]] = pattern.length - i - 1;
}
// 探索する
int index = -1;
int i = 0;
search: while (i <= text.length - pattern.length) {
// パターンを後ろから見ていく
int j;
for (j = pattern.length - 1; (j >= 0) && (text[i + j] == pattern[j]); j--) {
}
// すべて一致すれば見つかった
if (j < 0) {
index = i;
break search;
}
// 次の位置までスキップする
int k = skip[text[i + j]] - (pattern.length - j - 1);
if (k > 0) {
i += k;
} else {
i += 1;
}
}
return index;
}
}
/*
実行例
テキスト = [PQACZXYZRXYZ]
パターン = [XYZ]
index = 5
テキスト = [PQACZXYZRXYZ]
パターン = [XYZW]
index = -1
*/
-------------------------------------------------
import java.util.Scanner;
/**
* Quiz0904で、じゃんけんの勝敗表（2次
* 元配列）をつくり、勝負するロジックを簡単
* にする。
* また、指定した手も、数字ではなく、日本語
* 表記（グー、チョキ、パー）で表示すること。
* --------- ------- -------- --------
* 勝敗表 0 グー 1 チョキ 2 パー
* --------- ------- -------- --------
* 0 グー 引分け 勝ち 負け
* 1 チョキ 負け 引分け 勝ち
* 2 パー 勝ち 負け 引分け
* --------- ------- -------- --------
*/
public class Quiz1710 {
public static void main(String[] args) {
String[] HAND = {"グー", "チョキ", "パー"};
String[] JUDGE = {" あなたの負けです。", " 引き分けです。", " あなたの勝ちです。"};
// 標準入力を準備する
Scanner sin = new Scanner(System.in);
// じゃんけんの手を入力する
System.out.print("じゃんけんの手(0:グー、 1:チョキ、 2:パー )を入力してください => ");
int userTe = sin.nextInt(); // 標準入力から手を入力する
int computerTe = (int) (Math.random() * 3); // コンピューターの手
// 勝負する
int judge = judge(userTe, computerTe); // 勝敗結果 -1: 負け、0: 引分け、1: 勝ち
// 結果を表示する
System.out.print("あなた: " + HAND[userTe] + ", コンピューター: " + HAND[computerTe]);
System.out.println(JUDGE[judge + 1]);
}
/**
* 2つのじゃんけんの手の勝負結果を返す。
* @param te1 手1
* @param te2 手2
* @return 手1が負けたとき-1、引分けのとき0、勝ったとき1
*/
static int judge(int te1, int te2) {
int[][] JUDGE = {
{ 0, 1, -1}, // ぐー
{-1, 0, 1}, // ちょき
{ 1, -1, 0}, // ぱー
};
return JUDGE[te1][te2];
}
}
/* 実行結果例
じゃんけんの手(0:グー、 1:チョキ、 2:パー )を入力してください => 0
あなた: グー, コンピューター: グー 引き分けです。
*/
-------------------------------------------------
import java.util.Scanner;
/**
* 23．重さに対する料金を出す。
* 6×2の配列の、1列目に重さ、2列目に料金が
* 入っている。
* なお、重さは、下の表では以下をあらわす。
* たとえば、200gに対しては、190円になる。
* 2000gより重い場合は、一律に2000円とする
*
* ------- ----
* 重さ 料金
* ------- ----
* [0] 100 100
* [1] 200 190
* [2] 400 370
* [3] 600 550
* [4] 1000 900
* [5] 2000 1700
* ------- ----
*/
public class Quiz1711 {
public static void main(String[] args) {
String buffer; // データを入力するバッファー
int WEIGHT_RATE[][] = { // 重量-料金表
{ 100, 100},
{ 200, 190},
{ 400, 370},
{ 600, 550},
{1000, 900},
{2000, 1700},
};
int weight; // 重量
// 標準入力を設定する
Scanner in = new Scanner(System.in);
// データを入力する。
System.out.printf("重量を入力してください。");
buffer = in.nextLine();
weight = Integer.parseInt(buffer);
// 料金を引く
int rate = rate(WEIGHT_RATE, weight);
// 結果を表示する
System.out.println(weight + " g の料金は " + rate + " 円です。");
}
/**
* 料金表と重さを渡して、その重さに対する料金を返す。
* @param rateTable 料金表
* @param weight 重さ
* @return 重さに対する料金。表にない場合は、2000．
*/
private static int rate(int[][] rateTable, int weight) {
for (int i = 0; i < rateTable.length; i++) {
if (weight <= rateTable[i][0]) {
return rateTable[i][1];
}
}
return 2000;
}
}
/* 実行結果例
>java Quiz1711
重量を入力してください。50
50 g の料金は 100 円です。
>java Quiz1711
重量を入力してください。100
100 g の料金は 100 円です。
>java Quiz1711
重量を入力してください。150
150 g の料金は 190 円です。
>java Quiz1711
重量を入力してください。2000
2000 g の料金は 1700 円です。
>java Quiz1711
重量を入力してください。2001
2001 g の料金は 2000 円です。
*/
-------------------------------------------------
1. BMI を計算するメソッド
(参考: Quiz0602.java)
static double bmi(double height, double weight)
2. int型配列の要素を順に表示するメソッド。
static void print(int[] a)
3. 配列aの各要素を1つずらした配列を返す
メソッド。(参考: Quiz1603.java)
a[0]→b[1]、a[1]→b[2]、・・・
a[8]→b[9]、a[9]→b[0]
static int[] rotate(int[] a)
int型配列の要素を順に並べて文字列化する
メソッド。
static String toString(int[] a)
4．西暦年yearを渡して、その年がうるう年
かどうかを判断するメソッド。
(参考: Quiz0704.java)
static boolean isLeap(int year)
5．月(1～12)monthを渡して、その月の日数
を返すメソッド。
(参考: Quiz1606.java)
static int daysOf(int month)
6. （線形探索）
int型配列aとint型データを渡して、その
データが配列要素にあれば、そのときの添字
を返すメソッド。なければ、-1を返す。
(参考: Quiz1607.java)
static int sequentialSearch(int[] a, int data)
7. （二分探索）
int型配列aとint型データを渡して、その
データが配列要素にあれば、そのときの添字
を返すメソッド。なければ、-1を返す。
(参考: Quiz1608.java)
static int binarySearch(int[] a, int data)
8. （整列）
int型配列aを順番に並べ替えるメソッド。
アルゴリズムは、基本交換法、基本選択法、
基本挿入法のいずれを使ってもよい。
(参考: Quiz1609.java、 Quiz1610.java、
Quiz1611.java)
static void sort(int[] a)
9. （文字列探索）
char型配列textにデータが入っている。
この文字配列textの中に、パターン文字列
(char型配列pattern)を探索するメソッド。
あった場合は、patternの先頭文字と一致す
るtextの添字を返す。ない場合は、-1を返す。
アルゴリズムは、力まかせ探索法、BM法のい
ずれを使ってもよい。
(参考: Quiz1612.java、 Quiz1613.java)
static int indexOf(char[] text, char[] pattern)
10. じゃんけんの手を2つ渡して、勝敗を返
すメソッド。
第1引数が勝った場合1、引分け0、負けた場
合-1を返す。
(参考: Quiz1621.java)
static int judge(int te1, int te2)
11．料金表と重さを渡して、その重さに対す
る料金を返す。
(参考: Quiz1623.java)
static int rate(int[][] rateTable, int weight)
-------------------------------------------------
/**
* BMI を計算し、表示する。
* 体重 / 身長の2乗
*/
public class Quiz1701 {
public static void main(String[] args) {
System.out.println("BMI = " + bmi(1.62, 55));
}
static double bmi(double height, double weight) {
return weight / (Math.pow(height, 2));
}
}
/* 実行結果
BMI = 20.957171162932475
*/
-------------------------------------------------
/**
* 配列aの各要素を1つずらして、配列bにコピーする。
* a[0]→b[1]、a[1]→b[2]、・・・ a[8]→b[9]、a[9]→b[0]
*/
public class Quiz1703 {
public static void main(String[] args) {
int[] a = {5, 3, 7, 9, 0, 1, 2, 8, 4, 6, };
int[] b = new int[a.length];
// 表示する。
System.out.print("a = ");
print(a);
// ずらしてコピーする。
b = rotate(a);
// 表示する。
System.out.print("b = ");
print(b);
}
/**
* 指定された配列aの各要素を1つずらして、新しい配列を作って返す。
* @param a 配列
* @return 要素を1つずらした配列
*/
static int[] rotate(int[] a) {
int[] b = new int[a.length];
for (int i = 0; i
b[(i + 1) % b.length] = a[i];
}
return b;
}
/**
* 指定された配列aの各要素を並べて表示する。
* @param a 配列
*/
static void print(int[] a) {
System.out.print("[");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
if (a.length > 0) {
System.out.print(a[a.length - 1]);
}
System.out.println("]");
}
}
/*
a = [5, 3, 7, 9, 0, 1, 2, 8, 4, 6]
b = [6, 5, 3, 7, 9, 0, 1, 2, 8, 4]
*/
-------------------------------------------------
/**
* 西暦年を指定し、この西暦年がうるう年かどうかを表示する
* 西暦年が4の倍数ならうるう年
* 上記の条件でも、100の倍数なら平年
* 上記の条件でも、400の倍数ならうるう年
* どの条件にも当てはまらなければ平年
*/
public class Quiz1704 {
public static void main(String[] args) {
int year = 2010; // 西暦年
// 結果を表示する
if (isLeap(year)) {
System.out.println(year + " 年はうるう年です。");
} else {
System.out.println(year + " 年は平年です。");
}
}
/**
* 西暦年を指定し、この西暦年がうるう年かどうかを判断する。
* @param year 西暦年
* @return うるうどしのときtrue、平年のときfalse
*/
static boolean isLeap(int year) {
return (year % 400 == 0) || ((year % 100 != 0) && (year % 4 == 0));
}
}
/* 実行結果
2010 年は平年です。
*/
/* 疑似コード
*/
-------------------------------------------------
/**
* 月(1～12)を指定して、その月の日数を表示する
*/
public class Quiz1705 {
public static void main(String[] args) {
int month = 6; // 月
// 結果を表示する
System.out.println(month + " 月は " + daysOf(month) + " 日です。");
}
/**
* 月(1～12)を指定して、その月の日数を返す。
* @param month 月
* @return 指定された月の日数
*/
static int daysOf(int month) {
int[] DAYS = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
return DAYS[month - 1];
}
}
/* 実行結果
6 月は 30 日です。
*/
-------------------------------------------------
/**
* 7. （線形探索）
* 要素数10のint型配列aにデータが入っている。
* コマンドライン引数で、整数値を指定して、その数値が配列要素にあるかどうか、
* あれば、そのときの添字を表示する。
* （参考：午前中のテキストp.58の線形探索）
*/
public class Quiz1706 {
public static void main(String[] args) {
int key = Integer.parseInt(args[0]);
int[] a = {50, 30, 90, 40, 100, 10, 20, 60, 80, 70, };
// 探索する
int index = sequentialSearch(a, key);
// 結果を表示する
if (index >= 0) {
System.out.println(key + " はありました。(index = " + index + ")");
} else {
System.out.println(key + " はありませんでした。");
}
}
/**
* 指定された配列の中から、指定されたデータを探す。
* @param a 被検索の配列
* @param key 検索データ
* @return 見つかった場合、その添字、見つからなかった場合-1
*/
static int sequentialSearch(int[] a, int key) {
for (int i = 0; i
if (a[i] == key) {
return i;
}
}
return -1;
}
}
/* 実行結果
>java Quiz1706 10
10 はありました。(index = 5)
>java Quiz1706 50
50 はありました。(index = 0)
>java Quiz1706 70
70 はありました。(index = 9)
>java Quiz1706 55
55 はありませんでした。
*/
-------------------------------------------------
/**
* 7. （二分探索）
* 要素数10のint型配列aにデータが入っている。このとき、要素の値は昇順に入っている。
* コマンドライン引数で、整数値を指定して、その数値が配列要素にあるかどうか、
* あれば、そのときの添字を表示する。
* （参考：午前中のテキストp.58の二分探索）
*/
public class Quiz1707 {
public static void main(String[] args) {
int key = Integer.parseInt(args[0]);
int[] a = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, };
// 探索する
int index = binarySearch(a, key);
// 結果を表示する
if (index >= 0) {
System.out.println(key + " はありました。(index = " + index + ")");
} else {
System.out.println(key + " はありませんでした。");
}
}
/**
* 指定された配列の中から、指定されたデータを探す。
* @param a 被検索の配列。要素は昇順にソートされていなければならない。
* @param key 検索データ
* @return 見つかった場合、その添字、見つからなかった場合-1
*/
static int binarySearch(int[] a, int key) {
int lowerIndex = 0;
int upperIndex = a.length - 1;
int middleIndex;
while (lowerIndex <= upperIndex) {
middleIndex = (lowerIndex + upperIndex) / 2;
if (a[middleIndex] <key) { key) {
upperIndex = middleIndex - 1;
} else {
return middleIndex;
}
}
return -1;
}
}
/* 実行結果
>java Quiz1707 10
10 はありました。(index = 0)
>java Quiz1707 50
50 はありました。(index = 4)
>java Quiz1707 100
100 はありました。(index = 9)
>java Quiz1707 55
55 はありませんでした。
*/
-------------------------------------------------
--------------------------------------------------
import java.util.Scanner;
/**
* Quiz0904で、じゃんけんの勝敗表（2次
* 元配列）をつくり、勝負するロジックを簡単
* にする。
* また、指定した手も、数字ではなく、日本語
* 表記（グー、チョキ、パー）で表示すること。
* --------- ------- -------- --------
* 勝敗表 0 グー 1 チョキ 2 パー
* --------- ------- -------- --------
* 0 グー 引分け 勝ち 負け
* 1 チョキ 負け 引分け 勝ち
* 2 パー 勝ち 負け 引分け
* --------- ------- -------- --------
*/
public class Quiz1621 {
public static void main(String[] args) {
String[] HAND = {"グー", "チョキ", "パー"};
int[][] JUDGE = {
{ 0, 1, -1}, // ぐー
{-1, 0, 1}, // ちょき
{ 1, -1, 0}, // ぱー
};
// 標準入力を準備する
Scanner sin = new Scanner(System.in);
// じゃんけんの手を入力する
System.out.print("じゃんけんの手(0:グー、 1:チョキ、 2:パー )を入力してください => ");
int userTe = sin.nextInt(); // 標準入力から手を入力する
int computerTe = (int) (Math.random() * 3); // コンピューターの手
// 勝負する
int judge = JUDGE[userTe][computerTe]; // 勝敗結果 -1: 負け、0: 引分け、1: 勝ち
// 結果を表示する
System.out.print("あなた: " + HAND[userTe] + ", コンピューター: " + HAND[computerTe]);
if (judge == 0) {
System.out.println(" 引き分けです。");
} else if (judge > 0) {
System.out.println(" あなたの勝ちです。");
} else {
System.out.println(" あなたの負けです。");
}
}
}
--------------------------------------------------
import java.util.Scanner;
/**
* 1000円でお釣りをもらう。お釣りの硬貨は最低枚数とする。
* 6×2の配列の、2列目に、それぞれのお釣りの枚数を入れるアルゴリズムを作りなさい
* 1列目には硬貨の種類があらかじめ入っているものとする。
*/
public class Quiz1622 {
public static void main(String[] args) {
String buffer; // データを入力するバッファー
int coins[][] = { // 硬貨を数える配列
{1, 0},
{5, 0},
{10, 0},
{50, 0},
{100, 0},
{500, 0},
};
int mony; // 金額
int change; // お釣り
// 標準入力を設定する
Scanner in = new Scanner(System.in);
// データを入力する。
System.out.printf("金額を入力してください。");
buffer = in.nextLine();
mony = Integer.parseInt(buffer);
// お釣り
change = 1000 - mony;
System.out.println("金額は " + mony + " 円、お釣りは " + change + " 円です。");
// 枚数を数える
for (int i = coins.length - 1; i >= 0; i--) {
coins[i][1] = change / coins[i][0];
change %= coins[i][0];
}
// 枚数を表示する
for (int i = 0; i < coins.length; i++) {
System.out.println(coins[i][0] + " 円硬貨は " + coins[i][1] + " 枚です。");
}
}
}
--------------------------------------------------
import java.util.Scanner;
/**
* 23．重さに対する料金を出す。
* 6×2の配列の、1列目に重さ、2列目に料金が
* 入っている。
* なお、重さは、下の表では以下をあらわす。
* たとえば、200gに対しては、190円になる。
* 2000gより重い場合は、一律に2000円とする
*
* ------- ----
* 重さ 料金
* ------- ----
* [0] 100 100
* [1] 200 190
* [2] 400 370
* [3] 600 550
* [4] 1000 900
* [5] 2000 1700
* ------- ----
*/
public class Quiz1623 {
public static void main(String[] args) {
String buffer; // データを入力するバッファー
int WEIGHT_RATE[][] = { // 重量-料金表
{ 100, 100},
{ 200, 190},
{ 400, 370},
{ 600, 550},
{1000, 900},
{2000, 1700},
};
int weight; // 重量
// 標準入力を設定する
Scanner in = new Scanner(System.in);
// データを入力する。
System.out.printf("重量を入力してください。");
buffer = in.nextLine();
weight = Integer.parseInt(buffer);
// 料金を引く
int rate = 2000; // 料金
for (int i = 0; i < WEIGHT_RATE.length; i++) {
if (weight <= WEIGHT_RATE[i][0]) {
rate = WEIGHT_RATE[i][1];
break;
}
}
// 結果を表示する
System.out.println(weight + " g の料金は " + rate + " 円です。");
}
}
--------------------------------------------------
--------------------------------------------------
/**
* 9. （基本交換法）
* 要素数10のint型配列aにデータが入っている。
* この配列要素を昇順に並べ替える。
* （参考：午前中のテキストp.62の基本交換法を使う）
*/
public class Quiz1609 {
public static void main(String[] args) {
int[] a = {50, 30, 90, 40, 100, 10, 20, 60, 80, 70, };
// 表示する
System.out.print("整列前 = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
// 整列する
for (int i = 0; i
for (int j = 0; j
if (a[j] > a[j + 1]) {
int w = a[j];
a[j] = a[j + 1];
a[j + 1] = w;
}
}
}
// 表示する
System.out.print("整列後 = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
}
}
/* 実行結果
整列前 = [50, 30, 90, 40, 100, 10, 20, 60, 80, 70, ]
整列後 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, ]
*/
--------------------------------------------------
/**
* 10. （基本選択法）
* 要素数10のint型配列aにデータが入っている。
* この配列要素を昇順に並べ替える。
* （参考：午前中のテキストp.63の基本選択法を使う）
*/
public class Quiz1610 {
public static void main(String[] args) {
int[] a = {50, 30, 90, 40, 100, 10, 20, 60, 80, 70, };
// 表示する
System.out.print("整列前 = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
// 整列する
for (int i = 0; i
// 最大値を持つ添字を探す
int maxIndex = 0; // 最大値を持つ添字
for (int j = 0; j
if (a[j] > a[maxIndex]) {
maxIndex = j;
}
}
// 最大値を持つ添字を範囲の最後と交換する
if (a[a.length - i - 1]
int w = a[a.length - i - 1];
a[a.length - i - 1] = a[maxIndex];
a[maxIndex] = w;
}
}
// 表示する
System.out.print("整列後 = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
}
}
/* 実行結果
整列前 = [50, 30, 90, 40, 100, 10, 20, 60, 80, 70, ]
整列後 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, ]
*/
--------------------------------------------------
/**
* 11. （基本挿入法） 要素数10のint型配列aにデータが入っている。 この配列要素を昇順に並べ替える。
* （参考：午前中のテキストp.63の基本挿入法を使う）
*/
public class Quiz1611 {
public static void main(String[] args) {
int[] a = {50, 30, 90, 40, 100, 10, 20, 60, 80, 70, };
// 表示する
System.out.print("整列前 = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
// 整列する
for (int i = 1; i
int w = a[i];
if (a[i - 1] > w) {
// 挿入位置までずらす
int j = i;
for (j = i; (j > 0) && (a[j - 1] > w); j--) {
a[j] = a[j - 1];
}
a[j] = w;
}
}
// 表示する
System.out.print("整列後 = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
}
}
/*
* 実行結果
整列前 = [50, 30, 90, 40, 100, 10, 20, 60, 80, 70, ]
整列後 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, ]
*/
--------------------------------------------------
/**
* 12. （文字列探索 － 力まかせ探索法） char型配列textにデータが入っている。
* この文字配列textの中に、パターン文字列(char型配列pattern)を探索する。
* あった場合は、patternの先頭文字と一致するtextの添字を返す。 ない場合は、-1を返す。
* （参考：午前中のテキストp.66の力まかせ探索法を使う）
*/
public class Quiz1612 {
public static void main(String[] args) {
String textString = "PQACZXYZRXYZ";
char[] text = textString.toCharArray();
String patternString = "XYZ";
char[] pattern = patternString.toCharArray();
// 表示する
System.out.println("テキスト = [" + textString + "]");
System.out.println("パターン = [" + patternString + "]");
// 探索する
int index = -1;
search:
for (int i = 0; i <text.length - pattern.length + 1; i++) {
// パターンを後ろから見ていく
int j;
for (j = pattern.length - 1; (j >= 0) && (text[i + j] == pattern[j]); j--) {
}
// すべて一致すれば見つかった
if (j <0) { 0) {
i += k;
} else {
i += 1;
}
}
// 結果を表示する
System.out.print("index = " + index);
}
}
/*
* 実行例 テキスト = [PQACZXYZRXYZ] パターン = [XYZ] index = 5
*
* テキスト = [PQACZXYZRXYZ] パターン = [XYZW] index = -1
*/
--------------------------------------------------
1. 10個の要素を持つ配列a、bがある。
配列aの各要素をすべて配列bにコピーする。
2. 配列aの各要素を逆に配列bにコピーする。
a[0]→b[9]、a[1]→b[8]、・・・ a[9]→b[0]
3. 配列aの各要素を1つずらして、配列bにコピーする。
a[0]→b[1]、a[1]→b[2]、・・・
a[8]→b[9]、a[9]→b[0]
4. 配列aの各要素を逆にする。[オプション]
a[0]⇔a[9]、a[1]⇔a[8]、・・・a[4]⇔a[5]
5. 配列aの各要素を1つずつずらす。[オプション]
a[0]→a[1]→a[2]・・・ →a[9]→a[0]
6．配列DAYSには、つぎの初期値が順番に入っている。
int[] DAYS = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
これを使い、Quiz0705.java
「月(1～12)monthを入力して、その月の日数を表示する」
を改良する。
7. （線形探索）
要素数10のint型配列aにデータが入っている。
コマンドライン引数で、整数値を指定して、
その数値が配列要素にあるかどうか、
あれば、そのときの添字を表示する。
（参考：午前中のテキストp.58の線形探索）
8. （二分探索）
要素数10のint型配列aにデータが入っている。
このとき、要素の値は昇順に入っている。
コマンドライン引数で、整数値を指定して、
その数値が配列要素にあるかどうか、あれば、
そのときの添字を表示する。
（参考：午前中のテキストp.59の二分探索）
9. （基本交換法）
要素数10のint型配列aにデータが入っている。
この配列要素を昇順に並べ替える。
（参考：午前中のテキストp.62の基本交換法を使う）
10. （基本選択法）
要素数10のint型配列aにデータが入っている。
この配列要素を昇順に並べ替える。
（参考：午前中のテキストp.63の基本選択法を使う）
11. （基本挿入法）
要素数10のint型配列aにデータが入っている。
この配列要素を昇順に並べ替える。
（参考：午前中のテキストp.63の基本挿入法を使う）
12. （文字列探索 － 力まかせ探索法）
char型配列textにデータが入っている。
この文字配列textの中に、パターン文字列
(char型配列pattern)を探索する。あった場
合は、patternの先頭文字と一致するtextの
添字を返す。ない場合は、-1を返す。
（参考：午前中のテキストp.66の力まかせ探索法を使う）
（参考）Stringからchar配列を定義する例
String textString = "PQACZXYZRXYZ";
char[] text = textString.toCharArray();
13. （文字列探索 － BM法）
char型配列textにデータが入っている。
この文字配列textの中に、パターン文字列
(char型配列pattern)を探索する。あった場
合は、patternの先頭文字と一致するtextの
添字を返す。ない場合は、-1を返す。
（参考：午前中のテキストp.67のBM法を使う）
（2次元配列）
21. Quiz0904で、じゃんけんの勝敗表（2次
元配列）をつくり、勝負するロジックを簡単
にする。
また、指定した手も、数字ではなく、日本語
表記（グー、チョキ、パー）で表示すること。
--------- ------- -------- --------
勝敗表 0 グー 1 チョキ 2 パー
--------- ------- -------- --------
0 グー 引分け 勝ち 負け
1 チョキ 負け 引分け 勝ち
2 パー 勝ち 負け 引分け
--------- ------- -------- --------
22．金額を入力して、1000円でお釣りをもら
う。お釣りの硬貨は最低枚数とする。
6×2の配列coinsの、2列目に、それぞれのお
釣りの枚数を入れるアルゴリズムを作る。
1列目には硬貨の種類があらかじめ入ってい
るものとする。
------- ----------
硬貨 お釣り枚数
------- ----------
[0] 1
[1] 5
[2] 10
[3] 50
[4] 100
[5] 500
------- ----------
23．重さに対する料金を出す。
6×2の配列の、1列目に重さ、2列目に料金が
入っている。
なお、重さは、下の表では以下をあらわす。
たとえば、200gに対しては、190円になる。
2000gより重い場合は、一律に2000円とする
------- ----
重さ 料金
------- ----
[0] 100 100
[1] 200 190
[2] 400 370
[3] 600 550
[4] 1000 900
[5] 2000 1700
------- ----
--------------------------------------------------
/**
* 10個の要素を持つ配列a、bがある。
* 配列aの各要素をすべて配列bにコピーする。
*/
public class Quiz1601 {
public static void main(String[] args) {
int[] a = {5, 3, 7, 9, 0, 1, 2, 8, 4, 6, };
int[] b = new int[a.length];
// 表示する。
System.out.print("a = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
// コピーする。
for (int i = 0; i
b[i] = a[i];
}
// 表示する。
System.out.print("b = [");
for (int i = 0; i
System.out.print(b[i] + ", ");
}
System.out.println("]");
}
}
--------------------------------------------------
/**
* 配列aの各要素を逆に配列bにコピーする。
* a[0]→b[9]、a[1]→b[8]、・・・ a[9]→b[0]
*/
public class Quiz1602 {
public static void main(String[] args) {
int[] a = {5, 3, 7, 9, 0, 1, 2, 8, 4, 6, };
int[] b = new int[a.length];
// 表示する。
System.out.print("a = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
// 逆順にコピーする。
for (int i = 0; i
b[a.length - i - 1] = a[i];
}
// 表示する。
System.out.print("b = [");
for (int i = 0; i
System.out.print(b[i] + ", ");
}
System.out.println("]");
}
}
--------------------------------------------------
/**
* 配列aの各要素を1つずらして、配列bにコピーする。
* a[0]→b[1]、a[1]→b[2]、・・・ a[8]→b[9]、a[9]→b[0]
*/
public class Quiz1603 {
public static void main(String[] args) {
int[] a = {5, 3, 7, 9, 0, 1, 2, 8, 4, 6, };
int[] b = new int[a.length];
// 表示する。
System.out.print("a = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
// ずらしてコピーする。
for (int i = 0; i
b[(i + 1) % b.length] = a[i];
}
// 表示する。
System.out.print("b = [");
for (int i = 0; i
System.out.print(b[i] + ", ");
}
System.out.println("]");
}
}
--------------------------------------------------
/**
* 配列aの各要素を逆にする。(オプション)
* a[0]⇔a[9]、a[1]⇔a[8]、・・・a[4]⇔a[5]
*/
public class Quiz1604 {
public static void main(String[] args) {
int[] a = {5, 3, 7, 9, 0, 1, 2, 8, 4, 6, };
// 表示する。
System.out.print("before = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
// 逆にする。
for (int i = 0; i
int w = a[i];
a[i] = a[a.length - i - 1];
a[a.length - i - 1] = w;
}
// 表示する。
System.out.print(" after = [");
for (int i = 0; i
System.out.print(a[i] + ", ");
}
System.out.println("]");
}
}
--------------------------------------------------
/**
* 配列aの各要素を1つずつずらす。(オプション)
* a[0]→a[1]→a[2]・・・ →a[9]→a[0]
*/
public class Quiz1605 {
public static void main(String[] args) {
int[] a = {5, 3, 7, 9, 0, 1, 2, 8, 4, 6, };
// 表示する。
System.out.print("before = [");
for (int i = 0; i
System.out.printf("%d, ", a[i]);
}
System.out.println("]");
// ずらす。
int w = a[a.length - 1];
for (int i = a.length - 1; i > 0; i--) {
a[i] = a[i - 1];
}
a[0] = w;
// 表示する。
System.out.print(" after = [");
for (int i = 0; i
System.out.printf("%d, ", a[i]);
}
System.out.println("]");
}
}
--------------------------------------------------
/**
* 月(1～12)を指定して、その月の日数を表示する
*/
public class Quiz1606 {
public static void main(String[] args) {
int month = 6; // 月
int[] DAYS = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
// 結果を表示する
System.out.println(month + " 月は " + DAYS[month - 1] + " 日です。");
}
}
/* 実行結果
6 月は 30 日です。
*/
--------------------------------------------------
/**
* 7. （線形探索）
* 要素数10のint型配列aにデータが入っている。
* コマンドライン引数で、整数値を指定して、その数値が配列要素にあるかどうか、
* あれば、そのときの添字を表示する。
* （参考：午前中のテキストp.58の線形探索）
*/
public class Quiz1607 {
public static void main(String[] args) {
int key = Integer.parseInt(args[0]);
int[] a = {50, 30, 90, 40, 100, 10, 20, 60, 80, 70, };
// 探索する
int index = -1;
for (int i = 0; i
if (a[i] == key) {
index = i;
break;
}
}
// 結果を表示する
if (index >= 0) {
System.out.println(key + " はありました。(index = " + index + ")");
} else {
System.out.println(key + " はありませんでした。");
}
}
}
/* 実行結果
>java Quiz1607 10
10 はありました。(index = 5)
>java Quiz1607 50
50 はありました。(index = 0)
>java Quiz1607 70
70 はありました。(index = 9)
>java Quiz1607 55
55 はありませんでした。
*/
--------------------------------------------------
/**
* 7. （二分探索）
* 要素数10のint型配列aにデータが入っている。このとき、要素の値は昇順に入っている。
* コマンドライン引数で、整数値を指定して、その数値が配列要素にあるかどうか、
* あれば、そのときの添字を表示する。
* （参考：午前中のテキストp.58の二分探索）
*/
public class Quiz1608 {
public static void main(String[] args) {
int key = Integer.parseInt(args[0]);
int[] a = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, };
// 探索する
int index = -1;
int lowerIndex = 0;
int upperIndex = a.length - 1;
int middleIndex;
while (lowerIndex <= upperIndex) {
middleIndex = (lowerIndex + upperIndex) / 2;
if (a[middleIndex] <key) { key) {
upperIndex = middleIndex - 1;
} else {
index = middleIndex;
break;
}
}
// 結果を表示する
if (index >= 0) {
System.out.println(key + " はありました。(index = " + index + ")");
} else {
System.out.println(key + " はありませんでした。");
}
}
}
/* 実行結果
>java Quiz1608 10
10 はありました。(index = 0)
>java Quiz1608 50
50 はありました。(index = 4)
>java Quiz1608 100
100 はありました。(index = 9)
>java Quiz1608 55
55 はありませんでした。
*/
--------------------------------------------------
完全合格 応用情報技術者 午前問題集
http://ascii.asciimw.jp/books/books/detail/978-4-04-868358-6.shtml
著者： 林裕幸、末石吾朗、畠山弘行、野口庄一
定価：1,974円 (本体1,880円)
発売日：2010/07/09
形態：A5 (488ページ)
付属品：折込付録:解答用紙、解答一覧
ISBN：978-4-04-868358-6
http://ascii.asciimw.jp/books/books/detail/978-4-04-868358-6.shtml
著者： 林裕幸、末石吾朗、畠山弘行、野口庄一
定価：1,974円 (本体1,880円)
発売日：2010/07/09
形態：A5 (488ページ)
付属品：折込付録:解答用紙、解答一覧
ISBN：978-4-04-868358-6