adding leetcode weekly 239

LeetCode/Contests/Weekly 239/Minimum Adjacent Swaps to Reach the Kth Smallest Number.cpp

@@ -0,0 +1,87 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+
+class Solution {
+public:
+    int getMinSwaps(string nums, int k) {
+
+            int size=nums.size();
+            string cnums=nums;
+
+            while (k--)
+            {
+
+                int i=size-2;
+                multiset<char>dic;
+                dic.insert(nums[i+1]);
+
+                while(i>=0){
+
+                    if(nums[i]<nums[i+1])
+                        break;
+                    dic.insert(nums[i]);
+                    i--;
+                }
+
+                if(i==-1)
+                    break;
+                auto it=upper_bound(dic.begin(),dic.end(),nums[i]);
+                char ele=nums[i];
+                nums[i]=*it;
+                dic.erase(it);
+                dic.insert(ele);
+                i++;
+
+                for(auto ele:dic){
+                    nums[i]=ele;
+                    i++;
+                }
+
+
+            //cout<<cnums<<" "<<nums<<endl;
+                /* code */
+            }
+
+            int count=0;
+
+            int i;
+            for(int i=0;i<size;){
+
+                if(cnums[i]!=nums[i]){
+
+                    int j=i+1;
+                    while(j<size){
+                        if(nums[j]==cnums[i])
+                            break;
+                        j++;
+                    }
+
+                    int k=j-1;
+                    while (k>=i)
+                    {
+                        auto t=nums[k];
+                        nums[k]=nums[k+1];
+                        nums[k+1]=t;
+                        count++;
+                        k--;
+                        //cout<<"updating :"<<cnums<<" "<<nums<<endl;
+
+                        /* code */
+                    }
+
+                    i++;
+
+                }
+                else{
+                    i++;
+                }
+
+
+            }
+
+            return count;
+
+
+    }
+};

LeetCode/Contests/Weekly 239/Minimum Distance to the Target Element.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int getMinDistance(vector<int>& nums, int target, int start) {
+
+        int index=0;
+        int mini=INT_MAX;
+        for(auto ele:nums){
+            if(ele==target){
+                mini=min(abs(start-index),mini);
+            }
+            index++;
+        }
+        return mini;       
+    }
+};

LeetCode/Contests/Weekly 239/Splitting a String Into Descending Consecutive Values.cpp

@@ -0,0 +1,116 @@
+
+class Solution {
+public:
+    bool splitString(string s) {
+
+
+        int i=0;
+        while(s[i]){
+            if(s[i]=='0')
+                i++;
+            else{
+                break;
+            }
+        }
+
+        int size=s.size();
+
+
+        //cout<<"New :"<<s<<endl;
+        i=0;
+
+        while(i<(1<<size)){
+
+            bool space =false;
+
+            int number=i;
+
+            vector<bool>arr;
+
+            int times=0;
+
+            while(times<32){
+                arr.push_back((number&(1<<times))==0);
+
+                times++;
+            }
+
+
+            int j=0;
+
+            vector<long long>splittedNum;
+
+
+            while(j<32){
+
+                int k=j;
+                string childS;
+
+                while(k<32){
+
+                    if(arr[j]==arr[k])k++;
+                    else break;
+
+                }
+
+
+                if(j!=size){
+                    childS=s.substr(j,k-j);
+
+                    int ind=0;
+
+                    string newChildS;
+
+
+                    //cout<<"input :"<<childS<<"--";
+
+                    int index=0;
+                    for(auto ele:childS){
+                        if(!(ele>='0'&&ele<='9')){
+                            break;
+                        }
+                        index++;
+                    }
+
+                    childS=childS.substr(0,index);
+                    splittedNum.push_back(stoll(childS,nullptr,10));
+
+                }
+                j=k;
+
+
+            }
+
+            int I=1;
+            bool flag=true;
+            //cout<<"\nhere :"<<splittedNum.size()<<endl;
+
+            reverse(splittedNum.begin(),splittedNum.end());
+
+
+            while(I<splittedNum.size()){
+                //cout<<splittedNum[I]<<" "<<splittedNum[I-1]<<"--";
+                if(splittedNum[I]-splittedNum[I-1]!=1)
+                {
+                    flag=false;
+                    break;
+                }
+                I++;
+            }
+
+            if(flag&&splittedNum.size()>1&&!space)
+                return true;
+
+
+            //cout<<endl;
+
+
+
+
+            i++;
+        }
+
+        return false;
+
+    }
+};

LeetCode/Contests/Weekly 239/readme.md

@@ -0,0 +1,3 @@
+I have doubt in problem 2 and 3
+In my case both of them gave me TLE 
+Logic seems to be fine.