N épület van egy sorban. Az i-edik épület balról H_i magasságú.
Határozza meg, hogy van-e balról az elsőnél magasabb épület. Ha létezik ilyen épület, keresse meg a bal szélső ilyen épület helyzetét balról.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
H_1 H_2 \ldots H_N

Kimenet

Ha egyik épület sem magasabb, mint az első balról, nyomtasson -1-et.
Ha létezik ilyen épület, nyomtassa ki a bal szélső ilyen épület pozícióját (indexét) balról.

Korlátozások

- 1 \leq N \leq 100
- 1 \leq H_i \leq 100
- Minden bemeneti érték egész szám.

1. minta bemenet

4
3 2 5 2

1. minta kimenet

3

A balról az elsőnél magasabb épület balról a harmadik.

2. minta bemenet

3
4 3 2

2. minta kimenet

-1

Egyetlen épület sem magasabb, mint az első balról.

Minta bemenet 3

7
10 5 10 2 10 13 15

3. minta kimenet

6

A balról az elsőnél magasabb épületek a hatodik és a hetedik. Közülük a bal szélső a hatodik.

N épület van egy sorban igazítva. A bal oldali i-edik épület magassága H_i.
Állapítsa meg, hogy van-e balról az elsőnél magasabb épület. Ha létezik ilyen épület, keresse meg a bal szélső épület helyzetét balról.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
H_1 H_2 \ldots H_N

Kimenet

Ha egyetlen épület sem magasabb, mint balról az első, nyomtassa ki a -1 értéket.
Ha létezik ilyen épület, nyomtassa ki balról abal szélső épület indexét (indexét).

Korlátok

- 1 \leq N \leq 100
- 1 \leq H_i \leq 100
- Minden bemeneti érték egész szám.

1. minta bemenet

4
3 2 5 2

3

3

Az épület, amely balról az elsőnél magasabb, balról a harmadik.

2. minta bemenet

3
4 3 2

2. mintakimenet

-1

Egyetlen épület sem magasabb, mint az első balról.

3. minta bemenet

7
10 5 10 2 10 13 15

Minta kimenet 3

6

Az elsőnél magasabb épületek balról a hatodik és a hetedik. Ezek közül a bal szélső a hatodik.

N épület van egy sorban igazítva. A bal oldali i-edik épület magassága H_i.
Állapítsa meg, hogy van-e balról az elsőnél magasabb épület. Ha létezik ilyen épület, keresse meg a bal szélső épület helyzetét balról.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
H_1 H_2 \ldots H_N

Hozam

Ha egyetlen épület sem magasabb, mint balról az első, nyomtassa ki a -1 értéket.
Ha létezik ilyen épület, nyomtassa ki balról a bal szélső épület helyzetét (indexét).

Korlátok

- 1 \leq N \leq 100
- 1 \leq H_i \leq 100
- Minden bemeneti érték egész szám.

1. minta bemenet

4
3 2 5 2

1. minta kimenet

3

Az épület, amely balról az elsőnél magasabb, balról a harmadik.

2. minta bemenet

3
4 3 2

2. minta kimenet

-1

Egyetlen épület sem magasabb, mint az első balról.

3. minta bemenet

7
10 5 10 2 10 13 15

3. minta kimenet

6

Az elsőnél magasabb épületek balról a hatodik és a hetedik. Ezek közül a bal szélső a hatodik.


Az x és y karakterláncok esetében definiáljuk f(x, y) értékét a következőképpen:

- f(x, y) az x és y leghosszabb közös előtagjának hossza.

Adott N karakterlánc (S_1, \ldots, S_N), amelyek kisbetűs angol betűkből állnak. Keresse meg a következő kifejezés értékét:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(S_i,S_j).

Bemenet

A bemenetet a Standard Inputból adjuk meg a következő formátumban:
N
S_1 \ldots S_N

Kimenet

A válasz kiírása.

Korlátozások

- 2 \leq N \leq3 \times 10^5
- S_i egy angol kisbetűkből álló karakterlánc.
- 1 \leq |S_i|
- |S_1|+|S_2|+\ldots+|S_N|\leq 3\times 10^5
- Minden bemeneti szám egész szám.

Minta bemenet 1

3
ab abc arc

Minta Kimenet 1

4

- f(S_1,S_2)=2
- f(S_1,S_3)=1
- f(S_2,S_3)=1

A válasz tehát f(S_1,S_2) + f(S_1,S_3) + f(S_2,S_3) = 4.

2. Minta bemenet 2

11
ab bb aaa bba baba babbbabbaaba aabbb a a a b

Minta kimenet 2

32

Az x és y karakterláncokhoz adja meg az f(x, y)-t a következőképpen:

- f(x, y) az x és y leghosszabb közös előtagjának hossza.

N számú karakterláncot kap (S_1, \ldots, S_N), amelyek angol kisbetűkből állnak. Keresse meg a következő kifejezés értékét:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(S_i,S_j).

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
S_1 \ldots S_N

Kimenet

Nyomtassa ki a választ.

Korlátozások

- 2 \leq N \leq 3\times 10^5
- Az S_i egy kis angol betűkből álló karakterlánc.
- 1 \leq |S_i|
- |S_1|+|S_2|+\ldots+|S_N|\leq 3\times 10^5
- Minden bevitt szám egész szám.

1. minta bemenet

3
ab abc arc

1. minta kimenet

4

- f(S_1,S_2)=2
- f(S_1,S_3)=1
- f(S_2,S_3)=1

Így a válasz f(S_1,S_2) + f(S_1,S_3) + f(S_2,S_3) = 4.

2. minta bemenet

11
ab bb aaa bba baba babb aaaba aabbb a a b

2. minta kimenet

32

Az x és y karakterláncok esetében definiáljuk az f(x, y) értéket a következőképpen:

- f(x, y) az x és y leghosszabb közös előtagjának hossza.

N karakterláncot (S_1, \ldots, S_N) kapsz, amelyek kisbetűs angol betűkből állnak. Keresse meg a következő kifejezés értékét:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(S_i,S_j).

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
S_1 \ldots S_N

Kimenet

Nyomtassa ki a választ.

Korlátok

- 2 \leq N \leq 3\times 10^5
- S_i egy kisbetűs angol betűkből álló karakterlánc.
- 1 \leq |S_i|
- |S_1|+|S_2|+\ldots+|S_N|\leq 3\times 10^5
- Minden bemeneti szám egész szám.

1. minta bemenet

3
ab abc  arc

1. minta kimenet

4

- f(S_1;S_2)=2
- f(S_1,S_3)=1
- f(S_2;S_3)=1

Így a válasz f(S_1,S_2) + f(S_1,S_3) + f(S_2,S_3) = 4

2. minta bemenet

11
ab bb aaa bba baba babb aaaba aabbb a a b

2. minta kimenet

32


Pozitív egész x és y számok esetén definiáljuk f(x, y) értékét a következőképpen:

- Értelmezzük x és y decimális ábrázolásait karakterláncokként, és fűzzük össze őket ebben a sorrendben, hogy z karakterláncot kapjunk. Az f(x, y) értéke a z értéke tizedes egész számként értelmezve.

Például f(3, 14) = 314 és f(100, 1) = 1001.
Adott egy N hosszúságú pozitív egész számok sorozata A = (A_1, \ldots, A_N). Keresse meg a következő kifejezés modulo 998244353 értékét:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(A_i,A_j).

Bemenet

A bemenetet a Standard Inputból adjuk meg a következő formátumban:
N
A_1 \ldots A_N

Kimenet

A válasz kiírása.

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i \leq 10^9
- Minden bemeneti érték egész szám.

Minta bemenet 1

3
3 14 15

Minta kimenet 1

2044

- f(A_1, A_2) = 314
- f(A_1, A_3) = 315
- f(A_2, A_3) = 1415

A válasz tehát f(A_1, A_2) + f(A_1, A_3) + f(A_2, A_3) = 2044.

Minta bemenet 2

5
1001 5 1000000 1000000000 100000

Minta kimenet 2

625549048

Ügyeljen arra, hogy az értéket modulo 998244353 számítsa ki.

Az x és y pozitív egész számokhoz adja meg az f(x, y)-t a következőképpen:

- Értelmezze x és y decimális reprezentációit karakterláncként, és fűzze össze őket ebben a sorrendben, hogy z karakterláncot kapjon. Az f(x, y) értéke z értéke, ha decimális egész számként értelmezzük.

Például f(3, 14) = 314 és f(100, 1) = 1001.
Kapunk egy pozitív egész számsort A = (A_1, \ldots, A_N), amelyeknek hossza N. Keresse meg a következő modulo 998244353 kifejezés értékét:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(A_i,A_j).

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 \ldots A_N

Kimenet

Nyomtassa ki a választ.

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

3
3 14 15

1. minta kimenet

2044

- f(A_1, A_2) = 314
- f(A_1, A_3) = 315
- f(A_2, A_3) = 1415

Így a válasz f(A_1, A_2) + f(A_1, A_3) + f(A_2, A_3) = 2044.

2. minta bemenet

5
1001 5 1000000 1000000000 100000

2. minta kimenet

625549048

Mindenképpen számítsa ki a modulo 998244353 értéket.

Az x és y pozitív egész számok esetén definiálja az f(x, y)-t a következőképpen:

- Értelmezze x és y decimális reprezentációit karakterláncként, és fűzze össze őket ebben a sorrendben, hogy z karakterláncot kapjon. Az f(x, y) értéke z értéke, ha decimális egész számként értelmezzük.

Például f(3, 14) = 314 és f(100, 1) = 1001.
Kapunk egy pozitív egész számsort A = (A_1, \ldots, A_N), amelyeknek hossza N. Keresse meg a következő modulo 998244353 kifejezés értékét:
\displaystyle \sum_{i=1}^{N-1}\sum_{j=i+1}^N f(A_i,A_j).

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 \ldots A_N

Kimenet

Nyomtassa ki a választ.

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

3
3 14 15

1. minta kimenet

2044

- f(A_1, A_2) = 314
- f(A_1, A_3) = 315
- f(A_2, A_3) = 1415

Így a válasz f(A_1, A_2) + f(A_1, A_3) + f(A_2, A_3) = 2044.

2. minta bemenet

5
1001 5 1000000 1000000000 100000

2. minta kimenet

625549048

Mindenképpen számítsa ki a modulo 998244353 értéket.


N AtCoder-felhasználó gyűlt össze, hogy játsszon AtCoder RPS 2-t. Az i-edik felhasználó neve S_i, besorolásuk pedig C_i.
Az AtCoder RPS 2 lejátszása a következőképpen történik:

- Rendelje a felhasználókhoz a 0, 1, \dots, N - 1 számokat felhasználónevük lexikográfiai sorrendjében.
- Legyen T az N felhasználó értékelésének összege. A T \bmod N számhoz rendelt felhasználó a nyertes.

Nyomtassa ki a nyertes felhasználónevét.

Mi a lexikográfiai rend?

A lexikográfiai sorrend egyszerűen azt jelenti, hogy "a szavak szótárban való megjelenésének sorrendje". Pontosabban, a két különálló, kis angol betűkből álló S és T karakterlánc sorrendjének meghatározására szolgáló algoritmus a következő:

Itt az "S i-edik karakterét" S_i-ként jelöljük. Ha S lexikográfiailag kisebb, mint T, akkor S \lt T-t írunk, ha S nagyobb, akkor S \gt T-t.

- Legyen L az S és T közötti rövidebb karakterlánc hossza. Ellenőrizze, hogy S_i és T_i egyezik-e i=1,2,\dots,L esetén.
- Ha létezik olyan i, hogy S_i \neq T_i, legyen j a legkisebb ilyen i. Hasonlítsa össze az S_j-t és a T_j-t. Ha S_j alfabetikusan kisebb, mint T_j, akkor S \lt T. Ellenkező esetben S \gt T. Az algoritmus itt ér véget.

- Ha nincs olyan i, hogy S_i \neq T_i, hasonlítsa össze S és T hosszát. Ha S rövidebb, mint T, akkor S \lt T. Ha S hosszabb, akkor S \gt T. Az algoritmus itt véget ér.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
S_1 C_1
S_2 C_2
\vdots
S_N C_N

Kimenet

Nyomtassa ki a választ egyetlen sorba.

Korlátozások

- 1 \leq N \leq 100
- Az S_i egy karakterlánc, amely 3 és 16 közötti hosszúságú angol betűkből áll.
- Az S_1, S_2, \dots, S_N mind különböznek egymástól.
- 1 \leq C_i \leq 4229
- C_i egy egész szám.

1. minta bemenet

3
takahashi 2
aoki 6
snuke 5

1. minta kimenet

snuke

A három felhasználó értékelésének összege 13. A nevüket lexikográfiai sorrendbe rendezve aokit, snuke-t, takahashit kapunk, így az aoki 0-t, a snuke-t 1-et, a takahashit pedig 2-t kap.
Mivel 13 \bmod 3 = 1, nyomtasd ki a snuke-ot, akihez az 1-es szám van hozzárendelve.

2. minta bemenet

3
takahashi 2813
takahashixx 1086
takahashix 4229

2. minta kimenet

takahashix

N Az AtCoder felhasználók összegyűltek az AtCoder RPS 2 lejátszására. Az i-edik felhasználó neve S_i, minősítése pedig C_i.
Az AtCoder RPS 2 játék a következőképpen zajlik le:

- Rendelje hozzá a 0, 1, \dots, N - 1 számokat a felhasználókhoz felhasználónevük lexikográfiai sorrendjében.
- Legyen T az N felhasználó értékelésének összege. A T \bmod N számot hozzárendelő felhasználó a győztes.

Nyomtassa ki a nyertes felhasználónevét.

Mi a lexikográfiai sorrend?

A lexikográfiai sorrend, egyszerűen fogalmazva, azt jelenti, hogy "a szavak megjelenése a szótárban". Pontosabban, a kisbetűs angol betűkből álló két különálló S és T karakterlánc sorrendjének meghatározására szolgáló algoritmus a következő:

Itt az "S i-edik karakterét" S_i-ként jelöljük. Ha S lexikográfiailag kisebb, mint T, akkor S \lt T-t írunk, és ha S nagyobb, akkor S \gt T-t írunk.

- Legyen L az S és T közötti rövidebb karakterlánc hossza. Ellenőrizze, hogy S_i és T_i egyezik-e i=1,2,\dots,L esetén.
- Ha létezik olyan i, hogy S_i \neq T_i, legyen j a legkisebb ilyen i. Hasonlítsa össze S_j és T_j. Ha S_j betűrendben kisebb, mint T_j, akkor S \lt T. Ellenkező esetben S \gt T. Az algoritmus itt véget ér.

- Ha nincs olyan i, hogy S_i \neq T_i, hasonlítsuk össze S és T hosszát. Ha S rövidebb, mint T, akkor S \lt T. Ha S hosszabb, akkor S \gt; T. Az algoritmus itt véget ér.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
S_1 C_1
S_2 C_2
\vdots
S_N C_N

Kimenet

Nyomtassa ki a választ egyetlen sorban.

Korlátok

- 1 \leq N \leq 100
- S_i egy karakterlánc, amely kisbetűs angol betűkből áll, 3 és 16 közötti hosszúsággal.
- S_1, S_2, \dots, S_N mind különbözőek.
- 1 \leq C_i \leq 4229
- C_i egész szám.

1. minta bemenet

3
takahashi 2
Aoki 6
snuke 5

1. minta kimenet

snuke

A három felhasználó értékelésének összege 13. A nevüket lexikográfiai sorrendbe rendezve az aoki, snuke, takahashi kapjuk, így az aoki a 0, a snuke az 1, a takahashi pedig a 2.
Mivel 13 \bmod 3 = 1, nyomtassa ki a snuke-ot, aki az 1-es számot kapja.

2. minta bemenet

3
takahashi 2813
Takahashixx 1086
Takahashix 4229

2. minta kimenet

Takahashix


Takahashi egy növényt termeszt. Magassága a csírázás idején 0\,\mathrm{cm}. Ha a csírázás napját 0 napnak tekintjük, akkor a magassága 2^i\,\mathrm{cm} az i. nap éjszakájával nő (0 \le i).
Takahashi magassága H\,\,\mathrm{cm}.
Takahashi minden reggel megméri a magasságát ehhez a növényhez képest.  Keressük meg az első olyan napot, amikor a növény magassága szigorúan nagyobb, mint Takahashi magassága reggel.

Bemenet

A bemenetet a Standard Inputból adjuk meg a következő formátumban:
H

Kimenet

Kinyomtat egy egész számot, amely az első olyan napot jelöli, amikor a növény magassága nagyobb, mint Takahashi magassága reggel.

Korlátozások

- 1 \leq H \leq 10^{9}
- Minden bemeneti érték egész szám.

Minta bemenet 1

54

Minta kimenet 1

6

A növény magassága az 1., 2., 3., 4., 5., 6. nap reggelén 1\,\mathrm{cm}, 3\,\mathrm{cm}, 7\,\mathrm{cm}, 15\,\mathrm{cm}, 31\,\mathrm{cm}, 63\,\mathrm{cm} lesz. A növény a reggeli 6. napon magasabb lesz, mint Takahashi, így a 6. nyomtatás.

Minta bemenet 2

7

Minta kimenet 2

4

A növény magassága a 3. nap reggelén 7\,\mathrm{cm}, a 4. nap reggelén pedig 15\,\mathrm{cm} lesz. A növény a 4. nap reggelén magasabb lesz, mint Takahashi, ezért nyomtassa ki a 4-es értéket. Vegyük észre, hogy a 3. nap reggelén a növény ugyanolyan magas, mint Takahashi, de nem magasabb.

Minta bemenet 3

262144

Minta kimenet 3

19

Takahashi növényt nevel. Csírázáskori magassága 0\,\mathrm{cm}. Ha a csírázás napját 0. napnak tekintjük, magassága 2^i\,\mathrm{cm} nap i nappal (0 \le i) növekszik.
Takahashi magassága H\,\mathrm{cm}.
Takahashi minden reggel ehhez a növényhez méri a magasságát. Keresse meg az első napot úgy, hogy a növény magassága szigorúan nagyobb, mint Takahashi reggeli magassága.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
H

Kimenet

Nyomtasson ki egy egész számot, amely az első napot reprezentálja úgy, hogy a növény magassága nagyobb legyen, mint Takahashi reggeli magassága.

Korlátozások

- 1 \leq H \leq 10^{9}
- Minden bemeneti érték egész szám.

1. minta bemenet

54

1. minta kimenet

6

A növény magassága az 1., 2., 3., 4., 5., 6. nap reggelén 1\,\mathrm{cm}, 3\,\mathrm{cm}, 7\,\mathrm{cm}, 15,\mathrm{cm} lesz.. ,\mathrm{cm}, 31\,\mathrm{cm}, 63\,\mathrm{cm}. A növény a 6. napon reggel magasabb lesz, mint Takahashi, ezért nyomtasson 6-ot.

2. minta bemenet

7

2. minta kimenet

4

A növény magassága 7\,\mathrm{cm} lesz a 3. nap reggelén és 15\,\mathrm{cm} a 4. napon reggel. A növény a 4. nap reggelén magasabb lesz, mint Takahashi, ezért nyomtasson 4-et Vegye figyelembe, hogy a 3. nap reggelén a növény olyan magas, mint Takahashi, de nem magasabb.

Minta bemenet 3

262144

3. minta kimenet

19

Takahashi növényt termeszt. Magassága csírázáskor 0\,\mathrm{cm}. A csírázás napját 0. napnak tekintve magassága 2^i\,\mathrm{cm} nappal i éjjel (0 \le i) nő.
Takahasi magassága H\,\mathrm{cm}.
Takahashi minden reggel méri magasságát ezzel a növénykel.  Keresse meg az első napot úgy, hogy a növény magassága szigorúan nagyobb legyen, mint Takahasi magassága reggel.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
H

Hozam

Nyomtasson ki egy egész számot, amely az első napot jelöli úgy, hogy a növény magassága nagyobb legyen, mint Takahasi magassága reggel.

Korlátok

- 1 \leq H \leq 10^{9}
- Minden bemeneti érték egész szám.

1. minta bemenet

54

Minta output: 1

6

A növény magassága az 1., 2., 3., 4., 5., 6. nap reggelén rendre 1\,\mathrm{cm}, 3\,\mathrm{cm}, 7\,\mathrm{cm}, 15\,\mathrm{cm}, 31\,\mathrm{cm}, 63\,\mathrm{cm}. A növény magasabb lesz, mint Takahashi a reggeli 6. napon, így nyomtasson 6-ot.

2. minta bemenet

7

2. mintakimenet

4

A növény magassága 7\,\mathrm{cm} lesz a 3. nap reggelén és 15\,\mathrm{cm} a 4. nap reggelén. A növény a 4. nap reggelén magasabb lesz, mint Takahashi, így nyomtassa ki a 4. Ne feledje, hogy a 3. nap reggelén a növény olyan magas, mint Takahashi, de nem magasabb.

3. minta bemenet

262144

Minta kimenet 3

19


Takahashi és Aoki N kártyával játszanak. Az i-edik kártya elülső oldalára A_i, a hátoldalára pedig B_i van írva. Kezdetben az N kártyákat lerakják az asztalra. Mivel Takahashi megy először, a két játékos felváltva hajtja végre a következő műveletet:

- Válasszon ki egy pár kártyát az asztalról úgy, hogy vagy az elülső oldalukon lévő számok, vagy a hátoldalukon lévő számok azonosak legyenek, és vegye le ezt a két kártyát az asztalról. Ha nincs ilyen kártyapár, a játékos nem tudja végrehajtani a műveletet.

Az a játékos veszít, aki először nem tudja végrehajtani a műveletet, és a másik játékos nyer.
Határozza meg, ki nyer, ha mindkét játékos optimálisan játszik.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Kimenet

Nyomtasd ki a Takahashit, ha Takahashi nyer, ha mindkét játékos optimálisan játszik, Aoki pedig egyébként.

Korlátozások

- 1 \leq N \leq 18
- 1 \leq A_i, B_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

5
1 9
2 5
4 9
1 4
2 5

1. minta kimenet

Aoki

Ha Takahashi először eltávolítja

-
az első és a harmadik lap: Aoki nyerhet a második és az ötödik kártya eltávolításával.

-
az első és a negyedik lap: Aoki nyerhet a második és ötödik kártya eltávolításával.

-
a második és ötödik lap: Aoki nyerhet az első és a harmadik kártya eltávolításával.

Ez az egyetlen három kártyapár, amelyet Takahashi az első lépésében eltávolíthat, és Aoki minden esetben nyerhet. Ezért a válasz Aoki.

2. minta bemenet

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

2. minta kimenet

Takahashi

Takahashi és Aoki N kártyákkal játszanak. Az i-edik kártya elülső oldalára A_i van írva, a hátoldalára pedig B_i van írva. Kezdetben az N kártyákat az asztalra helyezik. Mivel Takahashi megy először, a két játékos felváltva hajtja végre a következő műveletet:

- Válasszon ki egy pár kártyát az asztalról úgy, hogy vagy az elülső oldalán lévő számok azonosak legyenek, vagy a hátoldalukon lévő számok azonosak legyenek, és távolítsa el ezt a két kártyát az asztalról. Ha nincs ilyen kártyapár, a játékos nem tudja végrehajtani a műveletet.

Az a játékos, aki elsőként nem tudja végrehajtani a műveletet, veszít, és a másik játékos nyer.
Határozza meg, ki nyer, ha mindkét játékos optimálisan játszik.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Hozam

Nyomtassa ki a Takahashit, ha Takahashi nyer, amikor mindkét játékos optimálisan játszik, és Aoki egyébként.

Korlátok

- 1 \leq N \leq 18
- 1 \leq A_i, B_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

5
1 9
2 5
4 9
1 4
2 5

1. Minta kimenet

Aoki

Ha Takahashi először eltávolítja

-
az első és a harmadik lap: Aoki nyerhet a második és ötödik kártya eltávolításával.

-
az első és a negyedik lap: Aoki nyerhet a második és ötödik kártya eltávolításával.

-
a második és ötödik lap: Aoki nyerhet az első és a harmadik kártya eltávolításával.

Ez az egyetlen három pár kártya, amit Takahashi az első lépésével eltávolíthat, és Aoki minden esetben nyerhet. Ezért a válasz Aoki.

2. minta bemenet

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

2. minta kimenet

Takahasi

Takahashi és Aoki N kártyával játszanak. Az i-edik kártya elülső oldalára A_i, a hátoldalára pedig B_i van írva. Kezdetben az N kártyákat lerakják az asztalra. Mivel Takahashi megy először, a két játékos felváltva hajtja végre a következő műveletet:

- Válasszon ki egy pár kártyát az asztalról úgy, hogy vagy az elülső oldalukon lévő számok, vagy a hátoldalukon lévő számok azonosak legyenek, és távolítsa el ezt a két kártyát az asztalról. Ha nincs ilyen kártyapár, a játékos nem tudja végrehajtani a műveletet.

Az a játékos veszít, aki először nem tudja végrehajtani a műveletet, és a másik játékos nyer.
Határozza meg, ki nyer, ha mindkét játékos optimálisan játszik.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Kimenet

Nyomtasd ki a Takahashit, ha Takahashi nyer, ha mindkét játékos optimálisan játszik, Aoki pedig egyébként.

Korlátozások

- 1 \leq N \leq 18
- 1 \leq A_i, B_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

5
1 9
2 5
4 9
1 4
2 5

1. minta kimenet

Aoki

Ha Takahashi először eltávolítja

-
az első és a harmadik lap: Aoki nyerhet a második és az ötödik kártya eltávolításával.

-
az első és a negyedik lap: Aoki nyerhet a második és ötödik kártya eltávolításával.

-
a második és ötödik lap: Aoki nyerhet az első és a harmadik kártya eltávolításával.

Ez az egyetlen három kártyapár, amit Takahashi az első lépésében eltávolíthat, és Aoki minden esetben nyerhet. Ezért a válasz Aoki.

2. minta bemenet

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

2. minta kimenet

Takahashi


Takahashinak N kártyája van az "AtCoder Magics" kártyajátékból. Az i-edik kártya neve i. Minden kártyának két paramétere van: erősség és költség. Az i kártya erőssége A_i és költsége C_i.
Nem szereti a gyenge lapokat, ezért eldobja azokat. Pontosabban, addig ismétli a következő műveletet, amíg az már nem hajtható végre:

- Válasszon ki két x és y kártyát úgy, hogy A_x > A_y és C_x < C_y. Dobja el a kártyát y.

Bizonyítható, hogy a hátralévő kártyák halmaza, amikor a műveletek már nem hajthatók végre, egyértelműen meghatározott. Keresse meg ezt a kártyakészletet.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 C_1
A_2 C_2
\vdots
A_N C_N

Kimenet

Legyen m kártya, i_1, i_2, \dots, i_m kártya, növekvő sorrendben. Nyomtassa ki ezeket a következő formátumban:
m
i_1 i_2 \cdots i_m

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i, C_i \leq 10^9
- Az A_1, A_2, \dots, A_N mind különböznek egymástól.
- A C_1, C_2, \dots, C_N mind különböznek egymástól.
- Minden bemeneti érték egész szám.

Mintabemenet 1

3
2 4
1 1
3 2

Mintakimenet 1

2
2 3

Az 1-es és 3-as lapokra fókuszálva A_1 < A_3 és C_1 > C_3 van, tehát az 1. kártya eldobható.
További műveletek nem hajthatók végre. Ezen a ponton a 2. és 3. kártya marad, ezért nyomtassa ki őket.

Mintabevitel 2

5
1 1
10 2
100 3
1000 4
10000 5

Mintakimenet 2

5
1 2 3 4 5

Ebben az esetben egyetlen kártya sem dobható el.

Mintabemenet 3

6
32 101
65 78
2 29
46 55
103 130
52 40

Mintakimenet 3

4
2 3 5 6

Takahashinak N kártyája van az "AtCoder Magics" kártyajátékból. Az i-edik kártya neve i. Minden kártyának két paramétere van: erősség és költség. Az i kártya erőssége A_i és költsége C_i.
Nem szereti a gyenge lapokat, ezért eldobja azokat. Pontosabban, addig ismétli a következő műveletet, amíg az már nem hajtható végre:

- Válasszon ki két x és y kártyát úgy, hogy A_x > A_y és C_x < C_y. Dobja el a kártyát y.

Bizonyítható, hogy a hátralévő kártyák halmaza, amikor a műveletek már nem hajthatók végre, egyértelműen meghatározott. Keresse meg ezt a kártyakészletet.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 C_1
A_2 C_2
\vdots
A_N C_N

Kimenet

Legyen m kártya, i_1, i_2, \dots, i_m kártya, növekvő sorrendben. Nyomtassa ki ezeket a következő formátumban:
m
i_1 i_2 \cdots i_m

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i, C_i \leq 10^9
- Az A_1, A_2, \dots, A_N mind különböznek egymástól.
- A C_1, C_2, \dots, C_N mind különböznek egymástól.
- Minden bemeneti érték egész szám.

1. minta bemenet

3
2 4
1 1
3 2

1. minta kimenet

2
2 3

Az 1. és 3. kártyára fókuszálva A_1 < A_3 és C_1 > C_3 van, tehát az 1. kártya eldobható.
További műveletek nem hajthatók végre. Ezen a ponton a 2. és 3. kártya marad, ezért nyomtassa ki őket.

2. minta bemenet

5
1 1
10 2
100 3
1000 4
10 000 5

2. minta kimenet

5
1 2 3 4 5

Ebben az esetben egyetlen kártya sem dobható el.

Minta bemenet 3

6
32 101
65 78
2 29
46 55
103 130
52 40

3. minta kimenet

4
2 3 5 6

Takahashi N kártyával rendelkezik az „AtCoder Magics” kártyajátékból. Az i-edik kártyát i kártyának nevezzük. Minden kártyának két paramétere van: erőssége és költsége. Az i. kártya erőssége A_i, költsége pedig C_i.
Nem szereti a gyenge kártyákat, ezért eldobja őket. Konkrétan addig ismétli a következő műveletet, amíg azt már nem tudja elvégezni:

- Válasszon két olyan x és y kártyát, hogy A_x > A_y és C_x < C_y. Dobja el az y kártyát.

Bebizonyítható, hogy a megmaradó kártyák halmaza, amikor a műveleteket már nem lehet elvégezni, egyértelműen meghatározható. Keressük meg ezt a kártyakészletet.

Bemenet

A bemenetet a Standard Inputból adjuk meg a következő formátumban:
N
A_1 C_1
A_2 C_2
\vdots
A_N C_N

Kimenet

Maradjon m kártya, i_1, i_2, \dots, i_m, növekvő sorrendben. Ezeket a következő formátumban írja ki:
m
i_1 i_2 \cdots i_m

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 1 \leq A_i, C_i \leq 10^9
- A_1, A_2, \dots ,A_N mind különbözőek.
- C_1, C_2, \dots ,C_N mind különbözőek.
- Minden bemeneti érték egész szám.

Minta bemenet 1

3
2 4
1 1
3 2

Minta kimenet 1

2
2 3

Az 1. és 3. lapra összpontosítva megállapíthatjuk, hogy A_1 < A_3 és C_1 > C_3, tehát az 1. lap eldobható.
További műveletek nem végezhetők. Ezen a ponton a 2. és a 3. kártya marad, így azokat ki kell nyomtatni.

Minta bemenet 2

5
1 1
10 2
100 3
1000 4
10000 5

Minta kimenet 2

5
1 2 3 4 5

Ebben az esetben egyetlen kártyát sem lehet eldobni.

Minta bemenet 3

6
32 101
65 78
2 29
46 55
103 130
52 40

Minta kimenet 3

4
2 3 5 6


Az AtCoder háttérképének mintázata az xy-síkon a következőképpen ábrázolható:

-
A síkot a következő három típusú vonal osztja fel:

-
x = n (ahol n egész szám)

-
y = n (ahol n páros szám)

-
x + y = n (ahol n páros szám)

-
Minden régió feketére vagy fehérre van festve. Az egyik vonal mentén szomszédos bármely két régió különböző színekkel van festve.

-
A (0,5, 0,5) régiót feketére festjük.

A következő ábra a minta egy részét mutatja.

A, B, C, D egész számokat kapjuk. Tekintsünk egy téglalapot, amelynek oldalai párhuzamosak az x és y tengellyel, bal alsó csúcsa (A, B) és jobb felső csúcsa (C, D). Számítsa ki a feketére festett területek területét ezen a téglalapon belül, és nyomtassa ki ennek a területnek a kétszeresét.
Bizonyítható, hogy a kimeneti érték egész szám lesz.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
A B C D

Kimenet

Nyomtassa ki a választ egyetlen sorba.

Korlátozások

- -10^9 \leq A, B, C, D \leq 10^9
- A < C és B < D.
- Minden bemeneti érték egész szám.

Példa bemenet 1

0 0 3 3

Példa kimenet 1

10

Meg kell keresnünk a feketére festett terület területét a következő négyzeten belül:

A terület 5, ezért nyomtassa ki ennek az értéknek a kétszeresét: 10.

Példa bemenet 2

-1 -2 1 3

Példa kimenet 2

11

A terület 5,5, ami nem egész szám, de a kimeneti érték egész szám.

Példa bemenet 3

-1000000000 -1000000000 1000000000 1000000000

Példa kimenet 3

400000000000000000

Ez a helyzet a legnagyobb téglalapnál, ahol a kimenet még mindig belefér egy 64 bites előjelű egész számba.

Az AtCoder háttérképének mintája az xy-síkon a következőképpen ábrázolható:

-
A síkot a következő három típusú vonal osztja fel:

-
x = n (ahol n egész szám)

-
y = n (ahol n páros szám)

-
x + y = n (ahol n páros szám)

-
Minden régió feketére vagy fehérre van festve. Az egyik vonal mentén szomszédos bármely két régió különböző színekkel van festve.

-
A (0,5, 0,5) tartományt feketére festjük.

A következő ábra a minta egy részét mutatja.

Adott egész számok A, B, C, D. Tekintsünk egy téglalapot, amelynek oldalai párhuzamosak az x és y tengellyel, bal alsó csúcsa (A, B) és jobb felső csúcsa (C, D). Számítsa ki a feketére festett területek területét ezen a téglalapon belül, és nyomtassa ki ennek a területnek a kétszeresét.
Bizonyítható, hogy a kimeneti érték egész szám lesz.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
A B C D

Kimenet

Nyomtassa ki a választ egyetlen sorba.

Korlátozások

- -10^9 \leq A, B, C, D \leq 10^9
- A < C és B < D.
- Minden bemeneti érték egész szám.

1. minta bemenet

0 0 3 3

1. minta kimenet

10

Meg kell keresnünk a feketére festett terület területét a következő négyzeten belül:

A terület 5, ezért nyomtassa ki ennek az értéknek a kétszeresét: 10.

2. minta bemenet

-1-213

2. minta kimenet

11

A terület 5,5, ami nem egész szám, de a kimeneti érték egész szám.

Minta bemenet 3

-1000000000 -1000000000 1000000000 1000000000

3. minta kimenet

400000000000000000

Ez a helyzet a legnagyobb téglalap esetében, ahol a kimenet még mindig belefér egy 64 bites előjelű egész számba.

Az AtCoder háttérképének mintája az xy síkon a következőképpen ábrázolható:

-
A síkot a következő három vonaltípus osztja:

-
x = n (ahol n egész szám)

-
y = n (ahol n páros szám)

-
x + y = n (ahol n páros szám)

-
Minden régió fekete vagy fehérre festett. Bármely két, ezen vonalak mentén szomszédos régió különböző színekkel van festve.

-
A (0,5, 0,5) tartományt tartalmazó régió fekete színű.

Az alábbi ábrán a minta egy része látható.

Az A, B, C, D egész számokat kapjuk. Vegyünk egy téglalapot, amelynek oldalai párhuzamosak az x és y tengellyel, bal alsó csúcsa (A, B) és jobb felső csúcsa (C, D). Számítsa ki a téglalapon belül feketére festett területek területét, és nyomtassa ki ennek a területnek a kétszeresét.
Bizonyítható, hogy a kimeneti érték egész szám lesz.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
A B C D

Hozam

Nyomtassa ki a választ egyetlen sorban.

Korlátok

- -10^9 \leq A, B, C, D \leq 10^9
- A < C és B < D.
- Minden bemeneti érték egész szám.

1. minta bemenet

0 0 3 3

1.minta kimenet

10

A feketére festett terület területét a következő négyzeten belül találjuk meg:

A terület 5, ezért nyomtassa ki ennek az értéknek a kétszeresét: 10.

2. minta bemenet

-1 -2 1 3

2. minta kimenet

11

A terület 5,5, ami nem egész szám, de a kimeneti érték egész szám.

3. minta bemenet

-1000000000 -1000000000 1000000000 1000000000

3.minta kimenet

4000000000000000000

Ez a helyzet a legnagyobb téglalap esetében, ahol a kimenet még mindig illeszkedik egy 64 bites előjeles egész számba.


Ez egy interaktív probléma (ahol a programod interakcióba lép a bíróval a bemeneten és a kimeneten keresztül).
Adunk egy N pozitív egész számot, valamint L és R egész számokat úgy, hogy 0 \leq L \leq R < 2^N. A bírónak van egy rejtett sorozata A = (A_0, A_1, \dots, A_{2^N-1}), amely 0 és 99 közötti egész számokból áll.
A cél az, hogy megtaláljuk a maradékot, ha az A_L + A_{L+1} + \dots + A_R osztva 100-zal. Az A sorozat elemeinek értékét azonban közvetlenül nem ismerheti meg. Ehelyett megkérheti a bírót, hogy következő kérdés:

- Válasszon nemnegatív i és j egész számokat úgy, hogy 2^i(j+1) \leq 2^N. Legyen l = 2^i j és r = 2^i (j+1) - 1. Kérd meg a maradékot, ha A_l + A_{l+1} + \dots + A_r osztva 100-zal.

Legyen m a maradék meghatározásához szükséges kérdések minimális száma, amikor az A_L + A_{L+1} + \dots + A_R elosztjuk 100-zal bármely A sorozat esetén. Ezt a maradékot m kérdésen belül kell megtalálnia.

Bemenet és Kimenet

Ez egy interaktív probléma (ahol a programod interakcióba lép a bíróval a bemeneten és a kimeneten keresztül).
Először olvassa el az N, L és R egész számokat a szabványos bevitelből:
N L R

Ezután ismételje meg a kérdéseket, amíg meg nem tudja határozni a maradékot, amikor az A_L + A_{L+1} + \dots + A_R osztva 100-zal. Minden kérdést a következő formátumban kell kinyomtatni:
? i j

Itt i-nek és j-nek meg kell felelnie a következő megkötéseknek:

- i és j nem negatív egész számok.
- 2^i(j+1) \leq 2^N

A kérdésre adott választ a következő formátumban adjuk meg a szabványos bemenetről:
T

Itt T a válasz arra a kérdésre, amely a maradék, ha A_l + A_{l+1} + \dots + A_r elosztjuk 100-zal, ahol l = 2^i j és r = 2^i (j+1) - 1.
Ha i és j nem teljesítik a megszorításokat, vagy ha a kérdések száma meghaladja az m-t, akkor T -1 lesz.
Ha a bíró -1-et ad vissza, a programod már hibásnak minősül. Ebben az esetben azonnal fejezze be a programot.
Miután meghatározta a maradékot, amikor az A_L + A_{L+1} + \dots + A_R osztva 100-zal, nyomtassa ki a maradék S részt a következő formátumban, és azonnal fejezze be a programot:
! S

Bemenet és Kimenet

Ez egy interaktív probléma (ahol a programod interakcióba lép a bíróval a bemeneten és a kimeneten keresztül).
Először olvassa el az N, L és R egész számokat a szabványos bevitelből:
N L R

Ezután ismételje meg a kérdéseket, amíg meg nem tudja határozni a maradékot, amikor az A_L + A_{L+1} + \dots + A_R osztva 100-zal. Minden kérdést a következő formátumban kell kinyomtatni:
? i j

Itt i-nek és j-nek meg kell felelnie a következő megkötéseknek:

- i és j nem negatív egész számok.
- 2^i(j+1) \leq 2^N

A kérdésre adott választ a következő formátumban adjuk meg a szabványos bemenetről:
T

Itt T a válasz arra a kérdésre, amely a maradék, ha A_l + A_{l+1} + \dots + A_r elosztjuk 100-zal, ahol l = 2^i j és r = 2^i (j+1) - 1.
Ha i és j nem teljesítik a megszorításokat, vagy ha a kérdések száma meghaladja az m-t, akkor T -1 lesz.
Ha a bíró -1-et ad vissza, a programod már hibásnak minősül. Ebben az esetben azonnal fejezze be a programot.
Miután meghatározta a maradékot, amikor az A_L + A_{L+1} + \dots + A_R osztva 100-zal, nyomtassa ki a maradék S részt a következő formátumban, és azonnal fejezze be a programot:
! S

Korlátozások

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Minden bemeneti érték egész szám.

Ez egy interaktív probléma (ahol a programod bemenet és kimenet útján kommunikál a bíróval).
Adott egy pozitív egész szám N, valamint az L és R egész számok, ahol 0 \leq L \leq R < 2^N. A bíró egy rejtett sorozatot tartalmaz, A = (A_0, A_1, \dots, A_{2^N-1}), amely az 0-99 közötti egész számokból áll.
Célod, hogy megtaláld az A_L + A_{L+1} + \dots + A_R 100-zal való osztási maradékát. Azonban nem ismerheted közvetlenül a sorozat A elemeinek értékét. Ehelyett a következő kérdést teheted fel a bírónak:

- Válassz nemnegatív egész számokat i és j úgy, hogy 2^i(j+1) \leq 2^N. Legyen l = 2^i j és r = 2^i (j+1) - 1. Kérd meg a maradékot, amikor A_l + A_{l+1} + \dots + A_r 100-zal van osztva.

Legyen m a minimális számú kérdés, amely szükséges az A_L + A_{L+1} + \dots + A_R 100-zal való osztásának maradékának meghatározásához bármely sorozat A esetében. Ezt a maradékot legfeljebb m kérdéssel kell meghatároznod.

Bemenet és Kimenet

Ez egy interaktív probléma (ahol a programod bemenet és kimenet útján kommunikál a bíróval).
Először olvasd be az N, L és R egészeket szabványos bemenetről:
N L R

Ezután kérdések feltevésével kell meghatároznod az A_L + A_{L+1} + \dots + A_R 100-zal való osztási maradékát. Mindegyik kérdést a következő formátumban kell kiírni:
? i j

Itt i és j a következő feltételeknek kell, hogy megfeleljenek:

- i és j nemnegatív egész számok.
- 2^i(j+1) \leq 2^N

A kérdésre adott válasz a következő formátumban érkezik szabványos bemenetről:
T

Itt T a kérdésre adott válasz, amely az A_l + A_{l+1} + \dots + A_r 100-zal való osztásának maradéka, ahol l = 2^i j és r = 2^i (j+1) - 1.
Ha i és j nem felelnek meg a feltételeknek, vagy ha a kérdések száma meghaladja m-et, akkor T -1 lesz.
Ha a bíró -1-et ad vissza, a programod már hibásnak számít. Ebben az esetben azonnal zárd le a programot.
Amint meghatároztad az A_L + A_{L+1} + \dots + A_R 100-zal való osztásának maradékát, írd ki a maradékot S a következő formátumban, és azonnal fejezd be a programot:
! S

Bemeneti és Kimeneti Feltételek

Ez egy interaktív probléma (ahol a programod bemenet és kimenet útján kommunikál a bíróval).
Először olvasd be az N, L és R egészeket Standard Inputból:
N L R

Ezután kérdések feltevésével kell meghatároznod az A_L + A_{L+1} + \dots + A_R 100-zal való osztási maradékát. Mindegyik kérdést a következő formátumban kell kiírni:
? i j

Itt i és j a következő feltételeknek kell, hogy megfeleljenek:

- i és j nemnegatív egész számok.
- 2^i(j+1) \leq 2^N

A kérdésre adott válasz a következő formátumban érkezik szabványos bemenetről:
T

Itt T a kérdésre adott válasz, amely az A_l + A_{l+1} + \dots + A_r 100-zal való osztásának maradéka, ahol l = 2^i j és r = 2^i (j+1) - 1.
Ha i és j nem felelnek meg a feltételeknek, vagy ha a kérdések száma meghaladja m-et, akkor T -1 lesz.
Ha a bíró -1-et ad vissza, a programod már hibásnak számít. Ebben az esetben azonnal zárd le a programot.
Amint meghatároztad az A_L + A_{L+1} + \dots + A_R 100-zal való osztásának maradékát, írd ki a maradékot S a következő formátumban, és azonnal fejezd be a programot:
! S

Korlátozások

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Minden bemenet egy egész szám.

Ez egy interaktív probléma (ahol a program bemeneten és kimeneten keresztül kommunikál a bíróval).
Kapunk egy pozitív N egész számot és L és R egész számokat úgy, hogy 0 \leq L \leq R < 2^N. A bírónak van egy rejtett A = (A_0, A_1, \dots, A_{2^N-1}) sorozata, amely 0 és 99 közötti egész számokból áll.
A cél az, hogy megtalálja a maradékot, ha A_L + A_{L+1} + \dots + A_R osztva van 100-zal. Az A sorozat elemeinek értékeit azonban nem ismerheti közvetlenül. Ehelyett felteheti a bírónak a következő kérdést:

- Válasszon i és j nemnegatív egész számokat úgy, hogy 2^i(j+1) \leq 2^N. Legyen l = 2^i j és r = 2^i (j+1) - 1. Kérje a maradékot, ha A_l + A_{l+1} + \dots + A_r osztva van 100-zal.

Legyen m a maradék meghatározásához szükséges kérdések minimális száma, ha A_L + A_{L+1} + \dots + A_R osztva 100-zal bármely A sorozatra. Ezt a maradékot m kérdésen belül kell megtalálnod.

Bemenet és kimenet

Ez egy interaktív probléma (ahol a program bemeneten és kimeneten keresztül kommunikál a bíróval).
Először olvassa be az N, L és R egész számokat a Standard bemenetből:
N L R

Ezután ismételje meg a kérdések feltevését, amíg meg nem tudja határozni a maradékot, amikor A_L + A_{L+1} + \dots + A_R osztva van 100-zal. Minden kérdést a következő formátumban kell kinyomtatni:
? i j

Itt az i-nek és a j-nek meg kell felelnie a következő korlátozásoknak:

- i és j nemnegatív egész számok.
- 2^i(j+1) \leq 2^N

A kérdésre adott válasz a következő formátumban történik a Standard Inputból:
T

Itt T a válasz a kérdésre, amely a maradék, ha A_l + A_{l+1} + \dots + A_r osztva 100-zal, ahol l = 2^i j és r = 2^i (j+1) - 1.
Ha i és j nem felel meg a megszorításoknak, vagy ha a kérdések száma meghaladja az m-et, akkor T -1 lesz.
Ha a bíró -1-et ad vissza, a program már helytelennek minősül. Ebben az esetben azonnal állítsa le a programot.
Miután meghatározta a maradékot, amikor A_L + A_{L+1} + \dots + A_R osztva van 100-zal, nyomtassa ki a maradék S-t a következő formátumban, és azonnal fejezze be a programot:
! S

Bemenet és kimenet

Ez egy interaktív probléma (ahol a program bemeneten és kimeneten keresztül kommunikál a bíróval).
Először olvassa be az N, L és R egész számokat a Standard bemenetből:
N L R

Ezután ismételje meg a kérdések feltevését, amíg meg nem tudja határozni a maradékot, amikor A_L + A_{L+1} + \dots + A_R osztva van 100-zal. Minden kérdést a következő formátumban kell kinyomtatni:
? i j

Itt az i-nek és a j-nek meg kell felelnie a következő korlátozásoknak:

- i és j nemnegatív egész számok.
- 2^i(j+1) \leq 2^N

A kérdésre adott válasz a következő formátumban történik a Standard Inputból:
T

Itt T a válasz a kérdésre, amely a maradék, ha A_l + A_{l+1} + \dots + A_r osztva 100-zal, ahol l = 2^i j és r = 2^i (j+1) - 1.
Ha i és j nem felel meg a megszorításoknak, vagy ha a kérdések száma meghaladja az m-et, akkor T -1 lesz.
Ha a bíró -1-et ad vissza, a program már helytelennek minősül. Ebben az esetben azonnal állítsa le a programot.
Miután meghatározta a maradékot, amikor A_L + A_{L+1} + \dots + A_R osztva van 100-zal, nyomtassa ki a maradék S-t a következő formátumban, és azonnal fejezze be a programot:
! S

Korlátok

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Minden bemeneti érték egész szám.


Adott egy N hosszúságú A=(A_1,A_2,\dots,A_N) sorozat és egy M hosszúságú B=(B_1,B_2,\dots,B_M) sorozat. Itt A és B minden eleme páronként különböző. Határozzuk meg, hogy a C=(C_1,C_2,\dots,C_{N+M}) sorozat, amely A és B összes elemének növekvő sorrendbe rendezésével jön létre, tartalmaz-e két egymást követő, A-ban szereplő elemet.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M
A_1 A_2 \dots A_N
B_1 B_2 \pontok B_M

Kimenet

Ha C két egymást követő, A-ban szereplő elemet tartalmaz, akkor igen, ellenkező esetben nem.

Korlátozások

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M különbözőek.
- Minden bemeneti érték egész szám.

Minta bemenet 1

3 2
3 2 5
4 1

Minta kimenet 1

Yes

C=(1,2,3,4,5). Mivel az A-ből a 2 és a 3 egymás után szerepel a C-ben, írja ki az Yes.

Minta bemenet 2

3 2
3 1 5
4 2

Minta kimenet 2

No

C = (1,2,3,4,5). Mivel az A-ból nem fordul elő két elem egymás után C-ben, nyomtassa ki a No.

Minta bemenet 3

1 1
1
2

Kimeneti minta 3

No

Kapsz egy N hosszúságú A=(A_1,A_2,\dots,A_N) sorozatot és egy M hosszúságú B=(B_1,B_2,\dots,B_M) sorozatot. Itt A és B minden eleme páronként különbözik. . Határozza meg, hogy az A és B összes elemének növekvő sorrendbe rendezésével létrehozott C=(C_1,C_2,\dots,C_{N+M}) sorozat tartalmaz-e két egymást követő A-ban megjelenő elemet.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Kimenet

Ha C két egymást követő elemet tartalmaz, amelyek A-ban szerepelnek, nyomtasson Igen; ellenkező esetben a Nyomtasson Nem.

Korlátozások

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- Az A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M különböznek egymástól.
- Minden bemeneti érték egész számok.

1. minta bemenet

3 2
3 2 5
4 1

1. minta kimenet

Yes

C=(1,2,3,4,5). Mivel A-ból 2 és 3 egymás után fordul elő C-ben, nyomtassa ki az Igen értéket.

2. minta bemenet

3 2
3 1 5
4 2

2. minta kimenet

No

C=(1,2,3,4,5). Mivel A-ból nem fordul elő két elem egymás után C-ben, a No.

Minta bemenet 3

1 1
1
2

3. minta kimenet

No

Egy N hosszúságú A=(A_1,A_2,\dots,A_N) sorozatot és egy M hosszúságú B=(B_1,B_2,\dots,B_M) sorozatot kapunk. Itt A és B minden eleme páronként elkülönül. . Állapítsa meg, hogy az A és B összes elemének növekvő sorrendbe rendezésével kapott C=(C_1,C_2,\dots,C_{N+M})sorozat tartalmaz-e két egymást követő elemet, amelyek A-ban szerepelnek.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M
A_1 A_2 \ dots A_N
B_1 B_2 \dots B_M

Kimenet

Ha C két egymást követő elemet tartalmaz, amelyek A-ban szerepelnek, nyomtasson Yes; ellenkező esetben nyomtasson No.

Korlátozások

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M különbözőek.
- Minden bemeneti érték egész szám.

Minta bemenet 1

3 2
3 2 5
4 1

Minta kimenet 1

Yes

C=(1,2,3,4,5). Mivel a 2 és 3 egymást követően fordulnak elő C-ben, amelyek A-ból származnak, nyomtassa ki Yes.

Minta bemenet 2

3 2
3 1 5
4 2

Minta kimenet 2

No

C=(1,2,3,4,5). Mivel A-ból nem fordul elő két elem egymás után C-ben, No

Minta bemenet 3

1 1
1
2

Minta kimenet 3

No


Van egy N \times N-es rács, ahol az i-edik sorból felülről és a j-edik oszlopból balra lévő cella az N \times (i-1) + j egész számot tartalmazza.
T fordulón keresztül egész számokat jelentenek be. Az i-edik fordulóban az A_i egész számot jelentik be, és az A_i-t tartalmazó cellát megjelölik. Határozd meg, melyik fordulóban érünk el először Bingót. Ha Bingót nem érünk el a T forduló alatt, írd ki -1-et.
Itt a Bingó elérése azt jelenti, hogy legalább az alábbi feltételek egyikének eleget teszünk:

- Létezik olyan sor, amelyben mind az N cella meg van jelölve.
- Létezik olyan oszlop, amelyben mind az N cella meg van jelölve.
- Létezik olyan átlós vonal (bal felső saroktól jobb alsó sarokig vagy jobb felső saroktól bal alsó sarokig), amelyen mind az N cella meg van jelölve.

Bemenet

A bemenet a következő formátumban érkezik a szabványos bemenetről:
N T
A_1 A_2 \ldots A_T

Kimenet

Ha Bingót érünk el a T forduló alatt, írd ki a forduló számát, amikor először elérjük a Bingót; ellenkező esetben írd ki -1-et.

Korlátozások

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j ha i \neq j.
- Minden bemeneti érték egész szám.

Bemeneti minta 1

3 5
5 1 8 9 7

Kimeneti minta 1

4

A rács állapota a következőképpen változik. Bingót először a 4. fordulóban érünk el.

Bemeneti minta 2

3 5
4 2 9 7 5

Kimeneti minta 2

-1

A Bingót nem érjük el az öt forduló alatt, így írd ki -1-et.

Bemeneti minta 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Kimeneti minta 3

9

Van egy N \times N rács, ahol a felső i-edik sorban lévő cella és a bal oldali j-edik oszlop tartalmazza az N \times (i-1) + j egész számot.
A T fordulók felett egész számok kerülnek bejelentésre. Az i fordulóban bejelenti az egész A_i, és megjelöli a A_i tartalmazó cellát. Határozza meg azt a fordulatot, amelyen a bingót először éri el. Ha a bingó nem érhető el T körökön belül, nyomtassa ki a -1 értéket.
Itt a bingó elérése azt jelenti, hogy az alábbi feltételek közül legalább egyet teljesíteni kell:

- Létezik egy sor, amelyben az összes N cella meg van jelölve.
- Létezik egy oszlop, amelyben az összes N cella meg van jelölve.
- Létezik egy átlós vonal (a bal felső saroktól a jobb alsó vagy a jobb felső saroktól a bal alsó sarokig), amelyben az összes N cella meg van jelölve.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N T
A_1 A_2 \ldots A_T

Hozam

Ha a bingót T körön belül érik el, nyomtassa ki azt a körszámot, amelyen a bingót először érte el; ellenkező esetben nyomtassa ki a -1 értéket.

Korlátok

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j if i \neq j.
- Minden bemeneti érték egész szám.

1. minta bemenet

3 5
5 1 8 9 7

1. minta kimenet

4

A rács állapota a következőképpen változik. A bingó először a 4-es kanyarban érhető el.

2. minta bemenet

3 5
4 2 9 7 5

2. minta kimenet

-1

A bingó nem érhető el öt fordulaton belül, ezért nyomtasson -1-et.

3. minta bemenet

4 12
13 9 6 5 2 7 16 14 8 3 10 11

3. minta kimenet

9

Létezik egy N \x N rács, ahol az i-edik sor cellája felülről és a j-edik oszlop balról az N \times (i-1) + j egész számot tartalmazza.
A T fordulatok felett egész számok kerülnek bemondásra. Az i körben az A_i egész szám kerül bemondásra, és az A_i-t tartalmazó cella megjelölésre kerül. Határozza meg azt a fordulatot, amelyen a Bingót először eléri. Ha a Bingót nem éri el a T körön belül, nyomtasson -1-et.
Itt a bingó elérése azt jelenti, hogy az alábbi feltételek közül legalább egyet teljesíteni kell:

- Létezik egy sor, amelyben minden N cella meg van jelölve.
- Létezik egy oszlop, amelyben minden N cella meg van jelölve.
- Létezik egy átlós vonal (a bal felsőtől a jobb alsóig vagy a jobb felsőtől a bal alsóig), amelyben minden N cella meg van jelölve.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N T
A_1 A_2 \ldots A_T

Kimenet

Ha a Bingót T körön belül sikerült elérni, nyomtassa ki azt a körszámot, amelyen a Bingót először elérte; ellenkező esetben nyomtat -1.

Korlátozások

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j if i \neq j.
- Minden bemeneti érték egész szám.

1. minta bemenet

3 5
5 1 8 9 7

1. minta kimenet

4

A rács állapota a következőképpen változik. A bingót először a 4. kanyarban érik el.

2. minta bemenet

3 5
4 2 9 7 5

2. minta kimenet

-1

A bingó nem érhető el öt körön belül, ezért nyomtasson -1-et.

Minta bemenet 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

3. minta kimenet

9


Takahashi tortáját valaki megette. Három gyanúsított van: az 1., a 2. és a 3. személy.
Két tanú van, Ringo és Snuke. Ringo úgy emlékszik, hogy nem A személy a tettes, Snuke pedig úgy emlékszik, hogy nem B személy a tettes.
Határozza meg, hogy a két tanú emlékei alapján egyértelműen azonosítható-e a tettes. Ha a tettes azonosítható, írd ki a személy számát.

Bemenet

A bemenetet a Standard Inputból adjuk meg a következő formátumban:
A B

Kimenet

Ha a két tanú emlékei alapján egyértelműen azonosítható a tettes, akkor írja ki a személy számát, ellenkező esetben írja ki a -1 értéket.

Korlátozások

- 1 \leq A, B \leq 3
- Minden bemeneti érték egész szám.

Minta bemenet 1

1 2

Minta kimenet 1

3

A két tanú emlékeiből megállapítható, hogy a 3. személy a tettes.

Minta bemenet 2

1 1

Minta kimenet 2

-1

A két tanú emlékei alapján nem lehet megállapítani, hogy a 2. vagy a 3. személy a tettes. Ezért nyomtasson -1-et.

Minta bemenet 3

3 1

Minta kimenet 3

2

Takahashi tortáját megette valaki. Három gyanúsított van: 1. személy, 2. személy és 3. személy.
Két tanú van, Ringo és Snuke. Ringo emlékszik, hogy A személy nem a tettes, és Snuke emlékszik arra, hogy B nem a tettes.
Határozza meg, hogy a két tanú emlékei alapján egyértelműen azonosítható-e a tettes. Ha a tettes azonosítható, nyomtassa ki a személy számát.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
A B

Kimenet

Ha a két tanú emlékei alapján a tettes egyértelműen azonosítható, nyomtassa ki a személy számát; ellenkező esetben nyomtat -1.

Korlátozások

- 1 \leq A, B \leq 3
- Minden bemeneti érték egész szám.

Példa bemenet 1

1 2

Példa kimenet 1

3

A két tanú emlékei alapján megállapítható, hogy a 3. személy a tettes.

Példa bemenet 2

1 1

Példa kimenet 2

-1

A két tanú emlékei alapján nem állapítható meg, hogy a 2. vagy a 3. személy a tettes. Ezért nyomtasd -1.

Példa bemenet 3

3 1

Példa kimenet 3

2

Valaki megette Takahashi tortáját. Három gyanúsított van: 1. személy, 2. személy és 3. személy.
Két tanú van, Ringo és Snuke. Ringo emlékszik, hogy A személy nem a tettes, és Snuke emlékszik arra, hogy B nem a tettes.
Határozza meg, hogy a két tanú emlékei alapján egyértelműen azonosítható-e a tettes. Ha a tettes azonosítható, nyomtassa ki a személy számát.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
A B

Kimenet

Ha a két tanú emlékei alapján a tettes egyértelműen azonosítható, nyomtassa ki a személy számát; ellenkező esetben nyomtat -1.

Korlátozások

- 1 \leq A, B \leq 3
- Minden bemeneti érték egész szám.

1. minta bemenet

1 2

1. minta kimenet

3

A két tanú emlékei alapján megállapítható, hogy a 3. személy a tettes.

2. minta bemenet

1 1

2. minta kimenet

-1

A két tanú emlékei alapján nem állapítható meg, hogy a 2. vagy a 3. személy a tettes. Ezért nyomtasd -1.

Minta bemenet 3

3 1

3. minta kimenet

2


Adott N intervallum valós szám. Az i-edik (1 \leq i \leq N) intervallum: [l_i, r_i]. Határozzuk meg az (i, j)\,(1 \leq i < j \leq N) párok számát úgy, hogy az i-edik és a j-edik intervallum metszi egymást.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Kimenet

Nyomtassa ki a választ.

Korlátozások

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Minden bemeneti érték egész szám.

Példa bemenet 1

3
1 5
7 8
3 7

Példa kimenet 1

2

A megadott intervallumok: [1,5], [7,8], [3,7]. Ezek között az 1. és 3. intervallum metszi egymást, valamint a 2. és 3. intervallum, így a válasz 2.

Példa bemenet 2

3
3 4
2 5
1 6

Példa kimenet 2

3

Példa bemenet 3

2
1 2
3 4

Példa kimenet 3

0

N valós számintervallumot kap. Az i-edik (1 \leq i \leq N) intervallum [l_i, r_i]. Keresse meg az (i, j)\,(1 \leq i < j \leq N) párok számát úgy, hogy az i-edik és j-edik intervallum metszi egymást.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Hozam

Nyomtassa ki a választ.

Korlátok

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

3
1 5
7 8
3 7

Minta output: 1

2

A megadott intervallumok: [1,5], [7,8], [3,7]. Ezek közül az 1. és 3. intervallumok metszik egymást, valamint a 2. és 3. intervallumok, így a válasz 2.

2. minta bemenet

3
3 4
2 5
1 6

2. mintakimenet

3

3. minta bemenet

2
1 2
3 4

Minta kimenet 3

0

N valós számintervallumot kap. Az i-edik (1 \leq i \leq N) intervallum [l_i, r_i]. Keresse meg az (i, j)\,(1 \leq i < j \leq N) párok számát úgy, hogy az i-edik és j-edik intervallum metszi egymást.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Hozam

Nyomtassa ki a választ.

Korlátok

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

3
1 5
7 8
3 7

1.minta kimenet

2

A megadott intervallumok: [1,5], [7,8], [3,7]. Ezek közül az 1. és 3. intervallumok metszik egymást, valamint a 2. és 3. intervallumok, így a válasz 2.

2. minta bemenet

3
3 4
2 5
1 6

2. minta kimenet

3

3. minta bemenet

2
1 2
3 4

3.minta kimenet

0


Kapsz egy n méretű tömb almát és egy m méretű kapacitás-tömb.
N olyan csomag van, ahol az i-edik csomag apple[i] almát tartalmaz. Van m doboz is, és az i-edik doboz capacity[i] alma.
Adja vissza azt a minimális számú dobozt, amelyet ki kell választania, hogy ezt az n csomag almát dobozokba oszthassa.
Vegye figyelembe, hogy az ugyanabból a csomagból származó almát különböző dobozokba lehet osztani.

Példa 1:

Bemenet: apple = [1,3,2], capacity = [4,3,1,5,2]
Kimenet: 2
Magyarázat: 4-es és 5-ös kapacitású dobozokat fogunk használni.
Lehetőség van az almák szétosztására, mivel a teljes kapacitás nagyobb vagy egyenlő, mint az összes alma száma.

Példa 2:

Bemenet: apple = [5,5,5], capacity = [2,4,2,7]
Kimenet: 4
Magyarázat: Fel kell használnunk az összes dobozt.

Korlátozások:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
A bemenet úgy jön létre, hogy az almacsomagokat újra el lehet osztani dobozokba.

Kap egy n méretű tömbalmát és egy m méretű tömbkapacitást.
N csomag van, ahol az i^th csomag alma[i] almát tartalmaz. Vannak m dobozok is, és az i^th doboz kapacitása [i] alma.
Adja vissza a dobozok minimális számát, amelyet ki kell választania ahhoz, hogy ezt az n csomag almát dobozokba terjessze.
Ne feledje, hogy ugyanabból a csomagból származó alma különböző dobozokba osztható.

1. példa:

Bemenet: apple= [1,3,2], kapacitás = [4,3,1,5,2]
Kimenet: 2
Magyarázat: 4-es és 5-ös kapacitású dobozokat fogunk használni.
Lehetőség van az alma elosztására, mivel a teljes kapacitás nagyobb vagy egyenlő az összes alma számával.

2. példa:

Bemenet: apple= [5,5,5], kapacitás = [2,4,2,7]
Kimenet: 4
Magyarázat: Minden dobozt fel kell használnunk.

Korlátok:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
A bemenet úgy jön létre, hogy az almacsomagokat dobozokba lehet osztani.

Adott egy n méretű alma tömb és egy m méretű tömbkapacitás.
Van n csomag, ahol az i^-edik csomag alma[i] almát tartalmaz. Van m doboz is, és az i^-edik doboz kapacitása kapacitás[i] alma.
Adja vissza a minimálisan kiválasztható dobozok számát, hogy ezeket az n csomag almákat újra szétoszthassuk dobozokba.
Vegyük figyelembe, hogy ugyanabból a csomagból származó almák különböző dobozokba is szétoszthatók.

Példa 1:

Bemenet: apple = [1,3,2], capacity = [4,3,1,5,2]
Kimenet: 2
Magyarázat: Az almát 4 és 5 kapacitású dobozokkal fogjuk használni.
Az almákat úgy lehet elosztani, hogy az összes kapacitás nagyobb vagy egyenlő az összes alma számával.

2. példa:

Bemenet: apple = [5,5,5], capacity = [2,4,2,7]
Kimenet: 4
Magyarázat: Az összes dobozt fel kell használnunk.

Korlátozások:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
A bemenetet úgy generáljuk, hogy az almacsomagok dobozokba történő újraelosztása lehetséges legyen.


Kapsz egy n hosszúságú boldogságtömböt és egy k pozitív egész számot.
n gyermek áll egy sorban, ahol az i^edik gyermeknek van boldogság értéke boldogság[i]. Ebből az n gyerekből k körben k gyereket szeretne kiválasztani.
Minden körben, amikor kiválaszt egy gyereket, az eddig ki nem választott gyerekek boldogságértéke 1-gyel csökken. Vegye figyelembe, hogy a boldogságérték nem válhat negatívvá, és csak akkor csökken, ha pozitív.
Adja vissza a kiválasztott gyerekek boldogságértékeinek maximális összegét, amelyet k gyermek kiválasztásával elérhet.

1. példa:

Bemenet: boldogság = [1,2,3], k = 2
Kimenet: 4
Magyarázat: 2 gyermeket a következő módon választhatunk ki:
- Válassza ki azt a gyermeket, akinek boldogságértéke == 3. A fennmaradó gyermekek boldogságértéke [0,1] lesz.
- Válassza ki azt a gyermeket, akinek boldogságértéke == 1. A fennmaradó gyermek boldogságértéke [0] lesz. Vegye figyelembe, hogy a boldogság értéke nem lehet kisebb 0-nál.
A kiválasztott gyerekek boldogságértékeinek összege 3 + 1 = 4.

2. példa:

Bemenet: boldogság = [1,1,1,1], k = 2
Kimenet: 1
Magyarázat: 2 gyermeket a következő módon választhatunk ki:
- Válasszon ki egy olyan gyermeket, akinek boldogságértéke == 1. A fennmaradó gyermekek boldogságértéke [0,0,0] lesz.
- Válassza ki azt a gyermeket, akinek boldogságértéke == 0. A fennmaradó gyermek boldogságértéke [0,0] lesz.
A kiválasztott gyerekek boldogságértékeinek összege 1 + 0 = 1.

3. példa:

Bemenet: boldogság = [2,3,4,5], k = 1
Kimenet: 5
Magyarázat: 1 gyermeket a következő módon választhatunk ki:
- Válassza ki azt a gyermeket, akinek boldogságértéke == 5. A fennmaradó gyermekek boldogságértéke [1,2,3] lesz.
A kiválasztott gyerekek boldogságértékeinek összege 5.

Korlátozások:

1 <= n == boldogság.hossz <= 2 * 10^5
1 <= boldogság[i] <= 10^8
1 <= k <= n

Kapsz egy n hosszúságú tömbboldogságot és egy k pozitív egész számot.
N gyermek áll egy sorban, ahol az i^-edik gyermeknek happiness[i]. Ebből az n gyermekből k gyermeket szeretne kiválasztani k fordulóban.
Minden fordulóban, amikor kiválaszt egy gyermeket, az eddig ki nem választott összes gyermek boldogságértéke 1-gyel csökken. Figyeljük meg, hogy a boldogságérték nem válhat negatívvá, és csak akkor csökken, ha pozitív.
Adja vissza a kiválasztott gyermekek boldogságértékeinek maximális összegét, amelyet k gyermek kiválasztásával érhet el.

1. példa:

Bemenet: happiness = [1,2,3], k = 2
Kimenet: 4
Magyarázat: 2 gyermeket a következő módon választhatunk ki:
- Válassza ki a gyermeket a boldogságértékkel == 3. A megmaradt gyermekek boldogságértéke [0,1] lesz.
- Válassza ki a gyermeket a boldogságértékkel == 1. A megmaradt gyermek boldogságértéke [0] lesz. Ne feledje, hogy a boldogság értéke nem lehet kisebb, mint 0.
A kiválasztott gyermekek boldogságértékeinek összege 3 + 1 = 4.

2. példa:

Bemenet: happiness = [1,1,1,1], k = 2
Kimenet: 1
Magyarázat: 2 gyermeket a következő módon választhatunk ki:
- Válasszon olyan gyermeket, akinek boldogságértéke == 1. A megmaradt gyermekek boldogságértéke [0,0,0] lesz.
- Válassza ki a gyermeket a boldogság értékével == 0. A fennmaradó gyermek boldogságértéke [0,0] lesz.
A kiválasztott gyermekek boldogságértékeinek összege 1 + 0 = 1.

3. példa:

Bemenet: happiness = [2,3,4,5], k = 1
Kimenet: 5
Magyarázat: 1 gyermeket a következő módon választhatunk ki:
- Válassza ki a gyermeket a boldogságértékkel == 5. A megmaradt gyermekek boldogságértéke [1,2,3] lesz.
A kiválasztott gyermekek boldogságértékeinek összege 5.

Korlátok:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n

Egy happiness tömböt kapsz, amely n hosszúságú, és egy pozitív egészként adott k értéket.
n gyerek áll sorban, ahol az i-edik gyerek boldogsági értéke happiness[i]. k gyereket szeretnél kiválasztani ebből a n gyerekből k körben.
Minden körben, amikor kiválaszt egy gyermeket, az eddig ki nem választott gyerekek boldogságértéke 1-gyel csökken. Vegye figyelembe, hogy a boldogságérték nem lehet negatív, és csak akkor csökken, ha pozitív.
Adja vissza a kiválasztott gyerekek boldogságértékeinek maximális összegét, amelyet k gyermek kiválasztásával elérhet.

1. példa:

Bemenet: happiness = [1,2,3], k = 2
Kimenet: 4
Magyarázat: 2 gyermeket a következő módon választhatunk ki:
- Válassza ki azt a gyermeket, akinek boldogságértéke == 3. A fennmaradó gyermekek boldogságértéke [0,1] lesz.
- Válassza ki azt a gyermeket, akinek boldogságértéke == 1. A fennmaradó gyermek boldogságértéke [0] lesz. Vegye figyelembe, hogy a boldogság értéke nem lehet 0-nál kisebb.
A kiválasztott gyerekek boldogságértékeinek összege 3 + 1 = 4.

2. példa:

Bemenet: happiness = [1,1,1,1], k = 2
Kimenet: 1
Magyarázat: 2 gyermeket a következő módon választhatunk ki:
- Válasszon ki egy olyan gyermeket, akinek boldogságértéke == 1. A fennmaradó gyermekek boldogságértéke [0,0,0] lesz.
- Válassza ki azt a gyermeket, akinek boldogságértéke == 0. A fennmaradó gyermek boldogságértéke [0,0] lesz.
A kiválasztott gyerekek boldogságértékeinek összege 1 + 0 = 1.

3. példa:

Bemenet: happiness = [2,3,4,5], k = 1
Kimenet: 5
Magyarázat: 1 gyermeket a következő módon választhatunk ki:
- Válassza ki azt a gyermeket, akinek boldogságértéke == 5. A fennmaradó gyermekek boldogságértéke [1,2,3] lesz.
A kiválasztott gyerekek boldogságértékeinek összege 5.

Korlátozások:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n


Egy n méretű arr tömböt kapunk, amely nem üres karakterláncokból áll.
Keressen egy n méretű karakterlánc-tömb választ úgy, hogy:

A válasz[i] az arr[i] legrövidebb részkarakterlánca, amely nem fordul elő részkarakterláncként az arr más karakterláncában. Ha több ilyen részkarakterlánc létezik, az [i] válasznak a lexikográfiailag legkisebbnek kell lennie. És ha nem létezik ilyen részkarakterlánc, az [i] válasznak üres karakterláncnak kell lennie.

Adja vissza a tömb választ.

1. példa:

Bemenet: arr = ["cab", "ad", "bad", "c"]
Kimenet: ["ab","","ba",""]
Magyarázat: A következőkkel rendelkezünk:
- A "cab" karakterlánchoz a legrövidebb, más karakterláncban nem előforduló részkarakterlánc vagy a "ca" vagy az "ab", a lexikográfiailag kisebb részstringet választjuk, ami az "ab".
- Az "ad" karakterlánchoz nincs olyan részkarakterlánc, amely más karakterláncban ne fordulna elő.
- A "bad" karakterláncnál a legrövidebb részkarakterlánc, amely más karakterláncban nem fordul elő, a "ba".
- A "c" karakterlánchoz nincs olyan részkarakterlánc, amely más karakterláncban ne fordulna elő.

2. példa:

Bemenet: arr = ["abc","bcd","abcd"]
Kimenet: ["","","abcd"]
Magyarázat: A következőkkel rendelkezünk:
- Az "abc" karakterlánchoz nincs olyan részkarakterlánc, amely más karakterláncban ne fordulna elő.
- A "bcd" karakterlánchoz nincs olyan részkarakterlánc, amely más karakterláncban ne fordulna elő.
- Az "abcd" karakterlánc esetében a legrövidebb részkarakterlánc, amely más karakterláncban nem fordul elő, az "abcd".

Korlátozások:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
Az arr[i] csak kisbetűs angol betűkből áll.

Kap egy n méretű tömb arr-t, amely nem üres karakterláncokból áll.
Keressen egy n méretű karakterlánctömb-választ úgy, hogy:

answer[i] az arr[i] legrövidebb részkarakterlánca, amely nem fordul elő részkarakterláncként az arr egyetlen más karakterláncában sem. Ha több ilyen részsztring létezik, akkor answer[i] lexikografikusan a legkisebbnek kell lennie És ha nincs ilyen részsztring, akkor az answer[i] egy üres karakterláncnak kell lennie.

Adja vissza a tömb válaszát.

1. példa:

Bemenet: arr = ["cab","ad","rossz","c"]
Kimenet: ["ab","","ba",""]
Magyarázat: A következők állnak rendelkezésünkre:
- A "cab" karakterlánchoz a legrövidebb részkarakterlánc, amely egyetlen más karakterláncban sem fordul elő, a "ca" vagy az "ab", a lexikográfiailag kisebb részkarakterláncot választjuk, amely "ab".
- Az "ad" karakterlánc esetében nincs olyan részsztring, amely más karakterláncban ne fordulna elő.
- A "rossz" karakterlánc esetében a legrövidebb részsztring, amely egyetlen más karakterláncban sem fordul elő, a "ba".
- A "c" karakterlánc esetében nincs olyan részsztring, amely más karakterláncban nem fordul elő.

2. példa:

Bemenet: arr = ["abc","bcd","abcd"]
Kimenet: ["","","abcd"]
Magyarázat: A következők állnak rendelkezésünkre:
- Az "abc" karakterlánc esetében nincs olyan alsztring, amely más karakterláncban nem fordul elő.
- A "bcd" karakterlánc esetében nincs olyan alsztring, amely más karakterláncban ne fordulna elő.
- Az "abcd" karakterlánc esetében a legrövidebb alkarakterlánc, amely egyetlen más karakterláncban sem fordul elő, az "abcd".

Korlátok:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] csak kisbetűs angol betűkből áll.


Kapunk egy 0 indexelt tömböt n hosszúságú egész számokból és egy pozitív páratlan k egész számból.
Az x résztömbök erőssége a következő: erősség = összeg[1] * x - összeg[2] * (x - 1) + összeg[3] * (x - 2) - összeg[4] * (x - 3) + ... + összeg[x] * 1 ahol sum[i] az i^-edik résztömb elemeinek összege. Formálisan az erősség a (-1)^i+1 * sum[i] * (x - i + 1) összege az összes i-re úgy, hogy 1 <= i <= x.
Ki kell választania k diszjunkt altömböket a számokból, hogy erősségük maximális legyen.
Állítsa vissza a lehető legnagyobb erősséget.
Vegye figyelembe, hogy a kijelölt résztömböknek nem kell lefedniük a teljes tömböt.

1. példa:

Bemenet: nums = [1,2,3,-1,2], k = 3
Kimenet: 22
Magyarázat: A 3 résztömb kiválasztásának legjobb módja: nums[0..2], nums[3..3] és nums[4..4]. Az erősség (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

2. példa:

Bemenet: nums = [12,-2,-2,-2,-2], k = 5
Kimenet: 64
Magyarázat: Az egyetlen lehetséges módja annak, hogy 5 diszjunkt résztömböt válasszunk ki: nums[0..0], nums[1..1], nums[2..2], nums[3..3] és nums[4..4]. Az erősség 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

3. példa:

Bemenet: nums = [-1,-2,-3], k = 1
Kimenet: -1
Magyarázat: 1 résztömb kiválasztásának legjobb módja: nums[0..0]. Az erősség -1.

Korlátok:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k páratlan.

0-indextől indexelt egész számokat tartalmazó tömböt kapunk, nums néven, melynek hossza n, és egy pozitív páratlan egész számot k.
Az x altömb erőssége a következőképpen definiálható: strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1, ahol az összeg[i] az i^. altömb elemeinek összege. Formálisan az erősség a (-1)^i+1 * sum[i] * (x - i + 1) összege az összes i-re, így 1 <= i <= x.
Ki kell választani k darab diszjunkt altömböt a számok közül úgy, hogy az erősségük maximális legyen.
Adja vissza a maximálisan elérhető erősséget.
Vegye figyelembe, hogy a kiválasztott altömböknek nem kell lefedniük a teljes tömböt.

1. példa:

Bemenet: nums = [1,2,3,-1,2], k = 3
Kimenet: 22
Magyarázat: A 3 altömb kiválasztásának legjobb módja a következő: nums[0..2], nums[3..3], és nums[4..4]. Az erő (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

2. példa:

Bemenet: nums = [12,-2,-2,-2,-2], k = 5
Kimenet: 64
Magyarázat: Az egyetlen lehetséges módja 5 diszjunkt altömb kiválasztásának: nums[0..0], nums[1..1], nums[2..2], nums[3..3], és nums[4..4]. Az erő 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

3. példa:

Bemenet: nums = [-1,-2,-3], k = 1
Kimenet: -1
Magyarázat: 1 altömb kiválasztásának legjobb módja a következő: nums[0..0]. Az erősség -1.

Korlátozások:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k páratlan.

Kapunk egy 0-indexelt n hosszúságú egész számokból álló tömböt, és egy pozitív páratlan k számot.
Az x altömb erőssége a következőképpen definiálható: strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1 ahol az sum[i] az i^. altömb elemeinek összege. Formálisan az erősség a (-1)^i+1 * sum[i] * (x - i + 1) összege az összes i-re, így 1 <= i <= x.
Ki kell választani k darab diszjunkt altömböt a számok közül úgy, hogy az erősségük maximális legyen.
Adja vissza a maximálisan elérhető erősséget.
Vegye figyelembe, hogy a kiválasztott altömböknek nem kell lefedniük a teljes tömböt.

1. példa:

Bemenet: nums = [1,2,3,-1,2], k = 3
Kimenet: 22
Magyarázat: A 3 altömb kiválasztásának legjobb módja a következő:nums[0..2], nums[3..3], és nums[4..4].Az erősség: (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

2. példa:

Bemenet: nums = [12,-2,-2,-2,-2], k = 5
Kimenet: 64
Magyarázat: Az egyetlen lehetséges módja 5 diszjunkt altömb kiválasztásának: nums[0..0], nums[1..1], nums[2..2], nums[3..3] és nums[4. .4]. Az erősség 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

3. példa:

Bemenet: nums = [-1,-2,-3], k = 1
Kimenet: -1
Magyarázat: 1 altömb kiválasztásának legjobb módja a következő: nums[0..0]. Az erősség -1.

Korlátozások:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k páratlan.


Adott egy s karakterlánc, keressen meg minden olyan 2 hosszúságú részstringet, amely az s fordítottjában is megtalálható.
Igaz értéket ad vissza, ha létezik ilyen részkarakterlánc, és hamis értéket egyébként.

Példa 1:

Bemenet: s = "leetcode"
Kimenet: true
Magyarázat: Az "ee" részkarakterlánc hossza 2, amely a fordított(ok)ban is jelen van == "edocteel".

Példa 2:

Bemenet: s = "abcba"
Kimenet: true
Magyarázat: Az összes 2. hosszúságú "ab", "bc", "cb", "ba" részkarakterlánc megfordítva is jelen van == "abcba".

Példa 3:

Bemenet: s = "abcd"
Kimenet: false
Magyarázat: Nincs s-ben 2 hosszúságú részkarakterlánc, amely az s fordítottjában is megtalálható.

Korlátozások:

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

Adott egy s karakterlánc, keressen meg minden olyan 2 hosszúságú részstringet, amely az s fordítottjában is megtalálható.
Igaz értéket ad vissza, ha létezik ilyen részkarakterlánc, és hamis értéket egyébként.

1. példa:

Bemenet: s = "leetcode"
Kimenet: igaz
Magyarázat: Az "ee" részkarakterlánc hossza 2, amely a fordított(ok)ban is jelen van == "edocteel".

2. példa:

Bemenet: s = "abcba"
Kimenet: igaz
Magyarázat: Az összes 2. hosszúságú "ab", "bc", "cb", "ba" részkarakterlánc megfordítva is jelen van == "abcba".

3. példa:

Bemenet: s = "abcd"
Kimenet: hamis
Magyarázat: Nincs s-ben 2 hosszúságú részkarakterlánc, amely az s fordítottjában is megtalálható.

Korlátozások:

1 <= s.length <= 100
s consists only of lowercase English letters.

Adott egy s karakterlánc, keressünk olyan 2 hosszúságú részláncot, amely az s fordítottjában is szerepel.
Ha létezik ilyen részlánc, akkor true-t ad vissza, ellenkező esetben false-t.

Példa 1:

Bemenet: s = "leetcode"
Kimenet: true
Magyarázat: Az „ee” részlánc hossza 2, amely a reverse(s) == „edocteel” részláncban is szerepel.

Példa 2:

Bemenet: s = "abcba"
Kimenet: true
Magyarázat: Az ''abc” és a ''bcb” értékek a következőek: ''bcb”: Az összes 2 hosszúságú "ab", "bc", "cb","ba" részlánc jelen van a reverse(s)-ben is =="abcba".

Példa 3:

Bemenet: s = "abcd"
Kimenet: false
Magyarázat: Nincs olyan 2 hosszúságú részlánc az s-ben, amely az s fordítottjában is szerepel.

Korlátozások:

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


Kapsz egy s karakterláncot és egy c karaktert. Az s c betűvel kezdődő és végződő részsztringek teljes számát adja eredményül.

1. példa:

Bemenet: s = "abada", c = "a"
Kimenet: 6
Magyarázat: Az "a"-val kezdődő és végződő részkarakterláncok a következők: "a", "abada", "ada", "ada", "a", "a".

2. példa:

Bemenet: s = "zzz", c = "z"
Kimenet: 6
Magyarázat: Az s-ben összesen 6 Részsztring van, és mindegyik "z"-vel kezdődik és végződik.

Korlátok:

1 <= s.length <= 10^5
s és c csak kisbetűs angol betűkből áll.

Kapsz egy s karakterláncot és egy c karaktert. Az s c-vel kezdődő és végződő részkarakterláncainak teljes számát adja vissza.

1. példa:

Bemenet: s = "abada", c = "a"
Kimenet: 6
Magyarázat: Az "a"-val kezdődő és végződő részkarakterláncok a következők: "abada", "abada", "abada", "abada", "abada", "abada".

2. példa:

Bemenet: s = "zzz", c = "z"
Kimenet: 6
Magyarázat: Összesen 6 részstring van az s-ben, és mindegyik "z"-vel kezdődik és végződik.

Korlátozások:

1 <= s.hossz <= 10^5
s és c csak kis angol betűkből áll.

Kapsz egy s karakterláncot és egy c karaktert. Az s c-vel kezdődő és végződő részkarakterláncainak teljes számát adja vissza.

példa 1:

Bemenet: s = "abada", c = "a"
Kimenet: 6
Magyarázat: Az "a"-val kezdődő és végződő részkarakterláncok a következők: "a", "aba", "ada", "abada", "a", "a".

példa 2:

Bemenet: s = "zzz", c = "z"
Kimenet: 6
Magyarázat: Összesen 6 részstring van az s-ben, és mindegyik "z"-vel kezdődik és végződik.

Korlátozások:

1 <= s.hossz <= 10^5
s és c csak kis angol betűkből áll.


Kapsz egy karakterláncszót és egy k egész számot.
A szót k-speciálisnak tekintjük, ha |freq(word[i]) - freq(word[j])| <= k a karakterlánc összes i és j indexére.
Itt a freq(x) az x karakter gyakoriságát jelöli a szóban, és |y| az y abszolút értékét jelöli.
Adja vissza azt a minimális karakterszámot, amelyet törölnie kell ahhoz, hogy a k szó különleges legyen.

1. példa:

Bemenet: word = "aabcaba", k = 0
Kimenet: 3
Magyarázat: A 0-speciálissá tehetjük az "a" 2 előfordulásának és a "c" 1 előfordulásának törlésével. Ezért a szó egyenlő lesz a "baba" szóval, ahol freq('a') == freq('b') == 2.

2. példa:

Bemenet: word = "dabdcbdcdcd", k = 2
Kimenet: 2
Magyarázat: A 2-es szót különlegessé tehetjük, ha töröljük az "a" 1 előfordulását és a "d" 1 előfordulását. Ezért a szó egyenlő lesz a "bdcbdcdcd"-vel, ahol freq('b') == 2, freq('c') == 3, és freq('d') == 4.

3. példa:

Bemenet: word = "aaabaaa", k = 2
Kimenet: 1
Magyarázat: A 2-es szót különlegessé tehetjük, ha töröljük a "b" 1 előfordulását. Ezért a szó egyenlő lesz az "aaaaaa" -val, ahol minden betű gyakorisága egységesen 6.

Korlátok:

1 <= word.length <= 10^5
0 <= k <= 10^5
szó csak kisbetűs angol betűkből áll.

Kapsz egy karakterláncszót és egy k egész számot.
A szót k-speciálisnak tekintjük, ha |freq(word[i]) - freq(word[j])| <= k a karakterlánc összes i és j indexére.
Itt a freq(x) az x karakter gyakoriságát jelöli a szóban, és |y| az y abszolút értékét jelöli.
Adja vissza azt a minimális karakterszámot, amelyet törölnie kell ahhoz, hogy a k szó különleges legyen.

1. példa:

Bemenet: szó = "aabcaba", k = 0
Kimenet: 3
Magyarázat: A 0-speciálissá tehetjük az "a" 2 előfordulásának és a "c" 1 előfordulásának törlésével. Ezért a szó egyenlő lesz a "baba" szóval, ahol freq('a') == freq('b') == 2.

2. példa:

Bemenet: szó = "dabdcbdcdcd", k = 2
Kimenet: 2
Magyarázat: A 2-es szót különlegessé tehetjük, ha töröljük az "a" 1 előfordulását és a "d" 1 előfordulását. Ezért a szó egyenlő lesz a "bdcbdcdcd"-vel, ahol freq('b') == 2, freq('c') == 3, és freq('d') == 4.

3. példa:

Bemenet: szó = "aaabaaa", k = 2
Kimenet: 1
Magyarázat: A 2-es szót különlegessé tehetjük, ha töröljük a "b" 1 előfordulását. Ezért a szó egyenlő lesz az "aaaaaa" -val, ahol minden betű gyakorisága egységesen 6.

Korlátok:

1 <= szó.hossz <= 10^5
0 <= k <= 10^5
szó csak kisbetűs angol betűkből áll.

Kapsz egy karakterlánc szót és egy k egész számot.
A szót k-különlegesnek tekintjük, ha |gyakoriság(szó[i]) - gyak(szó[j])| <= k a karakterlánc összes i és j indexére.
Itt a freq(x) az x karakter gyakoriságát jelöli a szóban, és |y| y abszolút értékét jelöli.
Adja vissza a törlendő karakterek minimális számát ahhoz, hogy a k szót különlegessé tegye.

Példa 1:

Bemenet: word = "aabcaba", k = 0
Kimenet: 3
Magyarázat: A word-et 0-különlegessé tehetjük, ha törlünk 2 "a" és 1 "c" előfordulást. Ezáltal a word "baba"-vá alakul, ahol a freq('a') == freq('b') == 2.

Példa 2:

Bemenet: word = "dabdcbdcdcd", k = 2
Kimenet: 2
Magyarázat: A word-et 2-különlegessé tehetjük, ha törlünk 1 "a" és 1 "d" előfordulást. Ezáltal a word "bdcbdcdcd"-vé alakul, ahol a freq('b') == 2, freq('c') == 3, és freq('d') == 4.

Példa 3:

Bemenet: word = "aaabaaa", k = 2
Kimenet: 1
Magyarázat: A word-et 2-különlegessé tehetjük, ha törlünk 1 "b" előfordulást. Ezáltal a word "aaaaaa"-vá alakul, ahol most az egyes betűk gyakorisága egyenletesen 6.

Korlátozások:

1 <= word.length <= 10^5
0 <= k <= 10^5
szó csak kisbetűs angol betűkből áll.


Egy bináris nums tömb adott, melynek hossza n, egy pozitív egész k és egy nemnegatív egész maxChanges.
Alice játszik egy játékot, melynek célja, hogy Alice k darab egyest vegyen fel a nums-ból a lehető legkevesebb lépéssel. Amikor a játék kezdődik, Alice bármilyen indexet aliceIndex felvesz a [0, n - 1] tartományból és ott áll meg. Ha nums[aliceIndex] == 1, Alice felveszi az egyest és nums[aliceIndex] 0 lesz (ez nem számít lépésnek). Ezután Alice bármennyi lépést tehet (beleértve a nullát is), ahol minden lépésben Alice-nek pontosan az alábbi műveletek egyikét kell végrehajtania:

Olyan indexet választ j != aliceIndex, hogy nums[j] == 0 és beállítja nums[j] = 1-re. Ezt a műveletet legfeljebb maxChanges alkalommal hajthatja végre.
Kiválaszt bármely két szomszédos indexet x és y (|x - y| == 1) úgy, hogy nums[x] == 1, nums[y] == 0, majd felcseréli az értékeiket (beállítja nums[y] = 1 és nums[x] = 0). Ha y == aliceIndex, Alice felveszi az egyest ebben a lépésben, és nums[y] 0 lesz.

Adja vissza a minimális lépésszámot, ami szükséges Alicenek ahhoz, hogy pontosan k darab egyest vegyen fel.

Példa 1:

Bemenet: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Kimenet: 3
Magyarázat: Alice 3 lépés alatt 3 egyest vehet fel, ha a következő műveleteket hajtja végre minden lépésben, amikor aliceIndex == 1-nél áll:

A játék elején Alice felvesz egy egyest és nums[1] 0 lesz. nums [1,1,1,0,0,1,1,0,0,1] lesz.
Kiválasztja j == 2-t és végrehajtja az első típusú műveletet. nums [1,0,1,0,0,1,1,0,0,1] lesz.
Kiválasztja x == 2 és y == 1-t, és végrehajtja a második típusú műveletet. nums [1,1,0,0,0,1,1,0,0,1] lesz. Mivel y == aliceIndex, Alice felveszi az egyest és nums [1,0,0,0,0,1,1,0,0,1] lesz.
Kiválasztja x == 0 és y == 1-t, és végrehajtja a második típusú műveletet. nums [0,1,0,0,0,1,1,0,0,1] lesz. Mivel y == aliceIndex, Alice felveszi az egyest és nums [0,0,0,0,0,1,1,0,0,1] lesz.

Megjegyzés, hogy lehetséges, hogy Alice valamilyen más 3 lépéses sorozattal is felvehet 3 egyest.

Példa 2:

Bemenet: nums = [0,0,0,0], k = 2, maxChanges = 3
Kimenet: 4
Magyarázat: Alice 4 lépés alatt 2 egyest vehet fel, ha a következő műveleteket hajtja végre minden lépésben, amikor aliceIndex == 0-nál áll:

Kiválasztja j == 1-et és végrehajtja az első típusú műveletet. nums [0,1,0,0] lesz.
Kiválasztja x == 1 és y == 0-t, és végrehajtja a második típusú műveletet. nums [1,0,0,0] lesz. Mivel y == aliceIndex, Alice felveszi az egyest és nums [0,0,0,0] lesz.
Ismét kiválasztja j == 1-et és végrehajtja az első típusú műveletet. nums [0,1,0,0] lesz.
Ismét kiválasztja x == 1 és y == 0-t, és végrehajtja a második típusú műveletet. nums [1,0,0,0] lesz. Mivel y == aliceIndex, Alice felveszi az egyest és nums [0,0,0,0] lesz.

Korláztozások:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

Kapsz egy n hosszúságú bináris tömböt, egy k pozitív egész számot és egy maxChanges nem negatív egész számot.
Alice játszik egy játékot, ahol a cél az, hogy Alice a minimális számú mozdulattal felvegye a k egyest a numokból. Amikor a játék elkezdődik, Alice felveszi a [0, n - 1] tartományban lévő aliceIndex indexet, és ott áll. Ha nums[aliceIndex] == 1 , Alice felveszi az egyest, és a nums[aliceIndex] 0 lesz (ez nem számít lépésnek). Ezt követően Alice tetszőleges számú lépést tehet (beleértve a nullát is), ahol Alice-nek minden lépésben pontosan az alábbi műveletek egyikét kell végrehajtania:

Válasszon ki egy j != aliceIndex indexet úgy, hogy nums[j] == 0 legyen, és állítsa be a nums[j] = 1 értéket. Ez a művelet a legtöbb esetben végrehajtható maxChanges idők.
Jelöljön ki bármely két szomszédos x és y indexet (|x - y| == 1) úgy, hogy nums[x] == 1, nums[y] == 0, majd cserélje fel értékeiket (állítsa be nums[y] = 1 és nums[x] = 0). Ha y == aliceIndex, Alice felveszi a lépés utáni egyiket, és a nums[y] 0 lesz.

Adja vissza az Alice által megkövetelt minimális lépésszámot, hogy pontosan k lépést válasszon.

1. példa:

Bemenet: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Kimenet: 3
Magyarázat: Alice 3 lépésben 3-at tud felvenni, ha Alice minden mozdulatnál a következő műveleteket hajtja végre, amikor aliceIndex == 1-nél áll:

 A játék elején Alice felveszi az egyest, és a nums[1] 0-ra változik. A nums [1,1,1,0,0,1,1,0,0,1] lesz.
Válassza ki a j == 2 értéket, és hajtsa végre az első típusú műveletet. A számból [1,0,1,0,0,1,1,1,0,0,1] lesz
Válassza az x == 2 és y == 1 lehetőséget, és hajtsa végre a második típusú műveletet. A nums [1,1,0,0,0,1,1,0,0,1] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és a nums [1,0,0,0,0,1,1,0,0,1] lesz.
Válassza az x == 0 és y == 1 lehetőséget, és hajtsa végre a második típusú műveletet. A nums [0,1,0,0,0,1,1,0,0,1] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és a nums[0,0,0,0,0,0,1,1,0,0,1] lesznek.

Ne feledje, hogy lehetséges, hogy Alice 3-at vegyen fel valamilyen más, 3 lépésből álló sorozattal.

2. példa:

Bemenet: nums = [0,0,0,0], k = 2, maxChanges = 3
Kimenet: 4
Magyarázat: Alice 4 lépésben 2-t tud felvenni, ha Alice minden mozdulatban végrehajtja a következő műveleteket, amikor aliceIndex == 0-nál áll:

Válassza a j == 1 lehetőséget, és hajtsa végre az első típusú műveletet. A nums [0,1,0,0] lesz.
Válassza az x == 1 és y == 0 lehetőséget, és hajtsa végre a második típusú műveletet. A nums [1,0,0,0] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és a numsból [0,0,0,0] lesz.
Válassza ki ismét a j == 1 értéket, és hajtsa végre az első típusú műveletet. A nums [0,1,0,0] lesz.
Válassza ki ismét az x == 1 és y == 0 értékeket, és hajtsa végre a második típusú műveletet. A nums [1,0,0,0] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és a numsból [0,0,0,0] lesz.

Korlátok:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(szám) >= k

Adott egy n hosszúságú nums bináris tömb, egy pozitív egész szám k és egy nemnegatív egész szám maxChanges.
Alice játszik egy játékot, ahol a cél az, hogy Alice a lehető legkevesebb lépésszámmal k egyeset vegyen fel a numsból. A játék kezdetekor Alice felveszi a [0, n - 1] tartományba eső bármelyik aliceIndex indexet, és ott áll. Ha nums[aliceIndex] == 1 , akkor Alice felveszi az egyest, és nums[aliceIndex] 0 lesz (ez nem számít lépésnek). Ezután Alice tetszőleges számú lépést tehet (beleértve a nullát is), ahol minden egyes lépésnél Alice-nek pontosan egyet kell végrehajtania a következő műveletek közül:

Válassza ki bármelyik j != aliceIndex indexet úgy, hogy nums[j] == 0 és állítsa nums[j] = 1. Ez a művelet legfeljebb maxChanges alkalommal hajtható végre.
Válasszunk ki két szomszédos indexet x és y (|x - y| == 1) úgy, hogy nums[x] == 1, nums[y] == 0, majd cseréljük fel az értékeiket (állítsuk be nums[y] = 1 és nums[x] = 0). Ha y == aliceIndex, akkor Alice felveszi az egyest e lépés után, és nums[y] 0 lesz.

Adja vissza, hogy Alice-nak hány lépés szükséges legalább ahhoz, hogy pontosan k darabot vegyen fel.

1. példa:

Bemenet: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Kimenet: 3
Magyarázat: Alice 3 lépés alatt 3 egyes számot tud felvenni, ha Alice az aliceIndex == 1 ponton állva minden lépésnél a következő műveleteket hajtja végre:

 A játék kezdetén Alice felveszi az egyest, és nums[1] 0 lesz. nums [1,1,1,0,0,1,1,0,0,1] lesz.
Válassza ki j == 2 és hajtson végre egy első típusú műveletet. nums [1,0,1,0,0,1,1,0,0,1] lesz.
Válassza ki x == 2 és y == 1, és hajtson végre egy második típusú műveletet. nums [1,1,0,0,0,1,1,0,0,1] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és nums [1,0,0,0,0,1,1,0,0,1] lesz.
Válasszuk ki x == 0 és y == 1, és hajtsunk végre egy második típusú műveletet. nums [0,1,0,0,0,1,1,0,0,1] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és nums [0,0,0,0,0,1,1,0,0,1] lesz.

Megjegyezzük, hogy lehetséges, hogy Alice 3 egyeset vesz fel, más 3 lépésből álló sorozatot használva.

2. példa:

Bemenet: nums = [0,0,0,0], k = 2, maxChanges = 3
Kimenet: 4
Magyarázat: Alice 4 lépés alatt 2 egyest tud felvenni, ha Alice az aliceIndex == 0 ponton állva minden lépésnél a következő műveleteket hajtja végre:

Válassza a j == 1 lehetőséget, és hajtsa végre az első típusú műveletet. A nums [0,1,0,0] lesz.
Válasszuk ki x == 1 és y == 0, és hajtsunk végre egy második típusú műveletet. nums [1,0,0,0,0,0] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és nums [0,0,0,0] lesz.
Válasszuk ki ismét j == 1, és hajtsunk végre egy első típusú műveletet. nums [0,1,0,0] lesz.
Válasszuk ki ismét x == 1 és y == 0, és végezzünk el egy második típusú műveletet. nums [1,0,0,0,0,0] lesz. Mivel y == aliceIndex, Alice felveszi az egyest, és nums [0,0,0,0] lesz.

Korlátozások:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k


Adott egy s karakterlánc, add vissza egy olyan részkarakterlánc maximális hosszát, amely legfeljebb két előfordulást tartalmaz minden karakterből.

Példa 1:

Bemenet: s = "bcbbbcba"
Kimenet: 4
Magyarázat:
Az alábbi részkarakterláncnak 4 a hossza és legfeljebb két előfordulást tartalmaz minden karakterből: "bcbbbcba".

Példa 2:

Bemenet: s = "aaaa"
Kimenet: 2
Magyarázat:
Az alábbi részkarakterláncnak 2 a hossza és legfeljebb két előfordulást tartalmaz minden karakterből: "aaaa".

Korlátozások:

2 <= s.length <= 100
s csak kisbetűs angol betűkből áll.

Adott egy s karakterlánc, adja vissza egy részkarakterlánc maximális hosszát úgy, hogy minden karakternek legfeljebb két előfordulása legyen.

1. példa:

Bemenet: s = "bcbbbcba"
Kimenet: 4
Magyarázat:
A következő alkarakterlánc hossza 4, és minden karakternek legfeljebb két előfordulását tartalmazza: "bcbbbcba".
2. példa:

Bemenet: s = "aaaa"
Kimenet: 2
Magyarázat:
A következő alkarakterlánc hossza 2, és minden karakterből legfeljebb két előfordulást tartalmaz: "aaaa".

Korlátok:

2 <= s.length <= 100
s csak kisbetűs angol betűkből áll.


Adott egy pozitív egész szám, k. Kezdetben van egy nums = [1] tömböd. A következő műveletek közül bármelyiket végezheted a tömbön tetszőleges számú alkalommal (akár nulla alkalommal is):

Válassz ki bármely elemet a tömbből, és növeld meg az értékét 1-gyel.
Duplikálj bármely elemet a tömbben, és add hozzá azt a tömb végéhez.
Add vissza a minimális műveletek számát, amely szükséges ahhoz, hogy a végső tömb elemeinek összege nagyobb vagy egyenlő legyen k-val.

Példa 1:

Bemenet: k = 11
Kimenet: 5
Magyarázat:
A következő műveleteket végezhetjük a nums = [1] tömbön:

Növeljük az elemet háromszor 1-gyel. Az eredmény nums = [4].
Duplikáljuk az elemet kétszer. Az eredmény nums = [4, 4, 4].
A végső tömb összege 4 + 4 + 4 = 12, ami nagyobb vagy egyenlő 11-tel.
A végrehajtott műveletek összes száma: 3 + 2 = 5.

Példa 2:

Bemenet: k = 1
Kimenet: 0
Magyarázat:
Az eredeti tömb összege már eleve nagyobb vagy egyenlő 1-gyel, így nincs szükség műveletekre.

Korlátozások:

1 <= k <= 10^5

Adott egy pozitív egész szám k. Kezdetben van egy nums = [1] tömb.
A tömbön tetszőleges számú (esetleg nulla) műveletet végezhetsz a következő műveletek közül:

Válasszuk ki a tömb bármelyik elemét, és növeljük az értékét 1-gyel.
Duplikáljuk meg a tömb bármelyik elemét, és adjuk hozzá a tömb végéhez.

Adja vissza a műveletek minimális számát, amelyek szükségesek ahhoz, hogy a végső tömb elemeinek összege nagyobb vagy egyenlő legyen k-nál.

Példa 1:

Bemenet: k = 11
Kimenet: 5
Magyarázat:
A nums = [1] tömbön a következő műveleteket tudjuk elvégezni:

Háromszor növeljük az elemet 1-gyel. Az eredményül kapott tömb a nums = [4].
Duplikáljuk az elemet kétszer. A kapott tömb nums = [4,4,4].

A végső tömb összege 4 + 4 + 4 = 12, ami nagyobb vagy egyenlő, mint k = 11.
Az elvégzett műveletek száma összesen 3 + 2 = 5.

2. példa:

Bemenet: k = 1
Kimenet: 0
Magyarázat:
Az eredeti tömb összege már nagyobb vagy egyenlő 1-nél, így nincs szükség műveletekre.

Korlátozások:

1 <= k <= 10^5

Kapsz egy k pozitív egész számot. Kezdetben egy tömb nums = [1].
A következő műveletek bármelyikét elvégezheti a tömbön akárhányszor (esetleg nullát):

Válassza ki a tömb bármely elemét, és növelje az értékét 1-gyel.
Másolja meg a tömb bármely elemét, és adja hozzá a tömb végéhez.

A műveletek minimális számát adja vissza ahhoz, hogy a végső tömb elemeinek összege k-nál nagyobb vagy egyenlő legyen.

1. példa:

Bemenet: k = 11
Kimenet: 5
Magyarázat:
A következő műveleteket végezhetjük el a tömb nums = [1]:

Növelje az elemet háromszor 1-gyel. Az eredményül kapott tömb nums = [4].
Másolja meg kétszer az elemet. Az eredményül kapott tömb nums = [4,4,4].

A végső tömb összege 4 + 4 + 4 = 12, amely nagyobb vagy egyenlő, mint k = 11.
Az elvégzett műveletek száma összesen 3 + 2 = 5.

2. példa:

Bemenet: k = 1
Kimenet: 0
Magyarázat:
Az eredeti tömb összege már nagyobb vagy egyenlő, mint 1, így nincs szükség műveletekre.

Korlátozások:

1 <= k <= 10^5


A probléma az azonosítók gyakoriságának nyomon követésével jár egy gyűjteményben, amely idővel változik. Két egész tömbje van, nums és freq, egyenlő hosszúságú n. A nums minden eleme egy azonosítót jelöl, és a frekvencia megfelelő eleme jelzi, hogy az azonosítót hányszor kell hozzáadni vagy eltávolítani a gyűjteményből az egyes lépésekben.

Azonosítók hozzáadása: Ha a freq[i] pozitív, az azt jelenti, hogy a nums[i] értékű freq[i] azonosítók az i lépésben hozzáadódnak a gyűjteményhez.
Azonosítók eltávolítása: Ha a freq[i] negatív, az azt jelenti, hogy a nums[i] értékkel rendelkező -freq[i] azonosítók eltávolításra kerülnek a gyűjteményből az i lépésben.

Egy n hosszúságú ans tömböt ad vissza, ahol ans[i] a gyűjtemény leggyakoribb azonosítójának számát jelöli az i^th lépés után. Ha a gyűjtemény bármelyik lépésben üres, az ans[i] értéknek 0-nak kell lennie az adott lépéshez.

1. példa:

Bemenet: nums = [2,3,2,1], freq = [3,2,-3,1]
Kimenet: [3,3,2,2]
Magyarázat:
A 0. lépés után 3 azonosítónk van 2 értékkel. Tehát ans[0] = 3.
Az 1. lépés után 3 azonosítónk van 2 értékkel és 2 azonosítónk 3 értékkel. Tehát ans[1] = 3.
A 2. lépés után 2 azonosítónk van, amelyek értéke 3. Tehát ans[2] = 2.
A 3. lépés után 2 azonosítónk van 3 értékkel és 1 azonosítónk 1 értékkel. Tehát ans[3] = 2.

2. példa:

Bemenet: nums = [5,5,3], freq = [2,-2,1]
Kimenet: [2,0,1]
Magyarázat:
A 0. lépés után 2 azonosítónk van 5 értékkel. Tehát ans[0] = 2.
Az 1. lépés után nincsenek azonosítók. Tehát ans[1] = 0.
A 2. lépés után 1 azonosítónk van, amelynek értéke 3. Tehát ans[2] = 1.

Korlátok:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
A bemenet úgy jön létre, hogy az azonosító előfordulásai egyetlen lépésben sem lesznek negatívak.

A probléma az azonosítók gyakoriságának nyomon követésével jár egy gyűjteményben, amely idővel változik. Két egész szám tömbje van, a num és a freq, amelyek egyenlő hosszúságúak n. A számokban szereplő minden elem egy azonosítót jelent, és a freq megfelelő eleme azt jelzi, hogy az adott azonosítót hányszor kell hozzáadni a gyűjteményhez vagy eltávolítani az egyes lépésekben.

Azonosítók hozzáadása: Ha a freq[i] pozitív, az azt jelenti, hogy az i. lépésben a gyűjteményhez adunk freq[i] darab szám[i] értékű azonosítót.
Azonosítók eltávolítása: Ha a freq[i] negatív, az azt jelenti, hogy a -freq[i] nums[i] értékű azonosítók eltávolításra kerülnek a gyűjteményből az i lépésben.

Egy n hosszúságú ans tömböt ad vissza, ahol az ans[i] a gyűjtemény leggyakrabban előforduló azonosítójának számát jelenti az i^. lépés után. Ha a gyűjtemény bármelyik lépésben üres, az ans[i] értéke 0 legyen az adott lépéshez.

1. példa:

Bemenet: nums = [2,3,2,1], freq = [3,2,-3,1]
Kimenet: [3,3,2,2]
Magyarázat:
A 0. lépés után 3 darab azonosítónk van, amelyek értéke 2. Tehát ans[0] = 3.
Az 1. lépés után 3 azonosítónk van 2 értékű és 2 azonosítónk 3 értékkel. Tehát ans[1] = 3.
A 2. lépés után 2 azonosítónk van, amelyek értéke 3. Tehát ans[2] = 2.
A 3. lépés után 2 db 3-as azonosítónk és 1 db 1-es értékű azonosítónk van. Tehát ans[3] = 2.

2. példa:

Bemenet: nums = [5,5,3], freq = [2,-2,1]
Kimenet: [2,0,1]
Magyarázat:
A 0. lépés után 2 azonosítónk van 5-ös értékkel. Tehát ans[0] = 2.
Az 1. lépés után nincsenek azonosítók. Tehát ans[1] = 0.
A 2. lépés után 1 azonosítónk van, melynek értéke 3. Tehát ans[2] = 1.

Korlátozások:

1 <= nums.hossz == freq.hossz <= 10^5
1 <= szám[i] <= 10^5
-10^5 <= frekvencia[i] <= 10^5
frekvencia[i]!= 0
A bemenet úgy jön létre, hogy az azonosító előfordulásai egyetlen lépésben sem lesznek negatívak.

A probléma az azonosítók gyakoriságának nyomon követésével jár egy gyűjteményben, amely idővel változik. Két egész szám tömbje van, a num és a freq, amelyek egyenlő hosszúságúak n. A számokban szereplő minden elem egy azonosítót jelent, és a freq megfelelő eleme azt jelzi, hogy az adott azonosítót hányszor kell hozzáadni a gyűjteményhez vagy eltávolítani az egyes lépésekben.

Azonosítók hozzáadása: Ha a freq[i] pozitív, az azt jelenti, hogy az i. lépésben a szám[i] értékű frekvencia[i] azonosítók kerülnek hozzáadásra a gyűjteményhez.
Azonosítók eltávolítása: Ha a freq[i] negatív, az azt jelenti, hogy a -freq[i] számok [i] értékű azonosítók eltávolításra kerülnek a gyűjteményből az i lépésben.

Egy n hosszúságú ans tömböt ad vissza, ahol az ans[i] a gyűjtemény leggyakrabban előforduló azonosítójának számát jelenti az i^. lépés után. Ha a gyűjtemény bármelyik lépésben üres, az ans[i] értéke 0 legyen az adott lépéshez.

1. példa:

Bemenet: nums = [2,3,2,1], freq = [3,2,-3,1]
Kimenet: [3,3,2,2]
Magyarázat:
A 0. lépés után 3 azonosítónk van, amelyek értéke 2. Tehát ans[0] = 3.
Az 1. lépés után 3 azonosítónk van 2 értékű és 2 azonosítónk 3 értékkel. Tehát ans[1] = 3.
A 2. lépés után 2 azonosítónk van, amelyek értéke 3. Tehát ans[2] = 2.
A 3. lépés után 2 azonosítónk van 3 értékű és 1 ID 1 értékű. Tehát ans[3] = 2.

2. példa:

Bemenet: nums = [5,5,3], freq = [2,-2,1]
Kimenet: [2,0,1]
Magyarázat:
A 0. lépés után 2 azonosítónk van 5-ös értékkel. Tehát ans[0] = 2.
Az 1. lépés után nincsenek azonosítók. Tehát ans[1] = 0.
A 2. lépés után 1 azonosítónk van, melynek értéke 3. Tehát ans[2] = 1.

Korlátozások:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
A bemenet úgy jön létre, hogy egy azonosító előfordulása egyetlen lépésben sem lesz negatív.