Odnajdywaniie najdłuższych stringów z strumienia Stringów

   Map<Integer, Set<String>> lengthStringsMap = strings.collect(groupingBy(String::length, mapping(Function.identity(), toSet())));
    return lengthStringsMap.entrySet().stream().
        max(Comparator.comparingInt(Map.Entry::getKey)).
        orElseGet(() -> new SimpleEntry<>(0,Collections.singleton(""))).
        getValue();
  }

public class LongestStrings {

	public static void main(String[] args) {
		Set<String> strings = Arrays.stream("Ala ma kota a kot ma hive".split(" "))
				.collect(Collectors.groupingBy(
						String::length, HashMap::new, toSet()
				)).entrySet().stream().max(Comparator.comparingInt(Map.Entry::getKey))
				.map(Map.Entry::getValue)
				.orElse(Collections.singleton(""));
		System.out.println(strings);

	}
}

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Stream;

class StoreOnlyLongestStringList {
    private final List<String> longestStrings = new ArrayList<>();
    private int currentLen = 0;

    public void addNewEntry(String newEntry) {
        int len = newEntry.length();
        if (len == currentLen) {
            longestStrings.add(newEntry);
        } else if (len > currentLen) {
            currentLen = len;
            longestStrings.clear();
            longestStrings.add(newEntry);
        }
    }

    public StoreOnlyLongestStringList combine(StoreOnlyLongestStringList otherList) {
        otherList.retrieveResult().forEach(this::addNewEntry);
        return this;
    }

    public List<String> retrieveResult() {
        return longestStrings;
    }
}

class RetainLongestStringListCollector implements Collector<String, StoreOnlyLongestStringList, List<String>> {

    @Override
    public Supplier<StoreOnlyLongestStringList> supplier() {
        return StoreOnlyLongestStringList::new;
    }

    @Override
    public BiConsumer<StoreOnlyLongestStringList, String> accumulator() {
        return StoreOnlyLongestStringList::addNewEntry;
    }

    @Override
    public BinaryOperator<StoreOnlyLongestStringList> combiner() {
        return StoreOnlyLongestStringList::combine;
    }

    @Override
    public Function<StoreOnlyLongestStringList, List<String>> finisher() {
        return StoreOnlyLongestStringList::retrieveResult;
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.emptySet();
    }
}

public class LongestStringsFinder {

    private List<String> findLongest(Stream<String> input) {
        return input.collect(new RetainLongestStringListCollector());
    }

    public static void main(String[] args) {
        LongestStringsFinder longestStringsFinder = new LongestStringsFinder();
        List<String> input = Arrays.asList("ala", "ma", "kot", "ala");
        System.out.println(longestStringsFinder.findLongest(input.stream()));
    }
}

public class LongestStringFinder {

    private List<String> findLongest(Stream<String> input) {
        return input.reduce(Longest.empty(), Longest::bigger, Longest::bigger).strings;
    }

    public static void main(String[] args) {
        LongestStringFinder longestStringsFinder = new LongestStringFinder();
        List<String> input = Arrays.asList("ala", "ma", "kot", "ala");
           System.out.println(longestStringsFinder.findLongest(input.stream()));
    }

    static class Longest {
        public final List<String> strings;
        public final int length;

        static Longest empty() {
            return new Longest(Collections.emptyList(), 0);
        }

        public Longest bigger(final String otherString) {
            if ( length < otherString.length()) {
                return new Longest(Arrays.asList(otherString), otherString.length());
            } else if ( length == otherString.length()) {
                final List<String> newList = new ArrayList<>(this.strings);
                newList.add(otherString);
                return new Longest(newList, this.length);
            } else {
                return this;
            }
        }

        public Longest bigger(final Longest other) {
            if ( length< other.length) {
                return other;
            }  else  if ( length > other.length) {
                return this;
            } else {
                final List<String> newList = new ArrayList<>(this.strings);
                newList.addAll(other.strings);
                return new Longest(newList, this.length);
            }
        }

        private Longest(List<String> strings, int length) {
            this.strings = strings;
            this.length = length;
        }
    }
}

public class Main {

	public static void main(String[] args) {
		List<String> result = new ArrayList<String>();
		int max = 0;
		String[] split = "Ala ma kota a kot ma hive".split(" ");
		for (String string : split) {
			int length = string.length();
			if(length>max) {
				result = new ArrayList<String>();
				result.add(string);
				max = length;
			}else if(length == max) {
				result.add(string);
			}
		}
        System.out.println(result);
	}

}

import javaslang.collection.List;

import java.util.Arrays;

public class LongestStringFinderVavr {

    private List<String> findLongest(java.util.stream.Stream<String> input) {
        return javaslang.collection.Stream.ofAll(input)
                .foldLeft(Longest.empty(), Longest::bigger).strings;
    }

    public static void main(String[] args) {
        LongestStringFinderVavr longestStringsFinder = new LongestStringFinderVavr();
        java.util.stream.Stream<String> input = Arrays.asList("ala", "ma", "kot", "ali", "ma").stream();
        System.out.println(longestStringsFinder.findLongest(input));
    }

    static class Longest {
        public final List<String> strings;
        public final int length;

        static Longest empty() {
            return new Longest(List.empty(), 0);
        }

        Longest bigger(final String otherString) {
            if (length < otherString.length()) {
                return new Longest(List.of(otherString), otherString.length());
            } else if (length == otherString.length()) {
                return new Longest(strings.prepend(otherString), this.length);
            } else {
                return this;
            }
        }

        private Longest(List<String> strings, int length) {
            this.strings = strings;
            this.length = length;
        }
    }
}

val list = List("ala", "ma", "kot", "ala")
val max = list.map(_.length).max
list.filter(_.length == max)

char kraj[20];

cin >> kraj;

for (i=0;i<20;i++) 
{
if (kraj[i]=='a') licz++
}

import java.util.*;
import java.lang.*;
import java.io.*;

/* Find longest word in string */
class Ideone {

	private static List<String> findLongestWords(String txt) {
		int idx = 0;
		List<String> words = new ArrayList<>();
		int longest = 0;

		while (idx < txt.length()) {
			int start = idx;
			while (start < txt.length() && txt.charAt(start) == ' ') {
				start++;
			}
			
			idx = start;
			while (idx < txt.length() && txt.charAt(idx) != ' ') {
				idx++;
			}
			
			int len = idx - start;
			String word = txt.substring(start, idx);
			
			if (len > longest) {
				longest = len;
				words = new ArrayList<>();
				words.add(word);
			} else if ((len == longest) && (len > 0)) {
				words.add(word);
			}
		}
		return words;
	}

	public static void main(String[] args) throws java.lang.Exception {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNextLine()) {
			String line = sc.nextLine();
			List<String> words = findLongestWords(line);
			System.out.printf("Longest: /%s/%n", words);
		}
	}
}

public class Main {
    public static void main(String[] args) {
        RCaller caller=new RCaller();
        try{
        	x <- c("Trololo", "JuliaOK", "Rnajlepszy")

        	findLongestString <- function(x){
        	    counted <- sapply(x, nchar)
                x[counted == max(counted)]
        	}

        	findLongestString(x)
        }
    }
}