diff --git a/December-01/java_PriyaShrinithi_SherlocksQuest.java b/December-01/java_PriyaShrinithi_SherlocksQuest.java
new file mode 100644
index 0000000..845bbc0
--- /dev/null
+++ b/December-01/java_PriyaShrinithi_SherlocksQuest.java
@@ -0,0 +1,23 @@
+package com.company;
+import java.lang.*;
+public class Quest
+{
+    public boolean isRoomSafe(int door_number)
+    {
+        int door_squared = 0;
+        int left = 0;
+        int right = 0;
+
+        if(door_number%3!=0)
+            return false;
+        door_squared = (int) Math.pow(door_number, 2);
+        int count = Integer.toString(door_squared).length();
+
+        left = (int) (door_squared / Math.pow(10, count / 2));
+        right = (int) (door_squared - left*Math.pow(10, count/2));
+
+        if(left+right!=door_number)
+            return false;
+        return true;
+    }
+}
diff --git a/December-02/java_PriyaShrinithi_Convo.java b/December-02/java_PriyaShrinithi_Convo.java
new file mode 100644
index 0000000..c1e7c87
--- /dev/null
+++ b/December-02/java_PriyaShrinithi_Convo.java
@@ -0,0 +1,41 @@
+package com.company;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class Convo
+{
+    int j = 0;
+    HashMap map = new HashMap<String, String>()
+    {{
+        put("2", "abc");
+        put("3", "def");
+        put("4", "ghi");
+        put("5", "jkl");
+        put("6", "mno");
+        put("7", "pqrs");
+        put("8", "tuv");
+        put("9", "wxyz");
+    }};
+
+    List combinations = new ArrayList<String>();
+    List <String> makeCombination(String number)
+    {
+        if(number.length()<=2)
+            backtrack("", number);
+        return combinations;
+    }
+
+    private void backtrack(String letter, String digit) {
+        if (digit.length()==0)
+            combinations.add(letter);
+        else {
+            String combinat = (String) map.get(digit.substring(0, 1));
+            for (int i = 0; i < combinat.length(); i++)
+            {
+                backtrack(letter+combinat.substring(i, i + 1), digit.substring(1, digit.length()));
+            }
+        }
+    }
+}
diff --git a/December-03/java_PriyaShrinithi_MeetAndGreet.java b/December-03/java_PriyaShrinithi_MeetAndGreet.java
new file mode 100644
index 0000000..6aa8e5c
--- /dev/null
+++ b/December-03/java_PriyaShrinithi_MeetAndGreet.java
@@ -0,0 +1,53 @@
+package com.company;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class MeetAndGreet
+{
+    List<List<String>> allotTime(List <List<String>> schedule)
+    {
+        List<List<String>> intervals  = new LinkedList<>();
+        List <String> interval;
+        int start_meet = 0;
+        int end_meet = 0;
+
+        int start = 900;
+        int end = 1700;
+
+        if(schedule==null)
+        {
+            interval = new LinkedList<>();
+            interval.add(Integer.toString(start));
+            interval.add(Integer.toString(end));
+            intervals.add(interval);
+        }
+        else
+        {
+            for(List<String> s: schedule)
+            {
+                 System.out.println(s);
+                 start_meet = Integer.parseInt(s.get(0));
+                 end_meet = Integer.parseInt(s.get(1));
+
+                if(start_meet - start >= 100)
+                {
+                    interval = new LinkedList<>();
+                    interval.add(Integer.toString(start));
+                    interval.add(Integer.toString(start_meet));
+                    intervals.add(interval);
+                }
+                start = end_meet;
+            }
+            if(end - end_meet >=100)
+            {
+                interval = new LinkedList<>();
+                interval.add(Integer.toString(end_meet));
+                interval.add(Integer.toString(end));
+                intervals.add(interval);
+
+            }
+        }
+        return intervals;
+    }
+}
diff --git a/December-04/java_PriyaShrinithi_SpoiledOrNot.java b/December-04/java_PriyaShrinithi_SpoiledOrNot.java
new file mode 100644
index 0000000..7354417
--- /dev/null
+++ b/December-04/java_PriyaShrinithi_SpoiledOrNot.java
@@ -0,0 +1,32 @@
+package com.company;
+
+public class Spoiled
+{
+    int spoiledOrNot(int icecreamNumbers, int[][] manufacturingDates, int [] bestBeforeDays, int [] Date)
+    {
+        if(manufacturingDates.length!=bestBeforeDays.length)
+            System.exit(-1);
+
+        int spoiledIcecreamNumbers = 0;
+
+        int [][] spoiled = new int[manufacturingDates.length][manufacturingDates[0].length];
+        int i = 0;
+        for(int[] date: manufacturingDates)
+        {
+            date[0] = date[0]+bestBeforeDays[i];
+            if(date[0]>30){
+                date[0] -=30;
+                date[1]++;
+            }
+            if(date[1]>12){
+                date[1]-=12;
+                date[2]++;
+            }
+            i++;
+            if(date[2]<=Date[2]&&date[1]<=Date[1]&&date[0]<Date[0])
+                spoiledIcecreamNumbers++;
+        }
+
+        return spoiledIcecreamNumbers;
+    }
+}
diff --git a/December-05/java_PriyaShrinithi_GrandMaster.java b/December-05/java_PriyaShrinithi_GrandMaster.java
new file mode 100644
index 0000000..2de0ab7
--- /dev/null
+++ b/December-05/java_PriyaShrinithi_GrandMaster.java
@@ -0,0 +1,37 @@
+package com.company;
+
+import java.util.LinkedList;
+import java.util.List;
+/*
+ * It was a dark and stormy night where an Oldman and his grandson were playing chess.
+ * The Oldman gave his grandson a problem, to check his knowledge and skills in chess.
+ * He stated that, It was a square chessboard of A x B size, the position of Knight (C, D) and position of a target (E, F) is given.
+ * Now the Grandson needs to find out the minimum steps a Knight will take to reach the target position.
+ * Sample Input/Output
+ * Dimension of Board : 6 6
+ * Position of Knight : 1 1
+ * Target Position :  4 5
+
+ * Minimum Steps : 3
+ * Explanation
+ * From the starting position of the Knight (1,1). The Knight can move to either (3,2) or (2,3). We choose (3,2).
+ * From (3,2) the Knight can move to (5,1), (1,3), (2,4), (4,4), (5,3), (1,1). We choose (5,3).
+ * From (5,3) the Knight moves to (4,5).
+ * The Minimum steps required is 3.
+*/
+public class KnightMinimumMoves
+{
+    int step = 0;
+    int minMoves(int edge, int sx, int sy, int tx, int ty)
+    {
+        if(sx<edge && sy<edge)
+        {
+            System.out.println(sx+" "+sy);
+            if (sx == tx && sy == ty)
+                step++;
+            step = 1 + Math.min(minMoves(edge, sx + 2, sy + 1, tx, ty), minMoves(edge, sx + 1, sy + 2, tx, ty));
+        }
+
+        return step;
+    }
+}
diff --git a/December-07/java_PriyaShrinithi_TemperatureScreening.java b/December-07/java_PriyaShrinithi_TemperatureScreening.java
new file mode 100644
index 0000000..653520f
--- /dev/null
+++ b/December-07/java_PriyaShrinithi_TemperatureScreening.java
@@ -0,0 +1,35 @@
+package com.company;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class TemperatureScreen
+{
+    private Queue <String> checkUpOrder = new LinkedList<>();
+
+    Queue<String> screen(Queue<String> A, Queue<String> B)
+    {
+
+        //A takes 2 minutes for 1 move
+        //B takes 1 minute for 1 move
+        if(A.isEmpty()&&B.isEmpty())
+            return checkUpOrder;
+        if(A.isEmpty())
+        {
+            checkUpOrder.add(B.poll());
+            checkUpOrder.add(B.poll());
+        }
+        if(B.isEmpty())
+            checkUpOrder.add(A.poll());
+        else
+        {
+            checkUpOrder.add(B.poll());
+            checkUpOrder.add(B.poll());
+            checkUpOrder.add(A.poll());
+        }
+        return screen(A, B);
+    }
+
+
+}
+
diff --git a/December-10/java_PriyaShrinithi_RestoreIPAddress.java b/December-10/java_PriyaShrinithi_RestoreIPAddress.java
new file mode 100644
index 0000000..5678366
--- /dev/null
+++ b/December-10/java_PriyaShrinithi_RestoreIPAddress.java
@@ -0,0 +1,45 @@
+package com.company;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RestoreIPAddress
+{
+    int r = 0;
+    List <String> uncorrupted_log = new ArrayList<>();
+    int corrupted_length = 0;
+    List<String> restore(String corrupted_log)
+    {
+        if(corrupted_log.length()<4||corrupted_log.length()>12)
+            return uncorrupted_log;
+        corrupted_length = corrupted_log.length();
+        backtrack("", corrupted_log, 0);
+        return uncorrupted_log;
+    }
+
+    void backtrack(String partOfLog, String restOf_corrupted_log, int end)
+    {
+        r++;
+        if(end==4||restOf_corrupted_log.length()==0) {
+            String log = partOfLog.substring(0, partOfLog.length() - 1);
+            if(validity(log))
+                uncorrupted_log.add(log);
+            System.out.println(r);
+            return;
+        }
+        else
+        {
+            for(int i = 1;i<=(restOf_corrupted_log.charAt(0)=='0'?1:3) && i<=restOf_corrupted_log.length();i++)
+            {
+                String path = restOf_corrupted_log.substring(0, i);
+                if(Integer.parseInt(path)> -1 && Integer.parseInt(path)<256)
+                    backtrack(partOfLog+path+".", restOf_corrupted_log.substring(i), end + 1);
+            }
+        }
+    }
+
+    boolean validity(String log)
+    {
+        return log.split("[.]").length == 4 && corrupted_length+3==log.length();
+    }
+}
\ No newline at end of file
diff --git a/December-11/java_PriyaShrinithi_JSQL.java b/December-11/java_PriyaShrinithi_JSQL.java
new file mode 100644
index 0000000..43cb02d
--- /dev/null
+++ b/December-11/java_PriyaShrinithi_JSQL.java
@@ -0,0 +1,37 @@
+package com.company;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class JSQL
+{
+    String convertToSQL(JSONObject json) throws JSONException {
+
+
+        String sql = "create table "+json.get("table name")+" (";
+        JSONObject header = (JSONObject) json.get("headers");
+        for(Iterator i = header.keys();i.hasNext();)
+        {
+            JSONObject key = (JSONObject) header.get((String) i.next());
+            String dt = (String) key.get("data type");;
+            String cn = (String) key.get("column name");
+            sql+=dt+" "+cn+", ";
+        }
+        sql = sql.substring(0, sql.length()-2)+")";
+        JSONObject record = (JSONObject) json.get("records");
+        int  i = 0;
+        for(Iterator keys = record.keys();keys.hasNext();)
+        {
+
+            String value = String.valueOf(record.get((String) keys.next()));
+            sql+="\ninsert into " + json.get("table name")+" values "+"("+value.substring(1, value.length()-1)+")";
+            i++;
+        }
+        return sql;
+    }
+}
diff --git a/December-12/java_PriyaShrinithi_RecruitmentDrive.java b/December-12/java_PriyaShrinithi_RecruitmentDrive.java
new file mode 100644
index 0000000..82b00ab
--- /dev/null
+++ b/December-12/java_PriyaShrinithi_RecruitmentDrive.java
@@ -0,0 +1,62 @@
+package com.company;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class RecruitmentDrive
+{
+    private List<String[]> columns = new ArrayList<>();
+    private double b0 = 0;
+    private double b1 = 0;
+    private double b2 = 0;
+    private double threshold = 0.5;
+    String readCSV(String csv_link, double gpa, double xp) throws IOException {
+            BufferedReader reader = new BufferedReader(new FileReader(csv_link));
+            String line ="";
+            while((line = reader.readLine())!=null) {
+                columns.add(line.split(","));
+            }
+            reader.close();
+        predict(columns);
+        if(predict(gpa, xp))
+            return "Selected";
+        return "Unselected";
+    }
+
+    void predict (List <String[]> columns)
+    {
+        for(String [] row: columns)
+        {
+            try{
+                double x1 = Double.parseDouble(row[0]);
+                double x2 = Double.parseDouble(row[1]);
+                double y = Integer.parseInt(row[2]);
+                double prediction = prediction(b0, b0, b1, x1, x2);
+                b0 = stochasticGradient(b0, 1,prediction, y);
+                b1 += stochasticGradient(b1, x1, prediction, y);
+                b2 += stochasticGradient(b2, x2, prediction, y);
+            }catch(Exception e){}
+
+        }
+    }
+
+    double stochasticGradient(double b, double x, double prediction, double y)
+    {
+        return b+0.3*(y - prediction)*prediction*(1-prediction)*x;
+    }
+
+    double prediction(double b0, double b1, double b2, double x1, double x2)
+    {
+        return 1/(1 + (Math.exp( - (b0+(b1*x1)+(b2*x2)))));
+    }
+
+    boolean predict(double gpa, double xp)
+    {
+        if(prediction(b0, b1, b2, gpa, xp)>threshold)
+            return true;
+        return false;
+    }
+}
diff --git a/December-13/java_PriyaShrinithi_CheckYourSpellingSara.java b/December-13/java_PriyaShrinithi_CheckYourSpellingSara.java
new file mode 100644
index 0000000..fac2f35
--- /dev/null
+++ b/December-13/java_PriyaShrinithi_CheckYourSpellingSara.java
@@ -0,0 +1,96 @@
+package com.company;
+
+import java.util.*;
+
+class Trie
+{
+
+    String prefix;
+    class TrieNode
+    {
+        public String word;
+        TrieNode children [] = new TrieNode[26];
+        boolean isEndOfWord;
+    }
+    private TrieNode root;
+    Trie()
+    {
+        root = new TrieNode();
+    }
+    void insert(String word) {
+        TrieNode crawl = root;
+        int key = 0;
+        for (int i = 0; i < word.length(); i++) {
+            key = word.charAt(i) - 'a';
+            if (crawl.children[key] == null)
+                crawl.children[key] = new TrieNode();
+            crawl = crawl.children[key];
+        }
+        crawl.isEndOfWord = true;
+        crawl.word = word;
+    }
+
+    boolean search(String word)
+    {
+        TrieNode crawl = root;
+        String pre = "";
+        for(int i = 0;i<word.length();i++)
+        {
+            int key = word.charAt(i)-'a';
+            pre = pre.concat(String.valueOf(word.charAt(i)));
+            if(crawl.children[key]==null)
+            {
+                prefix = pre.substring(0, pre.length()-1);
+                return true;
+            }
+            crawl = crawl.children[key];;
+        }
+        return crawl.isEndOfWord;
+    }
+    String findCorrect(String prefix)
+    {
+        TrieNode crawl = root;
+        String correct = prefix;
+        for(int i = 0;i<prefix.length();i++)
+        {
+            int key = prefix.charAt(i)-'a';
+            if(crawl.children[key]!=null)
+                crawl = crawl.children[key];
+        }
+        if(crawl.children!=null) {
+            Deque<TrieNode> nodeQ = new ArrayDeque<>();
+            nodeQ.addLast(crawl);
+            while (!nodeQ.isEmpty())
+            {
+                TrieNode _crawl = nodeQ.pollFirst();
+                for(TrieNode _crawler: _crawl.children)
+                {
+                    if(_crawler!=null)
+                        nodeQ.addLast(_crawler);
+                }
+                if(_crawl.isEndOfWord){
+                    correct = _crawl.word;
+                    break;
+                }
+            }
+        }
+        return correct.substring(0,1).toUpperCase()+correct.substring(1);
+    }
+}
+
+public class MistakeCorrection
+{
+    String mistake(List<String> dictionary, String mistake)
+    {
+        String correct = "";
+        Trie root = new Trie();
+        for(String word: dictionary)
+        {
+            root.insert(word.toLowerCase());
+            //System.out.println(root.search(word.toLowerCase()));
+        }
+        if(root.search(mistake.toLowerCase()));
+            correct = root.findCorrect(root.prefix);
+        return correct;
+    }
+}
diff --git a/December-15/java_PriyaShrinithi_HelpMaxShop.java b/December-15/java_PriyaShrinithi_HelpMaxShop.java
new file mode 100644
index 0000000..a066904
--- /dev/null
+++ b/December-15/java_PriyaShrinithi_HelpMaxShop.java
@@ -0,0 +1,32 @@
+package com.company;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+public class HelpMaxShop
+{
+    int arrange(String garments)
+    {
+        int [] countMap = new int[garments.length()+1];
+        int count = 0;
+        int i = 0;
+        while(i<garments.length()-1)
+        {
+            if((garments.charAt(i)=='s'&&garments.charAt(i+1)=='t') || garments.charAt(i)=='t'&&garments.charAt(i+1)=='s') {
+                count+=1;
+                i+=2;
+            }
+            else {
+                count = 0;
+                i++;
+            }
+            countMap[i] = count;
+        }
+
+        Arrays.sort(countMap);
+        return countMap[countMap.length-1]*2;
+    }
+}
diff --git a/December-16/java_PriyaShrinithi_Max'sParty.java b/December-16/java_PriyaShrinithi_Max'sParty.java
new file mode 100644
index 0000000..2697a0a
--- /dev/null
+++ b/December-16/java_PriyaShrinithi_Max'sParty.java
@@ -0,0 +1,91 @@
+package com.company;
+
+import java.util.HashMap;
+
+public class ROTCipher{
+    HashMap<Character, Integer> alphaIndex = new HashMap<>();
+    HashMap<Integer, Character> indexAlpha = new HashMap<>();
+    int Z_index;
+    int A_index;
+    int z_index;
+    int a_index;
+    ROTCipher() {
+        char c = 'a';
+        for (int i = 0; i < 52; i++) {
+            alphaIndex.put(c, i);
+            indexAlpha.put(i, c);
+            c++;
+            if (c - 'z' ==1)
+                c = 'A';
+        }
+    }
+
+    String encrypt(String unencryptedMessage, String key) {
+        StringBuilder message = new StringBuilder().append(unencryptedMessage);
+        for (char k : key.toCharArray()) {
+            if(k=='L')
+                message = shift(message, -1);
+            else if(k=='H')
+                message = shift(message, +1);
+            else if(k=='R')
+                message = rotate(message);
+            else
+                continue;
+            System.out.println(k+" "+message);
+       }
+        return message.toString();
+}
+
+    StringBuilder rotate(StringBuilder message) {
+        message.toString();
+        return new StringBuilder().append(message.substring(message.length()-1)+message.substring(0, message.length()-1));
+    }
+
+    StringBuilder shift(StringBuilder message, int val)
+    {
+        char [] rotMessage = new char[message.length()];
+        int left = 0;
+        int right = message.length()-1;
+        int in_left = left;
+        int in_right= right;
+        while(left<right)
+        {
+            in_left = compare(alphaIndex.get(message.charAt(left)), val);
+            in_right = compare(alphaIndex.get(message.charAt(right)), val);
+            rotMessage [left] = indexAlpha.get(in_left);
+            rotMessage[right] = indexAlpha.get(in_right);
+            left++;
+            right--;
+        }
+        if(left == right)
+        {
+            in_left = compare(alphaIndex.get(message.charAt(left)), val);
+            rotMessage[left] = indexAlpha.get(in_left);
+        }
+        return new StringBuilder().append(rotMessage);
+    }
+
+    int compare(int index, int val)
+    {
+        if(val == 1) {
+            Z_index = 51;
+            A_index = 26;
+            z_index = 25;
+            a_index = 0;
+        }
+        else {
+            A_index = 51;
+            Z_index = 26;
+            a_index = 25;
+            z_index = 0;
+        }
+
+        if(index == Z_index)
+            index = A_index;
+        else if(index == z_index)
+            index = a_index;
+        else
+            index = index+val;
+        return index;
+    }
+}
diff --git a/December-17/java_PriyaShrinithi_Pokemon.java b/December-17/java_PriyaShrinithi_Pokemon.java
new file mode 100644
index 0000000..754ccb1
--- /dev/null
+++ b/December-17/java_PriyaShrinithi_Pokemon.java
@@ -0,0 +1,48 @@
+package com.company;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Pokemon
+{
+    List <Integer> match = new ArrayList<>();
+    int matches = 0;
+    int trainer(int pokemon, int [] A, int [] B)
+    {
+        compare(A, B);
+        matchBreak(match, 0, 1);
+        return matches;
+    }
+
+    void compare(int [] A, int[] B)
+    {
+        int j = 0;
+        for(int i=0;i<A.length;i++)
+        {
+            if(A[i]>B[i])
+                matches++;
+            else
+            {
+                match.add(j, B[i]);
+                match.add(j++, A[i]);
+                j++;
+            }
+        }
+    }
+
+    void matchBreak(List<Integer> match, int left, int right)
+    {
+        if(match==null||right>=match.size()||left>=match.size())
+            return;
+        if(match.get(left)>match.get(right)) {
+            matches++;
+            match.remove(right);
+            match.remove(left);
+            matchBreak(match, 0, 1);
+        }
+        else
+            matchBreak(match, left, right + 2);
+
+    }
+}
diff --git a/December-18/java_PriyaShrinithi_IsThisANewUser.java b/December-18/java_PriyaShrinithi_IsThisANewUser.java
new file mode 100644
index 0000000..290e106
--- /dev/null
+++ b/December-18/java_PriyaShrinithi_IsThisANewUser.java
@@ -0,0 +1,71 @@
+package com.company;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+public class IsThisANewUser
+{
+
+    public static void main(String[] args) throws IOException
+    {
+        ValidAndAvailable vaa = new ValidAndAvailable();
+        List<String> contents = vaa.urlExtract("https://jsonplaceholder.typicode.com/users");
+        System.out.println(vaa.availability(vaa.validity("Leopoldo_Corkery"), contents));
+
+    }
+}
+public class ValidAndAvailable
+{
+    private String validityStatus="The username is not valid";
+    String userName;
+    boolean validity(String userName)
+    {
+        this.userName = userName;
+        String pattern = "^[a-zA-Z0-9_.-]*{1,21}$";
+        Pattern charPatt = Pattern.compile(pattern);
+        boolean valid = true;
+        if(!charPatt.matcher(userName).matches())
+            valid = false;
+        else
+            validityStatus = "The UserName is valid";
+
+        return valid;
+    }
+
+    String availability(boolean valid, List<String> contents)
+    {
+        String availabilityStatus = "";
+        if(!valid)
+            return validityStatus;
+        else if(valid && contents.contains(userName))
+            availabilityStatus = " but not available";
+        else
+            availabilityStatus = " and available";
+        return validityStatus+availabilityStatus;
+    }
+
+    List<String> urlExtract(String apiLink) throws IOException {
+        URL url = new URL(apiLink);
+        List <String> content;
+        try(InputStream in = url.openStream())
+        {
+            content = new ArrayList<>(Arrays.asList(new String(in.readAllBytes(), StandardCharsets.UTF_8).split(",")));
+        }
+        List<String> contents = new ArrayList<>();
+        for(String c: content)
+        {
+            if(c.contains("username")) {
+                c = c.split(":")[1];
+                contents.add(c.substring(2, c.length() - 1));
+            }
+        }
+        System.out.println(contents);
+        return contents;
+    }
+}
diff --git a/December-20/java_PriyaShrinithi_ShowUpPeople.java b/December-20/java_PriyaShrinithi_ShowUpPeople.java
new file mode 100644
index 0000000..e01f899
--- /dev/null
+++ b/December-20/java_PriyaShrinithi_ShowUpPeople.java
@@ -0,0 +1,24 @@
+package com.company;
+
+import java.util.List;
+
+public class ShowUp
+{
+    char [] records = new char[]{'P', 'L', 'A'};
+    int count =0;
+    int r=0;
+    int attendanceRecord(int n)
+    {
+        return attendanceRecord(n, "", 0);
+    }
+    int attendanceRecord(int n, String attendance, int absence)
+    {
+
+        if(attendance.contains("LLL")||(attendance.contains("A") && absence>=2))
+            return 0;
+        if(n==0)
+            return 1;
+        return attendanceRecord(n-1, attendance+records[0], absence) + attendanceRecord(n-1, attendance+records[1], absence) + attendanceRecord(n-1, attendance+records[2], absence+1);
+
+    }
+}
diff --git a/December-22/java_PriyaShrinithi_ClosestServers.java b/December-22/java_PriyaShrinithi_ClosestServers.java
new file mode 100644
index 0000000..24f8985
--- /dev/null
+++ b/December-22/java_PriyaShrinithi_ClosestServers.java
@@ -0,0 +1,75 @@
+package com.company;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+public class ClosestServers
+{
+    int k ;
+    List <Integer> cities;
+    List <Integer> centerCities;
+    ClosestServers()
+    {
+        k = 2;
+        centerCities = new ArrayList<>();
+        cities = new ArrayList <>();
+    }
+    List <Integer> findCities(int [][] graph)
+    {
+        int radius = 1;
+        int [] dummy = new int [(graph.length*graph.length)+1];
+        int ij = 0;
+        for(int i = 0;i<graph.length;i++)
+        {
+            for(int j = 0;j<graph.length;j++)
+            {
+                dummy[ij] = graph[i][j];
+                ij++;
+
+            }
+        }
+        Arrays.sort(dummy);
+        radius = dummy[dummy.length/2];
+        return kCenter(radius, graph);
+    }
+    List <Integer> getCities(int n)
+    {
+        List<Integer> cityList = new ArrayList<>();
+        for(int i = 0;i<n;i++)
+        {
+            cityList.add(i);
+        }
+        return cityList;
+    }
+
+    void removeAllCitiesAt2rRadius(List<Integer> cities, int radius, int [][] graph, int city)
+    {
+        for(int i = 0;i<graph.length;i++){
+            if(i<cities.size() && graph[city][i]<=2*radius)
+                cities.remove(cities.get(i));
+        }
+        int i = 0;
+        while(!cities.isEmpty())
+        {
+            centerCities.add(cities.remove(i));
+            i++;
+        }
+    }
+    List <Integer> kCenter(int radius, int [][] graph)
+    {
+        List <Integer> cities = getCities(graph.length);
+        int i = 0;
+        while(!cities.isEmpty())
+        {
+            int city = cities.remove(i);
+            centerCities.add(city);
+            removeAllCitiesAt2rRadius(cities, radius, graph, city);
+            i++;
+        }
+        if(centerCities.size()<=k)
+            return centerCities;
+        return kCenter(radius+1, graph);
+    }
+}
diff --git a/December-23/java_PriyaShrinithi_TheRiseOfTheKnight.java b/December-23/java_PriyaShrinithi_TheRiseOfTheKnight.java
new file mode 100644
index 0000000..4de0184
--- /dev/null
+++ b/December-23/java_PriyaShrinithi_TheRiseOfTheKnight.java
@@ -0,0 +1,26 @@
+package com.company;
+
+public class KnightAndThePrincess
+{
+    int healthPoints(int [][] fort)
+    {
+        int hp = 0;
+        int rows  = fort.length;
+        int columns = fort[0].length;
+        int i = 0;
+        int j = 0;
+        while(i<rows && j<columns)
+        {
+            if(j<columns-1) {
+                hp += fort[i][j];
+                j++;
+            }
+            else {
+                hp+=fort[i][j];
+                i++;
+            }
+        }
+        hp = Math.abs(hp)+1;
+        return hp;
+    }
+}
diff --git a/December-24/java_PriyaShrinithi_MinifyDamage.java b/December-24/java_PriyaShrinithi_MinifyDamage.java
new file mode 100644
index 0000000..4bfd5f5
--- /dev/null
+++ b/December-24/java_PriyaShrinithi_MinifyDamage.java
@@ -0,0 +1,69 @@
+package com.company;
+
+public class Minify
+{
+    private int damage = 0;
+    int findMin(int [] enemies,int k)
+    {
+        breakEnemies(enemies, k, enemies.length/k);
+        return damage;
+    }
+    void analyseEnemies(int [][] enemies)
+    {
+        int i = 0;
+        int j = 1;
+        while(i<enemies.length)
+        {
+            if(!(canDamage(enemies, i, 0, i, 1) && canDamage(enemies, j, 0, j, 1)) && enemies[i][0]!=enemies[j][0])
+                    swap(i, 0, j, 1, enemies);
+            if(Math.abs(enemies[i][0]-enemies[i][1])!=Math.abs(enemies[j][0]-enemies[j][1]))
+            {
+                if(canDamage(enemies, i, 0, j, 1) && canDamage(enemies, i, 0, j, 0) && Math.abs(enemies[i][0]-enemies[j][0])<Math.abs(enemies[i][0]-enemies[i][1]))
+                    swap(i, 0, j, 1, enemies);
+                if(canDamage(enemies, i, 1, j, 0) && canDamage(enemies, i, 1, j, 1) && Math.abs(enemies[i][0]-enemies[j][1])<Math.abs(enemies[i][0]-enemies[i][1]))
+                        swap(i, 1, j, 0, enemies);
+            }
+            if(canDamage(enemies, i, 0, i, 1) && canDamage(enemies, j, 0, j, 1))
+                damage+=Math.abs(enemies[i][0]-enemies[i][1])+Math.abs(enemies[j][0]-enemies[j][1]);
+            else{
+                damage = -1;
+                break;
+            }
+            i+=2;
+            j+=2;
+            if(j>=enemies.length && enemies.length%2!=0)
+                j = i;
+        }
+    }
+
+    void swap(int i0, int i1, int j0, int j1, int [][] e)
+    {
+        int temp = e[i0][i1];
+        e[i0][i1] = e[j0][j1];
+        e[j0][j1] = temp;
+    }
+
+    void breakEnemies(int [] enemies, int k, int parts)
+    {
+        int [][]inter = new int [k][parts];
+        int i = 0;
+        int part_index = 0;
+        int k_index  = 0;
+        while(i<enemies.length)
+        {
+            inter[k_index][part_index] = enemies[i];
+            i++;
+            part_index++;
+            if(part_index==parts)
+            {
+                k_index++;
+                part_index = 0;
+            }
+        }
+       analyseEnemies(inter);
+    }
+    boolean canDamage(int [][] enemies, int i0, int i1, int j0, int j1)
+    {
+        return enemies[i0][i1] - enemies[j0][j1] != 0;
+    }
+}
diff --git a/December-25/java_PrIyaShrinithi_TrappingRainWater.java b/December-25/java_PrIyaShrinithi_TrappingRainWater.java
new file mode 100644
index 0000000..e16f09a
--- /dev/null
+++ b/December-25/java_PrIyaShrinithi_TrappingRainWater.java
@@ -0,0 +1,83 @@
+package com.company;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+
+public class Trap
+{
+    int corner = 0;
+    int max = 0;
+    int findTrap(int [] height)
+    {
+        HashMap<Integer, Integer> unique = new HashMap<>();
+        for(int h: height)
+        {
+            if(!unique.containsKey(h))
+                unique.put(h, 1);
+            else
+                unique.put(h, unique.get(h)+1);
+        }
+        int min = Collections.min(unique.keySet());
+        max = Collections.max(unique.keySet());
+        return findTrap(height, 0, height.length-1, min, 0, unique);
+    }
+    private int findTrap(int[] height, int start, int end, int h, int capacity, HashMap<Integer, Integer> unique)
+    {
+        corner = Math.min(height[start], height[end]);
+        if(start==end)
+            return capacity;
+        while(start<=end)
+        {
+            if(height[start]==h){
+                start++;
+                unique.put(h, unique.get(h)-1);
+            }
+            if(height[end]==h){
+                end--;
+                unique.put(h, unique.get(h)-1);
+            }
+            else
+                break;
+        }
+        capacity+=unique.get(h);
+        if(!unique.containsKey(h+1) && h+1<max){
+            unique.put(h+1, 0);
+        }
+        unique.put(h+1, unique.get(h+1)+unique.get(h));
+        changeHeight(height, h, unique, start, end);
+       if(h+1==corner)
+           return capacity;
+        return findTrap(height, start, end, h+1, capacity, unique);
+    }
+    void changeHeight(int [] height, int h, HashMap<Integer, Integer> unique, int start, int end)
+    {
+        int count = 0;
+        int left = start;
+        int right = end;
+        int mid = left+right/2;
+        if(height[mid] == h && h+1<max){
+            height[mid] = h+1;
+            count++;
+        }
+        while(left<right)
+        {
+            if(count==unique.get(h))
+            {
+                unique.put(h, 0);
+                break;
+            }
+            if(height[left]==h  && h+1<max){
+                height[left] = h+1;
+                count++;
+            }
+            if(height[right]==h  && h+1<max){
+                height[right] = h+1;
+                count++;
+            }
+            left++;
+            right--;
+        }
+        unique.put(h, 0);
+    }
+}