Choosing the right skill

Choosing The Right Skill

Are you a beginner in IT/CS or any other computer application area?
Then the biggest confusion in your mind might be to decide what is the technology with good future.
What are your strengths in terms of technical knowledge?
where to find the relevant resources for your interest?
Here is a link to ReSkill that might sort out some of your doubts.

Visit the Reskill Site here

C program to multiply 2 matrices

To Develop the logic and trace the indices in 2-D array workout small problem on paper and observe the indices

/*
    c Program to multiply two matrices
*/


#include<stdio.h>
#include<stdlib.h>
int main()
{
        int A[3][3]={   {1,2,3},
                        {4,5,6},
                        {7,8,9}
                     };

        int B[3][3]={   {1,2,3},
                        {4,5,6},
                        {7,8,9}
                    };

        int i,j,k,l,temp=0;
        int C[3][3];    //result matrix

        for(i=0;i<3;i++){
                for(j=0;j<3;j++){
                        temp=0;
                        for(k=0;k<3;k++){
                                temp=temp+A[i][k]*B[k][j];
                        }
                        C[i][j]=temp;
                }
        }
        //To print the resultant matrix
        for(i=0;i<3;i++){
                for(j=0;j<3;j++){
                        printf("%d ",C[i][j]);
                }
                printf("\n");
        }

        return 0;
}

Write a function called sparse_array_out that takes two input arguments and returns one output argument. Its first argument is a two-dimensional array of doubles, which it writes into a binary file. The name of that file is the second argument to the function. The file must have the following format. It starts with three uint32 scalars specifying the number of rows of the array followed by the number of columns followed by the number of non-zero elements in the array. Then each non-zero element of the array is represented by two uint32 scalars and a double scalar in the file in this order: its row index (uint32), its column index (uint32), and its value (double). Note that this file format is an efficient way to store a so-called “sparse array”, which is by definition an array for which the overwhelming majority of its elements equal 0. The function’s output argument is of type logical and equals false if there was a problem opening the file and true otherwise.

function out = sparse_array_out(A,filename)
%Input A is 2D array and filename is a binary file
%Output out is logical value
fid = fopen(filename,'w+');
if fid < 0
    out=0;
    return;
end
dims = size(A);
[row,col,v] = find(A);
n=length(v);
fwrite(fid,dims(1),'uint32');
fwrite(fid,dims(2),'uint32');
fwrite(fid,n,'uint32');
for i=1:n
    fwrite(fid,[row(i),col(i),],'uint32');
    fwrite(fid,v(i),'double');
end
out=1;
fclose(fid);

Linklist: Create node , Traverse List, Delete Node

/*   C Program to create linklist, Traversal and deletion

*/

#include<stdio.h>
#include<stdlib.h>
struct node{
  int data;
  struct node *next;
};

struct node * head=NULL;
void addNode(int x){
  struct node *newNode,*p;
  p=head;
  newNode=(struct node *)malloc(sizeof(struct node));
  newNode->data=x;
  newNode->next=NULL;
  if(head==NULL){    // if list is empty
    head=newNode;
    return;
  }
  else{
    while(p->next!=NULL){ //find the last node
      p=p->next;
    }
    p->next=newNode;   //add node at the end
  }
  return;
}

void deleteNode(int x){
  if(head==NULL){
     printf("The list is empty\n");
     return;
  }
  else{
    struct node *p=head,*q;
    q=p;
    while(p!=NULL){
      //if element is first
      if(head->data==x){
        if(head->next!=NULL){  //if there are more nodes
          q=p;
          p=p->next;
          free(q);
          head=p;
          return;
        }
        else if(head->next==NULL){  //if head is the only node
          free(p);
          head=NULL;
          return;
        }
      }
      else if(p->data==x){
        if(p->next!=NULL){    //if node is not the last node
          q->next=p->next;
          free(p);
          return;
        }
        else if(p->next==NULL){  //if node is the last node
          free(p);
          q->next=NULL;
          return;
        }
      }
      q=p;
      p=p->next;
    }
    printf("Element not found\n");
    return;   
  }
}
void traverse(){
  if(head==NULL){
    printf("The list is empty\n");
  }
  else{
    struct node *p=head;
    do{
      printf("%d ",p->data);
      p=p->next;
    }while(p!=NULL);
    printf("\n");
  }
}
    
int main(){
  int choice;
  int x;
  while(1){
    printf("1)Add node\n2)Delete node\n3)Traverse list\n4)exit\n");
    scanf("%d",&choice);
    switch(choice){
      case 1:printf("Enter element to add\n");
             scanf("%d",&x);
      addNode(x);
        break;
      case 2:printf("Enter the node to be deleted\n");
             scanf("%d",&x);
             deleteNode(x);
        break;
      case 3:traverse();
        break;
      case 4:exit(1);
      default:printf("Enter valid choice\n");
    }
  }
  return 0;
}

Write a function called sparse_array_in that reads a two-dimensional array of doubles from a binary file whose name is provided by the single input argument of the function. The format of the file is specified in the previous problem. The function returns the two-dimensional array that it reads from the file as an output argument. Note that if you call sparse_array_out with an array called A and then call sparse_array_in using the same filename and save the output of the function in variable B, then A and B must be identical. If there is a problem opening the file, the function returns an empty array.

function A=sparse_array_in(filename)
%Input filename is a binary file
%Output 2D array
fid = fopen(filename,'r');
if fid < 0
    error('error opening file %s\n',filename);
end
r = fread(fid,1,'uint32');%row index
c = fread(fid,1,'uint32');%column index
n = fread(fid,1,'uint32');%value
A=zeros(r,c);
for i=1:n
    row = fread(fid,1,'uint32');
    col = fread(fid,1,'uint32');
    v = fread(fid,1,'double');
    A(row,col)=v;
end
fclose(fid);

Write a function called letter_counter that takes the name of a text file as input and returns the number of letters (i.e., any of the characters, a-to-z and A-to-Z) that the file contains. HINT: You can use the built-in function isletter. If there is a problem opening the file, the function returns -1. WARNING: if you use the ‘w’ flag with fopen, as opposed to ‘r’, you will overwrite the file.

function num = letter_counter(filename)
%Input filename is a text file
%Output num is a number of letters
s=0;
fid = fopen(filename,'rt');
if fid < 0
    num=-1;
    return;
end
oneline = fgets(fid);
while ischar(oneline)
    l=isletter(oneline);
    s=s+sum(l);
    fprintf('%s',oneline) % display one line
    oneline = fgets(fid);
end
num=s;
fprintf('\n');
fclose(fid);

Write a function called saddle that finds saddle points in the input matrix M. For the purposes of this problem, a saddle point is defined as an element whose value is greater than or equal to every element in its row, and less than or equal to every element in its column. Note that there may be more than one saddle point in M. Return a matrix called indices that has exactly two columns. Each row of indices corresponds to one saddle point with the first element of the row containing the row index of the saddle point and the second column containing the column index. The saddle points are provided in indices in the same order they are located in M according to column-major ordering. If there is no saddle point in M, then indices is the empty array.

function indices = saddle(M)
%Input M is a matrix
%Output indices is a matrix of exactly two columns
%Example indices = saddle([1 2 3;4 5 6;7 8 9])
indices=[];
[m,n]=size(M);
for i=1:n
    for j=1:m
        a=min(M(:,i));  %minimum element in a column
        b=max(M(j,:));  %maximum element in a row
        if M(j,i)==a && a==b 
            indices=[indices;j i];
        end
    end
end

Write a function called prime_pairs that returns the smallest prime number p smaller than 100,000 such that (p + n) is also prime, where n is a scalar integer and is the sole input argument to the function. If no such number exists, then the function returns -1. You may use the built-in functions, primes and isprime. Note that an efficient solution to this problem, such as the one the grader uses, takes a fraction of a second, but depending on how you do it, yours may be significantly slower.

function p= prime_pairs(n)
%Input n is a scalar integer
%Output p is prime number
%Example p=prime_pairs(22)
flag=0;
A=primes(100000);
l=length(A);
for i=1:l
    if isprime(A(i)+n)==1  %check if p+n is also prime
        p=A(i);
        flag=1;
        return;
    end
end
if flag~=1
    p=-1;
    return;
end

Write a function called bell that returns the first n rows of the Bell triangle, where n is an input argument. For a precise definition, see http://en.wikipedia.org/wiki/Bell_triangle. The function must return an n-by-n array where the top left triangle contains the Bell triangle with each row of the Bell triangle positioned diagonally—bottom-left-to-upper-right—and the bottom right triangle contains only zeros. If n is not a positive integer, the function returns an empty array.

function B = bell(n)
%Input n is a positive integer
%Output B is an array of nxn
%Example B=bell(7)
if n<1 || fix(n)~=n  %check if n is a positive integer
    B=[];
    return;
end
B = zeros(n);
B(1,1) = 1;
for row=2:n
  B(row, 1:row) = B(row-1,row-1) + cumsum([0 B(row-1, 1:row-1)]);
end
A=B(:,1);
count=n-1;
for i=2:n
    C=circshift(B(:,i),count);
    A=[A C];
    count=count-1;
end
B=A;

C program to implement josephus problem using circular linklist

/*
   C- Program to implement josephus problem
*/
#include<stdio.h>
#include<stdlib.h>
struct node{
        int data;
        struct node *next;
};
typedef struct node node;
int josephus(int, node *);
node *head=NULL,*h=NULL;
void main()
{
        int count=1,n,m;
        node *new;
        printf("enter the value of n:\n");   //total number of elements in list
        scanf("%d",&n);
        printf("enter the value of m:\n");  //m-th element will be removed every time
        scanf("%d",&m);
        while(count<=n)
        {
                new=(node*)malloc(sizeof(node));
                new->data=count++;
                if(head==NULL)
                {
                        head=new;
                        new->next=head;
                }
                else
                {
                        h=head;
                        while(h->next!=head)
                                h=h->next;
                        h->next=new;
                        new->next=head;
                }
        }
        printf("circular linklist is:\n");
        h=head;
        while(h->next!=head)
        {
         printf("%d->",h->data);
                h=h->next;
        }
        printf("%d",h->data);
        printf("\n");
        josephus(m,head);
}
int josephus(int m,node *front)
{
        node *f;
        int c=1;
        while(front->next!=front)
        {
                c=1;
                while(c!=m)
                {
                        f=front;
                        front=front->next;
                        c++;
                }
                f->next=front->next;
                printf("%d->",front->data); //sequence in which nodes getting deleted
                front=f->next;
        }
        printf("\n");
        printf("Winner is:%d\n",front->data);
        return;
}

Write a function called codeit that takes a string txt as input and returns another string coded as output. The function reverses the alphabet: It replaces each 'a' with 'z', each 'b' with 'y', each 'c' with 'x', etc. The function must work for uppercase letters the same way, but it must not change any other characters. Note that if you call the function twice like this str = codeit(codeit(txt)) then str and txt will be identical.

function coded = codeit(txt)
%Input txt is a string
%Output coded is a string
%Example coded=codeit('azAZ')
code=double(txt);
s=length(code);
for i=1:s
    if code(i)>=65 && code(i)<=90 %for uppercase  letters
        m=code(i)-65;
        code(i)=90-m;
    elseif code(i)>=97 && code(i)<=122 %for lowercase  letters
        m=code(i)-97;
        code(i)=122-m;
    end
end
coded=char(code);

Insertion Sort in Python

def sort(c):
        for i in range(0,len(c),1):
                j=i
                while(j>0):
                        if(c[j]<c[j-1]):
                                c[j],c[j-1]=c[j-1],c[j]
                        j-=j 
        return c
                
a=[10,23,54,23,32,98,87]
print a
b=sort(a)
print b

C- Program for insertion sort

//C-Program for insertion sort


#include<stdio.h>
#include<time.h>
#define MAX_SIZE 10
void swap(int *a,int *b){
  int temp;
  temp=*a;
  *a=*b;
  *b=temp;
}
void sort(int *arr)
{
  int i,j;
  for(i=1;i<MAX_SIZE;i++){
    for(j=i;j>0;j--){
      if(arr[j]<arr[j-1]){
        swap(&arr[j],&arr[j-1]);
      }
    }
  }
}

int main()
{
  int i;
  int arr[MAX_SIZE]={10,20,30,40,50,60,65,70,76,80};
  for(i=0;i<MAX_SIZE;i++) //Array before sorting
    printf("%d ",arr[i]);
  sort(arr);
  printf("\n\n");
  for(i=0;i<MAX_SIZE;i++) //Array after sorting
    printf("%d ",arr[i]);
  return 0;
}

Summation of primes: program to print sum of all prime numbers upto 2000000

/*Program to print sum of all prime numbers upto 2000000*/

/*To check whether a number is prime or not it takes n^2 time by
  brute force but this program is sqrt(n) according to
  mathematical rules to check prime number efficiently.
*/

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX 2000000
int main()
{
  int i,j;
  unsigned long int prod=0;
  int prime;
  for(i=2;i<=MAX;i++){
    prime=1;
    for(j=2;j<(int)(sqrt(i)+1);j++){
      if(i%j==0){
        prime=0;
        break;
      }
    }
    if(prime==1){
      prod=prod+i;
    }
  }
  printf("%ld",prod);
  return 0;
}

Create and Traverse Binary Search Tree without using recursion

/*
 Program to create and display a binary search tree
*/

#include<stdio.h>
#include<stdlib.h>
#define MAX_NODES 100

struct node{
  struct node *lChild;
  int data;
  struct node *rChild;
};
struct node *root=NULL;

/*Adding Element to a Binary Search Tree*/
void addElement(struct node *parent,int num)
{
  struct node *newNode;
  newNode=(struct node *)malloc(sizeof(struct node));
  newNode->lChild=NULL;
  newNode->rChild=NULL;
  newNode->data=num;
  if(root==NULL){
    root=newNode;
    return;
  }
  else{
    if(parent->data>num){  // go left
      if(parent->lChild==NULL){
        parent->lChild=newNode;
      }
      else{
        addElement(parent->lChild,num);
      }
    }
    else{                //go right
      if(parent->rChild==NULL){
        parent->rChild=newNode;
      }
      else{
        addElement(parent->rChild,num);
      }
    }
  }
  return;
}
/*Inorder Traversal with recursion*/
void inorder(struct node *parent)
{
  if(root==NULL){
    printf("No Element in Tree\n");
  }
  else{
    
    if(parent->lChild!=NULL){
      inorder(parent->lChild);
    }
    printf("%d ",parent->data);
    if(parent->rChild!=NULL){
      inorder(parent->rChild);
    }
  }
  return;
}

/*Binary Search Operation*/
struct node * search(struct node *parent,int num)
{
  if(root==NULL){
    printf("Empty Tree\n");
    return NULL;
  }
  else{
    if(parent->data==num){
      return parent;
    }
    else if(parent->data>num){
      if(parent->lChild!=NULL){
        search(parent->lChild,num);
      }
      else{
        printf("Element not found\n");
        return NULL;
      }
    }
    else{
      if(parent->rChild!=NULL){
        search(parent->rChild,num);
      }
      else{
        printf("Element not found\n");
        return NULL;
      }
    }
  }
}

/*Push pop for stack*/
void push(struct node **stack,int *top,struct node *child){
  if(*top<MAX_NODES-1){
    stack[++(*top)]=child;
  }
}

struct node *pop(struct node **stack,int *top){
  if(*top>-1){
    return stack[(*top)--];
  }
  else{
    printf("stack empty");
    return NULL;
  }
}


/*Pre order Traversal without using recursion*/
void preorder(){
  struct node * stack[MAX_NODES];
  struct node *p;
  int top=-1;
  if(root==NULL){
    printf("Tree is empty");
    return;
  }
  push(stack,&top,root);
  while(top!=-1){
    p=pop(stack,&top);
    printf("%d ",p->data);
    if(p->rChild!=NULL)
      push(stack,&top,p->rChild);
    if(p->lChild!=NULL)
      push(stack,&top,p->lChild);
  }
}

/*Post Order Traversal without using recursion*/
void postOrder(){
  struct node *stack[MAX_NODES];
  struct node *stack2[MAX_NODES];
  struct node*p;
  int top1=-1,top2=-1;
  if(root==NULL){
    printf("Tree is empty");
    return;
  }
  push(stack,&top1,root);
  while(top1!=-1){
    p=pop(stack,&top1);
    push(stack2,&top2,p);
    if(p->lChild!=NULL)
      push(stack,&top1,p->lChild);
    
    if(p->rChild!=NULL)
      push(stack,&top1,p->rChild);
  }
  while(top2!=-1){
    p=pop(stack2,&top2);
    printf("%d ",p->data);
  }
}


/*In order Traversal Without using Recursion*/
void inorderWithoutRecursion(){
  int arrIndex=-1;
  struct node *arr[MAX_NODES];
  struct node *stack[MAX_NODES];
  struct node *p;
  int top=-1,i;
  int flag=0;
  if(root==NULL){
    printf("Tree is empty\n");
    return;
  }
  push(stack,&top,root);
  while(top!=-1){
    p=pop(stack,&top);
    flag=0;
    for(i=0;i<=arrIndex;i++){
      if(arr[i]==p){
        printf("%d\n",p->data);
        flag=1;
        break;
      }
    }
    if(flag==0){
      if(p->rChild!=NULL)
        push(stack,&top,p->rChild);
      push(stack,&top,p);
      arr[++arrIndex]=p;
      if(p->lChild!=NULL)
        push(stack,&top,p->lChild);
    }
  }
}


/*Test Program to run the code*/
int main()
{
  struct node *p;
  int num,choice;
  while(1)
  {
    printf("\nEnter the choice\n");
    printf("1)Add element\n");
    printf("2)Inorder\n");
    printf("3)Search\n");
    printf("4)Preorder Traverse\n");
    printf("5)Post Order Traverse\n");
    printf("6)Inorder Traversal Without Recursion\n");
    printf("7)Exit\n");
    scanf("%d",&choice);
    switch(choice)
    {
      case 1:printf("Enter the number\n");
             scanf("%d",&num);
             addElement(root,num);
        break;
      case 2:inorder(root);
        break;
      case 3:printf("Enter element to search\n");
             scanf("%d",&num);
             p=search(root,num);
        break;
      case 4:preorder();
        break;
      
      case 5:postOrder();
        break;
      case 6:inorderWithoutRecursion();
        break;
      case 7:exit(0);
        break;
      default:printf("Enter valid choice\n");
    }
  }
  return 0;
}

Write a function called replace that takes three inputs: a cell vector (row or column) of strings and two characters: c1 and c2. The function returns the cell vector unchanged except that each instance of c1 in each string is replaced by c2. You are not allowed to use the built-in function strrep.

function c = replace(A,c1,c2)
%Input A is a cell vector of strings, c1, c2: two characters
%Output c is a cell vector
%Example: A={ 'XOXO', 'XOXO' }
%         c = replace(A,'X','Y')
[m,n]=size(A); %dimensions of A
for i=1:m
    for j=1:n
        a=length(A{i,j}); %length of each string in A
        for k=1:a
            if A{i,j}(k)==c1
                A{i,j}(k)=c2;
            end
        end
    end
end
c=A;

Write a function called May2015 that returns a struct vector (row or column) whose elements correspond to the days of May, 2015. Each struct should contain three fields with these (exact) field names: “month”, “date”, and “day” (all lower case).  The month field must contain the string 'May' (uppercase ‘M’).  The date field must contain a scalar of type double that equals the date (1 through 31).  The day field must contain the three-letter abbreviation of the day chosen from this list: 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'. For example, here is a call of the function followed by a command that shows the eleventh element of the struct array that is returned by the function: >> m = May2015; >> m(11) ans = month: 'May' date: 11 day: 'Mon'

function m = May2015
%Output m is struct vector
%Example: m = May2015
%         m(11)
D={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
M={'Fri','Sat','Sun','Mon','Tue','Wed','Thu','Fri','Sat','Sun','Mon','Tue','Wed','Thu',
   'Fri','Sat','Sun','Mon','Tue','Wed','Thu','Fri','Sat','Sun','Mon','Tue','Wed','Thu',
   'Fri','Sat','Sun'};
m=struct('month','May','date',D,'day',M);

Write a function called integerize that takes as its input a matrix A of non-negative integers of type double, and returns the name of the “smallest” unsigned integer class to which A can be accurately converted. If no such class exists, the string 'NONE' is returned. For example, if the largest element of A is 14, then the function would return 'uint8', but if the largest integer in A is 1e20, then the function would return 'NONE'.

function c = integerize(A)
%Input matrix A of non-negative integers
%Output c is smallest unsigned integer class
%Example: A = 256
%         c = integerize(A)
s = max(A(:)); %maximum element of A
if s>=0 && s< 2^8
    c = 'uint8';
elseif s>=0 && s< 2^16
    c = 'uint16';
elseif s>=0 && s< 2^32
    c = 'uint32';
elseif s>=0 && s< 2^64
    c = 'uint64';
else
    c = 'NONE';
end
    

Write a function myprime that takes n, a positive integer, as an input and returns true if n is prime or returns false otherwise. Do not use the isprime or primes or factor built-­‐in functions. Hint: you can use the rem or fix functions.

function p = myprime(n)
%Input n is a positive integer
%Output p is a boolean value
%Example: p = myprime(281)
if n==2
    p=1;
elseif n==3
    p=1;
else
    for i=2:fix(n/2) %check number divisible till n/2
        if mod(n,i)==0
            p=0;
            return;
        end
    end
    p=1;
end

Write a function called divvy that takes a matrix A of integers greater than or equal to zero and a single positive integer k as its two inputs and returns a matrix B that has the same size as A. The elements of B are all divisible by k. If an element of A is divisible by k, then the corresponding element in B must have the same value. If an element of A is not divisible by k, then the corresponding element of B must be the product of the given element of A and k. You are not allowed to use any for-­‐loops or while-­‐loops. For example, the call X = divvy([1 2 ; 3 4], 2) would make X equal to [2 2 ; 6 4].

function B = divvy(A,k)
%Input A is a matrix >=0, k is a positive integer
%Output B is a matrix
%Example: A = [1 2 ; 3 4]
%         X = divvy(A,2)
B=A;
B(mod(A,k)~=0)=A(mod(A,k)~=0).*k; %multiply with k if not divisible by k

Write a function called separate_by_two that takes a matrix A of positive integers as an input and returns two row vectors. The first one contains all the even elements of A and nothing else, while the second contains all the odd elements of A and nothing else, both arranged according to column-­‐major order of A. You are not allowed to use for-­‐loops or while-­‐loops.

function [u,v] = separate_by_two(A)
%Input A is a matrix of positive integers
%Output u and v are row vectors
%Example: A = [1 2 3;4 5 6;7 8 9]
%         [u,v]=separate_by_two(A)
u=(A(mod(A,2)==0))'; %contain even elements
v=(A(mod(A,2)~=0))'; %contain odd elements

Write a function called one_per_n that returns the smallest positive integer n for which the sum 1 + 1/2 + 1/3 + … + 1/n, is greater than or equal to x where the scalar x is the input argument. Limit the maximum number n of terms in the sum to 10,000 and return -1 if it is exceeded. (Note: if your program or the grader takes a long time, you may have created an infinite loop and need to hit Ctrl-­‐C on your keyboard.)

function n = one_per_n(x)
%Input x is a scalar
%Output n is a positive integer
%Example: n = one_per_n(4)
%         n = 31
sum=0;
n=0;
while sum<x
    if n<10000
        n=n+1;
        sum=sum+1/n;
    else
        n=-1;
        return;
    end
end

Write a function called large_elements that takes as input an array named X that is a matrix or a vector. The function identifies those elements of X that are greater than the sum of their two indexes. For example, if the element X(2,3) is 6, then that element would be identified because 6 is greater than 2 + 3. The output of the function gives the indexes of such elements found in row-­‐ major order. It is a matrix with exactly two columns. The first column contains the row indexes, while the second column contains the corresponding column indexes. For example, the statement indexes = large_elements([1 4; 5 2; 6 0], will make indexes equal to [1 2; 2 1; 3 1]. If no such element exists, the function returns an empty array.

function indexes = large_elements(x)
%Input x is a matrix or vector
%Output indexes is a matrix with two column
%Example: x = [1 4;5 2;6 0]
%         indexes = large_elements(x)
%         indexes = [1 2;2 1; 3 1]
indexes=[];
[m,n]=size(x);  %dimensions of x
for i=1:m
    for j=1:n
        if x(i,j)>(i+j)   
            indexes = [indexes; i j];  %indexes with value>=sum of indexes
        end
    end
end

Write a function called halfsum that takes as input an at most two-­‐dimensional matrix A and computes the sum of the elements of A that are in the diagonal or are to the right of it. The diagonal is defined as the set of those elements whose column and row indexes are the same. For example, if the input is [1 2 3; 4 5 6; 7 8 9], then the function would return 26.

function sum=halfsum(v)
%Input v is 2-D matrix
%Output sum is a value
%Example: v = [1 2 3;4 5 6;7 8 9]
%         sum = halfsum(v)
%         sum = 26
sum=0;
[m,n]=size(v);
for i=1:m
    for j=1:n
        if i<=j   %sum of elements with row index <= column index
            sum=sum+v(i,j);
        end
    end
end

The function replace_me is defined like this: function w = replace_me(v,a,b,c). The first input argument v is a vector, while a, b, and c are all scalars. The function replaces every element of v that is equal to a with b and c. For example, the command >> x = replace_me([1 2 3],2,4,5); makes x equal to [1 4 5 3]. If c is omitted, it replaces occurrences of a with two copies of b. If b is also omitted, it replaces each a with two zeros.

function w = replace_me(v,a,b,c)
%Input v is a vector, while a, b, and c are all scalars
%Output w is a vector
%Example: w = replace_me([1 2 3],2,4,5);
%         w = [1 4 5 3]
w=[];
if nargin==4
    for i=1:length(v)
        if v(i)==a
           w=[w b c];   %add b c to vector
        else
            r=v(i);
            w=[w r];
        end
    end
elseif nargin==3    %if c is omitted
    for i=1:length(v)
        if v(i)==a
            w=[w b b];   %add b b to vector
        else
            r=v(i);
            w=[w r];
        end
    end
elseif nargin==2    %if b is omitted
    for i=1:length(v)
        if v(i)==a
            w=[w 0 0]; %add 0 0 to vector
        else
            r=v(i);
            w=[w r];
        end
    end
end

Write a function called neighbor that takes as input a row vector called v and creates another row vector as output that contains the absolute values of the differences between neighboring elements of v. For example, if v == [1 2 4 7], then the output of the function would be [1 2 3]. Notice that the length of the output vector is one less than that of the input. Check that the input v is indeed a vector and has at least two elements and return an empty array otherwise. You are not allowed to use the diff built-­‐in function.

function v=neighbor(u)
%Input u is a row vector
%Output v is a row vector of length one less than u
%Example: u = [1 2 4 7]
%         v = neighbor(u)
l=length(u);    %number of elements in u
[m,n]=size(u);  %dimensions of u
if m==1         %condition check if u is a row vector
    v=zeros(1,l-1);
    for i=1:l-1
        v(i)=abs(u(i)-u(i+1));   %diff between consecutive elements of u
    end
else
    v=[];
end

Program to create and display a binary search tree

/*
 Program to create and display a binary search tree
*/

#include<stdio.h>
#include<stdlib.h>
struct node{
  struct node *lChild;
  int data;
  struct node *rChild;
};
struct node *root=NULL;

void addElement(struct node *parent,int num)
{
  struct node *newNode;
  newNode=(struct node *)malloc(sizeof(struct node));
  newNode->lChild=NULL;
  newNode->rChild=NULL;
  newNode->data=num;
  if(root==NULL){
    root=newNode;
    return;
  }
  else{
    if(parent->data>num){  // go left
      if(parent->lChild==NULL){
        parent->lChild=newNode;
      }
      else{
        addElement(parent->lChild,num);
      }
    }
    else{                //go right
      if(parent->rChild==NULL){
        parent->rChild=newNode;
      }
      else{
        addElement(parent->rChild,num);
      }
    }
  }
  return;
}

void display(struct node *parent)
{
  if(root==NULL){
    printf("No Element in Tree\n");
  }
  else{
    printf("%d ",parent->data);
    if(parent->lChild!=NULL){
      display(parent->lChild);
    }
    if(parent->rChild!=NULL){
      display(parent->rChild);
    }
  }
  return;
}
    

int main()
{
  int num,choice;
  while(1)
  {
    printf("\nEnter the choice\n1)Add element\n2)Display Tree\n3)Exit\n");
    scanf("%d",&choice);
    switch(choice)
    {
      case 1:printf("Enter the number\n");
             scanf("%d",&num);
             addElement(root,num);
        break;
      case 2:display(root);
        break;
      case 3:exit(0);
        break;
      default:printf("Enter valid choice\n");
    }
  }
  return 0;
}

Write a function called hulk that takes a row vector v as an input and returns a matrix H whose first column consist of the elements of v, whose second column consists of the squares of the elements of v, and whose third column consists of the cubes of the elements v. For example, if you call the function likes this, A = hulk(1:3) , then A will be [ 1 1 1; 2 4 8; 3 9 27 ].

function H = hulk(v)
%{
Input v is a row vector
Output H is a matrix
Example:
    A = hulk(1:3)
%}
H = [v; v.^2; v.^3]'; %column 1, 2, 3 are elements of v, squares and cubes respectively

Write a function called mean_squares that returns mm, which is the mean of the squares of the first nn positive integers, where nn is a positive integer and is the only input argument. For example, if nn is 5, your function needs to compute the average of the numbers 1, 4, 9, 16, and 25. You may use any built-in functions including, for example, sum.

function mm = mean_squares(nn)
%Input nn is a positive integer
%Output mm is the mean of the squares of the first nn positive integers
%Example:
%     nn=5;
%     mm = mean_squares(nn)
A = 1:1:nn; %row vector A of length nn from 1 to nn
mm = sum(A.^2)/nn; %mean square value of A

Write a function called bottom_left that takes two inputs: a matrix N and a scalar n, in that order, where each dimension of N is greater than or equal to n. The function returns the n-by-n square array at the bottom left corner of N.

function nbyn = bottom_left(N,n)
%Input a matrix N and a scalar n, each dimension of N is greater than or equal to n
%Output nbyn square array at the bottom left corner of N
%Example:
%    N = [1 2 3;4 5 6;7 8 9]
%    nbyn=bottom_left(N, 2)
[x,y] = size(N);    %row and columns of N
if n<=max(x,y)    %condition check
    nbyn = N(x-n+1:x,1:n);    %bottom left matrix of size nxn
end

Write a function called pitty that takes a matrix called ab as an input argument. The matrix ab has exactly two columns. The function should return a column vector c that contains positive values each of which satisfies the Pythagorean Theorem, a2 + b2 = c2, for the corresponding row of ab assuming that the two elements on each row of ab correspond to one pair, a and b, respectively, in the theorem. Note that the built-in MATLAB function sqrt computes the square root and you are allowed to use it.

function c = pitty(ab)
%Input matrix ab has exactly two columns
%Output column vector c contains positive values satisfies a2 + b2 = c2
%Example:
%    ab = [3 4;1 2]
%    c = pitty(ab)
c = sqrt(ab(:,1).^2 + ab(:,2).^2);%Pythagorean theorem formula

Write a function called light_time that takes as input a row vector of distances in miles and returns two row vectors of the same length. Each element of the first output argument is the time in minutes that light would take to travel the distance specified by the corresponding element of the input vector. To check your math, it takes a little more than 8 minutes for sunlight to reach Earth which is 92.9 million miles away. The second output contains the input distances converted to kilometers. Assume that the speed of light is 300,000 km/s and that one mile equals 1.609 km.

function [x,y] = light_time(a)
%Input a is row vector of distances in miles
%Output x is row vector of time in minutes that light would take to travel the distance
%       y is row vector of distance in kilometres
%Example:
%    a = [92.9 141.6 483.8]
%    [x,y]=light_time(a)
x = (1.609/18e6) .* a; %time in minutes, 8 minutes for 92.9 million miles
y = 1.609 .* a; %distance in kilometres, 1 mile = 1.609km

Suppose we have a pile of coins. Write a function called rich that computes how much money we have. It takes one input argument that is a row vector whose 4 elements specify the number of pennies (1 cent), nickels (5 cents), dimes (10 cents), and quarters (25 cents) that we have (in the order listed here). The output of the function is the value of the total in dollars (not cents). For example, if we had five coins, four quarters and a penny, the answer would be 1.01.

function r = rich(m)
%Input m is a row vector of length 4
%Output r is a value of the total in dollars (not cents)
%Example:
%    m = [1 0 0 4]
%    r = rich(m)
r = (m*[1 5 10 25]')/100; %values of penny, nickels, dimes and quarters divided by 100 in dollars

Write a function called int_col that has one input argument, a positive integer n that is greater than 1, and one output argument v that is a column vector of length n containing all the positive integers smaller than or equal to n, arranged in such a way that no element of the vector equals its own index. In other words, v(k) is not equal to k for any valid index k.

function v = int_col(n)
%Input n>1 an integer
%Output v is a column vector of elements less than and equal to n without
%same index as element value.
%Example:
%    v=int_col(10)
if n>1 %check if n is greater than 1 or not
    v = [2 : 1 : n 1]'; %values from 2 to n and 1 in last
end

Write a function called odd_index that takes a matrix, M, as input argument and returns a matrix that contains only those elements of M that are in odd rows and columns. In other words, it would return the elements of M at indices (1,1), (1,3), (1,5), …, (3,1), (3,3), (3,5), …, etc. Note that both the row and the column of an element must be odd to be included in the output. The following would not be returned: (1,2), (2,1), (2,2) because either the row or the column or both are even. As an example, if M were a 5-by-8 matrix, then the output must be 3-by-4 because the function omits rows 2 and 4 of M and it also omits columns 2, 4, 6, and 8 of M.

 function x = odd_index(M)
%Input M is a matrix
%Output x is a matrix contains elements of M having odd index
%Example:
%    M=randi(10,5,8) (random matrix of 5x8 range 1-10)
%    x=odd_index(M)
 [n m] = size(M); %size of matrix M is nxm
 x = M(1:2:n,1:2:m); %skipping row and column by 2 to skip even indexes.

Python: Beginning with python

print 'Hello world'

#save file using .py formate and execute e.g. test.py
#output:Hello world

C program for factorial of a number with recursion

#include<stdio.h>
int factorial(int num){
  if(num==1){  //Termination condition for recursion
    return 1;
  }
  else{ 
    return num*factorial(num-1);  //Recursive call to evaluate recursively factorial of n-1
  }
}
int main(){
  int number,result;
  printf("Enter the number to find factorial\n");
  scanf("%d",&number);  //user input for number
  result=factorial(number);  //call to factorial
  printf("Factorial of %d is %d\n",number,result);
  return 0;
}
ipput:5
output:120

C Program of Hello

#include<stdio.h>
int main()
{
     printf("Hello World");
     return 0;
}