இரண்டு பூஜ்ஜிய முழு எண் லீட்கோட் தீர்வின் தொகைக்கு முழு எண்ணாக மாற்றவும்


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது 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

சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

ஓ (NlogN), N என்பது உள்ளீடாக கொடுக்கப்பட்ட முழு எண். பதிவு அடிப்படை 10 ஐக் கொண்டுள்ளது, ஏனெனில் முழு எண் 0 உள்ளதா இல்லையா என்பதை சரிபார்க்கும் எங்கள் செயல்பாடு logN நேரத்தில் செயல்படுகிறது.

விண்வெளி சிக்கலானது

ஓ (1), நாங்கள் எந்த தகவலையும் சேமிக்க மாட்டோம். முழு வழிமுறையும் மாறிலிகளின் நிலையான எண்ணிக்கையைப் பயன்படுத்துகிறது. இதனால் விண்வெளி சிக்கலானது நிலையானது.