数组操作​​​​​​​\RSA\A-B数对\完美数

已于 2023-04-08 13:55:55 修改
阅读量189 收藏
点赞数
文章标签： c++
于 2023-04-03 20:37:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/funing7/article/details/129937325
版权

数组操作

给你一个有 nn 个元素的数组 aa 。你可以对它进行如下操作，次数不限。

从一个偶数大小为 2k2k 的数组中选择一些从位置 ll 开始的子数组(1≤l≤l+2⋅k−1≤n1≤l≤l+2⋅k−1≤n , k≥1k≥1) ，对于 00 到 k−1k−1（包括）之间的每一个 ii ，将值 al+k+ial+k+i 分配给 al+ial+i 。

例如，如果 a=[2,1,3,4,5,3]a=[2,1,3,4,5,3] ，然后选择 l=1l=1 和 k=2k=2 ，应用这个操作，数组将变成 a=[3,4,3,4,5,3]a=[3,4,3,4,5,3]。

请找出使数组中所有元素相等所需的最少操作数（可能是零）。

输入格式

输入由多个测试用例组成。第一行输入一个整数 t(1≤t≤2×104)t(1≤t≤2×104)表示测试用例的数量。

每个测试用例的包含 (n+1)(n+1) 个整数：

第一个整数 n(1≤n≤2×105)n(1≤n≤2×105) 表示数组的长度。

此后 nn 个整数 a1,a2,...,an(1≤ai≤n)a1,a2,...,an(1≤ai≤n) 表示数组的元素。

输出格式

输出 tt 行，每行一个整数表示用给定的操作使数组中所有元素相等所需的最小操作数。

样例输入

5
3 1 1 1
2 2 1
5 4 4 4 2 4
4 4 2 1 3
1 1

样例输出

0
1
1
2
0

数据规模

保证所有测试用例的 nn 之和不超过 200000200000。

提示

在第一个测试中，所有元素都是相等的，因此不需要任何操作。

在第二个测试中，你可以应用一个操作，k=1，l=1k=1，l=1，设置 a1←a2a1←a2 ，通过 11 个操作，数组变成 [1,1][1,1]。

在第三个测试中，你可以应用一个操作，k=1，l=4k=1，l=4，设置 a4←a5a4←a5 ，然后数组变成 [4,4,4,4,4][4,4,4,4,4]。

在第四个测试中，你可以应用一个操作，k=1，l=3k=1，l=3，设置 a3←a4a3←a4 ，数组变成 [4,2,3,3][4,2,3,3]，然后你可以应用另一个操作，k=2，l=1k=2，l=1，设置 a1←a3,a2←a4，a1←a3,a2←a4， 数组变成 [3,3,3,3][3,3,3,3]。

在第五次测试中，只有一个元素，因此不需要任何操作。

1.题目为区间赋值，将长度为k的后一个区间赋值给长度为k的前一个区间，因为是从后面往前面赋值，最终所有的数都会和最后一个数相同 。、

2.我们可以从后面开始枚举与最后一个数相同的数的个数，当不相同时开始赋值，相同的时候继续数长度

3.题目卡输入输出

#include<iostream>
#include<cstdio>
#include<cstring>
#define endl '\n'
using namespace std;
const int N = 2e5+10;
int t,a[N],n,num,len,cnt;
int main()
{
 	ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
	cin>>t;
	while(t--)
	{
		cin>>n;
		for(int i=1;i<=n;i++)cin>>a[i];
		len=1,cnt=0;
		while(len<n)
		{
			if(a[n-len]==a[n])len++;
			else 
			{
				cnt++;
				len*=2;
			}
		}
		cout<<cnt<<endl;
	}
	return 0;
}

RSA

RSA算法选择两个不同质数的积作为模数。现在有两个正整数 A,BA,B，如果它们是不同的质数，则判定为 full credit；否则，如果A⋅BA⋅B不是任意大于11的整数的平方的整数倍，则判定 partial credit；否则判定为no credit。

输入格式

一行两个正整数 A,BA,B。

输出格式

full credit 或 partial credit 或 no credit。

样例1输入

13 23

样例1输出

full credit

样例2输入

3 3

样例2输出

no credit

数据规模

所有数据保证 2≤A,B≤10122≤A,B≤1012。

数据范围有点大然后超时不会了... 

1.先判断a和b是否相等，如果相等直接输出no credit，因为他们的乘积一定是平方数的倍数（！！）
2.求出a和b的所有因子，并记录下所有因子的出现次数，

3.如果有一个因子出现了两次以上（说明不是质数了或者该两个数相等或者有平方数），或者已经有一个因子是某个数的平方数时，输出no credit
4.如果这两个数没有除了1和自身以外的数，就输出full credit
5.剩余情况输出partial credit

(223条消息) 2022-03-26每日刷题打卡_你好_Ä的博客-CSDN博客https://blog.csdn.net/fnmdpnmsl/article/details/123761642

#include<iostream>
#include<cmath>
using namespace std;
#include<algorithm>
#include<string>
#include<unordered_map>
#define int ll
#define endl '\n'
typedef long long ll;
const int N = 5e2 + 5;

//记录因数出现次数
unordered_map<int, int>mymap;
//求出x的全部因数
void check(int x)
{
    for (int i = 2; i <= x / i; i++)
    {
        if (x % i == 0)
        {
            
            mymap[i]++;
            mymap[x / i]++;
        }
    }
}
void solve()
{
    int a, b;
    cin >> a >> b;
    if (a == b)
    {
        cout << "no credit" << endl;
        return;
    }
    check(a);
    check(b);
    bool flag = false;
    for (auto i : mymap)
    {
    	
        int x = sqrt(i.first);
        //如果当前因数出现了两次，或者当前因数已经是某个数得平方数了，输出no credit
        if (i.second > 1 || x * x == i.first)
        {
            flag = true;
            break;
        }
        
    }
    if (mymap.size() == 0)cout << "full credit" << endl;
    else if(flag)cout << "no credit" << endl;
    else cout << "partial credit" << endl;
}



signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    solve();
    return 0;
}

A-B 数对

给出一串数以及一个数字 CC ，要求计算出所有 A−B=CA−B=C 的数对的个数（不同位置的数字一样的数对算不同的数对）。

输入格式

输入共两行。

第一行，两个整数 NN, CC。

第二行， NN 个整数，作为要求处理的那串数。

输出格式

一行，表示该串数中包含的满足 A−B=CA−B=C 的数对的个数。

样例输入

4 1
1 1 2 3

样例输出

3

数据范围

1≤N≤2×1051≤N≤2×105, 1≤C≤2×1051≤C≤2×105, 题目保证输入的 NN 个数范围小于 230230。

数据范围不是很大，枚举能过^~^

#include<iostream>
#include<cstring>
#include<algorithm>
#include<unordered_map>
using namespace std;
const int N = 2e5+10;
long long n,c,ans,a[N];
unordered_map<int,int> mp;
int main(){
	cin>>n>>c;
	for(int i=0;i<n;i++){
		cin>>a[i];
		mp[a[i]]++; 
	}
	for(int i=0;i<n;i++){
		ans+=mp[a[i]+c];
	}
	cout<<ans<<endl;
	return 0;
}

数位计算

​ 给出一个整数 nn，请解决下面的问题：

​ 使 f(x)=f(x)=（不超过 xx 且与 xx 具有相同位数的正整数的个数）。

​ 求出 f(1)+f(2)+...+f(n)f(1)+f(2)+...+f(n) ，结果对 998244353998244353 取模。

输入格式

​ 一个整数 NN。

输出格式

​ 一个整数——上面问题的答案，并对 998244353998244353 取模。

样例输入1

16

样例输出1

73

样例解释：对从 11 到 99 的每个 xx，不超过 xx 且与 xx 具有相同位数的正整数有 1,2,..,x1,2,..,x，因此，f(1)=1,f(2)=2,...,f(9)=9f(1)=1,f(2)=2,...,f(9)=9。对从 1010 到 1616 的每个 xx，不超过 xx 且与 xx 具有相同位数的正整数有 10,11,..,x10,11,..,x，因此，f(10)=1,f(11)=2,...,f(16)=7f(10)=1,f(11)=2,...,f(16)=7。所以答案为 7373。

样例输入2

238

样例输出2

13870

样例输入3

999999999999999999

样例输出3

762062362

数据规模

​ 所有数据保证 1≤N<10181≤N<1018，且 NN 是整数。

从10开始枚举10的倍数。如f(1)+...+f(9)有（1+2+3...+9;f(100)+..+f(999)=(1+..+900)=(1000-100+1)*(1000-100)/2;

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int MOD = 998244353;
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    unsigned long long n, res = 0, num = 0, power = 10;
    cin >> n;
    while (1)
    {
        if (n > power - 1)
        {
            ll x = (1 + power - power / 10) % MOD;
            ll y = ((power - power / 10)) % MOD;
            res =res+ (x*y/2)%MOD;
            res %= MOD;
        }
        else
        {
            ll x = (1 + n - power / 10 + 1) % MOD;
            ll y = ((n - power / 10 + 1)) % MOD;
            res = res+ (x*y/2)%MOD;
            res %= MOD;
            break;
        }
        power *= 10;

    }
    cout << res%MOD << endl;
    return 0;
}

#669. 完美数

对于给定的数字 aa , bb ,当整数 nn 在十进制下的所有数位都为 aa 或 bb 时，我们称 nn 是“好数”

对于好数 nn ，当 nn 在十进制下每一位的数字之和也为“好数”时，我们称 nn 是一个“完美数”

请你求出有多少 mm 位数是“完美数”

输入格式

输入一行三个整数 aa , bb , mm , 含义如题面所示 (1≤m≤106,1≤a,b≤9)(1≤m≤106,1≤a,b≤9)。

输出格式

输出一行一个整数表示完美数的数量 ， 由于答案可能很大 ， 请你将答案对 109+7109+7 取模

样例输入

5 1 5

样例输出

1

样例解释

只有 1111111111 满足要求

1.枚举每个数位上a,b的个数，最后将枚举出来的数各个数位上的和加起来，判断每一位是否都为a或者b

2.需要对组合数取模（知识盲区了）(225条消息) 组合数取模_ACdreamers的博客-CSDN博客
https://juejin.cn/post/7081175247197732900

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>

#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int MOD = 1e9 + 7, N = 1e6 + 10;

ll fact[N], infact[N];

ll qmi(int a, int b)
{
    ll res = 1;
    while (b)
    {
        if (b & 1) res = res * a % MOD;
        a = a * (ll)a % MOD;
        b >>= 1;
    }
    return res;
}

void init()
{
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i++)
        fact[i] = fact[i - 1] * i % MOD;

    infact[N - 1] = qmi(fact[N - 1], MOD - 2);
    for (int i = N - 2; i; i--)
        infact[i] = infact[i + 1] * (i + 1) % MOD;
}

int C(int a, int b)
{
    return (fact[a] * infact[b] % MOD * infact[a - b] % MOD) % MOD;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int a, b, m;
    cin >> a >> b >> m;
    init();
    char c = a + '0', d = b + '0';
    int x;
    ll res = 0;
    for (int i = 0; i <= m; i++)
    {
        x = m - i;
        ll num = x * a + i * b;
        bool flag = true;
        while (num)
        {
            if (num % 10 != a && num % 10 != b)
            {
                flag = false;
                break;
            }
            num /= 10;
        }
        if (!flag)continue;
        res = (res + C(m,i)) % MOD;
    }
    cout << (res%MOD) << endl;
    return 0;
}

新国王游戏

 附加文件 统计

又到了 HH 国国庆, 国王再次邀请 nn 位大臣来玩有奖游戏。上次国庆被众臣吐槽国王小气后，国王决定今年大方点，改变游戏规则且不再参与游戏，免得被大臣们质疑。首先, 他让每位大臣在左、 右手上面分别写下一个正整数。然后让这 nn 位大臣排成一排。排好队后, 所有的大臣都会获得国王奖赏的若千金币, 每位大臣获得的金币数分别是：排在该大臣后面的所有人的左手上的数的乘积乘以他自己右手上的数。国王希望所有大臣获得的金币数之和最多，所以他想请你帮他重新安排一下队伍的顺序。

简而言之，给定 nn 对数 ai,biai,bi，找到一种排列顺序，使得 b1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bnb1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bn 最大，求最大值，由于答案可能很大，需要对 10000000071000000007 取模

输入格式：

第一行，包含一个整数 nn。 第二行到第 n+1n+1 行，包含两个整数 ai,biai,bi

输出格式:

输出一行，表示按某种排序后的 b1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bnb1×a2∗a3∗…an+b2×a3∗a4∗…an+⋯+bn 的最大值对 10000000071000000007 取模的结果

样例输入

2
1 2
3 4

样例输出

10

说明

只有两种情况：

1.

1 2
3 4

(2∗3)+4=10(2∗3)+4=10

2.

3 4
1 2

(4∗1)+2=6(4∗1)+2=6

所以答案为 1010

数据限制

对于 100%100% 的数据，保证 1≤n≤106,1≤ai,bi≤230

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int max_n = 1e6;
const int max_ab = pow(2, 30);
const int mod_num = 1000000007;

struct person { long long l, r; }persons[max_n + 1];

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) cin >> persons[i].l >> persons[i].r;
	sort(persons + 1, persons + 1 + n, [](person p1, person p2) {
		return p1.r * p2.l + p2.r > p2.r * p1.l + p1.r;
		});
	long long ans = 0;
	long long sum = 1;
	for (int i = n; i > 0; i--) {
		ans = (ans + persons[i].r * sum) % mod_num;
		sum = (sum * persons[i].l) % mod_num;
	}
	cout << ans << endl;
	return 0;
}

Lusir的游戏

 附加文件 统计

LusirLusir 正在玩一个古老的基于 DOSDOS 的游戏。

游戏中有 N+1N+1 座建筑——从 00 到 NN 编号，从左到右排列。编号为 00 的建筑高度为 00 个单位，编号为 ii 的建筑高度为 H(i)H(i) 个单位。 起初，LusirLusir 在编号为 00 的建筑处。每一步，它跳到下一个（右边）建筑。假设 LusirLusir 在第 kk 个建筑，且它现在的能量值是 EE，下一步它将跳到第 k+1k+1 个建筑。

如果 H(k+1)>EH(k+1)>E，那么 LusirLusir 就失去 H(k+1)−EH(k+1)−E 的能量值，否则他将得到 E−H(k+1)E−H(k+1) 的能量值。

游戏目标是到达第 NN 个建筑，在这个过程中能量值不能为负数个单位。

现在的问题是 LusirLusir 至少以多少能量值开始游戏，才可以保证成功完成游戏？

输入格式

第一行输入整数 NN。 第二行是 NN 个空格分隔的整数，H(1),H(2),…,H(N)H(1),H(2),…,H(N) 代表建筑物的高度。

输出格式

输出一个整数，表示所需的最少单位的初始能量值上取整后的结果。

数据范围

1≤N,H(i)≤1051≤N,H(i)≤105

输入样例1：

5
3 4 3 2 4

输出样例1：

4

1.二分进行枚举

2.注意枚举的数大于建筑高度a[i] 最大值maxn时就一定满足，直接返回true即可

#include<iostream>
#include<queue>
using namespace std;
typedef long long ll;
const int N = 1e5;
int a[N],n;
ll ans,maxn;
int check(int mid)
{
	ll res=mid;
	for(int i=1;i<=n;i++)
	{
	    res=res+(res-a[i]);
	    if(res>maxn)return 1;
		if(res<0)return 0;
	}
	return 1;
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
		if(a[i]>maxn)maxn = a[i];
	}
	int l = 0,r = 1e6;
	while(l<=r)
	{
		int mid = l+r>>1;
		if(check(mid))ans=mid,r=mid-1;
		else l=mid+1;
	}
	cout<<ans;
	return 0;
}

#147. BFS练习1

 附加文件 统计

给你一个数字aa，每次可以选择下面四种操作中的一种：

  1. 把数字aa加上一。
  2. 把数字aa乘以22。
  3. 把数字aa乘以33。
  4. 把数字aa减去一。

问把这个aa变成bb最少需要多少步。

你要回答qq个询问，b1,b2,…,bqb1,b2,…,bq，输出把aa变成b1,b2,…,bqb1,b2,…,bq的最小步数。

输入格式

第一行两个整数a,qa,q。

接下来一行qq个整数b1,…,bqb1,…,bq。

输入格式

输出qq个数字，分别表示把aa变成b1,b2…,bqb1,b2…,bq的最小步数。

样例输入

3 10
1 2 3 4 5 6 7 8 9 10

样例输出

2 1 0 1 2 1 2 2 1 2

数据规模

对于所有数据，保证1≤a,q,bi≤1051≤a,q,bi≤105。

BFS减枝

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>

#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int N = 300050;
int a[N], f[N];

inline int read() {
    int x = 0; char ch = getchar();
    while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
    return x;
}

void write(int x) {
    if (x > 9) write(x / 10);
    putchar(x % 10 | '0');
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n, num;
    num = read(), n = read();
    vector<int>v(n);
    for (int i = 0; i < n; i++)
    {
        v[i] = read();
        a[v[i]] = -1;
    }
    queue<int>que;
    que.push(num);
    int res = 0;
    while (!que.empty()&&n)
    {
        int len = que.size();
        for (int i = 0; i < len; i++)
        {
            int ans = que.front();
            que.pop();
            if (a[ans] == -1)
            {
                a[ans] = res;
                n--;
            }
            if (ans * 3 < 100050 && f[ans * 3] == 0)
            {
                que.push(ans * 3);
                f[ans * 3] = 1;
            }
            if (ans * 2 < 100050 && f[ans * 2] == 0)
            {
                que.push(ans * 2);
                f[ans * 2] = 1;
            }
            if (ans - 1 > 0 && f[ans - 1] == 0)
            {
                que.push(ans - 1);
                f[ans - 1] = 1;
            }
            if (ans + 1 < 100050 && f[ans + 1] == 0)
            {
                que.push(ans + 1);
                f[ans + 1] = 1;
            }
        }
        res++;
    }
    for (auto i : v)
    {
        write(a[i]); 
        putchar(' ');
    }
    
    return 0;
}

01序列2

 附加文件 统计

又是大家最喜欢的01序列问题了呢

这次的问题非常的简单，cc觉得一个01序列中两个1之间至少要有kk个00，现在他要构造出一个长度为nn的01序列，请问他有多少种不同的构造方法

这个数字可能会非常大，请你对109+7109+7取模

输入格式

一行，给出两个整数n，kn，k

输出格式

一个整数，代表不同的构造方法数

数据范围

1≤n≤1061≤n≤106

0≤k<n0≤k<n

样例输入

4 2

样例输出

6

需要用组合数取模。组合数取模用Lucas定理最后一个点似乎会超时 

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>

#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int N = 1000050, MOD = 1e9 + 7;

ll fact[N], infact[N];

ll qmi(int a, int b)
{
    ll res = 1;
    while (b)
    {
        if (b & 1) res = res * a % MOD;
        a = a * (ll)a % MOD;
        b >>= 1;
    }
    return res;
}

void init()
{
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i++)
        fact[i] = fact[i - 1] * i % MOD;

    infact[N - 1] = qmi(fact[N - 1], MOD - 2);
    for (int i = N - 2; i; i--)
        infact[i] = infact[i + 1] * (i + 1) % MOD;
}

int C(int a, int b)
{
    return (fact[a] * infact[b] % MOD * infact[a - b] % MOD) % MOD;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n, k;
    init();
    cin >> n >> k;
    int i = 1;
    ll res = 1;
    while (i <= n - (i - 1) * k)
    {
        res = (res + C(n - (i - 1) * k, i) % MOD) % MOD;
        i++;
    }
    cout << res << endl;
    return 0;
}

 

整除光棍

 附加文件 统计

这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由 11 组成的数字，比如 1、111、111、11111、111、111、1111 等。传说任何一个光棍都能被一个不以 55 结尾的奇数整除。比如， 111111111111 就可以被 1313 整除。 现在，你的程序要读入一个整数 xx ，这个整数一定是奇数并且不以 55 结尾。然后，经过计算，输出两个数字：第一个数字 ss，表示xx 乘以 ss 是一个光棍，第二个数字nn是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。

提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除 xx 为止。但难点在于，ss 可能是个非常大的数 —— 比如，程序输入 3131 ，那么就输出 35842293906813584229390681和 1515 ，因为 3131 乘以 35842293906813584229390681 的结果是 111111111111111111111111111111 ，一共 1515 个 11。

输入格式

输入在一行中给出一个不以 55 结尾的正奇数 x（x<1000)x（x<1000)。

输出格式

在一行中输出相应的最小的 ss 和 nn，其间以 11 个空格分隔。

样例输入

31

样例输出

3584229390681 15

数太大枚举肯定会超出数据范围，因为被除数都是由1组成的，我们可以模拟直接除法的过程 

#include<iostream>
using namespace std;
int x,n,num;
int main()
{
	cin>>x;
	while(num<x)
	{
	num=num*10+1;
	n++;	
	}
	while(1)
	{
		cout<<num/x;
		num%=x;
		if(num==0)break;
		num=num*10+1;
		n++;
	}
	cout<<' '<<n;
	return 0;
}

 

Funing7
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
CPU缓存侧信道攻击综述-Survey of CPU Cache-Based Side-Channel Attacks
君子藏器于身，待时而动
12-23 2019
CPU缓存侧信道攻击
signature=a8a3e788013f73439051c7287d7f5f0b,广东省第三届强网杯Writeup
weixin_29064009的博客
05-29 1万+
原创：Team233合天智汇0X00 Pwn1​没有检查偏移，有数组越界​sleep有多线程竞争解题思路：主要是利用多线程竞争时候的sleep(3)，run后把对应的堆块free掉之后，可以泄露地址。本地远程同时测试得到环境是libc2.27，用ubuntu18.04直接跑测试，然后通过填满tcache来泄露libc，然后通过run来修改fd为free_hook，然后再malloc两次，第二次写...
图解系列--密钥，随机数，应用技术
x13262608581的博客
11-22 1563
密钥，随机数，应用技术
iOS每日一记------------之 中级完美大整理
mo_xiao_mo的博客
09-22 1921
iOS、mac开源项目及库汇总 UI 下拉刷新 EGOTableViewPullRefresh – 最早的下拉刷新控件。SVPullToRefresh – 下拉刷新控件。MJRefresh – 仅需一行代码就可以为UITableView或者CollectionView加上下拉刷新或者上拉刷新功能。可以自定义上下拉刷新的文字说明。具体使用看“使用方法”。 （国人写）XHRefreshC
运维开发工程师(BKDS)理论基础
静静是我女朋友
02-27 2256
运维开发工程师(BKDS)理论基础 蓝鲸SaaS开发框架包含哪些Web防护策略? A. 防 CSRF 攻击 B. 防 XSS 攻击 C. 防 SQL注入 D. 没有Web安全防护 正确答案:A,B,C 社区版如何将第三方系统放在工作台中使用? A. 社区版不支持第三方系统链接接入 B. 通过修改配置文件添加第三方系统链接 C. 通过PaaS平台DB管理端:domain/admin，添加“常用链接” D. 直接登录数据库，修改DB数据，添加“常用链接” 正确答案:C,D 以下哪些是生成器自身的方法? A.
【网络安全02】对称加密和消息机密性（对称加密原理 、对称分组加密算法 、DES、随机数和伪随机数 、流密码和RC4、分组密码工作模式）
weixin_43209177的博客
03-22 4619
文章目录2.1 对称加密原理2.1.1 密码体制2.1.2 密码分析2.1.3 Feistel 密码结构2.2 对称分组加密算法2.2.1 数据加密标准 (DES)2.2.2 三重DES2.2.3 高级加密标准2.3 随机数和伪随机数2.3.1 随机数的应用2.3.2 真随机数发生器、伪随机数生成器和伪随机函数2.3.3 算法设计2.4 流密码和RC42.4.1 流密码结构2.4.2 RC4算法2.5 分组密码工作模式2.5.1 电子密码本模式 (ECB)2.5.2 密码分组链接模式 (CBC)2.5.3
Nginx#Nginx-Typora笔记
热门推荐
kakaops_qing的博客
10-09 4万+
nginx基础笔记
day07-vue项目-搭建项目到登录功能
qq_33820545的博客
08-18 274
文章目录1.电商业务概述2.项目初始化3.码云相关操作B.安装gitD.在本地创建公钥：在终端运行：ssh-keygen -t rsa -C "xxx@xxx.com"4.配置后台项目A.安装phpStudy并导入mysql数据库数据B.安装nodeJS，配置后台项目,从终端打开后台项目vue_api_serverC.使用postman测试api接口5.实现登录功能概述A.登录状态保持B.登录逻辑C.添加新分支login，在login分支中开发当前项目vue_shop进一步处理A.添加element-ui的
RSA-Digital-Signature-master_加密_RSA数字签名_
10-02
这个"RSA-Digital-Signature-master"压缩包可能包含了一个关于如何使用RSA算法实现数字签名的示例代码或教程。 在RSA算法中，一对密钥被生成：公钥和私钥。公钥可以公开给任何人，而私钥则必须由密钥拥有者妥善保管...
easy-rsa-2.2.0.tar.gz
06-30
首先，我们需要从源代码包`easy-rsa-2.2.0.tar.gz`中解压并安装。这通常包括解压、进入目录、配置和编译过程。在Unix/Linux环境下，可以使用以下命令： ``` tar -zxvf easy-rsa-2.2.0.tar.gz cd easy-rsa-2.2.0 ./...
DES-RSA-master_rsa签名_withlrk_数字签名_
09-29
数字签名，网上下的，只是加密，DES啥的
ocaml-tls：纯OCaml中的T​​LS
02-06
- **密钥交换**：TLS支持多种密钥交换算法，如RSA、Diffie-Hellman（包括ECDH）等，确保只有通信双方能解密通信内容。 - **加密**：TLS使用对称加密和非对称加密相结合的方式，非对称加密用于密钥交换，对称加密...
针对RSA-CRT数字签名的光故障攻击研究
01-28
以Montgomery乘的 RSA-CRT数字签名算法为攻击对象，分析其算法的实现过程和故障注入机理。针对密码芯片实现的8位RSA-CRT签名算法，使用半导体激光作为注入光源，搭建光注入实验平台，在计算Sq时刻进行故障注入，从而...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1194
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 662
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 272
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1133
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
Python实现RSA算法数字签名软件设计
4. 生成数字签名：使用私钥对哈希值进行签名操作，这通常是通过`RSA.sign()`方法完成的。 5. 验证数字签名：接收方使用公钥对签名进行验证，通过`RSA.verify()`方法确保哈希值未被篡改且签名有效。 在实际应用中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值