雪花演算法數據重復概率

⑴ 雪花演算法與Mysql自增的優缺點

雪花演算法與Mysql自增的優缺點分別是：

雪花演算法優點是：

1、不會重復。

2、有序，不會造成空間浪費和胡亂插入影響性能。

3、生成很快特別是比UUid快得多。

4、相比UUid更小。

缺點是：時間回撥造成錯亂。

Mysql自增的優點是：

1、存儲空間小。

2、插入和查詢性能高。

缺點是：

1、int的范圍可能不夠大。

2、當要做數據遷移的時候，會很麻煩，主鍵容易沖突。

3、id自增，自身的業務增長情況很容易被別人掌握。

4、自增在高並發的情況下性能不好。

生成id的代碼是：

自增和UUid差異的原因是：mysql資料庫一般我們會採用支持事務的Innodb，在Innodb中，採用的是B+數索引。Innodb的存儲結構，是聚簇索引。對於聚簇索引順序主鍵和隨機主鍵的對效率的影響很大。

自增是順序主鍵存儲，查找和插入都很方便（插入會按順序插到前一個的後面），但UUid是無序的，通過計算獲得的hashcode也會是無序的（是按照hashcode選擇存儲位置）。

所以對於他的查找效率很低，而且因為他是無序的，他的插入有可能會插到前面的數據中，會造成很多其他的操作，很影響性能或者很多存儲空間因為沒有順序的存儲而被空缺浪費。

⑵ 一個12位的字元串，有0-9，A-F組成，100萬條數據有重復的概率是多少

12位的字元串，有（0-9，A-F，共16個不同字元）16^12種可能
100萬條數據，重復的概率為1-（1-1/16^12）^1000000=3.5527e-09

⑶ 訂單表數據量越來越大導致查詢緩慢, 如何處理

可以採用分庫分表. 由於歷史訂單使用率並不高, 高頻的可能只是近期訂單, 因此, 將訂單表按照時間進行拆分, 根據數據量的大小考慮按月分表或按年分表. 訂單ID最好包含時間(如根據雪花演算法生成), 此時既能根據訂單ID直接獲取到訂單記錄, 也能按照時間進行查詢。希望能幫到你。

⑷ 遞歸寫Koch雪花的演算法有哪些

現在繪制3條Koch曲線就構成了Koch雪花。
kochCurve(x0, y0, angle, length, n);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle -= pi*2/3;
kochCurve(x0, y0, angle, length, n);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle -= pi*2/3;
kochCurve(x0, y0, angle, length, n);
下一次的迭代同樣要用到這樣的方法，所以我們可以把這些代碼放倒kochCurve函數中。於是kochCurve成了一個遞歸函數。
為了控制遞歸的深度，我們需要給kochCurve添加一個參數n。
void kochCurve(double x0, double y0, double angle, double length, int n)
{
if(n == 0) {
double x1 = x0 + length*cos(angle);
double y1 = y0 + length*sin(angle);
glBegin(GL_LINES);
glVertex2d(x0, y0);
glVertex2d(x1, y1);
glEnd();
}
else {
length /= 3;
n --;
kochCurve(x0, y0, angle, length, n);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle += pi/3;
kochCurve(x0, y0, angle, length, n);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle -= pi*2/3;
kochCurve(x0, y0, angle, length, n);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle += pi/3;
kochCurve(x0, y0, angle, length, n);
}
}
n是函數遞歸的層數，也是Koch曲線迭代的次數。
kochCurve(x0, y0, angle, length, 0)畫出的是初始的圖形
kochCurve(x0, y0, angle, length, 1)畫出第一次迭代
下面是n = 2, 3, 4, 5的結果。
這里用線段的起點(x0, y0)，方向(和正向x軸之間的角度)及長度來描述一條線段。
繪制一條從(-1.0, 0.0)到(1.0, 0.0)的Koch曲線用下面的方法：
double length = 2.0;
double angle = 0.0;
double x0 = -1.0;
double y0 = 0.0;

kochCurve(x0, y0, angle, length);

一條Koch曲線是由4條比例縮寫為整體1/3的Koch曲線組成。
length = 2.0/3;
kochCurve(x0, y0, angle, length);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle += pi/3;
kochCurve(x0, y0, angle, length);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle -= pi*2/3;
kochCurve(x0, y0, angle, length);

x0 += length*cos(angle);
y0 += length*sin(angle);
angle += pi/3;
kochCurve(x0, y0, angle, length);

這樣就畫出了第一次迭代的結果。
理論上說，Koch曲線是由無數無限短的線段組成。繪圖的時候當然不可能畫出無限短的線段。所以我們根據要求，用若干線段組成。
首先，繪制構造Koch曲線的初始圖形，也就是一條直線。
void kochCurve(double x0, double y0, double angle, double length)
{
double x1 = x0 + length*cos(angle);
double y1 = y0 + length*sin(angle);
glBegin(GL_LINES);
glVertex2d(x0, y0);
glVertex2d(x1, y1);
glEnd();
}

⑸ Oracle中主鍵用什麼類型建

主鍵和數據類型無關。不管是數字，字元，還是時間都可以是主鍵。
不過設置主鍵要注意選擇不重復的欄位，而且最好是有主意查詢的欄位（後面這條不一定）。
而且也考考慮到可能建立的外鍵等等。

⑹ 壓縮的重復壓縮

有兩種形式的重復存在於計算機數據中，zip就是對這兩種重復進行了壓縮。
第一種
一種是短語形式的重復，即三個位元組以上的重復，對於這種重復，zip用兩個數字：1.重復位置距當前壓縮位置的距離；2.重復的長度，來表示這個重復，假設這兩個數字各佔一個位元組，於是數據便得到了壓縮，這很容易理解。
一個位元組有 0 - 255 共 256 種可能的取值，三個位元組有 256 * 256 * 256 共一千六百多萬種可能的情況，更長的短語取值的可能情況以指數方式增長，出現重復的概率似乎極低，實則不然，各種類型的數據都有出現重復的傾向，一篇論文中，為數不多的術語傾向於重復出現；一篇小說，人名和地名會重復出現；一張上下漸變的背景圖片，水平方向上的像素會重復出現；程序的源文件中，語法關鍵字會重復出現（我們寫程序時，多少次前後、paste？），以幾十 K 為單位的非壓縮格式的數據中，傾向於大量出現短語式的重復。經過上面提到的方式進行壓縮後，短語式重復的傾向被完全破壞，所以在壓縮的結果上進行第二次短語式壓縮一般是沒有效果的。
第二種
第二種重復為單位元組的重復，一個位元組只有256種可能的取值，所以這種重復是必然的。其中，某些位元組出現次數可能較多，另一些則較少，在統計上有分布不均勻的傾向，這是容易理解的，比如一個 ASCII 文本文件中，某些符號可能很少用到，而字母和數字則使用較多，各字母的使用頻率也是不一樣的，據說字母 e 的使用概率最高；許多圖片呈現深色調或淺色調，深色（或淺色）的像素使用較多（這里順便提一下：png圖片格式是一種無損壓縮，其核心演算法就是 zip 演算法，它和 zip 格式的文件的主要區別在於：作為一種圖片格式，它在文件頭處存放了圖片的大小、使用的顏色數等信息）；上面提到的短語式壓縮的結果也有這種傾向：重復傾向於出現在離當前壓縮位置較近的地方，重復長度傾向於比較短（20位元組以內）。這樣，就有了壓縮的可能：給 256 種位元組取值重新編碼，使出現較多的位元組使用較短的編碼，出現較少的位元組使用較長的編碼，這樣一來，變短的位元組相對於變長的位元組更多，文件的總長度就會減少，並且，位元組使用比例越不均勻，壓縮比例就越大。

⑺ 如何保證資料庫集群中id的唯一性，假設每秒鍾並發20萬次

用雪花演算法的工具類,1秒內可以生成26萬不重復的值,資料庫的主鍵不要自增,手動設置

java">packageentity;

importjava.lang.management.ManagementFactory;
importjava.net.InetAddress;
importjava.net.NetworkInterface;

/**
*<p>名稱：IdWorker.java</p>
*<p>描述：分布式自增長ID</p>
*<pre>
*Twitter的SnowflakeJAVA實現方案
*</pre>
*核心代碼為其IdWorker這個類實現，其原理結構如下，我分別用一個0表示一位，用—分割開部分的作用：
*1||0------00000---00000---000000000000
*在上面的字元串中，第一位為未使用（實際上也可作為long的符號位），接下來的41位為毫秒級時間，
*然後5位datacenter標識位，5位機器ID（並不算標識符，實際是為線程標識），
*然後12位該毫秒內的當前毫秒內的計數，加起來剛好64位，為一個Long型。
*這樣的好處是，整體上按照時間自增排序，並且整個分布式系統內不會產生ID碰撞（由datacenter和機器ID作區分），
*並且效率較高，經測試，snowflake每秒能夠產生26萬ID左右，完全滿足需要。
*<p>
*64位ID(42(毫秒)+5(機器ID)+5(業務編碼)+12(重復累加))
*
*@authorPolim
*/
publicclassIdWorker{
//時間起始標記點，作為基準，一般取系統的最近時間（一旦確定不能變動）
privatefinalstaticlongtwepoch=1288834974657L;
//機器標識位數
=5L;
//數據中心標識位數
=5L;
//機器ID最大值
=-1L^(-1L<<workerIdBits);
//數據中心ID最大值
=-1L^(-1L<<datacenterIdBits);
//毫秒內自增位
=12L;
//機器ID偏左移12位
=sequenceBits;
//數據中心ID左移17位
=sequenceBits+workerIdBits;
//時間毫秒左移22位
=sequenceBits+workerIdBits+datacenterIdBits;

=-1L^(-1L<<sequenceBits);
/*上次生產id時間戳*/
=-1L;
//0，並發控制
privatelongsequence=0L;

privatefinallongworkerId;
//數據標識id部分
privatefinallongdatacenterId;

publicIdWorker(){
this.datacenterId=getDatacenterId(maxDatacenterId);
this.workerId=getMaxWorkerId(datacenterId,maxWorkerId);
}
/**
*@paramworkerId
*工作機器ID
*@paramdatacenterId
*序列號
*/
publicIdWorker(longworkerId,longdatacenterId){
if(workerId>maxWorkerId||workerId<0){
(String.format("workerIdcan'tbegreaterthan%dorlessthan0",maxWorkerId));
}
if(datacenterId>maxDatacenterId||datacenterId<0){
(String.format("datacenterIdcan'tbegreaterthan%dorlessthan0",maxDatacenterId));
}
this.workerId=workerId;
this.datacenterId=datacenterId;
}
/**
*獲取下一個ID
*
*@return
*/
publicsynchronizedlongnextId(){
longtimestamp=timeGen();
if(timestamp<lastTimestamp){
thrownewRuntimeException(String.format("Clockmovedbackwards.Refusingtogenerateidfor%dmilliseconds",lastTimestamp-timestamp));
}

if(lastTimestamp==timestamp){
//當前毫秒內，則+1
sequence=(sequence+1)&sequenceMask;
if(sequence==0){
//當前毫秒內計數滿了，則等待下一秒
timestamp=tilNextMillis(lastTimestamp);
}
}else{
sequence=0L;
}
lastTimestamp=timestamp;
//ID偏移組合生成最終的ID，並返回ID
longnextId=((timestamp-twepoch)<<timestampLeftShift)
|(datacenterId<<datacenterIdShift)
|(workerId<<workerIdShift)|sequence;

returnnextId;
}

privatelongtilNextMillis(finallonglastTimestamp){
longtimestamp=this.timeGen();
while(timestamp<=lastTimestamp){
timestamp=this.timeGen();
}
returntimestamp;
}

privatelongtimeGen(){
returnSystem.currentTimeMillis();
}

/**
*<p>
*獲取maxWorkerId
*</p>
*/
(longdatacenterId,longmaxWorkerId){
StringBuffermpid=newStringBuffer();
mpid.append(datacenterId);
Stringname=ManagementFactory.getRuntimeMXBean().getName();
if(!name.isEmpty()){
/*
*GETjvmPid
*/
mpid.append(name.split("@")[0]);
}
/*
*MAC+PID的hashcode獲取16個低位
*/
return(mpid.toString().hashCode()&0xffff)%(maxWorkerId+1);
}

/**
*<p>
*數據標識id部分
*</p>
*/
(longmaxDatacenterId){
longid=0L;
try{
InetAddressip=InetAddress.getLocalHost();
NetworkInterfacenetwork=NetworkInterface.getByInetAddress(ip);
if(network==null){
id=1L;
}else{
byte[]mac=network.getHardwareAddress();
id=((0x000000FF&(long)mac[mac.length-1])
|(0x0000FF00&(((long)mac[mac.length-2])<<8)))>>6;
id=id%(maxDatacenterId+1);
}
}catch(Exceptione){
System.out.println("getDatacenterId:"+e.getMessage());
}
returnid;
}


publicstaticvoidmain(String[]args){
//推特26萬個不重復的ID
IdWorkeridWorker=newIdWorker(0,0);
for(inti=0;i<2600;i++){
System.out.println(idWorker.nextId());
}
}

}

⑻ EXCEL中給你一組數據怎麼算出它下次重復出現的概率

呵呵，你要是算上次還有可能，下次涉及預知，辦不到

⑼ 由數據1，2，3組成可重復數字的三位數，試求三位數中至多出現兩個不同數字的概率.

1，2，3可組成的數共有3*3*3=27種，其中數字都不重復的有3*2*1=6種，所以概率為（3*3*3-3*2*1）/（3*3*3）=7/9

⑽ 遞歸寫Koch雪花的演算法

這里有一個程序 希望可以幫到你 vb寫的Koch雪花遞歸演算法Const pi = 3.14159 Private Sub Form_Click() ScaleTop = 300 ScaleLeft = -75 ScaleWidth = 400 ScaleHeight = -300 Call fractal(50 + 30, 150, 110 + 30, 254, 1) Call fractal(110 + 30, 254, 170 + 30, 150, 1) Call fractal(170 + 30, 150, 50 + 30, 150, 1) End Sub Sub fractal(ax As Single, ay As Single, bx As Single, by As Single, s As Integer) If (bx - ax) * (bx - ax) + (by - ay) * (by - ay) < s Then Line (ax, ay)-(bx, by) Else Dim cx As Single, cy As Single Dim dx As Single, dy As Single Dim ex As Single, ey As Single Dim l As Single Dim alpha As Single cx = ax + (bx - ax) / 3 cy = ay + (by - ay) / 3 ex = bx - (bx - ax) / 3 ey = by - (by - ay) / 3 Call fractal(ax, ay, cx, cy, s) Call fractal(ex, ey, bx, by, s) l = Sqr((ex - cx) * (ex - cx) + (ey - cy) * (ey - cy)) alpha = Atn((ey - cy) / (ex - cx)) If (alpha >= 0 And (ex - cx) < 0) Or (alpha <= 0 And (ex - cx) < 0) Then alpha = alpha + pi End If dy = cy + Sin(alpha + pi / 3) * l dx = cx + Cos(alpha + pi / 3) * l Call fractal(cx, cy, dx, dy, s) Call fractal(dx, dy, ex, ey, s) End IfEnd Sub 祝你好運俄