1. c语言程序代码
char A = "abc";
char B = "bcd" char C = "cde";
char D;
B=C;C=D;D=B;
或者直接运用位运算。
2. 求C语言程序代码
// Microsoft Visual C++ 2010学习版
#include <stdio.h>
double add_thickness(double *thickness_ptr, int *times_ptr)
{
*thickness_ptr *= 2;
if (*times_ptr == 1)
{
return *thickness_ptr;
}
(*times_ptr)--;
return add_thickness(thickness_ptr, times_ptr);
}
int main()
{
double thickness = 0.006; // 0.006cm
int times = 43;
printf("设定纸张厚度：%f cm ", thickness);
printf("算出地月距离：%f cm ", add_thickness(&thickness,×));
printf("算出地月距离：%f km ", thickness / 1000 / 100);
// 地月距离
double distance = (double)386000 * 1000 * 100; // cm
// 操作43次
for (int i = 1; i <= 43; i++)
{
distance /= 2;
}
printf("纸张厚度应为：%f cm ", distance);
// 检验add_thickness()正确性
times = 43;
printf("按上述厚度，地月距离：%f km ", add_thickness(&distance,×) / 1000 / 100);
return 0;
}
---
若纸厚度0.006cm，按题操作43次，纸高度远大于地月距离386000公里！
若纸厚度0.004388cm，按题操作43次，纸高度等于地月距离386000公里。
程序执行结果：
3. c语言计算器程序源代码
栈操作~
输入的弄成字符串。
如：a+(b+c*(d+e))
先检索“（”入栈，b入栈，+入栈，c入栈，*入栈，后面的不是数字那么“（”入栈，+，入栈，e入栈，
“）”入栈，遇到“）”，出栈操作，直到遇到第一个“（”。
得到字符：d+e,通过算法计算出值D,然后把D入栈。那么栈中的字符为：a+(b+c*D
向后判断一步看是不是乘或除，不是继续向后入栈，是就出栈。
得到c*D，通过算法计算值为C，入栈，那么栈中的字符为：a+(b+C，向后判断，无乘或除运算，继续入栈：“）”，遇到“）”，出栈操作，直到遇到第一个“（”，得到字符串：b+c，算法计算值为B，入栈
栈中字符串为：a+B 字符串结束，出栈操作计算出a+B,值。
如果字符串的式子很长的话，就反复的入栈出栈计算。
思路是这样的......
关于COS，SIN类的关键字，也是上面的思路，
(入栈，直到遇到)出栈，先计算出括号里的，然后后退一步判断前面的是乘除或者关键字，
如：sin(0.1+0.2)
操作得出sin0.3然后判断前面的是不是关键字，是那句计算sin0.3。
但是遇到关键字的时候不是一个一个字符在一起的，你可以入栈的时候判断是不是字母，是字母，那么入栈直到不是字母为止，出栈判断关键字也是一样......
不明白的继续问~
4. 求简单C语言程序代码！
输入2个正整数m和n，求其最大公约数和最小公倍数
#include
#include
int main()
int m,n,p,q,s,r;
printf("请输入两个正整数；m,n ");
scanf("%d,%d",&m,&n);
#include<stdio.h>
main()
int a,b,t=0;
scanf("%d %d",&a,&b);
if (a<b)
printf("%d %d %d %d %d",(a+b),(a-b),(a/b),(a*b),(a%b));
}
主要特点
C语言是一种结构化语言，它有着清晰的层次，可按照模块的方式对程序进行编写，十分有利于程序的调试，且c语言的处理和表现能力都非常的强大，依靠非常全面的运算符和多样的数据类型，可以轻易完成各种数据结构的构建，通过指针类型更可对内存直接寻址以及对硬件进行直接操作，因此既能够用于开发系统程序，也可用于开发应用软件。
以上内容参考：网络-c语言
5. 求完整的计算机的c语言代码，坐等
你的编译器用的什么，如果是gcc的话就建一个主文件，里面放main函数，并包含其他的头文件，然后子目录里面分别放置各个运算的程序文件，在主函数里面调用这些文件（注意每一个子目录里面的c文件都要建立一个h文件，保存函数的前置声明，主函数里面包含子目录里的头文件就可以了）。如果windows下的vc就更简单了，在目录下建立文件夹结构（主文件夹下放界面，子目录下放运算的源码，然后建一个工程把他们拖进去就OK）
6. 求c语言的一个程序编码
*
================================================
功能：选择排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环
到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。算法复杂度O(n2)--[n的平方]
=====================================================
*/
void
select_sort(int
*x,
int
n)
{
int
i,
j,
min,
t;
for
(i=0;
i<n-1;
i++)
/*要选择的次数：0~n-2共n-1次*/
{
min
=
i;
/*假设当前下标为i的数最小，比较后再调整*/
for
(j=i+1;
j<n;
j++)/*循环找出最小的数的下标是哪个*/
{
if
(*(x+j)
<
*(x+min))
{
min
=
j;
/*如果后面的数比前面的小，则记下它的下标*/
}
}
if
(min
!=
i)
/*如果min在循环中改变了，就需要交换数据*/
{
t
=
*(x+i);
*(x+i)
=
*(x+min);
*(x+min)
=
t;
}
}
}
/*
================================================
功能：直接插入排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在要排序的一组数中，假设前面(n-1)
[n>=2]
个数已经是排
好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
也是排好顺序的。如此反复循环，直到全部排好顺序。
直接插入排序是稳定的。算法时间复杂度O(n2)--[n的平方]
=====================================================
*/
void
insert_sort(int
*x,
int
n)
{
int
i,
j,
t;
for
(i=1;
i<n;
i++)
/*要选择的次数：1~n-1共n-1次*/
{
/*
暂存下标为i的数。注意：下标从1开始，原因就是开始时
第一个数即下标为0的数，前面没有任何数，单单一个，认为
它是排好顺序的。
*/
t=*(x+i);
for
(j=i-1;
j>=0
&&
t<*(x+j);
j--)
/*注意：j=i-1，j--，这里就是下标为i的数，在它前面有序列中找插入位置。*/
{
*(x+j+1)
=
*(x+j);
/*如果满足条件就往后挪。最坏的情况就是t比下标为0的数都小，它要放在最前面，j==-1，退出循环*/
}
*(x+j+1)
=
t;
/*找到下标为i的数的放置位置*/
}
}
/*
================================================
功能：冒泡排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在要排序的一组数中，对当前还未排好序的范围内的全部数，自上
而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较
小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要
求相反时，就将它们互换。
下面是一种改进的冒泡算法，它记录了每一遍扫描后最后下沉数的
位置k，这样可以减少外层循环扫描的次数。
冒泡排序是稳定的。算法时间复杂度O(n2)--[n的平方]
=====================================================
*/
void
bubble_sort(int
*x,
int
n)
{
int
j,
k,
h,
t;
for
(h=n-1;
h>0;
h=k)
/*循环到没有比较范围*/
{
for
(j=0,
k=0;
j<h;
j++)
/*每次预置k=0，循环扫描后更新k*/
{
if
(*(x+j)
>
*(x+j+1))
/*大的放在后面，小的放到前面*/
{
t
=
*(x+j);
*(x+j)
=
*(x+j+1);
*(x+j+1)
=
t;
/*完成交换*/
k
=
j;
/*保存最后下沉的位置。这样k后面的都是排序排好了的。*/
}
}
}
}
/*
================================================
功能：希尔排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，
并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为
增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除
多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现
了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中
记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量
对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成
一组，排序完成。
下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，
以后每次减半，直到增量为1。
希尔排序是不稳定的。
=====================================================
*/
void
shell_sort(int
*x,
int
n)
{
int
h,
j,
k,
t;
for
(h=n/2;
h>0;
h=h/2)
/*控制增量*/
{
for
(j=h;
j<n;
j++)
/*这个实际上就是上面的直接插入排序*/
{
t
=
*(x+j);
for
(k=j-h;
(k>=0
&&
t<*(x+k));
k-=h)
{
*(x+k+h)
=
*(x+k);
}
*(x+k+h)
=
t;
}
}
}
/*
================================================
功能：快速排序
输入：数组名称（也就是数组首地址）、数组中起止元素的下标
================================================
*/
/*
====================================================
算法思想简单描述：
快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟
扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次
扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只
减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）
的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理
它左右两边的数，直到基准点的左右只有一个元素为止。它是由
C.A.R.Hoare于1962年提出的。
显然快速排序可以用递归实现，当然也可以用栈化解递归实现。下面的
函数是用递归实现的，有兴趣的朋友可以改成非递归的。
快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n2)
=====================================================
*/
void
quick_sort(int
*x,
int
low,
int
high)
{
int
i,
j,
t;
if
(low
<
high)
/*要排序的元素起止下标，保证小的放在左边，大的放在右边。这里以下标为low的元素为基准点*/
{
i
=
low;
j
=
high;
t
=
*(x+low);
/*暂存基准点的数*/
while
(i<j)
/*循环扫描*/
{
while
(i<j
&&
*(x+j)>t)
/*在右边的只要比基准点大仍放在右边*/
{
j--;
/*前移一个位置*/
}
if
(i<j)
{
*(x+i)
=
*(x+j);
/*上面的循环退出：即出现比基准点小的数，替换基准点的数*/
i++;
/*后移一个位置，并以此为基准点*/
}
while
(i<j
&&
*(x+i)<=t)
/*在左边的只要小于等于基准点仍放在左边*/
{
i++;
/*后移一个位置*/
}
if
(i<j)
{
*(x+j)
=
*(x+i);
/*上面的循环退出：即出现比基准点大的数，放到右边*/
j--;
/*前移一个位置*/
}
}
*(x+i)
=
t;
/*一遍扫描完后，放到适当位置*/
quick_sort(x,low,i-1);
/*对基准点左边的数再执行快速排序*/
quick_sort(x,i+1,high);
/*对基准点右边的数再执行快速排序*/
}
}
/*
================================================
功能：堆排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当
满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)
时称之为堆。在这里只讨论满足前者条件的堆。
由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项。完全二叉树可以
很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储顺序，
使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点
交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点
的堆，并对它们作交换，最后得到有n个节点的有序序列。
从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素
交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数
实现排序的函数。
堆排序是不稳定的。算法时间复杂度O(nlog2n)。
*/
/*
功能：渗透建堆
输入：数组名称（也就是数组首地址）、参与建堆元素的个数、从第几个元素开始
*/
void
sift(int
*x,
int
n,
int
s)
{
int
t,
k,
j;
t
=
*(x+s);
/*暂存开始元素*/
k
=
s;
/*开始元素下标*/
j
=
2*k
+
1;
/*右子树元素下标*/
while
(j<n)
{
if
(j<n-1
&&
*(x+j)
<
*(x+j+1))/*判断是否满足堆的条件：满足就继续下一轮比较，否则调整。*/
{
j++;
}
if
(t<*(x+j))
/*调整*/
{
*(x+k)
=
*(x+j);
k
=
j;
/*调整后，开始元素也随之调整*/
j
=
2*k
+
1;
}
else
/*没有需要调整了，已经是个堆了，退出循环。*/
{
break;
}
}
*(x+k)
=
t;
/*开始元素放到它正确位置*/
}
/*
功能：堆排序
输入：数组名称（也就是数组首地址）、数组中元素个数
*/
void
heap_sort(int
*x,
int
n)
{
int
i,
k,
t;
int
*p;
for
(i=n/2-1;
i>=0;
i--)
{
sift(x,n,i);
/*初始建堆*/
}
for
(k=n-1;
k>=1;
k--)
{
t
=
*(x+0);
/*堆顶放到最后*/
*(x+0)
=
*(x+k);
*(x+k)
=
t;
sift(x,k,0);
/*剩下的数再建堆*/
}
}
void
main()
{
#define
MAX
4
int
*p,
i,
a[MAX];
/*录入测试数据*/
p
=
a;
printf("Input
%d
number
for
sorting
:\n",MAX);
for
(i=0;
i<MAX;
i++)
{
scanf("%d",p++);
}
printf("\n");
/*测试选择排序*/
p
=
a;
select_sort(p,MAX);
/**/
/*测试直接插入排序*/
/*
p
=
a;
insert_sort(p,MAX);
*/
/*测试冒泡排序*/
/*
p
=
a;
insert_sort(p,MAX);
*/
/*测试快速排序*/
/*
p
=
a;
quick_sort(p,0,MAX-1);
*/
/*测试堆排序*/
/*
p
=
a;
heap_sort(p,MAX);
*/
for
(p=a,
i=0;
i<MAX;
i++)
{
printf("%d
",*p++);
}
printf("\n");
system("pause");
}
7. 求一道C语言中关于计算器的程序代码
这个已经有计算功能了，但记事本还没有，给你急用。因为C没有专门的字符串类型：有事再联系405719864// C语言计算器.cpp : Defines the entry point for the console application.
//
/*注意！本程序用C编写，在VC++6.0中运行通过，如果要有记事本功能，可能要用C++写，因为C没有专门的字符串类型*/
#include "stdafx.h"
#include <stdio.h>
#include <ctype.h>char c,operate;//c用于保存计算符号，operate表示当前输入
double n,m;//记录输入的数字
bool check_c,check_n,check_m;//各个输入的开关，当输入发生改变时，可以有根据地操作double count(double n,char ch,double m)//根据不同的计算符号计算结果
{
if(ch == '+') return n+m;
if(ch == '-') return n-m;
if(ch == '*') return n*m;
if(ch == '/')
{
if(m != 0) return n/m;
else printf("0不能作除数!\n");
}
return n;
}int main()
{
n=m=0;
check_c=check_n=check_m=false;
printf("0\n"); printf("若要结束，请输入任意字母!\n");
while(scanf("%c",&operate) != EOF)//表示输入以EOF结束
{
if(operate == 0x0d || operate==' ' || operate=='\n') continue;//表示排除无效字符
if(operate == '#')
{
n=m=0;
check_c=check_n=check_m=false;
printf("0\n");
}
else
{
if(isdigit(operate))
{
if(!check_n) { n=n*10+operate-'0'; printf("%.0lf\n",n); }
else { m=m*10+operate-'0'; check_m=true; check_c=true; printf("%.0lf\n",m); }
}
else
{
if(operate=='+' || operate=='-' || operate=='*' || operate=='/' || operate=='=')//出现运算符号
{
if(operate != '=')//非“=”，则第一个数字输入结束，并记录当前计算符号
{
check_n=true;
if(!check_c) c=operate;
}
if(check_n && check_m)//两个数字都有输入，就进行计算
{
n=count(n,c,m);
printf("%.0lf\n",n);
if(operate != '=')//出现连续等号，连续计算，非等号，则记录并从新输入第二个数字
{
c=operate;
check_c=false;
m=0;
check_m=false;
}
}
else printf("%.0lf\n",n);
}
else
{
printf("输入数据无效!\n");//表示以任意字母字符结束
break;
}
}
}
}
return 0;
}
8. c语言程序代码
例如：输入某年某月某日，判断这一天是这一年的第几天。
1.程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊
情况，闰年且输入月份大于3时需考虑多加一天。
2.程序源代码：
复制代码 代码如下:
main()
{
int day,month,year,sum,leap;
printf("\nplease input year,month,day\n");
scanf("%d,%d,%d",&year,&month,&day);
switch(month)/*先计算某月以前月份的总天数*/
{
case 1:sum=0;break;
case 2:sum=31;break;
case 3:sum=59;break;
case 4:sum=90;break;
case 5:sum=120;break;
case 6:sum=151;break;
case 7:sum=181;break;
case 8:sum=212;break;
case 9:sum=243;break;
case 10:sum=273;break;
case 11:sum=304;break;
case 12:sum=334;break;
defaultrintf("data error");break;
}
sum=sum+day; /*再加上某天的天数*/
if(year%400==0||(year%4==0&&year%100!=0))/*判断是不是闰年*/
leap=1;
else
leap=0;
if(leap==1&&month>2)/*如果是闰年且月份大于2,总天数应该加一天*/
sum++;
printf("It is the %dth day.",sum); }
9. 急求一个C语言程序代码！！！
这也是以前我们在学校C语言课程实训做的题目，当时在老师指导下一步步花了几天工夫才弄好的呢。
你所建立的Input、query、sort、insert、delete
函数都是你所学习的各个知识点，题目灵活性还好，自己用自己的想法做，有不懂点的就问。完善好它自己对C语言的熟练使用有很大帮助。直接给你程序的只能帮你敷衍过老师。自己努力设计吧！
10. 用c语言编写的代码程序
c语言的源程序语法结构如下：
#include<stdio.h>//预处理语句
/* 自定义函数1*/
/* 自定义函数2*/
int main()
{
//main()主函数执行调用以上定义的函数的顺序
return 0;//执行完毕 退出
}
示例如下：
#include <stdio.h>
int main()
{
printf("welcome to c language!!!\n");
return 0;
}