คุณได้รับจำนวนเต็มบวก n และ m
กำหนดจำนวนเต็มสองค่า num1 และ num2 ดังนี้:

num1: ผลรวมของจำนวนเต็มทั้งหมดในช่วง [1, n] ที่ไม่สามารถหารด้วย m ลงตัว
num2: ผลรวมของจำนวนเต็มทั้งหมดในช่วง [1, n] ที่สามารถหารด้วย m ลงตัว

คืนค่า num1 - num2

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

Input: n = 10, m = 3
Output: 19
คำอธิบาย: ในตัวอย่างที่กำหนด:
- จำนวนเต็มในช่วง [1, 10] ที่ไม่สามารถหารด้วย 3 ลงตัวคือ [1,2,4,5,7,8,10], num1 คือผลรวมของจำนวนเหล่านี้ = 37
- จำนวนเต็มในช่วง [1, 10] ที่สามารถหารด้วย 3 ลงตัวคือ [3,6,9], num2 คือผลรวมของจำนวนเหล่านี้ = 18
เราคืนค่า 37 - 18 = 19 เป็นคำตอบ

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

Input: n = 5, m = 6
Output: 15
คำอธิบาย: ในตัวอย่างที่กำหนด:
- จำนวนเต็มในช่วง [1, 5] ที่ไม่สามารถหารด้วย 6 ลงตัวคือ [1,2,3,4,5], num1 คือผลรวมของจำนวนเหล่านี้ = 15
- จำนวนเต็มในช่วง [1, 5] ที่สามารถหารด้วย 6 ลงตัวคือ [], num2 คือผลรวมของจำนวนเหล่านี้ = 0
เราคืนค่า 15 - 0 = 15 เป็นคำตอบ

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

Input: n = 5, m = 1
Output: -15
คำอธิบาย: ในตัวอย่างที่กำหนด:
- จำนวนเต็มในช่วง [1, 5] ที่ไม่สามารถหารด้วย 1 ลงตัวคือ [], num1 คือผลรวมของจำนวนเหล่านี้ = 0
- จำนวนเต็มในช่วง [1, 5] ที่สามารถหารด้วย 1 ลงตัวคือ [1,2,3,4,5], num2 คือผลรวมของจำนวนเหล่านี้ = 15
เราคืนค่า 0 - 15 = -15 เป็นคำตอบ

ข้อจำกัด:

1 <= n, m <= 1000

คุณได้รับจำนวนเต็มบวก n และ m
กำหนดจำนวนเต็มสองจำนวน คือ num1 และ num2 ดังต่อไปนี้:

num1: ผลรวมของจำนวนเต็มทั้งหมดในช่วง [1, n] ที่ไม่หารด้วย m ลงตัว
num2: ผลรวมของจำนวนเต็มทั้งหมดในช่วง [1, n] ที่หารด้วย m ลงตัว

ส่งคืนจำนวนเต็ม num1 - num2

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

อินพุต: n = 10, m = 3
เอาต์พุต: 19
คำอธิบาย: ในตัวอย่างที่กำหนด:
- จำนวนเต็มในช่วง [1, 10] ที่หารด้วย 3 ลงตัวคือ [1,2,4,5,7,8,10] โดย num1 คือผลรวมของจำนวนเต็มเหล่านั้น = 37
- จำนวนเต็มในช่วง [1, 10] ที่หารด้วย 3 ลงตัวคือ [3,6,9] โดย num2 คือผลรวมของจำนวนเต็มเหล่านั้น = 18
เราคืนค่า 37 - 18 = 19 เป็นคำตอบ

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

อินพุต: n = 5, m = 6
เอาต์พุต: 15
คำอธิบาย: ในตัวอย่างที่กำหนด:
- จำนวนเต็มในช่วง [1, 5] ที่หารด้วย 6 ไม่ลงตัวคือ [1,2,3,4,5] โดยที่ num1 คือผลรวมของจำนวนเต็มเหล่านั้น = 15
- จำนวนเต็มในช่วง [1, 5] ที่หารด้วย 6 ลงตัวคือ [] โดยที่ num2 คือผลรวมของจำนวนเต็มเหล่านั้น = 0
เราคืนค่า 15 - 0 = 15 เป็นคำตอบ

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

อินพุต: n = 5, m = 1
เอาต์พุต: -15
คำอธิบาย: ในตัวอย่างที่กำหนด:
- จำนวนเต็มในช่วง [1, 5] ที่ไม่หารด้วย 1 ได้คือ [], num1 คือผลรวมของจำนวนเต็มเหล่านั้น = 0
- จำนวนเต็มในช่วง [1, 5] ที่หารด้วย 1 ได้คือ [1,2,3,4,5], num2 คือผลรวมของจำนวนเต็มเหล่านั้น = 15
เราคืนค่า 0 - 15 = -15 เป็นคำตอบ

ข้อจำกัด:

1 <= n, m <= 1000


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

แต่ละสายย่อยมีความยาวเป็นเลขคู่
แต่ละสายย่อยมีเพียง 1 หรือเพียง 0 เท่านั้น

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

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

อินพุต: s = "1001"
เอาท์พุท: 2
คำอธิบาย: เราเปลี่ยน s [1] เป็น 1 และ s [3] เป็น 0 เพื่อรับสตริง "1100"
จะเห็นได้ว่าสตริง "1100" นั้นสวยงามเพราะเราสามารถแบ่งมันเป็น "11 | 00"
สามารถพิสูจน์ได้ว่า 2 คือจำนวนการเปลี่ยนแปลงขั้นต่ำที่จำเป็นในการทำให้สตริงสวยงาม

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

อินพุต: s = "10"
เอาท์พุท: 1
คำอธิบาย: เราเปลี่ยน s [1] เป็น 1 เพื่อรับสตริง "11"
จะเห็นได้ว่าสตริง "11" นั้นสวยงามเพราะเราสามารถแบ่งมันเป็น "11"
สามารถพิสูจน์ได้ว่า 1 คือจำนวนการเปลี่ยนแปลงขั้นต่ำที่จำเป็นในการทำให้สตริงสวยงาม

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

อินพุต: s = "0000"
เอาท์พุท: 0
คำอธิบาย: เราไม่จำเป็นต้องทำการเปลี่ยนแปลงใด ๆ เนื่องจากสตริง "0000" นั้นสวยงามอยู่แล้ว

ข้อ จำกัด :

2 <= s.length <= 10^5
s มีความยาวเป็นเลขคู่
s [i] คือ '0' หรือ '1'

คุณจะได้รับสตริงไบนารี s ที่มีดัชนี 0 ที่มีความยาวเท่ากัน
สตริงจะสวยงามหากสามารถแบ่งสตริงออกเป็นสตริงย่อยหนึ่งสตริงหรือมากกว่านั้นได้ โดยที่:

สตริงย่อยแต่ละสตริงมีความยาวเท่ากัน
สตริงย่อยแต่ละสตริงมีเฉพาะ 1 หรือ 0 เท่านั้น

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

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

อินพุต: s = "1001"
เอาต์พุต: 2
คำอธิบาย: เราเปลี่ยน s[1] เป็น 1 และ s[3] เป็น 0 เพื่อให้ได้สตริง "1100"
จะเห็นได้ว่าสตริง "1100" นั้นสวยงามเพราะเราสามารถแบ่งสตริงออกเป็น "11|00" ได้
สามารถพิสูจน์ได้ว่า 2 คือจำนวนการเปลี่ยนแปลงขั้นต่ำที่จำเป็นเพื่อให้สตริงสวยงาม
ตัวอย่างที่ 2:

อินพุต: s = "10"
เอาต์พุต: 1
คำอธิบาย: เราเปลี่ยน s[1] เป็น 1 เพื่อให้ได้สตริง "11"
จะเห็นได้ว่าสตริง "11" นั้นสวยงามเพราะเราสามารถแบ่งสตริงนี้ออกเป็น "11" ได้
สามารถพิสูจน์ได้ว่า 1 คือจำนวนการเปลี่ยนแปลงขั้นต่ำที่จำเป็นเพื่อให้สตริงสวยงาม

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

อินพุต: s = "0000"
เอาต์พุต: 0
คำอธิบาย: เราไม่จำเป็นต้องทำการเปลี่ยนแปลงใดๆ เนื่องจากสตริง "0000" นั้นสวยงามอยู่แล้ว

ข้อจำกัด:

2 <= s.length <= 10^5
s มีความยาวเท่ากัน
s[i] คือ '0' หรือ '1'


คุณจะได้รับอาร์เรย์ที่มีดัชนีเป็น 0 จำนวนเต็ม
ไตรเพล็ตของดัชนี (i, j, k) จะเป็นภูเขาถ้า:

i < j < k
nums[i] < nums[j] และ nums[k] < nums[j]

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

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

อินพุต: nums = [8,6,1,5,3]
เอาต์พุต: 9
คำอธิบาย: ทริปเล็ต (2, 3, 4) เป็นทริปเล็ตภูเขาของผลรวม 9 เนื่องจาก:
- 2 < 3 < 4
- nums[2] < nums[3] และ nums[4] < nums[3]
และผลรวมของทริปเล็ตนี้คือ nums[2] + nums[3] + nums[4] = 9 แสดงให้เห็นว่าไม่มีทริปเล็ตภูเขาใดที่ผลรวมน้อยกว่า 9

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

อินพุต: nums = [5,4,8,7,10,2]
เอาต์พุต: 13
คำอธิบาย: ทริปเล็ต (1, 3, 5) เป็นทริปเล็ตภูเขาของผลรวม 13 เนื่องจาก:
- 1 < 3 < 5
- nums[1] < nums[3] และ nums[5] < nums[3]
และผลรวมของไตรเพล็ตนี้คือ nums[1] + nums[3] + nums[5] = 13 แสดงให้เห็นว่าไม่มีไตรเพล็ตภูเขาใดที่ผลรวมน้อยกว่า 13

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

อินพุต: nums = [6,5,4,3,4,5]
เอาต์พุต: -1
คำอธิบาย: แสดงให้เห็นว่าไม่มีไตรเพล็ตภูเขาใน nums

ข้อจำกัด:

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

คุณจะได้รับจํานวนเต็มอาร์เรย์ที่มีดัชนี 0
แฝดสามของดัชนี (i, j, k) เป็นภูเขาหาก:

i< j < k
nums[i] < nums[j] และ nums[k] < nums[j]

ส่งคืนผลรวมขั้นต่ําที่เป็นไปได้ของแฝดสามภูเขาของ nums หากไม่มีแฝดสามดังกล่าวให้ส่งคืน -1

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

อินพุต: nums = [8,6,1,5,3]
เอาท์พุต: 9
คําอธิบาย: แฝดสาม (2, 3, 4) เป็นแฝดสามภูเขาของผลรวม 9 เนื่องจาก:
- 2 < 3 < 4
- nums[2] < nums[3] และ nums[4] < nums[3]
และผลรวมของทริปเปิลต์นี้คือ nums[2] + nums[3] + nums[4] = 9 สามารถแสดงให้เห็นได้ว่าไม่มีแฝดสามภูเขาที่ผลรวมน้อยกว่า 9

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

อินพุต: nums = [5,4,8,7,10,2]
เอาท์พุต: 13
คําอธิบาย: แฝดสาม (1, 3, 5) เป็นแฝดสามภูเขาของผลรวม 13 เนื่องจาก:
- 1 < 3 < 5
- nums[1] < nums[3] และ nums[5] < nums[3]
และผลรวมของทริปเปิลเลตนี้คือ nums[1] + nums[3] + nums[5] = 13 สามารถแสดงให้เห็นได้ว่าไม่มีแฝดสามภูเขาที่มีผลรวมน้อยกว่า 13

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

อินพุต: nums = [6,5,4,3,4,5]
เอาท์พุต: -1
คําอธิบาย: สามารถแสดงได้ว่าไม่มีแฝดสามภูเขาในจํานวน

ข้อจํากัด:

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


คุณได้รับอาเรย์จำนวนเต็ม nums ที่มีดัชนีเริ่มต้นที่ 0 และจำนวนเต็ม k
K-or ของ nums เป็นจำนวนเต็มที่ไม่เป็นลบที่สนองเงื่อนไขดังต่อไปนี้:

บิตที่ i^th ถูกตั้งค่าใน K-or ก็ต่อเมื่อมีอย่างน้อย k สมาชิกของ nums ซึ่งบิต i ถูกตั้งค่า

ส่งคืน K-or ของ nums
โปรดทราบว่าบิต i ถูกตั้งค่าใน x ถ้า (2^i AND x) == 2^i โดยที่ AND หมายถึงตัวดำเนินการ AND เชิงบิต

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

Input: nums = [7,12,9,8,9,15], k = 4
Output: 9
คำอธิบาย: บิต 0 ถูกตั้งค่าใน nums[0], nums[2], nums[4], และ nums[5]
บิต 1 ถูกตั้งค่าใน nums[0], และ nums[5]
บิต 2 ถูกตั้งค่าใน nums[0], nums[1], และ nums[5]
บิต 3 ถูกตั้งค่าใน nums[1], nums[2], nums[3], nums[4], และ nums[5]
เฉพาะบิต 0 และ 3 ถูกตั้งค่าในอย่างน้อย k สมาชิกของอาเรย์, และบิต i >= 4 ไม่ถูกตั้งค่าในสมาชิกใดๆ ของอาเรย์ ด้วยเหตุนี้ คำตอบคือ 2^0 + 2^3 = 9

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

Input: nums = [2,12,1,11,4,5], k = 6
Output: 0
คำอธิบาย: เนื่องจาก k == 6 == nums.length, 6-or ของอาเรย์คือเท่ากับ AND เชิงบิตของสมาชิกทั้งหมดด้วยกัน ด้วยเหตุนี้ คำตอบคือ 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0

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

Input: nums = [10,8,5,9,11,6,8], k = 1
Output: 15
คำอธิบาย: เนื่องจาก k == 1, 1-or ของอาเรย์คือเท่ากับ OR เชิงบิตของสมาชิกทั้งหมดด้วยกัน ด้วยเหตุนี้ คำตอบคือ 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15

Constraints:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ที่มีดัชนี 0 และจำนวนเต็ม k
K-or ของ nums เป็นจำนวนเต็มที่ไม่เป็นลบซึ่งเป็นไปตามเงื่อนไขต่อไปนี้:

บิตที่ i จะถูกตั้งค่าใน K-or ก็ต่อเมื่อมีองค์ประกอบของ nums อย่างน้อย k องค์ประกอบที่บิต i ถูกตั้งค่า

ส่งคืน K-or ของ nums
โปรดทราบว่าบิต i ถูกตั้งค่าใน x ถ้า (2^i AND x) == 2^i โดยที่ AND คือตัวดำเนินการ AND ตามบิต

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

อินพุต: nums = [7,12,9,8,9,15], k = 4
เอาต์พุต: 9
คำอธิบาย: บิต 0 ถูกตั้งค่าที่ nums[0], nums[2], nums[4] และ nums[5]
บิต 1 ถูกตั้งค่าที่ nums[0] และ nums[5] บิต 2 ถูกกำหนดไว้ที่ nums[0], nums[1] และ nums[5]
บิต 3 ถูกกำหนดไว้ที่ nums[1], nums[2], nums[3], nums[4] และ nums[5]
มีเพียงบิต 0 และ 3 เท่านั้นที่ถูกกำหนดไว้ในองค์ประกอบอย่างน้อย k รายการของอาร์เรย์ และบิต i >= 4 จะไม่ถูกกำหนดไว้ในองค์ประกอบใดๆ ของอาร์เรย์ ดังนั้น คำตอบคือ 2^0 + 2^3 = 9

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

อินพุต: nums = [2,12,1,11,4,5], k = 6
เอาต์พุต: 0
คำอธิบาย: เนื่องจาก k == 6 == nums.length 6-or ของอาร์เรย์จึงเท่ากับ AND ตามบิตขององค์ประกอบทั้งหมด ดังนั้นคำตอบคือ 2 และ 12 และ 1 และ 11 และ 4 และ 5 = 0

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

อินพุต: nums = [10,8,5,9,11,6,8], k = 1
เอาต์พุต: 15
คำอธิบาย: เนื่องจาก k == 1 1-or ของอาร์เรย์จึงเท่ากับ OR ตามบิตขององค์ประกอบทั้งหมด ดังนั้นคำตอบคือ 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15.

ข้อจำกัด:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

คุณจะได้รับอาร์เรย์จำนวนเต็มที่ถูกจัดทำดัชนีเริ่มต้นที่ 0 และจำนวนเต็ม k
K-or ของ NUMS เป็นจำนวนเต็มที่ไม่เป็นลบซึ่งเป็นไปตามสิ่งต่อไปนี้:

บิตที่ i ถูกตั้งค่าใน k-or ถ้าและเฉพาะในกรณีที่มีอย่างน้อย k องค์ประกอบ ของ nums ที่ฉันตั้งค่าบิต

ส่งคืน k-or ของ nums
โปรดทราบว่าฉันถูกตั้งค่าใน x ถ้า (2^i และ x) == 2^i, ที่ไหนและเป็นบิตและตัวดำเนินการ

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

อินพุต: nums = [7,12,9,8,9,15], k = 4
เอาท์พุท: 9
คำอธิบาย: บิต 0 ถูกตั้งค่าที่ nums[0], nums[2], nums[4], และ  nums[5].
บิต 1 ถูกตั้งค่าที่ nums[0], และ  nums[5].
บิต 2 ถูกตั้งค่าที่ nums[0], nums[1], และ nums[5].
บิต 3 ถูกตั้งค่าที่  nums[1], nums[2], nums[3], nums[4], และ  nums[5].
บิต 0 และ 3 เท่านั้นที่ตั้งอยู่ในอย่างน้อย k องค์ประกอบ ของอาร์เรย์และบิต i >= 4 ไม่ได้ถูกตั้งค่าในองค์ประกอบของอาร์เรย์ใด ๆ ดังนั้นคำตอบคือ 2^0 + 2^3 = 9

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

อินพุต: nums = [2,12,1,11,4,5], k = 6
เอาท์พุท: 0
คำอธิบาย: เนื่องจาก k == 6 == nums.length, 6-or ของอาร์เรย์เท่ากับ bitwise และขององค์ประกอบทั้งหมด ดังนั้นคำตอบคือ 2 และ 12 และ 1 และ 11 และ 4 และ 5 = 0

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

อินพุต: nums = [10,8,5,9,11,6,8], k = 1
เอาท์พุท: 15
คำอธิบาย: เนื่องจาก k == 1 1-or ของอาร์เรย์จะเท่ากับ bitwise หรือขององค์ประกอบทั้งหมด ดังนั้นคำตอบคือ 10 หรือ 8 หรือ 5 หรือ 9 หรือ 11 หรือ 6 หรือ 8 = 15

ข้อ จำกัด :

1 <= nums.length <= 50
0 <= nums [i] <2^31
1 <= k <= nums.length


คุณได้รับอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นจาก 0 ชื่อว่า nums
ลำดับย่อยของ nums ที่มีความยาว k และประกอบด้วยดัชนี i_0 < i_1 < ... < i_k-1 เป็นลำดับสมดุลหากเป็นไปตามเงื่อนไขต่อไปนี้:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, สำหรับทุก j ในช่วง [1, k - 1]

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

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

Input: nums = [3,3,5,6]
Output: 14
คำอธิบาย: ในตัวอย่างนี้ ลำดับย่อย [3,5,6] ซึ่งประกอบด้วยดัชนี 0, 2 และ 3 สามารถถูกเลือกได้
nums[2] - nums[0] >= 2 - 0
nums[3] - nums[2] >= 3 - 2
ดังนั้นมันเป็นลำดับย่อยที่สมดุล และผลรวมของมันคือค่าผลรวมสูงสุดในบรรดาลำดับย่อยที่สมดุลของ nums
ลำดับย่อยที่ประกอบด้วยดัชนี 1, 2 และ 3 ก็เป็นลำดับที่ถูกต้อง
สามารถแสดงให้เห็นว่ามันเป็นไปไม่ได้ที่จะได้รับลำดับย่อยที่สมดุลที่มีผลรวมมากกว่า 14

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

Input: nums = [5,-1,-3,8]
Output: 13
คำอธิบาย: ในตัวอย่างนี้ ลำดับย่อย [5,8] ซึ่งประกอบด้วยดัชนี 0 และ 3 สามารถถูกเลือกได้
nums[3] - nums[0] >= 3 - 0
ดังนั้นมันเป็นลำดับย่อยที่สมดุล และผลรวมของมันคือค่าผลรวมสูงสุดในบรรดาลำดับย่อยที่สมดุลของ nums
สามารถแสดงให้เห็นว่ามันเป็นไปไม่ได้ที่จะได้รับลำดับย่อยที่สมดุลที่มีผลรวมมากกว่า 13

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

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

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 nums
ลำดับย่อยของ nums ที่มีความยาว k และประกอบด้วยดัชนี i_0 < i_1 < ... < i_k-1 จะสมดุลหากเป็นไปตามนี้:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1 สำหรับทุก j ในช่วง [1, k - 1]

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

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

อินพุต: nums = [3,3,5,6]
เอาต์พุต: 14
คำอธิบาย: ในตัวอย่างนี้ สามารถเลือกลำดับย่อย [3,5,6] ที่ประกอบด้วยดัชนี 0, 2 และ 3 ได้
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
ดังนั้น จึงเป็นลำดับย่อยที่สมดุล และผลรวมของมันเป็นค่าสูงสุดในบรรดาลำดับย่อยที่สมดุลของ nums
ลำดับย่อยที่ประกอบด้วยดัชนี 1, 2 และ 3 ก็ถูกต้องเช่นกัน แสดงให้เห็นว่าไม่สามารถหาลำดับย่อยที่สมดุลด้วยผลรวมที่มากกว่า 14 ได้
ตัวอย่างที่ 2:

อินพุต: nums = [5,-1,-3,8]
เอาต์พุต: 13
คำอธิบาย: ในตัวอย่างนี้ สามารถเลือกลำดับย่อย [5,8] ที่ประกอบด้วยดัชนี 0 และ 3 ได้
nums[3] - nums[0] >= 3 - 0
ดังนั้น จึงเป็นลำดับย่อยที่สมดุล และผลรวมของมันคือค่าสูงสุดในบรรดาลำดับย่อยที่สมดุลของ nums
แสดงให้เห็นว่าไม่สามารถหาลำดับย่อยที่สมดุลด้วยผลรวมที่มากกว่า 13 ได้

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

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

ข้อจำกัด:

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


มี n ทีมที่นับจาก 0 ถึง n - 1 ในการแข่งขัน
ให้กริดเมทริกซ์บูลีน 2 มิติที่มีดัชนี 0 ขนาด n * n สำหรับ i, j ทั้งหมดที่ 0 <= i, j <= n - 1 และ i != j ทีม i จะแข็งแกร่งกว่าทีม j หาก grid[i][j] == 1 มิฉะนั้น ทีม j จะแข็งแกร่งกว่าทีม i

ทีม a จะเป็นแชมเปี้ยนของการแข่งขันหากไม่มีทีม b ที่แข็งแกร่งกว่าทีม a

ส่งคืนทีมที่จะเป็นแชมเปี้ยนของการแข่งขัน

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

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

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

ข้อจำกัด:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] จะเป็น 0 หรือ 1
สำหรับ i ทุกอัน grid[i][i] จะเป็น 0
สำหรับ i, j ทั้งหมดที่ i ไม่เท่ากับ j, grid[i][j] ไม่เท่ากับ grid[j][i]
อินพุตจะถูกสร้างขึ้นเพื่อให้หากทีม a แข็งแกร่งกว่าทีม b และทีม b แข็งแกร่งกว่าทีม c แสดงว่าทีม a แข็งแกร่งกว่าทีม c

มี n ทีมที่นับจาก 0 ถึง n - 1 ในการแข่งขัน
ให้กริดเมทริกซ์บูลีน 2 มิติที่มีดัชนี 0 ขนาด n * n สำหรับ i, j ทั้งหมดที่ 0 <= i, j <= n - 1 และ i != j ทีม i จะแข็งแกร่งกว่าทีม j หาก grid[i][j] == 1 มิฉะนั้น ทีม j จะแข็งแกร่งกว่าทีม i
ทีม a จะเป็นแชมเปี้ยนของการแข่งขันหากไม่มีทีม b ที่แข็งแกร่งกว่าทีม a
ส่งคืนทีมที่จะเป็นแชมเปี้ยนของการแข่งขัน

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

อินพุต: grid = [[0,1],[0,0]]
เอาต์พุต: 0
คำอธิบาย: มีสองทีมในการแข่งขันนี้
grid[0][1] == 1 หมายความว่าทีม 0 แข็งแกร่งกว่าทีม 1 ดังนั้นทีม 0 จะเป็นแชมเปี้ยน

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

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

ข้อจำกัด:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] จะเป็น 0 หรือ 1
สำหรับ i ทุกอัน grid[i][i] จะเป็น 0
สำหรับ i, j ทั้งหมดที่ i != j, grid[i][j]!= grid[j][i]
อินพุตจะถูกสร้างขึ้นเพื่อให้หากทีม a แข็งแกร่งกว่าทีม b และทีม b แข็งแกร่งกว่าทีม c แสดงว่าทีม a แข็งแกร่งกว่าทีม c


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

nums1[n - 1] เท่ากับค่าที่มากที่สุดในบรรดาทุกองค์ประกอบของ nums1 กล่าวคือ nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1])
nums2[n - 1] เท่ากับค่าที่มากที่สุดในบรรดาทุกองค์ประกอบของ nums2 กล่าวคือ nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1])

ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อให้เป็นไปตามทั้งสองเงื่อนไข หรือ -1 ถ้าเป็นไปไม่ได้ที่จะทำให้ทั้งสองเงื่อนไขเป็นจริง

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

Input: nums1 = [1,2,7], nums2 = [4,5,3]
Output: 1
คำอธิบาย: ในตัวอย่างนี้ สามารถทำการดำเนินการโดยใช้ดัชนี i = 2
เมื่อ nums1[2] และ nums2[2] ถูกสลับกัน nums1 จะกลายเป็น [1,2,3] และ nums2 จะกลายเป็น [4,5,7]
ทั้งสองเงื่อนไขจะเป็นจริง
สามารถแสดงได้ว่าจำนวนการดำเนินการขั้นต่ำที่ต้องทำคือ 1
ดังนั้นคำตอบคือ 1

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

Input: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Output: 2
คำอธิบาย: ในตัวอย่างนี้ การดำเนินการต่อไปนี้สามารถทำได้:
การดำเนินการแรกโดยใช้ดัชนี i = 4
เมื่อ nums1[4] และ nums2[4] ถูกสลับกัน nums1 จะกลายเป็น [2,3,4,5,4] และ nums2 จะกลายเป็น [8,8,4,4,9]
การดำเนินการอื่นโดยใช้ดัชนี i = 3
เมื่อ nums1[3] และ nums2[3] ถูกสลับกัน nums1 จะกลายเป็น [2,3,4,4,4] และ nums2 จะกลายเป็น [8,8,4,5,9]
ทั้งสองเงื่อนไขจะเป็นจริง
สามารถแสดงได้ว่าจำนวนการดำเนินการขั้นต่ำที่ต้องทำคือ 2
ดังนั้นคำตอบคือ 2

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

Input: nums1 = [1,5,4], nums2 = [2,5,3]
Output: -1
คำอธิบาย: ในตัวอย่างนี้ เป็นไปไม่ได้ที่จะทำให้ทั้งสองเงื่อนไขเป็นจริง
ดังนั้นคำตอบคือ -1

ข้อจำกัด:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9

คุณจะได้รับอาร์เรย์จำนวนเต็ม 0 ดัชนีสองตัว, nums1 และ nums2 ทั้งคู่มีความยาว n
คุณสามารถดำเนินการชุดปฏิบัติการได้ (อาจไม่มี)
ในการดำเนินการคุณเลือก index i ในช่วง [0, n - 1] และสลับค่าของ nums1 [i] และ nums2 [i]
งานของคุณคือการค้นหาจำนวนขั้นต่ำของการดำเนินการที่จำเป็นเพื่อตอบสนองเงื่อนไขต่อไปนี้:

nums1 [n - 1] เท่ากับค่าสูงสุดระหว่างองค์ประกอบทั้งหมดของ nums1, เช่น nums1 [n - 1] = สูงสุด (nums1 [0], nums1 [1], ... , nums1 [n - 1]) .
nums2 [n - 1] เท่ากับค่าสูงสุดระหว่างองค์ประกอบทั้งหมดของ nums2, เช่น nums2 [n - 1] = สูงสุด (nums2 [0], nums2 [1], ... , nums2 [n - 1]) .

ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการปฏิบัติตามเงื่อนไขทั้งสองหรือ -1 หากเป็นไปไม่ได้ที่จะตอบสนองทั้งสองเงื่อนไข

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

อินพุต: nums1 = [1,2,7], nums2 = [4,5,3]
เอาท์พุท: 1
คำอธิบาย: ในตัวอย่างนี้การดำเนินการสามารถทำได้โดยใช้ดัชนี i = 2
เมื่อ nums1 [2] และ nums2 [2] ถูกสลับ nums1 จะกลายเป็น [1,2,3] และ nums2 จะกลายเป็น [4,5,7]
ทั้งสองเงื่อนไขมีความพึงพอใจ
สามารถพิสูจน์ได้ว่าจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการดำเนินการคือ 1
ดังนั้นคำตอบคือ 1.

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

อินพุต: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
เอาท์พุท: 2
คำอธิบาย: ในตัวอย่างนี้การดำเนินการต่อไปนี้สามารถทำได้:
การดำเนินการครั้งแรกโดยใช้ดัชนี i = 4
เมื่อ nums1 [4] และ nums2 [4] ถูกเปลี่ยน nums1 จะกลายเป็น [2,3,4,5,4] และ nums2 จะกลายเป็น [8,8,4,4,9]
การดำเนินการอื่นโดยใช้ดัชนี i = 3
เมื่อ nums1 [3] และ nums2 [3] ถูกเปลี่ยน nums1 จะกลายเป็น [2,3,4,4,4] และ nums2 จะกลายเป็น [8,8,4,5,9]
ทั้งสองเงื่อนไขมีความพึงพอใจ
สามารถพิสูจน์ได้ว่าจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการดำเนินการคือ 2
ดังนั้นคำตอบคือ 2

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

อินพุต: nums1 = [1,5,4], nums2 = [2,5,3]
เอาท์พุท: -1
คำอธิบาย: ในตัวอย่างนี้มันเป็นไปไม่ได้ที่จะตอบสนองทั้งสองเงื่อนไข
ดังนั้นคำตอบคือ -1

ข้อ จำกัด :

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1 [i] <= 10^9
1 <= nums2 [i] <= 10^9

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

nums1[n - 1] เท่ากับค่าสูงสุดในบรรดาองค์ประกอบทั้งหมดของ nums1 นั่นคือ nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]) nums2[n - 1] เท่ากับค่าสูงสุดในบรรดาองค์ประกอบทั้งหมดของ nums2 นั่นคือ nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1])

ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อตอบสนองเงื่อนไขทั้งสอง หรือ -1 หากไม่สามารถตอบสนองเงื่อนไขทั้งสองได้

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

อินพุต: nums1 = [1,2,7], nums2 = [4,5,3]
เอาต์พุต: 1
คำอธิบาย: ในตัวอย่างนี้ การดำเนินการสามารถทำได้โดยใช้ดัชนี i = 2
เมื่อ nums1[2] และ nums2[2] สลับกัน nums1 จะกลายเป็น [1,2,3] และ nums2 จะกลายเป็น [4,5,7]
ตอนนี้ตอบสนองเงื่อนไขทั้งสองแล้ว จะเห็นได้ว่าจำนวนการดำเนินการขั้นต่ำที่จำเป็นต้องดำเนินการคือ 1
ดังนั้นคำตอบคือ 1

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

อินพุต: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
เอาต์พุต: 2
คำอธิบาย: ในตัวอย่างนี้ การดำเนินการต่อไปนี้สามารถดำเนินการได้:
การดำเนินการแรกโดยใช้ดัชนี i = 4
เมื่อสลับ nums1[4] และ nums2[4] nums1 จะกลายเป็น [2,3,4,5,4] และ nums2 จะกลายเป็น [8,8,4,4,9]
การดำเนินการอื่นโดยใช้ดัชนี i = 3
เมื่อสลับ nums1[3] และ nums2[3] nums1 จะกลายเป็น [2,3,4,4,4] และ nums2 จะกลายเป็น [8,8,4,5,9]
ตอนนี้ทั้งสองเงื่อนไขเป็นไปตามนั้นแล้ว จะเห็นได้ว่าจำนวนการดำเนินการขั้นต่ำที่จำเป็นต้องดำเนินการคือ 2
ดังนั้นคำตอบคือ 2

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

อินพุต: nums1 = [1,5,4], nums2 = [2,5,3]
เอาต์พุต: -1
คำอธิบาย: ในตัวอย่างนี้ ไม่สามารถตอบสนองเงื่อนไขทั้งสองได้

ดังนั้นคำตอบคือ -1

ข้อจำกัด:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9


กำหนดจำนวนเต็มสามจำนวน a, b และ n ให้คืนค่าสูงสุดของ (a XOR x) * (b XOR x) โดยที่ 0 <= x < 2^n
เนื่องจากคำตอบอาจมากเกินไป ให้คืนค่าโมดูโล 10^9 + 7
โปรดทราบว่า XOR คือการดำเนินการ XOR แบบบิต

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

อินพุต: a = 12, b = 5, n = 4
เอาต์พุต: 98
คำอธิบาย: สำหรับ x = 2, (a XOR x) = 14 และ (b XOR x) = 7 ดังนั้น (a XOR x) * (b XOR x) = 98
สามารถแสดงให้เห็นได้ว่า 98 เป็นค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับ 0 <= x < 2^n ทั้งหมด

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

อินพุต: a = 6, b = 7 , n = 5
เอาต์พุต: 930
คำอธิบาย: สำหรับ x = 25, (a XOR x) = 31 และ (b XOR x) = 30 ดังนั้น (a XOR x) * (b XOR x) = 930
สามารถแสดงให้เห็นได้ว่า 930 เป็นค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับ 0 <= x < 2^n ทั้งหมด
ตัวอย่างที่ 3:

อินพุต: a = 1, b = 6, n = 3
เอาต์พุต: 12
คำอธิบาย: สำหรับ x = 5, (a XOR x) = 4 และ (b XOR x) = 3 ดังนั้น (a XOR x) * (b XOR x) = 12
สามารถแสดงให้เห็นได้ว่า 12 เป็นค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับ 0 <= x < 2^n ทั้งหมด

ข้อจำกัด:

0 <= a, b < 2^50
0 <= n <= 50

ให้จำนวนเต็มสามตัว a, b และ n จงหาค่ามากสุดของ (a XOR x) * (b XOR x) เมื่อ 0 <= x < 2^n
เนื่องจากคำตอบอาจมีค่ามากเกินไป ให้หาผลลัพธ์แบบโมดูโล 10^9 + 7
หมายเหตุ: XOR คือการดำเนินการทางบิต XOR

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

Input: a = 12, b = 5, n = 4
Output: 98
คำอธิบาย: สำหรับ x = 2, (a XOR x) = 14 และ (b XOR x) = 7 ดังนั้น (a XOR x) * (b XOR x) = 98
ซึ่งสามารถแสดงให้เห็นได้ว่า 98 เป็นค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับทั้งหมด 0 <= x < 2^n

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

Input: a = 6, b = 7, n = 5
Output: 930
คำอธิบาย: สำหรับ x = 25, (a XOR x) = 31 และ (b XOR x) = 30 ดังนั้น (a XOR x) * (b XOR x) = 930
ซึ่งสามารถแสดงให้เห็นได้ว่า 930 เป็นค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับทั้งหมด 0 <= x < 2^n

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

Input: a = 1, b = 6, n = 3
Output: 12
คำอธิบาย: สำหรับ x = 5, (a XOR x) = 4 และ (b XOR x) = 3 ดังนั้น (a XOR x) * (b XOR x) = 12
ซึ่งสามารถแสดงให้เห็นได้ว่า 12 เป็นค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับทั้งหมด 0 <= x < 2^n

ข้อจำกัด:

0 <= a, b < 2^50
0 <= n <= 50

ให้สามจำนวนเต็ม a, b และ n, ส่งคืนค่าสูงสุดของ (a XOR x) * (b XOR x) โดยที่ 0 <= x <2^n
เนื่องจากคำตอบอาจมีขนาดใหญ่เกินไปให้ส่งคืนโมดูโล 10^9 + 7
โปรดทราบว่า XOR คือการทำงานของ Bitwise XOR

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

อินพุต: a = 12, b = 5, n = 4
เอาท์พุท: 98
คำอธิบาย: สำหรับ x = 2, (a XOR x) = 14 และ (bXOR x) = 7. ดังนั้น (a XOR x) * (b XOR x) = 98
มันสามารถแสดงให้เห็นว่า 98 คือค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับทั้งหมด 0 <= x <2^n

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

อินพุต: a = 6, b = 7, n = 5
เอาท์พุท: 930
คำอธิบาย: สำหรับ x = 25, (a XOR x) = 31  และ (b XOR x) = 30. ดังนั้น (a XOR x) * (b XOR x) = 930
มันสามารถแสดงให้เห็นว่า 930 เป็นค่าสูงสุดของ (a XOR x) * (b XOR x) สำหรับทั้งหมด 0 <= x <2^n
ตัวอย่างที่ 3:

อินพุต: a = 1, b = 6, n = 3
เอาท์พุท: 12
คำอธิบาย: สำหรับ x = 5, (a XOR x) = 4 and (b XOR x) = 3 ดังนั้น (a XOR x) * (b XOR x) = 12.
มันสามารถแสดงให้เห็นว่า 12 คือค่าสูงสุดของ(a XOR x) * (b XOR x) สำหรับทั้งหมด 0 <= x <2^n

ข้อ จำกัด :

0 <= a, b <2^50
0 <= n <= 50


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

|x - y| <= min(x, y)

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

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

อินพุต: nums = [1,2,3,4,5]
เอาต์พุต: 7
คำอธิบาย: มีคู่ที่แข็งแกร่ง 11 คู่ในอาร์เรย์ nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) และ (5, 5)
XOR สูงสุดที่เป็นไปได้จากคู่เหล่านี้คือ 3 XOR 4 = 7

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

อินพุต: nums = [10,100]
เอาต์พุต: 0
คำอธิบาย: มีคู่ที่แข็งแกร่ง 2 คู่ในอาร์เรย์ nums: (10, 10) และ (100, 100) ค่า XOR สูงสุดที่เป็นไปได้จากคู่เหล่านี้คือ 10 XOR 10 = 0 เนื่องจากคู่ (100, 100) ให้ผลลัพธ์เป็น 100 XOR 100 = 0 เช่นกัน

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

อินพุต: nums = [5,6,25,30]
เอาต์พุต: 7
คำอธิบาย: มีคู่ที่แข็งแกร่ง 6 คู่ในอาร์เรย์ nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) และ (30, 30)
ค่า XOR สูงสุดที่เป็นไปได้จากคู่เหล่านี้คือ 25 XOR 30 = 7 เนื่องจากค่า XOR ที่ไม่ใช่ศูนย์อื่นๆ คือ 5 XOR 6 = 3

ข้อจำกัด:

1 <= nums.length <= 50
1 <= nums[i] <= 100

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นที่ 0 คู่ของจำนวนเต็ม x และ y เรียกว่าคู่ที่แข็งแกร่งถ้ามันเป็นไปตามเงื่อนไข:

|x - y| <= min(x, y)

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

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

อินพุต: nums = [1,2,3,4,5]
เอาท์พุท: 7
คำอธิบาย: มี 11 คู่ที่แข็งแกร่งในอาร์เรย์ nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) และ (5, 5)
XOR สูงสุดที่เป็นไปได้จากคู่เหล่านี้คือ 3 xor 4 = 7

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

อินพุต: nums = [10,100]
เอาท์พุท: 0
คำอธิบาย: มี 2 คู่ที่แข็งแกร่งในอาร์เรย์ nums: (10, 10) และ (100, 100)
XOR สูงสุดที่เป็นไปได้จากคู่เหล่านี้คือ 10 xor 10 = 0 เนื่องจากคู่ (100, 100) ยังให้ 100 xor 100 = 0

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

อินพุต: nums = [5,6,25,30]
เอาท์พุท: 7
คำอธิบาย: มี 6 คู่ที่แข็งแกร่งในอาร์เรย์ Nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) และ (30, 30)
XOR สูงสุดที่เป็นไปได้จากคู่เหล่านี้คือ 25 XOR 30 = 7 เนื่องจากค่า XOR ที่ไม่ใช่ศูนย์อื่น ๆ คือ 5 XOR 6 = 3

ข้อ จำกัด :

1 <= nums.length <= 50
1 <= nums [i] <= 100


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

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

อินพุต: words = ["leet","code"], x = "e"
เอาต์พุต: [0,1]
คำอธิบาย: "e" ปรากฏในทั้งสองคำ: "leet" และ "code" ดังนั้น เราจึงส่งคืนดัชนี 0 และ 1

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

อินพุต: words = ["abc","bcd","aaaa","cbc"], x = "a"
เอาต์พุต: [0,2]
คำอธิบาย: "a" ปรากฏใน "abc" และ "aaaa" ดังนั้น เราจึงส่งคืนดัชนี 0 และ 2

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

อินพุต: words = ["abc","bcd","aaaa","cbc"], x = "z"
เอาต์พุต: []
คำอธิบาย: "z" ไม่ปรากฏในคำใดๆ ดังนั้น เราจึงส่งคืนอาร์เรย์ว่าง

ข้อจำกัด:

1 <= words.length <= 50
1 <= words[i].length <= 50
x เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
words[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับคำศัพท์สตริง 0-indexed และตัวละคร x
ส่งคืนอาร์เรย์ของดัชนีแทนคำที่มีอักขระ x
โปรดทราบว่าอาร์เรย์ที่ส่งคืนอาจอยู่ในลำดับใด ๆ

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

อินพุต: words = ["leet", "code"], x = "e"
เอาท์พุท: [0,1]
คำอธิบาย: "e" เกิดขึ้นทั้งสองคำ: "leet" และ "code" ดังนั้นเรากลับดัชนี 0 และ 1

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

อินพุต: words = ["abc","bcd","aaaa","cbc"], x = "a"
เอาท์พุท: [0,2]
คำอธิบาย: "a" เกิดขึ้นใน "abc" และ "aaaa" ดังนั้นเรากลับดัชนี 0 และ 2

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

อินพุต: words = ["abc", "bcd", "aaaa", "cbc"], x = "z"
เอาท์พุท: []
คำอธิบาย: "z" ไม่ได้เกิดขึ้นในคำใด ๆ ดังนั้นเราส่งคืนอาร์เรย์ที่ว่างเปล่า

ข้อ จำกัด :

1 <= words.length <= 50
1 <= words[i].length <= 50
x เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
words[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

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

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

Input: words = ["leet","code"], x = "e"
Output: [0,1]
คำอธิบาย: "e" ปรากฏในทั้งสองคำ: "leet" และ "code" ดังนั้นเราจึงคืนค่าอินเด็กซ์ 0 และ 1.

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

Input: words = ["abc","bcd","aaaa","cbc"], x = "a"
Output: [0,2]
คำอธิบาย: "a" ปรากฏใน "abc" และ "aaaa" ดังนั้นเราจึงคืนค่าอินเด็กซ์ 0 และ 2

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

Input: words = ["abc","bcd","aaaa","cbc"], x = "z"
Output: []
คำอธิบาย: "z" ไม่ปรากฏในคำใด ๆ ดังนั้นเราจึงส่งคืนอาร์เรย์ว่าง.

ข้อจำกัด:

1 <= words.length <= 50
1 <= words[i].length <= 50
x เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
words[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


มีลูกบอล n ลูกบนโต๊ะ โดยแต่ละลูกจะมีสีดำหรือสีขาว
คุณจะได้รับสตริงไบนารี s ที่มีความยาว n โดยมี 1 และ 0 แทนลูกบอลสีดำและสีขาวตามลำดับ
ในแต่ละขั้นตอน คุณสามารถเลือกลูกบอลที่อยู่ติดกันสองลูกและสลับกันได้
ส่งคืนจำนวนขั้นตอนขั้นต่ำในการจัดกลุ่มลูกบอลสีดำทั้งหมดทางด้านขวาและลูกบอลสีขาวทั้งหมดทางด้านซ้าย

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

อินพุต: s = "101"
เอาต์พุต: 1
คำอธิบาย: เราสามารถจัดกลุ่มลูกบอลสีดำทั้งหมดทางด้านขวาได้ดังนี้:
- สลับ s[0] และ s[1], s = "011"
ในตอนแรก 1 จะไม่ถูกจัดกลุ่มร่วมกัน ซึ่งต้องใช้ขั้นตอนอย่างน้อย 1 ขั้นตอนในการจัดกลุ่มลูกบอลเหล่านี้ทางด้านขวา
ตัวอย่างที่ 2:

อินพุต: s = "100"
เอาต์พุต: 2
คำอธิบาย: เราสามารถจัดกลุ่มลูกบอลสีดำทั้งหมดทางขวาได้ดังนี้:
- สลับ s[0] และ s[1], s = "010"
- สลับ s[1] และ s[2], s = "001"
สามารถพิสูจน์ได้ว่าจำนวนขั้นตอนขั้นต่ำที่จำเป็นคือ 2

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

อินพุต: s = "0111"
เอาต์พุต: 0
คำอธิบาย: ลูกบอลสีดำทั้งหมดถูกจัดกลุ่มไว้ทางขวาแล้ว

ข้อจำกัด:

1 <= n == s.length <= 10^5
s[i] คือ '0' หรือ '1'

มีลูกบอล n ลูกบนโต๊ะ โดยแต่ละลูกจะมีสีดำหรือสีขาว
คุณจะได้รับสตริงไบนารี s ที่มีความยาว n โดยมี 1 และ 0 แทนลูกบอลสีดำและสีขาวตามลำดับ
ในแต่ละขั้นตอน คุณสามารถเลือกลูกบอลที่อยู่ติดกันสองลูกและสลับกันได้
ส่งคืนจำนวนขั้นตอนขั้นต่ำในการจัดกลุ่มลูกบอลสีดำทั้งหมดทางขวาและลูกบอลสีขาวทั้งหมดทางซ้าย

ตัวอย่าง 1:

อินพุต: s = "101"
เอาต์พุต: 1
คำอธิบาย: เราสามารถจัดกลุ่มลูกบอลสีดำทั้งหมดทางขวาได้ดังนี้:
- สลับ s[0] และ s[1], s = "011"
ในตอนแรก 1 จะไม่ถูกจัดกลุ่มร่วมกัน ซึ่งต้องใช้ขั้นตอนอย่างน้อย 1 ขั้นตอนในการจัดกลุ่มลูกบอลเหล่านี้ทางขวา ตัวอย่างที่ 2:

อินพุต: s = "100"
เอาต์พุต: 2
คำอธิบาย: เราสามารถจัดกลุ่มลูกบอลสีดำทั้งหมดทางขวาได้ดังนี้:
- สลับ s[0] และ s[1], s = "010"
- สลับ s[1] และ s[2], s = "001"
สามารถพิสูจน์ได้ว่าจำนวนขั้นตอนขั้นต่ำที่จำเป็นคือ 2

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

อินพุต: s = "0111"
เอาต์พุต: 0
คำอธิบาย: ลูกบอลสีดำทั้งหมดถูกจัดกลุ่มไว้ทางขวาแล้ว

ข้อจำกัด:

1 <= n == s.length <= 10^5
s[i] คือ '0' หรือ '1'

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

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

อินพุต: s = "101"
เอาท์พุท: 1
คำอธิบาย: เราสามารถจัดกลุ่มลูกบอลสีดำทั้งหมดไปทางขวาด้วยวิธีต่อไปนี้:
- Swap s[0] and s[1], s = "011".
ในขั้นต้น 1s ไม่ได้จัดกลุ่มเข้าด้วยกันซึ่งต้องใช้อย่างน้อย 1 ขั้นตอนในการจัดกลุ่มทางด้านขวา
ตัวอย่างที่ 2:

อินพุต: s = "100"
เอาท์พุท: 2
คำอธิบาย: เราสามารถจัดกลุ่มลูกบอลสีดำทั้งหมดไปทางขวาด้วยวิธีต่อไปนี้:
- Swap s [0] และ s [1], s = "010"
- Swap s [1] และ s [2], s = "001"
สามารถพิสูจน์ได้ว่าจำนวนขั้นตอนขั้นต่ำที่จำเป็นคือ 2

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

อินพุต: s = "0111"
เอาท์พุท: 0
คำอธิบาย: ลูกบอลสีดำทั้งหมดถูกจัดกลุ่มไปทางขวาแล้ว

ข้อ จำกัด :

1 <= n == s.length <= 10^5
s [i] คือ '0' หรือ '1'


คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 nums และจำนวนเต็ม k
คุณสามารถดำเนินการต่อไปนี้กับอาร์เรย์ได้มากที่สุด k ครั้ง:

เลือกดัชนี i ใดก็ได้จากอาร์เรย์และเพิ่มหรือลด nums[i] ขึ้น 1

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

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

อินพุต: nums = [1,2,6,4], k = 3
เอาต์พุต: 3
คำอธิบาย: เราสามารถดำเนินการต่อไปนี้กับอาร์เรย์ได้:
- เลือก i = 0 และเพิ่มค่าของ nums[0] ขึ้น 1 อาร์เรย์ที่ได้คือ [2,2,6,4]
- เลือก i = 3 และลดค่าของ nums[3] ขึ้น 1 อาร์เรย์ที่ได้คือ [2,2,6,3] - เลือก i = 3 และลดค่าของ nums[3] ลง 1 อาร์เรย์ที่ได้คือ [2,2,6,2]
องค์ประกอบ 2 เป็นองค์ประกอบที่มีความถี่มากที่สุดในอาร์เรย์สุดท้าย ดังนั้นคะแนนของเราจึงเป็น 3
จะเห็นว่าเราไม่สามารถทำคะแนนได้ดีกว่านี้

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

อินพุต: nums = [1,4,4,2,4], k = 0
เอาต์พุต: 3
คำอธิบาย: เราไม่สามารถใช้การดำเนินการใดๆ ได้ ดังนั้นคะแนนของเราจะเป็นความถี่ขององค์ประกอบที่มีความถี่มากที่สุดในอาร์เรย์ดั้งเดิม ซึ่งคือ 3

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= k <= 10^14


คุณได้รับจำนวนเต็มบวกสองจำนวน n และ limit
คืนค่าจำนวนวิธีทั้งหมดในการแจกจ่ายลูกอม n ชิ้น ให้กับเด็ก 3 คน โดยที่ไม่มีใครได้รับลูกอมเกิน limit ชิ้น

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

Input: n = 5, limit = 2
Output: 3
คำอธิบาย: มี 3 วิธีในการแจกจ่ายลูกอม 5 ชิ้น โดยที่ไม่มีใครได้รับลูกอมเกิน 2 ชิ้น: (1, 2, 2), (2, 1, 2) และ (2, 2, 1)

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

Input: n = 3, limit = 3
Output: 10
คำอธิบาย: มี 10 วิธีในการแจกจ่ายลูกอม 3 ชิ้น โดยที่ไม่มีใครได้รับลูกอมเกิน 3 ชิ้น: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) และ (3, 0, 0)

ข้อจำกัด:

1 <= n <= 50
1 <= limit <= 50

คุณจะได้รับจํานวนเต็มบวกสองตัว n และ limit
ส่งคืนจํานวนวิธีทั้งหมดในการแจกจ่ายลูกอมให้กับเด็ก 3 คน เพื่อไม่ให้เด็กคนใดได้รับลูกอมเกินขีดจํากัด

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

อินพุต: n = 5, limit = 2
เอาท์พุต: 3
คําอธิบาย: มี 3 วิธีในการแจกจ่ายลูกอม 5 ลูกเพื่อไม่ให้เด็กได้รับลูกอมมากกว่า 2 ลูก: (1, 2, 2), (2, 1, 2) และ (2, 2, 1)

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

อินพุต: n = 3, limit = 3
เอาท์พุต: 10
คําอธิบาย: มี 10 วิธีในการแจกจ่ายลูกอม 3 ลูกเพื่อไม่ให้เด็กได้รับลูกอมมากกว่า 3 ลูก: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) และ (3, 0, 0)

ข้อจํากัด:

1 <= n <= 50
1 <= limit <= 50

คุณได้รับจำนวนเต็มบวกสองจำนวน n และ limit.
คืนจำนวนวิธีทั้งหมดในการแจกขนม n ชิ้นให้กับเด็ก 3 คน โดยที่เด็กแต่ละคนจะได้รับขนมไม่เกินจำนวนที่กำหนด

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

Input: n = 5, limit = 2
Output: 3
คำอธิบาย: มี 3 วิธีในการแจกจ่ายลูกอม 5 ชิ้น โดยที่เด็กแต่ละคนจะไม่ได้รับลูกอมมากกว่า 2 ชิ้น: (1, 2, 2), (2, 1, 2) และ (2, 2, 1)

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

Input: n = 3, limit = 3
Output: 10
คำอธิบาย:มี 10 วิธีในการแจกจ่ายลูกอม 3 ชิ้น โดยที่เด็กแต่ละคนจะไม่ได้รับลูกอมมากกว่า 3 ชิ้น: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) และ (3, 0, 0).

ข้อจำกัด:

1 <= n <= 50
1 <= limit <= 50


คุณได้รับจำนวนเต็ม n
สตริง s จะถูกเรียกว่า good ถ้ามีเฉพาะอักขระภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น และสามารถจัดเรียงอักขระของ s ใหม่ได้ โดยที่สตริงใหม่จะมี "leet" เป็นสตริงย่อย
ตัวอย่างเช่น:

สตริง "lteer" ดีเพราะเราสามารถจัดเรียงใหม่ให้เป็น "leetr" ได้

"letl" ไม่ดีเพราะเราไม่สามารถจัดเรียงใหม่ให้มี "leet" เป็นสตริงย่อยได้

ส่งคืนจำนวนสตริงที่ดีทั้งหมดที่มีความยาว n
เนื่องจากคำตอบอาจมีขนาดใหญ่ ให้ส่งคืนคำตอบนั้นโดยโมดูโล 10^9 + 7
สตริงย่อยคือลำดับอักขระที่ต่อเนื่องกันภายในสตริง
ตัวอย่างที่ 1:

อินพุต: n = 4
เอาต์พุต: 12
คำอธิบาย: สตริง 12 สตริงที่สามารถจัดเรียงใหม่เพื่อให้มี "leet" เป็นสตริงย่อยได้ ได้แก่: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" และ "tlee"
ตัวอย่างที่ 2:

อินพุต: n = 10
เอาต์พุต: 83943898
คำอธิบาย: จำนวนสตริงที่มีความยาว 10 ซึ่งสามารถจัดเรียงใหม่เพื่อให้มี "leet" เป็นสตริงย่อยได้คือ 526083947580 ดังนั้นคำตอบคือ 526083947580 % (10^9 + 7) = 83943898

ข้อจำกัด:

1 <= n <= 10^5

คุณจะได้รับจำนวนเต็ม n
สตริง s เรียกว่าดีถ้ามันมีเฉพาะอักขระภาษาอังกฤษตัวพิมพ์เล็กและเป็นไปได้ที่จะจัดเรียงอักขระของ S ใหม่เพื่อให้สตริงใหม่มี "leet" เป็น สตริงย่อย
ตัวอย่างเช่น:

สตริง "lteer" ดีเพราะเราสามารถจัดเรียงใหม่ให้เป็น "leetr"
"letl" ไม่ดีเพราะเราไม่สามารถจัดเรียงใหม่ให้มี "leet" เป็นสายย่อย

ส่งคืนจำนวนสตริงที่ดีทั้งหมดของความยาว n
เนื่องจากคำตอบอาจมีขนาดใหญ่ให้ส่งคืนโมดูโล 10^9 + 7
สตริงย่อยเป็นลำดับของอักขระที่ต่อเนื่องกันภายในสตริง

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

อินพุต: n = 4
เอาท์พุท: 12
คำอธิบาย: 12 สตริงที่สามารถจัดเรียงใหม่ให้มี "leet" เป็นสายย่อยคือ: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet" , "ltee", "teel", "tele" และ "tlee"

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

อินพุต: n = 10
เอาท์พุท: 83943898
คำอธิบาย: จำนวนสตริงที่มีความยาว 10 ซึ่งสามารถจัดเรียงใหม่ให้มี "leet" เป็น substring คือ 526083947580 ดังนั้นคำตอบคือ 526083947580 % (10^9 + 7) = 83943898

ข้อ จำกัด :

1 <= n <= 10^5

คุณจะได้รับจํานวนเต็ม n
สตริง s เรียกว่าดีหากมีอักขระภาษาอังกฤษตัวพิมพ์เล็กเท่านั้นและสามารถจัดเรียงอักขระของ s ใหม่เพื่อให้สตริงใหม่มี "leet" เป็นสตริงย่อย
เช่น:

สตริง "lteer" นั้นดีเพราะเราสามารถจัดเรียงใหม่ให้เป็น "leetr" ได้
"letl" ไม่ดีเพราะเราไม่สามารถจัดเรียงใหม่ให้มี "leet" เป็นสตริงย่อยได้

ส่งคืนจํานวนสตริงที่ดีทั้งหมดของความยาว n
เนื่องจากคําตอบอาจใหญ่ ให้ส่งคืนโมดูโล 10^9 + 7
สตริงย่อยคือลําดับอักขระที่ต่อเนื่องกันภายในสตริง

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

อินพุต: n = 4
เอาท์พุต: 12
คําอธิบาย: สตริง 12 สายที่สามารถจัดเรียงใหม่เพื่อให้มี "leet" เป็นสตริงย่อย ได้แก่ "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" และ "tlee"

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

อินพุต: n = 10
เอาท์พุต: 83943898
คําอธิบาย: จํานวนสตริงที่มีความยาว 10 ซึ่งสามารถจัดเรียงใหม่ให้มี "leet" เป็นสตริงย่อย 526083947580 ดังนั้นคําตอบคือ 526083947580 % (10^9 + 7) = 83943898

ข้อจํากัด:

1 <= n <= 10^5


คุณจะได้รับสตริง s ที่มีดัชนี 0 ที่มีความยาวคู่ n
คุณจะได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่มีดัชนี 0 เช่นกัน โดย query[i] = [a_i, b_i, c_i, d_i]
สำหรับแต่ละ query i คุณสามารถดำเนินการดังต่อไปนี้:

จัดเรียงอักขระภายในสตริงย่อย s[a_i:b_i] ใหม่ โดยที่ 0 <= a_i <= b_i < n / 2
จัดเรียงอักขระภายในสตริงย่อย s[c_i:d_i] ใหม่ โดยที่ n / 2 <= c_i <= d_i < n

สำหรับแต่ละ query งานของคุณคือการกำหนดว่าเป็นไปได้หรือไม่ที่จะสร้าง s เป็นพาลินโดรมโดยดำเนินการเหล่านี้
แต่ละ query จะได้รับคำตอบโดยอิสระจากอันอื่นๆ ส่งกลับคำตอบแบบอาร์เรย์ที่มีดัชนี 0 โดยที่ answer[i] == true หากสามารถสร้าง s เป็นพาลินโดรมได้โดยดำเนินการตามที่ระบุโดยคิวรีที่ i^ และ false หากไม่สามารถทำได้

ซับสตริงคือลำดับอักขระที่ต่อเนื่องกันภายในสตริง
s[x:y] แสดงถึงซับสตริงที่ประกอบด้วยอักขระตั้งแต่ดัชนี x ถึงดัชนี y ใน s รวมทั้ง 2 อักขระ

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

อินพุต: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
เอาต์พุต: [true,true]
คำอธิบาย: ในตัวอย่างนี้ มีคิวรีสองรายการ:
ในคิวรีรายการแรก:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5
- ดังนั้น คุณจึงสามารถจัดเรียง s[1:1] => abcabc และ s[3:5] => abcabc ใหม่ได้
- หากต้องการให้ s เป็นพาลินโดรม s[3:5] สามารถจัดเรียงใหม่เป็น => abccba ได้
- ขณะนี้ s เป็นพาลินโดรม ดังนั้น answer[0] = true ในแบบสอบถามที่สอง:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5
- ดังนั้น คุณจึงสามารถจัดเรียง s[0:2] => abcabc และ s[5:5] => abcabc ใหม่ได้
- หากต้องการให้ s เป็นพาลินโดรม s[0:2] สามารถจัดเรียงใหม่เป็น => cbaabc ได้
- ขณะนี้ s เป็นพาลินโดรม ดังนั้น คำตอบ[1] = true

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

อินพุต: s = "abbcdecbba", queries = [[0,2,7,9]]
เอาต์พุต: [false]
คำอธิบาย: ในตัวอย่างนี้ มีคิวรีเพียงรายการเดียว
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9
ดังนั้น คุณจึงสามารถจัดเรียง s[0:2] => abbcdecbba และ s[7:9] => abbcdecbba ใหม่ได้
ไม่สามารถทำให้ s เป็นพาลินโดรมได้โดยการจัดเรียงสตริงย่อยเหล่านี้ใหม่ เนื่องจาก s[3:6] ไม่ใช่พาลินโดรม
ดังนั้น answer[0] = false
ตัวอย่างที่ 3:

อินพุต: s = "acbcab", queries = [[1,2,4,5]]
เอาต์พุต: [true]
คำอธิบาย: ในตัวอย่างนี้ มีแบบสอบถามเพียงรายการเดียว
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5
ดังนั้น คุณจึงสามารถจัดเรียง s[1:2] => acbcab และ s[4:5] => acbcab ใหม่ได้
เพื่อให้ s เป็นพาลินโดรม s[1:2] สามารถจัดเรียงใหม่เป็น abccab ได้
จากนั้น s[4:5] สามารถจัดเรียงใหม่เป็น abccba ได้
ขณะนี้ s เป็นพาลินโดรม ดังนั้น answer[0] = true

ข้อจำกัด:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n เป็นเลขคู่
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับสตริง s ที่มีดัชนี 0 ที่มีความยาวคู่ n
คุณจะได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่มีดัชนี 0 เช่นกัน โดย query[i] = [a_i, b_i, c_i, d_i]
สำหรับแต่ละ query i คุณสามารถดำเนินการดังต่อไปนี้:

จัดเรียงอักขระภายในสตริงย่อย s[a_i:b_i] ใหม่ โดยที่ 0 <= a_i <= b_i < n / 2
จัดเรียงอักขระภายในสตริงย่อย s[c_i:d_i] ใหม่ โดยที่ n / 2 <= c_i <= d_i < n

สำหรับแต่ละ query งานของคุณคือการกำหนดว่าเป็นไปได้หรือไม่ที่จะสร้าง s เป็นพาลินโดรมโดยดำเนินการเหล่านี้
แต่ละ query จะได้รับคำตอบโดยอิสระจากอันอื่นๆ ส่งคืนอาร์เรย์ answer ที่มีดัชนี 0 โดยที่ answer[i] == true หากสามารถสร้าง s เป็นพาลินโดรมได้โดยดำเนินการตามที่ระบุโดยคิวรีที่ i^ และ false หากไม่สามารถทำได้

ซับสตริงคือลำดับอักขระที่ต่อเนื่องกันภายในสตริง
s[x:y] แสดงถึงซับสตริงที่ประกอบด้วยอักขระจากดัชนี x ถึงดัชนี y ใน s รวมทั้ง s ด้วย

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

อินพุต: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
เอาต์พุต: [true,true]
คำอธิบาย: ในตัวอย่างนี้ มีคิวรีสองรายการ:
ในคิวรีแรก:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5
- ดังนั้น คุณจึงสามารถจัดเรียง s[1:1] => abcabc และ s[3:5] => abcabc ใหม่ได้ - หากต้องการให้ s เป็นพาลินโดรม s[3:5] สามารถเรียงใหม่เป็น => abccba ได้
- ขณะนี้ s เป็นพาลินโดรม ดังนั้น answer[0] = true
ในคำถามที่สอง:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5
- ดังนั้น คุณจึงสามารถเรียง s[0:2] => abcabc และ s[5:5] => abcabc ใหม่ได้
- หากต้องการให้ s เป็นพาลินโดรม s[0:2] สามารถเรียงใหม่เป็น => cbaabc ได้
- ขณะนี้ s เป็นพาลินโดรม ดังนั้น answer[1] = true

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

อินพุต: s = "abbcdecbba", queries = [[0,2,7,9]]
เอาต์พุต: [false]
คำอธิบาย: ในตัวอย่างนี้ มีคิวรีเพียงรายการเดียว
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9
ดังนั้น คุณจึงสามารถจัดเรียง s[0:2] => abbcdecbba และ s[7:9] => abbcdecbba ใหม่ได้
ไม่สามารถทำให้ s เป็นพาลินโดรมได้โดยการจัดเรียงสตริงย่อยเหล่านี้ใหม่ เนื่องจาก s[3:6] ไม่ใช่พาลินโดรม
ดังนั้น answer[0] = false
ตัวอย่างที่ 3:

อินพุต: s = "acbcab", queries = [[1,2,4,5]]
เอาต์พุต: [true]
คำอธิบาย: ในตัวอย่างนี้ มีคิวรีเพียงรายการเดียว a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5
ดังนั้น คุณจึงสามารถจัดเรียง s[1:2] => acbcab และ s[4:5] => acbcab ใหม่ได้
เพื่อให้ s เป็นพาลินโดรม s[1:2] สามารถจัดเรียงใหม่เป็น abccab ได้
จากนั้น s[4:5] สามารถจัดเรียงใหม่เป็น abccba ได้
ขณะนี้ s เป็นพาลินโดรม ดังนั้น answer[0] = true
ข้อจำกัด:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n เป็นเลขคู่
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับสตริงที่มีดัชนีเริ่มต้นที่ 0 s ที่มีความยาวเท่ากัน n
คุณยังได้รับอาร์เรย์สองมิติของจำนวนเต็มที่มีดัชนีเริ่มต้นที่ 0 แบบสอบถาม โดยที่ queries[i] = [a_i, b_i, c_i, d_i]
สําหรับแต่ละแบบสอบถาม i คุณได้รับอนุญาตให้ดําเนินการต่อไปนี้:

จัดเรียงอักขระใหม่ภายในสตริงย่อย s[a_i:b_i] โดยที่ 0 <= a_i <= b_i < n / 2
จัดเรียงอักขระใหม่ภายในสตริงย่อย s[c_i:d_i] โดยที่ n / 2 <= c_i <= d_i < n

สําหรับงานของคุณคือพิจารณาว่าเป็นไปได้หรือไม่ที่จะทําให้ s เป็นพาลินโดรมโดยการดําเนินการ
แต่ละแบบสอบถามจะได้รับคําตอบโดยอิสระจากแบบสอบถามอื่นๆ
ส่งคืนอาร์เรย์คำตอบที่มีดัชนีเริ่มต้นที่ 0 โดยที่ answer[i] == true หากเป็นไปได้ที่จะทําให้ s เป็นพาลินโดรมโดยการดําเนินการที่ระบุโดยแบบสอบถามที่ i^th และfalseมิฉะนั้น

สตริงย่อยคือลําดับอักขระที่ต่อเนื่องกันภายในสตริง
s[x:y] แสดงถึงสตริงย่อยที่ประกอบด้วยอักขระจากดัชนี x ไปยังดัชนี y ใน s รวมทั้งสองอย่าง

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

อินพุต: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
เอาต์พุต: [true, true]
คําอธิบาย: ในตัวอย่างนี้ มีสองแบบสอบถาม:
ในแบบสอบถามแรก:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5
- ดังนั้นคุณจึงได้รับอนุญาตให้จัดเรียง s[1:1] => abcabc และ s[3:5] => abcabc
- ในการทําให้ s เป็นพาลินโดรม s[3:5] สามารถจัดเรียงใหม่ให้เป็น => abccba
- ตอนนี้ s เป็นพาลินโดรม ดังนั้น answer[0] = true
ในแบบสอบถามที่สอง:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5
- ดังนั้นคุณจึงได้รับอนุญาตให้จัดเรียง s[0:2] => abcabc และ s[5:5] => abcabc
- ในการทําให้ s เป็นพาลินโดรม s[0:2] สามารถจัดเรียงใหม่ให้เป็น => cbaabc
- ตอนนี้ s เป็นพาลินโดรม ดังนั้นคําตอบ[1] = true

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

อินพุต: s = "abbcdecbba", queries = [[0,2,7,9]]
เอาต์พุต: [false]
คําอธิบาย: ในตัวอย่างนี้ มีเพียงแบบสอบถามเดียว
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9
ดังนั้นคุณจึงได้รับอนุญาตให้จัดเรียง s[0:2] => abbcdecbba และ s[7:9] => abbcdecbba
เป็นไปไม่ได้ที่จะทําให้ s เป็นพาลินโดรมโดยการจัดเรียงสตริงย่อยเหล่านี้ใหม่เนื่องจาก s[3:6] ไม่ใช่พาลินโดรม
ดังนั้นคําตอบ[0] = false
ตัวอย่างที่ 3:

อินพุต: s = "acbcab", queries = [[1,2,4,5]]
เอาต์พุต: [true]
คําอธิบาย: ในตัวอย่างนี้ มีเพียงแบบสอบถามเดียว
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5
ดังนั้นคุณจึงได้รับอนุญาตให้จัดเรียง s[1:2] => acbcab และ s[4:5] => acbcab
ในการทําให้ s เป็นพาลินโดรม s [1:2] สามารถจัดเรียงใหม่ให้เป็น abccab ได้
จากนั้น s[4:5] สามารถจัดเรียงใหม่ให้เป็น abccba ได้
ตอนนี้ s เป็นพาลินโดรม ดังนั้น answer[0] = true

ข้อจํากัด:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 < = a_i < = b_i < n / 2
n / 2 <= c_i <= d_i < n
n เป็นเลขคู่
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 จำนวน 2 ชุด คือ nums1 และ nums2 ที่มีขนาด n และ m ตามลำดับ
ลองคำนวณค่าต่อไปนี้:

จำนวนดัชนี i ที่ทำให้ 0 <= i < n และ nums1[i] เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums2
จำนวนดัชนี i ที่ทำให้ 0 <= i < m และ nums2[i] เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums1

ส่งคืนคำตอบของอาร์เรย์จำนวนเต็มขนาด 2 ที่มีค่าสองค่าตามลำดับข้างต้น

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

อินพุต: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
เอาต์พุต: [3,4]
คำอธิบาย: เราคำนวณค่าดังต่อไปนี้:
- องค์ประกอบในดัชนี 1, 2 และ 3 ใน nums1 เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums2 ดังนั้นค่าแรกคือ 3
- องค์ประกอบในดัชนี 0, 1, 3 และ 4 ใน nums2 เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums1 ดังนั้นค่าที่สองคือ 4

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

อินพุต: nums1 = [3,4,2,3], nums2 = [1,5]
เอาต์พุต: [0,0]
คำอธิบาย: ไม่มีองค์ประกอบร่วมกันระหว่างอาร์เรย์ทั้งสอง ดังนั้นค่าทั้งสองจะเป็น 0

ข้อจำกัด:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

คุณจะได้รับจำนวนเต็ม 0-indexed สองอาร์เรย์ nums1 และ nums2 ของขนาด n และ m ตามลำดับ
พิจารณาการคำนวณค่าต่อไปนี้:

จํานวนดัชนี i ที่ 0 <= i <n และ nums1 [i] เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums2
จํานวนดัชนี i ที่ 0 <= i <m และ nums2 [i] เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums1

ส่งคืนคำตอบอาร์เรย์จำนวนเต็มขนาด 2 ที่มีค่าสองค่าตามลำดับข้างต้น

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

อินพุต: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
เอาท์พุท: [3,4]
คำอธิบาย: เราคำนวณค่าดังต่อไปนี้:
- องค์ประกอบที่ดัชนี 1, 2, และ 3 ใน nums1 เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums2 ดังนั้นค่าแรกคือ 3
- องค์ประกอบที่ดัชนี 0, 1, 3 และ 4 ใน nums2 เกิดขึ้นอย่างน้อยหนึ่งครั้งใน nums1 ดังนั้นค่าที่สองคือ 4

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

อินพุต: nums1 = [3,4,2,3], nums2 = [1,5]
เอาท์พุท: [0,0]
คำอธิบาย: ไม่มีองค์ประกอบทั่วไประหว่างสองอาร์เรย์ดังนั้นค่าทั้งสองจะเป็น 0

ข้อ จำกัด :

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1 [i], nums2 [i] <= 100

คุณได้รับอาร์เรย์จำนวนเต็มสองชุด nums1 และ nums2 ที่มีดัชนีเริ่มต้นที่ 0 ขนาด n และ m ตามลำดับ
พิจารณาการคำนวณค่าต่อไปนี้:

จำนวนดัชนี i ที่ทำให้ 0 <= i < n และ nums1[i] ปรากฏอย่างน้อยหนึ่งครั้งใน nums2
จำนวนดัชนี i ที่ทำให้ 0 <= i < m และ nums2[i] ปรากฏอย่างน้อยหนึ่งครั้งใน nums1

คืนค่าอาร์เรย์จำนวนเต็มที่มีขนาด 2 ซึ่งประกอบด้วยสองค่าในลำดับที่กล่าวถึงข้างต้

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

Input: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Output: [3,4]
คำอธิบาย: เราคำนวณค่าเป็นดังนี้:
- องค์ประกอบที่ตำแหน่ง 1, 2 และ 3 ใน nums1 ปรากฏอย่างน้อยหนึ่งครั้งใน nums2 ดังนั้นค่าตัวแรกคือ 3
- องค์ประกอบที่ตำแหน่ง 0, 1, 3 และ 4 ใน nums2 ปรากฏอย่างน้อยหนึ่งครั้งใน nums1 ดังนั้นค่าตัวที่สองคือ 4

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

Input: nums1 = [3,4,2,3], nums2 = [1,5]
Output: [0,0]
ไม่มีองค์ประกอบที่เหมือนกันระหว่างอาร์เรย์ทั้งสอง ดังนั้นค่าทั้งสองจะเป็น 0.

ข้อจำกัด:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100


คุณมีสตริงสามตัว s1, s2, และ s3 คุณต้องทำตามขั้นตอนดังนี้กับสตริงทั้งสามตัวนี้ดำเนินการกี่ครั้งก็ได้
ในการดำเนินการหนึ่งครั้ง คุณสามารถเลือกสตริงหนึ่งในสามที่มีความยาวอย่างน้อย 2 แล้วลบอักขระทางขวาสุดออก
ส่งคืนจำนวนขั้นตอนขั้นต่ำที่คุณต้องทำเพื่อให้สตริงทั้งสามเท่ากัน หากมีวิธีทำให้พวกมันเท่ากัน มิเช่นนั้นให้ส่งคืน -1

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

Input: s1 = "abc", s2 = "abb", s3 = "ab"
Output: 2
คำอธิบาย: การดำเนินการกับ s1 และ s2 หนึ่งครั้งจะทำให้สตริงทั้งสามเท่ากัน
แสดงให้เห็นว่าไม่มีวิธีใดที่จะทำให้พวกมันเท่ากันด้วยการดำเนินการน้อยกว่าสองครั้ง

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

Input: s1 = "dac", s2 = "bac", s3 = "cac"
Output: -1
คำอธิบาย: เนื่องจากตัวอักษรซ้ายสุดของ s1 และ s2 ไม่เท่ากัน พวกมันจึงไม่สามารถเท่ากันได้หลังจากดำเนินการใด ๆ ดังนั้นคำตอบคือ -1

ข้อจำกัด:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 และ s3 ประกอบด้วยอักขระภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับสตริง 3 ตัว คือ s1, s2 และ s3 คุณต้องดำเนินการต่อไปนี้กับสตริง 3 ตัวเหล่านี้หลายครั้งเท่าที่คุณต้องการ
ในการดำเนินการครั้งหนึ่ง คุณสามารถเลือกสตริงใดสตริงหนึ่งจาก 3 สตริงนี้ โดยให้มีความยาวอย่างน้อย 2 และลบตัวอักษรที่อยู่ขวาสุดของสตริงนั้น

ส่งคืนจำนวนการดำเนินการขั้นต่ำที่คุณต้องดำเนินการเพื่อให้สตริง 3 ตัวเท่ากัน หากมีวิธีที่ทำให้สตริงเหล่านี้เท่ากัน มิฉะนั้น ให้ส่งคืน -1

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

อินพุต: s1 = "abc", s2 = "abb", s3 = "ab"
เอาต์พุต: 2
คำอธิบาย: การดำเนินการกับ s1 และ s2 เพียงครั้งเดียวจะส่งผลให้ได้สตริง 3 ตัวที่เท่ากัน
จะเห็นได้ว่าไม่มีวิธีใดที่จะทำให้สตริง 3 ตัวเท่ากันได้ด้วยการดำเนินการน้อยกว่า 2 ครั้ง ตัวอย่างที่ 2:

อินพุต: s1 = "dac", s2 = "bac", s3 = "cac"
เอาต์พุต: -1
คำอธิบาย: เนื่องจากตัวอักษรซ้ายสุดของ s1 และ s2 ไม่เท่ากัน จึงไม่สามารถเท่ากันได้หลังจากดำเนินการหลายครั้ง ดังนั้นคำตอบคือ -1

ข้อจำกัด:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 และ s3 ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับสามสาย s1, s2 และ s3 คุณต้องดําเนินการต่อไปนี้กับสตริงทั้งสามนี้กี่ครั้งก็ได้ตามที่คุณต้องการ
ในการดําเนินการครั้งเดียวคุณสามารถเลือกหนึ่งในสามสตริงนี้เพื่อให้ความยาวอย่างน้อย 2 และลบอักขระขวาสุดของมัน
ส่งคืนจํานวนการดําเนินการขั้นต่ําที่คุณต้องดําเนินการเพื่อให้สตริงทั้งสามเท่ากันหากมีวิธีทําให้เท่ากันมิฉะนั้นให้ส่งคืน -1

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

อินพุต: s1 = "abc", s2 = "abb", s3 = "ab"
เอาท์พุต: 2
คําอธิบาย: การดําเนินการกับ s1 และ s2 หนึ่งครั้งจะนําไปสู่สามสตริงเท่ากัน
สามารถแสดงให้เห็นได้ว่าไม่มีทางที่จะทําให้เท่ากันด้วยการดําเนินการน้อยกว่าสองครั้ง
ตัวอย่างที่ 2:

อินพุต: s1 = "dac", s2 = "bac", s3 = "cac"
เอาท์พุต: -1
คําอธิบาย: เนื่องจากตัวอักษรซ้ายสุดของ s1 และ s2 ไม่เท่ากันจึงไม่สามารถเท่ากันได้หลังจากการดําเนินการจํานวนเท่าใดก็ได้ ดังนั้นคําตอบคือ -1

ข้อจํากัด:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 และ s3 ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณอยู่ที่ตลาดผลไม้ที่มีผลไม้แปลกใหม่หลากหลายชนิดจัดแสดงอยู่
คุณจะได้รับอาร์เรย์ของราคาที่มีดัชนีเริ่มต้นที่ 1 โดยที่ prices[i] หมายถึงจำนวนเหรียญที่ต้องใช้ในการซื้อผลไม้ที่ i
ตลาดผลไม้มีข้อเสนอดังต่อไปนี้:

หากคุณซื้อผลไม้ที่ i ในราคา prices[i] เหรียญ คุณจะได้ผลไม้ i ผลไม้ต่อไปฟรี

โปรดทราบว่าแม้ว่าคุณจะซื้อผลไม้ j ได้ฟรี คุณก็สามารถซื้อผลไม้ j ได้ในราคา prices[j] เหรียญเพื่อรับข้อเสนอใหม่
ส่งคืนจำนวนเหรียญขั้นต่ำที่จำเป็นในการรับผลไม้ทั้งหมด

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

อินพุต: prices = [3,1,2]
เอาต์พุต: 4
คำอธิบาย: คุณสามารถรับผลไม้ได้ดังนี้:
- ซื้อผลไม้ที่ 1 ด้วยเหรียญ 3 เหรียญ คุณจะได้ผลไม้ที่ 2 ได้ฟรี
- ซื้อผลไม้ที่ 2 ด้วยเหรียญ 1 เหรียญ คุณจะได้ผลไม้ที่ 3 ได้ฟรี
- รับผลไม้ที่ 3 ได้ฟรี โปรดทราบว่าถึงแม้คุณจะได้รับอนุญาตให้หยิบผลไม้ที่ 2 ได้ฟรี แต่คุณซื้อมันเพราะว่ามันเหมาะสมกว่า
สามารถพิสูจน์ได้ว่าต้องใช้เหรียญ 4 เหรียญในการรับผลไม้ทั้งหมด

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

อินพุต: prices = [1,10,1,1]
เอาต์พุต: 2
คำอธิบาย: คุณสามารถรับผลไม้ได้ดังนี้:
- ซื้อผลไม้ที่ 1 ด้วยเหรียญ 1 เหรียญ คุณมีสิทธิ์หยิบผลไม้ที่ 2 ได้ฟรี
- หยิบผลไม้ที่ 2 ได้ฟรี
- ซื้อผลไม้ที่ 3 ด้วยเหรียญ 1 เหรียญ คุณมีสิทธิ์หยิบผลไม้ที่ 4 ได้ฟรี
- หยิบผลไม้ที่ 4 ได้ฟรี

สามารถพิสูจน์ได้ว่าต้องใช้เหรียญ 2 เหรียญในการรับผลไม้ทั้งหมด

ข้อจำกัด:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

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

หากคุณซื้อผลไม้ที่ i^th ในราคา prices[i] เหรียญ คุณสามารถรับผลไม้ต่อไป i รายการได้ฟรี

โปรดทราบว่าแม้ว่าคุณจะสามารถรับผลไม้ j ได้ฟรี คุณยังสามารถซื้อมันในราคา prices[j] เหรียญเพื่อรับข้อเสนอใหม่
ส่งคืนจำนวนเหรียญขั้นต่ำที่จำเป็นในการรับผลไม้ทั้งหมด

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

อินพุต:prices = [3,1,2]
เอาท์พุท: 4
คำอธิบาย: คุณสามารถรับผลไม้ได้ดังนี้:
- ซื้อผลไม้ ที่ 1 ด้วย 3 เหรียญคุณได้รับอนุญาตให้ทานผล ที่ 2 ฟรี
- ซื้อผล ที่ 2 ด้วย 1 เหรียญคุณได้รับอนุญาตให้ทานผล ที่ 3 ฟรี
- ทานผลไม้ ที่ 3 ฟรี
โปรดทราบว่าแม้ว่าคุณจะได้รับอนุญาตให้ทานผลไม้ ที่ 2 ฟรีคุณซื้อมันเพราะมันเหมาะสมกว่า
สามารถพิสูจน์ได้ว่า 4 เป็นจำนวนเหรียญขั้นต่ำที่จำเป็นในการรับผลไม้ทั้งหมด

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

อินพุต: prices = [1,10,1,1]
เอาท์พุท: 2
คำอธิบาย: คุณสามารถรับผลไม้ได้ดังนี้:
- ซื้อผลไม้ ที่ 1 ด้วย 1 เหรียญคุณได้รับอนุญาตให้ทานผล ที่ 2 ฟรี
- ทานผล ที่ 2 ฟรี
- ซื้อผลไม้ ที่ 3 สำหรับ 1 เหรียญคุณได้รับอนุญาตให้ทานผล ที่ 4 ฟรี
- ทานผลไม้ ที่ 4 ฟรี
สามารถพิสูจน์ได้ว่า 2 คือจำนวนเหรียญขั้นต่ำที่จำเป็นในการรับผลไม้ทั้งหมด

ข้อ จำกัด :

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

คุณอยู่ที่ตลาดผลไม้ที่มีผลไม้แปลกใหม่หลากหลายชนิดจัดแสดงอยู่
คุณได้รับอาเรย์ที่มีดัชนีเริ่มต้นที่ 1 (1-indexed array) ชื่อว่า prices ซึ่ง prices[i] แสดงถึงจำนวนเหรียญที่ต้องใช้ในการซื้อผลไม้ชนิดที่ i
ตลาดผลไม้มีข้อเสนอดังต่อไปนี้:

หากคุณซื้อผลไม้ชนิดที่ i ในราคา prices[i] เหรียญ คุณจะสามารถรับผลไม้ชนิดถัดไป i ชนิดได้ฟรี

โปรดทราบว่าแม้ว่าคุณจะสามารถรับผลไม้ชนิด j ฟรีได้ แต่คุณยังสามารถซื้อผลไม้ชนิดนั้นในราคา prices[j] เหรียญเพื่อรับข้อเสนอใหม่
ให้คืนค่าจำนวนเหรียญขั้นต่ำที่จำเป็นในการซื้อผลไม้ทั้งหมด

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

Input: prices = [3,1,2]
Output: 4
คำอธิบาย: คุณสามารถรับผลไม้ได้ตามนี้:
- ซื้อผลไม้ลูกที่ 1 ด้วย 3 เหรียญ คุณจะได้รับอนุญาตให้รับผลไม้ลูกที่ 2 ฟรี
- ซื้อผลไม้ลูกที่ 2 ด้วย 1 เหรียญ คุณจะได้รับอนุญาตให้รับผลไม้ลูกที่ 3 ฟรี
- รับผลไม้ลูกที่ 3 ฟรี
โปรดทราบว่าแม้ว่าคุณจะได้รับอนุญาตให้รับผลไม้ลูกที่ 2 ฟรี แต่คุณก็ซื้อมันเพราะมันเป็นทางเลือกที่ดีกว่า
สามารถพิสูจน์ได้ว่า 4 เป็นจำนวนเหรียญขั้นต่ำที่จำเป็นในการรับผลไม้ทั้งหมด

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

Input: prices = [1,10,1,1]
Output: 2
คำอธิบาย: คุณสามารถรับผลไม้ได้ดังนี้:
- ซื้อผลไม้ลูกที่ 1 ด้วย 1 เหรียญ คุณจะได้รับผลไม้ลูกที่ 2 ฟรี
- รับผลไม้ลูกที่ 2 ฟรี
- ซื้อผลไม้ลูกที่ 3 ด้วย 1 เหรียญ คุณจะได้รับผลไม้ลูกที่ 4 ฟรี
- รับผลไม้ลูกที่ 4 ฟรี
สามารถพิสูจน์ได้ว่า 2 เป็นจำนวนเหรียญขั้นต่ำที่จำเป็นในการรับผลไม้ทั้งหมด

ข้อจำกัด:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5


คุณได้รับสตริง s และจำนวนเต็มบวก k
ให้จำนวนสระและพยัญชนะเป็นจำนวนของสระและพยัญชนะในสตริง
สตริงจะสวยงามถ้า:

จำนวนสระ == จำนวนพยัญชนะ
(จำนวนสระ * จำนวนพยัญชนะ) % k == 0 ซึ่งหมายความว่าผลคูณของจำนวนสระและจำนวนพยัญชนะหารด้วย k ลงตัว

ให้คืนค่าจำนวนซับสตริงที่ไม่ว่างเปล่าที่สวยงามในสตริง s ที่กำหนด
ซับสตริงคือชุดของอักขระที่ต่อเนื่องกันในสตริง
ตัวอักษรสระในภาษาอังกฤษคือ 'a', 'e', 'i', 'o', และ 'u'
ตัวอักษรพยัญชนะในภาษาอังกฤษคือทุกตัวอักษรยกเว้นสระ

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

Input: s = "baeyh", k = 2
Output: 2
คำอธิบาย: มี 2 ซับสตริงที่สวยงามในสตริงที่กำหนด
- ซับสตริง "baeyh", สระ = 2 (["a", "e"]), พยัญชนะ = 2 (["y", "h"]).
คุณสามารถเห็นได้ว่าสตริง "aeyh" สวยงามเพราะสระ == พยัญชนะ และสระ * พยัญชนะ % k == 0.
- ซับสตริง "baeyh", สระ = 2 (["a", "e"]), พยัญชนะ = 2 (["b", "y"]).
คุณสามารถเห็นได้ว่าสตริง "baey" สวยงามเพราะสระ == พยัญชนะ และสระ * พยัญชนะ % k == 0.
สามารถแสดงให้เห็นว่ามีเพียง 2 ซับสตริงที่สวยงามในสตริงที่กำหนด.

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

Input: s = "abba", k = 1
Output: 3
คำอธิบาย: มี 3 ซับสตริงที่สวยงามในสตริงที่กำหนด
- ซับสตริง "abba", สระ = 1 (["a"]), พยัญชนะ = 1 (["b"]).
- ซับสตริง "abba", สระ = 1 (["a"]), พยัญชนะ = 1 (["b"]).
- ซับสตริง "abba", สระ = 2 (["a","a"]), พยัญชนะ = 2 (["b","b"]).
สามารถแสดงให้เห็นว่ามีเพียง 3 ซับสตริงที่สวยงามในสตริงที่กำหนดเท่านั้น.

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

Input: s = "bcdf", k = 1
Output: 0
คำอธิบาย: ไม่มีซับสตริงที่สวยงามในสตริงที่กำหนด

ข้อจำกัด:

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

คุณได้รับสตริง s  และจำนวนเต็มบวก k
ให้ถือว่า จำนวนสระ และ จำนวนพยัญชนะ คือจำนวนสระและพยัญชนะในสตริง
สตริงจะสวยงามถ้า:

ให้vowels == consonants
(vowels * consonants) % k == 0,กล่าวอีกนัยหนึ่งการคูณสระและพยัญชนะจะหารด้วย k ลงตัว
คืนจำนวนของสตริงที่ไม่ว่างเปล่าและสวยงามในสตริง s  ที่ให้มา
สตริงย่อยคือลำดับของตัวอักษรที่ต่อเนื่องกันในสตริง
ตัวอักษรสระในภาษาอังกฤษคือ 'a', 'e', 'i', 'o', และ 'u'
ตัวอักษรพยัญชนะในภาษาอังกฤษคือตัวอักษรเว้นสระ

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

Input: s = "baeyh", k = 2
Output: 2
คำอธิบาย: มีสตริงย่อยที่สวยงาม 2 สตริงในสตริงที่กำหนด
- สตริงย่อย "baeyh", สระ = 2 (["a","e"]), พยัญชนะ = 2 (["y","h"]).
คุณสามารถเห็นว่าสตริง "aeyh" สวยงามเพราะสระ == พยัญชนะ และ สระ*พยัญชนะ% k == 0
- สตริงย่อย "baeyh", สระ = 2 (["a","e"]), พยัญชนะ = 2 (["b","y"]).
คุณสามารถเห็นว่าสตริง "baey" สวยงามเพราะสระ == พยัญชนะ และสระ*พยัญชนะ% k == 0
สามารถแสดงให้เห็นว่ามีเพียง 2 สตริงย่อยที่สวยงามในสตริงที่กำหนด

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

Input: s = "abba", k = 1
Output: 3
คำอธิบาย: มีสตริงย่อยที่สวยงาม 3 สตริงในสตริงที่กำหนด
- สตริงย่อย "abba", สระ = 1 (["a"]), พยัญชนะ = 1 (["b"]).
- สตริงย่อย "abba", สระ = 1 (["a"]), พยัญชนะ = 1 (["b"]).
- สตริงย่อย "abba", สระ = 2 (["a","a"]), พยัญชนะ = 2 (["b","b"]).
สามารถแสดงให้เห็นว่ามีเพียง 3 สตริงย่อยที่สวยงามในสตริงที่กำหนด

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

Input: s = "bcdf", k = 1
Output: 0
คำอธิบาย: ไม่มีสตริงย่อยที่สวยงามในสตริงที่กำหนด

เงื่อนไข:

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

คุณจะได้รับสตริง S และจำนวนเต็มบวก k
ให้สระและพยัญชนะเป็นจำนวนสระและพยัญชนะในสตริง
สตริงสวยถ้า:

vowels == consonants
(vowels * consonants) % k == 0 หรือ การคูณของสระและพยัญชนะสามารถหารได้โดย k

ส่งคืนจำนวนย่อยที่สวยงามที่ไม่ว่างเปล่าในสตริงที่กำหนด
สตริงย่อยเป็นลำดับของอักขระที่ต่อเนื่องกันในสตริง
ตัวอักษrpพยัญชนะเป็นภาษาอังกฤษคือ 'a', 'e', 'i', 'o'และ 'u'
ตัวอักษrpพยัญชนะเป็นภาษาอังกฤษเป็นจดหมายทุกฉบับยกเว้นสระ

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

อินพุต: s = "baeyh", k = 2
เอาท์พุท: 2
คำอธิบาย: มี 2 ส่วนย่อยที่สวยงามในสตริงที่กำหนด
- substring "baeyh", สระ = 2 (["a", e "]), พยัญชนะ = 2 ([" y "," h "])
คุณจะเห็นว่าสตริง "aeyh" นั้นสวยงามเหมือนเสียงสระ == พยัญชนะและเสียงสระ * พยัญชนะ % k == 0
- substring "baeyh", สระ = 2 (["a", e "]), พยัญชนะ = 2 ([" b "," y "])
คุณจะเห็นว่าสตริง "baey" นั้นสวยงามเหมือนเสียงสระ == พยัญชนะและเสียงสระ * พยัญชนะ % k == 0
มันสามารถแสดงให้เห็นว่ามีเพียง 2 substrings ที่สวยงามในสตริงที่กำหนด

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

อินพุต: s = "abba", k = 1
เอาท์พุท: 3
คำอธิบาย: มี 3 ส่วนย่อยที่สวยงามในสตริงที่กำหนด
- substring "abba", สระ = 1 (["a"]), พยัญชนะ = 1 (["b"])
- substring "abba", สระ = 1 (["a"]), พยัญชนะ = 1 (["b"])
- substring "abba", สระ = 2 (["a", "a"]), พยัญชนะ = 2 (["b", "b"])
มันสามารถแสดงให้เห็นว่ามีเพียง 3 ส่วนย่อยที่สวยงามในสตริงที่กำหนด

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

อินพุต: s = "bcdf", k = 1
เอาท์พุท: 0
คำอธิบาย: ไม่มีสตริงย่อยที่สวยงามในสตริงที่กำหนด

ข้อ จำกัด :

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


คุณมีอาเรย์จำนวนเต็มที่มีดัชนีเริ่มต้นที่ 0 ชื่อว่า nums
คุณสามารถดำเนินการได้หลายครั้ง โดยแต่ละครั้งจะเป็นการเลือก subarray ของอาเรย์และแทนที่ด้วยผลรวมขององค์ประกอบของมัน ตัวอย่างเช่น ถ้าให้อาเรย์เป็น [1,3,5,6] และคุณเลือก subarray [3,5] อาเรย์จะเปลี่ยนเป็น [1,8,6]
คืนค่าความยาวสูงสุดของอาเรย์ที่ไม่ลดลงที่สามารถสร้างได้หลังจากดำเนินการ
subarray คือกลุ่มขององค์ประกอบที่อยู่ติดกันและไม่ว่างเปล่าภายในอาเรย์

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

Input: nums = [5,2,2]
Output: 1
คำอธิบาย: อาเรย์นี้ที่มีความยาว 3 ไม่ใช่ไม่ลดลง
เรามีสองวิธีที่จะทำให้อาเรย์มีความยาวสอง
วิธีแรก เลือก subarray [2,2] แปลงอาเรย์เป็น [5,4]
วิธีที่สอง เลือก subarray [5,2] แปลงอาเรย์เป็น [7,2]
ในสองวิธีนี้ อาเรย์ไม่ใช่ไม่ลดลง
และหากเราเลือก subarray [5,2,2] และแทนที่ด้วย [9] มันจะกลายเป็นไม่ลดลง
ดังนั้นคำตอบคือ 1

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

Input: nums = [1,2,3,4]
Output: 4
คำอธิบาย: อาเรย์นี้ไม่ลดลง ดังนั้นคำตอบคือ 4

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

Input: nums = [4,3,2,6]
Output: 3
คำอธิบาย: การแทนที่ [3,2] ด้วย [5] แปลงอาเรย์ที่กำหนดเป็น [4,5,6] ที่เป็นไม่ลดลง
เนื่องจากอาเรย์ที่กำหนดไม่ใช่ไม่ลดลง คำตอบสูงสุดที่เป็นไปได้คือ 3

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

คุณจะได้รับอาร์เรย์จำนวนเต็มที่จัดทำดัชนีเป็น 0 nums
คุณสามารถดำเนินการได้หลายรายการ โดยแต่ละการดำเนินการเกี่ยวข้องกับการเลือกอาร์เรย์ย่อยของอาร์เรย์และแทนที่ด้วยผลรวมขององค์ประกอบในอาร์เรย์นั้น ตัวอย่างเช่น หากอาร์เรย์ที่กำหนดคือ [1,3,5,6] และคุณเลือกอาร์เรย์ย่อย [3,5] อาร์เรย์จะแปลงเป็น [1,8,6]
ส่งคืนความยาวสูงสุดของอาร์เรย์ที่ไม่ลดลงที่สามารถทำได้หลังจากใช้การดำเนินการ
อาร์เรย์ย่อยคือลำดับองค์ประกอบที่อยู่ติดกันและไม่ว่างภายในอาร์เรย์

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

อินพุต: nums = [5,2,2]
เอาต์พุต: 1
คำอธิบาย: อาร์เรย์ที่มีความยาว 3 นี้ไม่ใช่อาร์เรย์ที่ไม่ลดลง
เรามีสองวิธีในการทำให้อาร์เรย์มีความยาวเป็นสองเท่า
วิธีแรกคือการเลือกอาร์เรย์ย่อย [2,2] จะแปลงอาร์เรย์เป็น [5,4]
วิธีที่สองคือการเลือกอาร์เรย์ย่อย [5,2] จะแปลงอาร์เรย์เป็น [7,2] ด้วยสองวิธีนี้ อาร์เรย์จะไม่ลดลง
และถ้าเราเลือกซับอาร์เรย์ [5,2,2] และแทนที่ด้วย [9] ก็จะกลายเป็นไม่ลดลง

ดังนั้นคำตอบคือ 1

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

อินพุต: nums = [1,2,3,4]
เอาต์พุต: 4
คำอธิบาย: อาร์เรย์จะไม่ลดลง ดังนั้นคำตอบคือ 4

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

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

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

คุณจะได้รับอาร์เรย์จำนวนเต็มที่จัดทำดัชนีเป็น 0 nums
คุณสามารถดำเนินการได้หลายรายการ โดยแต่ละการดำเนินการเกี่ยวข้องกับการเลือกอาร์เรย์ย่อยของอาร์เรย์และแทนที่ด้วยผลรวมขององค์ประกอบในอาร์เรย์นั้น ตัวอย่างเช่น หากอาร์เรย์ที่กำหนดคือ [1,3,5,6] และคุณเลือกอาร์เรย์ย่อย [3,5] อาร์เรย์จะแปลงเป็น [1,8,6]
ส่งคืนความยาวสูงสุดของอาร์เรย์ที่ไม่ลดลงที่สามารถทำได้หลังจากใช้การดำเนินการ
อาร์เรย์ย่อยคือลำดับองค์ประกอบที่อยู่ติดกันและไม่ว่างภายในอาร์เรย์

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

อินพุต: nums = [5,2,2]
เอาต์พุต: 1
คำอธิบาย: อาร์เรย์ที่มีความยาว 3 นี้ไม่ใช่อาร์เรย์ที่ไม่ลดลง
เรามีสองวิธีในการทำให้อาร์เรย์มีความยาวเป็นสองเท่า
วิธีแรกคือการเลือกอาร์เรย์ย่อย [2,2] จะแปลงอาร์เรย์เป็น [5,4]
วิธีที่สองคือการเลือกอาร์เรย์ย่อย [5,2] จะแปลงอาร์เรย์เป็น [7,2] ด้วยสองวิธีนี้ อาร์เรย์จะไม่ลดลง
และถ้าเราเลือกอาร์เรย์ย่อย [5,2,2] และแทนที่ด้วย [9] ก็จะกลายเป็นไม่ลดลง

ดังนั้นคำตอบคือ 1

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

อินพุต: nums = [1,2,3,4]
เอาต์พุต: 4
คำอธิบาย: อาร์เรย์จะไม่ลดลง ดังนั้นคำตอบคือ 4

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

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

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5


คุณจะได้รับอาร์เรย์ nums ที่มีดัชนี 0 ซึ่งประกอบด้วยจำนวนเต็มบวก
การแบ่งอาร์เรย์ออกเป็นซับอาร์เรย์ที่ต่อเนื่องกันหนึ่งรายการหรือมากกว่านั้นเรียกว่า good หากไม่มีซับอาร์เรย์สองรายการใดที่มีตัวเลขเท่ากัน
ส่งคืนจำนวนพาร์ติชั่น nums ที่ถูกต้องทั้งหมด เนื่องจากคำตอบอาจมีค่ามาก ให้คืนค่าโมดูโล 10^9 + 7

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

อินพุต: nums = [1,2,3,4]
เอาต์พุต: 8
คำอธิบาย: พาร์ติชันที่ดี 8 พาร์ติชันที่เป็นไปได้คือ: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), และ ([1,2,3,4])

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

อินพุต: nums = [1,1,1,1]
เอาต์พุต: 1
คำอธิบาย: พาร์ติชันที่ดีเพียงพาร์ติชันเดียวที่เป็นไปได้คือ: ([1,1,1,1])
ตัวอย่างที่ 3:

อินพุต: nums = [1,2,1,3]
เอาต์พุต: 2
คำอธิบาย: พาร์ติชั่นที่ดี 2 แบบที่เป็นไปได้คือ: ([1,2,1], [3]) และ ([1,2,1,3])

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ที่มีดัชนีเริ่มต้นที่ 0 และประกอบด้วยจำนวนเต็มบวก
พาร์ติชันของอาร์เรย์เป็นหนึ่งหรือมากกว่าหนึ่ง subarrays ที่ต่อเนื่องกันเรียกว่าดีถ้าไม่มีสอง subarrays มีหมายเลขเดียวกัน
ส่งคืนจำนวนพาร์ติชันที่ดีทั้งหมดของ nums
เนื่องจากคำตอบอาจมีขนาดใหญ่ให้ส่งคืนโมดูโล 10^9 + 7

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

อินพุต: nums = [1,2,3,4]
เอาท์พุท: 8
คำอธิบาย: พาร์ทิชันที่ดี 8 ที่เป็นไปได้คือ: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2, 3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]) และ ([1,2,3,4])

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

อินพุต: nums = [1,1,1,1]
เอาท์พุท: 1
คำอธิบาย: พาร์ติชันที่ดีที่เป็นไปได้เพียงอย่างเดียวคือ: ([1,1,1,1])

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

อินพุต: nums = [1,2,1,3]
เอาท์พุท: 2
คำอธิบาย: พาร์ติชันที่ดีที่เป็นไปได้คือ: ([1,2,1], [3]) และ ([1,2,1,3])

ข้อ จำกัด :

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

คุณมีอาเรย์ที่เริ่มต้นด้วยดัชนี 0 ชื่อ nums ซึ่งประกอบด้วยจำนวนเต็มบวก การแบ่งอาเรย์เรียกว่า "ดี" ถ้าไม่มีสองซับอาเรย์ที่มีจำนวนเดียวกัน คืนค่าจำนวนทั้งหมดของการแบ่งที่ดีของ nums เนื่องจากผลลัพธ์อาจมีขนาดใหญ่ ให้คืนค่าผลลัพธ์แบบโมดูโล 10^9 + 7

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

Input: nums = [1,2,3,4] Output: 8 คำอธิบาย: การแบ่งที่ดี 8 แบบที่เป็นไปได้คือ: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), and ([1,2,3,4])

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

Input: nums = [1,1,1,1] Output: 1 คำอธิบาย: การแบ่งที่ดีที่เป็นไปได้เดียวคือ: ([1,1,1,1])

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

Input: nums = [1,2,1,3] Output: 2 คำอธิบาย: การแบ่งที่ดี 2 แบบที่เป็นไปได้คือ: ([1,2,1], [3]) and ([1,2,1,3])

ข้อจำกัด:

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


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

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

อินพุต: nums = [1,3,2,3,3], k = 2
เอาต์พุต: 6
คำอธิบาย: ซับอาร์เรย์ที่มีองค์ประกอบ 3 อย่างน้อย 2 ครั้งคือ: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] และ [3,3]

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

อินพุต: nums = [1,4,2,1], k = 3
เอาต์พุต: 0
คำอธิบาย: ไม่มีซับอาร์เรย์ใดที่มีองค์ประกอบ 4 อย่างน้อย 3 ครั้ง

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^6
1 <= k <= 10^5


คุณจะได้รับอาร์เรย์ที่มีดัชนี 0 ของจำนวนเต็มบวก nums และขีดจำกัดจำนวนเต็มบวก
ในการดำเนินการครั้งหนึ่ง คุณสามารถเลือกดัชนี i และ j ใดๆ ก็ได้ และสลับ nums[i] และ nums[j] หาก |nums[i] - nums[j]| <= ขีดจำกัด
ส่งคืนอาร์เรย์ที่เล็กที่สุดตามพจนานุกรมที่สามารถรับได้โดยการดำเนินการซ้ำๆ กันหลายครั้ง
อาร์เรย์ a มีขนาดเล็กตามพจนานุกรมมากกว่าอาร์เรย์ b ถ้าในตำแหน่งแรกที่ a และ b แตกต่างกัน อาร์เรย์ a มีองค์ประกอบที่น้อยกว่าองค์ประกอบที่สอดคล้องกันใน b ตัวอย่างเช่น อาร์เรย์ [2,10,3] มีขนาดเล็กตามพจนานุกรมมากกว่าอาร์เรย์ [10,2,3] เนื่องจากแตกต่างกันที่ดัชนี 0 และ 2 < 10

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

อินพุต: nums = [1,5,3,9,8], limit = 2
เอาต์พุต: [1,3,5,8,9]
คำอธิบาย: ใช้การดำเนินการ 2 ครั้ง:
- สลับ nums[1] กับ nums[2] อาร์เรย์จะกลายเป็น [1,3,5,9,8]
- สลับ nums[3] กับ nums[4] อาร์เรย์จะกลายเป็น [1,3,5,8,9]
เราไม่สามารถรับอาร์เรย์ที่มีขนาดเล็กกว่าตามพจนานุกรมได้โดยใช้การดำเนินการเพิ่มเติมใดๆ
โปรดทราบว่าอาจเป็นไปได้ที่จะได้รับผลลัพธ์เดียวกันโดยทำการดำเนินการที่แตกต่างกัน

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

อินพุต: nums = [1,7,6,18,2,1], limit = 3
เอาต์พุต: [1,6,7,18,1,2]
คำอธิบาย: ใช้การดำเนินการ 3 ครั้ง:
- สลับ nums[1] กับ nums[2] อาร์เรย์จะกลายเป็น [1,6,7,18,2,1]
- สลับ nums[0] กับ nums[4] อาร์เรย์จะกลายเป็น [2,6,7,18,1,1]
- สลับ nums[0] กับ nums[5] อาร์เรย์จะกลายเป็น [1,6,7,18,1,2]
เราไม่สามารถรับอาร์เรย์ที่มีขนาดเล็กกว่าตามพจนานุกรมได้โดยใช้การดำเนินการเพิ่มเติมใดๆ

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

อินพุต: nums = [1,7,28,19,10], limit = 3
เอาต์พุต: [1,7,28,19,10]
คำอธิบาย: [1,7,28,19,10] เป็นอาร์เรย์ที่เล็กที่สุดตามพจนานุกรมที่เราสามารถรับได้ เนื่องจากเราไม่สามารถดำเนินการกับดัชนีสองตัวใดๆ ได้

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ที่มีดัชนี 0 ของจำนวนเต็มบวก nums และขีดจำกัดจำนวนเต็มบวก
ในการดำเนินการหนึ่งครั้ง คุณสามารถเลือกดัชนี i และ j ใดๆ ก็ได้ และสลับ nums[i] และ nums[j] หาก |nums[i] - nums[j]| <= ขีดจำกัด

ส่งคืนอาร์เรย์ที่เล็กที่สุดตามพจนานุกรมที่สามารถรับได้โดยการดำเนินการซ้ำๆ กันหลายครั้ง
อาร์เรย์ a จะเล็กกว่าอาร์เรย์ b ตามพจนานุกรม หากในตำแหน่งแรกที่ a และ b แตกต่างกัน อาร์เรย์ a มีองค์ประกอบที่น้อยกว่าองค์ประกอบที่สอดคล้องกันใน b ตัวอย่างเช่น อาร์เรย์ [2,10,3] มีขนาดเล็กกว่าอาร์เรย์ [10,2,3] ตามพจนานุกรม เนื่องจากอาร์เรย์ทั้งสองแตกต่างกันที่ดัชนี 0 และ 2 < 10

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

อินพุต: nums = [1,5,3,9,8], limit = 2
เอาต์พุต: [1,3,5,8,9]
คำอธิบาย: ใช้การดำเนินการ 2 ครั้ง:
- สลับ nums[1] กับ nums[2] อาร์เรย์จะกลายเป็น [1,3,5,9,8]
- สลับ nums[3] กับ nums[4] อาร์เรย์จะกลายเป็น [1,3,5,8,9]
เราไม่สามารถรับอาร์เรย์ที่มีขนาดเล็กกว่าตามพจนานุกรมได้โดยใช้การดำเนินการเพิ่มเติมใดๆ
โปรดทราบว่าอาจเป็นไปได้ที่จะได้รับผลลัพธ์เดียวกันโดยทำการดำเนินการที่แตกต่างกัน
ตัวอย่างที่ 2:

อินพุต: nums = [1,7,6,18,2,1], limit = 3
เอาต์พุต: [1,6,7,18,1,2]
คำอธิบาย: ใช้การดำเนินการ 3 ครั้ง:
- สลับ nums[1] กับ nums[2] อาร์เรย์จะกลายเป็น [1,6,7,18,2,1]
- สลับ nums[0] กับ nums[4] อาร์เรย์จะกลายเป็น [2,6,7,18,1,1]
- สลับ nums[0] กับ nums[5] อาร์เรย์จะกลายเป็น [1,6,7,18,1,2]
เราไม่สามารถรับอาร์เรย์ที่มีขนาดเล็กกว่าตามพจนานุกรมได้โดยใช้การดำเนินการเพิ่มเติมใดๆ
ตัวอย่างที่ 3:

อินพุต: nums = [1,7,28,19,10], limit = 3
เอาต์พุต: [1,7,28,19,10]
คำอธิบาย: [1,7,28,19,10] เป็นอาร์เรย์ที่เล็กที่สุดตามพจนานุกรมที่เราสามารถรับได้ เนื่องจากเราไม่สามารถดำเนินการกับดัชนีสองตัวใดๆ ได้

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ 0-indexed ของจำนวนเต็มบวก nums และขีด จำกัด จำนวนเต็มบวก
ในการดำเนินการครั้งเดียวคุณสามารถเลือกดัชนีสองดัชนี i และ j และสลับ nums[i] และ nums [j] ถ้า | nums [i] - nums [j] | <= limit.
ส่งคืนอาร์เรย์ที่มีลำดับพจนานุกรมน้อยที่สุดที่สามารถรับได้โดยการดำเนินการใด ๆ หลายครั้ง
อาร์เรย์ a มีลำดับพจนานุกรมน้อยกว่าอาร์เรย์ b. หากอยู่ในตำแหน่งแรกที่ A และ B แตกต่างกันอาร์เรย์ a มีองค์ประกอบที่น้อยกว่าองค์ประกอบที่สอดคล้องกันใน b ตัวอย่างเช่นอาร์เรย์ [2,10,3] มีขนาดเล็กกว่าอาร์เรย์ [10,2,3] เพราะพวกเขาแตกต่างกันที่ดัชนี 0 และ 2 <10

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

อินพุต: nums = [1,5,3,9,8], limit = 2
ผลผลิต: [1,3,5,8,9]
คำอธิบาย: ใช้การดำเนินการ 2 ครั้ง:
- สลับ nums [1] กับ nums [2] อาร์เรย์จะกลายเป็น [1,3,5,9,8]
- สลับ nums [3] กับ nums [4] อาร์เรย์จะกลายเป็น [1,3,5,8,9]
เราไม่สามารถรับอาร์เรย์ที่มีขนาดเล็กลงได้โดยใช้การดำเนินงานเพิ่มเติม
โปรดทราบว่าอาจเป็นไปได้ที่จะได้ผลลัพธ์เดียวกันโดยการดำเนินการที่แตกต่างกัน

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

อินพุต: nums = [1,7,6,18,2,1], limit = 3
ผลผลิต: [1,6,7,18,1,2]
คำอธิบาย: ใช้การดำเนินการ 3 ครั้ง:
- สลับ nums [1] กับ nums [2] อาร์เรย์จะกลายเป็น [1,6,7,18,2,1]
- สลับ nums [0] ด้วย nums [4] อาร์เรย์จะกลายเป็น [2,6,7,18,1,1]
- สลับ nums [0] ด้วย nums [5] อาร์เรย์จะกลายเป็น [1,6,7,18,1,2]
เราไม่สามารถรับอาร์เรย์ที่มีขนาดเล็กลงได้โดยใช้การดำเนินงานเพิ่มเติม

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

อินพุต: nums = [1,7,28,19,10], limit = 3
ผลผลิต: [1,7,28,19,10]
คำอธิบาย: [1,7,28,19,10] เป็นอาร์เรย์ที่เล็กที่สุดในการทำพจนานุกรมที่เราสามารถรับได้เพราะเราไม่สามารถใช้การดำเนินการกับดัชนีสองดัชนีใด ๆ

ข้อ จำกัด :

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


คุณได้รับอาเรย์จำนวนเต็ม batteryPercentages ที่มีความยาว n แบบ 0-indexed ซึ่งบ่งชี้เปอร์เซ็นต์แบตเตอรี่ของอุปกรณ์ n ชิ้น ที่มีดัชนีเริ่มต้นที่ 0
งานของคุณคือการทดสอบแต่ละอุปกรณ์ i ตั้งแต่ 0 ถึง n - 1 โดยดำเนินการทดสอบดังต่อไปนี้:

ถ้า batteryPercentages[i] มากกว่า 0:

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

มิฉะนั้น ให้ย้ายไปยังอุปกรณ์ถัดไปโดยไม่ต้องทำการทดสอบ

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

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

Input: batteryPercentages = [1,1,2,1,3]
Output: 3
คำอธิบาย: ทำการทดสอบในลำดับเริ่มจากอุปกรณ์ 0:
ที่อุปกรณ์ 0, batteryPercentages[0] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 1 รายการ, และ batteryPercentages กลายเป็น [1,0,1,0,2].
ที่อุปกรณ์ 1, batteryPercentages[1] == 0, จึงย้ายไปยังอุปกรณ์ถัดไปโดยไม่ต้องทดสอบ.
ที่อุปกรณ์ 2, batteryPercentages[2] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 2 รายการ, และ batteryPercentages กลายเป็น [1,0,1,0,1].
ที่อุปกรณ์ 3, batteryPercentages[3] == 0, จึงย้ายไปยังอุปกรณ์ถัดไปโดยไม่ต้องทดสอบ.
ที่อุปกรณ์ 4, batteryPercentages[4] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 3 รายการ, และ batteryPercentages ยังคงเท่าเดิม.
ดังนั้น คำตอบคือ 3.

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

Input: batteryPercentages = [0,1,2]
Output: 2
คำอธิบาย: ทำการทดสอบในลำดับเริ่มจากอุปกรณ์ 0:
ที่อุปกรณ์ 0, batteryPercentages[0] == 0, จึงย้ายไปยังอุปกรณ์ถัดไปโดยไม่ต้องทดสอบ.
ที่อุปกรณ์ 1, batteryPercentages[1] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 1 รายการ, และ batteryPercentages กลายเป็น [0,1,1].
ที่อุปกรณ์ 2, batteryPercentages[2] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 2 รายการ, และ batteryPercentages ยังคงเท่าเดิม.
ดังนั้น คำตอบคือ 2.

ข้อจำกัด:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

คุณได้รับอาเรย์จำนวนเต็ม batteryPercentages ที่มีความยาว n แบบ 0-indexed ซึ่งบ่งชี้เปอร์เซ็นต์แบตเตอรี่ของอุปกรณ์ n ชิ้น
งานของคุณคือการทดสอบแต่ละอุปกรณ์ i ตั้งแต่ 0 ถึง n - 1 โดยดำเนินการทดสอบดังต่อไปนี้:

ถ้า batteryPercentages[i] มากกว่า 0:

เพิ่มจำนวนอุปกรณ์ที่ทดสอบแล้ว
ลดเปอร์เซ็นต์แบตเตอรี่ของอุปกรณ์ทั้งหมดที่มีดัชนี j ในช่วง [i + 1, n - 1] ลง 1 โดยให้แน่ใจว่าเปอร์เซ็นต์แบตเตอรี่ของพวกมันไม่ต่ำกว่า 0, i.e, กล่าวคือ batteryPercentages[j] = max(0, batteryPercentages[j] - 1)
ไปยังอุปกรณ์ถัดไป

มิฉะนั้น ให้ไปยังอุปกรณ์ถัดไปโดยไม่ต้องทำการทดสอบ

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

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

อินพุต: batteryPercentages = [1,1,2,1,3]
เอาต์พุต: 3
คำอธิบาย: ทำการทดสอบในลำดับเริ่มจากอุปกรณ์ 0:
ที่อุปกรณ์ 0, batteryPercentages[0] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 1 รายการ, และ batteryPercentages กลายเป็น [1,0,1,0,2].
ที่อุปกรณ์ 1, batteryPercentages[1] == 0, จึงไปยังอุปกรณ์ถัดไปโดยไม่ทำการทดสอบ.
ที่อุปกรณ์ 2, batteryPercentages[2] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 2 รายการ, และ batteryPercentages กลายเป็น [1,0,1,0,1].
ที่อุปกรณ์ 3, batteryPercentages[3] == 0, จึงไปยังอุปกรณ์ถัดไปโดยไม่ทำการทดสอบ.
ที่อุปกรณ์ 4, batteryPercentages[4] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 3 รายการ, และ batteryPercentages ยังคงเดิม.
ดังนั้น คำตอบคือ 3.

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

อินพุต: batteryPercentages = [0,1,2]
เอาต์พุตt: 2
คำอธิบาย: ทำการทดสอบในลำดับเริ่มจากอุปกรณ์ 0:
ที่อุปกรณ์ 0, batteryPercentages[0] == 0, จึงไปยังอุปกรณ์ถัดไปโดยไม่ทำการทดสอบ.
ที่อุปกรณ์ 1, batteryPercentages[1] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 1 รายการ, และ batteryPercentages กลายเป็น [0,1,1].
ที่อุปกรณ์ 2, batteryPercentages[2] > 0, จึงมีตอนนี้อุปกรณ์ที่ทดสอบแล้ว 2 รายการ, และ batteryPercentages ยังคงเดิม.
ดังนั้น คำตอบคือ 2.

ข้อจำกัด:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ชื่อ batteryPercentages ซึ่งมีความยาว n ซึ่งแสดงถึงเปอร์เซ็นต์แบตเตอรี่ของอุปกรณ์ที่มีดัชนี 0 จำนวน n เครื่อง
งานของคุณคือทดสอบอุปกรณ์แต่ละเครื่อง i ตามลำดับจาก 0 ถึง n - 1 โดยดำเนินการทดสอบดังต่อไปนี้:

หาก batteryPercentages[i] มากกว่า 0:

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

มิฉะนั้น ให้ย้ายไปยังอุปกรณ์ถัดไปโดยไม่ดำเนินการทดสอบใดๆ

ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนอุปกรณ์ที่จะทำการทดสอบหลังจากดำเนินการทดสอบตามลำดับ
ตัวอย่างที่ 1:

อินพุต: batteryPercentages = [1,1,2,1,3]
เอาต์พุต: 3
คำอธิบาย: ดำเนินการทดสอบตามลำดับโดยเริ่มจากอุปกรณ์ 0:
ที่อุปกรณ์ 0, batteryPercentages[0] > 0 ดังนั้นตอนนี้มีอุปกรณ์ที่ทดสอบแล้ว 1 เครื่อง และ batteryPercentages จะกลายเป็น [1,0,1,0,2]
ที่อุปกรณ์ 1, batteryPercentages[1] == 0 ดังนั้นเราจะย้ายไปที่อุปกรณ์ถัดไปโดยไม่ทดสอบ
ที่อุปกรณ์ 2, batteryPercentages[2] > 0 ดังนั้นตอนนี้มีอุปกรณ์ที่ทดสอบแล้ว 2 เครื่อง และ batteryPercentages จะกลายเป็น [1,0,1,0,1]
ที่อุปกรณ์ 3, batteryPercentages[3] == 0 ดังนั้นเราจะย้ายไปที่อุปกรณ์ถัดไปโดยไม่ทดสอบ
ที่อุปกรณ์ 4, batteryPercentages[4] > 0 ดังนั้นตอนนี้มีอุปกรณ์ที่ทดสอบแล้ว 3 เครื่อง และ batteryPercentages ยังคงเท่าเดิม ดังนั้นคำตอบคือ 3

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

อินพุต: batteryPercentages = [0,1,2]
เอาต์พุต: 2
คำอธิบาย: ดำเนินการทดสอบตามลำดับโดยเริ่มจากอุปกรณ์ 0:
ที่อุปกรณ์ 0 batteryPercentages[0] == 0 ดังนั้นเราจึงไปที่อุปกรณ์ถัดไปโดยไม่ทดสอบ
ที่อุปกรณ์ 1 batteryPercentages[1] > 0 ดังนั้นจึงมีอุปกรณ์ที่ทดสอบแล้ว 1 เครื่อง และ batteryPercentages จะกลายเป็น [0,1,1]
ที่อุปกรณ์ 2 batteryPercentages[2] > 0 ดังนั้นจึงมีอุปกรณ์ที่ทดสอบแล้ว 2 เครื่อง และ batteryPercentages ยังคงเท่าเดิม
ดังนั้นคำตอบคือ 2

ข้อจำกัด:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100


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

ยอดเขาถูกกำหนดให้เป็นองค์ประกอบที่มากกว่าองค์ประกอบข้างเคียงอย่างเคร่งครัด
องค์ประกอบแรกและองค์ประกอบสุดท้ายของอาร์เรย์ไม่ใช่ยอดเขา

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

อินพุต: mountain = [2,4,4]
เอาต์พุต: []
คำอธิบาย: mountain[0] และ mountain[2] ไม่สามารถเป็นยอดเขาได้เนื่องจากเป็นองค์ประกอบแรกและองค์ประกอบสุดท้ายของอาร์เรย์
mountain[1] ไม่สามารถเป็นยอดเขาได้เช่นกันเนื่องจากไม่มากกว่า mountain[2] อย่างเคร่งครัด
ดังนั้นคำตอบคือ []

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

อินพุต: mountain = [1,4,3,8,5]
เอาต์พุต: [1,3]
คำอธิบาย: mountain[0] และ mountain[4] ไม่สามารถเป็นยอดเขาได้เนื่องจากเป็นองค์ประกอบแรกและองค์ประกอบสุดท้ายของอาร์เรย์ mountain[2] ไม่สามารถเป็นยอดเขาได้ เนื่องจากไม่ได้สูงกว่าmountain[3] และmountain[1] อย่างเคร่งครัด
แต่mountain[1] และmountain[3] นั้นสูงกว่าองค์ประกอบข้างเคียงอย่างเคร่งครัด
ดังนั้นคำตอบคือ [1,3]

ข้อจำกัด:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

คุณได้รับอาร์เรย์ mountain ที่มีดัชนีเริ่มต้นที่ 0 งานของคุณคือการหาจุดยอดทั้งหมดในอาร์เรย์ mountain คืนค่าอาร์เรย์ที่ประกอบด้วยดัชนีของจุดยอดในอาร์เรย์ที่กำหนดในลำดับใดก็ได้ หมายเหตุ:

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

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

Input: mountain = [2,4,4]
Output: []
คำอธิบาย:mountain[0] และ mountain[2] ไม่สามารถเป็นยอดเขาได้เพราะเป็นสมาชิกแรกและสมาชิกสุดท้ายของอาร์เรย์
mountain[1] ก็ไม่สามารถเป็นยอดเขาได้เช่นกันเพราะมันไม่มากกว่าค่า mountain[2] อย่างเคร่งครัด
ดังนั้นคำตอบคือ []

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

Input: mountain = [1,4,3,8,5]
Output: [1,3]
คำอธิบาย: mountain[0] และ mountain[4] ไม่สามารถเป็นยอดเขาได้เพราะเป็นสมาชิกแรกและสมาชิกสุดท้ายของอาร์เรย์
mountain[2] ก็ไม่สามารถเป็นยอดเขาได้เช่นกันเพราะมันไม่มากกว่ามountain[3] และ mountain[1] อย่างเคร่งครัด
แต่ mountain[1] และ mountain[3] มากกว่าธาตุข้างเคียงของพวกมันอย่างเคร่งครัด
ดังนั้นคำตอบคือ [1,3].

ข้อจำกัด:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

คุณจะได้รับภูเขาอาร์เรย์ที่มีดัชนี 0 งานของคุณคือค้นหายอดเขาทั้งหมดในอาร์เรย์ภูเขา
ส่งคืนอาร์เรย์ที่ประกอบด้วยดัชนีของยอดสูงสุดในอาร์เรย์ที่กําหนดตามลําดับใดก็ได้
หมาย เหตุ:

จุดสูงสุดถูกกําหนดให้เป็นองค์ประกอบที่มากกว่าองค์ประกอบข้างเคียงอย่างเคร่งครัด
องค์ประกอบแรกและสุดท้ายของอาร์เรย์ไม่ใช่จุดสูงสุด

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

อินพุต: ภูเขา = [2,4,4]
เอาต์พุต: []
คําอธิบาย: ภูเขา[0] และภูเขา[2] ไม่สามารถเป็นยอดได้เนื่องจากเป็นองค์ประกอบแรกและองค์ประกอบสุดท้ายของอาร์เรย์
ภูเขา[1]ก็ไม่สามารถเป็นยอดเขาได้เพราะไม่ได้ใหญ่กว่าภูเขาอย่างเคร่งครัด[2]
ดังนั้นคําตอบคือ []

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

อินพุต: ภูเขา = [1,4,3,8,5]
เอาต์พุต: [1,3]
คําอธิบาย: ภูเขา[0] และภูเขา[4] ไม่สามารถเป็นยอดได้เพราะเป็นองค์ประกอบแรกและองค์ประกอบสุดท้ายของอาร์เรย์
ภูเขา[2] ก็ไม่สามารถเป็นยอดเขาได้เพราะไม่ได้ใหญ่กว่าภูเขา[3] และภูเขา[1] อย่างเคร่งครัด
แต่ภูเขา [1] และภูเขา [3] นั้นยิ่งใหญ่กว่าองค์ประกอบใกล้เคียงอย่างเคร่งครัด
ดังนั้นคําตอบคือ [1,3]

ข้อจํากัด:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100


คุณจะได้รับคำสตริงและจำนวนเต็ม k
สตริงย่อย s ของคำจะสมบูรณ์ถ้า:

อักขระแต่ละตัวใน s ปรากฏซ้ำ k ครั้งพอดี
ความแตกต่างระหว่างอักขระที่อยู่ติดกันสองตัวมีค่าไม่เกิน 2 นั่นคือ สำหรับอักขระ c1 และ c2 สองตัวที่อยู่ติดกันใน s ความแตกต่างสัมบูรณ์ในตำแหน่งของอักขระในตัวอักษรมีค่าไม่เกิน 2

ส่งคืนจำนวนสตริงย่อยที่สมบูรณ์ของคำ
สตริงย่อยคือลำดับอักขระต่อเนื่องที่ไม่ว่างเปล่าในสตริง

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

อินพุต: word = "igigee", k = 2
เอาต์พุต: 3
คำอธิบาย: สตริงย่อยที่สมบูรณ์ซึ่งอักขระแต่ละตัวปรากฏซ้ำสองครั้งพอดีและความแตกต่างระหว่างอักขระที่อยู่ติดกันมีค่าไม่เกิน 2 คือ: igigee, igigee, igigee

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

อินพุต: word = "aaabbbccc", k = 3
เอาต์พุต: 6
คำอธิบาย: สตริงย่อยทั้งหมดที่อักขระแต่ละตัวปรากฏซ้ำกันสามครั้งพอดี และความแตกต่างระหว่างอักขระที่อยู่ติดกันไม่เกิน 2 คือ: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc

ข้อจำกัด:

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

คุณได้รับสตริงคำ (word) และจำนวนเต็ม k
ซับสตริง s ของคำ (word) จะถือว่าครบถ้วนถ้า:

ตัวอักษรแต่ละตัวใน s ปรากฏขึ้น k ครั้ง
ความแตกต่างระหว่างตัวอักษรที่อยู่ติดกันไม่เกิน 2 นั่นคือ สำหรับตัวอักษรที่อยู่ติดกันสองตัว c1 และ c2 ใน s ความแตกต่างสัมบูรณ์ในตำแหน่งของพวกมันในอักษรจะไม่เกิน 2

คืนจำนวนของซับสตริงที่สมบูรณ์ของคำ
ซับสตริงคือ ลำดับของอักขระที่ต่อเนื่องกันในสตริงที่ไม่ว่างเปล่า

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

Input: word = "igigee", k = 2
Output: 3
คำอธิบาย: ซับสตริงที่สมบูรณ์ซึ่งตัวอักษรแต่ละตัวปรากฏขึ้นสองครั้งพอดีและความแตกต่างระหว่างตัวอักษรที่อยู่ติดกันไม่เกิน 2 คือ: igigee, igigee, igigee.

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

Input: word = "aaabbbccc", k = 3
Output: 6
คำอธิบาย: ซับสตริงที่สมบูรณ์ซึ่งแต่ละตัวอักษรปรากฏขึ้นสามครั้งพอดีและความแตกต่างระหว่างตัวอักษรที่อยู่ติดกันไม่เกิน 2 คือ: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

ข้อจำกัด:

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

คุณจะได้รับคําสตริงและจํานวนเต็ม k
สตริงย่อย s ของคําจะสมบูรณ์หาก:

อักขระแต่ละตัวใน s เกิดขึ้น k ครั้งพอดี
ความแตกต่างระหว่างอักขระสองตัวที่อยู่ติดกันคือ 2 นั่นคือสําหรับอักขระสองตัวที่อยู่ติดกัน c1 และ c2 ใน s ความแตกต่างสัมบูรณ์ในตําแหน่งในตัวอักษรจะอยู่ที่ 2

ส่งคืนจํานวนสตริงย่อยที่สมบูรณ์ของคํา
สตริงย่อยคือลําดับอักขระที่ต่อเนื่องกันที่ไม่ว่างเปล่าในสตริง

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

อินพุต: word = "igigee", k = 2
เอาท์พุต: 3
คําอธิบาย: สตริงย่อยที่สมบูรณ์ซึ่งอักขระแต่ละตัวปรากฏสองครั้งพอดี และความแตกต่างระหว่างอักขระที่อยู่ติดกันคือ 2 ตัวคือ: igigee, igigee, igigee

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

อินพุต: word = "aaabbbccc", k = 3
เอาท์พุต: 6
คําอธิบาย: สตริงย่อยที่สมบูรณ์ซึ่งอักขระแต่ละตัวปรากฏสามครั้งพอดี และความแตกต่างระหว่างอักขระที่อยู่ติดกันคือ 2 ตัว ได้แก่ aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc

ข้อจํากัด:

1 <= word.length <= 10^5
word ประกอบด้วยเฉพาะอักษรภาษาอังกฤษพิมพ์เล็ก
1 <= k <= word.length


คุณจะได้รับจำนวนเต็ม n และอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ชื่อ sick ซึ่งจะเรียงลำดับตามลำดับที่เพิ่มขึ้น
มีเด็ก n คนยืนอยู่ในคิวโดยกำหนดตำแหน่งตั้งแต่ 0 ถึง n - 1 ให้กับพวกเขา อาร์เรย์ sick ประกอบด้วยตำแหน่งของเด็กที่ติดเชื้อโรค เด็กที่ติดเชื้อในตำแหน่ง i สามารถแพร่โรคไปยังเด็กข้างเคียงที่ตำแหน่ง i - 1 และ i + 1 ได้ หากเด็กเหล่านี้มีอยู่จริงและไม่ได้รับเชื้อในขณะนี้ เด็กที่ไม่ได้รับเชื้อมาก่อนสามารถติดเชื้อได้มากที่สุด 1 คนในหนึ่งวินาที
สามารถแสดงให้เห็นได้ว่าหลังจากเวลาจำกัดวินาที เด็กทั้งหมดในคิวจะติดเชื้อโรค ลำดับการติดเชื้อคือลำดับลำดับของตำแหน่งที่เด็กที่ไม่ติดเชื้อทั้งหมดติดเชื้อโรค ส่งคืนจำนวนทั้งหมดของลำดับการติดเชื้อที่เป็นไปได้
เนื่องจากคำตอบอาจมีค่ามาก ให้ส่งคืนค่าโมดูโล 10^9 + 7
โปรดทราบว่าลำดับการติดเชื้อไม่มีตำแหน่งของเด็กที่ติดเชื้อโรคไปแล้วในตอนแรก

ตัวอย่าง 1:

อินพุต: n = 5, sick = [0,4]
เอาต์พุต: 4
คำอธิบาย: เด็กที่ตำแหน่ง 1, 2 และ 3 ไม่ติดเชื้อในตอนเริ่มต้น มีลำดับการติดเชื้อที่เป็นไปได้ 4 ลำดับ:
- เด็กที่ตำแหน่ง 1 และ 3 สามารถติดเชื้อได้เนื่องจากตำแหน่งของพวกเขาอยู่ติดกับเด็กที่ติดเชื้อ 0 และ 4 เด็กที่ตำแหน่ง 1 ติดเชื้อก่อน
ขณะนี้ เด็กที่ตำแหน่ง 2 อยู่ติดกับเด็กที่ตำแหน่ง 1 ซึ่งติดเชื้อ และเด็กที่ตำแหน่ง 3 อยู่ติดกับเด็กที่ตำแหน่ง 4 ซึ่งติดเชื้อ ดังนั้น เด็กคนใดคนหนึ่งจึงสามารถติดเชื้อได้ เด็กที่ตำแหน่ง 2 ติดเชื้อ
ในที่สุด เด็กที่ตำแหน่ง 3 ติดเชื้อเนื่องจากอยู่ติดกับเด็กที่ตำแหน่ง 2 และ 4 ซึ่งติดเชื้อ ลำดับการติดเชื้อคือ [1,2,3]
- เด็กที่ตำแหน่ง 1 และ 3 สามารถติดเชื้อได้เนื่องจากตำแหน่งของพวกเขาอยู่ติดกับเด็กที่ติดเชื้อ 0 และ 4 เด็กที่ตำแหน่ง 1 ติดเชื้อก่อน ตอนนี้เด็กในตำแหน่งที่ 2 อยู่ติดกับเด็กในตำแหน่งที่ 1 ซึ่งติดเชื้อ และเด็กในตำแหน่งที่ 3 อยู่ติดกับเด็กในตำแหน่งที่ 4 ซึ่งติดเชื้อ ดังนั้น เด็กคนใดคนหนึ่งอาจติดเชื้อได้ เด็กในตำแหน่งที่ 3 ติดเชื้อ
ในที่สุด เด็กในตำแหน่งที่ 2 ติดเชื้อเพราะอยู่ติดกับเด็กในตำแหน่งที่ 1 และ 3 ซึ่งติดเชื้อ ลำดับการติดเชื้อคือ [1,3,2]
- ลำดับการติดเชื้อคือ [3,1,2] ลำดับการติดเชื้อของโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4]
- ลำดับการติดเชื้อคือ [3,2,1] ลำดับการติดเชื้อโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

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

อินพุต: n = 4, sick = [1]
เอาต์พุต: 3
คำอธิบาย: เด็กที่ตำแหน่ง 0, 2 และ 3 ไม่ได้รับการติดเชื้อในตอนเริ่มต้น มีลำดับการติดเชื้อที่เป็นไปได้ 3 ลำดับ:
- ลำดับการติดเชื้อคือ [0,2,3] ลำดับการติดเชื้อในเด็กสามารถมองได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3]
- ลำดับการติดเชื้อคือ [2,0,3] ลำดับการติดเชื้อโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- ลำดับการติดเชื้อคือ [2,3,0] ลำดับการติดเชื้อโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

ข้อจำกัด:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick จะถูกเรียงลำดับตามลำดับที่เพิ่มขึ้น

คุณจะได้รับจำนวนเต็ม n และอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ชื่อ sick ซึ่งจะเรียงลำดับตามลำดับที่เพิ่มขึ้น
มีเด็ก n คนยืนอยู่ในคิวโดยกำหนดตำแหน่งตั้งแต่ 0 ถึง n - 1 ให้กับพวกเขา อาร์เรย์ sick ประกอบด้วยตำแหน่งของเด็กที่ติดเชื้อโรค เด็กที่ติดเชื้อในตำแหน่ง i สามารถแพร่โรคไปยังเด็กข้างเคียงที่ตำแหน่ง i - 1 และ i + 1 ได้ หากเด็กเหล่านี้มีอยู่จริงและไม่ได้รับเชื้อในขณะนี้ เด็กที่ไม่ได้รับเชื้อมาก่อนสามารถติดเชื้อได้มากที่สุด 1 คนในหนึ่งวินาที
สามารถแสดงให้เห็นได้ว่าหลังจากเวลาจำกัดวินาที เด็กทั้งหมดในคิวจะติดเชื้อโรค ลำดับการติดเชื้อคือลำดับลำดับของตำแหน่งที่เด็กที่ไม่ติดเชื้อทั้งหมดติดเชื้อโรค ส่งคืนจำนวนทั้งหมดของลำดับการติดเชื้อที่เป็นไปได้
เนื่องจากคำตอบอาจมีค่ามาก ให้ส่งคืนค่าโมดูโล 10^9 + 7
โปรดทราบว่าลำดับการติดเชื้อไม่มีตำแหน่งของเด็กที่ติดเชื้อโรคไปแล้วในตอนแรก

ตัวอย่าง 1:

อินพุต: n = 5, sick = [0,4]
เอาต์พุต: 4
คำอธิบาย: เด็กที่ตำแหน่ง 1, 2 และ 3 ไม่ติดเชื้อในตอนเริ่มต้น มีลำดับการติดเชื้อที่เป็นไปได้ 4 ลำดับ:
- เด็กที่ตำแหน่ง 1 และ 3 สามารถติดเชื้อได้เนื่องจากตำแหน่งของพวกเขาอยู่ติดกับเด็กที่ติดเชื้อ 0 และ 4 เด็กที่ตำแหน่ง 1 ติดเชื้อก่อน
ขณะนี้ เด็กที่ตำแหน่ง 2 อยู่ติดกับเด็กที่ตำแหน่ง 1 ซึ่งติดเชื้อ และเด็กที่ตำแหน่ง 3 อยู่ติดกับเด็กที่ตำแหน่ง 4 ซึ่งติดเชื้อ ดังนั้น เด็กคนใดคนหนึ่งจึงสามารถติดเชื้อได้ เด็กที่ตำแหน่ง 2 ติดเชื้อ
ในที่สุด เด็กที่ตำแหน่ง 3 ติดเชื้อเนื่องจากอยู่ติดกับเด็กที่ตำแหน่ง 2 และ 4 ซึ่งติดเชื้อ ลำดับการติดเชื้อคือ [1,2,3]
- เด็กที่ตำแหน่ง 1 และ 3 สามารถติดเชื้อได้เนื่องจากตำแหน่งของพวกเขาอยู่ติดกับเด็กที่ติดเชื้อ 0 และ 4 เด็กที่ตำแหน่ง 1 ติดเชื้อก่อน ตอนนี้เด็กในตำแหน่งที่ 2 อยู่ติดกับเด็กในตำแหน่งที่ 1 ซึ่งติดเชื้อ และเด็กในตำแหน่งที่ 3 อยู่ติดกับเด็กในตำแหน่งที่ 4 ซึ่งติดเชื้อ ดังนั้น เด็กคนใดคนหนึ่งอาจติดเชื้อได้ เด็กในตำแหน่งที่ 3 ติดเชื้อ
ในที่สุด เด็กในตำแหน่งที่ 2 ติดเชื้อเพราะอยู่ติดกับเด็กในตำแหน่งที่ 1 และ 3 ซึ่งติดเชื้อ ลำดับการติดเชื้อคือ [1,3,2]
- ลำดับการติดเชื้อคือ [3,1,2] ลำดับการติดเชื้อของโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4]
- ลำดับการติดเชื้อคือ [3,2,1] ลำดับการติดเชื้อในเด็กสามารถมองได้ดังนี้: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

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

อินพุต: n = 4, sick = [1]
เอาต์พุต: 3
คำอธิบาย: เด็กที่ตำแหน่ง 0, 2 และ 3 ไม่ได้รับการติดเชื้อในตอนเริ่มต้น มีลำดับการติดเชื้อที่เป็นไปได้ 3 ลำดับ:
- ลำดับการติดเชื้อคือ [0,2,3] ลำดับการติดเชื้อโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- ลำดับการติดเชื้อคือ [2,0,3] ลำดับการติดเชื้อโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- ลำดับการติดเชื้อคือ [2,3,0] ลำดับการติดเชื้อโรคในเด็กสามารถมองได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

ข้อจำกัด:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick จะถูกเรียงลำดับตามลำดับที่เพิ่มขึ้น

กำหนดจำนวนเต็ม n และอาร์เรย์จำนวนเต็ม 0-indexed sick ที่เรียงลำดับแบบเพิ่มขึ้น

มีเด็ก n คนยืนอยู่ในคิวโดยมีตำแหน่ง 0 ถึง n - 1 ถูกกำหนดให้พวกเขา อาร์เรย์ sick ประกอบด้วยตำแหน่งของเด็กที่ติดเชื้อโรคติดต่อ เด็กที่ติดเชื้อที่ตำแหน่ง i สามารถแพร่เชื้อไปยังเพื่อนบ้านข้างเคียงที่ตำแหน่ง i - 1 และ i + 1 ถ้ามีอยู่และยังไม่ติดเชื้อมาก่อน เด็กที่ไม่ติดเชื้อมาก่อนจะติดเชื้อได้ในเวลา 1 วินาทีเท่านั้น

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

เพราะว่าคำตอบอาจเป็นจำนวนมาก ให้คืนคำตอบนั้น mod กับ 10^9 + 7

โปรดทราบว่าลำดับการติดเชื้อไม่รวมตำแหน่งของเด็กที่ติดเชื้ออยู่แล้วตั้งแต่เริ่มต้น

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

Input: n = 5, sick = [0,4]
Output: 4
คำอธิบาย: เด็กที่ตำแหน่ง 1, 2 และ 3 ยังไม่ติดเชื้อตั้งแต่แรก มีลำดับการติดเชื้อที่เป็นไปได้ 4 แบบ:
- เด็กที่ตำแหน่ง 1 และ 3 สามารถติดเชื้อเพราะตำแหน่งอยู่ติดกับเด็กติดเชื้อที่ 0 และ 4 เด็กที่ตำแหน่ง 1 ติดเชื้อก่อน
ตอนนี้เด็กที่ตำแหน่ง 2 ติดกับเด็กที่ตำแหน่ง 1 ที่ติดเชื้ออยู่ และเด็กที่ตำแหน่ง 3 ติดกับเด็กที่ตำแหน่ง 4 ที่ติดเชื้ออยู่เช่นกัน ทำให้ทั้งสองคนใดก็ได้ติดเชื้อ เด็กที่ตำแหน่ง 2 ติดเชื้อ
สุดท้ายเด็กที่ตำแหน่ง 3 ติดเชื้อเพราะติดกับเด็กที่ตำแหน่ง 2 และ 4 ที่ติดเชื้อแล้ว ลำดับการติดเชื้อคือ [1,2,3]
- เด็กที่ตำแหน่ง 1 และ 3 สามารถติดเชื้อเพราะตำแหน่งอยู่ติดกับเด็กติดเชื้อที่ 0 และ 4 เด็กที่ตำแหน่ง 1 ติดเชื้อก่อน
ตอนนี้เด็กที่ตำแหน่ง 2 ติดกับเด็กที่ตำแหน่ง 1 ที่ติดเชื้อและเด็กที่ตำแหน่ง 3 ติดกับเด็กที่ตำแหน่ง 4 ที่ติดเชื้ออยู่เช่นกัน ทำให้ทั้งสองคนใดก็ได้ติดเชื้อ เด็กที่ตำแหน่ง 3 ติดเชื้อ
สุดท้ายเด็กที่ตำแหน่ง 2 ติดเชื้อเพราะติดกับเด็กที่ตำแหน่ง 1 และ 3 ที่ติดเชื้อแล้ว ลำดับการติดเชื้อคือ [1,3,2]
- ลำดับการติดเชื้อคือ [3,1,2] ลำดับการติดเชื้อคือ [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4]
- ลำดับการติดเชื้อคือ [3,2,1] ลำดับการติดเชื้อคือ [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4]

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

Input: n = 4, sick = [1]
Output: 3
คำอธิบาย: เด็กที่ตำแหน่ง 0, 2, และ 3 ยังไม่ติดเชื้อตั้งแต่แรก มีลำดับการติดเชื้อที่เป็นไปได้ 3 แบบ:
- ลำดับการติดเชื้อคือ [0,2,3] ลำดับการติดเชื้อของโรคในเด็กสามารถดูได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3]
- ลำดับการติดเชื้อคือ [2,0,3] ลำดับการติดเชื้อของโรคในเด็กสามารถดูได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3]
- ลำดับการติดเชื้อคือ [2,3,0] ลำดับการติดเชื้อของโรคในเด็กสามารถดูได้ดังนี้: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3]

เงื่อนไข:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick เรียงลำดับในแบบเพิ่มขึ้น


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

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

อินพุต: nums = [1,2,3,1,2,3,1,2], k = 2
เอาท์พุท: 6
คำอธิบาย: subarray ที่ดีที่สุดเท่าที่จะเป็นไปได้คือ [1,2,3,1,2,3] เนื่องจากค่า 1, 2 และ 3 เกิดขึ้นมากที่สุดสองครั้งใน subarray นี้ โปรดทราบว่า subarrays [2,3,1,2,3,1] และ [3,1,2,3,1,2] ก็ดีเช่นกัน
มันสามารถแสดงให้เห็นว่าไม่มี subarrays ที่ดีที่มีความยาวมากกว่า 6

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

อินพุต: nums = [1,2,1,2,1,2,1,2], k = 1
เอาท์พุท: 2
คำอธิบาย: subarray ที่ดีที่สุดเท่าที่จะเป็นไปได้คือ [1,2] เนื่องจากค่า 1 และ 2 เกิดขึ้นได้มากที่สุดครั้งหนึ่งใน subarray นี้ โปรดทราบว่า subarray [2,1] ก็ดีเช่นกัน
มันสามารถแสดงให้เห็นว่าไม่มี subarrays ที่ดีที่มีความยาวมากกว่า 2

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

อินพุต: nums = [5,5,5,5,5,5,5,5], k = 4
เอาท์พุท: 4
คำอธิบาย: subarray ที่ดีที่สุดเท่าที่จะเป็นไปได้คือ [5,5,5,5] เนื่องจากค่า 5 เกิดขึ้น 4 ครั้งใน subarray นี้
มันสามารถแสดงให้เห็นว่าไม่มี subarrays ที่ดีที่มีความยาวมากกว่า 4

ข้อ จำกัด :

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

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

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

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

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

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

อินพุต: nums = [5,5,5,5,5,5,5,5], k = 4
เอาท์พุท: 4
คำอธิบาย: subarray ที่ดีที่สุดเท่าที่จะเป็นไปได้คือ [5,5,5,5] เนื่องจากค่า 5 เกิดขึ้น 4 ครั้งใน subarray นี้
มันสามารถแสดงให้เห็นว่าไม่มี subarrays ที่ดีที่มีความยาวมากกว่า 4

ข้อ จำกัด :

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

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

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

Input: nums = [1,2,3,1,2,3,1,2], k = 2
Output: 6
คำอธิบาย: อาเรย์ย่อยที่ดีที่ยาวที่สุดคือ [1,2,3,1,2,3] เนื่องจากค่า 1, 2 และ 3 ปรากฏมากที่สุดสองครั้งในอาเรย์ย่อยนี้ ทั้งนี้อาเรย์ย่อย [2,3,1,2,3,1] และ [3,1,2,3,1,2] ก็เป็นอาเรย์ย่อยที่ดีเช่นกัน
แสดงให้เห็นว่าไม่มีอาเรย์ย่อยที่ดีที่มีความยาวเกินกว่า 6

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

Input: nums = [1,2,1,2,1,2,1,2], k = 1
Output: 2
คำอธิบาย: อาเรย์ย่อยที่ดีที่ยาวที่สุดคือ [1,2] เนื่องจากค่า 1 และ 2 ปรากฏมากที่สุดหนึ่งครั้งในอาเรย์นี้ย่อย ทั้งนี้อาเรย์ย่อย [2,1] ก็เป็นอาเรย์ย่อยที่ดีเช่นกัน
แสดงให้เห็นว่าไม่มีอาเรย์ย่อยที่ดีที่มีความยาวเกินกว่า 2

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

Input: nums = [5,5,5,5,5,5,5], k = 4
Output: 4
คำอธิบาย: อาเรย์ย่อยที่ดีที่ยาวที่สุดคือ [5,5,5,5] เนื่องจากค่า 5 ปรากฏ 4 ครั้งในอาเรย์ย่อยนี้
แสดงให้เห็นว่าไม่มีอาเรย์ย่อยที่ดีที่มีความยาวเกินกว่า 4

ข้อจำกัด:

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


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

ในแต่ละรอบ อลิซจะลบองค์ประกอบที่น้อยที่สุดจาก nums ก่อน จากนั้นบ็อบจะทำเช่นเดียวกัน
ตอนนี้ บ็อบจะเพิ่มองค์ประกอบที่ถูกลบลงในอาเรย์ arr ก่อน จากนั้นอลิซจะทำเช่นเดียวกัน
เกมจะดำเนินต่อไปจนกว่า nums จะว่างเปล่า

ส่งคืนอาเรย์ arr ที่ได้.

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

Input: nums = [5,4,2,3]
Output: [3,2,5,4]
คำอธิบาย: ในรอบแรก อลิซลบ 2 ก่อนแล้วบ็อบลบ 3 จากนั้นใน arr บ็อบเพิ่ม 3 และอลิซเพิ่ม 2 ดังนั้น arr = [3,2]
ในตอนเริ่มต้นของรอบที่สอง nums = [5,4] ตอนนี้ อลิซลบ 4 ก่อนแล้วบ็อบลบ 5 จากนั้นทั้งคู่เพิ่มลงใน arr ซึ่งกลายเป็น [3,2,5,4]

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

Input: nums = [2,5]
Output: [5,2]
คำอธิบาย: ในรอบแรก อลิซลบ 2 ก่อนแล้วบ็อบลบ 5 จากนั้นในอาร์เรย์ บ็อบเพิ่มเข้ามาก่อนแล้วอลิซเพิ่มเข้ามา ดังนั้นอาร์เรย์ = [5,2]

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0

คุณมีอาเรย์จำนวนเต็ม nums ที่เริ่มต้นด้วยดัชนี 0 ซึ่งมีความยาวเป็นเลขคู่ และยังมีอาเรย์ว่างชื่อ arr อลิซและบ๊อบตัดสินใจเล่นเกมที่ในแต่ละรอบอลิซและบ๊อบจะทำหนึ่งการย้าย กฎของเกมมีดังนี้:

ในแต่ละรอบ อลิซจะลบองค์ประกอบที่มีค่าน้อยที่สุดออกจาก nums ก่อน แล้วบ๊อบจะทำเช่นเดียวกัน
จากนั้น บ๊อบจะเพิ่มองค์ประกอบที่ถูกลบออกมาไปยังอาเรย์ arr ก่อน แล้วอลิซจะทำเช่นเดียวกัน
เกมจะดำเนินไปจนกว่า nums จะกลายเป็นว่างเปล่า

ส่งคืนอาเรย์ arr ที่ได้จากเกม

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

Input: nums = [5,4,2,3]
Output: [3,2,5,4]
คำอธิบาย: ในรอบแรก อลิซลบ 2 ก่อนแล้วบ๊อบลบ 3 จากนั้นใน arr บ๊อบเพิ่ม 3 ก่อนแล้วอลิซเพิ่ม 2 จึงทำให้ arr = [3,2]
เมื่อต้นรอบที่สอง nums = [5,4] ตอนนี้ อลิซลบ 4 ก่อนแล้วบ๊อบลบ 5 จากนั้นทั้งสองจึงเพิ่มใน arr ซึ่งกลายเป็น [3,2,5,4]

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

Input: nums = [2,5]
Output: [5,2]
คำอธิบาย: ในรอบแรก อลิซลบ 2 ก่อนแล้วบ๊อบลบ 5 แล้วใน arr บ๊อบเพิ่มก่อนและแล้วอลิซเพิ่ม arr จึงกลายเป็น [5,2]

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0

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

ทุกรอบอลิซแรกจะลบองค์ประกอบขั้นต่ำออกจาก nums แล้วบ๊อบก็ทำเช่นเดียวกัน
ตอนนี้บ๊อบจะผนวกองค์ประกอบที่ถูกลบในอาร์เรย์ arr แล้วอลิซก็ทำเช่นเดียวกัน
เกมยังคงดำเนินต่อไปจนกระทั่ง nums ว่างเปล่า

ส่งคืนอาร์เรย์ที่เกิดขึ้น arr

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

อินพุต: nums = [5,4,2,3]
เอาท์พุท: [3,2,5,4]
คำอธิบาย: ในรอบที่หนึ่งอลิซแรกจะลบ 2 แล้วบ๊อบจะลบออก 3 จากนั้นใน arr แรกบ๊อบจะผนวก 3 แล้วอลิซผนวก 2. ดังนั้น arr = [3,2]
ในรอบสอง, nums = [5,4] ตอนนี้อลิซแรกจะลบ 4 แล้วบ๊อบจะลบ 5 ออกจากนั้นทั้งสองต่อท้ายใน arr ซึ่งกลายเป็น [3,2,5,4]

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

อินพุต: nums = [2,5]
เอาท์พุท: [5,2]
คำอธิบาย: ในรอบที่หนึ่งอลิซแรกจะลบ 2 แล้วบ๊อบจะลบ 5. จากนั้นใน arr บ๊อบจะผนวกต่อท้ายจากนั้นอลิซต่อท้าย ดังนั้น arr = [5,2]

ข้อ จำกัด :

1 <= nums.length <= 100
1 <= nums [i] <= 100
nums.length % 2 == 0


คุณได้รับเมทริกซ์จำนวนเต็ม 2 มิติที่มีขนาด n * n โดยมีค่าอยู่ในช่วง [1, n^2] โดยแต่ละจำนวนจะปรากฏเพียงครั้งเดียว ยกเว้นจำนวน a ที่ปรากฏสองครั้งและจำนวน b ที่หายไป งานของคุณคือการหาหมายเลขที่ซ้ำกันและหมายเลขที่หายไป a และ b คืนค่าอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นที่ 0 ชนิด ans ขนาด 2 โดยที่ ans[0] เท่ากับ a และ ans[1] เท่ากับ b

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

Input: grid = [[1,3],[2,2]]
Output: [2,4]
คำอธิบาย: หมายเลข 2 ถูกทำซ้ำและหมายเลข 4 ขาดหายไป ดังนั้นคำตอบคือ [2,4].

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

Input: grid = [[9,1,7],[8,9,2],[3,4,6]]
Output: [9,5]
คำอธิบาย: หมายเลข 9 ถูกทำซ้ำและหมายเลข 5 ขาดหายไป ดังนั้นคำตอบคือ [9,5].

ข้อจำกัด:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
สำหรับทุก x ที่ 1 <= x <= n * n จะมี x เพียงหนึ่งเดียวที่ไม่เท่ากับสมาชิกใด ๆ ของกริด
สำหรับทุก x ที่ 1 <= x <= n * n จะมี x เพียงหนึ่งเดียวที่เท่ากับสมาชิกของกริดที่มีค่าเท่ากันสองตัว
สำหรับทุก x ที่ 1 <= x <= n * n ยกเว้นสองตัว จะมีคู่ของ i, j ที่มีค่า 0 <= i, j <= n - 1 และ grid[i][j] == x เพียงหนึ่งคู่

คุณจะได้รับตารางเมทริกซ์จำนวนเต็ม 2 มิติที่มีดัชนี 0 ขนาด n * n โดยมีค่าอยู่ในช่วง [1, n^2] จำนวนเต็มแต่ละจำนวนปรากฏเพียงครั้งเดียว ยกเว้น a ซึ่งปรากฏสองครั้งและ b ซึ่งหายไป ภารกิจคือค้นหาจำนวนที่ซ้ำกันและหายไป a และ b
ส่งคืนอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ans ขนาด 2 โดยที่ ans[0] เท่ากับ a และ ans[1] เท่ากับ b

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

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

อินพุต: grid = [[9,1,7],[8,9,2],[3,4,6]]
เอาต์พุต: [9,5]
คำอธิบาย: ตัวเลข 9 ซ้ำกันและไม่มีตัวเลข 5 ดังนั้นคำตอบคือ [9,5]

ข้อจำกัด:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
สำหรับ x ทั้งหมดที่ 1 <= x <= n * n จะมี x หนึ่งตัวเท่านั้นที่ไม่เท่ากับสมาชิกกริดใดๆ
สำหรับ x ทั้งหมดที่ 1 <= x <= n * n จะมี x หนึ่งตัวเท่านั้นที่เท่ากับสมาชิกกริดสองตัวเท่านั้น
สำหรับ x ทั้งหมดที่ 1 <= x <= n * n ยกเว้นสองตัว มีคู่ i, j หนึ่งคู่เท่านั้นที่ 0 <= i, j <= n - 1 และ grid[i][j] == x

คุณจะได้รับเมทริกซ์จำนวนเต็ม 2D ที่มีดัชนี 0 ขนาด n * n พร้อมค่าในช่วง [1, n^2] จำนวนเต็มแต่ละตัวปรากฏขึ้นอย่างแน่นอนยกเว้น a ซึ่งปรากฏขึ้นสองครั้งและ b ซึ่งหายไป ภารกิจคือการหาตัวเลขที่ทำซ้ำและหายไป a และ b
ส่งคืนอาร์เรย์จำนวนเต็ม ans ขนาด 2 ที่มีดัชนี 0 โดยที่ ans [0] เท่ากับ a และ ans [1] เท่ากับ b

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

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

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

อินพุต: grid = [[9,1,7], [8,9,2], [3,4,6]]
เอาท์พุท: [9,5]
คำอธิบาย: หมายเลข 9 ซ้ำแล้วซ้ำอีกและหมายเลข 5 หายไปดังนั้นคำตอบคือ [9,5]

ข้อ จำกัด :

2 <= n == grid.length == grid [i] .length <= 50
1 <= grid [i] [j] <= n * n
สำหรับ x ทั้งหมดที่ 1 <= x <= n * n มีหนึ่ง x ที่ไม่เท่ากับสมาชิกกริดใด ๆ
สำหรับ x ทั้งหมดที่ 1 <= x <= n * n มีหนึ่ง x ที่เท่ากับสมาชิกกริดสองคน
สำหรับ x ทั้งหมดที่ 1 <= x <= n * n ยกเว้นสองตัว มีเพียงหนึ่งคู่ของ i, j ที่ 0 <= i, j <= n - 1 และ grid[i][j] == x