## Posts

### An attempt to Implement Binary Search STL (associative) Containers agnostic way.

Binary Search is a very trivial algorithm to search a target value from a sorted array. It's popular among students of computer science and also during interviews it gets asked by the interviewer. It's easy. We take an array of integers already sorted and apply binary search on that array to figure out if the target value does present in that sorted array or not.  The condition can be either present or not present. If it is present we return the array index of the element else we return -1. The algorithm is very simple, it's broken down into three parts. 1. Find and compare the middle element of the search space with the key. 2. If the key is found in the middle, just return the array index. 3. If the key is not found then choose half of the array space, based on whether the key value is smaller or greater than the mid element.       a. If the key element is smaller than the mid element, then the left side of the search space will be used otherwise, the right side of the s

### A simple approach to generate Fibonacci series via multi-threading

T his is a very simple approach taken to generate the Fibonacci series through multithreading. Here instead of a function, used a function object. The code is very simple and self-explanatory.  #include <iostream> #include <mutex> #include <thread> class Fib { public:     Fib() : _num0(1), _num1(1) {}     unsigned long operator()(); private:     unsigned long _num0, _num1;     std::mutex mu; }; unsigned long Fib::operator()() {     mu.lock(); // critical section, exclusive access to the below code by locking the mutex     unsigned long  temp = _num0;     _num0 = _num1;     _num1 = temp + _num0;     mu.unlock();     return temp; } int main() {     Fib f;          int i = 0;     unsigned long res = 0, res2= 0, res3 = 0;     std::cout << "Fibonacci series: ";     while (i <= 15) {         std::thread t1([&] { res = f(); }); // Capturing result to respective variable via lambda         std::thread t2([&] { res2 = f(); });         std::thread t3(

### An Attempt to run Odd-Even Sorting in multi-threading

This is an attempt to run odd-even sorting from two threads without using locks. I have used a vector and split the vector logically in two halves if the size is beyond a value (Here as an example kept size 10, that means if the vector size is more than 10, then two threads will spawn and parallelize (on multi-core) sorting on the elements of the vector container. Finally, after sorting each half by two threads, another sorting will be arranged to make it finally sorted.  The Wiki contains the details about Odd-Even sorting. It's a comparison sorting. The below code snippet is a simple approach to odd-even sorting with multi-threading without having locks. No Extra space was allocated/used in this scenario.  void partBySort(std::vector<int>* vec, size_t begIndex, size_t endIndex) {     if (begIndex == endIndex) return;     bool isSorted = false;     while (!isSorted)     {         isSorted = true;         for (size_t i = begIndex; i <= endIndex - 1; i += 2)         {

### The Simplest sorting algorithm

The simplest sorting algorithm is not bubble sort or insertion sort but known as stupid sort aka gnome sort . The time complexity is like a bubble sort. However, the code base size is much smaller. Possibly it offers the smallest code base size in the domain of the sorting algorithm. The details can be found on Wikipedia . Here goes the code: void gnomeSort(std::vector<int>& data) {     int pos = 0;     while (pos < data.size())     {         if (pos == 0 or data[pos] >= data[pos - 1])             pos += 1;         else          {             std::swap(data[pos], data[pos - 1]);             pos -= 1;         }     } } int main() {        std::vector<int> v4 = { 10, 0, 2, 33, 5, 77, 8, 19, 1, 7 };       gnomeSort(v4);       for (auto i: v4)          std::cout << i << " "; } Happy sorting...