คุณมีอาร์เรย์ 2 มิติ m x n ที่แสดงกระดานหมากรุก ซึ่ง board[i][j] แทนค่าของเซลล์ (i, j) หมากรุกในแถวหรือคอลัมน์เดียวกันจะโจมตีกัน คุณต้องวางหมากรุกสามตัวยบนกระดานหมากรุกโดยที่หมากรุกไม่โจมตีกัน คืนค่าผลรวมของค่าของเซลล์ที่หมากรุกถูกวางไว้ให้ได้มากที่สุด

ตัวอย่างที่ 1:

Input: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Output: 4
คำอธิบาย:

เราสามารถวางหมากรุกในเซลล์ (0, 2), (1, 3), และ (2, 1) จะได้ผลรวม 1 + 1 + 2 = 4

ตัวอย่างที่ 2:

Input: board = [[1,2,3],[4,5,6],[7,8,9]]
Output: 15
คำอธิบาย:
เราสามารถวางหมากรุกในเซลล์ (0, 0), (1, 1), และ (2, 2) จะได้ผลรวม 1 + 5 + 9 = 15

ตัวอย่างที่ 3:

Input: board = [[1,1,1],[1,1,1],[1,1,1]]
Output: 3
คำอธิบาย:
เราสามารถวางหมากรุกในเซลล์ (0, 2), (1, 1), และ (2, 0) จะได้ผลรวม 1 + 1 + 1 = 3

ข้อจำกัด:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

คุณจะได้รับกระดานอาร์เรย์ 2 มิติ m x n ที่แสดงถึงกระดานหมากรุก โดยที่ board[i][j] แสดงถึงค่าของเซลล์ (i, j)
Rooks ในแถวหรือคอลัมน์เดียวกันโจมตีซึ่งกันและกัน คุณต้องวาง rooks สามตัวบนกระดานหมากรุกเพื่อไม่ให้ rooks โจมตีซึ่งกันและกัน
ส่งคืนผลรวมสูงสุดของค่าเซลล์ที่วาง rooks ไว้

ตัวอย่างที่ 1:

อินพุต: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
เอาท์พุต: 4
การอธิบาย:

เราสามารถวาง rooks ในเซลล์ (0, 2), (1, 3) และ (2, 1) เป็นผลรวม 1 + 1 + 2 = 4

ตัวอย่างที่ 2:

อินพุต:board = [[1,2,3],[4,5,6],[7,8,9]]
เอาท์พุต: 15
การอธิบาย:
เราสามารถวาง rooks ในเซลล์ (0, 0), (1, 1) และ (2, 2) เป็นผลรวม 1 + 5 + 9 = 15

ตัวอย่างที่ 3:

อินพุต: board = [[1,1,1],[1,1,1],[1,1,1]]
เอาท์พุต: 3
การอธิบาย:
เราสามารถวาง rooks ในเซลล์ (0, 2), (1, 1) และ (2, 0) ผลรวม 1 + 1 + 1 = 3

ข้อจํากัด:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

คุณได้รับอาร์เรย์ 2 มิติขนาด m x n ที่แสดงถึงกระดานหมากรุก โดยที่ board[i][j] แทนค่าของเซลล์ (i, j) รูคในแถวหรือคอลัมน์เดียวกันจะโจมตีกัน คุณต้องวางรูคสามตัวบนกระดานหมากรุกโดยที่รูคไม่โจมตีกัน คืนค่าผลรวมสูงสุดของค่าของเซลล์ที่วางรูคอยู่

ตัวอย่างที่ 1:

Input: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Output: 4
คำอธิบาย:
เราสามารถวางรูคในเซลล์ (0, 2), (1, 3) และ (2, 1) ได้ โดยมีผลรวมเป็น 1 + 1 + 2 = 4.

ตัวอย่างที่ 2:

Input: board = [[1,2,3],[4,5,6],[7,8,9]]
Output: 15
คำอธิบาย:
เราสามารถวางรูคในเซลล์ (0, 0), (1, 1) และ (2, 2) ได้ โดยมีผลรวมเป็น 1 + 5 + 9 = 15.

ตัวอย่างที่ 3:

Input: board = [[1,1,1],[1,1,1],[1,1,1]]
Output: 3
คำอธิบาย:
เราสามารถวางรูคในเซลล์ (0, 2), (1, 1) และ (2, 0) ได้ โดยมีผลรวมเป็น 1 + 1 + 1 = 3.

ข้อจำกัด:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9


คุณมีจำนวนเต็มบวกสามตัวคือ num1, num2 และ num3

คีย์ของ num1, num2 และ num3 ถูกกำหนดให้เป็นตัวเลขสี่หลักดังนี้:

ในขั้นแรก ถ้าตัวเลขใดมีน้อยกว่าสี่หลัก ให้เติมศูนย์ข้างหน้าให้ครบสี่หลัก

เลขหลักที่ i (1 <= i <= 4) ของคีย์ถูกสร้างขึ้นโดยการเลือกตัวเลขที่เล็กที่สุดในบรรดาเลขหลักที่ i^th ของ num1, num2 และ num3

ให้คืนค่าคีย์ของสามตัวเลขโดยตัดศูนย์ข้างหน้า(ถ้ามี)

ตัวอย่างที่ 1:

Input: num1 = 1, num2 = 10, num3 = 1000
Output: 0
คำอธิบาย:
เมื่อเติมศูนย์ num1 จะกลายเป็น "0001", num2 จะกลายเป็น "0010", และ num3 ยังคงเป็น "1000"

หลักที่ 1 ของคีย์คือ min(0, 0, 1)
หลักที่ 2 ของคีย์คือ min(0, 0, 0)
หลักที่ 3 ของคีย์คือ min(0, 1, 0)
หลักที่ 4 ของคีย์คือ min(1, 0, 0)

ดังนั้นคีย์คือ "0000" หรือ 0

ตัวอย่างที่ 2:

Input: num1 = 987, num2 = 879, num3 = 798
Output: 777

ตัวอย่างที่ 3:

Input: num1 = 1, num2 = 2, num3 = 3
Output: 1

ข้อจำกัด:

1 <= num1, num2, num3 <= 9999

คุณจะได้รับจํานวนเต็มบวกสามจํานวน num1, num2 และ num3
คีย์ของ num1, num2 และ num3 ถูกกําหนดให้เป็นตัวเลขสี่หลักดังนี้:

ในขั้นต้นหากตัวเลขใดมีตัวเลขน้อยกว่าสี่หลักจะถูกบุด้วยเลขศูนย์นําหน้า
หลักที่ i^(1 <= i <= 4) ของคีย์ถูกสร้างขึ้นโดยการนําตัวเลขที่เล็กที่สุดจากหลักที่ i^ของ num1, num2 และ num3

ส่งคืนคีย์ของตัวเลขสามตัวโดยไม่มีเลขศูนย์นําหน้า (ถ้ามี)

ตัวอย่างที่ 1:

อินพุต: num1 = 1, num2 = 10, num3 = 1000
เอาท์พุต: 0
การอธิบาย:
เมื่อเติม num1 จะกลายเป็น "0001" num2 จะกลายเป็น "0010" และ num3 ยังคงเป็น "1000"

หลักที่ 1 ของคีย์คือ min(0, 0, 1)
หลักที่ 2 ของคีย์คือ min(0, 0, 0)
หลักที่ 3 ของคีย์คือ min(0, 1, 0)
หลักที่ 4 ของคีย์คือ min(1, 0, 0)

ดังนั้นคีย์คือ "0000" เช่น 0

ตัวอย่างที่ 2:

อินพุต: num1 = 987, num2 = 879, num3 = 798
เอาท์พุต: 777

ตัวอย่างที่ 3:

อินพุต: num1 = 1, num2 = 2, num3 = 3
เอาท์พุต: 1

ข้อจํากัด:

1 <= num1, num2, num3 <= 9999

คุณจะได้รับจำนวนเต็มบวกสามตัว num1, num2 และ num3
คีย์ของ num1, num2 และ num3 ถูกกำหนดเป็นหลักสี่หลักเช่น:

เริ่มแรกหากหมายเลขใด ๆ มีหลักน้อยกว่าสี่หลักมันจะเป็นเติมศูนย์นำหน้า
i^th digit (1 <= i <= 4) ของคีย์ถูกสร้างขึ้นโดยการใช้หลักที่เล็กที่สุดในจำนวนหลัก i^th ของ num1, num2 และ num3

ส่งคืนคีย์ของหลักสามตัวโดยไม่มีศูนย์นำ (ถ้ามี)

ตัวอย่างที่ 1:

อินพุต: num1 = 1, num2 = 10, num3 = 1000
เอาท์พุท: 0
คำอธิบาย:
เมื่อเติมศูนย์นำหน้า, NUM1 กลายเป็น "0001", num2 กลายเป็น "0010" และ num3 ยังคงอยู่ "1000"

1^st หลักของคีย์คือขั้นต่ำ (0, 0, 1)
หลัก 2^nd ของคีย์คือขั้นต่ำ (0, 0, 0)
หลัก 3^rd ของคีย์คือขั้นต่ำ (0, 1, 0)
หลัก 4^th ของคีย์คือขั้นต่ำ (1, 0, 0)

ดังนั้น คีย์คือ "0000" เช่น 0

ตัวอย่างที่ 2:

อินพุต: num1 = 987, num2 = 879, num3 = 798
เอาท์พุท: 777

ตัวอย่างที่ 3:

อินพุต: num1 = 1, num2 = 2, num3 = 3
เอาท์พุท: 1

ข้อ จำกัด :

1 <= num1, num2, num3 <= 9999


คุณจะได้รับสตริง s ที่มีความยาว n และจำนวนเต็ม k โดยที่ n เป็นทวีคูณของ k งานของคุณคือแฮชสตริง s เป็นสตริงใหม่ที่เรียกว่า result ซึ่งมีความยาว n / k
ก่อนอื่น ให้แบ่ง s ออกเป็นซับสตริง n / k โดยแต่ละซับสตริงมีความยาว k จากนั้น ให้กำหนดค่าเริ่มต้นของ result เป็นสตริงว่าง
สำหรับแต่ละซับสตริงตามลำดับจากจุดเริ่มต้น:

ค่าแฮชของอักขระคือดัชนีของอักขระนั้นในอักษรภาษาอังกฤษ (เช่น 'a' → 0, 'b' → 1, ..., 'z' → 25)
คำนวณผลรวมของค่าแฮชทั้งหมดของอักขระในซับสตริง
หาส่วนที่เหลือของผลรวมนี้เมื่อหารด้วย 26 ซึ่งเรียกว่า hashedChar
ระบุอักขระในอักษรตัวพิมพ์เล็กภาษาอังกฤษที่สอดคล้องกับ hashedChar
ผนวกอักขระนั้นเข้าที่ท้ายผลลัพธ์

ส่งคืนผลลัพธ์

ตัวอย่างที่ 1:

อินพุต: s = "abcd", k = 2
เอาต์พุต: "bf"
คำอธิบาย:
ซับสตริงแรก: "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'
ซับสตริงที่สอง: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'

ตัวอย่างที่ 2:

อินพุต: s = "mxz", k = 3
เอาต์พุต: "i"
คำอธิบาย:
ซับสตริงเพียงตัวเดียว: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'

ข้อจำกัด:

1 <= k <= 100
k <= s.length <= 1000
s.length หารด้วย k ลงตัว s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับสตริง s ที่มีความยาว n และจํานวนเต็ม k โดยที่ n เป็นทวีคูณของ k งานของคุณคือแฮชสตริง s เป็นสตริงใหม่ที่เรียกว่า result ซึ่งมีความยาว n / k
ขั้นแรกแบ่ง s ออกเป็นสตริงย่อย n / k แต่ละสตริงมีความยาว k จากนั้นเริ่มต้นผลลัพธ์เป็นสตริงว่าง
สําหรับแต่ละสตริงย่อยตามลําดับตั้งแต่ต้น:

ค่าแฮชของอักขระคือดัชนีของอักขระนั้นในตัวอักษรภาษาอังกฤษ (เช่น 'a' → 0, 'b' → 1, ..., 'z' → 25)
คํานวณผลรวมของค่าแฮชทั้งหมดของอักขระในสตริงย่อย
หาส่วนที่เหลือของผลรวมนี้เมื่อหารด้วย 26 ซึ่งเรียกว่า hashedChar
ระบุอักขระในตัวอักษรตัวพิมพ์เล็กภาษาอังกฤษที่สอดคล้องกับ hashedChar
ผนวกอักขระนั้นต่อท้ายผลลัพธ์

ส่งคืนผลลัพธ์

ตัวอย่างที่ 1:

อินพุต: s = "abcd", k = 2
เอาต์พุต: "bf"
การอธิบาย:
สตริงย่อยแรก: "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'
สตริงย่อยที่สอง: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'

ตัวอย่างที่ 2:

อินพุต: s = "mxz", k = 3
เอาต์พุต: "i"
การอธิบาย:
สตริงย่อยเดียว: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'

ข้อจํากัด:

1 <= k <= 100
k <= s.length <= 1000
s.length หารด้วย k ลงตัว
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณได้รับจำนวนเต็มบวก n และ k
จำนวนเต็ม x เรียกว่า k-palindromic ถ้า:

x เป็น palindrome
x หารด้วย k ลงตัว

จำนวนเต็มเรียกว่า ดี หากตัวเลขของมันสามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็ม k-palindromic ได้ ตัวอย่างเช่น สำหรับ k = 2, 2020 สามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็ม k-palindromic 2002 ในขณะที่ 1010 ไม่สามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็ม k-palindromic ได้
คืนค่าจำนวนของจำนวนเต็มดีที่มี n หลัก
โปรดทราบว่าจำนวนเต็มใดๆ ต้องไม่มีเลขศูนย์นำหน้าไม่ว่าจะก่อนหรือหลังการจัดเรียงใหม่ ตัวอย่างเช่น 1010 ไม่สามารถจัดเรียงใหม่เพื่อสร้าง 101 ได้

ตัวอย่างที่ 1:

Input: n = 3, k = 5
Output: 27
คำอธิบาย:
บางส่วนของจำนวนเต็มดีคือ:

551 เพราะมันสามารถจัดเรียงใหม่เป็น 515 ได้
525 เพราะมันเป็น k-palindromic อยู่แล้ว

ตัวอย่างที่ 2:

Input: n = 1, k = 4
Output: 2
คำอธิบาย:
จำนวนเต็มดีที่มีสองจำนวนคือ 4 และ 8

ตัวอย่างที่ 3:

Input: n = 5, k = 6
Output: 2468

ข้อจำกัด:

1 <= n <= 10
1 <= k <= 9

คุณจะได้รับจำนวนเต็มบวกสองตัว n และ k
จำนวนเต็ม x เรียกว่า k-palindromic ถ้า:

x เป็น palindrome
x หารด้วย k ลงตัว

จำนวนเต็มเรียกว่าดีถ้าตัวเลขของมันสามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็ม k-palindromic ได้ตัวอย่างเช่น สำหรับ k = 2, 2020 สามารถจัดเรียงใหม่เพื่อสร้าง k-palindromic integer 2002 ในขณะที่ 1010 ไม่สามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็ม k-palindromic ได้
ส่งคืนจำนวนเต็มที่ดีที่มีตัวเลข n
โปรดทราบว่าจำนวนเต็มใด ๆ ไม่ควรเริ่มด้วยศูนย์ ทั้งก่อนและหลังการจัดเรียงใหม่ ตัวอย่างเช่น 1010 ไม่สามารถจัดเรียงใหม่เป็นรูปแบบ 101

ตัวอย่างที่ 1:

อินพุต: n = 3, k = 5
เอาท์พุท: 27
คำอธิบาย:
จำนวนเต็มที่ดีบางส่วนคือ:

551 เพราะสามารถจัดเรียงใหม่เป็นรูปแบบ 515
525 เพราะมันเป็น k-palindromic อยู่แล้ว

ตัวอย่างที่ 2:

อินพุต: n = 1, k = 4
เอาท์พุท: 2
คำอธิบาย:
จำนวนเต็มที่ดีทั้งสองคือ 4 และ 8

ตัวอย่างที่ 3:

อินพุต: n = 5, k = 6
เอาท์พุท: 2468

ข้อ จำกัด :

1 <= n <= 10
1 <= k <= 9

คุณได้รับจำนวนเต็มบวก n และ k
จำนวนเต็ม x จะเรียกว่าเป็นจำนวน k-palindromic ก็ต่อเมื่อ:

x เป็น palindrome
x หารด้วย k ลงตัว

จำนวนเต็มเรียกว่า "ดี" หากเลขโดดของมันสามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็มพาลินโดรม k-ตัวอักษร ตัวอย่างเช่น สำหรับ k = 2, 2020 สามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็มพาลินโดรม k-ตัวอักษร 2002 ในขณะที่ 1010 ไม่สามารถจัดเรียงใหม่เพื่อสร้างจำนวนเต็มพาลินโดรม k-ตัวอักษรได้
จงหาจำนวนของจำนวนเต็มดีที่มี n หลัก
หมายเหตุ: จำนวนเต็มใด ๆ ต้องไม่มีเลขศูนย์นำหน้า ทั้งก่อนและหลังการจัดเรียง ตัวอย่างเช่น 1010 ไม่สามารถจัดเรียงใหม่เพื่อสร้าง 101 ได้

ตัวอย่างที่ 1:

Input: n = 3, k = 5
Output: 27
คำอธิบาย:
บางส่วนของจำนวนเต็มที่ดีคือ:

551 เพราะมันสามารถจัดเรียงใหม่ให้เป็น 515 ได้
525 เพราะมันเป็น k-palindromic อยู่แล้ว

ตัวอย่างที่ 2:

Input: n = 1, k = 4
Output: 2
คำอธิบาย:
จำนวนเต็มดีที่มีสองจำนวนคือ 4 และ 8

ตัวอย่างที่ 3:

Input: n = 5, k = 6
Output: 2468

ข้อจำกัด:

1 <= n <= 10
1 <= k <= 9


คุณจะได้รับพลังจำนวนเต็มและอาร์เรย์จำนวนเต็มสองอาร์เรย์คือดาเมจและสุขภาพ โดยทั้งคู่มีความยาว n
บ็อบมีศัตรู n ตัว โดยศัตรู i จะสร้างความเสียหายให้บ็อบด้วยดาเมจ[i] จุดต่อวินาทีในขณะที่พวกมันยังมีชีวิตอยู่ (นั่นคือ สุขภาพ[i] > 0)
ทุก ๆ วินาที หลังจากที่ศัตรูสร้างความเสียหายให้บ็อบ เขาจะเลือกศัตรูตัวหนึ่งที่ยังมีชีวิตอยู่และสร้างพลังความเสียหายให้กับพวกมัน
กำหนดจำนวนแต้มความเสียหายขั้นต่ำที่จะมอบให้กับบ็อบก่อนที่ศัตรูทั้งหมด n ตัวจะตาย

ตัวอย่างที่ 1:

อินพุต: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
เอาต์พุต: 39
คำอธิบาย:

โจมตีศัตรู 3 ตัวในสองวินาทีแรก หลังจากนั้น ศัตรู 3 ตัวจะล้มลง จำนวนแต้มความเสียหายที่สร้างให้กับบ็อบคือ 10 + 10 = 20 แต้ม
โจมตีศัตรู 2 ใน 2 วินาที หลังจากนั้นศัตรู 2 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบได้รับคือ 6 + 6 = 12 แต้ม
โจมตีศัตรู 0 ในวินาทีถัดไป หลังจากนั้นศัตรู 0 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบได้รับคือ 3 แต้ม
โจมตีศัตรู 1 ใน 2 วินาที หลังจากนั้นศัตรู 1 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบได้รับคือ 2 + 2 = 4 แต้ม

ตัวอย่าง 2:

อินพุต: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
เอาต์พุต: 20
คำอธิบาย:

โจมตีศัตรู 0 ในวินาทีถัดไป หลังจากนั้นศัตรู 0 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบได้รับคือ 4 แต้ม
โจมตีศัตรู 1 ใน 2 วินาที หลังจากนั้นศัตรู 1 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบได้รับคือ 3 + 3 = 6 แต้ม
โจมตีศัตรู 2 ตัวใน 3 วินาทีถัดไป หลังจากนั้นศัตรู 2 ตัวจะล้มลง จำนวนแต้มความเสียหายที่บ็อบได้รับคือ 2 + 2 + 2 = 6 แต้ม
โจมตีศัตรู 3 ตัวใน 4 วินาทีถัดไป หลังจากนั้นศัตรู 3 ตัวจะล้มลง จำนวนแต้มความเสียหายที่บ็อบได้รับคือ 1 + 1 + 1 + 1 = 4 แต้ม

ตัวอย่างที่ 3:

อินพุต: power = 8, damage = [40], health = [59]
เอาต์พุต: 320

ข้อจำกัด:

1 <=  power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

คุณจะได้รับพลังจำนวนเต็มและอาร์เรย์จำนวนเต็มสองอาร์เรย์คือดาเมจและสุขภาพ โดยทั้งคู่มีความยาว n
บ็อบมีศัตรู n ตัว โดยศัตรู i จะสร้างความเสียหายให้บ็อบด้วยดาเมจ[i] จุดต่อวินาทีในขณะที่พวกมันยังมีชีวิตอยู่ (นั่นคือ สุขภาพ[i] > 0)
ทุก ๆ วินาที หลังจากที่ศัตรูสร้างความเสียหายให้บ็อบ เขาจะเลือกศัตรูตัวหนึ่งที่ยังมีชีวิตอยู่และสร้างพลังความเสียหายให้กับพวกมัน
กำหนดจำนวนแต้มความเสียหายขั้นต่ำที่จะมอบให้กับบ็อบก่อนที่ศัตรูทั้งหมด n ตัวจะตาย

ตัวอย่างที่ 1:

อินพุต: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
เอาต์พุต: 39
คำอธิบาย:

โจมตีศัตรู 3 ตัวในสองวินาทีแรก หลังจากนั้น ศัตรู 3 ตัวจะล้มลง จำนวนแต้มความเสียหายที่สร้างให้กับบ็อบคือ 10 + 10 = 20 แต้ม
โจมตีศัตรู 2 ใน 2 วินาทีถัดไป หลังจากนั้นศัตรู 2 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบทำได้คือ 6 + 6 = 12 แต้ม
โจมตีศัตรู 0 ในวินาทีถัดไป หลังจากนั้นศัตรู 0 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบทำได้คือ 3 แต้ม
โจมตีศัตรู 1 ใน 2 วินาทีถัดไป หลังจากนั้นศัตรู 1 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบทำได้คือ 2 + 2 = 4 แต้ม

ตัวอย่าง 2:

อินพุต: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
เอาต์พุต: 20
คำอธิบาย:

โจมตีศัตรู 0 ในวินาทีถัดไป หลังจากนั้นศัตรู 0 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบทำได้คือ 4 แต้ม
โจมตีศัตรู 1 ใน 2 วินาทีถัดไป หลังจากนั้นศัตรู 1 จะล้มลง จำนวนแต้มความเสียหายที่บ็อบทำได้คือ 3 + 3 = 6 แต้ม
โจมตีศัตรู 2 ตัวใน 3 วินาทีถัดไป หลังจากนั้นศัตรู 2 ตัวจะล้มลง จำนวนแต้มความเสียหายที่บ็อบทำได้คือ 2 + 2 + 2 = 6 แต้ม
โจมตีศัตรู 3 ตัวใน 4 วินาทีถัดไป หลังจากนั้นศัตรู 3 ตัวจะล้มลง จำนวนแต้มความเสียหายที่บ็อบทำได้คือ 1 + 1 + 1 + 1 = 4 แต้ม

ตัวอย่างที่ 3:

อินพุต: power = 8, damage = [40], health = [59]
เอาต์พุต: 320

ข้อจำกัด:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

คุณจะได้รับกำลังจำนวนเต็มและอาร์เรย์จำนวนเต็มสองอัน คือ อาร์เรย์ damage และ health ทั้งสองมีความยาว n
บ๊อบมีศัตรู n คน ศัตรู i จะทำให้บ๊อบเสียหาย damage[i] คะแนนต่อวินาทีตราบใดที่สุขภาพของศัตรู [i] > 0
ทุกวินาทีหลังจากที่ศัตรูสร้างความเสียหายให้กับบ๊อบเขาเลือกศัตรูตัวใดตัวหนึ่งที่ยังมีชีวิตอยู่และสร้างความเสียหายให้กับพวกเขา
กำหนดจำนวนคะแนนความเสียหายขั้นต่ำที่จะได้รับการจัดการให้กับ Bob ก่อนที่ศัตรูทุกคนจะตาย

ตัวอย่างที่ 1:

อินพุต: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
เอาท์พุท: 39
คำอธิบาย:

โจมตีศัตรู 0 ในวินาทีแรก เมื่อศัตรู 3 ล้มลงแล้ว จำนวนคะแนนความเสียหายที่ Bob ได้รับคือ 10 + 10 = 20 คะแนน
โจมตีศัตรู 2 ในสองวินาทีถัดมา เมื่อศัตรู 2 ล้มลงแล้ว จำนวนคะแนนความเสียหายที่ Bob ได้รับคือ 6 + 6 = 12 คะแนน
โจมตีศัตรู 0 ในวินาทีถัดมา เมื่อศัตรู 0 ล้มลงแล้ว จำนวนคะแนนความเสียหายที่ Bob ได้รับคือ 3 คะแนน
โจมตีศัตรู 1 ในสองวินาทีถัดมา เมื่อศัตรู 1 ล้มลงแล้ว จำนวนคะแนนความเสียหายที่ Bob ได้รับคือ 2 + 2 = 4 คะแนน

ตัวอย่างที่ 2:

อินพุต: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
เอาท์พุท: 20
คำอธิบาย:

โจมตีศัตรู 0 ในวินาทีแรกหลังจากนั้นศัตรู 0 จะลงไปจำนวนคะแนนความเสียหายที่เกี่ยวข้องกับบ๊อบคือ 4 คะแนน
โจมตีศัตรู 1 ในอีกสองวินาทีหลังจากนั้นศัตรู 1 จะลงไปจำนวนคะแนนความเสียหายที่เกี่ยวข้องกับ Bob คือ 3 + 3 = 6 คะแนน
โจมตีศัตรู 2 ในอีกสามวินาทีหลังจากนั้นศัตรู 2 จะลงไปจำนวนคะแนนความเสียหายที่เกี่ยวข้องกับ Bob คือ 2 + 2 + 2 = 6 คะแนน
โจมตีศัตรู 3 ในสี่วินาทีถัดไปหลังจากนั้นศัตรู 3 จะลงไปจำนวนคะแนนความเสียหายที่เกี่ยวข้องกับ Bob คือ 1 + 1 + 1 + 1 = 4 คะแนน

ตัวอย่างที่ 3:

อินพุต: power = 8, damage = [40], Health = [59]
เอาท์พุท: 320

ข้อ จำกัด :

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4


คุณจะได้รับตารางเมทริกซ์ไบนารี m x n และสุขภาพของจำนวนเต็ม
คุณเริ่มต้นที่มุมซ้ายบน (0, 0) และต้องการไปที่มุมล่างขวา (m - 1, n - 1)
คุณสามารถเลื่อนขึ้น ลง ซ้าย หรือขวาจากเซลล์หนึ่งไปยังอีกเซลล์ที่อยู่ติดกันได้ ตราบใดที่สุขภาพของคุณยังคงเป็นบวก
เซลล์ (i, j) ที่มีค่า grid[i][j] = 1 ถือว่าไม่ปลอดภัยและลดสุขภาพของคุณลง 1
คืนค่า true หากคุณสามารถเข้าถึงเซลล์สุดท้ายที่มีค่าสุขภาพ 1 หรือมากกว่า และคืนค่า false หากไม่เช่นนั้น

ตัวอย่างที่ 1:

อินพุต: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
เอาต์พุต: true
คำอธิบาย:
สามารถเข้าถึงเซลล์สุดท้ายได้อย่างปลอดภัยโดยเดินไปตามเซลล์สีเทาที่อยู่ด้านล่าง

ตัวอย่างที่ 2:

อินพุต: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
เอาต์พุต: false
คำอธิบาย:
ต้องมีค่าพลังชีวิตอย่างน้อย 4 คะแนนจึงจะไปถึงเซลล์สุดท้ายได้อย่างปลอดภัย

ตัวอย่างที่ 3:

อินพุต: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
เอาต์พุต: true
คำอธิบาย:
คุณสามารถไปถึงเซลล์สุดท้ายได้อย่างปลอดภัยโดยเดินไปตามเซลล์สีเทาด้านล่าง

เส้นทางใดก็ตามที่ไม่ผ่านเซลล์ (1, 1) จะไม่ปลอดภัยเนื่องจากพลังชีวิตของคุณจะลดลงเหลือ 0 เมื่อไปถึงเซลล์สุดท้าย

ข้อจำกัด:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] มีค่าเป็น 0 หรือ 1

คุณจะได้รับกริดเมทริกซ์ไบนารี m x n และสุขภาพจำนวนเต็ม
คุณเริ่มต้นที่มุมบนซ้าย (0, 0) และต้องการไปที่มุมล่างขวา (m - 1, n - 1)
คุณสามารถเลื่อนขึ้นลงซ้ายหรือขวาจากเซลล์หนึ่งไปยังเซลล์อื่นที่อยู่ติดกันตราบใดที่สุขภาพของคุณยังคงเป็นบวก
เซลล์ (i, j) ที่มีกริด [i] [j] = 1 ถือว่าไม่ปลอดภัยและลดสุขภาพของคุณลง 1
ส่งคืนจริงถ้าคุณสามารถไปถึงเซลล์สุดท้ายด้วยค่าสุขภาพ 1 หรือมากกว่าและเท็จเป็นอย่างอื่น

ตัวอย่างที่ 1:

อินพุต: grid = [[0,1,0,0,0], [0,1,0,1,0], [0,0,0,1,0]], สุขภาพ = 1
เอาท์พุท: จริง
คำอธิบาย:
เซลล์สุดท้ายสามารถเข้าถึงได้อย่างปลอดภัยโดยการเดินไปตามเซลล์สีเทาด้านล่าง

ตัวอย่างที่ 2:

อินพุต: grid = [[0,1,1,0,0,0,0], [1,0,1,0,0,0], [0,1,1,1,0,1], [0, 0, 0,1,0,1,0]], สุขภาพ = 3
เอาท์พุท: เท็จ
คำอธิบาย:
จำเป็นต้องมีคะแนนสุขภาพขั้นต่ำ 4 จุดเพื่อไปถึงเซลล์สุดท้ายอย่างปลอดภัย

ตัวอย่างที่ 3:

อินพุต: grid = [[1,1,1], [1,0,1], [1,1,1]], สุขภาพ = 5
เอาท์พุท: จริง
คำอธิบาย:
เซลล์สุดท้ายสามารถเข้าถึงได้อย่างปลอดภัยโดยการเดินไปตามเซลล์สีเทาด้านล่าง

เส้นทางใด ๆ ที่ไม่ผ่านเซลล์ (1, 1) ไม่ปลอดภัยเนื่องจากสุขภาพของคุณจะลดลงเป็น 0 เมื่อถึงเซลล์สุดท้าย

ข้อ จำกัด :

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= สุขภาพ <= m + n
กริด [i] [j] เป็น 0 หรือ 1

คุณจะได้รับตารางเมทริกซ์ไบนารี m x n และสุขภาพจำนวนเต็ม
คุณเริ่มต้นที่มุมซ้ายบน (0, 0) และต้องการไปที่มุมล่างขวา (m - 1, n - 1)
คุณสามารถเลื่อนขึ้น ลง ซ้าย หรือขวาจากเซลล์หนึ่งไปยังอีกเซลล์ที่อยู่ติดกันได้ ตราบใดที่สุขภาพของคุณยังคงเป็นบวก
เซลล์ (i, j) ที่มีค่า grid[i][j] = 1 ถือว่าไม่ปลอดภัยและลดสุขภาพของคุณลง 1
คืนค่า true หากคุณสามารถเข้าถึงเซลล์สุดท้ายที่มีค่าสุขภาพ 1 หรือมากกว่า และคืนค่า false หากไม่เช่นนั้น

ตัวอย่างที่ 1:

อินพุต: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
เอาต์พุต: true
คำอธิบาย:
สามารถเข้าถึงเซลล์สุดท้ายได้อย่างปลอดภัยโดยเดินไปตามเซลล์สีเทาที่อยู่ด้านล่าง
ตัวอย่างที่ 2:

อินพุต: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
เอาต์พุต: false
คำอธิบาย:
ต้องมีค่าพลังชีวิตอย่างน้อย 4 คะแนนจึงจะไปถึงเซลล์สุดท้ายได้อย่างปลอดภัย

ตัวอย่างที่ 3:

อินพุต: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
เอาต์พุต: true
คำอธิบาย:
คุณสามารถไปถึงเซลล์สุดท้ายได้อย่างปลอดภัยโดยเดินไปตามเซลล์สีเทาด้านล่าง

เส้นทางใดก็ตามที่ไม่ผ่านเซลล์ (1, 1) จะไม่ปลอดภัยเนื่องจากพลังชีวิตของคุณจะลดลงเหลือ 0 เมื่อไปถึงเซลล์สุดท้าย
ข้อจำกัด:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] มีค่าเป็น 0 หรือ 1


คุณจะได้รับอาร์เรย์จำนวนเต็ม nums และจำนวนเต็มบวก k
ค่าของลำดับ seq ขนาด 2 * x ถูกกำหนดเป็น:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1])

ส่งคืนค่าสูงสุดของลำดับย่อยใดๆ ของ nums ที่มีขนาด 2 * k

ตัวอย่างที่ 1:

อินพุต: nums = [2,6,7], k = 1
เอาต์พุต: 5
คำอธิบาย:
ลำดับย่อย [2, 7] มีค่าสูงสุดเท่ากับ 2 XOR 7 = 5

ตัวอย่างที่ 2:

อินพุต: nums = [4,2,5,6,7], k = 2
เอาต์พุต: 2
คำอธิบาย:
ลำดับย่อย [4, 5, 6, 7] มีค่าสูงสุดเท่ากับ (4 OR 5) XOR (6 OR 7) = 2

ข้อจำกัด:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

คุณได้รับอาเรย์จำนวนเต็ม nums และจำนวนเต็มบวก k
ค่าของลำดับ seq ขนาด 2 * x ถูกกำหนดไว้ว่า:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

ให้คืนค่าค่าสูงสุดของซับซีเควนซ์ใด ๆ ของ nums ที่มีขนาด 2 * k.

ตัวอย่างที่ 1:

Input: nums = [2,6,7], k = 1
Output: 5
คำอธิบาย:
อนุกรมย่อย [2, 7] มีค่ามากที่สุดคือ 2 XOR 7 = 5.

ตัวอย่างที่ 2:

Input: nums = [4,2,5,6,7], k = 2
Output: 2
คำอธิบาย:
อนุกรมย่อย [4, 5, 6, 7] มีค่ามากที่สุดเท่ากับ (4 OR 5) XOR (6 OR 7) = 2.

ข้อจำกัด:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

คุณจะได้รับ nums อาร์เรย์จํานวนเต็มและจํานวนเต็มบวก k
ค่าของลำดับที่มีขนาด 2 * x ถูกกำหนดเป็น:

(seq[0] หรือ seq[1] หรือ ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] หรือ ... หรือseq[2 * x - 1])

ส่งคืนค่าสูงสุดของลำดับย่อยของ nums ที่มีขนาด 2 * k

ตัวอย่างที่ 1:

อินพุต: nums = [2,6,7], k = 1
เอาท์พุต: 5
การอธิบาย:
ลำดับย่อย [2, 7] มีค่าสูงสุดที่ 2 XOR 7 = 5

ตัวอย่างที่ 2:

อินพุต: nums = [4,2,5,6,7], k = 2
เอาท์พุต: 2
การอธิบาย:
ลำดับย่อย [4, 5, 6, 7] มีค่าสูงสุดที่ (4 หรือ 5) XOR (6 หรือ 7) = 2

ข้อจํากัด:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2


คุณจะได้รับอาร์เรย์ 2 มิติของจำนวนเต็มพิกัดความยาว n และจำนวนเต็ม k โดยที่ 0 <= k < n
coordinates[i] = [x_i, y_i] ระบุจุด (x_i, y_i) ในระนาบ 2 มิติ
เส้นทางที่เพิ่มขึ้นที่มีความยาว m ถูกกำหนดให้เป็นรายการจุด (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) โดยที่:

x_i < x_i + 1 และ y_i < y_i + 1 สำหรับทุก i ที่ 1 <= i < m
(x_i, y_i) อยู่ในพิกัดที่กำหนดสำหรับทุก i ที่ 1 <= i <= m

ส่งคืนความยาวสูงสุดของเส้นทางที่เพิ่มขึ้นที่มี coordinates[k]

ตัวอย่างที่ 1:

อินพุต: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
เอาต์พุต: 3
คำอธิบาย:
(0, 0), (2, 2), (5, 3) คือเส้นทางที่เพิ่มขึ้นที่ยาวที่สุดที่มี (2, 2)

ตัวอย่างที่ 2:

อินพุต: coordinates = [[2,1],[7,0],[5,6]], k = 2
เอาต์พุต: 2
คำอธิบาย:
(2, 1), (5, 6) คือเส้นทางที่เพิ่มขึ้นที่ยาวที่สุดที่มี (5, 6)

ข้อจำกัด:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
องค์ประกอบทั้งหมดในพิกัดนั้นแยกจากกัน 0 <= k <= n - 1

คุณจะได้รับอาร์เรย์ 2 มิติของพิกัดจํานวนเต็มที่มีความยาว n และจํานวนเต็ม k โดยที่ 0 <= k < n
พิกัด[i] = [x_i, y_i] ระบุจุด (x_i, y_i) ในระนาบ 2 มิติ
เส้นทางที่เพิ่มขึ้นของความยาว m ถูกกําหนดให้เป็นรายการของจุด (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) เช่น:

x_i < x_i + 1 และ y_i < y_i + 1 สําหรับ i ทั้งหมดโดยที่ 1 <= i < m
(x_i, y_i) อยู่ในพิกัดที่กําหนดสําหรับ i ทั้งหมดโดยที่ 1 <= i <= m

ส่งกลับความยาวสูงสุดของเส้นทางที่เพิ่มขึ้นซึ่งมีพิกัด[k]

ตัวอย่างที่ 1:

อินพุต: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
เอาท์พุต: 3
การอธิบาย:
(0, 0), (2, 2), (5, 3) คือเส้นทางที่เพิ่มขึ้นที่ยาวที่สุดที่มี (2, 2)

ตัวอย่างที่ 2:

อินพุต:coordinates = [[2,1],[7,0],[5,6]], k = 2
เอาท์พุต: 2
การอธิบาย:
(2, 1), (5, 6) คือเส้นทางที่เพิ่มขึ้นที่ยาวที่สุดที่มี (5, 6)

ข้อจํากัด:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
ทุกองค์ประกอบใน coordinates แตกต่างกัน
0 <= k <= n - 1

คุณได้รับอาเรย์ 2D ของจำนวนเต็มที่เรียกว่า coordinates ซึ่งมีความยาว n และจำนวนเต็ม k โดยที่ 0 <= k < n
coordinates[i] = [x_i, y_i] แสดงถึงจุด (x_i, y_i) ในระนาบ 2D
เส้นทางที่เพิ่มขึ้นซึ่งมีความยาว m ถูกกำหนดให้เป็นรายการของจุด (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) โดยมีเงื่อนไขว่า:

x_i < x_i + 1 และ y_i < y_i + 1 สำหรับทุก i ที่ 1 <= i < m
(x_i, y_i) อยู่ใน coordinates ที่กำหนดสำหรับทุก i ที่ 1 <= i <= m

ให้คืนค่าความยาวสูงสุดของเส้นทางที่เพิ่มขึ้นซึ่งมี coordinates[k] อยู่ด้วย

ตัวอย่างที่ 1:

Input: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Output: 3
คำอธิบาย:
(0, 0), (2, 2), (5, 3) เป็นเส้นทางที่ยาวที่สุดที่มีการเพิ่มขึ้นซึ่งมี (2, 2) อยู่ด้วย

ตัวอย่างที่ 2:

Input: coordinates = [[2,1],[7,0],[5,6]], k = 2
Output: 2
คำอธิบาย:
(2, 1), (5, 6) เป็นเส้นทางที่ยาวที่สุดที่มีการเพิ่มขึ้นซึ่งประกอบด้วย (5, 6)

ข้อจำกัด:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
ทุกองค์ประกอบในพิกัดเป็นเอกลักษณ์แตกต่างกัน
0 <= k <= n - 1


คุณได้รับอาเรย์ของสตริง message และอาเรย์ของสตริง bannedWords

อาเรย์ของคำถือว่าเป็นสแปมถ้ามีอย่างน้อยสองคำในอาเรย์ที่ตรงกับคำใด ๆ ใน bannedWords อย่างสมบูรณ์

ให้คืนค่า true ถ้าอาเรย์ message เป็นสแปม และ false ถ้าไม่เป็น

ตัวอย่างที่ 1:

Input: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]

Output: true

คำอธิบาย:

คำว่า "hello" และ "world" จากอาเรย์ message ปรากฏในอาเรย์ bannedWords ทั้งคู่

ตัวอย่างที่ 2:

Input: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]

Output: false

คำอธิบาย:

มีเพียงคำเดียวจากอาเรย์ message ("programming") ที่ปรากฏในอาเรย์ bannedWords

ข้อจำกัด:

1 <= message.length, bannedWords.length <= 10^5

1 <= message[i].length, bannedWords[i].length <= 15

message[i] และ bannedWords[i] ประกอบด้วยตัวอักษรภาษาอังกฤษพิมพ์เล็กเท่านั้น

คุณจะได้รับอาร์เรย์ของสตริงข้อความและอาร์เรย์ของสตริง banishedWords
อาร์เรย์ของคำจะถือว่าเป็นสแปมหากมีอย่างน้อยสองคำในนั้นที่ตรงกับคำใดๆ ใน banishedWords อย่างแน่นอน

คืนค่า true หากข้อความในอาร์เรย์เป็นสแปม และคืนค่า false หากไม่ใช่

ตัวอย่างที่ 1:

อินพุต:message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
เอาต์พุต: true
คำอธิบาย:
คำว่า "hello" และ "world" จากอาร์เรย์ข้อความปรากฏในอาร์เรย์ banishedWords

ตัวอย่างที่ 2:

อินพุต: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
เอาต์พุต: false
คำอธิบาย:
มีเพียงคำเดียวจากอาร์เรย์ข้อความ ("programming") ปรากฏในอาร์เรย์ banishedWords
ข้อจำกัด:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] และ bannedWords[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับอาร์เรย์ของสตริงข้อความและอาร์เรย์ของสตริง banishedWords
อาร์เรย์ของคำจะถือว่าเป็นสแปมหากมีอย่างน้อยสองคำในนั้นที่ตรงกับคำใดๆ ใน banishedWords อย่างแน่นอน
คืนค่า true หากข้อความในอาร์เรย์เป็นสแปม และคืนค่า false หากไม่ใช่

ตัวอย่างที่ 1:

อินพุต: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
เอาต์พุต: true
คำอธิบาย:
คำว่า "hello" และ "world" จากอาร์เรย์ข้อความปรากฏในอาร์เรย์ banishedWords

ตัวอย่างที่ 2:

อินพุต: ข้message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
เอาต์พุต: false
คำอธิบาย:
มีเพียงคำเดียวจากอาร์เรย์ข้อความ ("programming") ปรากฏในอาร์เรย์ banishedWords

ข้อจำกัด:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] และ bannedWords[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณจะได้รับค่า mountainHeight จำนวนเต็มซึ่งแสดงถึงความสูงของภูเขา
คุณจะได้รับอาร์เรย์จำนวนเต็ม workerTimes ซึ่งแสดงเวลาการทำงานของคนงานเป็นวินาที
คนงานจะทำงานพร้อมกันเพื่อลดความสูงของภูเขา สำหรับคนงาน i:

ในการลดความสูงของภูเขาลง x ต้องใช้เวลา workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x วินาที ตัวอย่างเช่น:

ในการลดความสูงของภูเขาลง 1 ต้องใช้เวลา workerTimes[i] วินาที
ในการลดความสูงของภูเขาลง 2 ต้องใช้เวลา workerTimes[i] + workerTimes[i] * 2 วินาที เป็นต้น

ส่งคืนจำนวนเต็มที่แสดงจำนวนวินาทีขั้นต่ำที่จำเป็นสำหรับคนงานในการทำให้ความสูงของภูเขาเป็น 0

ตัวอย่าง 1:

อินพุต: mountainHeight = 4, workerTimes = [2,1,1]
เอาต์พุต: 3
คำอธิบาย:
วิธีหนึ่งที่จะลดความสูงของภูเขาให้เหลือ 0 ได้คือ:

คนงาน 0 ลดความสูงลง 1 โดยใช้เวลา workerTimes[0] = 2 วินาที
คนงาน 1 ลดความสูงลง 2 โดยใช้เวลา workerTimes[1] + workerTimes[1] * 2 = 3 วินาที
คนงาน 2 ลดความสูงลง 1 โดยใช้เวลา workerTimes[2] = 1 วินาที

เนื่องจากทั้งสองทำงานพร้อมกัน เวลาขั้นต่ำที่จำเป็นคือ max(2, 3, 1) = 3 วินาที
ตัวอย่างที่ 2:

อินพุต: mountainHeight = 10, workerTimes = [3,2,2,4]
เอาต์พุต: 12
คำอธิบาย:

คนงาน 0 ลดความสูงลง 2 โดยใช้ workerTimes[0] + workerTimes[0] * 2 = 9 วินาที
คนงาน 1 ลดความสูงลง 3 โดยใช้ workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 วินาที
คนงาน 2 ลดความสูงลง 3 โดยใช้ workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 วินาที
คนงาน 3 ลดความสูงลง 2 โดยใช้ workerTimes[3] + workerTimes[3] * 2 = 12 วินาที

จำนวนวินาทีที่ต้องการคือ max(9, 12, 12, 12) = 12 วินาที

ตัวอย่างที่ 3:

อินพุต: mountainHeight = 5, workerTimes = [1]
เอาต์พุต: 15
คำอธิบาย:
ในตัวอย่างนี้มีเพียงคนงานคนเดียว ดังนั้นคำตอบคือ workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15

ข้อจำกัด:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

มีจำนวนเต็ม mountainHeight แสดงความสูงของภูเขา
คุณยังได้รับอาเรย์ของจำนวนเต็ม workerTimes ที่แสดงเวลาการทำงานของคนงานเป็นวินาที
คนงานทำงานพร้อมกันเพื่อลดความสูงของภูเขา สำหรับคนงาน i:

ในการลดความสูงของภูเขา xจะใช้เวลา workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x วินาที ตัวอย่างเช่น:

ลดความสูงของภูเขาลง 1 ใช้เวลา workerTimes[i]` วินาที
ลดความสูงของภูเขาลง 2 ใช้เวลา workerTimes[i] + workerTimes[i] * 2 วินาที เป็นต้น

ส่งค่าจำนวนเต็มที่แสดงจำนวนวินาทีขั้นต่ำที่ต้องใช้เพื่อให้คนงานลดความสูงของภูเขาเป็น 0

ตัวอย่างที่ 1:

Input: mountainHeight = 4, workerTimes = [2,1,1]
Output: 3
คำอธิบาย:
วิธีหนึ่งที่สามารถลดความสูงของภูเขาลงเหลือ 0 คือ:

คนงาน 0 ลดความสูงลง 1 ใช้เวลา workerTimes[0] = 2 วินาที
คนงาน 1 ลดความสูงลง 2 ใช้เวลา workerTimes[1] + workerTimes[1] * 2 = 3 วินาที
คนงาน 2 ลดความสูงลง 1 ใช้เวลา workerTimes[2] = 1 วินาที

เนื่องจากพวกเขาทำงานพร้อมกัน เวลาน้อยที่สุดที่ต้องใช้คือสูงสุด(2, 3, 1) = 3 วินาที

ตัวอย่างที่ 2:

Input: `mountainHeight = 10`, workerTimes = [3,2,2,4]
Output: 12
คำอธิบาย:

คนงาน 0 ลดความสูงลง 2 ใช้เวลา workerTimes[0] + workerTimes[0] * 2 = 9 วินาที
คนงาน 1 ลดความสูงลง 3 ใช้เวลา workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 วินาที
คนงาน 2 ลดความสูงลง 3 ใช้เวลา workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 วินาที
คนงาน 3 ลดความสูงลง 2 ใช้เวลา `workerTimes[3] + workerTimes[3] * 2 = 12 วินาที

จำนวนวินาทีที่ต้องใช้คือ สูงสุด(9, 12, 12, 12) = 12 วินาที

ตัวอย่างที่ 3:

Input: `mountainHeight = 5`, `workerTimes = [1]`
Output: 15
คำอธิบาย:
มีคนงานเพียงหนึ่งคนในตัวอย่างนี้ ดังนั้นคำตอบคือ `workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15`

ข้อจำกัด:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

คุณจะได้รับจำนวนเต็มที่แสดงถึงความสูงของภูเขา
นอกจากนี้คุณยังได้รับอาร์เรย์จำนวนเต็มซึ่งเป็นตัวแทนของเวลาทำงานของคนงานในไม่กี่วินาที
คนงานทำงานพร้อมกันเพื่อลดความสูงของภูเขาลง สำหรับคนงาน i:

เพื่อลดความสูงของภูเขาลงด้วย x ต้องใช้workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x วินาที ตัวอย่างเช่น:

เพื่อลดความสูงของภูเขาด้วย  1 ใช้เวลา workerTimes[i] วินาที
เพื่อลดความสูงของภูเขาด้วย  2 ใช้เวลา workerTimes[i] + workerTimes[i] * 2 วินาที และต่อไปเช่นนี้

ส่งคืนจำนวนเต็มแทนจำนวนขั้นต่ำของวินาทีที่จำเป็นสำหรับคนงานที่จะทำให้ความสูงของภูเขา 0

ตัวอย่างที่ 1:

อินพุต: MountainHeight = 4, WorkerTimes = [2,1,1]
เอาท์พุท: 3
คำอธิบาย:
วิธีหนึ่งความสูงของภูเขาสามารถลดลงเป็น 0 คือ:

คนงาน 0 ลดความสูงลง 1 โดยใช้เวลาทำงาน [0] = 2 วินาที
คนงาน 1 ลดความสูง 2 โดยใช้เวลาทำงาน [1] + workerTimes [1] * 2 = 3 วินาที
คนงาน 2 ลดความสูงลง 1 โดยใช้เวลาทำงาน [2] = 1 วินาที

เนื่องจากพวกเขาทำงานพร้อมกัน ดังนั้นเวลาขั้นต่ำที่ต้องการคือสูงสุดของ (2, 3, 1) คือ 3 วินาที

ตัวอย่างที่ 2:

อินพุต: MountainHeight = 10, WorkerTimes = [3,2,2,4]
เอาท์พุท: 12
คำอธิบาย:

คนงาน 0 ลดความสูง 2 โดยใช้เวลาทำงาน [0] + WorkerTimes [0] * 2 = 9 วินาที
คนงาน 1 ลดความสูงลง 3 ครั้งโดยใช้เวลาทำงาน [1] + WorkerTimes [1] * 2 + WorkerTimes [1] * 3 = 12 วินาที
Worker 2 ลดความสูงลง 3 ครั้งโดยใช้เวลาทำงาน [2] + WorkerTimes [2] * 2 + WorkerTimes [2] * 3 = 12 วินาที
คนงาน 3 ลดความสูง 2 โดยใช้เวลาทำงาน [3] + WorkerTimes [3] * 2 = 12 วินาที

จำนวนวินาทีที่ต้องการคือสูงสุด (9, 12, 12, 12) = 12 วินาที

ตัวอย่างที่ 3:

อินพุต: MountainHeight = 5, WorkerTimes = [1]
เอาท์พุท: 15
คำอธิบาย:
มีคนงานเพียงคนเดียวในตัวอย่างนี้ดังนั้นคำตอบคือworkerTimes [0] + workerTimes [0] * 2 + WorkerTimes [0] * 3 + WorkerTimes [0] * 4 + WorkerTimes [0] * 5 = 15

ข้อ จำกัด :

1 <= Mountainheight <= 10^5
1 <= WorkerTimes.Length <= 10^4
1 <= WorkerTimes [i] <= 10^6


คุณจะได้รับสตริงสองตัวคือ word1 และ word2
สตริง x จะถูกเรียกว่าถูกต้องหากสามารถจัดเรียง x ใหม่เพื่อให้มี word2 เป็นคำนำหน้าได้
ส่งคืนจำนวนทั้งหมดของสตริงย่อยที่ถูกต้องของ word1

ตัวอย่างที่ 1:

อินพุต: word1 = "bcca", word2 = "abc"
เอาต์พุต: 1
คำอธิบาย:
สตริงย่อยที่ถูกต้องเพียงตัวเดียวคือ "bcca" ซึ่งสามารถจัดเรียงใหม่เป็น "abcc" ได้โดยมี "abc" เป็นคำนำหน้า

ตัวอย่างที่ 2:

อินพุต: word1 = "abcabc", word2 = "abc"
เอาต์พุต: 10
คำอธิบาย:
สตริงย่อยทั้งหมด ยกเว้นสตริงย่อยขนาด 1 และ 2 ถูกต้อง

ตัวอย่างที่ 3:

อินพุต: word1 = "abcabc", word2 = "aaabc"
เอาต์พุต: 0

ข้อจำกัด:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 และ word2 ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น..


Alice และ Bob กำลังเล่นเกมกัน ในตอนแรก Alice มีสตริง word = "a"
คุณจะได้รับจำนวนเต็มบวก k
ตอนนี้ Bob จะขอให้ Alice ดำเนินการต่อไปนี้ตลอดไป:

สร้างสตริงใหม่โดยการเปลี่ยนแต่ละตัวอักษรใน word ไปเป็นตัวอักขระถัดไปในตัวอักษรภาษาอังกฤษ แล้วผนวกเข้ากับ word เดิม

ตัวอย่างเช่น การดำเนินการบน "c" จะได้เป็น "cd" และการดำเนินการบน "zb" จะได้เป็น "zbac"
คืนค่าตัวอักขระที่ตำแหน่งที่ k ใน word หลังจากทำการดำเนินการจน word มีความยาวอย่างน้อย k ตัวอักษร
โปรดทราบว่าตัวอักขระ 'z' สามารถเปลี่ยนเป็น 'a' ในการดำเนินการนี้ได้

ตัวอย่าง 1:

Input: k = 5
Output: "b"
คำอธิบาย:
ในตอนแรก word = "a" เราต้องทำการดำเนินการสามครั้ง:

สตริงที่ได้คือ "b" word จะกลายเป็น "ab"
สตริงที่ได้คือ "bc" word จะกลายเป็น "abbc"
สตริงที่ได้คือ "bccd" word จะกลายเป็น "abbcbccd"

ตัวอย่าง 2:

Input: k = 10
Output: "c"

ข้อจำกัด:

1 <= k <= 500

อลิซและบ็อบกำลังเล่นเกม ในตอนแรก อลิซมีสตริงสตริง = "a"
คุณจะได้รับจำนวนเต็มบวก k
จากนั้น บ็อบจะขอให้อลิซดำเนินการต่อไปนี้ตลอดไป:

สร้างสตริงใหม่โดยเปลี่ยนอักขระแต่ละตัวในสตริงเป็นอักขระตัวถัดไปในตัวอักษรภาษาอังกฤษ และผนวกเข้ากับสตริงเดิม

ตัวอย่างเช่น การดำเนินการกับ "c" จะสร้าง "cd" และการดำเนินการกับ "zb" จะสร้าง "zbac"
ส่งคืนค่าของอักขระตัวที่ k^ ในสตริง หลังจากดำเนินการเพียงพอแล้วเพื่อให้สตริงมีอักขระอย่างน้อย k ตัว
โปรดทราบว่าสามารถเปลี่ยนอักขระ 'z' เป็น 'a' ในการดำเนินการได้

ตัวอย่างที่ 1:

อินพุต: k = 5
เอาต์พุต: "b"
สตริงอธิบาย:
ในตอนแรก word = "a" เราต้องทำการดำเนินการสามครั้ง:

สตริงที่สร้างคือ "b" สตริงกลายเป็น "ab"
สตริงที่สร้างคือ "bc" สตริงกลายเป็น "abbc" สตริงที่สร้างคือ "bccd" สตริงจะกลายเป็น "abbcbccd"

ตัวอย่างที่ 2:

อินพุต: k = 10
เอาต์พุต: "c"

ข้อจำกัด:

1 <= k <= 500

อลิซและบ๊อบกำลังเล่นเกม เริ่มแรกอลิซมีสตริงword = "a"
คุณจะได้รับจำนวนเต็มบวก k
ตอนนี้บ๊อบจะขอให้อลิซดำเนินการต่อไปนี้ตลอดไป:

สร้างสตริงใหม่โดยการเปลี่ยนตัวละครแต่ละตัวใน Word เป็นอักขระถัดไปในตัวอักษรภาษาอังกฤษและต่อท้ายเป็นคำดั้งเดิม

ตัวอย่างเช่นการดำเนินการบน "c" สร้าง "cd" และดำเนินการกับ "zb" สร้าง "zbcd"
ส่งคืนค่าของตัวละคร ตัวอักษรที่ k ใน Word หลังจากการดำเนินการมากพอที่จะทำให้คำมีอย่างน้อย k อักขระ
โปรดทราบว่าตัวละคร 'z' สามารถเปลี่ยนเป็น 'a' ในการดำเนินการ

ตัวอย่างที่ 1:

อินพุต: k = 5
เอาท์พุท: "b"
คำอธิบาย:
เริ่มแรก word = "a" เราต้องดำเนินการสามครั้ง:

สตริงที่สร้างขึ้นคือ "b" wordจะกลายเป็น "ab"
สตริงที่สร้างขึ้นคือ "bc", wordกลายเป็น "abbc"
สตริงที่สร้างขึ้นคือ "bccd", Word กลายเป็น "abbcbccd"

ตัวอย่างที่ 2:

อินพุต: k = 10
เอาท์พุท: "c"

ข้อ จำกัด :

1 <= k <= 500


คุณจะได้รับคำสตริงและจำนวนเต็มที่ไม่เป็นลบ k
ส่งคืนจำนวนทั้งหมดของสตริงย่อยของคำที่มีสระทุกตัว ('a', 'e', 'i', 'o' และ 'u') อย่างน้อยหนึ่งครั้งและมีพยัญชนะ k ตัวพอดี

ตัวอย่างที่ 1:

อินพุต: word = "aeioqq", k = 1
เอาต์พุต: 0
คำอธิบาย:
ไม่มีสตริงย่อยที่มีสระทุกตัว

ตัวอย่างที่ 2:

อินพุต: word = "aeiou", k = 0
เอาต์พุต: 1
คำอธิบาย:
สตริงย่อยเดียวที่มีสระทุกตัวและไม่มีพยัญชนะคือ word[0..4] ซึ่งก็คือ "aeiou"
ตัวอย่างที่ 3:

อินพุต: word = "ieaouqqieaouqq", k = 1
เอาต์พุต: 3
คำอธิบาย:
สตริงย่อยที่มีสระทุกตัวและพยัญชนะหนึ่งตัวคือ:

word[0..5] ซึ่งคือ "ieaouq"
word[6..11] ซึ่งคือ "qieaou"
word[7..12] ซึ่งคือ "ieaouq"

ข้อจำกัด:

5 <= word.length <= 250
word ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น
0 <= k <= word.length - 5


คุณจะได้รับอาร์เรย์ของจำนวนเต็ม nums ขนาด 3
ส่งคืนจำนวนสูงสุดที่เป็นไปได้ซึ่งการแสดงแบบไบนารีสามารถสร้างขึ้นได้โดยการเรียงการแสดงแบบไบนารีขององค์ประกอบทั้งหมดเป็น nums ในลำดับใดลำดับหนึ่ง
โปรดทราบว่าการแสดงแบบไบนารีของตัวเลขใดๆ จะไม่มีศูนย์นำหน้า

ตัวอย่างที่ 1:

อินพุต: nums = [1,2,3]
เอาต์พุต: 30
คำอธิบาย:
ต่อตัวเลขตามลำดับ [3, 1, 2] เพื่อให้ได้ผลลัพธ์ "11110" ซึ่งเป็นการแสดงเลขฐานสองของ 30

ตัวอย่างที่ 2:

อินพุต: nums = [2,8,16]
เอาต์พุต: 1296
คำอธิบาย:
ต่อตัวเลขตามลำดับ [2, 8, 16] เพื่อให้ได้ผลลัพธ์ "10100010000" ซึ่งเป็นการแสดงเลขฐานสองของ 1296

ข้อจำกัด:

nums.length == 3
1 <= nums[i] <= 127

คุณได้รับอาเรย์ของจำนวนเต็ม nums ขนาด 3
ส่งคืนจำนวนที่เป็นไปได้สูงสุดซึ่งแทนด้วยเลขฐานสองที่สามารถสร้างได้โดยการต่อเลขฐานสองของทุกองค์ประกอบใน nums ในบางลำดับ
โปรดทราบว่าเลขฐานสองของจำนวนใด ๆ จะไม่มีศูนย์นำหน้า

ตัวอย่างที่ 1:

Input: nums = [1,2,3]
Output: 30
คำอธิบาย:
ต่อเลขในลำดับ [3, 1, 2] เพื่อให้ได้ผลลัพธ์ "11110" ซึ่งเป็นเลขฐานสองของ 30

ตัวอย่างที่ 2:

Input: nums = [2,8,16]
Output: 1296
คำอธิบาย:
ต่อเลขในลำดับ [2, 8, 16] เพื่อให้ได้ผลลัพธ์ "10100010000" ซึ่งเป็นเลขฐานสองของ 1296

ข้อกำหนด:

nums.length == 3
1 <= nums[i] <= 127


คุณมีอาเรย์จำนวนเต็ม nums ที่มีความยาว n และอาเรย์จำนวนเต็ม queries
ให้ gcdPairs เป็นอาเรย์ที่ได้จากการคำนวณค่า GCD ของคู่ทั้งหมด (nums[i], nums[j]) ที่ 0 <= i < j < n และจัดเรียงค่าเหล่านี้ในลำดับเพิ่มขึ้น
สำหรับแต่ละ queries[i] คุณต้องหาค่าในดัชนี queries[i] ใน gcdPairs
คืนค่าอาเรย์จำนวนเต็ม answer โดยที่ answer[i] เป็นค่าที่ gcdPairs[queries[i]] สำหรับแต่ละคำถาม
คำว่า gcd(a, b) หมายถึงตัวหารร่วมมากที่สุดของ a และ b

ตัวอย่างที่ 1:

Input: nums = [2,3,4], queries = [0,2,2]
Output: [1,2,2]
คำอธิบาย:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1]
หลังจากการจัดเรียงในลำดับเพิ่มขึ้น gcdPairs = [1, 1, 2]
ดังนั้นคำตอบคือ [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2]

ตัวอย่างที่ 2:

Input: nums = [4,4,2,1], queries = [5,3,1,0]
Output: [4,2,1,1]
คำอธิบาย:
gcdPairs จัดเรียงในลำดับเพิ่มขึ้นคือ [1, 1, 1, 2, 2, 4]

ตัวอย่างที่ 3:

Input: nums = [2,2], queries = [0,0]
Output: [2,2]
คำอธิบาย:
gcdPairs = [2]

ข้อจำกัด:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ที่มีความยาว n และอาร์เรย์จำนวนเต็มสำหรับค้นหา
ให้ gcdPairs แทนอาร์เรย์ที่ได้จากการคำนวณ GCD ของคู่ที่เป็นไปได้ทั้งหมด (nums[i], nums[j]) โดยที่ 0 <= i < j < n จากนั้นเรียงลำดับค่าเหล่านี้ตามลำดับจากน้อยไปมาก
สำหรับแต่ละคิวรี query[i] คุณต้องค้นหาองค์ประกอบที่ดัชนี query[i] ใน gcdPairs
ส่งคืนอาร์เรย์จำนวนเต็ม answer โดยที่ answer[i] คือค่าที่ gcdPairs[queries[i]] สำหรับคิวรีแต่ละคิวรี
คำว่า gcd(a, b) หมายถึงตัวหารร่วมมากของ a และ b
ตัวอย่างที่ 1:

อินพุต: nums = [2,3,4], queries = [0,2,2]
เอาต์พุต: [1,2,2]
คำอธิบาย:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
หลังจากเรียงลำดับจากน้อยไปมากแล้ว gcdPairs = [1, 1, 2].
ดังนั้นคำตอบคือ [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].
ตัวอย่างที่ 2:

อินพุต: nums = [4,4,2,1], queries = [5,3,1,0]
เอาต์พุต: [4,2,1,1]
คำอธิบาย:
gcdPairs ที่เรียงลำดับจากน้อยไปมากคือ [1, 1, 1, 2, 2, 4]

ตัวอย่างที่ 3:

อินพุต: nums = [2,2], queries = [0,0]
เอาต์พุต: [2,2]
คำอธิบาย:
gcdPairs = [2]

ข้อจำกัด:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= query.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ที่มีความยาว n และอาร์เรย์จำนวนเต็มสำหรับค้นหา
ให้ gcdPairs แทนอาร์เรย์ที่ได้จากการคำนวณ GCD ของคู่ที่เป็นไปได้ทั้งหมด (nums[i], nums[j]) โดยที่ 0 <= i < j < n จากนั้นเรียงลำดับค่าเหล่านี้ตามลำดับจากน้อยไปมาก
สำหรับแต่ละคิวรี query[i] คุณต้องค้นหาองค์ประกอบที่ดัชนี query[i] ใน gcdPairs
ส่งคืนอาร์เรย์จำนวนเต็ม answer โดยที่ answer[i] คือค่าที่ gcdPairs[queries[i]] สำหรับคิวรีแต่ละคิวรี
คำว่า gcd(a, b) หมายถึงตัวหารร่วมมากของ a และ b
ตัวอย่างที่ 1:

อินพุต: nums = [2,3,4], query = [0,2,2]
เอาต์พุต: [1,2,2]
คำอธิบาย:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
หลังจากเรียงลำดับจากน้อยไปมากแล้ว gcdPairs = [1, 1, 2].
ดังนั้นคำตอบคือ [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].
ตัวอย่างที่ 2:

อินพุต: nums = [4,4,2,1], query = [5,3,1,0]
เอาต์พุต: [4,2,1,1]
คำอธิบาย:
gcdPairs ที่เรียงลำดับจากน้อยไปมากคือ [1, 1, 1, 2, 2, 4]

ตัวอย่างที่ 3:

อินพุต: nums = [2,2], query = [0,0]
เอาต์พุต: [2,2]
คำอธิบาย:
gcdPairs = [2]

ข้อจำกัด:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= query.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2


คุณจะได้รับอาร์เรย์จำนวนเต็ม nums
คุณแทนที่แต่ละองค์ประกอบใน nums ด้วยผลรวมของตัวเลข
ส่งคืนองค์ประกอบขั้นต่ำใน nums หลังจากแทนที่ทั้งหมด

ตัวอย่างที่ 1:

อินพุต: nums = [10,12,13,14]
เอาต์พุต: 1
คำอธิบาย:
nums จะกลายเป็น [1, 3, 4, 5] หลังจากการแทนที่ทั้งหมด โดยที่องค์ประกอบขั้นต่ำคือ 1

ตัวอย่างที่ 2:

อินพุต: nums = [1,2,3,4]
เอาต์พุต: 1
คำอธิบาย:
nums จะกลายเป็น [1, 2, 3, 4] หลังจากการแทนที่ทั้งหมด โดยที่องค์ประกอบขั้นต่ำคือ 1

ตัวอย่างที่ 3:

อินพุต: nums = [999,19,199]
เอาต์พุต: 10
คำอธิบาย:
nums จะกลายเป็น [27, 10, 19] หลังจากการแทนที่ทั้งหมด โดยที่องค์ประกอบขั้นต่ำคือ 10

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 10^4

คุณจะได้รับอาร์เรย์จำนวนเต็ม
คุณแทนที่แต่ละองค์ประกอบใน nums ด้วยผลรวมของตัวเลข
ส่งคืนองค์ประกอบขั้นต่ำใน nums หลังจากการเปลี่ยนทั้งหมด

ตัวอย่างที่ 1:

อินพุต: nums = [10,12,13,14]
เอาท์พุท: 1
คำอธิบาย:
nums กลายเป็น [1, 3, 4, 5] หลังจากการแทนที่ทั้งหมดด้วยองค์ประกอบขั้นต่ำ 1

ตัวอย่างที่ 2:

อินพุต: nums = [1,2,3,4]
เอาท์พุท: 1
คำอธิบาย:
nums กลายเป็น [1, 2, 3, 4] หลังจากการแทนที่ทั้งหมดด้วยองค์ประกอบขั้นต่ำ 1

ตัวอย่างที่ 3:

อินพุต: nums = [999,19,199]
เอาท์พุท: 10
คำอธิบาย:
nums กลายเป็น [27, 10, 19] หลังจากการแทนที่ทั้งหมดด้วยองค์ประกอบขั้นต่ำ 10

ข้อ จำกัด :

1 <= nums.length <= 100
1 <= nums [i] <= 10^4


คุณมีอาร์เรย์ชื่อ maximumHeight ที่แต่ละค่า maximumHeight[i] แสดงความสูงสูงสุดที่หอคอยลำดับที่ i สามารถได้รับ

หน้าที่ของคุณคือกำหนดความสูงให้แต่ละหอคอยเพื่อ:

ความสูงของหอคอยลำดับที่  i^th เป็นจำนวนเต็มบวกและไม่เกิน maximumHeight[i]
ไม่มีหอคอยสองแห่งใดที่มีความสูงเท่ากัน

คืนผลรวมความสูงของหอคอยทั้งหมดที่เป็นไปได้สูงสุด หากไม่สามารถกำหนดความสูงได้ให้คืนค่า -1

ตัวอย่างที่ 1:

Input: maximumHeight = [2,3,4,3]
Output: 10
คำอธิบาย:
เราสามารถกำหนดความสูงได้ดังนี้: [1, 2, 4, 3].

ตัวอย่างที่ 2:

Input: maximumHeight = [15,10]
Output: 25
คำอธิบาย:
เราสามารถกำหนดความสูงได้ดังนี้: [15, 10].

ตัวอย่างที่ 3:

Input: maximumHeight = [2,2,1]
Output: -1
คำอธิบาย:
ไม่สามารถกำหนดความสูงที่เป็นบวกให้แต่ละหอคอยได้โดยที่ไม่มีหอคอยสองแห่งที่มีความสูงเท่ากัน

Constraints:

1 <= maximumHeight.length <= 10^5
1 <= maximumHeight[i] <= 10^9

คุณมีอาร์เรย์ชื่อ maximumHeight ที่แต่ละค่า maximumHeight[i] แสดงความสูงสูงสุดที่หอคอยลำดับที่ i สามารถได้รับ
งานของคุณคือการกำหนดความสูงให้กับหอคอยแต่ละแห่งเพื่อให้:

ความสูงของหอคอยลำดับที่ i เป็นจำนวนเต็มบวกและไม่เกิน maximumHeight[i]
ไม่มีหอคอยสองแห่งที่มีความสูงเท่ากัน

ส่งคืนผลรวมทั้งหมดที่เป็นไปได้สูงสุดของความสูงของหอคอย หากเป็นไปไม่ได้ที่จะกำหนดความสูงให้กลับมา -1

ตัวอย่างที่ 1:

อินพุต: maximumHeight = [2,3,4,3]
เอาท์พุท: 10
คำอธิบาย:
เราสามารถกำหนดความสูงด้วยวิธีต่อไปนี้: [1, 2, 4, 3]

ตัวอย่างที่ 2:

อินพุต: maximumHeight = [15,10]
เอาท์พุท: 25
คำอธิบาย:
เราสามารถกำหนดความสูงด้วยวิธีต่อไปนี้: [15, 10]

ตัวอย่างที่ 3:

อินพุต: maximumHeight = [2,2,1]
เอาท์พุท: -1
คำอธิบาย:
เป็นไปไม่ได้ที่จะกำหนดความสูงในเชิงบวกให้กับแต่ละดัชนีเพื่อไม่ให้หอคอยสองแห่งมีความสูงเท่ากัน

ข้อ จำกัด :

1 <= maximumHeight.length <= 10^5
1 <= maximumHeight[i] <= 10^9

คุณจะได้รับอาร์เรย์สูงสุดที่มีค่าสูงสุด [i] หมายถึงความสูงสูงสุดที่หอคอย i^th สามารถกำหนดได้
งานของคุณคือการกำหนดความสูงให้กับหอคอยแต่ละแห่งเพื่อให้:

ความสูงของหอคอย i^th เป็นจำนวนเต็มบวกและไม่เกินสูงสุด [i]
ไม่มีหอคอยสองแห่งที่มีความสูงเท่ากัน

ส่งคืนผลรวมทั้งหมดที่เป็นไปได้สูงสุดของความสูงของหอคอย หากเป็นไปไม่ได้ที่จะกำหนดความสูงให้กลับมา -1

ตัวอย่างที่ 1:

อินพุต: maximumHeight = [2,3,4,3]
เอาท์พุท: 10
คำอธิบาย:
เราสามารถกำหนดความสูงด้วยวิธีต่อไปนี้: [1, 2, 4, 3]

ตัวอย่างที่ 2:

อินพุต: maximumHeight = [15,10]
เอาท์พุท: 25
คำอธิบาย:
เราสามารถกำหนดความสูงด้วยวิธีต่อไปนี้: [15, 10]

ตัวอย่างที่ 3:

อินพุต: maximumHeight = [2,2,1]
เอาท์พุท: -1
คำอธิบาย:
เป็นไปไม่ได้ที่จะกำหนดความสูงในเชิงบวกให้กับแต่ละดัชนีเพื่อไม่ให้หอคอยสองแห่งมีความสูงเท่ากัน

ข้อ จำกัด :

1 <= maximumHeight.length <= 10^5
1 <= maximumHeight[i]<= 10^9


คุณจะได้รับสตริงสองตัวคือ word1 และ word2
สตริง x จะถูกเรียกเกือบเท่ากับ y หากคุณเปลี่ยนอักขระใน x ได้สูงสุดหนึ่งตัวเพื่อให้เหมือนกับ y
ลำดับของดัชนี seq จะถูกเรียกให้ถูกต้องหาก:

ดัชนีจะเรียงลำดับจากน้อยไปมาก
การเชื่อมต่ออักขระในดัชนีเหล่านี้ใน word1 ในลำดับเดียวกันจะทำให้ได้สตริงที่เกือบเท่ากับ word2

ส่งคืนอาร์เรย์ขนาด word2.length ที่แสดงถึงลำดับดัชนีที่ถูกต้องที่เล็กที่สุดในพจนานุกรม หากไม่มีลำดับดัชนีดังกล่าว ให้ส่งคืนอาร์เรย์ว่าง
โปรดทราบว่าคำตอบจะต้องแสดงถึงอาร์เรย์ที่เล็กที่สุดในพจนานุกรม ไม่ใช่สตริงที่สอดคล้องกันซึ่งสร้างขึ้นโดยดัชนีเหล่านั้น

ตัวอย่างที่ 1:

อินพุต: word1 = "vbcca", word2 = "abc"
เอาต์พุต: [0,1,2]
คำอธิบาย:
ลำดับดัชนีที่ถูกต้องตามหลักพจนานุกรมที่เล็กที่สุดคือ [0, 1, 2]:

เปลี่ยน word1[0] เป็น 'a'
word1[1] เป็น 'b' อยู่แล้ว
word1[2] เป็น 'c' อยู่แล้ว

ตัวอย่างที่ 2:

อินพุต: word1 = "bacdc", word2 = "abc"
เอาต์พุต: [1,2,4]
คำอธิบาย:
ลำดับดัชนีที่ถูกต้องตามหลักพจนานุกรมที่เล็กที่สุดคือ [1, 2, 4]:

word1[1] เป็น 'a' อยู่แล้ว
เปลี่ยน word1[2] เป็น 'b'
word1[4] เป็น 'c' อยู่แล้ว

ตัวอย่างที่ 3:

อินพุต: word1 = "aaaaaa", word2 = "aaabc"
เอาต์พุต: []
คำอธิบาย:
ไม่มีลำดับดัชนีที่ถูกต้อง

ตัวอย่างที่ 4:

อินพุต: word1 = "abc", word2 = "ab"
เอาต์พุต: [0,1]

ข้อจำกัด:

1 <= word2.length < word1.length <= 3 * 10^5
word1 และ word2 ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณได้รับสองสตริงword1 และ word2
สตริง x เรียกว่าเกือบเท่ากับ y หากคุณสามารถเปลี่ยนได้ที่อักขระส่วนใหญ่ใน x เพื่อให้มันเหมือนกับ y
ลำดับของดัชนี seq เรียกว่าถูกต้องถ้า:

ดัชนีจะถูกจัดเรียงตามลำดับจากน้อยไปมาก
การเชื่อมต่ออักขระที่ดัชนีเหล่านี้ใน word1 ในลำดับเดียวกันส่งผลให้สตริงที่เกือบเท่ากับ word2

ส่งคืนอาร์เรย์ของขนาด word2.Length ซึ่งแสดงถึงลำดับของดัชนีที่เล็กที่สุดที่มีขนาดเล็กที่สุด หากไม่มีลำดับของดัชนีดังกล่าวให้ส่งคืนอาร์เรย์ที่ว่างเปล่า
โปรดทราบว่าคำตอบจะต้องเป็นตัวแทนของอาร์เรย์ที่เล็กที่สุดในการทำพจนานุกรมไม่ใช่สตริงที่เกี่ยวข้องที่เกิดขึ้นจากดัชนีเหล่านั้น

ตัวอย่างที่ 1:

อินพุต: word1 = "vbcca", word2 = "abc"
เอาท์พุท: [0,1,2]
คำอธิบาย:
ลำดับของดัชนีที่เล็กที่สุดที่มีขนาดเล็กที่สุดคือ [0, 1, 2]:

เปลี่ยน word1 [0] เป็น 'a'
word1 [1] 'b' อยู่แล้ว
word1 [2] 'c' อยู่แล้ว

ตัวอย่างที่ 2:

อินพุต: word1 = "bacdc", word2 = "abc"
เอาท์พุท: [1,2,4]
คำอธิบาย:
ลำดับของดัชนีที่เล็กที่สุดคือ [1, 2, 4]:

word1 [1] เป็น 'a' อยู่แล้ว
เปลี่ยน word1 [2] เป็น 'b'
word1 [4] เป็น 'c' อยู่แล้ว

ตัวอย่างที่ 3:

อินพุต: word1 = "aaaaaa", word2 = "aaabc"
เอาท์พุท: []
คำอธิบาย:
ไม่มีลำดับดัชนีที่ถูกต้อง

ตัวอย่างที่ 4:

อินพุต: word1 = "abc", word2 = "ab"
เอาท์พุท: [0,1]

ข้อ จำกัด :

1 <= word2.length <word1.length <= 3 * 10^5
word1 และ word2 ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณจะได้รับสตริง 2 ตัวคือ s และ pattern
สตริง x จะถูกเรียกเกือบเท่ากับ y หากคุณเปลี่ยนอักขระใน x ได้อย่างมากที่สุดหนึ่งตัวเพื่อให้เหมือนกับ y

ส่งคืนดัชนีเริ่มต้นที่เล็กที่สุดของสตริงย่อยใน s ที่เกือบเท่ากับ pattern หากไม่มีดัชนีดังกล่าว ให้ส่งคืน -1
สตริงย่อยคือลำดับอักขระที่อยู่ติดกันและไม่ว่างภายในสตริง

ตัวอย่างที่ 1:

อินพุต: s = "abcdefg", pattern = "bcdffg"
เอาต์พุต: 1
คำอธิบาย:
สามารถแปลงสตริงย่อย s[1..6] == "bcdefg" เป็น "bcdffg" ได้โดยเปลี่ยน s[4] เป็น "f"
ตัวอย่างที่ 2:

อินพุต: s = "abababbababa", pattern = "bacaba"
เอาต์พุต: 4
คำอธิบาย:
สามารถแปลงสตริงย่อย s[4..9] == "bababa" เป็น "bacaba" ได้โดยเปลี่ยน s[6] เป็น "c"

ตัวอย่างที่ 3:

อินพุต: s = "abcd", pattern = "dba"
เอาต์พุต: -1

ตัวอย่างที่ 4:

อินพุต: s = "dde", pattern = "d"
เอาต์พุต: 0

ข้อจำกัด:

1 <= pattern.length < s.length <= 10^5
s และ pattern ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

ติดตามผล: คุณสามารถแก้ปัญหาได้หรือไม่ หากสามารถเปลี่ยนอักขระต่อเนื่องได้ไม่เกิน k ตัว

คุณจะได้รับสองสตริง s และ pattern
สตริง x เรียกว่าเกือบเท่ากับ y หากคุณสามารถเปลี่ยนอักขระได้มากที่สุดหนึ่งตัวใน x เพื่อให้มันเหมือนกับ y
ส่งคืนดัชนีเริ่มต้นที่เล็กที่สุดของสายย่อยใน s ที่เกือบเท่ากับ pattern หากไม่มีดัชนีดังกล่าว ให้ส่งคืน -1
สตริงย่อยเป็นลำดับอักขระที่ไม่ว่างเปล่าที่ต่อเนื่องกันภายในสตริง
ตัวอย่างที่ 1:

อินพุต: s = "abcdefg", pattern = "bcdffg"
เอาท์พุท: 1
คำอธิบาย:
substring s[1..6] == "bcdefg"  สามารถแปลงเป็น "bcdffg" ได้โดยการเปลี่ยน s [4] เป็น "f"

ตัวอย่างที่ 2:

อินพุต: s = "ababbababa", pattern = "bacaba"
เอาท์พุท: 4
คำอธิบาย:
substring s [4..9] == "bababa" สามารถแปลงเป็น "bacaba" โดยการเปลี่ยน s [6] เป็น "c"

ตัวอย่างที่ 3:

อินพุต: s = "abcd", pattern = "dba"
เอาท์พุท: -1

ตัวอย่างที่ 4:

อินพุต: s = "dde", pattern = "d"
เอาท์พุท: 0

ข้อจำกัด :

1 <= pattern.length <s.length <= 10^5
s และ pattern ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

การติดตาม: คุณสามารถแก้ปัญหาได้หรือไม่ถ้าสามารถเปลี่ยนตัวละครต่อเนื่องกันได้มากที่สุด k ตัว?

คุณจะได้รับสองสายอักขระ s และ pattern
สตริง x เรียกว่าเกือบเท่ากับ y หากคุณสามารถเปลี่ยนอักขระได้มากที่สุดหนึ่งตัวใน x เพื่อให้มันเหมือนกับ y
ส่งคืนดัชนีเริ่มต้นที่เล็กที่สุดของสตริงย่อยใน s ที่เกือบเท่ากับ pattern หากไม่มีดัชนีดังกล่าว ให้ส่งคืน -1
สตริงย่อยหมายถึงลำดับอักขระที่ไม่ว่างเปล่าที่ต่อเนื่องกันภายในสตริง

ตัวอย่างที่ 1:

ป้อนข้อมูล: s = "abcdefg", pattern = "bcdffg"
เอาท์พุต: 1
คำอธิบาย:
สตริงย่อย s[1..6] == "bcdefg" ซึ่งสามารถเปลี่ยนเป็น "bcdffg" โดยการเปลี่ยนตัวอักษรที่ตำแหน่งที่ s[4] เป็น f

ตัวอย่างที่ 2:

ป้อนข้อมูล: s = "ababbababa", pattern = "bacaba"
เอาท์พุต: 4
คำอธิบาย:
สตริงย่อย s[4..9] == "bababa" ซึ่งสามารถเปลี่ยนเป็น "bacaba" โดยการเปลี่ยนตัวอักษรที่ตำแหน่งที่ s[6] เป็น c

ตัวอย่างที่ 3:

ป้อนข้อมูล: s = "abcd", pattern = "dba"
เอาท์พุต: -1

ตัวอย่างที่ 4:

ป้อนข้อมูล: s = "dde", pattern = "d"
เอาท์พุต: 0

ข้อจำกัด:
1 <= pattern.length < s.length <= 10^5
S และ pattern ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

ติดตามผล: คุณสามารถแก้ปัญหานี้ได้หรือไม่ หากสามารถเปลี่ยนอักขระที่ต่อเนื่องกันได้ไม่เกิน K ตัว?