比的演算法

① 黃金比例的演算法和黃金比是多少

黃金比例（以下簡稱「黃金比」）約為： 0.618:1

如果有一條線段的總長度為黃金比例的 分母加分子的單位長，若我們把他分割為兩半，長的為分母單位長度，短的為分子單位長度 則短線長度與長線長度的比值即為黃金比例。

設一個數列，它的最前面兩個數是1、1，後面的每個數都是它前面的兩個數之和。例如：1，1，2，3，5，8，13，21，34，55，89，144·····這個數列為「斐波那契數列」，這些數被稱為「斐波那契數」。經計算發現相鄰兩個斐波那契數的比值是隨序號的增加而逐漸逼近黃金分割比。

(1)比的演算法擴展閱讀：

畫家們發現，按0.618:1來設計的比例，畫出的畫最優美，在達·芬奇的作品《維特魯威人》、《蒙娜麗莎》、還有《最後的晚餐》中都運用了黃金分割。而現今的女性，腰身以下的長度平均只佔身高的0.58，因此古希臘的著名雕像斷臂維納斯及太陽神阿波羅都通過故意延長雙腿，使之與身高的比值為0.618。

建築師們對數字0.618特別偏愛，無論是古埃及的金字塔，還是巴黎的聖母院，或者是近世紀的法國埃菲爾鐵塔，希臘雅典的巴特農神廟，都有黃金分割的足跡。

② 關於濃度比的演算法

c(mol/L)=[1000ml×ρ(g/㎝?-3)×ω%]／溶液的摩爾質量（g/mol）×1L溶液 =1000ρω％/M c:溶液的量濃度，單位為mol/L ω％：溶液中質量的質量分數，ω％=溶質質量/溶液質量×100％ ρ：溶液密度，單位為g/㎝?-3 重量百分比=所求物質的量/總質量×100％

③ 如何算佔比例

佔比例計算：即為所求佔比例數值/總數值。

例如：一部門總人數為250個，缺勤人數為8個,缺勤率是8/250=0.032。

比例，表示兩個比相等的式子叫做比例,組成比例的四個數，叫做比例的項，兩端的兩項叫做比例的外項，中間的兩項叫做比例的內項。比例還是技術制圖中的一般規定術語，是指圖中圖形與其實物相應要素的線性尺寸之比。在數學中，比例是一個總體中各個部分的數量占總體數量的比重，用於反映總體的構成或者結構。

(3)比的演算法擴展閱讀

比例（proportion）是一個數學術語，表示兩或多個比相等的式子。在一個比例中，兩個外項的積等於兩個內項的積，叫做比例的基本性質。

在數學中，如果一個變數的變化總是伴隨著另一個變數的變化，則兩個變數是成比例的，並且如果變化總是通過使用常數乘數相關聯，那麼 常數稱為比例系數或比例常數。

比例是一個總體中各個部分的數量占總體數量的比重，用於反映總體的構成或者結構。

比例分為比例尺和比例兩種.表示兩個比相等的式子叫做比例。判斷兩個比能不能組成比例，要看它們的比值是不是相等。組成比例的四個數，叫做比例的項。

兩端的兩項叫做比例的外項，中間的兩項叫做比例的內項。在比例里，兩個外項的積等於兩個內項的積，這是比例的基本性質。求比例其中一個未知項，叫做解比例。

④ 100分比的演算法

就是65,4佔85的百分比。65.4除以85，等於0.7694，變換成百分比就是76.94%，

⑤ 急求比例的演算法！

長:寬:高==255:68:250，直接約分就可以了，化成最簡整數比

⑥ 冒泡排序法和快速排序比較的演算法

打你屁股，這么簡單的問題都不認真研究一下。

冒泡排序是最慢的排序，時間復雜度是 O(n^2)。

快速排序是最快的排序。關於快速排序，我推薦你看看《代碼之美》第二章：我編寫過的最漂亮的代碼。作者所說的最漂亮，就是指效率最高的。

--------------------------------摘自《代碼之美》---------------

當我撰寫關於分治（divide-and-conquer）演算法的論文時，我發現C.A.R. Hoare的Quicksort演算法（「Quicksort」，Computer Journal 5）無疑是各種Quicksort演算法的鼻祖。這是一種解決基本問題的漂亮演算法，可以用優雅的代碼實現。我很喜歡這個演算法，但我總是無法弄明白演算法中最內層的循環。我曾經花兩天的時間來調試一個使用了這個循環的復雜程序，並且幾年以來，當我需要完成類似的任務時，我會很小心地復制這段代碼。雖然這段代碼能夠解決我所遇到的問題，但我卻並沒有真正地理解它。
我後來從Nico Lomuto那裡學到了一種優雅的劃分（partitioning）模式，並且最終編寫出了我能夠理解，甚至能夠證明的Quicksort演算法。William Strunk Jr.針對英語所提出的「良好的寫作風格即為簡練」這條經驗同樣適用於代碼的編寫，因此我遵循了他的建議，「省略不必要的字詞」（來自《The Elements of Style》一書）。我最終將大約40行左右的代碼縮減為十幾行的代碼。因此，如果要回答「你曾編寫過的最漂亮代碼是什麼？」這個問題，那麼我的答案就是：在我編寫的《Programming Pearls, Second Edition》(Addison-Wesley)一書中給出的Quichsort演算法。在示例2-1中給出了用C語言編寫的Quicksort函數。我們在接下來的章節中將進一步地研究和改善這個函數。
【示例】 2-1 Quicksort函數
void quicksort(int l, int u)
{ int i, m;
if (l >= u) return; 10
swap(l, randint(l, u));
m = l;
for (i = l+1; i <= u; i++)
if (x[i] < x[l])
swap(++m, i);
swap(l, m);
quicksort(l, m-1);
quicksort(m+1, u);
}
如果函數的調用形式是quicksort(0, n-1)，那麼這段代碼將對一個全局數組x[n]進行排序。函數的兩個參數分別是將要進行排序的子數組的下標：l是較低的下標，而u是較高的下標。函數調用swap(i,j)將會交換x[i]與x[j]這兩個元素。第一次交換操作將會按照均勻分布的方式在l和u之間隨機地選擇一個劃分元素。
在《Programming Pearls》一書中包含了對Quicksort演算法的詳細推導以及正確性證明。在本章的剩餘內容中，我將假設讀者熟悉在《Programming Pearls》中所給出的Quicksort演算法以及在大多數初級演算法教科書中所給出的Quicksort演算法。
如果你把問題改為「在你編寫那些廣為應用的代碼中，哪一段代碼是最漂亮的？」我的答案還是Quicksort演算法。在我和M. D. McIlroy一起編寫的一篇文章（"Engineering a sort function," Software-Practice and Experience, Vol. 23, No. 11）中指出了在原來Unix qsort函數中的一個嚴重的性能問題。隨後，我們開始用C語言編寫一個新排序函數庫，並且考慮了許多不同的演算法，包括合並排序（Merge Sort）和堆排序（Heap Sort）等演算法。在比較了Quicksort的幾種實現方案後，我們著手創建自己的Quicksort演算法。在這篇文章中描述了我們如何設計出一個比這個演算法的其他實現要更為清晰，速度更快以及更為健壯的新函數——部分原因是由於這個函數的代碼更為短小。Gordon Bell的名言被證明是正確的：「在計算機系統中，那些最廉價，速度最快以及最為可靠的組件是不存在的。」現在，這個函數已經被使用了10多年的時間，並且沒有出現任何故障。
考慮到通過縮減代碼量所得到的好處，我最後以第三種方式來問自己在本章之初提出的問題。「你沒有編寫過的最漂亮代碼是什麼？」。我如何使用非常少的代碼來實現大量的功能？答案還是和Quicksort有關，特別是對這個演算法的性能分析。我將在下一節給出詳細介紹。
2.2 事倍功半
Quicksort是一種優雅的演算法，這一點有助於對這個演算法進行細致的分析。大約在1980年左右，我與Tony Hoare曾經討論過Quicksort演算法的歷史。他告訴我，當他最初開發出Quicksort時，他認為這種演算法太簡單了，不值得發表，而且直到能夠分析出這種演算法的預期運行時間之後，他才寫出了經典的「Quicksoft」論文。
我們很容易看出，在最壞的情況下，Quicksort可能需要n2的時間來對數組元素進行排序。而在最優的情況下，它將選擇中值作為劃分元素，因此只需nlgn次的比較就可以完成對數組的排序。那麼，對於n個不同值的隨機數組來說，這個演算法平均將進行多少次比較？
Hoare對於這個問題的分析非常漂亮，但不幸的是，其中所使用的數學知識超出了大多數程序員的理解范圍。當我為本科生講授Quicksort演算法時，許多學生即使在費了很大的努力之後，還是無法理解其中的證明過程，這令我非常沮喪。下面，我們將從Hoare的程序開
11
始討論，並且最後將給出一個與他的證明很接近的分析。
我們的任務是對示例2-1中的Quicksort代碼進行修改，以分析在對元素值均不相同的數組進行排序時平均需要進行多少次比較。我們還將努力通過最短的代碼、最短運行時間以及最小存儲空間來得到最深的理解。
為了確定平均比較的次數，我們首先對程序進行修改以統計次數。因此，在內部循環進行比較之前，我們將增加變數comps的值（參見示例2-2）。
【示例2-2】 修改Quicksort的內部循環以統計比較次數。
for (i = l+1; i <= u; i++) {
comps++;
if (x[i] < x[l])
swap(++m, i);
}
如果用一個值n來運行程序，我們將會看到在程序的運行過程中總共進行了多少次比較。如果重復用n來運行程序，並且用統計的方法來分析結果，我們將得到Quicksort在對n個元素進行排序時平均使用了1.4 nlgn次的比較。
在理解程序的行為上，這是一種不錯的方法。通過十三行的代碼和一些實驗可以反應出許多問題。這里，我們引用作家Blaise Pascal和T. S. Eliot的話，「如果我有更多的時間，那麼我給你寫的信就會更短。」現在，我們有充足的時間，因此就讓我們來對代碼進行修改，並且努力編寫出更短（同時更好）的程序。
我們要做的事情就是提高這個演算法的速度，並且盡量增加統計的精確度以及對程序的理解。由於內部循環總是會執行u-l次比較，因此我們可以通過在循環外部增加一個簡單的操作來統計比較次數，這就可以使程序運行得更快一些。在示例2-3的Quicksort演算法中給出了這個修改。
【示例2-3】 Quicksort的內部循環，將遞增操作移到循環的外部
comps += u-l;
for (i = l+1; i <= u; i++)
if (x[i] < x[l])
swap(++m, i);
這個程序會對一個數組進行排序，同時統計比較的次數。不過，如果我們的目標只是統計比較的次數，那麼就不需要對數組進行實際地排序。在示例2-4中去掉了對元素進行排序的「實際操作」，而只是保留了程序中各種函數調用的「框架」。
【示例2-4】將Quicksort演算法的框架縮減為只進行統計
void quickcount(int l, int u)
{ int m;
if (l >= u) return;
m = randint(l, u);
comps += u-l;
quickcount(l, m-1);
quickcount(m+1, u);
}
12
這個程序能夠實現我們的需求，因為Quichsort在選擇劃分元素時採用的是「隨機」方式，並且我們假設所有的元素都是不相等的。現在，這個新程序的運行時間與n成正比，並且相對於示例2-3需要的存儲空間與n成正比來說，現在所需的存儲空間縮減為遞歸堆棧的大小，即存儲空間的平均大小與lgn成正比。
雖然在實際的程序中，數組的下標（l和u）是非常重要的，但在這個框架版本中並不重要。因此，我們可以用一個表示子數組大小的整數(n)來替代這兩個下標（參見示例2-5）
【示例2-5】 在Quicksort代碼框架中使用一個表示子數組大小的參數
void qc(int n)
{ int m;
if (n <= 1) return;
m = randint(1, n);
comps += n-1;
qc(m-1);
qc(n-m);
}
現在，我們可以很自然地把這個過程整理為一個統計比較次數的函數，這個函數將返回在隨機Quicksort演算法中的比較次數。在示例2-6中給出了這個函數。
【示例2-6】 將Quicksort框架實現為一個函數
int cc(int n)
{ int m;
if (n <= 1) return 0;
m = randint(1, n);
return n-1 + cc(m-1) + cc(n-m);
}
在示例2-4、示例2-5和示例2-6中解決的都是相同的基本問題，並且所需的都是相同的運行時間和存儲空間。在後面的每個示例都對這些函數的形式進行了改進，從而比這些函數更為清晰和簡潔。
在定義發明家的矛盾（inventor's paradox）(How To Solve It, Princeton University Press)時，George Póllya指出「計劃越宏大，成功的可能性就越大。」現在，我們就來研究在分析Quicksort時的矛盾。到目前為止，我們遇到的問題是，「當Quicksort對大小為n的數組進行一次排序時，需要進行多少次比較？」我們現在將對這個問題進行擴展，「對於大小為n的隨機數組來說，Quichsort演算法平均需要進行多少次的比較？」我們通過對示例2-6進行擴展以引出示例2-7。
【示例2-7】 偽碼：Quicksort的平均比較次數
float c(int n)
if (n <= 1) return 0
sum = 0
for (m = 1; m <= n; m++)
sum += n-1 + c(m-1) + c(n-m)
return sum/n
如果在輸入的數組中最多隻有一個元素，那麼Quichsort將不會進行比較，如示例2-6
13
中所示。對於更大的n，這段代碼將考慮每個劃分值m（從第一個元素到最後一個，每個都是等可能的）並且確定在這個元素的位置上進行劃分的運行開銷。然後，這段代碼將統計這些開銷的總和（這樣就遞歸地解決了一個大小為m-1的問題和一個大小為n-m的問題），然後將總和除以n得到平均值並返回這個結果。
如果我們能夠計算這個數值，那麼將使我們實驗的功能更加強大。我們現在無需對一個n值運行多次來估計平均值，而只需一個簡單的實驗便可以得到真實的平均值。不幸的是，實現這個功能是要付出代價的：這個程序的運行時間正比於3n（如果是自行參考（self-referential）的，那麼用本章中給出的技術來分析運行時間將是一個很有趣的練習）。
示例2-7中的代碼需要一定的時間開銷，因為它重復計算了中間結果。當在程序中出現這種情況時，我們通常會使用動態編程來存儲中間結果，從而避免重復計算。因此，我們將定義一個表t[N+1]，其中在t[n]中存儲c[n]，並且按照升序來計算它的值。我們將用N來表示n的最大值，也就是進行排序的數組的大小。在示例2-8中給出了修改後的代碼。
【示例2-8】 在Quicksort中使用動態編程來計算
t[0] = 0
for (n = 1; n <= N; n++)
sum = 0
for (i = 1; i <= n; i++)
sum += n-1 + t[i-1] + t[n-i]
t[n] = sum/n
這個程序只對示例2-7進行了細微的修改，即用t[n]來替換c(n)。它的運行時間將正比於N2，並且所需的存儲空間正比於N。這個程序的優點之一就是：在程序執行結束時，數組t中將包含數組中從元素0到元素N的真實平均值（而不是樣本均值的估計）。我們可以對這些值進行分析，從而生成在Quichsort演算法中統計比較次數的計算公式。
我們現在來對程序做進一步的簡化。第一步就是把n-1移到循環的外面，如示例2-9所示。
【示例2-9】 在Quicksort中把代碼移到循環外面來計算
t[0] = 0
for (n = 1; n <= N; n++)
sum = 0
for (i = 1; i <= n; i++)
sum += t[i-1] + t[n-i]
t[n] = n-1 + sum/n
現在將利用對稱性來對循環做進一步的調整。例如，當n為4時，內部循環計算總和為：
t[0]+t[3] + t[1]+t[2] + t[2]+t[1] + t[3]+t[0]
在上面這些組對中，第一個元素增加而第二個元素減少。因此，我們可以把總和改寫為：
2 * (t[0] + t[1] + t[2] + t[3])
我們可以利用這種對稱性來得到示例2-10中的Quicksort。
【示例2-10】 在Quichsort中利用了對稱性來計算
t[0] = 0
14
for (n = 1; n <= N; n++)
sum = 0
for (i = 0; i < n; i++)
sum += 2 * t[i]
t[n] = n-1 + sum/n
然而，在這段代碼的運行時間中同樣存在著浪費，因為它重復地計算了相同的總和。此時，我們不是把前面所有的元素加在一起，而是在循環外部初始化總和並且加上下一個元素，如示例2-11所示。
【示例2-11】 在Quicksort中刪除了內部循環來計算
sum = 0; t[0] = 0
for (n = 1; n <= N; n++)
sum += 2*t[n-1]
t[n] = n-1 + sum/n
這個小程序確實很有用。程序的運行時間與N成正比，對於每個從1到N的整數，程序將生成一張Quicksort的估計運行時間表。
我們可以很容易地把示例2-11用表格來實現，其中的值可以立即用於進一步的分析。在2-1給出了最初的結果行。
表2-1 示例2-11中實現的表格輸出
N Sum t[n]
0 0 0
1 0 0
2 0 1
3 2 2.667
4 7.333 4.833
5 17 7.4
6 31.8 10.3
7 52.4 13.486
8 79.371 16.921
這張表中的第一行數字是用代碼中的三個常量來進行初始化的。下一行（輸出的第三行）的數值是通過以下公式來計算的：
A3 = A2+1 B3 = B2 + 2*C2 C3 = A2-1 + B3/A3
把這些（相應的）公式記錄下來就使得這張表格變得完整了。這張表格是「我曾經編寫的最漂亮代碼」的很好的證據，即使用少量的代碼完成大量的工作。
但是，如果我們不需要所有的值，那麼情況將會是什麼樣？如果我們更希望通過這種來方式分析一部分數值（例如，在20到232之間所有2的指數值）呢？雖然在示例2-11中構建了完整的表格t，但它只需要使用表格中的最新值。因此，我們可以用變數t的定長空間來替代table t[]的線性空間，如示例2-12所示。
【示例2-12】 Quicksoft 計算——最終版本
sum = 0; t = 0
15
for (n = 1; n <= N; n++)
sum += 2*t
t = n-1 + sum/n
然後，我們可以插入一行代碼來測試n的適應性，並且在必要時輸出這些結果。
這個程序是我們漫長學習旅途的終點。通過本章所採用的方式，我們可以證明Alan Perlis的經驗是正確的：「簡單性並不是在復雜性之前，而是在復雜性之後」 ("Epigrams on Programming," Sigplan Notices, Vol. 17, Issue 9)。

⑦ 高響應比優先調度演算法的原理

高響應比優先調度演算法既考慮作業的執行時間也考慮作業的等待時間，綜合了先來先服務和最短作業優先兩種演算法的特點。
該演算法中的響應比是指作業等待時間與運行比值，響應比公式定義如下：
響應比 =（等待時間+要求服務時間）/ 要求服務時間,即RR=（w+s）/s=1+w/s，因此響應比一定是大於1的。
如實例：
某系統有3個作業，系統確定它們在全部到達後，再開始採用響應比高者優先的調度演算法，則它們的調度順序是什麼？各自的周轉時間是什麼？
作業號 提交時間 運行時間
1 8.8 1.5
2 9.0 0.4
3 9.5 1.0
(1)如果都到達再算的話,等待時間=最後一個的提交時間-該作業到達的時刻
1: 9.5-8.8=0.7
2: 9.5-9=0.5
3: 0
所以響應比為（等待時間+要求服務時間）要求服務時間=等待時間/要求服務時間+1
1: 0.7/1.5+1=1.47
2: 0.5/0.4+1=2.25
3: 1
所以2先運行,2從9.5開始運行到9.9結束;
再以9.9時刻算響應比:
1: (9.9-8.8)/1.5+1=1.73
3: (9.9-9.5)/1+1=1.4
所以2執行完後1開始執行,從9.9執行到11.4結束
最後一個是3:從11.4開始執行到12.4結束
(2)如果不是都到達後才運行，那麼在8.8時只有作業1到達，所以先運行作業1
8.8+1.5（運行時間）=10.3
到10.3的時候作業1完成，此時作業2和3都已到達所以計算其響應比
（等待時間+要求服務時間）要求服務時間=等待時間/要求服務時間+1
作業2：（10.3-9.0）/0.4+1=4.325
作業3：（10.3-9.5）/1.0+1=1.8
所以先運行作業2
10.3+0.4=10.7
到10.7運行作業3
10.7+1.0=11.7
到11.7結束

⑧ 比例的兩個比的比值的計算方法是什麼

比的前項除以比的後項是比例的。

⑨ 如何求兩個數的比例 演算法是什麼

把計算式寫成豎式，找到分子分母的最大公約數，約分後就得到答案。或者從最小公約數開始約分，一次一次約，約到最後再也找不出公約數可約時，就是最後答案。

⑩ 比例演算法怎麼算的，請舉例

①1份糖 2份水 合計是3份液體，就是 3份之一的糖 。1除以3 就是 0.33的糖，33%的糖 66%的水。

②基礎代謝率＝（脈率＋脈壓）－111

基礎代謝率測定有兩種方法，即根據脈壓和脈率前計算，或用基礎代謝測定儀測定。

前者簡便易行，後者較可靠。常用計算公式為：基礎代謝率=（脈率十脈壓）-111。

正常值為±10％；＋20％～＋30％為輕度甲亢，＋30％～＋60％為中度，＞＋60％重度。