diff --git a/01_introduction_to_algorithms/d/01_binary_search.d b/01_introduction_to_algorithms/d/01_binary_search.d
new file mode 100644
index 0000000..7d9e137
--- /dev/null
+++ b/01_introduction_to_algorithms/d/01_binary_search.d
@@ -0,0 +1,27 @@
+module app;
+
+import std.stdio: writeln;
+import std.range: assumeSorted, SortedRange;
+
+long binary_search(T)(SortedRange!(T[]) list, T item) {
+    long low = 0;
+    long high = list.length - 1;
+
+    while (low <= high) {
+        auto mid = (low + high) / 2;
+        T guess = list[mid];
+        if (guess == item)
+            return mid;
+        else if (guess > item)
+            high = mid - 1;
+        else
+            low = mid + 1;
+    }
+    return -1;
+}
+
+void main() {
+    auto my_list = [1, 3, 5, 7, 9];
+    writeln(binary_search(assumeSorted(my_list), 3));
+    writeln(binary_search(assumeSorted(my_list), -1));
+}
diff --git a/02_selection_sort/d/01_selection_sort.d b/02_selection_sort/d/01_selection_sort.d
new file mode 100644
index 0000000..53d81bb
--- /dev/null
+++ b/02_selection_sort/d/01_selection_sort.d
@@ -0,0 +1,32 @@
+module app;
+
+import std.stdio: writeln;
+import std.algorithm: minIndex, remove;
+
+
+// or it is possible to use minIndex
+T findSmallest(T)(T[] arr) {
+    auto smallest = arr[0];
+    auto smallest_index = 0;
+    foreach(i; 0 .. cast(int)arr.length) {
+        if (arr[i] < smallest) {
+            smallest = arr[i];
+            smallest_index = i;
+        }
+    }
+    return smallest_index;
+}
+
+T[] selectionSort(T)(T[] arr) {
+    T[] newArr = [];
+    foreach(i; 0 .. cast(int)arr.length) {
+        auto smallest = findSmallest(arr); // or use minIndex(arr);
+        newArr ~= arr[smallest];
+        arr = arr.remove(smallest);
+    }
+    return newArr;
+}
+
+void main() {
+    writeln(selectionSort([5, 3, 6, 2, 10]));
+}
diff --git a/03_recursion/d/01_countdown.d b/03_recursion/d/01_countdown.d
new file mode 100644
index 0000000..6662a76
--- /dev/null
+++ b/03_recursion/d/01_countdown.d
@@ -0,0 +1,18 @@
+module app;
+
+import std;
+
+void countdown(int i) {
+    // base case
+    if (i <= 0)
+        return 0;
+    // recursive case
+    else {
+        writeln(i);
+        return countdown(i-1);
+    }
+}
+
+void main() {
+    countdown(5);
+}
diff --git a/03_recursion/d/02_greet.d b/03_recursion/d/02_greet.d
new file mode 100644
index 0000000..e1d5865
--- /dev/null
+++ b/03_recursion/d/02_greet.d
@@ -0,0 +1,22 @@
+module app;
+
+import std;
+
+void greet2(string name) {
+    writeln(i"how are you $(name)?");
+}
+
+void bye() {
+    writeln("ok bye!");
+}
+
+void greet(string name) {
+    writeln(i"hello, #(name)!");
+    greet2(name);
+    writeln("gettin ready to say bye...");
+    bye();
+}
+
+void main() {
+    greet("adit");
+}
diff --git a/03_recursion/d/03_factorial.d b/03_recursion/d/03_factorial.d
new file mode 100644
index 0000000..aa360c5
--- /dev/null
+++ b/03_recursion/d/03_factorial.d
@@ -0,0 +1,14 @@
+module app;
+
+import std;
+
+T fact(T x) {
+    if (x == 1)
+        return 1;
+    else
+        return x * fact(x-1);
+}
+
+void main() {
+    writeln(fact(5));
+}
diff --git a/03_recursion/d/04_count.d b/03_recursion/d/04_count.d
new file mode 100644
index 0000000..65ce37f
--- /dev/null
+++ b/03_recursion/d/04_count.d
@@ -0,0 +1,9 @@
+module app;
+
+import std;
+
+int count(T[] arr) {
+    if (arr.empty)
+        return 0;
+    return 1 + count(arr[1..$]);
+}
diff --git a/03_recursion/d/05_binary_search_recursive.d b/03_recursion/d/05_binary_search_recursive.d
new file mode 100644
index 0000000..261b2e6
--- /dev/null
+++ b/03_recursion/d/05_binary_search_recursive.d
@@ -0,0 +1,23 @@
+module app;
+
+import std;
+
+int binary_search(T)(T[] arr, T target) {
+    if (arr.length == 0)
+        return -1;
+
+    int mid = cast(int)arr.length / 2;
+    if (arr[mid] == target)
+        return mid;
+    else if (arr[mid] > target)
+        return binary_search(arr[0..mid], target);
+    else {
+        int recursive_response = binary_search(arr[mid + 1 .. $], target);
+        return recursive_response == -1 ? recursive_response : (mid + 1) + recursive_response;
+    }
+}
+
+void main() {
+    writeln(binary_search([6, 7, 8, 9, 10], 8));
+    writeln(binary_search([6, 7, 8, 9, 10], 6));
+}
diff --git a/03_recursion/d/06_find_max.d b/03_recursion/d/06_find_max.d
new file mode 100644
index 0000000..d09a145
--- /dev/null
+++ b/03_recursion/d/06_find_max.d
@@ -0,0 +1,10 @@
+T find_max(T)(T[] arr) {
+    if (arr.length == 0)
+        return 0;
+    else if (arr.length == 1)
+        return arr[0];
+    else if (arr.length == 2)
+        return arr[0] > arr[1] ? arr[0] : arr[1];
+    auto sub_max = find_max(arr[1..$]);
+    return arr[0] > sub_max ? arr[0] : sub_max;
+}
diff --git a/03_recursion/d/07_sum_array.d b/03_recursion/d/07_sum_array.d
new file mode 100644
index 0000000..22e5e34
--- /dev/null
+++ b/03_recursion/d/07_sum_array.d
@@ -0,0 +1,5 @@
+T sum_array(T)(T[] arr) {
+    if (arr.empty)
+        return 0;
+    return arr[0] + sum_array(arr[1..$]);
+}
diff --git a/03_recursion/d/08_look_for_key.d b/03_recursion/d/08_look_for_key.d
new file mode 100644
index 0000000..68c7ecb
--- /dev/null
+++ b/03_recursion/d/08_look_for_key.d
@@ -0,0 +1,61 @@
+modeul app;
+
+import std;
+
+class Item {
+    bool is_key = false;
+    Item[] items_in_box;
+
+    this() {
+        this.is_key = false;
+    }
+
+    this(bool key) {
+        this.is_key = key;
+    }
+
+    bool is_a_box() {
+        return !this.is_key;
+    }
+
+    bool is_a_key() {
+        return this.is_key;
+    }
+}
+
+void look_for_key(Item box) {
+    foreach(item; box.items_in_box)
+        if (item.is_a_box())
+            // recursive case
+            look_for_key(item);
+        else if (item.is_a_key())
+            // base case
+            writeln("found the key!");
+}
+
+/*
+main_box
+├── box_A
+│   ├── box_B
+│   └── box_C
+└── box_D
+    └── box_E
+        └── key
+*/
+void main() {
+    auto main_box = new Item();
+    auto box_A = new Item();
+    auto box_B = new Item();
+    auto box_C = new Item();
+    box_A.items_in_box = [box_B, box_C];
+
+    auto box_D = new Item();
+    auto box_E = new Item();
+    auto key = new Item(true);
+    box_E.items_in_box = [key];
+    box_D.items_in_box = [box_E];
+
+    main_box.items_in_box = [box_A, box_D];
+
+    look_for_key(main_box);
+}
diff --git a/04_quicksort/d/01_loop_sum.d b/04_quicksort/d/01_loop_sum.d
new file mode 100644
index 0000000..df5bc29
--- /dev/null
+++ b/04_quicksort/d/01_loop_sum.d
@@ -0,0 +1,14 @@
+module app;
+
+import std;
+
+T loop_sum(T[] arr) {
+    T total;
+    foreach(x; arr)
+        total += x;
+    return total;
+}
+
+void main() {
+    writeln(loop_sum([1,2,3,4]));
+}
diff --git a/04_quicksort/d/02_recursive_sum.d b/04_quicksort/d/02_recursive_sum.d
new file mode 100644
index 0000000..891b686
--- /dev/null
+++ b/04_quicksort/d/02_recursive_sum.d
@@ -0,0 +1,13 @@
+module app;
+
+import std;
+
+T rec_sum(T[] list) {
+    if (list.empty)
+        return 0;
+    return list[0] + sum(list[1..$]);
+}
+
+void main() {
+    writeln(rec_sum([1,2,3,4]));
+}
diff --git a/04_quicksort/d/03_recursive_count.d b/04_quicksort/d/03_recursive_count.d
new file mode 100644
index 0000000..b197479
--- /dev/null
+++ b/04_quicksort/d/03_recursive_count.d
@@ -0,0 +1,13 @@
+module app;
+
+import std;
+
+T rec_count(T[] list) {
+    if (list.empty)
+        return 0;
+    return 1 + rec_count(list[1..$]);
+}
+
+void main() {
+    writeln(rec_count([1,2,3,4]));
+}
diff --git a/04_quicksort/d/04_recursive_max.d b/04_quicksort/d/04_recursive_max.d
new file mode 100644
index 0000000..2f176d1
--- /dev/null
+++ b/04_quicksort/d/04_recursive_max.d
@@ -0,0 +1,19 @@
+module app;
+
+import std;
+
+T rec_max(T)(T[] list) {
+    if (list.empty)
+        return T.init;
+    if (list.length == 1)
+        return list[0];
+    else {
+        auto max_num = rec_max(list[1..$]);
+        return list[0] > max_num ? list[0] : max_num;
+    }
+}
+
+void main() {
+    writeln(rec_max([1,2,3]));
+}
+
diff --git a/04_quicksort/d/05_quicksort.d b/04_quicksort/d/05_quicksort.d
new file mode 100644
index 0000000..7b943a7
--- /dev/null
+++ b/04_quicksort/d/05_quicksort.d
@@ -0,0 +1,18 @@
+module app;
+
+import std;
+
+T[] quicksort(T[] arr) {
+    if (arr.length < 2)
+        return arr;
+    else {
+        auto pivot = arr[0];
+        auto less = arr.filter!(el => el < pivot).array;
+        auto greater = arr.filter!(el => el > pivot).array;
+        return quicksort(less) ~ arr.filter!(el => el == pivot).array ~ quicksort(greater);
+    }
+}
+
+void main() {
+    writeln(quicksort([10, 5, 2, 3]));
+}
diff --git a/05_hash_tables/d/01_price_of_groceries.d b/05_hash_tables/d/01_price_of_groceries.d
new file mode 100644
index 0000000..04f0b6b
--- /dev/null
+++ b/05_hash_tables/d/01_price_of_groceries.d
@@ -0,0 +1,8 @@
+module app;
+
+import std;
+
+void main() {
+    float[string] book = ["apple": 0.67, "milk": 1.49, "avocado": 1.49];
+    writeln(book);
+}
diff --git a/05_hash_tables/d/02_check_voter.d b/05_hash_tables/d/02_check_voter.d
new file mode 100644
index 0000000..e723227
--- /dev/null
+++ b/05_hash_tables/d/02_check_voter.d
@@ -0,0 +1,21 @@
+module app;
+
+import std;
+
+bool[string] voted;
+
+void check_voter(string name) {
+    auto p = name in voted;
+    if (p !is null)
+        writeln("Kick them out!");
+    else {
+        voted[name] = true;
+        writeln("Let them vote!");
+    }
+}
+
+void main() {
+    check_voter("tom");
+    check_voter("mike");
+    check_voter("mike");
+}    
diff --git a/06_breadth-first_search/d/01_breadth_first_search.d b/06_breadth-first_search/d/01_breadth_first_search.d
new file mode 100644
index 0000000..6fdae87
--- /dev/null
+++ b/06_breadth-first_search/d/01_breadth_first_search.d
@@ -0,0 +1,42 @@
+module app;
+
+import std;
+
+bool personIsSeller(string name) {
+    return name[name.length - 1] == 'm';
+}
+
+bool search(string name) {
+    auto search_queue = DList!string();
+    search_queue.insertBack(name);
+    bool[string] searched;
+    while (!search_queue.empty) {
+        auto person = search_queue.front();
+        search_queue.removeFront();
+        auto found = person in searched;
+        if (found !is null)
+            continue;
+        if (personIsSeller(person)) {
+            writeln(person, " is a mango seller!");
+            return true;
+        }
+        search_queue.insertBack(graph[person]);
+        searched[person] = true;
+    }
+    return false;
+}
+
+string[][string] graph;
+
+void main() {
+    graph["you"] = ["alice", "bob", "claire"];
+    graph["bob"] = ["anuj", "peggy"];
+    graph["alice"] = ["peggy"];
+    graph["claire"] = ["thom", "jonny"];
+    graph["anuj"] = [];
+    graph["peggy"] = [];
+    graph["thom"] = [];
+    graph["jonny"] = [];
+
+    search("you");
+}
diff --git a/07_trees/d/01_filesystem_dfs.d b/07_trees/d/01_filesystem_dfs.d
new file mode 100644
index 0000000..1974b49
--- /dev/null
+++ b/07_trees/d/01_filesystem_dfs.d
@@ -0,0 +1,19 @@
+module app;
+
+import std;
+
+void printnames(string dir)
+{
+    foreach(DirEntry name; dirEntries(dir, SpanMode.shallow))
+    {
+        if (name.isFile)
+            writeln(name);
+        else
+            printnames(name);
+    }
+}
+
+void main()
+{
+    printnames("test1");
+}
diff --git a/09_dijkstras_algorithm/d/01_dijkstras_algorithm.d b/09_dijkstras_algorithm/d/01_dijkstras_algorithm.d
new file mode 100644
index 0000000..be548ea
--- /dev/null
+++ b/09_dijkstras_algorithm/d/01_dijkstras_algorithm.d
@@ -0,0 +1,63 @@
+module app;
+
+import std;
+
+alias Costs = double[string];
+alias Graph = Costs[string];
+
+Graph graph;
+string[] processed;
+
+string find_lowest_cost_node(const Costs costs)
+{
+    double lowestCost = double.infinity;
+    string lowestCostNode;
+    foreach(node; costs.byPair)
+    {
+        auto cost = node.value;
+        if (cost < lowestCost && (!processed.canFind(node.key)))
+        {
+            lowestCost = cost;
+            lowestCostNode = node.key;
+        }
+    }
+    return lowestCostNode;
+}
+
+void main()
+{
+    graph["start"] = ["a": 6, "b": 2];
+    graph["a"] = ["finish": 1];
+    graph["b"] = ["a": 3, "finish": 5];
+    graph["finish"] = new Costs;
+
+    Costs costs;
+    costs["a"] = 6;
+    costs["b"] = 2;
+    costs["finish"] = double.infinity;
+
+    string[string] parents;
+    parents["a"] = "start";
+    parents["b"] = "start";
+
+    auto node = find_lowest_cost_node(costs);
+    while (!node.empty)
+    {
+        double cost = costs[node];
+        auto neighbors = graph[node];
+        foreach(n; neighbors.byKey())
+        {
+            double newCost = cost + neighbors[n];
+            if (costs[n] > newCost)
+            {
+                costs[n] = newCost;
+                parents[n] = node;
+            }
+        }
+        processed ~= node;
+        node = find_lowest_cost_node(costs);
+    }
+
+    writeln("Cost from the start to each node:");
+    writeln(costs);
+}
diff --git a/10_greedy_algorithms/d/01_set_covering.d b/10_greedy_algorithms/d/01_set_covering.d
new file mode 100644
index 0000000..837233a
--- /dev/null
+++ b/10_greedy_algorithms/d/01_set_covering.d
@@ -0,0 +1,40 @@
+module app;
+
+import std;
+
+alias Set = bool[string];
+
+void main()
+{
+    Set statesNeeded = assocArray(["mt", "wa", "or", "id", "nv", "ut", "ca", "az"], true.repeat);
+    Set[string] stations;
+    stations["kone"] = assocArray(["id", "nv", "ut"], true.repeat);
+    stations["ktwo"] = assocArray(["wa", "id", "mt"], true.repeat);
+    stations["kthree"] = assocArray(["or", "nv", "ca"], true.repeat);
+    stations["kfour"] = assocArray(["nv", "ut"], true.repeat);
+    stations["kfive"] = assocArray(["ca", "az"], true.repeat);
+
+    Set finalStations;
+
+    while (!statesNeeded.empty)
+    {
+        string bestStation;
+        Set statesCovered;
+        foreach(station; stations.byPair)
+        {
+            auto coverage = setIntersection(station.value.keys.sort, statesNeeded.keys.sort).array;
+            if (coverage.length > statesCovered.keys.length)
+            {
+                bestStation = station.key;
+                statesCovered = assocArray(coverage, true.repeat);
+            }
+        }
+        if (statesCovered.length)
+        {
+            foreach(st; statesCovered.keys)
+                statesNeeded.remove(st);
+        }
+        finalStations[bestStation] = true;
+    }
+    writeln(finalStations.keys);
+}
diff --git a/11_dynamic_programming/d/01_longest_common_sub.d b/11_dynamic_programming/d/01_longest_common_sub.d
new file mode 100644
index 0000000..35f9aa3
--- /dev/null
+++ b/11_dynamic_programming/d/01_longest_common_sub.d
@@ -0,0 +1,53 @@
+module app;
+
+import std;
+
+alias DpTable = ulong[][];
+
+DpTable longest_common_substring(T)(T[] table1, T[] table2)
+{
+    DpTable dp_table = new DpTable(table1.length, table2.length);
+
+    foreach(i, c1; table1)
+        foreach(j, c2; table2)
+        {
+            if (c1 == c2)
+                dp_table[i][j] = dp_table[i > 0 ? i - 1 : 0][j > 0 ? j - 1 : 0] + 1;
+            else
+                dp_table[i][j] = 0;
+        }
+    return dp_table;
+}
+
+
+DpTable longest_common_subsequence(T)(T[] table1, T[] table2)
+{
+    DpTable dp_table = new DpTable(table1.length, table2.length);
+
+    foreach(i, c1; table1)
+        foreach(j, c2; table2)
+        {
+            if (c1 == c2)
+                dp_table[i][j] = dp_table[i > 0 ? i-1 : 0][j > 0 ? j-1 : 0] + 1;
+            else
+            {
+                dp_table[i][j] = max(dp_table[i > 0 ? i-1 : 0][j],
+                                     dp_table[i][j > 0 ? j-1 : 0]);
+            }
+        }
+    return dp_table;
+}
+
+void main()
+{
+    auto dp_table_blue = "blue";
+    auto dp_table_clues = "clues";
+    
+    writeln("Longest substring:");
+    foreach(line; longest_common_substring(dp_table_blue.array, dp_table_clues.array))
+        writeln(line);
+
+    writeln("Longest subsequence:");
+    foreach(line; longest_common_subsequence(dp_table_blue.array, dp_table_clues.array))
+        writeln(line);
+}