ਪੂਰਨ ਅੰਕ ਨੂੰ ਦੋ ਨੋ-ਜ਼ੀਰੋ ਪੂਰਨ ਅੰਕ ਲੈੱਟਕੋਡ ਸਮਾਧਾਨ ਦੇ ਜੋੜ ਵਿੱਚ ਬਦਲੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਚ.ਆਰ.ਟੀ.
ਗਣਿਤ

ਸਮੱਸਿਆ ਨੂੰ ਪੂਰਨ ਅੰਕ ਦੋ ਨੋ-ਜ਼ੀਰੋ ਇੰਟੀਜਰਜ਼ ਲੈਟਕੋਡ ਸਲਿ ofਸ਼ਨ ਦੇ ਜੋੜ ਵਿਚ ਬਦਲਣ ਲਈ ਸਾਨੂੰ ਦਿੱਤੇ ਭਾਗਾਂ ਨੂੰ ਵੰਡਣ ਲਈ ਕਿਹਾ ਪੂਰਨ ਅੰਕ. ਸਾਨੂੰ ਦਿੱਤੇ ਅੰਕ ਨੂੰ ਦੋ ਅੰਕਾਂ ਵਿੱਚ ਵੰਡਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਨ੍ਹਾਂ ਦੋਵਾਂ ਪੂਰਨ ਸੰਕਟਾਂ ਉੱਤੇ ਇੱਕ ਪਾਬੰਦੀ ਲਗਾਈ ਗਈ ਹੈ। ਇਨ੍ਹਾਂ ਦੋਵਾਂ ਪੂਰਨ ਅੰਕ ਵਿਚ ਅੰਕ 0 ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਚੰਗੀ ਸਮਝ ਲਈ, ਅਸੀਂ ਕੁਝ ਉਦਾਹਰਣਾਂ 'ਤੇ ਝਾਤ ਮਾਰੀਏ.

ਪੂਰਨ ਅੰਕ ਨੂੰ ਦੋ ਨੋ-ਜ਼ੀਰੋ ਪੂਰਨ ਅੰਕ ਲੈੱਟਕੋਡ ਸਮਾਧਾਨ ਦੇ ਜੋੜ ਵਿੱਚ ਬਦਲੋ

n = 2
[1,1]

ਵਿਆਖਿਆ: ਆਉਟਪੁੱਟ ਵਿੱਚ ਦੋਵੇਂ ਪੂਰਨ ਅੰਕ 1 ਅਤੇ 1 ਹੁੰਦੇ ਹਨ. ਪੂਰਨ ਅੰਕ ਇਕੋ ਹੋ ਸਕਦੇ ਹਨ ਪਰ ਉਹਨਾਂ ਦਾ ਅੰਕ 0 ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ. ਦੋਵੇਂ ਪੂਰਨ ਅੰਕ ਦਾ ਜੋੜ ਵੀ ਇੰਪੁੱਟ ਦੇ ਬਰਾਬਰ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ ਆਉਟਪੁੱਟ ਸਹੀ ਹੈ.

n = 1010
[11, 999]

ਵਿਆਖਿਆ: ਆਉਟਪੁੱਟ ਸਹੀ ਹੈ ਕਿਉਂਕਿ ਦੋਵੇਂ ਪੂਰਨ ਅੰਕ ਦਾ ਜੋੜ 1010 ਦੇ ਬਰਾਬਰ ਹੈ. ਅਤੇ ਉਹਨਾਂ ਕੋਲ 0 ਦੇ ਬਰਾਬਰ ਦਾ ਕੋਈ ਅੰਕ ਵੀ ਨਹੀਂ ਹੁੰਦਾ.

ਟੂ ਨੋ-ਜ਼ੀਰੋ ਇੰਟੀਜਰਜ ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਦੇ ਜੋੜ ਲਈ ਪਰਿਵਰਤਨ ਪੂਰਨ ਅੰਕ ਲਈ ਪਹੁੰਚ

ਸਮੱਸਿਆ ਨੇ ਸਾਨੂੰ ਦਿੱਤੇ ਇੰਪੁੱਟ ਨੂੰ ਦੋ ਪੂਰਨ ਅੰਕ ਵਿਚ ਵੰਡਣ ਲਈ ਕਿਹਾ. ਜਿਹੜੀ ਸਥਿਤੀ ਨੂੰ ਪੂਰਾ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਉਹ ਉੱਪਰ ਦਿੱਤੇ ਵੇਰਵੇ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਦੱਸਿਆ ਗਿਆ ਹੈ. ਪਹਿਲੀ ਸ਼ਰਤ ਇਹ ਹੈ ਕਿ ਪੂਰਨ ਅੰਕ ਦਾ ਜੋੜ, ਦਿੱਤੇ ਪੂਰਨ ਅੰਕ ਦੇ ਬਰਾਬਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਦੋਵੇਂ ਪੂਰਨ ਅੰਕ ਜੋ ਆਉਟਪੁੱਟ ਵਿੱਚ ਕੋਈ 0 ਅੰਕ ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਵਾਪਸ ਕੀਤੇ ਜਾਣਗੇ. ਸਮੱਸਿਆ ਦੇ ਹੱਲ ਲਈ, ਅਸੀਂ ਪਹਿਲੇ ਪੂਰਨ ਅੰਕ ਉੱਤੇ ਇਕ ਲੂਪ ਚਲਾਉਂਦੇ ਹਾਂ ਜੋ ਕਿ 1 ਤੋਂ n ਤੱਕ ਹੈ. ਦੂਸਰਾ ਪੂਰਨ ਅੰਕ ਪਹਿਲੇ ਸੰਬੰਧ ਵਿਚੋਂ ਕੱuਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਫਿਰ ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀ ਦੋਵੇਂ ਪੂਰਨ ਅੰਕ ਦੂਸਰੀ ਸ਼ਰਤ ਨੂੰ ਸੰਤੁਸ਼ਟ ਕਰਦੇ ਹਨ.

ਦੂਜੀ ਸ਼ਰਤ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਕਸਟਮ ਫੰਕਸ਼ਨ ਬਣਾਉਂਦੇ ਹਾਂ ਜੋ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਪੂਰਨ ਅੰਕ ਲੈਂਦਾ ਹੈ. ਇਹ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਦਰਸਾਏ ਪੂਰਨ ਅੰਕ 0 ਹੈ ਜਾਂ ਨਹੀਂ ਇਸ ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ. ਇਹ ਵੇਖਣ ਲਈ ਕਿ ਅਸੀਂ ਸਿਰੇ ਤੋਂ ਇਕ-ਇਕ ਕਰਕੇ ਅੰਕ ਕੱ removingਦੇ ਰਹਿੰਦੇ ਹਾਂ.

ਕੋਡ

ਦੋ ਨੋ-ਜ਼ੀਰੋ ਇੰਟੀਜ਼ਰਸ ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਦੇ ਜੋੜ ਲਈ ਪੂਰਨ ਅੰਕ ਨੂੰ ਬਦਲਣ ਲਈ ਸੀ ++ ਕੋਡ

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

bool check(int n){
    while(n>0){
        if(n%10 == 0)
            return false;
        n/=10;
    }
    return true;
}

vector<int> getNoZeroIntegers(int n) {
    for(int i=1;i<n;i++){
        if(check(i) && check(n-i))
            return {i, n-i};
    }
    return {-1,-1};
}

int main(){
    int input = 1010;
    vector<int> output = getNoZeroIntegers(input);
    cout<<output[0]<<" "<<output[1];
}
11 999

ਦੋ ਨੋ-ਜ਼ੀਰੋ ਇੰਟੀਜ਼ਰਸ ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਦੇ ਜੋੜ ਲਈ ਪੂਰਨ ਅੰਕ ਨੂੰ ਬਦਲਣ ਲਈ ਜਾਵਾ ਕੋਡ

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

class Main
{
  private static boolean check(int n){
        while(n>0){
            if(n%10 == 0)return false;
            n/=10;
        }
        return true;
    }
    
    public static int[] getNoZeroIntegers(int n) {
        for(int i=1;i<n;i++){
            if(check(i) && check(n-i))
                return new int[]{i, n-i};
        }
        return new int[]{-1,-1};
    }
    
  public static void main (String[] args) throws java.lang.Exception{
    int input = 1010;
      int[] output = getNoZeroIntegers(input);
      System.out.print(output[0]+" "+output[1]);
  }
}
11 999

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨਲੌਗ ਐਨ), ਜਿੱਥੇ N ਇੰਪੁੱਟ ਦੇ ਤੌਰ ਤੇ ਦਿੱਤਾ ਪੂਰਨ ਅੰਕ ਹੁੰਦਾ ਹੈ. ਲੌਗ ਦਾ ਅਧਾਰ 10 ਹੈ ਕਿਉਂਕਿ ਸਾਡਾ ਕਾਰਜ ਜੋ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਪੂਰਨ ਅੰਕ 0 ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ ਜਾਂ ਲਾਗਇਨ ਸਮੇਂ ਵਿੱਚ ਕੰਮ ਨਹੀਂ ਕਰਦਾ.

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

ਓ (1), ਅਸੀਂ ਕੋਈ ਜਾਣਕਾਰੀ ਸਟੋਰ ਨਹੀਂ ਕਰਦੇ. ਅਤੇ ਪੂਰਾ ਐਲਗੋਰਿਦਮ ਨਿਰੰਤਰ ਗਿਣਤੀ ਦੇ ਵੇਰੀਏਬਲ ਵਰਤਦਾ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ ਪੁਲਾੜ ਦੀ ਜਟਿਲਤਾ ਨਿਰੰਤਰ ਹੈ.