304 North Cardinal St.
Dorchester Center, MA 02124

# Weekly Contest 277 LeetCode Solution

## Problem 1 – Count Elements With Strictly Smaller and Greater Elements Leetcode Solution

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`

### Count Elements With Strictly Smaller and Greater Elements Leetcode Solution in C++

``````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;
}
};
``````

### Count Elements With Strictly Smaller and Greater Elements Leetcode Solution in Java

``````class Solution {
public int countElements(int[] nums) {
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
for (int i = 0; i < nums.length; ++i) {
min = Math.min(min, nums[i]);
max = Math.max(max, nums[i]);
}
int count = 0;
for (int i = 0; i < nums.length; ++i) {
if (nums[i] > min && nums[i] < max) {
count++;
}
}
return count;
}
}
``````

### Count Elements With Strictly Smaller and Greater Elements Leetcode Solution in Python

``````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)
``````

### Count Elements With Strictly Smaller and Greater Elements Leetcode Solution in Python 3

``````class Solution:
def countElements(self, nums: List[int]) -> int:
mi = min(nums)
ma = max(nums)
check = Counter(nums)
ans = max(0,len(nums)-check[mi]-check[ma])
return ans
``````

## Problem 2 – Rearrange Array Elements by Sign Leetcode Solution

You are given a 0-indexed integer array `nums` of even length consisting of an equal number of positive and negative integers.

You should rearrange the elements of `nums` such that the modified array follows the given conditions:

1. Every consecutive pair of integers have opposite signs.
2. For all integers with the same sign, the order in which they were present in `nums` is preserved.
3. The rearranged array begins with a positive integer.

Return the modified array after rearranging the elements to satisfy the aforementioned conditions.

Example 1:

``````Input: nums = [3,1,-2,-5,2,-4]
Output: [3,-2,1,-5,2,-4]
Explanation:
The positive integers in nums are [3,1,2]. The negative integers are [-2,-5,-4].
The only possible way to rearrange them such that they satisfy all conditions is [3,-2,1,-5,2,-4].
Other ways such as [1,-2,2,-5,3,-4], [3,1,2,-2,-5,-4], [-2,3,-5,1,-4,2] are incorrect because they do not satisfy one or more conditions.  ``````

Example 2:

``````Input: nums = [-1,1]
Output: [1,-1]
Explanation:
1 is the only positive integer and -1 the only negative integer in nums.
So nums is rearranged to [1,-1].
``````

Constraints:

• `2 <= nums.length <= 2 * 105`
• `nums.length` is even
• `1 <= |nums[i]| <= 105`
• `nums` consists of equal number of positive and negative integers.

### Rearrange Array Elements by Sign Leetcode Solution in C++

``````vector<int> rearrangeArray(vector<int>& nums) {
vector<int> ans(n,0);
int indexpos = 0, indexneg=1;
for(auto num: nums){
if(num>0){
ans[indexpos] = num;
indexpos+=2;
}
if(num<0){
ans[indexneg] = num;
indexneg += 2;
}
}
return ans;

}
``````

### Rearrange Array Elements by Sign Leetcode Solution in Python 3

``````class Solution:
def rearrangeArray(self, nums: List[int]) -> List[int]:
a=[0]*len(nums)
p=0
n=1
for i in nums:
if i>0:
a[p]=i
p+=2
else:
a[n]=i
n+=2
return a
``````

### Rearrange Array Elements by Sign Leetcode Solution in Java

``````class Solution {
public int[] rearrangeArray(int[] nums) {
int [] out = new int [nums.length];
int j = 0;
int k = 1;
for(int i=0;i<nums.length;i++){
if(nums[i] >= 0){
out[j] = nums[i];
j += 2;
}else {
out[k] = nums[i];
k += 2;
}
}
return out;
}
}
``````

### Rearrange Array Elements by Sign Leetcode Solution in Python

``````class Solution:
def rearrangeArray(self, nums: List[int]) -> List[int]:
l1=[0]*len(nums)
a=1
b=0
for i in nums:
if "-" in str(i):
l1[a]=i
a+=2
else:
l1[b]=i
b+=2

return(l1)
``````

### Rearrange Array Elements by Sign Leetcode Solution in JavaScript

``````var rearrangeArray = function (nums) {
let n = nums.length;
let pos = 0;
let neg = 0;
let cur = -1;
while (pos < n && nums[pos] < 0) pos++;
while (neg < n && nums[neg] > 0) neg++;
for (let i = 0; i < n; i++) {
cur = cur === -1 ? 1 : -1;
if (cur === 1 && nums[i] > 0) {
pos++;
while (pos < n && nums[pos] < 0) pos++;
continue;
}
if (cur === -1 && nums[i] < 0) {
neg++;
while (neg < n && nums[neg] > 0) neg++;
continue;
}

let index = pos === i ? neg : pos;
let tmp = nums[index];
for (let k = index; k > i; k--) {
nums[k] = nums[k - 1];
}
nums[i] = tmp;

neg = i + 1;
pos = i + 1;
while (neg < n && nums[neg] > 0) neg++;
while (pos < n && nums[pos] < 0) pos++;
}
return nums;
};

``````

## Problem 3 – Find All Lonely Numbers in the Array Leetcode Solution

You are given an integer array `nums`. A number `x` is lonely when it appears only once, and no adjacent numbers (i.e. `x + 1` and `x - 1)` appear in the array.

Return all lonely numbers in `nums`. You may return the answer in any order.

Example 1:

``````Input: nums = [10,6,5,8]
Output: [10,8]
Explanation:
- 10 is a lonely number since it appears exactly once and 9 and 11 does not appear in nums.
- 8 is a lonely number since it appears exactly once and 7 and 9 does not appear in nums.
- 5 is not a lonely number since 6 appears in nums and vice versa.
Hence, the lonely numbers in nums are [10, 8].
Note that [8, 10] may also be returned.
``````

Example 2:

``````Input: nums = [1,3,5,3]
Output: [1,5]
Explanation:
- 1 is a lonely number since it appears exactly once and 0 and 2 does not appear in nums.
- 5 is a lonely number since it appears exactly once and 4 and 6 does not appear in nums.
- 3 is not a lonely number since it appears twice.
Hence, the lonely numbers in nums are [1, 5].
Note that [5, 1] may also be returned.
``````

Constraints:

• `1 <= nums.length <= 105`
• `0 <= nums[i] <= 106`

### Find All Lonely Numbers in the Array Leetcode Solution in Python 3

``````class Solution:
def findLonely(self, nums: List[int]) -> List[int]:
m = Counter(nums)
return [n for n in nums if m[n] == 1 and m[n - 1] + m[n + 1] == 0]
``````

### Find All Lonely Numbers in the Array Leetcode Solution in C++

``````vector<int> findLonely(vector<int>& nums) {
unordered_map<int, int> m;
vector<int> res;
for (int n : nums)
++m[n];
for (const auto [n, cnt] : m)
if (cnt == 1 && m.count(n + 1) == 0 && m.count(n - 1) == 0)
res.push_back(n);
return res;
}
``````

### Find All Lonely Numbers in the Array Leetcode Solution in Java

``````public List<Integer> findLonely(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
for (int num : nums) {
map.put(num, map.getOrDefault(num, 0) + 1);
}
List<Integer> res = new ArrayList<>();
for (int num : map.keySet()) {
//  for (int num : nums) {
if (map.get(num) == 1 && !map.containsKey(num - 1) && !map.containsKey(num + 1)) {
}
}
return res;
}
``````

### Find All Lonely Numbers in the Array Leetcode Solution in JavaScript

``````var findLonely = function(nums) {
let countMap = new Map();
let result = [];
for (let num of nums) {
countMap.set(num, (countMap.get(num) || 0) + 1);
}
for (let num of nums) {
if (!countMap.has(num - 1) && !countMap.has(num + 1) && countMap.get(num) === 1) {

result.push(num);
}

}
return result;
};
``````

### Find All Lonely Numbers in the Array Leetcode Solution in C#

``````public class Solution
{
public IList<int> FindLonely(int[] nums)
{
var dict = nums.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());
return nums.Where(x => dict[x] == 1 && !dict.ContainsKey(x - 1) && !dict.ContainsKey(x + 1)).ToList();
}
}
``````

### Find All Lonely Numbers in the Array Leetcode Solution in Python

``````class Solution:
def findLonely(self, nums: List[int]) -> List[int]:
counter=defaultdict(int)
ans=[]
for i in nums:
counter[i]+=1
for i in nums:
if counter[i-1] or counter [i+1] or counter[i]>1: continue
ans.append(i)
return ans

``````

## Problem 4 – Maximum Good People Based on Statements Leetcode Solution

There are two types of persons:

• The good person: The person who always tells the truth.
• The bad person: The person who might tell the truth and might lie.

You are given a 0-indexed 2D integer array `statements` of size `n x n` that represents the statements made by `n` people about each other. More specifically, `statements[i][j]` could be one of the following:

• `0` which represents a statement made by person `i` that person `j` is a bad person.
• `1` which represents a statement made by person `i` that person `j` is a good person.
• `2` represents that no statement is made by person `i` about person `j`.

Additionally, no person ever makes a statement about themselves. Formally, we have that `statements[i][i] = 2` for all `0 <= i < n`.

Return the maximum number of people who can be good based on the statements made by the `n` people.

Example 1:

``````Input: statements = [[2,1,2],[1,2,2],[2,0,2]]
Output: 2
Explanation: Each person makes a single statement.
- Person 0 states that person 1 is good.
- Person 1 states that person 0 is good.
- Person 2 states that person 1 is bad.
Let's take person 2 as the key.
- Assuming that person 2 is a good person:
- Based on the statement made by person 2, person 1 is a bad person.
- Now we know for sure that person 1 is bad and person 2 is good.
- Based on the statement made by person 1, and since person 1 is bad, they could be:
- telling the truth. There will be a contradiction in this case and this assumption is invalid.
- lying. In this case, person 0 is also a bad person and lied in their statement.
- Following that person 2 is a good person, there will be only one good person in the group.
- Assuming that person 2 is a bad person:
- Based on the statement made by person 2, and since person 2 is bad, they could be:
- telling the truth. Following this scenario, person 0 and 1 are both bad as explained before.
- Following that person 2 is bad but told the truth, there will be no good persons in the group.
- lying. In this case person 1 is a good person.
- Since person 1 is a good person, person 0 is also a good person.
- Following that person 2 is bad and lied, there will be two good persons in the group.
We can see that at most 2 persons are good in the best case, so we return 2.
Note that there is more than one way to arrive at this conclusion.
``````

Example 2:

``````Input: statements = [[2,0],[0,2]]
Output: 1
Explanation: Each person makes a single statement.
- Person 0 states that person 1 is bad.
- Person 1 states that person 0 is bad.
Let's take person 0 as the key.
- Assuming that person 0 is a good person:
- Based on the statement made by person 0, person 1 is a bad person and was lying.
- Following that person 0 is a good person, there will be only one good person in the group.
- Assuming that person 0 is a bad person:
- Based on the statement made by person 0, and since person 0 is bad, they could be:
- telling the truth. Following this scenario, person 0 and 1 are both bad.
- Following that person 0 is bad but told the truth, there will be no good persons in the group.
- lying. In this case person 1 is a good person.
- Following that person 0 is bad and lied, there will be only one good person in the group.
We can see that at most, one person is good in the best case, so we return 1.
Note that there is more than one way to arrive at this conclusion.
``````

Constraints:

• `n == statements.length == statements[i].length`
• `2 <= n <= 15`
• `statements[i][j]` is either `0``1`, or `2`.
• `statements[i][i] == 2`

### Maximum Good People Based on Statements Leetcode Solution in C++

``````class Solution {
public:
int n, ans = 0;
int maximumGood(vector<vector<int>>& S) {
n = size(S);
string cur = ""; cur.reserve(n);
dfs(S, cur, 0, 0);
return ans;
}
void dfs(vector<vector<int>>& S, string& cur, int i, int cnt) {
if(i == n) {
// if valid, update ans to store maximum good person found till now
if(valid(S, cur)) ans = max(ans, cnt);
return;
}
cur.append(1, '0');
dfs(S, cur, i+1, cnt);        // assuming ith person is bad
cur.back() = '1';
dfs(S, cur, i+1, cnt + 1);    // assuming ith person is good
cur.pop_back();
}
bool valid(vector<vector<int>>& S, string& cur) {
for(int i = 0; i < n; i++)
if(cur[i] == '1')
for(int j = 0; j < n; j++)
if(S[i][j] != 2 && S[i][j] != cur[j] - '0') return false;
return true;
}
};
``````

### Maximum Good People Based on Statements Leetcode Solution in Python

``````class Solution:
def maximumGood(self, S):
n, ans = len(S), 0
def valid(cur):
for i in range(n):
if cur[i]:
for j in range(n):
if S[i][j] != 2 and S[i][j] != cur[j]: return False
return True;
def dfs(cur, i, cnt):
nonlocal ans
if i == n:
if valid(cur): ans = max(ans, cnt)
return
cur.append(0)
dfs(cur, i+1, cnt)
cur[-1] = 1
dfs(cur, i+1, cnt+1)
cur.pop()

dfs([], 0, 0)
return ans
``````

### Maximum Good People Based on Statements Leetcode Solution in Java

``````class Solution {
static int BAD= 0,  GOOD= 1, UNKNOWN= 2;

public int maximumGood(int[][] statements) {
int n= statements.length;
int max= 0, combos= 1<<n;
int[] roles= new int[n];
if(possible(statements, roles))
max= Math.max(max, count);
}
return max;
}

// convert bitmask to role array, count good people in this mask
// (this part is optional, you can operate on bitmasks directly, but I like it this way to make the checking function's code easy)
int count= 0, n= roles.length;
for(int i=0; i<n; i++){
}
return count;
}

// verify the n x n statement matrix against the current combination of roles
boolean possible(int[][] statements, int[] roles){
int n= statements.length;
for(int i=0; i<n; i++){
// only check statements of good people
for(int j=0; j<n; j++){
if(statements[i][j]==UNKNOWN) continue;
// statement of a good person contradicts the assigned role in this combination
if(statements[i][j]!=roles[j]) return false;
}
}
return true;
}
}
``````
##### Weekly Contest 277 LeetCode Solution Review:

In our experience, we suggest you solve this Weekly Contest 277 LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Weekly Contest 277 LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Weekly Contest 277 LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions