Kapsz egy n egész számból álló 1-indexelt tömböt.
Egy számhalmaz akkor teljes, ha minden elempárjának szorzata tökéletes négyzet.
Az {1, 2, ..., n} indexhalmazok egy részhalmazához, amelyet {i_1, i_2, ..., i_k} jellel ábrázolunk, az elemösszegét a következőképpen határozzuk meg: nums[i_1] + nums[i_2] + ... + nums[i_k].
Az {1, 2, ..., n} indexhalmaz teljes részhalmazának maximális elemösszegét adja vissza.
A tökéletes négyzet olyan szám, amely önmagában is kifejezhető egy egész szám szorzataként.

1. példa:

Bemenet: nums = [8,7,3,5,7,2,4,9]
Kimenet: 16
Magyarázat: Az egyetlen indexből álló részhalmazokon kívül az indexeknek két másik teljes részhalmaza van: {1,4} és {2,8}.
Az 1-es és 4-es indexnek megfelelő elemek összege: nums[1] + nums[4] = 8 + 5 = 13.
A 2-es és 8-as indexnek megfelelő elemek összege: nums[2] + nums[8] = 7 + 9 = 16.
Ezért az indexek teljes részhalmazának maximális elemösszege 16.

2. példa:

Bemenet: nums = [5,10,3,10,1,13,7,9,4]
Kimenet: 19
Magyarázat: Az egyetlen indexből álló részhalmazokon kívül az indexeknek négy másik teljes részhalmaza van: {1,4}, {1,9}, {2,8}, {4,9} és {1,4 ,9}.
Az 1. és 4. indexnek megfelelő elemek összege: nums[1] + nums[4] = 5 + 10 = 15.
Az 1. és 9. indexnek megfelelő elemek összege: nums[1] + nums[9] = 5 + 4 = 9.
A 2. és 8. indexnek megfelelő elemek összege egyenlő a  nums[2] + nums[8] = 10 + 9 = 19.
A 4-es és 9-es indexnek megfelelő elemek összege: nums[4] + nums[9] = 10 + 4 = 14.
Az 1-es, 4-es és 9-es indexeknek megfelelő elemek összege: nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Ezért az indexek teljes részhalmazának maximális elemösszege 19.

Korlátozások:

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

A megadott "nums" egy 1-indexelt tömb n egész számmal.
Egy számhalmaz akkor teljes, ha elemeinek minden párjának szorzata tökéletes négyzet.
Az {1, 2, ..., n} indexhalmaz egy részhalmazának {i_1, i_2, ..., i_k} elemeinek összegét így definiáljuk: nums[i_1] + nums[i_2] + ... + nums[i_k].
Adj vissza a maximális elemszámú teljes részhalmazt az {1, 2, ..., n} indexhalmazból.
Egy tökéletes négyzet olyan szám, amely kifejezhető egy egész szám önmagával való szorzataként.

1. példa:

Input: nums = [8,7,3,5,7,2,4,9]
Output: 16
Magyarázat: Az egyetlen indexekből álló részhalmazokon kívül két további teljes részhalmaza van az indexeknek: {1,4} és {2,8}.
A 1-es és 4-es indexhez tartozó elemek összege nums[1] + nums[4] = 8 + 5 = 13.
A 2-es és 8-as indexhez tartozó elemek összege nums[2] + nums[8] = 7 + 9 = 16.
Ezért az indexek teljes részhalmazának maximális elemszáma 16.

2. példa:

Input: nums = [5,10,3,10,1,13,7,9,4]
Output: 19
Magyarázat: Az egyetlen indexekből álló részhalmazokon túl négy további teljes részhalmaza van az indexeknek: {1,4}, {1,9}, {2,8}, {4,9} és {1,4,9}.
A 1-es és 4-es indexhez tartozó elemek összege nums[1] + nums[4] = 5 + 10 = 15.
A 1-es és 9-es indexhez tartozó elemek összege nums[1] + nums[9] = 5 + 4 = 9.
A 2-es és 8-as indexhez tartozó elemek összege nums[2] + nums[8] = 10 + 9 = 19.
A 4-es és 9-es indexhez tartozó elemek összege nums[4] + nums[9] = 10 + 4 = 14.
A 1-es, 4-es és 9-es indexhez tartozó elemek összege nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Ezért az indexek teljes részhalmazának maximális elemszáma 19.

Korlátozások:

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

Kap egy 1 indexelt tömb számot n egész számból.
Egy számhalmaz akkor teljes, ha minden elempár szorzata tökéletes négyzet.
Az {1, 2, ..., n} indexhalmaz {i_1, i_2, ..., i_k} formájában ábrázolt részhalmazára elemösszegét a következőképpen definiáljuk: nums[i_1] + nums[i_2] + ... + nums[i_k].
Az {1, 2, ..., n} indexhalmaz teljes részhalmazának maximális elemösszegét adja eredményül.
A tökéletes négyzet olyan szám, amely önmagában egész szám szorzataként fejezhető ki.

1. példa:

Bemenet: nums = [8,7,3,5,7,2,4,9]
Kimenet: 16
Magyarázat: Az egyetlen indexből álló részhalmazokon kívül két másik teljes indexhalmaz is létezik: {1,4} és {2,8}.
Az 1. és 4. indexnek megfelelő elemek összege nums[1] + nums[4] = 8 + 5 = 13.
A 2. és 8. indexnek megfelelő elemek összege nums[2] + nums[8] = 7 + 9 = 16.
Ezért az indexek teljes részhalmazának maximális elemösszege 16.

2. példa:

Bemenet: nums = [5,10,3,10,1,13,7,9,4]
Kimenet: 19
Magyarázat: Az egyetlen indexből álló részhalmazokon kívül négy másik teljes index-részhalmaz is létezik: {1,4}, {1,9}, {2,8}, {4,9} és {1,4,9}.
Az 1. és 4. indexnek megfelelő elemek összege nums[1] + nums[4] = 5 + 10 = 15.
Az 1. és 9. indexnek megfelelő elemek összege egyenlő nums[1] + nums[9] = 5 + 4 = 9.
A 2. és 8. indexnek megfelelő elemek összege nums[2] + nums[8] = 10 + 9 = 19.
A 4. és 9. indexnek megfelelő elemek összege egyenlő nums[4] + nums[9] = 10 + 4 = 14.
Az 1., 4. és 9. indexnek megfelelő elemek összege egyenlő nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Ezért az indexek teljes részhalmazának maximális elemösszege 19.

Korlátok:

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


Kapsz egy bináris karakterláncot s, amely legalább egy „1”-et tartalmaz.
A biteket úgy kell átrendezni, hogy a kapott bináris szám legyen az ebből a kombinációból létrehozható maximális páratlan bináris szám.
Egy karakterláncot ad vissza, amely az adott kombinációból létrehozható maximális páratlan bináris számot reprezentálja.
Vegye figyelembe, hogy a kapott karakterlánc kezdő nullákat tartalmazhat.

1. példa:

Bemenet: s = "010"
Kimenet: "001"
Magyarázat: Mivel csak egy „1” van, ennek az utolsó pozícióban kell lennie. Tehát a válasz "001".

2. példa:

Bemenet: s = "0101"
Kimenet: "1001"
Magyarázat: Az 1-esek egyikének az utolsó pozícióban kell lennie. A fennmaradó számjegyekkel a maximális szám "100" lehet. Tehát a válasz "1001".

Korlátozások:

1 <= s.length <= 100
s csak '0'-ból és '1'-ből áll.
s legalább egy „1”-et tartalmaz.

Kap egy s bináris karakterláncot, amely legalább egy "1" -et tartalmaz.
A biteket úgy kell átrendezni, hogy az eredményül kapott bináris szám a maximális páratlan bináris szám legyen, amely ebből a kombinációból létrehozható.
Visszaad egy karakterláncot, amely az adott kombinációból létrehozható maximális páratlan bináris számot képviseli.
Vegye figyelembe, hogy az eredményül kapott karakterlánc tartalmazhat kezdő nullákat.

1. példa:

Bemenet: s = "010"
Kimenet: "001"
Magyarázat: Mivel csak egy "1" van, annak az utolsó pozícióban kell lennie. Tehát a válasz "001".

2. példa:

Bemenet: s = "0101"
Kimenet: "1001"
Magyarázat: Az egyik "1"-nek az utolsó pozícióban kell lennie. A fennmaradó számjegyekkel készíthető maximális szám "100". Tehát a válasz "1001".

Korlátok:

1 <= s.length <= 100
s csak '0'-t és '1'-et tartalmaz.
s legalább egy '1'-est tartalmaz.

Adott egy s bináris karakterlánc, amely legalább egy '1'-t tartalmaz.
A biteket úgy kell átrendezned, hogy az így kapott bináris szám a maximális páratlan bináris szám legyen, amely ebből a kombinációból létrehozható.
Visszaad egy stringet, amely a megadott kombinációból létrehozható maximális páratlan bináris számot reprezentálja.
Vegye figyelembe, hogy a kapott karakterlánc tartalmazhat vezető nullákat.

1. példa:

Bemenet:s = "010"
Kimenet:"001"
Magyarázat: Mivel csak egy '1' van, annak az utolsó pozícióban kell lennie. A válasz tehát "001".

2. példa:

Bemenet:s = "0101"
Kimenet:"1001"
Magyarázat: Az egyik '1'-nek az utolsó pozícióban kell lennie. A fennmaradó számjegyekkel legfeljebb „100” számot lehet létrehozni. A válasz tehát "1001".

Korlátozások:

1 <= s.length <= 100
s csak '0'-ból és'1'-ből áll.
s legalább egy '1'-est” tartalmaz.


Adott egy nums tömb, amely nemnegatív egész számokból áll.
A nums[l..r] résztömb pontszámát úgy határozzuk meg, hogy l <= r, mint nums[l] ÉS nums[l + 1] ÉS ... ÉS nums[r], ahol ÉS a bitenkénti ÉS művelet.
Fontolja meg a tömb egy vagy több résztömbre való felosztását oly módon, hogy a következő feltételek teljesüljenek:

A tömb minden eleme pontosan egy résztömbhez tartozik.
A résztömbek pontszámának összege a lehető legkisebb.

Adja vissza a maximális résztömbek számát egy olyan felosztásban, amely megfelel a fenti feltételeknek.
Egy résztömb a tömb egy összefüggő részét jelenti.

1. példa:

Bemenet: nums = [1,0,2,0,1,2]
Kimenet: 3
Magyarázat: Feloszthatjuk a tömböt a következő résztömbekre:
- [1,0]. Ennek a résztömbnek a pontszáma 1 ÉS 0 = 0.
- [2,0]. Ennek a résztömbnek a pontszáma 2 ÉS 0 = 0.
- [1,2]. Ennek a résztömbnek a pontszáma 1 ÉS 2 = 0.
A pontszámok összege 0 + 0 + 0 = 0, ami a lehető legkisebb elérhető pontszám.
Megmutatható, hogy nem bontható a tömb több, mint 3 résztömbre összesített pontszámmal 0. Ezért 3-at adunk vissza.

2. példa:

Bemenet: nums = [5,7,1,3]
Kimenet: 1
Magyarázat: Feloszthatjuk a tömböt egy résztömbre: [5,7,1,3] pontszámmal 1, ami a lehető legkisebb elérhető pontszám.
Megmutatható, hogy nem bontható a tömb több, mint 1 résztömbre összesített pontszámmal 1. Ezért 1-et adunk vissza.

Korlátozások:

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

Kapsz egy tömb számot, amely nem negatív egész számokból áll.
Meghatározzuk az alrendszerszámok[l..r] pontszámát úgy, hogy l <= r számok[l] ÉS számok[l + 1] ÉS ... ÉS számok[r] ahol ÉS a bitenkénti ÉS művelet.
Fontolja meg a tömb felosztását egy vagy több altömbre úgy, hogy a következő feltételek teljesüljenek:

A tömb minden eleme pontosan egy altömbhöz tartozik.
Az altáblák pontszámainak összege a lehető legkisebb.

Az altömbök maximális számát adja vissza egy olyan felosztásban, amely megfelel a fenti feltételeknek.
Az altömb egy tömb összefüggő része.

1. példa:

Bemenet: nums = [1,0,2,0,1,2]
Kimenet: 3
Magyarázat: A tömböt a következő altömbökre oszthatjuk fel:
- [1,0]. Ennek az altömbnek a pontszáma: 1 ÉS 0 = 0.
- [2,0]. Ennek az altömbnek a pontszáma: 2 ÉS 0 = 0.
- [1,2]. Ennek az altömbnek a pontszáma: 1 ÉS 2 = 0.
A pontszámok összege 0 + 0 + 0 = 0, ami a minimálisan elérhető pontszám.
Megmutatható, hogy a tömböt nem tudjuk 3-nál több altömbre felosztani 0 összpontszámmal. Tehát 3-at adunk vissza.

2. példa:

Bemenet: nums = [5,7,1,3]
Kimenet: 1
Magyarázat: A tömböt feloszthatjuk egy altömbre: [5,7,1,3] 1-es pontszámmal, ami a minimálisan elérhető pontszám.
Megmutatható, hogy a tömböt nem oszthatjuk fel 1-nél több altömbre 1 összpontszámmal. Tehát 1-et adunk vissza.

Korlátozások:

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

Kapsz egy tömbszámokat, amelyek nem negatív egész számokból állnak.
Meghatározzuk a résztömb pontszámát nums[l.. r] úgy, hogy l <= r mint nums[l] ÉS nums[l + 1] ÉS ... ÉS szám[r], ahol az AND a bitenkénti AND művelet.
Fontolja meg a tömb egy vagy több résztömbre való felosztását úgy, hogy az alábbi feltételek teljesüljenek:

A tömb minden eleme pontosan egy altömbhöz tartozik.
Az altömbök pontszámainak összege a lehető legkisebb.

A felosztásban lévő résztömbök maximális számát adja eredményül, amely megfelel a fenti feltételeknek.
Az altömb egy tömb összefüggő része.

1. példa:

Bemenet: nums = [1,0,2,0,1,2]
Kimenet: 3
Magyarázat: A tömböt a következő altömbökre oszthatjuk:
- [1,0]. Ennek az altömbnek a pontszáma 1 ÉS 0 = 0.
- [2,0]. Ennek az altömbnek a pontszáma 2 ÉS 0 = 0.
- [1,2]. Ennek az altömbnek a pontszáma 1 ÉS 2 = 0.
A pontszámok összege 0 + 0 + 0 = 0, ami a lehető legkisebb pontszám, amit elérhetünk.
Megmutatható, hogy a tömböt nem oszthatjuk fel 3-nál több résztömbre, összesen 0 ponttal. Tehát visszatérünk 3.

2. példa:

Bemenet: nums = [5,7,1,3]
Kimenet: 1
Magyarázat: A tömböt feloszthatjuk egy résztömbre: [5,7,1,3] 1-es pontszámmal, ami a minimális lehetséges pontszám.
Megmutatható, hogy a tömböt nem oszthatjuk fel 1-nél több altömbre, összesen 1 pontszámmal. Tehát visszatérünk 1.

Korlátok:

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


Kap egy 0-indexelt rendezett tömböt egész számokból.
A következő műveletet tetszőleges számú alkalommal elvégezheti:

Válasszon két indexet, az i-t és a j-t, ahol i < j, úgy, hogy nums[i] < nums[j].
Ezután távolítsa el az i és j indexek elemeit a numokból. A többi elem megtartja eredeti sorrendjét, és a tömb újraindexelésre kerül.

Egy egész számot ad vissza, amely a számok minimális hosszát jelöli a művelet tetszőleges számú végrehajtása után (beleértve a nullát is).
Vegye figyelembe, hogy a számok nem csökkenő sorrendben vannak rendezve.

1. példa:

Bemenet: nums = [1,3,4,9]
Kimenet: 0
Magyarázat: Kezdetben nums = [1, 3, 4, 9].
Az első műveletben választhatjuk a 0 és 1 indexet, mert a nums[0] < nums[1] <=> 1 < 3.
Távolítsa el a 0 és 1 indexeket, és a nums [4, 9] lesz.
A következő művelethez választhatjuk a 0 és 1 indexet, mert a nums[0] < nums[1] <=> 4 < 9.
Távolítsa el a 0 és 1 indexet, és a nums üres tömb lesz [].
Ezért az elérhető minimális hossz 0.
2. példa:

Bemenet: nums = [2,3,6,9]
Kimenet: 0
Magyarázat: Kezdetben nums = [2, 3, 6, 9].
Az első műveletben választhatjuk a 0 és 2 indexet, mert a nums[0] < nums[2] <=> 2 < 6.
Távolítsa el a 0 és 2 indexet, és a számok [3, 9] lesz.
A következő művelethez választhatjuk a 0 és 1 indexet, mert a nums[0] < nums[1] <=> 3 < 9.
Távolítsa el a 0 és 1 indexet, és a nums üres tömb lesz [].
Ezért az elérhető minimális hossz 0.

3. példa:

Bemenet: nums = [1,1,2]
Kimenet: 1
Magyarázat: Kezdetben nums = [1, 1, 2].
Egy műveletben választhatjuk a 0 és 2 indexet, mert a nums[0] < nums[2] <=> 1 < 2.
Távolítsa el a 0 és 2 indexet, és a nums [1] lesz.
A tömbön már nem lehet műveletet végrehajtani.
Ezért a minimálisan elérhető hossz 1.

Korlátok:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
A nums nem csökkenő sorrendben van rendezve.

Kapsz egy 0-indexelt, rendezett egész számokat tartalmazó tömböt.
A következő műveletet tetszőleges számú alkalommal elvégezheti:

Válasszon két indexet, az i-t és a j-t, ahol i < j, úgy, hogy a nums[i] < nums[j].
Ezután távolítsa el az i és j indexeknél lévő elemeket a számokból. A fennmaradó elemek megtartják eredeti sorrendjüket, és a tömb újraindexelésre kerül.

Olyan egész számot ad vissza, amely a számok minimális hosszát jelöli a művelet tetszőleges számú végrehajtása után (beleértve a nullát is).
Vegye figyelembe, hogy A nums nem csökkenő sorrendben van rendezve.

1. példa:

Bemenet: nums = [1,3,4,9]
Kimenet: 0
Magyarázat: Kezdetben a nums = [1, 3, 4, 9].
Az első műveletben választhatunk 0 és 1 indexet, mert nums[0] < nums[1] <=> 1 < 3.
Távolítsa el a 0 és 1 indexeket, és a nums [4, 9] lesz.
A következő művelethez a 0 és az 1 indexet választhatjuk, mivel a nums[0] < nums[1] <=> 4 < 9.
Távolítsa el a 0 és 1 indexeket, és a nums üres tömbbé válnak.
Ezért az elérhető minimális hossz 0.
2. példa:

Bemenet: nums= [2,3,6,9]
Kimenet: 0
Magyarázat: Kezdetben a nums = [2, 3, 6, 9].
Az első műveletben választhatunk 0 és 2 indexet, mert nums[0] < számok[2] <=> 2 < 6.
Távolítsa el a 0 és 2 indexeket, és a nums [3, 9] lesz.
A következő művelethez a 0 és az 1 indexet választhatjuk, mert a nums[0] < nums[1] <=> 3 < 9.
Távolítsa el a 0 és 1 indexeket, és a nums üres tömbbé válnak.
Ezért az elérhető minimális hossz 0.

3. példa:

Bemenet: nums= [1,1,2]
Kimenet: 1
Magyarázat: Kezdetben a nums = [1, 1, 2].
Egy műveletben választhatunk 0 és 2 indexet, mert a nums[0] < nums[2] <=> 1 < 2.
Távolítsa el a 0 és 2 indexeket, és a nums [1] lesz.
A tömbön már nem lehet műveletet végrehajtani.
Ezért a minimális elérhető hossz 1.

Korlátozások:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
A nums nem csökkenő sorrendben van rendezve.

Kap egy 0-indexelt rendezett tömböt egész számokból.
A következő műveletet tetszőleges számú alkalommal elvégezheti:

Válasszon két indexet, az i-t és a j-t, ahol i < j, úgy, hogy nums[i] < nums[j].
Ezután távolítsa el az i és j indexek elemeit a numokból. A többi elem megtartja eredeti sorrendjét, és a tömb újraindexelésre kerül.

Egy egész számot ad vissza, amely a számok minimális hosszát jelöli a művelet tetszőleges számú végrehajtása után (beleértve a nullát is).
Vegye figyelembe, hogy a számok nem csökkenő sorrendben vannak rendezve.

1. példa:

Bemenet: nums = [1,3,4,9]
Kimenet: 0
Magyarázat: Kezdetben nums = [1, 3, 4, 9].
Az első műveletben választhatjuk a 0 és 1 indexet, mert a nums[0] < nums[1] <=> 1 < 3.
Távolítsa el a 0 és 1 indexeket, és a nums [4, 9] lesz.
A következő művelethez választhatjuk a 0 és 1 indexet, mert a nums[0] < nums[1] <=> 4 < 9.
Távolítsa el a 0 és 1 indexet, és a nums üres tömb lesz [].
Ezért az elérhető minimális hossz 0.
2. példa:

Bemenet: nums = [2,3,6,9]
Kimenet: 0
Magyarázat: Kezdetben nums = [2, 3, 6, 9].
Az első műveletben választhatjuk a 0 és 2 indexet, mert a nums[0] < nums[2] <=> 2 < 6.
Távolítsa el a 0 és 2 indexet, és a számok [3, 9] lesz.
A következő művelethez választhatjuk a 0 és 1 indexet, mert a nums[0] < nums[1] <=> 3 < 9.
Távolítsa el a 0 és 1 indexet, és a nums üres tömb lesz [].
Ezért az elérhető minimális hossz 0.

3. példa:

Bemenet: nums = [1,1,2]
Kimenet: 1
Magyarázat: Kezdetben nums = [1, 1, 2].
Egy műveletben választhatjuk a 0 és 2 indexet, mert a nums[0] < nums[2] <=> 1 < 2.
Távolítsa el a 0 és 2 indexet, és a nums [1] lesz.
A tömbön már nem lehet műveletet végrehajtani.
Ezért a minimálisan elérhető hossz 1.

Korlátok:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
A NUMS nem csökkenő sorrendben van rendezve.


Kap egy 0-indexelt tömbszámot a nem negatív egész számokból, és két egész számot l és r.
A számon belüli részhalmazok számát adja eredményül, ahol az egyes részhalmazok elemeinek összege az [l, r] tartományba esik.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
A részmultihalmaz a tömb elemeinek rendezetlen gyűjteménye, amelyben egy adott x érték 0, 1, ..., occ[x] alkalommal fordulhat elő, ahol occ[x] az x előfordulásainak száma a tömbben.
Vegye figyelembe, hogy:

Két al-multiset ugyanaz, ha mindkét al-multiset rendezése azonos multihalmazokat eredményez.
Egy üres multihalmaz összege 0.

1. példa:

Bemenet: nums = [1,2,2,3], l = 6, r = 6
Kimenet: 1
Magyarázat: A számok egyetlen részhalmaza, amelynek összege 6, az {1, 2, 3}.

2. példa:

Bemenet: nums = [2,1,4,2,7], l = 1, r = 5
Kimenet: 7
Magyarázat: Az [1, 5] tartományba eső összeggel rendelkező számhalmazok a következők: {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} és {1, 2, 2}.

3. példa:

Bemenet: nums = [1,2,1,3,5,2], l = 3, r = 5
Kimenet: 9
Magyarázat: A [3, 5] tartományba eső összeggel rendelkező számhalmazok a következők: {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} és {1, 2, 2}.

Korlátok:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
A számok összege nem haladja meg a 2 * 10^4-et.
0 < = l <= r <= 2 * 10^4

Kap egy 0-indexelt tömbnumsot a nem negatív egész numsokból, és két egész numsot l és r.
A tömbben található részhalmazok numsát adja eredményül, ahol az egyes részhalmazok elemeinek összege az [l, r] tartományba esik.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
A részmultihalmaz a tömb elemeinek olyan rendezetlen gyűjteménye, amelyben egy adott x érték 0, 1, ..., occ[x] alkalommal fordulhat elő. amelyben egy adott x érték 0, 1, ..., occ[x] alkalommal fordulhat elő, ahol occ[x] az x előfordulásainak numsa a tömbben.
Vegye figyelembe, hogy:

Két al-multiset ugyanaz, ha mindkét al-multiset rendezése azonos multihalmazokat eredményez.
Egy üres multihalmaz összege 0.

1. példa:

Bemenet: nums = [1,2,2,3], l = 6, r = 6
Kimenet: 1
Magyarázat: A számok egyetlen részhalmaza, amelynek összege 6, az {1, 2, 3}.

2. példa:

Bemenet: szám = [2,1,4,2,7], l = 1, r = 5
Kimenet: 7
Magyarázat: Az [1, 5] tartományba eső összeggel rendelkező számhalmazok a következők: {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} és {1, 2, 2}.

3. példa:

Bemenet: nums = [1,2,1,3,5,2], l = 3, r = 5
Kimenet: 9
Magyarázat: A [3, 5] tartományba eső összeggel rendelkező számhalmazok a következők: {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} és {1, 2, 2}.

Korlátok:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
A számok összege nem haladja meg a 2 * 10^4-et.
0 < = l <= r <= 2 * 10^4

Kapunk egy 0-indexelt tömböt, amely nemnegatív egész számokat tartalmaz, valamint két l és r egész számot.
A részhalmazok számát adja vissza számokon belül, ahol az egyes részhalmazok elemeinek összege az [l, r] tartományba esik.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
Az al-multhalmaz a tömb elemeinek rendezetlen gyűjteménye, amelyben egy adott x érték 0, 1, ..., occ[x] alkalommal fordulhat elő, ahol occ[x] az x előfordulások száma a tömbben .
Vegye figyelembe, hogy:

Két al-multhalmaz azonos, ha mindkét al-multhalmaz rendezése azonos multihalmazokat eredményez.
Egy üres multihalmaz összege 0.

példa 1:

Bemenet: nums = [1,2,2,3], l = 6, r = 6
Kimenet: 1
Magyarázat: A számok egyetlen részhalmaza, amelynek összege 6, az {1, 2, 3}.

példa 2:

Bemenet: nums = [2,1,4,2,7], l = 1, r = 5
Kimenet: 7
Magyarázat: Azok a számok részhalmazai, amelyek összege az [1, 5] tartományon belül van, a következők: {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} és {1, 2, 2}.

példa 3:

Bemenet: nums = [1,2,1,3,5,2], l = 3, r = 5
Kimenet: 9
Magyarázat: A számok azon részhalmazai, amelyek összege a [3, 5] tartományon belül van, a következők: {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3} , {1, 1, 2}, {1, 1, 3} és {1, 2, 2}.

Korlátozások:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
A számok összege nem haladja meg a 2 * 10^4 értéket.
0 <= l <= r <= 2 * 10^4


Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Olyan egész számot ad vissza, amely azoknak az elemeknek az összegét jelöli számokban, amelyeknek a megfelelő indexei pontosan k bitet tartalmaznak a bináris ábrázolásukban.
Az egész szám beállított bitjei az 1-esek jelen vannak, amikor binárisan írjuk.

Például a 21 bináris reprezentációja 10101, amely 3 beállított bittel rendelkezik.

1. példa:

Bemenet: nums = [5,10,1,5,2], k = 1
Kimenet: 13
Magyarázat: Az indexek bináris ábrázolása a következő:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Az 1., 2. és 4. indexek bináris ábrázolásában k = 1 beállított bit van.
Ezért a válasz számok[1] + számok[2] + számok[4] = 13.
2. példa:

Bemenet: numsk = [4,3,2,1], k = 2
Kimenet: 1
Magyarázat: Az indexek bináris ábrázolása a következő:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Csak a 3. indexnek van k = 2 beállított bitje a bináris reprezentációjában.
Ezért a válasz számok[3] = 1.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Egy egész számot ad vissza, amely azoknak az elemeknek az összegét jelöli számokban, amelyek megfelelő indexei pontosan k bit bitet tartalmaznak a bináris ábrázolásukban.
Az egész szám beállított bitjei az 1-esek jelen vannak, amikor binárisan írjuk.

Például a 21 bináris ábrázolása 10101, amely 3 beállított bittel rendelkezik.

Példa 1:

Bemenet: nums = [5,10,1,5,2], k = 1
Kimenet: 13
Magyarázat: Az indexek bináris ábrázolása a következő:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Az 1., 2. és 4. indexek bináris ábrázolásában k = 1 bitkészlet van.
Ezért a válasz: nums[1] + nums[2] + nums[4] = 13.
2. példa:

Bemenet: nums = [4,3,2,1], k = 2
Kimenet: 1
Magyarázat: Az indexek bináris ábrázolása a következő:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Csak a 3. indexnek van k = 2 beállított bitje a bináris reprezentációjában.
Ezért a válasz: nums[3] = 1.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Olyan egész számot ad eredményül, amely azoknak az elemeknek az összegét jelöli számokban, amelyek megfelelő indexei bináris ábrázolásukban pontosan k halmazbitek vannak.
Az egész szám halmazbitjei az 1 jelen vannak, ha binárisan írják.

Például a 21 bináris ábrázolása 10101, amely 3 beállított bittel rendelkezik.

1. példa:

Bemenet: nums = [5,10,1,5,2], k = 1
Kimenet: 13
Magyarázat: Az indexek bináris ábrázolása a következő:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Az 1., 2. és 4. indexek bináris ábrázolásában k = 1 halmazbit van.
Ezért a válasz nums[1] + nums[2] + nums[4] = 13.
2. példa:

Bemenet: nums = [4,3,2,1], k = 2
Kimenet: 1
Magyarázat: Az indexek bináris ábrázolása a következő:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Csak a 3. indexnek van k = 2 halmazbitje a bináris ábrázolásában.
Ezért a válasz nums[3] = 1.

Korlátok:

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


Adott egy 0-indextől indexelt tömb, nums, amely pozitív egész számokból áll.
Kétféle művelet létezik, amelyeket tetszőleges számú alkalommal alkalmazhat a tömbön:

Válasszon ki két azonos értékű elemet, és törölje őket a tömbből.
Válasszon ki három egyenlő értékű elemet, és törölje őket a tömbből.

Adja vissza a minimális számú műveletet ahhoz, hogy a tömb üres legyen, vagy -1-et, ha ez nem lehetséges.

1. példa:

Bemenet: nums = [2,3,3,2,2,4,2,3,4]
Kimenet: 4
Magyarázat: A következő műveleteket alkalmazhatjuk a tömb üressé tételéhez:
- Alkalmazza az első műveletet a 0 és 3 indexű elemekre. Az eredményül kapott tömb nums = [3,3,2,4,2,3,4].
- Alkalmazza az első műveletet a 2-es és 4-es indexű elemekre. Az eredményül kapott tömb nums = [3,3,4,3,4].
- Alkalmazza a második műveletet a 0, 1 és 3 indexű elemekre. Az eredményül kapott tömb nums = [4,4].
- Alkalmazza az első műveletet a 0 és 1 indexű elemekre. Az eredményül kapott tömb nums = [].
Megmutatható, hogy 4-nél kevesebb művelettel nem tudjuk üressé tenni a tömböt.

2. példa:

Bemenet: nums = [2,1,2,2,3,3]
Kimenet: -1
Magyarázat: A tömb ürítése lehetetlen.

Korlátozások:

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

Kapsz egy 0-indexelt tömbszámokat, amelyek pozitív egész számokból állnak.
A tömbön tetszőleges számú művelettípus alkalmazható:

Válasszon ki két azonos értékű elemet, és törölje őket a tömbből.
Válasszon ki három azonos értékű elemet, és törölje őket a tömbből.

A tömb üresítéséhez szükséges műveletek minimális számát adja vissza, vagy -1 értéket, ha ez nem lehetséges.

1. példa:

Bemenet: nums = [2,3,3,2,2,4,2,3,4]
Kimenet: 4
Magyarázat: A tömb üresítéséhez a következő műveleteket alkalmazhatjuk:
- Alkalmazza az első műveletet a 0 és 3 indexű elemeken. Az eredményül kapott tömb nums = [3,3,2,4,2,3,4].
- Alkalmazza az első műveletet a 2. és 4. indexen lévő elemeken. Az eredményül kapott tömb nums = [3,3,4,3,4].
- Alkalmazza a második műveletet a 0, 1 és 3 indexű elemekre. Az eredményül kapott tömb nums = [4,4].
- Alkalmazza az első műveletet a 0 és 1 indexű elemeken. Az eredményül kapott tömb nums = [].
Megmutatható, hogy 4 műveletnél kevesebbel nem tudjuk üresíteni a tömböt.

2. példa:

Bemenet: nums = [2,1,2,2,3,3]
Kimenet: -1
Magyarázat: A tömböt nem lehet kiüríteni.

Korlátok:

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

Kapsz egy 0-indexelt tömb számokat, amelyek pozitív egész számokból állnak.
Kétféle művelet létezik, amelyeket tetszőleges számú alkalommal alkalmazhat a tömbön:

Válasszon ki két azonos értékű elemet, és törölje őket a tömbből.
Válasszon ki három egyenlő értékű elemet, és törölje őket a tömbből.

Adja vissza a minimális számú műveletet ahhoz, hogy a tömb üres legyen, vagy -1-et, ha ez nem lehetséges.

1. példa:

Bemenet: nums  = [2,3,3,2,2,4,2,3,4]
Kimenet: 4
Magyarázat: A következő műveleteket alkalmazhatjuk a tömb üressé tételéhez:
- Alkalmazza az első műveletet a 0 és 3 indexű elemekre. Az eredményül kapott tömb a szám = [3,3,2,4,2,3,4].
- Alkalmazza az első műveletet a 2-es és 4-es indexű elemekre. Az eredményül kapott tömb a szám = [3,3,4,3,4].
- Alkalmazza a második műveletet a 0, 1 és 3 indexű elemekre. Az eredményül kapott tömb a szám = [4,4].
- Alkalmazza az első műveletet a 0 és 1 indexű elemekre. Az eredményül kapott tömb a szám = [].
Megmutatható, hogy 4-nél kevesebb művelettel nem tudjuk üressé tenni a tömböt.

2. példa:

Bemenet: nums  = [2,1,2,2,3,3]
Kimenet: -1
Magyarázat: A tömb ürítése lehetetlen.

Korlátozások:

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


Kapsz egy 0-indexelt egész tömböt, melynek hossza n, ahol n az osztály tanulóinak teljes száma. Az osztályfőnök igyekszik úgy kiválasztani a tanulócsoportot, hogy minden diák boldog maradjon.
Az i. tanuló akkor lesz boldog, ha a következő két feltétel valamelyike teljesül:

A tanuló kiválasztásra kerül, és a kiválasztott tanulók összlétszáma szigorúan nagyobb, mint a nums[i].
A tanuló nem kerül kiválasztásra, és a kiválasztott tanulók összlétszáma szigorúan kevesebb, mint nums[i].

Adja meg a tanulócsoport kiválasztásának számos módját, hogy mindenki elégedett maradjon.

1. példa:

Bemenet: nums = [1,1]
Kimenet: 2
Magyarázat:
A két lehetséges út a következő:
Az osztályfőnök nem választ tanulót.
Az osztályfőnök mindkét tanulót kiválasztja a csoportba.
Ha az osztályfőnök csak egy tanulót választ ki egy csoportba, akkor mindkét diák nem lesz elégedett. Ezért csak két lehetséges út van.

2. példa:

Bemenet: nums = [6,0,3,3,6,7,2,7]
Kimenet: 3
Magyarázat:
A három lehetséges mód a következő:
Az osztályfőnök kiválasztja az 1 indexű tanulót a csoportba.
Az osztályfőnök kiválasztja az 1, 2, 3, 6 indexű tanulókat a csoportba.
Az osztályfőnök minden tanulót kiválaszt a csoportba.

Korlátozások:

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

Kap egy 0-indexelt egész számokból álló tömböt, amelynek hossza n, ahol n az osztály tanulóinak teljes száma, ahol n az osztály tanulóinak teljes száma. Az osztálytanár megpróbál kiválasztani egy diákcsoportot, hogy minden diák boldog maradjon.
Az i^th tanuló akkor lesz boldog, ha az alábbi két feltétel valamelyike teljesül:

A tanuló ki van választva, és a kiválasztott tanulók teljes száma szigorúan nagyobb, mint a nums[i].
A tanuló nincs kiválasztva, és a kiválasztott hallgatók teljes száma szigorúan kevesebb, mint a nums[i].

Adja vissza a diákcsoportok kiválasztásának módjainak számát, hogy mindenki boldog maradjon.

1. példa:

Bemenet: nums = [1,1]
Kimenet: 2
Magyarázat:
A két lehetséges módszer a következő:
Az osztályfőnök nem választ ki egyetlen tanulót sem.
Az osztályfőnök mindkét tanulót kiválasztja a csoport létrehozásához.
Ha az osztályfőnök csak egy tanulót választ ki egy csoport létrehozására, akkor mindkét diák nem lesz boldog. Ezért csak két lehetséges módja van.

2. példa:

Bemenet: nums = [6,0,3,3,6,7,2,7]
Kimenet: 3
Magyarázat:
A három lehetséges módszer a következő:
Az osztálytanár kiválasztja a tanulót index = 1 értékkel a csoport létrehozásához.
Az osztálytanár kiválasztja a tanulókat index = 1, 2, 3, 6 a csoport kialakításához.
Az osztályfőnök kiválasztja az összes tanulót a csoport létrehozásához.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömböt, amelyek n hosszúságúak, ahol n az osztály tanulóinak teljes száma. Az osztályfőnök igyekszik olyan tanulócsoportot kiválasztani, hogy minden diák boldog maradjon.
Az i. tanuló akkor lesz boldog, ha a következő két feltétel valamelyike teljesül:

A tanuló kiválasztásra kerül, és a kiválasztott tanulók összlétszáma szigorúan nagyobb, mint a nums[i].
A tanuló nem kerül kiválasztásra, és a kiválasztott tanulók összlétszáma szigorúan kevesebb, mint nums[i].

Adja meg a tanulócsoport kiválasztásának számos módját, hogy mindenki elégedett legyen.

1. példa:

Bemenet: nums = [1,1]
Kimenet: 2
Magyarázat:
A két lehetséges út a következő:
Az osztályfőnök nem választ tanulót.
Az osztályfőnök mindkét tanulót kiválasztja a csoportba.
Ha az osztályfőnök csak egy tanulót választ ki egy csoportba, akkor mindkét diák nem lesz elégedett. Ezért csak két lehetséges út van.

2. példa:

Bemenet: nums= [6,0,3,3,6,7,2,7]
Kimenet: 3
Magyarázat:
A három lehetséges mód a következő:
Az osztályfőnök kiválasztja az 1 indexű tanulót a csoportba.
Az osztályfőnök kiválasztja az 1, 2, 3, 6 indexű tanulókat a csoportba.
Az osztályfőnök minden tanulót kiválaszt a csoportba.

Korlátozások:

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


Adott egy 0-indexált egész számok nums tömbje és egy egész szám cél.
Adja vissza a nums leghosszabb részsorozatának hosszát, amely a célértéket eléri. Ha nincs ilyen részsorozat, akkor -1-et ad vissza.
A részsorozat olyan tömb, amely egy másik tömbből származtatható néhány vagy egyetlen elem törlésével anélkül, hogy a megmaradó elemek sorrendje megváltozna.

Példa 1:

bemenet: nums = [1,2,3,4,5], target = 9
Kimenet: 3
Magyarázat: 3 olyan részsorozat van, amelynek összege 9: [4,5], [1,3,5] és [2,3,4]. A leghosszabb részsorozatok az [1,3,5] és a [2,3,4]. A válasz tehát 3.

2. példa:

bemenet:nums = [4,1,3,2,1,5], target = 7
Kimenet: 4
Magyarázat: 5 olyan részsorozat van, amelynek összege 7: [4,3], [4,1,2], [4,2,1], [1,1,5] és [1,3,2,1]. A leghosszabb részsorozat az [1,3,2,1]. A válasz tehát 4.

3. példa:

bemenet: nums = [1,1,5,4,5], target = 3
Kimenet: -1
Magyarázat: Megmutatható, hogy a numsnak nincs olyan részsorozata, amelynek összege 3.

Korlátozások:

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

Kapsz egy 0-indexelt egész számokból álló tömböt és egy egész célt.
A nums leghosszabb részsorozatának hosszát adja vissza, amely összegezi a célt. Ha nem létezik ilyen részsorozat, adja vissza a -1-et.
Az alsorozat olyan tömb, amely egy másik tömbből származtatható úgy, hogy néhány elemet vagy egyetlen elemet sem töröl a többi elem sorrendjének megváltoztatása nélkül.

1. példa:

Bemenet: nums = [1,2,3,4,5], target = 9
Kimenet: 3
Magyarázat: 3 részsorozat van, amelyek összege 9: [4,5], [1,3,5] és [2,3,4]. A leghosszabb részsorozatok: [1,3,5] és [2,3,4]. Ezért a válasz a 3.

2. példa:

Bemenet: nums = [4,1,3,2,1,5], target = 7
Kimenet: 4
Magyarázat: 5 részsorozat van, amelyek összege 7: [4,3], [4,1,2], [4,2,1], [1,1,5] és [1,3,2 ,1]. A leghosszabb részsorozat [1,3,2,1]. Ezért a válasz a 4.

3. példa:

Bemenet: nums = [1,1,5,4,5], target = 3
Kimenet: -1
Magyarázat: Kimutatható, hogy a számoknak nincs olyan részsorozata, amely 3-at összegezne.

Korlátozások:

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

Kapsz egy 0-indexelt egész számokból álló tömböt és egy egész célt.
A számok leghosszabb részsorozatának hosszát adja vissza, amely összegezi a célt. Ha nem létezik ilyen részsorozat, adja vissza a -1-et.
Az alsorozat olyan tömb, amely egy másik tömbből származtatható úgy, hogy néhány elemet vagy egyetlen elemet sem töröl a többi elem sorrendjének megváltoztatása nélkül.

1. példa:

Bemenet: nums = [1,2,3,4,5], target = 9
Kimenet: 3
Magyarázat: 3 részsorozat van, amelyek összege 9: [4,5], [1,3,5] és [2,3,4]. A leghosszabb részsorozatok: [1,3,5] és [2,3,4]. Ezért a válasz a 3.

2. példa:

Bemenet: nums = [4,1,3,2,1,5], target = 7
Kimenet: 4
Magyarázat: 5 részsorozat van, amelyek összege 7: [4,3], [4,1,2], [4,2,1], [1,1,5] és [1,3,2 ,1]. A leghosszabb részsorozat [1,3,2,1]. Ezért a válasz a 4.

3. példa:

Bemenet: nums = [1,1,5,4,5], target = 3
Kimenet: -1
Magyarázat: Kimutatható, hogy a számoknak nincs olyan részsorozata, amely 3-at összegezne.

Korlátozások:

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


Adott egy 0 indexű, n egész számból álló maxHeights tömb.
Feladatod, hogy építs n tornyot a koordinátasorban. Az i^-edik torony az i koordinátán épül, és magassága heights[i].
A tornyok egy konfigurációja akkor szép, ha a következő feltételek teljesülnek:

1 <= heights[i] <= maxHeights[i]
heights egy hegyi tömb.

A heights tömb akkor hegy, ha létezik olyan i index, hogy:

Minden 0 < j <= i, heights[j - 1] <= heights[j]
Minden i <= k < n - 1 esetén heights[k + 1] <= heights[k]

Visszaadja a tornyok egy szép konfigurációjának maximálisan lehetséges magassági összegét.

1. példa:

Bemenet: maxHeights = [5,3,4,1,1,1]
Kimenet: 13
Magyarázat: Egy szép, maximális összegű konfiguráció a heights = [5,3,3,3,1,1]. Ez a konfiguráció azért szép, mert:
- 1 <= heights[i] <= maxHeights[i]
- heights egy hegy, amelynek csúcsa i = 0.
Megmutatható, hogy nem létezik más olyan szép konfiguráció, amelynek a magasságok összege nagyobb, mint 13.
2. példa:

Bemenet: maxHeights = [6,5,3,9,2,7]
Kimenet: 22
Magyarázat: Egy szép, maximális összegű konfiguráció a heights = [3,3,3,3,9,2,2,2]. Ez a konfiguráció azért szép, mert:
- 1 <= heights[i] <= maxHeights[i]
- heights egy hegy, amelynek csúcsa i = 3.
Megmutatható, hogy nem létezik más olyan szép konfiguráció, amelynek a magasságok összege nagyobb lenne 22-nél.
3. példa:

Bemenet: maxHeights = [3,2,5,5,2,2,3]
Kimenet: 18
Magyarázat: Egy szép, maximális összegű konfiguráció a heights = [2,2,5,5,5,2,2,2]. Ez a konfiguráció azért szép, mert:
- 1 <= heights[i] <= maxHeights[i]
- heights egy hegy, amelynek csúcsa i = 2.
Megjegyezzük, hogy ennél a konfigurációnál i = 3 is tekinthető csúcsnak.
Megmutatható, hogy nem létezik más olyan szép konfiguráció, amelynek a magasságok összege nagyobb lenne 18-nál.

Korlátozások:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

Kapsz egy 0-indexelt maxHeights n egész számból álló tömböt.
Az a feladat, hogy n tornyot építsünk a koordináta vonalon. Az i^th torony az i koordinátán épül, és a magassága heights[i].
A tornyok konfigurációja szép, ha a következő feltételek teljesülnek:

1 <= heights[i] <= maxHeights[i]
Heights egy hegytömb.

A tömbmagasságok egy hegy, ha létezik olyan i index, amelyre:

Minden 0 < j <= i, magasságok[j - 1] <= magasságok[j]
Minden i <= k < n - 1, magasság [k + 1] <= magasság[k]

Egy gyönyörű toronykonfiguráció magasságainak maximális összegét adja vissza.

Példa 1:

Bemenet: maxHeights = [5,3,4,1,1]
Kimenet: 13
Magyarázat: Egy gyönyörű konfiguráció maximális összeggel a heights = [5,3,3,1,1]. Ez a konfiguráció gyönyörű, mert:
- 1 <= heights[i] <= maxHeights[i]
- a magasság egy hegy, amelynek csúcsa i = 0.
Kimutatható, hogy nem létezik más gyönyörű konfiguráció, amelynek magasságösszege nagyobb 13-nál.
Példa 2:

Bemenet: maxHeights = [6,5,3,9,2,7]
Kimenet: 22
Magyarázat: Egy gyönyörű konfiguráció maximális összeggel a heights = [3,3,3,9,2,2]. Ez a konfiguráció gyönyörű, mert:
- 1 <= heights[i] <= maxHeights[i]
- a magasság egy hegy, amelynek csúcsa i = 3.
Kimutatható, hogy nem létezik más gyönyörű konfiguráció, amelynek magasságösszege nagyobb 22-nél.
Példa 3:

Bemenet: maxHeights = [3,2,5,5,2,3]
Kimenet: 18
Magyarázat: Egy gyönyörű konfiguráció maximális összeggel a heights = [3,3,3,9,2,2]. Ez a konfiguráció gyönyörű, mert:
- 1 <= heights[i] <= maxHeights[i]
- a magasság egy hegy, amelynek csúcsa i = 2.
Vegye figyelembe, hogy ennél a konfigurációnál az i = 3 is csúcsnak tekinthető.
Kimutatható, hogy nem létezik más gyönyörű konfiguráció, amelynek magasságösszege nagyobb 18-nál.

Korlátozások:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

Kapsz egy 0-indexelt maxHeights n egész számból álló tömböt.
Az Ön feladata, hogy n tornyot építsen a koordinátavonalban. Az i^edik torony az i koordinátán épült, és magassága [i].
A tornyok konfigurációja szép, ha a következő feltételek teljesülnek:

1 <= heights[i] <= maxHeights[i]
A heights egy hegytömb.

A tömbmagasságok egy hegy, ha létezik olyan i index, amelyre:

Minden 0 < j <= i, heights[j - 1] <= heights[j]
Minden  i <= k < n - 1, heights[k + 1] <= heights[k]

Egy gyönyörű toronykonfiguráció magasságainak maximális összegét adja vissza.

1. példa:

Bemenet: maxHeights = [5,3,4,1,1]
Kimenet: 13
Magyarázat: Egy gyönyörű konfiguráció maximális összeggel a heights = [5,3,3,1,1]. Ez a konfiguráció gyönyörű, mivel:
- 1 <= heights[i] <= maxHeights[i]
- a magasságok egy hegy, amelynek csúcsa i = 0.
Kimutatható, hogy nem létezik más gyönyörű konfiguráció, amelynek magasságösszege nagyobb 13-nál.
2. példa:

Bemenet: maxHeights = [6,5,3,9,2,7]
Kimenet: 22
Magyarázat: Egy gyönyörű konfiguráció maximális összeggel a heights = [3,3,3,9,2,2]. Ez a konfiguráció gyönyörű, mivel:
- 1 <= heights[i] <= maxHeights[i]
- a magasságok egy hegy, amelynek csúcsa i = 3.
Kimutatható, hogy nem létezik más gyönyörű konfiguráció, amelynek magasságösszege nagyobb 22-nél.
3. példa:

Bemenet: maxHeights = [3,2,5,5,2,3]
Kimenet: 18
Magyarázat: Egy gyönyörű konfiguráció maximális összeggel magasság = [2,2,5,5,2,2]. Ez a konfiguráció gyönyörű, mivel:
- 1 <= magasság[i] <= maxMagasság[i]
- a magasságok egy hegy, amelynek csúcsa i = 2.
Vegye figyelembe, hogy ennél a konfigurációnál az i = 3 is csúcsnak tekinthető.
Kimutatható, hogy nem létezik más gyönyörű konfiguráció, amelynek magasságösszege nagyobb 18-nál.

Korlátozások:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9


Adott egy 0-indexált nums tömb és egy egész szám cél.
Egy 0-indexált infinite_nums tömb úgy keletkezik, hogy a nums elemeit végtelenszer fűzzük egymás után.
Vissza kell adni az infinite_nums tömb legrövidebb részhalmazának hosszát, amelynek összege megegyezik a target értékkel. Ha nincs ilyen részhalmaz, térj vissza -1 értékkel.

Példa 1:

Bemenet: nums = [1,2,3], target = 5
Kimenet: 2
Magyarázat: Ebben az esetben infinite_nums = [1,2,3,1,2,3,1,2,...].
Az [1,2] tartományban lévő részhalmaz összege megegyezik a target = 5 értékkel és hossza 2.
Bizonyítható, hogy 2 a legrövidebb hosszú részhalmaz, amelynek az összege megegyezik a target = 5 értékkel.

Példa 2:

Bemenet: nums = [1,1,1,2,3], target = 4
Kimenet: 2
Magyarázat: Ebben az esetben infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...].
A [4,5] tartományban lévő részhalmaz összege megegyezik a target = 4 értékkel és hossza 2.
Bizonyítható, hogy 2 a legrövidebb hosszú részhalmaz, amelynek összege megegyezik a target = 4 értékkel.

Példa 3:

Bemenet: nums = [2,4,6,8], target = 3
Kimenet: -1
Magyarázat: Ebben az esetben infinite_nums = [2,4,6,8,2,4,6,8,...].
Bizonyítható, hogy nincs olyan részhalmaz, amelynek az összege megegyezik a target = 3 értékkel.

Korlátozások:

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

Kapsz egy 0-indexelt tömbszámot és egy egész célt.
Egy 0-indexelt végtelen_szám tömb úgy jön létre, hogy a számok elemeit végtelenül hozzáfűzi önmagához.
A végtelen_számok tömb legrövidebb altömbjének hosszát adja vissza célértékkel egyenlő összeggel. Ha nincs ilyen altömb visszatérés -1.

1. példa:

Bemenet: nums = [1,2,3], target = 5
Kimenet: 2
Magyarázat: Ebben a példában végtelen_számok = [1,2,3,1,2,3,1,2,...].
Az [1,2] tartományban lévő altömb összege cél = 5 és hossza = 2.
Bizonyítható, hogy 2 egy olyan résztömb legrövidebb hossza, amelynek összege cél = 5.

2. példa:

Bemenet: nums = [1,1,1,2,3], target = 4
Kimenet: 2
Magyarázat: Ebben a példában végtelen_számok = [1,1,1,2,3,1,1,1,2,3,1,1,...].
A [4,5] tartományban lévő altömb összege egyenlő cél = 4 és hossza = 2.
Bizonyítható, hogy 2 egy olyan résztömb legrövidebb hossza, amelynek összege cél = 4.

3. példa:

Bemenet: nums = [2,4,6,8], target = 3
Kimenet: -1
Magyarázat: Ebben a példában végtelen_számok = [2,4,6,8,2,4,6,8,...].
Bebizonyítható, hogy nincs olyan résztömb, amelynek összege egyenlő cél = 3-mal.

Korlátozások:

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

Kap egy 0 indexelt tömbszámot és egy egész célt.
A 0-indexelt tömb infinite_nums úgy jön létre, hogy a számok elemeit végtelenül hozzáfűzi magához.
A tömb legrövidebb résztömbjének hosszát adja eredményül, infinite_nums a céllal megegyező összeggel. Ha nincs ilyen altömb, adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [1,2,3], target = 5
Kimenet: 2
Magyarázat: Ebben a példában infinite_nums = [1,2,3,1,2,3,1,2,...].
Az [1,2] tartomány résztömbjének összege megegyezik a cél = 5 és a hossz = 2 értékkel.
Bizonyítható, hogy 2 egy altömb legrövidebb hossza, amelynek összege megegyezik a cél = 5-tel.

2. példa:

Bemenet: nums = [1,1,1,2,3], target = 4
Kimenet: 2
Magyarázat: Ebben a példában infinite_nums = [1,1,1,2,3,1,1,1,1,2,3,1,1,...].
A [4,5] tartomány résztömbjének összege megegyezik a cél = 4 és a hossz = 2 értékkel.
Bizonyítható, hogy 2 egy altömb legrövidebb hossza, amelynek összege megegyezik a cél = 4-gyel.

3. példa:

Bemenet: nums = [2,4,6,8], target = 3
Kimenet: -1
Magyarázat: Ebben a példában infinite_nums = [2,4,6,8,2,4,6,8,...].
Bizonyítható, hogy nincs olyan altömb, amelynek összege megegyezik a cél = 3-mal.

Korlátok:

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


Kapsz egy bináris s karakterláncot és egy k pozitív egész számot.
Az s részsztringje akkor szép, ha a benne lévő 1-esek száma pontosan k.
Legyen len a legrövidebb gyönyörű részsztring hossza.
Adja vissza az s karakterlánc lexikográfiailag legkisebb gyönyörű részkarakterláncát, amelynek hossza megegyezik a lennel. Ha az s nem tartalmaz szép részsztringet, adjon vissza egy üres karakterláncot.
Az a karakterlánc lexikográfiailag nagyobb, mint egy b karakterlánc (azonos hosszúságú), ha az első pozícióban, ahol a és b különbözik, a karaktere szigorúan nagyobb, mint a b megfelelő karaktere.

Például az "abcd" lexikográfiailag nagyobb, mint az "abcc", mert az első pozíció, amelyben különböznek, a negyedik karakternél van, és d nagyobb, mint c.

1. példa:

Bemenet: s = "100011001", k = 3
Kimenet: "11001"
Magyarázat: Ebben a példában 7 gyönyörű részsztring van:
1. Az "100011001" alkarakterlánc.
2. Az "100011001" alkarakterlánc.
3. Az "100011001" alkarakterlánc.
4. Az "100011001" alkarakterlánc.
5. Az "100011001" alkarakterlánc.
6. Az "100011001" alkarakterlánc.
7. Az "100011001" alkarakterlánc.
A legrövidebb gyönyörű alsztring hossza 5.
A lexikográfiailag legkisebb szép, 5 hosszúságú alsztring a "11001" alsztring.

2. példa:

Bemenet: s = "1011", k = 2
Kimenet: "11"
Magyarázat: Ebben a példában 3 gyönyörű részsztring van:
1. Az "1011" alkarakterlánc.
2. Az "1011" alkarakterlánc.
3. Az "1011" alkarakterlánc.
A legrövidebb gyönyörű alsztring hossza 2.
A lexikográfiailag legkisebb szép, 2 hosszúságú alsztring a "11" alsztring.

3. példa:

Bemenet: s = "000", k = 1
Kimenet: ""
Magyarázat: Ebben a példában nincsenek szép részsztringek.

Korlátok:

1 < = s.hossz <= 100
1 < = k <= s.hossz

Kapsz egy s bináris karakterláncot és egy k pozitív egész számot.
Egy s részkarakterlánc akkor szép, ha az 1-esek száma pontosan k.
Legyen len a legrövidebb gyönyörű részkarakterlánc hossza.
Adja vissza az s karakterlánc lexikográfiailag legkisebb gyönyörű részkarakterláncát, amelynek hossza len egyenlő. Ha az s nem tartalmaz gyönyörű részkarakterláncot, adjon vissza egy üres karakterláncot.
Egy a karakterlánc lexikográfiailag nagyobb, mint egy b karakterlánc (azonos hosszúságú), ha az első helyen, ahol a és b különbözik, a karaktere szigorúan nagyobb, mint a b-beli megfelelő karakter.

Például az "abcd" lexikográfiailag nagyobb, mint az "abcc", mert az első pozíció, amelytől eltérnek, a negyedik karakternél van, és d nagyobb, mint c.

1. példa:

Bemenet: s = "100011001", k = 3
Kimenet: "11001"
Magyarázat: Ebben a példában 7 gyönyörű részkarakterlánc található:
1. Az "100011001" részkarakterlánc.
2. Az "100011001" részkarakterlánc.
3. Az "100011001" részkarakterlánc.
4. Az "100011001" részkarakterlánc.
5. Az "100011001" részkarakterlánc.
6. Az "100011001" részkarakterlánc.
7. Az "100011001" részkarakterlánc.
A legrövidebb gyönyörű részkarakterlánc hossza 5.
A lexikográfiailag legkisebb gyönyörű, 5 hosszúságú részkarakterlánc az „11001” részkarakterlánc.

2. példa:

Bemenet: s = "1011", k = 2
Kimenet: "11"
Magyarázat: Ebben a példában 3 gyönyörű részkarakterlánc található:
1. Az "1011" részkarakterlánc.
2. Az "1011" részkarakterlánc.
3. Az "1011" részkarakterlánc.
A legrövidebb gyönyörű részkarakterlánc hossza 2.
A lexikográfiailag legkisebb gyönyörű 2-es karakterlánc a „11” részkarakterlánc.

3. példa:

Bemenet: s = "000", k = 1
Kimenet: ""
Magyarázat: Ebben a példában nincsenek gyönyörű részkarakterláncok.

Korlátozások:

1 <= s.length <= 100
1 <= k <= s.length


N darab processzora van, mindegyik 4 maggal és n * 4 feladattal, amelyeket úgy kell végrehajtani, hogy minden mag csak egy feladatot hajtson végre.
Adott egy 0 indexű egész tömb processorTime, amely azt az időpontot jelenti, amikor az egyes processzorok először elérhetővé válnak, és egy 0 indexelt egész tömb feladatok, amelyek az egyes feladatok végrehajtásához szükséges időt jelentik, akkor adja vissza a minimális időt, amikor az összes feladat megtörtént. a processzorok hajtják végre.
Megjegyzés: Mindegyik mag a többitől függetlenül hajtja végre a feladatot.

1. példa:

Bemenet: processorTime = [8,10], tasks  = [2,2,3,1,8,7,4,5]
Kimenet: 16
Magyarázat:
Optimális, ha a 4-es, 5-ös, 6-os, 7-es indexű feladatokat az első processzornak rendeli, amely a = 8 időpontban válik elérhetővé, a 0, 1, 2, 3 indexű feladatokat pedig a = 10 időpontban elérhetővé váló második processzorhoz. .
Az első processzor által az összes feladat végrehajtásához szükséges idő = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Az idő, ameddig a második processzor az összes feladat végrehajtását befejezi = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Így kimutatható, hogy az összes feladat végrehajtásához szükséges minimális idő 16.
2. példa:

Bemenet: processorTime = [10,20],  tasks = [2,3,1,2,5,8,4,3]
Kimenet: 23
Magyarázat:
Optimális, ha az 1, 4, 5, 6 indexű feladatokat az első processzornak rendeli, amely a = 10 időpontban válik elérhetővé, és a 0, 2, 3, 7 indexű feladatokat a második processzorhoz, amely = 20 időpontban válik elérhetővé. .
Az első processzornak az összes feladat végrehajtásához szükséges idő = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Az idő, ameddig a második processzor az összes feladat végrehajtását befejezi = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Így kimutatható, hogy az összes feladat végrehajtásához szükséges minimális idő 23.

Korlátozások:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

N darab processzora van, mindegyik 4 maggal és n * 4 feladattal, amelyeket úgy kell végrehajtani, hogy minden mag csak egy feladatot hajtson végre.
Adott egy 0 indexű egész tömb processorTime, amely azt az időt jelenti, amikor az egyes processzorok először elérhetővé válnak, és egy 0 indexelt egész szám tömb feladatok, amelyek az egyes tasks végrehajtásához szükséges időt jelentik, akkor adja vissza a minimális időt, amikor az összes feladatot elvégezték. a processzorok hajtják végre.
Megjegyzés: Mindegyik mag a többitől függetlenül hajtja végre a feladatot.

1. példa:

Bemenet: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Kimenet: 16
Magyarázat:
Optimális, ha a 4-es, 5-ös, 6-os, 7-es indexű feladatokat az első processzorhoz rendeli, amely az időpontban, amikor az első processzor elérhetővé válik (8) időpontban válik elérhetővé, a 0, 1, 2, 3 indexű feladatokat pedig az időpontban, amikor a második processzor elérhetővé válik (10) időpontban elérhetővé váló második processzorhoz. .
Az első processzor által az összes feladat végrehajtásához szükséges idő = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Az idő, ameddig a második processzor az összes feladat végrehajtását befejezi = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Így kimutatható, hogy az összes feladat végrehajtásához szükséges minimális idő 16.
2. példa:

Bemenet: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Kimenet: 23
Magyarázat:
Optimális, ha az 1, 4, 5, 6 indexű feladatokat az első processzorhoz rendeli, amely a = 10 időpontban válik elérhetővé, és a 0, 2, 3, 7 indexű feladatokat a második processzorhoz, amely = 20 időpontban válik elérhetővé. .
Az első processzornak az összes feladat végrehajtásához szükséges idő = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Az idő, ameddig a második processzor az összes feladat végrehajtását befejezi = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Így kimutatható, hogy az összes feladat végrehajtásához szükséges minimális idő 23.

Korlátozások:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

N processzora van, mindegyiknek 4 magja és n * 4 feladata van, amelyeket úgy kell végrehajtani, hogy minden magnak csak egy feladatot kell végrehajtania.
Adott egy 0 indexelt egész tömb processorTime, amely azt az időpontot jelöli, amikor az egyes processzorok először válnak elérhetővé, és egy 0 indexelt egész tömbfeladat, amely az egyes feladatok végrehajtásához szükséges időt jelöli, adja vissza azt a minimális időt, amikor a processzorok az összes feladatot végrehajtották.
Megjegyzés: Minden mag a többitől függetlenül hajtja végre a feladatot.

1. példa:

Bemenet:  processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Kimenet: 16
Magyarázat:
Optimális a 4-es, 5-ös, 6-os és 7-es indexben lévő feladatokat hozzárendelni az első processzorhoz, amely ekkor = 8 válik elérhetővé, a 0, 1, 2, 3 indexű feladatokat pedig a második processzorhoz, amely time = 10 válik elérhetővé.
Az első processzor által az összes feladat végrehajtásának befejezéséhez szükséges idő = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
A második processzor által az összes feladat végrehajtásának befejezéséhez szükséges idő = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Ezért kimutatható, hogy az összes feladat végrehajtásához szükséges minimális idő 16.
2. példa:

Bemenet: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Kimenet: 23
Magyarázat:
Optimális az 1-es, 4-es, 5-ös, 6-os indexben lévő feladatokat hozzárendelni az első processzorhoz, amely ekkor = 10 válik elérhetővé, a 0, 2, 3, 7 indexű feladatokat pedig a második processzorhoz, amely egyszerre = 20 alkalommal válik elérhetővé.
Az első processzor által az összes feladat végrehajtásának befejezéséhez szükséges idő = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
A második processzor által az összes feladat végrehajtásának befejezéséhez szükséges idő = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Ezért kimutatható, hogy az összes feladat végrehajtásához szükséges minimális idő 23.

Korlátok:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n


Van egy 0-indexelt egész számokat tartalmazó tömböd, nums, és egy pozitív egész szám k. A következő műveletet végezheted el a tömbön tetszőleges alkalommal:

Válassz ki két különböző i és j indexet, és egyidejűleg frissítsd a nums[i] értékét (nums[i] AND nums[j]) értékre, és a nums[j] értékét (nums[i] OR nums[j]) értékre. Itt az OR a bitenkénti OR műveletet, az AND pedig a bitenkénti AND műveletet jelöli.

Ki kell választanod k elemet a végső tömbből, és kiszámítani a négyzetük összegét. Térj vissza a legnagyobb négyzetösszeggel, amit elérhetsz. Mivel a válasz nagyon nagy lehet, add meg 10^9 + 7 modulusával.

Példa 1:

Bemenet: nums = [2,6,5,8], k = 2
Kimenet: 261
Magyarázat: A következő műveleteket végezhetjük el a tömbön:
- Válasszuk i = 0 és j = 3 értéket, majd változtassuk meg nums[0] értékét (2 AND 8) = 0-ra, és nums[3] értékét (2 OR 8) = 10-re. Az eredményül kapott tömb nums = [0,6,5,10].
- Válasszuk i = 2 és j = 3 értéket, majd változtassuk meg nums[2] értékét (5 AND 10) = 0-ra, és nums[3] értékét (5 OR 10) = 15-re. Az eredményül kapott tömb nums = [0,6,0,15].
A végső tömbből választhatjuk a 15 és 6 elemeket. A négyzetösszeg 15^2 + 6^2 = 261.
Bemutatható, hogy ez a maximális érték, amit elérhetünk.

Példa 2:

Bemenet: nums = [4,5,4,7], k = 3
Kimenet: 90
Magyarázat: Nem szükséges műveleteket alkalmazni.
Választhatjuk a 7, 5 és 4 elemeket a négyzetösszeggel: 7^2 + 5^2 + 4^2 = 90.
Bemutatható, hogy ez a maximális érték, amit elérhetünk.

Feltételek:

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

Kapsz egy 0-indexelt egész tömb számot és egy pozitív k egész számot.
A következő műveletet tetszőleges számú alkalommal elvégezheti a tömbön:

Válasszon ki két különálló i és j indexet, és egyidejűleg frissítse a nums[i] értékét (nums[i] ÉS nums[j]) értékre, illetve a nums[j] értékeit (nums[i] VAGY nums[j] értékre). Itt az VAGY a bitenkénti VAGY műveletet, az ÉS pedig a bitenkénti ÉS műveletet jelöli.

A végső tömbből ki kell választani k elemet, és ki kell számítani a négyzeteinek összegét.
Adja vissza a maximálisan elérhető négyzetösszeget.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet:nums = [2,6,5,8], k = 2
Kimenet: 261
Magyarázat: A következő műveleteket végezhetjük el a tömbön:
- Válassza ki az i = 0 és a j = 3 értéket, majd módosítsa a nums[0] értéket (2 ÉS 8) = 0-ra és a nums[3] értéket (2 VAGY 8) = 10-re. Az eredményül kapott tömb a következő: nums = [0,6,5 ,10].
- Válassza az i = 2 és a j = 3 értéket, majd módosítsa a számok[2] értékét (5 ÉS 10) = 0-ra, és a szám[3] értéket (5 VAGY 10) = 15-re. A kapott tömb a következő: nums = [0,6,0 ,15].
A végső tömbből kiválaszthatjuk a 15. és 6. elemet. A négyzetek összege 15^2 + 6^2 = 261.
Kimutatható, hogy ez a maximális érték, amit kaphatunk.

2. példa:

Bemenet: nums = [4,5,4,7], k = 3
Kimenet: 90
Magyarázat: Nem kell semmilyen műveletet alkalmaznunk.
A 7, 5 és 4 elemeket négyzetösszeggel választhatjuk ki: 7^2 + 5^2 + 4^2 = 90.
Kimutatható, hogy ez a maximális érték, amit kaphatunk.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot és egy pozitív k egész számot.
A következő műveletet tetszőleges számú alkalommal elvégezheti a tömbön:

Válasszon ki két különálló i és j indexet, és egyidejűleg frissítse a nums[i] értékét (nums[i] ÉS nums[j]) értékre, illetve a nums[j] értékeit (nums[i] VAGY nums[j] értékre). Itt az VAGY a bitenkénti VAGY műveletet, az ÉS pedig a bitenkénti ÉS műveletet jelöli.

A végső tömbből ki kell választani k elemet, és ki kell számítani a négyzeteinek összegét.
Adja vissza a maximálisan elérhető négyzetösszeget.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [2,6,5,8], k = 2
Kimenet: 261
Magyarázat: A következő műveleteket végezhetjük el a tömbön:
- Válassza ki az i = 0 és a j = 3 értéket, majd módosítsa a nums[0] értéket (2 ÉS 8) = 0-ra és a nums[3] értéket (2 VAGY 8) = 10-re. Az eredményül kapott tömb a következő: nums = [0,6,5 ,10].
- Válassza az i = 2 és a j = 3 értéket, majd módosítsa a számok[2] értékét (5 ÉS 10) = 0-ra, és a szám[3] értéket (5 VAGY 10) = 15-re. A kapott tömb a következő: nums = [0,6,0 ,15].
A végső tömbből kiválaszthatjuk a 15. és 6. elemet. A négyzetek összege 15^2 + 6^2 = 261.
Kimutatható, hogy ez a maximális érték, amit kaphatunk.

2. példa:

Bemenet: nums = [4,5,4,7], k = 3
Kimenet: 90
Magyarázat: Nem kell semmilyen műveletet alkalmaznunk.
A 7, 5 és 4 elemeket négyzetösszeggel választhatjuk ki: 7^2 + 5^2 + 4^2 = 90.
Kimutatható, hogy ez a maximális érték, amit kaphatunk.

Korlátozások:

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


Kap egy 0-indexelt egész számokból álló tömb.
Adj vissza az összes (i, j, k) indexhármas értékeinek a maximumát, ahol i < j < k. Ha az összes ilyen hármas értéke negatív, adjon vissza 0-t.
Az (i, j, k) indexhármas értéke (nums[i] - nums[j]) * nums[k].

1. példa:

Bemenet: nums = [12,6,1,2,7]
Kimenet: 77
Magyarázat: A hármas értéke (0, 2, 4) (nums[0] - nums[2]) * nums[4] = 77.
Megmutatható, hogy nincsenek rendezett indexhármasok, amelyek értéke nagyobb, mint 77.

2. példa:

Bemenet: nums = [1,10,3,4,19]
Kimenet: 133
Magyarázat: A hármas (1, 2, 4) értéke (nums[1] - nums[2]) * nums[4] = 133.
Megmutatható, hogy nincsenek rendezett indexhármasok, amelyek értéke nagyobb, mint 133.

3. példa:

Bemenet: nums = [1,2,3]
Kimenet: 0
Magyarázat: Az indexek egyetlen rendezett hármasának (0, 1, 2) negatív értéke (nums[0] - nums[1]) * nums[2] = -3. Ezért a válasz 0 lenne.

Korlátok:

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

Kapsz egy 0-indexelt egész tömb számot.
Adja vissza a maximális értéket az összes indexhármasra (i, j, k) úgy, hogy i < j < k. Ha minden ilyen hármas negatív értékű, akkor adjon vissza 0-t.
Az indexek hármasának (i, j, k) értéke egyenlő (nums[i] - nums[j]) * nums[k].

1. példa:

Bemenet: nums = [12,6,1,2,7]
Kimenet: 77
Magyarázat: A triplett (0, 2, 4) értéke (nums[0] - nums[2]) * nums[4] = 77.
Kimutatható, hogy nincsenek 77-nél nagyobb értékű indexek rendezett hármasai.

2. példa:

Bemenet: nums = [1,10,3,4,19]
Kimenet: 133
Magyarázat: A triplett (1, 2, 4) értéke (nums[1] - nums[2]) * nums[4] = 133.
Kimutatható, hogy nincsenek 133-nál nagyobb értékű indexek rendezett hármasai.

3. példa:

Bemenet: nums = [1,2,3]
Kimenet: 0
Magyarázat: Az egyetlen rendezett indexhármas (0, 1, 2) negatív értéke (nums[0] - nums[1]) * nums[2] = -3. Ezért a válasz 0 lenne.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot.
Adja vissza a maximális értéket az összes indexhármasra (i, j, k) úgy, hogy i < j < k. Ha minden ilyen hármas negatív értékű, akkor adjon vissza 0-t.
Az indexek (i, j, k) hármasának értéke egyenlő (nums[i] - nums[j]) * nums[k].

1. példa:

Bemenet: nums  = [12,6,1,2,7]
Kimenet: 77
Magyarázat: A triplett (0, 2, 4) értéke (nums[0] - nums[2]) * nums[4] = 77.
Kimutatható, hogy nincsenek 77-nél nagyobb értékű indexek rendezett hármasai.

2. példa:

Bemenet: nums  = [1,10,3,4,19]
Kimenet: 133
Magyarázat: A triplett (1, 2, 4) értéke (nums[1] - nums[2]) *nums[4] = 133.
Kimutatható, hogy nincsenek 133-nál nagyobb értékű indexek rendezett hármasai.

3. példa:

Bemenet: nums  = [1,2,3]
Kimenet: 0
Magyarázat: Az egyetlen rendezett indexhármas (0, 1, 2) negatív értéke (nums[0] - nums[1]) * nums[2] = -3. Ezért a válasz 0 lenne.

Korlátozások:

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


A 0-indexált, egész számokat tartalmazó nums tömböt kapod.
Egy nums részhalmaz különböző elemeinek száma a következőképpen definiálható:

Legyen nums[i..j] a nums egy részhalmaza, amely az összes i-től j-ig terjedő indexet tartalmazza, ahol 0 <= i <= j < nums.length. Ekkor a különböző értékek száma nums[i..j]-ben a nums[i..j] különböző elemeinek számának nevezik.

Add vissza az összes nums részhalmaz különböző elemeinek számának négyzeteinek összegét.
Egy részhalmaz egy tömbön belüli összefüggő, nem üres elemek sorozata.

Példa 1:

Bemenet: nums = [1,2,1]
Kimenet: 15
Magyarázat: Hat lehetséges részhalmaz van:
[1]: 1 különböző érték
[2]: 1 különböző érték
[1]: 1 különböző érték
[1,2]: 2 különböző érték
[2,1]: 2 különböző érték
[1,2,1]: 2 különböző érték
Az összes részhalmaz különböző számainak négyzeteinek összege egyenlő 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Példa 2:

Bemenet: nums = [1,1]
Kimenet: 3
Magyarázat: Három lehetséges részhalmaz van:
[1]: 1 különböző érték
[1]: 1 különböző érték
[1,1]: 1 különböző érték
Az összes részhalmaz különböző számainak négyzeteinek összege egyenlő 1^2 + 1^2 + 1^2 = 3.

Korlátozások:

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

Kap egy 0 indexelt egész tömb számát.
A számok egy résztömbjének különálló száma a következőképpen definiálható:

Legyen nums[i.. j] legyen a numok résztömbje, amely az i-től j-ig terjedő összes indexet tartalmazza úgy, hogy 0 <= i <= j < nums.length. Ezután a különböző értékek száma számban[i.. j] a számok különálló számának nevezik[i.. j].

A számok összes résztömbje különböző darabszámai négyzetének összegét adja eredményül.
A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [1,2,1]
Kimenet: 15
Magyarázat: Hat lehetséges altömb a következő:
[1]: 1 különböző érték
[2]: 1 különböző érték
[1]: 1 különböző érték
[1,2]: 2 különböző érték
[2,1]: 2 különböző érték
[1,2,1]: 2 különböző érték
Az összes résztömbben lévő különálló számok négyzeteinek összege egyenlő 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 + 2^2 = 15.

2. példa:

Bemenet: nums = [1,1]
Kimenet: 3
Magyarázat: Három lehetséges résztömb lehet:
[1]: 1 különböző érték
[1]: 1 különböző érték
[1,1]: 1 különböző érték
Az összes résztömbben lévő különböző számok négyzeteinek összege egyenlő 1^2 + 1^2 + 1^2 = 3.

Korlátok:

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

Kapsz egy 0-indexelt egész tömb számot.
A számok altömbjének különálló száma a következőképpen definiálható:

Legyen a számok[i..j] olyan számok altömbje, amely i-től j-ig terjedő összes indexből áll, úgy, hogy 0 <= i <= j < számok.hosszúság. Ekkor a számok [i..j]-ben lévő különböző értékek számát a számok [i..j] különálló számának nevezzük.

Visszaadja a számok összes altömbjeihez tartozó különböző számok négyzeteinek összegét.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [1,2,1]
Kimenet: 15
Magyarázat: Hat lehetséges altömb a következő:
[1]: 1 különálló érték
[2]: 1 különálló érték
[1]: 1 különálló érték
[1,2]: 2 különböző érték
[2,1]: 2 különböző érték
[1,2,1]: 2 különböző érték
A különböző számok négyzeteinek összege az összes altömbben egyenlő: 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

2. példa:

Bemenet: nums = [1,1]
Kimenet: 3
Magyarázat: Három lehetséges altömb:
[1]: 1 különálló érték
[1]: 1 különálló érték
[1,1]: 1 különálló érték
A különböző számok négyzeteinek összege az összes altömbben egyenlő 1^2 + 1^2 + 1^2 = 3.

Korlátozások:

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


Adott egy 0-indexelt karakterláncokból és szavakból álló tömb, ahol words[i] vagy egy pozitív egész szám, amely karakterláncként van ábrázolva, vagy a "prev" karakterlánc.
A tömb elejétől kezdve iterálj; minden "prev" karakterlánc esetén a szavakban találd meg az utoljára meglátogatott egész számot, amelyet az alábbiak szerint határozunk meg:

Legyen k a mostanáig látott egymást követő "prev" karakterláncok száma (beleértve a jelenlegi karakterláncot is). Legyen nums a mostanáig látott egész számok 0-indexelt tömbje, és legyen nums_reverse ennek reverze, akkor az integer (k - 1)^th indexén lévő nums_reverse lesz az utoljára meglátogatott egész szám ennek a "prev"-nek.
Ha k nagyobb, mint az összes meglátogatott egész szám, akkor az utoljára meglátogatott egész szám -1 lesz.

Térj vissza egy egész számokból álló tömbbel, amely tartalmazza az utoljára meglátogatott egész számokat.

Példa 1:

Bemenet: words = ["1","2","prev","prev","prev"]
Kimenet: [2,1,-1]
Magyarázat:
A "prev" esetén index = 2, az utoljára meglátogatott egész szám 2 lesz, mivel itt az egymást követő "prev" karakterláncok száma 1, és a reverse_nums tömbben 2 lesz az első elem.
A "prev" esetén index = 3, az utoljára meglátogatott egész szám 1 lesz, mivel összesen két egymást követő "prev" karakterlánc van, beleértve ezt a "prev"-t is, amelyet meglátogattak, és 1 a második utoljára meglátogatott egész szám.
A "prev" esetén index = 4, az utoljára meglátogatott egész szám -1 lesz, mivel összesen három egymást követő "prev" karakterlánc van, beleértve ezt a "prev"-t is, amelyet meglátogattak, de az összes meglátogatott egész szám száma kettő.

Példa 2:

Bemenet: words = ["1","prev","2","prev","prev"]
Kimenet: [1,2,1]
Magyarázat:
A "prev" esetén index = 1, az utoljára meglátogatott egész szám 1.
A "prev" esetén index = 3, az utoljára meglátogatott egész szám 2.
A "prev" esetén index = 4, az utoljára meglátogatott egész szám 1 lesz, mivel összesen két egymást követő "prev" karakterlánc van, beleértve ezt a "prev"-t is, amelyet meglátogattak, és 1 a második utoljára meglátogatott egész szám.

Korlátozások:

1 <= words.length <= 100
words[i] == "prev" vagy 1 <= int(words[i]) <= 100

Adott egy 0 indexelt karakterlánc-tömb, ahol a words[i] vagy egy pozitív egész szám, amelyet karakterláncként ábrázolnak, vagy a "prev" karakterlánc.
Indítsa el az iterációt a tömb elejétől; Minden szavakban látott "prev" karakterlánchoz keresse meg az utoljára látogatott egész számot szavakban, amely a következőképpen van definiálva:

Legyen k az eddig látott egymást követő "prev" karakterláncok száma (amely tartalmazza az aktuális karakterláncot). Legyen a num az eddig látott egész számok 0-indexelt tömbje, és nums_reverse a számok fordítottja, akkor a nums_reverse(k - 1)^th index egész száma lesz az "prev" utoljára látogatott egész száma.
Ha k nagyobb, mint az összes meglátogatott egész szám, akkor az utoljára látogatott egész szám -1 lesz.

Az utoljára meglátogatott egész számokat tartalmazó egész tömböt ad vissza.

1. példa:

Bemenet: words = ["1","2","prev","prev","prev"]
Kimenet: [2,1,-1]
Magyarázat:
Az index = 2 esetén az "prev" esetében az utoljára látogatott egész szám 2 lesz, mivel itt az egymást követő "prev" karakterláncok száma 1, és a tömbben reverse_nums 2 lesz az első elem.
Az index = 3 esetén az "prev" érték esetén az utoljára látogatott egész szám 1 lesz, mivel összesen két egymást követő "prev" karakterlánc van, beleértve ezt az "prev" is, amelyeket meglátogattak, és 1 az utolsó utolsó látogatás második egész száma.
Az index = 4 esetén az "prev" esetében az utoljára látogatott egész szám -1 lesz, mivel összesen három egymást követő "prev" karakterlánc van, beleértve ezt az "prev" is, amelyeket meglátogattak, de a meglátogatott egész számok teljes száma kettő.

2. példa:

Bemenet: words = ["1","prev","2","prev","prev"]
Kimenet: [1,2,1]
Magyarázat:
Az index = 1 esetén az "prev" esetében az utoljára látogatott egész szám 1 lesz.
Az index = 3 esetén az "prev" esetében az utoljára látogatott egész szám 2 lesz.
Az index = 4 esetén az "prev" érték esetén az utoljára látogatott egész szám 1 lesz, mivel összesen két egymást követő "prev" karakterlánc van, beleértve ezt az "prev" is, amelyeket meglátogattak, és 1 az utolsó utolsó alkalommal látogatott egész szám.

Korlátok:

1 <= words.length <= 100
words[i] == "prev" or 1 <= int(words[i]) <= 100

Adott egy 0 indexelt karakterlánc-tömb, ahol a words[i] vagy egy pozitív egész szám, amelyet karakterláncként ábrázolnak, vagy a "előző" karakterlánc.
Indítsa el az iterációt a tömb elejétől; Minden szavakban látott "előző" karakterlánchoz keresse meg az utoljára látogatott egész számot szavakban, amely a következőképpen van definiálva:

Legyen k az eddig látott egymást követő "előző" karakterláncok száma (amely tartalmazza az aktuális karakterláncot). Legyen a num az eddig látott egész számok 0-indexelt tömbje, és nums_reverse a számok fordítottja, akkor a nums_reverse(k - 1)^th index egész száma lesz az "előző" utoljára látogatott egész száma.
Ha k nagyobb, mint az összes meglátogatott egész szám, akkor az utoljára látogatott egész szám -1 lesz.

Az utoljára meglátogatott egész számokat tartalmazó egész tömböt ad vissza.

1. példa:

Bemenet: words = ["1","2","előző","előző","előző","előző"]
Kimenet: [2,1,-1]
Magyarázat:
Az index = 2 esetén az "előző" esetében az utoljára látogatott egész szám 2 lesz, mivel itt az egymást követő "előző" karakterláncok száma 1, és a tömbben reverse_nums 2 lesz az első elem.
Az index = 3 esetén az "előző" érték esetén az utoljára látogatott egész szám 1 lesz, mivel összesen két egymást követő "előző" karakterlánc van, beleértve ezt az "előzőt" is, amelyeket meglátogattak, és 1 az utolsó látogatott egész számok közül a második.
Az index = 4 esetén az "előző" esetében az utoljára látogatott egész szám -1 lesz, mivel összesen három egymást követő "előző" karakterlánc van, beleértve ezt az "előzőt" is, amelyeket meglátogattak, de a meglátogatott egész számok teljes száma kettő.

2. példa:

Bemenet: words = ["1","előző","2","előző","előző"]
Kimenet: [1,2,1]
Magyarázat:
Az index = 1 esetén az "előző" esetében az utoljára látogatott egész szám 1 lesz.
Az index = 3 esetén az "előző" esetében az utoljára látogatott egész szám 2 lesz.
Az index = 4 esetén az "előző" érték esetén az utoljára látogatott egész szám 1 lesz, mivel összesen két egymást követő "előző" karakterlánc van, beleértve ezt az "előzőt" is, amelyeket meglátogattak, és 1 az utolsó utolsó alkalommal látogatott egész szám.

Korlátok:

1 <= words.length <= 100
words[i] == "előző" or 1 <= int(words[i]) <= 100


Egy 0-indexelt egész tömböt kapunk, amelyek n hosszúságúak.
Az indexeket úgy szeretnénk csoportosítani, hogy minden i indexhez a [0, n - 1] tartományban pontosan egy csoporthoz legyen hozzárendelve.
A csoportos hozzárendelés akkor érvényes, ha a következő feltételek teljesülnek:

Minden g csoportban a g csoporthoz rendelt összes i indexnek azonos értéke van számokban.
Bármely két g_1 és g_2 csoport esetén a g_1 és g_2 értékhez rendelt indexek száma közötti különbség nem haladhatja meg az 1-et.

Egész számot ad vissza, amely az érvényes csoporthozzárendelés létrehozásához szükséges csoportok minimális számát jelöli.

1. példa:

Bemenet: nums = [3,2,3,2,3]
Kimenet: 2
Magyarázat: Az indexek 2 csoporthoz való hozzárendelésének egyik módja a következő, ahol a szögletes zárójelben lévő értékek indexek:
1. csoport -> [0,2,4]
2. csoport -> [1,3]
Minden index egy csoporthoz van hozzárendelve.
Az 1. csoportban nums[0] == nums[2] == nums[4],  tehát minden index azonos értékű.
A 2. csoportban nums[1] == nums[3], tehát minden index azonos értékű.
Az 1. csoporthoz rendelt indexek száma 3, a 2. csoporthoz rendelt indexek száma 2.
Különbségük nem haladja meg az 1-et.
Nem lehet 2-nél kevesebb csoportot használni, mert ahhoz, hogy csak 1 csoportot használjunk, az ehhez a csoporthoz rendelt összes indexnek azonos értékűnek kell lennie.
Ezért a válasz a 2.
2. példa:

Bemenet: nums= [10,10,10,3,1,1]
Kimenet: 4
Magyarázat: Az indexek 4 csoporthoz való hozzárendelésének egyik módja a következő, ahol a szögletes zárójelben lévő értékek indexek:
1. csoport -> [0]
2. csoport -> [1,2]
3. csoport -> [3]
4. csoport -> [4,5]
A fenti csoportos hozzárendelés mindkét feltételnek eleget tesz.
Kimutatható, hogy 4-nél kevesebb csoport felhasználásával nem lehet érvényes hozzárendelést létrehozni.
Ezért a válasz a 4.

Korlátozások:

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

Kapsz egy 0 indexelt egész tömb n hosszúságú számát.
Az indexeket úgy szeretnénk csoportosítani, hogy a [0, n - 1] tartomány minden i indexéhez pontosan egy csoporthoz legyen rendelve.
A csoport-hozzárendelés akkor érvényes, ha az alábbi feltételek teljesülnek:

Minden g csoport esetében a g csoporthoz rendelt összes i index értéke megegyezik numban.
Bármely két csoport g_1 és g_2 esetében a g_1 és g_2 indexek száma közötti különbség nem haladhatja meg az 1-et.

Egy egész számot ad vissza, amely az érvényes csoport-hozzárendelés létrehozásához szükséges csoportok minimális számát jelöli.

1. példa:

Bemenet: nums = [3,2,3,2,3]
Kimenet: 2
Magyarázat: Az indexek 2 csoporthoz való hozzárendelésének egyik módja a következő, ahol a szögletes zárójelben lévő értékek indexek:
1. csoport -> [0,2,4]
2. csoport -> [1,3]
Minden index egy csoporthoz van rendelve.
Az 1. csoportban nums[0] == nums[2] == nums[4], tehát minden indexnek ugyanaz az értéke.
A 2. csoportban nums[1] == nums[3], tehát minden indexnek ugyanaz az értéke.
Az 1. csoporthoz rendelt indexek száma 3, a 2. csoporthoz rendelt indexek száma pedig 2.
Különbségük nem haladja meg az 1-et.
Nem lehet 2-nél kevesebb csoportot használni, mert ahhoz, hogy csak 1 csoportot használjunk, a csoporthoz rendelt összes indexnek azonos értékkel kell rendelkeznie.
Ezért a válasz 2.
2. példa:

Bemenet: nums = [10,10,10,3,1,1]
Kimenet: 4
Magyarázat: Az indexek 4 csoporthoz való hozzárendelésének egyik módja a következő, ahol a szögletes zárójelben lévő értékek indexek:
1. csoport -> [0]
2. csoport -> [1,2]
3. csoport -> [3]
4. csoport -> [4,5]
A fenti csoport-hozzárendelés mindkét feltételnek megfelel.
Kimutatható, hogy 4-nél kevesebb csoport használatával nem lehet érvényes hozzárendelést létrehozni.
Ezért a válasz 4.

Korlátok:

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


Két tömböt kap, nums1 és nums2, amelyek pozitív egész számokból állnak.
Mindkét tömb összes 0-ját szigorúan pozitív egész számokra kell cserélni úgy, hogy mindkét tömb elemeinek összege egyenlő legyen.
Adja vissza a minimálisan egyenlő összeget, vagy -1-et, ha lehetetlen.

1. példa:

Bemenet: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Kimenet: 12
Magyarázat: A 0-kat a következő módon cserélhetjük ki:
- Cserélje ki a két 0-t a nums1-ben a 2 és 4 értékekre. Az eredményül kapott tömb nums1 = [3,2,2,1,4].
- Cserélje ki a nums2 0-ját az 1 értékre. Az eredményül kapott tömb nums2 = [6,5,1].
Mindkét tömb egyenlő összege 12. Kimutatható, hogy ez a minimális összeg, amit elérhetünk.

2. példa:

Bemenet: nums1 = [2,0,2,0], nums2 = [1,4]
Kimenet: -1
Magyarázat: Lehetetlen a két tömb összegét egyenlővé tenni.

Korlátok:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

Két pozitív egész számokból álló szám1 és szám2 tömböt kapunk.
Mindkét tömbben az összes 0-t szigorúan pozitív egész számokra kell cserélnie, hogy mindkét tömb elemeinek összege egyenlő legyen.
Adja vissza a minimálisan elérhető összeget, vagy -1-et, ha ez lehetetlen.

1. példa:

Bemenet: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Kimenet: 12
Magyarázat: A 0-kat a következő módon helyettesíthetjük:
- Cserélje le a nums1 két 0-ját 2 és 4 értékre. Az eredményül kapott tömb a nums1 = [3,2,2,1,4].
- Cserélje le a 0-t a nums2-ben 1-gyel. Az eredményül kapott tömb a nums2 = [6,5,1].
Mindkét tömbnek egyenlő összege 12. Megmutatható, hogy ez a minimális összeg, amit kaphatunk.

2. példa:

Bemenet: nums1 = [2,0,2,0], nums2 = [1,4]
Kimenet: -1
Magyarázat: Lehetetlen mindkét tömb összegét egyenlővé tenni.

Korlátozások:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

Két pozitív egész számokból álló nums1 és nums2 tömböt kapunk.
Mindkét tömbben az összes 0-t szigorúan pozitív egész számokra kell cserélnie, hogy mindkét tömb elemeinek összege egyenlő legyen.
Adja vissza a minimálisan elérhető összeget, vagy -1-et, ha ez lehetetlen.

1. példa:

Bemenet: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Kimenet: 12
Magyarázat: A 0-kat a következő módon helyettesíthetjük:
- Cserélje le a nums1 két 0-ját 2 és 4 értékre. Az eredményül kapott tömb a nums1 = [3,2,2,1,4].
- Cserélje le a 0-t a nums2-ben 1-gyel. Az eredményül kapott tömb a nums2 = [6,5,1].
Mindkét tömbnek egyenlő összege 12. Megmutatható, hogy ez a minimális összeg, amit kaphatunk.

2. példa:

Bemenet: nums1 = [2,0,2,0], nums2 = [1,4]
Kimenet: -1
Magyarázat: Lehetetlen mindkét tömb összegét egyenlővé tenni.

Korlátozások:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6


Kapsz n és m pozitív egész számokat.
Határozzon meg két egész számot, a num1-et és a num2-t az alábbiak szerint:

szám1: Az [1, n] tartományban lévő összes olyan egész szám összege, amelyek nem oszthatók m-mel.
szám2: Az [1, n] tartományban lévő összes olyan egész szám összege, amely osztható m-mel.

Visszaadja a num1 - num2 egész számot.

1. példa:

Bemenet: n = 10, m = 3
Kimenet: 19
Magyarázat: Az adott példában:
- Az [1, 10] tartományban lévő, 3-mal nem osztható egész számok: [1,2,4,5,7,8,10], a num1 ezeknek az egészeknek az összege = 37.
- Az [1, 10] tartományban 3-mal osztható egész számok [3,6,9], a num2 ezeknek az egészeknek az összege = 18.
Válaszként 37-18 = 19-et adunk vissza.

2. példa:

Bemenet: n = 5, m = 6
Kimenet: 15
Magyarázat: Az adott példában:
- Az [1, 5] tartományban lévő, 6-tal nem osztható egész számok [1,2,3,4,5], a num1 ezeknek az egészeknek az összege = 15.
- Az [1, 5] tartományban lévő, 6-tal osztható egész számok [], a szám2 ezeknek az egészeknek az összege = 0.
Válaszként 15-0 = 15-öt adunk vissza.

3. példa:

Bemenet: n = 5, m = 1
Kimenet: -15
Magyarázat: Az adott példában:
- Az [1, 5] tartományban lévő, 1-gyel nem osztható egész számok [], a szám1 ezeknek az egészeknek az összege = 0.
- Az [1, 5] tartományban 1-gyel osztható egész számok: [1,2,3,4,5], a num2 ezeknek az egészeknek az összege = 15.
Válaszként 0 - 15 = -15 értéket adunk vissza.

Korlátozások:

1 <= n, m <= 1000

Kapsz n és m pozitív egész számokat.
Határozzon meg két egész számot, a num1-et és a num2-t az alábbiak szerint:

num1: Az [1, n] tartományban lévő összes olyan egész szám összege, amelyek nem oszthatók m-mel.
num2: Az [1, n] tartományban lévő összes olyan egész szám összege, amely osztható m-mel.

Visszaadja a num1 - num2 egész számot.

1. példa:

Bemenet: n = 10, m = 3
Kimenet: 19
Magyarázat: Az adott példában:
- Az [1, 10] tartományban lévő, 3-mal nem osztható egész számok: [1,2,4,5,7,8,10], a num1 ezeknek az egészeknek az összege = 37.
- Az [1, 10] tartományban lévő, 3-mal osztható egész számok [3,6,9], a num2 ezeknek az egészeknek az összege = 18.
Válaszként 37-18 = 19-et adunk vissza.

2. példa:

Bemenet: n = 5, m = 6
Kimenet: 15
Magyarázat: Az adott példában:
- Az [1, 5] tartományban lévő, 6-tal nem osztható egész számok [1,2,3,4,5], a num1 ezeknek az egészeknek az összege = 15.
- Az [1, 5] tartományban lévő, 6-tal osztható egész számok [], a szám2 ezeknek az egészeknek az összege = 0.
Válaszként 15-0 = 15-öt adunk vissza.

3. példa:

Bemenet: n = 5, m = 1
Kimenet: -15
Magyarázat: Az adott példában:
- Az [1, 5] tartományban lévő, 1-gyel nem osztható egész számok [], a szám1 ezeknek az egészeknek az összege = 0.
- Az [1, 5] tartományban 1-gyel osztható egész számok [1,2,3,4,5], a num2 ezeknek az egészeknek az összege = 15.
Válaszként 0 - 15 = -15 értéket adunk vissza.

Korlátozások:

1 <= n, m <= 1000

Pozitív n és m egész számokat kap.
Definiáljon két egész számot, a num1 és num2 számokat az alábbiak szerint:

num1: Az [1, n] tartományban lévő összes olyan egész szám összege, amely nem osztható m-mel.
num2: Az [1, n] tartományban lévő összes egész szám összege, amelyek oszthatók m-mel.

A szám1 - szám2 egész számot adja eredményül.

1. példa:

Bemenet: n = 10, m = 3
Kimenet: 19
Magyarázat: Az adott példában:
- Az [1, 10] tartományba tartozó, 3-mal nem osztható egész számok [1,2,4,5,7,8,10], num1 ezen egész számok összege = 37.
- Az [1, 10] tartományban lévő, 3-mal osztható egész számok [3,6,9], num2 ezen egész számok összege = 18.
Válaszként 37 - 18 = 19-et adunk vissza.

2. példa:

Bemenet: n = 5, m = 6
Kimenet: 15
Magyarázat: Az adott példában:
- Az [1, 5] tartományban lévő egész számok, amelyek nem oszthatók 6-tal: [1,2,3,4,5], num1 ezen egész számok összege = 15.
- Az [1, 5] tartományban lévő, 6-tal osztható egész számok [], num2 az egész számok összege = 0.
Válaszként 15 - 0 = 15-öt adunk vissza.

3. példa:

Bemenet: n = 5, m = 1
Kimenet: -15
Magyarázat: Az adott példában:
- Az [1, 5] tartományban lévő egész számok, amelyek nem oszthatók 1-gyel: [], num1 az egész számok összege = 0.
- Az [1, 5] tartományban lévő, 1-gyel osztható egész számok [1,2,3,4,5], num2 ezen egész számok összege = 15.
Válaszként 0 - 15 = -15 értéket adunk vissza.

Korlátok:

1 < = n, m <= 1000


Adott egy 0-indexű, páros hosszúságú bináris karakterlánc, s.
Egy karakterlánc akkor szép, ha felosztható egy vagy több részkarakterláncra úgy, hogy:

Minden részkarakterlánc páros hosszúságú.
Minden részkarakterlánc csak 1-est vagy csak 0-t tartalmaz.

Az s bármelyik karakterét megváltoztathatod 0-ára vagy 1-re.
Add vissza a minimális változtatások számát ahhoz, hogy az s karakterlánc szép legyen.

1. példa:

Bemenet: s = "1001"
Kimenet: 2
Magyarázat: Megváltoztatjuk az s[1] értéket 1-re, az s[3] értéket pedig 0-ra, hogy megkapjuk  az "1100" karakterláncot.
Látható, hogy az "1100" karakterlánc szép, mert felosztható "11|00"-ra.
Bizonyítható, hogy 2 a minimális változtatások száma ahhoz, hogy a karakterlánc szép legyen.

2. példa:

Bemenet: s = "10"
Kimenet: 1
Magyarázat: Megváltoztatjuk s[1] értékét 1-re, hogy megkapjuk a "11" karakterláncot.
Látható, hogy a "11" karakterlánc szép, mert felosztható "11"-re.
Bizonyítható, hogy 1 a minimális változtatások száma ahhoz, hogy a karakterlánc szép legyen.

3. példa:

Bemenet: s = "0000"
Kimenet: 0
Magyarázat: Nem kell semmilyen változtatást végrehajtanunk, mivel a "0000" karakterlánc már szép.

Korlátozások:

2 <= s.hossz <= 10^5
s egyenletes hosszúságú.
s[i] vagy '0', vagy '1'.

Kapsz egy 0-indexelt bináris karakterláncot, amelynek páros hosszúságú.
Egy karakterlánc akkor szép, ha lehetséges egy vagy több részsztringre particionálni úgy, hogy:

Minden részsztring páros hosszúságú.
Minden részsztring csak 1-et vagy csak 0-t tartalmaz.

Az s bármely karakterét megváltoztathatja 0-ra vagy 1-re.
Visszaadja az s karakterlánc széppé tételéhez szükséges minimális számú módosítást.

1. példa:

Bemenet: s = "1001"
Kimenet: 2
Magyarázat: Az s[1]-et 1-re, az s[3]-at 0-ra változtatjuk, hogy megkapjuk az "1100" karakterláncot.
Látható, hogy az "1100" karakterlánc gyönyörű, mert "11|00" -ra oszthatjuk.
Bizonyítható, hogy a 2 a minimális számú változtatás, amely ahhoz szükséges, hogy a karakterlánc szép legyen.

2. példa:

Bemenet: s = "10"
Kimenet: 1
Magyarázat: Az s[1]-et 1-re változtatjuk, hogy megkapjuk a "11" karakterláncot.
Látható, hogy a "11" karakterlánc gyönyörű, mert "11" -re oszthatjuk.
Bizonyítható, hogy 1 a minimális számú változtatás, amely szükséges ahhoz, hogy a karakterlánc szép legyen.

3. példa:

Bemenet: s = "0000"
Kimenet: 0
Magyarázat: Nem kell változtatnunk, mivel a "0000" karakterlánc már gyönyörű.

Korlátok:

2 <= s.length <= 10^5
s egyenletes hosszúságú.
s[i] értéke "0" vagy "1".

Kapsz egy 0-indexelt bináris karakterláncot, melynek hossza páros.
Egy karakterlánc akkor szép, ha egy vagy több részkarakterláncra particionálható úgy, hogy:

Minden részkarakterlánc páros hosszúságú.
Minden részkarakterlánc csak 1-est vagy csak 0-t tartalmaz.

Bármely s karaktert megváltoztathatja 0-ra vagy 1-re.
Adja vissza a minimális számú változtatást ahhoz, hogy a karakterlánc szép legyen.

1. példa:

Bemenet: s = "1001"
Kimenet: 2
Magyarázat: Az s[1] értéket 1-re, az s[3] értéket 0-ra változtatjuk, hogy megkapjuk az "1100" karakterláncot.
Látható, hogy az "1100" karakterlánc azért szép, mert particionálhatjuk "11|00"-ra.
Bizonyítható, hogy 2 a minimális változtatások száma ahhoz, hogy a húr szép legyen.

2. példa:

Bemenet: s = "10"
Kimenet: 1
Magyarázat: Az s[1]-et 1-re változtatjuk, hogy megkapjuk a "11" karakterláncot.
Látható, hogy a "11" karakterlánc azért szép, mert particionálhatjuk "11"-re.
Bizonyítható, hogy 1 a minimális változtatások száma ahhoz, hogy a húr szép legyen.

3. példa:

Bemenet: s = "0000"
Kimenet: 0
Magyarázat: Semmit sem kell módosítanunk, mivel a „0000” karakterlánc már gyönyörű.

Korlátozások:

2 <= s.length <= 10^5
s has an even length.
s[i] is either '0' or '1'.


Adott egy 0-indexált egész számokból álló nums tömb.
Az (i, j, k) indexek hármasa hegy, ha:

i < j < k
nums[i] < nums[j] és nums[k] < nums[j]

A számok hegyi triplájának minimálisan lehetséges összegét adja vissza. Ha ilyen triplett nem létezik, akkor -1-et ad vissza.

Példa 1:

Bemenet: nums = [8,6,1,5,3]
Kimenet: 9
Magyarázat: A (2, 3, 4) triplett a 9-es összegű hegyi triplett, mivel:
- 2 < 3 < 4
- nums[2] < nums[3] és nums[4] < nums[3]
És ennek a triplettnek az összege: nums[2] + nums[3] + nums[4] = 9. Megmutatható, hogy nincs olyan hegyi hármas, amelynek összege kisebb lenne 9-nél.

Példa 2:

Bemenet: nums = [5,4,8,7,10,2]
Kimenet: 13
Magyarázat: A (1, 3, 5) triplett egy 13-as összegű hegyi triplett, mivel:
- 1 < 3 < 5
- nums[1] < nums[3] és nums[5] < nums[3]
És ennek a triplettnek az összege: nums[1] + nums[3] + nums[5] = 13. Megmutatható, hogy nincs olyan hegyi hármas, amelynek összege 13-nál kisebb lenne.

Példa 3:

Bemenet: nums = [6,5,4,3,4,5]
Kimenet: -1
Magyarázat: A nums-ban nincsenek hegyi hármasok.

Korlátozások:

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

Kapsz egy 0-indexelt tömböt egész számokból.
Az indexek hármasa (i, j, k) egy hegy, ha:

i < j < k
nums[i] < nums[j] and nums[k] < nums[j]

Adja vissza a számok hegyi hármasának minimális lehetséges összegét. Ha nem létezik ilyen hármas, adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [8,6,1,5,3]
Kimenet: 9
Magyarázat: A Triplet (2, 3, 4) egy 9-es összegű hegyi hármas, mivel:
- 2 < 3 < 4
- nums[2] < nums[3] and nums[4] < nums[3]
Ennek a hármasnak az összege pedig nums[2] + nums[3] + nums[4] = 9. Megmutatható, hogy nincsenek 9-nél kisebb összegű hegyhármasok.

2. példa:

Bemenet: nums = [5,4,8,7,10,2]
Kimenet: 13
Magyarázat: A Triplet (1, 3, 5) egy hegyi hármas, amelynek összege 13, mivel:
- 1 < 3 < 5
- nums[1] < nums[3] and nums[5] < nums[3]
Ennek a hármasnak az összege pedig nums[1] + nums[3] + nums[5] = 13. Megmutatható, hogy nincsenek 13-nál kisebb összegű hegyhármasok.

3. példa:

Bemenet: nums = [6,5,4,3,4,5]
Kimenet: -1
Magyarázat: Kimutatható, hogy számokban nincsenek hegyhármasok.

Korlátozások:

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

Kapsz egy 0-indexelt tömböt egész számokból.
Az indexek hármasa (i, j, k) egy hegy, ha:

i < j < k
nums[i] < nums[j] és nums[k] < nums[j]

Adja vissza a számok hegyi hármasának minimális lehetséges összegét. Ha nem létezik ilyen hármas, adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [8,6,1,5,3]
Kimenet: 9
Magyarázat: A Triplet (2, 3, 4) egy 9-es összegű hegyi hármas, mivel:
- 2 < 3 < 4
- nums[2] < nums[3] és nums[4] < nums[3]
Ennek a hármasnak az összege pedig nums[2] + nums[3] + nums[4] = 9. Megmutatható, hogy nincsenek 9-nél kisebb összegű hegyhármasok.

2. példa:

Bemenet: nums = [5,4,8,7,10,2]
Kimenet: 13
Magyarázat: A Triplet (1, 3, 5) egy hegyi hármas, amelynek összege 13, mivel:
- 1 < 3 < 5
- nums[1] < nums[3] és nums[5] < nums[3]
Ennek a hármasnak az összege pedig nums[1] + nums[3] + nums[5] = 13. Megmutatható, hogy nincsenek 13-nál kisebb összegű hegyhármasok.

3. példa:

Bemenet: nums = [6,5,4,3,4,5]
Kimenet: -1
Magyarázat: Kimutatható, hogy számokban nincsenek hegyhármasok.

Korlátozások:

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


Adott egy 0-indexált egész szám tömb nums és egy egész szám k.
A nums K-or olyan nemnegatív egész szám, amely kielégíti az alábbiakat:

Az i^-edik bit akkor és csak akkor van beállítva a K-orban, ha a numsnak legalább k olyan eleme van, amelyben az i. bit be van állítva.

A nums K-vagy értékének visszaadása.
Megjegyezzük, hogy egy i bit akkor van beállítva x-ben, ha (2^i AND x) == 2^i, ahol az AND a bitenkénti AND operátor.

Példa 1:

Bemenet: nums = [7,12,9,8,9,15], k = 4
Kimenet: 9
Magyarázat: A 0 bit a nums[0], nums[2], nums[4] és nums[5] értékeken van beállítva.
Az 1. bit a nums[0]-nál és a nums[5]-nél van beállítva.
A 2. bit a nums[0]-nál, a nums[1]-nél és a nums[5]-nél van beállítva.
A 3. bit a nums[1], nums[2], nums[3], nums[4] és nums[5] értékeken van beállítva.
A tömb legalább k elemében csak a 0 és a 3 bit van beállítva, és az i >= 4 bitek a tömb egyetlen elemében sincsenek beállítva. A válasz tehát 2^0 + 2^3 = 9.

2. példa:

Bemenet: nums = [2,12,1,11,4,5], k = 6
Kimenet: 0
Magyarázat: Mivel k == 6 == nums.length, a tömb 6-os vagyja egyenlő a tömb összes elemének bitenkénti ÉS-ével. Ezért a válasz: 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Példa 3:

Bemenet: nums = [10,8,5,9,11,6,8], k = 1
Kimenet: 15
Magyarázat: Mivel k == 1, a tömb 1-or-ja egyenlő az összes elemének bitenkénti VAGY-ával. Ezért a válasz: 10 VAGY 8 VAGY 5 VAGY 9 VAGY 11 VAGY 6 VAGY 8 = 15.

Korlátozások:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
A számok K-vagy értéke egy nem negatív egész szám, amely kielégíti a következőket:

Az i^-edik bit akkor és csak akkor van beállítva a K-ban, ha legalább k eleme van a számoknak, amelyekben az i bit be van állítva.

Adja vissza a számok K-vagy értékét.
Vegye figyelembe, hogy az i bit be van állítva x-ben, ha (2^i ÉS x) == 2^i, ahol az ÉS a bitenkénti ÉS operátor.

Példa 1:

Bemenet: számok = [7,12,9,8,9,15], k = 4
Kimenet: 9
Magyarázat: A 0. bit számok[0], számok[2], számok[4] és számok[5] értékre van állítva.
Az 1. bit nums[0] és nums[5] értékre van állítva.
A 2. bit nums[0], nums[1] és nums[5] értékre van beállítva.
A 3. bit számok[1], számok[2], számok[3], számok[4] és számok[5] értékre van beállítva.
A tömb legalább k elemében csak a 0 és 3 bitek vannak beállítva, az i >= 4 bitek pedig a tömb egyik elemében sincsenek beállítva. Ezért a válasz 2^0 + 2^3 = 9.

Példa 2:

Bemenet: nums = [2,12,1,11,4,5], k = 6
Kimenet: 0
Magyarázat: Mivel k == 6 == szám.length, a tömb 6-vagy értéke egyenlő az összes elem bitenkénti ÉS értékével. Ezért a válasz: 2 ÉS 12 ÉS 1 ÉS 11 ÉS 4 ÉS 5 = 0.

Példa 3:

Bemenet: nums = [10,8,5,9,11,6,8], k = 1
Kimenet: 15
Magyarázat: Mivel k == 1, a tömb 1-vagy értéke egyenlő az összes elem bitenkénti VAGY értékével. Ezért a válasz 10 VAGY 8 VAGY 5 VAGY 9 VAGY 11 VAGY 6 VAGY 8 = 15.

Korlátozások:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
A számok K-vagy értéke egy nem negatív egész szám, amely kielégíti a következőket:

Az i^-edik bit akkor és csak akkor van beállítva a K-ban, ha legalább k eleme van a számoknak, amelyekben az i bit be van állítva.

Adja vissza a számok K-vagy értékét.
Vegye figyelembe, hogy az i bit be van állítva x-ben, ha (2^i ÉS x) == 2^i, ahol az ÉS a bitenkénti ÉS operátor.

1. példa:

Bemenet: nums = [7,12,9,8,9,15], k = 4
Kimenet: 9
Magyarázat: A 0. bit nums[0], nums[2], nums[4] és nums[5] értékre van állítva.
Az 1. bit nums[0] és nums[5] értékre van állítva.
A 2. bit nums[0], nums[1] és nums[5] értékre van beállítva.
A 3. bit nums[1], nums[2], nums[3], nums[4] és nums [5] értékre van beállítva.
A tömb legalább k elemében csak a 0 és 3 bitek vannak beállítva, az i >= 4 bitek pedig a tömb egyik elemében sincsenek beállítva. Ezért a válasz 2^0 + 2^3 = 9.

2. példa:

Bemenet: nums = [2,12,1,11,4,5], k = 6
Kimenet: 0
Magyarázat: Mivel k == 6 == nums.length, a tömb 6-vagy értéke egyenlő az összes elem bitenkénti ÉS értékével. Ezért a válasz: 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

3. példa:

Bemenet: nums = [10,8,5,9,11,6,8], k = 1
Kimenet: 15
Magyarázat: Mivel k == 1, a tömb 1-vagy értéke egyenlő az összes elem bitenkénti VAGY értékével. Ezért a válasz 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15.

Korlátozások:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length


Adott egy 0-indexált egész számtömb nums.
A nums egy k hosszúságú részszekvenciája, amely az i_0 < i_1 < ... < i_k-1 indexekből áll, kiegyensúlyozott, ha a következő feltétel teljesül:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, minden j esetében a [1, k - 1] tartományban.

Egy elemszámú nums részszekvenciát kiegyensúlyozottnak tekintünk.
Adjon vissza egy egész számot, amely a nums egy kiegyensúlyozott részszekvenciájában lévő elemek maximális lehetséges összegét jelöli.
Egy tömb részszekvenciája egy új, nem üres tömb, amely az eredeti tömbből képződik úgy, hogy néhány (esetleg egyetlen) elemet törölnek anélkül, hogy a megmaradt elemek relatív helyzetét megváltoztatnák.

Példa 1:

Bemenet: nums = [3,3,5,6]
Kimenet: 14
Magyarázat: Ebben a példában a [3,5,6] részszekvenciát az 0, 2 és 3 indexek alkotják.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Ezért ez egy kiegyensúlyozott részszekvencia, és az összegük maximális a nums kiegyensúlyozott részszekvenciái között.
Az 1, 2 és 3 indexekből álló részszekvencia is érvényes.
Bizonyítható, hogy nem lehet nagyobb összegű kiegyensúlyozott részszekvenciát kapni, mint 14.
Példa 2:

Bemenet: nums = [5,-1,-3,8]
Kimenet: 13
Magyarázat: Ebben a példában a [5,8] részszekvenciát az 0 és 3 indexek alkotják.
nums[3] - nums[0] >= 3 - 0.
Ezért ez egy kiegyensúlyozott részszekvencia, és az összegük maximális a nums kiegyensúlyozott részszekvenciái között.
Bizonyítható, hogy nem lehet nagyobb összegű kiegyensúlyozott részszekvenciát kapni, mint 13.

Példa 3:

Bemenet: nums = [-2,-1]
Kimenet: -1
Magyarázat: Ebben a példában a [-1] részszekvenciát lehet kiválasztani.
Ez egy kiegyensúlyozott részszekvencia, és az összegük maximális a nums kiegyensúlyozott részszekvenciái között.

Korlátozások:

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

Adott egy 0-indexált egész számtömb nums.
A nums k hosszúságú, i_0 < i_1 < ... indexekből álló részsorozata. < i_k-1 kiegyensúlyozott, ha a következő áll:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, minden j-re az [1, k - 1] tartományban.

A nums 1 hosszúságú részsorozata kiegyensúlyozottnak tekinthető.
A nums kiegyensúlyozott részfolyamatában lévő elemek maximálisan lehetséges összegét jelölő egész számot adja vissza.
Egy tömb részsorozata egy új, nem üres tömb, amelyet az eredeti tömbből úgy képezünk, hogy néhány elemet (esetleg egyet sem) törölünk anélkül, hogy a megmaradt elemek relatív pozícióját megzavarnánk.

Példa 1:

Bemenet: nums = [3,3,5,6]
Kimenet: 14
Magyarázat: Ebben a példában a 0, 2 és 3 indexekből álló [3,5,6] részfolyamatot lehet kiválasztani.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Tehát ez egy kiegyensúlyozott részfolyamat, és az összege a legnagyobb a nums kiegyensúlyozott részfolyamatai közül.
Az 1, 2 és 3 indexekből álló részfolyamat is érvényes.
Megmutatható, hogy nem lehet olyan kiegyensúlyozott részfolyamatot kapni, amelynek összege nagyobb, mint 14.
Példa 2:

Bemenet: nums = [5,-1,-3,8]
Kimenet: 13
Magyarázat: Ebben a példában a 0 és 3 indexekből álló [5,8] részfolyamatot lehet kiválasztani.
nums[3] - nums[0] >= 3 - 0.
Tehát ez egy kiegyensúlyozott részfolyamat, és az összege a legnagyobb a nums kiegyensúlyozott részfolyamatai közül.
Megmutatható, hogy nem lehetséges olyan kiegyensúlyozott részfolyamatot kapni, amelynek összege nagyobb, mint 13.

Példa 3:

Bemenet: nums = [-2,-1]
Kimenet: -1
Magyarázat: Ebben a példában a [-1] részfolyamatot lehet kiválasztani.
Ez egy kiegyensúlyozott részsorozat, és az összege a nums kiegyensúlyozott részsorozatai közül a legnagyobb.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot.
A k hosszúságú és i_0 < i_1 < ... < i_k-1 indexekből álló számok részsorozata kiegyensúlyozott, ha a következők teljesülnek:

számok[i_j] - számok[i_j-1] >= i_j - i_j-1, az [1, k - 1] tartomány minden j-ére.

Az 1 hosszúságú számok részsorozatát kiegyensúlyozottnak tekintjük.
Egy egész számot ad vissza, amely a számok kiegyensúlyozott részsorozatának elemeinek maximális lehetséges összegét jelöli.
A tömb egy részsorozata egy új, nem üres tömb, amely az eredeti tömbből úgy jön létre, hogy néhány elemet (esetleg egyiket sem) töröl anélkül, hogy megzavarná a fennmaradó elemek egymáshoz viszonyított helyzetét.

1. példa:

Bemenet: nums = [3,3,5,6]
Kimenet: 14
Magyarázat: Ebben a példában a 0, 2 és 3 indexekből álló [3,5,6] részsorozat választható.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Ezért ez egy kiegyensúlyozott részsorozat, és összege a maximum a számok kiegyensúlyozott részsorozatai között.
Érvényes az 1., 2. és 3. indexekből álló részsorozat is.
Kimutatható, hogy nem lehet 14-nél nagyobb összegű kiegyensúlyozott részsorozatot kapni.
2. példa:

Bemenet: nums = [5,-1,-3,8]
Kimenet: 13
Magyarázat: Ebben a példában a 0 és 3 indexekből álló [5,8] részsorozat választható.
nums[3] - nums[0] >= 3 - 0.
Ezért ez egy kiegyensúlyozott részsorozat, és összege a maximum a számok kiegyensúlyozott részsorozatai között.
Megmutatható, hogy nem lehet 13-nál nagyobb összegű kiegyensúlyozott részsorozatot kapni.

3. példa:

Bemenet: nums = [-2,-1]
Kimenet: -1
Magyarázat: Ebben a példában a [-1] részsorozat választható.
Ez egy kiegyensúlyozott részsorozat, és összege a maximum a számok kiegyensúlyozott részsorozatai között.

Korlátozások:

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