1.  请补充函数fun()，该函数的功能是：只保留字符串中的大写字母，删除其他字符，结果仍保存在原来的字符串中，由全局变量m对删除后字符串的长度进行保存。
    注意：部分源程序给出如下。
    请勿改动主函数main和其他函数中的任何内容，仅在函数fun()的横线上填入所编写的若干表达式或语句。
    试题程序：
    #include＜stdio.h＞
    #include＜conio.h＞
    int m；
    void fun(char*s)
    {
      int i=0，j=0；
      char *p=s；
      while(*(p+i))
      {
        if(*(p+i)＞='A'&&*(p+i)＜='Z')
        {
          （1）  ；
        }
          （2）  ；
        }
        s[j]='\0'；
          （3）  ；
    }
    main()
    {
      char str[80]；
      clrscr()；
      printf("\nEnter a string：")；
      gets(str)；
      printf("\n\nThe string is:\%s\n"，str)；
      fun(str)；
      printf("\n\nThe string of changing is: \%s\n"，str)；
      printf("\n\nThe length of changed strtng is:\%d\n"，m)；
    }

1.  阅读以下说明和Java代码，将应填入  （n）  处的字句写在对应栏内。
    【说明】
    任何一种程序都是为了解决问题而撰写的，解决问题时需要实现一些特定的运算法则。在策略(Strategy)模式下，可以更换实现算法的部分而不留痕迹，切换整个算法，简化改为采用其他方法来解决同样问题。
    以下是一个“剪刀石头布”游戏。猜拳时的“策略”有2种方法：第一种是“猜赢后继续出同样的招式”(WinningStrategy)，第二种是“从上一次出的招式种，以概率分配方式求出下一个招式的几率”(ProbStrategy)。程序中定义了Hand类表示猜拳时的“手势”，类内部以0(石头)、1(剪刀)、2(布)来表示。Hand类的实例只会产生3个。
    以下是Java语言实现，省略了不相关属性及方法，方法实现体亦有所省略，能够正确编译通过。
    【Java代码】
    //Hand.java文件
    public class Hand{
    public static final int HANDVALUE_GUU=0; //石头
    public static final int HANDVALUE_CHO=1; //剪刀
    public static final int HANDVALUE_PAA=2; //布
    public static final Hand[] hand={
    new Hand (HANDVALUE_GUU),
    new Hand (HANDVALUE_CHO),
    new Hand (HANDVALUE_PAA),
    };
    private int handvalue;
      （1）  Hand (int handvalue){
    this.handvalue=handvalue;
    }
    public   （2）  Hand getHand(int handvalue) {//从值取得对象实例
    return    hand [handvalue];
    }
    }
    //Strategy.java文件
    public interface Strategy {
    public   （3）  Hand nextHand();
    }
    //ProbStrategy.java文件
    import java.util.Random;
    public class ProbStrategy implements Strategy {
    public Hand nextHand (){
    int handvalue=0;
    /*省略具体实现*/
    return Hand.getHand (handvalue);
    }
    }
    //WinningStrategy.java文件
    import java.util.Random;
    public class WinningStrategy implements Strategy{
    /*省略了不相关属性*/
    public Hand nextHand(){
    if(!won){
    prevHand=Hand.getHand(random.nextInt(3));
    }
    return prevHand;
    }
    }
    //Player.java文件
    public class Player{
    private String name;
    private Strategy strategy;
    public Player(String name,   （4）  strategy){
    this.name=name;
    this.strategy=strategy;
    }
    public Hand nextHand(){//向战略请示手势
    return   （5）  ;
    }
    }

1.  阅读以下说明和C代码，将应填入  （n）  处的字句写在对应栏内。
    【说明】
    下面程序用来将打乱的单词还原为原来的次序，比如将rty还原为try。单词的原来次序存储于wordlist.txt文件中，原则上可用穷举法(rty对应的穷举为：rty、ryt、try、tyr、ytr、yrt)，但考虑到破译速度，采用如下方法：
    注意到单词列表中不存在组成字符完全相同的单词(如Hack12与Hack21包含完全相同的字符)，因此将单词中的字符进行重组再进行比较，例如，try单词重组为rty(按ASCII码顺序)，这样不管打乱的单词是什么顺序，只要是由r、t、y三个字母组成的均破译为try，大大提高破译速度。程序中借助二叉排序树以进一步提高查找效率，二叉排序树左子树(如果有)上的节点对应的值均小于根节点的值，右子树(如果有)上的节点对应的值均大于根节点的值。
    函数中使用的符号定义如下：
    #define NumberofWords 1275 //单词总数
    #define MaxLength 10 //最长单词所含字符数
    char WordList [NumberofWords] [MaxLength];//存储单词列表
    int cmp(Node *q,Node *p);//q与p比较。p小,返回负值:p大返回正值;相等,返回0
    typedef struct Node{//二叉树节点
    char *eleLetters;//重组后的字符串
    int index;//对应单词表中的下标
    struct Node *lChild, *rChild;//左右子节点
    }Node;
    【C代码】
    void reCompose(Node *p, char *temp)
    //重组，亦即将temp字符串中的字符升序排序，存储于p节点中
    //采用直接插入排序法
    {
    char c;
    strcpy(p-＞eleLetters, temp);//
    int len=strlen(temp);
    int i, j, k;
    for(i=0; i＜len-1; i++){
    k=i;
    for(j=i+1; j＜len; j++){
    if(p-＞eleLetters[j] ＜p-＞eleLetters[k])k=j;
    }
    if{  （1）  ){
    c=p-＞eleLetters[i];
    p-＞eleLetters[i]=p-＞eleLetters[k];
    p-＞eleLetters[k]=c;
    }//if
    }//for
    };
    int find(Node &root, char *temp)
    / /在二叉排序树root中查找与temp匹配的单词。
    //若匹配返回相应单词在WordList中下标;若查找失败, 返回-1
    {
    Node *p, *q;
    int flag;
    p=  （2）  ;//临时存储
    reCompose(p, temp); //将temp重组
    q=&root;
    while((flag=(3)) &&q!=NULL){
    if(flag＜0) {//搜索左子树
    q=q-＞IChild;
    }else {//搜素右子树
    q=q-＞rChild;
    }
    }//while
    if(flag==0){//找到匹配的, 保存下标
    return   （4）  ;
    }
    if(  （5）  ){//查找失败
    printf("cant unscramble the following word:%s", temp);;
    return-1;
    }
    };

1.  阅读以下函数说明和C代码，将应填入  （n）  处的字句写在对应栏内。
    【说明】
    在某些系统中，存在非常复杂的对象，可以采用循序渐进的方式，进行组合将小对象组合成复杂的对象。
    以下实例展示了Builder(生成器)模式。该实例用来建立“文件”，文件内容包括：一个标题、一串字符以及一些有项目符号的项目。Builder类规定组成文件的方法，Director类利用这个方法产生一份具体的文件。下图显示了各个类间的关系。
   
    以下是C语言实现，能够正确编译通过。
    【C代码】
    typedef void(  （1）  )(char *title);
    typedef void (*fun2)(char items[][10], int N);
    typedef char* (*fun3)();
    char buffer [500];
    struct Builder{//构造器
    fun1 makeTitle;
      （2）  makeString;
    fun2 makeItems;
    fun3 getResult;
    };
    struct Director {
    struct Builder builder;
    };
    cbar* consrruct(  （3）  director)//构造文件
    {
    char items [2][10]={"早安","午安"};
    director-＞builder.makeTitle("Greeting");
    director-＞builder.makestring("从早上到白天结束");
    director-＞builder.makeItems (items,2);
    director-＞builder.makeString("到了晚上");
    strcpy(items[0],"晚安");
    strcpy(items [1],"好梦");
    director-＞builder.makeItems (items,2);
    return director-＞builder.getResult();
    }
    void TXTmakeTitle (char* title)
    {
    [＜img src="tu/1803/j/sp/zj/swrs78.41253F.jpg" /＞]
    strcat (buffer, title);
    strcat (buffer, "[＜img src="tu/1803/j/sp/zj/swrs78.4164A9.jpg" /＞]\n\n");
    }
    void TXTmakeString (char* str)
    {
    strcat (buffer, "■");
    strcat (buffer, str);
    strcat (buffer,"\n\n");
    }
    void TXTmakeItems(char items[][10],int N)//将items加入文件中
    {
    for(int i=0;i＜N;i++){
    strcat (buffer, ".");
    strcat(buffer,   （4）  );
    strcat (buffer, "\n");
    }
    strcat (buffer, "\n");
    }
    char* TXTgetResult()
    {
    return buffer;
    }
    void main()
    {
    Director director;
      （5）  ='\0';//清空缓冲区,使目前缓冲区中的内容不影响新生成的文件
    director.builder.makeTitle=TXTmakeTitle;
    director.builder.makeString=TXTmakeTitle;
    director.builder.makeItems=TXTmakeItems;
    director.builder.getResult=TXTgetResult;
    char* result=construct (&director);
    printf("%s\n", result);
    }

1.  阅读以下说明和Java代码，将应填入  （n）  处的字句写在相应处。
    【说明】
    对多个元素的聚合进行遍历访问时，需要依次推移元素，例如对数组通过递增下标的方式，数组下标功能抽象化、一般化的结果就称为迭代器(Iterator)。模式以下程序模拟将书籍(Book)放到书架(BookShelf)上并依次输出书名。这样就要涉及到遍历整个书架的过程。使用迭代器Iterator实现。下图显示了各个类间的关系。以下是JAVA语言实现，能够正确编译通过。
   
    【Java代码】
    //Iterator.java文件
    public interface Iterator {
    public abstract boolean hasNext ();
    public abstract Object next ();
    }
    //Aggregate.java文件
    public interface Aggregate {
    public abstract Iterator iterator ();
    }
    //Book.java
    public class Book {
    //省略具体方法和属性
    }
    //BookShelfIterator.java文件
    public class BookShelfIterator   （1）  Iterator{
    private BookShelf bookShelf;
    private int index;
    public BookShelfIterator(BookShelf bookShelf) {
    this.bookShelf=bookShelf;
    this.index=0;
    }
    public boolean hasNext () {//判断是否还有下一个素
    if (index ＜ bookShelf.getLength ()) {
    return true;
    } else {
    return false;
    }
    public Object nexr () (//取得下一个元素
    Book book=bookShelf.getBookAt (index);
    index++;
    return book;
    }
    }
    //BookShelf.java
    import java.util.Vector;
    public class BookShelf {
    private Vector books;
    public BookShelf (int initialsize) {
    this.books=new Vector (initialsize);
    }
    public Book getBookAt (int index) {
    return (Book) books.get (index);
    }
    public int getLength () {
    return books.size ();
    }
    public Iterator iterator () {
    return new BookShelfIterator (  （2）  );
    }
    //Main.java文件
    public class Main {
    public static void main (String [] args) {
    BookShelf bookShelf=new    BookShelf(4);
    //将书籍上架,省略代码
    Iterator it=bookShelf.   （3）  ;
    while(  （4）  )(//遍历书架,输出书名
    Book book=(Book)it.  （5）  ;
    System.out.println (""+book.getName());
    }
    }
    }