2012年认证杯SPSSPRO杯数学建模D题(第一阶段)人机游戏中的数学模型全过程文档及程序

2012年认证杯SPSSPRO杯数学建模

减缓热岛效应

D题 人机游戏中的数学模型

原题再现：

  计算机游戏在社会和生活中享有特殊地位。游戏设计者主要考虑易学性、趣味性和界面友好性。趣味性是本质吸引力，使玩游戏者百玩不厌。网络游戏一般考虑如何搭建安全可靠、丰富多彩的交互平台。人机游戏主要是考虑如何设计模型和算法，使其难度、趣味性达到恰当的平衡，玩家感觉既有难度，又有解决的信心。设计者既要像导演，规划玩家的行为，又要加入一定随机因素，使玩家觉得不是简单重复。所以在游戏创意和模型确定下来后，参数选择和优化变得非常关键。
  现在考虑“植物大战僵尸”游戏中的一些简单模型（参赛者不必更深入地了解该游戏）。现在只有三种角色：向日葵、豌豆荚和一种僵尸。向日葵产生阳光，用鼠标点击阳光才能将其收集存储，过一定时间不点击阳光就会消失。种植向日葵和豌豆荚需要花费阳光；豌豆荚当其所在格或右侧有僵尸存在时一粒一粒地发射豌豆，每个豌豆荚内的豌豆数量无限；豌豆向右飞行，打击飞行路线上的僵尸，豌豆不受向日葵和豌豆荚的阻挡，但不能射穿僵尸；僵尸只从屏幕最右边产生，沿着直线从右向左行进，它要吃掉沿途遇到的向日葵和豌豆荚，但会被豌豆打死立即消失。僵尸走到屏幕最左边，则计算机获胜，游戏结束。屏幕上的游戏场地是横平竖直、大小相等的网格，一个格内只能种植一株豌豆荚或向日葵，但可以有任意多个僵尸。
  第一阶段问题
  假设僵尸 3 步走一个格，豌豆荚发射豌豆的频率与僵尸的步频相等，豌豆飞行 6 格的时间僵尸走一步，僵尸被 9 粒豌豆打中立即消亡。僵尸走到豌豆荚或向日葵所在的格开始吞噬，用走 3 步的时间将其吃掉。向日葵产生 1 朵阳光所用时间僵尸恰好走 4 个格，僵尸走 1 格的时间不点击阳光，阳光就会消失。2 朵阳光可以种植 1 株向日葵，4 朵阳光可以种植 1 棵豌豆荚。场地只有从左至右的 9 个格。
  1. 将以上假设用更简洁明了的方式进行复述；
  2. 场地只在最左边的 1 个格内有豌豆荚，没有向日葵和阳光。问最小多大间隔产生 1 个僵尸，计算机永远不会赢？
  3. 场地在最左边的若干格内种有豌豆荚，没有向日葵和阳光，等间隔每次产生 1 个僵尸。问最少种几棵豌豆荚，使产生僵尸的间隔最小，而计算机永远不会赢。
  4. 假设游戏开始时有 6 朵阳光，每次产生 1 个僵尸。请设置最佳的种植方案和僵尸产生方案，使计算机永远不会赢，并且游戏紧张有趣。

整体求解过程概述(摘要)

  本文从颇有新意的角度出发，重点研究“植物大战僵尸”的游戏问题。以游戏中的向日葵、豌豆荚和僵尸为讨论对象，利用数学建模的方法，对不同的游戏要求，给出合理有效的设计方案。然后，应用我们所建立的模型，求得问题 3 最优解为最少种 5 棵豌 豆荚，使僵尸产生的最小间隔为2m/v ，而计算机永远不会赢。文章的最后部分对问题 4 的三种方案进行了详细分析，选择出了最佳方案为种植 1 株向日葵和 1 棵豌豆荚。

问题分析：

  对于问题 1，要求用更简洁明了的方式对题中的假设进行复述。
  对于问题 2，题目告诉我们场地只在最左边的 1 个格内有豌豆荚，没有向日葵和阳光。要求我们求出产生 1 个僵尸的最小间隔，使得计算机永远不会赢，也就是要让僵尸永远不能吃掉豌豆荚。经过分析，我们觉得必须先计算出第一只僵尸从产生到被射死时 走过的步数以及死时所在的位置。然后就上一只僵尸还在场地上的情形，对下一只僵尸何时产生的情况进行分析，找出最小的产生间隔。
  对于问题 3，题目以场地在最左边的若干格内种有豌豆荚，没有向日葵和阳光，等间隔产生 1 个僵尸为已知条件， 让我们求出最少种几棵豌豆荚， 使产生僵尸的间隔最小，而计算机永远不会赢。本题也涉及到产生僵尸的最小间隔问题，所以我们可以在问题 2所探索出的僵尸产生的最小间隔的情况这个基础上对本题进行分析求解。分别计算出种2—8 棵豌豆荚，每一只僵尸从产生到被射死所走过的步数，以此来计算出在种植不同棵数的情况下，僵尸产生的最小间隔，通过对比，找出其中最小的间隔。
  对于问题 4，已经假设游戏开始时有 6 朵阳光，每次产生 1 个僵尸，要让我们设置最佳的种植方案和僵尸产生方案，使计算机永远不会赢，并且游戏紧张有趣。根据所给的 6 朵阳光，我们可以设置出三种不同的种植方案，然后对三种不同方案分别进行分析计算，得出最佳的方案。

模型假设：

  （1）僵尸出现的次数为无穷；
  （2）豌豆发射子弹跟僵尸进入场地是同时发生的

论文缩略图：

在这里插入图片描述

全部论文请见下方“ 只会建模 QQ名片” 点击QQ名片即可

部分程序代码：(代码和文档not free)

#1 引入需要的模块
import pygame
import random
#1 配置图片地址
IMAGE_PATH = 'imgs/'
#1 设置页面宽高
scrrr_width=800
scrrr_height =560
#1 创建控制游戏结束的状态
GAMEOVER = False
#4 图片加载报错处理
LOG = '文件:{}中的方法:{}出错'.format(__file__,__name__)
#3 创建地图类
class Map():
    #3 存储两张不同颜色的图片名称
    map_names_list = [IMAGE_PATH + 'map1.png', IMAGE_PATH + 'map2.png']
    #3 初始化地图
    def __init__(self, x, y, img_index):
        self.image = pygame.image.load(Map.map_names_list[img_index])
        self.position = (x, y)
        # 是否能够种植
        self.can_grow = True
    #3 加载地图
    def load_map(self):
         MainGame.window.blit(self.image,self.position)
#4 植物类
class Plant(pygame.sprite.Sprite):
    def __init__(self):
        super(Plant, self).__init__()
        self.live=True

    # 加载图片
    def load_image(self):
        if hasattr(self, 'image') and hasattr(self, 'rect'):
            MainGame.window.blit(self.image, self.rect)
        else:
            print(LOG)
#5 向日葵类
class Sunflower(Plant):
    def __init__(self,x,y):
        super(Sunflower, self).__init__()
        self.image = pygame.image.load('imgs/sunflower.png')
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.price = 50
        self.hp = 100
        #5 时间计数器
        self.time_count = 0

    #5 新增功能：生成阳光
    def produce_money(self):
        self.time_count += 1
        if self.time_count == 25:
            MainGame.money += 5
            self.time_count = 0
    #5 向日葵加入到窗口中
    def display_sunflower(self):
        MainGame.window.blit(self.image,self.rect)
#6 豌豆射手类
class PeaShooter(Plant):
    def __init__(self,x,y):
        super(PeaShooter, self).__init__()
        # self.image 为一个 surface
        self.image = pygame.image.load('imgs/peashooter.png')
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.price = 50
        self.hp = 200
        #6 发射计数器
        self.shot_count = 0

    #6 增加射击方法
    def shot(self):
        #6 记录是否应该射击
        should_fire = False
        for zombie in MainGame.zombie_list:
            if zombie.rect.y == self.rect.y and zombie.rect.x < 800 and zombie.rect.x > self.rect.x:
                should_fire = True
        #6 如果活着
        if self.live and should_fire:
            self.shot_count += 1
            #6 计数器到25发射一次
            if self.shot_count == 25:
                #6 基于当前豌豆射手的位置，创建子弹
                peabullet = PeaBullet(self)
                #6 将子弹存储到子弹列表中
                MainGame.peabullet_list.append(peabullet)
                self.shot_count = 0

    #6 将豌豆射手加入到窗口中的方法
    def display_peashooter(self):
        MainGame.window.blit(self.image,self.rect)

#7 豌豆子弹类
class PeaBullet(pygame.sprite.Sprite):
    def __init__(self,peashooter):
        self.live = True
        self.image = pygame.image.load('imgs/peabullet.png')
        self.damage = 50
        self.speed  = 10
        self.rect = self.image.get_rect()
        self.rect.x = peashooter.rect.x + 60
        self.rect.y = peashooter.rect.y + 15

    def move_bullet(self):
        #7 在屏幕范围内，实现往右移动
        if self.rect.x < scrrr_width:
            self.rect.x += self.speed
        else:
            self.live = False

    #7 新增，子弹与僵尸的碰撞
    def hit_zombie(self):
        for zombie in MainGame.zombie_list:
            if pygame.sprite.collide_rect(self,zombie):
                #打中僵尸之后，修改子弹的状态，
                self.live = False
                #僵尸掉血
                zombie.hp -= self.damage
                if zombie.hp <= 0:
                    zombie.live = False
                    self.nextLevel()
    #7闯关方法
    def nextLevel(self):
        MainGame.score += 20
        MainGame.remnant_score -=20
        for i in range(1,100):
            if MainGame.score==100*i and MainGame.remnant_score==0:
                    MainGame.remnant_score=100*i
                    MainGame.shaoguan+=1
                    MainGame.produce_zombie+=50



    def display_peabullet(self):
        MainGame.window.blit(self.image,self.rect)
#9 僵尸类
class Zombie(pygame.sprite.Sprite):
    def __init__(self,x,y):
        super(Zombie, self).__init__()
        self.image = pygame.image.load('imgs/zombie.png')
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.hp = 1000
        self.damage = 2
        self.speed = 1
        self.live = True
        self.stop = False
    #9 僵尸的移动
    def move_zombie(self):
        if self.live and not self.stop:
            self.rect.x -= self.speed
            if self.rect.x < -80:
                #8 调用游戏结束方法
                MainGame().gameOver()

    #9 判断僵尸是否碰撞到植物，如果碰撞，调用攻击植物的方法
    def hit_plant(self):
        for plant in MainGame.plants_list:
            if pygame.sprite.collide_rect(self,plant):
                #8  僵尸移动状态的修改
                self.stop = True
                self.eat_plant(plant)
    #9 僵尸攻击植物
    def eat_plant(self,plant):
        #9 植物生命值减少
        plant.hp -= self.damage
        #9 植物死亡后的状态修改，以及地图状态的修改
        if plant.hp <= 0:
            a = plant.rect.y // 80 - 1
            b = plant.rect.x // 80
            map = MainGame.map_list[a][b]
            map.can_grow = True
            plant.live = False
            #8 修改僵尸的移动状态
            self.stop = False



    #9 将僵尸加载到地图中
    def display_zombie(self):
        MainGame.window.blit(self.image,self.rect)
#1 主程序
class MainGame():
    #2 创建关数，得分，剩余分数，钱数
    shaoguan = 1
    score = 0
    remnant_score = 100
    money = 200
    #3 存储所有地图坐标点
    map_points_list = []
    #3 存储所有的地图块
    map_list = []
    #4 存储所有植物的列表
    plants_list = []
    #7 存储所有豌豆子弹的列表
    peabullet_list = []
    #9 新增存储所有僵尸的列表
    zombie_list = []
    count_zombie = 0
    produce_zombie = 100
    #1 加载游戏窗口
    def init_window(self):
        #1 调用显示模块的初始化
        pygame.display.init()
        #1 创建窗口
        MainGame.window = pygame.display.set_mode([scrrr_width,scrrr_height])

    #2 文本绘制
    def draw_text(self, content, size, color):
        pygame.font.init()
        font = pygame.font.SysFont('kaiti', size)
        text = font.render(content, True, color)
        return text

    #2 加载帮助提示
    def load_help_text(self):
        text1 = self.draw_text('1.按左键创建向日葵 2.按右键创建豌豆射手', 26, (255, 0, 0))
        MainGame.window.blit(text1, (5, 5))

    #3 初始化坐标点
    def init_plant_points(self):
        for y in range(1, 7):
            points = []
            for x in range(10):
                point = (x, y)
                points.append(point)
            MainGame.map_points_list.append(points)
            print("MainGame.map_points_list", MainGame.map_points_list)

    #3 初始化地图
    def init_map(self):
        for points in MainGame.map_points_list:
            temp_map_list = list()
            for point in points:
                # map = None
                if (point[0] + point[1]) % 2 == 0:
                    map = Map(point[0] * 80, point[1] * 80, 0)
                else:
                    map = Map(point[0] * 80, point[1] * 80, 1)
                # 将地图块加入到窗口中
                temp_map_list.append(map)
                print("temp_map_list", temp_map_list)
            MainGame.map_list.append(temp_map_list)
        print("MainGame.map_list", MainGame.map_list)

    #3 将地图加载到窗口中
    def load_map(self):
        for temp_map_list in MainGame.map_list:
            for map in temp_map_list:
                map.load_map()

    #6 增加豌豆射手发射处理
    def load_plants(self):
        for plant in MainGame.plants_list:
            #6 优化加载植物的处理逻辑
            if plant.live:
                if isinstance(plant, Sunflower):
                    plant.display_sunflower()
                    plant.produce_money()
                elif isinstance(plant, PeaShooter):
                    plant.display_peashooter()
                    plant.shot()
            else:
                MainGame.plants_list.remove(plant)

    #7 加载所有子弹的方法
    def load_peabullets(self):
        for b in MainGame.peabullet_list:
            if b.live:
                b.display_peabullet()
                b.move_bullet()
                # v1.9 调用子弹是否打中僵尸的方法
                b.hit_zombie()
            else:
                MainGame.peabullet_list.remove(b)

    #8事件处理

    def deal_events(self):
        #8 获取所有事件
        eventList = pygame.event.get()
        #8 遍历事件列表，判断
        for e in eventList:
            if e.type == pygame.QUIT:
                self.gameOver()
            elif e.type == pygame.MOUSEBUTTONDOWN:
                # print('按下鼠标按键')
                print(e.pos)
                # print(e.button)#左键1  按下滚轮2 上转滚轮为4 下转滚轮为5  右键 3

                x = e.pos[0] // 80
                y = e.pos[1] // 80
                print(x, y)
                map = MainGame.map_list[y - 1][x]
                print(map.position)
                #8 增加创建时候的地图装填判断以及金钱判断
                if e.button == 1:
                    if map.can_grow and MainGame.money >= 50:
                        sunflower = Sunflower(map.position[0], map.position[1])
                        MainGame.plants_list.append(sunflower)
                        print('当前植物列表长度:{}'.format(len(MainGame.plants_list)))
                        map.can_grow = False
                        MainGame.money -= 50
                elif e.button == 3:
                    if map.can_grow and MainGame.money >= 50:
                        peashooter = PeaShooter(map.position[0], map.position[1])
                        MainGame.plants_list.append(peashooter)
                        print('当前植物列表长度:{}'.format(len(MainGame.plants_list)))
                        map.can_grow = False
                        MainGame.money -= 50

    #9 新增初始化僵尸的方法
    def init_zombies(self):
        for i in range(1, 7):
            dis = random.randint(1, 5) * 200
            zombie = Zombie(800 + dis, i * 80)
            MainGame.zombie_list.append(zombie)

    #9将所有僵尸加载到地图中
    def load_zombies(self):
        for zombie in MainGame.zombie_list:
            if zombie.live:
                zombie.display_zombie()
                zombie.move_zombie()
                # v2.0 调用是否碰撞到植物的方法
                zombie.hit_plant()
            else:
                MainGame.zombie_list.remove(zombie)
    #1 开始游戏
    def start_game(self):
        #1 初始化窗口
        self.init_window()
        #3 初始化坐标和地图
        self.init_plant_points()
        self.init_map()
        #9 调用初始化僵尸的方法
        self.init_zombies()
        #1 只要游戏没结束，就一直循环
        while not GAMEOVER:
            #1 渲染白色背景
            MainGame.window.fill((255, 255, 255))
            #2 渲染的文字和坐标位置
            MainGame.window.blit(self.draw_text('当前钱数$: {}'.format(MainGame.money), 26, (255, 0, 0)), (500, 40))
            MainGame.window.blit(self.draw_text(
                '当前关数{}，得分{},距离下关还差{}分'.format(MainGame.shaoguan, MainGame.score, MainGame.remnant_score), 26,
                (255, 0, 0)), (5, 40))
            self.load_help_text()

            #3 需要反复加载地图
            self.load_map()
            #6 调用加载植物的方法
            self.load_plants()
            #7  调用加载所有子弹的方法
            self.load_peabullets()
            #8 调用事件处理的方法
            self.deal_events()
            #9 调用展示僵尸的方法
            self.load_zombies()
            #9 计数器增长，每数到100，调用初始化僵尸的方法
            MainGame.count_zombie += 1
            if MainGame.count_zombie == MainGame.produce_zombie:
                self.init_zombies()
                MainGame.count_zombie = 0
            #9 pygame自己的休眠
            pygame.time.wait(10)
            #1 实时更新
            pygame.display.update()

    #10 程序结束方法
    def gameOver(self):
        MainGame.window.blit(self.draw_text('游戏结束', 50, (255, 0, 0)), (300, 200))
        print('游戏结束')
        pygame.time.wait(400)
        global GAMEOVER
        GAMEOVER = True
#1 启动主程序
if __name__ == '__main__':
    game = MainGame()
    game.start_game()
全部论文及程序请见下方“ 只会建模 QQ名片” 点击QQ名片即可

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/514206.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【leetcode】将x减到0的最小操作数/水果成篮/找到字符串中所有字母异位词{史上最容易懂的解析}

【leetcode】将x减到0的最小操作数/水果成篮/找到字符串中所有字母异位词{史上最容易懂的解析}

文章目录 1.将x减到0的最小操作数2.水果成篮3.找到字符串中所有字母异位词 1.将x减到0的最小操作数 分析题目 x不断地减去数组两端的值 看能否减到0&#xff1b;是不是就是在问&#xff1a;nums数组中存不存在【左端右端】组成的连续区间&#xff0c;区间上数的和为x 继续分析 …
阅读更多...
EXCEL地理数据处理工具（地图任务）

EXCEL地理数据处理工具（地图任务）

版本号 作者 修订内容 发布日期 1.0 小O 更新至0705版 2022-4-28 1.1 小O 更新至0772版 2024年4月3日 一、概述 小O地图EXCEL插件版提供基于EXCEL表格进行地理数据处理、地图可视化、地图绘图等功能&#xff0c;地理工具是用户使用频率很高的功能模块。地理工具能…
阅读更多...
hadoop:案例：将顾客在京东、淘宝、多点三家平台的消费金额汇总，然后先按京东消费额排序，再按淘宝消费额排序

hadoop:案例：将顾客在京东、淘宝、多点三家平台的消费金额汇总，然后先按京东消费额排序，再按淘宝消费额排序

一、原始消费数据buy.txt zhangsan 5676 2765 887 lisi 6754 3234 1232 wangwu 3214 6654 388 lisi 1123 4534 2121 zhangsan 982 3421 5566 zhangsan 1219 36 45二、实现思路&#xff1a;先通过一个MapReduce将顾客的消费金额进行汇总&#xff0c;再通过一个MapReduce来根据金…
阅读更多...
easyExcel 模版导出 中间数据纵向延伸,并且对指定列进行合并

easyExcel 模版导出 中间数据纵向延伸,并且对指定列进行合并

想要达到的效果 引入maven引用 <dependency><groupId>com.alibaba</groupId><artifactId>easyexcel</artifactId><version>3.2.1</version></dependency> 按照要求创建模版 备注 : 模板注意 用{} 来表示你要用的变量 如果本…
阅读更多...
【Spring】使用@Bean和@Import注解配置Bean，与Bean的实例化

【Spring】使用@Bean和@Import注解配置Bean，与Bean的实例化

目录 1、bean是什么 2、配置bean 2.1、使用Bean注解配置Bean 2.2、使用Import注解配置Bean 3、实例化Bean 1、bean是什么 在 Spring 中&#xff0c;Bean 是指由 Spring 容器管理的对象。Spring IOC 容器负责创建、配置和管理这些 Bean 对象的生命周期。Spring IOC 容器会管…
阅读更多...
网络基础二——传输层协议UDP与TCP

网络基础二——传输层协议UDP与TCP

九、传输层协议 ​ 传输层协议有UDP协议、TCP协议等&#xff1b; ​ 两个远端机器通过使用"源IP"&#xff0c;“源端口号”&#xff0c;“目的IP”&#xff0c;“目的端口号”&#xff0c;"协议号"来标识一次通信&#xff1b; 9.1端口号的划分 ​ 0-10…
阅读更多...
Spring Boot中前端通过请求接口下载后端存放的Excel模板

Spring Boot中前端通过请求接口下载后端存放的Excel模板

导出工具类 package com.yutu.garden.utils;import com.baomidou.mybatisplus.core.toolkit.ObjectUtils; import org.apache.commons.io.IOUtils; import org.apache.poi.hssf.util.HSSFColor; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import org.slf4j.Logger;…
阅读更多...
06-编辑器

06-编辑器

gedit编辑器 gedit是Ubuntu系统自带的编辑器&#xff0c;可以用来轻度编辑和记录一些内容。 在终端中我们通过以下命令打开&#xff1a; gedit 要打开或者新建的文件名虽然Ubuntu的图形界面也能通过gedit打开文件&#xff0c;但是用终端打开gedit可以动用更高的权限&#xff…
阅读更多...
OpenHarmony实战开发-使用一次开发多端部署实现一多设置典型页面

OpenHarmony实战开发-使用一次开发多端部署实现一多设置典型页面

介绍 本示例展示了设置应用的典型页面&#xff0c;其在小窗口和大窗口有不同的显示效果&#xff0c;体现一次开发、多端部署的能力。 1.本示例使用一次开发多端部署中介绍的自适应布局能力和响应式布局能力进行多设备&#xff08;或多窗口尺寸&#xff09;适配&#xff0c;保…
阅读更多...
掌握机器学习新星：使用Python和Scikit-Learn进行图像识别

掌握机器学习新星：使用Python和Scikit-Learn进行图像识别

正文&#xff1a; 随着智能手机和社交媒体的普及&#xff0c;图像数据的生成速度比以往任何时候都快。为了自动化处理这些数据&#xff0c;我们需要强大的图像识别系统。机器学习提供了一种有效的方法来识别和分类图像中的对象。Scikit-Learn是一个流行的Python库&#xff0c;它…
阅读更多...
谷粒商城实战(010 缓存-解决数据一致性问题以及SpringCache的使用)

谷粒商城实战(010 缓存-解决数据一致性问题以及SpringCache的使用)

Java项目《谷粒商城》架构师级Java项目实战&#xff0c;对标阿里P6-P7&#xff0c;全网最强 总时长 104:45:00 共408P 此文章包含第166p-第p172的内容 缓存一致性问题解决 redisson使用lua脚本&#xff0c;所以的锁都保证了原子性 改之前的代码 锁的粒度越小越好 如11号…
阅读更多...
PS入门｜黑白色的图标怎么抠成透明背景

PS入门｜黑白色的图标怎么抠成透明背景

前言 抠图可以算是PS的入门必备操作&#xff0c;开始学习PS的小伙伴可以根据本帖子推荐一步步学习哦&#xff01;但切勿心急&#xff5e; 今天给小伙伴们带来&#xff1a;黑白色的图标抠图教程 抠图有很多种方法&#xff0c;但根据类型的不同&#xff0c;使用适当的方法很重…
阅读更多...
Redis底层数据结构-Dict

Redis底层数据结构-Dict

1. Dict基本结构 Redis的键与值的映射关系是通过Dict来实现的。 Dict是由三部分组成&#xff0c;分别是哈希表&#xff08;DictHashTable&#xff09;&#xff0c;哈希节点&#xff08;DictEntry&#xff09;&#xff0c;字典&#xff08;Dict&#xff09; 哈希表结构如下图所…
阅读更多...
YUNBEE云贝-2024年4月PostgreSQL PGCM认证实战培训

YUNBEE云贝-2024年4月PostgreSQL PGCM认证实战培训

课程介绍 了解关注开源技术&#xff0c;学习PG以点带面 Linux/Andriod&#xff08;操作系统&#xff09;、Apache/Tomcat&#xff08;应用服务器&#xff09;、OpenStack/KVM&#xff08;虚拟化&#xff09;、Docker/K8S&#xff08;容器化&#xff09;、Hadoop&#xff08;大…
阅读更多...
利用Python和Selenium实现定时任务爬虫

利用Python和Selenium实现定时任务爬虫

网络爬虫在信息获取、数据分析等领域发挥着重要作用&#xff0c;而定时爬虫则可以实现定期获取网站数据的功能&#xff0c;为用户提供持续更新的信息。在Python中&#xff0c;结合Selenium技术可以实现定时爬虫的功能&#xff0c;但如何设置和优化定时爬虫的执行时间是一个关键…
阅读更多...
C语言编写Linux的Shell外壳

C语言编写Linux的Shell外壳

目录 一、输出命令行 1.1 了解环境变量 1.2 获取用户名、主机名、当前路径 1.3 缓冲区改进MakeCommandLine 二、获取用户命令 2.1 读取函数的选择 2.2 细节优化 2.3 返回值 三、指令和选项分割 3.1 strtok 函数 3.2 分割实现 四、执行命令 4.1 fork 方法 4.2 进…
阅读更多...
Qt C++ | Qt 元对象系统、信号和槽及事件(第一集)

Qt C++ | Qt 元对象系统、信号和槽及事件(第一集)

01 元对象系统 一、元对象系统基本概念 1、Qt 的元对象系统提供的功能有：对象间通信的信号和槽机制、运行时类型信息和动态属性系统等。 2、元对象系统是 Qt 对原有的 C++进行的一些扩展，主要是为实现信号和槽机制而引入的， 信号和槽机制是 Qt 的核心特征。 3、要使用元…
阅读更多...
蓝桥杯嵌入式学习笔记(9):RTC程序设计

蓝桥杯嵌入式学习笔记(9):RTC程序设计

目录 前言 1. RTC介绍 2. 使用CubeMx进行源工程配置 3. 代码编程 3.1 准备工作 3.2 进行bsp_rtc.h编写 3.3 进行bsp_rtc.c编写 3.4 main.c编写 3.4.1 头文件引用 3.4.2 变量声明 3.4.3 子函数声明 3.4.4 函数实现 3.4.5 main函数编写 4. 代码实验 5. 总结 前言 因本人备赛蓝…
阅读更多...
2024年购买阿里云服务器多少钱?100元-5000元预算

2024年购买阿里云服务器多少钱?100元-5000元预算

2024年阿里云服务器租用费用&#xff0c;云服务器ECS经济型e实例2核2G、3M固定带宽99元一年&#xff0c;轻量应用服务器2核2G3M带宽轻量服务器一年61元&#xff0c;ECS u1服务器2核4G5M固定带宽199元一年&#xff0c;2核4G4M带宽轻量服务器一年165元12个月&#xff0c;2核4G服务…
阅读更多...
IntelliJ IDEA中文---强化智能编码与重构，提升开发效率

IntelliJ IDEA中文---强化智能编码与重构，提升开发效率

IntelliJ IDEA 2023是一款功能强大的集成开发环境&#xff08;IDE&#xff09;&#xff0c;专为Java开发人员设计。它支持智能代码编辑、自动补全和重构&#xff0c;帮助开发者提高编码效率。同时&#xff0c;内置了丰富的调试工具&#xff0c;支持断点调试和变量监视&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023