f.i.r2函数c语言 c语言的fwrite函数

怎么用c语言计算圆周长和面积

代码如下：

#includelt;stdio.hgt;

int main(){

int radius;

float area,perimeter;

radius=6;

perimeter=2*3.14*radius;

printf("圆的周长=%f英寸\n",perimeter);

area=3.14*radius*radius;

printf("圆的面积=%f平方英寸\n",area);

return(0);

}

2、c语言计算矩形的周长和面积

#includelt;stdio.hgt;

/*长方形的高和宽，单位为米*/

int width;

int height;

int area;

int perimeter;

int main(){

height=7;

width=5;

perimeter=2*(height+width);

printf("矩形的周长=%d米\n",perimeter);

area=height*width;

printf("矩形的面积=%d平方米\n",area);

return(0);

}

扩展资料：

使用C语言计算圆周长和面积的优势:

1、简洁紧凑、灵活方便

C语言一共只有32个关键字，9种控制语句，程序书写形式自由，区分大小写。把高级语言的基本结构和语句与低级语言的实用性结合起来。C语言可以像汇编语言一样对位、字节和地址进行操作，而这三者是计算机最基本的工作单元。

2、运算符丰富

C语言的运算符包含的范围很广泛，共有34种运算符。C语言把括号、赋值、强制类型转换等都作为运算符处理。从而使C语言的运算类型极其丰富，表达式类型多样化。灵活使用各种运算符可以实现在其它高级语言中难以实现的运算。

相关问答

Q1: 关于C语言函数调用的问题。

p=f(i,++i)；的意思就是将函数f(i,++i)；返回的值传给p，也就是c；

“在下面的if（ab）c=1中，是怎么比较a，b的大小的？“这个问题问的让人难解，不就是普通的比较吗，a就是i，b就是i++

看下面的程序结果会不同，细细研究：

（哦，对了，你的程序有问题！！！）

1：#includestdio.h

int f(int a,int b)

{

int c;

if(ab)c=1;

else if(a==b) c=0;

else c=-1;

return(c);

}

main()

{

int i=2,p;

p=f(i,i++);

printf("%d\n",p);

}

结果为0；

2：

#includestdio.h

int f(int a,int b)

{

int c;

if(ab)c=1;

else if(a==b) c=0;

else c=-1;

return(c);

}

main()

{

int i=2,p;

p=f(i,++i);

printf("%d\n",p);

}

结果为0；

3：

#includestdio.h

int f(int a,int b)

{

int c;

if(ab)c=1;

else if(a==b) c=0;

else c=-1;

return(c);

}

main()

{

int i=2,p;

p=f(i,i+1);

printf("%d\n",p);

}

结果为-1

主要注意i++，++i，i+1的用法！

Q2: C语言 行列转换函数

转换干啥，直接写个读取函数就好了啊、大概就下面这意思。

int Read(int r, int c)

{

return arr[r][c];

}

int ReadAsTransposition(int r, int c)

{

return arr[c][r];

}

Q3: C语言纸牌速算24原理

/* 计算24是流行的扑克游戏。其方法是任意取出4张牌，A J Q K 王牌 算 1，其它牌按点数计算，花色不计。

目标是通过加、减、乘、除和括号最终算出24。设计一个程序，输入4个数字（1~10），则列出所有可能计算

结果为24的方案。要求：

方案不能重复（加法乘法交换律等算不同方案）。

计算中局部可以为分数，结果为整数即可（如 3 3 7 7 算法： (3 + 3/7)*7）

如果没有找到方案输出：无解。

在某些可不用括号的地方不用括号(即去掉括号后等式的解不变)

待完善：

1)除数不能为零没考虑(不用考虑可正常运行)

*/

#includestdio.h

#includemalloc.h

int zuheshu(float s[],int n); // 组合数的函数

float zuhe[4]={0}; // 暂时存放组合

int sum=0; // 用于计数

// 动态分配n个float变量的数组

float * fsz(int n)

{

return (float *)malloc(sizeof(float)*n);

}

int zuhefu(); //符号组合

int yunsuan(float s[],char p[],int k0[],int k1[]); // 算式组合

float qiujie(float suanshi[],int n); // 算式求解

int hefa(float suanshi[],int r); // 算式正确性检查

float jianjie(float suanshi[],int r); // 算式简洁性检查

int fuhe=0; // 计数符合算式数

void main()

{

// 输入四个数

//float shu[4]={0};

//printf("请输入4个数字(1~10):\n");

//scanf("%f",shu[0]);

//scanf("%f",shu[1]);

//scanf("%f",shu[2]);

//scanf("%f",shu[3]);

//float shu[4]={1,2,3,4};

//printf("输入的4个数字依此是: %.0f %.0f %.0f %.0f\n",shu[0],shu[1],shu[2],shu[3]);

//float s[4]={3,3,3,3},shu[4]={0};

//printf("请输入四个数(0-9):\n");

for(int i=0;i4;i++)

{

scanf("%f",s[i]);

for(int j=i;j0;j--)

{

if(s[j]=s[j-1])

{

float s0=s[j-1];

s[j-1]=s[j];

s[j]=s0;

}

}

}

printf("四个数是:");

for(i=0;i4;i++)

{

printf("%.0f ",s[i]);

}

printf("\n");

zuheshu(s,4);

printf("有%d个算式符合\n",fuhe);

}

// 组合数，并调用yunsuan

int zuheshu(float s[],int n)

{

if(n==1)

{

zuhe[4-n]=s[0];

zuhefu();

return 1;

}

for(int i=0;in;i++)

{

if(i==0)

{

// 直接填入s[0],数组和候选数中去除该数,递归

zuhe[4-n]=s[i];

float *p=fsz(n-1);

int o=0;

for(int k=0;kn;k++)

{

if(k!=i)

p[o++]=s[k];

}

zuheshu(p,n-1);

free(p);

}

else if(s[i]!=s[i-1])

{

// 直接填入s[0],数组和候选数中去除该数,递归

zuhe[4-n]=s[i];

float *p=fsz(n-1);

int o=0;

for(int k=0;kn;k++)

{

if(k!=i)

p[o++]=s[k];

}

zuheshu(p,n-1);

free(p);

}

}

}

// 组合运算符号,并调用yunsuan

int zuhefu()

{

// 对操作符'+','—','*','/'组合

char opter[4]={'+','-','*','/'};

for(int h=0;h4;h++) // 第一个操作符

{

for(int i=0;i4;i++) // 第二个操作符

{

for(int j=0;j4;j++) // 第三个操作符

{

char op[3]; // 放置操作符

op[0]=opter[h];

op[1]=opter[i];

op[2]=opter[j];

// 对括号组合

// 0 1 1 1 2 2 2 3

int khzh[8][3]={{0,0,0},{0,0,1},{0,1,0},{1,0,0},{0,1,1},{1,0,1},{1,1,0},{1,1,1}}; // 正或反括号

for(int k=0;k=3;k++)

{

switch(k)

{

case 0: // 有0个括号

{

yunsuan(zuhe,op,khzh[0],khzh[0]);

}

break;

case 1: // 有1个括号

{

for(int m=1;m=3;m++) // 正括号

{

for(int n=1;n=3;n++) //反括号

{//代码将算式组合，并判断正确性;其中(括号)010和100为错误组合,010和010无错误组合,001和100为错误组合,

//同时100和001可视做无括号应过滤（即正括号后接操作数,操作符,不能是操作数,反括号）

//正确组合有六组

if((m==2n==3)||(m==1n==2)||(m==3n==1)||(m==1n==3))

continue;

yunsuan(zuhe,op,khzh[m],khzh[n]);

}

}

}

break;

case 2: // 有2个括号

{

//代码将算式组合，并判断正确性;其中(括号)*1*和1**为错误组合，**1和*1*为错误组合，

//应过滤（即正括号后接操作数，操作符，不能是操作数，反括号）同时出现1**和**1也应视为0**和**0

//正确括法只有一种即101和101

yunsuan(zuhe,op,khzh[5],khzh[5]);

}

break;

case 3: //有3个括号,不可能

//利用khzu[7]代码将算式组合，并判断正确性(不正确)

break;

}

}

}

}

}

return 1;

}

// 对s[]中的四个数按照p[]和k[]中的运算符进行组合并调用qiujie()函数运算判断结果是否为24

int yunsuan(float s[],char p[],int k0[],int k1[])

{

float suanshi0[13]={'0'}; // 合成等式

int r=0; // 等式的长度

// 组合等式

for(int q=0;q13;q++)

{

switch(q)

{

case 0:

{

if(k0[0]==1)

suanshi0[r++]='(';

}

break;

case 1:

{

suanshi0[r++]=s[0];

}

break;

case 2:

{

suanshi0[r++]=p[0];

}

break;

case 3:

{

if(k0[1]==1)

suanshi0[r++]='(';

}

break;

case 4:

{

suanshi0[r++]=s[1];

}

break;

case 5:

{

if(k1[0]==1)

suanshi0[r++]=')';

}

break;

case 6:

{

suanshi0[r++]=p[1];

}

break;

case 7:

{

if(k0[2]==1)

suanshi0[r++]='(';

}

break;

case 8:

{

suanshi0[r++]=s[2];

}

break;

case 9:

{

if(k1[1]==1)

suanshi0[r++]=')';

}

break;

case 10:

{

suanshi0[r++]=p[2];

}

break;

case 11:

{

suanshi0[r++]=s[3];

}

break;

case 12:

{

if(k1[2]==1)

suanshi0[r++]=')';

}

break;

}

}

float * suanshi=fsz(r); // 动态空间申请

for(int i=0;ir;i++)

{

suanshi[i]=suanshi0[i];

}

// 组合算式的正确性检查

float f=hefa(suanshi,r);

if(f==0)

{

return 0;

}

// 组合算式的简洁性检查

f=jianjie(suanshi,r);

if(f==0)

{

return 0;

}

// 调用函数求解结果为24则输出等式

float sum0=qiujie(suanshi,r);

if(sum0==24)

{

fuhe++;

for(int t=0;tr;t++)

{

if(suanshi[t]10)

printf("%c",char(suanshi[t]));

else

printf("%0.0f",suanshi[t]);

}

printf("=%0.0f\n",sum0);

}

free(suanshi);

return 1;

}

// 算式正确性检查

int hefa(float suanshi[],int r)

{

float * p=suanshi[0]; // 为当前指针

float * q=suanshi[1]; // 为下一指针

int flag=1; // 等式正确标记

while(1)

{

if(*p==40) // 判断是否为'('

{

if((*q=0)(*q=9))

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

if((*p=0)(*p=9)) // 判断是否为数

{

if((p-suanshi)=(r-1))

{

break;

}

if(*q==')'||((*q41)(*q48))) // '+','-','*','/'在次范围内

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

if(*p==41) // 判断是否为')'

{

if((p-suanshi)=(r-1))

{

break;

}

if((*q41)(*q48)) // '+','-','*','/'在次范围内

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

if((*p41)(*p48)) // // 判断是否为符号

{

if(*q==40||((*q=0)(*q=9)))

{

p++;

q++;

}

else

{

flag=0;

break;

}

}

}

return flag;

}

// 算式简洁性检查

float jianjie(float suanshi[],int r)

{

float re=1; // 是否括号不影响算式求解

float *p=re,*q=re;

int k=0; // 括号数目

int k1=0; // 运算符的个数

float r0=0; // '('前的运算符优先级

float r2=1; // 算式运算符优先级

float r1=0; // ')'后的运算符优先级

int r3=0;

for(int i=0;ir;i++)

{

if(suanshi[i]=='(')

{

k++;

if(*p!='('||k==1)

{

p=suanshi[i];

if(i!=0)

{

if(*(p-1)=='+'||*(p-1)=='-')

{

r0=1;

}

else if(*(p-1)=='*'||*(p-1)=='/')

{

r0=2;

}

if(*(p-1)=='-')

{

r0+=100;

}

else if(*(p-1)=='/')

{

r0+=1000;

}

}

}

}

else if(suanshi[i]==')')

{

if(k--==1)

{

q=suanshi[i];

if(i!=r-1)

{

if(*(q+1)=='+'||*(q+1)=='-')

{

r1=1;

}

else if(*(q+1)=='*'||*(q+1)=='/')

{

r1=2;

}

}

//递归

re=jianjie(p+1,q-p-1); // 返回括号内的优先级

if(int(r0/100)=1) // 括号'('外出现减号或除号

{

if((int(r0/100))==1(int(re/100))==1) // 括号'('外出现减号,括号内出现+或-

{

continue;

}

else if((int(r0/1000))==1(int(re/1000))==1) // 括号'('外出现除号,括号内出现*或/

{

continue;

}

}

if(int(re/100)==1)

re-=100;

if(int(re/1000)==1)

re-=1000;

if(int(r0/100)==1)

r0-=100;

else if(int(r0/1000)==1)

r0-=1000;

if(re==0)

return 0;

if(re=r0re=r1)

return 0;

}

}

else if(k==0)

{

if(suanshi[i]=='+'||suanshi[i]=='-')

{

r2=((r2*k1)+1)/(++k1);

r3=r3/10+1;

}

else if(suanshi[i]=='*'||suanshi[i]=='/')

{

r2=(r2*k1+2)/(++k1);

r3=r3%10+10;

}

}

}

if(r3%10==1)

r2+=100;

if(r3/10==1)

r2+=1000;

return r2;

}

// 调用函数求解结果为24则输出等式

float qiujie(float suanshi[],int n)

{

if(n==3)

{

float a=0;

switch(char(suanshi[1]))

{

case '+':

return (suanshi[0]+suanshi[2]);

case '-':

return (suanshi[0]-suanshi[2]);

case '*':

return (suanshi[0]*suanshi[2]);

case '/':

return (suanshi[0]/suanshi[2]);

}

}

// 过滤掉括号项

float pq='0';

float * p=pq; // 指向算式的第一个正括号

float * q=pq; // 指向算式的与第一个正括号配对的反括号

int k=0;

float suanshi1[7]={'0'}; // 除去括号后的算式

int s=0; // 用来记录suanshi1数组的长度

float sum=0; // 算式的值

for(int m=0;mn;m++)

{

if(suanshi[m]=='(')

{

k++;

if((*p)!='(')

{

p=suanshi[m];

}

continue;

}

if(suanshi[m]==')')

{

if(k--==1)

{

q=suanshi[m];

suanshi1[s++]=qiujie(p+1,q-p-1);

p=pq;

q=pq;

}

continue;

}

if(k==0)

{

suanshi1[s++]=suanshi[m];

continue;

}

}

if(s==3)

{

sum=qiujie(suanshi1,s);

}

else

{

p=suanshi1[0]; // 指向第一个数

q=suanshi1[2]; // 只想第二个数

for(m=0;m(s-1)/2;m++)

{

switch(char(suanshi1[2*m+1]))

{

case '+':

if((s-1)/2!=1(suanshi1[2*(m+1)+1]=='*'||suanshi1[2*(m+1)+1]=='/'))

{

*q=qiujie(p+2,3);

int ws=suanshi1[s-1]-suanshi1[2*(m+1)];

for(int w=1;w=ws;w++)

{

if(((q+w+2)-(q+ws))0)

{

*(q+w)=-1;

}

else

{

*(q+w)=*(q+w+2);

}

}

s=s-2;

m--;

}

else

{

if(m==0)

{

sum+=*p+*q;

}

else

{

sum+=*q;

}

p=p+2;

q=q+2;

}

break;

case '-':

if((s-1)/2!=1(suanshi1[2*(m+1)+1]=='*'||suanshi1[2*(m+1)+1]=='/'))

{

*q=qiujie(p+2,3);

int ws=suanshi1[s-1]-suanshi1[2*(m+1)];

for(int w=1;w=ws;w++)

{

if(((q+w+2)-(q+ws))0)

{

*(q+w)=-1;

}

else

{

*(q+w)=*(q+w+2);

}

}

s=s-2;

m=-1;

}

else

{

if(m==0)

sum+=*p-*q;

else

sum-=*q;

p=p+2;

q=q+2;

}

break;

case '*':

if(m==0)

sum+=(*p)*(*q);

else

sum*=*q;

p=p+2;

q=q+2;

break;

case '/':

if(m==0)

{

sum+=(*p)/(*q);

}

else

{

sum/=*q;

}

p=p+2;

q=q+2;

break;

}

}

}

return sum;

}

关于f.i.r2函数c语言和c语言的fwrite函数的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。