/

Author: jaygajera17

Add_minimum-Char_palindrome.cpp

@@ -0,0 +1,29 @@
+
+
+/* https://practice.geeksforgeeks.org/problems/55d */
+
+
+ int addMinChar(string str){    
+        //code here
+        int n=str.length();
+        int i=0;
+        int j=n-1;
+        int ans=0;
+        while(i<=j)
+        {
+            if(str[i]==str[j])
+            {
+                i++;
+                j--;
+            }
+            else
+            {
+                ans++;
+                i=0;
+                j=n-1-ans;
+            }
+        }
+        
+      
+    return ans;
+    }

Count_Number_of_consistent_string.cpp

@@ -0,0 +1,25 @@
+/* https://leetcode.com/problems/count-the-number-of-consistent-strings/description/ */
+
+class Solution {
+public:
+    int countConsistentStrings(string allowed, vector<string>& words) {
+
+       int count=0; 
+        for(int i=0;i<words.size();i++)
+        {
+            for(int j=0;j<words[i].size();j++)
+            {
+                if(allowed.find(words[i][j])!=string::npos)
+                {
+
+                }
+                else
+                {
+                    count++;
+                    break;
+                }
+            }
+        }
+        return words.size()-count;
+    }
+};

Integer_To_Roman.cpp

@@ -17,20 +17,21 @@ class Solution{
   public:
     string convertToRoman(int n) {
         // code here
-      int num[]={1,4,5,9,10,40,50,90,100,400,500,900,1000};
-      string s[]={"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
-      string ans;
-      int i=12;
-      while(n>0)
-      {
-          int div=n/num[i];
-          n=n%num[i];
-          while(div--)
-          {
-              ans=ans+s[i];
-          }
-          i--;
-      }
-        return ans;
+      vector<string> notations = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
+        vector<int> value = {1000,900,500,400,100,90,50,40,10,9,5,4,1};
+        string s;
+       int i=0;
+        while(num!=0)
+        {
+            if(num>=value[i])
+            {
+              s=s+notations[i];
+              num=num-value[i];
+            }
+            else{
+                i++;
+            }
+        }
+        return s;
     }
 };

Longest_Balance_Binary_String.cpp

@@ -0,0 +1,18 @@
+
+/* https://leetcode.com/problems/find-the-longest-balanced-substring-of-a-binary-string/*/
+class Solution {
+public:
+    int findTheLongestBalancedSubstring(string s) {
+        int res=0;
+        string temp="01";
+        while(temp.size()<=s.size())
+        {
+            if(s.find(temp)!=string::npos){
+               res=temp.size();
+            }
+            temp='0'+temp+'1';
+        }
+        return res;
+
+    }
+};

Longest_Substring_without_repeting_char.cpp

@@ -0,0 +1,31 @@
+/*https://leetcode.com/problems/longest-substring-without-repeating-characters/description/*/
+
+
+
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        unordered_set<char>set;
+        int i=0,j=0,n=s.length();
+        int maxi=0;
+
+        while(i<n && j<n)
+        {
+            if(set.find(s[j])==set.end())
+            {
+                set.insert(s[j]);
+                j++;
+                maxi=max(maxi,j-i);
+
+            }
+            else
+            {
+                set.erase(s[i]);
+                i++;
+            }
+        }
+ 
+        return maxi;
+        }
+    
+};

Maximum_Length.cpp

@@ -0,0 +1,18 @@
+/* https://practice.geeksforgeeks.org/problems/84963d7b5b84aa24f7807d86e672d0f97f41a4b5/1 */
+
+
+class Solution {
+public:
+    int solve(int a, int b, int c) {
+        // code here || (b >(a+c)(a+c+1)/2) || (a>(b+c)(b+c+1)/2))
+       if( (c>2*(a+b)) || (b >2*(a+c))  ||  (a>2*(b+c)))
+       {
+           return -1;
+       }
+        else
+        {
+            return a+b+c;
+        }
+        
+    }
+};

README.md

@@ -25,6 +25,15 @@
 - transform(s.begin(), s.end(), s.begin(), ::tolower);
 - transform(s.begin(), s.end(), s.begin(), ::toupper);
 
-- Find:-  s1.find(s2[i]):- it means <find s2[i] in s1>
+- Find:-  s1.find(s2[i])!=string::npos:- it means <find s2[i] in s1> is present
+
+- token:- stringstream 
+  ex:    string s = "geeks for geeks"; 
+         stringstream ss(s); // Used for breaking words 
+         string word; // to store individual words 
+         while (ss >> word) 
+         cout << word << endl;
+
+         
 
         

Remove_Stars_From_String.cpp

@@ -0,0 +1,30 @@
+/* https://leetcode.com/problems/removing-stars-from-a-string/description/ */
+
+class Solution {
+public:
+    string removeStars(string s) {
+        stack<char>st;
+        for(char c:s)
+        {
+            
+                if(!st.empty() && c=='*')
+                {
+                    st.pop();
+                }
+                else
+                {
+                    st.push(c);
+                }
+            
+        }
+        string ans;
+        while(!st.empty())
+        {
+            ans+=st.top();
+            st.pop();
+        }
+        reverse(ans.begin(),ans.end());
+
+        return ans;
+    }
+};

Reverse_Word_in_String.cpp

@@ -56,4 +56,26 @@ mno.pqr
           ans1=ans1+i;
       }
      return ans1+t;
-    }
+    }
+
+
+    // https://leetcode.com/problems/reverse-words-in-a-string
+
+
+    string reverseWords(string s) {
+        stringstream ss(s);
+        string word;
+        vector<string>v;
+        while(ss>>word)
+        {
+            v.push_back(word);
+            v.push_back(" ");
+        }
+        v.pop_back();
+        reverse(v.begin(),v.end());
+        string ans;
+        for(auto i:v)
+        {
+            ans=ans+i;
+        }
+        return ans;

Roman_To_Integer.cpp

@@ -0,0 +1,33 @@
+/* https://leetcode.com/problems/roman-to-integer/ */
+
+
+class Solution {
+public:
+    int romanToInt(string s) {
+       
+        
+        unordered_map<char,int>m;
+        m['I']=1;
+        m['V']=5;
+        m['X']=10;
+        m['L']=50;
+        m['C']=100;
+        m['D']=500;
+        m['M']=1000;
+        
+
+        int ans=0;
+        for(int i=0;i<s.length();i++)
+        {
+             if(m[s[i]]>=m[s[i+1]] )
+             {
+                 ans=ans+m[s[i]];
+             }
+             else{
+                 ans=ans-m[s[i]];
+             }
+        }
+        return ans;
+
+    }
+};

find_divisibility_array_of_string.cpp

@@ -0,0 +1,30 @@
+/*https://leetcode.com/contest/weekly-contest-334/problems/find-the-divisibility-array-of-a-string/*/
+
+
+class Solution {
+public:
+    vector<int> divisibilityArray(string word, int m) {
+        vector<int>v;
+        string s;
+        unsigned long long int remainder=0; 
+      
+        for(int i=0;i<word.size();i++)
+        {
+         int digit=word[i]-'0';    
+        
+                remainder=(remainder*10 + digit)%m;
+          //  int n=stoi(s);
+            if(remainder==0)
+            {
+                
+               v.push_back(1);
+            }
+            else
+            {
+                v.push_back(0);
+            }
+            
+        }
+        return v;
+    }
+};

find_occurence_of_s2_in_s1.cpp

@@ -1,5 +1,6 @@
 /*
 link:- https://practice.geeksforgeeks.org/problems/implement-strstr/1
+https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/description/
 
 Input:
     s = GeeksForGeeks, x = Fr
@@ -10,6 +11,24 @@ string GeeksForGeeks as substring.
 
 */
 
+//NAIVE
+ int strStr(string a, string b) {
+        if(b.length()>a.length()) return -1;
+        for(int i=0;i<=a.length()-b.length();i++)
+        {
+            
+            for(int j=0;j<b.length();j++)
+            {
+                if(a[i+j]!=b[j])
+                {
+                  break;
+                }
+                if(j==b.length()-1) return i;
+            }
+        }
+        return -1;
+    }
+
 
 //Function to locate the occurrence of the string x in the string s.
 int strstr(string s, string x)

first-unique-character-in-string.cpp

@@ -0,0 +1,21 @@
+
+/* https://leetcode.com/problems/first-unique-character-in-a-string/ */
+
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        map<char,int>m;
+        for(int i=0;i<s.length();i++)
+        {
+            m[s[i]]++;
+        }
+        for(auto i=0;i<s.length();i++)
+        {
+            if(m[s[i]]==1)
+            {
+                return i;
+            }
+        }
+        return -1;
+    }
+};

permutation_of_string.cpp

@@ -0,0 +1,14 @@
+/* https://practice.geeksforgeeks.org/problems/permutations-of-a-given-string2041/1?page=4&sortBy=submissions */
+
+
+vector<string>find_permutation(string S)
+		{
+		    vector<string>v;
+		    sort(S.begin(),S.end());
+		    do{
+		        v.push_back(S);
+		    }
+		    while(next_permutation(S.begin(),S.end()));
+	
+		    return v;
+		}