首页

软考 - 初级_程序员

类型:
选择方向:
选择考试:
题型:
为你找到 191 个题目。

阅读以下说明和Java代码,填补Java代码中的空缺(1)~(6),将解答写在答题纸的对应栏内。
【说明】
已知某公司按周给员工发放工资,其工资系统需记录每名员工的员工号、姓名、工资等信息。其中一些员工是正式的,按年薪分周发放(每年按52周计算);另一些员工是计时工,以小时工资为基准,按每周工作小时数核算发放。
下面是实现该工资系统的Java代码,其中定义了四个类:工资系统类PayRoll,员工类Employee,正式工类Salaried和计时工类Hourly,Salaried和Hourly是Employee的子类。

【Java代码】
abstract class Employee  {
   protected String name;    //员工姓名
   protected int empCode;    //员工号
   protected double salary;    //周发放工资
   public Employee(int empCode, String name)  {
       this.empCode=empCode;
       this.name=name,
   }
   public double getSalary(){
       return this.salary;
   }
public abstract void pay() ;
}

class Salaried  (1)  Employee  {
   private double annualSalary;
   Salaried(int empCode, String name, double payRate) {
       super(empCode, name) ;
       this.annualSalary=payRate;
   }
   public void pay () {
       salary= (2) ;    //计算正式员工的周发放工资数
       System.out.println(this.name+":"+this.salary);
   }
}

class Hourly  (3)  Employee  {
   private double hourlyPayRate;
   private int hours;
   Hourly(int empCode, String name, int hours, double payRate) {
       super(empCode, name);
       this.hourlyPayRate=payRate;
       this.hours=hours;
   }
   public void pay () {
       salary= (4) ;    //计算计时工的周发放工资数
       System.out.println(thisname+":"+this.salary);
   }
}

public class PayRoll  {
   private  (5)  employees[]={
       new  Salaried(1001, "Zhang San", 58000.00),
//此处省略对其他职工对象的生成
       new Hourly(1005, "Li", 12, 50.00)
   };
   public void pay(Employee e[])  {
       for (int i=0; i            e[i]pay();
       }
   }
   public static void main(String[] args)
   {
       PayRoll payRoll=new PayRoll();
       payRoll.pay( (6) );
       double total=0.0;
       for (int i=0;i               total+=payRoll.employees[i].getSalary();
       }
System.out.println(total);
   }
}

阅读以下说明和C函数,填补C函数中的空缺(1)~(5),将解答写在答题纸的对应栏内。
【说明】
函数SetDiff(LA,LB)的功能是将LA与LB中的共有元素从LA中删除,使得LA中仅保留与LB不同的元素,而LB不变,LA和LB为含头结点的单链表的头指针。
例如,单链表LA、LB的示例如下图中的(a)、(b)所示,删除与LB共有的元素后的LA如下图中的(c)所示。

 
链表的结点类型定义如下:
   typedef struct Node {
       int data;
       struct Node *next;
   }Node, *LinkList;
函数SetDiff(LinkList LA, LinkList LB)的处理思路如下:
(1)从LA的第一个元素结点开始,令LA的第一个元素为当前元素。
(2)在LB中进行顺序查找,查找与LA的当前元素相同者,方法是令LA的当前元素先与LB的第一个元素进行比较,若相等,则结束在LB中的查找过程,否则继续与LB的下一个元素比较,重复以上过程,直到LB中的某一个元素与LA的当前元素相等(表明查找成功),或者到达LB的表尾(表明查找失败)为止。
(3)结束在LB表的一次查找后,若在LB中发现了与LA的当前元素相同者,则删除LA的当前元素,否则保留LA的当前元素。
(4)取LA的下一个元素为当前元素,重复(2)、(3),直到LA的表尾。

【C函数】
       void SetDiff (LinkList LA, LinkList LB)
       {
       LinkList pre, pa, pb;
       /* pa用于指向单链表LA的当前元素结点,pre指向pa所指元素的前驱 */
       /* pb用于指向单链表LB的元素结点 */
        (1) ;  /* 开始时令pa指向LA的第一个元素 */
       pre=LA;
       while (pa)  {
            pb=LB->next;
       /* 在LB中查找与LA的当前元素相同者,直到找到或者到达表尾 */
          while( (2) )  {
              if (pa->data==pb->data)
                 break;
                (3) ;
          }
         
          if (!pb)  {
          /* 若在LB中没有找到与LA中当前元素相同者,则继续考察LA的后续元素 */
                 pre=pa;
                 pa=pa->next;
             }
             else{
          /* 若在LB中找到与LA的当前元素相同者,则删除LA的当前元素 */
                 pre->next= (4) ;
                 free (pa);
                 pa= (5) ;
          }
}
}

阅读以下说明和C函数,填补C函数中的空缺(1)~(6),将解答写在答题纸的对应栏内。
【说明】
函数numberOfwords(char message[])的功能是计算存储在message字符数组中的一段英文语句中的单词数目,输出每个单词(单词长度超过20时仅输出其前20个字母),并计算每个英文字母出现的次数(即频数),字母计数时不区分大小写。
假设英文语句中的单词合乎规范(此处不考虑单词的正确性),单词不缩写或省略,即不会出现类似don't形式的词,单词之后都为空格或标点符号。
函数中判定单词的规则是:
(1)一个英文字母串是单词;
(2)一个数字串是单词;
(3)表示名词所有格的撇号(')与对应的单词看作是一个单词。
除上述规则外,其他情况概不考虑。
例如,句子“The 1990's witnessed many changes in people's concepts of conservation.”中有10个单词,输出如下:
      The
      1990's
       witnessed
       many
       changes
       in
       people's
       concepts
       of
       conservation
函数numberOfwords中用到的部分标准库函数如下表所述。


【C函数】
       int numberOfwords (char message[])
       {
       char wordbuffer[21], i=0;    /* i用作wordbuffer的下标 */
                       (1)  pstr;
                      int ps[26]={0};    /* ps[0]用于表示字母'A'或'a'的频数 */
        /* ps[1]用于表示字母'B'或'b'的频数,依此类推 */
                      int wordcounter=0;
                     
                      pstr=message;
                      while (*pstr)  {
                               if( (2) (*pstr))  {/* 调用函数判定是否为一个单词的开头字符 */
                               i=0;
                               do{/* 将一个单词的字符逐个存入wordbuffer[],并进行字母计数 */
                                        wordbuffer[i++]=*pstr;
                                        if (isalpha (*pstr))  {
                                                  if( (3) (*pstr)) ps[*pstr-'a']++;
                                                  else  ps[*pstr-'A']++;
                                        }
                                         (4) ;    /* pstr指向下一字符 */
                               }while   (i<20 && (isalnum(*pstr)||*pstr=='\''));

if (i>=20)  /* 处理超长单词(含名词所有格形式) */
                while (isalnum (*pstr)||*pstr=='\'')  { pstr++; }
         
           (5) ='\0';    /* 设置暂存在wordbuffer中的单词结尾 */
wordcounter++;    /* 单词计数 */
                  puts (wordbuffer);    /* 输出单词 */
                  }
                    (6) ;    /* pstr指向下一字符 */
          }
          return wordcounter;
}

阅读以下说明、C程序代码和问题1至问题3,将解答写在答题纸的对应栏内。
【说明1】
设在某C系统中为每个字符型数据分配1个字节,为每个整型(int)数据分配4个字节,为每个指针分配4个字节,sizeof(x)用于计算为x分配的字节数。
【C代码】
     #include
     #include
     int main()
     {   int arr[5]={10, 20, 30};
     char mystr[]="JustAtest\n";
     char *ptr=mystr;

              printf("%d %d %d\n", sizeof(int), sizeof(unsigned int), sizeof(arr));
              printf("%d %d\n", sizeof(char), sizeof(mystr);
     printf("%d %d %d\n", sizeof(ptr), sizeof(*ptr), strlen(ptr));
     return 0;
     }
【说明2】
const是C语言的一个关键字,可以用来定义“只读”型变量。

【问题1】(8分)
    请写出以上C代码的运行结果。
【问题2】(4分)
    (1)请定义一个“只读”型的整型常量size,并将其值初始化为10;
    (2)请定义一个指向整型变量a的指针ptr,使得ptr的值不能修改,而ptr所指向的目标变量的值可以修改(即可以通过ptr间接修改整型变量a的值)。
    注:无需给出整型变量a的定义。
【问题3】(3分)
    某C程序文件中定义的函数f如下所示,请简要说明其中static的作用,以及形参表“const int arr[]”中const的作用。
static int f(const int arr[])
{
  /* 函数体内的语句省略 */
}

阅读以下说明和流程图,填补流程图中的空缺(1)~(5),将解答填入答题纸的对应栏内。
【说明】
已知数组A[1:n]中各个元素的值都是非零整数,其中有些元素的值是相同的(重复)。为删除其中重复的值,可先通过以下流程图找出所有的重复值,并对所有重复值赋0标记。该流程图采用了双重循环。
处理思路:如果数组A某个元素的值在前面曾出现过,则该元素赋标记值0。例如,假设数组A的各元素之值依次为2,5,5,1,2,5,3,则经过该流程图处理后,各元素之值依次为2,5,0,1,0,0,3。

【流程图】
阅读以下说明和 Java 程序,填充程序中的空缺,将解答填入答题纸的对应栏内。
【说明】
下面的程序用来计算并寻找平面坐标系中给定点中最近的点对(若存在多对,则输出其中的一对即可)。程序运行时,先输入点的个数和一组互异的点的坐标,通过计算每对点之间的距离,从而确定出距离最近的点对。例如,在图6-1所示的8个点中,点(1,1)与(2,0.5)是间距最近的点对。
【Java代码】
import java.util.Scanner;
class  GPoint 
{
private double  x ,y;
public void  setX(double  x)   {  this.x  =  x;   }
public void  setY(double  y)   {   this.y  =  y;  }
public double  getX( )   {  return  this.x;   }
public double  getY()   {  return  this.y;   }
}
class  FindNearestPoints   {
public static void main(String[]  args)  {
Scanner input = new Scanner(System.in);
System.out.print(" 输入点的个数: ");
int numberOfPoints = input.nextInt( );
(1)points  =  new  GPoint[numberOfPoints);       //创建保存点坐标
的数组
System.out.print("请输入" +   numberOfPoints    +    "个点的坐标: ");
for  (int i = 0;  i < points.length;  i++)   {
points [i] = (2);
points[i].setX(input.nextDouble( ));
points[i].setY(input.nextDouble( ));
}
FindNearestPoints   fnp  =  new  FindNearestPoints( );
int  p1  = 0 ,p2  = 1;     / / p1 和 p2 用于表示距离最近的点对在数组中的下标
double   shortestDistance= fnp.getDistance (points [p1],points[p2]);
 
//计算每一对点之间的距离
for  (int i = 0;  i < points.length;  i++)
{
for  (int  j  =  i +  1; j  <       (3); j++)
{
double tmpDistance = fnp.(4)
//计算两点间的距离
 
if ( (5))
{
p1=  i;
p2  = j;
shortestDistance  = tmpDistance;
                   }
            }
   }
   System.out.println(" 距离最近的点对是("   +
   points[p1].getX( ) + "," + points[p1].gety( ) + ")和(" +
   points[p2] .getX( ) + ", " + points[p2] .gety( ) + ")");
   }
 
   public double getDistance(GPoint pt1,GPoint pt2)
   {
          return Math. sqrt ((pt2.getX ( ) - pt1.getX ( )) *      (pt2.getX ( ) -pt1.getX ( ))
               + (pt2.gety( ) - pt1.getY( )) *  (pt2.getY( ) - pt1.getY( )));
    }
}
阅读以下说明和c++代码,填充代码中的空缺,将解答填入答题纸的对应栏内。
【说明】
下面的程序用来计算并寻找平面坐标系中给定点中最近的点对(若存在多对,则输出其中的一对即可)。程序运行时,先输入点的个数和一组互异的点的坐标,通过计算每对点之间的距离,从而确定出距离最近的点对。例如,在图 5-1 所示的8个点中,点(1,1) 与(2,0.5)是间距最近的点对。
【C++代码】
#include 
#include
using  namespace  std;
class  GPoint  {
private:
       double  x ,y;
public:
       void  setX(double  x)   {  this->x  =  x;   }
       void  setY(double  y)   {  this->y  =  y;  }
       double  getX()   {  return  this->x;   }
       double  getY()   {  return  this->y;   }
}
 
class ComputeDistance  {
public:
       double  distance(GPoint   a ,GPoint  b)    {
           return sqrt((a.getX() - b.getX())*(a .getX() - b.getX())
               + (a.getY() - b.getY())*(a.getY() - b.getY()));
       }
};
 
int main ()
{
       int i ,j ,numberOfPoints  =  0;
       cout << "输入点的个数:";
       cin  >>  numberOfpoints;
       (1)points = new GPoint[numberOfPoints]; //创建保存点坐标的数组
         memset(points ,0 ,sizeof(points));
         cout <<  "输入" <<   numberOfPoints<<  "个点的坐标 :";
         for  (i  =  0;  i <  numberOfPoints;   i++)  {
             double tmpx ,tmpy;
             cin>>tmpx>>tmpy;
             points[i]  .setX(tmpx);
             points[i]  .setY(tmpy);
      }
      (2)computeDistance = new ComputeDistance();
      int p1 = 0 ,p2=1; //p1 和 p2 用于表示距离最近的点对在数组中的下标
      double    shortestDistance    =    computeDistance->distance(points[p1] ,points[p2]);
      //计算每一对点之间的距离
      for (i = 0; i < numberOfPoints; i++)  {
      for (j = i+1; j  <(3); j++)   { 
            double tmpDistance = computeDistance->(4);
             if (       (5)   )      {
                p1 =  i; p2 =  j;
                shortestDistance  = tmpDistance;
            }
       }
  }
  cout << "距离最近的点对是: (" ;
   cout << points[p1] .getX() << "," << points[pl] .gety()<<")和("  ;
  cout << points [p2].getX () << "," << points [p2].gety () << ")" << endl;
  delete computeDistance;
  return 0;
}
阅读以下说明和 C 函数,填充函数中的空缺,将解答填入答题纸的对应栏内。
【说明】
己知两个整数数组 A 和 B 中分别存放了长度为 m 和 n 的两个非递减有序序列,函数 Adjustment(A,B,m,n)的功能是合并两个非递减序列,并将序列的前m个整数存入A中,其余元素依序存入 B 中。
例如:

合并过程如下:从数组 A 的第一个元素开始处理。用数组 B 的最小元素 B[0]与数组 A  的当前元素比较,若 A 的元素较小,则继续考查 A 的下一个元素;否则,先将A的最大元素暂存入temp ,然后移动A中的元素挪出空闲单元并将 B[0]插入数组 A ,最后将暂存在temp 中的数据插入数组B的适当位置(保持 B的有序性)。如此重复,直到A中所有元素都不大于B中所有元素为止。【C 函数】
   void Adjustment(int  A[] ,int B[] ,int m ,int n)
   {     /*数组 A 有 m 个元素,数组 B 有 n 个元素*/
          int i ,k ,temp;
             
          for(i = 0;  i < m;  i++)
          {
            if  (A[i]  <= B[0])  continue;
 
            temp  =(1);           /*将 A 中的最大元素备份至 temp */
 
  /*从后往前依次考查 A 的元素,移动 A 的元素并将来自 B 的最小元素插入 A 中*/
            for(k = m-1;       (2);  k--)
            A[k] = A[k-1];
  A[i] =(3);
 
  /*将备份在 temp 的数据插入数组 B 的适当位置*/
            for(k  =  1;(4)&& k  < n;  k++)
               B[k-1] = B[k];
            B[k-1]  =(5);
     }
}
阅读以下说明和C函数,填充函数中的空缺,将解答填入答题纸的对应栏内。
【说明】
函数Insert_key(*root ,key)的功能是将键值 key 插入到*boot指向根结点的二叉查找树中(二叉查找树为空时 *root 为空指针)。若给定的二叉查找树中已经包含键值为 key 的结点,则不进行插入操作井返回 0;否则申请新结点、存入 key 的值并将新结点加入树中,返回1。
提示:
  • 二叉查找树又称为二叉排序树,它或者是一棵空树,或者是具有如下性质的二叉树:
  • 若它的左子树非空,则其左子树上所有结点的键值均小于根结点的键值;
  • 若它的右子树非空,则其右子树上所有结点的键值均大于根结点的键值;
  • 左、右子树本身就是二叉查找树。
设二叉查找树采用二叉链表存储结构,链表结点类型定义如下:
Typedef struct BiTnode{
int    key_value;                            /*结点的键值,为非负整数*/
Struct BiTnode*left,*right;                  /*结点的左、右子树指针*/
}BiTnode,*BSTree;【C 函数】
int   Insert_key   ( BSTree  *root ,int  key  )
{
     BiTnode  *father  =  NULL ,*p =  *root ,*s;

     while   ((1)&& key  != p->key_value   )    {            /*查找键值为key的结点*/
             father  =  p;
             if   (   key   < p->key_value)     p  =(2); /*进入左子树*/
             else           p =(3);                      /*进入右子树*/
     }
           
      if (p)   return  0;    /*二叉查找树中己存在键值为 key 的结点,无需再插入*/
 
      s = (BiTnode *)malloc ((4)); /*根据结点类型生成新结点*/
      if  (!s)  return  -1;
      s->key_value  =  key;     s->left  =  NULL;      s->right  =  NULL;
  
      if (   !father  )
        (5);   /*新结点作为二叉查找树的根结点*/
      else     /*新结点插入二叉查找树的适当位置*/
                    if   (   key  <  father->key_value)   father->left   =    s;
                    else father->right   =  s;
       return  1;
}
阅读以下说明和C函数,填充函数中的空缺,将解答填入答题纸的对应栏内。
【说明】
如果矩阵A中的元素A[i,j]满足条件: A[i,j]是第i行中值最小的元素,且又是第j列中值最大的元素,则称之为该矩阵的一个马鞍点。
一个矩阵可能存在多个马鞍点,也可能不存在马鞍点。下面的函数求解并输出一个矩阵中的所有马鞍点,最后返回该矩阵中马鞍点的个数。
【 C 函数】
int findSaddle(int a[] [N],int M)
{     /*  a 表示 M 行 N 列矩阵, N 是宏定义符号常量*/
      int row,column ,i,k;
      int minElem;
      int count = 0; /* count 用于记录矩阵中马鞍点的个数*/
 
       for ( row = 0; row < (1)     ; row++) {
             /* minElem 用于表示第 row 行的最小元素值,其初值设为该行第 o 列的元素值*/
            (2)
       for ( column = 1; column < (3)     ;  column++)
       if   (  minElem  > a[row] [column]   ){
               minElem  =  a[row] [column);
       }

for  (   k  =  0;  k  < N;   k++   )
    if   (   a [row] [k] ==minElem   )    {
         /*对第 row 行的每个最小元素,判断其是否为所在列的最大元素*/
         for  (i =  0;  i < M;  i++)
              if   (     (4)     > minElem  )   break;
 
         if   (i>=      (5)     )  {
              printf(" (%d ,%d):  %d\n" ,row ,k ,minElem);   /*输出马鞍点*/
              count++;
         }/*if*/
    }/*if*/
 
}/*for*/
 
return  count;
 
}/*findSaddle*/

上一页

第 10 页