1. /// <summary>
  2. /// 排列组件算法类
  3. /// </summary>
  4. /// <typeparam name="T"></typeparam>
  5. public class PermutationAndCombination<T>
  6. {
  7. /// <summary>
  8. /// 交换两个变量
  9. /// </summary>
  10. /// <param name="a">变量1</param>
  11. /// <param name="b">变量2</param>
  12. public static void Swap(ref T a, ref T b)
  13. {
  14. T temp = a;
  15. a = b;
  16. b = temp;
  17. }
  18. /// <summary>
  19. /// 递归算法求数组的组合(私有成员)
  20. /// </summary>
  21. /// <param name="list">返回的范型</param>
  22. /// <param name="t">所求数组</param>
  23. /// <param name="n">辅助变量</param>
  24. /// <param name="m">辅助变量</param>
  25. /// <param name="b">辅助数组</param>
  26. /// <param name="M">辅助变量M</param>
  27. private static void GetCombination(ref List<T[]> list, T[] t, int n, int m, int[] b, int M)
  28. {
  29. for (int i = n; i >= m; i--)
  30. {
  31. b[m - ] = i - ;
  32. if (m > )
  33. {
  34. GetCombination(ref list, t, i - , m - , b, M);
  35. }
  36. else
  37. {
  38. if (list == null)
  39. {
  40. list = new List<T[]>();
  41. }
  42. T[] temp = new T[M];
  43. for (int j = ; j < b.Length; j++)
  44. {
  45. temp[j] = t[b[j]];
  46. }
  47. list.Add(temp);
  48. }
  49. }
  50. }
  51. /// <summary>
  52. /// 递归算法求排列(私有成员)
  53. /// </summary>
  54. /// <param name="list">返回的列表</param>
  55. /// <param name="t">所求数组</param>
  56. /// <param name="startIndex">起始标号</param>
  57. /// <param name="endIndex">结束标号</param>
  58. private static void GetPermutation(ref List<T[]> list, T[] t, int startIndex, int endIndex)
  59. {
  60. if (startIndex == endIndex)
  61. {
  62. if (list == null)
  63. {
  64. list = new List<T[]>();
  65. }
  66. T[] temp = new T[t.Length];
  67. t.CopyTo(temp, );
  68. list.Add(temp);
  69. }
  70. else
  71. {
  72. for (int i = startIndex; i <= endIndex; i++)
  73. {
  74. Swap(ref t[startIndex], ref t[i]);
  75. GetPermutation(ref list, t, startIndex + , endIndex);
  76. Swap(ref t[startIndex], ref t[i]);
  77. }
  78. }
  79. }
  80. /// <summary>
  81. /// 求从起始标号到结束标号的排列,其余元素不变
  82. /// </summary>
  83. /// <param name="t">所求数组</param>
  84. /// <param name="startIndex">起始标号</param>
  85. /// <param name="endIndex">结束标号</param>
  86. /// <returns>从起始标号到结束标号排列的范型</returns>
  87. public static List<T[]> GetPermutation(T[] t, int startIndex, int endIndex)
  88. {
  89. if (startIndex < || endIndex > t.Length - )
  90. {
  91. return null;
  92. }
  93. List<T[]> list = new List<T[]>();
  94. GetPermutation(ref list, t, startIndex, endIndex);
  95. return list;
  96. }
  97. /// <summary>
  98. /// 返回数组所有元素的全排列
  99. /// </summary>
  100. /// <param name="t">所求数组</param>
  101. /// <returns>全排列的范型</returns>
  102. public static List<T[]> GetPermutation(T[] t)
  103. {
  104. return GetPermutation(t, , t.Length - );
  105. }
  106. /// <summary>
  107. /// 求数组中n个元素的排列
  108. /// </summary>
  109. /// <param name="t">所求数组</param>
  110. /// <param name="n">元素个数</param>
  111. /// <returns>数组中n个元素的排列</returns>
  112. public static List<T[]> GetPermutation(T[] t, int n)
  113. {
  114. if (n > t.Length)
  115. {
  116. return null;
  117. }
  118. List<T[]> list = new List<T[]>();
  119. List<T[]> c = GetCombination(t, n);
  120. for (int i = ; i < c.Count; i++)
  121. {
  122. List<T[]> l = new List<T[]>();
  123. GetPermutation(ref l, c[i], , n - );
  124. list.AddRange(l);
  125. }
  126. return list;
  127. }
  128. /// <summary>
  129. /// 求数组中n个元素的组合
  130. /// </summary>
  131. /// <param name="t">所求数组</param>
  132. /// <param name="n">元素个数</param>
  133. /// <returns>数组中n个元素的组合的范型</returns>
  134. public static List<T[]> GetCombination(T[] t, int n)
  135. {
  136. if (t.Length < n)
  137. {
  138. return null;
  139. }
  140. int[] temp = new int[n];
  141. List<T[]> list = new List<T[]>();
  142. GetCombination(ref list, t, t.Length, n, temp, n);
  143. return list;
  144. }
  145. }

枚举出键盘所有组合键代码:

  1. var combinePrefixKeyList = new Keys[] { Keys.Control, Keys.Alt, Keys.Shift };
  2. var result = new List<List<Keys>>();
  3. for(var i = ;i <= combinePrefixKeyList.Count() ;i++)
  4. {
  5. var combinationList = PermutationAndCombination<Keys>.GetCombination(combinePrefixKeyList, i);
  6. var items = combinationList.Select(item => item.ToList()).ToList();
  7. result.AddRange(items);
  8. }
  9.  
  10. var keyNames = Enum.GetNames(typeof(Keys)).ToList();
  11. foreach (var keyName in keyNames)
  12. KeyList.Add(keyName, (Keys)Enum.Parse(typeof(Keys), keyName));
  13.  
  14. var combineKeyList = (from item in result
  15. join key in KeyList.Select(k => k.Value).Except(new List<Keys> { Keys.None })
  16. on true equals true
  17. select item.Concat<Keys>(new List<Keys> { key })
  18. ).ToList();
  19.  
  20. Func<List<int>, int> GetCombinedKeyCode = null;
  21. GetCombinedKeyCode = delegate(List<int> args)
  22. {
  23. if (args.Count == )
  24. return ;
  25.  
  26. if (args.Count == )
  27. return args[];
  28.  
  29. return args[] | GetCombinedKeyCode(args.Skip().ToList());
  30. };
  31.  
  32. Func<int, int> GetVirtualKeyCode = delegate(int args)
  33. {
  34. return (byte)(args & 0xFF);
  35. };
  36.  
  37. foreach (var item in combineKeyList)
  38. {
  39. var names = item.Select(key => Enum.GetName(typeof(Keys), key));
  40. var keyCombination = string.Join("+", names);
  41. Debug.Print(keyCombination + ":\t" + GetVirtualKeyCode(GetCombinedKeyCode(item.Cast<int>().ToList())).ToString());
  42. }

c# 排列组合代码类的更多相关文章

  1. php实现排列组合

    php实现排列组合 一.总结 1.回溯:回溯的函数参数有些生疏了,记录递归的位置(pos或step),还要有东西(vis数组)来记录这个是否已经被访问 2.php全局变量的使用 :外部定义的普通变量, ...

  2. C#的排列组合类

    C#的排列组合类 //-----------------------------------------------------------------------------//// 算法:排列组合 ...

  3. C#排列组合类

    //----------------------------------------------------------------------------- // // 算法:排列组合类 // // ...

  4. 【原创】开源.NET排列组合组件KwCombinatorics使用(三)——笛卡尔积组合

           本博客所有文章分类的总目录:本博客博文总目录-实时更新 本博客其他.NET开源项目文章目录:[目录]本博客其他.NET开源项目文章目录 KwCombinatorics组件文章目录: 1. ...

  5. 【原创】开源.NET排列组合组件KwCombinatorics使用(二)——排列生成

           本博客所有文章分类的总目录:本博客博文总目录-实时更新 本博客其他.NET开源项目文章目录:[目录]本博客其他.NET开源项目文章目录 KwCombinatorics组件文章目录: 1. ...

  6. 【原创】开源.NET排列组合组件KwCombinatorics使用(一)—组合生成

           本博客所有文章分类的总目录:本博客博文总目录-实时更新 本博客其他.NET开源项目文章目录:[目录]本博客其他.NET开源项目文章目录 KwCombinatorics组件文章目录: 1. ...

  7. HDU 4045 Machine scheduling (组合数学-斯特林数,组合数学-排列组合)

    Machine scheduling Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Other ...

  8. [总结]数论和组合计数类数学相关(定理&证明&板子)

    0 写在前面 0.0 前言 由于我太菜了,导致一些东西一学就忘,特开此文来记录下最让我头痛的数学相关问题. 一些引用的文字都注释了原文链接,若侵犯了您的权益,敬请告知:若文章中出现错误,也烦请告知. ...

  9. 数组排列组合问题——BACKTRACKING

    BACKTRACKING backtracking(回溯法)是一类递归算法,通常用于解决某类问题:要求找出答案空间中符合某种特定要求的答案,比如eight queens puzzle(将国际象棋的八个 ...

随机推荐

  1. Qualcomm_Mobile_OpenCL.pdf 翻译-9-OpenCL优化用例的学习

    在这一章中,将会用一些例子来展示如何使用之前章节中讨论的技术来进行优化.除了一些小的简单代码片段的展示外,还有两个熟知的图像滤波处理,Epsilon滤波和Sobel滤波,将会使用之前章节中讨论的方法进 ...

  2. RMQ 2d 模板

    #include<iostream> #include<cstdio> #include<string.h> #include<string> #inc ...

  3. 如何创建DLL,以及注入DLL

    为了防止忘记,特记下 DLL的创建,在VS2017中选择dll的创建 // dllmain.cpp : Defines the entry point for the DLL application. ...

  4. 第四篇:存储库之mongodb、redis、mysql

    MongoDB的简单操作 一.简介 二.MongoDB基础知识 三.安装 四.基本数据类型 五.增删改查操作 六.可视化工具 七.pymongo 一.简介 MongoDB是一款强大.灵活.且易于扩展的 ...

  5. form表单和CSS

    一.form表单 1. form表单有什么用 能够获取用户输入的信息(输入,选择, 上传的文件),并且将这些数据全部发送给后端 2. form表单的用法 (1)有两个重要参数: action : 控制 ...

  6. set uniion()

    union()方法返回两个集合的并集,包含所有集合的元素,重复元素只会出现一次. 语法: set.union(set1,set2) 参数: set1必填参数,合并的目标集合 set2选填参数,其他要合 ...

  7. POJ-3020-Antena Placement(最小路径覆盖)

    链接: https://vjudge.net/problem/POJ-3020 题意: The Global Aerial Research Centre has been allotted the ...

  8. 设计模式Design Pattern(4) -- 访问者模式

    什么是访问者模式? 一个对象有稳定的数据结构,却为不同的访问者提供不同的数据操作,对象提供接收访问者的方法,从而保证数据结构的稳定性和操作的多样性.也可以理解为,封装对象的操作方法,达到不改变对象数据 ...

  9. 解决SonarQube启动时直接挂掉问题

    症状:启动SonarQube时,系统启动,但是马上关闭 查看日志,提示ElasticSearch启动有问题ClusterBlockException[blocked by: [FORBIDDEN/12 ...

  10. jvm——内存模型

    这是我理解的jvm内存模型,这一整块可以简单理解为虚拟内存空间: jvm代码.jvm数据:是运行jvm所用到的代码和数据,并不是我们自己编程得到的代码和数据 direct memory:主要是NIO在 ...