1.4编程基础之逻辑表达式与条件分支

最新推荐文章于 2024-04-24 15:47:54 发布
最新推荐文章于 2024-04-24 15:47:54 发布
阅读量195 收藏
点赞数
分类专栏： OpenJudge 文章标签： 算法 java c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lilianach/article/details/135839555
版权

目录

前言

这章题目主要是关于流程控制语句,题目还是比较简单的

1. 判断数正负

总时间限制: 1000ms 内存限制: 65536kB
描述
给定一个整数N，判断其正负。
输入
一个整数N(-109 <= N <= 109)
输出
如果N > 0, 输出positive;
如果N = 0, 输出zero;
如果N < 0, 输出negative
样例输入
1
样例输出
positive

C语言实现

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    if(n > 0)
        printf("positive\n");
    else if(n == 0)
        printf("zero\n");
    else
        printf("negative\n");
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        long N=sc.nextInt();
        if(N>0){
            System.out.println("positive");
        }else if(N==0){
            System.out.println("zero");
        }else {
            System.out.println("negative");
        }
    }
}

2. 输出绝对值

总时间限制: 1000ms 内存限制: 65536kB
描述
输入一个浮点数，输出这个浮点数的绝对值。
输入
输入一个浮点数，其绝对值不超过10000。
输出
输出这个浮点数的绝对值，保留到小数点后两位。
样例输入
-3.14
样例输出
3.14

C语言实现

#include <stdio.h>
#include <math.h>

int main() {
    float n;
    scanf("%f", &n);
    // 方法1：使用if-else语句
    //  if(n < 0) printf("%.2f\n", -n);
    //  else printf("%.2f\n", n);
    // 方法2：使用math库函数：fabs() 函数可以用于 double、float 和 long double 类型的参数。如果需要计算整数的绝对值，应该使用 abs() 函数。
    printf("%.2f\n", fabs(n));
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        float n=sc.nextFloat();
        System.out.printf("%.2f",Math.abs(n));
    }
}

3. 奇偶数判断

总时间限制: 1000ms 内存限制: 65536kB
描述
给定一个整数，判断该数是奇数还是偶数。
输入
输入仅一行，一个大于零的正整数n。
输出
输出仅一行，如果n是奇数，输出odd；如果n是偶数，输出even。
样例输入
5
样例输出
odd

C语言实现

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    if(n % 2 == 0) //n为偶数
        printf("even\n"); 
    else //n为基数
        printf("odd\n");
    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();
        if(n%2==1){
            System.out.println("odd");
        }
        else {
            System.out.println("even");
        }
    }
}

4. 奇偶ASCII值判断

总时间限制: 1000ms 内存限制: 65536kB
描述
任意输入一个字符，判断其ASCII是否是奇数，若是，输出YES，否则，输出NO
例如，字符A的ASCII值是65，则输出YES，若输入字符B(ASCII值是66)，则输出NO
输入
输入一个字符
输出
如果其ASCII值为奇数，则输出YES，否则，输出NO
样例输入
A
样例输出
YES

C语言实现

#include <stdio.h>

int main() {
    char c;
    scanf("%c", &c);
    int x = (int)c;
    if(x%2==0)
        printf("NO");
    else
        printf("YES");
}

这题Java只能得9分,通过不了,所以就不贴代码啦

5. 整数大小比较

总时间限制: 1000ms 内存限制: 65536kB
描述
输入两个整数，比较它们的大小。
输入
一行，包含两个整数x和y，中间用单个空格隔开。
0 <= x < 2^32, -2^31 <= y < 2^31。
输出
一个字符。
若x > y，输出 > ；
若x = y，输出 = ；
若x < y，输出 < ；
样例输入
1000 100
样例输出

C语言实现

#include <stdio.h>

int main() {
    long x, y;
    scanf("%ld %ld", &x, &y);
    if(x > y)
        printf(">");
    else if(x == y)
        printf("=");
    else
        printf("<");
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        long x=sc.nextLong();
        long y=sc.nextLong();
        if(x>y){
            System.out.println(">");
        }else if(x==y){
            System.out.println("=");
        }else{
            System.out.println("<");
        }
    }
}

6. 判断是否为两位数

总时间限制: 1000ms 内存限制: 65536kB
描述
判断一个正整数是否是两位数（即大于等于10且小于等于99）。
输入
一个正整数，不超过1000。
输出
一行。若该正整数是两位数，输出1，否则输出0。
样例输入
54
样例输出
1

C语言实现

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    if(n >= 10 && n <= 99)
        printf("1");
    else
        printf("0");
    return 0;
}

Java实现

import java.util.Scanner;

/*判断一个正整数是否是两位数（即大于等于10且小于等于99）。*/
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        if(n>=10&&n<=99){
            System.out.println(1);
        }else {
            System.out.println(0);
        }
    }
}

7. 收集瓶盖赢大奖

总时间限制: 1000ms 内存限制: 65536kB
描述
某饮料公司最近推出了一个“收集瓶盖赢大奖”的活动：如果你拥有10个印有“幸运”、或20个印有“鼓励”的瓶盖，就可以兑换一个神秘大奖。
现分别给出你拥有的印有“幸运”和“鼓励”的瓶盖数，判断是否可以去兑换大奖。
输入
一行，包含两个整数，分别是印有“幸运”和“鼓励”的瓶盖数，用一个空格隔开。
输出
一行。若可以兑换大奖，输出1，否则输出0。
样例输入
11 19
样例输出
1

C语言实现

#include <stdio.h>

int main() {
    int lucky, encourage;
    scanf("%d %d", &lucky, &encourage);
    if(lucky >= 10 || encourage >= 20)
        printf("1");
    else
        printf("0");
    return 0;
}

Java实现

import java.util.Scanner;

/*某饮料公司最近推出了一个“收集瓶盖赢大奖”的活动：如果你拥有10个印有“幸运”、或20个印有“鼓励”的瓶盖，就可以兑换一个神秘大奖。

现分别给出你拥有的印有“幸运”和“鼓励”的瓶盖数，判断是否可以去兑换大奖。*/
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int luck=sc.nextInt();
        int encourage=sc.nextInt();
        if(luck>=10||encourage>=20){
            System.out.println(1);
        }else {
            System.out.println(0);
        }
    }
}

8. 判断一个数能否同时被3和5整除

总时间限制: 1000ms 内存限制: 65536kB
描述
判断一个数n 能否同时被3和5整除
输入
输入一行，包含一个整数n。（ -1,000,000 < n < 1,000,000）
输出
输出一行，如果能同时被3和5整除输出YES，否则输出NO
样例输入
15
样例输出
YES

C语言实现

#include <stdio.h>

int main() {
    long n;
    scanf("%ld", &n);
    if((n%3==0) && (n%5==0))
        printf("YES");
    else
        printf("NO");
    return 0;
}

Java实现

import java.util.Scanner;

/*判断一个数n 能否同时被3和5整除*/
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        long n=sc.nextLong();
        if(n%3==0&&n%5==0){
            System.out.println("YES");
        }else {
            System.out.println("NO");
        }
    }
}

9. 判断能否被3，5，7整除

总时间限制: 1000ms 内存限制: 65536kB
描述
给定一个整数，判断它能否被3，5，7整除，并输出以下信息：
1、能同时被3，5，7整除（直接输出3 5 7，每个数中间一个空格）；
2、只能被其中两个数整除（输出两个数，小的在前，大的在后。例如：3 5或者 3 7或者5 7,中间用空格分隔）；
3、只能被其中一个数整除（输出这个除数）；
4、不能被任何数整除，输出小写字符‘n’,不包括单引号。
输入
输入一行，包括一个整数。
输出
输出一行，按照描述要求给出整数被3，5，7整除的情况。
样例输入
105
样例输出
3 5 7

这题用四个if语句直接判断能否被3,5,7整除更简洁且更好理解,所以没有选择if-else语句,因为if-else语句要分很多种情况,就很容易遗漏

C语言实现

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    if(n % 3 == 0)
        printf("3 ");
    if(n % 5 == 0)
        printf("5 ");
    if(n % 7 == 0)
        printf("7");
    if(n % 3 != 0 && n % 5 != 0 && n % 7 != 0)
        printf("n");
}

Java实现

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        if(n%3==0){
            System.out.print(3+" ");
        }
        if(n%5==0){
            System.out.print(5+" ");
        }
        if(n%7==0){
            System.out.print(7);
        }else if(n%3!=0&&n%5!=0&&n%7!=0){
            System.out.println("n");
        }
    }
}

10. 有一门课不及格的学生

总时间限制: 1000ms 内存限制: 65536kB
描述
给出一名学生的语文和数学成绩，判断他是否恰好有一门课不及格（成绩小于60分）。
输入
一行，包含两个在0到100之间的整数，分别是该生的语文成绩和数学成绩。
输出
若该生恰好有一门课不及格，输出1；否则输出0。
样例输入
50 80
样例输出
1

这题意思就是说,只要语文和数学其中一门成绩不及格,才输出1,否则就输出0. 所以我就想到了异或^:

aba^b
110
101
011
000

C语言实现

#include <stdio.h>

int main() {
    int chinese, math;
    scanf("%d %d", &chinese, &math);
    //a^b:当a和b同真或同假时，为false, 否则就为true
    if((chinese < 60) ^ (math < 60))
        printf("1");
    else
        printf("0");
    return 0;
}

Java实现

import java.util.Scanner;

/*给出一名学生的语文和数学成绩，判断他是否恰好有一门课不及格（成绩小于60分）。*/
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int chinese=sc.nextInt();
        int math=sc.nextInt();
        if((chinese<60&&math<60)||(math>=60&&chinese>=60)){
            System.out.println(0);
        }else {
            System.out.println(1);
        }
    }
}

11. 晶晶赴约会

总时间限制: 1000ms 内存限制: 65536kB
描述
晶晶的朋友贝贝约晶晶下周一起去看展览，但晶晶每周的1、3、5有课必须上课，请帮晶晶判断她能否接受贝贝的邀请，如果能输出YES；如果不能则输出NO。
输入
输入有一行，贝贝邀请晶晶去看展览的日期，用数字1到7表示从星期一到星期日。
输出
输出有一行，如果晶晶可以接受贝贝的邀请，输出YES，否则，输出NO。注意YES和NO都是大写字母！
样例输入
2
样例输出
YES

C语言实现

#include <stdio.h>

int main() {
    int day;
    scanf("%d", &day);
    if(day != 1 && day != 3 && day != 5)
        printf("YES");
    else
        printf("NO");
    return 0;
}

Java实现

import java.util.Scanner;

/*晶晶的朋友贝贝约晶晶下周一起去看展览，但晶晶每周的1、3、5有课必须上课，请帮晶晶判断她能否接受贝贝的邀请，如果能输出YES；如果不能则输出NO。*/
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        if(n!=1&&n!=3&&n!=5){
            System.out.println("YES");
        }else {
            System.out.println("NO");
        }
    }
}

12. 骑车与走路

总时间限制: 1000ms 内存限制: 65536kB
描述
在北大校园里,没有自行车,上课办事会很不方便.但实际上,并非去办任何事情都是骑车快,因为骑车总要找车、开锁、停车、锁车等,这要耽误一些时间.假设找到自行车,开锁并车上自行车的时间为27秒;停车锁车的时间为23秒;步行每秒行走1.2米,骑车每秒行走3.0米。请判断走不同的距离去办事,是骑车快还是走路快。
输入
输入一行，包含一个整数，表示一次办事要行走的距离,单位为米。
输出
输出一行,如果骑车快,输出一行"Bike";如果走路快,输出一行"Walk";如果一样快,输出一行"All"。
样例输入
120
样例输出
Bike

C语言实现

#include <stdio.h>

int main() {
    int distance;
    scanf("%d", &distance);
    //走路所花时间
    double walkCost = distance / 1.2;
    //骑车所花时间
    double bikeCost = distance / 3.0 + 27 + 23;
    if(walkCost > bikeCost)
        printf("Bike");
    else if(walkCost < bikeCost)
        printf("Walk");
    else
        printf("All");
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        //输入距离
        int s=sc.nextInt();
        //骑车所花的时间
        double bike=27+23+s/3.0;
        //走路所花时间
        double walk=s/1.2;
        if(bike>walk){
            System.out.println("Walk");
        }else if(bike==walk){
            System.out.println("All");
        }else {
            System.out.println("Bike");
        }
    }
}

13. 分段函数

总时间限制: 1000ms 内存限制: 65536kB
描述
编写程序，计算下列分段函数y=f(x)的值。
y=-x+2.5; 0 <= x < 5
y=2-1.5(x-3)(x-3); 5 <= x < 10
y=x/2-1.5; 10 <= x < 20
输入
一个浮点数N,0 <= N < 20
输出
输出N对应的分段函数值：f(N)。结果保留到小数点后三位。
样例输入
1.0
样例输出
1.500

C语言实现

#include <stdio.h>

int main() {
    double n;
    scanf("%lf", &n);
    if(n < 5)
        printf("%.3lf", -n + 2.5);
    else if(n < 10)
        printf("%.3lf", 2 - 1.5 * (n - 3) * (n - 3));
    else
        printf("%.3lf", n / 2 - 1.5);
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {
    public static double function(float x){
        if(x>=0&&x<5){
            return -x+2.5;
        }else if(x<10){
            return 2-1.5*(x-3)*(x-3);
        }else if(x<20){
            return x/2-1.5;
        }
        return 0;
    }

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        float x=sc.nextFloat();
        System.out.printf("%.3f",function(x));
    }
}

14. 计算邮资

总时间限制: 1000ms 内存限制: 65536kB
描述
根据邮件的重量和用户是否选择加急计算邮费。计算规则：重量在1000克以内(包括1000克), 基本费8元。超过1000克的部分，每500克加收超重费4元，不足500克部分按500克计算；如果用户选择加急，多收5元。
输入
输入一行，包含整数和一个字符，以一个空格分开，分别表示重量（单位为克）和是否加急。如果字符是y，说明选择加急；如果字符是n，说明不加急。
输出
输出一行，包含一个整数，表示邮费。
样例输入
1200 y
样例输出
17

C语言实现

#include <stdio.h>
#include <math.h>

int main() {
    int weight;
    char c;
    scanf("%d %c", &weight, &c);
    //邮费
    int postcost = 0;
    //计算基本邮费
    if(weight <= 1000)
        postcost += 8;
    else
        postcost = 8 + 4 * ceil((weight - 1000) * 1.0 / 500);
    //判断是否加急
    if(c == 'y')
        postcost += 5;
    printf("%d", postcost);
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {
    public static int post(int m){
        if(m<=1000){
            return 8;
        }else {
            return 8+(int)Math.ceil((m-1000.0)/500)*4;
        }
    }
    public static int urgency(String urg){
        if(urg.equals("y")){
            return 5;
        }
        return 0;
    }

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        String urg=sc.next();
        System.out.printf("%d",post(m)+urgency(urg));
    }
}

15. 最大数输出

总时间限制: 1000ms 内存限制: 65536kB
描述
输入三个整数,输出最大的数。
输入
输入为一行，包含三个整数，数与数之间以一个空格分开。
输出
输出一行，包含一个整数，即最大的整数。
样例输入
10 20 56
样例输出
56

C语言实现

#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    if(a > b){//此时a>b,所以只需要让c与a比
        if(a > c)
            printf("%d", a); //a为最大
        else
            printf("%d", c); //c为最大
    }else {//此时a<b，所以只需要让c与b比
        if(b > c)
            printf("%d", b);//b最大
        else 
            printf("%d", c);//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();
        if(a>b){
            System.out.println(Math.max(a, c));
        }else {
            System.out.println(Math.max(b, c));
        }
    }
}

16. 三角形判断

总时间限制: 1000ms 内存限制: 65536kB
描述
给定三个正整数，分别表示三条线段的长度，判断这三条线段能否构成一个三角形。
输入
输入共一行，包含三个正整数，分别表示三条线段的长度，数与数之间以一个空格分开。
输出
如果能构成三角形，则输出“yes” ，否则输出“no”。
样例输入
3 4 5
样例输出
yes

C语言实现

#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    //判断三条线段能否构成三角形，就是看任意两边之和是否都大于第三边
    if(a + b > c && a + c > b && b + c > a)
        printf("yes");
    else
        printf("no");
    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();
        if(a+b>c&&a+c>b&&b+c>a){
            System.out.println("yes");
        }else {
            System.out.println("no");
        }
    }
}

17. 判断闰年

总时间限制: 1000ms 内存限制: 65536kB
描述
判断某年是否是闰年。
输入
输入只有一行，包含一个整数a(0 < a < 3000)
输出
一行，如果公元a年是闰年输出Y，否则输出N
样例输入
2006
样例输出
N
提示
公历纪年法中，能被4整除的大多是闰年，但能被100整除而不能被400整除的年份不是闰年， 能被3200整除的也不是闰年，如1900年是平年，2000年是闰年，3200年不是闰年。

我们通常习惯于先考虑年份满足什么样的条件是闰年,所以一开始我们就会考虑判断a%4==0,满足这一条件就可能是闰年,然后再考虑能否被100整除且能被400整除…
这样考虑问题去写代码的话,就很可能会遗漏很多种情况,需要考虑很多种情况.这时,我们不妨反过来思考,我们先判断给定的年份是否为非闰年,如果都不满足非闰年的条件,那么这一年就肯定是闰年

C语言实现

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);
    //不能被4整除的不是闰年
    if(a % 4 != 0)
        printf("N");
    // 能被100整除而不能被400整除的年份不是闰年
    else if(a % 100 == 0 && a % 400 != 0)
        printf("N");
    //能被3200整除的也不是闰年
    else if(a % 3200 == 0)
        printf("N");
    //不满足以上条件的就是闰年
    else
        printf("Y");
    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();
        if(n%4!=0){
            System.out.println("N");
        }else if(n%100==0&&n%400!=0){
            System.out.println("N");
        }else if(n%3200==0){
            System.out.println("N");
        }else {
            System.out.println("Y");
        }
    }
}

18. 点和正方形的关系

总时间限制: 1000ms 内存限制: 65536kB
描述
有一个正方形，四个角的坐标（x,y)分别是（1，-1），（1，1），（-1，-1），（-1，1），x是横轴，y是纵轴。写一个程序，判断一个给定的点是否在这个正方形内（包括正方形边界）。
输入
输入一行，包括两个整数x、y，以一个空格分开，表示坐标(x,y)。
输出
输出一行，如果点在正方形内，则输出yes，否则输出no。
样例输入
1 1
样例输出
yes

C语言实现

#include <stdio.h>

int main(){
    int x, y;
    scanf("%d %d", &x, &y);
    if(x <= 1 && x >= -1 && y <= 1 && y >= -1)
        printf("yes");
    else
        printf("no");
    return 0;
}

Java实现

import java.util.Scanner;

/*有一个正方形，四个角的坐标（x,y)分别是（1，-1），（1，1），（-1，-1），（-1，1），x是横轴，y是纵轴。写一个程序，判断一个给定的点是否在这个正方形内（包括正方形边界）。*/
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int x=sc.nextInt();
        int y=sc.nextInt();
        if(x>=-1&&x<=1&&y>=-1&&y<=1){
            System.out.println("yes");
        }else {
            System.out.println("no");
        }
    }
}

19. 简单计算器

总时间限制: 1000ms 内存限制: 65536kB
描述
一个最简单的计算器，支持+, -, , / 四种运算。仅需考虑输入输出为整数的情况，数据和运算结果不会超过int表示的范围。
输入
输入只有一行，共有三个参数，其中第1、2个参数为整数，第3个参数为操作符（+,-,,/）。
输出
输出只有一行，一个整数，为运算结果。然而：

  1. 如果出现除数为0的情况，则输出：Divided by zero!
  2. 如果出现无效的操作符(即不为 +, -, *, / 之一），则输出：Invalid > operator!

样例输入
1 2 +
样例输出
3
提示
可以考虑使用if和switch结构

C语言实现

#include <stdio.h>

int main() {
    int a, b;
    char op;
    scanf("%d %d %c", &a, &b, &op);
    switch(op) {
        case '+':
            printf("%d", a + b);
            break;
        case '-':
            printf("%d", a - b);
            break;
        case '*':
            printf("%d", a * b);
            break;
        case '/':
            if(b == 0) printf("Divided by zero!");
            else printf("%d", a / b);
            break;
        default:
            printf("Invalid operator!\n");
            break;
    }
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {
    public static int add(int a,int b){
        return a+b;
    }
    public static int subtract(int a,int b){
        return a-b;
    }
    public static int multiply(int a,int b){
        return a*b;
    }
    public static Object divide(int a,int b){
        if(b==0){
            return "Divided by zero!";
        }
        return a/b;
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        String sm=sc.next();
        switch (sm) {
            case "+":
                System.out.println(add(a, b));
                break;
            case "-":
                System.out.println(subtract(a, b));
                break;
            case "*":
                System.out.println(multiply(a, b));
                break;
            case "/":
                System.out.println(divide(a, b));
                break;
            default:
                System.out.println("Invalid operator!");
                break;
        }
    }
}

20. 求一元二次方程的根

总时间限制: 1000ms 内存限制: 65536kB
描述
利用公式x1 = (-b + sqrt(bb-4ac))/(2a), x2 = (-b - sqrt(bb-4ac))/(2a)求一元二次方程ax2+ bx + c =0的根，其中a不等于0。
输入
输入一行，包含三个浮点数a, b, c（它们之间以一个空格分开），分别表示方程ax2 + bx + c =0的系数。
输出
输出一行，表示方程的解。
若b2 = 4 * a * c,则两个实根相等，则输出形式为：x1=x2=…。
若b2 > 4 * a * c,则两个实根不等，则输出形式为：x1=…;x2 = …，其中x1>x2。
若b2 < 4 * a * c，则有两个虚根，则输出：x1=实部+虚部i; x2=实部-虚部i，即x1的虚部系数大于等于x2的虚部系数，实部为0时不可省略。实部 = -b / (2a), 虚部 = sqrt(4ac-bb) / (2*a)
所有实数部分要求精确到小数点后5位，数字、符号之间没有空格。
样例输入

样例输入1
1.0 2.0 8.0
样例输入2
1 0 1

样例输出

样例输出1
x1=-1.00000+2.64575i;x2=-1.00000-2.64575i
样例输出2
x1=0.00000+1.00000i;x2=0.00000-1.00000i

C语言实现

#include <stdio.h>
#include <math.h>

int main() {
    double a, b, c;
    scanf("%lf %lf %lf", &a, &b, &c);
    //计算b^2-4*a*c
    double mid = b * b - 4.0 * a * c;
    //记录两个根的值
    double x1, x2;
    if(mid > 0){ //有两个不同的实根
        x1 = (-b + sqrt(mid)) / (2 * a);
        x2 = (-b - sqrt(mid)) / (2 * a);
        printf("x1=%.5lf;x2=%.5lf", x1, x2);
    }else if(mid == 0){//有两个相同的实根
        x1 = -b / (2 * a);
        printf("x1=x2=%.5lf", x1);
    }else{//有两个虚根
        double real = -b / (2 * a);//实部
        double imag = sqrt(-mid) / (2 * a); //虚部
        if(real == 0)
            real = 0;
        printf("x1=%.5lf+%.5lfi;x2=%.5lf-%.5lfi", real, imag, real, imag);
    }
    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.nextDouble();
        double b=sc.nextDouble();
        double c=sc.nextDouble();
        double D=b*b-4*a*c,x1,x2;
        if(D>0){
            x1=(-b+Math.sqrt(D))/(2*a);
            x2=(-b-Math.sqrt(D))/(2*a);
            System.out.printf("x1=%.5f;x2=%.5f",x1,x2);
        }else if(D==0){
            x1=x2=-b/(2*a);
            System.out.printf("x1=x2=%.5f",x1);
        }else {
            double A=-b/(2*a);
            double B=Math.sqrt(-D)/(2*a);
            if(A!=0) {
                System.out.printf("x1=%.5f+%.5fi;x2=%.5f-%.5fi", A, B, A, B);
            }else {
                A=0.0;
                System.out.printf("x1=%.5f+%.5fi;x2=%.5f-%.5fi",A,B,A,B);
            }
        }
    }
}

21. 苹果和虫子2

总时间限制: 1000ms 内存限制: 65536kB
描述
你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？
输入
输入仅一行，包括n，x和y（均为整数）。
输出
输出也仅一行，剩下的苹果个数
样例输入
10 4 9
样例输出
7
提示
注意：是要求完整的苹果数。

C语言实现

#include <stdio.h>
#include <math.h>

int main() {
    double n, x, y;
    scanf("%lf %lf %lf", &n, &x, &y);
    int remain = (int)floor(n - y / x);
    //如果求得remain为负数,那么就是苹果全部被吃完了
    if(remain < 0)
        remain = 0;
    printf("%d", remain);
    return 0;
}

Java实现

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        double n=sc.nextDouble();
        double x=sc.nextDouble();
        double y=sc.nextDouble();
        int m=(int) Math.floor(n-y/x);
        if(m<0){
            m=0;
        }
        System.out.printf("%d",m);
    }
}
Lilianac
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
1.4 编程基础之逻辑表达式与条件分支 python版.rar
11-20
1.4 编程基础之逻辑表达式与条件分支 python版.rar
OpenJudge NOI题库 1.4 编程基础之逻辑表达式与条件分支
青少年趣味编程
11-20 947
OpenJudge NOI题库 1.4 编程基础之逻辑表达式与条件分支
OpenJudge NOI 1.4编程基础之逻辑表达式与条件分支 C++ 解题思路
leleprogrammer的博客
10-03 3852
判断数正负输出绝对值奇偶数判断奇偶ASCII值判断整数大小比较判断是否为两位数收集瓶盖赢大奖判断一个数能否同时被3和5整除判断能否被3、5、7整除有一门课不及格的学生晶晶赴约会骑车与走路分段函数计算邮资最大数输出三角形判断判断闰年点和正方形的关系简单计算器。
NOI / 1.4编程基础之逻辑表达式与条件分支讲解-02:输出绝对值
绿树公司的博客
07-12 36
02:输出绝对值 总时间限制: 1000ms 内存限制: 65536kB 题目： 描述 输入一个浮点数，输出这个浮点数的绝对值。 输入 输入一个浮点数，其绝对值不超过10000。 输出 输出这个浮点数的绝对值，保留到小数点后两位。 样例输入 -3.14 样例输出 3.14 从题目中知道，我们要编一个输出绝对值的程序。 ...
1.4编程基础之逻辑表达式与条件分支 12 骑车与走路
青少年趣味编程
12-25 323
http://noi.openjudge.cn/ch0104/12/ /* 1.4编程基础之逻辑表达式与条件分支 12 骑车与走路--田承岭 http://noi.openjudge.cn/ch0104/12/ https://blog.csdn.net/yigezzchengxuyuan/article/details/86651658 */ #include <bits/stdc++.h> using namespace std; //http://noi.openjudge.cn/
108、1.4编程基础之逻辑表达式与条件分支_20求一元二次方程的根--2020.03.26a.pdf
05-08
108、1.4编程基础之逻辑表达式与条件分支_20求一元二次方程的根--2020.03.26a
1.4编程基础之逻辑表达式与条件分支(21题)--题目 有链接.pdf
06-09
1.4编程基础之逻辑表达式与条件分支(21题)--题目 有链接.pdf
1.4编程基础之逻辑表达式与条件分支_21苹果和虫子2
03-18
1.4编程基础之逻辑表达式与条件分支_21苹果和虫子2
1.4编程基础之逻辑表达式与条件分支_10有一门课不及格的学生(6分)--请改正
03-18
1.4编程基础之逻辑表达式与条件分支_10有一门课不及格的学生(6分)--请改正
【算法基础】第五章：动态规划
最新发布
m0_65787507的博客
04-24 482
DP：【1】状态表示：需要几个维度来表示状态（1）集合（所有选法，带有约束条件）（2）属性（最大值、最小值、数量）【2】状态计算：如何算出每一步的状态，对应集合的划分（不重+不漏）**DP的优化：**对代码/计算方程做变形。
力扣HOT100 - 543. 二叉树的直径
qq_61504864的博客
04-23 184
【代码】力扣HOT100 - 543. 二叉树的直径。
视频质量评价 BRISQUE算法详细介绍
小金牛来了
04-21 68
视频质量评价 BRISQUE算法详细介绍
【错题集-编程题】数组中的最长连续子序列（排序 + 模拟）
Elena's Blog
04-24 264
因为题目不要求位置连续，那么就可以直接想到排序（我把这一块理解错了，导致没有排序去做），接着就是简单的模拟。，然而实际上这道题目要求的是。小心处理数字相同的情况。
二分答案算法
2301_79980806的博客
04-21 1030
跟二分查找类似，当我们要找某个量的最值的时候，可以在这个两最小可能的取值，和最大可能的取值之间二分，来快速找到答案check函数为了验证中间值是否符合题目要求，根据是否来决定下一轮区间界限是作曲兼缩小，还是右区间缩小。
【Leetcode每日一题】 分治 - 数组中的第K个最大元素（难度⭐⭐）（63）
m0_73150338的博客
04-23 444
分治 - 数组中的第K个最大元素
【随想录】Day31—第八章 贪心算法 part01
weixin_44382896的博客
04-24 453
【代码】【随想录】Day31—第八章 贪心算法 part01。
【每日一题】377. 组合总和 Ⅳ-2024.4.22
weixin_45142381的博客
04-22 310
【每日一题】377. 组合总和 Ⅳ-2024.4.22
LeetCode39：组合总和
m0_50127633的博客
04-22 272
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。如果至少一个数字的被选数量不同，则两种组合是不同的。上个代码对于sum已经大于target的情况，其实是依然进入了下一层递归，只是下一层递归结束判断的时候，会判断sum > target的话就返回。对于给定的输入，保证和为 target 的不同组合数少于 150 个。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lilianac

你的鼓励是我的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值