Sync

Task/Knapsack-problem-0-1/D/knapsack-problem-0-1-1.d

@@ -0,0 +1,45 @@
+import std.stdio, std.algorithm, std.typecons, std.array, std.range;
+
+struct Item { string name; int weight, value; }
+
+Item[] knapsack01DinamicProgramming(in Item[] items, in int limit)
+pure nothrow {
+    auto tab = new int[][](items.length + 1, limit + 1);
+
+    foreach (immutable i, immutable it; items)
+        foreach (immutable w; 1 .. limit + 1)
+            tab[i + 1][w] = (it.weight > w) ? tab[i][w] :
+                max(tab[i][w], tab[i][w - it.weight] + it.value);
+
+    typeof(return) result;
+    int w = limit;
+    foreach_reverse (immutable i, immutable it; items)
+        if (tab[i + 1][w] != tab[i][w]) {
+            w -= it.weight;
+            result ~= it;
+        }
+
+    return result;
+}
+
+void main() {
+    enum int limit = 400;
+    immutable Item[] items = [
+        {"apple",      39,  40}, {"banana",        27,  60},
+        {"beer",       52,  10}, {"book",          30,  10},
+        {"camera",     32,  30}, {"cheese",        23,  30},
+        {"compass",    13,  35}, {"glucose",       15,  60},
+        {"map",         9, 150}, {"note-case",     22,  80},
+        {"sandwich",   50, 160}, {"socks",          4,  50},
+        {"sunglasses",  7,  20}, {"suntan cream",  11,  70},
+        {"t-shirt",    24,  15}, {"tin",           68,  45},
+        {"towel",      18,  12}, {"trousers",      48,  10},
+        {"umbrella",   73,  40}, {"water",        153, 200},
+        {"waterproof overclothes", 43, 75},
+        {"waterproof trousers",    42, 70}];
+
+    immutable bag = knapsack01DinamicProgramming(items, limit);
+    writefln("Items:\n%-(  %s\n%)", bag.map!q{ a.name }.retro);
+    const t = reduce!q{ a[] += [b.weight, b.value] }([0, 0], bag);
+    writeln("\nTotal weight and value: ", t[0] <= limit ? t : [0, 0]);
+}

Task/Knapsack-problem-0-1/D/knapsack-problem-0-1-2.d

@@ -0,0 +1,54 @@
+struct Item { string name; int weight, value; }
+
+immutable Item[] items = [
+    {"apple",      39,  40}, {"banana",        27,  60},
+    {"beer",       52,  10}, {"book",          30,  10},
+    {"camera",     32,  30}, {"cheese",        23,  30},
+    {"compass",    13,  35}, {"glucose",       15,  60},
+    {"map",         9, 150}, {"note-case",     22,  80},
+    {"sandwich",   50, 160}, {"socks",          4,  50},
+    {"sunglasses",  7,  20}, {"suntan cream",  11,  70},
+    {"t-shirt",    24,  15}, {"tin",           68,  45},
+    {"towel",      18,  12}, {"trousers",      48,  10},
+    {"umbrella",   73,  40}, {"water",        153, 200},
+    {"waterproof overclothes", 43, 75},
+    {"waterproof trousers",    42, 70}];
+
+struct Solution { uint bits; int value; }
+static assert(items.length <= Solution.bits.sizeof * 8);
+
+void solve(in int weight, in int idx, ref Solution s) pure nothrow {
+    if (idx < 0) {
+        s.bits = s.value = 0;
+        return;
+    }
+
+    if (weight < items[idx].weight) {
+        solve(weight, idx - 1, s);
+        return;
+     }
+
+    Solution v1, v2;
+    solve(weight, idx - 1, v1);
+    solve(weight - items[idx].weight, idx - 1, v2);
+
+    v2.value += items[idx].value;
+    v2.bits |= (1 << idx);
+
+    s = (v1.value >= v2.value) ? v1 : v2;
+}
+
+void main() {
+    import std.stdio;
+    auto s = Solution(0, 0);
+    solve(400, items.length - 1, s);
+
+    writeln("Items:");
+    int w = 0;
+    foreach (immutable i, immutable it; items)
+        if (s.bits & (1 << i)) {
+            writeln("  ", it.name);
+            w += it.weight;
+        }
+    writeln("\nTotal value: %d; weight: %d", s.value, w);
+}

Task/Knapsack-problem-0-1/D/knapsack-problem-0-1-3.d

@@ -0,0 +1,22 @@
+import std.stdio, std.algorithm, std.typecons, std.array, std.range;
+
+struct Item { string name; int w, v; }
+alias Pair = Tuple!(int,"tot", string[],"names");
+
+immutable Item[] items = [{"apple",39,40}, {"banana", 27, 60},
+    {"beer", 52, 10}, {"book", 30, 10}, {"camera", 32, 30},
+    {"cheese", 23, 30}, {"compass", 13, 35}, {"glucose", 15, 60},
+    {"map", 9, 150}, {"note-case", 22, 80}, {"sandwich", 50, 160},
+    {"socks", 4, 50}, {"sunglasses", 7, 20}, {"suntan cream", 11, 70},
+    {"t-shirt", 24, 15}, {"tin", 68, 45}, {"towel", 18, 12},
+    {"trousers", 48, 10}, {"umbrella", 73, 40}, {"water", 153, 200},
+    {"overclothes", 43, 75}, {"waterproof trousers", 42, 70}];
+
+auto addItem(Pair[] lst, in Item it) pure /*nothrow*/ {
+    auto aux = lst.map!(vn => Pair(vn.tot + it.v, vn.names ~ it.name));
+    return lst[0..it.w] ~ lst[it.w..$].zip(aux).map!q{ a[].max }.array;
+}
+
+void main() {
+    reduce!addItem(Pair().repeat.take(400).array, items).back.writeln;
+}

Task/Knapsack-problem-0-1/Haskell/knapsack-problem-0-1-3.hs

@@ -1,4 +1,10 @@
--- snipped the items list; same as above
+inv = [("map",9,150), ("compass",13,35), ("water",153,200), ("sandwich",50,160),
+       ("glucose",15,60), ("tin",68,45), ("banana",27,60), ("apple",39,40),
+       ("cheese",23,30), ("beer",52,10), ("cream",11,70), ("camera",32,30),
+       ("tshirt",24,15), ("trousers",48,10), ("umbrella",73,40),
+       ("waterproof trousers",42,70), ("overclothes",43,75), ("notecase",22,80),
+       ("sunglasses",7,20), ("towel",18,12), ("socks",4,50), ("book",30,10)]
+
 knapsack = foldr addItem (repeat (0,[])) where
 	addItem (name,w,v) list = left ++ zipWith max right newlist where
 		newlist = map (\(val, names)->(val + v, name:names)) list

Task/Knapsack-problem-0-1/R/knapsack-problem-0-1-1.r

@@ -0,0 +1,78 @@
+Full_Data<-structure(list(item = c("map", "compass", "water", "sandwich",
+"glucose", "tin", "banana", "apple", "cheese", "beer", "suntan_cream",
+"camera", "T-shirt", "trousers", "umbrella", "waterproof_trousers",
+"waterproof_overclothes", "note-case", "sunglasses", "towel",
+"socks", "book"), weigth = c(9, 13, 153, 50, 15, 68, 27, 39,
+23, 52, 11, 32, 24, 48, 73, 42, 43, 22, 7, 18, 4, 30), value = c(150,
+35, 200, 160, 60, 45, 60, 40, 30, 10, 70, 30, 15, 10, 40, 70,
+75, 80, 20, 12, 50, 10)), .Names = c("item", "weigth", "value"
+), row.names = c(NA, 22L), class = "data.frame")
+
+
+Bounded_knapsack<-function(Data,W)
+{
+	K<-matrix(NA,nrow=W+1,ncol=dim(Data)[1]+1)
+	0->K[1,]->K[,1]
+	matrix_item<-matrix('',nrow=W+1,ncol=dim(Data)[1]+1)
+	for(j in 1:dim(Data)[1])
+	{
+		for(w in 1:W)
+		{
+			wj<-Data$weigth[j]
+			item<-Data$item[j]
+			value<-Data$value[j]
+			if( wj > w )
+			{
+				K[w+1,j+1]<-K[w+1,j]
+				matrix_item[w+1,j+1]<-matrix_item[w+1,j]
+			}
+			else
+			{
+				if( K[w+1,j] >= K[w+1-wj,j]+value )
+				{
+					K[w+1,j+1]<-K[w+1,j]
+					matrix_item[w+1,j+1]<-matrix_item[w+1,j]					
+				}
+				else
+				{
+					K[w+1,j+1]<-K[w+1-wj,j]+value
+					matrix_item[w+1,j+1]<-item
+				}
+			}
+		}
+	}
+return(list(K=K,Item=matrix_item))
+}
+
+backtracking<-function(knapsack, Data)
+{
+	W<-dim(knapsack$K)[1]
+	itens<-c()
+	col<-dim(knapsack$K)[2]
+	selected_item<-knapsack$Item[W,col]
+	while(selected_item!='')
+	{
+		selected_item<-knapsack$Item[W,col]
+		if(selected_item!='')
+		{
+			selected_item_value<-Data[Data$item == selected_item,]
+			if(-knapsack$K[W - selected_item_value$weigth,col-1]+knapsack$K[W,col]==selected_item_value$value)
+			{
+				W <- W - selected_item_value$weigth
+				itens<-c(itens,selected_item)
+			}
+			col <- col - 1
+		}
+	}
+return(itens)
+}
+
+print_output<-function(Data,W)
+{
+	Bounded_knapsack(Data,W)->Knap
+	backtracking(Knap, Data)->Items
+	output<-paste('You must carry:', paste(Items, sep = ', '), sep=' ' )
+	return(output)
+}
+
+print_output(Full_Data, 400)

Task/Knapsack-problem-0-1/R/knapsack-problem-0-1-2.r

@@ -0,0 +1,12 @@
+ [1] "You must carry: socks"
+ [2] "You must carry: sunglasses"
+ [3] "You must carry: note-case"
+ [4] "You must carry: waterproof_overclothes"
+ [5] "You must carry: waterproof_trousers"
+ [6] "You must carry: suntan_cream"
+ [7] "You must carry: banana"
+ [8] "You must carry: glucose"
+ [9] "You must carry: sandwich"
+[10] "You must carry: water"
+[11] "You must carry: compass"
+[12] "You must carry: map"