Posts published in “Uncategorized”

花花酱 LeetCode 2523. Closest Prime Numbers in Range EP407

By zxi on December 31, 2022

Given two positive integers left and right, find the two integers num1 and num2 such that:

left <= nums1 < nums2 <= right .
nums1 and nums2 are both prime numbers.
nums2 - nums1 is the minimum amongst all other pairs satisfying the above conditions.

Return the positive integer array ans = [nums1, nums2]. If there are multiple pairs satisfying these conditions, return the one with the minimum nums1 value or [-1, -1] if such numbers do not exist.

A number greater than 1 is called prime if it is only divisible by 1 and itself.

Example 1:

Input: left = 10, right = 19
Output: [11,13]
Explanation: The prime numbers between 10 and 19 are 11, 13, 17, and 19.
The closest gap between any pair is 2, which can be achieved by [11,13] or [17,19].
Since 11 is smaller than 17, we return the first pair.

Example 2:

Input: left = 4, right = 6
Output: [-1,-1]
Explanation: There exists only one prime number in the given range, so the conditions cannot be satisfied.

Constraints:

1 <= left <= right <= 10⁶

Solution: Sieve of Eratosthenes

Use Sieve of Eratosthenes to find all primes in range [0, right].

Check neighbor primes and find the best pair.

Time complexity: O(nloglogn)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

vector<int> closestPrimes(int left, int right) {

vector<int> primes(right + 1, 1);

primes[0] = primes[1] = 0;

for (int i = 2; i <= sqrt(right); ++i) {

if (!primes[i]) continue;

for (int x = i * i; x <= right; x += i)

primes[x] = 0;

}

vector<int> ans{-1,-1};

for (int i = left, last = -1, best = INT_MAX; i <= right; ++i) {

if (!primes[i]) continue;

if (last > 0 && i - last < best) {

best = i - last;

ans = {last, i};

}

last = i;

}

return ans;

}

};

花花酱 LeetCode 2259. Remove Digit From Number to Maximize Result

By zxi on May 3, 2022

You are given a string number representing a positive integer and a character digit.

Return the resulting string after removing exactly one occurrence of digit from number such that the value of the resulting string in decimal form is maximized. The test cases are generated such that digit occurs at least once in number.

Example 1:

Input: number = "123", digit = "3"
Output: "12"
Explanation: There is only one '3' in "123". After removing '3', the result is "12".

Example 2:

Input: number = "1231", digit = "1"
Output: "231"
Explanation: We can remove the first '1' to get "231" or remove the second '1' to get "123".
Since 231 > 123, we return "231".

Example 3:

Input: number = "551", digit = "5"
Output: "51"
Explanation: We can remove either the first or second '5' from "551".
Both result in the string "51".

Constraints:

2 <= number.length <= 100
number consists of digits from '1' to '9'.
digit is a digit from '1' to '9'.
digit occurs at least once in number.

Solution 1: Brute Force

Try all possible resulting strings.

Time complexity: O(n²)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

string removeDigit(string number, char digit) {

const int n = number.size();

string ans(number.size() - 1, '1');

for (int i = 0; i < n; ++i)

if (number[i] == digit)

ans = max(ans, number.substr(0, i) + number.substr(i + 1));

return ans;

}

};

花花酱 LeetCode 2217. Find Palindrome With Fixed Length

By zxi on March 28, 2022

Given an integer array queries and a positive integer intLength, return an array answer where answer[i] is either the queries[i]^th smallest positive palindrome of length intLength or -1 if no such palindrome exists.

A palindrome is a number that reads the same backwards and forwards. Palindromes cannot have leading zeros.

Example 1:

Input: queries = [1,2,3,4,5,90], intLength = 3
Output: [101,111,121,131,141,999]
Explanation:
The first few palindromes of length 3 are:
101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, ...
The 90^th palindrome of length 3 is 999.

Example 2:

Input: queries = [2,4,6], intLength = 4
Output: [1111,1331,1551]
Explanation:
The first six palindromes of length 4 are:
1001, 1111, 1221, 1331, 1441, and 1551.

Constraints:

1 <= queries.length <= 5 * 10⁴
1 <= queries[i] <= 10⁹
1 <= intLength <= 15

Solution: Math

For even length e.g. 4, we work with length / 2, e.g. 2. Numbers: 10, 11, 12, …, 99, starting from 10, ends with 99, which consist of 99 – 10 + 1 = 90 numbers. For the x-th number, e.g. 88, the left part is 10 + 88 – 1 = 97, just mirror it o get the palindrome. 97|79. Thus we can answer a query in O(k/2) time which is critical.

For odd length e.g. 3 we work with length / 2 + 1, e.g. 2, Numbers: 10, 11, 12, 99. Drop the last digit and mirror the left part to get the palindrome. 101, 111, 121, …, 999.

Time complexity: O(n)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

vector<long long> kthPalindrome(vector<int>& queries, int k) {

long long s = pow(10, (k + 1) / 2 - 1);

long long e = s * 10;

auto gen = [](long long x, bool isOdd) {

long long ans = x;

for (long long c = isOdd ? x / 10 : x; c; c /= 10)

ans = ans * 10 + c % 10;

return ans;

};

vector<long long> ans;

for (int q : queries)

ans.push_back(q > e - s ? -1 : gen(s + q - 1, k & 1));

return ans;

}

};

花花酱 LeetCode 2120. Execution of All Suffix Instructions Staying in a Grid

By zxi on December 26, 2021

There is an n x n grid, with the top-left cell at (0, 0) and the bottom-right cell at (n - 1, n - 1). You are given the integer n and an integer array startPos where startPos = [start_row, start_col] indicates that a robot is initially at cell (start_row, start_col).

You are also given a 0-indexed string s of length m where s[i] is the i^th instruction for the robot: 'L' (move left), 'R' (move right), 'U' (move up), and 'D' (move down).

The robot can begin executing from any i^th instruction in s. It executes the instructions one by one towards the end of s but it stops if either of these conditions is met:

The next instruction will move the robot off the grid.
There are no more instructions left to execute.

Return an array answer of length m where answer[i] is the number of instructions the robot can execute if the robot begins executing from the i^th instruction in s.

Example 1:

Input: n = 3, startPos = [0,1], s = "RRDDLU"
Output: [1,5,4,3,1,0]
Explanation: Starting from startPos and beginning execution from the i^th instruction:
- 0^th: "RRDDLU". Only one instruction "R" can be executed before it moves off the grid.
- 1^st:  "RDDLU". All five instructions can be executed while it stays in the grid and ends at (1, 1).
- 2^nd:   "DDLU". All four instructions can be executed while it stays in the grid and ends at (1, 0).
- 3^rd:    "DLU". All three instructions can be executed while it stays in the grid and ends at (0, 0).
- 4^th:     "LU". Only one instruction "L" can be executed before it moves off the grid.
- 5^th:      "U". If moving up, it would move off the grid.

Example 2:

Input: n = 2, startPos = [1,1], s = "LURD"
Output: [4,1,0,0]
Explanation:
- 0^th: "LURD".
- 1^st:  "URD".
- 2^nd:   "RD".
- 3^rd:    "D".

Example 3:

Input: n = 1, startPos = [0,0], s = "LRUD"
Output: [0,0,0,0]
Explanation: No matter which instruction the robot begins execution from, it would move off the grid.

Constraints:

m == s.length
1 <= n, m <= 500
startPos.length == 2
0 <= start_row, start_col < n
s consists of 'L', 'R', 'U', and 'D'.

Solution: Simulation

Time complexity: O(m²)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

vector<int> executeInstructions(int n, vector<int>& startPos, string s) {

const int m = s.length();

auto moves = [&](int k) -> int {

int x = startPos[1];

int y = startPos[0];

for (int i = k; i < m; ++i) {

switch (s[i]) {

case 'R': x += 1; break;

case 'D': y += 1; break;

case 'L': x -= 1; break;

case 'U': y -= 1; break;

}

if (x < 0 || x == n || y < 0 || y == n)

return i - k;

}

return m - k;

};

vector<int> ans(m);

for (int i = 0; i < m; ++i)

ans[i] = moves(i);

return ans;

}

};

花花酱 LeetCode 1768. Merge Strings Alternately

By zxi on February 20, 2021

You are given two strings word1 and word2. Merge the strings by adding letters in alternating order, starting with word1. If a string is longer than the other, append the additional letters onto the end of the merged string.

Return the merged string.

Example 1:

Input: word1 = "abc", word2 = "pqr"
Output: "apbqcr"
Explanation: The merged string will be merged as so:
word1:  a   b   c
word2:    p   q   r
merged: a p b q c r

Example 2:

Input: word1 = "ab", word2 = "pqrs"
Output: "apbqrs"
Explanation: Notice that as word2 is longer, "rs" is appended to the end.
word1:  a   b 
word2:    p   q   r   s
merged: a p b q   r   s

Example 3:

Input: word1 = "abcd", word2 = "pq"
Output: "apbqcd"
Explanation: Notice that as word1 is longer, "cd" is appended to the end.
word1:  a   b   c   d
word2:    p   q 
merged: a p b q c   d

Constraints:

1 <= word1.length, word2.length <= 100
word1 and word2 consist of lowercase English letters.

Solution: Find the shorter one

Time complexity: O(m+n)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

string mergeAlternately(string word1, string word2) {

const int l1 = word1.size(), l2 = word2.size();

string ans;

for (int i = 0; i < min(l1, l2); ++i) {

ans += word1[i];

ans += word2[i];

}

ans += l1 > l2 ? word1.substr(l2) : word2.substr(l1);

return ans;

}

};