גער ינטעגער צו די סומע פון ​​צוויי ניט-נול ינטעגערס לעעטקאָדע סאַלושאַן


שוועריקייט לעוועל גרינג
אָפט געבעטן אין הרט
מאַט

די פּראָבלעם קאָנווערט ינטעגער צו די סומע פון ​​צוויי ניט-זעראָ ינטעגערז Leetcode סאַלושאַן געבעטן אונדז צו צעטיילן די געגעבן ינטעגער. מיר זאָל צעטיילן די געגעבן גאַנץ נומער אין צוויי נומערן. די צוויי ינטאַדזשערז זענען ימפּאָוזד. די צוויי ינטאַדזשערז זאָל נישט אַנטהאַלטן די ציפֿער 0. פֿאַר אַ בעסער פארשטאנד, מיר וועלן נעמען אַ ביסל ביישפילן.

גער ינטעגער צו די סומע פון ​​צוויי ניט-נול ינטעגערס לעעטקאָדע סאַלושאַן

n = 2
[1,1]

דערקלערונג: די צוויי גאַנץ נומערן אין דער רעזולטאַט זענען 1 און 1. די גאַנץ נומערן קענען זיין די זעלבע אָבער זיי מוזן נישט האָבן ציפֿער 0. דער קאַנסטריינט איז באגעגנט אין דער רעזולטאַט. די סומע פון ​​ביידע ינטאַדזשערז איז אויך גלייַך צו די אַרייַנשרייַב. אזוי דער רעזולטאַט איז ריכטיק.

n = 1010
[11, 999]

דערקלערונג: דער רעזולטאַט איז ריכטיק ווייַל די סומע פון ​​ביידע די גאַנץ נומערן איז גלייַך צו 1010. און זיי אויך טאָן ניט האָבן קיין ציפֿער גלייַך צו 0.

צוגאַנג צו קאָנווערט ינטעגער צו די סומע פון ​​צוויי ניט-נול ינטעגערס לעעטקאָדע סאַלושאַן

דער פּראָבלעם האָט אונדז געבעטן צו צעטיילן די געגעבן אַרייַנשרייַב אין צוויי ינטאַדזשערז. די צושטאַנד וואָס זאָל זיין באגעגנט איז שוין סטייטיד אין די באַשרייַבונג אויבן. דער ערשטער באַדינג איז אַז די סומע פון ​​די גאַנץ נומערן מוזן זיין גלייַך צו די געגעבן גאַנץ נומער. די צוויי ינטאַדזשערז וואָס וועט זיין אומגעקערט ווי דער רעזולטאַט זאָל ניט אַנטהאַלטן קיין 0 דידזשאַץ. צו סאָלווע דעם פּראָבלעם, מיר פירן אַ שלייף איבער דער ערשטער ינטאַדזשער אַז ריינדזשאַז פון 1 צו n. די רגע ינטאַדזשער קענען זיין דידוסט פֿון דער ערשטער באַציונג. דערנאָך מיר קאָנטראָלירן צי ביידע די גאַנץ נומערן באַפרידיקן די רגע צושטאַנד.

פֿאַר קאָנטראָלירונג די רגע צושטאַנד, מיר מאַכן אַ מנהג פֿונקציע וואָס נעמט אַ גאַנץ נומער ווי ינפּוט. עס קערט אמת אָדער פאַלש דיפּענדינג אויף צי די געגעבן גאַנץ נומער כּולל 0 אָדער נישט. צו קאָנטראָלירן אַז מיר נאָר האַלטן די נומער פון די דידזשאַץ פון די סוף.

קאָדעקס

C ++ קאָד צו קאָנווערט ינטעגער צו די סומע פון ​​צוויי ניט-נול ינטעגערס לעעטקאָדע סאַלושאַן

#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

Java קאָד צו קאָנווערט ינטעגער צו די סומע פון ​​צוויי ניט-נול ינטעגערס לעעטקאָדע סאַלושאַן

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), מיר טאָן ניט קראָם קיין אינפֿאָרמאַציע. די גאנצע אַלגערידאַם ניצט אַ קעסיידערדיק נומער פון וועריאַבאַלז. אזוי די פּלאַץ קאַמפּלעקסיטי איז קעסיידערדיק.