Coffee Time
0%

Posted on In Words count: 2.7k Reading time ≈ 2 mins.

2360. Longest Cycle in a Graph

1
2
3
4
5
6
7
8
9
10
You are given a directed graph of n nodes numbered from 0 to n - 1, where each node has at most one outgoing edge.

The graph is represented with a given 0-indexed array edges of size n, indicating that there is a directed edge from node i to node edges[i]. If there is no outgoing edge from node i, then edges[i] == -1.

Return the length of the longest cycle in the graph. If no cycle exists, return -1.

A cycle is a path that starts and ends at the same node.



Example 1:


1
2
3
4
Input: edges = [3,3,4,2,3]
Output: 3
Explanation: The longest cycle in the graph is the cycle: 2 -> 4 -> 3 -> 2.
The length of this cycle is 3, so 3 is returned.

Example 2:


1
2
3
Input: edges = [2,-1,3,1]
Output: -1
Explanation: There are no cycles in this graph.

Constraints:

1
2
3
4
- n == edges.length
- 2 <= n <= 105
- -1 <= edges[i] < n
- edges[i] != i

Difficulty : Hard

Read more »

Posted on In Words count: 1.8k Reading time ≈ 2 mins.

2348. Number of Zero-Filled Subarrays

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Given an integer array nums, return the number of subarrays filled with 0.

A subarray is a contiguous non-empty sequence of elements within an array.

 

Example 1:

Input: nums = [1,3,0,0,2,0,0,4]
Output: 6
Explanation: 
There are 4 occurrences of [0] as a subarray.
There are 2 occurrences of [0,0] as a subarray.
There is no occurrence of a subarray with a size more than 2 filled with 0. Therefore, we return 6.
Example 2:

Input: nums = [0,0,0,2,0,0]
Output: 9
Explanation:
There are 5 occurrences of [0] as a subarray.
There are 3 occurrences of [0,0] as a subarray.
There is 1 occurrence of [0,0,0] as a subarray.
There is no occurrence of a subarray with a size more than 3 filled with 0. Therefore, we return 9.
Example 3:

Input: nums = [2,10,2019]
Output: 0
Explanation: There is no subarray filled with 0. Therefore, we return 0.
 

Constraints:

1 <= nums.length <= 105
-109 <= nums[i] <= 109

Difficulty : Medium

Read more »

Posted on In Words count: 2.8k Reading time ≈ 3 mins.

A Beginner’s Guide to Scala Parser Combinators

Introduction

Scala parser combinators are a powerful library for writing text parsers. This library allows you to create
parsers by combining smaller, simpler parsers using higher-order functions called combinators.

What are Scala Parser Combinators and their API

Scala parser combinators are a parsing library built on the idea of combining simple parsers to create more complex parsers. The main components of the library are:

  • Parser: A basic building block that represents a parser for a specific input.
  • RegexParsers: A trait that provides the ability to create parsers from regular expressions.
  • Parsers: A trait that contains the basic combinators for constructing new parsers.

To use the library, you need to extend the Parsers trait or one of its subclasses (like RegexParsers).
Then, you can define your parsers by combining the basic parsers and combinators provided by the library.

Read more »

Posted on In Words count: 1.1k Reading time ≈ 1 mins.

1941. Check if All Characters Have Equal Number of Occurrences

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Given a string s, return true if s is a good string, or false otherwise.

A string s is good if all the characters that appear in s have the same number of occurrences (i.e., the same frequency).

 

Example 1:

Input: s = "abacbc"
Output: true
Explanation: The characters that appear in s are 'a', 'b', and 'c'. All characters occur 2 times in s.
Example 2:

Input: s = "aaabb"
Output: false
Explanation: The characters that appear in s are 'a' and 'b'.
'a' occurs 3 times while 'b' occurs 2 times, which is not the same number of times.
 

Constraints:

1 <= s.length <= 1000
s consists of lowercase English letters.
Read more »

Posted on In Words count: 844 Reading time ≈ 1 mins.

905. Sort Array By Parity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Given an integer array nums, move all the even integers at the beginning of the array followed by all the odd integers.

Return any array that satisfies this condition.

 

Example 1:

Input: nums = [3,1,2,4]
Output: [2,4,3,1]
Explanation: The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
Example 2:

Input: nums = [0]
Output: [0]
 

Constraints:

1 <= nums.length <= 5000
0 <= nums[i] <= 5000

Difficulty : Easy

Read more »