Longest of k consecutive strings

Question

I'm defining a Python function to determine the longest string if the original strings are combined for every k consecutive strings. The function takes two parameters, strarr and k.

Here is an example:

max_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2) --> "abigailtheta"

Here's my code so far (instinct is that I'm not passing k correctly within the function)

def max_consec(strarr, k):
    lenList = []
    for value in zip(strarr, strarr[k:]):
        consecStrings = ''.join(value)
        lenList.append(consecStrings)
    for word in lenList: 
        if max(word):
            return word

Here is a test case not passing:

testing(longest_consec(["zone", "abigail", "theta", "form", "libe", "zas"], 2), "abigailtheta")

My output:

'zonetheta' should equal 'abigailtheta'

Answer 1

It's not quite clear to me what you mean by "every k consecutive strings", but if you mean taking k-length slices of the list and concatenating all the strings in each slice, for example

['a', 'bb', 'ccc', 'dddd']  # k = 3

becomes

['a', 'bb', 'ccc']
['bb', 'ccc', 'dddd']

then

'abbccc'
'bbcccddd'

then this works ...

# for every item in strarr, take the k-length slice from that point and join the resulting strings
strs = [''.join(strarr[i:i + k]) for i in range(len(strarr) - k + 1)]

# find the largest by `len`gth
max(strs, key=len)

this post gives alternatives, though some of them are hard to read/verbose

Answer 2

def max_consec(strarr, k):
    n = -1
    result = ""
    for i in range(len(strarr)):
        s = ''.join(strarr[i:i+k])
        if len(s) > n:
            n = len(s)
            result = s     
    return result

• Iterate over the list of strings and create a new string concatenating it with next k strings
• Check if the newly created string is the longest. If so memorize it
• Repeat the above steps until the iterations complete
• return the memorised string

Answer 3

Store the string lengths in an array. Now assume a window of size k passing through this list. Keep track of the sum in this window and starting point of the window.

When window reaches the end of the array you should have maximum sum and index where the maximum occurs. Construct the result with the elements from this window.

Time complexity: O(size of array + sum of all strings sizes) ~ O(n)

Also add some corner case handling when k > array_size or k <= 0

def max_consec(strarr, k):

    size = len(strarr)

    # corner cases
    if k > size or k <= 0:
        return "None"  # or None

    # store lengths
    lenList = [len(word) for word in strarr]

    print(lenList)

    max_sum = sum(lenList[:k])   # window at index 0
    prev_sum = max_sum
    max_index = 0

    for i in range(1, size - k + 1):
        length = prev_sum - lenList[i-1] + lenList[i + k - 1]  # window sum at i'th index. Subract previous sum and add next sum
        prev_sum = length

        if length > max_sum:
            max_sum = length
            max_index = i

    return "".join(strarr[max_index:max_index+k])  # join strings in the max sum window


word = max_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2)

print(word)

Answer 4

If I understand your question correctly. You have to eliminate duplicate values (in this case with set), sort them by length and concatenate the k longest words.

>>> def max_consec(words, k):
...   words = sorted(set(words), key=len, reverse=True)
...   return ''.join(words[:k])
...
>>> max_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2)
'abigailtheta'

Update: If the k elements should be consecutive. You can create pairs of consecutive words (in this case with zip). And return the longest if they get joined.

>>> def max_consec(words, k):
...     return max((''.join(pair) for pair in zip(*[words[i:] for i in range(k)])), key=len)
...
>>> max_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2)
'abigailtheta'