Software Engineering

# Consecutive strings in Java

## The challenge#

You are given an array(list) `strarr` of strings and an integer `k`. Your task is to return the first longest string consisting of k consecutive strings taken in the array.

#### Examples#

``````strarr = ["tree", "foling", "trashy", "blue", "abcdef", "uvwxyz"], k = 2

Concatenate the consecutive strings of strarr by 2, we get:

treefoling   (length 10)  concatenation of strarr[0] and strarr[1]
folingtrashy ("      12)  concatenation of strarr[1] and strarr[2]
trashyblue   ("      10)  concatenation of strarr[2] and strarr[3]
blueabcdef   ("      10)  concatenation of strarr[3] and strarr[4]
abcdefuvwxyz ("      12)  concatenation of strarr[4] and strarr[5]

Two strings are the longest: "folingtrashy" and "abcdefuvwxyz".
The first that came is "folingtrashy" so
longest_consec(strarr, 2) should return "folingtrashy".

In the same way:
longest_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2) --> "abigailtheta"
``````

n being the length of the string array, if `n = 0` or `k > n` or `k <= 0` return “”.

#### Note#

consecutive strings : follow one after another without an interruption

## The solution in Java code#

Option 1:

``````class LongestConsec {
public static String longestConsec(String[] strarr, int k) {
if (strarr.length == 0 || k > strarr.length || k <= 0)
return "";

String longestStr = "";
for (int index = 0; index < strarr.length - k + 1; index++) {
StringBuilder sb = new StringBuilder();
for (int i = index; i < index + k; i++) {
sb.append(strarr[i]);
}
if (sb.toString().length() > longestStr.length()) {
longestStr = sb.toString();
}
}
return longestStr;
}
}
``````

Option 2:

``````import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

class LongestConsec {
public static String longestConsec(String[] strarr, int k) {
if (k <= 0) {
return "";
}

return IntStream.rangeClosed(0, strarr.length - k)
.mapToObj(i -> Arrays.stream(strarr, i, i + k).collect(Collectors.joining()))
.max(Comparator.comparingInt(String::length))
.orElse("");
}
}
``````

Option 3:

``````class LongestConsec {

public static String longestConsec(String[] strarr, int k) {

if(k < 1 || strarr.length < k || strarr.length == 0){
return "";
}

int startIndex = 0;
int max = strarr[0].length();
int sum = 0;

for(int i = 0; i < strarr.length; i++){
sum += strarr[i].length();

if(i > k - 1){
sum -= strarr[i - k].length();
}

if(sum > max){
max = sum;
startIndex = i - k + 1;
}
}

String result = "";
for (int i = startIndex; i < startIndex + k; i++){
result += strarr[i];
}
return result;
}
}
``````

## Test cases to validate our solution#

``````import static org.junit.Assert.*;
import org.junit.Test;

public class LongestConsecTest {

private static void testing(String actual, String expected) {
assertEquals(expected, actual);
}
@Test
public void test() {
System.out.println("longestConsec Fixed Tests");
testing(LongestConsec.longestConsec(new String[] {"zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"}, 2), "abigailtheta");
testing(LongestConsec.longestConsec(new String[] {"ejjjjmmtthh", "zxxuueeg", "aanlljrrrxx", "dqqqaaabbb", "oocccffuucccjjjkkkjyyyeehh"}, 1), "oocccffuucccjjjkkkjyyyeehh");
testing(LongestConsec.longestConsec(new String[] {}, 3), "");
testing(LongestConsec.longestConsec(new String[] {"itvayloxrp","wkppqsztdkmvcuwvereiupccauycnjutlv","vweqilsfytihvrzlaodfixoyxvyuyvgpck"}, 2), "wkppqsztdkmvcuwvereiupccauycnjutlvvweqilsfytihvrzlaodfixoyxvyuyvgpck");
testing(LongestConsec.longestConsec(new String[] {"wlwsasphmxx","owiaxujylentrklctozmymu","wpgozvxxiu"}, 2), "wlwsasphmxxowiaxujylentrklctozmymu");
testing(LongestConsec.longestConsec(new String[] {"zone", "abigail", "theta", "form", "libe", "zas"}, -2), "");
testing(LongestConsec.longestConsec(new String[] {"it","wkppv","ixoyx", "3452", "zzzzzzzzzzzz"}, 3), "ixoyx3452zzzzzzzzzzzz");
testing(LongestConsec.longestConsec(new String[] {"it","wkppv","ixoyx", "3452", "zzzzzzzzzzzz"}, 15), "");
testing(LongestConsec.longestConsec(new String[] {"it","wkppv","ixoyx", "3452", "zzzzzzzzzzzz"}, 0), "");
}
}
``````