C Programming

An array is simply a contiguous allocation of one or more elements of a given type.

int i; // a single element of type int

int j[100]; // an array of 100 elements of type int

The elements of an array are anonymous (we can't refer to them by name because they have no names). However we can access them by their offset address from the start of the array. The array name serves as a reference to the start of the array and will implicitly convert to a pointer:

int* p = j;

Each element of an array is offset by sizeof (type) bytes. However, the offset is known to the compiler so we do not need to specify it when accessing array elements, we only need to know the zero-based index of the element we wish to access:

int k = j[42];

Note that the suffix operator [] does not perform a range-check. It is up to the programmer to ensure the given index is in range. The array named j has 100 elements so all indices must be in the range 0 through 99. Access beyond the range of an array has undefined behaviour:

int m = j[100]; // undefined behaviour

Given j is a reference, we can also use pointer arithmetic to access elements:

int n = j + 42;

From this we can see that the following holds true:

j[42] 42[j]

It often surprises people to learn that j[42] and 42[j] are equivalent, however it's only because the suffix operator is sugar-coating for the underlying pointer arithmetic so the compiler sees 42 + j, not 42[j]. However, low-level trickery such as this has no place in production code.

The elements of an array are uninitialised at the point of instantiation. However we can use an initialiser to set initial values:

int j[5] = {5, 10, 15, 20, 25};

When we pass arrays to functions, the array implicitly converts to a pointer. This means information is lost in the exchange because the function cannot know how many elements are being referred to by the pointer. Thus we must pass the length of the array as a separate argument:

void f (int* arr, unsigned size) {

for (unsigned idx=0; idx<size; ++idx) {

arr[idx] = 0;

}

}

Given that arrays implicitly convert to pointers, variable-length arrays are treated exactly the same as fixed-length arrays, the only difference is that the programmer is responsible for allocating and releasing the memory:

void g (unsigned size) {

int* p = malloc (size * sizeof (int)); // allocate

f (p, size); // use

free (p); // release

}

Note that variable-length arrays cannot be initialised at the point of instantiation; they must be instantiated then initialised, as shown above.

Fixed-length arrays (where the length is known to the compiler) can be allocated in static memory, on the call stack or on the heap. Global arrays are best allocated statically while small local arrays are best allocated on the stack. Large local arrays should be allocated on the heap. Variable-length arrays must always be allocated on the heap.

#include<stdio.h>

#include<conio.h>

void main()

{

clrscr();

int a,b,c,n;

printf("enter the numbers");

scanf("%D",&n);

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

a=b;

a=c;

c=a+b;

printf("the sum is %c",);

getch();

}

Data structures are important because they allow us to aggregate different data types and treat them as a single entity. For instance, if we have separate variables such as first name, last name and age to represent a person, embedding them into a data structure means we can handle multiple people much more easily:

typedef struct person {

char* first_name;

char* last_name;

unsigned age;

};

struct person[100] people; // An array of 100 person objects.

Answer: In dos you have to create the complete application, yourself in other words the complete .EXE file, that can be done in any of the many different programming languishes IE. GWBasic, QBasic, C, or ASM etc., the last is the most difficult but the result is the fastest application. Where Windows is a platform for your application, most of the things you want to do is already created in Windows, all you have to do, is to use it from within your application, not that it means less programming, you actually have to do more coding than with Dos, for instance in Dos GWBasic, if you want to read data from a comm. port you just open it as follow

[code]

open "comm1:" for input as #1

input #1, var

close #1

[/code]

But in Windows it is a long story

DATA STRUCTURES AS ITS NAME IMPLIES DATA MEANS "VALUE' AND STRUCTURE MEANS THE WAY IT IS ORGANISED AND THE WAY IT IS ARRANGED INTO MATHEMATICAL AND LOGICAL WAY.

Just like array...array helps you to store elements without declaring multiples variable

eg: num[100] can store 100 variables which are integers. Here if you are not using array and want to store data in 100 variables then you must declare 100 unique variables names. This can be done effectively using data structures.

retail operator responsobilities

one of the world’s largest radio observatories

Because the quick sort can be used for large lists but selection not.

selection sort is used to find the minimum element ,but quick choose element called pivot and move all smaller nums before it & larger after it.

Due to platform independence, a Java compiler will interpret Java source code into Java Byte Code and pass to the JVM, which will pass machine understandable code through to cpu. (clarification needed).A conventional compiler converts source code directly to machine code.(clarification needed).

• OOP is a more complicated and structured paradigm than, say classic procedural programming.
• More planning and design is required on the programmer's part.
• OOP is less efficient in terms of a computer's resources than most other paradigms.
• OOP is a complex idea - no language including Java and C++ implements it perfectly.
• OOP may be overkill for smaller, simpler programs.

flow chart to swap two number

4m Sai. Gloabal Variable is variable which is declared before main (). int a=10; main() { } here a is a global variable. where ever u r using this variable ... we'll get the value as 10. Local Variable is a variable which is declared inside the main(). int a=10; main() { int a=5; ........ ....... } here a=5 is a local variable and a=10 is called as global variable. then if u want to get a value... printf("%d",a); then result 'll be a=5; B'cos compiler gives main preference to local variables.. if any local declareation is not there then it 'll prefer global variable.

#include

#include

main()

{

char a[30],fs[50]="",t[3],sd,ed,x[3],s[3],d[3],y[3];

int i,j,p=0,q=0;

clrscr();

printf("Enter characters to be stuffed : ");

scanf("%s",a);

printf("\nEnter a character that represents starting delimiter : ");

scanf(" %c",&sd);

printf("\nEnter a character that represents ending delimiter : ");

scanf(" %c",&ed);

x[0]=s[0]=s[1]=sd;

x[1]=s[2]='\0';

y[0]=d[0]=d[1]=ed;

d[2]=y[1]='\0';

strcat(fs,x);

for(i=0;i

{

t[0]=a[i];

t[1]='\0';

if(t[0]==sd)

strcat(fs,s);

else

if(t[0]==ed)

strcat(fs,d);

else

strcat(fs,t);

}

strcat(fs,y);

printf("\nAfter stuffing : %s",fs);

getch();

}

Embedded systems typically run on extremely limited hardware. Even the smallest implementation of Java (Micro Edition) can't compete with a small C implementation both in terms of memory footprint and execution speed.

In c:

int fibr(int n) { // Find nth Fibonacci number using recursion.

if (n<=2) return 1; // the first two Fibonacci numbers are 1 and 1

return (fibr(n-2)+fibr(n-1));

}

int fibi(int n) { // Find nth Fibonacci number using iteration.

int temp,last=1,f=1;

int i;

for (i=3;i<n;++i) { // the first two Fibonacci numbers are 1 and 1

temp=f;

f+=last;

last=temp;

}

return f;

}

#include <stdio.h>

#include <conio.h>

void main()

{

int height, line, i;

clrscr();

scanf("%d", &height);

for (i = 0; i < height - 1; ++i)

printf(" ");

printf("1\n");

for (line = 1; line < height; ++line)

{

for (i = 0; i < height - line - 1; ++i)

printf(" ");

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

printf("%d", line + 1);

printf(" ");

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

printf("%d", line + 1);

printf("\n");

}

getch();

}

Arrays are beneficial whenever you need constant-time, random-access to any element within a set of data and the number of elements doesn't change too much (enlarging an array may require the entire array be copied to a larger block of free memory, which is expensive in terms of performance). Linked lists are beneficial when the number of elements is highly variable and you also need constant time access to the head (as per a stack) or both the head and tail (as per a queue). Neither a queue nor a stack requires any traversal whatsoever, so the lack of random access is immaterial. If a set of data is variable and must remain in sorted order (such as a priority queue), then a heap or self-balancing binary tree is the most efficient structure to use.

Advantages:

1. Can store "n" number of same data types in different indexes

2. Can be accesses using reference.

Disadvantage:

1. No boundary check, if the array boundary is crossed run time

2. No facility to increase the size of array in Run time

It really depends on the language. In Java, you can use the .length property.

There are many approaches to this 'problem'. Since a C function is only allowed to return one value as the name of the function you have to provide parameters to the routine if you want multiple values to be returned.

For example, traditionally you return a value thus:

int Today () ;

if (Today() == 2) ....

int Today ()
{
/* Some logic */
return value ;
}


So if you want multiple values, send parameters to the routine that can be changed:

int Today (int * val1, int * val2, char * charValue) ;


Then, call it:

int first ;
int second ;
char third ;

if (Today (&first, &second, &third) == 2)

In this case first, second, and third can be changed inside the Today routine and return multiple values.

int Today (int * val1, int * val2, char * charValue)
{
*val1 = 5 ;
*val2 = 10 ;
*charValue = 'Y' ;
return 2 ;
}

Machine code is the native language of the machine. The machine does not "understand" any language other than its own native language. As such, all other languages, including low level assembly languages, must be compiled or interpreted in order to produce the required machine code.