ਬਦਸੂਰਤ ਲੀਟਕੋਡ ਹੱਲ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਗਣਿਤ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਇਸ ਸਮੱਸਿਆ ਵਿਚ ਸਾਨੂੰ ਇਕ ਨੰਬਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਾਨੂੰ ਜਾਂਚ ਕਰਨੀ ਪੈਂਦੀ ਹੈ ਕਿ ਇਹ ਬਦਸੂਰਤ ਨੰਬਰ ਹੈ ਜਾਂ ਨਹੀਂ.
ਦਿੱਤੇ ਗਏ ਕਿ ਬਦਸੂਰਤ ਨੰਬਰ ਸਕਾਰਾਤਮਕ ਸੰਖਿਆਵਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਦੇ ਪ੍ਰਮੁੱਖ ਕਾਰਕਾਂ ਵਿੱਚ ਸਿਰਫ 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 ਬਣ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਇਕ ਬਦਸੂਰਤ ਨੰਬਰ ਹੈ ਅਤੇ ਅਸੀਂ ਸਹੀ ਹੋ ਜਾਂਦੇ ਹਾਂ, ਨਹੀਂ ਤਾਂ ਅਸੀਂ ਗਲਤ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ.

ਲਾਗੂ

C ++ ਪ੍ਰੋਗਰਾਮ ਬਦਸੂਰਤ ਲੀਟਕੋਡ ਸਲਿolutionਸ਼ਨ ਲਈ

#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

ਬਦਸੂਰਤ ਨੰਬਰ ਲੇਟਕੋਡ ਹੱਲ ਲਈ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਲੌਗ (ਐਨ)): ਅਸੀਂ ਨੰਬਰ ਨੂੰ 2, 3 ਅਤੇ 5 ਵਿਚ ਵੰਡ ਰਹੇ ਹਾਂ ਜਦੋਂ ਕਿ ਬਾਰ ਬਾਰ ਲੂਪ. ਇਸਲਈ ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਓ (ਲੌਗ (ਐਨ)) ਹੋਵੇਗੀ, ਜਿੱਥੇ n ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ 

ਓ (1): ਅਸੀਂ ਕੋਈ ਵਾਧੂ ਥਾਂ ਨਹੀਂ ਵਰਤ ਰਹੇ, ਇਸ ਲਈ ਇਹ ਨਿਰੰਤਰ ਹੈ.