求二次方程根的程序-yiteyi-C++库

给出一个形式为ax的二次方程 ^2. +bx+c，找到它的根。

null

图片[1]-求二次方程根的程序-yiteyi-C++库

例如：

Input  :  a = 1, b = -2, c = 1Output :  Roots are real and same          1Input  :  a = 1, b = 7, c = 12Output :  Roots are real and different          -3, -4Input  :  a = 1, b = 1, c = 1Output :  Roots are complex           -0.5 + i1.73205          -0.5 - i1.73205

建议：请在“上解决” 实践 “首先，在讨论解决方案之前。

下面是求二次方程根的直接公式。

$x=frac{-bpm sqrt{b^2-4ac}}{2a}$

以下是一些重要的案例。

If b*b < 4*a*c, then roots are complex(not real).For example roots of x² + x + 1, roots are-0.5 + i1.73205 and -0.5 - i1.73205If b*b == 4*a*c, then roots are real and both roots are same.For example, roots of x² - 2x + 1 are 1 and 1If b*b > 4*a*c, then roots are real and different.For example, roots of x² - 7x - 12 are 3 and 4

下面是上述公式的实现。

C

                         /* C program to find roots of a quadratic equation */                       
                         #include <math.h>                       
                         #include <stdio.h>                       
                         #include <stdlib.h>                       
           
                         // Prints roots of quadratic equation ax*2 + bx + x                       
                         void                                     findRoots(                                     int                                     a,                                     int                                     b,                                     int                                     c)                       
                         {                       
                                                 // If a is 0, then equation is not quadratic, but                       
                                                 // linear                       
                                                 if                                     (a == 0) {                       
                                                 printf                                     (                                     "Invalid"                                     );                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 int                                     d = b * b - 4 * a * c;                       
                                                 double                                     sqrt_val =                                     sqrt                                     (                                     abs                                     (d));                       
           
                                                 if                                     (d > 0) {                       
                                                 printf                                     (                                     "Roots are real and different "                                     );                       
                                                 printf                                     (                                     "%f%f"                                     , (                                     double                                     )(-b + sqrt_val) / (2 * a),                       
                                                 (                                     double                                     )(-b - sqrt_val) / (2 * a));                       
                                                 }                       
                                                 else                                     if                                     (d == 0) {                       
                                                 printf                                     (                                     "Roots are real and same "                                     );                       
                                                 printf                                     (                                     "%f"                                     , -(                                     double                                     )b / (2 * a));                       
                                                 }                       
                                                 else                                     // d < 0                       
                                                 {                       
                                                 printf                                     (                                     "Roots are complex "                                     );                       
                                                 printf                                     (                                     "%f + i%f%f - i%f"                                     , -(                                     double                                     )b / (2 * a),                       
                                                 sqrt_val/(2 * a), -(                                     double                                     )b / (2 * a), sqrt_val/(2 * a);                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 int                                     a = 1, b = -7, c = 12;                       
                                   
                                                 // Function call                       
                                                 findRoots(a, b, c);                       
                                                 return                                     0;                       
                         }                       

C++

                         /* C++ program to find roots of a quadratic equation */                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Prints roots of quadratic equation ax*2 + bx + x                       
                         void                                     findRoots(                                     int                                     a,                                     int                                     b,                                     int                                     c)                       
                         {                       
                                                 // If a is 0, then equation is not quadratic, but                       
                                                 // linear                       
                                                 if                                     (a == 0) {                       
                                                 cout <<                                     "Invalid"                                     ;                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 int                                     d = b * b - 4 * a * c;                       
                                                 double                                     sqrt_val =                                     sqrt                                     (                                     abs                                     (d));                       
           
                                                 if                                     (d > 0) {                       
                                                 cout <<                                     "Roots are real and different "                                     ;                       
                                                 cout << (                                     double                                     )(-b + sqrt_val) / (2 * a) <<                                     ""                       
                                                 << (                                     double                                     )(-b - sqrt_val) / (2 * a);                       
                                                 }                       
                                                 else                                     if                                     (d == 0) {                       
                                                 cout <<                                     "Roots are real and same "                                     ;                       
                                                 cout << -(                                     double                                     )b / (2 * a);                       
                                                 }                       
                                                 else                                     // d < 0                       
                                                 {                       
                                                 cout <<                                     "Roots are complex "                                     ;                       
                                                 cout << -(                                     double                                     )b / (2 * a) <<                                     " + i"                                     << sqrt_val                       
                                                 <<                                     ""                       
                                                 << -(                                     double                                     )b / (2 * a) <<                                     " - i"                                     << sqrt_val;                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 int                                     a = 1, b = -7, c = 12;                       
                                   
                                                 // Function call                       
                                                 findRoots(a, b, c);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to find roots                       
                         // of a quadratic equation                       
           
                         import                                     java.io.*;                       
                         import                                     static                                     java.lang.Math.*;                       
                         class                                     Quadratic {                       
           
                                                 // Prints roots of quadratic                       
                                                 // equation ax * 2 + bx + x                       
                                                 static                                     void                                     findRoots(                                     int                                     a,                                     int                                     b,                                     int                                     c)                       
                                                 {                       
                                                 // If a is 0, then equation is not                       
                                                 // quadratic, but linear                       
           
                                                 if                                     (a ==                                     0                                     ) {                       
                                                 System.out.println(                                     "Invalid"                                     );                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 int                                     d = b * b -                                     4                                     * a * c;                       
                                                 double                                     sqrt_val = sqrt(abs(d));                       
           
                                                 if                                     (d >                                     0                                     ) {                       
                                                 System.out.println(                       
                                                 "Roots are real and different "                                     );                       
           
                                                 System.out.println(                       
                                                 (                                     double                                     )(-b + sqrt_val) / (                                     2                                     * a) +                                     ""                       
                                                 + (                                     double                                     )(-b - sqrt_val) / (                                     2                                     * a));                       
                                                 }                       
                                                 else                                     if                                     (d ==                                     0                                     ) {                       
                                                 System.out.println(                       
                                                 "Roots are real and same "                                     );                       
           
                                                 System.out.println(-(                                     double                                     )b / (                                     2                                     * a) +                                     ""                       
                                                 + -(                                     double                                     )b / (                                     2                                     * a));                       
                                                 }                       
                                                 else                                     // d < 0                       
                                                 {                       
                                                 System.out.println(                                     "Roots are complex "                                     );                       
           
                                                 System.out.println(-(                                     double                                     )b / (                                     2                                     * a) +                                     " + i"                       
                                                 + sqrt_val +                                     ""                       
                                                 + -(                                     double                                     )b / (                                     2                                     * a)                       
                                                 +                                     " - i"                                     + sqrt_val);                       
                                                 }                       
                                                 }                       
           
                                                 // Driver code                       
                                                 public                                     static                                     void                                     main(String args[])                       
                                                 {                       
           
                                                 int                                     a =                                     1                                     , b = -                                     7                                     , c =                                     12                                     ;                       
                                   
                                                 // Function call                       
                                                 findRoots(a, b, c);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Sumit Kumar.                       

Python3

                         # Python program to find roots                       
                         # of a quadratic equation                       
                         import                                     math                       
           
                         # Prints roots of quadratic equation                       
                         # ax*2 + bx + x                       
           
           
                         def                                     findRoots(a, b, c):                       
           
                                                 # If a is 0, then equation is                       
                                                 # not quadratic, but linear                       
                                                 if                                     a                                     =                                     =                                     0                                     :                       
                                                 print                                     (                                     "Invalid"                                     )                       
                                                 return                                     -                                     1                       
                                                 d                                     =                                     b                                     *                                     b                                     -                                     4                                     *                                     a                                     *                                     c                       
                                                 sqrt_val                                     =                                     math.sqrt(                                     abs                                     (d))                       
           
                                                 if                                     d >                                     0                                     :                       
                                                 print                                     (                                     "Roots are real and different "                                     )                       
                                                 print                                     ((                                     -                                     b                                     +                                     sqrt_val)                                     /                                     (                                     2                                     *                                     a))                       
                                                 print                                     ((                                     -                                     b                                     -                                     sqrt_val)                                     /                                     (                                     2                                     *                                     a))                       
                                                 elif                                     d                                     =                                     =                                     0                                     :                       
                                                 print                                     (                                     "Roots are real and same"                                     )                       
                                                 print                                     (                                     -                                     b                                     /                                     (                                     2                                     *                                     a))                       
                                                 else                                     :                                     # d<0                       
                                                 print                                     (                                     "Roots are complex"                                     )                       
                                                 print                                     (                                     -                                     b                                     /                                     (                                     2                                     *                                     a),                                     " + i"                                     , sqrt_val)                       
                                                 print                                     (                                     -                                     b                                     /                                     (                                     2                                     *                                     a),                                     " - i"                                     , sqrt_val)                       
           
           
                         # Driver Program                       
                         a                                     =                                     1                       
                         b                                     =                                     -                                     7                       
                         c                                     =                                     12                       
           
                         # Function call                       
                         findRoots(a, b, c)                       
           
                         # This code is contributed by Sharad Bhardwaj.                       

C#

                         // C# program to find roots                       
                         // of a quadratic equation                       
                         using                                     System;                       
           
                         class                                     Quadratic {                       
           
                                                 // Prints roots of quadratic                       
                                                 // equation ax * 2 + bx + x                       
                                                 void                                     findRoots(                                     int                                     a,                                     int                                     b,                                     int                                     c)                       
                                                 {                       
           
                                                 // If a is 0, then equation is                       
                                                 // not quadratic, but linear                       
           
                                                 if                                     (a == 0) {                       
                                                 Console.Write(                                     "Invalid"                                     );                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 int                                     d = b * b - 4 * a * c;                       
                                                 double                                     sqrt_val = Math.Abs(d);                       
           
                                                 if                                     (d > 0) {                       
                                                 Console.Write(                       
                                                 "Roots are real and different "                                     );                       
           
                                                 Console.Write(                       
                                                 (                                     double                                     )(-b + sqrt_val) / (2 * a) +                                     ""                       
                                                 + (                                     double                                     )(-b - sqrt_val) / (2 * a));                       
                                                 }                       
           
                                                 // d < 0                       
                                                 else                                     {                       
                                                 Console.Write(                                     "Roots are complex "                                     );                       
           
                                                 Console.Write(-(                                     double                                     )b / (2 * a) +                                     " + i"                       
                                                 + sqrt_val +                                     ""                       
                                                 + -(                                     double                                     )b / (2 * a) +                                     " - i"                       
                                                 + sqrt_val);                       
                                                 }                       
                                                 }                       
           
                                                 // Driver code                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 Quadratic obj =                                     new                                     Quadratic();                       
                                                 int                                     a = 1, b = -7, c = 12;                       
                                   
                                                 // Function call                       
                                                 obj.findRoots(a, b, c);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by nitin mittal.                       

PHP

                         <?php                       
                         // PHP program to find roots                       
                         // of a quadratic equation                       
           
                         // Prints roots of quadratic                       
                         // equation ax*2 + bx + x                       
                         function                                     findRoots(                                     $a                                     ,                                     $b                                     ,                                     $c                                     )                       
                         {                       
                                                 // If a is 0, then equation is                       
                                                 // not quadratic, but linear                       
                                                 if                                     (                                     $a                                     == 0)                       
                                                 {                       
                                                 echo                                     "Invalid"                                     ;                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 $d                                     =                                     $b                                     *                                     $b                                     - 4 *                                     $a                                     *                                     $c                                     ;                       
                                                 $sqrt_val                                     = sqrt(                                     abs                                     (                                     $d                                     ));                       
           
                                                 if                                     (                                     $d                                     > 0)                       
                                                 {                       
                                                 echo                                     "Roots are real and "                                     .                       
                                                 "different "                                     ;                       
                                                 echo                                     (-                                     $b                                     +                                     $sqrt_val                                     ) / (2 *                                     $a                                     ) ,                                     ""                                     ,                       
                                                 (-                                     $b                                     -                                     $sqrt_val                                     ) / (2 *                                     $a                                     );                       
                                                 }                       
                                                 else                                     if                                     (                                     $d                                     == 0)                       
                                                 {                       
                                                 echo                                     "Roots are real and same "                                     ;                       
                                                 echo                                     -                                     $b                                     / (2 *                                     $a                                     );                       
                                                 }                       
                                   
                                                 // d < 0                       
                                                 else                       
                                                 {                       
                                                 echo                                     "Roots are complex "                                     ;                       
                                                 echo                                     -                                     $b                                     / (2 *                                     $a                                     ) ,                                     " + i"                                     ,                       
                                                 $sqrt_val                                     ,                                     ""                                     , -                                     $b                                     / (2 *                                     $a                                     ),                       
                                                 " - i"                                     ,                                     $sqrt_val                                     ;                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         $a                                     = 1;                                     $b                                     = -7 ;                                     $c                                     = 12;                       
           
                         // Function call                       
                         findRoots(                                     $a                                     ,                                     $b                                     ,                                     $c                                     );                       
           
                         // This code is contributed                       
                         // by nitin mittal.                       
                         ?>                       

Javascript

                         <script>                       
           
                         // JavaScript program to find roots                       
                         // of a quadratic equation                       
           
                                                 // Prints roots of quadratic                       
                                                 // equation ax * 2 + bx + x                       
                                                 function                                     findRoots(a, b, c)                       
                                                 {                       
                                                 // If a is 0, then equation is not                       
                                                 // quadratic, but linear                       
                                   
                                                 if                                     (a == 0) {                       
                                                 document.write(                                     "Invalid"                                     );                       
                                                 return                                     ;                       
                                                 }                       
                                   
                                                 let d = b * b - 4 * a * c;                       
                                                 let sqrt_val = Math.sqrt(Math.abs(d));                       
                                   
                                                 if                                     (d > 0) {                       
                                                 document.write(                       
                                                 "Roots are real and different "                                     +                                     "<br/>"                                     );                       
                                   
                                                 document.write(                       
                                                 (-b + sqrt_val) / (2 * a) +                                     "<br/>"                       
                                                 + (-b - sqrt_val) / (2 * a));                       
                                                 }                       
                                                 else                                     if                                     (d == 0) {                       
                                                 document.write(                       
                                                 "Roots are real and same "                                     +                                     "<br/>"                                     );                       
                                   
                                                 document.write(-b / (2 * a) +                                     "<br/>"                       
                                                 + -b / (2 * a)) ;                       
                                                 }                       
                                                 else                                     // d < 0                       
                                                 {                       
                                                 document.write(                                     "Roots are complex "                                     );                       
                                   
                                                 document.write(-b / (2 * a) +                                     " + i"                       
                                                 + sqrt_val +                                     "<br/>"                       
                                                 + -b / (2 * a)                       
                                                 +                                     " - i"                                     + sqrt_val);                       
                                                 }                       
                                                 }                       
           
                         // Driver Code                       
           
                                                 let a = 1, b = -7, c = 12;                       
                                   
                                                 // Function call                       
                                                 findRoots(a, b, c);                       
           
                         </script>                       

输出

Roots are real and different 4.0000003.000000

本文由 德埃拉吉·古普塔 。如果您发现任何不正确的地方，请写下评论，或分享有关上述主题的更多信息。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章