阅读以下说明和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) ;

 }

 }

阅读以下说明和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中缺失的用例。

根据题意，给出“电影”类的主要属性。