一些-study项目中有用的代码片段

[C++]生成GUID(仅Windows下可用)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <objbase.h>

GUID CreateGuid() {
    GUID guid;
    if (CoCreateGuid(&guid) == S_OK) {
        return guid;
    }
    throw exception("generate guid failed!");
}

string GuidToString(const GUID& guid) {
    char buf[64] = { 0 };
    snprintf(buf, sizeof(buf),
        "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
        guid.Data1, guid.Data2, guid.Data3,
        guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
        guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
    return string(buf);
}

[C++]高斯消元

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <vector>
class Matrix : public std::vector<std::vector<double> > {
public:
	void Init(int row, int col) {
		assign(row, vector<double>());
		for (int i = 0; i < row; i++) {
			at(i).assign(col, 0);
		}
	}
};
/*要求系数矩阵可逆
此处A为增广矩阵，即A[i][n]为第i个方程右边的常数bi
运行结束后A[i][n]为第i个未知数的值 */
void gauss_elimination(std::vector<std::vector<double> >& A, int n) {
	int i, j, k, r;
	//消元过程
	for (i = 0; i < n; i++) {
		//选一行r并与第i行交换
		r = i;
		for (j = i + 1; j < n; j++) {
			if (fabs(A[j][i]) > fabs(A[r][i])) {
				r = j;
			}
		}
		if (r != i) {
			for (j = 0; j <= n; j++) {
				std::swap(A[r][j], A[i][j]);
			}
		}
		//与第i+1至第n行进行消元
		for (k = i + 1; k < n; k++) {
			double f = A[k][i] / A[i][i];
			for (j = i; j <= n; j++) {
				A[k][j] -= f * A[i][j];
			}
		}
	}
	//回代过程
	for (i = n - 1; i >= 0; i--) {
		for (j = i + 1; j < n; j++) {
			A[i][n] -= A[j][n] * A[i][j];
		}
		A[i][n] /= A[i][i];
	}
}

[C++]多项式拟合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>

// 高斯消元，定义在上一节
void gauss_elimination(std::vector<std::vector<double> >& A, int n)
inline bool fequal(double a, double b) {
	return fabs(a - b) < 1e-6;
}
void fxformatprint(std::vector<std::vector<double> > a, int n) {
	bool first = 1;
	int last = 0;
	std::cout << std::fixed << "f(x)=";
	for (int i = 0; i < n; i++) {
		if (fequal(a[i][n], 0)) {
			continue;
		}
		last = i;
		if (a[i][n] > 0 && !first) {
			std::cout << '+';
		}
		if (!fequal(a[i][n], 1)) {
			if (fequal(a[i][n], -1)) {
				std::cout << '-';
			}
			else {
				std::cout << a[i][n];
			}
		}
		if (n - (i + 1) > 1) {
			std::cout << "x^" << n - (i + 1);
		}
		else if (n - (i + 1) == 1) {
			std::cout << "x";
		}
		first = 0;
	}
	if (fequal(a[last][n], -1)) {
		std::cout << 1;
	}
}
// 仅支持{(1, a1),(2, a2),...,(n, an)}的数据
int main() {
    std::vector<std::vector<double> > a;
    int n;
	std::cin >> n;
    a.assign(row, vector<double>());
    for (int i = 0; i < row; i++) {
        a.at(i).assign(col, 0);
    }
	for (int i = 0; i < n; i++) {
		std::cin >> a[i][n];
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			a[i][j] = pow(i + 1, n - (j + 1));
		}
	}
    // 高斯消元
	gauss_elimination(a, n);
    // 多项式输出
	fxformatprint(a, n);
	return 0;
}

[C++]斗地主牌型解析(?)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
const int CardTypeCount = 13;
enum CardType {
	Single,
	Double,
	Triple,
	TripleSingle,
	TripleDouble,
	Straight,
	DoubleStraight,
	TripleStraight,
	PlaneWithSingle,
	PlaneWithDouble,
	Bomb,
	SuperBomb,
	BombDouble,
};
std::map<std::multiset<int>, CardType> CardTypeMap{
	{std::multiset<int>({4}),CardType::Bomb},
	{std::multiset<int>({4,2}),CardType::BombDouble},

	{std::multiset<int>({3}),CardType::Triple},
	{std::multiset<int>({3,1}),CardType::TripleSingle},
	{std::multiset<int>({3,2}),CardType::TripleDouble},

	{std::multiset<int>({3,3}),CardType::TripleStraight},
	{std::multiset<int>({3,3,3}),CardType::TripleStraight},
	{std::multiset<int>({3,3,3,3}),CardType::TripleStraight},
	{std::multiset<int>({3,3,3,3,3}),CardType::TripleStraight},

	{std::multiset<int>({3,3,1,1}),CardType::PlaneWithSingle},
	{std::multiset<int>({3,3,3,1,1,1}),CardType::PlaneWithSingle},

	{std::multiset<int>({3,3,2,2}),CardType::PlaneWithDouble},
	{std::multiset<int>({3,3,3,2,2,2}),CardType::PlaneWithDouble},

	{std::multiset<int>({2}),CardType::Double},

	{std::multiset<int>({2,2,2}),CardType::DoubleStraight},
	{std::multiset<int>({2,2,2,2}),CardType::DoubleStraight},
	{std::multiset<int>({2,2,2,2,2}),CardType::DoubleStraight},
	{std::multiset<int>({2,2,2,2,2,2}),CardType::DoubleStraight},
	{std::multiset<int>({2,2,2,2,2,2,2}),CardType::DoubleStraight},
	{std::multiset<int>({2,2,2,2,2,2,2,2}),CardType::DoubleStraight},

	{std::multiset<int>({1}),CardType::Single},
	{std::multiset<int>({1,1}),CardType::Double},

	{std::multiset<int>({1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
	{std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
};
class CardToken {
private:
	std::string BaseString;
	CardType Type;
	template<class T>
	std::multiset<std::pair<int, T>> Count(std::vector<T> v) {
		constexpr int tmpsize = std::numeric_limits<T>::max() - std::numeric_limits<T>::min();
		int tmp[tmpsize];
		memset(tmp, 0, sizeof(tmp));
		for (int i = 0; i < v.size(); i++) {
			tmp[v[i]]++;
		}
		std::multiset<pair<int, T>> ans;
		for (int i = 0; i < tmpsize; i++) {
			if (tmp[i] != 0) {
				ans.insert(pair<int, T>(tmp[i], i));
			}
		}
		return ans;
	}
	template<class T>
	CardType GetCardTypeByCountResult(std::multiset<std::pair<int, T>> CountResult) {
		std::multiset<int> times, cards;
		for (typename std::multiset<std::pair<int, T>>::const_iterator iter = CountResult.begin(); iter != CountResult.end(); iter++) {
			times.insert(iter->first);
			cards.insert(iter->second);
		}
		CardType ans = CardTypeMap[times];
		if (ans == CardType::Double && cards.count('S') && cards.count('L')) {
			ans = CardType::SuperBomb;
		}
		return ans;
	}
public:
	CardToken(std::string BaseString) :BaseString(BaseString) {};
	CardToken() { BaseString = ""; }

	CardType GetCardType()const { return Type; }
	void SetCardType(CardType Type) {
		if (Type >= CardTypeCount || Type < 0) {
			throw "CardType undefined!";
		}
		this->Type = Type;
	}
	std::string GetBaseString()const { return BaseString; }
	void SetBaseString(const std::string& BaseString) {
		this->BaseString = BaseString;
		this->Type = GetCardTypeByCountResult(Count(std::vector<char>(BaseString.begin(), BaseString.end())));
	}
};
//3-10(X is 10),JQK,small and large king
//const std::string SortedCards = "3456789XJQK12SL";

[C++]分数类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#pragma once
#include <sstream>

template<class Integer>
class FractionBase {
private:
	inline const Integer& gcd(const Integer& a, const Integer& b) {
		return b > 0 ? gcd(b, a % b) : a;
	}
	inline const Integer& lcm(const Integer& a, const Integer& b) {
		return a * b / gcd(a, b);
	}
	inline const Integer& pow(const Integer& a, int b) {
		Integer result = 1;
		for (int i = 1; i <= b; i++) {
			result *= a;
		}
		return result;
	}
	inline int GetDecimalLength(double a) {
		std::stringstream ss;
		ss << a - (int)a;
		return ss.str().length() - 2;
	}
	inline int GetDecimalLength(long double a) {
		std::stringstream ss;
		ss << a - (int)a;
		return ss.str().length() - 2;
	}
	inline void Simplify() {
		
		Integer gcdValue = gcd(numerator, denominator);
		numerator /= gcdValue;
		denominator /= gcdValue;
	}
	Integer numerator, denominator;
public:
	FractionBase(const Integer& numerator, const Integer& denominator):
		numerator(numerator), denominator(denominator) {
		Simplify();
	}
	FractionBase(double a) {
		(*this) = a;
	}
	FractionBase(long double a) {
		(*this) = a;
	}
	FractionBase(const Integer& a) {
		(*this) = a;
	}
	FractionBase() { }
	// 获取分子
	Integer& GetNumerator() { return numerator; }
	// 获取分母
	Integer& GetDenominator() { return denominator; }
	// 获取倒数
	inline FractionBase GetReversed() { return FractionBase(denominator, numerator); }

	void SetNumerator(Integer numerator) {
		this->numerator = numerator;
	}
	void SetDenominator(Integer deno) {
		if (deno == 0) {
			throw "The denominator cannot be 0!";
		}
		denominator = deno;
		//std::cout << denominator << ' ' << deno << std::endl;
	}
	
	FractionBase& operator=(FractionBase a) {
		numerator = a.numerator;
		denominator = a.denominator;
		Simplify();
		return *this;
	}
	FractionBase& operator=(const Integer& a) {
		SetNumerator(a);
		SetDenominator(1);
		Simplify();
		return *this;
	}
	FractionBase& operator=(double a) {
		int DecimalLength = GetDecimalLength(a);
		SetNumerator(a * pow(10, DecimalLength));
		SetDenominator(pow(10, DecimalLength));
		Simplify();
		return *this;
	}
	FractionBase& operator=(long double a) {
		int DecimalLength = GetDecimalLength(a);
		SetNumerator(a * pow(10, DecimalLength));
		SetDenominator(pow(10, DecimalLength));
		Simplify();
		return *this;
	}

	friend FractionBase operator+(FractionBase& a, FractionBase& b) {
		return FractionBase(a.GetNumerator() * b.GetDenominator() + a.GetDenominator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
	}
	friend FractionBase operator-(FractionBase& a, FractionBase& b) {
		return FractionBase(a.GetNumerator() * b.GetDenominator() - a.GetDenominator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
	}
	friend FractionBase operator*(FractionBase& a, FractionBase& b) {
		return FractionBase(a.GetNumerator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
	}
	friend FractionBase operator/(FractionBase& a, FractionBase& b) {
		return a * b.GetReversed();
	}
	friend FractionBase& operator+=(FractionBase& a, const FractionBase& b) { return a = a + b; }
	friend FractionBase& operator-=(FractionBase& a, const FractionBase& b) { return a = a - b; }
	friend FractionBase& operator*=(FractionBase& a, const FractionBase& b) { return a = a * b; }
	friend FractionBase& operator/=(FractionBase& a, const FractionBase& b) { return a = a / b; }

	friend bool operator>(const FractionBase& a, const FractionBase& b) {
		return a.GetNumerator() * b.GetDenominator() > a.GetDenominator() * b.GetNumerator();
	}
	friend bool operator<(const FractionBase& a, const FractionBase& b) {
		return a.GetNumerator() * b.GetDenominator() < a.GetDenominator() * b.GetNumerator();
	}
	friend bool operator==(const FractionBase& a, const FractionBase& b) {
		return a.GetNumerator() == b.GetNumerator() && a.GetDenominator() == b.GetDenominator();
	}
	friend bool operator>=(const FractionBase& a, const FractionBase& b) {
		return a > b || a == b;
	}
	friend bool operator<=(const FractionBase& a, const FractionBase& b) {
		return a < b || a == b;
	}
	friend bool operator!=(const FractionBase& a, const FractionBase& b) {
		return !(a == b);
	}

	template<class T>
	friend std::ostream& operator<<(std::ostream& os, FractionBase<T> a);
	template<class T>
	friend std::istream& operator>>(std::istream& is, FractionBase<T>& a);
};

template<class Integer>
std::ostream& operator<<(std::ostream& os, FractionBase<Integer> a) {
	return os << a.GetNumerator() << '/' << a.GetDenominator();
}
template<class Integer>
std::istream& operator>>(std::istream& is, FractionBase<Integer>& a) {
	Integer numerator, denominator;
	is >> numerator >> denominator;
	a.SetNumerator(numerator);
	a.SetDenominator(denominator);
	return is;
}

typedef FractionBase<int> frac;

[C++]随机数生成器类(梅森旋转法)

从一个实际项目中抽出来的 所以使用了functional

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#pragma once
#include <functional>
#include <ctime>

class Random
{
private:
	int MTindex;
	long long MT[624];
	void csrand(int seed) {
		MTindex = 0;
		MT[0] = seed;
		for (int i = 1; i < 624; i++) {
			int t = 1812433253 * (MT[i - 1] ^ (MT[i - 1] >> 30)) + i;
			MT[i] = t & 0xffffffff;
		}
	}
	inline void generate() {
		for (int i = 0; i < 624; i++) {
			long long y = (MT[i] & 0x80000000) + (MT[(i + 1) % 624] & 0x7fffffff);
			MT[i] = MT[(i + 397) % 624] ^ (y >> 1);
			if (y % 2 == 1) MT[i] ^= 2147483647;
		}
	}
public:
	std::function<int()> RandInt = [this] {
		if (MTindex == 0) generate();
		int y = MT[MTindex];
		y = y ^ (y >> 11);
		y = y ^ ((y << 7) & 1636928640);
		y = y ^ ((y << 15) & 1022730752);
		y = y ^ (y >> 18);
		MTindex = (MTindex + 1) % 624;
		return y;
	};
	std::function<int(int, int)> RandIntEx = [this](int Min, int Max) {
		if (Min > Max) Min = Max;
		if (Min == Max) return Min;
		else return RandInt() % (Max - Min + 1) + Min;
	};
	std::function<long long()> RandLongLong = [this] {
		return ((long long)(RandInt()) << 31) + RandInt();
	};
	std::function<long long(long long, long long)> RandLongLongEx = [this](long long Min, long long Max) {
		if (Min > Max) Min = Max;
		if (Min == Max) return Min;
		else return RandLongLong() % (Max - Min + 1) + Min;
	};
	std::function<bool()> RandBool = [this] {
		return RandIntEx(0, 1);
	};
	std::function<char()> RandVisibleChar = [this] {
		return RandIntEx(32, 126);
	};
	std::function<char()> RandUpperLetter = [this] {
		return RandIntEx('A', 'Z');
	};
	std::function<char()> RandLowerLetter = [this] {
		return RandIntEx('a', 'z');
	};
	std::function<char()> RandLetter = [this] {
		return RandBool() ? RandUpperLetter() : RandLowerLetter();
	};
	std::function<char()> RandFormatChar = [this] {
		const char fmtc[5] = { '\n','\t','\r','\v','\f' };
		return fmtc[RandIntEx(0, 4)];
	};
	std::function<std::string(int)> RandWord = [this](int Length) {
		std::string result = "";
		for (int i = 0; i < Length; i++) {
			result = result + RandLetter();
		}
		return result;
	};
	std::function<std::string(int, int, int)> RandArticle = [this](int WordSum, int WordLengthMin = 1, int WordLengthMax = 10) {
		std::string result;
		result = RandWord(RandIntEx(WordLengthMin, WordLengthMax));
		for (int i = 1; i < WordSum; i++) {
			result = result + " " + RandWord(RandIntEx(WordLengthMin, WordLengthMax));
		}
		return result;
	};

	Random() {
		csrand((int)time(NULL));
	}
	~Random() {

	}
};