C Programming

Dennis ritchie

echo "Enter A Number :"

read n

r=n

s=0

rem=0

while [ $n -gt 0 ]

do

rem=$(($n%10))

s=$(($s+$rem*$rem*$rem))

n=$(($n/10))

done

if [ $r -eq $s ]

then

echo "The Number is Avogadro"

else

echo "The Number is Not Avogadro"

fi

As written in the c programming language to find the LCM for up to 50 numbers. All that needs to be done is compile this. It is my first draft of the program, as it was due for a class 2 hrs ago, but if you wish to try and optimize it, that's your task.

-----------------------------------------------------------------------------------------------------------

#include <stdio.h>

#define NUMFACT 50

void FindFactor(int[]);

int Min(int[]);

int Max(int[]);

int calc(int[]);

int check(int[]);

void bubbleSort(int[]);

void Display(int[],int);

int main()

{

int factors[NUMFACT] = {0}; //FACTORS ARRAY INITIALIZED WITH 0'S

int lcf; //LOWEST COMMON FACTOR

FindFactor(factors);

lcf = calc(factors);

bubbleSort(factors);

Display(factors, lcf);

return(0);

}

void FindFactor(int factors[])

{

int tempvalue; //TEMP VALUE TO BE STORED IN FACTOR ARRAY

int location = 0; //LOCATION IN VECTOR TO PLACE INPUT NUMBER

do

{

printf("Enter factor: ");

scanf("%d",&tempvalue);

if (tempvalue != -1)

{

factors[location] = tempvalue;

}

++location;

} while (tempvalue != -1 && location <=49);

}

int Min(int factors[])

{

int increment; //INCREMENT EACH PASS

int min = Max(factors); //MAX VALUE IN FACTORS CHANGED TO LOWEST

int location; //LOCATION OF THE MIN VALUE IN ARRAY

for(increment = 0 ; increment < 49 ; increment++)

{

if (factors[increment] != 0)

{

if(factors[increment] < min)

{

min = factors[increment];

}

}

}

for(increment = 0 ; increment < 49 ; increment++)

{

if(min 0);

lcf = copyfactors[0];

return(lcf);

}

int check(int factors[])

{

int increment; // INCREMENT EACH PASS

int value = 1; //TRUE VALUE RETURNED IF IF-LOOP IS ALWAYS FALSE

for(increment = 1 ; increment < 49 ; increment++)

{

if (factors[increment] != 0)

{

if (factors[increment-1] != factors[increment])

{

value = 0;

}

}

}

return(value);

}

int Max(int factors[])

{

int max = 0; //START VALUE SINCE # CAN'T BE LESS THAN 0

int increment; //INCREMENT EACH PASS

for(increment = 0 ; increment < 50 ; increment++)

{

if (factors[increment] > max)

{

max = factors[increment];

}

}

return(max);

}

void bubbleSort(int factors[])

{

int numPasses; //LCV THAT CONTROLS # OF PASSES

int lcv; //LOOP CONTROL VARIABLE FOR SORTING

int temp; //HOLDS VALUE DURING SWAP

for(numPasses = 1; numPasses < NUMFACT ; numPasses++)

{

for(lcv = 0 ; lcv < NUMFACT - numPasses ; lcv++)

{

if(factors[lcv] > factors[lcv+1])

{

temp = factors[lcv];

factors[lcv] = factors[lcv+1];

factors[lcv+1] = temp;

}

}

}

}

void Display(int factors[],int lcf)

{

int increment; //INCREMENT EACH PASS

printf("The factors of %d are:",lcf);

for(increment = 0; increment < 50 ; increment++)

{

if(factors[increment] != 0)

{

printf(" %d",factors[increment]);

}

}

printf("\n");

}

An interrupt is a hardware-generated change of flow within the system. An interrupt handler deals with the cause of the interrupt. Control is then returned to the interrupted context An interrupt is a hardware-generated change of flow within the system. An interrupt handler deals with the cause of the interrupt. Control is then returned to the interrupted context

a. OOP provides a clear modular structure for programs which makes it good for defining abstract datatypes where implementation details are hidden and the unit has a clearly defined interface.

b. OOP makes it easy to maintain and modify existing code as new objects can be created with small differences to existing ones.

c. OOP provides a good framework for code libraries where supplied software components can be easily adapted and modified by the programmer. This is particularly useful for developing graphical user interfaces.

do

{

//statements

}while(condition);

The statements inside the block get executed at-least once, no matter what condition you have placed. Only from the 2nd time the condition is checked, simply because the condition is at the last.

for(initialization; condition; updation)

{

//statements

}

Here the statements don't get executed even once if the condition fails initially. The condition is at the entry itself.

floating-point variable cost

exponential series

#include<stdio.h>

#include<conio.h>

#include<math.h>

void main()

{

int i,x,n;

float e=1,denominator=1;

clrscr();

printf("Enter the value of x,n\n");

scanf("%d,%d",&x,&n);

while(i<=n)

{

e+=(float)(pow(x,i)/denominator);

denominator*=i;

++i;

}

printf("answer is %f",e);

}

You would have to use a version of Visual Studio that can target the .Net Compact Framework. Be aware that the Compact Framework is a SUBset of the .Net Framework, so there will be some missing classes and methods.

tanga

three levels of data abstraction

are:

1. Physical level : how the data is

stored physically and where it is

stored in

database.

2. Logical level : what information

or data is stored in the database

(like what is the

datatype or what is format of

data.

3.View level : end users work on

view level. if any amendment is

made it can be

saved by other name.

for the database to be usable it

must retrieve data efficently.this

efficency led designer to use

complex data structure in the

database

use system("clear");

eg:

main()

{

system("clear");

}

#include<stdio.h>

#include<conio.h>

void main()

{

int a,b,c,d,e;

clrscr();

if(a>b)

{

if(a>c)

e=a;

else

e=c;

}

else

{

if(b>c)

e=b;

else

e=c;

}

if(e>d)

printf("%d is the greatset",e);

else

printf("%d is the greatest",d);

getch();

}

The following code for example is a solution (you could do it with less variables, but this is more readable):
int GCD(int a, int b){
int n, k, c;
n = (a>b)?a:b;
k = (a>b)?b:a;
while (k){
c = n%k;
n=k;
k=c;
}
return n;
}

Because of the function declaration and definition (which must match)

When you define the function:

void msgBox(int x, int y, char *message);

you have to pass it parameters in the order they were defined:

void main()

{

msgBox(5,10,"Hello World");

}

If you present the values in the wrong order, it will either not compile (type mismatch), or the function will behave unexpectedly (for instance, x and y coordinates swapped).

In general the only difference between commands, or instructions, and data is the context in which each appears. If the CPU is fetching the contents of memory to get the next instruction, then it assumes that the Program Counter register points to commands. If the CPU is executing an instruction that needs to fetch data from memory, the data at the address specified by the instruction are fetched, assuming that the address points to data.

This is what allows a program to be loaded into memory in the first place; the part of the operation system responsible for this operation treats the program as data, loading it into memory as instructed in the file. Then the OS branches to a specified place within that memory and begins fetching instructions there.

This blurring between instructions and data has also been used in the past to allow a program to modify itself as it executes. This is usually considered poor practice; some operating systems, such as HP's OpenVMS, even set up memory page protections to keep this from happening.

Ideally, modules will have low coupling and high cohesion. Coupling describes the strength of the connection between modules in a program. Loose (or low) coupling occurs when modules do not depend on other modules. One way to control this is by avoiding the use of global variables and reducing the number of variables that are passed between the modules. Another is to limit the depth of module calls (where a module calls another module, that then calls another module, and so on). Cohesion is a measure of how well a module accomplishes the module's purpose. High cohesion implies that all the module's internal statements serve to perform the module's (single) task. In order for modules to work together, there must be some connection between them. The nature of the connection is important because it determines the extent to which the modules are coupled. How are they connected? The best way to connect them is to pass the value of a local variable in one module to a second module through its parameter list. (A local variable is a variable that is defined within a module (not a parameter) is local to that module. The values of local variables are not available outside of the module in which they are declared unless they are passed. Local variables are reset to their default values once control leaves the module in which they are declared.) Another way to share information is through the use of global variables. (A variable that is defined outside of a module and that does not need to be passed to a module to be accessed by it is a global variable. Global variables retain their value once control leaves the module in which they are referenced. ) Because the value of a global variable can be changed by any module without passing, it increases the coupling between modules.

In computer programming, many languages distinguish between uppercase and lowercase letters in user defined variables. This is an advantage because it allows users to tell the difference between variables based on whether they are uppercase or not. It is a disadvantage because forgetting to change a letter to the proper case will result in an error when the program runs.

IPR is an acronym that stands for many things. Some of them are Intellectual Property Rights, Industrial Property Rights, and Institute of Public Relations. It also stands for Injection Pressure Regulator, Interim Progress Review, and International Paranormal Research.

Gotoxy is used to move the cursor on the monitor screen. Gotoxy follows a certain programming code to put the cursor in the desired position.

Empty parenthesis is a self invoked function that is executed immediately after its created. IT makes the function an expression and any subsequent function, the call.