ಎರಡು-ಶೂನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಮೊತ್ತಕ್ಕೆ ಪೂರ್ಣಾಂಕವನ್ನು ಪರಿವರ್ತಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ HRT
ಮಠ

ಎರಡು ಪೂರ್ಣ-ಶೂನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತಕ್ಕೆ ಪೂರ್ಣಾಂಕವನ್ನು ಪರಿವರ್ತಿಸುವ ಸಮಸ್ಯೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವು ಕೊಟ್ಟಿರುವ ವಿಭಜನೆಯನ್ನು ಕೇಳಿದೆ ಪೂರ್ಣಾಂಕ. ಕೊಟ್ಟಿರುವ ಪೂರ್ಣಾಂಕವನ್ನು ನಾವು ಎರಡು ಸಂಖ್ಯೆಗಳಾಗಿ ವಿಭಜಿಸಬೇಕು. ಈ ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ಮೇಲೆ ನಿರ್ಬಂಧವಿದೆ. ಈ ಎರಡು ಪೂರ್ಣಾಂಕಗಳು 0 ಅಂಕಿಯನ್ನು ಹೊಂದಿರಬಾರದು. ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ, ನಾವು ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

ಎರಡು-ಶೂನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಮೊತ್ತಕ್ಕೆ ಪೂರ್ಣಾಂಕವನ್ನು ಪರಿವರ್ತಿಸಿ

n = 2
[1,1]

ವಿವರಣೆ: output ಟ್‌ಪುಟ್‌ನಲ್ಲಿರುವ ಎರಡು ಪೂರ್ಣಾಂಕಗಳು 1 ಮತ್ತು 1. ಪೂರ್ಣಾಂಕಗಳು ಒಂದೇ ಆಗಿರಬಹುದು ಆದರೆ ಅವು ಅಂಕೆ 0 ಹೊಂದಿರಬಾರದು. Output ಟ್‌ಪುಟ್‌ನಲ್ಲಿ ನಿರ್ಬಂಧವನ್ನು ಪೂರೈಸಲಾಗುತ್ತದೆ. ಎರಡೂ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತವು ಇನ್‌ಪುಟ್‌ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ಹೀಗಾಗಿ output ಟ್‌ಪುಟ್ ಸರಿಯಾಗಿದೆ.

n = 1010
[11, 999]

ವಿವರಣೆ: ಪೂರ್ಣಾಂಕವು ಸರಿಯಾಗಿದೆ ಏಕೆಂದರೆ ಎರಡೂ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತ 1010 ಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ಮತ್ತು ಅವುಗಳು 0 ಗೆ ಸಮನಾದ ಯಾವುದೇ ಅಂಕಿಗಳನ್ನು ಸಹ ಹೊಂದಿರುವುದಿಲ್ಲ.

ಎರಡು-ಶೂನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಮೊತ್ತಕ್ಕೆ ಪೂರ್ಣಾಂಕವನ್ನು ಪರಿವರ್ತಿಸುವ ವಿಧಾನ

ಕೊಟ್ಟಿರುವ ಇನ್ಪುಟ್ ಅನ್ನು ಎರಡು ಪೂರ್ಣಾಂಕಗಳಾಗಿ ವಿಭಜಿಸಲು ಸಮಸ್ಯೆ ನಮ್ಮನ್ನು ಕೇಳಿದೆ. ಪೂರೈಸಬೇಕಾದ ಸ್ಥಿತಿಯನ್ನು ಈಗಾಗಲೇ ಮೇಲಿನ ವಿವರಣೆಯಲ್ಲಿ ಹೇಳಲಾಗಿದೆ. ಮೊದಲ ಷರತ್ತು, ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತವು ಕೊಟ್ಟಿರುವ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಸಮನಾಗಿರಬೇಕು. Output ಟ್‌ಪುಟ್‌ನಂತೆ ಹಿಂತಿರುಗಿಸುವ ಎರಡು ಪೂರ್ಣಾಂಕಗಳು ಯಾವುದೇ 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

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್‌ಲಾಗ್ಎನ್), ಇಲ್ಲಿ N ಎಂಬುದು ಇನ್ಪುಟ್ ಆಗಿ ನೀಡಲಾದ ಪೂರ್ಣಾಂಕವಾಗಿದೆ. ಲಾಗ್ ಬೇಸ್ 10 ಅನ್ನು ಹೊಂದಿದೆ ಏಕೆಂದರೆ ಪೂರ್ಣಾಂಕವು 0 ಅನ್ನು ಹೊಂದಿದೆಯೆ ಅಥವಾ ಲಾಗ್ಎನ್ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ನಮ್ಮ ಕಾರ್ಯ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಒ (1), ನಾವು ಯಾವುದೇ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ. ಮತ್ತು ಸಂಪೂರ್ಣ ಅಲ್ಗಾರಿದಮ್ ಸ್ಥಿರ ಸಂಖ್ಯೆಯ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಹೀಗಾಗಿ ಜಾಗದ ಸಂಕೀರ್ಣತೆ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ.