Kapsz egy n hosszúságú tömböt és egy m egész számot. Meg kell határoznia, hogy lehetséges-e a tömb felosztása n nem üres tömbre egy sor lépés végrehajtásával.
Minden lépésben kiválaszthat egy legalább kettő hosszúságú meglévő tömböt (amely lehet az előző lépések eredménye), és két altömbre bonthatja, ha minden eredményül kapott altömbre az alábbiak közül legalább az egyik teljesül:

Az altömb hossza egy, ill
Az altömb elemeinek összege nagyobb vagy egyenlő, mint m.

Igazat ad vissza, ha az adott tömböt n tömbre osztja, ellenkező esetben hamis értéket ad vissza.
Megjegyzés: Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [2, 2, 1], m = 4
Kimenet: igaz
Magyarázat: A tömböt első lépésben feloszthatjuk [2, 2] és [1] részre. Ezután a második lépésben a [2, 2]-t feloszthatjuk [2]-re és [2]-re. Ennek eredményeként a válasz igaz.
2. példa:

Bemenet: nums = [2, 1, 3], m = 5
Kimenet: hamis
Magyarázat: Megpróbálhatjuk két különböző módon felosztani a tömböt: az első a [2, 1] és a [3], a második a [2] és az [1, 3]. Azonban mindkét módszer nem érvényes. Tehát a válasz hamis.
3. példa:

Bemenet: nums = [2, 3, 3, 2, 3], m = 6
Kimenet: igaz
Magyarázat: Az első lépésben feloszthatjuk a tömböt [2, 3, 3, 2] és [3] részekre. Ezután a második lépésben a [2, 3, 3, 2]-t feloszthatjuk [2, 3, 3]-ra és [2]-re. Ezután a harmadik lépésben a [2, 3, 3]-t feloszthatjuk [2]-re és [3, 3]-ra. Az utolsó lépésben pedig feloszthatjuk a [3, 3]-at [3]-ra és [3]-ra. Ennek eredményeként a válasz igaz.

Korlátozások:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

Kapsz egy n hosszúságú tömbszámot és egy m egész számot. Meg kell határoznia, hogy lehetséges-e a tömböt n nem üres tömbre osztani egy sor lépés végrehajtásával.
Minden lépésben kiválaszthat egy legalább két hosszúságú meglévő tömböt (amely az előző lépések eredménye is lehet), és feloszthatja két résztömbre, ha minden eredményül kapott résztömbhöz az alábbiak közül legalább egy teljesül:

A résztömb hossza egy, vagy
A résztömb elemeinek összege nagyobb vagy egyenlő m-mel.

Igaz értéket ad vissza, ha az adott tömböt n tömbre tudja osztani, ellenkező esetben hamis értéket ad vissza.
Megjegyzés: A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [2, 2, 1], m = 4
Kimenet: true
Magyarázat: Első lépésben feloszthatjuk a tömböt [2, 2] és [1] részre. Ezután a második lépésben feloszthatjuk a [2, 2] -t [2] és [2] -re. Ennek eredményeként a válasz igaz.
2. példa:

Bemenet: nums = [2, 1, 3], m = 5
Kimenet: false
Magyarázat: Megpróbálhatjuk felosztani a tömböt két különböző módon: az első módszer az, hogy [2, 1] és [3], a második módszer pedig az, hogy [2] és [1, 3]. Azonban mindkét módszer nem érvényes. Tehát a válasz hamis.
3. példa:

Bemenet: nums = [2, 3, 3, 2, 3], m = 6
Kimenet: true
Magyarázat: Első lépésben feloszthatjuk a tömböt [2, 3, 3, 2] és [3] részre. Ezután a második lépésben feloszthatjuk a [2, 3, 3, 2] -t [2, 3, 3] és [2] -re. Ezután a harmadik lépésben feloszthatjuk a [2, 3, 3] -t [2] és [3, 3] részre. Az utolsó lépésben pedig feloszthatjuk a [3, 3] -t [3] és [3] -ra. Ennek eredményeként a válasz igaz.

Korlátok:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

Kapsz egy n hosszúságú tömböt és egy m egész számot. Meg kell határoznia, hogy lehetséges-e a tömb felosztása n nem üres tömbre egy sor lépés végrehajtásával.
Minden lépésben kiválaszthat egy legalább kettő hosszúságú meglévő tömböt (amely lehet az előző lépések eredménye), és két altömbre bonthatja, ha minden eredményül kapott altömbre az alábbiak közül legalább az egyik teljesül:

Az altömb hossza egy, ill
Az altömb elemeinek összege nagyobb vagy egyenlő, mint m.

Igazat ad vissza, ha az adott tömböt n tömbre osztja, ellenkező esetben hamis értéket ad vissza.
Megjegyzés: Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [2, 2, 1], m = 4
Kimenet: true
Magyarázat: A tömböt első lépésben feloszthatjuk [2, 2] és [1] részre. Ezután a második lépésben a [2, 2]-t feloszthatjuk [2]-re és [2]-re. Ennek eredményeként a válasz true.
2. példa:

Bemenet: nums = [2, 1, 3], m = 5
Kimenet: false
Magyarázat: Megpróbálhatjuk két különböző módon felosztani a tömböt: az első a [2, 1] és a [3], a második a [2] és az [1, 3]. Azonban mindkét módszer nem érvényes. Tehát a válasz false.
3. példa:

Bemenet: nums = [2, 3, 3, 2, 3], m = 6
Kimenet: true
Magyarázat: A tömböt első lépésben feloszthatjuk [2, 3, 3, 2] és [3] részekre. Ezután a második lépésben a [2, 3, 3, 2]-t feloszthatjuk [2, 3, 3]-ra és [2]-re. Ezután a harmadik lépésben a [2, 3, 3]-t feloszthatjuk [2]-re és [3, 3]-ra. Az utolsó lépésben pedig feloszthatjuk a [3, 3]-at [3]-ra és [3]-ra. Ennek eredményeként a válasz true.

Korlátozások:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200


Adott egy 0-indexelt egész tömb n hosszúságú nums és egy egész cél, adja vissza a párok számát (i, j), ahol 0 <= i < j < n és nums[i] + nums[j] < cél.

1. példa:

Bemenet: nums = [-1,1,2,3,1], target = 2
Kimenet: 3
Magyarázat: 3 pár index teljesíti az utasításban szereplő feltételeket:
- (0, 1) since 0 < 1 and nums[0] + nums[1] = 0 < target
- (0, 2) since 0 < 2 and nums[0] + nums[2] = 1 < target
- (0, 4) since 0 < 4 and nums[0] + nums[4] = 0 < target
Ne feledje, hogy a (0, 3) nem számít, mivel a nums[0] + nums[3] nem kisebbek a célnál.

2. példa:

Bemenet: nums = [-6,2,5,-2,-7,-1,3], target = -2
Kimenet: 10
Magyarázat: 10 indexpár van, amely megfelel az utasításban szereplő feltételeknek:
- (0, 1) since 0 < 1 and nums[0] + nums[1] = -4 < target
- (0, 3) since 0 < 3 and nums[0] + nums[3] = -8 < target
- (0, 4) since 0 < 4 and nums[0] + nums[4] = -13 < target
- (0, 5) since 0 < 5 and nums[0] + nums[5] = -7 < target
- (0, 6) since 0 < 6 and nums[0] + nums[6] = -3 < target
- (1, 4) since 1 < 4 and nums[1] + nums[4] = -5 < target
- (3, 4) since 3 < 4 and nums[3] + nums[4] = -9 < target
- (3, 5) since 3 < 5 and nums[3] + nums[5] = -3 < target
- (4, 5) since 4 < 5 and nums[4] + nums[5] = -8 < target
- (4, 6) since 4 < 6 and nums[4] + nums[6] = -4 < target

Korlátozások:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Adott egy 0 indexelt n hosszúságú egész tömb és egy egész cél száma, adja vissza az (i, j) párok számát, ahol 0 <= i < j < n és nums[i] + nums[j] < cél.

1. példa:

Bemenet: nums = [-1,1,2,3,1], target = 2
Kimenet: 3
Magyarázat: 3 indexpár van, amelyek megfelelnek az állítás feltételeinek:
- (0, 1) since 0 < 1 and nums[0] + nums[1] = 0 < target
- (0, 2) since 0 < 2 and nums[0] + nums[2] = 1 < target
- (0, 4) since 0 < 4 and nums[0] + nums[4] = 0 < target
Vegye figyelembe, hogy a (0, 3) nem számít, mivel a nums[0] + nums[3] nem szigorúan kisebb, mint a cél.

2. példa:

Bemenet: nums = [-6,2,5,-2,-7,-1,3], target = -2
Kimenet: 10
Magyarázat: 10 indexpár van, amelyek megfelelnek az állítás feltételeinek:
- (0, 1) since 0 < 1 and nums[0] + nums[1] = -4 < target
- (0, 3) since 0 < 3 and nums[0] + nums[3] = -8 < target
- (0, 4) since 0 < 4 and nums[0] + nums[4] = -13 < target
- (0, 5) since 0 < 5 and nums[0] + nums[5] = -7 < target
- (0, 6) since 0 < 6 and nums[0] + nums[6] = -3 < target
- (1, 4) since 1 < 4 and nums[1] + nums[4] = -5 < target
- (3, 4) since 3 < 4 and nums[3] + nums[4] = -9 < target
- (3, 5) since 3 < 5 and nums[3] + nums[5] = -3 < target
- (4, 5) since 4 < 5 and nums[4] + nums[5] = -8 < target
- (4, 6) since 4 < 6 and nums[4] + nums[6] = -4 < target

Korlátok:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Adott egy 0-indexelt egész tömb n hosszúságú számok és egy egész cél, adja vissza a párok számát (i, j), ahol 0 <= i < j < n és számok[i] + számok[j] < cél.

1. példa:

Bemenet: nums = [-1,1,2,3,1], target = 2
Kimenet: 3
Magyarázat: 3 pár index teljesíti az utasításban szereplő feltételeket:
- (0, 1) mivel 0 < 1 és számok[0] + számok[1] = 0 < cél
- (0, 2) mivel 0 < 2 és számok[0] + számok[2] = 1 < cél
- (0, 4) mivel 0 < 4 és számok[0] + számok[4] = 0 < cél
Ne feledje, hogy a (0, 3) nem számít, mivel a számok[0] + számok[3] nem kisebbek a célnál.

2. példa:

Bemenet: nums = [-6,2,5,-2,-7,-1,3], target = -2
Kimenet: 10
Magyarázat: 10 indexpár van, amely megfelel az utasításban szereplő feltételeknek:
- (0, 1) mivel 0 < 1 és számok[0] + számok[1] = -4 < cél
- (0, 3) mivel 0 < 3 és számok[0] + számok[3] = -8 < cél
- (0, 4) mivel 0 < 4 és számok[0] + számok[4] = -13 < cél
- (0, 5) mivel 0 < 5 és számok[0] + számok[5] = -7 < cél
- (0, 6) mivel 0 < 6 és számok[0] + számok[6] = -3 < cél
- (1, 4), mivel 1 < 4 és számok[1] + számok[4] = -5 < cél
- (3, 4) mivel 3 < 4 és számok[3] + számok[4] = -9 < cél
- (3, 5) mivel 3 < 5 és számok[3] + számok[5] = -3 < cél
- (4, 5) mivel 4 < 5 és számok[4] + számok[5] = -8 < cél
- (4, 6) mivel 4 < 6 és számok[4] + számok[6] = -4 < cél

Korlátozások:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50


Kapsz egy 0-indexelt tömbhasználati korlátot, amelynek hossza n.
Az Ön feladata, hogy csoportokat hozzon létre 0 és n - 1 közötti számok használatával, biztosítva, hogy az egyes számok (i) legfeljebb usageLimits[i]-szer kerüljenek felhasználásra az összes csoportban. Ezenkívül meg kell felelnie a következő feltételeknek:

Minden csoportnak különálló számokból kell állnia, ami azt jelenti, hogy egyetlen csoporton belül nem megengedettek ismétlődő számok.
Minden csoportnak (az első kivételével) szigorúan nagyobbnak kell lennie, mint az előző csoporté.

Egy egész számot ad vissza, amely a létrehozható csoportok maximális számát jelöli, miközben teljesíti ezeket a feltételeket.

Példa 1:

Bemenet: usageLimits = [1,2,5]
Kimenet: 3
Magyarázat: Ebben a példában a 0-t legfeljebb egyszer, az 1-et legfeljebb kétszer és a 2-t legfeljebb ötször használhatjuk.
A maximális számú csoport létrehozásának egyik módja a feltételek teljesítése mellett:
Az 1. csoport a [2] számot tartalmazza.
A 2. csoport az [1,2] számokat tartalmazza.
A 3. csoport a [0,1,2] számokat tartalmazza.
Kimutatható, hogy a csoportok maximális száma 3.
Tehát a kimenet 3.
Példa 2:

Bemenet: usageLimits = [2,1,2]
Kimenet: 2
Magyarázat: Ebben a példában a 0-t legfeljebb kétszer, az 1-et legfeljebb egyszer és a 2-t legfeljebb kétszer használhatjuk.
A maximális számú csoport létrehozásának egyik módja a feltételek teljesítése mellett:
Az 1. csoport a [0] számot tartalmazza.
A 2. csoport az [1,2] számokat tartalmazza.
Megmutatható, hogy a csoportok maximális száma 2.
Tehát a kimenet 2.

Példa 3:

Bemenet: usageLimits = [1,1]
Kimenet: 1
Magyarázat: Ebben a példában a 0-t és az 1-et is legfeljebb egyszer használhatjuk.
A maximális számú csoport létrehozásának egyik módja a feltételek teljesítése mellett:
Az 1. csoport a [0] számot tartalmazza.
Megmutatható, hogy a csoportok maximális száma 1.
Tehát a kimenet 1.

Korlátozások:

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

A rendszer 0 indexelt tömb usageLimits of length n-t kap.
Az Ön feladata, hogy csoportokat hozzon létre 0 és n - 1 közötti számokkal, biztosítva, hogy minden i szám ne legyen több, mint usageLimits[i] alkalommal az összes csoportban. A következő feltételeknek is meg kell felelnie:

Minden csoportnak különböző számokból kell állnia, ami azt jelenti, hogy egyetlen csoporton belül nem engedélyezett ismétlődő számok.
Minden csoportnak (az első kivételével) szigorúan nagyobbnak kell lennie, mint az előző csoport.

Egy egész számot ad vissza, amely a feltételek teljesítése mellett létrehozható csoportok maximális számát jelöli.

1. példa:

Bemenet: usageLimits = [1,2,5]
Kimenet: 3
Magyarázat: Ebben a példában legfeljebb egyszer, legfeljebb kétszer használhatunk 1-et és legfeljebb ötször 2-t.
A maximális számú csoport létrehozásának egyik módja a feltételek teljesítése mellett:
Az 1. csoport tartalmazza a [2] számot.
A 2. csoport az [1,2] számokat tartalmazza.
A 3. csoport a [0,1,2] számokat tartalmazza.
Kimutatható, hogy a csoportok maximális száma 3.
Tehát a kimenet 3.
2. példa:

Bemenet: usageLimits = [2,1,2]
Kimenet: 2
Magyarázat: Ebben a példában legfeljebb kétszer használhatjuk a 0-t, legfeljebb egyszer az 1-et és legfeljebb kétszer a 2-t.
A maximális számú csoport létrehozásának egyik módja a feltételek teljesítése mellett:
Az 1. csoport tartalmazza a [0] számot.
A 2. csoport az [1,2] számokat tartalmazza.
Kimutatható, hogy a csoportok maximális száma 2.
Tehát a kimenet 2.

3. példa:

Bemenet: usageLimits = [1,1]
Kimenet: 1
Magyarázat: Ebben a példában a 0-t és az 1-et is használhatjuk egyszerre.
A maximális számú csoport létrehozásának egyik módja a feltételek teljesítése mellett:
Az 1. csoport tartalmazza a [0] számot.
Kimutatható, hogy a csoportok maximális száma 1.
Tehát a kimenet 1.

Korlátok:

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

A 0-indexelt, n hosszúságú usageLimits tömb áll rendelkezésedre.
A feladatod, hogy csoportokat hozz létre az 0-tól n - 1-ig terjedő számokkal, biztosítva, hogy az egyes számok, i, legfeljebb usageLimits[i] alkalommal legyenek használva az összes csoportban. Emellett meg kell felelnie a következő feltételeknek:

- Minden csoportnak különböző számokból kell állnia, azaz egyetlen csoporton belül sem lehetnek ismétlődő számok.
- Minden csoport (kivéve az elsőt) hossza szigorúan nagyobb kell legyen, mint az előző csoporté.

Adj vissza egy egész számot, amely azt jelzi, hogy a maximum hány csoportot hozhatsz létre a feltételek teljesítése mellett.

Példa 1:

Input: usageLimits = [1,2,5]
Output: 3
Magyarázat: Ebben a példában a 0-t legfeljebb egyszer, az 1-et legfeljebb kétszer, a 2-t pedig legfeljebb ötször használhatjuk.
Egy módja annak, hogy a feltételek teljesítése mellett a maximális számú csoportot hozzuk létre:
Az 1. csoport tartalmazza a számot [2].
A 2. csoport tartalmazza a számokat [1,2].
A 3. csoport tartalmazza a számokat [0,1,2].
Megmutatható, hogy a maximális csoportok száma 3.
Tehát a kimenet 3.

Példa 2:

Input: usageLimits = [2,1,2]
Output: 2
Magyarázat: Ebben a példában a 0-t legfeljebb kétszer, az 1-et legfeljebb egyszer, a 2-t pedig legfeljebb kétszer használhatjuk.
Egy módja annak, hogy a feltételek teljesítése mellett a maximális számú csoportot hozzuk létre:
Az 1. csoport tartalmazza a számot [0].
A 2. csoport tartalmazza a számokat [1,2].
Megmutatható, hogy a maximális csoportok száma 2.
Tehát a kimenet 2.

Példa 3:

Input: usageLimits = [1,1]
Output: 1
Magyarázat: Ebben a példában mind a 0, mind az 1 legfeljebb egyszer használható.
Egy módja annak, hogy a feltételek teljesítése mellett a maximális számú csoportot hozzuk létre:
Az 1. csoport tartalmazza a számot [0].
Megmutatható, hogy a maximális csoportok száma 1.
Tehát a kimenet 1.

Korlátozások:

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


Adott egy 0-indexelt tömb, a nums, amely n egész számot tartalmaz.
 Minden másodpercben végrehajtod a következő műveletet a tömbön:

Minden i indexre a [0, n - 1] tartományban cseréld ki nums[i]-t az alábbiak közül: nums[i], nums[(i - 1 + n) % n], vagy nums[(i + 1) % n].

Ne feledd, hogy az összes elem egyszerre lesz kicserélve.
Térj vissza a minimális másodpercek számával, amelyek szükségesek ahhoz, hogy az összes elem egyenlővé váljon a nums tömbben.

Példa 1:

Input: nums = [1,2,1,2]
Output: 1
Magyarázat: Az alábbi módon 1 másodperc alatt egyenlővé tehetjük a tömböt:

- Az 1. másodpercben cseréld ki az értékeket minden indexnél a következőre: [nums[3], nums[1], nums[3], nums[3]]. A csere után nums = [2, 2, 2, 2].
 Bizonyítható, hogy 1 másodperc a minimális idő, amely szükséges a tömb egyenlővé tételéhez.

Példa 2:

 Input: nums = [2,1,3,3,2]
Output: 2
Magyarázat: Az alábbi módon 2 másodperc alatt egyenlővé tehetjük a tömböt:
- Az 1. másodpercben cseréld ki az értékeket minden indexnél a következőre: [nums[0], nums[2], nums[2], nums[2], nums[3]]. A csere után nums = [2, 3, 3, 3, 3].
- A 2. másodpercben cseréld ki az értékeket minden indexnél a következőre: [nums[1], nums[1], nums[2], nums[3], nums[4]]. A csere után nums = [3, 3, 3, 3, 3].
"Bizonyítható, hogy 2 másodperc a minimum másodpercek száma, ami szükséges a tömb kiegyenlítéséhez."

Példa 3:

Input: nums = [5,5,5,5]
Output: 0
Magyarázat: Nem szükséges semmilyen műveletet végrehajtani, mivel az eredeti tömb összes eleme már megegyezik.

  Korlátozások:

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

Kap egy 0-indexelt tömbszámokat, amelyek n egész számot tartalmaznak.
Minden másodpercben a következő műveletet hajtja végre a tömbön:

A [0, n - 1] tartományban lévő minden i indexhez cserélje ki a nums[i] értéket nums[i], nums[(i - 1 + n) % n] vagy nums[(i + 1) % n] értékre.

Ne feledje, hogy az összes elem egyszerre cserélődik.
Azt a minimális másodpercszámot adja vissza, amely ahhoz szükséges, hogy a tömb összes eleme egyenlő legyen.

1. példa:

Bemenet: nums = [1,2,1,2]
Kimenet: 1
Magyarázat: A tömböt 1 másodperc alatt kiegyenlíthetjük a következő módon:
- 1^ másodperckor cserélje ki az egyes indexek értékeit a következőre: [nums[3],nums[1],nums[3],nums[3]]. Csere után nums = [2,2,2,2].
Bizonyítható, hogy 1 másodperc a tömb kiegyenlítéséhez szükséges minimális másodperc.

2. példa:

Bemenet: nums = [2,1,3,3,2]
Kimenet: 2
Magyarázat: A tömböt 2 másodperc alatt kiegyenlíthetjük a következő módon:
- 1^ másodperckor cserélje ki az egyes indexek értékeit a következőre: [nums[0],nums[2],nums[2],nums[2],nums[3]]. csere után nums = [2,3,3,3,3].
- A 2^. másodpercben cserélje ki az egyes indexek értékeit a következőre: [nums[1],nums[1],nums[2],nums[3],nums[4]]csere után nums = [3,3,3,3,3].
Bizonyítható, hogy 2 másodperc a tömb kiegyenlítéséhez szükséges minimális másodpercszám.

3. példa:

Bemenet: nums = [5,5,5,5]
Kimenet: 0
Magyarázat: Nem kell semmilyen műveletet végrehajtanunk, mivel a kezdeti tömb minden eleme azonos.

Korlátok:

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

Kapsz egy 0-indexelt tömb számokat, amelyek n egész számot tartalmaznak.
Minden másodpercenként a következő műveletet hajtjuk végre a tömbön:

A [0, n - 1] tartományban lévő minden i indexnél cserélje ki a nums[i] értéket a nums[i], a nums[(i - 1 + n) % n] vagy a nums [(i + 1) % n ].

Vegye figyelembe, hogy az összes elem egyszerre cserélődik ki.
Adja vissza azt a minimális számú másodpercet, amely ahhoz szükséges, hogy a tömb összes elemének száma egyenlő legyen.

1. példa:

Bemenet: nums = [1,2,1,2]
Kimenet: 1
Magyarázat: A tömböt 1 másodperc alatt kiegyenlíthetjük a következő módon:
- Az 1. másodpercben cserélje ki az egyes indexek értékeit a következőre: [nums[3], nums[1], nums[3], nums[3]]. Csere után a nums = [2,2,2,2].
Bizonyítható, hogy a tömb kiegyenlítéséhez 1 másodperc a minimális másodperc.

2. példa:

Bemenet: nums = [2,1,3,3,2]
Kimenet: 2
Magyarázat: A tömböt 2 másodperc alatt kiegyenlíthetjük a következő módon:
- Az 1. másodpercben cserélje ki az egyes indexek értékeit a következőre: [nums[0], nums[2], nums[2], nums[2], nums[3]]. Csere után a nums = [2,3,3,3,3].
- A 2. másodpercben cserélje ki az egyes indexek értékeit a következőre: [nums[1], nums[1], nums[2], nums[3], nums[4]]. Csere után a nums = [3,3,3,3,3].
Bizonyítható, hogy a tömb kiegyenlítéséhez 2 másodperc a minimális másodperc.

3. példa:

Bemenet: nums= [5,5,5,5]
Kimenet: 0
Magyarázat: Nem kell semmilyen műveletet végrehajtanunk, mivel a kezdeti tömb minden eleme azonos.

Korlátozások:

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


Adott két pozitív egész szám, alacsony és magas sztringként ábrázolva, keresse meg a lépésszámok számát az inkluzív tartományban [low, high].
A léptetőszám olyan egész szám, amelynek minden szomszédos számjegye abszolút különbsége pontosan 1.
Egy egész számot ad eredményül, amely a befogadó tartományban lévő lépésszámok számát jelöli [low, high].
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10 ^ 9 + 7.
Megjegyzés: A léptető számnak nem lehet kezdő nullája.

1. példa:

Bemenet: low = "1", high = "11"
Kimenet: 10
Magyarázat: Az [1,11] tartományban a lépésszámok a következők: 1, 2, 3, 4, 5, 6, 7, 8, 9 és 10. Összesen 10 lépésszám van a tartományban. Ezért a kimenet 10.
2. példa:

Bemenet: low = "90", high = "101"
Kimenet: 2
Magyarázat: A [90,101] tartomány lépőszámai a 98 és a 101. A tartományban összesen 2 lépésszám van. Ezért a kimenet 2.

Korlátok:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low és high csak számjegyekből áll.
low és high beállításnak nincs kezdő nullája.

Adott két pozitív egész szám alacsony és magas karakterláncként ábrázolva, keresse meg a léptető számok számát az [low, high] tartományban.
A léptető szám olyan egész szám, amelyben az összes szomszédos számjegy abszolút különbsége pontosan 1.
Egy egész számot ad vissza, amely az [alacsony, magas] tartományba eső léptető számok számát jelöli.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.
Megjegyzés: A lépésszámnak nem lehet kezdő nullája.

1. példa:

Bemenet: low = "1", high = "11"
Kimenet: 10
Magyarázat: A léptetési számok az [1,11] tartományban 1, 2, 3, 4, 5, 6, 7, 8, 9 és 10. A tartományban összesen 10 lépésszám található. Ezért a kimenet 10.
2. példa:

Bemenet: low = "90", high = "101"
Kimenet: 2
Magyarázat: A [90,101] tartományban a léptetési számok 98 és 101. A tartományban összesen 2 lépésszám található. Ezért a kimenet 2.

Korlátozások:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
alacsony és magas csak számjegyekből áll.
Az alacsony és a magas értékeknek nincs kezdő nullája.

Adott két pozitív egész alacsony és magas karakterláncként ábrázolva, keresse meg a léptető számok számát az [alacsony, magas] tartományban.
A léptető szám olyan egész szám, amelyben az összes szomszédos számjegy abszolút különbsége pontosan 1.
Egy egész számot ad vissza, amely az [alacsony, magas] tartományba eső léptető számok számát jelöli.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.
Megjegyzés: A lépésszámnak nem lehet kezdő nullája.

1. példa:

Bemenet: low = "1", high = "11"
Kimenet: 10
Magyarázat: A léptetési számok az [1,11] tartományban 1, 2, 3, 4, 5, 6, 7, 8, 9 és 10. A tartományban összesen 10 lépésszám található. Ezért a kimenet 10.
2. példa:

Bemenet: low = "90", high = "101"
Kimenet: 2
Magyarázat: A [90,101] tartományban a léptetési számok 98 és 101. A tartományban összesen 2 lépésszám található. Ezért a kimenet 2.

Korlátozások:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
alacsony és magas csak számjegyekből áll.
Az alacsony és a magas értékeknek nincs kezdő nullája.


Adott két 0-indexált, egyenlő hosszúságú egész számtömb nums1 és nums2. Minden másodpercben, minden indexre 0 <= i < nums1.length, a nums1[i] értéke növekszik a nums2[i]-vel. Miután ez megtörtént, elvégezhetjük a következő műveletet:

Válasszon egy indexet 0 <= i < nums1.length és tegye nums1[i] = 0 értékűvé.

Adott egy egész szám x is.
Adja vissza azt a minimális időt, amely alatt a nums1 összes elemének összege kisebb vagy egyenlő x-szel, vagy -1-et, ha ez nem lehetséges.

Példa 1:

Bemenet: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Kimenet: 3
Magyarázat:
Az 1. másodpercben a műveletet i = 0-ra alkalmazzuk, tehát nums1 = [0,2+2,3+3] = [0,4,6].
A 2. másodpercben a műveletet az i = 1-re alkalmazzuk. Ezért nums1 = [0+1,0,6+3] = [1,0,9].
A 3. másodpercben alkalmazzuk a műveletet i = 2-re. Ezért nums1 = [1+1,0+2,0] = [2,2,0].
Most nums1 összege = 4. Megmutatható, hogy ezek a műveletek optimálisak, így visszaadjuk a 3-at.

2. példa:

Bemenet: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Kimenet: -1
Magyarázat: Megmutatható, hogy a nums1 összege mindig nagyobb lesz, mint x, függetlenül attól, hogy milyen műveleteket hajtunk végre.

Korlátozások:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

Két 0-indexelt egész szám tömböt kapsz, amelyek száma1 és szám2 egyenlő hosszú. Minden 0 <= i < szám1.hosszú index esetén a szám1[i] értéke minden másodpercben nums2[i]-vel nő. Miután ez megtörtént, a következő műveletet hajthatja végre:

Válasszon egy indexet 0 <= i < szám1.hosszúság, és állítsa be a szám1[i] = 0 értéket.

Adunk egy x egész számot is.
Adja vissza azt a minimális időt, amely alatt a nums1 összes elemének összege kisebb vagy egyenlő legyen x-szel, vagy -1-gyel, ha ez nem lehetséges.

Példa 1:

Bemenet: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Kimenet: 3
Magyarázat:
Az 1. másodpercre az i = 0-ra vonatkozó műveletet alkalmazzuk. Ezért nums1 = [0,2+2,3+3] = [0,4,6].
A 2. másodpercre az i = 1-re vonatkozó műveletet alkalmazzuk. Ezért nums1 = [0+1,0,6+3] = [1,0,9].
A 3. másodpercre az i = 2-re vonatkozó műveletet alkalmazzuk. Ezért nums1 = [1+1,0+2,0] = [2,2,0].
Most a számok összege1 = 4. Megmutatható, hogy ezek a műveletek optimálisak, így 3-at adunk vissza.

Példa 2:

Bemenet: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Kimenet: -1
Magyarázat: Megmutatható, hogy a szám1 összege mindig nagyobb lesz x-nél, függetlenül attól, hogy milyen műveleteket hajtunk végre.

Korlátozások:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

Két 0-indexelt egész szám tömböt kapsz, amelyek száma1 és szám2 egyenlő hosszú. Minden 0 <= i < szám1.hosszú index esetén a szám1[i] értéke minden másodpercben nums2[i]-vel nő. Miután ez megtörtént, a következő műveletet hajthatja végre:

Válasszon egy indexet 0 <= i < szám1.hosszúság, és állítsa be a szám1[i] = 0 értéket.

Adunk egy x egész számot is.
Adja vissza azt a minimális időt, amely alatt a nums1 összes elemének összege kisebb vagy egyenlő legyen x-szel, vagy -1-gyel, ha ez nem lehetséges.

1. példa:

Bemenet: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Kimenet: 3
Magyarázat:
Az 1. másodpercre az i = 0-ra vonatkozó műveletet alkalmazzuk. Ezért nums1 = [0,2+2,3+3] = [0,4,6].
A 2. másodpercre az i = 1-re vonatkozó műveletet alkalmazzuk. Ezért nums1 = [0+1,0,6+3] = [1,0,9].
A 3. másodpercre az i = 2-re vonatkozó műveletet alkalmazzuk. Ezért nums1 = [1+1,0+2,0] = [2,2,0].
Most a számok összege1 = 4. Megmutatható, hogy ezek a műveletek optimálisak, így 3-at adunk vissza.

2. példa:

Bemenet: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Kimenet: -1
Magyarázat: Megmutatható, hogy a szám1 összege mindig nagyobb lesz x-nél, függetlenül attól, hogy milyen műveleteket hajtanak végre.

Korlátozások:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6


Adunk egy 2D egész tömb koordinátáit és egy k egész számot, ahol a coordinates[i] = [x_i, y_i] a 2D sík i^edik pontjának koordinátái.
Két pont (x_1, y_1) és (x_2, y_2) távolságát a következőképpen határozzuk meg: (x1 XOR x2) + (y1 XOR y2), ahol XOR a bitenkénti XOR művelet.
Adja vissza az (i, j) párok számát úgy, hogy i < j, és az i és j pontok távolsága egyenlő k-val.

1. példa:

Bemenet: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Kimenet: 2
Magyarázat: A következő párokat választhatjuk:
- (0,1): Mert van (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Mert van (1 XOR 5) + (3 XOR 2) = 5.

2. példa:

Bemenet: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Kimenet: 10
Magyarázat: Bármely két kiválasztott pár távolsága 0 lesz. 10 módja van két pár kiválasztásának.

Korlátozások:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Adott egy 2D-s egész számú koordinátatömb és egy egész számú k, ahol a koordináták[i] = [x_i, y_i] a 2D-sík i^-edik pontjának koordinátái.
Két pont (x_1, y_1) és (x_2, y_2) közötti távolságot úgy definiáljuk, hogy (x1 XOR x2) + (y1 XOR y2), ahol az XOR a bitenkénti XOR művelet.
Az olyan (i, j) párok számát adja vissza, amelyeknél i < j, és az i és j pontok közötti távolság egyenlő k-val.

Példa 1:

Bemenet:coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Kimenet: 2
Magyarázat: Választhatjuk a következő párokat:
- (0,1): Mert (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Mert (1 XOR 5) + (3 XOR 2) = 5.

2. példa:

Bemenet: coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Kimenet: 10
Magyarázat: Bármely két kiválasztott pár távolsága 0. Két pár kiválasztására 10 lehetőség van.

Korlátozások:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Adunk egy 2D egész tömb koordinátáit és egy k egész számot, ahol a koordináták[i] = [x_i, y_i] a 2D sík i^edik pontjának koordinátái.
Két pont (x_1, y_1) és (x_2, y_2) távolságát a következőképpen határozzuk meg: (x1 XOR x2) + (y1 XOR y2), ahol XOR a bitenkénti XOR művelet.
Adja vissza az (i, j) párok számát úgy, hogy i < j, és az i és j pontok távolsága egyenlő k-val.

1. példa:

Bemenet: coordinates = [[1,2], [4,2], [1,3], [5,2]], k = 5
Kimenet: 2
Magyarázat: A következő párokat választhatjuk:
- (0,1): Mert van (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Mert van (1 XOR 5) + (3 XOR 2) = 5.

2. példa:

Bemenet: coordinates = [[1,3], [1,3], [1,3], [1,3], [1,3]], k = 0
Kimenet: 10
Magyarázat: Bármely két kiválasztott pár távolsága 0 lesz. 10 módja van két pár kiválasztásának.

Korlátozások:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100


Kapsz egy egész tömb számát, valamint két pozitív egész számot, m és k.
A maximális összeget adja vissza az összes majdnem egyedi, k szám hosszúságú altömbből. Ha nem létezik ilyen altömb, adjon vissza 0-t.
A számok altömbje szinte egyedi, ha legalább m különálló elemet tartalmaz.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [2,6,7,3,1,7], m = 3, k = 4
Kimenet: 18
Magyarázat: 3 szinte egyedi altömb van, amelyek mérete k = 4. Ezek a következők: [2, 6, 7, 3], [6, 7, 3, 1] és [7, 3, 1, 7]. Ezen altömbök közül a legnagyobb összegű [2, 6, 7, 3], amelynek összege 18.

2. példa:

Bemenet: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Kimenet: 23
Magyarázat: 5 szinte egyedi k méretű altömb létezik. Ezek az altömbök a következők: [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] és [4, 5, 4]. Ezen altáblák közül a legnagyobb összegű [5, 9, 9], amelynek összege 23.

3. példa:

Bemenet: nums = [1,2,1,2,1,2,1], m = 3, k = 3
Kimenet: 0
Magyarázat: Az adott tömbben [1,2,1,2,1,2,1] nincsenek olyan k = 3 méretű altömbök, amelyek legalább m = 3 különböző elemet tartalmaznának. Ezért nem léteznek szinte egyedi altömbök, és a maximális összeg 0.

Korlátozások:

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

Kapsz egy egész tömb számot és két pozitív egész számot, m és k.
Az összes k hosszúságú szinte egyedi résztömb maximális összegét adja eredményül. Ha nem létezik ilyen résztömb, adja vissza a 0 értéket.
A numok egy résztömbje szinte egyedi, ha legalább m különböző elemet tartalmaz.
A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [2,6,7,3,1,7], m = 3, k = 4
Kimenet: 18
Magyarázat: 3 majdnem egyedi, k = 4 méretű altömb van. Ezek az altömbök a következők: [2, 6, 7, 3], [6, 7, 3, 1] és [7, 3, 1, 7]. Ezek közül a résztömbök közül a maximális összeg a [2, 6, 7, 3], amelynek összege 18.

2. példa:

Bemenet: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Kimenet: 23
Magyarázat: 5 szinte egyedi, k méretű résztömb van. Ezek az altömbök a következők: [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] és [4, 5, 4]. Ezek közül az altömbök közül a maximális összeg az [5, 9, 9], amelynek összege 23.

3. példa:

Bemenet: nums = [1,2,1,2,1,2,1], m = 3, k = 3
Kimenet: 0
Magyarázat: Nincsenek k = 3 méretű résztömbök, amelyek legalább m = 3 különböző elemet tartalmaznak az adott tömbben [1,2,1,2,1,2,1]. Ezért nem léteznek szinte egyedi résztömbök, és a maximális összeg 0.

Korlátok:

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9


Kezdetben 100 dolláros bankszámlaegyenleggel rendelkezik.
Kap egy egész számot, a purchaseAmount-ot, amely azt az összeget jelöli, amelyet egy vásárlásra fog költeni dollárban.
Az üzletben, ahol a vásárlást végzi, a vásárlási összeget 10 legközelebbi többszörösére kerekítik. Más szóval, Ön egy olyan nemnegatív összeget fizet, a kerekített összeget, hogy a kerekített összeg 10 többszöröse legyen, és az abs(kerekített összeg - vásárlási összeg) minimális legyen.
Ha 10 több legközelebbi többszöröse van, akkor a legnagyobb többszörös kerül kiválasztásra.
Egy egész számot ad vissza, amely a számla egyenlegét jelöli, miután a boltban purchaseAmount dollár értékű vásárlást hajtott végre.
Megjegyzés: Ebben a feladatban a 0 a 10 többszörösének tekintendő.

Példa 1:

Bemenet: purchaseAmount = 9
Kimenet: 90
Magyarázat: Ebben a példában a 10 legközelebbi többszöröse a 9-nek 10. Ezért a számlaegyenlege 100 - 10 = 90 lesz.

Példa 2:

Bemenet: purchaseAmount = 15
Kimenet: 80
Magyarázat: Ebben a példában a 15-nek két legközelebbi többszöröse van: 10 és 20. Tehát a nagyobb, 20-as többszörösét választjuk.
Így a számlaegyenleg 100 - 20 = 80 lesz.

Korlátozások:

0 <= purchaseAmount <= 100

Kezdetben 100 dollár bankszámlaegyenlege van.
Kapsz egy egész vásárlási összeget, amely azt az összeget jelenti, amelyet egy vásárlásra fordít dollárban.
Abban az üzletben, ahol vásárolni fog, a purchaseAmount a 10 legközelebbi többszörösére kerekítik. Más szavakkal, Ön egy nem negatív összeget fizet, a roundedAmount-ot úgy, hogy a roundedAmount a 10 és abs(roundedAmount - vásárlásAmount) többszöröse ) minimálisra csökken.
Ha a 10-nek egynél több legközelebbi többszöröse van, akkor a legnagyobb többszörösét választjuk.
Adjon vissza egy egész számot, amely a fiók egyenlegét jelöli, miután vásárolt összeget dollár értékben az üzletben.
Megjegyzés: Ebben a feladatban a 0 a 10 többszörösének tekinthető.

1. példa:

Input: purchaseAmount = 9
Kimenet: 90
Magyarázat: Ebben a példában 10-től 9-hez legközelebbi többszöröse 10. Így a számlaegyenleg 100-10 = 90 lesz.

2. példa:

Input: purchaseAmount = 15
Kimenet: 80
Magyarázat: Ebben a példában 10 és 15 között van két legközelebbi többszörös: 10 és 20. Tehát a nagyobbik többszöröse, a 20 kerül kiválasztásra.
Így a számlaegyenleg 100-20 = 80 lesz.

Korlátozások:

0 <= purchaseAmount <= 100

Kezdetben 100 dollár bankszámlaegyenlege van.
Kapsz egy egész vásárlási összeget, amely azt az összeget jelenti, amelyet egy vásárlásra fordít dollárban.
Abban az üzletben, ahol vásárolni fog, a vásárlás összegét a 10 legközelebbi többszörösére kerekítik. Más szavakkal, Ön egy nem negatív összeget fizet, a roundedAmount-ot úgy, hogy a roundedAmount a 10 és abs(roundedAmount - vásárlási összeg) többszöröse ) minimálisra csökken.
Ha a 10-nek egynél több legközelebbi többszöröse van, akkor a legnagyobb többszörösét választjuk.
Adjon vissza egy egész számot, amely a fiók egyenlegét jelöli, miután vásárolt összeget dollár értékben az üzletben.
Megjegyzés: Ebben a feladatban a 0 a 10 többszörösének számít.

1. példa:

Bemenet: purchaseAmount = 9
Kimenet: 90
Magyarázat: Ebben a példában 10-től 9-hez legközelebbi többszöröse 10. Így a számlaegyenleg 100-10 = 90 lesz.

2. példa:

Bemenet: purchaseAmount = 15
Kimenet: 80
Magyarázat: Ebben a példában 10 és 15 között van két legközelebbi többszörös: 10 és 20. Tehát a nagyobbik többszöröse, a 20 kerül kiválasztásra.
Így a számlaegyenleg 100-20 = 80 lesz.

Korlátozások:

0 <= purchaseAmount <= 100


Adott egy szavakból és egy s karakterláncból álló tömb, határozza meg, hogy s a szavak rövidítése-e.
Az s karakterláncot akkor tekintjük szavak betűszavának, ha a szavak minden egyes karakterláncának első karakterének sorrendben történő összefűzésével alkotható. Például az „ab” képezhető [„alma”, „banán”] szóból, de nem képezhető [„medve”, „földi cápa”] szóból.
Igazat ad vissza, ha s szavakból álló betűszó, ellenkező esetben hamisat.

1. példa:

Bemenet: words = ["alice","bob","charlie"], s = "abc"
Kimenet: true
Magyarázat: Az "alice", "bob" és "charlie" szavak első karaktere "a", "b" és "c". Ezért s = "abc" a mozaikszó.

2. példa:

Bemenet: words = ["an","apple"], s = "a"
Kimenet: hamis
Magyarázat: Az "an" és az "alma" szavak első karaktere "a" és "a".
A karakterek összefűzésével kialakított mozaikszó az "aa".
Ezért az s = "a" nem a mozaikszó.

3. példa:

Bemenet:words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Kimenet: true
Magyarázat: A tömbben lévő szavak első karakterének összefűzésével megkapjuk az "ngguoy" karakterláncot.
Ezért s = "ngguoy" a mozaikszó.

Korlátozások:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] és s kisbetűs angol betűkből áll.

Adott egy Tömb words és egy s karakterlánc, határozza meg, hogy az s words rövidítése-e.
Az s karakterlánc a words rövidítésének tekinthető, ha az egyes karakterláncok első karakterének Tömbrendben történő összefűzésével képezhető. Például az "ab" létrehozható ["alma", "banán"]-ból, de nem képezhető ["medve", "aardvark"]-ból.
Adja vissza az a kimenet igaz értéket, ha az s words rövidítése, és a kimenet hamis értéket adjon vissza.

Példa 1:

Bemenet: words = ["alice","bob","charlie"], s = "abc"
Kimenet: a kimenet igaz
Magyarázat: Az „alice”, „bob” és „charlie” szavak első karaktere „a”, „b” és „c”. Ezért az s = "abc" a rövidítés.

Példa 2:

Bemenet: words = ["an","apple"], s = "a"
Kimenet: a kimenet hamis
Magyarázat: Az „an” és az „alma” szavak első karaktere „a”, illetve „a”.
Az e karakterek összefűzésével képzett rövidítés „aa”.
Ezért az s = "a" nem a rövidítés.

Példa 3:

Bemenet: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Kimenet: igaz
Magyarázat: A tömbben lévő szavak első karakterének összefűzésével a „ngguoy” karakterláncot kapjuk.
Ezért az s = "ngguoy" a mozaikszó.

Korlátozások:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] és s kisbetűs angol betűkből áll.

Adott egy sor szavak és egy s karakterlánc, határozza meg, hogy az s szavak rövidítése-e.
Az s karakterlánc a szavak rövidítésének tekinthető, ha az egyes karakterláncok első karakterének sorrendben történő összefűzésével képezhető. Például az "ab" létrehozható ["alma", "banán"]-ból, de nem képezhető ["medve", "aardvark"]-ból.
Adja vissza az igaz értéket, ha az s szavak rövidítése, és hamis értéket adjon vissza.

1. példa:

Bemenet: words = ["alice","bob","charlie"], s = "abc"
Kimenet: igaz
Magyarázat: Az „alice”, „bob” és „charlie” szavak első karaktere „a”, „b” és „c”. Ezért az s = "abc" a mozaikszó.

2. példa:

Bemenet: words = ["an","alma"], s = "a"
Kimenet: hamis
Magyarázat: Az „an” és az „alma” szavak első karaktere „a”, illetve „a”.
Az e karakterek összefűzésével képzett mozaikszó „aa”.
Ezért az s = "a" nem a mozaikszó.

3. példa:

Bevitel: words = ["soha","gonna","adj","fel","on","te"], s = "ngguoy"
Kimenet: igaz
Magyarázat: A tömbben lévő szavak első karakterének összefűzésével a „ngguoy” karakterláncot kapjuk.
Ezért az s = "ngguoy" a mozaikszó.

Korlátozások:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
A szavak[i] és s kisbetűkből állnak.


Kapsz egy n egész számot, amely a házak számát képviseli egy számvonalon, 0-tól n - 1-ig számozva.
Ezenkívül kap egy 2D egész tömböt, ahol ajánlatok[i] = [start_i, end_i, gold_i], jelezve, hogy i^th vevő meg akarja vásárolni az összes házat start_i-től end_i-ig gold_i mennyiségű aranyért.
Értékesítőként az a célja, hogy maximalizálja bevételeit azáltal, hogy stratégiailag kiválasztja és eladja a házakat a vásárlóknak.
Adja vissza a maximálisan megszerezhető aranymennyiséget.
Ne feledje, hogy különböző vásárlók nem vásárolhatják meg ugyanazt a házat, és egyes házak eladatlanul maradhatnak.

1. példa:

Bemenet:n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
Kimenet: 3
Magyarázat: 5 ház van 0-tól 4-ig számozva, és 3 vételi ajánlat van.
A házakat [0,0] és 1^st vevő között értékesítjük 1 aranyért, és a házak [1,3] és 3^rd vevő között 2 aranyért.
Bebizonyítható, hogy 3 a maximális aranymennyiség, amit elérhetünk.

2. példa:

Bemenet: n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
Kimenet: 10
Magyarázat: 5 ház van 0-tól 4-ig számozva, és 3 vételi ajánlat van.
[0,2] és 2^nd vevő közötti házakat adunk el 10 aranyért.
Bebizonyítható, hogy 10 a maximális aranymennyiség, amit elérhetünk.

Korlátok:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

Kapunk egy n egész számot, amely a házak számát jelöli egy számegyenesen, 0-tól n-1-ig számozva.
Ezenkívül kap egy 2D egész tömböt, ahol ajánlatok[i] = [start_i, end_i, gold_i], jelezve, hogy az i^. vevő meg akarja vásárolni az összes házat start_i és end_i között gold_i mennyiségű aranyért.
Értékesítőként az Ön célja, hogy maximalizálja bevételét a házak stratégiai kiválasztásával és vevőknek történő eladásával.
Adja vissza a maximálisan kereshető aranyat.
Vegye figyelembe, hogy különböző vásárlók nem vásárolhatják meg ugyanazt a házat, és előfordulhat, hogy egyes házak eladatlanok maradnak.

1. példa:

Bemenet: n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
Kimenet: 3
Magyarázat: 5 ház van számozva 0-tól 4-ig, és 3 vételi ajánlat van.
A házakat [0,0]-tól 1^. vevőig 1 aranyért, az [1,3]-tól 3^. vevőig terjedő házakat 2 aranyért adjuk el.
Bizonyítható, hogy a 3 a maximális aranymennyiség, amit elérhetünk.

2. példa:

Bemenet: n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
Kimenet: 10
Magyarázat: 5 ház van számozva 0-tól 4-ig, és 3 vételi ajánlat van.
Házakat adunk el a [0,2] és a 2^. vevő között 10 aranyért.
Bizonyítható, hogy 10 a maximális aranymennyiség, amit elérhetünk.

Korlátozások:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3

Kapsz egy n egész számot, amely a házak számát képviseli egy számvonalon, 0-tól n - 1-ig számozva.
Ezenkívül kap egy 2D egész tömböt, ahol ajánlatok[i] = [start_i, end_i, gold_i], jelezve, hogy i^th vevő meg akarja vásárolni az összes házat start_i-től end_i-ig gold_i mennyiségű aranyért.
Értékesítőként az a célja, hogy maximalizálja bevételeit azáltal, hogy stratégiailag kiválasztja és eladja a házakat a vásárlóknak.
Adja vissza a maximálisan megszerezhető aranymennyiséget.
Ne feledje, hogy különböző vásárlók nem vásárolhatják meg ugyanazt a házat, és egyes házak eladatlanul maradhatnak.

1. példa:

Bemenet: n = 5, offers= [[0,0,1],[0,2,2],[1,3,2]]
Kimenet: 3
Magyarázat: 5 ház van 0-tól 4-ig számozva, és 3 vételi ajánlat van.
A házakat [0,0] és 1^st vevő között értékesítjük 1 aranyért, és a házak [1,3] és 3^rd vevő között 2 aranyért.
Bebizonyítható, hogy 3 a maximális aranymennyiség, amit elérhetünk.

2. példa:

Bemenet: n = 5, ajánlatok = [[0,0,1],[0,2,10],[1,3,2]]
Kimenet: 10
Magyarázat: 5 ház van 0-tól 4-ig számozva, és 3 vételi ajánlat van.
[0,2] és 2^nd vevő közötti házakat adunk el 10 aranyért.
Bebizonyítható, hogy 10 a maximális aranymennyiség, amit elérhetünk.

Korlátok:

1 <= n <= 10^5
1 <= offers.length <= 10^5
offers[i].length == 3
0 <= start_i <= end_i <= n - 1
1 <= gold_i <= 10^3


Adott két pozitív egész szám, az alacsony és a magas.
Egy 2 * n számjegyből álló x egész szám szimmetrikus, ha x első n számjegyének összege megegyezik x utolsó n számjegyének összegével. A páratlan számjegyű számok soha nem szimmetrikusak.
A [low, high] tartományban lévő szimmetrikus egész számok számát adja vissza.

Példa 1:

Bemenet: low = 1, high = 100
Kimenet: 9
Magyarázat: 1 és 100 között 9 szimmetrikus egész szám van: 11, 22, 33, 44, 55, 66, 77, 88 és 99.

Példa 2:

Bemenet: low = 1200, high = 1230
Kimenet: 4
Magyarázat: 1200 és 1230 között 4 szimmetrikus egész szám van: 1203, 1212, 1221 és 1230.

Korlátozások:

1 <= low <= high <= 10^4

Két pozitív egész számot kapsz: alacsony és magas.
Egy 2 * n számjegyből álló x egész szám szimmetrikus, ha x első n számjegyének összege egyenlő x utolsó n számjegyének összegével. A páratlan számjegyű számok soha nem szimmetrikusak.
A szimmetrikus egész számok számát adja vissza a [low, high] tartományban.

1. példa:

Bemenet: low = 1, high = 100
Kimenet: 9
Magyarázat: 9 szimmetrikus egész szám van 1 és 100 között: 11, 22, 33, 44, 55, 66, 77, 88 és 99.

2. példa:

Bemenet: low = 1200, high = 1230
Kimenet: 4
Magyarázat: 4 szimmetrikus egész szám van 1200 és 1230 között: 1203, 1212, 1221 és 1230.

Korlátozások:

1 <= low <= high <= 10^4

Két pozitív egész számot kapsz, alacsony és magas.
Egy 2 * n számjegyből álló x egész szám szimmetrikus, ha x első n számjegyének összege megegyezik x utolsó n számjegyének összegével. A páratlan számú számjegyű számok soha nem szimmetrikusak.
A szimmetrikus egész számok számát adja vissza az [alacsony, magas] tartományban.

1. példa:

Bemenet: alacsony = 1, magas = 100
Kimenet: 9
Magyarázat: 9 szimmetrikus egész szám van 1 és 100 között: 11, 22, 33, 44, 55, 66, 77, 88 és 99.

2. példa:

Bemenet: alacsony = 1200, magas = 1230
Kimenet: 4
Magyarázat: 1200 és 1230 között 4 szimmetrikus egész szám van: 1203, 1212, 1221 és 1230.

Korlátok:

1 < = alacsony <= magas <= 10^4


Két s1 és s2 karakterláncot kapsz, mindkettő 4 hosszúságú, és kisbetűs angol betűkből áll.
A következő műveletet tetszőleges számú alkalommal alkalmazhatja a két karakterlánc bármelyikére:

Válasszon ki tetszőleges két i és j indexet úgy, hogy j - i = 2, majd cserélje fel a két karaktert a karakterlánc ezen indexeinél.

Ha az s1 és s2 karakterláncokat egyenlővé tudja tenni, akkor a true értéket adja vissza, ellenkező esetben a false értéket.

Példa 1:

Bemenet: s1 = "abcd", s2 = "cdab"
Kimenet: igaz
Magyarázat: A következő műveleteket tudjuk elvégezni az s1-en:
- Válassza ki az i = 0, j = 2 indexeket. A kapott karakterlánc s1 = "cbad".
- Válassza ki az i = 1, j = 3 indexeket. A kapott karakterlánc s1 = "cdab" = s2.

Példa 2:

Bemenet: s1 = "abcd", s2 = "dacb"
Kimenet: hamis
Magyarázat: A két karakterláncot nem lehet egyenlővé tenni.

Korlátozások:

s1.length == s2.length == 4
Az s1 és s2 csak kisbetűket tartalmaz angolul.

Két s1 és s2 karakterláncot kapsz, mindkettő 4 hosszúságú, és kisbetűs angol betűkből áll.
A következő műveletet tetszőleges számú alkalommal alkalmazhatja a két karakterlánc bármelyikére:

Válasszon ki tetszőleges két i és j indexet úgy, hogy j - i = 2, majd cserélje fel a két karaktert a karakterlánc ezen indexeinél.

Ha az s1 és s2 karakterláncokat egyenlővé tudja tenni, adjon vissza true-t, ha az egyenlővé tehető, és false-t, ha nem.
1. példa:

Bemenet: s1 = "abcd", s2 = "cdab"
Kimenet: igaz
Magyarázat: A következő műveleteket tudjuk elvégezni az s1-en:
- Válassza ki az i = 0, j = 2 indexeket. A kapott karakterlánc s1 = "cbad".
- Válassza ki az i = 1, j = 3 indexeket. A kapott karakterlánc s1 = "cdab" = s2.

2. példa:

Bemenet: s1 = "abcd", s2 = "dacb"
Kimenet: hamis
Magyarázat: A két karakterláncot nem lehet egyenlővé tenni.

Korlátozások:

s1.length == s2.length == 4
Az s1 és s2 csak kisbetűket tartalmaz angolul.

Két karakterláncot kapsz s1 és s2, mindkettő 4 hosszúságú, kisbetűs angol betűkből áll.
A következő műveletet tetszőleges számú alkalommal alkalmazhatja a két karakterlánc bármelyikén:

Válasszon ki egy tetszőleges két i és j indexet úgy, hogy j - i = 2, majd cserélje fel a két karaktert a karakterlánc ezen indexein.

Igaz értéket ad vissza, ha az s1 és s2 sztringeket egyenlővé, egyébként hamissá teheti.

1. példa:

Bemenet: s1 = "abcd", s2 = "cdab"
Kimenet: true
Magyarázat: Az s1-en a következő műveleteket végezhetjük el:
- Válassza ki az i = 0, j = 2 indexeket. A kapott karakterlánc s1 = "cbad".
- Válassza ki az i = 1, j = 3 indexeket. Az eredményül kapott karakterlánc s1 = "cdab" = s2.

2. példa:

Bemenet: s1 = "abcd", s2 = "dacb"
Kimenet: false
Magyarázat: A két karakterláncot nem lehet egyenlővé tenni.

Korlátok:

s1.length == s2.length == 4
Az s1 és s2 csak kisbetűs angol betűkből áll.


Adott egy 0-indexált egész szám tömb nums és egy egész szám x.
Keressük meg a tömb két olyan eleme közötti legkisebb abszolút különbséget, amelyek legalább x index távolságra vannak egymástól.
Más szóval, keressünk két olyan i és j indexet, hogy abs(i - j) >= x és abs(nums[i] - nums[j]) minimális legyen.
Visszaad egy egész számot, amely a két olyan elem közötti minimális abszolút különbséget jelöli, amelyek legalább x index távolságra vannak egymástól.

Példa 1:

Bemenet: nums = [4,3,2,4], x = 2
Kimenet: 0
Magyarázat: A nums[0] = 4 és a nums[3] = 4 értéket választhatjuk.
Ezek legalább 2 index távolságra vannak egymástól, és abszolút különbségük a legkisebb, 0.
Megmutatható, hogy a 0 az optimális válasz.

2. példa:

Bemenet: nums = [5,3,2,10,15], x = 1
Kimenet: 1
Magyarázat: A nums[1] = 3 és a nums[2] = 2 értéket választhatjuk.
Ezek legalább 1 index távolságra vannak egymástól, és abszolút különbségük a legkisebb, 1.
Kimutatható, hogy az 1 az optimális válasz.

3. példa:

Bemenet: nums = [1,2,3,4], x = 3
Kimenet: 3
Magyarázat: A nums[0] = 1 és a nums[3] = 4 értéket választhatjuk.
Ezek legalább 3 index távolságra vannak egymástól, és abszolút különbségük a legkisebb, 3.
Megmutatható, hogy a 3 az optimális válasz.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot és egy x egész számot.
Keresse meg a minimális abszolút különbséget a tömb két olyan eleme között, amelyek legalább x index távolságra vannak egymástól.
Más szavakkal, keressen két i és j indexet úgy, hogy az abs(i - j) >= x és az abs(számok[i] - számok[j]) minimalizálva legyen.
Egy egész számot ad vissza, amely a minimális abszolút különbséget jelöli két olyan elem között, amelyek legalább x index távolságra vannak egymástól.

1. példa:

Bemenet: nums = [4,3,2,4], x = 2
Kimenet: 0
Magyarázat: Választhatunk nums[0] = 4 és nums[3] = 4 értéket.
Legalább 2 index távolságra vannak egymástól, és abszolút különbségük a minimum, 0.
Megmutatható, hogy a 0 az optimális válasz.

2. példa:

Bemenet: nums = [5,3,2,10,15], x = 1
Kimenet: 1
Magyarázat: Kiválaszthatunk nums[1] = 3 és nums[2] = 2.
Legalább 1 index távolságra vannak egymástól, abszolút különbségük pedig a minimum, 1.
Megmutatható, hogy az 1 az optimális válasz.

3. példa:

Bemenet: nums = [1,2,3,4], x = 3
Kimenet: 3
Magyarázat: Kiválaszthatunk nums[0] = 1 és nums[3] = 4.
Legalább 3 index távolságra vannak egymástól, abszolút különbségük pedig a minimum, 3.
Megmutatható, hogy a 3 az optimális válasz.

Korlátozások:

1 <= számok.hossz <= 10^5
1 <= szám[i] <= 10^9
0 <= x < számok.lengthKap egy 0-indexelt egész tömb számot és egy x egész számot.
Keresse meg a minimális abszolút különbséget a tömb két olyan eleme között, amelyek legalább x index távolságra vannak egymástól.
Más szavakkal, keressen két i és j indexet úgy, hogy az abs(i - j) >= x és az abs(számok[i] - számok[j]) minimalizálva legyen.
Egy egész számot ad vissza, amely a minimális abszolút különbséget jelöli két olyan elem között, amelyek legalább x index távolságra vannak egymástól.

1. példa:

Bemenet: nums = [4,3,2,4], x = 2
Kimenet: 0
Magyarázat: Választhatunk számok[0] = 4 és szám[3] = 4 értéket.
Legalább 2 index távolságra vannak egymástól, és abszolút különbségük a minimum, 0.
Megmutatható, hogy a 0 az optimális válasz.

2. példa:

Bemenet: nums = [5,3,2,10,15], x = 1
Kimenet: 1
Magyarázat: Kiválaszthatunk nums[1] = 3 és nums[2] = 2.
Legalább 1 index távolságra vannak egymástól, abszolút különbségük pedig a minimum, 1.
Megmutatható, hogy az 1 az optimális válasz.

3. példa:

Bemenet: nums = [1,2,3,4], x = 3
Kimenet: 3
Magyarázat: Kiválaszthatunk nums[0] = 1 és nums[3] = 4.
Legalább 3 index távolságra vannak egymástól, abszolút különbségük pedig a minimum, 3.
Megmutatható, hogy a 3 az optimális válasz.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot és egy x egész számot.
Keresse meg a minimális abszolút különbséget a tömb két olyan eleme között, amelyek legalább x index távolságra vannak egymástól.
Más szavakkal, keressen két i és j indexet úgy, hogy az abs(i - j) >= x és az abs(számok[i] - számok[j]) minimalizálva legyen.
Egy egész számot ad vissza, amely a minimális abszolút különbséget jelöli két olyan elem között, amelyek legalább x index távolságra vannak egymástól.

1. példa:

Bemenet: nums = [4,3,2,4], x = 2
Kimenet: 0
Magyarázat: Választhatunk számok[0] = 4 és szám[3] = 4 értéket.
Legalább 2 index távolságra vannak egymástól, és abszolút különbségük a minimum, 0.
Megmutatható, hogy a 0 az optimális válasz.

2. példa:

Bemenet: nums = [5,3,2,10,15], x = 1
Kimenet: 1
Magyarázat: Kiválaszthatunk számokat[1] = 3 és számokat[2] = 2.
Legalább 1 index távolságra vannak egymástól, abszolút különbségük pedig a minimum, 1.
Megmutatható, hogy az 1 az optimális válasz.

3. példa:

Bemenet: nums = [1,2,3,4], x = 3
Kimenet: 3
Magyarázat: Kiválaszthatunk számokat[0] = 1 és számokat[3] = 4.
Legalább 3 index távolságra vannak egymástól, abszolút különbségük pedig a minimum, 3.
Megmutatható, hogy a 3 az optimális válasz.

Korlátozások:

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


Adott pozitív egész számok: low, high és k.
Egy szám akkor szép, ha mindkét alábbi feltételnek megfelel:

A számban a páros számjegyek száma megegyezik a páratlan számjegyek számával.
A szám osztható k-val.

A [low, high] tartományban található szép egész számok számát adja vissza.

Példa 1:

Bemenet: low = 10, high = 20, k = 3
Kimenet: 2
Magyarázat: A megadott tartományban 2 szép egész szám van: [12,18].
- A 12 azért szép, mert tartalmaz 1 páratlan és 1 páros számjegyet, és osztható k = 3-mal.
- A 18 azért szép, mert tartalmaz 1 páratlan és 1 páros számjegyet, és osztható k = 3-mal.
Továbbá láthatjuk, hogy:
- A 16 nem szép, mert nem osztható k = 3-mal.
- A 15 nem szép, mert nem tartalmaz egyenlő számú páros és páratlan számjegyet.
Kimutatható, hogy az adott tartományban csak 2 szép egész szám van.

2. példa:

Bemenet:low = 1, high = 10, k = 1
Kimenet: 1
Magyarázat: A megadott tartományban 1 szép egész szám van: [10].
- A 10 azért szép, mert tartalmaz 1 páratlan és 1 páros számjegyet, és osztható k = 1-gyel.
Megmutatható, hogy a megadott tartományban csak 1 szép egész szám van.

3. példa:

Bemenet: low = 5, high = 5, k = 2
Kimenet: 0
Magyarázat: A megadott tartományban 0 szép egész szám van.
- Az 5 azért nem szép, mert nem osztható k = 2-vel, és nem tartalmaz egyenlő páros és páratlan számjegyeket.

Korlátozások:

0 < low <= high <= 10^9
0 < k <= 20

Pozitív egész számokat kapsz: alacsony, nagy és k.
Egy szám akkor szép, ha mindkét alábbi feltételnek megfelel:

A számban lévő páros számjegyek száma megegyezik a páratlan számjegyek számával.
A szám osztható k-val.

Visszaadja a szép egész számok számát az [low, high] tartományban.

Példa 1:

Bemenet: low = 10, high = 20, k = 3
Kimenet: 2
Magyarázat: A megadott tartományban 2 gyönyörű egész szám található: [12,18].
- A 12 azért szép, mert 1 páratlan és 1 páros számjegyet tartalmaz, és osztható k = 3-mal.
- A 18 azért szép, mert 1 páratlan és 1 páros számjegyet tartalmaz, és osztható k = 3-mal.
Ezen kívül láthatjuk, hogy:
- A 16 nem szép, mert nem osztható k = 3-mal.
- A 15 nem szép, mert nem tartalmaz egyenlő számokat páros és páratlan számjegyekkel.
Kimutatható, hogy csak 2 gyönyörű egész szám van az adott tartományban.

Példa 2:

Bemenet: low = 1, high = 10, k = 1
Kimenet: 1
Magyarázat: 1 gyönyörű egész szám van a megadott tartományban: [10].
- A 10 azért szép, mert 1 páratlan és 1 páros számjegyet tartalmaz, és osztható k = 1-gyel.
Kimutatható, hogy az adott tartományban csak 1 szép egész szám van.

Példa 3:

Bemenet: low = 5, high = 5, k = 2
Kimenet: 0
Magyarázat: 0 gyönyörű egész szám van az adott tartományban.
- Az 5 nem szép, mert nem osztható k = 2-vel, és nem tartalmaz egyenlő páros és páratlan számjegyeket.

Korlátozások:

0 < low <= high <= 10^9
0 < k <= 20

Adott pozitív egész számok alacsony, magas és k.
Egy szám akkor szép, ha megfelel mindkét alábbi feltételnek:

A számban lévő páros számjegyek száma megegyezik a páratlan számjegyek számával.
A szám osztható k-val.

A szép egész számok számát adja vissza a [alacsony, magas] tartományban.

1. példa:

Bemenet: low = 10,  high = 20, k = 3
Kimenet: 2
Magyarázat: A megadott tartományban 2 gyönyörű egész szám található: [12,18].
- A 12 azért szép, mert 1 páratlan és 1 páros számjegyet tartalmaz, és osztható k = 3-mal.
- A 18 azért szép, mert 1 páratlan és 1 páros számjegyet tartalmaz, és osztható k = 3-mal.
Ezen kívül láthatjuk, hogy:
- A 16 nem szép, mert nem osztható k = 3-mal.
- A 15 nem szép, mert nem tartalmaz egyenlő számokat páros és páratlan számjegyekkel.
Kimutatható, hogy csak 2 gyönyörű egész szám van az adott tartományban.

2. példa:

Bemenet: low = 1, high  = 10, k = 1
Kimenet: 1
Magyarázat: 1 gyönyörű egész szám van a megadott tartományban: [10].
- A 10 azért szép, mert 1 páratlan és 1 páros számjegyet tartalmaz, és osztható k = 1-gyel.
Kimutatható, hogy az adott tartományban csak 1 szép egész szám van.

3. példa:

Bemenet: low = 5, high = 5, k = 2
Kimenet: 0
Magyarázat: 0 gyönyörű egész szám van az adott tartományban.
- Az 5 nem szép, mert nem osztható k = 2-vel, és nem tartalmaz egyenlő páros és páratlan számjegyeket.

Korlátozások:

0 < low <= high <= 10^9
0 < k <= 20


Adott két 0 indexű string str1 és str2.
Egy műveletben kiválasztunk egy indexkészletet str1-ben, és a készlet minden egyes i indexére str1[i]-t ciklikusan a következő karakterig növeljük. Vagyis az 'a'-ból 'b' lesz, a 'b'-ből 'c' lesz, és így tovább, a 'z'-ből pedig 'a' lesz.
Visszaad true-t, ha a művelet legfeljebb egyszeri végrehajtásával str2-t str1 részfolyamatává lehet tenni, ellenkező esetben false-t.
Megjegyzés: Egy karakterlánc részsorozata olyan új karakterlánc, amelyet az eredeti karakterláncból úgy alakítunk ki, hogy néhány karaktert (esetleg egyet sem) törlünk anélkül, hogy a megmaradt karakterek relatív pozícióját megzavarnánk.

1. példa:

Bemenet: str1 = "abc", str2 = "ad"
Kimenet: true
Magyarázat: Válassza ki az str1 2. indexét.
Növelje str1[2] értékét, hogy 'd' legyen.
Így str1 "abd" lesz, és str2 most egy részfolyamat. Ezért true-t kapunk vissza.
2. példa:

Bemenet: str1 = "zc", str2 = "ad"
Kimenet: true
Magyarázat: Válasszuk ki a str1 0 és 1 indexét.
Növelje str1[0] értékét, hogy'a' legyen.
Növelje str1[1]-t, hogy 'd' legyen.
Így str1 "ad" lesz, és str2 most egy részfolyamat. Ezért true-t kapunk vissza.
3. példa:

Bemenet: str1 = "ab", str2 = "d"
Kimenet: false
Magyarázat: Ebben a példában megmutatható, hogy a művelet segítségével nem lehet str2-t str1 részfolyamatává tenni, legfeljebb egyszer.
Ezért false-t kapunk vissza.

Korlátozások:

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

Van két 0-indexű str1 és str2 sztring.

Egy művelet során kiválasztasz egy indexhalmazt a str1-ben, és minden i index esetén a halmazban ciklikusan növeled str1[i] karaktert. Azaz, 'a' 'b'-vé, 'b' 'c'-vé, és így tovább alakul, és 'z' 'a'-vá válik.

Adja vissza, hogy lehetséges-e str2-t a str1 egy részszekvenciájává tenni legfeljebb egy művelettel, vagy sem.

Megjegyzés: Egy sztring részszekvenciája egy új sztring, amely az eredetiből jön létre úgy, hogy néhány karaktert (lehet, hogy egyet sem) törölnek anélkül, hogy megzavarnák a megmaradt karakterek relatív pozícióját.

Példa 1:

Input: str1 = "abc", str2 = "ad"
Output: true
Magyarázat: Válaszd ki a 2-es indexet a str1-ben.
Növeld meg a str1[2]-t, hogy 'd' legyen.
Így a str1 "abd" lesz, és a str2 már részszekvenica. Ezért, true-t ad vissza.

Példa 2:

Input: str1 = "zc", str2 = "ad"
Output: true
Magyarázat: Válaszd ki a 0 és 1 indexeket a str1-ben.
Növeld meg a str1[0]-t, hogy 'a' legyen.
Növeld meg a str1[1]-t, hogy 'd' legyen.
Így a str1 "ad" lesz, és a str2 már részszekvenica. Ezért, true-t ad vissza.

Példa 3:

Input: str1 = "ab", str2 = "d"
Output: false
Magyarázat: Ebben az esetben kimutatható, hogy lehetetlen a str2-t a str1 részszekvenciájává tenni legfeljebb egy művelettel.
Ezért, false-t ad vissza.

Korlátok:

1 <= str1.length <= 10^5
1 <= str2.length <= 10^5
str1 és str2 csak kisbetűs angol betűket tartalmaznak.

Kapsz két 0-indexelt str1 és str2 karakterláncot.
Egy művelet során kiválasztasz egy indexhalmazt a str1-ben, és minden i index esetén a halmazban ciklikusan növeled str1[i] karaktert. Azaz, 'a' 'b'-vé, 'b' 'c'-vé, és így tovább alakul, és 'z' 'a'-vá válik.
Igaz értéket ad vissza, ha a művelet legfeljebb egyszeri végrehajtásával str2-t az str1 részsorozatává lehet tenni, egyébként false-t.
Megjegyzés: A karakterlánc egy részsorozata egy új karakterlánc, amely az eredeti karakterláncból jön létre úgy, hogy a karakterek egy részét (esetleg egyiket sem) töröljük anélkül, hogy megzavarná a fennmaradó karakterek egymáshoz viszonyított helyzetét.

1. példa:

Bemenet: str1 = "abc", str2 = "ad"
Kimenet: true
Magyarázat: Válassza ki a 2. indexet az str1-ben.
Növelje az str1[2]-et 'd'-vé.
Így a str1 "abd" lesz, és a str2 már részszekvenica. Ezért, true-t ad vissza.
2. példa:

Bemenet: str1 = "zc", str2 = "ad"
Kimenet: true
Magyarázat: Válassza ki a 0 és 1 indexet az str1-ben.
Növelje az str1[0]-t 'a'-vá.
Növelje az str1[1]-et 'd'-vé.
Így a str1 "ad" lesz, és a str2 már részszekvenica. Ezért, true-t ad vissza.
3. példa:

Bemenet: str1 = "ab", str2 = "d"
Kimenet: false
Magyarázat: Ebben a példában bemutatható, hogy az str2-t nem lehet legfeljebb egyszeri művelettel az str1 részsorozatává tenni.
Ezért a false értéket adják vissza.

Korlátozások:

1 <= str1.length <= 10^5
1 <= str2.length <= 10^5
str1 és str2 csak kisbetűs angol betűket tartalmaznak.


Kapsz egy n hosszúságú sztring lépést, amely csak 'L', 'R' és '_' karakterekből áll. A karakterlánc a 0 origótól induló számegyenes mozgását ábrázolja.
Az i^. lépésben a következő irányok közül választhat:

mozog balra, ha moves[i] = 'L' vagy moves[i] = '_'
mozog jobbra, ha moves[i] = 'R' vagy moves[i] = '_'

Adja vissza a távolságot a legtávolabbi pont kezdőpontjától, ahová n lépés után eljuthat.

1. példa:

Bemenet: moves = "L_RL__R"
Kimenet: 3
Magyarázat: A legtávolabbi pont, amelyet a 0 origótól elérhetünk, a -3 pont a következő lépéssorozaton keresztül: "LLRLLLR".

2. példa:

Bemenet: moves = "_R__LL_"
Kimenet: 5
Magyarázat: A legtávolabbi pont, amit a 0 origótól elérhetünk, a -5 pont a következő lépéssorozaton keresztül: LRLLLLL.

3. példa:

Bemenet: moves= "_______"
Kimenet: 7
Magyarázat: A legtávolabbi pont, amelyet a 0 origótól elérhetünk, a 7. pont a következő lépéssorozaton keresztül „RRRRRRRR”.

Korlátozások:

1 <= moves.length == n <= 50
A mozdulatok csak 'L', 'R' és '_' karakterekből állnak.

Adott egy n hosszúságú karakterlánc, amely..., amely csak "L", "R" és "_" karakterekből áll. A karakterlánc a 0 origótól kezdődő számvonalon való mozgását jelöli.
Az i^th lépésben a következő irányok közül választhat:

balra lép, ha moves[i] = 'L' vagy moves[i] =
jobbra lép, ha moves[i] = 'R' vagy moves[i] =

Adja vissza a távolságot a legtávolabbi pont origójától, ahová n lépés után juthat.

1. példa:

Bemenet: moves = "L_RL__R"
Kimenet: 3
Magyarázat: A legtávolabbi pont, amelyet a 0 origótól elérhetünk, a -3 pont a következő "LLRLLLR" lépéssorozaton keresztül.

2. példa:

Bemenet: moves = "_R__LL_"
Kimenet: 5
Magyarázat: A legtávolabbi pont, amelyet a 0 origótól elérhetünk, a -5 pont a következő "LRLLLLL" lépéssorozaton keresztül.

3. példa:

Bemenet: moves = "_______"
Kimenet: 7
Magyarázat: A legtávolabbi pont, amelyet a 0 origótól elérhetünk, a 7. pont a következő "RRRRRRR" lépéssorozaton keresztül.

Korlátok:

1 <= moves.length == n <= 50
A mozgások csak "L", "R" és "_" karakterekből állnak.

Kapsz egy n hosszúságú sztring lépést, amely csak 'L', 'R' és '_' karakterekből áll. A karakterlánc a 0 origótól induló számegyenes mozgását ábrázolja.
Az i^. lépésben a következő irányok közül választhat:

mozog balra, ha moves[i] = 'L' vagy moves[i] = '_'
mozog jobbra, ha moves[i] = 'R' vagy moves[i] = '_'

Adja vissza a távolságot a legtávolabbi pont kezdőpontjától, ahová n lépés után eljuthat.

1. példa:

Bemenet: moves = "L_RL__R"
Kimenet: 3
Magyarázat: A legtávolabbi pont, amelyet a 0 origótól elérhetünk, a -3 pont a következő lépéssorozaton keresztül: "LLRLLLR".

2. példa:

Bemenet: moves = "_R__LL_"
Kimenet: 5
Magyarázat: A legtávolabbi pont, amit a 0 origótól elérhetünk, a -5 pont a következő lépéssorozaton keresztül: LRLLLLL.

3. példa:

Bemenet: moves = "_______"
Kimenet: 7
Magyarázat: A legtávolabbi pont, amelyet a 0 origótól elérhetünk, a 7. pont a következő lépéssorozaton keresztül „RRRRRRRR”.

Korlátozások:

1 <= moves.length == n <= 50
A mozdulatok csak 'L', 'R' és '_' karakterekből állnak.


Adott két azonos hosszúságú, n hosszúságú s és t karakterlánc. Az s karakterláncon a következő műveletet végezhetjük el:

Távolítson el egy l hosszúságú s utótagot, ahol 0 < l < n, és illessze azt az s elejére.
	Például, legyen s = 'abcd', akkor egy művelettel eltávolíthatjuk a 'cd' utótagot, és beilleszthetjük az s elé, így s = 'cdab' lesz.

Adott egy egész szám is, k. Adja vissza, hogy hányféleképpen lehet s-t pontosan k művelettel t-vé alakítani.
Mivel a válasz nagy lehet, adjuk vissza modulo 10^9 + 7.

Példa 1:

Bemenet: s = „abcd”, t = „cdab”, k = 2
Kimenet: 2
Magyarázat:
Első mód:
Az első műveletben válasszuk ki az index = 3 utótagot, így az eredmény s = „dabc”.
A második műveletben válasszuk az index = 3 utótagot, így a kapott s = „cdab”.

Második mód:
Az első műveletben válasszuk az index = 1 utótagot, így a kapott s = „bcda”.
A második műveletben válasszuk az index = 1 utótagot, így a kapott s = „cdab”.

Példa 2:

Bemenet: s = "ababab", t = "ababab", k = 1
Kimenet: 2
Magyarázat:
Első mód:
Válasszunk utótagot az index = 2-ből, így az eredmény s = „ababab”.

Második mód:
Válasszunk utótagot a 4-es indexből, így a kapott s = „ababab”.

Korlátozások:

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s és t csak kisbetűs angol ábécékből áll.

Kapsz két s és t egyforma n hosszúságú karakterláncot. Az s karakterláncon a következő műveletet hajthatja végre:

Távolítson el egy s utótagot, amelynek hossza l, ahol 0 < l < n, és illessze az s elejére.
  Például legyen s = 'abcd', akkor az egyik műveletben eltávolíthatja a 'cd' utótagot, és hozzáfűzheti az s elé, így s = 'cdab'.

Kapsz egy k egész számot is. Adja vissza, hogy hány módon lehet s-t t-vé alakítani pontosan k művelettel.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: s = "abcd", t = "cdab", k = 2
Kimenet: 2
Magyarázat:
Első út:
Az első műveletben válassza ki az index = 3 utótagot, így az eredmény s = "dabc".
A második műveletben válassza ki az index = 3 utótagot, így az eredmény s = "cdab".

Második út:
Az első műveletben válassza ki az index = 1 utótagot, így az eredmény s = "bcda".
A második műveletben válasszon utótagot az index = 1-ből, így az eredmény s = "cdab".

2. példa:

Bemenet: s = "ababab", t = "ababab", k = 1
Kimenet: 2
Magyarázat:
Első út:
Válasszon utótagot az index = 2-ből, így az eredmény s = "ababab".

Második út:
Válasszon utótagot az index = 4-ből, így az eredmény s = "ababab".

Korlátozások:
2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s és t csak kisbetűs angol ábécékből áll.

Két egyenlő hosszúságú, n karakterből álló, s és t karakterláncot kapsz. Az s karakterláncon a következő műveletet hajthatjuk végre:

Eltávolítod az s egy olyan hosszúságú l végződését, ahol 0 < l < n, és hozzáfűzzük az elejére.
	Például, legyen s = 'abcd', akkor egy művelettel eltávolíthatjuk a 'cd' végződést, és hozzáfűzhetjük az s elé, így s = 'cdab' lesz.

Adott továbbá egy k egész szám. Add vissza, hogy hány módon alakítható át s t-re pontosan k művelettel.
Mivel a válasz nagy lehet, add vissza 10^9 + 7 modulo alatt.

Példa 1:

Bemenet: s = "abcd", t = "cdab", k = 2
Kimenet: 2
Magyarázat:
Első mód:
Az első műveletnél válasszd a végződést a 3. indextől, így az eredmény s = "dabc".
A második műveletnél válasszd a végződést a 3. indextől, így az eredmény s = "cdab".

Második mód:
Az első műveletnél válasszd a végződést az 1. indextől, így az eredmény s = "bcda".
A második műveletnél válasszd a végződést az 1. indextől, így az eredmény s = "cdab".

Példa 2:

Bemenet: s = "ababab", t = "ababab", k = 1
Kimenet: 2
Magyarázat:
Első mód:
Válasszd a végződést a 2. indextől, így az eredmény s = "ababab".

Második mód:
Válasszd a végződést a 4. indextől, így az eredmény s = "ababab".

Korlátozások:

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s és t csak kisbetűs angol ábécé karakterekből állnak.


Kap egy 0-indexelt tömböt, amely nem negatív 2-hatványokból áll, és egy egész számú célt.
Egy műveletben a következő módosításokat kell végrehajtania a tömbön:

Válassza ki a tömb bármely elemét nums[i] úgy, hogy a nums[i] > 1 legyen.
Távolítsa el a nums[i] elemet a tömbből.
Adja hozzá a nums[i] / 2 két előfordulását a nums végéhez.

Adja vissza a minimális művelet-számot, amennyi műveletet végrehajtanod kell, hogy a nums olyan részsorozatot tartalmazzon, amelynek elemei összege a cél. Ha lehetetlen ilyen részsorozatot elérni, adja vissza a -1 értéket.
Az alsorozat olyan tömb, amely egy másik tömbből származtatható néhány elem törlésével vagy anélkül, hogy megváltoztatná a fennmaradó elemek sorrendjét.

1. példa:

Bemenet: nums = [1,2,8], target = 7
Kimenet: 1
Magyarázat: Az első műveletben a nums elemet választjuk[2]. A tömb értéke nums = [1,2,4,4] lesz.
Ebben a szakaszban a nums tartalmazza az [1,2,4] részsorozatot, amely összesen 7-et tesz ki.
Kimutatható, hogy nincs rövidebb műveletsor, amely 7-ig terjedő szubszekvenciát eredményezne.

2. példa:

Bemenet: nums = [1,32,1,2], target = 12
Kimenet: 2
Magyarázat: Az első műveletben a nums elemet választjuk[1]. A tömb egyenlő lesz nums = [1,1,2,16,16].
A második műveletben a nums elemet választjuk[3]. A tömb értéke nums = [1,1,2,16,8,8] lesz
Ebben a szakaszban a nums tartalmazza az [1,1,2,8] részsorozatot, amely összesen 12.
Kimutatható, hogy nincs rövidebb műveletsor, amely 12-es összegű részsorozatot eredményezne.
3. példa:

Bemenet: nums = [1,32,1], target = 35
Kimenet: -1
Magyarázat: Kimutatható, hogy egyetlen műveletsor sem eredményez 35-ig terjedő részsorozatot.

Korlátok:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
A nums csak nem negatív 2-hatványokból áll.
1 <= target < 2^31

Kapsz egy 0-indexelt tömbszámot, amely 2 nem negatív hatványaiból és egy egész célból áll.
Egy műveletben a következő módosításokat kell alkalmaznia a tömbön:

Válassza ki a nums[i] tömb bármely elemét úgy, hogy a nums[i] > 1 legyen.
Távolítsa el a nums[i] a tömbből.
A számok végéhez adjon hozzá két előfordulási nums[i] / 2.

Adja vissza a végrehajtandó műveletek minimális számát, hogy a nums olyan részsorozatot tartalmazzon, amelynek elemei összegződnek a célba. Ha lehetetlen ilyen részsorozatot beszerezni, adjon vissza -1-et.
Az alsorozat olyan tömb, amely egy másik tömbből származtatható úgy, hogy néhány elemet vagy egyetlen elemet sem töröl a többi elem sorrendjének megváltoztatása nélkül.

példa 1:

Bemenet: nums = [1,2,8], target = 7
Kimenet: 1
Magyarázat: Az első műveletben az elemszámokat [2] választjuk. A tömb egyenlő lesz a nums = [1,2,4,4] értékkel.
Ebben a szakaszban a számok az [1,2,4] részsorozatot tartalmazzák, amely 7-et ad.
Kimutatható, hogy nincs rövidebb műveletsor, amely 7-ig összegző részsorozatot eredményezne.

példa 2:

Bemenet: nums = [1,32,1,2], target = 12
Kimenet: 2
Magyarázat: Az első műveletben az elem nums [1] választjuk. A tömb egyenlő lesz a nums = [1,1,2,16,16].
A második műveletben elemszámokat választunk[3]. A tömb egyenlő lesz a számokkal = [1,1,2,16,8,8]
Ebben a szakaszban a számok az [1,1,2,8] részsorozatot tartalmazzák, amely 12-t jelent.
Kimutatható, hogy nincs olyan rövidebb műveletsor, amely 12-ig összegző részsorozatot eredményez.
példa 3:

Bemenet: nums = [1,32,1], target = 35
Kimenet: -1
Magyarázat: Kimutatható, hogy egyetlen műveletsor sem eredményez 35-öt összegző részsorozatot.

Korlátozások:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
A számok csak a kettő nemnegatív hatványaiból állnak.
1 <= target < 2^31

Kapsz egy 0-indexelt tömbszámot, amely a 2 nem negatív hatványaiból és egy egész célból áll.
Az egyik műveletben a következő módosításokat kell alkalmaznia a tömbre:

Válassza ki a tömb bármely elemét nums[i] úgy, hogy a nums[i] > 1 legyen.
Távolítsa el a nums[i] elemet a tömbből.
Adja hozzá a nums[i] / 2 két előfordulását a nums végéhez.

Adja vissza a végrehajtandó műveletek minimális számát, hogy a nums olyan részsorozatot tartalmazzon, amelynek elemei a célhoz kerülnek. Ha lehetetlen ilyen részsorozatot elérni, adja vissza a -1 értéket.
Az alsorozat olyan tömb, amely egy másik tömbből származtatható néhány elem törlésével vagy anélkül, hogy megváltoztatná a fennmaradó elemek sorrendjét.

1. példa:

Bemenet: nums = [1,2,8], cél = 7
Kimenet: 1
Magyarázat: Az első műveletben a nums elemet választjuk[2]. A tömb értéke nums = [1,2,4,4] lesz.
Ebben a szakaszban a nums tartalmazza az [1,2,4] részsorozatot, amely összesen 7-et tesz ki.
Kimutatható, hogy nincs rövidebb műveletsor, amely 7-ig terjedő szubszekvenciát eredményezne.

2. példa:

Bemenet: nums = [1,32,1,2], cél = 12
Kimenet: 2
Magyarázat: Az első műveletben a nums elemet választjuk[1]. A tömb egyenlő lesz nums = [1,1,2,16,16].
A második műveletben a nums elemet választjuk[3]. A tömb értéke nums = [1,1,2,16,8,8] lesz
Ebben a szakaszban a nums tartalmazza az [1,1,2,8] részsorozatot, amely összesen 12.
Kimutatható, hogy nincs rövidebb műveletsor, amely 12-es összegű részsorozatot eredményezne.
3. példa:

Bemenet: nums = [1,32,1], cél = 35
Kimenet: -1
Magyarázat: Kimutatható, hogy egyetlen műveletsor sem eredményez 35-ig terjedő részsorozatot.

Korlátok:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums consists only of non-negative powers of two.
1 <= target < 2^31


Adott egy 0-indexelt n * m méretű 2D egész szám mátrix, a grid. Definiálunk egy 0-indexelt n * m méretű 2D mátrixot, p, mint a grid szorzat mátrixa, ha a következő feltétel teljesül:

Minden egyes p[i][j] elem úgy számítandó, mint a grid összes elemének szorzata az grid[i][j] elemet kivéve. Ez a szorzat modulo 12345 kerül meghatározásra.

Térj vissza a grid szorzat mátrixával.

1. példa:

Bemenet: grid = [[1,2],[3,4]]
Kimenet: [[24,12],[8,6]]
Magyarázat: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Tehát a válasz [[24,12],[8,6]].

2. példa:

Bemenet: grid = [[12345],[2],[1]]
Kimenet: [[2],[0],[0]]
Magyarázat: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Tehát p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Tehát p[0][2] = 0.
Tehát a válasz [[2],[0],[0]].

Korlátozások:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Adott egy n * m méretű 0 indexű 2D egész mátrix rács, akkor egy n * m méretű 0 indexű 2D mátrixot definiálunk a rács szorzatmátrixaként, ha a következő feltétel teljesül:

Minden p[i][j] elem a rács összes elemének szorzataként kerül kiszámításra, kivéve a grid[i][j] elemet. Ez a termék ezután modulo 12345 lesz.

Visszaadja a rács szorzatmátrixát.

1. példa:

Bemenet: grid = [[1,2],[3,4]]
Kimenet: [[24,12],[8,6]]
Magyarázat:  p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
So the answer is [[24,12],[8,6]].
2. példa:

Bemenet: grid = [[12345],[2],[1]]
Kimenet: [[2], [0], [0]]
Magyarázat: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Tehát p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Tehát p[0][2] = 0.
Tehát a válasz [[2],[0],[0]].

Korlátozások:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Adott egy n * m méretű, 0 indexű 2D-s egészértékű rácsrács, akkor definiálunk egy n * m méretű, 0 indexű 2D-s p rácsot a rács termékrácsaként, ha a következő feltétel teljesül:

Minden p[i][j] elemet a rács összes elemének szorzataként számolunk, kivéve a rács[i][j] elemet. Ezt a szorzatot ezután modulo 12345-re vesszük.

A grid termékrácsának visszaadása.

Példa 1:

Bemenet: grid = [[1,2],[3,4]]
Kimenet: [[24,12],[8,6]]
Magyarázat: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Tehát a válasz[[24,12],[8,6]].

Példa 2:

Bemenet: grid = [[12345],[2],[1]]
Kimenet: [[2],[0],[0]]
Magyarázat: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Tehát p[0][1] = 0.
p[0][2] = grid[0][0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Tehát p[0][2] = 0.
Tehát a válasz[[2],[0],[0]].

Korlátozások:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9


Kap egy 0 indexelt egész tömb vevőt n hosszúsággal és egy k egész számmal.
N játékosnak van egyedi azonosítója a [0, n - 1] tartományban, akik labdapasszjátékot játszanak, és az vevő[i] annak a játékosnak az azonosítója, aki passzokat kap az id i-vel rendelkező játékostól. A játékosok átadhatják magukat, azaz a vevő[i] egyenlő lehet i-vel.
Az n játékos közül egyet kell választanod a játék kezdő játékosának, és a labdát pontosan k-szor adják át a kiválasztott játékostól kezdve.
Egy kiválasztott kezdő játékos esetében, akinek x azonosítója van, definiálunk egy f(x) függvényt, amely jelöli x összegét és az összes olyan játékos azonosítóját, akik megkapják a labdát a k passzok során, beleértve az ismétléseket is. Más szóval, f(x) = x + vevő[x] + vevő[vevő[x]] + ... + vevő^(k)[x].
A feladatod az, hogy kiválassz egy kezdő játékost, akinek x azonosítója maximalizálja az f(x) értékét.
Egy egész számot ad vissza, amely a függvény maximális értékét jelenti.
Megjegyzés: a vevő tartalmazhat másolatokat.

1. példa:

Passz száma
Küldő azonosítója
Vevő azonosítója
x + Vevő azonosítók

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Bemenet: receiver = [2,0,1], k = 4
Kimenet: 6
Magyarázat: A fenti táblázat a játék szimulációját mutatja, kezdve azzal, hogy a játékos azonosítója x = 2.
A táblázatból f(2) egyenlő 6-tal.
Megmutatható, hogy 6 a függvény maximálisan elérhető értéke.
Ezért a kimenet 6.

2. példa:

Passz száma
Küldő azonosítója
Vevő azonosítója
x + Vevő azonosítók

4

1
4
3
7

2
3
2
9

3
2
1
10

Bemenet: receiver = [1,1,1,2,3], k = 3
Kimenet: 10
Magyarázat: A fenti táblázat a játék szimulációját mutatja, kezdve azzal, hogy a játékos azonosítója x = 4.
A táblázatból az f(4) egyenlő 10-zel.
Megmutatható, hogy 10 a függvény maximálisan elérhető értéke.
Ezért a kimenet 10.

Korlátok:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

Egy 0-indexált egész számokból álló receiver nevű tömböt kapsz, amely hossza n, valamint egy k egész számot.
Van n játékos, akiknek egyedi azonosítójuk van a [0, n - 1] tartományban, és akik egy labdát passzoló játékot fognak játszani. A receiver[i] annak a játékosnak az azonosítója, aki a passat kapja attól a játékostól, akinek az azonosítója i. A játékosok passzolhatnak maguknak is, azaz receiver[i] lehet egyenlő i-vel.
Ki kell választanod az n játékos egyikét, mint a játék kezdő játékosát, és a labdát pontosan k alkalommal passzolják, kezdve a kiválasztott játékossal.
Egy kiválasztott kezdő játékos azonosítójával, x, definiálunk egy f(x) függvényt, amely az x és az összes játékos azonosítójának összegét jelöli, akik megkapják a labdát a k passz során, beleértve az ismétlődéseket is. Más szavakkal, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
A te feladatod, hogy válassz egy kezdő játékost x azonosítóval, amely maximalizálja az f(x) értékét.
Adj vissza egy egész számot, ami a függvény maximális értékét jelenti.
Megjegyzés: a receiver tartalmazhat ismétlődéseket.

Példa 1:

Passz Szám
Küldő ID
Fogadó ID
x + Fogadó ID-k

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Bemenet: receiver = [2,0,1], k = 4
Kimenet: 6
Magyarázat: A fenti táblázat egy szimulációt mutat a játékra, amely a x = 2 azonosítójú játékossal indul. A táblázat alapján f(2) egyenlő 6-tal. Megmutatható, hogy 6 a függvény által elérhető maximális érték. Ezért a kimenet 6.

Példa 2:

Passz Szám
Küldő ID
Fogadó ID
x + Fogadó ID-k

4

1
4
3
7

2
3
2
9

3
2
1
10

Bemenet: receiver = [1,1,1,2,3], k = 3
Kimenet: 10
Magyarázat: A fenti táblázat egy szimulációt mutat a játékra, amely a x = 4 azonosítójú játékossal indul. A táblázat alapján f(4) egyenlő 10-zel. Megmutatható, hogy 10 a függvény által elérhető maximális érték. Ezért a kimenet 10.

Korlátozások:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

Adunk egy n hosszúságú 0 indexű egész tömb vevőt és egy k egész számot.
A [0, n - 1] tartományban n egyedi azonosítóval rendelkező játékos labdapasszolásban játszik, a fogadó[i] pedig annak a játékosnak az azonosítója, aki az i azonosítójú játékostól kap passzokat. A játékosok passzolhatnak maguknak, azaz a fogadó[i] egyenlő lehet az i-vel.
Az n játékos közül egyet kell kiválasztani kezdő játékosnak a játékban, és a labdát pontosan k-szer passzolják a kiválasztott játékostól kezdve.
Egy x azonosítójú kiválasztott kezdőjátékosra definiálunk egy f(x) függvényt, amely x összegét jelöli és az összes játékos azonosítóját, aki megkapja a labdát a k passz során, beleértve az ismétléseket is. Más szavakkal, f(x) = x + vevő[x] + vevő[vevő[x]] + ... + vevő^(k)[x].
Az Ön feladata, hogy válasszon egy kezdő játékost, akinek az id x maximalizálja az f(x) értékét.
Egy egész számot ad vissza, amely a függvény maximális értékét jelöli.
Megjegyzés: a vevő duplikátumokat tartalmazhat.

1. példa:

Pass Number
Feladó azonosítója
Vevő azonosítója
x + Vevőazonosítók

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Bemenet: receiver  = [2,0,1], k = 4
Kimenet: 6
Magyarázat: A fenti táblázat a játék szimulációját mutatja, amely az x = 2 azonosítójú játékossal kezdődik.
A táblázatból f(2) egyenlő 6-tal.
Megmutatható, hogy a 6 a függvény maximálisan elérhető értéke.
Ezért a kimenet 6.

2. példa:

Pass Number
Feladó azonosítója
Vevő azonosítója
x + Vevőazonosítók

4

1
4
3
7

2
3
2
9

3
2
1
10

Bemenet: receiver= [1,1,1,2,3], k = 3
Kimenet: 10
Magyarázat: A fenti táblázat a játék szimulációját mutatja, amely az x = 4 azonosítójú játékossal kezdődik.
A táblázatból f(4) egyenlő 10-zel.
Megmutatható, hogy a 10 a függvény maximálisan elérhető értéke.
Ezért a kimenet 10.

Korlátozások:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10


Kapunk két 0-indexelt bináris sztringet, s1 és s2, mindkettő n hosszú, és egy pozitív egész számot x.
A következő műveletek bármelyikét elvégezheti az s1 karakterláncon bármennyi alkalommal:

Válasszon két i és j indexet, és fordítsa meg mind az s1[i], mind az s1[j] indexet. Ennek a műveletnek a költsége x.
Válasszon egy i indexet úgy, hogy i < n - 1, és fordítsa meg az s1[i]-t és az s1[i + 1]-t is. Ennek a műveletnek a költsége 1.

Adja vissza az s1 és s2 karakterláncok egyenlővé tételéhez szükséges minimális költséget, vagy -1 értéket, ha ez lehetetlen.
Ne feledje, hogy egy karakter átfordítása azt jelenti, hogy 0-ról 1-re változtatja, vagy fordítva.

1. példa:

Bemenet: s1 = "1100011000", s2 = "0101001010", x = 2
Kimenet: 4
Magyarázat: A következő műveleteket tudjuk elvégezni:
- Válassza az i = 3 értéket, és alkalmazza a második műveletet. Az eredményül kapott karakterlánc: s1 = "1101111000".
- Válassza az i = 4 értéket, és alkalmazza a második műveletet. Az eredményül kapott karakterlánc: s1 = "1101001000".
- Válassza az i = 0 és a j = 8 értéket, és alkalmazza az első műveletet. Az eredményül kapott karakterlánc: s1 = "0101001010" = s2.
Az összköltség 1 + 1 + 2 = 4. Megmutatható, hogy ez a lehető legkisebb költség.

2. példa:

Bemenet: s1 = "10110", s2 = "00011", x = 4
Kimenet: -1
Magyarázat: A két karakterláncot nem lehet egyenlővé tenni.

Korlátozások:

n == s1.length == s2.length
1 <= n, x <= 500
s1 és s2 csak a „0” és „1” karakterekből áll.

Két 0-indexelt bináris karakterláncot kapunk s1 és s2, mindkettő n hosszúságú, és egy pozitív egész x szám.
Az s1 karakterláncon a következő műveletek bármelyikét tetszőleges számú alkalommal végrehajthatja:

Válasszon két i és j indexet, és fordítsa meg az s1[i] és s1[j] indexet. Ennek a műveletnek a költsége x.
Válasszon egy i indexet úgy, hogy i n - 1 <, és fordítsa meg mind az s1[i], mind az s1[i + 1] értéket. A művelet költsége 1.

Adja vissza az s1 és s2 karakterláncok egyenlővé tételéhez szükséges minimális költséget, vagy adja vissza a -1 értéket, ha ez lehetetlen.
Ne feledje, hogy egy karakter tükrözése azt jelenti, hogy 0-ról 1-re változtatja, vagy fordítva.

1. példa:

Bemenet: s1 = "1100011000", s2 = "0101001010", x = 2
Kimenet: 4
Magyarázat: A következő műveleteket végezhetjük el:
- Válassza az i = 3 lehetőséget, és alkalmazza a második műveletet. A kapott karakterlánc s1 = "1101111000".
- Válassza az i = 4 lehetőséget, és alkalmazza a második műveletet. A kapott karakterlánc s1 = "1101001000".
- Válassza az i = 0 és j = 8 lehetőséget, és alkalmazza az első műveletet. Az eredményül kapott karakterlánc s1 = "0101001010" = s2.
A teljes költség 1 + 1 + 2 = 4. Kimutatható, hogy ez a lehető legkisebb költség.

2. példa:

Bemenet: s1 = "10110", s2 = "00011", x = 4
Kimenet: -1
Magyarázat: A két karakterláncot nem lehet egyenlővé tenni.

Korlátok:

n == s1.length == s2.length
1 <= n, x <= 500
Az S1 és S2 csak "0" és "1" karakterekből áll.


Egy 0-indexált 2D egész szám tömböt kapsz, nums, amely az autók koordinátáit ábrázolja egy számegyenesen. Bármely i index esetén nums[i] = [start_i, end_i], ahol start_i az i-edik autó kezdőpontja és end_i az i-edik autó végpontja.
Add vissza az egész szám pontjainak számát a vonalon, amelyeket bármely autó részben lefed.

Példa 1:

Bemenet: nums = [[3,6],[1,5],[4,7]]
Kimenet: 7
Magyarázat: Az összes pont 1-től 7-ig legalább egy autóval metszi egymást, ezért a válasz 7 lenne.

Példa 2:

Bemenet: nums = [[1,3],[5,8]]
Kimenet: 7
Magyarázat: Azok a pontok, amelyek legalább egy autóval metszenek, 1, 2, 3, 5, 6, 7, 8. Összesen 7 pont van, így a válasz 7 lenne.

Korlátozások:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

Kapsz egy 0-indexelt 2D egész tömb számokat, amelyek a számvonalon parkoló autók koordinátáit képviselik. Bármely i index esetén nums[i] = [start_i, end_i], ahol start_i az i-edik autó kezdőpontja és end_i az i-edik autó végpontja.
Adj vissza a vonal azon egész pontjainak számát, amelyeket az autók bármely része lefed, amelyeket az autó bármely része lefed.

1. példa:

Bemenet: nums = [[3,6],[1,5],[4,7]]
Kimenet: 7
Magyarázat: Az 1-től 7-ig terjedő pontok legalább egy autót metszenek, ezért a válasz 7 lenne.

2. példa:

Bemenet: nums = [[1,3],[5,8]]
Kimenet: 7
Magyarázat: Legalább egy autót metsző pontok a következők: 1, 2, 3, 5, 6, 7, 8. Összesen 7 pont van, ezért a válasz 7 lenne.

Korlátok:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

Kapsz egy 0-indexelt 2D egész tömb számokat, amelyek a számvonalon parkoló autók koordinátáit képviselik. Bármely i index esetén nums[i] = [start_i, end_i], ahol start_i az i^-edik autó kezdőpontja és end_i az i^-edik autó végpontja.
A vonal azon egész pontjainak számát adja vissza, amelyeket az autó bármely része lefed.

1. példa:

Bemenet: nums = [[3,6],[1,5],[4,7]]
Kimenet: 7
Magyarázat: Az 1-től 7-ig terjedő pontok legalább egy autót metszenek, ezért a válasz 7 lenne.

2. példa:

Bemenet: nums = [[1,3],[5,8]]
Kimenet: 7
Magyarázat: Legalább egy autót metsző pontok a következők: 1, 2, 3, 5, 6, 7, 8. Összesen 7 pont van, ezért a válasz 7 lenne.

Korlátok:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100


Kapsz egy pozitív egész számokból álló tömböt és egy k egész számot.
Egy művelettel eltávolíthatja a tömb utolsó elemét, és hozzáadhatja a gyűjteményéhez.
Adja vissza az 1, 2, ..., k elemek összegyűjtéséhez szükséges minimális számú műveletet.

1. példa:

Bemenet: nums = [3,1,5,4,2], k = 2
Kimenet: 4
Magyarázat: 4 művelet után összegyűjtjük a 2., 4., 5. és 1. elemeket, ebben a sorrendben. Gyűjteményünk az 1. és a 2. elemet tartalmazza. A válasz tehát a 4.

2. példa:

Bemenet: nums = [3,1,5,4,2], k = 5
Kimenet: 5
Magyarázat: 5 művelet után összegyűjtjük a 2., 4., 5., 1. és 3. elemeket, ebben a sorrendben. Gyűjteményünk 1-től 5-ig terjedő elemeket tartalmaz. Ezért a válasz az 5.

3. példa:

Bemenet: nums = [3,2,5,3,1], k = 3
Kimenet: 4
Magyarázat: 4 művelet után összegyűjtjük az 1., 3., 5. és 2. elemeket, ebben a sorrendben. Gyűjteményünk az 1-től 3-ig terjedő elemeket tartalmazza. Ezért a válasz a 4.

Korlátozások:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
A bemenet úgy jön létre, hogy összegyűjtse az 1, 2, ..., k elemeket.

Kapsz egy pozitív egész numsokból álló listanumsot és egy k egész numsot.
Egy művelettel eltávolíthatja a lista utolsó elemét, és hozzáadhatja a gyűjteményhez.
Adja vissza a 1, 2, ..., k elemek összegyűjtéséhez szükséges műveletek minimális számát.

1. példa:

Bemenet: nums = [3,1,5,4,2], k = 2
Kimenet: 4
Magyarázat: 4 művelet után összegyűjtjük a 2., 4., 5. és 1. elemeket ebben a sorrendben. Gyűjteményünk az 1. és 2. elemeket tartalmazza. Ezért a válasz 4.

2. példa:

Bemenet: nums = [3,1,5,4,2], k = 5
Kimenet: 5
Magyarázat: 5 művelet után összegyűjtjük a 2., 4., 5., 1. és 3. elemeket ebben a sorrendben. Gyűjteményünk 1-től 5-ig terjedő elemeket tartalmaz. Ezért a válasz 5.

3. példa:

Bemenet: nums = [3,2,5,3,1], k = 3
Kimenet: 4
Magyarázat: 4 művelet után összegyűjtjük az 1., 3., 5. és 2. elemet, ebben a sorrendben. Gyűjteményünk 1-től 3-ig terjedő elemeket tartalmaz. Ezért a válasz 4.

Korlátok:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
A bemenet úgy jön létre, hogy összegyűjtse az 1, 2, ..., k számoket.

Kapsz egy pozitív egész számokból álló tömbszámot és egy k egész számot.
Egy művelettel eltávolíthatja a tömb utolsó elemét, és hozzáadhatja a gyűjteményhez.
Adja vissza az 1., 2., ..., k. elemek összegyűjtéséhez szükséges műveletek minimális számát.

1. példa:

Bemenet: nums = [3,1,5,4,2], k = 2
Kimenet: 4
Magyarázat: 4 művelet után összegyűjtjük a 2., 4., 5. és 1. elemeket ebben a sorrendben. Gyűjteményünk az 1. és 2. elemeket tartalmazza. Ezért a válasz 4.

2. példa:

Bemenet: nums = [3,1,5,4,2], k = 5
Kimenet: 5
Magyarázat: 5 művelet után összegyűjtjük a 2., 4., 5., 1. és 3. elemeket ebben a sorrendben. Gyűjteményünk 1-től 5-ig terjedő elemeket tartalmaz. Ezért a válasz 5.

3. példa:

Bemenet: nums = [3,2,5,3,1], k = 3
Kimenet: 4
Magyarázat: 4 művelet után összegyűjtjük az 1., 3., 5. és 2. elemet, ebben a sorrendben. Gyűjteményünk 1-től 3-ig terjedő elemeket tartalmaz. Ezért a válasz 4.

Korlátok:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
A bemenet úgy jön létre, hogy összegyűjtse az 1, 2, ..., k elemeket.


Adott egy 0-indexelt `nums` tömb, amelynek hossza n és különböző pozitív egész számokat tartalmaz. Add vissza a minimum számú jobbra tolást, amely szükséges ahhoz, hogy a `nums` rendezett legyen, és -1-et, ha ez nem lehetséges.
Egy jobbra tolás úgy van definiálva, hogy az i indexű elemet az (i + 1) % n indexre tesszük, minden index esetén.

1. példa:

Input: nums = [3,4,5,1,2]
Output: 2
Magyarázat:
Az első jobbra tolás után: nums = [2,3,4,5,1].
A második jobbra tolás után: nums = [1,2,3,4,5].
Most a nums rendezett; tehát a válasz 2.

2. példa:

Input: nums = [1,3,5]
Output: 0
Magyarázat: a nums már rendezett, ezért a válasz 0.

3. példa:

Input: nums = [2,1,4]
Output: -1
Magyarázat: Nem lehetséges rendezni a tömböt jobbra tolásokkal.

Feltételek:

1 <= nums.length <= 100
1 <= nums[i] <= 100
A nums különböző egészeket tartalmaz.

Kapsz egy 0-indexelt, n hosszúságú tömböt, amely különböző pozitív egész számokat tartalmaz. Visszaadja a tömb rendezéséhez szükséges minimális számú jobbra műszakot.
A jobbra műszak azt jelenti, hogy az i indexű elemet az (i + 1) % n indexű helyre tolják el minden index esetében.

Példa 1:

Bemenet: nums = [3,4,5,1,2]
Kimenet: 2
Magyarázat:
Az első jobbra műszak után nums = [2,3,4,5,1].
A második jobb műszak után nums = [1,2,3,4,5].
Most a nums rendezve van; Ezért a válasz 2.

Példa 2:

Bemenet: nums = [1,3,5]
Kimenet: 0
Magyarázat: a nums már rendezve van, ezért a válasz 0.
Példa 3:

Bemenet: nums = [2,1,4]
Kimenet: -1
Magyarázat: Lehetetlen a tömböt jobbra eltolva rendezni.

Korlátok:

1 <= nums.length <= 100
1 <= nums[i] <= 100
A nums különböző egész számokat tartalmaz.

Egy 0-indexelt tömböt kapunk, amelyek n hosszúságúak, és amelyek különböző pozitív egész számokat tartalmaznak. Adja vissza a számok rendezéséhez szükséges minimális számú jobb eltolást, és -1-t, ha ez nem lehetséges.
A jobbra eltolást úgy definiáljuk, mint az i indexnél lévő elem eltolását az (i + 1) % n indexre, minden index esetében.

1. példa:

Bemenet: nums= [3,4,5,1,2]
Kimenet: 2
Magyarázat:
Az első jobbra eltolás után a nums= [2,3,4,5,1].
A második jobbra eltolás után a nums= [1,2,3,4,5].
Most a számok rendezve vannak; ezért a válasz 2.

2. példa:

Bemenet: nums= [1,3,5]
Kimenet: 0
Magyarázat: a nums már rendezve vannak, ezért a válasz 0.
3. példa:

Bemenet: nums= [2,1,4]
Kimenet: -1
Magyarázat: Lehetetlen rendezni a tömböt jobbra tolással.

Korlátozások:

1 <= nums.length <= 100
1 <= nums[i] <= 100
A nums különböző egész számokat tartalmaz.


Adott egy 0-indexelt karakterlánc-szám, amely egy nemnegatív egész számot reprezentál.
Egy művelet során kiválaszthatod a szám bármelyik számjegyét, és törölheted azt. Vedd figyelembe, hogy ha a szám összes számjegyét törlöd, a szám 0 lesz.
Add vissza a minimális számú műveletet, amely a szám különlegessé tételéhez szükséges.
Egy x egész szám akkor tekinthető különlegesnek, ha osztható 25-tel.

1. példa:

Bemenet: szám = "2245047"
Kimenet: 2
Magyarázat: Töröld a num[5] és a num[6] számjegyeket. Az eredményül kapott szám "22450", ami különleges, mivel osztható 25-tel.
Kimutatható, hogy minimálisan 2 művelet szükséges a különleges szám eléréséhez.
2. példa:

Bemenet: szám = "2908305"
Kimenet: 3
Magyarázat: Töröld a num[3], num[4] és num[6] számjegyeket. Az eredményül kapott szám "2900", ami különleges, mivel osztható 25-tel.
Kimutatható, hogy minimálisan 3 művelet szükséges a különleges szám eléréséhez.
3. példa:

Bemenet: szám = "10"
Kimenet: 1
Magyarázat: Töröld a num[0] számjegyet. Az eredményül kapott szám "0", ami különleges, mivel osztható 25-tel.
Kimutatható, hogy minimálisan 1 művelet szükséges a különleges szám eléréséhez.

Feltételek:

1 <= num.length <= 100
num csak '0' és '9' közötti számjegyekből áll.
num nem tartalmaz kezdő nullákat.

Adott egy 0-indexelt karakterlánc, amely egy nem negatív egész számot képvisel, amely egy nem negatív egész számot képvisel.
Egy művelettel kiválaszthatja a num bármely számjegyét, és törölheti azt. Vegye figyelembe, hogy ha törli a szám összes számjegyét, a szám 0 lesz.
Visszaadja a num különlegessé tételéhez szükséges műveletek minimális számát.
Egy x egész szám akkor tekinthető speciálisnak, ha osztható 25-tel.

1. példa:

Bemenet: num = "2245047"
Kimenet: 2
Magyarázat: A szám[5] és a szám[6] számjegyek törlése. A kapott szám "22450", ami különleges, mivel osztható 25-tel.
Megmutatható, hogy a 2 a speciális szám megszerzéséhez szükséges minimális műveletek száma.
2. példa:

Bemenet: num = "2908305"
Kimenet: 3
Magyarázat: Törölje a szám[3], szám[4] és szám[6] számjegyeket. A kapott szám "2900", ami különleges, mivel osztható 25-tel.
Megmutatható, hogy 3 a speciális szám megszerzéséhez szükséges minimális műveletek száma.
3. példa:

Bemenet: num = "10"
Kimenet: 1
Magyarázat: számjegy[0] törlendő. A kapott szám "0", ami különleges, mivel osztható 25-tel.
Megmutatható, hogy az 1 a speciális szám megszerzéséhez szükséges minimális műveletek száma.

Korlátok:

1 <= num.length <= 100
A szám csak a "0"-tól "9"-ig terjedő számjegyekből áll.
A NUM nem tartalmaz kezdő nullákat.

Adott egy 0-indexelt karakterlánc, amely egy nem negatív egész számot képvisel, amely egy nem negatív egész számot képvisel.
Egy műveletben törölhet bármely számjegyet a num-ból. Ha törli a szám összes számjegyét, a szám 0 lesz.
Visszaadja a num különlegessé tételéhez szükséges műveletek minimális számát.
Egy x egész szám akkor tekinthető speciálisnak, ha osztható 25-tel.

1. példa:

Bemenet: num = "2245047"
Kimenet: 2
Magyarázat: A szám[5] és a szám[6] számjegyek törlése. A kapott szám "22450", ami különleges, mivel osztható 25-tel.
Megmutatható, hogy a 2 a speciális szám megszerzéséhez szükséges minimális műveletek száma.
2. példa:

Bemenet: num = "2908305"
Kimenet: 3
Magyarázat: Törölje a szám[3], szám[4] és szám[6] számjegyeket. A kapott szám "2900", ami különleges, mivel osztható 25-tel.
Megmutatható, hogy 3 a speciális szám megszerzéséhez szükséges minimális műveletek száma.
3. példa:

Bemenet: num = "10"
Kimenet: 1
Magyarázat: Törölje a szám[0] számjegyet. A kapott szám "0", ami különleges, mivel osztható 25-tel.
Megmutatható, hogy az 1 a speciális szám megszerzéséhez szükséges minimális műveletek száma.

Korlátok:

1 <= szám.hossz <= 100
A szám csak a "0"-tól "9"-ig terjedő számjegyekből áll.
A NUM nem tartalmaz kezdő nullákat.