വൃത്തികെട്ട നമ്പർ ലീറ്റ്കോഡ് പരിഹാരം


വൈഷമ്യ നില എളുപ്പമായ
മഠം

പ്രശ്നം പ്രസ്താവന

ഈ പ്രശ്‌നത്തിൽ ഞങ്ങൾക്ക് ഒരു നമ്പർ നൽകിയിട്ടുണ്ട്, അത് ഒരു വൃത്തികെട്ട സംഖ്യയാണോ എന്ന് പരിശോധിക്കേണ്ടതുണ്ട്.
വൃത്തികെട്ട സംഖ്യകൾ പോസിറ്റീവ് സംഖ്യകളാണെന്നതിനാൽ, അവയുടെ പ്രധാന ഘടകങ്ങളിൽ 2, 3, 5 മാത്രം ഉൾപ്പെടുന്നു.
1 നെ സാധാരണയായി ഒരു വൃത്തികെട്ട സംഖ്യയായി കണക്കാക്കുന്നു.

ഉദാഹരണം

6
true

വിശദീകരണം: 6 = 2 × 3

14
false

വിശദീകരണം: 14 = 2 × 7
മറ്റൊരു പ്രധാന ഘടകം 14 ഉൾപ്പെടുന്നതിനാൽ 7 വൃത്തികെട്ടതല്ല.

സമീപനം

പ്രശ്ന പ്രസ്താവനയിൽ നിന്ന് വ്യക്തമാണ്, ഒരു വൃത്തികെട്ട സംഖ്യയാകാൻ അതിൽ ഒന്നും അടങ്ങിയിരിക്കരുത് പ്രധാന ഘടകങ്ങൾ 2,3, 5 എന്നിവ ഒഴികെ.

ഒന്നോ അതിലധികമോ പ്രൈം നമ്പറുകളുടെ (1 ഒഴികെ) ചില ശക്തികളുടെ ഉൽ‌പ്പന്നമാണ് ഓരോ സംഖ്യയും രൂപപ്പെടുന്നതെന്ന് നമുക്കറിയാം. അതിനാൽ നമുക്ക് സംഖ്യയെ അതിന്റെ പ്രധാന ഘടകങ്ങളിലേക്ക് ഫാക്റ്ററൈസ് ചെയ്യാനും അതിൽ 2,3, 5 എന്നിവ ഒഴികെയുള്ള പ്രൈം നമ്പറുകൾ അടങ്ങിയിട്ടുണ്ടോ എന്ന് നോക്കാനും കഴിയും.

ഫാക്ടറൈസേഷൻ എന്നതിനർത്ഥം ഒരു പ്രൈം നമ്പറിന് ഒരു സംഖ്യയെ പൂർണ്ണമായും വിഭജിക്കാൻ കഴിയുമെങ്കിൽ അത് ആ പ്രത്യേക സംഖ്യയുടെ ഘടകമായിരിക്കും. അതിനാൽ‌, സംഖ്യയെ 2 കൊണ്ട് ഹരിക്കുകയാണെങ്കിൽ‌, തന്നിരിക്കുന്ന സംഖ്യയെ 2 കൊണ്ട് ഹരിക്കാം, അങ്ങനെ ഘടകം 1 ന്റെ ആദ്യ പവർ‌ നീക്കംചെയ്യാം. 2 ന്റെ എല്ലാ ശക്തികളും നമ്പറിൽ‌ നിന്നും നീക്കംചെയ്യുന്നതുവരെ ഞങ്ങൾ‌ 2 കൊണ്ട് ആവർത്തിക്കും.
അതുപോലെ തന്നെ ഘടകം 3, 5 എന്നിവയുടെ എല്ലാ ശക്തികളും ഞങ്ങൾ നീക്കംചെയ്യും.

ഈ സംഖ്യയിൽ 2,3, 5 എന്നിവ ഒഴികെയുള്ള ഏതെങ്കിലും പ്രധാന ഘടകങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, നിലവിലുള്ള ശേഷിക്കുന്ന സംഖ്യ 1 ന് തുല്യമാകില്ലെന്ന് ഇപ്പോൾ വ്യക്തമാണ്.
അതിനാൽ അവസാനം സംഖ്യ 1 ആകുകയാണെങ്കിൽ, അത് ഒരു വൃത്തികെട്ട സംഖ്യയാണ്, ഞങ്ങൾ ശരിയാണ്, അല്ലെങ്കിൽ ഞങ്ങൾ തെറ്റായി മടങ്ങുന്നു.

നടപ്പിലാക്കൽ

അഗ്ലി നമ്പർ ലീറ്റ്കോഡ് പരിഹാരത്തിനായുള്ള സി ++ പ്രോഗ്രാം

#include <bits/stdc++.h>
using namespace std;

bool isUgly(int num) 
{	
  if(num<=0) return false;
   
  while(num%2==0) num/=2;
  while(num%3==0) num/=3;
  while(num%5==0) num/=5;
  
  if(num==1) return true; 
    else return false;
}

int main() 
{
    int num=8;
  
  if(isUgly(num))
    cout<<"true"<<endl;
  else
    cout<<"false"<<endl;

  return 0; 
}
true

അഗ്ലി നമ്പർ ലീറ്റ്കോഡ് പരിഹാരത്തിനായുള്ള ജാവ പ്രോഗ്രാം

import java.util.*;
import java.lang.*;


class UglyNumber
{  
   public static boolean isUgly(int num) 
   {
        if(num<=0) return false;
       
        while(num%2==0) num/=2;
        while(num%3==0) num/=3;
        while(num%5==0) num/=5;
        
        if(num==1) return true; 
        else return false;
        
    }
    
    public static void main(String args[])
    {
        int num=8;

        System.out.println(isUgly(num));
        
    }
}
true

അഗ്ലി നമ്പർ ലീട്ട്‌കോഡ് പരിഹാരത്തിനായുള്ള സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (ലോഗ് (n)): ലൂപ്പ് ആവർത്തിച്ച് ഞങ്ങൾ 2, 3, 5 എന്നിങ്ങനെ വിഭജിക്കുന്നു. അതിനാൽ സമയ സങ്കീർണ്ണത O (ലോഗ് (n)) ആയിരിക്കും, ഇവിടെ n നൽകിയ സംഖ്യയാണ്.

ബഹിരാകാശ സങ്കീർണ്ണത 

O (1): ഞങ്ങൾ അധിക സ്ഥലമൊന്നും ഉപയോഗിക്കുന്നില്ല, അതിനാൽ ഇത് സ്ഥിരമാണ്.