What is a Resume?

The Aim of the Resume

Before we seek to find out the real aim of the resume, we need to define exactly what the resume is. As per Wikipedia, “A resume is a document used by individuals to present their background and skillsets. Résumés can be used for a variety of reasons but most often to secure new employment.” This basic definition is true to an extent as the resume is typically used to find a new job. However is preparing the resume as simple as presenting “their background and skillsets”? Is this enough to stand out from potentially hundreds of job seekers and get THE job?
There are so many aspects that make up a good resume and while a job seeker does need to present their background and skills, there are many other aspects that make up the perfect resume.
As a professional resume writer, I have broken down the three most important elements of preparing a professional resume. No matter if you’re an entry level job seeker or a high flying executive, the same rules apply.
Target the Reader:
It does not matter how much you like your resume. The most important thing is the reader likes your resume. After all, the reader is the only person that you need to impress. Knowing your audience is imperative when writing your resume. If you are applying for a corporate role your resume needs to give off a corporate feel. Fancy fonts and colors should be changed to bullet points and headings. Alternatively a graphic designer resume can be more creative with their resume as the target audience is a creative audience. Before you apply for any job you need to take a step back and imagine that you are the hiring manager and ask yourself the question “Is this resume targeted towards the role that I am applying for?”
Presenting a Professional Image:
First impressions are everything when it comes to hiring. Think about this. Imagine that you are sitting at home and your brother or sister tells you that they are coming over to introduce you to one of their friends who you have never met before. As the doorbell rings, you open the door to meet this new person for the very first time. Now imagine that when you open the door the person is standing there with a big spaghetti stain right in the middle of his shirt. Before you even shake the persons hand or introduce yourself you have already created a first impression of this person. The same goes for your resume. If a hiring manager opens your resume and sees a “spaghetti stain” right in the middle of your resume they will have created a first impression before reading a single word. In the world of job seeking, creating a professional image and positive first impression is the first hurdle you need to pass on your way to a new job. 

Highlighting Achievements and the Value Added Skills:
There is a huge difference between an average resume, a good resume and a great resume. Typically, what makes a great resume is being able to identify your key achievements and the value added skills (tangible and intangible) that you can bring to your next job. Where most people fail with their resume writing is that they concentrate too much on their daily duties and responsibilities (For example “I did this on a daily basis”) as opposed to creating more achievement statements which focus on how you have added value to the organization. Providing examples to back your statements up will give you an automatic edge over your competitors.

 www.cinterviews.com appreciates your contribution please mail us the questions you have to cinterviews.blogspot.com@gmail.com so that it will be useful to our job search community

Multidimensional Arrays in C Programming

 The array we used in the last example was a one dimensional array. Arrays can have more than one dimension, these arrays-of-arrays are called multidimensional arrays. They are very similar to standard arrays with the exception that they have multiple sets of square brackets after the array identifier. A two dimensional array can be though of as a grid of rows and columns.

#include <stdio.h> const int num_rows = 7; const int num_columns = 5; int main() { int box[num_rows][num_columns]; int row, column; for(row = 0; row < num_rows; row++) for(column = 0; column < num_columns; column++) box[row][column] = column + (row * num_columns); for(row = 0; row < num_rows; row++) { for(column = 0; column < num_columns; column++) { printf("%4d", box[row][column]); } printf("\n"); } return 0; }

This will produce following result:

   0   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  32  33  34

www.cinterviews.com appreciates your contribution please mail us the questions you have to cinterviews.blogspot.com@gmail.com so that it will be useful to our job search community

Arrays in C

1. Do array subscripts always start with zero?

Yes. If you have an array a[MAX] (in which MAX is some value known at compile time), the first element is a[0], and the last element is a[MAX-1]. This arrangement is different from what you would find in some other languages. In some languages, such as some versions of BASIC, the elements would be a[1] through a[MAX], and in other languages, such as Pascal, you can have it either way.
This variance can lead to some confusion. The "first element" in non-technical terms is the "zero'th" element according to its array index. If you're using spoken words, use "first" as the opposite of "last." If that's not precise enough, use pseudo-C. You might say, "The elements a sub one through a sub eight," or, "The second through ninth elements of a."
There's something you can do to try to fake array subscripts that start with one. Don't do it. The technique is described here only so that you'll know why not to use it.
Because pointers and arrays are almost identical, you might consider creating a pointer that would refer to the same elements as an array but would use indices that start with one. For example:

/* don't do this!!! */
int     a0[ MAX ];
int     *a1 = a0 - 1;   /* & a[ -1 ] */

Thus, the first element of a0 (if this worked, which it might not) would be the same as a1[1]. The last element of a0, a0[MAX-1], would be the same as a1[MAX]. There are two reasons why you shouldn't do this.
The first reason is that it might not work. According to the ANSI/ISO standard, it's undefined (which is a Bad Thing). The problem is that &a[-1] might not be a valid address; Your program might work all the time with some compilers, and some of the time with all compilers. Is that good enough?
The second reason not to do this is that it's not C-like. Part of learning C is to learn how array indices work. Part of reading (and maintaining) someone else's C code is being able to recognize common C idioms. If you do weird stuff like this, it'll be harder for people to understand your code. (It'll be harder for you to understand your own code, six months later.)

2. Is it valid to address one element beyond the end of an array?

It's valid to address it, but not to see what's there. (The really short answer is, "Yes, so don't worry about it.") With most compilers, if you say
int i, a[MAX], j;
then either i or j is at the part of memory just after the last element of the array. The way to see whether i or j follows the array is to compare their addresses with that of the element following the array. The way to say this in C is that either
& i == & a[ MAX ]
is true or
& a[ MAX ] == & j
is true. This isn't guaranteed; it's just the way it usually works. The point is, if you store something in a[MAX], you'll usually clobber something outside the a array. Even looking at the value of a[MAX] is technically against the rules, although it's not usually a problem. Why would you ever want to say &a[MAX]? There's a common idiom of going through every member of a loop using a pointer. Instead of

for ( i = 0; i < MAX; ++i )
{
        /* do something */;
}

C programmers often write this:

for ( p = a; p < & a[ MAX ]; ++p )
{
        /* do something */;
}

The kind of loop shown here is so common in existing C code that the C standard says it must work.

3. Can the sizeof operator be used to tell the size of an array passed to a function?

No. There's no way to tell, at runtime, how many elements are in an array parameter just by looking at the array parameter itself. Remember, passing an array to a function is exactly the same as passing a pointer to the first element. This is a Good Thing. It means that passing pointers and arrays to C functions is very efficient.
It also means that the programmer must use some mechanism to tell how big such an array is. There are two common ways to do that. The first method is to pass a count along with the array. This is what memcpy() does, for example:

char    source[ MAX ], dest[ MAX ];
/* ... */
memcpy( dest, source, MAX );

The second method is to have some convention about when the array ends. For example, a C "string" is just a pointer to the first character; the string is terminated by an ASCII NUL ('\0') character. This is also commonly done when you have an array of pointers; the last is the null pointer. Consider the following function, which takes an array of char*s. The last char* in the array is NULL; that's how the function knows when to stop.

void printMany( char *strings[] )
{
        int     i;
        i = 0;
        while ( strings[ i ] != NULL )
        {
             puts( strings[ i ] );
             ++i;
        }
}

Most C programmers would write this code a little more cryptically:

void  printMany( char *strings[] )
{
        while ( *strings )
        {
                puts( *strings++ );
        }
}

C programmers often use pointers rather than indices. You can't change the value of an array tag, but because strings is an array parameter, it's really the same as a pointer. That's why you can increment strings. Also,
while ( *strings )
means the same thing as
while ( *strings != NULL )
and the increment can be moved up into the call to puts().
If you document a function (if you write comments at the beginning, or if you write a "manual page" or a design document), it's important to describe how the function "knows" the size of the arrays passed to it. This description can be something simple, such as "null terminated," or "elephants has numElephants elements." (Or "arr should have 13 elements," if your code is written that way. Using hard coded numbers such as 13 or 64 or 1024 is not a great way to write C code, though.)

4. Is it better to use a pointer to navigate an array of values, or is it better to use a subscripted array name?

It's easier for a C compiler to generate good code for pointers than for subscripts.
Say that you have this:

/* X is some type */
X       a[ MAX ];       /* array */
X       *p;     /* pointer */
X       x;      /* element */
int     i;      /* index */

Here's one way to loop through all elements:

/* version (a) */
for ( i = 0; i < MAX; ++i )
{
        x = a[ i ];
        /* do something with x */
}

On the other hand, you could write the loop this way:

/* version (b) */
for ( p = a; p < & a[ MAX ]; ++p )
{
        x = *p;
        /* do something with x */
}

What's different between these two versions? The initialization and increment in the loop are the same. The comparison is about the same; more on that in a moment. The difference is between x=a[i] and x=*p. The first has to find the address of a[i]; to do that, it needs to multiply i by the size of an X and add it to the address of the first element of a. The second just has to go indirect on the p pointer. Indirection is fast; multiplication is relatively slow.
This is "micro efficiency." It might matter, it might not. If you're adding the elements of an array, or simply moving information from one place to another, much of the time in the loop will be spent just using the array index. If you do any I/O, or even call a function, each time through the loop, the relative cost of indexing will be insignificant.
Some multiplications are less expensive than others. If the size of an X is 1, the multiplication can be optimized away (1 times anything is the original anything). If the size of an X is a power of 2 (and it usually is if X is any of the built-in types), the multiplication can be optimized into a left shift. (It's like multiplying by 10 in base 10.)
What about computing &a[MAX] every time though the loop? That's part of the comparison in the pointer version. Isn't it as expensive computing a[i] each time? It's not, because &a[MAX] doesn't change during the loop. Any decent compiler will compute that, once, at the beginning of the loop, and use the same value each time. It's as if you had written this:

/* how the compiler implements version (b) */
X       *temp = & a[ MAX ];     /* optimization */
for ( p = a; p < temp; ++p )
{
        x = *p;
        /* do something with x */
}

This works only if the compiler can tell that a and MAX can't change in the middle of the loop. There are two other versions; both count down rather than up. That's no help for a task such as printing the elements of an array in order. It's fine for adding the values or something similar. The index version presumes that it's cheaper to compare a value with zero than to compare it with some arbitrary value:

/* version (c) */
for ( i = MAX - 1; i >= 0; --i )
{
        x = a[ i ];
        /* do something with x */
}

The pointer version makes the comparison simpler:

/* version (d) */
for ( p = & a[ MAX - 1 ]; p >= a; --p )
{
        x = *p;
        /* do something with x */
}

Code similar to that in version (d) is common, but not necessarily right. The loop ends only when p is less than a. That might not be possible.
The common wisdom would finish by saying, "Any decent optimizing compiler would generate the same code for all four versions." Unfortunately, there seems to be a lack of decent optimizing compilers in the world. A test program (in which the size of an X was not a power of 2 and in which the "do something" was trivial) was built with four very different compilers. Version (b) always ran much faster than version (a), sometimes twice as fast. Using pointers rather than indices made a big difference. (Clearly, all four compilers optimize &a[MAX] out of the loop.)
How about counting down rather than counting up? With two compilers, versions (c) and (d) were about the same as version (a); version (b) was the clear winner. (Maybe the comparison is cheaper, but decrementing is slower than incrementing?) With the other two compilers, version (c) was about the same as version (a) (indices are slow), but version (d) was slightly faster than version (b).
So if you want to write portable efficient code to navigate an array of values, using a pointer is faster than using subscripts. Use version (b); version (d) might not work, and even if it does, it might be compiled into slower code.
Most of the time, though, this is micro-optimizing. The "do something" in the loop is where most of the time is spent, usually. Too many C programmers are like half-sloppy carpenters; they sweep up the sawdust but leave a bunch of two-by-fours lying around.
 www.cinterviews.com appreciates your contribution please mail us the questions you have to cinterviews.blogspot.com@gmail.com so that it will be useful to our job search community

What Type of question to Prepare for C interviews

IF you are New to the Interviews Let me tell you one thing For C interviews only c is not asked c++ is also combined or some other things sql,gtk,linux,unix will be asked so atleast know the concept of oops when you are going for c interviews

Some people when you are not able to answer C the yask ok man on which you are confortable and they may proceed but be cautious you are going for negative mark.

Before going for interview please atleast read ones kernighan and ritche book one and try to solve all exercises
after that many websites are available for Faqs but be sure of basic interviews mainly people test basics

Make sure be prepared for this like questions at hr?


How do you rate your self in C and C++ at the scale of 10?....etc

c macro faqs

C macro faqs

Question1: What is the difference between a string copy (strcpy) and a memory copy (memcpy)? When should each be used?
Answer: The strcpy() function is designed to work exclusively with strings. It copies each byte of the source string to the destination string and stops when the terminating null character () has been moved. On the other hand, the memcpy () function is designed to work with any type of data. Because not all data ends with a null character, you must provide the memcpy () function with the number of bytes you want to copy from the source to the destination.

Question2: How can you check to see whether a symbol is defined?
Answer: You can use the #ifdef and #ifndef preprocessor directives to check whether a symbol has been defined
(#ifdef) or whether it has not been defined (#ifndef).

Question3: How do you override a defined macro?
Answer: You can use the #undef preprocessor directive to undefine (override) a previously defined macro.

Question4: What is #line used for?
Answer: The #line preprocessor directive is used to reset the values of the _ _LINE_ _ and _ _FILE_ _ symbols,
respectively. This directive is commonly used in fourth-generation languages that generate C language source files.

Question5: What is a pragma?
Answer :The #pragma preprocessor directive allows each compiler to implement compiler-specific features that can be turned on and off with the #pragma statement. For instance, your compiler might support a feature called loop optimization. This feature can be invoked as a command-line option or as a #pragma directive.

To implement this option using the #pragma directive, you would put the following line into your code:

#pragma loop_opt(on)
Conversely, you can turn off loop optimization by inserting the following line into your code:

Keywords:

c interview questions
c++ faq
faq on pointers in c
faq on arrays in c
faq videos
c tutorial
faqs on strings in c
steve summit
faq on pointers in c
faq on arrays in c
c++ faq
programming in c textbook
c tutorial
c programming resources
c language reference
cinterviews.com
c macro function
c macro
types of macros in c
macros in c geeksforgeeks
macros in c tutorialspoint
c define macro function
function-like macros in c
macro substitution in c
difference between strcpy() and memcpy with example
strcpy vs memcpy performance
replace strcpy with memcpy
c copy string using memcpy
difference between memcpy and memmove
memcpy in c
memcpy implementation
strcpy vs strncpy
how to solve undefined symbol error in c++
programming symbols list
undefined reference to c
programming symbols names
linker error undefined reference to function in c
symbols in computer science
what is the meaning of symbol in c
undefined reference to variable in c++
how do you override a defined macro
override macro
c override macro
c redefine macro
c macro expansion
using macros in c
gcc macro expansion
c macro string
program to draw a line in c
line in c
draw a line in c without graphics
c program to draw a circle
program to draw a line in computer graphics in c++
line function in computer graphics syntax
line() in c
rectangle function in computer graphics
pragma in c geeksforgeeks
what is pragma in c language
pragma pack in c
pragma in embedded c
pragma c
pragma in c structure padding
pragma once
gcc pragma

c faq questions

C faq questions

C interview question1:If we have declared an array as global in one file and we are using it in another file then why doesn't the sizeof operator works on an extern array?
Answer: An extern array is of incomplete type as it does not contain the size. Hence we cannot use sizeof operator, as it cannot get the size of the array declared in another file. To resolve this use any of one the following two solutions:
1. In the same file declare one more variable that holds the size of array. For example,

array.c
int arr[5] ;
int arrsz = sizeof ( arr ) ;
myprog.c
extern int arr[] ;
extern int arrsz ;

2. Define a macro which can be used in an array
declaration. For example,

myheader.h
#define SZ 5
array.c
#include "myheader.h"
int arr[SZ] ;
myprog.c
#include "myheader.h"
extern int arr[SZ] ;

C interview question2:How do I write printf( ) so that the width of a field can be specified at runtime?
Answer: This is shown in following code snippet.

main( )
{
int w, no ;
printf ( "Enter number and the width for the
number field:" ) ;
scanf ( "%d%d", &no, &w ) ;
printf ( "%*d", w, no ) ;
}

Here, an '*' in the format specifier in printf( ) indicates that an int value from the argument list should be used for the field width.

C interview question3:How to find the row and column dimension of a given 2-D array?
Answer: Whenever we initialize a 2-D array at the same place where it has been declared, it is not necessary to mention the row dimension of an array. The row and column dimensions of such an array can be determined programmatically as shown in following program.

void main( )
{
int a[][3] = { 0, 1, 2,9,-6, 8,7, 5, 44,23, 11,15 } ;
int c = sizeof ( a[0] ) / sizeof ( int ) ;
int r = ( sizeof ( a ) / sizeof ( int ) ) / c ;
int i, j ;
printf ( "\nRow: %d\nCol: %d\n", r, c ) ;
for ( i = 0 ; i < r ; i++ )
{
for ( j = 0 ; j < c ; j++ )
printf ( "%d ", a[i][j] ) ;
printf ( "\n" ) ;
}
}

C interview quesion4:What is access( ) function...
Answer:The access( ) function checks for the existence of a file and also determines whether it can be read,written to or executed. This function takes two arguments the filename and an integer indicating the access mode. The values 6, 4, 2, and 1 checks for read/write, read, write and execute permission of a given file, whereas value 0 checks whether the file exists or not. Following program demonstrates how we can use access( ) function to check if a given file exists.

#include
main( )
{
char fname[67] ;
printf ( "\nEnter name of file to open" ) ;
gets ( fname ) ;
if ( access ( fname, 0 ) != 0 )
{
printf ( "\nFile does not exist." ) ;
return ;
}
}
C interview question5:How do I convert a floating-point number to a string?
Answer: Use function gcvt( ) to convert a floating-point number to a string. Following program demonstrates the use of this function. #include main( )
{
char str[25] ;
float no ;
int dg = 5 ; /* significant digits */
no = 14.3216 ;
gcvt ( no, dg, str ) ;
printf ( "String: %s\n", str ) ;
}

Keywords:
c interview questions
c++ faq
faq on pointers in c
faq on arrays in c
faq videos
c tutorial
faqs on strings in c
steve summit
faq on pointers in c
faq on arrays in c
c++ faq
programming in c textbook
c tutorial
c programming resources
c language reference
cinterviews.com

c interview answers

C interview answers

C interview question1: What is atexit() ?

Answer:Function atexit( ) recevies parameter as the address of function of the type void fun ( void ). The function whose address is passed to atexit( ) gets called before the termination of program. If atexit( ) is called for more than one function then the functions are called in "first in last out" order. You can verify that from the output.

#include

void fun1( )

{

printf("Inside fun1\n");

}

void fun2( )

{

printf("Inside fun2\n");

}

main( )

{

atexit ( fun1 ) ;

/* some code */

atexit ( fun2 ) ;

printf ( "This is the last statement of

program?\n" );

}

C interview question2 : How do I write a user-defined function, which deletes each character in a string str1, which matches any character in string str2?

Answer: The function is as shown below:

Compress ( char str1[], char str2[] )

{

int i, j, k ;

for ( i = k = 0 ; str1[i] != ‘\0’ ; i++ )

{

for ( j = 0 ; str2[j] != ‘\0’ && str2[j] !=

str1[i] ; j++ );

if ( str2[j] == ‘\0’ )

str1[k++] = str1[I] ;

}

str1[k] = ‘\0’

}

C interview question3:How does free( ) know how many bytes to free?

Answer: The malloc( ) / free( ) implementation remembers the size of each block allocated and returned, so it is not necessary to remind it of the size when freeing.

C interview question4:What is the use of randomize( ) and srand( ) function?

Answer: While generating random numbers in a program, sometimes we require to control the series of numbers that random number generator creates. The process of assigning the random number generators starting number is called seeding the generator. The randomize( ) and srand( ) functions are used to seed the random number generators. The randomize( ) function uses PC's clock to produce a random seed, whereas the srand( ) function allows us to specify the random number generator's starting value.

C interview question5:How do I determine amount of memory currently available for allocating?

Answer: We can use function coreleft( ) to get the amount of memory available for allocation. However, this function does not give an exact amount of unused memory. If, we are using a small memory model, coreleft( ) returns the amount of unused memory between the top of the heap and stack. If we are using a larger model, this function returns the amount of memory between the highest allocated memory and the end of conventional memory. The function returns amount of memory in terms of bytes.

C interview question6:How does a C program come to know about command line arguments?

Answer: When we execute our C program, operating system loads the program into memory. In case of DOS, it first loads 256 bytes into memory, called program segment prefix. This contains file tables,environment segment, and command line information. When we compile the C program the compiler inserts additional code that parses the command, assigning it to the argv array, making the arguments easily accessible within our C program.

C interview question7:When we open a file, how does functions like fread( )/fwrite( ), etc. get to know from where to read or to write the data?

Answer: When we open a file for read/write operation using function like fopen( ), it returns a pointer to the structure of type FILE. This structure stores the file pointer called position pointer, which keeps track of current location within the file. On opening file for read/write operation, the file pointer is set to the start of the file. Each time we read/write a character, the position pointer advances one character. If we read one line of text at a step from the file, then file pointer advances to the start of the next line. If the file is opened in append mode, the file pointer is placed at the very end of the file. Using fseek( ) function we can set the file pointer to some other place within the file.

Keywords:
c interview questions
c++ faq
faq on pointers in c
faq on arrays in c
faq videos
c tutorial
faqs on strings in c
steve summit
faq on pointers in c
faq on arrays in c
c++ faq
programming in c textbook
c tutorial
c programming resources
c language reference