分析：
1、双色球复试计算千万不能拆成单注的。有固定算法的。（要不然福彩服务器早垮了）
2、双色球其实特点鲜明，是组合算法 。（只管数字，不管位置  01,02,03 和 03,02,01没区别）
3、福彩3D直选是排列，组三和组六和组合。
4、3D彩票中有个特点就是一份彩票不管复式还是单式中奖都只能是一注（双色球复式能中多注的）。
代码：
双色球：
注（WinAmount，WinAmountWithDan，Rank 三个方法是从360彩票网中脚本转来的）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TG.Package.Lottery.Base;
using TG.Package.Lottery.Calculate;
namespace TG.Package.Lottery.Win
{
public class TwoColor : IWinCalculate
{
public TwoColor()
{
}
private const Char SplitChar = ',';
public List<WinDetail> GetWinDetails(ILottery pLottery, Dictionary<NumericType, String> pWinNumber)
{
return GetWinDetailsByLottery(pLottery, pWinNumber);
}
/// <summary>
/// Get WinDetails By Lottery
/// </summary>
/// <param name="pLottery">Lottery</param>
/// <param name="pWinNumber">WinNumber</param>
/// <returns></returns>
private static List<WinDetail> GetWinDetailsByLottery(ILottery pLottery, Dictionary<NumericType, String> pWinNumber)
{
String[] redwins = pWinNumber[NumericType.Red].Split(SplitChar);
String bluewins = pWinNumber[NumericType.Blue];
List<WinDetail> result = new List<WinDetail>();
for (var i = 0; i < pLottery.Count; i++)
{
result.AddRange(GetWinDetailsByWelfareLottery(pLottery[i], redwins, bluewins, pLottery.LotteryIssue));
}
return result;
}
/// <summary>
/// Get WinDetails By WelfareLottery
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pRedWinNumbers">Red Win Numbers</param>
/// <param name="pBlueWinNumber"> Blue Win Number</param>
/// <param name="pLotteryIssue">Lottery Issue</param>
/// <returns></returns>
private static List<WinDetail> GetWinDetailsByWelfareLottery(WelfareLottery pWelfareLottery, String[] pRedWinNumbers, String pBlueWinNumber, String pLotteryIssue)
{
Int32[] winnumbers = null;
switch (pWelfareLottery.PlayType)
{
case PlayType.Normal: winnumbers =
GetWinNumberWithNormal(pWelfareLottery.Lottery[NumericType.Red], pWelfareLottery.Lottery[NumericType.Blue], pRedWinNumbers, pBlueWinNumber);
break;
case PlayType.DanTuo: winnumbers =
GetWinNumberWithDan(pWelfareLottery.Lottery[NumericType.Red], pWelfareLottery.Lottery[NumericType.Blue], pWelfareLottery.Lottery[NumericType.Dan], pRedWinNumbers, pBlueWinNumber);
break;
default: throw new FormatException("error: PlayType is error");
}
if (null == winnumbers)
{ throw new FormatException("error: winnumbers is null"); }
return WinAumountToWinDetails(winnumbers, pWelfareLottery, pLotteryIssue);
}
/// <summary>
/// Win Aumount To WinDetails
/// </summary>
/// <param name="pWinAumount">win aumount</param>
/// <param name="pWelfareLottery">Lottery</param>
/// <param name="pLotteryIssue">LotteryIssue</param>
/// <returns></returns>
private static List<WinDetail> WinAumountToWinDetails(Int32[] pWinAumount, WelfareLottery pWelfareLottery, String pLotteryIssue)
{
List<WinDetail> result = new List<WinDetail>();
for (var i = 0; i < pWinAumount.Length; i++)
{
if (pWinAumount[i] < 1)
{
continue;
}
WinDetail temp = new WinDetail();
temp.LotteryIssue = pLotteryIssue;
temp.LotteryNo = pWelfareLottery.ToString();
temp.LotteryType = LotteryType.TwoColor;
temp.PlayType = pWelfareLottery.PlayType;
temp.WinGrade = i + 1;
temp.WinMoney = 0;
temp.WinCount = pWinAumount[i];
result.Add(temp);
}
return result;
}
/// <summary>
/// Get Win number With Normal
/// </summary>
/// <param name="pRed">red buy</param>
/// <param name="pBlue">blue buy</param>
/// <param name="pRedWinNumbers">red match</param>
/// <param name="pBlueWinNumber">blue match</param>
/// <returns></returns>
private static Int32[] GetWinNumberWithNormal(String pRed, String pBlue, String[] pRedWinNumbers, String pBlueWinNumber)
{
Int32 redbuy = (pRed.Length / 3) + 1;
Int32 bluebuy = (pBlue.Length / 3) + 1;
Int32 redmatch = Calculate.NumberHelper.NumberEqual(pRedWinNumbers, pRed);
Int32 bluematch = Calculate.NumberHelper.NumberEqual(new String[] { pBlueWinNumber }, pBlue);
return WinAmount(redbuy, bluebuy, redmatch, bluematch);
}
/// <summary>
/// Get Win Number With Dan
/// </summary>
/// <param name="pRed">red buy</param>
/// <param name="pBlue">blue buy</param>
/// <param name="pDan">dan buy</param>
/// <param name="pRedWinNumbers">red winno</param>
/// <param name="pBlueWinNumber">blue winno</param>
/// <returns></returns>
private static Int32[] GetWinNumberWithDan(String pRed, String pBlue, String pDan, String[] pRedWinNumbers, String pBlueWinNumber)
{
Int32 redbuy = (pRed.Length / 3) + 1;
Int32 bluebuy = (pBlue.Length / 3) + 1;
Int32 danbuy = (pDan.Length / 3) + 1;
Int32 danmatch = Calculate.NumberHelper.NumberEqual(pRedWinNumbers, pDan);
Int32 redmatch = Calculate.NumberHelper.NumberEqual(pRedWinNumbers, pRed);
Int32 bluematch = Calculate.NumberHelper.NumberEqual(new String[] { pBlueWinNumber }, pBlue);
return WinAmountWithDan(danbuy, redbuy, bluebuy, danmatch, redmatch, bluematch);
}
#region Win Amount (not dan)
/// <summary>
/// Win Amount
/// </summary>
/// <param name="rl">red</param>
/// <param name="bl">blue</param>
/// <param name="red">match red</param>
/// <param name="blue">match blue</param>
/// <returns></returns>
private static Int32[] WinAmount(Int32 rl, Int32 bl, Int32 red, Int32 blue)
{
var result = new Int32[] { 0, 0, 0, 0, 0, 0 };
switch (red)
{
case 0:
case 1:
case 2:
#region red=2 blue=1
if (blue > 0)
{
result[5] += Discrete.C(rl, 6);
}
#endregion
break;
case 3:
#region red=3 blue=1
if (blue > 0)
{
result[5] += Discrete.C(rl - red, 4) * Discrete.C(red, 2);
result[5] += Discrete.C(rl - red, 5) * Discrete.C(red, 1);
result[5] += Discrete.C(rl - red, 6);
result[4] += Discrete.C(rl - red, 3);
}
#endregion
break;
case 4:
#region red=4 blue=1
if (blue > 0)
{
result[5] += Discrete.C(rl - red, 6);
result[5] += Discrete.C(rl - red, 5) * Discrete.C(red, 1);
result[5] += Discrete.C(rl - red, 4) * Discrete.C(red, 2);
result[4] += Discrete.C(rl - red, 3) * Discrete.C(red, 3);
result[4] += Discrete.C(rl - red, 2) * Discrete.C(red, 4) * (bl - 1);
result[3] += Discrete.C(rl - red, 2);
}
#endregion
#region red=4 blue=0
else
{
result[4] += Discrete.C(rl - red, 2) * bl;
}
#endregion
break;
case 5:
#region red=5 blue=1
if (blue > 0)
{
result[5] += Discrete.C(rl - red, 6);
result[5] += Discrete.C(rl - red, 5) * Discrete.C(red, 1);
result[5] += Discrete.C(rl - red, 4) * Discrete.C(red, 2);
result[4] += Discrete.C(rl - red, 3) * Discrete.C(red, 3);
result[4] += Discrete.C(rl - red, 2) * Discrete.C(red, 4) * (bl - 1);
result[3] += Discrete.C(rl - red, 2) * Discrete.C(red, 4);
result[3] += Discrete.C(rl - red, 1) * Discrete.C(red, 5) * (bl - 1);
result[2] += Discrete.C(rl - red, 1);
}
#endregion
#region red=5 blue=0
else
{
result[4] += Discrete.C(rl - red, 2) * Discrete.C(red, 4) * bl;
result[3] += Discrete.C(rl - red, 1) * Discrete.C(red, 5) * bl;
}
#endregion
break;
case 6:
#region red=6 blue=1
if (blue > 0)
{
result[5] += Discrete.C(rl - red, 6);
result[5] += Discrete.C(rl - red, 5) * Discrete.C(red, 1);
result[5] += Discrete.C(rl - red, 4) * Discrete.C(red, 2);
result[4] += Discrete.C(rl - red, 3) * Discrete.C(red, 3);
result[4] += Discrete.C(rl - red, 2) * Discrete.C(red, 4) * (bl - 1);
result[3] += Discrete.C(rl - red, 2) * Discrete.C(red, 4);
result[3] += Discrete.C(rl - red, 1) * Discrete.C(red, 5) * (bl - 1);
result[2] += Discrete.C(rl - red, 1) * Discrete.C(red, 5);
result[1] += bl - 1;
result[0]++;
}
#endregion
#region red=6 blue=0
else
{
result[4] += Discrete.C(rl - red, 2) * Discrete.C(red, 4) * bl;
result[3] += Discrete.C(rl - red, 1) * Discrete.C(red, 5) * bl;
result[1] += bl;
}
#endregion
break;
}
return result;
}
#endregion
#region Win Amount With Dan
/// <summary>
/// Win Amount With Dan
/// </summary>
/// <param name="d">dan</param>
/// <param name="t">tuo(red)</param>
/// <param name="b">blue</param>
/// <param name="md">match dan</param>
/// <param name="mt">match tuo(red)</param>
/// <param name="mb">match blue</param>
/// <returns></returns>
private static Int32[] WinAmountWithDan(Int32 d, Int32 t, Int32 b, Int32 md, Int32 mt, Int32 mb)
{
var mtmax = mt <= 6 - d ? mt : 6 - d;
//mt的最大有效值
var MR = new Int32[mtmax + 1];
//命中的红球的个数集合
for (var i = 0; i <= mtmax; i++)
{
MR[i] = md + i;
}
var Result = new Int32[] { 0, 0, 0, 0, 0, 0 };
var cur = 0;
if (mb == 1)
{
for (var i = 0; i <= mtmax; i++)
{
cur = Rank(MR[i], 0);
if (cur != -1)
{
Result[cur] += Discrete.C(t - mt, 6 - d - i) * (b - 1) * Discrete.C(mt, i);
}
cur = Rank(MR[i], 1);
Result[cur] += Discrete.C(t - mt, 6 - d - i) * Discrete.C(mt, i);
}
}
if (mb == 0)
{
for (var i = 0; i <= mtmax; i++)
{
cur = Rank(MR[i], 0);
if (cur != -1)
{
Result[cur] += Discrete.C(t - mt, 6 - d - i) * b * Discrete.C(mt, i);
}
}
}
return Result;
}
/// <summary>
/// Rank
/// </summary>
/// <param name="md">match dan</param>
/// <param name="b">blue</param>
/// <returns></returns>
private static Int32 Rank(Int32 md, Int32 b)
{
var src = md * 1 + b * 1;
switch (src)
{
case 7:
return 0;
case 6:
return (b == 1 ? 2 : 1);
case 5:
return 3;
case 4:
return 4;
default:
return (b == 1 ? 5 : -1);
}
}
#endregion
}//end TwoColor
}
福彩3D：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TG.Package.Lottery.Base;
namespace TG.Package.Lottery.Win
{
public class FuCai3D : IWinCalculate
{
public FuCai3D()
{
}
private const Char SplitChar = ',';
public List<WinDetail> GetWinDetails(ILottery pLottery, Dictionary<NumericType, String> pWinNumber)
{
return GetWinDetailsWithLottery(pLottery, pWinNumber);
}
/// <summary>
/// Get WinDetails By Lottery
/// </summary>
/// <param name="pLottery">Lottery</param>
/// <param name="pWinNumber">WinNumber</param>
/// <returns></returns>
private static List<WinDetail> GetWinDetailsWithLottery(ILottery pLottery, Dictionary<NumericType, String> pWinNumber)
{
List<WinDetail> reslut = new List<WinDetail>();
String[] winnumbers=new String[]{pWinNumber[NumericType.Ones],pWinNumber[NumericType.Tens],pWinNumber[NumericType.Hundreds]};
for (var i = 0; i < pLottery.Count; i++)
{
reslut.Add(GetWinDetailsByWelfareLottery(pLottery[i], winnumbers, pLottery.LotteryIssue));
}
return reslut;
}
/// <summary>
/// Get WinDetails By WelfareLottery
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pRedWinNumbers">Red Win Numbers</param>
/// <param name="pBlueWinNumber"> Blue Win Number</param>
/// <param name="pLotteryIssue">Lottery Issue</param>
/// <returns></returns>
private static WinDetail GetWinDetailsByWelfareLottery(WelfareLottery pWelfareLottery, String[] pWinNumbers, String pLotteryIssue)
{
Int32 winamount = 0;
switch (pWelfareLottery.PlayType)
{
case PlayType.Normal:
winamount = GetNormalWinAmount(pWelfareLottery, pWinNumbers);
break;
case PlayType.Zu3:
winamount = GetZu3WinAmount(pWelfareLottery, pWinNumbers);
break;
case PlayType.Zu6:
winamount = GetZu6WinAmount(pWelfareLottery, pWinNumbers);
break;
case PlayType.Normal | PlayType.DanTuo:
winamount = GetNormalDanWinAmount(pWelfareLottery, pWinNumbers);
break;
case PlayType.Zu3 | PlayType.DanTuo:
winamount = GetZu3DanWinAmount(pWelfareLottery, pWinNumbers);
break;
case PlayType.Zu6 | PlayType.DanTuo:
winamount = GetZu6DanWinAmount(pWelfareLottery, pWinNumbers);
break;
default: throw new FormatException("error:PlayType is error");
}
if (winamount == 1)
{
return GetWinDetailsModel(pWelfareLottery, pLotteryIssue);
}
return null;
}
/// <summary>
/// pWelfareLottery to WinDetail
/// </summary>
private static WinDetail GetWinDetailsModel(WelfareLottery pWelfareLottery, String pLotteryIssue)
{
WinDetail temp = new WinDetail();
temp.LotteryIssue = pLotteryIssue;
temp.LotteryNo = pWelfareLottery.ToString();
temp.LotteryType = LotteryType.FuCai3D;
temp.PlayType = pWelfareLottery.PlayType;
temp.WinGrade = 1;
temp.WinMoney = 0;
temp.WinCount = 1;
return temp;
}
#region Get Win Amount
/// <summary>
/// Get Normal WinAmount
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pWinNumbers">WinNumbers</param>
/// <returns></returns>
private static Int32 GetNormalWinAmount(WelfareLottery pWelfareLottery, String[] pWinNumbers)
{
String one = pWelfareLottery.Lottery[NumericType.Ones];
String ten = pWelfareLottery.Lottery[NumericType.Tens];
String hundred = pWelfareLottery.Lottery[NumericType.Hundreds];
if (Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[0] }, one) > 0
&& Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[1] }, ten) > 0
&& Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[2] }, hundred) > 0
)
{
return 1;
}
return 0;
}
/// <summary>
/// Get Zu3 WinAmount
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pWinNumbers">WinNumbers</param>
/// <returns></returns>
private static Int32 GetZu3WinAmount(WelfareLottery pWelfareLottery, String[] pWinNumbers)
{
if (!Calculate.NumberHelper.IsZu3WinNo(pWinNumbers))
{
return 0;
}
String zu3 = pWelfareLottery.Lottery[NumericType.Zu3];
if (Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[0] }, zu3) > 0
&& Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[2] }, zu3) > 0
)
{
return 1;
}
return 0;
}
/// <summary>
/// Get Zu6 WinAmount
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pWinNumbers">WinNumbers</param>
/// <returns></returns>
private static Int32 GetZu6WinAmount(WelfareLottery pWelfareLottery, String[] pWinNumbers)
{
if (Calculate.NumberHelper.IsZu3WinNo(pWinNumbers))
{
return 0;
}
String zu6 = pWelfareLottery.Lottery[NumericType.Zu6];
if (Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[0] }, zu6) > 0
&& Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[1] }, zu6) > 0
&& Calculate.NumberHelper.NumberEqual(new String[] { pWinNumbers[2] }, zu6) > 0
)
{
return 1;
}
return 0;
}
/// <summary>
/// Get Normal Dan WinAmount
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pWinNumbers">WinNumbers</param>
/// <returns></returns>
private static Int32 GetNormalDanWinAmount(WelfareLottery pWelfareLottery, String[] pWinNumbers)
{
String winno = String.Format("{0},{1},{2}", pWinNumbers[0], pWinNumbers[1], pWinNumbers[2]);
return GetDanWinAmount(pWelfareLottery, winno);
}
/// <summary>
/// Get Zu3 Dan WinAmount
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pWinNumbers">WinNumbers</param>
/// <returns></returns>
private static Int32 GetZu3DanWinAmount(WelfareLottery pWelfareLottery, String[] pWinNumbers)
{
if (!Calculate.NumberHelper.IsZu3WinNo(pWinNumbers))
{
return 0;
}
String winno = String.Format("{0},{1}", pWinNumbers[0], pWinNumbers[2]);
return GetDanWinAmount(pWelfareLottery, winno);
}
/// <summary>
/// Get Zu6 DanWinAmount
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pWinNumbers">WinNumbers</param>
/// <returns></returns>
private static Int32 GetZu6DanWinAmount(WelfareLottery pWelfareLottery, String[] pWinNumbers)
{
if (Calculate.NumberHelper.IsZu3WinNo(pWinNumbers))
{
return 0;
}
String winno = String.Format("{0},{1},{2}", pWinNumbers[0], pWinNumbers[1], pWinNumbers[2]);
return GetDanWinAmount(pWelfareLottery, winno);
}
/// <summary>
/// Get Dan WinAmount
/// </summary>
/// <param name="pWelfareLottery">WelfareLottery</param>
/// <param name="pWinNo">WinNo (ex: "1,2,3")</param>
/// <returns></returns>
private static Int32 GetDanWinAmount(WelfareLottery pWelfareLottery, String pWinNo)
{
String dan = pWelfareLottery.Lottery[NumericType.Dan];
String tuo = pWelfareLottery.Lottery[NumericType.Tuo];
if (Calculate.NumberHelper.NumberEqual(dan.Split(SplitChar), pWinNo) > 0
&& Calculate.NumberHelper.NumberEqual(tuo.Split(SplitChar), pWinNo) > 0
)
{
return 1;
}
return 0;
}
#endregion
}//end FuCai3D
}
结束语：
写这些4篇连续随笔，主要是记录下 当我接到模块后，的思维过程的编码过程。
希望在过2年又能有所不一样（当然是网好的方面发展 嘻嘻）
通过 Wiz 发布

转载于:https://www.cnblogs.com/tianjing/archive/2012/07/02/2573665.html

练习之彩票四 计算中奖数（结尾）相关推荐

  1. 【项目实战】——Java根据奖品权重计算中奖概率实现抽奖（适用于砸金蛋、大转盘等抽奖活动）...

    Java根据奖品权重计算中奖概率实现抽奖http://www.bieryun.com/1035.html 双蛋节(圣诞+元旦)刚刚过去,前几天项目上线的砸金蛋活动也圆满结束. 现在在许多网站上都会有抽 ...

  2. COUNT(*)计算行数有哪些优化手段

    COUNT(*)计算行数有哪些优化手段 --无索引 DROP TABLE T_20170704_COUNT_LHR_01 PURGE; CREATE TABLE T_20170704_COUNT_LH ...

  3. 【运筹学】人工变量法总结 ( 人工变量法解的分析 | 标准型变换 | 构造单位阵 | 目标函数引入 M | 计算检验数 | 选择入基变量 | 选择出基变量 | 中心元变换 | ) ★★

    文章目录 一.人工变量法及解的分析 二.案例 三.线性规划标准型变换 四.人工变量法构造单位阵 五.初始单纯形表 六.初始单纯形表 : 计算非基变量检验数 七.初始单纯形表 : 最优解判定 八.初始单 ...

  4. 【运筹学】单纯形法总结 ( 单纯形法原理 | 单纯形法流程 | 单纯形表 | 计算检验数 | 最优解判定 | 入基变量 | 出基变量 | 方程组同解变换 ) ★★★

    文章目录 一.单纯形法原理 二.单纯形法流程 三.单纯形法案例一 1.线性规划示例 2.转化标准形式 3.查找初始基可行解 4.初始基可行解的最优解判定 5.第一次迭代 : 入基与出基变量选择 6.第 ...

  5. 【运筹学】表上作业法 ( 找初始基可行解 | 计算检验数 | 调整运量 )

    文章目录 一.运输规划问题 二.找初始基可行解 三.计算检验数 四.调整运量 ( 换基 ) 一.运输规划问题 运输规划问题 : 二.找初始基可行解 使用最小元素法求得的初始基可行解 : B1\rm B ...

  6. 【运筹学】线性规划数学模型 ( 单纯形法 | 第二次迭代 | 方程组同解变换 | 生成新单纯形表 | 计算检验数 | 最优解判定 | 线性规划解个数分析 )

    文章目录 一.第二次迭代 二.方程组同解变换 三.生成新的单纯形表 四.计算检验数.最优解判定 五.最优解个数说明 1.唯一最优解 2.无穷最优解 3.无界解 4.总结 六.出基变量选择说明 上一篇博 ...

  7. 【运筹学】线性规划数学模型 ( 单纯形法 | 第一次迭代 | 方程组同解变换 | 计算新单纯形表 | 计算检验数 | 入基变量选择 | 出基变量选择 )

    文章目录 一.初始基可行解后第一次迭代 二.迭代后新的单纯形表 三.方程组同解变换 四.生成新的单纯形表 五.解出基可行解 六.计算检验数 σj\sigma_jσj​ 并选择入基变量 七.计算 θ\t ...

  8. I00020 计算卡特兰数函数

    卡特兰数是组合数学中的一个重要概念. 卡特兰数可以解决以下四种典型的问题: 1.括号化问题 矩阵链乘: P=a1×a2×a3×--×an,依据乘法结合律,不改变其顺序,只用括号表示成对的乘积,试问有几 ...

  9. Python练习：四叶玫瑰数

    练习:四叶玫瑰数 平台:Python123.io 教师:嵩天 描述 四叶玫瑰数是4位数的自幂数.自幂数是指一个 n 位数,它的每个位上的数字的 n 次幂之和等于它本身.(例如:当n为3时,有1^3 + ...

最新文章

  1. NodeJs端口被占用的情况
  2. java 全局变量_Java语言与C语言、C++语言有何差异以及优劣势
  3. stm32 堆和栈(stm32 Heap Stack)【worldsing笔记】
  4. 一个很简单的淡入淡出相册 （转）
  5. apache camel_您的Apache Camel应用程序现在包括现成的文档
  6. 【算法】剑指 Offer 24. 反转链表
  7. liferay 去掉 portlet:actionUrl 跳转时的message
  8. Interpreting and Disentangling Feature Components of Various Complexity from DNNS论文解读
  9. 做一个简易jsp项目的详细开发流程及步骤
  10. DTCloud编码规范
  11. 2013年新交规科目二考试实录（北京京东驾校）
  12. 阿里设计师：B端产品国际版体验设计
  13. QT 删除QString空白字符
  14. 计算机应用多媒体设计是学什么的,数字媒体艺术设计专业是学什么？
  15. 【机器学习】显卡、GPU、NVIDIA、CUDA、cuDNN
  16. app软件小程序开发
  17. Java 编程问题：四、类型推断
  18. 如何进行数据可视化制图
  19. PAMI2018跟踪算法HCFTstar的配置（Robust Visual Tracking via Hierarchical Convolutional Features）
  20. RK3568平台开发系列讲解（调试篇）PCIe调试详解

热门文章

  1. 认识float的指数与尾数
  2. 首次使用计算机 鼠标没反应,鼠标没反应各种解决方法教程
  3. C++ 创建指定大小的空白文件
  4. 错误代码 0x80070035 找不到网络路径 终极解决办法
  5. 算法之统计一篇文章里不同单词的个数
  6. python自动安装windows软件_python模块 - pywinauto(windows自动化安装软件)
  7. LSTM 的几种改进方案
  8. 计算机维护费可以跨年吗,税控维护费跨年抵扣分录怎么做
  9. 小学计算机教师集体备课计实,教师集体备课心得体会精选5篇合集
  10. 修改配置的时候提示token验证失败/微信公众号