คุณได้รับสตริงไบนารีที่มีดัชนีเริ่มต้นที่ 0 ซึ่งมีความยาว n โดยคุณสามารถทำการดำเนินการได้สองประเภท:

เลือกดัชนี i และกลับค่าตัวอักษรทั้งหมดตั้งแต่ดัชนี 0 ถึงดัชนี i (รวมทั้งสองดัชนี) โดยมีค่าใช้จ่ายเป็น i + 1
เลือกดัชนี i และกลับค่าตัวอักษรทั้งหมดตั้งแต่ดัชนี i ถึงดัชนี n - 1 (รวมทั้งสองดัชนี) โดยมีค่าใช้จ่ายเป็น n - i

คืนค่าต้นทุนขั้นต่ำในการทำให้ตัวอักษรทั้งหมดในสตริงเท่ากัน
การกลับค่าตัวอักษรหมายถึง หากค่าของมันเป็น '0' มันจะกลายเป็น '1' และในทางกลับกัน

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

Input: s = "0011"
Output: 2
คำอธิบาย: ใช้การดำเนินการครั้งที่สองโดยให้ i = 2 เพื่อให้ได้ s = "0000" โดยมีค่าใช้จ่าย 2 สามารถแสดงให้เห็นได้ว่า 2 เป็นค่าใช้จ่ายขั้นต่ำในการทำให้ตัวอักษรทั้งหมดเท่ากัน

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

Input: s = "010101"
Output: 9
คำอธิบาย: ดำเนินการแรกโดยใช้ i = 2 เพื่อให้ได้ s = "101101" โดยมีค่าใช้จ่าย 3
ดำเนินการแรกโดยใช้ i = 1 เพื่อให้ได้ s = "011101" โดยมีค่าใช้จ่าย 2
ดำเนินการแรกโดยใช้ i = 0 เพื่อให้ได้ s = "111101" โดยมีค่าใช้จ่าย 1
ดำเนินการที่สองโดยใช้ i = 4 เพื่อให้ได้ s = "111110" โดยมีค่าใช้จ่าย 2
ดำเนินการที่สองโดยใช้ i = 5 เพื่อให้ได้ s = "111111" โดยมีค่าใช้จ่าย 1
ค่าใช้จ่ายรวมในการทำให้ตัวอักษรทั้งหมดเท่ากันคือ 9 สามารถแสดงให้เห็นว่า 9 เป็นค่าใช้จ่ายขั้นต่ำในการทำให้ตัวอักษรทั้งหมดเท่ากัน

ข้อจำกัด:

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

คุณจะได้รับสตริงไบนารีที่มีดัชนี 0 ที่มีความยาว n ซึ่งคุณสามารถใช้การดำเนินการสองประเภท:

เลือก index i และกลับตัวอักขระทั้งหมดจาก index 0 ถึง index i (รวมทั้งสอง) ด้วยค่าใช้จ่ายของ i + 1
เลือก index i และกลับตัวอักขระทั้งหมดจาก index i ถึง index n - 1 (รวมทั้งสอง) ด้วยค่าใช้จ่ายของ n - I

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

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

อินพุต: s = "0011"
เอาท์พุท: 2
คำอธิบาย: ใช้การดำเนินการที่สองด้วย i = 2 เพื่อรับ s = "0000" สำหรับค่าใช้จ่าย 2. สามารถแสดงให้เห็นว่า 2 เป็นค่าใช้จ่ายขั้นต่ำที่จะทำให้อักขระทั้งหมดเท่ากัน

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

อินพุต: s = "010101"
เอาท์พุท: 9
คำอธิบาย: ใช้การดำเนินการครั้งแรกด้วย i = 2 เพื่อรับ s = "101101" สำหรับค่าใช้จ่าย 3
ใช้การดำเนินการครั้งแรกด้วย i = 1 เพื่อรับ s = "011101" สำหรับค่าใช้จ่าย 2
ใช้การดำเนินการครั้งแรกด้วย i = 0 เพื่อรับ s = "111101" สำหรับค่าใช้จ่าย 1
ใช้การดำเนินการที่สองด้วย i = 4 เพื่อรับ s = "111110" สำหรับค่าใช้จ่าย 2
ใช้การดำเนินการที่สองด้วย i = 5 เพื่อรับ s = "111111" สำหรับค่าใช้จ่าย 1
ค่าใช้จ่ายทั้งหมดในการทำให้อักขระทั้งหมดเท่ากันคือ 9 มันสามารถแสดงได้ว่า 9 คือค่าใช้จ่ายขั้นต่ำในการทำให้อักขระทั้งหมดเท่ากัน

ข้อ จำกัด :

1 <= s.length == n <= 10^5
s[i] is either '0' or '1'

คุณได้รับสตริงไบนารีที่มีการนับเริ่มจาก 0  s ที่มีความยาว  n  ซึ่งคุณสามารถใช้การดำเนินการได้สองแบบ:

เลือกดัชนี  i  และสลับตัวละครทั้งหมดจากดัชนี 0 ถึงดัชนี  i  (รวมทั้งสองตำแหน่ง) โดยมีค่าใช้จ่ายเท่ากับ  i + 1

เลือกดัชนี  i  และสลับตัวละครทั้งหมดจากดัชนี  i  ถึงดัชนี  n - 1  (รวมทั้งสองตำแหน่ง) โดยมีค่าใช้จ่ายเท่ากับ  n - i

ให้ผลตอบแทนเป็นค่าที่น้อยที่สุดในการทำให้ตัวละครทั้งหมดในสตริงตรงกัน
การสลับตัวละครหมายความว่า ถ้ามีค่าเป็น '0' จะกลายเป็น '1' และในทางกลับกัน

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

Input: s = "0011"
Output: 2
คำอธิบาย: ใช้การดำเนินการแบบที่สองกับ  i = 2  เพื่อให้ได้ s = "0000"  โดยมีค่าใช้จ่ายเท่ากับ 2 สามารถแสดงได้ว่า 2 เป็นค่าใช้จ่ายที่น้อยที่สุดในการทำให้ตัวละครทั้งหมดตรงกัน

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

Input: s = "010101"
Output: 9
คำอธิบาย: ใช้การดำเนินการแบบแรกกับ  i = 2  เพื่อให้ได้  s = "101101"  โดยมีค่าใช้จ่ายเท่ากับ 3
ใช้การดำเนินการแบบแรกกับ  i = 1  เพื่อให้ได้ s = "011101"  โดยมีค่าใช้จ่ายเท่ากับ 2
ใช้การดำเนินการแบบแรกกับ  i = 0  เพื่อให้ได้  s = "111101"  โดยมีค่าใช้จ่ายเท่ากับ 1
ใช้การดำเนินการแบบที่สองกับ  i = 4  เพื่อให้ได้  s = "111110"  โดยมีค่าใช้จ่ายเท่ากับ 2
ใช้การดำเนินการแบบที่สองกับ  i = 5  เพื่อให้ได้  s = "111111"  โดยมีค่าใช้จ่ายเท่ากับ 1
ค่าใช้จ่ายทั้งหมดในการทำให้ตัวละครทั้งหมดตรงกันคือ 9 สามารถแสดงได้ว่า 9 เป็นค่าใช้จ่ายที่น้อยที่สุดในการทำให้ตัวละครทั้งหมดตรงกัน

ข้อจำกัด:

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


กำหนดจำนวนเต็มบวก num ที่แสดงเป็นสตริง ให้ส่งคืนจำนวนเต็ม num โดยไม่มีศูนย์ตามหลังเป็นสตริง

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

อินพุต: num = "51230100"
เอาต์พุต: "512301"
คำอธิบาย: จำนวนเต็ม "51230100" มีศูนย์ตามหลัง 2 ตัว เราลบศูนย์เหล่านั้นออกแล้วส่งคืนจำนวนเต็ม "512301"

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

อินพุต: num = "123"
เอาต์พุต: "123"
คำอธิบาย: จำนวนเต็ม "123" ไม่มีศูนย์ตามหลัง เราส่งคืนจำนวนเต็ม "123"

ข้อจำกัด:

1 <= num.length <= 1000
num ประกอบด้วยตัวเลขเท่านั้น
num ไม่มีศูนย์นำหน้า

ให้จำนวนเต็มบวก num ที่แสดงเป็นสตริง คืนค่าจำนวนเต็ม num โดยไม่มีศูนย์ที่อยู่ด้านหลังเป็นสตริง

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

Input: num = "51230100"
Output: "512301"
คำอธิบาย: จำนวนเต็ม "51230100" มีเลขศูนย์ตามหลัง 2 ตัว เราจะลบออกและคืนค่าจำนวนเต็ม "512301"

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

Input: num = "123"
Output: "123"
คำอธิบาย: จำนวนเต็ม "123" ไม่มีศูนย์ตามหลัง เราจึงส่งกลับจำนวนเต็ม "123"

ข้อจำกัด:

1 <= num.length <= 1000
num ประกอบด้วยเฉพาะตัวเลขเท่านั้น
num ไม่มีศูนย์นำหน้า


คุณได้รับจำนวนเต็ม n ที่ประกอบด้วยตัวเลข 3 หลักอย่างแน่นอน เราจะเรียกจำนวน n ว่าน่าสนใจ (fascinating) หากหลังจากการปรับเปลี่ยนดังต่อไปนี้ จำนวนที่ได้จะมีตัวเลขตั้งแต่ 1 ถึง 9 ครบทุกตัวและไม่มีเลข 0:

นำ n มาต่อกับ 2 * n และ 3 * n

ให้คืนค่า true หาก n นั้นน่าสนใจ หรือ false หากไม่ใช่ การต่อจำนวนสองจำนวนหมายถึงการนำมารวมกัน เช่น การต่อ 121 และ 371 จะได้ 121371

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

Input: n = 192
Output: true
คำอธิบาย: เรารวมตัวเลข n = 192 และ 2 * n = 384 และ 3 * n = 576 เข้าด้วยกัน ผลลัพธ์ที่ได้คือ 192384576 ตัวเลขนี้ประกอบด้วยตัวเลขตั้งแต่ 1 ถึง 9 ทุกตัวอย่างละหนึ่งครั้ง

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

Input: n = 100
Output: false
คำอธิบาย: เรารวมตัวเลข n = 100 และ 2 * n = 200 และ 3 * n = 300 เข้าด้วยกัน ตัวเลขที่ได้คือ 100200300 ตัวเลขนี้ไม่ตรงตามเงื่อนไขใด ๆ ทั้งสิ้น

ข้อจำกัด:

\( 100 \leq n \leq 999 \)

คุณจะได้รับจำนวนเต็ม n ที่ประกอบด้วยตัวเลข 3 หลักพอดี
เราเรียกตัวเลข n ว่า interesting ถ้าหลังจากแก้ไขต่อไปนี้ ตัวเลขที่ได้มีตัวเลขทั้งหมดตั้งแต่ 1 ถึง 9 เพียงครั้งเดียวและไม่มี 0 อยู่เลย:

ต่อ n กับตัวเลข 2 * n และ 3 * n

คืนค่า true ถ้า n เป็น interesting หรือคืนค่า false ถ้าไม่ใช่
การเชื่อมตัวเลขสองตัวเข้าด้วยกันหมายถึงการเชื่อมตัวเลขสองตัวเข้าด้วยกัน ตัวอย่างเช่น การเชื่อม 121 กับ 371 เข้าด้วยกันคือ 121371

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

อินพุต: n = 192
เอาต์พุต: true
คำอธิบาย: เราต่อตัวเลข n = 192 และ 2 * n = 384 และ 3 * n = 576 เข้าด้วยกัน ตัวเลขที่ได้คือ 192384576 ตัวเลขนี้ประกอบด้วยตัวเลขทั้งหมดตั้งแต่ 1 ถึง 9 เพียงครั้งเดียว

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

อินพุต: n = 100
เอาต์พุต: เท็จ
คำอธิบาย: เราต่อตัวเลข n = 100 และ 2 * n = 200 และ 3 * n = 300 เข้าด้วยกัน ตัวเลขที่ได้คือ 100200300 ตัวเลขนี้ไม่เป็นไปตามเงื่อนไขใดๆ

ข้อจำกัด:

100 <= n <= 999

คุณจะได้รับจำนวนเต็ม n ที่ประกอบด้วยตัวเลข 3 หลักพอดี
เราเรียกตัวเลข n ว่า interesting ถ้าหลังจากแก้ไขต่อไปนี้ ตัวเลขที่ได้มีตัวเลขทั้งหมดตั้งแต่ 1 ถึง 9 เพียงครั้งเดียวและไม่มี 0 อยู่เลย:

ต่อ n กับตัวเลข 2 * n และ 3 * n

คืนค่า true ถ้า n เป็น interesting หรือคืนค่า false ถ้าไม่ใช่
การเชื่อมตัวเลขสองตัวเข้าด้วยกันหมายถึงการเชื่อมตัวเลขสองตัวเข้าด้วยกัน ตัวอย่างเช่น การเชื่อม 121 กับ 371 เข้าด้วยกันคือ 121371

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

อินพุต: n = 192
เอาต์พุต: true
คำอธิบาย: เราต่อตัวเลข n = 192 และ 2 * n = 384 และ 3 * n = 576 เข้าด้วยกัน ตัวเลขที่ได้คือ 192384576 ตัวเลขนี้ประกอบด้วยตัวเลขทั้งหมดตั้งแต่ 1 ถึง 9 เพียงครั้งเดียว
ตัวอย่างที่ 2:

อินพุต: n = 100
เอาต์พุต: false
คำอธิบาย: เราต่อตัวเลข n = 100 และ 2 * n = 200 และ 3 * n = 300 เข้าด้วยกัน ตัวเลขที่ได้คือ 100200300 ตัวเลขนี้ไม่เป็นไปตามเงื่อนไขใดๆ

ข้อจำกัด:

100 <= n <= 999


เราให้สตริงที่มีดัชนีเริ่มต้นที่ 0 ชื่อ s ทำซ้ำการดำเนินการต่อไปนี้ได้ไม่จำกัดจำนวนครั้ง:

เลือกดัชนี i ในสายอักขระและให้ c เป็นตัวอักษรในตำแหน่ง i ลบการเกิดขึ้นที่ใกล้ที่สุดของ c ด้านซ้ายของ i (ถ้ามี) และการเกิดขึ้นที่ใกล้ที่สุดของ c ด้านขวาของ i (ถ้ามี)

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

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

Input: s = "aaabc"
Output: 3
คำอธิบาย: ในตัวอย่างนี้ s คือ "aaabc" เราสามารถเริ่มต้นโดยการเลือกตัวอักษร 'a' ที่ดัชนี 1 จากนั้นเราลบ 'a' ที่ใกล้ที่สุดด้านซ้ายของดัชนี 1 ซึ่งอยู่ที่ดัชนี 0 และ 'a' ที่ใกล้ที่สุดด้านขวาของดัชนี 1 ซึ่งอยู่ที่ดัชนี 2 หลังจากการดำเนินการนี้ สตริงจะกลายเป็น "abc" การดำเนินการอื่นใดที่เราทำกับสตริงจะไม่เปลี่ยนแปลงมัน ดังนั้น ความยาวของสตริงที่ถูกทำให้มีขนาดเล็กที่สุดคือ 3

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

Input: s = "cbbd"
Output: 3
คำอธิบาย: สำหรับตัวอย่างนี้ เราสามารถเริ่มต้นด้วยตัวอักษร 'b' ที่ดัชนี 1 ไม่มีการเกิดขึ้นของ 'b' ทางด้านซ้ายของดัชนี 1 แต่มีการเกิดขึ้นหนึ่งทางขวาที่ดัชนี 2 ดังนั้นเราจึงลบ 'b' ที่ดัชนี 2 สตริงจะกลายเป็น "cbd" และการดำเนินการต่อไปจะไม่เปลี่ยนแปลงมัน ดังนั้น ความยาวที่ถูกทำให้มีขนาดเล็กที่สุดคือ 3

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

Input: s = "dddaaa"
Output: 2
คำอธิบาย: สำหรับตัวอย่างนี้ เราสามารถเริ่มต้นด้วยตัวอักษร 'd' ที่ดัชนี 1 การเกิดขึ้นที่ใกล้ที่สุดของ 'd' ทางด้านซ้ายคือที่ดัชนี 0 และการเกิดขึ้นที่ใกล้ที่สุดของ 'd' ทางด้านขวาคือที่ดัชนี 2 เราลบทั้งดัชนี 0 และ 2 ดังนั้น สตริงจะกลายเป็น "daaa" ในสตริงใหม่ เราสามารถเลือกตัวอักษร 'a' ที่ดัชนี 2 การเกิดขึ้นที่ใกล้ที่สุดของ 'a' ทางด้านซ้ายคือที่ดัชนี 1 และการเกิดขึ้นที่ใกล้ที่สุดของ 'a' ทางด้านขวาคือที่ดัชนี 3 เราลบทั้งสอง แล้วสตริงจะกลายเป็น "da" เราไม่สามารถย่อลงได้อีก ดังนั้นความยาวที่ย่อแล้วคือ 2

ข้อจำกัด:

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

กำหนดสตริง s ที่มีดัชนี 0 ให้ดำเนินการต่อไปนี้ซ้ำๆ กันกี่ครั้งก็ได้:

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

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

ตัวอย่าง 1:

อินพุต: s = "aaabc"
เอาต์พุต: 3
คำอธิบาย: ในตัวอย่างนี้ s คือ "aaabc" เราสามารถเริ่มต้นโดยเลือกอักขระ 'a' ที่ดัชนี 1 จากนั้นเราจะลบ 'a' ที่ใกล้เคียงที่สุดทางซ้ายของดัชนี 1 ซึ่งอยู่ที่ดัชนี 0 และ 'a' ที่ใกล้เคียงที่สุดทางขวาของดัชนี 1 ซึ่งอยู่ที่ดัชนี 2 หลังจากดำเนินการนี้ สตริงจะกลายเป็น "abc" การดำเนินการเพิ่มเติมใดๆ ที่เราทำกับสตริงจะไม่เปลี่ยนแปลง ดังนั้นความยาวของสตริงที่ย่อขนาดคือ 3
ตัวอย่างที่ 2:

อินพุต: s = "cbbd"
เอาต์พุต: 3
คำอธิบาย: สำหรับสิ่งนี้ เราสามารถเริ่มด้วยอักขระ 'b' ที่ดัชนี 1 ไม่มี 'b' เกิดขึ้นทางด้านซ้ายของดัชนี 1 แต่มี 'b' อยู่ทางด้านขวาที่ดัชนี 2 ดังนั้นเราจึงลบ 'b' ที่ดัชนี 2 สตริงจะกลายเป็น "cbd" และการดำเนินการต่อไปจะไม่เปลี่ยนแปลง ดังนั้นความยาวที่ย่อขนาดคือ 3

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

อินพุต: s = "dddaaa"
เอาต์พุต: 2
คำอธิบาย: สำหรับสิ่งนี้ เราสามารถเริ่มด้วยอักขระ 'd' ที่ดัชนี 1 อักขระ 'd' ที่เกิดขึ้นใกล้เคียงที่สุดทางด้านซ้ายจะอยู่ที่ดัชนี 0 และอักขระ 'd' ที่เกิดขึ้นใกล้เคียงที่สุดทางด้านขวาจะอยู่ที่ดัชนี 2 เราลบทั้งดัชนี 0 และ 2 ดังนั้นสตริงจะกลายเป็น "daaa" ในสตริงใหม่ เราสามารถเลือกอักขระ 'a' ที่ดัชนี 2 ได้ อักขระ 'a' ที่อยู่ใกล้ที่สุดทางซ้ายจะอยู่ที่ดัชนี 1 และอักขระ 'a' ที่อยู่ใกล้ที่สุดทางขวาจะอยู่ที่ดัชนี 3 เราลบอักขระทั้งสองตัวออก และสตริงจะกลายเป็น "da" เราไม่สามารถย่อขนาดลงได้อีก ดังนั้นความยาวที่ย่อขนาดลงคือ 2

ข้อจำกัด:

1 <= s.length <= 100
s มีเฉพาะตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

ได้รับสตริง 0 ดัชนี s, ดำเนินการซ้ำ ๆ ต่อไปนี้หลายครั้ง:

เลือกดัชนี I ในสตริงและปล่อยให้ c เป็นตัวละครในตำแหน่ง i ลบการเกิดขึ้นที่ใกล้เคียงที่สุดของ c ไปทางซ้ายของ I (ถ้ามี) และการเกิดขึ้นที่ใกล้เคียงที่สุดของ  c ทางด้านขวาของ i (ถ้ามี)

งานของคุณคือการลดความยาวของ s โดยการดำเนินการข้างต้นทุกครั้ง
ส่งคืนจำนวนเต็มที่แสดงถึงความยาวของสตริงย่อเล็กสุด

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

อินพุต: s =  "aaabc"
เอาท์พุท: 3
คำอธิบาย: ในตัวอย่างนี้คือ "aaabc". เราสามารถเริ่มต้นด้วยการเลือกอักขระ 'a' ที่ดัชนี 1 จากนั้นเราจะลบ 'a' ที่ใกล้ที่สุดไปทางซ้ายของดัชนี 1 ซึ่งอยู่ที่ดัชนี 0 และ 'a' ที่ใกล้ที่สุดทางด้านขวาของดัชนี 1 ซึ่งก็คือ ที่ดัชนี 2 หลังจากการดำเนินการนี้สตริงจะกลายเป็น "abc" การดำเนินการเพิ่มเติมใด ๆ ที่เราดำเนินการบนสตริงจะทำให้มันไม่เปลี่ยนแปลง ดังนั้นความยาวของสตริงย่อเล็กสุดคือ 3
ตัวอย่างที่ 2:

อินพุต: s = "cbbd"
เอาท์พุท: 3
คำอธิบาย: สำหรับสิ่งนี้เราสามารถเริ่มต้นด้วยตัวละคร 'b' ที่ดัชนี 1 ไม่มีการเกิด 'B' ไปทางซ้ายของดัชนี 1 แต่มีหนึ่งทางด้านขวาที่ดัชนี 2 ดังนั้นเราจึงลบ 'b' ที่ ดัชนี 2. สตริงกลายเป็น "cbd" และการดำเนินการเพิ่มเติมจะทำให้มันไม่เปลี่ยนแปลง ดังนั้นความยาวที่เล็กที่สุดคือ 3

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

อินพุต: s = "dddaaa"
เอาท์พุท: 2
คำอธิบาย: สำหรับสิ่งนี้เราสามารถเริ่มต้นด้วยตัวละคร 'd' ที่ดัชนี 1 การเกิดขึ้นที่ใกล้เคียงที่สุดของ 'd' ไปทางซ้ายคือที่ดัชนี 0 และการเกิดขึ้นที่ใกล้เคียงที่สุดของ 'd' ไปทางขวาคือที่ดัชนี 2 . เราลบทั้งดัชนี 0 และ 2 ดังนั้นสตริงจะกลายเป็น "daaa" ในสตริงใหม่เราสามารถเลือกอักขระ 'a' ที่ดัชนี 2 การเกิดขึ้นที่ใกล้เคียงที่สุดของ 'a' ไปทางซ้ายคือที่ดัชนี 1 และการเกิดขึ้นที่ใกล้เคียงที่สุดของ 'a' ไปทางขวาคือที่ดัชนี 3 เราลบทั้งสองและสตริงกลายเป็น "da" เราไม่สามารถลดสิ่งนี้ได้อีกต่อไปดังนั้นความยาวที่ลดลงคือ 2

ข้อ จำกัด :

1 <= s.length <= 100
s มีตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก


คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี nums เป็น 0 และคุณได้รับอนุญาตให้ท่องไปมาระหว่างดัชนีต่างๆ คุณสามารถท่องไปมาระหว่างดัชนี i และดัชนี j โดยที่ i ไม่เท่ากับ j ก็ต่อเมื่อ gcd(nums[i], nums[j]) > 1 โดยที่ gcd เป็นตัวหารร่วมมากที่สุด
งานของคุณคือตรวจสอบว่าสำหรับดัชนี i และ j ทุกคู่ใน nums โดยที่ i < j มีลำดับการท่องไปมาที่นำเราจาก i ไปยัง j หรือไม่
คืนค่า true หากสามารถท่องไปมาระหว่างดัชนีคู่ดังกล่าวทั้งหมดได้ หรือคืนค่า false หากไม่สามารถทำได้

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

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

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

อินพุต: nums = [3,9,5]
ผลลัพธ์: false
คำอธิบาย: ในตัวอย่างนี้ ลำดับการสืบค้นไม่สามารถนำเราจากดัชนี 0 ไปยังดัชนี 2 ได้ ดังนั้น เราจึงคืนค่า false

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

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

ข้อจำกัด:

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

คุณได้รับอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นที่ 0 ชื่อว่า nums และคุณสามารถเคลื่อนที่ระหว่างดัชนีต่าง ๆ ได้ คุณสามารถเคลื่อนที่ระหว่างดัชนี i และ j, i != j ได้ก็ต่อเมื่อ gcd(nums[i], nums[j]) > 1, โดยที่ gcd คือ ตัวหารร่วมมากที่สุด
งานของคุณคือการตรวจสอบว่า สำหรับทุกคู่ของดัชนี i และ j ใน nums ที่ i < j มีลำดับการเคลื่อนที่ที่สามารถนำเราไปจาก i ถึง j ได้หรือไม่
คืนค่า true ถ้าสามารถเคลื่อนที่ระหว่างคู่ของดัชนีทั้งหมดเหล่านี้ได้ หรือ false ถ้าไม่สามารถ

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

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

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

Input: nums = [3,9,5]
Output: false
คำอธิบาย: ไม่มีลำดับการเคลื่อนที่ที่สามารถนำเราจากดัชนี 0 ถึงดัชนี 2 ในตัวอย่างนี้ ดังนั้นเราคืนค่า false

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

Input: nums = [4,3,12,8]
Output: true
คำอธิบาย: มีคู่ของดัชนีทั้งหมด 6 คู่ที่สามารถเคลื่อนที่ระหว่างกันได้: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), และ (2, 3) มีลำดับการเคลื่อนที่ที่ถูกต้องสำหรับแต่ละคู่ ดังนั้นเราคืนค่า true

เงื่อนไข:

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


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

เลือกสตริงย่อยใดๆ ที่ไม่ว่างของ s อาจเป็นสตริงทั้งหมด จากนั้นแทนที่อักขระแต่ละตัวด้วยอักขระก่อนหน้าของตัวอักษรภาษาอังกฤษ ตัวอย่างเช่น 'b' จะถูกแปลงเป็น 'a' และ 'a' จะถูกแปลงเป็น 'z'

ส่งคืนสตริงที่เล็กที่สุดตามพจนานุกรมที่คุณสามารถรับได้หลังจากดำเนินการข้างต้นเพียงครั้งเดียว
สตริงย่อยคือลำดับอักขระที่ต่อเนื่องกันในสตริง
สตริง x จะมีขนาดเล็กตามพจนานุกรมกว่าสตริง y ที่มีความยาวเท่ากัน ถ้า x[i] อยู่ก่อน y[i] ตามลำดับตัวอักษรสำหรับตำแหน่งแรก i โดยที่ x[i] != y[i]

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

อินพุต: s = "cbabc"
เอาต์พุต: "baabc"
คำอธิบาย: เราใช้การดำเนินการกับสตริงย่อยที่เริ่มต้นที่ดัชนี 0 และสิ้นสุดที่ดัชนี 1 รวม

สามารถพิสูจน์ได้ว่าสตริงผลลัพธ์มีขนาดเล็กที่สุดในพจนานุกรม

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

อินพุต: s = "acbbc"
เอาต์พุต: "abaab"
คำอธิบาย: เราใช้การดำเนินการกับสตริงย่อยที่เริ่มต้นที่ดัชนี 1 และสิ้นสุดที่ดัชนี 4 รวม
สามารถพิสูจน์ได้ว่าสตริงผลลัพธ์มีขนาดเล็กที่สุดในพจนานุกรม

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

อินพุต: s = "leetcode"
เอาต์พุต: "kddsbncd"
คำอธิบาย: เราใช้การดำเนินการกับสตริงทั้งหมด
สามารถพิสูจน์ได้ว่าสตริงผลลัพธ์มีขนาดเล็กที่สุดในพจนานุกรม

ข้อจำกัด:

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

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

เลือกสตริงย่อยที่ไม่ว่างเปล่าของ s อาจเป็นสตริงทั้งหมดจากนั้นแทนที่อักขระแต่ละตัวด้วยอักขระก่อนหน้าของตัวอักษรภาษาอังกฤษ ตัวอย่างเช่น 'b' ถูกแปลงเป็น 'a' และ 'a' ถูกแปลงเป็น 'z'

ส่งคืนสตริงที่เล็กที่สุดในการทำพจนานุกรมที่คุณสามารถรับได้หลังจากดำเนินการข้างต้นทันที
สตริงย่อยเป็นลำดับของอักขระที่ต่อเนื่องกันในสตริง
สตริง x มีขนาดเล็กกว่าสตริง y ตามลำดับตัวอักษรหากความยาวเท่ากัน โดยที่ x[i] ปรากฏก่อน y[i] ในลำดับตัวอักษรสำหรับตำแหน่งแรก i ที่ x[i] != y[i]

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

อินพุต: s = "cbabc"
เอาท์พุท: "baabc"
คำอธิบาย: เราใช้การดำเนินการกับสตริงย่อยที่เริ่มต้นที่ดัชนี 0 และสิ้นสุดที่ดัชนี 1 รวม
สามารถพิสูจน์ได้ว่าสตริงที่ได้นั้นมีขนาดเล็กที่สุด

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

อินพุต: s = "acbbc"
เอาท์พุท: "abaab"
คำอธิบาย: เราใช้การดำเนินการกับสตริงย่อยที่เริ่มต้นที่ดัชนี 1 และสิ้นสุดที่ดัชนี 4 รวม
สามารถพิสูจน์ได้ว่าสตริงที่ได้นั้นมีขนาดเล็กที่สุด

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

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

ข้อ จำกัด :

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

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

เลือกสตริงย่อยที่ไม่ว่างใดๆ ใน s อาจเป็นทั้งสตริง จากนั้นแทนที่อักขระแต่ละตัวด้วยอักขระก่อนหน้าของตัวอักษรภาษาอังกฤษ เช่น 'b' ถูกแปลงเป็น 'a', และ 'a' ถูกแปลงเป็น 'z'

ส่งคืนสตริงที่มีลำดับตามตัวอักษรเล็กที่สุดที่คุณสามารถได้รับหลังจากดำเนินการดังกล่าวครั้งเดียว
สตริงย่อยคือชุดตัวอักษรติดต่อกันในสตริง
สตริง x มีขนาดเล็กกว่าสตริง y ตามลำดับตัวอักษรหากความยาวเท่ากัน โดยที่ x[i] ปรากฏก่อน y[i] ในลำดับตัวอักษรสำหรับตำแหน่งแรก i ที่ x[i] != y[i]

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

Input: s = "cbabc"
Output: "baabc"
คำอธิบาย: เราใช้การดำเนินการในสตริงย่อยที่เริ่มต้นที่ดัชนี 0 และสิ้นสุดที่ดัชนี 1 รวมด้วย
สามารถพิสูจน์ได้ว่าสตริงที่ได้เป็นสตริงที่มีลำดับตามตัวอักษรเล็กที่สุด

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

Input: s = "acbbc"
Output: "abaab"
คำอธิบาย: เราใช้การดำเนินการในสตริงย่อยที่เริ่มต้นที่ดัชนี 1 และสิ้นสุดที่ดัชนี 4 รวมด้วย
สามารถพิสูจน์ได้ว่าสตริงที่ได้เป็นสตริงที่มีลำดับตามตัวอักษรเล็กที่สุด

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

Input: s = "leetcode"
Output: "kddsbncd"
คำอธิบาย: เราใช้การดำเนินการในทั้งสตริง
สามารถพิสูจน์ได้ว่าสตริงที่ได้เป็นสตริงที่มีลำดับตามตัวอักษรเล็กที่สุด

ข้อจำกัด:

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


คุณได้รับอาเรย์จำนวนเต็ม nums ที่มีดัชนีเริ่มต้นที่ 0 คู่ของดัชนี i, j โดยที่ 0 <= i < j < nums.length จะเรียกว่าสวยงาม หากหลักแรกของ nums[i] และหลักสุดท้ายของ nums[j] เป็นจำนวนเฉพาะร่วมกัน (coprime)
คืนค่าจำนวนคู่ที่สวยงามทั้งหมดใน nums
สองจำนวนเต็ม x และ y จะเรียกว่ามีจำนวนเฉพาะร่วมกัน หากไม่มีจำนวนเต็มที่มากกว่า 1 ที่หารทั้งสองจำนวนได้ กล่าวอีกนัยหนึ่ง x และ y จะมีจำนวนเฉพาะร่วมกัน หาก gcd(x, y) == 1 โดยที่ gcd(x, y) คือ หารร่วมมากที่สุดของ x และ y

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

Input: nums = [2,5,1,4]
Output: 5
คำอธิบาย: มีคู่ที่สวยงาม 5 คู่ใน nums:
เมื่อ i = 0 และ j = 1: หลักแรกของ nums[0] คือ 2 และหลักสุดท้ายของ nums[1] คือ 5 เราสามารถยืนยันได้ว่า 2 และ 5 เป็นจำนวนเฉพาะร่วมกัน เนื่องจาก gcd(2,5) == 1
เมื่อ i = 0 และ j = 2: หลักแรกของ nums[0] คือ 2 และหลักสุดท้ายของ nums[2] คือ 1 จริงๆ แล้ว gcd(2,1) == 1
เมื่อ i = 1 และ j = 2: หลักแรกของ nums[1] คือ 5 และหลักสุดท้ายของ nums[2] คือ 1 จริงๆ แล้ว gcd(5,1) == 1
เมื่อ i = 1 และ j = 3: หลักแรกของ nums[1] คือ 5 และหลักสุดท้ายของ nums[3] คือ 4 จริงๆ แล้ว gcd(5,4) == 1
เมื่อ i = 2 และ j = 3: หลักแรกของ nums[2] คือ 1 และหลักสุดท้ายของ nums[3] คือ 4 จริงๆ แล้ว gcd(1,4) == 1
ดังนั้น เราจึงคืนค่า 5

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

Input: nums = [11,21,12]
Output: 2
คำอธิบาย: มีคู่ที่สวยงาม 2 คู่:
เมื่อ i = 0 และ j = 1: หลักแรกของ nums[0] คือ 1 และหลักสุดท้ายของ nums[1] คือ 1 จริงๆ แล้ว gcd(1,1) == 1
เมื่อ i = 0 และ j = 2: หลักแรกของ nums[0] คือ 1 และหลักสุดท้ายของ nums[2] คือ 2 จริงๆ แล้ว gcd(1,2) == 1
ดังนั้น เราจึงคืนค่า 2

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ที่มีดัชนี 0 คู่ของดัชนี i, j โดยที่ 0 <= i < j < nums.length จะถูกเรียกว่า beautiful ถ้าหลักแรกของ nums[i] และหลักสุดท้ายของ nums[j] เป็นจำนวนเฉพาะร่วมกัน
ส่งคืนจำนวนคู่ beautiful ทั้งหมดใน nums
จำนวนเต็ม x และ y สองจำนวนเป็นจำนวนเฉพาะร่วมกัน หากไม่มีจำนวนเต็มที่มากกว่า 1 ที่สามารถหารจำนวนทั้งสองได้ กล่าวอีกนัยหนึ่ง x และ y เป็นจำนวนเฉพาะร่วมกัน ถ้า gcd(x, y) == 1 โดยที่ gcd(x, y) คือตัวหารร่วมมากของ x และ y
ตัวอย่างที่ 1:

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

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

อินพุต: nums = [11,21,12]
เอาต์พุต: 2
คำอธิบาย: มีคู่ที่สวยงาม 2 คู่:
เมื่อ i = 0 และ j = 1: หลักแรกของ nums[0] คือ 1 และหลักสุดท้ายของ nums[1] คือ 1 gcd(1,1) == 1
เมื่อ i = 0 และ j = 2: หลักแรกของ nums[0] คือ 1 และหลักสุดท้ายของ nums[2] คือ 2 แท้จริงแล้ว gcd(1,2) == 1
ดังนั้น เราจะคืนค่า 2

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็ม ที่มีดัชนีเริ่มต้นที่ 0 ดัชนีคู่หนึ่ง i, j โดยที่ 0 <= i <j <nums.length เรียกว่าสวยงามถ้าตัวเลขตัวแรกของ nums [i] และตัวเลขตัวสุดท้ายของ nums [j] เป็น coprime
ส่งคืนจำนวนคู่ที่สวยงามทั้งหมดใน nums
สองจำนวนเต็ม x และ y เป็น coprime หากไม่มีจำนวนเต็มมากกว่า 1 ที่แบ่งทั้งสอง กล่าวอีกนัยหนึ่ง x และ y เป็น coprime ถ้า gcd (x, y) == 1 โดยที่ gcd (x, y) เป็นตัวหารร่วมที่ยิ่งใหญ่ที่สุดของ x และ y

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

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

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

อินพุต: nums = [11,21,12]
เอาท์พุท: 2
คำอธิบาย: มี 2 คู่ที่สวยงาม:
เมื่อ i = 0 และ j = 1: ตัวเลขตัวแรกของ nums [0] คือ 1 และตัวเลขตัวสุดท้ายของ nums [1] คือ 1 แน่นอน gcd (1,1) == 1
เมื่อ i = 0 และ j = 2: ตัวเลขตัวแรกของ nums [0] คือ 1 และตัวเลขตัวสุดท้ายของ nums [2] คือ 2 แน่นอน gcd (1,2) == 1
ดังนั้นเรากลับ 2.

ข้อ จำกัด :

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


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

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

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

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

ข้อจำกัด:

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

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

ซับอาเรย์จะเรียกว่าเท่ากันหากองค์ประกอบทั้งหมดของมันเท่ากัน สังเกตว่าซับอาเรย์ว่างก็เป็นซับอาเรย์ที่เท่ากัน

ส่งคืนความยาวของซับอาเรย์ที่เท่ากันได้ยาวที่สุดหลังจากลบองค์ประกอบอย่างน้อย k ออกจาก nums

ซับอาเรย์คือ ลำดับขององค์ประกอบที่ติดกันซึ่งอาจว่างเปล่าภายในอาเรย์

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

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

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

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

ข้อจำกัด:

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

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

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

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

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

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

ข้อ จำกัด :

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


คุณจะได้รับเลขจำนวนเต็ม n ซึ่งแสดงถึงจำนวนเซิร์ฟเวอร์ทั้งหมดและอาร์เรย์ล็อกเลขจำนวนเต็ม 2 มิติที่มีดัชนี 0 โดยที่ logs[i] = [server_id, time] แสดงว่าเซิร์ฟเวอร์ที่มี id server_id ได้รับคำขอในเวลา time
คุณจะได้รับเลขจำนวนเต็ม x และคิวรีอาร์เรย์เลขจำนวนเต็มที่มีดัชนี 0 ด้วย
ส่งคืน arr อาร์เรย์เลขจำนวนเต็มที่มีดัชนี 0 ที่มีความยาว query.length โดยที่ arr[i] แสดงถึงจำนวนเซิร์ฟเวอร์ที่ไม่ได้รับคำขอใดๆ ในช่วงเวลา [queries[i] - x, queries[i]]
โปรดทราบว่าช่วงเวลาดังกล่าวรวมอยู่ด้วย

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

อินพุต: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
เอาต์พุต: [1,2]
คำอธิบาย:
สำหรับคิวรี[0]: เซิร์ฟเวอร์ที่มี  id 1 และ 2 จะได้รับคำขอภายในระยะเวลา [5, 10] ดังนั้น เฉพาะเซิร์ฟเวอร์ 3 เท่านั้นที่ได้รับคำขอเป็นศูนย์
สำหรับคิวรี[1]: เฉพาะเซิร์ฟเวอร์ที่มี ID 2 เท่านั้นที่ได้รับคำขอภายในระยะเวลา [6,11] ดังนั้น เซิร์ฟเวอร์ที่มี ID 1 และ 3 จึงเป็นเซิร์ฟเวอร์เพียงแห่งเดียวที่ไม่ได้รับคำขอใดๆ ในช่วงเวลาดังกล่าว

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

อินพุต: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
เอาต์พุต: [0,1]
คำอธิบาย:
สำหรับ query[0]: เซิร์ฟเวอร์ทั้งหมดจะได้รับคำขออย่างน้อยหนึ่งรายการในช่วงระยะเวลา [1, 3]
สำหรับ query[1]: เฉพาะเซิร์ฟเวอร์ที่มี ID 3 เท่านั้นที่จะได้รับคำขอในช่วงระยะเวลา [2,4]

ข้อจำกัด:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= query.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

คุณจะได้รับเลขจำนวนเต็ม n ซึ่งแสดงถึงจำนวนเซิร์ฟเวอร์ทั้งหมดและอาร์เรย์ล็อกเลขจำนวนเต็ม 2 มิติที่มีดัชนี 0 โดยที่ logs[i] = [server_id, time] แสดงว่าเซิร์ฟเวอร์ที่มี id server_id ได้รับคำขอในเวลา time
คุณจะได้รับเลขจำนวนเต็ม x และคิวรีอาร์เรย์เลขจำนวนเต็มที่มีดัชนี 0 ด้วย
ส่งคืน arr อาร์เรย์เลขจำนวนเต็มที่มีดัชนี 0 ที่มีความยาว query.length โดยที่ arr[i] แสดงถึงจำนวนเซิร์ฟเวอร์ที่ไม่ได้รับคำขอใดๆ ในช่วงเวลา [queries[i] - x, queries[i]]
โปรดทราบว่าช่วงเวลาดังกล่าวรวมอยู่ด้วย

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

อินพุต: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
เอาต์พุต: [1,2]
คำอธิบาย:
สำหรับคิวรี[0]: เซิร์ฟเวอร์ที่มี ID 1 และ 2 จะได้รับคำขอภายในระยะเวลา [5, 10] ดังนั้น เฉพาะเซิร์ฟเวอร์ 3 เท่านั้นที่ได้รับคำขอเป็นศูนย์
สำหรับคิวรี[1]: เฉพาะเซิร์ฟเวอร์ที่มี ID 2 เท่านั้นที่ได้รับคำขอภายในระยะเวลา [6,11] ดังนั้น เซิร์ฟเวอร์ที่มี ID 1 และ 3 จึงเป็นเซิร์ฟเวอร์เพียงแห่งเดียวที่ไม่ได้รับคำขอใดๆ ในช่วงเวลาดังกล่าว

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

อินพุต: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
เอาต์พุต: [0,1]
คำอธิบาย:
สำหรับ queries[0]: เซิร์ฟเวอร์ทั้งหมดจะได้รับคำขออย่างน้อยหนึ่งรายการในช่วงระยะเวลา [1, 3]
สำหรับ queries[1] เฉพาะเซิร์ฟเวอร์ที่มี id 3 เท่านั้นที่จะได้รับคำขอในช่วงระยะเวลา [2,4]

ข้อจำกัด:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

คุณได้รับจำนวนเต็ม n ซึ่งแสดงถึงจำนวนเซิร์ฟเวอร์ทั้งหมด และอาร์เรย์ 2 มิติที่มีดัชนีเริ่มต้นที่ 0 logs ซึ่ง logs[i] = [server_id, time] หมายถึงเซิร์ฟเวอร์ที่มี id เป็น server_id ได้รับคำขอในเวลา time นอกจากนี้คุณยังได้รับจำนวนเต็ม x และอาร์เรย์ที่มีดัชนีเริ่มต้นที่ 0 queries ให้คืนค่าอาร์เรย์ที่มีดัชนีเริ่มต้นที่ 0 arr ซึ่งมีความยาวเท่ากับ queries.length โดยที่ arr[i] แสดงถึงจำนวนเซิร์ฟเวอร์ที่ไม่ได้รับคำขอใด ๆ ในช่วงเวลาที่อยู่ระหว่าง [queries[i] - x, queries[i]]
โปรดทราบว่าช่วงเวลาเป็นการรวมอยู่ด้วย

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

Input: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Output: [1,2]
คำอธิบาย:
สำหรับคำถาม[0]: เซิร์ฟเวอร์ที่มีรหัส 1 และ 2 ได้รับคำขอในช่วงเวลา [5, 10] ดังนั้น เซิร์ฟเวอร์ 3 จึงได้รับคำขอเป็นศูนย์
สำหรับคำถาม[1]: เซิร์ฟเวอร์ที่มีรหัส 2 เท่านั้นที่ได้รับคำขอในช่วงเวลา [6, 11] ดังนั้น เซิร์ฟเวอร์ที่มีรหัส 1 และ 3 จึงเป็นเซิร์ฟเวอร์เพียงสองตัวที่ไม่ได้รับคำขอในช่วงเวลานั้น

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

Input: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Output: [0,1]
คำอธิบาย:
สำหรับคำถาม[0]: เซิร์ฟเวอร์ทั้งหมดได้รับคำขออย่างน้อยหนึ่งคำขอในช่วงเวลา [1, 3].
สำหรับคำถาม[1]: เซิร์ฟเวอร์ที่มีรหัส 3 เท่านั้นที่ไม่ได้รับคำขอในช่วงเวลา [2, 4].

ข้อจำกัด:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6


คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 nums ที่แสดงตำแหน่งเริ่มต้นของลูกแก้วบางลูก คุณยังได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 สองอาร์เรย์คือ moveFrom และ moveTo ที่มีความยาวเท่ากัน
ตลอดขั้นตอน moveFrom.length คุณจะเปลี่ยนตำแหน่งของลูกแก้ว ในขั้นตอนที่ i^ คุณจะย้ายลูกแก้วทั้งหมดที่ตำแหน่ง moveFrom[i] ไปยังตำแหน่ง moveTo[i]
หลังจากทำตามขั้นตอนทั้งหมดแล้ว ให้ส่งคืนรายการเรียงลำดับของตำแหน่งที่ถูกครอบครอง
หมายเหตุ:

เราจะเรียกตำแหน่งที่ถูกครอบครองหากมีลูกแก้วอย่างน้อยหนึ่งลูกในตำแหน่งนั้น
อาจมีหลายลูกในตำแหน่งเดียว

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

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

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

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
กรณีทดสอบจะสร้างขึ้นเพื่อให้มีลูกแก้วอย่างน้อยหนึ่งลูกใน moveFrom[i] ในขณะที่เราต้องการใช้การเคลื่อนที่ครั้งที่ i

คุณได้รับอาเรย์จำนวนเต็มที่มีดัชนี0ของ `nums` ซึ่งแสดงถึงตำแหน่งเริ่มต้นของลูกหินบางลูก นอกจากนี้ยังได้รับอาเรย์จำนวนเต็ม `moveFrom` และ `moveTo` ซึ่งดัชนีสองอาเรย์ซึ่งมีความยาวเท่ากัน
ตลอดขั้นตอน `moveFrom.length` คุณจะเปลี่ยนตำแหน่งของลูกหิน ในขั้นตอนที่ i คุณจะย้ายลูกหินทั้งหมดที่ตำแหน่ง `moveFrom[i]` ไปยังตำแหน่ง `moveTo[i]`
หลังจากทำทุกขั้นตอนเสร็จสิ้น ให้คืนรายการตำแหน่งที่ถูกครอบครองซึ่งถูกเรียงลำดับ
หมายเหตุ:

เราเรียกตำแหน่งว่าถูกครอบครองหากมีลูกหินอย่างน้อยหนึ่งลูกในตำแหน่งนั้น
อาจมีลูกหินหลายลูกในตำแหน่งเดียวกัน

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

Input: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Output: [5,6,8,9]
คำอธิบาย: เริ่มต้น ลูกหินจะอยู่ที่ตำแหน่ง 1,6,7,8
ในขั้นตอนที่ i = 0 เราจะย้ายลูกหินที่ตำแหน่ง 1 ไปยังตำแหน่ง 2 จากนั้นตำแหน่ง 2,6,7,8 จะถูกครอบครอง
ในขั้นตอนที่ i = 1 เราจะย้ายลูกหินที่ตำแหน่ง 7 ไปยังตำแหน่ง 9 จากนั้นตำแหน่ง 2,6,8,9 จะถูกครอบครอง
ในขั้นตอนที่ i = 2 เราจะย้ายลูกหินที่ตำแหน่ง 2 ไปยังตำแหน่ง 5 จากนั้นตำแหน่ง 5,6,8,9 จะถูกครอบครอง
สุดท้ายตำแหน่งที่มีลูกหินอย่างน้อยหนึ่งลูกคือ [5,6,8,9]

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

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

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
กรณีทดสอบถูกสร้างขึ้นเพื่อให้แน่ใจว่ามีลูกหินอย่างน้อยหนึ่งลูกใน `moveFrom[i]` ในขณะที่เราต้องการดำเนินขั้นตอนที่ i

คุณได้รับอาเรย์จำนวนเต็ม nums ที่มีดัชนีเริ่มต้นที่ 0ซึ่งแทนตำแหน่งเริ่มต้นของลูกแก้วบางลูก นอกจากนี้ยังได้รับอาเรย์จำนวนเต็ม moveFrom และ moveTo ที่มีดัชนีเริ่มต้นที่ 0สองอาเรย์ซึ่งมีความยาวเท่ากัน
ตลอดขั้นตอน moveFrom.length คุณจะเปลี่ยนตำแหน่งของลูกแก้วในขั้นตอนที่ i^th คุณจะย้ายลูกแก้วทั้งหมดที่ตำแหน่ง moveFrom[i] ไปยังตำแหน่ง moveTo[i]
หลังจากทำทุกขั้นตอนเสร็จสิ้น ให้คืนรายการตำแหน่งที่ถูกครอบครองซึ่งถูกเรียงลำดับ
หมายเหตุ:

เราเรียกตำแหน่งว่าถูกครอบครองหากมีลูกแก้วอย่างน้อยหนึ่งลูกในตำแหน่งนั้น
อาจมีลูกแก้วหลายลูกในตำแหน่งเดียวกัน

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

Input: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Output: [5,6,8,9]
คำอธิบาย: เริ่มต้น ลูกแก้วจะอยู่ที่ตำแหน่ง 1,6,7,8
ในขั้นตอนที่ i = 0 เราจะย้ายลูกแก้วที่ตำแหน่ง 1 ไปยังตำแหน่ง 2 จากนั้นตำแหน่ง 2,6,7,8 จะถูกครอบครอง
ในขั้นตอนที่ i = 1 เราจะย้ายลูกแก้วที่ตำแหน่ง 7 ไปยังตำแหน่ง 9 จากนั้นตำแหน่ง 2,6,8,9 จะถูกครอบครอง
ในขั้นตอนที่ i = 2 เราจะย้ายลูกแก้วที่ตำแหน่ง 2 ไปยังตำแหน่ง 5 จากนั้นตำแหน่ง 5,6,8,9 จะถูกครอบครอง
สุดท้ายตำแหน่งที่มีลูกแก้วอย่างน้อยหนึ่งลูกคือ [5,6,8,9]

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

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

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
กรณีทดสอบถูกสร้างขึ้นเพื่อให้แน่ใจว่ามีลูกแก้วอย่างน้อยหนึ่งลูกใน moveFrom[i] ในขณะที่เราต้องการย้ายขั้นตอนที่ i^th


คุณได้รับจำนวนเต็มสองจำนวนคือ num1 และ num2
ในการดำเนินการครั้งหนึ่ง คุณสามารถเลือกจำนวนเต็ม i ในช่วง [0, 60] และลบ 2^i + num2 จาก num1
ส่งกลับจำนวนเต็มที่แสดงถึงจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อให้ num1 เท่ากับ 0
หากไม่สามารถทำให้ num1 เท่ากับ 0 ได้ ให้ส่งคืน -1

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

อินพุต: num1 = 3, num2 = -2
เอาต์พุต: 3
คำอธิบาย: เราสามารถทำให้ 3 เท่ากับ 0 ได้ด้วยการดำเนินการดังต่อไปนี้:
- เราเลือก i = 2 และลบ 2^2 + (-2) จาก 3, 3 - (4 + (-2)) = 1
- เราเลือก i = 2 และลบ 2^2 + (-2) จาก 1, 1 - (4 + (-2)) = -1
- เราเลือก i = 0 และลบ 2^0 + (-2) จาก -1, (-1) - (1 + (-2)) = 0
สามารถพิสูจน์ได้ว่า 3 คือจำนวนการดำเนินการขั้นต่ำที่เราจำเป็นต้องดำเนินการ

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

อินพุต: num1 = 5, num2 = 7
เอาต์พุต: -1
คำอธิบาย: สามารถพิสูจน์ได้ว่าเป็นไปไม่ได้ที่จะทำให้ 5 เท่ากับ 0 ด้วยการดำเนินการที่กำหนด

เงื่อนไข:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

คุณได้รับจำนวนเต็มสองจำนวนคือ num1 และ num2
ในการดำเนินการครั้งหนึ่ง คุณสามารถเลือกจำนวนเต็ม i ในช่วง [0, 60] และลบ 2^i + num2 จาก num1
ส่งกลับจำนวนเต็มที่แสดงถึงจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อให้ num1 เท่ากับ 0
หากไม่สามารถทำให้ num1 เท่ากับ 0 ได้ ให้ส่งกลับ -1

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

Input: num1 = 3, num2 = -2
Output: 3
คำอธิบาย: เราสามารถทำให้ 3 เท่ากับ 0 ด้วยการดำเนินการดังต่อไปนี้:
- เราเลือก i = 2 และลบ 2^2 + (-2) จาก 3, 3 - (4 + (-2)) = 1
- เราเลือก i = 2 และลบ 2^2 + (-2) จาก 1, 1 - (4 + (-2)) = -1
- เราเลือก i = 0 และลบ 2^0 + (-2) จาก -1, (-1) - (1 + (-2)) = 0
สามารถพิสูจน์ได้ว่า 3 คือตัวเลขขั้นตอนขั้นต่ำที่เราจำเป็นต้องทำ

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

Input: num1 = 5, num2 = 7
Output: -1
คำอธิบาย: สามารถพิสูจน์ได้ว่าเป็นไปไม่ได้ที่จะทำให้ 5 เท่ากับ 0 ด้วยการดำเนินการที่ให้มา

Constraints:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

คุณจะได้รับสองจำนวนเต็ม num1 และ num2
ในการดำเนินการครั้งเดียวคุณสามารถเลือกจำนวนเต็ม i ในช่วง [0, 60] และลบ 2^i + num2 จาก num1
ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนขั้นต่ำของการดำเนินการที่จำเป็นเพื่อทำให้ num1 เท่ากับ 0
หากเป็นไปไม่ได้ที่จะทำให้ num1 เท่ากับ 0 ให้กลับมา -1

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

อินพุต: num1 = 3, num2 = -2
เอาท์พุท: 3
คำอธิบาย: เราสามารถทำให้ 3 เท่ากับ 0 ด้วยการดำเนินการต่อไปนี้:
- เราเลือก i = 2 และ ลบ 2^2 + (-2) จาก 3, 3- (4 + (-2)) = 1
-เราเลือก i = 2 และ ลบ 2^2 + (-2) จาก 1, 1 -(4 + (-2)) = -1
-เราเลือก i = 0 และ ลบ 2^0 + (-2) จาก -1, (-1)-(1 + (-2)) = 0
สามารถพิสูจน์ได้ว่า 3 คือจำนวนขั้นต่ำของการดำเนินการที่เราต้องดำเนินการ

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

อินพุต: num1 = 5, num2 = 7
เอาท์พุท: -1
คำอธิบาย: สามารถพิสูจน์ได้ว่าเป็นไปไม่ได้ที่จะทำให้ 5 เท่ากับ 0 กับการดำเนินการที่กำหนด

ข้อจำกัด :

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9


คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 จำนวนสองชุดคือ nums1 และ nums2 โดยแต่ละชุดมีความยาว n และคิวรีอาร์เรย์ 2 มิติที่มีดัชนี 1 โดยที่ query[i] = [x_i, y_i]
สำหรับคิวรีที่ i ให้หาค่าสูงสุดของ nums1[j] + nums2[j] จากดัชนี j ทั้งหมด (0 <= j < n) โดยที่ nums1[j] >= x_i และ nums2[j] >= y_i หรือ -1 หากไม่มีดัชนี j ที่ตอบสนองเงื่อนไข
ส่งคืนคำตอบของอาร์เรย์ โดยที่ answer[i] คือคำตอบของคิวรีที่ i
ตัวอย่างที่ 1:

อินพุต: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
เอาต์พุต: [6,10,7]
คำอธิบาย:
สำหรับคิวรีแรก x_i = 4 และ y_i = 1 เราสามารถเลือกดัชนี j = 0 ได้ เนื่องจาก nums1[j] >= 4 และ nums2[j] >= 1 ผลรวม nums1[j] + nums2[j] คือ 6 และเราสามารถแสดงให้เห็นว่า 6 คือค่าสูงสุดที่เราจะได้รับ

สำหรับแบบสอบถามที่ 2 x_i = 1 และ y_i = 3 เราสามารถเลือกดัชนี j = 2 เนื่องจาก nums1[j] >= 1 และ nums2[j] >= 3 ผลรวม nums1[j] + nums2[j] คือ 10 และเราสามารถแสดงให้เห็นว่า 10 คือค่าสูงสุดที่เราหาได้

สำหรับแบบสอบถามที่ 3 x_i = 2 และ y_i = 5 เราสามารถเลือกดัชนี j = 3 เนื่องจาก nums1[j] >= 2 และ nums2[j] >= 5 ผลรวม nums1[j] + nums2[j] คือ 7 และเราสามารถแสดงให้เห็นว่า 7 คือค่าสูงสุดที่เราหาได้

ดังนั้น เราจึงส่งคืน [6,10,7]

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

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

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

อินพุต: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
เอาต์พุต: [-1]
คำอธิบาย: มีคิวรีหนึ่งรายการในตัวอย่างนี้ โดย x_i = 3 และ y_i = 3 สำหรับดัชนี j ทุกรายการ nums1[j] < x_i หรือ nums2[j] < y_i ดังนั้นจึงไม่มีคำตอบ

ข้อจำกัด:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= query.length <= 10^5
queries[i].length == 2
x_i == query[i][1]
y_i == query[i][2]
1 <= x_i, y_i <= 10^9

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

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

Input:

nums1 = [4,3,1,2]
nums2 = [2,4,9,5]
queries = [[4,1],[1,3],[2,5]]

Output:

[6,10,7]

Explanation:
	•	สำหรับคำถามลำดับที่ 1 ￼ และ ￼ สามารถเลือกดัชนี ￼ ได้ เนื่องจาก ￼ และ ￼ ดังนั้น ￼ และแสดงได้ว่า 6 เป็นค่ามากที่สุดที่สามารถหาได้
	•	สำหรับคำถามลำดับที่ 2 ￼ และ ￼ สามารถเลือกดัชนี ￼ ได้ เนื่องจาก ￼ และ ￼ ดังนั้น ￼ และแสดงได้ว่า 10 เป็นค่ามากที่สุดที่สามารถหาได้
	•	สำหรับคำถามลำดับที่ 3 ￼ และ ￼ สามารถเลือกดัชนี ￼ ได้ เนื่องจาก ￼ และ ￼ ดังนั้น ￼

ดังนั้น คืนค่า ￼

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

Input:

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

Output:

[9,9,9]

Explanation:
สำหรับตัวอย่างนี้ สามารถใช้ดัชนี ￼ สำหรับทุกคำถาม เนื่องจากตรงตามเงื่อนไขทุกข้อ

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

Input:

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

Output:

[-1]

Explanation:
สำหรับคำถามนี้ ￼ และ ￼
สำหรับดัชนี ￼ ทุกค่า ￼ หรือ ￼
ดังนั้น ไม่มีคำตอบที่เป็นไปได้

ข้อจำกัด:
	nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1 [i], nums2 [i] <= 10^9
1 <= queries.length  <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9￼

คุณจะได้รับอาร์เรย์จำนวนเต็ม 0 ดัชนีสองตัว nums1 และ nums2 ความยาวแต่ละอันและแบบสอบถามอาร์เรย์ 2D ที่มีดัชนี 1 รายการที่สอบถาม [i] = [x_i, y_i].
สำหรับการสืบค้นที่ i ให้ค้นหาค่าสูงสุดของ nums1 [j] + nums2 [j] ในดัชนีทั้งหมด j (0 <= j <n) โดยที่ nums1 [j]> = x_i และ nums2 [j]> = y_i หรือ -1 ถ้าไม่มี j ตอบสนองข้อ จำกัด
ส่งคืนคำตอบอาร์เรย์ที่คำตอบ [i] คือคำตอบของคำถาม i^th

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

อินพุต: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
เอาท์พุท: [6,10,7]
คำอธิบาย:
สำหรับการสืบค้นที่ 1 x_i = 4 และ y_i = 1 เราสามารถเลือกดัชนี j = 0 เนื่องจาก nums1 [j]> = 4 และ nums2 [j]> = 1. ผลรวม nums1 [j] + nums2 [j] คือ 6 และเราสามารถแสดงให้เห็นว่า 6 คือค่าสูงสุดที่เราจะได้รับ

สำหรับการสืบค้นที่ 2 x_i = 1 และ y_i = 3 เราสามารถเลือกดัชนี j = 2 เนื่องจาก nums1 [j]> = 1 และ nums2 [j]> = 3. sum nums1 [j] + nums2 [j] คือ 10, และเราสามารถแสดงให้เห็นว่า 10 คือค่าสูงสุดที่เราจะได้รับ

สำหรับการสืบค้นครั้งที่ 3 x_i = 2 และ y_i = 5 เราสามารถเลือกดัชนี j = 3 เนื่องจาก nums1 [j]> = 2 และ nums2 [j]> = 5. sum nums1 [j] + nums2 [j] คือ 7, และเราสามารถแสดงให้เห็นว่า 7 คือค่าสูงสุดที่เราจะได้รับ

ดังนั้นเราจึงกลับมา [6,10,7]

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

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

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

อินพุต: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
เอาท์พุท: [-1]
คำอธิบาย: มีการสืบค้นหนึ่งในตัวอย่างนี้ด้วย x_i = 3 และ y_i = 3 สำหรับทุกดัชนี j, nums1 [j] <x_i หรือ nums2 [j] <y_i ดังนั้นจึงไม่มีทางออก

ข้อ จำกัด :

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][0]
y_i == queries[i][1].
1 <= x_i, y_i <= 10^9


คุณได้รับอาร์เรย์จำนวนเต็ม nums ที่มีความยาว n โดยมีการจัดอันดับจาก 1
องค์ประกอบ nums[i] ของ nums จะถูกเรียกว่าเป็นพิเศษถ้า i แบ่ง n ได้ กล่าวคือ n % i == 0
ให้คืนค่าผลรวมของกำลังสองขององค์ประกอบพิเศษทั้งหมดใน nums

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

Input: nums = [1,2,3,4]
Output: 21
คำอธิบาย:มีองค์ประกอบพิเศษใน nums ทั้งหมด 3 ตัว: nums[1] เนื่องจาก 1 หาร 4 ลงตัว, nums[2] เนื่องจาก 2 หาร 4 ลงตัว, และ nums[4] เนื่องจาก 4 หาร 4 ลงตัว
ดังนั้น ผลรวมของกำลังสองขององค์ประกอบพิเศษทั้งหมดใน nums คือ nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

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

Input: nums = [2,7,1,19,18,3]
Output: 63
คำอธิบาย: มีองค์ประกอบพิเศษใน nums ทั้งหมด 4 ตัว: nums[1] เนื่องจาก 1 หาร 6 ลงตัว, nums[2] เนื่องจาก 2 หาร 6 ลงตัว, nums[3] เนื่องจาก 3 หาร 6 ลงตัว, และ nums[6] เนื่องจาก 6 หาร 6 ลงตัว
ดังนั้น ผลรวมของกำลังสองขององค์ประกอบพิเศษทั้งหมดใน nums คือ nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

ข้อจำกัด:

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

คุณได้รับอาเรย์จำนวนเต็มที่มีดัชนีเริ่มต้นจาก 1 ชื่อว่า nums ซึ่งมีความยาว n
ธาตุ nums[i] ของ nums จะถูกเรียกว่าพิเศษถ้า i หาร n ลงตัว, i.e. n % i == 0
จงหาผลรวมของกำลังสองของธาตุพิเศษทั้งหมดของ nums

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

Input: nums = [1,2,3,4]
Output: 21
คำอธิบาย: มีธาตุพิเศษใน nums 3 ธาตุ คือ nums[1] เนื่องจาก 1 หาร 4 ลงตัว, nums[2] เนื่องจาก 2 หาร 4 ลงตัว, และ nums[4] เนื่องจาก 4 หาร 4 ลงตัว
ดังนั้นผลรวมของกำลังสองของธาตุพิเศษทั้งหมดของ nums คือ nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21

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

Input: nums = [2,7,1,19,18,3]
Output: 63
คำอธิบาย: มีธาตุพิเศษใน nums 4 ธาตุ คือ nums[1] เนื่องจาก 1 หาร 6 ลงตัว, nums[2] เนื่องจาก 2 หาร 6 ลงตัว, nums[3] เนื่องจาก 3 หาร 6 ลงตัว, และ nums[6] เนื่องจาก 6 หาร 6 ลงตัว
ดังนั้นผลรวมของกำลังสองของธาตุพิเศษทั้งหมดของ nums คือ nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63

เงื่อนไข:

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

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 1 จำนวน nums ที่มีความยาว n
องค์ประกอบ nums[i] ของ nums จะถูกเรียกว่าพิเศษถ้า i หาร n นั่นคือ n % i == 0
ส่งคืนผลรวมของกำลังสองขององค์ประกอบพิเศษทั้งหมดของ nums

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

อินพุต: nums = [1,2,3,4]
เอาต์พุต: 21
คำอธิบาย: ใน nums มีองค์ประกอบพิเศษ 3 องค์ประกอบพอดี: nums[1] เนื่องจาก 1 หาร 4 ได้, nums[2] เนื่องจาก 2 หาร 4 ได้ และ nums[4] เนื่องจาก 4 หาร 4 ได้
ดังนั้น ผลรวมของกำลังสองขององค์ประกอบพิเศษทั้งหมดของ nums คือ nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21

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

อินพุต: nums = [2,7,1,19,18,3]
เอาต์พุต: 63
คำอธิบาย: ใน nums มีองค์ประกอบพิเศษ 4 องค์ประกอบพอดี: nums[1] เนื่องจาก 1 หาร 6, nums[2] เนื่องจาก 2 หาร 6 ได้, nums[3] เนื่องจาก 3 หาร 6 ได้ และ nums[6] เนื่องจาก 6 หาร 6 ได้
ดังนั้น ผลรวมของกำลังสองขององค์ประกอบพิเศษทั้งหมดของ nums คือ nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

ข้อจำกัด:

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


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

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

ค่าของพาร์ติชันคือ |max(nums1) - min(nums2)|
โดยที่ max(nums1) หมายถึงองค์ประกอบสูงสุดของอาร์เรย์ nums1 และ min(nums2) หมายถึงองค์ประกอบต่ำสุดของอาร์เรย์ nums2
ส่งกลับค่าของพาร์ติชันดังกล่าวเป็นจำนวนเต็ม
ตัวอย่างที่ 1:

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

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

อินพุต: nums = [100,1,10]
เอาต์พุต: 9
คำอธิบาย: เราสามารถแบ่งอาร์เรย์ nums เป็น nums1 = [10] และ nums2 = [100,1] ได้
- องค์ประกอบสูงสุดของอาร์เรย์ nums1 เท่ากับ 10
- องค์ประกอบต่ำสุดของอาร์เรย์ nums2 เท่ากับ 1
ค่าของพาร์ติชันคือ |10 - 1| = 9
สามารถพิสูจน์ได้ว่า 9 เป็นค่าต่ำสุดจากพาร์ติชันทั้งหมด
ข้อจำกัด:

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

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

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

ค่าของพาร์ติชันคือ |max(nums1) - min(nums2)|
ที่นี่สูงสุด (nums1) หมายถึงองค์ประกอบสูงสุดของอาร์เรย์ nums1 และขั้นต่ำ (nums2) หมายถึงองค์ประกอบขั้นต่ำของอาร์เรย์ nums2
ส่งคืนค่าของพาร์ติชัน

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

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

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

อินพุต: nums = [100,1,10]
เอาท์พุท: 9
คำอธิบาย: เราสามารถแบ่งพาร์ติชันอาร์เรย์ nums ลงใน nums1 = [10] และ nums2 = [100,1]
- องค์ประกอบสูงสุดของอาร์เรย์ nums1 เท่ากับ 10
- องค์ประกอบขั้นต่ำของอาร์เรย์ nums2 เท่ากับ 1
ค่าของพาร์ติชันคือ | 10 - 1 | = 9.
สามารถพิสูจน์ได้ว่า 9 เป็นค่าต่ำสุดจากพาร์ติชันทั้งหมด

ข้อ จำกัด :

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

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

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

ค่าของพาร์ติชันคือ | สูงสุด (nums1) - ขั้นต่ำ (nums2) |
ที่นี่สูงสุด (nums1) หมายถึงองค์ประกอบสูงสุดของอาร์เรย์ nums1 และขั้นต่ำ (nums2) หมายถึงองค์ประกอบขั้นต่ำของอาร์เรย์ nums2
ส่งคืนจำนวนเต็มที่แสดงถึงค่าของพาร์ติชันดังกล่าว

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

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

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

อินพุต: nums = [100,1,10]
เอาท์พุท: 9
คำอธิบาย: เราสามารถแบ่งพาร์ติชันอาร์เรย์ nums ลงใน nums1 = [10] และ nums2 = [100,1]
- องค์ประกอบสูงสุดของอาร์เรย์ nums1 เท่ากับ 10
- องค์ประกอบขั้นต่ำของอาร์เรย์ nums2 เท่ากับ 1
ค่าของพาร์ติชันคือ | 10 - 1 | = 9.
สามารถพิสูจน์ได้ว่า 9 เป็นค่าต่ำสุดจากพาร์ติชันทั้งหมด

ข้อ จำกัด :

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


ให้คุณอาเรย์ที่มีดัชนีเริ่มต้นจาก 0 ชื่อว่า words ซึ่งประกอบด้วยสตริงที่แตกต่างกัน
สตริง words[i] สามารถจับคู่กับสตริง words[j] ได้ถ้า:

สตริง words[i] เท่ากับสตริงที่กลับด้านของ words[j]
0 <= i < j < words.length

ให้คืนค่าจำนวนคู่สูงสุดที่สามารถสร้างได้จากอาเรย์ words
โดยที่แต่ละสตริงสามารถอยู่ในได้ไม่เกินหนึ่งคู่

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

Input: words = ["cd","ac","dc","ca","zz"]
Output: 2
คำอธิบาย: ในตัวอย่างนี้ เราสามารถสร้างคู่ของสตริงได้ 2 คู่ดังนี้:
- เราจับคู่สตริงที่ดัชนี 0 กับสตริงที่ดัชนี 2 เพราะสตริงที่กลับด้านของ words[0] คือ "dc" และเท่ากับ words[2]
- เราจับคู่สตริงที่ดัชนี 1 กับสตริงที่ดัชนี 3 เพราะสตริงที่กลับด้านของ words[1] คือ "ca" และเท่ากับ words[3]
สามารถพิสูจน์ได้ว่า 2 คือจำนวนคู่สูงสุดที่สามารถสร้างได้

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

Input: words = ["ab","ba","cc"]
Output: 1
คำอธิบาย: ในตัวอย่างนี้ เราสามารถสร้างคู่ของสตริงได้ 1 คู่ดังนี้:
- เราจับคู่สตริงที่ดัชนี 0 กับสตริงที่ดัชนี 1 เพราะสตริงที่กลับด้านของ words[1] คือ "ab" และเท่ากับ words[0]
สามารถพิสูจน์ได้ว่า 1 คือจำนวนคู่สูงสุดที่สามารถสร้างได้

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

Input: words = ["aa","ab"]
Output: 0
คำอธิบาย: ในตัวอย่างนี้ เราไม่สามารถสร้างคู่ของสตริงใดๆ ได้

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์คำที่มีดัชนี 0 ซึ่งประกอบด้วยสตริงที่แตกต่างกัน
สตริง words[i] สามารถจับคู่กับสตริง words[j] ได้หาก:

สตริง words[i] มีค่าเท่ากับสตริงที่กลับด้านของ words[j]
0 <= i < j < words.length

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

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

อินพุต: words = ["cd","ac","dc","ca","zz"]
เอาต์พุต: 2
คำอธิบาย: ในตัวอย่างนี้ เราสามารถสร้างคู่สตริง 2 คู่ได้ดังนี้:
- เราจับคู่สตริงที่ 0 กับสตริงที่ 2 เนื่องจากสตริงที่กลับด้านของ word[0] คือ "dc" และมีค่าเท่ากับ words[2]
 - เราจับคู่สตริงที่ 1 กับสตริงที่ 3 เนื่องจากสตริงที่กลับด้านของ word[1] คือ "ca" และเท่ากับ words[3]
สามารถพิสูจน์ได้ว่า 2 คือจำนวนคู่สูงสุดที่สามารถสร้างได้
ตัวอย่างที่ 2:

อินพุต: words = ["ab","ba","cc"]
เอาต์พุต: 1
คำอธิบาย: ในตัวอย่างนี้ เราสามารถสร้างคู่สตริง 1 คู่ได้ดังนี้:
- เราจับคู่สตริงที่ 0 กับสตริงที่ 1 เนื่องจากสตริงที่กลับด้านของ word[1] คือ "ab" และเท่ากับ words[0]
สามารถพิสูจน์ได้ว่า 1 คือจำนวนคู่สูงสุดที่สามารถสร้างได้

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

อินพุต: words = ["aa","ab"]
เอาต์พุต: 0
คำอธิบาย: ในตัวอย่างนี้ เราไม่สามารถสร้างคู่สตริงใดๆ ได้

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ของสตริง 0-ดัชนีที่ประกอบด้วยสตริงที่แตกต่างกัน
สตริง [i] สามารถจับคู่กับสตริงสตริง [j] ถ้า:

สตริง [i] เท่ากับสตริงที่กลับด้านของสตริง [j]
0 <= i <j <words.length

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

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

อินพุต: words = ["cd", "ac", "dc", "ca", "zz"]
เอาท์พุท: 2
สตริงอธิบาย: ในตัวอย่างนี้เราสามารถสร้างสาย 2 คู่ด้วยวิธีต่อไปนี้:
- เราจับคู่สตริง 0^th กับสตริง 2^nd เป็นสตริงที่กลับด้านของสตริง [0] คือ "dc" และเท่ากับสตริง [2]
- เราจับคู่สตริง 1^st กับสตริง 3^rd เป็นสตริงย้อนกลับของสตริง [1] คือ "ca" และเท่ากับสตริง [3]
สามารถพิสูจน์ได้ว่า 2 คือจำนวนคู่สูงสุดที่สามารถเกิดขึ้นได้
ตัวอย่างที่ 2:

อินพุต: words = ["ab", "ba", "cc"]
เอาท์พุท: 1
สตริงอธิบาย: ในตัวอย่างนี้เราสามารถสร้างสาย 1 คู่ด้วยวิธีต่อไปนี้:
- เราจับคู่สตริง 0^th กับสตริง 1^st เป็นสตริงที่กลับด้านของสตริง [1] คือ "ab" และเท่ากับสตริง [0]
สามารถพิสูจน์ได้ว่า 1 คือจำนวนคู่สูงสุดที่สามารถเกิดขึ้นได้

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

อินพุต: words = ["aa", "ab"]
เอาท์พุท: 0
สตริงอธิบาย: ในตัวอย่างนี้เราไม่สามารถสร้างสายคู่ใด ๆ ได้

ข้อ จำกัด :

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


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

สำหรับทุกดัชนี 0 <= i < n - 1 จะต้องเป็นจริงว่า nums[i] % nums[i+1] == 0 หรือ nums[i+1] % nums[i] == 0

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

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

Input: nums = [2,3,6]
Output: 2
คำอธิบาย: [3,6,2] และ [2,6,3] เป็นสองการจัดเรียงพิเศษของ nums.

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

Input: nums = [1,4,3]
Output: 2
คำอธิบาย: [3,1,4] และ [4,1,3] เป็นการจัดเรียงพิเศษสองแบบของ nums.

ข้อจำกัด:

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

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

สำหรับดัชนีทั้งหมด 0 <= i < n - 1 nums[i] % nums[i+1] == 0 หรือ nums[i+1] % nums[i] == 0

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

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

อินพุต: nums = [2,3,6]
เอาต์พุต: 2
คำอธิบาย: [3,6,2] และ [2,6,3] คือการเรียงสับเปลี่ยนพิเศษสองแบบของ nums

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

อินพุต: nums = [1,4,3]
เอาต์พุต: 2
คำอธิบาย: [3,1,4] และ [4,1,3] คือการเรียงสับเปลี่ยนพิเศษสองแบบของ nums

ข้อจำกัด:

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

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

สำหรับดัชนีทั้งหมด 0 <= i <n - 1 ทั้ง nums [i] % nums [i+1] == 0 หรือ nums [i+1] % nums [i] == 0

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

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

อินพุต: nums = [2,3,6]
เอาท์พุท: 2
คำอธิบาย: [3,6,2] และ [2,6,3] เป็นสองการเรียงสับเปลี่ยนพิเศษของ NUMS

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

อินพุต: nums = [1,4,3]
เอาท์พุท: 2
คำอธิบาย: [3,1,4] และ [4,1,3] เป็นสองการเรียงสับเปลี่ยนพิเศษของ NUMS

ข้อ จำกัด :

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


หมายเลขความไม่สมดุลของอาร์เรย์จำนวนเต็ม arr ที่มีดัชนี 0 ที่มีความยาว n ถูกกำหนดให้เป็นจำนวนดัชนีใน sarr = sorted(arr) โดยที่:

0 <= i < n - 1 และ
sarr[i+1] - sarr[i] > 1

ในที่นี้ sorted(arr) คือฟังก์ชันที่ส่งคืน arr เวอร์ชันที่เรียงลำดับแล้ว
เมื่อกำหนดจำนวนอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ให้ส่งคืนผลรวมของหมายเลขความไม่สมดุลของอาร์เรย์ย่อยทั้งหมด
อาร์เรย์ย่อยคือลำดับขององค์ประกอบที่ไม่ว่างและต่อเนื่องกันภายในอาร์เรย์

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

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

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

อินพุต: nums = [1,3,3,3,5]
เอาต์พุต: 8
คำอธิบาย: มี 7 ซับอาร์เรย์ที่มีหมายเลขความไม่สมดุลที่ไม่เป็นศูนย์:
- ซับอาร์เรย์ [1, 3] ที่มีหมายเลขความไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [1, 3, 3] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [1, 3, 3, 3] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [1, 3, 3, 3, 5] โดยมีค่าไม่สมดุลเท่ากับ 2
- ซับอาร์เรย์ [3, 3, 3, 5] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [3, 3, 5] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [3, 5] โดยมีค่าไม่สมดุลเท่ากับ 1
ค่าไม่สมดุลของซับอาร์เรย์อื่นๆ ทั้งหมดคือ 0 ดังนั้น ผลรวมของค่าไม่สมดุลของซับอาร์เรย์ทั้งหมดของ nums คือ 8

ข้อจำกัด:

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

จํานวนความไม่สมดุลของอาร์เรย์จํานวนเต็มที่มีดัชนี 0 arr ที่มีความยาว n ถูกกําหนดให้เป็นจํานวนดัชนีใน sarr = เรียง ลำดับ(arr) เช่น:

0 <= i < n - 1 และ
sarr[i+1] - sarr[i] > 1

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

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

อินพุต: nums = [2,3,1,4]
เอาท์พุต: 3
คําอธิบาย: มีอาร์เรย์ย่อย 3 ตัวที่มีตัวเลขไม่สมดุลที่ไม่ใช่ศูนย์:
- ซับอาร์เรย์ [3, 1] ที่มีจํานวนความไม่สมดุล 1
- ซับอาร์เรย์ [3, 1, 4] ที่มีจํานวนความไม่สมดุล 1
- ซับอาร์เรย์ [1, 4] ที่มีจํานวนความไม่สมดุล 1
จํานวนความไม่สมดุลของอาร์เรย์ย่อยอื่น ๆ ทั้งหมดคือ 0 ดังนั้นผลรวมของจํานวนความไม่สมดุลของอาร์เรย์ย่อยทั้งหมดของ nums คือ 3

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

อินพุต: nums = [1,3,3,3,5]
เอาท์พุต: 8
คําอธิบาย: มีอาร์เรย์ย่อย 7 อาร์เรย์ที่มีตัวเลขไม่สมดุลที่ไม่ใช่ศูนย์:
- ซับอาร์เรย์ [1, 3] ที่มีจํานวนความไม่สมดุล 1
- อาร์เรย์ย่อย [1, 3, 3] ที่มีจํานวนความไม่สมดุล 1
- ซับอาร์เรย์ [1, 3, 3, 3] ที่มีจํานวนความไม่สมดุล 1
- ซับอาร์เรย์ [1, 3, 3, 3, 5] ที่มีจํานวนความไม่สมดุล 2
- ซับอาร์เรย์ [3, 3, 3, 5] ที่มีจํานวนความไม่สมดุล 1
- ซับอาร์เรย์ [3, 3, 5] ที่มีจํานวนความไม่สมดุล 1
- ซับอาร์เรย์ [3, 5] ที่มีจํานวนความไม่สมดุล 1
จํานวนความไม่สมดุลของอาร์เรย์ย่อยอื่น ๆ ทั้งหมดคือ 0 ดังนั้นผลรวมของผลรวมของจํานวนความไม่สมดุลของอาร์เรย์ย่อยทั้งหมดของ nums คือ 8

ข้อจํากัด:

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

ค่าความไม่สมดุลของอาร์เรย์จำนวนเต็ม arr ที่มีดัชนี 0 ที่มีความยาว n ถูกกำหนดให้เป็นจำนวนดัชนีใน sarr = sorted(arr) โดยที่:

0 <= i < n - 1 และ
sarr[i+1] - sarr[i] > 1

ในที่นี้ sorted(arr) คือฟังก์ชันที่ส่งคืน arr เวอร์ชันที่เรียงลำดับแล้ว
เมื่อกำหนดจำนวนอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ให้ส่งคืนผลรวมของค่าความไม่สมดุลของอาร์เรย์ย่อยทั้งหมด
อาร์เรย์ย่อยคือลำดับขององค์ประกอบที่ไม่ว่างและต่อเนื่องกันภายในอาร์เรย์

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

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

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

อินพุต: nums = [1,3,3,3,5]
เอาต์พุต: 8
คำอธิบาย: มี 7 ซับอาร์เรย์ที่มีค่าความไม่สมดุลที่ไม่เป็นศูนย์:
- ซับอาร์เรย์ [1, 3] ที่มีค่าความไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [1, 3, 3] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [1, 3, 3, 3] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [1, 3, 3, 3, 5] โดยมีค่าไม่สมดุลเท่ากับ 2
- ซับอาร์เรย์ [3, 3, 3, 5] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [3, 3, 5] โดยมีค่าไม่สมดุลเท่ากับ 1
- ซับอาร์เรย์ [3, 5] โดยมีค่าไม่สมดุลเท่ากับ 1
ค่าไม่สมดุลของซับอาร์เรย์อื่นๆ ทั้งหมดคือ 0 ดังนั้น ผลรวมของค่าไม่สมดุลของซับอาร์เรย์ทั้งหมดของ nums คือ 8

ข้อจำกัด:

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


คุณได้รับจำนวนเต็มสามตัวคือ x, y และ z
คุณมีสตริง x ตัวที่เท่ากับ "AA", สตริง y ตัวที่เท่ากับ "BB", และสตริง z ตัวที่เท่ากับ "AB" คุณต้องการเลือกบางส่วน (อาจจะทั้งหมดหรือไม่มีเลย) ของสตริงเหล่านี้แล้วต่อเป็นหนึ่งสตริงใหม่ สตริงใหม่นี้ต้องไม่มี "AAA" หรือ "BBB" เป็นสตริงย่อย
ให้คืนค่าความยาวสูงสุดเท่าที่เป็นไปได้ของสตริงใหม่
สตริงย่อยคือการเรียงลำดับต่อเนื่องที่ไม่ว่างเปล่าของตัวอักษรภายในสตริง

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

Input: x = 2, y = 5, z = 1
Output: 12
คำอธิบาย: เราสามารถต่อสตริง "BB", "AA", "BB", "AA", "BB", และ "AB" ตามลำดับได้ จากนั้นสตริงใหม่ของเราคือ "BBAABBAABBAB"
สตริงนั้นมีความยาว 12 และเราสามารถแสดงให้เห็นว่าเป็นไปไม่ได้ที่จะสร้างสตริงที่มีความยาวมากกว่า

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

Input: x = 3, y = 2, z = 2
Output: 14
คำอธิบาย: เราสามารถต่อสตริง "AB", "AB", "AA", "BB", "AA", "BB", และ "AA" ตามลำดับได้ จากนั้นสตริงใหม่ของเราคือ "ABABAABBAABBAA"
สตริงนั้นมีความยาว 14 และเราสามารถแสดงให้เห็นว่าเป็นไปไม่ได้ที่จะสร้างสตริงที่มีความยาวมากกว่า

ข้อจำกัด:

1 <= x, y, z <= 50

คุณจะได้รับสามจำนวนเต็ม x, y และ z
คุณมีสตริง x เท่ากับ "AA", y สตริง เท่ากับ "BB" และ z สตริง เท่ากับ "AB" คุณต้องการเลือกสตริงเหล่านี้ (อาจทั้งหมดหรือไม่มีเลย) และต่อกันในลำดับใดลำดับหนึ่งเพื่อสร้างสตริงใหม่ สตริงใหม่นี้จะต้องไม่มี "AAA" หรือ "BBB" เป็นสายย่อย
ส่งคืนความยาวสูงสุดที่เป็นไปได้ของสตริงใหม่
สตริงย่อยเป็นลำดับอักขระที่ไม่ว่างเปล่าที่ต่อเนื่องกันภายในสตริง

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

อินพุต: x = 2, y = 5, z = 1
เอาท์พุท: 12
คำอธิบาย: เราสามารถเชื่อมโยงสตริง "BB", "AA", "BB", "AA", "BB" และ "AB" ตามลำดับ จากนั้นสตริงใหม่ของเราคือ "BBAABBAABBAB"
สตริงนั้นมีความยาว 12 และเราสามารถแสดงให้เห็นว่ามันเป็นไปไม่ได้ที่จะสร้างสตริงที่มีความยาวนานขึ้น

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

อินพุต: x = 3, y = 2, z = 2
เอาท์พุท: 14
คำอธิบาย: เราสามารถเชื่อมโยงสตริง "AB", "AB", "AA", "BB", "AA", "BB" และ "AA" ในลำดับนั้น จากนั้นสตริงใหม่ของเราคือ "ABABAABBAABBAA".
สตริงนั้นมีความยาว 14 และเราสามารถแสดงให้เห็นว่ามันเป็นไปไม่ได้ที่จะสร้างสตริงที่มีความยาวนานขึ้น

ข้อ จำกัด :

1 <= x, y, z <= 50

คุณได้รับจำนวนเต็มสามตัว x, y, และ z
คุณมี x สตริงที่เท่ากับ "AA", y สตริงที่เท่ากับ "BB", และ z สตริงที่เท่ากับ "AB" คุณต้องการเลือกบางส่วน (อาจจะทั้งหมดหรือไม่มีเลย) ของสตริงเหล่านี้และเชื่อมต่อพวกมันในลำดับใดลำดับหนึ่งเพื่อสร้างสตริงใหม่ สตริงใหม่นี้ต้องไม่ประกอบด้วย "AAA" หรือ "BBB" เป็นซับสตริง
ส่งคืนความยาวสูงสุดที่เป็นไปได้ของสตริงใหม่
ซับสตริงคือ ลำดับของอักขระที่ต่อเนื่องกันและไม่ว่างภายในสตริง

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

Input: x = 2, y = 5, z = 1
Output: 12
คำอธิบาย: เราสามารถเชื่อมต่อสตริง "BB", "AA", "BB", "AA", "BB", และ "AB" ตามลำดับได้ จากนั้น สตริงใหม่ของเราคือ "BBAABBAABBAB" สตริงนั้นมีความยาว 12 และเราสามารถแสดงให้เห็นว่าเป็นไปไม่ได้ที่จะสร้างสตริงที่มีความยาวมากกว่านี้

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

Input: x = 3, y = 2, z = 2
Output: 14
คำอธิบาย:เราสามารถเชื่อมต่อสตริง "AB", "AB", "AA", "BB", "AA", "BB", และ "AA" ตามลำดับได้ จากนั้น สตริงใหม่ของเราคือ "ABABAABBAABBAA" สตริงนั้นมีความยาว 14 และเราสามารถแสดงให้เห็นว่าไม่สามารถสร้างสตริงที่มีความยาวมากกว่านี้ได้

ข้อจำกัด:

1 <= x, y, z <= 50


คุณจะได้รับอาร์เรย์คำที่มีดัชนี 0 ซึ่งประกอบด้วยสตริง n รายการ
ให้เรากำหนดการดำเนินการ join(x, y) ระหว่างสตริง x และ y สองตัวโดยต่อสตริงเหล่านั้นเป็น xy อย่างไรก็ตาม หากอักขระตัวสุดท้ายของ x เท่ากับอักขระตัวแรกของ y อักขระตัวใดตัวหนึ่งจะถูกลบออก
ตัวอย่างเช่น join("ab", "ba") = "aba" และ join("ab", "cde") = "abcde"
คุณต้องดำเนินการ join n - 1 โดยให้ str_0 = words[0] เริ่มจาก i = 1 ขึ้นไปจนถึง i = n - 1 สำหรับการดำเนินการครั้งที่ i คุณสามารถทำอย่างใดอย่างหนึ่งต่อไปนี้:

Make str_i = join(str_i - 1, words[i])
Make str_i = join(words[i], str_i - 1)

งานของคุณคือลดความยาวของ str_n - 1 ให้เหลือน้อยที่สุด
ส่งคืนจำนวนเต็มที่แสดงถึงความยาวที่น้อยที่สุดที่เป็นไปได้ของ str_n - 1

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

อินพุต: words = ["aa","ab","bc"]
เอาต์พุต: 4
คำอธิบาย: ในตัวอย่างนี้ เราสามารถดำเนินการรวมในลำดับต่อไปนี้เพื่อลดความยาวของ str_2 ให้เหลือน้อยที่สุด:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
จะแสดงให้เห็นได้ว่าความยาวที่น้อยที่สุดที่เป็นไปได้ของ str_2 คือ 4.
ตัวอย่างที่ 2:

อินพุต: words = ["ab","b"]
เอาต์พุต: 2
คำอธิบาย: ในตัวอย่างนี้ str_0 = "ab" มีสองวิธีในการรับ str_1:
join(str_0, "b") = "ab" หรือ join("b", str_0) = "bab"
สตริงแรก "ab" มีความยาวขั้นต่ำ ดังนั้นคำตอบคือ 2

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

อินพุต: words = ["aaa","c","aba"]
เอาต์พุต: 6
คำอธิบาย: ในตัวอย่างนี้ เราสามารถดำเนินการ join ตามลำดับต่อไปนี้เพื่อลดความยาวของ str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
จะเห็นว่าความยาวขั้นต่ำที่เป็นไปได้ของ str_2 คือ 6

ข้อจำกัด:

1 <= words.length <= 1000
1 <= words[i].length <= 50
อักขระแต่ละตัวใน words[i] คือตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก

คุณจะได้รับคำอาร์เรย์ 0-indexed ที่มีสตริง n
มากำหนดการเข้าร่วมการดำเนินการเข้าร่วม (x, y) ระหว่างสองสาย x และ y เพื่อให้พวกเขาเป็น xy อย่างไรก็ตามหากตัวละครสุดท้ายของ x เท่ากับตัวละครตัวแรกของ y หนึ่งในนั้นจะถูกลบ
ตัวอย่างเช่นเข้าร่วม ("ab", "ba") = "aba" และเข้าร่วม ("ab", "cde") = "abcde"
คุณจะต้องดำเนินการเข้าร่วม n - 1 Let str_0 = words[0]. Starting from i = 1 up to i = n - 1, สำหรับการดำเนินการ i^th คุณสามารถทำอย่างใดอย่างหนึ่งต่อไปนี้:

Make str_i = join(str_i - 1, words[i])
Make str_i = join(words[i], str_i - 1)

งานของคุณคือลดความยาวของ str_n - 1
ส่งคืนจำนวนเต็มแสดงถึงความยาวต่ำสุดที่เป็นไปได้ของ str_n - 1

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

อินพุต: words = ["aa", "ab", "bc"]
เอาท์พุท: 4
คำอธิบาย: ในตัวอย่างนี้เราสามารถดำเนินการเข้าร่วมการดำเนินการตามลำดับต่อไปนี้เพื่อลดความยาวของ str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
มันสามารถแสดงให้เห็นว่าความยาวต่ำสุดที่เป็นไปได้ของ str_2 คือ 4
ตัวอย่างที่ 2:

อินพุต: words = ["ab", "b"]
เอาท์พุท: 2
คำอธิบาย: ในตัวอย่างนี้ str_0 = "ab" มีสองวิธีในการรับ str_1:
join(str_0, "b") = "ab" or join("b", str_0) = "bab".
สตริงแรก "ab" มีความยาวขั้นต่ำ ดังนั้นคำตอบคือ 2

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

อินพุต: words = ["aaa","c","aba"]
เอาท์พุท: 6
คำอธิบาย: ในตัวอย่างนี้เราสามารถดำเนินการเข้าร่วมการดำเนินการตามลำดับต่อไปนี้เพื่อลดความยาวของ str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
มันสามารถแสดงให้เห็นว่าความยาวต่ำสุดที่เป็นไปได้ของ str_2 คือ 6

ข้อ จำกัด :

1 <= words.length <= 1000
1 <= words[i].length <= 50
ตัวละครแต่ละตัวในคำพูด [i] เป็นตัวอักษรตัวพิมพ์เล็กภาษาอังกฤษ


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

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

คืนค่าจำนวนการกระโดดสูงสุดที่คุณสามารถทำได้เพื่อไปถึงดัชนี n - 1
ถ้าไม่มีวิธีการไปถึงดัชนี n - 1 ให้คืนค่า -1

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

Input: nums = [1,3,6,4,1,2], target = 2
Output: 3
คำอธิบาย: เพื่อไปจากดัชนี 0 ถึงดัชนี n - 1 ด้วยจำนวนการกระโดดสูงสุด คุณสามารถทำลำดับการกระโดดดังนี้:
- กระโดดจากดัชนี 0 ไปยังดัชนี 1
- กระโดดจากดัชนี 1 ไปยังดัชนี 3
- กระโดดจากดัชนี 3 ไปยังดัชนี 5
สามารถพิสูจน์ได้ว่าไม่มีลำดับการกระโดดอื่นที่ไปจาก 0 ถึง n - 1 ด้วยการกระโดดมากกว่า 3 ครั้ง ดังนั้นคำตอบคือ 3

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

Input: nums = [1,3,6,4,1,2], target = 3
Output: 5
คำอธิบาย: เพื่อไปจากดัชนี 0 ถึงดัชนี n - 1 ด้วยจำนวนการกระโดดสูงสุด คุณสามารถทำลำดับการกระโดดดังนี้:
- กระโดดจากดัชนี 0 ไปยังดัชนี 1
- กระโดดจากดัชนี 1 ไปยังดัชนี 2
- กระโดดจากดัชนี 2 ไปยังดัชนี 3
- กระโดดจากดัชนี 3 ไปยังดัชนี 4
- กระโดดจากดัชนี 4 ไปยังดัชนี 5
สามารถพิสูจน์ได้ว่าไม่มีลำดับการกระโดดอื่นที่ไปจาก 0 ถึง n - 1 ด้วยการกระโดดมากกว่า 5 ครั้ง ดังนั้นคำตอบคือ 5

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

Input: nums = [1,3,6,4,1,2], target = 0
Output: -1
คำอธิบาย: สามารถพิสูจน์ได้ว่าไม่มีลำดับการกระโดดที่ไปจาก 0 ถึง n - 1 ดังนั้นคำตอบคือ -1

ข้อจำกัด:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

คุณมีอาเรย์ที่มีดัชนี0 จำนวน nจำนวนเต็ม และtarget จำนวนเต็ม ในตอนแรกคุณอยู่ที่ดัชนี 0 และในหนึ่งขั้นตอนคุณสามารถกระโดดจากดัชนี i ไปยังดัชนี j โดยที่:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

คืนค่าจำนวนการกระโดดสูงสุดที่คุณสามารถทำได้เพื่อไปถึงดัชนี n - 1 ถ้าไม่มีวิธีการไปถึงดัชนี n - 1 ให้คืนค่า -1

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

Input: nums = [1,3,6,4,1,2], target = 2
Output: 3
คำอธิบาย: เพื่อไปจากดัชนี 0 ถึงดัชนี n - 1 ด้วยจำนวนการกระโดดสูงสุด คุณสามารถทำลำดับการกระโดดดังนี้:
- กระโดดจากดัชนี 0 ไปยังดัชนี 1
- กระโดดจากดัชนี 1 ไปยังดัชนี 3
- กระโดดจากดัชนี 3 ไปยังดัชนี 5
สามารถพิสูจน์ได้ว่าไม่มีลำดับการกระโดดอื่นที่ไปจาก 0 ถึง n - 1 ด้วยการกระโดดมากกว่า 3 ครั้ง ดังนั้นคำตอบคือ 3

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

Input: nums = [1,3,6,4,1,2], target = 3
Output: 5
คำอธิบาย: เพื่อไปจากดัชนี 0 ถึงดัชนี n - 1 ด้วยจำนวนการกระโดดสูงสุด คุณสามารถทำลำดับการกระโดดดังนี้:
- กระโดดจากดัชนี 0 ไปยังดัชนี 1
- กระโดดจากดัชนี 1 ไปยังดัชนี 2
- กระโดดจากดัชนี 2 ไปยังดัชนี 3
- กระโดดจากดัชนี 3 ไปยังดัชนี 4
- กระโดดจากดัชนี 4 ไปยังดัชนี 5
สามารถพิสูจน์ได้ว่าไม่มีลำดับการกระโดดอื่นที่ไปจาก 0 ถึง n - 1 ด้วยการกระโดดมากกว่า 5 ครั้ง ดังนั้นคำตอบคือ 5

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

Input: nums = [1,3,6,4,1,2], target = 0
Output: -1
คำอธิบาย: สามารถพิสูจน์ได้ว่าไม่มีลำดับการกระโดดที่ไปจาก 0 ถึง n - 1 ดังนั้นคำตอบคือ -1

ข้อจำกัด:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

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

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

ส่งคืนจํานวนการกระโดดสูงสุดที่คุณสามารถทําได้เพื่อเข้าถึงดัชนี n - 1
หากไม่มีทางไปถึงดัชนี n - 1 ให้ส่งคืน -1

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

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

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

อินพุต: nums = [1,3,6,4,1,2], target = 0
เอาท์พุต: -1
คําอธิบาย: สามารถพิสูจน์ได้ว่าไม่มีลําดับการกระโดดที่เปลี่ยนจาก 0 ถึง n - 1 ดังนั้นคําตอบคือ -1

ข้อจํากัด:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9


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

จำนวนขององค์ประกอบที่แตกต่างกันในซับอาร์เรย์เท่ากับจำนวนขององค์ประกอบที่แตกต่างกันในอาร์เรย์ทั้งหมด

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

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

Input: nums = [1,3,1,2,2]
Output: 4
คำอธิบาย: อาร์เรย์ย่อยที่สมบูรณ์มีดังนี้: [1,3,1,2], [1,3,1,2,2], [3,1,2] และ [3,1,2,2].

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

Input: nums = [5,5,5,5]
Output: 10
คำอธิบาย: อาเรย์ประกอบด้วยเฉพาะจำนวนเต็ม 5 ดังนั้นซับอาเรย์ใด ๆ ก็ถือว่าครบถ้วน จำนวนซับอาเรย์ที่เราสามารถเลือกได้คือ 10.

ข้อจำกัด:

1 <= nums.length <= 1000
1 <= nums[i] <= 2000

คุณได้รับอาร์เรย์ nums ซึ่งประกอบด้วยจำนวนเต็มบวก
เราเรียกว่า subarray ของอาร์เรย์ว่า "complete" ถ้าตรงตามเงื่อนไขดังนี้:

จำนวนขององค์ประกอบที่แตกต่างกันใน subarray เท่ากับจำนวนขององค์ประกอบที่แตกต่างกันในอาร์เรย์ทั้งหมด

คืนค่าจำนวนของ complete subarrays
subarray คือส่วนที่ไม่ว่างเปล่าและติดกันของอาร์เรย์

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

Input: nums = [1,3,1,2,2]
Output: 4
คำอธิบาย: complete subarrays ประกอบด้วย [1,3,1,2], [1,3,1,2,2], [3,1,2] และ [3,1,2,2]

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

Input: nums = [5,5,5,5]
Output: 10
คำอธิบาย: อาร์เรย์ประกอบด้วยจำนวนเต็ม 5 เพียงค่าเดียว ดังนั้น subarray ใดๆ ก็เป็น complete จำนวนของ subarray ที่สามารถเลือกได้คือ 10

ข้อจำกัด:

1 <= nums.length <= 1000
1 <= nums[i] <= 2000

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

จำนวนองค์ประกอบที่แตกต่างกันในซับอาร์เรย์จะเท่ากับจำนวนองค์ประกอบที่แตกต่างกันในอาร์เรย์ทั้งหมด

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

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

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

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

อินพุต: nums = [5,5,5,5]
เอาต์พุต: 10
คำอธิบาย: อาร์เรย์ประกอบด้วยจำนวนเต็ม 5 เท่านั้น ดังนั้นซับอาร์เรย์ใดๆ ก็ถือว่าสมบูรณ์ จำนวนซับอาร์เรย์ที่เราสามารถเลือกได้คือ 10

ข้อจำกัด:

1 <= nums.length <= 1000
1 <= nums[i] <= 2000


รถบรรทุกมีถังเชื้อเพลิงสองถัง คุณจะได้รับจำนวนเต็มสองจำนวน โดย mainTank แทนเชื้อเพลิงที่มีอยู่ในถังหลักเป็นลิตร และ additionalTank แทนเชื้อเพลิงที่มีอยู่ในถังเพิ่มเติมเป็นลิตร
รถบรรทุกวิ่งได้ระยะทาง 10 กม. ต่อลิตร เมื่อใดก็ตามที่ใช้เชื้อเพลิงในถังหลัก 5 ลิตร หากถังเพิ่มเติมมีเชื้อเพลิงอย่างน้อย 1 ลิตร เชื้อเพลิง 1 ลิตรจะถูกถ่ายโอนจากถังเพิ่มเติมไปยังถังหลัก
คืนระยะทางสูงสุดที่สามารถเดินทางได้
หมายเหตุ: การฉีดจากถังเพิ่มเติมไม่ต่อเนื่อง เกิดขึ้นทันทีทันใดสำหรับทุก ๆ 5 ลิตรที่บริโภค

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

อินพุต: mainTank = 5, additionalTank = 10
เอาต์พุต: 60
คำอธิบาย:
หลังจากใช้เชื้อเพลิง 5 ลิตรแล้ว เชื้อเพลิงที่เหลืออยู่คือ (5 - 5 + 1) = 1 ลิตร และระยะทางที่เดินทางคือ 50 กม. หลังจากใช้เชื้อเพลิงไป 1 ลิตรแล้ว ถังหลักจะไม่เติมเชื้อเพลิงอีก และถังหลักจะว่างเปล่า
ระยะทางที่เดินทางทั้งหมดคือ 60 กม.

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

อินพุต: mainTank = 1, additionalTank = 2
เอาต์พุต: 10
คำอธิบาย:
หลังจากใช้เชื้อเพลิงไป 1 ลิตร ถังหลักจะว่างเปล่า
ระยะทางที่เดินทางทั้งหมดคือ 10 กม.

ข้อจำกัด:

1 <= mainTank, additionalTank <= 100

รถบรรทุกมีถังเชื้อเพลิงสองถัง คุณจะได้รับจำนวนเต็มสองตัว คือ mainTank แทนเชื้อเพลิงที่มีอยู่ในถังหลักในลิตร และ additionalTank แทนเชื้อเพลิงที่มีอยู่ในถังเพิ่มเติมในลิตร
รถบรรทุกมีระยะทาง 10 กม. ต่อลิตร เมื่อเชื้อเพลิงในถังหลักใช้ไป 5 ลิตรหากถังเพิ่มเติมมีเชื้อเพลิงอย่างน้อย 1 ลิตร 1 ลิตรจะถูกโอนจากถังเพิ่มเติมไปยังถังหลัก
ส่งคืนระยะทางสูงสุดซึ่งสามารถเดินทางได้
หมายเหตุ: การฉีดจากถังเพิ่มเติมไม่ต่อเนื่อง มันเกิดขึ้นทันทีสำหรับทุก ๆ 5 ลิตรที่บริโภค
ตัวอย่างที่ 1:

อินพุต:  mainTank = 5, additionalTank = 10
เอาท์พุท: 60
คำอธิบาย:
หลังจากใช้เชื้อเพลิง 5 ลิตรเชื้อเพลิงที่เหลืออยู่คือ (5 - 5 + 1) = 1 ลิตรและระยะทางที่เดินทางคือ 50 กม.
หลังจากใช้เชื้อเพลิงอีก 1 ลิตรไม่มีเชื้อเพลิงถูกฉีดเข้าไปในถังหลักและถังหลักจะว่างเปล่า
ระยะทางทั้งหมดที่เดินทางคือ 60 กม.

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

อินพุต:  mainTank = 1, additionalTank = 2
เอาท์พุท: 10
คำอธิบาย:
หลังจากใช้เชื้อเพลิง 1 ลิตรถังหลักจะว่างเปล่า
ระยะทางทั้งหมดที่เดินทางคือ 10 กม.

ข้อ จำกัด :

1 <= mainTank, additionalTank <= 100


คุณได้รับอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นจาก 0 ชื่อ nums และค่าจำนวนเต็ม threshold
ให้คุณหา ความยาวของช่วงย่อยที่ยาวที่สุด ในอาร์เรย์ nums ซึ่งเริ่มต้นที่ดัชนี l และสิ้นสุดที่ดัชนี r (0 <= l <= r < nums.length) ที่ตรงตามเงื่อนไขดังนี้:
		nums[l] % 2 == 0 (องค์ประกอบตัวแรกของช่วงต้องเป็นเลขคู่)
		สำหรับทุกดัชนี i ในช่วง [l, r - 1] จะต้องมีเงื่อนไข nums[i] % 2 != nums[i + 1] % 2 (เลขในช่วงต้องมีความเป็นคู่และคี่สลับกัน)
		สำหรับทุกดัชนี i ในช่วง [l, r] จะต้องมีเงื่อนไข nums[i] <= threshold (ค่าในช่วงต้องไม่เกิน threshold)

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

Input: nums = [3,2,5,4], threshold = 5
Output: 3
Explanation: ในตัวอย่างนี้ เราสามารถเลือกช่วง [2,5,4] ซึ่งเริ่มที่ l = 1 และสิ้นสุดที่ r = 3 ได้ ช่วงนี้ตรงตามเงื่อนไขทั้งหมด ดังนั้นคำตอบคือ 3 ซึ่งเป็นความยาวของช่วง และเราสามารถแสดงได้ว่า 3 เป็นความยาวสูงสุดที่สามารถทำได้
ตัวอย่างที่ 2:

Input: nums = [1,2], threshold = 2
Output: 1
Explanation: ในตัวอย่างนี้ เราสามารถเลือกช่วง [2] ซึ่งเริ่มและสิ้นสุดที่ l = 1 และ r = 1 ได้ ช่วงนี้ตรงตามเงื่อนไขทั้งหมด และเราสามารถแสดงได้ว่า 1 เป็นความยาวสูงสุดที่สามารถทำได้
ตัวอย่างที่ 3:

Input: nums = [2,3,4,5], threshold = 4
Output: 3
Explanation: ในตัวอย่างนี้ เราสามารถเลือกช่วง [2,3,4] ซึ่งเริ่มที่ l = 0 และสิ้นสุดที่ r = 2 ได้ ช่วงนี้ตรงตามเงื่อนไขทั้งหมด ดังนั้นคำตอบคือ 3 ซึ่งเป็นความยาวของช่วง และเราสามารถแสดงได้ว่า 3 เป็นความยาวสูงสุดที่สามารถทำได้
เงื่อนไข:
	1 <= nums.length <= 100
1 <= nums [i] <= 100
1 <= threshold <= 100

คุณจะได้รับอาร์เรย์จำนวนเต็มที่จัดทำดัชนี 0 nums และเกณฑ์จำนวนเต็ม
ค้นหาความยาวของซับอาร์เรย์ที่ยาวที่สุดของ nums โดยเริ่มจากดัชนี l และสิ้นสุดที่ดัชนี r (0 <= l <= r < nums.length) ที่ตรงตามเงื่อนไขต่อไปนี้:

nums[l] % 2 == 0
สำหรับดัชนี i ทั้งหมดในช่วง [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
สำหรับดัชนี i ทั้งหมดในช่วง [l, r], nums[i] <= threshold

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

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

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

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

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

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็มที่จัดทำดัชนี 0 nums และเกณฑ์จำนวนเต็ม
ค้นหาความยาวของซับอาร์เรย์ที่ยาวที่สุดของ nums โดยเริ่มจากดัชนี l และสิ้นสุดที่ดัชนี r (0 <= l <= r < nums.length) ที่ตรงตามเงื่อนไขต่อไปนี้:

nums[l] % 2 == 0
สำหรับดัชนี i ทั้งหมดในช่วง [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
สำหรับดัชนี i ทั้งหมดในช่วง [l, r], nums[i] <= เกณฑ์

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

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

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

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

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

อินพุต: nums = [2,3,4,5], threshold = 4
เอาต์พุต: 3
คำอธิบาย: ในตัวอย่างนี้เราสามารถเลือก subarray ที่เริ่มต้นที่ l = 0 และสิ้นสุดที่ r = 2 => [2,3,4]
มันเป็นไปตามเงื่อนไขทั้งหมด
ดังนั้นคำตอบคือความยาวของ subarray, 3. เราสามารถแสดงให้เห็นว่า 3 คือความยาวสูงสุดที่ทำได้

ข้อจำกัด:

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


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

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

อินพุต: nums = [0,1,0,0,1]
เอาท์พุท: 3
คำอธิบาย: มี 3 วิธีในการแบ่ง Nums เป็น subarrays ที่ดี:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

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

อินพุต: nums = [0,1,0]
เอาท์พุท: 1
คำอธิบาย: มี 1 วิธีในการแบ่ง nums เป็น subarrays ที่ดี:
- [0,1,0]

ข้อ จำกัด :

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

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

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

อินพุต: nums = [0,1,0,0,1]
เอาท์พุท: 3
คำอธิบาย: มี 3 วิธีในการแบ่ง Nums เป็น subarrays ที่ดี:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

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

อินพุต: nums = [0,1,0]
เอาท์พุท: 1
คำอธิบาย: มี 1 วิธีในการแบ่ง nums เป็น subarrays ที่ดี:
- [0,1,0]

ข้อ จำกัด :

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

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

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

Input: nums = [0,1,0,0,1] Output: 3 คำอธิบาย: มี 3 วิธีในการแบ่ง nums เป็นอาร์เรย์ย่อยที่ดี: - [0,1] [0,0,1] - [0,1,0] [0,1] - [0,1,0,0] [1]

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

Input: nums = [0,1,0] Output: 1 คำอธิบาย: มี 1 วิธีในการแบ่ง nums เป็นอาร์เรย์ย่อยที่ดี: - [0,1,0]

ข้อจำกัด:

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


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

ให้ i, i + 1, ..., j_ เป็นดัชนีในซับอาเรย์ จากนั้น สำหรับแต่ละคู่ของดัชนีที่ i <= i_1, i_2 <= j จะมี 0 <= |nums[i_1] - nums[i_2]| <= 2.

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

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

Input: nums = [5,4,2,4]
Output: 8
คำอธิบาย:
อาร์เรย์ย่อยที่ต่อเนื่องขนาด 1: [5], [4], [2], [4].
อาร์เรย์ย่อยที่ต่อเนื่องขนาด 2: [5,4], [4,2], [2,4].
อาร์เรย์ย่อยที่ต่อเนื่องขนาด 3: [4,2,4].
ไม่มีอาร์เรย์ย่อยขนาด 4.
จำนวนซับอาเรย์ต่อเนื่องทั้งหมด = 4 + 3 + 1 = 8.
สามารถแสดงให้เห็นได้ว่าไม่มีซับอาเรย์ต่อเนื่องเพิ่มเติมอีกแล้ว.

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

Input: nums = [1,2,3]
Output: 6
คำอธิบาย:
อาร์เรย์ย่อยที่ต่อเนื่องขนาด 1: [1], [2], [3].
อาร์เรย์ย่อยที่ต่อเนื่องขนาด 2: [1,2], [2,3].
อาร์เรย์ย่อยที่ต่อเนื่องขนาด 3: [1,2,3].
จำนวนซับอาเรย์ต่อเนื่องทั้งหมด = 3 + 2 + 1 = 6.

ข้อจำกัด:

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

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

ให้ i, i + 1, ..., j_ เป็นดัชนีในอาร์เรย์ย่อย จากนั้น สำหรับแต่ละคู่ของดัชนี i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2

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

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

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

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

อินพุต: nums = [1,2,3]
เอาต์พุต: 6
คำอธิบาย:
ซับอาร์เรย์ต่อเนื่องขนาด 1: [1], [2], [3]
ซับอาร์เรย์ต่อเนื่องขนาด 2: [1,2], [2,3]
ซับอาร์เรย์ต่อเนื่องขนาด 3: [1,2,3]
ซับอาร์เรย์ต่อเนื่องทั้งหมด = 3 + 2 + 1 = 6

ข้อจำกัด:

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

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

ให้ i, i + 1, ... j_เป็นดัชนีในอาร์เรย์ย่อย จากนั้นสําหรับดัชนีแต่ละคู่ i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

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

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

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

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

อินพุต: nums = [1,2,3]
เอาท์พุต: 6
การอธิบาย:
อาร์เรย์ย่อยต่อเนื่องขนาด 1: [1], [2], [3]
อาร์เรย์ย่อยต่อเนื่องขนาด 2: [1,2], [2,3]
อาร์เรย์ย่อยต่อเนื่องขนาด 3: [1,2,3]
อาร์เรย์ย่อยต่อเนื่องทั้งหมด = 3 + 2 + 1 = 6

ข้อจํากัด:

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


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

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

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

หมายเหตุ: อาร์เรย์ย่อยคือชุดขององค์ประกอบที่เชื่อมต่อกันและไม่ว่างเปล่าภายในอาร์เรย์

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

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

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

Input: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Output: 4
คำอธิบาย: วิธีหนึ่งในการสร้าง nums3 คือ:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
อาร์เรย์ทั้งหมดเป็นซับอาร์เรย์ที่ไม่ลดลงยาว 4 ซึ่งทำให้ความยาวที่สามารถทำได้สูงสุด

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

Input: nums1 = [1,1], nums2 = [2,2]
Output: 2
คำอธิบาย: วิธีหนึ่งในการสร้าง nums3 คือ:
nums3 = [nums1[0], nums1[1]] => [1,1].
อาร์เรย์ทั้งหมดเป็นซับอาร์เรย์ที่ไม่ลดลงยาว 2 ซึ่งทำให้ความยาวที่สามารถทำได้สูงสุด

ข้อจำกัด:

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

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

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

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

อินพุต: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
เอาท์พุท: 4
คำอธิบาย: วิธีหนึ่งในการสร้าง NUMS3 คือ:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
อาร์เรย์ทั้งหมดเป็น subarray ที่ไม่ลดลงของความยาว 4 ทำให้มีความยาวสูงสุดที่ทำได้

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

อินพุต: nums1 = [1,1], nums2 = [2,2]
เอาท์พุท: 2
คำอธิบาย: วิธีหนึ่งในการสร้าง nums3 คือ:
nums3 = [nums1 [0], nums1 [1]] => [1,1]
อาร์เรย์ทั้งหมดเป็น subarray ที่ไม่ลดลงของความยาว 2 ทำให้มีความยาวสูงสุดที่ทำได้

ข้อ จำกัด :

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

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

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

อินพุต: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
เอาต์พุต: 4
คำอธิบาย: วิธีหนึ่งในการสร้าง nums3 คือ:

nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4]

อาร์เรย์ทั้งหมดจะสร้างอาร์เรย์ย่อยที่ไม่ลดลงซึ่งมีความยาว 4 ทำให้เป็นความยาวสูงสุดที่สามารถทำได้

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

อินพุต: nums1 = [1,1], nums2 = [2,2]
เอาต์พุต: 2
คำอธิบาย: วิธีหนึ่งในการสร้าง nums3 คือ:

nums3 = [nums1[0], nums1[1]] => [1,1]

อาร์เรย์ทั้งหมดจะสร้างอาร์เรย์ย่อยที่มีความยาว 2 โดยไม่ลดลง ทำให้เป็นความยาวสูงสุดที่สามารถทำได้

ข้อจำกัด:

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


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

m มากกว่า 1
s_1 = s_0 + 1
อาร์เรย์ย่อยที่มีดัชนี 0 s มีลักษณะดังนี้ [s_0, s_1, s_0, s_1,...,s_(m-1) % 2] กล่าวอีกนัยหนึ่ง s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1 และต่อไปเรื่อยๆ จนถึง s[m - 1] - s[m - 2] = (-1)^m

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

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

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

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

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

ข้อจำกัด:

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

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

m มากกว่า 1
s_1 = s_0 + 1
อาร์เรย์ย่อยที่มีดัชนี 0 s มีลักษณะดังนี้ [s_0, s_1, s_0, s_1,...,s_(m-1) % 2] กล่าวอีกนัยหนึ่ง s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1 และต่อไปเรื่อยๆ จนถึง s[m - 1] - s[m - 2] = (-1)^m

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

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

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

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

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

ข้อจำกัด:

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

คุณจะได้รับจํานวนอาร์เรย์จํานวนเต็มที่มีดัชนี 0 อาร์เรย์ย่อย s ที่มีความยาว m เรียกว่าสลับกันหาก:

m มากกว่า 1
s_1 = s_0 + 1
อาร์เรย์ย่อยที่มีดัชนี 0 มีลักษณะเหมือน [s_0, s_1, s_0, s_1,...,s_(m-1) % 2] กล่าวอีกนัยหนึ่ง s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1 และอื่น ๆ จนถึง s[m - 1] - s[m - 2] = (-1)^m

ส่งคืนความยาวสูงสุดของอาร์เรย์ย่อยสลับทั้งหมดที่มีอยู่ใน nums หรือ -1 หากไม่มีอาร์เรย์ย่อยดังกล่าว
อาร์เรย์ย่อยคือลําดับองค์ประกอบที่ไม่ว่างเปล่าที่อยู่ติดกันภายในอาร์เรย์

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

อินพุต: nums = [2,3,4,3,4]
เอาท์พุต: 4
คําอธิบาย: อาร์เรย์ย่อยสลับคือ [3,4], [3,4,3] และ [3,4,3,4] ที่ยาวที่สุดคือ [3,4,3,4] ซึ่งมีความยาว 4

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

อินพุต: nums = [4,5,6]
เอาท์พุต: 2
คําอธิบาย: [4,5] และ [5,6] เป็นอาร์เรย์ย่อยสลับกันเพียงสองอาร์เรย์ ทั้งสองมีความยาว 2

ข้อจํากัด:

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


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

เลือกจำนวนเต็ม i โดยที่ 0 <= i < nums.length - 1 และ nums[i] <= nums[i + 1] แทนที่องค์ประกอบ nums[i + 1] ด้วย nums[i] + nums[i + 1] แล้วลบองค์ประกอบ nums[i] ออกจากอาร์เรย์

ส่งคืนค่าขององค์ประกอบที่ใหญ่ที่สุดที่คุณสามารถรับได้ในอาร์เรย์สุดท้าย

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

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

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

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

ข้อจำกัด:

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

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

เลือกจํานวนเต็ม i เพื่อให้ 0 <= i < nums.length - 1 และ nums[i] <= nums[i + 1] แทนที่องค์ประกอบ nums[i + 1] ด้วย nums[i] + nums[i + 1] และลบองค์ประกอบ nums[i] ออกจากอาร์เรย์

ส่งกลับค่าขององค์ประกอบที่ใหญ่ที่สุดที่คุณสามารถรับได้ในอาร์เรย์สุดท้าย

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

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

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

อินพุต: nums = [5,3,3]
เอาท์พุต: 11
คําอธิบาย: เราสามารถดําเนินการต่อไปนี้กับอาร์เรย์:
- เลือก i = 1 อาร์เรย์ผลลัพธ์จะเป็น nums = [5,6]
- เลือก i = 0 อาร์เรย์ผลลัพธ์จะเป็น nums = [11]
มีองค์ประกอบเพียงองค์ประกอบเดียวในอาร์เรย์สุดท้าย ซึ่งก็คือ 11

ข้อจํากัด:

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

คุณมีอาร์เรย์ที่มีดัชนีเริ่มต้นที่ 0 ชื่อ nums ประกอบด้วยจำนวนเต็มบวก

คุณสามารถทำการดำเนินการต่อไปนี้บนอาร์เรย์ได้ไม่จำกัดจำนวนครั้ง:

เลือกจำนวนเต็ม i โดยที่ 0 <= i < nums.length - 1 และ nums[i] <= nums[i + 1] แทนที่สมาชิก nums[i + 1] ด้วย nums[i] + nums[i + 1] และลบสมาชิก nums[i] ออกจากอาร์เรย์

ส่งคืนค่าของสมาชิกที่มีค่ามากที่สุดที่คุณสามารถหาได้ในอาร์เรย์สุดท้าย

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

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

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

Input: nums = [5,3,3]
Output: 11
คำอธิบาย: เราสามารถทำการดำเนินการต่อไปนี้บนอาร์เรย์:
- เลือก i = 1. อาร์เรย์ที่ได้จะเป็น nums = [5,6].
- เลือก i = 0. อาร์เรย์ที่ได้จะเป็น nums = [11].
มีเพียงสมาชิกเดียวในอาร์เรย์สุดท้ายซึ่งคือ 11

ข้อจำกัด:

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


คุณได้รับจำนวนเต็ม n เราจะกล่าวว่า จำนวนเต็มสองจำนวน x และ y เป็นคู่จำนวนเฉพาะ หาก:

1 <= x <= y <= n
x + y == n
x และ y เป็นจำนวนเฉพาะ

ส่งคืนรายการ 2 มิติที่เรียงลำดับของคู่จำนวนเฉพาะ [x_i, y_i] รายการนี้ควรเรียงลำดับตามลำดับที่เพิ่มขึ้นของ x_i หากไม่มีคู่จำนวนเฉพาะเลย ให้ส่งคืนอาร์เรย์ว่าง
หมายเหตุ: จำนวนเฉพาะคือจำนวนธรรมชาติที่มากกว่า 1 ซึ่งมีปัจจัยเพียงสองตัว คือ ตัวมันเองและ 1.

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

Input: n = 10
Output: [[3,7],[5,5]]
คำอธิบาย: ในตัวอย่างนี้ มีคู่จำนวนเฉพาะสองคู่ที่ตรงตามเกณฑ์ คู่เหล่านี้คือ [3,7] และ [5,5] และเราจะส่งคืนพวกมันในลำดับที่เรียงตามที่ระบุในข้อความปัญหา

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

Input: n = 2
Output: []
คำอธิบาย: เราสามารถแสดงให้เห็นว่าไม่มีคู่ของจำนวนเฉพาะที่ให้ผลรวมเป็น 2 ดังนั้นเราจึงส่งคืนอาร์เรย์ว่างเปล่า

ข้อจำกัด:

1 <= n <= 10^6

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

1 <= x <= y <= n
x + y == n
x และ y เป็นจำนวนเฉพาะ

ส่งคืนรายการคู่ที่เรียงลำดับ 2D ของคู่จำนวนเฉพาะ [x_i, y_i] รายการควรเรียงลำดับในการเพิ่มลำดับของ x_i หากไม่มีคู่หมายเลขเฉพาะเลยให้ส่งคืนอาร์เรย์ที่ว่างเปล่า
หมายเหตุ: จำนวนเฉพาะคือจำนวนธรรมชาติที่มากกว่า 1 โดยมีเพียงสองปัจจัยเท่านั้นและ 1

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

อินพุต: n = 10
ผลลัพธ์: [[3,7], [5,5]]
คำอธิบาย: ในตัวอย่างนี้มีสองคู่หมายเลขเฉพาะที่เป็นไปตามเกณฑ์
คู่เหล่านี้คือ [3,7] และ [5,5] และเราส่งคืนพวกเขาในลำดับที่จัดเรียงตามที่อธิบายไว้ในคำสั่งปัญหา

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

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

ข้อ จำกัด :

1 <= n <= 10^6

คุณได้รับจำนวนเต็ม n เราจะบอกว่าจำนวนเต็ม x และ y สองจำนวนจะสร้างคู่จำนวนเฉพาะได้ก็ต่อเมื่อ:

1 <= x <= y <= n
x + y == n
x และ y เป็นจำนวนเฉพาะ

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

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

อินพุต: n = 10
เอาต์พุต: [[3,7],[5,5]]
คำอธิบาย: ในตัวอย่างนี้ มีคู่จำนวนเฉพาะสองคู่ที่ตรงตามเกณฑ์

คู่เหล่านี้คือ [3,7] และ [5,5] และเราส่งคืนคู่เหล่านี้ในลำดับที่เรียงลำดับตามที่อธิบายไว้ในคำชี้แจงปัญหา
ตัวอย่างที่ 2:

อินพุต: n = 2
เอาต์พุต: []
คำอธิบาย: เราสามารถแสดงให้เห็นว่าไม่มีคู่จำนวนเฉพาะใดที่มีผลรวมเท่ากับ 2 ดังนั้นเราจึงส่งคืนอาร์เรย์ว่าง

ข้อจำกัด:

1 <= n <= 10^6


ในบริษัทมีพนักงาน n คน โดยกำหนดหมายเลขตั้งแต่ 0 ถึง n - 1 พนักงานแต่ละคน i ทำงานในบริษัทเป็นเวลา hours[i] ชั่วโมง
บริษัทกำหนดให้พนักงานแต่ละคนทำงานอย่างน้อย target ชั่วโมง
คุณจะได้รับอาร์เรย์ที่มีดัชนี 0 ของจำนวนเต็มที่ไม่เป็นลบ จำนวนชั่วโมงที่มีความยาว n และจำนวนเต็มที่ไม่เป็นลบ เป้าหมาย
ส่งกลับจำนวนเต็มที่แสดงถึงจำนวนพนักงานที่ทำงานอย่างน้อย target ชั่วโมง
ตัวอย่างที่ 1:

อินพุต: hours = [0,1,2,3,4], target = 2
เอาต์พุต: 3
คำอธิบาย : บริษัทต้องการให้พนักงานแต่ละคนทำงานอย่างน้อย 2 ชั่วโมง
- พนักงาน 0 ทำงาน 0 ชั่วโมงและไม่บรรลุเป้าหมาย
- พนักงาน 1 ทำงาน 1 ชั่วโมงและไม่บรรลุเป้าหมาย
- พนักงาน 2 ทำงาน 2 ชั่วโมงและบรรลุเป้าหมาย
- พนักงาน 3 ทำงาน 3 ชั่วโมงและบรรลุเป้าหมาย
- พนักงาน 4 ทำงาน 4 ชั่วโมงและบรรลุเป้าหมาย
มีพนักงาน 3 คนที่บรรลุเป้าหมาย

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

อินพุต: hours = [5,1,4,2,2], target = 6
เอาต์พุต: 0
คำอธิบาย: บริษัทต้องการให้พนักงานแต่ละคนทำงานอย่างน้อย 6 ชั่วโมง
มีพนักงาน 0 คนที่บรรลุเป้าหมาย

ข้อจำกัด:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

มีพนักงาน n คนในบริษัท ซึ่งมีหมายเลขตั้งแต่ 0 ถึง n - 1 พนักงานแต่ละคน i ทำงานเป็นจำนวนชั่วโมง hours[i] ในบริษัท
บริษัทต้องการให้พนักงานแต่ละคนทำงานอย่างน้อยตามจำนวนชั่วโมงที่กำหนด (target hours)
คุณจะได้รับอาเรย์ที่มีดัชนีเริ่มต้นที่ 0 ซึ่งประกอบด้วยจำนวนเต็มที่ไม่เป็นลบ (non-negative integers) ชื่อ hours ที่มีความยาว n และจำนวนเต็มที่ไม่เป็นลบ (non-negative integer) ชื่อ target
ให้คืนค่าจำนวนเต็มที่แสดงถึงจำนวนพนักงานที่ทำงานอย่างน้อยตามจำนวนชั่วโมงที่กำหนด (target hours)

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

Input: hours = [0,1,2,3,4], target = 2
Output: 3
คำอธิบาย: บริษัทต้องการให้พนักงานแต่ละคนทำงานอย่างน้อย 2 ชั่วโมง
- พนักงาน 0 ทำงาน 0 ชั่วโมงและไม่ถึงเป้าหมาย
- พนักงาน 1 ทำงาน 1 ชั่วโมงและไม่ถึงเป้าหมาย
- พนักงาน 2 ทำงาน 2 ชั่วโมงและถึงเป้าหมาย
- พนักงาน 3 ทำงาน 3 ชั่วโมงและถึงเป้าหมาย
- พนักงาน 4 ทำงาน 4 ชั่วโมงและถึงเป้าหมาย
มีพนักงาน 3 คนที่ถึงเป้าหมาย

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

Input: hours = [5,1,4,2,2], target = 6
Output: 0
คำอธิบาย: บริษัทต้องการให้พนักงานแต่ละคนทำงานอย่างน้อย 6 ชั่วโมง มีพนักงาน 0 คนที่บรรลุเป้าหมายนี้

ข้อจำกัด:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

มีพนักงาน n คนในบริษัท หมายเลขตั้งแต่ 0 ถึง n - 1 พนักงานแต่ละคนฉันทํางานเป็นเวลาหลายชั่วโมงในบริษัท
บริษัทกําหนดให้พนักงานแต่ละคนต้องทํางานอย่างน้อยชั่วโมงเป้าหมาย
คุณจะได้รับอาร์เรย์ที่มีดัชนี 0 ของจํานวนเต็มที่ไม่ใช่ลบ ชั่วโมงที่มีความยาว n และเป้าหมายจํานวนเต็มที่ไม่ใช่ลบ
ส่งกลับจํานวนเต็มที่แสดงถึงจํานวนพนักงานที่ทํางานอย่างน้อยชั่วโมงเป้าหมาย

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

อินพุต: hours = [0,1,2,3,4], target = 2
เอาท์พุต: 3
คําอธิบาย: บริษัทต้องการให้พนักงานแต่ละคนทํางานอย่างน้อย 2 ชั่วโมง
- พนักงาน 0 ทํางานเป็นเวลา 0 ชั่วโมงและไม่บรรลุเป้าหมาย
- พนักงานที่ 1 ทํางาน 1 ชั่วโมง และไม่เป็นไปตามเป้าหมาย
- พนักงานที่ 2 ทํางาน 2 ชั่วโมง และบรรลุเป้าหมาย
- พนักงาน 3 ทํางาน 3 ชั่วโมง และบรรลุเป้าหมาย
- พนักงานที่ 4 ทํางาน 4 ชั่วโมง และบรรลุเป้าหมาย
มีพนักงาน 3 คนที่บรรลุเป้าหมาย

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

อินพุต: hours = [5,1,4,2,2], target = 6
เอาท์พุต: 0
คําอธิบาย: บริษัทต้องการให้พนักงานแต่ละคนทํางานอย่างน้อย 6 ชั่วโมง
มีพนักงานที่บรรลุเป้าหมาย 0 คน

ข้อจํากัด:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5