绝对零基础的C语言科班作业②数据（数据类型和常量变量）_c语言中值不变的数据对象称为

这部分理论知识很多，常见代码：①字符型常量中的英文大小写字母转换。②变量中的鸡兔同笼。初学C语言数据类型一般只会用到最常用的int（定义一个整数），double（定义一个双精度浮点型小数），char（定义一个字符）。其它的以后会讲。

一.数据类型

1.程序=算法+数据结构

通过完成第一部分的任务，我们知道：程序处理的对象是数据，程序是指令的有序集合。你知道吗，图灵奖获得者瑞士计算机科学家尼克劳斯·威茨（Niklaus Wirth）有一句计算机领域人尽皆知的名言“算法+数据结构=程序”，他在1976年曾出版一本同名著作《Algorithms + Data Structures=Programs》。

2.数据类型

在C语言中，任何一个数据都必须属于一种数据类型。数据与操作构成程序的两个基本要素，数据类型可以看作是数据的“抽象”。

C语言为我们提供了丰富的数据类型，如图2-2所示。

C语言的数据类型总体上可以分为基本类型、构造类型、指针类型和空类型四类。在这一章中，我们只讨论基本类型中的整型、实型和字符型。其它的数据类型会在以后的章节中作详细介绍。

可以看出，每种数据类型都用一个固定单词(关键字或标识符)来表示。例如在前面我们已经知道关键字int用来表示整型。

每种类型的数据都占据固定大小的存储空间，所以它们都有自己的取值范围。各种数据类型的名称、占据的存储空间及取值范围如表2-1所示。

表2-1 C数据类型、大小与取值范围

①（代码）认识数据类型

任务描述:

程序=数据结构+算法。数据是程序的处理对象，C语言的数据类型主要包括：整数型：char、short [int]、int、long [int]、long long [int]；浮点型：float、 double、long double；每种数据类型的数据在内存中所占的空间数量是不同的，通过sizeof()运算符可以计算，例如：sizeof(int)的值为4，表示int型数据在内存中占据4个字节。请按顺序输出以上8种数据类型在内存中所占据的字节数。两个数据之间分隔1个空格。

#include<stdio.h>
int main()
{
    printf("%d %d %d %d %d %d %d %d",
            sizeof(char),
            sizeof(short int),
            sizeof(int),
            sizeof(long int),
            sizeof(long long int),
            sizeof(float),
            sizeof(double),
            sizeof(long double)
          );
    return 0;          //sizeof是C语言的库函数，计算的是括号里类型的大小。
}                      //需要注意这些英文字母都要记下来。

输出样例:

1 2 4 8 8 4 8 16

相关知识-数据存储

1.所有数据都以二进制形式存储

计算机的硬件是由逻辑电路组成的，逻辑电路通常只能识别接通与断开(或者高电平和低电平)两个状态，这两种状态可以用数字0和1表示。因为只能识别0和1两个数据，所以在计算机内部采用二进制形式来表示一切数据，0和1被称为二进制的两个位(bit)。

2.存储单位

计算机的存储空间以字节(Byte)为基本单位，1个字节是由8个二进制位(bit)构成。存储空间的单位从小到大有：字节(B)、千字节(KB)、兆(MB)、吉(GB)、太(TB)、拍(PB)、艾(EB)、泽(ZB)、尧(YB)等。1B（Byte字节）=8bit；1KB (Kilo byte 千字节)=1024B，其中1024=210；1MB (Mega byte 兆字节)=1024KB；1GB (Giga byte 吉字节)=1024MB；1TB (Tera byte 太字节)=1024GB；1PB（Peta byte 拍字节）=1024TB；1EB（Exa byte 艾字节）=1024PB；1ZB (Zetta byte 泽字节)= 1024EB；1YB (Yotta byte 尧字节)= 1024ZB。小白弟弟，请你在PTA平台上正确提交以上代码，显示答案正确，说明在PTA平台当中long int类型数据的空间大小为8个字节。然后，请小白弟弟在Dev-C++中执行以上代码，你会看到如下结果：

执行结果显示，long int类型在你的计算机上占据存储空间4个字节。这是为什么呢？原来，在不同的操作系统和编译系统中，某个数据类型所占据的内存空间大小有可能是不同的，这取决于系统的不同设计，也就是说上面的代码在不同的计算机中、不同的操作系统下、不同的编译环境下，执行结果可能是不同的。

3.格式说明符%d

printf函数第一个参数中的“%d”，代表的是1个十进制整数的格式说明符（占位符），实际输出的值为后面对应的表达式的值。

4.C程序格式宽松

C语言程序的书写规范很宽松，一个语句可以写在多行，一行也可以写多个语句。

②（代码）无符号整型

任务描述:

C语言每个整数类型都对应一种无符号类型，例如： unsigned char、unsigned short [int]、unsigned int、unsigned long [int]、unsigned long long [int]。通过sizeof()运算符可以计算每种类型的数据在内存中所占的字节数量，例如：sizeof(unsigned int)的值为4，表示unsigned int型数据在内存中占据4个字节。请按顺序输出以上5种数据类型在内存中所占据的字节数。两个数据之间分隔1个空格。

#include<stdio.h>
int main()
{
    printf("%d %d %d %d %d",
            sizeof(unsigned char),
            sizeof(unsigned short int),
            sizeof(unsigned int),
            sizeof(unsigned long int),
            sizeof(unsigned long long int)
          );
    return 0;
}

输出样例:

1 2 4 8 8

二.整型常量

①（代码）输出今年是建党多少周年和建国多少周年

输入格式:

一个整数N(N>=2000)，代表某个年度数。

输出格式:

两个整数，以空格分隔，分别代表建党周年数和建国周年数。

输入样例:

2049

输出样例:

128 100

#include<stdio.h>
int main()
{
    int n;
    scanf("%d",&n);
    printf("%d %d",n-1921,n-1949);
    return 0;
}

相关知识-常量和变量

程序中值不变的量称为常量，常量可分为字面常量和符号常量。字面常量就是直接写出来的一个数据。符号常量是指用一个标识符来代表一个常量。程序运行的过程中，值可以改变的量称为变量。每个常量和变量都必须归属一个确定的数据类型，不同类型的常量和变量占据不同大小的存储空间、具有不同的表示范围。以上程序中的1921、1949和0都是字面常量，n是变量。

②（代码）认识整型常量

任务描述:

整型常量有八进制、十进制、十六进制三种表示形式。 编写程序输入三个整数，按要求输出它们的不同表示形式。

输入格式:

以空格分隔的三个整数，其中第1个为十进制数，第2个为八进制数，第3个为十六进制数。

输出格式:

请按输出样例形式输出这三个数的不同表示形式，其中：第1行输出十进制形式；第2行输出八进制形式；第3行输出带前导0的八进制形式；第4行输出十六进制形式,字母数字小写；第5行输出十六进制形式,字母数字大写；第6行输出十六进制形式,字母数字小写，输出前导0x。

输入样例:

2298 04372 0X8FA

输出样例:

2298,2298,2298

4372,4372,4372

04372,04372,04372

8fa,8fa,8fa

8FA,8FA,8FA

0x8fa,0x8fa,0x8fa

#include<stdio.h>
int main(){
    int a,b,c;
    scanf("%d%o%x",&a,&b,&c);
    printf("%d,%d,%d\n",a,b,c);   //十进制形式 
    printf("%o,%o,%o\n",a,b,c);   //八进制形式
    printf("%#o,%#o,%#o\n",a,b,c);//十进制形式,带前导0 
    printf("%x,%x,%x\n",a,b,c);   //十六进制形式,字母数字小写  
    printf("%X,%X,%X\n",a,b,c);   //十六进制形式,字母数字大写
    printf("%#x,%#x,%#x",a,b,c);  //十进制形式,带前导0x 
    return 0;
}

相关知识-整型常量

1.整型常量的表示

整型常量在C语言程序中有多种表示方法：(1)十进制整数。由0～9十个数字表示的整数，逢10进1，整数前不能加前导0。例如：521、-9、0、123、456、2147483647等等。(2)八进制整数。以数字0开头，由0～7八个数字表示的整数，逢8进1，例如：0521、-04、+0123、556677等等。(3)十六进制整数。以0x开头，由0～9和A～F十六个数字表示的整数，逢16进1，例如：0x521、-0x9、0X5A6B7F等等。字符X和数字A～F可以大写也可以小写。(4)字面常量类型认定。C语言对于没有后缀且在int表示范围内的整型常量都视为int型，对于超过此范围的整数根据其大小范围依次认定为unsigned int 、long、unsigned long、long long或unsigned long long型。(5)L后缀。可以在整型常量的末尾加上字符L或LL，来特别说明这是一个long型或long long型的整型常量，例如521L,034LL, 0xaL等等(L可小写)。(5)U后缀。可以在一个整型常量的末尾加上字符u或U来特别说明一个无符号整型常量。L、LL和U的位置可以互换。例如：12U、12LU、12ULL都是合法的表示方法。

2.整型数据格式说明符

(1)我们已经知道%d是十进制整数说明符，除此之外，%o是八进制整数说明符，%x是十六进制整数说明符，百分号后面的字母也可以大写。这三种形式可以用于scanf函数中输入相应格式的整数。(2)语句scanf("%d%o%x",&a,&b,&c);的功能是依次输入十进制、八进制和十六进制三个整数，分别赋值给int型变量a、b和c。(2)在printf函数中输出整数时有以下多种形式可以选择：%o:以八进制形式输出，%#o表示输出前导0；%x以十六进制形式输出，%#x表示输出前导0x，数字中的字母和前导x都是小写；当以%X或%#X格式输出十六进制数据时，数字中的字母和前导X都是大写。整型常量数据的表示和输入输出的基本规则你清楚了吗？如果有点晕，我们慢慢来，多多练习，熟悉就好了。

三.实型常量

①（代码）麦子价值

任务描述：小白弟弟家乡的小麦丰收了，收获后的小麦被堆成一个底面圆柱形的粮仓。经测量后得知底面半径为r米，粮仓的高为h米。假设一立方米麦子重750公斤，请你算一算这堆小麦有多少公斤。假设每吨小麦的价格是3500元，这堆小麦价值多少元呢。提示：题目中涉及到圆周率时，取π=3.14159265。

输入格式:

程序输入为两个实数，表示粮仓的底面半径和高。

输出格式:

输出两个实数，即小麦的重量和价值(单位:万元)，保留到小数点后4位。

输入样例:

1.5 2.5

输出样例:

7952.1564 2783.2547

#include<stdio.h>
#define PI 3.14159265   //宏定义PI为3.14159265（代码中PI直接替换为3.14159265）
                        //有分号也会替换过去，建议不要加分号
int main()
{
    double r, h, v;     //定义三个为双精度浮点型的变量
    scanf("%lf%lf", &r, &h);
    v = PI * r * r * h;
    printf("%.4lf %.4lf", v * 450., v * 450.00 * 0.35);
    return 0;
}

相关知识-实型常量的表示

实型常量用十进制表示,有如下两种表示方法：小数形式：3.14159265、-0.618等等。其中小数点前或后的唯一0可以省略，但不能全省略，例如100.、.618、-.618、.0、0.等等都是合法的表示方法。指数形式：当一个实数很小或很大时，用小数形式表示起来就十分困难，而用指数形式表示则很方便，其格式为：±尾数部分E±指数部分 (E也可小写)例如：-1.2e+2表示-1.2×102、1.32E-2表示1.32×10-2等等，e或E前后必须都有数字,且E后必须为整数。不加后缀说明的所有实型常量都被解释成double类型；在实型常量后加上字符f或F后缀，可以将其说明为float类型；在实型常量后加上字符l或L后缀，可以将其说明为long double类型。例如，常量3.14159265是double类型, 常量3.14159265F就是float类型，常量3.14159265L就是long double类型。

相关知识-符号常量

定义符号常量的格式为：#define 符号常量标识符 值程序中指令#define PI 3.14159265的意义是定义一个符号常量PI，其值是3.14159265。这样在程序中就可以使用PI来进行运算了。符号常量的值一经定义，不允许改变。符号常量的定义属于编译预处理指令，通常放在主函数外的程序开始处。实质上是在程序正式编译之前的预处理时，将程序中的所有PI都替换成3.14159265，然后再编译执行。也就是说，符号常量的实质是正式编译前预处理时的替换。

代码分析

1.程序中的3.14159265、450.、450.00、0.35都是合法的实型常量，标识符PI是符号常量。2.语句double r,h,v;的功能是定义3个double型的变量r,h和v。3.语句scanf("%lf%lf",&r,&h);的功能是输入2个实数，赋值给变量r和h。%lf是实型数据格式说明符，此处用于输入实数。4.语句v=PI*r*r*h;的功能是将表达式PI*r*r*h的值赋给左侧的变量v。5.语句printf("%.4lf %.4lf",v*450.,v*450.00*0.35);的功能是输出格式字符串"%.4lf %.4lf"的内容。%lf用于输出实型数据，默认输出6位小数，%.4lf在输出实型数据时保留4位小数。语句首先输出v*450.的值，再原样输出一个空格，再输出表达式v*450.00*0.35的值。

②（代码）

任务描述:

根据世界卫生组织推荐的计算方法，男性标准体重计算方法为（身高cm－80）×70%。 本题目要求读入1个表示某男性身高的实数（单位为米，小数点最多2位），输出此人的标准体重，小数点后保留2位。

输入格式:

输入只有一行，1个实数。

输出格式:

在一行中输出标准体重结果，结果后输出KG。

输入样例:

1.85

输出样例:

73.50KG

#include<stdio.h>
int main() 
{
    double g, h;  //定义两个为双精度浮点型的变量
    scanf("%lf", &h);
    g = (h * 100 - 80) * 0.7;
    printf("%.2lfKG", g);
    return 0;
}

四.字符型常量

①代码（ASCLL码值）

任务描述:

C语言中字符型数据的实质是整型数据，它是1个字节的整数，取值范围是-128到+127。 字符型数据在内存中实质上存储的是它的ASCII码，字符型数据和整型数据可以混合运算。

输入格式:

首先是一个字符A，然后跟一个32至126之间的正整数N。

输出格式:

第一行输出字符A的ASCII码值和整数N的值，用一个空格分隔。第二行输出字符A和ASCII码为N的字符。第三行输出字符A后相邻的字符，再输出ASCII码为N+1的字符。

输入样例:

A 97

输出样例:

65,97

A,a

B,b

输入样例:

# 42

输出样例:

35,42

#,*

$,+

#include<stdio.h>
int main()
{
    char a;  //定义一个字符型变量a
    int n;
    scanf("%c%d",&a,&n);
    printf("%d,%d\n",a,n);
    printf("%c,%c\n",a,n);
    printf("%c,%c",a+1,n+1);
    return 0;
}

相关知识 ASCII码

ASCII码（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统，并等同于国际标准ISO/IEC 646。

ASCII码使用8位二进制数组合(正好一个字节)来表示0到255共256种可能的字符。

前128个字符是标准ASCII码，表示所有的大小写字母、数字0到9、标点符号，以及在美式英语中使用的特殊控制字符。

后128个字符是扩展ASCII码，一般用来表示特殊符号、外来语字母和图形符号。

相关知识 字符型常量

字符型常量是由一对单引号括起来的一个字符。字符常量的表示方法有两种：普通字符和转义字符。

普通字符就是单引号将一个单字符括起来。例如：'A'、'6'、'$'、';'、 '>'、'G'、'?'等等。单引号只是一对定界符,在普通字符表示当中只能包括一个字符。

转义字符是指用形如'???'的形式来表示一个字符。常用的转义字符及其含义如表2-3所示。

由于字符'A'的ASCII码为十进制数65，用八进制表示是0101，用十六进制表示是0x41，所以字符'\101'和'\X41'都表示字符'A'。用这种方法可以表示任何字符。例如'\141'表示字符'a'。再例如'\0'、'\000'和'\x00'都代表的是ASCII码为0的控制字符,即空字符。空字符被用来作为字符串结束的标记。

相关知识 字符型数据在内存中的表示

字符型数据在内存中是以整型数据形式存储的。举例来说字符'A'在内存中占一个字节，存储的是整型数据65（字符'A'的ASCII码），也就是说字符型数据是一个字节的整数。小白弟弟，你注意到了吗？所有的大写英文字母的ASCII码比它们的小写形式小32，也就是说：'A'+32的值是97，也就是'a'；'B'-32的值是66，也就是'b'。字符型数据和整型数据是可以通用、可以混合运算。字符型数据可以当做整型数据来使用，整型数据也可以当做字符型数据来使用。

任务代码分析

1.语句char a;的功能是定义字符型变量a；语句int n;的功能是定义整型变量n。

2.语句scanf("%c%d",&a,&n);的功能是输入一个字符和整数，赋值给变量a和n。其中%c是字符型格式说明符，在这里指输入一个字符。3.语句printf("%d,%d\n",a,n);的功能是输出两个以逗号分隔的整数和回车。第一个%d输出的是表达式a的值，就是字符a的ASCII码，字符a可以直接当整型数据使用。第二个%d输出的是整数n的值。4.语句printf("%c,%c\n",a,n);的功能是输出两个以逗号分隔的字符和回车。第一个%c输出的是字符a。第二个%c输出的是以n为ASCII码的字符，这里的整数n将以字符的身份输出。5.语句printf("%c,%c",a+1,n+1);的功能也是输出两个以逗号分隔的字符。第一个%c输出的是以a+1为ASCII码的字符，这里的字符a和整数1可以直接相加。第二个%c输出的是以n+1为ASCII码的字符。通过以上的学习和分析，应该明白字符型数据的原理了吧！

相关知识 字符串常量

字符串常量是以双引号括起来的一串字符序列。例如， "This is a c program."、"ABC"、"I LOVE C"或""(空串)等。其中双引号为字符串的定界符，不属于字符串的内容。字符串常量在内存中的某个起始存储单元开始依次存储各个字符(实际存储的是ASCII码)，并在最末字符的下一个字节位置额外存储一个空字符'\O'，表示字符串结束。所以，字符串数据在内存中存储在一块连续的地址空间中，所占内存空间长度为其实际字符个数加1。例如，字符串"CHINA'在内存中所占用的存储空间是6个字节。

示例代码分析

#include<stdio.h>
int main()
{
    printf("%d", sizeof("CHINA"));
    return 0;
}

执行程序输出：6

②（英文大小写字母变换）

任务描述:

输入数据为在一行中有一个大写字母a和小写字母b（没有空格），编程分别输出它们对应的另一字母(小写或大写)。

输入样例:

Am

输出样例:

aM

#include<stdio.h>
int main()
{
    char a, m;
    scanf("%c%c", &a, &m);//if就是如果，else就是否则，后面会讲。
    if (a >= 'a' && a <= 'z')//记不住对应的ASCLL值这样括起来（相当于a>=97&&a<=122）
    {
        a = a - 32;
    }
    else  if (a >= 'A' && a <= 'Z')
    {
        a = a + 32;
    }
    if (m >= 'a' && m <= 'z')
    {
        m = m - 32;
    }
    else if (m >= 'A' && m <= 'Z')
    {
        m = m + 32;
    }
    printf("%c%c", a, m);
    return 0;
}

五.变量

①（代码）小明父亲的工资

任务描述：

编程输入小明的父亲每个月的工资数（单位元，实数）和工作时间（月分数，整数），小明父亲单位发工资时要扣除15%的所得税，输出应发工资总额（实数，保留2位小数）。

输入格式:

输入在一行中给出2个值,一个是月工资数，一个是工作月数。

输出格式:

只输出一个实数，保留2位小数.

输入样例:

10000 12

输出样例:

102000.00

#include<stdio.h>
int main()
{
    double x, s; //double型变量，x表示每月工资数,表示应发工资总额 
    int t;      //int型变量，表示工作月数 
    scanf("%lf%d", &x, &t);  //输入数据赋给变量x和t 
    s = x * t * (1 - 0.15);        //计算应发工资总额
    printf("%.2lf", s);     //输出结果
    return 0;
}

代码分析

1.程序定义了2个double型变量(x,s)和1个int型的变量t。

2.语句scanf("%lf%d",&x,&t);的功能是输入1个实数和1个整数，

输入数据之间可由空格、TAB或回车分隔，输入的数据按顺序赋值给右边的变量x和t。

3.语句s=x*t*(1-0.15);的功能是计算工资总额，赋给左边的变量。

4.语句printf("%.2lf",s);的功能是输出结果，格式说明%.2lf在输出数据时保留2位小数。

相关知识 变量

在程序运行的过程中，值可以改变的量称为变量。变量有不同的数据类型，占据不同大小的存储空间、具有不同的表示范围。变量的基本属性包括变量名称、变量类型和变量值。每一个变量都有一个变量名、都从属于某一个数据类型，在其生存期内的每一时刻都有值。变量一经定义，其类型不再改变。

1.变量定义

变量定义语句的一般格式为：数据类型标识符 变量名表;变量名表中如果是多个变量，变量之间要用逗号分隔开来。变量一定要先定义后使用，并且在同一个作用域内变量不可重复定义。例如以下变量的定义都是合法的。int a,b,s;short f;long p,q,r;unsigned long k;char c1,c2;float x,y;double d1,d2;

2.变量的赋初值

第一次给变量赋值，也称为给变量赋初值。给变量赋初值可以通过一个单独的赋值语句来完成。例如：int a; a=8;给变量赋初值也可以在定义变量的时候一次完成。例如:

int a = 8;          /*定义变量a为整型，同时赋初始值为8*/
float f = 3.14;     /*定义变量f为单精度实型，同时赋初始值为3.14*/
double d = 0.5;     /*定义变量d为双精度实型，同时赋初始值为0.5*/

我们也可以在定义变量时,只给部分变量赋初值，例如：

int a = 3, b, c;      /*定义a,b,c三个整型变量,只给a赋初始值3*/

定义变量，必需一个一个进行。例如，我们想给多个变量(a,b,c,d)赋相同的初始值6，则必须写成：int a=6,b=6,c=6,d=6;不允许写成 int a=b=c=d=6;。

②（代码）鸡兔同笼

任务描述:

中国古代《孙子算经》中记载有趣的“鸡兔同笼”问题：“雉兔同笼，上有三十五头，下有九十四足，问雉兔各几何?”请仿照上例编程输入一组可能的头数量和脚数量，分别输出鸡兔各多少只。（提示，可能的数据有：头35脚94、头88脚244、头100脚200、头80脚240、等等）。

输入格式:

头数量和脚的数量。

输出格式:

鸡的数量和兔的数量，中间空一格。

输入样例:

10 30

输出样例:

5 5

解法一：穷举法（列表法）可以根据测试集穷举出每种情况，想不到其他方法再用，代码自己实现

假设总脚数为94，总头数为35

解法二:抬腿法

这是古人解题的方法，也就是《孙子算经》中采用的方法。

1、抬腿，即鸡“金鸡独立”，兔两个后腿着地，前腿抬起，腿的数量就为原来数量的一半。

94+ 2=47只脚。

2、现在鸡有一只脚，兔有两只脚。笼子里只要有一只兔子，脚数就比头数多1。

3、那么脚数与头数的差47-35=12就是兔子的只数。

4、最后用头数减去兔的只数35-12=23就得出鸡的只数。

所以，我们可以总结出这样的公式:兔子的只数= 总腿数/2-总只数。

#include<stdio.h>
int main()
{
    int a, b, n, m;
    // a鸡的数量
    // b兔的数量
    // n鸡兔总数
    // m总脚数
    scanf("%d %d", &n, &m);
    b = m / 2 - n;//算出兔的数量
    a = n - b;//算出鸡的数量
    if (a <= 0 || b <= 0)
    {   //结果小于等于0，答案不成立，无解
        printf("No answer");
    }
    else 
    {   //结果大于0
        printf("%d %d", a, b);
    }
    return 0;
}

解法三:假设法

假设法是鸡兔同笼类问题最常用的方法之一。假设这35个头都是兔子，那么腿数就应该是35X4=140，就比94还多，那么是哪里多的呢?当然是我们把两条腿的鸡看成了四条腿的兔子了。我们都知道一一只兔子比一一只鸡多2条腿，多2条腿就有1只鸡，那么多的腿数当中有多少个2就有多少只鸡。我们可以列式为:鸡的只数= (35X4-94) 六(4-2)。 总结公式为:鸡的只数= (兔的脚数X总只数一总腿数)/(兔的腿数-鸡的腿数)。

当然我们也可以把这35个头都看成鸡的，那么腿数应该是35X2=70，就比94还少，相信不说你也明白为什么少了?对，因为我们把4条腿的兔子看成了2条腿的鸡，那么每少两条腿就有1只兔子。所以我们可以这样列式:兔的只数= (94-35X2)六(4-2)。总结公式为:兔的只数= (总脚数-鸡的脚数X总只数)/( 兔的脚数-鸡的脚数)。

#include<stdio.h>
int main()
{
    int a, b, n, m;
    // a鸡的数量
    // b兔的数量
    // n鸡兔总数
    // m总脚数
    scanf("%d %d", &n, &m);
    a = (4 * n - m) / 2;//算出鸡的数量
    b = n - a;//算出兔的数量
    if (a <= 0 || b <= 0)
    {   //结果小于等于0，答案不成立，无解
        printf("No answer");
    }
    else 
    {   //结果大于0
        printf("%d %d", a, b);
    }
    return 0;
}

解法四:砍腿法

砍腿法是假设法的深入拓展，下面我就用这种方法来解一下这道题。我们首先砍去每只鸡、每只兔的两条腿，这样每只鸡就没有腿了，每只兔子就剩下了两条腿，腿的总数也就变成了94-35X2=24 (条)，那么这24条腿都是砍掉两条腿后的兔子的腿，所以兔子的只数就是24+2=12 (只)，鸡的只数就是35-12=23 (只)。我们仔细观察会发现它的计算过程和假设法中先把所有的都看成鸡的做法是一样的.只不过这种说法，我们理解起来更容易而己。

代码可以按照上面自己实现，动手才是硬道理。