开门人关门人c语言代码

以下是一个简单的开门人关门人的C语言代码示例：

#include <stdio.h>

int main() {
char input;
printf("请问是开门人还是关门人？（K 或 G）\n");
scanf("%c", &input);
if (input == 'K') {
printf("欢迎进入！\n");
} else if (input == 'G') {
printf("对不起，门已经关闭。\n");
} else {
printf("输入无效！\n");
}
return 0;
}

代码中使用了一个字符型变量input，用于接收用户输入的开门人还是关门人的信息。使用if和else if语句判断用户输入的信息，如果是K则输出欢迎进入，如果是G则输出门已经关闭，如果既不是K也不是G则输出输入无效。

相关问题

使用C语言，编写程序，查找当天实验室开门和关门的人。每天第一个到实验室的人负责开门，最后一个离开实验室的人负责关门。 实验室的考勤系统会记录每人的ID号、到达时间和离开时间。假设实验室有n（n<=20）人，每个人当天一定要离开实验室（即时间不会跨天）。

好的，这是一个关于实验室考勤的问题，我来帮您解答。对于这个问题，我们可以通过以下步骤来解决：

1. 定义一个结构体，存储每个人的ID号、到达时间和离开时间。

2. 读取输入数据，将每个人的考勤信息存储到结构体数组中。

3. 对结构体数组按照到达时间排序，查找第一个到达实验室的人，并记录其ID号。

4. 对结构体数组按照离开时间排序，查找最后一个离开实验室的人，并记录其ID号。

5. 输出开门和关门的人的ID号。

以下是一个C语言的实现代码，仅供参考：

#include <stdio.h>
#include <stdlib.h>

#define MAX_N 20

struct Record {
    int id;
    int arrive_time;
    int leave_time;
};

int cmp_arrive_time(const void *a, const void *b) {
    return ((struct Record *)a)->arrive_time - ((struct Record *)b)->arrive_time;
}

int cmp_leave_time(const void *a, const void *b) {
    return ((struct Record *)b)->leave_time - ((struct Record *)a)->leave_time;
}

int main() {
    int n;
    struct Record records[MAX_N];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d%d%d", &records[i].id, &records[i].arrive_time, &records[i].leave_time);
    }
    qsort(records, n, sizeof(struct Record), cmp_arrive_time);
    printf("开门的人是%d\n", records[0].id);
    qsort(records, n, sizeof(struct Record), cmp_leave_time);
    printf("关门的人是%d\n", records[0].id);
    return 0;
}

以上代码中，我们先定义了一个结构体 `Record`，用于存储每个人的考勤信息。然后，我们读入输入数据，并对结构体数组按照到达时间和离开时间分别排序，最后输出开门和关门的人的ID号。

用C语言编写电梯控制系统，包括开门关门控制系统和楼层检测系统，

好的，这是一个很有趣的问题。电梯控制系统是一个典型的实时控制系统，需要多任务处理能力和硬件设备接口编程经验。下面是一个简单的电梯控制系统的代码示例，包括开门关门控制系统和楼层检测系统。

#include <stdio.h>
#include <stdbool.h>
#include <time.h>

#define MAX_FLOORS 20

// 电梯状态
enum {
    ELEVATOR_STOPPED = 0,
    ELEVATOR_OPENING,
    ELEVATOR_OPENED,
    ELEVATOR_CLOSING,
    ELEVATOR_MOVING_UP,
    ELEVATOR_MOVING_DOWN
};

// 楼层状态
enum {
    FLOOR_UP = 1,
    FLOOR_DOWN = -1,
    FLOOR_NONE = 0
};

// 电梯状态结构体
typedef struct {
    int status;     // 当前状态
    int floor;      // 当前楼层
    bool doorsOpen; // 门是否打开
} Elevator;

// 楼层状态结构体
typedef struct {
    int status;     // 当前状态
    int direction;  // 上行或下行或不动
    bool buttonUp;  // 上行信号是否触发
    bool buttonDown;// 下行信号是否触发
} Floor;

// 初始化电梯状态
void initElevator(Elevator *elevator) {
    elevator->status = ELEVATOR_STOPPED;
    elevator->floor = 1;
    elevator->doorsOpen = false;
}

// 初始化楼层状态
void initFloor(Floor *floor) {
    floor->status = FLOOR_NONE;
    floor->direction = FLOOR_NONE;
    floor->buttonUp = false;
    floor->buttonDown = false;
}

// 电梯开门操作
void openDoors(Elevator *elevator) {
    printf("Opening doors...\n");
    elevator->doorsOpen = true;
}

// 电梯关门操作
void closeDoors(Elevator *elevator) {
    printf("Closing doors...\n");
    elevator->doorsOpen = false;
}

// 电梯上行操作
void moveUp(Elevator *elevator) {
    printf("Moving up...\n");
    elevator->status = ELEVATOR_MOVING_UP;
    elevator->floor++;
}

// 电梯下行操作
void moveDown(Elevator *elevator) {
    printf("Moving down...\n");
    elevator->status = ELEVATOR_MOVING_DOWN;
    elevator->floor--;
}

// 电梯停止操作
void stopElevator(Elevator *elevator) {
    printf("Stopping elevator...\n");
    elevator->status = ELEVATOR_STOPPED;
}

// 处理楼层状态，检测是否需要电梯停靠
void processFloor(Elevator *elevator, Floor *floor) {
    if (floor->status == FLOOR_NONE || floor->status == elevator->status) {
        return;
    }
    if (floor->status == FLOOR_UP && elevator->floor < MAX_FLOORS && elevator->status != ELEVATOR_MOVING_DOWN) {
        elevator->status = ELEVATOR_MOVING_UP;
        floor->status = FLOOR_NONE;
    } else if (floor->status == FLOOR_DOWN && elevator->floor > 1 && elevator->status != ELEVATOR_MOVING_UP) {
        elevator->status = ELEVATOR_MOVING_DOWN;
        floor->status = FLOOR_NONE;
    }
}

// 电梯控制主函数
void controlElevator(Elevator *elevator, Floor floors[MAX_FLOORS]) {
    while (true) {
        // 处理楼层状态
        for (int i = 0; i < MAX_FLOORS; i++) {
            processFloor(elevator, &floors[i]);
        }
        // 检测电梯状态
        switch (elevator->status) {
            case ELEVATOR_STOPPED:
                // 检测是否有开门请求
                if (elevator->doorsOpen) {
                    // 开门时间
                    time_t openTime = time(NULL);
                    while (time(NULL) - openTime < 3) {} // 模拟门开3秒
                    closeDoors(elevator);
                }
                // 检测是否有上行或下行请求
                for (int i = elevator->floor + 1; i <= MAX_FLOORS; i++) {
                    if (floors[i - 1].buttonUp) {
                        elevator->status = ELEVATOR_MOVING_UP;
                        floors[i - 1].status = FLOOR_NONE;
                        break;
                    }
                }
                for (int i = elevator->floor - 1; i >= 1; i--) {
                    if (floors[i - 1].buttonDown) {
                        elevator->status = ELEVATOR_MOVING_DOWN;
                        floors[i - 1].status = FLOOR_NONE;
                        break;
                    }
                }
                break;
            case ELEVATOR_OPENING:
                openDoors(elevator);
                elevator->status = ELEVATOR_OPENED;
                break;
            case ELEVATOR_OPENED:
                // 开门时间
                time_t openTime = time(NULL);
                while (time(NULL) - openTime < 3) {} // 模拟门开3秒
                closeDoors(elevator);
                elevator->status = ELEVATOR_CLOSING;
                break;
            case ELEVATOR_CLOSING:
                closeDoors(elevator);
                elevator->status = ELEVATOR_STOPPED;
                break;
            case ELEVATOR_MOVING_UP:
                moveUp(elevator);
                // 检测是否到达目标楼层
                if (floors[elevator->floor - 1].status == FLOOR_UP || floors[elevator->floor - 1].status == FLOOR_NONE) {
                    elevator->status = ELEVATOR_OPENING;
                    floors[elevator->floor - 1].status = FLOOR_NONE;
                }
                break;
            case ELEVATOR_MOVING_DOWN:
                moveDown(elevator);
                // 检测是否到达目标楼层
                if (floors[elevator->floor - 1].status == FLOOR_DOWN || floors[elevator->floor - 1].status == FLOOR_NONE) {
                    elevator->status = ELEVATOR_OPENING;
                    floors[elevator->floor - 1].status = FLOOR_NONE;
                }
                break;
        }
        // 模拟电梯运行时间
        time_t sleepTime = time(NULL);
        while (time(NULL) - sleepTime < 1) {}
    }
}

int main() {
    Elevator elevator;
    Floor floors[MAX_FLOORS];
    initElevator(&elevator);
    for (int i = 0; i < MAX_FLOORS; i++) {
        initFloor(&floors[i]);
    }
    // 模拟楼层按键
    floors[2].buttonUp = true;
    floors[5].buttonDown = true;
    controlElevator(&elevator, floors);
    return 0;
}

这是一个非常简单的电梯控制系统示例，仅供参考。实际应用中，还需要考虑更多的场景和细节，例如电梯超载保护、紧急停止、故障报警等等。