updated

Author: ASTRO063

Hard_level/.DS_Store

@@ -0,0 +1,39 @@
+Given two sorted arrays nums1 and nums2 of size m and n respectively.
+
+Return the median of the two sorted arrays.
+
+Follow up: The overall run time complexity should be O(log (m+n)).
+
+ 
+
+Example 1:
+
+Input: nums1 = [1,3], nums2 = [2]
+Output: 2.00000
+Explanation: merged array = [1,2,3] and median is 2.
+Example 2:
+
+Input: nums1 = [1,2], nums2 = [3,4]
+Output: 2.50000
+Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+Example 3:
+
+Input: nums1 = [0,0], nums2 = [0,0]
+Output: 0.00000
+Example 4:
+
+Input: nums1 = [], nums2 = [1]
+Output: 1.00000
+Example 5:
+
+Input: nums1 = [2], nums2 = []
+Output: 2.00000
+ 
+
+Constraints:
+
+nums1,length == m
+nums2,length == n
+0 <= m <= 1000
+0 <= n <= 1000
+1 <= m + n <= 2000

Hard_level/4. Median of Two Sorted Arrays/question

@@ -0,0 +1,14 @@
+class Solution:
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
+        nums1.extend(nums2)
+        nums1.sort()
+        if len(nums1)%2==0:
+            # print("index1=",len(nums1)//2,"index2=",(len(nums1)//2)-1)
+            # print("value1=",nums1[len(nums1)//2])
+            # print("value2=",nums1[(len(nums1)//2)-1])
+            # print("median=",(nums1[len(nums1)//2] +nums1[(len(nums1)//2)-1])/2)
+            return (nums1[len(nums1)//2] +nums1[(len(nums1)//2)-1])/2
+        else:
+            # print("index=",len(nums1)//2)
+            # print("median=",nums1[len(nums1)//2])
+            return float(nums1[len(nums1)//2])

Hard_level/4. Median of Two Sorted Arrays/solution.py

@@ -0,0 +1,22 @@
+Given an array of 4 digits, return the largest 24 hour time that can be made.
+
+The smallest 24 hour time is 00:00, and the largest is 23:59.  Starting from 00:00, a time is larger if more time has elapsed since midnight.
+
+Return the answer as a string of length 5.  If no valid time can be made, return an empty string.
+
+ 
+
+Example 1:
+
+Input: [1,2,3,4]
+Output: "23:41"
+Example 2:
+
+Input: [5,5,5,5]
+Output: ""
+ 
+
+Note:
+
+1)A.length == 4
+2)0 <= A[i] <= 9

September-2020-Daily challenges/.DS_Store

@@ -0,0 +1,37 @@
+class Solution:
+    def largestTimeFromDigits(self, A: List[int]) -> str:          
+        hour,mintue=0,0
+        flag=False
+        a,b=0,0
+        time={}
+        for i in range(0,4):
+            for j in range(0,4):
+                temp=(A[i]*10 + A[j])   
+                if i!=j and temp>=0 and temp<=23 :
+                    hour=A[i]*10 + A[j]
+                    i1,i2=i,j
+                    a,b=A[i1],A[i2]
+                    A[i1],A[i2]=None,None
+                    mintues=[A[k] for k in range(0,4) if A[k]!=None ]
+                    flag=True
+                    if mintues[0]>=mintues[1]:
+                        mintue= str(mintues[0]) + str(mintues[1])
+                    else:
+                        mintue= str(mintues[1]) + str(mintues[0])
+        
+                    if int(mintue) >=60:
+                        mintue=mintue[::-1]
+                        if int(mintue)>=60:
+                            flag=False
+                    if flag==True:
+                        time[hour]=mintue
+                    A[i1],A[i2]=a,b
+                        
+        if len(time) ==0:
+            return ""
+        else:
+            hour=max(time.keys())
+            mintue=time[hour]
+            return str(hour//10)+str(hour%10)+":"+str(mintue)
+        
+                

September-2020-Daily challenges/week-1/ Largest Time for Given Digits/question

@@ -0,0 +1,18 @@
+Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. You may assume the given string consists of lowercase English letters only and its length will not exceed 10000.
+
+ 
+
+Example 1:
+
+Input: "abab"
+Output: True
+Explanation: It's the substring "ab" twice.
+Example 2:
+
+Input: "aba"
+Output: False
+Example 3:
+
+Input: "abcabcabcabc"
+Output: True
+Explanation: It's the substring "abc" four times. (And the substring "abcabc" twice.)

September-2020-Daily challenges/week-1/ Largest Time for Given Digits/solution.py

@@ -0,0 +1,20 @@
+class Solution:
+    def repeatedSubstringPattern(self, s: str) -> bool:
+        st=s[0]
+        half=len(s)//2
+        for i in range(0,half):    
+            # print("sub",st)
+            # if len(st)%2 ==0:
+            #     pass
+            # else:
+            #     pass
+            rst=st[:]
+            while len(rst) < len(s):
+                rst=rst+st
+            # print("str",rst)
+            if rst==s:
+                return True
+            else:
+                st=s[:i+2]
+                # print("edsd==",st)
+        return False

September-2020-Daily challenges/week-1/ Repeated Substring Pattern/question

@@ -0,0 +1,14 @@
+Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.
+
+Example 1:
+
+Input: nums = [1,2,3,1], k = 3, t = 0
+Output: true
+Example 2:
+
+Input: nums = [1,0,1,1], k = 1, t = 2
+Output: true
+Example 3:
+
+Input: nums = [1,5,9,1,5,9], k = 2, t = 3
+Output: false