2315. Statistical star number

Thought：

mine：The simple version of the simple out of the stack into the stack
@ylq：right|Number count，The number is2Perform the multiple*Count

Code：

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution:
    def countAsterisks(self, s: str) -> int:
        stack = True
        flag = 0
        for i in s:
            if stack:
                if i == '*':
                    flag += 1
            if i == '|' and stack:
                stack = False
            elif i == '|' and not stack:
                stack = True
        return flag

1
2
3
4
5
6
7
8
9

class Solution:
    def countAsterisks(self, s: str) -> int:
        count1, count2 = 0, 0
        for i in range(len(s)):
            if s[i] == '|':
                count1 += 1
            if count1 % 2 == 0 and s[i] == '*':
                count2 += 1
        return count2

2309. The best English letters with both appropriates and lowercases

Thought：

1. Hash table：The first thing to think of the question is to solve it with a dictionary。But find that you can directly traverse the alphabet，fromZStart looking for，See if the applause exists，Just return directly。
   

Running time exceeds99.9%
2. Bit operation：We can use two integers mask1 and mask2 Record string separately s 中出现的小写字母and大写字母，in mask1 First i
Position representation i Does a lowercase letter appear，and mask2 First i Position representation i Whether an uppercase letter appears。

Then we will mask1 and mask2 Perform and calculate，The results obtained mask First i Position representation i Whether the lethals of the letter appear at the same time。

As long as you get mask The highest level of binary representation 1 s position，Convert it to the corresponding capital letter。If all binary positions are not 1，Explain that there is no letter that appears at the same time,，Return to an empty string。

author：ylb
Link：https://leetcode.cn/problems/greatest-english-letter-in-upper-and-lower-case/solutions/2077636/by-lcbin-zbg0/
source：Deduction（LeetCode）
著作权归author所有。商业转载请联系author获得授权，Non -commercial reprint Please indicate the source。

Code：

1
2
3
4
5
6

class Solution:
    def greatestLetter(self, s: str) -> str:
        for i in range(90, 64, -1):
            if chr(i) in s and chr(i+32) in s:
                return chr(i)
        return ""

1
2
3
4
5
6
7
8
9
10
11
12

class Solution {
public:
    string greatestLetter(string s) {
        unordered_set<char> strin(s.begin(),s.end());
        for(char c = 'Z'; c >= 'A'; --c){
            if(strin.count(c) && strin.count(char(c+32))){
                return string(1,c);
            }
        }
        return "";
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution:
    def greatestLetter(self, s: str) -> str:
        # We can use two integers mask1 and mask2
        # Record string separately s 中出现的小写字母and大写字母，in mask1 First i Position representation i Does a lowercase letter appear，
            # and mask2 First i Position representation i Whether an uppercase letter appears。
        mask1 = mask2 = 0
        for i in s:
            if i.islower():
                mask1 |= 1 << (ord(i) - ord("a"))
            else:
                mask2 |= 1 << (ord(i) - ord("A"))
        mask = mask1 & mask2
        return chr(mask.bit_length() - 1 + ord("A")) if mask else ""

topic：

2319. Determine whether the matrix is ​​one X matrix

Thought：

GolangPure violence，PythonLearn Spirit God
The downward bidding on the main diagonal needs to be satisfied：i=j
Opposition to the corner line is satisfied：i+j=n−1

Code：

1
2
3
4
5

class Solution:
    def checkXMatrix(self, grid: List[List[int]]) -> bool:
        return all(
            (v != 0) == (i == j or i + j == len(grid) - 1) for i, row in enumerate(grid) for j, v in enumerate(row))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func checkXMatrix(grid [][]int) bool {
    for i := 0; i < len(grid); i++ {
        for j := 0; j < len(grid[i]); j++ {
		//Two numbers in the first line
			if (i == j) || (i+j == len(grid)-1) {
				if grid[i][j] == 0 {
					return false
				}
			} else if grid[i][j] != 0 {
				return false
			}
		}
	}
	return true
}

2325. Decrypt

Thought：

Simple hash mapping table，pythonUse ascii_lowercase[] Directly obtain a lowercase letter。
Golang Look at the answer of Lingshen，

“Imam on the space to the space，In this way, you don’t need to judge the space。”

Code：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

from string import ascii_lowercase

class Solution:
    def decodeMessage(self, key: str, message: str) -> str:
        str1 = ''
        dict1 = {}
        index = 0
        for i in key.replace(' ', ''):
            if i not in dict1:
                dict1[i] = ascii_lowercase[index]
                index += 1
        for i in message:
            if i in dict1:
                str1 += dict1[i]
            else:
                str1 += ' '
        return str1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

func decodeMessage(key string, message string) string {
	mp := ['z' + 1]byte{' ': ' '}
	cur := byte('a')
	for _, c := range key {
		if mp[c] == 0 {
			mp[c] = cur
			cur += 1
		}
	}
	s := []byte(message)
	for i, c := range s {
		s[i] = mp[c]
	}
	return string(s)
}

topic：

2331Calculate the value of the Boolean binary tree

Thought：

For the currentroot，in the case ofleaf root（That is, the left node is empty），Then judge the current Boolean value（The leaf node must be Boolean instead of judging）。
Otherwise，Until traversing the leaf node，After seeing the left and right children of a sub -tree，Judge the current Valtype，Finally seekingValValue。
ifValNot the root node，butValChildren’s nodes as other trees return to the previous layer。

Code：

1
2
3
4
5
6
7

class Solution:
    def evaluateTree(self, root: Optional[TreeNode]) -> bool:
        if root.left is None:
            return bool(root.val)
        l = self.evaluateTree(root.left)
        r = self.evaluateTree(root.right)
        return l or r if root.val == 2 else l and r

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func evaluateTree(root *TreeNode) bool {
	if root.Left == nil {
		return root.Val == 1
	}
	l, r := evaluateTree(root.Left), evaluateTree(root.Right)
	if root.Val == 2 {
		return l || r
	}
	return l && r
}

topic：

2335. The shortest total time to be filled with a cup.md

Thought：

1. This question is very simple，但是我好像没用贪心的Thought。Look at the second test case and find it found，In fact, the minimum number of seconds is to avoid a certain number as much as possible0。
   So keep sorting，Always operate the two largest numbers。This sending can also be used for DoriamountCase，But because of sorting，I don’t know if it can be used for a large number。
   Look atylbBig，和我一样但是Big细节处理得很好，Two fewer judgments than me，Then it seems that the classification discussion method below may be a solution to the difficult situation。
2. mathematical method？Sort the number of drinks from small to large，Set the quantity x，y，z。Our goal is to match the different drinks as much as possible。
   like$x+y<=z$，The answer isz。like反之，Then set$t=(x+y-z)$，t是偶数The answer is
   $ \frac{t−1}{2} +z$Plus one

Code：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution:
    def fillCups(self, amount: List[int]) -> int:
        amount.sort()
        count = 0
        # Try to avoid returning0
        while amount[-1] > 0:
            if amount[-1] > 0 and amount[1] > 0:
                amount[-1] -= 1
                amount[1] -= 1
                count += 1
            if amount[-1] > 0 and amount[1] == 0:
                return count + amount[-1]
            amount.sort()
        return count

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import "sort"

func fillCups(amount []int) int {
	ans := 0
	for amount[0] + amount[1] + amount[2] > 0 {
		sort.Ints(amount)
		ans ++
		amount[2] --
		if amount[1] > 0{
			amount[1] --
		}
	}
	return ans
}

topic：

2341. How much can the array be formed.md

Thought：

I am：

I don’t know if I saw it“Simple”Two words，This question has the initiative to think about the optimal solution。Actually this timeylbBig guy’s hash table method is still fast。
Sort the list，Whether two or two are equal to whether。

Hash tableThought：

CounterAfter counting，a+=v//2,b+=v%2For each number x，
if x Number of times v more than the 1，You can choose two from the array x Form a number pair，we willv Divide 2 Take down，
You can get the current number x Number pairs that can be formed，Then we accumulate this number to the variable s middle。

Code：

1
2
3
4
5
6
7
8
9
10

class Solution:
    def numberOfPairs(self, nums: List[int]) -> List[int]:
        nums.sort()
        ans = [0, len(nums)]
        for index in range(1, len(nums)):
            if nums[index - 1] == nums[index]:
                ans[0] += 1
                ans[1] -= 2
                nums[index - 1] = nums[index] = -1
        return ans

1
2
3
4
5
6
7
8
9

class Solution:
    def numberOfPairs(self, nums: List[int]) -> List[int]:
        x = Counter(nums)
        a = 0
        b = 0
        for k,v in x.items():
            a+=v//2
            b+=v%2
        return [a,b]

topic：

Give you a linked list，Two or two exchanges are adjacent nodes，And return to the head node of the linked list after exchange。You must complete this question without modifying the internal value of the node（Right now，Can only exchange nodes）。

Exemplary example 1：

enter：head = [1,2,3,4]
Output：[2,1,4,3]

Exemplary example 2：

enter：head = []
Output：[]

Exemplary example 3：

enter：head = [1]
Output：[1]

hint：

• The number of nodes in the linked list is in the range [0, 100] Inside
• 0 <= Node.val <= 100

24.Two or two exchanges linked watches.md

Thought：

use head 表示原始Linked的头节点，新的Linked的第二个节点，use newHead 表示新的Linked的头节点，原始Linked的第二个节点，则原始Linked中的其余节点的头节点是 newHead.next。make head.next = swapPairs(newHead.next)，Indicates two or two exchanges for the rest of the nodes，The new head node after the exchange is head The next node。然后make newHead.next = head，Right now完成了所有节点的交换。最后返回新的Linked的头节点 newHead。

Code：

1
2
3
4
5
6
7
8

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head
        virtual_head = head.next
        head.next = self.swapPairs(virtual_head.next)
        virtual_head.next = head
        return virtual_head

1
2
3
4
5
6
7
8
9
10
11
12

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr or head->next == nullptr){
            return head;
        }
        ListNode *yummyNode = head->next;
        head->next = swapPairs(yummyNode->next);
        yummyNode->next = head;
        return yummyNode;
    }
};

6289.Query array Xor Beautiful value。

This question has been studied for a long time，Discovering a mathematical problem，But I didn’t want to be transparent，Because unfamiliar or valuable。So there is no better solution。

The first is to read the question and learn(nums[i]|nums[j])&nums[k]，becauseijkCan be any value in the array，So the tripleforcycle（It will definitely timeout），Then he was a little bit out of his own，Just a little bit，feeli，jThe value of the value is the same，So add an additional layer of judgment（Dictionary）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution:
    def xorBeauty(self, nums: List[int]) -> int:
        ans = []
        record = {}
        for i in range(len(nums)):
            for j in range(len(nums)):
                for k in range(len(nums)):
                    if k not in record:
                        if (i,j) not in record.values():
                            record[k] = (i,j)
                            flag = (nums[i]|nums[j])&nums[k]
                            if flag not in ans:
                                ans.append(flag)
                            else:
                                ans.remove(flag)
        if len(ans) == 0:
            return 0
        answer = ans[0]

        for i in range(1,len(ans)):
            answer ^= ans[i]
        return answer

I have been thinking about how to judge the same situation when I go out today，As a result@Lingcha Mountain AifuSolution，One by one，That’s okay。

1
2
3
4

class Solution:
    def xorBeauty(self, nums: List[int]) -> int:
        return reduce(xor, nums)

Then do，Search online，It turns out that if the two values ​​are the same，for exampleA^B^A = B，Soappend，removeTo implement this function。at lastforcycle求异或值。

Big Big Code is still studyinging

topic：

2679.In the matrix and the harmony.md

Thought：

One -line
First of all, the meaning is to find the largest number of each sub -list，Thenpopgo out，Finally ask for peace。
The effect of traversing again and again is too bad，So I thought of using itzip一次性Traversal多个子Array。
于yes先对每个子ArraySort，Then usezipTraversal，Find the maximum。
for example：
nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Sort后：
nums = [[1,2,7],[2,4,6],[3,5,6],[1,2,3]]
Then usezipTraversal得到：
[(1,2,3,1),(2,4,5,2),(7,6,6,3)]
Find the maximum：
[3,5,7]
Context：
15

Code：

1
2
3
4

class Solution:
    def matrixSum(self, nums: List[List[int]]) -> int:
        return sum(max(i) for i in \
        zip(*(sorted(sublist) for sublist in nums)))

*The role and the rolezip()explain

1
2
3
4
5
6
7
8
9
10

nums = [[1,2,7],[2,4,6],[3,5,6],[1,2,3]]

for i in range(len(nums[1])):
    for j in range(len(nums)):
        print(nums[j][i])
# ans = 123124527663
num1 = [1,2,7]
num2 = [2,4,6]
num3 = [3,5,6]
num4 = [1,2,3]

zip()The function corresponds to one -to -one elements in multiple lists，Then return onezipObject，Can uselist()Function convert to list。

1
2
3
4
5

for i in zip(num1, num2, num3, num4):
    print(i)
#(1, 2, 3, 1)
#(2, 4, 5, 2)
#(7, 6, 6, 3)

*numsThe role ispythonNot a pointer，InsteadnumsEach element in the parameter is passed into the function。I understand here as a list。

1
2
3
4

# Enumerate
print(*nums)
# [1, 2, 7] [2, 4, 6] [3, 5, 6] [1, 2, 3]

zip(*nums)WillnumsEach element is passed in as a parameterzip()In the function，Then return onezipObject，Can uselist()Function convert to list。
zip(*nums)Equivalent tozip(num1, num2, num3, num4)，innum1, num2, num3, num4yesnumsElement。

1
2
3
4
5
6

for i in zip(*nums):
    print(i)
# Equivalent
#(1, 2, 3, 1)
#(2, 4, 5, 2)
#(7, 6, 6, 3)