Merge branch 'main' of https://github.com/python-geeks/Leetcode-scripts into allwells

Author: allwells

0033/ search_in_rotated_sorted_array.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+       """
+        low, high = 0, len(nums) - 1
+        while low <= high:
+            mid = low + ((high - low) >> 1)
+            if nums[mid] == target:
+                return mid
+            elif nums[low] > nums[mid]:
+                if nums[mid] < target and nums[high] >= target:
+                    low = mid + 1
+                else:
+                    high = mid - 1
+            elif nums[low] <= nums[mid]:
+                if nums[low] <= target and nums[mid] > target:
+                    high = mid - 1
+                else:
+                    low = mid + 1
+        return -1

0033/README.md

@@ -0,0 +1,42 @@
+
+# **Search in Rotated Sorted Array**
+## **Problem Statement:**
+
+There is an integer array nums sorted in ascending order (with distinct values).
+
+Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].
+
+Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.
+
+You must write an algorithm with O(log n) runtime complexity.
+
+## **Example 1:**
+### **Input: nums=[4,5,6,7,0,1,2]**
+## **target:4**
+## **Output:4**
+
+## **Example 2:**
+### **Input: nums=[4,5,6,7,0,1,2]**
+### **target: 3**
+### **Output:-1**
+
+# **Solution:**
+To find the target element .in log(N) time.We have to use a Binary search function.But it only works on
+Sorted array. Because our list is rotated , it is not sorted anymore.
+So we have to make a slight change in binary search function.
+## **Changes in Code snippet**
+```angular2html
+            if nums[mid] == target:
+                return mid
+            elif nums[low] > nums[mid]://Reassign the variables if the array is not sorted
+                if nums[mid] < target and nums[high] >= target:
+                    low = mid + 1
+                else:
+                    high = mid - 1
+            elif nums[low] <= nums[mid]:
+                if nums[low] <= target and nums[mid] > target:
+                    high = mid - 1
+                else:
+                    low = mid + 1
+
+```

1833/READme.md

@@ -0,0 +1,30 @@
+# 1833. Maximum Ice Cream Bars
+It is a sweltering summer day, and a boy wants to buy some ice cream bars.
+
+At the store, there are n ice cream bars. You are given an array costs of length n, where costs[i] is the price of the ith ice cream bar in coins. The boy initially has coins coins to spend, and he wants to buy as many ice cream bars as possible. 
+
+Return the maximum number of ice cream bars the boy can buy with coins coins.
+
+Note: The boy can buy the ice cream bars in any order.
+
+ 
+### Examples:
+
+Example 1:
+
+Input: costs = [1,3,2,4,1], coins = 7
+Output: 4
+Explanation: The boy can buy ice cream bars at indices 0,1,2,4 for a total price of 1 + 3 + 2 + 1 = 7.
+Example 2:
+
+Input: costs = [10,6,8,7,7,8], coins = 5
+Output: 0
+Explanation: The boy cannot afford any of the ice cream bars.
+Example 3:
+
+Input: costs = [1,6,3,1,2,5], coins = 20
+Output: 6
+Explanation: The boy can buy all the ice cream bars for a total price of 1 + 6 + 3 + 1 + 2 + 5 = 18.
+
+
+Question Link: https://leetcode.com/problems/maximum-ice-cream-bars/

1833/maxiumIceCreamBars.py

@@ -0,0 +1,11 @@
+class Solution:
+    def maxIceCream(self, costs: list[int], coins: int) -> int:
+        costs.sort()
+        total = 0
+        for c in costs:
+            if coins < c:
+                break
+            coins -= c
+            total += 1
+
+        return total

374/README.md

@@ -0,0 +1,14 @@
+## Guess Number Higher or Lower
+
+We are playing the Guess Game. The game is as follows:
+
+I pick a number from 1 to n. You have to guess which number I picked.
+
+Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.
+
+You call a pre-defined API int guess(int num), which returns 3 possible results:
+
+-1: The number I picked is lower than your guess (i.e. pick < num).
+1: The number I picked is higher than your guess (i.e. pick > num).
+0: The number I picked is equal to your guess (i.e. pick == num).
+Return the number that I picked.

374/guessNumberHigherOrLower.py

@@ -0,0 +1,37 @@
+# The guess API is already defined for you.
+# @param num, your guess
+# @return -1 if my number is lower,
+# 1 if my number is higher, otherwise return 0
+
+# this function is just added to pass the flake8 code linter
+# delete this function definition while using it on leetcode
+def guess(num: int) -> int:
+    pass
+
+
+class Solution:
+    def guessNumber(self, n: int) -> int:
+        # here start = 1 ans end = n
+        # I supply mid as my pick and check with the original pick
+        # if pick is not right, update start or end accodingly
+
+        start = 1
+        end = n
+        while start <= end:
+
+            mid = start + (end - start) // 2
+            x = guess(mid)
+
+            if x == 0:
+                # element is found
+                return mid
+
+            elif x == -1:
+
+                # guessed element is greater than actual element
+                # search in the left of mid
+                end = mid - 1
+            else:
+                # guessed element is less than actual element
+                # search in the right of mid
+                start = mid + 1

704/REAMDE.md

@@ -0,0 +1,16 @@
+## Binary Search
+
+Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.
+
+You must write an algorithm with O(log n) runtime complexity.
+
+### Example 1:
+Input: nums = [-1,0,3,5,9,12], target = 9
+Output: 4
+
+### Example 2:
+Input: nums = [-1,0,3,5,9,12], target = 2
+Output: -1
+
+Question link : [Binary Search](https://leetcode.com/problems/binary-search/)
+

704/binarySearch.py

@@ -0,0 +1,16 @@
+class Solution:
+    def search(self, arr, target: int) -> int:
+        # simple Binary Search Algorithm
+
+        start = 0
+        end = len(arr) - 1
+
+        while start <= end:
+            mid = start + (end - start) // 2
+            if arr[mid] == target:
+                return mid
+            elif target < arr[mid]:
+                end = mid - 1
+            else:
+                start = mid + 1
+        return -1