เมื่อมีสตริงสามตัวคือ a, b และ c งานของคุณคือค้นหาสตริงที่มีความยาวขั้นต่ำและมีสตริงทั้งสามตัวเป็นสตริงย่อย
หากมีสตริงดังกล่าวหลายตัว ให้ส่งคืนสตริงที่เล็กที่สุดตามพจนานุกรม
ส่งคืนสตริงที่ระบุคำตอบของปัญหา
หมายเหตุ

สตริง a มีขนาดเล็กกว่าสตริง b ตามพจนานุกรม (มีความยาวเท่ากัน) หากในตำแหน่งแรกที่ a และ b แตกต่างกัน สตริง a จะมีตัวอักษรที่ปรากฏก่อนตัวอักษรที่สอดคล้องกันใน b ในตัวอักษรภาษาอังกฤษ
สตริงย่อยคือลำดับอักขระที่ต่อเนื่องกันภายในสตริง

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

อินพุต: a = "abc", b = "bca", c = "aaa"
เอาต์พุต: "aaabca"
คำอธิบาย: เราจะแสดงให้เห็นว่า "aaabca" มีสตริงที่กำหนดให้ทั้งหมด: a = ans[2...4], b = ans[3..5], c = ans[0..2] จะเห็นได้ว่าความยาวของสตริงที่ได้จะมีอย่างน้อย 6 และ "aaabca" เป็นสตริงที่เล็กที่สุดในพจนานุกรม
ตัวอย่างที่ 2:

อินพุต: a = "ab", b = "ba", c = "aba"
เอาต์พุต: "aba"
คำอธิบาย: เราจะแสดงให้เห็นว่าสตริง "aba" มีสตริงทั้งหมดที่กำหนดไว้: a = ans[0..1], b = ans[1..2], c = ans[0..2] เนื่องจากความยาวของ c คือ 3 ความยาวของสตริงที่ได้จะมีอย่างน้อย 3 จะเห็นได้ว่า "aba" เป็นสตริงที่เล็กที่สุดในพจนานุกรม

ข้อจำกัด:

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

เมื่อกําหนดสามสาย a, b และ c งานของคุณคือค้นหาสตริงที่มีความยาวต่ําสุดและมีสตริงทั้งสามเป็นสตริงย่อย
หากมีสตริงดังกล่าวหลายสตริง ให้ส่งคืนสตริงที่เล็กที่สุดตามพจนานุกรม
ส่งคืนสตริงที่แสดงถึงคําตอบของปัญหา
หมาย เหตุ

สตริง a มีขนาดเล็กกว่าสตริง b (ที่มีความยาวเท่ากัน) หากในตําแหน่งแรกที่ a และ b ต่างกัน สตริง a มีตัวอักษรที่ปรากฏในตัวอักษรก่อนหน้าตัวอักษรมากกว่าตัวอักษรที่สอดคล้องกันใน b
สตริงย่อยคือลําดับอักขระที่ต่อเนื่องกันภายในสตริง

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

อินพุต: a = "abc", b = "bca", c = "aaa"
เอาต์พุต: "aaabca"
คําอธิบาย: เราแสดงให้เห็นว่า "aaabca" มีสตริงที่กําหนดทั้งหมด: a = ans[2...4], b = ans[3..5], c = ans[0..2] สามารถแสดงให้เห็นได้ว่าความยาวของสตริงผลลัพธ์จะมีอย่างน้อย 6 และ "aaabca" เป็นสตริงที่เล็กที่สุดในพจนานุกรม
ตัวอย่างที่ 2:

อินพุต: a = "ab", b = "ba", c = "aba"
เอาต์พุต: "aba"
คําอธิบาย: เราแสดงให้เห็นว่าสตริง "aba" มีสตริงที่กําหนดทั้งหมด: a = ans[0..1], b = ans[1..2], c = ans[0..2] เนื่องจากความยาวของ c คือ 3 ความยาวของสตริงผลลัพธ์จึงเป็นอย่างน้อย 3 สามารถแสดงให้เห็นว่า "aba" เป็นพจนานุกรมที่เล็กที่สุด

ข้อจํากัด:

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

ให้สตริงสามตัว a, b, และ c งานของคุณคือการหาสตริงที่มีความยาวน้อยที่สุดและมีสตริงทั้งสามเป็นซับสตริง ถ้ามีสตริงดังกล่าวหลายสตริง ให้คืนสตริงที่เรียงตามตัวอักษรเป็นลำดับที่น้อยที่สุด ส่งคืนสตริงที่ระบุคำตอบของปัญหา

หมายเหตุ

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

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

Input: a = "abc", b = "bca", c = "aaa"
Output: "aaabca"
คำอธิบาย: เราเห็นได้ว่า "aaabca" มีสตริงที่ให้มาทั้งหมดเป็นซับสตริง: a = ans[2...4], b = ans[3..5], c = ans[0..2]. สามารถแสดงได้ว่าความยาวของสตริงผลลัพธ์จะต้องมีอย่างน้อย  6 และ "aaabca" คือสตริงที่เรียงตามลำดับอักษรที่เล็กที่สุด
ตัวอย่างที่ 2:

Input: a = "ab", b = "ba", c = "aba"
Output: "aba"
คำอธิบาย: เราเห็นได้ว่าสตริง "aba" มีสตริงที่ให้มาทั้งหมดเป็นซับสตริง: a = ans[0..1], b = ans[1..2], c = ans[0..2]. เมื่อความยาวของ c คือ 3 ความยาวของสตริงผลลัพธ์จะต้องมีอย่างน้อย  3 สามารถแสดงได้ว่า "aba" คือสตริงที่เรียงตามลำดับอักษรที่เล็กที่สุด

ข้อจำกัด:

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


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

เลือกซับอาร์เรย์ขนาด k จากอาร์เรย์และลดค่าทุกองค์ประกอบในซับอาร์เรย์นั้นลง 1

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

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

Input: nums = [2,2,3,1,1,0], k = 3
Output: true
คำอธิบาย: เราสามารถทำการดำเนินการต่อไปนี้ได้:
- เลือกซับอาเรย์ [2,2,3]. อาเรย์ที่ได้จะเป็น nums = [1,1,2,1,1,0].
- เลือกซับอาเรย์ [2,1,1]. อาเรย์ที่ได้จะเป็น nums = [1,1,1,0,0,0].
- เลือกซับอาเรย์ [1,1,1]. อาเรย์ที่ได้จะเป็น nums = [0,0,0,0,0,0].

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

Input: nums = [1,3,1,1], k = 2
Output: false
คำอธิบาย: ไม่สามารถทำให้สมาชิกในอาเรย์ทั้งหมดเท่ากับ 0 ได้

ข้อจำกัด:

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

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

เลือกอาร์เรย์ย่อยขนาด k จากอาร์เรย์และลดองค์ประกอบทั้งหมดลง 1

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

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

อินพุต: nums = [2,2,3,1,1,0], k = 3
เอาต์พุต: true
คำอธิบาย: เราสามารถดำเนินการต่อไปนี้ได้:
- เลือกอาร์เรย์ย่อย [2,2,3] อาร์เรย์ที่ได้จะเป็น nums = [1,1,2,1,1,0]
- เลือกอาร์เรย์ย่อย [2,1,1] อาร์เรย์ที่ได้จะเป็น nums = [1,1,1,0,0,0] - เลือกอาร์เรย์ย่อย [1,1,1] อาร์เรย์ที่ได้จะเป็น nums = [0,0,0,0,0,0]

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

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

ข้อจำกัด:

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

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

เลือกอาร์เรย์ย่อยที่มีขนาด k จากอาร์เรย์และลดองค์ประกอบทั้งหมดลง 1

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

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

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

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

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

ข้อจํากัด:

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


กำหนดสตริง s และจำนวนเต็ม k ให้แบ่ง s ออกเป็นซับสตริง k สตริงเพื่อให้ผลรวมของจำนวนการเปลี่ยนแปลงตัวอักษรที่จำเป็นในการทำให้ซับสตริงแต่ละตัวเป็นเซมิพาลินโดรมน้อยที่สุด
ส่งกลับจำนวนเต็มที่แสดงถึงจำนวนการเปลี่ยนแปลงตัวอักษรขั้นต่ำที่จำเป็น
หมายเหตุ

สตริงเป็นพาลินโดรมหากสามารถอ่านได้ในลักษณะเดียวกันจากซ้ายไปขวาและจากขวาไปซ้าย
สตริงที่มีความยาว len ถือเป็นเซมิพาลินโดรมหากมีจำนวนเต็มบวก d ที่ทำให้ 1 <= d < len และ len % d == 0 และหากเราใช้ดัชนีที่มีโมดูโลเท่ากันโดย d ดัชนีเหล่านั้นจะสร้างเป็นพาลินโดรม ตัวอย่างเช่น "aa" "aba" "adbgad" และ "abab" เป็นเซมิพาลินโดรม ส่วน "a" "ab" และ "abca" ไม่ใช่
ซับสตริงคือลำดับอักขระที่ต่อเนื่องกันภายในสตริง
ตัวอย่างที่ 1:

อินพุต: s = "abcac", k = 2
เอาต์พุต: 1
คำอธิบาย: เราสามารถแบ่ง s ออกเป็นซับสตริง "ab" และ "cac" สตริง "cac" เป็นเซมิพาลินโดรมอยู่แล้ว หากเราเปลี่ยน "ab" เป็น "aa" สตริงนั้นจะกลายเป็นเซมิพาลินโดรมโดยที่ d = 1
จะเห็นว่าไม่มีวิธีใดที่จะแบ่งสตริง "abcac" ออกเป็นซับสตริงเซมิพาลินโดรมสองอัน ดังนั้น คำตอบจะต้องเป็นอย่างน้อย 1
ตัวอย่างที่ 2:

อินพุต: s = "abcdef", k = 2
เอาต์พุต: 2
คำอธิบาย: เราสามารถแบ่งสตริงดังกล่าวออกเป็นซับสตริง "abc" และ "def" ซับสตริง "abc" และ "def" แต่ละอันต้องมีการเปลี่ยนแปลงหนึ่งครั้งจึงจะกลายเป็นเซมิพาลินโดรม ดังนั้น เราจึงต้องมีการเปลี่ยนแปลงทั้งหมด 2 ครั้งเพื่อให้ซับสตริงทั้งหมดเป็นเซมิพาลินโดรม จะเห็นได้ว่าเราไม่สามารถแบ่งสตริงที่กำหนดให้เป็นสองสตริงย่อยได้ในลักษณะที่ต้องมีการเปลี่ยนแปลงน้อยกว่า 2 ครั้ง
ตัวอย่างที่ 3:

อินพุต: s = "aabbaa", k = 3
เอาต์พุต: 0
คำอธิบาย: เราสามารถแบ่งสตริงย่อยเป็น "aa", "bb" และ "aa"
สตริง "aa" และ "bb" เป็นเซมิพาลินโดรมอยู่แล้ว ดังนั้น คำตอบคือศูนย์

ข้อจำกัด:

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

กำหนดสตริง s และจำนวนเต็ม k ให้แบ่ง s ออกเป็นซับสตริง k สตริงเพื่อให้ผลรวมของจำนวนการเปลี่ยนแปลงตัวอักษรที่จำเป็นในการเปลี่ยนซับสตริงแต่ละตัวให้เป็นเซมิพาลินโดรมลดลง
ส่งกลับจำนวนเต็มที่แสดงถึงจำนวนการเปลี่ยนแปลงตัวอักษรขั้นต่ำที่จำเป็น
หมายเหตุ

สตริงเป็นพาลินโดรมหากสามารถอ่านได้ในลักษณะเดียวกันจากซ้ายไปขวาและจากขวาไปซ้าย
สตริงที่มีความยาว len ถือเป็นเซมิพาลินโดรมหากมีจำนวนเต็มบวก d ที่ทำให้ 1 <= d < len และ len % d == 0 และหากเราใช้ดัชนีที่มีโมดูโลเท่ากันโดย d ดัชนีเหล่านั้นจะสร้างเป็นพาลินโดรม ตัวอย่างเช่น "aa" "aba" "adbgad" และ "abab" เป็นเซมิพาลินโดรม ส่วน "a" "ab" และ "abca" ไม่ใช่
ซับสตริงคือลำดับอักขระที่ต่อเนื่องกันภายในสตริง

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

อินพุต: s = "abcac", k = 2
เอาต์พุต: 1
คำอธิบาย: เราสามารถแบ่ง s ออกเป็นซับสตริง "ab" และ "cac" สตริง "cac" เป็นเซมิพาลินโดรมอยู่แล้ว หากเราเปลี่ยน "ab" เป็น "aa" สตริงนั้นจะกลายเป็นเซมิพาลินโดรมโดยที่ d = 1
จะเห็นว่าไม่มีวิธีใดที่จะแบ่งสตริง "abcac" ออกเป็นซับสตริงเซมิพาลินโดรมสองอัน ดังนั้น คำตอบจะต้องเป็นอย่างน้อย 1
ตัวอย่างที่ 2:

อินพุต: s = "abcdef", k = 2
เอาต์พุต: 2
คำอธิบาย: เราสามารถแบ่งสตริงดังกล่าวออกเป็นซับสตริง "abc" และ "def" ซับสตริง "abc" และ "def" แต่ละอันต้องมีการเปลี่ยนแปลงหนึ่งครั้งจึงจะกลายเป็นเซมิพาลินโดรม ดังนั้น เราจึงต้องมีการเปลี่ยนแปลงทั้งหมด 2 ครั้งเพื่อให้ซับสตริงทั้งหมดเป็นเซมิพาลินโดรม จะเห็นได้ว่าเราไม่สามารถแบ่งสตริงที่กำหนดให้เป็นสองสตริงย่อยได้ในลักษณะที่ต้องมีการเปลี่ยนแปลงน้อยกว่า 2 ครั้ง
ตัวอย่างที่ 3:

อินพุต: s = "aabbaa", k = 3
เอาต์พุต: 0
คำอธิบาย: เราสามารถแบ่งสตริงย่อยเป็น "aa", "bb" และ "aa"
สตริง "aa" และ "bb" เป็นเซมิพาลินโดรมอยู่แล้ว ดังนั้น คำตอบคือศูนย์

ข้อจำกัด:

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

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

สตริงเป็นพาลินโดรมถ้าสามารถอ่านได้จากซ้ายไปขวาและจากขวาไปซ้ายได้
สตริงที่มีความยาว len ถือว่าเป็นกึ่งพาลินโดรมถ้ามีจำนวนเต็มบวก  d  ที่ทำให้  1 <= d < lenและ len % d == 0, และถ้าเรานำดัชนีที่มีค่าโมดูลูเดียวกันโดย  d  มารวมกัน พวกมันจะกลายเป็นพาลินโดรม ตัวอย่างเช่น "aa", "aba", "adbgad", และ "abab" เป็นกึ่งพาลินโดรม และ "a", "ab", และ "abca" ไม่ใช่
สตริงย่อยคือชุดของตัวอักษรที่ต่อเนื่องกันภายในสตริง

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

Input: s = "abcac", k = 2
Output: 1
คำอธิบาย: เราสามารถแบ่ง  s เป็นสตริงย่อย "ab" และ "cac" สตริง "cac" เป็นกึ่งพาลินโดรมอยู่แล้ว ถ้าเราเปลี่ยน "ab" เป็น "aa" มันจะกลายเป็นกึ่งพาลินโดรมพร้อมด้วย  d = 1
สามารถแสดงให้เห็นได้ว่าไม่มีวิธีใดที่จะแบ่งสตริง "abcac" เป็นสตริงย่อยกึ่งพาลินโดรม สองสตริง ดังนั้นคำตอบจะเป็นอย่างน้อย 1

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

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

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

Input: s = "aabbaa", k = 3
Output: 0
คำอธิบาย: เราสามารถแบ่งมันเป็นสตริงย่อย "aa", "bb" และ "aa"
สตริง "aa" และ "bb" เป็นกึ่งพาลินโดรมอยู่แล้ว ดังนั้นคำตอบคือศูนย์

ข้อกำหนด:

\( 2 \leq s.length \leq 200 \)
\( 1 \leq k \leq s.length / 2 \)
 s ประกอบไปด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


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

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

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

Input: words = ["one.two.three","four.five","six"], separator = "."
Output: ["one","two","three","four","five","six"]
ในตัวอย่างนี้เราจะแบ่งออกเป็นดังนี้:

"one.two.three" แยกเป็น "one", "two", "three"
"four.five" แยกเป็น "four", "five"
"six" แยกเป็น "six"

ดังนั้น อาร์เรย์ที่ได้คือ ["one","two","three","four","five","six"]
ตัวอย่างที่ 2:

Input: words = ["$easy$","$problem$"], separator = "$"
Output: ["easy","problem"]
คำอธิบาย: ในตัวอย่างนี้เราจะแบ่งออกเป็นดังนี้:

"$easy$" แยกเป็น "easy" (ไม่รวมสตริงว่าง)
"$problem$" แยกเป็น "problem" (ไม่รวมสตริงว่าง)

ดังนั้น อาร์เรย์ที่ได้คือ ["easy","problem"]
ตัวอย่างที่ 3:

Input: words = ["|||"], separator = "|"
Output: []
คำอธิบาย: ในตัวอย่างนี้ ผลลัพธ์จากการแบ่ง "|||" จะประกอบด้วยแต่สตริงว่างเท่านั้น ดังนั้นเราจึงส่งคืนอาเรย์ว่าง []

ข้อจำกัด:

1 <= words.length <= 100
1 <= words[i].length <= 20
ตัวอักษรใน words[i] เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กหรืออักขระจากสตริง ".,|$#@" (ไม่รวมเครื่องหมายคำพูด) ตัวแบ่งคืออักขระจากสตริง ".,|$#@" (ไม่รวมเครื่องหมายคำพูด)

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

ตัวคั่นใช้เพื่อกำหนดว่าควรแยกที่ใด แต่จะไม่รวมอยู่ในสตริงผลลัพธ์
การแยกอาจส่งผลให้มีสตริงมากกว่าสองสตริง
สตริงผลลัพธ์จะต้องรักษาลำดับเดียวกันกับที่กำหนดไว้ในตอนแรก

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

อินพุต: words = ["one.two.three","four.five","six"], separator = "."
ผลลัพธ์: ["one","two","three","four","five","six"]
คำอธิบาย: ในตัวอย่างนี้ เราแบ่งดังนี้:

"one.two.three" แยกเป็น "one", "two", "three"
"four.five" แยกเป็น "four", "five"
"six" แยกเป็น "six"

ดังนั้น อาร์เรย์ผลลัพธ์คือ ["one","two","three","four","five","six"]
ตัวอย่างที่ 2:

อินพุต: words = ["$easy$","$problem$"], separator = "$"
ผลลัพธ์: ["easy","problem"]
คำอธิบาย: ในตัวอย่างนี้ เราแบ่งดังนี้:

"$easy$" แยกเป็น "easy" (ไม่รวมสตริงว่าง)
"$problem$" แยกเป็น "problem" (ไม่รวมสตริงว่าง)

ดังนั้น อาร์เรย์ผลลัพธ์คือ ["easy","problem"]

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

อินพุต: words = ["|||"], separator = "|"
เอาต์พุต: []
คำอธิบาย: ในตัวอย่างนี้ การแยก "|||" ที่เกิดขึ้นจะมีเฉพาะสตริงว่างเท่านั้น ดังนั้นเราจึงส่งคืนอาร์เรย์ว่าง []

ข้อจำกัด:

1 <= words.length <= 100
1 <= words[i].length <= 20
อักขระใน words[i] จะเป็นตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กหรืออักขระจากสตริง ".,|$#@" (ไม่รวมเครื่องหมายคำพูด)
separator คืออักขระจากสตริง ".,|$#@" (ไม่รวมเครื่องหมายคำพูด)

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

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

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

อินพุต: words = ["one.two.three","four.five","six"], separator = "."
เอาท์พุท: ["one","two","three","four","five","six"]
คำอธิบาย: ในตัวอย่างนี้เราแยกดังนี้:

"one.two.three" แยกออกเป็น "one", "two", "three"
"Four.Five" แยกออกเป็น "Four", "Five"
"six" แบ่งออกเป็น "six"

ดังนั้นอาร์เรย์ที่ได้คือ ["one","two","three","four","five","six"].
ตัวอย่างที่ 2:

อินพุต: words = ["$easy$","$problem$"], separator = "$"
เอาท์พุท: ["easy","problem"]
คำอธิบาย: ในตัวอย่างนี้เราแยกดังนี้:

"$ easy $" แยกออกเป็น "Easy" (ไม่รวมสายว่าง)
"$ problem $" แบ่งออกเป็น "problem" (ไม่รวมสตริงที่ว่างเปล่า)

ดังนั้นอาร์เรย์ที่ได้คือ ["easy","problem"]

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

อินพุต: words = ["|||"], separator = "|"
เอาท์พุท: []
คำอธิบาย: ในตัวอย่างนี้การแยกผลลัพธ์ของ "|||" จะมีเฉพาะสตริงที่ว่างเปล่าดังนั้นเราจึงส่งคืนอาร์เรย์ที่ว่างเปล่า []

ข้อ จำกัด :

1 <= words.length <= 100
1 <= words[i].length <= 20
ตัวละครในคำพูด [i] เป็นตัวพิมพ์เล็กหรือตัวอักษรภาษาอังกฤษจากสตริง "., | $#@" (ไม่รวมคำพูด)
ตัวคั่นเป็นอักขระจากสตริง "., | $#@" (ไม่รวมคำพูด)


กำหนดจำนวนเต็มบวกสองจำนวนคือ n และ x

ส่งคืนจำนวนวิธีที่ n สามารถแสดงเป็นผลรวมของกำลัง x ของจำนวนเต็มบวกที่ไม่ซ้ำกัน กล่าวอีกนัยหนึ่งคือ จำนวนชุดของจำนวนเต็มที่ไม่ซ้ำกัน [n_1, n_2, ..., n_k] โดยที่ n = n_1^x + n_2^x + ... + n_k^x

เนื่องจากผลลัพธ์อาจมีค่ามาก ให้ส่งคืนโมดูโล 10^9 + 7

ตัวอย่างเช่น หาก n = 160 และ x = 3 วิธีหนึ่งในการแสดง n คือ n = 2^3 + 3^3 + 5^3

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

อินพุต: n = 10, x = 2
เอาต์พุต: 1
คำอธิบาย: เราสามารถแสดง n ได้ดังนี้: n = 3^2 + 1^2 = 10
สามารถแสดงให้เห็นได้ว่านี่เป็นวิธีเดียวในการแสดง 10 เป็นผลรวมของเลขยกกำลังสองของจำนวนเต็มที่ไม่ซ้ำกัน

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

อินพุต: n = 4, x = 1
เอาต์พุต: 2
คำอธิบาย: เราสามารถแสดง n ได้ดังนี้:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

ข้อจำกัด:

1 <= n <= 300
1 <= x <= 5

ให้จำนวนเต็มบวกสองจำนวน n และ x
คืนค่าจำนวนวิธีที่ n สามารถแสดงเป็นผลรวมของพลัง x ของจำนวนเต็มบวกที่ไม่ซ้ำกัน กล่าวอีกนัยหนึ่งคือ จำนวนชุดของจำนวนเต็มที่ไม่ซ้ำกัน [n_1, n_2, ..., n_k] ที่ทำให้ n = n_1^x + n_2^x + ... + n_k^x
เนื่องจากผลลัพธ์อาจมีค่ามาก จึงให้คืนค่าเป็นโมดูล 10^9 + 7
ตัวอย่างเช่น หาก n = 160 และ x = 3 หนึ่งในวิธีการแสดง n คือ n = 2^3 + 3^3 + 5^3

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

Input: n = 10, x = 2
Output: 1
คำอธิบาย: เราสามารถแสดง n ได้ดังนี้: n = 3^2 + 1^2 = 10
สามารถแสดงให้เห็นได้ว่านี่เป็นวิธีเดียวในการแสดง 10 เป็นผลรวมของกำลังสองของจำนวนเต็มที่ไม่ซ้ำกัน

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

Input: n = 4, x = 1
Output: 2
คำอธิบาย: เราสามารถแสดง n ในรูปแบบต่อไปนี้:
- n = 4^1 = 4
- n = 3^1 + 1^1 = 4

ข้อจำกัด:

1 <= n <= 300
1 <= x <= 5

ให้จํานวนเต็มบวกสองตัว n และ x
ส่งคืนจํานวนวิธีที่ n สามารถแสดงเป็นผลรวมของยกกําลัง x^ ของจํานวนเต็มบวกที่ไม่ซ้ํากันกล่าวอีกนัยหนึ่งคือจํานวนชุดของจํานวนเต็มที่ไม่ซ้ํากัน [n_1, n_2, ..., n_k] โดยที่ n = n_1^x + n_2^x + ... + n_k^x
เนื่องจากผลลัพธ์อาจมีขนาดใหญ่มาก ให้ส่งคืนโมดูโล 10^9 + 7
ตัวอย่างเช่น ถ้า n = 160 และ x = 3 วิธีหนึ่งในการแสดง n คือ n = 2^3 + 3^3 + 5^3

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

อินพุต: n = 10, x = 2
เอาท์พุต: 1
คําอธิบาย: เราสามารถแสดง n ได้ดังนี้: n = 3^2 + 1^2 = 10
สามารถแสดงให้เห็นได้ว่าเป็นวิธีเดียวที่จะแสดง 10 เป็นผลรวมของยกกําลัง 2^nd ของจํานวนเต็มที่ไม่ซ้ํากัน

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

อินพุต: n = 4, x = 1
เอาท์พุต: 2
คําอธิบาย: เราสามารถแสดง n ได้ด้วยวิธีต่อไปนี้:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

ข้อจํากัด:

1 <= n <= 300
1 <= x <= 5


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

ไม่มีเลขศูนย์นำหน้า
เป็นการแสดงเลขฐานสองของตัวเลขที่มีเลขยกกำลัง 5

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

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

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

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

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

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

อินพุต: s = "0"
เอาต์พุต: -1
คำอธิบาย: เราไม่สามารถแบ่งพาร์ติชั่นสตริงที่กำหนดเป็นสตริงย่อยที่สวยงามได้

ข้อจำกัด:

1 <= s.length <= 15
s[i] คือ '0' หรือ '1'

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

มันไม่มีศูนย์นำ
มันเป็นตัวแทนไบนารีของตัวเลขที่เป็นกำลังของ 5

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

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

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

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

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

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

อินพุต: s = "0"
เอาท์พุท: -1
คำอธิบาย: เราไม่สามารถแบ่งพาร์ติชันสตริงที่กำหนดเป็นย่อยที่สวยงาม

ข้อ จำกัด :

1 <= s.length <= 15
S [i] คือ '0' หรือ '1'


คุณได้รับสตริงคำ (word) และอาร์เรย์ของสตริงที่ถูกห้าม (forbidden)
สตริงจะถูกเรียกว่าถูกต้อง (valid) หากไม่มีซับสตริงใด ๆ ของมันที่ปรากฏในรายการที่ถูกห้าม
ให้คืนค่าความยาวของซับสตริงที่ถูกต้อง (valid substring) ที่ยาวที่สุดในสตริงคำ
ซับสตริงคือชุดของอักขระที่ต่อเนื่องกันในสตริง ซึ่งอาจเป็นค่าว่างก็ได้

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

Input: word = "cbaaaabc", forbidden = ["aaa","cb"]
Output: 4
คำอธิบาย: มี 11 สตริงย่อยที่ถูกต้องในคำว่า: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" และ "aabc" ความยาวของสตริงย่อยที่ถูกต้องที่ยาวที่สุดคือ 4 สามารถแสดงให้เห็นได้ว่าสตริงย่อยอื่น ๆ ทั้งหมดมี "aaa" หรือ "cb" เป็นสตริงย่อย

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

Input: word = "leetcode", forbidden = ["de","le","e"]
Output: 4
คำอธิบาย: มี 11 สตริงย่อยที่ถูกต้องในคำว่า: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod", และ "tcod" ความยาวของสตริงย่อยที่ถูกต้องที่ยาวที่สุดคือ 4 สามารถแสดงให้เห็นได้ว่าสตริงย่อยอื่น ๆ ทั้งหมดมี "de", "le" หรือ "e" เป็นสตริงย่อย

ข้อจำกัด:

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

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

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

อินพุต: word = "cbaaaabc", forbidden = ["aaa","cb"]
เอาต์พุต: 4
คำอธิบาย: มีซับสตริงที่ถูกต้อง 11 ตัวใน word: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" และ "aabc" ความยาวของซับสตริงที่ถูกต้องที่ยาวที่สุดคือ 4

สามารถแสดงให้เห็นได้ว่าซับสตริงอื่นๆ ทั้งหมดมี "aaa" หรือ "cb" เป็นซับสตริง ตัวอย่างที่ 2:

อินพุต: word = "leetcode", forbidden = ["de","le","e"]
เอาต์พุต: 4
คำอธิบาย: มีสตริงย่อยที่ถูกต้อง 11 รายการใน word: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" และ "tcod" ความยาวของสตริงย่อยที่ถูกต้องที่ยาวที่สุดคือ 4
สามารถแสดงให้เห็นว่าสตริงย่อยอื่นๆ ทั้งหมดมี "de", "le" หรือ "e" เป็นสตริงย่อย

ข้อจำกัด:

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

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

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

อินพุต: word = "cbaaaabc", forbidden = ["aaa", "cb"]
เอาท์พุท: 4
คำอธิบาย: มี 11 substrings ที่ถูกต้องในword: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" และ "aabc" ความยาวของสตริงย่อยที่ถูกต้องยาวที่สุดคือ 4
มันสามารถแสดงให้เห็นว่าพื้นผิวอื่น ๆ ทั้งหมดมีทั้ง "aaa" หรือ "cb" เป็นสายย่อย
ตัวอย่างที่ 2:

อินพุต: word = "leetcode", forbidden = ["de", "le", "e"]
เอาท์พุท: 4
คำอธิบาย: มี 11 substrings ที่ถูกต้องใน word: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod", และ "tcod" ความยาวของสตริงย่อยที่ถูกต้องยาวที่สุดคือ 4
มันสามารถแสดงให้เห็นว่าหมวดย่อยอื่น ๆ ทั้งหมดมีทั้ง "de", "le" หรือ "e" เป็นสายย่อย

ข้อ จำกัด :

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


แป้นพิมพ์แล็ปท็อปของคุณมีปัญหา และเมื่อใดก็ตามที่คุณพิมพ์อักขระ 'i' บนแป้นพิมพ์ แป้นพิมพ์จะย้อนกลับสตริงที่คุณเขียน การพิมพ์อักขระอื่นๆ จะทำงานตามที่คาดไว้
คุณจะได้รับสตริง s ที่มีดัชนี 0 และคุณพิมพ์อักขระแต่ละตัวของ s โดยใช้แป้นพิมพ์ที่มีข้อผิดพลาด
ส่งคืนสตริงสุดท้ายที่จะปรากฏบนหน้าจอแล็ปท็อปของคุณ

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

อินพุต:  s = "string"
เอาต์พุต: "rtsng"
คำอธิบาย:
หลังจากพิมพ์อักขระแรก ข้อความบนหน้าจอจะเป็น "s"

หลังจากอักขระที่สอง ข้อความจะเป็น "st"
หลังจากอักขระที่สาม ข้อความจะเป็น "str"
เนื่องจากอักขระที่สี่เป็น 'i' ข้อความจึงย้อนกลับและกลายเป็น "rts"
หลังจากอักขระที่ห้า ข้อความจะเป็น "rtsn"
หลังจากอักขระที่หก ข้อความจะเป็น "rtsng"
ดังนั้น เราจึงส่งคืน "rtsng"

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

อินพุต: s = "poiinter"
เอาต์พุต: "ponter"
คำอธิบาย:
หลังจากอักขระตัวแรก ข้อความบนหน้าจอจะเป็น "p"
หลังจากอักขระตัวที่สอง ข้อความจะเป็น "po"
เนื่องจากอักขระตัวที่สามที่คุณพิมพ์เป็น 'i' ข้อความจึงกลับด้านและกลายเป็น "op"
เนื่องจากอักขระตัวที่สี่ที่คุณพิมพ์เป็น 'i' ข้อความจึงกลับด้านและกลายเป็น "po"
หลังจากอักขระตัวที่ห้า ข้อความจะเป็น "pon"
หลังจากอักขระตัวที่หก ข้อความจะเป็น "pont"
หลังจากอักขระตัวที่เจ็ด ข้อความจะเป็น "ponte"
หลังจากอักขระตัวที่แปด ข้อความจะเป็น "ponter"
ดังนั้น เราจึงส่งคืน "ponter"

ข้อจำกัด:

1 <= s.length <= 100
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
s[0] != 'i'

Your laptop keyboard is faulty, and whenever you type a character 'i' on it, it reverses the string that you have written. Typing other characters works as expected.
You are given a 0-indexed string s, and you type each character of s using your faulty keyboard.
Return the final string that will be present on your laptop screen.

Example 1:

Input: s = "string"
Output: "rtsng"
Explanation:
After typing first character, the text on the screen is "s".
After the second character, the text is "st".
After the third character, the text is "str".
Since the fourth character is an 'i', the text gets reversed and becomes "rts".
After the fifth character, the text is "rtsn".
After the sixth character, the text is "rtsng".
Therefore, we return "rtsng".

Example 2:

Input: s = "poiinter"
Output: "ponter"
Explanation:
After the first character, the text on the screen is "p".
After the second character, the text is "po".
Since the third character you type is an 'i', the text gets reversed and becomes "op".
Since the fourth character you type is an 'i', the text gets reversed and becomes "po".
After the fifth character, the text is "pon".
After the sixth character, the text is "pont".
After the seventh character, the text is "ponte".
After the eighth character, the text is "ponter".
Therefore, we return "ponter".

Constraints:

1 <= s.length <= 100
s consists of lowercase English letters.
s[0] != 'i'

แป้นพิมพ์แล็ปท็อปของคุณมีปัญหา และเมื่อใดก็ตามที่คุณพิมพ์อักขระ 'i' บนแป้นพิมพ์ แป้นพิมพ์จะย้อนกลับสตริงที่คุณเขียน การพิมพ์อักขระอื่นๆ จะทำงานตามที่คาดไว้
คุณจะได้รับสตริง s ที่มีดัชนี 0 และคุณพิมพ์อักขระแต่ละตัวของ s โดยใช้แป้นพิมพ์ที่มีข้อผิดพลาด
ส่งคืนสตริงสุดท้ายที่จะปรากฏบนหน้าจอแล็ปท็อปของคุณ

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

อินพุต: s = "สตริง"
เอาต์พุต: "rtsng"
คำอธิบาย:
หลังจากพิมพ์อักขระแรก ข้อความบนหน้าจอจะเป็น "s"
หลังจากอักขระที่สอง ข้อความจะเป็น "st"
หลังจากอักขระที่สาม ข้อความจะเป็น "str"
เนื่องจากอักขระที่สี่เป็น 'i' ข้อความจึงย้อนกลับและกลายเป็น "rts"
หลังจากอักขระที่ห้า ข้อความจะเป็น "rtsn"
หลังจากอักขระที่หก ข้อความจะเป็น "rtsng"
ดังนั้น เราจึงส่งคืน "rtsng"

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

อินพุต: s = "poiinter"
เอาต์พุต: "ponter"
คำอธิบาย:
หลังจากอักขระตัวแรก ข้อความบนหน้าจอจะเป็น "p"
หลังจากอักขระตัวที่สอง ข้อความจะเป็น "po"
เนื่องจากอักขระตัวที่สามที่คุณพิมพ์เป็น 'i' ข้อความจึงกลับด้านและกลายเป็น "op"
เนื่องจากอักขระตัวที่สี่ที่คุณพิมพ์เป็น 'i' ข้อความจึงกลับด้านและกลายเป็น "po"
หลังจากอักขระตัวที่ห้า ข้อความจะเป็น "pon"
หลังจากอักขระตัวที่หก ข้อความจะเป็น "pont"
หลังจากอักขระตัวที่เจ็ด ข้อความจะเป็น "ponte"
หลังจากอักขระตัวที่แปด ข้อความจะเป็น "ponter"
ดังนั้น เราจึงส่งคืน "ponter"

ข้อจำกัด:

1 <= s.length <= 100
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
s[0] != 'i'


ให้พิจารณาสตริง s ที่มีดัชนีเริ่มต้นที่ 0 ทำการจัดเรียง s ใหม่เพื่อให้ได้สตริง t ใหม่ที่มีคุณสมบัติดังนี้:

อักษรพยัญชนะทั้งหมดจะต้องอยู่ในตำแหน่งเดิมของพวกเขา กล่าวคือ ถ้ามีดัชนี i ที่มีค่า 0 <= i < s.length และ s[i] เป็นอักษรพยัญชนะ จะต้องมี t[i] = s[i].
อักษรสระจะต้องถูกจัดเรียงในลำดับที่ไม่ลดลงตามค่า ASCII ของพวกเขา กล่าวคือ สำหรับคู่ของดัชนี i, j ที่มีค่า 0 <= i < j < s.length และ s[i] และ s[j] เป็นอักษรสระ จะต้องมี t[i] ไม่มีค่า ASCII ที่สูงกว่าของ t[j].

คืนสตริงที่ได้ผลลัพธ์
สระคือ 'a', 'e', 'i', 'o', และ 'u' ซึ่งสามารถปรากฏในรูปตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่ได้ ส่วนพยัญชนะประกอบด้วยตัวอักษรทั้งหมดที่ไม่ใช่สระ

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

Input: s = "lEetcOde"
Output: "lEOtcede"
คำอธิบาย: 'E', 'O' และ 'e' เป็นสระใน s; 'l', 't', 'c' และ 'd' เป็นพยัญชนะทั้งหมด สระจะถูกจัดเรียงตามค่า ASCII ของพวกมัน ในขณะที่พยัญชนะจะยังคงอยู่ในตำแหน่งเดิม

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

Input: s = "lYmpH"
Output: "lYmpH"
คำอธิบาย: ไม่มีสระใน s (ตัวอักษรทั้งหมดใน s เป็นพยัญชนะ) ดังนั้นเราจึงคืนค่า "lYmpH"

ข้อจำกัด:

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

กำหนดสตริง s ที่มีดัชนี 0 ให้สับเปลี่ยน s เพื่อให้ได้สตริง t ใหม่ โดยที่:

พยัญชนะทั้งหมดจะยังคงอยู่ในตำแหน่งเดิม หากเป็นทางการมากขึ้น หากมีดัชนี i ที่มีค่า 0 <= i < s.length โดยที่ s[i] เป็นพยัญชนะ t[i] = s[i]
สระจะต้องเรียงลำดับตามลำดับค่า ASCII ที่ไม่ลดลง หากเป็นทางการมากขึ้น สำหรับคู่ดัชนี i, j ที่มีค่า 0 <= i < j < s.length โดยที่ s[i] และ s[j] เป็นสระ t[i] จะต้องไม่มีค่า ASCII ที่สูงกว่า t[j]

ส่งคืนสตริงที่ได้
สระคือ 'a', 'e', 'i', 'o' และ 'u' และสามารถปรากฏเป็นตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่ก็ได้ พยัญชนะประกอบด้วยตัวอักษรทั้งหมดที่ไม่ใช่สระ

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

อินพุต: s = "lEetcOde"
เอาต์พุต: "lEOtcede"
คำอธิบาย: 'E', 'O' และ 'e' คือสระใน s; 'l', 't', 'c' และ 'd' คือพยัญชนะทั้งหมด สระจะถูกเรียงลำดับตามค่า ASCII และพยัญชนะจะอยู่ในตำแหน่งเดียวกัน

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

อินพุต: s = "lYmpH"
เอาต์พุต: "lYmpH"
คำอธิบาย: ไม่มีสระใน s (ตัวอักษรทั้งหมดใน s เป็นพยัญชนะ) ดังนั้นเราจึงส่งคืน "lYmpH"

ข้อจำกัด:

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

ให้สตริง ￼ ที่มีดัชนีเริ่มต้นที่ 0 ทำการสลับตำแหน่งตัวอักษรใน ￼ เพื่อให้ได้สตริงใหม่ ￼ โดยที่:
	•	พยัญชนะยังคงอยู่ในตำแหน่งเดิม กล่าวคือ หากมีดัชนี ￼ โดยที่ ￼ และ ￼ เป็นพยัญชนะ จะต้องมี ￼
	•	สระต้องถูกจัดเรียงตามลำดับค่า ASCII แบบไม่ลดลง กล่าวคือ สำหรับคู่ดัชนี ￼ โดยที่ ￼ และ ￼ และ ￼ เป็นสระ จะต้องมี ￼ มีค่า ASCII ไม่มากกว่า ￼

คืนสตริงที่ได้หลังการจัดเรียง
สระได้แก่ ‘a’, ‘e’, ‘i’, ‘o’, และ ‘u’ และสามารถปรากฏได้ทั้งตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ส่วนพยัญชนะคืออักษรทุกตัวที่ไม่ใช่สระ

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

Input:

s = "lEetcOde"

Output:

"lEOtcede"

Explanation:
	•	‘E’, ‘O’, และ ‘e’ เป็นสระใน ￼
	•	‘l’, ‘t’, ‘c’, และ ‘d’ เป็นพยัญชนะทั้งหมด
	•	สระถูกจัดเรียงตามลำดับค่า ASCII และพยัญชนะคงอยู่ในตำแหน่งเดิม

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

Input:

s = "lYmpH"

Output:

"lYmpH"

Explanation:
ไม่มีสระใน ￼ (ตัวอักษรทั้งหมดใน ￼ เป็นพยัญชนะ) ดังนั้นจึงคืนค่า ￼

เงื่อนไข:
	•	1 <= s.length <= 10^5￼
	•	￼ ประกอบด้วยตัวอักษรภาษาอังกฤษทั้งตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เท่านั้น


องค์ประกอบ x ของอาร์เรย์จำนวนเต็ม arr ที่มีความยาว m จะเป็นองค์ประกอบหลักถ้า freq(x) * 2 > m โดยที่ freq(x) คือจำนวนครั้งของ x ที่เกิดขึ้นใน arr โปรดทราบว่าคำจำกัดความนี้หมายความว่า arr สามารถมีองค์ประกอบหลักได้มากที่สุดหนึ่งองค์ประกอบ
คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 จำนวน nums ที่มีความยาว n โดยมีองค์ประกอบหลักหนึ่งองค์ประกอบ
คุณสามารถแยก nums ที่ดัชนี i ออกเป็นสองอาร์เรย์ คือ nums[0, ..., i] และ nums[i + 1, ..., n - 1] แต่การแยกนั้นจะใช้ได้เฉพาะในกรณีที่:

0 <= i < n - 1
nums[0, ..., i] และ nums[i + 1, ..., n - 1] มีองค์ประกอบหลักตัวเดียวกัน

ในที่นี้ nums[i, ..., j] หมายถึงอาร์เรย์ย่อยของ nums ที่เริ่มต้นที่ดัชนี i และสิ้นสุดที่ดัชนี j โดยที่ทั้งสองจุดรวมอยู่ด้วย โดยเฉพาะอย่างยิ่ง ถ้า j < i ดังนั้น nums[i, ..., j] จะหมายถึงซับอาร์เรย์ว่าง
ส่งคืนดัชนีขั้นต่ำของการแยกที่ถูกต้อง ถ้าไม่มีการแยกที่ถูกต้อง ให้ส่งคืน -1

ตัวอย่าง 1:

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

ในอาร์เรย์ [1,2,2] องค์ประกอบ 2 เป็นตัวเด่นเนื่องจากเกิดขึ้นสองครั้งในอาร์เรย์และ 2 * 2 > 3

ในอาร์เรย์ [2] องค์ประกอบ 2 เป็นตัวเด่นเนื่องจากเกิดขึ้นหนึ่งครั้งในอาร์เรย์และ 1 * 2 > 1
ทั้ง [1,2,2] และ [2] มีองค์ประกอบหลักเหมือนกันกับ nums ดังนั้นนี่จึงเป็นการแยกที่ถูกต้อง

สามารถแสดงให้เห็นได้ว่าดัชนี 2 เป็นดัชนีขั้นต่ำของการแยกที่ถูกต้อง ตัวอย่างที่ 2:

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

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

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums มีองค์ประกอบหลักเพียงหนึ่งองค์ประกอบเท่านั้น

องค์ประกอบ x ของอาร์เรย์อาร์เรย์เต็ม arr ที่มีความยาว m จะโดดเด่นหาก freq(x) * 2 > m โดยที่ freq(x) คืออาร์เรย์การเกิดขึ้นของ x ใน arr โปรดทราบว่าคําจํากัดความนี้บอกเป็นนัยว่า arr สามารถมีองค์ประกอบที่โดดเด่นได้สูงสุดหนึ่งองค์ประกอบ
คุณจะได้รับอาร์เรย์อาร์เรย์เต็มที่จัดทําดัชนี 0 อาร์เรย์ความยาว n โดยมีองค์ประกอบที่โดดเด่นหนึ่งองค์ประกอบ
คุณสามารถแยกตัวเลขที่ดัชนี i ออกเป็นสองอาร์เรย์ nums[0, ..., i] และ nums[i + 1, ..., n - 1] แต่การแยกจะใช้ได้ก็ต่อเมื่อ:

0 <= i < n - 1
nums[0, ..., i] และ nums[i + 1, ..., n - 1] มีองค์ประกอบที่โดดเด่นเหมือนกัน

ในที่นี้ nums[i, ..., j] หมายถึงอาร์เรย์ย่อยของ nums ที่เริ่มต้นที่ดัชนี i และสิ้นสุดที่ดัชนี j ปลายทั้งสองด้านจะรวมอยู่ด้วย โดยเฉพาะอย่างยิ่งถ้า j < i nums[i, ..., j] หมายถึงอาร์เรย์ย่อยที่ว่างเปล่า
ส่งกลับดัชนีขั้นต่ําของการแยกที่ถูกต้อง หากไม่มีการแยกที่ถูกต้อง ให้ส่งกลับ -1

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

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

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

อินพุต: nums = [3,3,3,3,7,2,2]
เอาท์พุต: -1
คําอธิบาย: สามารถแสดงได้ว่าไม่มีการแยกที่ถูกต้อง

ข้อจํากัด:

1 <= ความยาว <= 10^5
1 <= ตัวเลข[i] <= 10^9
อาร์เรย์ มีองค์ประกอบที่โดดเด่นเพียงองค์ประกอบเดียว


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

เลือกดัชนี i ที่ยังไม่ถูกเลือกมาก่อนจากช่วง [0, nums.length - 1]
แทนที่ nums[i] ด้วยจำนวนเต็มใด ๆ จากช่วง [nums[i] - k, nums[i] + k]

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

อนุกรมย่อยของอาร์เรย์คืออาร์เรย์ใหม่ที่สร้างขึ้นจากอาร์เรย์ต้นฉบับโดยการลบบางองค์ประกอบ (อาจไม่มีเลย) โดยไม่เปลี่ยนลำดับขององค์ประกอบที่เหลืออยู่

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

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

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

Input: nums = [1,1,1,1], k = 10
Output: 4
คำอธิบาย: ในตัวอย่างนี้เราไม่จำเป็นต้องทำการดำเนินการใดๆ ความสวยงามของอาร์เรย์ nums คือ 4 (อาร์เรย์ทั้งหมด)

ข้อจำกัด:

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

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

เลือกดัชนี i ที่ยังไม่ได้เลือกมาก่อนจากช่วง [0, nums.length - 1]
แทนที่ nums[i] ด้วยจำนวนเต็มใดๆ จากช่วง [nums[i] - k, nums[i] + k]

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

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

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

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

อินพุต: nums = [1,1,1,1], k = 10
เอาต์พุต: 4
คำอธิบาย: ในตัวอย่างนี้ เราไม่จำเป็นต้องใช้การดำเนินการใดๆ
nums ของอาร์เรย์จะมีค่าเท่ากับ 4 (ทั้งอาร์เรย์)

ข้อจำกัด:

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


ให้คุณมีอาร์เรย์ของจำนวนเต็ม nums เราถือว่าอาร์เรย์นั้นอยู่ในสภาพดีถ้ามันเป็นการสับเปลี่ยนของอาร์เรย์ base[n]
base[n] = [1, 2, ..., n - 1, n, n] (กล่าวอีกนัยหนึ่ง มันเป็นอาร์เรย์ที่มีความยาว n + 1 ซึ่งมีตัวเลขจาก 1 ถึง n - 1 ครั้ง และหนึ่งครั้ง บวกกับ n สองครั้ง) ตัวอย่างเช่น base[1] = [1, 1] และ base[3] = [1, 2, 3, 3]
คืนค่า true ถ้าอาร์เรย์ที่ให้มานั้นอยู่ในสภาพดี มิฉะนั้นให้คืนค่า false
หมายเหตุ: การเรียงสับเปลี่ยนของจำนวนเต็ม แสดงถึงการจัดเรียงจำนวนเหล่านี้

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

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

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

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

Input: nums = [1, 1]
Output: true
คำอธิบาย: เนื่องจากองค์ประกอบสูงสุดในอาร์เรย์คือ 1 ตัวเดียวที่เป็นตัวเลือกของ n ที่อาร์เรย์นี้สามารถเป็นการเรียงสับเปลี่ยนของ base[n] คือ n = 1 สามารถเห็นได้ว่า nums เป็นการเรียงสับเปลี่ยนของ base[1] = [1, 1] ดังนั้นคำตอบคือ true
ตัวอย่างที่ 4:

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

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums เราจะถือว่าอาร์เรย์นั้นดีหากเป็นการเรียงสับเปลี่ยนของอาร์เรย์ base[n]
base[n] = [1, 2, ..., n - 1, n, n] (กล่าวอีกนัยหนึ่งก็คือเป็นอาร์เรย์ที่มีความยาว n + 1 ซึ่งมี 1 ถึง n - 1 เพียงครั้งเดียวบวกกับการเกิดขึ้นของ n สองครั้ง) ตัวอย่างเช่น base[1] = [1, 1] และ base[3] = [1, 2, 3, 3]
คืนค่า true หากอาร์เรย์ที่กำหนดนั้นดี มิฉะนั้นจะคืนค่า false
หมายเหตุ: การเรียงสับเปลี่ยนของจำนวนเต็มแสดงถึงการจัดเรียงของตัวเลขเหล่านี้

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

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

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

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

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

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

ข้อจำกัด:

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


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

หากคุณอยู่ในตำแหน่ง i ในขณะนี้ คุณสามารถย้ายไปยังตำแหน่ง j ใดก็ได้ที่ i < j

สำหรับตำแหน่ง i แต่ละตำแหน่งที่คุณเยี่ยมชม คุณจะได้รับคะแนน nums[i]

หากคุณย้ายจากตำแหน่ง i ไปยังตำแหน่ง j และค่าความคู่หรือคี่ของ nums[i] และ nums[j] แตกต่างกัน คุณจะเสียคะแนน x

ส่งคืนคะแนนรวมสูงสุดที่คุณจะได้รับ
โปรดทราบว่าในตอนแรกคุณมีคะแนน nums[0]
ตัวอย่างที่ 1:

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

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

อินพุต: nums = [2,4,6,8], x = 3
เอาต์พุต: 20
คำอธิบาย: จำนวนเต็มทั้งหมดในอาร์เรย์มีความสมดุลเดียวกัน ดังนั้นเราจึงเยี่ยมชมทั้งหมดได้โดยไม่สูญเสียคะแนนใดๆ คะแนนรวมคือ: 2 + 4 + 6 + 8 = 20

เงื่อนไข:

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

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

หากคุณอยู่ในตำแหน่ง i ในขณะนี้ คุณสามารถย้ายไปยังตำแหน่ง j ใดก็ได้ที่ i < j
สำหรับตำแหน่ง i แต่ละตำแหน่งที่คุณเยี่ยมชม คุณจะได้รับคะแนน nums[i]
หากคุณย้ายจากตำแหน่ง i ไปยังตำแหน่ง j และค่าความเท่าเทียมกันของ nums[i] และ nums[j] แตกต่างกัน คุณจะเสียคะแนน x

ส่งคืนคะแนนรวมสูงสุดที่คุณจะได้รับ
โปรดทราบว่าในตอนแรกคุณมีคะแนน nums[0]

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

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

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

อินพุต: nums = [2,4,6,8], x = 3
เอาต์พุต: 20
คำอธิบาย: จำนวนเต็มทั้งหมดในอาร์เรย์มีความคู่หรือคี่เดียวกัน ดังนั้นเราจึงเยี่ยมชมทั้งหมดได้โดยไม่สูญเสียคะแนนใดๆ คะแนนรวมคือ: 2 + 4 + 6 + 8 = 20

เงื่อนไข:

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

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

ถ้าคุณอยู่ในตำแหน่ง i ขณะนี้ คุณสามารถย้ายไปตำแหน่ง j ที่ i < j
สำหรับตำแหน่ง i ที่คุณเยี่ยมชม คุณจะได้รับคะแนนเท่ากับ nums[i]
ถ้าคุณย้ายจากตำแหน่ง i ไปตำแหน่ง j และความเท่า/คี่ของ nums[i] และ nums[j] ต่างกัน คุณจะเสียคะแนนเป็น x

ให้คืนคะแนนรวมสูงสุดที่คุณจะได้รับ
สังเกตว่าตอนเริ่มต้นคุณมีคะแนน nums[0]

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

Input: nums = [2,3,6,1,9,2], x = 5
Output: 13
คำอธิบาย: คุณสามารถเยี่ยมชมตำแหน่งในอาเรย์ดังนี้: 0 -> 2 -> 3 -> 4
ค่าที่เกี่ยวข้องคือ 2, 6, 1 และ 9 เนื่องจากจำนวนเต็ม 6 และ 1 มีความเท่า/คี่ต่างกัน การย้าย 2 -> 3 จะทำให้คุณเสียคะแนน x = 5
คะแนนรวมจะเป็น: 2 + 6 + 1 + 9 - 5 = 13

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

Input: nums = [2,4,6,8], x = 3
Output: 20
คำอธิบาย: จำนวนเต็มทั้งหมดในอาเรย์มีความเท่า/คี่เหมือนกัน ดังนั้นคุณสามารถเยี่ยมชมทั้งหมดโดยไม่เสียคะแนน
คะแนนรวมคือ: 2 + 4 + 6 + 8 = 20

ข้อจำกัด:

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


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

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

Input: nums = [51,71,17,24,42]
Output: 88
คำอธิบาย:
สำหรับ i = 1 และ j = 2, nums[i] และ nums[j] มีเลขหลักสูงสุดเท่ากันและผลรวมของคู่คือ 71 + 17 = 88
สำหรับ i = 3 และ j = 4, nums[i] และ nums[j] มีเลขหลักสูงสุดเท่ากันและผลรวมของคู่คือ 24 + 42 = 66
สามารถแสดงได้ว่าไม่มีคู่ใดที่มีเลขหลักสูงสุดเท่ากันอื่น ๆ ดังนั้นคำตอบคือ 88
ตัวอย่างที่ 2:

Input: nums = [1,2,3,4]
Output: -1
คำอธิบาย: ไม่มีคู่ใดใน nums ที่มีเลขหลักสูงสุดเท่ากัน

เงื่อนไข:

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

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

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

อินพุต: nums = [51,71,17,24,42]
เอาท์พุท: 88
คำอธิบาย:
สำหรับ i = 1 และ j = 2, nums [i] และ nums [j] มีตัวเลขสูงสุดเท่ากันกับผลรวมคู่ของ 71 + 17 = 88
สำหรับ i = 3 และ j = 4, nums [i] และ nums [j] มีตัวเลขสูงสุดเท่ากันกับผลรวมคู่ 24 + 42 = 66
มันสามารถแสดงให้เห็นว่าไม่มีคู่อื่นที่มีตัวเลขสูงสุดเท่ากันดังนั้นคำตอบคือ 88
ตัวอย่างที่ 2:

อินพุต: nums = [1,2,3,4]
เอาท์พุท: -1
คำอธิบาย: ไม่มีคู่อยู่ใน nums ที่มีตัวเลขสูงสุดเท่ากัน

ข้อ จำกัด :

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

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

อินพุต: nums = [51,71,17,24,42]
เอาต์พุต: 88
คำอธิบาย:
สำหรับ i = 1 และ j = 2, nums[i] และ nums[j] จะมีจำนวนหลักสูงสุดเท่ากันโดยผลรวมของคู่คือ 71 + 17 = 88
สำหรับ i = 3 และ j = 4, nums[i] และ nums[j] จะมีจำนวนหลักสูงสุดเท่ากันโดยผลรวมของคู่คือ 24 + 42 = 66
จะแสดงให้เห็นว่าไม่มีคู่อื่นที่มีจำนวนหลักสูงสุดเท่ากัน ดังนั้นคำตอบคือ 88
ตัวอย่างที่ 2:

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

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


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

ให้ cnt เป็นจำนวนดัชนี i ในช่วง [l, r] โดยที่ nums[i] % modulo == k จากนั้น cnt % modulo == k

ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนอาร์เรย์ย่อยที่น่าสนใจ

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

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

อินพุต: nums = [3,1,9,6], modulo = 3, k = 0
เอาต์พุต: 2
คำอธิบาย: ในตัวอย่างนี้ ซับอาร์เรย์ที่น่าสนใจคือ:
ซับอาร์เรย์ nums[0..3] ซึ่งคือ [3,1,9,6] - มีดัชนีสามตัวคือ i = 0, 2, 3 ในช่วง [0, 3] ที่ตรงตาม nums[i] % modulo == k
- ดังนั้น cnt = 3 และ cnt % modulo == k
ซับอาร์เรย์ nums[1..1] ซึ่งคือ [1]
- ไม่มีดัชนี i ในช่วง [1, 1] ที่ตรงตาม nums[i] % modulo == k
- ดังนั้น cnt = 0 และ cnt % modulo == k
จะเห็นได้ว่าไม่มีซับอาร์เรย์ที่น่าสนใจอื่น ๆ ดังนั้น คำตอบคือ 2

ข้อจำกัด:

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

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

ให้ cnt เป็นจำนวนของดัชนี i ในช่วง [l, r] ที่ nums[i] % modulo == k จากนั้น cnt % modulo == k

คืนค่าจำนวนเต็มที่ระบุจำนวนของ subarray ที่น่าสนใจ
หมายเหตุ: subarray คืออนุกรมต่อเนื่องที่ไม่ว่างเปล่าของสมาชิกภายในอาร์เรย์

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

Input: nums = [3,2,4], modulo = 2, k = 1
Output: 3
คำอธิบาย: ในตัวอย่างนี้ subarray ที่น่าสนใจคือ:
subarray nums[0..0] ซึ่งคือ [3]
- มีเพียงหนึ่งดัชนี i = 0 ในช่วง [0, 0] ที่ตรงตาม nums[i] % modulo == k
- ดังนั้น cnt = 1 และ cnt % modulo == k
subarray nums[0..1] ซึ่งคือ [3,2]
- มีเพียงหนึ่งดัชนี i = 0 ในช่วง [0, 1] ที่ตรงตาม nums[i] % modulo == k
- ดังนั้น cnt = 1 และ cnt % modulo == k
subarray nums[0..2] ซึ่งคือ [3,2,4]
- มีเพียงหนึ่งดัชนี i = 0 ในช่วง [0, 2] ที่ตรงตาม nums[i] % modulo == k
- ดังนั้น cnt = 1 และ cnt % modulo == k
สามารถแสดงได้ว่าไม่มี subarray ที่น่าสนใจอื่น ๆ ดังนั้นคำตอบคือ 3

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

Input: nums = [3,1,9,6], modulo = 3, k = 0
Output: 2
คำอธิบาย: ในตัวอย่างนี้ subarray ที่น่าสนใจคือ:
subarray nums[0..3] ซึ่งคือ [3,1,9,6]
- มีดัชนีสามอัน i = 0, 2, 3 ในช่วง [0, 3] ที่ตรงตาม nums[i] % modulo == k
- ดังนั้น cnt = 3 และ cnt % modulo == k
subarray nums[1..1] ซึ่งคือ [1]
- ไม่มีดัชนีที่ i ในช่วง [1, 1] ที่ตรงตาม nums[i] % modulo == k
- ดังนั้น cnt = 0 และ cnt % modulo == k
สามารถแสดงได้ว่าไม่มี subarray ที่น่าสนใจอื่น ๆ ดังนั้นคำตอบคือ 2

เงื่อนไข:

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


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

ความยาวของอาเรย์ย่อยเท่ากับหนึ่ง หรือ
ผลรวมของสมาชิกในอาเรย์ย่อยมากกว่าหรือเท่ากับ m

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

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

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

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

Input: nums = [2, 3, 3, 2, 3], m = 6
Output: true
คำอธิบาย: เราสามารถแบ่งอาร์เรย์ออกเป็น [2, 3, 3, 2] และ [3] ในขั้นตอนแรก จากนั้นในขั้นตอนที่สอง เราสามารถแบ่ง [2, 3, 3, 2] ออกเป็น [2, 3, 3] และ [2] จากนั้นในขั้นตอนที่สาม เราสามารถแบ่ง [2, 3, 3] ออกเป็น [2] และ [3, 3] และในขั้นตอนสุดท้ายเราสามารถแบ่ง [3, 3] ออกเป็น [3] และ [3] ดังนั้นผลลัพธ์คือ true

ข้อจำกัด:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

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

ความยาวของ subarray เป็นหนึ่ง หรือ
ผลรวมขององค์ประกอบใน subarray มากกว่าหรือเท่ากับ m

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

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

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

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

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

ข้อ จำกัด :

1 <= n == nums.length <= 100
1 <= nums [i] <= 100
1 <= m <= 200

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

ความยาวของอาร์เรย์ย่อยคือหนึ่ง หรือ
ผลรวมขององค์ประกอบของอาร์เรย์ย่อยมากกว่าหรือเท่ากับ m

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

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

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

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

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

ข้อจำกัด:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200


กำหนดจำนวนเต็มที่มีดัชนี 0 จำนวน nums ที่มีความยาว n และเป้าหมายจำนวนเต็ม ให้ส่งคืนจำนวนคู่ (i, j) โดยที่ 0 <= i < j < n และ nums[i] + nums[j] < เป้าหมาย

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

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

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

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

ข้อจำกัด:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

เมื่อกําหนดอาร์เรย์จํานวนเต็มที่มีดัชนี 0 จํานวน nums ที่มีความยาว n และเป้าหมายจํานวนเต็ม ให้ส่งคืนจํานวนคู่ (i, j) โดยที่ 0 <= i < j < n และ nums[i] + nums[j] <เป้าหมาย

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

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

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

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

ข้อจํากัด:

1 <= nums.length == n <= 50
-50 <= nums[i], เป้าหมาย <= 50

เมื่อกำหนดอาร์เรย์จำนวนเต็มดัชนี 0 ที่มีความยาว n และเป้าหมายจำนวนเต็ม ให้ส่งคืนจำนวนคู่ (i, j) โดยที่ 0 <= i < j < n และ nums[i] + nums[j] < target

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

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

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

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

ข้อจำกัด:

1 <= nums.length == n <= 50
-50 <= nums[i], เป้าหมาย <= 50


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

แต่ละกลุ่มจะต้องประกอบด้วยตัวเลขที่แตกต่างกัน ซึ่งหมายความว่าไม่อนุญาตให้มีตัวเลขซ้ำกันภายในกลุ่มเดียว
แต่ละกลุ่ม (ยกเว้นกลุ่มแรก) จะต้องมีความยาวที่มากกว่ากลุ่มก่อนหน้าอย่างเคร่งครัด

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

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

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

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

ตัวอย่าง 3:

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

ข้อจำกัด:

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

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

แต่ละกลุ่มต้องประกอบด้วยตัวเลขที่แตกต่างกัน ซึ่งหมายความว่าไม่อนุญาตให้ใช้ตัวเลขซ้ํากันภายในกลุ่มเดียว
แต่ละกลุ่ม (ยกเว้นกลุ่มแรก) ต้องมีความยาวมากกว่ากลุ่มก่อนหน้าอย่างเคร่งครัด

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

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

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

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

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

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

ข้อจํากัด:

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


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

สำหรับดัชนี i ทุกตัวในช่วง [0, n - 1] ให้แทนที่ nums[i] ด้วย nums[i], nums[(i - 1 + n) % n] หรือ nums[(i + 1) % n]

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

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

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

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

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

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

อินพุต: nums = [5,5,5,5]
เอาต์พุต: 0
คำอธิบาย: เราไม่จำเป็นต้องดำเนินการใดๆ เนื่องจากองค์ประกอบทั้งหมดในอาร์เรย์เริ่มต้นนั้นเหมือนกัน

ข้อจำกัด:

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

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

สำหรับทุกดัชนี i ในช่วง [0, n - 1], ให้แทนที่ nums[i] ด้วย  nums[i], nums[(i - 1 + n) % n],  หรือ nums[(i + 1) % n].

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

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

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

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

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

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

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

เงื่อนไข:

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


กำหนดจำนวนเต็มบวกสองจำนวนคือ low และ high ที่แสดงเป็นสตริง หาจำนวนนับก้าวในช่วงรวม [low, high]
จำนวนก้าวคือจำนวนเต็มที่ตัวเลขที่อยู่ติดกันทั้งหมดมีค่าต่างกันสัมบูรณ์ 1 พอดี
ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนนับก้าวในช่วงรวม [low, high]

เนื่องจากคำตอบอาจมีค่ามาก ให้ส่งคืนค่าโมดูโล 10^9 + 7
หมายเหตุ: จำนวนก้าวไม่ควรมีเลขศูนย์นำหน้า

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

อินพุต: low = "1", high = "11"
เอาต์พุต: 10
คำอธิบาย: จำนวนก้าวในช่วง [1,11] คือ 1, 2, 3, 4, 5, 6, 7, 8, 9 และ 10 มีทั้งหมด 10 จำนวนก้าวในช่วงนี้ ดังนั้นผลลัพธ์คือ 10
ตัวอย่างที่ 2:

อินพุต: low = "90", high = "101"
ผลลัพธ์: 2
คำอธิบาย: หมายเลขการก้าวในช่วง [90,101] คือ 98 และ 101 มีหมายเลขการก้าวทั้งหมด 2 หมายเลขในช่วงนี้ ดังนั้นผลลัพธ์คือ 2

ข้อจำกัด:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
ต่ำและสูงประกอบด้วยตัวเลขเท่านั้น
ต่ำและสูงไม่มีเลขศูนย์นำหน้า

ให้จํานวนเต็มบวกสองจํานวนlowและhighที่แสดงเป็นสตริงให้ค้นหาจํานวนตัวเลขสเต็ปในช่วงรวม  [low, high]
ตัวเลขสเต็ปเป็นจํานวนเต็มเพื่อให้ตัวเลขที่อยู่ติดกันทั้งหมดมีความแตกต่างสัมบูรณ์เท่ากับ 1 พอดี
ส่งกลับจํานวนเต็มที่แสดงถึงจํานวนของตัวเลขสเต็ปในช่วงรวม  [low, high]
เนื่องจากคําตอบอาจใหญ่มาก ให้ส่งคืนโมดูโล 10^9 + 7
หมายเหตุ: หมายเลขสเต็ปปิ้งไม่ควรมีเลขศูนย์นําหน้า

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

อินพุต: low = "1", high = "11"
เอาท์พุต: 10
คําอธิบาย: ตัวเลขสเต็ปในช่วง [1,11] คือ 1, 2, 3, 4, 5, 6, 7, 8, 9 และ 10 มีหมายเลขสเต็ปทั้งหมด 10 ตัวในช่วง ดังนั้นผลลัพธ์คือ 10
ตัวอย่างที่ 2:

อินพุต: low = "90", high = "101"
เอาท์พุต: 2
คําอธิบาย: ตัวเลขสเต็ปในช่วง [90,101] คือ 98 และ 101 มีหมายเลขสเต็ปทั้งหมด 2 หมายเลขในช่วง ดังนั้นผลลัพธ์คือ 2

ข้อจํากัด:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low และ high ประกอบด้วยเฉพาะตัวเลขเท่านั้น
low และ high ไม่มีเลขศูนย์นำหน้า


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

เลือกดัชนี 0 <= i < nums1.length และทำให้ nums1[i] = 0

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

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

Input: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Output: 3
คำอธิบาย:
สำหรับวินาทีที่ 1 เราทำการดำเนินการที่ i = 0 ดังนั้น nums1 = [0,2+2,3+3] = [0,4,6]
สำหรับวินาทีที่ 2 เราทำการดำเนินการที่ i = 1 ดังนั้น nums1 = [0+1,0,6+3] = [1,0,9]
สำหรับวินาทีที่ 3 เราทำการดำเนินการที่ i = 2 ดังนั้น nums1 = [1+1,0+2,0] = [2,2,0]
ขณะนี้ ผลรวมของ nums1 = 4 สามารถแสดงได้ว่าการดำเนินการเหล่านี้เป็นผลลัพธ์ที่ดีที่สุด ดังนั้นเราจะคืนค่า 3

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

Input: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Output: -1
คำอธิบาย: สามารถแสดงได้ว่าผลรวมของ nums1 จะมากกว่า x เสมอ ไม่ว่าจะทำการดำเนินการใด ๆ

ข้อจำกัด:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

คุณจะได้รับอาร์เรย์จำนวนเต็ม ที่มีดัชนีเริ่มต้นที่ 0สองตัว nums1 และ nums2 ที่มีความยาวเท่ากัน ทุกวินาทีสำหรับดัชนีทั้งหมด 0 <= i <nums1.Length ค่าของ nums1 [i] จะเพิ่มขึ้นโดย nums2 [i] หลังจากทำเสร็จแล้วคุณสามารถดำเนินการต่อไปนี้:

เลือกดัชนี 0 <= i <nums1.length และสร้าง nums1 [i] = 0

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

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

อินพุต: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
เอาท์พุท: 3
คำอธิบาย:
สำหรับวินาทีที่ 1 เราใช้การดำเนินการกับ i = 0 ดังนั้น nums1 = [0,2+2,3+3] = [0,4,6]
สำหรับวินาทีที่ 2 เราใช้การดำเนินการกับ i = 1 ดังนั้น nums1 = [0+1,0,6+3] = [1,0,9]
สำหรับวินาทีที่ 3 เราใช้การดำเนินการกับ i = 2 ดังนั้น nums1 = [1+1,0+2,0] = [2,2,0]
ตอนนี้ผลรวมของ nums1 = 4 สามารถแสดงให้เห็นว่าการดำเนินการเหล่านี้ดีที่สุดดังนั้นเราจึงกลับมา 3

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

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

ข้อ จำกัด :

1 <= nums1.Length <= 10^3
1 <= nums1 [i] <= 10^3
0 <= nums2 [i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

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

เลือกดัชนี 0 <= i < nums1.length แล้วทำให้ nums1[i] = 0

คุณจะได้รับจำนวนเต็ม x ด้วย

ส่งคืนเวลาขั้นต่ำที่คุณสามารถทำให้ผลรวมขององค์ประกอบทั้งหมดของ nums1 น้อยกว่าหรือเท่ากับ x หรือส่งคืน -1 หากทำไม่ได้
ตัวอย่างที่ 1:

อินพุต: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
เอาต์พุต: 3
คำอธิบาย:
สำหรับวินาทีที่ 1 เราใช้การดำเนินการกับ i = 0 ดังนั้น nums1 = [0,2+2,3+3] = [0,4,6]
สำหรับวินาทีที่ 2 เราใช้การดำเนินการกับ i = 1 ดังนั้น nums1 = [0+1,0,6+3] = [1,0,9]
สำหรับวินาทีที่ 3 เราใช้การดำเนินการกับ i = 2 ดังนั้น nums1 = [1+1,0+2,0] = [2,2,0]
ตอนนี้ผลรวมของ nums1 = 4 แสดงให้เห็นว่าการดำเนินการเหล่านี้เหมาะสมที่สุด ดังนั้นเราจึงส่งคืน 3

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

อินพุต: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
เอาต์พุต: -1
คำอธิบาย: แสดงให้เห็นว่าผลรวมของ nums1 จะมากกว่า x เสมอ ไม่ว่าจะดำเนินการใด

ข้อจำกัด:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6


คุณได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่ชื่อว่า coordinates และจำนวนเต็ม k โดยที่ coordinates[i] = [x_i, y_i] คือพิกัดของจุดที่ i ในระนาบ 2 มิติ เรากำหนดระยะห่างระหว่างสองจุด (x_1, y_1) และ (x_2, y_2) ว่าเป็น (x1 XOR x2) + (y1 XOR y2) โดยที่ XOR คือการดำเนินการ XOR แบบบิต Return จำนวนคู่ (i, j) ที่ทำให้ i < j และระยะห่างระหว่างจุด i และ j เท่ากับ k.

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

Input: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Output: 2
คำอธิบาย: เราสามารถเลือกคู่ต่อไปนี้ได้:
- (0,1): เพราะเรามี (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): เพราะเรามี (1 XOR 5) + (3 XOR 2) = 5.

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

Input: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Output: 10
คำอธิบาย: คู่ที่เลือกใด ๆ สองคู่จะมีระยะห่างเป็น 0 มีวิธีการเลือกสองคู่ทั้งหมด 10 วิธี

ข้อจำกัด:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

คุณจะได้รับพิกัดอาร์เรย์จำนวนเต็ม 2D และจำนวนเต็ม k ที่พิกัด [i] = [x_i, y_i] เป็นพิกัดของจุด i^th ในระนาบ 2D
เรากำหนดระยะห่างระหว่างสองจุด (x_1, y_1) และ (x_2, y_2) เป็น (x1 XOR x2) + (y1 XOR y2) โดยที่ xor คือการทำงานของ Bitwise XOR
ส่งคืนจำนวนคู่ (i, j) ที่ i < j และระยะห่างระหว่างจุด i และ j เท่ากับ k
ตัวอย่างที่ 1:

อินพุต: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
เอาท์พุท: 2
คำอธิบาย: เราสามารถเลือกคู่ต่อไปนี้:
- (0,1): เพราะเรามี (1  XOR 4) + (2  XOR 2) = 5
- (2,3): เพราะเรามี (1  XOR 5) + (3  XOR 2) = 5

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

อินพุต: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
เอาท์พุท: 10
คำอธิบาย: คู่ที่เลือกสองคู่จะมีระยะทาง 0 มี 10 วิธีในการเลือกสองคู่

ข้อ จำกัด :

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

คุณจะได้รับพิกัดอาร์เรย์จำนวนเต็ม 2 มิติและจำนวนเต็ม k โดยที่ coordinates[i] = [x_i, y_i] คือพิกัดของจุดที่ i^ ในระนาบ 2 มิติ
เราจะกำหนดระยะห่างระหว่างสองจุด (x_1, y_1) และ (x_2, y_2) ให้เป็น (x1 XOR x2) + (y1 XOR y2) โดยที่ XOR คือการดำเนินการ XOR ตามบิต

ส่งคืนจำนวนคู่ (i, j) ที่ i < j และระยะห่างระหว่างจุด i และ j เท่ากับ k

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

อินพุต: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
เอาต์พุต: 2
คำอธิบาย: เราสามารถเลือกคู่ต่อไปนี้ได้:
- (0,1): เนื่องจากเราได้ (1 XOR 4) + (2 XOR 2) = 5
- (2,3): เนื่องจากเราได้ (1 XOR 5) + (3 XOR 2) = 5

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

อินพุต: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
เอาต์พุต: 10
คำอธิบาย: คู่ที่เลือกสองคู่จะมีระยะห่าง 0 มี 10 วิธีในการเลือกสองคู่
ข้อจำกัด:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100


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

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

Input: nums = [2,6,7,3,1,7], m = 3, k = 4
Output: 18
คำอธิบาย: มีซับอาร์เรย์ที่เกือบจะไม่ซ้ำกัน 3 ชุด ขนาด k = 4 ซับอาร์เรย์เหล่านี้คือ [2, 6, 7, 3], [6, 7, 3, 1] และ [7, 3, 1, 7] ในบรรดาซับอาร์เรย์เหล่านี้ ซับอาร์เรย์ที่มีผลรวมสูงสุดคือ [2, 6, 7, 3] ซึ่งมีผลรวมเท่ากับ 18.

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

Input: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Output: 23
คำอธิบาย: มีซับอาเรย์ที่เกือบจะไม่ซ้ำกันขนาด k จำนวน 5 ชุด ได้แก่ [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] และ [4, 5, 4] ในบรรดาซับอาเรย์เหล่านี้ ซับอาเรย์ที่มีผลรวมสูงสุดคือ [5, 9, 9] ซึ่งมีผลรวมเท่ากับ 23.

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

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

ข้อจำกัด:

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

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

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

Input: nums = [2,6,7,3,1,7], m = 3, k = 4
Output: 18
คำอธิบาย: มีซับอาร์เรย์ 3 ซับที่แทบจะมีเอกลักษณ์เฉพาะตัว โดยมีขนาด k = 4 ซับอาร์เรย์เหล่านี้คือ [2, 6, 7, 3], [6, 7, 3, 1] และ [7, 3, 1, 7] ในบรรดาซับอาร์เรย์เหล่านี้ ซับอาร์เรย์ที่มีผลรวมสูงสุดคือ [2, 6, 7, 3] ซึ่งมีผลรวมเท่ากับ 18

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

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

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

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

ข้อจำกัด:

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

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

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

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

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

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

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

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

ข้อจำกัด:

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9


คุณมีเงินในบัญชีธนาคารเริ่มต้นจำนวน 100 ดอลลาร์
คุณจะได้รับจำนวนเต็ม purchaseAmount ซึ่งแสดงถึงจำนวนเงินที่คุณจะใช้ในการซื้อสินค้าเป็นดอลลาร์
ที่ร้านค้าที่คุณจะทำการซื้อ จำนวนเงินซื้อสินค้าจะถูกปัดเป็นจำนวนเต็มที่ใกล้ที่สุดที่เป็นผลคูณของ 10 กล่าวคือ คุณจ่ายเป็นจำนวนเงินที่ไม่ติดลบ ซึ่งคือ roundedAmount โดยที่ roundedAmount เป็นผลคูณของ 10 และ abs(roundedAmount - purchaseAmount) มีค่าน้อยที่สุด
หากมีผลคูณของ 10 ที่ใกล้ที่สุดมากกว่าหนึ่งค่า จะเลือกค่าที่มากที่สุด
คืนค่าจำนวนเต็มที่แสดงถึงยอดเงินในบัญชีของคุณหลังจากทำการซื้อสินค้ามูลค่า purchaseAmount ดอลลาร์จากร้านค้า
หมายเหตุ: 0 ถือว่าเป็นผลคูณของ 10 ในปัญหานี้

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

Input: purchaseAmount = 9
Output: 90
คำอธิบาย: ในตัวอย่างนี้ ผลคูณของ 10 ที่ใกล้ที่สุดกับ 9 คือ 10 ดังนั้นยอดเงินในบัญชีของคุณกลายเป็น 100 - 10 = 90

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

Input: purchaseAmount = 15
Output: 80
คำอธิบาย: ในตัวอย่างนี้ มีตัวคูณที่ใกล้เคียงที่สุดของ 10 ถึง 15 สองตัว ได้แก่ 10 และ 20 ดังนั้นจึงเลือกค่าที่มากกว่าคือ 20
ดังนั้นยอดเงินในบัญชีของคุณกลายเป็น 100 - 20 = 80

ข้อจำกัด:

0 <= purchaseAmount <= 100

เบื้องต้น คุณมีเงินคงเหลือในบัญชีธนาคาร 100 ดอลลาร์
คุณจะได้รับจำนวนเต็มของ purchaseAmount ซึ่งแสดงถึงจำนวนเงินที่คุณจะใช้จ่ายในการซื้อเป็นดอลลาร์
ในร้านค้าที่คุณจะซื้อ จำนวนเงินที่ซื้อจะถูกปัดเศษเป็นทวีคูณที่ใกล้เคียงที่สุดของ 10 กล่าวอีกนัยหนึ่ง คุณจะจ่ายเป็นจำนวนเงินที่ไม่เป็นลบ คือ roundedAmount โดยที่ roundedAmount จะเป็นทวีคูณของ 10 และ abs(roundedAmount - purchaseAmount) จะถูกย่อให้เล็กสุด
หากมีทวีคูณที่ใกล้เคียงที่สุดของ 10 มากกว่าหนึ่งตัว ระบบจะเลือกทวีคูณที่มากที่สุด
ส่งกลับจำนวนเต็มที่แสดงถึงยอดคงเหลือในบัญชีของคุณหลังจากซื้อของที่มีมูลค่า purchaseAmount เป็นดอลลาร์จากร้านค้า
หมายเหตุ: 0 ถือเป็นทวีคูณของ 10 ในโจทย์นี้
ตัวอย่างที่ 1:

อินพุต: purchaseAmount = 9
เอาต์พุต: 90
คำอธิบาย: ในตัวอย่างนี้ ตัวคูณที่ใกล้เคียงที่สุดของ 10 ถึง 9 คือ 10 ดังนั้น ยอดคงเหลือในบัญชีของคุณจึงกลายเป็น 100 - 10 = 90

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

อินพุต: purchaseAmount = 15
เอาต์พุต: 80
คำอธิบาย: ในตัวอย่างนี้ มีตัวคูณที่ใกล้เคียงที่สุดของ 10 ถึง 15 สองตัว ได้แก่ 10 และ 20 ดังนั้นจึงเลือกตัวคูณที่ใหญ่กว่า คือ 20
ดังนั้น ยอดคงเหลือในบัญชีของคุณจึงกลายเป็น 100 - 20 = 80

ข้อจำกัด:

0 <= purchaseAmount <= 100

ในขั้นต้นคุณมียอดบัญชีธนาคาร 100 ดอลลาร์
คุณจะได้รับจำนวนเต็ม purchaseAmount ที่แสดงถึงจำนวนเงินที่คุณจะใช้จ่ายในการซื้อเป็นดอลลาร์
ที่ร้านค้าที่คุณจะทำการซื้อจำนวนเงินที่ซื้อจะถูกปัดเศษเป็นจำนวนที่ใกล้ที่สุดของ 10 กล่าวอีกนัยหนึ่งคุณจ่ายจำนวนเงินที่ไม่เป็นลบ, RoundedAmount เช่น RoundedAmount เป็นจำนวนที่หารด้วย 10 ลงตัว และ abs(RoundedAmount - purchaseAmount) น้อยที่สุด
หากมีมากกว่าหนึ่งตัวที่ใกล้ที่สุดของ 10 ตัวเลขที่มากที่สุดจะถูกเลือก
ส่งคืนจำนวนเต็มที่แสดงถึงยอดคงเหลือในบัญชีของคุณหลังจากทำการซื้อมูลค่าเงินซื้อจากร้านค้า
หมายเหตุ: 0 ถือเป็นจำนวนที่หารด้วย 10 ลงตัว ในปัญหานี้

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

อินพุต: purchaseAmount = 9
เอาท์พุท: 90
คำอธิบาย: ในตัวอย่างนี้คูณที่ใกล้ที่สุดของ 10 ถึง 9 คือ 10 ดังนั้นยอดคงเหลือในบัญชีของคุณจะกลายเป็น 100 - 10 = 90

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

อินพุต: Purchaseamount = 15
เอาท์พุท: 80
คำอธิบาย: ในตัวอย่างนี้มีสองตัวเลขที่ใกล้ที่สุดกับ 15 คือ 10 และ 20 ดังนั้นตัวเลขที่มากที่สุดคือ 20
ดังนั้นยอดคงเหลือในบัญชีของคุณจะกลายเป็น 100 - 20 = 80

ข้อ จำกัด :

0 <= Purchaseamount <= 100


ให้พิจารณาอาเรย์ของสตริงที่ชื่อว่า words และสตริง s ให้ตรวจสอบว่า s เป็นตัวย่อของ words หรือไม่
สตริง s จะถือว่าเป็นตัวย่อของ words หากสามารถสร้างขึ้นได้โดยการเชื่อมต่ออักขระตัวแรกของแต่ละสตริงใน words ตามลำดับ ตัวอย่างเช่น "ab" สามารถสร้างจาก ["apple", "banana"] แต่ไม่สามารถสร้างจาก ["bear", "aardvark"]
ให้คืนค่า true หาก s เป็นตัวย่อของ words และ false หากไม่ใช่

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

Input: words = ["alice","bob","charlie"], s = "abc"
Output: true
คำอธิบาย: ตัวอักษรตัวแรกในคำว่า "alice", "bob", และ "charlie" คือ 'a', 'b', และ 'c' ตามลำดับ ดังนั้น s = "abc" จึงเป็นตัวย่อ

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

Input: words = ["an","apple"], s = "a"
Output: false
คำอธิบาย: ตัวอักษรตัวแรกในคำว่า "an" และ "apple" คือ 'a' และ 'a' ตามลำดับ
คำย่อที่เกิดจากการรวมตัวอักษรเหล่านี้คือ "aa"
ดังนั้น s = "a" จึงไม่ใช่คำย่อ

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

Input: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Output: true
คำอธิบาย: โดยการเชื่อมต่ออักขระตัวแรกของคำในอาร์เรย์ เราจะได้สตริงว่า "ngguoy"
ดังนั้น s = "ngguoy" จึงเป็นตัวย่อ

ข้อจำกัด:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] และ s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก

กำหนดอาร์เรย์ของสตริง word และสตริง s ให้พิจารณาว่า s เป็นตัวย่อของคำหรือไม่
สตริง s จะถือเป็นตัวย่อของคำหากสามารถสร้างได้โดยการต่อตัวอักษรตัวแรกของแต่ละสตริงเป็นคำตามลำดับ ตัวอย่างเช่น "ab" สามารถสร้างได้จาก ["apple", "banana"] แต่ไม่สามารถสร้างขึ้นได้จาก ["bear", "aardvark"]
คืนค่า true หาก s เป็นตัวย่อของคำ และคืนค่า false หากไม่เช่นนั้น

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

อินพุต: words = ["alice","bob","charlie"], s = "abc"
เอาต์พุต: true
คำอธิบาย: ตัวอักษรตัวแรกในคำว่า "alice", "bob" และ "charlie" คือ 'a', 'b' และ 'c' ตามลำดับ ดังนั้น s = "abc" จึงเป็นตัวย่อ

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

อินพุต: words = ["an","apple"], s = "a"
เอาต์พุต: false
คำอธิบาย: อักขระตัวแรกในคำว่า "an" และ "apple" คือ 'a' และ 'a' ตามลำดับ
ตัวย่อที่เกิดจากการเชื่อมอักขระเหล่านี้เข้าด้วยกันคือ "aa"
ดังนั้น s = "a" จึงไม่ใช่ตัวย่อ

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

อินพุต: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
เอาต์พุต: true
คำอธิบาย: การเชื่อมอักขระตัวแรกของคำในอาร์เรย์เข้าด้วยกันจะทำให้ได้สตริง "ngguoy"
ดังนั้น s = "ngguoy" จึงเป็นตัวย่อ

ข้อจำกัด:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] และ s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก

ได้รับสตริงคำและสตริง s พิจารณาว่า s เป็นตัวย่อของคำหรือไม่
สตริง s ถือเป็นคำย่อของคำถ้ามันสามารถเกิดขึ้นได้โดยการเชื่อมต่ออักขระแรกของแต่ละสตริงในคำตามลำดับ ตัวอย่างเช่น "ab" สามารถเกิดขึ้นได้จาก ["apple", "banana"] แต่มันไม่สามารถเกิดขึ้นได้จาก ["bear", "aardvark"]
ส่งคืนค่าจริงถ้า s เป็นตัวย่อของคำและเท็จเป็นอย่างอื่น

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

อินพุต: words = ["alice","bob","charlie"], s = "abc"
เอาท์พุท: จริง
คำอธิบาย: ตัวอักษรตัวแรกของคำว่า "อลิซ", "บ๊อบ" และ "ชาร์ลี" คือ 'a', 'b' และ 'c' ตามลำดับ ดังนั้น s = "abc" เป็นตัวย่อ

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

อินพุต: words = ["an", "apple"], s = "a"
เอาท์พุท: เท็จ
คำอธิบาย: ตัวละครตัวแรกในคำว่า "an" และ "apple" คือ 'a' และ 'a' ตามลำดับ
ตัวย่อที่เกิดขึ้นจากการเชื่อมต่อตัวละครเหล่านี้คือ "aa"
ดังนั้น S = "a" ไม่ใช่ตัวย่อ

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

อินพุต: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
เอาท์พุท: จริง
คำอธิบาย: โดยการเชื่อมต่อตัวละครแรกของคำในสตริงเราจะได้รับสตริง "ngguoy"
ดังนั้น s = "ngguoy" เป็นตัวย่อ

ข้อ จำกัด :

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
คำ [i] และ s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก


คุณได้รับจำนวนเต็ม n ซึ่งแสดงถึงจำนวนบ้านบนเส้นตัวเลข ซึ่งมีหมายเลขตั้งแต่ 0 ถึง n - 1
นอกจากนี้ คุณยังได้รับอาร์เรย์จำนวนเต็ม 2D ที่ชื่อว่า offers ซึ่ง offers[i] = [start_i, end_i, gold_i], บ่งชี้ว่าผู้ซื้อคนที่ i ต้องการซื้อบ้านทั้งหมดจาก start_i ถึง end_i เป็นจำนวนทองคำ gold_i
ในฐานะพนักงานขาย เป้าหมายของคุณคือการเพิ่มรายได้ของคุณให้สูงสุดโดยการเลือกอย่างมีกลยุทธ์เพื่อขายบ้านให้กับผู้ซื้อ
จงคืนจำนวนทองคำสูงสุดที่คุณสามารถได้รับ
โปรดทราบว่าผู้ซื้อที่แตกต่างกันไม่สามารถซื้อบ้านเดียวกันได้ และบางบ้านอาจไม่มีการขาย

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

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

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

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

ข้อจำกัด:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

คุณจะได้รับจำนวนเต็ม n ที่แสดงถึงจำนวนบ้านบนเส้นจำนวนตั้งแต่ 0 ถึง n - 1
นอกจากนี้ คุณยังได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่ชื่อว่า offers โดยที่ offers[i] = [start_i, end_i, gold_i] ซึ่งระบุว่าผู้ซื้อรายที่ i^ ต้องการซื้อบ้านทั้งหมดตั้งแต่ start_i ถึง end_i ด้วยทองคำจำนวน gold_i
ในฐานะนักขาย เป้าหมายของคุณคือการเพิ่มรายได้ให้สูงสุดโดยการคัดเลือกและขายบ้านให้กับผู้ซื้ออย่างมีกลยุทธ์
ส่งคืนทองคำจำนวนสูงสุดที่คุณจะได้รับ
โปรดทราบว่าผู้ซื้อที่แตกต่างกันไม่สามารถซื้อบ้านหลังเดียวกันได้ และบ้านบางหลังอาจยังไม่ได้ขาย

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

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

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

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

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

คุณจะได้รับจำนวนเต็ม n ที่แสดงถึงจำนวนบ้านบนเส้นจำนวนตั้งแต่ 0 ถึง n - 1
นอกจากนี้ คุณยังได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่ชื่อว่า offers โดยที่ offers[i] = [start_i, end_i, gold_i] ซึ่งระบุว่าผู้ซื้อรายที่ i^ ต้องการซื้อบ้านทั้งหมดตั้งแต่ start_i ถึง end_i ด้วยทองคำจำนวน gold_i
ในฐานะนักขาย เป้าหมายของคุณคือการเพิ่มรายได้ให้สูงสุดโดยการคัดเลือกและขายบ้านให้กับผู้ซื้ออย่างมีกลยุทธ์
ส่งคืนทองคำจำนวนสูงสุดที่คุณจะได้รับ
โปรดทราบว่าผู้ซื้อที่แตกต่างกันไม่สามารถซื้อบ้านหลังเดียวกันได้ และบ้านบางหลังอาจยังไม่ได้ขาย

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

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

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

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

ข้อจำกัด:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3


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

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

อินพุต: low = 1, high = 100
เอาต์พุต: 9
คำอธิบาย: มีจำนวนเต็มสมมาตร 9 จำนวนระหว่าง 1 ถึง 100: 11, 22, 33, 44, 55, 66, 77, 88,และ 99

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

อินพุต: low = 1200, high = 1230
เอาต์พุต: 4
คำอธิบาย: มีจำนวนเต็มสมมาตร 4 จำนวนระหว่าง 1200 ถึง 1230: 1203, 1212, 1221,  และ 1230

ข้อจำกัด:

1 <= low <= high <= 10^4

คุณมีจำนวนเต็มบวกสองตัว low และ high
จำนวนเต็ม x ซึ่งประกอบด้วย 2 * n หลักถือเป็น symmetric ถ้าผลรวมของ n หลักแรกของ x เท่ากับผลรวมของ n หลักสุดท้ายของ x ตัวเลขที่มีจำนวนหลักเป็นเลขคี่จะไม่เป็น symmetric
จงคืนจำนวนของ symmetric integers ในช่วง [low, high]

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

Input: low = 1, high = 100
Output: 9
คำอธิบาย: มี symmetric integers 9 ตัวระหว่าง 1 และ 100: 11, 22, 33, 44, 55, 66, 77, 88, และ 99

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

Input: low = 1200, high = 1230
Output: 4
คำอธิบาย: มี symmetric integers 4 ตัวระหว่าง 1200 และ 1230: 1203, 1212, 1221, และ 1230

เงื่อนไข:

1 <= low <= high <= 10^4

You are given two positive integers low and high.
An integer x consisting of 2 * n digits is symmetric if the sum of the first n digits of x is equal to the sum of the last n digits of x. Numbers with an odd number of digits are never symmetric.
Return the number of symmetric integers in the range [low, high].

Example 1:

Input: low = 1, high = 100
Output: 9
Explanation: There are 9 symmetric integers between 1 and 100: 11, 22, 33, 44, 55, 66, 77, 88, and 99.

Example 2:

Input: low = 1200, high = 1230
Output: 4
Explanation: There are 4 symmetric integers between 1200 and 1230: 1203, 1212, 1221, and 1230.

Constraints:

1 <= low <= high <= 10^4


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

เลือกดัชนี i และ j ใดๆ สองตัวที่ j - i = 2 จากนั้นสลับอักขระสองตัวที่ดัชนีเหล่านั้นในสตริง

คืนค่า true หากคุณทำให้สตริง s1 และ s2 เท่ากัน และคืนค่า false หากไม่เช่นนั้น

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

อินพุต: s1 = "abcd", s2 = "cdab"
เอาต์พุต: true
คำอธิบาย: เราสามารถดำเนินการต่อไปนี้กับ s1 ได้:
- เลือกดัชนี i = 0, j = 2 สตริงที่ได้คือ s1 = "cbad"
- เลือกดัชนี i = 1, j = 3 สตริงที่ได้คือ s1 = "cdab" = s2

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

อินพุต: s1 = "abcd", s2 = "dacb"
เอาต์พุต: false
คำอธิบาย: ไม่สามารถทำให้สตริงทั้งสองเท่ากันได้

ข้อจำกัด:

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

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

เลือกดัชนีสองตัว i และ j เพื่อให้ j - i = 2 จากนั้นสลับอักขระสองตัวที่ดัชนีเหล่านั้นในสตริง

ส่งกลับ จริง หากคุณสามารถทําให้สตริง s1 และ s2 เท่ากับ และมิฉะนั้นจะ ปลอม

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

อินพุต: s1 = "abcd", s2 = "cdab"
เอาท์พุต: จริง
คําอธิบาย: เราสามารถดําเนินการต่อไปนี้ใน s1:
- เลือกดัชนี i = 0, j = 2 สตริงผลลัพธ์คือ s1 = "cbad"
- เลือกดัชนี i = 1, j = 3 สตริงผลลัพธ์คือ s1 = "cdab" = s2

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

อินพุต: s1 = "abcd", s2 = "dacb"
เอาต์พุต: เท็จ
คําอธิบาย: เป็นไปไม่ได้ที่จะทําให้ทั้งสองสตริงเท่ากับ

ข้อจํากัด:

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


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

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

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

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

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

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

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

ข้อจำกัด:

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

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

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

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

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

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

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

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

ข้อ จำกัด :

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

คุณมีอาร์เรย์ตัวเลขจำนวนเต็มที่มีดัชนี 0 ชื่อ nums และจำนวนเต็ม x
หาค่าความแตกต่างสัมบูรณ์ขั้นต่ำสุดระหว่างสององค์ประกอบในอาร์เรย์ที่อยู่ห่างกันอย่างน้อย x ดัชนี
กล่าวอีกนัยหนึ่ง หาดัชนี i และ j ที่ทำให้ abs(i - j) >= x และ abs(nums[i] - nums[j]) มีค่าน้อยที่สุด
ส่งคืนจำนวนเต็มที่แสดงถึงค่าความแตกต่างสัมบูรณ์ขั้นต่ำสุดระหว่างสององค์ประกอบที่อยู่ห่างกันอย่างน้อย x ดัชนี

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

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

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

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

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

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

ข้อจำกัด:

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


คุณได้รับจำนวนเต็มบวก low, high และ k
จำนวนหนึ่งจะถือว่าสวยงามถ้ามันตรงตามเงื่อนไขทั้งสองข้อดังต่อไปนี้:

1. จำนวนหลักคู่ในจำนวนเท่ากับจำนวนหลักคี่
2. จำนวนนี้หารด้วย k ลงตัว

ให้คืนค่าจำนวนจำนวนที่สวยงามในช่วง [low, high]

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

Input: low = 10, high = 20, k = 3
Output: 2
คำอธิบาย: มีจำนวนเต็มที่สวยงาม 2 ตัวในช่วงที่กำหนด: [12,18]
- 12 สวยงามเพราะมีตัวเลขคี่ 1 ตัวและตัวเลขคู่ 1 ตัว และหารด้วย k = 3 ลงตัว
- 18 สวยงามเพราะมีตัวเลขคี่ 1 ตัวและตัวเลขคู่ 1 ตัว และหารด้วย k = 3 ลงตัว
นอกจากนี้เรายังเห็นว่า:
- 16 ไม่สวยงามเพราะไม่สามารถหารด้วย k = 3 ลงตัว
- 15 ไม่สวยงามเพราะไม่มีจำนวนตัวเลขคู่และตัวเลขคี่ที่เท่ากัน
สามารถแสดงให้เห็นว่ามีจำนวนเต็มที่สวยงามเพียง 2 ตัวในช่วงที่กำหนดนี้

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

Input: low = 1, high = 10, k = 1
Output: 1
คำอธิบาย: มีจำนวนเต็มที่สวยงาม 1 ตัวในช่วงที่กำหนด: [10].
- 10 เป็นจำนวนที่สวยงามเพราะมีหลักเลขคี่ 1 หลักและหลักเลขคู่ 1 หลัก และสามารถหารด้วย k = 1 ได้
สามารถแสดงให้เห็นว่ามีจำนวนเต็มที่สวยงามเพียง 1 ตัวในช่วงที่กำหนดนี้.

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

Input: low = 5, high = 5, k = 2
Output: 0
คำอธิบาย: มีจำนวนเต็มที่สวยงาม 0 ตัวในช่วงที่กำหนด
- 5 ไม่สวยงามเพราะมันไม่สามารถหารด้วย k = 2 และมันไม่มีหลักคู่และคี่ที่เท่ากัน

ข้อจำกัด:

0 < low <= high <= 10^9
0 < k <= 20

คุณมีจำนวนเต็มบวก low, high, และ k
ตัวเลขจะถือว่าสวยงามถ้ามันตรงตามเงื่อนไขทั้งสองข้อต่อไปนี้:

จำนวนของตัวเลขหลักคู่ในตัวเลขนั้นเท่ากับจำนวนของตัวเลขหลักคี่
ตัวเลขนั้นหารด้วย k ลงตัว

ให้คืนค่าเป็นจำนวนของตัวเลขสวยงามในช่วง [low, high]

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

Input: low = 10, high = 20, k = 3
Output: 2
คำอธิบาย: มีตัวเลขสวยงาม 2 ตัวในช่วงที่ให้: [12,18]
- 12 สวยงามเพราะมีตัวเลขหลักคี่ 1 ตัวและหลักคู่ 1 ตัว และหารด้วย k = 3 ลงตัว
- 18 สวยงามเพราะมีตัวเลขหลักคี่ 1 ตัวและหลักคู่ 1 ตัว และหารด้วย k = 3 ลงตัว
เพิ่มเติม สามารถเห็นได้ว่า:
- 16 ไม่สวยงามเพราะไม่หารด้วย k = 3 ลงตัว
- 15 ไม่สวยงามเพราะไม่มีจำนวนหลักคู่และคี่ที่เท่ากัน
แสดงให้เห็นว่ามีตัวเลขสวยงามเพียง 2 ตัวในช่วงที่กำหนด

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

Input: low = 1, high = 10, k = 1
Output: 1
คำอธิบาย: มีตัวเลขสวยงาม 1 ตัวในช่วงที่ให้: [10]
- 10 สวยงามเพราะมีตัวเลขหลักคี่ 1 ตัวและหลักคู่ 1 ตัว และหารด้วย k = 1 ลงตัว
แสดงให้เห็นว่ามีตัวเลขสวยงามเพียง 1 ตัวในช่วงที่กำหนด

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

Input: low = 5, high = 5, k = 2
Output: 0
คำอธิบาย: มีตัวเลขสวยงาม 0 ตัวในช่วงที่ให้
- 5 ไม่สวยงามเพราะไม่หารด้วย k = 2 ลงตัวและไม่มีจำนวนตัวเลขหลักคู่และคี่ที่เท่ากัน

ข้อจำกัด:

0 < low <= high <= 10^9
0 < k <= 20

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

จำนวนตัวเลขคู่ในจำนวนเท่ากับจำนวนตัวเลขคี่
จำนวนหารด้วย k

ส่งคืนจำนวนจำนวนเต็มที่สวยงามในช่วง [low, high].

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

อินพุต: low = 10, high = 20, k = 3
เอาท์พุท: 2
คำอธิบาย: มีจำนวนเต็มที่สวยงาม 2 ตัวในช่วงที่กำหนด: [12,18]
-12 มีความสวยงามเพราะมี 1 หลักคี่และ 1 หลักคู่ และหารด้วย k = 3
- 18 มีความสวยงามเพราะมี 1 หลักคี่และ 1 หลักคู่ และหารด้วย k = 3
นอกจากนี้เราจะเห็นว่า:
- 16 ไม่สวยงามเพราะไม่สามารถหารด้วย k = 3
15 ไม่สวยงามเพราะไม่มีจำนวนตัวเลขคู่และคี่เท่ากัน.
สามารถแสดงให้เห็นว่ามีจำนวนเต็มที่สวยงามเพียง 2 ตัวในช่วงที่กำหนด

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

อินพุต: low = 1, high = 10, k = 1
เอาท์พุท: 1
คำอธิบาย: มีจำนวนเต็มที่สวยงาม 1 อันในช่วงที่กำหนด: [10]
- 10 มีความสวยงามเพราะมี 1 หลักคี่และ 1 หลักคู่ และหารด้วย k = 1.
มันสามารถแสดงให้เห็นว่ามีเพียง 1 จำนวนเต็มที่สวยงามในช่วงที่กำหนด

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

อินพุต: low = 5, high = 5, k = 2
เอาท์พุท: 0
คำอธิบาย: มีจำนวนเต็มที่สวยงาม 0 ในช่วงที่กำหนด
- 5 ไม่สวยงามเพราะมันไม่สามารถหารด้วย k = 2 และมันไม่มีตัวเลขคู่และคี่เท่ากัน.

ข้อ จำกัด :

0 < low <= high <= 10^9
0 < k <= 20


คุณจะได้รับสตริงที่มีดัชนี 0 สองตัวคือ str1 และ str2
ในการดำเนินการ คุณเลือกชุดดัชนีใน str1 และสำหรับดัชนี i แต่ละตัวในชุด ให้เพิ่ม str1[i] เป็นอักขระตัวถัดไปแบบวนซ้ำ นั่นคือ 'a' จะกลายเป็น 'b', 'b' จะกลายเป็น 'c' และอื่นๆ และ 'z' จะกลายเป็น 'a'
คืนค่า true หากสามารถทำให้ str2 เป็นลำดับย่อยของ str1 ได้โดยดำเนินการเพียงครั้งเดียว และคืนค่า false หากไม่สามารถทำได้
หมายเหตุ: ลำดับย่อยของสตริงคือสตริงใหม่ที่สร้างขึ้นจากสตริงดั้งเดิมโดยการลบอักขระบางตัว (อาจไม่มีเลย) โดยไม่รบกวนตำแหน่งสัมพันธ์ของอักขระที่เหลือ

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

อินพุต: str1 = "abc", str2 = "ad"
เอาต์พุต: true
คำอธิบาย: เลือกดัชนี 2 ใน str1
เพิ่ม str1[2] ให้กลายเป็น 'd' ดังนั้น str1 จึงกลายเป็น "abd" และ str2 จึงเป็นลำดับย่อย ดังนั้นจึงส่งคืน true
ตัวอย่างที่ 2:

อินพุต: str1 = "zc", str2 = "ad"
เอาต์พุต: true
คำอธิบาย: เลือกดัชนี 0 และ 1 ใน str1
เพิ่ม str1[0] ให้กลายเป็น 'a'
เพิ่ม str1[1] ให้กลายเป็น 'd'
ดังนั้น str1 จึงกลายเป็น "ad" และ str2 จึงเป็นลำดับย่อย ดังนั้นจึงส่งคืน true
ตัวอย่างที่ 3:

อินพุต: str1 = "ab", str2 = "d"
เอาต์พุต: false
คำอธิบาย: ในตัวอย่างนี้ จะแสดงให้เห็นว่าเป็นไปไม่ได้ที่จะทำให้ str2 เป็นลำดับย่อยของ str1 โดยใช้การดำเนินการเพียงครั้งเดียว
ดังนั้นจึงส่งคืน false

ข้อจำกัด:

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

คุณจะได้รับสตริงสองสตริงที่มีดัชนีเริ่มต้นที่ 0 คือ str1 และ str2
ในการดําเนินการ คุณเลือกชุดของดัชนีใน str1 และสําหรับแต่ละดัชนี i ในชุด ให้เพิ่ม str1[i] ไปยังอักขระถัดไปตามวัฏจักร นั่นคือ 'a' กลายเป็น 'b' 'b' กลายเป็น 'c' เป็นต้น และ 'z' กลายเป็น 'a'
ส่งคืน true ถ้าสามารถทําให้ str2 เป็นลําดับย่อยของ str1 ด้วยการดําเนินการมากที่สุดหนึ่งครั้ง ถ้าไม่ได้ ให้ส่งคืน false
หมายเหตุ: ลําดับย่อยของสตริงคือสตริงใหม่ที่เกิดขึ้นจากสตริงต้นฉบับโดยการลบอักขระบางตัว (อาจไม่มี) โดยไม่รบกวนตําแหน่งสัมพัทธ์ของอักขระที่เหลือ

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

อินพุต: str1 = "abc", str2 = "ad"
เอาท์พุต: true
คําอธิบาย: เลือกดัชนี 2 ใน str1
เพิ่ม str1[2] ให้เป็น 'd'
ดังนั้น str1 จึงกลายเป็น "abd" และ str2 เป็นลําดับย่อย ดังนั้น true จึงถูกส่งคืน
ตัวอย่างที่ 2:

อินพุต: str1 = "zc", str2 = "ad"
เอาท์พุต: จริง
คําอธิบาย: เลือกดัชนี 0 และ 1 ใน str1
เพิ่ม str1[0] ให้เป็น 'a'
เพิ่ม str1[1] ให้เป็น 'd'
ดังนั้น str1 จึงกลายเป็น "ad" และ str2 เป็นลําดับย่อย ดังนั้น true จึงถูกส่งคืน
ตัวอย่างที่ 3:

อินพุต: str1 = "ab", str2 = "d"
เอาต์พุต: false
คําอธิบาย: ในตัวอย่างนี้ สามารถแสดงได้ว่าเป็นไปไม่ได้ที่จะทําให้ str2 เป็นลําดับย่อยของ str1 โดยใช้การดําเนินการมากที่สุดครั้งเดียว
ดังนั้น false จะถูกส่งคืน

ข้อจํากัด:

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