Open In App

# Python – Length Conditional Concatenation

Given a list of strings, perform concatenation of Strings whose length is greater than K.

Input : test_list = [“Gfg”, ‘is’, “Best”, ‘for’, ‘CS’, ‘Everything’], K = 3
Output : BestEverything
Explanation : All elements with Length > 3 are concatenated.

Input : test_list = [“Gfg”, ‘is’, “Best”, ‘for’, ‘CS’, ‘Everything’], K = 1
Output : GfgisBestforCSEverything
Explanation : All elements with Length > 1 are concatenated.

Method #1: Using loop + len():
This offers a brute way to solve this problem. In this, we iterate for each string and perform concatenation if the string length is greater than K using len().

## Python3

 `# Python3 code to demonstrate working of``# Length Conditional Concatenation``# Using loop + len()` `# initializing lists``test_list ``=` `[``"Gfg"``, ``'is'``, ``"Best"``, ``'for'``, ``'CS'``, ``'Everything'``]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# initializing K``K ``=` `2` `# loop to run through all the elements``res ``=` `''``for` `ele ``in` `test_list:``    ` `    ``# using len() to check for length``    ``if` `len``(ele) > ``2``:``        ``res ``+``=` `ele` `# printing result``print``(``"String after Concatenation : "` `+` `str``(res))`

Output

```The original list : ['Gfg', 'is', 'Best', 'for', 'CS', 'Everything']
String after Concatenation : GfgBestforEverything```

Time Complexity: O(n)

Auxiliary Space: O(n)

Method #2 : Using join() + filter() + lambda + len():
The combination of above functions can be used to solve this problem. In this, we perform concatenation using join(), filter and lambda are used for conditional check using len().

## Python3

 `# Python3 code to demonstrate working of``# Length Conditional Concatenation``# Using join() + filter() + lambda + len()` `# initializing lists``test_list ``=` `[``"Gfg"``, ``'is'``, ``"Best"``, ``'for'``, ``'CS'``, ``'Everything'``]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# initializing K``K ``=` `2` `# join() performing Concatenation of required strings``res ``=` `''.join(``filter``(``lambda` `ele: ``len``(ele) > K, test_list))` `# printing result``print``(``"String after Concatenation : "` `+` `str``(res))`

Output

```The original list : ['Gfg', 'is', 'Best', 'for', 'CS', 'Everything']
String after Concatenation : GfgBestforEverything```

Time Complexity: O(n)

Auxiliary Space: O(n)

Method#3: Using list comprehension + join():
This method lists strings whose length is greater than the defined number. With the help of join method, we can join the list in string.

## Python3

 `# Python3 code to demonstrate working of``# Length Conditional Concatenation``# Using list comprehension + join` `# Initializing lists``test_list ``=` `[``"Gfg"``, ``'is'``, ``"Best"``, ``'for'``, ``'CS'``, ``'Everything'``]` `# Printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Initializing K``K ``=` `3` `# list comprehension make list of string with greater length``# join() performing Concatenation of required strings``temp ``=` `[x ``for` `x ``in` `test_list ``if` `len``(x) > K]``res ``=` `"".join(temp)` `# Printing result``print``(``"String after Concatenation : "` `+` `str``(res))`

Output

```The original list : ['Gfg', 'is', 'Best', 'for', 'CS', 'Everything']
String after Concatenation : BestEverything```

The Time and Space Complexity for all the methods are the same:

Time Complexity: O(n)

Space Complexity: O(n)

#### Approach#4: Using reduce

This approach defines a function concat_strings that takes a list test_list and an integer K as input. It uses the filter function with a lambda function to filter the elements of test_list with length greater than K. It then uses the reduce function with a lambda function to concatenate the filtered elements. Finally, it returns the concatenated string.

#### Algorithm

1. Use reduce function to concatenate the elements of the input list with length greater than K.
2. Return the concatenated string.

## Python3

 `from` `functools ``import` `reduce` `def` `concat_strings(test_list, K):``    ``filtered_list ``=` `filter``(``lambda` `string: ``len``(string) > K, test_list)``    ``concatenated_string ``=` `reduce``(``lambda` `x, y: x ``+` `y, filtered_list, '')``    ``return` `concatenated_string``test_list ``=` `[``"Gfg"``, ``'is'``, ``"Best"``, ``'for'``, ``'CS'``, ``'Everything'``]``K``=``3``print``(concat_strings(test_list, K))`

Output

`BestEverything`

Time Complexity: O(n), where n is the length of the input list.
Auxiliary Space: O(n), where n is the length of the input list (due to the creation of a new iterator).