పూర్ణాంకాన్ని రెండు నో-జీరో పూర్ణాంకాల లీట్‌కోడ్ సొల్యూషన్ మొత్తంగా మార్చండి


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది HRT
మఠం

ఇంటీజర్‌ను రెండు నో-జీరో ఇంటీజర్స్ లీట్‌కోడ్ సొల్యూషన్ మొత్తానికి మార్చడం ఇచ్చిన విభజనను అడిగారు పూర్ణ సంఖ్య. ఇచ్చిన పూర్ణాంకాన్ని మనం రెండు సంఖ్యలుగా విభజించాలి. ఈ రెండు పూర్ణాంకాలపై ఒక పరిమితి ఉంది. ఈ రెండు పూర్ణాంకాలు అంకె 0 ని కలిగి ఉండకూడదు. మంచి అవగాహన కోసం, మేము కొన్ని ఉదాహరణలను పరిశీలిస్తాము.

పూర్ణాంకాన్ని రెండు నో-జీరో పూర్ణాంకాల లీట్‌కోడ్ సొల్యూషన్ మొత్తంగా మార్చండి

n = 2
[1,1]

వివరణ: అవుట్‌పుట్‌లోని రెండు పూర్ణాంకాలు 1 మరియు 1. పూర్ణాంకాలు ఒకే విధంగా ఉంటాయి కాని వాటికి అంకె 0 ఉండకూడదు. అవుట్‌పుట్‌లో అడ్డంకి కలుస్తుంది. రెండు పూర్ణాంకాల మొత్తం కూడా ఇన్‌పుట్‌కు సమానం. అందువలన అవుట్పుట్ సరైనది.

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), ఇక్కడ N అనేది పూర్ణాంకం ఇన్పుట్‌గా ఇవ్వబడుతుంది. లాగ్ బేస్ 10 ను కలిగి ఉంది, ఎందుకంటే పూర్ణాంకం 0 ఉందా లేదా లాగ్ఎన్ టైమ్‌లో పనిచేస్తుందో లేదో తనిఖీ చేసే మా ఫంక్షన్.

అంతరిక్ష సంక్లిష్టత

ఓ (1), మేము ఏ సమాచారాన్ని నిల్వ చేయము. మరియు మొత్తం అల్గోరిథం వేరియబుల్స్ యొక్క స్థిరమైన సంఖ్యను ఉపయోగిస్తుంది. అందువలన స్థల సంక్లిష్టత స్థిరంగా ఉంటుంది.