From d3e518432ed2f8a882db5eb15aeb8cdcee2f9c71 Mon Sep 17 00:00:00 2001
From: Piyush Chhoriya <piyushchhoriya98@gmail.com>
Date: Tue, 8 Apr 2025 20:40:36 -0400
Subject: [PATCH 1/3] Find celebrity

---
 Find-Celebrity.java | 81 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 Find-Celebrity.java

diff --git a/Find-Celebrity.java b/Find-Celebrity.java
new file mode 100644
index 0000000..7edfe33
--- /dev/null
+++ b/Find-Celebrity.java
@@ -0,0 +1,81 @@
+## Problem 2:Find Celebrity(https://leetcode.com/problems/find-the-celebrity/)
+
+In this question we have to find out the celebrity from n people and we are given a condition that 
+- all people except celebrity knows the celebrity 
+- celebrity does not know the people 
+and to find out who knows whom we are given a function knows(a,b) which returns a true is a knows b and flase id a does not know b
+
+so this question can be solved in 2 ways 
+1. bruteforce
+in this we will maintain and indegrees array so a celebrity will have n-1 indegrees so if knows(a,b) = true so we will do 
+indegre[a]-- and indegree[b]++ and at the end if indegree[i]==n-1 then it is the celebrity
+Time Complexity : O(n2)
+Space Complexity : O(n)
+public class Solution extends Relation {
+
+     public int findCelebrity(int n) {
+
+        if(n==0){
+            return -1;
+        }
+        int[] indegree = new int[n];
+        for(int i=0;i<n;i++){
+            for(int j=0;j<n;j++){
+                if(i!=j){
+                    if(knows(i,j)){
+                        indegree[i]--;
+                        indegree[j]++;
+                    }
+                }
+            }
+            
+        }
+        for(int i=0;i<n;i++){
+            if(indegree[i]==n-1){
+                return i;
+            }
+        }
+        return -1;
+
+     }
+
+
+}
+
+//Optimal Solution
+In this what we will do is we will try to eliminate the people who are not the celebrities and find the potential celebrity and then we will check if he is the only celeberity
+We will do this using 2 loops
+1. will eliminate all other and find a potential celebrity 
+2. We will make sure he is the celebrity
+
+Time Complexity : O(n)
+Space Complexity : O(1)
+
+public class Solution extends Relation {
+
+     public int findCelebrity(int n) {
+
+        if(n==0){
+            return -1;
+        }
+        int potential = 0;
+        //this will help us to find the potential celebrity
+        for(int i=1;i<n;i++){
+            if(knows(potential,i)){
+                potential = i;
+            }
+        }
+
+        //we will confirm if he is the celebrity
+        for(int i=0;i<n;i++){
+            if(i!=potential){
+                if(knows(potential,i) || !knows(i,potential)){
+                    return -1;
+                }
+            }
+        }
+
+        return potential;
+
+     }
+}
\ No newline at end of file

From a2826e935bc29e44f9e9d75554e3163aa542f73f Mon Sep 17 00:00:00 2001
From: Piyush Chhoriya <piyushchhoriya98@gmail.com>
Date: Thu, 10 Apr 2025 03:09:37 -0400
Subject: [PATCH 2/3] Alien Dictionary

---
 AlienDictionary.class | Bin 0 -> 2231 bytes
 AlienDictionary.java  |  83 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+)
 create mode 100644 AlienDictionary.class
 create mode 100644 AlienDictionary.java

diff --git a/AlienDictionary.class b/AlienDictionary.class
new file mode 100644
index 0000000000000000000000000000000000000000..7fe949e2339353582e1e368dbaf0a0e78e5f79e0
GIT binary patch
literal 2231
zcmZuyU2qds6#j0qn@!U#Ep3<5TI9c^P1{(03N}zJ1*FhYFi<R@bek+?A=$)agBE?W
zPx|8UCOYFxXPmw{=t!^@JG|(O%;<|R`skz2zNjGh-A#W|$iv>fd+$Bp`OZ1tJ^S#<
zcZ&c9@O}tB_%$dxR0IU-u9-K?Xv%b^qN9`7tb{8NIA}Yz+b`e`w~qx86o7`1z<Td!
z!L?J-<7WQqh?xzc3jQk8V4a3q9d%eQP&<&aE$4`xaP5p^=B5dgHnRc^!_S$=q-leW
zMi>G?+euneIm;68T^tIb2^%#u>uA9XYgoqJob61JWy*4<+^Zf-@AxJiFJdz{5?9UK
z0OL@?L+yhhY{fPW+jZ=~PO?}HcaX=-glpvlv>RrsV2xf8*ccvcFA?=pvT`P-Vb`*?
zmw|y?&YT{$^KJ-j@XJJW=!l?`e6j^PKM*d1DP=bH{7Sj6r9%>`TSpWx5o*dJR9gk8
z3WgeX3#?mBvLsiH9_-bz54{94lSu)i64(U|2Lu|+ZJp~@vJ~EaDVLZ)(`xEUH8@<b
zQ%NfqLSHEX{W@Nej;a$G$2Dyyf6|(+rsVc&I80rvqMs>P1xxN6(Qy>Vn14HeG@W&&
zR>JKU<j!#&LpZ@2W;3Z2sf8;9EK57AV+5xJs$|i}WEDLOmc0+Bb)3QL6oi@0S`K4x
zU0d8WQN(1b&gwWP<)-BAn<UtS^Rf_c$gB-jB+!QoIxgZ8<?CjamARH|X*DLxdNzp5
z0^(*6CSPWV>gVlA!qRX>#}p{$vg;V1&bwBc;bf$qjFNclO!PGM?-JEA(?qSoH67Q%
z90e(s(HsjRuq%AAOlwOF$^%#-<shRWtK)6ZtaLfnx?pj#(qYPZMmx)>V@!VBo^njL
zkYn=ClpL3LiGyWaRxec9IjOVChx%jvRGu=JNfNqt*mkT_h4iGAJ8Mp+xKa~$&BS#!
zqNQ&oP1y--s2DzphT@q*E@2(BrE%jkjjCG;6kC{4A3LRd*v}x4_r6??>{A^5eAqg<
zQ{Ze9-)xXjJMKYz#fiWTj&fUq2w5ABJnH)e3W7Ya82J&w$l`4T>a{x^3#b~uhw8h~
zJL+2Qhwh@@f2cLGIEz@Mb@wTMuVN@&MQoVG&MreKqP17;_y)S6ev2&&XrpPki1za{
zikN%)+l-In51ze}oJC$DL|T=J-F=F`S2ffU(3qh%6N!++U4|+l1I<clq8R~0`yAb#
zivV2|(e(g5hQ{eU_V{p~JN1TEXC^OoD-)x0sG3pfbI$Yp(E|39(90tW=;QlfiG5wm
zEP5qiooOf&w>;28pJ0=Rq;%g#L+8rQJYJ;_FPNV?=P@X78`GS;Ch!1Ti#XY<cv%>g
zJaj`@Vc4hodjm$GS)E5*U={<-su7sSm~YumD<_^DUHPK_+Rml;Jl_F^Ge7rqhPfJN
zlBAy^-kkM{CD-nFb(J;#lKoy*x{AL?onsS1*o<oI;#Y(++K+W?h_#4wKF;;aXn;)-
zr70s98}K15Zeb%nMKc+<;67f!L$u;&?)}QMzq7ynfo=E`+wm86h&ukjwqUzxL%WEg
zLmWax9N{159J)jj-J*b~_<+BSkI^GO<Jv6tiZ8HF6xo#LaRBd-?Flqg`5vQD{0Ch_
zllTW6|3ZBXA)dhCf?RuqbALnS@)Oi+7|_rs_IO`CLL>Ae407Aoz=+?)bV=J7rncq9
z2nW7L)40F>t@yZ7KM@~SIU8O;4dpO7@--5jks|CO(yKS6o|eFI=4FVnpJ4V*67we4
He0cAF9w`Yq

literal 0
HcmV?d00001

diff --git a/AlienDictionary.java b/AlienDictionary.java
new file mode 100644
index 0000000..7a1ce10
--- /dev/null
+++ b/AlienDictionary.java
@@ -0,0 +1,83 @@
+Time Complexity : O(N*k) -> N = no of words and k is the average length
+Space Complexity : O(N*k)
+In this as we want to find a order and when we comapared 2 strings we found out a relationship that c1 comes before c2 and so on so we can say
+that it is a graph problem. Now what we will do is first iterate through all the words and find unique characters and add them in a map
+Then we will find out the relationship ones we get the mismatching character in both the strings then we will add them in a map and indegrees array and breaks.
+then we will iterate and find out the character with 0 indegree and add it in a queue and carry out BFS. The popped character is stored in StringBuilder
+
+import java.util.*;
+class AlienDictionary{
+    HashMap<Character,List<Character>> map;
+    int[] indegree;
+    public String getOrder(String[] str){
+        if(str==null || str.length==0){
+            return "";
+        }
+        map = new HashMap<>();
+        indegree = new int[26];
+        for(int j=0;j<str.length;j++){
+            String s = str[j];
+            for(int i=0;i<s.length();i++){
+                char ch = s.charAt(i);
+                map.put(ch,new ArrayList<>());
+            }
+        }
+
+        for(int i=0;i<str.length-1;i++){
+            String str1 = str[i]; 
+            String str2 = str[i+1];
+            for(int j=0;j<str1.length() && j<str2.length();j++){
+                char ch1 = str1.charAt(j);
+                char ch2 = str2.charAt(j);
+                if(ch1 != ch2){
+                    map.get(ch1).add(ch2);
+                    indegree[ch2-'a']++;
+                    break;
+                }
+            }
+        }
+
+        Queue<Character> q = new LinkedList<>();
+        StringBuilder sb = new StringBuilder();
+        for(int i=0;i<26;i++){
+            if(map.containsKey((char)('a'+i)) && indegree[i]==0){
+                q.add((char)('a'+i));
+            }
+        }
+        // System.out.println(q.peek());
+        while(!q.isEmpty()){
+            char ch = q.poll();
+            sb.append(ch);
+            List<Character> list = map.get(ch);
+            for(int i=0;i<list.size();i++){
+                char c = list.get(i);
+                indegree[c-'a']--;
+                if(indegree[c-'a']==0){
+                    q.add(c);
+                }
+            }
+        }
+        if(sb.toString().length() < map.size()){
+            return "";
+        }
+        return sb.toString();
+
+        // for(Map.Entry<Character,List<Character>> entry : map.entrySet()){
+        //     System.out.println(entry.getKey() +""+ entry.getValue());
+        // }
+        // for(int i=0;i<26;i++){
+        //     if(indegree[i]!=0){
+        //         System.out.println(i + " "+indegree[i]);
+        //     }
+        // }
+        // return "";
+        
+    }
+
+    public static void main(String[] args){
+        String[] str = {"wrt","wrf","er","ett","rfttz"};
+        // String[] str = {"z","a","z"};
+        AlienDictionary ad = new AlienDictionary();
+        System.out.println(ad.getOrder(str));
+    }
+}
\ No newline at end of file

From c496ca8a76c0f7b64a3622be1a9f2c9119a3a5cd Mon Sep 17 00:00:00 2001
From: Piyush Chhoriya <piyushchhoriya98@gmail.com>
Date: Thu, 10 Apr 2025 03:16:08 -0400
Subject: [PATCH 3/3] Alien Dictionary

---
 Verifying-an-Alien-Dictionary.java | 32 ++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Verifying-an-Alien-Dictionary.java

diff --git a/Verifying-an-Alien-Dictionary.java b/Verifying-an-Alien-Dictionary.java
new file mode 100644
index 0000000..741dbd2
--- /dev/null
+++ b/Verifying-an-Alien-Dictionary.java
@@ -0,0 +1,32 @@
+class Solution {
+    HashMap<Character, Integer> map;
+    public boolean isAlienSorted(String[] words, String order) {
+      if(words==null || words.length==0){
+        return true;
+      }  
+      map = new HashMap<>();
+      for(int i=0;i<order.length();i++){
+        char c = order.charAt(i);
+        map.put(c,i);
+      }
+      for(int i=0;i<words.length-1;i++){
+        boolean answer = checkLexicographical(words[i],words[i+1]);
+        if(answer == false){
+            return false;
+        }
+      }
+      return true;
+    }
+    private boolean checkLexicographical(String one, String two){
+        int m = one.length();
+        int n = two.length();
+        for(int i=0;i<m && i< n;i++){
+            char firstChar = one.charAt(i);
+            char secondChar = two.charAt(i);
+            if(map.get(firstChar) != map.get(secondChar)){
+                return map.get(firstChar) < map.get(secondChar);
+            }
+        }
+        return m<=n;
+    }
+}
\ No newline at end of file