CSES Solutions Repetitions (original) (raw)

Last Updated : 16 Mar, 2024

You are given a DNA sequence: a string **S consisting of characters A, C, G, and T. Your task is to find the longest repetition in the sequence. This is a maximum-length substring containing only one type of character.

**Examples:

**Input: S = "ATTCGGGA"
**Output: 3
**Explanation: The longest repetition in the sequence is "GGG" which has a length of 3.

**Input: S ="AATTGGCCCC"
**Output: 4
**Explanation: The longest repetition in the sequence is "CCCC" which has a length of 4.

**Approach: To solve the problem, follow the below idea:

The problem can be solved by maintaining the **running count of contiguous characters. Iterate over the string and if the current character is same as the previous character, then we can **increment the count by 1 otherwise we can **reset the count to 1. Also maintain another variable to store the maximum value of count in any iteration.

**Step-by-step algorithm:

• Maintain a variable **count to store the running count of the contiguous character.
• Iterate over the string, if the current character is same as the previous character, increment count by 1.
• Otherwise reset count to 1.
• Also keep checking for the maximum value of count and store it in ans.
• After iterating over the entire string, return **ans as the final result.

Below is the implementation of the algorithm:

C++ `

#include <bits/stdc++.h> using namespace std;

int solve(string S) { int ans = 1, count = 1; for (int i = 1; i < S.length(); i++) { // If the current character is same as the previous // character, then increment the count if (S[i] == S[i - 1]) count += 1; else // If the current character is different from // the previous character, then reset count to 1 count = 1; ans = max(ans, count); } return ans; }

int main() { // Input string S = "AATTGGCCCC";

cout << solve(S) << endl;
return 0;

}

Java

public class Main {

static int solve(String S) {
    int ans = 1, count = 1;
    for (int i = 1; i < S.length(); i++) {
        // If the current character is same as the previous
        // character, then increment the count
        if (S.charAt(i) == S.charAt(i - 1))
            count += 1;
        else
            // If the current character is different from
            // the previous character, then reset count to 1
            count = 1;
        ans = Math.max(ans, count);
    }
    return ans;
}

public static void main(String[] args) {
    // Input
    String S = "AATTGGCCCC";

    System.out.println(solve(S));
}

}

C#

using System;

class GFG { static int Solve(string S) { int ans = 1, count = 1; for (int i = 1; i < S.Length; i++) { // If the current character is same as the previous // character then increment the count if (S[i] == S[i - 1]) count += 1; else // If the current character is different from // previous character then reset count to 1 count = 1;

        ans = Math.Max(ans, count);
    }
    return ans;
}
static void Main(string[] args)
{
    // Input
    string S = "AATTGGCCCC";

    Console.WriteLine(Solve(S));
}

}

JavaScript

function GFG(S) { let ans = 1; let count = 1; for (let i = 1; i < S.length; i++) { // If the current character is same as the previous character // then increment the count if (S[i] === S[i - 1]) { count += 1; } else { count = 1; } // Update ans with maximum count encountered so far ans = Math.max(ans, count); } return ans; } // Sample Input const S = "AATTGGCCCC"; console.log(GFG(S));

Python3

def solve(S): ans = 1 count = 1

for i in range(1, len(S)):
    # If the current character is same as the previous
    # character then increment the count
    if S[i] == S[i - 1]:
        count += 1
    else:
        # If the current character is different from
        # the previous character then reset count to 1
        count = 1

    ans = max(ans, count)

return ans

Main function

if name == "main": # Input S = "AATTGGCCCC"

print(solve(S))

This code is contributed by shivamgupta310570

`

**Time Complexity: O(N), where **N is the length of input string **S.
**Auxiliary Space: O(1)