An Attempt at December Of Algorithms

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;
+    }
+}

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()));
+            }
+        }
+    }
+}

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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);
+    }
+
+
+}
+

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();
+    }
+}

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;
+    }
+}

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;
+    }
+}