Working with Array - Inbuilt Functions in Java

 

Leetcode 2894. Divisible and Non-divisible Sums Difference

 

Problem Statement:

 leetcode problem 2894. Divisible and Non-divisible Sums Difference - 

You are given positive integers n and m.

Define two integers as follows:num1: The sum of all integers in the range [1, n] (both inclusive) that are not divisible by m.
num2: The sum of all integers in the range [1, n] (both inclusive) that are divisible by m.

Return the integer num1 - num2.

Initial Code

class Solution {
    public int differenceOfSums(int n, int m) {
        int suma = 0;sumb=0; // ERROR: sumb not declared properly
        for (int i=1; i==n; i++){ // ERROR: i==n (this never iterates)
            if(i%m==0){
                sumb+=i;
            }else{
                suma+=i;
            }
        }
        return suma-sumb;
    }
}

Issues in the code:

• Variable declaration: sumb is undeclared.
• Loop condition: for (int i = 1; i == n; i++) executes only when i equals n, so it never loops. It must be i <= n.
• Minor style: combining declarations on one line makes it harder to read

Corrected code

class Solution {
    public int differenceOfSums(int n, int m) {
        int suma = 0;
        int sumb = 0;
        for (int i = 1; i <= n; i++) {
            if (i % m == 0) sumb += i;
            else suma += i;
        }
        return suma - sumb;
    }
}

Object Oriented Programming Concepts in a MindMap

 

Understanding Object-Oriented Programming (OOP) is fundamental for modern software development. OOP concepts, such as classes and objects, encapsulation, inheritance, and polymorphism, allow developers to create modular, reusable, and maintainable code. 

MindMap Representation of OOP's Concept

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to design applications and computer programs.

Understanding Class

Class in Java is a  blueprint of attributes and behavior (actions) of an object.

Below are the members of a class:

• Class Variables (Static Fields): These are common to all instances of a class and are declared with the `static` modifier. 

• Instance Variables (Non-static Fields): These are unique to each instance of a class. Following the `Bicycle` example, `cadence`, `gear`, and `speed` would be instance variables, with each `Bicycle` object having its own copy.

• Methods: These are functions that define the behavior of the objects created from the class. They can be static (class methods) or non-static (instance methods).

• Constructors: Special methods used to initialize new objects. They have the same name as the class and may take parameters to set initial values for the instance variables.

• Nested Classes: Classes can contain other classes, known as nested classes.

Principle of OOPs concept:

•  Encapsulation: Bundling the data with the code that manipulates it

• Bundling data (variables) and methods (functions) that operate on the data into a class. 
• Access to the data is restricted and controlled through public methods known as getters and setters. 
• Allows for data hiding, where internal workings of a class are hidden from outside  interference and misuse. 
• Promotes modularity and maintainability of code 
• Enhances data security, as only approved methods can modify the internal state of objects.

• Data Types 

• Public: accessible from any other class, not just the class in which it is declared.
• Protected: accessible within its own class and by derived classes.
• Private: accessible within the class in which it is declared, and not from any other class.

• Abstraction: Hiding complex realities while exposing only the necessary parts.
• Achieved through abstract classes and interfaces, allowing for the creation of classes that cannot be instantiated on their own but can be sub classed.
• Abstract classes may contain abstract methods without a body; these methods must be implemented by subclasses.
• An interface is a blueprint for a class
•  Include abstract methods and constants.
• Used to achieve abstraction and multiple inheritance, as a class can implement multiple interfaces.
• Class implementing an interface must override all of its methods.
• Interfaces cannot be instantiated—they can only be implemented by classes or extended by other interfaces.

• Inheritance: Allowing new objects to take on the properties of existing one.

• Inheritance in Java allows one class to inherit the features (fields and methods) of another class.
• Syntax for inheritance uses the `extends` keyword
• Java supports different types of inheritance: single, multilevel, and hierarchical.
• Multiple inheritance is not supported in Java through classes, but it can be achieved using interfaces.

• Polymorphism: Allows objects to take on multiple forms.
• Manifests in two primary forms: compile-time (static) and runtime (dynamic) polymorphism.
• Compile-time polymorphism is achieved through method overloading, where multiple methods have the same name but different parameter lists.
• Runtime polymorphism is realized through method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass.