algo_input
stringlengths 240
3.91k
| solution_py
stringlengths 10
6.72k
| solution_java
stringlengths 87
8.97k
| solution_c
stringlengths 10
7.38k
| solution_js
stringlengths 10
4.56k
| title
stringlengths 3
77
|
|---|---|---|---|---|---|
Alice and Bob take turns playing a game, with Alice starting first.
Initially, there are n stones in a pile. On each player's turn, that player makes a move consisting of removing any non-zero square number of stones in the pile.
Also, if a player cannot make a move, he/she loses the game.
Given a positive integer n, return true if and only if Alice wins the game otherwise return false, assuming both players play optimally.
Example 1:
Input: n = 1
Output: true
Explanation: Alice can remove 1 stone winning the game because Bob doesn't have any moves.
Example 2:
Input: n = 2
Output: false
Explanation: Alice can only remove 1 stone, after that Bob removes the last one winning the game (2 -> 1 -> 0).
Example 3:
Input: n = 4
Output: true
Explanation: n is already a perfect square, Alice can win with one move, removing 4 stones (4 -> 0).
Constraints:
1 <= n <= 105
| class Solution:
def winnerSquareGame(self, n: int) -> bool:
squares = lambda x: (i * i for i in range(isqrt(x), 0, -1))
@cache
def can_win(n: int) -> bool:
return n and not all(can_win(n - s) for s in squares(n))
return can_win(n) | class Solution {
// idea: Alice wins a game with n stones if and only if there exists
// some perfect square p <= n such that Alice wins a game with
// n - p stones... i.e., Bob DOES NOT win a game with n - p stones
public boolean winnerSquareGame(int n) {
// this bit would be better with just an array of booleans, but this
// is how i thought of it at the time, so leaving it this way...
// maybe it will be "more explicit" and help someone better understand dp?
HashMap<Integer, Boolean> memo = new HashMap<>();
memo.put(1, true); // if there is one stone in the pile to begin the game, the next player to go wins
memo.put(0, false); // if there are zero stones in the pile to begin the game, the next player to go loses
List<Integer> perfectSquares = new ArrayList<>();
int i = 1;
while (i * i <= n) {
perfectSquares.add(i * i);
i++;
}
// if there are some perfect square number of stones in the pile to begin the game, the next player to go wins
perfectSquares.forEach(p -> memo.put(p, true));
// Alice goes first...
return this.playerWins(n, perfectSquares, memo);
}
private boolean playerWins(int n, List<Integer> P, HashMap<Integer, Boolean> m) {
if (m.containsKey(n)) { return m.get(n); } // if we already computed the answer for n, just return it
m.put(n, false); // otherwise, assume it's false to begin...
for (Integer p : P) { // check every perfect square p...
if (p <= n && !playerWins(n - p, P, m)) {
// if p <= n AND the player who goes next (e.g., Bob) does not win a game that begins with
// n - p stones, then we know that the player whose turn it is right now (e.g., Alice) wins
// a game that begins with n stones, so record this discovery in the memo and then break out
// of the loop because there's no more work to do...
m.put(n, true);
break;
} // else p >= n OR taking p stones would not result in a win for the player whose turn it is right now...
}
// we put false in before the loop; if we never found a reason to change it to true,
// then false is the correct result...
return m.get(n);
}
} | class Solution {
public:
bool winnerSquareGame(int n) {
vector<int> dp(n+1,false);
for(int i=1;i<=n;i++){
for(int j=sqrt(i);j>=1;j--){
if(dp[i-j*j] == false){
dp[i] = true;
break;
}
}
}
return dp[n];
}
}; | var winnerSquareGame = function(n) {
const map = new Map();
map.set(0, false);
map.set(1, true);
const dfs = (num) => {
if( map.has(num) ) return map.get(num);
let sqRoot = Math.floor(Math.sqrt(num));
for(let g=1; g<=sqRoot; g++){
if( !dfs(num - (g*g)) ) {
map.set(num, true);
return true;
}
}
map.set(num, false);
return false;
}
return dfs(n)
}; | Stone Game IV |
In an n*n grid, there is a snake that spans 2 cells and starts moving from the top left corner at (0, 0) and (0, 1). The grid has empty cells represented by zeros and blocked cells represented by ones. The snake wants to reach the lower right corner at (n-1, n-2) and (n-1, n-1).
In one move the snake can:
Move one cell to the right if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.
Move down one cell if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.
Rotate clockwise if it's in a horizontal position and the two cells under it are both empty. In that case the snake moves from (r, c) and (r, c+1) to (r, c) and (r+1, c).
Rotate counterclockwise if it's in a vertical position and the two cells to its right are both empty. In that case the snake moves from (r, c) and (r+1, c) to (r, c) and (r, c+1).
Return the minimum number of moves to reach the target.
If there is no way to reach the target, return -1.
Example 1:
Input: grid = [[0,0,0,0,0,1],
[1,1,0,0,1,0],
[0,0,0,0,1,1],
[0,0,1,0,1,0],
[0,1,1,0,0,0],
[0,1,1,0,0,0]]
Output: 11
Explanation:
One possible solution is [right, right, rotate clockwise, right, down, down, down, down, rotate counterclockwise, right, down].
Example 2:
Input: grid = [[0,0,1,1,1,1],
[0,0,0,0,1,1],
[1,1,0,0,0,1],
[1,1,1,0,0,1],
[1,1,1,0,0,1],
[1,1,1,0,0,0]]
Output: 9
Constraints:
2 <= n <= 100
0 <= grid[i][j] <= 1
It is guaranteed that the snake starts at empty cells.
| class Solution:
def minimumMoves(self, grid: List[List[int]]) -> int:
queue , vis , n = [(0,1,0,0)] , {} , len(grid)
while queue:
x,y,pos,moves = queue.pop(0)
if x == y == n-1 and pos == 0: return moves
if pos == 0:
if y + 1 < n and grid[x][y+1] == 0 and (x,y+1,0) not in vis:
vis[(x,y+1,0)] = True
queue.append((x,y+1,0,moves+1))
if x + 1 < n and grid[x+1][y-1] == 0 and grid[x+1][y] == 0:
if (x+1,y-1,1) not in vis:
vis[(x+1,y-1,1)] = True
queue.append((x+1,y-1,1,moves+1))
if (x+1,y,0) not in vis:
vis[(x+1,y,0)] = True
queue.append((x+1,y,0,moves+1))
else:
if x + 1 < n and grid[x+1][y] == 0 and (x+1,y,1) not in vis:
vis[(x+1,y,1)] = True
queue.append((x+1,y,1,moves+1))
if y + 1 < n and grid[x-1][y+1] == grid[x][y+1] == 0:
if (x-1,y+1,0) not in vis:
vis[(x-1,y+1,0)] = True
queue.append((x-1,y+1,0,moves+1))
if (x,y+1,1) not in vis:
vis[(x,y+1,1)] = True
queue.append((x,y+1,1,moves+1))
return -1 | class Solution {
public int minimumMoves(int[][] grid) {
int n = grid.length;
//boolean[][][][] visited = new boolean[n][n][n][n];
Set<Position> set = new HashSet<>();
Queue<Position> q = new LinkedList<>();
q.offer(new Position(0,0,0,1));
int count = 0;
if(grid[n-1][n-2] == 1 || grid[n-1][n-1] == 1)
return -1;
while(!q.isEmpty()){
++count;
Queue<Position> nextq = new LinkedList<>();
while(!q.isEmpty()){
Position p = q.poll();
int r1 = p.getr1();
int r2 = p.getr2();
int c1 = p.getc1();
int c2 = p.getc2();
if(r1 == n-1 && r2 == n-1 && c1 == n-2 && c2==n-1)
return count-1;
if(set.contains(p))
continue;
if(c1+1 < n && grid[r1] [c1+1] != 1 && c2+1 < n && grid[r2] [c2+1] != 1)
nextq.offer(new Position(r1, c1+1, r2, c2+1));
if(r1+1 < n && grid[r1+1] [c1] != 1 && r2+1 < n && grid[r2+1] [c2] != 1)
nextq.offer(new Position(r1+1, c1, r2+1, c2));
if(r1 == r2 && r1+1 < n && r2+1 < n && grid[r1+1][c1] == 0 && grid[r2+1][c2] == 0 && grid[r1+1][c1] == 0)
nextq.offer(new Position(r1,c1, r1+1, c1));
if(c1 == c2 && c1+1 < n && c2+1 < n && grid[r1][c1+1] == 0 && grid[r2][c1+1] == 0 && grid[r1][c1+1] == 0)
nextq.offer(new Position(r1,c1, r1, c1+1));
set.add(p);
}
q = nextq;
}
return -1;
}
private class Position{
int r1;
int c1;
int r2;
int c2;
public Position(int r1, int c1, int r2, int c2){
this.r1 = r1;
this.r2 = r2;
this.c1 =c1;
this.c2 = c2;
}
public int getr1(){
return this.r1;
}
public int getr2(){
return this.r2;
}
public int getc1(){
return this.c1;
}
public int getc2(){
return this.c2;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * r1 + c1 + prime *r2 + c2;
return result;
}
@Override
public boolean equals(Object obj) {
Position p = (Position) obj;
if(this.r1 == p.getr1() && this.r2 ==p.getr2() && this.c1 == p.getc1() && this.c2==p.getc2())
return true;
else
return false;
}
}
} | class Solution {
public:
int n;
set<vector<int>> visited;
bool candown(vector<vector<int>>& grid,int x,int y,bool hor){
if(!hor){
if(x+2<n && grid[x+1][y]==0 && grid[x+2][y]==0 && !visited.count({x+1,y,hor})){
return true;
}
}else{
if(x+1<n && y+1<n && grid[x+1][y]==0 && grid[x+1][y+1]==0 && !visited.count({x+1,y,hor})){
return true;
}
}
return false;
}
bool canright(vector<vector<int>>& grid,int x,int y,bool hor){
if(hor){
if(y+2<n && grid[x][y+1]==0 && grid[x][y+2]==0 && !visited.count({x,y+1,hor})){
return true;
}
}else{
if(y+1<n && x+1<n && grid[x][y+1]==0 && grid[x+1][y+1]==0 && !visited.count({x,y+1,hor})){
return true;
}
}
return false;
}
bool canrot(vector<vector<int>>& grid,int x,int y,bool hor){
if(hor){
if(y+1<n && x+1<n && grid[x+1][y]==0 && grid[x+1][y+1]==0 && !visited.count({x,y,!hor})){
return true;
}
}else{
if(x+1<n && y+1<n && grid[x][y+1]==0 &&grid[x+1][y+1]==0 && !visited.count({x,y,!hor})){
return true;
}
}
return false;
}
int minimumMoves(vector<vector<int>>& grid) {
queue<array<int, 3>> q;
q.push({0,0,true});
int ans=0;
n=grid.size();
while(!q.empty()){
int size=q.size();
while(size--){
auto a=q.front();
q.pop();
if(visited.count({a[0],a[1],a[2]})){
continue;
}
visited.insert({a[0],a[1],a[2]});
int x=a[0];
int y=a[1];
if(x==n-1 && y==n-2 && a[2]==1){
return ans;
}
if(candown(grid,x,y,a[2])){
q.push({x+1,y,a[2]});
}
if(canrot(grid,x,y,a[2])){
q.push({x,y,!a[2]});
}
if(canright(grid,x,y,a[2])){
q.push({x,y+1,a[2]});
}
}
ans++;
}
return -1;
}
}; | /**
* @param {number[][]} grid
* @return {number}
*/
var minimumMoves = function(grid) {
const len = grid.length;
const initPosition = [0, true, 1]
const visited = new Set([initPosition.join()]);
const queue = new Queue();
initPosition.push(0);
queue.enqueue(initPosition)
while (!queue.isEmpty()) {
let [row, isHorizontal, col, numMoves] = queue.dequeue();
if (row + col === len * 2 - 2 && isHorizontal) return numMoves;
numMoves++;
const positions = [];
if (isHorizontal) {
if (grid[row][col + 1] === 0) {
positions.push([row, true, col + 1])
}
if (row + 1 < len && grid[row + 1][col - 1] === 0 && grid[row + 1][col] === 0) {
positions.push([row + 1, true, col])
positions.push([row + 1, false, col - 1]);
}
} else {
if (row + 1 < len && grid[row + 1][col] === 0) {
positions.push([row + 1, false, col]);
}
if (row > 0 && grid[row - 1][col + 1] === 0 && grid[row][col + 1] === 0) {
positions.push([row, false, col + 1]);
positions.push([row - 1, true, col + 1]);
}
}
for (let position of positions) {
const str = position.join();
if (visited.has(str)) continue;
visited.add(str);
position.push(numMoves);
queue.enqueue(position);
}
}
return -1;
};
class Queue {
constructor() {
this.head = { next: null };
this.tail = this.head;
}
isEmpty() {
return this.head.next === null;
}
dequeue() {
const { value } = this.head.next;
this.head = this.head.next;
return value;
}
enqueue(value) {
this.tail.next = { value, next: null };
this.tail = this.tail.next;
}
} | Minimum Moves to Reach Target with Rotations |
You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.
Merge nums1 and nums2 into a single array sorted in non-decreasing order.
The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.
Example 1:
Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
Output: [1,2,2,3,5,6]
Explanation: The arrays we are merging are [1,2,3] and [2,5,6].
The result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1.
Example 2:
Input: nums1 = [1], m = 1, nums2 = [], n = 0
Output: [1]
Explanation: The arrays we are merging are [1] and [].
The result of the merge is [1].
Example 3:
Input: nums1 = [0], m = 0, nums2 = [1], n = 1
Output: [1]
Explanation: The arrays we are merging are [] and [1].
The result of the merge is [1].
Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.
Constraints:
nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[j] <= 109
Follow up: Can you come up with an algorithm that runs in O(m + n) time?
| class Solution(object):
def merge(self, nums1, m, nums2, n):
# Initialize nums1's index
i = m - 1
# Initialize nums2's index
j = n - 1
# Initialize a variable k to store the last index of the 1st array...
k = m + n - 1
while j >= 0:
if i >= 0 and nums1[i] > nums2[j]:
nums1[k] = nums1[i]
k -= 1
i -= 1
else:
nums1[k] = nums2[j]
k -= 1
j -= 1 | class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
// Initialize i and j to store indices of the last element of 1st and 2nd array respectively...
int i = m - 1 , j = n - 1;
// Initialize a variable k to store the last index of the 1st array...
int k = m + n - 1;
// Create a loop until either of i or j becomes zero...
while(i >= 0 && j >= 0) {
if(nums1[i] >= nums2[j]) {
nums1[k] = nums1[i];
i--;
} else {
nums1[k] = nums2[j];
j--;
}
k--;
// Either of i or j is not zero, which means some elements are yet to be merged.
// Being already in a sorted manner, append them to the 1st array in the front.
}
// While i does not become zero...
while(i >= 0)
nums1[k--] = nums1[i--];
// While j does not become zero...
while(j >= 0)
nums1[k--] = nums2[j--];
// Now 1st array has all the elements in the required sorted order...
return;
}
} | class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
vector<int> temp(n+m);
int i=0,j=0,k=0;
while(i<m && j<n){ //select smaller element from both vector
if(nums1[i]<nums2[j]){
temp[k]=nums1[i];
i++;
k++;
}
else{
temp[k]=nums2[j];
j++;
k++;
}
}
while(i<m){ //insert remaining nums1 element
temp[k]=nums1[i];
i++;
k++;
}
while(j<n){ //insert remaining nums2 element
temp[k]=nums2[j];
j++;
k++;
}
nums1=temp;
return ;
}
}; | var merge = function(nums1, m, nums2, n) {
// Initialize i and j to store indices of the last element of 1st and 2nd array respectively...
let i = m - 1 , j = n - 1;
// Initialize a variable k to store the last index of the 1st array...
let k = m + n - 1;
// Create a loop until either of i or j becomes zero...
while(i >= 0 && j >= 0) {
if(nums1[i] >= nums2[j]) {
nums1[k] = nums1[i];
i--;
} else {
nums1[k] = nums2[j];
j--;
}
k--;
// Either of i or j is not zero, which means some elements are yet to be merged.
// Being already in a sorted manner, append them to the 1st array in the front.
}
// While i does not become zero...
while(i >= 0)
nums1[k--] = nums1[i--];
// While j does not become zero...
while(j >= 0)
nums1[k--] = nums2[j--];
// Now 1st array has all the elements in the required sorted order...
return;
}; | Merge Sorted Array |
Given an array of strings nums containing n unique binary strings each of length n, return a binary string of length n that does not appear in nums. If there are multiple answers, you may return any of them.
Example 1:
Input: nums = ["01","10"]
Output: "11"
Explanation: "11" does not appear in nums. "00" would also be correct.
Example 2:
Input: nums = ["00","01"]
Output: "11"
Explanation: "11" does not appear in nums. "10" would also be correct.
Example 3:
Input: nums = ["111","011","001"]
Output: "101"
Explanation: "101" does not appear in nums. "000", "010", "100", and "110" would also be correct.
Constraints:
n == nums.length
1 <= n <= 16
nums[i].length == n
nums[i] is either '0' or '1'.
All the strings of nums are unique.
| class Solution(object):
def findDifferentBinaryString(self, nums):
ans='';
for i,num in enumerate(nums):
ans+= '1' if(num[i]=='0') else '0' #ternary if else
#ans+= str(1- int(num[i])); # Alternate: cast to string & 1-x to flip
return ans; | class Solution {
public String findDifferentBinaryString(String[] nums) {
StringBuilder ans= new StringBuilder();
for(int i=0; i<nums.length; i++)
ans.append(nums[i].charAt(i) == '0' ? '1' : '0'); // Using ternary operator
return ans.toString();
}
} | class Solution {
public:
string findDifferentBinaryString(vector<string>& nums) {
unordered_set<int> s;
for (auto num : nums) s.insert(stoi(num, 0, 2));
int res = 0;
while (++res) {
if (!s.count(res)) return bitset<16>(res).to_string().substr(16-nums.size());
}
return "";
}
}; | var findDifferentBinaryString = function(nums) {
return nums.map((s, i) => s[i] == 1 ? '0' : '1').join('');
}; | Find Unique Binary String |
Given the head of a linked list, we repeatedly delete consecutive sequences of nodes that sum to 0 until there are no such sequences.
After doing so, return the head of the final linked list. You may return any such answer.
(Note that in the examples below, all sequences are serializations of ListNode objects.)
Example 1:
Input: head = [1,2,-3,3,1]
Output: [3,1]
Note: The answer [1,2,1] would also be accepted.
Example 2:
Input: head = [1,2,3,-3,4]
Output: [1,2,4]
Example 3:
Input: head = [1,2,3,-3,-2]
Output: [1]
Constraints:
The given linked list will contain between 1 and 1000 nodes.
Each node in the linked list has -1000 <= node.val <= 1000.
| # Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeZeroSumSublists(self, head: Optional[ListNode]) -> Optional[ListNode]:
root = ListNode(0,head)
summ , d , node = 0 , {} , root
while node:
summ += node.val
if summ in d:
prev = d[summ]
tmp = prev.next
tmp_sum = summ
while tmp != node:
tmp_sum += tmp.val
if tmp_sum in d and d[tmp_sum] == tmp :d.pop(tmp_sum)
tmp = tmp.next
prev.next = node.next
node = prev
else:
d[summ] = node
node = node.next
return root.next | class Solution {
public ListNode removeZeroSumSublists(ListNode head) {
ListNode dummy = new ListNode(0);
dummy.next = head;
int prefix = 0;
ListNode curr = dummy;
Map<Integer, ListNode> seen = new HashMap<>();
seen.put(prefix, dummy);
while (curr != null) {
prefix += curr.val;
seen.put(prefix, curr);
curr = curr.next;
}
prefix = 0;
curr = dummy;
while (curr != null) {
prefix += curr.val;
curr.next = seen.get(prefix).next;
curr = curr.next;
}
return dummy.next;
}
} | class Solution {
public:
ListNode* removeZeroSumSublists(ListNode* head) {
unordered_map<int, ListNode*> m; // {prefix -> node}
ListNode* dummy = new ListNode(0);
ListNode* cur = dummy;
dummy->next = head;
int prefix = 0;
while(cur){
prefix += cur->val;
if(m[prefix] != NULL){
ListNode *t = m[prefix]->next;
int sum = prefix;
sum+=t->val;
while(sum != prefix){
m.erase(sum);
t = t->next;
sum+= t->val;
}
m[prefix]->next = cur->next;
}
else m[prefix] = cur;
cur = cur->next;
}
return dummy->next;
}
}; | var removeZeroSumSublists = function(head) {
const dummyHead = new ListNode();
dummyHead.next = head;
let prev = dummyHead;
let start = head;
while (start != null) {
let sum = 0;
let tail = start;
while (tail != null) {
sum += tail.val;
if (sum === 0) break;
tail = tail.next;
}
if (tail) {
prev.next = tail.next;
start = tail.next;
}
else {
prev = start;
start = start.next;
}
}
return dummyHead.next;
}; | Remove Zero Sum Consecutive Nodes from Linked List |
Given a palindromic string of lowercase English letters palindrome, replace exactly one character with any lowercase English letter so that the resulting string is not a palindrome and that it is the lexicographically smallest one possible.
Return the resulting string. If there is no way to replace a character to make it not a palindrome, return an empty string.
A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, a has a character strictly smaller than the corresponding character in b. For example, "abcc" is lexicographically smaller than "abcd" because the first position they differ is at the fourth character, and 'c' is smaller than 'd'.
Example 1:
Input: palindrome = "abccba"
Output: "aaccba"
Explanation: There are many ways to make "abccba" not a palindrome, such as "zbccba", "aaccba", and "abacba".
Of all the ways, "aaccba" is the lexicographically smallest.
Example 2:
Input: palindrome = "a"
Output: ""
Explanation: There is no way to replace a single character to make "a" not a palindrome, so return an empty string.
Constraints:
1 <= palindrome.length <= 1000
palindrome consists of only lowercase English letters.
| class Solution(object):
def breakPalindrome(self, palindrome):
"""
:type palindrome: str
:rtype: str
"""
s = palindrome
palindrome = [ch for ch in s]
if len(palindrome) == 1:
return ""
for i in range(len(palindrome)//2):
if palindrome[i] != 'a':
palindrome[i] = 'a'
return "".join(palindrome)
palindrome[-1] = 'b'
return "".join(palindrome)
| class Solution {
public String breakPalindrome(String palindrome) {
int left = 0;
int right = palindrome.length()-1;
if(palindrome.length()==1)
return "";
while(left<right){
char c = palindrome.charAt(left);
if(c!='a'){
StringBuilder sb = new StringBuilder(palindrome);
sb.setCharAt(left,'a');
return sb.toString();
}
else{
left++;
right--;
}
}
// aaaa
// aba
StringBuilder sb = new StringBuilder(palindrome);
sb.setCharAt(palindrome.length()-1,'b');
return sb.toString();
}
} | class Solution {
public:
string breakPalindrome(string palindrome) {
int n = palindrome.size();
string res = "";
if(n==1){
return res;
}
int i = 0;
while(i<n){
if(n%2!=0 && i==n/2){
i++;
continue;
}
if(palindrome[i] != 'a'){
palindrome[i] = 'a';
break;
}
i++;
}
if(i==n){
palindrome[i-1] = 'b';
}
return palindrome;
}
}; | var breakPalindrome = function(palindrome) {
// domain n / 2 k pehlay
palindrome = palindrome.split('');
const len = palindrome.length;
if(len == 1) return "";
const domain = Math.floor(len / 2);
let firstNonAChar = -1, lastAChar = -1;
for(let i = 0; i < domain; i++) {
if(palindrome[i] != 'a') {
firstNonAChar = i;
break;
}
}
if(firstNonAChar == -1) {
palindrome[len - 1] = 'b';
} else palindrome[firstNonAChar] = 'a';
return palindrome.join('');
}; | Break a Palindrome |
You are given an integer array nums. You want to maximize the number of points you get by performing the following operation any number of times:
Pick any nums[i] and delete it to earn nums[i] points. Afterwards, you must delete every element equal to nums[i] - 1 and every element equal to nums[i] + 1.
Return the maximum number of points you can earn by applying the above operation some number of times.
Example 1:
Input: nums = [3,4,2]
Output: 6
Explanation: You can perform the following operations:
- Delete 4 to earn 4 points. Consequently, 3 is also deleted. nums = [2].
- Delete 2 to earn 2 points. nums = [].
You earn a total of 6 points.
Example 2:
Input: nums = [2,2,3,3,3,4]
Output: 9
Explanation: You can perform the following operations:
- Delete a 3 to earn 3 points. All 2's and 4's are also deleted. nums = [3,3].
- Delete a 3 again to earn 3 points. nums = [3].
- Delete a 3 once more to earn 3 points. nums = [].
You earn a total of 9 points.
Constraints:
1 <= nums.length <= 2 * 104
1 <= nums[i] <= 104
| class Solution:
def deleteAndEarn(self, nums: List[int]) -> int:
count = Counter(nums)
m = max(nums)
memo = {}
def choose(num):
if num > m:
return 0
if num not in count:
count[num] = 0
if num in memo:
return memo[num]
memo[num] = max(choose(num + 1), num * count[num] + choose(num + 2))
return memo[num]
return choose(1)
# time and space complexity
# n = max(nums)
# time: O(n)
# space: O(n)
| class Solution {
public int deleteAndEarn(int[] nums) {
Arrays.sort(nums);
int onePreviousAgo = 0;
int previous = 0;
for(int i = 0; i < nums.length; i++) {
int sum = 0;
// On hop there's no constraint to add the previous value
if(i > 0 && nums[i-1] < nums[i] - 1) {
onePreviousAgo = previous;
}
// Accumulate equal values
while(i < nums.length - 1 && nums[i] == nums[i+1]) {
sum += nums[i];
i++;
}
int currentPrevious = previous;
previous = Math.max(
onePreviousAgo + nums[i] + sum,
previous
);
onePreviousAgo = currentPrevious;
// System.out.println(nums[i] + ":" + previous);
}
return previous;
}
} | class Solution {
public:
// Dynamic Programming : Bottom Up Approach Optmised
int deleteAndEarn(vector<int>& nums)
{
int size = nums.size();
// Initialise vectors with size 10001 and value 0
vector<int> memo(10001 , 0);
vector<int> res(10001 , 0);
// get the count of elements int res vector
for(auto num : nums)
res[num]++;
// for index : less than 3 calculate memo[i] as the index times number of occurences
// : greater than equal to 3 as calculate memo[i] as the index times number of occurences + max of the last second and third element
for(int i = 0 ; i < 10001 ; i++)
memo[i] += (i < 3) ? (i * res[i]) : (i * res[i]) + max(memo[i-2] , memo[i-3]);
// return max of last 2 elements
return max(memo[10000] , memo[9999]);
}
}; | var deleteAndEarn = function(nums) {
let maxNumber = 0;
const cache = {};
const points = {};
function maxPoints(num) {
if (num === 0) {
return 0;
}
if (num === 1) {
return points[1] || 0;
}
if (cache[num] !== undefined) {
return cache[num];
}
const gain = points[num] || 0;
return cache[num] = Math.max(maxPoints(num - 1), maxPoints(num - 2) + gain);
}
for (let num of nums) {
points[num] = (points[num] || 0) + num;
maxNumber = Math.max(maxNumber, num);
}
return maxPoints(maxNumber);
}; | Delete and Earn |
Given n orders, each order consist in pickup and delivery services.
Count all valid pickup/delivery possible sequences such that delivery(i) is always after of pickup(i).
Since the answer may be too large, return it modulo 10^9 + 7.
Example 1:
Input: n = 1
Output: 1
Explanation: Unique order (P1, D1), Delivery 1 always is after of Pickup 1.
Example 2:
Input: n = 2
Output: 6
Explanation: All possible orders:
(P1,P2,D1,D2), (P1,P2,D2,D1), (P1,D1,P2,D2), (P2,P1,D1,D2), (P2,P1,D2,D1) and (P2,D2,P1,D1).
This is an invalid order (P1,D2,P2,D1) because Pickup 2 is after of Delivery 2.
Example 3:
Input: n = 3
Output: 90
Constraints:
1 <= n <= 500
| class Solution:
def countOrders(self, n: int) -> int:
total = 1
mod = 10 ** 9 + 7
for k in reversed(range(2, n + 1)):
total = total * ((2 * k - 1) * (2 * k - 2) // 2 + 2 * k - 1)
total = total % mod
return total | class Solution {
public int countOrders(int n) {
long res = 1;
long mod = 1000000007;
for (int i = 1; i <= n; i++) {
res = res * (2 * i - 1) * i % mod;
}
return (int)res;
}
} | class Solution {
public:
int countOrders(int n) {
int mod = 1e9+7;
long long ans = 1;
for(int i=1;i<=n;i++){
int m = 2*i-1;
int p = (m*(m+1))/2;
ans=(ans*p)%mod;
}
return ans;
}
}; | var countOrders = function(n) {
let ans = 1; //for n=1, there will only be one valid pickup and delivery
for(let i = 2; i<=n; i++){
let validSlots = 2 * i -1; //calculating number of valid slots of new pickup in (n-1)th order
validSlots = (validSlots * (validSlots+1))/2;
ans = (ans * validSlots)%1000000007; //multiplying the ans of (n-1)th order to current order's valid slots
}
return ans;
}; | Count All Valid Pickup and Delivery Options |
Given a string s, return the maximum number of unique substrings that the given string can be split into.
You can split string s into any list of non-empty substrings, where the concatenation of the substrings forms the original string. However, you must split the substrings such that all of them are unique.
A substring is a contiguous sequence of characters within a string.
Example 1:
Input: s = "ababccc"
Output: 5
Explanation: One way to split maximally is ['a', 'b', 'ab', 'c', 'cc']. Splitting like ['a', 'b', 'a', 'b', 'c', 'cc'] is not valid as you have 'a' and 'b' multiple times.
Example 2:
Input: s = "aba"
Output: 2
Explanation: One way to split maximally is ['a', 'ba'].
Example 3:
Input: s = "aa"
Output: 1
Explanation: It is impossible to split the string any further.
Constraints:
1 <= s.length <= 16
s contains only lower case English letters.
| class Solution:
def maxUniqueSplit(self, s: str) -> int:
ans, n = 0, len(s)
def dfs(i, cnt, visited):
nonlocal ans, n
if i == n: ans = max(ans, cnt); return # stop condition
for j in range(i+1, n+1):
if s[i:j] in visited: continue # avoid re-visit/duplicates
visited.add(s[i:j]) # update visited set
dfs(j, cnt+1, visited) # backtracking
visited.remove(s[i:j]) # recover visited set for next possibility
dfs(0, 0, set()) # function call
return ans | class Solution {
int max = 0;
public int maxUniqueSplit(String s) {
int n = s.length();
backtrack(s, 0, new HashSet<String>());
return max;
}
public void backtrack(String s, int start, Set<String> h) {
if(start == s.length()) {
max = Math.max(max, h.size());
}
String res = "";
for(int i = start;i < s.length();i++) {
res += s.charAt(i);
if(h.contains(res)) continue;
h.add(res);
backtrack(s, i+1, h);
h.remove(res);
}
}
} | class Solution {
public:
unordered_set<string>st;
int ans=0;
void dfs(string &s, int idx)
{
if(st.size()>ans) ans=st.size();
if(idx>=s.length()) return;
string str="";
for(int i=idx ; i<s.length() ; i++)
{
str += s[i];
if(st.find(str)==st.end())
{
st.insert(str);
dfs(s,i+1);
st.erase(str);
}
}
}
int maxUniqueSplit(string s) {
dfs(s,0);
return ans;
}
}; | var maxUniqueSplit = function(s) {
let wordSet = new Set(), res = 1;
function checkUniqueSubstring(i) {
if (i === s.length) {
res = Math.max(wordSet.size, res);
return;
}
for (let j = i+1; j <= s.length; j++) {
let str = s.substring(i,j);
if (!wordSet.has(str)) {
wordSet.add(str);
checkUniqueSubstring(j);
wordSet.delete(str);
}
}
}
checkUniqueSubstring(0);
return res;
}; | Split a String Into the Max Number of Unique Substrings |
You are given the root node of a binary search tree (BST) and a value to insert into the tree. Return the root node of the BST after the insertion. It is guaranteed that the new value does not exist in the original BST.
Notice that there may exist multiple valid ways for the insertion, as long as the tree remains a BST after insertion. You can return any of them.
Example 1:
Input: root = [4,2,7,1,3], val = 5
Output: [4,2,7,1,3,5]
Explanation: Another accepted tree is:
Example 2:
Input: root = [40,20,60,10,30,50,70], val = 25
Output: [40,20,60,10,30,50,70,null,null,25]
Example 3:
Input: root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
Output: [4,2,7,1,3,5]
Constraints:
The number of nodes in the tree will be in the range [0, 104].
-108 <= Node.val <= 108
All the values Node.val are unique.
-108 <= val <= 108
It's guaranteed that val does not exist in the original BST.
| class Solution:
def insertIntoBST(self, root, val):
if not root:
return TreeNode(val)
if val<root.val:
root.left = self.insertIntoBST(root.left, val)
else:
root.right = self.insertIntoBST(root.right, val)
return root | class Solution {
public TreeNode insertIntoBST(TreeNode root, int val) {
if(root == null) return new TreeNode(val);
if(root.val > val) root.left = insertIntoBST(root.left, val);
else root.right = insertIntoBST(root.right, val);
return root;
}
} | class Solution {
public:
TreeNode* insertIntoBST(TreeNode* root, int val) {
if(root==NULL) return new TreeNode(val);
TreeNode* node = root;
while(true){
if(val>=node->val){
if(node->right) node = node->right;
else{
node->right = new TreeNode(val);
break;
}
}
else{
if(node->left) node = node->left;
else{
node->left = new TreeNode(val);
break;
}
}
}
return root;
}
}; | var insertIntoBST = function(root, val) {
if (root == null) {
return new TreeNode(val);
}
if(val < root.val) {
root.left = insertIntoBST(root.left, val);
} else {
root.right = insertIntoBST(root.right, val);
}
return root;
}; | Insert into a Binary Search Tree |
You are given an m x n integer matrix grid, and three integers row, col, and color. Each value in the grid represents the color of the grid square at that location.
Two squares belong to the same connected component if they have the same color and are next to each other in any of the 4 directions.
The border of a connected component is all the squares in the connected component that are either 4-directionally adjacent to a square not in the component, or on the boundary of the grid (the first or last row or column).
You should color the border of the connected component that contains the square grid[row][col] with color.
Return the final grid.
Example 1:
Input: grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
Output: [[3,3],[3,2]]
Example 2:
Input: grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3
Output: [[1,3,3],[2,3,3]]
Example 3:
Input: grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
Output: [[2,2,2],[2,1,2],[2,2,2]]
Constraints:
m == grid.length
n == grid[i].length
1 <= m, n <= 50
1 <= grid[i][j], color <= 1000
0 <= row < m
0 <= col < n
| class Solution:
def colorBorder(self, grid: List[List[int]], row: int, col: int, color: int) -> List[List[int]]:
rows, cols = len(grid), len(grid[0])
border_color = grid[row][col]
border = []
# Check if a node is a border node or not
def is_border(r, c):
if r == 0 or r == rows - 1 or c == 0 or c == cols - 1:
return True
for dr, dc in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
nr, nc = r + dr, c + dc
if grid[nr][nc] != border_color:
return True
return False
def dfs(r, c):
if r < 0 or c < 0 or r == rows or c == cols or (r, c) in visited or grid[r][c] != border_color:
return
visited.add((r, c))
if is_border(r, c):
border.append((r, c))
dfs(r + 1, c)
dfs(r - 1, c)
dfs(r, c + 1)
dfs(r, c - 1)
visited = set()
dfs(row, col)
for r, c in border:
grid[r][c] = color
return grid | class Solution {
public int[][] colorBorder(int[][] grid, int row, int col, int color) {
dfs(grid,row,col,grid[row][col]);
for(int i = 0;i<grid.length;i++)
{
for(int j = 0;j<grid[0].length;j++)
{
if(grid[i][j]<0)
{
grid[i][j] = color;
}
}
}
return grid;
}
int[][] dirs = {{0,1},{1,0},{0,-1},{-1,0}};
public void dfs(int[][] grid, int row, int col, int color) {
grid[row][col] = - color;
int count = 0;
for(int i = 0;i<4;i++)
{
int rowdash = row+dirs[i][0];
int coldash = col+dirs[i][1];
if(rowdash<0||coldash<0||rowdash>=grid.length||coldash>=grid[0].length||
Math.abs(grid[rowdash][coldash])!=color)
{
continue;
}
count++;
if(grid[rowdash][coldash]==color)
{
dfs(grid,rowdash,coldash,color);
}
}
if(count==4)
{
grid[row][col] = color;
}
}
} | // marking element -ve and then fix it while backtracking worked as visited matrix
// marking element 1e9 and not fixing it while backtracking works for coloring element
class Solution {
private:
int m,n;
public:
bool is_valid(int i,int j,vector<vector<int>> &grid,int org_color){
return i >= 0 and j >= 0 and i < m and j < n and grid[i][j] == org_color and grid[i][j] > 0;
}
bool is_colorable(int i,int j,vector<vector<int>> &grid,int org_color){
if(i == 0 or j == 0 or i == m-1 or j == n-1) return true; // boundary condn
// checking any of the neighbour is of opposite color or not
if(i-1 >= 0 and abs(grid[i-1][j]) != org_color and grid[i-1][j] != 1e9) return true;
if(i+1 < m and abs(grid[i+1][j]) != org_color and grid[i+1][j] != 1e9) return true;
if(j-1 >= 0 and abs(grid[i][j-1]) != org_color and grid[i][j-1] != 1e9) return true;
if(j+1 < n and abs(grid[i][j+1]) != org_color and grid[i][j+1] != 1e9) return true;
return false;
}
void dfs(int i,int j,vector<vector<int>> &grid,int org_color){
if(!is_valid(i,j,grid,org_color)) return;
if(is_colorable(i,j,grid,org_color)) grid[i][j] = 1e9;
else grid[i][j] = -grid[i][j];
dfs(i-1,j,grid,org_color); dfs(i+1,j,grid,org_color); // up and down
dfs(i,j-1,grid,org_color); dfs(i,j+1,grid,org_color); // left and right
if(grid[i][j] < 0) grid[i][j] = -grid[i][j];
}
vector<vector<int>> colorBorder(vector<vector<int>>& grid, int row, int col, int color){
m = grid.size(), n = grid[0].size();
dfs(row,col,grid,grid[row][col]);
for(auto &it : grid){
for(auto &i : it){
if(i == 1e9) i = color;
}
}
return grid;
}
}; | var colorBorder = function(grid, row, col, color) {
const m = grid.length;
const n = grid[0].length;
const dirs = [-1, 0, 1, 0, -1];
const res = [];
for (let i = 0; i < m; i++) {
res[i] = new Array(n).fill(-1);
}
const val = grid[row][col];
const stack = [];
const visited = new Set();
visited.add(`${row}#${col}`);
stack.push([row, col]);
while (stack.length > 0) {
const [currRow, currCol] = stack.pop();
let isConnected = true;
for (let i = 0; i < dirs.length - 1; i++) {
const neiRow = currRow + dirs[i];
const neiCol = currCol + dirs[i + 1];
if (withinBound(neiRow, neiCol)) {
if (!visited.has(`${neiRow}#${neiCol}`)) {
if (grid[neiRow][neiCol] === val) {
visited.add(`${neiRow}#${neiCol}`);
stack.push([neiRow, neiCol]);
}
else {
isConnected = false;
}
}
}
}
if (isBorder(currRow, currCol) || !isConnected) res[currRow][currCol] = color;
}
for (let i = 0; i < m; i++) {
for (let j = 0; j < n; j++) {
if (res[i][j] === -1) {
res[i][j] = grid[i][j];
}
}
}
return res;
function withinBound(row, col) {
return row >= 0 && col >= 0 && row < m && col < n;
}
function isBorder(row, col) {
return row === 0 || col === 0 || row === m - 1 || col === n - 1;
}
}; | Coloring A Border |
Given an array rectangles where rectangles[i] = [xi, yi, ai, bi] represents an axis-aligned rectangle. The bottom-left point of the rectangle is (xi, yi) and the top-right point of it is (ai, bi).
Return true if all the rectangles together form an exact cover of a rectangular region.
Example 1:
Input: rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]
Output: true
Explanation: All 5 rectangles together form an exact cover of a rectangular region.
Example 2:
Input: rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]
Output: false
Explanation: Because there is a gap between the two rectangular regions.
Example 3:
Input: rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]
Output: false
Explanation: Because two of the rectangles overlap with each other.
Constraints:
1 <= rectangles.length <= 2 * 104
rectangles[i].length == 4
-105 <= xi, yi, ai, bi <= 105
| class Solution:
def isRectangleCover(self, rectangles: List[List[int]]) -> bool:
X1, Y1 = float('inf'), float('inf')
X2, Y2 = -float('inf'), -float('inf')
points = set()
actual_area = 0
for x1, y1, x2, y2 in rectangles:
# calculate the coords of the potential perfect rectangle
X1, Y1 = min(X1, x1), min(Y1, y1)
X2, Y2 = max(X2, x2), max(Y2, y2)
# add up to the actual_area, so we can check against to see if thers is any part overwritten.
actual_area += (x2 - x1) * (y2 - y1)
# proving steps in https://labuladong.github.io/algo/4/32/131/
for p in [(x1, y1), (x1, y2), (x2, y1), (x2, y2)]:
if p in points:
points.remove(p)
else:
points.add(p)
# check the area
expected_area = (X2 - X1) * (Y2 - Y1)
if actual_area != expected_area:
return False
if len(points) != 4:
return False
if (X1, Y1) not in points:
return False
if (X1, Y2) not in points:
return False
if (X2, Y1) not in points:
return False
if (X2, Y2) not in points:
return False
return True | class Solution {
// Rectangle x0,y0,x1,y1
public boolean isRectangleCover(int[][] rectangles) {
// Ordered by y0 first and x0 second
Arrays.sort(rectangles,(r1,r2)->{
if(r1[1]==r2[1]) return r1[0]-r2[0];
return r1[1]-r2[1];
});
// Layering rectangles with pq, ordered by y1 first and x0 second
PriorityQueue<int[]> pq = new PriorityQueue<>((r1,r2)->{
if(r1[3]==r2[3]) return r1[0]-r2[0];
return r1[3]-r2[3];
});
// Create first layer
pq.offer(rectangles[0]);
int i=1;
while(i<rectangles.length&&rectangles[i][1]==rectangles[i-1][1]){
if(rectangles[i][0]!=rectangles[i-1][2]) return false;
pq.offer(rectangles[i++]);
}
while(i<rectangles.length){
int[] curr = rectangles[i++];
int x=curr[0];
//matching current rectangle with rectangles in the lower layer
while(!pq.isEmpty()&&x<curr[2]){
int[] prev=pq.poll();
if(prev[3]!=curr[1]||prev[0]!=x) return false;
if(prev[2]>curr[2]){
pq.offer(new int[]{curr[2], prev[1], prev[2], prev[3]});
x=curr[2];
}else {
x=prev[2];
}
}
if(x<curr[2]) return false;
pq.offer(curr);
}
int[] prev=pq.poll();
while(!pq.isEmpty()){
if(pq.poll()[3]!=prev[3]) return false;
}
return true;
}
} | class Solution {
public:
bool isRectangleCover(vector<vector<int>>& rectangles) {
SegmentTree<STMax> st(2e5 + 1);
sort(rectangles.begin(), rectangles.end(), [](auto& lhs, auto& rhs) -> bool {
if (lhs[1] != rhs[1]) return lhs[1] < rhs[1];
return lhs[0] < rhs[0];
});
int min_x = rectangles[0][0];
int min_y = rectangles[0][1];
int max_a = rectangles[0][2];
int max_b = rectangles[0][3];
long long sum = 1ll * (max_a - min_x) * (max_b - min_y);
st.update(min_x + 1e5 + 1, max_a + 1e5, max_b);
for (int i = 1; i < rectangles.size(); ++i) {
if (rectangles[i][0] < min_x) return false;
int max_height = st.query(rectangles[i][0] + 1e5 + 1, rectangles[i][2] + 1e5);
if (max_height > rectangles[i][1]) return false;
max_a = max(max_a, rectangles[i][2]);
max_b = max(max_b, rectangles[i][3]);
sum += 1ll * (rectangles[i][2] - rectangles[i][0]) * (rectangles[i][3] - rectangles[i][1]);
st.update(rectangles[i][0] + 1e5 + 1, rectangles[i][2] + 1e5, rectangles[i][3]);
}
return sum == 1ll * (max_a - min_x) * (max_b - min_y);
}
}; | var isRectangleCover = function(R) {
// left to right, bottom to top (so sort on bottom first, then left)
R.sort(([left1, bottom1], [left2, bottom2]) => bottom1 - bottom2 || left1 - left2);
// Find all corners
let leftMost = Infinity,
bottomMost = Infinity,
rightMost = -Infinity,
topMost = -Infinity;
for (let [left, bottom, right, top] of R) {
leftMost = Math.min(leftMost, left);
bottomMost = Math.min(bottomMost, bottom);
rightMost = Math.max(rightMost, right);
topMost = Math.max(topMost, top);
}
// All calculations are with-respect-to large rectangle
let CH = new Array(rightMost - leftMost).fill(0);
for (let [left, bottom, right, top] of R) {
const baseHeight = bottom - bottomMost; // how high base is
const ceilHeight = top - bottomMost; // how high ceil is
for (let tempLeft = left; tempLeft < right; tempLeft++) {
if (CH[tempLeft - leftMost] != baseHeight)
return false; // > is a duplicate cell < is a gap/ missing cell/ hole
CH[tempLeft - leftMost] = ceilHeight;
}
}
const rectHeight = topMost - bottomMost;
for (let ceilHeight of CH) {
if (ceilHeight !== rectHeight)
return false;
}
return true;
} | Perfect Rectangle |
Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value.
If target is not found in the array, return [-1, -1].
You must write an algorithm with O(log n) runtime complexity.
Example 1:
Input: nums = [5,7,7,8,8,10], target = 8
Output: [3,4]
Example 2:
Input: nums = [5,7,7,8,8,10], target = 6
Output: [-1,-1]
Example 3:
Input: nums = [], target = 0
Output: [-1,-1]
Constraints:
0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums is a non-decreasing array.
-109 <= target <= 109
| class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
# if target is not in nums list, we simply return [-1,-1]
if target not in nums:
return [-1,-1]
# create an empty list
result = []
# iterate nums for the first time, if we found nums[i] matches with target
# append the index i to result, break the for loop
# because we only care the first and last index of target in nums
for i in range(len(nums)):
if nums[i] == target:
result.append(i)
break
# loop through nums backward, if we found nums[j] matches target
# append j to result and break the for loop
for j in range(len(nums)-1, -1, -1):
if nums[j] == target:
result.append(j)
break
return result
| class Solution {
public int[] searchRange(int[] nums, int target) {
int[] ans={-1,-1};
int start=search(nums,target,true);
int end=search(nums,target,false);
ans[0]=start;
ans[1]=end;
return ans;
}
int search(int[] nums ,int target,boolean findStart){
int ans=-1;
int start=0;
int end=nums.length-1;
while(start<=end){
int mid=start+(end-start)/2;
if(target>nums[mid]){
start=mid+1;
}
else if(target<nums[mid]){
end=mid-1;
}
else{
ans=mid;
if(findStart){
end=mid-1;
}
else{
start=mid+1;
}
}
}
return ans;
}
} | class Solution {
public:
int startEle(vector<int>& nums, int target,int l,int r)
{
while(l<=r)
{
int m = (l+r)/2;
if(nums[m]<target) l=m+1;
else if(nums[m]>target) r = m-1;
else
{
if(m==0)
return m;
else if(nums[m-1]==target)
r = m-1;
else
return m;
}
}
return -1;
}
int lastEle(vector<int>& nums, int target,int l,int r)
{
while(l<=r)
{
int m = (l+r)/2;
if(nums[m]<target) l=m+1;
else if(nums[m]>target) r = m-1;
else
{
if(m==nums.size()-1)
return m;
else if(nums[m+1]==target)
l = m+1;
else
return m;
}
}
return -1;
}
vector<int> searchRange(vector<int>& nums, int target) {
vector<int> binSearch;
int a = startEle(nums,target,0,nums.size()-1);
if(a==-1)
{
binSearch.push_back(-1);
binSearch.push_back(-1);
return binSearch;
}
else
{
binSearch.push_back(a);
}
int b = lastEle(nums,target,0,nums.size()-1);
binSearch.push_back(b);
return binSearch;
}
}; | var searchRange = function(nums, target) {
if (nums.length === 1) return nums[0] === target ? [0, 0] : [-1, -1];
const findFirstInstance = (left, right) => {
if (left === right) return left;
var pivot;
while (left < right) {
if (left === pivot) left += 1;
pivot = Math.floor((left + right) / 2);
if (nums[pivot] === target) {
if (nums[pivot - 1] !== target) return pivot;
return findFirstInstance(left, pivot - 1);
}
if (nums[pivot] > target) right = pivot;
else left = pivot;
}
}
const findLastInstance = (left, right) => {
if (left === right) return left;
var pivot;
while (left < right) {
if (left === pivot) left += 1;
pivot = Math.floor((left + right) / 2);
if (nums[pivot] === target) {
if (nums[pivot + 1] !== target) return pivot;
return findLastInstance(pivot + 1, right);
}
if (nums[pivot] > target) right = pivot;
else left = pivot;
}
}
var left = 0,
right = nums.length - 1,
pivot;
while (left < right) {
if (left === pivot) left += 1;
pivot = Math.floor((left + right) / 2);
if (nums[pivot] === target) {
var first = nums[pivot - 1] !== target ? pivot : findFirstInstance(left, pivot - 1);
var last = nums[pivot + 1] !== target ? pivot : findLastInstance(pivot + 1, right);
return [first, last];
}
if (nums[pivot] > target) right = pivot;
else left = pivot;
}
return [-1, -1];
}; | Find First and Last Position of Element in Sorted Array |
Given a list of strings words and a string pattern, return a list of words[i] that match pattern. You may return the answer in any order.
A word matches the pattern if there exists a permutation of letters p so that after replacing every letter x in the pattern with p(x), we get the desired word.
Recall that a permutation of letters is a bijection from letters to letters: every letter maps to another letter, and no two letters map to the same letter.
Example 1:
Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
Output: ["mee","aqq"]
Explanation: "mee" matches the pattern because there is a permutation {a -> m, b -> e, ...}.
"ccc" does not match the pattern because {a -> c, b -> c, ...} is not a permutation, since a and b map to the same letter.
Example 2:
Input: words = ["a","b","c"], pattern = "a"
Output: ["a","b","c"]
Constraints:
1 <= pattern.length <= 20
1 <= words.length <= 50
words[i].length == pattern.length
pattern and words[i] are lowercase English letters.
| class Solution:
def findAndReplacePattern(self, words: List[str], pattern: str) -> List[str]:
d={}
for i,v in enumerate(pattern):
if v in d:
d[v].append(i)
else:
d|={v:[i]}
#DICTIONARY CONTAINING LETTERS AND THEIR INDICES
ans=[]
for i in words:
e={}
for j,v in enumerate(i):
if v in e:
e[v].append(j)
else:
e|={v:[j]}
#DICTIONARY CONTAINING LETTERS OF INDICES OF CURRENT WORD
for u,v in zip(d.values(),e.values()):
#COMPARING EACH VALUE
if u!=v:
break
#IF SUCCESSFUL APPEND TO ANS
else:ans.append(i)
return ans | class Solution {
public List<String> findAndReplacePattern(String[] words, String pattern) {
List<String> result=new ArrayList<>();
for(String word:words) {
Map<Character,Character> map=new HashMap<>();
Set<Character> set=new HashSet<>();
int i=0;
for(;i<word.length();i++) {
char ch=pattern.charAt(i);
if(map.get(ch)==null) {
if(set.contains(word.charAt(i))) break;
map.put(ch, word.charAt(i));
set.add(word.charAt(i));
}
else {
char mc=map.get(ch);
if(mc!=word.charAt(i)) break;
}
}
if(i==pattern.length()) result.add(word);
}
return result;
}
} | //😉If you Like the repository don't foget to star & fork the repository😉
class Solution {
public:
vector<int> found_Pattern(string pattern)
{
// if string is empty return empty vector.
if(pattern.size() == 0)
return {};
vector<int> v;
// ind variable for keeping track of unique characters
int ind = 0;
unordered_map<char,int> mp;
for(int i = 0; i<pattern.size(); ++i)
{
// if character not present in map, insert the char with an index,
// increment index because for next unique character the index should be differnt.
if(mp.find(pattern[i]) == mp.end())
{
mp.insert({pattern[i],ind++});
// also push the index to v(numeric pattern vector)
// mp[pattern[i]] gives the key to that character, here key is ind(which we are giving to every unique character)
v.push_back(mp[pattern[i]]);
}
else
{
// if char is already in map than push index mapped to that character into the vector
v.push_back(mp[pattern[i]]);
}
}
// return numeric pattern
return v;
}
vector<string> findAndReplacePattern(vector<string>& words, string pattern) {
// store numeric patten of Pattern string in v
vector<int> v = found_Pattern(pattern);
int n = words.size();
vector<string> ans;
// iterating and comparing pattern of each word with v(numeric pattern of Pattern)
for(int i = 0; i<n; ++i)
{
vector<int> pattern_word = found_Pattern(words[i]);
// if matched add words[i] to answer vector
if(v == pattern_word)
ans.push_back(words[i]);
}
return ans;
}
}; | var findAndReplacePattern = function(words, pattern) {
var patt = patternarr(pattern) // 010
return words.filter(e=>patternarr(e) == patt)
};
const patternarr = function (str) {
var result = '';
for(let i=0;i<str.length;i++) {
//finding the first index
result += str.indexOf(str[i])
}
return result
} | Find and Replace Pattern |
Given a string s, check if it can be constructed by taking a substring of it and appending multiple copies of the substring together.
Example 1:
Input: s = "abab"
Output: true
Explanation: It is the substring "ab" twice.
Example 2:
Input: s = "aba"
Output: false
Example 3:
Input: s = "abcabcabcabc"
Output: true
Explanation: It is the substring "abc" four times or the substring "abcabc" twice.
Constraints:
1 <= s.length <= 104
s consists of lowercase English letters.
| class Solution:
def repeatedSubstringPattern(self, s: str) -> bool:
for i in range(1, len(s)//2+1):
if s[:i] * (len(s)//i) == s:
return True
return False | class Solution {
public boolean repeatedSubstringPattern(String s) {
String temp="";
for(int i=0 ;i<s.length()/2 ;i++){
temp+=s.charAt(i);
if(s.length()%temp.length()==0) {
int times_repeat= s.length()/temp.length();
StringBuilder str = new StringBuilder();
for(int j=0 ;j<times_repeat ;j++){
str.append(temp);
}
if(str.toString().equals(s)) return true;
}
}
return false;
}
} | class Solution {
public:
vector<int> get_kmp_table(const string &s) {
vector<int> table(s.size());
int i=0; int j=-1;
table[0] = -1;
while (i < s.size()) {
if (j == -1 || s[i] == s[j]) {
i++;
j++;
table[i] = j;
}
else {
j = table[j];
}
}
return table;
}
bool validate_table(const vector<int>& table) {
int idx = table.size() - 1;
while (idx >= 0 && table[idx] > 0) {
idx--;
}
if (idx <= 0) return false;
int substr_len = idx;
if (table.size() % substr_len != 0) return false;
idx = idx + 1; // the first nonzero element in the string
while (idx < table.size()-1) {
if (table[idx] != table[idx+1]-1) return false;
idx++;
}
return true;
}
bool repeatedSubstringPattern(string s) {
if (s.size() <= 1) return true;
auto table1 = get_kmp_table(s);
string ss = s;
reverse(ss.begin(), ss.end());
auto table2 = get_kmp_table(ss);
return (validate_table(table1) && validate_table(table2));
}
}; | var repeatedSubstringPattern = function(s) {
let repeatStr = s.repeat(2) //first duplicate the string with repeat function
let sliceStr = repeatStr.slice(1,-1) // slice string first and last string word
return sliceStr.includes(s) // now check if the main string(s) is included by sliced string
} | Repeated Substring Pattern |
In MATLAB, there is a handy function called reshape which can reshape an m x n matrix into a new one with a different size r x c keeping its original data.
You are given an m x n matrix mat and two integers r and c representing the number of rows and the number of columns of the wanted reshaped matrix.
The reshaped matrix should be filled with all the elements of the original matrix in the same row-traversing order as they were.
If the reshape operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.
Example 1:
Input: mat = [[1,2],[3,4]], r = 1, c = 4
Output: [[1,2,3,4]]
Example 2:
Input: mat = [[1,2],[3,4]], r = 2, c = 4
Output: [[1,2],[3,4]]
Constraints:
m == mat.length
n == mat[i].length
1 <= m, n <= 100
-1000 <= mat[i][j] <= 1000
1 <= r, c <= 300
| import numpy
class Solution:
def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
return numpy.reshape(mat,(r,c)) if r*c==len(mat)*len(mat[0]) else mat | class Solution {
public int[][] matrixReshape(int[][] mat, int r, int c) {
if (r * c != mat.length * mat[0].length) {
return mat;
}
int[][] ans = new int[r][c];
int i = 0;
int j = 0;
for(int k = 0; k < mat.length; k++) {
for(int l = 0; l < mat[0].length; l++) {
if (j == c) {
i++;
j = 0;
}
ans[i][j++] = mat[k][l];
}
}
return ans;
}
} | class Solution {
public:
vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
if(mat.size()* mat[0].size()!= r * c) {
return mat;
}
vector<vector<int>>v(r,vector<int>(c));
int k = 0;
int l = 0;
for(int i = 0; i < mat.size(); i++) {
for(int j = 0; j < mat[0].size(); j++) {
if(l == v[0].size()) {
l = 0;
k++;
}
v[k][l++] = mat[i][j];
}
}
return v;
}
}; | var matrixReshape = function(mat, r, c) {
const origR = mat.length;
const origC = mat[0].length;
if (r*c !== origR*origC) {
return mat;
}
const flat = mat.flatMap(n => n);
const output = [];
for (let i=0; i<flat.length; i++) {
if (i%c === 0) {
output.push([]);
}
output[output.length-1].push(flat[i]);
};
return output;
}; | Reshape the Matrix |
You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
Example 1:
Input: l1 = [7,2,4,3], l2 = [5,6,4]
Output: [7,8,0,7]
Example 2:
Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [8,0,7]
Example 3:
Input: l1 = [0], l2 = [0]
Output: [0]
Constraints:
The number of nodes in each linked list is in the range [1, 100].
0 <= Node.val <= 9
It is guaranteed that the list represents a number that does not have leading zeros.
Follow up: Could you solve it without reversing the input lists?
| class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
def number(head):
ans = ''
while head:
ans+=str(head.val)
head = head.next
return int(ans)
temp = dummy = ListNode(0)
for i in str(number(l1) + number(l2)):
temp.next = ListNode(i)
temp = temp.next
return dummy.next
| class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode res=new ListNode(0);
ListNode curr=res;
l1=reverseLinkedList(l1);
l2=reverseLinkedList(l2);
int carry=0;
while(l1!=null||l2!=null||carry==1)
{
int sum=0;
if(l1!=null)
{
sum+=l1.val;
l1=l1.next;
}
if(l2!=null)
{
sum+=l2.val;
l2=l2.next;
}
sum+=carry;
carry = sum/10;
curr.next= new ListNode(sum % 10);
curr = curr.next;
}
return reverseLinkedList(res.next);
}
public ListNode reverseLinkedList(ListNode head)
{
ListNode curr=head;
ListNode prev=null;
ListNode next;
while(curr!=null)
{
next=curr.next;
curr.next=prev;
prev=curr;
curr=next;
}
return prev;
}
} | /**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* reverse(ListNode* l1){
if(l1==NULL||l1->next==NULL){
return l1;
}
ListNode* ans=reverse(l1->next);
l1->next->next=l1;
l1->next=NULL;
return ans;
}
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* l11= reverse(l1);
ListNode* l22= reverse(l2);
ListNode* dummy=new ListNode(0);
ListNode* curr=dummy;
int carry=0;
int sum=0;
while(l11||l22||carry!=0){
int x=l11?l11->val:0;
int y=l22?l22->val:0;
sum=x+y+carry;
carry=sum/10;
curr->next=new ListNode(sum%10);
curr=curr->next;
l11=l11?l11->next:nullptr;
l22=l22?l22->next:nullptr;
}
dummy=dummy->next;
dummy=reverse(dummy);
return dummy;
}
}; | var addTwoNumbers = function(l1, l2) {
const reverse = head =>{
let prev = null
let dummy = head
while(dummy){
let temp = dummy.next
dummy.next = prev
prev = dummy
dummy = temp
}
return prev
}
let head1 = reverse(l1)
let head2 = reverse(l2)
// add
let sum = new ListNode()
let p = sum
let carry = 0
while((head1 && head2) || carry){
let v1 = head1?head1.val:0
let v2 = head2?head2.val:0
let v = v1+v2+carry
if(v>=10) carry = 1
else carry = 0
let node = new ListNode(v%10)
sum.next = node
sum = sum.next
head1 = head1&&head1.next
head2 = head2&&head2.next
}
sum.next = head1||head2
return reverse(p.next)
}; | Add Two Numbers II |
An image is represented by an m x n integer grid image where image[i][j] represents the pixel value of the image.
You are also given three integers sr, sc, and color. You should perform a flood fill on the image starting from the pixel image[sr][sc].
To perform a flood fill, consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, plus any pixels connected 4-directionally to those pixels (also with the same color), and so on. Replace the color of all of the aforementioned pixels with color.
Return the modified image after performing the flood fill.
Example 1:
Input: image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, color = 2
Output: [[2,2,2],[2,2,0],[2,0,1]]
Explanation: From the center of the image with position (sr, sc) = (1, 1) (i.e., the red pixel), all pixels connected by a path of the same color as the starting pixel (i.e., the blue pixels) are colored with the new color.
Note the bottom corner is not colored 2, because it is not 4-directionally connected to the starting pixel.
Example 2:
Input: image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, color = 0
Output: [[0,0,0],[0,0,0]]
Explanation: The starting pixel is already colored 0, so no changes are made to the image.
Constraints:
m == image.length
n == image[i].length
1 <= m, n <= 50
0 <= image[i][j], color < 216
0 <= sr < m
0 <= sc < n
| class Solution:
def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:
queue = deque()
rows = len(image)
cols = len(image[0])
targetColor = image[sr][sc]
if color == targetColor:
# in this case, we don't need to do anything
return image
rDirs = [1, 0, -1, 0]
cDirs = [0, 1, 0, -1]
queue.append((sr, sc))
while len(queue) > 0:
r, c = queue.pop()
image[r][c] = color
for rd, cd in zip(rDirs, cDirs):
newRow = r + rd
newCol = c + cd
isValidCoordinate = newRow >= 0 and newRow < rows and newCol >= 0 and newCol < cols
if isValidCoordinate and image[newRow][newCol] == targetColor:
queue.append((newRow, newCol))
return image
| class Solution {
void colorFill(int[][]image,int sr,int sc,int sourceColor,int targetColor){
int m = image.length, n = image[0].length;
if(sr>=0 && sr<m && sc>=0 && sc<n)
{
if( (image[sr][sc] != sourceColor) ||(image[sr][sc] == targetColor)) return;
image[sr][sc] = targetColor;
colorFill(image,sr,sc-1,sourceColor,targetColor); // left
colorFill(image,sr,sc+1,sourceColor,targetColor); // right
colorFill(image,sr-1,sc,sourceColor,targetColor); // up
colorFill(image,sr+1,sc,sourceColor,targetColor); // down
}
else
return;
}
public int[][] floodFill(int[][] image, int sr, int sc, int color) {
int rows = image.length, cols = image[0].length;
colorFill(image,sr,sc,image[sr][sc],color);
return image;
}
} | class Solution {
public:
vector<vector<int>> paths = {{0,1},{0,-1},{-1,0},{1,0}};
bool check(int i,int j , int n, int m){
if(i>=n or i<0 or j>=m or j<0) return false;
return true;
}
void solve(vector<vector<int>> &image, int sr, int sc, int color, int orig){
int n = image.size(), m = image[0].size();
image[sr][sc] = color;
for(int i=0;i<4;i++){
int new_sr = paths[i][0] + sr;
int new_sc = paths[i][1] + sc;
if(check(new_sr,new_sc,n,m)==true and image[new_sr][new_sc]==orig){
solve(image, new_sr, new_sc, color,orig);
}
}
}
vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
if(color==image[sr][sc]) return image;
int orig = image[sr][sc];
solve(image, sr,sc,color, orig);
return image;
}
}; | /**
* @param {number[][]} image
* @param {number} sr
* @param {number} sc
* @param {number} color
* @return {number[][]}
*/
var floodFill = function(image, sr, sc, color) {
const pixelsToCheck = [[sr, sc]]
const startingPixelColor = image[sr][sc]
const directions = [[1, 0], [0, 1], [-1, 0], [0, -1]]
const seenPixels = new Set()
if (
startingPixelColor === undefined ||
startingPixelColor === color
) return image
for (const pixel of pixelsToCheck) {
const currentPixelColor = image[pixel[0]]?.[pixel[1]]
if (
currentPixelColor === undefined ||
startingPixelColor !== currentPixelColor
) continue
image[pixel[0]][pixel[1]] = color
for (const direction of directions) {
const newPixel = [pixel[0] + direction[0], pixel[1] + direction[1]]
const pixelString = newPixel.join()
if (seenPixels.has(pixelString)) continue
pixelsToCheck.push(newPixel)
seenPixels.add(pixelString)
}
}
return image
}; | Flood Fill |
Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:
Each row must contain the digits 1-9 without repetition.
Each column must contain the digits 1-9 without repetition.
Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.
Note:
A Sudoku board (partially filled) could be valid but is not necessarily solvable.
Only the filled cells need to be validated according to the mentioned rules.
Example 1:
Input: board =
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
Output: true
Example 2:
Input: board =
[["8","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
Output: false
Explanation: Same as Example 1, except with the 5 in the top left corner being modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.
Constraints:
board.length == 9
board[i].length == 9
board[i][j] is a digit 1-9 or '.'.
| class Solution:
def isValidSudoku(self, board: List[List[str]]) -> bool:
hrow = {}
hcol = {}
hbox = defaultdict(list)
#CHECK FOR DUPLICATES ROWWISE
for i in range(9):
for j in range(9):
#JUST THAT THE DUPLICATE SHOULDNT BE ","
if board[i][j] != '.':
if board[i][j] not in hrow:
hrow[board[i][j]] = 1
else:
return False
#CLEAR HASHMAP FOR THIS ROW
hrow.clear()
print("TRUE1")
#CHECK FOR DUPLICATES COLUMNWISE
for i in range(9):
for j in range(9):
#JUST THAT THE DUPLICATE SHOULDNT BE ","
if board[j][i] != '.':
if board[j][i] not in hcol:
hcol[board[j][i]] = 1
else:
return False
#CLEAR HASHMAP FOR THIS COL
hcol.clear()
print('TRUE2')
#CHECK DUPLICATE IN BOX, THIS IS WHERE KEY DESIGN SKILLS COME INTO PLAY, FOR SUDOKU YOU COMBINE ROW INDICES AND COL INDICES
for i in range(9):
for j in range(9):
i_3 = i //3
j_3 = j//3
# print(hbox)
if board[i][j] != '.':
#CHECK ELEMENT OF ORIGINAL INDICE present in key i_3 , j_3
if board[i][j] not in hbox[i_3 , j_3]:
# #CHECKED IN NEW KEY
hbox[i_3 ,j_3 ]= hbox[i_3 ,j_3 ] + [board[i][j]]
else:
return False
return True | for(int i=0; i<9; i++){
for(int j=0; j<9; j++){
if(board[i][j] != '.'){
char currentVal = board[i][j];
if(!(seen.add(currentVal + "found in row "+ i)) ||
!(seen.add(currentVal + "found in column "+ j) ) ||
!(seen.add(currentVal + "found in sub box "+ i/3 + "-"+ j/3)))
return false;
}
}
}
return true;
} | class Solution {
public:
bool isValidSudoku(vector<vector<char>>& board) {
int n = board.size();
for(int i=0;i<n;i++){
unordered_map<char,int>m;
for(int j=0;j<board[i].size();j++){
if(board[i][j]=='.'){
continue;
}
if(m.find(board[i][j])!=m.end()){
return false;
}
else{
m[board[i][j]]++;
}
}
}
for(int i=0;i<n;i++){
unordered_map<char,int>m;
for(int j=0;j<n;j++){
if(board[j][i]=='.'){
continue;
}
if(m.find(board[j][i])!=m.end()){
return false;
}
else{
m[board[j][i]]++;
}
}
}
for(int i=0;i<n;i+=3){
for(int j=0;j<n;j+=3){
unordered_map<char,int>m;
for(int k=i;k<=i+2;k++){
for(int p=j;p<=j+2;p++){
if(board[k][p]=='.'){
continue;
}
if(m.find(board[k][p])!=m.end()){
return false;
}
else{
m[board[k][p]]++;
}
}
}
}
}
return true;
}
}; | /**
* @param {character[][]} board
* @return {boolean}
*/
var isValidSudoku = function(board) {
let rowMap = new Map();
let colMap = new Map();
let square = new Map();
for(let i=0; i<board.length; i++) {
for(let j=0; j<board[0].length; j++) {
if(board[i][j] === '.') continue;
if(!rowMap.has(i)) rowMap.set(i, new Set());
if(!colMap.has(j)) colMap.set(j, new Set());
let squareKey = Math.floor(i/3) + '#' + Math.floor(j/3);
if(!square.has(squareKey)) square.set(squareKey, new Set());
let rowSet = rowMap.get(i);
let colSet = colMap.get(j);
let squareSet = square.get(squareKey);
if(rowSet.has(board[i][j]) || colSet.has(board[i][j]) || squareSet.has(board[i][j])) return false;
rowSet.add(board[i][j]);
colSet.add(board[i][j]);
squareSet.add(board[i][j]);
rowMap.set(i, rowSet);
colMap.set(j, colSet);
square.set(squareKey, squareSet);
}
}
return true;
}; | Valid Sudoku |
Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.
You must write an algorithm with O(log n) runtime complexity.
Example 1:
Input: nums = [-1,0,3,5,9,12], target = 9
Output: 4
Explanation: 9 exists in nums and its index is 4
Example 2:
Input: nums = [-1,0,3,5,9,12], target = 2
Output: -1
Explanation: 2 does not exist in nums so return -1
Constraints:
1 <= nums.length <= 104
-104 < nums[i], target < 104
All the integers in nums are unique.
nums is sorted in ascending order.
| class Solution:
def search(self, nums: List[int], target: int) -> int:
left = 0
right = len(nums)-1
while left<=right:
mid = (left+right)//2
if nums[mid]==target:
return mid
elif nums[mid]>target:
right = mid-1
else:
left = mid+1
return -1 | class Solution {
public int search(int[] nums, int target) {
int l = 0;
int r = nums.length - 1;
return binarySearch(nums, l, r, target);
}
private int binarySearch(int[] nums, int l, int r, int target) {
if (l <= r) {
int mid = (r + l) / 2;
if (nums[mid] == target) {
return mid;
}
if (nums[mid] < target) {
return binarySearch(nums, mid + 1, r, target);
} else {
return binarySearch(nums, l, mid - 1, target);
}
}
return -1;
}
} | class Solution {
public:
int search(vector<int>& nums, int target) {
int n = nums.size();
int jump = 5;
int p = 0;
while (jump*5 < n) jump *= 5;
while (jump > 0) {
while (p+jump < n && nums[p+jump] <= target) p += jump;
jump /= 5;
}
return (p == n || nums[p]!= target) ? -1 : p;
}
}; | /**
* @param {number[]} nums
* @param {number} target
* @return {number}
*/
var search = function(nums, target) {
let low=0;
let high=nums.length-1;
if(target<nums[0] || target>nums[high]){
return -1;
}
while(low<=high) {
mid=Math.floor((low+high)/2);
if (nums[mid]==target){
return mid;
}
else{
if(target>nums[mid]){
low=mid+1;
}
else{
high=mid-1;
}
}
}
return -1;
}; | Binary Search |
Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".
One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.
Implementation the MyCircularQueue class:
MyCircularQueue(k) Initializes the object with the size of the queue to be k.
int Front() Gets the front item from the queue. If the queue is empty, return -1.
int Rear() Gets the last item from the queue. If the queue is empty, return -1.
boolean enQueue(int value) Inserts an element into the circular queue. Return true if the operation is successful.
boolean deQueue() Deletes an element from the circular queue. Return true if the operation is successful.
boolean isEmpty() Checks whether the circular queue is empty or not.
boolean isFull() Checks whether the circular queue is full or not.
You must solve the problem without using the built-in queue data structure in your programming language.
Example 1:
Input
["MyCircularQueue", "enQueue", "enQueue", "enQueue", "enQueue", "Rear", "isFull", "deQueue", "enQueue", "Rear"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
Output
[null, true, true, true, false, 3, true, true, true, 4]
Explanation
MyCircularQueue myCircularQueue = new MyCircularQueue(3);
myCircularQueue.enQueue(1); // return True
myCircularQueue.enQueue(2); // return True
myCircularQueue.enQueue(3); // return True
myCircularQueue.enQueue(4); // return False
myCircularQueue.Rear(); // return 3
myCircularQueue.isFull(); // return True
myCircularQueue.deQueue(); // return True
myCircularQueue.enQueue(4); // return True
myCircularQueue.Rear(); // return 4
Constraints:
1 <= k <= 1000
0 <= value <= 1000
At most 3000 calls will be made to enQueue, deQueue, Front, Rear, isEmpty, and isFull.
| class MyCircularQueue {
int head = -1;
int tail = -1;
int[] q;
int k;
public MyCircularQueue(int k) {
q = new int[k];
this.k = k;
}
public boolean enQueue(int value) {
if(head == -1 && tail == -1) {
// enqueue when the queue is empty
head = tail = 0;
q[tail] = value; // enQueue done
return true;
}
if((tail == k-1 && head == 0) || tail+1 == head) {
// queue is full
return false;
}
tail++;
if(tail == k) // condition for circularity
tail = 0;
q[tail] = value; // enQueue done
return true;
}
public boolean deQueue() {
if(head == -1) {
// check if q is already empty
return false;
}
if(head == tail) {
// only 1 element is there and head,tail both points same index
head = tail = -1; // deQueue done
return true;
}
head++; // deQueue done
if(head == k) // condition for circularity
head = 0;
return true;
}
public int Front() {
if(head == -1)
return -1;
return q[head];
}
public int Rear() {
if(tail == -1)
return -1;
return q[tail];
}
public boolean isEmpty() {
if(head == -1 && tail == -1)
return true;
return false;
}
public boolean isFull() {
if(tail == k-1 || tail+1 == head)
return true;
return false;
}
}
/**
* Your MyCircularQueue object will be instantiated and called as such:
* MyCircularQueue obj = new MyCircularQueue(k);
* boolean param_1 = obj.enQueue(value);
* boolean param_2 = obj.deQueue();
* int param_3 = obj.Front();
* int param_4 = obj.Rear();
* boolean param_5 = obj.isEmpty();
* boolean param_6 = obj.isFull();
*/ | class MyCircularQueue {
private int front;
private int rear;
private int[] arr;
private int cap;
private int next(int i){ // to get next idx after i in circular queue
return (i+1)%cap;
}
private int prev(int i){ // to get prev idx before i in circular queue
return (i+cap-1)%cap;
}
// rest is as simple as implmenting a normal queue using array.
public MyCircularQueue(int k) {
arr = new int[k];
cap=k;
front=-1;
rear=-1;
}
public boolean enQueue(int value) {
if(isFull())return false;
if(front==-1){
front=0;
rear=0;
arr[rear]=value;
return true;
}
rear = next(rear);
arr[rear]=value;
return true;
}
public boolean deQueue() {
if(isEmpty())return false;
if(front==rear){
front=-1;
rear=-1;
return true;
}
front=next(front);
return true;
}
public int Front() {
if(front==-1)return -1;
return arr[front];
}
public int Rear() {
if(rear==-1)return -1;
return arr[rear];
}
public boolean isEmpty() {
return front==-1;
}
public boolean isFull() {
return front!=-1 && next(rear)==front;
}
} | class MyCircularQueue {
int head = -1;
int tail = -1;
int[] q;
int k;
public MyCircularQueue(int k) {
q = new int[k];
this.k = k;
}
public boolean enQueue(int value) {
if(head == -1 && tail == -1) {
// enqueue when the queue is empty
head = tail = 0;
q[tail] = value; // enQueue done
return true;
}
if((tail == k-1 && head == 0) || tail+1 == head) {
// queue is full
return false;
}
tail++;
if(tail == k) // condition for circularity
tail = 0;
q[tail] = value; // enQueue done
return true;
}
public boolean deQueue() {
if(head == -1) {
// check if q is already empty
return false;
}
if(head == tail) {
// only 1 element is there and head,tail both points same index
head = tail = -1; // deQueue done
return true;
}
head++; // deQueue done
if(head == k) // condition for circularity
head = 0;
return true;
}
public int Front() {
if(head == -1)
return -1;
return q[head];
}
public int Rear() {
if(tail == -1)
return -1;
return q[tail];
}
public boolean isEmpty() {
if(head == -1 && tail == -1)
return true;
return false;
}
public boolean isFull() {
if(tail == k-1 || tail+1 == head)
return true;
return false;
}
}
/**
* Your MyCircularQueue object will be instantiated and called as such:
* MyCircularQueue obj = new MyCircularQueue(k);
* boolean param_1 = obj.enQueue(value);
* boolean param_2 = obj.deQueue();
* int param_3 = obj.Front();
* int param_4 = obj.Rear();
* boolean param_5 = obj.isEmpty();
* boolean param_6 = obj.isFull();
*/ | class MyCircularQueue {
int head = -1;
int tail = -1;
int[] q;
int k;
public MyCircularQueue(int k) {
q = new int[k];
this.k = k;
}
public boolean enQueue(int value) {
if(head == -1 && tail == -1) {
// enqueue when the queue is empty
head = tail = 0;
q[tail] = value; // enQueue done
return true;
}
if((tail == k-1 && head == 0) || tail+1 == head) {
// queue is full
return false;
}
tail++;
if(tail == k) // condition for circularity
tail = 0;
q[tail] = value; // enQueue done
return true;
}
public boolean deQueue() {
if(head == -1) {
// check if q is already empty
return false;
}
if(head == tail) {
// only 1 element is there and head,tail both points same index
head = tail = -1; // deQueue done
return true;
}
head++; // deQueue done
if(head == k) // condition for circularity
head = 0;
return true;
}
public int Front() {
if(head == -1)
return -1;
return q[head];
}
public int Rear() {
if(tail == -1)
return -1;
return q[tail];
}
public boolean isEmpty() {
if(head == -1 && tail == -1)
return true;
return false;
}
public boolean isFull() {
if(tail == k-1 || tail+1 == head)
return true;
return false;
}
}
/**
* Your MyCircularQueue object will be instantiated and called as such:
* MyCircularQueue obj = new MyCircularQueue(k);
* boolean param_1 = obj.enQueue(value);
* boolean param_2 = obj.deQueue();
* int param_3 = obj.Front();
* int param_4 = obj.Rear();
* boolean param_5 = obj.isEmpty();
* boolean param_6 = obj.isFull();
*/ | Design Circular Queue |
Design a data structure that efficiently finds the majority element of a given subarray.
The majority element of a subarray is an element that occurs threshold times or more in the subarray.
Implementing the MajorityChecker class:
MajorityChecker(int[] arr) Initializes the instance of the class with the given array arr.
int query(int left, int right, int threshold) returns the element in the subarray arr[left...right] that occurs at least threshold times, or -1 if no such element exists.
Example 1:
Input
["MajorityChecker", "query", "query", "query"]
[[[1, 1, 2, 2, 1, 1]], [0, 5, 4], [0, 3, 3], [2, 3, 2]]
Output
[null, 1, -1, 2]
Explanation
MajorityChecker majorityChecker = new MajorityChecker([1, 1, 2, 2, 1, 1]);
majorityChecker.query(0, 5, 4); // return 1
majorityChecker.query(0, 3, 3); // return -1
majorityChecker.query(2, 3, 2); // return 2
Constraints:
1 <= arr.length <= 2 * 104
1 <= arr[i] <= 2 * 104
0 <= left <= right < arr.length
threshold <= right - left + 1
2 * threshold > right - left + 1
At most 104 calls will be made to query.
| MAX_N = 2*10**4
MAX_BIT = MAX_N.bit_length()
class MajorityChecker:
def __init__(self, nums: List[int]):
n = len(nums)
self.bit_sum = [[0] * MAX_BIT for _ in range(n+1)]
for i in range(1, n+1):
for b in range(MAX_BIT):
self.bit_sum[i][b] = self.bit_sum[i-1][b] + ((nums[i-1] >> b) & 1)
self.num_idx = defaultdict(list)
for i in range(n):
self.num_idx[nums[i]].append(i)
def query(self, left: int, right: int, threshold: int) -> int:
num = 0
for b in range(MAX_BIT):
if self.bit_sum[right+1][b] - self.bit_sum[left][b] >= threshold:
num |= 1 << b
l = bisect.bisect_left(self.num_idx[num], left)
r = bisect.bisect_right(self.num_idx[num], right)
if r-l >= threshold:
return num
return -1 | class MajorityChecker {
private final int digits=15;
private int[][]presum;
private ArrayList<Integer>[]pos;
public MajorityChecker(int[] arr) {
int len=arr.length;
presum=new int[len+1][digits];
pos=new ArrayList[20001];
for(int i=0;i<len;i++){
int n=arr[i];
if(pos[n]==null)pos[n]=new ArrayList();
pos[n].add(i);
for(int j=0;j<digits;j++){
presum[i+1][j]=presum[i][j]+(n&1);
n>>=1;
}
}
}
public int query(int left, int right, int threshold) {
int ans=0;
for(int i=digits-1;i>=0;i--){
int cnt=presum[right+1][i]-presum[left][i];
int b=1;
if(cnt>=threshold)b=1;
else if(right-left+1-cnt>=threshold)b=0;
else return -1;
ans=(ans<<1)+b;
}
// check
ArrayList<Integer>list=pos[ans];
if(list==null)return -1;
int L=floor(list,left-1);
int R=floor(list,right);
if(R-L>=threshold)return ans;
return -1;
}
private int floor(ArrayList<Integer>list,int n){
int left=0, right=list.size()-1, mid;
while(left<=right){
mid=left+(right-left)/2;
int index=list.get(mid);
if(index==n)return mid;
else if(index<n)left=mid+1;
else right=mid-1;
}
return right;
}
} | class MajorityChecker {
public:
MajorityChecker(vector<int>& arr) {
this->arr = arr;
map<int, int> cnt;
for (auto& v: arr) {
cnt[v]++;
}
val_idx = vector<int>(20001, -1);
for (auto it = cnt.begin(); it != cnt.end(); ++it) {
if (it->second >= 250) {
val_idx[it->first] = elems.size();
elems.push_back(it->first);
}
}
n = elems.size();
pre = vector<vector<int>>(n, vector<int>(arr.size(), 0));
if (val_idx[arr[0]] != -1)
pre[val_idx[arr[0]]][0]++;
for (int i = 1; i < arr.size(); ++i) {
for (int j = 0; j < n; ++j) {
pre[j][i] = pre[j][i-1];
}
if (val_idx[arr[i]] != -1)
pre[val_idx[arr[i]]][i]++;
}
}
int query(int left, int right, int threshold) {
int width = right - left + 1;
if (width < 500) {
map<int, int> cnt;
int most_frequent = 0;
int most_frequent_val;
while (left <= right) {
if (++cnt[arr[left++]] > most_frequent) {
most_frequent = cnt[arr[left - 1]];
most_frequent_val = arr[left - 1];
}
// early end condition, there are not enough elements left
if (right + most_frequent + 1 < threshold + left) return -1;
}
return most_frequent >= threshold ? most_frequent_val : -1;
}
for (int i = 0; i < n; ++i) {
if (pre[i][right] - (left - 1 >= 0 ? pre[i][left - 1] : 0) >= threshold) {
return elems[i];
}
}
return -1;
}
private:
vector<int> arr;
vector<int> elems;
vector<int> val_idx;
int n;
vector<vector<int>> pre;
}; | var MajorityChecker = function(arr) {
this.arr = arr;
};
MajorityChecker.prototype.query = function(left, right, threshold) {
var candidate = 0
var count = 0
for (var i = left; i < right+1; i++) {
if (count == 0) {
candidate = this.arr[i];
count = 1;
}
else if (candidate == this.arr[i]) {
count += 1
}
else {
count -= 1
}
}
count = 0
for (var i = left; i < right+1; i++) {
if (candidate == this.arr[i]) {
count += 1
}
}
if (count >= threshold) {
return candidate
}
return -1
}; | Online Majority Element In Subarray |
You are given a 0-indexed string s that you must perform k replacement operations on. The replacement operations are given as three 0-indexed parallel arrays, indices, sources, and targets, all of length k.
To complete the ith replacement operation:
Check if the substring sources[i] occurs at index indices[i] in the original string s.
If it does not occur, do nothing.
Otherwise if it does occur, replace that substring with targets[i].
For example, if s = "abcd", indices[i] = 0, sources[i] = "ab", and targets[i] = "eee", then the result of this replacement will be "eeecd".
All replacement operations must occur simultaneously, meaning the replacement operations should not affect the indexing of each other. The testcases will be generated such that the replacements will not overlap.
For example, a testcase with s = "abc", indices = [0, 1], and sources = ["ab","bc"] will not be generated because the "ab" and "bc" replacements overlap.
Return the resulting string after performing all replacement operations on s.
A substring is a contiguous sequence of characters in a string.
Example 1:
Input: s = "abcd", indices = [0, 2], sources = ["a", "cd"], targets = ["eee", "ffff"]
Output: "eeebffff"
Explanation:
"a" occurs at index 0 in s, so we replace it with "eee".
"cd" occurs at index 2 in s, so we replace it with "ffff".
Example 2:
Input: s = "abcd", indices = [0, 2], sources = ["ab","ec"], targets = ["eee","ffff"]
Output: "eeecd"
Explanation:
"ab" occurs at index 0 in s, so we replace it with "eee".
"ec" does not occur at index 2 in s, so we do nothing.
Constraints:
1 <= s.length <= 1000
k == indices.length == sources.length == targets.length
1 <= k <= 100
0 <= indexes[i] < s.length
1 <= sources[i].length, targets[i].length <= 50
s consists of only lowercase English letters.
sources[i] and targets[i] consist of only lowercase English letters.
| class Solution:
def findReplaceString(self, s: str, indices: List[int], sources: List[str], targets: List[str]) -> str:
inputs = list(zip(indices,sources,targets))
inputs.sort(key = lambda x: x[0])
offset = 0
for idx, src, tgt in inputs:
idx += offset
if s[idx:idx + len(src)] != src:
print('hi')
print(idx)
continue
offset += len(tgt) - len(src)
s = s[:idx] + tgt + s[idx+len(src):]
return s | class Solution {
public String findReplaceString(String s, int[] indices, String[] sources, String[] targets) {
HashMap<Integer, String> subst = new HashMap<>();
HashMap<Integer, String> tgt = new HashMap<>();
for(int i = 0; i< indices.length; i++) {
subst.put(indices[i], sources[i]);
tgt.put(indices[i],targets[i]);
}
Arrays.sort(indices);
String res = "";
int count = 0;
int avail[] = new int[indices.length];
for(int i = 0; i< s.length(); i++) {
if(count < indices.length && i == indices[count] && s.indexOf(subst.get(indices[count]), indices[count]) == indices[count]){
res = res+""+tgt.get(indices[count]);
i = i+ subst.get(indices[count]).length()-1;
count++;
} else {
if(count < indices.length && i == indices[count])
count++;
res+= s.charAt(i);
}
}
return res;
}
} | class Solution {
public:
string findReplaceString(string s, vector<int>& indices, vector<string>& sources, vector<string>& targets) {
int baggage = 0;
int n = indices.size();
map<int, pair<string,string>> mp;
for(int i=0;i<n;++i)
{
mp[indices[i]]={sources[i], targets[i]};
}
for(auto it:mp)
{
string temp = s.substr(it.first+baggage, it.second.first.size());
if(temp == it.second.first)
{
s.erase(it.first+baggage,it.second.first.size());
s.insert(it.first+baggage, it.second.second);
baggage += it.second.second.size() - it.second.first.size();
}
}
return s;
}
}; | var findReplaceString = function(s, indices, sources, targets) {
let res = s.split('');
for(let i=0; i<indices.length; i++) {
let index = indices[i];
let str = sources[i];
if(s.slice(index, index + str.length) == str) {
res[index] = targets[i];
for(let j = 1; j < str.length; j++) {
res[index+=1] = "";
}
}
}
return res.join('');
}; | Find And Replace in String |
Given an integer array queries and a positive integer intLength, return an array answer where answer[i] is either the queries[i]th smallest positive palindrome of length intLength or -1 if no such palindrome exists.
A palindrome is a number that reads the same backwards and forwards. Palindromes cannot have leading zeros.
Example 1:
Input: queries = [1,2,3,4,5,90], intLength = 3
Output: [101,111,121,131,141,999]
Explanation:
The first few palindromes of length 3 are:
101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, ...
The 90th palindrome of length 3 is 999.
Example 2:
Input: queries = [2,4,6], intLength = 4
Output: [1111,1331,1551]
Explanation:
The first six palindromes of length 4 are:
1001, 1111, 1221, 1331, 1441, and 1551.
Constraints:
1 <= queries.length <= 5 * 104
1 <= queries[i] <= 109
1 <= intLength <= 15
| class Solution:
def kthPalindrome(self, queries: List[int], intLength: int) -> List[int]:
ogLength = intLength
isOdd = intLength & 1
if isOdd:
intLength += 1
k = intLength // 2
k = 10 ** (k - 1)
op = []
for q in queries:
pal = str(k + q - 1)
if isOdd:
pal += pal[::-1][1:]
else:
pal += pal[::-1]
if len(pal) == ogLength:
op.append(int(pal))
else:
op.append(-1)
return op | class Solution {
public long[] kthPalindrome(int[] queries, int intLength) {
long[] res= new long[queries.length];
for(int i=0;i<queries.length;i++){
res[i]=nthPalindrome(queries[i],intLength);
}
return res;
}
public long nthPalindrome(int nth, int kdigit)
{
long temp = (kdigit & 1)!=0 ? (kdigit / 2) : (kdigit/2 - 1);
long palindrome = (long)Math.pow(10, temp);
palindrome += nth - 1;
long res1=palindrome;
if ((kdigit & 1)>0)
palindrome /= 10;
while (palindrome>0)
{
res1=res1*10+(palindrome % 10);
palindrome /= 10;
}
String g="";
g+=res1;
if(g.length()!=kdigit)
return -1;
return res1;
}
} | #define ll long long
class Solution {
public:
vector<long long> kthPalindrome(vector<int>& queries, int intLength) {
vector<ll> result;
ll start = intLength % 2 == 0 ? pow(10, intLength/2 - 1) : pow(10, intLength/2);
for(int q: queries) {
string s = to_string(start + q - 1);
string palindrome = s;
reverse(s.begin(), s.end());
if(intLength % 2 == 0) {
palindrome += s;
} else {
palindrome += s.substr(1, s.size() - 1);
}
// len of palindrome should be intLength, otherwise -1
if (palindrome.size() == intLength)
result.push_back(stoll(palindrome));
else
result.push_back(-1);
}
return result;
}
}; | var kthPalindrome = function(queries, intLength) {
let output=[];
// 1. We use FIRST 2 digits to create palindromes: Math.floor((3+1)/2)=2
let digit=Math.floor((intLength+1)/2);
for(let i=0; i<queries.length; i++){
// 2A. Get Nth 2-digits numbers: 10*(2-1)-1+[5,98]=[14,107]
let helper=10**(digit-1)-1+queries[i];
// 2B. Digits checking: 107>=100, which is INVALID
if(helper>=10**digit){output.push(-1)}
else{
let m=intLength-digit;
// 3A. We still need m digits for REFLECTION: 14=>["1","4"]=>"41"
let add=helper.toString().substr(0, m).split("").reverse().join("");
// 3B. Multiply 10**m for reversed digits: 14=>1400=>1441
helper=helper*10**m+add*1;
output.push(helper);
}
}
return output; // [1441,-1]
}; | Find Palindrome With Fixed Length |
You are given an integer array nums and an integer k. You want to find a subsequence of nums of length k that has the largest sum.
Return any such subsequence as an integer array of length k.
A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
Example 1:
Input: nums = [2,1,3,3], k = 2
Output: [3,3]
Explanation:
The subsequence has the largest sum of 3 + 3 = 6.
Example 2:
Input: nums = [-1,-2,3,4], k = 3
Output: [-1,3,4]
Explanation:
The subsequence has the largest sum of -1 + 3 + 4 = 6.
Example 3:
Input: nums = [3,4,3,3], k = 2
Output: [3,4]
Explanation:
The subsequence has the largest sum of 3 + 4 = 7.
Another possible subsequence is [4, 3].
Constraints:
1 <= nums.length <= 1000
-105 <= nums[i] <= 105
1 <= k <= nums.length
| class Solution(object):
def maxSubsequence(self, nums, k):
ret, max_k = [], sorted(nums, reverse=True)[:k]
for num in nums:
if num in max_k:
ret.append(num)
max_k.remove(num)
if len(max_k) == 0:
return ret | class Solution {
public int[] maxSubsequence(int[] nums, int k) {
PriorityQueue<int[]> pq = new PriorityQueue<>((a,b) -> b[0] - a[0]);
for(int i=0; i<nums.length; i++)
pq.offer(new int[]{nums[i], i});
List<int[]> l = new ArrayList<>();
while(k-- != 0)
l.add(pq.poll());
Collections.sort(l, (a,b) -> a[1] - b[1]);
int[] res = new int[l.size()];
int index = 0;
for(int[] i: l)
res[index++] = i[0];
return res;
}
} | // OJ: https://leetcode.com/problems/find-subsequence-of-length-k-with-the-largest-sum/
// Author: github.com/lzl124631x
// Time: O(NlogN)
// Space: O(N)
class Solution {
public:
vector<int> maxSubsequence(vector<int>& A, int k) {
vector<int> id(A.size());
iota(begin(id), end(id), 0); // Index array 0, 1, 2, ...
sort(begin(id), end(id), [&](int a, int b) { return A[a] > A[b]; }); // Sort the indexes in descending order of their corresponding values in `A`
id.resize(k); // Only keep the first `k` indexes with the greatest `A` values
sort(begin(id), end(id)); // Sort indexes in ascending order
vector<int> ans;
for (int i : id) ans.push_back(A[i]);
return ans;
}
}; | var maxSubsequence = function(nums, k) {
return nums.map((v,i)=>[v,i]).sort((a,b)=>a[0]-b[0]).slice(-k).sort((a,b)=>a[1]-b[1]).map(x=>x[0]);
}; | Find Subsequence of Length K With the Largest Sum |
You are given an array target that consists of distinct integers and another integer array arr that can have duplicates.
In one operation, you can insert any integer at any position in arr. For example, if arr = [1,4,1,2], you can add 3 in the middle and make it [1,4,3,1,2]. Note that you can insert the integer at the very beginning or end of the array.
Return the minimum number of operations needed to make target a subsequence of arr.
A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the remaining elements' relative order. For example, [2,7,4] is a subsequence of [4,2,3,7,2,1,4] (the underlined elements), while [2,4,2] is not.
Example 1:
Input: target = [5,1,3], arr = [9,4,2,3,4]
Output: 2
Explanation: You can add 5 and 1 in such a way that makes arr = [5,9,4,1,2,3,4], then target will be a subsequence of arr.
Example 2:
Input: target = [6,4,8,1,3,2], arr = [4,7,6,2,3,8,6,1]
Output: 3
Constraints:
1 <= target.length, arr.length <= 105
1 <= target[i], arr[i] <= 109
target contains no duplicates.
| from bisect import bisect_left
class Solution:
def minOperations(self, target: List[int], arr: List[int]) -> int:
dt = {num: i for i, num in enumerate(target)}
stack = []
for num in arr:
if num not in dt: continue
i = bisect_left(stack, dt[num])
if i == len(stack):
stack.append(dt[num])
else:
stack[i] = dt[num]
return len(target) - len(stack) | class Solution {
public int minOperations(int[] target, int[] arr) {
int n = target.length;
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < n; i++) {
map.put(target[i], i);
}
List<Integer> array = new ArrayList<>();
for(int i = 0; i < arr.length; i++) {
if(!map.containsKey(arr[i])) {
continue;
}
array.add(map.get(arr[i]));
}
int maxLen = 0;
int[] tails = new int[n + 1];
for(int i = 0; i < n; i++) {
tails[i] = -1;
}
for(int num: array) {
int index = findMinIndex(tails, maxLen, num);
if(tails[index] == -1) {
maxLen++;
}
tails[index] = num;
}
return n - maxLen;
}
public int findMinIndex(int[] tails, int n, int val) {
int low = 0;
int ans = n;
int high = n - 1;
while(low <= high) {
int mid = (high + low) / 2;
if(tails[mid] >= val) {
ans = mid;
high = mid - 1;
}
else {
low = mid + 1;
}
}
return ans;
}
} | class Solution {
public:
vector<int> ans;
void bin(int lo, int hi, int num) {
if(lo == hi) {
ans[lo] = num;
return;
}
int mid = (lo + hi) / 2;
if(ans[mid] < num) bin(mid + 1, hi, num);
else bin(lo, mid, num);
}
int minOperations(vector<int>& target, vector<int>& arr) {
unordered_map<int, int> idx;
for(int i = 0; i < target.size(); i++) {
idx[target[i]] = i;
}
for(int i = 0; i < arr.size(); i++) {
if(idx.find(arr[i]) == idx.end()) continue;
int num = idx[arr[i]];
if(ans.size() == 0 || num > ans.back()) {
ans.push_back(num);
}
else {
bin(0, ans.size() - 1, num);
}
}
return (target.size() - ans.size());
}
}; | const minOperations = function (targets, arr) {
const map = {};
const n = targets.length;
const m = arr.length;
targets.forEach((target, i) => (map[target] = i));
//map elements in arr to index found in targets array
const arrIs = arr.map(el => {
if (el in map) {
return map[el];
} else {
return -1;
}
});
//create a LIS table dp whose length is the longest increasing subsequence
const dp = [];
for (let i = 0; i < m; i++) {
const curr = arrIs[i];
if (curr === -1) continue;
if (!dp.length || curr > dp[dp.length - 1]) {
dp.push(curr);
} else if (curr < dp[0]) {
dp[0] = curr;
} else {
let l = 0;
let r = dp.length;
while (l < r) {
const mid = Math.floor((l + r) / 2);
if (arrIs[i] <= dp[mid]) {
r = mid;
} else {
l = mid + 1;
}
}
dp[r] = curr;
}
}
return n-dp.length;
}; | Minimum Operations to Make a Subsequence |
An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5.
Given an integer n, return true if n is an ugly number.
Example 1:
Input: n = 6
Output: true
Explanation: 6 = 2 × 3
Example 2:
Input: n = 1
Output: true
Explanation: 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.
Example 3:
Input: n = 14
Output: false
Explanation: 14 is not ugly since it includes the prime factor 7.
Constraints:
-231 <= n <= 231 - 1
| class Solution:
def isUgly(self, n: int) -> bool:
if n == 0:
return False
res=[2, 3, 5]
while n!= 1:
for i in res:
if n%i==0:
n=n//i
break
else:
return False
return True | class Solution {
public boolean isUgly(int n) {
if(n==0) return false; //edge case
while(n!=1){
if(n%2==0){
n=n/2;
}
else if(n%3==0){
n=n/3;
}
else if(n%5==0){
n=n/5;
}
else{
return false;
}
}
return true;
}
} | class Solution {
public:
bool isUgly(int n)
{
if (n <= 0) return false;
int n1 = 0;
while(n != n1)
{
n1 = n;
if ((n % 2) == 0) n /= 2;
if ((n % 3) == 0) n /= 3;
if ((n % 5) == 0) n /= 5;
}
if (n < 7) return true;
return false;
}
}; | var isUgly = function(n) {
let condition = true;
if(n == 0) // 0 has infinite factors. So checking if the number is 0 or not
return false;
while(condition){ //applying for true until 2, 3, 5 gets removed from the number
if(n % 2 == 0)
n = n / 2;
else if(n % 3 == 0)
n = n / 3;
else if(n % 5 == 0)
n = n / 5;
else
condition = false; //if the number doesnt have 2, 3, 5 in it anymore, this part will execute and will end the while loop
}
return n == 1 ? true : false;//checking if the number only had 2, 3, 5 in it or had something else in it as well
}; | Ugly Number |
Given a pattern and a string s, find if s follows the same pattern.
Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in s.
Example 1:
Input: pattern = "abba", s = "dog cat cat dog"
Output: true
Example 2:
Input: pattern = "abba", s = "dog cat cat fish"
Output: false
Example 3:
Input: pattern = "aaaa", s = "dog cat cat dog"
Output: false
Constraints:
1 <= pattern.length <= 300
pattern contains only lower-case English letters.
1 <= s.length <= 3000
s contains only lowercase English letters and spaces ' '.
s does not contain any leading or trailing spaces.
All the words in s are separated by a single space.
| class Solution(object):
def wordPattern(self, pattern, s):
"""
:type pattern: str
:type s: str
:rtype: bool
"""
p, s = list(pattern), list(s.split(" "))
return len(s) == len(p) and len(set(zip(p, s))) == len(set(s)) == len(set(p)) | class Solution {
public boolean wordPattern(String pattern, String s) {
String[] arr=s.split(" ");
if(pattern.length()!=arr.length) return false;
Map<Character,String> map=new HashMap<Character,String>();
for(int i=0;i<pattern.length();i++){
char ch=pattern.charAt(i);
if(map.containsKey(ch)){
if(!map.get(ch).equals(arr[i])){
return false;
}
}else if(!(map.containsKey(ch)|| map.containsValue(arr[i]))){
map.put(ch,arr[i]);
}else{
return false;
}
}
return true;
}
} | class Solution {
public:
unordered_set<string> processed_words;
string m[26]; // char to string mapping
bool crunch_next_word(char c, string word)
{
int idx = c-'a';
if(m[idx].empty() && processed_words.count(word)==0)
{
m[idx] = word;
processed_words.insert(word);
return true;
}
else if(m[idx]==word) return true;
else return false;
}
bool wordPattern(string pattern, string s)
{
int count = 0;
int start = 0;
int end = s.find(' ');
while (end != -1)
{
string word = s.substr(start, end - start);
char c = pattern[count];
if(!crunch_next_word(c,word)) return false;
start = end + 1;
end = s.find(' ', start);
count++;
if(count == pattern.length()) return false;
}
if(count != pattern.length()-1) return false;
string word = s.substr(start, end - start);
char c = pattern[count];
if(!crunch_next_word(c,word)) return false;
return true;
}
}; | var wordPattern = function(pattern, s) {
let wordArray = s.split(" ");
if(wordArray.length !== pattern.length) return false;
let hm = {};
let hs = new Set();
for(let index in pattern) {
let word = wordArray[index];
let char = pattern[index];
if(hm[char] !== undefined) {
if(hm[char] !== word) return false;
} else {
if(hs.has(word)) return false; // Duplicate Occurence of word on first occurrence of a char
hm[char] = word;
hs.add(word);
}
}
return true;
} | Word Pattern |
You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.
Example 1:
Input: nums = [1,2,3,1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
Total amount you can rob = 1 + 3 = 4.
Example 2:
Input: nums = [2,7,9,3,1]
Output: 12
Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
Total amount you can rob = 2 + 9 + 1 = 12.
Constraints:
1 <= nums.length <= 100
0 <= nums[i] <= 400
| class Solution:
def rob(self, nums: List[int]) -> int:
# [rob1,rob2,n,n+1]
# 1 | 2 | 3 | 1
#index 0 1 2 3
# so upto last index it depends on previous 2 values :
# here upto 2nd index max rob is 1+3=4; not choosing adjacent element 2
# and upto 1st index max rob is 2 ; not choosing any adjacent elements
# so at 3rd index it depend on prev rob value and 1st index rob value+last value
# i.e max(2+(val at last index),4)
rob1=0;rob2=0;
for i in nums:
temp=max(rob1+i,rob2);
rob1=rob2;
rob2=temp;
return rob2; | class Solution {
public int rob(int[] nums) {
int[] t = new int[nums.length] ;
for(int i=0; i<t.length; i++){
t[i] =-1;
}
return helper(nums,0,t);
}
static int helper(int[] nums, int i,int[] t){
if(i>=nums.length){
return 0;
}
if(i==nums.length-1){
return nums[i];
}
if(t[i] != -1){
return t[i];
}
int pick = nums[i] + helper(nums,i+2,t);
int unpicked = helper(nums,i+1,t);
t[i] = Math.max(pick,unpicked);
return t[i];
}
} | class Solution {
public:
int helper(int i, vector<int>& nums) {
if(i == 0) return nums[i];
if(i < 0) return 0;
int pick = nums[i] + helper(i-2, nums);
int not_pick = 0 + helper(i-1, nums);
return max(pick,not_pick);
}
int rob(vector<int>& nums) {
return helper(nums.size()-1, nums);
}
}; | const max=(x,y)=>x>y?x:y
var rob = function(nums) {
if(nums.length==1) return(nums[0]);
let temp=[]
temp[0]=nums[0];
temp[1]=max(nums[0],nums[1]);
for(let i =2;i<nums.length;i++){
temp[i] = max(temp[i-1],nums[i]+temp[i-2]);
}
// console.log(temp)
return(temp[nums.length-1]);
}; | House Robber |
Convert a non-negative integer num to its English words representation.
Example 1:
Input: num = 123
Output: "One Hundred Twenty Three"
Example 2:
Input: num = 12345
Output: "Twelve Thousand Three Hundred Forty Five"
Example 3:
Input: num = 1234567
Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
Constraints:
0 <= num <= 231 - 1
| class Solution:
def numberToWords(self, num: int) -> str:
if num == 0:
return "Zero"
dic1 = {1000000000: "Billion", 1000000: "Million", 1000: "Thousand", 1: ""}
dic2 = {90: "Ninety", 80: "Eighty", 70: "Seventy", 60: "Sixty", 50: "Fifty", 40: "Forty", 30: "Thirty", 20: "Twenty", 19: 'Nineteen', 18: "Eighteen", 17: "Seventeen", 16: "Sixteen", 15: "Fifteen", 14: "Fourteen", 13: "Thirteen", 12: "Twelve", 11: "Eleven", 10: "Ten", 9: "Nine", 8: "Eight", 7: "Seven", 6: "Six", 5: "Five", 4: "Four", 3: "Three", 2: "Two", 1: "One"}
def construct_num(num):
ans = ''
d, num = divmod(num, 100)
if d > 0:
ans += dic2[d] + " " + "Hundred"
for k, v in dic2.items():
d, num = divmod(num, k)
if d > 0:
ans += " " + v
return ans.lstrip()
ans = ""
for k, v in dic1.items():
d, num = divmod(num, k)
if d > 0:
ans += " " + construct_num(d) + " " + v
return ans.strip() | class Solution {
private static final int[] INT_NUMBERS = {
1_000_000_000, 1_000_000, 1000, 100, 90, 80, 70, 60, 50, 40, 30, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
private static final String[] STRING_NUMBERS = {
"Billion", "Million", "Thousand", "Hundred", "Ninety", "Eighty", "Seventy", "Sixty", "Fifty", "Forty", "Thirty", "Twenty",
"Nineteen", "Eighteen", "Seventeen", "Sixteen", "Fifteen", "Fourteen", "Thirteen", "Twelve", "Eleven", "Ten",
"Nine", "Eight", "Seven", "Six", "Five", "Four", "Three", "Two", "One"};
public String numberToWords(int num) {
if (num == 0) return "Zero";
return numberToWordsHelper(num).toString();
}
private StringBuilder numberToWordsHelper(int num) {
StringBuilder sb = new StringBuilder();
if (num == 0) return sb;
for (int i = 0; i < INT_NUMBERS.length; i++) {
if (num >= INT_NUMBERS[i]) {
if (num >= 100) {
sb.append(numberToWordsHelper(num / INT_NUMBERS[i]).append(" "));
}
sb.append(STRING_NUMBERS[i]).append(" ").append(numberToWordsHelper(num % INT_NUMBERS[i]));
break;
}
}
return sb.charAt(sb.length() - 1) == ' ' ? sb.deleteCharAt(sb.length() - 1) : sb; // trim
}
} | unordered_map<int, string> mp_0 = {{1, "One "},{2, "Two "},{3, "Three "},{4, "Four "}, {5, "Five "},{6, "Six "},{7, "Seven "},{8, "Eight "},{9, "Nine "}, {10, "Ten "},{11,"Eleven "},{12, "Twelve "},{13, "Thirteen "},{14, "Fourteen "},{15, "Fifteen "},{16, "Sixteen "},{17, "Seventeen "},{18, "Eighteen "},{19, "Nineteen "}};
unordered_map<int, string> mp_10 = {{20, "Twenty "},{30, "Thirty "},{40 , "Forty "},{50, "Fifty "},{60, "Sixty "},{70, "Seventy "},{80, "Eighty "},{90, "Ninety "}};
class Solution {
void Solve2(string &ans , int num)
{
ans = mp_0[num] + ans;
}
void Solve( string &ans, int num)
{
int factor = 1;
for(int i = 0 ; num>0 ; i++)
{
if(factor == 1)
{
if(num%100 < 20)
{
Solve2(ans, num%100);
factor = factor*10;
num = num/10;
}
else
{
if(num%10 !=0)
ans = mp_0[num%10] + ans;
}
}
else if(factor == 10)
{
if(num%10 != 0)
ans = mp_10[(num%10)*10] + ans;
}
else if(factor == 100)
{
if(num%10 != 0)
ans = (mp_0[num%10] + "Hundred ") + ans;
}
factor = factor*10;
num = num/10;
}
}
public:
string numberToWords(int num) {
//2,147,483,647
if(num == 0)
return "Zero";
string ans ;
for(int i = 0 ; num>0 ; i++)
{
if(i == 1)
{
if(num%1000>0)
ans = "Thousand "+ ans;
}
else if(i == 2)
{
if(num%1000>0)
ans = "Million "+ ans;
}
else if( i == 3)
ans = "Billion "+ ans;
Solve(ans, num%1000);
num = num/1000;
}
ans.pop_back();
return ans;
}
}; | let numberMap = {
0: 'Zero',
100: 'Hundred',
1: 'One',
2: 'Two',
3: 'Three',
4: 'Four',
5: 'Five',
6: 'Six',
7: 'Seven',
8: 'Eight',
9: 'Nine',
10: 'Ten',
11: 'Eleven',
12: 'Twelve',
13: 'Thirteen',
14: 'Fourteen',
15: 'Fifteen',
16: 'Sixteen',
17: 'Seventeen',
18: 'Eighteen',
19: 'Nineteen',
20: 'Twenty',
30: 'Thirty',
40: 'Forty',
50: 'Fifty',
60: 'Sixty',
70: 'Seventy',
80: 'Eighty',
90: 'Ninety'
};
let bigNumberMap = {
1000000000: 'Billion',
1000000: 'Million',
1000: 'Thousand',
1: 'One'
}
let bases = [];
for (let base in numberMap) {
bases.push(parseInt(base, 10));
}
bases = bases.sort((a,b) => b-a);
let bigBases = [];
for (let base in bigNumberMap) {
bigBases.push(parseInt(base, 10));
}
bigBases = bigBases.sort((a,b) => b-a);
var numberToWords = function(num) {
let res = '';
if (num === 0) return numberMap[num];
bigBases.forEach((base) => {
base = parseInt(base, 10);
let baseAsString = base + '';
let nums = num/base << 0;
let remainder = num - nums * base;
if (nums >= 1) {
[res, nums] = getForHundredBase(res, nums);
res += baseAsString.length > 1 ? (' ' + bigNumberMap[base + '']) : '';
num = remainder;
}
});
return res;
};
function getForHundredBase(res, num) {
bases.forEach((base) => {
base = parseInt(base, 10);
[num, res] = getNums(num, base, res);
});
return [res, num];
}
function getNums(num, base, res) {
let nums = num / base << 0;
let baseAsString = base + '';
if (nums > 1 || (nums == 1 && baseAsString.length > 2)) {
res += res === '' ? res : " ";
res += numberMap[nums] + " " + numberMap[baseAsString];
} else if (nums == 1) {
res += res === '' ? res : " ";
res += numberMap[baseAsString];
}
return [num - (nums * base), res];
} | Integer to English Words |
Hercy wants to save money for his first car. He puts money in the Leetcode bank every day.
He starts by putting in $1 on Monday, the first day. Every day from Tuesday to Sunday, he will put in $1 more than the day before. On every subsequent Monday, he will put in $1 more than the previous Monday.
Given n, return the total amount of money he will have in the Leetcode bank at the end of the nth day.
Example 1:
Input: n = 4
Output: 10
Explanation: After the 4th day, the total is 1 + 2 + 3 + 4 = 10.
Example 2:
Input: n = 10
Output: 37
Explanation: After the 10th day, the total is (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4) = 37. Notice that on the 2nd Monday, Hercy only puts in $2.
Example 3:
Input: n = 20
Output: 96
Explanation: After the 20th day, the total is (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4 + 5 + 6 + 7 + 8) + (3 + 4 + 5 + 6 + 7 + 8) = 96.
Constraints:
1 <= n <= 1000
| from itertools import cycle, \
repeat, \
starmap
from operator import floordiv
class Solution:
def totalMoney(self, n: int) -> int:
return sum(starmap(add,zip(
starmap(floordiv, zip(range(n), repeat(7, n))),
cycle((1,2,3,4,5,6,7))
))) | class Solution {
public int totalMoney(int n) {
int m=n/7; //(no.of full weeks)
// first week 1 2 3 4 5 6 7 (sum is 28 i.e. 7*(i+3) if i=1)
// second week 2 3 4 5 6 7 8 (sum is 35 i.e. 7*(i+3) if i=2)
//.... so on
int res=0; //for result
//calculating full weeks
for(int i=1;i<=m;i++){
res+=7*(i+3);
}
//calculating left days
for(int i=7*m;i<n;i++){
res+=++m;
}
return res;
}
} | class Solution {
public:
int totalMoney(int n) {
int res = 0;
for (int i = 1, c = 1; i <= n; i++, c++) {
res += c;
c = i % 7 ? c : (i / 7);
}
return res;
}
}; | var totalMoney = function(n) {
let min = 1;
let days = 7;
let total = 0;
let inc = 1;
for (let i = 0; i < n; i++) {
if (days !== 0) {
total += min;
min++;
days--;
} else {
inc++;
min = inc
days = 7;
i--;
}
}
return total;
}; | Calculate Money in Leetcode Bank |
You are given n balloons, indexed from 0 to n - 1. Each balloon is painted with a number on it represented by an array nums. You are asked to burst all the balloons.
If you burst the ith balloon, you will get nums[i - 1] * nums[i] * nums[i + 1] coins. If i - 1 or i + 1 goes out of bounds of the array, then treat it as if there is a balloon with a 1 painted on it.
Return the maximum coins you can collect by bursting the balloons wisely.
Example 1:
Input: nums = [3,1,5,8]
Output: 167
Explanation:
nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
coins = 3*1*5 + 3*5*8 + 1*3*8 + 1*8*1 = 167
Example 2:
Input: nums = [1,5]
Output: 10
Constraints:
n == nums.length
1 <= n <= 300
0 <= nums[i] <= 100
| from functools import cache
class Solution:
def maxCoins(self, nums: List[int]) -> int:
nums = [1] + nums + [1]
length = len(nums)
dp = [[None]*(length+1) for i in range(length+1)]
@cache
def dfs(l,r):
if l>r: return 0
if dp[l][r] is not None: return dp[l][r]
dp[l][r] = 0
for i in range(l,r+1):
coins = dfs(l, i-1) + dfs(i+1, r) + nums[l-1]*nums[i]*nums[r+1]
dp[l][r] = max(dp[l][r], coins)
return dp[l][r]
return dfs(1, length-2) | class Solution {
public int maxCoins(int[] nums) {
int n = nums.length;
// adding 1 to the front and back
int[] temp = new int[n + 2];
temp[0] = 1;
for(int i = 1; i < temp.length - 1; i++){
temp[i] = nums[i-1];
}
temp[temp.length - 1] = 1;
nums = temp;
// memoization
int[][] dp = new int[n+1][n+1];
for(int[] row : dp){
Arrays.fill(row, -1);
}
// result
return f(1, n, nums, dp);
}
int f(int i, int j, int[] a, int[][] dp){
if(i > j) return 0;
if(dp[i][j] != -1) return dp[i][j];
int max = Integer.MIN_VALUE;
for(int n = i; n <= j; n++){
int coins = a[i-1] * a[n] * a[j+1] + f(i, n-1, a, dp) + f(n+1, j, a, dp);
max = Math.max(max, coins);
}
return dp[i][j] = max;
}
}
// Time Complexity: O(N * N * N) ~ O(N^3);
// Space Complexity: O(N^2) + O(N); | class Solution {
public:
//topDown+memoization
int solve(int i,int j,vector<int>& nums,vector<vector<int>>& dp){
if(i>j) return 0;
if(dp[i][j]!=-1) return dp[i][j];
int maxcost = INT_MIN;
for(int k = i;k<=j;k++){
int cost = nums[i-1]*nums[k]*nums[j+1]+solve(i,k-1,nums,dp)+solve(k+1,j,nums,dp);
maxcost = max(maxcost,cost);
}
return dp[i][j] = maxcost;
}
int maxCoins(vector<int>& nums) {
nums.insert(nums.begin(),1);
nums.push_back(1);
int n = nums.size();
vector<vector<int>> dp(n+1,vector<int>(n+1,-1));
return solve(1,n-2,nums,dp);
}
//bottomUp dp
int maxCoins(vector<int>& nums) {
//including the nums[-1] == 1 and nums[n] == 1
int n = nums.size();
nums.insert(nums.begin(),1);
nums.push_back(1);
vector<vector<int>> dp(nums.size()+1,vector<int>(nums.size()+1,0));
for (int len = 1; len <= n; ++len)
for (int left = 1; left <= n - len + 1; ++left) {
int right = left + len - 1;
for (int k = left; k <= right; ++k)
dp[left][right] = max(dp[left][right], nums[left-1]*nums[k]*nums[right+1] + dp[left][k-1] + dp[k+1][right]);
}
return dp[1][n];
}
}; | var rec = function(i,j,arr,dp){
if(i>j)return 0;
if(dp[i][j] !== -1)return dp[i][j];
let max = Number.MIN_VALUE;
for(let k=i;k<=j;k++){
let cost = arr[i-1] * arr[k] * arr[j+1] + rec(i,k-1,arr,dp)+rec(k+1,j,arr,dp);
if(cost>max){
max = cost
}
}
return dp[i][j] = max
}
var maxCoins = function(nums) {
let n = nums.length;
let sol = [];
for(let i=0;i<n+1;i++){
sol[i] = Array(n+1).fill(-1)
}
nums.unshift(1);
nums.push(1)
return rec(1,n,nums,sol)
}; | Burst Balloons |
Given an integer array nums, return the number of elements that have both a strictly smaller and a strictly greater element appear in nums.
Example 1:
Input: nums = [11,7,2,15]
Output: 2
Explanation: The element 7 has the element 2 strictly smaller than it and the element 11 strictly greater than it.
Element 11 has element 7 strictly smaller than it and element 15 strictly greater than it.
In total there are 2 elements having both a strictly smaller and a strictly greater element appear in nums.
Example 2:
Input: nums = [-3,3,3,90]
Output: 2
Explanation: The element 3 has the element -3 strictly smaller than it and the element 90 strictly greater than it.
Since there are two elements with the value 3, in total there are 2 elements having both a strictly smaller and a strictly greater element appear in nums.
Constraints:
1 <= nums.length <= 100
-105 <= nums[i] <= 105
| class Solution:
def countElements(self, nums: List[int]) -> int:
M = max(nums)
m = min(nums)
return sum(1 for i in nums if m<i<M) | class Solution {
public int countElements(int[] nums) {
int nmin=Integer.MAX_VALUE;
int nmax=Integer.MIN_VALUE;
for(int a:nums)
{
nmin=Math.min(a,nmin);
nmax=Math.max(a,nmax);
}
int count=0;
for(int a:nums)
{
if(a>nmin && a<nmax)
count++;
}
return count;
}
} | class Solution {
public:
int countElements(vector<int>& nums) {
int M = *max_element(nums.begin(), nums.end());
int m = *min_element(nums.begin(), nums.end());
int res = 0;
for(int i = 0; i < nums.size(); i++){
if(nums[i] > m && nums[i] < M) res++;
}
return res;
}
}; | var countElements = function(nums) {
let map = {}, total = 0;
// adding elements to map
for(let i of nums) map[i] ? map[i]++ : map[i] = 1;
// Removing repeated elements
let newNums = [... new Set(nums)];
// If length of array after removing repeated nums is less than three return 0;
if(newNums.length < 3) return 0;
// sort the newNums array and remove the first and last element.
// for all the remaining elements check their number in map and add it to total variable
newNums.sort((a,b) => a-b).slice(1, newNums.length-1).forEach(num => total += map[num]);
// return total variable
return total;
}; | Count Elements With Strictly Smaller and Greater Elements |
In this problem, a tree is an undirected graph that is connected and has no cycles.
You are given a graph that started as a tree with n nodes labeled from 1 to n, with one additional edge added. The added edge has two different vertices chosen from 1 to n, and was not an edge that already existed. The graph is represented as an array edges of length n where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the graph.
Return an edge that can be removed so that the resulting graph is a tree of n nodes. If there are multiple answers, return the answer that occurs last in the input.
Example 1:
Input: edges = [[1,2],[1,3],[2,3]]
Output: [2,3]
Example 2:
Input: edges = [[1,2],[2,3],[3,4],[1,4],[1,5]]
Output: [1,4]
Constraints:
n == edges.length
3 <= n <= 1000
edges[i].length == 2
1 <= ai < bi <= edges.length
ai != bi
There are no repeated edges.
The given graph is connected.
| class UnionFind:
def __init__(self, size):
self.parent = [-1 for _ in range(size)]
self.rank = [-1 for _ in range(size)]
def find(self, i):
if self.parent[i] == -1:
return i
k = self.find(self.parent[i])
self.parent[i] = k
return k
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return -1
else:
if self.rank[x] > self.rank[y]:
self.parent[y] = x
elif self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.rank[x] += 1
self.parent[y] = x
class Solution:
def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
vertex_set = set()
for edge in edges:
vertex_set.add(edge[0])
vertex_set.add(edge[1])
union_find = UnionFind(len(vertex_set))
for edge in edges:
new_edge = [edge[0]-1, edge[1]-1]
if union_find.union(new_edge[0], new_edge[1]) == -1:
return edge
return [] | class Solution {
public int[] findRedundantConnection(int[][] edges) {
UnionFind uf = new UnionFind(edges.length);
for (int[] edge : edges) {
if (!uf.union(edge[0], edge[1])) {
return new int[]{edge[0], edge[1]};
}
}
return null;
}
private class UnionFind {
int[] rank;
int[] root;
UnionFind(int n) {
rank = new int[n + 1];
root = new int[n + 1];
for (int i = 1; i <= n; i++) {
root[i] = i;
rank[i] = 1;
}
}
int find(int x) {
if (x == root[x]) {
return x;
}
return root[x] = find(root[x]);
}
boolean union(int x, int y) {
int rootX = find(x);
int rootY = find(y);
if (rootX != rootY) {
if (rank[rootX] > rank[rootY]) {
root[rootY] = root[rootX];
} else if (rank[rootY] > rank[rootX]) {
root[rootX] = root[rootY];
} else {
root[rootY] = root[rootX];
rank[rootX]++;
}
return true;
}
return false;
}
}
} | class UnionFind {
public:
int* parent;
int* rank;
UnionFind(int n){
rank = new int[n];
parent = new int[n];
for(int i=0; i<n; i++){
parent[i] = i;
rank[i] = 0;
}
}
// collapsing find
int Find(int node){
// if parent of node is itself
if(parent[node] == node){
return node;
}
return parent[node] = Find(parent[node]);
}
// union by rank
void Union(int u, int v){
// find the parent nodes of u and v
u = Find(u);
v = Find(v);
// if u and v don't belong to the same set
if(u != v){
if(rank[u]<rank[v]){
swap(u,v);
}
// attaching the lower rank tree with the higher rank one
parent[v] = u;
// if ranks are equal increase the rank of u
if(rank[u]==rank[v]){
rank[u]++;
}
}
}
};
class Solution {
public:
vector<int> findRedundantConnection(vector<vector<int>>& edges) {
UnionFind UF = UnionFind(1001);
for(vector<int>& edge : edges){
int u = edge[0];
int v = edge[1];
// if adding this edge creates a cycle
if(UF.Find(u) == UF.Find(v)){
return {u,v};
}
// add u and v to the same set
UF.Union(u,v);
}
// if no cycle was found
return {-1};
}
}; | var findRedundantConnection = function(edges) {
const root = [];
const find = (index) => {
const next = root[index];
return next ? find(next) : index;
};
for (const [a, b] of edges) {
const x = find(a);
const y = find(b);
if (x === y) return [a, b];
root[x] = y;
}
}; | Redundant Connection |
The chess knight has a unique movement, it may move two squares vertically and one square horizontally, or two squares horizontally and one square vertically (with both forming the shape of an L). The possible movements of chess knight are shown in this diagaram:
A chess knight can move as indicated in the chess diagram below:
We have a chess knight and a phone pad as shown below, the knight can only stand on a numeric cell (i.e. blue cell).
Given an integer n, return how many distinct phone numbers of length n we can dial.
You are allowed to place the knight on any numeric cell initially and then you should perform n - 1 jumps to dial a number of length n. All jumps should be valid knight jumps.
As the answer may be very large, return the answer modulo 109 + 7.
Example 1:
Input: n = 1
Output: 10
Explanation: We need to dial a number of length 1, so placing the knight over any numeric cell of the 10 cells is sufficient.
Example 2:
Input: n = 2
Output: 20
Explanation: All the valid number we can dial are [04, 06, 16, 18, 27, 29, 34, 38, 40, 43, 49, 60, 61, 67, 72, 76, 81, 83, 92, 94]
Example 3:
Input: n = 3131
Output: 136006598
Explanation: Please take care of the mod.
Constraints:
1 <= n <= 5000
| class Solution:
def knightDialer(self, n: int) -> int:
# Sum elements of matrix modulo mod subroutine
def sum_mat(matrix, mod):
return sum(sum(row) % mod for row in matrix) % mod
# Matrix multiplication subroutine
def mult_mat(a, b):
return [[sum(a[i][k]*b[k][j] for k in range(10)) for j in range(10)] for i in range(10)]
# Matrix exponentiation subroutine
def pow_mat(matrix, k, dp):
if k not in dp:
if k == 0:
dp[k] = [[(1 if i == j else 0) for j in range(10)] for i in range(10)]
else:
dp[k] = pow_mat(matrix, k//2, dp)
dp[k] = mult_mat(dp[k], dp[k])
if k % 2:
dp[k] = mult_mat(dp[k], matrix)
return dp[k]
# Create matrix
edges = [(1, 6), (1, 8), (2, 9), (2, 7), (3, 4), (3, 8), (4, 0), (4, 9), (6, 1), (6, 0), (6, 7)]
matrix = [[0 for j in range(10)] for i in range(10)]
for i, j in edges:
matrix[i][j] = 1
matrix[j][i] = 1
# Solve
mod = 10**9 + 7
return sum_mat(pow_mat(matrix, n-1, {}), mod) | class Solution {
public int knightDialer(int n) {
var dp = new long[10];
var tmp = new long[10];
Arrays.fill(dp, 1);
for (int i = 1; i < n; i++) {
tmp[1] = dp[6]+dp[8];
tmp[2] = dp[7]+dp[9];
tmp[3] = dp[4]+dp[8];
tmp[4] = dp[0]+dp[3]+dp[9];
tmp[5] = 0;
tmp[6] = dp[0]+dp[1]+dp[7];
tmp[7] = dp[2]+dp[6];
tmp[8] = dp[1]+dp[3];
tmp[9] = dp[2]+dp[4];
tmp[0] = dp[4]+dp[6];
for (int j = 0; j < 10; j++) tmp[j] = tmp[j] % 1000000007;
var arr = dp;
dp = tmp;
tmp = arr;
}
long res = 0;
for (int i = 0; i < 10; i++) {
res = (res+dp[i]) % 1000000007;
}
return (int)res;
}
} | class Solution {
int MOD=1e9+7;
public:
int knightDialer(int n) {
if(n==1) return 10;
int a=2, b=2, c=3, d=2; //a{2,8} b{1,3,7,9} c{4,6} d{0}
for(int i=3; i<=n; i++){
int w, x, y, z;
w = 2ll*b%MOD;
x = (1ll*a + 1ll*c)%MOD;
y = (2ll*b + 1ll*d)%MOD;
z = 2ll*c%MOD;
a = w; b = x; c = y; d = z;
}
int ans = (2ll*a + 4ll*b + 2ll*c + d)%MOD;
return ans;
}
}; | var knightDialer = function(n) {
let dp = Array(10).fill(1)
let MOD = 10**9 + 7
for(let i = 2; i <= n ; i++) {
oldDp = [...dp]
dp[0] = (oldDp[4] + oldDp[6]) % MOD
dp[1] = (oldDp[8] + oldDp[6]) % MOD
dp[2] = (oldDp[9] + oldDp[7]) % MOD
dp[3] = (oldDp[8] + oldDp[4]) % MOD
dp[4] = (oldDp[3] + oldDp[9] + oldDp[0]) % MOD
dp[5] = 0
dp[6] = (oldDp[0] + oldDp[7] + oldDp[1]) % MOD
dp[7] = (oldDp[6] + oldDp[2]) % MOD
dp[8] = (oldDp[3] + oldDp[1]) % MOD
dp[9] = (oldDp[4] + oldDp[2]) % MOD
}
return dp.reduce((ans, ele) => ans += ele, 0) % MOD
}; | Knight Dialer |
Given the string s, return the size of the longest substring containing each vowel an even number of times. That is, 'a', 'e', 'i', 'o', and 'u' must appear an even number of times.
Example 1:
Input: s = "eleetminicoworoep"
Output: 13
Explanation: The longest substring is "leetminicowor" which contains two each of the vowels: e, i and o and zero of the vowels: a and u.
Example 2:
Input: s = "leetcodeisgreat"
Output: 5
Explanation: The longest substring is "leetc" which contains two e's.
Example 3:
Input: s = "bcbcbc"
Output: 6
Explanation: In this case, the given string "bcbcbc" is the longest because all vowels: a, e, i, o and u appear zero times.
Constraints:
1 <= s.length <= 5 x 10^5
s contains only lowercase English letters.
| class Solution:
def findTheLongestSubstring(self, s: str) -> int:
integrals = [(False, False, False, False, False)] # integrals[10][mapping["a"]] == False means we have seen "a" appears even times before index 10
mapping = {
"a": 0,
"i": 1,
"u": 2,
"e": 3,
"o": 4
}
for v in s:
vector = list(integrals[-1])
if v in mapping: # if v is a vowel
vector[mapping[v]] = not vector[mapping[v]] # toggle that dimension, because if v had appeared even times before, it becomes odd times now
integrals.append(tuple(vector))
seen = {}
res = 0
for i, v in enumerate(integrals):
if v in seen: # we have seen this vector before
res = max(res, i - seen[v]) # compare its substring length
else:
seen[v] = i # just record the first time each vector appears
return res | class Solution {
public int findTheLongestSubstring(String s) {
int res = 0 , mask = 0, n = s.length();
HashMap<Integer, Integer> seen = new HashMap<>();// key--> Mask, value--> Index
seen.put(0, -1);
for (int i = 0; i < n; ++i) {
if(s.charAt(i)=='a' || s.charAt(i)=='e' || s.charAt(i)=='i' || s.charAt(i)=='o' || s.charAt(i)=='u'){ // check only vowels and skip consonant
int c=s.charAt(i);
mask=mask ^ c;
seen.putIfAbsent(mask, i);
}
res = Math.max(res, i - seen.get(mask));
}
return res;
}
} | //When the xor of all the even times numbers are done it results in 0. The xor of the vowels are done by indicating
//them with a single digit and the xor value is stored in a map
class Solution {
public:
int findTheLongestSubstring(string s) {
int x= 0;
unordered_map<int,int>mp;
mp[0]=-1;
int n=0;
for(int i=0;i<s.length();i++){
if(s[i]=='a' || s[i]=='e' || s[i]=='i' || s[i]=='o' || s[i]=='u'){
x^= (s[i]-'a'+1);
if(mp.find(x)==mp.end())
mp[x]=i;
}
if(mp.find(x)!=mp.end())
n= max(n,i-mp[x]);
}
return n;
}
}; | var findTheLongestSubstring = function(s) {
// u o i e a
// 0 0 0 0 0 => initial state, all are even letters
// s = "abcab"
// 0 0 0 0 1 => at index 0, only a is odd count
// 0 0 0 0 1 => at index 1, max = 1
// 0 0 0 0 1 => at index 2, max = 2
// 0 0 0 0 0 => at index 3, max = 4
// 0 0 0 0 0 => at index 4, max = 5
// valid condition: same state in previous index, then it means we have a even count for all letters within the middle substring.
var mask = 0;
var t = "aeiou";
var count = new Map(); // <mask, first_idx>
count.set(0,-1);
var res = 0;
for(var i = 0; i<s.length; i++)
{
if(t.indexOf(s[i])>=0)
{
var j = t.indexOf(s[i]);
mask = mask ^ (1 << j);
}
if(!count.has(mask))
{
count.set(mask,i);
}
else
{
// substring is from [prevIdx+1, i];
res = Math.max(res, i - count.get(mask));
}
}
return res;
}; | Find the Longest Substring Containing Vowels in Even Counts |
There is a long and thin painting that can be represented by a number line. The painting was painted with multiple overlapping segments where each segment was painted with a unique color. You are given a 2D integer array segments, where segments[i] = [starti, endi, colori] represents the half-closed segment [starti, endi) with colori as the color.
The colors in the overlapping segments of the painting were mixed when it was painted. When two or more colors mix, they form a new color that can be represented as a set of mixed colors.
For example, if colors 2, 4, and 6 are mixed, then the resulting mixed color is {2,4,6}.
For the sake of simplicity, you should only output the sum of the elements in the set rather than the full set.
You want to describe the painting with the minimum number of non-overlapping half-closed segments of these mixed colors. These segments can be represented by the 2D array painting where painting[j] = [leftj, rightj, mixj] describes a half-closed segment [leftj, rightj) with the mixed color sum of mixj.
For example, the painting created with segments = [[1,4,5],[1,7,7]] can be described by painting = [[1,4,12],[4,7,7]] because:
[1,4) is colored {5,7} (with a sum of 12) from both the first and second segments.
[4,7) is colored {7} from only the second segment.
Return the 2D array painting describing the finished painting (excluding any parts that are not painted). You may return the segments in any order.
A half-closed segment [a, b) is the section of the number line between points a and b including point a and not including point b.
Example 1:
Input: segments = [[1,4,5],[4,7,7],[1,7,9]]
Output: [[1,4,14],[4,7,16]]
Explanation: The painting can be described as follows:
- [1,4) is colored {5,9} (with a sum of 14) from the first and third segments.
- [4,7) is colored {7,9} (with a sum of 16) from the second and third segments.
Example 2:
Input: segments = [[1,7,9],[6,8,15],[8,10,7]]
Output: [[1,6,9],[6,7,24],[7,8,15],[8,10,7]]
Explanation: The painting can be described as follows:
- [1,6) is colored 9 from the first segment.
- [6,7) is colored {9,15} (with a sum of 24) from the first and second segments.
- [7,8) is colored 15 from the second segment.
- [8,10) is colored 7 from the third segment.
Example 3:
Input: segments = [[1,4,5],[1,4,7],[4,7,1],[4,7,11]]
Output: [[1,4,12],[4,7,12]]
Explanation: The painting can be described as follows:
- [1,4) is colored {5,7} (with a sum of 12) from the first and second segments.
- [4,7) is colored {1,11} (with a sum of 12) from the third and fourth segments.
Note that returning a single segment [1,7) is incorrect because the mixed color sets are different.
Constraints:
1 <= segments.length <= 2 * 104
segments[i].length == 3
1 <= starti < endi <= 105
1 <= colori <= 109
Each colori is distinct.
| class Solution:
def splitPainting(self, segments: List[List[int]]) -> List[List[int]]:
mix, res, last_i = DefaultDict(int), [], 0
for start, end, color in segments:
mix[start] += color
mix[end] -= color
for i in sorted(mix.keys()):
if last_i in mix and mix[last_i]:
res.append([last_i, i, mix[last_i]])
mix[i] += mix[last_i]
last_i = i
return res | class Solution {
//class for segments
class Seg{
int val,end;
int color;
boolean isStart;
public Seg(int val,int end,int color, boolean isStart){
this.val = val;
this.end = end;
this.color = color;
this.isStart = isStart;
}
public String toString(){
return "[" + val+" "+end+" "+color+" "+isStart+"]";
}
}
public List<List<Long>> splitPainting(int[][] segments) {
List<List<Long>> res = new ArrayList();
List<Seg> list = new ArrayList();
//making a list of segments
for(int[] segment : segments){
list.add(new Seg(segment[0],segment[1],segment[2],true));
list.add(new Seg(segment[1],segment[1],segment[2],false));
}
//Sorting the segments
Collections.sort(list,(a,b)->{return a.val-b.val;});
//System.out.println(list);
//Iterating over list to combine the elements
for(Seg curr: list){
int len = res.size();
if(curr.isStart){
//if the segment is starting there could be three ways
if(res.size()>0 && res.get(len-1).get(0)==curr.val){
//if starting point of two things is same
List<Long> temp = res.get(len-1);
temp.set(1,Math.max(temp.get(1),curr.end));
temp.set(2,(long)(temp.get(2)+curr.color));
}else if(res.size()>0 && res.get(len-1).get(1)>curr.val){
//if there is a start in between create a new segment of different color
List<Long> prev = res.get(len-1);
prev.set(1,(long)curr.val);
List<Long> temp = new ArrayList();
temp.add((long)curr.val); temp.add((long)curr.end); temp.add((long)(prev.get(2)+curr.color));
res.add(temp);
}else{
//Add a new value if nothing is present in result
List<Long> temp = new ArrayList();
temp.add((long)curr.val); temp.add((long)curr.end); temp.add((long)curr.color);
res.add(temp);
}
}else{
if(res.size()>0 && res.get(len-1).get(0)==curr.val){
//if ending point of 2 segments is same
Long prevColor = res.get(len-1).get(2);
res.get(len-1).set(2,(long)(prevColor-curr.color));
}
else if(res.size()>0 && res.get(len-1).get(1)>curr.val){
//if there is a ending in between create a new segment of different color
Long prevColor = res.get(len-1).get(2);
Long prevEnd = res.get(len-1).get(1);
res.get(len-1).set(1,(long)curr.val);
List<Long> temp = new ArrayList();
temp.add((long)curr.val); temp.add((long)prevEnd); temp.add((long)(prevColor-curr.color));
res.add(temp);
}
}
//System.out.println(res+" "+curr);
}
//System.out.println(res);
return res;
}
} | typedef long long ll;
class Solution {
public:
vector<vector<long long>> splitPainting(vector<vector<int>>& segments) {
vector<vector<ll> > ans;
map<int,ll> um;
for(auto s : segments){
um[s[0]] += s[2];
um[s[1]] -= s[2];
}
bool flag = false;
pair<int,ll> prev;
ll curr = 0;
for(auto x : um){
if(flag == false){
prev = x;
curr += x.second;
flag = true;
continue;
}
vector<ll> v = {prev.first,x.first,curr};
prev = x;
if(curr)
ans.push_back(v);
curr += x.second;
}
return ans;
}
}; | /**
* @param {number[][]} segments
* @return {number[][]}
*/
var splitPainting = function(segments) {
const arr = [];
segments.forEach(([start, end, val])=>{
arr.push([start, val]);
arr.push([end, -val]);
});
arr.sort((i,j)=>i[0]-j[0]);
const ans = [];
let currVal = 0, prevTime;
arr.forEach(([time, val])=>{
if(prevTime !== undefined && currVal && prevTime !== time) ans.push([prevTime, time, currVal]);
currVal += val;
prevTime = time;
})
return ans;
}; | Describe the Painting |
The variance of a string is defined as the largest difference between the number of occurrences of any 2 characters present in the string. Note the two characters may or may not be the same.
Given a string s consisting of lowercase English letters only, return the largest variance possible among all substrings of s.
A substring is a contiguous sequence of characters within a string.
Example 1:
Input: s = "aababbb"
Output: 3
Explanation:
All possible variances along with their respective substrings are listed below:
- Variance 0 for substrings "a", "aa", "ab", "abab", "aababb", "ba", "b", "bb", and "bbb".
- Variance 1 for substrings "aab", "aba", "abb", "aabab", "ababb", "aababbb", and "bab".
- Variance 2 for substrings "aaba", "ababbb", "abbb", and "babb".
- Variance 3 for substring "babbb".
Since the largest possible variance is 3, we return it.
Example 2:
Input: s = "abcde"
Output: 0
Explanation:
No letter occurs more than once in s, so the variance of every substring is 0.
Constraints:
1 <= s.length <= 104
s consists of lowercase English letters.
| class Solution:
class Solution:
def largestVariance(self, s: str) -> int:
def maxSubArray(nums: List[int]):
ans=-float('inf')
runningSum=0
seen=False
for x in (nums):
if x<0:
seen=True
runningSum+=x
if seen:
ans=max(ans,runningSum)
else:
ans=max(ans,runningSum-1)
if runningSum<0:
runningSum=0
seen=False
return ans
f=set()
a=''
for x in s:
if x not in f:
a+=x
f.add(x)
n=len(s)
res=0
for j in range(len(a)-1):
for k in range(j+1,len(a)):
x=a[j]
y=a[k]
arr=[]
for i in range(n):
if s[i]!=x and s[i]!=y:
continue
elif s[i]==x:
arr.append(1)
else:
arr.append(-1)
res=max(res,maxSubArray(arr),maxSubArray([-x for x in arr]))
return res
| class Solution {
public int largestVariance(String s) {
int [] freq = new int[26];
for(int i = 0 ; i < s.length() ; i++)
freq[(int)(s.charAt(i) - 'a')]++;
int maxVariance = 0;
for(int a = 0 ; a < 26 ; a++){
for(int b = 0 ; b < 26 ; b++){
int remainingA = freq[a];
int remainingB = freq[b];
if(a == b || remainingA == 0 || remainingB == 0) continue;
// run kadanes on each possible character pairs (A & B)
int currBFreq = 0, currAFreq = 0;
for(int i = 0 ; i < s.length() ; i++){
int c = (int)(s.charAt(i) - 'a');
if(c == b) currBFreq++;
if(c == a) {
currAFreq++;
remainingA--;
}
if(currAFreq > 0)
maxVariance = Math.max(maxVariance, currBFreq - currAFreq);
if(currBFreq < currAFreq && remainingA >= 1){
currBFreq = 0;
currAFreq = 0;
}
}
}
}
return maxVariance;
}
} | /*
Time: O(26*26*n)
Space: O(1)
Tag: Kadane's Algorithm
Difficulty: H (Logic) | E(Implementation)
*/
class Solution {
public:
int largestVariance(string s) {
int res = 0;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
if (i == j) continue;
int highFreq = 0;
int lowFreq = 0;
bool prevHadLowFreqChar = false;
for (char ch : s) {
if (ch - 'a' == i)
highFreq++;
else if (ch - 'a' == j)
lowFreq++;
if (lowFreq > 0)
res = max(res, highFreq - lowFreq);
else if (prevHadLowFreqChar)
res = max(res, highFreq - 1);
if (highFreq - lowFreq < 0) {
highFreq = 0;
lowFreq = 0;
prevHadLowFreqChar = true;
}
}
}
}
return res;
}
}; | var largestVariance = function(s) {
let chars = new Set(s.split("")), maxDiff = 0;
for (let l of chars) {
for (let r of chars) {
if (l === r) continue;
let lCount = 0, rCount = 0, hasRight = false;
for (let char of s) {
lCount += char === l ? 1 : 0;
rCount += char === r ? 1 : 0;
if (rCount > 0 && lCount > rCount) { // has both characters and positive difference
maxDiff = Math.max(maxDiff, lCount - rCount);
}
if (lCount > rCount && hasRight) { // has positive difference and a previous "right" character we can add to the start
maxDiff = Math.max(maxDiff, lCount - rCount - 1);
}
if (lCount < rCount) {
lCount = 0, rCount = 0;
hasRight = true;
}
}
}
}
return maxDiff;
}; | Substring With Largest Variance |
Given the coordinates of two rectilinear rectangles in a 2D plane, return the total area covered by the two rectangles.
The first rectangle is defined by its bottom-left corner (ax1, ay1) and its top-right corner (ax2, ay2).
The second rectangle is defined by its bottom-left corner (bx1, by1) and its top-right corner (bx2, by2).
Example 1:
Input: ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2
Output: 45
Example 2:
Input: ax1 = -2, ay1 = -2, ax2 = 2, ay2 = 2, bx1 = -2, by1 = -2, bx2 = 2, by2 = 2
Output: 16
Constraints:
-104 <= ax1 <= ax2 <= 104
-104 <= ay1 <= ay2 <= 104
-104 <= bx1 <= bx2 <= 104
-104 <= by1 <= by2 <= 104
| class Solution:
def computeArea(self, ax1: int, ay1: int, ax2: int, ay2: int, bx1: int, by1: int, bx2: int, by2: int) -> int:
def segment(ax1,ax2,bx1,bx2):
return min(ax2,bx2) - max(ax1, bx1) if max(ax1, bx1) < min(ax2, bx2) else 0
return (ax2-ax1)*(ay2-ay1) + (bx2-bx1)*(by2-by1) - segment(ax1,ax2,bx1,bx2)*segment(ay1,ay2,by1,by2) | class Solution {
public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
int x1 = Math.max(ax1,bx1);
int y1 = Math.max(ay1,by1);
int x2 = Math.min(ax2,bx2);
int y2 = Math.min(ay2,by2);
int area = 0;
int R1 = (ax2-ax1)*(ay2-ay1);
int R2 = (bx2-bx1)*(by2-by1);
area = R1 + R2;
if(x2 > x1 && y2 > y1){
int overlap = (x2-x1)*(y2-y1);
area = area - overlap;
}
return area;
}
} | class Solution {
public:
int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
int rec1=abs(ax2-ax1)*abs(ay2-ay1); //Area(Rectangle 1)
int rec2=abs(bx2-bx1)*abs(by2-by1); //Area(Rectangle 2)
//As explained above, if intervals overlap, max(x1,x3) < min(x2,x4) and overlapped interval
//is ( max(x1,x3) , min(x2,x4) ).
int ox1=(max(ax1,bx1)-min(ax2,bx2)); //if ox1 is negative, abs(ox1) is the length of overlapped rectangle, else rectangles do not overlap.
int oy1=(max(ay1,by1)-min(ay2,by2)); //breadth of overlapped rectangle
int rec3=0; //if rectangles do not overlap, area of overlapped rectangle is zero.
if(ox1<0&&oy1<0) //if both ox1 and oy2 are negative, two rectangles overlap.
rec3=ox1*oy1;
return rec1+rec2-rec3; //Area(Rectangle 1) + Area(Rectangle 2) - Area(Overlapped triangle)
}
}; | var computeArea = function(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {
let area1 = (ax2-ax1)*(ay2-ay1)
let area2 = (bx2-bx1)*(by2-by1)
let overlap = (by1>ay2 || by2<ay1 || bx1>ax2 || bx2<ax1) ? 0 : Math.abs((Math.min(ax2,bx2) - Math.max(ax1, bx1))*(Math.min(ay2,by2) - Math.max(ay1, by1)))
return area1 + area2 - overlap
}; | Rectangle Area |
You are given an integer finalSum. Split it into a sum of a maximum number of unique positive even integers.
For example, given finalSum = 12, the following splits are valid (unique positive even integers summing up to finalSum): (12), (2 + 10), (2 + 4 + 6), and (4 + 8). Among them, (2 + 4 + 6) contains the maximum number of integers. Note that finalSum cannot be split into (2 + 2 + 4 + 4) as all the numbers should be unique.
Return a list of integers that represent a valid split containing a maximum number of integers. If no valid split exists for finalSum, return an empty list. You may return the integers in any order.
Example 1:
Input: finalSum = 12
Output: [2,4,6]
Explanation: The following are valid splits: (12), (2 + 10), (2 + 4 + 6), and (4 + 8).
(2 + 4 + 6) has the maximum number of integers, which is 3. Thus, we return [2,4,6].
Note that [2,6,4], [6,2,4], etc. are also accepted.
Example 2:
Input: finalSum = 7
Output: []
Explanation: There are no valid splits for the given finalSum.
Thus, we return an empty array.
Example 3:
Input: finalSum = 28
Output: [6,8,2,12]
Explanation: The following are valid splits: (2 + 26), (6 + 8 + 2 + 12), and (4 + 24).
(6 + 8 + 2 + 12) has the maximum number of integers, which is 4. Thus, we return [6,8,2,12].
Note that [10,2,4,12], [6,2,4,16], etc. are also accepted.
Constraints:
1 <= finalSum <= 1010
| class Solution:
def maximumEvenSplit(self, finalSum: int) -> List[int]:
l=[]
if finalSum%2!=0:
return l
else:
s=0
i=2 # even pointer 2, 4, 6, 8, 10, 12...........
while(s<finalSum):
s+=i #sum
l.append(i) # append the i in list
i+=2
if s==finalSum: #if sum s is equal to finalSum then no modidfication required
return l
else:
l.pop(l.index(s-finalSum)) #Deleting the element which makes s greater than finalSum
return l | class Solution {
public List<Long> maximumEvenSplit(long finalSum) {
List<Long> res = new ArrayList<Long>();
//odd sum cannot be divided into even numbers
if(finalSum % 2 != 0) {
return res;
}
//Greedy approach, try to build the total sum using minimum unique even nos
long currNum = 2;
long remainingSum = finalSum;
//as long as we can add subtract this number from remaining sum
while(currNum <= remainingSum) {
res.add(currNum);
remainingSum -= currNum;//reducing remaining sum
currNum += 2;//next even number
}
//now, remaining sum cannot be fulfilled by any larger even number
//so extract the largest even number we added to the last index of res, and make it even larger by adding this current remaining sum
//add remaining sum to the last element
long last = res.remove(res.size()-1);
res.add(last+remainingSum);
return res;
}
} | class Solution {
public:
using ll = long long;
ll bs(ll low , ll high, ll fs){
ll ans = 1;
while(low<=high){
ll mid = low + (high-low)/2;
if(mid*(mid+1)>fs){
high = mid-1; // If sum till index equal to 'mid' > fs then make high = mid-1
}
else if(mid*(mid+1)==fs){
return mid; // If sum till index equal to 'mid == fs, return 'mid'
}
else{
ans = mid; // If sum till index equal to 'mid' < fs, update answer
low = mid+1; // check for better answer
}
}
return ans;
}
vector<long long> maximumEvenSplit(long long finalSum) {
// ****some base cases / corner cases****
if(finalSum&1) return {};
if(finalSum==4) return {4};
if(finalSum==8) return {2,6};
vector<ll> ans;
// assume that we are giving indices to even numbers
// EVEN NUMBERS -> 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 ..............
// THEIR INDICES-> 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ..............
// 'idx' is the index of that EVEN number uptil which the total sum of all even numbers <= finalSum
ll idx = bs(1,finalSum/2,finalSum);
//Consequently, 'end' is that EVEN number uptil which the total sum of all even numbers <= finalSum
ll start = 2, end = idx*2;
//Now, we add all the even numbers from index 1 to index 'idx-1'
// 2 + 4 + 6 + 8 ........................... + (end-2) + end
// 1 2 3 4 ........................... idx-1 idx
for(int i = start; i<= (idx-1)*2; i+=2){
ans.push_back(i);
}
// We do not add the last even number yet, so that we can modify it and add it later to make the (totalSumSoFar) == finalSum
// 'totalSumSoFar' can be easily calculated by using the formula ( totalSumSoFar = idx*(idx+1) )
// increasing the last even number 'end' by the difference of (finalSum and totalSumSoFar)
if(idx*(idx+1)<finalSum){
end = end + abs(finalSum - idx*(idx+1));
}
// adding the last even number after increasing it with the required factor
ans.push_back(end);
return ans;
}
}; | var maximumEvenSplit = function(finalSum) {
if(finalSum % 2) return [];
const set = new Set();
let n = 2, sum = 0;
while(sum < finalSum) {
sum += n;
set.add(n);
n += 2;
}
set.delete(sum - finalSum);
return [...set];
}; | Maximum Split of Positive Even Integers |
Given an array of integers nums, sort the array in ascending order.
Example 1:
Input: nums = [5,2,3,1]
Output: [1,2,3,5]
Example 2:
Input: nums = [5,1,1,2,0,0]
Output: [0,0,1,1,2,5]
Constraints:
1 <= nums.length <= 5 * 104
-5 * 104 <= nums[i] <= 5 * 104
| import heapq
class Solution:
def sortArray(self, nums: List[int]) -> List[int]:
h = {}
for i in nums:
if i in h:
h[i]+=1
else:
h[i]=1
heap = []
for i in h:
heap.append([i,h[i]])
heapq.heapify(heap)
ans = []
while heap:
x = heapq.heappop(heap)
ans.append(x[0])
if x[1]>1:
heapq.heappush(heap,[x[0],x[1]-1])
return ans | class Solution {
public void downHeapify(int[] nums, int startIndex, int lastIndex){
int parentIndex = startIndex;
int leftChildIndex = 2*parentIndex + 1;
int rightChildIndex = 2*parentIndex + 2;
while(leftChildIndex <= lastIndex){
int maxIndex = parentIndex;
if(nums[leftChildIndex] > nums[maxIndex]){
maxIndex = leftChildIndex;
}
if(rightChildIndex <= lastIndex && nums[rightChildIndex] > nums[maxIndex]){
maxIndex = rightChildIndex;
}
if(maxIndex == parentIndex){
return;
}
int temp = nums[maxIndex];
nums[maxIndex] = nums[parentIndex];
nums[parentIndex] = temp;
parentIndex = maxIndex;
leftChildIndex = 2*parentIndex + 1;
rightChildIndex = 2*parentIndex + 2;
}
return;
}
public int[] sortArray(int[] nums) {
int len = nums.length;
//building a heap - O(n) time
for(int i=(len/2)-1;i>=0;i--){
downHeapify(nums,i,len-1);
}
//sorting element - nlogn(n) time
for(int i=len -1 ;i>0;i--){
int temp = nums[i];
nums[i] = nums[0];
nums[0] = temp;
downHeapify(nums,0,i-1);
}
return nums;
}
} | class Solution {
public:
vector<int> sortArray(vector<int>& nums) {
priority_queue<int, vector<int>, greater<int>>pq;
for(auto it : nums)
{
pq.push(it);
}
vector<int>ans;
while(!pq.empty())
{
ans.push_back(pq.top());
pq.pop();
}
return ans;
}
}; | var sortArray = function(nums) {
return quickSort(nums, 0, nums.length - 1);
};
const quickSort = (arr, start, end) => {
// base case
if (start >= end) return arr;
// return pivot index to divide array into 2 sub-arrays.
const pivotIdx = partition(arr, start, end);
// sort sub-array to the left and right of pivot index.
quickSort(arr, start, pivotIdx - 1);
quickSort(arr, pivotIdx + 1, end);
return arr;
}
const partition = (arr, start, end) => {
// select a random pivot index, and swap pivot value with end value.
const pivotIdx = Math.floor(Math.random() * (end - start + 1)) + start;
[arr[pivotIdx], arr[end]] = [arr[end], arr[pivotIdx]];
const pivotVal = arr[end];
// loop from start to before end index (because pivot is stored at end index).
for (let i = start; i < end; i++) {
if (arr[i] < pivotVal) {
// swap smaller-than-pivot value (at i) with the value at the start index.
// This ensures all values to the left of start index will be less than pivot.
[arr[i], arr[start]] = [arr[start], arr[i]];
start++;
}
}
// swap pivot (which was stored at end index) with value at start index.
// This puts the pivot in its correct place.
[arr[start], arr[end]] = [arr[end], arr[start]];
return start;
}
/*
Note: Instead of always picking a fixed index as the pivot (ie. start or end index),
The pivot was randomly selected to mitigate the odds of achieving worst case TC and SC.
TC:
Best and avg case: O(nlogn)
worst case: O(n^2)
SC:
Since algo done in-place, space comes from recursive call stack.
best and avg case: O(logn)
worst case: O(n)
*/ | Sort an Array |
You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.
You can either start from the step with index 0, or the step with index 1.
Return the minimum cost to reach the top of the floor.
Example 1:
Input: cost = [10,15,20]
Output: 15
Explanation: You will start at index 1.
- Pay 15 and climb two steps to reach the top.
The total cost is 15.
Example 2:
Input: cost = [1,100,1,1,1,100,1,1,100,1]
Output: 6
Explanation: You will start at index 0.
- Pay 1 and climb two steps to reach index 2.
- Pay 1 and climb two steps to reach index 4.
- Pay 1 and climb two steps to reach index 6.
- Pay 1 and climb one step to reach index 7.
- Pay 1 and climb two steps to reach index 9.
- Pay 1 and climb one step to reach the top.
The total cost is 6.
Constraints:
2 <= cost.length <= 1000
0 <= cost[i] <= 999
| class Solution:
def minCostClimbingStairs(self, cost: List[int]) -> int:
n = len(cost)
dp = cost[:2] + [0]*(n-2)
for i in range(2, n):
dp[i] = min(dp[i-1], dp[i-2]) + cost[i]
return min(dp[-1], dp[-2]) | class Solution {
public int minCostClimbingStairs(int[] cost) {
int a[] = new int[cost.length+1];
a[0]=0;
a[1]=0;
for(int i=2;i<=cost.length;i++)
{
a[i]= Math.min(cost[i-1]+a[i-1], cost[i-2]+a[i-2]);
}
return a[cost.length];
}
} | class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
/* Minimize cost of steps, where you can take one or two steps.
At each step, store the minimum of the current step plus the step previous
or the step two previous. At the last step we can either take the last
element or leave it off.
*/
int n = cost.size();
for(int i = 2; i < n; i++) {
cost[i] = min(cost[i] + cost[i-2], cost[i] + cost[i-1]);
}
return min(cost[n-1], cost[n-2]);
}
}; | var minCostClimbingStairs = function(cost) {
//this array will be populated with the minimum cost of each step starting from the top
let minCostArray = [];
//append a 0 at end to represent reaching the 'top'
minCostArray[cost.length] = 0;
//append the last stair to the end of the array
minCostArray[cost.length - 1] = cost[cost.length - 1];
//starts at -2 the length since we already have two elements in our array
for (let i = cost.length - 2; i > -1; i--) {
//checks which minimum cost is lower and assigns the value at that index accordingly
if (minCostArray[i + 1] < minCostArray[i + 2]) minCostArray[i] = cost[i] + minCostArray[i + 1];
else minCostArray[i] = cost[i] + minCostArray[i + 2];
}
//checks which of the first two options is the lowest cost
return minCostArray[0] > minCostArray[1] ? minCostArray[1] : minCostArray[0];
}; | Min Cost Climbing Stairs |
Alice and Bob want to water n plants in their garden. The plants are arranged in a row and are labeled from 0 to n - 1 from left to right where the ith plant is located at x = i.
Each plant needs a specific amount of water. Alice and Bob have a watering can each, initially full. They water the plants in the following way:
Alice waters the plants in order from left to right, starting from the 0th plant. Bob waters the plants in order from right to left, starting from the (n - 1)th plant. They begin watering the plants simultaneously.
It takes the same amount of time to water each plant regardless of how much water it needs.
Alice/Bob must water the plant if they have enough in their can to fully water it. Otherwise, they first refill their can (instantaneously) then water the plant.
In case both Alice and Bob reach the same plant, the one with more water currently in his/her watering can should water this plant. If they have the same amount of water, then Alice should water this plant.
Given a 0-indexed integer array plants of n integers, where plants[i] is the amount of water the ith plant needs, and two integers capacityA and capacityB representing the capacities of Alice's and Bob's watering cans respectively, return the number of times they have to refill to water all the plants.
Example 1:
Input: plants = [2,2,3,3], capacityA = 5, capacityB = 5
Output: 1
Explanation:
- Initially, Alice and Bob have 5 units of water each in their watering cans.
- Alice waters plant 0, Bob waters plant 3.
- Alice and Bob now have 3 units and 2 units of water respectively.
- Alice has enough water for plant 1, so she waters it. Bob does not have enough water for plant 2, so he refills his can then waters it.
So, the total number of times they have to refill to water all the plants is 0 + 0 + 1 + 0 = 1.
Example 2:
Input: plants = [2,2,3,3], capacityA = 3, capacityB = 4
Output: 2
Explanation:
- Initially, Alice and Bob have 3 units and 4 units of water in their watering cans respectively.
- Alice waters plant 0, Bob waters plant 3.
- Alice and Bob now have 1 unit of water each, and need to water plants 1 and 2 respectively.
- Since neither of them have enough water for their current plants, they refill their cans and then water the plants.
So, the total number of times they have to refill to water all the plants is 0 + 1 + 1 + 0 = 2.
Example 3:
Input: plants = [5], capacityA = 10, capacityB = 8
Output: 0
Explanation:
- There is only one plant.
- Alice's watering can has 10 units of water, whereas Bob's can has 8 units. Since Alice has more water in her can, she waters this plant.
So, the total number of times they have to refill is 0.
Constraints:
n == plants.length
1 <= n <= 105
1 <= plants[i] <= 106
max(plants[i]) <= capacityA, capacityB <= 109
| class Solution:
def minimumRefill(self, plants: List[int], capacityA: int, capacityB: int) -> int:
Alice , Bob = capacityA, capacityB
res, i, j = 0, 0, len(plants)-1
while i < j:
if Alice >= plants[i]:
Alice -= plants[i]
else:
res += 1
Alice = capacityA - plants[i]
if Bob >= plants[j]:
Bob -= plants[j]
else:
res += 1
Bob = capacityB - plants[j]
i += 1
j -= 1
return res + 1 if i == j and Alice < plants[i] and Bob < plants[i] else res
| class Solution {
public int minimumRefill(int[] plants, int capacityA, int capacityB) {
int count=0;
int c1=capacityA,c2=capacityB;
for(int start=0,end=plants.length-1;start<=plants.length/2&&end>=plants.length/2;start++,end--){
if(start==end||start>end)break;
if(c1>=plants[start]){
c1-=plants[start];
}
else{
count++;
c1=capacityA;
c1-=plants[start];
}
if(c2>=plants[end]){
c2-=plants[end];
}
else{
count++;
c2=capacityB;
c2-=plants[end];
}
}
if((c1>c2||c1==c2)&&plants.length%2!=0){
if(plants[plants.length/2]>c1)count++;
}
else if(c1<c2&&plants.length%2!=0){
if(plants[plants.length/2]>c2)count++;
}
return count;
}
} | class Solution {
public:
int minimumRefill(vector<int>& plants, int capacityA, int capacityB) {
int n(plants.size()), res(0), aliceC(capacityA), bobC(capacityB), alice(0), bob(n-1);
while (alice < bob)
{
if (alice == bob)
{
if (aliceC < plants[alice] and bobC < plants[bob]) res++;
break;
}
if (aliceC < plants[alice]) aliceC = capacityA, res++;
if (bobC < plants[bob]) bobC = capacityB, res++;
aliceC -= plants[alice++];
bobC -= plants[bob--];
}
return res;
}
}; | var minimumRefill = function(plants, capacityA, capacityB) {
const n = plants.length;
let left = 0;
let right = n - 1;
let remA = capacityA;
let remB = capacityB;
let refills = 0;
while (left < right) {
const leftAmount = plants[left++];
const rightAmount = plants[right--];
if (leftAmount > remA) {
++refills;
remA = capacityA;
}
remA -= leftAmount;
if (rightAmount > remB) {
++refills;
remB = capacityB;
}
remB -= rightAmount;
}
if (left === right) {
const midAmount = plants[left];
if (remB > remA) {
if (remB < midAmount) ++refills;
}
else {
if (remA < midAmount) ++refills;
}
}
return refills;
}; | Watering Plants II |
Given an array of digits digits, return the largest multiple of three that can be formed by concatenating some of the given digits in any order. If there is no answer return an empty string.
Since the answer may not fit in an integer data type, return the answer as a string. Note that the returning answer must not contain unnecessary leading zeros.
Example 1:
Input: digits = [8,1,9]
Output: "981"
Example 2:
Input: digits = [8,6,7,1,0]
Output: "8760"
Example 3:
Input: digits = [1]
Output: ""
Constraints:
1 <= digits.length <= 104
0 <= digits[i] <= 9
| class Solution:
def largestMultipleOfThree(self, digits: List[int]) -> str:
A = digits
A.sort()
A.reverse()
@cache
def DP(i, r): # max number whose remainder is r using subarray [0:i] (inclusive)
if i == 0:
if A[0] % 3 == r:
return A[0]
else:
return 0
Ra = DP(i-1, r)
Rb = [ x for j in range(3) \
for x in ( DP(i-1,j) * 10 + A[i] ,)
if x % 3 == r ]
return max([Ra, *Rb])
ans = DP(len(A) - 1, 0)
if ans == 0 and 0 not in A:
return ""
else:
return str(ans) | class Solution {
public String largestMultipleOfThree(int[] digits) {
int n=digits.length;
Arrays.sort(digits);
if(digits[digits.length-1]==0){
return "0";
}
int sum=0;
for(int i=0;i<digits.length;i++){
sum+=digits[i];
}
if(sum%3==0){
StringBuilder sb=new StringBuilder("");
for(int i=n-1;i>=0;i--){
sb.append(digits[i]);
}
return sb.toString();
}else if(sum%3==1){
int modOne=-1;
for(int i=0;i<n;i++){
if(digits[i]%3==1){
modOne=i;
break;
}
}
if(modOne==-1){
int []idx=new int[2];
Arrays.fill(idx,-1);
for(int i=0;i<n;i++){
if(digits[i]%3==2){
if(idx[0]==-1){
idx[0]=i;
}else{
idx[1]=i;
break;
}
}
}
if(idx[1]==-1){
return "";
}else{
digits[idx[0]]=-1;
digits[idx[1]]=-1;
}
}else{
digits[modOne]=-1;
}
}else{
int modTwo=-1;
for(int i=0;i<n;i++){
if(digits[i]%3==2){
modTwo=i;
break;
}
}
if(modTwo==-1){
int []idx=new int[2];
Arrays.fill(idx,-1);
for(int i=0;i<n;i++){
if(digits[i]%3==1){
if(idx[0]==-1){
idx[0]=i;
}else{
idx[1]=i;
break;
}
}
}
if(idx[1]==-1){
return "";
}else{
digits[idx[0]]=-1;
digits[idx[1]]=-1;
}
}else{
digits[modTwo]=-1;
}
}
StringBuilder sb=new StringBuilder("");
for(int i=n-1;i>=0;i--){
if(digits[i]!=-1){
sb.append(digits[i]);
}
}
if(sb.length()>0 && sb.toString().charAt(0)=='0'){
return "0";
}
return sb.toString();
}
} | class Solution {
public:
vector<int> ans;
void calculate(vector<int>& count,int no,vector<int>& temp){
if(no==0){
int flag=0,sum1=0,sum2=0,validSum=0;
for(int j=1;j<10;j++){
sum1+=temp[j];
sum2+=ans[j];
validSum+=(temp[j]*j);
}
if(validSum%3!=0){
return ;
}
if(sum2>sum1)
return;
else if(sum1>sum2){
for(int i=1;i<10;i++){
ans[i]=temp[i];
}
return ;
}
int j=9;
while(j>0){
if(ans[j]<temp[j])
{
flag=1;
break;
}else if(ans[j]>temp[j])
break;
j--;
}
if (flag==1){
for(int i=1;i<10;i++){
ans[i]=temp[i];
}
}
return ;
}
int targetCount=count[no]-2;
if(targetCount<0)
targetCount=0;
int co=count[no];
do{
temp[no]=co;
calculate(count,no-1,temp);
co--;
}
while(co>=targetCount);
}
string largestMultipleOfThree(vector<int>& digits) {
vector<int> count(10,0);
int n=digits.size();
for(int i=0;i<n;i++){
count[digits[i]]++;
}
vector<int> temp(10,0);
ans.resize(10,0);
calculate(count,9,temp);
string res="";
ans[0]=count[0];
for(int i=9;i>=0;i--){
for(int j=1;j<=ans[i];j++){
res+=('0'+i);
}
}
if(res.size()>=2 && res[0]=='0' && res[1]=='0')
return "0";
return res;
}
}; | /**
* @param {number[]} digits
* @return {string}
*/
var largestMultipleOfThree = function(digits) {
// highest digit first
digits.sort((l, r) => r - l);
// what is the remainder of the total sum?
const sumRemainder = digits.reduce((a, c) => a + c, 0) % 3;
if (sumRemainder) {
let targetIndex = 0, i = digits.length - 1;
// try to find what is the smallest number that can be removed
for (; i >= 0; i--) {
if ((digits[i] - sumRemainder) % 3 === 0) {
targetIndex = i;
break;
}
}
if (i < 0) {
// iterated the whole loop, couldn't find a single number to remove
// remove everything but multiples of 3
digits = digits.filter(v => v % 3 === 0);
} else {
digits.splice(targetIndex, 1);
}
}
return (digits[0] === 0) ? '0' : digits.join('');
}; | Largest Multiple of Three |
Given an array of integers nums and an integer limit, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is less than or equal to limit.
Example 1:
Input: nums = [8,2,4,7], limit = 4
Output: 2
Explanation: All subarrays are:
[8] with maximum absolute diff |8-8| = 0 <= 4.
[8,2] with maximum absolute diff |8-2| = 6 > 4.
[8,2,4] with maximum absolute diff |8-2| = 6 > 4.
[8,2,4,7] with maximum absolute diff |8-2| = 6 > 4.
[2] with maximum absolute diff |2-2| = 0 <= 4.
[2,4] with maximum absolute diff |2-4| = 2 <= 4.
[2,4,7] with maximum absolute diff |2-7| = 5 > 4.
[4] with maximum absolute diff |4-4| = 0 <= 4.
[4,7] with maximum absolute diff |4-7| = 3 <= 4.
[7] with maximum absolute diff |7-7| = 0 <= 4.
Therefore, the size of the longest subarray is 2.
Example 2:
Input: nums = [10,1,2,4,7,2], limit = 5
Output: 4
Explanation: The subarray [2,4,7,2] is the longest since the maximum absolute diff is |2-7| = 5 <= 5.
Example 3:
Input: nums = [4,2,2,2,4,4,2,2], limit = 0
Output: 3
Constraints:
1 <= nums.length <= 105
1 <= nums[i] <= 109
0 <= limit <= 109
| # max absolte diff within a subarray is subarray max substracted by subarray min
class Solution:
def longestSubarray(self, nums: List[int], limit: int) -> int:
q = collections.deque() # monotonic decreasing deque to compute subarray max, index of
q2 = collections.deque() # monotonic increasing deque to compute subarray min, index of
# sliding window
res = left = 0
for right in range(len(nums)):
# pop monotocity-violating numbers from right end
while q and nums[q[-1]] <= nums[right]:
q.pop()
q.append(right)
# pop monotocity-violating numbers from right end
while q2 and nums[q2[-1]] >= nums[right]:
q2.pop()
q2.append(right)
# sliding window
while left < right and q and q2 and nums[q[0]] - nums[q2[0]] > limit:
# compress window from left pointer
if q and q[0] == left:
q.popleft()
# compress left pointer
if q2 and q2[0] == left:
q2.popleft()
left += 1
if nums[q[0]] - nums[q2[0]] <= limit:
res = max(res, right - left + 1)
return res | class Solution {
public int longestSubarray(int[] nums, int limit) {
Deque<Integer> increasing = new LinkedList<Integer>(); // To keep track of Max_value index
Deque<Integer> decreasing = new LinkedList<Integer>(); // To keep track of Min_value index
int i = 0 ;
int j = 0 ;
int max_length = 0 ;
while(j < nums.length){
while(!increasing.isEmpty() && nums[increasing.peekLast()] >= nums[j]){
increasing.pollLast() ;
}
increasing.add(j);
while(!decreasing.isEmpty() && nums[decreasing.peekLast()] <= nums[j]){
decreasing.pollLast() ;
}
decreasing.add(j);
int max_val = nums[decreasing.peekFirst()] ;
int min_val = nums[increasing.peekFirst()] ;
if(max_val-min_val <= limit){
max_length = Math.max(max_length , j-i+1);
}else{
// If maximum absolute diff > limit , then remove from dequeue and increase i
while(i<=j && nums[decreasing.peekFirst()] - nums[increasing.peekFirst()] > limit ){
if(!increasing.isEmpty() && increasing.peekFirst() == i){
increasing.pollFirst() ;
}
if(!decreasing.isEmpty() && decreasing.peekFirst() == i){
decreasing.pollFirst() ;
}
i++ ;
}
}
j++ ;
}
return max_length ;
}
} | class Solution {
public:
int longestSubarray(vector<int>& nums, int limit) {
int max_ans = 0;
map <int, int> mp;
int j = 0;
for(int i = 0 ; i < nums.size() ; i++) {
mp[nums[i]] ++;
while( mp.size() > 0 && abs(mp.rbegin()->first - mp.begin()->first) > limit)
{
if(mp[nums[j]] > 0) {
mp[nums[j]] --;
}
if(mp[nums[j]] == 0) {
mp.erase(nums[j]);
}
j++;
}
max_ans = max(max_ans, i - j + 1);
}
return max_ans;
}
}; | /**
* @param {number[]} nums
* @param {number} limit
* @return {number}
*/
var longestSubarray = function(nums, limit) {
const maxQueue = [];
const minQueue = [];
let start = 0;
let res = 0;
for(let end = 0; end < nums.length; end ++) {
const num = nums[end];
while(maxQueue.length > 0 && maxQueue[maxQueue.length - 1] < num) {
maxQueue.pop();
}
while(minQueue.length > 0 && minQueue[minQueue.length - 1] > num) {
minQueue.pop();
}
maxQueue.push(num);
minQueue.push(num);
if(maxQueue[0] - minQueue[0] > limit) {
if(maxQueue[0] === nums[start]) {
maxQueue.shift();
}
if(minQueue[0] === nums[start]) {
minQueue.shift();
}
start +=1;
}
res = Math.max(res, end - start + 1);
}
return res;
}; | Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit |
Return the result of evaluating a given boolean expression, represented as a string.
An expression can either be:
"t", evaluating to True;
"f", evaluating to False;
"!(expr)", evaluating to the logical NOT of the inner expression expr;
"&(expr1,expr2,...)", evaluating to the logical AND of 2 or more inner expressions expr1, expr2, ...;
"|(expr1,expr2,...)", evaluating to the logical OR of 2 or more inner expressions expr1, expr2, ...
Example 1:
Input: expression = "!(f)"
Output: true
Example 2:
Input: expression = "|(f,t)"
Output: true
Example 3:
Input: expression = "&(t,f)"
Output: false
Constraints:
1 <= expression.length <= 2 * 104
expression[i] consists of characters in {'(', ')', '&', '|', '!', 't', 'f', ','}.
expression is a valid expression representing a boolean, as given in the description.
| class Solution:
def parseBoolExpr(self, expression: str) -> bool:
# expresssion map
opMap = {"!" : "!", "|" : "|" , "&" : "&"}
expMap = {"t" : True, "f" : False}
expStack = []
opStack = []
ans = 0
i = 0
while i < len(expression):
if expression[i] in opMap:
opStack.append(opMap[expression[i]])
elif expression[i] in expMap:
expStack.append(expMap[expression[i]])
elif expression[i] == "(":
expStack.append("(")
# strat performing operations
elif expression[i] == ")":
op = opStack.pop()
ans = [] # evaluator arr
# To Check
# print("EXPSTACK :- ", expStack, "OPSTACK :- ", opStack, "outer WHILE")
# Performing serries of operation on exp inside a ()
while expStack[-1] != "(":
# To check
# print("EXPSTACK :- ", expStack, "OPSTACK :- ", opStack, "OPerator :- ",op, "INNER WHILE")
# Not single operation only
if op == "!":
ans.append(not expStack.pop())
else:
ans.append(expStack.pop())
# Operation evaluation for more then 1 exp inside () for &, or
while len(ans) > 1:
# or
if op == "|":
exp1, exp2 = ans.pop(), ans.pop()
res = exp1 or exp2
ans.append(res)
# and
elif op == "&":
exp1, exp2 = ans.pop(), ans.pop()
res = exp1 and exp2
ans.append(res)
# poping ")" and adding the res of operation done above
expStack.pop() # poping ")"
expStack.append(ans[-1])
# increment i
i += 1
return expStack[-1]
"""
TC : O(n * m) | n = len(expression), m = no of expression inside a prenthesis
Sc : O(n)
""" | class Solution {
int pos = 0;
public boolean parseBoolExpr(String s) {
pos = 0;
return solve(s, '-');
}
public boolean solve(String s, char prev_sign) {
boolean res = s.charAt(pos) == 'f' ? false : true;
char cur_sign = ' ';
int flag_res_init = 0;
while(pos < s.length()) {
char cur_char = s.charAt(pos++);
if(isExpr(cur_char)){
res = eval(cur_char == 't'?true:false, res , prev_sign);
}
else if(isSign(cur_char)){
cur_sign = cur_char;
}
else if(cur_char == '('){
if(flag_res_init == 1 || prev_sign == '!')
res = eval(solve(s, cur_sign), res, prev_sign);
else {
res = solve(s, cur_sign);
flag_res_init = 1;
}
}
else if(cur_char == ')'){
return res;
}
}
return res;
}
public boolean isExpr(char c){
return (c == 'f' || c == 't');
}
public boolean isSign(char c){
return (c == '!' || c == '&' || c == '|');
}
public boolean eval(boolean e1, boolean e2, char sign) {
boolean res = false;
if(sign == '!')
res = !e1;
else if(sign == '|')
res = e1 | e2;
else if(sign == '&')
res = e1&e2;
return res;
}
} | class Solution {
pair<bool,int> dfs(string &e, int idx){
bool res;
if(e[idx]=='!'){
auto [a,b]=dfs(e, idx+2);
return {!a,b+3};
}else if(e[idx]=='&'){
int len=2;
res=true;
idx+=2;
while(e[idx]!=')'){
if(e[idx]==','){
idx++;len++;
}
auto [a,b]=dfs(e,idx);
res&=a;
idx+=b;
len+=b;
}
return {res,len+1};
}else if(e[idx]=='|'){
int len=2;
res=false;
idx+=2;
while(e[idx]!=')'){
if(e[idx]==','){
idx++;len++;
}
auto [a,b]=dfs(e,idx);
res|=a;
idx+=b;
len+=b;
}
return {res,len+1};
}else{
return {e[idx]=='t',1};
}
}
public:
bool parseBoolExpr(string expression) {
return dfs(expression, 0).first;
}
}; | var parseBoolExpr = function(expression) {
let sol, stack = [],
op={t:true, f:false};
for(let i=0; i<expression.length; i++){
if(expression[i] != ")"){
if(expression[i]!==",")stack.push(expression[i]);
}else{
let findings = [], ko;;
while(stack.slice(-1)[0] !== "("){
findings.push(stack.pop());
}
stack.pop();
let operator = stack.pop();
if(operator == '|'){
ko=findings.reduce((a,b)=>(op[a]||op[b]) === true?'t':'f');
}
if(operator == '&'){
ko=findings.reduce((a,b)=>(op[a]&&op[b]) === true?'t':'f');
}
if(operator == '!'){
ko=findings.pop()==='f'?'t':'f';
}
stack.push(ko);
}
}
return stack.pop()=='f'?false:true;
}; | Parsing A Boolean Expression |
Design a stack which supports the following operations.
Implement the CustomStack class:
CustomStack(int maxSize) Initializes the object with maxSize which is the maximum number of elements in the stack or do nothing if the stack reached the maxSize.
void push(int x) Adds x to the top of the stack if the stack hasn't reached the maxSize.
int pop() Pops and returns the top of stack or -1 if the stack is empty.
void inc(int k, int val) Increments the bottom k elements of the stack by val. If there are less than k elements in the stack, just increment all the elements in the stack.
Example 1:
Input
["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"]
[[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
Output
[null,null,null,2,null,null,null,null,null,103,202,201,-1]
Explanation
CustomStack customStack = new CustomStack(3); // Stack is Empty []
customStack.push(1); // stack becomes [1]
customStack.push(2); // stack becomes [1, 2]
customStack.pop(); // return 2 --> Return top of the stack 2, stack becomes [1]
customStack.push(2); // stack becomes [1, 2]
customStack.push(3); // stack becomes [1, 2, 3]
customStack.push(4); // stack still [1, 2, 3], Don't add another elements as size is 4
customStack.increment(5, 100); // stack becomes [101, 102, 103]
customStack.increment(2, 100); // stack becomes [201, 202, 103]
customStack.pop(); // return 103 --> Return top of the stack 103, stack becomes [201, 202]
customStack.pop(); // return 202 --> Return top of the stack 102, stack becomes [201]
customStack.pop(); // return 201 --> Return top of the stack 101, stack becomes []
customStack.pop(); // return -1 --> Stack is empty return -1.
Constraints:
1 <= maxSize <= 1000
1 <= x <= 1000
1 <= k <= 1000
0 <= val <= 100
At most 1000 calls will be made to each method of increment, push and pop each separately.
| class CustomStack:
def __init__(self, maxSize: int):
self.size = maxSize
self.stack = []
def push(self, x: int) -> None:
if self.size > len(self.stack):
self.stack.append(x)
def pop(self) -> int:
if self.stack:
return self.stack.pop()
return -1
def increment(self, k: int, val: int) -> None:
len_stack = len(self.stack)
if len_stack < k:
self.stack[:] = [i + val for i in self.stack]
return
for i in range(k):
self.stack[i] += val | class CustomStack {
int[] stack;
int top;
public CustomStack(int maxSize) {
//intialise the stack and the top
stack= new int[maxSize];
top=-1;
}
public void push(int x) {
// if the stack is full just skip
if( top==stack.length-1) return;
//add to the stack
top++;
stack[top]=x;
}
public int pop() {
//if stack is empty return -1
if( top==-1) return -1;
//remove/pop the top element
top--;
return stack[top+1];
}
public void increment(int k, int val) {
//got to increment the min of the elements present in the stack and k
int n= Math.min(top+1,k);
for( int i=0; i<n ; i++){
stack[i]+=val;
}
}
} | class CustomStack {
int *data;
int nextIndex;
int capacity;
public:
CustomStack(int maxSize) {
data = new int[maxSize];
nextIndex = 0;
capacity = maxSize;
}
void push(int x) {
if(nextIndex == capacity){
return;
}
data[nextIndex] = x;
nextIndex++;
}
int pop() {
if(nextIndex == 0){
return -1;
}
int temp = data[nextIndex-1];
nextIndex--;
return temp;
}
void increment(int k, int val) {
//loop will run upto nextIndex if k >= nextIndex else runt upto k only
int n = (k >= nextIndex) ? nextIndex : k;
for(int i = 0; i < n; i++){
data[i] = data[i] + val;
}
}
}; | var CustomStack = function(maxSize) {
this.stack = new Array(maxSize).fill(-1);
this.maxSize = maxSize;
this.size = 0;
};
CustomStack.prototype.push = function(x) {
if(this.size < this.maxSize){
this.stack[this.size] = x;
this.size++;
}
};
CustomStack.prototype.pop = function() {
if(this.size > 0){
this.size--;
return this.stack[this.size];
}
return -1;
};
CustomStack.prototype.increment = function(k, val) {
let count = k >= this.size ? this.size-1 : k-1;
while(count >= 0){
this.stack[count] += val;
count--;
}
}; | Design a Stack With Increment Operation |
We had some 2-dimensional coordinates, like "(1, 3)" or "(2, 0.5)". Then, we removed all commas, decimal points, and spaces and ended up with the string s.
For example, "(1, 3)" becomes s = "(13)" and "(2, 0.5)" becomes s = "(205)".
Return a list of strings representing all possibilities for what our original coordinates could have been.
Our original representation never had extraneous zeroes, so we never started with numbers like "00", "0.0", "0.00", "1.0", "001", "00.01", or any other number that can be represented with fewer digits. Also, a decimal point within a number never occurs without at least one digit occurring before it, so we never started with numbers like ".1".
The final answer list can be returned in any order. All coordinates in the final answer have exactly one space between them (occurring after the comma.)
Example 1:
Input: s = "(123)"
Output: ["(1, 2.3)","(1, 23)","(1.2, 3)","(12, 3)"]
Example 2:
Input: s = "(0123)"
Output: ["(0, 1.23)","(0, 12.3)","(0, 123)","(0.1, 2.3)","(0.1, 23)","(0.12, 3)"]
Explanation: 0.0, 00, 0001 or 00.01 are not allowed.
Example 3:
Input: s = "(00011)"
Output: ["(0, 0.011)","(0.001, 1)"]
Constraints:
4 <= s.length <= 12
s[0] == '(' and s[s.length - 1] == ')'.
The rest of s are digits.
| class Solution(object):
def ambiguousCoordinates(self, s):
"""
:type s: str
:rtype: List[str]
"""
def _isValidSplit(s):
return False if len(s)>1 and re.match('/^[0]+$/',s) else True
def _isValidNum(ipart,fpart):
return False if (len(ipart)>1 and ipart[0]=='0') or (fpart and fpart[-1]=='0') else True
def _splitToNums(s):
rets=[]
if len(s)==1:return [s]
for i in range(1,len(s)+1):
a,b=s[:i],s[i:]
if _isValidNum(a,b):rets.append("%s.%s"%(a,b) if b else "%s"%(a))
return rets
ans,s=[],s[1:-1]
for i in range(1,len(s)):
a,b=s[:i],s[i:]
if not _isValidSplit(a) or not _isValidSplit(b):continue
for c1,c2 in itertools.product(_splitToNums(a),_splitToNums(b)):ans.append("(%s, %s)"%(c1,c2))
return ans | class Solution {
public List<String> ret;
public List<String> ans;
public List<String> ambiguousCoordinates(String s) {
ret=new ArrayList<>();
ans=new ArrayList<>();
String start=s.substring(0,2);
util(s,1);
fun();
return ans;
}
//putting comma
void util(String s,int idx) {
if(idx==s.length()-2) {
return;
}
String ns=s.substring(0,idx+1)+", "+s.substring(idx+1);
ret.add(ns);
util(s,idx+1);
}
//helper function for puting decimals after comma
void fun() {
for(String s:ret) {
int cIndex=0;
for(int i=0;i<s.length();i++) {
if(s.charAt(i)==',') {
cIndex=i;
break;
}
}
String a=s.substring(1,cIndex);
String b=s.substring(cIndex+2,s.length()-1);
List<String> n1=dot(a);
List<String> n2=dot(b);
if(n1==null || n2==null) { //invalid strings
continue;
}else { //valid strings
for(String fir:n1) {
for(String sec:n2) {
ans.add("("+fir+", "+sec+")");
}
}
}
}
}
//putting decimal point
List<String> dot(String n) {
List<String> li=new ArrayList<>();
if(n.length()==1) {
li.add(n);
}else {
//just checking for first and last zeroes and making conditions accordingly
if(n.charAt(n.length()-1)=='0') {
if(n.charAt(0)=='0') {
return null;
}else {
li.add(n);
}
}else if(n.charAt(0)=='0') {
li.add("0."+n.substring(1));
}else {
for(int i=0;i<n.length()-1;i++) {
li.add(n.substring(0,i+1)+"."+n.substring(i+1));
}
li.add(n); //without any decimal
}
}
return li;
}
} | class Solution {
public:
vector<string> check(string s){
int n = s.size();
vector<string> res;
if(s[0] == '0'){
if(n == 1)
res.push_back(s);
else{
if(s[n-1] == '0')
return res;
s.insert(1, ".");
res.push_back(s);
}
}
else{
if(s[n-1] == '0'){
res.push_back(s);
return res;
}
for(int i=1; i<n; i++){
string t = s.substr(0, i) + "." + s.substr(i, n-i);
res.push_back(t);
}
res.push_back(s);
}
return res;
}
vector<string> ambiguousCoordinates(string s) {
int n = s.size();
vector<string> res;
for(int i=2; i<n-1; i++){
vector<string> left = check(s.substr(1, i-1));
vector<string> right = check(s.substr(i, n-i-1));
for(int j=0; j<left.size(); j++){
for(int k=0; k<right.size(); k++){
string t = "(" + left[j] + ", " + right[k] + ")";
res.push_back(t);
}
}
}
return res;
}
}; | var ambiguousCoordinates = function(S) {
let ans = [], xPoss
const process = (str, xy) => {
if (xy)
for (let x of xPoss)
ans.push(`(${x}, ${str})`)
else xPoss.push(str)
}
const parse = (str, xy) => {
if (str.length === 1 || str[0] !== "0")
process(str, xy)
if (str.length > 1 && str[str.length-1] !== "0")
process(str.slice(0,1) + "." + str.slice(1), xy)
if (str.length > 2 && str[0] !== "0" && str[str.length-1] !== "0")
for (let i = 2; i < str.length; i++)
process(str.slice(0,i) + "." + str.slice(i), xy)
}
for (let i = 2; i < S.length - 1; i++) {
let strs = [S.slice(1,i), S.slice(i, S.length - 1)]
xPoss = []
for (let j = 0; j < 2; j++)
if (xPoss.length || !j) parse(strs[j], j)
}
return ans
}; | Ambiguous Coordinates |
You are given a string s and an integer array indices of the same length. The string s will be shuffled such that the character at the ith position moves to indices[i] in the shuffled string.
Return the shuffled string.
Example 1:
Input: s = "codeleet", indices = [4,5,6,7,0,2,1,3]
Output: "leetcode"
Explanation: As shown, "codeleet" becomes "leetcode" after shuffling.
Example 2:
Input: s = "abc", indices = [0,1,2]
Output: "abc"
Explanation: After shuffling, each character remains in its position.
Constraints:
s.length == indices.length == n
1 <= n <= 100
s consists of only lowercase English letters.
0 <= indices[i] < n
All values of indices are unique.
| class Solution:
def restoreString(self, s: str, indices: List[int]) -> str:
dec = {}
c = 0
res=''
for i in indices:
dec[i] = s[c]
c += 1
# dec = {"4":"c","5":"o","6":"d","7":"e","0":"l","2":"e","1":"e","3":"t"}
for x in range(len(indices)):
res += dec[x]
# x in range 0, 1, 2,....... len *indices or s*
return res | class Solution {
public String restoreString(String s, int[] indices) {
char[] ch = new char[s.length()];
for(int i = 0 ; i< s.length() ; i ++){
ch[indices[i]]=s.charAt(i);
}
return new String (ch);
}
} | class Solution {
public:
string restoreString(string s, vector<int>& indices) {
string ans = s;
for(int i=0 ; i<s.size() ; i++){
ans[indices[i]] = s[i];
}
return ans;
}
}; | var restoreString = function(s, indices) {
const result = []
for(let i=0; i<s.length; i++) {
const letter = s[i]
const index = indices[i]
result[index] = letter
}
return result.join('')
}; | Shuffle String |
You are given an integer array target and an integer n.
You have an empty stack with the two following operations:
"Push": pushes an integer to the top of the stack.
"Pop": removes the integer on the top of the stack.
You also have a stream of the integers in the range [1, n].
Use the two stack operations to make the numbers in the stack (from the bottom to the top) equal to target. You should follow the following rules:
If the stream of the integers is not empty, pick the next integer from the stream and push it to the top of the stack.
If the stack is not empty, pop the integer at the top of the stack.
If, at any moment, the elements in the stack (from the bottom to the top) are equal to target, do not read new integers from the stream and do not do more operations on the stack.
Return the stack operations needed to build target following the mentioned rules. If there are multiple valid answers, return any of them.
Example 1:
Input: target = [1,3], n = 3
Output: ["Push","Push","Pop","Push"]
Explanation: Initially the stack s is empty. The last element is the top of the stack.
Read 1 from the stream and push it to the stack. s = [1].
Read 2 from the stream and push it to the stack. s = [1,2].
Pop the integer on the top of the stack. s = [1].
Read 3 from the stream and push it to the stack. s = [1,3].
Example 2:
Input: target = [1,2,3], n = 3
Output: ["Push","Push","Push"]
Explanation: Initially the stack s is empty. The last element is the top of the stack.
Read 1 from the stream and push it to the stack. s = [1].
Read 2 from the stream and push it to the stack. s = [1,2].
Read 3 from the stream and push it to the stack. s = [1,2,3].
Example 3:
Input: target = [1,2], n = 4
Output: ["Push","Push"]
Explanation: Initially the stack s is empty. The last element is the top of the stack.
Read 1 from the stream and push it to the stack. s = [1].
Read 2 from the stream and push it to the stack. s = [1,2].
Since the stack (from the bottom to the top) is equal to target, we stop the stack operations.
The answers that read integer 3 from the stream are not accepted.
Constraints:
1 <= target.length <= 100
1 <= n <= 100
1 <= target[i] <= n
target is strictly increasing.
| class Solution:
def buildArray(self, target: List[int], n: int) -> List[str]:
temp = []
result = []
x = target[-1]
for i in range(1,x+1):
temp.append(i)
for i in range(len(temp)):
if temp[i] in target:
result.append("Push")
elif temp[i] not in target:
result.append("Push")
result.append("Pop")
return result | class Solution {
public List<String> buildArray(int[] target, int n) {
List<String> result=new ArrayList<>();
int i=1,j=0;
while(j<target.length)
{
result.add("Push");
if(i==target[j]){
j++;
}else{
result.add("Pop");
}
i++;
}
return result;
}
} | class Solution {
public:
vector<string> buildArray(vector<int>& target, int n) {
vector<string>ans;
int l=target.size(), count=0,ind=0; // ind is index of the target array
for(int i=1;i<=n;i++){
if(count==l) break;
if(target[ind]!=i){
ans.push_back("Push");
ans.push_back("Pop");
}
else{
ans.push_back("Push");
count++;
ind++;
}
}
return ans;
}
}; | /**
* @param {number[]} target
* @param {number} n
* @return {string[]}
*/
var buildArray = function(target, n) {
let arr = [];
let index = 0;
for(let i = 1; i <= target[target.length-1];i++){
if(target[index] == i){
arr.push('Push');
index++;
}else{
arr.push('Push');
arr.push('Pop');
}
}
return arr;
}; | Build an Array With Stack Operations |
Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.
Basically, the deletion can be divided into two stages:
Search for a node to remove.
If the node is found, delete the node.
Example 1:
Input: root = [5,3,6,2,4,null,7], key = 3
Output: [5,4,6,2,null,null,7]
Explanation: Given key to delete is 3. So we find the node with value 3 and delete it.
One valid answer is [5,4,6,2,null,null,7], shown in the above BST.
Please notice that another valid answer is [5,2,6,null,4,null,7] and it's also accepted.
Example 2:
Input: root = [5,3,6,2,4,null,7], key = 0
Output: [5,3,6,2,4,null,7]
Explanation: The tree does not contain a node with value = 0.
Example 3:
Input: root = [], key = 0
Output: []
Constraints:
The number of nodes in the tree is in the range [0, 104].
-105 <= Node.val <= 105
Each node has a unique value.
root is a valid binary search tree.
-105 <= key <= 105
Follow up: Could you solve it with time complexity O(height of tree)?
| # Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
def find_inorder(root, key):
if root is None :
return []
return find_inorder(root.left, key) + [root.val] + find_inorder(root.right, key)
def find_preorder(root, key):
if root is None:
return []
return [root.val] + find_preorder(root.left,key) + find_preorder(root.right, key)
preorder = find_preorder(root, key)
try:
preorder.remove(key)
except:
return root
inorder = find_inorder(root, key)
inorder.remove(key)
hashmap = {}
for i in range(len(inorder)):
key = inorder[i]
hashmap[key] = i
def buildTree(left, right):
if left > right:
return
val = inorder[left]
root = TreeNode(val)
index = hashmap[val]
root.left = buildTree(left, index-1)
root.right = buildTree(index+1, right)
return root
N = len(inorder)
new_tree = buildTree(0,N-1)
return new_tree | class Solution {
public TreeNode deleteNode(TreeNode root, int key) {
if(root==null) return null;
if(key<root.val){
root.left = deleteNode(root.left,key);
return root;
}
else if(key>root.val){
root.right = deleteNode(root.right,key);
return root;
}
else{
if(root.left==null){
return root.right;
}
else if(root.right==null){
return root.left;
}
else{
TreeNode min = root.right;
while(min.left!=null){
min = min.left;
}
root.val = min.val;
root.right = deleteNode(root.right,min.val);
return root;
}
}
}
} | class Solution {
public:
TreeNode* deleteNode(TreeNode* root, int key) {
if(root)
if(key < root->val) root->left = deleteNode(root->left, key); //We frecursively call the function until we find the target node
else if(key > root->val) root->right = deleteNode(root->right, key);
else{
if(!root->left && !root->right) return NULL; //No child condition
if (!root->left || !root->right)
return root->left ? root->left : root->right; //One child contion -> replace the node with it's child
//Two child condition
TreeNode* temp = root->left; //(or) TreeNode *temp = root->right;
while(temp->right != NULL) temp = temp->right; // while(temp->left != NULL) temp = temp->left;
root->val = temp->val; // root->val = temp->val;
root->left = deleteNode(root->left, temp->val); // root->right = deleteNode(root->right, temp);
}
return root;
}
}; | /**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
const getLeftMostNode=(root)=>{
if(!root)return null;
let node=getLeftMostNode(root.left);
return node?node:root;
}
/**
* @param {TreeNode} root
* @param {number} key
* @return {TreeNode}
*/
var deleteNode = function(root, key) {
if(!root)return null;
if(root.val>key){
root.left=deleteNode(root.left,key);
}else if(root.val<key){
root.right= deleteNode(root.right,key);
}else{
if(!root.left)return root.right;
if(!root.right)return root.left;
let succ_node=getLeftMostNode(root.right);
root.val=succ_node.val;
root.right= deleteNode(root.right,succ_node.val);
}
return root;
}; | Delete Node in a BST |
You are given an integer array score of size n, where score[i] is the score of the ith athlete in a competition. All the scores are guaranteed to be unique.
The athletes are placed based on their scores, where the 1st place athlete has the highest score, the 2nd place athlete has the 2nd highest score, and so on. The placement of each athlete determines their rank:
The 1st place athlete's rank is "Gold Medal".
The 2nd place athlete's rank is "Silver Medal".
The 3rd place athlete's rank is "Bronze Medal".
For the 4th place to the nth place athlete, their rank is their placement number (i.e., the xth place athlete's rank is "x").
Return an array answer of size n where answer[i] is the rank of the ith athlete.
Example 1:
Input: score = [5,4,3,2,1]
Output: ["Gold Medal","Silver Medal","Bronze Medal","4","5"]
Explanation: The placements are [1st, 2nd, 3rd, 4th, 5th].
Example 2:
Input: score = [10,3,8,9,4]
Output: ["Gold Medal","5","Bronze Medal","Silver Medal","4"]
Explanation: The placements are [1st, 5th, 3rd, 2nd, 4th].
Constraints:
n == score.length
1 <= n <= 104
0 <= score[i] <= 106
All the values in score are unique.
| class Solution:
def findRelativeRanks(self, score: List[int]) -> List[str]:
scores_ids = []
for i in range(len(score)):
scores_ids.append((score[i], i))
scores_ids.sort(reverse=True)
ans = [0] * len(scores_ids)
for i in range(len(scores_ids)):
ans[scores_ids[i][1]] = str(i+1)
try:
ans[scores_ids[0][1]] = "Gold Medal"
ans[scores_ids[1][1]] = "Silver Medal"
ans[scores_ids[2][1]] = "Bronze Medal"
except:
pass
return ans | class Solution {
public String[] findRelativeRanks(int[] score) {
String[] res = new String[score.length];
TreeMap<Integer, Integer> map = new TreeMap<>();
for(int i = 0; i < score.length; i++) map.put(score[i], i);
int rank = score.length;
for(Map.Entry<Integer, Integer> p: map.entrySet()){
if(rank == 1) res[p.getValue()] = "Gold Medal";
else if(rank == 2) res[p.getValue()] = "Silver Medal";
else if(rank == 3) res[p.getValue()] = "Bronze Medal";
else res[p.getValue()] = String.valueOf(rank);
rank--;
}
return res;
}
} | class Solution {
public:
vector<string> findRelativeRanks(vector<int>& score) {
int n=score.size();
vector<string> vs(n);
unordered_map<int,int> mp;
for(int i=0; i<score.size(); i++){
mp[score[i]]=i;
}
sort(score.begin(),score.end(),greater<int>());
for(int i=0; i<score.size(); i++){
int temp=mp[score[i]];
if(i==0){
vs[temp]="Gold Medal";
continue;
}
if(i==1){
vs[temp]="Silver Medal";
continue;
}
if(i==2){
vs[temp]="Bronze Medal";
continue;
}
int t=i+1;
string st= to_string(t);
vs[temp]=st;
}
return vs;
}
}; | var findRelativeRanks = function(score) {
let output=score.slice(0);
let map={};
score.sort((a,b)=>b-a).forEach((v,i)=>map[v]=i+1);
for(let item in map){
if(map[item]==1){map[item]="Gold Medal"};
if(map[item]==2){map[item]="Silver Medal"};
if(map[item]==3){map[item]="Bronze Medal"};
}
return output.map(v=>map[v]+""); // +"": num=>str.
}; | Relative Ranks |
You are given an integer array prices representing the daily price history of a stock, where prices[i] is the stock price on the ith day.
A smooth descent period of a stock consists of one or more contiguous days such that the price on each day is lower than the price on the preceding day by exactly 1. The first day of the period is exempted from this rule.
Return the number of smooth descent periods.
Example 1:
Input: prices = [3,2,1,4]
Output: 7
Explanation: There are 7 smooth descent periods:
[3], [2], [1], [4], [3,2], [2,1], and [3,2,1]
Note that a period with one day is a smooth descent period by the definition.
Example 2:
Input: prices = [8,6,7,7]
Output: 4
Explanation: There are 4 smooth descent periods: [8], [6], [7], and [7]
Note that [8,6] is not a smooth descent period as 8 - 6 ≠ 1.
Example 3:
Input: prices = [1]
Output: 1
Explanation: There is 1 smooth descent period: [1]
Constraints:
1 <= prices.length <= 105
1 <= prices[i] <= 105
| import sys
class Solution:
def getDescentPeriods(self, prices: List[int]) -> int:
def calculate(k,ans):
if k>1:
ans+=((k-1)*(k))//2
#Sum of Natural Numbers
return ans
else:
return ans
end = 0
start = 0
prev= sys.maxsize
k= 0
ans = 0
while end<len(prices):
if prev- prices[end]==1 or prev == sys.maxsize:
k+=1
prev = prices[end]
end+=1
else:
ans = calculate(k,ans)
start = end
if end<len(prices):
prev = sys.maxsize
k=0
if k>1:
ans = calculate(k,ans)
return ans+len(prices) | class Solution {
public long getDescentPeriods(int[] prices) {
int i=0;
int j=1;
long ans=1;
while(j<prices.length){
if( prices[j-1]-prices[j]==1){
//It means that j(current element) can be part of previous subarrays (j-i)
//and can also start a subarray from me (+1). So add (j-i+1) in total Subarrays
int count=j-i+1;
ans+=count;
}else{
//It means that j cannot be part of previous subarrays but can start subarray from me. So, ans+=1
i=j;
ans+=1;
}
j++;
}
return ans;
}
} | class Solution {
public:
long long getDescentPeriods(vector<int>& prices) {
long long ans = 0;
long long temp = 0;
for(int i=1; i<prices.size(); i++){
if(prices[i - 1] - prices[i] == 1){
temp++;
ans += temp;
}
else{
temp = 0;
}
}
ans += prices.size();
return ans;
}
}; | var getDescentPeriods = function(prices) {
const n = prices.length;
let left = 0;
let totRes = 0;
while (left < n) {
let count = 1;
let right = left + 1;
while (right < n && prices[right] + 1 === prices[right - 1]) {
count += (right - left + 1);
++right;
}
totRes += count;
left = right;
}
return totRes;
}; | Number of Smooth Descent Periods of a Stock |
You are given an undirected graph (the "original graph") with n nodes labeled from 0 to n - 1. You decide to subdivide each edge in the graph into a chain of nodes, with the number of new nodes varying between each edge.
The graph is given as a 2D array of edges where edges[i] = [ui, vi, cnti] indicates that there is an edge between nodes ui and vi in the original graph, and cnti is the total number of new nodes that you will subdivide the edge into. Note that cnti == 0 means you will not subdivide the edge.
To subdivide the edge [ui, vi], replace it with (cnti + 1) new edges and cnti new nodes. The new nodes are x1, x2, ..., xcnti, and the new edges are [ui, x1], [x1, x2], [x2, x3], ..., [xcnti-1, xcnti], [xcnti, vi].
In this new graph, you want to know how many nodes are reachable from the node 0, where a node is reachable if the distance is maxMoves or less.
Given the original graph and maxMoves, return the number of nodes that are reachable from node 0 in the new graph.
Example 1:
Input: edges = [[0,1,10],[0,2,1],[1,2,2]], maxMoves = 6, n = 3
Output: 13
Explanation: The edge subdivisions are shown in the image above.
The nodes that are reachable are highlighted in yellow.
Example 2:
Input: edges = [[0,1,4],[1,2,6],[0,2,8],[1,3,1]], maxMoves = 10, n = 4
Output: 23
Example 3:
Input: edges = [[1,2,4],[1,4,5],[1,3,1],[2,3,4],[3,4,5]], maxMoves = 17, n = 5
Output: 1
Explanation: Node 0 is disconnected from the rest of the graph, so only node 0 is reachable.
Constraints:
0 <= edges.length <= min(n * (n - 1) / 2, 104)
edges[i].length == 3
0 <= ui < vi < n
There are no multiple edges in the graph.
0 <= cnti <= 104
0 <= maxMoves <= 109
1 <= n <= 3000
| class Solution:
def reachableNodes(self, edges: List[List[int]], maxMoves: int, n: int) -> int:
m = defaultdict(list)
for a, b, p in edges:
m[a].append((p, b))
m[b].append((p, a))
vis = set()
queue = []
heappush(queue, (0, 0))
edgevis = set()
edgeofl = defaultdict(lambda: 0)
ans = 0
while queue:
# print(queue)
cost, cur = heappop(queue)
vis.add(cur)
for p, nxt in m[cur]:
if p < maxMoves - cost:
if (cur, nxt) not in edgevis and (nxt, cur) not in edgevis:
ans += p
# if nxt in vis:
# ans -= 1
edgevis.add((cur, nxt))
edgevis.add((nxt, cur))
if nxt not in vis:
heappush(queue, (cost + p + 1, nxt))
else:
bal = maxMoves - cost
if (cur, nxt) in edgevis:
continue
if bal <= edgeofl[(cur, nxt)]:
continue
if bal + edgeofl[(nxt, cur)] < p:
ans += bal - edgeofl[(cur, nxt)]
edgeofl[(cur, nxt)] = bal
else:
ans += p - edgeofl[(nxt, cur)] - edgeofl[(cur, nxt)]
edgevis.add((cur, nxt))
edgevis.add((nxt, cur))
return ans + len(vis) | class Solution {
public int reachableNodes(int[][] edges, int maxMoves, int n) {
int[][] graph = new int[n][n];
for ( int[] t: graph ) {
Arrays.fill(t, -1);
}
for ( int[] t: edges ) {
graph[t[0]][t[1]] = t[2];
graph[t[1]][t[0]] = t[2];
}
PriorityQueue<int[]> heap = new PriorityQueue<>( (a, b) -> b[1]-a[1] );
int ans = 0;
boolean[] vis = new boolean[n];
heap.offer(new int[]{0, maxMoves});
while ( !heap.isEmpty() ) {
int[] info = heap.poll();
int nearestNodeId = info[0];
int maxMovesRemaining = info[1];
if ( vis[nearestNodeId] ) {
continue;
}
// visiting the current node
vis[nearestNodeId] = true;
// since we visited this node we increment our counter
ans++;
for ( int i=0; i<n; i++ ) {
// checking if we do have an edge
if ( graph[nearestNodeId][i]!=-1 ) {
if ( !vis[i] && maxMovesRemaining>=graph[nearestNodeId][i]+1 ) {
heap.offer( new int[] {i, maxMovesRemaining-graph[nearestNodeId][i]-1} );
}
int movesTaken = Math.min(maxMovesRemaining, graph[nearestNodeId][i]);
graph[nearestNodeId][i] -= movesTaken;
graph[i][nearestNodeId] -= movesTaken;
ans += movesTaken;
}
}
}
return ans;
}
} | class Solution {
public:
int reachableNodes(vector<vector<int>>& edges, int maxMoves, int n) {
const int INF = 1e8;
vector<vector<pair<int,int>> g(n);
for(auto i: edges){
g[i[0]].push_back({i[1],i[2]});
g[i[1]].push_back({i[0],i[2]});
}
priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>> > pq;
pq.push({0, 0}); //distance,node
vector<int> d(n, INF);
d[0] = 0;
while(!pq.empty()){
int dist = pq.top().first;
int node = pq.top().second;
pq.pop();
//if(d[u.second]!=u.first) continue;
for(auto it:g[node]){
if(d[it.first]>dist+it.second+1) //since number of edges=nodes in between+1
{
d[it.first]=dist+it.second+1;
pq.push({d[it.first], it.first});
}
}
}
//now we have minimum distances to reach each node, so check how many reachable with minMoves
int ans = 0;
for(int i = 0; i < n; ++i) { // add 1 for nodes that can be visited
if(d[i] <= maxMoves)
ans++;
}
/*
Now add for intermediate newly added nodes
Eg. 0->1 and 10 in between
Visitable from 0 -> maxMoves-(dist/moves already covered by 0 (from source))
Visitable from 1 -> maxMoves-(dist/moves already covered by 1 (from source))
To calculate Extra nodes I can visit we follow above
*/
for(auto i : edges) {
int src=i[0],dest=i[1], between=i[2];
int x = max(0, (maxMoves - d[src])); // nodes visited using edge e[0]->e[1]
int y = max(0, (maxMoves - d[dest])); // nodes visited using edge e[1]->e[0]
ans += min(between, x + y); //minimum to avoid overlapping in counting
}
return ans; | var reachableNodes = function(edges, maxMoves, n) {
const g = Array.from({length: n}, () => []);
for(let [u, v, cnt] of edges) {
g[u].push([v, cnt + 1]);
g[v].push([u, cnt + 1]);
}
// find min budget to reach from 0 to all nodes
const budget = new Array(n).fill(Infinity);
budget[0] = 0;
const dijkstra = () => {
// heap will be collection [node, weight]
const heap = new MinPriorityQueue({ priority: (x) => x[1] });
heap.enqueue([0, 0]);
while(heap.size()) {
const [n, c] = heap.dequeue().element;
for(let [nextNode, cost] of g[n]) {
let temp = c + cost;
if(budget[nextNode] > temp) {
budget[nextNode] = temp;
heap.enqueue([nextNode, temp]);
}
}
}
};
dijkstra();
// add to sum all reachable nodes from 0 with max move
let vis = 0;
for(let w of budget) vis += w <= maxMoves;
// add intermediate nodes between edges with available budget
for(let [a, b, c] of edges) {
let [availableFromA, availableFromB] = [maxMoves - budget[a], maxMoves - budget[b]];
if(availableFromA < 0 || availableFromB < 0) {
vis += Math.max(availableFromA, 0) + Math.max(availableFromB, 0);
} else {
const total = availableFromA + availableFromB;
vis += total - Math.max(total - c, 0);
}
}
return vis;
}; | Reachable Nodes In Subdivided Graph |
You are given a 0-indexed array of positive integers w where w[i] describes the weight of the ith index.
You need to implement the function pickIndex(), which randomly picks an index in the range [0, w.length - 1] (inclusive) and returns it. The probability of picking an index i is w[i] / sum(w).
For example, if w = [1, 3], the probability of picking index 0 is 1 / (1 + 3) = 0.25 (i.e., 25%), and the probability of picking index 1 is 3 / (1 + 3) = 0.75 (i.e., 75%).
Example 1:
Input
["Solution","pickIndex"]
[[[1]],[]]
Output
[null,0]
Explanation
Solution solution = new Solution([1]);
solution.pickIndex(); // return 0. The only option is to return 0 since there is only one element in w.
Example 2:
Input
["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
[[[1,3]],[],[],[],[],[]]
Output
[null,1,1,1,1,0]
Explanation
Solution solution = new Solution([1, 3]);
solution.pickIndex(); // return 1. It is returning the second element (index = 1) that has a probability of 3/4.
solution.pickIndex(); // return 1
solution.pickIndex(); // return 1
solution.pickIndex(); // return 1
solution.pickIndex(); // return 0. It is returning the first element (index = 0) that has a probability of 1/4.
Since this is a randomization problem, multiple answers are allowed.
All of the following outputs can be considered correct:
[null,1,1,1,1,0]
[null,1,1,1,1,1]
[null,1,1,1,0,0]
[null,1,1,1,0,1]
[null,1,0,1,0,0]
......
and so on.
Constraints:
1 <= w.length <= 104
1 <= w[i] <= 105
pickIndex will be called at most 104 times.
| class Solution(object):
def __init__(self, w):
"""
:type w: List[int]
"""
#Cumulative sum
self.list = [0] * len(w)
s = 0
for i, n in enumerate(w):
s += n
self.list[i] = s
def pickIndex(self):
"""
:rtype: int
"""
return bisect_left(self.list, random.randint(1, self.list[-1]))
# Your Solution object will be instantiated and called as such:
# obj = Solution(w)
# param_1 = obj.pickIndex() | class Solution {
private int[] prefixSum;
private Random random;
public Solution(int[] w) {
for (int i = 1; i < w.length; i++)
w[i] += w[i - 1];
prefixSum = w;
random = new Random();
}
public int pickIndex() {
int num = 1 + random.nextInt(prefixSum[prefixSum.length - 1]); // Generate random number between 1 and total sum of weights
int left = 0;
int right = prefixSum.length - 1;
while (left < right) {
int mid = (left + right) / 2;
if (num == prefixSum[mid])
return mid;
else if (num < prefixSum[mid])
right = mid;
else
left = mid + 1;
}
return left;
}
} | class Solution {
public:
vector<int> cumW;
Solution(vector<int>& w) {
// initialising random seeder
srand(time(NULL));
// populating the cumulative weights vector
cumW.resize(w.size());
cumW[0] = w[0];
for (int i = 1; i < w.size(); i++) cumW[i] = cumW[i - 1] + w[i];
}
int pickIndex() {
return upper_bound(begin(cumW), end(cumW), rand() % cumW.back()) - begin(cumW);
}
}; | class Solution {
constructor(nums) {
this.map = new Map();
this.sum = 0;
nums.forEach((num, i) => {
this.sum += num;
this.map.set(this.sum, i);
})
}
pickIndex = function() {
const random_sum = Math.floor(Math.random() * this.sum);
return this.fetchIndexUsingBS(random_sum);
}
fetchIndexUsingBS = function(target) {
const sums = Array.from(this.map.keys());
let lo = 0,
hi = sums.length - 1,
mid;
while(lo <= hi) {
mid = Math.floor((hi - lo)/2) + lo;
// if((mid === 0 || sums[mid - 1] < target) && sums[mid] >= target) {
// return this.map.get(sums[mid]);
// }
if(sums[mid] > target) {
hi = mid - 1;
} else {
lo = mid + 1;
}
}
return lo;
}
} | Random Pick with Weight |
Given two integers n and k, construct a list answer that contains n different positive integers ranging from 1 to n and obeys the following requirement:
Suppose this list is answer = [a1, a2, a3, ... , an], then the list [|a1 - a2|, |a2 - a3|, |a3 - a4|, ... , |an-1 - an|] has exactly k distinct integers.
Return the list answer. If there multiple valid answers, return any of them.
Example 1:
Input: n = 3, k = 1
Output: [1,2,3]
Explanation: The [1,2,3] has three different positive integers ranging from 1 to 3, and the [1,1] has exactly 1 distinct integer: 1
Example 2:
Input: n = 3, k = 2
Output: [1,3,2]
Explanation: The [1,3,2] has three different positive integers ranging from 1 to 3, and the [2,1] has exactly 2 distinct integers: 1 and 2.
Constraints:
1 <= k < n <= 104
| class Solution:
def constructArray(self, n: int, k: int) -> List[int]:
# n = 8, k = 5
# 1 2 3 8 4 7 5 6
# 1 1 5 4 3 2 1
res = list(range(1,n-k+1))
sign, val = 1, k
for i in range(k):
res.append(res[-1]+sign*val)
sign *= -1
val -= 1
return res | class Solution {
public int[] constructArray(int n, int k) {
int [] result = new int[n];
result[0] = 1;
int sign = 1;
for(int i = 1 ; i < n; i++, k--){
if(k > 0){
result[i] = result[i-1] + k * sign;
sign *= -1;
}
else{
result[i] = i+1;
}
}
return result;
}
} | class Solution {
public:
vector<int> constructArray(int n, int k) {
int diff = n - k;
int lo = 1;
int hi = n;
vector<int> out;
int i = 0;
// we generate a difference of 1 between subsequent elements for the first n-k times.
while(i < diff){
out.push_back(lo);
lo++;
i++;
}
bool flag = true;
//Now we go zig zag to generate k unique differences, the last one will be automatically taken care
//as the difference between last two elements will be one which we have already generated above.
for(int i = out.size() ; i < n ; i++){
//flag to alternatively zig zag
if(flag){
out.push_back(hi);
hi--;
flag = false;
}
else{
out.push_back(lo);
lo++;
flag = true;
}
}
return out;
}
}; | var constructArray = function(n, k) {
const result = [];
let left = 1;
let right = n;
for (let index = 0; index < n; index++) {
if (k === 1) {
result.push(left++);
continue;
}
const num = k & 1 ? left++ : right--;
result.push(num);
k -= 1;
}
return result;
}; | Beautiful Arrangement II |
Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.
You must write an algorithm that runs in O(n) time.
Example 1:
Input: nums = [100,4,200,1,3,2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
Example 2:
Input: nums = [0,3,7,2,5,8,4,6,0,1]
Output: 9
Constraints:
0 <= nums.length <= 105
-109 <= nums[i] <= 109
| class Solution(object):
def longestConsecutive(self, nums):
ans=0
nums=set(nums)
count=0
for i in nums:
if i-1 not in nums:
j=i
count=0
while j in nums:
count+=1
j+=1
ans=max(ans,count)
return ans | class Solution {
public int longestConsecutive(int[] nums) {
Set<Integer> storage = new HashSet();
for(int i = 0; i < nums.length; i++){
storage.add(nums[i]);
}
int maxL = 0;
for(int i = 0; i < nums.length; i++){
//check if nums[i] id present in set or not
//since after checking in set we remove the element from
//set, there is no double calculation for same sequence
if(storage.contains(nums[i])){
storage.remove(nums[i]);
int dec = nums[i]-1;
int inc = nums[i]+1;
int tempL = 1;
//check both ways from nums[i] and calculate
//tempL. since we are removing elements from
//set we only calculate once for every sequence.
while(storage.contains(dec)){
storage.remove(dec);
dec--;
tempL++;
}
while(storage.contains(inc)){
storage.remove(inc);
inc++;
tempL++;
}
maxL = Math.max(maxL, tempL);
}
}
return maxL;
}
} | class Solution {
public:
int longestConsecutive(vector<int>& nums) {
set<int> hashSet;
int longestConsecutiveSequence = 0;
for(auto it : nums){
hashSet.insert(it);
}
for(auto it : nums){
if(!hashSet.count(it-1)){
int count = 1;
while(hashSet.count(it+count)) ++count;
longestConsecutiveSequence = max(count,longestConsecutiveSequence);
}
}
return longestConsecutiveSequence;
}
}; | /**
* @param {number[]} nums
* @return {number}
*/
var longestConsecutive = function(nums) {
if(nums.length === 1){
return 1
}
if(nums.length === 0){
return 0
}
nums.sort((a, b) => a - b)
let result = 1
let streak = 1
let i = 0
while(i < nums.length - 1){
if(nums[i] == nums[i + 1]) {
i++
continue
}
if(nums[i] == nums[i + 1] - 1){
streak++
if(streak > result){
result = streak
}
} else {
streak = 1
}
i++
}
return result
}; | Longest Consecutive Sequence |
You are given a string number representing a positive integer and a character digit.
Return the resulting string after removing exactly one occurrence of digit from number such that the value of the resulting string in decimal form is maximized. The test cases are generated such that digit occurs at least once in number.
Example 1:
Input: number = "123", digit = "3"
Output: "12"
Explanation: There is only one '3' in "123". After removing '3', the result is "12".
Example 2:
Input: number = "1231", digit = "1"
Output: "231"
Explanation: We can remove the first '1' to get "231" or remove the second '1' to get "123".
Since 231 > 123, we return "231".
Example 3:
Input: number = "551", digit = "5"
Output: "51"
Explanation: We can remove either the first or second '5' from "551".
Both result in the string "51".
Constraints:
2 <= number.length <= 100
number consists of digits from '1' to '9'.
digit is a digit from '1' to '9'.
digit occurs at least once in number.
| class Solution:
def removeDigit(self, number: str, digit: str) -> str:
# Initializing the last index as zero
last_index = 0
#iterating each number to find the occurences, \
# and to find if the number is greater than the next element \
for num in range(1, len(number)):
# Handling [case 1] and [case 2]
if number[num-1] == digit:
if int(number[num]) > int(number[num-1]):
return number[:num-1] + number[num:]
else:
last_index = num - 1
# If digit is the last number (last occurence) in the string [case 3]
if number[-1] == digit:
last_index = len(number) - 1
return number[:last_index] + number[last_index + 1:] | class Solution {
public String removeDigit(String number, char digit) {
List<String> digits = new ArrayList<>();
for (int i = 0; i < number.length(); i++) {
if (number.charAt(i) == digit) {
String stringWithoutDigit = number.substring(0, i) + number.substring(i + 1);
digits.add(stringWithoutDigit);
}
}
Collections.sort(digits);
return digits.get(digits.size() - 1);
}
} | class Solution {
public:
string removeDigit(string number, char digit) {
string res = "";
for(int i=0; i<number.size(); i++){
if(number[i] == digit){
string temp = number.substr(0, i) + number.substr(i+1);
res = max(res, temp);
}
}
return res;
}
}; | /**
* @param {string} number
* @param {character} digit
* @return {string}
*/
var removeDigit = function(number, digit) {
let str = [];
let flag = 0;
for (let i = 0; i < number.length; i++) {
if (number[i] == digit ) {
let temp = number.substring(0, i) + number.substring(i+1);
str.push(temp);
}
}
str.sort();
return str[str.length-1];
}; | Remove Digit From Number to Maximize Result |
Given a string s, reverse the string according to the following rules:
All the characters that are not English letters remain in the same position.
All the English letters (lowercase or uppercase) should be reversed.
Return s after reversing it.
Example 1:
Input: s = "ab-cd"
Output: "dc-ba"
Example 2:
Input: s = "a-bC-dEf-ghIj"
Output: "j-Ih-gfE-dCba"
Example 3:
Input: s = "Test1ng-Leet=code-Q!"
Output: "Qedo1ct-eeLg=ntse-T!"
Constraints:
1 <= s.length <= 100
s consists of characters with ASCII values in the range [33, 122].
s does not contain '\"' or '\\'.
| class Solution:
def reverseOnlyLetters(self, s: str) -> str:
st,sp=[],[]
for i,ch in enumerate(s):
if ch.isalpha():
st.append(ch)
else:
sp.append([i,ch])
st=st[::-1]
for i in sp:
st.insert(i[0],i[1])
return (''.join(st)) | class Solution {
public String reverseOnlyLetters(String s) {
// converting the string to the charArray...
char[] ch = s.toCharArray();
int start = 0;
int end = s.length()-1;
// Storing all the english alphabets in a hashmap so that the searching becomes easy...
HashMap<Character , Integer> hash = new HashMap<>();
for(int i=0 ; i<26 ;i++){
hash.put((char)(97+i) , 1);
}
for(int i=0 ; i<26 ; i++){
hash.put((char)(65+i) , 1);
}
// using two while loops ..since the constraints are too less thats why we can prefer nested loops approach..
while(start<end){
// interating untill start pointer reacher a good character
while(start<end&&!hash.containsKey(ch[start])){
start++;
}
// iterating untill the end pointer reaches the good character..
while(end>start&&!hash.containsKey(ch[end])){
end--;
}
// swapping the array elements..
char temp = ch[start];
ch[start] = ch[end];
ch[end] = temp;
start++;
end--;
}
// converting the charArray to the string again..
String ans = new String(ch);
return ans;
// Time Complexity : O(N) (since the loops will run only till the number of charcters in the string..)
// Space Complexity : O(N) since we used hashmap..
}
} | class Solution {
public:
string reverseOnlyLetters(string s) {
int a=0,b=s.size()-1;
for(;a<b;)
{
if(((s[a]>='a'&&s[a]<='z')||(s[a]>='A'&&s[a]<='Z'))&&((s[b]>='a'&&s[b]<='z')||(s[b]>='A'&&s[b]<='Z')))
{
char z=s[a];
s[a]=s[b];
s[b]=z;
a++;
b--;
}
else if(!((s[a]>='a'&&s[a]<='z')||(s[a]>='A'&&s[a]<='Z'))&&((s[b]>='a'&&s[b]<='z')||(s[b]>='A'&&s[b]<='Z')))
{
a++;
}
else if(((s[a]>='a'&&s[a]<='z')||(s[a]>='A'&&s[a]<='Z'))&&!((s[b]>='a'&&s[b]<='z')||(s[b]>='A'&&s[b]<='Z')))
b--;
else{
a++;
b--;
}
}
return s;
}
}; | var reverseOnlyLetters = function(s) {
let valid = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
let arr = s.split('')
let r = arr.length - 1;
let l = 0;
while (l < r) {
while (!valid.includes(arr[l]) && l < r) {
l++;
continue;
}
while (!valid.includes(arr[r]) && l < r) {
r--;
continue
}
if (l >= r) break;
[arr[l], arr[r]] = [arr[r], arr[l]];
l++;
r--;
}
return arr.join('')
``` | Reverse Only Letters |
You are given a 0-indexed integer array nums. For each index i (1 <= i <= nums.length - 2) the beauty of nums[i] equals:
2, if nums[j] < nums[i] < nums[k], for all 0 <= j < i and for all i < k <= nums.length - 1.
1, if nums[i - 1] < nums[i] < nums[i + 1], and the previous condition is not satisfied.
0, if none of the previous conditions holds.
Return the sum of beauty of all nums[i] where 1 <= i <= nums.length - 2.
Example 1:
Input: nums = [1,2,3]
Output: 2
Explanation: For each index i in the range 1 <= i <= 1:
- The beauty of nums[1] equals 2.
Example 2:
Input: nums = [2,4,6,4]
Output: 1
Explanation: For each index i in the range 1 <= i <= 2:
- The beauty of nums[1] equals 1.
- The beauty of nums[2] equals 0.
Example 3:
Input: nums = [3,2,1]
Output: 0
Explanation: For each index i in the range 1 <= i <= 1:
- The beauty of nums[1] equals 0.
Constraints:
3 <= nums.length <= 105
1 <= nums[i] <= 105
| class Solution:
def sumOfBeauties(self, nums: List[int]) -> int:
n = len(nums)
max_dp = [0] * n
min_dp = [float(inf)] * n
max_dp[0] = nums[0]
min_dp[-1] = nums[-1]
for i in range(1, n):
max_dp[i] = max(nums[i], max_dp[i-1])
for i in range(n-2, -1, -1):
min_dp[i] = min(nums[i], min_dp[i+1])
ans = 0
for i in range(1, n-1):
if max_dp[i-1] < max_dp[i] and nums[i] < min_dp[i+1]:
ans += 2
elif nums[i-1] < nums[i] < nums[i+1]:
ans += 1
return ans | class Solution {
public int sumOfBeauties(int[] nums) {
boolean[] left = new boolean[nums.length];
boolean[] right = new boolean[nums.length];
left[0] = true;
int leftMax = nums[0];
for(int i = 1; i < nums.length; i++) {
if(nums[i] > leftMax) {
left[i] = true;
leftMax = nums[i];
}
}
right[nums.length-1] = true;
int rightMin = nums[nums.length-1];
for(int i = nums.length-2; i >= 0; i--) {
if(nums[i] < rightMin) {
right[i] = true;
rightMin = nums[i];
}
}
int beautyCount = 0;
for(int i = 1; i < nums.length-1; i++) {
if(left[i] && right[i]) {
beautyCount += 2;
}
else if(nums[i-1] < nums[i] && nums[i] < nums[i+1]) {
beautyCount += 1;
}
}
return beautyCount;
}
} | class Solution {
public:
int sumOfBeauties(vector<int>& nums) {
int n=nums.size();
vector<int>right;
vector<int>left;
int low=nums[0];
for(int i=0;i<nums.size();i++){
left.push_back(low);
low=max(low,nums[i]);
}
low=nums[n-1];
for(int i=n-1;i>=0;i--){
right.push_back(low);
low=min(low,nums[i]);
}
reverse(right.begin(),right.end());
int ans=0;
for(int i=1;i<n-1;i++){
if(nums[i]>left[i] && nums[i]<right[i]){
ans+=2;
}
else if(nums[i]>nums[i-1] && nums[i]<nums[i+1]){
ans+=1;
}
else{
ans+=0;
}
}
return ans;
}
}; | /**
* @param {number[]} nums
* @return {number}
*/
var sumOfBeauties = function(nums) {
let min = nums[0], max = Infinity, maxArr = [], total = 0;
// Creating an array, which will keep the record of minimum values from last index
for(let i=nums.length-1; i>1; i--) {
if(nums[i] < max) max = nums[i];
maxArr.push(max);
}
// iterating through array to check the given conditions
for(let i=1; i<nums.length-1; i++) {
// Keeping a record of max value from all index < i
if(nums[i-1] > min) min = nums[i-1];
// Checking conditions
if(nums[i] < maxArr.pop() && min < nums[i]) total += 2;
else if(nums[i-1] < nums[i] && nums[i] < nums[i+1]) total += 1;
}
return total;
}; | Sum of Beauty in the Array |
You are given two jugs with capacities jug1Capacity and jug2Capacity liters. There is an infinite amount of water supply available. Determine whether it is possible to measure exactly targetCapacity liters using these two jugs.
If targetCapacity liters of water are measurable, you must have targetCapacity liters of water contained within one or both buckets by the end.
Operations allowed:
Fill any of the jugs with water.
Empty any of the jugs.
Pour water from one jug into another till the other jug is completely full, or the first jug itself is empty.
Example 1:
Input: jug1Capacity = 3, jug2Capacity = 5, targetCapacity = 4
Output: true
Explanation: The famous Die Hard example
Example 2:
Input: jug1Capacity = 2, jug2Capacity = 6, targetCapacity = 5
Output: false
Example 3:
Input: jug1Capacity = 1, jug2Capacity = 2, targetCapacity = 3
Output: true
Constraints:
1 <= jug1Capacity, jug2Capacity, targetCapacity <= 106
| class Solution:
def canMeasureWater(self, jug1Capacity: int, jug2Capacity: int, targetCapacity: int) -> bool:
n1, n2, t = jug1Capacity, jug2Capacity, targetCapacity
if n1 == t or n2 == t or n1 + n2 == t:
return True
if n1 + n2 < t:
return False
if n1 < n2:
n1, n2 = n2, n1
stack = []
visited = set()
d = n1 - n2
if d == t:
return True
while d > n2:
d -= n2
if d == t:
return True
stack.append(d)
while stack:
#print(stack)
d = stack.pop()
visited.add(d)
n = n1 + d
if n == t:
return True
n = n1 - d
if n == t:
return True
while n > n2:
n -= n2
if n == t:
return True
if n < n2 and n not in visited:
stack.append(n)
n = n2 - d
if n == t:
return True
if n not in visited:
stack.append(n)
return False | class Solution {
private static int gcd(int a,int b){
if(b==0)return a;
return gcd(b,a%b);
}
public boolean canMeasureWater(int jug1Capacity, int jug2Capacity, int targetCapacity) {
if(targetCapacity>jug1Capacity+jug2Capacity){
return false;
}
int g=gcd(jug1Capacity,jug2Capacity);
return (targetCapacity%g==0);
}
} | class Solution {
public:
bool canMeasureWater(int jug1Capacity, int jug2Capacity, int targetCapacity) {
if(targetCapacity > jug1Capacity + jug2Capacity)
return false;
vector<int> dp(jug1Capacity + jug2Capacity + 1, -1);
return helper(0, jug1Capacity, jug2Capacity, targetCapacity, dp);
}
bool helper(int tmp, int &jug1Capacity, int &jug2Capacity, int &targetCapacity, vector<int> &dp)
{
if(tmp < 0 || tmp > jug1Capacity + jug2Capacity)
return false;
if(tmp == targetCapacity)
return true;
if(dp[tmp] != -1)
return dp[tmp];
dp[tmp] = false;
if(helper(tmp + jug1Capacity, jug1Capacity, jug2Capacity, targetCapacity, dp))
return dp[tmp] = true;
if(helper(tmp - jug1Capacity, jug1Capacity, jug2Capacity, targetCapacity, dp))
return dp[tmp] = true;
if(helper(tmp + jug2Capacity, jug1Capacity, jug2Capacity, targetCapacity, dp))
return dp[tmp] = true;
if(helper(tmp - jug2Capacity, jug1Capacity, jug2Capacity, targetCapacity, dp))
return dp[tmp] = true;
return dp[tmp] = false;
}
}; | var canMeasureWater = function(jug1Capacity, jug2Capacity, targetCapacity) {
const gcd = (x, y) => y === 0 ? x : gcd(y, x % y);
return jug1Capacity + jug2Capacity >= targetCapacity &&
targetCapacity % gcd(jug1Capacity, jug2Capacity) === 0;
}; | Water and Jug Problem |
Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times.
Example 1:
Input: nums = [3,2,3]
Output: [3]
Example 2:
Input: nums = [1]
Output: [1]
Example 3:
Input: nums = [1,2]
Output: [1,2]
Constraints:
1 <= nums.length <= 5 * 104
-109 <= nums[i] <= 109
Follow up: Could you solve the problem in linear time and in O(1) space?
| class Solution:
def majorityElement(self, nums: List[int]) -> List[int]:
#Boyer Moore Voting Algo (As used in ME1 ques)
#now we can observe that there cannot be more than two elements occuring more than n//3 times in an array
#so find two majority elements(me=majority element)
n=len(nums)
req=n//3 #for an element to be ME required number of times present
c1=0 #count 1
c2=0 #count 2
me1=None #majority element 1
me2=None #majority element 2
for i in nums:
if i == me1:
c1+=1
elif i == me2:
c2+=1
elif c1 == 0:
me1=i
c1=1
elif c2 == 0:
me2=i
c2=1
else:
c1-=1
c2-=1
#here we have found our majority elements now check if the found majority element is ME
# print(me1,me2)
#check if the found majority element is ME
c1=0
c2=0
for i in nums:
if i==me1:
c1+=1
if i==me2:
c2+=1
# print(c1,c2)
if c1 > req and c2 > req:
return [me1,me2]
elif c1> req :
return [me1]
elif c2> req :
return [me2] | class Solution {
public List<Integer> majorityElement(int[] nums) {
int val1 = nums[0], val2 = nums[0], cnt1 = 1, cnt2 = 0;
for(int i = 1; i < nums.length; i++){
if(val1 == nums[i]){
cnt1++;
} else if(val2 == nums[i]){
cnt2++;
} else{
if(cnt1 == 0){
val1 = nums[i];
cnt1++;
} else if(cnt2 == 0){
val2 = nums[i];
cnt2++;
} else{
cnt1--;
cnt2--;
}
}
}
int check1 = 0, check2 = 0;
for(int i = 0; i < nums.length; i++){
if(val1 == nums[i])check1++;
else if(val2 == nums[i])check2++;
}
List<Integer> ans = new ArrayList<>();
if(check1 > nums.length / 3) ans.add(val1);
if(check2 > nums.length / 3) ans.add(val2);
return ans;
}
} | class Solution {
public:
vector<int> majorityElement(vector<int>& nums) {
int n = nums.size();
vector<int> result;
int num1 = -1 , num2 = -1 , count1 = 0 , count2 = 0;
for(auto it : nums){
if(num1 == it) ++count1;
else if(num2 == it) ++count2;
else if(count1 == 0){
num1 = it;
count1 = 1;
}
else if(count2 == 0){
num2 =it;
count2 = 1;
}
else{
--count1;
--count2;
}
}
count1 = 0;
count2 = 0;
for(auto it : nums){
if(it == num1) ++count1;
else if(it == num2) ++count2;
}
if(count1>(n/3)) result.push_back(num1);
if(count2>(n/3)) result.push_back(num2);
return result;
}
}; | /**
* @param {number[]} nums
* @return {number[]}
*/
var majorityElement = function(nums) {
const objElement = {};
const timesVar = Math.floor(nums.length/3);
const resultSet = new Set();
for(var indexI=0; indexI<nums.length; indexI++){
if(objElement[nums[indexI]]) {
objElement[nums[indexI]] = objElement[nums[indexI]] + 1;
}
else objElement[nums[indexI]] = 1;
if(objElement[nums[indexI]]>timesVar) resultSet.add(nums[indexI]);
}
return [...resultSet];
}; | Majority Element II |
You are given a phone number as a string number. number consists of digits, spaces ' ', and/or dashes '-'.
You would like to reformat the phone number in a certain manner. Firstly, remove all spaces and dashes. Then, group the digits from left to right into blocks of length 3 until there are 4 or fewer digits. The final digits are then grouped as follows:
2 digits: A single block of length 2.
3 digits: A single block of length 3.
4 digits: Two blocks of length 2 each.
The blocks are then joined by dashes. Notice that the reformatting process should never produce any blocks of length 1 and produce at most two blocks of length 2.
Return the phone number after formatting.
Example 1:
Input: number = "1-23-45 6"
Output: "123-456"
Explanation: The digits are "123456".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 3 digits remaining, so put them in a single block of length 3. The 2nd block is "456".
Joining the blocks gives "123-456".
Example 2:
Input: number = "123 4-567"
Output: "123-45-67"
Explanation: The digits are "1234567".
Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
Step 2: There are 4 digits left, so split them into two blocks of length 2. The blocks are "45" and "67".
Joining the blocks gives "123-45-67".
Example 3:
Input: number = "123 4-5678"
Output: "123-456-78"
Explanation: The digits are "12345678".
Step 1: The 1st block is "123".
Step 2: The 2nd block is "456".
Step 3: There are 2 digits left, so put them in a single block of length 2. The 3rd block is "78".
Joining the blocks gives "123-456-78".
Constraints:
2 <= number.length <= 100
number consists of digits and the characters '-' and ' '.
There are at least two digits in number.
| class Solution:
def reformatNumber(self, number: str) -> str:
s = number.replace(" ", "").replace("-", "")
pieces = list()
while s:
if len(s) == 2:
pieces.append(s)
break
elif len(s) == 4:
pieces.append(s[:2])
pieces.append(s[2:])
break
else:
pieces.append(s[:3])
s = s[3:]
return "-".join(pieces) | class Solution {
String modifiedNumber="";
public String reformatNumber(String number) {
modifiedNumber=number.replace(" ","");
modifiedNumber=modifiedNumber.replace("-","");
int l=modifiedNumber.length();
if(l<=3){
return modifiedNumber;
} else if(l==4){
return modifiedNumber.substring(0,2)+"-"+ modifiedNumber.substring(2,4);
} else {
modifiedNumber=modifiedNumber.substring(0,3)+"-"+reformatNumber(modifiedNumber.substring(3,l));
}
return modifiedNumber;
}
} | class Solution {
public:
string reformatNumber(string number) {
string temp; // stores the digits from string number
string ans; //stores final answer
int n = number.size();
for(auto ch:number)
if(isdigit(ch)) temp += ch;
int len = temp.size();
int i = 0;
while(len>0){
//check for different values of "len"
if(len > 4){ //if len > 4 -> make grp of 3 digits
ans += temp.substr(i,i+3);
temp.erase(i,3);
len = len-3;
ans += "-";
}
else if(len == 3){ //if len == 3 -> make grp of 3 digits
ans += temp.substr(i,i+3);
temp.erase(i,3);
len = len-3;
ans += "-";
}
else if(len == 2){ //if len == 2 -> make grp of 2 digits
ans += temp.substr(i,i+2);
temp.erase(i,2);
len = len-2;
ans += "-";
}
else if(len == 4){ //if len == 4 -> make 1 grp of 2 digits & reduce the length by 2 units, in the next iteration it will automatically catch (len==2) condition
ans += temp.substr(i,i+2);
temp.erase(i,2);
ans += "-";
// ans += temp.substr(i,i+2); ------(1)
// temp.erase(i,2); ------(2)
// ans += "-"; ------(3)
len = len-2; // *len = len-4* can be edited to *len = len-2*------(4)
}
}
ans.pop_back();
return ans;
}
}; | var reformatNumber = function(number) {
let numArr = number.replace(/-/g,'').replace(/ /g,'').split('')
let res = ''
while(numArr.length >= 4){
numArr.length == 4 ?
res += numArr.splice(0,2).join('') +'-'+numArr.splice(0,2).join('') :
res += numArr.splice(0,3).join('') + '-'
}
res += numArr.join('')
return res
}; | Reformat Phone Number |
An integer array is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.
For example, [1,3,5,7,9], [7,7,7,7], and [3,-1,-5,-9] are arithmetic sequences.
Given an integer array nums, return the number of arithmetic subarrays of nums.
A subarray is a contiguous subsequence of the array.
Example 1:
Input: nums = [1,2,3,4]
Output: 3
Explanation: We have 3 arithmetic slices in nums: [1, 2, 3], [2, 3, 4] and [1,2,3,4] itself.
Example 2:
Input: nums = [1]
Output: 0
Constraints:
1 <= nums.length <= 5000
-1000 <= nums[i] <= 1000
| #Baraa
class Solution:
def numberOfArithmeticSlices(self, nums: List[int]) -> int:
"""
what is (x * (x + 1)) // 2? this is series sum formula between n and 1
which means: n + (n - 1) + (n - 2) + (n - 3) .... + 1
when we have a total number of 10 elements that form an arithmetic sum
eg: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
we can form subarrays up until count - 2
which means 1,2,3,4,5,6,7,8
if we take 7 for example --> [7, 8, 9, 10] or [7, 8, 9]
we cant take [9, 10] as subarray as its length < 3
"""
#this is done for termination only
nums += [-float("inf")]
n = len(nums)
#base case
if n < 3:
return 0
res = 0
#store inital difference we have
prev_diff = nums[1] - nums[0]
#because we calculated an initial difference we store 2 inside count
#which represents number of elements
count = 2
for i in range(2, n):
diff = nums[i] - nums[i - 1]
if prev_diff != diff:
x = count - 2
res = res + (x * (x + 1)) // 2
prev_diff = diff
count = 2
else:
count += 1
prev_diff = diff
return res | class Solution {
public int numberOfArithmeticSlices(int[] nums) {
int n = nums.length;
if (n < 3) {
return 0;
}
int[] dp = new int[n - 1];
dp[0] = nums[1] - nums[0];
for (int i = 2; i < n; i++) {
dp[i - 1] = nums[i] - nums[i - 1];
}
int si = 0;
int count = 0;
for (int i = 1; i < n - 1; i++) {
if (dp[i] == dp[i - 1]) {
count += (i - si);
} else {
si = i;
}
}
return count;
}
} | class Solution {
public:
int numberOfArithmeticSlices(vector<int>& nums) {
int n=nums.size(),i,j,count=0,comm_diff;
for(i=0;i<=n-3;i++)
{
comm_diff = nums[i+1]-nums[i];
for(j=i+1;j<n;j++)
{
if(nums[j]-nums[j-1]==comm_diff)
{
if((j-i+1)>=3)
{
count++;
}
}
else
{
break;
}
}
}
return count;
}
}; | /**
* @param {number[]} nums
* @return {number}
*/
var numberOfArithmeticSlices = function(nums) {
nums.push(-2000)
let count = 0
let dist = nums[1]-nums[0]
let start = 0
for (let i = 1; i < nums.length; i++) {
if (nums[i]-nums[i-1] !== dist) {
let len = i - start
start = i-1
dist = nums[i] - nums[i-1]
// count the length of each largest AS and add to sum
// of len = 5 => the number of sub AS = 1 (len = 5) + 2 (len = 4) + 3 (len = 3)
for (let k = 3; k <=len; k++) {
count += len - k + 1
}
}
}
return count
}; | Arithmetic Slices |
Given a rectangle of size n x m, return the minimum number of integer-sided squares that tile the rectangle.
Example 1:
Input: n = 2, m = 3
Output: 3
Explanation: 3 squares are necessary to cover the rectangle.
2 (squares of 1x1)
1 (square of 2x2)
Example 2:
Input: n = 5, m = 8
Output: 5
Example 3:
Input: n = 11, m = 13
Output: 6
Constraints:
1 <= n, m <= 13
| class Solution:
def tilingRectangle(self, n: int, m: int) -> int:
# try brute force backtracking?
board = [[0 for _ in range(n)] for _ in range(m)]
ans = math.inf
def bt(counts):
nonlocal ans
if counts >= ans:
return
pos = None
found = False
for row in range(m):
for col in range(n):
if board[row][col] == 0:
pos = (row, col)
found = True
break
if found:
break
if not found:
ans = min(ans, counts)
return
# see how many difference size of squares we can place from this spot
r, c = pos
offset = 0
while r + offset < m and c + offset < n and board[r + offset][c] == 0 and board[r][c + offset] == 0:
offset += 1
# max can place size is offset
for row in range(r, r + offset):
for col in range(c, c + offset):
board[row][col] = 1
# do bt and shrink
while offset > 0:
bt(counts + 1)
# shrink
for row in range(r, r + offset):
board[row][c + offset - 1] = 0
for col in range(c, c + offset):
board[r + offset - 1][col] = 0
offset -= 1
bt(0)
return ans | class Solution {
int ret; // store the final result
int m, n; // m is the height, and n is the width
// Note: original signature is changed from n,m to m,n
public int tilingRectangle(int m, int n) {
this.m = m;
this.n = n;
this.ret = m * n; // initilize the result as m*n if cut rectangle to be all 1*1 squares
int[][] mat = new int[m][n]; // record the status of every location, 0 means not covered, 1 means covered
backtrack(mat, 0); // start backtracking
return ret;
}
// the size means how many squares cut now
public void backtrack(int[][] mat, int size) {
if (size > ret) return; // if we already have more squares than the min result, no need to go forward
// find out the leftmost and topmost postion where is not covered yet
int x = -1, y = -1;
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
if (mat[i][j] == 0) {
x = i;
y = j;
break;
}
}
if (x != -1 && y != -1) break;
}
// if not found, we know that all positions are covered
if (x == -1 && y == -1) {
// update the result
ret = Math.min(size, ret);
}
else {
int len = findWidth(x, y, mat); // find the maximum width to cut the square
while(len >= 1) {
cover(x, y, len, mat, 1); // cover the current square
backtrack(mat, size + 1);
cover(x, y, len, mat, 0); // uncover the previous result
len--; // decrement the square width by 1
}
}
}
public int findWidth(int x, int y, int[][] mat) {
int len = 1;
while(x + len < m && y + len < n) {
boolean flag = true; // flag means the len is reachable
for (int i = 0; i <= len; i++) {
// check the right i-th column and the bottom i-th row away from (x, y)
if (mat[x + i][y + len] == 1 || mat[x + len][y + i] == 1) {
flag = false;
break;
}
}
if (!flag) break;
len++;
}
return len;
}
public void cover(int x, int y, int len, int[][] mat, int val) {
for (int i = x; i < x + len; i++) {
for (int j = y; j < y + len; j++) {
mat[i][j] = val;
}
}
}
} | class Solution {
public:
int solve(int n, int m, vector<vector<int>>& dp) {
if(n<0 || m<0) return 0;
if(m==n) return 1;
// this is special case
if((m==13 && n==11) || (m==11 && n==13)) return dp[n][m]=6;
if(dp[n][m]!=0) return dp[n][m];
int hz=1e9;
for(int i=1;i<=n/2;i++) {
hz = min(hz, solve(i,m,dp) + solve(n-i,m,dp));
}
int vert = 1e9;
for(int i=1;i<=m/2;i++) {
vert = min(vert, solve(n,m-i,dp) + solve(n,i,dp));
}
return dp[n][m] = min(hz,vert);
}
int tilingRectangle(int n, int m) {
vector<vector<int>> dp (n+1,vector<int> (m+1,0));
return solve(n,m,dp);
}
}; | var tilingRectangle = function(n, m) {
const queue = [[new Array(n).fill(0), 0]];
while (true) {
const [curr, numSquares] = queue.shift();
let min = { height: Infinity, start: Infinity, end: Infinity }
for (let i = 0; i < n; i++) {
if (curr[i] < min.height) {
min.height = curr[i];
min.start = i;
min.end = i + 1;
} else if (curr[i] === min.height && min.end === i) {
min.end++
}
}
if (min.height === m) return numSquares;
const largestSquare = Math.min(m - min.height, min.end - min.start);
for (let sqWidth = largestSquare; sqWidth; sqWidth--) {
const next = curr.slice();
for (let i = min.start; i < min.start + sqWidth; i++) {
next[i] += sqWidth;
}
queue.push([next, numSquares + 1]);
}
}
}; | Tiling a Rectangle with the Fewest Squares |
You are given a string s consisting of n characters which are either 'X' or 'O'.
A move is defined as selecting three consecutive characters of s and converting them to 'O'. Note that if a move is applied to the character 'O', it will stay the same.
Return the minimum number of moves required so that all the characters of s are converted to 'O'.
Example 1:
Input: s = "XXX"
Output: 1
Explanation: XXX -> OOO
We select all the 3 characters and convert them in one move.
Example 2:
Input: s = "XXOX"
Output: 2
Explanation: XXOX -> OOOX -> OOOO
We select the first 3 characters in the first move, and convert them to 'O'.
Then we select the last 3 characters and convert them so that the final string contains all 'O's.
Example 3:
Input: s = "OOOO"
Output: 0
Explanation: There are no 'X's in s to convert.
Constraints:
3 <= s.length <= 1000
s[i] is either 'X' or 'O'.
| class Solution:
def minimumMoves(self, s: str) -> int:
i, m = 0, 0
l = len(s)
while i < l:
if s[i] != 'X':
i += 1
elif 'X' not in s[i:i+1]:
i += 2
elif 'X' in s[i:i+2]:
m += 1
i += 3
return m | class Solution {
public int minimumMoves(String s) {
int i=0;
int step=0;
while(i<s.length()){
if(s.charAt(i)=='X'){
i=i+3;
step++;
}
else{
i++;
}
}
return step;
}
} | class Solution {
public:
int minimumMoves(string s) {
int count=0;
int i=0;
for(int i=0;i<s.size();){
if(s[i]=='O'){
// continue;
i++;}
else{
count++;
i+=3;
}
}
return count;
}
}; | var minimumMoves = function(s) {
let move = 0;
let i = 0;
while(i<s.length){
let char = s[i];
// incrementing the index if we already have 'O'
if(char== 'O'){
i++;
}
// incrementing the move and index by 3 (Per move = 3 characters)
if(char== 'X'){
i=i+3;
move++;
}
}
return move;
}; | Minimum Moves to Convert String |
Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive.
There is only one repeated number in nums, return this repeated number.
You must solve the problem without modifying the array nums and uses only constant extra space.
Example 1:
Input: nums = [1,3,4,2,2]
Output: 2
Example 2:
Input: nums = [3,1,3,4,2]
Output: 3
Constraints:
1 <= n <= 105
nums.length == n + 1
1 <= nums[i] <= n
All the integers in nums appear only once except for precisely one integer which appears two or more times.
Follow up:
How can we prove that at least one duplicate number must exist in nums?
Can you solve the problem in linear runtime complexity?
| class Solution:
def findDuplicate(self, nums: List[int]) -> int:
dictx = {}
for each in nums:
if each not in dictx:
dictx[each] = 1
else:
return each | class Solution {
public int findDuplicate(int[] nums) {
int i = 0;
while (i < nums.length) {
if (nums[i] != i + 1) {
int correct = nums[i] - 1;
if (nums[i] != nums[correct]) {
swap(nums, i , correct);
} else {
return nums[i];
}
} else {
i++;
}
}
return -1;
}
static void swap(int[] arr, int first, int second) {
int temp = arr[first];
arr[first] = arr[second];
arr[second] = temp;
}
} | // Please upvote if it helps
class Solution {
public:
int findDuplicate(vector<int>& nums) {
int low = 1, high = nums.size() - 1, cnt;
while(low <= high)
{
int mid = low + (high - low) / 2;
cnt = 0;
// cnt number less than equal to mid
for(int n : nums)
{
if(n <= mid)
++cnt;
}
// binary search on left
if(cnt <= mid)
low = mid + 1;
else
// binary search on right
high = mid - 1;
}
return low;
}
// for github repository link go to my profile.
}; | var findDuplicate = function(nums) {
let dup = new Map();
for(let val of nums){
if(dup.has(val)){
dup.set(val, dup.get(val) + 1);
return val;
}
else
dup.set(val, 1);
}
}; | Find the Duplicate Number |
Given a string s consisting of words and spaces, return the length of the last word in the string.
A word is a maximal substring consisting of non-space characters only.
Example 1:
Input: s = "Hello World"
Output: 5
Explanation: The last word is "World" with length 5.
Example 2:
Input: s = " fly me to the moon "
Output: 4
Explanation: The last word is "moon" with length 4.
Example 3:
Input: s = "luffy is still joyboy"
Output: 6
Explanation: The last word is "joyboy" with length 6.
Constraints:
1 <= s.length <= 104
s consists of only English letters and spaces ' '.
There will be at least one word in s.
| class Solution:
def lengthOfLastWord(self, s: str) -> int:
return len(s.strip().split()[-1]) | class Solution {
public int lengthOfLastWord(String s) {
int j=s.length()-1,len=0; boolean flag=true;
while(j>=0 && (flag || (!flag && s.charAt(j)!=' ')))
if(s.charAt(j--)!=' '){
flag=false;
len++;
}
return len;
}
} | class Solution {
public:
int lengthOfLastWord(string s) {
int count = 0;
int n = s.size();
int i = n-1;
while(i>=0){
if(s[i]==' '){
i--;
if(count >0){
break;
}
}
else{
count++;
i--;
}
}
return count;
}
}; | var lengthOfLastWord = function(s) {
s = s.split(" ");
if(s[s.length-1] == ``)
{
for(var i = s.length-1; i >= 0; i-- )
{
if(s[i].length > 0)
{
return s[i].length;
}
}
}
else
{
return s[s.length-1].length;
}
}; | Length of Last Word |
You are given a 0-indexed integer array nums of length n.
The average difference of the index i is the absolute difference between the average of the first i + 1 elements of nums and the average of the last n - i - 1 elements. Both averages should be rounded down to the nearest integer.
Return the index with the minimum average difference. If there are multiple such indices, return the smallest one.
Note:
The absolute difference of two numbers is the absolute value of their difference.
The average of n elements is the sum of the n elements divided (integer division) by n.
The average of 0 elements is considered to be 0.
Example 1:
Input: nums = [2,5,3,9,5,3]
Output: 3
Explanation:
- The average difference of index 0 is: |2 / 1 - (5 + 3 + 9 + 5 + 3) / 5| = |2 / 1 - 25 / 5| = |2 - 5| = 3.
- The average difference of index 1 is: |(2 + 5) / 2 - (3 + 9 + 5 + 3) / 4| = |7 / 2 - 20 / 4| = |3 - 5| = 2.
- The average difference of index 2 is: |(2 + 5 + 3) / 3 - (9 + 5 + 3) / 3| = |10 / 3 - 17 / 3| = |3 - 5| = 2.
- The average difference of index 3 is: |(2 + 5 + 3 + 9) / 4 - (5 + 3) / 2| = |19 / 4 - 8 / 2| = |4 - 4| = 0.
- The average difference of index 4 is: |(2 + 5 + 3 + 9 + 5) / 5 - 3 / 1| = |24 / 5 - 3 / 1| = |4 - 3| = 1.
- The average difference of index 5 is: |(2 + 5 + 3 + 9 + 5 + 3) / 6 - 0| = |27 / 6 - 0| = |4 - 0| = 4.
The average difference of index 3 is the minimum average difference so return 3.
Example 2:
Input: nums = [0]
Output: 0
Explanation:
The only index is 0 so return 0.
The average difference of index 0 is: |0 / 1 - 0| = |0 - 0| = 0.
Constraints:
1 <= nums.length <= 105
0 <= nums[i] <= 105
| from itertools import accumulate
class Solution:
def minimumAverageDifference(self, nums: List[int]) -> int:
size = len(nums)
nums[::] = list(accumulate(nums))
total = nums[-1]
min_tuple = [0, sys.maxsize]
for (i, n) in enumerate(nums):
i = i + 1
avg_i = floor(n/i)
diff = size - i
total_avg = floor((total - n) / (diff if diff>0 else 1))
avg = abs( avg_i - total_avg)
if min_tuple[1] > avg:
min_tuple[1] = avg
min_tuple[0] = i - 1
return min_tuple[0] | class Solution {
public int minimumAverageDifference(int[] nums) {
if(nums.length == 1){
return 0;
}
int idx = -1;
long min = Integer.MAX_VALUE;
long suml = nums[0];
long sumr = 0;
for(int i = 1; i < nums.length; i++){
sumr += nums[i];
}
int i = 1;
int calc = 0;
int left = 1;
int right = nums.length - left;
long[] arr = new long[nums.length];
while(i < nums.length){
long diff = Math.abs((suml/left) - (sumr/right));
arr[calc] = diff;
if(diff < min){
min = diff;
idx = calc;
}
suml += nums[i];
sumr -= nums[i];
left++;
right--;
calc++;
i++;
}
arr[calc] = suml/nums.length;
if(arr[calc] < min){
min = arr[calc];
idx = nums.length - 1;
}
// for(i = 0; i < nums.length; i++){
// System.out.println(arr[i]);
// }
return (int)idx;
}
} | class Solution {
public:
int minimumAverageDifference(vector<int>& nums) {
int n(size(nums)), minAverageDifference(INT_MAX), index;
long long sumFromFront(0), sumFromEnd(0);
for (auto& num : nums) sumFromEnd += num;
for (int i=0; i<n; i++) {
sumFromFront += nums[i];
sumFromEnd -= nums[i];
int a = sumFromFront / (i+1); // average of the first i + 1 elements.
int b = (i == n-1) ? 0 : sumFromEnd / (n-i-1); // average of the last n - i - 1 elements.
if (abs(a-b) < minAverageDifference) {
minAverageDifference = abs(a-b);
index = i;
}
}
return index;
}
}; | ```/**
* @param {number[]} nums
* @return {number}
*/
var minimumAverageDifference = function(nums) {
if (nums.length == 1) return 0;
let mins = 100000, resultIndex, leftTotal = 0;
let rightTotal = nums.reduce((a,b)=>a + b);
let numLength = nums.length;
nums.forEach((data, index)=> {
leftTotal += data;
rightTotal -= data;
let currentAverageDiff = Math.abs(Math.floor(leftTotal/(index+1)) - Math.floor(rightTotal/(numLength-index-1) || 0));
if (currentAverageDiff < mins) {
resultIndex = index;
mins = currentAverageDiff;
}
});
return resultIndex;
}; | Minimum Average Difference |
You are given the head of a linked list containing unique integer values and an integer array nums that is a subset of the linked list values.
Return the number of connected components in nums where two values are connected if they appear consecutively in the linked list.
Example 1:
Input: head = [0,1,2,3], nums = [0,1,3]
Output: 2
Explanation: 0 and 1 are connected, so [0, 1] and [3] are the two connected components.
Example 2:
Input: head = [0,1,2,3,4], nums = [0,3,1,4]
Output: 2
Explanation: 0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.
Constraints:
The number of nodes in the linked list is n.
1 <= n <= 104
0 <= Node.val < n
All the values Node.val are unique.
1 <= nums.length <= n
0 <= nums[i] < n
All the values of nums are unique.
| class Solution:
def numComponents(self, head: Optional[ListNode], nums: List[int]) -> int:
d,count={},0
for num in nums:
d[num] = 0
while head:
if head.val in d:
head = head.next
while head and head.val in d:
head = head.next
count += 1
else:
head = head.next
return count | class Solution {
public int numComponents(ListNode head, int[] nums) {
int count=0;
HashSet<Integer> set=new HashSet();
for(int i=0;i<nums.length;i++)
{
set.add(nums[i]);
}
while(head!=null)
{
if(set.contains(head.val))
{
while(head.next!=null&&set.contains(head.next.val))
{
head=head.next;
}
count++;
}
head=head.next;
}
return count;
}
} | class Solution {
public:
int numComponents(ListNode* head, vector<int>& nums)
{
unordered_set<int> s;
for(auto &x:nums)
s.insert(x);
int count=0;
while(head!=NULL)
{
if(s.find(head->val)!=s.end()) count++;
while(head!=NULL && s.find(head->val)!=s.end())
{
head=head->next;
}
if(head!=NULL)
head=head->next;
}
return count;
}
}; | var numComponents = function(head, nums) {
let broken = true, count = 0;
while (head) {
if (nums.includes(head.val) && broken) {
count++;
broken = false;
}
else if (!nums.includes(head.val)) {
broken = true;
}
// reset head as next
head = head.next
}
// result
return count;
}; | Linked List Components |
You are given a 0-indexed string s that has lowercase English letters in its even indices and digits in its odd indices.
There is a function shift(c, x), where c is a character and x is a digit, that returns the xth character after c.
For example, shift('a', 5) = 'f' and shift('x', 0) = 'x'.
For every odd index i, you want to replace the digit s[i] with shift(s[i-1], s[i]).
Return s after replacing all digits. It is guaranteed that shift(s[i-1], s[i]) will never exceed 'z'.
Example 1:
Input: s = "a1c1e1"
Output: "abcdef"
Explanation: The digits are replaced as follows:
- s[1] -> shift('a',1) = 'b'
- s[3] -> shift('c',1) = 'd'
- s[5] -> shift('e',1) = 'f'
Example 2:
Input: s = "a1b2c3d4e"
Output: "abbdcfdhe"
Explanation: The digits are replaced as follows:
- s[1] -> shift('a',1) = 'b'
- s[3] -> shift('b',2) = 'd'
- s[5] -> shift('c',3) = 'f'
- s[7] -> shift('d',4) = 'h'
Constraints:
1 <= s.length <= 100
s consists only of lowercase English letters and digits.
shift(s[i-1], s[i]) <= 'z' for all odd indices i.
| class Solution(object):
def replaceDigits(self, s):
"""
:type s: str
:rtype: str
"""
res = []
for i in range(len(s)):
if i % 2 == 0:
res.append(s[i])
if i % 2 == 1:
res.append( chr(ord(s[i-1]) + int(s[i])) )
return ''.join(res) | class Solution {
public String replaceDigits(String s) {
char[] str = s.toCharArray();
for(int i=0;i<str.length;i++){
if(Character.isDigit(str[i])){
str[i] = shift(str[i-1],str[i]);
}
}
return String.valueOf(str);
}
char shift(char letter, char number){
int a = Integer.parseInt(String.valueOf(number));
int asci = (int)letter;
char c = (char)(asci + a);
return c;
}
} | class Solution {
public:
string replaceDigits(string s) {
for(int i=1;i<s.size();i+=2){
s[i]=s[i-1]+(s[i]-'0'); //or s[i] += s[i-1] - '0';
}
return s;
}
}; | var replaceDigits = function(s) {
let res = ''
for(let i = 0; i < s.length; i++){
if(i % 2 !== 0){
res += String.fromCharCode(s[i - 1].charCodeAt() + parseInt(s[i]))
} else{
res += s[i]
}
}
return res;
}; | Replace All Digits with Characters |
You are given a tree with n nodes numbered from 0 to n - 1 in the form of a parent array parent where parent[i] is the parent of the ith node. The root of the tree is node 0, so parent[0] = -1 since it has no parent. You want to design a data structure that allows users to lock, unlock, and upgrade nodes in the tree.
The data structure should support the following functions:
Lock: Locks the given node for the given user and prevents other users from locking the same node. You may only lock a node using this function if the node is unlocked.
Unlock: Unlocks the given node for the given user. You may only unlock a node using this function if it is currently locked by the same user.
Upgrade: Locks the given node for the given user and unlocks all of its descendants regardless of who locked it. You may only upgrade a node if all 3 conditions are true:
The node is unlocked,
It has at least one locked descendant (by any user), and
It does not have any locked ancestors.
Implement the LockingTree class:
LockingTree(int[] parent) initializes the data structure with the parent array.
lock(int num, int user) returns true if it is possible for the user with id user to lock the node num, or false otherwise. If it is possible, the node num will become locked by the user with id user.
unlock(int num, int user) returns true if it is possible for the user with id user to unlock the node num, or false otherwise. If it is possible, the node num will become unlocked.
upgrade(int num, int user) returns true if it is possible for the user with id user to upgrade the node num, or false otherwise. If it is possible, the node num will be upgraded.
Example 1:
Input
["LockingTree", "lock", "unlock", "unlock", "lock", "upgrade", "lock"]
[[[-1, 0, 0, 1, 1, 2, 2]], [2, 2], [2, 3], [2, 2], [4, 5], [0, 1], [0, 1]]
Output
[null, true, false, true, true, true, false]
Explanation
LockingTree lockingTree = new LockingTree([-1, 0, 0, 1, 1, 2, 2]);
lockingTree.lock(2, 2); // return true because node 2 is unlocked.
// Node 2 will now be locked by user 2.
lockingTree.unlock(2, 3); // return false because user 3 cannot unlock a node locked by user 2.
lockingTree.unlock(2, 2); // return true because node 2 was previously locked by user 2.
// Node 2 will now be unlocked.
lockingTree.lock(4, 5); // return true because node 4 is unlocked.
// Node 4 will now be locked by user 5.
lockingTree.upgrade(0, 1); // return true because node 0 is unlocked and has at least one locked descendant (node 4).
// Node 0 will now be locked by user 1 and node 4 will now be unlocked.
lockingTree.lock(0, 1); // return false because node 0 is already locked.
Constraints:
n == parent.length
2 <= n <= 2000
0 <= parent[i] <= n - 1 for i != 0
parent[0] == -1
0 <= num <= n - 1
1 <= user <= 104
parent represents a valid tree.
At most 2000 calls in total will be made to lock, unlock, and upgrade.
| class LockingTree:
def __init__(self, parent: List[int]):
self.p = collections.defaultdict(lambda: -2)
self.c = collections.defaultdict(list)
for i, p in enumerate(parent):
self.c[p].append(i)
self.p[i] = p
self.user = collections.defaultdict(set)
self.node = collections.defaultdict(lambda: -2)
def lock(self, num: int, user: int) -> bool:
if self.node[num] == -2:
self.user[user].add(num)
self.node[num] = user
return True
return False
def unlock(self, num: int, user: int) -> bool:
if self.node[num] == user:
del self.node[num]
self.user[user].remove(num)
return True
return False
def upgrade(self, num: int, user: int) -> bool:
if self.node[num] != -2: return False
if not self.has_locked_descendant(num): return False
if self.has_locked_ancester(num): return False
self.lock(num, user)
self.unlock_descendant(num)
return True
def has_locked_descendant(self, num): #function to check if alteast one desendent is lock or not
has = False
for child in self.c[num]:
if self.node[child] != -2:
return True
has |= self.has_locked_descendant(child)
return has
def has_locked_ancester(self, num): # function to check if no parent is locked
if num == -1: return False
if self.node[self.p[num]] != -2:
return True
return self.has_locked_ancester(self.p[num])
def unlock_descendant(self, num): # function fro unlocking all desendents
for child in self.c[num]:
if child in self.node:
user = self.node[child]
del self.node[child]
if user in self.user:
self.user[user].remove(child)
self.unlock_descendant(child) | class LockingTree {
int[] p;
Map<Integer, Integer> map = new HashMap<>();
Map<Integer, List<Integer>> children = new HashMap<>();
public LockingTree(int[] parent) {
p = parent;
for(int i = 0; i < p.length; i ++) {
children.put(i, new ArrayList<>());
}
for(int i = 1; i < p.length; i ++) {
children.get(p[i]).add(i);
}
}
public boolean lock(int num, int user) {
if(!map.containsKey(num)) {
map.put(num, user);
return true;
}
return false;
}
public boolean unlock(int num, int user) {
if(map.containsKey(num) && map.get(num) == user) {
map.remove(num);
return true;
}
return false;
}
public boolean upgrade(int num, int user) {
//check the node
if(map.containsKey(num)) return false;
//check Ancestor
int ori = num;
while(p[num] != -1) {
if(map.get(p[num]) != null) return false;
num = p[num];
}
//check Decendant
Queue<Integer> q = new LinkedList<>();
List<Integer> child = children.get(ori);
if(child != null) {
for(int c : child) q.offer(c);
}
boolean lock = false;
while(!q.isEmpty()) {
int cur = q.poll();
if(map.get(cur) != null) {
lock = true;
map.remove(cur); // unlock
}
List<Integer> cc = children.get(cur);
if(cc != null) {
for(int c : cc) q.offer(c);
}
}
if(!lock) return false;
map.put(ori, user); // lock the original node
return true;
}
} | class LockingTree {
public:
unordered_map<int,int> locks_aquired;
vector<vector<int>> graph;
unordered_map<int,int> parents;
LockingTree(vector<int>& parent)
{
int n=parent.size();
graph = vector<vector<int> >(n);
parents[0] = -1 ; // since parent of node 0 is always -1
for(int i=1; i<n; i++)
{
parents[i] = parent[i];
graph[parent[i]].push_back(i);
}
}
bool lock(int num, int user)
{
if(locks_aquired.find(num) == locks_aquired.end())
{ locks_aquired[num]=user; return 1;}
return 0;
}
bool unlock(int num, int user)
{
if(locks_aquired.find(num) != locks_aquired.end() && locks_aquired[num]==user)
{ locks_aquired.erase(num); return 1;}
return 0;
}
bool check_ans(int num)
{
while(num != -1)
{
if(locks_aquired.find(num) != locks_aquired.end()) return 0;
num = parents[num];
}
return 1;
}
bool dfs(int num) // function to check if alteast one desendent is lock or not
{
for(int i=0; i<graph[num].size(); i++)
{
int x = graph[num][i];
if( locks_aquired.find(x) != locks_aquired.end())
return 1;
if( dfs(x)) return 1;
}
return 0;
}
void unlock_descendents(int num)
{
for(int i=0; i<graph[num].size(); i++)
{
int x = graph[num][i];
if( locks_aquired.find(x) != locks_aquired.end())
locks_aquired.erase(x);
dfs_des(x);
}
}
bool upgrade(int num, int user)
{
if( locks_aquired.find(num) != locks_aquired.end()) return 0; // if current node is locked can't lock it again
if( dfs(num) && check_ans(parents[num]))
{
unlock_descendents(num);
locks_aquired[num]=user;
return 1;
}
return 0;
}
};
/**
* Your LockingTree object will be instantiated and called as such:
* LockingTree* obj = new LockingTree(parent);
* bool param_1 = obj->lock(num,user);
* bool param_2 = obj->unlock(num,user);
* bool param_3 = obj->upgrade(num,user);
*/ | var LockingTree = function(parent) {
this.parents = parent;
this.children = [];
this.locked = new Map();
for (let i = 0; i < this.parents.length; ++i) {
this.children[i] = [];
}
for (let i = 1; i < this.parents.length; ++i) {
const parent = this.parents[i];
this.children[parent].push(i);
}
};
LockingTree.prototype.lock = function(num, user) {
if (this.locked.has(num)) return false;
this.locked.set(num, user);
return true;
};
LockingTree.prototype.unlock = function(num, user) {
if (!this.locked.has(num) || this.locked.get(num) != user) return false;
this.locked.delete(num);
return true;
};
LockingTree.prototype.upgrade = function(num, user) {
let isLocked = traverseUp(num, this.parents, this.locked);
if (isLocked) return false;
const queue = [];
isLocked = false;
queue.push(num);
while (queue.length > 0) {
const node = queue.shift();
if (node != num && this.locked.has(node)) {
isLocked = true;
this.locked.delete(node);
}
for (let i = 0; i < this.children[node].length; ++i) {
queue.push(this.children[node][i]);
}
}
if (!isLocked) return false;
this.locked.set(num, user);
return true;
function traverseUp(num, parents, locked) {
if (locked.has(num)) return true;
if (num === 0) return false;
const parentIdx = parents[num];
return traverseUp(parentIdx, parents, locked);
}
}; | Operations on Tree |
Design a parking system for a parking lot. The parking lot has three kinds of parking spaces: big, medium, and small, with a fixed number of slots for each size.
Implement the ParkingSystem class:
ParkingSystem(int big, int medium, int small) Initializes object of the ParkingSystem class. The number of slots for each parking space are given as part of the constructor.
bool addCar(int carType) Checks whether there is a parking space of carType for the car that wants to get into the parking lot. carType can be of three kinds: big, medium, or small, which are represented by 1, 2, and 3 respectively. A car can only park in a parking space of its carType. If there is no space available, return false, else park the car in that size space and return true.
Example 1:
Input
["ParkingSystem", "addCar", "addCar", "addCar", "addCar"]
[[1, 1, 0], [1], [2], [3], [1]]
Output
[null, true, true, false, false]
Explanation
ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);
parkingSystem.addCar(1); // return true because there is 1 available slot for a big car
parkingSystem.addCar(2); // return true because there is 1 available slot for a medium car
parkingSystem.addCar(3); // return false because there is no available slot for a small car
parkingSystem.addCar(1); // return false because there is no available slot for a big car. It is already occupied.
Constraints:
0 <= big, medium, small <= 1000
carType is 1, 2, or 3
At most 1000 calls will be made to addCar
| class ParkingSystem:
def __init__(self, big: int, medium: int, small: int):
self.vehicle =[big,medium,small]
def addCar(self, carType: int) -> bool:
if carType == 1 :
if self.vehicle[0] > 0:
self.vehicle[0]-=1
return True
elif carType == 2:
if self.vehicle[1] > 0:
self.vehicle[1]-=1
return True
elif carType == 3:
if self.vehicle[2] > 0:
self.vehicle[2]-=1
return True
return False | class ParkingSystem {
private int[] size;
public ParkingSystem(int big, int medium, int small) {
this.size = new int[]{big, medium, small};
}
public boolean addCar(int carType) {
return size[carType-1]-->0;
}
} | class ParkingSystem {
public: vector<int> vehicle;
public:
ParkingSystem(int big, int medium, int small) {
vehicle = {big, medium, small};
}
bool addCar(int carType) {
return vehicle[carType - 1]-- > 0;
} | var ParkingSystem = function(big, medium, small) {
this.count = [big, medium, small];
};
/**
* @param {number} carType
* @return {boolean}
*/
ParkingSystem.prototype.addCar = function(carType) {
return this.count[carType - 1]-- > 0;
};
/**
* Your ParkingSystem object will be instantiated and called as such:
* var obj = new ParkingSystem(big, medium, small)
* var param_1 = obj.addCar(carType)
*/ | Design Parking System |
Given an array of integers nums, return the number of good pairs.
A pair (i, j) is called good if nums[i] == nums[j] and i < j.
Example 1:
Input: nums = [1,2,3,1,1,3]
Output: 4
Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.
Example 2:
Input: nums = [1,1,1,1]
Output: 6
Explanation: Each pair in the array are good.
Example 3:
Input: nums = [1,2,3]
Output: 0
Constraints:
1 <= nums.length <= 100
1 <= nums[i] <= 100
| from itertools import combinations
class Solution:
def numIdenticalPairs(self, nums) -> int:
res = 0
nums_set = set(nums)
nums_coppy = nums
for number in nums_set:
number_found = []
deleted = 0
while True:
try:
found = nums_coppy.index(number)
nums_coppy.remove(number)
if deleted > 0:
number_found.append(found + deleted)
else:
number_found.append(found + deleted)
deleted += 1
except:
comb = list(combinations(number_found, 2))
res += len(comb)
break
return res | class Solution {
public int numIdenticalPairs(int[] nums) {
int len =nums.length;
int counter=0;
for (int i =0;i<len;i++){
for (int j=i+1;j<len;j++){
if(nums[i]==nums[j]){
counter++;
}
}
}
return counter;
}
} | class Solution {
public:
int numIdenticalPairs(vector<int>& nums) {
int cnt = 0;
for(int i=0 ; i<nums.size() ; i++){
for(int j=i+1 ; j<nums.size() ; j++){
if(nums[i] == nums[j]){
cnt++;
}
}
}
return cnt;
}
}; | var numIdenticalPairs = function(nums) {
let counter = 0;
let map = {};
for(let num of nums) {
if(map[num]) {
counter += map[num];
map[num]++;
} else {
map[num] = 1;
}
}
return counter;
}; | Number of Good Pairs |
You are given the head of a linked list.
The nodes in the linked list are sequentially assigned to non-empty groups whose lengths form the sequence of the natural numbers (1, 2, 3, 4, ...). The length of a group is the number of nodes assigned to it. In other words,
The 1st node is assigned to the first group.
The 2nd and the 3rd nodes are assigned to the second group.
The 4th, 5th, and 6th nodes are assigned to the third group, and so on.
Note that the length of the last group may be less than or equal to 1 + the length of the second to last group.
Reverse the nodes in each group with an even length, and return the head of the modified linked list.
Example 1:
Input: head = [5,2,6,3,9,1,7,3,8,4]
Output: [5,6,2,3,9,1,4,8,3,7]
Explanation:
- The length of the first group is 1, which is odd, hence no reversal occurs.
- The length of the second group is 2, which is even, hence the nodes are reversed.
- The length of the third group is 3, which is odd, hence no reversal occurs.
- The length of the last group is 4, which is even, hence the nodes are reversed.
Example 2:
Input: head = [1,1,0,6]
Output: [1,0,1,6]
Explanation:
- The length of the first group is 1. No reversal occurs.
- The length of the second group is 2. The nodes are reversed.
- The length of the last group is 1. No reversal occurs.
Example 3:
Input: head = [1,1,0,6,5]
Output: [1,0,1,5,6]
Explanation:
- The length of the first group is 1. No reversal occurs.
- The length of the second group is 2. The nodes are reversed.
- The length of the last group is 2. The nodes are reversed.
Constraints:
The number of nodes in the list is in the range [1, 105].
0 <= Node.val <= 105
| class Solution:
def reverseEvenLengthGroups(self, head: Optional[ListNode]) -> Optional[ListNode]:
group = 2
tail = head # tail of previous group
while tail and tail.next:
cnt = 1 # actual size of the current group
cur = tail.next # first node of the current group
while cur.next and cnt < group:
cur = cur.next
cnt += 1
pre, cur = tail, tail.next
if cnt % 2 == 0: # if group size is even
while cnt and cur:
nxt = cur.next
cur.next = pre
pre = cur
cur = nxt
cnt -= 1
first = tail.next # first node of the original group
first.next = cur
tail.next = pre
tail = first
else:
while cnt and cur:
pre, cur = cur, cur.next
cnt -= 1
tail = pre
group += 1
return head | // This Question can be solved easily using two standard methods of LinkedList
// 1) addFirst (it adds node in front of the LinkedList)
// 2) addLast (it adds node in end of the LinkedList)
class Solution {
static ListNode oh;
static ListNode ot;
static ListNode th;
static ListNode tt;
public ListNode reverseEvenLengthGroups(ListNode head) {
oh = null;
ot = null;
th = null;
tt = null;
if(head == null || head.next == null)
return head;
int size = length(head);
int idx = 1;
ListNode curr = head;
int group = 1;
while(curr!=null)
{
int temp = size - idx + 1;
if((temp>=group && group%2 == 0) || (temp<group && temp%2 == 0))
{
int k = group;
while(k-->0 && curr!=null)
{
ListNode t = curr.next;
curr.next = null;
addFirst(curr);
curr = t;
idx++;
}
}
else
{
int k = group;
while(k-->0 && curr!=null)
{
ListNode t = curr.next;
curr.next = null;
addLast(curr);
curr = t;
idx++;
}
}
if(oh==null && ot==null)
{
oh = th;
ot = tt;
}
else
{
ot.next = th;
ot = tt;
}
th = null;
tt = null;
group++;
}
return oh;
}
public int length (ListNode head)
{
if(head==null) return 0;
ListNode curr = head;
int k = 0;
while(curr!=null)
{
k++;
curr = curr.next;
}
return k;
}
public void addFirst(ListNode head)
{
if(tt == null && th == null)
{
th = head;
tt = head;
}
else
{
head.next = th;
th = head;
}
}
public void addLast(ListNode head)
{
if(tt == null && th == null)
{
th = head;
tt = head;
}
else
{
tt.next = head;
tt = head;
}
}
} | class Solution {
public:
// Function to reverse a linked list
ListNode* reverseList(ListNode* head) {
if(!head)
return head;
ListNode* prev = NULL;
while(head) {
ListNode* temp = head -> next;
head -> next = prev;
prev = head;
head = temp;
}
return prev;
}
ListNode* reverseEvenLengthGroups(ListNode* head) {
// Creating a dummy node to avoid adding checks for the first node
ListNode* dummy = new ListNode();
dummy -> next = head;
ListNode* prev = dummy;
// Loop to determine the lengths of groups
for(int len = 1; len < 1e5 && head; len++) {
ListNode* tail = head;
ListNode* nextHead;
// Determining the length of the current group
// Its maximum length can be equal to len
int j = 1;
while(j < len && tail && tail -> next) {
tail = tail -> next;
j++;
}
// Head of the next group
nextHead = tail -> next;
if((j % 2) == 0) {
// If even sized group is found
// Reversing the group and setting prev and head appropriately
tail -> next = NULL;
prev -> next = reverseList(head);
prev = head;
head -> next = nextHead;
head = nextHead;
} else {
// If group is odd sized, then simply going towards the next group
prev = tail;
head = nextHead;
}
}
// Returning the head
return dummy -> next;
}
}; | var reverseEvenLengthGroups = function(head) {
let groupSize = 2;
let start = head;
let prev = head;
let curr = head.next;
let count = 0;
while (curr != null) {
if (count === groupSize) {
if (groupSize % 2 === 0) { // we only reverse when it is even
const end = curr;
const tail = start.next; // the starting node of the reverse linked list will be the tail after the reverse takes place
reverseList(start, end, count); // we need to reverse everything in the middle of start and end
start = tail; // we set the new start to the end of the reversed linked list
}
else { // when groupSize is even we don't need to reverse, but need to set the new start to the prev node
start = prev;
}
count = 0; // whenever we reached the group size we need to reset our count and up our groupSize
++groupSize;
}
else { // just a normal traversal when we haven't hit our groupSize
prev = curr;
curr = curr.next;
++count;
}
}
if (count % 2 === 0) { // in the case where we ended early on even count
reverseList(start, null, count);
}
return head;
function reverseList(start, end, count) {
if (start.next == null) return start; // for case when we have a single node
let prev = start;
let curr = start.next;
let tail = start.next;
for (let i = 0; i < count; ++i) {
const next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
start.next = prev;
tail.next = end;
return ;
}
}; | Reverse Nodes in Even Length Groups |
There is a biker going on a road trip. The road trip consists of n + 1 points at different altitudes. The biker starts his trip on point 0 with altitude equal 0.
You are given an integer array gain of length n where gain[i] is the net gain in altitude between points i and i + 1 for all (0 <= i < n). Return the highest altitude of a point.
Example 1:
Input: gain = [-5,1,5,0,-7]
Output: 1
Explanation: The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.
Example 2:
Input: gain = [-4,-3,-2,-1,4,3,2]
Output: 0
Explanation: The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.
Constraints:
n == gain.length
1 <= n <= 100
-100 <= gain[i] <= 100
| class Solution:
def largestAltitude(self, gain: List[int]) -> int:
return max(accumulate([0]+gain)) | class Solution {
public int largestAltitude(int[] gain) {
int max_alt=0;
int curr_alt=0;
for(int i=0;i<gain.length;i++){
curr_alt+=gain[i];
max_alt=Math.max(curr_alt, max_alt);
}
return max_alt;
}
}
//TC: O(n), SC: O(1) | class Solution {
public:
int largestAltitude(vector<int>& gain) {
int maxAltitude = 0;
int currentAltitude = 0;
for (int i = 0; i < gain.size(); i++) {
currentAltitude += gain[i];
maxAltitude = max(maxAltitude, currentAltitude);
}
return maxAltitude;
}
}; | var largestAltitude = function(gain) {
let points = [0]
let highest = 0
for (let i = 0; i < gain.length; i++) {
let point = points[i] + gain[i]
points.push(point)
if (point > highest) highest = point
}
return highest
}; | Find the Highest Altitude |
You are given an integer n. You have an n x n binary grid grid with all values initially 1's except for some indices given in the array mines. The ith element of the array mines is defined as mines[i] = [xi, yi] where grid[xi][yi] == 0.
Return the order of the largest axis-aligned plus sign of 1's contained in grid. If there is none, return 0.
An axis-aligned plus sign of 1's of order k has some center grid[r][c] == 1 along with four arms of length k - 1 going up, down, left, and right, and made of 1's. Note that there could be 0's or 1's beyond the arms of the plus sign, only the relevant area of the plus sign is checked for 1's.
Example 1:
Input: n = 5, mines = [[4,2]]
Output: 2
Explanation: In the above grid, the largest plus sign can only be of order 2. One of them is shown.
Example 2:
Input: n = 1, mines = [[0,0]]
Output: 0
Explanation: There is no plus sign, so return 0.
Constraints:
1 <= n <= 500
1 <= mines.length <= 5000
0 <= xi, yi < n
All the pairs (xi, yi) are unique.
| class Solution:
def orderOfLargestPlusSign(self, n: int, mines: list[list[int]]) -> int:
matrix = [1] * n
aux = {}
hasOne = False
for i in range(0,n):
matrix[i] = [1] * n
for mine in mines:
matrix[mine[0]][mine[1]] = 0
for i in range(0,n):
for j in range(0,n):
if(matrix[i][j] == 1):
hasOne = True
if((i,j) not in aux):
aux[(i,j)] = {"t":0,"l":0,"r":0,"b":0}
if(j>0 and matrix[i][j] == 1 and matrix[i][j-1] == 1):
aux[(i,j)]["l"] = aux[(i,j-1)]["l"] + 1
if(i>0 and matrix[i][j] == 1 and matrix[i-1][j] == 1):
aux[(i,j)]["t"] = aux[(i-1,j)]["t"] + 1
maxOrder = 0
for i in range(n-1,-1,-1):
if(i<maxOrder):
break
for j in range(n-1,-1,-1):
if(j<maxOrder):
break
if(j<n-1 and matrix[i][j] == 1 and matrix[i][j+1] == 1):
aux[(i,j)]["r"] = aux[(i,j+1)]["r"] + 1
if(i<n-1 and matrix[i][j] == 1 and matrix[i+1][j]):
aux[(i,j)]["b"] = aux[(i+1,j)]["b"] + 1
maxOrder = max(min(aux[(i,j)]["b"],aux[(i,j)]["t"],aux[(i,j)]["r"],aux[(i,j)]["l"]),maxOrder)
print(maxOrder+1)
return maxOrder + 1 | class Solution {
public int orderOfLargestPlusSign(int n, int[][] mines) {
// Create the matrix
int[][] arr = new int[n][n];
for(int[] subArray : arr) {
Arrays.fill(subArray, 1);
}
for(int i = 0; i < mines.length; i++) {
arr[mines[i][0]][mines[i][1]] = 0;
}
// Prefix Count DP arrays
int[][] dpTop = new int[arr.length][arr.length];
int[][] dpLeft = new int[arr.length][arr.length];
int[][] dpRight = new int[arr.length][arr.length];
int[][] dpBottom = new int[arr.length][arr.length];
// Prefix count of 1 cells on top and left directions
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr.length; j++) {
if(i - 1 >= 0 && arr[i - 1][j] == 1) {
dpTop[i][j] = 1 + dpTop[i - 1][j];
}
if(j - 1 >= 0 && arr[i][j - 1] == 1) {
dpLeft[i][j] = 1 + dpLeft[i][j - 1];
}
}
}
// Prefix count of 1 cells on bottom and right directions
for(int i = arr.length - 1; i >= 0; i--) {
for(int j = arr.length - 1; j >= 0; j--) {
if(i + 1 < arr.length && arr[i + 1][j] == 1) {
dpBottom[i][j] = 1 + dpBottom[i + 1][j];
}
if(j + 1 < arr.length && arr[i][j + 1] == 1) {
dpRight[i][j] = 1 + dpRight[i][j + 1];
}
}
}
int maxPlusSignLength = 0;
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr.length; j++) {
if(arr[i][j] == 0) continue;
// Minimum adjacent 1 cell count from all four directions to ensure symmetry
int minAdjacentOnes = Math.min(Math.min(dpTop[i][j], dpBottom[i][j]), Math.min(dpLeft[i][j], dpRight[i][j]));
maxPlusSignLength = Math.max(maxPlusSignLength, minAdjacentOnes + 1);
}
}
return maxPlusSignLength;
}
} | class Solution {
public:
int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {
//jai shri ram
int ans=0;
vector<bool>block(25*int(1e4)+1,0);
vector<vector<int>>dp(n,vector<int>(n,0));
for(auto x:mines){
int a=x[0],b=x[1];
block[a*n+b]=true;
}
for(int i=0;i<n;i++){
int sum=0;
for(int j=0;j<n;j++){
if(block[i*n+j]){
sum=0;
}else {
sum+=1;
}
dp[i][j]=sum;
}
}
for(int j=0;j<n;j++){
int sum=0;
for(int i=0;i<n;i++){
if(block[i*n+j]){
sum=0;
}else sum+=1;
dp[i][j]=min(dp[i][j],sum);
}
}
for(int j=n-1;j>=0;j--){
int sum=0;
for(int i=n-1;i>=0;i--){
if(block[i*n+j]){
sum=0;
}else sum+=1;
dp[i][j]=min(dp[i][j],sum);
}
}
for(int i=n-1;i>=0;i--){
int sum=0;
for(int j=n-1;j>=0;j--){
if(block[i*n+j]){
sum=0;
}else sum+=1;
dp[i][j]=min(dp[i][j],sum);
ans=max(ans,dp[i][j]);
}
}
return ans;
}
}; | /**
* @param {number} n
* @param {number[][]} mines
* @return {number}
*/
var orderOfLargestPlusSign = function(n, mines) {
// create n * n as a table, and each grid fill the maximum number
const t = new Array(n).fill(0).map(() => new Array(n).fill(n));
// insert `0` to the grid in table according the position in mines
mines.forEach(a => t[a[0]][a[1]] = 0);
// loop each rows and cols
// - for rows: calculate non-zero grid from left to right
// - for cols: calculate non-zero grid from top to bottom
// - when the loop is completed, all of non-zero values will be calculated by four directions
// - and these grids value will be updated by comparing. then we can obtain the minimum value of the four directions caculation, which is the maximum of the grid
for (let i = 0; i < n; i++) {
// save the maximum value of non-zeros with for directions
let [l, r, u, d] = [0, 0, 0, 0];
// l: left, loop row i from left to right
// r: right, loop row i from right to left
// u: up, loop col i from top to bottom
// d: down, loop col i from bottom to top
for (let j = 0, k = n - 1; j < n; j++, k--) {
// if the value is `0`, then set variable to `0`, and indicates it's broken
l = t[i][j] && l + 1;
r = t[i][k] && r + 1;
u = t[j][i] && u + 1;
d = t[k][i] && d + 1;
// if current value is less than origin value
// one possibility: the origin value is default
// another possibility: the length of non-zero in a centain direction is langer than in the current direction, which the minimum value we need
if (l < t[i][j]) t[i][j] = l;
if (r < t[i][k]) t[i][k] = r;
if (u < t[j][i]) t[j][i] = u;
if (d < t[k][i]) t[k][i] = d;
}
}
// return maximum value be saved by all cells
return Math.max(...t.map(v => Math.max(...v)));
} | Largest Plus Sign |
You are given a 0-indexed integer array nums and a target element target.
A target index is an index i such that nums[i] == target.
Return a list of the target indices of nums after sorting nums in non-decreasing order. If there are no target indices, return an empty list. The returned list must be sorted in increasing order.
Example 1:
Input: nums = [1,2,5,2,3], target = 2
Output: [1,2]
Explanation: After sorting, nums is [1,2,2,3,5].
The indices where nums[i] == 2 are 1 and 2.
Example 2:
Input: nums = [1,2,5,2,3], target = 3
Output: [3]
Explanation: After sorting, nums is [1,2,2,3,5].
The index where nums[i] == 3 is 3.
Example 3:
Input: nums = [1,2,5,2,3], target = 5
Output: [4]
Explanation: After sorting, nums is [1,2,2,3,5].
The index where nums[i] == 5 is 4.
Constraints:
1 <= nums.length <= 100
1 <= nums[i], target <= 100
| class Solution:
def targetIndices(self, nums, target):
ans = []
for i,num in enumerate(sorted(nums)):
if num == target: ans.append(i)
return ans | class Solution {
/** Algorithm:
- Parse the array once and count how many are lesser than target and how many are equal
- DO NOT sort the array as we don't need it sorted.
Just to know how many are lesser and how many are equal. O(N) better than O(NlogN - sorting)
- The response list will have a size = with the number of equal elements (as their positions)
- Loop from smaller to smaller+equal and add the values into the list. Return the list
*/
public List<Integer> targetIndices(int[] nums, int target) {
int smaller = 0;
int equal = 0;
for (int num : nums) {
if (num < target) {
smaller++;
} else if (num == target) {
equal++;
}
}
List<Integer> indices = new ArrayList<>(equal);
for (int i = smaller; i < smaller + equal; i++) {
indices.add(i);
}
return indices;
}
} | class Solution {
public:
vector<int> targetIndices(vector<int>& nums, int target) {
vector<int> result;
sort(nums.begin(),nums.end());
for(int i=0;i<nums.size();i++){
if(nums[i]==target) result.push_back(i);
}
return result;
}
}; | function binarySearch(lists, sorted, low, high, target){
if(low > high) return;
const mid = low + Math.floor((high - low) / 2);
if(sorted[mid] === target){
lists.push(mid);
}
binarySearch(lists, sorted, low, mid-1, target);
binarySearch(lists, sorted, mid+1, high, target);
}
var targetIndices = function(nums, target) {
let result = [];
nums.sort((a,b)=>a-b);
if(!nums.includes(target)) return [];
binarySearch(result, nums, 0 , nums.length-1, target);
return result.sort((a,b) => a-b);
} | Find Target Indices After Sorting Array |
You have a set which contains all positive integers [1, 2, 3, 4, 5, ...].
Implement the SmallestInfiniteSet class:
SmallestInfiniteSet() Initializes the SmallestInfiniteSet object to contain all positive integers.
int popSmallest() Removes and returns the smallest integer contained in the infinite set.
void addBack(int num) Adds a positive integer num back into the infinite set, if it is not already in the infinite set.
Example 1:
Input
["SmallestInfiniteSet", "addBack", "popSmallest", "popSmallest", "popSmallest", "addBack", "popSmallest", "popSmallest", "popSmallest"]
[[], [2], [], [], [], [1], [], [], []]
Output
[null, null, 1, 2, 3, null, 1, 4, 5]
Explanation
SmallestInfiniteSet smallestInfiniteSet = new SmallestInfiniteSet();
smallestInfiniteSet.addBack(2); // 2 is already in the set, so no change is made.
smallestInfiniteSet.popSmallest(); // return 1, since 1 is the smallest number, and remove it from the set.
smallestInfiniteSet.popSmallest(); // return 2, and remove it from the set.
smallestInfiniteSet.popSmallest(); // return 3, and remove it from the set.
smallestInfiniteSet.addBack(1); // 1 is added back to the set.
smallestInfiniteSet.popSmallest(); // return 1, since 1 was added back to the set and
// is the smallest number, and remove it from the set.
smallestInfiniteSet.popSmallest(); // return 4, and remove it from the set.
smallestInfiniteSet.popSmallest(); // return 5, and remove it from the set.
Constraints:
1 <= num <= 1000
At most 1000 calls will be made in total to popSmallest and addBack.
| class SmallestInfiniteSet:
def __init__(self):
self.index = 1
self.heap = []
def popSmallest(self) -> int:
if self.heap:
return heapq.heappop(self.heap)
self.index += 1
return self.index-1
def addBack(self, num: int) -> None:
if self.index > num and num not in self.heap:
heapq.heappush(self.heap,num) | class SmallestInfiniteSet {
private PriorityQueue<Integer> q;
private int index;
public SmallestInfiniteSet() {
q = new PriorityQueue<Integer>();
index = 1;
}
public int popSmallest() {
if (q.size()>0){
return q.poll();
}
return index++;
}
private boolean is_in_q(int num){
for(int i : q){
if (i == num){
return true;
}
}
return false;
}
public void addBack(int num) {
if( num < index && !is_in_q(num)){
q.add(num);
}
}
} | class SmallestInfiniteSet {
public:
int cur;
set<int> s;
SmallestInfiniteSet() {
cur=1;
}
int popSmallest() {
if(s.size()){
int res=*s.begin(); s.erase(res);
return res;
}else{
cur+=1;
return cur-1;
}
}
void addBack(int num) {
if(cur>num) s.insert(num);
}
}; | var SmallestInfiniteSet = function() {
const s = new Set();
this.s = s;
for(let i = 1; i <= 1000; i++) s.add(i);
};
/**
* @return {number}
*/
SmallestInfiniteSet.prototype.popSmallest = function() {
const min = Math.min(...Array.from(this.s));
this.s.delete(min);
return min;
};
/**
* @param {number} num
* @return {void}
*/
SmallestInfiniteSet.prototype.addBack = function(num) {
this.s.add(num);
};
/**
* Your SmallestInfiniteSet object will be instantiated and called as such:
* var obj = new SmallestInfiniteSet()
* var param_1 = obj.popSmallest()
* obj.addBack(num)
*/ | Smallest Number in Infinite Set |
You are given an n x n binary grid board. In each move, you can swap any two rows with each other, or any two columns with each other.
Return the minimum number of moves to transform the board into a chessboard board. If the task is impossible, return -1.
A chessboard board is a board where no 0's and no 1's are 4-directionally adjacent.
Example 1:
Input: board = [[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]
Output: 2
Explanation: One potential sequence of moves is shown.
The first move swaps the first and second column.
The second move swaps the second and third row.
Example 2:
Input: board = [[0,1],[1,0]]
Output: 0
Explanation: Also note that the board with 0 in the top left corner, is also a valid chessboard.
Example 3:
Input: board = [[1,0],[1,0]]
Output: -1
Explanation: No matter what sequence of moves you make, you cannot end with a valid chessboard.
Constraints:
n == board.length
n == board[i].length
2 <= n <= 30
board[i][j] is either 0 or 1.
| class Solution(object):
def movesToChessboard(self, board):
N = len(board)
ans = 0
# For each count of lines from {rows, columns}...
for count in (collections.Counter(map(tuple, board)), # get row
collections.Counter(zip(*board))): #get column
# If there are more than 2 kinds of lines,
# or if the number of kinds is not appropriate ...
if len(count) != 2 or sorted(count.values()) != [N/2, (N+1)/2]:
return -1
# If the lines are not opposite each other, impossible
line1, line2 = count
if not all(x ^ y for x, y in zip(line1, line2)):
return -1
# starts = what could be the starting value of line1
# If N is odd, then we have to start with the more
# frequent element
starts = [int(line1.count(1) * 2 > N)] if N%2 else [0, 1]
# To transform line1 into the ideal line [i%2 for i ...],
# we take the number of differences and divide by two
ans += min(sum((x-i) % 2 for i, x in enumerate(line1, start))
for start in starts) / 2
return ans | class Solution {
public int movesToChessboard(int[][] board) {
int N = board.length, colToMove = 0, rowToMove = 0, rowOneCnt = 0, colOneCnt = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (((board[0][0] ^ board[i][0]) ^ (board[i][j] ^ board[0][j])) == 1) {
return -1;
}
}
}
for (int i = 0; i < N; i++) {
rowOneCnt += board[0][i];
colOneCnt += board[i][0];
if (board[i][0] == i % 2) {
rowToMove++;
}
if (board[0][i] == i % 2) {
colToMove++;
}
}
if (rowOneCnt < N / 2 || rowOneCnt > (N + 1) / 2) {
return -1;
}
if (colOneCnt < N / 2 || colOneCnt > (N + 1) / 2) {
return -1;
}
if (N % 2 == 1) {
// we cannot make it when ..ToMove is odd
if (colToMove % 2 == 1) {
colToMove = N - colToMove;
}
if (rowToMove % 2 == 1) {
rowToMove = N - rowToMove;
}
} else {
colToMove = Math.min(colToMove, N - colToMove);
rowToMove = Math.min(rowToMove, N - rowToMove);
}
return (colToMove + rowToMove) / 2;
}
} | class Solution {
const int inf = 1e9;
void transpose(vector<vector<int>>& board) {
const int n = board.size();
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
swap(board[i][j], board[j][i]);
}
bool isSame(vector<int> &r1, vector<int>& r2) {
const int n = r1.size();
for (int i = 0; i < n; i++)
if (r1[i] != r2[i])
return false;
return true;
}
bool isOpposite(vector<int> &r1, vector<int>& r2) {
const int n = r1.size();
for (int i = 0; i < n; i++)
if (r1[i] == r2[i])
return false;
return true;
}
int getSteps(vector<vector<int>> &&confusionMatrix) {
int steps = inf;
if (confusionMatrix[0][1] == confusionMatrix[1][0])
steps = confusionMatrix[0][1];
if (confusionMatrix[0][0] == confusionMatrix[1][1])
steps = min(steps, confusionMatrix[0][0]);
return steps;
}
vector<vector<int>> getConfusionMatrix(vector<int>& rowType) {
const int n = rowType.size();
vector<vector<int>> confusionMatrix(2, vector<int>(2, 0));
for (int i = 0; i < n; i++)
confusionMatrix[rowType[i]][i & 1]++;
return confusionMatrix;
}
int solve1d(vector<int> &arr) {
return getSteps(getConfusionMatrix(arr));
}
int makeColumnsAlternating(vector<vector<int>>& board) {
const int n = board.size();
vector<int> rowType(n, 0);
for (int i = 1; i < n; i++)
if (isOpposite(board[0], board[i]))
rowType[i] = 1;
else if (!isSame(board[0], board[i]))
return inf;
return solve1d(rowType);
}
public:
int movesToChessboard(vector<vector<int>>& board) {
int steps = makeColumnsAlternating(board);
transpose(board);
steps += makeColumnsAlternating(board);
if (steps >= inf)
return -1;
return steps;
}
}; | /**
* @param {number[][]} board
* @return {number}
*/
var movesToChessboard = function(board) {
const boardSize = board.length;
const boardSizeIsEven = boardSize % 2 === 0;
if(!canBeTransformed(board)) return -1;
// to convert to 010101
let rowSwap = 0;
let colSwap = 0;
// to convert to 101010
let rowSwap2 = 0;
let colSwap2 = 0;
for(let i=0; i<boardSize; i++) {
if(board[i][0] === i % 2) {
rowSwap++;
} else {
rowSwap2++;
}
if(board[0][i] === i % 2) {
colSwap++;
} else {
colSwap2++;
}
}
// no need to swap anything
if((rowSwap + colSwap) === 0 || (rowSwap2 + colSwap2) === 0) return 0;
if(boardSizeIsEven) {
rowSwap = Math.min(rowSwap, rowSwap2);
colSwap = Math.min(colSwap, colSwap2);
} else {
rowSwap = rowSwap % 2 === 0 ? rowSwap : rowSwap2;
colSwap = colSwap % 2 === 0 ? colSwap : colSwap2;
}
return (rowSwap + colSwap) / 2;
function canBeTransformed(board) {
// number of 0 and 1 should be equal
let sum = board[0].reduce((a,b) => a+b);
if(boardSizeIsEven && sum != boardSize/2) return false;
if(!boardSizeIsEven && sum > ((boardSize + 1)/2)) return false;
let first = board[0].join('');
let opposite = board[0].map((item) => item === 1 ? 0 : 1).join('');
// each row should be equal to first or opposite
let counter = [0,0];
for(let i=0; i<boardSize; i++) {
let str = board[i].join('');
if(str == first) {
counter[0]++;
} else if(str == opposite) {
counter[1]++;
} else {
return false;
}
}
// for even board, two types of rows should be equal
if(boardSizeIsEven) {
return counter[0] == counter[1];
}
return Math.abs(counter[0] - counter[1]) === 1
}
}; | Transform to Chessboard |
There is a tree (i.e., a connected, undirected graph that has no cycles) consisting of n nodes numbered from 0 to n - 1 and exactly n - 1 edges. Each node has a value associated with it, and the root of the tree is node 0.
To represent this tree, you are given an integer array nums and a 2D array edges. Each nums[i] represents the ith node's value, and each edges[j] = [uj, vj] represents an edge between nodes uj and vj in the tree.
Two values x and y are coprime if gcd(x, y) == 1 where gcd(x, y) is the greatest common divisor of x and y.
An ancestor of a node i is any other node on the shortest path from node i to the root. A node is not considered an ancestor of itself.
Return an array ans of size n, where ans[i] is the closest ancestor to node i such that nums[i] and nums[ans[i]] are coprime, or -1 if there is no such ancestor.
Example 1:
Input: nums = [2,3,3,2], edges = [[0,1],[1,2],[1,3]]
Output: [-1,0,0,1]
Explanation: In the above figure, each node's value is in parentheses.
- Node 0 has no coprime ancestors.
- Node 1 has only one ancestor, node 0. Their values are coprime (gcd(2,3) == 1).
- Node 2 has two ancestors, nodes 1 and 0. Node 1's value is not coprime (gcd(3,3) == 3), but node 0's
value is (gcd(2,3) == 1), so node 0 is the closest valid ancestor.
- Node 3 has two ancestors, nodes 1 and 0. It is coprime with node 1 (gcd(3,2) == 1), so node 1 is its
closest valid ancestor.
Example 2:
Input: nums = [5,6,10,2,3,6,15], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]
Output: [-1,0,-1,0,0,0,-1]
Constraints:
nums.length == n
1 <= nums[i] <= 50
1 <= n <= 105
edges.length == n - 1
edges[j].length == 2
0 <= uj, vj < n
uj != vj
| class Solution:
def getCoprimes(self, nums: List[int], edges: List[List[int]]) -> List[int]:
gcdset = [set() for i in range(51)]
for i in range(1,51):
for j in range(1,51):
if math.gcd(i,j) == 1:
gcdset[i].add(j)
gcdset[j].add(i)
graph = defaultdict(list)
for v1, v2 in edges:
graph[v1].append(v2)
graph[v2].append(v1)
ans = [-1]*len(nums)
q = [[0, {}]]
seen = set([0])
depth = 0
while q:
temp = []
for node, ancestors in q:
index_depth = (-1,-1)
for anc in list(ancestors.keys()):
if anc in gcdset[nums[node]]:
index, d = ancestors[anc]
if d > index_depth[1]:
index_depth = (index,d)
ans[node] = index_depth[0]
copy = ancestors.copy()
copy[nums[node]] = (node,depth)
for child in graph[node]:
if child not in seen:
seen.add(child)
temp.append([child, copy])
q = temp
depth += 1
return ans | class Solution {
//made TreeNode class for simple implementation in recurring function
class TreeNode{
int id;
int val;
List<TreeNode> child;
public TreeNode(int id,int val){
this.id=id;this.val=val;child=new ArrayList<>();
}
}
public int[] getCoprimes(int[] nums, int[][] edges) {
// making tree/graph with edges
TreeNode[] tr=new TreeNode[nums.length];
for(int i=0;i<nums.length;i++)tr[i]=new TreeNode(i,nums[i]);
for(int []x:edges){
tr[x[0]].child.add(tr[x[1]]);
tr[x[1]].child.add(tr[x[0]]);
}
// intializing answer array of length of tree's nodes which we will return
int [] ans=new int[nums.length];
Arrays.fill(ans,-1);
//creating gcd to not compute gcd everytime
boolean [][] gcd=new boolean[51][51];
for(int i=1;i<=50;i++){
for(int j=i;j<=50;j++){
if(find_gcd(i,j)==1){
gcd[i][j]=true;
gcd[j][i]=true;
}
}
}
int [][] latest= new int[51][2];
//instead of latest[][] as 2d array we can also use 2 arrays, one for who is latest ancestor & one for storing id
// in [][0] we will store height of tree so latest ancestor will be called
// in [][1] we will store id of latest tree
// initializing all to -1
for(int i=0;i<=50;i++){latest[i][0]=-1;latest[i][1]=-1;}
find_closest_ancestor(tr[0],new TreeNode(-1,-1),ans,latest,gcd,0);
return ans;
}
public void find_closest_ancestor(TreeNode root,TreeNode parent, int[] ans,int [][] latest, boolean [][] gcd, int height){
int val=root.val;
int latest_id=0;
for(int i=1;i<=50;i++){
//if gcd [val][i] is true & latest[i][0] is latest ancestor i.e. it's height is more then save that id
if(gcd[val][i] && latest[latest_id][0] < latest[i][0])latest_id=i;
}
ans[root.id]=latest[latest_id][1];// even if no latest ancestor found latest[id][1] is -1 by default
//this is must we will save before state & after calling all it's child we will make it as it was before calling
//like backtracking
int pre_height = latest[val][0],pre_id = latest[val][1];
latest[val][0]=height; latest[val][1]=root.id;
// we recur with all child
for(TreeNode root_child: root.child){
// we will check if we aren't going upward in tree so root.child!=parent then call function
if(root_child!=parent)find_closest_ancestor(root_child,root,ans,latest,gcd,height+1);
}
//as it was before we will put it back
latest[val][0]=pre_height; latest[val][1]=pre_id;
}
//simple gcd code
public int find_gcd(int a, int b){
if(b==0)return a;
return find_gcd(b,a%b);
}
} | class Solution {
public:
vector<int> adj[100009];
vector<int> d[55];
int dis[100009];
void dfs(vector<int>& nums,vector<int> &ans,int i,int p,int h1)
{
int h=nums[i];
dis[i]=h1;
ans[i]=-1;
int val=-1;
for(int w=1;w<=50;w++)
{
if(__gcd(h,w)==1)
{
if(d[w].size())
{
int u=d[w].back();
if(dis[u]>val)
{
val=dis[u];
ans[i]=u;
}
}
}
}
d[h].push_back(i);
for(auto x:adj[i])
{
if(x==p) continue;
dfs(nums,ans,x,i,h1+1);
}
d[h].pop_back();
}
vector<int> getCoprimes(vector<int>& nums, vector<vector<int>>& edges) {
int n=nums.size();
for(int i=0;i<n;i++)
{
adj[i].clear();
}
for(int i=0;i<n-1;i++)
{
adj[edges[i][0]].push_back(edges[i][1]);
adj[edges[i][1]].push_back(edges[i][0]);
}
vector<int> ans(n);
dfs(nums,ans,0,-1,0);
return ans;
}
}; | var getCoprimes = function(nums, edges) {
const node = {}
const ans = Array(nums.length).fill(null)
function addNode(f, t){
if(!node[f]){
node[f]=[]
}
node[f].push(t)
}
edges.forEach(([f, t])=>{
addNode(f, t)
addNode(t, f)
})
function gcd(a, b){
while(b) [a, b] = [b, a % b];
return a;
}
const map = []
for(let i=0; i<51; i++){
map[i]=[]
for(let j=0; j<51; j++){
map[i][j]= gcd(i,j)
}
}
let pi=-1
let path=Array(nums.length)
function check(v){
if(ans[v]!==null) return
ans[v] = -1
let a = nums[v]
for(let k=pi; k>=0; k--){
let b = nums[path[k]]
if(map[a][b]===1){
ans[v]=path[k]
break
}
}
if(node[v]) {
path[++pi]=v
node[v].forEach(child=>check(child))
pi--
}
}
for(let i=0; i<nums.length; i++){
check(i)
}
return ans
}; | Tree of Coprimes |
You are given an integer n indicating there are n specialty retail stores. There are m product types of varying amounts, which are given as a 0-indexed integer array quantities, where quantities[i] represents the number of products of the ith product type.
You need to distribute all products to the retail stores following these rules:
A store can only be given at most one product type but can be given any amount of it.
After distribution, each store will have been given some number of products (possibly 0). Let x represent the maximum number of products given to any store. You want x to be as small as possible, i.e., you want to minimize the maximum number of products that are given to any store.
Return the minimum possible x.
Example 1:
Input: n = 6, quantities = [11,6]
Output: 3
Explanation: One optimal way is:
- The 11 products of type 0 are distributed to the first four stores in these amounts: 2, 3, 3, 3
- The 6 products of type 1 are distributed to the other two stores in these amounts: 3, 3
The maximum number of products given to any store is max(2, 3, 3, 3, 3, 3) = 3.
Example 2:
Input: n = 7, quantities = [15,10,10]
Output: 5
Explanation: One optimal way is:
- The 15 products of type 0 are distributed to the first three stores in these amounts: 5, 5, 5
- The 10 products of type 1 are distributed to the next two stores in these amounts: 5, 5
- The 10 products of type 2 are distributed to the last two stores in these amounts: 5, 5
The maximum number of products given to any store is max(5, 5, 5, 5, 5, 5, 5) = 5.
Example 3:
Input: n = 1, quantities = [100000]
Output: 100000
Explanation: The only optimal way is:
- The 100000 products of type 0 are distributed to the only store.
The maximum number of products given to any store is max(100000) = 100000.
Constraints:
m == quantities.length
1 <= m <= n <= 105
1 <= quantities[i] <= 105
| class Solution:
def minimizedMaximum(self, n: int, quantities: List[int]) -> int:
def cond(m, n):
return sum([(q // m) + (q % m > 0) for q in quantities]) <= n
l, r = 1, max(quantities)
while l < r:
m = (l + r) // 2
if cond(m, n):
r = m
else:
l = m + 1
return l | class Solution {
public int minimizedMaximum(int n, int[] quantities) {
int lo = 1;
int hi = (int)1e5;
int ans = -1;
while(lo <= hi){
int mid = (lo + hi)/2;
if(isItPossible(mid, quantities, n)){
ans = mid;
hi = mid-1;
}else{
lo = mid+1;
}
}
return ans;
}
private boolean isItPossible(int x, int[] quantities, int n){
// isItPossible to distribute <= x products to each of the n shops
for(int i=0; i<quantities.length; i++){
int products = quantities[i];
n -= Math.ceil(products/(x*1.0));
if(n<0) // means it requires more than n shops to distribute all products
return false;
}
return true; // distributed all products to exactly n shops
}
} | class Solution {
public:
bool func(int N, int n, vector<int>& quantities){
int temp = 0;
for(int id = 0; temp <= n && id != quantities.size(); id++)
temp += quantities[id] / N + (quantities[id] % N ? 1 : 0);
return temp <= n;
}
int minimizedMaximum(int n, vector<int>& quantities) {
int l = 1, r = *max_element(quantities.begin(), quantities.end());
for(int m = (l + r)>>1; l <= r; m = (l + r)>>1)
func(m, n , quantities) ? r = m - 1 : l = m + 1;
return l;
}
}; | var minimizedMaximum = function(n, quantities) {
const MAX = Number.MAX_SAFE_INTEGER;
const m = quantities.length;
let left = 1;
let right = quantities.reduce((acc, num) => acc + num, 0);
let minRes = MAX;
while (left <= right) {
const mid = (left + right) >> 1;
if (canDistribute(mid)) {
minRes = Math.min(minRes, mid);
right = mid - 1;
}
else {
left = mid + 1;
}
}
return minRes;
function canDistribute(minGiven) {
const clonedQ = [...quantities];
let j = 0;
let i = 0;
for (; i < n && j < m; ++i) {
const remQ = clonedQ[j];
if (remQ > minGiven) {
clonedQ[j] -= minGiven;
}
else {
++j;
}
}
return j === m;
}
}; | Minimized Maximum of Products Distributed to Any Store |
Given a singly linked list, return a random node's value from the linked list. Each node must have the same probability of being chosen.
Implement the Solution class:
Solution(ListNode head) Initializes the object with the head of the singly-linked list head.
int getRandom() Chooses a node randomly from the list and returns its value. All the nodes of the list should be equally likely to be chosen.
Example 1:
Input
["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"]
[[[1, 2, 3]], [], [], [], [], []]
Output
[null, 1, 3, 2, 2, 3]
Explanation
Solution solution = new Solution([1, 2, 3]);
solution.getRandom(); // return 1
solution.getRandom(); // return 3
solution.getRandom(); // return 2
solution.getRandom(); // return 2
solution.getRandom(); // return 3
// getRandom() should return either 1, 2, or 3 randomly. Each element should have equal probability of returning.
Constraints:
The number of nodes in the linked list will be in the range [1, 104].
-104 <= Node.val <= 104
At most 104 calls will be made to getRandom.
Follow up:
What if the linked list is extremely large and its length is unknown to you?
Could you solve this efficiently without using extra space?
| class Solution:
def __init__(self, head: Optional[ListNode]):
self.lst = []
while head:
self.lst.append(head.val)
head = head.next
def getRandom(self) -> int:
return random.choice(self.lst) | class Solution {
int N = 0;
ListNode head = null;
public Solution(ListNode head) {
this.head = head;
}
public int getRandom() {
ListNode p = this.head;
int i = 1, ans = 0;
while (p != null) {
if (Math.random() * i < 1) ans = p.val; // replace ans with i-th node.val with probability 1/i
p = p.next;
i ++;
}
return ans;
}
} | /**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
vector<int>v;
Solution(ListNode* head) {
while(head!=NULL) {
v.push_back(head->val);
head=head->next;
}
}
int getRandom() {
return v[rand()%v.size()];
}
};
/**
* Your Solution object will be instantiated and called as such:
* Solution* obj = new Solution(head);
* int param_1 = obj->getRandom();
*/ | var Solution = function(head) {
this.res = [];
let curr = head;
while(curr !== null) {
this.res.push(curr)
curr = curr.next;
}
this.length = this.res.length;
};
Solution.prototype.getRandom = function() {
//Math.random() will generate a random number b/w 0 & 1.
//then multiply it with the array size, as i have all the value in the list, i know the size of the list
//take only the integer part which is a random index.
//return the element at that random index.
return this.res[Math.floor(Math.random() * this.length)].val
}; | Linked List Random Node |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters.
| from itertools import combinations
class Solution:
def createNewWord(self, wordList) :
ans = ''
for word in wordList :
ans += word
charList = [i for i in ans]
return charList
def maxScoreWords(self, words: List[str], letters: List[str], score: List[int]) -> int:
score_dict = {}
ord_a = 97
for i in range(len(score)) :
score_dict[chr(ord_a + i)] = score[i]
max_count, sum_list, to_remove = 0, [], []
for word in words :
char_list = [i for i in word]
max_num = 0
for char in set(char_list) :
if char_list.count(char) > letters.count(char) :
max_num = 0
to_remove.append(word)
break
else :
max_num += score_dict[char]*char_list.count(char)
if max_num > 0 :
sum_list.append(max_num)
if max_num > max_count :
max_count = max_num
new_word = [i for i in words if i not in to_remove]
# print(new_word)
for i in range(2, len(sum_list)+1) :
comb = combinations(new_word, i)
for c in comb :
combinedWord = self.createNewWord(c)
totalNum = 0
for char in set(combinedWord) :
if combinedWord.count(char) > letters.count(char) :
totalNum = 0
break
else :
totalNum += score_dict[char]*combinedWord.count(char)
if totalNum > max_count :
max_count = totalNum
return max_count | class Solution {
int[] memo;
public int maxScoreWords(String[] words, char[] letters, int[] score) {
memo = new int[words.length];
Arrays.fill(memo,-1);
HashMap<Character,Integer> hm = new HashMap<>();
for(char c : letters){
int t = hm.getOrDefault(c,0);
t++;
hm.put(c,t);
}
//return dp(words,hm,score,0,0);
int res = dp(words,hm,score,0,0);
//for(int i : memo) System.out.println(i);
return res;
}
public int dp(String[] words, Map<Character,Integer> hm, int[] score, int index, int cs){//cs-current Score
if(index==words.length) return cs;
if(memo[index]!=-1) return memo[index];
HashMap<Character,Integer> temp = new HashMap<>(hm);
int tcs=cs; //tcs = temporory current score
for(char c : words[index].toCharArray()){
int t = temp.getOrDefault(c,0);
t--;
if(t<0){
return dp(words,hm,score,index+1,cs);
// memo[index] = dp(words,hm,score,index+1,cs);
// return memo[index];
}
tcs+=score[c-'a'];
temp.put(c,t);
}
return Math.max(dp(words,hm,score,index+1,cs),dp(words,temp,score,index+1,tcs));
// memo[index] = Math.max(dp(words,hm,score,index+1,cs),dp(words,temp,score,index+1,tcs));
// return memo[index];
}
} | class Solution {
public:
int calc(vector<string>& words,map<char,int>&m,vector<int>& score,int i){
int maxi=0;
if(i==words.size())
return 0;
map<char,int>m1=m;//Creating a duplicate in case the given word does not satisfy our answer
int c=0;//Store the score
for(int j=0;j<words[i].length();j++){
if(m1.find(words[i][j])==m1.end()||m1[words[i][j]]==0){//If frequency of the letter reduces to zero or that letter is not present in our hashMap
c=-1;
break;
}
c+=score[words[i][j]-'a'];
m1[words[i][j]]--;
}
if(c!=-1)
maxi=c+(calc(words,m1,score,i+1));//We are considering the current word and adding it to our answer
return max(maxi,calc(words,m,score,i+1));//FInding tha maximum between when we consider the current word and when we DONT consider current word
}
int maxScoreWords(vector<string>& words, vector<char>& letters, vector<int>& score) {
map<char,int>m;
for(auto i:letters)
m[i]++;
return calc(words,m,score,0);
}
}; | var maxScoreWords = function(words, letters, score) {
// unique chars
let set = new Set();
for (let w of words)
for (let c of w)
set.add(c)
// score of unique chars
let map = new Map();
for (let c of set)
map.set(c, score[c.charCodeAt() - 'a'.charCodeAt()])
// letter count
let map_letters = new Map();
for (let c of letters)
map_letters.set(c, map_letters.has(c) ? map_letters.get(c) + 1 : 1);
// score of words
let SW = [];
for (let w of words) {
let s = 0;
for (let c of w)
s += map.get(c)
SW.push(s)
}
const sortStr = (s) => s.split("").sort().join("")
const combineStrings_fromArrayAndIndexes = (A, I) => I.reduce((s, i) => (s + A[i]), '')
const getFreqMapFromStr = (s) => s.split("").reduce((m, c) => (m.set(c, m.has(c) ? m.get(c) + 1 : 1), m), new Map())
const isMapSubOfAnotherMap = (m1, m2) => {
for (let [c, count] of m1)
if (!m2.has(c) || count > m2.get(c))
return false
return true
}
let max1 = -Infinity;
const takeOrNot = (i, take, indexes, A, n) => {
if (i === n) {
if (isMapSubOfAnotherMap(
getFreqMapFromStr(
combineStrings_fromArrayAndIndexes(words, indexes)
),
map_letters
)) {
let mm = indexes.reduce((sum, i) => sum + SW[i], 0)
max1 = Math.max(max1, mm);
}
return
}
takeOrNot(i + 1, take, indexes, A, n)
takeOrNot(i + 1, take, [...indexes, i], A, n);
}
takeOrNot(0, true, [], SW, SW.length);
return max1;
}; | Maximum Score Words Formed by Letters |
You are given a string s and array queries where queries[i] = [lefti, righti, ki]. We may rearrange the substring s[lefti...righti] for each query and then choose up to ki of them to replace with any lowercase English letter.
If the substring is possible to be a palindrome string after the operations above, the result of the query is true. Otherwise, the result is false.
Return a boolean array answer where answer[i] is the result of the ith query queries[i].
Note that each letter is counted individually for replacement, so if, for example s[lefti...righti] = "aaa", and ki = 2, we can only replace two of the letters. Also, note that no query modifies the initial string s.
Example :
Input: s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
Output: [true,false,false,true,true]
Explanation:
queries[0]: substring = "d", is palidrome.
queries[1]: substring = "bc", is not palidrome.
queries[2]: substring = "abcd", is not palidrome after replacing only 1 character.
queries[3]: substring = "abcd", could be changed to "abba" which is palidrome. Also this can be changed to "baab" first rearrange it "bacd" then replace "cd" with "ab".
queries[4]: substring = "abcda", could be changed to "abcba" which is palidrome.
Example 2:
Input: s = "lyb", queries = [[0,1,0],[2,2,1]]
Output: [false,true]
Constraints:
1 <= s.length, queries.length <= 105
0 <= lefti <= righti < s.length
0 <= ki <= s.length
s consists of lowercase English letters.
| class Solution:
def canMakePaliQueries(self, s: str, queries: List[List[int]]) -> List[bool]:
hash_map = {s[0]: 1}
x = hash_map
prefix = [hash_map]
for i in range(1, len(s)):
x = x.copy()
x[s[i]] = x.get(s[i], 0) + 1
prefix.append(x)
result = []
for query in queries:
cnt = 0
for key, value in prefix[query[1]].items():
if query[0] > 0:
x = value - prefix[query[0]-1].get(key, 0)
else:
x = value
if x % 2:
cnt+=1
if cnt - 2 * query[2] > 1:
result.append(False)
else:
result.append(True)
return result | class Solution
{
public List<Boolean> canMakePaliQueries(String s, int[][] queries)
{
List<Boolean> list = new ArrayList<>();
int n = s.length();
int[][] map = new int[n+1][26];
for(int i=0;i<s.length();i++)
{
for(int j=0;j<26;j++)
map[i+1][j] = map[i][j];
map[i+1][s.charAt(i) - 'a']++;
}
for(int[] q : queries)
{
int l = q[0];
int r = q[1];
int k = q[2];
int count = 0;
for(int i=0;i<26;i++)
count += (map[r+1][i] - map[l][i]) % 2;
list.add(count/2 <= k);
}
return list;
}
} | class Solution {
public:
vector<bool> canMakePaliQueries(string s, vector<vector<int>>& queries) {
vector<vector<int>>table(s.size(), vector<int>(26,0));
vector<bool>ans;
table[0][s[0]-'a']++;
for(int i = 1; i != s.size(); i++){
for(int j = 0; j != 26; j++) table[i][j] = table[i-1][j];
table[i][s[i]-'a']++;
}
for(auto &q: queries){
int odd = 2 + (q[2]<<1);
for(int i = 0; i != 26; i++){
int val = table[q[1]][i] - (q[0] ? table[q[0]-1][i] : 0);
if( (val & 1) && --odd == 0){ans.push_back(false); goto mark;}
}
ans.push_back(true);
mark:;
}
return ans;
}
}; | const getBitCount = (n) => {
let cnt = 0;
while(n > 0) {
cnt += n & 1;
n >>= 1;
}
return cnt;
}
var canMakePaliQueries = function(s, queries) {
const masks = [0], base = 'a'.charCodeAt(0);
let mask = 0;
for(let c of s) {
mask ^= (1 << (c.charCodeAt(0) - base));
masks.push(mask);
}
return queries.map(([l, r, k]) => {
const cnt = getBitCount(masks[l] ^ masks[r+1]);
return cnt - 1 <= 2 * k
});
}; | Can Make Palindrome from Substring |
You are given a string text. You should split it to k substrings (subtext1, subtext2, ..., subtextk) such that:
subtexti is a non-empty string.
The concatenation of all the substrings is equal to text (i.e., subtext1 + subtext2 + ... + subtextk == text).
subtexti == subtextk - i + 1 for all valid values of i (i.e., 1 <= i <= k).
Return the largest possible value of k.
Example 1:
Input: text = "ghiabcdefhelloadamhelloabcdefghi"
Output: 7
Explanation: We can split the string on "(ghi)(abcdef)(hello)(adam)(hello)(abcdef)(ghi)".
Example 2:
Input: text = "merchant"
Output: 1
Explanation: We can split the string on "(merchant)".
Example 3:
Input: text = "antaprezatepzapreanta"
Output: 11
Explanation: We can split the string on "(a)(nt)(a)(pre)(za)(tep)(za)(pre)(a)(nt)(a)".
Constraints:
1 <= text.length <= 1000
text consists only of lowercase English characters.
| class Solution:
def longestDecomposition(self, text: str) -> int:
left, right = 0, len(text) - 1
sol, last_left = 0, 0
a, b = deque(), deque()
while right > left:
a.append(text[left])
b.appendleft(text[right])
if a == b:
sol += 2
last_left = left
a, b = deque(), deque()
right -= 1
left += 1
if left == right or left > last_left + 1:
sol += 1
return max(sol, 1) | class Solution {
public int longestDecomposition(String text) {
int n = text.length();
for (int i = 0; i < n/2; i++)
if (text.substring(0, i + 1).equals(text.substring(n-1-i, n)))
return 2+longestDecomposition(text.substring(i+1, n-1-i));
return (n==0)?0:1;
}
} | class Solution {
public:
int longestDecomposition(string text) {
if(text.size() == 0)
return 0;
int i = 0;
deque<char> sFront;
deque<char> sBack;
while(i < text.size() / 2){
sFront.push_back(text[i]);
sBack.push_front(text[text.size() - 1 - i]);
if(sFront == sBack)
return 2 + longestDecomposition(text.substr(i + 1, text.size() - 2*(i+1)));
i++;
}
return 1;
}
}; | var longestDecomposition = function(text) {
var i = 1
var output = 0
while(i < text.length)
{
if(text.substring(0,i) == text.substring(text.length-i))
{
output += 2 //add 2 to simulate adding to both sides of output array
text = text.substring(i,text.length-i) //cut text to simulate popping off of both sides
i=1
} else {
i++
}
}
return text ? output + 1 : output //if there's any text leftover that didn't have a match, it's the middle and would add 1 to output array
} | Longest Chunked Palindrome Decomposition |
You are given the root of a binary tree containing digits from 0 to 9 only.
Each root-to-leaf path in the tree represents a number.
For example, the root-to-leaf path 1 -> 2 -> 3 represents the number 123.
Return the total sum of all root-to-leaf numbers. Test cases are generated so that the answer will fit in a 32-bit integer.
A leaf node is a node with no children.
Example 1:
Input: root = [1,2,3]
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.
Example 2:
Input: root = [4,9,0,5,1]
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.
Constraints:
The number of nodes in the tree is in the range [1, 1000].
0 <= Node.val <= 9
The depth of the tree will not exceed 10.
| # Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def sumNumbers(self, root: Optional[TreeNode]) -> int:
int_list = []
def traverse(node, input_string):
nonlocal int_list
if not node:
return int_list
input_string = input_string + str(node.val)
if not (node.left or node.right):
int_list.append(int(input_string))
traverse(node.left, input_string)
traverse(node.right, input_string)
traverse(root, "")
return sum(int_list)
| class Solution {
int res;
public int sumNumbers(TreeNode root) {
res = 0;
getSum(root, 0);
return res;
}
public void getSum(TreeNode root, int sum){
if(root.left == null && root.right == null) {
res += (sum*10+root.val);
}
if(root.left != null)
getSum(root.left, sum*10+root.val);
if(root.right != null)
getSum(root.right, sum*10+root.val);
}
} | class Solution {
public:
int ans=0;
void dfs(TreeNode* root, string s){
if(!root->left && !root->right){
s+=to_string(root->val);
ans+=stoi(s);
return;
}
string o = s;
s+=to_string(root->val);
if(root->left) dfs(root->left,s);
if(root->right) dfs(root->right,s);
s=o;
}
int sumNumbers(TreeNode* root) {
if(!root) return ans;
string s = "";
dfs(root,s);
return ans;
}
}; | /**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number}
*/
var sumNumbers = function(root) {
return dfs(root)
};
const dfs = (root, path = '') => {
if (!root.left && !root.right) return +(path + root.val)
const left = root.left ? dfs(root.left, path + root.val) : 0
const right = root.right ? dfs(root.right, path + root.val) : 0
return left + right
} | Sum Root to Leaf Numbers |
Given an integer array nums and two integers k and t, return true if there are two distinct indices i and j in the array such that abs(nums[i] - nums[j]) <= t and abs(i - j) <= k.
Example 1:
Input: nums = [1,2,3,1], k = 3, t = 0
Output: true
Example 2:
Input: nums = [1,0,1,1], k = 1, t = 2
Output: true
Example 3:
Input: nums = [1,5,9,1,5,9], k = 2, t = 3
Output: false
Constraints:
1 <= nums.length <= 2 * 104
-231 <= nums[i] <= 231 - 1
0 <= k <= 104
0 <= t <= 231 - 1
| from sortedcontainers import SortedList
class Solution:
def containsNearbyAlmostDuplicate(self, nums, k, t):
sl = SortedList()
for i in range(len(nums)):
if i > k: sl.remove(nums[i-k-1])
idxl = sl.bisect_left(nums[i]-t)
idxr = sl.bisect_right(nums[i]+t)
if idxl != idxr: return True
sl.add(nums[i])
return False | /**
* Sliding Window solution using Buckets
*
* Time Complexity: O(N)
*
* Space Complexity: O(min(N, K+1))
*
* N = Length of input array. K = Input difference between indexes.
*/
class Solution {
public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
if (nums == null || nums.length < 2 || k < 1 || t < 0) {
return false;
}
HashMap<Long, Long> buckets = new HashMap<>();
// The bucket size is t+1 as the ranges are from 0..t, t+1..2t+1, ..
long bucketSize = (long) t + 1;
for (int i = 0; i < nums.length; i++) {
// Making sure only K buckets exists in map.
if (i > k) {
long lastBucket = ((long) nums[i - k - 1] - Integer.MIN_VALUE) / bucketSize;
buckets.remove(lastBucket);
}
long remappedNum = (long) nums[i] - Integer.MIN_VALUE;
long bucket = remappedNum / bucketSize;
// If 2 numbers belong to same bucket
if (buckets.containsKey(bucket)) {
return true;
}
// If numbers are in adjacent buckets and the difference between them is at most
// t.
if (buckets.containsKey(bucket - 1) && remappedNum - buckets.get(bucket - 1) <= t) {
return true;
}
if (buckets.containsKey(bucket + 1) && buckets.get(bucket + 1) - remappedNum <= t) {
return true;
}
buckets.put(bucket, remappedNum);
}
return false;
}
} | class Solution {
public:
bool containsNearbyAlmostDuplicate(vector<int>& nums, int indexDiff, int valueDiff) {
int i=0;
map<int,int> mp;
int n=nums.size();
for(int j=0;j<n;j++){
auto val=mp.lower_bound(nums[j]);
if(val!=mp.end() and (val->first-nums[j])<=valueDiff){
return true;
}
if(val!=mp.begin()){
val--;
if(abs(val->first-nums[j])<=valueDiff){
return true;
}
}
mp[nums[j]]++;
if((j-i)==indexDiff){
mp[nums[i]]--;
if(mp[nums[i]]==0){
mp.erase(nums[i]);
}
i++;
}
}
return false;
}
}; | /**
* @param {number[]} nums
* @param {number} k
* @param {number} t
* @return {boolean}
*/
var containsNearbyAlmostDuplicate = function(nums, k, t) {
for(let i=0;i<nums.length;i++){
for(let j=i+1;j<nums.length;j++){
if(Math.abs(nums[i]-nums[j])<=t && (Math.abs(i-j)<=k)){
return true;
}
}
}
return false;
}; | Contains Duplicate III |
Given a 0-indexed integer array nums of length n and an integer k, return the number of pairs (i, j) where 0 <= i < j < n, such that nums[i] == nums[j] and (i * j) is divisible by k.
Example 1:
Input: nums = [3,1,2,2,2,1,3], k = 2
Output: 4
Explanation:
There are 4 pairs that meet all the requirements:
- nums[0] == nums[6], and 0 * 6 == 0, which is divisible by 2.
- nums[2] == nums[3], and 2 * 3 == 6, which is divisible by 2.
- nums[2] == nums[4], and 2 * 4 == 8, which is divisible by 2.
- nums[3] == nums[4], and 3 * 4 == 12, which is divisible by 2.
Example 2:
Input: nums = [1,2,3,4], k = 1
Output: 0
Explanation: Since no value in nums is repeated, there are no pairs (i,j) that meet all the requirements.
Constraints:
1 <= nums.length <= 100
1 <= nums[i], k <= 100
| class Solution:
def countPairs(self, nums: List[int], k: int) -> int:
n=len(nums)
c=0
for i in range(0,n):
for j in range(i+1,n):
if nums[i]==nums[j] and ((i*j)%k==0):
c+=1
return c | class Solution {
public int countPairs(int[] nums, int k) {
HashMap<Integer,List<Integer>> hMap = new HashMap<>();
int count = 0;
for(int i = 0 ; i < nums.length ; i++){
if(!hMap.containsKey(nums[i])){
List<Integer> l = new ArrayList<>();
l.add(i);
hMap.put(nums[i],l);
}else{
List<Integer> v = hMap.get(nums[i]);
for(Integer j : v){
if((i*j)%k == 0) count++;
}
v.add(i);
hMap.put(nums[i],v);
}
}
return count;
}
} | class Solution {
public:
int countPairs(vector<int>& nums, int k) {
int count=0;
for(int i=0;i<nums.size()-1;i++)
{
for(int j=i+1;j<nums.size();j++)
if(nums[i]==nums[j] && i*j%k==0)
{
count++;
}
}
return count;
}
}; | /**
* @param {number[]} nums
* @param {number} k
* @return {number}
*/
var countPairs = function(nums, k) {
var count = 0;
for(let i=0; i<nums.length; i++){
for(let j=i+1; j<nums.length; j++){
if(nums[i] == nums[j] && (i * j) % k == 0){
count++;
}
}
}
return count;
}; | Count Equal and Divisible Pairs in an Array |
Given a triangle array, return the minimum path sum from top to bottom.
For each step, you may move to an adjacent number of the row below. More formally, if you are on index i on the current row, you may move to either index i or index i + 1 on the next row.
Example 1:
Input: triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
Output: 11
Explanation: The triangle looks like:
2
3 4
6 5 7
4 1 8 3
The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).
Example 2:
Input: triangle = [[-10]]
Output: -10
Constraints:
1 <= triangle.length <= 200
triangle[0].length == 1
triangle[i].length == triangle[i - 1].length + 1
-104 <= triangle[i][j] <= 104
Follow up: Could you do this using only O(n) extra space, where n is the total number of rows in the triangle? | class Solution:
def minimumTotal(self, t: List[List[int]]) -> int:
dp = []
dp.append(t[0])
r = len(t)
answer = float('inf')
for i in range(1, r):
c = len(t[i])
dp.append([])
for j in range(0, c):
if j == 0:
val = dp[i - 1][j] + t[i][j]
elif j == c - 1:
val = dp[i - 1][j - 1] + t[i][j]
else:
val = min(dp[i - 1][j], dp[i - 1][j - 1]) + t[i][j]
if i == r - 1:
answer = min(answer, val)
dp[i].append(val)
return answer if r > 1 else t[0][0] | class Solution {
public int minimumTotal(List<List<Integer>> triangle) {
int n = triangle.get( triangle.size() - 1).size();
int dp[] = new int[n + 1];
for(int i = triangle.size() - 1; i>=0; i--)
{
for(int j = 0; j<triangle.get(i).size(); j++)
dp[j] = triangle.get(i).get(j) + Math.min(dp[j], dp[j+1]);
}
return dp[0];
}
} | class Solution {
public:
int travel(vector<vector<int>>& tr , int lvl , int ind) {
if(ind >= tr[lvl].size()) // To check if we are going out of bound
return INT_MAX;
if(lvl == tr.size() - 1) { // Return if we are on last line
return tr[lvl][ind];
}
int s = travel(tr , lvl + 1, ind ); // Go South
int se = travel(tr , lvl + 1 , ind + 1); // Go South East
// Return the minimum of south and south east + cost of the index we are currently at.
return min(s , se) + tr[lvl][ind];
}
int minimumTotal(vector<vector<int>>& triangle) {
return travel(triangle , 0 , 0);
}
}; | var minimumTotal = function(triangle) {
const memo = {};
function minPath(row, col) {
let key = `${row}:${col}`;
if (key in memo) {
return memo[key];
}
let path = triangle[row][col];
if (row < triangle.length - 1) {
path += Math.min(minPath(row + 1, col), minPath(row + 1, col + 1));
}
memo[key] = path;
return path;
}
return minPath(0, 0);
}; | Triangle |
Given the root of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.
As a reminder, a binary search tree is a tree that satisfies these constraints:
The left subtree of a node contains only nodes with keys less than the node's key.
The right subtree of a node contains only nodes with keys greater than the node's key.
Both the left and right subtrees must also be binary search trees.
Example 1:
Input: root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
Output: [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
Example 2:
Input: root = [0,null,1]
Output: [1,null,1]
Constraints:
The number of nodes in the tree is in the range [1, 100].
0 <= Node.val <= 100
All the values in the tree are unique.
Note: This question is the same as 538: https://leetcode.com/problems/convert-bst-to-greater-tree/
| class Solution:
def bstToGst(self, root):
self.total = 0
def dfs(n):
if n:
dfs(n.right)
self.total += n.val
n.val = self.total
dfs(n.left)
dfs(root)
return root | class Solution {
int sum=0;
public TreeNode bstToGst(TreeNode root) {
if(root!=null){
bstToGst(root.right);
sum += root.val;
root.val = sum;
bstToGst(root.left);
}
return root;
}
} | class Solution {
public:
int s = 0;
void solve(TreeNode* root){
if(!root) return;
solve(root->right);
root->val = s + root->val;
s = root->val;
solve(root->left);
return;
}
TreeNode* bstToGst(TreeNode* root) {
if(!root) return NULL;
solve(root);
return root;
}
}; | var bstToGst = function(root) {
let sum = 0;
const traverse = (r = root) => {
if(!r) return null;
traverse(r.right);
let temp = r.val;
r.val += sum;
sum += temp;
traverse(r.left);
}
traverse();
return root;
}; | Binary Search Tree to Greater Sum Tree |
A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.
Design an algorithm to insert a new node to a complete binary tree keeping it complete after the insertion.
Implement the CBTInserter class:
CBTInserter(TreeNode root) Initializes the data structure with the root of the complete binary tree.
int insert(int v) Inserts a TreeNode into the tree with value Node.val == val so that the tree remains complete, and returns the value of the parent of the inserted TreeNode.
TreeNode get_root() Returns the root node of the tree.
Example 1:
Input
["CBTInserter", "insert", "insert", "get_root"]
[[[1, 2]], [3], [4], []]
Output
[null, 1, 2, [1, 2, 3, 4]]
Explanation
CBTInserter cBTInserter = new CBTInserter([1, 2]);
cBTInserter.insert(3); // return 1
cBTInserter.insert(4); // return 2
cBTInserter.get_root(); // return [1, 2, 3, 4]
Constraints:
The number of nodes in the tree will be in the range [1, 1000].
0 <= Node.val <= 5000
root is a complete binary tree.
0 <= val <= 5000
At most 104 calls will be made to insert and get_root.
| class CBTInserter:
def __init__(self, root: Optional[TreeNode]):
self.root = root
self.queue = Queue()
self.queue.put(self.root)
self.parent_of_last_inserted = None
def insert(self, val: int) -> int:
if self.parent_of_last_inserted is not None and self.parent_of_last_inserted.right is None:
self.parent_of_last_inserted.right = TreeNode(val)
self.queue.put(self.parent_of_last_inserted.right)
return self.parent_of_last_inserted.val
while not self.queue.empty():
node = self.queue.get()
if node.left is None:
node.left = TreeNode(val)
self.queue.put(node.left)
self.parent_of_last_inserted = node
return node.val
else:
self.queue.put(node.left)
if node.right is None:
node.right = TreeNode(val)
self.queue.put(node.right)
self.parent_of_last_inserted = node
return node.val
else:
self.queue.put(node.right)
def get_root(self) -> Optional[TreeNode]:
return self.root | class CBTInserter {
private TreeNode root;
private int total;
private int count(TreeNode root) {
if (root == null) return 0;
return 1+count(root.left)+count(root.right);
}
public CBTInserter(TreeNode root) {
this.root = root;
total = count(root);
}
private int insertBinary(int val, int k, int right) {
int left = 0;
var ptr = root;
while (left < right) {
if (left == right -1) {
if (ptr.left == null) ptr.left = new TreeNode(val);
else ptr.right = new TreeNode(val);
return ptr.val;
}
int mid = (right-left) / 2 + left;
if (mid >= k ) {
ptr = ptr.left;
right = mid;
} else if (mid < k) {
left = mid+1;
ptr = ptr.right;
}
}
return 0;
}
public int insert(int val) {
int depth = 0;
int n = total;
while(n > 0) {
depth++;
n /= 2;
}
if ((1<<depth)-1 == total) depth++;
// k is the new index in the lowest level of tree, right is the max index of the lowest level of tree
// e.g. for tree
// 1
// / \
// 2 new
//index 0 1
// it's insertBinary(val, 1, 1)
var res = insertBinary(val, total - (1<<(depth-1))+1 , (1<<(depth-1)) -1);
total++;
return res;
}
public TreeNode get_root() {
return root;
}
} | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class CBTInserter {
public:
vector<TreeNode*> arr;
CBTInserter(TreeNode* root) {
arr.push_back(root);
queue<TreeNode*> q;
q.push(root);
while(!q.empty()){
if(q.front() -> left != NULL){
arr.push_back(q.front() -> left);
q.push(q.front() -> left);
}
if(q.front() -> right != NULL){
arr.push_back(q.front() -> right);
q.push(q.front() -> right);
}
q.pop();
}
}
int insert(int val) {
TreeNode* new_node = new TreeNode(val);
arr.push_back(new_node);
int parent_index = (arr.size()-2)/2;
if(2*parent_index +1 == arr.size()-1){arr[parent_index] -> left = new_node;}
else{arr[parent_index] -> right = new_node;}
return arr[parent_index] -> val;
}
TreeNode* get_root() {
return arr[0];
}
};
/**
* Your CBTInserter object will be instantiated and called as such:
* CBTInserter* obj = new CBTInserter(root);
* int param_1 = obj->insert(val);
* TreeNode* param_2 = obj->get_root();
*/ | /**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
*/
var CBTInserter = function(root) {
this.root = root;
};
/**
* @param {number} val
* @return {number}
*/
CBTInserter.prototype.insert = function(val) {
let cur = this.root;
let queue = [cur];
while(queue.length){
let updatedQueue = [];
while(queue.length){
let node = queue.shift();
if(!node.left) {
node.left = new TreeNode(val);
return node.val;
}
else updatedQueue.push(node.left);
if(!node.right) {
node.right = new TreeNode(val);
return node.val;
}
else updatedQueue.push(node.right);
}
queue = updatedQueue ;
}
};
/**
* @return {TreeNode}
*/
CBTInserter.prototype.get_root = function() {
return this.root;
};
/**
* Your CBTInserter object will be instantiated and called as such:
* var obj = new CBTInserter(root)
* var param_1 = obj.insert(val)
* var param_2 = obj.get_root()
*/ | Complete Binary Tree Inserter |
You are given a string s of lowercase English letters and an array widths denoting how many pixels wide each lowercase English letter is. Specifically, widths[0] is the width of 'a', widths[1] is the width of 'b', and so on.
You are trying to write s across several lines, where each line is no longer than 100 pixels. Starting at the beginning of s, write as many letters on the first line such that the total width does not exceed 100 pixels. Then, from where you stopped in s, continue writing as many letters as you can on the second line. Continue this process until you have written all of s.
Return an array result of length 2 where:
result[0] is the total number of lines.
result[1] is the width of the last line in pixels.
Example 1:
Input: widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10], s = "abcdefghijklmnopqrstuvwxyz"
Output: [3,60]
Explanation: You can write s as follows:
abcdefghij // 100 pixels wide
klmnopqrst // 100 pixels wide
uvwxyz // 60 pixels wide
There are a total of 3 lines, and the last line is 60 pixels wide.
Example 2:
Input: widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10], s = "bbbcccdddaaa"
Output: [2,4]
Explanation: You can write s as follows:
bbbcccdddaa // 98 pixels wide
a // 4 pixels wide
There are a total of 2 lines, and the last line is 4 pixels wide.
Constraints:
widths.length == 26
2 <= widths[i] <= 10
1 <= s.length <= 1000
s contains only lowercase English letters.
| class Solution:
def numberOfLines(self, w: List[int], s: str) -> List[int]:
r=[0]*2
px=0
l=1
for i in range(len(s)):
px+=w[ord(s[i])-97]
if px>100:
l+=1
px=w[ord(s[i])-97]
print(ord(s[i]))
r[0]=l
r[1]=px
return r
| class Solution {
public int[] numberOfLines(int[] widths, String s) {
int sum=0,count=0;
for(int j=0;j<s.length();j++)
{
int pos = s.charAt(j)-'a';
sum+=widths[pos];
if(sum>100)
{
j--;
count++;
sum=0;
continue;
}
}
int[] arr = new int[2];
arr[0]=count+1;
arr[1]=sum;
return arr;
}
} | class Solution {
public:
vector<int> numberOfLines(vector<int>& widths, string s) {
vector<int>ans(2);
int lines =0;
int calc = 0;
int i =0;
while(i<s.length()){
calc = 0;
while(i<s.length() and calc<=100){
calc+=widths[s[i]-'a'];
i++;
}
if(calc>100){
i-=1;
calc-=widths[s[i]-'a'];
}
lines++;
// cout<<lines;
}
ans[0] = lines;
ans[1] = calc;
return ans;
}
}; | var numberOfLines = function(widths, s) {
let pixel=100, line=1;
for(let i=0; i<s.length; i++){
if(pixel>=widths[s[i].charCodeAt()-97]){
pixel-=widths[s[i].charCodeAt()-97];
}else{
// this word should be written in NEXT line, so it CANNOT count.
i--; line++; pixel=100;
}
}
// 100-pixel = space used in this line.
return [line, 100-pixel];
}; | Number of Lines To Write String |
You are given two strings order and s. All the characters of order are unique and were sorted in some custom order previously.
Permute the characters of s so that they match the order that order was sorted. More specifically, if a character x occurs before a character y in order, then x should occur before y in the permuted string.
Return any permutation of s that satisfies this property.
Example 1:
Input: order = "cba", s = "abcd"
Output: "cbad"
Explanation:
"a", "b", "c" appear in order, so the order of "a", "b", "c" should be "c", "b", and "a".
Since "d" does not appear in order, it can be at any position in the returned string. "dcba", "cdba", "cbda" are also valid outputs.
Example 2:
Input: order = "cbafg", s = "abcd"
Output: "cbad"
Constraints:
1 <= order.length <= 26
1 <= s.length <= 200
order and s consist of lowercase English letters.
All the characters of order are unique.
| class Solution:
def customSortString(self, order: str, s: str) -> str:
charValue = [0] * 26
for i in range(len(order)):
idx = ord(order[i]) - ord('a')
charValue[idx] = 26 - i
arrS = []
n = 0
for c in s:
arrS.append(c)
n += 1
sorted = False
while not sorted:
sorted = True
for i in range(n - 1):
if charValue[ord(arrS[i]) - ord('a')] < charValue[ord(arrS[i + 1]) - ord('a')]:
sorted = False
arrS[i], arrS[i + 1] = arrS[i + 1], arrS[i]
return ''.join(arrS) | class Solution {
public String customSortString(String order, String s) {
if(s.length() <= 1) return s;
StringBuilder finalString = new StringBuilder();
HashMap<Character, Integer> hm = new HashMap<>();
for(int i = 0; i < s.length(); i++) {
char actualChar = s.charAt(i);
if(order.indexOf(actualChar) == -1) {
finalString.append(actualChar);
} else {
hm.put(actualChar, hm.getOrDefault(actualChar, 0) + 1);
}
}
for(int i = 0; i < order.length(); i++) {
char actualChar = order.charAt(i);
if (hm.get(actualChar) != null){
for(int j = 0; j < hm.get(actualChar); j++) {
finalString.append(actualChar);
}
}
}
return finalString.toString();
}
} | class Solution {
public:
string customSortString(string order, string s) {
map<char,int>mp;
for(int i =0 ; i<order.size() ; i++)
mp[order[i]]=i+1;
vector<pair<int,char> > p;
int x=200;
for(int i =0 ; i < s.size(); i++)
{
if(mp[s[i]]!=0)
p.push_back(make_pair(mp[s[i]],s[i]));
else
p.push_back(make_pair(x--,s[i]));
}
sort(p.begin(),p.end());
string ans="";
for(int i =0 ;i < p.size(); i++)
{
ans+=p[i].second;
}
return ans;
}
}; | var customSortString = function(order, s) {
const hm = new Map();
for(let c of s) {
if(!hm.has(c)) hm.set(c, 0);
hm.set(c, hm.get(c) + 1);
}
let op = "";
for(let c of order) {
if(hm.has(c)) {
op += "".padStart(hm.get(c), c);
hm.delete(c);
}
}
for(let [c, occ] of hm) {
op += "".padStart(hm.get(c), c);
hm.delete(c);
}
return op;
}; | Custom Sort String |
Given a string formula representing a chemical formula, return the count of each atom.
The atomic element always starts with an uppercase character, then zero or more lowercase letters, representing the name.
One or more digits representing that element's count may follow if the count is greater than 1. If the count is 1, no digits will follow.
For example, "H2O" and "H2O2" are possible, but "H1O2" is impossible.
Two formulas are concatenated together to produce another formula.
For example, "H2O2He3Mg4" is also a formula.
A formula placed in parentheses, and a count (optionally added) is also a formula.
For example, "(H2O2)" and "(H2O2)3" are formulas.
Return the count of all elements as a string in the following form: the first name (in sorted order), followed by its count (if that count is more than 1), followed by the second name (in sorted order), followed by its count (if that count is more than 1), and so on.
The test cases are generated so that all the values in the output fit in a 32-bit integer.
Example 1:
Input: formula = "H2O"
Output: "H2O"
Explanation: The count of elements are {'H': 2, 'O': 1}.
Example 2:
Input: formula = "Mg(OH)2"
Output: "H2MgO2"
Explanation: The count of elements are {'H': 2, 'Mg': 1, 'O': 2}.
Example 3:
Input: formula = "K4(ON(SO3)2)2"
Output: "K4N2O14S4"
Explanation: The count of elements are {'K': 4, 'N': 2, 'O': 14, 'S': 4}.
Constraints:
1 <= formula.length <= 1000
formula consists of English letters, digits, '(', and ')'.
formula is always valid.
| from collections import Counter, deque
class Solution:
def countOfAtoms(self, formula: str) -> str:
"""
parser:
formula: elem {count} formula
elem: term | ( formula )
term: [A-Z](a-z)+
count: [0-9]+
"""
def parse_formula(dq, allCount=Counter()):
lhs = parse_elem(dq)
count = 1
while dq and dq[0].isdigit():
count = parse_count(dq)
for k in lhs.keys():
allCount[k] += lhs[k] * count
if dq and dq[0] not in ')':
return parse_formula(dq, allCount)
else:
return allCount
def parse_elem(dq):
if dq and dq[0] == '(':
dq.popleft()
res = parse_formula(dq, Counter())
dq.popleft()
return res
else:
elem = ''
if dq and dq[0].isupper():
elem += dq.popleft()
while dq and dq[0].islower():
elem += dq.popleft()
return {elem: 1}
def parse_count(dq):
c = 0
while dq and dq[0].isdigit():
c = c * 10 + int(dq.popleft())
return c
formula = deque(formula)
count_result = parse_formula(formula)
result = ''
for k in sorted(count_result.keys()):
v = count_result[k]
if v == 1:
result += k
else:
result += f"{k}{count_result[k]}"
return result | class Solution {
public String countOfAtoms(String formula) {
Deque<Integer> multiplier = new ArrayDeque<>();
Map<String, Integer> map = new HashMap<>();
int lastValue = 1;
multiplier.push(1);
// Iterate from right to left
for (int i = formula.length() - 1; i >= 0; i--) {
if (Character.isDigit(formula.charAt(i))) { // Case of a digit - Get full number and save
StringBuilder sb = new StringBuilder();
while (Character.isDigit(formula.charAt(i-1))) {
sb.append(formula.charAt(i));
i--;
}
sb.append(formula.charAt(i));
lastValue = Integer.parseInt(sb.reverse().toString());
} else if (formula.charAt(i) == ')') { // Start parenthesis - push next multiplier to stack
multiplier.push(lastValue * multiplier.peek());
lastValue = 1;
} else if (formula.charAt(i) == '(') { // End parenthesis - pop last multiplier
multiplier.pop();
} else { // Case of an element name - construct name, update count based on multiplier
StringBuilder sb = new StringBuilder();
while (Character.isLowerCase(formula.charAt(i))) {
sb.append(formula.charAt(i));
i--;
}
sb.append(formula.charAt(i));
String element = sb.reverse().toString();
map.put(element, map.getOrDefault(element, 0) + lastValue * multiplier.peek());
lastValue = 1;
}
}
// Sort map keys
List<String> elements = new ArrayList<>(map.keySet());
StringBuilder sb = new StringBuilder();
Collections.sort(elements);
// Construct output
for (String element : elements) {
sb.append(element);
if (map.get(element) > 1) {
sb.append(map.get(element));
}
}
return sb.toString();
}
} | class Solution {
public:
// helper functions
bool isUpper(char ch) {
return ch >= 65 && ch <= 90;
}
bool isLower(char ch) {
return ch >= 97 && ch <= 122;
}
bool isLetter(char ch) {
return isUpper(ch) || isLower(ch);
}
bool isNumber(char ch) {
return ch >= 48 && ch <= 57;
}
void addKey(map<string, long int>& count, string key, long int value) {
if(count.find(key) != count.end()) {
count[key] = count[key] + value;
}
else {
count[key] = value;
}
}
// very specific utility function
string buildName(string formula, int& i) {
string name = "";
name.push_back(formula[i]);
if(isUpper(formula[i])) {
return name;
}
if(i == formula.length()-1) {
return name;
}
while(isLower(formula[i-1])) {
name.push_back(formula[i-1]);
i--;
}
name.push_back(formula[i-1]);
i--;
reverse(name.begin(), name.end());
return name;
}
// very specific utility function
long int buildCount(string formula, int& i, vector<long int>& stack) {
long int num = formula[i] - '0';
long int place = 1;
if(i == 0) {
return num;
}
while(isNumber(formula[i-1])) {
place = place * 10;
num = (formula[i-1]-'0') * place + num;
i--;
}
return num;
}
string countOfAtoms(string formula) {
string ans;
map<string, long int> count;
vector<long int> stack;
long int factor = 1;
string name = "";
long int num = -1; // -1 indicates a number reset, ie, count = 1
// iterator i is passed by reference to keep track of
// the substrings that are builded, ie, atom
// names or numbers
int i = formula.length()-1;
while (i >= 0) {
// here we need the number after the bracket close. This is
// either 1 or num depending on whether we built a number before
if(formula[i] == ')') {
if(i+1 <= formula.length()-1 && isNumber(formula[i+1])) {
stack.push_back(num);
factor = factor * num;
num = -1;
}
else {
stack.push_back(1);
}
}
// here is why we need a stack. Remove latest factor that was added.
else if(formula[i] == '(') {
factor = factor / stack.back();
stack.pop_back();
}
// once we detect a letter, we know it can only be a word. num gives us the atom subscript
// and factor gives us the molecular count.
else if(isLetter(formula[i])) {
name = buildName(formula, i);
if(num == -1) {
addKey(count, name, 1 * factor);
}
else {
addKey(count, name, num * factor);
}
num = -1; // reset number
}
else if(isNumber(formula[i])) {
num = buildCount(formula, i, stack);
}
i--;
}
// arrange name and count in a string
map<string, long int>::iterator it;
for (it = count.begin(); it != count.end(); it++)
{
ans = ans + it->first;
if(it->second != 1) {
ans = ans + to_string(it->second);
}
}
return ans;
}
}; | var countOfAtoms = function(formula) {
function getElementCount(flatFormula) {
const reElementCount = /([A-Z][a-z]*)(\d*)/g;
let matches = flatFormula.matchAll(reElementCount);
let output = new Map();
for (let [match, element, count] of matches) {
count = count === '' ? 1 : +count;
if (output.has(element)) {
output.set(element, output.get(element) + count);
} else {
output.set(element, count);
}
}
return output;
}
function flattenElementCount(elCountMap) {
let arr = [...elCountMap.entries()].sort();
return arr.reduce( (str, item) => {
let num = item[1] === 1 ? '' : item[1];
return str + item[0] + num;
}, '' );
}
function unnest(fullMatch, innerFormula, multiplier) {
let elementCount = getElementCount(innerFormula);
multiplier = multiplier === '' ? 1 : +multiplier;
for (let [element, count] of elementCount) {
elementCount.set(element, elementCount.get(element) * multiplier);
}
return flattenElementCount(elementCount);
}
function flattenFormula(formula) {
const reNested = /\((\w+)\)(\d*)/g;
while (reNested.test(formula)) {
formula = formula.replaceAll(reNested, unnest);
}
return formula;
}
let flatFormula = flattenFormula(formula);
return flattenElementCount(getElementCount(flatFormula));
}; | Number of Atoms |
Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.
Example 1:
Input: intervals = [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlap, merge them into [1,6].
Example 2:
Input: intervals = [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considered overlapping.
Constraints:
1 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti <= endi <= 104
| class Solution:
def merge(self, A: List[List[int]]) -> List[List[int]]:
#sort array wrt its 0'th index
A.sort(key=lambda x:x[0])
i=0
while i<(len(A)-1):
if A[i][1]>=A[i+1][0]:
A[i][1]=max(A[i+1][1],A[i][1])
A.pop(i+1)
else:
i+=1
return(A)
| class Solution {
public int[][] merge(int[][] intervals) {
// sort
// unknown size of ans = use ArrayList
// insert from back
// case 1 : Merging
// start of new interval is less that end of old interval
// new end = Math.max(new intervals end, old intervals end)
// case 2 : Non-merging
// seperate interval
// convert ArrayList to array and return
Arrays.sort(intervals, (a,b) -> a[0]-b[0]);
ArrayList<int[]> list = new ArrayList<>();
for(int i = 0; i < intervals.length; i++) {
if(i == 0) {
list.add(intervals[i]);
} else {
int[] prev = list.get(list.size()-1);
int[] curr = intervals[i];
if(curr[0] <= prev[1]) {
prev[1] = Math.max(curr[1], prev[1]);
}else {
list.add(curr);
}
}
}
return list.toArray(new int[list.size()][2]);
}
} | class Solution {
public:
vector<vector<int>> merge(vector<vector<int>>& intervals) {
sort(intervals.begin(), intervals.end());
vector<vector<int>> res;
int i=0;
while(i<=intervals.size()-1){
int start=intervals[i][0];
int end=intervals[i][1];
while(i<intervals.size()-1 && end>=intervals[i+1][0]){
i++;
if(end<intervals[i][1]) end=intervals[i][1];
}
i++;
res.push_back({start, end});
}
return res;
}
}; | /**
* @param {number[][]} intervals
* @return {number[][]}
*/
var merge = function(intervals) {
// sorting the intervals array first is a general good first step
intervals.sort((a,b) => a[0] - b[0]);
const result = [];
// i am using the result array as a way to compare previous and next intervals
result.push(intervals[0])
for (let i=1; i<intervals.length; i++) {
const prevInterval = result[result.length-1]
const interval = intervals[i]
if (prevInterval[1] >= interval[0]) {
// overlap detected
const [ l, r ] = result.pop();
// if overlap, merge intervals by taking min/max of both boundaries
const newL = Math.min(l, interval[0])
const newR = Math.max(r, interval[1])
result.push([newL, newR])
} else {
result.push(intervals[i])
}
}
return result
}; | Merge Intervals |
You are given a string s and an integer k. You can choose one of the first k letters of s and append it at the end of the string..
Return the lexicographically smallest string you could have after applying the mentioned step any number of moves.
Example 1:
Input: s = "cba", k = 1
Output: "acb"
Explanation:
In the first move, we move the 1st character 'c' to the end, obtaining the string "bac".
In the second move, we move the 1st character 'b' to the end, obtaining the final result "acb".
Example 2:
Input: s = "baaca", k = 3
Output: "aaabc"
Explanation:
In the first move, we move the 1st character 'b' to the end, obtaining the string "aacab".
In the second move, we move the 3rd character 'c' to the end, obtaining the final result "aaabc".
Constraints:
1 <= k <= s.length <= 1000
s consist of lowercase English letters.
| class Solution:
def orderlyQueue(self, s: str, k: int) -> str:
if k>1:
s=list(c for c in s)
s.sort()
return ''.join(s)
s1=s
for i in range(len(s)):
s=s[1:]+s[0]
s1=min(s1,s)
return s1 | // Time O(n)
// Space O(n)
class Solution {
public String orderlyQueue(String s, int k) {
int n = s.length();
String ans = "";
if (k == 1){
s+=s; // add itself again
for (int i = 0; i < n; i++) if (ans.isEmpty() || s.substring(i, i+n).compareTo(ans) < 0){
ans = s.substring(i, i+n);
}
}else{
char[] arr = s.toCharArray();
Arrays.sort(arr);
ans = String.valueOf(arr);
}
return ans;
}
} | class Solution {
public:
string orderlyQueue(string s, int k) {
if(k>1){
sort(s.begin(),s.end());
return s;
}
else{
string res=s;
for(int i=0;i<s.length();i++){
s=s.substr(1)+s.substr(0,1);
res=min(res,s);
}
return res;
}
return s;
}
}; | /**
* @param {string} s
* @param {number} k
* @return {string}
*/
var orderlyQueue = function(s, k) {
// rotate the string one by one, and check which is lexographically smaller
if (k === 1) {
let temp = `${s}`;
let smallest = `${s}`;
let count = 0;
while (count < s.length) {
temp = temp.substring(1, s.length) + temp.charAt(0);
if (temp < smallest) {
smallest = temp;
}
count++;
}
return smallest;
}
// if k is greater than 1, any permutation is possilbe
// so we simply return the sorted string (convert to array -> sort -> back to string)
if (k > 1) {
return [...s].sort().join('');
}
return s;
}; | Orderly Queue |
Given an integer n, add a dot (".") as the thousands separator and return it in string format.
Example 1:
Input: n = 987
Output: "987"
Example 2:
Input: n = 1234
Output: "1.234"
Constraints:
0 <= n <= 231 - 1
| class Solution(object):
def thousandSeparator(self, n):
"""
:type n: int
:rtype: str
"""
n = str(n)
if len(n) <= 3:
return str(n)
result = ""
dot = '.'
index = 0
startPos = len(n) % 3
if startPos == 0:
startPos += 3
val = -1
while index < len(n):
result += n[index]
if index == startPos - 1:
result += dot
val = 0
if val != -1:
val += 1
if val > 3 and (val - 1) % 3 == 0 and index != len(n) - 1:
result += dot
val = 1
index += 1
return result | class Solution {
public String thousandSeparator(int n) {
StringBuffer str = new StringBuffer(Integer.toString(n));
int index = str.length() - 3;
while(index >= 1){
str.insert(index , '.');
index = index - 3;
}
return str.toString();
}
} | class Solution {
public:
string thousandSeparator(int n) {
string s="";
int a=0;
if(n==0)return "0";
while(n>0){
s+=char(n%10+48);
a++;
n/=10;
if(a==3&&n!=0)
{
a=0;
s+=".";
}
}
reverse(s.begin(),s.end());
return s;
}
}; | var thousandSeparator = function(n) {
let ans = "";
if(n >= 1000){
const arr = String(n).split('');
for(let i=0;i<arr.length;i++){
let temp = arr.length - i;
if(temp === 3 && arr.length > temp || temp === 6 && arr.length > temp || temp === 9 && arr.length > temp || temp === 12 && arr.length > temp){
ans += '.';
}
ans += arr[i];
}
}else{
ans += n;
}
return ans;
}; | Thousand Separator |
Your country has an infinite number of lakes. Initially, all the lakes are empty, but when it rains over the nth lake, the nth lake becomes full of water. If it rains over a lake that is full of water, there will be a flood. Your goal is to avoid floods in any lake.
Given an integer array rains where:
rains[i] > 0 means there will be rains over the rains[i] lake.
rains[i] == 0 means there are no rains this day and you can choose one lake this day and dry it.
Return an array ans where:
ans.length == rains.length
ans[i] == -1 if rains[i] > 0.
ans[i] is the lake you choose to dry in the ith day if rains[i] == 0.
If there are multiple valid answers return any of them. If it is impossible to avoid flood return an empty array.
Notice that if you chose to dry a full lake, it becomes empty, but if you chose to dry an empty lake, nothing changes.
Example 1:
Input: rains = [1,2,3,4]
Output: [-1,-1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day full lakes are [1,2,3]
After the fourth day full lakes are [1,2,3,4]
There's no day to dry any lake and there is no flood in any lake.
Example 2:
Input: rains = [1,2,0,0,2,1]
Output: [-1,-1,2,1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day, we dry lake 2. Full lakes are [1]
After the fourth day, we dry lake 1. There is no full lakes.
After the fifth day, full lakes are [2].
After the sixth day, full lakes are [1,2].
It is easy that this scenario is flood-free. [-1,-1,1,2,-1,-1] is another acceptable scenario.
Example 3:
Input: rains = [1,2,0,1,2]
Output: []
Explanation: After the second day, full lakes are [1,2]. We have to dry one lake in the third day.
After that, it will rain over lakes [1,2]. It's easy to prove that no matter which lake you choose to dry in the 3rd day, the other one will flood.
Constraints:
1 <= rains.length <= 105
0 <= rains[i] <= 109
| from bisect import bisect_left
class Solution:
def avoidFlood(self, rains):
full_lakes, dry_dates = {}, []
ans = [-1] * len(rains)
for date, rain_lake in enumerate(rains):
if rain_lake == 0: # no rain, we can dry one lake
dry_dates.append(date) # keep dry date, we'll decide later
continue
if rain_lake in full_lakes: # the lake is already full
# BS find out earliest day we can use to dry that lake | greedy
dry_day = bisect_left(dry_dates, full_lakes[rain_lake])
if dry_day >= len(dry_dates): return [] # can not find a date to dry this lake
ans[dry_dates.pop(dry_day)] = rain_lake # dry this lake at the date we choose
# remember latest rain on this lake
full_lakes[rain_lake] = date
# we may have dry dates remain, on these days, rain > 0, we can not use -1, just choose day 1 to dry (maybe nothing happend)
for dry_day in dry_dates:
ans[dry_day] = 1
return ans | class Solution {
public int[] avoidFlood(int[] rains) {
// the previous appeared idx of rains[i]
Map<Integer, Integer> map = new HashMap<>();
TreeSet<Integer> zeros = new TreeSet<>();
int[] res = new int[rains.length];
for (int i = 0; i < rains.length; i++) {
if (rains[i] == 0) {
zeros.add(i);
} else {
if (map.containsKey(rains[i])) {
// find the location of zero that can be used to empty rains[i]
Integer next = zeros.ceiling(map.get(rains[i]));
if (next == null) return new int[0];
res[next] = rains[i];
zeros.remove(next);
}
res[i] = -1;
map.put(rains[i], i);
}
}
for (int i : zeros) res[i] = 1;
return res;
}
} | class Solution {
public:
vector<int> avoidFlood(vector<int>& rains) {
vector<int> ans(rains.size() , -1) ;
unordered_map<int,int> indices ; //store the lake and its index
set<int> st ; //stores the indices of zeros
for(int i = 0 ; i < rains.size() ; ++i ){
if(!rains[i]) st.insert(i) ;
else{
if(indices.find(rains[i]) == end(indices)) indices[rains[i]] = i ;
else{
int prevDay = indices[rains[i]] ;
auto it = st.upper_bound(prevDay) ;
if(it == end(st)) return {} ;
ans[*it] = rains[i] ;
indices[rains[i]] = i ;
st.erase(it);
}
}
}
for(int i = 0 ; i < ans.size(); ++i ){
if(!rains[i] and ans[i] == -1) ans[i] = 1 ;
}
return ans ;
}
}; | var avoidFlood = function(rains) {
const n = rains.length;
const filledLakes = new Map();
const res = new Array(n).fill(-1);
const dryDays = [];
for (let i = 0; i < n; i++) {
const lake = rains[i]; // lake to rain on
if (lake === 0) {
// It is a dry day
dryDays.push(i);
}
else if (!filledLakes.has(lake)) {
// The lake is not filled yet, so we let it be filled (we just don't want it to be rained on again and be flooded)
filledLakes.set(lake, i);
}
else {
// The lake is already filled. We want to see if a dry day was available after the lake was previously rained on so that we can empty the lake
const lake_index = filledLakes.get(lake); //
const dry_index = binarySearch(lake_index);
if (dry_index === dryDays.length) return []; // there was no dry day after the lake was previouly filled
res[dryDays[dry_index]] = lake; // mark the earliest dry day that was used in our result array
filledLakes.set(lake, i); // we need to update the day that the lake is rained on again
dryDays.splice(dry_index, 1); // remove the dry day that was used (this is not very efficient, but it just makes our code cleaner)
}
}
dryDays.forEach((day) => res[day] = 1);
return res;
function binarySearch(target) {
let left = 0;
let right = dryDays.length - 1;
while (left <= right) {
const mid = left + Math.floor((right - left) / 2);
if (dryDays[mid] < target) left = mid + 1;
else right = mid - 1;
}
return left;
}
}; | Avoid Flood in The City |
You are given a string s. You can convert s to a palindrome by adding characters in front of it.
Return the shortest palindrome you can find by performing this transformation.
Example 1:
Input: s = "aacecaaa"
Output: "aaacecaaa"
Example 2:
Input: s = "abcd"
Output: "dcbabcd"
Constraints:
0 <= s.length <= 5 * 104
s consists of lowercase English letters only.
| class Solution:
def shortestPalindrome(self, s: str) -> str:
end = 0
# if the string itself is a palindrome return it
if(s == s[::-1]):
return s
# Otherwise find the end index of the longest palindrome that starts
# from the first character of the string
for i in range(len(s)+1):
if(s[:i]==s[:i][::-1]):
end=i-1
# return the string with the remaining characters other than
# the palindrome reversed and added at the beginning
return (s[end+1:][::-1])+s | class Solution {
public String shortestPalindrome(String s) {
for(int i=s.length()-1; i >= 0; i--){
if(isPalindrome(s, 0, i)){
String toAppend = s.substring(i+1);
String result = new StringBuilder(toAppend).reverse().append(s).toString();
return result;
}
}
String result = new StringBuilder(s).reverse().append(s).toString();
return result;
}
boolean isPalindrome(String s, int left, int right){
while(left < right){
if(s.charAt(left) != s.charAt(right))
return false;
left++;
right--;
}
return true;
}
} | class Solution {
public:
string shortestPalindrome(string s) {
int BASE = 26, MOD = 1e9+7;
int start = s.size()-1;
// Calculate hash values from front and back
long front = 0, back = 0;
long power = 1;
for(int i=0; i<s.size(); i++){
front = (front*BASE + (s[i]-'a'+1))%MOD;
back = (back*BASE + (s[start--]-'a'+1))%MOD;
power = (power*BASE)%MOD;
}
// If hash values of both front and back are same, then it is a palindrome
if(front == back){
return s;
}
// As it is not palindrome, add last characters in the beginning, and then check.
// Store the hash value of the newly added characters from front and back
// new_front will be added to front to get new hash value
// new_back will be added to back to get new hash value
long new_front = 0, new_back = 0;
long new_power = 1;
int end=s.size()-1;
string ans = "";
while(end >= 0){
// Taking character from ending
int ch = (s[end]-'a'+1);
new_front = (new_front*BASE + ch*power) % MOD;
new_back = (ch*new_power + new_back) % MOD;
new_power = (new_power*BASE) % MOD;
int final_front = (new_front + front) % MOD;
back = (back*BASE) % MOD;
int final_back = (new_back + back) % MOD;
// Storing it in separate string
ans += s[end];
end--;
// Both hashes are same
if(final_front == final_back){
break;
}
}
return ans+s;
}
}; | var shortestPalindrome = function(s) {
const rev = s.split('').reverse().join('');
const slen = s.length;
const z = s + '$' + rev;
const zlen = z.length;
const lpt = new Array(zlen).fill(0);
for(let i = 1; i < zlen; i++) {
let j = lpt[i-1];
while(j > 0 && z.charAt(i) != z.charAt(j))
j = lpt[j-1];
if(z.charAt(i) == z.charAt(j))
j++;
lpt[i] = j;
}
return rev.slice(0, slen - lpt.at(-1)) + s;
}; | Shortest Palindrome |
Subsets and Splits