Solution For Substring With Largest Variance

The Substring With Largest Variance problem on LeetCode is a medium-level question that asks you to find the substring of a given string that has the largest variance of its characters.

The problem statement is as follows:

Given a string s containing n characters, find the substring of s that has the largest variance of its characters. The variance of a substring is defined as the difference between the maximum and minimum ASCII value of its characters.

Example:

Input: “abcdefg”
Output: 103
Explanation: The substring with the largest variance is “g” which has a variance of 103 (the ASCII value of ‘g’ is 103, and the ASCII value of ‘a’ is 97).

To solve this problem, we can use a sliding window technique. We will keep track of the minimum and maximum ASCII values of the characters in the current window and calculate the variance. We will move the window to the right one character at a time and update the minimum and maximum values accordingly.

Here is the step-by-step solution:

1. Initialize variables

We start by initializing variables that we will use in the solution:

• `max_var` – the maximum variance that we will find
• `start` – the starting index of the substring with the largest variance
• `min_val` – the minimum ASCII value of the characters in the current window
• `max_val` – the maximum ASCII value of the characters in the current window

We will set the initial values of `max_var` and `start` to 0.

1. Start the sliding window

We will start the sliding window from the beginning of the string s. We will use a for loop to iterate through the string s.

For each iteration, we will do the following:

• Update the minimum and maximum values if necessary
• Calculate the variance of the current window
• Update `max_var` and `start` if the current variance is larger than the previous maximum variance.

Here is the code:

“`
max_var = 0
start = 0
min_val = ord(s[0])
max_val = ord(s[0])

for i in range(1, len(s)):
# update minimum and maximum values
if ord(s[i]) < min_val:
min_val = ord(s[i])
if ord(s[i]) > max_val:
max_val = ord(s[i])

``````# calculate variance
variance = max_val - min_val

# update max_var and start
if variance > max_var:
max_var = variance
start = i - (max_val == ord(s[i])) # the start index should be updated according to the maximum ASCII value
``````

return max_var
“`

After the for loop finishes, we return the `max_var` variable.

This solution has a time complexity of O(n), where n is the length of the input string s, since we iterate through the string once. The space complexity is O(1), since we use only a constant amount of extra space to store the variables.

Step by Step Implementation For Substring With Largest Variance

```class Solution {
public int findSubstringInWraproundString(String p) {
// keep track of the longest substring ending at each position
int[] longest = new int[26];

// keep track of the length of the current substring
int currLength = 0;

for (int i = 0; i < p.length(); i++) {
// if the current character is the next character in alphabetical order
if (i > 0 && (p.charAt(i) - p.charAt(i - 1) == 1 || (p.charAt(i - 1) - p.charAt(i) == 25))) {
currLength++;
}
// otherwise, the current substring ends
else {
currLength = 1;
}

// update the longest substring ending at this position
// to be the maximum of the previous longest substring
// ending at this position and the current substring length
longest[p.charAt(i) - 'a'] = Math.max(longest[p.charAt(i) - 'a'], currLength);
}

// the total number of unique substring is the sum of the longest
// substring at each position
int sum = 0;
for (int num : longest) {
sum += num;
}
return sum;
}
}```
```Given a string s of lowercase letters, return the substring with the largest variance in letter frequencies. If there is more than one substring with the same variance, return the substring that occurs earliest in the string.

def largest_variance_substring(s):

# keep track of the maximum variance and the corresponding substring
max_variance = 0
max_substring = ""

# iterate through all possible substrings of s
for i in range(len(s)):
for j in range(i+1, len(s)+1):
# get the current substring
substring = s[i:j]

# calculate the variance of the letter frequencies in the current substring
variance = 0
for letter in set(substring):
letter_frequency = substring.count(letter) / len(substring)
variance += (letter_frequency - 0.5) ** 2

# update the maximum variance and corresponding substring if necessary
if variance > max_variance:
max_variance = variance
max_substring = substring

return max_substring```
```var largestVariance = function(s) {
// create a hashmap to store the variance of each substring
// key is the substring, value is the variance
const map = {};
// create a variable to store the length of the longest substring
let maxLength = 0;
// create a variable to store the longest substring with the largest variance
let maxString = "";

// iterate through the string
for (let i = 0; i < s.length; i++) {
// create a variable to store the current substring
let currentString = "";
// create a variable to store the sum of the current substring
let sum = 0;
// create a variable to store the variance of the current substring
let variance = 0;

// iterate through the string again, starting at the current index
for (let j = i; j < s.length; j++) {
// add the current character to the current substring
currentString += s[j];
// add the current character to the sum
sum += s[j];
// calculate the length of the current substring
const length = currentString.length;
// calculate the mean of the current substring
const mean = sum / length;

// iterate through the current substring
for (let k = 0; k < currentString.length; k++) {
// calculate the variance of the current substring
variance += Math.pow((currentString[k] - mean), 2);
}

// store the current substring and its variance in the hashmap
map[currentString] = variance / length;

// if the current substring is longer than the longest substring
// and has a larger variance, update the maxLength and maxString variables
if (length > maxLength && variance / length > map[maxString]) {
maxLength = length;
maxString = currentString;
}
}
}
// return the longest substring with the largest variance
return maxString;
};```
```class Solution {
public:
int findSubstringInWraproundString(string p) {
int n = p.length();
vector dp(26, 0);
int cur = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && (p[i] - p[i - 1] == 1 || p[i - 1] - p[i] == 25)) {
cur++;
} else {
cur = 1;
}
dp[p[i] - 'a'] = max(dp[p[i] - 'a'], cur);
}
return accumulate(dp.begin(), dp.end(), 0);
}
};```
```using System;
using System.Collections.Generic;

public class Solution {

public int SubstringWithLargestVariance(string s) {

// check for empty string
if (string.IsNullOrEmpty(s)) {
return 0;
}

// keep track of the max variance
int maxVariance = 0;

// keep track of the substring with the largest variance
string maxVarianceSubstring = "";

// iterate through the string
for (int i = 0; i < s.Length; i++) {

// get the current substring
string currentSubstring = s.Substring(i);

// get the variance of the current substring
int currentVariance = GetVariance(currentSubstring);

// check if the current variance is greater than the max variance
if (currentVariance > maxVariance) {

// if so, update the max variance
maxVariance = currentVariance;

// and update the max variance substring
maxVarianceSubstring = currentSubstring;
}
}

// return the max variance substring
return maxVarianceSubstring;
}

// helper method to get the variance of a string
public int GetVariance(string s) {

// keep track of the sum of the ASCII values
int sum = 0;

// keep track of the sum of the squares of the ASCII values
int sumOfSquares = 0;

// iterate through the string
for (int i = 0; i < s.Length; i++) {

// get the ASCII value of the current character
int asciiValue = (int)s[i];

// update the sum
sum += asciiValue;

// update the sum of squares
sumOfSquares += asciiValue * asciiValue;
}

// calculate the mean
int mean = sum / s.Length;

// calculate the variance
int variance = sumOfSquares / s.Length - mean * mean;

// return the variance
return variance;
}
}```

Scroll to Top
[gravityforms id="5" description="false" titla="false" ajax="true"]