C Programming

A forest is a disjoint union of trees.

#include<iostream>

double celsius(double fahrenheit) { return((fahrenheit-32)*5/9); }

double fahrenheit(double celsius) { return(celsius*9/5+32); }

int main()

{

double f, c;

c = celsius( 32.0); // c 212.0

return(0);

}

stats

If you have a 1 byte (8 bit) number, then you can use those bits in two different ways, signed and unsigned.

Unsigned means that all 8 bits represent a power of two, so you can go from 00000000 = 0 (2^0) to 11111111 = 255 (2^8 - 1).

SIgned means that you take the first bit and use it to represent positive or negative. In this case 00000001 = 1 and 10000001 = -1. So your range of values is 11111111 = -127 (-(2^7 - 1)) to 01111111 = 127.

There are a couple of problems with this simplified example, one being that you have two different representations for zero. Most computer systems use two's complement to get around this.

In most languages, you can't have names with space, for functions, variables, etc. Assuming your function is called myFunction, the usual way to call it is:

myFunction()

This assumes the function requires no parameters. If the function does require parameters, the parameters will be included within parentheses.

They are INT , FLOAT , CHAR. int carries integers only & occupies 2bytes of memory space each. float carries fractional numbers only & occupies 4bytes of memory space each.char carries characters only & occupies 1bytes of memory space each.

Hope this will help you.

Using a temporary variable:

#include<stdio.h>

#include<conio.h>

void main()

{

int a,b,temp;

clrscr():

printf("Enter the first number a\n");

scanf("%d",&a);

printf("Enter the second number b\n");

scanf("%d",&b);

printf("Before swapping a=%d b=%d",a,b);

temp=a;

a=b;

b=temp;

printf("The swapped values are: a=%d b=%d",a,b);

getch();

}

Without using a temporary variable:

#include<stdio.h>

#include<conio.h>

void main()

{

int a,b;

clrscr();

printf("Enter the first number a\n");

scanf("%d",&a);

printf("Enter the second number b\n");

scanf("%d",&b);

printf("Before swapping a=%d b=%d",a,b);

a=a+b;

b=a-b;

a=a-b;

printf("The swapped values are: a=%d b=%d\n");

getch();

}

Here is the java version, C should be similar

// merges two Singly linked lists A and B, both sorted in increasing order of integers .

// Return a Singly linked list sorted in increasing order

// for ex if A = 1->2->3->6 and B = 2->4->7, returns 1->2->2->3->4->6->7

public LinkedList merge(LinkedList A, LinkedList B) {

Node 1A = A.head;

Node 1B = B.head;

Node P1A = NULL;

Node 2A = NULL;

Node 2B = NULL;

while ( 1A != NULL && 1B !=NULL){

2A = 1A.next;

2B = 1B.next;

if (1A.item >= 1B.item) {

if (P1A != NULL) {

P1A.next = 1B;

}

else if ( P1A == NULL){

P1A = 1B;

}

1B.next = 1A;

P1A = 1B;

1B = 2B;

}

else if ( 1A.item < 1B.item){

if ( 2A != NULL) {

P1A = 1A;

1A = 1A.next;

}

else{

1A.next = 1B;

break;

}

}

}

return A;

}

#include<stdio.h>

int main () {

int odd=1;

int count=0;

while (count++<10) {

printf (%d\n", odd);

odd+=2;

}

return 0;

}

Can't say without some detail about the algorithm in question.

10 digits in a telephone number including the area code

Compiler directives instruct the preprocessor to perform certain tasks prior to compiling the source code. The language compiler can only compile C code, but macros (lines beginning with a # symbol) are not part of the C language, so these need to be processed before the compiler can do its job.

The most common compiler directive is the #include directive, which instructs the preprocessor to import the named file, effectively copy/pasting the content of that file in place of the directive. The content may itself contain directives and these must also be processed accordingly before the content is inserted.

Note that the insertion takes place in a temporary file; the source file is not changed by the preprocessor. The temporary file is usually deleted after compilation is complete, however you can configure the compiler to retain these files so you can see what code is produced by the preprocessor and thus what the compiler "sees".

The #define and #undefine compiler directives define or undefine macros; symbols which the preprocessor can refer to while processing other directives. Macros can also be defined via the command line.

The #ifdef, #ifndef, #elif, #else and #endif compiler directives are used in conditional compilation in conjunction with macro definitions. These tell the preprocessor which parts of the source code to include in or exclude from the temporary file. This is useful when writing debug code that we wish to include in a debug build but exclude from a retail build, or we wish to cater for different architectures and require different libraries and function calls in order to cater for them.

A macro symbol can also be given a value. Wherever that symbol appears in the code, the symbol is replaced with the value. This provides a convenient text-replacement system that can help make code easier to read. However, a macro can also be used to define a function (a macro function). These differ from ordinary functions in that they are always inline expanded, however they are not type-safe and the compiler cannot help you debug them (the compiler never sees the macro -- it only sees the inline expanded code produced by the macro). Macro functions are best avoided, however when used with care they can help to resolve complex problems that cannot easily be resolved within the language itself. It's best to think of macro functions as being code generators but, because they are not part of the language, its best to keep their usage as simple as possible.

As well as processing compiler directives, the preprocessor also strips out all the user-comments from the source file. Even if a compiler could read a comment it certainly wouldn't understand it, so to keep the compiler implementation as simple and as efficient as possible, all non-C code is completely stripped out. Even the redundant whitespace and newline characters are stripped out. The end result is a compact source file which can be easily compiled -- assuming no errors have been generated by your macros!

In the early days of computing, the dominant programming languages weresequential(such as basic or assembly language). A program consisted of a sequence of instructions, which were executed one after the other. It ran from start to finish on a single processor.

reference: http://code.google.com/edu/parallel/mapreduce-tutorial.html

for (int i=0; i<3; ++i) printf ("1 1 0 ");

printf("1\n");

1

Identifiers can be composed of letters, numbers, _ and $. Identifiers can only begin with a letter, _ or $. The identifer can be of mixed case.

also. read page 51, paragraph titled"User- Defined Identifiers"

in the book ITT gave you. The answer to your homework is clearly stated there.

computer

Not in its standard form, but there are modified versions available that will allegedly work under Windows 7. But if you really want to work with Windows 7 programs then you'd best avoid Turbo C++. Use a more generic and up to date version such as GCC.

queue is an abstract data type that which entities in a collection are kept in order, this makes the sense of fifo(first in first out).

stack is a container of the object which works on the principle of lifo(last in first out)

Yes,we can compile our program without header file without any error,but we can not use any predefine functions like printf,scanf.

Computers can directly run only binary machine code. When people write programs, that program text must be processed into machine code before it can be run.

Compilers and assemblers convert the source code into machine code. Compilers take a high-level language such as C or C++ and convert it, while assemblers take a much lower level language called "assembly language" where there is one language statement per machine instruction. High-level languages can be recompiled for different kinds of processors (like Intel or ARM CPUs) but assembly language is closely tied to the kind of processor. Some compilers actually compile high-level code into assembly language and then run that through an assembler to get machine code.

Interpreters are a different animal. They take either source code or partially compiled code and run it in the interpreter itself, rather than creating machine code. In other words, they directly "interpret" the program. Languages such as Perl, Python, and Ruby are interpreted from the source code. For Java and C#, the source code is compiled into an intermediate code that is easy to interpret.

seq 1 2 99