从给定的斜边和面积|集1中找出直角三角形的所有边-yiteyi-C++库

给定直角三角形的斜边和面积，求出它的底边和高度，如果任何三角形不能给定斜边和面积，就不能打印。 例如：

null

Input  : hypotenuse = 5,    area = 6Output : base = 3, height = 4Input : hypotenuse = 5, area = 7 Output : No triangle possible with above specification.

hypotenuse

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

我们可以用直角三角形的一个性质来解决这个问题，可以这样说：，

A right angle triangle with fixed hypotenuse attainsmaximum area, when it is isosceles i.e. both heightand base becomes equal so if hypotenuse if H, then by pythagorean theorem,Base² + Height² = H²For maximum area both base and height should be equal, b² + b² = H²b = sqrt(H²/2)Above is the length of base at which triangle attainsmaximum area, given area must be less than this maximumarea, otherwise no such triangle will possible.

如果给定的面积小于这个最大面积，我们可以对基的长度进行二元搜索，因为增加基会增加面积，这是一个单调递增的函数，可以很容易地应用二元搜索。在下面的代码中，编写了一种获取直角三角形面积的方法，回想一下，对于直角三角形，面积是½*基底*高度，高度可以使用毕达哥拉斯定理 . 以下是上述方法的实施情况：

C++

                         // C++ program to get right angle triangle, given                       
                         // hypotenuse and area of triangle                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
                                   
                         //  limit for float comparison                       
                         #define eps 1e-6                       
                                   
                         // Utility method to get area of right angle triangle,                       
                         // given base and hypotenuse                       
                         double                                     getArea(                                     double                                     base,                                     double                                     hypotenuse)                       
                         {                       
                                                 double                                     height =                                     sqrt                                     (hypotenuse*hypotenuse - base*base);                       
                                                 return                                     0.5 * base * height;                       
                         }                       
                                   
                         // Prints base and height of triangle using hypotenuse                       
                         // and area information                       
                         void                                     printRightAngleTriangle(                                     int                                     hypotenuse,                                     int                                     area)                       
                         {                       
                                                 int                                     hsquare = hypotenuse * hypotenuse;                       
                                   
                                                 // maximum area will be obtained when base and height                       
                                                 // are equal (= sqrt(h*h/2))                       
                                                 double                                     sideForMaxArea =                                     sqrt                                     (hsquare / 2.0);                       
                                                 double                                     maxArea = getArea(sideForMaxArea, hypotenuse);                       
                                   
                                                 // if given area itself is larger than maxArea then no                       
                                                 // solution is possible                       
                                                 if                                     (area > maxArea)                       
                                                 {                       
                                                 cout <<                                     "Not possiblen"                                     ;                       
                                                 return                                     ;                       
                                                 }                       
                                   
                                                 double                                     low = 0.0;                       
                                                 double                                     high = sideForMaxArea;                       
                                                 double                                     base;                       
                                   
                                                 // binary search for base                       
                                                 while                                     (                                     abs                                     (high - low) > eps)                       
                                                 {                       
                                                 base = (low + high) / 2.0;                       
                                                 if                                     (getArea(base, hypotenuse) >= area)                       
                                                 high = base;                       
                                                 else                       
                                                 low = base;                       
                                                 }                       
                                   
                                                 // get height by pythagorean rule                       
                                                 double                                     height =                                     sqrt                                     (hsquare - base*base);                       
                                                 cout << base <<                                     " "                                     << height << endl;                       
                         }                       
                                   
                         // Driver code to test above methods                       
                         int                                     main()                       
                         {                       
                                                 int                                     hypotenuse = 5;                       
                                                 int                                     area = 6;                       
                                   
                                                 printRightAngleTriangle(hypotenuse, area);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to get right angle triangle, given                       
                         // hypotenuse and area of triangle                       
                         public                                     class                                     GFG {                       
           
                         // limit for float comparison                       
                                                 final                                     static                                     double                                     eps = (                                     double                                     ) 1e-                                     6                                     ;                       
           
                         // Utility method to get area of right angle triangle,                       
                         // given base and hypotenuse                       
                                                 static                                     double                                     getArea(                                     double                                     base,                                     double                                     hypotenuse) {                       
                                                 double                                     height = Math.sqrt(hypotenuse * hypotenuse - base * base);                       
                                                 return                                     0.5                                     * base * height;                       
                                                 }                       
           
                         // Prints base and height of triangle using hypotenuse                       
                         // and area information                       
                                                 static                                     void                                     printRightAngleTriangle(                                     int                                     hypotenuse,                                     int                                     area) {                       
                                                 int                                     hsquare = hypotenuse * hypotenuse;                       
           
                                                 // maximum area will be obtained when base and height                       
                                                 // are equal (= sqrt(h*h/2))                       
                                                 double                                     sideForMaxArea = Math.sqrt(hsquare /                                     2.0                                     );                       
                                                 double                                     maxArea = getArea(sideForMaxArea, hypotenuse);                       
           
                                                 // if given area itself is larger than maxArea then no                       
                                                 // solution is possible                       
                                                 if                                     (area > maxArea) {                       
                                                 System.out.print(                                     "Not possible"                                     );                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 double                                     low =                                     0.0                                     ;                       
                                                 double                                     high = sideForMaxArea;                       
                                                 double                                     base =                                     0                                     ;                       
           
                                                 // binary search for base                       
                                                 while                                     (Math.abs(high - low) > eps) {                       
                                                 base = (low + high) /                                     2.0                                     ;                       
                                                 if                                     (getArea(base, hypotenuse) >= area) {                       
                                                 high = base;                       
                                                 }                                     else                                     {                       
                                                 low = base;                       
                                                 }                       
                                                 }                       
           
                                                 // get height by pythagorean rule                       
                                                 double                                     height = Math.sqrt(hsquare - base * base);                       
                                                 System.out.println(Math.round(base) +                                     " "                                     + Math.round(height));                       
                                                 }                       
           
                         // Driver code to test above methods                       
                                                 static                                     public                                     void                                     main(String[] args) {                       
                                                 int                                     hypotenuse =                                     5                                     ;                       
                                                 int                                     area =                                     6                                     ;                       
           
                                                 printRightAngleTriangle(hypotenuse, area);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by 29AjayKumar                       

Python3

                         # Python 3 program to get right angle triangle, given                       
                         # hypotenuse and area of triangle                       
           
                         # limit for float comparison                       
                         # define eps 1e-6                       
                         import                                     math                       
           
                         # Utility method to get area of right angle triangle,                       
                         # given base and hypotenuse                       
                         def                                     getArea(base, hypotenuse):                       
                                                 height                                     =                                     math.sqrt(hypotenuse                                     *                                     hypotenuse                                     -                                     base                                     *                                     base);                       
                                                 return                                     0.5                                     *                                     base                                     *                                     height                       
           
                         # Prints base and height of triangle using hypotenuse                       
                         # and area information                       
                         def                                     printRightAngleTriangle(hypotenuse, area):                       
                                                 hsquare                                     =                                     hypotenuse                                     *                                     hypotenuse                       
           
                                                 # maximum area will be obtained when base and height                       
                                                 # are equal (= sqrt(h*h/2))                       
                                                 sideForMaxArea                                     =                                     math.sqrt(hsquare                                     /                                     2.0                                     )                       
                                                 maxArea                                     =                                     getArea(sideForMaxArea, hypotenuse)                       
           
                                                 # if given area itself is larger than maxArea then no                       
                                                 # solution is possible                       
                                                 if                                     (area > maxArea):                       
                                                 print                                     (                                     "Not possiblen"                                     )                       
                                                 return                       
                                   
                                                 low                                     =                                     0.0                       
                                                 high                                     =                                     sideForMaxArea                       
                                   
                                                 # binary search for base                       
                                                 while                                     (                                     abs                                     (high                                     -                                     low) >                                     1e                                     -                                     6                                     ):                       
                                                 base                                     =                                     (low                                     +                                     high)                                     /                                     2.0                       
                                                 if                                     (getArea(base, hypotenuse) >                                     =                                     area):                       
                                                 high                                     =                                     base                       
                                                 else                                     :                       
                                                 low                                     =                                     base                       
                                   
                                                 # get height by pythagorean rule                       
                                                 height                                     =                                     math.ceil(math.sqrt(hsquare                                     -                                     base                                     *                                     base))                       
                                                 base                                     =                                     math.floor(base)                       
                                                 print                                     (base,height)                       
           
                         # Driver code to test above methods                       
                         if                                     __name__                                     =                                     =                                     '__main__'                                     :                       
                                                 hypotenuse                                     =                                     5                       
                                                 area                                     =                                     6                       
           
                                                 printRightAngleTriangle(hypotenuse, area)                       
           
                         # This code is contributed by                       
                         # Surendra_Gangwar                       

C#

                         // C# program to get right angle triangle, given                       
                         // hypotenuse and area of triangle                       
           
                         using                                     System;                       
                         public                                     class                                     GFG{                       
           
           
                         // limit for float comparison                       
                                                 static                                     double                                     eps = (                                     double                                     ) 1e-6;                       
           
                         // Utility method to get area of right angle triangle,                       
                         // given base and hypotenuse                       
                                                 static                                     double                                     getArea(                                     double                                     base1,                                     double                                     hypotenuse) {                       
                                                 double                                     height = Math.Sqrt(hypotenuse * hypotenuse - base1 * base1);                       
                                                 return                                     0.5 * base1 * height;                       
                                                 }                       
           
                         // Prints base and height of triangle using hypotenuse                       
                         // and area information                       
                                                 static                                     void                                     printRightAngleTriangle(                                     int                                     hypotenuse,                                     int                                     area) {                       
                                                 int                                     hsquare = hypotenuse * hypotenuse;                       
           
                                                 // maximum area will be obtained when base and height                       
                                                 // are equal (= sqrt(h*h/2))                       
                                                 double                                     sideForMaxArea = Math.Sqrt(hsquare / 2.0);                       
                                                 double                                     maxArea = getArea(sideForMaxArea, hypotenuse);                       
           
                                                 // if given area itself is larger than maxArea then no                       
                                                 // solution is possible                       
                                                 if                                     (area > maxArea) {                       
                                                 Console.Write(                                     "Not possible"                                     );                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 double                                     low = 0.0;                       
                                                 double                                     high = sideForMaxArea;                       
                                                 double                                     base1 = 0;                       
           
                                                 // binary search for base                       
                                                 while                                     (Math.Abs(high - low) > eps) {                       
                                                 base1 = (low + high) / 2.0;                       
                                                 if                                     (getArea(base1, hypotenuse) >= area) {                       
                                                 high = base1;                       
                                                 }                                     else                                     {                       
                                                 low = base1;                       
                                                 }                       
                                                 }                       
           
                                                 // get height by pythagorean rule                       
                                                 double                                     height = Math.Sqrt(hsquare - base1 * base1);                       
                                                 Console.WriteLine(Math.Round(base1) +                                     " "                                     + Math.Round(height));                       
                                                 }                       
           
                         // Driver code to test above methods                       
                                                 static                                     public                                     void                                     Main() {                       
                                                 int                                     hypotenuse = 5;                       
                                                 int                                     area = 6;                       
           
                                                 printRightAngleTriangle(hypotenuse, area);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by 29AjayKumar                       

PHP

                         <?php                       
                         // PHP program to get right angle triangle,                       
                         // given hypotenuse and area of triangle                       
           
                         // limit for float comparison                       
                         $eps                                     =.0000001;                       
           
                         // Utility method to get area of right                       
                         // angle triangle, given base and hypotenuse                       
                         function                                     getArea(                                     $base                                     ,                                     $hypotenuse                                     )                       
                         {                       
                                                 $height                                     = sqrt(                                     $hypotenuse                                     *                                     $hypotenuse                                     -                       
                                                 $base                                     *                                     $base                                     );                       
                                                 return                                     0.5 *                                     $base                                     *                                     $height                                     ;                       
                         }                       
           
                         // Prints base and height of triangle                       
                         // using hypotenuse and area information                       
                         function                                     printRightAngleTriangle(                                     $hypotenuse                                     ,                       
                                                 $area                                     )                       
                         {                       
                                                 global                                     $eps                                     ;                       
                                                 $hsquare                                     =                                     $hypotenuse                                     *                                     $hypotenuse                                     ;                       
           
                                                 // maximum area will be obtained when base                       
                                                 // and height are equal (= sqrt(h*h/2))                       
                                                 $sideForMaxArea                                     = sqrt(                                     $hsquare                                     / 2.0);                       
                                                 $maxArea                                     = getArea(                                     $sideForMaxArea                                     ,                       
                                                 $hypotenuse                                     );                       
           
                                                 // if given area itself is larger than                       
                                                 // maxArea then no solution is possible                       
                                                 if                                     (                                     $area                                     >                                     $maxArea                                     )                       
                                                 {                       
                                                 echo                                     "Not possiblen"                                     ;                       
                                                 return                                     ;                       
                                                 }                       
           
                                                 $low                                     = 0.0;                       
                                                 $high                                     =                                     $sideForMaxArea                                     ;                       
                                                 $base                                     ;                       
           
                                                 // binary search for base                       
                                                 while                                     (                                     abs                                     (                                     $high                                     -                                     $low                                     ) >                                     $eps                                     )                       
                                                 {                       
                                                 $base                                     = (                                     $low                                     +                                     $high                                     ) / 2.0;                       
                                                 if                                     (getArea(                                     $base                                     ,                                     $hypotenuse                                     ) >=                                     $area                                     )                       
                                                 $high                                     =                                     $base                                     ;                       
                                                 else                       
                                                 $low                                     =                                     $base                                     ;                       
                                                 }                       
           
                                                 // get height by pythagorean rule                       
                                                 $height                                     = sqrt(                                     $hsquare                                     -                                     $base                                     *                                     $base                                     );                       
                                                 echo                                     (                                     ceil                                     (                                     $base                                     )) ,                                     " "                                     ,                       
                                                 (                                     floor                                     (                                     $height                                     )),                                     ""                                     ;                       
                         }                       
           
                         // Driver Code                       
                         $hypotenuse                                     = 5;                       
                         $area                                     = 6;                       
           
                         printRightAngleTriangle(                                     $hypotenuse                                     ,                                     $area                                     );                       
           
                         // This code is contributed by Sachin                       
                         ?>                       

Javascript

                         <script>                       
           
                         // JavaScript program to get right angle triangle, given                       
                         // hypotenuse and area of triangle                       
           
                         // limit for float comparison                       
                                                 let eps =  1e-6;                       
                                   
                         // Utility method to get area of right angle triangle,                       
                         // given base and hypotenuse                       
                                                 function                                     getArea(base, hypotenuse) {                       
                                                 let height = Math.sqrt(hypotenuse * hypotenuse - base * base);                       
                                                 return                                     0.5 * base * height;                       
                                                 }                       
                                   
                         // Prints base and height of triangle using hypotenuse                       
                         // and area information                       
                                                 function                                     printRightAngleTriangle(hypotenuse, area) {                       
                                                 let hsquare = hypotenuse * hypotenuse;                       
                                   
                                                 // maximum area will be obtained when base and height                       
                                                 // are equal (= sqrt(h*h/2))                       
                                                 let sideForMaxArea = Math.sqrt(hsquare / 2.0);                       
                                                 let maxArea = getArea(sideForMaxArea, hypotenuse);                       
                                   
                                                 // if given area itself is larger than maxArea then no                       
                                                 // solution is possible                       
                                                 if                                     (area > maxArea) {                       
                                                 document.write(                                     "Not possible"                                     );                       
                                                 return                                     ;                       
                                                 }                       
                                   
                                                 let low = 0.0;                       
                                                 let high = sideForMaxArea;                       
                                                 let base = 0;                       
                                   
                                                 // binary search for base                       
                                                 while                                     (Math.abs(high - low) > eps) {                       
                                                 base = (low + high) / 2.0;                       
                                                 if                                     (getArea(base, hypotenuse) >= area) {                       
                                                 high = base;                       
                                                 }                                     else                                     {                       
                                                 low = base;                       
                                                 }                       
                                                 }                       
                                   
                                                 // get height by pythagorean rule                       
                                                 let height = Math.sqrt(hsquare - base * base);                       
                                                 document.write(Math.round(base) +                                     " "                                     + Math.round(height));                       
                                                 }                       
                                   
                         // Driver Code                       
                                                 let hypotenuse = 5;                       
                                                 let area = 6;                       
                                   
                                                 printRightAngleTriangle(hypotenuse, area);                       
           
                         // This code is contributed by chinmoy1997pal.                       
                         </script>                       

输出：

3 4

另一个解决方案将在下面的帖子中讨论。检查给定区域和斜边是否可能成直角本文由 乌特卡什·特里维迪 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

技术文章