Data commit

Task/Power-set/D/power-set-1.d

@@ -0,0 +1,27 @@
+import std.algorithm;
+import std.range;
+
+auto powerSet(R)(R r)
+{
+	return
+		(1L<<r.length)
+		.iota
+		.map!(i =>
+			r.enumerate
+			.filter!(t => (1<<t[0]) & i)
+			.map!(t => t[1])
+		);
+}
+
+unittest
+{
+	int[] emptyArr;
+	assert(emptyArr.powerSet.equal!equal([emptyArr]));
+	assert(emptyArr.powerSet.powerSet.equal!(equal!equal)([[], [emptyArr]]));
+}
+
+void main(string[] args)
+{
+	import std.stdio;
+	args[1..$].powerSet.each!writeln;
+}

Task/Power-set/D/power-set-2.d

@@ -0,0 +1,42 @@
+import std.range;
+
+struct PowerSet(R)
+	if (isRandomAccessRange!R)
+{
+	R r;
+	size_t position;
+
+	struct PowerSetItem
+	{
+		R r;
+		size_t position;
+
+		private void advance()
+		{
+			while (!(position & 1))
+			{
+				r.popFront();
+				position >>= 1;
+			}
+		}
+
+		@property bool empty() { return position == 0; }
+		@property auto front()
+		{
+			advance();
+			return r.front;
+		}
+		void popFront()
+		{
+			advance();
+			r.popFront();
+			position >>= 1;
+		}
+	}
+
+	@property bool empty() { return position == (1 << r.length); }
+	@property PowerSetItem front() { return PowerSetItem(r.save, position); }
+	void popFront() { position++; }
+}
+
+auto powerSet(R)(R r) { return PowerSet!R(r); }

Task/Power-set/D/power-set-3.d

@@ -0,0 +1,16 @@
+// Haskell definition:
+// foldr f z []     = z
+// foldr f z (x:xs) = x `f` foldr f z xs
+S foldr(T, S)(S function(T, S) f, S z, T[] rest) {
+    return (rest.length == 0) ? z : f(rest[0], foldr(f, z, rest[1..$]));
+}
+
+// Haskell definition:
+//powerSet = foldr (\x acc -> acc ++ map (x:) acc) [[]]
+T[][] powerset(T)(T[] set) {
+    import std.algorithm;
+    import std.array;
+    // Note: The types before x and acc aren't needed, so this could be made even more concise, but I think it helps
+    // to make the algorithm slightly clearer.
+    return foldr( (T x, T[][] acc) => acc ~ acc.map!(accx => x ~ accx).array , [[]], set );
+}