Solutions to Java Advanced section

sknsht · sknsht · commit 00c7846cbf9c · 2018-05-22T22:46:53.000+02:00
diff --git a/Java/Advanced/Can You Access/Solution.java b/Java/Advanced/Can You Access/Solution.java
@@ -0,0 +1,53 @@
+import java.io.*;
+import java.security.*;
+
+public class Solution {
+
+    public static void main(String[] args) throws Exception {
+        DoNotTerminate.forbidExit();
+
+        try {
+            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+            int num = Integer.parseInt(br.readLine().trim());
+            Object o;// Must be used to hold the reference of the instance of the class Solution.Inner.Private
+            o = new Inner().new Private();
+            
+            System.out.println(num + " is " + ((Solution.Inner.Private) o).powerof2(num));
+            System.out.println("An instance of class: " + o.getClass().getCanonicalName() + " has been created");
+
+        }//end of try
+
+        catch (DoNotTerminate.ExitTrappedException e) {
+            System.out.println("Unsuccessful Termination!!");
+        }
+    }//end of main
+
+    static class Inner {
+        private class Private {
+            private String powerof2(int num) {
+                return ((num & num - 1) == 0) ? "power of 2" : "not a power of 2";
+            }
+        }
+    }//end of Inner
+
+}//end of Solution
+
+class DoNotTerminate { //This class prevents exit(0)
+
+    public static class ExitTrappedException extends SecurityException {
+
+        private static final long serialVersionUID = 1L;
+    }
+
+    public static void forbidExit() {
+        final SecurityManager securityManager = new SecurityManager() {
+            @Override
+            public void checkPermission(Permission permission) {
+                if (permission.getName().contains("exitVM")) {
+                    throw new ExitTrappedException();
+                }
+            }
+        };
+        System.setSecurityManager(securityManager);
+    }
+}
diff --git a/Java/Advanced/Covariant Return Types/Solution.java b/Java/Advanced/Covariant Return Types/Solution.java
@@ -0,0 +1,62 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+class Flower {
+    String whatsYourName() {
+        return "I have many names and types.";
+    }
+}
+
+class Jasmine extends Flower {
+    @Override
+    String whatsYourName() {
+        return "Jasmine";
+    }
+}
+
+class Lily extends Flower {
+    @Override
+    String whatsYourName() {
+        return "Lily";
+    }
+}
+
+class Region {
+    Flower yourNationalFlower() {
+        return new Flower();
+    }
+}
+
+class WestBengal extends Region {
+    @Override
+    Jasmine yourNationalFlower() {
+        return new Jasmine();
+    }
+}
+
+class AndhraPradesh extends Region {
+    @Override
+    Lily yourNationalFlower() {
+        return new Lily();
+    }
+}
+
+public class Solution {
+    
+    public static void main(String[] args) throws IOException {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        String s = reader.readLine().trim();
+        Region region = null;
+        switch (s) {
+            case "WestBengal":
+                region = new WestBengal();
+                break;
+            case "AndhraPradesh":
+                region = new AndhraPradesh();
+                break;
+        }
+        Flower flower = region.yourNationalFlower();
+        System.out.println(flower.whatsYourName());
+    }
+}
diff --git a/Java/Advanced/Java Annotations/Solution.java b/Java/Advanced/Java Annotations/Solution.java
@@ -0,0 +1,59 @@
+import java.lang.annotation.*;
+import java.lang.reflect.*;
+import java.util.*;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@interface FamilyBudget {
+    String userRole() default "GUEST";
+
+    int budgetLimit() default 0;
+}
+
+class FamilyMember {
+    @FamilyBudget(userRole = "SENIOR", budgetLimit = 100)
+    public void seniorMember(int budget, int moneySpend) {
+        System.out.println("Senior Member");
+        System.out.println("Spend: " + moneySpend);
+        System.out.println("Budget Left: " + (budget - moneySpend));
+    }
+
+    @FamilyBudget(userRole = "JUNIOR", budgetLimit = 50)
+    public void juniorUser(int budget, int moneySpend) {
+        System.out.println("Junior Member");
+        System.out.println("Spend: " + moneySpend);
+        System.out.println("Budget Left: " + (budget - moneySpend));
+    }
+}
+
+public class Solution {
+    
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        int testCases = Integer.parseInt(in.nextLine());
+        while (testCases-- > 0) {
+            String role = in.next();
+            int spend = in.nextInt();
+            try {
+                Class annotatedClass = FamilyMember.class;
+                Method[] methods = annotatedClass.getMethods();
+                for (Method method : methods) {
+                    if (method.isAnnotationPresent(FamilyBudget.class)) {
+                        FamilyBudget family = method.getAnnotation(FamilyBudget.class);
+                        String userRole = family.userRole();
+                        int budgetLimit = family.budgetLimit();
+                        if (userRole.equals(role)) {
+                            if (spend <= budgetLimit) {
+                                method.invoke(FamilyMember.class.newInstance(), budgetLimit, spend);
+                            } else {
+                                System.out.println("Budget Limit Over");
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
diff --git a/Java/Advanced/Java Factory Pattern/Solution.java b/Java/Advanced/Java Factory Pattern/Solution.java
@@ -0,0 +1,70 @@
+import java.util.*;
+import java.security.*;
+
+interface Food {
+    public String getType();
+}
+
+class Pizza implements Food {
+    public String getType() {
+        return "Someone ordered a Fast Food!";
+    }
+}
+
+class Cake implements Food {
+    public String getType() {
+        return "Someone ordered a Dessert!";
+    }
+}
+
+class FoodFactory {
+    public Food getFood(String order) {
+        switch (order.toLowerCase()) {
+            case "pizza":
+                return new Pizza();
+            case "cake":
+                return new Cake();
+            default:
+                return null;
+        }
+    }//End of getFood method
+}//End of factory class
+
+public class Solution {
+
+    public static void main(String args[]) {
+        Do_Not_Terminate.forbidExit();
+
+        try {
+            Scanner sc = new Scanner(System.in);
+            //creating the factory
+            FoodFactory foodFactory = new FoodFactory();
+
+            //factory instantiates an object
+            Food food = foodFactory.getFood(sc.nextLine());
+
+            System.out.println("The factory returned " + food.getClass());
+            System.out.println(food.getType());
+        } catch (Do_Not_Terminate.ExitTrappedException e) {
+            System.out.println("Unsuccessful Termination!!");
+        }
+    }
+}
+
+class Do_Not_Terminate {
+    public static class ExitTrappedException extends SecurityException {
+        private static final long serialVersionUID = 1L;
+    }
+
+    public static void forbidExit() {
+        final SecurityManager securityManager = new SecurityManager() {
+            @Override
+            public void checkPermission(Permission permission) {
+                if (permission.getName().contains("exitVM")) {
+                    throw new ExitTrappedException();
+                }
+            }
+        };
+        System.setSecurityManager(securityManager);
+    }
+}	
diff --git a/Java/Advanced/Java Lambda Expressions/Solution.java b/Java/Advanced/Java Lambda Expressions/Solution.java
@@ -0,0 +1,76 @@
+import java.io.*;
+import java.util.*;
+
+interface PerformOperation {
+    boolean check(int a);
+}
+
+class MyMath {
+    public static boolean checker(PerformOperation p, int num) {
+        return p.check(num);
+    }
+
+    public static PerformOperation isOdd() {
+        return n -> (n & 1) == 1;
+    }
+
+    public static PerformOperation isPrime() {
+        return n -> {
+            if (n < 2) {
+                return false;
+            } else if (n == 2) {
+                return true;
+            } else if (n % 2 == 0) {
+                return false;
+            }
+            int sqrt = (int) Math.sqrt(n);
+            for (int i = 3; i <= sqrt; i += 2) {
+                if (n % i == 0) {
+                    return false;
+                }
+            }
+            return true;
+        };
+    }
+
+    public static PerformOperation isPalindrome() {
+        return n -> {
+            String original = Integer.toString(n);
+            String reversed = new StringBuilder(Integer.toString(n)).reverse().toString();
+            return original.equals(reversed);
+        };
+    }
+}
+
+public class Solution {
+
+    public static void main(String[] args) throws IOException {
+        MyMath ob = new MyMath();
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int T = Integer.parseInt(br.readLine());
+        PerformOperation op;
+        boolean ret = false;
+        String ans = null;
+        while (T-- > 0) {
+            String s = br.readLine().trim();
+            StringTokenizer st = new StringTokenizer(s);
+            int ch = Integer.parseInt(st.nextToken());
+            int num = Integer.parseInt(st.nextToken());
+            if (ch == 1) {
+                op = ob.isOdd();
+                ret = ob.checker(op, num);
+                ans = (ret) ? "ODD" : "EVEN";
+            } else if (ch == 2) {
+                op = ob.isPrime();
+                ret = ob.checker(op, num);
+                ans = (ret) ? "PRIME" : "COMPOSITE";
+            } else if (ch == 3) {
+                op = ob.isPalindrome();
+                ret = ob.checker(op, num);
+                ans = (ret) ? "PALINDROME" : "NOT PALINDROME";
+
+            }
+            System.out.println(ans);
+        }
+    }
+}
diff --git a/Java/Advanced/Java Varargs - Simple Addition/Solution.java b/Java/Advanced/Java Varargs - Simple Addition/Solution.java
@@ -0,0 +1,54 @@
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+
+class Add {
+    void add(int... vars) {
+        StringBuffer sb = new StringBuffer();
+        int sum = 0;
+
+        for (int var : vars) {
+            sb.append(var + "+");
+            sum += var;
+        }
+
+        sb.setCharAt(sb.length() - 1, '=');
+        sb.append(sum);
+        System.out.println(sb);
+    }
+}
+
+public class Solution {
+
+    public static void main(String[] args) {
+        try {
+            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+            int n1 = Integer.parseInt(br.readLine());
+            int n2 = Integer.parseInt(br.readLine());
+            int n3 = Integer.parseInt(br.readLine());
+            int n4 = Integer.parseInt(br.readLine());
+            int n5 = Integer.parseInt(br.readLine());
+            int n6 = Integer.parseInt(br.readLine());
+            Add ob = new Add();
+            ob.add(n1, n2);
+            ob.add(n1, n2, n3);
+            ob.add(n1, n2, n3, n4, n5);
+            ob.add(n1, n2, n3, n4, n5, n6);
+            Method[] methods = Add.class.getDeclaredMethods();
+            Set<String> set = new HashSet<>();
+            boolean overload = false;
+            for (int i = 0; i < methods.length; i++) {
+                if (set.contains(methods[i].getName())) {
+                    overload = true;
+                    break;
+                }
+                set.add(methods[i].getName());
+            }
+            if (overload) {
+                throw new Exception("Overloading not allowed");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/Java/Advanced/Java Visitor Pattern/Solution.java b/Java/Advanced/Java Visitor Pattern/Solution.java
diff --git a/Java/Advanced/Prime Checker/Solution.java b/Java/Advanced/Prime Checker/Solution.java
