practice DONE

JavaCourse/src/main/java/com/rinftech/practice/Practice.java

@@ -0,0 +1,129 @@
+package com.rinftech.practice;
+
+import java.util.*;
+
+public class Practice {
+
+    //1
+    public int sumOfDigits(int number) {
+        int sum = 0;
+        while (number != 0) {
+            sum += number % 10;
+            number /= 10;
+        }
+        return sum;
+    }
+
+    //2
+    public void countLettersSpacesNumbers(String input) {
+        int letters = 0;
+        int spaces = 0;
+        int numbers = 0;
+        for (Character ch : input.toCharArray()) {
+            if (Character.isLetter(ch)) {
+                letters++;
+            } else if (Character.isDigit(ch)) {
+                numbers++;
+            } else if (Character.isWhitespace(ch)) {
+                spaces++;
+            }
+        }
+        System.out.println("Letters: " + letters);
+        System.out.println("Spaces: " + spaces);
+        System.out.println("Numbers: " + numbers);
+    }
+
+    //5
+    public static String[] findCommonElements(String[] array1, String[] array2) {
+        Set<String> set1 = new HashSet<>(Arrays.asList(array1));
+        Set<String> set2 = new HashSet<>(Arrays.asList(array2));
+
+        set1.retainAll(set2);
+
+        String[] commonElements = new String[set1.size()];
+        set1.toArray(commonElements);
+
+        return commonElements;
+    }
+
+    //8
+    public void swapElements(ArrayList<String> list, int index1, int index2) {
+        if (index1 < 0 || index1 >= list.size() || index2 < 0 || index2 >= list.size()) {
+            System.out.println("Invalid indices.");
+            return;
+        }
+
+        String aux = list.get(index1);
+        list.set(index1, list.get(index2));
+        list.set(index2, aux);
+    }
+
+    //9
+    public void findOccurrences(List<String> list, String element) {
+        int firstOccurrence = -1;
+        int lastOccurrence = -1;
+
+        for (int i = 0; i < list.size(); i++) {
+            if (list.get(i).equals(element)) {
+                if (firstOccurrence == -1) {
+                    firstOccurrence = i;
+                }
+                lastOccurrence = i;
+            }
+        }
+
+        if (firstOccurrence != -1) {
+            System.out.println("First occurrence for " + element + " is position " + firstOccurrence + " and last is position " + lastOccurrence);
+        } else {
+            System.out.println("Element " + element + " not found in the list.");
+        }
+    }
+
+    //10
+    public List<List<String>> groupAnagrams(String[] strs) {
+        if (strs == null || strs.length == 0) {
+            return new ArrayList<>();
+        }
+
+        Map<String, List<String>> map = new HashMap<>();
+
+        for (String str : strs) {
+            char[] chars = str.toCharArray();
+            Arrays.sort(chars);
+            String sorted = new String(chars);
+            if (!map.containsKey(sorted)) {
+                map.put(sorted, new ArrayList<>());
+            }
+            map.get(sorted).add(str);
+        }
+
+        return new ArrayList<>(map.values());
+    }
+
+    public static void main(String[] args) {
+
+        Practice practice = new Practice();
+
+        System.out.println(practice.sumOfDigits(8733));
+        System.out.println();
+
+        practice.countLettersSpacesNumbers("The quick brown fox jumps over 42 lazy dogs");
+        System.out.println();
+
+        String[] array1 = {"Python", "Java", "GoLang", "Lisp"};
+        String[] array2 = {"Java", "C++", "Apples", "Hamburger", "Lisp"};
+        System.out.println(Arrays.toString(findCommonElements(array1, array2)));
+        System.out.println();
+
+        ArrayList<String> list = new ArrayList<>(Arrays.asList("Red", "Green", "Black", "White", "Pink", "Black"));
+        practice.swapElements(list, 1, 4);
+        System.out.println();
+
+        practice.findOccurrences(list, "Black");
+        System.out.println();
+
+        String[] strs = {"eat", "tea", "tan", "ate", "nat", "bat", "listen", "silent", "enlist", "hello", "world", "dlrow"};
+        System.out.println(practice.groupAnagrams(strs));
+        System.out.println();
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/animal/Animal.java

@@ -0,0 +1,11 @@
+package com.rinftech.practice.animal;
+
+public class Animal {
+    public void eat() {
+        System.out.println("The animal eats food.");
+    }
+
+    public void sound() {
+        System.out.println("The animal makes a sound.");
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/animal/Lion.java

@@ -0,0 +1,13 @@
+package com.rinftech.practice.animal;
+
+public class Lion extends Animal {
+    @Override
+    public void eat() {
+        System.out.println("The lion eats meat.");
+    }
+
+    @Override
+    public void sound() {
+        System.out.println("The lion roars.");
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/animal/Panther.java

@@ -0,0 +1,13 @@
+package com.rinftech.practice.animal;
+
+public class Panther extends Animal {
+    @Override
+    public void eat() {
+        System.out.println("The panther eats meat and birds.");
+    }
+
+    @Override
+    public void sound() {
+        System.out.println("The panther meows.");
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/animal/Tiger.java

@@ -0,0 +1,14 @@
+package com.rinftech.practice.animal;
+
+public class Tiger extends Animal {
+    @Override
+    public void eat() {
+        System.out.println("The tiger eats meat and humans");
+    }
+
+    @Override
+    public void sound() {
+        System.out.println("The tiger growls.");
+
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/person/Employee.java

@@ -0,0 +1,18 @@
+package com.rinftech.practice.person;
+
+public class Employee extends Person {
+
+    private int employeeId;
+    private String jobTitle;
+
+    public int getEmployeeId() {
+        return employeeId;
+    }
+
+    @Override
+    public String getLastName() {
+        return super.getLastName() + jobTitle;
+    }
+
+}
+

JavaCourse/src/main/java/com/rinftech/practice/person/Person.java

@@ -0,0 +1,15 @@
+package com.rinftech.practice.person;
+
+public class Person {
+
+    private String firstName;
+    private String lastName;
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/shapes/Circle.java

@@ -0,0 +1,15 @@
+package com.rinftech.practice.shapes;
+
+public class Circle extends Shape {
+
+    private final float radius;
+
+    public Circle(float radius) {
+        this.radius = radius;
+    }
+
+    @Override
+    public float calculateArea() {
+        return (float) (Math.PI * Math.pow(radius, 2));
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/shapes/Rectangle.java

@@ -0,0 +1,17 @@
+package com.rinftech.practice.shapes;
+
+public class Rectangle extends Shape {
+
+    private final float width;
+    private final float height;
+
+    public Rectangle(float width, float height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    @Override
+    public float calculateArea() {
+        return width * height;
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/shapes/Shape.java

@@ -0,0 +1,8 @@
+package com.rinftech.practice.shapes;
+
+public class Shape {
+
+    public float calculateArea() {
+        return 0.0f;
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/shapes/Triangle.java

@@ -0,0 +1,17 @@
+package com.rinftech.practice.shapes;
+
+public class Triangle extends Shape {
+
+    private final float base;
+    private final float height;
+
+    public Triangle(float base, float height) {
+        this.base = base;
+        this.height = height;
+    }
+
+    @Override
+    public float calculateArea() {
+        return (base * height) / 2;
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/vehicle/Car.java

@@ -0,0 +1,33 @@
+package com.rinftech.practice.vehicle;
+
+public class Car extends Vehicle {
+
+    public Car(String make, String model, int year, String fuelType) {
+        super(make, model, year, fuelType);
+    }
+
+    public String calculateFuelEfficiency() {
+
+        if (this.getFuelType().equals("diesel")) {
+            return "Fuel efficient for a car";
+        } else {
+            return "Not fuel efficient for a car";
+        }
+    }
+
+    public String distanceTravelled() {
+        if (this.getYear() > 2000) {
+            return "not so much";
+        } else {
+            return "a lot";
+        }
+    }
+
+    public String maxSpeed() {
+        if (this.getYear() > 1990 && this.getFuelType().equals("gas")) {
+            return "fast";
+        } else {
+            return "slow";
+        }
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/vehicle/Motorcycle.java

@@ -0,0 +1,40 @@
+package com.rinftech.practice.vehicle;
+
+public class Motorcycle extends Vehicle {
+
+    public Motorcycle(String make, String model, int year, String fuelType) {
+        if (fuelType.equals("diesel")) {
+            throw new IllegalArgumentException("Motorcycles cannot run on diesel");
+        } else {
+            this.setMake(make);
+            this.setModel(model);
+            this.setYear(year);
+            this.setFuelType(fuelType);
+        }
+    }
+
+    public String calculateFuelEfficiency() {
+
+        if (this.getYear() > 2010) {
+            return "Fuel efficient for a motorcycle";
+        } else {
+            return "Not fuel efficient for a motorcycle";
+        }
+    }
+
+    public String distanceTravelled() {
+        if (this.getYear() > 2010) {
+            return "not so much";
+        } else {
+            return "a lot";
+        }
+    }
+
+    public String maxSpeed() {
+        if (this.getYear() > 2020) {
+            return "fast";
+        } else {
+            return "slow";
+        }
+    }
+}

JavaCourse/src/main/java/com/rinftech/practice/vehicle/Truck.java

@@ -0,0 +1,33 @@
+package com.rinftech.practice.vehicle;
+
+public class Truck extends Vehicle {
+
+    public Truck(String make, String model, int year, String fuelType) {
+        super(make, model, year, fuelType);
+    }
+
+    public String calculateFuelEfficiency() {
+
+        if (this.getFuelType().equals("diesel")) {
+            return "Fuel efficient for a truck";
+        } else {
+            return "Not fuel efficient for a truck";
+        }
+    }
+
+    public String distanceTravelled() {
+        if (this.getYear() > 2000) {
+            return "not so much";
+        } else {
+            return "a lot";
+        }
+    }
+
+    public String maxSpeed() {
+        if (this.getYear() > 2000 && this.getFuelType().equals("gas")) {
+            return "fast";
+        } else {
+            return "slow";
+        }
+    }
+}