4. Median of Two Sorted Arrays | Hard | C++

.github/workflows/IssueComment.yml

@@ -0,0 +1,34 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the main branch
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      - name: Issue comment
+        # You may pin to the exact commit or the version.
+  # uses: kyoncy/issue-comment-actions@1b1e351bee044874171a5dc99598257425f6272c
+        uses: kyoncy/issue-comment-actions@v1
+        with:
+    # GitHub token for use by this action.
+         token: ${{ secrets.GITHUB_TOKEN }}
+    # Message
+         message: Thankyou, for opening the issue. Please wait for the issue to be assigned to you and fo not open anymore issues until this is resolved.
+

.github/workflows/main.yml

@@ -28,4 +28,4 @@ jobs:
     # GITHUB_TOKEN secret
         repo-token: ${{ secrets.GITHUB_TOKEN }}
     # Message to comment
-        message: Please link your PR with the issue assigned to it, otherwise it will not be reviewed
+        message: Please link your PR with the issue, otherwise it will not be reviewed. If this PR was created for an Issue not assigned to you, it might be marked invalid

C++/3Sum.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> res;
+        sort(nums.begin(), nums.end());
+        for(int i=0;i<nums.size();i++){
+            int target=-nums[i];
+            int front=i+1;
+            int back=nums.size()-1;
+            while(front<back){
+                int sum=nums[front]+nums[back];
+                if(sum>target){
+                    back--;
+                }
+                else if(sum<target){
+                    front++;
+                }else{
+                    int f=nums[front];
+                    int b=nums[back];
+                    res.push_back({nums[i],f,b});
+                    while(front<back&&nums[front]==f)
+                        front++;
+                    while(front<back&&nums[back]==b)
+                        back--;
+                }
+            }
+            while(i+1<nums.size() && nums[i+1]==nums[i])
+                i++;
+        }
+        return res;
+    }
+};

C++/LongestIncreasingSubsequence.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        vector<vector<int>> dp(nums.size()+1,vector<int>(nums.size()+1,0));
+        vector<int> a;
+        vector<int> s=nums;
+        sort(s.begin(),s.end());
+        a.push_back(s[0]);
+        for(int i=1;i<s.size();i++){
+            if(s[i]!=s[i-1])
+                a.push_back(s[i]);
+        }
+        for(int i=0;i<nums.size();i++){
+            for(int j=0;j<a.size();j++){
+                if(nums[i]==a[j]){
+                    dp[i+1][j+1]=1+dp[i][j];
+                }else{
+                    dp[i+1][j+1]=max(dp[i+1][j],dp[i][j+1]);
+                }
+            }
+        }
+        return dp[nums.size()][a.size()];
+    }
+};

C++/Median_of_two_sorted_arrays.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    double findMedianSortedArrays(vector<int>& a, vector<int>& b) {
+        int m=a.size();
+        int n=b.size();
+        if(m>n)
+            return findMedianSortedArrays(b,a);
+        int l=0,r=m;
+        while(l<=r){
+            int partx=l+(r-l)/2;
+            int party=(m+n+1)/2-partx;
+            int maxlx=(partx==0)?INT_MIN:a[partx-1];
+            int minrx=(partx==m)?INT_MAX:a[partx];
+            int maxly=(party==0)?INT_MIN:b[party-1];
+            int minry=(party==n)?INT_MAX:b[party];
+            if(maxlx<=minry&&maxly<=minrx){
+                if((m+n)%2==0)
+                    return (double)(max(maxlx,maxly)+min(minrx,minry))/2;
+                else
+                    return (double)(max(maxlx,maxly));
+            }else if(maxlx>minry)
+                r=partx-1;
+            else
+                l=partx+1;
+        }
+        return -1.0; 
+    }
+};

C++/Permutation_Sequence.cpp

@@ -0,0 +1,29 @@
+// https://leetcode.com/problems/permutation-sequence/
+class Solution {
+public:
+    string getPermutation(int n, int k) {
+        vector<bool> chck(n+1,false);
+        vector<long long> fac={1,1,2,6,24,120,720,5040,40320,362880};
+        string ans;
+        int len=0;
+        while(len!=n)
+        {
+            int x=(k-1)/fac[n-len-1];
+            k-=fac[n-len-1]*x;
+            int count=0;
+            for(int i=1;i<=n;i++)
+            {
+                if(chck[i]==false)
+                    count++;
+                if(count==(x+1))
+                {
+                    chck[i]=true;
+                    ans+=i+48;
+                    len++;
+                    break;
+                }
+            }
+        }
+        return ans;
+    }
+};

C++/ShuffleAnArray.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<int> nums;
+    Solution(vector<int>& nums) {
+        this->nums=nums;
+    }
+
+    /** Resets the array to its original configuration and return it. */
+    vector<int> reset() {
+        return nums;
+    }
+
+    /** Returns a random shuffling of the array. */
+    vector<int> shuffle() {
+        vector<int> nw(nums);
+        for(int i=0;i<nums.size();i++){
+            int pos=rand()%(nums.size()-i);
+            swap(nw[pos+i],nw[i]);
+        }
+        return nw;
+    }
+};
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution* obj = new Solution(nums);
+ * vector<int> param_1 = obj->reset();
+ * vector<int> param_2 = obj->shuffle();
+ */

C++/Text_Justification.cpp

@@ -0,0 +1,109 @@
+//https://leetcode.com/problems/text-justification/
+#define ff first
+#define ss second
+class Solution {
+public:
+    vector<string> fullJustify(vector<string>& words, int maxWidth) {
+        int n=words.size();
+        if(n==1)
+        {
+            vector<string> ans(1);
+            ans[0]+=words[0];
+            while(ans[0].length()!=maxWidth)
+                ans[0]+=" ";
+            return ans;
+        }
+        vector<pair<int,int>> len(n);
+        len[0].first=words[0].length();
+        len[0].second=len[0].first;
+        int i;
+        for(i=1;i<n;i++)
+        {
+            len[i].first=words[i].length();
+            len[i].second=len[i-1].second+len[i].first;
+        }
+        if(len[i-1].ss+i-1<=maxWidth)
+        {
+            vector<string> ans(1);
+            ans[0]+=words[0];
+            for(int i=1;i<n;i++)
+                ans[0]+=" "+words[i];
+            while(ans[0].length()!=maxWidth)
+                ans[0]+=" ";
+            return ans;
+        }
+        vector<pair<int,int>> help(1);
+        int check=0;
+        help[0].ff=0;
+        int j=0;
+        for(i=0;i<words.size();i++)
+        {
+            if(check+len[i].first<=maxWidth)
+            {
+                check+=len[i].first;
+                check++;
+            }
+            else
+            {
+                help[j].ss=i-1;
+                j++;
+                help.push_back(make_pair(i,0));
+                check=len[i].first;
+                check++;
+            }
+        }
+        help[j].ss=i-1;
+        j++;
+        vector<string> ans(j,"");
+        int sum=len[help[0].ss].ss;
+        int space=help[0].ss;
+        i=0;
+        while(i!=help[0].ss)
+        {
+            ans[0]+=words[i];
+            i++;
+            int xx=maxWidth-sum;
+            int j;
+            for(j=0;j<ceil((double)xx/(double)space);j++)
+            {
+                ans[0]+=" ";
+            }
+            space--;
+            sum+=(j);
+        }
+        ans[0]+=words[i];
+         while(ans[0].length()!=maxWidth)
+            ans[0]+=" ";
+        int ii;
+        for(ii=1;ii<j-1;ii++)
+        {
+            i=help[ii].ff;
+            sum=len[help[ii].ss].ss-len[help[ii].ff-1].ss;
+            space=help[ii].ss-help[ii].ff;
+            while(i!=help[ii].ss)
+            {
+                ans[ii]+=words[i];
+                i++;
+                int xx=maxWidth-sum;
+                int j;
+                for(j=0;j<ceil((double)xx/(double)space);j++)
+                {
+                    ans[ii]+=" ";
+                }
+                space--;
+                sum+=(j);
+            }
+            ans[ii]+=words[i];
+             while(ans[ii].length()!=maxWidth)
+            ans[ii]+=" ";
+        }
+        ans[ii]+=words[help[ii].ff];
+        for(int i=help[ii].ff+1;i<n;i++)
+        {
+            ans[ii]+=" "+words[i];
+        }
+        while(ans[ii].length()!=maxWidth)
+            ans[ii]+=" ";
+        return ans;
+    }
+};

C++/Valid_Number.cpp

@@ -0,0 +1,63 @@
+//https://leetcode.com/problems/valid-number
+class Solution {
+public:
+    bool isNumber(string s) {
+        int n=s.length();
+        if(n==0)
+            return false;
+        if(n==1&&(s[0]<'0'||s[0]>'9'))
+            return false;
+        int i=0;
+        while(s[i]==' '&&i<n)
+            i++;
+        if(i==n)
+            return false;
+        while(s[n-1]==' '&&i>=0)
+            n--;
+        if(s[i]=='+'||s[i]=='-')
+            i++;
+        if(i==n)
+            return false;
+        bool chcke=false;
+        bool chckdec=false;
+        if(s[i]=='e')
+            return false;
+        if(s[i]=='.'&&i+1<n&&s[i+1]>='0'&&s[i+1]<='9')
+        {
+            i++;
+            chckdec=true;
+        }
+        for(i;i<n;i++)
+        {
+            if(s[i]>='0'&&s[i]<='9')
+            {
+                if(i+1<n&&s[i+1]=='.')
+                {
+                    if(chckdec==false)
+                        chckdec=true;
+                    else
+                        return false;
+                    i++;
+                }
+            }
+            else if(s[i]=='e')
+            {
+                if(i+1==n)
+                    return false;
+                if(chcke==true)
+                    return false;
+                chcke=true;
+                if(s[i+1]=='+'||s[i+1]=='-')
+                {
+                    i++;
+                    if(i+1==n)
+                        return false;
+                }
+                chckdec=true;
+            }
+            else
+                return false;
+        }
+    return true;   
+    }
+};