C高级第三次PTA作业(1)
题目6-1 输出月份英文名
1.设计思路
(1)算法(子函数)
第一步：定义字符型一级指针子函数名getmonth,形参整型n。
第二步：定义长度为12的字符数组指针months依次指向12个月份的升序英文名称(首字母大写)。
第三步：若数字月份n大于12或者小于1则返回空指针NULL,否则返回间接访问months加n减1(对应n月份的二级指针指向的一级指针的值为指向对应n月份的地址)。
(2)流程图
2.实验代码
#include <stdio.h>
char *getmonth( int n );
int main()
{
int n;
char *s;
scanf("%d", &n);
s = getmonth(n);
if ( s==NULL ) printf("wrong input!
");
else printf("%s
", s);
return 0;
}
char *getmonth(int n)
{
char *months[12]={"January","February","March","April","May","June",
"July","August","September","October","November","December"};
if(n<1||n>12)
return NULL;
else
return *(months+n-1);
}
3.本题调试过程碰到问题及解决办法
错误信息1：
错误原因：字母写错和变量写错了就不说了。
在判断不满足可以输出月份的条件的n的值的时候使用的逻辑运算符是与,导致这个条件一直是0,判断时不会返回空指针。判断中否则的返回语句返回的是一个常量,不能传递正确的指针,没有根据月份的不同而变化。
改正方法：将逻辑运算符更改成或,只要满足其中的一个条件就是1。将指针变量加上n减去1,对应代码区中的相应的字符串的地址和下标。
错误信息2：
错误原因：判断中满足1-12月份的返回值是一个二级指针也就是指针数组的地址,这个地址指向的是指向字符串首元素地址的地址,主函数读出来的就是地址不是字符串。
改正方法：在返回的二级指针前加上间接访问符号*,间接访问二级指针中的值,就是返回一级指针,这样程序主函数读出来的就是字符串了。
提交列表：
题目6-2 查找星期
1.设计思路
(1)算法(子函数)
第一步：定义整型子函数名getindex,形参字符指针型s。
第二步：定义字符指针型的长度为7的字符数组days,将星期的英文从周日Sunday开始一次赋初值给days(每个星期字符串的首字母大写),0赋给整型循环变量i。
第三步：若i小于7则下一步,否则返回-1。
第四步：若主函数输入的星期字符串的首元素地址s与间接访问days加i(第i+1个星期字符串的首字母的地址)通过strcmp函数比较的值为0则返回i的值,否则不执行。
第五步：i+1赋给i,跳到第三步。
(2)流程图
略
2.实验代码
#include <stdio.h>
#include <string.h>
#define MAXS 80
int getindex( char *s );
int main()
{
int n;
char s[MAXS];
scanf("%s", s);
n = getindex(s);
if ( n==-1 ) printf("wrong input!
");
else printf("%d
", n);
return 0;
}
int getindex(char *s)
{
char *days[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
for(short int i=0;i<7;i++)
if(strcmp(s,*(days+i))==0)
return i;
return -1;
}
3.本题调试过程碰到问题及解决办法
错误信息1：
错误原因：变量少了一个字母之类的就不说了。
题目要求若输入的不是代表星期的字符串就返回-1，代码中没有返回-1的语句。
改正方法：在循环结束后无返回说明并没有满足一样的星期,是除星期以外的字符串,则返回-1。
错误信息2：
错误原因：for循环中判断的是数据区的字符数组s的首元素地址是否与代码区的二级指针days+i指向的一级指针的地址相等,本来地址的存放区域就不同了,在比较时判断结果肯定始终是0。
改正方法：由裁判实现部分发现头文件有<string.h>的文件,指明这道题目是可以用字符的比较来判断,将原判断条件改成strcmp(s,*(days+i))==0的形式来判断。
提交列表：
题目6-3 计算最长的字符串长度
1.设计思路
(1)算法(子函数)
第一步：定义整型子函数名max_len,形参字符指针型字符数组s,整型n。
第二步：间接访问s(代表第一个单词字符串的首元素地址)通过strlen函数计算的长度赋给整数length,1赋给整数i。
第三步：若i小于n则下一步,否则返回length的值。
第四步：若strlen((s+i))(第i+1个单词字符串的首元素的地址通过strlen函数读取并计算长度)大于length则strlen((s+i))赋给length,否则不执行。
第五步：i+1赋给i,跳到第三步。
(2)流程图
略
2.实验代码
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXN 10
#define MAXS 20
int max_len( char *s[], int n );
int main()
{
int i, n;
char *string[MAXN] = {NULL};
scanf("%d", &n);
for(i = 0; i < n; i++)
{
string[i] = (char *)malloc(sizeof(char)*MAXS);
scanf("%s", string[i]);
}
printf("%d
", max_len(string, n));
return 0;
}
int max_len(char *s[],int n)
{
short int length=strlen(*s);
for(short int i=1;i<n;i++)
if(strlen(*(s+i))>length)
length=strlen(*(s+i));
return length;
}
3.本题调试过程碰到问题及解决办法
错误信息：
错误原因：函数中的strlen函数括号内的变量s、s+i是二级字符指针变量,strlen函数读取一级字符指针变量的地址,并不能读出一级指针指向的字符串首元素地址。
改正方法：在二级字符指针前加上间接访问符号,使之成为二级指针指向的一级指针的值就是一级指针变量中存的字符串的首元素地址。
提交列表：
题目6-4 指定位置输出字符串
1.设计思路
(1)算法(子函数)
第一步：定义一个标志flag初始值为0,新建一个存放指定位置字符的一维字符数组result,下标j初始值为0,返回的指定第一个字符的地址ch1指针address初始值为回车符号。
第二步：利用一个for循环,若循环变量i大于等于MAXS则跳出循环,第j+1字符数组的元素为结束符,跳到第五步,否则下一步。
第三步：若标志为1则将原字符数组中的字符赋给result对应的下一个字符,j+1赋给j,如果此字符满足指定的第二个字符ch2则跳出循环,跳到第五步,否则下一步。
第四步：若标志为0则判断此时字符是否为指定字符ch1,若是则标志flag为1,并将此字符赋值给result的第一个元素,j+1赋给j,指针address指向ch1的地址,i+1赋给i,跳到第二步。
第五步：若一维字符数组result为空则输出字符串result,并返回address的值(这里有输出字符形式的区别具体看代码)。
(2)流程图
略
2.实验代码
#include <stdio.h>
#define MAXS 10
char *match( char *s, char ch1, char ch2 );
int main()
{
char str[MAXS], ch_start, ch_end, *p;
scanf("%s
", str);
scanf("%c %c", &ch_start, &ch_end);
p = match(str, ch_start, ch_end);
printf("%s
", p);
return 0;
}
char *match(char *s,char ch1,char ch2)
{
short int flag=0,j=0;
char *address={"
"},result[MAXS];
for(short int i=0;i<MAXS;i++)
if(flag==1)
{
*(result+j)=*(s+i);
j++;
if(*(s+i)==ch2)
break;
}
else
{
if(*(s+i)==ch1)
{
flag=1;
*(result+j)=*(s+i);
j++;
address=(s+i);
}
}
*(result+j)=' ';
if(*result==NULL)
{
printf("%s",result);
return address;
}
else
{
puts(result);
return address;
}
}
3.本题调试过程碰到问题及解决办法
错误信息1：
错误原因：没仔细读懂题目的意思,一开始理解题目的意思以为是返回字符ch1和字符ch2之间的字符串,有主函数实现输出,实际意思是用子函数实现输出两个字符之间的字符串,然后返回字符ch1在原字符串中的位置,即返回该字符的地址,由主函数实现输出字符ch1开始所有字符,本人直接将要输出的内容赋给了原字符串,改变了原字符串,子函数中也没有实现输出两个字符之间的字符串,返回的指针是改变原字符串的指针。
改正方法：重新定义两个字符指针变量address(用来存放字符ch1在原字符串中的地址)、result(用来存放字符ch1和字符ch2之间的字符),后续情况不做具体说明。
错误信息2：
错误原因：本段代码中的实现子函数输出字符ch1和字符ch2之间的字符串并没有实现的错误在错误信息1中已经作出说明
字符指针不能实现一个一个赋值,字符指针可以实现一个一个赋值,在定义存放字符ch1和ch2中的字符串的变量时定义的是字符指针,所以两个字符之间的字符并不能正确地赋值。考虑得不全面,第一个字符ch1可能在原始字符串中出现相同的ch1字符,如果不解决这种情况,返回的ch1的地址就是第二个ch1的地址,与原题目不符。
改正方法：将字符指针变量result改成字符数组型,result作为名字,将两个字符之间的字符一个一个赋值给result。本题代码设定了一个标识符flag初始值为0,如果没有遇到和字符ch1相同的字符则始终不进行字符串的赋值,通过先判断flag来排除出现多个ch1的情况,只要出现一次ch1就改变标识符为1,如此判断就不会出现重复赋地址给address的情况了。
错误信息3：
错误原因：由于address没有赋初值,在返回address时没有返回一个正确的地址。
改正方法：本题由于不知道主函数应该输出回车符号,所以一开始只是给字符指针address初始定义为空,
错误信息4：
错误原因：在字符数组result为空时输出的不是result对应的空指针而是换行了,错误地理解了题目的意思,并且直接返回回车这样的代码是无效的。
改正方法：使用printf输出result,不会多出一行的换行,给字符指针address赋一个换行符号的初值,并且在判断中返回address。
提交列表：
一道编程题：
有一个axb的数组,该数组里面顺序存放了从1到a*b的数字。其中a是你大学号的前三位数字，b是你大学号的后四位数字，比如你的学号是2017023936，那么数组大小是201 x 3936，数组中顺序存放了1到791136（201和3936的积）的整数. 要求用筛选法,把该数组里的质数找出并打印出来，打印格式为5个质数一行，数字间用空格隔开。
筛选法具体做法是：先把N个自然数按次序排列起来。1不是质数，也不是合数，要划去。第二个数2是质数留下来，而把2后面所有能被2整除的数都划去。2后面第一个没划去的数是3，把3留下，再把3后面所有能被3整除的数都划去。3后面第一个没划去的数是5，把5留下，再把5后面所有能被5整除的数都划去。这样一直做下去，就会把不超过N的全部合数都筛掉，留下的就是不超过N的全部质数。
1.设计思路
(1)算法
第一步：定义一个行是201列是3950的全局变量二维数组array。
第二步：input子函数调用,输入数组array中各个元素的值。
第三步：利用双层for循环,外循环变量i初始值为0,i大于等于201则跳出外循环,否则内循环变量j初始值为0,j大于等于3950则跳出内循环,执行外循环。
第四步：若二维数组对应的第i+1行第j+1列个元素的值不为0则判断调用子函数prime判断这个元素是否为素数,是则调用子函数exclude,使能够被这个素数整除除这个素数本身以外的数都变成0,否则让这个非素数变成0。
第五步：j+1赋给j,跳到第二步,若是满足条件跳出内循环则i+1赋给i,跳到第二步。
第一步：定义空子函数input,传递参数二级指针array。
第二步：利用两个for循环,将从number从1开始的值依次赋给二维数组array的每个元素。
第一步：定义短整型子函数名prime,传递参数正整数number。
第二步：若number为1则返回0,否则下一步。
第三步：利用for循环,循环变量i初始值为1,循环条件为i小于等于number除以2,循环时i+1赋给i。
第四步：若i为1则不执行跳到第二步,否则判断number是否能被i整除,能整除则返回0。
第五步：跳出循环则说明是素数返回1。
第一步：定义空子函数名为exclude,传递参数array和number。
第二步：利用两个for循环,同上。
第三步：若第i+1行第j+1列元素的值不等于0则下一步,否则跳到上一步进行循环。
第四步：若第i+1行第j+1列元素的值除以number的余数等于0且商不等于1则第i+1行第j+1列元素的值为0,否则跳到第二步进行循环。
第一步：定义空子函数名为output,传递参数array。
第二步：定义短整型数count初始值为1。
第三步：利用两个for循环,同上。
第四步：若第i+1行第j+1列元素的值不等于0则下一步,否则跳到上一步进行循环。
第五步：若count等于1则输出第i+1行第j+1列元素的值,count+1赋给count,否则下一步。
第六步：若count等于5则输出空格第i+1行第j+1列元素的值回车,1赋给count,否则输出空格第i+1行第j+1列元素的值,count+1赋给count。
(2)流程图
略
2.实验代码
#include <stdio.h>
#include <stdlib.h>
int array[201][3950];
void input(int array[201][3950]);
short int prime(int number);
void exclude(int array[201][3950],int number);
void output(int array[201][3950]);
int main()
{
input(array);
for(int i=0;i<201;i++)
for(int j=0;j<3950;j++)
if(array[i][j])
{
if(prime(array[i][j]))
exclude(array,array[i][j]);
else
array[i][j]=0;
}
output(array);
return 0;
}
void input(int array[201][3950])
{
int number=0;
for(int i=0;i<201;i++)
for(int j=0;j<3950;j++)
array[i][j]=++number;
}
short int prime(int number)
{
if(number==1)
return 0;
for(short int i=1;i<=number/2;i++)
if(i==1)
continue;
else if(number%i==0)
return 0;
return 1;
}
void exclude(int array[201][3950],int number)
{
for(int i=0;i<201;i++)
for(int j=0;j<3950;j++)
if(array[i][j])
if(array[i][j]%number==0&&array[i][j]/number!=1)
array[i][j]=0;
}
void output(int array[201][3950])
{
short int count=1;
for(int i=0;i<201;i++)
for(int j=0;j<3950;j++)
{
if(array[i][j])
{
if(count==1)
{
printf("%d",array[i][j]);
count++;
}
else if(count==5)
{
printf(" %d
",array[i][j]);
count=1;
}
else
{
printf(" %d",array[i][j]);
count++;
}
}
}
}
3.本题调试过程碰到问题及解决办法
略
C高级第三次PTA作业(2)
题目6-1 奇数值结点链表
1.设计思路
(1)算法
第一步：定义子函数struct ListNode指针型名为readlist。
第二步：定义单向链表的头指针head为空,利用for循环,其中定义一个尾结点和一个动态指针结点。
第三步：输入结构中需要的数据data,并让动态指针指向输入的数据,尾指针指向空。
第四步：判断输入的data数据是否为1,若是则跳出循环,跳到第五步,否则让单向链表指向动态指针,若头指针为空则头指针指向动态结点,否则尾结点的next指针指向动态结点。
第五步：尾指针tail始终指向动态结点,跳到第第三步。
第六步：返回头指针。
第一步：定义一个新奇数链表的头指针oddhead为空,新的偶数链表的头指针evenhead为空。
第二步：让头指针oddhead指向其中的奇数结点,依次找出奇数结点并且组成一个奇数单向链表。
第三步：让头指针evenhead指向原链表中的偶数结点,找出偶数结点形成的偶数单向链表,并让原链表的头指针指向新建偶数单向链表。
第四步：返回奇数链表的头指针oddhead。
(2)流程图
略
2.实验代码
#include <stdio.h>
#include <stdlib.h>
struct ListNode
{
int data;
struct ListNode *next;
};
struct ListNode *readlist();
struct ListNode *getodd( struct ListNode **L );
void printlist( struct ListNode *L )
{
struct ListNode *p = L;
while (p)
{
printf("%d ", p->data);
p = p->next;
}
printf("
");
}
int main()
{
struct ListNode *L,*Odd;
L=readlist();
Odd=getodd(&L);
printlist(Odd);
printlist(L);
return 0;
}
struct ListNode *readlist()
{
struct ListNode *head=NULL;
for(struct ListNode *i=NULL,*tail=NULL;;tail=i)
{
i=(struct ListNode*)malloc(sizeof(struct ListNode));
scanf("%d",&i->data);
i->next=NULL;
if(i->data==-1)
break;
else if(head)
tail->next=i;
else
head=i;
}
return head;
}
struct ListNode *getodd(struct ListNode **L)
{
struct ListNode *oddhead=NULL,*evenhead=NULL;
for(struct ListNode *i=(*L),*oddtail=NULL,*eventail=NULL;i!=NULL;i=i->next)
if(i->data%2!=0)
{
struct ListNode *odd=(struct ListNode *)malloc(sizeof(struct ListNode));
odd->data=i->data;
odd->next=NULL;
if(oddhead)
oddtail->next=odd;
else
oddhead=odd;
oddtail=odd;
}
else
{
struct ListNode *even=(struct ListNode *)malloc(sizeof(struct ListNode));
even->data=i->data;
even->next=NULL;
if(evenhead)
eventail->next=even;
else
evenhead=even;
eventail=even;
}
(*L)=evenhead;
return oddhead;
}
3.本题调试过程碰到问题及解决办法
错误信息1：
错误原因：这个错误点主要是因为对新建链表的知识点还不是很懂。
在子函数getodd中新建奇数链表的时候直接将原单链表赋值给了新链表,间接改变了原链表,还使原链表结点中指针指向了空,使以后的结点都断了。
改正方法：新建动态结点odd,重新分别把原结点的值赋给新结点odd的值,然后新结点odd的值赋给新奇数链表。
错误信息2：
错误原因：找不出原因。
改正方法：具体做法请查阅算法和实验代码。本题老师课上讲述的时候是说不能用删除的方法做,一开始的时候就是使用的是删除的方法,我觉得这题还有解决的方法,就是还没找到。代码修改后总是有一些小问题解决不了,具体的不清楚是什么原因。还请老师指点。
提交列表：
题目6-2 学生成绩列表处理
1.设计思路
(1)算法
第一步：定义链表的头指针head为空。
第二步：利用for循环输入数据,若输入的num为0则跳出循环,跳到第五步,否则下一步
第三步：将满足条件的数据输入存入动态结点i中,若头指针为空则头指针head指向动态结点,否则尾指针tail中的next指向动态结点。
第四步：尾指针tail始终指向动态结点,跳到第二步。
第五步：返回头指针head。
第一步：定义前面的指针front为头指针。
第二步：利用for循环遍历链表。
第三步：若循环指针i指向空,则跳出循环,跳到第六步,否则下一步。
第四步：若链表中某一个结点中的score小于传入的参数min_score则删除这个结点,若是头结点则头指针指向第二个结点,释放这个结点的动态内存,此时的循环变量i指向前面的指针front,否则下一步。
第五步：表示前面的指针front指向此时的结点,跳到第三步。
第六步：返回头指针head。
(2)流程图
略
2.实验代码
#include <stdio.h>
#include <stdlib.h>
struct stud_node
{
int num;
char name[20];
int score;
struct stud_node *next;
};
struct stud_node *createlist();
struct stud_node *deletelist( struct stud_node *head, int min_score );
int main()
{
int min_score;
struct stud_node *p,*head=NULL;
head=createlist();
scanf("%d",&min_score);
head=deletelist(head, min_score);
for( p = head; p != NULL; p = p->next )
printf("%d %s %d
", p->num, p->name, p->score);
return 0;
}
struct stud_node *createlist()
{
struct stud_node *head=NULL;
for(struct stud_node *i=NULL,*tail=NULL;;tail=i,i=i->next)
{
i=(struct stud_node *)malloc(sizeof(struct stud_node));
scanf("%d",&i->num);
if(i->num==0)
break;
scanf("%s %d",i->name,&i->score);
i->next=NULL;
if(head)
tail->next=i;
else
head=i;
}
return head;
}
struct stud_node *deletelist(struct stud_node *head,int min_score)
{
for(struct stud_node *i=head,*front=head;i!=NULL;i=i->next)
{
if(i->score<min_score)
{
if(i==head)
head=i->next;
else
front->next=i->next;
free(i);
i=front;
}
front=i;
}
return head;
}
3.本题调试过程碰到问题及解决办法
错误信息1：
错误原因：不重要的错误：略。
for循环中第二个判断条件错误,条件head始终为1,致使不会进行else中的语句。
改正方法：判断条件应该更正为循环变量i是否为头指针,再执行相关的语句。
错误信息2：
错误原因：释放掉变量i中的动态空间之后,前一个结点指针front就没有可以指向的结点了,使front的指向产生盲点。
改正方法：在释放i后将i指向原先的front,使此时的i为删除结点之前的结点,不会使front的指向不清楚,这样就可以直接判断删除结点的下一个结点。
提交列表：
题目6-3 链表拼接
1.设计思路
(1)算法
第一步：利用两个for循环,外循环控制list2,内循环控制list1。
第二步：按照升序将链表list2中的结点插入到链表list1中去,释放list2链表的内存。
第三步：返回头指针list1。
(2)流程图
略
2.实验代码
#include <stdio.h>
#include <stdlib.h>
struct ListNode
{
int data;
struct ListNode *next;
};
struct ListNode *createlist(); /*裁判实现，细节不表*/
struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);
void printlist( struct ListNode *head )
{
struct ListNode *p = head;
while (p)
{
printf("%d ", p->data);
p = p->next;
}
printf("
");
}
int main()
{
struct ListNode *list1, *list2;
list1 = createlist();
list2 = createlist();
list1 = mergelists(list1, list2);
printlist(list1);
return 0;
}
struct ListNode *mergelists(struct ListNode *list1,struct ListNode *list2)
{
for(struct ListNode *i=list2;i!=NULL;i=i->next)
for(struct ListNode *j=list1,*front=list1;j!=NULL;j=j->next)
{
if(i->data<=j->data)
{
struct ListNode *assignment=(struct ListNode *)malloc(sizeof(struct ListNode));
assignment->data=i->data;
assignment->next=NULL;
if(j==list1)
{
assignment->next=list1;
list1=assignment;
}
else
{
assignment->next=j;
front->next=assignment;
}
break;
}
else if(j->next==NULL)
{
struct ListNode *assignment=(struct ListNode *)malloc(sizeof(struct ListNode));
assignment->data=i->data;
assignment->next=NULL;
j->next=assignment;
break;
}
front=j;
}
free(list2);
return list1;
}
3.本题调试过程碰到问题及解决办法
错误信息1：
错误原因：for循环中直接将list2中小于等于list1中的结点赋给动态指针变量assignment,直接使assignment成为了头指针,意味着将从i开始之后的单向链表全部赋值给了assignment,改变了原来的固定的单向链表。没有考虑到list2中的数据大于list1中的所有数据的情况,输出链表时就不会输出大于list1的数据。
改正方法：将当时结点内的值赋给动态指针变量assignment,再让assignment中的指针指向空,就不会改变原来的单向链表了。判断一下list1链表循环到最后一个结点的时候的情况,这种情况说明此时list2中的这个结点的数据大于list1中所有结点中的数据,使list1中最后一个结点的指针指向具有list2数据的此时动态指针变量assignment。
错误信息2：
错误原因：在判断循环变量j是否等于头指针list1时,判断为真的第一个语句中的赋值错误,将第二个结点赋给了变量assignment中的指针,跳过了头结点,相当于删除了第一个结点。
改正方法：让assignment中的指针指向第一个结点,并且头指针指向assignment。
提交列表：
学习总结和进度
总结知识点和错误：
（1）如何理解指针数组，它与指针、数组有何关系？为何可以用二级指针对指针数组进行操作？
指针数组中的数组名是一个二级指针,整个数组是一级指针,它是由数组构成的一个指针,指向多个值,这种指针可以用来存放数组和指针。因为初始定义一个数组为指针,是这个数组中存放指针,并且数组的数组名本身就是一个指针,这样数组中的值是数据的地址,数组名形成的二级指针指向的是存放地址的一级指针的地址。
（2）将C高级第三次PTA作业（1）任何一个题目改为使用二级指针对指针数组进行操作。
在前面的代码中已经实现了。
（3）用指针数组处理多个字符串有何优势？可以直接输入多个字符串给未初始化的指针数组吗？为什么？
借用了一下书上的话：更加方便灵活地处理多个字符串,节省内存单元,字符串的长度可以随意长,移动指针比移动字符串节省时间。
不能,因为指针数组中的字符串是存在代码区的,代码区的字符串是不能更改的,只能在源代码中更改,若要输入,只能使用二维的字符数组,存在数据区。
GitHub地址：
评论博客地址：
学习进度表格和折线图
| 日期 | 代码时间 | 代码行数 | 博客时间 | 博客行数 |
|---|---|---|---|---|
| 4月9日 | 0 | 0 | 0 | 0 |
| 4月10日 | 86 | 7 | 23 | 150 |
| 4月11日 | 15 | 6 | 250 | 20 |
| 4月12日 | 50 | 6 | 45 | 239 |
| 4月13日 | 0 | 0 | 0 | 0 |
| 4月14日 | 42 | 22 | 0 | 0 |
| 4月15日 | 101 | 0 | 0 | 0 |
| 4月16日 | 0 | 0 | 0 | 0 |
| 4月17日 | 0 | 0 | 0 | 0 |
| 4月18日 | 0 | 0 | 0 | 0 |
| 4月19日 | 0 | 0 | 0 | 0 |
| 4月20日 | 0 | 0 | 0 | 0 |
| 4月21日 | 0 | 0 | 0 | 0 |
| 4月22日 | 0 | 0 | 0 | 0 |
| 4月23日 | 0 | 0 | 0 | 0 |
 |