มีไพ่สามใบที่มีตัวอักษร $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ วางเรียงตามลำดับในบางลำดับ คุณสามารถทำการสลับไพ่สองใบได้มากที่สุดเพียงครั้งเดียว:

- เลือกไพ่สองใบ แล้วสลับกัน สามารถทำให้เรียงเป็น $\texttt{abc}$ ได้หรือไม่? ให้แสดงผล "YES" ถ้าทำได้ และ "NO" ถ้าทำไม่ได้

Input

บรรทัดแรกมีจำนวนเต็ม $t$ ($1 \leq t \leq 6$) — จำนวนชุดทดสอบ

บรรทัดเดียวของแต่ละชุดทดสอบมีสตริงที่ประกอบด้วยตัวอักษร $\texttt{a}$, $\texttt{b}$ และ $\texttt{c}$ อย่างละหนึ่งตัวแทนไพ่

Output

สำหรับแต่ละชุดทดสอบ ให้แสดง "YES" ถ้าสามารถทำให้เรียงเป็น $\texttt{abc}$ ได้โดยใช้การดำเนินการมากที่สุดหนึ่งครั้ง หรือ "NO" ถ้าไม่สามารถทำได้

คุณสามารถแสดงผลคำตอบในรูปแบบใดก็ได้ (เช่น สตริง "yEs", "yes", "Yes" และ "YES" จะถูกยอมรับว่าเป็นคำตอบที่เป็นบวก)ตัวอย่างอินพุต 1:
6

abc

acb

bac

bca

cab

cba

ตัวอย่างOutput 1:

YES
YES
YES
NO
NO
YES

หมายเหตุ

ในชุดทดสอบแรก ไม่จำเป็นต้องทำการดำเนินการใด ๆ เนื่องจากเรียงอยู่ในรูปแบบ $\texttt{abc}$ แล้ว

ในชุดทดสอบที่สอง สามารถสลับ $\texttt{c}$ และ $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$

ในชุดทดสอบที่สาม สามารถสลับ $\texttt{b}$ และ $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$

ในชุดทดสอบที่สี่ ไม่สามารถทำให้เรียงเป็น $\texttt{abc}$ ด้วยการดำเนินการมากที่สุดหนึ่งครั้ง

มีไพ่สามใบพร้อมตัวอักษร $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ วางอยู่ในแถวในบางลำดับ คุณสามารถดำเนินการต่อไปนี้ได้มากที่สุดครั้งเดียว:

- เลือกไพ่สองใบแล้วสลับพวกเขา เป็นไปได้หรือไม่ที่แถวจะกลายเป็น $\texttt{abc}$ หลังจากการดำเนินการ? เอาต์พุต "YES" ถ้าเป็นไปได้และ "NO" มิฉะนั้น

ป้อนข้อมูล

บรรทัดแรกมีจำนวนเต็มเดียว $t$ ($1 \leq t \leq 6$) - จำนวนกรณีทดสอบ

บรรทัดเดียวของแต่ละกรณีการทดสอบมีสตริงเดียวที่ประกอบด้วยแต่ละอักขระสามอักขระ $\texttt{a}$, $\texttt{b}$, และ $\texttt{c}$ หนึ่งครั้งที่แสดงถึงการ์ด

เอาท์พุท

สำหรับแต่ละกรณีทดสอบเอาต์พุต "YES" หากคุณสามารถสร้างแถว $\texttt{abc}$ ด้วยการดำเนินการมากที่สุดหรือ "NO" มิฉะนั้น

คุณสามารถส่งออกคำตอบได้ในทุกกรณี (ตัวอย่างเช่นสตริง "yEs", "yes", "Yes"  และ YES" จะได้รับการยอมรับว่าเป็นคำตอบที่เป็นบวก) อินพุตตัวอย่าง 1:
6

abc

acb

bac

bca

cab

cba

ตัวอย่างเอาท์พุต 1:

YES
YES
YES
NO
NO
YES

บันทึก

ในกรณีทดสอบครั้งแรกเราไม่จำเป็นต้องดำเนินการใด ๆ เนื่องจากแถวนั้นมีอยู่แล้ว $\texttt{abc}$

ในกรณีทดสอบที่สองเราสามารถแลกเปลี่ยน $\texttt{c}$ and $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$

ในกรณีทดสอบครั้งที่สามเราสามารถแลกเปลี่ยน $\texttt{b}$ and $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$

ในกรณีทดสอบครั้งที่สี่มันเป็นไปไม่ได้ที่จะสร้าง $\texttt{abc}$ โดยใช้การดำเนินการมากที่สุดครั้งเดียว

มีไพ่สามใบที่มีตัวอักษร $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ วางเรียงกันเป็นแถวในลำดับใดลำดับหนึ่ง คุณสามารถทำการดำเนินการต่อไปนี้ได้มากที่สุดครั้งเดียว:

- เลือกไพ่สองใบและสลับกัน เป็นไปได้หรือไม่ที่แถวจะกลายเป็น $\texttt{abc}$ หลังจากการดำเนินการ ให้พิมพ์ "YES" หากเป็นไปได้ และพิมพ์ "NO" หากเป็นไปได้

อินพุต

บรรทัดแรกมีจำนวนเต็ม $t$ เพียงตัวเดียว ($1 \leq t \leq 6$) — จำนวนกรณีทดสอบ

บรรทัดเดียวของแต่ละกรณีทดสอบมีสตริงเดี่ยวที่ประกอบด้วยอักขระ $\texttt{a}$, $\texttt{b}$ และ $\texttt{c}$ แต่ละตัวเพียงครั้งเดียวเท่านั้น ซึ่งแสดงถึงไพ่

เอาต์พุต

สำหรับแต่ละชุดทดสอบ ให้แสดง "YES" ถ้าสามารถทำให้เรียงเป็น
abc
abc ได้โดยใช้การดำเนินการมากที่สุดหนึ่งครั้ง หรือ "NO" ถ้าไม่สามารถทำได้

คุณสามารถแสดงผลคำตอบในรูปแบบใดก็ได้ (เช่น สตริง "yEs", "yes", "Yes" และ "YES" จะถูกยอมรับว่าเป็นคำตอบที่เป็นบวก)ตัวอย่างอินพุต 1:
6

abc

acb

bac

bca

cab

cba

ตัวอย่างเอาต์พุต 1:

YES
YES
YES
NO
NO
YES

หมายเหตุ

ในกรณีทดสอบแรก เราไม่จำเป็นต้องดำเนินการใดๆ เนื่องจากแถวเป็น $\texttt{abc}$ อยู่แล้ว

ในกรณีทดสอบที่สอง เราสามารถสลับ $\texttt{c}$ และ $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$

ในกรณีทดสอบที่สาม เราสามารถสลับ $\texttt{b}$ และ $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$

ในกรณีทดสอบที่สี่ ไม่สามารถสร้าง $\texttt{abc}$ โดยใช้การดำเนินการมากที่สุดหนึ่งครั้งได้


Slavic กำลังเตรียมของขวัญวันเกิดให้เพื่อน เขามีอาเรย์ $a$ ของตัวเลข $n$ ตัว และของขวัญนั้นจะเป็นผลคูณของตัวเลขเหล่านี้ทั้งหมด เนื่องจาก Slavic เป็นคนดีที่ต้องการทำให้ผลคูณใหญ่ที่สุดเท่าที่จะเป็นไปได้ เขาต้องการเพิ่ม $1$ ให้กับตัวเลขหนึ่งตัวในอาเรย์

ผลคูณที่มากที่สุดที่ Slavic สามารถทำได้คือเท่าไร?

อินพุต

บรรทัดแรกประกอบด้วยจำนวนเต็ม $t$ ($1 \leq t \leq 10^4$) — จำนวนของชุดทดสอบ

บรรทัดแรกของแต่ละชุดทดสอบประกอบด้วยจำนวนเต็ม $n$ ($1 \leq n \leq 9$) — จำนวนของตัวเลข

บรรทัดที่สองของแต่ละชุดทดสอบประกอบด้วยจำนวนเต็ม $n$ ตัวคั่นด้วยช่องว่าง $a_i$ ($0 \leq a_i \leq 9$) — ตัวเลขในอาเรย์

เอาต์พุต

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

ตัวอย่างอินพุต 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

ตัวอย่างเอาต์พุต 1:

16
2
432
430467210

สลาฟกำลังเตรียมของขวัญวันเกิดให้เพื่อน เขามีอาร์เรย์ $a$ ของ $n$ หลัก และของขวัญจะเป็นผลคูณของหลักทั้งหมดเหล่านี้ เนื่องจากสลาฟเป็นเด็กดีที่ต้องการสร้างผลคูณที่มากที่สุด เขาจึงต้องการบวก $1$ เข้ากับหลักใดหลักหนึ่งของเขาพอดี

ผลคูณสูงสุดที่สลาฟสร้างได้คือเท่าไร

อินพุต

บรรทัดแรกมีจำนวนเต็ม $t$ เพียงตัวเดียว ($1 \leq t \leq 10^4$) — จำนวนกรณีทดสอบ

บรรทัดแรกของกรณีทดสอบแต่ละกรณีมีจำนวนเต็ม $n$ ตัวเดียว ($1 \leq n \leq 9$) — จำนวนหลัก

บรรทัดที่สองของแต่ละกรณีทดสอบมีจำนวนเต็มที่คั่นด้วยช่องว่าง $n$ ตัว $a_i$ ($0 \leq a_i \leq 9$) — หลักในอาร์เรย์

ผลลัพธ์

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

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

ผลลัพธ์ตัวอย่าง 1:

16
2
432
430467210

Slavic กำลังเตรียมของขวัญวันเกิดให้เพื่อน เขามีอาเรย์ $a$ ของตัวเลข $n$ ตัว และของขวัญนั้นจะเป็นผลคูณของตัวเลขเหล่านี้ทั้งหมด เนื่องจาก Slavic เป็นคนดีที่ต้องการทำให้ผลคูณใหญ่ที่สุดเท่าที่จะเป็นไปได้ เขาต้องการเพิ่ม $1$ ให้กับตัวเลขหนึ่งตัวในอาเรย์

ผลคูณที่มากที่สุดที่ Slavic สามารถทำได้คือเท่าไร?

Input

บรรทัดแรกประกอบด้วยจำนวนเต็ม $t$ ($1 \leq t \leq 10^4$) — จำนวนของชุดทดสอบ

บรรทัดแรกของแต่ละชุดทดสอบประกอบด้วยจำนวนเต็ม $n$ ($1 \leq n \leq 9$) — จำนวนของตัวเลข

บรรทัดที่สองของแต่ละชุดทดสอบประกอบด้วยจำนวนเต็ม $n$ ตัวคั่นด้วยช่องว่าง $a_i$ ($0 \leq a_i \leq 9$) — ตัวเลขในอาเรย์

Output

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

ตัวอย่างอินพุต 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

ตัวอย่างOutput 1:

16
2
432
430467210


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

ค้นหาจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการลบเซลล์สีดำทั้งหมด

อินพุต

บรรทัดแรกมีจำนวนเต็ม $t$ เพียงตัวเดียว ($1 \leq t \leq 1000$) — จำนวนกรณีทดสอบ

บรรทัดแรกของกรณีทดสอบแต่ละกรณีมีจำนวนเต็ม $n$ และ $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) — ความยาวของกระดาษและจำนวนเต็มที่ใช้ในการดำเนินการ

บรรทัดที่สองของแต่ละกรณีทดสอบประกอบด้วยสตริง $s$ ที่มีความยาว $n$ ซึ่งประกอบด้วยอักขระ $\texttt{B}$ (แทนเซลล์สีดำ) หรือ $\texttt{W}$ (แทนเซลล์สีขาว)
ผลรวมของ $n$ ในกรณีทดสอบทั้งหมดไม่เกิน $2 \cdot 10^5$
ผลลัพธ์

สำหรับกรณีทดสอบแต่ละกรณี ให้ผลลัพธ์เป็นจำนวนเต็มเพียงตัวเดียว ซึ่งเป็นจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการลบเซลล์สีดำทั้งหมด ตัวอย่างอินพุต 1:

8

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

ผลลัพธ์ตัวอย่าง 1:

2
1
2
1
4
3
4
0

หมายเหตุ

ในกรณีทดสอบแรก คุณสามารถดำเนินการต่อไปนี้ได้: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

ในกรณีทดสอบที่สอง คุณสามารถดำเนินการต่อไปนี้ได้: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

ในกรณีทดสอบที่สาม คุณสามารถดำเนินการต่อไปนี้ได้: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$

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

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

ป้อนข้อมูล

บรรทัดแรกมีจำนวนเต็มเดียว $ t $ ($ 1 \ leq t \ leq 1000 $) - จำนวนกรณีทดสอบ

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็มสองจำนวน $ n $ และ $ k $ ($ 1 \ leq k \ leq n \ leq 2 \ cdot 10^5 $) - ความยาวของกระดาษและจำนวนเต็มที่ใช้ในการดำเนินการ

บรรทัดที่สองของแต่ละกรณีการทดสอบมีสตริง $ s $ ของความยาว $ n $ ประกอบด้วยอักขระ $ \ texttt {B} $ (แทนเซลล์สีดำ) หรือ $ \ texttt {W} $ (แสดงเซลล์สีขาว)

ผลรวมของ $ n $ มากกว่ากรณีทดสอบทั้งหมดไม่เกิน $ 2 \ cdot 10^5 $

เอาท์พุท

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

6 3

WBWWWB

7 3

WWBWBWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

ตัวอย่างเอาท์พุท 1:

2
1
2
1
4
3
4
0

บันทึก

ในกรณีทดสอบครั้งแรกคุณสามารถดำเนินการต่อไปนี้: $$ \ color {red} {\ texttt {WBW}} \ texttt {WWB} \ to \ texttt {WWW} \ color {red} {\ texttt {WWB}} \ to \ texttt {WWWWWW} $$

ในกรณีทดสอบที่สองคุณสามารถดำเนินการต่อไปนี้: $$ \ texttt {WW} \ color {red} {\ texttt {BWB}} \ texttt {WW} \ to \ texttt {WWWWWWW} $$

ในกรณีทดสอบครั้งที่สามคุณสามารถดำเนินการต่อไปนี้: $$ \ texttt {B} \ color {red} {\ texttt {WBWB}} \ to \ color {red} {\ texttt {BWWW}} \ texttt {W} \ to \ texttt {WWWWW} $$


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

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

พาลินโดรมคือสตริงที่อ่านค่าไปข้างหน้าและข้างหลังได้เหมือนกัน ตัวอย่างเช่น สตริง "z", "aaa", "aba", "abccba" เป็นพาลินโดรม ในขณะที่สตริง "codeforces", "reality", "ab" ไม่ใช่

อินพุต

การทดสอบแต่ละครั้งประกอบด้วยกรณีทดสอบหลายกรณี บรรทัดแรกมีจำนวนเต็ม $t$ เพียงตัวเดียว ($1 \leq t \leq 10^4$) ซึ่งเป็นจำนวนกรณีทดสอบ ตามด้วยคำอธิบาย

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ และ $k$ ($0 \leq k < n \leq 10^5$) — ความยาวของสตริง $s$ และจำนวนอักขระที่ต้องการลบ

บรรทัดที่สองของแต่ละกรณีทดสอบมีสตริง $s$ ที่มีความยาว $n$ ซึ่งประกอบด้วยอักษรละตินตัวพิมพ์เล็ก

รับประกันว่าผลรวมของ $n$ ในทุกกรณีทดสอบจะไม่เกิน $2 \cdot 10^5$

ผลลัพธ์

สำหรับกรณีทดสอบแต่ละกรณี ให้ผลลัพธ์ "YES" หากสามารถลบอักขระ $k$ ตัวจากสตริง $s$ ได้พอดี โดยที่อักขระที่เหลือสามารถจัดเรียงใหม่เพื่อสร้างพาลินโดรมได้ และ "NO" ในกรณีอื่น

คุณสามารถผลลัพธ์คำตอบได้ในทุกกรณี (ตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก) ตัวอย่างเช่น สตริง "yEs" "yes" "Yes" และ "YES" จะถูกจดจำเป็นคำตอบเชิงบวก ตัวอย่างอินพุต 1:
14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

ตัวอย่างเอาต์พุต 1:

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

หมายเหตุ

ในกรณีทดสอบแรก ไม่มีสิ่งใดที่สามารถทำได้ ให้ลบออก และสตริง "a" จะเป็นพาลินโดรม

ในกรณีทดสอบที่สอง ไม่สามารถลบอะไรออกได้ แต่สตริง "ab" และ "ba" ไม่ใช่พาลินโดรม

ในกรณีทดสอบที่สาม สามารถลบอักขระใดๆ ก็ได้ และสตริงที่ได้จะเป็นพาลินโดรม

ในกรณีทดสอบที่สี่ สามารถลบอักขระ "a" ออกได้หนึ่งครั้ง ส่งผลให้สตริง "bb" ซึ่งเป็นพาลินโดรม

ในกรณีทดสอบที่หก สามารถลบอักขระ "b" และ "d" ออกได้หนึ่งครั้ง ส่งผลให้สตริง "acac" ซึ่งสามารถจัดเรียงใหม่เป็นสตริง "acca" ได้

ในกรณีทดสอบที่เก้า สามารถลบอักขระ "t" และ "k" ออกได้หนึ่งครั้ง ส่งผลให้สตริง "aagaa" ซึ่งเป็นพาลินโดรม

คุณจะได้รับสตริง $ s $ ของความยาว $ n $ ซึ่งประกอบด้วยตัวอักษรละตินตัวพิมพ์เล็กและจำนวนเต็ม $ k $

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

Palindrome เป็นสตริงที่อ่านไปข้างหน้าและย้อนกลับเดียวกัน ตัวอย่างเช่น Strings "z", "aaa", "aba", "abccba"  เป็น Palindromes ในขณะที่ Strings "codeforces", "Reality", "ab" ไม่ใช่

ป้อนข้อมูล

การทดสอบแต่ละครั้งประกอบด้วยหลายกรณีทดสอบ บรรทัดแรกมีจำนวนเต็มเดียว $ t $ ($ 1 \ leq t \ leq 10^4 $) - จำนวนกรณีทดสอบ ตามด้วยคำอธิบายของพวกเขา

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็มสองจำนวน $ n $ และ $ k $ ($ 0 \ leq k <n \ leq 10^5 $) - ความยาวของสตริง $ s $ และจำนวนอักขระที่จะถูกลบ

บรรทัดที่สองของแต่ละกรณีทดสอบมีสตริง $ s $ ของความยาว $ n $ ซึ่งประกอบด้วยตัวอักษรละตินตัวพิมพ์เล็ก

มีการรับประกันว่าผลรวมของ $ n $ มากกว่ากรณีทดสอบทั้งหมดไม่เกิน $ 2 \ cdot 10^5 $

เอาท์พุท

สำหรับแต่ละกรณีการทดสอบเอาต์พุต "ใช่" หากเป็นไปได้ที่จะลบอักขระ $ k $ ออกจากสตริง $ s $ ในลักษณะที่อักขระที่เหลือสามารถจัดเรียงใหม่เพื่อสร้าง palindrome และ "NO" เป็นอย่างอื่น

คุณสามารถส่งออกคำตอบในทุกกรณี (ตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก) ตัวอย่างเช่นสตริง "yEs", "yes", "Yes" และ "YES" จะได้รับการยอมรับว่าเป็นคำตอบที่เป็นบวกตัวอย่างอินพุต 1:
14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

ตัวอย่างเอาท์พุท 1:

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

บันทึก

ในกรณีทดสอบครั้งแรกไม่มีอะไรสามารถลบออกได้และสตริง "a" เป็น palindrome

ในกรณีทดสอบครั้งที่สองไม่มีอะไรสามารถลบออกได้ แต่สตริง "ab" และ "ba" ไม่ใช่ palindromes

ในกรณีทดสอบที่สามสามารถลบอักขระใด ๆ ได้และสตริงผลลัพธ์จะเป็น palindrome

ในกรณีการทดสอบครั้งที่สี่การเกิดขึ้นหนึ่งของตัวละคร "a" สามารถลบออกส่งผลให้สตริง "bb" ซึ่งเป็น palindrome

ในกรณีทดสอบครั้งที่หกสามารถลบตัวละคร "b" และ "d" ได้หนึ่งตัวส่งผลให้สตริง "acac" ซึ่งสามารถจัดเรียงใหม่เป็นสตริง "acca"

ในกรณีการทดสอบครั้งที่เก้าสามารถลบตัวละคร "t" และ "k" ได้หนึ่งตัวส่งผลให้สตริง "aagaa" ซึ่งเป็น palindrome

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

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

พาลินโดรมคือสตริงที่อ่านค่าไปข้างหน้าและข้างหลังได้เหมือนกัน ตัวอย่างเช่น สตริง "z", "aaa", "aba", "abccba" เป็นพาลินโดรม ในขณะที่สตริง "codeforces", "reality", "ab" ไม่ใช่

อินพุต

การทดสอบแต่ละครั้งประกอบด้วยกรณีทดสอบหลายกรณี บรรทัดแรกมีจำนวนเต็ม $t$ เพียงตัวเดียว ($1 \leq t \leq 10^4$) ซึ่งเป็นจำนวนกรณีทดสอบ ตามด้วยคำอธิบาย

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ และ $k$ ($0 \leq k < n \leq 10^5$) — ความยาวของสตริง $s$ และจำนวนอักขระที่ต้องการลบ

บรรทัดที่สองของแต่ละกรณีทดสอบมีสตริง $s$ ที่มีความยาว $n$ ซึ่งประกอบด้วยอักษรละตินตัวพิมพ์เล็ก

รับประกันว่าผลรวมของ $n$ ในทุกกรณีทดสอบจะไม่เกิน $2 \cdot 10^5$

ผลลัพธ์

สำหรับกรณีทดสอบแต่ละกรณี ให้ผลลัพธ์ "YES" หากสามารถลบอักขระ $k$ ตัวจากสตริง $s$ ได้พอดี โดยที่อักขระที่เหลือสามารถจัดเรียงใหม่เพื่อสร้างพาลินโดรมได้ และ "NO" ในกรณีอื่น

คุณสามารถผลลัพธ์คำตอบได้ในทุกกรณี (ตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก) ตัวอย่างเช่น สตริง "yEs" "yes" "Yes" และ "YES" จะถูกจดจำเป็นคำตอบเชิงบวก ตัวอย่างอินพุต 1:
14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

ตัวอย่างเอาต์พุต 1:

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Note

ในกรณีทดสอบแรก ไม่มีสิ่งใดที่สามารถทำได้ ให้ลบออก และสตริง "a" จะเป็นพาลินโดรม

ในกรณีทดสอบที่สอง ไม่สามารถลบอะไรออกได้ แต่สตริง "ab" และ "ba" ไม่ใช่พาลินโดรม

ในกรณีทดสอบที่สาม สามารถลบอักขระใดๆ ก็ได้ และสตริงที่ได้จะเป็นพาลินโดรม

ในกรณีทดสอบที่สี่ สามารถลบอักขระ "a" ออกได้หนึ่งครั้ง ส่งผลให้สตริง "bb" ซึ่งเป็นพาลินโดรม

ในกรณีทดสอบที่หก สามารถลบอักขระ "b" และ "d" ออกได้หนึ่งครั้ง ส่งผลให้สตริง "acac" ซึ่งสามารถจัดเรียงใหม่เป็นสตริง "acca" ได้

ในกรณีทดสอบที่เก้า สามารถลบอักขระ "t" และ "k" ออกได้หนึ่งครั้ง ส่งผลให้สตริง "aagaa" ซึ่งเป็นพาลินโดรม


คุณจะได้รับอาร์เรย์ของจำนวนเต็ม $a_1, a_2, \ldots, a_n$ และตัวเลข $k$ ($2 \leq k \leq 5$) ในการดำเนินการครั้งเดียว คุณสามารถทำสิ่งต่อไปนี้ได้:

- เลือกดัชนี $1 \leq i \leq n$,
- กำหนด $a_i = a_i + 1$ ค้นหาจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการทำให้ผลคูณของตัวเลขทั้งหมดในอาร์เรย์ $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ หารด้วย $k$ ลงตัว

อินพุต

การทดสอบแต่ละครั้งประกอบด้วยกรณีทดสอบหลายกรณี บรรทัดแรกมีจำนวนเต็ม $t$ เพียงจำนวนเดียว ($1 \leq t \leq 10^4$) — จำนวนกรณีทดสอบ จากนั้นจึงตามด้วยคำอธิบายของกรณีทดสอบ

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ และ $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — ขนาดของอาร์เรย์ $a$ และจำนวน $k$

บรรทัดที่สองของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$)

รับประกันว่าผลรวมของ $n$ ในทุกกรณีทดสอบจะไม่เกิน $2 \cdot 10^5$

ผลลัพธ์

สำหรับกรณีทดสอบแต่ละกรณี ให้ผลลัพธ์จำนวนการดำเนินการขั้นต่ำที่จำเป็นในการทำให้ผลคูณของตัวเลขทั้งหมดในอาร์เรย์หารด้วย $k$ ลงตัว ตัวอย่างอินพุต 1:
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

ผลลัพธ์ตัวอย่าง 1:

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

Note

ในกรณีทดสอบแรก เราต้องเลือกดัชนี $i = 2$ สองครั้ง หลังจากนั้น อาร์เรย์จะเป็น $a = [7, 5]$ ผลคูณของตัวเลขทั้งหมดในอาร์เรย์คือ $35$

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

ในกรณีทดสอบที่แปด เราสามารถดำเนินการสองอย่างได้โดยเลือก $i = 2$ และ $i = 3$ ในลำดับใดก็ได้ หลังจากนั้น อาร์เรย์จะเป็น $a = [1, 6, 10]$ ผลคูณของตัวเลขในอาร์เรย์คือ $60$

คุณจะได้รับอาร์เรย์ของจำนวนเต็ม $a_1, a_2, \ldots, a_n$ และตัวเลข $k$ ($2 \leq k \leq 5$) ในการดำเนินการครั้งเดียว คุณสามารถทำสิ่งต่อไปนี้ได้:

- เลือกดัชนี $1 \leq i \leq n$,
- กำหนด $a_i = a_i + 1$ ค้นหาจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการทำให้ผลคูณของตัวเลขทั้งหมดในอาร์เรย์ $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ หารด้วย $k$ ลงตัว

อินพุต

การทดสอบแต่ละครั้งประกอบด้วยกรณีทดสอบหลายกรณี บรรทัดแรกมีจำนวนเต็ม $t$ เพียงจำนวนเดียว ($1 \leq t \leq 10^4$) — จำนวนกรณีทดสอบ จากนั้นจึงตามด้วยคำอธิบายของกรณีทดสอบ

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ และ $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — ขนาดของอาร์เรย์ $a$ และจำนวน $k$

บรรทัดที่สองของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$)

รับประกันว่าผลรวมของ $n$ ในทุกกรณีทดสอบจะไม่เกิน $2 \cdot 10^5$

ผลลัพธ์

สำหรับกรณีทดสอบแต่ละกรณี ให้ผลลัพธ์จำนวนการดำเนินการขั้นต่ำที่จำเป็นในการทำให้ผลคูณของตัวเลขทั้งหมดในอาร์เรย์หารด้วย $k$ ลงตัว ตัวอย่างอินพุต 1:
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

ผลลัพธ์ตัวอย่าง 1:

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

หมายเหตุ

ในกรณีทดสอบแรก เราต้องเลือกดัชนี $i = 2$ สองครั้ง หลังจากนั้น อาร์เรย์จะเป็น $a = [7, 5]$ ผลคูณของตัวเลขทั้งหมดในอาร์เรย์คือ $35$

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

ในกรณีทดสอบที่แปด เราสามารถดำเนินการสองอย่างได้โดยเลือก $i = 2$ และ $i = 3$ ในลำดับใดก็ได้ หลังจากนั้น อาร์เรย์จะเป็น $a = [1, 6, 10]$ ผลคูณของตัวเลขในอาร์เรย์คือ $60$

คุณได้รับอาร์เรย์จำนวนเต็ม a_1, a_2, \ldots, a_n และค่าหนึ่ง k (2 \leq k \leq 5)
ในหนึ่งการดำเนินการ คุณสามารถทำสิ่งต่อไปนี้ได้:
	•	เลือกดัชนี 1 \leq i \leq n
	•	กำหนดค่า a_i = a_i + 1

คำถาม: หา จำนวนครั้งขั้นต่ำของการดำเนินการ ที่จำเป็นเพื่อให้ผลคูณของตัวเลขทั้งหมดในอาร์เรย์ a_1 \cdot a_2 \cdot \ldots \cdot a_n หารด้วย k ลงตัว
อินพุต

อินพุตประกอบด้วยหลายเคสการทดสอบ
	•	บรรทัดแรกประกอบด้วยจำนวนเต็ม t (1 \leq t \leq 10^4) — จำนวนเคสการทดสอบ
	•	จากนั้นตามด้วยรายละเอียดของแต่ละเคส

แต่ละเคสการทดสอบประกอบด้วย:
	1.	บรรทัดแรกมีจำนวนเต็มสองตัว n และ k (2 \leq n \leq 10^5, 2 \leq k \leq 5) — ขนาดของอาร์เรย์ a และตัวเลข k
	2.	บรรทัดที่สองมีจำนวนเต็ม n ตัว a_1, a_2, \ldots, a_n (1 \leq a_i \leq 10)

เงื่อนไข:
	•	ผลรวมของ n จากทุกเคสการทดสอบรวมกันไม่เกิน 2 \cdot 10^5
เอาต์พุต

สำหรับแต่ละเคสการทดสอบ ให้พิมพ์จำนวนการดำเนินการขั้นต่ำที่จำเป็นในบรรทัดเดียว
ตัวอย่างอินพุต
15
2 5
7 3
3 3
7 4 1
5 2
9 7 7 3 9
5 5
5 4 1 2 3
7 4
9 5 1 5 9 5 1
3 4
6 3 6
3 4
6 1 5
3 4
1 5 9
4 4
1 4 1 1
3 4
3 5 3
4 5
8 9 9 3
2 5
1 6
2 5
10 10
4 5
1 6 1 1
2 5
7 7
ตัวอย่างเอาต์พุต 1:

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

โน้ต

ในกรณีทดสอบแรก เราต้องเลือกดัชนี $i = 2$ สองครั้ง หลังจากนั้นอาร์เรย์จะเป็น $a = [7, 5]$ ผลคูณของตัวเลขทั้งหมดในอาร์เรย์คือ $35$

ในกรณีทดสอบที่สี่ ผลคูณของตัวเลขในอาร์เรย์คือ $120$ ซึ่งหารด้วย $5$ ลงตัวแล้ว ดังนั้นจึงไม่จําเป็นต้องดําเนินการใดๆ

ในกรณีทดสอบที่แปดเราสามารถดําเนินการสองอย่างได้โดยเลือก $i = 2$ และ $i = 3$ ตามลําดับใดก็ได้ หลังจากนั้นอาร์เรย์จะเป็น $a = [1, 6, 10]$ ผลคูณของตัวเลขในอาร์เรย์คือ $60$


Vanya และ Vova กำลังเล่นเกม ผู้เล่นจะได้รับจำนวนเต็ม $n$ ในตาของพวกเขา ผู้เล่นสามารถเพิ่ม $1$ ลงในจำนวนเต็มปัจจุบันหรือลบ $1$ ผู้เล่นผลัดกัน Vanya เริ่มเกม หากหลังจากที่ Vanya เดิน จำนวนเต็มหารด้วย $3$ ลงตัว Vanya จะเป็นผู้ชนะ หากผ่านไปแล้ว $10$ เดินและ Vanya ไม่ชนะ Vova จะเป็นผู้ชนะ

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

อินพุต

บรรทัดแรกประกอบด้วยจำนวนเต็ม $t$ ($1 \leq t \leq 100$) — จำนวนกรณีทดสอบ

บรรทัดเดียวของแต่ละกรณีทดสอบประกอบด้วยจำนวนเต็ม $n$ ($1 \leq n \leq 1000$)

ผลลัพธ์

สำหรับกรณีทดสอบแต่ละกรณี ให้พิมพ์ "First" โดยไม่ต้องใส่เครื่องหมายคำพูด หาก Vanya ชนะ และพิมพ์ "Second" โดยไม่ต้องใส่เครื่องหมายคำพูด หาก Vova ชนะ ตัวอย่างอินพุต 1:

6

1

3

5

100

999

1000

ผลลัพธ์ตัวอย่าง 1:

First
Second
First
First
Second
First

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

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

Input

บรรทัดแรกประกอบด้วยจำนวนเต็ม $t$ ($1 \leq t \leq 100$) — จำนวนกรณีทดสอบ

บรรทัดเดียวของแต่ละกรณีทดสอบประกอบด้วยจำนวนเต็ม $n$ ($1 \leq n \leq 1000$)

Output

สำหรับแต่ละกรณีทดสอบ ให้พิมพ์ "First" โดยไม่มีเครื่องหมายคำพูด หาก Vanya ชนะ และ "Second" โดยไม่มีเครื่องหมายคำพูด หาก Vova ชนะ ตัวอย่างข้อมูลนำเข้า 1:

ตัวอย่างInput 1:
6

1

3

5

100

999

1000

ตัวอย่าง Output 1:

First
Second
First
First
Second
First


อเล็กซ์มีส่วนร่วมในการถ่ายทำวิดีโอของ BrMeast อีกครั้งและ BrMeast ขอให้อเล็กซ์เตรียมทีเอ็นที 250,000 ตัน แต่อเล็กซ์ไม่ได้ยินเขาดีดังนั้นเขาจึงเตรียมกล่อง $n$ และจัดเรียงเป็นแถวรอรถบรรทุก กล่อง $i$-th จากด้านซ้ายมีน้ำหนัก $a_i$ ตัน

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

- กล่อง $k$ แรกไปที่รถบรรทุกคันแรก
- กล่อง $k$ ที่สองไปที่รถบรรทุกคันที่สอง
- $ \dotsb$
- กล่อง $k$ สุดท้ายไปที่  $\frac{n}{k}$-th truck  เมื่อโหลดเสร็จสิ้นรถบรรทุกแต่ละคันจะต้องมีกล่อง $k$ อย่างแน่นอน กล่าวอีกนัยหนึ่งถ้าในบางจุดมันเป็นไปไม่ได้ที่จะโหลดกล่อง $k$ ลงในรถบรรทุกแล้วตัวเลือกการโหลดด้วย $k$ นั้นเป็นไปไม่ได้

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

อเล็กซ์มีการเชื่อมต่อค่อนข้างมากดังนั้นสำหรับทุก ๆ  $1 \leq k \leq n$  เขาสามารถค้นหา บริษัท ที่รถบรรทุกแต่ละคันสามารถเก็บกล่อง $k$ ได้อย่างแน่นอน พิมพ์ความแตกต่างสัมบูรณ์สูงสุดระหว่างน้ำหนักรวมของรถบรรทุกสองคันใด ๆ

ป้อนข้อมูล

บรรทัดแรกมีหนึ่งจำนวนเต็ม $t$ ($1 \leq t \leq 10^4$) - จำนวนกรณีทดสอบ

บรรทัดแรกของแต่ละกรณีการทดสอบมีหนึ่งจำนวนเต็ม $n$ ($1 \leq n \leq 150\,000$) - จำนวนกล่อง

บรรทัดที่สองมี $n$ จำนวนเต็ม $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) - น้ำหนักของกล่อง

มีการรับประกันว่าผลรวมของ $n$ สำหรับกรณีทดสอบทั้งหมดไม่เกิน $ 150\,000 $

เอาท์พุท

สำหรับแต่ละกรณีทดสอบให้พิมพ์จำนวนเต็มเดียว - คำตอบของปัญหาตัวอย่างอินพุต 1:
5

2

1 2

6

10 2 3 6 1 3

4

100000000 1000000000 100000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

ตัวอย่างเอาท์พุท 1:

1
9
0
189114
112141

บันทึก

ในกรณีแรกเราควรเลือกรถบรรทุกสองคันดังนั้นรถคันแรกจะมีเพียงกล่องแรกเท่านั้นและอันที่สองจะมีเพียงกล่องที่สองเท่านั้น

ในกรณีที่สองเราควรเลือกรถบรรทุกหกคันดังนั้นค่าสูงสุดจะเป็น $10$ ขั้นต่ำจะเป็น $1$ และคำตอบคือ $10 - 1= 9$

ในกรณีที่สามสำหรับ $k$, ที่เป็นไปได้รถบรรทุกจะมีน้ำหนักรวมของกล่องทั้งหมดดังนั้นคำตอบคือ $0$.

อเล็กซ์กำลังมีส่วนร่วมในการถ่ายทำวิดีโออื่นของ BrMeast และ BrMeast ขอให้อเล็กซ์เตรียม TNT 250,000 ตัน แต่อเล็กซ์ไม่ได้ยินสิ่งที่เขาพูด จึงเตรียมกล่อง $n$ กล่องและจัดเรียงเป็นแถวรอรถบรรทุก กล่องที่ $i$ จากซ้ายมีน้ำหนัก $a_i$ ตัน

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

- กล่อง $k$ แรกจะถูกส่งไปยังรถบรรทุกคันแรก
- กล่อง $k$ ที่สองจะถูกส่งไปยังรถบรรทุกคันที่สอง
- $\dotsb$
- กล่อง $k$ สุดท้ายจะถูกส่งไปยังรถบรรทุกคันที่ $\frac{n}{k}$ เมื่อการโหลดเสร็จสิ้น รถบรรทุกแต่ละคันจะต้องมีกล่อง $k$ พอดี กล่าวอีกนัยหนึ่ง หากในบางจุดไม่สามารถโหลดกล่อง $k$ ลงในรถบรรทุกได้พอดี ก็ไม่สามารถโหลดด้วย $k$ นั้นได้

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

อเล็กซ์มีการเชื่อมโยงค่อนข้างมาก ดังนั้นสำหรับทุกๆ $1 \leq k \leq n$ เขาสามารถค้นหาบริษัทที่รถบรรทุกแต่ละคันสามารถบรรทุกกล่องได้พอดี $k$ พิมพ์ความแตกต่างสัมบูรณ์สูงสุดระหว่างน้ำหนักรวมของรถบรรทุกสองคันใดๆ

อินพุต

บรรทัดแรกมีจำนวนเต็ม $t$ หนึ่งจำนวน ($1 \leq t \leq 10^4$) ซึ่งเป็นจำนวนกรณีทดสอบ

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ หนึ่งจำนวน ($1 \leq n \leq 150\,000$) ซึ่งเป็นจำนวนกล่อง

บรรทัดที่สองมีจำนวนเต็ม $n$ จำนวน $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) ซึ่งเป็นน้ำหนักของกล่อง

รับประกันว่าผลรวม $n$ สำหรับกรณีทดสอบทั้งหมดจะไม่เกิน $150\,000$

ผลลัพธ์

สำหรับแต่ละกรณีทดสอบ ให้พิมพ์จำนวนเต็มตัวเดียว — คำตอบของปัญหา ตัวอย่างอินพุต 1:

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

ผลลัพธ์ตัวอย่าง 1:

1
9
0
189114
112141

หมายเหตุ

ในกรณีแรก เราควรเลือกรถบรรทุก 2 คัน โดยคันแรกจะมีเฉพาะกล่องแรก และคันที่สองจะมีเฉพาะกล่องที่สอง

ในกรณีที่สอง เราควรเลือกรถบรรทุก 6 คัน ดังนั้น จำนวนสูงสุดจะเท่ากับ 10 คัน จำนวนต่ำสุดจะเท่ากับ 1 คัน และคำตอบคือ 10 - 1 = 9 คัน

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

Alex กำลังเข้าร่วมการถ่ายทำวิดีโอของ BrMeast และ BrMeast ขอให้ Alex เตรียม TNT จำนวน 250,000 ตัน แต่ Alex ได้ยินไม่ชัดเจน จึงเตรียมกล่อง $n$ ใบและจัดเรียงเรียบร้อยรอรถบรรทุก กล่องใบที่ $i$ จากด้านซ้ายมีน้ำหนัก $a_i$ ตัน

รถบรรทุกทั้งหมดจะมีจำนวนกล่องเท่ากัน ซึ่งแสดงด้วย $k$ กระบวนการบรรทุกจะเกิดขึ้นดังนี้:

- กล่อง $k$ แรกไปที่รถบรรทุกคันแรก,
- กล่อง $k$ ที่สองไปที่รถบรรทุกคันที่สอง,
- $\dotsb$
- กล่อง $k$ สุดท้ายไปที่รถบรรทุกคันที่ $\frac{n}{k}$ เมื่อการบรรทุกเสร็จสมบูรณ์ รถบรรทุกแต่ละคันต้องมีกล่องจำนวน $k$ เท่ากัน กล่าวอีกนัยหนึ่ง หากในบางขณะไม่สามารถบรรทุกกล่อง $k$ กล่องเข้าไปในรถบรรทุกได้ ตัวเลือกการบรรทุกด้วย $k$ นั้นจะไม่สามารถทำได้

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

Alex มีการเชื่อมต่อหลายอย่าง ดังนั้นสำหรับทุก $1 \leq k \leq n$ เขาสามารถหาบริษัทที่รถบรรทุกแต่ละคันสามารถถือกล่องได้ $k$ กล่อง พิมพ์ส่วนต่างสัมบูรณ์สูงสุดระหว่างน้ำหนักรวมของรถบรรทุกใด ๆ สองคัน

Input

บรรทัดแรกประกอบด้วยจำนวนเต็ม $t$ ($1 \leq t \leq 10^4$) — จำนวนกรณีทดสอบ

บรรทัดแรกของแต่ละกรณีทดสอบประกอบด้วยจำนวนเต็ม $n$ ($1 \leq n \leq 150\,000$) — จำนวนกล่อง

บรรทัดที่สองประกอบด้วยจำนวนเต็ม $n$ ตัว $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — น้ำหนักของกล่อง

มันถูกรับประกันว่าผลรวมของ $n$ สำหรับทุกกรณีทดสอบไม่เกิน $150,000$

Output

สำหรับแต่ละกรณีทดสอบ ให้พิมพ์จำนวนเต็มหนึ่งตัว — คำตอบของปัญหา

ตัวอย่างInput 1:

5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

ตัวอย่างOutput 1:

1
9
0
189114
112141

หมายเหตุ

ในกรณีแรก เราควรเลือกสองรถบรรทุก ดังนั้นคันแรกจะมีเพียงกล่องแรก และคันที่สองจะมีเพียงกล่องที่สอง

ในกรณีที่สอง เราควรเลือกหกรถบรรทุก ดังนั้นค่ามากที่สุดจะเป็น $10$ ค่าต่ำสุดจะเป็น $1$ และคำตอบคือ $10 - 1 = 9$

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


ซับอาร์เรย์เป็นส่วนต่อเนื่องของอาร์เรย์

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

ตัวอย่างเช่น $[1, 2, 3]$ เป็นที่ยอมรับได้ แต่ $[1, 2, 4]$ เป็นที่ยอมรับไม่ได้ เนื่องจาก $2$ และ $4$ ทั้งคู่เป็นคู่และอยู่ติดกัน

คุณต้องช่วย Yarik โดยหาผลรวมสูงสุดของซับอาร์เรย์ดังกล่าว

อินพุต

บรรทัดแรกมีจำนวนเต็ม $t$ $(1 \le t \le 10^4)$ — จำนวนกรณีทดสอบ แต่ละกรณีทดสอบจะอธิบายดังต่อไปนี้

บรรทัดแรกของแต่ละกรณีทดสอบมีจำนวนเต็ม $n$ $(1 \le n \le 2 \cdot 10^5)$ — ความยาวของอาร์เรย์

บรรทัดที่สองของแต่ละกรณีทดสอบจะมีจำนวนเต็ม $n$ จำนวน คือ $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — องค์ประกอบของอาร์เรย์

รับประกันว่าผลรวมของ $n$ สำหรับกรณีทดสอบทั้งหมดจะไม่เกิน $2 \cdot 10^5$

ผลลัพธ์

สำหรับกรณีทดสอบแต่ละกรณี ให้ผลลัพธ์เป็นจำนวนเต็มเพียงตัวเดียว ซึ่งเป็นคำตอบของปัญหา ตัวอย่างอินพุต 1:
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

-10 5 -8 10 6 -10 7 9 -2 -6 7 2 -4 6 -1 7 -6 -7 4 1

ผลลัพธ์ตัวอย่าง 1:

15
17
8
4
-1000
101
10


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

เนื่องจาก Yarik ชอบวิชาคอมพิวเตอร์เช่นกัน ในระบบของเขา โน้ตจึงแสดงด้วยจำนวนเต็ม $2^k$ โดยที่ $k \ge 1$ ซึ่งเป็นจำนวนเต็มบวก แต่คุณคงทราบดีอยู่แล้วว่าคุณไม่สามารถใช้โน้ตเพียงอย่างเดียวในการเขียนเพลงได้ ดังนั้น Yarik จึงใช้ชุดโน้ตสองตัว ชุดโน้ต $(a, b)$ โดยที่ $a = 2^k$ และ $b = 2^l$ แสดงด้วยจำนวนเต็ม $a^b$

ตัวอย่างเช่น ถ้า $a = 8 = 2^3$, $b = 4 = 2^2$ ดังนั้นชุดค่าผสม $(a, b)$ จะแสดงด้วยจำนวนเต็ม $a^b = 8^4 = 4096$ โปรดทราบว่าชุดค่าผสมที่แตกต่างกันอาจมีสัญลักษณ์เดียวกันได้ เช่น ชุดค่าผสม $(64, 2)$ จะแสดงด้วยจำนวนเต็ม $4096 = 64^2$ เช่นกัน

Yarik ได้เลือกโน้ต $n$ ตัวที่ต้องการใช้ในทำนองใหม่ของเขาแล้ว อย่างไรก็ตาม เนื่องจากจำนวนเต็มของโน้ตเหล่านี้สามารถมีขนาดใหญ่ได้มาก เขาจึงเขียนโน้ตเหล่านี้ลงในอาร์เรย์ $a$ ที่มีความยาว $n$ ดังนั้นโน้ต $i$ จึงเป็น $b_i = 2^{a_i}$ จำนวนเต็มในอาร์เรย์ $a$ สามารถทำซ้ำได้

ทำนองจะประกอบด้วยชุดค่าผสมของโน้ตสองตัวหลายตัว Yarik สงสัยว่ามีคู่โน้ต $b_i, b_j$ $(i < j)$ กี่คู่ที่ทำให้ชุดค่าผสม $(b_i, b_j)$ เท่ากับชุดค่าผสม $(b_j, b_i)$ กล่าวอีกนัยหนึ่ง เขาต้องการนับจำนวนคู่ $(i, j)$ $(i < j)$ ที่ทำให้ $b_i^{b_j} = b_j^{b_i}$ ช่วยเขาหาจำนวนคู่ดังกล่าว

อินพุต

บรรทัดแรกของอินพุตมีจำนวนเต็ม $t$ หนึ่งจำนวน ($1 \le t \le 10^4$) ซึ่งเป็นจำนวนกรณีทดสอบ

บรรทัดแรกของกรณีทดสอบแต่ละกรณีมีจำนวนเต็ม $n$ หนึ่งจำนวน ($1 \leq n \leq 2 \cdot 10^5$) ซึ่งเป็นความยาวของอาร์เรย์

บรรทัดถัดไปมีจำนวนเต็ม $n$ ตัว $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — อาร์เรย์ $a$

รับประกันว่าผลรวมของ $n$ ในทุกกรณีทดสอบจะไม่เกิน $2 \cdot 10^5$

ผลลัพธ์

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

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

2 4 1 6 2 8 5 4 2 10 5 10 8 7 4 3 2 6 10

ตัวอย่างเอาต์พุต 1:

0
2
1
3
19

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

เนื่องจาก Yarik ชอบสารสนเทศ ในระบบของเขา โน้ตจะถูกแทนด้วยจำนวนเต็มรูปแบบ $2^k$ โดยที่ $k \ge 1$ เป็นจำนวนเต็มบวก แต่เท่าที่เราทราบ คุณไม่สามารถใช้โน้ตในการแต่งเพลงได้ ดังนั้น Yarik ใช้โน้ตสองตัวผสมกัน การรวมกันโน้ตสองตัว $(a, b)$ โดยที่ $a = 2^k$ และ $b = 2^l$ เขาแสดงด้วยจำนวนเต็ม $a^b$

ตัวอย่างเช่น หาก $a = 8 = 2^3$, $b = 4 = 2^2$ การผสม $(a, b)$ นี้จะแสดงด้วยจำนวนเต็ม $a^b = 8^4 = 4096$ โปรดทราบว่าการผสมต่าง ๆ อาจมีสัญลักษณ์เดียวกัน ยกตัวอย่างเช่นการผสม $(64, 2)$ ก็ยังฉศโ.ด้วยจำนวนเต็ม $4096 = 64^2$ เหมือนกัน

Yarik ได้เลือกโน้ต $n$ ตัวที่เขาต้องการใช้ในทำนองใหม่นี้ แต่เนื่องจากจำนวนเต็มเหล่านี้อาจมีขนาดใหญ่มาก เขาจึงเขียนลงในรูปแบบอาเรย์ $a$ ความยาว $n$ ดังนั้นโน้ตที่ $i$ คือ $b_i = 2^{a_i}$ จำนวนเต็มในอาเรย์ $a$ อาจซ้ำได้

ทำนองเพลงจะประกอบด้วยการผสมของโน้ตสองคู่ Yarik สงสัยว่ามีกี่คู่ของโน้ต $b_i, b_j$ $(i < j)$ ที่มีการผสม $(b_i, b_j)$ เท่ากับการผสม $(b_j, b_i)$ พูดอีกนัยหนึ่งคือ เขาต้องการนับจำนวนคู่ $(i, j)$ $(i < j)$ ที่ทำให้ $b_i^{b_j} = b_j^{b_i}$ ช่วยเขานับจำนวนคู่ดังกล่าว

Input

บรรทัดแรกของอินพุตประกอบด้วยจำนวนเต็ม $t$ ($1 \le t \le 10^4$) จำนวนของเคสที่ทดสอบ

บรรทัดแรกของแต่ละเคสการทดสอบประกอบด้วยจำนวนเต็ม $n$ ($1 \leq n \leq 2 \cdot 10^5$) ความยาวของอาเรย์

บรรทัดถัดไปประกอบด้วยจำนวนเต็ม $n$ ตัว $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) อาเรย์ $a$

มีการรับประกันว่าผลรวมของ $n$ สำหรับทุกเคสการทดสอบจะไม่เกิน $2 \cdot 10^5$

Output

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

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

2 4 1 6 2 8 5 4 2 10 5 10 8 7 4 3 2 6 10

ตัวอย่าง Output 1:

0
2
1
3
19

ยาริก เป็นแฟนตัวยงของดนตรีหลายประเภท แต่ Yarik ไม่เพียงแต่ชอบฟังเพลงเท่านั้น แต่ยังชอบเขียนเพลงด้วย เขาชอบดนตรีอิเล็กทรอนิกส์มากที่สุดดังนั้นเขาจึงสร้างระบบโน้ตดนตรีของตัวเองซึ่งในความคิดของเขาดีที่สุดสําหรับมัน

เนื่องจาก ยาริก ชอบสารสนเทศเช่นกันในบันทึกระบบของเขาจะแสดงด้วยจํานวนเต็ม $2^k$ โดยที่ $k \ge 1$ ซึ่งเป็นจํานวนเต็มบวก คุณไม่สามารถใช้แค่โน้ตในการเขียนเพลงได้ ดังนั้น ยาริก จึงใช้โน้ตสองตัวรวมกัน การรวมกันของโน้ตสองตัว $(a, b)$ โดยที่ $a = 2^k$ และ $b = 2^l$ เขาแสดงด้วยจํานวนเต็ม $a^b$

ตัวอย่างเช่น ถ้า $a = 8 = 2^3$, $b = 4 = 2^2$ ชุดค่าผสม $(a, b)$ จะแสดงด้วยจํานวนเต็ม $a^b = 8^4 = 4096$ โปรดทราบว่าชุดค่าผสมที่แตกต่างกันสามารถมีสัญกรณ์เดียวกันได้ เช่น ชุดค่าผสม $(64, 2)$ จะแสดงด้วยจํานวนเต็ม $4096 = 64^2$

ยาริก ได้เลือกโน้ต $n$ ที่เขาต้องการใช้ในทํานองใหม่ของเขาแล้ว อย่างไรก็ตามเนื่องจากจํานวนเต็มของพวกมันอาจมีขนาดใหญ่มากเขาจึงเขียนเป็นอาร์เรย์ $a$ ที่มีความยาว $n$ ดังนั้นโน้ต $i$ คือ $b_i = 2^{a_i}$ จํานวนเต็มในอาร์เรย์ $a$ สามารถทําซ้ําได้

ท่วงทํานองจะประกอบด้วยการผสมผสานของโน้ตสองตัว Yarik สงสัยว่ามีโน้ต $b_i, b_j$ $(i < j)$ กี่คู่ เพื่อให้ชุดค่าผสม $(b_i, b_j)$ เท่ากับชุดค่าผสม $(b_j, b_i)$ กล่าวอีกนัยหนึ่งเขาต้องการนับจํานวนคู่ $(i, j)$ $(i < j)$ เพื่อให้ $b_i^{b_j} = b_j^{b_i}$ ช่วยเขาหาจํานวนคู่ดังกล่าว

อินพุต

บรรทัดแรกของอินพุตประกอบด้วยจํานวนเต็มหนึ่งจํานวน $t$ ($1\ le t \le 10^4$) — จํานวนกรณีทดสอบ

บรรทัดแรกของแต่ละกรณีทดสอบประกอบด้วยจํานวนเต็มหนึ่ง $n$ ($1\ leq n\ leq 2 \cdot 10^5$) — ความยาวของอาร์เรย์

บรรทัดถัดไปประกอบด้วยจํานวนเต็ม $n$ $a_1, a_2, dots, a_n$ ($1\ leq a_i\ leq 10^9$) — อาร์เรย์ $a$

รับประกันได้ว่าผลรวมของ $n$ ในกรณีทดสอบทั้งหมดไม่เกิน $2\ cdot 10^5$

ผลิตภัณฑ์

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

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

2 4 1 6 2 8 5 4 2 10 5 10 8 7 4 3 2 6 10

ตัวอย่างเอาต์พุต 1:

0
2
1
3
19


คุณได้รับอาเรย์ของสตริงที่เรียกว่า details ที่จัดแสดงแบบ 0-indexed แต่ละองค์ประกอบใน details ให้ข้อมูลเกี่ยวกับผู้โดยสารในรูปแบบที่ถูกบีบอัดเป็นสตริงที่มีความยาว 15 ตัวอักษร ระบบมีรายละเอียดดังนี้:

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

จงคืนจำนวนผู้โดยสารที่มีอายุมากกว่า 60 ปีจริง ๆ

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

Input: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Output: 2
คำอธิบาย: ผู้โดยสารที่ดัชนี 0, 1, และ 2 มีอายุ 75, 92, และ 40 ดังนั้นมี 2 คนที่อายุมากกว่า 60 ปี

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

Input: details = ["1313579440F2036","2921522980M5644"]
Output: 0
คำอธิบาย: ไม่มีผู้โดยสารคนใดที่มีอายุมากกว่า 60 ปี

ข้อจำกัด:

1 <= details.length <= 100
details[i].length == 15
details[i] ประกอบด้วยตัวเลขจาก '0' ถึง '9'
details[i][10] เป็น 'M' หรือ 'F' หรือ 'O'
หมายเลขโทรศัพท์และหมายเลขที่นั่งของผู้โดยสารไม่ซ้ำกัน

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

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

ส่งคืนจำนวนผู้โดยสารที่มีอายุมากกว่า 60 ปีอย่างเคร่งครัด

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

อินพุต: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
เอาท์พุท: 2
คำอธิบาย: ผู้โดยสารที่ดัชนี 0, 1 และ 2 มีอายุ 75, 92 และ 40 ดังนั้นจึงมี 2 คนที่มีอายุมากกว่า 60 ปี

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

อินพุต: details = ["1313579440F2036","2921522980M5644"]
เอาท์พุท: 0
คำอธิบาย: ไม่มีผู้โดยสารคนใดที่มีอายุมากกว่า 60 ปี

ข้อ จำกัด :

1 <= details.length <= 100
details[i].length == 15
details[i] consists of digits from '0' to '9'.
details[i][10] is either 'M' or 'F' or 'O'.
หมายเลขโทรศัพท์และหมายเลขที่นั่งของผู้โดยสารมีความแตกต่าง

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

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

ส่งคืนจำนวนผู้โดยสารที่มีอายุมากกว่า 60 ปีอย่างเคร่งครัด

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

อินพุต: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
เอาต์พุต: 2
คำอธิบาย: ผู้โดยสารในดัชนี 0, 1 และ 2 มีอายุ 75, 92 และ 40 ปี ดังนั้น จึงมี 2 คนที่มีอายุมากกว่า 60 ปี

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

อินพุต:  details = ["1313579440F2036","2921522980M5644"]
เอาต์พุต: 0
คำอธิบาย: ผู้โดยสารไม่มีใครอายุเกิน 60 ปี

ข้อจำกัด:

1 <= details.length <= 100
details[i].length == 15
details[i] ประกอบด้วยตัวเลขตั้งแต่ '0' ถึง '9'
details[i][10] คือ 'M' หรือ 'F' หรือ 'O'
หมายเลขโทรศัพท์และหมายเลขที่นั่งของผู้โดยสารจะแยกจากกัน


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

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

คืนค่าคะแนนสุดท้าย

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

Input: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Output: 15
คำอธิบาย: ในการดำเนินการครั้งแรก เราลบ 7, 6, 6 และ 3 จากนั้นเพิ่ม 7 ลงในคะแนนของเรา ถัดไป เราลบ 2, 4, 5 และ 2 เราเพิ่ม 5 ในคะแนนของเรา สุดท้าย เราลบ 1, 2, 3 และ 1 เราเพิ่ม 3 ในคะแนนของเรา ดังนั้น คะแนนสุดท้ายของเราคือ 7 + 5 + 3 = 15

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

Input: nums = [[1]]
Output: 1
คำอธิบาย: เราลบ 1 และเพิ่มลงในคำตอบ เราคืนค่า 1

ข้อกำหนด:

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3

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

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

คืนคะแนนสุดท้าย.

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

Input: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Output: 15
คำอธิบาย: ในการดำเนินการครั้งแรก เราลบ 7, 6, 6, และ 3 จากนั้นเราจะเพิ่ม 7 ลงในคะแนนของเรา ต่อไปเราลบ 2, 4, 5, และ 2 เราเพิ่ม 5 ลงในคะแนนของเรา สุดท้ายเราลบ 1, 2, 3, และ 1 เราเพิ่ม 3 ลงในคะแนนของเรา ดังนั้นคะแนนสุดท้ายของเราคือ 7 + 5 + 3 = 15.

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

Input: nums = [[1]]
Output: 1
คำอธิบาย: เราลบ 1 และเพิ่มมันเข้าไปในคำตอบ เราจะคืนค่า 1.

ข้อจำกัด:

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3

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

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

คืนค่าคะแนนสุดท้าย

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

Input: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Output: 15
คำอธิบาย: ในการดำเนินการครั้งแรก เราลบ 7, 6, 6 และ 3 จากนั้นเพิ่ม ตัวเลข7 ลงในคะแนนของเรา ถัดไป เราลบ 2, 4, 5 และ 2 เราเพิ่ม ตัวเลข5 ลงในคะแนนของเรา สุดท้าย เราลบ 1, 2, 3 และ 1 เราเพิ่ม ตัวเลข3 ลงในคะแนนของเรา ดังนั้น คะแนนสุดท้ายของเราคือ 7 + 5 + 3 = 15

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

Input: nums = [[1]]
Output: 1
คำอธิบาย: เราลบ 1 และเพิ่มลงในคำตอบ เราคืนค่า 1

ข้อกำหนด:

1 <= nums.length <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3


คุณได้รับอาเรย์จำนวนเต็ม nums ที่มีดัชนีเริ่มต้นที่ 0 ความยาว n และจำนวนเต็ม k ในการดำเนินการ คุณสามารถเลือกองค์ประกอบหนึ่งและคูณมันด้วย 2
คืนค่าค่าสูงสุดที่เป็นไปได้ของ nums[0] | nums[1] | ... | nums[n - 1] ที่สามารถได้รับหลังจากการดำเนินการบน nums สูงสุด k ครั้ง
หมายเหตุว่า a | b แสดงถึงการดำเนินการ OR แบบบิตระหว่างจำนวนเต็มสองจำนวน a และ b.

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

Input: nums = [12,9], k = 1
Output: 30
คำอธิบาย: ถ้าเรานำการดำเนินการไปใช้กับดัชนี 1 อาร์เรย์ใหม่ของเราคือ nums จะเท่ากับ [12, 18] ดังนั้นเราจะคืนค่าผลลัพธ์ของการดำเนินการ bitwise or ระหว่าง 12 และ 18 ซึ่งได้ค่าเท่ากับ 30

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

Input: nums = [8,1,2], k = 2
Output: 35
คำอธิบาย: หากเราทำการดำเนินการนี้สองครั้งที่ดัชนี 0 เราจะได้อาร์เรย์ใหม่เป็น [32, 1, 2] ดังนั้นเราจะคืนค่า 32|1|2 = 35

ข้อจำกัด:

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

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

ตัวอย่าง 1:

อินพุต: nums = [12,9], k = 1
เอาต์พุต: 30
คำอธิบาย: หากเราใช้การดำเนินการกับดัชนี 1 อาร์เรย์ nums ใหม่ของเราจะเท่ากับ [12,18] ดังนั้น เราจะส่งคืนบิตของ 12 และ 18 ซึ่งคือ 30

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

อินพุต: nums = [8,1,2], k = 2
เอาต์พุต: 35
คำอธิบาย: หากเราใช้การดำเนินการสองครั้งกับดัชนี 0 เราจะได้อาร์เรย์ใหม่ของ [32,1,2] ดังนั้น เราจะส่งคืน 32|1|2 = 35

ข้อจำกัด:

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


คุณมีอาเรย์จำนวนเต็มที่มีดัชนี0ที่แสดงคะแนนของนักเรียนในการสอบ คุณครูต้องการสร้างกลุ่มนักเรียนที่มีความแข็งแกร่งสูงสุด โดยความแข็งแกร่งของกลุ่มนักเรียนที่มีดัชนี i_0, i_1, i_2, ... , i_k ถูกกำหนดด้วย nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k]
ส่งคืนค่าความแข็งแกร่งสูงสุดของกลุ่มที่คุณครูสามารถสร้างได้

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

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

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

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

ข้อจำกัด:

1 <= nums.length <= 13
-9 <= nums[i] <= 9

คุณจะได้รับตัวเลขอาร์เรย์จํานวนเต็มที่มีดัชนี 0 ซึ่งแสดงถึงคะแนนของนักเรียนในการสอบ ครูต้องการสร้างกลุ่มนักเรียนที่ไม่ว่างเปล่าที่มีความแข็งแกร่งสูงสุด โดยที่ความแข็งแกร่งของกลุ่มนักเรียนที่มีดัชนี i_0, i_1, i_2, ... , i_k ถูกกําหนดให้เป็น nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k]
คืนความแข็งแกร่งสูงสุดของกลุ่มที่ครูสามารถสร้างได้

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

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

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

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

ข้อจํากัด:

1 <= nums.length <= 13
-9 <= nums[i] <= 9

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 nums ที่แสดงคะแนนของนักเรียนในการสอบ ครูต้องการจัดกลุ่มนักเรียนที่ไม่ว่างกลุ่มหนึ่งที่มีความแข็งแกร่งสูงสุด โดยที่ความแข็งแกร่งของกลุ่มนักเรียนที่มีดัชนี i_0, i_1, i_2, ... , i_k ถูกกำหนดให้เป็น nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k]
ส่งคืนค่าความแข็งแกร่งสูงสุดของกลุ่มที่ครูสามารถสร้างได้

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

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

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

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

ข้อจำกัด:

1 <= nums.length <= 13
-9 <= nums[i] <= 9


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

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

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

Input: s = "leetscode", dictionary = ["leet","code","leetcode"]
Output: 1
คำอธิบาย: เราสามารถแบ่ง s เป็นสองสตริงย่อย: "leet" จากดัชนี 0 ถึง 3 และ "code" จากดัชนี 5 ถึง 8 มีเพียง 1 ตัวอักษรที่ไม่ได้ใช้ (ที่ดัชนี 4) ดังนั้นเราคืนค่า 1

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

Input: s = "sayhelloworld", dictionary = ["hello","world"]
Output: 3
คำอธิบาย: เราสามารถแบ่ง s เป็นสองสตริงย่อย: "hello" จากดัชนี 3 ถึง 7 และ "world" จากดัชนี 8 ถึง 12 ตัวอักษรที่ดัชนี 0, 1, 2 ไม่ได้ใช้ในสตริงย่อยใด ๆ และถือว่าเป็นตัวอักษรที่เพิ่มขึ้น ดังนั้นเราคืนค่า 3

เงื่อนไข:

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

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

อินพุต: s = "leetscode", dictionary = ["leet","code","leetcode"]
เอาต์พุต: 1
คำอธิบาย: เราสามารถแยก s ออกเป็นสองสตริงย่อย: "leet" จากดัชนี 0 ถึง 3 และ "code" จากดัชนี 5 ถึง 8 มีอักขระที่ไม่ได้ใช้เพียง 1 ตัว (ที่ดัชนี 4) ดังนั้นเราจึงส่งคืน 1

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

อินพุต: s = "sayhelloworld", dictionary = ["hello","world"]
เอาต์พุต: 3
คำอธิบาย: เราสามารถแยก s ออกเป็นสองสตริงย่อย: "hello" จากดัชนี 3 ถึง 7 และ "world" จากดัชนี 8 ถึง 12 อักขระที่ดัชนี 0, 1, 2 จะไม่ถูกใช้ในสตริงย่อยใดๆ ดังนั้นจึงถือเป็นอักขระพิเศษ ดังนั้นเราจะคืนค่า 3

ข้อจำกัด:

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

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

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

อินพุต: s = "leetscode", dictionary = ["leet", "code", "leetcode"]
เอาท์พุท: 1
คำอธิบาย: เราสามารถทำลาย s ในสองส่วนย่อย: "leet" จากดัชนี 0 ถึง 3 และ "code" จากดัชนี 5 ถึง 8 มีเพียง 1 ตัวอักษรที่ไม่ได้ใช้ (ที่ดัชนี 4) ดังนั้นเราจึงกลับมา 1

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

อินพุต: s = "sayhelloworld", dictionary = ["hello","world"]
เอาท์พุท: 3
คำอธิบาย: เราสามารถทำลาย s ในสองส่วนย่อย: "hello" จากดัชนี 3 ถึง 7 และ "world" จากดัชนี 8 ถึง 12 อักขระที่ดัชนี 0, 1, 2 ไม่ได้ใช้ใน substring ใด ๆ และถือเป็นอักขระที่ไม่ได้ใช้ . ดังนั้นเรากลับ 3.

ข้อ จำกัด :

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


คุณได้รับอาร์เรย์จำนวนเต็ม prices ซึ่งแสดงราคาของช็อกโกแลตต่างๆ ในร้านค้า นอกจากนี้ยังมีจำนวนเต็ม money หนึ่งค่า ซึ่งแสดงจำนวนเงินเริ่มต้นของคุณ

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

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

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

Input: prices = [1,2,2], money = 3
Output: 0
คำอธิบาย: ซื้อช็อกโกแลตราคา 1 และ 2 หน่วยตามลำดับ คุณจะมีเงินเหลือ 3 - 3 = 0 หน่วย ดังนั้นเราจะคืนค่า 0

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

Input: prices = [3,2,3], money = 3
Output: 3
คำอธิบาย: คุณไม่สามารถซื้อช็อกโกแลต 2 ชิ้นโดยไม่เป็นหนี้ได้ ดังนั้นเราจึงคืนค่า 3

ข้อจำกัด:

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100

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

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

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

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

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

ข้อจำกัด:

2 <= ราคาความยาว <= 50
1 <= ราคา[i] <= 100
1 <= เงิน <= 100

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

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

อินพุต: prices = [1,2,2], money = 3
เอาท์พุท: 0
คำอธิบาย: ซื้อช็อคโกแลตราคา 1 และ 2 หน่วยตามลำดับ คุณจะมี 3 - 3 = 0 หน่วยของเงินหลังจากนั้น ดังนั้นเรากลับ 0.

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

อินพุต:prices= [3,2,3], money= 3
เอาท์พุท: 3
คำอธิบาย: คุณไม่สามารถซื้อช็อคโกแลต 2 ตัวโดยไม่ต้องเสียหนี้ดังนั้นเราจึงคืน 3

ข้อ จำกัด :

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100


คุณจะได้รับสตริงตัวเลขสองตัวคือ num1 และ num2 และจำนวนเต็มสองตัวคือ max_sum และ min_sum เราจะกำหนดให้จำนวนเต็ม x เป็นจำนวนที่ดีก็ต่อเมื่อ:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum

ส่งคืนจำนวนจำนวนเต็มที่ดี เนื่องจากคำตอบอาจมีค่ามาก ให้ส่งคืนโมดูโล 10^9 + 7
โปรดทราบว่า digit_sum(x) หมายถึงผลรวมของตัวเลขหลักของ x
ตัวอย่างที่ 1:

อินพุต: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
เอาต์พุต: 11
คำอธิบาย: มีจำนวนเต็ม 11 จำนวนที่ผลรวมหลักอยู่ระหว่าง 1 ถึง 8 ได้แก่ 1,2,3,4,5,6,7,8,10,11 และ 12 ดังนั้น เราจึงส่งคืน 11

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

อินพุต: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
เอาต์พุต: 5
คำอธิบาย: จำนวนเต็ม 5 จำนวนที่ผลรวมหลักอยู่ระหว่าง 1 ถึง 5 ได้แก่ 1,2,3,4 และ 5 ดังนั้น เราจึงส่งคืน 5

ข้อจำกัด:

1 <= num1 <= num2 <= 10^22
1 <= ผลรวมต่ำสุด <= ผลรวมสูงสุด <= 400

คุณจะได้รับสตริงตัวเลขสองตัวคือ num1 และ num2 และจำนวนเต็มสองตัวคือ max_sum และ min_sum เราจะกำหนดให้จำนวนเต็ม x เป็นจำนวนที่ดีก็ต่อเมื่อ:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum

ส่งคืนจำนวนจำนวนเต็มที่ดี เนื่องจากคำตอบอาจมีค่ามาก ให้ส่งคืนโมดูโล 10^9 + 7
โปรดทราบว่า digit_sum(x) หมายถึงผลรวมของตัวเลขหลักของ x

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

อินพุต: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
เอาต์พุต: 11
คำอธิบาย: มีจำนวนเต็ม 11 จำนวนที่ผลรวมของหลักอยู่ระหว่าง 1 ถึง 8 ได้แก่ 1,2,3,4,5,6,7,8,10,11 และ 12 ดังนั้น เราจึงส่งคืน 11

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

อินพุต: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
เอาต์พุต: 5
คำอธิบาย: จำนวนเต็ม 5 จำนวนที่ผลรวมของหลักอยู่ระหว่าง 1 ถึง 5 ได้แก่ 1,2,3,4 และ 5 ดังนั้น เราจึงส่งคืน 5

ข้อจำกัด:

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400

คุณจะได้รับสองสตริงตัวเลข Num1 และ Num2 และจำนวนเต็มสองตัว Max_sum และ min_sum เราแสดงว่าจำนวนเต็ม x เป็นสิ่งที่ดีถ้า:

num1 <= x <= num2
min_sum <= digit_sum (x) <= max_sum

ส่งคืนจำนวนจำนวนเต็มที่ดี เนื่องจากคำตอบอาจมีขนาดใหญ่ให้ส่งคืนโมดูโล 10^9 + 7
โปรดทราบว่า digit_sum (x) หมายถึงผลรวมของตัวเลขของ x

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

อินพุต: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
เอาท์พุท: 11
คำอธิบาย: มีจำนวนเต็ม 11 ตัวที่มีตัวเลขรวมอยู่ระหว่าง 1 ถึง 8 คือ 1,2,3,4,5,6,7,8,10,11 และ 12 ดังนั้นเราจึงกลับมา 11

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

อินพุต: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
เอาท์พุท: 5
คำอธิบาย: จำนวนเต็ม 5 จำนวนที่มีตัวเลขอยู่ระหว่าง 1 ถึง 5 คือ 1,2,3,4 และ 5 ดังนั้นเราจึงกลับมา 5

ข้อ จำกัด :

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400


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

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

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

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

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

ข้อจำกัด:

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

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

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

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

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

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

ข้อ จำกัด :

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

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

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

Input: nums = [1,2,3,4,5]
Output: [-3,-1,1,3,5]
คำอธิบาย: สำหรับดัชนี i = 0 มี 1 องค์ประกอบในพรีฟิกและ 4 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[0] = 1 - 4 = -3
สำหรับดัชนี i = 1 มี 2 องค์ประกอบที่แตกต่างกันในพรีฟิกและ 3 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[1] = 2 - 3 = -1
สำหรับดัชนี i = 2 มี 3 องค์ประกอบที่แตกต่างกันในพรีฟิกและ 2 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[2] = 3 - 2 = 1
สำหรับดัชนี i = 3 มี 4 องค์ประกอบที่แตกต่างกันในพรีฟิกและ 1 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[3] = 4 - 1 = 3
สำหรับดัชนี i = 4 มี 5 องค์ประกอบที่แตกต่างกันในพรีฟิกและไม่มีองค์ประกอบในซัฟฟิก ดังนั้น diff[4] = 5 - 0 = 5

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

Input: nums = [3,2,3,4,2]
Output: [-2,-1,0,2,3]
คำอธิบาย: สำหรับดัชนี i = 0 มี 1 องค์ประกอบในพรีฟิกและ 3 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[0] = 1 - 3 = -2
สำหรับดัชนี i = 1 มี 2 องค์ประกอบที่แตกต่างกันในพรีฟิกและ 3 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[1] = 2 - 3 = -1
สำหรับดัชนี i = 2 มี 2 องค์ประกอบที่แตกต่างกันในพรีฟิกและ 2 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[2] = 2 - 2 = 0
สำหรับดัชนี i = 3 มี 3 องค์ประกอบที่แตกต่างกันในพรีฟิกและ 1 องค์ประกอบที่แตกต่างกันในซัฟฟิก ดังนั้น diff[3] = 3 - 1 = 2
สำหรับดัชนี i = 4 มี 3 องค์ประกอบที่แตกต่างกันในพรีฟิกและไม่มีองค์ประกอบในซัฟฟิก ดังนั้น diff[4] = 3 - 0 = 3

ข้อจำกัด:

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


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

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

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

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

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

ข้อจำกัด:

1 <= n <= 10^5
1 <= query.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <= color_i <= 10^5

มีอาเรย์ nums ที่เริ่มต้นที่ดัชนี 0 ความยาว n โดยเริ่มต้นทุกองค์ประกอบไม่มีสี (มีค่าเป็น 0) คุณได้รับอาเรย์ 2D ที่เป็นจำนวนเต็ม queries ซึ่ง queries[i] = [index_i, color_i] สำหรับแต่ละ query คุณจะย้อมสีที่ดัชนี index_i ด้วยสี color_i ในอาเรย์ nums ส่งคืนอาเรย์ answer ที่มีความยาวเท่ากับ queries โดยที่ answer[i] เป็นจำนวนขององค์ประกอบที่ติดกันซึ่งมีสีเดียวกันหลังจาก query ที่ i

ในรูปแบบที่เป็นทางการ answer[i] คือจำนวนดัชนี j ที่ 0 <= j < n - 1 และ nums[j] == nums[j + 1] และ nums[j] != 0 หลังจาก query ที่ i

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

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

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

Input: n = 1, queries = [[0,100000]]
Output: [0]
คำอธิบาย: เริ่มต้นอาเรย์ nums = [0] โดยที่ 0 แทนองค์ประกอบที่ไม่มีสีของอาเรย์
- หลังจาก query ที่ 1 nums = [100000] จำนวนขององค์ประกอบที่ติดกันซึ่งมีสีเดียวกันคือ 0

เงื่อนไข:

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <= color_i <= 10^5

มีอาร์เรย์ nums ที่มีดัชนี 0 และความยาว n เริ่มแรกองค์ประกอบทั้งหมดจะไม่ได้สี (มีค่า 0)
คุณจะได้รับอาร์เรย์จำนวนเต็ม 2D ที่เรียกว่า queries ที่การสืบค้น [i] = [index_i, color_i]
สำหรับการสืบค้นแต่ละครั้งคุณจะระบายสีดัชนี index_i ด้วย color color_i ในอาร์เรย์ nums
ส่งคืนอาร์เรย์คำตอบที่มีความยาวเท่ากับการสืบค้นที่คำตอบ [i] คือจำนวนองค์ประกอบที่อยู่ติดกันที่มีสีเดียวกันหลังจากการสืบค้น i^th
อย่างเป็นทางการ, answer[i] คือ คือจำนวนดัชนี j เช่น 0 <= j <n - 1 และ nums [j] == nums [j + 1] และ nums [j]! = 0 หลังจาก i^th การสืบค้น.

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

อินพุต:  n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
ผลลัพธ์: [0,1,1,0,2]
คำอธิบาย: เริ่มต้นอาร์เรย์ nums = [0,0,0,0] โดยที่ 0 หมายถึงองค์ประกอบที่ไม่ได้สีของอาร์เรย์
- หลังจาก 1^st query Nums = [2,0,0,0] จำนวนองค์ประกอบที่อยู่ติดกันที่มีสีเดียวกันคือ 0
- หลังจากการสืบค้น 2^nd nums = [2,2,0,0] จำนวนองค์ประกอบที่อยู่ติดกันที่มีสีเดียวกันคือ 1
- หลังจาก 3^rd query nums = [2,2,0,1] จำนวนองค์ประกอบที่อยู่ติดกันที่มีสีเดียวกันคือ 1
- หลังจากการสืบค้น 4^th nums = [2,1,0,1] จำนวนองค์ประกอบที่อยู่ติดกันที่มีสีเดียวกันคือ 0
- หลังจากการสืบค้นครั้งที่ 5^th query = [2,1,1,1] จำนวนองค์ประกอบที่อยู่ติดกันที่มีสีเดียวกันคือ 2

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

อินพุต: n = 1, queries = [[0,100000]]
เอาท์พุท: [0]
คำอธิบาย: เริ่มแรกอาร์เรย์ nums = [0] โดยที่ 0 หมายถึงองค์ประกอบที่ไม่ได้สีของอาร์เรย์
- หลังจาก 1^st query nums = [100000] จำนวนองค์ประกอบที่อยู่ติดกันที่มีสีเดียวกันคือ 0

ข้อ จำกัด :

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <=  color_i <= 10^5


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

ให้ i_0, i_1, ... ,i_k เป็นดัชนีของฮีโร่ในกลุ่มนั้น พลังของกลุ่มนี้คือ max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k])

ให้คืนค่าผลรวมของพลังของกลุ่มฮีโร่ที่ไม่ว่างทั้งหมดที่เป็นไปได้ เนื่องจากผลรวมอาจมีค่ามาก จึงให้คืนค่าเป็นโมดูโล 10^9 + 7.

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

Input: nums = [2,1,4]
Output: 141
คำอธิบาย:
กลุ่มที่ 1: [2] มีพลัง = 2^2 * 2 = 8
กลุ่มที่ 2: [1] มีพลัง = 1^2 * 1 = 1
กลุ่มที่ 3: [4] มีพลัง = 4^2 * 4 = 64
กลุ่มที่ 4: [2,1] มีพลัง = 2^2 * 1 = 4
กลุ่มที่ 5: [2,4] มีพลัง = 4^2 * 2 = 32
กลุ่มที่ 6: [1,4] มีพลัง = 4^2 * 1 = 16
กลุ่มที่ 7: [2,1,4] มีพลัง = 4^2 * 1 = 16
ผลรวมของพลังทั้งหมดของกลุ่มคือ 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

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

Input: nums = [1,1,1]
Output: 7
คำอธิบาย: มีทั้งหมด 7 กลุ่มที่เป็นไปได้ และพลังของแต่ละกลุ่มจะเท่ากับ 1 ดังนั้นผลรวมของพลังของทุกกลุ่มจึงเท่ากับ 7

ข้อจำกัด:

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

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

ให้ i_0 i_1 ... i_k เป็นดัชนีของฮีโร่ในกลุ่ม จากนั้นกําลังของกลุ่มนี้คือ max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k])

ส่งคืนผลรวมของพลังของกลุ่มฮีโร่ที่ไม่ว่างเปล่าทั้งหมดที่เป็นไปได้ เนื่องจากผลรวมอาจใหญ่มาก ให้ส่งคืนโมดูโล 10^9 + 7

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

อินพุต: nums = [2,1,4]
เอาท์พุต: 141
การอธิบาย:
กลุ่มที่ 1^: [2] มีกําลัง = 2^2 * 2 = 8
กลุ่มที่ 2^: [1] มีกําลัง = 1^2 * 1 = 1
กลุ่มที่ 3^: [4] มีกําลัง = 4^2 * 4 = 64
กลุ่มที่ 4^: [2,1] มีกําลัง = 2^2 * 1 = 4
กลุ่มที่ 5^: [2,4] มีกําลัง = 4^2 * 2 = 32
กลุ่มที่ 6^: [1,4] มีกําลัง = 4^2 * 1 = 16
กลุ่มที่ 7^: [2,1,4] มีกําลัง = 4^2 * 1 = 16
ผลรวมของกําลังของทุกกลุ่มคือ 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141

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

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

ข้อจำกัด:

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

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

ให้ i_0, i_1, ... ,i_k เป็นดัชนีของฮีโร่ในกลุ่ม จากนั้นพลังของกลุ่มนี้คือ max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k])

คืนค่าผลรวมของพลังของกลุ่มฮีโร่ที่ไม่ว่างเปล่าทั้งหมดที่เป็นไปได้ เนื่องจากผลรวมอาจมีค่ามาก ให้คืนค่าโมดูโล 10^9 + 7

ตัวอย่าง 1:

อินพุต: nums = [2,1,4]
เอาต์พุต: 141
คำอธิบาย:

กลุ่มที่ 1: [2] มีกำลัง = 2^2 * 2 = 8
กลุ่มที่ 2: [1] มีกำลัง = 1^2 * 1 = 1
กลุ่มที่ 3: [4] มีกำลัง = 4^2 * 4 = 64
กลุ่มที่ 4: [2,1] มีกำลัง = 2^2 * 1 = 4
กลุ่มที่ 5: [2,4] มีกำลัง = 4^2 * 2 = 32
กลุ่มที่ 6: [1,4] มีกำลัง = 4^2 * 1 = 16
กลุ่มที่ 7: [2,1,4] มีกำลัง = 4^2 * 1 = 16.
ผลรวมของกำลังของกลุ่มทั้งหมดคือ 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141

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

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

ข้อจำกัด:

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


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

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

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

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

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

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

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

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

Input: nums = [1,3,4,2,5]
Output: 0
คำอธิบาย: การเรียงสับเปลี่ยนนี้เป็นการเรียงสับเปลี่ยนแบบกึ่งเรียงลำดับอยู่แล้ว

เงื่อนไข:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums เป็นการเรียงสับเปลี่ยน

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

เลือกองค์ประกอบที่อยู่ติดกันสององค์ประกอบใน nums จากนั้นสลับกัน

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

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

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

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

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

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

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

ข้อจำกัด:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums คือการเรียงสับเปลี่ยน

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

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

ส่งคืนจํานวนการดําเนินการขั้นต่ําเพื่อทําให้ nums เป็นเรียงสับเปลี่ยนแบบกึ่งลําดับ
การเรียงสับเปลี่ยนคือลําดับของจํานวนเต็มตั้งแต่ 1 ถึง n ที่มีความยาว n ซึ่งแต่ละตัวเลขมีเพียงครั้งเดียว

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

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

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

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

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

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

ข้อจํากัด:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums เป็นการเรียงสับเปลี่ยน


คุณได้รับสตริง s ที่มีดัชนีเริ่มต้นที่ 0 ซึ่งประกอบด้วยตัวเลขจาก 0 ถึง 9
สตริง t จะถูกเรียกว่าเป็น semi-repetitive หากมีคู่ตัวเลขที่เหมือนกันติดต่อกันได้ไม่เกินหนึ่งคู่ภายใน t ตัวอย่างเช่น 0010, 002020, 0123, 2002, และ 54944 เป็น semi-repetitive ในขณะที่ 00101022 และ 1101234883 ไม่ใช่
ให้คืนค่าความยาวของซับสตริง semi-repetitive ที่ยาวที่สุดภายใน s
ซับสตริงคือ ลำดับของอักขระที่ต่อเนื่องกันและไม่ว่างภายในสตริง

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

Input: s = "52233"
Output: 4
คำอธิบาย: ซับสตริงที่มีการทำซ้ำแบบกึ่งยาวที่สุดคือ '5223' ซึ่งเริ่มที่ i = 0 และสิ้นสุดที่ j = 3.

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

Input: s = "5494"
Output: 4
คำอธิบาย: s เป็นสตริงกึ่งซ้ำซ้อน ดังนั้นคำตอบคือ 4.

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

Input: s = "1111111"
Output: 2
คำอธิบาย: ซับสตริงที่มีการทำซ้ำแบบกึ่งยาวที่สุดคือ '11' ซึ่งเริ่มที่ i = 0 และสิ้นสุดที่ j = 1.

ข้อจำกัด:

1 <= s.length <= 50
'0' <= s[i] <= '9'

คุณจะได้รับสตริง s ที่มีดัชนี 0 ซึ่งประกอบด้วยตัวเลขตั้งแต่ 0 ถึง 9
สตริง t เรียกว่ากึ่งซ้ําหากมีตัวเลขเดียวกันต่อเนื่องกันมากที่สุดหนึ่งคู่ภายใน t ตัวอย่างเช่น 0010, 002020, 0123, 2002 และ 54944 เป็นแบบกึ่งซ้ําในขณะที่ 00101022 และ 1101234883 ไม่ซ้ํา
ส่งคืนความยาวของสตริงย่อยกึ่งซ้ําที่ยาวที่สุดภายใน s
สตริงย่อยคือลําดับอักขระที่ไม่ว่างเปล่าที่อยู่ติดกันภายในสตริง

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

อินพุต: s = "52233"
เอาท์พุต: 4
คําอธิบาย: สตริงย่อยกึ่งซ้ําที่ยาวที่สุดคือ "5223" ซึ่งเริ่มต้นที่ i = 0 และสิ้นสุดที่ j = 3

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

อินพุต: s = "5494"
เอาท์พุต: 4
คําอธิบาย: s เป็นสตริงsemi-reptitiveน ดังนั้นคําตอบคือ 4

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

อินพุต: s = "1111111"
เอาท์พุต: 2
คําอธิบาย: สตริงย่อยกึ่งซ้ําที่ยาวที่สุดคือ "11" ซึ่งเริ่มต้นที่ i = 0 และสิ้นสุดที่ j = 1

ข้อจํากัด:

1 <= s.length<= 50
'0' <= s[i] <= '9'

คุณจะได้รับสตริง s ที่มีดัชนี 0 ซึ่งประกอบด้วยตัวเลขตั้งแต่ 0 ถึง 9
สตริง t เรียกว่าแบบกึ่งซ้ำกันหากมีคู่ตัวเลขเดียวกันติดต่อกันไม่เกินหนึ่งคู่ภายใน t ตัวอย่างเช่น 0010, 002020, 0123, 2002 และ 54944 เป็นแบบกึ่งซ้ำกันในขณะที่ 00101022 และ 1101234883 ไม่ใช่
ส่งคืนความยาวของสตริงย่อยแบบกึ่งซ้ำกันที่ยาวที่สุดภายใน s
สตริงย่อยคือลำดับอักขระที่ไม่ว่างต่อเนื่องกันภายในสตริง
ตัวอย่างที่ 1:

อินพุต: s = "52233"
เอาต์พุต: 4
คำอธิบาย: สตริงกึ่งซ้ำที่ยาวที่สุดคือ "5223" ซึ่งเริ่มต้นที่ i = 0 และสิ้นสุดที่ j = 3

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

อินพุต: s = "5494"
เอาต์พุต: 4
คำอธิบาย: s เป็นสตริงกึ่งซ้ำ ดังนั้นคำตอบคือ 4

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

อินพุต: s = "1111111"
เอาต์พุต: 2
คำอธิบาย: สตริงกึ่งซ้ำที่ยาวที่สุดคือ "11" ซึ่งเริ่มต้นที่ i = 0 และสิ้นสุดที่ j = 1

ข้อจำกัด:

1 <= s.length <= 50
'0' <= s[i] <= '9'


มีเพื่อน n คนเล่นเกมกันอยู่ เพื่อนเหล่านี้นั่งเป็นวงกลมและมีหมายเลขตั้งแต่ 1 ถึง n โดยเรียงตามเข็มนาฬิกา อย่างเป็นทางการ การเคลื่อนย้ายตามเข็มนาฬิกาจากเพื่อนคนที่ i^th จะไปถึงเพื่อนคนที่  (i+1)^th  สำหรับ 1 <= i < n และเคลื่อนย้ายตามเข็มนาฬิกาจากเพื่อนคนที่ n จะไปถึงเพื่อนคนที่ 1

กติกาของเกมมีดังนี้:

เพื่อนคนที่ 1^st ได้รับลูกบอล หลังจากนั้น เพื่อนคนที่ 1^st จะส่งต่อให้กับเพื่อนที่อยู่ห่างจากเขา k ก้าวในทิศทางตามเข็มนาฬิกา
หลังจากนั้น เพื่อนที่ได้รับลูกบอลจะส่งต่อให้เพื่อนที่อยู่ห่างจากเขา 2 * k ก้าวในทิศทางตามเข็มนาฬิกา

ต่อไปเรื่อยๆ เพื่อนที่ได้รับลูกบอลจะส่งต่อให้เพื่อนที่อยู่ห่างจากเขา 3 * k ก้าวในทิศทางตามเข็มนาฬิกา และทำเช่นนี้ต่อเนื่องไปเรื่อยๆ

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

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

Input: n = 5, k = 2
Output: [4,5]
คำอธิบาย: เกมดำเนินไปดังนี้:
1) เริ่มต้นที่เพื่อนคนที่ 1^st และส่งต่อให้เพื่อนที่อยู่ห่างจากเขา 2 ก้าวตามเข็มนาฬิกา - เพื่อนคนที่ 3^rd
2) เพื่อนคนที่ 3^rd ส่งต่อให้เพื่อนที่อยู่ห่างจากเขา 4 ก้าวตามเข็มนาฬิกา - เพื่อนคนที่ 2^nd
3) เพื่อนคนที่ 2^nd ส่งต่อให้เพื่อนที่อยู่ห่างจากเขา 6 ก้าวตามเข็มนาฬิกา - เพื่อนคนที่ 3^rd
4) เกมจบเมื่อเพื่อนคนที่ 3^rd ได้รับลูกบอลเป็นครั้งที่สอง

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

Input: n = 4, k = 4
Output: [2,3,4]

คำอธิบาย: เกมดำเนินไปดังนี้:

1) เริ่มต้นที่เพื่อนคนที่ 1^st  และส่งต่อให้เพื่อนที่อยู่ห่างจากเขา 4 ก้าวตามเข็มนาฬิกา - เพื่อนคนที่ 1^st

2) เกมจบเมื่อเพื่อนคนที่ 1 ได้รับลูกบอลเป็นครั้งที่สอง

ข้อจำกัด:

1 <= k <= n <= 50

มีเพื่อน n คนกำลังเล่นเกม เพื่อน ๆ นั่งเป็นวงกลมและมีการนับเลขจาก 1 ถึง n ตามลำดับตามเข็มนาฬิกา พูดง่าย ๆ ก็คือ การเคลื่อนที่ตามเข็มนาฬิกาจากเพื่อนคนที่ i จะนำคุณไปยังเพื่อนคนที่ (i+1) สำหรับ 1 <= i < n และการเคลื่อนที่ตามเข็มนาฬิกาจากเพื่อนคนที่ n^ จะนำคุณไปยังเพื่อนคนที่ 1
กติกาของเกมมีดังนี้:
เพื่อนคนที่ 1 รับลูกบอล

จากนั้น เพื่อนคนที่ 1 ส่งลูกบอลไปให้เพื่อนที่อยู่ห่างจากพวกเขา k ก้าวตามเข็มนาฬิกา
หลังจากนั้น เพื่อนที่รับลูกบอลควรส่งลูกบอลไปให้เพื่อนที่อยู่ห่างจากพวกเขา 2 * k ก้าวตามเข็มนาฬิกา
หลังจากนั้น เพื่อนที่รับลูกบอลควรส่งลูกบอลไปให้เพื่อนที่อยู่ห่างจากพวกเขา 3 * k ก้าวตามเข็มนาฬิกา และเป็นเช่นนี้ต่อไป

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

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

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

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

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

เงื่อนไข:

1 <= k <= n <= 50

มีเพื่อน n คนที่กําลังเล่นเกม เพื่อน ๆ นั่งเป็นวงกลมและมีหมายเลขตั้งแต่ 1 ถึง n ตามลําดับเข็มนาฬิกา การเลื่อนตามเข็มนาฬิกาจากเพื่อนที่ i^th จะนําคุณไปสู่เพื่อนคนที่ (i+1) 1 <= i < n และการเลื่อนตามเข็มนาฬิกาจากเพื่อนที่ n^th จะนําคุณไปยังเพื่อนคนที่ 1^คน
กฎของเกมมีดังนี้:
เพื่อนคนที่ 1^ ได้รับลูกบอล

หลังจากนั้นเพื่อนคนที่ 1^คนแรกจะส่งต่อให้เพื่อนที่อยู่ห่างออกไปตามเข็มนาฬิกา
หลังจากนั้นเพื่อนที่ได้รับลูกบอลควรส่งให้เพื่อนที่อยู่ห่างจากพวกเขา 2 * k ก้าวตามเข็มนาฬิกา
หลังจากนั้นเพื่อนที่ได้รับลูกบอลควรส่งให้เพื่อนที่อยู่ห่าง 3 * k ก้าวตามเข็มนาฬิกา เป็นต้น

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

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

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

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

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

ข้อจํากัด:

1 <= k <= n <= 50


อาร์เรย์ที่มีดัชนีเริ่มต้นที่ 0 ชื่อว่า derived ที่มีความยาว  n  ถูกสร้างขึ้นโดยการคำนวณ XOR แบบบิต (⊕) ของค่าที่อยู่ติดกันในอาร์เรย์ไบนารี original ที่มีความยาว  n
โดยเฉพาะอย่างยิ่ง สำหรับแต่ละดัชนี  i  ในช่วง [0, n - 1]:
	•	หาก  i = n - 1 :  \text{derived}[i] = \text{original}[i] \ ⊕ \ \text{original}[0]
	•	มิฉะนั้น:  \text{derived}[i] = \text{original}[i] \ ⊕ \ \text{original}[i + 1]

ให้ derived เป็นอาร์เรย์ที่กำหนดไว้ หน้าที่ของคุณคือหาว่ามีอาร์เรย์ไบนารี original ที่เป็นไปได้หรือไม่ที่สามารถสร้าง derived ขึ้นมาได้
หากมีอาร์เรย์ดังกล่าวให้คืนค่า true หากไม่มีให้คืนค่า false

หมายเหตุ:
อาร์เรย์ไบนารี (binary array) หมายถึงอาร์เรย์ที่ประกอบด้วยเฉพาะตัวเลข 0 และ 1
ตัวอย่างที่ 1:

อินพุต: derived = [1,1,0]
เอาท์พุท: จริง
คำอธิบาย: อาร์เรย์ดั้งเดิมที่ถูกต้องที่ให้มาคือ [0,1,0]
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

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

อินพุต: derived = [1,1]
เอาท์พุท: จริง
คำอธิบาย: อาเรย์ original ที่ให้ derived คือ [0,1
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

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

อินพุต: derived = [1,0]
เอาท์พุท: เท็จ
คำอธิบาย: ไม่มีอาร์เรย์ดั้งเดิมที่ถูกต้องที่ให้มา

ข้อ จำกัด :

n == derived.length
1 <= n <= 10^5
ค่าใน derived เป็น 0 หรือ 1

อาร์เรย์ที่มีดัชนี 0 ที่อนุมานด้วยความยาว n อนุมานโดยการคำนวณค่าบิตต่อบิต XOR (⊕) ของค่าที่อยู่ติดกันในอาร์เรย์ไบนารีต้นฉบับที่มีความยาว n
โดยเฉพาะอย่างยิ่ง สำหรับแต่ละดัชนี i ในช่วง [0, n - 1]:

ถ้า i = n - 1 ดังนั้น derived[i] = original[i] ⊕ original[0]
มิฉะนั้น derived[i] = original[i] ⊕ original[i + 1]

เมื่อได้รับอาร์เรย์ที่อนุมาน งานของคุณคือการกำหนดว่ามีอาร์เรย์ไบนารีต้นฉบับที่ถูกต้องที่สามารถสร้างอนุมานได้หรือไม่
คืนค่า true หากมีอาร์เรย์ดังกล่าวอยู่หรือคืนค่า false หากไม่มี

อาร์เรย์ไบนารีคืออาร์เรย์ที่มีเฉพาะ 0 และ 1

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

อินพุต: derived = [1,1,0]
เอาต์พุต: true
คำอธิบาย: อาร์เรย์ต้นฉบับที่ถูกต้องซึ่งให้ค่า derived คือ [0,1,0] derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

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

อินพุต: derived = [1,1]
เอาต์พุต: true
คำอธิบาย: อาร์เรย์ต้นฉบับที่ถูกต้องซึ่งให้ค่า derived คือ [0,1]
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

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

อินพุต: derived = [1,0]
เอาต์พุต: false
คำอธิบาย: ไม่มีอาร์เรย์ต้นฉบับที่ถูกต้องซึ่งให้ค่า derived
ข้อจำกัด:

n == derived.length
1 <= n <= 10^5
ค่าใน derived จะเป็น 0 หรือ 1

อาเรย์ที่ใช้ระบบดัชนีเริ่มต้นที่ 0 ที่ชื่อ derived ซึ่งมีความยาว n ถูกสร้างขึ้นโดยการคำนวณ Bitwise XOR (⊕) ของค่าที่อยู่ติดกันในอาเรย์ไบนารีที่ชื่อ original ซึ่งมีความยาว n โดยเฉพาะสำหรับแต่ละดัชนี i ในช่วง [0, n - 1]:

ถ้า i = n - 1, ดังนั้น derived[i] = original[i] ⊕ original[0]
มิฉะนั้น derived[i] = original[i] ⊕ original[i + 1]

ให้อาเรย์ derived งานของคุณคือการตรวจสอบว่ามีอาเรย์ไบนารี original ที่สามารถสร้าง derived ได้หรือไม่ ให้คืนค่า true ถ้ามีอาเรย์ดังกล่าว หรือคืนค่า false ถ้าไม่มี

อาเรย์ไบนารีคืออาเรย์ที่มีค่าคือ 0 หรือ 1 เท่านั้น

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

Input: derived = [1,1,0]
Output: true
Explanation: อาเรย์ original ที่ให้ derived คือ [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

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

Input: derived = [1,1]
Output: true
Explanation: อาเรย์ original ที่ให้ derived คือ [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

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

Input: derived = [1,0]
Output: false
Explanation: ไม่มีอาเรย์ original ที่ให้ derived ได้

ข้อจำกัด:

n == derived.length
1 <= n <= 10^5
ค่าต่าง ๆ ใน derived เป็น 0 หรือ 1 เท่านั้น


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

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

อินพุต: s = "ABFCACDB"
เอาต์พุต: 2
คำอธิบาย: เราสามารถดำเนินการต่อไปนี้ได้:
- ลบสตริงย่อย "ABFCACDB" ดังนั้น s = "FCACDB"
- ลบสตริงย่อย "FCACDB" ดังนั้น s = "FCAB"
- ลบสตริงย่อย "FCAB" ดังนั้น s = "FC"
ดังนั้นความยาวผลลัพธ์ของสตริงคือ 2
สามารถแสดงได้ว่าเป็นความยาวขั้นต่ำที่เราสามารถรับได้
ตัวอย่างที่ 2:

อินพุต: s = "ACBBD"
เอาต์พุต: 5
คำอธิบาย: เราไม่สามารถดำเนินการใดๆ กับสตริงได้ ดังนั้นความยาวจึงยังคงเท่าเดิม

ข้อจำกัด:

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

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

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

อินพุต: s = "ABFCACDB"
เอาต์พุต: 2
คำอธิบาย: เราสามารถดำเนินการดังต่อไปนี้:
- ลบสตริงย่อย "ABFCACDB" ดังนั้น s = "FCACDB"
- ลบสตริงย่อย "FCACDB" ดังนั้น s = "FCAB"
- ลบสตริงย่อย "FCAB" ดังนั้น s = "FC"
ดังนั้นความยาวผลลัพธ์ของสตริงคือ 2
สามารถแสดงให้เห็นว่าเป็นความยาวขั้นต่ำที่เราสามารถรับได้ ตัวอย่างที่ 2:

อินพุต: s = "ACBBD"
เอาต์พุต: 5
คำอธิบาย: เราไม่สามารถดำเนินการใดๆ กับสตริงได้ ดังนั้นความยาวจึงยังคงเท่าเดิม

ข้อจำกัด:

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

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

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

อินพุต: s= "ABFCACDB"
เอาท์พุท: 2
คำอธิบาย: เราสามารถดำเนินการต่อไปนี้:
- ถอดสตริงย่อย "AB" จาก "ABFCACDB" ทำให้ s = "FCACDB"
- ถอด substring "FCACDB" ดังนั้น s = "FCAB"
- ถอด substring "FCAB" ดังนั้น s = "FC"
ดังนั้นความยาวที่เกิดขึ้นของสตริงคือ 2
มันสามารถแสดงให้เห็นว่ามันเป็นความยาวขั้นต่ำที่เราสามารถรับได้
ตัวอย่างที่ 2:

อินพุต: s = "ACBBD"
เอาท์พุท: 5
คำอธิบาย: เราไม่สามารถดำเนินการใด ๆ บนสตริงได้ดังนั้นความยาวจะยังคงเหมือนเดิม

ข้อ จำกัด :

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


กำหนดจำนวนเต็มบวก n ให้ส่งคืนหมายเลขการลงโทษของ n
หมายเลขการลงโทษของ n ถูกกำหนดให้เป็นผลรวมของกำลังสองของจำนวนเต็ม i ทั้งหมด โดยที่:

1 <= i <= n
การแสดงค่าทศนิยมของ i * i สามารถแบ่งย่อยเป็นสตริงย่อยที่ต่อเนื่องกันได้ โดยที่ผลรวมของค่าจำนวนเต็มของสตริงย่อยเหล่านี้เท่ากับ i

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

อินพุต: n = 10
เอาต์พุต: 182
คำอธิบาย: มีจำนวนเต็ม i 3 ตัวที่ตรงตามเงื่อนไขในคำสั่ง:
- 1 เนื่องจาก 1 * 1 = 1
- 9 เนื่องจาก 9 * 9 = 81 และ 81 สามารถแบ่งเป็น 8 + 1 ได้
- 10 เนื่องจาก 10 * 10 = 100 และ 100 สามารถแบ่งเป็น 10 + 0 ได้
ดังนั้น จำนวนโทษของ 10 คือ 1 + 81 + 100 = 182

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

อินพุต: n = 37
เอาต์พุต: 1478
คำอธิบาย: มีจำนวนเต็ม i 4 ตัวที่ตรงตามเงื่อนไขในคำสั่ง:
- 1 เนื่องจาก 1 * 1 = 1
- 9 เนื่องจาก 9 * 9 = 81 และ 81 สามารถแบ่งเป็น 8 + 1.
- 10 เนื่องจาก 10 * 10 = 100 และ 100 สามารถแบ่งเป็น 10 + 0 ได้
- 36 เนื่องจาก 36 * 36 = 1296 และ 1296 สามารถแบ่งเป็น 1 + 29 + 6 ได้
ดังนั้น จำนวนโทษของ 37 คือ 1 + 81 + 100 + 1296 = 1478

เงื่อนไข:

1 <= n <= 1000

ให้จำนวนเต็มบวก n ให้คืนค่า punishment number ของ n
punishment number ของ n ถูกกำหนดให้เป็นผลรวมของกำลังสองของจำนวนเต็ม i ทั้งหมดโดยที่:

1 <= i <= n

โดยที่การแสดงผลแบบทศนิยมของ i * i สามารถแบ่งออกเป็นสตริงย่อยที่อยู่ติดกัยน โดยผลรวมของค่าจำนวนเต็มของสตริงย่อยเหล่านี้เท่ากับ i

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

Input: n = 10
Output: 182
คำอธิบาย: มีจำนวนเต็ม i ที่เป็นไปตามเงื่อนไขในข้อความ 3 จำนวนคือ:
- 1 เนื่องจาก 1 * 1 = 1
- 9 เนื่องจาก 9 * 9 = 81 และ 81 สามารถแบ่งเป็น 8 + 1ได้
- 10 เนื่องจาก 10 * 10 = 100 และ 100 สามารถแบ่งเป็น 10 + 0ได้
ดังนั้น punishment number ของ 10 คือ 1 + 81 + 100 = 182

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

Input: n = 37
Output: 1478
คำอธิบาย: มีจำนวนเต็ม i ที่เป็นไปตามเงื่อนไขในข้อความ 4 จำนวนคือ:
- 1 เนื่องจาก 1 * 1 = 1
- 9 เนื่องจาก 9 * 9 = 81 และ 81 สามารถแบ่งเป็น 8 + 1ได้
- 10 เนื่องจาก 10 * 10 = 100 และ 100 สามารถแบ่งเป็น 10 + 0ได้
- 36 เนื่องจาก 36 * 36 = 1296 และ 1296 สามารถแบ่งเป็น 1 + 29 + 6ได้
ดังนั้น punishment number ของ 37 คือ 1 + 81 + 100 + 1296 = 1478

ข้อจำกัด:

1 <= n <= 1000


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

1. ช่างทาสีที่ต้องจ่ายเงิน ซึ่งทาสีผนังที่ i ในเวลา time[i] หน่วยเวลาและใช้เงิน cost[i] หน่วย
2. ช่างทาสีฟรี ซึ่งสามารถทาสีผนังใดก็ได้ในเวลา 1 หน่วย โดยไม่มีค่าใช้จ่าย แต่ช่างทาสีฟรีสามารถใช้ได้ก็ต่อเมื่อช่างทาสีที่ต้องจ่ายเงินกำลังทำงานอยู่

ส่งคืนจำนวนเงินขั้นต่ำที่จำเป็นในการทาสีผนัง n ผนัง

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

Input: cost = [1,2,3,2], time = [1,2,3,2]
Output: 3
คำอธิบาย: กำแพงที่ดัชนี 0 และ 1 จะถูกทาสีโดยช่างทาสีที่ได้รับค่าจ้าง และจะใช้เวลา 3 หน่วยเวลา ในขณะเดียวกัน ช่างทาสีฟรีจะทาสีกำแพงที่ดัชนี 2 และ 3 โดยไม่เสียค่าใช้จ่ายในเวลา 2 หน่วย ดังนั้น ค่าใช้จ่ายรวมคือ 1 + 2 = 3.

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

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

ข้อจำกัด:

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

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

ช่างทาสีที่ได้รับค่าจ้างจะทาสีผนังที่ดัชนี i^th ใน time[i] หน่วยของเวลาและใช้ cost[i] หน่วยของเงิน
ช่างทาสีฟรีสามารถทาสีผนังใด ๆ ได้ใน 1 หน่วยของเวลาโดยไม่มีค่าใช้จ่าย แต่สามารถใช้ช่างทาสีฟรีได้ก็ต่อเมื่อช่างทาสีที่ได้รับค่าจ้างไม่ว่างเท่านั้น

คืนจำนวนเงินน้อยที่สุดที่จำเป็นในการทาสีผนัง n ผนัง

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

Input: cost = [1,2,3,2], time = [1,2,3,2]
Output: 3
คำอธิบาย: ผนังที่ดัชนี 0 และ 1 จะถูกทาสีโดยช่างทาสีที่ได้รับค่าจ้างและใช้เวลา 3 หน่วยของเวลา ในขณะเดียวกันช่างทาสีฟรีจะทาสีผนังที่ดัชนี 2 และ 3 โดยไม่มีค่าใช้จ่ายใน 2 หน่วยของเวลา ดังนั้นต้นทุนรวมคือ 1 + 2 = 3

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

Input: cost = [2,3,4,2], time = [1,1,1,1]
Output: 4
คำอธิบาย: ผนังที่ดัชนี 0 และ 3 จะถูกทาสีโดยช่างทาสีที่ได้รับค่าจ้างและใช้เวลา 2 หน่วยของเวลา ในขณะเดียวกันช่างทาสีฟรีจะทาสีผนังที่ดัชนี 1 และ 2 โดยไม่มีค่าใช้จ่ายใน 2 หน่วยของเวลา ดังนั้นต้นทุนรวมคือ 2 + 2 = 4

ข้อจำกัด:

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

คุณจะได้รับอาร์เรย์จำนวนเต็ม 2 ชุดที่มีดัชนี 0 คือ cost และ time โดยมีขนาด n ซึ่งแสดงถึงค่าใช้จ่ายและเวลาที่ใช้ในการทาสีผนัง n ผนังที่แตกต่างกันตามลำดับ โดยมีจิตรกร 2 คนให้เลือกใช้:

จิตรกรที่จ่ายเงิน ซึ่งทาสีผนังที่ i โดยใช้เวลา time[i] หน่วยเวลาและมีค่าใช้จ่าย cost[i] หน่วยเงิน
จิตรกรที่เป็นอิสระ ซึ่งทาสีผนังใด ๆ ก็ได้ในเวลา 1 หน่วย และไม่มีค่าใช้จ่าย แต่จิตรกรที่เป็นอิสระสามารถใช้ได้เฉพาะเมื่อจิตรกรที่จ่ายเงินกำลังทาสีผนังอยู่แล้ว
คุณต้องคืนจำนวนเงินขั้นต่ำที่จำเป็นในการทาสีผนัง n ผนังทั้งหมด

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

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

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

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

ข้อจำกัด:
1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500


คุณมีอาเรย์จำนวนเต็มที่เรียกว่า nums ซึ่งมีขนาด n แทนค่าใช้จ่ายในการเก็บช็อกโกแลตชนิดต่างๆ ค่าใช้จ่ายในการเก็บช็อกโกแลตที่ดัชนี i คือ nums[i] ช็อกโกแลตแต่ละชนิดเป็นชนิดที่ต่างกัน และเริ่มต้นด้วยชนิดที่ตำแหน่ง i คือชนิดที่ i^th

ในหนึ่งการดำเนินการ คุณสามารถทำสิ่งต่อไปนี้ด้วยค่าใช้จ่ายที่เกิดขึ้น x:

เปลี่ยนช็อกโกแลตของชนิดที่ i^th เป็นชนิด ((i + 1) mod n) สำหรับช็อกโกแลตทั้งหมดพร้อมกัน

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

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

Input: nums = [20,1,15], x = 5
Output: 13
คำอธิบาย: ในตอนแรก ช็อกโกแลตมีชนิด [0,1,2] เราจะซื้อช็อกโกแลตชนิดที่ 1 ที่มีค่าใช้จ่าย 1
ตอนนี้เราจะดำเนินการด้วยค่าใช้จ่าย 5 และชนิดของช็อกโกแลตจะกลายเป็น [1,2,0] เราจะซื้อช็อกโกแลตชนิดที่ 2 ที่มีค่าใช้จ่าย 1
ตอนนี้เราจะดำเนินการอีกครั้งด้วยค่าใช้จ่าย 5 และชนิดของช็อกโกแลตจะกลายเป็น [2,0,1] เราจะซื้อช็อกโกแลตชนิดที่ 0 ที่มีค่าใช้จ่าย 1
ดังนั้นค่าใช้จ่ายรวมจะกลายเป็น (1 + 5 + 1 + 5 + 1) = 13 ซึ่งสามารถยืนยันได้ว่าเป็นผลลัพธ์ที่เหมาะสมที่สุด

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

Input: nums = [1,2,3], x = 4
Output: 6
คำอธิบาย: เราจะเก็บช็อกโกแลตทั้งสามชนิดที่ราคาของตัวเองโดยไม่ต้องดำเนินการใดๆ ดังนั้น ค่าใช้จ่ายรวมคือ 1 + 2 + 3 = 6

ข้อจำกัด:

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

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

เปลี่ยนช็อกโกแลตประเภทที่ i^ เป็นประเภทที่ ((i + 1) mod n)^ สำหรับช็อกโกแลตทั้งหมดพร้อมกัน

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

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

อินพุต: nums = [20,1,15], x = 5
เอาต์พุต: 13
คำอธิบาย: ในตอนแรก ประเภทของช็อกโกแลตคือ [0,1,2] เราจะซื้อช็อกโกแลตประเภทที่ 1 ในราคา 1
จากนั้น เราจะทำการดำเนินการในราคา 5 และช็อกโกแลตประเภทต่างๆ จะกลายเป็น [1,2,0] เราจะซื้อช็อกโกแลตประเภทที่ 2 ในราคา 1
จากนั้น เราจะทำการดำเนินการในราคา 5 อีกครั้ง และช็อกโกแลตประเภทต่างๆ จะกลายเป็น [2,0,1] เราจะซื้อช็อกโกแลตประเภทที่ 0 ในราคา 1
ดังนั้น ต้นทุนรวมจะกลายเป็น (1 + 5 + 1 + 5 + 1) = 13 เราสามารถพิสูจน์ได้ว่านี่เป็นค่าที่เหมาะสมที่สุด

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

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

เงื่อนไข:

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

คุณจะได้รับคุณจะได้รับอาร์เรย์จำนวนเต็ม nums ขนาด n ที่มีการจัดทำดัชนีเริ่มต้นที่ 0ขนาด n แสดงถึงค่าใช้จ่ายในการรวบรวมช็อคโกแลตที่แตกต่างกัน ค่าใช้จ่ายในการรวบรวมช็อคโกแลตที่ดัชนี iเป็น nums [i] ช็อคโกแลตแต่ละชนิดมีประเภทที่แตกต่างกันและในขั้นต้นช็อคโกแลตที่ดัชนี iเป็นประเภท i^th
ในการดำเนินการครั้งเดียวคุณสามารถทำสิ่งต่อไปนี้ด้วยค่าใช้จ่ายที่เกิดขึ้นของ x:

เปลี่ยนช็อคโกแลตของ I^th type เป็น ((i + 1) mod n)^th Type สำหรับช็อคโกแลตทั้งหมด

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

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

อินพุต: nums = [20,1,15], x = 5
เอาท์พุท: 13
คำอธิบาย: เริ่มแรกประเภทช็อคโกแลตคือ [0,1,2] เราจะซื้อช็อคโกแลตประเภท 1^st ในราคา 1
ตอนนี้เราจะดำเนินการในราคา 5 และช็อคโกแลตประเภทจะกลายเป็น [1,2,0] เราจะซื้อช็อคโกแลต 2^nd^ ในราคา 1
ตอนนี้เราจะดำเนินการอีกครั้งในราคา 5 และช็อคโกแลตประเภทจะกลายเป็น [2,0,1] เราจะซื้อช็อคโกแลตประเภท 0^th ในราคา 1
ดังนั้นค่าใช้จ่ายทั้งหมดจะกลายเป็น (1 + 5 + 1 + 5 + 1) = 13 เราสามารถพิสูจน์ได้ว่านี่เป็นสิ่งที่เหมาะสมที่สุด

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

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

ข้อ จำกัด :

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


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

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

อินพุต: n = 5, k = 4
เอาต์พุต: 18
คำอธิบาย: พิจารณาอาร์เรย์ที่หลีกเลี่ยง k [1,2,4,5,6] ซึ่งมีผลรวมเท่ากับ 18
สามารถพิสูจน์ได้ว่าไม่มีอาร์เรย์ที่หลีกเลี่ยง k ที่มีผลรวมน้อยกว่า 18

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

อินพุต: n = 2, k = 6
เอาต์พุต: 3
คำอธิบาย: เราสามารถสร้างอาร์เรย์ [1,2] ซึ่งมีผลรวมเท่ากับ 3
สามารถพิสูจน์ได้ว่าไม่มีอาร์เรย์ที่หลีกเลี่ยง k ที่มีผลรวมน้อยกว่า 3

ข้อจำกัด:

1 <= n, k <= 50

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

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

อินพุต: n = 5, k = 4
เอาท์พุท: 18
คำอธิบาย: พิจารณาอาร์เรย์ที่หลีกเลี่ยง K [1,2,4,5,6] ซึ่งมีผลรวม 18
สามารถพิสูจน์ได้ว่าไม่มีอาร์เรย์ที่หลีกเลี่ยง K ที่มีผลรวมน้อยกว่า 18

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

อินพุต: n = 2, k = 6
เอาท์พุท: 3
คำอธิบาย: เราสามารถสร้างอาร์เรย์ [1,2] ซึ่งมีผลรวม 3
สามารถพิสูจน์ได้ว่าไม่มีอาร์เรย์ที่หลีกเลี่ยง K ที่มีผลรวมน้อยกว่า 3

ข้อ จำกัด :

1 <= n, k <= 50

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

อินพุต: n = 5, k = 4
เอาต์พุต: 18
คำอธิบาย: พิจารณาอาร์เรย์หลีกเลี่ยง k [1,2,4,5,6] ซึ่งมีผลรวมเท่ากับ 18
สามารถพิสูจน์ได้ว่าไม่มีอาร์เรย์หลีกเลี่ยง k ที่มีผลรวมน้อยกว่า 18

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

อินพุต: n = 2, k = 6
เอาต์พุต: 3
คำอธิบาย: เราสามารถสร้างอาร์เรย์ [1,2] ซึ่งมีผลรวมเท่ากับ 3
สามารถพิสูจน์ได้ว่าไม่มีอาร์เรย์หลีกเลี่ยง k ที่มีผลรวมน้อยกว่า 3

ข้อจำกัด:

1 <= n, k <= 50


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

เพิ่มหรือลด x ขึ้น 1 และเพิ่มหรือลด num ขึ้น 1 พร้อมกัน

ส่งคืนจำนวนสูงสุดที่เป็นไปได้ที่สามารถบรรลุได้ สามารถพิสูจน์ได้ว่ามีจำนวนสูงสุดที่เป็นไปได้

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

อินพุต: num = 4, t = 1
เอาต์พุต: 6
คำอธิบาย: จำนวนสูงสุดที่เป็นไปได้คือ x = 6; สามารถเท่ากับ num ได้หลังจากดำเนินการนี้:
1- ลด x ลง 1 และเพิ่ม num ขึ้น 1 ตอนนี้ x = 5 และ num = 5
สามารถพิสูจน์ได้ว่าไม่มีตัวเลขใดที่สามารถทำได้มากกว่า 6

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

อินพุต: num = 3, t = 2
เอาต์พุต: 7
คำอธิบาย: ตัวเลขสูงสุดที่สามารถทำได้คือ x = 7 หลังจากดำเนินการเหล่านี้แล้ว x จะเท่ากับ num:
1- ลด x ลง 1 และเพิ่ม num ขึ้น 1 ตอนนี้ x = 6 และ num = 4
2- ลด x ลง 1 และเพิ่ม num ขึ้น 1 ตอนนี้ x = 5 และ num = 5
สามารถพิสูจน์ได้ว่าไม่มีตัวเลขใดที่สามารถทำได้มากกว่า 7

ข้อจำกัด:

1 <= num, t <= 50

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

เพิ่มหรือลด x โดย 1 และเพิ่มหรือลด num พร้อมกันโดย 1

ส่งคืนหมายเลขที่ทำได้สูงสุด สามารถพิสูจน์ได้ว่ามีจำนวนอย่างน้อยหนึ่งหมายเลขที่ทำได้

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

อินพุต: num = 4, t = 1
เอาท์พุท: 6
คำอธิบาย: จำนวนสูงสุดที่ทำได้คือ x = 6; มันอาจเท่ากับ num หลังจากดำเนินการนี้:
1- ลด x โดย 1 และเพิ่ม num โดย 1 ตอนนี้ x = 5 และ num = 5
สามารถพิสูจน์ได้ว่าไม่มีจำนวนที่มากกว่า 6

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

อินพุต: num = 3, t = 2
เอาท์พุท: 7
คำอธิบาย: จำนวนสูงสุดที่ทำได้คือ x = 7; หลังจากดำเนินการเหล่านี้ x จะเท่ากับ num:
1- ลด x โดย 1 และเพิ่ม num โดย 1 ตอนนี้ x = 6 และ num = 4
2- ลด x โดย 1 และเพิ่ม num โดย 1 ตอนนี้ x = 5 และ num = 5
สามารถพิสูจน์ได้ว่าไม่มีจำนวนที่มากกว่า 7

ข้อ จำกัด :

1 <= num, t <= 50


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

ส่งคืนสตริงพาลินโดรมที่ได้

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

อินพุต: s = "egcfe"
เอาต์พุต: "efcfe"
คำอธิบาย: จำนวนการดำเนินการขั้นต่ำเพื่อทำให้ "egcfe" เป็นพาลินโดรมคือ 1 และสตริงพาลินโดรมที่เล็กที่สุดในพจนานุกรมที่เราสามารถรับได้โดยการแก้ไขอักขระหนึ่งตัวคือ "efcfe" โดยเปลี่ยน 'g'

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

อินพุต: s = "abcd"
เอาต์พุต: "abba"
คำอธิบาย: จำนวนการดำเนินการขั้นต่ำเพื่อทำให้ "abcd" เป็นพาลินโดรมคือ 2 และสตริงพาลินโดรมที่เล็กที่สุดในพจนานุกรมที่เราสามารถรับได้โดยการแก้ไขอักขระสองตัวคือ "abba"
ตัวอย่างที่ 3:

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

ข้อจำกัด:

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

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

ตัวอย่าง 1:

Input: s = "egcfe"
Output: "efcfe"
คำอธิบาย: จำนวนการดำเนินการที่น้อยที่สุดในการทำให้ "egcfe" เป็นพาลินโดรมคือ 1 และสตริงพาลินโดรมที่เล็กที่สุดตามลำดับที่เราสามารถทำได้โดยการแก้ไขหนึ่งตัวอักษรคือ "efcfe" โดยการเปลี่ยน 'g'

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

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

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

Input: s = "seven"
Output: "neven"
คำอธิบาย: จำนวนการดำเนินการที่น้อยที่สุดในการทำให้ "seven" เป็นพาลินโดรมคือ 1 และสตริงพาลินโดรมที่เล็กที่สุดตามลำดับที่เราสามารถทำได้โดยการแก้ไขหนึ่งตัวอักษรคือ "neven"

ข้อจำกัด:

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