Computer Science

seq 1 2 99

MDI (Multiple Document Interface) is a Microsoft Windows programming interface for creating an application that enables users to work with multiple documents at the same time. Each document is in a separate space with its own controls for scrolling. The user can see and work with different documents such as a spreadsheet, a text document, or a drawing space by simply moving the cursor from one space to another. An MDI application is something like the Windows desktop interface since both include multiple viewing spaces. However, the MDI viewing spaces are confined to the application's window or client area . Within the client area, each document is displayed within a separate child window . MDI applications can be used for a variety of purposes - for example, working on one document while referring to another document, viewing different presentations of the same information, viewing multiple Web sites at the same time, and any task that requires multiple reference points and work areas at the same time

Subscripts are used when accessing arrays. An array is a contiguous block of memory containing two or more elements of the same type. Since each element is the same length, it is trivial to work out the offset address of one element relative to another using a zero-based index. For any type T, the type T[n] is an array of Ts with indices in the range 0 to n-1. We can also create arrays at runtime by allocating sufficient memory on the heap for the given type:

void f(int n) {

if (n<1) return; // cannot allocate 0 elements!

int* ptr = malloc (n * sizeof(int)); // allocate memory for n integers

if (ptr!=0) return; // ensure memory was allocated!

ptr[0] = 42; // use subscript operator to assign a value to the first element

// assign to other elements...

// use array...

free (ptr); // release memory as soon as we're finished with it

}

The complexity of Insertion Sort is O(n^2). This is the same complexity as Bubblesort, but is more efficient (quicker). However, it is unsuitable for large data sets which are best handled using an Introsort with O(n log n) complexity.

These two algorithms are almost completely different. The only real similarity is that they are each designed to use only integer addition/subtraction and multiplication, avoiding expensive division and floating point operations.

* search array => O(1) linked list=> O(n) binary tree=> O(log n) hash=>O(1) * search array => O(1) linked list=> O(n) binary tree=> O(log n) hash=>O(1)

java uses simple or primitive data types, such as int, char and Boolean etc. These data types are not part of the object hierarchy. They are passed by value to methods and cannot be directly passed by reference. However, at times there is a need to create an object representation of these simple data types. To address this need, Java provides classes that correspond to each of these simple types. These classes encapsulate, or wrap, the simple data type within a class. Thus, they are commonly referred to as wrapper classes.

Wrapper classes corresponding to respective simple data types are as given in table below.

Primitive Data Types

Wrapper class

byte

Byte

short

Short

int

Integer

long

Long

char

Character

float

Float

double

Double

boolean

Boolean

void

Void

eg

Say supposing there is a requirement to store only the

object in an array A.The Primitive types cannot be stored in

the same array as the array can accommodate only Objects

here is where Wrapper Class come into picture.ie, we create

wrapper for the primitive types.One such example is as below

Ex:int i;

Wrapper class for the primitive type(int) is created as below:

Integer i = new Integer();

It is less efficient on list containing more number of elements.

As the number of elements increases the performance of the program would be slow.

Insertion sort needs a large number of element shifts.

Using binary tree, one can create expression trees. The leaves of the expression tree are operands such as constants, variable names and the other node contains the operator (binary operator). this particular tree seems to be binary because all the operators used are binary operators. it is also possible for a node to have one node also, in case when a unary minus operator is used.

we can evaluate an expression tree by applying the operator at the root to the values obtained by recursively evaluating the left and right sub trees.

It is used for

1.to do complex computations

2. for data analysis

3. modelling

4.Calculations

5.Storage and Data Transfer

6.Mapping

-SubhaGolu

This is very common exception and name of the exception class tells exactly what kind of problem you have. If you would look into stack trace, which should have been generated too you would be able to find exact place where it happened.

The problem is that "Array Index Out Of Bounds". This means that you used index on array which is invalid. That could negative number, because all arrays starts from 0. If you array has N items and you will try to get item with index N or higher you will get this exception too. Only available indexes are from 0 to N - 1, where 0 points to the first item and N - 1 to the last one.

Let's look at an example. If you want to convert the number 100112 to decimal you can split up the number so each digit has an index associated to it:

4 3 2 1 0

1 0 0 1 1

We can then find the decimal value:

24 * 1 + 23 * 0 + 22 * 0 + 21 * 1 + 20 * 1 =

16 * 1 + 8 * 0 + 4 * 0 + 2 * 1 + 1 * 1 = 16 + 0 + 0 + 2 + 1 = 19

So what we need to do is to multiply each of the binary digits by the value of two raised to the index of the digit. This will give you the conversion from any binary number to a decimal number.

The body tag in HTML 5 does not support any element-specific attributes. It does however support the global attributes, and the event attributes.

Please see the related links for a complete reference.

An Adapter class is just a "blank" implementation of a Listener interface. They're convenience classes made so you don't need to implement all of the methods of an interface.

A good example is the MouseListener interface. Let's say you want to detect when a user clicks on your Component. You only need to implement the mouseClicked method to get that part working. This will leave you with...

public void mousePressed(MouseEvent e) {

}

public void mouseReleased(MouseEvent e) {

}

public void mouseEntered(MouseEvent e) {

}

public void mouseExited(MouseEvent e) {

}

...at the end of your implementation. Ugly. So Java gives us the MouseAdapter class (which gives us the same empty implementations as above). We can use this in place of a MouseListener to try to keep our code cleaner.

Basically it's all of your networks and supporting systems and in some cases the entire IT department as well.

A queue is simply a FIFO i.e first in first out. In queue we've front and rear. Front is the initial or first location of the queue whereas rear indicates the last entry location in the queue. In the circular queue the location of front and rear will be the same IF the total space of the circular queue is utilized. Each element has its position no. for insertion , if we set the 5th element as the front element then after every insertion the ptr indicates the 5th element as front. in deletion, the fifth element is deleted every time it is the rear position. after deletion of an element the queue rotates and every time the rear indicates the 5th element of the circular queue. and every time the 5th location element is deleted.

The copy constructor is used to initialize a new instance from an old

instance, and is called when passing variables by value into functions

or as return values out of functions.

The assignment operator is used to change an existing instance to have

the same values as the rvalue, which means that the instance has to be

destroyed and re-initialized if it has internal dynamic memory.

Firstly you would need to get the user input and initialize some variables (This is all done in C#):

string text = Console.ReadLine();

int numberOfEven = 0;

int numberOfOdd = 0;

int numberOfZero = 0;

int number = 0;

Then you would need to loop through the string to see for the odd and even numbers:

while(number < text.Length) // Loops through how many times there are // numbers in the string

{

if (text[number] 0) // Just like the one before, checks if it is // odd

{

numberOfOdd ++;

}

number ++;

}

And you can print off each of the integers to get how many evens, odds and zeros there are.

1.start

2.a=0,b=1,c and counter

3.display a

4.display b

5.c=a+b

6.display c

7.a=b

8.b=c

9.check whether number is less than the last number you have

if yes than go to step 5

if no stop it

arrays are used to store the group of data which are of same type.

These arrays can be applied in student mark sheet applications,online library applications etc.

• 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.