C Programming

The following example repeatedly asks for a number. As each number is entered, the array (arr) is dynamically resized to accommodate the new number. To finish entering numbers, enter any non-number (such as the letter X). If any numbers were entered, the array is then sorted using a simple bubble sort and the result is then displayed.

Note that resizing an array like this is highly inefficient because the array must be copied each time it is resized. If you can determine how many numbers will be entered in advance (at runtime), then the array can be allocated just once, before reading the numbers into each array element.

#include <iostream>

int main()

{

float t, num = 0, *arr = NULL;

int max = 0, i, j;

while( 1 )

{

printf( "\nEnter a number:\n(Any letter to quit)\n>" );

int iResult = scanf( "%f", &num );

if( !iResult )

break;

arr = ( float * ) realloc( arr, ++max * sizeof( float ));

arr[ max-1 ] = num;

}

printf( "%d numbers entered.\n", max );

if( max )

{

for( i=1; i<max; i++ )

{

for( j=0; j<max-i; j++ )

{

if( arr[j] > arr[j+1] )

{

t = arr[j];

arr[j] = arr[j+1];

arr[j+1] = t;

}

}

}

printf( "Sorted:\n");

for( i=0; i<max; i++ )

printf( "%f\n", arr[i] );

printf( "\n" );

free( arr );

arr = NULL;

}

return( 0 );

}

Platform dependent. Many in unix, few in WinDos.

1. # include
2. # include
3. void main()
4. {
5. int a[20], i, n ;
6. clrscr() ;
7. printf("Enter the limit : ") ;
8. scanf("%d", &n) ;
9. printf("Enter the elements") ;
10. for(i = 0 ; i < =n ; i++)
11. scanf("%d", &a[i]) ;
12. printf("The positive elements are") ;
13. printf("the negative elements are);
14. for(i = 0 ; i < n ; i++)
15. {
16. if(a[i] > 0)
17. printf("%d", a[i]) ;
18. if(a[i]<0
19. printf("%d",a[i]);
20. }
21. getch() ;
22. }

Any for loop is equivalent to some while loop, so the language doesn't get any additional power by having the for statement. For certain type of problem, a for loop can be easier to construct and easier to read than the corresponding while loop. The for statement makes a common type of while loop easier to write. It is a very good (perhaps the best) choice for counting loops.

Built-in functions are functions that are provided for you by the standard includes. User-defined functions are those that you write yourself. Third-party functions are those that are written for you, but that are not provided by the standard includes.

The assembly language does not support object oriented program

so they change to c and c++ the c++ will support object oriented program

this are the demerits of assembly language.

#include<iostream>

int main()

{

int a=40;

int b=2;

std::cout<<a<<'+'<<b<<'='<<a+b<<std::endl;

}

Output:

40+2=42

We'll assume the matrix elements are doubles, but we can easily adapt the code to cater for any numeric data type.

First we need a (primitive) function that emulates the += operator for two arrays of doubles:

double* add_assign_array (double* a, double* b, size_t sz) {

for (size_t i=0; i<sz; ++i) a[i] += b[i];

return a;

}

Note that we are wholly reliant upon the caller to ensure all arguments are valid. We could test for null pointer arguments, however there's no advantage in doing so when we cannot even guarantee that a and b actually refer to at least sz elements. For efficiency it's better if the caller handles any and all necessary runtime tests and thus keep those tests to a minimum.

With this function in place we can now add two matrices, row by row:

double* add_assign_matrix (double* a, double* b, size_t rows, size_t cols) {

size_t i;

for (size_t row=0; row<rows; ++row) {

i = row * cols;

add_assign_array (a[i], b[i], cols);

}

return a;

}

Example usage:

// Utility functions: void print_array (double*, size_t);

void print_matrix (double*, size_t, size_t);

int main (void) {

const size_t rows = 3;

const size_t cols = 4;

double a[rows][cols] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

double b[rows][cols] = {{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}};

printf ("Matrix a:\n");

print_matrix (a, rows, cols);

printf ("Matrix b:\n");

print_matrix (b, rows, cols);

printf ("Matrix a+=b:\n");

add_assign_matrix (a, b, rows, cols);

print_matrix (a, rows, cols);

return 0;

}

void print_array (double* a, size_t sz) {

for (size_t i=0; i<sz; ++i) printf ("%f\t") a[i];

printf ("\n");

}

void print_matrix (double* a, size_t rows, size_t cols) {

for (size_t row=0; row<rows; ++row) print_array (a[row * cols], cols);

}

Note that the add_assign function emulates a += b rather than c = a + b. However, we can easily emulate this by copying one of the matrices and then calling add_assign upon the copy:

// e.g., c = a + b;

double c[rows][cols]; // uninitialised matrix

memcpy (c, a, rows * cols * sizeof (double)); // c is a copy of a

add_assign_matrix (c, b, rows, cols); // c += b

It's far from intuitive but arrays and matrices are anything but intuitive in C programming.

The only loop that does not require an entry condition is the procedural goto loop:

again:

/*...*/

goto again;

Although a do-while loop has no entry condition per-se, it still requires a mandatory entry condition into the second and all subsequent iterations.

do { /*...*/} while (true); // mandatory entry condition into all but the 1st iteration

And although a for loop's condition is optional, it is implicit:

for (;;) {/*..*/} // implicit for ever loop

for (;true;) {/*...*/} // explicit for ever loop

You don't need a flow chart for that; just use the quadratic formula directly; most programming languages have a square root function or method. You would only need to do this in many small steps if you use Assembly programming. The formulae would be something like this:

x1 = (-b + sqrt(b^2 - 4*a*c)) / (2 * a)

and

x2 = (-b - sqrt(b^2 - 4*a*c)) / (2 * a)

where a, b, and c are the coefficients of the quadratic equation in standard form, and x1 and x2 are the solutions you want.

Approval at Milestone C is dependent on an approved CPD, compliance with the DoD strategic plan and demonstration that the system is affordable throughout the life cycle. The MDA also approves the updated acquisiton strategy and the acquisition decision memorandum at Milestone C.

It depends what language you are using and how the function is implemented. However, generally, you need to pass 4 arguments to the function:

1. A reference to the array.

2. The lower bound of the sub-array to be sorted (usually 0).

3. The upper bound of the sub-array to be sorted (usually n-1 for an array of n elements).

4. A binary predicate to perform comparisons between the elements (usually a less-than predicate).

Firstly, thanks for trying solve this algorithm.

I will rewrite the wrong way and debug it in the next line, and the causes in th last line , O right?


wrong:void delete(int n).
debug:void delete_node(node* list, int n).
causes:
-You have to include the name of the list from which you want to delete a node. -you used delete as a name of the function, and that is impossible because delete is a predefined function, use delete_node for example.




wrong:you didn't affect the address of the list to the temporary pointer named here P.
debug:p=list.
causes:
-one of the disadvantages of the chained list -unlike contiguous list-is: to arrive to the the required node, we have to traverse all previous nodes to get the required one, therefor we use that temporary pointer, and this latter mast have to start from the first node names here list.


the rest is right, try this code, I think it works::


void delete_node(node *list, int n)
{
node *p;
p=list;
int i=1;
while(i
{
p=p->next;
++i;
}
node *q;
q=p->next;
p->next=q->next;
free(q);
}



Best regards of InfoMan.

#include<stdio.h>

#include<conio.h>

void main()

{

int a=2,b=3;

swap(a,b);

printf("%d%d",a,b);

getch()

}

swap(int *x,int *y)

{

int t;

t=*x;

*x=*y;

*y=t;

printf("%d%d",x,y);

}

BASIC , FORTRAN ,COBOL , PASCAL are high level lanhuages which are simply understood by us used in the computers.

The function of a frequency drive is to control the speed of an electric motor.

In general, a frequency drive converts the ac supply voltage into a dc voltage and then converts this dc voltage into a ac voltage of which the amplitude (voltage) and the frequency can be varied. Giving you the possibility to fully control the speed of the motor.

Applications: (big) ventilators, pumps, cranes, elevators and virtually all other applications where electric motors are used.

One way data communication.

http://en.wikipedia.org/wiki/Simplex_communication