Added new files

Bit Manipulation/power of 4/cpp/power_of_4.cpp

@@ -0,0 +1,34 @@
+/* Power of 2 can be found by (n&(n-1) == 0
+ * Because it will have only one set bit
+ * For power of 4 we have to check the even
+ * positions for the set bit
+ * So we & it with 10101010101010101010101010101010
+ * It can also be written as 0xAAAAAAAA
+ * If (n & 0xAAAAAAAA) == 0 then n is power of 4
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+typedef double dl;
+#define mem(x,val) memset((x),(val),sizeof(x))
+#define pb push_back
+#define mod 1000000007
+
+bool poweroffour(int n)
+{
+    return (n && !(n&(n-1)) && !(n & 0xAAAAAAAA));
+}
+int main()
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int n;
+    cin>>n;
+    if(poweroffour(n))
+        cout<<n<<" is a power of 4\n";
+    else
+        cout<<n<<" is not a power of 4\n";
+    return 0;
+}

Bit Manipulation/xor of subsets/cpp/XOR_of_subsets_equal_to_k.cpp

@@ -0,0 +1,43 @@
+#include<bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+typedef double dl;
+#define mem(x,val) memset((x),(val),sizeof(x))
+#define pb push_back
+#define mod 1000000007
+int subsetXOR(int arr[],int n,int k)
+{
+    int max_ele=*max_element(arr,arr+n);
+    int m=(1<<(int)log2(max_ele)+1)-1;
+
+    int dp[n+1][m+1];
+
+    for(int i=0;i<=n;i++)
+    {
+        for(int j=0;j<=m;j++)
+            dp[i][j]=0;
+    }
+
+    dp[0][0]=1;
+    for(int i=1;i<=n;i++)
+    {
+        for(int j=0;j<=m;j++)
+            dp[i][j]=dp[i-1][j]+dp[i][j^arr[i-1]];
+    }
+    return dp[n][k];
+}
+int main()
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int n;
+    cin>>n;
+    int arr[n];
+    for(int i=0;i<n;i++)
+        cin>>arr[i];
+    int k;
+    cin>>k;
+    cout<<subsetXOR(arr,n,k);
+    return 0;
+}

Greedy Algorithms/Activity Selection/cpp/activity_selection.cpp

@@ -0,0 +1,41 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Activitiy
+{
+    int start, finish;
+};
+
+
+bool activityCompare(Activitiy s1, Activitiy s2)
+{
+    return (s1.finish < s2.finish);
+}
+
+
+void printMaxActivities(Activitiy arr[], int n)
+{
+    sort(arr, arr+n, activityCompare);
+
+    cout << "Following activities are selected n";
+    int i = 0;
+    cout << "(" << arr[i].start << ", " << arr[i].finish << "), ";
+    for (int j = 1; j < n; j++)
+    {
+      if (arr[j].start >= arr[i].finish)
+      {
+          cout << "(" << arr[j].start << ", "
+              << arr[j].finish << "), ";
+          i = j;
+      }
+    }
+}
+
+int main()
+{
+    Activitiy arr[] = {{5, 9}, {1, 2}, {3, 4}, {0, 6},
+                                       {5, 7}, {8, 9}};
+    int n = sizeof(arr)/sizeof(arr[0]);
+    printMaxActivities(arr, n);
+    return 0;
+}

Greedy Algorithms/Activity Selection/python/activity_selection.py

@@ -0,0 +1,35 @@
+
+
+class Activity:
+
+    def __init__(self, start, finish):
+        self.start = start
+        self.finish = finish
+
+    def __lt__(self, other):
+        return self.finish < other.finish
+
+    def __repr__(self):
+        return "( %s, %s )" % (self.start, self.finish)
+
+
+def activity_selection(activity_arr):
+    selected_activities = []
+
+    if activity_arr:
+        activity_arr.sort()
+        selected = activity_arr[0]
+
+        selected_activities.append(selected)
+
+        for activity in activity_arr:
+            if activity.start >= selected.finish:
+                selected = activity
+                selected_activities.append(selected)
+
+    return selected_activities
+
+
+activity_arr = [Activity(5,9), Activity(1, 2), Activity(3, 4), Activity(0, 6), Activity(5, 7), Activity(8, 9)]
+
+print(activity_selection(activity_arr))

Mathematics/factorial/cpp/FactorialOfLargeNumber.cpp

@@ -0,0 +1,49 @@
+#include<iostream>
+using namespace std;
+
+#define MAX 500
+
+int multiply(int x, int res[], int res_size);
+
+void factorial(int n)
+{
+    int res[MAX];
+
+    res[0] = 1;
+    int res_size = 1;
+
+    for (int x=2; x<=n; x++)
+    {
+        res_size = multiply(x, res, res_size);
+    }
+
+    cout << "Factorial of given number is \n";
+    for (int i=res_size-1; i>=0; i--)
+        cout << res[i];
+}
+
+int multiply(int x, int res[], int res_size)
+{
+    int carry = 0;
+
+    for (int i=0; i<res_size; i++)
+    {
+        int prod = res[i] * x + carry;
+        res[i] = prod % 10;  
+        carry  = prod/10;    
+    }
+
+    while (carry)
+    {
+        res[res_size] = carry%10;
+        carry = carry/10;
+        res_size++;
+    }
+    return res_size;
+}
+
+int main()
+{
+    factorial(100);
+    return 0;
+}

Tree/right_view_binary_tree/cpp/right_view_binary_tree.cpp

@@ -0,0 +1,56 @@
+#include<bits/stdc++.h>
+using namespace std;
+struct node
+{
+ int d;
+ node *left;
+ node *right;
+};
+
+struct node* newnode(int num)
+{
+ node *temp=new node;
+ temp->d=num;
+ temp->left=temp->right=NULL;
+ return temp;
+}
+
+void rightview(struct node *root, int level, int *maxlevel)
+{
+ if(root==NULL)
+ return;
+
+
+ if(*maxlevel<level)
+ {
+  cout<<root->d<<" ";
+  *maxlevel=level;
+ }
+
+ rightview(root->right,level+1,maxlevel);
+ rightview(root->left,level+1,maxlevel);
+
+}
+
+int main()
+{
+    struct node *root = newnode(1);
+    root->left = newnode(2);
+    root->right = newnode(3);
+    root->left->left = newnode(4);
+    root->left->right = newnode(5);
+    root->right->left = newnode(6);
+    root->right->right = newnode(7);
+    root->right->left->right = newnode(8);
+
+
+ int maxlevel=0;
+
+ cout<<"\nRight view : ";
+ rightview(root,1,&maxlevel);
+
+ cout<<endl;
+ return 0;
+}
+
+

Tree/right_view_binary_tree/python/right_view.py

@@ -0,0 +1,32 @@
+
+class Node:
+    def __init__(self, item):
+        self.data = item
+        self.left = None
+        self.right = None
+
+def rightViewUtil(root, level, max_level):
+
+    if root is None:
+        return
+    if (max_level[0] < level):
+        print "%d   " %(root.data),
+        max_level[0] = level
+    rightViewUtil(root.right, level+1, max_level)
+    rightViewUtil(root.left, level+1, max_level)
+
+def rightView(root):
+    max_level = [0]
+    rightViewUtil(root, 1, max_level)
+
+root = Node(1)
+root.left = Node(2)
+root.right = Node(3)
+root.left.left = Node(4)
+root.left.right = Node(5)
+root.right.left = Node(6)
+root.right.right = Node(7)
+root.right.left.right = Node(8)
+
+rightView(root)
+

data structures/linked list/cpp/circular_linked_list.cpp

@@ -0,0 +1,56 @@
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+
+struct node{
+	int info;
+	node *next;
+}*ptr,*head,*start;
+
+int c=1,data;
+
+ptr=new node;
+ptr->next=NULL;
+
+start=head=ptr;
+
+while(c<3 && c>0){
+	cout<<"1.Insert\n2.Link List\n";
+	cin>>c;
+
+	switch(c){
+		case 1:
+			cout<<"Enter Data\n";
+			cin>>data;
+
+			ptr=new node;
+			ptr->next=start;
+			ptr->info=data;
+
+			head->next=ptr;
+			head=ptr;
+
+		break;
+
+		case 2:
+			ptr=start->next;
+
+			while(ptr!=start && ptr!=NULL){
+				cout<<ptr->info<<"->";
+				ptr=ptr->next;
+			}
+			cout<<"\n";
+		break;
+
+		default:
+			cout<<"Wrong Choice\nExiting...\n";
+	}
+
+}
+
+getch();
+return 0;
+}