માન્ય પરફેક્ટ સ્ક્વેર લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન
લેટકોડ

આ પોસ્ટ માન્ય પરફેક્ટ સ્ક્વેર લિટકોડ સોલ્યુશન પર છે

સમસ્યા નિવેદન

સમસ્યામાં “માન્ય પરફેક્ટ સ્ક્વેર” આપણને એક નંબર આપવામાં આવે છે “num” અને અમારે તપાસ કરવાની જરૂર છે કે આ નંબર એક સંપૂર્ણ ચોરસ છે કે નહીં. આપણે બિલ્ટ-ઇન સ્ક્વેર ટ ફંકશનનો ઉપયોગ કર્યા વિના આ તપાસવું પડશે.

જો સંખ્યા એક સંપૂર્ણ વર્ગ છે, તો પછી આપણે સાચું પાછા આવીશું અન્યથા આપણે ખોટાં વળતર આપીશું.

ઉદાહરણ

num = 25
true

સમજૂતી:

માન્ય પરફેક્ટ સ્ક્વેર લીટકોડ સોલ્યુશન

25 એ એક માન્ય સંપૂર્ણ વર્ગ છે કારણ કે તેનો વર્ગમૂળ 5. છે. તેથી, જવાબ સાચો થઈ જાય છે.

અભિગમ

જેમ આપણે બિલ્ટ-ઇન ફંક્શંસનો ઉપયોગ કરી શકતા નથી, તેથી આ સમસ્યાનું નિરાકરણ લાવવા માટેનો મૂળ અભિગમ એ છે કે દરેક નંબરને 1 થી નંબરો સુધી તપાસવું અને તેનો ચોરસ શોધવો, પછી તપાસો કે તેનો ચોરસ સંખ્યા બરાબર છે કે નહીં. જો ચોરસ સંખ્યા બરાબર હોય તો num એ વેલિડ પરફેક્ટ સ્ક્વેર છે તેથી, આપણે સાચા પાડીશું અન્યથા આપણે ખોટા પાડીશું.

દરેક સંખ્યાની લાઇનરી તપાસ કરતા હોવા છતાં, આપણે 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ગન). અહીં n એ num ની વેલ્યુ છે.

જગ્યાની જટિલતા

ઉપરોક્ત કોડની અવકાશ જટિલતા છે ઓ (1) કારણ કે આપણે જવાબ સંગ્રહવા માટે માત્ર એક વેરીએબલ વાપરી રહ્યા છીએ.

સંદર્ભ