Report 2a
b1910586 2a:△ Tue May 19 15:40:15 2020
提出日時：2020/05/19
［課題］
演習1.e 配列に加えて整数2つを受け取り1つを返す関数へのポインタを
受け取り、それを用いて配列の値を集約した結果を返す関数int iarray
inject(int*a, int n, int (*fp)(int, int))を作成する。さらにそれ
を用いて、「配列の合計値」「配列の最大値」を求める。
［ソース］
#include <stdio.h>
#include <stdbool.h>
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iadd(int x, int y) {
return x + y;
}
int imax(int x, int y) {
return x > y ? x : y;
}
int iarray_inject(int*a, int n, int (*fp)(int, int)) {
int res = a[0];
for (int i = 1; i < n; i++) {
res = fp(res, a[i]);
}
return res;
}
int main(void) {
int a5[] = {8,5,2,4,1};
expect_int(iarray_inject(a5, 5, iadd), 20, "8+5+2+4+1");
expect_int(iarray_inject(a5, 5, imax), 8, "max(8,5,2,4,1)");
return 0;
}
［実行例］
OK 20:20 8+5+2+4+1
OK 8:8 max(8,5,2,4,1)
［説明］
配列の最初の要素の値をresに格納し、2番目から最後までのループでfp
にresと配列の要素を渡し、fpをコールし、集約を行う。最後にresを返
す。
［レビュー課題］
コードが短くまとまっていて見やすい、関数のポインタもうまく使えていていいと思う
［アンケート］
Q1. アドレス、ポインタについて納得しましたか。
はい。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
はい。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
特にないです。授業の高度な内容に取り組みたいです。
「テストケースは増やしてみること」が行われていない。おつかれ様です。
f1810567 2a:○ Tue May 19 15:16:54 2020
提出日付:5/19
演習1a 配列の最大値を求める関数を作成する
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max = *a;
for(int i=1; i<n; ++i){
if(*(a+i) >= max){
max = *(a+i);
}
return max;
}
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1,4), -2, "-3 -2 -4");
}
配列aの先頭の値を*aで参照してmaxに入れておく。あとは1番目の要素
から順にmaxの値と比較していって、maxより大きい値だったらその値を
新たなmaxとする。
・実行例
OK 9:9 9 0 0 1 2 3
NG 0:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
・レビュー
配列の全ての要素をもれなく比較しているか確認するテストコードをつけていてよいと思った。
・アンケート
Q1. アドレス、ポインタについて納得しましたか。
まだあやふやなところがある。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
理解したがどのような場面で役に立つのかいまいち分からない。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
具体例がないと理解しにくい内容だった。
f1910560 2a:○ Tue May 19 21:33:04 2020
2020/05/19
プログラム
#include<stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 0; i < n; ++i){
if(max < a[i]){
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9, 0, 0 , 1, 2, 3}, b[] = {-1, -3, -2, -4, -1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(a+1, 2), 0, "0 0");
expect_int(iarray_max(b+2, 2), -2, "-2 -4");
}
結果
./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 0:0 0 0
OK -2:-2 -2 -4
説明
最初にmaxをつくりそこにaの最初の要素をいれる。iを0からnまで動か
して、a[i]がmaxより大きければmaxにa[i]を入れる。増やしたテストケー
スは、含まれる要素が全て同じになる場合などである。
レビュー課題(家族)
説明を読んでもわからないが、見ながら説明してもらうと分かったような気がする。
アンケート
Q1.
納得した。
Q2.
納得した。
Q3.
特になし。
f1910563 2a:○ Tue May 19 19:36:46 2020
プログラミング通論レポートA課題 ＃2
提出日付:5月19日
[プログラム]
<演習1.a>
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 0; i < n; ++i){
if(max < a[i]){
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");//配列の全ての要素の場合
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");//1番の位置から５要素分の場合(範囲の開始点を最初から１つずらした)
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");//配列の全ての要素の場合
expect_int(iarray_max(b+1,4),-1,"-3 -2 -4 -1");//1番の位置から4要素分の場合(範囲の開始点を最初から１つずらした)
expect_int(iarray_max(b+1,3),-2,"-3 -2 -4");//1番の位置から3要素分の場合(配列の中の部分を範囲とした)
expect_int(iarray_max(a,4),9,"9 0 0 1");//0番の位置から4要素分の場合(範囲の終了点を最後から１つずらした)
expect_int(iarray_max(a,1),9,"9");//0番の位置から1要素分の場合(最初の要素で長さ１の場合)
expect_int(iarray_max(a+5,1),3,"3");//5番の位置から1要素分の場合(最後の要素で長さ１の場合)
}
[実行結果]
[…]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
OK 9:9 9 0 0 1
OK 9:9 9
OK 3:3 3
[説明]
配列の最大値を求める関数を作成し、その関数が正しいのか確認するた
めに、その関数により得られた実際の結果と想定される結果を照らし合
わせる関数を作成した。main関数では、配列を用意し、様々なテストケー
スを用意した。
[レビュー課題]
変数を定義する際に、maxという名前で変数を定義しており一目見ただ
けでわかりやすい名前になっているのが良いと思った。(友人より)
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
基礎プロでやっていたので納得しました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだ、理解が不十分なので、次の課題を通して理解を深めていきたいです。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
チャット形式だと、先生や生徒の言った内容を振り返ることができたり、
ペースが追いつかなくて聞き逃してしまうようなことがなくてとてもよ
かったです。
最大を求める関数の中身を説明してほしいですが。おつかれ様でした。
f1910567 2a:○ Tue May 19 19:53:04 2020
プログラミング通論 レポート 2a
提出日付: 2020/05/19
[課題の再掲]
演習1.d : ある配列の要素に他の配列の要素を足す関数iarray_add(int
*a, int *b, int n)を作成する
[プログラム]
#作成した関数
-------------
void iarray_add(int *a, int *b, int n){
for(int i = 0; i < n; ++i){
a[i] += b[i];
}
}
---------------
#単体テストをふくめたプログラム全体
---------------
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
char *bool2str(bool b) { return b ? "true" : "false" }
void expect_bool(bool b1, bool b2, char *msg) {
printf("%s %s:%s %s\n", (b1==b2)?"OK":"NG",
bool2str(b1), bool2str(b2), msg);
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
void expect_double(double d1, double d2, char *msg) {
printf("%s %g:%g %s\n", (d1==d2)?"OK":"NG", d1, d2, msg);
}
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 1; i < n; ++i){
if(max < a[i]){
max = a[i];
}
}
return max;
}
void iarray_add(int *a, int *b, int n){
for(int i = 0; i < n; ++i){
a[i] += b[i];
}
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,1,2,2,3}, c[] = {9,6,4,6,4};
iarray_add(a, b, 5); expect_iarray(a, c, 5, "85241+11223 -> 96464");
int d[] = {9,6,5,7,6};
iarray_add(a+2,b,3); expect_iarray(a, d, 5, "96464+ --112 -> 96576");
int e[] = {0,0,0,0,0}, f[] = {-1,-2,-3,-4,-5}, g[] = {2,1,0,-1,-2},
h[] = {8,4,2,3,1}, i[] = {10,5,2,2,-1};
iarray_add(a,e,5); expect_iarray(a, d, 5, "96576+00000 -> 96576");
iarray_add(a,f,5); expect_iarray(a, h, 5, "96576-12345 -> 84231");
iarray_add(a,g,5); expect_iarray(a, i, 5, "84231+(2 1 0 -1 -2) -> 10 5 2 2 -1");
iarray_add(a,g,0); expect_iarray(a, i, 5, "(10 5 2 2 -1)+ ----- -> 10 5 2 2 -1");
return 0;
}
[プログラムの説明]
関数iarray_addは2つのint型配列a,bのポインタ、整数nを受け取り、
(i=0, 1,...,n-1)についてa[i] += b[i]を行う。
単体テストは配列の長さ、値を変え、行った。
単体テストを含むプログラムの実行例は以下の通りである。
$ ./a.out
OK 85241+11223 -> 96464
9 6 4 6 4
9 6 4 6 4
OK 96464+ --112 -> 96576
9 6 5 7 6
9 6 5 7 6
OK 96576+00000 -> 96576
9 6 5 7 6
9 6 5 7 6
OK 96576-12345 -> 84231
8 4 2 3 1
8 4 2 3 1
OK 84231+(2 1 0 -1 -2) -> 10 5 2 2 -1
10 5 2 2 -1
10 5 2 2 -1
OK (10 5 2 2 -1)+ ----- -> 10 5 2 2 -1
10 5 2 2 -1
10 5 2 2 -1
[レビュー課題]
加える配列の長さに変化をつけてテストを行うといった、工夫が施され
ていて良いと思います。
[アンケート]
#Q1: アドレス、ポインタについて納得しましたか。
A: 納得しました。
#Q2: 「構造体を用いた情報隠蔽」について納得しましたか。
A: 納得しました。
#Q3: リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
A: 配列の基本的な扱いについて復習出来た。また配列がポインタと同
じであることを改めて認識出来た。
f1910575 2a:○ Tue May 19 18:36:09 2020
プログラミング通論 第2回 レポート2A
提出日時:5月19日(火)
【選択した課題】演習1a
(課題の要約)
配列の最大値を求める関数iarray_max(int *a, int n)を作成し単体テストを行う。
【方針】
配列の先頭要素と各要素の大小を比較していくことで最大値を求める。
テストケースについては、配列をいくつか用意し、そのそれぞれについ
て複数のテストケースを適用する方針で進める。
【コード】
#include <stdio.h>
int iarray_max(int *a, int n) {
int max = a[0];
for (int i = 1; i < n; i++) {
if (a[i] > max) {
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1"); //ここまでがスライド記載のテストケース
expect_int(iarray_max(a+1, 2), 0, "0 0"); //ここからが増やしたテストケース
expect_int(iarray_max(a, 1), 9, "9");
expect_int(iarray_max(a+3, 1), 1, "1");
expect_int(iarray_max(a+4, 2), 3, "2 3");
expect_int(iarray_max(a+5, 1), 3, "3");
expect_int(iarray_max(b, 1), -1, "-1");
expect_int(iarray_max(b+4, 1), -1, "-1");
expect_int(iarray_max(b+1, 3), -2, "-3 -2 -4");
return 0;
}
【実行例】
[f1910575@sol l2]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 0:0 0 0
OK 9:9 9
OK 1:1 1
OK 3:3 2 3
OK 3:3 3
OK -1:-1 -1
OK -1:-1 -1
OK -2:-2 -3 -2 -4
【解説】
冒頭は配列の最大値を求めるプログラムである。初めに配列先頭の要素
を仮の最大値として変数maxに格納する。その後、2番目の要素(a[1])か
ら順にmaxとの大小を比較していき、maxよりも大きかった場合はmaxに
その要素を代入することで配列の最大値を求めている。その次の部分は
iarray_maxが正しいかどうかテストするための関数である。想定される
最大値とiarray_maxの結果が等しい場合は"OK"、等しくない場合は"NO"
を出力する。最後はmain関数である。2つの配列aとbに対して複数のテ
ストケースでexpect_intを実行している。
【レビュー課題】
レビューをもらった人:TA
1要素だけや配列の途中部分だけなど、既存のテストケースにない形で
のテストを多く用意していて、良いと思います。
【考察】
iarray_maxのテストのためのexpect_intを書いていた際、printf内の%d
と書くべき部分を%gとしてしまっていた。iarray_maxの戻り値がint型
であるところに実数型の%gをあてはめてしまったため、エラーとなった。
ある関数が正しいかテストするための関数が正しいか入念に確認するこ
との重要性がよく分かった。また、普段作成したプログラムを実行する
際、特例になりうるような場合(要素数0など)を意識的に取り上げて実
行していたが、それも重要なことであると今回の課題で認識できた。
【アンケート】
Q1. アドレス、ポインタについて納得しましたか。
納得した。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだ完全には納得できていない。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
今まで作成したプログラムは自分で適当な場合を逐一考えて実行してい
たが、今回の課題で単体テストの重要性がよく分かった。
f1910576 2a:○ Tue May 19 22:32:27 2020
学籍番号：1910576
氏名：藤松栞 (ペア：「個人作業」)
提出日時：5/19
1.課題につて
1-1.課題の内容
(1a):配列の最大値を求める関数int iarray_max(int *a,int n)を作成する。
1-2.書いたプログラム
// saidaiti.c --- unit test of array_equal
#include <stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a,int n){
int b=a[0];
for(int i=0;i<n;++i){
if(b<a[i]){
b=a[i];
}
}
return b;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = { -1, -3, -2, -4, -1};
int c[]={0,1,3,5,-1,-5,9};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 7), 9, "0 1 3 5 -1 -5 9");
expect_int(iarray_max(c+3, 4), 9, "5 -1 -5 9");
return 0;
}
1-3. プログラムの説明と実行例
例題を元にし、最大値を計算するiarray_maxを作成した。この時最初
int b=0;にせずに与えられた配列の最初の数を入れるようにした。(も
しそうしないと配列内に負の値が出てきたときに最大値が上手く表示さ
れないから。)その後、expect_intでiarray_maxで求めた値が正しいか
どうかを確認する関数を入れ、テストケースを作成した。
元々与えられてたa,bの配列を動かしてiarray_maxの部分の不等号が<か
<=かでどうバグが発生するかを確認した後、自分でも配列を作成しテス
トケースを作成した。正負が混合されている配列を作成し上手くいくか
を確かめた。
実行例は以下のようになった。
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 9:9 0 1 3 5 -1 -5 9
OK 9:9 5 -1 -5 9
2.レビュー課題
1aと同様に同大学の他類の人にレビューを頼んだところ、
「テストケースももれなく出来ているし、コードも分かりやすくていい
と思う。コードを書くときに同じような形をしたものは揃えて書くと間
違いにくかったり、もうっとわかりやすくなったりすると思った。」と
いう意見を貰った
3.アンケート
Q1. アドレス、ポインタについて納得しましたか。
春休みに復習していたため、基礎プロの時よりは出来たと思う。ポイン
タとしておくことでテストケースをどこからはじめるというのを自在に
やれて便利さを感じた。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだ不明なところはあるが問題を解いていき次第に理解を深めていきたい。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
テストケースを自分で作成するのは例を考えるのも大変だと思った。
もちろんテストケース大変ですよ。でもまあそれもやるべきことなんで。
おつかれ様です。
f1910579 2a:○ Tue May 19 21:44:08 2020
1910579
個人作業
5月19日
課題1a
[ソース]
//最大値
#include<stdio.h>
#include<stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a,int n){
int x=a[0];
for(int i = 1; i <n ;++i){
if(x<a[i]){
x = a[i];
}
}
return x;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+2, 2), -2, "-2 -4");
expect_int(iarray_max(a+1, 2), 0, "0 0");
return 0;
}
[説明]
最大値を求める関数iarray_maxでは、配列a*, 整数nを指定して、変数x
の中に配列aの最初の要素を入れ、それから変数iをi<nまで反復させて
前の要素より大きかったらxにその値を代入し、xを返した。テストのコー
ドはテキストに載っているものを用いた。テストの内容は他に2つ増や
した。
[実行例]
./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -2 -4
OK 0:0 0 0
以上の結果から私の作ったコードは正しいと考えられる。
[レビュー]
テストの内容が少ないのでもう少し増やした方がいいと思う。
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
--去年触れた内容だったので特に問題はなかった。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
--まだ触れてないのでこれから復習して納得したい。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
--前回は去年の復習だったのもあったが、前回より難しくなっている
ので、もっと勉強してついていきたい。
f1910583 2a:○ Tue May 19 18:43:31 2020
レポート2A
課題1a「配列の最大値を求める関数 int iarray max(int *a, int n) を作成する」
-ソースコード-
#include <stdio.h>
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iarray_max(int *a, int n){
int i, max = a[0];
for(i = 0; i < n ;i++){
if (max < a[i]){ max = a[i]; }
}
return max;
}
int main(void){
int a[] = {9,0,0,1,2,3};
int b[] = {-1,-3,-2,-4,-1};
int c[] = {1,2,-9,0};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 1), 1, "1");
expect_int(iarray_max(c+2, 2), 0, "-9 0");
return 0;
}
-実行例-
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 1:1 1
OK 0:0 -9 0
-解説-
iarray_maxは、配列の最大値をint型の変数maxに代入し、maxを返す関
数である。まずmaxに0番目の要素を代入し、0からn番目の要素の中で
maxより大きい要素があったらmaxを更新する。main関数では単体テスト
を行う。
-レビュー課題-
友人からのレビューは下記の通り
「for文の初期条件はi = 1にしてもいいと思った。」
-アンケート-
Q1. アドレス、ポインタについて納得しましたか。
配列のポインタの使い方がまだあやふやだ。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
一度読んだだけでは理解できなかったので復習する必要がある。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ
ポインタと構造体の基礎をもっと勉強しないといけないと痛感した。
h1810533 2a:○ Tue May 19 15:32:51 2020
「個人作業」
5/19
ソースコード
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max = a[0]; for(int i = 0; i < n; ++i){
if(max < a[i]){ max = a[i];}
}
return max;
}
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_bool(bool b1, bool b2, char *msg) {
printf("%s %s:%s %s\n", (b1==b2)?"OK":"NG",
bool2str(b1), bool2str(b2), msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4, -1},
c[] = {0, -8, -3, -5, 0, -1};
expect_bool(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_bool(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_bool(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_bool(iarray_max(b+3, 2), -1, "-4 -1");
expect_bool(iarray_max(c, 6), 0, "0, -8, -3, -5, 0, -1");
expect_bool(iarray_max(c+1, 5), 0, "-8, -3, -5, 0, -1");
return 0;
}
説明
配列の最大値を求める関数iarray_maxとその単体テスト
単体テストの結果
OK true:true 9 0 0 1 2 3
OK true:true 0 0 1 2 3
OK true:true -1 -3 -2 -4 -1
OK true:true -4 -1
OK false:false 0, -8, -3, -5, 0, -1
OK false:false -8, -3, -5, 0, -1
コメント
無駄な変数等の定義がなく、また適切な改行によって読みやすいプログラムになっている。
テストケースで配列の長さが異なるケースをさらに追加すればより良いと思った。
（友人）
アンケート
Q1. アドレス、ポインタについて納得しましたか。
おおまかなことは納得。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだ納得できていない。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
単体テストで起こりうるミスを網羅できるかどうかはセンスが問われると思った。
最大値だったらexpect_intを使うんじゃないのかな。おつかれ様です。
h1810542 2a:△ Tue May 19 13:39:37 2020
レポート2A
選択した課題:
演習1a: 配列の最大値を求める関数 int iarray max(int *a, int n)
を作成する。
方針:for文if文によってmaxに最大値を代入するようにした
コード:
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i <= n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iarray_max(int *a,int n){
int max;
max = a[0];
for(int i=0;i<n;++i){
if(max<a[i]){
max = a[i];
}
}
return max;
}
int main(void) {
int a[]={9,0,0,1,2,3},b[]={-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
return 0;
}
実行例:
./1a.exe
ok 9:9 9 0 0 1 2 3
ok 3:3 0 0 1 2 3
ok -1:-1 -1 -3 -2 -4 -1
解説:
iarray_maxで最初に配列aをnのサイズで確保できるようにした。最初にint型のmaxにa[0]
を代入、if文によってmaxの値とa[i]の値を比べて、a[i]のほうが大きい場合にmaxにa[i]
を代入するようにした。それをfor文によってn回繰り返すことでmaxに
a[i]の最大値が代入されるようにした。
レビュー:
void iarray_read、void iarray_print、bool iarray_equalは必要がないと思いました。
iarray_maxも簡単なコードでできていたのでいいと思いました。
アンケート:
Q1. アドレス、ポインタについて納得しましたか。
しました
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
した
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
無駄を省こうかと思いました
提出ファイルの文字コードをUTF8にしてください。
「テストケースを増やしてみること」が行われていません。
h1910525 2a:○ Tue May 19 18:14:00 2020
学籍番号 1910525
ペア 1910616
演習1.a
//enshu01
#include <stdio.h>
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iarray_max(int *a, int n){
int s = a[0];
for(int i = 1; i < n; ++i){
if(s < a[i]){ s = a[i]; }
}
return s;
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
int c[] = {1, 1, 4, 5, 1, 4}, d[] = {2, 7, 8, 3, 1, 4};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 6), 5, "1, 1, 4, 5, 1, 4");
expect_int(iarray_max(c+1, 5), 5, "1, 4, 5, 1, 4");
expect_int(iarray_max(d, 6), 8, "2, 7, 8, 3, 1, 4");
return 0;
}
簡単な説明：渡された配列の要素の中で最も大きい整数を返す関数
iarray_max。配列の0番目を変数sにいれ、for文内でその後の要素と比
較している。sより大きいものは上書きされ、最終的なsの値を返す。
レビュー
iarray_max関数のレビューを行う。この関数はint型の配列を受け取り、
その最大要素を返す関数である。この関数の特徴として、要素数の異な
る配列を受け取るために、配列の先頭要素のポインタと、配列の長さを
引数として受け取るようになっており、汎用性が高くなるように工夫が
されている。ただし、空の配列が渡された時に問題が起きる可能性があ
る。この関数では必ず配列の0番目の要素にアクセスしているが、引数
が空の配列の場合は配列の範囲外への読み取りになってしまう。例えば、
引数が正の整数に限られている場合は、-1など異常値を返すようにする
と、より安全な関数になると考えられる。(kai)
アンケート
Q1.アドレス、ポインタについて納得しましたか。
概念は理解したが自在に使えるかは微妙という段階だと感じる。
Q2.「構造体を用いた情報隠蔽」について納得しましたか。
納得した。やり方が違うだけでクラスと同質かなと感じた。
Q3.リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
基礎プロで挑戦した事が活きた回だった。具体的な使用を経験している
と理解が捗った。今回は素晴らしいレビューを頂けて非常に勉強になっ
た。
h1910527 2a:△ Tue May 19 19:00:48 2020
演習1a
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 1; i < n; ++i) {
if(max < a[i]) { max = a[i]; }
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1},c[] = {1,5,-3,0},d[] = {1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 5), 5 , "1,5,-3,0");
expect_int(iarray_max(d, 1), 1, "1");
return 0;
}
単体テスト結果
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 5:5 1,5,-3,0
OK 1:1 1
解説
関数iarray_maxは渡された整数型配列のn番目までの最大値を求める。
まず配列の先頭の値を仮データとして代入し、その後forループで各項
の値と大小比較している。
レビュー
アンケート
Q1.いざ自分で使ってみようとするとまだ怪しい。
Q2.動作の安全性が確保されるのでいいと思う。
Q3.チャット方式も悪くないなと思います。
レビューもらってから出してくださいね。TAさんからでもいいので。
h1910528 2a:○ Tue May 19 14:25:06 2020
提出日：5/12
■作成したプログラム
[演習1a]
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 0; i < n; ++i) {
if (max <= a[i]){
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {-1,0,-2, 3,-5};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+2, 3), -1, "-2 -4 -1");
expect_int(iarray_max(c, 5), 3, "-1 0 -2 3 -5");
return 0;
}
[実行例]
PS C:\programming> gcc .\0519\practice05191a.c
PS C:\programming> .\a.exe
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -2 -4 -1
OK 3:3 -1 0 -2 3 -5
■簡単な説明
与えられた行列内の与えられた数の要素の中から最高の数を返すプログ
ラム。行列最初の数を整数型maxにいれておき、for文を用いて、行列の
要素一つ一つを取り出し、その都度maxと比較、max以上の時はmaxに新
しく代入することを繰り替えし、最終的にmaxを返す。また追加のテス
トケースとして、行列bの要素から特定のものを比較する例と、正負の
混じった行列cの比較をつくり、行った。
■他人からの感想(友人)
テストケースとして行列cを増やしているのが自分としては盲点だった
ので、既存のケースだけでなく色々なケースを自分で作り、吟味してテ
ストしているのは見習っていきたい。
■アンケート
Q1. アドレス、ポインタについて納得しましたか。
難しい概念でまだint**などがしっかり理解できているとは言えないの
で復習を通して身に着けたい。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
ヘッダファイルの理解度が低くよくわからない点が多かった。自分で調
べたりしながらじっくり理解を深めたい。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
c言語の持つ特徴、問題点に関する話がとても興味深かった。
提出ファイルの文字コードをUTF8にしてください。
おつかれ様です。
h1910529 2a:○ Tue May 19 17:37:15 2020
プログラミング通論2a
コード（1a）
// iarraymax.c
#include <stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarraymax(int *a, int n) {
int w = a[0];
for(int i = 0; i < n; ++i){
if(w < a[i]){
w = a[i];
}
}
return w;
}
int main(void) {
int a[4];
iarray_read(a,4);
int w = iarraymax(a,4);
printf(" %d", w);
return 0;
}
説明
配列の中の最大値を出力するようにすればよい。そのためにまず配
列の最初の値をwとおきそれを配列の別の値と比較し、大きいほうを新
しく代入させる。これを配列の位置を変えながら繰り返させることで最
大値を特定した。そしてその値を返させた。
単体テスト
// iarraymaxtest.c
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarraymax(int *a, int n) {
int w = a[0];
for(int i = 0; i < n; ++i){
if(w < a[i]){
w = a[i];
}
}
return w;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarraymax(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarraymax(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarraymax(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarraymax(b+1, 3), -2, "-3,-2,-4");
return 0;
}
実行例
[h1910529@sol r02]$ gcc8 iarraymaxtest.c
[h1910529@sol r02]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3,-2,-4
コメント
今回は、クラスメイトの前田裕作くんにもらった。「forの中はi=1からでもよい」というコメントをもらった。
Q1. アドレス、ポインタについて納得しましたか。
A1, その利点ぐらいなら理解できました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
A2, なんとなく納得できました
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
A3, printfの限界をみました
レビューはもうちょっと長くお願いしますよ。おつかれ様です。
h1910531 2a:○ Tue May 19 20:21:03 2020
課題2a
学籍番号 1910531
個人作業
プログラム
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
int iarray_max(int *a, int n) {
int m=*a;
for (int i = 1; i < n; ++i) {
if(a[i]>m) { m=a[i]; }
}
return m;
}
int main(void) {
int a[5];
iarray_read(a, 5);
printf("max number= %d\n",iarray_max( a,5));
return 0;
}
説明
readで配列を入力する
maxで最大値を求める。最大値mをa[0]と仮定する。他の配列aの要素とmを比較し、
存在すれば、mの値をmより大きい要素に入れかえる。
単体テスト
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(a+3,3),3,"1 2 3");
実行例
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 3:3 1 2 3
レビュー 友人
もっとテストケースを増やすべきだと思います。
4. 以下のアンケートの回答。
Q1. アドレス、ポインタについて納得しましたか。
授業中の他の人の質問と、それに対する答えをみることで、
一年生のときより理解を深めることができたと思います。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
いいえ、まだです。課題2に取り組んで納得できるところまで持ち込みたいです。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
授業中に質問できるほどになるには、自分の予習が足りなかったです。
質問できるまで予習してから参加しましょうね。おつかれ様です。
h1910532 2a:○ Tue May 19 23:12:24 2020
プログラミング通論 #2 2a
1910532
個人作業
5/19
1a
配列の最大値を求める関数int iarray_max(int *a, int n)の作成
ソース
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int m = a[0];
for(int i = 0; i < n; ++i){
if(m < a[i]){
m = a[i];
}
}
return m;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(a+1, 2), 0, "0 0");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 3), -2, "-3 -2 -4");
expect_int(iarray_max(b+2, 3), -1, "-2 -4 -1");
return 0;
}
実行例
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK 0:0 0 0
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
OK -1:-1 -2 -4 -1
様々な単体テストの結果はすべてOKであった。
説明
配列の1つ目を仮の最大値として配列の他の要素と比較していき、随時
最大値を更新していくプログラムである。
レビュー課題(友人)
iarray内2行目:
forループの初期値は"i = 1"でよい。
テストケースでは様々なパターンが試されていていいと思った。
アンケート
A1
基礎プロの時より理解することができました。
A2
まだ演習をしていないので納得していません
A3
始め、単体テストが何しているのか分からず大変でした。
h1910534 2a:○ Tue May 19 16:08:30 2020
学籍番号: 1910534
ペア: 個人作業
提出日時:2020年5月19日
・課題の再掲
演習1a
配列の最大値を求める関数 int iarray_max(int *a, int n) を作成する
・単体テストを含むプログラム
// test_array_equal.c --- unit test of array_equal
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_bool(bool b1, bool b2, char *msg) {
printf("%s %s:%s %s\n", (b1==b2)?"OK":"NG",
bool2str(b1), bool2str(b2), msg);
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iarray_max(int *a, int n){
int max = *a;
for (int i = 1; i < n; i++) {
if (max < a[i]) {
max = a[i];
}
}
return max;
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(a+5, 1), 3, "3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 3), -2, "-3 -2 -4");
expect_int(iarray_max(b, 2), -1, "-1 -3");
expect_int(iarray_max(b+4, 1), -1, "-1");
return 0;
}
・実行例
$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK 3:3 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
OK -1:-1 -1 -3
OK -1:-1 -1
・プログラムの説明
int iarray_maxの中では、まず最大値を入れるint型変数maxを用意し、
引数の配列の0番目の整数を代入した。次にfor文で配列の1番目から最
後の要素まで順にmaxの値と比較し、maxの方が小さければその数をmax
に代入している。最後にmaxを返している。
レビュー
友人から。
「シンプルな仕組みで良い。最大値の変数名がmaxなのもわかりやすく、
間違えることがなさそう。」
アンケート
Q1. アドレス、ポインタについて納得しましたか。
納得した
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得した
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
基礎プロの時よりアドレス、ポインタについての理解が深まった。
h1910541 2a:○ Tue May 19 20:41:08 2020
5月19日
source code
// test_array_max.c --- unit test of array_max
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
int i;
for(i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
int i;
for(i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int max = a[0];
int i;
for(i = 0; i < n; ++i) {
if( a[0] < a[i] ) { max = a[i]; }
}
return max;
}
int main(void){
int a[4];
iarray_read(a, 4); iarray_print(a, 4);
printf("max ' %d\n", iarray_max(a, 4));
return 0;
}
単体テスト
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 4), -1, " -1 -3 -2 -4 ");
expect_int(iarray_max(b+1, 3), -2, " -3 -2 -4 ");
return 0;
}
実行例
［単体テスト］
[h1910541@sol ~]$ gcc hihi.c
[h1910541@sol ~]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4
OK -2:-2 -3 -2 -4
[通常］
1> 7
2> 3
3> 5
4> 1
7 3 5 1
max ' 7
[説明］
最初のirarry_read,irarry_printは例題と変わらないので割愛。
int_irarry_maxで最初にmaxにa[0]を代入しておく。その後、forを使い
ループさせ、ifの条件でmaxよりa[i]の値が大きければ、その値をmaxに
入れ代入させる。最後にreturn maxで最大値を返す。単体テストでは、
今回は整数であるためint型に変更した。
[レビュー］
単体テストで、最大値が性の場合、負の場合両方を調べていたり、最初
の項、最後の項に最大値がある場合など広く調べられていていいと思う
[アンケート］
A1,何となく納得
A2,まだやっていない
A3,特になし
h1910542 2a:○ Tue May 19 16:14:12 2020
1.プログラム
演習１のa
演習１のaは配列の最大値を求める関数 int iarray max(int *a, int
n) を作成するというプログラム。作成したプログラムは以下のように
なった。
#include<stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int x = a[0];
for(int i = 1; i < n; ++i){
if(x < a[i]){
x = a[i];
}
}
return x;
}
int main(void){
int a[5];
iarray_read(a, 5); iarray_print(a, 5);
printf("max: %d\n", iarray_max(a, 5));
return 0;
}
・実行例
[h1910542@sol #2]$ ./a.out
1> 2
2> 4
3> 3
4> 7
5> 1
2 4 3 7 1
max: 7
【単体テスト】
・プログラム
// test_iarray_max.c --- unit test of array_emax
#include<stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int x = a[0];
for(int i = 1; i < n; ++i){
if(x < a[i]){
x = a[i];
}
}
return x;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {5,-1,12,2,-20}, d[] = {9};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 5), 12, "5 -1 12 2 -20");
expect_int(iarray_max(d, 1), 9, "9");
return 0;
}
・実行例
[h1910542@sol #2]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 12:12 5 -1 12 2 -20
OK 9:9 9
【プログラムの説明】
iarray_max は配列の最大の数を探し出すプログラムであるので配列の
最初の項であるa[0]をxに入れ、for構文の中でif文を使ってxに入って
いる数とそれ以降の項を比べる。もしそれ以降の項がxより大きい場合
はxにその項を入れる。これを繰り返すことで最後にはxに配列の最大の
数がはいっている。 ２．提出プログラムに対するコメント(クラスメー
ト)配列の最大値を出す時に変数xをおいて配列の要素と比べてるのがい
いと思った。
３．アンケート
Q１．変数のアドレスを値として扱えるのはややこしいので完璧には理解できていない。
Q２．完璧には理解できてないが便利だと思った。
Q３．ポインタ、アドレスについての理解が基礎プロの時より深まったので良かった。
h1910546 2a:○ Tue May 19 21:05:33 2020
プログラムのソース
#include <stdio.h>
int iarray_max(int *a, int n) {
int x = a[0];
for (int i = 1; i < n; i++) {
if (a[i] > x) {
x = a[i];
}
}
return x;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
return 0;
}
実行例
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
追加したテストケース
int main(void) {
int a[] = {0,0,0,1,1,6}, b[] = {-8,-8,-8,8,8};
expect_int(iarray_max(a, 3), 0, "0 0 0 1 1 6");
expect_int(iarray_max(a+1, 5), 6, "0 0 1 1 6");
expect_int(iarray_max(b, 3), -8, "-8 -8 -8 8 8");
expect_int(iarray_max(b+2, 3), 8, "-8 -8 -8 8 8");
return 0;
}
実行例
OK 0:0 0 0 0 1 1 6
OK 6:6 0 0 1 1 6
OK -8:-8 -8 -8 -8 8 8
OK 8:8 -8 -8 -8 8 8
簡単な説明
配列の最大値を求める関数のプログラムをつくり、単体テストを行った。
配列の最大値はfor文を使い、大小を比べることをを繰り返すことで、
最終的に最大値が求まるようにした。単体テストを行うため、expect
int関数を用い、配列の最大値を求める関数iarray_maxが返す値と予想
される値が等しければＯＫ、異なればＮＧと表示するようにした。
レビュー課題（友人）
テストケースが多様に作られているのがよいと思った。
アンケート
Q1. アドレス、ポインタについて納得しましたか。
まだ難しいと感じるが、少し理解が深まった。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだあまり理解できていない。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
単体テストはとても重要だとおもった。
h1910556 2a:○ Tue May 19 15:33:33 2020
レポート2a
2020/5/19 提出
1 プログラム (演習)
1.1 ソースコード
#include <stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
int iadd(int x, int y) { return x + y; }
int imax(int x, int y) { return (x > y) ? x : y; }
int iarray_inject(int *a, int n, int (*fp)(int, int)) {
if(n==0) {
return 0;
}
int ans = a[0];
for (int i = 1; i < n; ++i) {
ans = fp(ans, a[i]);
}
return ans;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1 == i2) ? "OK" : "NG", i1, i2, msg);
}
int main(void) {
int size;
printf("size> ");
scanf("%d", &size);
int array[size];
iarray_read(array, size);
printf("sum = %d, max = %d\n", iarray_inject(array, size, iadd), iarray_inject(array, size, imax));
// テストケース
int a[] = {8, 5, 2, 4, 1};
expect_int(iarray_inject(a, 5, iadd), 20, "8+5+2+4+1");
expect_int(iarray_inject(a + 1, 4, iadd), 12, "5+2+4+1");
expect_int(iarray_inject(a, 1, iadd), 8, "8");
expect_int(iarray_inject(a, 5, imax), 8, "max(8,5,2,4,1)");
expect_int(iarray_inject(a + 1, 4, imax), 5, "max(5,2,4,1)");
expect_int(iarray_inject(a + 4, 1, imax), 1, "max(1)");
int b[] = {0,0,0};
expect_int(iarray_inject(b, 3, iadd), 0, "0+0+0");
expect_int(iarray_inject(b, 3, imax), 0, "max(0,0,0)");
expect_int(iarray_inject(b, 0, iadd), NULL, " ");
expect_int(iarray_inject(b, 0, imax), NULL, "max()");
return 0;
}
1.2 実行例
in size> 5
1> 9
2> 1
3> 2
4> 4
5> 7
out sum = 23, max = 9
in size> 1
1> 3
out sum = 3, max = 3
in size> 0
out sum = 0, max = 0
1.3 テストケース
OK 20:20 8+5+2+4+1
OK 12:12 5+2+4+1
OK 8:8 8
OK 8:8 max(8,5,2,4,1)
OK 5:5 max(5,2,4,1)
OK 1:1 max(1)
OK 0:0 0+0+0
OK 0:0 max(0,0,0)
OK 0:0
OK 0:0 max()
1.4 説明
与えられたiaddとimaxが2つの整数を渡して結果を返すというものであっ
たのでiarray_injectでは与えた配列の初項a[0]を初期値にした変数ans
を配列の各要素で更新していき、最終的な答えを返すようにした。配列
のサイズが0であるときは初期値がa[0]が存在しないので、条件分岐で0
を返すようにした。テストケースはすべての要素が同じ配列、要素数が
0などのパターンを試した。
2 レビュー課題
7行目で関数ポインタの代入で、iaddとimaxのどちらを代入しても変数
ansによって答えの整数を簡潔に返していました。
これは変数ansにa[0]を代入している所がポイントで、とても良いと思いました。
また、入力した配列に関して最大値と合計値を求める柔軟さも良かったです。
このプログラムでは必要ないかもしれないですがテストケースのa[]に
関してiarray_injectにaとa+1を代入しただけだと先頭が最大のみの場
合しか考えられてないのでa+2とかも代入してimaxの確認をしても良い
のかなと思いました。
3 アンケート
Q1. アドレス、ポインタについて納得しましたか。
関数のポインタなどの便利な機能があることはわかった。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
よくわからなかった。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
C言語はしょっちゅうポインタの概念がでてきて大変だと思った。
そう、しょっちゅうポインタが出てくるんです。おつかれ様です。
h1910589 2a:○ Tue May 19 20:40:07 2020
[プログラムのソース]
演習1a(配列の最大値を求める関数 int iarray max(int *a, int n)の作成)
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max=*a;
for(int i=0; i<n; ++i){
if(*(a+i)>=max){
max=*(a+i);
}
return max;
}
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b,1),1,"1");
}
[プログラムの説明]
配列に含まれる数を1つずつ順番にmaxの値と比較する.もしmaxよりも大
きな値が現れた場合は改めてその値をmaxとする.始めに比較対象になる
maxの値は*aを使って配列aの先頭から持ってきた.
[実行例]
OK 9:9 9 0 0 1 2 3
NG 0:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 1:1 1
[レビュー課題]
forの中身はint i=1にした方が無駄な動作が減ると思いました.
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
6割程度は.
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
4割程度.
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ
次はもっと頑張る.
テストケースにNGがあるじゃないですか。それはテストケースの方が
間違ってます。直しておいてください。
h1910596 2a:○ Tue May 19 21:14:57 2020
学籍番号: 1910596
提出日時: 2020/5/19
演習1a
・ソース
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max = a[0];
for (int i = 1; i < n; ++i){
if (a[i] > max) {
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {-1,5,2,-9,7,4,-2};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+2, 3), -1, " -2 -4 -1");
expect_int(iarray_max(c, 7), 7, "-1 5 2 -9 7 4 -2");
expect_int(iarray_max(c+3, 4), 7, "-9 7 4 -2");
return 0;
}
・説明
配列の最大値を求める関数iarray_max。int型のmaxにa[0]を代入し、
a[i]との大小を比べa[i]がmaxよりも大きい場合にmaxにa[i]を代入して
いき、for文を使いn回行うことで最終的に配列の最大値が求まる。
・実行例
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -2 -4 -1
OK 7:7 -1 5 2 -9 7 4 -2
OK 7:7 -9 7 4 -2
・レビュー
無駄なものがなくて簡潔にまとめられていて良いと思う。また、変数に
maxを使っていて分かりやすい。
・アンケート
Q1. アドレス、ポインタについて納得しましたか。
難しくまだ理解できていない。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
よくわからない。
Q3. リフレクション・感想・要望をどうぞ。
理解しきれていない部分が多いので、理解できるように頑張りたい。
i1910089 2a:○ Tue May 19 20:18:02 2020
1a
ソース
#include<stdio.h>
void expect_int(int i1,int i2,char *msg) {
printf("%s %d:%d %s\n",(i1==i2)?"OK":"NG",i1,i2,msg);
}
int iarray_max(int *a,int n){
int max=a[0];
for(int i=0;i<n;i++)if(a[i]>max)max=a[i];
return max;
}
int main(void){
int a[]={9,0,0,1,2,3},b[]={-1,-3,-2,-4,-1},c[]={4,1,2,8};
expect_int(iarray_max(a,6),9,"9 0 0 1 2 3");
expect_int(iarray_max(a+1,5),3,"0 0 1 2 3");
expect_int(iarray_max(b,5),-1,"-1 -3 -2 -4 -1");
expect_int(iarray_max(c,4),8,"4 1 2 8");
expect_int(iarray_max(c,3),4,"4 1 2");
expect_int(iarray_max(c+1,2),2,"1 2");
return 0;
}
実行例
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 8:8 4 1 2 8
OK 4:4 4 1 2
OK 2:2 1 2
説明
配列とサイズを引数に取る。
最大値を格納する変数maxを用意し、配列の先頭の値を初期値とした。
for文で配列を回して、maxより大きいならばそれを代入して更新する。
最後にmaxを返す。
レビュー
中括弧の省略など無駄なものが無くて簡潔でいいと思います
Q1. 納得できた。
Q2. 納得できた。
Q3. 変数と配列でポインタの使い方が違う。
k1710179 2a:○ Tue May 19 15:06:43 2020
プログラミング通論#2
1.課題
演習2ーa
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n) {
int x = a[0];
if(n == 0) return '\0';
for(int i = 0; i < n; ++i) {
if(x < a[i]) { x = a[i]; }
}
return x;
}
char *bool2str(int b) { return b ? "true" : "false"; }
void expect_int(int b1, int b2, char *msg) {
printf("%s %s:%s %s\n", (b1==b2)?"OK":"NG",
bool2str(b1), bool2str(b2), msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4, -1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 0), -1, "-1 -3 -2 -4 -1");
return 0;
}
2.簡単な説明
配列を用意し、サブルーチンの引数に用意した配列のアドレスと項数を
渡すとその項数内での配列の最大値を見つけ、値を返す。見つけられな
かった場合はfalse、見つけられた場合はtureを返す。
3.出力結果
PS C:\pro2> gcc pro2-2-1a.c
PS C:\pro2> ./a.exe
OK true:true 9 0 0 1 2 3
OK true:true 0 0 1 2 3
OK true:true -1 -3 -2 -4 -1
4.考察
選択ソートの要領で最大値をみつけ出力した。
項数が0のときiarray_maxの返り値を'\0'にしてしまったがこれでいいのかが分からない。
4.アンケート
Q1. アドレス、ポインタについて納得しましたか ?
納得しました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
少し難しかった。
Q3. リフレクション ( 今回の課題で分かったこと ) ・感想・要望をどうぞ。
課題がんばります。
0個のときはしかたがないよね。実行例でテストケースの出力が
3つしかない。実行例と掲載プログラムが一致していないのでは?
m1810587 2a:○ Tue May 19 20:07:25 2020
1810587
個人作業
2020/05/19
演習1b
与えられた配列の順序を逆転させる関数を作れ。
ソースコード
#include<stdio.h>
#include<stdbool.h>
#include "test.h"
void iarray_reverse(int *a,int n){
for(int i = 0;i < n/2;++i){
int top = *(a+i);
*(a+i) = *(a+n-i-1);
*(a+n-i-1) = top;
}
}
int main(void){
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};
int c[] = {1,5,8,9,3,3},d[] = {3,3,9,8,5,1};
int e[] = {10,0,0,0,1,0,0,10}, f[] = {10,0,0,1,0,0,0,10};
iarray_reverse(a,5);
expect_iarray(a,b,5,"85241 -> 14258");
iarray_reverse(c,6);
expect_iarray(c,d,6,"158933 -> 339851");
iarray_reverse(e,8);
expect_iarray(e,f,8,"1000010010 -> 1000010010");
}
説明
配列を逆にしたとき、最初の位置にある数字は一番最後の数字、２番目
にある数字は最後から２番目、という規則で数字の位置が変わる。それ
を一般化すると、i番目の数字は配列がn個のとき、n-i-1番目に来るこ
とになる。配列の真ん中までループさせて数字の位置を交換していく。
実行結果
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 158933 -> 339851
3 3 9 8 5 1
3 3 9 8 5 1
OK 1000010010 -> 1000010010
10 0 0 1 0 0 0 10
10 0 0 1 0 0 0 10
求められている機能が実装できていることが分かる。
コメント
関数の記述がシンプルにまとまっていて良い。
Q1. アドレス、ポインタについて納得しましたか。
はい。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
はい
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
ポインタがc言語で一番苦手な箇所なので頑張ります。
m1810639 2a:○ Tue May 19 16:20:52 2020
学籍番号:1810639
個人作業
提出日時:5/19
ソース
int iadd(int a, int b) {return a+b;}
int imax(int a, int b) {return (a > b) ? a : b; }
int iarray_inject(int *a, int n, int (*fp)(int, int)){
int c = fp(a[0], a[1]);
for(int i = 2;i < n; i++) {
c = fp(c, a[i]);
}
return c;
}
単体テスト
expect_int(iarray_inject(a, 5, iadd), 20, "8+5+2+4+1");
expect_int(iarray_inject(b, 5, iadd), 4, "8-5+4+0-3");
expect_int(iarray_inject(a, 5, imax), 8, "max(8,5,2,4,1)");
expect_int(iarray_inject(b, 5, imax), 8, "max(8,-5,4,0,-3)");
実行例
OK 20:20 8+5+2+4+1
OK 4:4 8-5+4+0-3
OK 8:8 max(8,5,2,4,1)
OK 8:8 max(8,-5,4,0,-3)
説明
２つのint型引数をもつ関数iaddとimaxを用意して、関数iarray_inject
の引数の中に関数ポインタをいれた。この関数ポインタの中にiaddと
imaxのどちらでも計算できるようにfor文をかいた。
レビュー課題
関数ポインタを使えていて、どっちの関数が入っても計算できるように
考えられていてよい。
アンケート
Q1
よくわかった。
Q2
よく納得した。
Q3
関数ポインタをいれるともっと複雑なことができるなと思ってワクワクした。
レポートでは動作するプログラム全体を掲載してくださいね。
おつかれ様です。
m1910598 2a:○ Tue May 19 19:14:09 2020
1. プログラムのソースと簡単な説明
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iarray_max(int *a,int n){
int max=a[0];
for(int i=0;i<n;++i){
if(a[0]<a[i]){
max=a[i];
}
}
return max;
}
int main(void){
int a[] = {9,0,0,1,2,3},b[] = {-1,-3,-2,-4,-1},c[]={1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(a+2, 4), 3, "0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 4), -1, "-3 -2 -4 -1");
expect_int(iarray_max(b+2,3),-1,"-2 -4 -1");
expect_int(iarray_max(c,1),1,"1");
return 0;
}
(実行例)
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK 3:3 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -3 -2 -4 -1
OK -1:-1 -2 -4 -1
OK 1:1 1
(説明)
最大値を配列の最初の数字と仮定し、順に数字を比較して最大値を入れ
替えるプログラムである。
2. レビュー課題(友人から)
int iarray_max(int *a,int n)に関してはほぼ模範解答のようなもので
なのでむしろいいと思う。文句が出てこない。 あと、テストケースが
正、0、負が混ざったの使ってて最大値をどの番号から求めるのかも変
えているのでほとんどのパターンが網羅できててきちんとテストできて
そうだと感じた。
3. アンケート
Q1. アドレス、ポインタについて納得しましたか。
なんとなく納得できた。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
あまり把握できていない。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
単体テストの重要性を理解できた。
m1910601 2a:○ Tue May 19 17:58:29 2020
1910601
「個人作業」
5/19
[作成したプログラム（演習１ーb 配列のならびを逆順にするもの）]
実際に作成したプログラムは次の通りである。
// iarray_reverse--- (1-b)
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
int i;
for(i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
int i;
for(i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
int i;
for(i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void iarray_reverse(int *a, int n) {
int c[n];
int i;
for(i = 0; i < n; ++i) {
c[i] = a[i];
}
for(i = 0; i < n; ++i) {
a[i] = c[n-1-i];
}
}
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8},
c[] = {3,1,4,1,5,9,2,6,5}, d[] = {5,6,2,9,5,1,4,1,3},
e[] = {7}, f[] = {7};
iarray_reverse(a, 5);
expect_iarray(a, b, 5, "85241 -> 14258");
iarray_reverse(c, 9);
expect_iarray(c, d, 9, "314159265 -> 562951413");
iarray_reverse(e, 1);
expect_iarray(e, f, 1, "7 -> 7");
return 0;
}
[プログラムの説明]
与えられた配列の並びを逆順にする関数iarray_reverseを作成した。
iarray_reverseでは、まず与えられた配列a[]をループを使い、その要
素を１個づつ入れていくことで配列a[]をコピーした配列c[]を作成し
た。次にループを用いてa[]の先頭から順に、c[]の要素を逆順で入れ
ていくことによって、与えられた配列a[]の並びを逆順にした。
[単体テストと実行例]
単体テストは以下の通りです。
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8},
c[] = {3,1,4,1,5,9,2,6,5}, d[] = {5,6,2,9,5,1,4,1,3},
e[] = {7}, f[] = {7};
iarray_reverse(a, 5);
expect_iarray(a, b, 5, "85241 -> 14258");
iarray_reverse(c, 9);
expect_iarray(c, d, 9, "314159265 -> 562951413");
iarray_reverse(e, 1);
expect_iarray(e, f, 1, "7 -> 7");
実行例は次のようになり、問題なく動作していた。
$ ./a.out
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 314159265 -> 562951413
5 6 2 9 5 1 4 1 3
5 6 2 9 5 1 4 1 3
OK 7 -> 7
7
7
[レビュー課題（学内の友人にしてもらった）]
「コード自体には特に問題はないけど、仮引数の宣言（今回の場合は
iarray_reveres内のint c[n] と int i）は一行にまとめて書いた方が
すっきりする。」と言われた。以降、意識していきたい。
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
納得はできましたが、使いこなせるまでにはまだ時間がかかりそうです。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
あまりよくは理解できていないので、時間をかけて理解できるようにしたい。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
テストケースの質にも、良し悪しがあると思うので、設定するときはよ
り有用なものをつくれるようにしたいなと思いました。
m1910603 2a:○ Tue May 19 20:15:57 2020
課題2a
1a
配列の最大値を求める関数とそれのテストケース
#include <stdio.h>
int iarray_max(int *a, int n) {
int j = a[0];
for(int i = 0; i < n; ++i) {
if(a[i] > j ) { j = a[i]; }
}
return j;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {4,-7,11,-8,15,6};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 6), 15, "4 -7 11 -8 15 6");
return 0;
}
変数i1にiarray_maxで求めた値が入る。
実行例
c[]は自分で追加した単体テスト
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 15:15 4 -7 11 -8 15 6
レビュー課題
変数アルファベット1文字は避けたほうが良いと思う。
変数が増えるとわからなくなる。（友人より）
Q1.ある程度は納得した
Q2.あまりよくわからない
Q3.特になし
説明1行は簡単すぎだって。もうちょっと書いてくださいね。
今回まけときます。
m1910606 2a:○ Tue May 19 17:23:45 2020
学籍番号:1910606
氏名:@@@牧野 広隼
提出日時:5月19日
プログラム:1-a
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *x, int n){
int max = x[0];
for(int i = 0; i < n; i++){
if(max < x[i]){
max = x[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1},c[] = {-4,4,0,1,6,-6};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+3,2), -1,"-4,-1");
expect_int(iarray_max(c,6), 6,"-4,4,0,1,6,-6");
return 0;
}
最大値はまず配列内の最初の数値をmaxに入れ、その後の数値と比較し
てmaxより大きくなるたびにそれをmaxに代入した。単体テストに正負が
入り混じる配列を追加した。
テスト実行結果:
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -4,-1
OK 6:6 -4,4,0,1,6,-6
レビュー:
正負を混ぜた配列においてのテストも行っていて、工夫されていて良いと思います。
アンケート:
Q1. アドレス、ポインタについて納得しましたか。
ある程度理解したと思う。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得した。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
プログラミングが長くなってきて理解に時間がかかるがしっかりとやっていきたい。
m1910615 2a:○ Tue May 19 18:02:52 2020
第02回aレポート
学籍番号：1910615
提出日時 2020/05/12
ペア:個人作業
演習 1 array equal.c、test array equal.c の例題を動かして動作を
確認しなさい。納得したら以下のものを作ってみなさい。必ず単体テス
トを動かし、またテストケースは増やしてみること。
c. 何らかの整列アルゴリズムで配列を昇順に整列する関数 void
iarray sort(int *a, int n) を作成する。
int a[] = {8,5,2,4,1}, b[] = {1,2,4,5,8};
iarray_sort(a, 5); expect_iarray(a, b, 5, "85241 -> 12458");
プログラム
#include <stdio.h>
#include <stdbool.h>
void iarray_reverse(int *a, int n);
void expect_iarray(int *a, int *b, int n, char *msg);
void iarray_print(int *a, int n);
int main (void){
int a[] = {8, 5, 2, 4, 1}, b[] = {1, 4, 2, 5, 8};
iarray_reverse(a, 5); expect_iarray(a, b, 5, "85241 -> 14258");
//追加
int d[] = {8, 5, 2, 4, 1, 5, 6}, f[] = {6, 5, 1, 4, 2, 5, 8};
iarray_reverse(d, 7); expect_iarray(d, f, 7, "8524156 -> 6514258");
return 0;
}
void iarray_reverse(int *a, int n){
int i;
int c[n - 1];
for(i = 0; i < n ; ++i){
c[n - 1 - i] = *(a + i);
}
for(i = 0; i < n ; ++i){
*(a + i) = c[i];
}
}
bool iarray_equal(int *a, int *b, int n) {
int i;
for(i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
void iarray_print(int *a, int n) {
int i;
for(i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
実行例
[m1910615@sol ~]$ ./a.out
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 8524156 -> 6514258
6 5 1 4 2 5 8
6 5 1 4 2 5 8
説明
一旦新しい配列にa[n]を記憶させ、配列を組み替えた。//追加 にテストケースを追加した。
レビュー課題
bool関数を用いることでexpect_array内の条件式がスマートにまとまっていていいと思いました
(同クラスの友人)
アンケート
Q1. アドレス、ポインタについて納得しましたか。
できました。宣言のときの*と参照のときの*が紛らわしいと感じました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
できました。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
次回も頑張りたいと思います。
m1910616 2a:○ Tue May 19 19:46:05 2020
プログラミング通論’20 ＃2 – アドレスとポインタ
課題1a
学籍番号：1910616
ペアの学籍番号：1910525
提出日時：2020/5/20
・演習1a
【課題の再掲】
配列の最大値を求める関数を作成する。
【コード】
#include <stdio.h>
#include <stdbool.h>
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iarray_max(int *a, int n){
int s = a[0];
for(int i = 1; i < n; ++i){
if(s < a[i]){ s = a[i]; }
}
return s;
}
int main(void) {
int a[] = {0, 1, 2, 3, 4, 5}, b[] = {9, 1, 2, 3, 4, 6};
int c[] = {1, 1, 4, 5, 1, 4}, d[] = {2, 7, 8, 3, 1, 4};
expect_int(iarray_max(a, 6), 5, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 5, "0 0 1 2 3");
expect_int(iarray_max(b, 6), 9, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 6), 5, "1, 1, 4, 5, 1, 4}");
expect_int(iarray_max(c+1, 5), 5, "1, 4, 5, 1, 4");
expect_int(iarray_max(d, 6), 8, "2, 7, 8, 3, 1, 4");
return 0;
}
【実行例】
OK 5:5 9 0 0 1 2 3
OK 5:5 0 0 1 2 3
OK 9:9 -1 -3 -2 -4 -1
OK 5:5 1, 1, 4, 5, 1, 4
OK 5:5 1, 4, 5, 1, 4
OK 8:8 2, 7, 8, 3, 1, 4
どれも最大値を取り出すことができていた。
【説明】
expect_int関数はテキストの通り、最初の2引数を比較して同じ値であ
るときにOKそうでなければNGを出す。iarray関数は与えられた配列の最
大値を返す。mainでは四種類の配列を用いて配列の最大値を確認し、更
にそれが望ましい結果になっているかをexpect_intを用いて確認する。
【レビュー】
R氏「簡潔にまとまっていて見やすくなっていて良いと思いました。
強いて言うならテストケースのiarray_maxの指定が偏っているのでいろ
いろ変えた方がテストにはなるかなと思いました。よりコンパクトにす
るなら#include <stdbool.h>もなくても動く気がします。」
【アンケート】
Q1. アドレス、ポインタについて納得しましたか。
最低限の仕組みは理解できたと思います。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得しました。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
レビューによってペアプログラミングですら気が付かなかったことに
気付くことができた。特に、テストケースを見返すと、全て要素数6の
配列であるが、これにはよりバリエーションを持たせた方が良いように
思えた。
最大値を返す関数の中身を説明するべきですね。まあまけときます。
おつかれ様でした。
m1910619 2a:○ Tue May 19 19:22:01 2020
プログラム通論 ＃02 課題2a
[課題の再掲]
配列の最大値を求める関数 int iarray max(int *a, int n) を作成する。
必ず単体テストを動かし、またテストケースは増やしてみること。
[実施したこととその結果]
作成したプログラム
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int max=a[0];
for(int i=0; i<n; ++i){
if(max<a[i]){max=a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
//自分で作成した単体テスト
expect_int(iarray_max(b+1, 3), -2, "-3 -2 -4");
expect_int(iarray_max(a, 3), 9, "9 0 0");
return 0;
}
その結果
[m1910619@sol ~/pro2]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
OK 9:9 9 0
[プログラムの説明]
例題を元にプログラムを作成した．配列の中の一番目の要素とその次の
要素の大小を比較し，大きいものをmaxの値とする．これをforでループ
させ，比較する要素を一つづつずらしていくることで配列の中の最大値
を求めることができるようにした．
[友人からのレビュ-]
もっと，プログラムの中に他人が見ても分かりやすいようにコメント
(//を使って)を書き込んだ方が良いと感じた．
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
納得しましたが，まだ完全理解しているとは言えないです．
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
構造は理解しました．
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
ポインタは理解しにくい部分が多かったので，時間をかけて使いこなせ
るようにしたいです．
m1910620 2a:○ Tue May 19 23:37:52 2020
[プログラミング]
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 1;i < n; ++i){
if(a[i]>max){
max=a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {10,8,3,9,11,8};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 6), 11, "10,8,3,9,11,8");
expect_int(iarray_max(c+1, 5), 8, "8,3,9,11,8");
return 0;
}
[テストケース]
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 11:11 10,8,3,9,11,8
NG 11:8 8,3,9,11,8
[説明]
iarray_maxで配列の最大値を求める関数を作成した。
またvoid expect_intではあるに数を比べ、同じ数だった場合にOK、違っ
た場合NGを表示させる関数を作った。メインではこれら２つを用い、
expectのi1に最大値を入れ、i2には予想値を入力した。
[レビュー課題]
見やすくまとめられていて良かったと思う。
他のやり方がないか考えてみてもらいたい。
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
ポインタを使うと便利だと納得した。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
あまり理解できなかった。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
C言語は難しいと感じた。
m1910626 2a:○ Tue May 19 17:08:25 2020
1910626
個人作業
5/19
＜演習1c＞
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
void iarray_sort(int *a, int n){
int x = 0;
for(int i = 0; i < n; ++i){
for(int j = i + 1; j < n; ++j){
if (a[i] > a[j]){
x = a[i];
a[i] = a[j];
a[j] = x;
}
}
}
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,2,4,5,8}, c[] = {3,-5,0,-1,10}, d[] = {-5,-1,0,3,10};
iarray_sort(a, 5); expect_iarray(a, b, 5, "85241 -> 12458");
iarray_sort(c, 5); expect_iarray(c, d, 5, "3-50-110 -> -5-10310");
return 0;
}
(iarray_sortの説明)
変数iとjを用意し、配列の要素の番号を示した。i番目とj番目を比較す
る。iとjの初期値はそれぞれ0と１で、要素数0番目と１番目、０番目と
２番目…、０番目とn番目という順番に比較していき、その後iの値を1
ずつ増やしていった。i番目がj番目よりも大きい時は値を入れ替える。
代入の際に値が消えてしまわないよう、xという初期値０の変数に保存
できるようにした。
(単体テストの実行結果)
mizukoshikairinoMacBook-Pro:c mizukoshikairi$ ./a.out
OK 85241 -> 12458
1 2 4 5 8
1 2 4 5 8
OK 3-50-110 -> -5-10310
-5 -1 0 3 10
-5 -1 0 3 10
(クラスメートから頂いたコメント)
iarray_sort内に用意したint xにわざわざ0を代入する必要はない。
(アンケート）
A1.まだ理解不十分な点が多く、納得するまでには至っていない。
A2.難しかったので復習しておこうと思った。
A3.とても難しかった。関数が多数出てくると、様々なエラーが出るので大変だった。
様々なエラーがまず取れるようにはなるべきでしょ。おつかれ様です。
m1910627 2a:○ Tue May 19 20:03:13 2020
学籍番号 1910627
個人作業
提出日時 5月19日 20時頃
プログラム
演習1-a
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int i;
int max = a[0];
for(i = 1; i < n; i++){
if(max < a[i]){
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3,}, b[] = {-1,-3,-2,-4,-1};
int c[] = {3,8,4,6};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
//テスト増やした
expect_int(iarray_max(a+4,2), 3, "2 3");
expect_int(iarray_max(b+4, 1), -1, "-1");
expect_int(iarray_max(a+2,4), 3," 0 1 2 3 ");
expect_int(iarray_max(c+1,3), 8, "8 4 6");
expect_int(iarray_max(c+2,2),6, "4 6");
return 0;
}
実行例
m1910627@DESKTOP-QOKSOM0:/mnt/c/Users/みずたかずし/Documents/prog/02$ gcc 1a.c
m1910627@DESKTOP-QOKSOM0:/mnt/c/Users/みずたかずし/Documents/prog/02$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 3:3 2 3
OK -1:-1 -1
OK 3:3 0 1 2 3
OK 8:8 8 4 6
OK 6:6 4 6
説明
関数iarray_maxには配列の要素数も渡すので、その要素数-1がその配列
の添え時の最大の数になる。最初にa[0]をその配列の最大(max)として
仮定し、iを0から要素数-1まで繰り返しmaxとa[i]の比較をして大きい
方をmaxに代入することで配列の最大値を得た。
レビュー（友人より）
テストケース増やしてるし、//でテスト増やしたとコメントしてるのわ
かりやすかった
アンケート
Q1. アドレス、ポインタについて納得しましたか。
納得したつもりだが、実際にもっと使っていかないと危うい気がしています
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだ納得できてないです
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
難しくなってきたが1年の頃より時間空いてるので頑張りたい。チャッ
トの質問は消えたりせず残るのが便利だと思いました。
m1910629 2a:○ Tue May 19 20:51:57 2020
1910629
個人作業,5/19
--以下コード
#include <stdio.h>
#include <stdbool.h>
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
void iarray_reverse(int *a, int n){
int b[n];
for(int i=0;i<n;i++){
b[i] = a[n-i-1];
}
for(int i=0;i<n;i++){
a[i] = b[i];
}
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};
iarray_reverse(a, 5); expect_iarray(a, b, 5, "85241 -> 14258");
int c[] = {1}, d[] = {1};
iarray_reverse(c, 1); expect_iarray(c, d, 1, "1 -> 1");
int e[] = {8,5}, f[] = {5,8};
iarray_reverse(e, 2); expect_iarray(e, f, 2, "85 -> 58");
return 0;
}
--以下実行例
PS C:\~\PRG2020\2> .\a.exe
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 1 -> 1
1
1
OK 85 -> 58
5 8
5 8
簡単な説明:
iarray_print,iarray_equal,expect_iarrayはコード例そのまま．
iarray_reverse:一時保存用の配列bを作りaを逆順でコピーする．この
配列bをaにコピーしてaを逆順にしている．
テストケース:要素の内容それ自体は操作しないので，要素数がバグの
元になると考えられる．そのため，要素数1のケースを追加した．
レビュー(同クラスの友人から):別の配列を用意し、末尾の値から取り
出して代入していっているプログラム。単体テストでは要素が1個の配
列のケースを調べられている。
アンケート:
A1:内容は納得できたが感覚的には理解できていないような気がする．
A2:未だ見ていないのでこれを書き終わったら触れようと思う．
A3:単体テストについて，JR1のP演習などで触れたことはあったが，初
めて体系的に理解できた．
m1910631 2a:○ Tue May 19 22:45:50 2020
プログラミング通論レポートa#2
＜課題＞
演習1b 配列を逆順にするプログラム
＜コード＞
#include <stdio.h>
#include <stdbool.h>
void iarray_print(int *a, int n){
for (int i = 0; i < n; ++i)
{
printf(" %2d", a[i]);
}
printf("\n");
}
bool iarray_equal(int *a, int *b, int n){
for (int i = 0; i < n; ++i)
{
if (a[i] != b[i])
{
return false;
}
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg){
printf("%s %s\n", iarray_equal(a, b, n) ? "OK" : "NG", msg);
iarray_print(a, n);
iarray_print(b, n);
}
void iarray_reverse(int *a, int n){
int lim = n/2;
for (int i = 0; i < lim; ++i){
int d = a[i];
a[i] = a[n-1-i];
a[n-1-i] = d;
}
}
int main(){
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};
iarray_reverse(a, 5); expect_iarray(a, b, 5, "85241 -> 14258");
int c[] = {8,5,2,4}, d[] = {4,2,5,8};
iarray_reverse(c, 4); expect_iarray(c, d, 4, "8524 -> 4258");
int e[] = {1}, f[] = {1};
iarray_reverse(e, 1); expect_iarray(e, f, 1, "1 -> 1");
}
＜説明＞
左端と右端、左から2番目と右から2番目……と一時格納用の変数を使っ
て真ん中の数まで順に交換した。
＜テスト結果＞
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 8524 -> 4258
4 2 5 8
4 2 5 8
OK 1 -> 1
1
1
＜レビュー＞
dという変数名をもっと媒介変数っぽくわかりやすい名前にしてもいいと思います
＜アンケート＞
A1.完全には理解できなかったと思う
A2.理解途中
A3.ポインタのポインタを知った
m1910632 2a:○ Tue May 19 16:11:22 2020
レポート2a
選択した課題: 1-b: 配列の並び順を逆順にする関数を作成する。
方針:
右から1番目と左から1番目を入れ替えて、右から2番目と左から2番目を
入れ替えて、...、右からn/2番目と左からn/2番目を入れ替えれば逆順
にできるはずなので、そのように実装することにした。
コード: プログラム一式(動くものを貼ること)
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
void iarray_reverse(int *a, int n) {
int j, tmp;
for(int i = 0; i < n/2; ++i) {
j = n-1-i;
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void) {
int a1[] = {8,5,2,4,1}, b1[] = {1,4,2,5,8};
iarray_reverse(a1, 5);
expect_iarray(a1, b1, 5, "85241 -> 14258");
int a2[] = {1,1,1,1,1}, b2[] = {1,1,1,1,1};
iarray_reverse(a2, 5);
expect_iarray(a2, b2, 5, "11111 -> 11111");
int a3[] = {-2,-2,-1,1,0}, b3[] = {0,1,-1,-2,-2};
iarray_reverse(a3, 5);
expect_iarray(a3, b3, 5, "-2,-2,-1,1,0 -> 0,1,-1,-2,-2");
int a4[] = {8}, b4[] = {8};
iarray_reverse(a4, 1);
expect_iarray(a4, b4, 1, "8 -> 8");
int a5[] = {0,2,4,0,5,7,2,7,5,1};
int b5[] = {1,5,7,2,7,5,0,4,2,0};
iarray_reverse(a5, 10);
expect_iarray(a5, b5, 10, "0240572751 -> 1572750420");
int a6[] = {1,0,6,8,3,4,1,1,6,3,0,3,4,8,2};
int b6[] = {2,8,4,3,0,3,6,1,1,4,3,8,6,0,1};
iarray_reverse(a6, 15);
expect_iarray(a6, b6, 15, "106834116303482 -> 284303611438601");
int a7[] = {188,576,317,-845,-419,-443,496,274,-419,810};
int b7[] = {810,-419,274,496,-443,-419,-845,317,576,188};
iarray_reverse(a7, 10);
expect_iarray(a7, b7, 10, "188,576,317,-845,-419,-443,496,274,-419,810 -> 810,-419,274,496,-443,-419,-845,317,576,188");
int a8[] = {}, b8[] = {};
iarray_reverse(a8, 0);
expect_iarray(a8, b8, 0, " -> ");
int a9[] = {1,2,3,4,3,2,1}, b9[] = {1,2,3,4,3,2,1};
iarray_reverse(a9, 7);
expect_iarray(a9, b9, 7, "1234321 -> 1234321");
return 0;
}
実行結果:
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 11111 -> 11111
1 1 1 1 1
1 1 1 1 1
OK -2,-2,-1,1,0 -> 0,1,-1,-2,-2
0 1 -1 -2 -2
0 1 -1 -2 -2
OK 8 -> 8
8
8
OK 0240572751 -> 1572750420
1 5 7 2 7 5 0 4 2 0
1 5 7 2 7 5 0 4 2 0
OK 106834116303482 -> 284303611438601
2 8 4 3 0 3 6 1 1 4 3 8 6 0 1
2 8 4 3 0 3 6 1 1 4 3 8 6 0 1
OK 188,576,317,-845,-419,-443,496,274,-419,810 -> 810,-419,274,496,-443,-419,-845,317,576,188
810 -419 274 496 -443 -419 -845 317 576 188
810 -419 274 496 -443 -419 -845 317 576 188
OK ->
OK 1234321 -> 1234321
1 2 3 4 3 2 1
1 2 3 4 3 2 1
解説:
j = n-1-i と定義する。
0 <= i <= n/2 の範囲でループを回す。
ループでは一時変数tmpを使う。まずtmpにa[i]を入れ、a[i]にa[j]を入れ、a[j]にtmpをいれる。
こうすることでa[i]とa[j]の入れ替えをすることができた。
この操作は配列aの左からi番目と右からi番目を入れ替えることに対応
する。これをn/2まで繰り返すとaは順番が逆転する。
nが奇数の時はn/2は小数点以下が切り捨てられるが、奇数個の配列にお
いて中央の要素は逆順にしても位置が変わらないので問題ない。
レビュー課題:
n-i-1を変数jに入れることで、一行一行がすっきりしていてとても見や
すくなっていると思います。
アンケート:
Q1. アドレス、ポインタについて納得しましたか。
納得した。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得した。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
可変長配列の仕組みを理解できた。先頭に要素数を持つことでスムーズ
に新しい要素の追加ができると分かった。
m1910636 2a:○ Tue May 19 16:00:30 2020
プログラム
演習1b
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
/****ここから****/
//1b
void iarray_reverse(int *a,int n){
int buf;
for(int i=0;i<n/2;i++){// n/2ループ
buf=a[i];
a[i]=a[n-i-1];
a[n-i-1]=buf;
}
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};//要素数が奇数
iarray_reverse(a, 5); expect_iarray(a, b, 5, "85241 -> 14258");
int c[] = {}, d[] = {};//0
iarray_reverse(c, 0); expect_iarray(c, d, 0, " -> ");
int e[]={1,2,3,4},f[]={4,3,2,1};//偶数
iarray_reverse(e,4); expect_iarray(e, f, 4, "1234 -> 4321");
int g[]={42},h[]={42};//1つ
iarray_reverse(g,1); expect_iarray(g, h, 1, "42 -> 42");
int i[]={1,2,3,4,5},j[]={4,3,2,1,5};//配列の途中まで
iarray_reverse(i,4); expect_iarray(i, j, 5, "12345 -> 43215");
int k[]={1,2,3,4,5},l[]={1,5,4,3,2};//途中から
iarray_reverse(k+1,4); expect_iarray(k, l, 5, "12345 -> 15432");
return 0;
}
説明
配列を逆順にする関数を作成した。要素数の半分(要素数が奇数のとき
は小数点以下切り捨て)の回数分for文で繰り返し、先頭からi番目を一
旦bufという変数に入れ、後ろからi番目の値先頭からi番目に入れ、後
ろからi番目をbufで書き換える。という方法を用いた。テストケースと
して、配列の長さを偶数、奇数の両方について試し、また、要素数0、1
なども試した。他にも、配列の途中までや途中からのみ入れ替えるとい
うことも試した。
実行例
$ ./activity1b.out
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK ->
OK 1234 -> 4321
4 3 2 1
4 3 2 1
OK 42 -> 42
42
42
OK 12345 -> 43215
4 3 2 1 5
4 3 2 1 5
OK 12345 -> 15432
1 5 4 3 2
1 5 4 3 2
レビュー課題
友人より
様々なテストケースを考えたことは良いと思います。
アンケート
Q1.アドレス、ポインタについて納得しましたか。
大体は納得したが、関数のポインタの考え方が難しかった。
Q2.「構造体を用いた情報隠蔽」について納得しましたか。
難しく、納得できていないので課題を通して理解したい。
Q3.リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
ポインタや配列の使い方、動的メモリ管理について分かった。難しい
内容だがしっかり復習をして身につけたい。
m1910638 2a:○ Tue May 19 22:22:17 2020
1.演習1.a コード
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 1; i < n; ++i){
if(max < a[i])
max = a[i];
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1,3), -2, "-3 -2 -4”);//追加のテストケース
return 0;
}
2.実行例
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
3.説明
iarray_maxではmaxの初期値を与えられる配列の0番目の数字とし、一つ
づつ大小を比べて大きな方をmaxに入れ、最後にmaxの値を返した。追加
したテストケースは「負の値を与えられたときにfor文が正常に動いて
いるか」の確認に使用した。for文が動いていない場合、初期値として
設定した0番目の数字（この場合−３）が返されることになるが、正常
に作動しているので−２が返されOKと表示された。
4.レビュー（友人より）
追加したテストケースの想定を聞くと「最初や最後に入っている数字が
maxに入ってしまっただけかもしれない」と言われ納得した。
5.アンケート
A1.納得はしたが感覚的にまだつかめていない。
A2.納得した。
A3.もう少しテキストを熟読してみようと思った。
もうちょっとテストケース追加してください。おつかれ様です。
m1910640 2a:○ Tue May 19 19:44:10 2020
プログラミング通論 課題2aレポート
個人作業
提出日付:5月19日
[課題再掲]
書いたプログラムは下である。
#include <stdio.h>
//テストケース確認時はDEBUGを有効にする。
#define DEBUG
int iadd(int x, int y);int imax(int x, int y);
int iarray_inject(int *a, int n, int (*fp)(int, int));
void expect_int(int a, int n, char *msg);
int main(void) {
int a[] = {8,5,2,4,1};
printf("sum: %d/max: %d\n", iarray_inject(a, 5, iadd), iarray_inject(a, 5, imax));
#ifdef DEBUG
int a1[] = {2, -1, -6, 5, 4, 0, 1, 0};
expect_int(iarray_inject(a1, 8, iadd), 5, "2+(-1)+(-6)+5+4+0+1+0");
expect_int(iarray_inject(a1, 8, imax), 5, "max(2,-1,-6,5,4,0,1,0)");
int a2[] = {1,2,3,4,5,6};
expect_int(iarray_inject(a2, 6, iadd), 21, "1+2+3+4+5+6");
expect_int(iarray_inject(a2, 6, imax), 6, "max(1,2,3,4,5,6)");
int a3[] = {0,0,0,0};
expect_int(iarray_inject(a3, 4, iadd), 0, "0+0+0+0");
expect_int(iarray_inject(a3, 4, imax), 0, "max(0,0,0,0)");
int a4[] = {-5, 90, -6, 30};
expect_int(iarray_inject(a4, 4, iadd), 109, "(-5)+90+(-6)+30");
expect_int(iarray_inject(a4, 4, imax), 90, "max(-5,90,-6,30)");
#endif
return 0;
}
int iadd(int x, int y) { return x+y;}
int imax(int x, int y) { return (x > y)?x:y;}
int iarray_inject(int *a, int n, int (*fp)(int, int)) {
int sum = 0, max = a[0];
for(int i = 0; i < n; i++){
if(fp == iadd){
sum = iadd(sum, a[i]);
}else if(fp == imax){
max = imax(max, a[i]);
}
}
if(fp == iadd){
return sum;
}else if(fp == imax){
return max;
}
return 0;
}
void expect_int(int a, int n, char *msg) {
printf("%s\n", (a == n)?"OK":"NG");
printf("question : %s\n", msg);
printf("expected : %d\n", n);
printf("result : %d\n\n", a);
}
このプログラムでは受け取った変数2つを足し合わせるiaddと2つの変数
のうち最大値を返すimaxを用意した。次に、配列と配列の大きさと関数
のポインタを入力して関数の結果を整数として得るiarray_injectを用
意した。さらにテストケースを試すものとしてexpect_intという関数も
用意した。
実行した結果は下である。
[]$ ./a.out
sum: 20/max: 8
OK
question : 2+(-1)+(-6)+5+4+0+1+0
expected : 5
result : 5
OK
question : max(2,-1,-6,5,4,0,1,0)
expected : 5
result : 5
OK
question : 1+2+3+4+5+6
expected : 21
result : 21
OK
question : max(1,2,3,4,5,6)
expected : 6
result : 6
OK
question : 0+0+0+0
expected : 0
result : 0
OK
question : max(0,0,0,0)
expected : 0
result : 0
OK
question : (-5)+90+(-6)+30
expected : 109
result : 109
OK
question : max(-5,90,-6,30)
expected : 90
result : 90
[レビュー課題]
友人からこのプログラムについてレビューをいただきました。
〇コードに関して
"#define DEBUG", "#ifdef DEBUG", "#endif"を使ってテストケースの
オンオフを切り替えているのがいいと思った。
iarray_inject内3～6行目:
関数のポインタの良さを殺してしまっている。
〇アルゴリズムに関して
iarray_inject内1～13行目:
変数sum, maxに対して変数xを"int x = a[0];"とし、forのループを
"for(int i = 1;i < n; ++i) {"とすれば
4,6行目は"x = iadd(x, a[i]);", "x = imax(x, a[i]);"でよくなり、
変数を1つですませることができる。
また、9～13行目は"return x;"のみでよくなる。
[考察]
array_injectでは変数としてmaxとsumの二つを用意し、fpに代入された
ものがimaxかisumであるかによって計算を変えるようにした。このとき、
代入されたfpがisum、imaxと一致するかどうかを調べた。この結果から
関数名は数値比較と同様に==を使って名前が一致するかを判定できるこ
とが分かった。また、友人からの指摘にもあった通りfpを代入したのに
も関わらず、fpが一体何だったのかを調べる条件文を経た上での計算に
なってしまっている。imax、isumを上手くfpで統一して表現できるよう
に書くべきであった。テストケースはそのプログラムにバグがないかを
調べるときにのみ使うので#ifdef DEBUGによって切替できるようにして
おくと便利である。
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
ある程度は納得できましたが、まだ使いこなせません。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
「ひとまとまりの機能を実装するデータ構造を実装するコードだけから
参照可能にし、それ以外からは見えなくする」というのがよくわかって
ません。もう少しテキストを読みます。
Q3. 感想、要望
ポインタをまだ使いこなせないのでたくさん練習していきたいです。
m1910646 2a:○ Tue May 19 22:56:49 2020
1910646
「個人作業」
2020/5/19
[プログラムのソース]
演習1-b
#include <stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_reverse(int *a, int n) {
for(int i = 0; i < n/2; i++) {
int t = a[i];
a[i] = a[n-i-1];
a[n-i-1] = t;
}
for(int j = 0; j < n; j++){
printf(" %2d", a[j]);
}
printf("\n");
}
int main(void) {
int a[5];
iarray_read(a, 5); iarray_reverse(a, 5);
return 0;
}
[単体テスト]
#include <stdio.h>
#include <stdbool.h>
(iarray_read,iarray_print,iarray_equal,iarray_reverse here)
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void expect_reverse(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};
iarray_reverse(a, 5); expect_reverse(a, b, 5, "85241 -> 14258");
int c[] = {3,1,9}, d[] = {9,1,3};
iarray_reverse(c, 3); expect_reverse(c, d, 3, "319 -> 913");
int e[] = {1}, f[] = {1};
iarray_reverse(e, 1); expect_reverse(e, f, 1, "1 -> 1");
return 0;
}
[単体テストの実行]
1 4 2 5 8
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
9 1 3
OK 319 -> 913
9 1 3
9 1 3
1
OK 1 -> 1
1
1
[プログラムの実行例]
1> 1
2> 2
3> 3
4> 4
5> 5
5 4 3 2 1
1> 1
2> 3
3> 5
4> 7
5> 9
9 7 5 3 1
1> 12
2> 42
3> 6
4> 23
5> 14
14 23 6 42 12
[簡単な説明]
配列aの要素数nをうまく用いることで、配列aの並び順を逆転させた。
実行例にあるように、このままでは要素数が5個の配列しか並び順を逆
転させることはできないが、main関数内の要素数を替えることで様々な
配列に対応できる。
[レビュー課題]
n/2回の入れかえによって逆順に並び替えしていて、計算回数を減らす
工夫が良いと思います。
[アンケート]
Q1.まだ理解できていない部分も多い。
Q2.まだ理解できていない部分も多い。
Q3.まだ理解できていない箇所も多いのでしっかり復習しようと思う。
n1910483 2a:○ Tue May 19 15:03:48 2020
学籍番号：1910483
（個人作業）
提出日時：2020/5/19
<製作プログラム>
2-a
int *ivec_concat(int *a, int *b) {
int *c = ivec_new(a[0]+b[0]);
int j = 1;
int n = b[0];
int i;
if(a[0]<b[0]){
n = a[0];
}
for(i = 1; j <= n ; i+=2) { c[i] = a[j]; c[i+1] = b[j]; j+=1;}
if(a[0]<b[0]){
for(int k = i ; j <= b[0];++k){
c[k] = b[j]; j+=1;
}
}else{
for(int l = i ; j <= a[0];++l){
c[l] = a[j] ; j+=1;
}
}
return c;
}
int main(void) {
int a[] = {3,1,2,3}, b[] = {3,4,5,6}, c[] = {6,1,4,2,5,3,6}, d[] = {1,4}, e[]={4,1,4,2,3},f[] = {9,1,1,2,4,3,2,5,3,6};
int *p = ivec_concat(a, b);
int *q = ivec_concat(a, d);
int *r = ivec_concat(a, c);
expect_iarray(p, c, 7, "[1,2,3]+[4,5,6]=[1,4,2,5,3,6]");
expect_iarray(q, e, 5, "[1,2,3]+[4]=[1,4,2,3]");
expect_iarray(r, f, 10, "[1,2,3]+[1,4,2,5,3,6]=[1,1,2,4,3,2,5,3,6]");
return 0;
}
このプログラムは、2つの配列の要素を、交互に入れた新しい配列を作
るプログラムである。2つの配列の長さが異なるときは、if文を用いて
それぞれの状況に応じて長い方の配列を後ろに詰めるようにしている。
テストケースにおいて、2つの配列をa,bとしたとき、「aの方が長いケー
ス」「bの方が長いケース」「a,bで長さが同じであるケース」の3つを
採用している。これによって、2つの配列の長さが異なるとき、つまり
プログラム中のif文でのオプションが機能しているかをテストすること
ができる。
＜レビュー＞
レビュワー：歴戦の棋士
「concatの処理が2つの配列のサイズに応じて上手く条件分岐していて、
自分とは違った方法で行われていたので勉強になった。」
＜アンケート＞
Q1.結果を見て結果から納得した、というものが主。中身を完全に理解
できたといえないため、演習などで復習しながら理解に努めたい。
Q2.テキストをざっと見ただけなので、演習を通して理解したい。
Q3.今回のプログラムもそうだが、最近自分でプログラムを読み解くこ
とに喜びを感じるようになってきた気がする・・・
おつかれ様でした。関数名はivec_interploateとか
ivec_alternate_concatとか工夫した方がいいですね。
n1910485 2a:○ Tue May 19 18:20:01 2020
第2回プログラミング通論 A課題
①プログラム
1a
// test_array_max.c --- unit test of array_max
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; i++) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int max = a[0];
int i;
for(i=0;i<n;i++){
if(a[0]<a[i]){max = a[i];}
}
return max;
}
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[4];
iarray_read(a, 4); iarray_print(a, 4);
printf("max is %d\n",iarray_max(a,4));
return 0;
}
↑ここまでのmainが通常時
↓ここからのmainが単体テスト時
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(a+1, 3), 1, "0 0 1");
return 0;
}
②実行例,単体テスト
（実行例）
[n1910485@sol ~/prg]$ ./a.out
1> 9
2> 4
3> -3
4> 6
9 4 -3 6
max is 9
[n1910485@sol ~/prg]$ ./a.out
1> 342
2> 346
3> 643
4> 642
342 346 643 642
max is 643
[n1910485@sol ~/prg]$ ./a.out
1> 532
2> 5742
3> 4366423
4> 42
532 5742 4366423 42
max is 4366423
（単体テスト）
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 1:1 0 0 1
③プログラムの説明
ここでは、int iarry_maxとmainの関数について説明する。
iarray_maxは、最終的に最大値が入るint型の変数maxに、まずa[0]を入
れる。そして、a[1]~a[n-1]の全ての配列の要素についてmaxと比べて大
きい場合はmaxにその要素の値を入れる。こうすることでmaxは次々と大
きいものに変わっていき、最終的最大値が入る。
④レビュー
友達から
iarray_maxの関数がおそらく1番シンプルな形でまとまっていると思う。
それに加えて単体テストの中も整数に変えていて良い
⑤アンケート
Q1. アドレス、ポインタについて納得しましたか。
基礎プロのときはほとんど分からなったが、番地や*の意味がようやく分かってきた。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだそこまで行っていないので、次週までに見ておきたい。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
チャットで質問を共有できてよかった。
n1910493 2a:○ Tue May 19 15:01:43 2020
プログラミング通論レポート 2a
学籍番号：1910493
ペアの学籍番号：個人作業
提出日時：2020/5/19
------
・演習1-a：配列の最大値を求める関数の作成
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 1; i < n; ++i) {
if(a[i] > max) { max = a[i]; }
}
return max;
}
---単体テスト---
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3"); //all of a
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3"); //a[1] to end of a
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1"); //all of b
expect_int(iarray_max(a+1, 2), 0, "0 0"); //the case of same numbers
expect_int(iarray_max(b+1, 3), -2, "-3, -2, -4"); //b[1] to b[3]
return 0;
}
---実行例---
% ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 0:0 0 0
OK -2:-2 -3, -2, -4
---説明---
配列の最初の要素をmaxというint型の変数に入れ、for文内で、配列
の要素を一つずつmaxと比較し、もしmaxよりも大きいものがあったら上
書きするというループを組んで、最後に最大値を返すようにした。 単
体テストでは、全く同じ数だった場合(a+1, 2)と、配列bについて最初
と最後がなかった場合(b+1, 3)を追加した。
---レビュー課題---
(寮の同じユニットの友達より)
配列の要素が全く同じ数しかなかった場合のテストがある点が良いと思う。
---アンケート---
Q1. アドレス、ポインタについて納得しましたか。
書き方はなんとなくわかりましたが、どういう仕組みになっているのか
まだ完全には理解できていません。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
授業の時間ではそこまで進むことができなかったので、2bに取り組む際
に納得できるよう演習に励みます。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
図があったことで、参照がどうなっているのか分かりやすかったです。
2bでの演習を通し、理解できるよう頑張ります。ありがとうございました。
n1910496 2a:○ Tue May 19 21:05:24 2020
学籍番号：1910496
個人作業
提出日時；2020/5/19 21:05
・プログラム
// 1-a
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 0; i < n; ++i) {
if(a[i] >= max) { max = a[i]; }
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(a+5, 1), 3, "3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+2, 1), -2, "-2");
return 0;
}
・説明
配列の最大値を求めるプログラム。最大値の変数の初期値を初項にし、
順に比較していって最大値を更新していくアルゴリズム。
・単体テストと実行結果
a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}における演習で指定さ
れたテストケース、
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(a+5, 1), 3, "3");
に加え、新たに配列は用意せず、
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+2, 1), -2, "-2");
で単体テストをおこなった。
以下、その実行結果である。
[n1910496@sol ~]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK 3:3 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -2
・友人からのレビュー
最初に先頭の要素を暫定的な最大値として定義し、後続の要素と順番に
比較してこれより大きい値があれば暫定最大を更新していって最大値を
求めている。テストケースについては、バグが起きやすい0や負の数、
要素数1の配列を取り入れている。
・アンケート
Q1. アドレス、ポインタについて納得しましたか。
納得しました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得しました。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
B課題も頑張ります。
n1910498 2a:○ Tue May 19 16:05:19 2020
レポート2a
【選択した課題】
演習１-ｂ
配列の並び順を逆順にする関数 void iarray revese(int *a, int n)
を作成せよ。また、必ず単体テストを動かし、またテストケースは増
やすこと。
【コード】
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
void iarray_reverse(int *a, int n){
for(int i = 0; i < (n/2); ++i) {
int x = a[i];
a[i] = a[n-1-i];
a[n-1-i] = x;
}
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};
int c[] = {8,5,2,4,1,0}, d[] = {0,1,4,2,5,8};
int e[] = {}, f[] = {};
iarray_reverse(a, 5); expect_iarray(a, b, 5, "85241 -> 14258");
iarray_reverse(c, 6); expect_iarray(c, d, 6, "852410 -> 014258");
iarray_reverse(e, 0); expect_iarray(e, f, 0, " -> ");
return 0;
}
【実行例】
$ ./a.out
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 852410 -> 014258
0 1 4 2 5 8
0 1 4 2 5 8
OK ->
【説明・考察】
一番先頭の数字と一番後ろの数字を交換し、繰り返しを使いながら同
じように端からどんどん交換していくプログラムを作成した。(なので
n/2を繰り返しの最後にした)
また、単体テストについては数字の数が奇数の場面と偶然の場合、そ
して０(空の配列)の場合を作成した。
【レビュー課題】
しっかりプログラミンされており、よく出来ています。気になる点も
ありません。(他クラスの友人N.Sさんより)
【アンケート】
Q1. アドレス、ポインタについて納得しましたか。
納得しました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだよくわかっていないので、次回までにしかっり学習しておきたいです。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
次回も頑張りたいです。
n1910506 2a:△ Tue May 19 14:45:45 2020
プログラミング課題
学籍番号1910506
課題提出日 5月19日
プログラミングどれかひとつとその説明
配列を受け取り、昇順に整列する。
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a,int n){
for(int i = 0;i < n;++i) {
printf("%d> ",i+1);scanf("%d",a+i);
}
}
void iarray_print(int *a,int n) {
for(int i = 0;i < n;++i) {
printf(" %2d",a[i]);
printf("\n");
}
}
bool iarray_equal(int *a,int *b,int n){
for(int i = 0;i < n;++i){
if(a[i] !=b[i]){return false;}
}
return true;
}
void expect_iarray(int *a,int *b,int n,char *msg){
printf("%s %s\n", iarray_equal(a,b,n)?"OK":"NG",msg);
iarray_print(a,n);iarray_print(b,n);
}}
void iarray_sort(int *a, int n) {
int m;
for(int i = 0;i <n;++i){
for(int i = 0;i <n;++i){
if(a[i] > a[i+1]){
m = a[i];a[i]=a[i+1];a[i+1] =m;
}
}
}
}
int main(void) {
int a[] = {8,5,4,2,1},b[] = {1,2,4,5,8};
int c[]={3,2,3,6,4,6,4},d[]={2,3,3,4,4,6,6};
iarray_sort(a,5);expect_iarray(a,b,5,"85421 -> 12458");
iarray_sort(c,7);expect_iarray(c,d,7,"3236464->233446");
}
レビュー
父:なかなかきれいに整列していて、プログラムをみやすかった
でも、いらないプログラムは消した方がいい。
アンケート
Q1.アドレス、ポインタについて納得しましたか。
まだまだ時間がかかりそう。
Q2.「構造体を用いた情報隠蔽について納得しましたか。
なんとなく分かった。
Q3.リフレクション(今回の課題で分かったこと)・感想・要望
ポインタは複雑そうだと思うがそれが理解できれば、C言語が理解できる気がする。
プログラムの説明が1行しかない。レポートに実行例が含まれていない。
n1910507 2a:○ Tue May 19 14:54:07 2020
提出日時：2020/5/19
[演習1a]
[ソースコード]
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a, int n){
int max=a[0];
for(int i=0; i<n; ++i){
if(max<a[i]){
max=a[i];
}
}
return max;
}
void expect_int(int max, int x, char *msg){
printf("%s %s : max=%d\n", (max==x)?"OK":"NG", msg, x);
}
int main(void){
int a[]={9, 0, 0, 1, 2, 3}, b[]={-1, -3, -2, -4, -1};
int c[]={9, 8, 7, 6, 5, 4, 3, 2, 1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(c, 9), 9, "9 8 7 6 5 4 3 2 1");
expect_int(iarray_max(c+1, 8), 8, "8 7 6 5 4 3 2 1");
expect_int(iarray_max(c+2, 7), 7, "7 6 5 4 3 2 1");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 4), -1, "-3 -2 -4 -1");
return 0;
}
[実行結果]
OK 9 0 0 1 2 3 : max=9
OK 0 0 1 2 3 : max=3
OK 9 8 7 6 5 4 3 2 1 : max=9
OK 8 7 6 5 4 3 2 1 : max=8
OK 7 6 5 4 3 2 1 : max=7
OK -1 -3 -2 -4 -1 : max=-1
OK -3 -2 -4 -1 : max=-1
[説明]
配列の最大値を求める関数と単体テスト。テストケースはより多くのテ
ストをするために新しくcという配列をつくった。
[レビュー]
テストケースを増やしていて丁寧に確認しているのがいいと思った。(友人)
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
完全に納得したとは言いがたい。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得した。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
ポインタについて理解しきれていないので、今週中に理解したいと思う。
n1910509 2a:○ Tue May 19 15:21:47 2020
1.1910509 根古谷 勇作(個人作業) 提出日 ５/19
2. プログラム
#include <stdio.h>
#include <stdbool.h>
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int iarray_max(int *a,int n){
int max = a[0];
for(int i=0;i<n;++i){if(max<a[i]){max = a[i];}}
return max;
}
int main(void) {
int a[] = {0, 1, 2, 3, 4, 5},b[]={-1,-3,-2,-4,-1},c[]={0,0,2};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+3, 2), -4, "-4 -1");
expect_int(iarray_max(a+4, 2), 2, "4 5");
expect_int(iarray_max(c, 3), 0, "0 0 2");
return 0;
}
テストケース
NG 5:9 9 0 0 1 2 3
NG 5:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
NG -1:-4 -4 -1
NG 5:2 4 5
NG 2:0 0 0 2
プログラムの説明
配列中の最初の値を最大値とし、その他のすべての配列の要素と比較し
て最大値を求めるプログラムを作成した。テストケースも新たに自分で
配列を作成して行った。
3. 友人のコメント:〈stdbool.h〉が余分だと思われる。テストケース多くていいと思う。
4. 以下のアンケートの回答。
Q1. アドレス、ポインタについて納得しましたか。
復習で理解できた。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
あまりわからなかった。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
しっかり復習して授業に追いついていきたいと思います。
提出ファイルの文字コードはUTF8にしてください。
単体テストでNGが出てたらいけないんじゃないの(expect_intに
指定している値が最大値になっていない、つまりテストケースが
間違っている)。今回はまけときます。おつかれ様でした。
n1910513 2a:○ Tue May 19 19:49:04 2020
提出日:2020/05/19
演習1a. 配列の最大値を求める
int iarray_max で先頭から順に比較して最大値を求めた。
プログラム：
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n) {
int max=a[0];
for(int i = 1; i < n; ++i) {
if(a[i] > max) { max = a[i]; }
}
return max;
}
void expect_int(int a1, int a2, char *msg) {
printf("%s %d:%d %s\n", (a1==a2)?"OK":"NG", a1, a2, msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4, -1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 3), -2, "-3 -2 -4");
return 0;
}
実行結果：
[n1910513@sol 02]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
レビュー:
｢配列の途中部分だけを比べるテストケースを増やしていて、既存のテ
ストケースにはない形でよいと思います。｣(TA宮島さんから)
アンケート:
Q1.アドレス、ポインタについては納得した。
Q2.情報隠蔽については理解が難しかった。
Q3.ポインタについて去年分からなかったところが理解出来た。
n1910519 2a:○ Tue May 19 19:32:22 2020
演習1a
配列の最大値を求める関数int iarray_max(int *a, int n) を作成する。
コード
#include<stdio.h>
#include<stdbool.h>
void iarray_read(int *a, int n){
for(int i=0; i<n; ++i){
printf("%d> ",i+1); scanf("%d",a+i);
}
}
void iarray_print(int *a, int n){
for(int i=0; i<n; ++i){printf(" %2d", a[i]);}
printf("\n");
}
int iarray_max(int *a, int n){
int x= *a;
for(int i=0; i<n; ++i){
if(*(a+i) > x){x = *(a+i);}
}
return x;
}
void expect_int(int i1, int i2, char *msg){
printf("%s %d:%d %s\n",(i1==i2)?"OK":"NG", i1,i2,msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1},c[]= {-1, 0};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 2),0,"-1 0");
expect_int(iarray_max(c, 1), -1, "-1");
}
実行例
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 0:0 -1 0
OK -1:-1 -1
説明
最大値の候補を代入する変数xを用意して、配列のある要素がxより大き
かった時その値をxに代入した。これを配列の全要素で行なって、最大
値xを求めた。単体テストでは、要素が1つだけでも上手くいくか確認し
た。
友人のコメント
今回習ったポインタを使おうとしていて良かった。
アンケート
Q1,納得しました。
Q2,取り組む時間がなかったので、読んでおきます。
Q3,前回よりコードを書くのに時間がかかりました。
r1910720 2a:○ Tue May 19 18:32:10 2020
プログラミング通論 第２回 課題２a
プログラム：
#include <stdio.h>
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 0; i < n; ++i){
if(max < a[i]){
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {4,3,9,6,-2,-1,0,0};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 8), 9, "4 3 9 6 -2 -1 0 0");
expect_int(iarray_max(c+4, 3), 0, "-2 -1 0");
return 0;
}
説明：配列の中に最大値を求めること。また、main(void)の中、
iarray_maxにあるのはある配列の何番目から何個の数がとっていること。
レビューコメント：わかりやすく、簡潔にまとまっているのと単体テス
トで配列の長さを変えたりと工夫を感じる
アンケート：
Q1. アドレス、ポインタについて納得しましたか。
大体わかりました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
授業中にやらなかったが、復習とレポートを書く時に工夫します。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
今回の内容は新しい内容のため、わからない部分が色々出てきます。
この部分について工夫しないといけないと考える。
わからないことはさっさと質問してくださいね。おつかれ様です。
s1910346 2a:○ Tue May 19 19:13:07 2020
------演習1a-----------------
#include <stdio.h>
#include <stdbool.h>
#include <limits.h>
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_bool(bool b1, bool b2, char *msg) {
printf("%s %s:%s %s\n", (b1==b2)?"OK":"NG",
bool2str(b1), bool2str(b2), msg);
}
int iarray_max(int* a, int n){
int max = INT_MIN;
for(int i = 0;i < n;i++){
if(max < a[i]) max = a[i];
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
int c[] = {-10, -2, -5, -9, 1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 5), 1, "-10 -2 -5 -9 1");
return 0;
}
--------------------------------------
実行結果
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 1:1 -10 -2 -5 -9 1
--------------------------------------
負の数の想定をしていなかったので,maxの初期値を0にして計算をして
いた. しかし,テストケースでNGがでたことでエラーに気づくことがで
きた. INT_MINを代入してINTの範囲のみの対応となってしまったが後
述のレビューにもあるように与えられた文字列をはじめに受け取るほう
が範囲の制約が少ないプログラムになるので今後はそうしていきたい.
--------レビュー課題------------------
INT_MINの代わりにa[0]でinitializeして,ループをi=1から始める方法もあります。
個人的に配列にない値と比較するのはあまりよくないと思います.
Q1. アドレス、ポインタについて納得しましたか。
納得した.ポインタのポインタの概念も理解することができた.
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
クラスのもともとの概念という印象をもった.
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ
テストやデバッグを効率よくすることについて理解することができた.
デバッグもプログラムを活用して一つひとつ機能を確かめていくと
バグ発見につながるということが理解できた.
t1810743 2a:○ Tue May 19 23:00:33 2020
プログラミング通論 レポート2a
演習１ b.配列の並び順を逆順にする関数void iarray revese(int
*a, int n)を 作成する。
・プログラムコード
void iarray_reverse(int *a, int n){
int a_[n];
for(int i=0; i<n; ++i) a_[i] = a[i];
for(int i=0; i<n; ++i) a[i] = a_[n-i-1];
}
・プログラムの説明
a_に配列aをコピーする。
次にaにa_を逆順に代入していく。
・単体テスト
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};
iarray_reverse(a, 5); expect_iarray(a, b, 5, "85241 -> 14258");
int c[] = {}, d[] = {};
iarray_reverse(c, 0); expect_iarray(c, d, 0, " -> ");
int e[] = {8,5,2,4,1,0,1,5}, f[] = {5,1,0,1,4,2,5,8};
iarray_reverse(e, 8); expect_iarray(e, f, 8, "85241015 -> 51014258");
・実行結果
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK ->
OK 85241015 -> 51014258
5 1 0 1 4 2 5 8
5 1 0 1 4 2 5 8
・考察
大きさ５と８の配列は正確にできた。
大きさ０の配列も正確に実行することができた。
・レビュー課題
友人：for文一個だけでいけると思います。
void iarray_reverse(int *a, int n){
int tmp;
for(int i=0; i<n/2; ++i){
tmp = a[i]
a[i] = a[n-i-1]
a[n-i-1] = tmp;
}
}
>>確かにfor文一つでいけました。
・アンケートの回答
Q1:完全な理解には及びませんが、納得しました。
Q2:授業でやらなかったのでまだ読んでいません。
Q3:配列の操作はポインタの操作だったのだと知りました。
文字コードはUTF8でお願いします。プログラムは抜粋せず動くもの一式
で掲載してください。おつかれ様でした。
w1810714 2a:○ Tue May 19 13:02:50 2020
個人作業, 提出日5/19
演習1a. 配列の最大値を求める関数を作成する。
コード
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
int iarray_max(int *a, int n) {
int m;
m = *a;
for(int i = 0; i<n-1; ++i) {
if(m<*(a+1)) { m = *(a+1); }
a = a+1;
}
return m;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[6];
int ma;
int b[] = {9, 0, 0, 1, 2, 3}, c[] = {-1, -3, -2, -4, -1};
int d[] = {-1, 3, 4, 0};
iarray_read(a, 6);
ma = iarray_max(a, 6);
printf("max = %d\n", ma);
expect_int(iarray_max(b, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(b+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(c, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(d, 4), 4, "-1, 3, 4, 0");
return 0;
}
実行例(単体テストを含む)
[w1810714@sol 2]$ ./a.out
1> 1
2> 6
3> -1
4> 5
5> 3
6> 0
max = 6
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 4:4 -1, 3, 4, 0
説明
まず入力された長さ6の配列について最大値を求めている。その後、配
列{9, 0, 0, 1, 2, 3}, {0, 0, 1, 2, 3}, {-1, -3, -2, -4, -1},
{-1, 3, 4, 0}についての単体テストを行っている。
レビュー
問題なく動作していると思う。
各処理が細かく関数に分けられているため、可読性の高いプログラムになっている。
全体的に、しっかりと動作する上に簡潔で良いプログラムだと思う。
アンケート
1. 納得した。
2. 納得した。
3. 納得と納豆って似てますね。
たしかに似ていますね。それはいいけどアンケートの回答が手抜きです。
w1910722 2a:○ Tue May 19 20:59:23 2020
学籍番号1910722
個人作業
提出日付 2020年5月19日
作成したプログラムのソースコード
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a,int n){
int a_max = a[0];
for(int i = 0; i<n; i++){
if(a[i] >= a_max) a_max = a[i];
}
return a_max;
}
void expect_int(int i1,int i2,char *msg){
printf("%s %d:%d %s\n",(i1==i2)?"OK":"NG",i1,i2,msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4, 0};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(b, 5), 0, "-1 -3 -2 -4 0");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b+1, 4), 0, "-3 -2 -4 0 ");
expect_int(iarray_max(a+2, 3), 2, "0 1 2 ");
expect_int(iarray_max(b+2, 2), -2, "-2 -4");
expect_int(iarray_max(a+0, 6), 9, "9 0 0 1 2 3");
return 0;
}
説明
配列を与えて、その要素の最大値を返すプログラム。
単体テストの実行結果
OK 9:9 9 0 0 1 2 3
OK 0:0 -1 -3 -2 -4 0
OK 3:3 0 0 1 2 3
OK 0:0 -3 -2 -4 0
OK 2:2 0 1 2
OK -2:-2 -2 -4
OK 9:9 9 0 0 1 2 3
レビュー課題
コードに不要な部分が無く、シンプルにまとまっていてかつ単体テスト
の場合が多めにとってあって良いと思った。(友人より)
アンケート
Q1.なんとなく理解をした程度なので、使いこなすにはまだ早いと感じる。
Q2.あまり納得できていない。
Q3.第二回から内容の面でつまずいているので友人などの協力を仰ぎたいと思った。
説明では関数の中の処理を説明してください。おつかれ様です。
w1910726 2a:○ Tue May 19 15:29:08 2020
学籍番号 1910726
個人作業
提出日時 2020/5/19
演習1a
ソースコード
#include<stdio.h>
#include<stdlib.h>
void expect_int(int i1, int i2, char *msg);
int iarray_max(int *a, int n);
int main()
{
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
return 0;
}
void expect_int(int i1, int i2, char *msg) { printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);}
int iarray_max(int *a, int n)
{
int larger = a[0];
for (int i = 1; i < n; i++) {larger = (larger < a[i])? a[i] : larger;}
return larger;
}
説明文
iarray_max関数内でfor文と３項演算子を用いて変数largerの中身を一
つ一つ比較していき最終的に変数largerに入っているものが配列の中で
一番大きいものになっているのでそれをreturnで返し終了とした。
単体テスト
ソースコード
int main()
{
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(a+3, 3), 3, "1 2 3");
expect_int(iarray_max(a+2, 4), 3, "0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+3, 2), -1, "-4 -1");
expect_int(iarray_max(b+2, 3), -1, "-2 -4 -1");
return 0;
}
実行例
PS C:\Users\miang\Desktop\info_uec_tsk> ./a.exe
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK 3:3 1 2 3
OK 3:3 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -4 -1
OK -1:-1 -2 -4 -1
レビュー
プロトタイプ宣言を行うのは、テキストと違って珍しい。
if文を裂けてプログラムの行数を増やさないような工夫がみられる。
Q1. アドレス、ポインタについて納得しましたか。
納得しました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得しました。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
引き続き頑張ります。
w1910727 2a:○ Tue May 19 23:46:32 2020
提出日 5/19
1つ目の課題の掲載
演習1-a.配列の最大値を求める関数intiarray max(int*a,intn)を作成する。
作成したプログラムのソース
#include <stdio.h>
int iarray_max(int *a, int n) {
int k = a[0];
for(int i = 0; i <n; ++i) {
if(k < a[i]) {
k = a[i];
}
}
return k;
}
void expect_int(int i1, int i2, char*msg) {
printf("%s%d:%d%s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[]={9,0,0,1,2,3},b[]={-1,-3,-2,-4,-1};
expect_int(iarray_max(a,6),9,"9 0 0 1 2 3");
expect_int(iarray_max(a+1,5),3,"0 0 1 2 3");
expect_int(iarray_max(b,5),-1,"-1 -3 -2 -4 -1");
int z[]={1,2,3,4,-5,6+2,7};
expect_int(iarray_max(z,5),4,"1 2 3 4 -5");
expect_int(iarray_max(z,7),8,"1 2 3 4 5 6+2 7");
return 0;
}
実行例は以下の通り。
OK9:99 0 0 1 2 3
OK3:30 0 1 2 3
OK-1:-1-1 -3 -2 -4 -1
OK4:41 2 3 4 -5
OK8:81 2 3 4 5 6+2 7
プログラムの説明
配列の最初の値をkに格納しており、for文を用いて配列の次の値とkと
の大小を比較し、kより大きな値をkに格納することで、最終的に配列の
要素の中で最大の数がkに格納され、それを返している。
実行例の説明
指定のテストケースに加えて、新たに配列zを加えた。実行はいずれも
問題なく行われた。また、h配列zの要素内に足し算6+2を含めても正常
に動作は行われた。
レビュー課題
友人によるレビューによると、特に無駄のないプログラムであり、テス
トケースもしっかりしているとのことでした。
アンケート
Q1. アドレス、ポインタについて納得しましたか。
ある程度納得できた。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
あまり納得できなかったので、よく復習したい。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
だんだんと難しく感じてきたので、時間をかけて学んでいきたい。
y1810658 2a:○ Tue May 19 16:45:43 2020
学籍番号：1810658
個人作業
提出日時：2020/5/19
選択した課題: 演習1a
配列の最大値を求める関数を作成し、単体テストを動かす。
方針:
配列の先頭の要素を保存しておき、その要素と配列の要素をfor文で順
番に比較していき、大きい値を上書き保存していく。最後に保存してあ
る値を返す。
コード:
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int x=a[0];
for(int i=0; i<n; ++i){
if(x<a[i]){
x=a[i];
}
}
return x;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4, -1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+2, 3), -1, "-2 -4 -1");
expect_int(iarray_max(b+3, 1), -4, "-4");
return 0;
}
実行例:
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -2 -4 -1
OK -4:-4 -4
解説:
コードのベースは例題で動かしたもので自分で書いた部分はiarrai_max
の部分とmainの中のテストケースの部分である。まず最大値を求める関
数は初めに配列の先頭の要素を変数xに代入し、for文で順番に値の大小
を比較して\\いく。その中でxより大きい値があればxに代入し、最後に
xを返すようなものである。
レビュー課題:
最大値を求める関数がシンプルで理解しやすかった。
考察:
単体テストでは例で示されていたものにいくつか新しいテストケースを
増やした。どれもOKと表示されたため、自分が書いたコードが正しく動
いていることがわかった。自分の書いたコードが正しく動いているかど
うかを確か\\めるときはコードを入念に見返すことや値を適当に打ち込
んで確かめるよりも単体テストを作成して確かめる方が正確性があり、
間違っている箇所に早く気づけると感じた。
アンケート:
Q1 アドレス、ポインタについて納得したか。
納得した。
Q2「構造体を用いた情報隠蔽」について納得したか。
納得した。
Q3リフレクション・感想・要望
ポインタの考え方の復習ができた。また１bのレポートで先生から解説
はプログラムコードのコメントでは認められないということで今回から
書き方を修正しました。
y1910661 2a:○ Tue May 19 22:59:43 2020
[プログラム]演習1.c
#include<stdio.h>
#include<stdbool.h>
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
void swap(int *a,int *b){
int tmp = *a;
*a = *b;
*b = tmp;
}
void iarray_sort(int *a,int n){
int i,tmp; // tmp meas index
for(i = 0;i<n;i++){
tmp = i;
int j;
for(j = i+1;j<n;j++){
if(a[j] < a[tmp]){tmp = j;}
}
swap(a+i,a+tmp);
}
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void){
int a[] = {8,5,2,4,1}, b[] = {1,2,4,5,8};
int c[] = {-3,-5,3,1}, d[] = {-5,-3,1,3};
int e[] = {1,2,3}, f[] = {1,2,3};
int g[] = {3,2,1}, h[] ={1,2,3};
iarray_sort(a, 5);
iarray_sort(c,4);
iarray_sort(e,3);
iarray_sort(g,3);
expect_iarray(a, b, 5, "85241 -> 12458");
expect_iarray(c, d, 4, "-3 -5 3 1 -> -5 -3 1 3");
expect_iarray(e, f, 3, "123 -> 123");
expect_iarray(g, h, 3, "321 -> 123");
return 0;
}
[実行例]
OK 85241 -> 12458
1 2 4 5 8
1 2 4 5 8
OK -3 -5 3 1 -> -5 -3 1 3
-5 -3 1 3
-5 -3 1 3
OK 123 -> 123
1 2 3
1 2 3
OK 321 -> 123
1 2 3
1 2 3
[説明]
配列のアドレスと，大きさを与えると昇順に並べ替える関数とその実行例．
[レビュー by TA 宮島]
要素を入れ替える補助関数swapを自分で用意しており、工夫が施されて
いて良いと思います。
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
納得した．
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
具体例ではr->valueを使うことによってcd_seqgetを使わなくてもcdseq
の値にアクセスできるので，
どこが情報隠ぺいになっているのかいまいち理解できなかった．
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
プログラムが正しく作れているかを調べるテストケースを作るのは難し
いと思った．
情報隠蔽は次回にまた続きをやりますので。おつかれ様でした。
y1910662 2a:○ Tue May 19 18:12:09 2020
個人作業
提出日時:2020/05/19
演習1a
作成したプログラム（単体テスト含）
#include <stdio.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int max = a[0];
for(int i=0;i<n;i++){
if(a[i]>max){
max = a[i];
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {1,5,7}, d[] = {2};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(a+2,3),2,"0 1 2");
expect_int(iarray_max(b+2,2),-2,"-2 -4");
expect_int(iarray_max(c,3),7,"1 5 7");
expect_int(iarray_max(d,1),2,"2");
return 0;
}
実行結果
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 2:2 0 1 2
OK -2:-2 -2 -4
OK 7:7 1 5 7
OK 2:2 2
プログラムの説明
与えられた配列の最大値を求めるプログラムである。
配列の読み込みはiarray_read、出力はiarray_printが行う。
iarray_maxは配列aと要素数nを与えると最大値を返す関数である。int
maxの初期値は配列の先頭の要素の値とし、そこからfor文でn個の要素
までを順番に見ていって、maxに入っている値よりも大きいものがあっ
た場合はmaxに代入し、最終的にn個見終わったときにmaxに入っていた
値を返す。
expect_intは結果値i1と想定値i2が等しければOK、そうでなければNGを
表示する関数であり、実行した時にOKorNG、結果値、想定値、そのテス
トケースの配列の順に表示する。
main関数の中でテストに用いる配列a、b、c、dを決めておき、
expect_intを用いてテストを行う。
レビュー課題（同じクラスの方にレビューして頂きました）
自分はテキストの例題を課題1aに適用することで精一杯だったので、比
較する２数をa,nのまま使っているが、その点このプログラムではi1,i2
としているので、どのような数字を比較しているか視覚的に分かりやす
いと思いました。
アンケート
Q1.以前基礎プロで初めて扱った時よりはわかるようになったと思う。
Q2.一通り目を通したが難しいと感じたので復習が必要だと思った。
Q3.テストをすることで、いちいち色々なパターンを実行して頭のなか
で想定値と照らし合わせたりしなくてもバグが発見しやすくなり、感動
した。
y1910668 2a:△ Tue May 19 16:10:14 2020
学籍番号：1910668
ペア:個人作業
＜ソース＞
(1-a)
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
int iarray_max(int *a,int n){
int x=a[0];
for(int i=1;i<n;++i){
if(x<a[i]){
x=a[i];
}
}
return x;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(){
//int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
//expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
//expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
//expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
int a[6];
iarray_read(a,6);
printf("max=%2d\n",iarray_max(a,6));
return 0;
}
＜実行例＞
1> 1
2> 3
3> 6
4> 2
5> 1
6> 5
max=6
(テスト)
OK [1,2,3]->[3,2,1]
3 3 2 1
3 3 2 1
＜説明＞
配列の最初の値をxに入れて、その値との大小を比較し、大きければxの
値を置き換える。そうして、最後のxのあたいが最大なのでその値を返
した。
＜レビュー＞(クラスメート)
シンプルに書けていて理解しやすいです。演算子の前後にスペースを入
れたりするともっと読みやすくなると思います。
＜アンケート＞
Q1.大方納得した。
Q2.まだあまり理解できていないのでもう少し頑張りたい。
Q3.非常に難しく感じたので復習をしっかりしておきたいと思った。
y1910670 2a:○ Tue May 19 22:58:58 2020
学籍番号：1910670
ペア：個人作業
提出日時：5月19日
・プログラム（課題1-a）
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 0; i < n; ++i) {
if (max < a[i]) {
max = a[i];
}
}
return max;
}
（以降が単体テスト）
void expect_int(int a, int n, char *msg) {
printf("%s:%d, %s\n", (a==n)?"OK":"NG", n, msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4, -1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(a+3, 3), 3, "1 2 3");
expect_int(iarray_max(a, 1), 9, "9");
expect_int(iarray_max(a, 0), 0, "");
return 0;
}
・実行例
OK:9, 9 0 0 1 2 3
OK:3, 0 0 1 2 3
OK:-1, -1 -3 -2 -4 -1
OK:3, 1 2 3
OK:9, 9
NG:0,
Program ended with exit code: 0
・説明
iarray_maxは、今までの通り、反復を用いて、最初に一番大きいと仮定
しているa[0]をa[1]と比較して、大きい方をmaxに代入し、それをiを増
やして繰り返して行くという動作をしている。なお、expect_maxは、予
想の最大値nとiarray_maxの結果の最大値が等しいかどうかの確認をし
ている。テストケースについては、元々提示されていたテストケースに
加え、さらに要素数が少ない場合と、要素数０での場合を加えた。
・レビュー（先輩）
配列の全てを見れていて間違いなく動作する良いプログラムだと思いま
すただ一つ、最大値の初期値をa[0]で与えたのにそれをa[0]と比較して
るのが何となく勿体ないのでfor(i=0; i<n-1; ++i) {...}として参照す
るのをa[i-1]にすると繰り返し回数が減るかなと思いました
・アンケート
Q1.納得した。
Q2.納得した
Q3.なし
y1910671 2a:○ Tue May 19 15:13:41 2020
課題A
個人作業
提出日時: 2020/05/19
演習1-a
[ソースコード]
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
// 1a
int iarray_max(int *a, int n){
int max = a[0];
int i;
for(i = 0; i < n; i++){
if(max < a[i]){
max = a[i];
}
}
return max;
}
int main(void){
int a[] = {9,0,0,1,2,3};
int b[] = {-1,-3,-2,-4,-1};
int c[5];
expect_int(iarray_max(a,6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1,5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(a+1,2),0,"0 0");
expect_int(iarray_max(b+1,4),-1, "-3 -2 -4 -1");
iarray_read(c,5);
printf("max = %d\n",iarray_max(c,5));
return 0;
}
[説明]
配列の最大値を求める関数iarray_maxを作成した。
テストケースを既存のものから2つ追加した。
[テストと実行例]
[y1910671@sol #2]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 0:0 0 0
OK -1:-1 -3 -2 -4 -1
1> 1
2> 2
3> 3
4> 4
5> 5
max = 5
[ペアからのコメント]
a[0]を最初に入れてるから、forのときにiは1からでいいじゃないかと思った。
[アンケート]
Q1.納得できた。
Q2.利点がまだよくわからない。
Q3.情報隠蔽が分かっていないので演習をして理解を深めたい。
y1910673 2a:○ Tue May 19 19:44:25 2020
プログラム通論第2回A課題
学籍番号：1910673
個人作業
提出日時：５月１９日
[取り組んだ課題]
演習1.d 2 つの配列 (長さは同じ) を受け取り、2 番目の各要素の値を
1 番目の配列の各要素に足し込む関数 void iarray add(int *a, int
*b, int n) を作成する。
[作成したプログラム]
#include <stdio.h>
#include <stdbool.h>
void iarray_add(int *a, int *b, int n) {
int i;
printf("---演算前---\n");
for (i = 0; i < n; i++) {
printf("%d", *(a + i));
}
printf(" + ");
for (i = 0; i < n; i++) {
printf("%d", *(b + i));
}
printf("\n");
for (i = 0; i < n; i++) {
a[i] = a[i] + b[i];
if (a[i] >= 10) { a[i] = a[i] - 10; a[i - 1] = a[i - 1] + 1; }
}
printf("---演算後---\n");
printf(" = ");
for (i = 0; i < n; i++) {
printf("%d", *(a + i));
}
printf("\n");
}
void iarray_print(int* a, int n) {
int i;
for (i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int* a, int* b, int n) {
int i;
for (i = 0; i <= n; ++i) {
if (a[i] != b[i]) { return false; }
}
return true;
}
void expect_iarray(int* a, int* b, int n, char* msg) {
printf("%s %s\n", iarray_equal(a, b, n) ? "OK" : "NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void) {
int a[] = { 8,5,2,4,1 }, b[] = { 1,1,2,2,3 }, c[] = { 9,6,4,6,4 };
int d[] = { 0,0,2,4,4 }, e[] = { 0,0,3,8,1 }, f[] = { 0,0,6,2,5 };
iarray_add(a, b, 5); printf("テスト_1\n");
expect_iarray(a, c, 5, "85241+11223 -> 96464");
printf("\n");
iarray_add(d, e, 5); printf("テスト_2\n");
expect_iarray(d, f, 5, "00244+00381 -> 00625");
}
[プログラムの簡単な説明]
void iarray_addを作成した。初めにa+bというように演算前の式を出力し、
その後、aが参照しているアドレスにポインタ値aとポインタ値bをそれぞれ入れていく。
この時、値の繰り上がりを配列の順番に気を付けてif文で実行するようにした。
そして演算後のところにはポインタ値aを順に出力する。
テストケースに関してはテスト_1は繰り上がりのない足し算でテスト_2
は繰り上がりのある足し算を設定している。
[実行例]
---演算前---
85241 + 11223
---演算後---
= 96464
テスト_1
OK 85241+11223 -> 96464
9 6 4 6 4
9 6 4 6 4
---演算前---
00244 + 00381
---演算後---
= 00625
テスト_2
OK 00244+00381 -> 00625
0 0 6 2 5
0 0 6 2 5
[レビュー課題]
間柄：友人
感想：求められていることをシンプルに書けていると思いました。ただ
し*(a + i)とa[i]は統一したほうがより分かりやすいと思います。
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
納得できました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得できました。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
ポインタについて理解できたときとてもすっきりしました。
y1910677 2a:○ Tue May 19 19:01:43 2020
情報領域演習第二：#02A
提出日付 2020/5/19
【実施した内容（演習1a）】
プログラム：
//演習1a
#include <stdio.h>
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 1; i < n; ++i) {
if(a[i] > max) { max = a[i]; }
}
return max;
}
void expect_int(int b1, int b2, char *msg) {
printf("%s %d:%d [%s]\n", (b1==b2)?"OK":"NG",
b1, b2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1},c[]={1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(a+2, 4), 3, "0 1 2 3");
expect_int(iarray_max(a+3, 3), 3, "1 2 3");
expect_int(iarray_max(a+4, 2), 3, "2 3");
expect_int(iarray_max(c, 1), 1, "1");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 4), -1, "-3 -2 -4 -1");
return 0;
}
実行例：
OK 9:9 [9 0 0 1 2 3]
OK 3:3 [0 0 1 2 3]
OK 3:3 [0 1 2 3]
OK 3:3 [1 2 3]
OK 3:3 [2 3]
OK 1:1 [1]
OK -1:-1 [-1 -3 -2 -4 -1]
OK -1:-1 [-3 -2 -4 -1]
説明：今回のプログラムではint iarray_maxという関数の中で配列の中
身を一つずつ比較することにより最大値を求め、expect_intという関数
の中で想定した最大値とプログラムによって求められた最大値が同じだっ
たら「OK」を出力し、異なっていたら「NG」を出力している。メイン関
数では複数の配列を定義し、expect_intを実行することにより単体テス
トを行っている。
【レビュー課題】
最大値を求める関数の最初にmaxにa[0]を代入してるため、そのあとの
for文でi = 0ではなく、i = 1で始めることで、無駄な計算を省いてる
点がよいと思った。（by友人）
【アンケート】
Q1.アドレス、ポインタについて納得しましたか。
まだ少し不安ですが、納得はできました。
Q2.「構造体を用いた情報隠蔽」について納得しましたか。
まだあまり理解ができていないです。
Q3.リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
今回の課題ではテストのやり方について学ぶことができました。
y1910679 2a:○ Tue May 19 22:53:40 2020
学籍番号：1910679
提出日時；2020/5/19
プログラミング〜演習１.a
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
void expect_int(int i1, int i2, char *msg){
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG",
i1,i2,msg);
}
int iarray_max(int *x, int n){
int max = x[0];
for(int i = 0; i<n; i++){
if(x[i] > max){
max =x[i];
}
}
return max;
}
int main(void) {
int a[]={9,0,0,1,2,3},b[]={-1,-3,-2,-4,-1};
expect_int(iarray_max(a,6),9,"900123");
expect_int(iarray_max(a+1,5),3,"00123");
expect_int(iarray_max(b,5),-1,"-1-3-2-4-1");
expect_int(iarray_max(b+1,4),-1,"-3-2-4-1");
expect_int(iarray_max(a+2,3),2,"012");
return 0;
}
プログラミングの簡単な説明
配列の最大値を求めるiarray_maxを求めた。さらに、expect_intで想定
される最大値と実際の最大値の正誤を判定できるようにした。また、テ
ストケースを２つ追加した。
実行例
OK 9:9 900123
OK 3:3 00123
OK -1:-1 -1-3-2-4-1
OK -1:-1 -3-2-4-1
OK 2:2 012
ペアからのコメント（友人）
forをつかって最大値を求めるところが分かりやすいと思った。
アンケート
Q1. アドレス、ポインタについて納得しましたか。
納得した。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
納得した。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
提出するファイルの文字コードはUTF8でお願いします。
コメントは「ペア以外の人」からでお願いします。おつかれ様です。
アンケートのQ3が書いてないですよ。
y1910681 2a:○ Tue May 19 20:59:39 2020
課題(演習１b)
ソース
#include<stdio.h>
#include<string.h>
#include<stdbool.h>
void iarray_reverse(int *b, int n){
int a, i;
if(n != 0){
for(i = 0; i < n/2; i++){
a = b[i];
b[i] = b[n - i - 1];
b[n - i - 1] = a;
}
}
}
bool judge(int *a, int *b, int n){
int i = 0;
iarray_reverse(a, n);
for(i = 0; i < n; i++){
if(a[i] != b[i]){ return false;}
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *array){
printf("%s\t%s\n",judge(a, b, n)?"OK":"NG", array);
}
int main(){
int a[] = {8,5,2,4,1}, ra[] = {1,4,2,5,8}, b[] =
{1,2,3,4,5}, rb[] = {5,4,3,2,2}, c[] = {1}, rc[] = {1}, d[]
= {100,-4,0}, rd[] = {0,-4,100}, e[] = {3,2,1,4,5}, re[] =
{1,2,3,4,5};
expect_iarray(a, ra, 5, "85241 -> 14258");
expect_iarray(b, rb, 5, "12345 -> 54321");
expect_iarray(c, rc, 1, "1 -> 1");
expect_iarray(d, rd, 3, "100-40 -> 0-4100");
expect_iarray(e, re, 3, "32145 -> 12345");
expect_iarray(c, rc, 0, "1 -> 1");
return 0;
}
実行結果
[y1910681@sol pem2]$ gcc b1.c ; ./a.out
OK 85241 -> 14258
NG 12345 -> 54321
OK 1 -> 1
OK 100-40 -> 0-4100
OK 32145 -> 12345
OK 1 -> 1
説明
iarray_reverse(int *b, int n)
forでbの配列を両端から[n/2]までの要素を交換していく
judge(int *a, int *b, int n)
forでaとbの0からn-1までの要素全てが等しいか比較するする。一つで
も違えばがfalse、それ以外ならtrueを返す
expect_iarray(int *a, int *b, int n, char *arrray)
iarray_reverse(int *a, int n)関数を呼び出す。
printfで"(judge(a[n], b[n],n}の出力))(タブ)(array文字列)(改行)"を表示する。
ここでのarrayは"(順番を逆にしたい配列) -> (順番が逆になったときの配列)"
main()
int a[] = {8,5,2,4,1}, ra[] = {1,4,2,5,8}, b[] = {1,2,3,4,5},
rb[] = {5,4,3,2,2}, c[] = {1}, rc[] = {1}, d[] = {100,-4,0},
rd[] = {0,-4,100}, e[] = {3,2,1,4,5}, re[] = {1,2,3,4,5}
変数の先頭にrがついていない配列をint *a,変数の先頭にrがついてい
る配列をint *b,配列の要素数をint n, "(順番を逆にしたい配列) ->
(順番が逆になったときの配列)"をchar *arrayとしてexpect_iarrayの
引き関数とした。rb[]は回目はjudge関数が正しいか確認のため、わざ
と逆順になった配列とは異なる配列。
コメント
配列のサイズをわざわざ定義しなくともb[n-i-1]をb[i]にいれるなどを
して少ない文字数で抑えている点がよいと思う。
アンケート
Q1. アドレス、ポインタについて納得しましたか。
A1. 納得できた。整数などとは違い関数内でいじるとそれ自体も配列自
体もいじられてしまう。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
A2. 納得したけど完ぺきではないような気がする。完全に隠蔽するこ
とはできないのだろうか。
Q3. リフレクション (今回の課題で分かったこと)・感想・要望をどうぞ。
A3. 配列についてわすれてた部分を思い出せた
単体テストでNGが出ているものがあるじゃないですか。まあテストの
方が違っているんですが。おつかれ様です。
y1910684 2a:○ Tue May 19 15:11:03 2020
レポート2a
提出日時 2020/05/19
<演習1a>
配列の最大値を求める関数int iarray max(int *a, int n)を作成する。
<ソースコード>
#include <stdio.h>
int iarray_max(int *a, int n){
int max = a[0];
for(int i = 0; i < n; ++i){
if(max < *(a+i)){max = *(a+i);}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {0,31,2,11,10};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 5), 31, "0 31 2 11 10");
expect_int(iarray_max(c+2, 3), 11, "2 11 10");
expect_int(iarray_max(c+4, 1), 10, "10");
return 0;
}
<説明>
iarray_maxのところは、まずint型の変数maxをa[0]とおいて、aの配列
にある整数をfor文でn回探索し、もしmaxより大きければmaxをその数に
するような動作を作成した。main関数では負の整数もちゃんと正しく動
作できているかの確認と、配列の開始位置をずらしても動作するかを確
認できるように単体テストを作成した。
<単体テストと実行例>
[y1910684@sol L02]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 31:31 0 31 2 11 10
OK 11:11 2 11 10
OK 10:10 10
<レビュー>（同級生より）
きちんと結果が出て、とても簡潔かつわかりやすいプログラムだと思う。
<アンケート>
Q1.アドレス、ポインタについて納得しましたか。
少しは理解できていると思うがまだ関数のポインタがいまいちなので演
習をしていきながら理解を深めたい。
Q2.「構造体を用いた情報隠蔽」について納得しましたか。
例題を動かして理解することができた。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
アドレスとポインタは基礎プロでもやったことなので復習として演習を
していたがまだ理解不足な面もあって
難しい内容だと感じた。
y1910685 2a:○ Tue May 19 21:55:08 2020
学籍番号:1910685
ペア:個人作業
日付:5/19
[実行した課題]
演習1.b(与えられた配列を逆順にする)
[プログラムのソース]
#include <stdio.h>
#include <stdbool.h>
#define SIZE 5
#define CASE 5
bool ary_equ(int *a, int *b, int n);
int tester(int a[][SIZE], int b[][SIZE], int n, int m);
void test_result(int a, int n);
void iarrayreves(int *a, int n);
void print_ary(int *a,int n);
int test_pro[CASE][SIZE] = {
{1,2,3,4,5},
{1,4,5,67,1},
{61,5,7,1,5},
{8,45,3,4,3},
{5,2,5,3,23}
};
int test_ans[CASE][SIZE] = {
{5,4,3,2,1},
{1,67,5,4,1},
{5,1,7,5,61},
{3,4,3,45,8},
{23,3,5,2,5}
};
int main(){
for(int n = 0;n<CASE;n++){
iarrayreves(test_pro[n],SIZE);
}
test_result(tester(test_pro,test_ans,SIZE,CASE),CASE);
return 0;
}
bool ary_equ(int *a, int *b, int n){
for(int k = 0;k<n;k++){
if(a[k] != b[k])return false;
}
return true;
}
//配列の長さnのm個のテストケースを試行する
int tester(int a[][SIZE], int b[][SIZE], int n, int m){
int ans = 0;
for(int k = 0;k < m;k++){
for(int l = 0;l < n; l++){
if(a[k][n] != b[k][n])ans = ans | (1 >> m);
}
}
return ans;
}
void test_result(int a, int n){
printf("*が正解、/が不正解で順に表示します。\n");
for(int k = 0;k < n;k++){
printf("%c", (a & (1 >> k)) ? '/' : '*');
}
printf("\n");
}
void iarrayreves(int *a, int n){
int dump = 0;
printf("before:");
print_ary(a,n);
for(int k = 0;k < n/2;k++){
dump = a[k];
a[k] = a[n-k-1];
a[n-k-1] = dump;
}
printf("After :");
print_ary(a,n);
}
void print_ary(int *a,int n){
for(int k = 0;k < n;k++)printf("%d ",a[k]);
printf("\n");
}
[ソースの簡単な説明]
与えられた長さnの配列を逆順にする関数iarrayrevesを、一度他の変数
に値を格納し、その後対称の位置の値を入れ替えることで作成した。ま
た、用意したテストケースと、今回の結果が合っているかを確認するた
めのtester関数と、その結果を表示するtest_result関数を作成した。
[実行例]
before:1 2 3 4 5
After :5 4 3 2 1
before:1 4 5 67 1
After :1 67 5 4 1
before:61 5 7 1 5
After :5 1 7 5 61
before:8 45 3 4 3
After :3 4 3 45 8
before:5 2 5 3 23
After :23 3 5 2 5
*が正解、/が不正解で順に表示します。
*****
[レビュー課題]
間柄:友人
感想:配列の長さをdefineで定義しているのが、後から変更できて良いと思いました。
[考察等]
テストケースに対して、今回の結果が正解がどうかを確かめるtester関
数の返り値を、正解の部分は0、間違いの部分は1という2進数表記(例え
ば001000のような)にすることで、変数一つでどこが間違っていて、ど
こが正解であるかを分かるようにした。このようにしておくと、あとで
多くのテストケースでテストをする際に非常に楽にテストが進められる
と感じた。
[アンケート]
Q1.アドレス、ポインタについて納得しましたか。
しました。
Q2.「構造体を用いた情報隠蔽」について納得しましたか。
しました。
Q3.リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
C言語で多次元配列を扱うのは少し窮屈だと思いました。
なるほどですが、まあテストケースの成否は普通に見られる
方が結局使いやすいような気もします。おつかれ様です。
y1910686 2a:○ Tue May 19 22:27:43 2020
[提出日] 2020/05/19
[課題1c] 数値の配列を昇順にソートするプログラムのテスト
//bubblesort.c
//バブルソートと言っておきながらちゃっかり挿入ソートの関数もある
#include <stdio.h>
#include <stdbool.h>
#include <math.h>
void insertion_sort(int *begin, int n, bool reversed)
{
int tmp;
int *end = begin + n;
for (int* i = begin; i != end; i += 1)
{
for (int *j = begin; j != end; j += 1)
{
if ((bool)(signbit(*j - *i)) == reversed)
{
tmp = *i;
*i = *j;
*j = tmp;
}
}
}
}
void bubble_sort_step(int *i, int *end, int stepwidth, bool reversed)
{
int tmp;
for (int *j = i; j != end; j += stepwidth)
{
if ((bool)(signbit(*j - *(j + stepwidth))) == reversed)
{
tmp = *j;
*j = *(j + stepwidth);
*(j + stepwidth) = tmp;
}
}
}
//unittest.c
//単体テストを行う関数群
#include <stdio.h>
#include <stdbool.h>
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_int(int i1, int i2, char *msg)
{
printf("%s %d:%d %s\n", (i1 == i2) ? "OK" : "NG", i1, i2, msg);
}
void expect_double(double d1, double d2, char *msg)
{
printf("%s %g:%g %s\n", (d1 == d2) ? "OK" : "NG", d1, d2, msg);
}
void expect_bool(bool b1, bool b2, char *msg)
{
printf("%s %s:%s %s\n", (b1 == b2) ? "OK" : "NG",
bool2str(b1), bool2str(b2), msg);
}
bool iarray_equal(int *a, int *b, int n)
{
for (int i = 0; i < n; ++i)
{
if (a[i] != b[i])
{
return false;
}
}
return true;
}
void iarray_print(int *a, int n)
{
for (int i = 0; i < n; ++i)
{
printf(" %2d", a[i]);
}
printf("\n");
}
void expect_iarray(int *a, int *b, int n, char *msg)
{
printf("%s %s\n", iarray_equal(a, b, n) ? "OK" : "NG", msg);
iarray_print(a, n);
iarray_print(b, n);
}
//cocktailshakersort.c
//メイン部分。カクテルシェーカーソートの実装と、単体テストの実行。
#include "bubblesort.c"
#include "unittest.c"
int my_signbit(double x)
{
return x >= 0 ? 0 : 1;
}
void cocktail_shaker_sort(int *arr, int count)
{
int *left = arr, *right = arr + count - 1;
for (size_t i = 0; i < count >> 1; i++)
{
bubble_sort_step(left, right, 1, false);
bubble_sort_step(right, left, -1, true);
left++;
right--;
}
}
int main()
{
int napier[12] = {2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5};
int napier_right[12] = {1, 1, 2, 2, 2, 4, 5, 7, 8, 8, 8, 8};
int pi[15] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9};
int pi_right[15] = {1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 7, 8, 9, 9, 9};
int shuffle[10] = {7, 2, 9, 3, 6, 5, 0, 1, 4, 8};
int shuffle_right[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
insertion_sort(shuffle, 10, false);
expect_iarray(shuffle, shuffle_right, 10, "shuffle");
cocktail_shaker_sort(pi, 15);
expect_iarray(pi, pi_right, 15, "pi");
cocktail_shaker_sort(napier, 12);
expect_iarray(napier, napier_right, 12, "napier");
}
[実行例]
OK shuffle
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
OK pi
1 1 2 3 3 4 5 5 5 6 7 8 9 9 9
1 1 2 3 3 4 5 5 5 6 7 8 9 9 9
OK napier
1 1 2 2 2 4 5 7 8 8 8 8
1 1 2 2 2 4 5 7 8 8 8 8
[アンケート]
Q1. はい。
Q2. 納得できました。
Q3. C言語は確かに厄介な言語ですが、個人的には低級な言語は好きで
す。計算機通論の
アセンブリ言語の回が待ち遠しいですね。
[友人によるレビュー]
sortアルゴリズムと，testの二つに分けるよいのじゃないかと思いました．
unittestは各関数と一緒にやった形跡を残すとネットで見たことあります．
いずれにせよtestの回数が少ないように感じます．
[追伸]
コード以外の部分に@@@を付けるものだと勘違いしておりました。
大変申し訳ありませんでした。
y1910688 2a:○ Tue May 19 15:07:36 2020
プログラミング通論（久野先生）
第２回A課題
提出日時 2020/5/19
・作成したプログラム
演習1a
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n){
int i,max=a[0];
for(i=0;i<n;i++){
if(a[i]>max){
max=a[i];
}
}
return max;
}
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_bool(bool b1, bool b2, char *msg) {
printf("%s %s:%s %s\n", (b1==b2)?"OK":"NG",
bool2str(b1), bool2str(b2), msg);
}
int main(void) {
int a[] = {7,3,2,5,1}, b[] = {-1,-3,-2,-4,-1};
expect_bool(iarray_max(a,5),7,"7 3 2 5 1");
expect_bool(iarray_max(a+1,4),3,"3 2 5 1");
expect_bool(iarray_max(b,5),-1,"-1 -3 -2 -4 -1");
expect_bool(iarray_max(b+3,2),-1,"-4 -1");
expect_bool(iarray_max(b+4,1),-1,"-1");
expect_bool(iarray_max(b+5,0),0,"[]");
return 0;
}
・実行例
[y1910688@sol ~/pp20]$ ./a.out
OK true:true 7 3 2 5 1
OK true:true 3 2 5 1
OK true:true -1 -3 -2 -4 -1
OK true:true -4 -1
OK true:true -1
OK false:false []
・簡単な説明
与えられた配列の範囲の中で最大値を求めるプログラム。
最大値の判定方法一つ一つ現時点での最大値との比較を行うオーソドッ
クスなものを用いた。単位テストは様々なケースに対応できるように多
めに作った。
・レビュー
レビュアー 友人N氏
テストプログラムにおいて、自然数だけでなく負の数でも比べているの
がいいと思いました。正負で比べたり、端数を比べたりできるともっと
いいかも？
・アンケート
Q1のA
スライドなどの説明を見て理解することはできた。
Q2のA
構造体に関してあまり理解することができてないのでスライドを読んで復習したい。
Q3のA
授業の進め方に慣れてきたと感じる。
単体テストに使う関数はexpect_boolじゃなくexpect_intでは。
勉強してください。
y1910692 2a:○ Tue May 19 19:34:43 2020
#2 A課題レポート
学籍番号:1910692
ペアの学籍番号:個人作業
提出日時:5/19
[問題の再掲]
演習1-b:配列の並び順を逆順にする関数void iarray revese(int *a,
int n) を作成する。
[実際に書いたコードとその説明]
#include<stdio.h>
#include<stdbool.h>
void iarraay_reverse(int *a,int n){
int b[n];
for(int i=0;i<n;++i){b[i]=a[i];}
for(int i=0;i<n;++i){a[i]=b[n-1-i];}
}
bool iarray_eqaul(int a[],int b[],int l){
for(int i=0;i<l;++i){if(a[i]!=b[i]){return false;}}
return true;
}
void expect_iarray(int *a,int *b,int l,char *msg){
iarraay_reverse(a,l);
printf("%s ",iarray_eqaul(a,b,l) ?"OK":"NO");
for(int i=0;i<l;++i){printf("%d ",a[i]);}
printf(":");
for(int i=0;i<l;++i){printf("%d ",b[i]);}
printf(" %s\n",msg);
}
int main(){
int a[]={2,7,9};
int b[]={9,7,2};
int c[]={1,2,3,4,5,6,7,8,9};
int d[]={9,8,7,6,5,4,3,2,1};
int e[]={5};
int f[]={};
expect_iarray(a,b,3,"279->972");
expect_iarray(c,d,9,"123456789->987654321");
expect_iarray(e,e,1,"5->5");
expect_iarray(f,f,0,"[]->[]");
return 0;
}
void iarraay_reverse(int *a,int n)に関しては、並び順を逆にしたい
配列aをbにコピーした後、aの先頭から順に
bの後ろからの値を代入することでaは、入力した配列とは逆の順番の配
列になる。テストケースvoid expect_iarrayに関しては、逆にしたい配列を
iarraay_reverseで逆にしてから、出るべき結果の配列bと比較
（iarray_eqaul）して最初に"OK","NO"を出るように
し、その後に、操作を施した後の配列 :そうなるはずの結果の配列
変化の状況 のように表示させた。
テストケースに関しては、・すべてがバラバラな配列 ・要素が一つし
かない配列 ・何も入っていない配列 で行い、下のようになった。
また、最後のテストケースではずっとNOが表示されていたが、その後
expect_iarray内でiarray_eqaul(a,b,l)としなければならなかった所を
(a,b,l)としていたのに気づき修正後きちんとOKになった。
OK 9 7 2 :9 7 2 279->972
OK 9 8 7 6 5 4 3 2 1 :9 8 7 6 5 4 3 2 1 123456789->987654321
OK 5 :5 5->5
OK : []->[]
[他人からコードへのレビュー]
iarray_reverseが簡潔に書かれているためわかりやすい
空の配列や異なる文字数の配列に関してテストを行っているため全ての
パターンを網羅していると思われる
(1類３クラスの友人より)
[アンケート]
Q1.アドレス、ポインタについて納得しましたか。
先週の休日に基礎プロの復習をしておいたので理解が早かった。
Q2.「構造体を用いた情報隠蔽」について納得しましたか。
動的メモリ管理までしか理解できてないのでB課題で触れてみようと思います。
Q3.リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
この課題でもテストケースによって思いもよらない間違いに気づけた。
以前はこういうテストをしてきていないので、間違ったコードをどこか
で書いてしまっているなと少し後悔をしてしまった。
y1910693 2a:○ Tue May 19 15:40:57 2020
課題2a
[作成したプログラム]
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 0; i < n; ++i) {
if (max < a[i]) {
max = a[i];
}
}
return max;
}
void expect_int(int a, int n, char *msg) {
printf("%s:%s %s\n", (a==n)?"OK":"NG", msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3}, b[] = {-1, -3, -2, -4, -1},c[] = {10, 5, -8, 4};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c,4), 10, "10, 5, -8, 4");
expect_int(iarray_max(c+1,3), 5, "5, -8, 4");
return 0;
}
[実行結果]
OK:9 0 0 1 2 3 OK
OK:0 0 1 2 3 OK
OK:-1 -3 -2 -4 -1 OK
OK:10, 5, -8, 4 OK
OK:5, -8, 4 OK
[プログラムの内容]
ある配列を呼び込み、配列内の最大値を出力させる
また、単体テストを行うことで、エラーがないかの確認を行っている
[レビュー]
printf内の(変換指定文字列の数) ≧ (引数) でも動くことを知って驚いた
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
納得できたと思うが、少し不安でもある
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだ理解できてないのでこの一週間で何とか頑張ります。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
いままで浅い理解できてしまったことを痛感したのでしっかりと学びます
y1910695 2a:○ Tue May 19 15:49:20 2020
学籍番号:1910695
個人作業
提出日時:2020/05/19
演習1-b
[コード]
#include<stdio.h>
#include<stdbool.h>
void iarray_read(int *a, int n)
{
for(int i = 0; i < n; ++i)
{
printf("%d> ",i+1);
scanf("%d",a+i);
}
}
void iarray_print(int *a, int n)
{
for(int i = 0; i < n; ++i)
{
printf("%2d",a[i]);
}
printf("\n");
}
bool iarray_equal(int *a, int *b, int n)
{
for(int i = 0; i < n; ++i)
{
if(a[i] != b[i])
{
return false;
}
}
return true;
}
void expect_iarray(int *a, int *b, int n, char *msg)
{
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n);
iarray_print(b, n);
}
void iarray_revese(int *a, int n)
{
int x;
for(int i = 0; i < n/2; i++)
{
x = a[i];
a[i] = a[n-1-i];
a[n-1-i] = x;
}
}
int main(void)
{
int a[] = {8,5,2,4,1};
int b[] = {1,4,2,5,8};
int c[6];
int d[] = {1,2,3,4,5,6,7,8,9};
int e[] = {9,8,7,6,5,4,3,2,1};
int f[] = {0,1,0,2,0,3};
int g[] = {3,0,2,0,1,0};
iarray_revese(a, 5);
expect_iarray(a, b, 5, "85241 -> 14258");
iarray_revese(d, 9);
expect_iarray(d, e, 9, "123456789 -> 987654321");
iarray_revese(f, 6);
expect_iarray(f, g, 6, "010203 -> 302010");
iarray_read(c, 6);
iarray_revese(c,6);
iarray_print(c, 6);
return 0;
}
[実行例]
13:57:03 #02 $ ./a.out
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 123456789 -> 987654321
9 8 7 6 5 4 3 2 1
9 8 7 6 5 4 3 2 1
OK 010203 -> 302010
3 0 2 0 1 0
3 0 2 0 1 0
1> 1
2> 3
3> 2
4> 4
5> 3
6> 5
5 3 4 2 3 1
[説明]
iarray_reverseとmainのところ以外はテキストを参考にした。
iarray_reverseでは、xを用意し配列の最初と最後から順番に入れ替わるようにした。
iは配列の前半の範囲だけ動けばいいためこの範囲になった。
[レビュー]
ポインタを引数に受け取ったら、a[i]ではなくて*(a+i)としても良い。
[アンケート]
Q1.はい。
Q2.はい。
Q3.アドレス等の理解が深まった。
y1910697 2a:○ Tue May 19 18:27:46 2020
学籍番号 1910697
個人作業
5月19日提出
演習1a 配列の最大値を求める
プログラム
#include <stdio.h>
#include <stdbool.h>
int iarray_max(int *a,int n){
if (n==0){
printf("error");
return 0;
}else{
int max=a[0],i;
for (i=0;i<n;i++){
if (max<a[i]){
max=a[i];
}
}
return max;
}
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 4), -1, "-3 -2 -4 -1");
expect_int(iarray_max(b, 0),0 , "");
expect_int(iarray_max(b+1, 0),0 , "");
expect_int(iarray_max(a, 0),0 , "");
return 0;
}
説明
iarray_maxが配列の最大値を求める関数です。わたされた配列の長さが
0の時はerrorを表示して0を返します。expect_intは単体テスト用の関
数です。
結果
[y1910697@sol 2kai]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -1:-1 -3 -2 -4 -1
errorOK 0:0
errorOK 0:0
errorOK 0:0
レビュー課題
TAの宮島さん
エラー処理を加えるという工夫がされていて良いです。ただ、「error」
を出力した後に改行を加えると、より見やすくなると思います。
アンケート
Q1 アドレス、ポインタについて納得しましたか？
A1 複数の値を同時に扱えるのは便利だと思いました。使い方に混乱しているのでなれるしかないと思いました。
Q2 構造体を用いた情報隠蔽について納得しましたか？
A2 完全には理解しきれていません。ポインタをもう少しちゃんと理解
する必要があると感じました。
Q3 リフレクション
A3 テストケースを考えたりチェックするのになれたいと思いました。
ポインタやアドレスに対する理解が足りないとわかったので復習します。
前回につづいて改行をいれてなくて結果の可読性が低くなっているので
気をつけたいと思います。
y1910698 2a:○ Tue May 19 19:42:32 2020
プログラミング通論レポート＃2a
提出日付：2020年5月19日
[取り組んだ課題と作成したプログラム]
課題:1a
・実際に作成したプログラム
//配列の最大値を求める
#include <stdio.h>
#include <stdbool.h>
int iarray_max (int *a, int n)
{
int max = a[0];
for (int i=0; i < n; i++)
{
if (max < a[i])
max = a[i];
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s¥n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void)
{
int a[] = {9,0,0,1,2,3};
int b[] = {-1,-3,-2,-4,-1};
int c[] = {-9,45,50,12,2,-5,2};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
//増やしたテストケース
expect_int(iarray_max(b+1,3),-2,"-3 -2 -4");
expect_int(iarray_max(a+2,3),2,"0 1 2");
expect_int(iarray_max(c,7),50, "-9 45 50 12 2 -5 2");
expect_int(iarray_max(c+3,3),12, "12 2 -5 2");
return (0);
}
[プログラムの実行例]
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
OK 2:2 0 1 2
OK 50:50 -9 45 50 12 2 -5 2
OK 12:12 12 2 -5 2
[プログラムの説明]
関数iarray_maxは配列の要素の最大値を求める関数です。また、
expect_intで単体テストを行い、プログラムが正常に動くかを確かめま
す。//増やしたテストケースより下に書かれているテストコードはテキ
ストには記されていない独自で考えて追加したテストケースです。また、
テストケースには新たに配列cを加えて行っているものも増やしました。
[レビュー課題]
レビュー回答者: 兄
プログラムは正常に動いていている点は良いが、もしも与えられるnの
値が0以下だった時にはなにか「error」などの表示をするなどの工夫を
するとより親切ではないかと思った。
[アンケート]
Q1. まだ完全に理解したわけではないので、よく復習しようと思う。
Q2.難しかったが、仕組みは理解できた。
Q3. ポインタを使うと何が何を表しているのか頭がこんがらがって大変だった。
y1910699 2a:○ Tue May 19 23:35:23 2020
プログラミング通論 第二回レポート課題(a)
2020/5/19
【作成したプログラム(入力された配列の最大値を返すプログラム)】
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 0; i < n; ++i) {
if (max < a[i]) {
max = a[i];
}
}
return max;
}
int main(void) {
int a[4], b[4];
iarray_read(a,4); iarray_print(a, 4);
printf("The maximum value is %d\n",iarray_max(a, 4));
return 0;
}
【プログラムの簡単な説明】
iarray_read関数で入力された整数を配列に格納し、iaaray_print関数
でその配列をターミナルに表示している。また、iarray_max関数で配列
中の最大値を返し、main関数でその値を表示している。
【手動入力による実行結果】
1> 2
2> 5
3> 4
4> 6
2 5 4 6
The maximum value is 6
1> -1
2> -8
3> 0
4> -12
-1 -8 0 -12
The maximum value is 0
【単体テストプログラム】
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a, int n) {
int max = a[0];
for(int i = 0; i < n; ++i) {
if (max < a[i]) {
max = a[i];
}
}
return max;
}
void expect_int(int a, int n, char *msg) {
printf("%s:%s %s\n", (a==n)?"OK":"NG", msg);
}
int main(void) {
int a[] = {9, 0, 0, 1, 2, 3};
int b[] = {-1, -3, -2, -4, -1};
int c[] = {2, 92, -6, 10, -51, 0};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c+2, 4), 10, "-6, 10, -51, 0");
return 0;
}
【テストプログラムの簡単な説明】
expect_int関数では、引数aとnの値が一致していればOK、そうでなけれ
ばNGと表示し、また*msgに入力された文字列も表示している。main関数
内には3つの配列があらかじめ用意されており、ここでexpect_int関数
を実行している。1つ目の引数はiarray_max関数により返された値、2つ
目の引数は本来出力されるべき配列の最大値であり、これが一致してい
るかどうかを判定する。また、3つ目の引数には最大値を評価する対象
の配列が文字列として入力されている。
【テストプログラムの実行結果】
OK:9 0 0 1 2 3 OK
OK:0 0 1 2 3 OK
OK:-1 -3 -2 -4 -1 OK
OK:-6, 10, -51, 0 OK
【レビュー課題(友人から)】
コンパクトにまとまっていて見やすいと思いました。自分も後から気が
付いたのですが、#include <stdbool.h>はなくても動くかなと思いまし
た。それから、テストケースを増やさないとレポート△になるかも、と
いう旨の発言を先生がおっしゃっていたので足した方がいいかもしれな
いです。
(プログラムを友人にレビューしてもらった時点では、テキストのテス
トケースのみ実行していました。)
【アンケート】
Q1. アドレス、ポインタについて納得しましたか。
→まだまだ完全な理解からは程遠いですが、今回の講義で少しわかるよ
うになりました。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
→まだ完全には理解できていないので、引き続き勉強します。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
→当然の事ですが、予習が大切だと感じました。予習をして、講義中は
先生とTAの方に質問を繰り返して
やっとこのレポートが書けるレベルなので…
次回も頑張ります。
y1910705 2a:○ Tue May 19 15:13:11 2020
2aレポート
[課題]
演習1a:配列の最大値を求める関数
~作成したプログラム~
#include <stdio.h>
int iarray_max(int *a, int n){
int i;
int max = *a;
for(i = 0; i < n; ++i ){
if(max < *(a + i)){
max = *(a + i);
}
}
return max;
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1}, c[] = {5,8,-5,0,2,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1, 3), -2, "-3 -2 -4");
expect_int(iarray_max(c, 6), 8, "5 8 -5 0 2 -1");
expect_int(iarray_max(c+2, 3), 2, "-5 0 2");
return 0;
}
~実行例~
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
OK 8:8 5 8 -5 0 2 -1
OK 2:2 -5 0 2
~プログラムの説明~
ポインタを用いて配列の最大値を求めるプログラムを作成した。
また、単体テストで様々なテストケースを試せるようにした。
~レビュー（友人）~
配列をポインタのみであらわしていて見やすい。テストケースがたくさ
んあってとても良い。
[アンケート]
Q1. アドレス、ポインタについて納得しましたか。
あまり納得できていないため、復習したい。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
まだ学習できていない。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
今週の課題も頑張りたい。
y1910707 2a:○ Tue May 19 17:05:50 2020
// iarray_demo.c --- array input/output and equality demo.
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i < n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
int iarray_reverse(int *a, int n) {
int c;
for(int i=0; i < n/2; ++i){
c = a[i];
a[i] = a[n-i-1];
a[n-i-1] = c;
}
}
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", (iarray_equal(a, b, n))?"OK":"NG", msg);
iarray_print(a, n); iarray_print(b, n);
}
int main(void) {
int a[] = {8,5,2,4,1}, b[] = {1,4,2,5,8};
iarray_reverse(a, 5);
expect_iarray(a, b, 5, "85241 -> 14258");
int c[] = {1,1,1,1,1}, d[] = {1,1,1,1,1};
iarray_reverse(c, 5);
expect_iarray(c, d, 5, "11111 -> 11111");
int e[] = {0,100,16,4,1, 5}, f[] = {5,1,4,16,100,0};
iarray_reverse(e, 6);
expect_iarray(e, f, 6, "010016415 -> 514610010");
return 0;
}
実行例
OK 85241 -> 14258
1 4 2 5 8
1 4 2 5 8
OK 11111 -> 11111
1 1 1 1 1
1 1 1 1 1
OK 010016415 -> 514610010
5 1 4 16 100 0
5 1 4 16 100 0
説明
iarray_reverse()で配列を変換後, これが等しいか否かをiarray_equal
で調べて真偽値を返している. なおテストケースに関しては配列のサイ
ズを変えたものも用意した.
コメント(友人より)
nを指定するのは何故？リストの個数見るんじゃダメなの？
アンケート
Q.1 復習になるので, 理解はできた.
Q.2 原理的にできそうなことは分かった.
Q.3 今後ともポインタについては扱っていきたい.
ご友人の方がちょっと理解に問題あるかもですね。おつかれ様です。
y1910708 2a:○ Tue May 19 13:58:02 2020
1910708 吉田光河 個人作業 2020/5/19
1a
// test_array_equal.c --- unit test of array_equal
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
bool iarray_equal(int *a, int *b, int n) {
for(int i = 0; i <= n; ++i) {
if(a[i] != b[i]) { return false; }
}
return true;
}
int iarray_max(int *a, int n) {
int t;
int i;
for(i = 0; i <= n - 1; ++i) {
if(i == 0){
t = a[0];
}else if(i > 0){
if(a[i] > t){
t = a[i];
}
}
}
return t;
}
char *bool2str(bool b) { return b ? "true" : "false"; }
void expect_bool(bool b1, bool b2, char *msg) {
printf("%s %s:%s %s\n", (b1==b2)?"OK":"NG",
bool2str(b1), bool2str(b2), msg);
}
//以下２つは単体テスト用
// bool iarray_equal(int *a, int *b, int n) {
// for(int i = 0; i < n; ++i) {
// if(a[i] != b[i]) { return false; }
// }
// return true;
// }
void expect_iarray(int *a, int *b, int n, char *msg) {
printf("%s %s\n", iarray_equal(a, b, n)?"OK":"NG", msg);
iarray_print(a, n);
iarray_print(b, n);
}
void expect_int(int i1, int i2, char *msg) {
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1},c[] = {5,5,5,-5,10};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(c, 5), 10, "5 5 5 -5 10");
return 0;
}
決められた配列の最大値を求める関数
for文を用いて、初めはa[0]を最大値tとして
それよりも大きな値がある場合に最大値tとして更新した。
単体テストと実行例
C:\Users\81909\Documents\Code\2020 演習２>a.exe
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 10:10 5 5 5 -5 10
レビュー課題
このコードでは初めの最大値を決めるときにif文でi = 0のときに
分岐させて決めているが、tの宣言の際に t = a[0]としておけば
そのif文を無くせるため、より簡潔になると思う。
Q1. アドレス、ポインタについて納得しましたか。
課題をやるなかで理解できた。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
いまいちよく分からない。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
次回も頑張りたい
もうちょっとテストケース増やしたいね。おつかれ様でした。
y1910709 2a:○ Tue May 19 19:27:55 2020
学籍番号:1910709
提出日時:5/19
演習1aのソースコード:
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n) {
for(int i = 0; i < n; ++i) {
printf("%d> ", i+1); scanf("%d", a+i);
}
}
void iarray_print(int *a, int n) {
for(int i = 0; i < n; ++i) { printf(" %2d", a[i]); }
printf("\n");
}
int iarray_max(int *a,int n) {
int k = a[0];
for(int i = 0; i < n; ++i) {
if(a[i] > k) { k = a[i]; }
}
return k;
}
void expect_int(int b1, int b2, char *msg) {
printf("%s %d:%d %s\n", (b1==b2)?"OK":"NG", b1, b2, msg);
}
int main(void) {
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
expect_int(iarray_max(a+2, 4), 3, "0 1 2 3");
expect_int(iarray_max(b+1, 3), -2, "-3 -2 -4");
expect_int(iarray_max(b, 3), -1, "-1 -3 -2");
return 0;
}
説明:
最初に配列a,bを定義しiarray_max関数に調べる要素の場所と要素数を引数として
渡す。iarray_max関数では変数kにa[0]を渡しfor文で各要素を調べ、a[i] > k
を満たすとき変数kにその値を代入する。そうして最終的に最大の要素をreturn k
で返す。返ってきた値と予想していた値をexpect_int関数に入れ,テストする。
返ってきた値が予想していた値と等しかった場合,OK,異なっていたときNGを返す。
今回はテストケースを6つ実行している。
単体テストの実行結果:
[y1910709@sol ~/pro]$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK 3:3 0 1 2 3
OK -2:-2 -3 -2 -4
OK -1:-1 -1 -3 -2
レビュー:
バグをプログラムを使って発見するのは効率的だと感じた(友人から)
アンケート:
Q1 なんとなくは理解できた。
Q2 スライドを読んだが難しかった
Q3 アドレスやポインタの扱いが複雑で混乱した。 テストケースは便
利だと思った。
文字コードをUTF8で出してくださいね。おつかれ様です。
y1910714 2a:○ Tue May 19 21:10:52 2020
個人作業
提出日時:5月19日 21:10頃
1a:配列と整数nを受け取り、配列の最大値を返す
【ソースコード・単体テスト】
#include<stdio.h>
#include<stdbool.h>
int iarray_max(int *a, int n){
int i,m=a[0];
for(i=0;i<n;++i){
if(m<a[i]){m=a[i];}
}
return m;
}
void expect_int(int i1, int i2, char *msg){
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG",i1,i2,msg);
}
int main(void){
int a[]={9,0,0,1,2,3},b[]={-1,-3,-2,-4,-1};
expect_int(iarray_max(a,6),9,"9 0 0 1 2 3");
expect_int(iarray_max(a+1,5),3,"0 0 1 2 3");
expect_int(iarray_max(b,5),-1,"-1 -3 -2 -4 -1");
expect_int(iarray_max(b+1,3),-2,"-3 -2 -4");
return 0;
}
【実行例】
$ ./a.out
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
OK -2:-2 -3 -2 -4
【説明】
最大値を返す関数iarray_maxはこれまでに学んだ通りである。すなわち、
まず初項を最大値としておき、続く項がそれを上回ればその値に更新す
ればよい。
テストケースは、問題文に示されている他に、b[1]からb[3]の3数に
iarray_maxを適用した場合を加えた。これは、bの両端がともに-1で、
これらを除けば最大値が-2に変わるからである。
【コメント(原文ママ)】
簡潔で良くかけています。
【アンケート】(以下、Q1の回答をA1などと記す)
A1.ある程度は納得しました。1aでは「配列はポインタの一種」である
こと(とテストケース)を確認するにとどまり、基礎プロでやったような
「一つの関数で複数の変数を書き換える」操作はありませんでしたが。
A2.ある程度は。「実装部分」という概念が登場し、なんとなくプログ
ラミングらしさを感じました。
A3.テストケースは、プログラムを書く以上欠かせないものだと分かり
ました。しっかり身につけたいです。
レビューまもうちょっと書いてもらいましょうね。おつかれ様です。
y1910715 2a:○ Tue May 19 20:39:35 2020
学籍番号：1910715
「個人作業」
取り組んだ課題：課題1-a
配列の最大値を求める関数int iarray max(int *a, int n) を作成する。
作成したプログラム：
//iarraymax.c --- quest maximum of array.
#include <stdio.h>
int iarray_max(int *a, int n){
int k = *(a);
for(int i= 0; i < n; ++i){
if(k < *(a+i)){k=a[i];}
}
return k;
}
void expect_int(int i1, int i2, char *msg){
printf("%s %d:%d %s\n", (i1==i2)?"OK":"NG", i1, i2, msg);
}
int main(void){
int a[] = {9,0,0,1,2,3}, b[] = {-1,-3,-2,-4,-1};
expect_int(iarray_max(a, 6), 9, "9 0 0 1 2 3");
expect_int(iarray_max(a+1, 5), 3, "0 0 1 2 3");
expect_int(iarray_max(b, 5), -1, "-1 -3 -2 -4 -1");
printf("%d\n",iarray_max(a, 0));
int c[] = {2,5,-10,8,2*5};
expect_int(iarray_max(c, 4), 8, "2,5,-10,8");
expect_int(iarray_max(c, 3), 5, "2,5,-10,8");
expect_int(iarray_max(c, 5), 10, "2,5,-10,8,2*5");
return 0;
}
簡単な説明および単体テストと実行例：
iarray_maxでは最初に渡された配列の最初の値をkに入れている。
そのあとのforループの中で順次配列に格納されている値を呼び出し、k
に入っている値より大きければその値をkに入れている。
配列の最後までこの操作を行ったら、最大値が格納されているkの値を返している。
テストケースでは教科書に提示されていたものに加え、iarray_max(a,
0)の実行結果と新たにc[] = {2,5,-10,8,2*5}という配列を作って
iarray_max(c, 4)とiarray_max(c, 3)とiarray_max(c, 5)が想定通りの
動きをするかを見た。
教科書に提示されていたテストケースの実行結果は以下のようになり、問題なかった。
OK 9:9 9 0 0 1 2 3
OK 3:3 0 0 1 2 3
OK -1:-1 -1 -3 -2 -4 -1
また自作のテストケースについても、iarray_max(a, 0)の結果が9になっ
ていることから、kの初期値として配列の最初の値を入れることができ
ていることが分かる。
そして配列cを使ったテストケースの動作も問題ないことが分かり、iarray_max(c, 3)とiarray_max(c, 5)の動作が問題無いことからiarray_maxは渡された要素数（nの値）以上は操作を行わず、要素内に計算を含むものでも動作することが分かった。
実行結果は以下の通り
9
OK 8:8 2,5,-10,8
OK 5:5 2,5,-10,8
OK 10:10 2,5,-10,8,2*5
レビュー：友達
簡潔にまとまっていて良いプログラムだと思った。また、テストケース
に計算を含めることで、実用性を高めていて良いと思った。
アンケート：
Q1. アドレス、ポインタについて納得しましたか。
プログラミング通論や情報領域学演習第一の時にてこずって、いろいろ
と試したおかげか今回は割とスムーズに理解できた。
Q2. 「構造体を用いた情報隠蔽」について納得しましたか。
外部に対しては使えるコマンドだけ教えて、処理は暗号化された中で行
うということなら納得できた。
Q3. リフレクション(今回の課題で分かったこと)・感想・要望をどうぞ。
自分は動作が思い通りにならなかったりしたときは直接使用している関
数内でprintfを行ったりしている。
例えば今回の場合だとiarray_maxの中の
for(int i= 0; i < n; ++i){
if(k < *(a+i)){k=a[i];}
}
を
for(int i= 0; i < n; ++i){
if(k < *(a+i)){k=a[i];}
printf("%d ",k);
}
printf("\n");
と変えてkの内容が適切に変わっているかを見たりしている。
そして提出するときや実装するときは加えたprintfの部分を//でコメン
トアウトを行っている。でもやはり、直接関数をいじるのはそれ自体が
バグの要因になる可能性があるからやめた方がいいのでしょうか？
いや、printfデバッグとかしたければどうぞ。おつかれ様です。
y1910716 2a:○ Tue May 19 21:18:05 2020
学籍番号 1910716
個人作業
提出日時 2020/05/19 21:19
[プログラム]
演習1 ｃ
ソース
#include <stdio.h>
#include <stdbool.h>
void iarray_read(int *a, int n){//配列の入力
for(int i =0; i < n; i++){
printf("%d",i+1);scanf("%d",a+i);
}
}
void iarray_print(int *a, int n){//配列の出力
for(int i = 0; i < n; i++){
printf("%d",a[i]);
}
printf("\n");
}
bool iarray_equal(int *a, int *b, int n){//配列の同値比較
for(int i; i < n; i++){
if(a[i] != b[i]){
return false;
}
}
return true;
}
void iarray_sort(int *a, int n){ //ソート
int k;
for(int i = 1; i < n; i++){
for(int j = 0; j < i; j++){
if(a[i] < a[j]){
k = a[i];
a[i] = a[j];
a[j] = k;
}
}
}
}
void expect_iarray(int *a, int *b, int n, const char *msg){ //単体テスト
printf("%s %s\n",iarray_equal(a, b, n)?"OK":"NG",msg);
iarray_print(a, n);
iarray_print(b, n);
}
int main(void){
int i,n;
int a[9];
printf("1.実行 2.テスト>");scanf("%d",&i);
if(i==2){ //main単体テスト
int a[] = {8,5,2,4,1}, b[] = {1,2,4,5,8};
int c[] = {7,5,-2,0,3,7}, d[] = {-2,0,3,5,7,7};
iarray_sort(a, 5);
expect_iarray(a, b, 5, "85241 -> 12458");
iarray_sort(c, 6);
expect_iarray(c, d, 6, "75-2437 -> -203577");
}
else{ //main実行
printf("n(0-9)>");scanf("%d",&n);
iarray_read(a, n);
iarray_sort(a, n);
iarray_print(a, n);
}
return 0;
}
説明
ソートしたい数字の数を入力し、ソートする数字をひとつずつ配列に入
力させた。完成した配列と入力した文字数を引数とした関数を動かして
ソートし、ソートできた数列を表示させた。単体テストはソート前の配
列とソート後の配列をあらかじめ作り、ソート前の配列を用いてソート
を行い、作ったソート後の配列と比較して同値であることを確認した。
実行例
1.
n(0-9)>5
1>3
2>6
3>8
4>1
5>5
13568
2.
n(0-9)>8
1>7
2>1
3>1
4>7
5>4
6>-2
7>-5
8>3
-5-2113477
テスト
1.
OK 85241 -> 12458
12458
12458
2.
OK 75-2437 -> -203577
-203577
-203577
[コメント]
ソートの処理に無駄が多いと思います。
もう少し最適化してソートすることができると思います。
[アンケート]
Q1.
ある程度納得した。
Q2.
よくわからなかった。今週中に例文を動かしたりして納得したい。
Q3.
if文のなかで配列を定義できなかった。
ifの中でもできますがスコープがifの中だけになりますね。
おつかれ様でした。