rectangle of star and others

Akash Kumar/2ndlargest.c

@@ -0,0 +1,44 @@
+#include<stdio.h>
+
+int main()
+{
+ int a,b,d;
+ int c =0;
+ scanf("%d %d",&a,&b);
+
+ if(a>b)
+  {
+      c=b;
+
+  }
+ if(b>a)
+  {
+      c=a;
+      a=b;
+      b=c;
+  }
+
+ for(;;)
+  {
+      scanf("%d",&b);
+      if(b==-1)
+       {
+           printf("%d",c);
+           break;
+       }
+
+      if(b>a)
+       { 
+         c=a;
+         a=b;
+       }
+      if(b>c && b<a)
+       {
+           c =b;
+       }
+
+  }
+
+
+return 0;
+}

Akash Kumar/BinarybyRecursion.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+int binary_conversion(int);
+
+int main()
+{
+   int num, bin;
+
+   printf("Enter a decimal number: ");
+   scanf("%d", &num);
+   bin = binary_conversion(num);
+   printf("The binary equivalent of %d is %d\n", num, bin);
+}
+
+int binary_conversion(int num)
+{
+    if (num == 0)
+    {
+        return 0;
+    }
+    else
+    {
+        return (num % 2) + 10 * binary_conversion(num / 2);
+    }
+}

Akash Kumar/BinarytoOctal.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+int main()
+{
+    long int binarynum, octalnum = 0, j = 1, remainder;
+
+    printf("Enter the value for  binary number: ");
+    scanf("%ld", &binarynum);
+    while (binarynum != 0)
+    {
+        remainder = binarynum % 10;
+        octalnum = octalnum + remainder * j;
+        j = j * 2;
+        binarynum = binarynum / 10;
+    }
+    printf("Equivalent octal value: %lo", octalnum);
+    return 0;
+}

Akash Kumar/BintoHexa.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+int main()
+{
+    long int binary, hexadecimalval = 0, i = 1, remainder;
+
+    printf("Enter the binary number: ");
+    scanf("%ld", &binary);
+    while (binaryval != 0)
+    {
+        remainder = binary % 10;
+        hexadecimalval = hexadecimalval + remainder * i;
+        i = i * 2;
+        binary = binary / 10;
+    }
+    printf("Equivalent hexadecimal value: %lX", hexadecimalval);
+    return 0;
+}

Akash Kumar/CollatzFunction.c

@@ -0,0 +1,49 @@
+/* The Collatz function is defined for a positive integer n as follows.
+
+f(n) = 3n+1 if n is odd
+
+       = n/2     if n is even
+       = 1 if n=1
+
+
+We consider the repeated application of the Collatz function starting with a given integer n, as follows:
+
+f(n), f(f(n)), f(f(f(n))), …
+
+
+It is conjectured that no matter which positive integer n you start from, this sequence eventually will have 1 in it. It has been verified to hold for numbers up to 5 × 260  [Wikipedia: Collatz Conjecture]. */
+
+#include <stdio.h>
+int x =0;
+void collatz_repeat(int n)
+{
+
+	if ( n == 1 ) 
+	{
+		if(x==0)
+		printf("1");
+		else
+		return;
+
+	}
+
+	else{
+		x=1;
+		if ( n % 2 == 1 ) {
+			printf("%d ",3*n+1 );
+			collatz_repeat(3*n+1);
+		}else{
+			printf("%d ",n/2);
+		    collatz_repeat(n/2);
+		}
+	}
+}
+
+
+int main()
+{
+	int n;
+	scanf("%d",&n);
+	collatz_repeat(n); 
+	return 0;
+}

Akash Kumar/DecimaltoHexa.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+int main()
+{
+    long decimalnum, quotient, remainder;
+    int i, j = 0;
+    char hexadecimalnum[100];
+
+    printf("Enter decimal number: ");
+    scanf("%ld", &decimalnum);
+
+    quotient = decimalnum;
+
+    while (quotient != 0)
+    {
+        remainder = quotient % 16;
+        if (remainder < 10)
+            hexadecimalnum[j++] = 48 + remainder;
+        else
+            hexadecimalnum[j++] = 55 + remainder;
+        quotient = quotient / 16;
+    }
+ for (i = j; i >= 0; i--)
+            printf("%c", hexadecimalnum[i]);
+    return 0;
+}

Akash Kumar/DectoOctal.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+int main()
+{
+    long decimalnum, remainder, quotient;
+    int octalNumber[100], i = 1, j;
+
+    printf("Enter the decimal number: ");
+    scanf("%ld", &decimalnum);
+    quotient = decimalnum;
+    while (quotient != 0)
+    {
+        octalNumber[i++] = quotient % 8;
+        quotient = quotient / 8;
+    }
+    printf("Equivalent octal value of decimal no %d: ", decimalnum);
+    for (j = i - 1; j > 0; j--)
+        printf("%d", octalNumber[j]);
+    return 0;
+}

Akash Kumar/DeleteallaftercertainelementinLinkedList.c

@@ -0,0 +1,115 @@
+/*  You are given a sequence of integers terminated with a -1. The -1 is
+not part of the input sequence.
+
+
+Next, you are given a positive number N.
+
+You have to create a linked list with the input sequence of integers
+as entries. You can use the following structure.
+
+ struct node{
+ 	int data;
+	struct node *next;
+ };
+
+
+Now, you have to delete all but the last N elements from the linked
+list, and print the resulting list. (i.e. The resulting list will
+consist of only the last N elements from the list.)
+
+
+If N is longer than the length of the linked list, you must print -1.
+
+While printing, the entries of the list must be separated by a single
+space. 
+
+Sample Input
+------------
+3 4 5 6 -1
+1
+
+Sample Output
+-------------
+6 
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+struct node {
+int data;
+struct node *next;
+};
+int list_length;
+struct node* create_node ( int n )
+{
+struct node *new_node;
+new_node = (struct node *) malloc ( sizeof(struct node) );
+new_node->data = n;
+new_node->next = NULL;
+return new_node;
+}
+struct node* create_list ( struct node *head )
+{
+int number;
+struct node *current_node, *new_node;
+scanf("%d",&number);
+if(number != -1){
+head = create_node ( number );
+current_node = head;
+list_length++;
+scanf ( "%d", &number );
+while ( number != -1 ){
+new_node = create_node ( number );
+current_node->next = new_node;
+list_length++;
+current_node = new_node; /* advance to next node */
+scanf ( "%d", &number );
+}
+}
+return head;
+}
+/* Delete the first num nodes from the list */
+struct node *delete_first ( int num, struct node *head )
+{
+int i=1;
+struct node *current_node = head;
+struct node *next_node;
+while ( i <= num ) {
+next_node = current_node->next;
+free(current_node);
+current_node = next_node;
+i++;
+}
+head = current_node;
+return head;
+}
+void print_list ( struct node *head )
+{
+struct node * current_node;
+if ( head == NULL ){
+return;
+}
+current_node = head;
+while ( current_node != NULL ) {
+printf ( "%d ", current_node->data );
+current_node = current_node->next;
+}
+printf("\n");
+return;
+}
+int main()
+{
+int number;
+int pruned_length=0;
+struct node *head;
+head = create_list ( head );
+scanf("%d", &pruned_length);
+if(pruned_length > list_length){
+printf ( "-1\n" );
+return 0;
+}else{
+head=delete_first(list_length-pruned_length, head);
+print_list(head);
+}
+return 0;
+}