# Daily Coding Challenge #90

This is a series of Daily Coding Challenge. Each day I show a few solutions written in C++. The questions are from coding practice/contest sites such as HackerRank, LeetCode, Codeforces, Atcoder and etc.

/*
Kth Missing Positive Number

Given an array arr of positive integers sorted in a strictly increasing order, and an integer k.

Find the kth positive integer that is missing from this array.

Example 1:

Input: arr = [2,3,4,7,11], k = 5
Output: 9
Explanation: The missing positive integers are [1,5,6,8,9,10,12,13,...]. The 5th missing positive integer is 9.
Example 2:

Input: arr = [1,2,3,4], k = 2
Output: 6
Explanation: The missing positive integers are [5,6,7,...]. The 2nd missing positive integer is 6.
*/

class Solution {
public:
int findKthPositive(vector<int>& arr, int k) {
for(int i=1;;i++){
// find if the number exists, decrease k by 1 if not
if(find(arr.begin(),arr.end(),i)==arr.end()) k--;
// if k==0, i would be the ans
if(k==0) return i;
}
}
};

class Solution2 {
public:
int findKthPositive(vector<int>& arr, int k) {
// binary search approach
int n=arr.size();
if(n==0||arr[0]>k)return k;
if(arr[n-1]<n+k) return n+k;
int l=0;
int r=n-1;
while(l<r){
int mid=l+(r-l)/2;
if(arr[mid]-(mid+1)<k) l=mid+1;
else r=mid;
}
return k+l;
}
};


/*
Can Convert String in K Moves

Given two strings s and t, your goal is to convert s into t in k moves or less.

During the ith (1 <= i <= k) move you can:

Choose any index j (1-indexed) from s, such that 1 <= j <= s.length and j has not been chosen in any previous move, and shift the character at that index i times.
Do nothing.
Shifting a character means replacing it by the next letter in the alphabet (wrapping around so that 'z' becomes 'a'). Shifting a character by i means applying the shift operations i times.

Remember that any index j can be picked at most once.

Return true if it's possible to convert s into t in no more than k moves, otherwise return false.

Example 1:

Input: s = "input", t = "ouput", k = 9
Output: true
Explanation: In the 6th move, we shift 'i' 6 times to get 'o'. And in the 7th move we shift 'n' to get 'u'.
Example 2:

Input: s = "abc", t = "bcd", k = 10
Output: false
Explanation: We need to shift each character in s one time to convert it into t. We can shift 'a' to 'b' during the 1st move. However, there is no way to shift the other characters in the remaining moves to obtain t from s.
Example 3:

Input: s = "aab", t = "bbb", k = 27
Output: true
Explanation: In the 1st move, we shift the first 'a' 1 time to get 'b'. In the 27th move, we shift the second 'a' 27 times to get 'b'.

Constraints:

1 <= s.length, t.length <= 10^5
0 <= k <= 10^9
s, t contain only lowercase English letters.
*/

class Solution {
public:
bool canConvertString(string s, string t, int k) {
int m=s.size(), n=t.size();
if(m!=n) return false; // s and t must have the same length
unordered_map<int,int> mp;
for(int i=0;i<n;i++){
// calculate the diff between two characters
int diff=(t[i]-s[i]+26)%26;
// if both character is not same, and it requires more than k moves, return false
if(diff>0&&diff+mp[diff]*26>k) return false;
mp[diff]++;
}
return true;
}
};


/*
Minimum Insertions to Balance a Parentheses String

Given a parentheses string s containing only the characters '(' and ')'. A parentheses string is balanced if:

Any left parenthesis '(' must have a corresponding two consecutive right parenthesis '))'.
Left parenthesis '(' must go before the corresponding two consecutive right parenthesis '))'.
For example, "())", "())(())))" and "(())())))" are balanced, ")()", "()))" and "(()))" are not balanced.

You can insert the characters '(' and ')' at any position of the string to balance it if needed.

Return the minimum number of insertions needed to make s balanced.

Example 1:

Input: s = "(()))"
Output: 1
Explanation: The second '(' has two matching '))', but the first '(' has only ')' matching. We need to to add one more ')' at the end of the string to be "(())))" which is balanced.
Example 2:

Input: s = "())"
Output: 0
Explanation: The string is already balanced.
Example 3:

Input: s = "))())("
Output: 3
Explanation: Add '(' to match the first '))', Add '))' to match the last '('.
Example 4:

Input: s = "(((((("
Output: 12
Explanation: Add 12 ')' to balance the string.
Example 5:

Input: s = ")))))))"
Output: 5
Explanation: Add 4 '(' at the beginning of the string and one ')' at the end. The string becomes "(((())))))))".

Constraints:

1 <= s.length <= 10^5
s consists of '(' and ')' only.
*/

class Solution {
public:
int minInsertions(string s) {
// right : the number we need to add for ')'
for(char c:s){
if(c=='('){
// if right is odd, it only needs 1 more ')'
// if even, it needs '))'
right+=2;
}else{
right--;
// we need '(' and ')' as '(' needs '))'
}
}
}
};


The source code is available in corresponding repo below. Star and watch for timely updates!

## wingkwong / atcoder

Posted on by:

### Wing-Kam

Consultant by day. Developer by night. AWS certified. Exploring #CloudNative currently.