本章主要是让我们了解变量与运算符的使用，题目也都比较简单，当然也需要我们一点点数学的基本知识，才能让我们更好的理解这章的题目。
总时间限制: 1000ms 内存限制: 65536kB
描述
在大部分的在线题库中，都会将A+B问题作为第一题，以帮助新手熟悉平台的使用方法。
A+B问题的题目描述如下：给定两个整数A和B，输出A+B的值。保证A、B及结果均在整型范围内。
现在请你解决这一问题。
输入
一行，包含两个整数A，B，中间用单个空格隔开。A和B均在整型范围内。
输出
一个整数，即A+B的值。保证结果在整型范围内。
样例输入
1 2
样例输出
3
题目保证结果在整形范围内，所以只需要定义两个整型变量即可
C语言实现
#include <stdio.h>
int main(){
int a, b;
scanf("%d %d", &a, &b);
printf("%d", a + b);
return 0;
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int A=sc.nextInt();
int B=sc.nextInt();
System.out.println(A+B);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
给定3个整数a、b、c，计算表达式(a+b)*c的值。
输入
输入仅一行，包括三个整数a、b、c, 数与数之间以一个空格分开。
(－10,000 < a,b,c < 10,000)
输出
输出一行，即表达式的值
样例输入
2 3 5
样例输出
25
考察运算符的使用
C语言实现
#include <stdio.h>
int main(){
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
printf("%d", (a + b)*c);
return 0;
}
Java实现
import java.util.Scanner;
/*给定3个整数a、b、c，计算表达式(a+b)*c的值。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
System.out.println((a+b)*c);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
给定3个整数a、b、c，计算表达式(a+b)/c的值，/是整除运算。
输入
输入仅一行，包括三个整数a、b、c, 数与数之间以一个空格分开。(－10,000 < a,b,c < 10,000, c不等于0)
输出
输出一行，即表达式的值。
样例输入
1 1 3
样例输出
0
考察运算符的使用
C语言实现
#include <stdio.h>
int main(){
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
printf("%d", (a + b)/c);
return 0;
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
System.out.println((a+b)/c);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
给定被除数和除数，求整数商及余数。
此题中请使用默认的整除和取余运算，无需对结果进行任何特殊处理。看看程序运行结果与数学上的定义有什么不同？
输入
一行，包含两个整数，依次为被除数和除数（除数非零），中间用一个空格隔开。
输出
一行，包含两个整数，依次为整数商和余数，中间用一个空格隔开。
样例输入
10 3
样例输出
3 1
考察/和%的使用
C语言实现
#include <stdio.h>
int main(){
int a, b;
scanf("%d %d", &a, &b);
printf("%d %d", a / b, a%b);
return 0;
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
System.out.print(a/b+" ");
System.out.println(a%b);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
两个整数a和b分别作为分子和分母，既分数 a/b ，求它的浮点数值（双精度浮点数，保留小数点后9位）
输入
输入仅一行，包括两个整数a和b（b不为0）
输出
输出也仅一行，分数 a/b 的浮点数值（双精度浮点数，保留小数点后9位）
样例输入
5 7
样例输出
0.714285714
考察浮点数的除法. 浮点数一般都定义成double类型,因为题目说a和b是整数,所以我就定义成int类型了,不过定义为double类型也是可以的
通过与上题的对比, 我们可以了解到浮点数与整数的除法所得结果不同. 整形数据因为只存储整数部分,所以两数相除所得结果只能是整数,而浮点数有小数部分,两数相除所得结果比整形数据精度更大,即有小数部分
C语言实现
#include <stdio.h>
int main() {
int a, b;
scanf("%d %d", &a, &b);
printf("%.9f", (double)a / (double)b);
return 0;
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double a=sc.nextInt();
double b=sc.nextInt();
System.out.printf("%.9f",a/b);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
甲流并不可怕，在中国，它的死亡率并不是很高。请根据截止2009年12月22日各省报告的甲流确诊数和死亡数，计算甲流在各省的死亡率。
输入
输入仅一行，有两个整数，第一个为确诊数，第二个为死亡数。
输出
输出仅一行，甲流死亡率，以百分数形式输出，精确到小数点后3位。
样例输入
10433 60
样例输出
0.575%
提示
输出%可以使用printf(“%%”);
同样考察浮点数的除法
C语言实现
#include <stdio.h>
int main()
{
double a, b;
scanf("%lf %lf", &a, &b);
printf("%.3lf%%", b / a * 100);
return 0;
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double a=sc.nextInt();
double b=sc.nextInt();
System.out.printf("%.3f%%",b/a*100);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
对于多项式f(x) = ax3 + bx2 + cx + d 和给定的a, b, c, d, x，计算f(x)的值。
输入
输入仅一行，包含5个实数，分别是x，及参数a、b、c、d的值，每个数都是绝对值不超过100的双精度浮点数。数与数之间以一个空格分开。
输出
输出一个实数，即f(x)的值，保留到小数点后7位。
样例输入
2.31 1.2 2 2 3
样例输出
33.0838692
本题用到了一个库函数math, pow(x, 3)表示的意思就是x3, 也可以写成x*x*x
C语言实现
#include <stdio.h>
#include <math.h>
int main() {
double x, a, b, c, d;
scanf("%lf %lf %lf %lf %lf", &x, &a, &b, &c, &d);
// printf("%f %f %f %f %f", x, a, b, c, d);
double f = a * pow(x, 3) + b * pow(x, 2) + c * x + d;
printf("%.7f", f);
}
Java实现
import java.util.Scanner;
/*对于多项式f(x) = ax3 + bx2 + cx + d 和给定的a, b, c, d, x，计算f(x)的值。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double x=sc.nextDouble();
double a=sc.nextDouble();
double b=sc.nextDouble();
double c=sc.nextDouble();
double d=sc.nextDouble();
double s=a*Math.pow(x,3)+b*Math.pow(x,2)+c*x+d;
System.out.printf("%.7f",s);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
利用公式 C = 5 * (F-32) / 9 （其中C表示摄氏温度，F表示华氏温度） 进行计算转化。
输入
输入一行，包含一个实数f，表示华氏温度。（f >= -459.67）
输出
输出一行，包含一个实数，表示对应的摄氏温度，要求精确到小数点后5位。
样例输入
41
样例输出
5.00000
C语言实现
#include <stdio.h>
int main()
{
double f;
scanf("%lf", &f);
printf("%.5lf", 5*(f-32)/9);
return 0;
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double F=sc.nextDouble();
double C=5*(F-32)/9;
System.out.printf("%.5f",C);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
给出圆的半径，求圆的直径、周长和面积。
输入
输入包含一个实数r（0 < r <= 10,000），表示圆的半径。
输出
输出一行，包含三个数，分别表示圆的直径、周长、面积，数与数之间以一个空格分开，每个数保留小数点后4位。
样例输入
3.0
样例输出
6.0000 18.8495 28.2743
提示
如果圆的半径是r，那么圆的直径、周长、面积分别是2*r、2 * pi * r、pi * r * r，其中约定pi＝3.14159。
可以使用printf(“%.4lf”, …)实现保留小数点后4位。
这题的pi和r都需要定义成double类型才能通过
C语言实现
#include <stdio.h>
int main() {
double PI = 3.14159;
double r;
scanf("%lf", &r);
printf("%.4lf %.4lf %.4lf", 2 * r, 2 * PI * r, PI * r * r);
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
double pi = 3.14159;
Scanner sc = new Scanner(System.in);
double r = sc.nextDouble();
System.out.printf("%.4f %.4f %.4f", 2 * r, 2 * pi * r, pi * r * r);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
对于阻值为r1和r2的电阻，其并联电阻阻值公式计算如下：
R = 1/(1/r1 + 1/r2)
输入
两个电阻阻抗大小，浮点型，以一个空格分开。
输出
并联之后的阻抗大小，结果保留小数点后2位
样例输入
1 2
样例输出
0.67
C语言实现
#include <stdio.h>
int main()
{
float r1, r2;
scanf("%f %f", &r1, &r2);
printf("%.2f", 1/(1 / r1 + 1 / r2));
return 0;
}
Java实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
float r1=sc.nextFloat();
float r2=sc.nextFloat();
System.out.printf("%.2f",1/(1/r1+1/r2));
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
计算两个双精度浮点数a和b的相除的余数，a和b都是正数的。这里余数（r）的定义是：a = k * b + r，其中 k是整数， 0 <= r < b。
输入
输入仅一行，包括两个双精度浮点数a和b。
输出
输出也仅一行，a÷b的余数
样例输入
73.263 0.9973
样例输出
0.4601
提示
注意：输出时小数尾部没有多余的0，可以用下面这种格式：
double x;
x = 1.33;
printf(“%g”, x);
C语言中浮点数不能用%求余数, 要求浮点数的余数,首先a/b取得整数部分,即强转为int类型,然后再乘b,最后再用a减去上面所得结果,才能求得浮点数的余数
C语言实现
#include <stdio.h>
int main() {
double a, b;
scanf("%lf %lf", &a, &b);
// printf("%d\n", (int)(a / b));
printf("%g", a - (int)(a / b) * b);
}
在Java中可以使用%求浮点数的余数, 但是这样直接算到的结果会不准确
因此需要将计算所得的结果通过String.format()格式化, 参数%g的描述:
The result is formatted using computerized scientific notation or decimal format, depending on the precision and the value after rounding.
翻译过来就是:根据精度和四舍五入后的值，使用计算机科学记数法或十进制格式对结果进行格式化。
最后使用BigDecimal类中的stripTrailingZeros()方法去除小数后多余的0
Java实现
import java.math.BigDecimal;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double a = sc.nextDouble();
double b = sc.nextDouble();
double remainder = a % b;
// System.out.println(remainder);//0.46010000000000784
//这样算算出来的结果不准确
//为什么会出现这样的现象，这是因为二进制表示的小数可以做到“每个十进制整数都有对应的二进制数”，但是不能做到“每一个十进制小数都有对应的二进制数”
//所以浮点类型 float、 double 的数据不适合在不容许舍入误差的金融计算领域。
//所以在编程中，可以采用四舍五入的方式进行验证，避免上述问题
//先用format方法，将结果进行格式化，再调用BigDecimal类的stripTrailingZeros方法，移除remainder小数点后多余的0
BigDecimal res = new BigDecimal(String.format("%g", remainder)).stripTrailingZeros();
//调用了stripTrailingZeros()再调用 toString() 将会转换为科学计数法输出。如果不希望用科学计数法输出，可以使用toPlainString()进行全字符输出。
System.out.println(res.toPlainString());
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
对于半径为r的球，其体积的计算公式为V=4/3*πr3，这里取π= 3.14。
现给定r，求V。
输入
输入为一个不超过100的非负实数，即球半径，类型为double。
输出
输出一个实数，即球的体积，保留到小数点后2位。
样例输入
4
样例输出
267.95
这个题目如果要按照公式的4/3*πr^3的顺序来写的话,要注意4要写成浮点类型4.0, 否则结果会出错
C语言实现
#include <stdio.h>
int main()
{
double r;
double pi = 3.14;
scanf("%lf", &r);
printf("%.2lf", 4.0 / 3 * pi * r * r * r);
return 0;
}
Java实现
import java.util.Scanner;
/*对于半径为r的球，其体积的计算公式为V=4/3*πr3，这里取π= 3.14。
现给定r，求V。*/
public class Main{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double r=sc.nextDouble();
System.out.printf("%.2f",4*1.0/3*3.14*Math.pow(r,3));
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
将一个三位数反向输出。
输入
一个三位数n。
输出
反向输出n。
样例输入
100
样例输出
001
C语言实现
#include <stdio.h>
int main()
{
int n;
scanf("%d", &n);
printf("%d%d%d", n % 10, n / 10 % 10, n / 100);
return 0;
}
Java实现
import java.util.Scanner;
/*将一个三位数反向输出。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int a=n/100;
int b=n/10%10;
int c=n%10;
System.out.print(c);
System.out.print(b);
System.out.println(a);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
一只大象口渴了，要喝20升水才能解渴，但现在只有一个深h厘米，底面半径为r厘米的小圆桶(h和r都是整数)。问大象至少要喝多少桶水才会解渴。
输入
输入有一行：包行两个整数，以一个空格分开，分别表示小圆桶的深h和底面半径r，单位都是厘米。
输出
输出一行，包含一个整数，表示大象至少要喝水的桶数。
样例输入
23 11
样例输出
3
提示
如果一个圆桶的深为h厘米，底面半径为r厘米，那么它最多能装Pi * r * r * h立方厘米的水。(设Pi=3.14159)
1升 = 1000毫升
1毫升 = 1 立方厘米
这个题目要用到math库函数中的ceil()函数,表示向上取整
C语言实现
#include <stdio.h>
#include <math.h>
int main()
{
double pi = 3.14159;
double h, r;
scanf("%lf %lf", &h, &r);
printf("%d", (int)ceil(20000.0 / (pi * r * r * h)));
return 0;
}
Java实现
import java.util.Scanner;
/*一只大象口渴了，要喝20升水才能解渴，但现在只有一个深h厘米，底面半径为r厘米的小圆桶(h和r都是整数)。问大象至少要喝多少桶水才会解渴。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
float PI=3.14159f;
double h=sc.nextDouble();
double r=sc.nextDouble();
System.out.printf("%d",(int)Math.ceil(20000 / (PI * r * r * h)));
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？
输入
输入仅一行，包括n，x和y（均为整数）。输入数据保证y <= n * x。
输出
输出也仅一行，剩下的苹果个数
样例输入
10 4 9
样例输出
7
这题是使用math库函数中的floor()函数,表示向下取整
C语言实现
#include <stdio.h>
#include <math.h>
int main()
{
double n, x, y;
scanf("%lf %lf %lf", &n, &x, &y);
printf("%d", (int)floor(n - y / x));
return 0;
}
Java实现
import java.util.Scanner;
/*你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double n=sc.nextInt();
double x=sc.nextInt();
double y=sc.nextInt();
System.out.printf("%d",(int)Math.floor(n-y/x));
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
已知线段的两个端点的坐标A（Xa,Ya），B（Xb，Yb），求线段AB的长度。
输入
共两行。
第一行是两个实数Xa，Ya，即A的坐标。
第二行是两个实数Xb，Yb，即B的坐标。
输入中所有实数的绝对值均不超过10000。
输出
一个实数，即线段AB的长度，保留到小数点后3位。
样例输入
1 1
2 2
样例输出
1.414
根据中学学的求两个点之间的线段长度公式√△x2+△y2, 然后这题就变得很简单了
C语言实现
#include <stdio.h>
#include <math.h>
int main() {
double xa, ya;
double xb, yb;
scanf("%lf %lf", &xa, &ya);
scanf("%lf %lf", &xb, &yb);
double ab = sqrt((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb));
printf("%.3lf", ab);
}
Java实现
import java.util.Scanner;
/*已知线段的两个端点的坐标A（Xa,Ya），B（Xb，Yb），求线段AB的长度。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double xa =sc.nextDouble();
double ya =sc.nextDouble();
double xb =sc.nextDouble();
double yb =sc.nextDouble();
System.out.printf("%.3f",Math.sqrt((xa-xb)*(xa-xb)+(ya-yb)*(ya-yb)));
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
平面上有一个三角形，它的三个顶点坐标分别为(x1, y1), (x2, y2), (x3, y3)，那么请问这个三角形的面积是多少。
输入
输入仅一行，包括6个单精度浮点数，分别对应x1, y1, x2, y2, x3, y3。
输出
输出也是一行，输出三角形的面积，精确到小数点后两位。
样例输入
0 0 4 0 0 3
样例输出
6.00
提示
海伦公式
这个题目关键就是知道海伦公式求三角形面积, 海伦公式:S=√p*(p-a)(p-b)(p-c), 其中p=(a+b+c)/2, a,b,c分别表示三角形三条边的长度,根据上一题就已经知道怎么求两点之间线段的长度,最后套公式即可,这样,这个题目就解决了
C语言实现
#include <stdio.h>
#include <math.h>
int main() {
double x1, y1, x2, y2, x3, y3;
scanf("%lf %lf %lf %lf %lf %lf", &x1, &y1, &x2, &y2, &x3, &y3);
//计算出三条边的长度
double a = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
double b = sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3));
double c = sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
//根据海伦公式求三角形面积：S=√p*(p-a)(p-b)(p-c), p=(a+b+c)/2
double p = (a + b + c) / 2;
// printf("%lf %lf %lf %lf\n", a, b, c, p);
printf("%.2lf", sqrt(p * (p - a) * (p - b) * (p - c)));
}
Java实现
import java.util.Scanner;
/*平面上有一个三角形，它的三个顶点坐标分别为(x1, y1), (x2, y2), (x3, y3)，那么请问这个三角形的面积是多少。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
float x1=sc.nextFloat(),
y1=sc.nextFloat(),
x2=sc.nextFloat(),
y2=sc.nextFloat(),
x3=sc.nextFloat(),
y3=sc.nextFloat();
double a=Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
double b=Math.sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
double c=Math.sqrt((x2-x3)*(x2-x3)+(y2-y3)*(y2-y3));
double p=(a+b+c)/2;
System.out.printf("%.2f",Math.sqrt(p*(p-a)*(p-b)*(p-c)));
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
给出一个等差数列的前两项a1，a2，求第n项是多少。
输入
一行，包含三个整数a1，a?2，n。-100 <= a1,a?2 <= 100，0 < n <= 1000。
输出
一个整数，即第n项的值。
样例输入
1 4 100
样例输出
298
根据我们中学学过的等差数列求第n项公式an=a1+(n-1)*d, d为公差
C语言实现
#include <stdio.h>
int main() {
int a1, a2, n;
scanf("%d %d %d", &a1, &a2, &n);
printf("%d", a1 + (n - 1) * (a2 - a1));
return 0;
}
Java实现
import java.util.Scanner;
/*给出一个等差数列的前两项a1，a2，求第n项是多少。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a1=sc.nextInt();
int a2=sc.nextInt();
int n=sc.nextInt();
System.out.printf("%d",a1+(n-1)*(a2-a1));
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
输入两个正整数A和B，求AB。
输入
一行，包含两个正整数A和B，中间用单个空格隔开。1 <= A,B <= 50000。
输出
一个整数，即AB的值。
样例输入
3 4
样例输出
12
整数乘法很容易溢出, 所以数据类型应选择比int类型更大的long类型
C语言实现
#include <stdio.h>
#include <math.h>
int main()
{
long long a, b;
scanf("%lld %lld", &a, &b);
printf("%lld", a * b);
return 0;
}
Java实现
import java.util.Scanner;
/*输入两个正整数A和B，求A*B。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
long a=sc.nextLong();
long b=sc.nextLong();
System.out.println(a*b);
}
}
总时间限制: 1000ms 内存限制: 65536kB
描述
给定非负整数n，求2n。
输入
一个整数n。0 <= n < 31。
输出
一个整数，即2的n次方。
样例输入
3
样例输出
8
这题最佳方法是用位运算符
C语言实现
#include <stdio.h>
#include <math.h>
int main()
{
int n;
scanf("%d", &n);
//方法1: 用math库函数中的pow()函数
// printf("%d", (int)pow(2.0, n));
//方法2: 用位运算符
if(n == 0) printf("1");
else printf("%d", 2 << (n-1));
return 0;
}
Java实现
import java.util.Scanner;
/*给定非负整数n，求2n。*/
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
System.out.println((int)Math.pow(2,n));
}
}