Posts tagged as “easy”

花花酱 LeetCode 1608. Special Array With X Elements Greater Than or Equal X

By zxi on October 4, 2020

You are given an array nums of non-negative integers. nums is considered special if there exists a number x such that there are exactly x numbers in nums that are greater than or equal to x.

Notice that x does not have to be an element in nums.

Return x if the array is special, otherwise, return -1. It can be proven that if nums is special, the value for x is unique.

Example 1:

Input: nums = [3,5]
Output: 2
Explanation: There are 2 values (3 and 5) that are greater than or equal to 2.

Example 2:

Input: nums = [0,0]
Output: -1
Explanation: No numbers fit the criteria for x.
If x = 0, there should be 0 numbers >= x, but there are 2.
If x = 1, there should be 1 number >= x, but there are 0.
If x = 2, there should be 2 numbers >= x, but there are 0.
x cannot be greater since there are only 2 numbers in nums.

Example 3:

Input: nums = [0,4,3,0,4]
Output: 3
Explanation: There are 3 values that are greater than or equal to 3.

Example 4:

Input: nums = [3,6,7,7,0]
Output: -1

Constraints:

1 <= nums.length <= 100
0 <= nums[i] <= 1000

Solution 1: Brute Force

Try all possible x from 0 to n.

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

C++

// Author: Huahua

class Solution {

public:

int specialArray(vector<int>& nums) {

for (int x = 0; x <= nums.size(); ++x)

if (x == count_if(begin(nums), end(nums), [x](int num) {

return num >= x; }))

return x;

return -1;

}

};

Python3

# Author: Huahua

class Solution:

def specialArray(self, nums: List[int]) -> int:

for x in range(len(nums) + 1):

if x == sum([n >= x for n in nums]): return x

return -1

Solution 2: Counting Sort

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

f[i] := sum(nums >= i)

C++

// Author: Huahua

class Solution {

public:

int specialArray(vector<int>& nums) {

const int n = nums.size();

vector<int> f(n + 2);

for (int v : nums) ++f[min(v, n)];

for (int i = n; i >= 0; --i)

if ((f[i] += f[i + 1]) == i) return i;

return -1;

}

};

花花酱 LeetCode 1603. Design Parking System

By zxi on October 3, 2020

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

Solution: Simulation

Time complexity: O(1) per addCar call
Space complexity: O(1)

C++

// Author: Huahua

class ParkingSystem {

public:

ParkingSystem(int big, int medium, int small):

slots_{{big, medium, small}} {}

bool addCar(int carType) {

return slots_[carType - 1]-- > 0;

}

private:

vector<int> slots_;

};

Python3

# Author: Huahua

class ParkingSystem:

def __init__(self, big: int, medium: int, small: int):

self.slots = {1: big, 2: medium, 3: small}

def addCar(self, carType: int) -> bool:

if self.slots[carType] == 0: return False

self.slots[carType] -= 1

return True

花花酱 LeetCode 1598. Crawler Log Folder

By zxi on September 27, 2020

The Leetcode file system keeps a log each time some user performs a change folder operation.

The operations are described below:

"../" : Move to the parent folder of the current folder. (If you are already in the main folder, remain in the same folder).
"./" : Remain in the same folder.
"x/" : Move to the child folder named x (This folder is guaranteed to always exist).

You are given a list of strings logs where logs[i] is the operation performed by the user at the i^th step.

The file system starts in the main folder, then the operations in logs are performed.

Return the minimum number of operations needed to go back to the main folder after the change folder operations.

Example 1:

Input: logs = ["d1/","d2/","../","d21/","./"]
Output: 2
Explanation: Use this change folder operation "../" 2 times and go back to the main folder.

Example 2:

Input: logs = ["d1/","d2/","./","d3/","../","d31/"]
Output: 3

Example 3:

Input: logs = ["d1/","../","../","../"]
Output: 0

Constraints:

1 <= logs.length <= 10³
2 <= logs[i].length <= 10
logs[i] contains lowercase English letters, digits, '.', and '/'.
logs[i] follows the format described in the statement.
Folder names consist of lowercase English letters and digits.

Solution: Simulation

We only need to track the depth of current folder, and name and path can be ignored.

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

C++

// Author: Huahua

class Solution {

public:

int minOperations(vector<string>& logs) {

int ans = 0;

for (const string& log : logs) {

if (log == "../")

ans = max(ans - 1, 0);

else if (log != "./")

++ans;

}

return ans;

}

};

花花酱 LeetCode 1592. Rearrange Spaces Between Words

By zxi on September 20, 2020

You are given a string text of words that are placed among some number of spaces. Each word consists of one or more lowercase English letters and are separated by at least one space. It’s guaranteed that text contains at least one word.

Rearrange the spaces so that there is an equal number of spaces between every pair of adjacent words and that number is maximized. If you cannot redistribute all the spaces equally, place the extra spaces at the end, meaning the returned string should be the same length as text.

Return the string after rearranging the spaces.

Example 1:

Input: text = "  this   is  a sentence "
Output: "this   is   a   sentence"
Explanation: There are a total of 9 spaces and 4 words. We can evenly divide the 9 spaces between the words: 9 / (4-1) = 3 spaces.

Example 2:

Input: text = " practice   makes   perfect"
Output: "practice   makes   perfect "
Explanation: There are a total of 7 spaces and 3 words. 7 / (3-1) = 3 spaces plus 1 extra space. We place this extra space at the end of the string.

Example 3:

Input: text = "hello   world"
Output: "hello   world"

Example 4:

Input: text = "  walks  udp package   into  bar a"
Output: "walks  udp  package  into  bar  a "

Example 5:

Input: text = "a"
Output: "a"

Constraints:

1 <= text.length <= 100
text consists of lowercase English letters and ' '.
text contains at least one word.

Solution: Simulation

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

C++

// Author: Huahua

class Solution {

public:

string reorderSpaces(string text) {

vector<string> words;

string word;

int t = 0;

for (char c : text) {

if (c == ' ') {

++t;

if (!word.empty()) {

words.push_back(word);

word.clear();

}

} else {

word += c;

}

if (!word.empty()) words.push_back(word);

const int n = words.size();

if (n == 1) return words[0] + string(t, ' ');

const int s = t / (n - 1);

const int r = t % (n - 1);

string ans;

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

if (i) ans.append(s, ' ');

ans += words[i];

}

ans.append(r, ' ');

return ans;

}

};

花花酱 LeetCode 1582. Special Positions in a Binary Matrix

By zxi on September 12, 2020

Given a rows x cols matrix mat, where mat[i][j] is either 0 or 1, return the number of special positions in mat.

A position (i,j) is called special if mat[i][j] == 1 and all other elements in row i and column j are 0 (rows and columns are 0-indexed).

Example 1:

Input: mat = [[1,0,0],
              [0,0,1],
              [1,0,0]]
Output: 1
Explanation: (1,2) is a special position because mat[1][2] == 1 and all other elements in row 1 and column 2 are 0.

Example 2:

Input: mat = [[1,0,0],
              [0,1,0],
              [0,0,1]]
Output: 3
Explanation: (0,0), (1,1) and (2,2) are special positions.

Example 3:

Input: mat = [[0,0,0,1],
              [1,0,0,0],
              [0,1,1,0],
              [0,0,0,0]]
Output: 2

Example 4:

Input: mat = [[0,0,0,0,0],
              [1,0,0,0,0],
              [0,1,0,0,0],
              [0,0,1,0,0],
              [0,0,0,1,1]]
Output: 3

Constraints:

rows == mat.length
cols == mat[i].length
1 <= rows, cols <= 100
mat[i][j] is 0 or 1.

Solution: Sum for each row and column

Brute force:
Time complexity: O(R*C*(R+C))
Space complexity: O(1)

We can pre-compute the sums for each row and each column, ans = sum(mat[r][c] == 1 and rsum[r] == 1 and csum[c] == 1)

Time complexity: O(R*C)
Space complexity: O(R+C)

C++

class Solution {

public:

int numSpecial(vector<vector<int>>& mat) {

const int rows = mat.size();

const int cols = mat[0].size();

vector<int> rs(rows);

vector<int> cs(cols);

for (int r = 0; r < rows; ++r)

for (int c = 0; c < cols; ++c) {

rs[r] += mat[r][c];

cs[c] += mat[r][c];

}

int ans = 0;

for (int r = 0; r < rows; ++r)

for (int c = 0; c < cols; ++c)

ans += mat[r][c] && rs[r] == 1 && cs[c] == 1;

return ans;

}

};