From 1133a623a2890a5ea47802d4aeb2d287002eda0f Mon Sep 17 00:00:00 2001
From: pankhuri0209 <pankhurig1@gmail.com>
Date: Sat, 2 Nov 2024 22:16:25 -0400
Subject: [PATCH] problems

---
 .idea/.gitignore    |  8 ++++++
 .idea/Hashing-1.iml | 11 ++++++++
 .idea/misc.xml      |  6 ++++
 .idea/modules.xml   |  8 ++++++
 .idea/vcs.xml       |  6 ++++
 problem1.java       | 47 ++++++++++++++++++++++++++++++
 problem2.java       | 61 +++++++++++++++++++++++++++++++++++++++
 problem3.java       | 69 +++++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 216 insertions(+)
 create mode 100644 .idea/.gitignore
 create mode 100644 .idea/Hashing-1.iml
 create mode 100644 .idea/misc.xml
 create mode 100644 .idea/modules.xml
 create mode 100644 .idea/vcs.xml
 create mode 100644 problem1.java
 create mode 100644 problem2.java
 create mode 100644 problem3.java

diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 00000000..13566b81
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/.idea/Hashing-1.iml b/.idea/Hashing-1.iml
new file mode 100644
index 00000000..b107a2dd
--- /dev/null
+++ b/.idea/Hashing-1.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 00000000..07115cdf
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 00000000..c12cdf14
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Hashing-1.iml" filepath="$PROJECT_DIR$/.idea/Hashing-1.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 00000000..35eb1ddf
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/problem1.java b/problem1.java
new file mode 100644
index 00000000..0d217627
--- /dev/null
+++ b/problem1.java
@@ -0,0 +1,47 @@
+//Problem 1:
+//Given an array of strings, group anagrams together.
+//
+//        Example: Input: ["eat", "tea", "tan", "ate", "nat", "bat"], Output: [ ["ate","eat","tea"], ["nat","tan"], ["bat"] ]
+//
+//Note: All inputs will be in lowercase. The order of your output does not matter.
+
+//Time complexity: O(n*k)
+//Space complexity: O(n*k)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class problem1 {
+
+    public List<List<String>> groupAnagrams(String[] strs)
+    {
+        HashMap<Double, List<String>> map= new HashMap<>();
+
+        for (String word: strs)
+        {
+            double hash= getHash(word);
+            if (!map.containsKey(hash))
+            {
+                map.put(hash, new ArrayList<>());
+            }
+            map.get(hash).add(word);
+        }
+        return new ArrayList<>(map.values());
+    }
+    private double getHash(String word)
+    {
+        double hash=1;
+        int[] prime= {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,61,67,71,73,79,83,89,97,100};
+        for (char c: word.toCharArray())
+        {
+            hash = hash * prime[c - 'a'];
+        }
+        return hash;
+    }
+
+    public static void main(String[] args)
+    {
+
+    }
+}
diff --git a/problem2.java b/problem2.java
new file mode 100644
index 00000000..7212108d
--- /dev/null
+++ b/problem2.java
@@ -0,0 +1,61 @@
+//Given two strings s and t, determine if they are isomorphic. Two strings are isomorphic if the characters in s can be replaced to get t. All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.
+//
+//Example 1: Input: s = "egg", t = "add" Output: true
+//
+//Example 2: Input: s = "foo", t = "bar" Output: false
+//
+//Example 3: Input: s = "paper", t = "title" Output: true Note: You may assume both s and t have the same length.
+
+//Time complexity: O(n)
+//Space complexity: O(n)
+
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class problem2 {
+    private static boolean isIsomorphic(String a, String b)
+    {
+        if (a==null && b==null)
+        {
+            return true;
+        }
+        if(a==null || b==null)
+        {
+            return false;
+        }
+        if (a.length() != b.length())
+        {
+            return false;
+        }
+        HashMap<Character,Character> sMap= new HashMap<>();
+        HashSet<Character> sSet= new HashSet<>();
+        for (int i=0;i<a.length();i++)
+        {
+            char aChar= a.charAt(i);
+            char bChar= b.charAt(i);
+
+            if (sMap.containsKey(aChar))
+            {
+                if (sMap.get(aChar) != bChar)
+                {
+                    return false;
+                }
+            }
+            else {
+                if (sSet.contains(bChar)) // Search space is O(1)
+                {
+                    return false;
+                }
+                sSet.add(bChar);
+                sMap.put(aChar, bChar);
+
+            }
+        }
+        return true;
+    }
+    public static void main(String[] args)
+    {
+        isIsomorphic("egg","add");
+    }
+}
diff --git a/problem3.java b/problem3.java
new file mode 100644
index 00000000..5fca22bd
--- /dev/null
+++ b/problem3.java
@@ -0,0 +1,69 @@
+//Problem 3:
+//Given a pattern and a string str, find if str follows the same pattern. Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in str.
+//
+//Example 1: Input: pattern = "abba", str = "dog cat cat dog" Output: true
+//
+//Example 2: Input:pattern = "abba", str = "dog cat cat fish" Output: false
+//
+//Example 3: Input: pattern = "aaaa", str = "dog cat cat dog" Output: false
+//
+//Example 4: Input: pattern = "abba", str = "dog dog dog dog" Output: false Notes: You may assume pattern contains only lowercase letters, and str contains lowercase letters that may be separated by a single space.
+
+
+//Time complexity: O(n)
+//Space complexity: O(n)
+
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class problem3 {
+
+    public static boolean isIsomorphic(String pattern, String s)
+    {
+        if (pattern==null && s==null)
+        {
+            return true;
+        }
+        if (pattern==null && s==null)
+        {
+            return false;
+        }
+        String[] words=s.split(" ");
+        int wordCount=words.length;
+        if (pattern.length()!=wordCount)
+        {
+            return false;
+        }
+        HashMap<Character, String> map=new HashMap<>();
+        String[] str=s.split(" ");
+        HashSet<String> set= new HashSet<>();
+        for (int i=0;i<pattern.length();i++)
+        {
+            char a= pattern.charAt(i);
+            String b=words[i];
+            if (map.containsKey(a))
+            {
+                if (!map.get(a).equals(b))
+                {
+                    return false;
+                }
+            }
+            else {
+                if (set.contains(b))
+                {
+                    return false;
+                }
+                set.add(b);
+                map.put(a,b);
+            }
+        }
+        return true;
+    }
+    public static void main(String[] args)
+    {
+      boolean res=  isIsomorphic("egg","add");
+    }
+
+
+}