WAP to print a string such that , if input string is "hello how are you and where are you good " then out put is "doog era dna era olleh how you where you" and if input is " hello how are you and where are you good one" then out put is "eno uoy erehw uoy woh hello are and are good".

import java.util.StringTokenizer;


public class stringTokenTest {
public static void main(String[] args) {
String str = "hello how are you and where are you good one";
String delim = " ,;?'#%&*";
StringBuilder build = new StringBuilder();
StringBuilder string = null;
String s;
StringTokenizer token = new StringTokenizer(str, delim);
while (token.hasMoreElements()) {
s = token.nextToken();
string = build.append(" " + s).reverse();
}
System.out.println(string);
}


}

NOTE: implement it in C language without using built-in function

WAP to implement stack.

#include<stdio.h>
#include<stdlib.h>
#define MAX 100
struct stack
{
int top;
int items[MAX];
};


struct stack st;
void push(struct stack *ps,int n)
{
   if(ps->top == MAX-1)
        printf("Overflow");
    else
        ps->items[++(ps->top)]=n;
}


int empty(struct stack *ps)
{
    return (ps->top == -1);
}


int pop(struct stack *ps)
{
        if(empty(ps))
        {
            printf("Underflow");
            exit(1);
        }
        else
            return ps->items[(ps->top)--];
}
int main()
{
    st.top== -1;
    int x;
    int i=0;
    push(&st,25);
    push(&st,51);
    push(&st,53);
    push(&st,51);
    push(&st,54);
    push(&st,30);
    push(&st,50);
    push(&st,70);
    push(&st,90);
    push(&st,10);
    push(&st,80);


printf("top: %d\n",st.top);
  for(i=st.top;i>0;i--){
      x=pop(&st);
    printf("%d\n",x);
  }
  return 0;
}

Write a program to find the winner of election. each similar element of an array is treated as a candidate

#include<stdio.h>
#include<stdlib.h>
void winnerSelect(int a[], int size, int max)
{
    int i;
    int maxVote,winCandidate;


    int *candidate;
    candidate=(int*)malloc(sizeof(int)*max);
    for(i=0;i<=max;i++)
    {
        candidate[i]=0;
    }
    maxVote=0;
    winCandidate=a[0];
    for(i=0;i<size;i++)
    {
        candidate[a[i]]++;
        if(candidate[a[i]]>maxVote)
            {
                maxVote=candidate[a[i]];
                winCandidate=a[i];
            }
    }
    printf("Max vote: %d\nWinner candidate : %d\n",maxVote,winCandidate);
    free(candidate);
}


int main()
{
    int a[]={10,12,11,23,23,12,12,11,11,34};
    int size = sizeof(a)/sizeof(int);
    int max=0,i;
    for(i=0;i<size;i++)
    {
        if(a[i]>max)
            max=a[i];
        else
            max=max;
    }
    winnerSelect(a,size,max);
    printf("Size: %d  Max : %d",size,max);
}

Given "a1","b1","c1","a2","b2","c2","a3","b3","c3","a4","b4","c4","a5","b5","c5" , write a program to arrange like a1 a2 a3 a4 a5 b1 b2 b3 b4 b5 c1 c2 c3 c4 c5.........

#include <stdio.h>
int main()
{


    char *str[3*5]={"a1","b1","c1","a2","b2","c2","a3","b3","c3","a4","b4","c4","a5","b5","c5"};


    int n=3,i,j;
    for(i=1;i<=3;i++)
    {
        for(j=i-1;j<15;j++)
        {
            printf("%s ",str[j]);
            j=j+2;
        }
    }
return 0;
}

Write a program to reverse ( in place ) a string.

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void reverse(char *begin, char *end)
{
    char temp;
    while(begin<end)
    {
        temp=*begin;
        *begin++ = *end;
        *end-- = temp;
    }
  /*  src=src+strlen(src)-1;
     while(*des++ = *src--);  */
}


reverseword(char *s)
{
    char *start,*temp;
    start=temp=s;
    while(*temp)
    {
        temp++;
        if(*temp==' '|| *temp=='\0')
        {
            reverse(start,temp-1);
            start=temp+1;
        }
    }
    reverse(s,temp-1);
}
int main()
{
char s[]="This is a good boy";
reverseword(s);
printf("%s\n",s);
return 0;
}

Output: boy good a is This

Write a program to evaluate post-fix expression.

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX 50
#define TRUE 1
#define FALSE 0


struct stack{
int top;
double items[MAX];
};


int digit(char symb)
{
    return (symb>='0' && symb<='9');
}


void push(struct stack *ps,double n)
{
    ps->items[++(ps->top)]=n;
}


double pop(struct stack *ps)
{
    return ps->items[(ps->top)--];
}


double oper(int symb, double op1, double op2)
{
    switch (symb)
    {
        case '+':return (op1+op2);
        case '-':return (op1-op2);
        case '*':return (op1*op2);
        case '/':return (op1/op2);
        case '%': return (fmod(op1,op2));
        default: printf("Invalid operation..."); exit(1);
    }
}


double eval(char expr[])
{
struct stack ps;
ps.top=-1;
int c,position;
double oprd1,oprd2,result;
for(position=0; ( c = expr[position] ) != '\0'; position++)
        if(digit(c))
            push(&ps,(double)(c-'0'));
        else
        {
            oprd2 = pop(&ps);
            oprd1 = pop(&ps);
            result = oper(c,oprd1,oprd2);
            push(&ps,result);
        }


return (pop(&ps));
}




int main()
{
char expr[MAX];
int position = 0;
while( (expr[position++]= getchar() )!='\n') // to read expression.
                ;
expr[--position]='\0';
printf("Origional Expression: %s\n",expr);


printf("%f\n", eval(expr));
return 0;
}

Semaphor Vs Mutex

Mutex can be released only by thread that had acquired it, while you can signal semaphore from any other thread (or process), so semaphores are more suitable for some synchronization problems like producer-consumer.

On Windows, binary semaphores are more like event objects than mutexes.

Mutex:

Is a key to a toilet. One person can have the key - occupy the toilet - at the time. When finished, the person gives (frees) the key to the next person in the queue.

Officially: "Mutexes are typically used to serialise access to a section of re-entrant code that cannot be executed concurrently by more than one thread. A mutex object only allows one thread into a controlled section, forcing other threads which attempt to gain access to that section to wait until the first thread has exited from that section."

(A mutex is really a semaphore with value 1.)

Semaphore:

Is the number of free identical toilet keys. Example, say we have four toilets with identical locks and keys. The semaphore count - the count of keys - is set to 4 at beginning (all four toilets are free), then the count value is decremented as people are coming in. If all toilets are full, ie. there are no free keys left, the semaphore count is 0. Now, when eq. one person leaves the toilet, semaphore is increased to 1 (one free key), and given to the next person in the queue.

Officially: "A semaphore restricts the number of simultaneous users of a shared resource up to a maximum number. Threads can request access to the resource (decrementing the semaphore), and can signal that they have finished using the resource (incrementing the semaphore)." Ref: Symbian Developer Library

Their synchronization semantics are very different:

·         mutexes allow serialization of access to a given resource i.e. multiple threads wait for a lock, one at a time and as previously said, the thread owns the lock until it is done: only this particular thread can unlock it.

·         a binary semaphore is a counter with value 0 and 1: a task blocking on it until any task does a sem_post. The semaphore advertises that a resource is available, and it provides the mechanism to wait until it is signaled as being available.

As such one can see a mutex as a token passed from task to tasks and a semaphore as traffic red-light (it signals someone that it can proceed).

On Windows, there are two differences between mutexes and binary semaphores:

1.    A mutex can only be released by the thread which has ownership, i.e. the thread which previously called the Wait function, (or which took ownership when creating it). A semaphore can be released by any thread.

2.    A thread can call a wait function repeatedly on a mutex without blocking. However, if you call a wait function twice on a binary semaphore without releasing the semaphore in between, the thread will block.

for more details :

http://blog.feabhas.com/2009/09/mutex-vs-semaphores-%E2%80%93-part-1-semaphores/

http://blog.feabhas.com/2009/09/mutex-vs-semaphores-%E2%80%93-part-2-the-mutex/

http://blog.feabhas.com/2009/10/mutex-vs-semaphores-%E2%80%93-part-3-final-part-mutual-exclusion-problems/