my commit

Author: jaygajera17

Binary_String.cpp

@@ -0,0 +1,64 @@
+/*
+link:- https://practice.geeksforgeeks.org/problems/binary-string-1587115620/1
+problem:
+Given a binary string S. The task is to count the number of substrings that start and end with 1.
+For example, if the input string is “00100101”, then there are three substrings “1001”, “100101” and “101”.
+
+Input:
+N = 4
+S = 1111
+Output: 6
+Explanation: There are 6 substrings from
+the given string. They are 11, 11, 11,
+111, 111, 1111.
+
+Input:
+N = 5
+S = 01101
+Output: 3
+Explanation: There 3 substrings from the
+given string. They are 11, 101, 1101.
+
+*/
+
+class Solution
+{
+    public:
+    //Function to count the number of substrings that start and end with 1.
+    long binarySubstring(int n, string a){
+        
+        // n = length of string , a = binary string
+        int ans=0;
+        sort(a.begin(),a.end());
+        for(int i=0;i<n;i++)
+        {
+            if(a[i]!='0')
+            {
+                ans++;
+            }
+           //ans= count(a.begin(), a.end(), '1');
+        }
+       // return count;
+       return (ans*(ans-1))/2;
+    }
+
+};
+
+
+/*
+
+approch:-
+
+1.count the total number of 1's in the string ( using sort string and for loop)
+2. observe pattern if 
+number of 1 is 1 then ans 1
+number of 1 is 2 then ans 2
+number of 1 is 3 then ans 3
+number of 1 is 4 then ans 6
+number of 1 is 5 then ans 10
+.
+.
+number of 1 is n then ans n*(n-1)/2
+
+*/
+

Integer_To_Roman.cpp

@@ -0,0 +1,36 @@
+/*
+link:- https://practice.geeksforgeeks.org/problems/convert-to-roman-no/1
+
+problem:- covert integer to roman number 
+
+Input:
+n = 5
+Output: V
+
+Input:
+n = 3
+Output: III
+
+*/
+
+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;
+    }
+};

anagram_make.cpp

@@ -0,0 +1,64 @@
+
+
+/*
+ problem link:- https://practice.geeksforgeeks.org/problems/anagram-of-string/1
+
+ problem statement:- Given two strings S1 and S2 in lowercase, the task is to make them anagram.
+                     The only allowed operation is to remove a character from any string. 
+                     Find the minimum number of characters to be deleted to make both the strings anagram.
+                     Two strings are called anagram of each other if one of them can be converted into another by rearranging its letters.
+
+Example 1:
+
+Input:
+S1 = bcadeh
+S2 = hea
+Output: 3
+Explanation: We need to remove b, c
+and d from S1.
+
+Example 2:
+
+Input:
+S1 = cddgk
+S2 = gcd
+Output: 2
+Explanation: We need to remove d and
+k from S1.
+
+*/
+
+int remAnagram(string str1, string str2)
+{
+
+  int m1[26]={0},m2[26]={0},res=0;
+  for(int i=0;i<str1.length();i++)
+  {
+      m1[str1[i]-'a']++;
+  }
+    for(int i=0;i<str2.length();i++)
+  {
+      m2[str2[i]-'a']++;
+  }
+  for(int i=0;i<26;i++)
+  {
+      res=res+abs(m1[i]-m2[i]);
+  }
+    return res;
+}
+
+//Dry run
+/*
+
+s1=cddgk
+s2=gcd
+
+s1 map | s2 map  | diff | res
+c-1    | c-1     | 0    | 0
+d-2    | d-1     | 1    | 1
+g-1    | g-1     | 0    | 0
+k-1    |         | 1    | 1+1=2
+
+res=output=2
+
+*/

anagram_string_or_not.cpp

@@ -0,0 +1,26 @@
+
+/* 
+link:-  https://practice.geeksforgeeks.org/problems/anagram-1587115620/1
+
+problem: Given two strings a and b consisting of lowercase characters. 
+         The task is to check whether two given strings are an anagram of each other or not.
+         An anagram of a string is another string that contains the same characters, 
+         only the order of characters can be different.
+         For example, act and tac are an anagram of each other.
+
+
+Input: a = geeksforgeeks, b = forgeeksgeeks
+Output: YES
+Explanation: Both the string have same characters with
+        same frequency. So, both are anagrams.
+*/
+
+class Solution
+{
+    public:
+    bool isAnagram(string a, string b){
+        sort(a.begin(),a.end());
+        sort(b.begin(),b.end());
+        return a==b;
+    }
+};

array_subset_of_another_sum.cpp

@@ -0,0 +1,85 @@
+/*
+link:- https://practice.geeksforgeeks.org/problems/array-subset-of-another-array2317/1
+
+problem:-
+Given two arrays: a1[0..n-1] of size n and a2[0..m-1] of size m. Task is to
+check whether a2[] is a subset of a1[] or not.
+Both the arrays can be sorted or unsorted.
+
+Input:
+a1[] = {11, 1, 13, 21, 3, 7}
+a2[] = {11, 3, 7, 1}
+Output:
+Yes
+Explanation:
+a2[] is a subset of a1[]
+
+Input:
+a1[] = {10, 5, 2, 23, 19}
+a2[] = {19, 5, 3}
+Output:
+No
+Explanation:
+a2[] is not a subset of a1[]
+
+*/
+
+string isSubset(int a1[], int a2[], int n, int m)
+{
+
+    unordered_set<int> s(a1, a1 + n);
+    for (int i = 0; i < n; i++)
+    {
+        s.insert(a1[i]);
+    }
+    int cnt = 0;
+    // cout<< s.size();
+    for (int i = 0; i < m; i++)
+    {
+        if (s.count(a2[i]))
+        {
+            cnt++;
+        }
+        if (cnt == m)
+        {
+            return "Yes";
+        }
+    }
+    return "No";
+}
+
+/*
+
+OTHER APPROCH:-
+
+string isSubset(int a1[], int a2[], int n, int m) {
+
+   vector<int>v1(a1,a1+n);
+   vector<int>v2(a2,a2+m);
+   int f=0;
+      vector<int>::iterator it;
+    int i=0;
+   while(i!=v2.size())
+   {
+  it=find(v1.begin(),v1.end(),v2[i]);
+  i++;
+  if(it!=v1.end())
+  {
+
+  }
+  else
+    {
+       f=1;
+    }
+}
+if(f==1)
+{
+    return "No";
+}
+else
+{
+    return "Yes";
+}
+}
+
+*/

check_string_rotated_eachother_or_not.cpp

@@ -0,0 +1,54 @@
+
+/*
+link:- https://practice.geeksforgeeks.org/problems/check-if-strings-are-rotations-of-each-other-or-not-1587115620/1
+
+Given two strings s1 and s2. The task is to check if s2 is a rotated version of the string s1.
+ The characters in the strings are in lowercase.
+
+Input:
+    geeksforgeeks
+    forgeeksgeeks
+Output: 
+    1
+
+Explanation: s1 is geeksforgeeks, s2 is
+forgeeksgeeks. Clearly, s2 is a rotated
+version of s1 as s2 can be obtained by
+left-rotating s1 by 5 units.
+
+
+Example 2:
+
+Input:
+    mightandmagic
+    andmagicmigth
+Output: 
+    0
+Explanation: Here with any amount of
+rotation s2 can't be obtained by s1.
+
+
+*/
+
+
+// approch:- do s1+s1 and find window of s2 in s1 and check if s2 is there or not.
+class Solution
+{
+    public:
+    //Function to check if two strings are rotations of each other or not.
+    bool areRotations(string s1,string s2)
+    {
+        if(s1.length()!=s2.length())
+        {
+            return 0;
+        }
+        else
+        {
+         string s=s1+s1;
+         if(s.find(s2)!=string::npos)
+            return 1;
+         else
+             return 0;
+        }
+    }
+};

find_occurence_of_s2_in_s1.cpp

@@ -0,0 +1,28 @@
+/*
+link:- https://practice.geeksforgeeks.org/problems/implement-strstr/1
+
+Input:
+    s = GeeksForGeeks, x = Fr
+Output: -1
+
+Explanation: Fr is not present in the
+string GeeksForGeeks as substring.
+
+*/
+
+
+//Function to locate the occurrence of the string x in the string s.
+int strstr(string s, string x)
+{
+     //Your code here
+    // char p=strstr(s,x);
+     if(s.find(x)!=string::npos)
+     {
+         return s.find(x);  //returns the index of the first occurence of x in s
+     }
+     else
+     {
+         return -1;
+     }
+     
+}