คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 จำนวน 2 ชุด คือ nums1 และ nums2 ที่มีความยาวคู่ n
คุณต้องลบองค์ประกอบ n/2 ออกจาก nums1 และองค์ประกอบ n/2 ออกจาก nums2 หลังจากการลบองค์ประกอบเหล่านี้แล้ว คุณแทรกองค์ประกอบที่เหลือของ nums1 และ nums2 ลงในเซต s
ส่งคืนขนาดสูงสุดที่เป็นไปได้ของเซต s

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

อินพุต: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
เอาต์พุต: 2
คำอธิบาย: เราลบ 1 ที่เกิดขึ้นสองครั้งจาก nums1 และ nums2 หลังจากการลบองค์ประกอบเหล่านี้แล้ว อาร์เรย์จะเท่ากับ nums1 = [2,2] และ nums2 = [1,1] ดังนั้น s = {1,2}
สามารถแสดงได้ว่า 2 คือขนาดสูงสุดที่เป็นไปได้ของเซต s หลังจากการลบองค์ประกอบเหล่านี้

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

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

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

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

ข้อจำกัด:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n เป็นเลขคู่
1 <= nums1[i], nums2[i] <= 10^9

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

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

Input: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Output: 2
คำอธิบาย: เราลบจำนวน 1 สองครั้งจาก nums1 และ nums2 หลังจากการลบ อาร์เรย์จะกลายเป็น nums1 = [2,2] และ nums2 = [1,1] ดังนั้น s = {1,2} สามารถแสดงให้เห็นได้ว่า 2 เป็นขนาดสูงสุดที่เป็นไปได้ของเซ็ต s หลังจากการลบ

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

Input: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Output: 5
คำอธิบาย: เราลบ 2, 3 และ 6 ออกจาก nums1 รวมถึง 2 และจำนวน 3 สองครั้งจาก nums2 หลังจากการลบ อาร์เรย์จะกลายเป็น nums1 = [1,4,5] และ nums2 = [2,3,2] ดังนั้น s = {1,2,3,4,5} สามารถแสดงให้เห็นได้ว่า 5 เป็นขนาดสูงสุดที่เป็นไปได้ของเซ็ต s หลังจากการลบ

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

Input: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Output: 6
คำอธิบาย:เราลบ 1, 2 และ 3 ออกจาก nums1 รวมถึง 4, 5 และ 6 จาก nums2 หลังจากการลบ อาร์เรย์จะกลายเป็น nums1 = [1,2,3] และ nums2 = [4,5,6] ดังนั้น s = {1,2,3,4,5,6} สามารถแสดงให้เห็นได้ว่า 6 เป็นขนาดสูงสุดที่เป็นไปได้ของเซ็ต s หลังจากการลบ

ข้อจำกัด:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n เป็นเลขคู่
1 <= nums1[i], nums2[i] <= 10^9

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

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

Input:

nums1 = [1,2,1,2]
nums2 = [1,1,1,1]

Output:

2

Explanation:
เราลบ 1 ออกจาก ￼ และ ￼ อย่างละ 2 ครั้ง
หลังจากการลบ อาร์เรย์กลายเป็น ￼ และ ￼
ดังนั้น ￼
แสดงได้ว่าขนาดสูงสุดของเซต ￼ คือ 2

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

Input:

nums1 = [1,2,3,4,5,6]
nums2 = [2,3,2,3,2,3]

Output:

5

Explanation:
เราลบ 2, 3 และ 6 จาก ￼ รวมถึงลบ 2 และ 3 (2 ครั้ง) จาก ￼
หลังจากการลบ อาร์เรย์กลายเป็น ￼ และ ￼
ดังนั้น ￼
แสดงได้ว่าขนาดสูงสุดของเซต ￼ คือ 5

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

Input:

nums1 = [1,1,2,2,3,3]
nums2 = [4,4,5,5,6,6]

Output:

6

Explanation:
เราลบ 1, 2 และ 3 จาก ￼ รวมถึงลบ 4, 5 และ 6 จาก ￼
หลังจากการลบ อาร์เรย์กลายเป็น ￼ และ ￼
ดังนั้น ￼
แสดงได้ว่าขนาดสูงสุดของเซต ￼ คือ 6

ข้อจำกัด:
	n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n คือคู่
1 <= nums1[i], nums2[i] <= 10^9￼


คุณมีอาเรย์จำนวนเต็ม nums แบบ 0-indexed ที่มีความยาว n

คุณสามารถทำการเคลื่อนไหวพิเศษได้จำนวนครั้งใด ๆ (รวมถึงศูนย์) บน nums ในการเคลื่อนไหวพิเศษหนึ่งครั้ง ให้ทำตามขั้นตอนดังนี้:

เลือกดัชนี i ในช่วง [0, n - 1] และจำนวนเต็มบวก x
เพิ่ม |nums[i] - x| เข้ากับค่าใช้จ่ายรวม
เปลี่ยนค่า nums[i] เป็น x

จำนวนที่เป็นปาลินโดรมิกคือจำนวนเต็มบวกที่ยังคงเหมือนเดิมเมื่อตัวเลขถูกกลับด้าน เช่น 121, 2552 และ 65756 เป็นจำนวนที่เป็นปาลินโดรมิก ในขณะที่ 24, 46, 235 ไม่เป็นจำนวนที่เป็นปาลินโดรมิก
อาเรย์ถือว่าเป็น equalindromic หากองค์ประกอบทุกตัวในอาเรย์มีค่าเท่ากับจำนวนเต็ม y ที่ y เป็นจำนวนที่เป็นปาลินโดรมิกน้อยกว่า 10^9
คืนค่าจำนวนเต็มที่แสดงถึงค่าใช้จ่ายรวมขั้นต่ำที่ทำให้ nums เป็น equalindromic โดยการทำเคลื่อนไหวพิเศษใด ๆ

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

Input: nums = [1,2,3,4,5]
Output: 6
อธิบาย: เราสามารถทำให้อาเรย์เป็น equalindromic โดยเปลี่ยนทุกองค์ประกอบเป็น 3 ซึ่งเป็นจำนวนที่เป็นปาลินโดรมิก ค่าใช้จ่ายในการเปลี่ยนอาเรย์เป็น [3,3,3,3,3] โดยใช้การเคลื่อนไหวพิเศษ 4 ครั้งคือ |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6
สามารถแสดงได้ว่าการเปลี่ยนแปลงทุกองค์ประกอบเป็นจำนวนที่เป็นปาลินโดรมิกอื่นนอกเหนือจาก 3 ไม่สามารถทำได้ในค่าที่ต่ำกว่า

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

Input: nums = [10,12,13,14,15]
Output: 11
อธิบาย: เราสามารถทำให้อาเรย์เป็น equalindromic โดยเปลี่ยนทุกองค์ประกอบเป็น 11 ซึ่งเป็นจำนวนที่เป็นปาลินโดรมิก ค่าใช้จ่ายในการเปลี่ยนอาเรย์เป็น [11,11,11,11,11] โดยใช้การเคลื่อนไหวพิเศษ 5 ครั้งคือ |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11
สามารถแสดงได้ว่าการเปลี่ยนแปลงทุกองค์ประกอบเป็นจำนวนที่เป็นปาลินโดรมิกอื่นนอกเหนือจาก 11 ไม่สามารถทำได้ในค่าที่ต่ำกว่า

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

Input: nums = [22,33,22,33,22]
Output: 22
อธิบาย: เราสามารถทำให้อาเรย์เป็น equalindromic โดยเปลี่ยนทุกองค์ประกอบเป็น 22 ซึ่งเป็นจำนวนที่เป็นปาลินโดรมิก ค่าใช้จ่ายในการเปลี่ยนอาเรย์เป็น [22,22,22,22,22] โดยใช้การเคลื่อนไหวพิเศษ 2 ครั้งคือ |33 - 22| + |33 - 22| = 22
สามารถแสดงได้ว่าการเปลี่ยนแปลงทุกองค์ประกอบเป็นจำนวนที่เป็นปาลินโดรมิกอื่นนอกเหนือจาก 22 ไม่สามารถทำได้ในค่าที่ต่ำกว่า

เงื่อนไข:

1 <= n <= 10^5
1 <= nums[i] <= 10^9

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 nums ที่มีความยาว n
คุณสามารถทำการเคลื่อนไหวพิเศษได้หลายครั้ง (รวมถึงศูนย์) ในการเคลื่อนไหวพิเศษครั้งหนึ่ง คุณต้องดำเนินการตามขั้นตอนต่อไปนี้ตามลำดับ:

เลือกดัชนี i ในช่วง [0, n - 1] และจำนวนเต็มบวก x
เพิ่ม |nums[i] - x| ลงในต้นทุนรวม
เปลี่ยนค่าของ nums[i] เป็น x

จำนวนพาลินโดรมคือจำนวนเต็มบวกที่ยังคงเท่าเดิมเมื่อสลับตัวเลข ตัวอย่างเช่น 121, 2552 และ 65756 เป็นจำนวนพาลินโดรม ในขณะที่ 24, 46, 235 ไม่ใช่จำนวนพาลินโดรม
อาร์เรย์จะถือว่าเท่ากันหากองค์ประกอบทั้งหมดในอาร์เรย์เท่ากับจำนวนเต็ม y โดยที่ y คือจำนวนพาลินโดรมที่น้อยกว่า 10^9 ส่งคืนจำนวนเต็มที่แสดงถึงต้นทุนรวมต่ำสุดที่เป็นไปได้ในการทำให้ nums เท่ากันโดยใช้การเคลื่อนไหวพิเศษจำนวนเท่าใดก็ได้

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

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

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

อินพุต: nums = [10,12,13,14,15]
เอาต์พุต: 11
คำอธิบาย: เราสามารถสร้างอาร์เรย์ให้เท่ากันได้โดยเปลี่ยนองค์ประกอบทั้งหมดเป็น 11 ซึ่งเป็นตัวเลขพาลินโดรม ค่าใช้จ่ายในการเปลี่ยนอาร์เรย์เป็น [11,11,11,11,11] โดยใช้การเคลื่อนไหวพิเศษ 5 ครั้งคือ |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11
จะเห็นว่าการเปลี่ยนองค์ประกอบทั้งหมดเป็นตัวเลขพาลินโดรมอื่นที่ไม่ใช่ 11 นั้นไม่สามารถทำได้ด้วยต้นทุนที่ต่ำกว่า

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

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

ข้อจำกัด:

1 <= n <= 10^5
1 <= nums[i] <= 10^9

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 nums ที่มีความยาว n
คุณสามารถทำการเคลื่อนไหวพิเศษได้หลายครั้ง (รวมถึงศูนย์) ในการเคลื่อนไหวพิเศษครั้งหนึ่ง คุณต้องดำเนินการตามขั้นตอนต่อไปนี้ตามลำดับ:

เลือกดัชนี i ในช่วง [0, n - 1] และจำนวนเต็มบวก x
เพิ่ม |nums[i] - x| ลงในต้นทุนรวม
เปลี่ยนค่าของ nums[i] เป็น x

จำนวนพาลินโดรมคือจำนวนเต็มบวกที่ยังคงเท่าเดิมเมื่อสลับตัวเลข ตัวอย่างเช่น 121, 2552 และ 65756 เป็นจำนวนพาลินโดรม ในขณะที่ 24, 46, 235 ไม่ใช่จำนวนพาลินโดรม
อาร์เรย์จะถือว่าเท่ากันหากองค์ประกอบทั้งหมดในอาร์เรย์เท่ากับจำนวนเต็ม y โดยที่ y คือจำนวนพาลินโดรมที่น้อยกว่า 10^9 ส่งคืนจำนวนเต็มที่แสดงถึงต้นทุนรวมต่ำสุดที่เป็นไปได้ในการทำให้ nums เท่ากันโดยใช้การเคลื่อนไหวพิเศษจำนวนเท่าใดก็ได้

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

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

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

อินพุต: nums = [10,12,13,14,15]
เอาต์พุต: 11
คำอธิบาย: เราสามารถสร้างอาร์เรย์ให้เท่ากันได้โดยเปลี่ยนองค์ประกอบทั้งหมดเป็น 11 ซึ่งเป็นตัวเลขพาลินโดรม ค่าใช้จ่ายในการเปลี่ยนอาร์เรย์เป็น [11,11,11,11,11] โดยใช้การเคลื่อนไหวพิเศษ 5 ครั้งนั้นกำหนดโดย |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11
จะเห็นว่าการเปลี่ยนองค์ประกอบทั้งหมดเป็นตัวเลขพาลินโดรมอื่นที่ไม่ใช่ 11 นั้นไม่สามารถทำได้ด้วยต้นทุนที่ต่ำกว่า

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

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

ข้อจำกัด:

1 <= n <= 10^5
1 <= nums[i] <= 10^9


คุณจะได้รับคำที่มีดัชนีเริ่มต้นที่ 0
ในการดำเนินการครั้งหนึ่ง คุณสามารถเลือกดัชนี i ของคำและเปลี่ยน word[i] เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กใดๆ ก็ได้
คืนจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการลบอักขระที่เกือบเท่ากันที่อยู่ติดกันทั้งหมดออกจากคำ
อักขระ a และ b สองตัวจะเกือบเท่ากันหาก a == b หรือ a และ b อยู่ติดกันในตัวอักษร

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

อินพุต: word = "aaaaa"
เอาต์พุต: 2
คำอธิบาย: เราสามารถเปลี่ยนคำเป็น "acaca" ซึ่งไม่มีอักขระที่เกือบเท่ากันที่อยู่ติดกันใดๆ
จะเห็นว่าจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการลบอักขระที่เกือบเท่ากันที่อยู่ติดกันทั้งหมดออกจากคำคือ 2

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

อินพุต: word = "abddez"
เอาต์พุต: 2
คำอธิบาย: เราสามารถเปลี่ยนคำเป็น "ybdoez" ซึ่งไม่มีอักขระที่เกือบเท่ากันที่อยู่ติดกันใดๆ แสดงให้เห็นว่าจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการลบอักขระที่เกือบเท่ากันที่อยู่ติดกันทั้งหมดออกจากคำคือ 2
ตัวอย่างที่ 3:

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

ข้อจำกัด:

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

คุณจะได้รับสตริงที่มีดัชนีเริ่มต้นที่ 0
ในการดำเนินการครั้งเดียว คุณสามารถเลือกดัชนี i ของwordและเปลี่ยน word[i] เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กใด ๆ
ส่งคืนจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการลบอักขระเกือบเท่ากันทั้งหมดที่อยู่ติดกันทั้งหมดออกจาก word
อักขระสองตัว a และ b เกือบเท่ากันถ้า a == b หรือ a และ b อยู่ติดกันในตัวอักษร

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

อินพุต: word = "aaaaa"
เอาท์พุท: 2
wordอธิบาย: เราสามารถเปลี่ยนwordเป็น "acaca" ซึ่งไม่มีอักขระเกือบเท่ากันที่อยู่ติดกัน
สามารถพิสูจน์ได้ว่าจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการลบอักขระเกือบเท่ากันทั้งหมดที่อยู่ติดกันทั้งหมดออกจาก word คือ 2

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

อินพุต: word = "abddez"
เอาท์พุท: 2
wordอธิบาย: เราสามารถเปลี่ยนwordเป็น "ybdoez" ซึ่งไม่มีอักขระเกือบเท่ากันที่อยู่ติดกัน
มันสามารถแสดงให้เห็นว่าจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการลบอักขระเกือบเท่ากันทั้งหมดที่อยู่ติดกันทั้งหมดออกจาก Word คือ 2
ตัวอย่างที่ 3:

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

ข้อ จำกัด :

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


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

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

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

อินพุต: coins = [1,4,10], target = 19
เอาต์พุต: 2
คำอธิบาย: เราต้องเพิ่มเหรียญ 2 และ 8 อาร์เรย์ที่ได้จะเป็น [1,2,4,8,10] จะเห็นได้ว่าจำนวนเต็มทั้งหมดตั้งแต่ 1 ถึง 19 ได้จากอาร์เรย์ผลลัพธ์ และ 2 คือจำนวนเหรียญขั้นต่ำที่ต้องเพิ่มเข้าไปในอาร์เรย์

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

อินพุต: coins = [1,4,10,5,7,19], target = 19
เอาต์พุต: 1
คำอธิบาย: เราต้องเพิ่มเหรียญ 2 เท่านั้น อาร์เรย์ผลลัพธ์จะเป็น [1,2,4,5,7,10,19]
จะเห็นได้ว่าจำนวนเต็มทั้งหมดตั้งแต่ 1 ถึง 19 ได้จากอาร์เรย์ผลลัพธ์ และ 1 คือจำนวนเหรียญขั้นต่ำที่ต้องเพิ่มเข้าไปในอาร์เรย์

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

อินพุต: coins = [1,1,1], target = 20
เอาต์พุต: 3
คำอธิบาย: เราต้องเพิ่มเหรียญ 4, 8 และ 16 อาร์เรย์ผลลัพธ์จะเป็น [1,1,1,4,8,16] จะเห็นได้ว่าจำนวนเต็มทั้งหมดตั้งแต่ 1 ถึง 20 สามารถรับได้จากอาร์เรย์ที่ได้ และ 3 คือจำนวนเหรียญขั้นต่ำที่ต้องเพิ่มเข้าไปในอาร์เรย์

ข้อจำกัด:

1 <=  target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= เป้าหมาย

คุณจะได้รับอาร์เรย์ของเหรียญที่มีดัชนีเริ่มต้นที่ 0 ซึ่งแสดงถึงค่าของเหรียญที่มีอยู่ และเป้าหมายจํานวนเต็ม
จํานวนเต็ม x สามารถหาได้หากมีลําดับย่อยของเหรียญที่รวมเป็น x
ส่งคืนจํานวนเหรียญขั้นต่ําของค่าใด ๆ ที่ต้องเพิ่มลงในอาร์เรย์เพื่อให้สามารถรับจํานวนเต็มทั้งหมดในช่วง [1, target] ได้
ลําดับย่อยของอาร์เรย์คืออาร์เรย์ใหม่ที่ไม่ว่างเปล่าที่เกิดขึ้นจากอาร์เรย์เดิมโดยการลบองค์ประกอบบางส่วน (อาจไม่มี) โดยไม่รบกวนตําแหน่งสัมพัทธ์ขององค์ประกอบที่เหลือ

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

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

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

อินพุต: coins = [1,4,10,5,7,19], target = 19
เอาท์พุต: 1
คําอธิบาย: เราต้องเพิ่มเหรียญ 2 เท่านั้น อาร์เรย์ผลลัพธ์จะเป็น [1,2,4,5,7,10,19]
สามารถแสดงได้ว่าจํานวนเต็มทั้งหมดตั้งแต่ 1 ถึง 19 สามารถหาได้จากอาร์เรย์ผลลัพธ์ และ 1 คือจํานวนเหรียญขั้นต่ําที่ต้องเพิ่มลงในอาร์เรย์

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

อินพุต: coins = [1,1,1], target= 20
เอาท์พุต: 3
คําอธิบาย: เราต้องเพิ่มเหรียญ 4, 8 และ 16 อาร์เรย์ผลลัพธ์จะเป็น [1,1,1,4,8,16]
สามารถแสดงได้ว่าจํานวนเต็มทั้งหมดตั้งแต่ 1 ถึง 20 สามารถหาได้จากอาร์เรย์ผลลัพธ์ และ 3 คือจํานวนเหรียญขั้นต่ําที่ต้องเพิ่มลงในอาร์เรย์

ข้อจํากัด:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

คุณมีกลุ่มตัวเลขเต็ม coins ที่มีดัชนีเริ่มต้นที่ 0 ซึ่งแสดงค่าของเหรียญที่มี และมีจำนวนเต็ม target
จำนวนเต็ม x สามารถทำได้หากมีอนุกรมย่อยของ coins ที่รวมกันได้เป็น x
ให้คืนจำนวนเหรียญขั้นต่ำที่ต้องเพิ่มเข้ากับอาเรย์เพื่อให้ทุกจำนวนเต็มในช่วง [1, target] สามารถทำได้
อนุกรมย่อยของอาเรย์คือตัวอาเรย์ใหม่ที่ไม่ว่างซึ่งสร้างขึ้นจากอาเรย์ต้นฉบับโดยการลบบาง (อาจไม่มี) ของสมาชิกออก โดยไม่เปลี่ยนแปลงลำดับของสมาชิกที่เหลือ

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

Input: coins = [1,4,10], target = 19
Output: 2
คำอธิบาย: เราจำเป็นต้องเพิ่มเหรียญ 2 และ 8 อาเรย์ที่ได้จะเป็น [1,2,4,8,10]
สามารถแสดงได้ว่าทุกจำนวนเต็มจาก 1 ถึง 19 ทำได้จากอาเรย์ที่ได้ และ 2 คือจำนวนขั้นต่ำของเหรียญที่ต้องเพิ่มเข้า

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

Input: coins = [1,4,10,5,7,19], target = 19
Output: 1
คำอธิบาย: เราจำเป็นต้องเพิ่มเหรียญ 2 เท่านั้น อาเรย์ที่ได้จะเป็น [1,2,4,5,7,10,19]
สามารถแสดงได้ว่าทุกจำนวนเต็มจาก 1 ถึง 19 ทำได้จากอาเรย์ที่ได้ และ 1 คือจำนวนขั้นต่ำของเหรียญที่ต้องเพิ่มเข้า

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

Input: coins = [1,1,1], target = 20
Output: 3
คำอธิบาย: เราจำเป็นต้องเพิ่มเหรียญ 4, 8 และ 16 อาเรย์ที่ได้จะเป็น [1,1,1,4,8,16]
สามารถแสดงได้ว่าทุกจำนวนเต็มจาก 1 ถึง 20 ทำได้จากอาเรย์ที่ได้ และ 3 คือจำนวนขั้นต่ำของเหรียญที่ต้องเพิ่มเข้า

ข้อจำกัด:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target


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

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

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

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

อินพุต: s = "accca", k = 2
เอาต์พุต: 3
คำอธิบาย: ในตัวอย่างนี้ เพื่อเพิ่มจำนวนพาร์ติชันที่เกิดขึ้นให้ได้มากที่สุด s[2] สามารถเปลี่ยนเป็น 'b' ได้
s จะกลายเป็น "acbca" ตอนนี้สามารถดำเนินการดังต่อไปนี้จนกว่า s จะว่างเปล่า:
- เลือกคำนำหน้าที่ยาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 2 ตัว คือ "acbca"
- ลบคำนำหน้า และ s จะกลายเป็น "bca" จำนวนพาร์ติชันตอนนี้คือ 1
- เลือกคำนำหน้าที่ยาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 2 ตัว คือ "bca"
- ลบคำนำหน้า และ s จะกลายเป็น "a" จำนวนพาร์ติชันตอนนี้คือ 2
- เลือกคำนำหน้าที่ยาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 2 ตัว คือ "a"
- ลบคำนำหน้า และ s จะกลายเป็นว่างเปล่า จำนวนพาร์ติชันตอนนี้คือ 3
ดังนั้น คำตอบคือ 3
จะแสดงให้เห็นว่าไม่สามารถรับพาร์ติชันได้มากกว่า 3 พาร์ติชัน
ตัวอย่างที่ 2:

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

จะแสดงให้เห็นว่าไม่สามารถรับพาร์ติชันได้มากกว่า 1 พาร์ติชัน

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

อินพุต: s = "xxyz", k = 1
เอาต์พุต: 4
คำอธิบาย: ในตัวอย่างนี้ เพื่อเพิ่มจำนวนพาร์ติชันที่เกิดขึ้นให้สูงสุด s[1] สามารถเปลี่ยนเป็น 'a' ได้
s จะกลายเป็น "xayz"
ตอนนี้สามารถดำเนินการดังต่อไปนี้จนกว่า s จะว่างเปล่า:
- เลือกคำนำหน้าที่ยาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 1 ตัว คือ "xayz"
- ลบคำนำหน้า และ s จะกลายเป็น "ayz" จำนวนพาร์ติชันตอนนี้คือ 1
- เลือกคำนำหน้าที่ยาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 1 ตัว คือ "ayz" - ลบคำนำหน้าออก แล้ว s จะกลายเป็น "yz" จำนวนพาร์ติชันตอนนี้คือ 2
- เลือกคำนำหน้าที่ยาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 1 ตัว คือ "yz"
- ลบคำนำหน้าออก แล้ว s จะกลายเป็น "z" จำนวนพาร์ติชันตอนนี้คือ 3
- เลือกคำนำหน้าที่ยาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 1 ตัว คือ "z"
- ลบคำนำหน้าออก แล้ว s จะกลายเป็นว่าง จำนวนพาร์ติชันตอนนี้คือ 4
ดังนั้น คำตอบคือ 4
สามารถแสดงให้เห็นว่าไม่สามารถรับพาร์ติชันมากกว่า 4 พาร์ติชันได้

ข้อจำกัด:

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

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

เลือกคำนำหน้ายาวที่สุดของ s ที่มีอักขระที่แตกต่างกันไม่เกิน k ตัว
ลบคำนำหน้าจาก s และเพิ่มจำนวนพาร์ติชันด้วยหนึ่ง อักขระที่เหลือ (ถ้ามี) ใน s รักษาคำสั่งเริ่มต้นของพวกเขา

ก่อนการดำเนินการคุณจะได้รับอนุญาตให้เปลี่ยนดัชนีสูงสุดหนึ่งตัวใน S เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กอีกตัวหนึ่ง
ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนสูงสุดของพาร์ติชันผลลัพธ์หลังจากการดำเนินการโดยเลือกอย่างเหมาะสมในการเปลี่ยนแปลงดัชนีสูงสุดหนึ่งตัว
ตัวอย่างที่ 1:

อินพุต: s = "accca", k = 2
เอาท์พุท: 3
คำอธิบาย: ในตัวอย่างนี้เพื่อเพิ่มจำนวนพาร์ติชันผลลัพธ์สูงสุด s [2] สามารถเปลี่ยนเป็น 'b' ได้
s กลายเป็น "acbca"
ตอนนี้การดำเนินการสามารถทำได้ดังนี้จนกว่า s จะว่างเปล่า:
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันมากที่สุด "acsca"
- ลบคำนำหน้าและ s กลายเป็น "bca" จำนวนพาร์ติชันคือ 1
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันมากที่สุด 2 ตัวคือ "bca"
- ลบคำนำหน้าและ s กลายเป็น "a" จำนวนพาร์ติชันคือ 2
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันไม่เกิน 2 ตัว "a"
- ลบคำนำหน้าและ s จะว่างเปล่า จำนวนพาร์ติชันตอนนี้ 3
ดังนั้นคำตอบคือ 3
มันสามารถแสดงให้เห็นว่ามันเป็นไปไม่ได้ที่จะได้รับมากกว่า 3 พาร์ติชัน
ตัวอย่างที่ 2:

อินพุต: s = "aabaab", k = 3
เอาท์พุท: 1
คำอธิบาย: ในตัวอย่างนี้เพื่อเพิ่มจำนวนพาร์ติชันผลลัพธ์สูงสุดที่เราสามารถทิ้งไว้ได้
ตอนนี้การดำเนินการสามารถทำได้ดังนี้จนกว่า s จะว่างเปล่า:
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันมากที่สุด "aabaab"
- ลบคำนำหน้าและ S จะว่างเปล่า จำนวนพาร์ติชันกลายเป็น 1
ดังนั้นคำตอบคือ 1
มันสามารถแสดงให้เห็นว่ามันเป็นไปไม่ได้ที่จะได้รับมากกว่า 1 พาร์ติชัน

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

อินพุต: s = "xxyz", k = 1
เอาท์พุท: 4
คำอธิบาย: ในตัวอย่างนี้เพื่อเพิ่มจำนวนพาร์ติชันผลลัพธ์สูงสุด S [1] สามารถเปลี่ยนเป็น 'a' ได้
s กลายเป็น "xayz"
ตอนนี้การดำเนินการสามารถทำได้ดังนี้จนกว่า s จะว่างเปล่า:
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันมากที่สุด "xayz"
- ลบคำนำหน้าและ s กลายเป็น "ayz" จำนวนพาร์ติชันคือ 1
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันมากที่สุด "ayz"
- ลบคำนำหน้าและ s กลายเป็น "yz" จำนวนพาร์ติชันคือ 2
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันมากที่สุด "yz"
- ลบคำนำหน้าและ s กลายเป็น "z" จำนวนพาร์ติชันตอนนี้ 3
- เลือกคำนำหน้ายาวที่สุดที่มีอักขระที่แตกต่างกันมากที่สุด "z"
- ลบคำนำหน้าและ s จะว่างเปล่า จำนวนพาร์ติชันคือ 4
ดังนั้นคำตอบคือ 4
มันสามารถแสดงให้เห็นว่ามันเป็นไปไม่ได้ที่จะได้รับมากกว่า 4 พาร์ติชัน

ข้อ จำกัด :

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


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

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

ส่งคืนอาร์เรย์ที่ประกอบด้วยดัชนีที่ดีในลำดับใดก็ได้

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

Input: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Output: [0,2]
คำอธิบาย: สำหรับแต่ละดัชนี i ในอาร์เรย์ variables:
1) สำหรับดัชนี 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) สำหรับดัชนี 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) สำหรับดัชนี 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
ดังนั้นเราจึงส่งคืน [0,2] เป็นคำตอบ

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

Input: variables = [[39,3,1000,1000]], target = 17
Output: []
คำอธิบาย: สำหรับแต่ละดัชนี i ในอาร์เรย์ variables:
1) สำหรับดัชนี 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
ดังนั้นเราจึงส่งคืน [] เป็นคำตอบ

ข้อจำกัด:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

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

0 <= i < variables.length
((a_i^b_i % 10)^c_i) % m_i == target

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

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

Input: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Output: [0,2]
คำอธิบาย: สำหรับแต่ละดัชนี i ในอาร์เรย์ตัวแปร:
1) สำหรับดัชนี 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) สำหรับดัชนี 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) สำหรับดัชนี 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
ดังนั้นเราจะส่งคืน [0,2] เป็นคำตอบ.

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

Input: variables = [[39,3,1000,1000]], target = 17
Output: []
คำอธิบาย: สำหรับแต่ละดัชนี i ในอาร์เรย์ตัวแปร:
1) สำหรับดัชนี 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
ดังนั้นเราจะส่งคืน [] เป็นคำตอบ.

ข้อจำกัด:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

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

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == เป้าหมาย

ส่งคืนอาร์เรย์ที่ประกอบด้วยดัชนีที่ดีในลำดับใดก็ได้
ตัวอย่างที่ 1:

อินพุต: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
เอาต์พุต: [0,2]
คำอธิบาย: สำหรับดัชนี i แต่ละตัวในอาร์เรย์ตัวแปร:
1) สำหรับดัชนี 0 variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2
2) สำหรับดัชนี 1 variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0
3) สำหรับดัชนี 2 variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2
ดังนั้น เราจึงส่งคืน [0,2] เป็นคำตอบ
ตัวอย่างที่ 2:

อินพุต: variables = [[39,3,1000,1000]], target = 17
เอาต์พุต: []
คำอธิบาย: สำหรับดัชนี i แต่ละตัวในอาร์เรย์ตัวแปร:
1) สำหรับดัชนี 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1
ดังนั้น เราจึงส่งคืน [] เป็นคำตอบ

ข้อจำกัด:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3


คุณจะได้รับสตริงที่มีดัชนี 0 สองตัวคือ source และ target ซึ่งทั้งคู่มีความยาว n และประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก นอกจากนี้ คุณยังจะได้รับอาร์เรย์อักขระที่มีดัชนี 0 สองตัวคือ original และ changed และอาร์เรย์จำนวนเต็ม cost โดยที่ cost[i] แทนต้นทุนของการเปลี่ยนอักขระ original[i] เป็นอักขระ changed[i]
คุณเริ่มต้นด้วยสตริง source ในการดำเนินการหนึ่งครั้ง คุณสามารถเลือกอักขระ x จากสตริงและเปลี่ยนเป็นอักขระ y ด้วยต้นทุน z หากมีดัชนี j ใดๆ ที่ทำให้ cost[j] == z, original[j] == x และ changed[j] == y
ส่งคืนต้นทุนขั้นต่ำเพื่อแปลงสตริง source เป็นสตริงเป้าหมายโดยใช้การดำเนินการจำนวนเท่าใดก็ได้ หากไม่สามารถแปลงสตริง source เป็นเป้าหมายได้ ให้ส่งคืน -1
โปรดทราบว่าอาจมีดัชนี i, j อยู่ โดยที่ original[j] == original[i] และ changed[j] == changed[i]

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

อินพุต: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
เอาต์พุต: 28
คำอธิบาย: การแปลงสตริง "abcd" เป็นสตริง "acbe":
- เปลี่ยนค่าที่ดัชนี 1 จาก 'b' เป็น 'c' ด้วยต้นทุน 5
- เปลี่ยนค่าที่ดัชนี 2 จาก 'c' เป็น 'e' ด้วยต้นทุน 1
- เปลี่ยนค่าที่ดัชนี 2 จาก 'e' เป็น 'b' ด้วยต้นทุน 2
- เปลี่ยนค่าที่ดัชนี 3 จาก 'd' เป็น 'e' ด้วยต้นทุน 20
ต้นทุนรวมที่เกิดขึ้นคือ 5 + 1 + 2 + 20 = 28
สามารถแสดงให้เห็นได้ว่านี่คือต้นทุนต่ำสุดที่เป็นไปได้

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

อินพุต: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
เอาต์พุต: 12
คำอธิบาย: หากต้องการเปลี่ยนอักขระ 'a' เป็น 'b' ให้เปลี่ยนอักขระ 'a' เป็น 'c' ด้วยต้นทุน 1 ตามด้วยการเปลี่ยนอักขระ 'c' เป็น 'b' ด้วยต้นทุน 2 โดยมีต้นทุนรวม 1 + 2 = 3 หากต้องการเปลี่ยนการเกิดขึ้นทั้งหมดของ 'a' เป็น 'b' จะต้องใช้ต้นทุนรวม 3 * 4 = 12

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

อินพุต: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
เอาต์พุต: -1
คำอธิบาย: ไม่สามารถแปลง source เป็น target ได้เนื่องจากไม่สามารถเปลี่ยนค่าที่ดัชนี 3 จาก 'd' เป็น 'e' ได้

ข้อจำกัด:

1 <= source.length == target.length <= 10^5
source, target ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
1 <= cost.length == original.length == updated.length <= 2000
original[i], created[i] เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
1 <= cost[i] <= 10^6
original[i] != created[i]

คุณได้รับสตริง source และ target ที่มีดัชนีเริ่มต้นที่ 0 ทั้งสองสตริงมีความยาว n และประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก. คุณยังได้รับอาเรย์อักขระ original และ changed ที่มีดัชนีเริ่มต้นที่ 0. และอาเรย์จำนวนเต็ม cost ซึ่ง cost[i] แสดงถึงค่าค่าใช้จ่ายในการเปลี่ยนอักขระ original[i] เป็นอักขระ changed[i]
คุณเริ่มต้นด้วยสตริง source ในการดำเนินการหนึ่งครั้ง คุณสามารถเลือกอักขระ x จากสตริงและเปลี่ยนเป็นอักขระ yได้ในราคา z หากมีดัชนี j ใดอยู่ เช่นcost[j] == z, original[j] == x และ changed[j] == y
ส่งคืนค่าทุนขั้นต่ำในการแปลงสตริง source เป็นสตริง target โดยใช้การดำเนินการจำนวนใดก็ได้ หากไม่สามารถแปลง source เป็น target ได้ ให้ส่งคืน -1
โปรดสังเกตว่าอาจมีดัชนี i, j ซึ่งoriginal[j] == original[i] และ changed[j] == changed[i]

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

Input: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Output: 28
คำอธิบาย: เพื่อแปลงสตริง "abcd" เป็นสตริง "acbe":
- เปลี่ยนค่าที่ดัชนี 1 จาก 'b' เป็น 'c' ที่ค่าใช้จ่าย 5
- เปลี่ยนค่าที่ดัชนี 2 จาก 'c' เป็น 'e' ที่ค่าใช้จ่าย 1
- เปลี่ยนค่าที่ดัชนี 2 จาก 'e' เป็น 'b' ที่ค่าใช้จ่าย 2
- เปลี่ยนค่าที่ดัชนี 3 จาก 'd' เป็น 'e' ที่ค่าใช้จ่าย 20
ค่ารวมที่เกิดขึ้นคือ 5 + 1 + 2 + 20 = 28
สามารถแสดงได้ว่านี่เป็นค่าใช้จ่ายขั้นต่ำที่เป็นไปได้

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

Input: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Output: 12
คำอธิบาย: เพื่อเปลี่ยนอักขระ 'a' เป็น 'b' ให้เปลี่ยนอักขระ 'a' เป็น 'c' ที่ค่าใช้จ่าย 1 ตามด้วยการเปลี่ยนอักขระ 'c' เป็น 'b' ที่ค่าใช้จ่าย 2, สำหรับค่ารวม 1 + 2 = 3 เพื่อเปลี่ยนเกิด 'a' เป็น 'b' ทั้งหมด, ค่ารวมคือ 3 * 4 = 12

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

Input: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Output: -1
คำอธิบาย: เป็นไปไม่ได้ที่จะแปลง source เป็น target เพราะค่าในดัชนี 3 ไม่สามารถเปลี่ยนจาก 'd' เป็น 'e' ได้

ข้อจำกัด:

1 <= source.length == target.length <= 10^5
source, target ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
1 <= cost[i] <= 10^6
original[i] != changed[i]

คุณจะได้รับสตริงที่มีดัชนี 0 สองตัวคือ source และ target ซึ่งทั้งคู่มีความยาว n และประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก นอกจากนี้ คุณยังจะได้รับอาร์เรย์อักขระที่มีดัชนี 0 สองตัวคือ original และ changed และอาร์เรย์จำนวนเต็ม cost โดยที่ cost[i] แทนต้นทุนของการเปลี่ยนอักขระ original[i] เป็นอักขระ changed[i]
คุณเริ่มต้นด้วยสตริง source ในการดำเนินการหนึ่งครั้ง คุณสามารถเลือกอักขระ x จากสตริงและเปลี่ยนเป็นอักขระ y ด้วยต้นทุน z หากมีดัชนี j ใดๆ ที่ทำให้ cost[j] == z, original[j] == x และ changed[j] == y
ส่งคืนต้นทุนขั้นต่ำเพื่อแปลงสตริง source เป็นสตริงเป้าหมายโดยใช้การดำเนินการจำนวนเท่าใดก็ได้ หากไม่สามารถแปลงสตริง source เป็นเป้าหมายได้ ให้ส่งคืน -1
โปรดทราบว่าอาจมีดัชนี i, j อยู่ โดยที่ original[j] == original[i] และ changed[j] == changed[i]

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

อินพุต: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"],changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
เอาต์พุต: 28
คำอธิบาย: การแปลงสตริง "abcd" เป็นสตริง "acbe":
- เปลี่ยนค่าที่ดัชนี 1 จาก 'b' เป็น 'c' ด้วยต้นทุน 5
- เปลี่ยนค่าที่ดัชนี 2 จาก 'c' เป็น 'e' ด้วยต้นทุน 1
- เปลี่ยนค่าที่ดัชนี 2 จาก 'e' เป็น 'b' ด้วยต้นทุน 2
- เปลี่ยนค่าที่ดัชนี 3 จาก 'd' เป็น 'e' ด้วยต้นทุน 20
ต้นทุนรวมที่เกิดขึ้นคือ 5 + 1 + 2 + 20 = 28
สามารถแสดงให้เห็นได้ว่านี่คือต้นทุนต่ำสุดที่เป็นไปได้
ตัวอย่างที่ 2:

อินพุต: source = "aaaa", target = "bbbb", original = ["a","c"],changed = ["c","b"], cost = [1,2]
เอาต์พุต: 12
คำอธิบาย: หากต้องการเปลี่ยนอักขระ 'a' เป็น 'b' ให้เปลี่ยนอักขระ 'a' เป็น 'c' ด้วยต้นทุน 1 ตามด้วยการเปลี่ยนอักขระ 'c' เป็น 'b' ด้วยต้นทุน 2 โดยมีต้นทุนรวม 1 + 2 = 3 หากต้องการเปลี่ยนการเกิดขึ้นทั้งหมดของ 'a' เป็น 'b' จะต้องใช้ต้นทุนรวม 3 * 4 = 12
ตัวอย่างที่ 3:

อินพุต: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
เอาต์พุต: -1
คำอธิบาย: ไม่สามารถแปลง source เป็น target ได้เนื่องจากไม่สามารถเปลี่ยนค่าที่ดัชนี 3 จาก 'd' เป็น 'e' ได้

ข้อจำกัด:

1 <= source.length == target.length <= 10^5
source, target ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
1 <= cost.length == original.length == updated.length <= 2000
original[i], changed[i] เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
1 <= cost[i] <= 10^6
original[i] != changed[i]


คุณจะได้รับอาร์เรย์ของจำนวนเต็ม nums ที่มีดัชนี 0
คำนำหน้า nums[0..i] จะเป็นแบบต่อเนื่อง ถ้าสำหรับ 1 <= j <= i ทั้งหมด nums[j] = nums[j - 1] + 1 โดยเฉพาะอย่างยิ่ง คำนำหน้าที่ประกอบด้วย nums[0] เท่านั้นจะเป็นแบบต่อเนื่อง
ส่งคืนจำนวนเต็มที่เล็กที่สุด x ที่ขาดหายไปจาก nums โดยที่ x มากกว่าหรือเท่ากับผลรวมของคำนำหน้าแบบต่อเนื่องที่ยาวที่สุด

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

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

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

ข้อจำกัด:

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

คุณได้รับอาเรย์ของจำนวนเต็ม nums ที่มีดัชนีเริ่มต้นที่ 0
พรีฟิก nums[0..i] จะเรียกว่าต่อเนื่องหาก สำหรับทุก ๆ 1 <= j <= i, nums[j] = nums[j - 1] + 1 โดยเฉพาะอย่างยิ่ง พรีฟิกที่ประกอบด้วยเพียง nums[0] จะถือว่าต่อเนื่อง
ให้คืนค่าจำนวนเต็มที่น้อยที่สุด x ที่หายไปจาก nums โดยที่ x จะต้องมากกว่าหรือเท่ากับผลรวมของพรีฟิกที่ต่อเนื่องที่ยาวที่สุด

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

Input: nums = [1,2,3,2,5]
Output: 6
คำอธิบาย: พรีฟิกซ์ที่ต่อเนื่องยาวที่สุดของ nums คือ [1,2,3] โดยมีผลรวมเท่ากับ 6. 6 ไม่อยู่ในอาร์เรย์ ดังนั้น 6 จึงเป็นจำนวนเต็มที่หายไปที่เล็กที่สุดซึ่งมากกว่าหรือเท่ากับผลรวมของพรีฟิกซ์ที่ต่อเนื่องยาวที่สุด.

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

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

ข้อจำกัด:

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


ให้จำนวนเต็มบวกสองตัว x และ y

ในการดำเนินการหนึ่งครั้ง คุณสามารถทำหนึ่งในสี่การดำเนินการต่อไปนี้:

หาร x ด้วย 11 ถ้า x เป็นผลคูณของ11
หาร x ด้วย 5 ถ้า x เป็นผลคูณของ 5
ลดค่า x ลง 1
เพิ่มค่า x ขึ้น 1

ส่งคืนจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นเพื่อทำให้ x และ y เท่ากัน

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

Input: x = 26, y = 1
Output: 3
คำอธิบาย: เราสามารถทำให้ 26 เท่ากับ 1 ได้โดยทำการดำเนินการดังนี้:
1. ลดค่า x ลง 1
2. หาร x ด้วย 5
3. หาร x ด้วย 5
จะเห็นได้ว่า 3 เป็นจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นเพื่อทำให้ 26 เท่ากับ 1

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

Input: x = 54, y = 2
Output: 4
คำอธิบาย: เราสามารถทำให้ 54 เท่ากับ 2 ได้โดยทำการดำเนินการดังนี้:
1. เพิ่มค่า x ขึ้น 1
2. หาร x ด้วย 11
3. หาร x ด้วย 5
4. เพิ่มค่า x ขึ้น 1
จะเห็นได้ว่า 4 เป็นจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นเพื่อทำให้ 54 เท่ากับ 2

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

Input: x = 25, y = 30
Output: 5
คำอธิบาย: เราสามารถทำให้ 25 เท่ากับ 30 ได้โดยทำการดำเนินการดังนี้:
1. เพิ่มค่า x ขึ้น 1
2. เพิ่มค่า x ขึ้น 1
3. เพิ่มค่า x ขึ้น 1
4. เพิ่มค่า x ขึ้น 1
5. เพิ่มค่า x ขึ้น 1
จะเห็นได้ว่า 5 เป็นจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นเพื่อทำให้ 25 เท่ากับ 30

ข้อจำกัด:

1 <= x, y <= 10^4

ให้ตัวเลขบวกสองตัว x และ y

ในการดำเนินการหนึ่งครั้ง คุณสามารถทำหนึ่งในสี่การดำเนินการต่อไปนี้:

หาร x ด้วย 11 ถ้า x ลงตัวด้วย 11
หาร x ด้วย 5 ถ้า x ลงตัวด้วย 5
ลดค่า x ลง 1
เพิ่มค่า x ขึ้น 1

ส่งคืนจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นในการทำให้ x และ y เท่ากัน

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

Input: x = 26, y = 1
Output: 3
คำอธิบาย: เราสามารถทำให้ 26 เท่ากับ 1 ได้โดยทำการดำเนินการดังนี้:
1. ลดค่า x ลง 1
2. หาร x ด้วย 5
3. หาร x ด้วย 5
จะเห็นได้ว่า 3 เป็นจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นในการทำให้ 26 เท่ากับ 1

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

Input: x = 54, y = 2
Output: 4
คำอธิบาย: เราสามารถทำให้ 54 เท่ากับ 2 ได้โดยทำการดำเนินการดังนี้:
1. เพิ่มค่า x ขึ้น 1
2. หาร x ด้วย 11
3. หาร x ด้วย 5
4. เพิ่มค่า x ขึ้น 1
จะเห็นได้ว่า 4 เป็นจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นในการทำให้ 54 เท่ากับ 2

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

Input: x = 25, y = 30
Output: 5
คำอธิบาย: เราสามารถทำให้ 25 เท่ากับ 30 ได้โดยทำการดำเนินการดังนี้:
1. เพิ่มค่า x ขึ้น 1
2. เพิ่มค่า x ขึ้น 1
3. เพิ่มค่า x ขึ้น 1
4. เพิ่มค่า x ขึ้น 1
5. เพิ่มค่า x ขึ้น 1
จะเห็นได้ว่า 5 เป็นจำนวนการดำเนินการที่น้อยที่สุดที่จำเป็นในการทำให้ 25 เท่ากับ 30

ข้อจำกัด:

1 <= x, y <= 10^4

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

หาร x ด้วย 11 ถ้า x เป็นหลายของ 11
หาร x ด้วย 5 ถ้า x เป็นหลายของ 5
ลด x ลง 1
เพิ่ม x โดย 1

ส่งคืนจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการทำให้ x และ y เท่ากัน

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

อินพุต: x = 26, y = 1
เอาท์พุท: 3
คำอธิบาย: เราสามารถทำให้ 26 เท่ากับ 1 โดยใช้การดำเนินการต่อไปนี้:
1. ลด x ลง 1
2. หาร x ด้วย 5
3. หาร x ด้วย 5
มันสามารถแสดงให้เห็นว่า 3 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการทำให้ 26 เท่ากับ 1

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

อินพุต: x = 54, y = 2
เอาท์พุท: 4
คำอธิบาย: เราสามารถสร้าง 54 เท่ากับ 2 โดยใช้การดำเนินการต่อไปนี้:
1. เพิ่ม x โดย 1
2. หาร x โดย 11
3. หาร x โดย 5
4. เพิ่ม x โดย 1
สามารถแสดงให้เห็นว่า 4 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการสร้าง 54 เท่ากับ 2

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

อินพุต: x = 25, y = 30
เอาท์พุท: 5
คำอธิบาย: เราสามารถสร้าง 25 เท่ากับ 30 โดยใช้การดำเนินการต่อไปนี้:
1. เพิ่ม x โดย 1
2. เพิ่ม x โดย 1
3. เพิ่ม x โดย 1
4. เพิ่ม x โดย 1
5. เพิ่ม x โดย 1
สามารถแสดงให้เห็นว่า 5 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการสร้าง 25 เท่ากับ 30

ข้อ จำกัด :

1 <= x, y <= 10^4


คุณได้รับจำนวนเต็ม k และจำนวนเต็ม x
พิจารณาว่า s คือการแสดงเลขฐานสองที่มีดัชนี 1 ของจำนวนเต็ม num ราคาของจำนวน num คือจำนวนของ i โดยที่ i % x == 0 และ s[i] คือบิตเซต
ส่งคืนจำนวนเต็ม num ที่มากที่สุดโดยที่ผลรวมของราคาของจำนวนทั้งหมดตั้งแต่ 1 ถึง num น้อยกว่าหรือเท่ากับ k
หมายเหตุ:

ในการแสดงเลขฐานสองของชุดจำนวน บิตคือบิตที่มีค่า 1
การแสดงเลขฐานสองของจำนวนจะถูกจัดทำดัชนีจากขวาไปซ้าย ตัวอย่างเช่น ถ้า s == 11100, s[4] == 1 และ s[2] == 0

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

อินพุต: k = 9, x = 1
เอาต์พุต: 6
คำอธิบาย: ตัวเลข 1, 2, 3, 4, 5 และ 6 สามารถเขียนในรูปแบบไบนารีได้ดังนี้ "1", "10", "11", "100", "101" และ "110" ตามลำดับ
เนื่องจาก x มีค่าเท่ากับ 1 ราคาของแต่ละตัวเลขจึงเป็นจำนวนบิตที่ตั้งค่าไว้
จำนวนบิตที่ตั้งค่าไว้ในตัวเลขเหล่านี้คือ 9 ดังนั้นผลรวมของราคาของตัวเลข 6 ตัวแรกคือ 9
ดังนั้นคำตอบคือ 6
ตัวอย่างที่ 2:

อินพุต: k = 7, x = 2
เอาต์พุต: 9
คำอธิบาย: เนื่องจาก x มีค่าเท่ากับ 2 เราจึงควรตรวจสอบบิตที่คู่เท่านั้น บิตที่สองของการแทนค่าไบนารีของตัวเลข 2 และ 3 เป็นบิตชุด ดังนั้นผลรวมของราคาคือ 2
บิตที่สองของการแทนค่าไบนารีของตัวเลข 6 และ 7 เป็นบิตชุด ดังนั้นผลรวมของราคาคือ 2
บิตที่สี่ของการแทนค่าไบนารีของตัวเลข 8 และ 9 เป็นบิตชุด แต่บิตที่สองไม่ใช่ ดังนั้นผลรวมของราคาคือ 2
ตัวเลข 1, 4 และ 5 ไม่มีบิตชุดในบิตคู่ในการแทนค่าไบนารี ดังนั้นผลรวมของราคาคือ 0
บิตที่สองและที่สี่ของการแทนค่าไบนารีของตัวเลข 10 เป็นบิตชุด ดังนั้นราคาคือ 2
ผลรวมของราคาของตัวเลข 9 ตัวแรกคือ 6
เนื่องจากผลรวมของราคาของตัวเลข 10 ตัวแรกคือ 8 คำตอบจึงเป็น 9

เงื่อนไข:

1 <= k <= 10^15
1 <= x <= 8

คุณจะได้รับจำนวนเต็ม k และจำนวนเต็ม x
พิจารณา s คือการแทนค่าไบนารีแบบ 1-ดัชนีของจํานวนเต็ม num ราคาจำนวนจำนวนคือจำนวนของฉันที่ฉัน % x == 0 และ s [i] เป็นบิตที่ตั้งไว้
ส่งคืนจำนวนเต็มที่ยิ่งใหญ่ที่สุดเช่นผลรวมของราคาทั้งหมดจาก 1 ถึง num น้อยกว่าหรือเท่ากับ k
บันทึก:

ในการแสดงไบนารีของบิตชุดตัวเลขเป็นบิตของค่า 1
การเป็นตัวแทนไบนารีของตัวเลขจะถูกจัดทำดัชนีจากขวาไปซ้าย ตัวอย่างเช่นถ้า s == 11100, s [4] == 1 และ s [2] == 0

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

อินพุต: k = 9, x = 1
เอาท์พุท: 6
คำอธิบาย: ตัวเลข 1, 2, 3, 4, 5 และ 6 สามารถเขียนได้ในการเป็นตัวแทนไบนารีเป็น "1", "10", "11", "100", "101" และ "110" ตามลำดับ
เนื่องจาก x เท่ากับ 1 ราคาของแต่ละหมายเลขคือจำนวนบิตที่ตั้งไว้
จำนวนบิตชุดในตัวเลขเหล่านี้คือ 9 ดังนั้นผลรวมของราคาของ 6 หมายเลขแรกคือ 9
ดังนั้นคำตอบคือ 6.
ตัวอย่างที่ 2:

อินพุต: k = 7, x = 2
เอาท์พุท: 9
คำอธิบาย: เนื่องจาก x เท่ากับ 2 เราควรตรวจสอบแม้แต่บิต^th
บิตที่สองของการแสดงไบนารีของตัวเลข 2 และ 3 เป็นบิตที่ตั้งไว้ ดังนั้นยอดรวมของราคาคือ 2
บิตที่สองของการแสดงไบนารีของตัวเลข 6 และ 7 เป็นบิตที่ตั้งไว้ ดังนั้นยอดรวมของราคาคือ 2
บิตที่สี่ของการแสดงไบนารีของตัวเลข 8 และ 9 เป็นบิตที่ตั้งไว้ แต่บิตที่สองของพวกเขาไม่ได้ ดังนั้นยอดรวมของราคาคือ 2
หมายเลข 1, 4 และ 5 ไม่มีบิตในบิต^th ของพวกเขาในการเป็นตัวแทนไบนารีของพวกเขา ดังนั้นยอดรวมของราคาคือ 0
บิตที่สองและสี่ของการแสดงไบนารีของหมายเลข 10 เป็นบิตที่ตั้งไว้ ราคาของมันคือ 2
ผลรวมของราคา 9 หมายเลขแรกคือ 6
เนื่องจากผลรวมของราคา 10 หมายเลขแรกคือ 8 คำตอบคือ 9

ข้อ จำกัด :

1 <= k <= 10^15
1 <= x <= 8


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

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

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

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

ข้อ จำกัด :

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

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

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

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

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

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

ข้อ จำกัด :

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

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

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

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

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

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

ข้อจำกัด:

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


คุณได้รับจำนวนเต็มสามจำนวนคือ start, finish และ limit คุณยังได้รับสตริง s ที่ถูกจัดทำในรูปแบบ 0-indexed ซึ่งแสดงจำนวนเต็มบวก

จำนวนเต็มบวก x จะเรียกว่า powerful ถ้ามันลงท้ายด้วย s (กล่าวคือ s เป็นส่วนท้ายของ x) และแต่ละหลักใน x ต้องไม่เกิน limit

จงคืนจำนวนรวมของจำนวนเต็ม powerful ในช่วง [start..finish]

สตริง x เป็นส่วนท้ายของสตริง y ก็ต่อเมื่อ x เป็นสตริงย่อยของ y ที่เริ่มจากบางตำแหน่ง (รวมถึง 0) ใน y และยาวไปถึงตำแหน่ง y.length - 1 ตัวอย่างเช่น 25 เป็นส่วนท้ายของ 5125 ในขณะที่ 512 ไม่ใช่

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

Input: start = 1, finish = 6000, limit = 4, s = "124"
Output: 5
คำอธิบาย: จำนวนเต็ม powerful ในช่วง [1..6000] คือ 124, 1124, 2124, 3124 และ 4124 จำนวนเต็มเหล่านี้มีแต่ละหลัก <= 4 และมี "124" เป็นส่วนท้าย โปรดทราบว่า 5124 ไม่ใช่จำนวนเต็ม powerful เพราะหลักแรกคือ 5 ซึ่งมากกว่า 4
สามารถแสดงให้เห็นได้ว่ามีจำนวนเต็ม powerful เพียง 5 ตัวในช่วงนี้

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

Input: start = 15, finish = 215, limit = 6, s = "10"
Output: 2
คำอธิบาย: จำนวนเต็ม powerful ในช่วง [15..215] คือ 110 และ 210 จำนวนเต็มเหล่านี้มีแต่ละหลัก <= 6 และมี "10" เป็นส่วนท้าย
สามารถแสดงให้เห็นได้ว่ามีจำนวนเต็ม powerful เพียง 2 ตัวในช่วงนี้

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

Input: start = 1000, finish = 2000, limit = 4, s = "3000"
Output: 0
คำอธิบาย: จำนวนเต็มทั้งหมดในช่วง [1000..2000] น้อยกว่า 3000 ดังนั้น "3000" ไม่สามารถเป็นส่วนท้ายของจำนวนเต็มใดๆ ในช่วงนี้ได้

ข้อกำหนด:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s ประกอบด้วยตัวเลขเท่านั้นซึ่งเป็นตัวเลขที่ไม่เกิน limit
s ไม่มีเลขศูนย์นำหน้า

คุณจะได้รับจำนวนเต็มสามจำนวน ได้แก่ start, finish และ limit นอกจากนี้ คุณยังได้รับสตริง s ที่มีดัชนี 0 ซึ่งแสดงถึงจำนวนเต็มบวก
จำนวนเต็มบวก x จะถูกเรียกว่าเป็นจำนวนเต็มที่มีประสิทธิภาพหากลงท้ายด้วย s (กล่าวอีกนัยหนึ่ง s เป็นคำต่อท้ายของ x) และแต่ละหลักใน x มีค่าไม่เกินขีดจำกัด
ส่งคืนจำนวนเต็มที่มีประสิทธิภาพทั้งหมดในช่วง [start..finish]
สตริง x เป็นคำต่อท้ายของสตริง y ก็ต่อเมื่อ x เป็นสตริงย่อยของ y ที่เริ่มต้นจากดัชนีบางตัว (รวมถึง 0) ใน y และขยายไปถึงดัชนี y.length - 1 ตัวอย่างเช่น 25 เป็นคำต่อท้ายของ 5125 ในขณะที่ 512 ไม่ใช่

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

อินพุต: start = 1, finish = 6000, limit = 4, s = "124"
เอาต์พุต: 5
คำอธิบาย: จำนวนเต็มที่ทรงประสิทธิภาพในช่วง [1..6000] ได้แก่ 124, 1124, 2124, 3124 และ 4124 จำนวนเต็มเหล่านี้ทั้งหมดมีตัวเลขแต่ละตัว <= 4 และมี "124" เป็นส่วนต่อท้าย โปรดทราบว่า 5124 ไม่ใช่จำนวนเต็มที่ทรงประสิทธิภาพเนื่องจากตัวเลขตัวแรกคือ 5 ซึ่งมากกว่า 4
จะเห็นว่ามีจำนวนเต็มที่ทรงประสิทธิภาพเพียง 5 ตัวในช่วงนี้

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

อินพุต: start = 15, finish = 215, limit = 6, s = "10"
เอาต์พุต: 2
คำอธิบาย: จำนวนเต็มที่มีพลังในช่วง [15..215] คือ 110 และ 210 จำนวนเต็มทั้งหมดเหล่านี้มีตัวเลขแต่ละตัว <= 6 และมี "10" เป็นส่วนต่อท้าย
สามารถแสดงให้เห็นว่ามีจำนวนเต็มที่มีพลังเพียง 2 ตัวในช่วงนี้

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

อินพุต: start = 1000, finish = 2000, limit = 4, s = "3000"
เอาต์พุต: 0
คำอธิบาย: จำนวนเต็มทั้งหมดในช่วง [1000..2000] มีค่าน้อยกว่า 3000 ดังนั้น "3000" จึงไม่สามารถเป็นส่วนต่อท้ายของจำนวนเต็มใดๆ ในช่วงนี้ได้

ข้อจำกัด:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s ประกอบด้วยตัวเลขหลักเท่านั้นซึ่งมีขีดจำกัดสูงสุด
s ไม่มีเลขศูนย์นำหน้า


คุณมีอาเรย์จำนวนเต็มที่จัดทำดัชนีเป็นศูนย์ชื่อ nums ซึ่งประกอบด้วยจำนวนเต็มบวก
งานของคุณคือลดความยาวของ nums โดยทำตามการปฏิบัติการต่อไปนี้จำนวนครั้งเท่าใดก็ได้ (รวมทั้งศูนย์):

เลือกสองดัชนี i และ j ที่แตกต่างกันจาก nums โดยที่ nums[i] > 0 และ nums[j] > 0
ใส่ผลลัพธ์ของ nums[i] % nums[j] ที่ตอนปลาย nums
ลบองค์ประกอบที่ดัชนี i และ j จาก nums

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

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

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

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

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

เงื่อนไข:

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

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

เลือกดัชนีที่แตกต่างกันสองรายการคือ i และ j จาก nums โดยที่ nums[i] > 0 และ nums[j] > 0
แทรกผลลัพธ์ของ nums[i] % nums[j] ที่ส่วนท้ายของ nums
ลบองค์ประกอบที่ดัชนี i และ j จาก nums

ส่งคืนจำนวนเต็มที่แสดงถึงความยาวขั้นต่ำของ nums หลังจากดำเนินการนี้จำนวนครั้งใดก็ได้

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

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

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

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

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ของจํานวนเต็มที่มีดัชนี 0 ที่มีจํานวนเต็มบวก
งานของคุณคือลดความยาวของอาร์เรย์ numsโดยดําเนินการต่อไปนี้หลายครั้งเท่าใดก็ได้ (รวมถึงศูนย์):

เลือกดัชนีที่แตกต่างกันสองดัชนี i และ j จาก nums เพื่อให้ nums[i] > 0 และ nums[j] > 0
แทรกผลลัพธ์ของ nums[i] % nums[j] ที่ส่วนท้ายของ nums
ลบองค์ประกอบที่ดัชนี i และ j ออกจากอาร์เรย์ nums

ส่งกลับจํานวนเต็มที่แสดงถึงความยาวขั้นต่ําของ nums หลังจากดําเนินการกี่ครั้งก็ได้

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

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

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

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

ข้อจํากัด:

1 <= ความยาวของอาร์เรย์ <= 10^5
1 <= nums[i] <= 10^9


คุณจะได้รับสตริง s ที่มีดัชนี 0, สตริง a, สตริง b และจำนวนเต็ม k
ดัชนี i จะสวยงามหาก:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
มีดัชนี j อยู่ซึ่ง:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

ส่งคืนอาร์เรย์ที่มีดัชนีที่สวยงามในลำดับที่เรียงลำดับจากน้อยไปมาก

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

อินพุต: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
เอาต์พุต: [16,33]
คำอธิบาย: มีดัชนีที่สวยงาม 2 รายการ: [16,33]
- ดัชนี 16 สวยงามเนื่องจาก s[16..17] == "my" และมีดัชนี 4 อยู่ โดยที่ s[4..11] == "squirrel" และ |16 - 4| <= 15
- ดัชนี 33 สวยงามเนื่องจาก s[33..34] == "my" และมีดัชนี 18 อยู่ โดยที่ s[18..25] == "squirrel" และ |33 - 18| <= 15
ดังนั้น เราจะส่งคืน [16,33] เป็นผลลัพธ์

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

อินพุต: s = "abcd", a = "a", b = "a", k = 4
เอาต์พุต: [0]
คำอธิบาย: มีดัชนีที่สวยงาม 1 รายการ: [0] - ดัชนี 0 นั้นสวยงามเนื่องจาก s[0..0] == "a" และมีดัชนี 0 อยู่โดยที่ s[0..0] == "a" และ |0 - 0| <= 4
ดังนั้นเราจึงส่งคืน [0] เป็นผลลัพธ์

ข้อจำกัด:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a และ b มีเฉพาะตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณได้รับสตริง s ที่มีดัชนีเริ่มต้นที่ 0, สตริง a, สตริง b, และจำนวนเต็ม k
ดัชนี i จะถือว่าสวยงามถ้า:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
มีดัชนี j ที่มีอยู่ซึ่งว่า:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

คืนอาร์เรย์ที่ประกอบด้วยดัชนีที่สวยงามในลำดับที่เรียงจากน้อยไปมากก

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

Input: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Output: [16,33]
คำอธิบาย: มีดัชนีที่สวยงาม 2 ตัว: [16,33].
- ดัชนี 16 สวยงามเพราะ s[16..17] == "my" และมีดัชนี 4 ที่ทำให้ s[4..11] == "squirrel" และ |16 - 4| <= 15.
- ดัชนี 33 สวยงามเพราะ s[33..34] == "my" และมีดัชนี 18 ที่ทำให้ s[18..25] == "squirrel" และ |33 - 18| <= 15.
ดังนั้นเราจึงส่งคืน [16,33] เป็นผลลัพธ์.

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

Input: s = "abcd", a = "a", b = "a", k = 4
Output: [0]
คำอธิบาย: มีดัชนีที่สวยงาม 1 ตัว: [0].
- ดัชนี 0 สวยงามเพราะ s[0..0] == "a" และมีดัชนี 0 ที่ s[0..0] == "a" และ |0 - 0| <= 4.
ดังนั้นเราจึงส่งคืน [0] เป็นผลลัพธ์.

ข้อจำกัด:

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

คุณจะได้รับสตริงs ที่มีดัชนีเริ่มต้นที่0, สตริง a, สตริง b และจำนวนเต็ม k
ดัชนีฉันสวยถ้า:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
มีดัชนี j เช่นนั้น:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

ส่งคืนอาร์เรย์ที่มีดัชนีที่สวยงามตามลำดับจากที่เล็กที่สุดไปจนถึงใหญ่ที่สุด

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

อินพุต: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
เอาท์พุท: [16,33]
คำอธิบาย: มี 2 ดัชนีที่สวยงาม: [16,33]
- ดัชนี 16 สวยเหมือน s [16..17] == "ของฉัน" และมีดัชนี 4 กับ S [4..11] == "กระรอก" และ | 16 - 4 | <= 15.
- ดัชนี 33 นั้นสวยงามเหมือน s [33..34] == "ของฉัน" และมีดัชนี 18 ด้วย S [18..25] == "กระรอก" และ | 33 - 18 | <= 15.
ดังนั้นเราจึงกลับมา [16,33] ตามผลลัพธ์

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

อินพุต: s = "abcd", a = "a", b = "a", k = 4
เอาท์พุท: [0]
คำอธิบาย: มี 1 ดัชนีที่สวยงาม: [0]
- ดัชนี 0 สวยเหมือน s [0..0] == "a" และมีดัชนี 0 ด้วย s [0..0] == "a" และ | 0 - 0 | <= 4.
ดังนั้นเราจึงกลับ [0] ตามผลลัพธ์

ข้อ จำกัด :

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a และ b มีตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณจะได้รับอาร์เรย์ของจำนวนเต็มบวก nums
คุณต้องตรวจสอบว่าเป็นไปได้หรือไม่ที่จะเลือกองค์ประกอบสององค์ประกอบขึ้นไปในอาร์เรย์เพื่อให้ค่า OR ตามบิตขององค์ประกอบที่เลือกมีศูนย์ตามท้ายอย่างน้อยหนึ่งตัวในการแสดงแบบไบนารี
ตัวอย่างเช่น การแสดงแบบไบนารีของ 5 ซึ่งคือ "101" ไม่มีศูนย์ตามท้ายเลย ในขณะที่การแสดงแบบไบนารีของ 4 ซึ่งคือ "100" มีศูนย์ตามท้ายสองตัว
คืนค่า true หากสามารถเลือกองค์ประกอบสององค์ประกอบขึ้นไปที่มีค่า OR ตามบิตที่มีศูนย์ตามท้าย มิฉะนั้นให้คืนค่า false

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

อินพุต: nums = [1,2,3,4,5]
เอาต์พุต: true
คำอธิบาย: หากเราเลือกองค์ประกอบ 2 และ 4 ค่า OR ตามบิตขององค์ประกอบเหล่านั้นคือ 6 ซึ่งมีการแสดงแบบไบนารี "110" โดยมีศูนย์ตามท้ายหนึ่งตัว

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

อินพุต: nums = [2,4,8,16]
เอาต์พุต: true
คำอธิบาย: หากเราเลือกองค์ประกอบ 2 และ 4 OR ตามบิตขององค์ประกอบเหล่านั้นคือ 6 ซึ่งมีการแสดงแบบไบนารี "110" โดยมีศูนย์ตามท้ายหนึ่งตัว
วิธีอื่นๆ ที่เป็นไปได้ในการเลือกองค์ประกอบเพื่อให้มีศูนย์ตามท้ายในการแสดงแบบไบนารีของ OR ตามบิต ได้แก่: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), และ (2, 4, 8, 16)

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

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

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ของจำนวนเต็มบวก nums
คุณต้องตรวจสอบว่าเป็นไปได้หรือไม่ที่จะเลือกองค์ประกอบสององค์ประกอบขึ้นไปในอาร์เรย์เพื่อให้ค่า OR ตามบิตขององค์ประกอบที่เลือกมีศูนย์ตามท้ายอย่างน้อยหนึ่งตัวในการแสดงแบบไบนารี
ตัวอย่างเช่น การแสดงแบบไบนารีของ 5 ซึ่งคือ "101" ไม่มีศูนย์ตามท้ายเลย ในขณะที่การแสดงแบบไบนารีของ 4 ซึ่งคือ "100" มีศูนย์ตามท้ายสองตัว
คืนค่า true หากสามารถเลือกองค์ประกอบสององค์ประกอบขึ้นไปที่มีค่า OR ตามบิตที่มีศูนย์ตามท้าย มิฉะนั้นให้คืนค่า false

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

อินพุต: nums = [1,2,3,4,5]
เอาต์พุต: true
คำอธิบาย: หากเราเลือกองค์ประกอบ 2 และ 4 ค่า OR ตามบิตขององค์ประกอบเหล่านั้นคือ 6 ซึ่งมีการแสดงแบบไบนารี "110" โดยมีศูนย์ตามท้ายหนึ่งตัว

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

อินพุต: nums = [2,4,8,16]
เอาต์พุต: true
คำอธิบาย: หากเราเลือกองค์ประกอบ 2 และ 4 OR ตามบิตขององค์ประกอบเหล่านั้นคือ 6 ซึ่งมีการแสดงแบบไบนารี "110" โดยมีศูนย์ตามหลังหนึ่งตัว
วิธีอื่นๆ ที่เป็นไปได้ในการเลือกองค์ประกอบเพื่อให้มีศูนย์ตามหลังในการแสดงแบบไบนารีของ OR ตามบิต ได้แก่: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), และ (2, 4, 8, 16)

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

อินพุต: nums = [1,3,5,7,9]
เอาต์พุต: false
คำอธิบาย: ไม่มีวิธีใดที่เป็นไปได้ในการเลือกองค์ประกอบสององค์ประกอบขึ้นไปเพื่อให้มีศูนย์ตามหลังในการแสดงแบบไบนารีของ OR ตามบิต

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ของจำนวนเต็มบวก nums
คุณต้องตรวจสอบว่าสามารถเลือกองค์ประกอบสององค์ประกอบหรือมากกว่าในอาร์เรย์ได้หรือไม่ โดยที่ค่า OR ตามบิตขององค์ประกอบที่เลือกจะมีศูนย์ตามหลังอย่างน้อยหนึ่งตัวในการแสดงแบบไบนารี
ตัวอย่างเช่นการเป็นตัวแทนไบนารีของ 5 ซึ่งคือ "101" ไม่มีศูนย์ต่อท้ายใด ๆ ในขณะที่การเป็นตัวแทนไบนารีของ 4 ซึ่งคือ "100" มีศูนย์ต่อท้ายสอง
กลับคืนค่า true หากเป็นไปได้ที่จะเลือกองค์ประกอบสองอย่างขึ้นไปซึ่งมีบิตหรือมีศูนย์ต่อท้าย ถ้าไม่เป็นเช่นนั้น ให้ส่งคืนค่า false

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

อินพุต: nums= [1,2,3,4,5]
เอาท์พุท: true
คำอธิบาย: ถ้าเราเลือกองค์ประกอบ 2 และ 4 บิต OR ของพวกเขาคือ 6 ซึ่งมีการเป็นตัวแทนไบนารี "110" โดยมีหนึ่งศูนย์ต่อท้าย

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

อินพุต: nums = [2,4,8,16]
เอาท์พุท: true
คำอธิบาย: ถ้าเราเลือกองค์ประกอบ 2 และ 4 บิตของพวกเขาหรือ 6 ซึ่งมีการเป็นตัวแทนไบนารี "110" โดยมีหนึ่งศูนย์ต่อท้าย
วิธีอื่น ๆ ที่เป็นไปได้ในการเลือกองค์ประกอบที่จะมีศูนย์ต่อท้ายในการเป็นตัวแทนไบนารีของ bitwise หรือคือ: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) และ (2, 4, 8, 16)

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

อินพุต: nums = [1,3,5,7,9]
เอาท์พุท: false
คำอธิบาย: ไม่มีวิธีที่เป็นไปได้ในการเลือกองค์ประกอบสองอย่างขึ้นไปเพื่อให้มีศูนย์ต่อท้ายในการเป็นตัวแทนไบนารีของ bitwise หรือ

ข้อ จำกัด :

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


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

เลือกองค์ประกอบใด ๆ ของอาร์เรย์และพลิกบิตในตัวแทนแบบไบนารีของมัน การพลิกบิตหมายถึงการเปลี่ยน 0 เป็น 1 หรือในทางกลับกัน

จงคืนค่าจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อทำให้ผลลัพธ์ของการ XOR ของทุกองค์ประกอบในอาร์เรย์สุดท้ายเท่ากับ k
โปรดทราบว่าคุณสามารถพลิกบิตศูนย์นำในรูปแบบไบนารีขององค์ประกอบได้ ตัวอย่างเช่น สำหรับหมายเลข (101)_2 คุณสามารถพลิกบิตที่สี่และได้ (1101)_2

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

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

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

Input: nums = [2,0,2,0], k = 0
Output: 0
คำอธิบาย: ผลลัพธ์ของ XOR ของสมาชิกในอาร์เรย์คือ (2 XOR 0 XOR 2 XOR 0) == 0 == k ดังนั้นไม่จำเป็นต้องทำการดำเนินการใด ๆ

ข้อจำกัด:

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

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

เลือกองค์ประกอบใดก็ได้ของอาร์เรย์และพลิกบิตในการแสดงไบนารี การพลิกบิตหมายถึงการเปลี่ยน 0 เป็น 1 หรือในทางกลับกัน

ส่งกลับจํานวนการดําเนินการขั้นต่ําที่จําเป็นในการสร้าง XOR ขององค์ประกอบทั้งหมดของอาร์เรย์สุดท้ายเท่ากับ k
โปรดทราบว่าคุณสามารถพลิกบิตศูนย์นําหน้าในการแสดงไบนารีขององค์ประกอบได้ ตัวอย่างเช่น สําหรับตัวเลข (101)_2 คุณสามารถพลิกบิตที่สี่และรับ (1101)_2

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

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

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

อินพุต: nums = [2,0,2,0], k = 0
เอาท์พุต: 0
คําอธิบาย: XOR ขององค์ประกอบของอาร์เรย์คือ (2 XOR 0 XOR 2 XOR 0) == 0 == k ดังนั้นจึงไม่จําเป็นต้องดําเนินการ

ข้อจํากัด:

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

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

เลือกองค์ประกอบใดๆ ของอาร์เรย์และพลิกบิตในการแสดงแบบไบนารี การพลิกบิตหมายถึงการเปลี่ยน 0 เป็น 1 หรือในทางกลับกัน

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

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

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

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

อินพุต: nums = [2,0,2,0], k = 0
เอาต์พุต: 0
คำอธิบาย: XOR ขององค์ประกอบของอาร์เรย์คือ (2 XOR 0 XOR 2 XOR 0) == 0 == k ดังนั้นจึงไม่จำเป็นต้องดำเนินการใดๆ

ข้อจำกัด:

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


คุณจะได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่มีดัชนี 0
สำหรับดัชนี i ทั้งหมด 0 <= i < dimensions.length, dimensions[i][0] แทนความยาว และ dimensions[i][1] แทนความกว้างของรูปสี่เหลี่ยมผืนผ้า i
ส่งคืนพื้นที่ของรูปสี่เหลี่ยมผืนผ้าที่มีเส้นทแยงมุมยาวที่สุด หากมีรูปสี่เหลี่ยมผืนผ้าหลายรูปที่มีเส้นทแยงมุมยาวที่สุด ให้ส่งคืนพื้นที่ของรูปสี่เหลี่ยมผืนผ้าที่มีพื้นที่สูงสุด

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

อินพุต: dimensions = [[9,3],[8,6]]
เอาต์พุต: 48
คำอธิบาย:
สำหรับดัชนี = 0, ความยาว = 9 และความกว้าง = 3 ความยาวเส้นทแยงมุม = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487
สำหรับดัชนี = 1, ความยาว = 8 และความกว้าง = 6 ความยาวแนวทแยง = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10
ดังนั้น รูปสี่เหลี่ยมผืนผ้าที่ดัชนี 1 จึงมีความยาวแนวทแยงมากกว่า ดังนั้นเราจึงส่งคืนพื้นที่ = 8 * 6 = 48

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

อินพุต: dimensions = [[3,4],[4,3]]
เอาต์พุต: 12
คำอธิบาย: ความยาวของแนวทแยงเท่ากันสำหรับทั้งสองรูป ซึ่งคือ 5 ดังนั้น พื้นที่สูงสุด = 12

ข้อจำกัด:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

คุณได้รับอาเรย์จำนวนเต็ม 2 มิติที่มีดัชนีเริ่มต้นจาก 0 ชื่อ dimensions
สำหรับทุก ๆ ดัชนี i ที่ 0 <= i < dimensions.length, dimensions[i][0] แทนความยาว และ dimensions[i][1] แทนความกว้างของสี่เหลี่ยมผืนผ้า i
ให้คืนค่าพื้นที่ของสี่เหลี่ยมผืนผ้าที่มีเส้นทแยงมุมยาวที่สุด ถ้ามีหลายรูปที่มีเส้นทแยงมุมยาวเท่ากัน ให้คืนค่าพื้นที่ของสี่เหลี่ยมผืนผ้าที่มีพื้นที่มากที่สุด

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

Input: dimensions = [[9,3],[8,6]]
Output: 48
คำอธิบาย:
สำหรับดัชนี = 0, ความยาว = 9 และ ความกว้าง = 3 ความยาวเส้นทแยงมุม = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487
สำหรับดัชนี = 1, ความยาว = 8 และ ความกว้าง = 6 ความยาวเส้นทแยงมุม = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10
ดังนั้น สี่เหลี่ยมผืนผ้าที่ดัชนี 1 มีความยาวเส้นทแยงมุมมากกว่าจึงคืนค่าพื้นที่ = 8 * 6 = 48

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

Input: dimensions = [[3,4],[4,3]]
Output: 12
คำอธิบาย: ความยาวของเส้นทแยงมุมคือ 5 สำหรับทั้งสองรูป, ดังนั้นพื้นที่สูงสุด = 12

ข้อจำกัด:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100


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

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

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

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

อินพุต: nums = [6,5,7,8]
เอาต์พุต: 7
คำอธิบาย: ซับอาร์เรย์ที่เพิ่มได้ 7 รายการคือ: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] และ [6,5,7,8]
จะเห็นได้ว่ามีอาร์เรย์ย่อยที่เพิ่มได้เพียง 7 รายการใน nums

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

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

ข้อจำกัด:

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

คุณได้รับอาเรย์ที่มีดัชนีเริ่มต้นที่ 0 ของจำนวนเต็มบวกที่ชื่อว่า nums
อาร์เรย์ย่อยของ nums จะเรียกว่า incremovable ถ้า nums เพิ่มขึ้นอย่างเคร่งครัดเมื่อลบอาร์เรย์ย่อย ตัวอย่างเช่น อาร์เรย์ย่อย [3, 4] คืออาร์เรย์ย่อยที่เพิ่มไม่ได้ของ [5, 3, 4, 6, 7] เนื่องจากการลบอาร์เรย์ย่อยนี้จะเปลี่ยนอาร์เรย์ [5, 3, 4, 6, 7] เป็น [5, 6, 7] ซึ่งเพิ่มขึ้นอย่างเคร่งครัด
ให้คืนจำนวนรวมหรือ incremovable subarrays ของ nums
โปรดทราบว่าอาเรย์ว่างถูกพิจารณาว่าเพิ่มขึ้นอย่างเข้มงวด
อาร์เรย์ย่อยคืออนุกรมที่ไม่ว่างที่ต่อเนื่องกันภายในอาเรย์

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

Input: nums = [1,2,3,4]
Output: 10
คำอธิบาย: 10 incremovable subarrays คือ: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4], และ [1,2,3,4] เพราะเมื่อลบอาร์เรย์ย่อยเหล่านี้ nums จะเพิ่มขึ้นอย่างเข้มงวด โปรดทราบว่าไม่สามารถเลือกอาร์เรย์ย่อยว่างได้

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

Input: nums = [6,5,7,8]
Output: 7
คำอธิบาย: 7 incremovable subarrays คือ: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] และ [6,5,7,8]
สามารถพิสูจน์ได้ว่าใน nums มีเพิ่ม 7 incremovable subarrays เท่านั้น

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

Input: nums = [8,7,6,6]
Output: 3
คำอธิบาย: 3 incremovable subarrays คือ: [8,7,6], [7,6,6], และ [8,7,6,6] โปรดทราบว่า [8,7] ไม่ใช่ incremovable subarray เพราะเมื่อลบ [8,7] nums กลายเป็น [6,6] ซึ่งเรียงลำดับตามลำดับเพิ่มขึ้นแต่ไม่ใช่เพิ่มขึ้นอย่างเข้มงวด

ข้อจำกัด:

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


คุณได้รับอาเรย์จำนวนเต็ม nums ที่มีดัชนีเริ่มต้นที่ 0 และจำนวนเต็ม k
ในหนึ่งการดำเนินการ คุณสามารถเลือกดัชนีใด ๆ ของ nums ที่ทำให้ 0 <= i < nums.length - 1 และแทนที่ nums[i] และ nums[i + 1] ด้วยการเกิดขึ้นเพียงครั้งเดียวของ nums[i] & nums[i + 1] ซึ่ง & แทนที่ตัวดำเนินการ AND แบบบิต
ส่งคืนค่าต่ำสุดที่เป็นไปได้ของ OR แบบบิตขององค์ประกอบที่เหลือของ nums หลังจากทำการดำเนินการไม่เกิน k ครั้ง

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

Input: nums = [3,5,3,2,7], k = 2
Output: 3
คำอธิบาย: ทำการทำงานดังต่อไปนี้:
1. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [1,3,2,7]
2. แทนที่ nums[2] และ nums[3] ด้วย (nums[2] & nums[3]) เพื่อให้ nums เท่ากับ [1,3,2]
bitwise-or ของอาเรย์สุดท้ายคือ 3
สามารถแสดงได้ว่า 3 เป็นค่าต่ำสุดที่เป็นไปได้ของ bitwise OR ขององค์ประกอบที่เหลือของ nums หลังจากการใช้สมการสูงสุด k ครั้ง

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

Input: nums = [7,3,15,14,2,8], k = 4
Output: 2
คำอธิบาย: ให้ทำการดำเนินการต่อไปนี้:
1. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [3,15,14,2,8].
2. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [3,14,2,8].
3. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [2,2,8].
4. แทนที่ nums[1] และ nums[2] ด้วย (nums[1] & nums[2]) เพื่อให้ nums เท่ากับ [2,0].
ผลลัพธ์ของการทำ bitwise-or ของอาร์เรย์สุดท้ายคือ 2.
สามารถแสดงให้เห็นว่า 2 เป็นค่าต่ำสุดที่เป็นไปได้ของ bitwise OR ขององค์ประกอบที่เหลือของ nums หลังจากทำการดำเนินการไม่เกิน k ครั้ง.

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

Input: nums = [10,7,10,3,9,14,9,4], k = 1
Output: 15
คำอธิบาย: โดยไม่ต้องทำการดำเนินการใด ๆ ผลลัพธ์ของการทำ bitwise-or ของ nums คือ 15
สามารถแสดงให้เห็นว่า 15 เป็นค่าต่ำสุดที่เป็นไปได้ของ bitwise OR ขององค์ประกอบที่เหลือของ nums หลังจากทำการดำเนินการไม่เกิน k ครั้ง

ข้อจำกัด:

1 <= nums.length <= 10^5
0 <= nums[i] < 2^30
0 <= k < nums.length

คุณได้รับอาเรย์เลขจำนวนเต็มแบบ 0-indexed ชื่อ nums และจำนวนเต็ม k
ในการทำงานหนึ่งครั้ง คุณสามารถเลือกดัชนี i ของ nums ได้โดยที่ 0 <= i < nums.length - 1 และแทนที่ nums[i] และ nums[i + 1] ด้วยการเกิดขึ้นครั้งเดียวของ nums[i] & nums[i + 1] โดยที่ & แทนตัวดำเนินการ bit AND operations
จงส่งคืนค่าต่ำสุดที่เป็นไปได้ของ bitwise OR ขององค์ประกอบที่เหลือของ nums หลังจากการใช้สมการสูงสุด k ครั้ง

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

Input: nums = [3,5,3,2,7], k = 2
Output: 3
คำอธิบาย: ทำการทำงานดังต่อไปนี้:
1. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [1,3,2,7]
2. แทนที่ nums[2] และ nums[3] ด้วย (nums[2] & nums[3]) เพื่อให้ nums เท่ากับ [1,3,2]
bit-or ของอาเรย์สุดท้ายคือ 3
สามารถแสดงได้ว่า 3 เป็นค่าต่ำสุดที่เป็นไปได้ของ bit OR ขององค์ประกอบที่เหลือของ nums หลังจากการใช้สมการสูงสุด k ครั้ง

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

Input: nums = [7,3,15,14,2,8], k = 4
Output: 2
คำอธิบาย: ทำการทำงานดังต่อไปนี้:
1. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [3,15,14,2,8]
2. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [3,14,2,8]
3. แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [2,2,8]
4. แทนที่ nums[1] และ nums[2] ด้วย (nums[1] & nums[2]) เพื่อให้ nums เท่ากับ [2,0]
bit-or ของอาเรย์สุดท้ายคือ 2
สามารถแสดงได้ว่า 2 เป็นค่าต่ำสุดที่เป็นไปได้ของ bit OR ขององค์ประกอบที่เหลือของ nums หลังจากการใช้สมการสูงสุด k ครั้ง

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

Input: nums = [10,7,10,3,9,14,9,4], k = 1
Output: 15
คำอธิบาย: โดยไม่ต้องทำการทำงานใด ๆ bit-or ของ nums คือ 15
สามารถแสดงได้ว่า 15 เป็นค่าต่ำสุดที่เป็นไปได้ของ bit OR ขององค์ประกอบที่เหลือของ nums หลังจากการใช้สมการสูงสุด k ครั้ง

ข้อจำกัด:

1 <= nums.length <= 10^5
0 <= nums[i] < 2^30
0 <= k < nums.length

คุณจะได้รับอาร์เรย์จำนวนเต็มที่ถูกจัดทำดัชนีเริ่มต้นที่ 0และจำนวนเต็ม k
ในการทำงานหนึ่งครั้ง คุณสามารถเลือกดัชนี i ของ nums ได้โดยที่ 0 <= i < nums.length - 1 และแทนที่ nums[i] และ nums[i + 1] ด้วยการเกิดขึ้นครั้งเดียวของ nums[i] & nums[i + 1] โดยที่ & แทนตัวดำเนินการ bitwise AND
ส่งคืนค่าต่ำสุดที่เป็นไปได้ของ bitwise OR ขององค์ประกอบที่เหลือของ nums หลังจากใช้การดำเนินการไม่เกิน k ครั้ง

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

อินพุต: nums = [3,5,3,2,7], k = 2
เอาท์พุท: 3
คำอธิบาย: มาดำเนินการต่อไปนี้:
1. แทนที่ nums [0] และ nums [1] ด้วย (nums[0] & nums [1]) เพื่อให้ nums เท่ากับ [1,3,2,7]
2. แทนที่ nums [2] และ nums [3] ด้วย (nums[2] & nums [3]) เพื่อให้nums มีค่าเท่ากับ [1,3,2]
bitwise-or ของอาร์เรย์สุดท้ายคือ 3
มันสามารถแสดงให้เห็นว่า 3 เป็นค่าขั้นต่ำที่เป็นไปได้ของ ตามเข็มขัด หรือขององค์ประกอบที่เหลือของ nums หลังจากใช้ในการดำเนินการ k ส่วนใหญ่
ตัวอย่างที่ 2:

อินพุต: nums = [7,3,15,14,2,8], k = 4
เอาท์พุท: 2
คำอธิบาย: มาดำเนินการต่อไปนี้:

1.แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [3,15,14,2,8]
2.แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [3,14,2,8]
3.แทนที่ nums[0] และ nums[1] ด้วย (nums[0] & nums[1]) เพื่อให้ nums เท่ากับ [2,2,8]
4.แทนที่ nums[1] และ nums[2] ด้วย (nums[1] & nums[2]) เพื่อให้ nums เท่ากับ [2,0]
bitwise-or ของอาร์เรย์สุดท้ายคือ 2
มันสามารถแสดงให้เห็นว่า 2 เป็นค่าต่ำสุดที่เป็นไปได้ของ ตามเข็มขัด หรือขององค์ประกอบที่เหลือของ nums หลังจากใช้ในการดำเนินการ k ส่วนใหญ่

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

อินพุต: nums = [10,7,10,3,9,14,9,4], k = 1
เอาท์พุท: 15
คำอธิบาย: โดยไม่ต้องใช้การดำเนินการใด ๆ bitwise-or ของ nums คือ 15
มันสามารถแสดงให้เห็นว่า 15 เป็นค่าต่ำสุดที่เป็นไปได้ของ bitwise หรือขององค์ประกอบที่เหลือของ nums หลังจากใช้ในการดำเนินการ k ส่วนใหญ่

ข้อ จำกัด :

1 <= nums.length <= 10^5
0 <= nums [i] <2^30
0 <= k <nums.length


คุณจะได้รับอาร์เรย์ของจำนวนเต็มบวกจำนวน nums ที่มีความยาว n
รูปหลายเหลี่ยมคือรูปร่างระนาบปิดที่มีอย่างน้อย 3 ด้าน ด้านที่ยาวที่สุดของรูปหลายเหลี่ยมจะเล็กกว่าผลรวมของด้านอื่นๆ
ในทางกลับกัน หากคุณมีจำนวนจริงบวก k (k >= 3) a_1, a_2, a_3, ..., a_k โดยที่ a_1 <= a_2 <= a_3 <= ... <= a_k และ a_1 + a_2 + a_3 + ... + a_k-1 > a_k ก็จะมีรูปหลายเหลี่ยมที่มี k ด้านเสมอ โดยมีความยาวเป็น a_1, a_2, a_3, ..., a_k
เส้นรอบวงของรูปหลายเหลี่ยมคือผลรวมของความยาวของด้าน
คืนค่าเส้นรอบวงที่ใหญ่ที่สุดที่เป็นไปได้ของรูปหลายเหลี่ยมซึ่งด้านสามารถสร้างได้จาก nums หรือ -1 หากไม่สามารถสร้างรูปหลายเหลี่ยมได้
ตัวอย่างที่ 1:

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

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

อินพุต: nums = [1,12,1,2,5,50,3]
เอาต์พุต: 12
คำอธิบาย: รูปหลายเหลี่ยมที่มีเส้นรอบวงที่ใหญ่ที่สุดที่สร้างจาก nums ได้คือ 5 ด้าน ได้แก่ 1, 1, 2, 3 และ 5 โดยเส้นรอบวงคือ 1 + 1 + 2 + 3 + 5 = 12
เราไม่สามารถมีรูปหลายเหลี่ยมที่มีด้านที่ยาวที่สุดเป็น 12 หรือ 50 ได้ เนื่องจากไม่สามารถรวมด้านที่เล็กกว่า 2 ด้านขึ้นไปที่มีผลรวมมากกว่าด้านใดด้านหนึ่งได้ จะเห็นได้ว่าเส้นรอบวงที่ใหญ่ที่สุดคือ 12

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

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

ข้อจำกัด:

3 <= n <= 10^5
1 <= nums[i] <= 10^9

คุณจะได้รับอาร์เรย์ของจำนวนเต็มบวกความยาว n
รูปหลายเหลี่ยมเป็นรูประนาบปิดที่มีอย่างน้อย 3 ด้าน ด้านที่ยาวที่สุดของรูปหลายเหลี่ยมมีขนาดเล็กกว่าผลรวมของด้านอื่น ๆ
ในทางกลับกันถ้าคุณมี k (k> = 3) จำนวนจริงบวก a_1, a_2, a_3, ..., a_k โดยที่ a_1 <= a_2 <= a_3 <= ... <= a_k และ a_1 + a_2 + a_3 + ... + a_k-1 > a_k จากนั้นมีรูปหลายเหลี่ยมที่มีด้าน k ที่มีความยาวคือ a_1, a_2, a_3, ..., a_k
ปริมณฑลของรูปหลายเหลี่ยมคือผลรวมของความยาวของด้านข้าง
ส่งคืนขอบเขตที่ใหญ่ที่สุดที่เป็นไปได้ของรูปหลายเหลี่ยมที่สามารถเกิดขึ้นได้จาก nums หรือ -1 หากไม่สามารถสร้างรูปหลายเหลี่ยมได้

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

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

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

อินพุต: nums = [1,12,1,2,5,50,3]
เอาท์พุท: 12
คำอธิบาย: รูปหลายเหลี่ยมที่มีเส้นรอบวงที่ใหญ่ที่สุดซึ่งสามารถทำจาก nums มี 5 ด้าน: 1, 1, 2, 3, และ 5. ปริมณฑลคือ 1 + 1 + 2 + 3 + 5 = 12
เราไม่สามารถมีรูปหลายเหลี่ยมที่มี 12 หรือ 50 เป็นด้านที่ยาวที่สุดเพราะมันเป็นไปไม่ได้ที่จะรวม 2 ด้านที่เล็กกว่าหรือมากกว่าที่มีผลรวมมากกว่าทั้งสองด้าน
มันสามารถแสดงให้เห็นว่าเส้นรอบวงที่ใหญ่ที่สุดที่เป็นไปได้คือ 12

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

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

ข้อ จำกัด :

3 <= n <= 10^5
1 <= nums [i] <= 10^9


คุณจะได้รับอาร์เรย์ของจำนวนเต็มจำนวน nums ที่มีความยาว n
ต้นทุนของอาร์เรย์คือค่าขององค์ประกอบแรก ตัวอย่างเช่น ต้นทุนของ [1,2,3] คือ 1 ในขณะที่ต้นทุนของ [3,4,1] คือ 3
คุณต้องแบ่ง nums ออกเป็น 3 ซับอาร์เรย์ที่ต่อเนื่องกันและแยกจากกัน
ส่งคืนผลรวมต้นทุนที่น้อยที่สุดที่เป็นไปได้ของซับอาร์เรย์เหล่านี้
ตัวอย่างที่ 1:

อินพุต: nums = [1,2,3,12]
เอาต์พุต: 6
คำอธิบาย: วิธีที่ดีที่สุดในการสร้างอาร์เรย์ย่อย 3 ชุดคือ: [1], [2] และ [3,12] โดยมีต้นทุนรวม 1 + 2 + 3 = 6
วิธีอื่นๆ ที่เป็นไปได้ในการสร้างอาร์เรย์ย่อย 3 ชุดคือ:
- [1], [2,3] และ [12] โดยมีต้นทุนรวม 1 + 2 + 12 = 15
- [1,2], [3] และ [12] โดยมีต้นทุนรวม 1 + 3 + 12 = 16

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

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

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

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

ข้อจำกัด:

3 <= n <= 50
1 <= nums[i] <= 50

ให้คุณอาเรย์ของจำนวนเต็ม nums ที่มีความยาว n
ค่าของอาร์เรย์คือค่าขององค์ประกอบแรก ตัวอย่างเช่น ค่าของ [1,2,3] คือ 1 ในขณะที่ค่าของ [3,4,1] คือ 3
คุณต้องแบ่ง nums ออกเป็น 3 อาเรย์ย่อยที่ไม่ทับซ้อนกันแต่ติดกัน
ให้คืนค่าผลรวมขั้นต่ำสุดของค่าของอาเรย์ย่อยเหล่านี้

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

Input: nums = [1,2,3,12]
Output: 6
คำอธิบาย: วิธีที่ดีที่สุดในการสร้าง 3 อาเรย์ย่อยคือ: [1], [2], และ [3,12] ด้วยค่ารวม 1 + 2 + 3 = 6
วิธีอื่นๆ ในการสร้าง 3 อาเรย์ย่อยคือ:
- [1], [2,3], และ [12] ด้วยค่ารวม 1 + 2 + 12 = 15
- [1,2], [3], และ [12] ด้วยค่ารวม 1 + 3 + 12 = 16

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

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

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

Input: nums = [10,3,1,1]
Output: 12
คำอธิบาย: วิธีที่ดีที่สุดในการสร้าง 3 อาเรย์ย่อยคือ: [10,3], [1], และ [1] ด้วยค่ารวม 10 + 1 + 1 = 12
สามารถแสดงได้ว่า 12 เป็นค่าที่ต่ำที่สุดที่ทำได้

Constraints:

3 <= n <= 50
1 <= nums[i] <= 50


คุณจะได้รับอาร์เรย์ nums ที่มีความยาว n และจำนวนเต็มบวก k
อาร์เรย์ย่อยของ nums จะถูกเรียกว่า good ถ้าความแตกต่างสัมบูรณ์ระหว่างองค์ประกอบแรกและองค์ประกอบสุดท้ายเท่ากับ k พอดี กล่าวอีกนัยหนึ่ง อาร์เรย์ย่อย nums[i..j] จะถือว่า good ถ้า |nums[i] - nums[j]| == k
ส่งคืนผลรวมสูงสุดของอาร์เรย์ย่อยที่ดีของ nums หากไม่มีอาร์เรย์ย่อยที่ดี ให้ส่งคืน 0

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

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

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

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

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

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

ข้อจำกัด:

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

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

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

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

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

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

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

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

ข้อ จำกัด :

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

คุณได้รับอาร์เรย์ nums ที่มีความยาว n และจำนวนเต็มบวก k
ซับอาร์เรย์ของ nums จะเรียกว่าดีถ้าค่าความแตกต่างสัมบูรณ์ระหว่างองค์ประกอบแรกและองค์ประกอบสุดท้ายของมันเท่ากับ k โดยกล่าวอีกนัยหนึ่ง ซับอาร์เรย์ nums[i..j] จะดีถ้า |nums[i] - nums[j]| == k
ให้คืนค่าผลรวมสูงสุดของซับอาร์เรย์ที่ดีของ nums หากไม่มีซับอาร์เรย์ที่ดี ให้คืนค่า 0

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

Input: nums = [1,2,3,4,5,6], k = 1
Output: 11
คำอธิบาย: ความแตกต่างที่แน่นอนระหว่างองค์ประกอบแรกและองค์ประกอบสุดท้ายต้องเป็น 1 สำหรับซับอาเรย์ที่ดี ซับอาเรย์ที่ดีทั้งหมดคือ: [1,2], [2,3], [3,4], [4,5], และ [5,6] ผลรวมของซับอาเรย์สูงสุดคือ 11 สำหรับซับอาเรย์ [5,6]

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

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

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

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

ข้อจำกัด:

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


คุณจะได้รับสตริง s ที่ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
สตริงจะเรียกว่าพิเศษหากประกอบด้วยอักขระเพียงตัวเดียว ตัวอย่างเช่น สตริง "abc" ไม่ใช่พิเศษ ในขณะที่สตริง "ddd", "zz" และ "f" เป็นพิเศษ
ส่งคืนความยาวของซับสตริงพิเศษที่ยาวที่สุดของ s ซึ่งเกิดขึ้นอย่างน้อยสามครั้ง หรือ -1 หากไม่มีซับสตริงพิเศษเกิดขึ้นอย่างน้อยสามครั้ง
ซับสตริงคือลำดับอักขระที่ไม่ว่างต่อเนื่องกันภายในสตริง

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

อินพุต: s = "aaaa"
เอาต์พุต: 2
คำอธิบาย: ซับสตริงพิเศษที่ยาวที่สุดซึ่งเกิดขึ้นสามครั้งคือ "aa": ซับสตริง "aaaa", "aaaa" และ "aaaa" แสดงให้เห็นว่าความยาวสูงสุดที่ทำได้คือ 2

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

อินพุต: s = "abcdef"
เอาต์พุต: -1
คำอธิบาย: ไม่มีซับสตริงพิเศษที่เกิดขึ้นอย่างน้อยสามครั้ง ดังนั้นให้ส่งคืน -1

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

อินพุต: s = "abcaba"
เอาต์พุต: 1
คำอธิบาย: ซับสตริงพิเศษที่ยาวที่สุดที่เกิดขึ้นสามครั้งคือ "a": ซับสตริง "abcaba", "abcaba" และ "abcaba"
แสดงให้เห็นว่าความยาวสูงสุดที่ทำได้คือ 1

ข้อจำกัด:

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

คุณได้รับสตริง s ที่ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
สตริงจะถูกเรียกว่าพิเศษ หากมันประกอบด้วยตัวอักษรเพียงตัวเดียวเท่านั้น ตัวอย่างเช่น สตริง "abc" ไม่ใช่พิเศษ ในขณะที่สตริง "ddd", "zz" และ "f" เป็นพิเศษ
ให้คืนค่าความยาวของซับสตริงพิเศษที่ยาวที่สุดของ s ซึ่งเกิดขึ้นอย่างน้อยสามครั้ง หรือ -1 หากไม่มีซับสตริงพิเศษที่เกิดขึ้นอย่างน้อยสามครั้ง
ซับสตริงคือชุดของตัวอักษรที่ต่อเนื่องกันและไม่ว่างภายในสตริง

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

Input: s = "aaaa"
Output: 2
คำอธิบาย: ซับสตริงพิเศษที่ยาวที่สุดที่เกิดขึ้นอย่างน้อยสามครั้งคือ 'aa': ซับสตริง 'aaaa', 'aaaa', และ 'aaaa' สามารถแสดงให้เห็นได้ว่าความยาวสูงสุดที่สามารถทำได้คือ 2

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

Input: s = "abcdef"
Output: -1
ไม่มีซับสตริงพิเศษใดที่เกิดขึ้นอย่างน้อยสามครั้ง ดังนั้นให้คืนค่า -1.

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

Input: s = "abcaba"
Output: 1
คำอธิบาย: ซับสตริงพิเศษที่ยาวที่สุดที่เกิดขึ้นอย่างน้อยสามครั้งคือ 'a': ซับสตริง 'abcaba', 'abcaba', และ 'abcaba' สามารถแสดงให้เห็นได้ว่าความยาวสูงสุดที่สามารถทำได้คือ 1

ข้อกำกัด

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


คุณได้รับอาร์เรย์จำนวนเต็ม nums ขนาด n ที่มีดัชนีเริ่มต้นที่ 0 และอาร์เรย์จำนวนเต็ม pattern ขนาด m ที่ประกอบด้วยจำนวน -1, 0 และ 1
ซับอาร์เรย์ nums[i..j] ขนาด m + 1 จะถือว่าตรงกับรูปแบบหากเงื่อนไขต่อไปนี้เป็นจริงสำหรับแต่ละองค์ประกอบ pattern[k]:

nums[i + k + 1] > nums[i + k] หาก pattern[k] == 1
nums[i + k + 1] == nums[i + k] หาก pattern[k] == 0
nums[i + k + 1] < nums[i + k] หาก pattern[k] == -1

คืนค่าจำนวนของ subarrays ใน nums ที่ตรงกับรูปแบบ (pattern) ที่กำหนด

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

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

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

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

ข้อจำกัด:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ขนาด n และรูปแบบอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ขนาด m ซึ่งประกอบด้วยจำนวนเต็ม -1, 0 และ 1
อาร์เรย์ย่อย nums[i..j] ขนาด m + 1 จะถือว่าตรงกับรูปแบบหากเงื่อนไขต่อไปนี้เป็นจริงสำหรับแต่ละองค์ประกอบ pattern[k]:

nums[i + k + 1] > nums[i + k] if pattern[k] == 1.
nums[i + k + 1] == nums[i + k] if pattern[k] == 0.
nums[i + k + 1] < nums[i + k] if pattern[k] == -1.

ส่งคืนจำนวนอาร์เรย์ย่อยใน num ที่ตรงกับรูปแบบ

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

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

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

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

ข้อจำกัด:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นที่ 0ขนาด N และรูปแบบอาร์เรย์จำนวนเต็ม 0 ดัชนีที่มีขนาด m ประกอบด้วยจำนวนเต็ม -1, 0 และ 1
subarray nums[i..j] ของขนาด m + 1 ถือว่าตรงกับรูปแบบถ้าเงื่อนไขต่อไปนี้ถือสำหรับแต่ละองค์ประกอบองค์ประกอบ [k]:

nums[i + k + 1] > nums[i + k] if pattern[k] == 1.
nums[i + k + 1] == nums[i + k] if pattern[k] == 0.
nums[i + k + 1] < nums[i + k] if pattern[k] == -1.

ส่งคืนจำนวน subarrays ใน nums ที่ตรงกับรูปแบบ

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

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

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

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

ข้อ จำกัด :

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1


อลิซและบ็อบกำลังเล่นเกมผลัดตากันบนสนามวงกลมที่ล้อมรอบด้วยดอกไม้ วงกลมแทนสนาม และมีดอกไม้ x ดอกในทิศทางตามเข็มนาฬิกาอยู่ระหว่างอลิซและบ็อบ และมีดอกไม้ y ดอกในทิศทางทวนเข็มนาฬิการะหว่างพวกเขา
เกมดำเนินไปดังนี้:

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

เมื่อกำหนดจำนวนเต็ม n และ m งานคือคำนวณจำนวนคู่ที่เป็นไปได้ (x, y) ที่ตรงตามเงื่อนไข:

อลิซต้องชนะเกมตามกฎที่อธิบายไว้
จำนวนดอกไม้ x ดอกในทิศทางตามเข็มนาฬิกาต้องอยู่ในช่วง [1,n]
จำนวนดอกไม้ y ดอกในทิศทางทวนเข็มนาฬิกาต้องอยู่ในช่วง [1,m]

ส่งคืนจำนวนคู่ที่เป็นไปได้ (x, y) ที่ตอบสนองเงื่อนไขที่ระบุในคำสั่ง

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

อินพุต: n = 3, m = 2
เอาต์พุต: 3
คำอธิบาย: คู่ต่อไปนี้ตอบสนองเงื่อนไขที่ระบุในคำสั่ง: (1,2), (3,2), (2,1)

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

อินพุต: n = 1, m = 1
เอาต์พุต: 0
คำอธิบาย: ไม่มีคู่ใดตอบสนองเงื่อนไขที่ระบุในคำสั่ง

ข้อจำกัด:

1 <= n, m <= 10^5

อลิซและบ๊อบกำลังเล่นเกมเทิร์นอิงบนสนามวงกลมที่ล้อมรอบด้วยดอกไม้ วงกลมแสดงถึงสนามและมีดอกไม้ x ในทิศทางตามเข็มนาฬิการะหว่างอลิซและบ๊อบและดอกไม้ y ในทิศทางทวนเข็มนาฬิการะหว่างพวกเขา
เกมดำเนินการดังนี้:

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

ได้รับสองจำนวนเต็ม n และ m งานคือการคำนวณจำนวนคู่ที่เป็นไปได้ (x, y) ที่เป็นไปตามเงื่อนไข:

อลิซจะต้องชนะเกมตามกฎที่อธิบายไว้
จำนวนดอกไม้ x ในทิศทางตามเข็มนาฬิกาจะต้องอยู่ในช่วง [1, n]
จำนวนดอกไม้ y ในทิศทางทวนเข็มนาฬิกาต้องอยู่ในช่วง [1, m]

ส่งคืนจำนวนคู่ที่เป็นไปได้ (x, y) ที่เป็นไปตามเงื่อนไขที่กล่าวถึงในคำสั่ง

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

อินพุต: n = 3, m = 2
เอาท์พุท: 3
คำอธิบาย: คู่ต่อไปนี้เป็นไปตามเงื่อนไขที่อธิบายไว้ในคำแถลง: (1,2), (3,2), (2,1)

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

อินพุต: n = 1, m = 1
เอาท์พุท: 0
คำอธิบาย: ไม่มีคู่ตรงตามเงื่อนไขที่อธิบายไว้ในคำแถลง

ข้อ จำกัด :

1 <= n, m <= 10^5

อลิซและบ็อบกําลังเล่นเกมแบบเทิร์นเบสบนทุ่งวงกลมที่รายล้อมไปด้วยดอกไม้ วงกลมแสดงถึงสนาม และมีดอกไม้ x ในทิศทางตามเข็มนาฬิการะหว่างอลิซและบ็อบ และดอกไม้ y ในทิศทางทวนเข็มนาฬิการะหว่างพวกเขา
เกมดําเนินไปดังนี้:

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

เมื่อกําหนดจํานวนเต็มสองตัว n และ m งานคือการคํานวณจํานวนคู่ที่เป็นไปได้ (x, y) ที่ตรงตามเงื่อนไข:

อลิซต้องชนะเกมตามกฎที่อธิบายไว้
จํานวนดอกไม้ x ในทิศทางตามเข็มนาฬิกาต้องอยู่ในช่วง [1,n]
จํานวนดอก y ในทิศทางทวนเข็มนาฬิกาต้องอยู่ในช่วง [1,m]

ส่งคืนจํานวนคู่ที่เป็นไปได้ (x, y) ที่ตรงตามเงื่อนไขที่กล่าวถึงในคําสั่ง

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

อินพุต: n = 3, m = 2
เอาท์พุต: 3
คําอธิบาย: คู่ต่อไปนี้เป็นไปตามเงื่อนไขที่อธิบายไว้ในข้อความ: (1,2), (3,2), (2,1)

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

อินพุต: n = 1, m = 1
เอาท์พุต: 0
คําอธิบาย: ไม่มีคู่ใดที่ตรงตามเงื่อนไขที่อธิบายไว้ในคําชี้แจง

ข้อจํากัด:

1 <= n, m <= 10^5


คุณจะได้รับอาร์เรย์ที่มีดัชนี 0 ของจำนวนเต็มบวก nums
ในการดำเนินการหนึ่งครั้ง คุณสามารถสลับองค์ประกอบที่อยู่ติดกันสององค์ประกอบได้หากองค์ประกอบเหล่านั้นมีจำนวนบิตที่ตั้งค่าเท่ากัน คุณสามารถดำเนินการนี้ได้หลายครั้งเท่าที่ต้องการ (รวมถึงศูนย์ด้วย)
คืนค่า true หากคุณสามารถเรียงลำดับอาร์เรย์ได้ มิฉะนั้น ให้คืนค่า false

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

อินพุต: nums = [8,4,2,30,15]
เอาต์พุต: true
คำอธิบาย: มาดูการแสดงแบบไบนารีขององค์ประกอบแต่ละองค์ประกอบกัน ตัวเลข 2, 4 และ 8 มีบิตที่ตั้งค่าไว้ 1 บิต โดยแต่ละบิตมีการแสดงแบบไบนารี "10", "100" และ "1000" ตามลำดับ ตัวเลข 15 และ 30 มีบิตที่ตั้งค่าไว้ 4 บิต โดยแต่ละบิตมีการแสดงแบบไบนารี "1111" และ "11110"
เราสามารถเรียงลำดับอาร์เรย์ได้โดยใช้การดำเนินการ 4 ประการ:
- สลับ nums[0] กับ nums[1] การดำเนินการนี้ถูกต้องเนื่องจาก 8 และ 4 มีบิตที่ตั้งค่าไว้ 1 บิต อาร์เรย์จะกลายเป็น [4,8,2,30,15]
- สลับ nums[1] กับ nums[2] การดำเนินการนี้ถูกต้องเนื่องจาก 8 และ 2 มีบิตที่ตั้งค่าไว้ 1 บิตต่ออาร์เรย์จะกลายเป็น [4,2,8,30,15]
- สลับ nums[0] กับ nums[1] การดำเนินการนี้ถูกต้องเนื่องจาก 4 และ 2 มีบิตที่ตั้งค่าไว้ 1 บิตต่ออาร์เรย์จะกลายเป็น [2,4,8,30,15]
- สลับ nums[3] กับ nums[4] การดำเนินการนี้ถูกต้องเนื่องจาก 30 และ 15 มีบิตที่ตั้งค่าไว้ 4 บิตต่ออาร์เรย์จะกลายเป็น [2,4,8,15,30]
อาร์เรย์ได้รับการเรียงลำดับแล้ว ดังนั้นเราจึงส่งคืนค่าจริง
โปรดทราบว่าอาจมีลำดับการดำเนินการอื่นๆ ที่เรียงลำดับอาร์เรย์ด้วยเช่นกัน

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

อินพุต: nums = [1,2,3,4,5]
เอาต์พุต: true
คำอธิบาย: อาร์เรย์ได้รับการเรียงลำดับแล้ว ดังนั้นเราจึงส่งคืนค่า true

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

อินพุต: nums = [3,16,8,4,2]
เอาต์พุต: false
คำอธิบาย: จะเห็นได้ว่าไม่สามารถเรียงลำดับอาร์เรย์อินพุตโดยใช้การดำเนินการใดๆ ได้เลย

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 2^8

คุณจะได้รับอาร์เรย์ 0-indexed ของจำนวนเต็มบวก nums
ในการดำเนินการครั้งเดียวคุณสามารถสลับองค์ประกอบสองอย่างที่อยู่ติดกันได้หากพวกเขามีจำนวนบิตชุดเท่ากัน คุณได้รับอนุญาตให้ดำเนินการนี้หลายครั้ง (รวมถึงศูนย์)
ส่งคืน true ถ้าคุณสามารถเรียงลำดับอาร์เรย์ ถ้าไม่ได้ ให้ส่งคืน false

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

อินพุต: nums = [8,4,2,30,15]
เอาท์พุท:  true
คำอธิบาย: ลองดูการเป็นตัวแทนไบนารีของทุกองค์ประกอบ หมายเลข 2, 4 และ 8 มีหนึ่งบิตตั้งแต่ละตัวด้วยการเป็นตัวแทนไบนารี "10", "100" และ "1,000" ตามลำดับ หมายเลข 15 และ 30 มีบิตสี่ชุดแต่ละชุดมีการเป็นตัวแทนไบนารี "1111" และ "11110"
เราสามารถเรียงลำดับอาร์เรย์โดยใช้ 4 การดำเนินการ:
- สลับ nums [0] ด้วย nums [1] การดำเนินการนี้ใช้ได้เนื่องจาก 8 และ 4 มีหนึ่งบิตแต่ละชุด อาร์เรย์จะกลายเป็น [4,8,2,30,15]
- สลับ nums [1] กับ nums [2] การดำเนินการนี้ใช้ได้เนื่องจาก 8 และ 2 มีหนึ่งบิตแต่ละชุด อาร์เรย์กลายเป็น [4,2,8,30,15]
- สลับ nums [0] ด้วย nums [1] การดำเนินการนี้ใช้ได้เพราะ 4 และ 2 มีหนึ่งบิตแต่ละชุด อาร์เรย์กลายเป็น [2,4,8,30,15]
- สลับ nums [3] กับ nums [4] การดำเนินการนี้ใช้ได้เนื่องจาก 30 และ 15 มีสี่ชุดแต่ละชุด อาร์เรย์จะกลายเป็น [2,4,8,15,30]
อาร์เรย์ได้เรียงลำดับเรียบร้อยแล้วดังนั้นเราจึงกลับมาเป็นจริง
โปรดทราบว่าอาจมีลำดับการดำเนินการอื่น ๆ ซึ่งเรียงลำดับอาร์เรย์

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

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

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

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

ข้อ จำกัด :

1 <= nums.length <= 100
1 <= nums [i] <= 2^8

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

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

อินพุต: ตัวเลข = [8,4,2,30,15]
เอาท์พุต: จริง
คำอธิบาย: ลองดูที่การแสดงไบนารีของทุกองค์ประกอบ ตัวเลข 2, 4 และ 8 มีหนึ่งชุดบิตโดยแต่ละชุดมีเลขฐานสอง "10", "100" และ "1000" ตามลำดับ ตัวเลข 15 และ 30 มีบิตชุดสี่ชุด แต่ละชุดมีเลขฐานสอง "1111" และ "11110"
เราสามารถจัดเรียงอาร์เรย์ได้โดยใช้ 4 การดำเนินการ:
- สลับตัวเลข[0]กับตัวเลข[1] การดำเนินการนี้ถูกต้องเนื่องจาก 8 และ 4 มีบิตชุดละหนึ่งบิต อาร์เรย์จะกลายเป็น [4,8,2,30,15]
- สลับตัวเลข [1] กับตัวเลข [2] การดำเนินการนี้ถูกต้องเนื่องจาก 8 และ 2 มีบิตชุดละหนึ่งบิต อาร์เรย์จะกลายเป็น [4,2,8,30,15]
- สลับตัวเลข[0]กับตัวเลข[1] การดำเนินการนี้ถูกต้องเนื่องจาก 4 และ 2 มีบิตชุดละหนึ่งบิต อาร์เรย์จะกลายเป็น [2,4,8,30,15]
- สลับตัวเลข [3] กับตัวเลข [4] การดำเนินการนี้ถูกต้องเนื่องจาก 30 และ 15 มีบิตชุดละ 4 บิต อาร์เรย์จะกลายเป็น [2,4,8,15,30]
อาร์เรย์ถูกจัดเรียงแล้ว ดังนั้นเราจึงคืนค่าเป็นจริง
โปรดทราบว่าอาจมีลำดับการดำเนินการอื่นๆ ที่เรียงลำดับอาร์เรย์ด้วย

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

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

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

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

ข้อจำกัด:

1 <= nums.ความยาว <= 100
1 <= ตัวเลข[i] <= 2^8


คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 1 จำนวน 2 ชุด คือ nums และ changeIndices ซึ่งมีความยาว n และ m ตามลำดับ
ในขั้นแรก ดัชนีทั้งหมดใน nums จะไม่มีการทำเครื่องหมาย งานของคุณคือทำเครื่องหมายดัชนีทั้งหมดใน nums
ในแต่ละวินาที s ตามลำดับจาก 1 ถึง m (รวมทั้งหมด) คุณสามารถดำเนินการอย่างใดอย่างหนึ่งต่อไปนี้:

เลือกดัชนี i ในช่วง [1, n] และลด nums[i] ลง 1
ถ้า nums[changeIndices[s]] เท่ากับ 0 ให้ทำเครื่องหมายดัชนี changeIndices[s]
ไม่ต้องทำอะไร

ส่งคืนจำนวนเต็มที่แสดงถึงวินาทีแรกสุดในช่วง [1, m] เมื่อดัชนีทั้งหมดใน nums สามารถทำเครื่องหมายได้โดยเลือกการดำเนินการที่เหมาะสมที่สุด หรือ -1 หากทำไม่ได้
ตัวอย่างที่ 1:

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

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

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

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

อินพุต: nums = [0,1], changeIndices = [2,2,2]
เอาต์พุต: -1
คำอธิบาย: ในตัวอย่างนี้ ไม่สามารถทำเครื่องหมายดัชนีทั้งหมดได้เนื่องจากดัชนี 1 ไม่ได้อยู่ใน changeIndices
ดังนั้นคำตอบคือ -1

ข้อจำกัด:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n