C Programming

Programs written in low level language are executed immediately. They require no compilers.

Low Level Language instructions can be used to manipulate the individual bits in a byte of computer storage.

difficult to program.

Impossible for the programmer to memorize all the operational codes.

Correcting and modifying a program is difficult.

I am providing a succinct and easy to understand version of the program. I have run it in 3-4 compilers and it works perfect. Mind you, you should not enter a number more than 2147483647 (which is the largest number a variable can process in C!). If you do, no problem, but it will display all numbers above it, including the even numbers to be prime. So here you are:

#include

#include

main()

{

long int a,b,c;

printf("Enter the number: ");

scanf("%ld",&a);

for (b=2;b

{

c= a%b;

if (c==0)

goto cool;

}

printf("\nThe number is goddamned prime!");

goto fool;

cool: printf("\nThis ain't a prime number you dumbo!");

fool: printf("\n");

}

By the way I am not sure what your query really was. I gave the above program to check whether a number is prime or not. If you mean to generate prime numbers between 2 (which is of course the first prime number) and a given number g and also want to know the number of prime numbers between the two, well here is it:

#include

#include

main()

{

long int a=2,i=2,c,count=0,g;

printf("Prime numbers upto what number should be generated? ");

scanf("%ld",&g);

printf("\nFollowing is the list of prime numbers:\n");

while (a<=g)

{

for (i=2;i

{

c=(a%i);

if (c==0)

goto cool;

else

continue;

}

printf("\n%ld",a);

++count;

cool: ++a;

}

printf("\nTotal number of prime numbers between 2 and %ld is %ld. ",g,count);

}

For both these programs, simply copy-paste them into your compiler and have your result. Hope you got what you wanted...

An array's name is not a constant pointer; it's not even a pointer! An array name is a reference to the array itself. Unlike pointers, references have no memory of their own, therefore a reference cannot be constant (only what it refers to can be constant). A reference is nothing more than an alias for a memory address. Since there is no separate storage for references, you cannot reassign references while they remain in scope. So, in that sense, it behaves like a constant pointer. But a pointer is a variable, so even if declared const, it requires memory of its own in order to store the memory address it points to.

Example:

int a[10];

int * const p = a; // const pointer

assert( *p &a ); would cause an assertion. Likewise, assert( p != &p); proves that p must reside in a separate memory address from that referred to by a. It has to: pointers are variables even when they are declared const.

In Systematically search option (Depth First Search), Data storing and retrieving in hard disk based on the "BALANCED TREE(AVL

- B- TREE)", printer (QUEUE),

In Programming language point of with out Data structure and Algorithms we can't develop a single program -

primitive data structures - INTEGER, FLOAT, CHAR , BOOLEAN, ETC..

abstract data structures- ARRAY , LINKED LIST , GRAPH, TREE, STACK , QUEUE. ETC..

So, In programming every where we are using without knowing about this...

try to learn basic thing about programming ....for to become a Good Software Engineer you should know the fundamental of Data Structure and Algorithms.

Inversing of a given Number. suppose we gave input 123456 then the output of the program will be 654321./*mycfiles.wordpress.com

C program to print inverse of a given number*/

#include

#include

void main()

{

long int n,rn=0,d=0;

clrscr();

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

scanf("%ld",&n);

while(n>0)

{

d=n%10;

rn=rn*10+d;

n=n/10;

}

printf("%ld",rn);

getch();

}

In a C source program, the basic element recognized by the compiler is the "token." A token is source-program text that the compiler does not break down into component elements. Syntax

; token: : keyword identifierconstant string-literal operatorpunctuator The keywords, identifiers, constants, string literals, and operators described in this section are examples of tokens. Punctuation characters such as brackets ([ ]), braces ({ }), parentheses ( ( ) ), and commas (,) are also tokens.

One first basic rule is that you should use the for loop when the number of iterations is known. For instance:

• The loop iterates over the elements of a collection.
• The loop iterates over a range of values which is known in advance at execution time.
• The object provides a way to iterate over its elements with a for statements (e.g files).

The while loop is the more general one because its loop condition is more flexible and can be more complicated than that of a for loop. The condition of a for loop is always the same and implicit in the construction. A for loop stops if there are no more elements in the collection to treat. For simple traversals or iterations over index ranges it is a good advice to use the for statement because it handles the iteration variable for you, so it is more secure than while where you have to handle the end of the iteration and the change of the iteration variable by yourself.

The while loop can take every boolean expression as condition and permits therefore more complex end conditions. It is also the better choice if the iteration variable does not change evently by the same step or if there are more than one iteration variable. Even if you can handle more than one iteration variable in a for statement, the collections from which to choose the values must have the same number of elements.

Note: In C 'for' and 'while' can be easily replaced by each other:

while (exp) stmt

for (;exp;) stmt

for (exp1;exp2;exp3) stmt

{ exp1; while (exp2) { stmt exp3}}

The difference between "do while" and "do until" is that a "do while" loops while the test case is true, whereas "do until" loops UNTIL the test case is true (which is equivalent to looping while the test case is false).

The difference between a "do ...while" loop and a "while {} " loop is that the while loop tests its condition before execution of the contents of the loop begins; the "do" loop tests its condition after it's been executed at least once. As noted above, if the test condition is false as the while loop is entered the block of code is never executed. Since the condition is tested at the bottom of a do loop, its block of code is always executed at least once.

To further clear your concept on this, understand the syntax and description of the two loop types:

while
The while loop is used to execute a block of code as long as some condition is true. If the condition is false from the start the block of code is not executed at al. The while loop tests the condition before it's executed so sometimes the loop may never be executed if initially the condition is not met. Its syntax is as follows.

while (tested condition is satisfied)
{
block of code
}

In all constructs, curly braces should only be used if the construct is to execute more than one line of code. The above program executes only one line of code so it not really necessary (same rules apply to if...else constructs) but you can use it to make the program seem more understandable or readable.

Here is a simple example of the use of the while loop. This program counts from 1 to 100.

#include

int main(void)
{

int count = 1;

while (count <= 100)
{
printf("%d\n",count);
count += 1; // Notice this statement
}

return 0;

}

Note that no semi-colons ( ; ) are to be used after the while (condition) statement. These loops are very useful because the condition is tested before execution begins. However i never seem to like these loops as they are not as clear to read as the do ...while loops. The while loop is the favorite amongst most programmers but as for me, i definitely prefer the do ...while loop.

do ....while
The do loop also executes a block of code as long as a condition is satisfied.

Again, The difference between a "do ...while" loop and a "while {} " loop is that the while loop tests its condition before execution of the contents of the loop begins; the "do" loop tests its condition after it's been executed at least once. As noted above, if the test condition is false as the while loop is entered the block of code is never executed. Since the condition is tested at the bottom of a do loop, its block of code is always executed at least once.

Some people don't like these loops because it is always executed at least once. When i ask them "so what?", they normally reply that the loop executes even if the data is incorrect. Basically because the loop is always executed, it will execute no matter what value or type of data is supposed to be required. The "do ....while" loops syntax is as follows

Note that a semi-colon ( ; ) must be used at the end of the do ...while loop. This semi-colon is needed because it instructs whether the while (condition) statement is the beginning of a while loop or the end of a do ...while loop. Here is an example of the use of a do loop.

include

int main(void)
{

}