easy – Page 9 – Huahua’s Tech Road

花花酱 LeetCode 2243. Calculate Digit Sum of a String

By zxi on April 17, 2022

You are given a string s consisting of digits and an integer k.

A round can be completed if the length of s is greater than k. In one round, do the following:

Divide s into consecutive groups of size k such that the first k characters are in the first group, the next k characters are in the second group, and so on. Note that the size of the last group can be smaller than k.
Replace each group of s with a string representing the sum of all its digits. For example, "346" is replaced with "13" because 3 + 4 + 6 = 13.
Merge consecutive groups together to form a new string. If the length of the string is greater than k, repeat from step 1.

Return s after all rounds have been completed.

Example 1:

Input: s = "11111222223", k = 3
Output: "135"
Explanation: 
- For the first round, we divide s into groups of size 3: "111", "112", "222", and "23".
  Then we calculate the digit sum of each group: 1 + 1 + 1 = 3, 1 + 1 + 2 = 4, 2 + 2 + 2 = 6, and 2 + 3 = 5. 
  So, s becomes "3" + "4" + "6" + "5" = "3465" after the first round.
- For the second round, we divide s into "346" and "5".
  Then we calculate the digit sum of each group: 3 + 4 + 6 = 13, 5 = 5. 
  So, s becomes "13" + "5" = "135" after second round. 
Now, s.length <= k, so we return "135" as the answer.

Example 2:

Input: s = "00000000", k = 3
Output: "000"
Explanation: 
We divide s into "000", "000", and "00".
Then we calculate the digit sum of each group: 0 + 0 + 0 = 0, 0 + 0 + 0 = 0, and 0 + 0 = 0. 
s becomes "0" + "0" + "0" = "000", whose length is equal to k, so we return "000".

Constraints:

1 <= s.length <= 100
2 <= k <= 100
s consists of digits only.

Solution:

Time complexity: O(n*n/k?)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

string digitSum(string s, int k) {

while (s.length() > k) {

string ss;

for (int j = 0; j < s.length(); j += k) {

int sum = 0;

for (int i = 0; i < k && i + j < s.length(); ++i)

sum += (s[j + i] - '0');

ss += to_string(sum);

}

ss.swap(s);

}

return s;

}

};

花花酱 LeetCode 2239. Find Closest Number to Zero

By zxi on April 16, 2022

Given an integer array nums of size n, return the number with the value closest to 0 in nums. If there are multiple answers, return the number with the largest value.

Example 1:

Input: nums = [-4,-2,1,4,8]
Output: 1
Explanation:
The distance from -4 to 0 is |-4| = 4.
The distance from -2 to 0 is |-2| = 2.
The distance from 1 to 0 is |1| = 1.
The distance from 4 to 0 is |4| = 4.
The distance from 8 to 0 is |8| = 8.
Thus, the closest number to 0 in the array is 1.

Example 2:

Input: nums = [2,-1,1]
Output: 1
Explanation: 1 and -1 are both the closest numbers to 0, so 1 being larger is returned.

Constraints:

1 <= n <= 1000
-10⁵ <= nums[i] <= 10⁵

Solution: ABS

Time complexity: O(n)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int findClosestNumber(vector<int>& nums) {

return *min_element(begin(nums), end(nums), [](int a, int b){

return abs(a) < abs(b) || (abs(a) == abs(b) && a > b);

});

}

};

花花酱 LeetCode 2236. Root Equals Sum of Children

By zxi on April 16, 2022

You are given the root of a binary tree that consists of exactly 3 nodes: the root, its left child, and its right child.

Return true if the value of the root is equal to the sum of the values of its two children, or false otherwise.

Example 1:

Input: root = [10,4,6]
Output: true
Explanation: The values of the root, its left child, and its right child are 10, 4, and 6, respectively.
10 is equal to 4 + 6, so we return true.

Example 2:

Input: root = [5,3,1]
Output: false
Explanation: The values of the root, its left child, and its right child are 5, 3, and 1, respectively.
5 is not equal to 3 + 1, so we return false.

Constraints:

The tree consists only of the root, its left child, and its right child.
-100 <= Node.val <= 100

Solution:

Just want to check whether you know binary tree or not.

Time complexity: O(1)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

bool checkTree(TreeNode* root) {

return root->val == root->left->val + root->right->val;

}

};

花花酱 LeetCode 2235. Add Two Integers

By zxi on April 16, 2022

Given two integers num1 and num2, return the sum of the two integers.

Example 1:

Input: num1 = 12, num2 = 5
Output: 17
Explanation: num1 is 12, num2 is 5, and their sum is 12 + 5 = 17, so 17 is returned.

Example 2:

Input: num1 = -10, num2 = 4
Output: -6
Explanation: num1 + num2 = -6, so -6 is returned.

Constraints:

-100 <= num1, num2 <= 100

Solution: Just sum them up

Time complexity: O(1)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int sum(int num1, int num2) {

return num1 + num2;

}

};

花花酱 LeetCode 2231. Largest Number After Digit Swaps by Parity

By zxi on April 9, 2022

You are given a positive integer num. You may swap any two digits of num that have the same parity (i.e. both odd digits or both even digits).

Return the largest possible value of num after any number of swaps.

Example 1:

Input: num = 1234
Output: 3412
Explanation: Swap the digit 3 with the digit 1, this results in the number 3214.
Swap the digit 2 with the digit 4, this results in the number 3412.
Note that there may be other sequences of swaps but it can be shown that 3412 is the largest possible number.
Also note that we may not swap the digit 4 with the digit 1 since they are of different parities.

Example 2:

Input: num = 65875
Output: 87655
Explanation: Swap the digit 8 with the digit 6, this results in the number 85675.
Swap the first digit 5 with the digit 7, this results in the number 87655.
Note that there may be other sequences of swaps but it can be shown that 87655 is the largest possible number.

Constraints:

1 <= num <= 10⁹

Solution:

Put all even digits into one array, all odd digits into another one, all digits into the third. Sort two arrays, and generate a new number from sorted arrays.

Time complexity: O(logn*loglogn)
Space complexity: O(logn)

C++

// Author: Huahua

class Solution {

public:

int largestInteger(int num) {

vector<int> odd, even, org;

for (int cur = num; cur; cur /= 10) {

((cur & 1) ? odd : even).push_back(cur % 10);

org.push_back(cur % 10);

}

sort(begin(odd), end(odd));

sort(begin(even), end(even));

int ans = 0;

for (int i = 0; i < org.size(); ++i) {

if (i) ans *= 10;

auto& cur = (org[org.size() - i - 1] & 1) ? odd : even;

ans += cur.back();

cur.pop_back();

}

return ans;

}

};

Posts tagged as “easy”

花花酱 LeetCode 2243. Calculate Digit Sum of a String

Solution:

C++

花花酱 LeetCode 2239. Find Closest Number to Zero

Solution: ABS

C++

花花酱 LeetCode 2236. Root Equals Sum of Children

Solution:

C++

花花酱 LeetCode 2235. Add Two Integers

Solution: Just sum them up

C++

花花酱 LeetCode 2231. Largest Number After Digit Swaps by Parity

C++