1012. Complement of Base 10 Integer
Every non-negative integerNhas a binary representation. For example,5can be represented as"101"in binary,11as"1011"in binary, and so on. Note that except forN = 0, there are no leading zeroes in any binary representation.The complement of a binary representation is the number in binary you get when changing every
1to a0and0to a1. For example, the complement of"101"in binary is"010"in binary.For a given number
Nin base-10, return the complement of it's binary representation as a base-10 integer.Example 1:
Input: 5 Output: 2 Explanation: 5 is "101" in binary, with complement "010" in binary, which is 2 in base-10.Example 2:
Input: 7 Output: 0 Explanation: 7 is "111" in binary, with complement "000" in binary, which is 0 in base-10.Example 3:
Input: 10 Output: 5 Explanation: 10 is "1010" in binary, with complement "0101" in binary, which is 5 in base-10.Note:
0 <= N < 10^9
Approach #1: Math. [C++]
class Solution {
public:
int bitwiseComplement(int N) {
int X = 1;
while (N > X) X = X * 2 + 1;
return X ^ N;
}
};
Analysis:
Claim ----- The XOR operation evaluates the difference in the individual bits, i.e it gives information about whether the bits are identical or not.
Proof ----- It's easy once youknow the definition of XOR. 0^0 = 1^1 = 0 (as the bits don't differ), whereas 0^1 = 1^0 = 1 (as the bits are difference).
Claim ----- XOR of identical numbers is zero.
Proof ----- As argued above, the bits of identical numbers do not differ at any position. Hence, XOR is zero.
Claim ----- 0 XOR any number is the number itself.
Proof ----- XOR gives us the bit difference. Since all the bits in 0 are unset, therefore the difference in bits is the number itself.
Claim ----- XOR of a number with its complement results in a number with all set bits.
Proof ----- This is trivial, since bits of a number and its complement differ at every position(according to the definition of complement).
So, number ^ complement = all_set_bits ==> number ^ number ^ complement = number ^ all_set_bits ===> 0 ^ complement = number ^ all_set_bits
So, complement = number ^ all_set_bits.
So, we find out the number containing all the set bits and XOR with the original number to get the answer.
Reference:
1013. Pairs of Songs With Total Durations Divisible by 60
In a list of songs, the
i-th song has a duration oftime[i]seconds.Return the number of pairs of songs for which their total duration in seconds is divisible by
60. Formally, we want the number of indicesi < jwith(time[i] + time[j]) % 60 == 0.Example 1:
Input: [30,20,150,100,40] Output: 3 Explanation: Three pairs have a total duration divisible by 60: (time[0] = 30, time[2] = 150): total duration 180 (time[1] = 20, time[3] = 100): total duration 120 (time[1] = 20, time[4] = 40): total duration 60Example 2:
Input: [60,60,60] Output: 3 Explanation: All three pairs have a total duration of 120, which is divisible by 60.Note:
1 <= time.length <= 600001 <= time[i] <= 500
Approach #1: Brute force + Map. [C++]
class Solution {
public:
int numPairsDivisibleBy60(vector<int>& time) {
int ans = 0;
int len = time.size();
map<int, vector<int>> m;
vector<int> duration = {60, 120, 180, 240, 300, 360, 420, 480, 540, 600,
660, 720, 780, 840, 900, 960, 1020};
for (int i = 0; i < len; ++i) m[time[i]].push_back(i);
for (int i = 0; i < len; ++i) {
for (int j = 0; j < duration.size(); ++j) {
if (duration[j] - time[i] > 0) {
int tmp = duration[j] - time[i];
if (m.count(tmp)) {
int count = m[tmp].end() - upper_bound(m[tmp].begin(), m[tmp].end(), i);
ans += count;
}
}
}
}
return ans;
}
};
Approach #2: Orz.
int numPairsDivisibleBy60(vector<int>& time) {
vector<int> c(60);
int res = 0;
for (int t : time) {
res += c[(60 - t % 60) % 60];
c[t % 60] += 1;
}
return res;
}
Analysis:
Calculate the time%60 then it will be exactly same as two sum problem.
Reference:
1014. Capacity To Ship Packages Within D Days
A conveyor belt has packages that must be shipped from one port to another within
Ddays.The
i-th package on the conveyor belt has a weight ofweights[i]. Each day, we load the ship with packages on the conveyor belt (in the order given byweights). We may not load more weight than the maximum weight capacity of the ship.Return the least weight capacity of the ship that will result in all the packages on the conveyor belt being shipped within
Ddays.Example 1:
Input: weights = [1,2,3,4,5,6,7,8,9,10], D = 5 Output: 15 Explanation: A ship capacity of 15 is the minimum to ship all the packages in 5 days like this: 1st day: 1, 2, 3, 4, 5 2nd day: 6, 7 3rd day: 8 4th day: 9 5th day: 10 Note that the cargo must be shipped in the order given, so using a ship of capacity 14 and splitting the packages into parts like (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) is not allowed.Example 2:
Input: weights = [3,2,2,4,1,4], D = 3 Output: 6 Explanation: A ship capacity of 6 is the minimum to ship all the packages in 3 days like this: 1st day: 3, 2 2nd day: 2, 4 3rd day: 1, 4Example 3:
Input: weights = [1,2,3,1,1], D = 4 Output: 3 Explanation: 1st day: 1 2nd day: 2 3rd day: 3 4th day: 1, 1Note:
1 <= D <= weights.length <= 500001 <= weights[i] <= 500
Approach #1: Binary search. [C++]
class Solution {
public:
int shipWithinDays(vector<int>& weights, int D) {
int left = *max_element(weights.begin(), weights.end());
int right = 25000000;
while (left < right) {
int mid = (right + left) / 2;
int need = 1, cur = 0;
for (int i = 0; i < weights.size() && need <= D; cur += weights[i++]) {
if (cur + weights[i] > mid)
cur = 0, need++;
}
if (need > D) left = mid + 1;
else right = mid;
}
return left;
}
};
Analysis:
Given the number of bags, return the minimum capacity of each bag, so that we can put items one by one into all bags.
Reference:
1015. Numbers With Repeated Digits
Given a positive integer N, return the number of positive integers less than or equal to N that have at least 1 repeated digit.
Example 1:
Input: 20
Output: 1
Explanation: The only positive number (<= 20) with at least 1 repeated digit is 11.
Example 2:
Input: 100
Output: 10
Explanation: The positive numbers (<= 100) with atleast 1 repeated digit are 11, 22, 33, 44, 55, 66, 77, 88, 99, and 100.
Example 3:
Input: 1000
Output: 262
Note:
1 <= N <= 10^9
Approach #1:
class Solution {
public:
int numDupDigitsAtMostN(int N) {
int invalid = 0;
int c = floor(log10(N+1)) + 1;
for (int i = 0; i < c-1; ++i) {
invalid += 9 * perm(9, i);
}
int digits = 0;
for (int i = 0; i < c; ++i) {
int digit = ((N+1) / (int)pow(10, c-i-1)) % 10;
for (int j = (i > 0 ? 0 : 1); j < digit; ++j) {
if (((digits >> j) & 1) == 0) {
invalid += perm(9 - i, c - i - 1);
}
}
if ((digits >> digit) & 1) break;
digits |= 1 << digit;
}
return N - invalid;
}
int perm(int m, int n) {
int out = 1;
while (m > 1 && n > 0) {
out *= m;
m--;
n--;
}
return out;
}
};
Analysis:
For example, with the number 350, we have 3 digits, meaning we can start by finding all invalid numbers from 0 to 99 (e.g. the first two digits). To start, let's assuming we only have 1 digit available. In this case, we can't vary any other digits in the number since there are none, and because there is only 1 digit they are all invalid. Thus, since there are 9 total numbers with 1 digit, we have 9 invalid permutations for this digit. Similary, for 2 digits, we have 1 digit we can vary (e.g. 1x has x that can be varied, 2y has y that can be varied, so on and so forth). Plugging that into our formula, we have perm(9,1) which results in 9. Because there are 9 possible digits for the first digit, we can multiply the result by 9 (perm(9, 1) * 9) which gives us 81 invalid digits. Adding that onto our first result of 9, and we get 90 invalid for a number range of 1-99 (meaning we have 9 valid digits in that range).
At this point, for the number 350, we know that thare are at least 90 invalid digits from 1 - 100 as a result (since 100 is valid). Now however we need to count the number of invalid digits from 100 - 350. This can be done by varying each of the digits in 351 (e.g. N+1), and finding the valid permutations of that as a result. For example:
3XX -> perm(9-0, 3-0-1) -> perm(9, 2) X5X -> perm(9-1, 3-1-1) -> perm(8, 1) XX1 -> perm(9-2, 3-2-1) -> perm(7, 0)We then add this number of invalid permutations to our count based on the number we have. However, if we have previously seen a number in that range. we ignore it. For example, when we get to the 5 in 351, we will only add perm(8, 1)'s result 4 time, since the third time has alredy been accounted for when we went over the 3 in 351. Once we've done all of this, we can simply subtract our number of nvalid numbers from our original number N to get our result.
Here is what this process looks like in action:
350 -> 351 invalid digits -> 0 1 digit -> X -> perm(9, 0) * 9 -> 9 invalid digits 2 digits -> YX -> perm(9, 1) * 9 -> 81 invalid digits invalid digits -> 90 0XX -> invalid so don't count the invalid digits. 1XX -> perm(9, 2) -> 72 invalid digits 2XX -> perm(9, 2) -> 72 invalid digits 3XX -> stop counting invalid numbers for the first digit. X0X -> perm(8, 1) -> 8 invalid digits X1X -> perm(8, 1) -> 8 invalid digits X2X -> perm(8, 1) -> 8 invalid digits X3X -> perm(8, 1) -> 8 invalid digits -> but because we've already looked at the digit 3 previously we can skip this. X4X -> perm(8, 1) -> 8 invalid digits X5X -> stop counting invalid numbers for the second digit. XX0 -> perm(7, 0) -> 1 invalid digit XX1 -> stop counting invalid numbers for the third and final digit. invalid digits -> 267 result -> 350 - 267 = 83
Reference: