Három kártya van a $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ betűkkel, amelyek valamilyen sorrendben sorban vannak elhelyezve. Az alábbi műveletet legfeljebb egyszer hajthatja végre:

- Válasszon ki két kártyát, és cserélje meg őket. Lehetséges-e, hogy a sor $\texttt{abc}$ lesz a művelet után? Adja meg a "YES" választ, ha lehetséges, és a "NO" választ, ha nem.

Bemenet

Az első sor egyetlen egész számot tartalmaz $t$ ($1 \leq t \leq 6$) — a tesztesetek számát.

Minden teszteset egyetlen sorban egy karaktersorozatot tartalmaz, amely mindhárom $\texttt{a}$, $\texttt{b}$ és $\texttt{c}$ karaktert pontosan egyszer tartalmazza, és a kártyákat képviseli.

Kimenet

Minden tesztesetnél adja meg a "YES" választ, ha legfeljebb egy művelettel elérhető az $\texttt{abc}$ sor, vagy a "NO" választ, ha nem lehetséges.

A választ bármilyen formában megadhatja (például a "yEs", "yes", "Yes" és "YES" formák is pozitív válaszként értelmezhetők).

Bemeneti minta 1:
6

abc

acb

bac

bca

cab

cba

Kimeneti minta 1:

YES
YES
YES
NO
NO
YES

Megjegyzés

Az első tesztesetben nem kell végrehajtanunk semmilyen műveletet, mivel a sor már $\texttt{abc}$.

A második tesztesetben kicserélhetjük $\texttt{c}$ és $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$.

A harmadik tesztesetben kicserélhetjük $\texttt{b}$ és $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$.

A negyedik tesztesetben lehetetlen legfeljebb egy művelettel elérni az $\texttt{abc}$ formát.

Három kártya van, amelyek $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ betűket tartalmaznak egy sorban valamilyen sorrendben. A következő műveletet legfeljebb egyszer végezheti el:

- Válasszon két kártyát, és cserélje ki őket.  Lehetséges, hogy a sor $\texttt{abc}$ lesz a művelet után? Kimenet "IGEN", ha lehetséges, és "NEM" egyébként.

Bemenet

Az első sor egyetlen egész számot tartalmaz $t$ ($1 \leq t \leq 6$) — a tesztesetek számát.

Az egyes tesztesetek egyetlen sora egyetlen karakterláncot tartalmaz, amely a három $\texttt{a}$, $\texttt{b}$ és $\texttt{c}$ karakterből áll, pontosan egyszer, a kártyákat képviselve.

Hozam

Minden tesztesetben adja ki az "IGEN" értéket, ha a sort legfeljebb egy művelettel $\texttt{abc}$ tudja létrehozni, vagy egyébként "NEM" értéket.

A választ minden esetben kiadhatja (például az "yEs", "yes", "Yes" és "YES" karakterláncokat pozitív válaszként ismeri fel). 1. minta bemenet:
6

Abc

Acb

Bac

BCA

vezetőfülke

CBA

1. mintakimenet:

YES
YES
YES
NO
NO
YES

Jegyzet

Az első tesztesetben nem kell semmilyen műveletet végrehajtanunk, mivel a sor már $\texttt{abc}$.

A második tesztesetben felcserélhetjük a $\texttt{c}$ és $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$ értéket.

A harmadik tesztesetben felcserélhetjük a $\texttt{b}$ és $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$ értéket.

A negyedik tesztesetben lehetetlen $\texttt{abc}$ létrehozni legfeljebb egy művelettel.

Három kártya van, amelyek $\texttt{a}$, $\texttt{b}$, $\texttt{c}$ betűket tartalmaznak egy sorban valamilyen sorrendben. A következő műveletet legfeljebb egyszer végezheti el:

- Válasszon két kártyát, és cserélje ki őket.  Lehetséges, hogy a sor $\texttt{abc}$ lesz a művelet után? Kimenet "YES", ha lehetséges, és "NO" egyébként.

Bemenet

Az első sor egyetlen egész számot tartalmaz $t$ ($1 \leq t \leq 6$) — a tesztesetek számát.

Az egyes tesztesetek egyetlen sora egyetlen karakterláncot tartalmaz, amely a három $\texttt{a}$, $\texttt{b}$ és $\texttt{c}$ karakterből áll, pontosan egyszer, a kártyákat képviselve.

Hozam

Minden tesztesetben adja ki az "YES" értéket, ha a sort legfeljebb egy művelettel $\texttt{abc}$ tudja létrehozni, vagy egyébként "NO" értéket.

A választ minden esetben kiadhatja (például az "yEs", "yes", "Yes" és "YES" karakterláncokat pozitív válaszként ismeri fel). 1. minta bemenet:
6

abc

acb

bac

bca

cab

cba

1. minta kimenet:

YES
YES
YES
NO
NO
YES

Jegyzet

Az első tesztesetben nem kell semmilyen műveletet végrehajtanunk, mivel a sor már $\texttt{abc}$.

A második tesztesetben felcserélhetjük a $\texttt{c}$ és $\texttt{b}$: $\texttt{acb} \to \texttt{abc}$ értéket.

A harmadik tesztesetben felcserélhetjük a $\texttt{b}$ és $\texttt{a}$: $\texttt{bac} \to \texttt{abc}$ értéket.

A negyedik tesztesetben lehetetlen $\texttt{abc}$ létrehozni legfeljebb egy művelettel.


Slavic ajándékot készít egy barátjának születésnapjára. Van egy $n$ számjegyű $a$ tömbje, és a jelen ezeknek a számjegyeknek a szorzata lesz. Mivel Slavic jó gyerek, aki a lehető legnagyobb terméket akarja készíteni, pontosan az egyik számjegyéhez szeretne 1-et hozzáadni.

Mi a maximális termék, amit Slavic készíthet?

Bemenet

Az első sor egyetlen egész számot tartalmaz: $t$ ($1 \leq t \leq 10^4$) – a tesztesetek számát.

Minden teszteset első sora egyetlen egész számot tartalmaz: $n$ ($1 \leq n \leq 9$) – a számjegyek számát.

Minden teszteset második sora $n$ szóközzel elválasztott $a_i$ ($0 \leq a_i \leq 9$) egész számot tartalmaz – a tömb számjegyeit.

Kimenet

Minden tesztesethez adjon ki egyetlen egész számot – a maximális szorzatot, amelyet szláv tud elérni, ha pontosan az egyik számjegyéhez ad hozzá $1$-t. 1. mintabevitel:
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. minta kimenet:

16
2
432
430467210

Szláv ajándékot készít egy barátja születésnapjára. Van egy tömbje $a$ $n$ számjegyekből, és a jelen ezeknek a számjegyeknek a szorzata lesz. Mivel a szláv jó gyerek, aki a lehető legnagyobb terméket akarja előállítani, he wants to add 1 to exactly one of his digits

Mi a maximális termék, amit a szláv készíthet?

Bemenet

Az első sorban egyetlen egész szám $t$ ($1 \leq t \leq 10^4$) - a tesztesetek száma.

Minden egyes teszteset első sora tartalmaz egy egész számot $n$ ($1 \leq n \leq 9$) - a számjegyek száma.

Minden teszteset második sora $n$ szóközzel elválasztott egész számokat tartalmaz $a_i$ ($0 \leq a_i \leq 9$) - a tömb számjegyeit.

Kimenet

Minden tesztesethez adjon ki egyetlen egész számot - a maximális szorzatot, amelyet a szláv készíthet, ha pontosan az egyik számjegyéhez hozzáad $1$-t. 1. minta bemenet:
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

Minta kimenet 1:

16
2
432
430467210

Szláv ajándékot készít egy barátjának születésnapjára. Van egy $n$ számjegyű $a$ tömbje, és a jelen ezeknek a számjegyeknek a szorzata lesz. Mivel Slavic jó gyerek, aki a lehető legnagyobb terméket akarja készíteni, pontosan az egyik számjegyéhez szeretne 1 dollárt hozzáadni.

Mi a maximális termék, amit a szláv készíthet?

Bemenet

Az első sor egyetlen egész számot tartalmaz: $t$ ($1 \leq t \leq 10^4$) – a tesztesetek számát.

Minden teszteset első sora egyetlen egész számot tartalmaz: $n$ ($1 \leq n \leq 9$) – a számjegyek számát.

Minden teszteset második sora $n$ szóközzel elválasztott $a_i$ ($0 \leq a_i \leq 9$) egész számot tartalmaz – a tömb számjegyeit.

Kimenet

Minden tesztesethez adjon ki egyetlen egész számot – a maximális szorzatot, amelyet szláv tud elérni, ha pontosan az egyik számjegyéhez ad hozzá $1$-t. 1. mintabevitel:
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. minta kimenet:

16
2
432
430467210


Kapsz egy $s$ papírcsíkot, amely $n$ cella hosszú. Minden cella fekete vagy fehér. Egy műveletben tetszőleges $k$ egymás utáni cellát vehet, és mindegyiket fehérre teheti.

Keresse meg az összes fekete cella eltávolításához szükséges műveletek minimális számát.

Bemenet

Az első sor egyetlen egész számot tartalmaz: $t$ ($1 \leq t \leq 1000$) – a tesztesetek számát.

Minden teszteset első sora két egész számot tartalmaz: $n$ és $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) – a papír hossza és a műveletben használt egész szám.

Minden teszteset második sora tartalmaz egy $s$ karakterláncot, amelynek hossza $n$, amely $\texttt{B}$ (fekete cellát jelöl) vagy $\texttt{W}$ (fehér cellát jelöl) karakterekből áll.

Az összes tesztesetre vetített $n$ összege nem haladja meg a $2 \cdot 10^5$ összeget.

Kimenet

Minden tesztesethez adjon ki egyetlen egész számot – az összes fekete cella eltávolításához szükséges műveletek minimális számát. 1. minta bemenet:
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

Példa kimenet 1:

2
1
2
1
4
3
4
0

Megjegyzés

Az első tesztesetben a következő műveleteket hajthatja végre: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

A második tesztesetben a következő műveleteket hajthatja végre: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

A harmadik tesztesetben a következő műveleteket hajthatja végre: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$

Kapunk egy $s$ hosszúságú, $n$ cellás papírcsíkot. Minden egyes cella fekete vagy fehér. Egy művelet során bármelyik $k$ egymást követő cellát fehérre színezheted.

Keressük meg a minimálisan szükséges műveletszámot az összes fekete cella eltávolításához.

Bemenet

Az első sor egyetlen egész számot tartalmaz $t$ ($1 \leq t \leq 1000$) - a tesztesetek számát.

Minden egyes teszteset első sora két egész számot tartalmaz $n$ és $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) - a papír hossza és a műveletben használt egész szám.

Minden teszteset második sora egy $s$ hosszúságú $n$ karakterláncot tartalmaz, amely $\texttt{B}$ (fekete cellát jelöl) vagy $\texttt{W}$ (fehér cellát jelöl) karakterekből áll.

Az összes tesztesetre vonatkozó $n$ összege nem haladja meg a $2 \cdot 10^5$ értéket.

Kimenet

Minden egyes tesztesethez adjon ki egyetlen egész számot - az összes fekete cella eltávolításához szükséges műveletek minimális számát.Bemeneti minta 1:
8

6 3

WBWWWWB

7 3

WWBWWBWW

5 4

BWBWB

5 5

BBBBBB

8 2

BWBWBBBB

10 2

WBBWWBBWBBWBBW

4 1

BBBB

3 2

WWW

Kimeneti minta 1:

2
1
2
1
4
3
4
0

Megjegyzés

Az első tesztesetben a következő műveleteket végezheti el: $$\color{red}{\texttt{WBW}}\texttt{WWWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWWWWW}$$$

A második tesztesetben a következő műveleteket végezhetjük el: $$$\texttt{WWW}\color{red}{\texttt{BWB}}\texttt{WWW} \to \texttt{WWWWWWWWWWW}$$$

A harmadik tesztesetben a következő műveleteket végezheti: $$$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWWWW}$$$

Kapsz egy $s$ papírcsíkot, amely $n$ cella hosszú. Minden cella fekete vagy fehér. Egy műveletben tetszőleges $k$ egymás utáni cellát vehet, és mindegyiket fehérre teheti.

Keresse meg az összes fekete cella eltávolításához szükséges műveletek minimális számát.

Bemenet

Az első sor egyetlen egész számot tartalmaz: $t$ ($1 \leq t \leq 1000$) – a tesztesetek számát.

Minden teszteset első sora két egész számot tartalmaz: $n$ és $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) – a papír hossza és a műveletben használt egész szám.

Minden teszteset második sora tartalmaz egy $s$ karakterláncot, amelynek hossza $n$, amely $\texttt{B}$ (fekete cellát jelöl) vagy $\texttt{W}$ (fehér cellát jelöl) karakterekből áll.

Az összes tesztesetre vetített $n$ összege nem haladja meg a $2 \cdot 10^5$ összeget.

Kimenet

Minden tesztesethez adjon ki egyetlen egész számot – az összes fekete cella eltávolításához szükséges műveletek minimális számát. 1. minta bemenet:
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. minta kimenet:

2
1
2
1
4
3
4
0

Jegyzet

Az első tesztesetben a következő műveleteket hajthatja végre: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \to \texttt{WWWWWW}$$

A második tesztesetben a következő műveleteket hajthatja végre: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

A harmadik tesztesetben a következő műveleteket hajthatja végre: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \to \texttt{WWWWW}$$


Adott egy $s$ karakterlánc, amely hossza $n$, és kisbetűs latin betűkből áll, valamint egy egész szám $k$.

Ellenőriznünk kell, hogy lehetséges-e pontosan $k$ karaktert eltávolítani az $s$ karakterláncból úgy, hogy a megmaradó karakterek átrendezhetők legyenek egy palindróma formálására. Megjegyzés: a megmaradó karakterek bármilyen módon átrendezhetők.

Palindróma az a karakterlánc, amely előről és hátulról olvasva ugyanaz. Például a "z", "aaa", "aba", "abccba" karakterláncok palindrómák, míg a "codeforces", "reality", "ab" karakterláncok nem azok.

Bemenet

Mindegyik teszt több tesztesetből áll. Az első sor egyetlen egész számot tartalmaz: $t$ ($1 \leq t \leq 10^4$) — a tesztesetek száma. Ezt követi a leírásuk.

Mindegyik teszteset első sora két egész számot tartalmaz: $n$ és $k$ ($0 \leq k < n \leq 10^5$) — a karakterlánc $s$ hossza és az eltávolítandó karakterek száma.

Mindegyik teszteset második sora egy $s$ karakterláncot tartalmaz, amely hossza $n$, és kisbetűs latin betűkből áll.

Biztosított, hogy az összes teszteset $n$ összege nem haladja meg a $2 \cdot 10^5$-öt.

Kimenet

Mindegyik tesztesethez írd ki, hogy "YES", ha lehetséges pontosan $k$ karaktert eltávolítani az $s$ karakterláncból úgy, hogy a megmaradó karakterek átrendezhetők legyenek egy palindróma formálására, és "NO", egyébként.

A válasz bármilyen formában kiírható (kis- vagy nagybetű). Például a "yEs", "yes", "Yes" és "YES" karakterláncok pozitív válaszként lesznek felismerve.

Sample Input 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

Sample Output 1:

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

Note

Az első tesztesetben semmit sem lehet eltávolítani, és az "a" karakterlánc palindróma.

A második tesztesetben semmit sem lehet eltávolítani, de az "ab" és a "ba" nem palindrómák.

A harmadik tesztesetben bármely karaktert eltávolíthatjuk, és az eredményként kapott karakterlánc palindróma lesz.

A negyedik tesztesetben egy "a" karakter eltávolítható, így a "bb" karakterláncot kapjuk, ami palindróma.

A hatodik tesztesetben egy "b" és egy "d" karakter eltávolítható, így a "acac" karakterláncot kapjuk, ami átrendezve "acca" formában palindróma.

A kilencedik tesztesetben egy "t" és egy "k" karakter eltávolítható, így az "aagaa" karakterláncot kapjuk, ami palindróma.

Kapsz egy $s$ hosszúságú $n$ karakterláncot, amely kisbetűs latin betűkből áll, és egy egész számot $k$.

Ellenőriznie kell, hogy lehetséges-e pontosan eltávolítani a $k$ karaktereket a $s$ karakterláncból oly módon, hogy a fennmaradó karakterek átrendezhetők legyenek palindrom kialakításához. Ne feledje, hogy a fennmaradó karaktereket bármilyen módon átrendezheti.

A palindrom egy karakterlánc, amely ugyanazt olvassa előre és hátra. Például a "z", "aaa", "aba", "abccba" karakterláncok palindromok, míg a "kóderők", "valóság", "ab" karakterláncok nem.

Bemenet

Minden teszt több tesztesetből áll. Az első sor egyetlen egész számot tartalmaz $t$ ($1 \leq t \leq 10^4$) — a tesztesetek számát. Ezt követi a leírásuk.

Minden teszteset első sora két egész számot tartalmaz $n$ és $k$ ($0 \leq k < n \leq 10^5$) — a karakterlánc hossza $s$ és a törlendő karakterek száma.

Az egyes tesztesetek második sora tartalmaz egy $s$ hosszúságú $n$ karakterláncot, amely kisbetűs latin betűkből áll.

Garantált, hogy a $n$ összege az összes tesztesetben nem haladja meg a $2 \cdot 10^5$-t.

Hozam

Minden tesztesetben adja ki az "IGEN" értéket, ha lehetséges pontosan eltávolítani a $k$ karaktereket a $s$ karakterláncból oly módon, hogy a fennmaradó karakterek átrendezhetők palindrom kialakításához, és "NEM" egyébként.

A választ bármilyen esetben kiadhatja (nagybetű vagy kisbetű). Például az "yEs", "yes", "Yes" és "YES" karakterláncokat pozitív válaszként ismeri fel a rendszer. 1. minta bemenet:
14

1 0

egy

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

Trraakkttoorr

5 3

debdb

5 4

ECADC

5 3

Debca

5 3

ABAAC

1. mintakimenet:

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

Jegyzet

Az első tesztesetben semmit sem lehet eltávolítani, és az "a" karakterlánc palindrom.

A második tesztesetben semmit sem lehet eltávolítani, de az "ab" és "ba" karakterláncok nem palindromok.

A harmadik tesztesetben bármely karakter eltávolítható, és a kapott karakterlánc palindrom lesz.

A negyedik tesztesetben az "a" karakter egyik előfordulása eltávolítható, ami a "bb" karakterláncot eredményezi, amely egy palindrom.

A hatodik tesztesetben a "b" és "d" karakterek egy előfordulása eltávolítható, ami az "acac" karakterláncot eredményezi, amely átrendezhető az "acca" karakterláncra.

A kilencedik tesztesetben a "t" és "k" karakterek egy előfordulása eltávolítható, ami az "aagaa" karakterláncot eredményezi, amely egy palindrom.

Kapsz egy $s$ karakterláncot, amelynek hossza $n$, amely kisbetűs latin betűkből és egy $k$ egész számból áll.

Meg kell vizsgálni, hogy lehetséges-e pontosan $k$ karaktert eltávolítani a $s$ karakterláncból oly módon, hogy a megmaradt karakterek átrendezhetők palindrommá. Vegye figyelembe, hogy a fennmaradó karaktereket bármilyen módon átrendezheti.

A palindrom egy olyan karakterlánc, amely előre és hátrafelé ugyanazt olvassa. Például a "z", "aaa", "aba", "abccba" karakterláncok palindromok, míg a "codeforces", "reality", "ab" karakterláncok nem.

Bemenet

Minden teszt több tesztesetből áll. Az első sor egyetlen egész számot tartalmaz: $t$ ($1 \leq t \leq 10^4$) – a tesztesetek számát. Ezt követi a leírásuk.

Minden teszteset első sora két egész számot tartalmaz: $n$ és $k$ ($0 \leq k < n \leq 10^5$) – a $s$ karakterlánc hosszát és a törölni kívánt karakterek számát.

Minden teszteset második sora tartalmaz egy $s$ karakterláncot, amelynek hossza $n$, és kisbetűkből áll.

Garantáltan az összes tesztesetre vetített $n$ összeg nem haladja meg a $2 \cdot 10^5$-t.

Kimenet

Minden tesztesetnél adjon "YES"-t, ha lehetséges pontosan $k$ karaktert eltávolítani a $s$ karakterláncból oly módon, hogy a fennmaradó karakterek átrendezhetők palindrommá, ellenkező esetben pedig "NO"-t.

A választ minden esetben kiírhatja (kis- vagy nagybetűvel). Például a „YES”, „yes”, „Yes” és „YES” karakterláncok pozitív válaszként kerülnek felismerésre. 1. mintabevitel:
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

ttraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

1. minta kimenet:

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

Jegyzet

Az első tesztesetben semmit nem lehet eltávolítani, és az "a" karakterlánc palindrom.

A második tesztesetben semmit nem lehet eltávolítani, de az "ab" és "ba" karakterláncok nem palindromok.

A harmadik tesztesetben bármely karakter eltávolítható, és a kapott karakterlánc palindrom lesz.

A negyedik tesztesetben az "a" karakter egy előfordulása eltávolítható, ami a "bb" karakterláncot eredményezi, amely palindrom.

A hatodik tesztesetben a „b” és „d” karakterek egy-egy előfordulása eltávolítható, ami az „acac” karakterláncot eredményezi, amely átrendezhető „acca” karakterláncra.

A kilencedik tesztesetben a "t" és a "k" karakterek egy-egy előfordulása eltávolítható, ami az "aagaa" karakterláncot eredményezi, amely egy palindrom.


Egész számok tömbjét kapja $a_1, a_2, \ldots, a_n$ és egy $k$ számot ($2 \leq k \leq 5$). Egy művelettel a következőket teheti:

- Válasszon egy indexet $1 \leq i \leq n$,
- Állítsa be a $a_i = a_i + 1$ értéket. Keresse meg azt a minimális műveletszámot, amely ahhoz szükséges, hogy a tömb összes számának szorzata osztható legyen $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ $k$ értékkel.

Bemenet

Minden teszt több tesztesetből áll. Az első sor egyetlen egész számot tartalmaz $t$ ($1 \leq t \leq 10^4$) — a tesztesetek számát. Ezután következik a tesztesetek leírása.

Az egyes tesztesetek első sora két egész számot tartalmaz $n$ és $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — a tömb mérete $a$ és a szám $k$.

Az egyes tesztesetek második sora $n$ egész számokat tartalmaz $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Garantált, hogy a $n$ összege az összes tesztesetben nem haladja meg a $2 \cdot 10^5$-t.

 Kimenet

Minden tesztesethez adja ki azt a minimális számú műveletet, amely ahhoz szükséges, hogy a tömb összes számának szorzata osztható legyen $k$-ral. 1. minta bemenet:
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. minta kimenet:

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

Jegyzet

Az első tesztesetben kétszer kell kiválasztanunk az indexet $i = 2$. Ezután a tömb $a = [7, 5]$ lesz. A tömb összes számának szorzata $35$.

A negyedik tesztesetben a tömbben lévő számok szorzata $120$, ami már osztható $5$-ral, így nincs szükség műveletekre.

A nyolcadik tesztesetben két műveletet hajthatunk végre a $i = 2 $ és $i = 3 $ kiválasztásával bármilyen sorrendben. Ezután a tömb $a = [1, 6, 10]$ lesz. A tömbben lévő számok szorzata $60$.

Egész számok tömbjét kapja $a_1, a_2, \ldots, a_n$ és egy $k$ számot ($2 \leq k \leq 5$). Egy művelettel a következőket teheti:

- Válasszon egy indexet $1 \leq i \leq n$,
- Állítsa be a $a_i = a_i + 1$ értéket. Keresse meg azt a minimális műveletszámot, amely ahhoz szükséges, hogy a tömb összes számának szorzata osztható legyen $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ $k$ értékkel.

Bemenet

Minden teszt több tesztesetből áll. Az első sor egyetlen egész számot tartalmaz $t$ ($1 \leq t \leq 10^4$) — a tesztesetek számát. Ezután következik a tesztesetek leírása.

Az egyes tesztesetek első sora két egész számot tartalmaz $n$ és $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) — a tömb mérete $a$ és a szám $k$.

Az egyes tesztesetek második sora $n$ egész számokat tartalmaz $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Garantált, hogy a $n$ összege az összes tesztesetben nem haladja meg a $2 \cdot 10^5$-t.

Hozam

Minden tesztesethez adja ki azt a minimális számú műveletet, amely ahhoz szükséges, hogy a tömb összes számának szorzata osztható legyen $k$-ral. 1. minta bemenet:
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. minta kimenet:

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

Jegyzet

Az első tesztesetben kétszer kell kiválasztanunk az indexet $i = 2$. Ezután a tömb $a = [7, 5]$ lesz. A tömb összes számának szorzata $35$.

A negyedik tesztesetben a tömbben lévő számok szorzata $120$, ami már osztható $5$-ral, így nincs szükség műveletekre.

A nyolcadik tesztesetben két műveletet hajthatunk végre a $i = 2 $ és $i = 3 $ kiválasztásával bármilyen sorrendben. Ezután a tömb $a = [1, 6, 10]$ lesz. A tömbben lévő számok szorzata $60$.

Kapsz egy $a_1, a_2, \ldots, a_n$ egész számokat és egy $k$ számot ($2 \leq k \leq 5$). Egy művelettel a következőket teheti:

- Válasszon egy indexet: $1 \leq i \leq n$,
- Állítsa be: $a_i = a_i + 1$. Keresse meg a minimális számú műveletet, amely ahhoz szükséges, hogy a $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ tömb összes számának szorzata osztható legyen $k$-tal.

Bemenet

Minden teszt több tesztesetből áll. Az első sor egyetlen egész számot tartalmaz: $t$ ($1 \leq t \leq 10^4$) – a tesztesetek számát. Ezután következik a tesztesetek leírása.

Minden teszteset első sora két egész számot tartalmaz: $n$ és $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) – a $a$ tömb mérete és a szám $k$.

Minden teszteset második sora $n$ egész számot tartalmaz: $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Garantáltan az összes tesztesetre vetített $n$ összeg nem haladja meg a $2 \cdot 10^5$-t.

Kimenet

Minden tesztesethez adja ki a minimális számú műveletet ahhoz, hogy a tömbben lévő összes szám szorzata osztható legyen $k$-al. 1. mintabemenet:
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. minta kimenet:

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

Jegyzet

Az első tesztesetben kétszer kell a $i = 2$ indexet választanunk. Ezt követően a tömb $a = [7, 5]$ lesz. A tömbben lévő összes szám szorzata 35.

A negyedik tesztesetben a tömbben lévő számok szorzata $120$, ami már osztható $5$-ral, tehát nincs szükség műveletekre.

A nyolcadik tesztesetben tetszőleges sorrendben $i = 2$ és $i = 3$ választásával két műveletet hajthatunk végre. Ezt követően a tömb $a = [1, 6, 10]$ lesz. A tömbben lévő számok szorzata 60.


Vanya és Vova játszanak. A játékosok egész számot kapnak $n$. A játékos hozzáadhat $1$-t az aktuális egész számhoz, vagy kivonhat $1$-t. A játékosok felváltva játszanak; Vanya elindul. Ha Vanya lépése után az egész szám osztható $3$-ral, akkor nyer. Ha $10$ lépés telt el, és Vanya nem nyert, akkor Vova nyer.

Írj egy programot, amely az egész szám alapján $n$, meghatározza, hogy ki fog nyerni, ha mindkét játékos optimálisan játszik.

Bemenet

Az első sor tartalmazza a $t$ ($1 \leq t \leq 100$) egész számot — a tesztesetek számát.

Az egyes tesztesetek egyetlen sora tartalmazza az egész $n$ ($1 \leq n \leq 1000$) számot.

Kimenet

Minden tesztesetben nyomtassa ki az "First" idézőjelek nélkül, ha Vanya nyer, és a "Second" idézőjelek nélkül, ha Vova nyer. Példa bemenet 1:
6

1

3

5

100

999

1000

Példa kimenet 1:

First
Second
First
First
Second
First

Ványa és Vova játszanak. A játékosok egy $n$ egész számot kapnak. A körükben a játékos hozzáadhat $1$-t az aktuális egészhez, vagy kivonhat 1$-t. A játékosok váltják egymást; – kezdi Ványa. Ha Ványa lépése után az egész szám osztható $3$-tal, akkor ő nyer. Ha 10$-os lépések elhaladtak, és Vanya nem nyert, akkor Vova nyer.

Írj egy programot, amely a $n$ egész szám alapján meghatározza, hogy ki nyer, ha mindkét játékos optimálisan játszik.

Bemenet

Az első sor a $t$ egész számot tartalmazza ($1 \leq t \leq 100$) – a tesztesetek számát.

Minden teszteset egyetlen sora tartalmazza a $n$ egész számot ($1 \leq n \leq 1000$).

Kimenet

Minden tesztesetnél nyomtassa ki az „Első” szót idézőjelek nélkül, ha Ványa nyer, és a „Második” szót idézőjelek nélkül, ha Vova nyer. 1. példa:
6

1

3

5

100

999

1000

1. minta kimenet:

First
Second
First
First
Second
First

Ványa és Vova játszanak. A játékosok egy $n$ egész számot kapnak. A körükben a játékos hozzáadhat $1$-t az aktuális egészhez, vagy kivonhat 1$-t. A játékosok váltják egymást; – kezdi Ványa. Ha Ványa lépése után az egész szám osztható $3$-tal, akkor ő nyer. Ha 10$-os lépések elhaladtak, és Vanya nem nyert, akkor Vova nyer.

Írj egy programot, amely a $n$ egész szám alapján meghatározza, hogy ki nyer, ha mindkét játékos optimálisan játszik.

Bemenet

Az első sor a $t$ egész számot tartalmazza ($1 \leq t \leq 100$) – a tesztesetek számát.

Minden teszteset egyetlen sora tartalmazza a $n$ egész számot ($1 \leq n \leq 1000$).

Kimenet

Minden tesztesetnél nyomtassa ki az „First” szót idézőjelek nélkül, ha Ványa nyer, és a „Second” szót idézőjelek nélkül, ha Vova nyer. 1. példa:
6

1

3

5

100

999

1000

1. minta kimenet:

First
Second
First
First
Second
First


Alex részt vesz a BrMeast újabb videójának forgatásában, a BrMeast pedig felkérte Alexet, hogy készítsen elő 250 ezer tonna TNT-t, de Alex nem hallotta jól, ezért $n$-os dobozokat készített elő, és sorba rendezte a kamionokra várva. A bal oldali $i$-edik doboz $a_i$ tonnát nyom.

Az összes teherautó, amelyet Alex használni fog, ugyanannyi dobozt tartalmaz, amelyet $k$ jelöl. A betöltés a következőképpen történik:

- Az első $k$ doboz az első kamionhoz kerül,
- A második $k$ doboz a második kamionhoz kerül,
- $\dotsb$
- Az utolsó $k$ doboz a $\frac{n}{k}$-edik teherautóra kerül. A rakodás befejeztével minden teherautón pontosan $k$ doboznak kell lennie. Vagyis ha egy ponton nem lehet pontosan $k$ dobozt berakni a teherautóba, akkor azzal a $k$-os rakodási lehetőség nem lehetséges.

Alex gyűlöli az igazságszolgáltatást, ezért azt szeretné, ha két teherautó össztömege közötti maximális abszolút különbség a lehető legnagyobb lenne. Ha csak egy teherautó van, akkor ez az érték $0$.

Alexnek elég sok kapcsolata van, így minden 1 $ \leq k \leq n$ után talál egy olyan céget, amelynek minden teherautójában pontosan $k$ dobozok férnek el. Nyomtassa ki bármely két teherautó össztömege közötti maximális abszolút különbséget.

Bemenet

Az első sor egy egész számot tartalmaz: $t$ ($1 \leq t \leq 10^4$) – a tesztesetek száma.

Minden teszteset első sora egy egész számot tartalmaz $n$ ($1 \leq n \leq 150\,000$) – a dobozok számát.

A második sor $n$ egész számot tartalmaz: $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – a dobozok súlyát.

Garantáltan az összes tesztesetre vonatkozó $n$ összeg nem haladja meg a 150\,000$-t.

Kimenet

Minden tesztesethez nyomtasson ki egyetlen egész számot – a választ a problémára. 1. mintabevitel:
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

Minta kimenet 1:

1
9
0
189114
112141

Jegyzet

Az első esetben két kamiont válasszunk, így az elsőben csak az első, a másodikban csak a második doboz lesz.

A második esetben hat kamiont válasszunk, így a maximum 10$ lesz, a minimum 1$, a válasz pedig 10$ - 1 = 9$.

A harmadik esetben minden lehetséges $k$ esetén a teherautók dobozainak össztömege megegyezik, így a válasz $0$.

Alex részt vesz a BrMeast újabb videójának forgatásán, a BrMeast pedig felkérte Alexet, hogy készítsen elő 250 ezer tonna TNT-t, de Alex nem hallotta jól, ezért $n$-os dobozokat készített elő, és sorba rendezte a kamionokra várva. A bal oldali $i$-edik doboz $a_i$ tonnát nyom.

Az összes teherautó, amelyet Alex használni fog, ugyanannyi dobozt tartalmaz, amelyet $k$ jelöl. A betöltés a következőképpen történik:

- Az első $k$ doboz az első kamionhoz kerül,
- A második $k$ doboz a második kamionhoz kerül,
- $\dotsb$
- Az utolsó $k$ doboz a $\frac{n}{k}$-edik teherautóra kerül. A rakodás befejeztével minden teherautón pontosan $k$ doboznak kell lennie. Vagyis ha egy ponton nem lehet pontosan $k$ dobozt berakni a teherautóba, akkor azzal a $k$-os rakodási lehetőség nem lehetséges.

Alex gyűlöli az igazságszolgáltatást, ezért azt szeretné, ha két teherautó össztömege közötti maximális abszolút különbség a lehető legnagyobb lenne. Ha csak egy teherautó van, ez az érték 0 USD.

Alexnek elég sok kapcsolata van, így minden 1 $ \leq k \leq n$ után talál egy olyan céget, amelynek minden teherautójában pontosan $k$ dobozok férnek el. Nyomtassa ki bármely két teherautó össztömege közötti maximális abszolút különbséget.

Bemenet

Az első sor egy egész számot tartalmaz: $t$ ($1 \leq t \leq 10^4$) – a tesztesetek száma.

Minden teszteset első sora egy egész számot tartalmaz $n$ ($1 \leq n \leq 150\,000$) – a dobozok számát.

A második sor $n$ egész számot tartalmaz: $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – a dobozok súlyát.

Garantáltan az összes tesztesetre vonatkozó $n$ összeg nem haladja meg a 150\,000$-t.

Kimenet

Minden tesztesethez nyomtasson ki egyetlen egész számot – a választ a problémára. 1. mintabevitel:
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

1. minta kimenet:

1
9
0
189114
112141

Jegyzet

Az első esetben két kamiont válasszunk, így az elsőben csak az első, a másodikban csak a második doboz lesz.

A második esetben hat kamiont válasszunk, így a maximum 10$ lesz, a minimum 1$, a válasz pedig 10$ - 1 = 9$.

A harmadik esetben minden lehetséges $k$ esetén a teherautók dobozainak össztömege megegyezik, így a válasz $0$.

Alex részt vesz a BrMeast egy másik videójának forgatásában, és BrMeast megkérte Alexet, hogy készítsen 250 ezer tonna TNT-t, de Alex nem hallotta jól, ezért $n$ dobozokat készített, és egymás után rendezte őket teherautókra várva. A bal oldali $i$-th doboz súlya $a_i$ tonna.

Minden teherautó, amelyet Alex használni fog, ugyanannyi dobozt tartalmaz, amelyet $k$ jelöl. A betöltés a következő módon történik:

- Az első $k$ dobozok az első teherautóhoz kerülnek,
- A második $k$ dobozok a második teherautóhoz kerülnek,
- $\dotsb$
- Az utolsó $k$ dobozok a $\frac{n}{k}$-th teherautóhoz kerülnek. A betöltés befejezése után minden teherautónak pontosan $k$ dobozzal kell rendelkeznie. Más szóval, ha egy bizonyos ponton nem lehet pontosan $k$ dobozokat betölteni a teherautóba, akkor a betöltési lehetőség ezzel a $k $ -val nem lehetséges.

Alex utálja az igazságot, ezért azt akarja, hogy a lehető legnagyobb abszolút különbség legyen két teherautó össztömege között. Ha csak egy teherautó van, ez az érték $0$.

Alexnek elég sok kapcsolata van, így minden $1 \leq k \leq n$ után talál egy olyan céget, amelynek minden teherautója pontosan $k$ dobozokat tud befogadni. Nyomtassa ki bármely két teherautó össztömege közötti maximális abszolút különbséget.

Bemenet

Az első sor egy egész számot tartalmaz $t$ ($1 \leq t \leq 10^4$) — a tesztesetek számát.

Minden teszteset első sora egy egész számot tartalmaz $n$ ($1 \leq n \leq 150\,000$) — a dobozok számát.

A második sor $n$ egész számokat tartalmaz $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — a dobozok súlyát.

Garantált, hogy az $n$ összege az összes tesztesetben nem haladja meg a $150\,000$-t.

Kimenet

Minden tesztesethez nyomtasson egyetlen egész számot – ez a válasz a problémára. 1. minta bemenet:
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

1. minta kimenet:

1
9
0
189114
112141

Jegyzet

Az első esetben két teherautót kell választanunk, így az elsőnek csak az első doboza lesz, a másodiknak pedig csak a második doboza.

A második esetben hat teherautót kell választanunk, így a maximum $10$ lesz, a minimum $1$, és a válasz $10 - 1 = 9$.

A harmadik esetben minden lehetséges $k$ esetén a teherautók teljes súlya megegyezik a dobozok össztömegével, így a válasz $0$.


Egy részhalmaz egy tömb folyamatos része.

Yarik nemrég talált egy $n$ elemű tömböt $a$, és elkezdte érdekelni a nem üres részhalmazok maximális összege. Yarik azonban nem szereti azonos paritású egymás utáni egész számokat, ezért az általa választott részhalmaznak váltakozó paritású szomszédos elemeket kell tartalmaznia.

Például $[1, 2, 3]$ elfogadható, de $[1, 2, 4]$ nem az, mivel $2$ és $4$ mindkettő páros és szomszédos.

Segítened kell Yarika-nak, hogy megtalálja az ilyen részhalmaz maximális összegét.

Bemenet

Az első sor tartalmaz egy egész számot $t$ $(1 \le t \le 10^4)$ — a tesztesetek számát. Minden tesztesetet a következők írnak le.

Minden teszteset első sora tartalmaz egy egész számot $n$ $(1 \le n \le 2 \cdot 10^5)$ — a tömb hossza.

A második sor minden tesztesethez tartalmaz $n$ egész számot $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — a tömb elemei.

Garantált, hogy az összes teszteset $n$ összege nem haladja meg a $2 \cdot 10^5$-t.

Kimenet

Minden tesztesethez írj ki egy egész számot — a feladat megoldásának eredményét. Bemeneti minta 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

Kimeneti minta 1:

15
17
8
4
-1000
101
10

Az altömb a tömb egy folytonos része.

Yarik nemrégiben talált egy $a$ típusú, $n$ elemű tömböt, és nagyon érdekelte, hogy megkeresse egy nem üres altömb maximális összegét. Yarik azonban nem szereti az egymás után következő, azonos paritású egész számokat, ezért az általa választott altömbnek váltakozó paritásúnak kell lennie a szomszédos elemeknek.

Például a $[1, 2, 3]$ elfogadható, de a $[1, 2, 4]$ nem, mivel $2$ és $4$ páros és szomszédos.

Segítened kell Yariknak azzal, hogy megtalálod egy ilyen résztömb maximális összegét.

Bemenet

Az első sorban egy egész $t$ $(1 \le t \le 10^4)$ - a tesztesetek száma - szerepel. Minden egyes teszteset a következőképpen van leírva.

Minden teszteset első sora tartalmaz egy egész számot $n$ $(1 \le n \le 2 \cdot 10^5)$ - a tömb hossza.

Minden teszteset második sora $n$ egész $a_1, a_2, \dot, a_n$ $(-10^3 \le a_i \le 10^3)$ - a tömb elemeit tartalmazza.

Garantált, hogy az összes teszteset $n$ összege nem haladja meg a $2 \cdot 10^5$ értéket.

Kimenet

Minden egyes tesztesethez egyetlen egész számot ad ki - a feladat megoldását.Minta bemenet 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

Minta kimenet 1:

15
17
8
4
-1000
101
10

Az altömb a tömb folytonos része.

Yarik nemrég talált egy $n$ elemű $a$ tömböt, és nagyon érdeklődött egy nem üres altömb maximális összegének megtalálása iránt. Yarik azonban nem szereti az azonos paritású, egymást követő egész számokat, ezért az általa választott altömbnek váltakozó paritásokkal kell rendelkeznie a szomszédos elemekhez.

Például a $[1, 2, 3]$ elfogadható, de a $[1, 2, 4]$ nem, mivel a $2$ és a 4$ páros és szomszédos.

Segítened kell Yariknak egy ilyen alcsoport maximális összegének megtalálásával.

Bemenet

Az első sor egy egész számot tartalmaz: $t$ $(1 \le t \le 10^4)$ — a tesztesetek száma. Az egyes tesztesetek leírása az alábbiak szerint történik.

Minden teszteset első sora egy $n$ $(1 \le n \le 2 \cdot 10^5)$ egész számot tartalmaz – a tömb hossza.

Minden teszteset második sora $n$ egész számot tartalmaz: $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — a tömb elemei.

Garantáltan az összes tesztesetre vonatkozó $n$ összeg nem haladja meg a $2 \cdot 10^5$-t.

Kimenet

Minden tesztesethez adjon ki egyetlen egész számot – a választ a problémára. 1. mintabemenet:
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. minta kimenet:

15
17
8
4
-1000
101
10


Yarik sokféle zene nagy rajongója. De Yarik nemcsak hallgatni, hanem írni is szeret zenét. Leginkább az elektronikus zenét szereti, ezért létrehozta saját kottarendszerét, amely szerinte a legjobb erre a célra.

Mivel Yarik az informatikát is szereti, az ő rendszerében a hangjegyeket $2^k$ egész számokkal jelöli, ahol $k \ge 1$ - egy pozitív egész szám. De mint tudjuk, nem lehet csak hangjegyekkel zenét írni, ezért Yarik két hangjegy kombinációit használja. Két hang $(a, b)$ kombinációját, ahol $a = 2^k$ és $b = 2^l$, az $a^b$ egész számmal jelöli.

Például, ha $a = 8 = 2^3$, $b = 4 = 2^2$, akkor a $(a, b)$ kombinációt a $a^b = 8^4 = 4096$ egész számmal jelöli. Megjegyezzük, hogy különböző kombinációkat ugyanazzal a jelöléssel is jelölhetünk, például a $(64, 2)$ kombinációt a $4096 = 64^2$ egész számmal is jelölhetjük.

Yarik már kiválasztott $n$ hangjegyet, amelyet az új dallamában fel akar használni. Mivel azonban ezek egész számai nagyon nagyok lehetnek, ezért egy $n$ hosszúságú $a$ tömbként írta le őket, ekkor a $i$ hangjegy $b_i = 2^{a_i}$. Az $a$ tömbben lévő egész számok megismételhetők.

A dallam két hang többféle kombinációjából fog állni. Yarik arra volt kíváncsi, hogy hány olyan $b_i, b_j$ $(i < j)$ hangpár létezik, hogy a $(b_i, b_j)$ kombináció megegyezik a $(b_j, b_i)$ kombinációval. Más szóval, meg akarja számolni azon $(i, j)$ $(i < j)$ párok számát, amelyeknél $b_i^{b_j} = b_j^{b_i}$. Segíts neki megtalálni az ilyen párok számát.

Bemenet

A bemenet első sora egy egész számot tartalmaz $t$ ($1 \le t \le 10^4$) - a tesztesetek számát.

Minden egyes teszteset első sora egy egész számot tartalmaz $n$ ($1 \leq n \leq 2 \cdot 10^5$) - a tömbök hossza.

A következő sor $n$ egész számot tartalmaz $a_1, a_2, \dot, a_n$ ($1 \leq a_i \leq 10^9$) - az $a$ tömb.

Garantált, hogy az $n$ összege az összes tesztesetben nem haladja meg a $2 \cdot 10^5$ értéket.

Kimenet

Minden egyes tesztesethez adja ki a megadott feltételnek megfelelő párok számát.Minta 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

1. minta kimenet:

0
2
1
3
19

Yarik sokféle zene nagy rajongója. De Yarik nemcsak zenét hallgat, hanem írni is szeret. Leginkább az elektronikus zenét szereti, ezért saját hangjegyrendszert alakított ki, ami szerinte a legjobban illik hozzá.

Mivel Yarik is szereti az informatikát, rendszerében a jegyzeteket $2^k$ egész számok jelölik, ahol $k \ge 1$ – pozitív egész szám. De, mint tudod, nem használhatsz pusztán hangjegyeket zeneíráshoz, ezért Yarik két hang kombinációját használja. Két $(a, b)$ hang kombinációját, ahol $a = 2^k$ és $b = 2^l$, az $a^b$ egész számmal jelöli.

Például, ha $a = 8 = 2^3$, $b = 4 = 2^2$, akkor a $(a, b)$ kombinációt a $a^b = 8^4 = 4096$ egész szám jelöli. . Érdemes megjegyezni, hogy különböző kombinációk ugyanazt a jelölést is megkaphatják, például a $(64, 2)$ kombinációt is a $4096 = 64^2$ egész számmal jelöljük.

Yarik már kiválasztott $n$ hangokat, amelyeket használni szeretne az új dallamában. Mivel azonban egész számuk nagyon nagy is lehet, felírta őket $n$ hosszúságú $a$ tömbként, így a $i$ jegyzet $b_i = 2^{a_i}$. Az $a$ tömbben lévő egész számok megismételhetők.

A dallam két hang több kombinációjából áll majd. Yarik arra volt kíváncsi, hány $b_i, b_j$ $(i < j)$ hangpár létezik úgy, hogy a $(b_i, b_j)$ kombináció egyenlő a $(b_j, b_i)$ kombinációval. Más szóval, meg akarja számolni a $(i, j)$ $(i < j)$ párok számát úgy, hogy $b_i^{b_j} = b_j^{b_i}$. Segíts neki megtalálni az ilyen párok számát.

Bemenet

A bemenet első sora egy egész számot tartalmaz: $t$ ($1 \le t \le 10^4$) – a tesztesetek számát.

Minden teszteset első sora egy egész számot tartalmaz $n$ ($1 \leq n \leq 2 \cdot 10^5$) – a tömbök hosszát.

A következő sor $n$ egész számot tartalmaz: $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – $a$ tömb.

Garantáltan az összes tesztesetre vetített $n$ összeg nem haladja meg a $2 \cdot 10^5$-t.

Kimenet

Minden tesztesethez adja ki az adott feltételnek megfelelő párok számát. 1. minta bemenet:
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. minta kimenet:

0
2
1
3
19

Yarik sokféle zene nagy rajongója. De Yarik nemcsak zenét hallgat, hanem írni is szeret. Leginkább az elektronikus zenét szereti, ezért saját hangjegyrendszert alakított ki, amely szerinte a legjobban illik hozzá.

Mivel Yarik is szereti az informatikát, rendszerében a jegyzeteket $2^k$ egész számok jelölik, ahol $k \ge 1$ – pozitív egész szám. De, mint tudod, nem használhatsz pusztán hangjegyeket zeneíráshoz, ezért Yarik két hang kombinációját használja. Két $(a, b)$ hang kombinációját, ahol $a = 2^k$ és $b = 2^l$, az $a^b$ egész számmal jelöli.

Például, ha $a = 8 = 2^3$, $b = 4 = 2^2$, akkor a $(a, b)$ kombinációt a $a^b = 8^4 = 4096$ egész szám jelöli. . Vegye figyelembe, hogy a különböző kombinációknak ugyanaz a jelölése lehet, például a $(64, 2)$ kombinációt is a $4096 = 64^2$ egész számmal jelöljük.

Yarik már kiválasztott $n$ hangokat, amelyeket használni szeretne az új dallamában. Mivel azonban egész számuk nagyon nagy is lehet, felírta őket $n$ hosszúságú $a$ tömbként, így a $i$ jegyzet $b_i = 2^{a_i}$. Az $a$ tömbben lévő egész számok megismételhetők.

A dallam két hang több kombinációjából áll majd. Yarik arra volt kíváncsi, hány $b_i, b_j$ $(i < j)$ hangpár létezik úgy, hogy a $(b_i, b_j)$ kombináció egyenlő a $(b_j, b_i)$ kombinációval. Más szóval, meg akarja számolni a $(i, j)$ $(i < j)$ párok számát úgy, hogy $b_i^{b_j} = b_j^{b_i}$. Segíts neki megtalálni az ilyen párok számát.

Bemenet

A bemenet első sora egy egész számot tartalmaz: $t$ ($1 \le t \le 10^4$) – a tesztesetek számát.

Minden teszteset első sora egy egész számot tartalmaz $n$ ($1 \leq n \leq 2 \cdot 10^5$) – a tömbök hosszát.

A következő sor $n$ egész számot tartalmaz: $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – $a$ tömb.

Garantáltan az összes tesztesetre vetített $n$ összeg nem haladja meg a $2 \cdot 10^5$-t.

Kimenet

Minden tesztesethez adja ki az adott feltételnek megfelelő párok számát. 1. minta bemenet:
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

Minta kimenet 1:

0
2
1
3
19


Egy 0-indexelt karakterlánc-részletet kap. A részletek minden eleme egy 15-ös hosszúságú karakterláncba tömörítve ad információt egy adott utasról. A rendszer olyan, hogy:

Az első tíz karakter az utasok telefonszámát tartalmazza.
A következő karakter a személy nemét jelöli.
A következő két karakter a személy életkorának jelzésére szolgál.
Az utolsó két karakter határozza meg az adott személy számára kiosztott helyet.

Adja meg a szigorúan 60 évnél idősebb utasok számát.

Példa 1:

Bevitel: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Kimenet: 2
Magyarázat: A 0, 1 és 2 indexű utasok 75, 92 és 40 évesek. Így 2 személy van 60 év felett.

Példa 2:

Bevitel: details = ["1313579440F2036","2921522980M5644"]
Kimenet: 0
Magyarázat: Egyik utas sem idősebb 60 évnél.

Korlátozások:

1 <= details.length <= 100
details[i].length == 15
details[i] számjegyeket tartalmaz '0'-tól '9'-ig.
details[i][10] lehet 'M', 'F' vagy 'O'.
Az utasok telefonszáma és ülésszáma különbözik.

Egy 0-indexelt karakterlánc-részletet kap. A részletek minden eleme egy 15-ös hosszúságú karakterláncba tömörítve ad információt az adott utasról. A rendszer olyan, hogy:

Az első tíz karakter az utasok telefonszámát tartalmazza.
A következő karakter a személy nemét jelöli.
A következő két karakter a személy életkorának jelzésére szolgál.
Az utolsó két karakter határozza meg az adott személy számára kiosztott helyet.

Adja meg a szigorúan 60 évnél idősebb utasok számát.

1. példa:

Bevitel: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Kimenet: 2
Magyarázat: A 0, 1 és 2 indexű utasok 75, 92 és 40 évesek. Így 2 fő 60 év feletti.

2. példa:

Bevitel: details = ["1313579440F2036","2921522980M5644"]
Kimenet: 0
Magyarázat: Egyik utas sem idősebb 60 évnél.

Korlátozások:

1 <= details.length <= 100
details[i].length == 15
details[i] „0” és „9” közötti számjegyekből áll.
details[i][10] vagy "M" vagy "F" vagy "O".
Az utasok telefonszáma és ülésszáma különbözik.

A sztringek részleteinek 0 indexelt tömbjét kapja meg. A részletek minden eleme információt nyújt egy adott utasról, 15 hosszúságú karakterláncba tömörítve. A rendszer olyan, hogy:

Az első tíz karakter az utasok telefonszámából áll.
A következő karakter a személy nemét jelöli.
A következő két karakter a személy életkorának jelzésére szolgál.
Az utolsó két karakter határozza meg az adott személynek kiosztott helyet.

Adja vissza a szigorúan 60 évesnél idősebb utasok számát.

1. példa:

Bemenet: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Kimenet: 2
Magyarázat: A 0., 1. és 2. indexen szereplő utasok 75, 92 és 40 évesek. Így 2 ember van, akik 60 év felettiek.

2. példa:

Bemenet: details = ["1313579440F2036","2921522980M5644"]
Kimenet: 0
Magyarázat: Az utasok egyike sem idősebb 60 évesnél.

Korlátok:

1 <= details.length <= 100
details[i].length == 15
details[i] "0"-tól "9"-ig terjedő számjegyekből állnak.
details[i][10] vagy "M" vagy "F" vagy "O".
Az utasok telefonszáma és ülésszáma eltérő.


Adott egy 0-indexált 2D-s egész számtömb nums. Kezdetben a pontszámod 0. Végezd el a következő műveleteket, amíg a mátrix ki nem ürül:

A mátrix minden sorából válassza ki a legnagyobb számot, és távolítsa el. Döntetlen esetén nem számít, hogy melyik számot választjuk.
Határozza meg az 1. lépésben eltávolított számok közül a legnagyobbat. Ezt a számot add hozzá a pontszámodhoz.

Adja vissza a végső pontszámot.

Példa 1:

Bemenet: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Kimenet: 15
Magyarázat: Az első műveletben eltávolítjuk a 7, 6, 6 és 3 számokat. Ezután hozzáadjuk a 7-et a pontszámunkhoz. Ezután eltávolítjuk a 2, 4, 5 és 2 értékeket. A pontszámunkhoz hozzáadjuk az 5-öt. Végül eltávolítjuk az 1, 2, 3 és 1 értékeket. 3 értéket adunk hozzá a pontszámunkhoz. Így a végső pontszámunk 7 + 5 + 3 = 15.

Példa 2:

Bemenet: nums = [[1]]
Kimenet: 1
Magyarázat: A válaszhoz hozzáadjuk az 1-et. Visszaadunk 1-et.

Korlátozások:

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

Kapsz egy 0-indexelt 2D egész tömb számokat. Kezdetben az Ön pontszáma 0. Végezze el a következő műveleteket, amíg a mátrix ki nem ürül:

A mátrix minden sorából válassza ki a legnagyobb számot, és távolítsa el. Döntetlen esetén nem mindegy, hogy melyik számot választják.
Határozza meg a legmagasabb számot az 1. lépésben eltávolítottak közül. Adja hozzá ezt a számot a pontszámához.

Adja vissza a végeredményt.

1. példa:

Bemenet: nums  = [[7,2,1], [6,4,2], [6,5,3], [3,2,1]]
Kimenet: 15
Magyarázat: Az első műveletben eltávolítjuk a 7-et, a 6-ot, a 6-ot és a 3-at. Ezután hozzáadunk 7-et a pontszámunkhoz. Ezután eltávolítjuk a 2-t, 4-et, 5-öt és 2-t. 5-öt adunk a pontszámunkhoz. Végül eltávolítjuk az 1-et, 2-t, 3-at és 1-et. Hozzáadunk 3-at a pontszámunkhoz. Így a végső pontszámunk 7 + 5 + 3 = 15.

2. példa:

Bemenet: nums  = [[1]]
Kimenet: 1
Magyarázat: 1-et eltávolítunk, és hozzáadjuk a válaszhoz. Visszatérünk 1.

Korlátozások:

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

Kapsz egy 0-indexelt 2D egész tömb számokat. Kezdetben az Ön pontszáma 0. Végezze el a következő műveleteket, amíg a mátrix ki nem ürül:

A mátrix minden sorából válassza ki a legnagyobb számot, és távolítsa el. Döntetlen esetén nem mindegy, hogy melyik számot választják.
Határozza meg a legmagasabb számot az 1. lépésben eltávolítottak közül. Adja hozzá ezt a számot a pontszámához.

Adja vissza a végeredményt.

Példa 1:

Bemenet: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Kimenet: 15
Magyarázat: Az első műveletben eltávolítjuk a 7-et, 6-ot, 6-ot és 3-at. Ezután hozzáadunk 7-et a pontszámunkhoz. Ezután eltávolítjuk a 2-t, 4-et, 5-öt és 2-t. 5-öt adunk a pontszámunkhoz. Végül eltávolítjuk az 1-et, 2-t, 3-at és 1-et. Hozzáadunk 3-at a pontszámunkhoz. Így a végső pontszámunk 7 + 5 + 3 = 15.

Példa 2:

Bemenet: nums = [[1]]
Kimenet: 1
Magyarázat: 1-et eltávolítunk, és hozzáadjuk a válaszhoz. Visszatérünk 1.

Korlátozások:

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


Egy 0-indexelt egész tömböt kapunk, amelyek n hosszúságúak és egy k egész számot. Egy műveletben kiválaszthat egy elemet, és megszorozhatja 2-vel.
A számok maximális lehetséges értékét adja vissza[0] | számok[1] | ... | számok[n - 1], amelyeket a számokra vonatkozó művelet legfeljebb k alkalommal történő alkalmazása után kaphatunk.
Vegye figyelembe, hogy a | b jelöli a bitenkénti vagy két a és b közötti egész számot.

1. példa:

Bemenet: nums= [12,9], k = 1
Kimenet: 30
Magyarázat: Ha a műveletet az 1-es indexre alkalmazzuk, az új tömbszámunk [12,18] lesz. Így a 12 és 18 bitenkénti vagy bitenkénti értékét adjuk vissza, ami 30.

2. példa:

Bemenet: nums = [8,1,2], k = 2
Kimenet: 35
Magyarázat: Ha a műveletet kétszer alkalmazzuk a 0 indexre, akkor egy új [32,1,2] tömböt kapunk. Így a 32|1|2 = 35 értéket adjuk vissza.

Korlátozások:

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

Kapsz egy 0 indexelt egész tömb n hosszúságú számát és egy k egész számát. Egy műveletben kiválaszthat egy elemet, és megszorozhatja 2-vel.
Adja vissza a nums[0] | nums[1] | ... | nums[n - 1] lehetséges legnagyobb értékét, amelyet a művelet legfeljebb k alkalommal történő alkalmazása után érhet el. amely a művelet legfeljebb k alkalommal történő alkalmazása után érhető el.
Vegye figyelembe, hogy a | b a két egész szám, a és b, bitenkénti vagy művelete.

1. példa:

Bemenet: nums = [12,9], k = 1
Kimenet: 30
Magyarázat: Ha a műveletet az 1-es indexre alkalmazzuk, az új tömbszámunk [12,18] lesz. Így visszaadjuk a bitenkénti vagy 12-es és 18-as értéket, ami 30.

2. példa:

Bemenet: nums = [8,1,2], k = 2
Kimenet: 35
Magyarázat: Ha a műveletet kétszer alkalmazzuk a 0 indexre, akkor egy új tömböt kapunk [32,1,2]. Így 32|1|2 = 35-öt adunk vissza.

Korlátok:

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

Egy 0-indexelt egész tömb n hosszúságú és egy k egész számot kap. Egy műveletben kiválaszthat egy elemet, és megszorozhatja 2-vel.
A számok maximális lehetséges értékét adja vissza[0] | számok[1] | ... | számok[n - 1], amelyeket a számokra vonatkozó művelet legfeljebb k alkalommal történő alkalmazása után kaphatunk.
Vegye figyelembe, hogy a | b jelöli a bitenkénti vagy két a és b közötti egész számot.

példa 1:

Bemenet: nums = [12,9], k = 1
Kimenet: 30
Magyarázat: Ha a műveletet az 1-es indexre alkalmazzuk, az új tömbszámunk [12,18] lesz. Így a 12 és 18 bitenkénti vagy bitenkénti értékét adjuk vissza, ami 30.

példa 2:

Bemenet: nums = [8,1,2], k = 2
Kimenet: 35
Magyarázat: Ha a műveletet kétszer alkalmazzuk a 0 indexre, akkor egy új [32,1,2] tömböt kapunk. Így a 32|1|2 = 35 értéket adjuk vissza.

Korlátozások:

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


Kapsz egy 0-indexelt egész tömb számokat, amelyek a tanulók pontszámát képviselik egy vizsgán. A tanár egy nem üres, maximális erősségű tanulócsoportot szeretne kialakítani, ahol az i_0, i_1, i_2, ... , i_k indexű tanulók csoportjának erősségét nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
A tanár által létrehozható csoport maximális erejét adja vissza.

1. példa:

Bemenet: nums = [3,-1,-5,2,5,-9]
Kimenet: 1350
Magyarázat: A maximális erősségű csoport kialakításának egyik módja a tanulók csoportosítása a [0,2,3,4,5] indexek szerint. Erősségük 3 * (-5) * 2 * 5 * (-9) = 1350, ami optimálisnak mutatkozik.

2. példa:

Bemenet: nums = [-4,-5,-4]
Kimenet: 20
Magyarázat: Csoportosítsa a tanulókat a [0, 1] indexekhez. Ekkor 20-as erősségünk lesz. Ennél nagyobb erőt nem tudunk elérni.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számokat, amelyek a tanulók pontszámát képviselik egy vizsgán. A tanár egy nem üres, maximális erősségű tanulócsoportot szeretne kialakítani, ahol az i_0, i_1, i_2, ... , i_k indexű tanulók csoportjának erősségét nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k] értékként határozzuk meg. * nums[i_2] * ... * nums[i_k].
A tanár által létrehozható csoport maximális erejét adja vissza.

1. példa:

Bemenet: nums = [3,-1,-5,2,5,-9]
Kimenet: 1350
Magyarázat: A maximális erősségű csoport kialakításának egyik módja a tanulók csoportosítása a [0,2,3,4,5] indexek szerint. Erősségük 3 * (-5) * 2 * 5 * (-9) = 1350, ami optimálisnak mutatkozik.

2. példa:

Bemenet: nums = [-4,-5,-4]
Kimenet: 20
Magyarázat: csoportosíthatja a tanulókat a [0, 1] indexekhez. Ekkor 20-as erősségünk lesz. Ennél nagyobb erőt nem tudunk elérni.

Korlátozások:

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

Adott egy 0-indexált egész számtömb nums, amely a vizsgán részt vevő diákok pontszámát jelöli. A tanár egy nem üres, maximális erősségű csoportot szeretne kialakítani a tanulókból, ahol az i_0, i_1, i_2, ... indexű tanulók egy csoportjának erőssége... , i_k a következőképpen definiálható: nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
A tanár által létrehozható csoport maximális erősségét adja vissza.

Példa 1:

Bemenet: nums = [3,-1,-5,2,5,-9]
Kimenet: 1350
Magyarázat: A maximális erősségű csoport kialakításának egyik módja, hogy a [0,2,3,4,5] indexű tanulókat csoportosítjuk. Erősségük 3 * (-5) * 2 * 5 * (-9) = 1350, amiről megmutathatjuk, hogy optimális.

2. példa:

Bemenet: nums = [-4,-5,-4]
Kimenet: 20
Magyarázat: Csoportosítsuk a [0, 1] indexű tanulókat . Ekkor az eredményül kapott erősség 20 lesz. Ennél nagyobb erősséget nem tudunk elérni.

Korlátozások:

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


Egy 0-indexelt s karakterláncot és egy szavakat tartalmazó szótárt kapsz. Fel kell bontanod s-t egy vagy több nem átfedő részkarakterláncra úgy, hogy minden részkarakterlánc szerepeljen a szótárban. Lehet, hogy s-ben van néhány extra karakter, amelyek nem szerepelnek egyik részkarakterláncban sem.
Add vissza az optimális felbontás esetén fennmaradó extra karakterek minimális számát.

1. példa:

Bemenet: s = "leetscode", dictionary = ["leet","code","leetcode"]
Kimenet: 1
Magyarázat: Fel tudjuk bontani s-t két részkarakterláncra: "leet" az index 0-tól 3-ig és "code" az index 5-től 8-ig. Csak 1 fel nem használt karakter van (az index 4-nél), így visszatérünk 1-gyel.

2. példa:

Bemenet: s = "sayhelloworld", dictionary = ["hello","world"]
Kimenet: 3
Magyarázat: Fel tudjuk bontani s-t két részkarakterláncra: "hello" az index 3-tól 7-ig és "world" az index 8-tól 12-ig. Az indexek 0, 1, 2 karakterei nem szerepelnek egyik részkarakterláncban sem, így azokat extra karaktereknek tekintjük. Ezért visszatérünk 3-mal.

Feltételek:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] és s csak kisbetűs angol betűkből áll
dictionary különálló szavakat tartalmaz

Kapsz egy 0 indexű karakterláncot és egy szótár szótárt. Az s-t egy vagy több nem átfedő részkarakterláncra kell bontani úgy, hogy mindegyik részstring szerepeljen a szótárban. Lehetnek olyan extra karakterek az s-ben, amelyek egyik részkarakterláncban sem szerepelnek.
Adja vissza a megmaradt extra karakterek minimális számát, ha optimálisan bontja fel s-t.

Példa 1:

Bemenet: s = "leetscode", dictionary = ["leet","code","leetcode"]
Kimenet: 1
Magyarázat: Az s-t két részkarakterláncban törhetjük meg: "leet" 0-tól 3-ig, és "code" indextől 5-től 8-ig. Csak 1 használaton kívüli karakter van (a 4-es indexnél), ezért 1-et adunk vissza.

Példa 2:

Bemenet: s = "sayhelloworld", dictionary = ["hello","world"]
Kimenet: 3
Magyarázat: Az s-t két részkarakterláncban törhetjük meg: "hello" a 3-tól 7-ig, a "world" pedig a 8-tól 12-ig. A 0, 1, 2 indexű karakterek nem szerepelnek semmilyen részkarakterláncban, ezért extra karaktereknek számítanak. . Ezért visszaadjuk a 3-at.

Korlátozások:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
szótár[i] és s csak kisbetűket tartalmaz angolul
a szótár különálló szavakat tartalmaz

Adott egy 0-indexált s karakterlánc és egy szótár szótár. Az s-t egy vagy több nem átfedő részsztringre kell bontani úgy, hogy minden részsztring szerepeljen a szótárban. Az s-ben lehet néhány olyan extra karakter, amely egyik részláncban sem szerepel.
Az optimális s felbontás esetén a minimálisan megmaradó extra karakterek számát adja vissza.

Példa 1:

Bemenet: s = "leetscode", dictionary = ["leet","code","leetcode"]
Kimenet: 1
Magyarázat: Az s-t két részláncra bonthatjuk: „leet” a 0-tól 3-ig terjedő indexig és »code« az 5-től 8-ig terjedő indexig. Csak 1 nem használt karakter van (a 4-es indexen), ezért 1-et adunk vissza.

Példa 2:

Bemenet: s = "sayhelloworld", dictionary = ["hello","world"]
Kimenet: 3
Magyarázat: Az s-t két részsztringre bonthatjuk: "hello" a 3-tól 7-ig és "world" a 8-tól 12-ig. A 0, 1, 2 indexben lévő karakterek nem használatosak egyetlen részkarakterláncban sem, így extra karaktereknek számítanak. Ezért visszatérünk 3.

Korlátozások:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] és s csak kisbetűs angol betűkből áll.
a szótár különböző szavakat tartalmaz


Kap egy egész számokból álló tömböt, amely tartalmazza a különböző csokoládék árait, amelyek a különböző csokoládék árait képviselik egy boltban. Egyetlen egész számot is kapsz, amely a kezdeti pénzösszeget jelenti.
Pontosan két csokoládét kell vásárolnia oly módon, hogy még mindig legyen némi nem negatív maradék pénze. Szeretné minimalizálni a megvásárolt két csokoládé árának összegét.
Adjon vissza azt a pénzösszeget, amely a két csokoládé megvásárlása után megmarad. Ha nincs mód arra, hogy két csokoládét vásároljon anélkül, hogy adósságba kerülne, adja vissza a pénzt. Ne feledje, hogy a maradéknak nem negatívnak kell lennie.

1. példa:

Bemenet: prices = [1,2,2], money = 3
Kimenet: 0
Magyarázat: Vásárolja meg a csokoládékat 1, illetve 2 egységért. Utána 3 - 3 = 0 pénzegységek maradnak lesz. Így 0-t adunk vissza.

2. példa:

Input: árak = [3,2,3], pénz = 3
Kimenet: 3
Magyarázat: Nem tud 2 csokoládét vásárolni anélkül, hogy adósságba kerüljen, ezért 3-at visszaküldünk.

Korlátok:

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

Egy egész tömböt kapsz az árakról, amelyek a különféle csokoládék árait reprezentálják az üzletben. Egyetlen egész pénzt is kapsz, ami a kezdeti pénzösszegedet jelenti.
Pontosan két csokoládét kell vásárolnod úgy, hogy még maradjon egy kis nem negatív pénzmaradvány. Szeretné minimalizálni a megvásárolt két csokoládé árának összegét.
Add vissza a két csokoládé megvásárlása után megmaradt pénzösszeget. Ha nincs mód arra, hogy két csokoládét vegyen anélkül, hogy eladósodna, adjon vissza pénzt. Vegye figyelembe, hogy a maradék nem lehet negatív.

1. példa:

Bemenet: prices = [1,2,2], money = 3
Kimenet: 0
Magyarázat: Vásárolja meg a csokoládékat 1, illetve 2 egység áron. Utána 3-3 = 0 egységnyi pénzed lesz. Így 0-t adunk vissza.

2. példa:

Input: prices = [3,2,3], money = 3
Kimenet: 3
Magyarázat: Nem vásárolhatsz 2 csokoládét anélkül, hogy eladósodna, ezért 3-at visszaküldünk.

Korlátozások:

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

Kap egy egész tömb árakat, amelyek a különböző csokoládék árait képviselik egy boltban. Egyetlen egész számot is kapsz, amely a kezdeti pénzösszeget jelenti.
Pontosan két csokoládét kell vásárolnia oly módon, hogy még mindig legyen némi nem negatív maradék pénze. Szeretné minimalizálni a megvásárolt két csokoládé árának összegét.
Fizesse vissza azt a pénzösszeget, amely a két csokoládé megvásárlása után megmarad. Ha nincs mód arra, hogy két csokoládét vásároljon anélkül, hogy adósságba kerülne, adja vissza a pénzt. Ne feledje, hogy a maradéknak nem negatívnak kell lennie.

1. példa:

Ráfordítás: prices = [1,2,2], money = 3
Kimenet: 0
Magyarázat: Vásárolja meg a csokoládékat 1, illetve 2 egységért. Utána 3 - 3 = 0 pénzegységed lesz. Így 0-t adunk vissza.

2. példa:

Input: prices = [3,2,3], money = 3
Kimenet: 3
Magyarázat: Nem vásárolhat 2 csokoládét adósság nélkül, ezért 3-at visszaküldünk.

Korlátok:

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


Adott két numerikus karakterlánc num1 és num2, valamint két egész szám max_sum és min_sum. Egy egész számot x akkor jelölünk jónak, ha:

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

Adjuk vissza a jó egész számok számát. Mivel a válasz nagy lehet, adjuk vissza modulo 10^9 + 7.
Vegyük észre, hogy digit_sum(x) az x számjegyeinek összegét jelöli.

1. példa:

Bemenet: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Kimenet: 11
Magyarázat: Van 11 olyan egész szám, amelyek számjegyeinek összege 1 és 8 között van: 1,2,3,4,5,6,7,8,10,11 és 12. Így tehát 11-et adunk vissza.

2. példa:

Bemenet: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Kimenet: 5
Magyarázat: Az 5 egész szám, amelyek számjegyeinek összege 1 és 5 között van: 1,2,3,4 és 5. Így tehát 5-t adunk vissza.

Korlátozások:

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

Két numerikus sztringet kapsz: num1 és num2, valamint két max_sum és min_sum egész számot. Egy x egész számot jelölünk jónak, ha:

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

Adja vissza a jó egész számok számát. Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
Vegye figyelembe, hogy a digit_sum(x) az x számjegyeinek összegét jelöli.

1. példa:

Bemenet: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Kimenet: 11
Magyarázat: 11 egész szám van, amelyek 1 és 8 közötti számjegyeinek összege 1,2,3,4,5,6,7,8,10,11 és 12. Így 11-et adunk vissza.

2. példa:

Bemenet: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Kimenet: 5
Magyarázat: Az 5 egész szám, amelyek számjegyeinek összege 1 és 5 között van, 1,2,3,4 és 5. Így 5-öt adunk vissza.

Korlátozások:

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

Két numerikus sztringet kapsz: num1 és num2, valamint két max_sum és min_sum egész számot. Egy x egész számot jelölünk jónak, ha:

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

Adja vissza a jó egész számok számát. Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
Vegye figyelembe, hogy a digit_sum(x) az x számjegyeinek összegét jelöli.

Példa 1:

Bemenet: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Kimenet: 11
Magyarázat: 11 egész szám van, amelyek 1 és 8 közötti számjegyeinek összege 1,2,3,4,5,6,7,8,10,11 és 12. Így 11-et adunk vissza.

Példa 2:

Bemenet: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Kimenet: 5
Magyarázat: Az 5 egész szám, amelyek számjegyeinek összege 1 és 5 között van, 1,2,3,4 és 5. Így 5-öt adunk vissza.

Korlátozások:

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


Kapunk egy 0-indexelt tömb számokat, amelyek n hosszúak.
A számok megkülönböztetett különbségi tömbje egy n hosszúságú diff tömb, így a diff[i] egyenlő a nums[i + 1, ..., n - 1] utótag különböző elemeinek számával, levonva a különböző elemek számából. elemek a nums[0, ..., i] előtagban.
Visszaadja a számok különálló különbségi tömbjét.
Figyeljük meg, hogy a számok[i, ..., j] a számok azon altömbjét jelöli, amelyek az i indextől kezdődnek, és a j indexre végződnek. Különösen, ha i > j, akkor a nums[i, ..., j] üres altömböt jelöl.

1. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: [-3,-1,1,3,5]
Magyarázat: Az i = 0 index esetén 1 elem van az előtagban és 4 különálló elem az utótagban. Így diff[0] = 1 - 4 = -3.
Az i = 1 index esetén 2 különálló elem van az előtagban és 3 különböző elem az utótagban. Így diff[1] = 2 - 3 = -1.
Az i = 2 index esetén 3 különálló elem van az előtagban és 2 különálló elem az utótagban. Így diff[2] = 3 - 2 = 1.
Az i = 3 index esetén 4 különálló elem van az előtagban és 1 különálló elem az utótagban. Így diff[3] = 4 - 1 = 3.
Az i = 4 index esetén 5 különálló elem van az előtagban, és nincs elem az utótagban. Így diff[4] = 5 - 0 = 5.

2. példa:

Bemenet: nums = [3,2,3,4,2]
Kimenet: [-2,-1,0,2,3]
Magyarázat: Az i = 0 index esetén 1 elem van az előtagban és 3 különálló elem az utótagban. Így diff[0] = 1 - 3 = -2.
Az i = 1 index esetén 2 különálló elem van az előtagban és 3 különböző elem az utótagban. Így diff[1] = 2 - 3 = -1.
Az i = 2 index esetén 2 különálló elem van az előtagban és 2 különböző elem az utótagban. Így diff[2] = 2 - 2 = 0.
Az i = 3 index esetén 3 különálló elem van az előtagban és 1 különálló elem az utótagban. Így diff[3] = 3 - 1 = 2.
Az i = 4 index esetén 3 különálló elem van az előtagban, és nincs elem az utótagban. Így diff[4] = 3 - 0 = 3.

Korlátozások:

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

Adott egy 0-indexelt nums nevű tömb, amelynek hossza n.
A számok különbségtömbje egy n hosszúságú tömbdiff úgy, hogy a diff[i] egyenlő a nums[i + 1, ..., n - 1] utótagKülönböző elemeinek számával, kivonva a nums[0, ..., i] előtag Különböző elemeinek számából.
Adja vissza a nums tömb különböző különbségtömbjét.
Jegyezzük meg hogy a nums[i, ..., j] az i indextől kezdődő és j indexig záródó számok résztömbjét jelöli. Különösen, ha i > j, akkor a nums[i, ..., j] üres résztömböt jelöl.

1. példa:

Bemenet: nums = [1,2,3,4,5]
kimenet: [-3,-1,1,3,5]
Magyarázat: Az i = 0 index esetén 1 elem van az előtagban és 4Különböző elem az utótagban. Így diff[0] = 1 - 4 = -3.
Az i = 1 index esetén az előtagban 2 Különböző elem van, az utótagban pedig 3 különböző elem. Így diff[1] = 2 - 3 = -1.
Az i = 2 index esetén az előtagban 3 Különböző elem van, az utótagban pedig 2 Különböző elem. Így diff[2] = 3 - 2 = 1.
Az i = 3 index esetén az előtagban 4Különböző elem van, az utótagban pedig 1 Különböző elem. Így diff[3] = 4 - 1 = 3.
Az i = 4 index esetén az előtagban 5Különböző elem van, az utótagban pedig nincs elem. Így diff[4] = 5 - 0 = 5.

2. példa:

Bemenet: nums = [3,2,3,4,2]
kimenet: [-2,-1,0,2,3]
Magyarázat: Az i = 0 index esetén az előtagban 1 elem, az utótagban pedig 3 különálló elem található. Így diff[0] = 1 - 3 = -2.
Az i = 1 index esetén az előtagban 2 különálló elem van, az utótagban pedig 3 különböző elem. Így diff[1] = 2 - 3 = -1.
Az i = 2 index esetén az előtagban 2 különálló elem van, az utótagban pedig 2 különálló elem. Így diff[2] = 2 - 2 = 0.
Az i = 3 index esetén az előtagban 3 különálló elem van, az utótagban pedig 1 különálló elem. Így diff[3] = 3 - 1 = 2.
Az i = 4 index esetén az előtagban 3 különálló elem van, az utótagban pedig nincsenek. Így diff[4] = 3 - 0 = 3.

Korlátok:

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


Van egy 0-indexált n hosszúságú nums tömb. Kezdetben minden elem színtelen (értéke 0).
Adott egy 2D-s egész számtömb lekérdezések, ahol queries[i] = [index_i, color_i].
Minden lekérdezésnél a nums tömb index_i indexű elemét color_i színnel színezed.
A lekérdezésekkel azonos hosszúságú válasz tömböt add vissza, ahol az answer[i] az i^-edik lekérdezés után azonos színű szomszédos elemek száma.
Formálisan, answer[i] azoknak az indexeknek a száma j, ahol 0 <= j < n - 1 és nums[j] == nums[j + 1] és nums[j] != 0 az i-edik lekérdezés után.

Példa 1:

Bemenet: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Kimenet: [0,1,1,0,2]
Magyarázat: Kezdetben a nums tömb = [0,0,0,0], ahol 0 a tömb színtelen elemeit jelöli.
- Az 1. lekérdezés után nums = [2,0,0,0]. Az egymás melletti azonos színű elemek száma 0.
- A 2. lekérdezés után nums = [2,2,0,0]. Az egymás melletti azonos színű elemek száma 1.
- A 3. lekérdezés után nums = [2,2,0,1]. Az egymás melletti azonos színű elemek száma 1.
- A 4. lekérdezés után nums = [2,1,0,1]. Az egymás melletti azonos színű elemek száma 0.
- Az 5. lekérdezés után nums = [2,1,1,1]. Az egymás melletti azonos színű elemek száma 2.

Példa 2:

Bemenet: n = 1, queries = [[0,100000]]
Kimenet: [0]
Magyarázat: Kezdetben a nums tömb = [0], ahol 0 a tömb színtelen elemeit jelöli.
- Az 1. lekérdezés után nums = [100000]. Az egymás melletti azonos színű elemek száma 0.

Korlátozások:

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

Van egy 0-indexelt tömb, amelynek hossza n. Kezdetben minden elem színtelen (értéke 0).
Kap egy 2D egész számokból álló tömbet, amelyet lekérdezéseknek nevezünk, ahol a queries[i] = [index_i, color_i].
Minden lekérdezéshez színezni kell az indexet index_i a tömbban lévő color_i színnel.
A lekérdezésekkel azonos hosszúságú választömb ad vissza, ahol answer[i] az i^th lekérdezés után azonos színű szomszédos elemek száma.
Formálisabban answer[i] a j indexek száma, úgy, hogy 0 <= j < n - 1 és nums[j] == nums[j + 1] és nums[j] != 0 az i^th lekérdezés után.

1. példa:

Bemenet: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Kimenet: [0,1,1,0,2]
Magyarázat: Kezdetben tömbszám = [0,0,0,0], ahol a 0 a tömb színtelen elemeit jelöli.
- Az 1. (első) lekérdezés után nums = [2,0,0,0]. Az azonos színű szomszédos elemek száma 0.
- A 2. (második) lekérdezés után nums = [2,2,0,0]. Az azonos színű szomszédos elemek száma 1.
- A 3^rd lekérdezés után nums = [2,2,0,1]. Az azonos színű szomszédos elemek száma 1.
- A 4^. lekérdezés után nums = [2,1,0,1]. Az azonos színű szomszédos elemek száma 0.
- Az 5^. lekérdezés után nums = [2,1,1,1]. Az azonos színű szomszédos elemek száma 2.

2. példa:

Bemenet:n = 1, queries = [[0,100000]]
Kimenet: [0]
Magyarázat: Kezdetben tömb nums = [0], ahol a 0 a tömb színtelen elemeit jelöli.
- Az 1^st lekérdezés után nums = [100000]. Az azonos színű szomszédos elemek száma 0.

Korlátok:

1 <= n <= 10^5
1 <= lekérdezések.hossza <= 10^5
queries[i].length == 2
0 < = index_i < = n - 1
1 <= color_i <= 10^5

Van egy 0-indextől kezdődő, n hosszúságú nums tömb. Kezdetben minden elem színtelen (értéke 0).
Egy 2D egész számokat tartalmazó queries tömböt kapsz, ahol queries[i] = [index_i, color_i].
Minden lekérdezésnél a nums tömb index_i indexű elemét color_i színnel színezed.
Adj vissza egy answer tömböt, amely ugyanolyan hosszú, mint a queries, ahol answer[i] az i-edik lekérdezés után az egymás melletti, azonos színű elemek száma.
Formálisan, answer[i] azoknak az indexeknek a száma j, ahol 0 <= j < n - 1 és nums[j] == nums[j + 1] és nums[j] != 0 az i-edik lekérdezés után.

1. példa:

Input: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Output: [0,1,1,0,2]
Magyarázat: Kezdetben a nums tömb = [0,0,0,0], ahol 0 a tömb színtelen elemeit jelöli.
- Az 1. lekérdezés után nums = [2,0,0,0]. Az egymás melletti azonos színű elemek száma 0.
- A 2. lekérdezés után nums = [2,2,0,0]. Az egymás melletti azonos színű elemek száma 1.
- A 3. lekérdezés után nums = [2,2,0,1]. Az egymás melletti azonos színű elemek száma 1.
- A 4. lekérdezés után nums = [2,1,0,1]. Az egymás melletti azonos színű elemek száma 0.
- Az 5. lekérdezés után nums = [2,1,1,1]. Az egymás melletti azonos színű elemek száma 2.

2. példa:

Input: n = 1, queries = [[0,100000]]
Output: [0]
Magyarázat: Kezdetben a nums tömb = [0], ahol 0 a tömb színtelen elemeit jelöli.
- Az 1. lekérdezés után nums = [100000]. Az egymás melletti azonos színű elemek száma 0.

Korlátok:

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


Egy 0-indexelt egész szám tömböt, nums-t kapsz, amely néhány hős erejét ábrázolja. Egy hőscsoport ereje a következőképpen van meghatározva:

Legyenek i_0, i_1, ..., i_k a csoport hőseinek indexei. Akkor ennek a csoportnak az ereje max(nums[i_0], nums[i_1], ..., nums[i_k])^2 * min(nums[i_0], nums[i_1], ..., nums[i_k]).

Add vissza az összes nem üres hőscsoport erejének összegét. Mivel az összeg nagyon nagy lehet, térj vissza az eredménnyel modulo 10^9 + 7.

Példa 1:
Bemenet: nums = [2,1,4]
Kimenet: 141
Magyarázat:
1^es csoport: [2] ereje van= 2^2 * 2 = 8.
2^es csoport: [1] ereje van= 1^2 * 1 = 1.
3^as csoport: [4] ereje van= 4^2 * 4 = 64.
4^es csoport: [2,1] ereje van= 2^2 * 1 = 4.
5^ös csoport: [2,4] ereje van= 4^2 * 2 = 32.
6^os csoport: [1,4] ereje van= 4^2 * 1 = 16.
7^es csoport: [2,1,4] ereje van= 4^2 * 1 = 16.
Az összes csoport erejének összege 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Példa 2:
Bement: nums = [1,1,1]
Kimenet: 7
Magyarázat: Összesen 7 csoport lehetséges, és minden csoport ereje 1 lesz. Ezért az összes csoport erejének összege 7.

Korlátok:

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

Kapsz egy 0-indexelt egész tömb számokat, amelyek néhány hős erejét képviselik. A hősök egy csoportjának erejét a következőképpen határozzuk meg:

Legyenek i_0, i_1, ... ,i_k a csoport hőseinek mutatói. Ekkor ennek a csoportnak a hatványa max(szám[i_0], szám[i_1], ... ,szám[i_k])^2 * min(szám[i_0], szám[i_1], ... ,szám[ i_k]).

Adja vissza az összes lehetséges nem üres hőscsoport erejének összegét. Mivel az összeg nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [2,1,4]
Kimenet: 141
Magyarázat:
1^. csoport: [2] ereje = 2^2 * 2 = 8.
2. csoport: [1] értéke = 1^2 * 1 = 1.
3^. csoport: [4] ereje = 4^2 * 4 = 64.
4. csoport: [2,1] értéke = 2^2 * 1 = 4.
5^. csoport: [2,4] értéke = 4^2 * 2 = 32.
6^. csoport: [1,4] értéke = 4^2 * 1 = 16.
7^. csoport: [2,1,4] hatványa = 4^2 * 1 = 16.
Az összes csoport hatványainak összege 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

2. példa:

Bemenet: nums= [1,1,1]
Kimenet: 7
Magyarázat: Összesen 7 csoport lehetséges, és mindegyik csoport hatványa 1 lesz. Ezért az összes csoport hatványainak összege 7.

Korlátozások:

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

Kapsz egy 0 indexelt egész tömb számokat, amelyek néhány hős erejét képviselik. A hősök csoportjának erejét a következőképpen határozzuk meg:

Legyen i_0, i_1, ..., i_k a csoport hőseinek mutatói. Ekkor ennek a csoportnak a hatványa max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[i_k]).

Adja vissza az összes lehetséges nem üres hőscsoport erejének összegét. Mivel az összeg nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [2,1,4]
Kimenet: 141
Magyarázat:
1^st csoport: [2] hatványa = 2^2 * 2 = 8.
2^nd csoport: [1] hatványa = 1^2 * 1 = 1.
3^rd csoport: [4] hatványa = 4^2 * 4 = 64.
4^th csoport: [2,1] hatványa = 2^2 * 1 = 4.
5^th csoport: [2,4] hatványa = 4^2 * 2 = 32.
6^th csoport: [1,4] hatványa = 4^2 * 1 = 16.
7^. csoport: [2,1,4] hatványa = 4^2 * 1 = 16.
Az összes csoport hatásköreinek összege 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

2. példa:

Bemenet: nums = [1,1,1]
Kimenet: 7
Magyarázat: Összesen 7 csoport lehetséges, és mindegyik csoport ereje 1 lesz. Ezért az összes csoport hatásköreinek összege 7.

Korlátok:

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


Kapsz egy n egész számból álló 0-indexelt permutációt.
A permutációt félig rendezettnek nevezzük, ha az első szám 1, az utolsó pedig n. Az alábbi műveletet annyiszor hajthatja végre, ahányszor csak akarja, amíg a számokat félig rendezett permutációvá nem teszi:

Válasszon két szomszédos elemet számokkal, majd cserélje fel őket.

Adja vissza a műveletek minimális számát, hogy a számok félig rendezett permutációvá váljanak.
A permutáció 1-től n-ig terjedő, n hosszúságú egész számsorozat, amely minden számot pontosan egyszer tartalmaz.

Példa 1:

Bemenet: nums = [2,1,4,3]
Kimenet: 2
Magyarázat: A permutációt félig rendezettté tehetjük a következő műveletsorokkal:
1 - swap i = 0 és j = 1. A permutáció [1,2,4,3] lesz.
2 - swap i = 2 és j = 3. A permutáció [1,2,3,4] lesz.
Bizonyítható, hogy nincs olyan kettőnél kevesebb műveletből álló sorozat, amely a számokat félig rendezett permutációvá tenné.

Példa 2:

Bemenet: nums = [2,4,1,3]
Kimenet: 3
Magyarázat: A permutációt félig rendezettté tehetjük a következő műveletsorokkal:
1 - swap i = 1 és j = 2. A permutáció [2,1,4,3] lesz.
2 - swap i = 0 és j = 1. A permutáció [1,2,4,3] lesz.
3 - swap i = 2 és j = 3. A permutáció [1,2,3,4] lesz.
Bebizonyítható, hogy nincs háromnál kevesebb műveletből álló sorozat, amely a számokat félig rendezett permutációvá tenné.

Példa 3:

Bemenet: nums = [1,3,4,2,5]
Kimenet: 0
Magyarázat: A permutáció már egy félig rendezett permutáció.

Korlátozások:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
A számok egy permutáció.

Adott egy 0-indexelt permutáció n egész számokból.
A permutációt félrendezettnek nevezzük, ha az első szám 1, az utolsó szám pedig n. Az alábbi műveletet annyiszor hajthatja végre, amíg a nums-t nem teszi félig rendezett permutációvá.

Válasszon ki két szomszédos elemet a számokból, majd cserélje fel őket.

Adja vissza a műveletek minimális számát ahhoz, hogy a nums félig rendezett permutációvá váljon.
A permutáció egy 1-től n-ig terjedő egész számok sorozata, amely minden számot pontosan egyszer tartalmaz.

1. példa:

Bemenet: nums = [2,1,4,3]
Kimenet: 2
Magyarázat: A permutációt félig rendezetté tehetjük a következő műveletsorokkal:
1 - i = 0 és j = 1 swap. A permutáció [1,2,4,3] lesz.
2 - i = 2 és j = 3 swap. A permutáció [1,2,3,4] lesz.
Bizonyítható, hogy nincs kettőnél kevesebb műveletből álló sorozat, amely a numokat félig rendezett permutációvá teszi.

2. példa:

Bemenet: nums = [2,4,1,3]
Kimenet: 3
Magyarázat: A permutációt félig rendezetté tehetjük a következő műveletsorokkal:
1 - i = 1 és j = 2 swap. A permutáció [2,1,4,3] lesz.
2 - i = 0 és j = 1 swap. A permutáció [1,2,4,3] lesz.
3 - i = 2 és j = 3 swap. A permutáció [1,2,3,4] lesz.
Bizonyítható, hogy nincs háromnál kevesebb műveletből álló sorozat, amely a numokat félig rendezett permutációvá teszi.

3. példa:

Bemenet: nums = [1,3,4,2,5]
Kimenet: 0
Magyarázat: A permutáció már félrendezett permutáció.

Korlátok:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
A nums egy permutáció.

Kapsz egy n egész számból álló 0-indexelt permutációt.
A permutációt félig rendezettnek nevezzük, ha az első szám 1, az utolsó pedig n. Az alábbi műveletet annyiszor hajthatja végre, ahányszor csak akarja, amíg a számokat félig rendezett permutációvá nem teszi:

Válasszon két szomszédos elemet számokkal, majd cserélje fel őket.

Adja vissza a műveletek minimális számát, hogy a számok félig rendezett permutációvá váljanak.
A permutáció 1-től n-ig terjedő, n hosszúságú egész számsorozat, amely minden számot pontosan egyszer tartalmaz.

1. példa:

Bemenet: nums = [2,1,4,3]
Kimenet: 2
Magyarázat: A permutációt félig rendezettté tehetjük a következő műveletsorokkal:
1 - swap i = 0 és j = 1. A permutáció [1,2,4,3] lesz.
2 - swap i = 2 és j = 3. A permutáció [1,2,3,4] lesz.
Bizonyítható, hogy nincs olyan kettőnél kevesebb műveletből álló sorozat, amely a számokat félig rendezett permutációvá tenné.

2. példa:

Bemenet: nums = [2,4,1,3]
Kimenet: 3
Magyarázat: A permutációt félig rendezettté tehetjük a következő műveletsorokkal:
1 - swap i = 1 és j = 2. A permutáció [2,1,4,3] lesz.
2 - swap i = 0 és j = 1. A permutáció [1,2,4,3] lesz.
3 - swap i = 2 és j = 3. A permutáció [1,2,3,4] lesz.
Bebizonyítható, hogy nincs háromnál kevesebb műveletből álló sorozat, amely a számokat félig rendezett permutációvá tenné.

3. példa:

Bemenet: nums= [1,3,4,2,5]
Kimenet: 0
Magyarázat: A permutáció már egy félig rendezett permutáció.

Korlátozások:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
A számok egy permutáció.


Kapsz egy 0-indexelt s karakterláncot, amely 0 és 9 közötti számjegyekből áll.
A t karakterláncot félig ismétlődőnek nevezzük, ha legfeljebb egy egymást követő pár van ugyanazon számjegyekből t belsejében. Például a 0010, 002020, 0123, 2002 és 54944 félig ismétlődő, míg 00101022, 1101234883 pedig nem.
Az s belsejében található leghosszabb félig ismétlődő részkarakterlánc hosszát adja eredményül.
Az alkarakterlánc egy karakterláncon belüli folytonos, nem üres karaktersorozat.

1. példa:

Bemenet: s = "52233"
Kimenet: 4
Magyarázat: A leghosszabb félig ismétlődő részkarakterlánc az "5223", amely i = 0-nál kezdődik és j = 3-nál végződik.

2. példa:

Bemenet: s = "5494"
Kimenet: 4
Magyarázat: s egy félig ismétlődő, tehát a válasz 4.

3. példa:

Bemenet: s = "1111111"
Kimenet: 2
Magyarázat: A leghosszabb félig ismétlődő részkarakterlánc a "11", amely i = 0-nál kezdődik és j = 1-nél végződik.

Korlátok:

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

Kapsz egy 0 indexű s karakterláncot, amely 0 és 9 közötti számjegyekből áll.
Egy t karakterláncot félig ismétlődőnek nevezünk, ha a t-ben legfeljebb egy egymást követő azonos számpár található. Például a 0010, 002020, 0123, 2002 és 54944 félig ismétlődő, míg a 00101022 és 1101234883 nem.
Az s-en belüli leghosszabb félig ismétlődő részkarakterlánc hosszát adja vissza.
A részkarakterlánc a karakterláncon belüli, egymást követő, nem üres karaktersorozat.

1. példa:

Bemenet: s = "52233"
Kimenet: 4
Magyarázat: A leghosszabb félig ismétlődő részkarakterlánc az "5223", amely i = 0-val kezdődik és j = 3-ra végződik.

2. példa:

Bemenet: s = "5494"
Kimenet: 4
Magyarázat: s egy félig ismétlődő karakterlánc, így a válasz 4.

3. példa:

Bemenet: s = "1111111"
Kimenet: 2
Magyarázat: A leghosszabb félig ismétlődő részkarakterlánc a "11", amely i = 0-val kezdődik és j = 1-re végződik.

Korlátozások:

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

Kapsz egy 0 indexű s karakterláncot, amely 0 és 9 közötti számjegyekből áll.
Egy t karakterláncot félig ismétlődőnek nevezünk, ha a t-ben legfeljebb egy egymást követő azonos számpár található. Például a 0010, 002020, 0123, 2002 és 54944 félig ismétlődő, míg a 00101022 és 1101234883 nem.
Az s-en belüli leghosszabb félig ismétlődő részkarakterlánc hosszát adja vissza.
A részkarakterlánc egy karakterláncon belüli, egymást követő, nem üres karaktersorozat.

1. példa:

Bemenet: s = "52233"
Kimenet: 4
Magyarázat: A leghosszabb félig ismétlődő részkarakterlánc az "5223", amely i = 0-val kezdődik és j = 3-ra végződik.

2. példa:

Bemenet: s = "5494"
Kimenet: 4
Magyarázat: s egy félig ismétlődő karakterlánc, így a válasz 4.

3. példa:

Bemenet: s = "1111111"
Kimenet: 2
Magyarázat: A leghosszabb félig ismétlődő részkarakterlánc a "11", amely i = 0-val kezdődik és j = 1-re végződik.

Korlátozások:

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


N barát játszik. A barátok körben ülnek, és az óramutató járásával megegyező sorrendben 1-től n-ig vannak számozva. Formálisabban, ha az i^edik baráttól az óramutató járásával megegyező irányban mozogsz, akkor az (i+1)^. baráthoz jutsz 1 <= i < n-ért, és az óramutató járásával megegyező irányban mozogva az n^edik baráttól az 1^st baráthoz jutsz.
A játékszabályok a következők:
1^st barát kapja a labdát.

Ezután az 1^st barát átadja annak a barátnak, aki k lépésre van tőlük az óramutató járásával megegyező irányban.
Ezt követően a labdát fogadó barátnak át kell adnia azt annak a barátnak, aki 2 * k lépésre van tőlük az óramutató járásával megegyező irányban.
Ezután a labdát fogadó barátnak át kell adnia azt annak a barátnak, aki 3 * k lépésre van tőlük az óramutató járásával megegyező irányban, és így tovább, és így tovább.

Más szóval, az i^-edik fordulóban a labdát tartó barátnak át kell adnia azt annak a barátnak, aki i * k lépésnyire van tőlük az óramutató járásával megegyező irányban.
A játék akkor ér véget, amikor egy barát másodszor is megkapja a labdát.
A játék vesztesei olyan barátok, akik az egész játékban nem kapták meg a labdát.
Tekintettel a barátok számára, n és egy k egész számra, adja vissza a tömb, amely növekvő sorrendben tartalmazza a játék veszteseit.

1. példa:

Bemenet: n = 5, k = 2
Kimenet: [4,5]
Magyarázat: A játék a következőképpen megy:
1) Kezdje az 1^. barátnál, és adja át a labdát annak a barátnak, aki 2 lépésre van tőlük - 3^rd barát.
2) 3^rd barát átadja a labdát annak a barátnak, aki 4 lépésre van tőlük - 2^nd barát.
3) 2^. barát átadja a labdát annak a barátnak, aki 6 lépésre van tőlük - 3^rd barát.
4) A játék akkor ér véget, amikor a 3^. barát másodszor is megkapja a labdát.

2. példa:

Bemenet: n = 4, k = 4
Kimenet: [2,3,4]
Magyarázat: A játék a következőképpen megy:
1) Kezdje az 1^. barátnál, és adja át a labdát annak a barátnak, aki 4 lépésre van tőlük - 1^ barát.
2) A játék akkor ér véget, amikor az 1^ barát másodszor is megkapja a labdát.

Korlátok:

1 < = k <= n <= 50

Van n barát, aki játszik. A barátok körben ülnek, és az óramutató járásával megegyező irányban 1-től n-ig vannak számozva. Formálisabban, ha az i^. baráttól az óramutató járásával megegyező irányba mozog, az (i+1)^. baráthoz 1 <= i < n, az óramutató járásával megegyező irányba haladva pedig az n^. baráttól az 1. baráthoz jut.
A játék szabályai a következők:
Az 1. barát megkapja a labdát.

Ezután az 1. barát átadja annak a barátnak, aki k lépést tesz tőlük az óramutató járásával megegyező irányba.
Ezt követően a labdát kapó barát passzoljon a tőlük 2 * k lépésre lévő barátnak az óramutató járásával megegyező irányban.
Ezután a labdát kapó barát passzoljon a tőlük 3 * k lépésre lévő barátjának az óramutató járásával megegyező irányban, és így tovább, és így tovább.

Más szóval, az i^. körben a labdát tartó barátnak át kell adnia azt a barátjának, aki i * k az óramutató járásával megegyező irányban.
A játék akkor ér véget, amikor valamelyik barát másodszor is megkapja a labdát.
A játék vesztesei azok a barátok, akik nem kapták meg a labdát az egész játék során.
Adott a barátok száma, n és egy k egész szám, adja vissza a tömbválaszt, amely a játék veszteseit tartalmazza növekvő sorrendben.

1. példa:

Bemenet: n = 5, k = 2
Kimenet: [4,5]
Magyarázat: A játék a következőképpen zajlik:
1) Kezdje az 1. barátnál, és adja át a labdát annak a barátnak, aki 2 lépésre van tőlük – a 3. barátnak.
2) A 3. barát átpasszolja a labdát annak a barátnak, aki 4 lépésre van tőlük - a 2. barátnak.
3) A 2. barát átpasszolja a labdát a tőlük 6 lépésre lévő barátnak - 3. barátnak.
4) A játék akkor ér véget, amikor a 3. barát másodszor is megkapja a labdát.

2. példa:

Bemenet: n = 4, k = 4
Kimenet: [2,3,4]
Magyarázat: A játék a következőképpen zajlik:
1) Kezdje az 1. barátnál, és adja át a labdát annak a barátnak, aki 4 lépésre van tőlük - az 1. barátnak.
2) A játék akkor ér véget, amikor az 1. barát másodszor is megkapja a labdát.

Korlátozások:

1 <= k <= n <= 50

N barát játszik. A barátok körben ülnek, és az óramutató járásával megegyező sorrendben 1-től n-ig vannak számozva. Formálisabban, ha az i^edik baráttól az óramutató járásával megegyező irányban mozogsz, akkor az (i+1)^th baráthoz jutsz 1 <= i < n-ért, és az óramutató járásával megegyező irányban mozogva az n^edik baráttól az 1^st baráthoz jutsz.
A játékszabályok a következők:
1^st barát kapja a labdát.

Ezután az 1^st barát átadja annak a barátnak, aki k lépésre van tőlük az óramutató járásával megegyező irányban.
Ezt követően a labdát fogadó barátnak át kell adnia azt annak a barátnak, aki 2 * k lépésre van tőlük az óramutató járásával megegyező irányban.
Ezután a labdát fogadó barátnak át kell adnia azt annak a barátnak, aki 3 * k lépésre van tőlük az óramutató járásával megegyező irányban, és így tovább, és így tovább.

Más szóval, az i^-edik fordulóban a labdát tartó barátnak át kell adnia azt annak a barátnak, aki i * k lépésnyire van tőlük az óramutató járásával megegyező irányban.
A játék akkor ér véget, amikor egy barát másodszor is megkapja a labdát.
A játék vesztesei olyan barátok, akik az egész játékban nem kapták meg a labdát.
Tekintettel a barátok számára, n és egy k egész számra, adja vissza a tömbválaszt, amely növekvő sorrendben tartalmazza a játék veszteseit.

1. példa:

Bemenet: n = 5, k = 2
Kimenet: [4,5]
Magyarázat: A játék a következőképpen megy:
1) Kezdje az 1^. barátnál, és adja át a labdát annak a barátnak, aki 2 lépésre van tőlük - 3^rd barát.
2) 3^rd barát átadja a labdát annak a barátnak, aki 4 lépésre van tőlük - 2^nd barát.
3) 2^. barát átadja a labdát annak a barátnak, aki 6 lépésre van tőlük - 3^rd barát.
4) A játék akkor ér véget, amikor a 3^. barát másodszor is megkapja a labdát.

2. példa:

Bemenet: n = 4, k = 4
Kimenet: [2,3,4]
Magyarázat: A játék a következőképpen megy:
1) Kezdje az 1^. barátnál, és adja át a labdát annak a barátnak, aki 4 lépésre van tőlük - 1^st barát.
2) A játék akkor ér véget, amikor az 1^st barát másodszor is megkapja a labdát.

Korlátok:

1 < = k <= n <= 50


Egy n hosszúságú, 0-indexelt tömböt úgy származtatunk, hogy kiszámítjuk a szomszédos értékek bitenkénti XOR-értékét (⊕) egy n hosszúságú bináris tömb eredetijében.
Pontosabban a [0, n - 1] tartomány minden i indexére:

Ha i = n - 1, akkor származtatott[i] = eredeti[i] ⊕ eredeti[0].
Egyébként származtatott[i] = eredeti[i] ⊕ eredeti[i + 1].

Adott egy származtatott tömb, az Ön feladata annak meghatározása, hogy létezik-e olyan érvényes bináris tömb eredeti, amely származtatott tömböt alkothatott volna.
Ha létezik ilyen tömb, akkor a true értéket adja vissza, egyébként pedig a false értéket.

A bináris tömb olyan tömb, amely csak 0-t és 1-et tartalmaz

1. példa:

Bemenet: derived = [1,1,0]
Kimenet: true
Magyarázat: Egy érvényes eredeti tömb, amely származtatott értéket ad, [0,1,0].
származtatott[0] = eredeti[0] ⊕ eredeti[1] = 0 ⊕ 1 = 1
származtatott[1] = eredeti[1] ⊕ eredeti[2] = 1 ⊕ 0 = 1
származtatott[2] = eredeti[2] ⊕ eredeti[0] = 0 ⊕ 0 = 0

2. példa:

Bemenet: derived = [1,1]
Kimenet: true
Magyarázat: Egy érvényes eredeti tömb, amely származtatott értéket ad, [0,1].
származtatott[0] = eredeti[0] ⊕ eredeti[1] = 1
származtatott[1] = eredeti[1] ⊕ eredeti[0] = 1

3. példa:

Bemenet: derived = [1,0]
Kimenet: false
Magyarázat: Nincs érvényes eredeti tömb, amely származtatott értéket adna.

Korlátozások:

n == derived.length
1 <= n <= 10^5
A derived értékei 0-ák vagy 1-esek

Az n hosszúsággal származtatott 0-indexelt tömböt úgy számítjuk ki, hogy kiszámítjuk a szomszédos értékek bitenkénti XOR (⊕) értékét egy n hosszúságú eredeti bináris tömbben.
Pontosabban, a [0, n - 1] tartomány minden i indexére:

Ha i = n - 1, akkor derived[i] = original[i] ⊕ original[0].
Ellenkező esetben derived[i] = original[i] ⊕ original[i + 1].

Származtatott tömb esetén a feladat annak megállapítása, hogy létezik-e érvényes bináris tömb eredeti, amely származtatva is kialakulhatott.
Igaz értéket ad vissza, ha létezik ilyen tömb, vagy hamis értéket.

A bináris tömb olyan tömb, amely csak 0-kat és 1-eket tartalmaz

1. példa:

Bemenet: derived = [1,1,0]
Kimenet: true
Magyarázat: Egy érvényes eredeti tömb, amely származtatott értéket ad, a [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. példa:

Ráfordítás: derived = [1,1]
Kimenet: true
Magyarázat: Egy érvényes eredeti tömb, amely származtatott értéket ad, a [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

3. példa:

Bemenet: derived = [1,0]
Kimenet: hamis
Magyarázat: Nincs érvényes eredeti tömb, amely származtatottat adna.

Korlátok:

n == derived.length
1 <= n <= 10^5
A származtatott értékek 0 vagy 1

Egy 0-indexű derived tömb hosszúsága n úgy van előállítva, hogy az original bináris tömb szomszédos értékeinek bitenkénti XOR-ját (⊕) számoljuk ki, amelynek hossza n.
Kifejezetten minden i indexre a [0, n - 1] tartományban:

Ha i = n - 1, akkor derived[i] = original[i] ⊕ original[0].
Egyébként derived[i] = original[i] ⊕ original[i + 1].

Adott egy derived tömb, a feladatod meghatározni, hogy létezik-e olyan érvényes bináris original tömb, amely létrehozhatta derived-et.
Térj vissza true-val, ha létezik ilyen tömb, vagy false-szal, ha nem.

Egy bináris tömb csak 0-ákból és 1-esekből áll

1. példa:

Bemenet: derived = [1,1,0]
Kimenet: true
Magyarázat: Egy érvényes original tömb, amely derived-et ad, az [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. példa:

Bemenet: derived = [1,1]
Kimenet: true
Magyarázat: Egy érvényes original tömb, amely derived-et ad, az [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

3. példa:

Bemenet: derived = [1,0]
Kimenet: false
Magyarázat: Nincs olyan érvényes original tömb, amely derived-et ad.

Megkötések:

n == derived.length
1 <= n <= 10^5
A derived értékei 0-ák vagy 1-esek


Kapsz egy s karakterláncot, amely csak angol nagybetűket tartalmaz.
Alkalmazhat néhány műveletet erre a karakterláncra, ahol egy műveletben eltávolíthatja az "AB" vagy "CD" részkarakterláncok bármelyikének előfordulását az s-ből.
Adja vissza a kapott karakterlánc minimális lehetséges hosszát, amelyet megkaphat.
Vegye figyelembe, hogy a karakterlánc az alsztring eltávolítása után összefűződik, és új "AB" vagy "CD" részstringeket hozhat létre.

1. példa:

Bemenet: s = "ABFCACDB"
Kimenet: 2
Magyarázat: A következő műveleteket tudjuk elvégezni:
- Távolítsa el az "ABFCACDB" részstringet, így s = "FCACDB".
- Távolítsa el az "FCACDB" részstringet, így s = "FCAB".
- Távolítsa el az "FCAB" részstringet, így s = "FC".
Tehát a karakterlánc eredő hossza 2.
Megmutatható, hogy ez a minimális hosszúság, amit elérhetünk.
2. példa:

Bemenet: s = "ACBBD"
Kimenet: 5
Magyarázat: Nem tudunk semmilyen műveletet végrehajtani a karakterláncon, így a hossza változatlan marad.

Korlátozások:

1 <= s.length <= 100
s csak angol nagybetűkből áll.

Kapsz egy s karakterláncot, amely csak angol nagybetűket tartalmaz.
Alkalmazhat néhány műveletet erre a karakterláncra, ahol egy műveletben eltávolíthatja az "AB" vagy "CD" részkarakterláncok bármelyikének előfordulását az s-ből.
Adja vissza a kapott karakterlánc minimális lehetséges hosszát, amelyet megkaphat.
Vegye figyelembe, hogy a karakterlánc az alsztring eltávolítása után összefűződik, és új "AB" vagy "CD" részstringeket hozhat létre.

példa 1:

Bemenet: s = "ABFCACDB"
Kimenet: 2
Magyarázat: A következő műveleteket tudjuk elvégezni:
- Távolítsa el az "ABFCACDB" részstringet, így s = "FCACDB".
- Távolítsa el az "FCACDB" részstringet, így s = "FCAB".
- Távolítsa el az "FCAB" részstringet, így s = "FC".
Tehát a karakterlánc eredő hossza 2.
Megmutatható, hogy ez a minimális hosszúság, amit elérhetünk.
példa 2:

Bemenet: s = "ACBBD"
Kimenet: 5
Magyarázat: Nem tudunk semmilyen műveletet végrehajtani a karakterláncon, így a hossza változatlan marad.

Korlátozások:

1 <= s.length <= 100
s csak angol nagybetűkből áll.

Kapsz egy s karakterláncot, amely csak nagybetűs angol betűkből áll.
Erre a karakterláncra alkalmazhat néhány műveletet, ahol egy művelettel eltávolíthatja az "AB" vagy "CD" alsztringek egyikének előfordulását az s-ből.
Az eredményül kapott karakterlánc lehető legkisebb beszerezhető hosszát adja vissza.
Vegye figyelembe, hogy a karakterlánc összefűződik az alkarakterlánc eltávolítása után, és új "AB" vagy "CD" részsztringeket hozhat létre.

1. példa:

Bemenet: s = "ABFCACDB"
Kimenet: 2
Magyarázat: A következő műveleteket végezhetjük el:
- Távolítsa el az "ABFCACDB" alsztringet, így s = "FCACDB".
- Távolítsa el az "FCACDB" alsztringet, így s = "FCAB".
- Távolítsa el az "FCAB" alsztringet, így s = "FC".
Tehát a kapott karakterlánc hossza 2.
Megmutatható, hogy ez a minimális hossz, amit elérhetünk.
2. példa:

Bemenet: s = "ACBBD"
Kimenet: 5
Magyarázat: Nem tudunk semmilyen műveletet végrehajtani a karakterláncon, így a hossza változatlan marad.

Korlátok:

1 <= s.length <= 100
s csak nagybetűs angol betűkből áll.