D. J.:

- Added the leetcode problem and solution for 6, 12, 13, 14, 28, 42, 58, 68, 134, 135, 151, 238, 274 and 380

Author: nobodyPerfecZ

README.md

@@ -26,19 +26,27 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 
 - [1 Two Sum](https://leetcode.com/problems/two-sum/description/)
 - [2 Add Two Numbers](https://leetcode.com/problems/add-two-numbers/description/)
+- [6 Zigzag Conversion](https://leetcode.com/problems/zigzag-conversion/description/)
+- [12 Integer to Roman](https://leetcode.com/problems/integer-to-roman/description/)
+- [13 Roman to Integer](https://leetcode.com/problems/roman-to-integer/description/)
+- [14 Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/description/)
 - [19 Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
 - [20 Valid Parentheses](https://leetcode.com/problems/valid-parentheses/description/)
 - [21 Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/description/)
 - [25 Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/description/)
 - [26 Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/)
 - [27 Remove Element](https://leetcode.com/problems/remove-element/description/)
+- [28 Find the Index of the First Occurrence in a String](https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/description/)
+- [42 Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/description/)
 - [45 Jump Game II](https://leetcode.com/problems/jump-game-ii/description/)
 - [49 Group Anagrams](https://leetcode.com/problems/group-anagrams/description/)
 - [55 Jump Game](https://leetcode.com/problems/jump-game/description/)
+- [58 Length of Last Word](https://leetcode.com/problems/length-of-last-word/description/)
 - [56 Merge Intervals](https://leetcode.com/problems/merge-intervals/description/)
 - [57 Insert Interval](https://leetcode.com/problems/insert-interval/description/)
 - [61 Rotate List](https://leetcode.com/problems/rotate-list/description/)
 - [67 Add Binary](https://leetcode.com/problems/add-binary/description/)
+- [68 Text Justification](https://leetcode.com/problems/text-justification/description/)
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
 - [80 Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/)
 - [82 Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/description/)
@@ -65,12 +73,15 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [129 Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/description/)
 - [130 Surrounded Regions](https://leetcode.com/problems/surrounded-regions/description/)
 - [133 Clone Graph](https://leetcode.com/problems/clone-graph/description/)
+- [134 Gas Station](https://leetcode.com/problems/gas-station/description/)
+- [135 Candy](https://leetcode.com/problems/candy/description/)
 - [136 Single Number](https://leetcode.com/problems/single-number/description/)
 - [137 Single Number II](https://leetcode.com/problems/single-number-ii/description/)
 - [138 Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/description/)
 - [141 Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/)
 - [146 LRU Cache](https://leetcode.com/problems/lru-cache/description/)
 - [150 Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/description/)
+- [151 Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/description/)
 - [155 Min Stack](https://leetcode.com/problems/min-stack/description/)
 - [169 Majority Element](https://leetcode.com/problems/majority-element/description/)
 - [173 Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/description/)
@@ -92,8 +103,11 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [228 Summary Ranges](https://leetcode.com/problems/summary-ranges/description/)
 - [230 Kth Smallest Element in a BST](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
 - [236 Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+- [238 Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/description/)
 - [242 Valid Anagram](https://leetcode.com/problems/valid-anagram/description/)
+- [274 H-Index](https://leetcode.com/problems/h-index/description/)
 - [290 Word Pattern](https://leetcode.com/problems/word-pattern/description/)
+- [380 Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/description/)
 - [383 Ransom Note](https://leetcode.com/problems/ransom-note/description/)
 - [392 Is Subsequence](https://leetcode.com/problems/is-subsequence/description/)
 - [399 Evaluate Division](https://leetcode.com/problems/evaluate-division/description/)

awesome_python_leetcode/_12_integer_to_roman.py

@@ -0,0 +1,55 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def intToRoman(self, num: int) -> str:
+        """
+        Seven different symbols represent Roman numerals with the following values:
+
+        Symbol	Value
+        I	1
+        V	5
+        X	10
+        L	50
+        C	100
+        D	500
+        M	1000
+
+        Roman numerals are formed by appending the conversions of decimal place values
+        from highest to lowest. Converting a decimal place value into a Roman numeral
+        has the following rules:
+        - If the value does not start with 4 or 9, select the symbol of the maximal
+        value that can be subtracted from the input, append that symbol to the result,
+        subtract its value, and convert the remainder to a Roman numeral.
+        - If the value starts with 4 or 9 use the subtractive form representing one
+        symbol subtracted from the following symbol, for example, 4 is 1 (I) less than
+        5 (V): IV and 9 is 1 (I) less than 10 (X): IX. Only the following subtractive
+        forms are used: 4 (IV), 9 (IX), 40 (XL), 90 (XC), 400 (CD) and 900 (CM).
+        - Only powers of 10 (I, X, C, M) can be appended consecutively at most 3 times
+        to represent multiples of 10. You cannot append 5 (V), 50 (L), or 500 (D)
+        multiple times. If you need to append a symbol 4 times use the subtractive form.
+
+        Given an integer, convert it to a Roman numeral.
+        """
+        itr = {
+            1: "I",
+            4: "IV",
+            5: "V",
+            9: "IX",
+            10: "X",
+            40: "XL",
+            50: "L",
+            90: "XC",
+            100: "C",
+            400: "CD",
+            500: "D",
+            900: "CM",
+            1000: "M",
+        }
+        roman = ""
+        for key in reversed(itr):
+            num_symbols = num // key
+            if num_symbols == 0:
+                continue
+            roman += num_symbols * itr[key]
+            num = num - num_symbols * key
+        return roman

awesome_python_leetcode/_134_gas_station.py

@@ -0,0 +1,30 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
+        """
+        There are n gas stations along a circular route, where the amount of gas at the
+        ith station is gas[i].
+
+        You have a car with an unlimited gas tank and it costs cost[i] of gas to travel
+        from the ith station to its next (i + 1)th station. You begin the journey with
+        an empty tank at one of the gas stations.
+
+        Given two integer arrays gas and cost, return the starting gas station's index
+        if you can travel around the circuit once in the clockwise direction, otherwise
+        return -1. If there exists a solution, it is guaranteed to be unique.
+        """
+        if sum(gas) < sum(cost):
+            return -1
+
+        res = 0
+        total = 0
+        for i in range(len(gas)):
+            total += gas[i] - cost[i]
+            if total < 0:
+                total = 0
+                res = i + 1
+        return res

awesome_python_leetcode/_135_candy.py

@@ -0,0 +1,30 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def candy(self, ratings: List[int]) -> int:
+        """
+        There are n children standing in a line. Each child is assigned a rating value
+        given in the integer array ratings.
+
+        You are giving candies to these children subjected to the following
+        requirements:
+        - Each child must have at least one candy.
+        - Children with a higher rating get more candies than their neighbors.
+        - Return the minimum number of candies you need to have to distribute the
+        candies to the children.
+        """
+        candy = [1 for i in range(len(ratings))]
+
+        # From left to right
+        for i in range(1, len(ratings)):
+            if ratings[i] > ratings[i - 1]:
+                candy[i] = max(candy[i], candy[i - 1]) + 1
+
+        # From right to left
+        for i in range(len(ratings) - 2, -1, -1):
+            if ratings[i] > ratings[i + 1] and candy[i] <= candy[i + 1]:
+                candy[i] = max(candy[i], candy[i + 1]) + 1
+        return sum(candy)

awesome_python_leetcode/_13_roman_to_integer.py

@@ -0,0 +1,58 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def romanToInt(self, s: str) -> int:
+        """
+        Roman numerals are represented by seven different symbols: I, V, X, L, C, D
+        and M.
+
+        Symbol       Value
+        I             1
+        V             5
+        X             10
+        L             50
+        C             100
+        D             500
+        M             1000
+
+        For example, 2 is written as II in Roman numeral, just two ones added together.
+        12 is written as XII, which is simply X + II. The number 27 is written as
+        XXVII, which is XX + V + II.
+
+        Roman numerals are usually written largest to smallest from left to right.
+        However, the numeral for four is not IIII. Instead, the number four is written
+        as IV. Because the one is before the five we subtract it making four. The same
+        principle applies to the number nine, which is written as IX. There are six
+        instances where subtraction is used:
+        - I can be placed before V (5) and X (10) to make 4 and 9.
+        - X can be placed before L (50) and C (100) to make 40 and 90.
+        - C can be placed before D (500) and M (1000) to make 400 and 900.
+
+        Given a roman numeral, convert it to an integer.
+        """
+        rti = {
+            "I": 1,
+            "V": 5,
+            "X": 10,
+            "L": 50,
+            "C": 100,
+            "D": 500,
+            "M": 1000,
+        }
+        before, total = None, 0
+        for r in reversed(s):
+            if not before:
+                total += rti[r]
+            elif (before, r) in [
+                ("V", "I"),
+                ("X", "I"),
+                ("L", "X"),
+                ("C", "X"),
+                ("D", "C"),
+                ("M", "C"),
+            ]:
+                total -= rti[r]
+            else:
+                total += rti[r]
+            before = r
+        return total

awesome_python_leetcode/_14_longest_common_prefix.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        """
+        Write a function to find the longest common prefix string amongst an array of
+        strings.
+
+        If there is no common prefix, return an empty string "".
+        """
+        prefix = ""
+        for i, c in enumerate(strs[0]):
+            for s in strs:
+                if i >= len(s) or s[i] != c:
+                    return prefix
+            prefix += c
+        return prefix

awesome_python_leetcode/_151_reverse_words_in_a_string.py

@@ -0,0 +1,17 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def reverseWords(self, s: str) -> str:
+        """
+        Given an input string s, reverse the order of the words.
+
+        A word is defined as a sequence of non-space characters. The words in s will be
+        separated by at least one space.
+
+        Return a string of the words in reverse order concatenated by a single space.
+
+        Note that s may contain leading or trailing spaces or multiple spaces between
+        two words. The returned string should only have a single space separating the
+        words. Do not include any extra spaces.
+        """
+        return " ".join(reversed(s.split()))

awesome_python_leetcode/_238_product_of_array_except_self.py

@@ -0,0 +1,29 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        """
+        Given an integer array nums, return an array answer such that answer[i] is
+        equal to the product of all the elements of nums except nums[i].
+
+        The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit
+        integer.
+
+        You must write an algorithm that runs in O(n) time and without using the
+        division operation.
+        """
+        result = []
+        prefix = 1
+        for i in range(len(nums)):
+            result.append(prefix)
+            prefix *= nums[i]
+
+        suffix = 1
+        for i in range(len(nums) - 1, -1, -1):
+            result[i] *= suffix
+            suffix *= nums[i]
+
+        return result

awesome_python_leetcode/_274_h_index.py

@@ -0,0 +1,30 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def hIndex(self, citations: List[int]) -> int:
+        """
+        Given an array of integers citations where citations[i] is the number of
+        citations a researcher received for their ith paper, return the researcher's
+        h-index.
+
+        According to the definition of h-index on Wikipedia: The h-index is defined as
+        the maximum value of h such that the given researcher has published at least h
+        papers that have each been cited at least h times.
+        """
+        # Sort citations by number of papers
+        n = len(citations)
+        count = collections.defaultdict(int)
+        for i, val in enumerate(citations):
+            index = min(val, n)
+            count[index] += 1
+
+        # Find index h that have at least h paper with more than h citations
+        num_paper = 0
+        for h_index in range(n, -1, -1):
+            num_paper += count[h_index]
+            if num_paper >= h_index:
+                return h_index

awesome_python_leetcode/_28_find_the_index_of_the_first_occurrence_in_a_string.py

@@ -0,0 +1,9 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def strStr(self, haystack: str, needle: str) -> int:
+        """
+        Given two strings needle and haystack, return the index of the first occurrence
+        of needle in haystack, or -1 if needle is not part of haystack.
+        """
+        return haystack.find(needle)