ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್
ಲೀಟ್‌ಕೋಡ್

ಈ ಪೋಸ್ಟ್ ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿದೆ

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

“ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್” ಸಮಸ್ಯೆಯಲ್ಲಿ ನಮಗೆ “ಸಂಖ್ಯೆ” ಎಂಬ ಸಂಖ್ಯೆಯನ್ನು ನೀಡಲಾಗಿದೆ ಮತ್ತು ಈ ಸಂಖ್ಯೆ ಪರಿಪೂರ್ಣ ಚೌಕವೋ ಅಥವಾ ಇಲ್ಲವೋ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ. ಅಂತರ್ನಿರ್ಮಿತ ಚದರ ಕಾರ್ಯವನ್ನು ಬಳಸದೆ ನಾವು ಇದನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ.

ಸಂಖ್ಯೆ ಪರಿಪೂರ್ಣ ಚೌಕವಾಗಿದ್ದರೆ ನಾವು ನಿಜವಾಗುತ್ತೇವೆ, ಇಲ್ಲದಿದ್ದರೆ ನಾವು ಸುಳ್ಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಉದಾಹರಣೆ

num = 25
true

ವಿವರಣೆ:

ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

25 ಅದರ ಪರಿಪೂರ್ಣ ಮೂಲ 5 ಆಗಿರುವುದರಿಂದ ಮಾನ್ಯ ಪರಿಪೂರ್ಣ ಚೌಕವಾಗಿದೆ. ಆದ್ದರಿಂದ, ಉತ್ತರವು ನಿಜವಾಗುತ್ತದೆ.

ಅಪ್ರೋಚ್

ನಾವು ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲಾಗದ ಕಾರಣ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಮೂಲ ವಿಧಾನವೆಂದರೆ ಪ್ರತಿ ಸಂಖ್ಯೆಯನ್ನು 1 ರಿಂದ ಸಂಖ್ಯೆಗೆ ಪರಿಶೀಲಿಸುವುದು ಮತ್ತು ಅದರ ಚೌಕವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಮತ್ತು ಅದರ ಚೌಕವು ಸಂಖ್ಯೆಗೆ ಸಮನಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ. ಚೌಕವು ಸಂಖ್ಯೆಗೆ ಸಮನಾಗಿದ್ದರೆ ಸಂಖ್ಯೆ ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್ ಆದ್ದರಿಂದ, ನಾವು ನಿಜವಾಗುತ್ತೇವೆ ಇಲ್ಲದಿದ್ದರೆ ನಾವು ಸುಳ್ಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಪ್ರತಿ ಸಂಖ್ಯೆಯನ್ನು ರೇಖೀಯವಾಗಿ ಪರಿಶೀಲಿಸಿದರೂ, ನಾವು a ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿಹಾರವನ್ನು ಸುಧಾರಿಸಬಹುದು ಬೈನರಿ ಹುಡುಕಾಟ ವಿಧಾನ. ಈ ವಿಧಾನದಲ್ಲಿ, ನಮ್ಮ ಹುಡುಕಾಟ ಶ್ರೇಣಿ, ಪ್ರಾರಂಭದ ಸ್ಥಳ ಮತ್ತು ಅಂತಿಮ ಬಿಂದುವನ್ನು ನಾವು ನಿರ್ಧರಿಸಬೇಕು.

  1. ಪ್ರಾರಂಭದ ಹಂತವು 1 ಆಗಿರುತ್ತದೆ.
  2. ಅಂತಿಮ ಬಿಂದುವು ಸಂಖ್ಯೆಯಾಗಿರುತ್ತದೆ ಏಕೆಂದರೆ ಸಂಖ್ಯೆಗಿಂತ ದೊಡ್ಡದಾದ ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಚೌಕವು ಯಾವಾಗಲೂ ಸಂಖ್ಯೆಗಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ.
  3. ಆದ್ದರಿಂದ ಆಗಿನ ಶ್ರೇಣಿ ಬೈನರಿ ಹುಡುಕಾಟ 1 ರಿಂದ ಸಂಖ್ಯೆ.
  4. ಈಗ ನಾವು ಮಧ್ಯದ ಚೌಕವನ್ನು ಕಾಣುತ್ತೇವೆ. ಚೌಕವು ಸಂಖ್ಯೆಗೆ ಸಮನಾಗಿದ್ದರೆ ನಾವು ಬೇರೆ ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ:
    1. ಚೌಕವು ಸಂಖ್ಯೆಗಿಂತ ದೊಡ್ಡದಾಗಿದ್ದರೆ ನಮ್ಮ ಅಂತಿಮ ಬಿಂದುವು ಮಧ್ಯ -1 ಕ್ಕೆ ಕಡಿಮೆಯಾಗುತ್ತದೆ.
    2. ಇಲ್ಲದಿದ್ದರೆ ಪ್ರಾರಂಭದ ಬಿಂದುವು ಮಧ್ಯ +1 ಆಗುತ್ತದೆ.
  5. ಕೊನೆಯಲ್ಲಿ, ಸಂಖ್ಯೆಯ ಯಾವುದೇ ವರ್ಗದೊಂದಿಗೆ ಸಂಖ್ಯೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ ನಾವು ಸುಳ್ಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಕೋಡ್

ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಸಿ ++ ಕೋಡ್

#include <bits/stdc++.h> 
using namespace std; 
    bool isPerfectSquare(int num) {
        int s=1,e=num;
        while(s<=e)
        {
            long long int mid=s+(e-s)/2;
            if(mid*mid==num)
                return true;
            else if(mid*mid>num)
             e=mid-1;
            else
                s=mid+1;
        }
        return false;
    }
int main() 
{ 
 int num=25;
 cout<<boolalpha;
 cout<<isPerfectSquare(num)<<endl; 
 return 0;
}
true

ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಜಾವಾ ಕೋಡ್

import java.util.Arrays; 
public class Tutorialcup {
    public static  boolean isPerfectSquare(int num){
    long s=1,e=num;
        while(s<=e)
        {
            long mid=s+(e-s)/2;
            if(mid*mid==num)
                return true;
            else if(mid*mid>num)
             e=mid-1;
            else
                s=mid+1;
        }
        return false;
    }
  public static void main(String[] args) {
    int num=25;
    boolean ans=  isPerfectSquare(num);
    System.out.println(ans);
  }
}
true

ಮಾನ್ಯ ಪರ್ಫೆಕ್ಟ್ ಸ್ಕ್ವೇರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯದ ಸಂಕೀರ್ಣತೆ

ಮೇಲಿನ ಕೋಡ್‌ನ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯಾಗಿದೆ ಒ (ಲಾಗ್). ಇಲ್ಲಿ n ಎಂಬುದು ಸಂಖ್ಯೆಯ ಮೌಲ್ಯವಾಗಿದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಮೇಲಿನ ಕೋಡ್‌ನ ಸ್ಥಳ ಸಂಕೀರ್ಣತೆಯಾಗಿದೆ ಒ (1) ಏಕೆಂದರೆ ನಾವು ಉತ್ತರವನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತಿದ್ದೇವೆ.

ಉಲ್ಲೇಖಗಳು