Programming, Data Structures & Algorithms

Relevant Course / Subjects to Artificial Intelligence

2013-01-29T09:51:00.002-08:00

Philosophy : Logic, methods of reasoning, mind as physical system, foundations of learning, language, rationality.

Mathematics: Formal representation and proof, algorithms, computation, (un)decidability, (in)tractability

Probability/Statistics: Modeling uncertainty, learning from data

Economics: Utility, decision theory, rational economic agents

Neuroscience: Neurons as information processing units.

Psychology/ Cognitive Science: How do people behave, perceive, process cognitive information, represent knowledge.

Computer engineering: Building fast computers

Control theory: Design systems that maximize an objective function over time

Linguistics: Knowledge representation, grammars.

Intelligence and Artificial Intelligence, what is it?

2013-01-29T09:32:00.001-08:00

What is artificial intelligence?

Artificial intelligence is the intelligence of machines and robots and the branch of computer science that aims to create it. - Wikipedia.
It is the science and engineering of making intelligent machines, especially intelligent computer programs. It is related to the similar task of using computers to understand human intelligence, but AI does not have to confine itself to methods that are biologically observable.

What is intelligence?

“the capacity to learn and solve problems” (Websters dictionary)
In particular,

the ability to solve novel problems
the ability to act rationally
the ability to act like humans refere to AI.

Intelligence is the computational part of the ability to achieve goals in the world. Varying kinds and degrees of intelligence occur in people, many animals and some machines.

Knapsack Algorithm Shortcut Method

2012-05-17T12:51:00.001-07:00

The knapsack problem or rucksack problem is a problem in combinatorial optimization: Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. It derives its name from the problem faced by someone who is constrained by a fixed-size knapsack and must fill it with the most valuable items.
The main goal of Knapsack is:

You have a knapsack that has capacity (weight) W.
You have several items I1,…,In.
Each item Ij has a weight wj and a benefit bj.You want to place a certain number of copies of each item Ij in the knapsack so that: The knapsack weight capacity is not exceeded and The total benefit is maximal.

There is a Shortcut Method for Knapsack Algorithm , see the video:

Java Program for finding Palindrome

2012-05-13T15:34:00.000-07:00

Just follow the program to find Palindrome in java:

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Palindrome {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s1 = new String();

s1 =br.readLine();

s1 = s1.toLowerCase();
String s2 = new StringBuffer(s1).reverse().toString();

if(s1.equals(s2)){
System.out.println("Palindrome");
}else
System.out.println("Not Palindrome");
}
}

Read or input form user in Java using BufferedReader

2012-05-13T14:15:00.001-07:00

BufferedReader use to read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.The buffer size may be specified, or the default size may be used. The default is large enough for most purposes.
In Java BufferedReader is a efficient method to read an input. Here given a short example to read a string from user and print it:


package palindrome;



import java.io.BufferedReader;

import java.io.InputStreamReader;



public class 
inputExample  {



    public static void main(String[] args) throws Exception {



   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    String s = new String();

  

    s =br.readLine();

    System.out.println(s);

    }

}

Difference between Scanner vs. BufferedReader

2012-05-13T14:09:00.001-07:00

BufferedReader Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines. The buffer size may be specified, or the default size may be used. The default is large enough for most purposes.

Where Scanner is a simple text scanner which can parse primitive types and strings using regular expressions. A Scanner breaks its input into tokens using a delimiter pattern, which by default matches whitespace. The resulting tokens may then be converted into values of different types using the various next methods.

Scanner is used for parsing tokens from the contents of the stream while BufferedReader just reads the stream and does not do any special parsing. In currently latest JDK6 release/build, the Scanner has a littler buffer (1KB char buffer) as opposed to the BufferedReader (8KB byte buffer), but it's more than enough.As to the choice, use the Scanner if you want to parse the file, use the BufferedReader if you want to read the file line by line. Also see the introductory text of their aforelinked API documentations.

A BufferedReader is a simple class meant to efficiently read from the underling stream. Generally, each read request made of a Reader like a FileReadercauses a corresponding read request to be made to underlying stream. Each invocation of read() or readLine() could cause bytes to be readfrom the file, converted into characters, and then returned, which can be very inefficient. Efficiency is improved appreciably if a Reader is warped in a BufferedReader. BufferedReader is synchronized, so read operations on a BufferedReadercan safely be done from multiple threads.

A scanner on the other hand has a lot more cheese built into it; it can do all that a BufferedReader can do and at the same level of efficiency as well. However, in addition a Scanner can parsethe underlying stream for primitive types and strings using regular expressions. It can also tokenize the underlying stream with the delimiter of your choice. It can also do forward scanning of the underlying stream disregardingthe delimiter! A scanner however is not thread safe, it has to be externally synchronized.

The choice of using a BufferedReader or a Scanner depends on the codeyou are writing, if you are writing a simple log reader Buffered readeris adequate. However if you are writing an XML parser Scanner isthe more natural choice.

Difference Between Function and Method

2012-05-13T12:27:00.001-07:00

Each language has its own lexicon of terms with special meaning. In C Programming Language, the word Function means a program routine. In Java, the term Function does not have any special meaning. Whereas Method means one of the routines that forms the implementation of a class.

First let we know what is Function?

A function is a piece of reuseable code that is called by name. In C or C++ we used to say function to a reusable code. It can be passed data to operate on (arguments / parameters) and can optionally return a result. Function is a portion of code within a larger program, which performs a specific task and is relatively independent of the remaining code.

So What is Method??

A method is a piece of code that is called by name that is associated with an object. A method is almost identical to a function but it's purpose is generally to operate on the data contained within the component (class). Method is a function that is a member of a class.

If you know little bit about Function and Method, you may noticed that "Functions stand alone and methods are members of a class."

Now You can Say: Method != Function and Function != Method [ :P]

We can find another difference and that is: In C programmer used to say Function. In the same way java programmer used to say Method.

Implementation of Artificial Intelligent

2012-03-02T09:54:00.001-08:00

Artificial Intelligent successfully been used and using in:

Finance
Robotics
Games
Medicines
The Web and many more..

What exactly Artificial Intelligence or AI is?

2012-03-02T09:43:00.002-08:00

Artificial intelligence or AI is the intelligence of machines, any kind of machines that is programmable. And it is called AI program. Now another topics come here, that is "What is AI or Artificial Intelligence program is?" Yes, AI program is called Intelligent Agent.

Do you know what is Intelligent Agent?
An intelligent agent is a system that perceives its environment and takes actions that maximize its chances of success. I will discuss more about intelligent agent in my next post. Stay with me. Thank You.

C++ Code of Bubble Sort

2012-02-21T11:37:00.003-08:00

Bubble sort, often incorrectly referred to as sinking sort, is a simple sorting algorithm that works by repeatedly stepping through the list to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order.

Here is the C++ implantation of Bubble sort

#include <iostream>

using namespace std;

int main()
{
    int i,j, n;
    cout<< "How much number you will sort?" << endl;
    cin>>n;
    int a[n];
    for(int x=1; x<=n;x++)
    {
        cout<< "Enter "<< " Number "  << x <<": "  << endl;
        cin>>a[x];

    }
for(int i=1; i<=n;i++)
    for(int j=i+1; j<=n;j++)
        {
        if (a[i]>a[j]){
            int temp;
            temp = a[i];
            a[i]=a[j];
            a[j]=temp;
        }

}

cout<< "Sorted numbers are:" << endl;
for(int x=1; x<=n;x++)
    {
        cout<< a[x] << ", ";

    }

    return 0;
}

Thanks, Jakir Hossain

Integer Numbers in Programming Language

2011-09-19T09:14:00.000-07:00

An integer variable may be defined to be of type short, int, or long. The only difference is that an int uses more or at least the same number of bytes as a short, and a long uses more or at least the same number of bytes as an int. For example, on the author’s PC, a short uses 2 bytes, an int also 2 bytes, and a long 4 bytes.

short age = 20;

int salary = 65000;

long price = 4500000;

By default, an integer variable is assumed to be signed (i.e., have a signed representation so that it can assume positive as well as negative values). However, an integer can be defined to be unsigned by using the keyword unsigned in its definition. The keyword signed is also allowed but is redundant.

unsigned short age = 20;

unsigned int salary = 65000;

unsigned long price = 4500000;

A literal integer (e.g., 1984) is always assumed to be of type int, unless it has an L or l suffix, in which case it is treated as a long. Also, a literal integer can be specified to be unsigned using the suffix U or u. For example:

1984L 1984l 1984U 1984u 1984LU 1984ul

Literal integers can be expressed in decimal, octal, and hexadecimal notations. The decimal notation is the one we have been using so far. An integer is taken to be octal if it is preceded by a zero (0), and hexadecimal if it is preceded by a 0x or 0X. For example:

92 // decimal

0134 // equivalent octal

0x5C // equivalent hexadecimal

Octal numbers use the base 8, and can therefore only use the digits 0-7. Hexadecimal numbers use the base 16, and therefore use the letter A-F (or a-f) to represent, respectively, 10-15. Octal and hexadecimal numbers are calculated as follows:

0134 = 1 × 82 + 3 × 81 + 4 × 80 = 64 + 24 + 4 = 92

0x5C = 5 × 161 + 12 × 160 = 80 + 12 = 92

Memory, Memory Address in Programming Language

2011-09-19T08:04:00.000-07:00

A computer provides a Random Access Memory (RAM) for storing executable program code as well as the data the program manipulates. This memory can be thought of as a contiguous sequence of bits, each of which is capable of storing a binary digit (0 or 1). Typically, the memory is also divided into groups of 8 consecutive bits (called bytes). The bytes are sequentially addressed. Therefore each byte can be uniquely identified by its address.

Figure: Bits and bytes in memory.

The C++ compiler generates executable code which maps data entities to memory locations. For example, the variable definition

int salary = 65000;

causes the compiler to allocate a few bytes to represent salary. The exact number of bytes allocated and the method used for the binary representation of the integer depends on the specific C++ implementation, but let us say two bytes encoded as a 2’s complement integer. The compiler uses the address of the first byte at which salary is allocated to refer to it. The above assignment causes the value 65000 to be stored as a 2’s complement integer in the two bytes allocated.

Figure: Representation of an integer in memory.

While the exact binary representation of a data item is rarely of interest to a programmer, the general organization of memory and use of addresses for referring to data items (as we will see later) is very important.

Comments in Programming Language

2011-09-19T07:56:00.000-07:00

A comment is a piece of descriptive text which explains some aspect of a program. Program comments are totally ignored by the compiler and are only intended for human readers.

C++ provides two types of comment delimiters:

· Anything after // (until the end of the line on which it appears) is considered a comment.

· Anything enclosed by the pair /* and */ is considered a comment.

Comments should be used to enhance (not to hinder) the readability of a program.

The following two points, in particular, should be noted:

· A comment should be easier to read and understand than the code which it tries to explain. A confusing or unnecessarily-complex comment is worse han

no comment at all.

· Over-use of comments can lead to even less readability. A program which contains so much comment that you can hardly see the code can by no means be considered readable.

· Use of descriptive names for variables and other entities in a program, and proper indentation of the code can reduce the need for using comments. The best guideline for how to use comments is to simply apply common sense.

Variables In Programming Language

2011-09-19T07:50:00.000-07:00

A variable is a symbolic name for a memory location in which data can be stored and subsequently recalled. Variables are used for holding data values so that they can be utilized in various computations in a program. All

variables have two important attributes:

· A type which is established when the variable is defined (e.g., integer, real, character). Once defined, the type of a C++ variable cannot be changed.

· A value which can be changed by assigning a new value to the variable. The kind of values a variable can assume depends on its type. For example, an integer variable can only take integer values (e.g., 2, 100, -12).

Compilation Process of a C++ Program

2011-09-19T07:47:00.000-07:00

Compiling a C++ program involves a number of steps (most of which are

transparent to the user):

· First, the C++ preprocessor goes over the program text and carries out theinstructions specified by the preprocessor directives (e.g., #include). The result is a modified program text which no longer contains any directives.

· Then, the C++ compiler translates the program code. The compiler may be a true C++ compiler which generates native (assembly or machine) code, or just a translator which translates the code into C. In the latter case, the resulting C code is then passed through a C compiler to produce native object code. In either case, the outcome may be incomplete due to the program referring to library routines which are not defined as a part of the program. For example, Listing 1.1 refers to the << operator which is actually defined in a separate IO library.

· Finally, the linker completes the object code by linking it with the object code of any library modules that the program may have referred to. The final result is an executable file.

In the following Figure, illustrates the above steps for both a C++ translator and a C++ native compiler. In practice all these steps are usually invoked by a single command (e.g. CC) and the user will not even see the intermediate files generated.

A simple C++ Program and Explanation of it

2011-09-19T06:39:00.000-07:00

A simple C++ Program and Explanation of it:

#include <iostream.h>

int main (void)

{

cout << "Hello World\n";

}

#include <iostream.h>

1. This line uses the preprocessor directive #include to include the contents of the header file iostream.h in the program. Iostream.h is a standard C++ header file and contains definitions for input and output.

int main (void)

2. This line defines a function called main. A function may have zero or more parameters; these always appear after the function name, between a pair of brackets. The word void appearing between the brackets indicates that main has no parameters. A function may also have a return type; this always appears before the function name. The return type for main is int (i.e., an integer number). All C++ programs must have exactly one main function. Program execution always begins from main.

{

3. This brace marks the beginning of the body of main.

cout << "Hello World\n";

4. This line is a statement. A statement is a computation step which may produce a value. The end of a statement is always marked with a semicolon (;). This statement causes the string "Hello World\n" to be sent to the cout output stream. A string is any sequence of characters enclosed in double-quotes. The last character in this string (\n) is a newline character which is similar to a carriage return on a type writer. A stream is an object which performs input or output. Cout is the standard output stream in C++ (standard output usually means your computer monitor screen). The symbol << is an output operator which takes an output stream as its left operand and an expression as its right operand, and causes the value of the latter to be

5. sent to the former. In this case, the effect is that the string "Hello World\n" is sent to cout, causing it to be printed on the computer monitor screen.

}

6. This brace marks the end of the body of main.

Polymorphism, Encapsulation, and Inheritance Work Together

2011-09-19T03:01:00.000-07:00

Polymorphism, Encapsulation, and Inheritance Work Together:

When properly applied, polymorphism, encapsulation, and inheritance combine to produce a programming environment that supports the development of far more robust and scaleable programs than does the process-oriented model. A well-designed hierarchy of classes is the basis for reusing the code in which you have invested time and effort developing and testing. Encapsulation allows you to migrate your implementations over time without breaking the code that depends on the public interface of your classes. Polymorphism allows you to create clean, sensible, readable, and resilient code. Of the two real-world examples, the automobile more completely illustrates the power of object-oriented design. Dogs are fun to think about from an inheritance standpoint, but cars are more like programs. All drivers rely on inheritance to drive different types (subclasses) of vehicles. Whether the vehicle is a school bus, a Mercedes sedan, a Porsche, or the family minivan, drivers can all more or less find and operate the steering wheel, the brakes, and the accelerator. After a bit of gear grinding, most people can even manage the difference between a stick shift and an automatic, because they fundamentally understand their common superclass, the transmission.

People interface with encapsulated features on cars all the time. The brake and gas pedals hide an incredible array of complexity with an interface so simple you can operate them with your feet! The implementation of the engine, the style of brakes, and the size of the tires have no effect on how you interface with the class definition of the pedals. The final attribute, polymorphism, is clearly reflected in the ability of car manufacturers to offer a wide array of options on basically the same vehicle. For example, you can get an antilock braking system or traditional brakes, power or rack-and-pinion steering, 4-, 6-, or 8-cylinder engines. Either way, you will still press the break pedal to stop, turn

the steering wheel to change direction, and press the accelerator when you want to move. The same interface can be used to control a number of different implementations. As you can see, it is through the application of encapsulation, inheritance, and polymorphism that the individual parts are transformed into the object known as a car. The same is also true of computer programs. By the application of object-oriented principles, the various parts of a complex program can be brought together to form

a cohesive, robust, maintainable whole. As mentioned at the start of this section, every Java program is object-oriented. Or, put more precisely, every Java program involves encapsulation, inheritance, and

polymorphism. Although the short example programs shown in the rest of this chapter and in the next few chapters may not seem to exhibit all of these features, they are nevertheless present. As you will see, many of the features supplied by Java are part of its built-in class libraries, which do make extensive use of encapsulation, inheritance, and polymorphism.

Polymorphism In JAV A Programming Languagea

2011-09-19T02:55:00.000-07:00

Polymorphism In JAV A Programming Language:

Polymorphism (from the Greek, meaning “many forms”) is a feature that allows one interface to be used for a general class of actions. The specific action is determined by the exact nature of the situation. Consider a stack (which is a last-in, first-out list). You might have a program that requires three types of stacks. One stack is used for integer values, one for floating-point values, and one for characters. The algorithm that implements each stack is the same, even though the data being stored differs. In a non– object-oriented language, you would be required to create three different sets of stack routines, with each set using different names. However, because of polymorphism, in Java you can specify a general set of stack routines that all share the same names. More generally, the concept of polymorphism is often expressed by the phrase “one interface, multiple methods.” This means that it is possible to design a generic interface to a group of related activities. This helps reduce complexity by allowing the same interface to be used to specify a general class of action. It is the compiler’s job to select the specific action (that is, method) as it applies to each situation. You, the programmer, do not need to make this selection manually. You need only remember and utilize the general interface.

Extending the dog analogy, a dog’s sense of smell is polymorphic. If the dog smells a cat, it will bark and run after it. If the dog smells its food, it will salivate and run to its bowl. The same sense of smell is at work in both situations. The difference is what is being smelled, that is, the type of data being operated upon by the dog’s nose! This same general concept can be implemented in Java as it applies to methods within a Java program.

Inheritance in JAVA Programming Language

2011-09-19T02:49:00.000-07:00

Inheritance in JAVA Programming Language:

Inheritance is the process by which one object acquires the properties of another object. This is important because it supports the concept of hierarchical classification. As mentioned earlier, most knowledge is made manageable by hierarchical (that is, top-down) classifications. For example, a Golden Retriever is part of the classification dog, which in turn is part of the mammal class, which is under the larger class animal. Without the use of hierarchies, each object would need to define all of its characteristics explicitly. However, by use of inheritance, an object need only define those qualities that make it unique within its class. It can inherit its general attributes from its parent. Thus, it is the inheritance mechanism that makes it possible for one object to be a specific instance of a more general case. Let’s take a closer look at this process.

Most people naturally view the world as made up of objects that are related to each other in a hierarchical way, such as animals, mammals, and dogs. If you wanted to describe animals in an abstract way, you would say they have some attributes, such as size, intelligence, and type of skeletal system. Animals also have certain behavioral aspects; they eat, breathe, and sleep. This description of attributes and behavior is the class definition for animals.

If you wanted to describe a more specific class of animals, such as mammals, they would have more specific attributes, such as type of teeth, and mammary glands. This is known as a subclass of animals, where animals are referred to as mammals’ superclass. Since mammals are simply more precisely specified animals, they inherit all of the attributes from animals. A deeply inherited subclass inherits all of the attributes from each of its ancestors in the class hierarchy.

Inheritance interacts with encapsulation as well. If a given class encapsulates some attributes, then any subclass will have the same attributes plus any that it adds as part of its specialization (see Figure 2-2). This is a key concept which lets object-oriented programs grow in complexity linearly rather than geometrically. A new subclass inherits all of the attributes of all of its ancestors. It does not have unpredictable interactions with the majority of the rest of the code in the system.

Encapsulation in JAVA Programming Language

2011-09-19T02:42:00.000-07:00

Encapsulation:

Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse. One way to think about encapsulation is as a protective wrapper that prevents the code and data from being arbitrarily accessed by other code defined outside the wrapper. Access to the code and data inside the wrapper is tightly controlled through a well-defined interface. To relate this to the real world, consider the automatic transmission on an automobile.

It encapsulates hundreds of bits of information about your engine, such as how much you are accelerating, the pitch of the surface you are on, and the position of the shift lever. You, as the user, have only one method of affecting this complex encapsulation: by moving the gear-shift lever. You can’t affect the transmission by using the turn signal or windshield wipers, for example. Thus, the gear-shift lever is a well-defined (indeed, unique) interface to the transmission. Further, what occurs inside the transmission does not affect objects outside the transmission. For example, shifting gears does not turn

on the headlights! Because an automatic transmission is encapsulated, dozens of car manufacturers can implement one in any way they please. However, from the driver’s point of view, they all work the same. This same idea can be applied to programming. The power of encapsulated code is that everyone knows how to access it and thus can use it regardless of the implementation details—and without fear of unexpected side effects.

In Java the basis of encapsulation is the class. Although the class will be examined in great detail later in this book, the following brief discussion will be helpful now. A class defines the structure and behavior (data and code) that will be shared by a set of objects. Each object of a given class contains the structure and behavior defined by the class, as if it were stamped out by a mold in the shape of the class. For this reason, objects are sometimes referred to as instances of a class. Thus, a class is a logical construct; an

object has physical reality.

When you create a class, you will specify the code and data that constitute that class. Collectively, these elements are called members of the class. Specifically, the data defined by the class are referred to as member variables or instance variables. The code that operates on that data is referred to as member methods or just methods. (If you are familiar with C/C++, it may help to know that what a Java programmer calls a method, a C/C++ programmer calls a function.) In properly written Java programs, the methods define how the member variables can be used. This means that the behavior and interface of a class are defined by the methods that operate on its instance data.

Since the purpose of a class is to encapsulate complexity, there are mechanisms for hiding the complexity of the implementation inside the class. Each method or variable in a class may be marked private or public. The public interface of a class represents everything that external users of the class need to know, or may know. The private methods and data can only be accessed by code that is a member of the class. Therefore, any other code that is not a member of the class cannot access a private method or variable. Since the private members of a class may only be accessed by other parts of your program through the class’ public methods, you can ensure that no improper actions take place. Of course, this means that the public interface should be carefully designed not to expose too much of the inner workings of a class .

Abstraction in JAVA Programming Language

2011-09-19T02:38:00.000-07:00

Abstraction in JAVA Programming Language:

An essential element of object-oriented programming is abstraction. Humans manage complexity through abstraction. For example, people do not think of a car as a set of tens of thousands of individual parts. They think of it as a well-defined object with its own unique behavior. This abstraction allows people to use a car to drive to the grocery

store without being overwhelmed by the complexity of the parts that form the car. They can ignore the details of how the engine, transmission, and braking systems work. Instead they are free to utilize the object as a whole.

A powerful way to manage abstraction is through the use of hierarchical classifications. This allows you to layer the semantics of complex systems, breaking them into more manageable pieces. From the outside, the car is a single object. Once inside, you see that the car consists of several subsystems: steering, brakes, sound system, seat belts, heating, cellular phone, and so on. In turn, each of these subsystems is made up of more specialized units. For instance, the sound system consists of a radio, a CD player, and/or a tape player. The point is that you manage the complexity of the car (or any other complex system) through the use of hierarchical abstractions. Hierarchical abstractions of complex systems can also be applied to computer programs. The data from a traditional process-oriented program can be transformed by abstraction into its component objects. A sequence of process steps can become a collection of messages between these objects. Thus, each of these objects describes its own unique behavior. You can treat these objects as concrete entities that respond to messages telling them to do something. This is the essence of object-oriented programming.

Object-oriented concepts form the heart of Java just as they form the basis for human understanding. It is important that you understand how these concepts translate into programs. As you will see, object-oriented programming is a powerful and natural paradigm for creating programs that survive the inevitable changes accompanying the life cycle of any major software project, including conception, growth, and aging. For example, once you have well-defined objects and clean, reliable interfaces to those objects, you can gracefully decommission or replace parts of an older system without fear.

Object-Oriented Programming and JAVA Programming Language

2011-09-19T02:35:00.000-07:00

Object-Oriented Programming and:

Object-oriented programming (OOP) is a programming paradigm using "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as data abstraction, encapsulation, messaging, modularity, olymorphism, and inheritance. Many modern programming languages now support OOP, at least as an option.

JAVA Programming Language:

Object-oriented programming is at the core of Java. In fact, all Java programs are object-oriented, this isn’t an option the way that it is in C++, for example. OOP is so integral to Java that you must understand its basic principles before you can write even simple Java programs. Therefore, this chapter begins with a discussion of the theoretical aspects of OOP.

Adding two integer array element wise.

2011-09-18T12:39:00.000-07:00

Here given an program that adds two integer array element wise.

#include <iostream>

using namespace std;

int* sum(int*, int, int*, int);
void print(int*, int);
int main()
{

int a[] = {11,22,33,44,55};
int b[]={66,77,88};
print(a,5);
print(b,3);
int* c= sum(a,5,b,3);
print(c,5);
}

int* sum(int* a, int m, int*b, int n)
{
int* aa, *bb;
int mm, nn;
if(m<n) aa = a, bb=b, mm=m, nn=n;
else aa=b, bb=a, mm=n, nn=m;
int* c = new int[nn];
for(int i=0; i< mm; i++)
c[i]= aa[i] + bb[i];
for (int i=mm;i<nn; i++)
c[i]=bb[i];
return c;

}
void print(int* a, int n)
{

cout <<"{" << a[0];
for (int i=1;i<n;i++)
cout << "," << a[i];
cout << "} \n";
}

Appends one array to another and print them in C++

2011-09-18T12:10:00.000-07:00

In the following program, show how to append or add one array to another.

#include <iostream>

using namespace std;

int* append(int*, int, int*, int);
void print(int*, int);
int main()
{

int a[] = {11,22,33,44,55};
int b[]={66,77,88,99};
print(a,5);
print(b,5);
int* c= append(a,5,b,5);
print(c,9);
}

int* append(int* a, int m, int*b, int n)
{
int* c= new int[m+n];
for (int i=0; i<m;i++)
c[i]=a[i];
for(int i=m;i<m+n;i++)
c[i]=b[i-m];
return c;

}
void print(int* a, int n)
{

cout <<"{" << a[0];
for (int i=1;i<n;i++)
cout << "," << a[i];
cout << "} \n";
}

Finding maximum value of an array in C++

2011-09-18T11:54:00.000-07:00

In the following program you can find maximum value of an array:

#include <iostream>

using namespace std;
int min(int*, int);
int main()
{
int array[]={66,44,88,11,77,33,99,55,22};
cout<< "min(array,9)=" << min(array,9);
}
int min(int* array, int n)
{

int m=array[0];
for(int i=1;i<n;i++)
if (array[i]>m) m=array[i];
return m;
}