Adding Selection Sort Code In C++

BIT_subarrays_sum_in_given_range.cpp

@@ -0,0 +1,55 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define N 500000
+pair<long long int,int> a[N+1],c[N+1];
+long long int b;
+int bit[N+1];
+void update(int ind,int n)
+{
+    while(ind<=n)
+    {
+        bit[ind]++;
+        ind+=ind&(-ind);
+    }
+}
+long long int que(int ind)
+{
+    long long int ans=0;
+    while(ind>0)
+    {
+        ans+=bit[ind];
+        ind-=ind&(-ind);
+    }
+    return ans;
+}
+int main()
+{
+	ios_base::sync_with_stdio(false);
+    cin.tie(0);
+    int n,q;
+	long long int cnt,l,r;
+	cin>>n>>q;
+	for(int i=1;i<=n;i++)
+	    cin>>b,a[i].first+=a[i-1].first+b,a[i].second=i,c[i]=a[i];
+	sort(c+1,c+n+1);
+	for(int i=1;i<=n;i++)
+	    a[c[i].second].second=i;
+	while(q--)
+	{
+        cnt=0;
+        cin>>l>>r;
+        for(int i=1;i<=n;i++)
+        {
+            int h=upper_bound(c+1,c+n+1,make_pair(a[i].first-l,INT_MAX))-c;
+            int lo=lower_bound(c+1,c+n+1,make_pair(a[i].first-r,INT_MIN))-c;
+            if(a[i].first>=l && a[i].first<=r)
+                cnt+=1;
+            cnt+=que(h-1)-que(lo-1);
+             update(a[i].second,n);
+        }
+        cout<<cnt<<endl;
+        for(int i=1;i<=n;i++)
+            bit[i]=0;
+	}
+	return 0;
+}

CONTRIBUTING.md

@@ -1,7 +1,5 @@
 <ul>
-<li>Algorithms can br from any field(ML etc) and any language</li>
-<li>
-   Add Comments. Your code should be self documented
-   </li>
-   <li> Use relivant names</li>
-   </ul>
+<li> Algorithms can be from any field (ML etc) and language </li>
+<li> Add Comments. Your code should be self documented </li>
+<li> Use relevant names </li>
+</ul>

DisjointSet.cpp

@@ -57,6 +57,7 @@ int main(){
         cout<<i<<" "<<ds.Find(i)<<"\n"; // displays parent of i'th indes is ds.Find(i)
                                         // alternatively we can say that those that have same ds.find() values belong to same set
     }
+    return 0;
 }
 
 

Fenwick-tree.cpp

@@ -0,0 +1,30 @@
+#include <bits/stdc++.h>
+#define LSB(x) x&-x
+using namespace std;
+int BIT[1000], A[1000], N;
+void update(int idx, int val){
+    for(; idx<=N; idx+= LSB(idx)){
+        BIT[idx] += val;
+    }
+}
+
+int query(int idx){
+    int sum = 0;
+    for(; idx>0; idx-= LSB(idx)){
+        sum += BIT[idx];
+    }
+    return sum;
+}
+
+int main(){
+    N = 16;
+    int l,r;
+    //creating BIT
+    for(int i = 1; i<=N; i++){
+        A[i] = i;
+        update(i, A[i]);
+    }
+    //range query
+    cin >> l >> r;
+	cout << query(r) - query(l-1);
+}

Fenwick_tree(Binary_indexed_tree).cpp

@@ -0,0 +1,32 @@
+#include<bits/stdc++.h>
+#define ll long long int
+using namespace std;
+
+ll Fen_tree[100005], a[100005], n;
+void updt(ll x, ll val)
+{
+      for(; x <= n; x += x&-x)
+        Fen_tree[x] += val;
+}
+ll query(ll val)
+{
+     ll sum = 0;
+     for(; val > 0; val -= val&-val)
+        sum += Fen_tree[val];
+     return sum;
+}
+
+int main()
+{
+     cin>>n;
+     ll i,x,l,r;
+     for(i = 1; i <= n; i++)
+     {
+           cin>>a[i];
+           updt(i, a[i]);
+     }
+     cin>>x>>l>>r;
+     cout<<"Sum of first "<<x<<" elements is "<<query(x)<<endl;
+     cout<<"Sum of all elements in range "<<"[ "<<l<<" , "<<r<<" ] is "<<(query(r)-query(l-1));
+     return 0;
+}

List.cpp

@@ -0,0 +1,109 @@
+#include <iostream>
+
+template < typename T >
+class Node
+{
+public:
+    T data;
+    Node* next;
+
+    Node (T data) { this->data = data; }
+    Node(){}
+};
+
+template < typename T >
+class List
+{
+public:
+    int count;
+    Node<T>* head = new Node<T>;
+
+    List ();
+
+    void add (T data);
+    void remove (int index);
+    int size () { return this->count; }
+    void print ();
+};
+
+template <typename T>
+List<T>::List ()
+{
+    this->count = 0;
+    this->head->next = nullptr;
+    this->head->next = nullptr;
+}
+
+template < typename T >
+void List<T>::add (T data)
+{
+    Node<T>* newNode = new Node<T>(data);
+    newNode->next = nullptr;
+
+    if (head->next == nullptr) { head->next = newNode; }
+    else {
+        Node<T>* temp = head;
+        while (temp->next != nullptr)
+            temp = temp->next;
+        temp->next = newNode;
+    }
+
+    ++List::count;
+}
+
+template <typename T>
+void List<T>::remove (int index)
+{
+    Node<T>* temp = head;
+    Node<T>* target = head;
+
+    if(count < index) { std::cout << "out of index!" << std::endl; return; }
+
+    for (int i = 0; i < index; ++i) {
+        temp = temp->next;
+        target = target->next;
+    }
+    target = target->next;
+
+    temp->next = target->next;
+    target->next = nullptr;
+    delete target;
+    --List::count;
+}
+
+template <typename T>
+void List<T>::print ()
+{
+    Node<T>* iterator;
+    iterator = head;
+
+    while(iterator->next != nullptr) {
+        iterator = iterator->next;
+        std::cout << iterator->data << " ";
+    }
+    std::cout << std::endl;
+}
+
+int main ()
+{
+    // These codes are test
+    List<char> test;
+    test.add ('A');
+    test.print ();
+
+    test.add ('B');
+    test.print ();
+
+    test.add ('C');
+    test.print ();
+
+    test.remove(5);
+    test.print();
+
+    test.remove(1);
+    test.print();
+
+    return 0;
+}
+
+

README.md

@@ -1 +1,2 @@
-<h1> Add only Advanced Data Structrues</h1>
+<h1> Some cool data structures Repo</h1>
+<p> This repo contains the implementation of various data structus in different languages.</p>

Segment Tree Lazy Propagation.cpp

@@ -0,0 +1,67 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long int ll;
+ll tree[400001],tree1[400001];
+void lazy(ll node,ll l,ll r)
+{
+	tree[node]+=tree1[node]*(r-l+1);
+	if(l==r)
+	{
+		tree1[node]=0;
+		return;
+	}
+	tree1[2*node]+=tree1[node];
+	tree1[2*node+1]+=tree1[node];
+	tree1[node]=0;
+}
+ll q0(ll node,ll l,ll r,ll l1,ll r1,ll val=0){
+	//cout<<val<<endl;
+	lazy(node,l,r);
+	if(l1<=l&&r<=r1)
+	{
+		tree1[node]+=val;
+		lazy(node,l,r);
+		//cout<<tree[node]<<" ";
+		return tree[node];
+	}
+	else if(r<l1||r1<l)
+	{
+		return 0;
+	}
+	else{
+		ll mid=(l+r)/2;
+
+		ll x1=q0(2*node,l,mid,l1,r1,val);
+		ll x2=q0(2*node+1,mid+1,r,l1,r1,val);
+		tree[node]=tree[2*node]+tree[2*node+1];
+		return x1+x2;
+	}
+}
+int main() {
+	// your code goes here
+	ll t;
+	cin>>t;
+	while(t--)
+	{
+		ll n,m;
+		cin>>n>>m;
+		ll i,j,k;
+		memset(tree,0,sizeof(tree));
+		memset(tree1,0,sizeof(tree1));
+		while(m--)
+		{
+			ll x,p,q,v;
+			cin>>x;
+			if(x==0)
+			{
+				cin>>p>>q>>v;
+				q0(1,1,n,p,q,v);
+			}
+			else{
+				cin>>p>>q;
+				cout<<q0(1,1,n,p,q)<<endl;
+			}
+		}
+	}
+	return 0;
+}