阅读下列函数说明和C++代码，回答问题
[说明]
任何一种程序都是为了解决问题而撰写的，解决问题时需要实现一些特定的运算法则。在策略(Strategy)模式下，可以更换实现算法的部分而不留痕迹，切换整个算法，简化改为采用其他方法来解决同样问题。
以下是一个“剪刀石头布”游戏。猜拳时的“策略”有2种方法：第一种是“猜赢后继续出同样的招式”(WinningStrategy)，第二种是“从上一次出的招式中，以概率分配方式求出下一个招式的几率”(ProbStrategy)。程序中定义了Hand类表示猜拳时的“手势”，类内部以0(石头)、1(剪刀)、2(布)来表示。Hand类的实例只会产生3个。以下是C++语言实现，能够正确编译通过。
[C++代码]
class Hand{
private:
int handvalue;
static Hand *hand0;
static Hand *hand1;
static Hand *hand2;
(1) ;
Hand(int handvalue){
this->handvalue = handvalue;
}
public:
(2) Hand* getHand(int handvalue){
/*省略具体实现*/
}
};
Hand *Hand::hand0 = new Hand(0);
Hand *Hand::hand1 = new Hand(1);
Hand *Hand::hand2 = new Hand(2);
class Strategy{
public:
(3) Hand* nextHand() = 0;
};
class WinningStrategy : public Strategy{
private:
bool won;
Hand *prevHand;
public:
winningStrategy(){
won = false;
}
Hand* nextHand(){
if(!won){
prevHand = Hand::getHand(rand()%3);
}
return prevHand;
}
};
class probstrategy : public Strategy{
public:
Hand* nextHand(){
int handvalue = 0;
/*省略具体实现*/
return Hand::getHand(handvalue);
}
};
class Player{
private:
string name;
Strategy* strategy;
public:
Player(string name, (4) strategy){
this->name = name;
this->strategy = strategy;
}
Hand *nextHand()(//向战略请示手势
return (5) ;
}
};
-
阅读以下说明和Java代码，回答问题
[说明]
任何一种程序都是为了解决问题而撰写的，解决问题时需要实现一些特定的运算法则。在策略(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) ;
}
}
-
阅读以下函数说明和C代码，回答问题
[说明]
任何一种程序都是为了解决问题而撰写的，解决问题时需要实现一些特定的运算法则。在策略(Strategy)模式下，可以更换实现算法的部分而不留痕迹，切换整个算法，简化改为采用其他方法来解决同样问题。
以下是一个“剪刀石头布”游戏。猜拳时的“策略”有2种方法：第一种是“猜赢后继续出同样的招式”(WinningStrategy)，第二种是“从上一次出的招式种，以概率分配方式求出下一个招式的几率”(ProbStrategy)。程序中定义了Hand类表示猜拳时的“手势”，类内部以0(石头)、1(剪刀)、2(布)来表示。Hand类的实例只会产生3个。
以下是C语言实现，省略了不相关属性及方法，方法实现体亦有所省略，能够正确编译通过。
[C代码]
typedef (1) (*funl)();
enum HandValue{HANDVALUE_GUU=0, HANDVALUE_CHO=1, HANDVALUE_PAA=2};
//手势可取值，依次为“石头”、“剪刀”、“布”
//其大小顺序是循环相克的，即：石头赢剪刀，剪刀赢布，布赢石头
bool won;
struct Hand *WSprevHand;
struct Hand{//手势
enum HandValue handvalue;
}hand[3]={HANDVALUE_GUU, HANDVALUE_CHO, HANDVALUE_PAA};
int fight(struct Hand *h1, struct Hand *h2)
//比较h1和h2。h1代表的手势较大时返回1，h1较小时返回-1，相等时返回0
//
{
if(h1->handvalue == h2->handvalue){
return 0;
}else if((h1->handvalue+1)% (2) == h2>handvalue){
return 1;
}else{
return -1;
}
}
struct Hand* getHand(int handvalue){
//依据手势代表的值取得手势，若handvalue不合法，返回NULL
switch(handvalue){
case 0:
return &hand[0];
break;
case 1:
return &hand[1];
bteak;
case 2;
return &hand[2];
break;
}
return (3) ;
}
struct Strategy{//策略
funl nextHand;//下一个手势
};
struct Hand* WSnextHand()
{
if(!won){
PSprevHand = getHand(rand()%3);
}
return PSprevHand;
}
struct Player{
char name[20];
(4) strategy;//策略
int wincount;
int losecount;
int gamecount;
};
void main()
{
Strategy WS;
WS.nextHand = WSnextHand;
WSpreVHand = NULL;
struct Player WSplayer;
(5)(WSplayer.name,"ww");
WSplayer.wincount = 0;
WSplayer.losecount = 0;
WSplayer.gamecount = 0;
WSplayer.strategy = &WS;
}
-
阅读下列函数说明、图和C代码，回答问题
[说明]
在进行文法分析的时候，通常需要检测一个单词是否在我们的单词列表里。为了提高查找和定位的速度，通常都要画出与单词列表所对应的单词查找树。
程序构造一棵二叉排序树，每个节点存储一个单词，按字典序列，较小的在左子树，较大的在右子树。
函数中使用的预定义符号如下：
typedef struct TreeNode{/*二叉排序树节点*/
char *word;
struct TreeNode *left, *right;
}BNODE;
[函数]
int getWord(FILE *fpt, char *word)
/*从文件fpt中读取单词到word中，到达文件结束时返回0*/
{
char c;
c = fgetc(fpt);
if(c == EOF)return 0;
/*跳过单词间的非字母字符*/
while(!(tolower(c) >= 'a' && tolower(c)<= 'z')){
c = fgetc(fpt);
if(c == EOF)return 0;
}
/*不区分大小写*/
while(tolower(c) >= 'a' && tolower(c)<= 'z'){
*word++ = c;
c = fqetc(fpt);
}
*word = '\0';
return 1;
}
void BTree(BNODE **t, char *word)
{
BNODE *ptr, *p;
int compres;
p = NITLL;
(1) ;
while(ptr){
compres = strcmp(word, (2) );
if(!compres){
return;
}else{
(3) ;
ptr = compres >0 ? ptr->right : ptr->left;
}
}
ptr = (BNODE*)malloc(sizeof ptr);
ptr->left = ptr->right = NULL;
ptr->word = (char*)malloc(strlen(word) + 1);
strcpy(ptr->word, word);
if(p == NULL){
(4) ;
}else if(compres >0){
p->right = ptr;
}else{
p->left = ptr;
}
}
int main()
{
FILE *fpt;
char word[40];
BNODE *root = NULL;
if((fpt = fopen("text.in", "r")) == NULL){
printf("不能打开文件text.in! \n");
return 1;
}
while(getWord(fpt, word) == 1){
BTree (5) ;
}
fclose(fpt);
return 0;
}
-
阅读下列函数说明和C++代码，回答问题
[说明]
任何一种程序都是为了解决问题而撰写的，解决问题时需要实现一些特定的运算法则。在策略(Strategy)模式下，可以更换实现算法的部分而不留痕迹，切换整个算法，简化改为采用其他方法来解决同样问题。
以下是一个“剪刀石头布”游戏。猜拳时的“策略”有2种方法：第一种是“猜赢后继续出同样的招式”(WinningStrategy)，第二种是“从上一次出的招式中，以概率分配方式求出下一个招式的几率”(ProbStrategy)。程序中定义了Hand类表示猜拳时的“手势”，类内部以0(石头)、1(剪刀)、2(布)来表示。Hand类的实例只会产生3个。以下是C++语言实现，能够正确编译通过。
[C++代码]
class Hand{
private:
int handvalue;
static Hand *hand0;
static Hand *hand1;
static Hand *hand2;
(1) ;
Hand(int handvalue){
this->handvalue = handvalue;
}
public:
(2) Hand* getHand(int handvalue){
/*省略具体实现*/
}
};
Hand *Hand::hand0 = new Hand(0);
Hand *Hand::hand1 = new Hand(1);
Hand *Hand::hand2 = new Hand(2);
class Strategy{
public:
(3) Hand* nextHand() = 0;
};
class WinningStrategy : public Strategy{
private:
bool won;
Hand *prevHand;
public:
winningStrategy(){
won = false;
}
Hand* nextHand(){
if(!won){
prevHand = Hand::getHand(rand()%3);
}
return prevHand;
}
};
class probstrategy : public Strategy{
public:
Hand* nextHand(){
int handvalue = 0;
/*省略具体实现*/
return Hand::getHand(handvalue);
}
};
class Player{
private:
string name;
Strategy* strategy;
public:
Player(string name, (4) strategy){
this->name = name;
this->strategy = strategy;
}
Hand *nextHand()(//向战略请示手势
return (5) ;
}
};
-
请在下列SQL查询语句空缺处填入正确的内容
(1)查询身份证号为“123456”的人作为驾驶员时所有的事故记录。
SELECT * FROM事故 WHERE (1)
(2)查询身份证号为“123456”的车主所拥有的汽车的事故记录。
SELECT * FROM事故 WHERE 车牌号 (2)
(SELECT车牌号 FROM (3) WHERE身份证号 = "123456")
(3)查询车牌号为“123456”汽车在车主是驾驶员时的事故记录。
SELECT * FROM 事故 WHERE (4)
(SELECT * FROM (5) WHERE 车牌号 = "123456"
AND (6) )
-
阅读下列函数说明、图和C代码，回答问题
[说明]
假定用一个整型数组表示一个长整数，数组的每个元素存储长整数的一位数字，则实际的长整数m表示为：
m=a[k]×10k-2+a[k-1]×10k-3+…+a[3]×10+a[2]
其中a[1]保存该长整数的位数，a[0]保存该长整数的符号：0表示正数、1表示负数。
运算时先决定符号，再进行绝对值运算。对于绝对值相减情况，总是绝对值较大的减去绝对值较小的，以避免出现不够减情况。注意，不考虑溢出情况，即数组足够大。
[函数]
int cmp(int *LA, int *LB);
/*比较长整数LA与LB的绝对值大小*/
/*若LA绝对值较大返回正值，LA较小返回负值，相等则返回0*/
int ADD (int *LA, int *LB, int *LC)
/*计算长整数LA与LB的和，结果存储于LC中*/
/*注意：正数与负数的和相当于正数与负数绝对值的差*/
/*数据有误返回0，正常返回1*/
{
if(LA == NULL || LB == NULL || LC == NULL)return 0;
int *pA, *pB, i, N, carry, flag;
flag = LA[0] + LB[0];
switch(flag){ /*根据参与运算的两个数的符号进行不同的操作*/
case 0:
case 2:
Lc[0] = LA[0];/*LA与LB同号，结果符号与LA(LB)相同*/
pA = LA;
pB = LB;
(1) ;
break;
case 1: /*LA与LB异号*/
/*比较两者的绝对值大小，结果符号与较大者相同*/
flag = (2) ;
if(flag >0){ /*LA较大*/
LC[0] = LA[0];
pA = LA;
pB = LB;
}
else if(flag< 0)(/*LB较大*/
LC[0] = LB[0];
pA = LB;
pB = LA;
}
else{/*LA与LB相等*/
LC[0] = 0;
LC[1] = 0;
return 1;
}
flag = -1;
break;
default:
return 0;
break;
}/*switch*/
/*绝对值相加减*/
/*注意对于减法pA指向较大数，pB指向较小数，不可能出现不够减情况*/
(3) ;
N = LA[1] >LB[1] ? LA[1] : LB[1];
for(i = 0; i< N; i++){
if(i >= pA[1]){/*LA计算完毕*/
carry += flag * pB[i+2];
}
else if(i >= pB[1]){/*LB计算完毕*/
carry += pA[i+2];
}
else{
carry += pA[i+2] + flag * pB[i+2];
}
LC[i+2] = carry % 10;
carry /= 10;
if( (4) ){/*需要借位，针对减法*/
LC[i+2] += 10;
carry--;
}
}/*for*/
if( (5) ){/*最高进位，针对加法*/
LC[i+2] = carry;
i++;
}
if(LC[i+1] == 0) i--; /*若最高位为零，针对减法*/
LC[1] = i;
return 1;
};/*ADD*/
-
创建人表时，“身份证号”使用INTEGER数据类型，并且要求此列值不能为空、值惟一，姓名列不能为空。请在下列用于创建表人的SQL语句空缺处填入正确的内容。
CREATE TABLE 人 (身份证号 INTEGER,
姓名CHAR(20) (1) ,
性别CHAR(1),
年龄INTEGER,
地址CHAR(20),
(2) )
-
指出每种关系模式的主键。
-
根据题意，指出图1-1中缺失的用例。
-
根据题意，给出“电影”类的主要属性。
高级经济师考试试题精选练习（1）
高级经济师考试模拟练习题之单选题（1
高级经济师考试试题精选练习（2）
高级经济师考试试题精选练习（3）
高级经济师考试试题：经济法案例试题精
高级经济师考试模拟试题及答案
高级经济师考试试题及答案：单选练习题
高级经济师考试试题：经济法案例试题精
高级经济师考试模拟题及答案练习(1)
高级经济师考试模拟题及答案练习(2)