0101直播 密码是0101+(当年日期)。

荒野头像随便拿。 拿走记得发站内消息跟我吱一声。 这里有很多头像

一些游戏。

https://www.crazygames.com/

宝玩

https://cpsgames.org/!

国际象棋

超级猫里奥

植物大战僵尸网页版

狗狗刺杀

å∫ç∂´ƒ©˙ˆ∆˚¬µ˜øπœ®ß†¨√∑≈¥Ω 输出26个字母同时按住option键

（一）定义 栈（Stack）是一种遵循后进先出（Last - In - First - Out，LIFO）原则的线性数据结构。 （二）关键术语 栈顶（Top）：栈中可进行插入和删除操作的一端，最新元素所在位置。 栈底（Bottom）：栈中固定的一端，最早进入栈的元素所在位置。 入栈（Push）：向栈顶添加元素的操作。 出栈（Pop）：移除栈顶元素的操作。 栈溢出（Stack Overflow）：当栈已满还进行入栈操作时发生的错误。 栈下溢（Stack Underflow）：当栈为空还进行出栈操作时发生的错误。 （三）栈的实现 数组实现：

1. 实现思路 使用数组来存储栈中的元素，通过一个变量 top 记录栈顶的位置。数组大小在创建栈时确定，当 top 达到数组最大下标时栈满，top 为 -1 时栈空。
2. 代码示例

#include <iostream>
using namespace std;
const int MAX_SIZE = 100;
class ArrayStack {
private:
    int arr[MAX_SIZE];
    int top;
public:
    // 构造函数，初始化栈顶位置
    ArrayStack() : top(-1) {}

    // 判断栈是否为空
    bool isEmpty() const {
        return top == -1;
    }

    // 判断栈是否已满
    bool isFull() const {
        return top == MAX_SIZE - 1;
    }

    // 入栈操作
    void push(int value) {
        if (isFull()) {
            cout << "Stack Overflow!" << endl;
            return;
        }
        arr[++top] = value;
    }

    // 出栈操作
    int pop() {
        if (isEmpty()) {
            cout << "Stack Underflow!" << endl;
            return -1;
        }
        return arr[top--];
    }

    // 查看栈顶元素
    int peek() const {
        if (isEmpty()) {
            cout << "Stack is empty!" << endl;
            return -1;
        }
        return arr[top];
    }
};

3. 复杂度分析 入栈（Push）：时间复杂度为 O(1)，因为只涉及到 top 指针的更新和数组元素的赋值。 出栈（Pop）：时间复杂度为 O(1)，只需更新 top 指针。 查看栈顶（Peek）：时间复杂度为 O(1)，直接访问数组元素。空间复杂度：O(n)，其中 n是数组的最大容量。 （四）链表实现 1.实现思路 使用链表来存储栈中的元素，链表的头节点作为栈顶。入栈操作相当于在链表头部插入新节点，出栈操作相当于删除链表的头节点。 2.代码示例

#include <iostream>
using namespace std;
// 定义链表节点
struct Node {
    int data;
    Node* next;
    Node(int value) : data(value), next(nullptr) {}
};

class LinkedStack {
private:
    Node* top;
public:
    // 构造函数，初始化栈顶指针
    LinkedStack() : top(nullptr) {}

    // 判断栈是否为空
    bool isEmpty() const {
        return top == nullptr;
    }

    // 入栈操作
    void push(int value) {
        Node* newNode = new Node(value);
        newNode->next = top;
        top = newNode;
    }

    // 出栈操作
    int pop() {
        if (isEmpty()) {
            cout << "Stack Underflow!" << endl;
            return -1;
        }
        int value = top->data;
        Node* temp = top;
        top = top->next;
        delete temp;
        return value;
    }

    // 查看栈顶元素
    int peek() const {
        if (isEmpty()) {
            cout << "Stack is empty!" << endl;
            return -1;
        }
        return top->data;
    }

    // 析构函数，释放链表内存
    ~LinkedStack() {
        while (!isEmpty()) {
            pop();
        }
    }
};

3. 复杂度分析 入栈（Push）：时间复杂度为 O(1)，主要是创建新节点和更新指针。 出栈（Pop）：时间复杂度为 O(1)，包含指针更新和节点内存释放。 查看栈顶（Peek）：时间复杂度为 O(1)，直接访问头节点数据。 空间复杂度：O(n)，其中 n 是栈中元素的数量。 (五)、栈的常见操作及使用示例 （1）入栈（Push） // 以数组实现的栈为例

ArrayStack stack;
stack.push(10);
stack.push(20);

（2）出栈（Pop）

int poppedValue = stack.pop();
if (poppedValue != -1) {
    cout << "Popped value: " << poppedValue << endl;
}

（3）查看栈顶（Peek）

int topValue = stack.peek();
if (topValue != -1) {
    cout << "Top value: " << topValue << endl;
}

（4）判断栈空（IsEmpty）

if (stack.isEmpty()) {
    cout << "Stack is empty." << endl;
} else {
    cout << "Stack is not empty." << endl;
}```

三、set 容器介绍
（一）基本概念
set 是一个有序的集合容器，它基于红黑树（一种自平衡的二叉搜索树）实现。元素在 set 中会按照一定的顺序自动排序，默认是升序。
（二）头文件包含
要使用 set，需要包含 头文件，示例代码如下：
#include <set>
（三）声明和初始化
以下是一个声明并初始化 set 容器，然后插入元素并遍历的示例：

#include <iostream>
#include <set>
using namespace std;
int main() {
    // 声明一个存储整数的 set
    set<int> mySet;

    // 插入元素
    mySet.insert(3);
    mySet.insert(1);
    mySet.insert(2);

    // 遍历 set
    for (auto it = mySet.begin(); it != mySet.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}
（四）输出结果
上述代码的输出结果为：
1 2 3
可以看到，元素会自动按照升序排列。
四、set 的常见操作
（一）插入元素
使用 insert 方法向 set 中插入元素，示例如下：

set<int> mySet;
mySet.insert(5);
mySet.insert(10);
（二）查找元素
使用 find 方法查找元素，若找到则返回指向该元素的迭代器，若未找到则返回 end() 迭代器，示例如下：

auto it = mySet.find(5);
if (it != mySet.end()) {
    cout << "Element found!" << endl;
} else {
    cout << "Element not found!" << endl;
}
（三）删除元素
使用 erase 方法删除元素，示例如下：

mySet.erase(5);
（四）获取元素数量
使用 size 方法获取 set 中元素的数量，示例如下：

size_t size = mySet.size();
五、unordered_set 容器介绍
（一）基本概念
unordered_set 是一个无序的集合容器，它基于哈希表实现。元素在 unordered_set 中没有特定的顺序，插入和查找操作的平均时间复杂度为 。
（二）头文件包含
要使用 unordered_set，需要包含 <unordered_set> 头文件，示例代码如下：

#include <unordered_set>
（三）声明和初始化
以下是一个声明并初始化 unordered_set 容器，然后插入元素并遍历的示例：

#include <iostream>
#include <unordered_set>

int main() {
    // 声明一个存储整数的 unordered_set
    unordered_set<int> myUnorderedSet;

    // 插入元素
    myUnorderedSet.insert(3);
    myUnorderedSet.insert(1);
    myUnorderedSet.insert(2);

    // 遍历 unordered_set
    for (auto it = myUnorderedSet.begin(); it != myUnorderedSet.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}
（四）输出结果
元素输出顺序不确定，例如可能是：
3 1 2
六、unordered_set 的常见操作
（一）插入元素
使用 insert 方法向 unordered_set 中插入元素，示例如下：

unordered_set<int> myUnorderedSet;
myUnorderedSet.insert(5);
myUnorderedSet.insert(10);
（二）查找元素
使用 find 方法查找元素，若找到则返回指向该元素的迭代器，若未找到则返回 end() 迭代器，示例如下：

auto it = myUnorderedSet.find(5);
if (it != myUnorderedSet.end()) {
    cout << "Element found!" << endl;
} else {
    cout << "Element not found!" << endl;
}
（三）删除元素
使用 erase 方法删除元素，示例如下：

myUnorderedSet.erase(5);
（四）获取元素数量
使用 size 方法获取 unordered_set 中元素的数量，示例如下：

size_t size = myUnorderedSet.size();
七、set 和 unordered_set 的性能比较
205f200699571ff292bff0be89f81adf.png
性能分析
set 基于红黑树，插入、查找和删除操作的时间复杂度为
?
(
?
?
?
?
)
O(logn) ，但元素是有序的。
unordered_set 基于哈希表，插入、查找和删除操作的平均时间复杂度为
?
(
1
)
O(1) ，但元素是无序的，且在最坏情况下（哈希冲突严重）时间复杂度会退化为 
?
(
?
)
O(n)。
八、选择合适的容器
（一）需要有序元素
如果需要元素按照一定的顺序存储，例如升序或降序，应该选择 set。

set<int> sortedSet;
sortedSet.insert(3);
sortedSet.insert(1);
sortedSet.insert(2);
// 元素会自动按升序排列
（二）对性能要求高
如果对插入、查找和删除操作的性能要求较高，且不关心元素的顺序，应该选择 unordered_set。

unordered_set<int> fastSet;
fastSet.insert(3);
fastSet.insert(1);
fastSet.insert(2);
// 插入和查找操作平均时间复杂度为 O(1)
九、实际案例：去重
（一）使用 set 去重

#include <iostream>
#include <set>
#include <vector>

int main() {
    vector<int> numbers = {1, 2, 2, 3, 3, 3};
    set<int> uniqueNumbers(numbers.begin(), numbers.end());

    for (auto num : uniqueNumbers) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}
（二）使用 unordered_set 去重

#include <iostream>
#include <unordered_set>
#include <vector>

int main() {
    vector<int> numbers = {1, 2, 2, 3, 3, 3};
    unordered_set<int> uniqueNumbers(numbers.begin(), numbers.end());

    for (auto num : uniqueNumbers) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

高精度加法： 1.读入数据:将两个大整数以字符串形式读入，并且逆序存储到两个整数类型的数组 
2.初始化结果数组，进位设置为0 
3.逐位相加：从最低位开始，逐位将两个数相加，并加上前一位的进位，将 和的个位保留，存到结果数组，并且将和的十位保留下来 
4.处理最高位进位 ：如果最后以为相加仍然有进位，结果数组被填满，不需要去除前导 反之，没有产生进位需要去除 
5.去除前导0 6.输出结果（逆序输出）

#include<bits/stdc++.h>
using namespace std;
/*
memset(void *arr,int val,size_t_size)
arr 填充内容的起始位置 
val 设置的值 （0，-1）
size_t_size 填充的字节数（sizeof(arr)）

*/	
int main(){
	int a[5];
	memset(a,0,sizeof(a));
	memset(&a[0],0,sizeof(a));
	memset(a,0,5*sizeof(int));
	
	int arr1[5][5];
	memset(arr1,0,sizeof(arr1));
	memset(arr1[0],0,sizeof(arr1));
	memset(&arr1[0][0],0,sizeof(arr1));
	memset(arr1,0,25*sizeof(int));
	
	int a[5];
	fill(a, a + 5, 0);
	fill(&a[0], a + 5, 0);
	fill(&a[0], &a[5], 1); // 因为是"不到last"
	fill(&a[0], a + sizeof(a) / sizeof(int), 1);
	fill(&a[0], a + sizeof(a) / sizeof(a[0]), 1);
	int a[5][5];
// fill(a, a + 5 * 5, 0); // 报错，'const int' to 'int [5]'
// fill(&a, &a + 5 * 5, 0); // 报错，'const int' to 'int [5][5]'
// fill(&a[0], &a[0] + 5 * 5, 0); // 报错，'const int' to 'int [5]'
	fill(a[0], a[0] + 5 * 5, 0);
	fill(&a[0][0], &a[5][5], 0);
	fill(&a[0][0], &a[0][0] + 5 * 5, 0);
	fill(&a[0][0], &a[0][0] + sizeof(a) / sizeof(int), 0);
	
	return 0;
}

/*
// 单个字符
char c = getchar(); // 输入单个字符
putchar(c);// 输出单个字符
islower(c);// 判断c是否为小写字母
isupper(c);// 判断c是否为大写字母
isalpha(c);// 判断是否为字母
isdigit(c);// 判断是否为数字
、// 字符数组
'\0' // 字符数组最后一个：ASCII值：0
char str[];
cin>>str; // 可以作为一个整体进行cin,cout
cout<<str;
str ="sdfa"；// 可以直接用字符串赋值

// 字符数组常用处理函数：
char str[100]; // char *str
puts(str); // 输出字符串
gets(str);// 输入一整行字符串（包括空格，已弃用）
fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
strcat(str1,str2) // 把str2连接到str1后面
strcmp(str1,str2) // 比较两个字符串，正数：1大；0：一样大，负数：2大
strlen(str) // 获取字符串长度（不包括'\0'）

// string
#include<string> // 字符串头文件
=  可以重新赋值
+= 尾部加入字符串

+ 连接字符串
  ==，！=，<,>,<=,>= 字符串的比较
  [] 存取单一字符
  getline(cin,str) // 输入（包括空格，enter键结束）
  str.substr(i,1) // 从i开始截取，截取长度为1的子字符串
  str.find(str2) // 在str字符串中去找到str字符串
  str.rfind(str2) //  str中查找str2，返回所在的下标，没找到返回string::npos
  str.erase(i,1)  // 第i个字符开始往后面去删除
  str.inser(i,str2) // 在个位置 cun

<< // 输出
str.substr(i, l); // 从i开始，截取长度为l的子字符串
str.find(str2); // 在str中查找str2，返回所在的下标，没找到返回string::npos
str.rfind(str2); // 同find，但是从右向左找
str.erase(i, l); // 从i开始，删除长度为l的子字符串
str.insert(i, str2); // 在i的位置前，插入str2
str.size(); // 获取str的长度
str.c_str(); // 获取str对应的char[]
str.begin(); // 获取str的首地址
str.end(); // 获取str的尾地址(最后一个元素后面)

*/

// 字符数组
'\0' // 字符数组最后一个：ASCII值：0
char str[];
cin>>str; // 可以作为一个整体进行cin,cout
cout<<str;
str ="sdfa"；// 可以直接用字符串赋值

// 字符数组常用处理函数：
char str[100]; // char *str
puts(str); // 输出字符串
gets(str);// 输入一整行字符串（包括空格，已弃用）
fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
strcat(str1,str2) // 把str2连接到str1后面
strcmp(str1,str2) // 比较两个字符串，正数：1大；0：一样大，负数：2大
strlen(str) // 获取字符串长度（不包括'\0'）

// string
#include<string> // 字符串头文件
=  可以重新赋值
+= 尾部加入字符串

+ 连接字符串
  ==，！=，<,>,<=,>= 字符串的比较
  [] 存取单一字符
  getline(cin,str) // 输入（包括空格，enter键结束）
  str.substr(i,1) // 从i开始截取，截取长度为1的子字符串
  str.find(str2) // 在str字符串中去找到str字符串
  str.rfind(str2) //  str中查找str2，返回所在的下标，没找到返回string::npos
  str.erase(i,1)  // 第i个字符开始往后面去删除
  str.inser(i,str2) // 在个位置 cun

<< // 输出
str.substr(i, l); // 从i开始，截取长度为l的子字符串
str.find(str2); // 在str中查找str2，返回所在的下标，没找到返回string::npos
str.rfind(str2); // 同find，但是从右向左找
str.erase(i, l); // 从i开始，删除长度为l的子字符串
str.insert(i, str2); // 在i的位置前，插入str2
str.size(); // 获取str的长度
str.c_str(); // 获取str对应的char[]
str.begin(); // 获取str的首地址
str.end(); // 获取str的尾地址(最后一个元素后面)


内建涵数
_builtin_ffs(x)返回X中最后一个为1位是从后向前第几位
(后往前第一个出现1位置)00000010010100 3位置
__builtin_popcount(x)统计二进制中1的个数
__builtin_ctz(x)    x末尾0的个数    100100     2个 
__builtin_clz(x)    x前导0的个数    00001001   4个
__builtin_parity(x) x中1的奇偶性 1有偶数个返回0,否则返回1
*/

#include
#include<bitset> 
using namespace std;

/*
bitset<N> varm(M) 用于处理进制
N 代表占的位数 
varm 代表bitset名
M变量的初始值 
bitset头文件：
#include<bitset> 
bitset例子：
bitset<32> b; 
相关STL函数：
b.any() 当bitset对象的一位或多个位被设置为1 时any()返回true 
用途：检测总开关是否全被关闭状态
b.none() 如果bitset 对象的所有位都被设置为0 ,则none()操作返回true
用途：检测总开关是否全被关闭状态(出现一个没关false)
b.count() count()操作返回被设置为1的位的个数.
b.set() 我们可以用set()操作或者下标操作符来设置某个单独的位
b.test(位置) 测试某个单独的位是否为1 
if(b.test(2)) 返回真测试第二位是否为1 
b.reset(x) 把x位设置为0 
b.flip()  操作翻转整个bitset 对象或一个独立的位
b.flip( 0 ); // 翻转第一位  
b[0].flip(); // 也是翻转第一位  
b.flip(); // 翻转所有的位的值
size()：返回大小（位数）。
to_ulong()：返回它转换为unsigned long的结果，如果超出范围，则报错。
to_string()：返回它转换为string的结果。


*/
bitset<32> b(12); // 000000000000000000000000000000000000001100
int main(){
//	string s;
//	cin>>s;
//	int len = s.size();
//	for(int i = 0;i<len-1;i++){
//		ans+=(s[i]-'0')*pow(2,len-i-1);
//		cout<<ans<<endl;
//	}
	cout<<b<<endl;
	bool c = b.any();
	bool k = b.none();
	cout<<c<<" "<<k<<endl;
	//偶数位数设为1会变成什么
	for(int i = 0;i<32;i++){
		if(i%2==0){
			b[i]=1;
		}
	}
//	int m = b.count();
	cout<<b<<endl; 
	if(b.test(13)){
		cout<<"第13位是1"; 
	} else{
		cout<<"第13位是0";
	}
	b.reset(4);
	cout<<endl<<b<<endl;
	b.flip(0);
	b.flip(2);
	b[6].flip();
	cout<<"翻转第一位后的结果：";
	cout<<endl<<b<<endl;
	cout<<"把整个bitset翻转:"<<endl;
	b.flip();
	cout<<endl<<b<<endl;
	int l = b.to_ulong();
	cout<<"改变后的进制转成数字"<<l;
 
	
}

将字符串转成数字：

1.借用bitset将01字符串变成无符号整数

string a = "1001";

bitset<64> b(string("1001"))

bitset<64> b(a)

cout<<b.to\_ulong()

2.用sscanf() 函数把字符数组里面的字符串打印到数值变量里面

int buf;

sscanf("123456","%d",&buf)

printf("%d\\n",buf)

3.用sprintf()把数据打印到字符数组里面

char s[100]

sprintf(s,"%d",123)

4.用直接的方式

string s = "1234";

int n = 0;

for(int i = 0;i<4;i++){

n = n\*10+s[i]-'0';

}

5.一般用法

char buf[512] = ;

sscanf("123456 ", "%s", buf);

printf("%s\\n", buf);

结果为：123456

1. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。

sscanf("123456 ", "%4s", buf);

printf("%s\\n", buf);

结果为：12342. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。

sscanf("123456 abcdedf", "%[^ ]", buf);

printf("%s\\n", buf);

结果为：123456

3. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。

sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

4. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。

sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

5、给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 "iios/"过滤掉，再将

非'@'的一串内容送到buf中

sscanf("iios/12DDWDFF@122", "%\*[^/]/%[^@]", buf);

printf("%s\\n", buf);

结果为：12DDWDFF

6、给定一个字符串"hello, world"，仅保留"world"。（注意：“，”之后有一空格）

sscanf("hello, world", "%\*s%s", buf);

printf("%s\\n", buf);

结果为：world　　P.S. %\*s表示第一个匹配到的%s被过滤掉，即hello,被过滤了，如果没有空格则结果为

NUL

#include<bits/stdc++.h>
#define f_Getchar() getchar()
#define f_Putchar(ch) putchar(ch)
using namespace std;


inline int read(){ // 单个字符读入
	register int x = 0,t=1;
	register char cj =getchar();
	while(cj<'0'||cj>'9'){
		if(cj == '-')t--;
		cj = getchar();
	}
	while(cj>='0'&&cj<='9'){
	//x =(x<<1)+(x<<3)+(cj^48);
		x = x*10+cj-'0';
		cj = getchar();
	}
	return x*t;
}
inline void write(int x){
	if(x<0){// 写入
		putchar('-');
		x=-x;
	}
	if(x>9){
		write(x/10);
	}
	putchar(x%10+'0');
	putchar('\n');
	return;
}
//string 整行快读读入
inline void inputL(char* s){
    char ch = f_Getchar() ;
    while(ch == '\n')ch = f_Getchar() ;
    while(ch != '\n')*s = ch,++ s,ch = f_Getchar() ;
    *s = '\0' ;
    return ;
}
// 确定字符串长度情况下 
inline void inputSs(char* s,unsigned long long len){
    char ch = f_Getchar() ;
    while(ch == ' ' || ch == '\n')ch = f_Getchar() ;
    while((len --) && (ch != ' ' && ch != '\n')){
    	*s = ch,++ s,ch = f_Getchar() ;
    	*s = '\0' ;
	}
    return ;
}
// 正常字符串快写 
inline void outputS(const char* s){
    while(*s)f_Putchar(*s ++) ;
    return ;
}
//输出一行字符串
inline void outputSL(const char* s){
    while(*s && *s != '\n')f_Putchar(*s ++) ;
    return ;
} 
int main(){
//	int m,n;
//	m = read();
//	n = read();
//	write(m);
//	write(n);
	char s[100];
	inputL(s);https://slowroads.io/
	outputS(s);
}

什么你竟然刷到这，那我就给你个好玩的网站─=≡Σ(((つ•̀ω•́)つ

飙车 风叶穿行 4399

https://www.scratch-cn.cn/