Armstrong Numbers between 1-1000.

An Optimal Stopping Problem

@@ -0,0 +1,69 @@
+// C++ Program to test 1/e law for Secretary Problem : 
+#include <iostream> 
+#include <time.h> 
+#define e 2.71828 
+using namespace std; 
+
+// To find closest integer of num. 
+int roundNo(float num) 
+{ 
+	return num < 0 ? num - 0.5 : num + 0.5; 
+} 
+
+// Finds best candidate using n/e rule. candidate[] 
+// represents talents of n candidates. 
+void printBestCandidate(int candidate[], int n) 
+{ 
+	// Calculating sample size for benchmarking. 
+	int sample_size = roundNo(n/e); 
+	cout << "\n\nSample size is " << sample_size << endl; 
+
+	// Finding best candidate in sample size 
+	int best = 0; 
+	for (int i = 1; i < sample_size; i++) 
+		if (candidate[i] > candidate[best]) 
+			best = i; 
+
+	// Finding the first best candidate that is 
+	// better than benchmark set. 
+	for (int i = sample_size; i < n; i++) 
+		if (candidate[i] >= candidate[best]) { 
+			best = i; 
+			break; 
+		} 
+
+	if (best >= sample_size) 
+		cout << endl << "Best candidate found is "
+			<< best + 1 << " with talent "
+			<< candidate[best] << endl; 
+	else
+		cout << "Couldn't find a best candidate\n"; 
+} 
+
+int main() 
+{ 
+	int n = 8; 
+
+	// n = 8 candidates and candidate array contains 
+	// talents of n candidate where the largest 
+	// number means highest talented candidate. 
+	int candidate[n]; 
+
+	// generating random numbers between 1 to 8 
+	// for talent of candidate 
+	srand(time(0));	 
+	for (int i = 0; i < n; i++) 
+		candidate[i] = 1 + rand() % 8; 
+
+	cout << "Candidate : "; 
+	for (int i = 0; i < n; i++) 
+		cout << i + 1 << " "; 
+	cout << endl; 
+	cout << " Talents : "; 
+	for (int i = 0; i < n; i++) 
+		cout << candidate[i] << " "; 
+
+	printBestCandidate(candidate, n); 
+
+	return 0; 
+} 

Array Reversal.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main()
+{
+    int num, *arr, i;
+    scanf("%d", &num);
+    arr = (int*) malloc(num * sizeof(int));
+    for(i = 0; i < num; i++) {
+        scanf("%d", arr + i);
+    }
+    int* left_ptr = arr;
+    int* right_ptr;
+    int temp;
+    for(i = 0; i < num; i++) {
+        if(i == num - 1) {
+            right_ptr = (arr + i);
+        }
+    }
+    while(left_ptr < right_ptr) {
+        temp = *right_ptr;
+        *right_ptr = *left_ptr;
+        *left_ptr = temp;
+        right_ptr--;
+        left_ptr++;
+    }
+
+    for(i = 0; i < num; i++) {
+        printf("%d ", *(arr + i));
+    }
+    free(arr);
+    return 0;
+}

Array Stacking Algorithm/C++/stackusing2qs.cpp

@@ -0,0 +1,94 @@
+#include<iostream>
+using namespace std;
+
+struct qu1// queue1 declaration {
+   qu1 *n1;
+   int d1;
+}*f1 = NULL, *r1 = NULL, *q1 = NULL, *p1 = NULL, *np1 = NULL;
+
+struct qu2// queue2 declaration {
+   qu2 *n2;
+   int d2;
+}*f2 = NULL, *r2 = NULL, *q2 = NULL, *p2 = NULL, *np2 = NULL;
+
+void enqueue1(int a) {
+   np1 = new qu1;
+   np1->d1 = a;
+   np1->n1 = NULL;
+   if (f1 == NULL) {
+      r1 = np1;
+      r1->n1 = NULL;
+      f1 = r1;
+   } else {
+      r1->n1 = np1;
+      r1 = np1;
+      r1->n1 = NULL;
+   }
+}
+
+int dequeue1() {
+   int a;
+   if (f1 == NULL) {
+      cout<<"no elements present in queue\n";
+   } else {
+      q1 = f1;
+      f1 = f1->n1;
+      a = q1->d1;
+      delete(q1);
+      return a;
+   }
+}
+
+void enqueue2(int a) {
+   np2 = new qu2;
+   np2->d2 = a;
+   np2->n2 = NULL;
+   if (f2 == NULL) {
+      r2 = np2;
+      r2->n2 = NULL;
+      f2 = r2;
+   } else {
+      r2->n2 = np2;
+      r2 = np2;
+      r2->n2 = NULL;
+   }
+}
+
+int dequeue2() {
+   int a;
+   if (f2 == NULL) {
+      cout<<"no elements present in queue\n";
+   } else {
+      q2 = f2;
+      f2 = f2->n2;
+      a = q2->d2;
+      delete(q2);
+      return a;
+   }
+}
+
+int main() {
+   int n, a, i = 0;
+   cout<<"Enter the number of elements to be entered into stack\n";
+   cin>>n;
+   while (i < n) {
+      cout<<"enter the element to be entered\n";
+      cin>>a;
+      enqueue1(a);
+      i++;
+   }
+   cout<<"\n\nElements popped\n\n";
+   while (f1 != NULL || f2 != NULL)// if both queues are not null {
+      if (f2 == NULL)// if queue 2 is null {
+         while (f1->n1 != NULL) {
+            enqueue2(dequeue1());
+         }
+         cout<<dequeue1()<<endl;
+      } else if (f1 == NULL)//if queue 1 is null {
+         while (f2->n2 != NULL) {
+            enqueue1(dequeue2());
+         }
+         cout<<dequeue2()<<endl;
+      }
+   }
+}

Automaton/PushDown-Automata.py

@@ -0,0 +1,90 @@
+# A Simple Implementation of Push Down Automaton:
+##    Defining the 6 tuples:
+#>  *  Q-->finite set of sets
+#>  *  Sigma-->finite set of input alphabet
+#>  *  Gamma-->finite set of stack alphabet
+#>  *  Delta-->transition relation
+#>  *  Q0-->start state
+#>  *  Z-->initial stack symbol
+#>  *  F-->set of accepting states
+
+# Defining the states:
+
+#* state 0: starting state
+
+#* state 1:From state 0 whenever it sees a 1 or 2, it moves to state 1+pushes the element onto the stack
+#* state 1:From state 1 whenever it sees a 1 or 2, it remains in state 1+pushes the element onto the stack
+
+#* state 2:From state 1 whenever it sees a 0, it moves to state 2+pops from the stack
+#* state 2:From state 1 whenever it sees a 0, it remains in state 2+pops from the stack
+
+#* state 3:From state 0, if it sees a 0,it moves to state 3,the rejected state
+#* state 3:From state 2, if it sees a 1 or 2 , it moves to state 3, the rejected state
+#* state 3:If at the end, the stack is not empty, it moves to state 3,the rejected state
+
+#stack functions
+def push(a,list1):
+    #pushing to the stack/adding to the top of the stack
+    list1.append(a)
+    return 1
+
+def pop(list1):
+    #for poping from the stack/removing the top element of the stack
+    index=len(list1)-1
+    if (index>0):
+        list1.pop(index)
+        return 1
+    else:
+        return 0
+
+#    Q={0,1,2,3}
+#    Sigma={0,1,2}
+#    Starting state={0}
+#    Z=#
+#    F={2}
+
+#setting the initial stack symbol
+stack=['#']
+#setting the starting state
+state=0
+
+#taking the input
+input_string=input('Enter the String:')
+
+#performing the operations
+l=len(input_string)
+i=0
+if l%2==0:
+    while i<l//2:
+        letter=int(input_string[i])
+        if letter in [1,2]:
+            push(letter,stack)
+            state=1
+        else :
+            state=3
+            break
+        i+=1
+
+    while i<l:
+        letter=int(input_string[i])
+        if state==3:
+            break
+        if letter==0:
+            state=2
+            pop(stack)
+        else:
+            state=3
+            break
+        i+=1
+else:
+    state=3
+
+if state==2 and len(stack)!=1:
+    state=3
+
+
+#checking the final state and displaying the result
+if(state==2):
+    print("The String is accepted")
+else:
+    print("The String is rejected")

BIT/ComputeXOR1toN/computeXOR1toN.py

@@ -0,0 +1,14 @@
+#Direct XOR of all numbers from 1 to n 
+def computeXOR( n) 
+
+    if (n % 4 == 0) :
+        return n
+    if (n % 4 == 1) :
+        return 1 
+    if (n % 4 == 2) :
+        return n + 1 
+    else :
+        return 0 
+
+n = input("enter N")
+print(computeXOR(n))

BIT/Maximum Subset XOR/flip.cpp

@@ -0,0 +1,27 @@
+#include <iostream> 
+using namespace std; 
+
+int countSetBit(int n) 
+{ 
+    int c = 0; 
+    while (n) 
+    { 
+        c += n & 1; 
+        n >>= 1; 
+    } 
+    return c; 
+} 
+
+int FlippedCount(int a, int b) 
+{ 
+    return countSetBit(a^b); 
+} 
+
+
+int main() 
+{ 
+    int n1 = 14; 
+    int n2 = 50; 
+    cout << FlippedCount(n1, n2)<<endl; 
+    return 0; 
+}

BIT/Maximum Subset XOR/maxXor.cpp

@@ -0,0 +1,57 @@
+#include<bits/stdc++.h> 
+using namespace std; 
+
+#define INT_BITS 32 
+
+int maxSubarrayXOR(int set[], int n) 
+{ 
+
+    int indx = 0; 
+
+    for (int i = INT_BITS-1; i >= 0; i--) 
+    { 
+        int maxInd = indx; 
+        int maxEle = INT_MIN; 
+        for (int j = indx; j < n; j++) 
+        { 
+
+            if ( (set[j] & (1 << i)) != 0  
+                     && set[j] > maxEle ) 
+                maxEle = set[j], maxInd = j; 
+        } 
+
+        if (maxEle == INT_MIN) 
+        continue; 
+
+        swap(set[indx], set[maxInd]); 
+
+        maxInd = indx; 
+
+        for (int j=0; j<n; j++) 
+        {  
+            if (j != maxInd && 
+               (set[j] & (1 << i)) != 0) 
+                set[j] = set[j] ^ set[maxInd]; 
+        } 
+
+        // Increment index of 
+        // chosen elements 
+        indx++; 
+    } 
+
+    int result = 0; 
+    for (int i = 0; i < n; i++) 
+        result ^= set[i]; 
+    return result; 
+} 
+
+
+int main() 
+{ 
+    int set[] = {10, 8, 5}; 
+    int n = sizeof(set) / sizeof(set[0]); 
+
+    cout << "Maximum subset XOR is "; 
+    cout << maxSubarrayXOR(set, n); 
+    return 0; 
+}