Easy on Jiang Yi(姜祎)'s Homepage

506. Relative Ranks

Thu, 22 Aug 2024 21:36:01 +0800

Given an integer, flip all bits in its binary representation.

Intuition

Use XOR operation to complete this task.

Approach

We can use the XOR operation to complete this task. However, notice that we cannot simply use num ^ INT_MAX since the leading 1s are still 1s if num is too small. Instead, we need to compute the number of digits in num, and use the corresponding masks.

Notice that if 2^30 < num <= 2^31-1, in this case the corresponding mask will exceeds the integer ranges, thus we use INT_MAX directly in this case.

Complexity

Time complexity: Compute the digits of a number.
$$O(\log n)$$
Space complexity: No extra spaces needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 int findComplement(int num) {
 int num_bits = 0;
 int temp = num;
 while (temp) {
 temp >>= 1;
 ++num_bits;
 }
 if (num_bits == 31) {
 return num ^ INT_MAX;
 }
 int mask = (1 << num_bits) - 1;
 return num ^ mask;
 }
};

Reference

leetcode 476

506. Relative Ranks

Wed, 08 May 2024 20:17:53 +0800

Given an array of scores, assign different ranks based on their position in the sorted array

Intuition

Sort the array and assign based on the sorted array.

Approach

in C++, we can use the property of the container map to solve this problem, the map is constructed so that the key is the score and the value is the index of the score.

Complexity

Time complexity: construct the map
$$O(n\log n)$$
Space complexity: store the scores and indexes
$$O(n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 vector<string> findRelativeRanks(vector<int>& score) {
 map<int, int> m;
 for (int i = 0; i < score.size(); ++i) {
 m[score[i]] = i;
 }
 vector<string> result(score.size());
 int index = 1;
 for (auto iter = m.rbegin(); iter != m.rend(); ++iter, ++index) {
 if (index == 1) result[iter->second] = "Gold Medal";
 else if (index == 2) result[iter->second] = "Silver Medal";
 else if (index == 3) result[iter->second] = "Bronze Medal";
 else result[iter->second] = to_string(index);
 }
 return result;
 }
};

Reference

leetcode 506

2441. Largest Positive Integer That Exists With Its Negative

Thu, 02 May 2024 10:28:05 +0800

Given a list containing integers, find the largest positive integer that its negative also exists in the list.

Intuition

There are two ways to solve the problem.

One way is to use two sum, we find the all pairs of integers such that their sum is zero and the one is the negative of the other.
The second way is to use two pointer, we move left and right pointer utils their absolute values are equal.

Approach 1: two sum

Similar to Two Sum, for each num in nums, we store its negative -num in the hash table, however, notice that the added term can be determined by num, we can use a set instead.

Complexity

Time complexity: iterate the list once.
$$O(n)$$
Space complexity: use a set to store numbers.
$$O(n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 int findMaxK(vector<int>& nums) {
 set<int> s;
 int result = -1;
 for (int num: nums) {
 if (s.find(-num) != s.end()) {
 result = max(result, abs(num));
 } else {
 s.insert(num);
 }
 }
 return result;
 }
};

Approach 2: two pointer

We first sort the lists, then we use left=0 and right=length(nums) pointer to iterate the list, there are three cases:

if nums[left] == -nums[right], then we directly return nums[right] since this is the largest one (note that the list is sorted)
if nums[left] < -nums[right], then we update left to left + 1 since (nums[left], -nums[left]) cannot be found in the list.
if nums[left] > -nums[right], then we update right to right - 1 since (-nums[right], nums[right]) cannot be found in the list.

Complexity

Time complexity: sort the array and iterate the list once.
$$O(n\log n)$$
Space complexity: no extra spaces are needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 int findMaxK(vector<int>& nums) {
 sort(nums.begin(), nums.end());
 int left = 0, right = nums.size() - 1;
 while (left <= right) {
 if (nums[left] == -nums[right]) return nums[right];
 else if (nums[left] < -nums[right]) ++left;
 else --right;
 }
 return -1;
 }
};
``

# References
- [Leetcode](https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/description/)
- [Leetcode Two Sum](https://leetcode.com/problems/two-sum/)

2000. Reverse Prefix of Word

Wed, 01 May 2024 09:01:22 +0800

Given a string ans a specified character, reverse the prefix that is ended with the specified character.

Intuition

Simulate the process.

Approach

find the first occurrence of the specified character, then reverse the prefix.

Complexity

Time complexity: find the first occurrence of the specified character.
$$O(n)$$
Space complexity: no extra spaces are needed.
$$O(1)$$

Code

1
2
3
4
5
6
7
8
9


class Solution {
public:
 string reversePrefix(string word, char ch) {
 auto pos = word.find(ch);
 if (pos == word.npos) return word;
 reverse(word.begin(), word.begin() + pos + 1);
 return word;
 }
};