do some easy letcode

Author: Octoberr

.idea/workspace.xml

@@ -0,0 +1,61 @@
+"""
+A robot on an infinite grid starts at point (0, 0) and faces north.  The robot can receive one of three possible types of commands:
+
+-2: turn left 90 degrees
+-1: turn right 90 degrees
+1 <= x <= 9: move forward x units
+Some of the grid squares are obstacles.
+
+The i-th obstacle is at grid point (obstacles[i][0], obstacles[i][1])
+
+If the robot would try to move onto them, the robot stays on the previous grid square instead (but still continues following the rest of the route.)
+
+Return the square of the maximum Euclidean distance that the robot will be from the origin.
+
+
+
+Example 1:
+
+Input: commands = [4,-1,3], obstacles = []
+Output: 25
+Explanation: robot will go to (3, 4)
+Example 2:
+
+Input: commands = [4,-1,4,-2,4], obstacles = [[2,4]]
+Output: 65
+Explanation: robot will be stuck at (1, 4) before turning left and going to (1, 8)
+
+
+solution:
+start at position x, y = 0, 0 and direction dx, dy = 0, 1
+loop over commands
+if command == -2, (dx, dy) -> (-dy, dx) ccw rotate 90 degree
+if command == -1, (dx, dy) -> (dy, -dx) cw rotate 90 degree
+if command 1-9, repeat given steps of x += dx, y += dy if not in obstacle, otherwise stop
+"""
+
+
+class Solution:
+    def robotSim(self, commands, obstacles) -> int:
+        x, y, dx, dy = 0, 0, 0, 1  # position & direction
+        obstacles = set(map(tuple, obstacles))
+        dis2 = 0
+
+        for command in commands:
+            if command == -2: dx, dy = -dy, dx  # ccw (left)
+            if command == -1: dx, dy = dy, -dx  # cw (right)
+            if 1 <= command <= 9:
+                for _ in range(command):
+                    if (x + dx, y + dy) in obstacles: break
+                    x += dx
+                    y += dy
+                dis2 = max(dis2, x ** 2 + y ** 2)
+        return dis2
+
+
+if __name__ == '__main__':
+    s = Solution()
+    commands = [4, -1, 4, -2, 4]
+    obstacles = [[2, 4]]
+    res = s.robotSim(commands, obstacles)
+

easy/874walking_robot_simulation.py

@@ -0,0 +1,44 @@
+"""
+On a N * N grid, we place some 1 * 1 * 1 cubes that are axis-aligned with the x, y, and z axes.
+
+Each value v = grid[i][j] represents a tower of v cubes placed on top of grid cell (i, j).
+
+Now we view the projection of these cubes onto the xy, yz, and zx planes.
+
+A projection is like a shadow, that maps our 3 dimensional figure to a 2 dimensional plane.
+
+Here, we are viewing the "shadow" when looking at the cubes from the top, the front, and the side.
+
+Return the total area of all three projections.
+
+Input: [[1,0],[0,2]]
+Output: 8
+Example 4:
+
+Input: [[1,1,1],[1,0,1],[1,1,1]]
+Output: 14
+Example 5:
+
+Input: [[2,2,2],[2,1,2],[2,2,2]]
+Output: 21
+"""
+
+
+class Solution:
+    def projectionArea(self, grid) -> int:
+        ans = 0
+        for cubes in grid:
+            ans += len(cubes) - cubes.count(0)  # 'projection onto xy plane'
+            ans += max(cubes)  # 'projection onto yz plane'
+        zipped = zip(*list(grid))
+        ys = list(zipped)
+        for tup in ys:
+            ans += max(tup)  # 'projection onto xz plane'
+        return ans
+
+
+if __name__ == '__main__':
+    s = Solution()
+    a = [[2, 2, 2], [2, 1, 2], [2, 2, 2]]
+    res = s.projectionArea(a)
+    print(res)

easy/883projection_area_of_3d_shapes.py

@@ -0,0 +1,46 @@
+"""
+We are given two sentences A and B.  (A sentence is a string of space separated words.  Each word consists only of lowercase letters.)
+
+A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence.
+
+Return a list of all uncommon words.
+
+You may return the list in any order.
+
+
+
+Example 1:
+
+Input: A = "this apple is sweet", B = "this apple is sour"
+Output: ["sweet","sour"]
+Example 2:
+
+Input: A = "apple apple", B = "banana"
+Output: ["banana"]
+
+使用集合解决
+^对称差集
+A, B = A.split(), B.split()
+return (set(A) ^ set(B)) - set(a for a in A if A.count(a) > 1) - set(b for b in B if B.count(b) > 1)
+"""
+
+
+class Solution:
+    def uncommonFromSentences(self, A: str, B: str):
+        a = {}
+        allstr = A + ' ' + B
+        aslist = allstr.split(' ')
+        for el in aslist:
+            if a.__contains__(el):
+                a[el] += 1
+                continue
+            a[el] = 1
+
+        reslist = [k for k, v in a.items() if v == 1]
+        return reslist
+if __name__ == '__main__':
+    s = Solution()
+    A = "apple apple"
+    B = "banana"
+    res = s.uncommonFromSentences(A, B)
+    print(res)

easy/884uncommon_words_from_two_sentences.py

@@ -0,0 +1,54 @@
+"""
+Alice and Bob have candy bars of different sizes: A[i] is the size of the i-th bar of candy that Alice has, and B[j] is the size of the j-th bar of candy that Bob has.
+
+Since they are friends, they would like to exchange one candy bar each so that after the exchange, they both have the same total amount of candy.  (The total amount of candy a person has is the sum of the sizes of candy bars they have.)
+
+Return an integer array ans where ans[0] is the size of the candy bar that Alice must exchange, and ans[1] is the size of the candy bar that Bob must exchange.
+
+If there are multiple answers, you may return any one of them.  It is guaranteed an answer exists.
+
+
+
+Example 1:
+
+Input: A = [1,1], B = [2,2]
+Output: [1,2]
+Example 2:
+
+Input: A = [1,2], B = [2,3]
+Output: [1,2]
+Example 3:
+
+Input: A = [2], B = [1,3]
+Output: [2,3]
+Example 4:
+
+Input: A = [1,2,5], B = [2,4]
+Output: [5,4]
+
+after swap:
+sum1 + temp - one == sum2 - temp + one
+so :
+temp = (sum2+2*one-sum1 )//2
+牛P
+
+
+"""
+
+
+class Solution:
+    def fairCandySwap(self, A, B):
+        sum1, sum2 = sum(A), sum(B)
+        B = set(B)
+        for one in A:
+            temp = (sum2 + 2 * one - sum1) // 2
+            if temp in B:
+                return [one, temp]
+
+
+if __name__ == '__main__':
+    s = Solution()
+    A = [2]
+    B = [1, 3]
+    res = s.fairCandySwap(A, B)
+    print(res)

easy/888fair_candy_swap.py

@@ -0,0 +1,55 @@
+"""
+You are given an array A of strings.
+
+A move onto S consists of swapping any two even indexed characters of S, or any two odd indexed characters of S.
+
+Two strings S and T are special-equivalent if after any number of moves onto S, S == T.
+
+For example, S = "zzxy" and T = "xyzz" are special-equivalent because we may make the moves "zzxy" -> "xzzy" -> "xyzz" that swap S[0] and S[2], then S[1] and S[3].
+
+Now, a group of special-equivalent strings from A is a non-empty subset of A such that:
+
+Every pair of strings in the group are special equivalent, and;
+The group is the largest size possible (ie., there isn't a string S not in the group such that S is special equivalent to every string in the group)
+Return the number of groups of special-equivalent strings from A.
+
+
+Example 1:
+
+Input: ["abcd","cdab","cbad","xyzz","zzxy","zzyx"]
+Output: 3
+Explanation:
+One group is ["abcd", "cdab", "cbad"], since they are all pairwise special equivalent, and none of the other strings are all pairwise special equivalent to these.
+
+The other two groups are ["xyzz", "zzxy"] and ["zzyx"].  Note that in particular, "zzxy" is not special equivalent to "zzyx".
+Example 2:
+
+Input: ["abc","acb","bac","bca","cab","cba"]
+Output: 3
+
+one line solution
+from collections import Counter
+
+class Solution:
+  def numSpecialEquivGroups(self, A: List[str]) -> int:
+    return len({tuple(tuple(sorted(Counter(S[j::2]).items())) for j in range(2)) for S in A})
+"""
+
+from collections import Counter
+
+
+class Solution:
+    def numSpecialEquivGroups(self, A) -> int:
+        s = set()
+        for S in A:
+            evens = tuple(sorted(Counter(S[0::2]).items()))
+            odds = tuple(sorted(Counter(S[1::2]).items()))
+            s.add((evens, odds))
+        return len(s)
+
+
+if __name__ == '__main__':
+    s = Solution()
+    a = ["abcd", "cdab", "cbad", "xyzz", "zzxy", "zzyx"]
+    res = s.numSpecialEquivGroups(a)
+    print(res)

easy/893groups_of_special_equivalent_strings.py

@@ -0,0 +1,55 @@
+"""
+An array is monotonic if it is either monotone increasing or monotone decreasing.
+
+An array A is monotone increasing if for all i <= j, A[i] <= A[j].  An array A is monotone decreasing if for all i <= j, A[i] >= A[j].
+
+Return true if and only if the given array A is monotonic.
+
+
+
+Example 1:
+
+Input: [1,2,2,3]
+Output: true
+Example 2:
+
+Input: [6,5,4,4]
+Output: true
+Example 3:
+
+Input: [1,3,2]
+Output: false
+Example 4:
+
+Input: [1,2,4,5]
+Output: true
+Example 5:
+
+Input: [1,1,1]
+Output: true
+
+正面排序
+然后反面排序
+牛P
+
+"""
+
+
+class Solution:
+    def isMonotonic(self, A) -> bool:
+        if sorted(A) == A:
+            return True
+
+        A.reverse()
+
+        if sorted(A) == A:
+            return True
+
+        return False
+
+
+if __name__ == '__main__':
+    s = Solution()
+    inputa = [6, 5, 4, 4]
+    res = s.isMonotonic(inputa)
+    print(res)