Welcome to Subscribe On Youtube

1317. Convert Integer to the Sum of Two No-Zero Integers

Description

No-Zero integer is a positive integer that does not contain any 0 in its decimal representation.

Given an integer n, return a list of two integers [a, b] where:

• a and b are No-Zero integers.
• a + b = n

The test cases are generated so that there is at least one valid solution. If there are many valid solutions, you can return any of them.

 

Example 1:

Input: n = 2
Output: [1,1]
Explanation: Let a = 1 and b = 1.
Both a and b are no-zero integers, and a + b = 2 = n.

Example 2:

Input: n = 11
Output: [2,9]
Explanation: Let a = 2 and b = 9.
Both a and b are no-zero integers, and a + b = 9 = n.
Note that there are other valid answers as [8, 3] that can be accepted.

 

Constraints:

• 2 <= n <= 104

Solutions

• Java
• C++
• Python
• Go
• TypeScript
• Rust
• Java 2
• C++ 2
• Python 2
• Go 2
• TypeScript 2
• Rust 2

• class Solution {
      public int[] getNoZeroIntegers(int n) {
          for (int a = 1;; ++a) {
              int b = n - a;
              if (!(a + "" + b).contains("0")) {
                  return new int[] {a, b};
              }
          }
      }
  }
  

• class Solution {
  public:
      vector<int> getNoZeroIntegers(int n) {
          for (int a = 1;; ++a) {
              int b = n - a;
              if ((to_string(a) + to_string(b)).find('0') == -1) {
                  return {a, b};
              }
          }
      }
  };
  

• class Solution:
      def getNoZeroIntegers(self, n: int) -> List[int]:
          for a in range(1, n):
              b = n - a
              if "0" not in str(a) + str(b):
                  return [a, b]
  
  

• func getNoZeroIntegers(n int) []int {
  	for a := 1; ; a++ {
  		b := n - a
  		if !strings.Contains(strconv.Itoa(a)+strconv.Itoa(b), "0") {
  			return []int{a, b}
  		}
  	}
  }
  

• function getNoZeroIntegers(n: number): number[] {
      for (let a = 1; ; ++a) {
          const b = n - a;
          if (!`${a}${b}`.includes('0')) {
              return [a, b];
          }
      }
  }
  
  

• impl Solution {
      pub fn get_no_zero_integers(n: i32) -> Vec<i32> {
          for a in 1..n {
              let b = n - a;
              if !a.to_string().contains('0') && !b.to_string().contains('0') {
                  return vec![a, b];
              }
          }
          vec![]
      }
  }
  
  

• class Solution {
      public int[] getNoZeroIntegers(int n) {
          for (int a = 1;; ++a) {
              int b = n - a;
              if (f(a) && f(b)) {
                  return new int[] {a, b};
              }
          }
      }
  
      private boolean f(int x) {
          for (; x > 0; x /= 10) {
              if (x % 10 == 0) {
                  return false;
              }
          }
          return true;
      }
  }
  

• class Solution {
  public:
      vector<int> getNoZeroIntegers(int n) {
          auto f = [](int x) {
              for (; x; x /= 10) {
                  if (x % 10 == 0) {
                      return false;
                  }
              }
              return true;
          };
          for (int a = 1;; ++a) {
              int b = n - a;
              if (f(a) && f(b)) {
                  return {a, b};
              }
          }
      }
  };
  

• class Solution:
      def getNoZeroIntegers(self, n: int) -> List[int]:
          def f(x: int) -> bool:
              while x:
                  if x % 10 == 0:
                      return False
                  x //= 10
              return True
  
          for a in count(1):
              b = n - a
              if f(a) and f(b):
                  return [a, b]
  
  

• func getNoZeroIntegers(n int) []int {
  	f := func(x int) bool {
  		for ; x > 0; x /= 10 {
  			if x%10 == 0 {
  				return false
  			}
  		}
  		return true
  	}
  	for a := 1; ; a++ {
  		b := n - a
  		if f(a) && f(b) {
  			return []int{a, b}
  		}
  	}
  }
  

• function getNoZeroIntegers(n: number): number[] {
      const f = (x: number): boolean => {
          for (; x; x = (x / 10) | 0) {
              if (x % 10 === 0) {
                  return false;
              }
          }
          return true;
      };
      for (let a = 1; ; ++a) {
          const b = n - a;
          if (f(a) && f(b)) {
              return [a, b];
          }
      }
  }
  
  

• impl Solution {
      pub fn get_no_zero_integers(n: i32) -> Vec<i32> {
          fn f(mut x: i32) -> bool {
              while x > 0 {
                  if x % 10 == 0 {
                      return false;
                  }
                  x /= 10;
              }
              true
          }
  
          for a in 1..n {
              let b = n - a;
              if f(a) && f(b) {
                  return vec![a, b];
              }
          }
          vec![]
      }
  }
  
  

All Problems

All Solutions