Posts tagged as “array”

花花酱 LeetCode 26. Remove Duplicates from Sorted Array

By zxi on October 2, 2018

Problem

Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,0,1,1,1,2,2,3,3,4],

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively. It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.

Internally you can think of this:

// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

Solution:

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int removeDuplicates(vector<int>& nums) {

const int n = nums.size();

if (n <= 1) return n;

int ans = 0;

int i = 0;

while (i < n) {

nums[ans++] = nums[i];

int j = i + 1;

while (j < n && nums[j] == nums[j - 1]) ++j;

i = j;

}

return ans;

}

};

花花酱 LeetCode 896. Monotonic Array

By zxi on September 1, 2018

An array is monotonic if it is either monotone increasing or monotone decreasing.

An array A is monotone increasing if for all i <= j, A[i] <= A[j]. An array A is monotone decreasing if for all i <= j, A[i] >= A[j].

Return true if and only if the given array A is monotonic.

Solution:

C++

// Author: Huahua

class Solution {

public:

bool isMonotonic(vector<int>& A) {

bool inc = true;

bool dec = true;

for (int i = 1; i < A.size(); ++i) {

inc &= A[i] >= A[i - 1];

dec &= A[i] <= A[i - 1];

}

return inc || dec;

}

};

Java

class Solution {

public boolean isMonotonic(int[] A) {

boolean inc = true;

boolean dec = true;

for (int i = 1; i < A.length; ++i) {

inc &= A[i] >= A[i - 1];

dec &= A[i] <= A[i - 1];

}

return inc || dec;

}

Python

# Author: Huahua

class Solution:

def isMonotonic(self, A):

inc = True;

dec = True;

for i in range(1, len(A)):

inc = inc and A[i] >= A[i - 1]

dec = dec and A[i] <= A[i - 1]

return inc or dec;

花花酱 LeetCode 888. Fair Candy Swap

By zxi on August 19, 2018

Problem

Alice and Bob have candy bars of different sizes: A[i] is the size of the i-th bar of candy that Alice has, and B[j] is the size of the j-th bar of candy that Bob has.

Since they are friends, they would like to exchange one candy bar each so that after the exchange, they both have the same total amount of candy. (The total amount of candy a person has is the sum of the sizes of candy bars they have.)

Return an integer array ans where ans[0] is the size of the candy bar that Alice must exchange, and ans[1] is the size of the candy bar that Bob must exchange.

If there are multiple answers, you may return any one of them. It is guaranteed an answer exists.

Example 1:

Input: A = [1,1], B = [2,2]
Output: [1,2]

Example 2:

Input: A = [1,2], B = [2,3]
Output: [1,2]

Example 3:

Input: A = [2], B = [1,3]
Output: [2,3]

Example 4:

Input: A = [1,2,5], B = [2,4]
Output: [5,4]

Note:

1 <= A.length <= 10000
1 <= B.length <= 10000
1 <= A[i] <= 100000
1 <= B[i] <= 100000
It is guaranteed that Alice and Bob have different total amounts of candy.
It is guaranteed there exists an answer.

Solution: HashTable

Time complexity: O(A+B)

Space complexity: O(B)

Clean version

// Author: Huahua

// Running time: 132 ms

class Solution {

public:

vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {

int sum_a = accumulate(begin(A), end(A), 0);

int sum_b = accumulate(begin(B), end(B), 0);

unordered_set<int> s(begin(B), end(B));

int diff = (sum_b - sum_a) / 2;

for (int a : A)

if (s.count(a + diff)) return {a, a + diff};

}

};

Faster version

// Author: Huahua

// Running time: 68 ms

class Solution {

public:

vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {

int sum_a = accumulate(begin(A), end(A), 0);

int sum_b = 0;

unordered_set<int> s;

for (int b : B) {

sum_b += b;

s.insert(b);

}

int diff = (sum_b - sum_a) / 2;

for (int a : A)

if (s.count(a + diff)) return {a, a + diff};

}

};

花花酱 LeetCode 303. Range Sum Query – Immutable

By zxi on August 17, 2018

Problem

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

Example:

Given nums = [-2, 0, 3, -5, 2, -1]

sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3

Note:

You may assume that the array does not change.
There are many calls to sumRange function.

Solution: Prefix sum

sums[i] = nums[0] + nums[1] + … + nums[i]

sumRange(i, j) = sums[j] – sums[i – 1]

Time complexity: pre-compute: O(n), query: O(1)

Space complexity: O(n)

// Author: Huahua

// Running time: 112 ms

class NumArray {

public:

NumArray(vector<int> nums): sums_(nums) {

if (nums.empty()) return;

for (int i = 1; i < nums.size();++i)

sums_[i] += sums_[i - 1];

}

int sumRange(int i, int j) {

if (i == 0) return sums_[j];

return sums_[j] - sums_[i-1];

}

private:

vector<int> sums_;

};

花花酱 LeetCode 561. Array Partition I

By zxi on August 16, 2018

Problem

Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a₁, b₁), (a₂, b₂), …, (a_n, b_n) which makes sum of min(a_i, b_i) for all i from 1 to n as large as possible.

Example 1:

Input: [1,4,3,2]

Output: 4
Explanation: n is 2, and the maximum sum of pairs is 4 = min(1, 2) + min(3, 4).

Note:

n is a positive integer, which is in the range of [1, 10000].
All the integers in the array will be in the range of [-10000, 10000].

Solution 1: Sorting

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua

// Running time: 52 ms

class Solution {

public:

int arrayPairSum(vector<int>& nums) {

std::sort(nums.begin(), nums.end());

int ans = 0;

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

ans += nums[i];

return ans;

}

};

Solution 2: HashTable

Time complexity: O(n + max(nums) – min(nums))

Space complexity: O(max(nums) – min(nums))

// Author: Huahua

// Running time: 39 ms

class Solution {

public:

int arrayPairSum(vector<int>& nums) {

const int max_val = *max_element(begin(nums), end(nums));

const int min_val = *min_element(begin(nums), end(nums));

const int offset = -min_val;

vector<int> c(max_val - min_val + 1);

for (int num : nums)

++c[num + offset];

int ans = 0;

int index = 0;

int n = min_val;

while (n <= max_val) {

if (c[n + offset] == 0) {

++n;

continue;

}

ans += (++index & 1) ? n : 0;

--c[n + offset];

}

return ans;

}

};