亦年的一年

第八届蓝桥杯javaC组真题

外星日历

某星系深处发现了文明遗迹。

他们的计数也是用十进制。

他们的文明也有日历。日历只有天数，没有年、月的概念。

有趣的是，他们也使用了类似“星期”的概念，

只不过他们的一个星期包含了9天，

为了方便，这里分别记为: A,B,C....H,I

从一些资料上看到，

他们的23日是星期E

他们的190日是星期A

他们的343251日是星期I

令人兴奋的是，他们居然也预见了“世界末日”的那天，

当然是一个很大很大的数字

651764141421415346185

请你计算一下，这遥远的一天是该文明的星期几？

你需要提交的是一个大写字母，表示该文明的星期几，

不要填写任何多余的内容。

import java.math.BigInteger;

/**
 * @createDate：2019年3月18日 上午8:14:53
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：外星日历.java @describe：
 */
public class 外星日历 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BigInteger sum = new BigInteger("651764141421415346185");
		int sus = sum.mod(BigInteger.valueOf(9)).intValue();
		System.out.println((char) (sus - 1 + 'A'));
	}
}

兴趣小组

为丰富同学们的业余文化生活，某高校学生会创办了3个兴趣小组

（以下称A组，B组，C组）。

每个小组的学生名单分别在【A.txt】,【B.txt】和【C.txt】中。

每个文件中存储的是学生的学号。

由于工作需要，我们现在想知道：

既参加了A组，又参加了B组，但是没有参加C组的同学一共有多少人？

请你统计该数字并通过浏览器提交答案。

注意：答案是一个整数，不要提交任何多余的内容。

--------------------

笨笨有话说：

哇塞！数字好多啊！一眼望过去就能发现相同的，好像没什么指望。

不过，可以排序啊，要是每个文件都是有序的，那就好多了。

歪歪有话说：

排什么序啊，这么几行数字对计算机不是太轻松了吗？

我看着需求怎么和中学学过的集合很像啊.....

【A】

12894792, 92774113, 59529208, 22962224, 02991600, 83340521, 87365045,

40818286, 16400628, 39475245, 55933381, 76940287, 61366748, 95631228,

17102313, 50682833, 61562613, 87002524, 83062019, 51743442, 61977890,

32010762, 69680621, 87179571, 81761697, 32364296, 07833271, 36198035,

26588918, 84046668, 43059468, 73191775, 56794101, 00454780, 11141030,

10008994, 35072237, 44945158, 53959980, 75758119, 18560273, 35801494,

42102550, 22496415, 03981786, 34593672, 13074905, 07733442, 42374678,

23452507, 98586743, 30771281, 17703080, 52123562, 05898131, 56698981,

90758589, 18238802, 18217979, 04511837, 75682969, 31135682, 55379006,

42224598, 98263070, 40228312, 28924663, 11580163, 25686441, 45944028,

96731602, 53675990, 03854194, 14858183, 16866794, 40677007, 73141512,

32317341, 56641725, 43123040, 15201174, 62389950, 72887083, 76860787,

61046319, 06923746, 17874548, 46028629, 10577743, 48747364, 05328780,

59855415, 60965266, 20592606, 14471207, 70896866, 46938647, 33575820,

53426294, 56093931, 51326542, 94050481, 80114017, 33010503, 72971538,

22407422, 17305672, 78974338, 93209260, 83461794, 41247821, 26118061,

10657376, 42198057, 15338224, 50284714, 32232841, 26716521, 76048344,

23676625, 62897700, 69296551, 59653393, 38704390, 48481614, 69782897,

26850668, 37471053, 88720989, 51010849, 94951571, 60024611, 29808329,

70377786, 13899299, 09683688, 58218284, 46792829, 97221709, 45286643,

48158629, 57367208, 26903401, 76900414, 87927040, 09926730, 01508757,

15101101, 62491840, 43802529,

【B】

44894050, 34662733, 44141729, 92774113, 99208727, 91919833, 23727681,

10003409, 55933381, 54443275, 13584702, 96523685, 50682833, 61562613,

62380975, 20311684, 93200452, 23101945, 42192880, 28992561, 18460278,

19186537, 58465301, 01111066, 62680429, 23721241, 20277631, 91708977,

57514737, 03981786, 81541612, 07346443, 93154608, 19709455, 37446968,

17703080, 72378958, 66200696, 30610382, 89586343, 33152171, 67040930,

35696683, 63242065, 99948221, 96233367, 52593493, 98263070, 01418023,

74816705, 89375940, 58405334, 96731602, 84089545, 16866794, 94737626,

01673442, 70548494, 13638168, 08163691, 11106566, 64375392, 40267902,

00897705, 56447313, 54532235, 94738425, 66642634, 83219544, 40546096,

66924991, 20592606, 96037590, 73434467, 70896866, 91025618, 57892091,

08487641, 32500082, 84412833, 23311447, 38380409, 79957822, 72971538,

69645784, 91863314, 73099909, 93209260, 83461794, 81378487, 30423273,

22233715, 32232841, 26716521, 03511221, 29196547, 58263562, 56233305,

52547525, 55812835, 87253244, 52484232, 80837360, 94098464, 52028151,

53267501, 66381929, 84381316, 59788467, 09683688, 67082008, 71605255,

80654064, 21434307, 45286643, 76556656, 82465821, 57367208, 79218980,

48460468, 59170479, 46046391, 43043164, 96544490, 83340521, 70837892,

18926791, 40818286, 28936302, 11489524, 51031183, 73860337, 13241219,

09025448, 10718828, 76360986, 26031606, 76558053, 97726139, 46473415,

48406387, 23625539, 86756012, 35164187, 49161302, 78082834, 35072237,

08602486, 29815841, 56562216, 77684187, 81751704, 20160464, 50407962,

27786415, 19893526, 00934129, 37759498, 52636463, 25666982, 43262852,

38393436, 02581136, 29323250, 56950657, 05898131, 95286262, 75574581,

54057961, 06703896, 90758589, 57782642, 34492535, 41919697, 06395464,

10993500, 81212949, 34017532, 69569396, 99009936, 57129610, 67401593,

71044018, 62076698, 29533873, 71936325, 86874388, 26545032, 35695544,

30433724, 53127345, 72887083, 25390873, 63711546, 06923746, 27783723,

33199575, 35929698, 16491251, 18276792, 62744775, 92096155, 06336570,

56141974, 73007273, 31416832, 00171057, 64176982, 46938647, 58460388,

69972026, 73724304, 27435484, 51568616, 15531822, 47788699, 11818851,

41594694, 83561325, 43107163, 56965375, 10557343, 26118061, 74650126,

90076467, 10657376, 49901436, 03425162, 61164599, 15797769, 05427896,

14444084, 36795868, 18079449, 59653393, 72942548, 06763077, 33895610,

94892653, 12085268, 65174140, 79567366, 23020126, 74290047, 13498869,

21696323, 27724594, 54941003, 38229841, 07050068,

【C】

13404901, 39952424, 47847739, 94939581, 13809950, 70966043, 11161555,

17102313, 47079425, 50682833, 74154313, 61562613, 93200452, 37103342,

18479435, 32502597, 36198035, 54210010, 73191775, 48358178, 85544503,

05996766, 54651623, 52113220, 27465181, 23871783, 22496415, 54107041,

65899605, 56528700, 82671109, 61176034, 42374678, 51612628, 63329997,

56591652, 04552733, 12789324, 89586343, 51935014, 38611966, 43916409,

70996050, 98263070, 01418023, 65345049, 21734275, 76846198, 71506230,

00833171, 67128139, 41367555, 64769510, 44010700, 16475199, 93164325,

09386162, 95324041, 80688223, 67629139, 79552617, 76219736, 50368644,

45096021, 54972488, 63779011, 28862942, 73145521, 74078605, 66924991,

12806850, 02171001, 70896866, 73434467, 08487641, 44415025, 32500082,

84412833, 83896188, 52243759, 49191410, 38744339, 48079796, 44937032,

06267501, 81866886, 38575984, 25978688, 78974338, 41247821, 12356966,

64842303, 79127158, 02366944, 68000570, 12426275, 96409230, 00705972,

08266503, 83820884, 08831807, 43273308, 23216105, 29196547, 95160161,

05553537, 52182214, 32641346, 91553427, 24436506, 77433749, 01979664,

52028151, 88985343, 01761499, 76203088, 63237368, 23405334, 59788467,

09683688, 67755443, 29946533, 12053603, 00437479, 15200030, 45286643,

93537527, 82465821, 57367208, 53899751, 15354933, 97760830, 68933762,

80220545, 01892750, 39868288, 21524323, 69716610, 65083815, 78048499,

03227391, 83340521, 87365045, 71720254, 51031183, 89168555, 08503028,

37086236, 25103057, 87002524, 22808816, 80928090, 90741678, 15993372,

99117082, 49938176, 21755083, 86903426, 87830263, 53959980, 75758119,

59781354, 58679691, 25666982, 56307643, 47180521, 62776522, 78136608,

44882734, 90758589, 08075999, 66303819, 23480347, 11580163, 87080118,

18329165, 92514163, 89404632, 92377859, 03912329, 17499963, 59699979,

79876366, 63894807, 37857001, 86003935, 90087123, 29433345, 80298948,

61531153, 61046319, 37839841, 19421134, 48747364, 35196916, 62484573,

59907079, 36845702, 21631642, 72739317, 26283700, 80114017, 76639390,

29154110, 35159758, 47788699, 11818851, 56520669, 36396767, 36031167,

83817428, 10657376, 90076467, 14676452, 11024560, 16327605, 76048344,

14444084, 95452011, 99612346, 65172562, 84813675, 88618282, 38704390,

27998014, 63859011, 33787505, 60024611, 16229880, 13899299, 35240335,

29173227, 45036451, 66177893, 82658333, 43100730, 44520187, 74290047,

85013538, 09926730, 27724594, 95148523, 20503000, 64390907, 26006953,

98116293, 97457666, 29017396, 04634371, 70791589,

import java.util.ArrayList;
import java.util.List;

/**
 * @createDate：2019年3月18日 上午8:27:25
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：兴趣小组.java @describe：
 */
public class 兴趣小组 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List list = new ArrayList();
		int arr1[] = { 12894792, 92774113, 59529208, 22962224, 2991600, 83340521, 87365045, 40818286, 16400628,
				39475245, 55933381, 76940287, 61366748, 95631228, 17102313, 50682833, 61562613, 87002524, 83062019,
				51743442, 61977890, 32010762, 69680621, 87179571, 81761697, 32364296, 7833271, 36198035, 26588918,
				84046668, 43059468, 73191775, 56794101, 454780, 11141030, 10008994, 35072237, 44945158, 53959980,
				75758119, 18560273, 35801494, 42102550, 22496415, 3981786, 34593672, 13074905, 7733442, 42374678,
				23452507, 98586743, 30771281, 17703080, 52123562, 5898131, 56698981, 90758589, 18238802, 18217979,
				4511837, 75682969, 31135682, 55379006, 42224598, 98263070, 40228312, 28924663, 11580163, 25686441,
				45944028, 96731602, 53675990, 3854194, 14858183, 16866794, 40677007, 73141512, 32317341, 56641725,
				43123040, 15201174, 62389950, 72887083, 76860787, 61046319, 6923746, 17874548, 46028629, 10577743,
				48747364, 5328780, 59855415, 60965266, 20592606, 14471207, 70896866, 46938647, 33575820, 53426294,
				56093931, 51326542, 94050481, 80114017, 33010503, 72971538, 22407422, 17305672, 78974338, 93209260,
				83461794, 41247821, 26118061, 10657376, 42198057, 15338224, 50284714, 32232841, 26716521, 76048344,
				23676625, 62897700, 69296551, 59653393, 38704390, 48481614, 69782897, 26850668, 37471053, 88720989,
				51010849, 94951571, 60024611, 29808329, 70377786, 13899299, 9683688, 58218284, 46792829, 97221709,
				45286643, 48158629, 57367208, 26903401, 76900414, 87927040, 9926730, 1508757, 15101101, 62491840,
				43802529 };

		int arr2[] = { 44894050, 34662733, 44141729, 92774113, 99208727, 91919833, 23727681, 10003409, 55933381,
				54443275, 13584702, 96523685, 50682833, 61562613, 62380975, 20311684, 93200452, 23101945, 42192880,
				28992561, 18460278, 19186537, 58465301, 1111066, 62680429, 23721241, 20277631, 91708977, 57514737,
				3981786, 81541612, 7346443, 93154608, 19709455, 37446968, 17703080, 72378958, 66200696, 30610382,
				89586343, 33152171, 67040930, 35696683, 63242065, 99948221, 96233367, 52593493, 98263070, 1418023,
				74816705, 89375940, 58405334, 96731602, 84089545, 16866794, 94737626, 1673442, 70548494, 13638168,
				8163691, 11106566, 64375392, 40267902, 897705, 56447313, 54532235, 94738425, 66642634, 83219544,
				40546096, 66924991, 20592606, 96037590, 73434467, 70896866, 91025618, 57892091, 8487641, 32500082,
				84412833, 23311447, 38380409, 79957822, 72971538, 69645784, 91863314, 73099909, 93209260, 83461794,
				81378487, 30423273, 22233715, 32232841, 26716521, 3511221, 29196547, 58263562, 56233305, 52547525,
				55812835, 87253244, 52484232, 80837360, 94098464, 52028151, 53267501, 66381929, 84381316, 59788467,
				9683688, 67082008, 71605255, 80654064, 21434307, 45286643, 76556656, 82465821, 57367208, 79218980,
				48460468, 59170479, 46046391, 43043164, 96544490, 83340521, 70837892, 18926791, 40818286, 28936302,
				11489524, 51031183, 73860337, 13241219, 9025448, 10718828, 76360986, 26031606, 76558053, 97726139,
				46473415, 48406387, 23625539, 86756012, 35164187, 49161302, 78082834, 35072237, 8602486, 29815841,
				56562216, 77684187, 81751704, 20160464, 50407962, 27786415, 19893526, 934129, 37759498, 52636463,
				25666982, 43262852, 38393436, 2581136, 29323250, 56950657, 5898131, 95286262, 75574581, 54057961,
				6703896, 90758589, 57782642, 34492535, 41919697, 6395464, 10993500, 81212949, 34017532, 69569396,
				99009936, 57129610, 67401593, 71044018, 62076698, 29533873, 71936325, 86874388, 26545032, 35695544,
				30433724, 53127345, 72887083, 25390873, 63711546, 6923746, 27783723, 33199575, 35929698, 16491251,
				18276792, 62744775, 92096155, 6336570, 56141974, 73007273, 31416832, 171057, 64176982, 46938647,
				58460388, 69972026, 73724304, 27435484, 51568616, 15531822, 47788699, 11818851, 41594694, 83561325,
				43107163, 56965375, 10557343, 26118061, 74650126, 90076467, 10657376, 49901436, 3425162, 61164599,
				15797769, 5427896, 14444084, 36795868, 18079449, 59653393, 72942548, 6763077, 33895610, 94892653,
				12085268, 65174140, 79567366, 23020126, 74290047, 13498869, 21696323, 27724594, 54941003, 38229841,
				7050068 };

		int arr3[] = { 13404901, 39952424, 47847739, 94939581, 13809950, 70966043, 11161555, 17102313, 47079425,
				50682833, 74154313, 61562613, 93200452, 37103342, 18479435, 32502597, 36198035, 54210010, 73191775,
				48358178, 85544503, 5996766, 54651623, 52113220, 27465181, 23871783, 22496415, 54107041, 65899605,
				56528700, 82671109, 61176034, 42374678, 51612628, 63329997, 56591652, 4552733, 12789324, 89586343,
				51935014, 38611966, 43916409, 70996050, 98263070, 1418023, 65345049, 21734275, 76846198, 71506230,
				833171, 67128139, 41367555, 64769510, 44010700, 16475199, 93164325, 9386162, 95324041, 80688223,
				67629139, 79552617, 76219736, 50368644, 45096021, 54972488, 63779011, 28862942, 73145521, 74078605,
				66924991, 12806850, 2171001, 70896866, 73434467, 8487641, 44415025, 32500082, 84412833, 83896188,
				52243759, 49191410, 38744339, 48079796, 44937032, 6267501, 81866886, 38575984, 25978688, 78974338,
				41247821, 12356966, 64842303, 79127158, 2366944, 68000570, 12426275, 96409230, 705972, 8266503,
				83820884, 8831807, 43273308, 23216105, 29196547, 95160161, 5553537, 52182214, 32641346, 91553427,
				24436506, 77433749, 1979664, 52028151, 88985343, 1761499, 76203088, 63237368, 23405334, 59788467,
				9683688, 67755443, 29946533, 12053603, 437479, 15200030, 45286643, 93537527, 82465821, 57367208,
				53899751, 15354933, 97760830, 68933762, 80220545, 1892750, 39868288, 21524323, 69716610, 65083815,
				78048499, 3227391, 83340521, 87365045, 71720254, 51031183, 89168555, 8503028, 37086236, 25103057,
				87002524, 22808816, 80928090, 90741678, 15993372, 99117082, 49938176, 21755083, 86903426, 87830263,
				53959980, 75758119, 59781354, 58679691, 25666982, 56307643, 47180521, 62776522, 78136608, 44882734,
				90758589, 8075999, 66303819, 23480347, 11580163, 87080118, 18329165, 92514163, 89404632, 92377859,
				3912329, 17499963, 59699979, 79876366, 63894807, 37857001, 86003935, 90087123, 29433345, 80298948,
				61531153, 61046319, 37839841, 19421134, 48747364, 35196916, 62484573, 59907079, 36845702, 21631642,
				72739317, 26283700, 80114017, 76639390, 29154110, 35159758, 47788699, 11818851, 56520669, 36396767,
				36031167, 83817428, 10657376, 90076467, 14676452, 11024560, 16327605, 76048344, 14444084, 95452011,
				99612346, 65172562, 84813675, 88618282, 38704390, 27998014, 63859011, 33787505, 60024611, 16229880,
				13899299, 35240335, 29173227, 45036451, 66177893, 82658333, 43100730, 44520187, 74290047, 85013538,
				9926730, 27724594, 95148523, 20503000, 64390907, 26006953, 98116293, 97457666, 29017396, 4634371,
				70791589 };
		int s = 0, count = 0;
		for (int i = 0; i < arr1.length; i++) {
			for (int j = 0; j < arr2.length; j++) {
				if (arr1[i] == arr2[j]) {
					list.add(arr1[i]);
					s++;
				}
			}
		}
		for (int i = 0; i < arr3.length; i++) {
			for (int j = 0; j < list.size(); j++) {
				if (arr3[i] == list.get(j)) {
					count++;
				}
			}
		}
		System.out.println(s - count);
	}
}

纸牌三角形

A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。

下图就是一种排法（如有对齐问题，参看p1.png）。

9 6

4 8

3 7 5 2

这样的排法可能会有很多。

如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？

请你计算并提交该数字。

注意：需要提交的是一个整数，不要提交任何多余内容。

---------------------------

笨笨有话说：

感觉可以暴力破解哦。

麻烦的是，对每个排法还要算出它的旋转、镜像排法，看看有没有和历史重复。

歪歪有话说：

人家又不让你把所有情况都打印出来，只是要算种类数。

对于每个基本局面，通过旋转、镜像能造出来的新局面数目不是固定的吗？

/**
 * @createDate：2019年3月18日 上午8:42:24
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：纸牌三角形.java @describe：
 */
public class 纸牌三角形 {

	static int cnt = 0;
	static int a[] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		fun(0);
		System.out.println(cnt / 3 / 2);
	}

	public static void fun(int k) {
		if (k == 9) {
			if (a[0] + a[1] + a[2] + a[3] == a[3] + a[4] + a[5] + a[6]
					&& a[3] + a[4] + a[5] + a[6] == a[6] + a[7] + a[8] + a[0])
				cnt++;
		} else {
			for (int i = k; i < 9; i++) {
				GetEx(i, k);
				fun(k + 1);
				GetEx(i, k);
			}
		}
	}

	public static void GetEx(int x, int y) {
		int temp = a[x];
		a[x] = a[y];
		a[y] = temp;
	}
}

承压计算

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。

金属材料被严格地堆放成金字塔形。

5 8

7 8 8

9 2 7 2

8 1 4 9 1

8 1 8 8 4 1

7 9 6 1 4 5 4

5 6 5 5 6 9 5 6

5 5 4 7 9 3 5 5 1

7 5 7 9 7 4 7 3 3 1

4 6 4 5 5 8 8 3 2 4 3

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

9 9 9 2 1 9 1 9 2 9 5 7 9

4 3 3 7 7 9 3 6 1 3 8 8 3 7

3 6 8 1 5 3 9 5 8 3 8 1 8 3 3

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

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

2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9

7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6

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

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

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

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

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

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

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

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

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

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

X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X

其中的数字代表金属块的重量（计量单位较大）。

最下一层的X代表30台极高精度的电子秤。

假设每块原料的重量都十分精确地平均落在下方的两个金属块上，

最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。

电子秤的计量单位很小，所以显示的数字很大。

工作人员发现，其中读数最小的电子秤的示数为：2086458231

请你推算出：读数最大的电子秤的示数为多少？

注意：需要提交的是一个整数，不要填写任何多余的内容。

--------------------------------------------

笨笨有话说：

不断的除2，加到下面，除2,加到下面,.... 不会浮点精度溢出吧？

歪歪有话说：

怕除不开还不好办，把每个数字扩大一定的倍数不就好了。

/**
 ** @createDate：2019年3月18日,上午9:04:08
 ** @porjectName：lanqiao
 ** @author Static
 ** @version 1.0
 ** @since JDK 1.8.0_21
 ** @filename：承压计算.java @describe：
 */
public class 承压计算 {

	public static void main(String[] args) {
		// TODO Auto-generated,method,stub
		double a[][] = { 
				{ 7 }, 
				{ 5, 8 },
				{ 7, 8, 8 }, 
				{ 9, 2, 7, 2 }, 
				{ 8, 1, 4, 9, 1 }, 
				{ 8, 1, 8, 8, 4, 1 },
				{ 7, 9, 6, 1, 4, 5, 4 }, 
				{ 5, 6, 5, 5, 6, 9, 5, 6 },
				{ 5, 5, 4, 7, 9, 3, 5, 5, 1 },
				{ 7, 5, 7, 9, 7, 4, 7, 3, 3, 1 }, 
				{ 4, 6, 4, 5, 5, 8, 8, 3, 2, 4, 3 },
				{ 1, 1, 3, 3, 1, 6, 6, 5, 5, 4, 4, 2 },
				{ 9, 9, 9, 2, 1, 9, 1, 9, 2, 9, 5, 7, 9 },
				{ 4, 3, 3, 7, 7, 9, 3, 6, 1, 3, 8, 8, 3, 7 }, 
				{ 3, 6, 8, 1, 5, 3, 9, 5, 8, 3, 8, 1, 8, 3, 3 },
				{ 8, 3, 2, 3, 3, 5, 5, 8, 5, 4, 2, 8, 6, 7, 6, 9 },
				{ 8, 1, 8, 1, 8, 4, 6, 2, 2, 1, 7, 9, 4, 2, 3, 3, 4 },
				{ 2, 8, 4, 2, 2, 9, 9, 2, 8, 3, 4, 9, 6, 3, 9, 4, 6, 9 },
				{ 7, 9, 7, 4, 9, 7, 6, 6, 2, 8, 9, 4, 1, 8, 1, 7, 2, 1, 6 },
				{ 9, 2, 8, 6, 4, 2, 7, 9, 5, 4, 1, 2, 5, 1, 7, 3, 9, 8, 3, 3 },
				{ 5, 2, 1, 6, 7, 9, 3, 2, 8, 9, 5, 5, 6, 6, 6, 2, 1, 8, 7, 9, 9 },
				{ 6, 7, 1, 8, 8, 7, 5, 3, 6, 5, 4, 7, 3, 4, 6, 7, 8, 1, 3, 2, 7, 4 },
				{ 2, 2, 6, 3, 5, 3, 4, 9, 2, 4, 5, 7, 6, 6, 3, 2, 7, 2, 4, 8, 5, 5, 4 },
				{ 7, 4, 4, 5, 8, 3, 3, 8, 1, 8, 6, 3, 2, 1, 6, 2, 6, 4, 6, 3, 8, 2, 9, 6 },
				{ 1, 2, 4, 1, 3, 3, 5, 3, 4, 9, 6, 3, 8, 6, 5, 9, 1, 5, 3, 2, 6, 8, 8, 5, 3 },
				{ 2, 2, 7, 9, 3, 3, 2, 8, 6, 9, 8, 4, 4, 9, 5, 8, 2, 6, 3, 4, 8, 4, 9, 3, 8, 8 },
				{ 7, 7, 7, 9, 7, 5, 2, 7, 9, 2, 5, 1, 9, 2, 6, 5, 3, 9, 3, 5, 7, 3, 5, 4, 2, 8, 9 },
				{ 7, 7, 6, 6, 8, 7, 5, 5, 8, 2, 4, 7, 7, 4, 7, 2, 6, 9, 2, 1, 8, 2, 9, 8, 5, 7, 3, 6 },
				{ 5, 9, 4, 5, 5, 7, 5, 5, 6, 3, 5, 3, 9, 5, 8, 9, 5, 4, 1, 2, 6, 1, 4, 3, 5, 3, 2, 4, 1 } };

		double b[][] = new double[30][30];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				b[i][j] = a[i][j];
			}
		}

		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				b[i + 1][j] += b[i][j] * 1.0 / 2;
				b[i + 1][j + 1] += b[i][j] * 1.0 / 2;
			}
		}

		double min = b[29][0], max = b[29][0];
		for (int i = 0; i <= 29; i++) {
			if (b[29][i] > max)
				max = b[29][i];
			if (b[29][i] < min)
				min = b[29][i];
		}
		System.out.printf("%f", (2086458231 / min) * max);
	}
}

杨辉三角

杨辉三角也叫帕斯卡三角，在很多数量关系中可以看到，十分重要。

第0行： 1

第1行： 1 1

第2行： 1 2 1

第3行： 1 3 3 1

第4行： 1 4 6 4 1

....

两边的元素都是1，中间的元素是左上角的元素与右上角的元素和。

我们约定，行号，列号都从0计数。

所以：第6行的第2个元素是15，第3个元素是20

直观地看，需要开辟一个二维数组，其实一维数组也可以胜任。

如下程序就是用一维数组“腾挪”的解法。

public class A

{

// 杨辉三角形的第row行第col列

static long f(int row, int col){

if(row<2) return 1;

if(col==0) return 1;

if(col==row) return 1;

long[] a = new long[row+1];

a[0]=1;

a[1]=1;

int p = 2;

while(p<=row){

a[p] = 1;

for( __________________ ) a[q] = a[q] + a[q-1];

p++;

}

return a[col];

}

public static void main(String[] args){

System.out.println(f(6,2));

System.out.println(f(6,3));

}

请仔细分析源码，并完成划线部分缺少的代码。

注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。

/**
 * @createDate：2019年3月18日 上午10:57:25
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：二维杨辉三角转一维.java @describe：
 */
public class 二维杨辉三角转一维 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(f(6, 2));
		System.out.println(f(6, 3));
	}

	// 杨辉三角形的第row行第col列
	static long f(int row, int col) {
		if (row < 2)
			return 1;
		if (col == 0)
			return 1;
		if (col == row)
			return 1;

		long[] a = new long[row + 1];
		a[0] = 1;
		a[1] = 1;

		int p = 2;

		while (p <= row) {
			a[p] = 1;
			for (int q = p - 1; q > 0; q--)
				a[q] = a[q] + a[q - 1];
			p++;
		}
		return a[col];
	}
}

最大公共子串

最大公共子串就是求两个串的所有子串中能够匹配上的最大长度是多少。

比如："abcdkkk" 和 "baabcdadabc"，

可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。

下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。

请分析该解法的思路，并补全划线部分缺失的代码。

public class A

{

static int f(String s1, String s2)

{

char[] c1 = s1.toCharArray();

char[] c2 = s2.toCharArray();

int[][] a = new int[c1.length+1][c2.length+1];

int max = 0;

for(int i=1; i

for(int j=1; j

if(c1[i-1]==c2[j-1]) {

a[i][j] = _______________________ ; //填空

if(a[i][j] > max) max = a[i][j];

}

return max;

}

public static void main(String[] args){

int n = f("abcdkkk", "baabcdadabc");

System.out.println(n);

}

注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。

/**
 * @createDate：2019年3月18日 下午9:06:20
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：最大公共子串.java @describe：
 */
public class 最大公共子串 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n = f("abcdkkk", "baabcdadabc");
		System.out.println(n);
	}

	static int f(String s1, String s2) {
		char[] c1 = s1.toCharArray();
		char[] c2 = s2.toCharArray();

		int[][] a = new int[c1.length + 1][c2.length + 1];

		int max = 0;
		for (int i = 1; i < a.length; i++) {
			for (int j = 1; j < a[i].length; j++) {
				if (c1[i - 1] == c2[j - 1]) {
					a[i][j] = a[i - 1][j - 1] + 1; // 填空
					if (a[i][j] > max)
						max = a[i][j];
				}
			}
		}

		return max;
	}
}

Excel地址

Excel单元格的地址表示很有趣，它使用字母来表示列号。

比如，

A表示第1列，

B表示第2列，

Z表示第26列，

AA表示第27列，

AB表示第28列，

BA表示第53列，

....

当然Excel的最大列号是有限度的，所以转换起来不难。

如果我们想把这种表示法一般化，可以把很大的数字转换为很长的字母序列呢？

本题目既是要求对输入的数字, 输出其对应的Excel地址表示方式。

例如，

输入：

则程序应该输出：

再例如，

输入：

2054

则程序应该输出：

BZZ

我们约定，输入的整数范围[1,2147483647]

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

不要使用package语句。不要使用jdk1.7及以上版本的特性。

主类的名字必须是：Main，否则按无效代码处理。

------------------------------

笨笨有话说：

这有点像进制关系，又不完全是。好像末2位是以1当26，末3位是以1当26*26

歪歪有话说：

要是从字母序列转数字还好点，倒过来有点麻烦，不过计算机跑得快啊。

import java.util.Scanner;
import java.util.Stack;

/**
 * @createDate：2019年3月18日 下午10:16:49
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：Excel地址.java @describe：
 */
public class Excel地址 {

	static Stack sta = new Stack();

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		fun(n);
	}

	public static void fun(int n) {
		while (n != 0) {
			sta.push(n % 26 == 0 ? 'Z' : (char) (n % 26 - 1 + 'A'));
			n--;
			n /= 26;
		}
		String str = "";
		while (!sta.empty()) {
			str += sta.pop();
		}
		System.out.println(str);
	}
}

拉马车

小的时候，你玩过纸牌游戏吗？

有一种叫做“拉马车”的游戏，规则很简单，却很吸引小朋友。

其规则简述如下：

假设参加游戏的小朋友是A和B，游戏开始的时候，他们得到的随机的纸牌序列如下：

A方：[K, 8, X, K, A, 2, A, 9, 5, A]

B方：[2, 7, K, 5, J, 5, Q, 6, K, 4]

其中的X表示“10”，我们忽略了纸牌的花色。

从A方开始，A、B双方轮流出牌。

当轮到某一方出牌时，他从自己的纸牌队列的头部拿走一张，放到桌上，并且压在最上面一张纸牌上（如果有的话）。

此例中，游戏过程：

A出K，B出2，A出8，B出7，A出X，此时桌上的序列为：

K,2,8,7,X

当轮到B出牌时，他的牌K与桌上的纸牌序列中的K相同，则把包括K在内的以及两个K之间的纸牌都赢回来，放入自己牌的队尾。注意：为了操作方便，放入牌的顺序是与桌上的顺序相反的。

此时，A、B双方的手里牌为：

A方：[K, A, 2, A, 9, 5, A]

B方：[5, J, 5, Q, 6, K, 4, K, X, 7, 8, 2, K]

赢牌的一方继续出牌。也就是B接着出5，A出K，B出J，A出A，B出5，又赢牌了。

5,K,J,A,5

此时双方手里牌：

A方：[2, A, 9, 5, A]

B方：[Q, 6, K, 4, K, X, 7, 8, 2, K, 5, A, J, K, 5]

注意：更多的时候赢牌的一方并不能把桌上的牌都赢走，而是拿走相同牌点及其中间的部分。但无论如何，都是赢牌的一方继续出牌，有的时候刚一出牌又赢了，也是允许的。

当某一方出掉手里最后一张牌，但无法从桌面上赢取牌时，游戏立即结束。

对于本例的初始手牌情况下，最后A会输掉，而B最后的手里牌为：

9K2A62KAX58K57KJ5

本题的任务就是已知双方初始牌序，计算游戏结束时，赢的一方手里的牌序。当游戏无法结束时，输出-1。

输入为2行，2个串，分别表示A、B双方初始手里的牌序列。

输出为1行，1个串，表示A先出牌，最后赢的一方手里的牌序。

例如，

输入：

96J5A898QA

6278A7Q973

则程序应该输出：

2J9A7QA6Q6889977

再比如，

输入：

25663K6X7448

J88A5KJXX45A

则程序应该输出：

6KAJ458KXAX885XJ645

我们约定，输入的串的长度不超过30

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

不要使用package语句。不要使用jdk1.7及以上版本的特性。

主类的名字必须是：Main，否则按无效代码处理。

----------------------------

笨笨有话说：

不断删除前边的，又要后边添加.... 如果用数组，需要开一个大点的，请佛祖保佑在游戏结束前，不会用到数组的边缘。

歪歪有话说：

反正串也不长，不如每次操作都返回一个新的串。

默默有话说：

我一般都不吱声，这是典型的队列结构，动态数组最好，没有？自己造一个呗！

import java.util.Scanner;
import java.util.Stack;

/**
 * @createDate：2019年3月19日 上午8:31:01
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：拉马车.java @describe：
 */
public class Main {

	static Stack sta = new Stack();
	static String str1;
	static String str2;

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		str1 = sc.next();
		str2 = sc.next();
		int bol = fun();
		if (bol == -1) {
			System.out.println("-1");
		} else if (str1.length() > str2.length()) {
			System.out.println(str1);
		} else {
			System.out.println(str2);
		}
	}

	public static int fun() {
		boolean flag = true;
		int index = 0;
		int bol = 0;
		while (true) {
			if (flag) {
				sta.push(str1.charAt(0));
				index = GetEx();
				if (str1.length() == 1 && index == -1) {
					break;
				} else {
					str1 = str1.substring(1);
					if (index != -1) {
						str1 += PopStack(sta.size() - index);
						flag = true;
					} else {
						flag = false;
					}
				}
			}
			if (!flag) {
				sta.push(str2.charAt(0));
				index = GetEx();
				if (str2.length() == 1 && index == -1) {
					break;
				} else {
					str2 = str2.substring(1);
					if (index != -1) {
						str2 += PopStack(sta.size() - index);
						flag = false;
					} else {
						flag = true;
					}
				}
			}
			if (str1 == str2) {
				bol = -1;
				break;
			}
		}
		return bol;
	}

	public static int GetEx() {
		int x = -1;
		if (sta.size() >= 2) {
			for (int i = 0; i < sta.size() - 1; i++) {
				if (sta.get(i) == sta.get(sta.size() - 1)) {
					x = i;
					break;
				}
			}
		}
		return x;
	}

	public static String PopStack(int n) {
		String ss = "";
		for (int i = 0; i < n; i++) {
			ss += sta.pop();
		}
		return ss;
	}
}

青蛙跳杯子

X星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。

X星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。

如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。

*WWWBBB

其中，W字母表示白色青蛙，B表示黑色青蛙，*表示空杯子。

X星的青蛙很有些癖好，它们只做3个动作之一：

1. 跳到相邻的空杯子里。

2. 隔着1只其它的青蛙（随便什么颜色）跳到空杯子里。

3. 隔着2只其它的青蛙（随便什么颜色）跳到空杯子里。

对于上图的局面，只要1步，就可跳成下图局面：

WWW*BBB

本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。

输入为2行，2个串，表示初始局面和目标局面。

输出要求为一个整数，表示至少需要多少步的青蛙跳。

例如：

输入：

*WWBB

WWBB*

则程序应该输出：

再例如，

输入：

WWW*BBB

BBB*WWW

则程序应该输出：

我们约定，输入的串的长度不超过15

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

不要使用package语句。不要使用jdk1.7及以上版本的特性。

主类的名字必须是：Main，否则按无效代码处理。

----------------------------

笨笨有话说：我梦见自己是一棵大树，青蛙跳跃，我就发出新的枝条，春风拂动那第 5 层的新枝, 哦，我已是枝繁叶茂。

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;

/**
 * @createDate：2019年3月20日 上午8:10:08
 * @porjectName：lanqiao
 * @author Static
 * @version 1.0
 * @since JDK 1.8.0_21
 * @filename：青蛙跳杯.java @describe：
 */
public class 青蛙跳杯 {

	static Map mp = new HashMap();
	static String s1;
	static String s2;
	static String tempStr;

	static class Node {
		String s;
		int tep;

		public Node(String s, int tep) {
			this.s = s;
			this.tep = tep;
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		s1 = sc.next();
		s2 = sc.next();
		fbs();
	}

	public static void fbs() {
		Queue qu = new LinkedList();
		Node node = new Node(s1, 0);
		Node now, next;
		qu.add(node);
		mp.put(node.s, 1);
		while (!qu.isEmpty()) {
			now = qu.poll();
			if (now.s.equals(s2)) {
				System.out.println(now.tep);
				break;
			}
			char arr[] = now.s.toCharArray();
			for (int i = 0; i < arr.length; i++) {
				if (arr[i] != '*')
					for (int j = -3; j <= 3; j++) {
						if (i + j >= 0 && i + j < arr.length && j != 0 && arr[i + j] == '*') {
							tempStr = GetEx(arr, i, i + j);
							next = new Node(tempStr, now.tep + 1);
							if (!mp.containsKey(next.s)) {
								qu.add(next);
								mp.put(next.s, 1);
							}
							GetEx(arr, i, i + j);
						}
					}
			}
		}
	}

	public static String GetEx(char a[], int i, int j) {
		char temp = a[i];
		a[i] = a[j];
		a[j] = temp;
		return String.valueOf(a);
	}
}

总结：有点像全排列的回溯法，广度优先，先把各节点同一层情况入队往后追加

图形排版

小明需要在一篇文档中加入 N 张图片，其中第 i 张图片的宽度是 Wi，高度是 Hi。

假设纸张的宽度是 M，小明使用的文档编辑工具会用以下方式对图片进行自动排版：

1. 该工具会按照图片顺序，在宽度 M 以内，将尽可能多的图片排在一行。该行的高度是行内最高的图片的高度。例如在 M=10 的纸张上依次打印 3x4, 2x2, 3x3 三张图片，则效果如下图所示，这一行高度为4。(分割线以上为列标尺，分割线以下为排版区域；数字组成的矩形为第x张图片占用的版面)

0123456789

----------

111

111 333

11122333

2. 如果当前行剩余宽度大于0，并且小于下一张图片，则下一张图片会按比例缩放到宽度为当前行剩余宽度(高度向上取整)，然后放入当前行。例如再放入一张4x9的图片，由于剩余宽度是2，这张图片会被压缩到2x5，再被放入第一行的末尾。此时该行高度为5：

0123456789

----------

111 44

111 33344

1112233344

3. 如果当前行剩余宽度为0，该工具会从下一行开始继续对剩余的图片进行排版，直到所有图片都处理完毕。此时所有行的总高度和就是这 N 张图片的排版高度。例如再放入11x1, 5x5, 3x4 的图片后，效果如下图所示，总高度为11：

0123456789

----------

111 44

111 333 44

1112233344

5555555555

66666

66666777

现在由于排版高度过高，图片的先后顺序也不能改变，小明只好从 N 张图片中选择一张删除掉以降低总高度。他希望剩余N-1张图片按原顺序的排版高度最低，你能求出最低高度是多少么？

输入：

第一行包含两个整数 M 和 N，分别表示纸张宽度和图片的数量。

接下来 N 行，每行2个整数Wi, Hi，表示第 i 个图大小为 Wi*Hi。

对于30%的数据，满足1<=N<=1000

对于100%的数据，满足1<=N<=100000，1<=M, Wi, Hi<=100

输出：

一个整数，表示在删除掉某一张图片之后，排版高度最少能是多少。

样例输入：

4 3

2 2

2 3

2 2

样例输出：

另一个示例，

样例输入：

2 10

4 4

4 3

1 3

4 5

2 1

2 3

5 4

5 3

1 5

2 4

样例输出：

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 2000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

不要使用package语句。不要使用jdk1.7及以上版本的特性。

主类的名字必须是：Main，否则按无效代码处理。

//代码

//结果

你可能感兴趣的:(算法,数据结构,蓝桥杯)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习 K近邻
importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
4.C_数据结构_队列荣世蓥数据结构数据结构
概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
Python算法L5：贪心算法小熊同学哦 Python算法算法 python 贪心算法
Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【RabbitMQ 项目】服务端：数据管理模块之绑定管理月夜星辉雪 rabbitmq 分布式
文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
【树一线性代数】005入门 Owlet_woodBird 算法
Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
非对称加密算法原理与应用2——RSA私钥加密文件私语茶馆云部署与开发架构及产品灵感记录 RSA2048 私钥加密
作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构 leetcode 算法
给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能 matlab 算法
在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
非对称加密算法————RSA理论及详情 hu19930613
转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
java封装继承多态等麦田的设计者 java eclipse jvm c encapsulatopn
最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。 1、final关键字译为：最终的 &
F5与集群的区别 bijian1013 weblogic 集群 F5
http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。 F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
LeetCode[Math] - #7 Reverse Integer Cwind java 题解 Math LeetCode Algorithm
原题链接：#7 Reverse Integer 要求：按位反转输入的数字例1：输入 x = 123, 返回 321 例2：输入 x = -123, 返回 -321 难度：简单分析：对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
BufferedOutputStream 周凡杨
首先说一下这个大批量，是指有上千万的数据量。例子：有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！ select t.msisd
linux下模拟按键输入和鼠标被触发 linux
查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices 设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。 linux/in
ContentProvider初体验肆无忌惮_ ContentProvider
ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
关于Spring MVC项目（maven）中通过fileupload上传文件 843977358 mybatis spring mvc 修改头像上传文件 upload
Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。 1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar 因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定） <!-- 文件上传 start by zhangyd-c --&g
使用svnkit api，纯java操作svn，实现svn提交，更新等操作 aigo svnkit
原文：http://blog.csdn.net/hardwin/article/details/7963318 import java.io.File; import org.apache.log4j.Logger; import org.tmatesoft.svn.core.SVNCommitInfo; import org.tmateso
对比浏览器，casperjs，httpclient的Header信息 alleni123 爬虫 crawler header
@Override protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { String type=req.getParameter("type"); Enumeration es=re
java.io操作 DataInputStream和DataOutputStream基本数据流百合不是茶 java 流
1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象先将类实例化后面的文章将详细写到 2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
车辆保险理赔案例 bijian1013 车险
理赔案例：一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。赔付建议和方案：客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”；如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
学习Spring必学的Java基础知识(5)—注解 bijian1013 java spring
文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。有必要对
【Struts2一】Struts2 Hello World bit1129 Hello world
Struts2 Hello World应用的基本步骤创建Struts2的Hello World应用，包括如下几步： 1.配置web.xml 2.创建Action 3.创建struts.xml，配置Action 4.启动web server，通过浏览器访问配置web.xml <?xml version="1.0" encoding="
【Avro二】Avro RPC框架 bit1129 rpc
1. Avro RPC简介 1.1. RPC RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
lua　set get cookie ronin47 lua cookie
lua: local access_token = ngx.var.cookie_SGAccessToken if access_token then ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000" end
java-打印不大于N的质数 bylijinnan java
public class PrimeNumber { /** * 寻找不大于N的质数 */ public static void main(String[] args) { int n=100; PrimeNumber pn=new PrimeNumber(); pn.printPrimeNumber(n); System.out.print
Spring源码学习-PropertyPlaceholderHelper bylijinnan java spring
今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug 当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复：详见： http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug
[逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么? comsci 拓扑
如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢? 是否可以形成一种新的模糊语言识别和处理模型呢? 大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
ITEYE 都换百度推广了 cuisuqiang Google AdSense 百度推广广告外快
以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。为什么个人博客设置里面还是Google AdSense呢？都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。什么时候能从ITEYE上来点外快，哪怕少点
新浪微博技术架构分析 dalan_123 新浪微博架构
新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
玩转ARP攻击 dcj3sjt126com r
我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。网上关于ARP的资料已经很多了，就不用我都说了。用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。以下讨论的机子有一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
PHP编码规范 dcj3sjt126com 编码规范
一、文件格式 1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
linux 脱机管理（nohup） eksliang linux nohup nohup
脱机管理 nohup 转载请出自出处：http://eksliang.iteye.com/blog/2166699 nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下 nohup [命令与参数] --在终端机前台工作 nohup [命令与参数] & --在终端机后台工作但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
BusinessObjects Enterprise Java SDK greemranqq java BO SAP Crystal Reports
最近项目用到oracle_ADF 从SAP/BO 上调用水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手提供更多的便利。首先，我是尝试用JAVA JSP 去访问的。官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
系统负载剧变下的管控策略 iamzhongyong 高并发
假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。 1、水平扩展这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。 2、系统分组假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
BitTorrent DHT 协议中文翻译 justjavac bit
前言做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。 BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
Ubuntu下Java环境的搭建 macroli java 工作 ubuntu
配置命令：　　$sudo apt-get install ubuntu-restricted-extras 　　再运行如下命令：　　$sudo apt-get install sun-java6-jdk 　　待安装完毕后选择默认Java. 　　$sudo update- alternatives --config java 　　安装过程提示选择，输入“2”即可，然后按回车键确定。
js字符串转日期（兼容IE所有版本） qiaolevip TO Date String IE
/** * 字符串转时间（yyyy-MM-dd HH:mm:ss） * result （分钟） */ stringToDate : function(fDate){ var fullDate = fDate.split(" ")[0].split("-"); var fullTime = fDate.split("
【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析 superlxw1234 sql 数据挖掘关联规则
关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%] 支持度3%：意味3%顾客同时购买牛奶和面包。置信度40%：意味购买牛奶的顾客40%也购买面包。规则的支持度和置信度是两个规则兴
Spring 5.0 的系统需求，期待你的反馈 wiselyman spring
Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。 Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。