精华内容
下载资源
问答
  • 2020-11-12 18:19:55

    使用 JavaScript 重写的算法网页:
    https://yuqingxiong.github.io/Wumpus-World-Problem/
    github仓库地址:
    https://github.com/YuqingXiong/Wumpus-World-Problem

    题目描述

    Wumpus World PEAS 描述:
    性能度量:
    gold +1000, death -1000-
    1 per step, -10 for using the arrow
    环境描述:
    Squares adjacent to wumpusare smelly
    Squares adjacent to pit are breezy
    Glitter iffgold is in the same square
    Shooting kills wumpus if you are facing it
    Shooting uses up the only arrow
    Grabbing picks up gold if in same square
    Releasing drops the gold in same square
    传感器:Stench, Breeze, Glitter, Bump, Scream
    执行器:Left turn, Right turn, Forward, Grab, Release, Shoot
    
    Wumpus世界的PEAS描述
    - 性能度量:金子+100,死亡-1000,每一步-1,用箭-10
    - 环境:4×4网格,智能体初始在[1,1],面向右方,金子和wumpus在[1,1]之外随机均匀分布
    - 执行器:左转,右转,前进,捡起,射箭
        - 智能体可向前、左转或右转
        - 智能体如果进入一个有陷阱或者活着的wumpus的方格,将死去。
        - 如果智能体前方有一堵墙,那么向前移动无效
        - Grab:捡起智能体所在方格中的一个物体
        - Shoot:向智能体所正对方向射箭(只有一枝箭)
    - 传感器:
        - Smell:在wumpus所在之外以及与之直接相邻的方格内,智能体可以感知到臭气。
        - Breeze:在与陷阱直接相邻的方格内,智能体可以感知到微风。
        - Glitter(发光):在金子所处的方格内,智能体可以感知到闪闪金光。
        - 当智能体撞到墙时,它感受到撞击。
        - 当wumpus被杀死时,它发出洞穴内任何地方都可感知到的悲惨嚎叫。
    

    目标:找到金子并获得最高的分数(即使死去);

    此题为人工智能的课程设计题目之一,目的是使用联机搜索的方法,自己设计具体的搜索算法的细节。可能每个人对于游戏目标的追求不相同,有些人的算法设计更注重于安全性,所以即使找不到金子,也可以回家。但是我更注重于在相对安全的情况下获取金子然后回家,即使在寻找金子的过程中有很大概率掉进陷阱。

    界面效果

    在这里插入图片描述

    算法

    参考代码(https://github.com/Marko-M/wumpus-world/)
    上述代码是没有界面设计的,我在理解代码实现算法后,使用qt实现了可视化。主要借鉴了代码中对周围点的标记方法,使用二进制下的0,1对某种标记是否存在进行判断。

    基本思想

    使用联机搜索进行求解,联机问题在执行时,需要计算和行动交叉进行。联机搜索需要智能体能够记住先前的状态,不能访问下一个状态。下面是算法的基本流程:

    • (1)随机生成金子,怪兽,陷阱的位置,且它们的位置各不相同。
    • (2)从起始点开始DFS,更新当前点的信息,对当前点的四个邻居根据已有信息进行评估,选择最有利的邻居点走下去。
    • (3)评估标准为:
      首先寻找四周安全的点,如果没有则在地图上寻找最近安全点(BFS实现)
      如果没有安全点,则去往没有怪兽和陷阱的这些相对安全的点。
      如果没有相对安全的点,则去往有怪兽的点杀死怪兽。
      如果没有怪兽,则随机选择一个未被访问的点走下去,虽然很可能调入陷阱。
    • (4)重复上述过程直到找到金子然后最短路径回家或者掉入陷阱死亡。

    需求分析

    1、使用联机搜索算法进行求解。
    2、随机生成地图上陷阱,怪兽和金子的位置。
    3、智能体可以感知周围信息,得到金子获得最高的分数。
    4、图形化界面展示智能体的移动和当前获得的分数及状态。

    模块设计

    (1)RandInt模块:生成一个[l, r]之间且不在except中的随机整数。
    (2)RandPoint模块:生成一个在矩形l,r之内且不在except中的随机点。
    (3)PutFlag模块:为指定世界的某个点放陷阱,怪兽,臭气,微风等标志。
    (4)GetNeighborPosition模块:得到周围点的坐标。
    (5)Dfs模块:使用Dfs的框架实现联机搜索算法。
    (6)Bfs模块:bfs获得从src到tar的最短路径,用于计算最近的安全点和回家的最短路。
    (7)UpdateNeighborsInformation模块:每走到一个新的点,则更新邻居节点的信息。
    (8)GetBfsPath模块:根据在BFS算法中记录的路径,得到搜索到的路径结果并存储。
    (9)ShowPath模块:根据记录的路径展示最终的智能体在地图上的路线。
    (10)CreatWorld模块:随机生成一个世界,包含3个陷阱,1个怪兽,1个金子,坐标随机。

    模块间的调用关系:
    在这里插入图片描述

    存储结构设计

    (1)随机生成的地图每一个点都通过一个12位的标记向量表示这个点的已知信息,通过二进制中的每个比特位是否为1表示是否有这个标记。

    标记名称当前点安全已访问发光臭气微风怀疑金子怀疑陷阱怀疑怪兽金子陷阱怪兽
    二进制位123456789101112
    十进制值124816326412825651210242048

    算法设计

    运行程序后,创建WumpusWorld类的对象调用类的构造函数,在类的构造函数中进行世界的随机生成和初始界面显示。
    当用户点击Game Start按钮时,调用按钮响应函数,在按钮响应函数ButtonClick()中调用ShowPath模块开始联机搜索然后进行搜索路径的显示。
    

    算法流程图:
    在这里插入图片描述

    文件结构

    在这里插入图片描述
    资源文件中的图片是直接在网上搜索下载下的怪兽,金子,陷阱等图片还有一些通过PPT制作的按钮图片和文字图片。

    代码

    mainwindow.h文件代码

    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    #include <QTime>
    #include <QTest>
    
    #include <QDebug>
    #include <QPushButton>
    #include <QMessageBox>
    #include <QLabel>
    
    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <string>
    #include <vector>
    #include <ctime>
    #include <cmath>
    #include <algorithm>
    #include <cstdlib>
    #include <queue>
    #include <map>
    
    using namespace std;
    
    #define ROW_NUM			4		// 行数
    #define COL_NUM			4		// 列数
    #define GOLD_NUM		1		// 金子数
    #define CAVE_NUM		3		// 陷阱数
    #define WUMPUS_NUM		1		// 怪兽数
    #define FLAG_NUM		12		// 标记向量的比特位数量
    
    #define CURRENT			1		// 当前点
    #define SAFE			2		// 安全
    #define VISITED			4		// 已访问
    #define GLITTER			8		// 发光
    #define STENCH			16		// 臭气
    #define BREEZE			32		// 微风
    #define GOLD_SUSPECT	64		// 怀疑有金子
    #define CAVE_SUSPECT	128		// 怀疑有陷阱
    #define WUMPUS_SUSPECT	256		// 怀疑有怪兽
    #define GOLD			512		// 金子
    #define CAVE			1024	// 陷阱
    #define WUMPUS			2048	// 怪兽
    
    #define GOLD_VALUE		1000	// 金子价值
    #define WUMPUS_COST		10		// 怪兽消耗
    #define DEATH_COST		1000	// 死亡消耗
    #define STEP_COST		1		// 行动消耗
    
    #define Point pair<int, int>	// pair存储点坐标
    #define xx first				// x坐标
    #define yy second				// y坐标
    
    
    namespace Ui {
    class MainWindow;
    }
    
    class WumpusWorld : public QMainWindow
    {
        Q_OBJECT
    public:
        QList<QLabel *> map_label;    // 地图
        QLabel *score_get;            // 分数显示
        QLabel *state;                // 当前状态
    public:
        explicit WumpusWorld(QWidget *parent = 0);
        ~WumpusWorld();
        int RandInt(int l, int r, vector<int> except);					// 生成一个[l, r]之间且不在except中的随机整数
        Point RandPoint(Point l, Point r, vector<Point> except);		// 生成一个在矩形l,r之内且不在except中的随机点
        void PutFlag(int world[ROW_NUM][COL_NUM], Point pos, int flag);	// 放标志
        void GetNeighborPosition(Point pos, vector<Point> &neighbor);	// 得到周围点的坐标
        void Dfs(Point current);										// 联机搜索算法
        int Bfs(Point src, Point tar, bool record);						// bfs获得从src到tar的最短路径
        void UpdateNeighborsInformation(Point current);					// 更新邻居点的信息
        void GetBfsPath(Point cur, Point begPos, Point tar, map<Point, Point> bfs_path);
        void ShowPath();               // 展示agent路径
        void CreatWorld();             // 随机生成一个WumpusWorld
    
    private:
        int real_world[ROW_NUM][COL_NUM];	// 真实世界
        int agent_world[ROW_NUM][COL_NUM];	// 代理世界
    
        Point cave_position[CAVE_NUM];		// 陷阱坐标
        Point wumpus_position[WUMPUS_NUM];	// 怪兽坐标
        Point gold_position[GOLD_NUM];		// 金子坐标
    
        Point path_record[100];			// 路径记录
        Point start;	// 起始点坐标
    
        bool find_gold;	// 是否找到金子
        bool game_over;	// 是否游戏结束
        int score;		// 当前分数
        int step_cnt;   // 步数
    
    private:
        Ui::MainWindow *ui;
    
    public slots:
        void ButtonClick(); // 游戏开始信号
    };
    #endif // MAINWINDOW_H
    

    main.cpp

    #include "mainwindow.h"
    #include <QApplication>
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        WumpusWorld w;
        w.show();
        return a.exec();
    }
    

    mainwindow.cpp

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    WumpusWorld::WumpusWorld(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
    
        /* ======================= 图形界面部分 ===================== */
        setWindowTitle("WumpusWorld");  //设置窗体名
        setFixedSize(900, 600);   //设置窗体大小
        setWindowIcon(QIcon(":/logo.png")); //设置窗体图标
        //设置窗体背景为白色
        QPalette palette(this->palette());
        palette.setColor(QPalette::Background, Qt::white);
        this->setPalette(palette);
    
        srand((unsigned int)time(0));	//初始化随机种子
        CreatWorld();
    
    
        // 信息
        QLabel *infor = new QLabel(this);
        infor->setGeometry(state->pos().x() + 15, state->pos().y() + 70, 150, 250);
        infor->setStyleSheet("border-image:url(:/information.png);");
    }
    
    void WumpusWorld::CreatWorld()
    {
        /* ==================== WumpusWorld初始化 ================== */
        start.xx = 0, start.yy = 0;	// 起始点(0, 0)
        vector<Point> except;		// 非法访问点
        except.push_back(start);	// 将起始点不可再访问
        Point l{1, 1}, r{ ROW_NUM - 1, COL_NUM - 1 };	// 边界点
        find_gold = false;
        game_over = false;
        step_cnt = 0;
    
        for (int i = 0; i < ROW_NUM; ++i) {
            for (int j = 0; j < COL_NUM; ++j) {
                real_world[i][j] = 0;
                agent_world[i][j] = 0;
            }
        }
    
        // 生成陷阱位置
        for (int i = 0; i < CAVE_NUM; ++i) {
            cave_position[i] = RandPoint(l, r, except);
            except.push_back(cave_position[i]);
        }
    
        // 生成怪兽位置
        for (int i = 0; i < WUMPUS_NUM; ++i) {
            wumpus_position[i] = RandPoint(l, r, except);
            except.push_back(wumpus_position[i]);
        }
    
        // 生成金子位置
        for (int i = 0; i < CAVE_NUM; ++i) {
            gold_position[i] = RandPoint(l, r, except);
            except.push_back(gold_position[i]);
        }
    
        vector<Point> neighbor;	// 当前点的邻居坐标
        // 生成世界
        for (int i = 0; i < ROW_NUM; ++i) {
            for (int j = 0; j < COL_NUM; ++j) {
                // 陷阱检查
                for (int k = 0; k < CAVE_NUM; ++k) {
                    if (i == cave_position[k].xx && cave_position[k].yy == j) {
                        PutFlag(real_world, cave_position[k], CAVE);	// 放陷阱
                        GetNeighborPosition(cave_position[k], neighbor);// 获取邻居坐标
                        while (!neighbor.empty()) {	// 陷阱的邻居点都打上微风标记
                            PutFlag(real_world, neighbor[neighbor.size() - 1], BREEZE);
                            neighbor.pop_back();
                        }
                    }
                }
    
                // 怪兽检查
                for (int k = 0; k < WUMPUS_NUM; ++k) {
                    if (i == wumpus_position[k].xx && j == wumpus_position[k].yy) {
                        PutFlag(real_world, wumpus_position[k], WUMPUS);  // 放怪兽
                        GetNeighborPosition(wumpus_position[k], neighbor);// 获取邻居坐标
                        while (!neighbor.empty()) {	// 怪兽的邻居点都打上臭气标记
                            PutFlag(real_world, neighbor[neighbor.size() - 1], STENCH);
                            neighbor.pop_back();
                        }
                    }
                }
    
                // 金子检查
                for (int k = 0; k < GOLD_NUM; ++k) {
                    if (i == gold_position[k].xx && j == gold_position[k].yy) {
                        PutFlag(real_world, gold_position[k], GOLD);	// 放金子
                        GetNeighborPosition(gold_position[k], neighbor);// 获取邻居坐标
                        while (!neighbor.empty()) {
                            PutFlag(real_world, neighbor[neighbor.size() - 1], GLITTER);
                            neighbor.pop_back();
                        }
                    }
                }
            }
        }
        /* =============== 程序输出界面显示生成的世界 ================= */
    
        for (int i = 0; i < CAVE_NUM; ++i) printf("%d. cave corrd: (%d, %d)\n", i, cave_position[i].xx, cave_position[i].yy);
        for (int i = 0; i < WUMPUS_NUM; ++i) printf("%d. wumpus corrd: (%d, %d)\n", i, wumpus_position[i].xx, wumpus_position[i].yy);
        for(int i = 0; i < GOLD_NUM; ++ i) printf("%d. gold corrd: (%d, %d)\n", i, gold_position[i].xx, gold_position[i].yy);
    
        // 显示世界
        for (int i = 0; i < ROW_NUM; ++i) {
            for (int j = 0; j < COL_NUM; ++j) {
                if ((real_world[i][j] & CAVE) == CAVE) printf("C ");
                else if ((real_world[i][j] & WUMPUS) == WUMPUS) printf("W ");
                else if ((real_world[i][j] & GOLD) == GOLD) printf("G ");
                else printf("O ");
            }
            printf("\n");
        }
    
        /* =============== 图形界面显示生成的世界 ================= */
        int w = 140, h = 140, px = 0, py = 0;
        for(int i = 0; i < ROW_NUM; ++ i){
            for(int j = 0; j < COL_NUM; ++ j){
                QLabel *label = new QLabel(this);
                map_label.push_back(label);
                px = i * w + 30, py = j * h + 30;
                label->setGeometry(px, py, w, h);   // 设置坐标和大小
                if ((real_world[i][j] & CAVE) == CAVE) label->setStyleSheet("border-image:url(:/cave.png);");
                else if ((real_world[i][j] & WUMPUS) == WUMPUS) label->setStyleSheet("border-image:url(:/monster.png);");
                else if ((real_world[i][j] & GOLD) == GOLD) label->setStyleSheet("border-image:url(:/gold.png);");
                else label->setStyleSheet("border-image:url(:/grid.png);");
            }
        }
        map_label[0]->setStyleSheet("border-image:url(:/agent.png);");
        // 开始按钮
        QPushButton *startBut = new QPushButton(this);
        startBut->setGeometry(650, 30, 210, 70);
        startBut->setStyleSheet("border-image:url(:/start.png);");
        connect(startBut, SIGNAL(clicked(bool)), this, SLOT(ButtonClick()));//为每个按钮添加响应函数
    
        // 分数标签
        QLabel *score_label = new QLabel(this);
        score_label->setGeometry(startBut->pos().x(), startBut->pos().y() + 70, 210, 60);
        score_label->setStyleSheet("border-image:url(:/score.png);");
    
        // 分数
        score_get = new QLabel(this);
        score_get->setGeometry(score_label->pos().x(), score_label->pos().y() + 50, 210, 60);
        score_get->setStyleSheet("qproperty-alignment: 'AlignVCenter|AlignHCenter';font-size:50px;color:rgb(31, 93, 173);font-family:黑体");
        score_get->setText("0");
    
        // 当前状态
        QLabel *state_text = new QLabel(this);
        state_text->setGeometry(score_get->pos().x(), score_get->pos().y() + 70, 210, 60);
        state_text->setStyleSheet("border-image:url(:/state.png);");
    
        state = new QLabel(this);
        state->setGeometry(state_text->pos().x(), state_text->pos().y() + 50, 210, 50);
        state->setStyleSheet("border-image:url(:/waiting.png);");
    }
    
    void WumpusWorld::ButtonClick()
    {
        ShowPath();
    }
    int WumpusWorld::RandInt(int l, int r, vector<int> except)
    {
        int result = 0;
        do {
            result = rand() % (r - l + 1) + l;	// 随机数生成
        } while (std::find(except.begin(), except.end(), result) != except.end());
    
        return result;
    }
    
    Point WumpusWorld::RandPoint(Point l, Point r, vector<Point> except)
    {
        Point result;
        do {
            result.xx = RandInt(l.xx, r.xx, vector<int>{});	// x坐标
            result.yy = RandInt(l.yy, r.yy, vector<int>{});	// y坐标
        } while (std::find(except.begin(), except.end(), result) != except.end());
        return result;
    }
    
    void WumpusWorld::PutFlag(int world[ROW_NUM][COL_NUM], Point pos, int flag)
    {
        // 如果已访问则其他的传感器标志置零
        if (pos.xx < 0 || pos.xx >= ROW_NUM || pos.yy < 0 || pos.yy >= COL_NUM) {
            return;
        }
        if (flag == VISITED) {
            world[pos.xx][pos.yy] &= ~SAFE;
            world[pos.xx][pos.yy] &= ~CAVE_SUSPECT;
            world[pos.xx][pos.yy] &= ~GOLD_SUSPECT;
            world[pos.xx][pos.yy] &= ~WUMPUS_SUSPECT;
        }
        world[pos.xx][pos.yy] |= flag;	// 放标记
    }
    
    void WumpusWorld::GetNeighborPosition(Point pos, vector<Point> &neighbor)
    {
        int Next[4][2] = { {0, 1}, {0, -1}, {1, 0}, {-1, 0} };// 上,下,左,右
        for (int i = 0; i < 4; ++i) {
            int next_x = pos.xx + Next[i][0];	// 邻居点x坐标
            int next_y = pos.yy + Next[i][1];	// 邻居点y坐标
            if (next_x >= 0 && next_x < ROW_NUM && next_y >= 0 && next_y < COL_NUM) {// 边界检查
                neighbor.push_back({ next_x, next_y });
            }
        }
    }
    
    void WumpusWorld::Dfs(Point current)
    {
        vector<Point> neighbors;
        path_record[step_cnt++] = current;
        agent_world[current.xx][current.yy] |= real_world[current.xx][current.yy];	// 获取当前点信息
        if ((agent_world[current.xx][current.yy] & GOLD) == GOLD) {	//如果遇到了金子
            find_gold = true;
            return;
        }
        if ((agent_world[current.xx][current.yy] & CAVE) == CAVE) {	// 掉进了洞穴
            game_over = true;
            return;
        }
        PutFlag(agent_world, current, VISITED);	// 当前点已访问
        UpdateNeighborsInformation(current);	// 更新周围点的信息
        agent_world[current.xx][current.yy] &= ~CURRENT;	// 不在当前点
    
        int Next[4][2] = { {0, 1}, {0, -1}, {1, 0}, {-1, 0} };// 上,下,左,右
        for (int i = 0; i < 4; ++i) {
            int next_x = current.xx + Next[i][0];	// 邻居点x坐标
            int next_y = current.yy + Next[i][1];	// 邻居点y坐标
            if (next_x >= 0 && next_x < ROW_NUM && next_y >= 0 && next_y < COL_NUM) {// 边界检查
                neighbors.push_back({ next_x, next_y });
            }
        }
        for (int i = 0; i < neighbors.size(); ++i) {	// 周围可能有金子
            if ((agent_world[neighbors[i].xx][neighbors[i].yy] & GOLD) == GOLD) {
                PutFlag(agent_world, neighbors[i], CURRENT);
                Dfs(neighbors[i]);	// 下一步
                if (find_gold || game_over) return;
            }
        }
        // 周围没有金子
        if (find_gold == false) {
            vector<Point> safe_place;
            for (int i = 0; i < neighbors.size(); ++i) {
                if (((agent_world[neighbors[i].xx][neighbors[i].yy] & SAFE) == SAFE)		// 安全
                    && ((agent_world[neighbors[i].xx][neighbors[i].yy] & VISITED)  == 0)) { // 未访问
                    safe_place.push_back(neighbors[i]);
                }
            }
            if (safe_place.size() > 0) {	// 存在安全区域
                int rand_next_pos = rand() % safe_place.size();	// 随机选择一个安全区域
                PutFlag(agent_world, safe_place[rand_next_pos], CURRENT);
                Dfs(safe_place[rand_next_pos]);	// 下一步
                if (find_gold || game_over) return;
            }else {		// 没有安全区域,寻找最近的安全地带
                Point nearest_safe_pos = { -1, -1 };	// 最近的安全点初始化
                for (int i = 0; i < ROW_NUM; ++i) {
                    for (int j = 0; j < COL_NUM; ++j) {
                        if ((agent_world[i][j] & SAFE) == SAFE) {
                            if (nearest_safe_pos == Point{ -1, -1 })	// 第一个安全的点
                                nearest_safe_pos = { i, j };
                            else {
                                int dismin = Bfs(current, nearest_safe_pos, false); // 最近安全点距离
                                int discur = Bfs(current, Point{ i, j }, false);	// 当前安全点距离
                                if (discur < dismin) {	// 当前安全点更近
                                    nearest_safe_pos = { i, j };	// 更新最近安全点
                                }
                            }
                        }
                    }
                }
                // 机器人地图上有安全点
                if (nearest_safe_pos != Point{-1, -1}) {
                    PutFlag(agent_world, nearest_safe_pos, CURRENT);
                    Bfs(current, nearest_safe_pos, true);	// 记录行动路线
                    Dfs(nearest_safe_pos);	// 下一步
                    if (find_gold || game_over) return;
                }else {	// 没有安全点,选择一个相对安全的地点
                    vector<Point> good_neighbor;
                    for (int i = 0; i < neighbors.size(); ++i) {
                        if(((agent_world[neighbors[i].xx][neighbors[i].yy] & VISITED)  == 0)	// 未被访问
                            && ((agent_world[neighbors[i].xx][neighbors[i].yy] & CAVE) == 0)	// 没有陷阱
                            && ((agent_world[neighbors[i].xx][neighbors[i].yy] & WUMPUS) == 0)) // 没有怪兽
                            good_neighbor.push_back(neighbors[i]);
                    }
    
                    if (good_neighbor.size() > 0) {	// 有相对安全的点
                        int rand_next_goodpos = rand() % (good_neighbor.size());	// 随机选取一个相对安全的点
                        Dfs(good_neighbor[rand_next_goodpos]);	// 下一步
                        if (find_gold || game_over) return;
                    }else {	// 没有相对安全的点,选择杀死怪兽
                        vector<Point> kill_pos, cave_pos;
                        for (int i = 0; i < neighbors.size(); ++i) {
                            if ((agent_world[neighbors[i].xx][neighbors[i].yy] & VISITED) == 0) // 未被访问过
                                if((agent_world[neighbors[i].xx][neighbors[i].yy] & WUMPUS) == WUMPUS) {	// 是怪兽
                                kill_pos.push_back(neighbors[i]);
                                }else {
                                    cave_pos.push_back(neighbors[i]);
                                }
                        }
                        if (kill_pos.size() > 0) {	// 存在怪兽则杀死怪兽
                            int kill_wumpus = rand() % kill_pos.size();
                            vector<Point> wumpus_neighbors;
                            GetNeighborPosition(kill_pos[kill_wumpus], wumpus_neighbors);
                            agent_world[kill_pos[kill_wumpus].xx][kill_pos[kill_wumpus].yy] &= ~WUMPUS;// 取消怪兽标记
                            // 将杀死的怪兽周围的臭气标记取消
                            for (int i = 0; i < wumpus_neighbors.size(); ++i) {
                                agent_world[wumpus_neighbors[i].xx][wumpus_neighbors[i].yy] &= ~STENCH;
                            }
                            PutFlag(agent_world, kill_pos[kill_wumpus], CURRENT);
                            Dfs(kill_pos[kill_wumpus]);	// 下一步
                            if (find_gold || game_over) return;
                        }else if(cave_pos.size()){	// 没有怪兽只有陷阱
                            int jump_cave = rand() % cave_pos.size();
                            PutFlag(agent_world, cave_pos[jump_cave], CURRENT);
                            Dfs(cave_pos[jump_cave]);
                        }
                    }
                }
            }
        }
    }
    
    int WumpusWorld::Bfs(Point src, Point tar, bool record)
    {
        // 上下左右四个方向
        int Next[4][2] = { {0, 1}, {0, -1}, {-1, 0},{1, 0} };
        int steps = 0;
        map<Point, Point> bfs_path;
        bool flag = false;
        if ((agent_world[tar.xx][tar.yy] & VISITED) == 0) {
            agent_world[tar.xx][tar.yy] |= VISITED;
            flag = true;
        }
    
        queue<Point> Q;
        Q.push(src);
        bool vis[ROW_NUM][COL_NUM];	// 遍历标记
        memset(vis, false, sizeof(vis));
        vis[src.xx][src.yy] = true;
        while (!Q.empty()) {
            Point cur = Q.front();
            Q.pop();
            ++steps;
            if (cur == tar) {
                break;
            }
            for (int i = 0; i < 4; ++i) {
                int dx = cur.xx + Next[i][0];   // 下一个点的坐标
                int dy = cur.yy + Next[i][1];
                if (dx >= 0 && dx < ROW_NUM && dy >= 0 && dy < COL_NUM && ((agent_world[dx][dy] & VISITED) == VISITED )&& vis[dx][dy] == false) {
                    if (record == true)	// 需要记录路径
                        bfs_path[Point{ dx,dy }] = cur;
                    vis[dx][dy] = true;
                    Q.push({ dx, dy });
                }
            }
        }
        if (record == true) {   // 需要记录则根据搜索路径找到搜索结果
            GetBfsPath(tar, src, tar, bfs_path);
        }
        if(flag) agent_world[tar.xx][tar.yy] &= ~VISITED;// 取消访问标记
        return steps;   // 返回最短路径长度
    }
    
    void WumpusWorld::GetBfsPath(Point cur, Point begPos, Point tar, map<Point, Point> bfs_path)
    {
        if (cur == begPos) {
            return;
        }
        GetBfsPath(bfs_path[cur], begPos, tar, bfs_path);
        if(cur != tar) path_record[step_cnt++] = cur;
    }
    
    void WumpusWorld::ShowPath()
    {
        Dfs(start);
    
        if (find_gold) {
            Bfs(gold_position[0], start, true);
            path_record[step_cnt++] = start;
        }
        for (int i = 0; i < step_cnt; ++i) {
            int pos_index = path_record[i].xx * ROW_NUM + path_record[i].yy;
            map_label[pos_index]->setStyleSheet("border-image:url(:/agent.png);");
            QTest::qWait(400);
            if((real_world[path_record[i].xx][path_record[i].yy] & CAVE) == CAVE){  // 当前点是陷阱
                map_label[pos_index]->setStyleSheet("border-image:url(:/deathagent.png);");
            }
            if(i != step_cnt - 1){
                map_label[pos_index]->setStyleSheet("border-image:url(:/grid.png);");
                score -= STEP_COST;
                if(path_record[i + 1] == start){    // 下个点是起点
                    state->setStyleSheet("border-image:url(:/back.png);");
                }
                else if((real_world[path_record[i + 1].xx][path_record[i + 1].yy] & WUMPUS) == WUMPUS){  // 下一个点是怪兽
                    score -= WUMPUS_COST;
                    real_world[path_record[i + 1].xx][path_record[i + 1].yy] &= ~WUMPUS;
                    state->setStyleSheet("border-image:url(:/kill.png);");
                }
                else if((real_world[path_record[i + 1].xx][path_record[i + 1].yy] & GOLD) == GOLD){ // 下一个点是金子
                    score += GOLD_VALUE;
                    state->setStyleSheet("border-image:url(:/findgold.png);");
                }
                else if((real_world[path_record[i + 1].xx][path_record[i + 1].yy] & CAVE) == CAVE){ // 下一个点是陷阱
                    score -= DEATH_COST;
                    state->setStyleSheet("border-image:url(:/death.png);");
                }
                else{
                    state->setStyleSheet("border-image:url(:/move.png);");
                }
                score_get->setText(QString::number(score));
            }
            printf("(%d, %d)\t", path_record[i].xx, path_record[i].yy);
        }
    }
    
    void WumpusWorld::UpdateNeighborsInformation(Point current)
    {
        vector<Point> neighbors;
        GetNeighborPosition(current, neighbors);
        int curx = current.xx, cury = current.yy;
        for (int i = 0; i < neighbors.size(); ++i) {
            int nx = neighbors[i].xx;
            int ny = neighbors[i].yy;
            if ((agent_world[nx][ny] & SAFE) == 0 && (agent_world[nx][ny] & VISITED) == 0) {	   // 不安全且未被访问
                if ((agent_world[curx][cury] & BREEZE) == BREEZE) {	// 有微风
                    if ((agent_world[nx][ny] & CAVE_SUSPECT) == CAVE_SUSPECT) {
                        PutFlag(agent_world, neighbors[i], CAVE);
                    }
                    else {
                        PutFlag(agent_world, neighbors[i], CAVE_SUSPECT);
                    }
                }
    
                if ((agent_world[curx][cury] & STENCH) == STENCH) {	// 有臭气
                    if ((agent_world[nx][ny] & WUMPUS_SUSPECT) == WUMPUS_SUSPECT) {
                        PutFlag(agent_world, neighbors[i], WUMPUS);
                    }
                    else {
                        PutFlag(agent_world, neighbors[i], WUMPUS_SUSPECT);
                    }
                }
    
                if ((agent_world[curx][cury] & GLITTER) == GLITTER) {	//有闪光
                    if ((agent_world[nx][ny] & GOLD_SUSPECT) == GOLD_SUSPECT) {
                        PutFlag(agent_world, neighbors[i], GOLD);
                    }
                    else {
                        PutFlag(agent_world, neighbors[i], GOLD_SUSPECT);
                    }
                }
    
                if (((agent_world[curx][cury] & BREEZE) == 0) && ((agent_world[curx][cury] & STENCH)== 0)) {	 // 没有微风和臭气则安全
                    PutFlag(agent_world, neighbors[i], SAFE);
                    // 删除其他非必要标记
                    agent_world[nx][ny] &= ~CAVE_SUSPECT;
                    agent_world[nx][ny] &= ~WUMPUS_SUSPECT;
                    agent_world[nx][ny] &= ~CAVE;
                    agent_world[nx][ny] &= ~WUMPUS;
                }
            }
        }
    }
    
    WumpusWorld::~WumpusWorld()
    {
        delete ui;
    }
    

    运行结果及分析

    1、根据算法智能体每走一步都会更新信息,然后将周围点进行标记,这样的话被标记两次为怀疑陷阱的地方就会被标记为陷阱,被怀疑为怪兽两次的地方被标记为怪兽。
    2、由于算法每次优先选取安全的点进行移动,有时候往往有更短的路线可以移动但是由于最短路线上有未知的没有到达的点所以导致了线路变长,扣分增多。
    3、根据测试,在多数情况下智能体都可以避开陷阱和怪兽,至多杀死怪兽从而找到金子。但是在少数情况下由于金子的位置过于偏僻(比如被怪兽和陷阱所包围)的时候,智能体只能依靠随机的选择,这样死亡的概率大大增加。
    4、联机搜索可以解决实时的问题,但是由于知道的信息随时更新,具有太强的随机性,所以有时候得到的解往往不那么理想。

    使用说明

    点击Game Start按钮,智能体开始移动。Score显示当前分数,State显示当前智能体的状态,一共有6个状态分别为:Waiting to start(等待游戏开始);Move(智能体移动);Find Gold!(找到金子);DEATH(智能体掉入陷阱死亡);KillMonster (智能体杀死怪兽);BackHome(智能体找到金子后回到起始点)。

    每次运行程序智能体只行走一次,当想要生成下一个WumpusWorld时需要关闭程序后重新运行就会生成新的地图,然后点击Game Start按钮。

    完整项目文件下载

    工程代码文件:
    CSDN下载:https://download.csdn.net/download/qq_45364953/15164347

    demo:
    百度网盘:https://pan.baidu.com/s/1S-mlO7_pJ4oFsWHr_7MzXw
    提取码:r4t6

    更多相关内容
  • 你真的懂Java怎么输出Hello World吗?

    万次阅读 多人点赞 2021-06-09 22:00:57
    你真的懂Java怎么输出Hello World吗?1. 你会不会输出"Hello World!"?2. 小生抛砖引玉,欢迎指正3. 总结 1. 你会不会输出"Hello World!"? 当我们学习一门编程语言的时候,我们都会先学如何输出Hello World! ????...

    1. 你会不会输出"Hello World!"?

    图1图 2
    在这里插入图片描述在这里插入图片描述

    当我们学习一门编程语言的时候,我们都会先学如何输出Hello World!

    👨:“你真的会吗?”

    👩:“会!”

    👩:“以下这几个例子,我背都给你背下来!!!!【骄傲】”

    • C语言
    printf("Hello World!");
    
    • C++语言
    cout << "Hello World!";
    
    • Golang语言:
    fmt.Print("hello world!")
    
    • Java语言:
    System.out.print("Hello World!");
    
    • Python语言:
    print('Hello World!')
    

    👨:“但!你真的会吗?【邪魅一笑】。这次我赌你不会!不信?那你接着往下看~”

    2. 小生抛砖引玉,欢迎指正

    下面这个代码是Java输出Hello World的代码,代码没有报错,输出结果正确。
    在这里插入图片描述
    我们在输出这一行打一个断点,并且以debug模式运行,不断点击下一步。
    在这里插入图片描述
    首先我们可以看到是System类调用静态成员out,并且out是一个PrintStream对象的实例,调用这个实例的println方法,就来到如下页面。我们可以看到这个方法传入的是我们的Hello World字符串,并且调用print方法,再调用newLine方法。从这里就可以看出print和println方法的区别。聪明的你应该可以猜到,没错,newLine方法就是换行。好的,继续往下走~

    在这里插入图片描述

    这个时候我们进入了print方法。这里也很好理解。你可以想想当我们的字符串为null的时候,你会发现输出的是一个字符串的null,而在源码里面正好就是这样的设计。紧接着,将会调用该类中的write方法。那行,我们继续进入write方法。
    在这里插入图片描述
    进入write方法,我们会发现这里有一个同步锁。学过Java语法的同学应该马上就反应到了,这是防止在多线程的情况下,一个字符串还未处理完,另一个字符串便进来这个方法了,这会导致内部的数据出现矛盾!!接着是执行一个ensureOpen方法,按照我的蹩脚英文hh,初步理解这是“确定是否打开”的意思。那我们就进去看看到底是确定什么是否打开!

    在这里插入图片描述
    我们发现这里有一个判断out实例是否为null的情况,当out为null的时候,抛出一个“流关闭”的异常。结合这个提示,加上对代码的查看,我们发现这个out实例正是输出流对象的实例。当我们要输出什么内容的时候,当然要判断输出流对象是否为空呀。OK,这里我们没啥问题。
    在这里插入图片描述
    那我们就要进入整个输出语句最重要的源代码了:执行写入。
    在这里插入图片描述
    进去之后我们发现,同样是调用重载的write方法,传入的参数为字符串,0以及字符串长度。接着进入该方法。

    在这里插入图片描述

    前方高能!!!
    同步锁和ensureOpen方法上面已经讲过不赘述。这里初始化变量b是0,t是0加上字符串的长度。
    这个时候的t-b正好就是字符串的长度,那么接着下去,我们会取我们一次可以写入最大的长度t-b最小值。

    • 当最小值是我们的字符串长度的时候,我们直接获取字符串的字符数组,让初始变量b加上写入的长度,这个时候我们会发现循环条件已经不成立,那么将会结束循环;
    • 当最小值是一次可以写入最大的长度的时候,我们直接写入最大的长度,这时候初始变量加上写入长度的时候,循环条件是成立的,同时我们也有字符串没有获取,那么将会进入下一次循环,直到b<t不成立时退出。
      同时在执行循环体的过程中,仍然需要不断清楚缓存。


    其余的几个方法和上面的思路比较相似,这里将不一一赘述。
    在这里插入图片描述

    3. 总结

    这里是我个人的一点点小小的思考,我觉得程序员有三个境界,从浅到深依次是:

    1. 会调用源代码
    2. 会看懂源代码
    3. 会复写源代码

    为什么要看源代码呢?很多急于求成的程序员会说,别人写好的东西,你会用就好了啊,你要看懂实现原理干嘛?但我想说的是,其实看源码的过程正是你学习代码的过程。Java源码经历过二十几年的沉淀,很多东西看似底层,但其实最考验基础语法的功底。博主本人现在读大二,关于Java源码的讲解肯定有很多不够完善的地方,但我的初衷是分享。我也希望优秀的你,在评论区给我更加宝贵的建议和意见,感谢!!

    展开全文
  • World Wind Java三维地理信息系统开发技术指南 World Wind GIS WW
  • 目录0、安装:pip install pygal_maps_world1、指定代码绘制国家2、指定某个国家的标签值3、获取大洲区域地图4、雷达图5、基本饼图(Pie)6、条形图6、词云图7、柱状图8、折线柱状图附件 0、安装:pip install pygal...

    0、安装:pip install pygal_maps_world

    此时可以访问pygal.maps.world模块

    1、指定代码绘制国家

    # # 导入需要的包
    # import numpy as np
    # import matplotlib.pyplot as plt
    # from mpl_toolkits.basemap import Basemap
    # # conda install basemap
    # # pip install -U matplotlib==3.2
    # # pip install packagename
    # #export PROJ_LIB=/opt/conda/share/proj
    # import os
    # import conda
    #
    # conda_file_dir = conda.__file__
    # conda_dir = conda_file_dir.split('lib')[0]
    # proj_lib = os.path.join(os.path.join(conda_dir, 'share'), 'proj')
    # os.environ["PROJ_LIB"] = proj_lib
    #
    #
    #
    # # 初始化图形
    #
    # plt.figure(figsize=(8, 8))
    #
    # # 底图:圆形, lat_0:纬度;lon_o: 经度, (113,29)是武汉
    # m = Basemap(projection='ortho', resolution=None, lat_0=29, lon_0=113)
    # # 底色
    # m.bluemarble(scale=0.5)
    # # m.shadedrelief(scale=0.5)浮雕图像
    #
    # plt.show()
    #
    #
    # pip install pyecharts echarts-countries-pypkg echarts-china-provinces-pypkg echarts-china-cities-pypkg  echarts-china-counties-pypkg echarts-china-misc-pypkg echarts-united-kingdom-pypkg
    # 导入需要的包
    import pygal.maps.world
    
    worldmap_chart = pygal.maps.world.World()
    worldmap_chart.title = 'Some countries'
    worldmap_chart.add('F countries', ['fr', 'fi'])
    worldmap_chart.add('M countries', ['ma', 'mc', 'md', 'me', 'mg',
                                       'mk', 'ml', 'mm', 'mn', 'mo',
                                       'mr', 'mt', 'mu', 'mv', 'mw',
                                       'mx', 'my', 'mz'])
    worldmap_chart.add('U countries', ['ua', 'ug', 'us', 'uy', 'uz'])
    worldmap_chart.render_to_file('bar_chart.svg')
    
    

    生成文件:
    在这里插入图片描述
    在火狐浏览器中打开显示即可:
    在这里插入图片描述

    2、指定某个国家的标签值

    import pygal.maps.world
    
    worldmap_chart = pygal.maps.world.World()
    worldmap_chart.title = 'Minimum deaths by capital punishement (source: Amnesty International)'
    worldmap_chart.add('In 2012', {
      'af': 14,
      'bd': 1,
      'by': 3,
      'cn': 1000,
      'gm': 9,
      'in': 1,
      'ir': 314,
      'iq': 129,
      'jp': 7,
      'kp': 6,
      'pk': 1,
      'ps': 6,
      'sa': 79,
      'so': 6,
      'sd': 5,
      'tw': 1000,
      'ae': 1,
      'us': 43,
      'ye': 28
    })
    worldmap_chart.render_to_file('bar_chart.svg')
    

    生成结果:
    在这里插入图片描述

    3、获取大洲区域地图

    import pygal.maps.world
    
    supra = pygal.maps.world.SupranationalWorld()
    supra.add('Asia', [('asia', 1)])
    supra.add('Europe', [('europe', 1)])
    supra.add('Africa', [('africa', 1)])
    supra.add('North america', [('north_america', 1)])
    supra.add('South america', [('south_america', 1)])
    supra.add('Oceania', [('oceania', 1)])
    supra.add('Antartica', [('antartica', 1)])
    supra.render_to_file('bar_chart.svg')
    

    在这里插入图片描述

    4、雷达图

    import pygal
    
    radar_chart = pygal.Radar()
    radar_chart.title = 'V8 benchmark results'
    radar_chart.x_labels = ['Richards', 'DeltaBlue', 'Crypto', 'RayTrace', 'EarleyBoyer', 'RegExp', 'Splay', 'NavierStokes']
    radar_chart.add('Chrome', [6395, 8212, 7520, 7218, 12464, 1660, 2123, 8607])
    radar_chart.add('Firefox', [7473, 8099, 11700, 2651, 6361, 1044, 3797, 9450])
    radar_chart.add('Opera', [3472, 2933, 4203, 5229, 5810, 1828, 9013, 4669])
    radar_chart.add('IE', [43, 41, 59, 79, 144, 136, 34, 102])
    radar_chart.render_to_file('bar_chart.svg')
    

    在这里插入图片描述

    5、基本饼图(Pie)

    import pygal
    
    pie_chart = pygal.Pie()
    pie_chart.title = 'Browser usage in February 2012 (in %)'
    pie_chart.add('IE', 19.5)
    pie_chart.add('Firefox', 36.6)
    pie_chart.add('Chrome', 36.3)
    pie_chart.add('Safari', 4.5)
    pie_chart.add('Opera', 2.3)
    pie_chart.render_to_file('bar_chart.svg')
    

    在这里插入图片描述

    6、条形图

    '''绘制竖向堆叠条形图 多图横向排列'''
    bar_chart = pygal.HorizontalStackedBar()
    # 条形图标题
    bar_chart.title = "Remarquable sequences"
    # x轴标题
    bar_chart.x_labels = map(str, range(11))
    bar_chart.add('Fibonacci', [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55])
    bar_chart.add('Padovan', [1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12])
    bar_chart.render_to_file('bar_chart.svg')
    

    在这里插入图片描述

    import pygal
    
    line_chart = pygal.Bar()
    line_chart.title = 'Browser usage evolution (in %)'
    line_chart.x_labels = map(str, range(2002, 2013))
    line_chart.add('Firefox', [None, None, 0, 16.6,   25,   31, 36.4, 45.5, 46.3, 42.8, 37.1])
    line_chart.add('Chrome',  [None, None, None, None, None, None,    0,  3.9, 10.8, 23.8, 35.3])
    line_chart.add('IE',      [85.8, 84.6, 84.7, 74.5,   66, 58.6, 54.7, 44.8, 36.2, 26.6, 20.1])
    line_chart.add('Others',  [14.2, 15.4, 15.3,  8.9,    9, 10.4,  8.9,  5.8,  6.7,  6.8,  7.5])
    line_chart.render_to_file('bar_chart.svg')
    

    在这里插入图片描述

    6、词云图

    from pyecharts import Line
    from pyecharts import Pie
    from pyecharts import WordCloud
    from pyecharts import EffectScatter, Overlap
    
    
    # 词云图
    name = [
        'Though', 'the answer', 'this question',
        'may at first', 'seem to border', 'on the',
        'absurd', 'reflection', 'will show', 'that there',
        'is a', 'good deal', 'more in', 'it than meets', 'the eye'
        ]
    value = [10000, 6189, 4556, 2356, 2233,
         1895, 1456, 1255, 981, 875,
         542, 462, 361, 265, 125]
    
    worldcloud = WordCloud(width=1300, height=620)
    worldcloud.add('词云', name, value, word_size_range=[20, 100])
    worldcloud.render('worldcloud.html')
    

    在这里插入图片描述
    参考:https://www.jb51.net/article/180024.htm

    7、柱状图

    参考:https://www.jb51.net/article/180024.htm

    from pyecharts import Bar
    # 基本柱状图
    bar = Bar("基本柱状图", "副标题")
    bar.use_theme('dark') # 暗黑色主题
    bar.add('真实成本',  # label
        ["1月", "2月", "3月", "4月", "5月", "6月"],  # 横坐标
        [5, 20, 36, 10, 75, 90],    # 纵坐标
        is_more_utils=True)  # 设置最右侧工具栏
    # bar.show_config()    # 调试输出pyecharts的js的配置信息
    bar.render('bar_demo.html') # 生成html文件
    

    在这里插入图片描述

    8、折线柱状图

    from pyecharts import Bar
    # 基本柱状图
    import math
    
    LISTS = []
    ins = []
    for i in range(100):
        LISTS.append(math.exp(2* math.sqrt(i*math.atan(i))))
        ins.append(i)
    bar = Bar("基本柱状图", "副标题")
    bar.use_theme('dark') # 暗黑色主题
    
    bar.add('真实成本',  # label
        ins,  # 横坐标
        LISTS,    # 纵坐标
        is_more_utils=True)  # 设置最右侧工具栏
    # bar.show_config()    # 调试输出pyecharts的js的配置信息
    bar.render('bar_demo.html') # 生成html文件
    

    在这里插入图片描述

    附件

    引用参考文章:
    https://www.cnblogs.com/keqipu/p/7283991.html
    https://www.cnblogs.com/keqipu/p/7283439.html
    https://www.cnblogs.com/keqipu/p/7281599.html

    Python数据可视化之基于pyecharts实现的地理图表的绘制
    https://www.jb51.net/article/214614.htm

    展开全文
  • c语言的Hello World

    千次阅读 2021-12-31 21:58:18
    C语言Hello World 入门一、Hello World1.1、当前目录下创建.c结尾的c文件1.2、编写c语言代码1.3、dos下编译运行1.4、内容解析 记录学习笔记 一、Hello World   首先创建一个文件夹用来存放代码,如下: 1.1、当前...


    记录学习笔记

    一、Hello World

      首先创建一个文件夹用来存放代码,如下:
    在这里插入图片描述

    1.1、当前目录下创建.c结尾的c文件

    在这里插入图片描述
    注意:以.c结尾的文件是c语言的源文件

    1.2、编写c语言代码

    我使用的是notepad++打开,编写一段c语言程序
    在这里插入图片描述
    必须是提前安装了gcc程序, gcc不是系统自带的。

    接下来使用dos进行编译,注意安装gcc;
    https://blog.csdn.net/xc123555/article/details/121878218?spm=1001.2014.3001.5501

    1.3、dos下编译运行

    在这里插入图片描述

    1.4、内容解析

    1.4.1、include头文件包含

    include 是告诉编译器包含一个头文件,在c语言当中,任何库函数调用都需要包含头文件
    什么是库函数:例如:printf就是一个库函数,需要使用到printf就需要导入头文件
    在c语言中,任何库函数的声明都需要提前包含库函数

    1.4.2、Main函数

    main函数是C语言的主函数,也是c语言的入口程序 , 一个c语言的程序有且只有一个主函数

    1.4.3、{ }

    c语言中的所有函数的代码都是在{ }里面包着的

    1.4.4、注释

    //代表注释,就是一个说明,没有实质的意义。 单行注释是c++语言的注释方法
    /* */ 多行注释是标准的c语言的注释方法

    1.4.5、 printf

    printf是c语言的库函数

    1.4.6、声明

    int a ;
    声明一个变量名字叫a,对于c语言,变量的名称可以自定义的。
    int不可以随意修改,它是c语言的关键字。

    1.4.7、c语言自定义名称

    1.可以使用大小写字母,下划线,数字,但是第一个字母必须是字母或者下划线,
    字母区分大小写。
    2.不能用c语言的关键字作为变量名称
    注意:c语言中每一行以;结尾。
    在这里插入图片描述

    1.4.8、printf函数

    printf是向标准输出设备输出字符串,如果要输出一个字符串:例如:
    printf(“hello world”);
    如果要输出一个整数
    printf("%d\n",3);
    1.%d表示输出一个整数,占位符
    2.\n表示输出一个回车换行

    1.4.9、return语句

    一个函数遇到return语句就终止了,return是c语言的关键字。

    二、Visual Studio创建hellowrold项目

    在这里插入图片描述

    注意:Visual Studio不是一个编译器,它是一个IDE集成环境。
    在这里插入图片描述

    展开全文
  • 18. OP-TEE中secur world和non-secure world的切换过程

    千次阅读 热门讨论 2017-05-28 20:26:37
     在secure world态或者是non-secure world态调用smc指令之后,处理器将会触发异常操作进入到monitor模式中并更新monitor模式下的CPSR, SPSR, LR,并从MVBAR寄存器中获取到monitor模式的异常中断向量表基地址,进而...
  • 每一个刚开始写java程序的时候,都会写helloworld相关的程序,其实这个程序还是很简单的,那么几年我们就来给大家讲解一下这方面的内容。一.创建Java应用程序源文件1)打开文本编辑器NotePad(记事本)【开始】→【程序...
  • 上一篇文章中我们主要介绍了vsomeip库如何编译,以及成功的运行了helloworld的程序。 这一篇主要分析helloworld程序的服务端的运行。 相关代码目录: examples/hello_world/hello_world_service_main.cpp ...
  • helloworld代码怎么写?

    千次阅读 2021-01-29 10:39:27
    public class helloworld{public static void main(String []args){System.out.println("Hello world!");}}python2:print "Hello world!"python3:print ("Hello world!")C/C++:#include int main(...
  • Hello World代码

    千次阅读 2022-02-15 12:30:25
    Hello World代码 public class Hello{ public static void main(String[] args){ System.out.print("HEllo World"); } } ​ 编译 javac Java文件 生成class文件 Java命令 运行class文件
  • World Machine 地形制作使用笔记 效果展示: 一、思维导图式笔记: 二、World Machine制作地形>>Unity使用 World Machine 界面分布: World Machine根据案例常用节点: World Machine导出...
  • HelloWorld程序编写

    千次阅读 2021-11-27 19:33:24
    配置Java环境 下载jdk 安装jdk:准备工作:在空间比较充足的盘符下新建... HelloWorld程序编写(目前在jdk的bin目录下编写) 1.编写程序(编写.java 后缀的文件) class HelloWorld{ public static void...
  • 每日一面 - JVM 何时会 Stop the world

    万次阅读 2021-01-17 08:22:49
    这个定时主要是为了一些没必要立刻 Stop the world 的任务执行,可以设置-XX:GuaranteedSafepointInterval=0关闭这个定时,我推荐是关闭。 由于 jstack,jmap 和 jstat 等命令,也就是 Signal Dispatcher 线程要处理...
  • Java 基础 —— Hello World

    万次阅读 多人点赞 2020-02-27 14:44:30
    “Hello, world"程序是指在计算机屏幕上输出“Hello, world”这行字符串的计算机程序,“hello, world”的中文意思是“你好,世界。”。因为《The C Programming Language》中使用它做为第一个演示程序,非常著名,...
  • JavaWeb的Hello World

    2016-02-22 21:34:07
    JavaWeb的Hello World,采用maven打包 出来的
  • java输出Hello World

    千次阅读 2021-02-26 09:08:13
    一、输出“Hello World!”1、新建一个java项目,点击File->New->Java Project,创建java项目的界面之后,输入项目名称wly,点击finish。2、创建好java项目之后,鼠标右键项目,选择New->Class,创建一个类...
  • 1.导入World Machine生成的高度图,创建地形(大小为2000*2000比较合适,高度需要折算)。勾选Draw Instanced。 2.打开Gaia Manager 3.选择要生成的生物群落类型 4.点击【Fit To Terrain】,确保操作范围在...
  • gazebo加载world模型

    千次阅读 2020-12-22 20:18:56
    使用launch文件启动gazebo加载world模型,或者说是将world模型加入gazebo仿真器中作为环境。 first,我们应该告诉gazebo 要加载的world文件放在哪里。并通过arg标签,设置此world文件加载时的参数。 <!--...
  • Python之Hello World的条件输出实例

    千次阅读 2021-03-17 21:50:05
    题目描述:#获得用户输入的一个整数,参考该整数值,打印输出"Hello World",要求:‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫...
  • C语言Hello world代码

    千次阅读 2021-12-27 20:10:46
    C语言Hello,world!代码 代码如下: #include int main() { printf("Hello,world!\n"); return 0; }
  • Java实现 Hello World

    千次阅读 2021-02-01 20:45:40
    Hello World记事本手写Hello Worldeclipse编辑器从零到一实现Hello World 记事本手写Hello World 1.新建Hello文本文件输入以下代码 eclipse编辑器从零到一实现Hello World
  • HelloWorld

    万次阅读 2021-02-02 15:59:49
    public class HelloWorld{ //定义一个公开的类,起名为HelloWorld /*多行注释 main方法是程序的主入口 */ public static void main(String[] args){ /* 方法体:有一行一行的“java语句”构成 每条语句必须以...
  • 超详细的Eclipse使用教程——使用Eclipse创建第一个HelloWorld!,手把手教学啊。
  • Java编写的第一个程序:HelloWorld

    千次阅读 2021-03-05 17:45:20
    原理:Java文件需要编译后才能运行,编译命令为 javac HelloWorld.java(使用javac.exe命令),编译之后会出现以.class结尾的字节码文件(HelloWorld.class)。运行的是字节码文件,运行命令为java HelloWorld在桌面上...
  • 每天一遍hello world

    千次阅读 2022-01-29 19:34:24
    每天一遍Hello World!
  • android studio上实现Hello world
  • hello world程序在Python语言中的写法及引号在Python语言中的用法
  • SpringMVC-Helloworld

    热门讨论 2015-05-05 14:58:52
    SpringMVC跑的一个HelloWorld
  • World Wind入门

    千次阅读 2018-11-01 16:49:32
    World Wind 简介 World Wind是一个虚拟地球的免费的、开源的API。World Wind使开发者可以简单快速的创建3D地球,地图和地理信息的交互式可视化。世界各地的组织可以通过World Wind来监控天气模式,可视化城市和地形...
  • JAVA的HelloWorld代码编写

    千次阅读 2021-11-14 16:39:23
    第一步:新建一个文本文档 第二步:打开代码输入代码(注意大小写,Java对大小写很敏感) 第三步:更改后缀为.java(这样这个文档就会...第六步:在Power shell窗口里输入 Javac Helloworld会输出HelloWorld...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,895,759
精华内容 758,303
关键字:

world

友情链接: MyCamera2.rar