Your browser (Unknown 0) is no longer supported. Some parts of the website may not work correctly. Please update your browser.

UPCOMING CHALLENGES:

CURRENT CHALLENGES:

Neon 2014

PAST CHALLENGES

Fluorum 2014

Oxygenium 2014

Nitrogenium 2013

Carbo 2013

Boron 2013

Beryllium 2013

Lithium 2013

Helium 2013

Hydrogenium 2013

Omega 2013

Psi 2012

Chi 2012

Phi 2012

Upsilon 2012

Tau 2012

Sigma 2012

Rho 2012

Pi 2012

Omicron 2012

Xi 2012

Nu 2011

Mu 2011

Lambda 2011

Kappa 2011

Iota 2011

Theta 2011

Eta 2011

Zeta 2011

Epsilon 2011

Delta 2011

Gamma 2011

December 2010

PrefixSet edition (2010-10)

Find the maximal product of string prefixes.

Spoken language:

A *prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

The *product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

The longest prefix is identical to the original string. The goal is to choose such a prefix as maximizes the value of the product. In above example the maximal product is 10.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

int solution(char *S);

that, given a string S consisting of N characters, returns the maximal product of any prefix of the given string. If the product is greater than 1,000,000,000 the function should return 1,000,000,000.

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

Copyright 2009–2023 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

A *prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

The *product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

The longest prefix is identical to the original string. The goal is to choose such a prefix as maximizes the value of the product. In above example the maximal product is 10.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

int solution(string &S);

that, given a string S consisting of N characters, returns the maximal product of any prefix of the given string. If the product is greater than 1,000,000,000 the function should return 1,000,000,000.

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

Copyright 2009–2023 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

A *prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

The *product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

The longest prefix is identical to the original string. The goal is to choose such a prefix as maximizes the value of the product. In above example the maximal product is 10.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

int solution(string &S);

that, given a string S consisting of N characters, returns the maximal product of any prefix of the given string. If the product is greater than 1,000,000,000 the function should return 1,000,000,000.

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

Copyright 2009–2023 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

class Solution { public int solution(string S); }

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

int solution(String S);

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

func Solution(S string) int

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

class Solution { public int solution(String S); }

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

class Solution { public int solution(String S); }

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

function solution(S);

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

fun solution(S: String): Int

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

function solution(S)

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

int solution(NSString *S);

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

function solution(S: PChar): longint;

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

function solution($S);

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

sub solution { my ($S) = @_; ... }

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

def solution(S)

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

def solution(s)

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

object Solution { def solution(s: String): Int }

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

public func solution(_ S : inout String) -> Int

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

function solution(S: string): number;

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).

*prefix* of a string S is any leading contiguous part of S. For example, "`c`" and "`cod`" are prefixes of the string "`codility`". For simplicity, we require prefixes to be non-empty.

*product* of prefix P of string S is the number of occurrences of P multiplied by the length of P. More precisely, if prefix P consists of K characters and P occurs exactly T times in S, then the product equals K * T.

For example, S = "`abababa`" has the following prefixes:

- "
a", whose product equals 1 * 4 = 4,- "
ab", whose product equals 2 * 3 = 6,- "
aba", whose product equals 3 * 3 = 9,- "
abab", whose product equals 4 * 2 = 8,- "
ababa", whose product equals 5 * 2 = 10,- "
ababab", whose product equals 6 * 1 = 6,- "
abababa", whose product equals 7 * 1 = 7.

In this problem we consider only strings that consist of lower-case English letters (`a`−`z`).

Write a function

Private Function solution(S As String) As Integer

For example, for a string:

- S = "
abababa" the function should return 10, as explained above,- S = "
aaa" the function should return 4, as the product of the prefix "aa" is maximal.

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..300,000];
- string S is made only of lowercase letters (
a−z).