数的编码源码

㈠ 你好，请问你有没有浮点数编码实例的遗传算法的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