Problem URL: [Check if Two String Arrays are Equivalent](https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/?envType=daily-question&envId=2023-12-01)

Text:
Given two string arrays word1 and word2, return true if the two arrays represent the same string, and false otherwise.

A string is represented by an array if the array elements concatenated in order forms the string.

Example 1:
Input:
- word1 = ["ab", "c"]
- word2 = ["a", "bc"]

Output: true

Explanation:
- word1 represents string "ab" + "c" -> "abc"
- word2 represents string "a" + "bc" -> "abc"
- The strings are the same, so return true.

Example 2:
Input:
- word1 = ["a", "cb"]
- word2 = ["ab", "c"]

Output: false

Example 3:
Input:
- word1 = ["abc", "d", "defg"]
- word2 = ["abcddefg"]

Output: true

Constraints:
- 1 <= word1.length, word2.length <= 10^3
- 1 <= word1[i].length, word2[i].length <= 10^3
- 1 <= sum(word1[i].length), sum(word2[i].length) <= 10^3
- word1[i] and word2[i] consist of lowercase letters.

Today is a first day of https://adventofcode.com/2023/day/1, great opportunity to learn some new language. I will be solving it in Rust https://github.com/samoylenkodmitry/AdventOfCode_2023

#### Problem
We are given an array of strings words and a string chars. A string is considered "good" if it can be formed using characters from chars, with each character used only once. We need to find the sum of the lengths of all "good" strings in words.

#### Example 1
- Input:
- words = ["cat","bt","hat","tree"]
- chars = "atach"
- Output: 6
- Explanation: The "good" strings that can be formed are "cat" and "hat", so the answer is 3 + 3 = 6.

#### Example 2
- Input:
- words = ["hello","world","leetcode"]
- chars = "welldonehoneyr"
- Output: 10
- Explanation: The "good" strings that can be formed are "hello" and "world", so the answer is 5 + 5 = 10.

#### Constraints
- 1 <= words.length <= 1000
- 1 <= words[i].length, chars.length <= 100
- words[i] and chars consist of lowercase English letters.

#### Problem URL
[Problem URL](https://leetcode.com/problems/find-words-that-can-be-formed-by-characters/?envType=daily-question&amp;envId=2023-12-02)

#### Problem Description

On a 2D plane, there are n points with integer coordinates points[i] = [xi, yi]. Return the minimum time in seconds to visit all the points in the order given by points.

You can move according to these rules:
- In 1 second, you can either:
- move vertically by one unit,
- move horizontally by one unit, or
- move diagonally sqrt(2) units (in other words, move one unit vertically then one unit horizontally in 1 second).

You have to visit the points in the same order as they appear in the array. You are allowed to pass through points that appear later in the order, but these do not count as visits.

#### Example 1:
Input: points = [[1,1],[3,4],[-1,0]]
Output: 7
Explanation: One optimal path is [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]
Time from [1,1] to [3,4] = 3 seconds
Time from [3,4] to [-1,0] = 4 seconds
Total time = 7 seconds

#### Constraints:

- 1 <= points.length <= 100
- points[i].length == 2
- -1000 <= points[i][0], points[i][1] <= 1000

Problem URL: [https://leetcode.com/problems/largest-3-same-digit-number-in-string/?envType=daily-question&amp;envId=2023-12-04](https://leetcode.com/problems/largest-3-same-digit-number-in-string/?envType=daily-question&amp;envId=2023-12-04)

Problem Statement

You are given a string num representing a large integer. An integer is good if it meets the following conditions:

- It is a substring of num with length 3.
- It consists of only one unique digit.

Return the maximum good integer as a string or an empty string "" if no such integer exists.

Note:
- A substring is a contiguous sequence of characters within a string.
- There may be leading zeroes in num or a good integer.

Example 1:

Input: num = "6777133339"
Output: "777"
Explanation: There are two distinct good integers: "777" and "333".
"777" is the largest, so we return "777".

Example 2:

Input: num = "2300019"
Output: "000"
Explanation: "000" is the only good integer.

Constraints:
- 3 <= num.length <= 1000
- num only consists of digits.

Problem url: [Count of Matches in Tournament](https://leetcode.com/problems/count-of-matches-in-tournament/?envType=daily-question&amp;envId=2023-12-05)
Text:
Given an integer n, the number of teams in a tournament. You need to return the number of matches played in the tournament until a winner is decided.

If the current number of teams is even, each team gets paired with another team. A total of n / 2 matches are played, and n / 2 teams advance to the next round.

If the current number of teams is odd, one team randomly advances in the tournament, and the rest gets paired. A total of (n - 1) / 2 matches are played, and (n - 1) / 2 + 1 teams advance to the next round.

Example 1:
Input: n = 7
Output: 6
Explanation:
- 1st Round: Teams = 7, Matches = 3, and 4 teams advance.
- 2nd Round: Teams = 4, Matches = 2, and 2 teams advance.
- 3rd Round: Teams = 2, Matches = 1, and 1 team is declared the winner.
Total number of matches = 3 + 2 + 1 = 6.

Constraints:
1 <= n <= 200

I am traveling, so here is a sunrise at 11 km, leetcode maybe later

I think this easy week is somehow related to ongoing AdventOfCode 😉

https://leetcode.com/problems/largest-odd-number-in-string/description/

Return the largest valued odd integer that is a non-empty substring of a given string num. If no odd integer exists, return an empty string.

https://leetcode.com/problems/construct-string-from-binary-tree/description/

606. Construct String from Binary Tree

Given the root of a binary tree, construct a string consisting of parenthesis and integers using the preorder traversal. Omit all unnecessary empty parenthesis pairs that do not affect the one-to-one mapping relationship between the string and the original binary tree.

Example 1:

Input: root = [1,2,3,4]
Output: "1(2(4))(3)"
Explanation: Originally, it needs to be "1(2(4)())(3()())", but you need to omit all the unnecessary empty parenthesis pairs. And it will be "1(2(4))(3)"

Example 2:

Input: root = [1,2,3,null,4]
Output: "1(2()(4))(3)"
Explanation: Almost the same as the first example, except we cannot omit the first parenthesis pair to break the one-to-one mapping relationship between the input and the output.

Constraints:

- The number of nodes in the tree is in the range [1, 104].
- Node.val is between -1000 and 1000.

https://leetcode.com/problems/binary-tree-inorder-traversal/description/

Binary Tree Inorder Traversal - Given the root of a binary tree, return the inorder traversal of its nodes' values.

https://leetcode.com/problems/transpose-matrix/description/

Transpose 2D matrix

https://leetcode.com/problems/element-appearing-more-than-25-in-sorted-array/description/

Most frequent element

https://leetcode.com/problems/maximum-product-of-two-elements-in-an-array/description/

Maximum Product of Two Elements in an Array

https://leetcode.com/problems/special-positions-in-a-binary-matrix/description/

Number of single 1 in row/col matrix

https://leetcode.com/problems/difference-between-ones-and-zeros-in-row-and-column/description/

diff[i][j] = onesRowi + onesColj - zerosRowi - zerosColj

https://leetcode.com/problems/destination-city/description/

Destination city in a paths[i] = [cityAi, cityBi] path

https://leetcode.com/problems/valid-anagram/description/

Are two strings an anagram

Yearly badge

https://leetcode.com/problems/design-a-food-rating-system/description/

Given foods, cuisines and ratings implement efficient methods changeRating(food, newRating) and highestRated(cuisine)

https://leetcode.com/problems/maximum-product-difference-between-two-pairs/description/

max * second_max - min * second_min