diff --git a/app/src/main/assets/00000028.txt b/app/src/main/assets/00000028.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f55de8a85ad1d2e655412ba440efbc38f2ea4d39
--- /dev/null
+++ b/app/src/main/assets/00000028.txt
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <math.h>
+
+int main()
+{
+ int number, originalNumber, remainder, result = 0, n = 0 ;
+
+ printf("Enter an integer: ");
+ scanf("%d", &number);
+
+ originalNumber = number;
+
+ while (originalNumber != 0)
+ {
+ originalNumber /= 10;
+ ++n;
+ }
+
+ originalNumber = number;
+
+ while (originalNumber != 0)
+ {
+ remainder = originalNumber%10;
+ result += pow(remainder, n);
+ originalNumber /= 10;
+ }
+
+ if(result == number)
+ printf("%d is an Armstrong number.", number);
+ else
+ printf("%d is not an Armstrong number.", number);
+
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000029.txt b/app/src/main/assets/00000029.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2d4c1a9313ec5611fd791468435d8d46f5ec9849
--- /dev/null
+++ b/app/src/main/assets/00000029.txt
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#define SIZE 15
+
+int binarySearch( const int b[], int searchKey, int low, int high );
+
+int main() {
+ int a[ SIZE ];
+ int i;
+ int key = 10;
+ int result = -1;
+
+ for ( i = 0; i < SIZE; i++ ) {
+ a[ i ] = 2 * i;
+ }
+
+ result = binarySearch( a, key, 0, SIZE - 1 );
+
+ if ( result != -1 ) {
+ printf( "\n%d found in array element %d\n", key, result );
+ } else {
+ printf( "\n%d not found\n", key );
+ }
+
+ return 0;
+
+}
+
+int binarySearch( const int b[], int searchKey, int low, int high )
+{
+ int middle;
+
+ while ( low <= high ) {
+ middle = ( low + high ) / 2;
+
+ if ( searchKey == b[ middle ] ) {
+ return middle;
+ } else if ( searchKey < b[ middle ] ) {
+ high = middle - 1;
+ } else {
+ low = middle + 1;
+ }
+ }
+ return -1;
+
+}
diff --git a/app/src/main/assets/00000030.txt b/app/src/main/assets/00000030.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ec57df9a266ecab9138ddb540c60ac9281b94fbc
--- /dev/null
+++ b/app/src/main/assets/00000030.txt
@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <math.h>
+int convertBinaryToDecimal(long long n);
+
+int main()
+{
+ long long n;
+ printf("Enter a binary number: ");
+ scanf("%lld", &n);
+ printf("%lld in binary = %d in decimal", n, convertBinaryToDecimal(n));
+ return 0;
+}
+
+int convertBinaryToDecimal(long long n)
+{
+ int decimalNumber = 0, i = 0, remainder;
+ while (n!=0)
+ {
+ remainder = n%10;
+ n /= 10;
+ decimalNumber += remainder*pow(2,i);
+ ++i;
+ }
+ return decimalNumber;
+}
diff --git a/app/src/main/assets/00000031.txt b/app/src/main/assets/00000031.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cdd0040564ade5620da21bf20ae4891c0cae98a9
--- /dev/null
+++ b/app/src/main/assets/00000031.txt
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <conio.h>
+void main()
+{
+ int a[15],i,j,n,temp;
+ clrscr();
+ printf("\nENTER THE SIZE OF ARRAY:") ;
+ scanf("%d",&n);
+ printf("\nENTER VALUES FOR THE ARRAY:\n");
+ for(i=0;i<n;i++)
+ scanf("%d",&a[i]);
+ for(i=0;i<n-1;i++)
+ {
+ for(j=i+1;j<n;j++)
+ {
+ if(a[i]>a[j])
+ {
+ temp=a[i];
+ a[i]=a[j];
+ a[j]=temp;
+ }
+ }
+ }
+ printf("\nTHE SORTED ARRAY IS:\n");
+ for(i=0;i<n;i++)
+ printf("%d ",a[i]);
+ getch();
+}
diff --git a/app/src/main/assets/00000032.txt b/app/src/main/assets/00000032.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50d0effef160a773a1578fdb2b04c31ac3501955
--- /dev/null
+++ b/app/src/main/assets/00000032.txt
@@ -0,0 +1,38 @@
+#include<stdio.h>
+void Bucket_Sort(int array[], int n) {
+ int i, j;
+ int count[n];
+ for (i=0; i < n; i++) {
+ count[i] = 0;
+ }
+ for (i=0; i < n; i++) {
+ (count[array[i]])++;
+ }
+ for (i=0,j=0; i < n; i++) {
+ for (; count[i]>0;(count[i])--) {
+ array[j++] = i;
+ }
+ }
+}
+int main() {
+ int array[100];
+ int num;
+ int i;
+ printf("Enter How many Numbers : ");
+ scanf("%d",&num);
+ printf("Enter the %d elements to be sorted:\n",num);
+ for (i = 0; i < num; i++ ) {
+ scanf("%d",&array[i]);
+ }
+ printf("\nThe array of elements before sorting : \n");
+ for (i = 0;i < num;i++) {
+ printf("%d ", array[i]);
+ }
+ printf("\nThe array of elements after sorting : \n");
+ Bucket_Sort(array, num);
+ for (i = 0;i < n;i++) {
+ printf("%d ", array[i]);
+ }
+ printf("\n");
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000033.txt b/app/src/main/assets/00000033.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9c5175ab04648f8a095d8f9a7bdbc098c4c5edd7
--- /dev/null
+++ b/app/src/main/assets/00000033.txt
@@ -0,0 +1,82 @@
+#include<stdio.h>
+#include<conio.h>
+#include<math.h>
+
+int fm(int date, int month, int year) {
+ int fmonth, leap;
+
+ //leap function 1 for leap & 0 for non-leap
+ if ((year % 100 == 0) && (year % 400 != 0))
+ leap = 0;
+ else if (year % 4 == 0)
+ leap = 1;
+ else
+ leap = 0;
+
+ fmonth = 3 + (2 - leap) * ((month + 2) / (2 * month))
+ + (5 * month + month / 9) / 2;
+
+ //bring it in range of 0 to 6
+ fmonth = fmonth % 7;
+
+ return fmonth;
+}
+
+//----------------------------------------------
+int day_of_week(int date, int month, int year) {
+
+ int dayOfWeek;
+ int YY = year % 100;
+ int century = year / 100;
+
+ printf("\nDate: %d/%d/%d \n", date, month, year);
+
+ dayOfWeek = 1.25 * YY + fm(date, month, year) + date - 2 * (century % 4);
+
+ //remainder on division by 7
+ dayOfWeek = dayOfWeek % 7;
+
+ switch (dayOfWeek) {
+ case 0:
+ printf("weekday = Saturday");
+ break;
+ case 1:
+ printf("weekday = Sunday");
+ break;
+ case 2:
+ printf("weekday = Monday");
+ break;
+ case 3:
+ printf("weekday = Tuesday");
+ break;
+ case 4:
+ printf("weekday = Wednesday");
+ break;
+ case 5:
+ printf("weekday = Thursday");
+ break;
+ case 6:
+ printf("weekday = Friday");
+ break;
+ default:
+ printf("Incorrect data");
+ }
+ return 0;
+}
+//------------------------------------------
+int main() {
+ int date, month, year;
+
+ printf("\nEnter the year ");
+ scanf("%d", &year);
+
+ printf("\nEnter the month ");
+ scanf("%d", &month);
+
+ printf("\nEnter the date ");
+ scanf("%d", &date);
+
+ day_of_week(date, month, year);
+
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000034.txt b/app/src/main/assets/00000034.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bceac53f1cf1eb67ac23a74a2e35141604210be2
--- /dev/null
+++ b/app/src/main/assets/00000034.txt
@@ -0,0 +1,33 @@
+#include<stdio.h>
+#include <string.h>
+
+int main()
+{
+ int i, j;
+ char str[10][50], temp[50];
+
+ printf("Enter 10 words:\n");
+
+ for(i=0; i<10; ++i)
+ scanf("%s[^\n]",str[i]);
+
+
+ for(i=0; i<9; ++i)
+ for(j=i+1; j<10 ; ++j)
+ {
+ if(strcmp(str[i], str[j])>0)
+ {
+ strcpy(temp, str[i]);
+ strcpy(str[i], str[j]);
+ strcpy(str[j], temp);
+ }
+ }
+
+ printf("\nIn lexicographical order: \n");
+ for(i=0; i<10; ++i)
+ {
+ puts(str[i]);
+ }
+
+ return 0;
+}
diff --git a/app/src/main/assets/00000035.txt b/app/src/main/assets/00000035.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2816a37431a9a9fd8080cb8aa38b4ca3b3a3b9fc
--- /dev/null
+++ b/app/src/main/assets/00000035.txt
@@ -0,0 +1,34 @@
+#include<iostream.h>
+#include<conio.h>
+void main()
+{
+ int a,b,c;
+ float d;
+ clrscr();
+ cout<<"Enter the value of a:";
+ cin>>a;
+ cout<<"Enter the value of b:";
+ cin>>b;
+ cout<<"Enter the value of c:";
+ cin>>c;
+
+ try
+ {
+ if((a-b)!=0)
+ {
+ d=c/(a-b);
+ cout<<"Result is:"<<d;
+ }
+ else
+ {
+ throw(a-b);
+ }
+ }
+
+ catch(int i)
+ {
+ cout<<"Answer is infinite because a-b is:"<<i;
+ }
+
+ getch();
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000036.txt b/app/src/main/assets/00000036.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1b1c615be3f8fc725c591d5135905b26d624a49e
--- /dev/null
+++ b/app/src/main/assets/00000036.txt
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include<stdlib.h>
+
+struct course
+{
+ int marks;
+ char subject[30];
+};
+
+int main()
+{
+ struct course *ptr;
+ int i, noOfRecords;
+ printf("Enter number of records: ");
+ scanf("%d", &noOfRecords);
+
+ // Allocates the memory for noOfRecords structures with pointer ptr pointing to the base address.
+ ptr = (struct course*) malloc (noOfRecords * sizeof(struct course));
+
+ for(i = 0; i < noOfRecords; ++i)
+ {
+ printf("Enter name of the subject and marks respectively:\n");
+ scanf("%s %d", &(ptr+i)->subject, &(ptr+i)->marks);
+ }
+
+ printf("Displaying Information:\n");
+
+ for(i = 0; i < noOfRecords ; ++i)
+ printf("%s\t%d\n", (ptr+i)->subject, (ptr+i)->marks);
+
+ return 0;
+}
diff --git a/app/src/main/assets/00000037.txt b/app/src/main/assets/00000037.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0d0a9ac5997ba2509b562f9656a55fa7b1af4104
--- /dev/null
+++ b/app/src/main/assets/00000037.txt
@@ -0,0 +1,26 @@
+#include<stdio.h>
+#define ACCURACY 0.0001
+
+int main() {
+ int n, count;
+ float x, term, sum;
+
+ printf("\nEnter value of x :");
+ scanf("%f", &x);
+
+ n = term = sum = count = 1;
+
+ while (n <= 100) {
+ term = term * x / n;
+ sum = sum + term;
+ count = count + 1;
+
+ if (term < ACCURACY)
+ n = 999;
+ else
+ n = n + 1;
+ }
+
+ printf("\nTerms = %d Sum = %f", count, sum);
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000038.txt b/app/src/main/assets/00000038.txt
new file mode 100644
index 0000000000000000000000000000000000000000..51d5d5608d05cb78f1d121aaea195e6ed4d1d1c6
--- /dev/null
+++ b/app/src/main/assets/00000038.txt
@@ -0,0 +1,27 @@
+#include<iostream>
+#include<conio.h>
+
+using namespace std;
+
+int main()
+{
+
+� � �// Variable Declaration
+� � �int counter, n, fact = 1;
+
+� � �// Get Input Value
+� � �cout<<"Enter the Number :";
+� � �cin>>n;
+
+� � �//for Loop Block
+� � �for (int counter = 1; counter <= n; counter++)
+� � �{
+� � � � �fact = fact * counter;
+� � �}
+
+� � �cout<<n<<" Factorial Value Is "<<fact;
+� � �// Wait For Output Screen
+� � �getch();
+� � �return 0;
+�}
+
diff --git a/app/src/main/assets/00000039.txt b/app/src/main/assets/00000039.txt
new file mode 100644
index 0000000000000000000000000000000000000000..16c75ee6e38bd2a50c4f12064f4bb68b1b9bd385
--- /dev/null
+++ b/app/src/main/assets/00000039.txt
@@ -0,0 +1,28 @@
+#include<iostream>
+#include<conio.h>
+
+using namespace std;
+
+int main()
+{
+
+ // Variable Declaration
+ int counter, n;
+ long last=1,next=0,sum;
+ // Get Input Value
+ cout<<"Enter the Number :";
+ cin>>n;
+
+ //Fibonacci Series Calculation
+ while(next<n/2)
+ {
+ cout<<last <<" ";
+ sum=next+last;
+ next=last;
+ last=sum;
+ }
+
+ // Wait For Output Screen
+ getch();
+ return 0;
+ }
\ No newline at end of file
diff --git a/app/src/main/assets/00000040.txt b/app/src/main/assets/00000040.txt
new file mode 100644
index 0000000000000000000000000000000000000000..772bee54f3d6bde5db7a46eb4e95ce1fa536f691
--- /dev/null
+++ b/app/src/main/assets/00000040.txt
@@ -0,0 +1,21 @@
+#include<stdio.h>
+
+int main() {
+
+ int i, j, k = 1;
+ int range;
+
+ printf("Enter the range: ");
+ scanf("%d", &range);
+
+ printf("\nFLOYD'S TRIANGLE : \n");
+
+ for (i = 1; i <= range; i++) {
+ for (j = 1; j <= i; j++, k++) {
+ printf("%d", k);
+ }
+ printf("\n");
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000041.txt b/app/src/main/assets/00000041.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8cf1bca7a0a8a0c182a80fbb8e12760573808ab0
--- /dev/null
+++ b/app/src/main/assets/00000041.txt
@@ -0,0 +1,19 @@
+#include <stdio.h>
+int main()
+{
+ int n1, n2, i, gcd;
+
+ printf("Enter two integers: ");
+ scanf("%d %d", &n1, &n2);
+
+ for(i=1; i <= n1 && i <= n2; ++i)
+ {
+ // Checks if i is factor of both integers
+ if(n1%i==0 && n2%i==0)
+ gcd = i;
+ }
+
+ printf("G.C.D of %d and %d is %d", n1, n2, gcd);
+
+ return 0;
+}s
\ No newline at end of file
diff --git a/app/src/main/assets/00000042.txt b/app/src/main/assets/00000042.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bda9518015b354a6e4e8365791f6b30110c36188
--- /dev/null
+++ b/app/src/main/assets/00000042.txt
@@ -0,0 +1,60 @@
+#include<stdio.h>
+void heapsort(int[],int);
+void heapify(int[],int);
+void adjust(int[],int);
+main() {
+ int n,i,a[50];
+ system("clear");
+ printf("\nEnter the limit:");
+ scanf("%d",&n);
+ printf("\nEnter the elements:");
+ for (i=0;i<n;i++)
+ scanf("%d",&a[i]);
+ heapsort(a,n);
+ printf("\nThe Sorted Elements Are:\n");
+ for (i=0;i<n;i++)
+ printf("\t%d",a[i]);
+ printf("\n");
+}
+void heapsort(int a[],int n) {
+ int i,t;
+ heapify(a,n);
+ for (i=n-1;i>0;i--) {
+ t = a[0];
+ a[0] = a[i];
+ a[i] = t;
+ adjust(a,i);
+ }
+}
+void heapify(int a[],int n) {
+ int k,i,j,item;
+ for (k=1;k<n;k++) {
+ item = a[k];
+ i = k;
+ j = (i-1)/2;
+ while((i>0)&&(item>a[j])) {
+ a[i] = a[j];
+ i = j;
+ j = (i-1)/2;
+ }
+ a[i] = item;
+ }
+}
+void adjust(int a[],int n) {
+ int i,j,item;
+ j = 0;
+ item = a[j];
+ i = 2*j+1;
+ while(i<=n-1) {
+ if(i+1 <= n-1)
+ if(a[i] <a[i+1])
+ i++;
+ if(item<a[i]) {
+ a[j] = a[i];
+ j = i;
+ i = 2*j+1;
+ } else
+ break;
+ }
+ a[j] = item;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000044.txt b/app/src/main/assets/00000044.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a1e4aa3c3b379cc29e9a9a1d478730f7c69db264
--- /dev/null
+++ b/app/src/main/assets/00000044.txt
@@ -0,0 +1,25 @@
+#include<stdio.h>
+#include<conio.h>
+void inst_sort(int []);
+void main() {
+ int num[5],count;
+ clrscr();
+ printf("\nEnter the Five Elements to sort:\n");
+ for (count=0;count<5;count++)
+ scanf("%d",&num[count]);
+ inst_sort(num);
+ printf("\n\nElements after sorting: \n");
+ for (count=0;count<5;count++)
+ printf("%d\n",num[count]);
+ getch();
+}
+// Function for Insertion Sorting
+void inst_sort(int num[]) {
+ int i,j,k;
+ for (j=1;j<5;j++) {
+ k=num[j];
+ for (i=j-1;i>=0 && k<num[i];i--)
+ num[i+1]=num[i];
+ num[i+1]=k;
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000045.txt b/app/src/main/assets/00000045.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8ff57de32458e04ecff14ab8c2d4fe5fa5fe54d6
--- /dev/null
+++ b/app/src/main/assets/00000045.txt
@@ -0,0 +1,55 @@
+#include<stdio.h>
+
+// a 3 i i
+void reduction(float a[][6], int size, int pivot, int col) {
+ int i, j;
+ float factor;
+ factor = a[pivot][col];
+
+ for (i = 0; i < 2 * size; i++) {
+ a[pivot][i] /= factor;
+ }
+
+ for (i = 0; i < size; i++) {
+ if (i != pivot) {
+ factor = a[i][col];
+ for (j = 0; j < 2 * size; j++) {
+ a[i][j] = a[i][j] - a[pivot][j] * factor;
+ }
+ }
+ }
+}
+
+void main() {
+ float matrix[3][6];
+ int i, j;
+
+ for (i = 0; i < 3; i++) {
+ for (j = 0; j < 6; j++) {
+ if (j == i + 3) {
+ matrix[i][j] = 1;
+ } else {
+ matrix[i][j] = 0;
+ }
+ }
+ }
+
+ printf("\nEnter a 3 X 3 Matrix :");
+ for (i = 0; i < 3; i++) {
+ for (j = 0; j < 3; j++) {
+ scanf("%f", &matrix[i][j]);
+ }
+ }
+
+ for (i = 0; i < 3; i++) {
+ reduction(matrix, 3, i, i);
+ }
+
+ printf("\nInvers Matrix");
+ for (i = 0; i < 3; i++) {
+ printf("\n");
+ for (j = 0; j < 3; j++) {
+ printf("%8.3f", matrix[i][j + 3]);
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000046.txt b/app/src/main/assets/00000046.txt
new file mode 100644
index 0000000000000000000000000000000000000000..679b48d4a84740f2c63fcd4143e3c4004790ffac
--- /dev/null
+++ b/app/src/main/assets/00000046.txt
@@ -0,0 +1,74 @@
+# include<stdio.h>
+
+void knapsack(int n, float weight[], float profit[], float capacity) {
+ float x[20], tp = 0;
+ int i, j, u;
+ u = capacity;
+
+ for (i = 0; i < n; i++)
+ x[i] = 0.0;
+
+ for (i = 0; i < n; i++) {
+ if (weight[i] > u)
+ break;
+ else {
+ x[i] = 1.0;
+ tp = tp + profit[i];
+ u = u - weight[i];
+ }
+ }
+
+ if (i < n)
+ x[i] = u / weight[i];
+
+ tp = tp + (x[i] * profit[i]);
+
+ printf("\nThe result vector is:- ");
+ for (i = 0; i < n; i++)
+ printf("%f\t", x[i]);
+
+ printf("\nMaximum profit is:- %f", tp);
+
+}
+
+int main() {
+ float weight[20], profit[20], capacity;
+ int num, i, j;
+ float ratio[20], temp;
+
+ printf("\nEnter the no. of objects:- ");
+ scanf("%d", &num);
+
+ printf("\nEnter the wts and profits of each object:- ");
+ for (i = 0; i < num; i++) {
+ scanf("%f %f", &weight[i], &profit[i]);
+ }
+
+ printf("\nEnter the capacityacity of knapsack:- ");
+ scanf("%f", &capacity);
+
+ for (i = 0; i < num; i++) {
+ ratio[i] = profit[i] / weight[i];
+ }
+
+ for (i = 0; i < num; i++) {
+ for (j = i + 1; j < num; j++) {
+ if (ratio[i] < ratio[j]) {
+ temp = ratio[j];
+ ratio[j] = ratio[i];
+ ratio[i] = temp;
+
+ temp = weight[j];
+ weight[j] = weight[i];
+ weight[i] = temp;
+
+ temp = profit[j];
+ profit[j] = profit[i];
+ profit[i] = temp;
+ }
+ }
+ }
+
+ knapsack(num, weight, profit, capacity);
+ return(0);
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000047.txt b/app/src/main/assets/00000047.txt
new file mode 100644
index 0000000000000000000000000000000000000000..de9ee6f0234bbba3b4a0ba172b505b3de79c6306
--- /dev/null
+++ b/app/src/main/assets/00000047.txt
@@ -0,0 +1,22 @@
+#include <stdio.h>
+int main()
+{
+ int n1, n2, minMultiple;
+ printf("Enter two positive integers: ");
+ scanf("%d %d", &n1, &n2);
+
+ // maximum number between n1 and n2 is stored in minMultiple
+ minMultiple = (n1>n2) ? n1 : n2;
+
+ // Always true
+ while(1)
+ {
+ if( minMultiple%n1==0 && minMultiple%n2==0 )
+ {
+ printf("The LCM of %d and %d is %d.", n1, n2,minMultiple);
+ break;
+ }
+ ++minMultiple;
+ }
+ return 0;
+}
diff --git a/app/src/main/assets/00000048.txt b/app/src/main/assets/00000048.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31453c4223322419c0af829dabb28a231add4868
--- /dev/null
+++ b/app/src/main/assets/00000048.txt
@@ -0,0 +1,68 @@
+#include<stdio.h>
+#include<conio.h>
+
+int main() {
+ int size = 3;
+ int matrix[3][3]; // = {{4,9,2},{3,5,7},{8,1,6}};
+ int row, column = 0;
+ int sum, sum1, sum2;
+ int flag = 0;
+
+ printf("\nEnter matrix : ");
+ for (row = 0; row < size; row++) {
+ for (column = 0; column < size; column++)
+ scanf("%d", &matrix[row][column]);
+ }
+
+ printf("Entered matrix is : \n");
+ for (row = 0; row < size; row++) {
+ printf("\n");
+ for (column = 0; column < size; column++) {
+ printf("\t%d", matrix[row][column]);
+ }
+ }
+
+ //For diagonal elements
+ sum = 0;
+ for (row = 0; row < size; row++) {
+ for (column = 0; column < size; column++) {
+ if (row == column)
+ sum = sum + matrix[row][column];
+ }
+ }
+
+ //For Rows
+ for (row = 0; row < size; row++) {
+ sum1 = 0;
+ for (column = 0; column < size; column++) {
+ sum1 = sum1 + matrix[row][column];
+ }
+ if (sum == sum1)
+ flag = 1;
+ else {
+ flag = 0;
+ break;
+ }
+ }
+
+ //For Columns
+ for (row = 0; row < size; row++) {
+ sum2 = 0;
+ for (column = 0; column < size; column++) {
+ sum2 = sum2 + matrix[column][row];
+ }
+ if (sum == sum2)
+ flag = 1;
+ else {
+ flag = 0;
+ break;
+ }
+ }
+
+ if (flag == 1)
+ printf("\nMagic square");
+ else
+ printf("\nNo Magic square");
+
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000049.txt b/app/src/main/assets/00000049.txt
new file mode 100644
index 0000000000000000000000000000000000000000..17a95fc214e2c8797093aba69e60169617e173d4
--- /dev/null
+++ b/app/src/main/assets/00000049.txt
@@ -0,0 +1,67 @@
+#include <stdio.h>
+
+int main()
+{
+ int a[10][10], b[10][10], result[10][10], r1, c1, r2, c2, i, j, k;
+
+ printf("Enter rows and column for first matrix: ");
+ scanf("%d %d", &r1, &c1);
+
+ printf("Enter rows and column for second matrix: ");
+ scanf("%d %d",&r2, &c2);
+
+ // Column of first matrix should be equal to column of second matrix and
+ while (c1 != r2)
+ {
+ printf("Error! column of first matrix not equal to row of second.\n\n");
+ printf("Enter rows and column for first matrix: ");
+ scanf("%d %d", &r1, &c1);
+ printf("Enter rows and column for second matrix: ");
+ scanf("%d %d",&r2, &c2);
+ }
+
+ // Storing elements of first matrix.
+ printf("\nEnter elements of matrix 1:\n");
+ for(i=0; i<r1; ++i)
+ for(j=0; j<c1; ++j)
+ {
+ printf("Enter elements a%d%d: ",i+1, j+1);
+ scanf("%d", &a[i][j]);
+ }
+
+ // Storing elements of second matrix.
+ printf("\nEnter elements of matrix 2:\n");
+ for(i=0; i<r2; ++i)
+ for(j=0; j<c2; ++j)
+ {
+ printf("Enter elements b%d%d: ",i+1, j+1);
+ scanf("%d",&b[i][j]);
+ }
+
+ // Initializing all elements of result matrix to 0
+ for(i=0; i<r1; ++i)
+ for(j=0; j<c2; ++j)
+ {
+ result[i][j] = 0;
+ }
+
+ // Multiplying matrices a and b and
+ // storing result in result matrix
+ for(i=0; i<r1; ++i)
+ for(j=0; j<c2; ++j)
+ for(k=0; k<c1; ++k)
+ {
+ result[i][j]+=a[i][k]*b[k][j];
+ }
+
+ // Displaying the result
+ printf("\nOutput Matrix:\n");
+ for(i=0; i<r1; ++i)
+ for(j=0; j<c2; ++j)
+ {
+ printf("%d ", result[i][j]);
+ if(j == c2-1)
+ printf("\n\n");
+ }
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000050.txt b/app/src/main/assets/00000050.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d0c06b0e92f1045d30bd925af37de879f1b3a1cd
--- /dev/null
+++ b/app/src/main/assets/00000050.txt
@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <stdlib.h>
+#define MAX_ARY 10
+void merge_sort(int x[], int end, int start);
+int main(void) {
+ int ary[MAX_ARY];
+ int j = 0;
+ printf("\n\nEnter the elements to be sorted: \n");
+ for (j=0;j<MAX_ARY;j++)
+ scanf("%d",&ary[j]);
+ /* array before mergesort */
+ printf("Before :");
+ for (j = 0; j < MAX_ARY; j++)
+ printf(" %d", ary[j]);
+ printf("\n");
+ merge_sort(ary, 0, MAX_ARY - 1);
+ /* array after mergesort */
+ printf("After Merge Sort :");
+ for (j = 0; j < MAX_ARY; j++)
+ printf(" %d", ary[j]);
+ printf("\n");
+ getch();
+}
+/* Method to implement Merge Sort*/
+void merge_sort(int x[], int end, int start) {
+ int j = 0;
+ const int size = start - end + 1;
+ int mid = 0;
+ int mrg1 = 0;
+ int mrg2 = 0;
+ int executing[MAX_ARY];
+ if(end == start)
+ return;
+ mid = (end + start) / 2;
+ merge_sort(x, end, mid);
+ merge_sort(x, mid + 1, start);
+ for (j = 0; j < size; j++)
+ executing[j] = x[end + j];
+ mrg1 = 0;
+ mrg2 = mid - end + 1;
+ for (j = 0; j < size; j++) {
+ if(mrg2 <= start - end)
+ if(mrg1 <= mid - end)
+ if(executing[mrg1] > executing[mrg2])
+ x[j + end] = executing[mrg2++]; else
+ x[j + end] = executing[mrg1++]; else
+ x[j + end] = executing[mrg2++]; else
+ x[j + end] = executing[mrg1++];
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000051.txt b/app/src/main/assets/00000051.txt
new file mode 100644
index 0000000000000000000000000000000000000000..725a8154e1560591f6811064da4b87fca4dcf77c
--- /dev/null
+++ b/app/src/main/assets/00000051.txt
@@ -0,0 +1,30 @@
+#include <stdio.h>
+int main()
+{
+ int low, high, i, flag;
+ printf("Enter two numbers(intervals): ");
+ scanf("%d %d", &low, &high);
+
+ printf("Prime numbers between %d and %d are: ", low, high);
+
+ while (low < high)
+ {
+ flag = 0;
+
+ for(i = 2; i <= low/2; ++i)
+ {
+ if(low % i == 0)
+ {
+ flag = 1;
+ break;
+ }
+ }
+
+ if (flag == 0)
+ printf("%d ", low);
+
+ ++low;
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000052.txt b/app/src/main/assets/00000052.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41d140fa346c3638efc651195847087d2ca795a5
--- /dev/null
+++ b/app/src/main/assets/00000052.txt
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <math.h>
+
+int convertDecimalToOctal(int decimalNumber);
+int main()
+{
+ int decimalNumber;
+
+ printf("Enter a decimal number: ");
+ scanf("%d", &decimalNumber);
+
+ printf("%d in decimal = %d in octal", decimalNumber, convertDecimalToOctal(decimalNumber));
+
+ return 0;
+}
+
+int convertDecimalToOctal(int decimalNumber)
+{
+ int octalNumber = 0, i = 1;
+
+ while (decimalNumber != 0)
+ {
+ octalNumber += (decimalNumber % 8) * i;
+ decimalNumber /= 8;
+ i *= 10;
+ }
+
+ return octalNumber;
+}
diff --git a/app/src/main/assets/00000053.txt b/app/src/main/assets/00000053.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c381b55912a84303ffa3702390fa8dbc5bd02d1b
--- /dev/null
+++ b/app/src/main/assets/00000053.txt
@@ -0,0 +1,100 @@
+#include<stdio.h>
+#include<conio.h>
+
+int n, cost[10][10];
+
+void prim() {
+ int i, j, startVertex, endVertex;
+ int k, nr[10], temp, minimumCost = 0, tree[10][3];
+
+ /* For first smallest edge */
+ temp = cost[0][0];
+ for (i = 0; i < n; i++) {
+ for (j = 0; j < n; j++) {
+ if (temp > cost[i][j]) {
+ temp = cost[i][j];
+ startVertex = i;
+ endVertex = j;
+ }
+ }
+ }
+ /* Now we have fist smallest edge in graph */
+ tree[0][0] = startVertex;
+ tree[0][1] = endVertex;
+ tree[0][2] = temp;
+ minimumCost = temp;
+
+ /* Now we have to find min dis of each vertex from either
+ startVertex or endVertex by initialising nr[] array
+ */
+
+ for (i = 0; i < n; i++) {
+ if (cost[i][startVertex] < cost[i][endVertex])
+ nr[i] = startVertex;
+ else
+ nr[i] = endVertex;
+ }
+
+ /* To indicate visited vertex initialise nr[] for them to 100 */
+ nr[startVertex] = 100;
+ nr[endVertex] = 100;
+
+ /* Now find out remaining n-2 edges */
+ temp = 99;
+ for (i = 1; i < n - 1; i++) {
+ for (j = 0; j < n; j++) {
+ if (nr[j] != 100 && cost[j][nr[j]] < temp) {
+ temp = cost[j][nr[j]];
+ k = j;
+ }
+ }
+ /* Now i have got next vertex */
+ tree[i][0] = k;
+ tree[i][1] = nr[k];
+ tree[i][2] = cost[k][nr[k]];
+ minimumCost = minimumCost + cost[k][nr[k]];
+ nr[k] = 100;
+
+ /* Now find if k is nearest to any vertex
+ than its previous near value */
+
+ for (j = 0; j < n; j++) {
+ if (nr[j] != 100 && cost[j][nr[j]] > cost[j][k])
+ nr[j] = k;
+ }
+ temp = 99;
+ }
+ /* Now i have the answer, just going to print it */
+ printf("\nThe min spanning tree is:- ");
+ for (i = 0; i < n - 1; i++) {
+ for (j = 0; j < 3; j++)
+ printf("%d", tree[i][j]);
+ printf("\n");
+ }
+
+ printf("\nMin cost : %d", minimumCost);
+}
+
+void main() {
+ int i, j;
+ clrscr();
+
+ printf("\nEnter the no. of vertices :");
+ scanf("%d", &n);
+
+ printf("\nEnter the costs of edges in matrix form :");
+ for (i = 0; i < n; i++)
+ for (j = 0; j < n; j++) {
+ scanf("%d", &cost[i][j]);
+ }
+
+ printf("\nThe matrix is : ");
+ for (i = 0; i < n; i++) {
+ for (j = 0; j < n; j++) {
+ printf("%d\t", cost[i][j]);
+ }
+ printf("\n");
+ }
+ prim();
+ getch();
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000054.txt b/app/src/main/assets/00000054.txt
new file mode 100644
index 0000000000000000000000000000000000000000..42a43b44acbd6fa411f59d4cf701dc180712aec0
--- /dev/null
+++ b/app/src/main/assets/00000054.txt
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#define MAX 100
+#define SHOWPASS
+void print(int *a, int n) {
+ int i;
+ for (i = 0; i < n; i++)
+ printf("%d\t", a[i]);
+}
+void radix_sort(int *a, int n) {
+ int i, b[MAX], m = 0, exp = 1;
+ for (i = 0; i < n; i++) {
+ if (a[i] > m)
+ m = a[i];
+ }
+ while (m / exp > 0) {
+ int box[10] = {
+ 0
+ }
+ ;
+ for (i = 0; i < n; i++)
+ box[a[i] / exp % 10]++;
+ for (i = 1; i < 10; i++)
+ box[i] += box[i - 1];
+ for (i = n - 1; i >= 0; i--)
+ b[--box[a[i] / exp % 10]] = a[i];
+ for (i = 0; i < n; i++)
+ a[i] = b[i];
+ exp *= 10;
+ #ifdef SHOWPASS
+ printf("\n\nPASS : ");
+ print(a, n);
+ #endif
+ }
+}
+int main() {
+ int arr[MAX];
+ int i, num;
+ printf("\nEnter total elements (num < %d) : ", MAX);
+ scanf("%d", &num);
+ printf("\nEnter %d Elements : ", num);
+ for (i = 0; i < num; i++)
+ scanf("%d", &arr[i]);
+ printf("\nARRAY : ");
+ print(&arr[0], num);
+ radix_sort(&arr[0], num);
+ printf("\n\nSORTED : ");
+ print(&arr[0], num);
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000055.txt b/app/src/main/assets/00000055.txt
new file mode 100644
index 0000000000000000000000000000000000000000..64b9efa5f43a5c7ab1bf1bfc39bbe5f138b3977d
--- /dev/null
+++ b/app/src/main/assets/00000055.txt
@@ -0,0 +1,22 @@
+#include <stdio.h>
+void reverseSentence();
+
+int main()
+{
+ printf("Enter a sentence: ");
+ reverseSentence();
+
+ return 0;
+}
+
+void reverseSentence()
+{
+ char c;
+ scanf("%c", &c);
+
+ if( c != '\n')
+ {
+ reverseSentence();
+ printf("%c",c);
+ }
+}
diff --git a/app/src/main/assets/00000056.txt b/app/src/main/assets/00000056.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a4199de9fc2218e23b24ac195eb7e0e736d302f3
--- /dev/null
+++ b/app/src/main/assets/00000056.txt
@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <math.h>
+
+int main()
+{
+ double a, b, c, determinant, root1,root2, realPart, imaginaryPart;
+
+ printf("Enter coefficients a, b and c: ");
+ scanf("%lf %lf %lf",&a, &b, &c);
+
+ determinant = b*b-4*a*c;
+
+ // condition for real and different roots
+ if (determinant > 0)
+ {
+ // sqrt() function returns square root
+ root1 = (-b+sqrt(determinant))/(2*a);
+ root2 = (-b-sqrt(determinant))/(2*a);
+
+ printf("root1 = %.2lf and root2 = %.2lf",root1 , root2);
+ }
+
+ //condition for real and equal roots
+ else if (determinant == 0)
+ {
+ root1 = root2 = -b/(2*a);
+
+ printf("root1 = root2 = %.2lf;", root1);
+ }
+
+ // if roots are not real
+ else
+ {
+ realPart = -b/(2*a);
+ imaginaryPart = sqrt(-determinant)/(2*a);
+ printf("root1 = %.2lf+%.2lfi and root2 = %.2f-%.2fi", realPart, imaginaryPart, realPart, imaginaryPart);
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000057.txt b/app/src/main/assets/00000057.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afbdc66ee729d91d2493c28adc32484cb97ac4ad
--- /dev/null
+++ b/app/src/main/assets/00000057.txt
@@ -0,0 +1,243 @@
+#include<stdio.h>
+
+#include<conio.h>
+
+#include<stdlib.h>
+
+#include<math.h>
+
+#include<string.h>
+
+long int p,q,n,t,flag,e[100],d[100],temp[100],j,m[100],en[100],i;
+
+char msg[100];
+
+int prime(long int);
+
+void ce();
+
+long int cd(long int);
+
+void encrypt();
+
+void decrypt();
+
+void main() {
+
+ clrscr();
+
+ printf("\nENTER FIRST PRIME NUMBER\n");
+
+ scanf("%d",&p);
+
+ flag=prime(p);
+
+ if(flag==0) {
+
+ printf("\nWRONG INPUT\n");
+
+ getch();
+
+ exit(1);
+
+ }
+
+ printf("\nENTER ANOTHER PRIME NUMBER\n");
+
+ scanf("%d",&q);
+
+ flag=prime(q);
+
+ if(flag==0||p==q) {
+
+ printf("\nWRONG INPUT\n");
+
+ getch();
+
+ exit(1);
+
+ }
+
+ printf("\nENTER MESSAGE\n");
+
+ fflush(stdin);
+
+ scanf("%s",msg);
+
+ for (i=0;msg[i]!=NULL;i++)
+
+ m[i]=msg[i];
+
+ n=p*q;
+
+ t=(p-1)*(q-1);
+
+ ce();
+
+ printf("\nPOSSIBLE VALUES OF e AND d ARE\n");
+
+ for (i=0;i<j-1;i++)
+
+ printf("\n%ld\t%ld",e[i],d[i]);
+
+ encrypt();
+
+ decrypt();
+
+ getch();
+
+}
+
+int prime(long int pr) {
+
+ int i;
+
+ j=sqrt(pr);
+
+ for (i=2;i<=j;i++) {
+
+ if(pr%i==0)
+
+ return 0;
+
+ }
+
+ return 1;
+
+}
+
+void ce() {
+
+ int k;
+
+ k=0;
+
+ for (i=2;i<t;i++) {
+
+ if(t%i==0)
+
+ continue;
+
+ flag=prime(i);
+
+ if(flag==1&&i!=p&&i!=q) {
+
+ e[k]=i;
+
+ flag=cd(e[k]);
+
+ if(flag>0) {
+
+ d[k]=flag;
+
+ k++;
+
+ }
+
+ if(k==99)
+
+ break;
+
+ }
+
+ }
+
+}
+
+long int cd(long int x) {
+
+ long int k=1;
+
+ while(1) {
+
+ k=k+t;
+
+ if(k%x==0)
+
+ return(k/x);
+
+ }
+
+}
+
+void encrypt() {
+
+ long int pt,ct,key=e[0],k,len;
+
+ i=0;
+
+ len=strlen(msg);
+
+ while(i!=len) {
+
+ pt=m[i];
+
+ pt=pt-96;
+
+ k=1;
+
+ for (j=0;j<key;j++) {
+
+ k=k*pt;
+
+ k=k%n;
+
+ }
+
+ temp[i]=k;
+
+ ct=k+96;
+
+ en[i]=ct;
+
+ i++;
+
+ }
+
+ en[i]=-1;
+
+ printf("\nTHE ENCRYPTED MESSAGE IS\n");
+
+ for (i=0;en[i]!=-1;i++)
+
+ printf("%c",en[i]);
+
+}
+
+void decrypt() {
+
+ long int pt,ct,key=d[0],k;
+
+ i=0;
+
+ while(en[i]!=-1) {
+
+ ct=temp[i];
+
+ k=1;
+
+ for (j=0;j<key;j++) {
+
+ k=k*ct;
+
+ k=k%n;
+
+ }
+
+ pt=k+96;
+
+ m[i]=pt;
+
+ i++;
+
+ }
+
+ m[i]=-1;
+
+ printf("\nTHE DECRYPTED MESSAGE IS\n");
+
+ for (i=0;m[i]!=-1;i++)
+
+ printf("%c",m[i]);
+
+}
diff --git a/app/src/main/assets/00000058.txt b/app/src/main/assets/00000058.txt
new file mode 100644
index 0000000000000000000000000000000000000000..170f98522eb60dec587edcd1b4c9e355adcfa2aa
--- /dev/null
+++ b/app/src/main/assets/00000058.txt
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <conio.h>
+main()
+{
+ int arr[]={12,23,78,98,67,56,45,19,65,9},key,i,flag=0;
+ clrscr();
+ printf("\nENTER A NUMBER: ");
+ scanf("%d",&key);
+ for(i=0;i<10;i++)
+ {
+ if(key==arr[i])
+ flag=1;
+ }
+ if(flag==1)
+ printf("\nTHE NUMBER %d EXISTS IN THE ARRAY",key);
+ else
+printf("\nTHE NUMBER %d DOES NOT EXIST IN THE ARRAY",key);
+ getch();
+}
diff --git a/app/src/main/assets/00000059.txt b/app/src/main/assets/00000059.txt
new file mode 100644
index 0000000000000000000000000000000000000000..81445926884f9f490fac4346911e4ee76efc772c
--- /dev/null
+++ b/app/src/main/assets/00000059.txt
@@ -0,0 +1,115 @@
+#include<stdio.h>
+#include<conio.h>
+#include<process.h>
+#include<stdlib.h>
+#include<alloc.h>
+
+void Push(int, node **);
+void Display(node **);
+int Pop(node **);
+int Sempty(node *);
+
+typedef struct stack {
+ int data;
+ struct stack *next;
+} node;
+
+
+void main() {
+ node *top;
+ int data, item, choice;
+ char ans, ch;
+
+ clrscr();
+
+ top = NULL;
+
+ printf("\nStack Using Linked List : nn");
+ do {
+ printf("\n\n The main menu");
+ printf("\n1.Push \n2.Pop \n3.Display \n4.Exit");
+ printf("\n Enter Your Choice");
+ scanf("%d", &choice);
+
+ switch (choice) {
+ case 1:
+ printf("\nEnter the data");
+ scanf("%d", &data);
+ Push(data, &top);
+ break;
+ case 2:
+ if (Sempty(top))
+ printf("\nStack underflow!");
+ else {
+ item = Pop(&top);
+ printf("\nThe popped node is%d", item);
+ }
+ break;
+ case 3:
+ Display(&top);
+ break;
+ case 4:
+ printf("\nDo You want To Quit?(y/n)");
+ ch = getche();
+ if (ch == 'y')
+ exit(0);
+ else
+ break;
+ }
+
+ printf("\nDo you want to continue?");
+ ans = getche();
+ getch();
+ clrscr();
+ } while (ans == 'Y' || ans == 'y');
+ getch();
+}
+
+void Push(int Item, node **top) {
+ node *New;
+ node * get_node(int);
+ New = get_node(Item);
+ New->next = *top;
+ *top = New;
+}
+
+node * get_node(int item) {
+ node * temp;
+ temp = (node *) malloc(sizeof(node));
+ if (temp == NULL)
+ printf("\nMemory Cannot be allocated");
+ temp->data = item;
+ temp->next = NULL;
+ return (temp);
+}
+
+int Sempty(node *temp) {
+ if (temp == NULL)
+ return 1;
+ else
+ return 0;
+}
+
+int Pop(node **top) {
+ int item;
+ node *temp;
+ item = (*top)->data;
+ temp = *top;
+ *top = (*top)->next;
+ free(temp);
+ return (item);
+}
+
+void Display(node **head) {
+ node *temp;
+ temp = *head;
+ if (Sempty(temp))
+ printf("\nThe stack is empty!");
+ else {
+ while (temp != NULL) {
+ printf("%d\n", temp->data);
+ temp = temp->next;
+ }
+ }
+ getch();
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000060.txt b/app/src/main/assets/00000060.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fd0aadf67cfa01bb11fe484744969cf4abf12de2
--- /dev/null
+++ b/app/src/main/assets/00000060.txt
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <math.h>
+
+float calculateSD(float data[]);
+
+int main()
+{
+ int i;
+ float data[10];
+
+ printf("Enter 10 elements: ");
+ for(i=0; i < 10; ++i)
+ scanf("%f", &data[i]);
+
+ printf("\nStandard Deviation = %.6f", calculateSD(data));
+
+ return 0;
+}
+
+float calculateSD(float data[])
+{
+ float sum = 0.0, mean, standardDeviation = 0.0;
+
+ int i;
+
+ for(i=0; i<10; ++i)
+ {
+ sum += data[i];
+ }
+
+ mean = sum/10;
+
+ for(i=0; i<10; ++i)
+ standardDeviation += pow(data[i] - mean, 2);
+
+ return sqrt(standardDeviation/10);
+}
\ No newline at end of file
diff --git a/app/src/main/assets/00000061.txt b/app/src/main/assets/00000061.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fd5abed706f947b253c7c92d807683a9dd6f49cd
--- /dev/null
+++ b/app/src/main/assets/00000061.txt
@@ -0,0 +1,20 @@
+#include<stdio.h>
+
+void TOH(int num, char x, char y, char z);
+
+int main() {
+ int num;
+ printf("\nEnter number of plates:");
+ scanf("%d", &num);
+
+ TOH(num - 1, 'A', 'B', 'C');
+ return (0);
+}
+
+void TOH(int num, char x, char y, char z) {
+ if (num > 0) {
+ TOH(num - 1, x, z, y);
+ printf("\n%c -> %c", x, y);
+ TOH(num - 1, z, y, x);
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/assets/0000062.txt b/app/src/main/assets/0000062.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c9ec6a4151fe12ba3d8f2e9dbd992460e8f4af37
--- /dev/null
+++ b/app/src/main/assets/0000062.txt
@@ -0,0 +1,46 @@
+#include <stdio.h>
+
+int main()
+{
+ int a[10][10], transpose[10][10], r, c, i, j;
+ printf("Enter rows and columns of matrix: ");
+ scanf("%d %d", &r, &c);
+
+ // Storing elements of the matrix
+ printf("\nEnter elements of matrix:\n");
+ for(i=0; i<r; ++i)
+ for(j=0; j<c; ++j)
+ {
+ printf("Enter element a%d%d: ",i+1, j+1);
+ scanf("%d", &a[i][j]);
+ }
+
+ // Displaying the matrix a[][] */
+ printf("\nEntered Matrix: \n");
+ for(i=0; i<r; ++i)
+ for(j=0; j<c; ++j)
+ {
+ printf("%d ", a[i][j]);
+ if (j == c-1)
+ printf("\n\n");
+ }
+
+ // Finding the transpose of matrix a
+ for(i=0; i<r; ++i)
+ for(j=0; j<c; ++j)
+ {
+ transpose[j][i] = a[i][j];
+ }
+
+ // Displaying the transpose of matrix a
+ printf("\nTranspose of Matrix:\n");
+ for(i=0; i<c; ++i)
+ for(j=0; j<r; ++j)
+ {
+ printf("%d ",transpose[i][j]);
+ if(j==r-1)
+ printf("\n\n");
+ }
+
+ return 0;
+}
diff --git a/app/src/main/assets/0000063.txt b/app/src/main/assets/0000063.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ea744b1b72ea293c111606b7f8c02291828fa7b0
--- /dev/null
+++ b/app/src/main/assets/0000063.txt
@@ -0,0 +1,22 @@
+#include <stdio.h>
+int main()
+{
+ char c
+ int isLowercaseVowel, isUppercaseVowel;
+
+ printf("Enter an alphabet: ");
+ scanf("%c",&c);
+
+ // evaluates to 1 (true) if c is a lowercase vowel
+ isLowercaseVowel = (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
+
+ // evaluates to 1 (true) if c is an uppercase vowel
+ isUppercaseVowel = (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U');
+
+ // evaluates to 1 (true) if either isLowercaseVowel or isUppercaseVowel is true
+ if (isLowercaseVowel || isUppercaseVowel)
+ printf("%c is a vowel.", c);
+ else
+ printf("%c is a consonant.", c);
+ return 0;
+}
\ No newline at end of file
diff --git a/app/src/main/assets/INDEX.txt b/app/src/main/assets/INDEX.txt
index 40e2901b2f19b6fc63a802fe448ca6b2cb1a3fbc..6cf310d55e2fd7667292a73caf35854f2971be45 100644
--- a/app/src/main/assets/INDEX.txt
+++ b/app/src/main/assets/INDEX.txt
@@ -52,3 +52,77 @@ sum of digits
00000026
table of number
00000027
+armstrong number
+00000028
+binary search
+00000029
+binary to decimal
+00000030
+bubble sort
+00000031
+bucket sort
+00000032
+calender
+00000033
+dictionary sort
+00000034
+divide_by_zero
+00000035
+dynamic memory allocation
+00000036
+exponent power series
+00000037
+factorial
+00000038
+fibonacci
+00000039
+floyd's triangle
+00000040
+GCD
+00000041
+heap sort
+00000042
+insertion sort
+00000043
+inverse of a matrix
+00000044
+knapsack problem
+00000045
+LCM
+00000046
+magic square
+00000047
+matrix multiplication
+00000048
+merge sort
+00000049
+no of prime between a and b
+00000050
+octal to decimal
+00000051
+prims algorithms
+00000052
+radix sort
+00000053
+reverse a string
+00000054
+Root of a factorial
+00000055
+RSA agorithm
+00000056
+sequential search
+00000057
+singly linked list
+00000058
+standard deviation
+00000059
+tower of hanoi
+00000060
+transpose of a matrix
+00000061
+vowels_or_consonants
+00000062
+
+
+
+