ProgrammingBlue

Difference between throw and throws in Java

2014-04-10T15:08:00.001+05:30

Throws: Throws declares that your method is capable of throwing an exception but it does not handle the exception that must be specified by using “throws” class.

When programmer defines a method and he knows that some part of code can raise an exception, and he don’t want to handle that exception within that function, then the method is defined with throws keyword.

Let us understand this with following example:

Imagine you have been assigned a task of finding a specific book, and then reading and explaining its contents to a class of students. The required sequence may look like:

Get the specified book
Read aloud its contents
Explain the contents to a class of students.

But what happens if you can't find the specified book? You can't proceed with the rest of the action without it so you need to report back to the person who assigned the task to you. This unexpected event (missing book) prevents you from completing your task. By reporting it back, you want the originator of this request to take corrective or alternate steps.

Let's code the above task as method teachClass, as shown in figure 1 and use it to compare the throw and throws statement. This example code is for demonstration purpose only because it uses methods locateBook, readBook, and explainContents, which aren't defined.

void teachclass () throws BookNotFoundException

{

boolean bookFound = locateBook();

if(!bookFound)

{

throw new BookNotFoundException();

}

}

Code in figure 1 is simple to follow. On execution of code throw new BookNotFoundException, execution of teachClass() halts. The JVM creates an instance of BookNotFoundException and sends it to off to the caller of teachClass() so that alternate arrangements can be made.

The throw statement is used to throw an instance of exception—BookNotFoundException. The throws statement is used in the signature of method teachClass to signal that it can throw exception BookNotFoundException.

Why does a method choose to throw an exception as opposed to handling it itself? It's a contract between the calling method and the called method. Referring back to the method teachClass, as shown in figure 1, the caller of teachClass would like to be informed if teachClass is unable to find the specified book. The method teachClass doesn't handle BookNotFoundException itself because its responsibilities don't include how to work around a missing book.

Finding the missing term of an A.P.

2013-12-05T14:22:00.004+05:30

An Arithmetic Progression is defined as one in which there is a constant difference between the consecutive terms of a given series of numbers. You are provided with consecutive elements of an Arithmetic Progression. There is however one hitch: Exactly one term from the original series is missing from the set of numbers which have been given to you. The rest of the given series is the same as the original AP. Find the missing term.

#include <stdio.h>
int main() {
    unsigned int N,i;
    N = 0;
    int *M;
    scanf("%u",&N);
    M = (int*)malloc(sizeof(int)*N);
    for(i = 0; i<N; i++)
    {
        scanf("%d",&M[i]);
    }
    int diff1 = 0, diff2 = 0, diff3 = 0;
    diff1 = M[1] - M[0];
    diff2 = M[2] - M[1];

    int cd = 0;
    if (diff1 > diff2)
        cd = diff2;
    else
        cd = diff1;

    for(i = 0;i<N-1;i++)
    {
        if(M[i+1] - M[i] == cd)
            continue;
        else if(M[i+1] - M[i] == cd*2)
        {
            printf("%d",M[i]+cd);
        }

    }

    return 0;
}

Any question? Please mail on 27it08@gmail.com

Running Wamp server on on port different than default port 80

2013-11-19T10:12:00.000+05:30

You have developed a system that is written using windows-apache-mysql-php. One day you open the system, launches the wamp server and here you g , you are finding that localhost is no longer responding and it becomes a nightmare for you to figure it out why it is not working. The reason is you have installed some other server like IIS, Glassfish or any other server that is by default configured on port 80. With the installation of glassfish you may not encounter the problem but when it is IIS, you are in trouble. As IIS is made to run forever on system by default, port 80 is always in use and you cannot open another socket connection on same port.

I think problem is clear enough. Now let us proceed to rescue the thing that is haunting you for weeks. Simple solution is to change the port number. There is funny part associated with this. Once someone asked if he should format the computer. Lol. You do not need to format your computer to solve just port related problems. Just change the configuration file in the installation directory of wamp and problem is solved.

Here is the steps you need to follow:

Go to <Installation directory>\wamp\bin\apache\apache2.2.22\conf .
Open httpd.conf and look for 80 by ctrl+F.
Replace 80 by the port you want wamp to listen to. Now you are done. But wait. This is only half way done. Because when you launch wamp from tray icon it will open http://localhost/ in your default browser. But it is supposed to open http://localhost:<you new port>/ .
Obviously you can always type http://localhost:<you new port>/ manually in your favourite browser but if this could have worked by clicking localhost in tray icon menu of wamp, wouldnot that be easier for you! Okay then keep reading to know how it is getting done.
In <Installation directory>\wamp you will find wampmanager.tpl. Open it and search for localhost. Replace http://localhost/ by http://localhost:<your new port>/.
Same thing you do with wampmanager.ini found in <Installation directory>\wamp.
You are done. Restart wamp. And Launch your localhost wamp home page.

Write a Java Program to implement Counting Sort.

2012-12-15T02:18:00.000+05:30

Counting Sort assumes that each of the n input elements is an integer range from 0 to k for some integer k. When k is in order of uper bound n then sort runs in order of n.

package counting.sort;
public class CountingSort
{
public static void main(String[ ] args)
{
int [ ]A = {-1, 19,20,23,48,19,34,34,19,0,2};
int [ ]C = new int[50];

//Frequency of each element
for(int i = 1;i<A.length;i++)
{
C[A[i]] = C[A[i]]+1;
}
//Cumulative Frequency
for(int i = 1;i<C.length;i++)
{
C[i] = C[i]+C[i-1];
}

int [ ]B= new int[A.length];
for(int i = A.length -1 ;i>=1;i--)
{
B[C[A[i]]] = A[i];
C[A[i]] = C[A[i]] - 1;
}
print(B); //B is sorted array
}
static void print(int [ ]A)
{
System.out.println();
for(int i=0;i<A.length;i++)
{
if(i!=A.length-1)
System.out.print(A[i]+ ",");
else
System.out.print(A[i]);;
}
}

}

Write Java Program to implement Quick Sort.

2012-12-15T02:13:00.001+05:30

This Sorting Algorithm is based on Divide and Conquer approach.

package quicksort;
public class QuickSort {

public static void main(String[ ] args) {
int [ ]A = {6, 9, 18, 4, 3, 15};
Sort qs = new Sort();
qs.sort(A,0,A.length-1);
qs.print(A);

}

}
class Sort
{
void sort(int [ ]A, int p, int r)
{
int q = 0;
if(p<r)
{
q = this.partition(A, p, r);
sort(A,p, q -1);
sort(A,q+1,r);
}
}
int partition(int [ ]A,int a, int b)
{
int x =A[b];
int i = a -1;
for (int j = a;j<=b -1; j++)
{
if(A[j]<=x)
{
i++;
//Swap
if(A[i]!=A[j])
{
A[i] = A[i] ^ A[j];
A[j] = A[i] ^ A[j];
A[i] = A[i] ^ A[j];
}
}
}
A[i+1] = A[i+1] ^ A[b];
A[b] = A[i+1] ^ A[b];
A[i+1] = A[i+1] ^ A[b];
return i+1;

}
void print(int [ ]A)
{
System.out.println();
for(int i=0;i<A.length;i++)
{
if(i!=A.length-1)
System.out.print(A[i]+ ",");
else
System.out.print(A[i]);;
}
}
}

Write a Java Program to implement heap and heap sort.

2012-12-02T16:54:00.008+05:30

I am assuming that actual index of array for purpose of implementing heap starts with 1 and whatever value is in index no. 0 will treated as garbage.

package heap;
public class Heap
{
public static void main(String[ ] args)
{

int [ ]A = {-9999, 67, 28, 2, 23, 5 ,93, 98, -37};
HeapData myHeap = new HeapData(A);
System.out.println("Heap formed is:");
myHeap.printHeap();
System.out.println(myHeap.checkHeap(A));
myHeap.HeapSort();
myHeap.printHeap();
//test case 1
int [ ]B = {-9999, 162, 32, 92, 2, 22, 12, 42}; //This is a Heapified Array .. must return true.
System.out.println(myHeap.checkHeap(B));
//test case 2
int [ ]C = {-9999, 12, 32, 2, 32, 29, 122, 43};
System.out.println(myHeap.checkHeap(C));
}
}

class HeapData
{
int [ ] Data;
HeapData(int [ ]A)
{
int i = 1, k = 1;

for(i =2 ; i<A.length; i++)
{
k =i;
do
{
if(A[k] > A[(k>>1)])
{
/* SWAP */
A[k] = A[k] ^ A[k>>1];
A[k>>1] = A[k] ^ A[k>>1];
A[k] = A[k] ^ A[k>>1];
}
k = k>>1;

}while(k>1);
}
Data = A;
}
void printHeap()
{
for(int i = 1 ; i<Data.length;i++)
{

System.out.print(Data[i]);
if (i < Data.length -1)
System.out.print(", ");
}
System.out.println();
}
boolean checkHeap(int A[ ])
{
for (int i = 1; i< A.length/2;i++)
{

if(!(A[i]>A[2*i] && A[i]>A[(2*i) +1]))
{
return false;
}
}
return true;
}
void HeapSort()
{
int i, j, k = 0;
for(i = Data.length - 1;i>0;i--)
{
//Swap Data[1] with ith element
Data[i] = Data[i] ^ Data[1];
Data[1] = Data[i] ^ Data[1];
Data[i] = Data[i] ^ Data[1];
for(j =2 ; j<i; j++)
{
k =j;
do
{
if(Data[k] > Data[(k>>1)])
{
/* SWAP */
Data[k] = Data[k] ^ Data[k>>1];
Data[k>>1] = Data[k] ^ Data[k>>1];
Data[k] = Data[k] ^ Data[k>>1];
}
k = k>>1;

}while(k>1);
}
}

}

}

Write a Java program to convert positive decimal integer to binary equivalent using bit-wise operators.

2012-12-01T17:09:00.004+05:30

package decimaltobinary;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class DecimalToBinary {

public static void main(String[ ] args) throws IOException {
System.out.print("Enter The Decimal numbber:");
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String input = reader.readLine();
int deci = Integer.parseInt(input);
Convert toConvert = new Convert();
toConvert.deciTobinary(deci);

}
}

class Convert
{
Convert()
{

}
void deciTobinary(int decimal)
{
System.out.println("Binary Equivalent of "+decimal+" is:" );
int mask = 1073741824;
/* Binary Value of 1073741824 is 1000000000000000000000000000000 which is used as masking for logical bit-wise ANDing. Note: int in Java is of 32 bit */
while(mask > 0)
{
if((decimal & mask) > 0)
{
System.out.print("1");
}
else
{
System.out.print("0");
}
mask = mask >> 1;
}
}
}

Write a Java Program to check two string if they are anagram of each other

2012-11-29T01:50:00.002+05:30

package AnaGram;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class myAnagram
{

public static void main(String[] args) throws IOException
{
// TODO code application logic her
BufferedReader reader1= new BufferedReader(new InputStreamReader(System.in));
System.out.println("\nEnter first string:");
String s1= reader1.readLine();

BufferedReader reader2= new BufferedReader(new InputStreamReader(System.in));
System.out.println("\nEnter first string:");
String s2= reader2.readLine();

Anagram ana = new Anagram();
if(ana.check(s1,s2)==true)
System.out.println(" String "+s1+" is anagram of "+s2);
else
System.out.println(" String "+s1+" is not anagram of "+s2);
}
}

class Anagram
{
boolean check(String s1,String s2)
{
char a1[]= s1.toCharArray();
char a2[]= s2.toCharArray();
int []index1= new int[26];
int []index2= new int[26];
int i = 0;
for(i=0;i<a1.length;i++)
{
index1[a1[i]-'a']++;

}
for(i=0;i<a2.length;i++)
{
index2[a2[i]-'a']++;

}
for(i=0;i<26;i++)
{
if(index1[i]!=index2[i])
return false;
}
return true;
}
}

Write a Java Program to find second smallest element of an array.

2012-11-29T00:50:00.000+05:30

package Small2;
public class small2 {

public static void main(String[] args) {
int []A = {10,2,8,15,-2};
SecondSmall slg = new SecondSmall();
int y = slg.findsecondsmall(A);
System.out.println("Second Smallest element of Array A is "+ y);

int []B = {10,15,30,5,7};
y = slg.findsecondsmall(B);
System.out.println("Second Smallest element of Array B is "+ y);

int []C = {13,74,29,30,31,73,62,22};
y = slg.findsecondsmall(C);
System.out.println("Second Smallest element of Array C is "+ y);

int []D = {1,2,3,4,5,6,7};
y = slg.findsecondsmall(D);
System.out.println("Second Smallest element of Array D is "+ y);

int []E = {7,6,5,4,3,2,1};
y = slg.findsecondsmall(E);
System.out.println("Second Smallest element of Array E is "+ y);

int []F = {7,6,5,4,3,2,1,-1,-2,-3,-4,-5,-6,-7};
y = slg.findsecondsmall(F);
System.out.println("Second Smallest element of Array F is "+ y);
}
}

class SecondSmall
{
int findsecondsmall(int A[])
{
int first1 = A[0];
int first2 = A[1];
int i = 1;
for(;i<A.length;i++)
{
if(A[i]<first1)
{
first2 = first1 ;
first1 = A[i];
}

else if(A[i]<first2)
{
first2 = A[i];
}
}
return first2;

}
}

Write a Java Program to find Nth Fibonacci number.

2012-11-28T23:57:00.001+05:30

package Fibonacci;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Fibonacci {

public static void main(String[] args) {
try {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("\nEnter FIbonaci Index:");
String input= reader.readLine();
int i = Integer.parseInt(input);
Fibo f = new Fibo();
int y = f.fibo(i);
System.out.println("Fibonaci number index "+i+" is "+y);

} catch (IOException ex) {
System.out.println("IO Exception Error");
}

}
}

class Fibo
{
public int fibo(int n)
{
if(n <=0)
return -1;
if(n == 1)
return 0;
if(n == 2)
return 1;
else
return (fibo(n-1)+fibo(n-2));
}
}

Assessing System Performance

2012-11-21T16:51:00.004+05:30

System/Application performance depends not just on the raw speed of the processor,but on the instruction set, choice of implementation language, efficiency of the compiler, and skill of the programming done to implement the application.

System Clock plays most important role in measuring system performance. Operations such as fetching instructions, decoding it, performing arithmetic operations and so on are governed by system clock. At most primitive level speed of clock is dictated by frequency pulse produced by clock. Clock pulse is measured in cycles per second or Hertz (Hz). 1 GHz processor means processor receives 1 billion instructions per second. This is called as clock rate or clock pulse.

The execution of an instruction involves a number of discrete steps, such as fetching the instruction from memory, decoding the various portions of the instruction, loading and storing data, and performing arithmetic and logical operations. Thus, most instructions on most processors require multiple clock cycles to complete. Some instructions may take only a few cycles, while others require dozens. In addition, when pipelining is used, multiple instructions are being executed simultaneously.Thus, a straight comparison of clock speeds on different processors does not tell the whole story about performance.

A processor is driven by a clock at constant execution rate at frequency f or time τ = 1/f .The instruction count, Ic, for a program is the number of machine instructions executed for that program until it runs to completion or for some defined time interval.

Hence, The processor time T needed to execute a given program can be expressed as

T = Ic* CPI * τ

Here, CPI is clock cycle per instructions. If all instructions required the same number of clock

cycles, then CPI would be a constant value for a processor. However, on any give processor, the number of clock cycles required varies for different types of instructions, such as load, store, branch, and so on. Let CPIi be the number of cycles required for instruction type i. and Ii be the number of executed instructions of type i for a given program. Then we can calculate an overall CPI as follows:

SUM(CPIi * Ii)

CPI = ----------------------

We can refine the formulation by recognizing that during the execution of an instruction, part of the work is done by the processor, and part of the time a word is being transferred to or from memory. In this latter case, the time to transfer depends on the memory cycle time, which may be greater than equal to the processor cycle time. We can rewrite the preceding equation as

T = Ic * [ p + (m * k)] * t

where p is the number of processor cycles needed to decode and execute the instruction, m is the number of memory references needed, and k is the ratio between memory cycle time and processor cycle time.

The five performance factors in the preceding equation (Ic, p, m, k, τ) are influenced by four system attributes:

1. The design of the instruction set (known as instruction set architecture),

2. Compiler technology (how effective the compiler is in producing an efficient machine language program from a high-level language program),

3. Processor implementation, and

4. Cache and memory hierarchy.

A common measure of performance for a processor is the rate at which instructions are executed, expressed as millions of instructions per second (MIPS), referred to as the MIPS rate. We can express the MIPS rate in terms of the clock rate

__________

CPI * 10^6

Stringifying the MACRO!!!!!!!

2012-08-03T01:37:00.004+05:30

Do you know that you can also stringify the MACRO?

Sometimes you want to convert a MACRO arguments into string constant. This is achieved by stringification of MACRO.

"Stringification" means turning a code fragment into a string constant whose contents are the text for the code fragment. For example, stringifying `foo (z)' results in `"foo (z)"'.

In the C & C++ preprocessor, stringification is an option available when macro arguments are substituted into the macro definition. In the body of the definition, when an argument name appears, the character `#' before the name specifies stringification of the corresponding actual argument when it is substituted at that point in the definition. The same argument may be substituted in other places in the definition without stringification if the argument name appears in those places with no `#'.

But note that there is no way to combine an argument with surrounding text and stringify it all together. Instead, you can write a series of adjacent string constants and stringified arguments. The preprocessor will replace the stringified arguments with string constants. The C compiler will then combine all the adjacent string constants into one long string.


Here is an example of a macro definition that uses stringification:




 #define WARN_IF(EXP) \

     do { if (EXP) \
             fprintf (stderr, "Warning: " #EXP "\n"); } \
     while (0)

All leading and trailing whitespace in text being stringified is ignored. 
Any sequence of whitespace in the middle of the text is converted to a single space in the stringified result. 
Comments are replaced by white space long before stringification happens, 
so they never appear in stringified text.
There is no way to convert a macro argument into a character constant.
If you want to stringify the result of expansion of a macro argument, you have to use two levels of macros.

Stringification in C involves more than putting double-quote characters around the fragment. The preprocessor backslash-escapes the quotes surrounding embedded string constants, and all backslashes within string and character constants, in order to get a valid C string constant with the proper contents. Thus, stringifying p = "foo\n"; results in "p = \"foo\\n\";". However, backslashes that are not inside string or character constants are not duplicated: `\n' by itself stringifies to "\n".


The following example prints the text [now is the time]

#define now then

#define is was

#define print(stuff) std::cout<<"["#stuff "]\n"

print(now is the time)

enum in C and C++

2012-07-13T17:22:00.004+05:30

The C/C++ enumeration syntax exists to support the use of human readable character names to support a specific list of available values for the specified variable. This is enabled in C and C++ as a set of named integer constants. This can be expressed as a C or C++ enumerated type "enum". Both C and C++ use the same enumeration syntax.

You could use enum as below.

        enum week { Mon=1, Tue, Wed, Thu, Fri Sat, Sun} days;

Here is a code snippets in C++ that define a variable of type enum.

#include <iostream>
using namespace std;

main()
{
   enum
   {
      monday, tuesday, wednesday, thursday, friday, saturday, sunday
   } day;

   day = wednesday;

   if(day == saturday || day == sunday)
      cout << "Day is a weekend day" << endl;
   else if(day == wednesday)
      cout << "Day is hump day - middle of the work week" << endl;
}

You can access enum members directly by writing

printf("%d",monday);

in C

or

cout<<monday;

in C++.

We can also create a enum type of which we can declare variables as and when desired:

#include <iostream>
using namespace std;

main()
{
   enum TEENS
   {
      thirteen = 10,
      fourteen,
      fifteen,
      sixteen,
      seventeen,
      eighteen,
      nineteen
   } ;

   TEENS teen = seventeen;

   if(teen == seventeen)
      cout << seventeen << endl;
}

#include <iostream>

using namespace std;

main()

{

typedef enum

{

thirteen = 10,

fourteen,

fifteen,

sixteen,

seventeen,

eighteen,

nineteen

} TEENS;

TEENS teen = seventeen;

if(teen == seventeen)

cout << seventeen << endl;

}

Now question is why to prefer enum over #define.

Here are few reasons :

1. Prefer Enums Over #define Macros When You Need a Fixed Set of Values

#define JAN 1
#define FEB 2
//...
#define DEC 12

Enum types are a significantly better choice:

 //file enums.h
enum Months {
//a list of enumerators:
Jan,
Feb,
//...
Dec };
enum Days {
Sun,
Mon,
//...
};

One more point to note is that C++ compiler has strong type check for enum where as C compiler doesnt.

Here in our example below:

#include <stdio.h>
//using namespace std;

int main()
{
   typedef enum
   {
      thirteen = 10,
      fourteen,
      fifteen,
      sixteen,
      seventeen,
      eighteen,
      nineteen
   } TEENS;

   TEENS teen=10;
      printf("%d\n%d",seventeen,teen);
        return 0;
}

we are directly assigning 10 to teen and C compiler compiles it without giving an error and gives output

where as in C++ with similar code:


#include <iostream>
using namespace std;

int main()
{
   typedef enum
   {
      thirteen = 10,
      fourteen,
      fifteen,
      sixteen,
      seventeen,
      eighteen,
      nineteen
   } TEENS;

   TEENS teen=10;
   cout<<seventeen<<teen;
   return 0;
}

gives error :

enum.cpp:17: error: invalid conversion from int to main()::TEENS

With C++ Compiler, strong type check gives much advantage. The compiler checks that an enum is always assigned a valid value (one of the enumerators in the enum's definition and no other). Enum types behave like any other built-in type so you can use them to overload functions:

#include enums.h

bool func(Months month); //1

bool func(Days day); //2

void main() {

Days day = Sun; //Type Safety. Mind that day = 1 is illegal

Months month = Feb;

bool b = func(day); // func() #1 is called

b = func(month); //now func() #2 is called

}

This feature also eliminates silly mistakes like this:

bool b= func(50); //If we used #defines, this would pass unnoticed.

//Enums ensure that this mistake is detected at

//compile time

2. C++ enums are very efficient because they are automatically converted by the compiler to plain ints. Furthermore, an enum in C++ needn't be identical in size to sizeof(int). As a result, the compiler may optimize memory usage by storing the enumerators list in units smaller than int, e.g., short or char. There is also the possibility of storing the enum's value on a machine register, which may considerably increase performance even more.

Do you know about #pragma pack() ?

2012-07-11T18:07:00.001+05:30

Pragma directive (#pragma)

This directive is used to specify diverse options to the compiler. These options are specific for the platform and the compiler you use. Consult the manual or the reference of your compiler for more information on the possible parameters that you can define with #pragma. If the compiler does not support a specific argument for #pragma, it is ignored - no error is generated.

Basically the compiler unless otherwise directed will line up structure members on

2 byte or 4 byte boundaries - this makes it easier and faster for the processor to handle.

So the structure contains secret padding bytes to make this happen.

The pragma pack directive allows you to change this alignment scheme.

Some things (particularly in relation to hardware) do not have the luxury to waste bytes like

this and they send their data in an exact fit.

This means that it is not wise to read data from a hardware device directly into a normal structure.

If you have want to read data that is an exact fit into a structure - you can tell the compiler

to make the structure an exact fit;

#pragma pack(push, 1) // exact fit - no padding
struct MyStruct
{
  char b; 
  int a; 
  int array[2];
};
#pragma pack(pop) //back to whatever the previous packing mode was

Without the pragma directive, the size of the structure is 16 bytes - with the packing of 1 - the size is 13 bytes.

Preprocessor directives : #ifdef, #ifndef, #if, #endif, #else and #elif

2012-07-11T12:04:00.000+05:30

Conditional inclusions (#ifdef, #ifndef, #if, #endif, #else and #elif)

These directives allow to include or discard part of the code of a program if a certain condition is met.

#ifdef allows a section of a program to be compiled only if the macro that is specified as the parameter has been defined, no matter which its value is. For example:

1
2
3

#ifdef TABLE_SIZE
int table[TABLE_SIZE];
#endif

In this case, the line of code int table[TABLE_SIZE]; is only compiled if TABLE_SIZE was previously defined with#define, independently of its value. If it was not defined, that line will not be included in the program compilation.

#ifndef serves for the exact opposite: the code between #ifndef and #endif directives is only compiled if the specified identifier has not been previously defined. For example:

#ifndef TABLE_SIZE
#define TABLE_SIZE 100
#endif
int table[TABLE_SIZE];

In this case, if when arriving at this piece of code, the TABLE_SIZE macro has not been defined yet, it would be defined to a value of 100. If it already existed it would keep its previous value since the #define directive would not be executed.

The #if, #else and #elif (i.e., "else if") directives serve to specify some condition to be met in order for the portion of code they surround to be compiled. The condition that follows #if or #elif can only evaluate constant expressions, including macro expressions. For example:

#if TABLE_SIZE>200
#undef TABLE_SIZE
#define TABLE_SIZE 200
 
#elif TABLE_SIZE<50
#undef TABLE_SIZE
#define TABLE_SIZE 50
 
#else
#undef TABLE_SIZE
#define TABLE_SIZE 100
#endif
 
int table[TABLE_SIZE];

Notice how the whole structure of #if, #elif and #else chained directives ends with #endif.

The behavior of #ifdef and #ifndef can also be achieved by using the special operators defined and !definedrespectively in any #if or #elif directive:

#if !defined TABLE_SIZE
#define TABLE_SIZE 100
#elif defined ARRAY_SIZE
#define TABLE_SIZE ARRAY_SIZE
int table[TABLE_SIZE];
#endif

Line control (#line)

When we compile a program and some error happens during the compiling process, the compiler shows an error message with references to the name of the file where the error happened and a line number, so it is easier to find the code generating the error.

The #line directive allows us to control both things, the line numbers within the code files as well as the file name that we want that appears when an error takes place. Its format is:

#line number "filename"

Where number is the new line number that will be assigned to the next code line. The line numbers of successive lines will be increased one by one from this point on.

"filename" is an optional parameter that allows to redefine the file name that will be shown. For example:

1
2

#line 20 "assigning variable"
int a?;

This code will generate an error that will be shown as error in file "assigning variable", line 20.

Error directive (#error)

This directive aborts the compilation process when it is found, generating a compilation the error that can be specified as its parameter:

1
2
3

#ifndef __cplusplus
#error A C++ compiler is required!
#endif

This example aborts the compilation process if the macro name __cplusplus is not defined (this macro name is defined by default in all C++ compilers).

Preprocessor directives : #define and #undef

2012-07-11T11:36:00.001+05:30

Preprocessor directives are lines included in the code of our programs that are not program statements but directives for the preprocessor. These lines are always preceded by a hash sign (#). The preprocessor is executed before the actual compilation of code begins, therefore the preprocessor digests all these directives before any code is generated by the statements.

These preprocessor directives extend only across a single line of code. As soon as a newline character is found, the preprocessor directive is considered to end. No semicolon (;) is expected at the end of a preprocessor directive. The only way a preprocessor directive can extend through more than one line is by preceding the newline character at the end of the line by a backslash (\).

macro definitions (#define, #undef)

To define preprocessor macros we can use #define. Its format is:

#define identifier replacement
When the preprocessor encounters this directive, it replaces any occurrence of identifier in the rest of the code by replacement. This replacement can be an expression, a statement, a block or simply anything. The preprocessor does not understand C++, it simply replaces any occurrence of identifier by replacement.

1
2
3

#define TABLE_SIZE 100
int table1[TABLE_SIZE];
int table2[TABLE_SIZE];

After the preprocessor has replaced TABLE_SIZE, the code becomes equivalent to:

1
2

int table1[100];
int table2[100];

This use of #define as constant definer is already known by us from previous tutorials, but #define can work also with parameters to define function macros:

#define getmax(a,b) a>b?a:b

This would replace any occurrence of getmax followed by two arguments by the replacement expression, but also replacing each argument by its identifier, exactly as you would expect if it was a function:

// function macro
#include <iostream>
using namespace std;

#define getmax(a,b) ((a)>(b)?(a):(b))

int main()
{
  int x=5, y;
  y= getmax(x,2);
  cout << y << endl;
  cout << getmax(7,x) << endl;
  return 0;
}

5
7

Defined macros are not affected by block structure. A macro lasts until it is undefined with the #undef preprocessor directive:

#define TABLE_SIZE 100
int table1[TABLE_SIZE];
#undef TABLE_SIZE
#define TABLE_SIZE 200
int table2[TABLE_SIZE];

This would generate the same code as:

1
2

int table1[100];
int table2[200];

Function macro definitions accept two special operators (# and ##) in the replacement sequence:
If the operator # is used before a parameter is used in the replacement sequence, that parameter is replaced by a string literal (as if it were enclosed between double quotes)

1
2

#define str(x) #x
cout << str(test);

This would be translated into:

cout << "test";

The operator ## concatenates two arguments leaving no blank spaces between them:

1
2

#define glue(a,b) a ## b
glue(c,out) << "test";

This would also be translated into:

cout << "test";

Because preprocessor replacements happen before any C++ syntax check, macro definitions can be a tricky feature, but be careful: code that relies heavily on complicated macros may seem obscure to other programmers, since the syntax they expect is on many occasions different from the regular expressions programmers expect in C.

Methodology to crack pattern problems like constructing a pyramid of stars or diamond made up of stars.

2012-06-28T16:39:00.000+05:30

Have you wondered how to crack problems like generating patterns from C code or Java code ?? Here, I am presenting a methodology to crack simple pattern problems.

Write an algorithm to generate following pattern:
*
* *
* *
* *
*

for n=any odd number say 5.

To understand the behavior of pattern put them inside grid a follows:

0			*
1		*		*
2	*				*
3		*		*
4			*

Now we will check what trend above pattern is following. On close observation we find out that

upper left edge of pattern follows :
print * if i<=2 and j<=2 and i+j=2

upper right edge of pattern follows :
print * if i<=2 and j>=2 and j-i=2

lower left edge of pattern follows :
print * if i>=2 and j<=2 and i-j=2

upper left edge of pattern follows :
print * if i>=2 and j>=2 and i+j=6

Now following code-snippets can be written to generate above pattern:

for(j=0;j<n;j++)
{
for(i=0;i<n;i++)
{
if((i<=n/2 && j<=n/2 && i+j==n/2)||(i<=n/2 && j>=n/2 && j-i==n/2)||(i>=n/2 && j<=n/2 && i-j==n/2)||(i>=n/2&& j>=n/2 && i+j==((n-1)/2)*3))
{
printf("*");
}
else
printf(" ");
}
printf("\n");
}

Hope you have understood essence of pattern generation. As a assignment, you can generate following pattern :

0			*
1		*	*	*
2	*	*	*	*	*

main( ) function explained

2012-06-18T18:19:00.001+05:30

A C program starts execution with a function called main( ). The prototype for the main function is

int main(int argc , char **argv)

where argc is the number of command line arguments and argv is an array of pointers to the arguments.

When a C program is executed by the kernel - by one of the exec functions, a special start up routine is called before the main function is called. The executable program file specifies this routine as the starting address of the program; this is set up the link editor when it is invoked by C compiler. This start up routine takes values from the kernel - the command line arguments and the environment and sets this up so that main function is called.

A note about exec function:

When a process calls the exec functions, that process is completely replaced by a new program and the new program starts executing at its main function. The process ID doesn't change across exec because a new process is not created; exec mere replaces the current process - its text, data, heap and stack segments with a brand new program from disk.

Signal Handling in C

2012-06-18T13:33:00.002+05:30

Signals are ways by which a process notify that some conditon(s) has/have occurred. For example divding by zero or segmentation fault are some of events that occurr and it is required to be notified by the process.

There are three ways to handle signals:

1. Ignore the signal, though this action is not recommended for signals related with hardware actions such as referncing memory outside address space of memory etc.

2. Let default action takes place.

3. Provide a function that gets called as soon as some signal occurrs. This kind of function is known as signal handler.

Note: The signals SIGKILL and SIGSTOP cannot be caught or ignored.

If the signal signum is delivered to the process, then one of the following happens:

       *a* If the disposition is set to SIG_IGN, then the signal is ignored.

       *b* If the disposition is set to SIG_DFL, then the default action associated with the signal (see signal(7)) occurs.

       *c* If the disposition is set to a function, then first either the disposition is reset to SIG_DFL, or the signal is blocked and then handler is called with argument signum. If invocation of the handler caused the signal to be blocked, then the signal is unblocked upon return from the handler.

1. Ignoring the signal:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/wait.h>

int main(int argc, char **argv)
{
        if(signal(SIGINT,SIG_IGN)==SIG_ERR)
        {
                perror("signal error");
        }
        while(1)
        {
                printf("\nHello!! You cant terminate me by pressing ctrl-C !! ;) \n");
         }
        return 0;
}

2. Handling the signal

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/wait.h>
int flag=0;
void sighandler(int signum)
{
        printf("\nSignal Handled ....\n Exiting...\n");
        flag=1;
}

int main(int argc, char **argv)
{
        if(signal(SIGINT,sighandler)==SIG_ERR)
        {
                perror("signal error");
        }
        while(flag!=1)
        {
                printf("\nHello!! Press ctrl-C to be caught by Handler!! ;) \n");
        //      sleep(1);
        }
        return 0;
}

3. If we dont state signal( ) function or write SIG_DFL instead of SIG_IGN then default action takes place.

Error Hadling in C using linux system calls

2012-06-18T12:53:00.001+05:30

C being a system programming language allows you handle error at lower levels or system levels. Most functions return -1 or NULL on error and set errno with an error code which is a global variable defined in #include<errno.h>.

As a good C programmer, we can always check errors and take appropriate actions as and when required. As a good practice, developer should set errno to 0 at the time of initialization of the program. A value of 0 indicates that there is no error in the program.

There are two functions defined in C to get error messages associated with errno .

1. perror( string ): perror return text message containing string passed to it as an argument followed by colon followed by textual message associated with an errno value.

2. strerror(int errnum ): It returns pointer to textual represent of current errno value.

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main(int argc,char **argv)
{
        fprintf(stderr,"EACCES:%s\n",strerror(EACCES));

        errno=ENOENT;
        perror(argv[0]);
        return 0;
}

Steps to write a UDP client (Unicast).

2012-06-08T13:33:00.001+05:30

1. Declare all necessary variables such as buffer, socket descriptor, socket address structure etc.
2. Now Configure socket API with proper parameters.
                s=socket(AF_INET,SOCK_DGRAM,0)
3. Then configure socket address with proper assignments
saddr.sin_family=AF_INET
saddr.sin_port=htons(PORT)
4. Then check for address format and convert it into numeric format.
               if(inet_pton(AF_INET,argv[1],&saddr.sin_addr)<=0)
             {
                   printf("Error. Invalid IP adress\n");
                   exit(0);
             }

5. Then send request to server by using buffer
             if(sendto(s,buffer,strlen(buffer),0,(struct sockaddr*)&saddr,sizeof(sadd))<0)
   {
   printf("\n Send Error");
   exit(0);
   }
6. After sending buffer request , i waits for some receiving data.
printf("\nWaiting for response...\n");
             n=recvfrom(s,buffer,sizeof(buffer)-1,0,NULL,NULL);
             if(n<0)
            {
                  printf("\n Recieve error\n");
              exit(0);
          }

7. Close Socket.
            close(s);
Full program is as follows:

#define PORT 1300
int main(int argc, char *argv[])
{
        int s,n;
        char buffer[100];

        struct sockaddr_in saddr;

        if(argc!=2)
        {
                printf("Usage::<%s><Serv_IP>\n",argv[0]);
                exit(0);
        }
        s=socket(AF_INET,SOCK_DGRAM,0);
        if(s<0)
        {
                printf("Socket Error");
                exit(0);
        }

        saddr.sin_family=AF_INET;
        saddr.sin_port=htons(PORT);

        if(inet_pton(AF_INET,argv[1],&saddr.sin_addr)<=0)
        {
                printf("Error. Invalid IP adress\n");
                exit(0);
        }

        strcpy(buffer,"Hello Server!! I am Client !!");

        printf("Sending request to server %s\n",argv[1]);
        if(sendto(s,buffer,strlen(buffer),0,(struct sockaddr*)&saddr,sizeof(saddr))<0)
        {
                printf("\nSend error\n");
                exit(0);
        }

        printf("\nWaiting for response...\n");
        n=recvfrom(s,buffer,sizeof(buffer)-1,0,NULL,NULL);
        if(n<0)
        {
                printf("\n Recieve error\n");
                exit(0);
        }

        buffer[n]=0;
        printf("\nReply from server %s is %s\n",argv[1],buffer);
        close(s);
        return 0;
}

Write a C program that will write input into a file, then it will return frequency of each letter occurred in the file.

2012-05-16T15:42:00.003+05:30

Underlying Concept: File Handling

Note: Press CTRL-D for taking EOF as input

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

int main()

{

        FILE *f1,*f2;

        char ch,bh;

        printf("\n write to file INPUT.txt:\n");

        f1=fopen("FREQUENCY.txt","w");

        while((ch=getchar())!=EOF)

                putc(ch,f1);

        fclose(f1);

    int n=0;

    f2=fopen("histogram.txt","w");

    unsigned char r;

    printf("\n\n");

    for(r=97;r<122;r++)

{

        n=0;

        if(r%5==0)

            printf("\n");

        f1=fopen("FREQUENCY.txt","r");

        while((ch=getc(f1))!=EOF)

{

            if(ch==r)

                n++;

}

            printf(" Frequency of %c is %d\t",r,n);

            fprintf(f2,"%d",n);

            fprintf(f2,"\n");

        fclose(f1);

}

    fclose(f2);

    return 0;

}

Write a C program to generate a list and divide into two sublist one contating elements at odd index and other elements at even index.

2012-05-16T15:33:00.003+05:30

Underlying concept to demonstrate: Self-referential structure, linked list.

#include<stdio.h>
#include<stdlib.h>

struct node
{
        int data;
        struct node *next;
};
typedef struct node LL;

void display(LL *p)
{

        printf("\n The linked list is: ");

        while(p!=NULL)
        {
                printf(" %d",p->data);
                p=p->next;
        }
}

void insert(LL **head,int n)
{
        LL *temp,*current;
        temp=(LL *)malloc(sizeof(LL));
        temp->data=n;
        temp->next=NULL;
        if(*head==NULL)
                        *head=temp;
        else
                {
                        current=*head;
                        while(current->next!=NULL)
                                current=current->next;
                        current->next=temp;
                }
}

int main()
{
        LL *head,*odd,*even;
        head=NULL;
        odd=NULL;
        even=NULL;
        int num;
        printf("\n Linked list:\n");
        do
        {
                printf("\n Enter the no. to insert(Enter -ve to stop inserting):");
                scanf("%d",&num);
        if(num<0)
            break;
                insert(&head,num);
        }while(1);

        display(head);
        LL *temp;
    temp=head;
    int i=0;
    while(temp!=NULL)
    {
        i++;
        if(i%2==0)
            insert(&even,temp->data);
        else
                insert(&odd,temp->data);
        temp=temp->next;
    }

    printf("\n Sub list with elements having odd index:");
    display(odd);
    printf("\n Sub list with elements having even index:");
    display(even);
    return 0;
}

Write a C program to reverse a substring of a string without using any library function.

2012-05-16T15:29:00.004+05:30

Underlying Concept: String manipulation

#include<stdio.h>
#include<stdlib.h>
int sub_reverse(char *s,char *r,char *t)
{
    int i=0;
    while(s[i]!=0)
    {
        if(s[i]==r[0])
            break;
        i++;
    }
    char temp;
    while(s<t)
    {
        temp=*s;
        *s=*t;
        *t=temp;
        s++;
        t--;
    }
}

int main()
{
    char *string,*sub,*end;
    unsigned u,pos1,pos2;
    printf("\n enter size of string:");
    scanf("%u",&u);
    string=(char *)malloc(u*sizeof(char));
    printf("\n enter the string:");
    scanf("%s",string);
    printf("\n What is the position of first character of substring:");
    scanf("%u",&pos1);
    printf("\n What is the position of last character of substring:");
    scanf("%u",&pos2);
    sub=string+pos1;
    end=string+pos2;
    sub_reverse(string,sub,end);
    printf("\nNew string is:%s",string);
    return 0;
}

Write a C program to generate all possible permutation of a string.

2012-05-16T15:16:00.005+05:30

Underlying concept: Recursion
Assignment: Generate all possible Combinations of a string (Its to remind you that combination is different from permutation)

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int cnt=0;
void permutate(char *cut,char *c)
{
    char d,keep[20];
    int i,j;
    strcpy(keep,cut);
    int len=strlen(cut);
    d=c[len];
    if(d=='\0')
    {
        printf("%d.%s\n*****\n",++cnt,cut);
        return ;
    }

    for(i=len;i>=0;--i)
    {
        for(j=len;j>=i;j--)
            cut[j+1]=cut[j];
        cut[++j]=d;
        permutate(cut,c);
        strcpy(cut,keep);
    }


}


int main()
{
    char *c,*cut;
    int n;
    printf("\n Enter n:");
    scanf("%d",&n);
    c=(char*)malloc(n*sizeof(char));
    cut=(char*)malloc(n*sizeof(char));
    printf("Enter the string:");
    scanf("%s",c);
    cut[0]=c[0];
    cut[1]='\0';
    permutate(cut,c);
    return 0;
}