### Problem Statement

You are given two strings, `s1` and `s2`. Your task is to find the length of the longest common substring between `s1` and `s2`.

A substring is a contiguous sequence of characters within a string, formed without skipping any character.

### Requirements
1. **Function Signature**: Implement the function `LCSLen` that takes two parameters:
   - `str1`: The first string.
   - `str2`: The second string.

2. **Output**: The function should return an integer representing the length of the longest common substring between the two given strings.

### Example
Consider the following input strings:

```javascript
console.log('Length of Longest Common Substring is', LCSLen('javascript', 'java'));
console.log('Length of Longest Common Substring is', LCSLen('headphone', 'phone'));
```

**Expected Outputs**:
```javascript
Length of Longest Common Substring is 4
Length of Longest Common Substring is 5
```

### Constraints
- The function should have a time complexity of O(n1 * n2), where n1 and n2 are the lengths of the input strings `s1` and `s2`, respectively.
- The function should use O(n1 * n2) additional space for the dynamic programming table.

### Explanation
To solve this problem, we use dynamic programming. We define a 2D array `dp` where `dp[i][j]` represents the length of the longest common substring ending at `str1[i-1]` and `str2[j-1]`.

1. **Initialization**: Create a 2D array `dp` of size `(n1+1) x (n2+1)` initialized to 0. Initialize a variable `maxLen` to store the length of the longest common substring found.
2. **Filling the DP Table**:
   - Iterate over each character in `str1` and `str2`.
   - If the characters at the current positions in the two strings match (`str1[i-1] === str2[j-1]`), update `dp[i][j]` to `1 + dp[i-1][j-1]` and update `maxLen` if `dp[i][j]` is greater than `maxLen`.
3. **Result**: The length of the longest common substring is stored in `maxLen`.

### Example Walkthrough
For the input strings `"javascript"` and `"java"`:
1. Initialize the 2D array `dp` and `maxLen`.
2. Iterate through each character in the two strings and update the `dp` table.
3. The longest common substring is `"java"`, with a length of 4.

### Algorithm
1. **Initialization**: Create a 2D array `dp` of size `(n1+1) x (n2+1)` initialized to 0. Initialize `maxLen` to 0.
2. **Filling the DP Table**: Iterate through each character in `str1` and `str2`, updating the `dp` table and `maxLen` accordingly.
3. **Return Result**: Return `maxLen`, which contains the length of the longest common substring.

### Function Signature
```javascript
function LCSLen(str1, str2) {
    // implementation here
}
```

complete.test.js

index.js

partial.test.js

Longest Common Substring

### Introduction
Finding the longest common substring between two strings is a classic problem in dynamic programming. A substring is a contiguous sequence of characters within a string, formed without skipping any characters. The longest common substring problem involves identifying the longest such sequence that appears in both given strings.

### Problem Restatement
Given two strings `s1` and `s2`, implement a function `LCSLen` that finds the length of the longest common substring between `s1` and `s2`.

### Requirements
1. **Function Signature**: Implement the function `LCSLen` that takes two parameters:
   - `str1`: The first string.
   - `str2`: The second string.

2. **Output**: The function should return an integer representing the length of the longest common substring between the two given strings.

### Example
Consider the following input strings:

```javascript
console.log('Length of Longest Common Substring is', LCSLen('javascript', 'java'));
console.log('Length of Longest Common Substring is', LCSLen('headphone', 'phone'));
```

**Expected Outputs**:
```javascript
Length of Longest Common Substring is 4
Length of Longest Common Substring is 5
```

### Constraints
- The function should have a time complexity of O(n1 * n2), where n1 and n2 are the lengths of the input strings `s1` and `s2`, respectively.
- The function should use O(n1 * n2) additional space for the dynamic programming table.

### Explanation
To solve this problem, we use dynamic programming. We define a 2D array `dp` where `dp[i][j]` represents the length of the longest common substring ending at `str1[i-1]` and `str2[j-1]`.

1. **Initialization**: Create a 2D array `dp` of size `(n1+1) x (n2+1)` initialized to 0. Initialize a variable `maxLen` to store the length of the longest common substring found.
2. **Filling the DP Table**:
   - Iterate over each character in `str1` and `str2`.
   - If the characters at the current positions in the two strings match (`str1[i-1] === str2[j-1]`), update `dp[i][j]` to `1 + dp[i-1][j-1]` and update `maxLen` if `dp[i][j]` is greater than `maxLen`.
3. **Result**: The length of the longest common substring is stored in `maxLen`.

### Example Walkthrough
For the input strings `"javascript"` and `"java"`:
1. **Initialization**: Create a 2D array `dp` of size `10 x 5` initialized to 0. Set `maxLen` to 0.
2. **Filling the DP Table**:
   - Iterate through each character in `"javascript"` and `"java"`.
   - Update the `dp` table based on matching characters and compute the maximum length of common substrings.
3. **Result**: The longest common substring is `"java"`, with a length of 4.

### Algorithm
1. **Initialization**: Create a 2D array `dp` of size `(n1+1) x (n2+1)` initialized to 0. Initialize `maxLen` to 0.
2. **Filling the DP Table**: Iterate through each character in `str1` and `str2`, updating the `dp` table and `maxLen` accordingly.
3. **Return Result**: Return `maxLen`, which contains the length of the longest common substring.

### Code Implementation

Here is the code for the `LCSLen` function:

```javascript
function LCSLen(str1, str2) {
    const n1 = str1.length;
    const n2 = str2.length;
    const dp = Array(n1+1).fill(0).map(() => Array(n2+1).fill(0));
    let maxLen = 0;
  
    for (let i = 1; i <= n1; i++) {
        for (let j = 1; j <= n2; j++) {
            if (str1[i-1] === str2[j-1]) {
                dp[i][j] = 1 + dp[i-1][j-1];
                maxLen = Math.max(maxLen, dp[i][j]);
            }
        }
    }
    return maxLen;
}
export { LCSLen };
```

### Explanation of the Code
- **Initialization**: The 2D array `dp` is created and initialized to 0. `maxLen` is initialized to 0.
- **Filling the DP Table**: The outer loop iterates over the characters in `str1`, and the inner loop iterates over the characters in `str2`. If the characters match, `dp[i][j]` is updated to `1 + dp[i-1][j-1]`, and `maxLen` is updated if necessary.
- **Return Result**: The function returns the value of `maxLen`, which represents the length of the longest common substring.

### Conclusion
The solution efficiently finds the length of the longest common substring between two given strings using dynamic programming. This approach ensures that the function operates in O(n1 * n2) time complexity with O(n1 * n2) additional space, meeting the problem's constraints. The dynamic programming method is both intuitive and effective for identifying common substrings.