數的編碼源碼

㈠ 你好，請問你有沒有浮點數編碼實例的遺傳演算法的c++源代碼 或者實數編碼也行

浮點數編碼還不明白

C++還沒有學

遺傳演算法還不知道

實說編碼還沒有學

㈡ 源代碼是什麼

源代碼
source code

源程序是指未編譯的文本代碼。

驗證碼主要是為防止暴利破解，所以需要防止圖片識別。所以驗證碼一般情況下為書寫不正規，且有隨機的背景雜點，或雜線

源代碼（也稱源程序），是指一系列人類可讀的計算機語言指令。

在現代程序語言中，源代碼可以是以書籍或者磁帶的形式出現，但最為常用的格式是文本文件，這種典型格式的目的是為了編譯出計算機程序。計算機源代碼的最終目的是將人類可讀的文本翻譯成為計算機可以執行的二進制指令，這種過程叫做編譯，通過編譯器完成。

作用 ：

源代碼主要功用有如下2種作用：

生成目標代碼，即計算機可以識別的代碼。

對軟體進行說明，即對軟體的編寫進行說明。為數不少的初學者，甚至少數有經驗的程序員都忽視軟體說明的編寫，因為這部分雖然不會在生成的程序中直接顯示，也不參與編譯。但是說明對軟體的學習、分享、維護和軟體復用都有巨大的好處。因此，書寫軟體說明在業界被認為是能創造優秀程序的良好習慣，一些公司也硬性規定必須書寫。

需要指出的是，源代碼的修改不能改變已經生成的目標代碼。如果需要目標代碼做出相應的修改，必須重新編譯。

代碼組合 ：

源代碼作為軟體的特殊部分，可能被包含在一個或多個文件中。一個程序不必用同一種格式的源代碼書寫。例如，一個程序如果有c語言庫的支持，那麼就可以用C語言；而另一部分為了達到比較高的運行效率，則可以用匯編語言編寫。

較為復雜的軟體，一般需要數十種甚至上百種的源代碼的參與。為了降低種復雜度，必須引入一種可以描述各個源代碼之間聯系，並且如何正確編譯的系統。在這樣的背景下，修訂控制系統（RCS）誕生了，並成為研發者對代碼修訂的必備工具之一。

還有另外一種組合：源代碼的編寫和編譯分別在不同的平台上實現，專業術語叫做軟體移植。

版權 ：

如果按照源代碼類型區分軟體，通常被分為兩類：自由軟體和非自由軟體。自由軟體一般是不僅可以免費得到，而且公開源代碼；相對應地，非自由軟體則是不公開源代碼。所有一切通過非正常手段獲得非自由軟體源代碼的行為都將被視為非法。

質量 ：

對於計算機而言，並不存在真正意義上的「好」的源代碼；然而作為一個人，好的書寫習慣將決定源代碼的好壞。源代碼是否具有可讀性，成為好壞的重要標准。軟體文檔則是表明可讀性的關鍵。

源代碼 source code
源程序是指未編譯的文本代碼。

驗證碼主要是為防止暴利破解，所以需要防止圖片識別。所以驗證碼一般情況下為書寫不正規，且有隨機的背景雜點，或雜線

源代碼（也稱源程序），是指一系列人類可讀的計算機語言指令。

在現代程序語言中，源代碼可以是以書籍或者磁帶的形式出現，但最為常用的格式是文本文件，這種典型格式的目的是為了編譯出計算機程序。計算機源代碼的最終目的是將人類可讀的文本翻譯成為計算機可以執行的二進制指令，這種過程叫做編譯，通過編譯器完成。

作用

源代碼主要功用有如下2種作用：

生成目標代碼，即計算機可以識別的代碼。

對軟體進行說明，即對軟體的編寫進行說明。為數不少的初學者，甚至少數有經驗的程序員都忽視軟體說明的編寫，因為這部分雖然不會在生成的程序中直接顯示，也不參與編譯。但是說明對軟體的學習、分享、維護和軟體復用都有巨大的好處。因此，書寫軟體說明在業界被認為是能創造優秀程序的良好習慣，一些公司也硬性規定必須書寫。

需要指出的是，源代碼的修改不能改變已經生成的目標代碼。如果需要目標代碼做出相應的修改，必須重新編譯。

代碼組合

源代碼作為軟體的特殊部分，可能被包含在一個或多個文件中。一個程序不必用同一種格式的源代碼書寫。例如，一個程序如果有C語言庫的支持，那麼就可以用C語言；而另一部分為了達到比較高的運行效率，則可以用匯編語言編寫。

較為復雜的軟體，一般需要數十種甚至上百種的源代碼的參與。為了降低種復雜度，必須引入一種可以描述各個源代碼之間聯系，並且如何正確編譯的系統。在這樣的背景下，修訂控制系統（RCS）誕生了，並成為研發者對代碼修訂的必備工具之一。

還有另外一種組合：源代碼的編寫和編譯分別在不同的平台上實現，專業術語叫做軟體移植。

版權

如果按照源代碼類型區分軟體，通常被分為兩類：自由軟體和非自由軟體。自由軟體一般是不僅可以免費得到，而且公開源代碼；相對應地，非自由軟體則是不公開源代碼。所有一切通過非正常手段獲得非自由軟體源代碼的行為都將被視為非法。

質量

對於計算機而言，並不存在真正意義上的「好」的源代碼；然而作為一個人，好的書寫習慣將決定源代碼的好壞。源代碼是否具有可讀性，成為好壞的重要標准。軟體文檔則是表明可讀性的關鍵。

效率

雖然我們可以通過不同的語言來實現計算機的同一功能，但在執行效率上則存在不同。普遍規律是：越高級的語言，其執行效率越低。這也是為什麼匯編語言生成的文件比用VB語言生成文件普遍要小的原因。

簡單來說:
1.理論上的概念
源代碼是相對目標代碼和可執行代碼而言的。
源代碼就是用匯編語言和高級語言寫出來的地代碼。
目標代碼是指源代碼經過編譯程序產生的能被cpu直接識別二進制代碼。
可執行代碼就是將目標代碼連接後形成的可執行文件，當然也是二進制的。
2.最直觀的概念
在這個網頁上右鍵滑鼠,選擇查看源文件.出來一個記事本,裡面的內容就是此網頁的源代碼.
===================================================
關於兩者的區別聯系:
1.從字面意義上來講,源文件是指一個文件,指源代碼的集合.源代碼則是一組具有特定意義的可以實現特定功能的字元(程序開發代碼).
2."源代碼"在大多數時候等於"源文件".
楓舞在上面說過"2.最直觀的概念 在這個網頁上右鍵滑鼠,選擇查看源文件.出來一個記事本,裡面的內容就是此網頁的源代碼."這句話就體現了他們的關系,此處的源文件是指網頁的源文件,而源代碼就是源文件的內容,所以又可以稱做網頁的源代碼..

效率 ：

雖然我們可以通過不同的語言來實現計算機的同一功能，但在執行效率上則存在不同。普遍規律是：越高級的語言，其執行效率越低。這也是為什麼匯編語言生成的文件比用VB語言生成文件普遍要小的原因。

㈢ c/c++的隨機函數的源代碼怎麼寫

static int next=1;
int rand(void)

{
next = next * 1103515245 + 12345;
return (next/65536) % 32768;
}
return一句的功能只是把得數的絕對值控制在0~32767之間，關鍵是next = next * 1103515245 + 12345一句。next變數是靜態的，變化以後的值是不消失的，下一次還可用，所以每執行一次next = next * 1103515245 + 12345就獲得一個新值，這個新值被return取整除、取余除後控制在0~32767之間就形成了0~32767的隨機數。比如第一次，next=1*1103515245 + 12345=1103527590，經return中的對65536取整、對32768取余後就是16838；若再來一次，next已經是1103527590了，那麼next = next * 1103515245 + 12345就為next = 1103527590 * 1103515245 + 12345=1217759518843121895；但這個數已經溢出了，實際上表示成了-1770082073，經return中取整取余後返回的就是-27009；可以算出來，再下一次是10113……不過，你這個函數並不能產生真正意義上的「隨機」數，因為作為基數的1103515245在每次開始時是不變的，所以只能得出同樣的序列，即每次執行都產生16838、-27009、10113……這樣一組無限多的數。所以實際的C隨機函數rand()的形參並不是void而是一個長整型變數，通常來調用實時時間函數獲取實時時間值來得到，因為時間是每時每刻都在變化的，所以充當"1103515245」角色的數就每調用一次的值都不同。這樣每次執行就都能得到不重復的序列。至於12345，我想隨便取個數都行！僅供參考……

㈣ 數字編碼的由來

一、編碼的由來

計算機只能計算和識別二進制，必須讓計算機識別文字，才能和計算機進行交互，彼此也才能通過計算機通信。

由此，有了ASCII編碼的誕生，它起始於50年代後期，在1967年定案，是最初美國國家標准，供不同計算機在相互通信時用作共同遵守的西文字元編碼標准。

二、ASCII編碼

八位二進制最多可以表示的十進制數字范圍是，0000 0000 ~ 1111 1111 = 0 ~ 255 ，一共256個不同數字。

ASCII編碼就是將常用的英文字元和符號，與256個數字逐一對應起來形成的對應表。

由於計算機是美國人發明的，因此，最早只有127個字母被編碼到計算機里，也就是大小寫英文字母、數字和一些符號，這個編碼表被稱為ASCII編碼；

後來又擴展了128個，稱為擴展ASCII碼。

例如：十進制33對應嘆號！，65對應大寫A，83對應大寫S，97對應小寫a

這樣我們輸入字元，計算機轉換成十進制，再轉換成二進制，就可以通過計算機計算或傳輸。

三、位元組

中英文都需要斷句才能明確含義，二進制也一樣。

一串二進制數字，沒有規定開頭結尾，是無法准確識別轉換成十進制，從而對應編碼找出對應字元的。

ASCII編碼一共256個，0~255，最多八位二進制就能表示完全，所以規定八位二進制為一個單位，不足前面補0；

例如：大寫A對應十進制65，計算機里就是0100 0001，這樣一串二進制就能八位一讀寫，准確識別。

在這里，每一位0或者1所佔的空間單位為bit(比特)，這是計算機中最小的表示單位；

每8個bit組成一個位元組，這是計算機中最小的存儲單位(畢竟你是沒有辦法存儲半個字元的)

㈤ 小數和分數的原碼&補碼怎麼做啊

一、小數部分的原碼和補碼可以表示為兩個復數的分子和分母，然後計算二進制小數系統，根據下面三步的方法就會找出小數源代碼和補碼的百位形式。

37／64＝100101B／2＾6＝0．100101B

－51／128＝110011B／2＾7＝0．0110011B

二、將十進制十進制原始碼和補碼轉換成二進制十進制，然後根據下面三步的方法求出十進制源代碼和補碼形式。一個

0．375＝0．011B

0．5625＝0．1001B

三、二進制十進制對應的原碼和補碼

［37／64］源代碼＝［0．100101B］源代碼＝00100101B

［－51／128］源代碼＝［0．0110011b］源代碼＝10110011B

［0．375］原碼＝［0．011b］原碼＝00110000B

［0．5625］源代碼＝［0．1001B］源代碼＝01001000B

［37／64］補體＝［0．100101B］補體＝00100101B

［－51／128］補體＝［0．0110011b］補體＝11001101B

［0．375］補碼＝［0．011b］補碼＝00110000B

［0．5625］補體＝［0．1001B］補體＝01001000B

(5)數的編碼源碼擴展閱讀：

原碼、逆碼、補碼的使用：

在計算機中對數字編碼有三種方法，對於正數，這三種方法返回的結果是相同的。

＋1＝00000001［原碼］＝00000001［逆碼］＝00000001［補碼］

對於這個負數：

對計算機來說，加、減、乘、除是最基本的運算。有必要使設計盡可能簡單。如果計算機能夠區分符號位，那麼計算機的基本電路設計就會變得更加復雜。

負的正數等於正的負數，2－1等於2＋（－1）所以這個機器只做加法，不做減法。符號位參與運算，只保留加法運算。

（1）原始代碼操作：

十進制操作：1－1＝0。

1－1＝1＋（－1）＝00000001［源代碼］＋10000001［源代碼］＝10000010［源代碼］＝－2。

如果用原代碼來表示，讓符號位也參與計算，對於減法，結果顯然是不正確的，所以計算機不使用原代碼來表示一個數字。

（2）逆碼運算：

為了解決原碼相減的問題，引入了逆碼。

十進制操作：1－1＝0。

1－1＝1＋（－1）＝00000001［源代碼］＋10000001［源代碼］＝00000001［源代碼］＋11111110［源代碼］＝11111111［源代碼］＝10000010［源代碼］＝－0。

使用反減法，結果的真值部分是正確的，但在特定的值「0」。雖然＋0和－0在某種意義上是相同的，但是0加上符號是沒有意義的，00000001［源代碼］和10000001［源代碼］都代表0。

（3）補充操作：

補語的出現解決了零和兩個碼的符號問題。

十進制運算：1－1＝0。

1－1＝1＋（－1）＝00000001［原碼］＋10000001［原碼］＝00000001［補碼］＋11111111［補碼］＝00000000［補碼］＝00000000［原碼］＝0。

這樣，0表示為［00000000］，而之前的－0問題不存在，可以表示為［10000000］－128。

（－1）＋（－127）＝10000001［源代碼］＋11111111［源代碼］＝11111111［補充］＋10000001［補充］＝1000000［補充］＝－128。

－1－127的結果應該是－128。在補碼操作的結果中，10000000［補碼］是－128，但是請注意，由於－0的補碼實際上是用來表示－128的，所以－128沒有原碼和逆碼。（－128的補碼表10000000［補碼］計算出的00000000［原碼］是不正確的）。

㈥ java如何把源代碼轉成二進制數

先說說，匯編幾乎和二進制編碼（機器碼是一一對應的），基本上相當於給每個機器指令起了個名字，增加可讀性。

c語言跟匯編的區別相對比較小，基本就是用匯編中的跳轉（JMP，JNE等），比較（CMP）等命令來表示控制、分支、循環等結構，把函數轉換成標簽，用寄存器來存放參數，用棧來保存局部變數等。

C++比c語言多了許多特性，主要是面向對象特性（比如繼承，多態，模板等），當然翻譯成匯編語言的難度也就更大。

而java和C#並不是直接編譯成匯編語言，而是它們專有的中間語言（和匯編比較像，但是優點是與機器無關，可以跨平台，只要在該平台編寫了對應的解釋器，缺點是速度稍慢）

以上是我的理解，可能並不十分准確，僅供參考。

㈦ 求用Javascript做三個數字的最大公約數和最小公倍數的源代碼

<script language="javascript">function getSpecialNum(num1,num2,num3){
var max=num1;
var min=num1;
var specilanum=new Object();
if(num1<1||num2<1||num3<1){
specilanum.GCM=-1;
specilanum.LCM=-1;
return specilanum;
}
if(num2>num1)max=num2;
if(max<num3)max=num3;
if(num2<num1)min=num2;
if(num3<min)min=num3;

for(var i=min;i>0;i--){
if(num1%i==0&&num2%i==0&&num3%i==0){
specilanum.GCM=i;
break;
}
}

for(var i=max;i<=num1*num2*num3;i++){
if(i%num1==0&&i%num2==0&&i%num3==0){
specilanum.LCM=i;
break;
}
}
return specilanum;
}
</script>
調用該js函數，傳遞三個數字，會返回一個js對象，這個對象的屬性LCM表示最小公倍數，GCM表示最大公約數。
如
var result=getSpecialNum(3,5,15);
alert(result.LCM)//彈出最小公倍數
alert(result.GCM)//彈出最大公約數

㈧ 如何用vb寫全排列的源代碼

什麼意思？請補充！

㈨ 哈夫曼編碼的C語言源代碼

/*文件名:exp7-6.cpp*/
#include <stdio.h>
#include <string.h>
#define N 50 /*葉子結點數*/
#define M 2*N-1 /*樹中結點總數*/
typedef struct
{
char data[5]; /*結點值*/
int weight; /*權重*/
int parent; /*雙親結點*/
int lchild; /*左孩子結點*/
int rchild; /*右孩子結點*/
} HTNode;
typedef struct
{
char cd[N]; /*存放哈夫曼碼*/
int start;
} HCode;
void CreateHT(HTNode ht[],int n)
{
int i,k,lnode,rnode;
int min1,min2;
for (i=0;i<2*n-1;i++) /*所有結點的相關域置初值-1*/
ht[i].parent=ht[i].lchild=ht[i].rchild=-1;
for (i=n;i<2*n-1;i++) /*構造哈夫曼樹*/
{
min1=min2=32767; /*lnode和rnode為最小權重的兩個結點位置*/
lnode=rnode=-1;
for (k=0;k<=i-1;k++)
if (ht[k].parent==-1) /*只在尚未構造二叉樹的結點中查找*/
{
if (ht[k].weight<min1)
{
min2=min1;rnode=lnode;
min1=ht[k].weight;lnode=k;
}
else if (ht[k].weight<min2)
{
min2=ht[k].weight;rnode=k;
}
}
ht[lnode].parent=i;ht[rnode].parent=i;
ht[i].weight=ht[lnode].weight+ht[rnode].weight;
ht[i].lchild=lnode;ht[i].rchild=rnode;
}
}
void CreateHCode(HTNode ht[],HCode hcd[],int n)
{
int i,f,c;
HCode hc;
for (i=0;i<n;i++) /*根據哈夫曼樹求哈夫曼編碼*/
{
hc.start=n;c=i;
f=ht[i].parent;
while (f!=-1) /*循序直到樹根結點*/
{
if (ht[f].lchild==c) /*處理左孩子結點*/
hc.cd[hc.start--]='0';
else /*處理右孩子結點*/
hc.cd[hc.start--]='1';
c=f;f=ht[f].parent;
}
hc.start++; /*start指向哈夫曼編碼最開始字元*/
hcd[i]=hc;
}
}
void DispHCode(HTNode ht[],HCode hcd[],int n)
{
int i,k;
int sum=0,m=0,j;
printf(" 輸出哈夫曼編碼:\n"); /*輸出哈夫曼編碼*/
for (i=0;i<n;i++)
{
j=0;
printf(" %s:\t",ht[i].data);
for (k=hcd[i].start;k<=n;k++)
{
printf("%c",hcd[i].cd[k]);
j++;
}
m+=ht[i].weight;
sum+=ht[i].weight*j;
printf("\n");
}
printf("\n 平均長度=%g\n",1.0*sum/m);
}
void main()
{
int n=15,i;
char *str[]={"The","of","a","to","and","in","that","he","is","at","on","for","His","are","be"};
int fnum[]={1192,677,541,518,462,450,242,195,190,181,174,157,138,124,123};
HTNode ht[M];
HCode hcd[N];
for (i=0;i<n;i++)
{
strcpy(ht[i].data,str[i]);
ht[i].weight=fnum[i];
}
printf("\n");
CreateHT(ht,n);
CreateHCode(ht,hcd,n);
DispHCode(ht,hcd,n);
printf("\n");
}

以前寫的，你照著改下就行的.

㈩ 八數碼C++源代碼

#include<cstdio>
#include<vector>
#include<queue>
#include<ctime>
#define maxhash 73939
#define hash(x) x%maxhash
using namespace std;
typedef unsigned long long ULL;

vector<ULL>list[maxhash];
vector<int>dist[maxhash];

inline int abs(int x)
{
return x<0?-x:x;
}
int hval[10][10];
void fill_hval(int *d)
{
for(int i=0;i<=8;i++)//number i
{
int pos;
for(int k=1;k<=9;k++)//i's position
if(d[k]==i)
{
pos=k;
break;
}
for(int j=1;j<=9;j++)
{
hval[i][j]=abs((j-1)/3-(pos-1)/3)+abs((j-1)%3-(pos-1)%3);
}
}
}
int h(ULL d)
{
int answer=0;
for(int i=9;i>=1;i--)
{
int x=d%10;
d/=10;
answer+=hval[x][i];
}
return answer;
}

int ToARR(ULL s,int *d)
{
int z=0;
for(int i=9;i>=1;i--)
{
d[i]=s%10;
if(d[i]==0) z=i;
s/=10;
}
return z;
}
ULL ToULL(int *d)
{
ULL ans=0;
for(int i=1;i<=9;i++)
ans=ans*10+d[i];
return ans;
}

void insert(ULL x,int di)
{
ULL hx=hash(x);
list[hx].push_back(x);
dist[hx].push_back(di);
}

int find(ULL x)
{
ULL hx=hash(x);
int size=list[hx].size();
for(int i=0;i<size;i++)
if(x==list[hx][i]) return dist[hx][i];
return -1;
}

inline void swap(int &x,int &y)
{
int t=x;
x=y;
y=t;
}
struct state{
int step;
ULL x;
friend bool operator <(state a,state b)
{
return a.step>b.step;
}
};
int cnt=0;
void AStar(int *from,int *to)
{
priority_queue<state>q;
ULL x=ToULL(from);
ULL y=ToULL(to);
fill_hval(to);
q.push((state){h(x),x});
insert(x,0);

int d[10];
while(!q.empty())
{
cnt++;
state s=q.top();
ULL i=s.x; q.pop();
int step=find(i);
int z=ToARR(i,d);
//printf("%lld %d %d\n",i,step,z);
if(i==y) return;

if(z-3>0)
{
swap(d[z],d[z-3]);
ULL j=ToULL(d);
swap(d[z],d[z-3]);
if(find(j)!=-1) goto out1;
q.push((state){step+h(j),j});
insert(j,step+1);
}
out1:
if(z+3<10)
{
swap(d[z],d[z+3]);
ULL j=ToULL(d);
swap(d[z],d[z+3]);
if(find(j)!=-1) goto out2;
q.push((state){step+h(j),j});
insert(j,step+1);
}
out2:
if(z%3!=0)
{
swap(d[z],d[z+1]);
ULL j=ToULL(d);
swap(d[z],d[z+1]);
if(find(j)!=-1) goto out3;
q.push((state){step+h(j),j});
insert(j,step+1);
}
out3:
if(z%3!=1)
{
swap(d[z],d[z-1]);
ULL j=ToULL(d);
swap(d[z],d[z-1]);
if(find(j)!=-1) continue;
q.push((state){step+h(j),j});
insert(j,step+1);
}
}
}
int from[10],to[10];
void work()
{
for(int i=1;i<=9;i++)
scanf("%d",&from[i]);
for(int i=1;i<=9;i++)
scanf("%d",&to[i]);

AStar(from,to);

ULL y=ToULL(to);
printf("%d ",find(y));
#ifdef DEBUG
printf("%d ",clock());
printf("%d ",cnt);
#endif
}
int main()
{
#ifdef DEBUG
freopen("debug.in","r",stdin);
freopen("debug.out","w",stdout);
#endif
work();

return 0;
}
這是基於曼哈頓距離的估價函數的Astar