પૂર્ણાંકને બે નો ઝીરો પૂર્ણાંકો લીટકોડ સોલ્યુશનના સરવાળામાં કન્વર્ટ કરો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એચઆરટી
મઠ

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

પૂર્ણાંકને બે નો ઝીરો પૂર્ણાંકો લીટકોડ સોલ્યુશનના સરવાળામાં કન્વર્ટ કરો

n = 2
[1,1]

સમજૂતી: આઉટપુટમાંના બે પૂર્ણાંકો 1 અને 1 છે. પૂર્ણાંકો સમાન હોઈ શકે છે પરંતુ તેમની પાસે અંક ન હોવો જોઈએ. આઉટપુટમાં અવરોધ પૂર્ણ થાય છે. બંને પૂર્ણાંકોનો સરવાળો પણ ઇનપુટ સમાન છે. આમ આઉટપુટ યોગ્ય છે.

n = 1010
[11, 999]

સમજૂતી: આઉટપુટ યોગ્ય છે કારણ કે બંને પૂર્ણાંકોનો સરવાળો 1010 ની બરાબર છે. અને તેમની પાસે પણ 0 ની બરાબર કોઈ અંક નથી.

ટુ નો-ઝીરો ઇંટીઝર્સ લીટકોડ સોલ્યુશનના સરવાળોમાં કન્વર્ટ પૂર્ણાંક માટેનો અભિગમ

સમસ્યાએ અમને આપેલ ઇનપુટને બે પૂર્ણાંકોમાં પાર્ટીશન કરવાનું કહ્યું. શરત જે મળવી જોઈએ તે ઉપરના વર્ણનમાં પહેલેથી જ જણાવેલ છે. પ્રથમ શરત એ છે કે પૂર્ણાંકોનો સરવાળો આપેલ પૂર્ણાંક સમાન હોવો જોઈએ. બે પૂર્ણાંકો કે જે પાછા આવશે તે આઉટપુટમાં 0 અંક હોવા જોઈએ નહીં. સમસ્યા હલ કરવા માટે, આપણે પહેલા પૂર્ણાંક ઉપર એક લૂપ ચલાવીએ છીએ જે 1 થી n સુધીની હોય છે. બીજા પૂર્ણાંકો પ્રથમ સંબંધમાંથી બાદ કરી શકાય છે. પછી અમે તપાસો કે બંને પૂર્ણાંકો બીજી શરતને સંતોષે છે.

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

કોડ

પૂર્ણાંકને બે નો ઝીરો પૂર્ણાંકો લીટકોડ સોલ્યુશનના સરવાળામાં રૂપાંતરિત કરવા માટે સી ++ કોડ

#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

જટિલતા વિશ્લેષણ

સમય જટિલતા

O (NlogN), જ્યાં એન એ પૂર્ણાંક છે જે ઇનપુટ તરીકે આપવામાં આવે છે. લ Theગનો આધાર 10 હોય છે કારણ કે અમારું ફંક્શન જે તપાસ કરે છે કે પૂર્ણાંક 0 છે કે કેમ તે લોગએન સમયમાં કાર્યરત નથી.

અવકાશ જટિલતા

ઓ (1), અમે કોઈ માહિતી સ્ટોર કરતા નથી. અને સંપૂર્ણ અલ્ગોરિધમનો સતત સંખ્યાબંધ ચલોનો ઉપયોગ થાય છે. આમ જગ્યા જટિલતા સતત છે.