Math.sqrt పద్ధతి - జావాలో స్క్వేర్ రూట్

సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ ఇంటర్వ్యూలకు జావాలో వర్గమూలాన్ని లెక్కించడం అంత సాధారణ ప్రశ్న కానప్పటికీ, కొన్నిసార్లు, ఒక ఇంటర్వ్యూ మిమ్మల్ని ఇలా అడగవచ్చు: “ మీకు పూర్ణాంకం x ఉంది. దాని వర్గమూలాన్ని లెక్కించే జావా ప్రోగ్రామ్‌ను సృష్టించండి”. అటువంటి ప్రాథమిక ప్రశ్న మిమ్మల్ని పట్టించుకోకుండా చూసుకోవడానికి, జావాలో స్క్వేర్ రూట్ ఎలా చేయాలో చూద్దాం.

స్క్వేర్ మరియు స్క్వేర్ రూట్: గణిత భావనలను సమీక్షించడం

చతురస్రాలు మరియు మూలాలతో వ్యవహరించేటప్పుడు మీకు గందరగోళం లేదని నిర్ధారించుకోవడానికి, ఈ భావన యొక్క సిద్ధాంతాన్ని సమీక్షిద్దాం. సంఖ్య యొక్క వర్గాన్ని దానితో గుణించిన సంఖ్య. n = 4 అయితే, అప్పుడు n^2 = 4 4 = 16. ఒక సంఖ్య యొక్క వర్గమూలం, దానితో గుణిస్తే, ఇచ్చిన విలువ Xని ఇస్తుంది. ఉదాహరణకు, మీరు n = వర్గమూలాన్ని కనుగొనాలి. 16, ఒక సంఖ్యను కనుగొనడం ద్వారా, రెండు యొక్క శక్తికి ఎలివేట్ చేస్తే 16 ఇస్తుంది, మీరు సమస్యను పరిష్కరిస్తారు. n విషయంలో, 16 సంఖ్య యొక్క వర్గమూలం 4 (4 * 4 = 16 నుండి).

java.lang.Math.sqrt()ని ఉపయోగించి జావాలో స్క్వేర్ రూట్ ఎలా చేయాలి

జావాలో సంఖ్య యొక్క వర్గమూలాన్ని కనుగొనడానికి అత్యంత సాధారణ మార్గం పద్ధతిని వర్తింపజేయడం java.lang.Math.sqrt(). java.lang.Math.sqrt() పద్ధతి యొక్క సాధారణ వాక్యనిర్మాణం ఇక్కడ ఉంది:

public static double sqrt(double a)

పద్ధతిలో, a అనేది మీరు వర్గమూలాన్ని పొందాలనుకునే రెండు శక్తికి ఎలివేట్ చేయబడిన విలువ. డెవలపర్ వర్తించే Onc java.lang.Math.sqrt(), పద్ధతి a యొక్క సానుకూల వర్గమూలాన్ని అందిస్తుంది (a అనేది 0 కంటే ఎక్కువ ఉంటే). ప్రతికూల వాదనల కోసం, java.lang.Math.sqrtNaN అవుట్‌పుట్‌ను అందిస్తుంది.

java.lang.Math.sqrt() యొక్క ప్రత్యేక కేసులు రిటర్న్‌లు

పైన చెప్పినట్లుగా, చాలా సందర్భాలలో, పద్ధతి సానుకూల విలువలను అందిస్తుంది. అయినప్పటికీ, రూట్-ఫైండింగ్ ప్రోగ్రామ్‌ను రూపొందించేటప్పుడు డెవలపర్ తెలుసుకోవలసిన కొన్ని నిర్దిష్ట సందర్భాలు ఉన్నాయి.

• NaN విలువలను కలిగి ఉన్న లేదా ప్రతికూలంగా ఉన్న ఆర్గ్యుమెంట్‌ల కోసం, పద్ధతి NaN ఫలితాన్ని అందిస్తుంది.
• అనంతంగా సానుకూలంగా ఉన్న వాదనల కోసం, పద్ధతి అనంతమైన సానుకూల ఫలితాన్ని అందిస్తుంది.
• ధనాత్మక లేదా ప్రతికూల సున్నాతో కూడిన ఆర్గ్యుమెంట్‌ల కోసం, a యొక్క వర్గమూలం a కి సమానం.

java.lang.Math.sqrt()ని ఉపయోగించే ఉదాహరణ

package MyPackage;
 
public class SquareRoot2 {
 
    public static void main(String args[])
    {
        double a = 100;
   
        System.out.println(Math.sqrt(a));
        // For positive values, the output is the square root of x 
   
        double b = -81.00;
   
        System.out.println(Math.sqrt(b));
        // For negative values as input, Output NaN 
   
        double c = 0.0/0;
        // Input NaN, Output NaN 
   
        System.out.println(Math.sqrt(c));
   
        double d = 1.0/0; 
        // For inputs containing  positive infinity, Output positive infinity  
   
        System.out.println(Math.sqrt(d));
         
        double e = 0.0;
        // Input positive Zero, Output positive zero 
         
        System.out.println(Math.sqrt(e));
    }
         
}

జావా ప్రాక్టీస్ సమస్యలో స్క్వేర్ రూట్‌లను కనుగొనడం

జావాలో వర్గమూలాలను లెక్కించే ప్రోగ్రామ్‌ను ఎలా సృష్టించాలో ఇప్పుడు మీకు తెలుసు, మరింత అధునాతన అభ్యాస సమస్యలకు భావన ఎలా సరిపోతుందో చూద్దాం. ఉదాహరణకు, ఒక ఇంటర్వ్యూయర్ మిమ్మల్ని క్వాడ్రాటిక్ సమీకరణాన్ని పరిష్కరించమని అడగవచ్చు. అటువంటి సమస్యను ఎలా ఎదుర్కోవాలో చూద్దాం. సమస్య: a = 1, b = 5, c = 2 అనే వర్గ సమీకరణాన్ని పరిష్కరించండి . పరిష్కారం:

import java.util.Scanner;
public class Exercise2 {

    
  public static void main(String[] Strings) {

        Scanner input = new Scanner(System.in);

            System.out.print("Input a: ");
            double a = input.nextDouble();
            System.out.print("Input b: ");
            double b = input.nextDouble();
            System.out.print("Input c: ");
            double c = input.nextDouble();

            double result = b * b - 4.0 * a * c;

            if (result > 0.0) {
                double r1 = (-b + Math.pow(result, 0.5)) / (2.0 * a);
                double r2 = (-b - Math.pow(result, 0.5)) / (2.0 * a);
                System.out.println("The roots are " + r1 + " and " + r2);
            } else if (result == 0.0) {
                double r1 = -b / (2.0 * a);
                System.out.println("The square root is " + r1);
            } else {
                System.out.println("There are no real square roots in the equation.");
            }

    }
}

ముగింపు

ఇది జావాలో సంఖ్య యొక్క వర్గమూలాన్ని కనుగొనడంలో సంక్షిప్త వివరణ. సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ బిగినర్స్ కోసం, కాన్సెప్ట్‌పై గట్టి పట్టును పొందడానికి విభిన్న దృశ్యాలను (a>0, a<0, a = 0) సాధన చేయడం మంచిది. మీరు java.lang.Math.sqrt పద్ధతి యొక్క ఇన్‌లు మరియు అవుట్‌లను అర్థం చేసుకున్న తర్వాత, సంక్లిష్ట ప్రోగ్రామ్‌లలో పద్ధతిని వర్తింపజేయడం, వర్గ సమీకరణాలను పరిష్కరించడం వంటి పనులను నిర్వహించడం ప్రారంభించండి.