Constructor overloading is a concept of having more than one constructor with different parameters list, in such a way so that each constructor performs a different task. For e.g. Vector class has 4 types of constructors. If you do not want to specify the initial capacity and capacity increment then you can simply use default constructor of Vector class like this Vector v = new Vector(); however if you need to specify the capacity and increment then you call the parameterized constructor of Vector class with two int arguments like this: Vector v= new Vector(10, 5);

Constructor overloading Program :-

1. public class Student {  
2. //instance variables of the class  
3. int id;  
4. String name;  
5.   
6. Student(){  
7. System.out.println("this a default constructor");  
8. }  
9.   
10. Student(int i, String n){  
11. id = i;  
12. name = n;  
13. }  
14.   
15. public static void main(String[] args) {  
16. //object creation  
17. Student s = new Student();  
18. System.out.println(" Default Constructor values:  ");  
19. System.out.println("Student Id : "+s.id + " Student Name : "+s.name);  
20.   
21. System.out.println(" Parameterized Constructor values:  ");  
22. Student student = new Student(10, "David");  
23. System.out.println("Student Id : "+student.id + " Student Name : "+student.name);  
24. }  
25. }  

Output :-

this a default constructor

Default Constructor values:

Student Id : 0

Student Name : null

Parameterized Constructor values: 

Student Id : 10

Student Name : David

If a class, has multiple methods having same name but different in parameters, it is known as Method Overloading.

Method overloading is a form of polymorphism in OOP. Polymorphism allows objects or methods to act in different ways, according to the means in which they are used. One such manner in which the methods behave according to their argument types and number of arguments is method overloading.

For example: 

Here, the func() method is overloaded. These methods have the same name but accept different arguments.

(i) Refer Diagram 1.

(ii) Refer Diagram 2.

ID3 Steps :-

1. Calculate the Information Gain of each feature. 

2. Considering that all rows don’t belong to the same class, split the dataset S into subsets using the feature for which the Information Gain is maximum. 

3. Make a decision tree node using the feature with the maximum Information gain. 

4. If all rows belong to the same class, make the current node as a leaf node with the class as its label.

5. Repeat for the remaining features until we run out of all features, or the decision tree has all leaf nodes

ID3 uses a top-down greedy approach to build a decision tree. In simple words, the top-down approach means that we start building the tree from the top and the greedy approach means that at each iteration we select the best feature at the present moment to create a node.

ID3 uses Information Gain or just Gain to find the best feature.

Information Gain calculates the reduction in the entropy and measures how well a given feature separates or classifies the target classes. The feature with the highest Information Gain is selected as the best one.

In simple words, Entropy is the measure of disorder and the Entropy of a dataset is the measure of disorder in the target feature of the dataset. In the case of binary classification (where the target column has only two types of classes) entropy is 0 if all values in the target column are homogenous(similar) and will be 1 if the target column has equal number values for both the classes.

We denote our dataset as S, entropy is calculated as: Entropy(S) = - ∑ pᵢ * log₂(pᵢ) ; i = 1 to n

where, n is the total number of classes in the target column (in our case n = 2 i.e YES and NO) pᵢ is the probability of class ‘i’ or the ratio of “number of rows with class i in the target column” to the “total number of rows” in the dataset.

Information Gain for a feature column A is calculated as: IG(S, A) = Entropy(S) - ∑((|Sᵥ| / |S|) * Entropy(Sᵥ))

where Sᵥ is the set of rows in S for which the feature column A has value v, |Sᵥ| is the number of rows in Sᵥ and likewise |S| is the number of rows in S.

1. Important attributes :- There are two attributes shown in the diagram, instance and isa. Since these attributes support property of inheritance, they are of prime importance. 

2. Relationships among attributes  :- Basically, the attributes used to describe objects are nothing but the entities. However, the attributes of an object do not depend on the encoded specific knowledge. 

3. Choosing the granularity of representation :- While deciding the granularity of representation, it is necessary to know the following: 

i. What are the primitives and at what level should the knowledge be represented? 

ii. What should be the number (small or large) of low-level primitives or high-level facts? 

High-level facts may be insufficient to draw the conclusion while Low-level primitives may require a lot of storage. For example: Suppose that we are interested in following facts: John spotted Alex. 

Now, this could be represented as "Spotted (agent(John), object (Alex))" 

Such a representation can make it easy to answer questions such as: Who spotted Alex? 

Suppose we want to know : "Did John see Sue?" Given only one fact, user cannot discover that answer. 

Hence, the user can add other facts, such as "Spotted (x, y) → saw (x, y)" 

4. Representing sets of objects :- There are some properties of objects which satisfy the condition of a set together but not as individual; 

Example: Consider the assertion made in the sentences: "There are more sheep than people in Australia", and "English speakers can be found all over the world." 

These facts can be described by including an assertion to the sets representing people, sheep, and English. 

5. Finding the right structure as needed :- To describe a particular situation, it is always important to find the access of right structure. This can be done by selecting an initial structure and then revising the choice.

While selecting and reversing the right structure, it is necessary to solve following problem statements. 

They include the process on how to: 

• Select an initial appropriate structure. 

• Fill the necessary details from the current situations. 

• Determine a better structure if the initially selected structure is not appropriate to fulfill other conditions. 

• Find the solution if none of the available structures is appropriate. 

• Create and remember a new structure for the given condition. 

• There is no specific way to solve these problems, but some of the effective knowledge representation techniques have the potential to solve them.

The solution is given below :-

Concept Learning :- Acquiring the definition of a general category from given sample positive and negative training examples of the category. Concept Learning can seen as a problem of searching through a predefined space of potential hypotheses for the hypothesis that best fits the training examples. 

General Hypothesis :- Hypothesis, in general, is an explanation for something. The general hypothesis basically states the general relationship between the major variables.

1. The process starts with initializin generally, it is the first positive example in the data set. 

2. We check for each positive example. If the example is negative, we will move on to the next example but if it is a positive example we will consider it for the next step. 

3. We will check if each attribute in the example is equal to the hypothesis value. 

4. If the value matches, then no changes are made. 

5. If the value does not match, the value is changed to ‘?’. 

6. We do this until we reach the last positive example in the data set.

The solution is given below :-

Ground water is a precious and the most widely distributed resource of the earth and unlike any other minerals resource, its get annual replenishment from the meteoric precipitation. 

Sample input:

Cat

Sample output:

Ct

Sample input:

Heel

Sample Output:

Heel

Execution Time limit:

• 10 Sec

Code:

x=input()
array=[]
array2=["a","e","i","o","u"]
for i in range(len(x)):
    array.append(x[i])
for k in range(len(array)-1):
    if array[k] in array2:
        if array[k+1] == array[k]:
            break;
        else:
            array.remove(array[k])
print('.join(array))