字节跳动笔试

最新推荐文章于 2022-08-07 14:54:48 发布
最新推荐文章于 2022-08-07 14:54:48 发布
阅读量3.2k 收藏 12
点赞数
分类专栏： 算法笔试 C++ 文章标签： 笔试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/excellent_sun/article/details/96325393
版权

字节跳动笔试

8月25日 笔试

在这里插入图片描述

code1

#include<iostream>
#include<queue>
#include<set>
#include<algorithm>
using namespace std;
 
int main()
{
    int n;
    cin >> n;
    set<int> s;//遍历过
    queue<int> q;
    int** map = new int*[n];
    for (int i = 0; i < n; i++)
    {
        map[i] = new int[n];
        for (int j = 0; j < n; j++)
        {
            cin >> map[i][j];
        }
    }
    int count = 0;
    for (int i = 0; i < n; i++)
    {
        if (s.find(i) != s.end())//找到了
        {
            continue;
        }
        else 
        {
            s.insert(i);
            count++;
            q.push(i);
            while (!q.empty())
            {
                int temp = q.front();
                q.pop();
                for (int j = 0; j < n; j++)
                {
                    if (map[temp][j] >=3 && s.find(j) == s.end())
                    {
                        q.push(j);
                    }
                }
                s.insert(temp);
            }
        }
    }
    cout << count;
    return 0;
}

code2

#include <iostream>
#include <vector>

using namespace std;

int main()
{
	int m;
	cin >> m;

	int **bottle;
	bottle = new int*[m];
	for (int i = 0; i < m; i++)
	{
		bottle[i] = new int[m];
		for (int j = 0; j < m; j++)
		{
			cin >> bottle[i][j];
		}
	}
	int flag = 1;
	int *flag1 = new int[m];
	memset(flag1, 0, sizeof(int)*m);
	for (int i = 0; i < m - 1; i++)
	{
		for (int j = i + 1; j < m; j++)
		{
			if (bottle[i][j] >= 3)
			{
				if (!flag1[i] || !flag1[j])
				{
					if (!flag1[i])
						flag = flag1[i];
					else
						flag = flag1[j];
				}
				flag1[i] = flag;
				flag1[j] = flag;
			}
		}
		flag++;
	}
	cout << flag;
}

在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
 
int main()
{
    int n;
    cin >> n;
    if (n == 2)
    {
        cout << 1;
        return 0;
    }
    long long* num = new long long [1001] ();
    num[0] = 1;
    for (int i = 2; i <= n; i = i + 2)
    {
        for (int j = 2; j <= i; j = j + 2)
        {
            long long temp = (num[j - 2] * num[i - j]) % 1000000007;
 
            num[i] = (num[i] + temp) % 1000000007;
        }
 
    }
    cout << num[n];
 
    return 0;
}

在这里插入图片描述

#include<iostream>
#include<queue>
#include<set>
#include<algorithm>
using namespace std;
 
int main()
{
    int d;
    cin >> d;
    int m[4][4];
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            cin >> m[i][j];
        }
    }
    if (d == 1)
    {
        for (int j = 0; j < 4; j++)
        {
            for (int i = 0; i < 3; i++)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = i + 1; k < 4; k++)
                    {
                        if (m[k][j] != 0)
                        {
                            swap(m[k][j], m[i][j]);
                            break;
                        }
                    }
                }
            }
            for (int i = 0; i < 3; i++)//合并
            {
                if (m[i][j] == m[i + 1][j])
                {
                    m[i][j] *= 2;
                    m[i + 1][j] = 0;
                }
            }
            for (int i = 0; i < 3; i++)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = i + 1; k < 4; k++)
                    {
                        if (m[k][j] != 0)
                        {
                            swap(m[k][j], m[i][j]);
                            break;
                        }
                    }
                }
            }
        }
    }
     
    if (d == 2)
    {
        for (int j = 0; j < 4; j++)
        {
            for (int i = 3; i > 0; i--)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = i - 1; k >= 0; k--)
                    {
                        if (m[k][j] != 0)
                        {
                            swap(m[k][j], m[i][j]);
                            break;
                        }
                    }
                }
            }
            for (int i = 3; i >0; i--)//合并
            {
                if (m[i][j] == m[i - 1][j])
                {
                    m[i][j] *= 2;
                    m[i - 1][j] = 0;
                }
            }
            for (int i = 3; i >0 ; i--)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = i - 1; k >=0; k--)
                    {
                        if (m[k][j] != 0)
                        {
                            swap(m[k][j], m[i][j]);
                            break;
                        }
                    }
                }
            }
        }
    }
 
    if (d == 3)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 3; j++)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = j + 1; k < 4; k++)
                    {
                        if (m[i][k] != 0)
                        {
                            swap(m[i][k], m[i][j]);
                            break;
                        }
                    }
                }
            }
            for (int j = 0; j < 3; j++)//合并
            {
                if (m[i][j] == m[i][j + 1])
                {
                    m[i][j] *= 2;
                    m[i][j + 1] = 0;
                }
            }
            for (int j = 0; j < 3; j++)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = j + 1; k < 4; k++)
                    {
                        if (m[i][k] != 0)
                        {
                            swap(m[i][k], m[i][j]);
                            break;
                        }
                    }
                }
            }
        }
    }
    if (d == 4)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 3; j > 0; j--)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = j - 1; k >= 0; k--)
                    {
                        if (m[i][k] != 0)
                        {
                            swap(m[i][k], m[i][j]);
                            break;
                        }
                    }
                }
            }
            for (int j = 3; j > 0; j--)//合并
            {
                if (m[i][j] == m[i][j - 1])
                {
                    m[i][j] *= 2;
                    m[i][j - 1] = 0;
                }
            }
            for (int j = 3; j > 0; j--)//下落
            {
                if (m[i][j] == 0)
                {
                    for (int k = j - 1; k >= 0; k--)
                    {
                        if (m[i][k] != 0)
                        {
                            swap(m[i][k], m[i][j]);
                            break;
                        }
                    }
                }
            }
        }
    }
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            cout << m[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

在这里插入图片描述

面试题1:

在这里插入图片描述

#include<iostream>

using namespace std;

class Solution {
public:
	int findpos(int& a) {
		int count = 1;
		while (!(a&1)) {
			count++;
			a = a >> 1;
		}
		return count;
	}
};
int main() {
	int a = 16;
	int pos = Solution().findpos(a);
	cout << pos << endl;
	system("pause");
	return 0;
}

面试题2:

在这里插入图片描述

code1

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void traverse(vector<vector<int>> &A, int i, int j)
{
    if(i<0||i>=A.size()||j<0||j>=A[0].size()||A[i][j]==0)
        return;
    A[i][j] = 0;
    traverse(A,i-1,j);
    traverse(A,i+1,j);
    traverse(A,i,j-1);
    traverse(A,i,j+1);
    return;
}

int main()
{
    int count = 0;
    vector<vector<int>> A(5,vector<int>(8,0));
    for(int i=0;i<5;i++)
    {
        for(int j=0;j<8;j++)
        {
            cin>>A[i][j];
        }
    }
    for(int i=0;i<A.size();i++)
    {
        for(int j=0;j<A[0].size();j++)
        {
            if(A[i][j]==1)
            {
                traverse(A,i,j);
                count+=1;
            }
        }
    }
    cout<<count<<endl;
    return 0;
}

题目1（贪心算法）：

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

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main()
{
	vector<int> A, B;
	int n;
	int i, j;
	int sum;
	int tworst, kworst, tbest, kbest;
	while (cin >> n && n)
	{
		A.resize(n);
		B.resize(n);
		for (i = 0; i < n; i++)
		{
			cin >> A[i];
		}
		for (i = 0; i < n; i++)
		{
			cin >> B[i];
		}
		sort(A.begin(), A.end());
		sort(B.begin(), B.end());
		//for(i=0;i<n;i++)
		//{
		// cout<<tian[i]<<" "<<king[i]<<endl;
	 //}
		tworst = 0; kworst = 0;
		tbest = n - 1; kbest = n - 1;
		sum = 0;
		while (tworst <= tbest)
		{
			if (A[tbest] > B[kbest])
			{
				sum += 1;
				tbest--;
				kbest--;
			}
			else if (A[tbest] < B[kbest])
			{
				sum -= 1;
				kbest--;
				tworst++;
			}
			else if (A[tbest] == B[kbest] && A[tworst] > B[kworst])
			{
				sum += 1;
				tworst++;
				kworst++;
			}
			else if (A[tbest] == B[kbest] && A[tworst] <= B[kworst])
			{
				if (A[tworst] < B[kbest])
					sum -= 1;
				tworst++;
				kbest--;
			}
		}
		cout << sum << endl;
		A.clear();
		B.clear();
	}
	return 0;
}

题目2（动态规划）：

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

#include <iostream>
#include <vector>
using namespace std ;

int calsum(const vector<int>& nums, int i, int j)
{
	int sum =0;
	for(int start = i; start <=j; start++ )
	{
		sum += nums[start];
	}
	return sum ;
}

int findMaxScore(vector<int>& nums)
{
	vector<vector<int>> dp(nums.size(),vector<int>(nums.size(), -1));
	dp[0][0] = nums[0];
	dp[0][1] = nums[0]+nums[1];
	int maxRes = 0;

	for(int i=1; i<dp.size();i++)
	{
		for(int j=i;j<dp[0].size();j++)
		{
			if( j-i<=1)
			{
				int max = -1;
				for(int length =1; length<=4; length ++ )
				{
					if(length <= 2)
					{
						for(int changdu = 1; changdu<=2; changdu++ )
						{
							if(i-length-changdu >= 0 && 
								dp[i-length-changdu][i-length-1] != -1)
							{
								if(dp[i-length-changdu][i-length-1]>max)
									max = dp[i-length-changdu][i-length-1];
							}
						}
					}
					else
					{
						int changdu = 2 ;
						if(i-length-changdu >= 0 && 
								dp[i-length-changdu][i-length-1] != -1)
							{
								if(dp[i-length-changdu][i-length-1]>max)
									max = dp[i-length-changdu][i-length-1];
							}
					}
				}
				if(max != -1)
					dp[i][j] = max+calsum(nums, i, j);
			}
			if(dp[i][j]>maxRes)
				maxRes = dp[i][j];
		}
	}
	return maxRes;
}


int main()
{	
	//5 
	//2 7 9 4 3 : 9 
	vector<int> nums;
	nums.push_back(9);
	nums.push_back(7);nums.push_back(9);
	nums.push_back(4);nums.push_back(3);
	cout << findMaxScore(nums)<<endl;
	//cout << calsum( nums, 2, 3);
	return 0;
}

题目3：

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

code1

#include<iostream>
#include<vector>

using namespace std;

int isswap(vector<int> arr, int from, int to)
{
	for (int i = from; i < to; i++)
	{
		if (arr[i] == arr[to])
			return 0;
	}
	return 1;
}

void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
vector<int> permutations(vector<int> arr, int k, int n,vector<int> &post)
{
	
	if (k == n)
	{
		for (int i = 0; i < n; i++) 
		{
			post.push_back(arr[i]);
			//cout << arr[i] << " ";
			//++count;

		}  
		//cout << endl;
	}
	else
	{
		for (int i = k; i < n; i++)
		{
			if (isswap(arr, k, i))
			{
				swap(&arr[k], &arr[i]);
				permutations(arr, k + 1, n,post);
				swap(&arr[i], &arr[k]);
			}
			
		}
	}
	return post;
}
int main()
{
	int n,m;
	int count=0;
	cin >> n >> m;
	vector<int> A(n);
	vector<int> post;
	for (int i = 0; i < n; ++i) cin >> A[i]; cout << endl;
	post = permutations(A, 0, n,post);
	count = post.size() / n;
	//cout << count << endl;
	for (int i = 1; i < post.size(); ++i) 
	{
		if (abs(post[i - 1] - post[i]) > m & (i) % n != 0)
			--count;
		if (i > n - 2 && (i+1) % n == 0 && abs(post[i - n + 1] - post[i]) > m)
			--count;	
		//cout << post[i]<<" ";
	}
	cout << count<<endl;
	system("pause");
	return 0;
}

code2

//#include<bits/stdc++.h>
#include<iostream>
#include<map>
#include<vector>
#include <algorithm> 

#define pb push_back

using namespace std;

const int N = 2e5 + 11;
int n, m, a[N], ans, b[N];

map<vector<int>, int>vis;

int main() {
	ios::sync_with_stdio(false);
	cin >> n >> m;
	for (int i = 1; i <= n; i++)cin >> a[i], b[i] = i;
	do {
		int sta = 0;
		for (int i = 2; i <= n; i++) {
			if (abs(a[b[i]] - a[b[i - 1]]) > m) {
				sta = 1;
				break;
			}
		}
		if (abs(a[b[1]] - a[b[n]]) > m)sta = 1;
		if (!sta) {
			vector<int>gao;
			int pos;
			for (int i = 1; i <= n; i++) {
				if (b[i] == 1) {
					pos = i;
					break;
				}
			}
			int cnt = 0;
			while (cnt < n) {
				gao.pb(b[pos]);
				pos++;
				cnt++;
				if (pos > n)pos = 1;
			}
			if (!vis[gao])ans++, vis[gao] = 1;
		}
	} while (next_permutation(b + 1, b + 1 + n));
	cout << ans << endl;
	system("pause");
	return 0;
}

题目4：

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

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int main()
{
	int n, m;
	cin >> n >> m;
	vector<int> dp(n + 1);
	vector<int>a(m + 1, 0);
	vector<int>b(m + 1, 0);
	for (int i = 0; i < m; i++)
		cin >> a[i] >> b[i];
	for (int j = 0; j <= n; j++)
		dp[j] = (j >= a[0] ? b[0] : 0);
	for (int i = 1; i < m; i++)
	{
		for (int j = n; j >= a[i]; j--)
		{
			dp[j] = max(dp[j], dp[j - a[i]] + b[i]);
		}
	}
	cout << dp[n] << endl;
	system("pause");
	return 0;
}
知行SUN
关注
专栏目录
字节跳动笔试题——算法岗
FPGA/MATLAB学习教程/源码/项目合作开发
09-17 3349
【代码】字节跳动笔试题——算法岗。
【秋招突围】2024届秋招笔试-字节跳动笔试题-01-三语言题解(Java/Cpp/Python)
春秋招笔试突围
07-11 610
A先生有一个环形的花圃，花圃被分成了 $n$ 块区域。最初，A先生在花圃上选择了三块区域种植了玫瑰。 现在，A先生想要通过移动操作，使得花圃达到**平衡状态**。 平衡状态：任意两块种植玫瑰的区域之间的距离不小于 $k$（相邻区域的距离为 $1$）。 移动操作：交换相邻区域的状态（玫瑰区域变为空区域，空区域变为玫瑰区域）。 同时，A先生是一个很注重效率的人，所以他希望你能使用最少的移动次数使得花圃达到平衡状态。
字节跳动2022.3.13笔试
weixin_50666824的博客
03-13 3320
题目1 1、题目描述 2、算法分析 gg，题目没读懂！ ------------------------------------------------------------------------------------------------------------------ 题目2： 1、题目描述 2、算法分析 首先根据题意，从当前点到下一个目标点的时候，首先是先跳一步，然后如果没有到达target位置，那么后续跳的距离是前一次距离长度+1； 然后，还..
【算法】字节跳动2018校招Android方向（第二批）笔试题：用户喜好
weixin_43185955的博客
09-25 279
题目 牛客题目链接 为了不断优化推荐效果，今日头条每天要存储和处理海量数据。假设有这样一种场景：我们对用户按照它们的注册时间先后来标号，对于一类文章，每个用户都有不同的喜好值，我们会想知道某一段时间内注册的用户（标号相连的一批用户）中，有多少用户对这类文章喜好值为k。因为一些特殊的原因，不会出现一个查询的用户区间完全覆盖另一个查询的用户区间(不存在L1<=L2<=R2<=R1)。 输入描述: 输入： 第1行为n代表用户的个数 第2行为n个整数，第i个代表用户标号为i的用户对某类文章的
字节跳动笔试题（二）——正则式匹配
不积跬步无以至千里
07-15 1359
字节笔试题（二）
2019/3/16 字节跳动笔试题
大洋深处
03-17 1909
有n个人参加编程比赛，比赛结束后每个人都得到一个分数；现在所有人排成一圈（第一个和第n个相邻）领取奖品，要求； 1：如果某个人的分数比左右的人高，那么奖品数量也要比左右的人多； 2：每个人至少得到有个奖品。 问最少应该准备多少奖品。 输入描述： 第一行是整数n，表示测试样例个数 每个测试样例的第一行是一个正整数n，表示参加比赛的人数；（0&lt;n&lt;100000） 第二行是n个正整数a[i]...
2018字节跳动后端笔试第二批三个题
胖墩的IT博客
03-15 896
链接：https://www.nowcoder.com/questionTerminal/429c2c5a984540d5ab7b6fa6f0aaa8b5 来源：牛客网 作为一个手串艺人，有金主向你订购了一条包含n个杂色串珠的手串——每个串珠要么无色，要么涂了若干种颜色。为了使手串的色彩看起来不那么单调，金主要求，手串上的任意一种颜色（不包含无色），在任意连续的m个串珠里至多出现一次（注意这里手串...
字节跳动笔试、面试、工作总结.zip
05-01
本压缩包文件“字节跳动笔试、面试、工作总结.zip”很可能包含了与应聘该公司的全过程相关的重要资料，包括技术面试的编程题目、非技术面试的策略以及可能的工作总结，这些都对求职者有极大的参考价值。 首先，我们...
字节跳动笔试题解析与实践- Java编程挑战题精选
最新发布
10-30
内容概要：本文档收集了几道典型的字节跳动公司笔试编程题，涵盖基础数学运算、矩阵操作、社会网络图划分、合法性判断和字符串处理等常见面试题目。通过解析这些问题，不仅可以帮助读者掌握具体解题方法，还能深入...
字节跳动 2022/3/20笔试
weixin_50666824的博客
03-20 1212
题目1 import java.io.*; import java.util.*; class Test{ public static void main(String[] args) { Scanner sc = new Scanner(System.in); String s = sc.nextLine(); String[] str = s.split(" "); int n..
字节跳动笔试题（三）——寒冰王座
不积跬步无以至千里
07-16 6562
字节笔试题（三）
2021大厂字节跳动笔试题（含答案）
Aybuai的博客
06-22 6865
第一题 [ {num: 12, city: ‘beijing’}, {num: 56, city: ‘shanghai’}, {num: 167, city: ‘guangzhou’}, {num: 23, city: ‘shenzhen’}, {num: 45, city: ‘caoxian’} ] 写一个方法实现把上面的数组转换成下面这种格式： {beijing: 12, shanghai: 56,…} 解析 只要把数组遍历循环然后再向一个对象中插入就好了，代码如下： // 这里用的map，也可以用
字节跳动第四批笔试题
weixin_43518584的博客
07-12 3440
输入说明： 第一行输入n代表队伍中的人数 第二行输入队伍中每个人的身高（用空格隔开） 比如输入： 5 2 3 1 5 4 6 5 4 1 6 8 2 输出说明： 如果现在所在位置之前没有比自己身高高的，数值变为-1，如果现在所在位置之前有比自己身高高的，数值变为所在位置之前那个离自己最近的且比自己高的那个人的身高 上例的输入对应输出： 5 -1 -1 3 -1 4 6 -1 5 4 -1 -1 8 ```python # --*-- coding : utf-8 --*-- def No1(k, ls):
【软件测试】（北京）字节跳动科技有限公司二面笔试题
阿里大叔说测试的博客
08-07 1066
​ 1、请观察下面图片，然后给出答案：进行管理和控制的软件是？ 2、软件测试应该划分几个阶段?简述各个阶段应重点测试的点?各个阶段的含义？ 3、在您以往的工作中，一条软件缺陷（或者叫Bug）记录都包含了哪些内容？如何提交高质量的软件缺陷（Bug）记录？ 4、请简单介绍一下实用过的安卓UI自动化测试工具？ 5、根据自己的理解什么是测试用例和测试规程，设计一个测试用例应当从哪几方面考虑？ ​...
字节笔试
qq_24624539的博客
07-23 993
小B决定请小A吃汉堡。 他们来到了一家特别的汉堡店，这里的汉堡有J种面包和K种肉饼，每次制作 时，老版会随机选择- -种面包和一种肉饼来做一一个汉堡。 小A和小B都有点挑食，他们每个人都有自己不喜欢的原材料。但是小B有钱 就是任性，他决定一-次性买n个汉堡，并且从这n个汉堡中选出两个他们各自 喜欢的汉堡。 请问，小B买n个汉堡，能满足他们要求的概率是? 输入描述: 第一行三个整数N,J,K (1 <=J,K <= 10000, 2<=N<=10000) 第二行三个整数Aj,Bj,Tj
3.21字节跳动笔试
DecafTea的博客
03-21 824
二分答案 #include<bits/stdc++.h> using namespace std; bool check(vector<long long>& a, long long mid){ long long temp; for(int i=0; i<a.size()-1; i++){ temp = min(a[i]*2, mid/2); if(a[i]>temp) return false; .
字节跳动笔试题之手串
ssllnn1314的博客
04-13 399
作为一个手串艺人，有金主向你订购了一条包含n个杂色串珠的手串——每个串珠要么无色，要么涂了若干种颜色。为了使手串的色彩看起来不那么单调，金主要求，手串上的任意一种颜色（不包含无色），在任意连续的m个串珠里至多出现一次（注意这里手串是一个环形）。手串上的颜色一共有c种。现在按顺时针序告诉你n个串珠的手串上，每个串珠用所包含的颜色分别有哪些。请你判断该手串上有多少种颜色不符合要求。即询问有多少种颜色在...
2020字节跳动笔试题
JH_Shawlin的博客
09-17 2803
第一题 小明总是睡过头，所以他定了很多闹钟，只有在闹钟响的时候他才会醒过来并且决定起不起床，从他起来算起他需要X分钟到达教室，上课时间为当天的A时B分，请问他最晚可以什么时候起床。 输入描述：第一行为一个正整数，表示闹钟的数量N（N<=100） 接下来的N行每行两个整数，表示这个闹钟响起的时间为Hi时Mi分 接下来的一行包含一个整数，表示从起床起他需要X（0<=X<=100）分钟...
字节跳动笔试题python
01-25
以下是字节跳动笔试题的Python解法： ```python n, dist = map(int, input().split()) nums = list(map(int, input().split())) res = 0 i = 0 j = 2 while i < n-2: while j < n and nums[j] - nums[i] <= dist: j += 1 if j - 1 - i >= 2: num = j - i - 1 res += num * (num - 1) // 2 i += 1 res = res % 99997867 print(res) ``` 这段代码是用来解决字节跳动笔试题的问题。它首先从输入中获取两个整数n和dist，然后获取一个包含n个整数的列表nums。接下来，它使用两个指针i和j来遍历列表nums，并计算满足条件的子数组的数量。最后，它将结果取模99997867并打印出来。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知行SUN

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值