房间匹配机制--自走旗

最新推荐文章于 2024-02-26 15:06:41 发布
最新推荐文章于 2024-02-26 15:06:41 发布
阅读量2k 收藏 5
点赞数 1
分类专栏： 随笔
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglu_1024/article/details/89397349
版权

       从去年年底开始，dota自走旗火了。国产手游厂商纷纷效仿，都想在手游上分一杯羹。我们自然也不例外，只可惜曾经还不错的数据已经快要被梦塔防、龙渊代理的快冲击完了，其实主要还是自己作死了一波。作为程序，还是把其中一些机制总结一下。

       房间匹配机制：目前的匹配机制是，按照房间匹配，也就是说，当玩家自由匹配的时候，会查找仍然有空位的房间，将玩家放进去，但是目前侠客的匹配机制有一点有待优化，如果玩家首先点击自有匹配，此时服务器上没有空余房间，将为玩家创建一个房间，这个房间只有该玩家一个人。此时另一个之前创建好的房间点击开始匹配，并不会将这两个房间的玩家合并到一个房间。虽然对于玩家这样的操作是不可见的，但是对于服务器程序来说，心里还是有个梗的。

        解决方法：在匹配检测的地方，增加一个匹配预处理的函数，该函数的主要功能就是将玩家聚拢。

        实现方法：开辟一个数组，数组每个元素是一个set。遍历两次所有玩家房间的集合，第一次将所有玩家房间按照人数放进我们开辟的数组当中，这样得到的就是：vector<set<uint>>  vector的下标就是对应玩家数量，set集合中就是这些玩家数量的房间的集合，如下图。第二步，处理这个数组。

①两个位置标量，一个从数组头开始，一个从数组尾开始。

②两个标量的房间人数相加，大于最大房间人数，最大标量减一。等于最大房间人数，合并。小于最大房间人数，合并，然后最大房间人数减去合并完的房间人数，再去找剩余人数的下标的集合是否有房间，有的话，刚好合并完这三个房间就是房间最大人数。此处存在一个优化点，最大房间人数减去合并完的房间人数，应该扫描多次。因为如果极端情况，房间人数全是1。

③合并房间人数，删除，插入。

处理代码：

        因为代码是在内网，外网就将该模块抽出来，写了个简单例子，可以正常运行，但是没有大量测试，还是主要看思路吧。

#ifndef _MATCH_H_
#define _MATCH_H_

#include <map>
#include <set>
#include <list>
#include <time.h>
#include <vector>
#include <iostream>
using namespace std;
#define MAX_ROOM_NUM 3
#define uint unsigned int

enum ROOM_TYPE
{
	ROOM_PUBLIC = 1,
	ROOM_PRIVATE = 2,
};

class CTime
{
public:
	static CTime &getMe()
	{
		if (NULL == instance)
		{
			instance = new CTime();
			if (NULL == instance)
				exit(1);
		}
		return *instance;
	}
	uint getNowTime()
	{
		time_t tmp;
		time(&tmp);
		return (uint)tmp;
	}
	uint getThisId()
	{
		uint uiNowSec = getNowTime();
		if (uiNowSec != uiBeforeTime)
		{
			uiBeforeTime = uiNowSec;
			uiMaxNumSec = 0;
		}
		return (uiBeforeTime << 14) + (++uiMaxNumSec);
	}
private:
	//上一次时间戳
	uint uiBeforeTime;
	//每秒最大累加数
	uint uiMaxNumSec;
	static CTime *instance;
	CTime():uiBeforeTime(0), uiMaxNumSec(0)
	{}
};
struct CRoom
{
	uint uiRoomNum;
	uint uiCreateTime;
	uint uiRoomType;
	std::multiset<uint> setRoomMember;

	CRoom(uint uiRoomtype = ROOM_PUBLIC)
	{
		uiRoomType = uiRoomtype;
		uiRoomNum = CTime::getMe().getThisId();
		uiCreateTime = CTime::getMe().getNowTime();
	}
};
class CMatchManager
{
public:
	static CMatchManager &getMe()
	{
		if (NULL == instance)
		{
			instance = new CMatchManager();
			if (NULL == instance)
			{
				exit(1);
			}
		}
		return *instance;
	}
	uint createRoomPub(uint uiCreateId)
	{
		//不在房间
		if (m_mapUserRoom.find(uiCreateId) != m_mapUserRoom.end())
		{
			return 0;
		}
		CRoom croom(ROOM_PUBLIC);
		croom.setRoomMember.insert(uiCreateId);
		m_mapWaitingRoom.insert(std::make_pair(croom.uiRoomNum, croom));
		m_mapUserRoom.insert(std::make_pair(uiCreateId, croom.uiRoomNum));
		std::cout << "create publicroom success,user:" << uiCreateId << ",room:" << croom.uiRoomNum << std::endl;
		return croom.uiRoomNum;
	}
	uint createRoomPri(uint uiCreateId)
	{
		if (m_mapUserRoom.find(uiCreateId) != m_mapUserRoom.end())
		{
			return 0;
		}
		CRoom croom(ROOM_PRIVATE);
		croom.setRoomMember.insert(uiCreateId);
		m_mapWaitingRoom.insert(std::make_pair(croom.uiRoomNum, croom));
		m_mapUserRoom.insert(std::make_pair(uiCreateId, croom.uiRoomNum));
		std::cout << "create privateroom success,user:" << uiCreateId << ",room:" << croom.uiRoomNum << std::endl;
		return croom.uiRoomNum;
	}
	void intoRoomByRoomId(uint uiRoomid, uint uiRoleid)
	{
		if (m_mapUserRoom.find(uiRoleid) != m_mapUserRoom.end())
		{
			std::cout << "error: user have room" << std::endl;
			return;
		}
		auto it = m_mapWaitingRoom.find(uiRoomid);
		if (it == m_mapWaitingRoom.end())
		{
			std::cout << "error: into room error" << std::endl;
			return;
		}
		it->second.setRoomMember.insert(uiRoleid);
	}
	void changeRoomType(uint uiRoomid, uint uiRoleid, ROOM_TYPE type)
	{
		auto it = m_mapWaitingRoom.find(uiRoomid);
		if (it == m_mapWaitingRoom.end())
		{
			std::cout << "error: room not exists" << std::endl;
			return;
		}
		if (0 == (uint)it->second.setRoomMember.size())
		{
			std::cout << "error: room number size is 0" << std::endl;
			return;
		}
		if (uiRoleid != *(it->second.setRoomMember.begin()))
		{
			std::cout << "error: you aren't room creater" << std::endl;
			return;
		}
		it->second.uiRoomType = type;
	}
	void beginMatch(uint uiRoleid)
	{
		//是否有房间
		auto it = m_mapUserRoom.find(uiRoleid);
		if (it == m_mapUserRoom.end())
		{
			if (m_setMatchingUser.find(uiRoleid) == m_setMatchingUser.end())
			{
				m_setMatchingUser.insert(uiRoleid);
			}
		}
		else
		{
			auto itroom = m_mapWaitingRoom.find(it->second);
			if (itroom == m_mapWaitingRoom.end())
			{
				std::cout << "error: room not exists" << std::endl;
			}
			//private房间
			else if (ROOM_PRIVATE == itroom->second.uiRoomType)
			{
				if (1 < (uint)itroom->second.setRoomMember.size())
				{
					beginGameWaiting(itroom);
				}
			}
			//房间人数已满
			else if (MAX_ROOM_NUM <= (uint)itroom->second.setRoomMember.size())
			{
				beginGameWaiting(itroom);
			}
			//未满 匹配
			else
			{
				m_mapMatchingRoom.insert(std::make_pair(itroom->second.uiRoomNum, itroom->second));
				m_mapWaitingRoom.erase(itroom++);
			}
		}
		checkMatch();
	}
	void checkMatch()
	{
		//房间优先
		auto it = m_mapMatchingRoom.begin();
		for (; it != m_mapMatchingRoom.end(); ++it)
		{
			if (ROOM_PRIVATE == it->second.uiRoomType)
			{
				beginGameMatching(it);
				continue;
			}
			if (MAX_ROOM_NUM <= (uint)it->second.setRoomMember.size())
			{
				beginGameMatching(it);
				continue;
			}
			if (m_setMatchingUser.empty())
			{
				break;
			}
			bool bFlag = false;
			auto ituser = m_setMatchingUser.begin();
			for (; ituser != m_setMatchingUser.end(); )
			{
				it->second.setRoomMember.insert(*ituser);
				m_setMatchingUser.erase(ituser++);
				if (MAX_ROOM_NUM <= (uint)it->second.setRoomMember.size())
				{
						beginGameMatching(it);
						bFlag = true;
						break;
				}
			}
			if (bFlag)
				break;
		}
		if(it == m_mapMatchingRoom.end())
		{
			//查找玩家集合，合并
			while (MAX_ROOM_NUM <= (uint)m_setMatchingUser.size())
			{
				CRoom croom(ROOM_PUBLIC);
				int i = 0;
				for (auto ittmp = m_setMatchingUser.begin(); i < MAX_ROOM_NUM && ittmp != m_setMatchingUser.end(); ++i)
				{
					croom.setRoomMember.insert(*ittmp);
					m_setMatchingUser.erase(ittmp++);
				}
				beginGame(croom);
			}
		}
		else
		{
			///
			//开辟数组，每个元素是对应下标房间人数的集合，然后两个下标，一个前一个后，
			//优先合并相加等于房间最大人数的多个房间，剩余的，可以合并则合并
			///
			//查找多个房间，合并    vector<set<roomid>>
			std::vector<std::multiset<uint>> veTmp;
			for (int i = 0; i < MAX_ROOM_NUM; ++i)
			{
				std::multiset<uint> setTmp;
				veTmp.push_back(setTmp);
			}
			for (it = m_mapMatchingRoom.begin(); it != m_mapMatchingRoom.end(); )
			{
				if (it->second.setRoomMember.empty())
				{
					m_mapMatchingRoom.erase(it++);
				}
				else
				{
					veTmp[(uint)it->second.setRoomMember.size() - 1].insert(it->second.uiRoomNum);
					++it;
				}
			}

			//Begin和End前后相向走，遇到合适的就合并
			std::vector<std::vector<uint>> vecComRoom;
			uint uiBegin = 0;
			uint uiEnd = MAX_ROOM_NUM - 1;
			while (uiBegin < uiEnd)
			{
				while (uiBegin < uiEnd && veTmp[uiBegin].empty()) uiBegin++;
				if (uiBegin >= uiEnd) break;
				while (uiBegin < uiEnd && veTmp[uiEnd].empty()) uiEnd--;
				if (uiBegin >= uiEnd) break;

				if (uiBegin + uiEnd > MAX_ROOM_NUM)
				{
					uiEnd--;
					continue;
				}
				else if (uiBegin + uiEnd == MAX_ROOM_NUM)
				{
					for (auto itbegin = veTmp[uiBegin].begin(); itbegin != veTmp[uiBegin].end(); )
					{
						auto itend = veTmp[uiEnd].begin();
						if (itend != veTmp[uiEnd].end())
						{
							std::vector<uint> vec;
							vec.push_back(*itend);
							vec.push_back(*itbegin);
							veTmp[uiBegin].erase(itbegin++);
							veTmp[uiEnd].erase(itend++);
							vecComRoom.push_back(vec);
						}
						else
						{
							++itbegin;
						}
					}
				}
				else
				{
					for (auto itbegin = veTmp[uiBegin].begin(); itbegin != veTmp[uiBegin].end(); )
					{
						auto itend = veTmp[uiEnd].begin();
						if (itend != veTmp[uiEnd].end())
						{
							std::vector<uint> vec;
							vec.push_back(*itend);
							vec.push_back(*itbegin);
							veTmp[uiBegin].erase(itbegin++);
							veTmp[uiEnd].erase(itend++);
							//查找最后符合的
							uint uiSub = MAX_ROOM_NUM - uiBegin - uiEnd;
							auto itsub = veTmp[uiSub].begin();
							if (itsub != veTmp[uiSub].end())
							{
								vec.push_back(*itsub);
							}
							vecComRoom.push_back(vec);
						}
						else
						{
							++itbegin;
						}
					}
				}
			}
			if (0 < uiBegin && uiBegin <= MAX_ROOM_NUM / 2 && !veTmp[uiBegin].empty())
			{
				uint uiNum = 0;
				std::vector<uint> vec;
				for (auto it = veTmp[uiBegin].begin(); it != veTmp[uiEnd].end(); ++it)
				{
					if (2 == uiNum)
					{
						vecComRoom.push_back(vec);
						vec.clear();
						uiNum = 0;
					}
					vec.push_back(*it);
					uiNum += 1;
				}
				if (!vec.empty())
				{
					vecComRoom.push_back(vec);
				}
			}
			/*
			//前后先查找一遍，将符合的提出来，然后在走一遍，每次叠加，找到叠加值的互补值
			for (uint i = 0; i < MAX_ROOM_NUM; ++i)
			{
				if (veTmp[i].empty())
				{
					continue;
				}
				if (veTmp[MAX_ROOM_NUM - i - 1].empty())
				{
					continue;
				}
				auto itroomfirst = veTmp[i].begin();
				auto itroomsecond = veTmp[MAX_ROOM_NUM - i - 1].begin();
				while (itroomfirst != veTmp[i].end() && itroomsecond != veTmp[MAX_ROOM_NUM - i - 1].end())
				{
					uint uitmpfirst = *itroomfirst;
					auto ittmpfirst = m_mapMatchingRoom.find(uitmpfirst);
					uint uitmpsecond = *itroomsecond;
					auto ittmpsecond = m_mapMatchingRoom.find(uitmpsecond);
					if (ittmpfirst == m_mapMatchingRoom.end() || ittmpsecond == m_mapMatchingRoom.end())
					{
						continue;
					}

				}
			}*/
			mergeRoom(vecComRoom);
		}
	}
	void mergeRoom(std::vector<std::vector<uint>> &vecComRoom)
	{
		for (uint dwI = 0; dwI < vecComRoom.size(); ++dwI)
		{
			uint uiRoomid = (uint)-1;
			for (uint dwJ = 0; dwJ < vecComRoom[dwI].size(); ++dwJ)
			{
				if ((uint)-1 == uiRoomid)
				{
					uiRoomid = vecComRoom[dwI][dwJ];
					continue;
				}
				auto it = m_mapMatchingRoom.find(uiRoomid);
				auto ittmp = m_mapMatchingRoom.find(vecComRoom[dwI][dwJ]);
				if (it == m_mapMatchingRoom.end() || ittmp == m_mapMatchingRoom.end())
				{
					break;
				}
				for (auto itnow = ittmp->second.setRoomMember.begin(); itnow != ittmp->second.setRoomMember.end(); ++itnow)
				{
					auto itindex = m_mapMatchingRoom.find(*itnow);
					if (itindex == m_mapMatchingRoom.end())
					{
						return;
					}
					m_mapMatchingRoom.erase(itindex);
					it->second.setRoomMember.insert(*itnow);
				}
			}
		}
	}
	//beginGame
	void beginGameWaiting(std::map<uint, CRoom>::iterator &itroom)
	{
		if (itroom != m_mapWaitingRoom.end())
		{
			std::cout << "into game success" << std::endl;
			std::cout << "-------------------" << std::endl;
			for (auto &it : itroom->second.setRoomMember)
			{
				cout << "user: " << it << endl;
			}
			std::cout << "-------------------" << std::endl;
			itroom = m_mapWaitingRoom.erase(itroom);
		}
	}
	void beginGameMatching(std::map<uint, CRoom>::iterator &itroom)
	{
		if (itroom != m_mapMatchingRoom.end())
		{
			std::cout << "into game success" << std::endl;
			std::cout << "-------------------" << std::endl;
			for (auto &it : itroom->second.setRoomMember)
			{
				cout << "user: " << it << endl;
			}
			std::cout << "-------------------" << std::endl;
			itroom = m_mapMatchingRoom.erase(itroom);
		}
	}
	std::multiset<uint>::iterator beginGame(std::multiset<uint>::iterator ituser)
	{
		if (ituser != m_setMatchingUser.end())
		{
			std::cout << "into game success" << std::endl;
			std::cout << "-------------------" << std::endl;
			cout << "user: " << *ituser << endl;
			std::cout << "-------------------" << std::endl;
			m_setMatchingUser.erase(ituser++);
		}
		return ituser;
	}
	void beginGame(CRoom &croom)
	{
		std::cout << "into game success" << std::endl;
		std::cout << "-------------------" << std::endl;
		for (auto &it : croom.setRoomMember)
		{
			cout << "user: " << it << endl;
		}
		std::cout << "-------------------" << std::endl;
	}
private:
	//正在匹配房间 <roomid, room>
	std::map<uint, CRoom> m_mapMatchingRoom;
	//<userid, roomid>
	std::map<uint, uint> m_mapUserRoom;
	//未匹配房间  <roomid, room>
	std::map<uint, CRoom> m_mapWaitingRoom;
	//玩家等待列表
	std::multiset<uint> m_setMatchingUser;
	static CMatchManager *instance;
	CMatchManager() {}
};

#endif // !_MATCH_H_

测试文件：

#include "match.h"
#include <iostream>
using namespace std;
CTime *CTime::instance = NULL;
CMatchManager *CMatchManager::instance = NULL;

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <math.h>
using namespace std;
int main()
{
	uint uiRoomid = CMatchManager::getMe().createRoomPri(10);
	CMatchManager::getMe().beginMatch(10);
	CMatchManager::getMe().intoRoomByRoomId(uiRoomid, 11);
	CMatchManager::getMe().beginMatch(10);
	CMatchManager::getMe().createRoomPub(12);
	CMatchManager::getMe().beginMatch(12);
	CMatchManager::getMe().beginMatch(13);
	CMatchManager::getMe().beginMatch(14);


	//for (uint i = 10; i < 30; ++i)
	{
		//CMatchManager::getMe().beginMatch(i);
	}
	return 0;
}

        关于侠客自走旗，前两个月，数据都还可以。现在如此情景，其实挺遗憾的，但是也不遗憾。毕竟对于我而言，并不遗憾。

zhanglu_1024
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java游戏房间匹配_游戏匹配和结算实现
weixin_31520435的博客
02-26 1232
匹配匹配.png//请求匹配message CM_Match {int type; //匹配房间类型String name; //玩家名称long targetPlayerId; //加入他人比赛，目标玩家id}//匹配成功message L2RM_MatchSucc {int roomId;int roomType;boolean createRoomIfNotExist; //场景中的第一个...
RoommateMatching:科技写作室友匹配算法的实现
06-02
室友配对 科技写作室友匹配算法的实现
十万人在线的房间和匹配系统
奎特尔星球
05-26 598
3 月底，腾讯云发布公告 MGOBE 将于 2022 年 6 月 1 日正式下线，也给不少开发者带来一些困扰。没有了 MGOBE，还有哪些替代方案？本篇文章，将在上次的分享基础上介绍，如何利用 TSRPC 实现 MGOBE 同款的房间系统和匹配系统，并利用分布式架构轻松支持十万人同时在线。需求首先来看看我们的需求：房间系统：支持开房间，同时进行多局游戏匹配系统：支持随机匹...
有房间匹配和无房间匹配
金庆的专栏
04-09 925
有房间匹配和无房间匹配 (金庆的专栏 2020.4) 网游的匹配可以分为2种：有房间匹配和无房间匹配。 有房间匹配 请求匹配即搜索并加入一个房间，或者开一个新房间。 匹配过程中可以看到房间人数增加。 可以列出其他房间，加入指定房间，如棋牌类大厅 可以无需等待人满即开始，开始后还可以继续加人 无房间匹配 请求匹配即进入等待状态，匹配成功才能看到所有人 匹配成功, 如人满了, 才可以进入游戏...
PHP 游戏房间匹配demo2
03-30
PHP 游戏 房间匹配demo2
模糊匹配--递归遍历文件
08-22
boost库的regex正则表达式实现文件递归模糊匹配搜索
影像匹配-------相关系数法
05-01
总的来说，影像匹配-------相关系数法是一种实用的影像分析技术，通过OpenCV库的实现，可以方便地在各种应用场景中进行图像匹配。通过学习和理解这个项目，不仅可以掌握相关系数匹配的基本原理，还能提升在实际项目...
天线阻抗匹配 Non-Foster_Reactance_Matching
09-17
在无线通信领域，天线阻抗匹配是一个至关重要的概念，它直接影响到天线与传输线之间的能量传输效率。"Non-Foster Reactance Matching"是一种特殊的阻抗匹配技术，旨在解决传统Foster网络无法应对的高速、宽频或负...
游戏设计------匹配模块设计
wangdamingll的博客
10-21 1100
一、背景 游戏的匹配模块可谓是游戏设计中比较重要的模块了,MMO游戏基本上都有这个模块,但是要想写的比较好确是不容易,下面简单谈谈如何设计. 这里提到的设计只是简单抽象的,并不是适合所有游戏 二、匹配模块 1. 部分服务架构图 2. 匹配流程图 3. 匹配房间状态机 4. 匹配模块设计UML类图 三、总结 上面匹配模块体现了部分设计模式思想,比如,MatchApp只针对Queue抽象编程,具体的匹配逻辑也是针对Queue编程,体现了解耦的思想,而不是乱糟糟的写到一起 ...
FPS游戏之漫谈房间匹配流程
最新发布
听老罗娓娓道来
02-26 273
FPS游戏的房间匹配流程一般包括以下步骤：
棋牌游戏服务器架构
JunChow
02-22 4821
特点 不分区不分服：具有随着用户量增加而扩展的需求 房间模式：同一局游戏就是在同一个房间中，同一个房间中的人可以接收到其他人的消息。 房间的操作具有顺序性：类似回合制游戏，每个玩家的操作都是由顺序的。 每个游戏服务器相当于一个模块，运行一个进程，在启动时会连接网关。 关键点 数据共享如何实现 由于棋牌类不分区不分服，一般都会按世界服的思路来设计，也就是说，服务器是一个由多台...
java游戏房间匹配_一种游戏房间匹配方法与流程
weixin_36132709的博客
02-26 990
本发明涉及计算机技术领域，尤其涉及一种游戏房间匹配方法。背景技术：在目前的网络游戏中，游戏对象与游戏对象会通过互联网在线上进行竞技比赛，很多时候都需要多名玩家共同参与，现有的游戏对象的配对方法大多是由一名玩家创建房间，再邀请其他玩家或通过查找房间号进入房间，即使玩家面对面也无法快速的加入同一场游戏中，还容易被其他玩家抢先进入游戏房间，影响游戏的开始。技术实现要素：本发明所要解决的技术问题是克服现有...
实时联网游戏后台服务技术选型和挑战（房间匹配与数据同步篇）
weixin_34007886的博客
05-07 815
在此前的《网络接入篇》中我们介绍了实时联网游戏网络接入相关内容，网络接入层开发考验的是开发者高性能网络编程的功底，即解决C10K甚至C10M的能力。本文开始介绍游戏逻辑层，由于不同游戏玩法千奇百怪，本文不涉及游戏具体的业务逻辑，只探讨在逻辑层实现中经常遇到的房间匹配和数据同步问题。 基于“房间”模式的联网对战游戏，游戏流程可分为匹配（matchmaking）和 对战(gameplay)两个阶段。匹...
客户端版本与房间版本不匹配_《绝地求生》新版本来临：匹配机制改动，仅亚服中国玩家可以参与...
weixin_42222501的博客
12-27 236
近日《绝地求生》游戏发布了9.2版本的更新内容，今天为大家细讲一下在下版本中即将更新的新通行证，新系统与新载具：《绝地求生》游戏——新功能：越野摩托车万众瞩目的越野摩托来了！这款摩托在体积上很小，但是速度马力却是游戏里数一数二的，在新版中这款小摩托会在除了卡拉金之外所有地图上刷新！ 《绝地求生》游戏——新功能：驾驶席射击在吃鸡中你是否最怕遇见猪队友，尤其是开车时如果有一个不会打人的队友可以说是能气...
java游戏房间匹配_游戏匹配实现
weixin_39618806的博客
02-26 1355
设计思路客户端向服务器发送匹配请求，服务端接收后将客户端Session放入匹配队列中，匹配完成时通知用户。使用观察者设计模式可以实现这个功能。代码观察者代码：Java util 包拥有Observer 接口，这里根据实际应用自定义参数 Map。import java.util.Map;​public interface Observer {​public void update(Map map);...
正则表达式匹配1-100的整数
06-09
可以使用如下正则表达式来匹配1-100的整数： `^(?!0\d)\d{1,2}$|^(?!100$)100$` 解释： - `^` 匹配字符串的开头 - `(?!0\d)` 负向零宽断言，表示不匹配以0开头的数字 - `\d{1,2}` 匹配1-99的数字 - `|` 或 - `(?!100$)` 负向零宽断言，表示不匹配100 - `100` 匹配100 - `$` 匹配字符串的结尾 将两个正则表达式用 `|` 连接起来，即可匹配1-100的整数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值