Adott egy n egész számból álló nums 0-indexált tömb és egy egész szám cél.
Kezdetben az index 0-nál vagy. Egy lépésben az i indexről bármelyik j indexre ugorhatsz, ahol:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Add vissza az elérhető maximális ugrások számát az index n - 1 eléréséhez.
Ha nincs mód az index n - 1 elérésére, add vissza a -1-et.

Példa 1:

Bemenet: nums = [1,3,6,4,1,2], target = 2
Kimenet: 3
Magyarázat: Ahhoz, hogy az index 0-ról az index n - 1-re a maximális számú ugrással eljussunk, a következő ugrássorozatot hajthatjuk végre:
- Ugrás az index 0-ról az index 1-re.
- Ugrás az index 1-ről az index 3-ra.
- Ugrás az index 3-ról az index 5-re.
Bizonyítható, hogy nincs más ugrássorozat, amely index 0-ról index n - 1-re több mint 3 ugrással menne. Ezért a válasz 3.

Példa 2:

Bement: nums = [1,3,6,4,1,2], target = 3
Kimenet: 5
Magyarázat: Ahhoz, hogy az index 0-ról az index n - 1-re a maximális számú ugrással eljussunk, a következő ugrássorozatot hajthatjuk végre:
- Ugrás az index 0-ról az index 1-re.
- Ugrás az index 1-ről az index 2-re.
- Ugrás az index 2-ről az index 3-ra.
- Ugrás az index 3-ról az index 4-re.
- Ugrás az index 4-ről az index 5-re.
Bizonyítható, hogy nincs más ugrássorozat, amely index 0-ról index n - 1-re több mint 5 ugrással menne. Ezért a válasz 5.

Példa 3:

Bemenet: nums = [1,3,6,4,1,2], target = 0
Kimenet: -1
Magyarázat: Bizonyítható, hogy nincs olyan ugrássorozat, amely index 0-ról index n - 1-re menne. Ezért a válasz -1.

Korlátozások:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

Adott egy n egész számból álló nums 0-indexált tömb és egy egész szám cél.
Kezdetben a 0 indexen helyezkedik el. Egy lépésben az i indexről bármelyik j indexre ugorhatsz úgy, hogy:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Adja vissza az n - 1 index eléréséhez maximálisan elvégezhető ugrások számát.
Ha nem lehet elérni az n - 1 indexet, akkor -1-et ad vissza.

1. példa:

bemenet: nums = [1,3,6,4,1,2], target = 2
Kimenet: 3
Magyarázat: A 0 indexről az n - 1 indexre a maximális számú ugrásoksal lehet eljutni, ha a következőugrásoksorozatot hajtjuk végre:
- ugrások a 0. indexről az 1. indexre.
- ugrások az 1. indexről a 3. indexre.
- ugrások a 3. indexről az 5. indexre.
Bebizonyítható, hogy nincs más olyan ugrásoksorozat, amely 0-ról n - 1-re több mint 3ugrásoksal jutna el. A válasz tehát 3.
2. példa:

Bemenet:nums = [1,3,6,4,1,2], target = 3
Kimenet: 5
Magyarázat: A 0 indexről az n - 1 indexre a maximális számú ugrásoksal lehet eljutni, ha a következő ugrásoksorozatot hajtjuk végre:
- ugrásoka 0. indexről az 1. indexre.
- ugrások az 1. indexről a 2. indexre.
- ugrások a 2. indexről a 3. indexre.
- ugrások a 3. indexről a 4. indexre.
- ugrások a 4. indexről az 5. indexre.
Bizonyítható, hogy nincs olyan ugrásoksorozat, amely 0-tól n - 1-ig 5-nél több ugrásoksal haladna. A válasz tehát 5.
3. példa:

Bemenet: nums = [1,3,6,4,1,2], target = 0
Kimenet: -1
Magyarázat: Bebizonyítható, hogy nincs olyan ugrásoki sorozat, amely 0-tól n - 1-ig terjed. Ezért a válasz -1.

Kényszerek:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

Kap egy 0 indexelt tömb számot n egész számból és egy egész célból.
Kezdetben a 0-as indexen van. Egy lépésben ugorhat az i indexről bármely j indexre úgy, hogy:

0 < = i < j < n
-target <= nums[j] - nums[i] <= target

Adja vissza az n - 1 index eléréséhez elvégezhető ugrások maximális számát.
Ha nincs mód az n - 1 index elérésére, adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [1,3,6,4,1,2], target = 2
Kimenet: 3
Magyarázat: Ha a 0-s indexről az n - 1 indexre szeretne lépni a maximális ugrásszámmal, a következő ugrássorozatot hajthatja végre:
- Ugrás a 0-s indexről az 1-es indexre.
- Ugrás az 1. indexről a 3. indexre.
- Ugrás a 3. indexről az 5. indexre.
Bizonyítható, hogy nincs más ugrási sorrend, amely 0-tól n - 1-ig megy, több mint 3 ugrással. Ezért a válasz 3.
2. példa:

Bemenet: nums = [1,3,6,4,1,2], target = 0
Kimenet: 5
Magyarázat: Ha a 0-s indexről az n - 1 indexre szeretne lépni a maximális ugrásszámmal, a következő ugrássorozatot hajthatja végre:
- Ugrás a 0-s indexről az 1-es indexre.
- Ugrás az 1. indexről a 2. indexre.
- Ugrás a 2. indexről a 3. indexre.
- Ugrás a 3. indexről a 4. indexre.
- Ugrás a 4. indexről az 5. indexre.
Bizonyítható, hogy nincs más ugrási sorrend, amely 0-tól n - 1-ig megy, több mint 5 ugrással. Ezért a válasz 5.
3. példa:

Bemenet: nums = [1,3,6,4,1,2], target = 0
Kimenet: -1
Magyarázat: Bebizonyítható, hogy nincs olyan ugrási sorozat, amely 0-tól n - 1-ig terjed. Ezért a válasz -1.

Korlátok:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9


Egy pozitív egész számokból álló nums tömböt kapsz.
Egy tömb altömbjét teljesnek nevezzük, ha a következő feltétel teljesül:

Az altömbben lévő különálló elemek száma megegyezik a teljes tömbben lévő különálló elemek számával.

Visszaadja a teljes altömbök számát.
Az altömb egy tömb összefüggő, nem üres része.

Példa 1:

Bemenet: nums = [1,3,1,2,2]
Kimenet: 4
Magyarázat: A teljes altömbök a következők: [1,3,1,2], [1,3,1,2,2], [3,1,2] és [3,1,2,2].

Példa 2:

Bemenet: nums = [5,5,5,5]
Kimenet: 10
Magyarázat: A tömb csak az 5-ös egész számból áll, tehát minden altömb teljes. A választható altáblák száma 10.

Korlátozások:

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

Kapsz egy pozitív egész számokból álló tömböt.
Egy tömb altömbjét teljesnek nevezzük, ha a következő feltétel teljesül:

Az altömbben lévő különálló elemek száma megegyezik a teljes tömbben lévő különálló elemek számával.

Visszaadja a teljes altömbök számát.
Az altömb egy tömb összefüggő, nem üres része.

1. példa:

Bemenet: nums = [1,3,1,2,2]
Kimenet: 4
Magyarázat: A teljes altömbök a következők: [1,3,1,2], [1,3,1,2,2], [3,1,2] és [3,1,2,2].

2. példa:

Bemenet: nums = [5,5,5,5]
Kimenet: 10
Magyarázat: A tömb csak az 5-ös egész számból áll, tehát minden altömb teljes. A választható altáblák száma 10.

Korlátozások:

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

Kapsz egy tömbszámot, amely pozitív egész számokból áll.
Egy tömb résztömbjét teljesnek nevezzük, ha a következő feltétel teljesül:

Az altömbben lévő különálló elemek száma megegyezik a teljes tömb különálló elemeinek számával.

A teljes résztömbök számát adja eredményül.
Az altömb egy tömb folytonos, nem üres része.

1. példa:

Bemenet: nums = [1,3,1,2,2]
Kimenet: 4
Magyarázat: A teljes résztömbök a következők: [1,3,1,2], [1,3,1,2,2], [3,1,2] és [3,1,2,2].

2. példa:

Bemenet: nums = [5,5,5,5]
Kimenet: 10
Magyarázat: A tömb csak az 5 egész számból áll, így minden résztömb teljes. A választható altömbök száma 10.

Korlátok:

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


A teherautónak két üzemanyagtartálya van. Két egész számot kapunk, a mainTank a főtartályban lévő üzemanyagot literben, a additionalTank pedig a kiegészítő tartályban lévő üzemanyagot literben.
A teherautó kilométerteljesítménye literenként 10 km. Amikor 5 liter üzemanyag elfogy a főtartályban, ha a kiegészítő tartályban van legalább 1 liter üzemanyag, akkor 1 liter üzemanyag kerül át a kiegészítő tartályból a főtartályba.
Visszaadja a maximálisan megtehető távolságot.
Megjegyzés: A befecskendezés a kiegészítő tartályból nem folyamatos. Ez hirtelen és azonnal történik minden 5 liter elfogyasztott liter után.

1. példa:

Bemenet: mainTank = 5, additionalTank = 10
Kimenet: 60
Magyarázat:
Az 5 liter üzemanyag elköltése után a maradék üzemanyag (5 - 5 + 1) = 1 liter, a megtett távolság pedig 50 km.
További 1 liter üzemanyag elköltése után a főtartályba nem kerül üzemanyag, és a főtartály üres lesz.
A megtett távolság összesen 60 km.

2. példa:

Bemenet: mainTank = 1, additionalTank = 2
Kimenet: 10
Magyarázat:
Miután elköltött 1 liter üzemanyagot, a főtartály kiürül.
A megtett távolság összesen 10 km.

Korlátozások:

1 <= mainTank, additionalTank <= 100

Egy teherautón két üzemanyagtartály található. Két egész számot kapsz: mainTank, amely a fő tartályban lévő üzemanyag mennyiségét jelenti literben, és additionalTank, amely az extra tartályban lévő üzemanyag mennyiségét jelenti literben.
A teherautó üzemanyag-fogyasztása 10 km literenként. Amikor a fő tartályban 5 liter üzemanyag elhasználódik, ha az extra tartályban legalább 1 liter üzemanyag van, akkor 1 liter üzemanyag átkerül az extra tartályból a fő tartályba.
 Térj vissza a megtett maximális távolsággal.
Megjegyzés: Az üzemanyag átvitele az extra tartályból nem folyamatos. Minden 5 liter elfogyasztása után hirtelen és azonnal történik, ha az extra tartályban legalább 1 liter üzemanyag van.

Példa 1:

Input: mainTank = 5, additionalTank = 10
Output: 60
Magyarázat:
Miután elhasználódott 5 liter üzemanyag, a fennmaradó üzemanyag mennyisége (5 - 5 + 1) = 1 liter, és a megtett távolság 50 km.
Miután újabb 1 liter üzemanyag elhasználódik, nem történik üzemanyag-átemelés a fő tartályba, és a fő tartály kiürül.
A megtett összes távolság 60 km.

Példa 2:

Input: mainTank = 1, additionalTank = 2
Output: 10
Magyarázat:
Miután 1 liter üzemanyag elhasználódott, a fő tartály kiürül.
A megtett összes távolság 10 km.

Korlátozások:

1 <= mainTank, additionalTank <= 100

Egy teherautónak két üzemanyagtartálya van. Két egész számot kap, a mainTank a fő tartályban lévő üzemanyag mennyiségét jelöli literben, az extraTank pedig a kiegészítő tartályban lévő üzemanyagot jelöli literben.
A teherautó futásteljesítménye literenként 10 km. Amikor 5 liter üzemanyag elfogy a fő tartályban, és ha a kiegészítő tartályban legalább 1 liter üzemanyag van, 1 liter üzemanyag kerül át a kiegészítő tartályból a fő tartályba.
Visszaadja a maximálisan megtehető távolságot.
Megjegyzés: A kiegészítő tartályból történő befecskendezés nem folyamatos. Hirtelen és azonnal történik minden elfogyasztott 5 literre.

1. példa:

Bemenet: mainTank = 5, additionalTank = 10
Kimenet: 60
Magyarázat:
5 liter üzemanyag elfogyasztása után a maradék üzemanyag (5 - 5 + 1) = 1 liter, a megtett távolság pedig 50 km.
További 1 liter üzemanyag elfogyasztása után nem fecskendez be üzemanyagot a főtartályba, és a főtartály kiürül.
A teljes megtett távolság 60 km.

2. példa:

Bemenet: mainTank = 1, additionalTank  = 2
Kimenet: 10
Magyarázat:
1 liter üzemanyag elfogyasztása után a főtartály kiürül.
A teljes megtett távolság 10 km.

Korlátozások:

1 <= mainTank, additionalTank <= 100


Adott egy 0-indexált egész szám tömb nums és egy egész szám küszöbérték.
Találd meg a nums leghosszabb rész-tömbjének (subarray) hosszát, amely az l indexnél kezdődik és az r indexnél végződik (0 <= l <= r < nums.length) és megfelel a következő feltételeknek:

nums[l] % 2 == 0
Minden i indexre az [l, r - 1] intervallumban, nums[i] % 2 != nums[i + 1] % 2
Minden i indexre az [l, r] intervallumban, nums[i] <= threshold

Adj vissza egy egész számot, amely megadja az ilyen rész-tömb leghosszabb hosszát.
Megjegyzés: Egy rész-tömb egy tömb szomszédos és nem üres elemek sorozata.

Példa 1:

Bemenet: nums = [3,2,5,4], threshold = 5
Kimenet: 3
Magyarázat: Ebben a példában választhatjuk a rész-tömböt, amely az l = 1 indexnél kezdődik és az r = 3 indexnél végződik => [2,5,4]. Ez a rész-tömb megfelel a feltételeknek.
Ezért a válasz a rész-tömb hossza, ami 3. Bizonyítható, hogy a 3 a maximálisan elérhető hossz.

Példa 2:

Bemenet: nums = [1,2], threshold = 2
Kimenet: 1
Magyarázat: Ebben a példában választhatjuk a rész-tömböt, amely az l = 1 indexnél kezdődik és az r = 1 indexnél végződik => [2].
Ez minden feltételt kielégít és bizonyítható, hogy 1 a maximálisan elérhető hossz.

Példa 3:

Bemenet: nums = [2,3,4,5], threshold = 4
Kimenet: 3
Magyarázat: Ebben a példában választhatjuk a rész-tömböt, amely az l = 0 indexnél kezdődik és az r = 2 indexnél végződik => [2,3,4].
Ez minden feltételt kielégít.
Ezért a válasz a rész-tömb hossza, ami 3. Bizonyítható, hogy a 3 a maximálisan elérhető hossz.

Korlátozások:

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

Megadott egy 0-indextől számozott egész számokat tartalmazó tömb, nums, és egy egész threshold.
Találd meg a nums leghosszabb rész-tömbjének (subarray) hosszát, amely az l indexnél kezdődik és az r indexnél végződik (0 <= l <= r < nums.length) és megfelel a következő feltételeknek:

nums[l] % 2 == 0
Minden i indexre az [l, r - 1] intervallumban, nums[i] % 2 != nums[i + 1] % 2
Minden i indexre az [l, r] intervallumban, nums[i] <= threshold

Adj vissza egy egész számot, amely megadja az ilyen rész-tömb leghosszabb hosszát.
Megjegyzés: Egy rész-tömb egy tömb szomszédos és nem üres elemek sorozata.

Példa 1:

Input: nums = [3,2,5,4], threshold = 5
Output: 3
Magyarázat: Ebben a példában választhatjuk a rész-tömböt, amely az l = 1 indexnél kezdődik és az r = 3 indexnél végződik => [2,5,4]. Ez a rész-tömb megfelel a feltételeknek.
Ezért a válasz a rész-tömb hossza, ami 3. Bizonyítható, hogy a 3 a maximálisan elérhető hossz.

Példa 2:

Input: nums = [1,2], threshold = 2
Output: 1
Magyarázat: Ebben a példában választhatjuk a rész-tömböt, amely az l = 1 indexnél kezdődik és az r = 1 indexnél végződik => [2].
Ez minden feltételt kielégít és bizonyítható, hogy 1 a maximálisan elérhető hossz.

Példa 3:

Input: nums = [2,3,4,5], threshold = 4
Output: 3
Magyarázat: Ebben a példában választhatjuk a rész-tömböt, amely az l = 0 indexnél kezdődik és az r = 2 indexnél végződik => [2,3,4].
Ez minden feltételt kielégít.
Ezért a válasz a rész-tömb hossza, ami 3. Bizonyítható, hogy a 3 a maximálisan elérhető hossz.

Feltételek:

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

Adott egy 0-indexált egész szám tömb nums és egy egész szám küszöbérték.
Keressük meg a nums leghosszabb, l indexen kezdődő és r indexen végződő (0 <= l <= r < nums.length) altömbjének hosszát, amely kielégíti a következő feltételeket:

nums[l] % 2 == 0
A [l, r - 1] tartományban lévő összes i indexre vonatkozóan nums[i] % 2 != nums[i + 1] % 2
Az [l, r] tartományban lévő összes i indexre vonatkozóan nums[i] <= küszöbérték

Adjon vissza egy egész számot, amely a leghosszabb ilyen altömb hosszát jelöli.
Megjegyzés: Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

Példa 1:

Bevitel: nums = [3,2,5,4], threshold = 5
Kimenet: 3
Magyarázat: Ebben a példában az l = 1-nél kezdődő és r = 3-nál végződő résztömböt választhatjuk ki => [2,5,4]. Ez az altömb megfelel a feltételeknek.
A válasz tehát az altömb hossza, 3. Megmutathatjuk, hogy 3 a maximálisan elérhető hosszúság.
2. példa:

Bemenet: nums = [1,2], threshold = 2
Kimenet: 1
Magyarázat: Ebben a példában azt az altömböt választhatjuk ki, amely l = 1-nél kezdődik és r = 1-nél végződik => [2].
Ez minden feltételt kielégít, és megmutathatjuk, hogy 1 a maximálisan elérhető hosszúság.

3. példa:

Bevitel: nums = [2,3,4,5], threshold = 4
Kimenet: 3
Magyarázat: Ebben a példában az l = 0-nál kezdődő és r = 2-nél végződő résztömböt választhatjuk ki => [2,3,4].
Ez minden feltételnek megfelel.
A válasz tehát az altömb hossza, 3. Megmutathatjuk, hogy 3 a maximálisan elérhető hosszúság.

Korlátozások:

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


Adott egy bináris tömb, nums.
Egy tömb egy részhalmaza akkor jó, ha pontosan egy elemet tartalmaz, amelynek értéke 1.
Adj vissza egy egész számot, amely jelzi, hányféleképpen lehet a nums tömböt jó részhalmazokra osztani. Mivel a szám túl nagy lehet, add vissza a 10^9 + 7 modójára.
Egy részhalmaz a tömb elemeinek folytonos, nem üres sorrendje.

Példa 1:

Bemenet: nums = [0,1,0,0,1]
Kimenet: 3
Magyarázat: 3 mód van a nums jó részhalmazokra való osztására:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Példa 2:

Bemenet: nums = [0,1,0]
Kimenet: 1
Magyarázat: 1 mód van a nums jó részhalmazokra való osztására:
- [0,1,0]

Korlátozások:

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

Kapsz egy bináris tömb számokat.
Egy tömb altömbje akkor jó, ha pontosan egy 1-es értékű elemet tartalmaz.
Adjon vissza egy egész számot, amely azt jelöli, hogy hány módon lehet a tömbszámokat jó altömbökre felosztani. Mivel a szám túl nagy lehet, adja vissza modulo 10^9 + 7 értékkel.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [0,1,0,0,1]
Kimenet: 3
Magyarázat: Háromféleképpen lehet számokat felosztani jó altömbökre:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

2. példa:

Bemenet: nums = [0,1,0]
Kimenet: 1
Magyarázat: Egyféleképpen lehet számokat felosztani jó altömbökre:
- [0,1,0]

Korlátozások:

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

Bináris tömb numokat kap.
A tömb altömbje akkor jó, ha pontosan egy elemet tartalmaz 1 értékkel.
Egy egész számot ad vissza, amely a tömb számainak jó résztömbökre való felosztásának számos módját jelöli. Mivel a szám túl nagy lehet, adja vissza modulo 10^9 + 7.
A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [0,1,0,0,1]
Kimenet: 3
Magyarázat: 3 módja van annak, hogy a számokat jó résztömbökre oszthassuk:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

2. példa:

Bemenet: nums = [0,1,0]
Kimenet: 1
Magyarázat: 1 módon lehet a számokat jó résztömbökre osztani:
- [0,1,0]

Korlátok:

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


Kapsz egy 0-indexelt egész tömb számot. A számok egy altömbjét folytonosnak nevezzük, ha:

Legyenek i, i + 1, ..., j_ a részarray indexei. Ekkor minden i <= i_1, i_2 <= j index pár esetén teljesül, hogy 0 <= |nums[i_1] - nums[i_2]| <= 2.

Visszaadja a folytonos altömbök teljes számát.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

Példa 1:

Bemenet: nums = [5,4,2,4]
Kimenet: 8
Magyarázat:
1-es méretű folytonos altömb: [5], [4], [2], [4].
2-es méretű folytonos altömb: [5,4], [4,2], [2,4].
3-as méretű folytonos altömb: [4,2,4].
Nincsenek 4-es méretű alházak.
Összes folytonos altömb = 4 + 3 + 1 = 8.
Megmutatható, hogy nincsenek több folytonos altömbök.

Példa 2:

Bemenet: nums = [1,2,3]
Kimenet: 6
Magyarázat:
1-es méretű folytonos altömb: [1], [2], [3].
2-es méretű folytonos altömb: [1,2], [2,3].
3-as méretű folytonos altömb: [1,2,3].
Összes folytonos altömb = 3 + 2 + 1 = 6.

Korlátozások:

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

Kap egy 0 indexelt egész tömb számát. A számok egy résztömbjét folytonosnak nevezzük, ha:

Legyen i, i + 1, ..., j_ a résztömb indexei. Ezután minden i indexpárra <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

A folytonos résztömbök teljes számá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 = [5,4,2,4]
Kimenet: 8
Magyarázat:
1-es méretű folytonos résztömb: [5], [4], [2], [4].
2-es méretű folytonos résztömb: [5,4], [4,2], [2,4].
3-as méretű folytonos résztömb: [4,2,4].
Nincsenek 4-es méretű résztömbök.
Az összes folytonos résztömb száma: 4 + 3 + 1 = 8.
Kimutatható, hogy nincs több folytonos résztömb.

2. példa:

Bemenet: nums = [1,2,3]
Kimenet: 6
Magyarázat:
1-es méretű folytonos résztömb: [1], [2], [3].
2-es méretű folytonos résztömb: [1,2], [2,3].
3-as méretű folytonos résztömb: [1,2,3].
Összes folytonos résztömb = 3 + 2 + 1 = 6.

Korlátok:

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

Kapsz egy 0-indexelt egész tömb számot. A számok egy altömbjét folytonosnak nevezzük, ha:

Legyenek i, i + 1, ..., j_ az indexek az altömbben. Ezután minden indexpárhoz i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Visszaadja a folytonos altömbök teljes számát.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [5,4,2,4]
Kimenet: 8
Magyarázat:
1-es méretű folytonos altömb: [5], [4], [2], [4].
2-es méretű folytonos altömb: [5,4], [4,2], [2,4].
3-as méretű folytonos altömb: [4,2,4].
Nincsenek 4-es méretű alházak.
Összes folytonos altömb = 4 + 3 + 1 = 8.
Megmutatható, hogy nincsenek több folytonos altömbök.

2. példa:

Bemenet: nums = [1,2,3]
Kimenet: 6
Magyarázat:
1-es méretű folytonos altömb: [1], [2], [3].
2-es méretű folytonos altömb: [1,2], [2,3].
3-as méretű folytonos altömb: [1,2,3].
Összes folytonos altömb = 3 + 2 + 1 = 6.

Korlátozások:

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


Két 0 indexelt egész tömböt kap, nums1 és nums2 n hosszúságú.
Definiáljunk egy másik 0 indexelt egész tömböt, nums3, n hosszúsággal. A [0, n - 1] tartomány minden i indexéhez hozzárendelheti a nums1[i] vagy nums2[i] számot a nums3[i] számhoz.
Az Ön feladata, hogy maximalizálja a nums3 leghosszabb nem csökkenő résztömbjének hosszát az értékeinek optimális kiválasztásával.
Egy egész számot ad eredményül, amely a leghosszabb nem csökkenő résztömb hosszát adja vissza a nums3 számban.
Megjegyzés: A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums1 = [2,3,1], nums2 = [1,2,1]
Kimenet: 2
Magyarázat: A nums3 felépítésének egyik módja:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
A 0 indextől kezdődő és az 1. indexnél végződő [2,2] résztömb egy 2 hosszúságú, nem csökkenő résztömböt alkot.
Megmutathatjuk, hogy 2 a maximálisan elérhető hossz.
2. példa:

Bemenet: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Kimenet: 4
Magyarázat: A nums3 felépítésének egyik módja:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
A teljes tömb egy nem csökkenő 4-es hosszúságú résztömböt alkot, így ez a maximálisan elérhető hossz.

3. példa:

Bemenet: nums1 = [1,1], nums2 = [2,2]
Kimenet: 2
Magyarázat: A nums3 felépítésének egyik módja:
nums3 = [nums1[0], nums1[1]] => [1,1].
A teljes tömb egy nem csökkenő 2 hosszúságú résztömböt alkot, így ez a maximálisan elérhető hossz.

Korlátok:

1 <= nums1.length == nums2.length == n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9

Két 0-indextől induló egész számokból álló tömböt kapsz, nums1 és nums2, amelyek hossza n.
Definiáljunk egy másik, n hosszúságú 0-indexelt egész tömböt, a nums3-at. A [0, n - 1] tartományban lévő minden i indexhez hozzárendelheti a nums1[i] vagy a nums2[i] értéket a nums3[i] értékhez.
Az Ön feladata, hogy maximalizálja a leghosszabb, nem csökkenő altömb hosszát nums3-ban az értékeinek optimális megválasztásával.
Egy egész számot ad vissza, amely a leghosszabb, nem csökkenő résztömb hosszát reprezentálja számokban3.
Megjegyzés: Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums1 = [2,3,1], nums2 = [1,2,1]
Kimenet: 2
Magyarázat: Az egyik módja a nums3 kialakításának:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
A 0 indextől kezdődő és az 1-es indexre végződő altömb [2,2] egy 2 hosszúságú, nem csökkenő altömböt alkot.
Megmutathatjuk, hogy 2 a maximális elérhető hossz.
2. példa:

Bemenet: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Kimenet: 4
Magyarázat: Az egyik módja a nums3 kialakításának:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
A teljes tömb egy 4-es hosszúságú, nem csökkenő altömböt alkot, így ez a maximális elérhető hosszúság.

3. példa:

Bemenet: nums1 = [1,1], nums2 = [2,2]
Kimenet: 2
Magyarázat: Az egyik módja a nums3 kialakításának:
nums3 = [nums1[0], nums1[1]] => [1,1].
A teljes tömb egy 2-es hosszúságú, nem csökkenő altömböt alkot, így ez a maximális elérhető hosszúság.

Korlátozások:

1 <= nums1.length == nums2.length == n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9


Kap egy 0 indexelt egész tömb numsát. Egy m hosszúságú s résztömböt váltakozónak nevezünk, ha:

m nagyobb, mint 1.
s_1 = s_0 + 1.
A 0 indexelt s résztömb így néz ki: [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Más szóval, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, és így tovább s[m - 1] - s[m - 2] = (-1)^m.

Az összes váltakozó résztömb maximális hosszát adja vissza numsban vagy -1-ben, ha ilyen résztömb nem létezik.
A résztömb egy folytonos, nem üres elem-sorozat a tömbben.

1. példa:

Bemenet: nums = [2,3,4,3,4]
Kimenet: 4
Magyarázat: A váltakozó résztömbök: [3,4], [3,4,3] és [3,4,3,4]. Ezek közül a leghosszabb a [3,4,3,4], amely 4 hosszú.

2. példa:

Bemenet: nums = [4,5,6]
Kimenet: 2
Magyarázat: A [4,5] és az [5,6] az egyetlen két váltakozó résztömb. Mindkettő 2 hosszú.

Korlátok:

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

Kapsz egy 0-indexelt egész tömb számot. Az m hosszúságú s résztömböt váltakozónak nevezzük, ha:

m nagyobb, mint 1.
s_1 = s_0 + 1.
A 0-indexelt s altömb így néz ki: [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Más szavakkal, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, és így tovább s[m - 1] - s[m - 2] = ( -1)^m.

Visszaadja az összes jelenlévő alternáló altömb maximális hosszát számokban vagy -1-ben, ha nem létezik ilyen altömb.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [2,3,4,3,4]
Kimenet: 4
Magyarázat: A váltakozó altömbök a következők: [3,4], [3,4,3] és [3,4,3,4]. Ezek közül a leghosszabb a [3,4,3,4], amely 4 hosszúságú.

2. példa:

Bemenet: nums = [4,5,6]
Kimenet: 2
Magyarázat: A [4,5] és az [5,6] az egyetlen két váltakozó altömb. Mindkettő 2-es hosszúságú.

Korlátozások:

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


Adott egy 0-indexelt nums tömb, amely pozitív egész számokat tartalmaz. Az alábbi műveletet végezhetjük el a tömbön tetszőleges számban:

Válasszunk egy i egész számot úgy, hogy 0 <= i < nums.length - 1 és nums[i] <= nums[i + 1]. Cseréljük le a nums[i + 1] elemet a nums[i] + nums[i + 1] értékre, és töröljük a nums[i] elemet a tömbből.

Adjuk vissza a legnagyobb elem értékét, amelyet a végső tömbben elérhetünk.

1. példa:

Bemenet: nums = [2,3,7,9,3]
Kimenet: 21
Magyarázat: Az alábbi műveleteket alkalmazhatjuk a tömbön:
- Válasszuk i = 0. Az eredményül kapott tömb nums = [5,7,9,3].
- Válasszuk i = 1. Az eredményül kapott tömb nums = [5,16,3].
- Válasszuk i = 0. Az eredményül kapott tömb nums = [21,3].
A végső tömb legnagyobb eleme 21. Megmutatható, hogy ennél nagyobb elemet nem tudunk elérni.

2. példa:

Bemenet: nums = [5,3,3]
Kimenet: 11
Magyarázat: Az alábbi műveleteket végezhetjük el a tömbön:
- Válasszuk i = 1. Az eredményül kapott tömb nums = [5,6].
- Válasszuk i = 0. Az eredményül kapott tömb nums = [11].
Csak egyetlen elem van a végső tömbben, ami 11.

Korlátozások:

1 <= 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 következő műveletet tetszőleges számú alkalommal elvégezheti a tömbön:

Válasszon egy i egész számot úgy, hogy 0 <= i < nums.length - 1 és nums[i] <= nums[i + 1]. Cserélje ki a nums[i + 1] elemet nums[i] + nums[i + 1] elemre, és törölje a nums[i] elemet a tömbből.

A végső tömbben elérhető legnagyobb elem értékét adja eredményül.

1. példa:

Bemenet:nums = [2,3,7,9,3]
Kimenet: 21
Magyarázat: A következő műveleteket alkalmazhatjuk a tömbön:
- Válassza az i = 0 lehetőséget. Az eredményül kapott tömb nums = [5,7,9,3] lesz.
- Válassza az i = 1 lehetőséget. Az eredményül kapott tömb nums = [5,16,3] lesz.
- Válassza az i = 0 lehetőséget. Az eredményül kapott tömb nums = [21,3] lesz.
A végső tömb legnagyobb eleme 21. Kimutatható, hogy nem kaphatunk nagyobb elemet.

2. példa:

Bemenet: nums = [5,3,3]
Kimenet: 11
Magyarázat: A következő műveleteket hajthatjuk végre a tömbön:
- Válassza az i = 1 lehetőséget. Az eredményül kapott tömb nums = [5,6] lesz.
- Válassza az i = 0 lehetőséget. Az eredményül kapott tömb nums = [11] lesz.
A végső tömbben csak egy elem van, ami 11.

Korlátok:

1 <= 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 következő műveletet tetszőleges számú alkalommal elvégezheti a tömbön:

Válasszon egy i egész számot úgy, hogy 0 <= i < nums.length - 1 és nums[i] <= nums[i + 1]. Cserélje ki a nums[i + 1] elemet nums[i] + nums[i + 1] elemre, és törölje a nums[i] elemet a tömbből.

A végső tömbben elérhető legnagyobb elem értékét adja eredményül.

1. példa:

Bemenet: nums = [2,3,7,9,3]
Kimenet: 21
Magyarázat: A következő műveleteket alkalmazhatjuk a tömbön:
- Válassza az i = 0 lehetőséget. Az eredményül kapott tömb nums = [5,7,9,3] lesz.
- Válassza az i = 1 lehetőséget. Az eredményül kapott tömb nums = [5,16,3] lesz.
- Válassza az i = 0 lehetőséget. Az eredményül kapott tömb nums = [21,3] lesz.
A végső tömb legnagyobb eleme 21. Kimutatható, hogy nem kaphatunk nagyobb elemet.

2. példa:

Bemenet: nums = [5,3,3]
Kimenet: 11
Magyarázat: A következő műveleteket hajthatjuk végre a tömbön:
- Válassza az i = 1 lehetőséget. Az eredményül kapott tömb nums = [5,6] lesz.
- Válassza az i = 0 lehetőséget. Az eredményül kapott tömb nums = [11] lesz.
A végső tömbben csak egy elem van, ami 11.

Korlátok:

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


Van egy n egész szám. Két egész számot, x és y, prímszámpárnak nevezünk, ha:

1 <= x <= y <= n
x + y == n
x és y prímek

Add vissza a prímszámpárok [x_i, y_i] 2D rendezett listáját. A listát x_i növekvő sorrendjében kell rendezni. Ha egyáltalán nincsenek prímszámpárok, add vissza egy üres tömböt.
Megjegyzés: A prímszám egy 1-nél nagyobb természetes szám, amelynek csak két osztója van: önmaga és 1.

Példa 1:

Bemenet: n = 10
Kimenet: [[3,7],[5,5]]
Magyarázat: Ebben a példában két prím pár létezik, amelyek kielégítik a kritériumokat.
Ezek a párok [3,7] és [5,5], és visszaadjuk őket a feladatleírásban meghatározott sorrendben.

Példa 2:

Bemenet: n = 2
Kimenet: []
Magyarázat: Megmutathatjuk, hogy nincs olyan prímszámpár, amelynek összege 2, ezért egy üres tömböt adunk vissza.

Korlátozások:

1 <= n <= 10^6

Egy n egész számot kapsz. Azt mondjuk, hogy két x és y egész szám prímszámpárt alkot, ha:

1 <= x <= y <= n
x + y == n
x és y prímszámok

Visszaadja a prímszámpárok 2D-ben rendezett listáját [x_i, y_i]. A listát x_i növekvő sorrendbe kell rendezni. Ha egyáltalán nincsenek prímszámpárok, adjon vissza egy üres tömböt.
Megjegyzés: A prímszám olyan természetes szám, amely 1-nél nagyobb, csak két tényezővel, önmagával és 1-gyel.

1. példa:

Bemenet: n = 10
Kimenet: [[3,7],[5,5]]
Magyarázat: Ebben a példában két prímpár van, amely megfelel a feltételeknek.
Ezek a párok a [3,7] és az [5,5], és a problémafelvetésben leírt rendezett sorrendben adjuk vissza őket.

2. példa:

Bemenet: n = 2
Kimenet: []
Magyarázat: Megmutathatjuk, hogy nincs olyan prímszámpár, amely 2-t adna, ezért üres tömböt adunk vissza.

Korlátozások:

1 <= n <= 10^6

Kap egy egész n számot. Azt mondjuk, hogy két x és y egész szám prímszámpárt alkot, ha:

1 < = x <= y <= n
x + y == n
x és y prímszámok

A prímszámpárok 2D rendezett listájának visszaadása [x_i, y_i]. A listát növekvő sorrendbe kell rendezni x_i. Ha egyáltalán nincsenek prímszámpárok, adjon vissza egy üres tömböt.
Megjegyzés: A prímszám egy 1-nél nagyobb természetes szám, amely csak két tényezővel rendelkezik, önmagával és 1-gyel.

1. példa:

Bemenet: n = 10
Kimenet: [[3,7],[5,5]]
Magyarázat: Ebben a példában két prímpár felel meg a feltételeknek.
Ezek a párok [3,7] és [5,5], és a problémanyilatkozatban leírt rendezett sorrendben adjuk vissza őket.

2. példa:

Bemenet: n = 2
Kimenet: []
Magyarázat: Megmutathatjuk, hogy nincs olyan prímszámpár, amely 2 összeget adna, ezért üres tömböt adunk vissza.

Korlátok:

1 <= n <= 10^6


Egy vállalatnak n alkalmazottja van, számozásuk 0-tól n-1-ig terjed. Minden i alkalmazott órát[i] órát dolgozott a vállalatnál.
A vállalat megköveteli minden alkalmazotttól, hogy legalább célórát dolgozzon.
Kapsz egy 0-indexelt, n hosszú, nem negatív egész számokból álló tömböt, és egy nem negatív egész számot.
Adja vissza azt az egész számot, amely azon alkalmazottak számát jelöli, akik legalább célórát dolgoztak.

1. példa:

Bevitel: hours = [0,1,2,3,4], target = 2
Kimenet: 3
Magyarázat: A vállalat azt szeretné, ha minden alkalmazott legalább 2 órát dolgozna.
- A 0 alkalmazott 0 órát dolgozott, és nem érte el a kitűzött célt.
- Az 1. alkalmazott 1 órát dolgozott, és nem érte el a kitűzött célt.
- A 2. alkalmazott 2 órát dolgozott és teljesítette a célt.
- A 3. alkalmazott 3 órát dolgozott és teljesítette a célt.
- A 4. alkalmazott 4 órát dolgozott és teljesítette a célt.
3 alkalmazott teljesítette a célt.

2. példa:

Bevitel: hours = [5,1,4,2,2], target = 6
Kimenet: 0
Magyarázat: A vállalat azt szeretné, ha minden alkalmazott legalább 6 órát dolgozna.
0 alkalmazott teljesítette a célt.

Korlátozások:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

Egy vállalatnak n alkalmazottja van, számozásuk 0-tól n-1-ig terjed. Minden i alkalmazott órát[i] órát dolgozott a vállalatnál.
A vállalat megköveteli minden alkalmazotttól, hogy legalább célórát dolgozzon.
Kapsz egy 0-indexelt, n hosszú, nem negatív egész számokból álló tömböt, és egy nem negatív egész számot.
Adja vissza a legalább célórát ledolgozott alkalmazottak számát jelölő egész számot.

Példa 1:

Bevitel: hours = [0,1,2,3,4], target = 2
Kimenet: 3
Magyarázat: A vállalat azt szeretné, ha minden alkalmazott legalább 2 órát dolgozna.
- A 0 alkalmazott 0 órát dolgozott, és nem érte el a kitűzött célt.
- Az 1. alkalmazott 1 órát dolgozott, és nem érte el a kitűzött célt.
- A 2. alkalmazott 2 órát dolgozott és teljesítette a célt.
- A 3. alkalmazott 3 órát dolgozott és teljesítette a célt.
- A 4. alkalmazott 4 órát dolgozott és teljesítette a célt.
3 alkalmazott teljesítette a célt.

Példa 2:

Bevitel: hours = [5,1,4,2,2], target = 6
Kimenet: 0
Magyarázat: A vállalat azt szeretné, ha minden alkalmazott legalább 6 órát dolgozna.
0 alkalmazott teljesítette a célt.

Korlátozások:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

Egy vállalatban n alkalmazott van, 0-tól n - 1-ig számozva. Minden alkalmazott órákat dolgozott a vállalatnál.
A vállalat megköveteli, hogy minden alkalmazott legalább célórákban dolgozzon.
Kap egy 0-indexelt tömböt n hosszúságú nem negatív egész számokból és egy nem negatív egész célt.
Adja vissza az egész számot, amely azon alkalmazottak számát jelöli, akik legalább célórákat dolgoztak.

1. példa:

Bemenet: hours = [0,1,2,3,4], target = 2
Kimenet: 3
Magyarázat: A vállalat azt akarja, hogy minden alkalmazott legalább 2 órát dolgozzon.
- A 0. alkalmazott 0 órát dolgozott, és nem érte el a célt.
- Az 1. alkalmazott 1 órát dolgozott, és nem érte el a célt.
- A 2. alkalmazott 2 órát dolgozott, és teljesítette a célt.
- A 3. alkalmazott 3 órát dolgozott, és teljesítette a célt.
- A 4. alkalmazott 4 órát dolgozott és teljesítette a célt.
3 alkalmazott teljesítette a célt.

2. példa:

Bemenet: hours = [5,1,4,2,2], target = 6
Kimenet: 0
Magyarázat: A vállalat azt akarja, hogy minden alkalmazott legalább 6 órát dolgozzon.
0 alkalmazott teljesítette a célt.

Korlátok:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5


Három a, b és c karakterlánc esetén a feladat egy olyan karakterlánc keresése, amely minimális hosszúságú, és mindhárom karakterláncot részsztringként tartalmazza.
Ha több ilyen karakterlánc van, adja vissza a lexikográfiailag legkisebbet.
A problémára adott választ jelző karakterláncot ad vissza.
Notes

Az a karakterlánc lexikográfiailag kisebb, mint egy b karakterlánc (azonos hosszúságú), ha az első pozícióban, ahol a és b különbözik, az a karakterláncnak van egy betűje, amely korábban jelenik meg az ábécében, mint a b megfelelő betűje.
A részkarakterlánc karakterek összefüggő sorozata egy karakterláncon belül.

1. példa:

Bemenet: a = "abc", b = "bca", c = "aaa"
Kimenet: "aaabca"
Magyarázat: Megmutatjuk, hogy az "aaabca" tartalmazza az összes megadott karakterláncot: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Megmutatható, hogy a kapott karakterlánc hossza legalább 6 lenne, és az "aaabca" lexikográfiailag a legkisebb.
2. példa:

Bemenet: a = "ab", b = "ba", c = "aba"
Kimenet: "aba"
Magyarázat: Megmutatjuk, hogy az "aba" karakterlánc tartalmazza az összes megadott karakterláncot: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Mivel c hossza 3, az eredményül kapott karakterlánc hossza legalább 3 lenne. Megmutatható, hogy az "aba" a lexikográfiailag legkisebb.

Korlátok:

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

Adott három karakterlánc a, b és c, az a feladatunk, hogy találjunk egy olyan karakterláncot, amelyik a minimális hosszúságú, és mindhárom karakterláncot részkarakterláncként tartalmazza.
Ha több ilyen karakterlánc van, adja vissza a lexikográfiailag legkisebbet.
Adjon vissza egy karakterláncot, amely a problémára adott választ jelöli.
Megjegyzések

Az a karakterlánc lexikográfiailag kisebb, mint egy b karakterlánc (ugyanolyan hosszú), ha az első helyen, ahol a és b különbözik, az a karakterláncnak van egy olyan betűje, amely korábban jelenik meg az ábécében, mint a b megfelelő betűje.
A részkarakterlánc egy karakterláncon belüli összefüggő karaktersorozat.

Példa 1:

Bemenet: a = "abc", b = "bca", c = "aaa"
Kimenet: "aaabca"
Magyarázat: Megmutatjuk, hogy az "aaabca" tartalmazza az összes megadott karakterláncot: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Megmutatható, hogy a kapott karakterlánc hossza legalább 6, és az "aaabca" a lexikográfiailag legkisebb.
Példa 2:

Bemenet: a = "ab", b = "ba", c = "aba"
Kimenet: "aba"
Magyarázat: Megmutatjuk, hogy az "aba" karakterlánc tartalmazza az összes megadott karakterláncot: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Mivel c hossza 3, a kapott karakterlánc hossza legalább 3. Megmutatható, hogy az "aba" a szótárilag legkisebb.

Korlátozások:

1 <= a.length, b.length, c.length <= 100
a, b, c csak kisbetűket tartalmaz angolul.

Három a, b és c karakterlánc esetén a feladat egy olyan karakterlánc keresése, amely minimális hosszúságú, és mindhárom karakterláncot részsztringként tartalmazza.
Ha több ilyen karakterlánc van, adja vissza a lexikográfiailag legkisebbet.
A problémára adott választ jelző karakterláncot ad vissza.
Notes

Az a karakterlánc lexikográfiailag kisebb, mint egy b karakterlánc (azonos hosszúságú), ha az első pozícióban, ahol a és b különbözik, az a karakterláncnak van egy betűje, amely korábban jelenik meg az ábécében, mint a b megfelelő betűje.
A részkarakterlánc karakterek összefüggő sorozata egy karakterláncon belül.

1. példa:

Bemenet: a = "abc", b = "bca", c = "aaa"
Kimenet: "aaabca"
Magyarázat: Megmutatjuk, hogy az "aaabca" tartalmazza az összes megadott karakterláncot: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Megmutatható, hogy a kapott karakterlánc hossza legalább 6 lenne, és az "aaabca" lexikográfiailag a legkisebb.
2. példa:

Bemenet: a = "ab", b = "ba", c = "aba"
Kimenet: "aba"
Magyarázat: Megmutatjuk, hogy az "aba" karakterlánc tartalmazza az összes megadott karakterláncot: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Mivel c hossza 3, az eredményül kapott karakterlánc hossza legalább 3 lenne. Megmutatható, hogy az "aba" a lexikográfiailag legkisebb.

Korlátok:

1 < = a.hossz, b.hossz, c.hossz <= 100
a, b, c csak kisbetűs angol betűkből áll.


Adott egy 0-indexált egész szám tömb nums és egy pozitív egész szám k.
A tömbön tetszőleges számúszor alkalmazhatjuk a következő műveletet:

Válasszuk ki a tömb bármelyik k méretű altömbjét, és csökkentsük az összes elemét 1-gyel.

Adjon vissza true-t, ha a tömb minden elemét 0-val egyenlővé tudja tenni, vagy false-t, ha nem.
Az altömb egy tömb összefüggő, nem üres része.

Példa 1:

Bemenet: nums = [2,2,3,1,1,0], k = 3
Kimenet: true
Magyarázat: A következő műveleteket tudjuk elvégezni:
- Válasszuk ki a [2,2,3] résztömböt. A kapott tömb a nums = [1,1,2,1,1,0] lesz.
- Válasszuk ki a [2,1,1] altömböt. A kapott tömb a következő lesz: nums = [1,1,1,0,0,0].
- Válasszuk ki a [1,1,1] altömböt. A kapott tömb a következő lesz: nums =[0,0,0,0,0,0].

Példa 2:

Bemenet: nums = [1,3,1,1], k = 2
Kimenet: false
Magyarázat: Nem lehetséges, hogy a tömb minden eleme 0 legyen.

Korlátozások:

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

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 alkalmazhatja a tömbön:

Válasszon ki egy tetszőleges k méretű altömböt a tömbből, és csökkentse az összes elemét 1-gyel.

Igaz értéket ad vissza, ha a tömb összes elemét egyenlővé tudja tenni 0-val, vagy hamis értékkel tér vissza.
Az altömb egy tömb összefüggő, nem üres része.

1. példa:

Bemenet: nums  = [2,2,3,1,1,0], k = 3
Kimenet: igaz
Magyarázat: A következő műveleteket tudjuk elvégezni:
- Válassza ki az altömböt [2,2,3]. Az eredményül kapott tömb a következő lesz: nums = [1,1,2,1,1,0].
- Válassza ki az altömböt [2,1,1]. Az eredményül kapott tömb a következő lesz: nums = [1,1,1,0,0,0].
- Válassza ki az altömböt [1,1,1]. Az eredményül kapott tömb a következő lesz: nums = [0,0,0,0,0,0].

2. példa:

Bemenet: nums = [1,3,1,1], k = 2
Kimenet: hamis
Magyarázat: Nem lehet minden tömbelemet 0-val egyenlővé tenni.

Korlátozások:

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

Adott egy nullától indexelt egész számokat tartalmazó tömb, a nums, és egy pozitív egész k.
A következő műveletet tetszőleges számú alkalommal alkalmazhatja a tömbön:

Válasszon ki egy tetszőleges k méretű altömböt a tömbből, és csökkentse az összes elemét 1-gyel.

Igaz értéket ad vissza, ha a tömb összes elemét egyenlővé tudja tenni 0-val, vagy hamis értékkel tér vissza.
Az altömb egy tömb összefüggő, nem üres része.

1. példa:

Bemenet: nums = [2,2,3,1,1,0], k = 3
Kimenet: true
Magyarázat: A következő műveleteket tudjuk elvégezni:
- Válassza ki az altömböt [2,2,3]. Az eredményül kapott tömb a következő lesz: nums = [1,1,2,1,1,0].
- Válassza ki az altömböt [2,1,1]. Az eredményül kapott tömb a következő lesz: nums = [1,1,1,0,0,0].
- Válassza ki az altömböt [1,1,1]. Az eredményül kapott tömb a következő lesz: nums = [0,0,0,0,0,0].

2. példa:

Bemenet: nums = [1,3,1,1], k = 2
Kimenet: hamis
Magyarázat: Nem lehet minden tömbelemet 0-val egyenlővé tenni.

Korlátozások:

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


Adott egy s karakterlánc és egy k egész szám, az s-t k részstringre kell felosztani úgy, hogy az egyes részkarakterláncok félpalindrommá alakításához szükséges betűváltozások számának összege minimális legyen.
Egy egész számot ad vissza, amely a szükséges betűmódosítások minimális számát jelöli.
Megjegyzések

Egy karakterlánc akkor palindrom, ha ugyanúgy olvasható balról jobbra és jobbról balra.
A len hosszúságú karakterláncot félpalindromnak tekintjük, ha létezik olyan d pozitív egész szám, amelyre 1 <= d < len és len % d == 0, és ha olyan indexeket veszünk, amelyeknek d-nek a modulója azonos, akkor palindromot alkotnak. Például az „aa”, „aba”, „adbgad” és „abab” félpalindrom, az „a”, „ab” és „abca” pedig nem.
A részkarakterlánc egy karakterláncon belüli összefüggő karaktersorozat.

Példa 1:

Bemenet: s = "abcac", k = 2
Kimenet: 1
Magyarázat: Az s-t feloszthatjuk "ab" és "cac" részkarakterláncra. A "cac" karakterlánc már félpalindrom. Ha az "ab"-t "aa"-ra változtatjuk, akkor félpalindrommá válik, ahol d = 1.
Kimutatható, hogy az "abcac" karakterláncot nem lehet két félpalindrom részstringre osztani. Ezért a válasz legalább 1.
Példa 2:

Bemenet: s = "abcdef", k = 2
Kimenet: 2
Magyarázat: Feloszthatjuk "abc" és "def" részkarakterláncra. Az "abc" és a "def" részkarakterláncok mindegyike egy változtatást igényel, hogy félpalindrommá váljon, tehát összesen 2 változtatásra van szükség ahhoz, hogy az összes részstringet félpalindrommá tegyük.
Megmutatható, hogy az adott karakterláncot nem tudjuk úgy két részstringre felosztani, hogy az 2-nél kevesebb változtatást igényelne.
Példa 3:

Bemenet: s = "aabbaa", k = 3
Kimenet: 0
Magyarázat: Feloszthatjuk "aa", "bb" és "aa" részkarakterláncokra.
Az "aa" és "bb" karakterláncok már félig palindromok. Így a válasz nulla.

Korlátozások:

2 <= s.length <= 200
1 <= k <= s.length / 2
s csak kis angol betűkből áll.

Adott egy s karakterlánc és egy k egész szám, osszuk fel az s-t k részláncra úgy, hogy az egyes részláncok fél-palindrómává alakításához szükséges betűváltások összege minimális legyen.
Adjon vissza egy egész számot, amely a szükséges betűváltások minimális számát jelöli.
Megjegyzések

Egy karakterlánc akkor palindrom, ha balról jobbra és jobbról balra ugyanúgy olvasható.
Egy len hosszúságú húr akkor tekinthető félpalindromnak, ha létezik olyan d pozitív egész szám, hogy 1 <= d < len és len % d == 0, és ha olyan indexeket veszünk, amelyek d-vel azonos modulóval rendelkeznek, akkor palindromot alkotnak. Például az "aa", "aba", "adbgad" és "abab" félig palindrom, az "a", "ab" és "abca" pedig nem.
A részlánc a karakterláncban lévő karakterek összefüggő sorozata.

1. példa:

Bemenet: s = "abcac", k = 2
Kimenet: 1
Magyarázat: Az s-t "ab" és "cac" részsztringekre oszthatjuk. A "cac" karakterlánc már félig palindrom. Ha az "ab" -ot "aa" -ra változtatjuk, akkor d = 1 félpalindrommá válik.
Megmutatható, hogy nincs mód arra, hogy az "abcac" karakterláncot két félig palindrom részhúrra osztjuk. Ezért a válasz legalább 1 lenne.
2. példa:

Bemenet: s ="abcdef", k = 2
Kimenet: 2
Magyarázat: Feloszthatjuk "abc" és "def" részsztringekre. Az "abc" és "def" alsztringek mindegyike egy változtatást igényel ahhoz, hogy félpalindrommá váljon, tehát összesen 2 változtatásra van szükségünk ahhoz, hogy az összes részkarakterlánc félig palindrom legyen.
Megmutatható, hogy az adott karakterláncot nem tudjuk úgy felosztani két részstringre, hogy az 2-nél kevesebb változtatást igényelne.
3. példa:

Bemenet: s ="aabbaa", k = 3
Kimenet: 0
Magyarázat: Feloszthatjuk "aa", "bb" és "aa" részsztringekre.
Az "aa" és "bb" húrok már félig palindromok. Így a válasz nulla.

Korlátozások:

2 <= s.length <= 200
1 <= k <= s.length / 2
s csak kisbetűs angol betűkből áll.

Adott egy s karakterlánc és egy k egész szám, az s-t k részstringre kell felosztani úgy, hogy az egyes részkarakterláncok félpalindrommá alakításához szükséges betűváltozások számának összege minimális legyen.
Egy egész számot ad vissza, amely a szükséges betűmódosítások minimális számát jelöli.
Megjegyzések

Egy karakterlánc akkor palindrom, ha ugyanúgy olvasható balról jobbra és jobbról balra.
A len hosszúságú karakterláncot félpalindromnak tekintjük, ha létezik olyan d pozitív egész szám, amelyre 1 <= d < len és len % d == 0, és ha olyan indexeket veszünk, amelyeknek d-nek a modulója azonos, akkor palindromot alkotnak. Például az „aa”, „aba”, „adbgad” és „abab” félpalindrom, az „a”, „ab” és „abca” pedig nem.
A részkarakterlánc egy karakterláncon belüli összefüggő karaktersorozat.

1. példa:

Bemenet: s = "abcac", k = 2
Kimenet: 1
Magyarázat: Az s-t feloszthatjuk "ab" és "cac" részkarakterláncra. A "cac" karakterlánc már félpalindrom. Ha az "ab"-t "aa"-ra változtatjuk, akkor félpalindrommá válik, ahol d = 1.
Kimutatható, hogy az "abcac" karakterláncot nem lehet két félpalindrom részstringre osztani. Ezért a válasz legalább 1.
2. példa:

Bemenet: s = "abcdef", k = 2
Kimenet: 2
Magyarázat: Feloszthatjuk "abc" és "def" részkarakterláncokra. Az "abc" és a "def" részkarakterláncok mindegyike egy változtatást igényel, hogy félpalindrommá váljon, tehát összesen 2 változtatásra van szükség ahhoz, hogy az összes részstringet félpalindrommá tegyük.
Megmutatható, hogy az adott karakterláncot nem tudjuk úgy két részstringre felosztani, hogy az 2-nél kevesebb változtatást igényelne.
3. példa:

Bemenet: s = "aabbaa", k = 3
Kimenet: 0
Magyarázat: Feloszthatjuk "aa", "bb" és "aa" részkarakterláncokra.
Az "aa" és "bb" karakterláncok már félig palindromok. Így a válasz nulla.

Korlátozások:

2 <= s.length <= 200
1 <= k <= s.length / 2
s csak kis angol betűkből áll.


Adott egy sor karakterlánc-szavat és egy karakterelválasztót, ossza fel az egyes karakterláncokat szavakra elválasztónként.
A felosztás után létrejött új karakterláncokat tartalmazó karakterláncok tömbjét adja vissza, az üres karakterláncok kivételével.
Megjegyzések

Az elválasztót annak meghatározására használják, hogy hol történjen a felosztás, de ez nem szerepel a kapott karakterláncok részeként.
Egy felosztás kettőnél több karakterláncot eredményezhet.
Az eredményül kapott karakterláncoknak ugyanazt a sorrendet kell megőrizniük, mint amit eredetileg megadtak.

1. példa:

Bevitel: words = ["one.two.three","four.five","six"], elválasztó = "."
Kimenet: ["egy", "kettő", "három", "négy", "öt", "hat"]
Magyarázat: Ebben a példában a következőképpen osztjuk fel:

Az "one.two.three" "egy", "kettő", "három" részre oszlik
A „four.five” „négy”, „öt” részre oszlik
a "hat" "hat"-ra oszlik

Ezért az eredményül kapott tömb ["egy", "kettő", "három", "négy", "öt", "hat"].
2. példa:

Bemenet: words = ["$easy$","$problem$"], separator = "$"
Kimenet: ["könnyű", "probléma"]
Magyarázat: Ebben a példában a következőképpen osztjuk fel:

Az "$easy$" "easy"-re oszlik (kivéve az üres karakterláncokat)
A "$problem$" "probléma"-ra oszlik (kivéve az üres karakterláncokat)

Ezért az eredményül kapott tömb ["könnyű", "probléma"].

3. példa:

Bemenet: words = ["|||"], separator = "|"
Kimenet: []
Magyarázat: Ebben a példában a "|||" eredő felosztása csak üres karakterláncokat tartalmaz, ezért egy üres tömböt [] adunk vissza.

Korlátozások:

1 <= words.length <= 100
1 <= words[i].length <= 20
a words[i] szereplő karakterek vagy kisbetűk angol betűk, vagy a ".,|$#@" karakterlánc karakterei (az idézőjelek kivételével)
az elválasztó karakter a ".,|$#@" karakterláncból (az idézőjelek kivételével)

Adott egy szavakból álló sztringekből álló tömb és egy karakteres elválasztójel, osszuk fel az egyes sztringeket a szavakra az elválasztójel alapján.
Adjon vissza egy stringekből álló tömböt, amely tartalmazza a felosztás után keletkezett új stringeket, kivéve az üres stringeket.
Megjegyzések

A szeparátor annak meghatározására szolgál, hogy hol történjen az osztás, de nem része az eredményül kapott karakterláncoknak.
Egy osztás több mint két karakterláncot eredményezhet.
Az eredményül kapott karakterláncoknak ugyanazt a sorrendet kell megtartaniuk, mint amit eredetileg megadtak.

Példa 1:

Bemenet: words = ["one.two.three","four.five","six"], separator = "."
Kimenet:["one","two","three","four","five","six"]
Magyarázat: Ebben a példában a következőképpen osztunk:

Az "egy.kettő.három" "egy", "kettő", "három" részre oszlik
A "four.five" "négyre", "ötre" oszlik
A "hat" "hatra" oszlik

Ezért az eredményül kapott tömb ["egy", "kettő", "három", "négy", "öt", "hat"].
Példa 2:

Bemenet: words = ["$easy$","$problem$"], separator = "$"
Kimenet: ["easy","problem"]
Magyarázat: Ebben a példában a következőképpen osztunk:

A "$easy$" "egyszerűre" oszlik (kivéve az üres karakterláncokat)
A "$problem$" "problémára" oszlik (kivéve az üres karakterláncokat)

Ezért az eredményül kapott tömb ["könnyű","probléma"].

Példa 3:

Bemenet: words = ["|||"], separator = "|"
Kimenet: []
Magyarázat: Ebben a példában az eredményül kapott "|||" felosztás csak üres karakterláncokat tartalmaz, ezért üres tömböt adunk vissza [].

Korlátozások:

1 <= words.length <= 100
1 <= words[i].length <= 20
a words[i] karakterei vagy kisbetűs angol betűk, vagy a „.,|$#@” karakterlánc karakterei (idézőjelek nélkül).
a szeparátor a „.,|$#@” karakterlánc egyik karaktere (idézőjelek nélkül).

Adott egy sor karakterlánc, szó és egy karakterelválasztó, ossza fel az egyes karakterláncokat szavakra elválasztóval.
A felosztások után létrehozott új karakterláncokat tartalmazó karakterlánctömböt ad vissza, kivéve az üres karakterláncokat.
Notes

Az elválasztó segítségével meghatározható, hogy hol történjen a felosztás, de nem szerepel az eredményül kapott karakterláncok között.
A felosztás kettőnél több karakterláncot eredményezhet.
Az eredményül kapott sztringeknek meg kell őrizniük az eredetileg megadott sorrendet.

1. példa:

Bemenet: words = ["one.two.three","four.five","six"], separator = "."
Output: ["one","two","three","four","five","six"]

Magyarázat: Ebben a példában a következőképpen oszlunk meg:

Az "egy.kettő.három" "egy", "kettő", "három" részre oszlik
A "four.five" "négyre", "ötre" oszlik
A "hat" "hatra" oszlik

Ezért az eredményül kapott tömb ["egy", "kettő", "három", "négy", "öt", "hat"].
2. példa:

Bemenet: words = ["$easy$","$problem$"], separator = "$"
Output: ["easy","problem"]

Magyarázat: Ebben a példában a következőképpen oszlunk meg:

A "$easy$" "egyszerűre" oszlik (kivéve az üres karakterláncokat)
A "$problem$" "problémára" oszlik (kivéve az üres karakterláncokat)

Ezért az eredményül kapott tömb ["könnyű","probléma"].

3. példa:

Bemenet: words = ["|||"], separator = "|"
Kimenet: []
Magyarázat: Ebben a példában az eredményül kapott "|||" felosztás csak üres karakterláncokat tartalmaz, ezért üres tömböt adunk vissza [].

Korlátok:

1 <= words.length <= 100
1 <= words[i].length <= 20
a szavakban szereplő karakterek[i] kisbetűs angol betűk vagy a ".,|$#@" karakterlánc karakterei (kivéve az idézőjeleket)
Az elválasztó a ".,|$#@" karakterlánc karaktere (az idézőjelek kivételével)


Adott két pozitív egész szám, n és x.
Visszaadja, hogy n hány módon fejezhető ki egyedi pozitív egész számok x^-edik hatványának összegeként, más szóval az egyedi egész számok halmazainak száma [n_1, n_2, ..., n_k], ahol n = n_1^ x + n_2^x + ... + n_k^x.
Mivel az eredmény nagyon nagy lehet, adja vissza modulo 10^9 + 7.
Például, ha n = 160 és x = 3, akkor n kifejezésének egyik módja n = 2^3 + 3^3 + 5^3.

1. példa:

Bemenet: n = 10, x = 2
Kimenet: 1
Magyarázat: Az n-t a következőképpen fejezhetjük ki: n = 3^2 + 1^2 = 10.
Kimutatható, hogy ez az egyetlen módja annak, hogy a 10-et egyedi egész számok 2. hatványának összegeként fejezzük ki.

2. példa:

Bemenet: n = 4, x = 1
Kimenet: 2
Magyarázat: Az n-t a következő módokon fejezhetjük ki:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Korlátozások:

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

Adott két pozitív egész szám n és x.
Adja meg, hogy hányféleképpen fejezhető ki n az egyedi pozitív egész számok x^-edik hatványának összegeként, más szóval az egyedi egész számok [n_1, n_2, ..., n_k] halmazainak száma, ahol n = n_1^x + n_2^x + .... + n_k^x.
Mivel az eredmény nagyon nagy lehet, adja vissza modulo 10^9 + 7.
Például, ha n = 160 és x = 3, akkor az n egyik kifejezési módja n = 2^3 + 3^3 + 5^3.

Példa 1:

Bemenet: n = 10, x = 2
Kimenet: 1
Magyarázat: Az n-t a következőképpen fejezhetjük ki: n = 3^2 + 1^2 = 10.
Megmutatható, hogy csak így fejezhető ki a 10-es szám, mint a 2^. egész számok 2^. hatványának összege.

Példa 2:

Bemenet: n = 4, x = 1
Kimenet: 2
Magyarázat: A következő módokon fejezhetjük ki az n-t:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Kényszerek:

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


Adott egy s bináris karakterlánc, particionálja a karakterláncot egy vagy több részkarakterláncra úgy, hogy mindegyik részstring szép legyen.
Egy húr akkor szép, ha:

Nem tartalmaz kezdő nullákat.
Ez egy olyan szám bináris reprezentációja, amely 5 hatványa.

Adja vissza az ilyen partícióban található részkarakterláncok minimális számát. Ha lehetetlen particionálni az s karakterláncot gyönyörű részkarakterláncokra, adja vissza a -1 értéket.
A részkarakterlánc egy karakterláncban összefüggő karaktersorozat.

1. példa:

Bemenet: s = "1011"
Kimenet: 2
Magyarázat: A megadott karakterláncot particionálhatjuk a következőre: ["101", "1"].
- A "101" karakterlánc nem tartalmaz kezdő nullákat, és az 5^1 = 5 egész szám bináris reprezentációja.
- Az "1" karakterlánc nem tartalmaz kezdő nullákat, és az 5^0 = 1 egész szám bináris reprezentációja.
Megmutatható, hogy 2 a minimális számú gyönyörű részkarakterlánc, amelyre s particionálható.

2. példa:

Bemenet: s = "111"
Kimenet: 3
Magyarázat: A megadott karakterláncot particionálhatjuk ["1", "1", "1"]-re.
- Az "1" karakterlánc nem tartalmaz kezdő nullákat, és az 5^0 = 1 egész szám bináris reprezentációja.
Megmutatható, hogy 3 a minimális számú gyönyörű részkarakterlánc, amelyre s particionálható.

3. példa:

Bemenet: s = "0"
Kimenet: -1
Magyarázat: Az adott karakterláncot nem tudjuk szép alsztringekre particionálni.

Korlátozások:

1 <= s.length <= 15
s[i] is either '0' or '1'.

Adott egy s bináris karakterlánc, particionálja a karakterláncot egy vagy több részsztringre úgy, hogy minden részkarakterlánc gyönyörű legyen.
Egy karakterlánc akkor szép, ha:

Nem tartalmaz kezdő nullákat.
Ez egy szám bináris ábrázolása, amely az 5 hatványa.

Az ilyen partíció részsztringjeinek minimális számát adja vissza. Ha lehetetlen az s karakterláncot gyönyörű részsztringekre particionálni, adja vissza a -1 értéket.
A részkarakterlánc egy karakterlánc összefüggő karaktersorozata.

1. példa:

Bemenet: s = "1011"
Kimenet: 2
Magyarázat: Az adott karakterláncot ["101", "1"] -re parititálhatjuk.
- A "101" karakterlánc nem tartalmaz bevezető nullákat, és az 5^1 = 5 egész szám bináris ábrázolása.
- Az "1" karakterlánc nem tartalmaz bevezető nullákat, és az 5^0 = 1 egész szám bináris ábrázolása.
Megmutatható, hogy 2 a szép részkarakterláncok minimális száma, amelyekre s particionálható.

2. példa:

Bemenet: s = "111"
Kimenet: 3
Magyarázat: Az adott karakterláncot ["1", "1", "1"-re parititálhatjuk.
- Az "1" karakterlánc nem tartalmaz bevezető nullákat, és az 5^0 = 1 egész szám bináris ábrázolása.
Megmutatható, hogy 3 a minimális számú gyönyörű részsztring, amelyre s particionálható.

3. példa:

Bemenet: s = "0"
Kimenet: -1
Magyarázat: Nem oszthatjuk fel az adott karakterláncot gyönyörű részsztringekre.

Korlátok:

1 <= s.length <= 15
s[i] is either '0' or '1'.

Adott egy s bináris karakterlánc, particionálja a karakterláncot egy vagy több részkarakterláncra úgy, hogy mindegyik részstring szép legyen.
Egy húr akkor szép, ha:

Nem tartalmaz kezdő nullákat.
Ez egy olyan szám bináris reprezentációja, amely 5 hatványa.

Adja vissza az ilyen partícióban található részkarakterláncok minimális számát. Ha lehetetlen particionálni az s karakterláncot gyönyörű részkarakterláncokra, adja vissza a -1 értéket.
A részkarakterlánc egy karakterláncban összefüggő karaktersorozat.

1. példa:

Bemenet: s = "1011"
Kimenet: 2
Magyarázat: A megadott karakterláncot particionálhatjuk a következőre: ["101", "1"].
- A "101" karakterlánc nem tartalmaz kezdő nullákat, és az 5^1 = 5 egész szám bináris reprezentációja.
- Az "1" karakterlánc nem tartalmaz kezdő nullákat, és az 5^0 = 1 egész szám bináris reprezentációja.
Megmutatható, hogy 2 a minimális számú gyönyörű részkarakterlánc, amelyre s particionálható.

2. példa:

Bemenet: s = "111"
Kimenet: 3
Magyarázat: A megadott karakterláncot particionálhatjuk ["1", "1", "1"]-re.
- Az "1" karakterlánc nem tartalmaz kezdő nullákat, és az 5^0 = 1 egész szám bináris reprezentációja.
Megmutatható, hogy 3 a minimális számú gyönyörű részkarakterlánc, amelyre s particionálható.

3. példa:

Bemenet: s = "0"
Kimenet: -1
Magyarázat: Az adott karakterláncot nem tudjuk szép részkarakterláncokra particionálni.

Korlátozások:

1 <= s.length <= 15
s[i] '0' vagy '1'.


Kapsz egy karakterlánc szót és egy sor karakterláncot tiltva.
Egy karakterláncot érvényesnek nevezünk, ha egyik részkarakterlánca sem szerepel a forbidden mezőben.
A karakterlánc szó leghosszabb érvényes részkarakterláncának hosszát adja vissza.
A részkarakterlánc egy karakterlánc összefüggő sorozata, amely esetleg üres.

1. példa:

Bemenet: word= "cbaaaabc", forbidden = ["aaa","cb"]
Kimenet: 4
Magyarázat: A szóban 11 érvényes részkarakterlánc található: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" és "aabc". A leghosszabb érvényes részkarakterlánc hossza 4.
Megmutatható, hogy az összes többi részkarakterlánc tartalmazza az "aaa" vagy a "cb" karakterláncot.
2. példa:

Bemenet: word= "leetcode", forbidden = ["de","le","e"]
Kimenet: 4
Magyarázat: A szóban 11 érvényes részkarakterlánc található: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod", és "tcod". A leghosszabb érvényes részkarakterlánc hossza 4.
Megmutatható, hogy az összes többi részkarakterlánc tartalmazza a „de”, „le” vagy „e” karakterláncot.

Korlátozások:

1 <= word.length <= 10^5
word kizárólag kisbetűs angol betűkből áll.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] kizárólag kisbetűs angol betűkből áll.

Kapsz egy karakterláncot és egy sor karakterláncot, amelyek tiltottak.
Egy karakterlánc akkor minősül érvényesnek, ha egyik részkarakterlánca sincs jelen a tiltottban.
A karakterláncszó leghosszabb érvényes részkarakterláncának hosszát adja eredményül.
A részkarakterlánc egy karakterláncban található összefüggő karaktersorozat, amely lehet üres is.

1. példa:

Bemenet: word = "cbaaaabc", forbidden = ["aaa","cb"]
Kimenet: 4
Magyarázat: 11 érvényes alszöveg van a szóban: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" és "aabc". A leghosszabb érvényes részkarakterlánc hossza 4.
Megmutatható, hogy az összes többi alsztring tartalmazza az "aaa" vagy a "cb" karakterláncot részkarakterláncként.
2. példa:

Bemenet: word = "leetcode", forbidden = ["de","le","e"]
Kimenet: 4
Magyarázat: A szóban 11 érvényes részkarakterlánc van: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" és "tcod". A leghosszabb érvényes részkarakterlánc hossza 4.
Megmutatható, hogy az összes többi alsztring tartalmazza a "de", "le" vagy "e" részkarakterláncot.

Korlátok:

1 <= word.length <= 10^5
word consists only of lowercase English letters.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] csak kisbetűs angol betűkből áll.

Kapsz egy karakterlánc szót és egy sor karakterláncot tiltva.
Egy karakterláncot érvényesnek nevezünk, ha egyik részkarakterlánca sem szerepel a forbidden mezőben.
A karakterlánc szó leghosszabb érvényes részkarakterláncának hosszát adja vissza.
A részkarakterlánc egy karakterlánc összefüggő sorozata, amely esetleg üres.

1. példa:

Bemenet: word = "cbaaaabc", forbidden = ["aaa","cb"]
Kimenet: 4
Magyarázat: 11 érvényes részkarakterlánc van a word-ben: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" és "aabc". A leghosszabb érvényes részkarakterlánc hossza 4.
Kimutatható, hogy az összes többi részkarakterlánc tartalmazza vagy az "aaa" vagy a "cb" részkarakterláncot.
2. példa:

Bemenet: word = "leetcode", forbidden = ["de","le","e"]
Kimenet: 4
Magyarázat: 11 érvényes részkarakterlánc van a word-ben: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" és "tcod". A leghosszabb érvényes részkarakterlánc hossza 4.
Kimutatható, hogy az összes többi részkarakterlánc tartalmazza vagy a "de", vagy a "le", vagy az "e" részkarakterláncot.

Korlátozások:

1 <= word.length <= 10^5
word kizárólag kisbetűs angol betűkből áll.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] kizárólag kisbetűs angol betűkből áll.


A laptop billentyűzete hibás, és valahányszor beírsz rajta egy „i” karaktert, az megfordítja a leírt karakterláncot. Más karakterek beírása a várt módon működik.
Adott egy 0 indexű s karakterlánc, és a hibás billentyűzettel beírja az s minden egyes karakterét.
Visszaadja a végleges karakterláncot, amely a laptop képernyőjén jelenik meg.

Példa 1:

Bemenet: s = "string"
Kimenet: "rtsng"
Magyarázat:
Az első karakter beírása után a képernyőn megjelenő szöveg "s".
A második karakter után a szöveg "st".
A harmadik karakter után a szöveg "str".
Mivel a negyedik karakter "i", a szöveg megfordul, és "rts" lesz.
Az ötödik karakter után a szöveg "rtsn".
A hatodik karakter után a szöveg "rtsng".
Ezért visszatérünk az "rtsng" -hez.

Példa 2:

Bemenet: s = "poiinter"
Kimenet: "ponter"
Magyarázat:
Az első karakter után a képernyőn megjelenő szöveg "p".
A második karakter után a szöveg "po".
Mivel a harmadik beírt karakter "i", a szöveg megfordul, és "op" lesz.
Mivel a negyedik beírt karakter "i", a szöveg megfordul, és "po" lesz.
Az ötödik karakter után a szöveg "pon".
A hatodik karakter után a szöveg "pont".
A hetedik karakter után a szöveg "ponte".
A nyolcadik karakter után a szöveg "ponter".
Ezért visszatérünk "ponter".

Korlátozások:

1 <= s.length <= 100
s kisbetűs angol betűkből áll.
s[0] != 'i'

A laptop billentyűzete hibás, és amikor beír egy „i” karaktert, az megfordítja a beírt karakterláncot. Más karakterek beírása a várt módon működik.
Kapsz egy 0 indexű s karakterláncot, és minden s karaktert beírsz a hibás billentyűzeteddel.
Adja vissza az utolsó karakterláncot, amely jelen lesz a laptop képernyőjén.

Példa 1:

Bemenet: s = "string"
Kimenet: "rtsng"
Magyarázat:
Az első karakter beírása után a képernyőn megjelenő szöveg „s”.
A második karakter után a szöveg „st”.
A harmadik karakter után a szöveg „str”.
Mivel a negyedik karakter egy „i”, a szöveg megfordul és „rts” lesz.
Az ötödik karakter után a szöveg „rtsn”.
A hatodik karakter után a szöveg „rtsng”.
Ezért visszaadjuk az "rtsng"-t.

Példa 2:

Bemenet: s = "pointer"
Kimenet: "ponter"
Magyarázat:
Az első karakter után a képernyőn megjelenő szöveg „p”.
A második karakter után a szöveg „po”.
Mivel a harmadik beírt karakter egy „i”, a szöveg megfordul, és „op” lesz.
Mivel a negyedik beírt karakter egy „i”, a szöveg megfordul, és „po” lesz.
Az ötödik karakter után a szöveg „pon”.
A hatodik karakter után a szöveg „pont”.
A hetedik karakter után a szöveg „ponte”.
A nyolcadik karakter után a szöveg „ponter”.
Ezért a "ponter"-t adjuk vissza.

Korlátozások:

1 <= s.length <= 100
s kisbetűs angol betűkből áll.
s[0] != 'i'

A laptop billentyűzete hibás, és amikor beír egy „i” karaktert, az megfordítja a beírt karakterláncot. A többi karakter beírása a várt módon működik.
Kapsz egy 0 indexű s karakterláncot, és minden s karaktert beírsz a hibás billentyűzeteddel.
Adja vissza az utolsó karakterláncot, amely jelen lesz a laptop képernyőjén.

1. példa:

Bemenet: s = "string"
Kimenet: "rtsng"
Magyarázat:
Az első karakter beírása után a képernyőn megjelenő szöveg „s”.
A második karakter után a szöveg „st”.
A harmadik karakter után a szöveg „str”.
Mivel a negyedik karakter egy „i”, a szöveg megfordul és „rts” lesz.
Az ötödik karakter után a szöveg „rtsn”.
A hatodik karakter után a szöveg „rtsng”.
Ezért visszaadjuk az "rtsng"-t.

2. példa:

Bemenet: s = "pointer"
Kimenet: "ponter"
Magyarázat:
Az első karakter után a képernyőn megjelenő szöveg „p”.
A második karakter után a szöveg „po”.
Mivel a harmadik beírt karakter egy „i”, a szöveg megfordul, és „op” lesz.
Mivel a negyedik beírt karakter egy „i”, a szöveg megfordul, és „po” lesz.
Az ötödik karakter után a szöveg „pon”.
A hatodik karakter után a szöveg „pont”.
A hetedik karakter után a szöveg „ponte”.
A nyolcadik karakter után a szöveg „ponter”.
Ezért a "ponter"-t adjuk vissza.

Korlátozások:

1 <= s.length <= 100
s angol kisbetűkből áll.
s[0] != 'i'


Adott egy 0-indexelt s karakterlánc, permutálja az s-t, hogy egy új t karakterláncot kapjon, így:

Minden mássalhangzó az eredeti helyén marad. Formálisabban, ha van olyan i index, amelynek 0 <= i < s.hosszúsága úgy, hogy s[i] mássalhangzó, akkor t[i] = s[i].
A magánhangzókat az ASCII-értékeik nem csökkenő sorrendjében kell rendezni. Formálisabban fogalmazva, olyan i, j indexpárok esetén, amelyek 0 <= i < j < s.hosszúságúak úgy, hogy s[i] és s[j] magánhangzók, akkor t[i]-nek nem lehet nagyobb ASCII-értéke, mint t[ j].

Adja vissza a kapott karakterláncot.
A magánhangzók 'a', 'e', 'i', 'o' és 'u', és kis- és nagybetűkkel is megjelenhetnek. A mássalhangzók minden olyan betűt tartalmaznak, amelyek nem magánhangzók.

1. példa:

Bemenet: s = "lEetcOde"
Kimenet: "lEOtcede"
Magyarázat: 'E', 'O' és 'e' az s-ben lévő magánhangzók; Az 'l', 't', 'c' és 'd' mind mássalhangzók. A magánhangzók ASCII-értékük szerint vannak rendezve, és a mássalhangzók ugyanazokon a helyeken maradnak.

2. példa:

Bemenet: s = "lYmpH"
Kimenet: "lYmpH"
Magyarázat: Az s-ben nincsenek magánhangzók (az s-ben minden karakter mássalhangzó), ezért az "lYmpH"-t adjuk vissza.

Korlátozások:

1 <= s.hossz <= 10^5
s csak az angol ábécé nagy- és kisbetűiből áll.

Adott egy 0 indexelt s karakterlánc, permutálja az s-t, hogy új t karakterláncot kapjon úgy, hogy:

Minden mássalhangzó az eredeti helyén marad. Formálisabban, ha van egy i index, amelynek 0 <= i < s.length olyan, hogy s[i] mássalhangzó, akkor t[i] = s[i].
A magánhangzókat ASCII értékeik nem csökkenő sorrendjében kell rendezni. Formálisabban, az i, j indexpárok esetében, ahol 0 <= i < j < s.hosszúság úgy, hogy s[i] és s[j] magánhangzók, akkor t[i] nem lehet magasabb ASCII érték, mint t[j].

Adja vissza az eredményül kapott karakterláncot.
A magánhangzók "a", "e", "i", "o" és "u", és kisbetűvel vagy nagybetűvel is megjelenhetnek. A mássalhangzók közé tartozik minden olyan betű, amely nem magánhangzó.

1. példa:

Bemenet: s = "lEetcOde"
Kimenet: "lEOtcede"
Magyarázat: Az "E", "O" és "e" az s magánhangzói; Az "l", "t", "c" és "d" mind mássalhangzók. A magánhangzók ASCII értékeik szerint vannak rendezve, és a mássalhangzók ugyanazon a helyen maradnak.

2. példa:

Bemenet: s = "lYmpH"
Kimenet: "lYmpH"
Magyarázat: Az s-ben nincsenek magánhangzók (az s minden karaktere mássalhangzó), ezért az "lYmpH" értéket adjuk vissza.

Korlátok:

1 <= s.length <= 10^5
s csak az angol ábécé betűiből áll, nagy- és kisbetűkkel.

Adott egy 0-indexelt s karakterlánc, permutálja az s-t, hogy egy új t karakterláncot kapjon, így:

Minden mássalhangzó az eredeti helyén marad. Formálisabban, ha van olyan i index, amelynek 0 <= i < s.hossz úgy, hogy s[i] mássalhangzó, akkor t[i] = s[i].
AA magánhangzókat növekvő ASCII sorrendben kell rendezni. Formálisabban, ha léteznek i, j indexek, ahol 0 <= i < j < s.hossz és s[i] és s[j] magánhangzók, akkor t[i] nem lehet magasabb ASCII értékkel, mint t[j].

Adja vissza a kapott karakterláncot.
A magánhangzók 'a', 'e', 'i', 'o' és 'u', és kis- vagy nagybetűvel is megjelenhetnek. A mássalhangzók minden olyan betűt tartalmaznak, amelyek nem magánhangzók.

1. példa:

Bemenet: s = "lEetcOde"
Kimenet: "lEOtcede"
Magyarázat: 'E', 'O' és 'e' az s-ben lévő magánhangzók; Az 'l', 't', 'c' és 'd' mind mássalhangzók. A magánhangzók ASCII-értékük szerint vannak rendezve, és a mássalhangzók ugyanazokon a helyeken maradnak.

2. példa:

Bemenet: s = "lYmpH"
Kimenet: "lYmpH"
Magyarázat: Az s-ben nincsenek magánhangzók (az s-ben minden karakter mássalhangzó), ezért az "lYmpH"-t adjuk vissza.

Korlátozások:

1 <= s.hossz <= 10^5
s csak az angol ábécé nagy- és kisbetűiből áll.


Egy x elem egy m hosszúságú egész számokból álló arr tömbben domináns, ha freq(x) * 2 > m, ahol freq(x) az x előfordulásainak száma az arr tömbben. Ez a meghatározás azt jelenti, hogy az arr tömbben legfeljebb egy domináns elem lehet.
Megadunk egy 0-indexált nums egész számokból álló tömböt n hosszúsággal, amely egy domináns elemet tartalmaz.
A nums tömböt két részre oszthatjuk egy i indexnél nums[0, ..., i] és nums[i + 1, ..., n - 1], de az osztás csak akkor érvényes, ha:

0 <= i < n - 1
nums[0, ..., i], és nums[i + 1, ..., n - 1] ugyanazzal a domináns elemmel rendelkeznek.

Itt a nums[i, ..., j] a nums tömb i indextől kezdve j indexig tartó részhalmazát jelöli, mindkét végével együtt. Különösen, ha j < i, akkor nums[i, ..., j] egy üres részhalmazt jelöl.
Add vissza az érvényes osztás minimális indexét. Ha nincs érvényes osztás, add vissza a -1-et.

Példa 1:

Bemenet: nums = [1,2,2,2]
Kimenet: 2
Magyarázat: A tömböt feloszthatjuk a 2. indexnél, hogy kapjunk [1,2,2] és [2] tömböket.
A [1,2,2] tömbben a 2 elem domináns, mivel kétszer fordul elő a tömbben és 2 * 2 > 3.
A [2] tömbben a 2 elem domináns, mivel egyszer fordul elő a tömbben és 1 * 2 > 1.
Mind a [1,2,2], mind pedig a [2] azonos domináns elemmel rendelkezik, mint a nums, így ez egy érvényes osztás.
Megmutatható, hogy a 2 az érvényes osztás minimális indexe.

Példa 2:

Bemenet: nums = [2,1,3,1,1,1,7,1,2,1]
Kimenet: 4
Magyarázat: A tömböt feloszthatjuk a 4. indexnél, hogy kapjunk [2,1,3,1,1] és [1,7,1,2,1] tömböket.
A [2,1,3,1,1] tömbben az 1 elem domináns, mivel háromszor fordul elő és 3 * 2 > 5.
A [1,7,1,2,1] tömbben az 1 elem domináns, mivel háromszor fordul elő és 3 * 2 > 5.
Mind a [2,1,3,1,1], mind pedig a [1,7,1,2,1] azonos domináns elemmel rendelkezik, mint a nums, így ez egy érvényes osztás.
Megmutatható, hogy a 4 az érvényes osztás minimális indexe.

Példa 3:

Bemenet: nums = [3,3,3,3,7,2,2]
Kimenet: -1
Magyarázat: Megmutatható, hogy nincs érvényes osztás.

Korlátozások:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums pontosan egy domináns elemet tartalmaz.

Egy m hosszúságú arr egész tömb x eleme domináns, ha freq(x) * 2 > m, ahol freq(x) x előfordulásainak száma arr. Megjegyezzük, hogy ez a meghatározás azt jelenti, hogy az arr-nek legfeljebb egy domináns eleme lehet.
Kapsz egy 0-indexelt egész tömb n hosszúságú számot egy domináns elemmel.
Az i indexben lévő számokat feloszthatja két tömbre: nums[0, ..., i] és nums[i + 1, ..., n - 1], de a felosztás csak akkor érvényes, ha:

0 < = i < n - 1
A nums[0, ..., i] és nums[i + 1, ..., n - 1] ugyanazzal a domináns elemmel rendelkezik.

Itt a nums[i, ..., j] az i indextől kezdődő és j indexre végződő számok résztömbjét jelöli, mindkét vége bezárólag. Különösen, ha j < i, akkor nums[i, ..., j] üres résztömböt jelöl.
Egy érvényes felosztás minimális indexét adja vissza. Ha nincs érvényes felosztás, adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [1,2,2,2]
Kimenet: 2
Magyarázat: Feloszthatjuk a tömböt a 2-es indexen, hogy [1,2,2] és [2] tömböket kapjunk.
Az [1,2,2] tömbben a 2. elem domináns, mivel kétszer fordul elő a tömbben és 2 * 2 > 3.
A [2] tömbben a 2. elem domináns, mivel egyszer fordul elő a tömbben és 1 * 2 > 1.
Mind az [1,2,2], mind a [2] ugyanazzal a domináns elemmel rendelkezik, mint a numok, tehát ez egy érvényes felosztás.
Kimutatható, hogy a 2. index az érvényes felosztás minimális indexe.
2. példa:

Bemenet: nums = [2,1,3,1,1,1,1,7,1,2,1]
Kimenet: 4
Magyarázat: Feloszthatjuk a tömböt a 4-es indexen, hogy [2,1,3,1,1] és [1,7,1,2,1] tömböket kapjunk.
A [2,1,3,1,1] tömbben az 1. elem domináns, mivel háromszor fordul elő a tömbben és 3 * 2 > 5.
Az [1,7,1,2,1] tömbben az 1. elem domináns, mivel háromszor fordul elő a tömbben és 3 * 2 > 5.
Mind a [2,1,3,1,1], mind az [1,7,1,2,1] domináns eleme megegyezik a numokkal, tehát ez egy érvényes felosztás.
Kimutatható, hogy a 4. index az érvényes felosztás minimális indexe.
3. példa:

Bemenet: nums = [3,3,3,3,7,2,2]
Kimenet: -1
Magyarázat: Kimutatható, hogy nincs érvényes felosztás.

Korlátok:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
A numsnak pontosan egy domináns eleme van.

Egy m hosszúságú arr egész tömb x eleme domináns, ha freq(x) * 2 > m, ahol freq(x) az x előfordulások száma az arr-ben. Vegye figyelembe, hogy ez a definíció azt jelenti, hogy az arr legfeljebb egy domináns elemet tartalmazhat.
Egy 0-indexelt egész tömböt kapunk, amelyek n hosszúságúak egy domináns elemmel.
Az i indexben lévő számokat feloszthatja két tömbre: nums[0, ..., i] és nums[i + 1, ..., n - 1], de a felosztás csak akkor érvényes, ha:

0 <= i < n - 1
nums[0, ..., i], and nums[i + 1, ..., n - 1] ugyanazt a domináns elemet tartalmazzák.

Itt a nums[i, ..., j] az i indextől kezdődő és a j indexre végződő számok altömbjét jelöli, mindkét végét magában foglalja. Különösen, ha j < i, akkor a szám[i, ..., j] üres altömböt jelöl.
Egy érvényes felosztás minimális indexét adja vissza. Ha nem létezik érvényes felosztás, adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [1,2,2,2]
Kimenet: 2
Magyarázat: Feloszthatjuk a 2-es indexű tömböt, hogy megkapjuk az [1,2,2] és [2] tömböket.
Az [1,2,2] tömbben a 2. elem a domináns, mivel kétszer fordul elő a tömbben, és 2 * 2 > 3.
A [2] tömbben a 2. elem a domináns, mivel egyszer fordul elő a tömbben, és 1 * 2 > 1.
Mind az [1,2,2], mind a [2] elemnek ugyanaz a domináns eleme, mint a számoknak, tehát ez egy érvényes felosztás.
Megmutatható, hogy a 2. index egy érvényes felosztás minimális indexe.
2. példa:

Bemenet: nums = [2,1,3,1,1,1,7,1,2,1]
Kimenet: 4
Magyarázat: Feloszthatjuk a 4-es indexű tömböt, hogy megkapjuk a [2,1,3,1,1] és [1,7,1,2,1] tömböket.
A [2,1,3,1,1] tömbben az 1. elem a domináns, mivel háromszor fordul elő a tömbben, és 3 * 2 > 5.
Az [1,7,1,2,1] tömbben az 1. elem a domináns, mivel háromszor fordul elő a tömbben, és 3 * 2 > 5.
Mind a [2,1,3,1,1], mind az [1,7,1,2,1] domináns eleme ugyanaz, mint a számoknak, tehát ez egy érvényes felosztás.
Megmutatható, hogy a 4-es index egy érvényes felosztás minimális indexe.
3. példa:

Bemenet: nums = [3,3,3,3,7,2,2]
Kimenet: -1
Magyarázat: Kimutatható, hogy nincs érvényes felosztás.

Korlátozások:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
A numsnak pontosan egy domináns eleme van.


Kapsz egy 0-indexelt tömbszámot és egy nem negatív k egész számot.
Egy művelettel a következőket teheti:

Válassz egy i indexet, amelyet korábban nem választottál a [0, nums.length - 1] tartományból.
Cseréld le a nums[i] értékét bármely egész számra a [nums[i] - k, nums[i] + k] tartományban.

A tömb szépsége az egyenlő elemekből álló leghosszabb részsorozat hossza.
A művelet tetszőleges számú alkalmazása után adja vissza a tömbszámok lehető legnagyobb szépségét.
Vegye figyelembe, hogy a műveletet minden indexre csak egyszer alkalmazhatja.
Egy tömb részsorozata egy új tömb, amelyet az eredeti tömbből generálnak úgy, hogy néhány elemet (esetleg egyiket sem) törölnek a fennmaradó elemek sorrendjének megváltoztatása nélkül.

Példa 1:

Bemenet: nums = [4,6,1,2], k = 2
Kimenet: 3
Magyarázat: Ebben a példában a következő műveleteket alkalmazzuk:
- Válassza az 1-es indexet, cserélje ki 4-re ([4,8] tartományból), számok = [4,4,1,2].
- Válassza a 3. indexet, cserélje ki 4-re ([0,4] tartományból), számok = [4,4,1,4].
Az alkalmazott műveletek után a tömbszámok szépsége 3 (0, 1 és 3 indexekből álló részsorozat).
Bizonyítható, hogy a 3 a maximálisan elérhető hosszúság.

Példa 2:

Bemenet: nums = [1,1,1,1], k = 10
Kimenet: 4
Magyarázat: Ebben a példában nem kell semmilyen műveletet alkalmaznunk.
A tömb számok szépsége 4 (teljes tömb).

Korlátozások:

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

Kapsz egy 0-indexelt tömbszámot és egy nem negatív egész számot k.
Egy művelettel a következőket teheti:

Válasszon egy olyan i indexet, amelyet még nem választott ki a [0, nums.length - 1] tartományból.
Cserélje ki a nums[i] helyére bármely egész számot a [nums[i] - k, nums[i] + k tartományból.

A tömb szépsége az egyenlő elemekből álló leghosszabb alsorozat hossza.
A tömb számának lehető legnagyobb szépségét adja vissza, miután akárhányszor alkalmazta a műveletet.
Vegye figyelembe, hogy a műveletet minden indexre csak egyszer alkalmazhatja.
A tömb részsorozata egy új tömb, amely az eredeti tömbből jön létre néhány elem törlésével (esetleg egyik sem) a fennmaradó elemek sorrendjének megváltoztatása nélkül.

1. példa:

Bemenet: nums = [4,6,1,2], k = 2
Kimenet: 3
Magyarázat: Ebben a példában a következő műveleteket alkalmazzuk:
- Válassza ki az 1. indexet, cserélje ki 4-re (from range [4,8]), nums = [4,4,1,2].
- Válassza ki a 3. indexet, cserélje ki 4-re (from range [0,4]), nums = [4,4,1,4].
Az alkalmazott műveletek után a tömbszámok szépsége 3 (0, 1 és 3 indexekből álló részsorozat).
Bizonyítható, hogy a 3 a maximális lehetséges hossz, amit elérhetünk.

2. példa:

Bemenet: nums = [1,1,1,1], k = 10
Kimenet: 4
Magyarázat: Ebben a példában nem kell semmilyen műveletet alkalmaznunk.
A tömb számának szépsége 4 (egész tömb).

Korlátok:

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

Kapsz egy 0-indexelt tömbszámot és egy nem negatív k egész számot.
Egy művelettel a következőket teheti:

Válasszon egy i indexet, amelyet korábban nem választott ki a [0, nums.length - 1] tartományból.
Cserélje le a számokat [i] bármely egész számra a [nums[i] - k, nums[i] + k] tartományból.

A tömb szépsége az egyenlő elemekből álló leghosszabb részsorozat hossza.
A művelet tetszőleges számú alkalmazása után adja vissza a tömbszámok lehető legnagyobb szépségét.
Vegye figyelembe, hogy a műveletet minden indexre csak egyszer alkalmazhatja.
Egy tömb részsorozata egy új tömb, amelyet az eredeti tömbből generálnak úgy, hogy néhány elemet (esetleg egyiket sem) törölnek a fennmaradó elemek sorrendjének megváltoztatása nélkül.

1. példa:

Bemenet: nums = [4,6,1,2], k = 2
Kimenet: 3
Magyarázat: Ebben a példában a következő műveleteket alkalmazzuk:
- Válassza az 1-es indexet, cserélje ki 4-re ([4,8] tartományból), nums = [4,4,1,2].
- Válassza a 3. indexet, cserélje ki 4-re ([0,4] tartományból), nums = [4,4,1,4].
Az alkalmazott műveletek után a tömbszámok szépsége 3 (0, 1 és 3 indexekből álló részsorozat).
Bizonyítható, hogy a 3 a maximálisan elérhető hosszúság.

2. példa:

Bemenet: nums = [1,1,1,1], k = 10
Kimenet: 4
Magyarázat: Ebben a példában nem kell semmilyen műveletet alkalmaznunk.
A tömb számok szépsége 4 (teljes tömb).

Korlátozások:

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


Adott egy egész számokból álló tömb, nums. Egy tömböt akkor tekintünk jónak, ha az egy tömbalap[n] permutációja.
base[n] = [1, 2, ..., n - 1, n, n] (más szóval, ez egy n + 1 hosszúságú tömb, amely pontosan egyszer tartalmaz 1-től n - 1-ig, plusz n két előfordulását). Például base[1] = [1, 1] és base[3] = [1, 2, 3, 3].
Igaz értéket ad vissza, ha az adott tömb jó, ellenkező esetben hamis értéket ad vissza.
Megjegyzés: Az egész számok permutációja ezeknek a számoknak az elrendezését jelenti.

1. példa:

Bemenet: nums = [2, 1, 3]
Kimenet: false
Magyarázat: Mivel a tömb maximális eleme 3, az egyetlen n jelölt, amelyre ez a tömb a base[n] permutációja lehet, n = 3. A base[3] azonban négy elemet tartalmaz, de a a tömb elemei három. Ezért nem lehet a bázis permutációja[3] = [1, 2, 3, 3]. Tehát a válasz hamis.

2. példa:

Bemenet: nums = [1, 3, 3, 2]
Kimenet: true
Magyarázat: Mivel a tömb maximális eleme 3, az egyetlen n jelölt, amelyre ez a tömb a bázis[n] permutációja lehet, n = 3. Látható, hogy a nums a base[3] = [1, 2, 3, 3] permutációja (a második és negyedik elem numokban történő felcserélésével elérjük a base[3]-t). Ezért a válasz igaz.
3. példa:

Bemenet: nums = [1, 1]
Kimenet: true
Magyarázat: Mivel a tömb maximális eleme 1, az egyetlen n jelölt, amelyre ez a tömb a bázis[n] permutációja lehet, n = 1. Látható, hogy a nums a base[1] = [1, 1] permutációja. Ezért a válasz igaz.
4. példa:

Bemenet: nums = [3, 4, 4, 1, 2, 1]
Kimenet: false
Magyarázat: Mivel a tömb maximális eleme 4, az egyetlen n jelölt, amelyre ez a tömb a base[n] permutációja lehet, n = 4. A base[4] azonban öt elemet tartalmaz, de a a tömb elemei hat. Ezért nem lehet a bázis permutációja[4] = [1, 2, 3, 4, 4]. Tehát a válasz hamis.

Korlátok:

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

Kap egy egész tömb nums-t. Egy tömböt akkor tekintünk jónak, ha az egy tömbalap[n] permutációja.
bázis[n] = [1, 2, ..., n - 1, n, n] (más szóval, ez egy n + 1 hosszúságú tömb, amely pontosan egyszer tartalmaz 1-től n - 1-ig, plusz n két előfordulását). Például base[1] = [1, 1] és base[3] = [1, 2, 3, 3].
Igaz értéket ad vissza, ha az adott tömb jó, ellenkező esetben hamis értéket ad vissza.
Megjegyzés: Az egész számok permutációja ezeknek a számoknak az elrendezését jelenti.

1. példa:

Bemenet: nums = [2, 1, 3]
Kimenet: hamis
Magyarázat: Mivel a tömb maximális eleme 3, az egyetlen n jelölt, amelyre ez a tömb a bázis[n] permutációja lehet, n = 3. A base[3] azonban négy elemet tartalmaz, de a tömbszámokat három. Ezért nem lehet a bázis permutációja[3] = [1, 2, 3, 3]. Tehát a válasz hamis.

2. példa:

Bemenet: nums = [1, 3, 3, 2]
Kimenet: true
Magyarázat: Mivel a tömb maximális eleme 3, az egyetlen n jelölt, amelyre ez a tömb a bázis[n] permutációja lehet, n = 3. Látható, hogy a nums a base[3] = [1, 2, 3, 3] permutációja (a második és negyedik elem numokban történő felcserélésével elérjük a base[3]-t). Ezért a válasz igaz.
3. példa:

Bemenet: nums = [1, 1]
Kimenet: true
Magyarázat: Mivel a tömb maximális eleme 1, az egyetlen n jelölt, amelyre ez a tömb a bázis[n] permutációja lehet, n = 1. Látható, hogy a nums a bázis[1] = [1, 1] permutációja. Ezért a válasz igaz.
4. példa:

Bemenet: nums = [3, 4, 4, 1, 2, 1]
Kimenet: hamis
Magyarázat: Mivel a tömb maximális eleme 4, az egyetlen n jelölt, amelyre ez a tömb a bázis[n] permutációja lehet, n = 4. A base[4] azonban öt elemet tartalmaz, de a tömbszámokat hat. Ezért nem lehet a bázis permutációja[4] = [1, 2, 3, 4, 4]. Tehát a válasz hamis.

Korlátok:

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

Kapsz egy egész tömb számát. Egy tömböt akkor tekintünk jónak, ha egy tömbbázis [n] permutációja.
bázis[n] = [1, 2, ..., n - 1, n, n] (más szóval ez egy n + 1 hosszúságú tömb, amely pontosan egyszer tartalmaz 1-től n-1-ig, plusz két előfordulását n). Például bázis[1] = [1, 1] és bázis[3] = [1, 2, 3, 3].
Ad vissza igazat, ha az adott tömb jó, ellenkező esetben hamis értéket..
Megjegyzés: Az egész számok permutációja ezeknek a számoknak az elrendezését jelenti.

1. példa:

Bemenet: nums = [2, 1, 3]
Kimenet: false
Magyarázat: Mivel a tömb maximális eleme 3, az egyetlen n jelölt, amelyre ez a tömb a base[n] permutációja lehet, n = 3. A base[3]-nak azonban négy eleme van, a tömbszámoknak pedig három. Ezért ez nem lehet bázis [3] = [1, 2, 3, 3] permutációja. Tehát a válasz false.

példa:
2. példa:

Bemenet: nums = [1, 3, 3, 2]
Kimenet: true
Magyarázat: Mivel a tömb maximális eleme 3, az egyetlen n jelölt, amelyre ez a tömb a base[n] permutációja lehet, n = 3. Látható, hogy a nums a base[3] = [1, 2, 3, 3] permutációja (a második és negyedik elemek felcserélésével elérhető). Ezért a válasz true.
3. példa:

Bemenet: nums = [1, 1]
Kimenet: true
Magyarázat: Mivel a tömb maximális eleme 1, az egyetlen n jelölt, amelyre ez a tömb a base[n] permutációja lehet, n = 1. Látható, hogy a nums a base[1] = permutációja. [1, 1]. Ezért a válasz true.
4. példa:

Bemenet: nums = [3, 4, 4, 1, 2, 1]
Kimenet: false
Magyarázat: Mivel a tömb maximális eleme 4, az egyetlen jelölt n, amelyre ez a tömb a base[n] permutációja lehet, n = 4. A base[4]-nek azonban öt eleme van, a tömbszámoknak pedig hat. Ezért ez nem lehet bázis [4] = [1, 2, 3, 4, 4] permutációja. Tehát a válasz false.

Korlátozások:

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


Egy 0-indexelt egész számokból álló nums tömböt és egy pozitív egész számot x kapsz.
Kezdetben a 0. pozícióban vagy a tömbben, és az alábbi szabályok szerint más pozíciókat látogathatsz meg:

Ha éppen az i pozícióban vagy, akkor bármelyik j pozícióba léphetsz, ahol i < j.
Minden egyes i pozícióban, amelyet meglátogatsz, a nums[i] értéke lesz a pontszámod.
Ha egy i pozícióból egy j pozícióba lépsz, és a nums[i] és nums[j] paritása eltér, akkor x pontot veszítesz.

Térj vissza a maximális összpontszámmal, amit elérhetsz.
Ne feledd, hogy kezdetben nums[0] pontod van.

Példa 1:

Input: nums = [2,3,6,1,9,2], x = 5
Output: 13
Magyarázat: Az alábbi pozíciókat látogathatjuk meg a tömbben: 0 -> 2 -> 3 -> 4.
A megfelelő értékek: 2, 6, 1 és 9. Mivel a 6 és 1 különböző paritásúak, a 2 -> 3 lépés x = 5 pontot veszít.
A teljes pontszám: 2 + 6 + 1 + 9 - 5 = 13.

Példa 2:

Input: nums = [2,4,6,8], x = 3
Output: 20
Magyarázat: A tömbben szereplő összes egész számnak ugyanaz a paritása, így mindet meglátogathatjuk anélkül, hogy pontot veszítenénk.
A teljes pontszám: 2 + 4 + 6 + 8 = 20.

Korlátozások:

2 <= nums.hosszúság <= 10^5
1 <= nums[i], x <= 10^6

Kap egy 0 indexelt egész tömb számot és egy pozitív egész x számot.
Kezdetben a tömb 0. pozíciójában van, és a következő szabályok szerint látogathat más pozíciókat:

Ha jelenleg az i pozícióban vagy, akkor bármelyik j pozícióba léphetsz, úgy, hogy i < j legyen.
Minden egyes i pozícióért, amelyet meglátogat, kapsz egy pontszámot nums[i].
Ha egy i pozícióból egy j pozícióba lépsz, és a nums[i] és a nums[j] paritása különbözik, akkor x pontszámot veszítesz.

Adja vissza a maximális összpontszámot.
Vegye figyelembe, hogy kezdetben nums[0] pontjai vannak.

1. példa:

Bemenet: szám = [2,3,6,1,9,2], x = 5
Kimenet: 13
Magyarázat: A tömb következő pozícióit látogathatjuk meg: 0 -> 2 -> 3 -> 4.
A megfelelő értékek 2, 6, 1 és 9. Mivel a 6. és 1. egész számok különböző paritásúak, a 2 -> 3 lépés x = 5 pontszámot veszít.
A teljes pontszám: 2 + 6 + 1 + 9 - 5 = 13.

2. példa:

Bemenet: nums = [2,4,6,8], x = 3
Kimenet: 20
Magyarázat: A tömb összes egész száma azonos paritással rendelkezik, így mindegyiket meglátogathatjuk pontszámvesztés nélkül.
A teljes pontszám: 2 + 4 + 6 + 8 = 20.

Korlátok:

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

Adott egy 0 indexű egész szám tömb nums és egy pozitív egész szám x.
Kezdetben a tömb 0. pozícióján állsz, és a következő szabályok szerint más pozíciókat is meglátogathatsz:

Ha jelenleg az i pozícióban vagy, akkor bármelyik j pozícióba léphetsz, úgy, hogy i < j.
Minden egyes i pozícióra, amelyet meglátogatsz, kapsz egy nums[i] értéket.
Ha az i pozícióból a j pozícióba lépsz, és a nums[i] és a nums[j] paritásai különböznek, akkor x pontszámot veszítesz.

Adja vissza a maximálisan elérhető összpontszámot.
Vegyük figyelembe, hogy kezdetben nums[0] pontokkal rendelkezünk.

Példa 1:

Bevitel: nums = [2,3,6,1,9,2], x = 5
Kimenet: 13
Magyarázat: A következő pozíciókat látogathatjuk meg a tömbben: 0 -> 2 -> 3 -> 4.
A megfelelő értékek: 2, 6, 1 és 9. Mivel a 6 és az 1 egész számok különböző paritásúak, a 2 -> 3 lépéssel x = 5 pontot veszítünk.
A teljes pontszám így lesz: 2 + 6 + 1 + 9 - 5 = 13.

Példa 2:

Bemenet: nums = [2,4,6,8], x = 3
Kimenet: 20
Magyarázat: A tömbben lévő összes egész szám azonos paritású, így mindegyiket meglátogathatjuk anélkül, hogy pontveszteséget szenvednénk.
A teljes pontszám: 2 + 4 + 6 + 8 = 20.

Korlátozások:

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


Adott egy 0-indexelt egész számokból álló tömb. Találja meg a számok közötti számpárok maximális összegét, amelyekben mindkét szám maximális számjegye egyenlő.
Adjuk vissza a maximális összeget, vagy -1, ha nincs ilyen pár.

Példa 1

Bemenet: nums = [51,71,17,24,42]
Kimenet: 88
Magyarázat:
i = 1 és j = 2 esetén a nums[i] és a nums[j] egyenlő maximális számjegyekkel rendelkezik, párösszege 71 + 17 = 88.
i = 3 és j = 4 esetén a nums[i] és a nums[j] egyenlő maximális számjegyekkel rendelkezik, párösszege 24 + 42 = 66.
Megmutatható, hogy nincsenek más párok, amelyek egyenlő maximális számjegyűek, így a válasz 88.
Példa 2

Bemenet: nums = [1,2,3,4]
Kimenet: -1
Magyarázat: Nincs pár egyenlő maximális számjegyű számokban.

Korlátozások.

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

Kapsz egy 0-indexelt egész tömb számot. A számokból meg kell találnia egy számpár maximális összegét úgy, hogy mindkét számban a maximális számjegy egyenlő legyen.
Adja vissza a maximális összeget vagy -1-et, ha nem létezik ilyen pár.

1. példa:

Bemenet: nums = [51,71,17,24,42]
Kimenet: 88
Magyarázat:
Ha i = 1 és j = 2, a nums[i] és a nums[j] maximális számjegyei egyenlőek, és a párösszeg 71 + 17 = 88.
Ha i = 3 és j = 4, a nums[i] és a nums[j] maximális számjegyei egyenlőek, és a párösszeg 24 + 42 = 66.
Kimutatható, hogy nincs más pár egyenlő maximális számjegyekkel, így a válasz 88.
2. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: -1
Magyarázat: Nincs olyan számpár, amelynek maximális számjegyei egyenlőek.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot. A számokból meg kell találnia egy számpár maximális összegét úgy, hogy mindkét számban a maximális számjegy egyenlő legyen.
Adja vissza a maximális összeget vagy -1-et, ha nem létezik ilyen pár.

Példa 1:

Bemenet: nums = [51,71,17,24,42]
Kimenet: 88
Magyarázat:
Ha i = 1 és j = 2, a számok[i] és a számok[j] maximális számjegyei egyenlőek, és a párösszeg 71 + 17 = 88.
Ha i = 3 és j = 4, a számok[i] és számok[j] maximális számjegyei egyenlőek, párösszegük 24 + 42 = 66.
Kimutatható, hogy nincs más pár egyenlő maximális számjegyekkel, így a válasz 88.
Példa 2:

Bemenet: nums = [1,2,3,4]
Kimenet: -1
Magyarázat: Nincs olyan számpár, amelynek maximális számjegyei egyenlőek.

Korlátozások:

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


Kapsz egy 0-indexelt egész tömb számot, egy integer modulo és egy k egész számot.
Az Ön feladata, hogy megtalálja az érdekes altömbök számát.
A nums[l..r] alsor érdekes, ha a következő feltétel teljesül:

Legyen cnt az i indexek száma az [l, r] tartományban úgy, hogy nums[i] % modulo == k. Ekkor cnt % modulo == k.

Egy egész számot ad vissza, amely az érdekes altömbök számát jelöli.
Megjegyzés: Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [3,2,4], modulo = 2, k = 1
Kimenet: 3
Magyarázat: Ebben a példában az érdekes altömbök a következők:
Az altömb szám[0..0], ami [3].
- Csak egy index van, az i = 0 a [0, 0] tartományban, amely kielégíti a nums[i] % modulo == k-t.
- Ezért cnt = 1 és cnt % modulo == k.
Az altömb [0..1], ami [3,2].
- Csak egy index van, az i = 0 a [0, 1] tartományban, amely kielégíti a nums[i] % modulo == k-t.
- Ezért cnt = 1 és cnt % modulo == k.
Az altömb [0..2], ami [3,2,4].
- Csak egy index van, az i = 0 a [0, 2] tartományban, amely kielégíti a nums[i] % modulo == k-t.
- Ezért cnt = 1 és cnt % modulo == k.
Kimutatható, hogy nincs más érdekes alrendszer. Tehát a válasz: 3.
2. példa:

Bemenet: nums = [3,1,9,6], modulo = 3, k = 0
Kimenet: 2
Magyarázat: Ebben a példában az érdekes altömbök a következők:
Az altömb számai[0..3], ami [3,1,9,6].
- Három olyan index van, i = 0, 2, 3 a [0, 3] tartományban, amelyek kielégítik a nums[i] % modulo == k-t.
- Ezért cnt = 3 és cnt % modulo == k.
Az altömb [1..1], amely [1].
- Az [1, 1] tartományban nincs olyan i index, amely megfelel a nums[i] % modulo == k értéknek.
- Ezért cnt = 0 és cnt % modulo == k.
Kimutatható, hogy nincs más érdekes alrendszer. Tehát a válasz: 2.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot, egy egész modulót és egy k egész számot.
Az Ön feladata, hogy megtalálja az érdekes altömbök számát.
Egy résztömb nums[l.. r] akkor érdekes, ha a következő feltétel teljesül:

Legyen cnt az i indexek száma az [l, r] tartományban úgy, hogy nums[i] % modulo == k. Ezután cnt % modulo == k.

Az érdekes résztömbök számát jelölő egész számot ad vissza.
Megjegyzés: A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [3,2,4], modulo = 2, k = 1
Kimenet: 3
Magyarázat: Ebben a példában az érdekes altömbök a következők:
A résztömb nums[0..0], ami [3].
- A [0, 0] tartományban csak egy index van, i = 0, amely kielégíti a nums[i] % modulo == k értéket.
- Ezért cnt = 1 és cnt % modulo == k.
A résztömb nums[0..1], ami [3,2].
- A [0, 1] tartományban csak egy index van, i = 0, amely kielégíti a nums[i] % modulo == k értéket.
- Ezért cnt = 1 és cnt % modulo == k.
A résztömb nums[0..2], ami [3,2,4].
- A [0, 2] tartományban csak egy index van, i = 0, amely kielégíti a nums[i] % modulo == k értéket.
- Ezért cnt = 1 és cnt % modulo == k.
Megmutatható, hogy nincsenek más érdekes altömbök. Tehát a válasz 3.
2. példa:

Bemenet: nums = [3,1,9,6], modulo = 3, k = 0
Kimenet: 2
Magyarázat: Ebben a példában az érdekes altömbök a következők:
A résztömb nums[0..3], ami [3,1,9,6].
- A [0, 3] tartományban három index van, i = 0, 2, 3, amelyek kielégítik a nums[i] % modulo == k értéket.
- Ezért cnt = 3 és cnt % modulo == k.
A résztömb nums[1..1], ami [1].
- Az [1, 1] tartományban nincs olyan index, i, amely kielégítené a nums[i] % modulo == k értéket.
- Ezért cnt = 0 és cnt % modulo == k.
Megmutatható, hogy nincsenek más érdekes altömbök. Tehát a válasz 2.

Korlátok:

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

Kapsz egy 0-indexelt egész tömb számot, egy integer modulo és egy k egész számot.
Az Ön feladata, hogy megtalálja az érdekes altömbök számát.
A nums[l..r] alsor érdekes, ha a következő feltétel teljesül:

Legyen cnt az i indexek száma az [l, r] tartományban úgy, hogy nums[i] % modulo == k. Ekkor cnt % modulo == k.

Egy egész számot ad vissza, amely az érdekes altömbök számát jelöli.
Megjegyzés: Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

Példa 1:

Bemenet: nums = [3,2,4], modulo = 2, k = 1
Kimenet: 3
Magyarázat: Ebben a példában az érdekes altömbök a következők:
Az altömb szám[0..0], ami [3].
- Csak egy index van, az i = 0 a [0, 0] tartományban, amely kielégíti a nums[i] % modulo == k-t.
- Ezért cnt = 1 és cnt % modulo == k.
Az altömb [0..1], ami [3,2].
- Csak egy index van, az i = 0 a [0, 1] tartományban, amely kielégíti a nums[i] % modulo == k-t.
- Ezért cnt = 1 és cnt % modulo == k.
Az altömb [0..2], ami [3,2,4].
- Csak egy index van, az i = 0 a [0, 2] tartományban, amely kielégíti a nums[i] % modulo == k-t.
- Ezért cnt = 1 és cnt % modulo == k.
Kimutatható, hogy nincs más érdekes alrendszer. Tehát a válasz: 3.
Példa 2:

Bemenet: nums = [3,1,9,6], modulo = 3, k = 0
Kimenet: 2
Magyarázat: Ebben a példában az érdekes altömbök a következők:
Az altömb számai[0..3], ami [3,1,9,6].
- Három olyan index van, i = 0, 2, 3 a [0, 3] tartományban, amelyek kielégítik a nums[i] % modulo == k-t.
- Ezért cnt = 3 és cnt % modulo == k.
Az altömb [1..1], amely [1].
- Az [1, 1] tartományban nincs olyan i index, amely megfelel a nums[i] % modulo == k értéknek.
- Ezért cnt = 0 és cnt % modulo == k.
Kimutatható, hogy nincs más érdekes alrendszer. Tehát a válasz: 2.

Korlátozások:

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