Computer Programming

qué relacion existe entre la fisica y la informática?

System Application and Products in Data processing. It's an ERP Software.

The size of an int variable in c is a function of the compiler implementation. It is usually a word in the underlying computer architecture. Original Microsoft C/C++ compilers for the 16 bit platform defined an int as 2 bytes. Current compilers for the 32 bit platform define an int as 4 bytes. The current ANSI C standard provides that an int is at least 4 bytes, but it could be higher, say 8 bytes on a 64 bit platform.

This is a question I asked myself when I was studying algorithms.

Algorithms are important because of how crucial they are to so many real world applications. Just a few examples are web searching, file sharing, file systems, compilers. Getting a computer science job without knowing anything about algorithms would severely limit you, probably would only be able to find a GUI programming job.

Almost all big companies like Microsoft, Google, Yahoo and Amazon use algorithms in their software and look for engineers who understand them very well. Having a very strong grasp of algorithms in a job interview would set you apart from all others who only simply know how to program.

Basically you need to study algorithms because they are used all the time in complex software projects.

In short you want job then learn algorithm.

An assignment statement sets the value of a named object. This can be used to initialise the object's value or to change the object's value. The object may be a constant or variable, however you can only initialise a constant, not change it.

int i = 42; // Assigns the value 42 to the integer variable named i.

i = 0; // Replaces the value 42 with the value 0.

const double pi = 3.14; // Assigns the value 3.14 to the constant named pi.

pi = 3.14159; // Compiler error; pi is constant!

It means "nothing", there is no data provided at all; just an empty value.

Contrary to the previous edit it does not mean "zero", "none" or "blank"; as zero is a number and none and blank can be regarded as data.

#include <iostream> void main() { using namespace std; int num, rem, sum=0; //Declaring variables cout<<"Enter a number :"<<endl; cin>>num; //Loop to calculate the sum of the digits of the given number. while(num!=0) { rem=num%10; num=num/10; sum=sum+rem; } cout<<"Sum of the digits is "<<sum<<endl; cin.get(); }

The advantage of contiguous memory allocation is

1. It supports fast sequential and direct access

2. It provides a good performance

3. the number of disk seek required is minimal

The disadvantage of contiguous memory allocation is fragmentation.

In software, an encoder takes some data and transforms it into a format suitable for storage or transmission.

In hardware, an encoder which takes multiple input lines and outputs the binary representation of the single input line which is set to high. Since it is difficult to guarantee that only a single input line will be high at the same time, a priority encoder is generally used instead.

A data strucutre is classified into two categories: Linear and Non-Linear data strcutures. A data structure is said to be linear if the elements form a sequence, for example Array, Linked list, queue etc. Elements in a nonlinear data structure do not form a sequence, for example Tree, Hash tree, Binary tree,etc. There are two ways of represneting linear data strucutresin memory.One way is to have the linear relationship betweent he elements by means of sequential memory locations. Such linear strucutres are called arrays. The other way is to have the linear relationship betweent he elements represnted by means of links.Such linear data strucutres are callled linked list.

There are three forms of loop commonly used in C/C++, the for loop, the while loop

and the do-while loop.

The for loop is most commonly used whenever an action is going to be performed a set amount of times. For example, to sum every element in an array:

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

{

sum = sum + array[i];

}

The while loop and do-while loop are commonly used to loop until a condition is met. The difference between the two is that the do-while loop goes through one iteration before checking its condition, while the while loop checks its condition before any execution of the loop.

Example do-while loop:

do

{

randomNumber = rand() % 10;

}while(randomNumber != 6);

Example while loop:

cout > number;

while(number < 0)

{

cout > number;

}

Binary is the simplest way to implement operations and information in a computer system.

However, It is not the only way.

But because of the nature and simplicity to switch electricity on and off it is a natural for computers.

Computers speak only one language which is composed of two sylables, namely "on" and "off". This is just like your light switch on the wall.

Computers are made up of millions of switches. This complexity allows logic functions, similar to human thought, to be performed.

This manifests as a very impressive operation only because a computer operates at such fast speeds.

Passing array elements to a function is achieved by passing the individual elements by reference or by value, just as you would any other variable. However, passing the entire array requires that you pass a pointer-to-pointer to the array along with the dimension(s) of the array.

#include<stdio.h>

void main()

{

int a,b,t;

printf("enter the values of two varaible");

scanf("%d%d",&a,&b);

t=a;

a=b;

b=t;

printf("the exchanged values are",b,a);

}

A singly-linked circular list is useful for implementing queue data structures with minimum overhead. Normally we implement a queue with two pointers: one to the tail for insertions and one to the head for extractions. With a circular list we only need to maintain a single pointer to the tail because the tail always points "forwards" to the head (instead of null as it normally would), thus achieving constant-time access to both the head and tail via a single pointer.

Circular linked lists are generally useful wherever "wraparound" is necessary. That is, from any given node in the list, we can traverse forwards with the guarantee that we will eventually arrive back at that same node. With doubly-linked circular lists we have the advantage of traversing in either direction (bi-directional traversal).

A 3D drawing is when you use shadows and a sense of depth to create space. making the drawing more convincing and ugly.just kidding more real i meant.

An inline function replaces the call to the function by the body of the function, thus reducing the overhead of saving the context in stack. This is good for functions which are small in size and called occasionally. A recursive function calls an instance of itself and thus can be a deeply nested. Different compilers handle this differently. Some will inline it up to a certain depth and then call a non-inlined instance for further recursion; others will not inline the function at all and generate a normal function call.

The number of dimensions is immaterial. All arrays are implemented as a one dimensional array. A multidimensional array is simply an array where every element is itself an array.

The only thing actually known about any array is that its name is a reference to the start address. Unlike an ordinary (non-array) variable, the elements in the array do not have names, we can only refer to them by their memory offsets from the start of the array. As such, in order to obtain the values stored at those offsets, we must dereference them. While the subscript operator gives us notational convenience, it's easy to forget that there's actually pointer arithmetic and dereferencing going on behind the scenes.

Two method of representing a binary tree is

Static allocation, and

Dynamic allocation

Repetition.

For example the following lines do the same thing:

while (expression) statement;

LABEL: if (expression) {statement; goto LABEL; }

Or these: for (exp1; exp2; exp3) statement;

exp1; LABEL: if (exp2) {statement; exp3; goto LABEL; }

Dijkstra's algorithm is used by the OSPF and the IS-IS routing protocols. The last three letters in OSPF (SPF) mean "shortest path first", which is an alternative name for Dijkstra's algorithm.