Data Update

Task/Amb/C++/amb-2.cpp

@@ -0,0 +1,57 @@
+#include <functional>
+#include <iostream>
+#include <numeric>
+#include <string>
+#include <vector>
+
+std::string join(const std::string& delimiter, const std::vector<std::string>& list) {
+	return list.empty() ? "" : std::accumulate(++list.begin(), list.end(), list[0],
+											   [delimiter](auto& a, auto& b) { return a + delimiter + b; });
+}
+
+std::vector<std::string> amb(std::function<bool(std::string&, std::string&)> func,
+		                     std::vector<std::vector<std::string>> options, std::string previous) {
+
+	if ( options.empty() ) {
+		return std::vector<std::string>();
+	}
+
+	for ( std::string& option : options.front() ) {
+		if ( ! previous.empty() && ! func(previous, option) ) {
+			continue;
+		}
+
+		if ( options.size() == 1 ) {
+			return std::vector<std::string>(1, option);
+		}
+
+		std::vector<std::vector<std::string>> next_options(options.begin() + 1, options.end());
+		std::vector<std::string> result = amb(func, next_options, option);
+
+		if ( ! result.empty() ) {
+			result.emplace(result.begin(), option);
+			return result;
+		}
+	}
+
+	return std::vector<std::string>();
+
+}
+
+std::string Amb(std::vector<std::vector<std::string>> options) {
+	std::function<bool(std::string, std::string)> continues =
+		[](std::string before, std::string after) { return before.back() == after.front(); };
+
+	std::vector<std::string> amb_result = amb(continues, options, "");
+
+	return ( amb_result.empty() ) ? "No match found" : join(" ", amb_result);
+}
+
+int main() {
+	 std::vector<std::vector<std::string>> words = { { "the", "that", "a" },
+			 	 	 	 	 	 	 	             { "frog", "elephant", "thing" },
+										             { "walked", "treaded", "grows" },
+										             { "slowly", "quickly" } };
+
+	std::cout << Amb(words) << std::endl;
+}

Task/Amb/Java/amb.java

@@ -0,0 +1,52 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public final class AmbTask {
+
+	public static void main(String[] aArgs) {
+		List<List<String>> words = List.of(
+			List.of( "the", "that", "a" ),
+		    List.of( "frog", "elephant", "thing" ),
+		    List.of( "walked", "treaded", "grows" ),
+		    List.of( "slowly", "quickly" ) );		
+
+		System.out.println(Amb(words));		
+	}
+	
+	private static String Amb(List<List<String>> aOptions) {
+		BiFunction<String, String, Boolean> continues = (before, after) -> before.endsWith(after.substring(0, 1));		
+		List<String> ambResult = amb(continues, aOptions, "");
+		return ( ambResult.isEmpty() ) ? "No match found" : String.join(" ", ambResult);		
+	}
+	
+	private static List<String> amb(
+			BiFunction<String, String, Boolean> aBiFunction, List<List<String>> aOptions, String aPrevious) {
+		
+		if ( aOptions.isEmpty() ) {
+			return new ArrayList<String>();
+		}
+
+		for ( String option : aOptions.get(0) ) {
+		    if ( ! aPrevious.isEmpty() && ! aBiFunction.apply(aPrevious, option) ) {
+		    	continue;
+			}
+	
+		    if ( aOptions.size() == 1 ) {
+		    	return Stream.of(option).collect(Collectors.toList());
+		    }
+	
+		    List<String> result = (ArrayList<String>) amb(aBiFunction, aOptions.subList(1, aOptions.size()), option);
+	
+		    if ( ! result.isEmpty() ) {
+				result.add(0, option);
+				return result;
+			}	
+		}
+		
+		return new ArrayList<String>();
+	}
+	
+}