IPL 2013

IPL 2013 Dates: 3 April to 26 May, 2013

The 2013 Indian Premier League season, abbreviated as IPL 6 or the IPL 2013, will be the sixth season of the Indian Premier League.

IPL Committee has announced the dates of IPL 6. The tournament will begin on April 3, 2013 and the final match of IPL 2013 will be played on Sunday May 26, 2013.

The opening and closing ceremonies, and the opening and final matches will be played at the Eden Gardens, Kolkata as Kolkata Knight Riders' (KKR) won in IPL 5.

IPL 6 Schedule 2013

	Match	Date	Time	Team1	Team2
.	1	3rd April	8 PM	Kolkata Knight Riders	Delhi Daredevils
.	2	4th April	8 PM	Royal Challengers Bangalore	Mumbai Indians
.	3	5th April	8 PM	Hyderabad Sunrisers	Pune Warriors India
.	4	6th April	4 PM	Delhi Daredevils	Rajasthan Royals
.	5	6th April	8 PM	Chennai Super Kings	Mumbai Indians
.	6	7th April	4 PM	Pune Warriors India	Kings XI Pinjab
.	7	7th April	8 PM	Hyderabad Sunrisers	Royal Challengers Bangalore
.	8	8th April	8 PM	Rajasthan Royals	Kolkata Knight Riders
.	9	9th April	8 PM	Mumbai Indians	Delhi Daredevils
.	10	10th April	8 PM	Kings XI Punjab	Chennai Super Kings
.	11	11th April	4 PM	Royal Challengers Bangalore	Kolkata Knight Riders
.	12	11th April	8 PM	Pune Warriors India	Rajasthan Royals
.	13	12th April	8 PM	Delhi Daredevils	Hyderabad Sunrisers
.	14	13th April	4 PM	Mumbai Indians	Pune Warriors India
.	15	13th April	8 PM	Chennai Super Kings	Royal Challengers Bangalore
.	16	14th April	4 PM	Kolkata Knight Riders	Hyderabad Sunrisers
.	17	14th April	8 PM	Rajasthan Royals	Kings XI Pinjab
.	18	15th April	8 PM	Chennai Super Kings	Pune Warriors India
.	19	16th April	4 PM	Kings XI Punjab	Kolkata Knight Riders
.	20	16th April	8 PM	Royal Challengers Bangalore	Delhi Daredevils
.	21	17th April	4 PM	Pune Warriors India	Hyderabad Sunrisers
.	22	17th April	8 PM	Rajasthan Royals	Mumbai Indians
.	23	18th April	8 PM	Delhi Daredevils	Chennai Super Kings
.	24	19th April	8 PM	Hyderabad Sunrisers	Kings XI Pinjab
.	25	20th April	4 PM	Kolkata Knight Riders	Chennai Super Kings
.	26	20th April	8 PM	Royal Challengers Bangalore	Rajasthan Royals
.	27	21st April	4 PM	Delhi Daredevils	Mumbai Indians
.	28	21st April	8 PM	Kings XI Punjab	Pune Warriors India
.	29	22nd April	8 PM	Chennai Super Kings	Rajasthan Royals
.	30	23rd April	4 PM	Royal Challengers Bangalore	Pune Warriors India
.	31	23rd April	8 PM	Kings XI Punjab	Delhi Daredevils
.	32	24th April	8 PM	Kolkata Knight Riders	Mumbai Indians
.	33	25th April	8 PM	Chennai Super Kings	Hyderabad Sunrisers
.	34	26th April	8 PM	Kolkata Knight Riders	Kings XI Pinjab
.	35	27th April	4 PM	Rajasthan Royals	Hyderabad Sunrisers
.	36	27th April	8 PM	Mumbai Indians	Royal Challengers Bangalore
.	37	28th April	4 PM	Chennai Super Kings	Kolkata Knight Riders
.	38	28th April	8 PM	Delhi Daredevils	Pune Warriors India
.	39	29th April	4 PM	Rajasthan Royals	Royal Challengers Bangalore
.	40	29th April	8 PM	Mumbai Indians	Kings XI Pinjab
.	41	30th April	8 PM	Pune Warriors India	Chennai Super Kings
.	42	1st May	4 PM	Hyderabad Sunrisers	Mumbai Indians
.	43	1st May	8 PM	Delhi Daredevils	Kolkata Knight Riders
.	44	2nd May	4 PM	Chennai Super Kings	Kings XI Pinjab
.	45	2nd May	8 PM	Pune Warriors India	Royal Challengers Bangalore
.	46	3rd May	8 PM	Kolkata Knight Riders	Rajasthan Royals
.	47	4th May	4 PM	Hyderabad Sunrisers	Delhi Daredevils
.	48	4th May	8 PM	Royal Challengers Bangalore	Kings XI Pinjab
.	49	5th May	4 PM	Mumbai Indians	Chennai Super Kings
.	50	5th May	8 PM	Rajasthan Royals	Pune Warriors India
.	51	6th May	8 PM	Royal Challengers Bangalore	Hyderabad Sunrisers
.	52	7th May	4 PM	Rajasthan Royals	Delhi Daredevils
.	53	7th May	8 PM	Mumbai Indians	Kolkata Knight Riders
.	54	8th May	8 PM	Hyderabad Sunrisers	Chennai Super Kings
.	55	9th May	4 PM	Kings XI Punjab	Rajasthan Royals
.	56	9th May	8 PM	Pune Warriors India	Kolkata Knight Riders
.	57	10th May	8 PM	Delhi Daredevils	Royal Challengers Bangalore
.	58	11th May	4 PM	Pune Warriors India	Mumbai Indians
.	59	11th May	8 PM	Kings XI Punjab	Hyderabad Sunrisers
.	60	12th May	4 PM	Kolkata Knight Riders	Royal Challengers Bangalore
.	61	12th May	8 PM	Rajasthan Royals	Chennai Super Kings
.	62	13th May	4 PM	Delhi Daredevils	Kings XI Pinjab
.	63	13th May	8 PM	Mumbai Indians	Hyderabad Sunrisers
.	64	14th MAy	8 PM	Kolkata Knight Riders	Pune Warriors India
.	65	15th May	4 PM	Chennai Super Kings	Delhi Daredevils
.	66	15th May	8 PM	Mumbai Indians	Rajasthan Royals
.	67	16th May	8 PM	Kings XI Punjab	Royal Challengers Bangalore
.	68	17th May	8 PM	Hyderabad Sunrisers	Rajasthan Royals
.	69	18th May	4 PM	Kings XI Punjab	Mumbai Indians
.	70	18th May	8 PM	Pune Warriors India	Delhi Daredevils
.	71	19th May	4 PM	Royal Challengers Bangalore	Chennai Super Kings
.	72	19th May	8 PM	Hyderabad Sunrisers	Kolkata Knight Riders
.	Qualifier 1	21st May	8 PM	First Placed	Second Placed
.	Eliminator	22nd May	8 PM	Third Placed	Fourth Placed
.	Qualifier 2	24th May	8 PM	Winner of Eliminator	Loser of Qialifier 1
.	Final	26th May	8 PM	Winner of Qualifier 1	Winner of Qua

C - Scope Rules

A scope in any programming is a region of the program where a defined variable can have its existence and beyond that variable can not be accessed. There are three places where variables can be declared in C programming language:

1. Inside a function or a block which is called local variables,
2. Outside of all functions which is called global variables.
3. In the definition of function parameters which is called formal parameters.

Let us explain what are local and global variables and formal parameters.

Read more...

Local Variables
Global Variables
Formal Parameters
Initializing Local and Global Variables

Initializing Local and Global Variables

When a local variable is defined, it is not initialized by the system, you must initialize it yourself. Global variables are initialized automatically by the system when you define them as follows:

Data Type	Initial Default Value
int	0
char	'\0'
float	0
double	0
pointer	NULL

It is a good programming practice to initialize variables properly otherwise, your program may produce unexpected results because uninitialized variables will take some garbage value already available at its memory location.

Formal Parameters

A function parameters, formal parameters, are treated as local variables with-in that function and they will take preference over the global variables. Following is an example: 

#include <stdio.h>
 
/* global variable declaration */
int a = 20;
 
int main ()
{
  /* local variable declaration in main function */
  int a = 10;
  int b = 20;
  int c = 0;

  printf ("value of a in main() = %d\n",  a);
  c = sum( a, b);
  printf ("value of c in main() = %d\n",  c);

  return 0;
}

/* function to add two integers */
int sum(int a, int b)
{
    printf ("value of a in sum() = %d\n",  a);
    printf ("value of b in sum() = %d\n",  b);

    return a + b;
}

When the above code is compiled and executed, it produces following result:

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

Global Variables

Global variables are defined outside of a function, usually on top of the program. The global variables will hold their value throughout the lifetime of your program and they can be accessed inside any of the functions defined for the program.

A global variable can be accessed by any function. That is, a global variable is available for use throughout your entire program after its declaration. Following is the example using global and local variables:

#include <stdio.h>
 
/* global variable declaration */
int g;
 
int main ()
{
  /* local variable declaration */
  int a, b;
 
  /* actual initialization */
  a = 10;
  b = 20;
  g = a + b;
 
  printf ("value of a = %d, b = %d and g = %d\n", a, b, g);
 
  return 0;
}

A program can have same name for local and global variables but value of local variable inside a function will take preference. Following is an example:

#include <stdio.h>
 
/* global variable declaration */
int g = 20;
 
int main ()
{
  /* local variable declaration */
  int g = 10;
 
  printf ("value of g = %d\n",  g);
 
  return 0;
}

When the above code is compiled and executed, it produces following result:

value of g = 10

Local Variables

Variables that are declared inside a function or block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. Following is the example using local variables. Here all the variables a, b and c are local to main() function.

#include <stdio.h>
 
int main ()
{
  /* local variable declaration */
  int a, b;
  int c;
 
  /* actual initialization */
  a = 10;
  b = 20;
  c = a + b;
 
  printf ("value of a = %d, b = %d and c = %d\n", a, b, c);
 
  return 0;
}

Function call by reference in C

The call by reference method of passing arguments to a function copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the passed argument.

To pass the value by reference, argument pointers are passed to the functions just like any other value. So accordingly you need to declare the function parameters as pointer types as in the following function swap(), which exchanges the values of the two integer variables pointed to by its arguments.

/* function definition to swap the values */
void swap(int *x, int *y)
{
   int temp;
   temp = *x;    /* save the value at address x */
   *x = *y;      /* put y into x */
   *y = temp;    /* put temp into y */
  
   return;
}

For now, let us call the function swap() by passing values by reference as in the following example 

#include <stdio.h>
 
/* function declaration */
void swap(int *x, int *y);
 
int main ()
{
   /* local variable definition */
   int a = 100;
   int b = 200;
 
   printf("Before swap, value of a : %d\n", a );
   printf("Before swap, value of b : %d\n", b );
 
   /* calling a function to swap the values.
    * &a indicates pointer to a ie. address of variable a and 
    * &b indicates pointer to b ie. address of variable b.
   */
   swap(&a, &b);
 
   printf("After swap, value of a : %d\n", a );
   printf("After swap, value of b : %d\n", b );
 
   return 0;
}

Let us put above code in a single C file, compile and execute it, it will produce following result: 

Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :200
After swap, value of b :100

Which shows that the change has reflected outside of the function as well unlike call by value where changes does not reflect outside of the function. 

Function Arguments

If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

The formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways that arguments can be passed to a function:

1. Call by value - This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument. 
2. Call by reference - This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.

By default, C uses call by value to pass arguments. In general, this means that code within a function cannot alter the arguments used to call the function and above mentioned example while calling max() function used the same method.

Function call by value in C

The call by value method of passing arguments to a function copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.

By default, C programming language uses call by value method to pass arguments. In general, this means that code within a function cannot alter the arguments used to call the function. Consider the function swap() definition as follows.

/* function definition to swap the values */
void swap(int x, int y)
{
   int temp;

   temp = x; /* save the value of x */
   x = y;    /* put y into x */
   y = temp; /* put temp into y */
  
   return;
}

Now let us call the function swap() by passing actual values as in the following example:

#include <stdio.h>
 
/* function declaration */
void swap(int x, int y);
 
int main ()
{
   /* local variable definition */
   int a = 100;
   int b = 200;
 
   printf("Before swap, value of a : %d\n", a );
   printf("Before swap, value of b : %d\n", b );
 
   /* calling a function to swap the values */
   swap(a, b);
 
   printf("After swap, value of a : %d\n", a );
   printf("After swap, value of b : %d\n", b );
 
   return 0;
}

Let us put above code in a single C file, compile and execute it, it will produce following result: 

Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200

Calling a Function

While creating a C function, you give a definition of what the function has to do. To use a function, you will have to call that function to perform the defined task.

When a program calls a function, program control is transferred to the called function. A called function performs defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns program control back to the main program.

To call a function you simply need to pass the required parameters along with function name and if function returns a value then you can store returned value. For example:

#include <stdio.h>
 
/* function declaration */
int max(int num1, int num2);
 
int main ()
{
   /* local variable definition */
   int a = 100;
   int b = 200;
   int ret;
 
   /* calling a function to get max value */
   ret = max(a, b);
 
   printf( "Max value is : %d\n", ret );
 
   return 0;
}
 
/* function returning the max between two numbers */
int max(int num1, int num2) 
{
   /* local variable declaration */
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

I kept max() function along with main() function and complied the source code. While running final executable, it would produce following result:

Max value is : 200

Function Declarations

A function declaration tells the compiler about a function name and how to call the function. The actual body of the function can be defined separately.

A function declaration has the following parts:

return_type function_name( parameter list );

For the above defined function max(), following is the function declaration: 

int max(int num1, int num2);

 
Parameter names are not important in function declaration only their type is required, so following is also valid declaration:

int max(int, int);

 
Function declaration is required when you define a function in one source file and you call that function in another file. In such case you should declare the function at the top of the file calling the function.

C - Functions

A function is a group of statements that together perform a task. Every C program has at least one function which is main(), and all the most trivial programs can define additional functions.

You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically the division usually is so each function performs a specific task.

A function declaration tells the compiler about a function's name, return type, and parameters. A function definition provides the actual body of the function.

The C standard library provides numerous built-in functions that your program can call. For example, function strcat() to concatenate two strings, function memcpy() to copy one memory location to another location and many more functions.

A function is known with various names like a method or a sub-routine or a procedure etc.

Defining a Function

The general form of a function definition in C programming language is as follows:

return_type function_name( parameter list )

{

   body of the function

}

A function definition in C programming language consists of a function header and a function body. Here are all the parts of a function:

·         Return Type: A function may return a value. The return_type is the data type of the value the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the keyword void.

·         Function Name: This is the actual name of the function. The function name and the parameter list together constitute the function signature.

·         Parameters: A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.

·         Function Body: The function body contains a collection of statements that define what the function does.

Example:
 
Following is the source code for a function called max(). This function takes two parameters num1 and num2 and returns the maximum between the two:

/* function returning the max between two numbers */
int max(int num1, int num2)
{
     /* local variable declaration */
     int result;

     if (num1 > num2)
         result = num1;
     else
         result = num2;

     return result;
}