Adott egy n hosszúságú s karakterlánc és egy k egész szám, ahol n a k többszöröse. Az Ön feladata, hogy az s karakterláncot egy új, result nevű karakterlánccá hash-olja, amelynek hossza n / k lesz.
Először is osszuk fel az s-t n / k részláncra, amelyek mindegyike k hosszúságú. Ezután inicializáljuk az eredményt üres karakterlánccá.
Minden részláncra az elejétől kezdve sorrendben:

Egy karakter hash-értéke az adott karakter indexe az angol ábécében (pl. 'a' → 0, 'b' → 1, ..., 'z' → 25).
Számítsuk ki a részláncban lévő karakterek hash-értékeinek összegét.
Keressük meg ennek az összegnek a 26-tal osztott maradékát, amelyet hashedChar-nak nevezünk.
Határozzuk meg az angol kisbetűs ábécé azon karakterét, amely megfelel a hashedChar értéknek.
Illesszük ezt a karaktert az eredmény végéhez.

Visszaadja az eredményt.

Példa 1:

Bemenet: s = "abcd", k = 2
Kimenet: "bf"
Magyarázat:
Első alkarakterlánc: "ab", 0 + 1 = 1, 1 % 26 = 1, eredmény[0] = 'b'.
Második alkarakterlánc: "cd", 2 + 3 = 5, 5 % 26 = 5, eredmény[1] = 'f'.

Példa 2:

Bemenet: s = "mxz", k = 3
Kimenet: "i"
Magyarázat:
Az egyetlen részkarakterlánc: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, eredmény[0] = 'i'.

Korlátozások:

1 <= k <= 100
k <= s.length <= 1000
s.length osztható k-val.
s csak kisbetűs angol betűkből áll.

Kapunk egy n hosszúságú s karakterláncot és egy k egész számot, ahol n a k többszöröse. Az Ön feladata, hogy az s karakterláncot egy új, eredménynek nevezett karakterláncba kivonatolja, amelynek hossza n / k.
Először ossza meg az s-t n / k részsztringekre, amelyek mindegyike k hosszúságú. Ezután inicializálja az eredményt üres sztringként.
Minden egyes részkarakterlánchoz az elejétől kezdve:

Egy karakter hash értéke az adott karakter indexe az angol ábécében (pl. 'a' → 0, 'b' → 1, ..., 'z' → 25).
Számítsa ki az alsztringben lévő karakterek összes hash értékének összegét.
Keresse meg ennek az összegnek a fennmaradó részét, ha elosztja 26-tal, amelyet hashedChar-nak hívnak.
Azonosítsa az angol kisbetűs ábécé azon karakterét, amely megfelel a hashedChar karakternek.
Fűzze hozzá ezt a karaktert az eredmény végéhez.

Visszatérési eredmény.

1. példa:

Bemenet: s = "abcd", k = 2
Kimenet: "bf"
Magyarázat:
Első alkarakterlánc: "ab", 0 + 1 = 1, 1 % 26 = 1, eredmény[0] = 'b'.
Második alkarakterlánc: "cd", 2 + 3 = 5, 5 % 26 = 5, eredmény[1] = 'f'.

2. példa:

Bemenet: s = "mxz", k = 3
Kimenet: "i"
Magyarázat:
Az egyetlen részkarakterlánc: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, eredmény[0] = 'i'.

Korlátok:

1 < = k <= 100
k <= s.length <= 1000
s.hossza osztható k-val.
s csak kisbetűs angol betűkből áll.

Adunk egy n hosszú s karakterláncot és egy k egész számot, ahol n k többszöröse. Az Ön feladata az s karakterlánc kivonatolása egy eredmény nevű új karakterláncba, amelynek hossza n / k.
Először osszuk fel s-t n/k részkarakterláncra, amelyek mindegyike k hosszú. Ezután inicializálja az eredményt üres karakterláncként.
Minden egyes karakterlánchoz sorrendben az elejétől:

Egy karakter hash értéke az adott karakter indexe az angol ábécében (pl. „a” → 0, „b” → 1, ..., „z” → 25).
Számítsa ki az alsztringben szereplő karakterek összes hash értékének összegét.
Keresse meg ennek az összegnek a maradékát, ha elosztja 26-tal, amit hashedCharnak neveznek.
Határozza meg az angol kisbetűs ábécében azt a karaktert, amely megfelel a hashedChar-nak.
Adja hozzá ezt a karaktert az eredmény végéhez.

Eredmény visszaadása.

1. példa:

Bemenet: s = "abcd", k = 2
Kimenet: "bf"
Magyarázat:
Első részkarakterlánc:"ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'.
Második részkarakterlánc: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'.

2. példa:

Bemenet: s = "mxz", k = 3
Kimenet: "i"
Magyarázat:
Az egyetlen részkarakterlánc: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'.

Korlátozások:

1 <= k <= 100
k <= s.length <= 1000
s.hossz osztható k-val.
s csak kis angol betűkből áll.


Kapsz két pozitív egész számot, n és k.
Egy x egész számot k-palindromnak nevezünk, ha:

x egy palindrom.
x osztható k-val.

Egy egész számot akkor nevezünk jónak, ha a számjegyei átrendezhetők k-palindrom egész számmá. Például, ha k = 2, 2020 átrendezhető a 2002 k-palindrom egész számra, míg az 1010 nem rendezhető át k-palindrom egész számra.
Az n számjegyet tartalmazó jó egész számok számát adja vissza.
Ne feledje, hogy egyetlen egész számban sem lehetnek vezető nullák, sem az átrendezés előtt, sem utána. Például az 1010 nem rendezhető át 101-re.

1. példa:

Bemenet: n = 3, k = 5
Kimenet: 27
Magyarázat:
Néhány jó egész szám a következő:

551, mert átrendezhető 515-re.
525, mert már k-palindromos.

2. példa:

Bemenet: n = 1, k = 4
Kimenet: 2
Magyarázat:
A két jó egész szám a 4 és a 8.

3. példa:

Bemenet: n = 5, k = 6
Kimenet: 2468

Korlátozások:

1 <= n <= 10
1 <= k <= 9

Kapsz két pozitív egész számot, n és k.
Egy x egész számot k-palindromnak nevezünk, ha:

x egy palindrom.
x osztható k-val.

Egy egész számot akkor nevezünk jónak, ha a számjegyei átrendezhetők k-palindrom egész számmá. Például, ha k = 2, 2020 átrendezhető a 2002 k-palindrom egész számra, míg az 1010 nem rendezhető át k-palindrom egész számra.
Az n számjegyet tartalmazó jó egész számok számát adja vissza.
Ne feledje, hogy egyetlen egész számban sem lehetnek vezető nullák, sem az átrendezés előtt, sem utána. Például az 1010 nem rendezhető át 101-re.

Példa 1:

Bemenet: n = 3, k = 5
Kimenet: 27
Magyarázat:
Néhány jó egész szám:

551, mert átrendezhető 515-re.
525, mert az már k-palindromos.

Példa 2:

Bemenet: n = 1, k = 4
Kimenet: 2
Magyarázat:
A két jó egész szám a 4 és a 8.

Példa 3:

Bemenet: n = 5, k = 6
Kimenet: 2468

Korlátozások:

1 <= n <= 10
1 <= k <= 9

Két pozitív egész számot kapunk n és k.
Egy x egész számot k-palindromnak nevezünk, ha:

x egy palindrom.
x osztható k-val.

Egy egész számot akkor nevezünk jónak, ha számjegyei átrendezhetők k-palindrom egész számmá. Például k = 2 esetén 2020 átrendezhető úgy, hogy a k-palindrom egész számot 2002-re alkossa, míg az 1010 nem rendezhető át k-palindrom egész számmá.
Az n számjegyet tartalmazó jó egész számok számát adja eredményül.
Ne feledje, hogy egyetlen egész számnak sem lehet kezdő nullája, sem az átrendezés előtt, sem utána. Az 1010 például nem rendezhető át 101-es formátumba.

1. példa:

Bemenet: n = 3, k = 5
Kimenet: 27
Magyarázat:
Néhány jó egész szám:

551, mert átrendezhető 515-re.
525 mert már K-palindrom.

2. példa:

Bemenet: n = 1, k = 4
Kimenet: 2
Magyarázat:
A két jó egész szám a 4 és a 8.

3. példa:

Bemenet: n = 5, k = 6
Kimenet: 2468

Korlátok:

1 < = n <= 10
1 < = k <= 9


Kapsz egy egész hatványt és két egész tömb sebzést és egészséget, mindkettő n hosszúságú.
Bobnak n ellensége van, ahol az i ellenség másodpercenként damage[i] pont sebzést okoz Bobnak, amíg él (azaz health[i] > 0).
Minden másodpercben, miután az ellenségek sebzést okoztak Bobnak, kiválaszt egyet a még élő ellenségek közül, és erőpontokat oszt ki nekik.
Határozd meg a sebzéspontok minimális összegét, amelyet Bobnak osztanak, mielőtt mind az n ellenség meghalna.

1. példa:

Bemenet: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Kimenet: 39
Magyarázat:

Támadd meg a 3. ellenséget az első két másodpercben, ezután a 3. ellenség leesik, a Bobnak járó sebzéspontok száma 10 + 10 = 20 pont.
Támadd meg a 2. ellenséget a következő két másodpercben, ezután a 2. ellenség leesik, a Bobnak járó sebzéspontok száma 6 + 6 = 12 pont.
Támadd meg a 0. ellenséget a következő másodpercben, ezután a 0. ellenség leesik, a Bobnak járó sebzéspontok száma 3 pont.
Támadd meg az 1. ellenséget a következő két másodpercben, ami után az 1. ellenség leesik, a Bobnak járó sebzéspontok száma 2 + 2 = 4 pont.

2. példa:

Bemenet: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Kimenet: 20
Magyarázat:

Az első másodpercben támadd meg a 0. ellenséget, utána a 0. ellenség leesik, a Bobnak járó sebzéspontok száma 4 pont.
Támadd meg az 1. ellenséget a következő két másodpercben, ami után az 1. ellenség leesik, a Bobnak járó sebzéspontok száma 3 + 3 = 6 pont.
Támadd meg a 2. ellenséget a következő három másodpercben, ezután a 2. ellenség leesik, a Bobnak járó sebzéspontok száma 2 + 2 + 2 = 6 pont.
Támadd meg a 3. ellenséget a következő négy másodpercben, ami után a 3. ellenség leesik, a Bobnak járó sebzéspontok száma 1 + 1 + 1 + 1 = 4 pont.

3. példa:

Bemenet: power = 8, damage = [40], health = [59]
Kimenet: 320

Korlátozások:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Kapsz egy egész hatványt és két egész tömböt károsodás és életerő, mindkettő hossza n.
Bobnak n ellensége van, ahol az ellenség másodpercenként sebzési pontokat okoz Bobnak, amíg életben vannak (azaz életerő[i] > 0).
Minden másodpercben, miután az ellenség sebzést okoz Bobnak, kiválaszt egy még életben lévő ellenséget, és sebzési pontokat oszt ki nekik.
Határozd meg a Bobnak kiosztott sebzési pontok minimális összegét, mielőtt az összes n ellenség meghalna.

1. példa:

Bemenet: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Kimenet: 39
Magyarázat:

Támadja meg a 3. ellenséget az első két másodpercben, amely után a 3. ellenség leesik, a Bobnak kiosztott sebzési pontok száma 10 + 10 = 20 pont.
Támadja meg a 2. ellenséget a következő két másodpercben, amely után a 2. ellenség leesik, a Bobnak kiosztott sebzési pontok száma 6 + 6 = 12 pont.
Támadja meg a 0 ellenséget a következő másodpercben, majd az ellenség leesik, a Bobnak kiosztott sebzési pontok száma 3 pont.
Támadd meg az 1. ellenséget a következő két másodpercben, amely után az 1. ellenség leesik, a Bobnak kiosztott sebzési pontok száma 2 + 2 = 4 pont.

2. példa:

Bemenet: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Kimenet: 20
Magyarázat:

Támadja meg a 0 ellenséget az első másodpercben, majd az ellenség leesik, a Bobnak kiosztott sebzési pontok száma 4 pont.
Támadja meg az 1. ellenséget a következő két másodpercben, amely után az 1. ellenség leesik, a Bobnak kiosztott sebzési pontok száma 3 + 3 = 6 pont.
Támadja meg a 2. ellenséget a következő három másodpercben, amely után a 2. ellenség leesik, a Bobnak kiosztott sebzési pontok száma 2 + 2 + 2 = 6 pont.
Támadd meg a 3. ellenséget a következő négy másodpercben, amely után a 3. ellenség leesik, a Bobnak kiosztott sebzési pontok száma 1 + 1 + 1 + 1 = 4 pont.

3. példa:

Bemenet: power = 8, damage = [40], health = [59]
Kimenet: 320

Korlátok:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Kapsz egy egész hatványt és két egész tömböt károsodás és életerő, mindkettő hossza n.
Bobnak n ellensége van, ahol az ellenség másodpercenként sebzési pontokat okoz Bobnak, amíg életben vannak (azaz életerő[i] > 0).
Minden másodpercben, miután az ellenség sebzést okoz Bobnak, kiválaszt egy még életben lévő ellenséget, és sebzési pontokat oszt ki nekik.
Határozd meg a Bobnak kiosztott sebzéspontok minimális összegét, mielőtt az összes n ellenség meghalna.

1. példa:

Bemenet:  power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Kimenet: 39
Magyarázat:

Támadja meg a 3. ellenséget az első két másodpercben, amely után a 3. ellenség leesik, a Bobnak kiosztott sebzéspontok száma 10 + 10 = 20 pont.
Támadja meg a 2. ellenséget a következő két másodpercben, amely után a 2. ellenség leesik, a Bobnak kiosztott sebzéspontok száma 6 + 6 = 12 pont.
Támadja meg a 0 ellenséget a következő másodpercben, majd az ellenség 0 csökken, a Bobnak kiosztott sebzéspontok száma 3 pont.
Támadd meg az 1. ellenséget a következő két másodpercben, amely után az 1. ellenség leesik, a Bobnak kiosztott sebzéspontok száma 2 + 2 = 4 pont.

2. példa:

Bemenet: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Kimenet: 20
Magyarázat:

Támadja meg a 0 ellenséget az első másodpercben, majd az ellenség 0 csökken, a Bobnak kiosztott sebzéspontok száma 4 pont.
Támadja meg az 1. ellenséget a következő két másodpercben, amely után az 1. ellenség leesik, a Bobnak kiosztott sebzéspontok száma 3 + 3 = 6 pont.
Támadja meg a 2. ellenséget a következő három másodpercben, amely után a 2. ellenség leesik, a Bobnak kiosztott sebzéspontok száma 2 + 2 + 2 = 6 pont.
Támadd meg a 3. ellenséget a következő négy másodpercben, amely után a 3. ellenség leesik, a Bobnak kiosztott sebzéspontok száma 1 + 1 + 1 + 1 = 4 pont.

3. példa:

Bemenet: teljesítmény = 8, sérülés = [40], állapot = [59]
Kimenet: 320

Korlátok:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4


Adott egy m x n bináris mátrixrács és egy egész szám egészség.
A bal felső sarokban (0, 0) kezded, és a jobb alsó sarokba (m - 1, n - 1) szeretnél eljutni.
Felfelé, lefelé, balra vagy jobbra mozoghatsz egyik cellából a másik szomszédos cellába, amíg az egészséged pozitív marad.
Azok a cellák (i, j), amelyeknél a grid[i][j] = 1, nem biztonságosnak minősülnek, és az egészségedet 1-gyel csökkentik.
Visszaad true-t, ha az utolsó cellát 1 vagy annál nagyobb egészségértékkel érheted el, ellenkező esetben false-t.

Példa 1:

Bemenet: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Kimenet: true
Magyarázat:
Az utolsó cellát az alatta lévő szürke cellákon végigsétálva biztonságosan elérhetjük.

Példa 2:

Bemenet: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Kimenet: false
Magyarázat:
Legalább 4 egészségpont szükséges ahhoz, hogy biztonságosan elérjük az utolsó cellát.

Példa 3:

Bemenet: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Kimenet: true
Magyarázat:
Az utolsó cellát az alatta lévő szürke cellákon végigsétálva biztonságosan elérhetjük.

Minden olyan útvonal, amely nem az (1, 1) cellán keresztül vezet, nem biztonságos, mivel az utolsó cellába érve az életerőd 0-ra csökken.

Korlátozások:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] értéke 0 vagy 1.

Kapsz egy m x n bináris mátrix rácsot és egy egész állapotot.
A bal felső sarokban indul (0, 0), és szeretne eljutni a jobb alsó sarokhoz (m - 1, n - 1).
Felfelé, lefelé, balra vagy jobbra mozoghat egyik cellából a másik szomszédos cellába, amíg az állapota pozitív marad.
Azok az (i, j) cellák, amelyeknél a grid[i][j] = 1, nem minősül biztonságosnak, és 1-gyel csökkenti az egészséget.
Az igaz értéket adja vissza, ha eléri a végső cellát 1 vagy annál nagyobb állapotértékkel, és hamis értéket ad vissza.

1. példa:

Bemenet: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Kimenet: true
Magyarázat:
A végső cellát biztonságosan elérheti az alábbi szürke cellák mentén.

2. példa:

Bemenet: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Kimenet: false
Magyarázat:
A végső sejt biztonságos eléréséhez legalább 4 életpontra van szükség.

3. példa:

Bemenet: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Kimenet: true
Magyarázat:
A végső cellát biztonságosan elérheti az alábbi szürke cellák mentén.

Minden olyan útvonal, amely nem megy át a cellán (1, 1), nem biztonságos, mivel az állapota 0-ra csökken, amikor eléri az utolsó cellát.

Korlátozások:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] értéke 0 vagy 1.

Kapsz egy m x n bináris mátrix rácsot és egy egész állapotot.
A bal felső sarokban indul (0, 0), és szeretne eljutni a jobb alsó sarokhoz (m - 1, n - 1).
Felfelé, lefelé, balra vagy jobbra mozoghat egyik cellából a másik szomszédos cellába, amíg az állapota pozitív marad.
Azok az (i, j) cellák, amelyeknél a rács[i][j] = 1, nem tekinthetők biztonságosnak, és 1-gyel csökkentik az egészséget.
Az igaz értéket adja vissza, ha eléri a végső cellát 1 vagy annál nagyobb állapotértékkel, és hamis értéket ad vissza.

1. példa:

Bemenet: grid= [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Kimenet: igaz
Magyarázat:
A végső cellát biztonságosan elérheti az alábbi szürke cellák mentén.

2. példa:

Bemenet: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0, 0,1,0,1,0]], health = 3
Kimenet: hamis
Magyarázat:
A végső sejt biztonságos eléréséhez legalább 4 életpontra van szükség.

3. példa:

Bemenet: grid  = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Kimenet: igaz
Magyarázat:
A végső cellát biztonságosan elérheti az alábbi szürke cellák mentén.

Minden olyan útvonal, amely nem megy át a cellán (1, 1), nem biztonságos, mivel az állapota 0-ra csökken, amikor eléri az utolsó cellát.

Korlátozások:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] is either 0 or 1.


Kapsz egy egész tömb számot és egy pozitív egész számot k .
A 2 * x méretű seq szekvencia értéke a következőképpen határozható meg:

(seq[0] VAGY seq[1] VAGY ... VAGY seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... VAGY seq[2 * x - 1]).

Visszaadja a 2 * k méretű számok bármely részsorozatának maximális értékét.

1. példa:

Bemenet: nums = [2,6,7], k = 1
Kimenet: 5
Magyarázat:
A [2, 7] részsorozat maximális értéke 2 XOR 7 = 5.

2. példa:

Bemenet: nums = [4,2,5,6,7], k = 2
Kimenet: 2
Magyarázat:
A [4, 5, 6, 7] részsorozat maximális értéke (4 VAGY 5) XOR (6 VAGY 7) = 2.

Korlátok:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Kapsz egy egész számokból álló tömböt és egy pozitív egész számot.
A 2 * x méretű seq értékét a következőképpen határozzuk meg:

(seq[0] VAGY seq[1] VAGY ... VAGY seq[x - 1]) XOR (seq[x] VAGY szekv.[x + 1] VAGY ... VAGY szekv[2 * x - 1]).

Adj vissza a 2 * k méretű bármely részsorozat maximális értékét.

1. példa:

Bemenet: nums= [2,6,7], k = 1
Kimenet: 5
Magyarázat:
A [2, 7] részsorozat maximális értéke 2 XOR 7 = 5.

2. példa:

Bemenet: nums = [4,2,5,6,7], k = 2
Kimenet: 2
Magyarázat:
A [4, 5, 6, 7] részsorozat maximális értéke (4 VAGY 5) XOR (6 VAGY 7) = 2.

Korlátozások:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Kapsz egy egész tömb számot és egy pozitív egész számot.
A 2 * x méretű szekvencia értékét a következőképpen határozzuk meg:

(seq[0] VAGY seq[1] VAGY ... VAGY seq[x - 1]) XOR (seq[x] VAGY szekv.[x + 1] VAGY ... VAGY szekv[2 * x - 1]).

A 2 * k méretű számok bármely részsorozatának maximális értékét adja vissza.

1. példa:

Bemenet: nums = [2,6,7], k = 1
Kimenet: 5
Magyarázat:
A [2, 7] részsorozat maximális értéke 2 XOR 7 = 5.

2. példa:

Bemenet:  nums = [4,2,5,6,7], k = 2
Kimenet: 2
Magyarázat:
A [4, 5, 6, 7] részsorozat maximális értéke (4 VAGY 5) XOR (6 VAGY 7) = 2.

Korlátozások:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2


Kapunk egy n hosszúságú egész koordinátákból álló 2D tömböt és egy k egész számot, ahol 0 <= k < n.
coordinates[i] = [x_i, y_i] az (x_i, y_i) pontot jelöli egy 2D síkban.
Az m hosszúságú növekvő útvonalat az alábbi pontok listájaként határozzuk meg: (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m):

x_i < x_i + 1 és y_i < y_i + 1 minden i-re, ahol 1 <= i < m.
(x_i, y_i) a megadott koordinátákban van minden i-re, ahol 1 <= i <= m.

Egy olyan növekvő útvonal maximális hosszát adja vissza, amely coordinates[k] tartalmaz.

1. példa:

Bemenet: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Kimenet: 3
Magyarázat:
(0, 0), (2, 2), (5, 3) a (2, 2) leghosszabb növekvő útvonal.

2. példa:

Bemenet: coordinates = [[2,1],[7,0],[5,6]], k = 2
Kimenet: 2
Magyarázat:
(2, 1), (5, 6) az (5, 6) leghosszabb növekvő útvonal.

Korlátozások:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
A coordinates összes eleme különböző.
0 <= k <= n - 1

Kapunk egy n hosszúságú egész koordináták 2D tömbjét és egy k egész számot, ahol 0 <= k < n.
coordinates[i] = [x_i, y_i] jelenti a (x_i, y_i) pontot egy 2D síkon.
Az m hosszúság növelését az (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) pontok felsorolásaként határozzuk meg úgy, hogy:

x_i < x_i + 1 és y_i < y_i + 1 minden i-re, ahol 1 <= i < m.
(x_i, y_i) minden i megadott koordinátáiban van, ahol 1 <= i <= m.

Adjuk vissza a koordinátákat[k] tartalmazó növekvő útvonal maximális hosszát.

1. példa:

Bemenet: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Kimenet: 3
Magyarázat:
(0, 0), (2, 2), (5, 3) a leghosszabb növekvő út, amely tartalmazza a (2, 2) értéket.

2. példa:

Bemenet: coordinates= [[2,1],[7,0],[5,6]], k = 2
Kimenet: 2
Magyarázat:
(2, 1), (5, 6) a leghosszabb növekvő út, amely tartalmazza az (5, 6) értéket.

Korlátok:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
A koordináták minden eleme eltérő.
0 < = k <= n - 1

Kapunk egy n hosszúságú egész koordináták 2D tömbjét és egy k egész számot, ahol 0 <= k < n.
koordináták[i] = [x_i, y_i] jelzi a pontot (x_i, y_i) egy 2D síkban.
Az m hosszúság növelését az (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) pontok felsorolásaként határozzuk meg úgy, hogy:

x_i < x_i + 1 és y_i < y_i + 1 minden i-re, ahol 1 <= i < m.
(x_i, y_i) minden i megadott koordinátáiban van, ahol 1 <= i <= m.

A koordinátákat[k] tartalmazó növekvő útvonal maximális hosszát adja eredményül.

1. példa:

Bemenet: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Kimenet: 3
Magyarázat:
(0, 0), (2, 2), (5, 3) a leghosszabb növekvő út, amely tartalmazza a (2, 2) értéket.

2. példa:

Bemenet: coordinates = [[2,1],[7,0],[5,6]], k = 2
Kimenet: 2
Magyarázat:
(2, 1), (5, 6) a leghosszabb növekvő út, amely tartalmazza az (5, 6) értéket.

Korlátok:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
A koordináták minden eleme eltérő.
0 < = k <= n - 1


Adott egy tömbnyi string üzenet és egy tömbnyi string bannedWords.
Egy szótömb akkor tekinthető spamnek, ha legalább két olyan szó van benne, amely pontosan megegyezik a bannedWords bármelyik szavával.
Visszaadja az true értéket, ha a tömb üzenete spam, és a false értéket, ha nem.

Példa 1:

Bemenet: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Kimenet: true
Magyarázat:
Az üzenettömb "hello" és "world" szavai egyaránt megjelennek a bannedWords tömbben.

2. példa:

Bemenet: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Kimenet: false
Magyarázat:
Az üzenet tömbből csak egy szó("programming") szerepel a bannedWords tömbben.

Korlátozások:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] és bannedWords[i] csak kisbetűs angol betűkből áll.

Kapsz egy tömb karakterlánc üzenetet és egy tömb karakterláncok bannedWords.
Egy szótömb akkor minősül spamnek, ha legalább két olyan szó van benne, amelyek pontosan megegyeznek a bannedWords bármely szavával.
Igaz értéket ad vissza, ha a tömbüzenet spam, és false értéket egyébként.

1. példa:

Bemenet: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Kimenet: true
Magyarázat:
Az üzenettömbben szereplő „hello” és „world” szavak egyaránt megjelennek a bannedWords tömbben.

2. példa:

Bemenet: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Kimenet: false
Magyarázat:
Csak egy szó jelenik meg az üzenettömbből ("programozás") a bannedWords tömbben.

Korlátozások:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
üzenet[i] és tiltottSzavak[i] csak kisbetűket tartalmaznak angolul.

Kapsz egy tömb karakterlánc üzenetet és egy tömb karakterláncok bannedWords.
Egy szótömb akkor minősül spamnek, ha legalább két olyan szó van benne, amelyek pontosan megegyeznek a bannedWords bármely szavával.
Igaz értéket ad vissza, ha a tömbüzenet spam, és false értéket egyébként.

1. példa:

Bemenet: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Kimenet: igaz
Magyarázat:
Az üzenettömbben szereplő „hello” és „world” szavak egyaránt megjelennek a bannedWords tömbben.

2. példa:

Bemenet: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Kimenet: hamis
Magyarázat:
Csak egy szó jelenik meg az üzenettömbből ("programozás") a bannedWords tömbben.

Korlátozások:

1 <= message.length, bannedWords.length <= 10^5
1 <= üzenet[i].hosszúság, bannedWords[i].length <= 15
üzenet[i] és bannedWords[i] csak kis angol betűket tartalmaznak.


Adott egy egész szám mountainHeight, amely a hegy magasságát jelöli.
Adott továbbá egy workerTimes egész számtömb, amely a munkások munkaidejét jelöli másodpercben.
A munkások egyszerre dolgoznak a hegy magasságának csökkentésén. Az i. munkás esetében:

Ahhoz, hogy a hegy magassága x-szel csökkenjen, workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x másodperc. Például:

A hegy magasságának 1-gyel való csökkentéséhez workerTimes[i] másodpercek kellenek.
A hegy magasságának 2-vel való csökkentéséhez workerTimes[i] + workerTimes[i] * 2 másodperc szükséges, és így tovább.

Adjon vissza egy egész számot, amely azt a minimális másodpercszámot jelenti, amely a munkásoknak szükséges ahhoz, hogy a hegy magassága 0 legyen.

Példa 1:

Bemenet: mountainHeight = 4, workerTimes = [2,1,1]
Kimenet: 3
Magyarázat:
A hegy magasságát például így lehet 0-ra csökkenteni:

A 0 munkás 1-re csökkenti a magasságot, ami workerTimes[0] = 2 másodpercet vesz igénybe.
Az 1. munkás 2-vel csökkenti a magasságot, ami workerTimes[1] + workerTimes[1] * 2 = 3 másodpercig tart.
A 2. munkás 1-nel csökkenti a magasságot, ami workerTimes[2] = 1 másodperc.

Mivel egyszerre dolgoznak, a minimálisan szükséges idő max(2, 3, 1) = 3 másodperc.

2. példa:

Bemenet: mountainHeight = 10, workerTimes = [3,2,2,4]
Kimenet: 12
Magyarázat:

A 0. munkás csökkenti a magasságot 2-vel, ami workerTimes[0] + workerTimes[0] * 2 = 9 másodpercet vesz igénybe.
Az 1-es munkás 3-tal csökkenti a magasságot, ami workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 másodperc.
A 2. munkás 3-nal csökkenti a magasságot, ami workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 másodperc.
A 3. munkás 2vel csökkenti a magasságot, ami workerTimes[3] + workerTimes[3] * 2 = 12 másodperc.

A szükséges másodpercek száma max(9, 12, 12, 12, 12) = 12 másodperc.

Példa 3:

Bemenet: mountainHeight = 5, workerTimes = [1]
Kimenet: 15
Magyarázat:
Ebben a példában csak egy munkás van, így a válasz workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Korlátozások:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Egy hegy magasságát jelölő egész hegymagasságot kapsz.
Ezenkívül kap egy workerTimes egész tömböt, amely a dolgozók munkaidejét másodpercben jelzi.
A munkások egyszerre dolgoznak a hegy magasságának csökkentésén. Az én dolgozónak:

A hegy magasságának x-szel való csökkentéséhez workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x másodperc szükséges. Például:

A hegy magasságának 1-gyel való csökkentése workerTimes[i] másodpercet vesz igénybe.
A hegy magasságának 2-vel való csökkentéséhez workerTimes[i] + workerTimes[i] * 2 másodpercre van szükség, és így tovább.

Adjon vissza egy egész számot, amely azt a minimális másodpercszámot jelenti, amelyre a munkásoknak szüksége van ahhoz, hogy a hegy magasságát 0 legyen.

1. példa:

Bemenet: mountainHeight = 4, workerTimes = [2,1,1]
Kimenet: 3
Magyarázat:
Az egyik módja annak, hogy a hegy magassága 0-ra csökkenthető:

A 0 dolgozó 1-gyel csökkenti a magasságot, és a workerTimes[0] = 2 másodpercet vesz fel.
Az 1. dolgozó 2-vel csökkenti a magasságot, így workerTimes[1] + workerTimes[1] * 2 = 3 másodperc.
A 2. munkás 1-gyel csökkenti a magasságot, így workerTimes[2] = 1 másodperc.

Mivel egyidejűleg működnek, a szükséges minimális idő max(2, 3, 1) = 3 másodperc.

2. példa:

Bemenet: mountainHeight = 10, workerTimes = [3,2,2,4]
Kimenet: 12
Magyarázat:

A 0 dolgozó 2-vel csökkenti a magasságot, így workerTimes[0] + workerTimes[0] * 2 = 9 másodperc.
Az 1. dolgozó 3-mal csökkenti a magasságot, így workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 másodperc.
A 2. dolgozó 3-mal csökkenti a magasságot, így workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 másodperc.
A 3. dolgozó 2-vel csökkenti a magasságot, így workerTimes[3] + workerTimes[3] * 2 = 12 másodperc.

A szükséges másodpercek száma max(9, 12, 12, 12) = 12 másodperc.

3. példa:

Bemenet: mountainHeight = 5, workerTimes = [1]
Kimenet: 15
Magyarázat:
Ebben a példában csak egy dolgozó szerepel, így a válasz workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Korlátozások:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Egy hegy magasságát jelző egész hegymagasságot kapsz.
Ezenkívül kap egy workerTimes egész tömböt, amely a dolgozók munkaidejét másodpercben jelzi.
A munkások egyszerre dolgoznak a hegy magasságának csökkentésén. Az én dolgozónak:

A hegy magasságának x-szel való csökkentéséhez workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x másodperc szükséges. Például:

A hegy magasságának 1-gyel való csökkentése workerTimes[i] másodpercet vesz igénybe.
A hegy magasságának 2-vel való csökkentéséhez workerTimes[i] + workerTimes[i] * 2 másodpercre van szükség, és így tovább.

Adjon vissza egy egész számot, amely azt a minimális másodpercszámot jelenti, amelyre a munkásoknak szüksége van ahhoz, hogy a hegy magasságát 0 legyen.

1. példa:

Bemenet: mountainHeight = 4, workerTimes = [2,1,1]
Kimenet: 3
Magyarázat:
Az egyik módja annak, hogy a hegy magassága 0-ra csökkenthető:

A 0 dolgozó 1-gyel csökkenti a magasságot, és a workerTimes[0] = 2 másodpercet vesz fel.
Az 1. dolgozó 2-vel csökkenti a magasságot, így workerTimes[1] + workerTimes[1] * 2 = 3 másodperc.
A 2. munkás 1-gyel csökkenti a magasságot, így workerTimes[2] = 1 másodperc.

Mivel egyidejűleg működnek, a szükséges minimális idő max(2, 3, 1) = 3 másodperc.

2. példa:

Bemenet: mountainHeight = 10, workerTimes = [3,2,2,4]
Kimenet: 12
Magyarázat:

A 0 dolgozó 2-vel csökkenti a magasságot, így workerTimes[0] + workerTimes[0] * 2 = 9 másodperc.
Az 1. dolgozó 3-mal csökkenti a magasságot, így workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 másodperc.
A 2. dolgozó 3-mal csökkenti a magasságot, így workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 másodperc.
A 3. dolgozó 2-vel csökkenti a magasságot, így workerTimes[3] + workerTimes[3] * 2 = 12 másodperc.

A szükséges másodpercek száma max(9, 12, 12, 12) = 12 másodperc.

3. példa:

Bemenet: mountainHeight = 5, workerTimes = [1]
Kimenet: 15
Magyarázat:
Ebben a példában csak egy dolgozó szerepel, így a válasz workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Korlátozások:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6


Adott két karakterlánc, word1 és word2.
Egy x karakterláncot akkor nevezünk érvényesnek, ha x átrendezhető úgy, hogy word2 előtagja legyen.
Add vissza az word1 összes érvényes részkarakterláncának számát.

Példa 1:

Bemenet: word1 = "bcca", word2 = "abc"
Kimenet: 1
Magyarázat:
Az egyetlen érvényes részkarakterlánc a "bcca", ami átrendezhető "abcc"-vé, amelynek "abc" az előtagja.

Példa 2:

Bemenet: word1 = "abcabc", word2 = "abc"
Kimenet: 10
Magyarázat:
Az összes részkarakterlánc, kivéve az 1 és 2 méretűeket, érvényes.

Példa 3:

Bemenet: word1 = "abcabc", word2 = "aaabc"
Kimenet: 0

Korlátozások:

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

Két karakterláncot kapsz: szó1 és szó2.
Az x karakterláncot érvényesnek nevezzük, ha az x átrendezhető úgy, hogy a word2 előtag legyen.
A word1 érvényes részkarakterláncainak teljes számát adja vissza.

1. példa:

Bemenet: word1 = "bcca", word2 = "abc"
Kimenet: 1
Magyarázat:
Az egyetlen érvényes részkarakterlánc a „bcca”, amely átrendezhető „abcc”-re, amelynek előtagja „abc”.

2. példa:

Bemenet: word1 = "abcabc", word2 = "abc"
Kimenet: 10
Magyarázat:
Az 1-es és 2-es méretű karakterláncok kivételével az összes karakterlánc érvényes.

3. példa:

Bemenet: word1 = "abcabc", word2 = "aaabc"
Kimenet: 0

Korlátozások:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
A szó1 és a szó2 csak kisbetűket tartalmaz angolul.

Adott két karakterlánc word1 és word2.
Egy x karakterláncot akkor nevezünk érvényesnek, ha x átrendezhető úgy, hogy előtagja word2 legyen.
Adja vissza a word1 érvényes részláncainak teljes számát.

1. példa:

Bemenet: word1 = "bcca", word2 = "abc"
Kimenet: 1
Magyarázat:
Az egyetlen érvényes részlánc a „bcca”, amely átrendezhető „abcc”-re, ha az „abc” előtagot használjuk.

2. példa:

Bemenet: word1 = "abcabc", word2 = "abc"
Kimenet: 10
Magyarázat:
Az 1 és 2 méretű részláncok kivételével minden részlánc érvényes.

3. példa:

Bemenet: word1 = "abcabc", word2 = "aaabc"
Kimenet: 0

Korlátozások:

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


Alice és Bob egy játékot játszanak. Kezdetben Alice-nek van egy szó string word = "a".
Adott egy pozitív egész szám k.
Most Bob megkéri Alice-t, hogy végezze el a következő műveletet örökké:

Generáljon egy új karakterláncot azáltal, hogy a szó minden karakterét az angol ábécé következő karakterére változtatja, és fűzze hozzá az eredeti szóhoz.

Például a művelet elvégzése "c"-n "cd"-t generál, és a "zb"-n "zbac"-ot generál.
Adjuk vissza a szó k^adik karakterének értékét, miután elegendő műveletet végeztünk ahhoz, hogy a szónak legalább k karaktere legyen.
Megjegyzendő, hogy a "z" karakter megváltoztatható "a"-ra a művelet során.

Példa 1:

Bemenet: k = 5
Kimenet: "b"
Magyarázat:
Kezdetben word = "a". Háromszor kell végrehajtanunk a műveletet:

A generált karakterlánc "b", a szó "ab" lesz.
A generált karakterlánc "bc", a szó "abbc" lesz.
A generált karakterlánc "bccd", a szó "abbcbccd" lesz.

Példa 2:

Bemenet: k = 10
Kimenet: "c"

Korlátok:

1 <= k <= 500

Alice és Bob játszanak. Kezdetben Alice-nek van egy karakterlánca: "a".
Kapsz egy k pozitív egész számot.
Most Bob megkéri Alice-t, hogy végezze el a következő műveletet örökre:

Hozzon létre egy új karakterláncot úgy, hogy a szó minden karakterét az angol ábécé következő karakterére módosítja, és hozzáfűzi az eredeti szóhoz.

Például a „c” művelet végrehajtása „cd”, a „zb” művelet végrehajtása pedig „zbac” generál.
Visszaadja a k^-edik karakter értékét a Wordben, miután elegendő műveletet végeztek a szóhoz, hogy legalább k karakter legyen.
Vegye figyelembe, hogy a műveletben a „z” karakter „a”-ra változtatható.

1. példa:

Bemenet: k = 5
Kimenet: "b"
Magyarázat:
Kezdetben a szó = "a". A műveletet háromszor kell elvégeznünk:

A generált karakterlánc „b”, a szó „ab” lesz.
A generált karakterlánc „bc”, a szó „abbc” lesz.
A generált karakterlánc „bccd”, a szó „abbcbccd” lesz.

2. példa:

Bemenet: k = 10
Kimenet: "c"

Korlátozások:

1 <= k <= 500

Alice és Bob egy játékot játszanak. Kezdetben Alice-nek van egy szó string word = "a".
Adott egy pozitív egész szám k.
Most Bob megkéri Alice-t, hogy végezze el a következő műveletet örökké:

Generáljon egy új karakterláncot azáltal, hogy a szó minden karakterét az angol ábécé következő karakterére változtatja, és fűzze hozzá az eredeti szóhoz.

Például a művelet elvégzése "c"-n "cd"-t generál, és a "zb"-n "zbac"-ot generál.
Adjuk vissza a szó k^adik karakterének értékét, miután elegendő műveletet végeztünk ahhoz, hogy a szónak legalább k karaktere legyen.
Megjegyzendő, hogy a "z" karakter megváltoztatható "a"-ra a művelet során.

Példa 1:

Bemenet: k = 5
Kimenet: "b"
Magyarázat:
Kezdetben word = "a". Háromszor kell végrehajtanunk a műveletet:

A generált karakterlánc "b", a szó "ab" lesz.
A generált karakterlánc "bc", a szó "abbc" lesz.
A generált karakterlánc "bccd", a szó "abbcbccd" lesz.

Példa 2:

Bemenet: k = 10
Kimenet: "c"

Korlátozások:

1 <= k <= 500


Kapsz egy karakterláncszót és egy nem negatív egész k számot.
Visszaadja azoknak a szórészeknek a teljes számát, amelyek minden magánhangzót ('a', 'e', 'i', 'o' és 'u') tartalmaznak legalább egyszer és pontosan k mássalhangzókat.

1. példa:

Bemenet: szó = "aeioqq", k = 1
Kimenet: 0
Magyarázat:
Nincs minden magánhangzóhoz tartozó alszöveg.

2. példa:

Bemenet: szó = "aeiou", k = 0
Kimenet: 1
Magyarázat:
Az egyetlen alkarakterlánc, amely minden magánhangzóval és nulla mássalhangzóval rendelkezik, a szó[0..4], ami "aeiou".

3. példa:

Bemenet: szó = "ieaouqqieaouqq", k = 1
Kimenet: 3
Magyarázat:
Az alkarakterláncok minden magánhangzóval és egy mássalhangzóval a következők:

szó[0..5], ami "ieaouq".
szó[6..11], ami "qieaou".
szó[7..12], ami "ieaouq".

Korlátok:

5 <= szó.length <= 250
szó csak kisbetűs angol betűkből áll.
0 <= k <= szó.length - 5

Kapsz egy karakterláncszót és egy nem negatív egész k számot.
Visszaadja azoknak a szórészeknek a teljes számát, amelyek minden magánhangzót ('a', 'e', 'i', 'o' és 'u') tartalmaznak legalább egyszer és pontosan k mássalhangzókat.

1. példa:

Bemenet: szó = "aeioqq", k = 1
Kimenet: 0
Magyarázat:
Nincs minden magánhangzóhoz tartozó alszöveg.

2. példa:

Bemenet: word = "aeiou", k = 0
Kimenet: 1
Magyarázat:
Az egyetlen alkarakterlánc, amely minden magánhangzóval és nulla mássalhangzóval rendelkezik, a word[0..4], ami "aeiou".

3. példa:

Bemenet: word = "ieaouqqieaouqq", k = 1
Kimenet: 3
Magyarázat:
Az alkarakterláncok minden magánhangzóval és egy mássalhangzóval a következők:

word[0..5], ami "ieaouq".
szó[6..11], ami "qieaou".
szó[7..12], ami "ieaouq".

Korlátok:

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

Kapsz egy karakterlánc szót és egy k nem negatív egész számot.
Visszaadja a szó azon részkarakterláncainak teljes számát, amelyek minden magánhangzót ('a', 'e', 'i', 'o' és 'u') tartalmaznak legalább egyszer, és pontosan k mássalhangzót.

1. példa:

Bemenet: word = "aeioqq", k = 1
Kimenet: 0
Magyarázat:
Nincs minden magánhangzóhoz részstring.

2. példa:

Bemenet:  word = "aeiou", k = 0
Kimenet: 1
Magyarázat:
Az egyetlen részstring minden magánhangzóval és nulla mássalhangzóval a word[0..4], ami az "aeiou".

3. példa:

Bemenet: word = "ieaouqqieaouqq", k = 1
Kimenet: 3
Magyarázat:
Az egyes magánhangzókkal és egy mássalhangzóval rendelkező részstringek a következők:

word[0..5], ami "ieaouq".
word[6..11], ami "qieaou".
word[7..12], ami "ieaouq".

Korlátozások:

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


Van egy integers típusú nums tömböd, amely 3 elemű.
Add vissza azt a legnagyobb lehetséges számot, amelynek bináris ábrázolását a nums elemeinek bináris ábrázolásának valamilyen sorrendben történő összefűzésével lehet kialakítani.
Vegye figyelembe, hogy egyetlen szám bináris ábrázolása sem tartalmaz kezdő nullákat.

1. példa:

Bemenet: nums = [1,2,3]
Kimenet: 30
Magyarázat:
Kösd össze a számokat a [3, 1, 2] sorrendben, hogy megkapd az „11110” eredményt, amely a 30 bináris reprezentációja.

2. példa:

Bemenet: nums = [2,8,16]
Kimenet: 1296
Magyarázat:
Kösd össze a számokat a [2, 8, 16] sorrendben, hogy megkapd az "10100010000" eredményt, amely az 1296 bináris reprezentációja.

Korlátozások:

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

Kapsz egy tömböt egész számokból, 3-as méretű számokat.
Azt a maximális számot adja eredményül, amelynek bináris ábrázolása létrehozható úgy, hogy az összes elem bináris ábrázolását valamilyen sorrendben összefűzi.
Ne feledje, hogy bármely szám bináris ábrázolása nem tartalmaz bevezető nullákat.

1. példa:

Bemenet: nums = [1,2,3]
Kimenet: 30
Magyarázat:
Fűzze össze a számokat a [3, 1, 2] sorrendben, hogy megkapja az "11110" eredményt, amely a 30 bináris ábrázolása.

2. példa:

Bemenet: nums = [2,8,16]
Kimenet: 1296
Magyarázat:
Fűzze össze a számokat [2, 8, 16] sorrendben, hogy megkapja az "10100010000" eredményt, amely az 1296 bináris ábrázolása.

Korlátok:

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

3-as méretű egész számokból álló tömböt kapsz.
Adja vissza azt a lehetséges maximális számot, amelynek bináris reprezentációja úgy alakítható ki, hogy az összes elem bináris reprezentációját számokban valamilyen sorrendben összefűzzük.
Vegye figyelembe, hogy egyetlen szám bináris ábrázolása sem tartalmaz kezdő nullákat.

1. példa:

Bemenet: nums= [1,2,3]
Kimenet: 30
Magyarázat:
Kösd össze a számokat a [3, 1, 2] sorrendben, hogy megkapd az „11110” eredményt, amely a 30 bináris reprezentációja.

2. példa:

Bemenet: nums= [2,8,16]
Kimenet: 1296
Magyarázat:
Kösd össze a számokat a [2, 8, 16] sorrendben, hogy megkapd az "10100010000" eredményt, amely az 1296 bináris reprezentációja.

Korlátozások:

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


Egy `nums` egész szám tömb és egy `queries` egész szám tömb adott. Legyen `gcdPairs` egy tömb, amelyet úgy kapunk meg, hogy kiszámítjuk az összes lehetséges pár `(nums[i], nums[j])`, ahol `0 <= i < j < n`, legnagyobb közös osztóját (GCD), majd ezeket az értékeket növekvő sorrendbe rendezzük. Minden lekérdezéshez `queries[i]`, meg kell találni az elemet a `gcdPairs` `queries[i]` indexén. Adjon vissza egy `answer` egész szám tömböt, ahol `answer[i]` az érték `gcdPairs[queries[i]]` minden lekérdezéshez. Az `gcd(a, b)` a és b legnagyobb közös osztóját jelenti.

1. példa:

Input: nums = [2,3,4], queries = [0,2,2]
Output: [1,2,2]
Magyarázat:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Miután növekvő sorrendbe rendeztük, gcdPairs = [1, 1, 2].
Tehát a válasz [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

2. példa:

Input: nums = [4,4,2,1], queries = [5,3,1,0]
Output: [4,2,1,1]
Magyarázat:
gcdPairs növekvő sorrendben rendezve [1, 1, 1, 2, 2, 4].

3. példa:

Input: nums = [2,2], queries = [0,0]
Output: [2,2]
Magyarázat:
gcdPairs = [2].

Feltételek:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Kap egy n hosszúságú egész tömböt és egy egész tömb lekérdezést.
Jelölje a gcdPairs egy tömböt, amelyet az összes lehetséges pár (nums[i], nums[j]) GCD-jének kiszámításával kapunk, ahol 0 <= i < j < n, majd ezeket az értékeket növekvő sorrendbe rendezzük.
Minden lekérdezési lekérdezéshez[i] meg kell találnia a elemet az index queryries[i] helyen a gcdPairs fájlban.
Egy egész tömbválaszt ad vissza, ahol answer[i] az egyes lekérdezések gcdPairs[queries[i]] értéke.
A gcd(a, b) kifejezés az a és b legnagyobb közös osztóját jelöli.

1. példa:

Bemenet: nums = [2,3,4], queries = [0,2,2]
Output: [1,2,2]
Kimenet: [1,2,2]
Magyarázat:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Növekvő sorrendbe rendezés után gcdPairs = [1, 1, 2].
Tehát a válasz: [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

2. példa:

Bemenet: nums = [4,4,2,1], queries = [5,3,1,0]
Kimenet: [4,2,1,1]
Magyarázat:
gcdA párok növekvő sorrendbe rendezve [1, 1, 1, 2, 2, 4].

3. példa:

Bemenet: nums = [2,2], queries = [0,0]
Kimenet: [2,2]
Magyarázat:
gcdPairs = [2].

Korlátok:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Kapsz egy n hosszúságú egész tömb  és egy egész tömb lekérdezést.
Legyen gcdPairs egy tömb, amelyet úgy kapunk, hogy kiszámítjuk az összes lehetséges pár (szám[i], szám[j]) GCD-jét, ahol 0 <= i < j < n, majd ezeket az értékeket növekvő sorrendbe rendezzük.
Minden egyes lekérdezéshez [i] meg kell találnia az elemet a gcdPairs [i] index lekérdezésénél.
Egy egész tömb választ ad vissza, ahol a válasz[i] a gcdPairs[queries[i]] értéke minden egyes lekérdezésnél.
A gcd(a, b) kifejezés a és b legnagyobb közös osztóját jelöli.

1. példa:

Bemenet: nums = [2,3,4], queries = [0,2,2]
Kimenet: [1,2,2]
Magyarázat:
gcdPairs = [gcd(számok[0], számok[1]), gcd(számok[0], számok[2]), gcd(számok[1], számok[2])] = [1, 2, 1] .
A növekvő sorrendben történő rendezés után gcdPairs = [1, 1, 2].
Tehát a válasz: [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

2. példa:

Bemenet: nums = [4,4,2,1], queries = [5,3,1,0]
Kimenet: [4,2,1,1]
Magyarázat:
A gcdpárok növekvő sorrendben vannak rendezve: [1, 1, 1, 2, 2, 4].

3. példa:

Bemenet: nums = [2,2], queries = [0,0]
Kimenet: [2,2]
Magyarázat:
gcdPairs = [2].

Korlátozások:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2


Adott egy egész szám tömb nums.
A nums minden elemét a számjegyeinek összegével helyettesítjük.
Az összes csere után adja vissza a nums minimális elemét.

Példa 1:

Bemenet: nums = [10,12,13,14]
Kimenet: 1
Magyarázat:
A nums az összes csere után [1, 3, 4, 5]-re változik, a minimális elem 1.

2. példa:

Input: nums = [1,2,3,4]
Kimenet: 1
Magyarázat:
A nums az összes csere után [1, 2, 3, 4]-re változik, a minimális elem 1.

Példa 3:

Bemenet: nums = [999,19,199]
Kimenet: 10
Magyarázat:
A nums az összes csere után [27, 10, 19] lesz, a minimális elem 10.

Korlátozások:

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

Kap egy egész számokból álló tömböt.
Minden egyes elemet helyettesíti a számjegyeinek összegével.
Adja vissza a tömbben lévő minimális elemet minden csere után.

1. példa:

Bemenet: nums = [10,12,13,14]
Kimenet: 1
Magyarázat:
A tömb [1, 3, 4, 5] lesz minden csere után, a minimális elem 1.

2. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 1
Magyarázat:
A számok az összes csere után [1, 2, 3, 4] lesz, a minimális elem 1.

3. példa:

Bemenet: nums = [999,19,199]
Kimenet: 10
Magyarázat:
A számok minden csere után [27, 10, 19] lesz, minimum 10-es elemmel.

Korlátozások:

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

Kapsz egy egész tömb számát.
Minden egyes elemet számokkal helyettesít a számjegyeinek összegével.
Minden csere után adja vissza a minimális elemet számokban.

példa 1:

Bemenet: nums = [10,12,13,14]
Kimenet: 1
Magyarázat:
A számok értéke [1, 3, 4, 5] lesz minden csere után, minimum 1 elemmel.

példa 2:

Bemenet: nums = [1,2,3,4]
Kimenet: 1
Magyarázat:
A számok az összes csere után [1, 2, 3, 4] lesz, minimum 1 elemmel.

példa 3:

Bemenet: nums = [999,19,199]
Kimenet: 10
Magyarázat:
A számok minden csere után [27, 10, 19] lesz, minimum 10-es elemmel.

Korlátozások:

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


Adunk egy maximumHeight tömböt, ahol a maximumHeight[i] az i^edik toronyhoz rendelhető maximális magasságot jelöli.
Az Ön feladata, hogy minden toronyhoz hozzárendeljen egy magasságot, így:

Az i^edik torony magassága pozitív egész szám, és nem haladja meg a maximumHeight[i] értéket.
Nincs két egyforma magasságú torony.

Adja vissza a toronymagasságok lehetséges maximális összegét. Ha nem lehetséges a magasságok hozzárendelése, adjon vissza -1-et.

Példa 1:

Bemenet: maximumHeight = [2,3,4,3]
Kimenet: 10
Magyarázat:
A magasságokat a következő módon rendelhetjük hozzá: [1, 2, 4, 3].

Példa 2:

Bemenet: maximumHeight = [15,10]
Kimenet: 25
Magyarázat:
A magasságokat a következő módon tudjuk hozzárendelni: [15, 10].

Példa 3:

Bemenet: maximumHeight = [2,2,1]
Kimenet: -1
Magyarázat:
Lehetetlen minden indexhez pozitív magasságot rendelni, hogy ne legyen két azonos magasságú torony.

Korlátozások:

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

Kap egy tömb maximumHeight, ahol maximumHeight[i] jelöli az i^th torony hozzárendelhető maximális magasságát.
Az Ön feladata, hogy minden toronyhoz magasságot rendeljen úgy, hogy:

Az i^th torony magassága pozitív egész szám, és nem haladja meg a maximumHeight[i] értéket.
Nincs két egyforma magasságú torony.

A toronymagasságok maximális lehetséges teljes összegét adja eredményül. Ha nem lehet magasságot hozzárendelni, adja vissza a -1 értéket.

1. példa:

Bemenet: maximumHeight = [2,3,4,3]
Kimenet: 10
Magyarázat:
A magasságokat a következőképpen rendelhetjük hozzá: [1, 2, 4, 3].

2. példa:

Bemenet: maximumHeight = [15,10]
Kimenet: 25
Magyarázat:
A magasságokat a következőképpen rendelhetjük hozzá: [15, 10].

3. példa:

Bemenet: maximumHeight = [2,2,1]
Kimenet: -1
Magyarázat:
Lehetetlen pozitív magasságokat rendelni minden indexhez, hogy két torony magassága ne legyen azonos.

Korlátok:

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

Adunk egy maximumHeight tömböt, ahol a maximumHeight[i] az i^edik toronyhoz rendelhető maximális magasságot jelöli.
Az Ön feladata, hogy minden toronyhoz hozzárendeljen egy magasságot, így:

Az i^edik torony magassága pozitív egész szám, és nem haladja meg a maximumHeight[i] értéket.
Nincs két egyforma magasságú torony.

Adja vissza a toronymagasságok lehetséges maximális összegét. Ha nem lehetséges a magasságok hozzárendelése, adjon vissza -1-et.

1. példa:

Bemenet: maximumHeight = [2,3,4,3]
Kimenet: 10
Magyarázat:
A magasságokat a következő módon rendelhetjük hozzá: [1, 2, 4, 3].

2. példa:

Bemenet: maximumHeight = [15,10]
Kimenet: 25
Magyarázat:
Magasságokat a következő módon rendelhetünk hozzá: [15, 10].

3. példa:

Bemenet: maximumHeight = [2,2,1]
Kimenet: -1
Magyarázat:
Lehetetlen minden indexhez pozitív magasságot rendelni, hogy ne legyen két azonos magasságú torony.

Korlátozások:

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


Két karakterlánc van megadva, word1 és word2.
Egy x karakterlánc majdnem egyenlő y-nal, ha legfeljebb egy karaktert megváltoztathatsz x-ben, hogy azonos legyen y-nal.
Egy indexsorozat érvényes, ha:

Az indexek növekvő sorrendben vannak.
Az indexek helyén lévő karakterek összefűzése word1-ben ugyanebben a sorrendben egy majdnem egyenlő karakterláncot eredményez word2-vel.

Add vissza egy tömböt, amely word2 hosszával azonos méretű, és az ábécérendben legkisebb érvényes indexsorozatot képviseli. Ha nem létezik ilyen indexsorozat, adj vissza egy üres tömböt.
Figyelj arra, hogy a válasznak az ábécérendben legkisebb tömböt kell képviselnie, nem az indexek által alkotott karakterláncot.

Példa 1:

Bemenet: word1 = "vbcca", word2 = "abc"
Kimenet: [0,1,2]
Magyarázat:
Az ábécérendben legkisebb érvényes indexsorozat a [0, 1, 2]:

Változtasd meg word1[0]-t 'a'-ra.
word1[1] már 'b'.
word1[2] már 'c'.

Példa 2:

Bemenet: word1 = "bacdc", word2 = "abc"
Kimenet: [1,2,4]
Magyarázat:
Az ábécérendben legkisebb érvényes indexsorozat a [1, 2, 4]:

word1[1] már 'a'.
Változtasd meg word1[2]-t 'b'-re.
word1[4] már 'c'.

Példa 3:

Bemenet: word1 = "aaaaaa", word2 = "aaabc"
Kimenet: []
Magyarázat:
Nincs érvényes indexsorozat.

Példa 4:

Bemenet: word1 = "abc", word2 = "ab"
Kimenet: [0,1]

Korlátozások:

1 <= word2.length < word1.length <= 3 * 10^5
word1 és word2 csak kisbetűs angol betűket tartalmaznak.

Két karakterláncot kapsz: szó1 és szó2.
Egy x karakterláncot majdnem egyenlőnek nevezünk y-val, ha legfeljebb egy karaktert változtathatunk meg az x-ben, hogy az azonos legyen y-val.
Seq indexek sorozatát érvényesnek nevezzük, ha:

Az indexek növekvő sorrendben vannak rendezve.
Ha a word1-ben ezeken az indexeken lévő karaktereket ugyanabban a sorrendben fűzzük össze, akkor egy karakterláncot kapunk, amely majdnem egyenlő a word2-vel.

Egy word2.length méretű tömböt ad vissza, amely a lexikográfiailag legkisebb érvényes indexsorozatot reprezentálja. Ha nem létezik ilyen indexsorozat, adjon vissza egy üres tömböt.
Vegye figyelembe, hogy a válasznak a lexikográfiailag legkisebb tömböt kell képviselnie, nem pedig az indexek által alkotott megfelelő karakterláncot.

1. példa:

Bemenet: word1 = "vbcca", szó2 = "abc"
Kimenet: [0,1,2]
Magyarázat:
A lexikográfiailag legkisebb érvényes indexsorozat a [0, 1, 2]:

A word1[0] módosítása 'a'-ra.
word1[1] már 'b'.
word1[2] már 'c'.

2. példa:

Bemenet: word1 = "bacdc", szó2 = "abc"
Kimenet: [1,2,4]
Magyarázat:
A lexikográfiailag legkisebb érvényes indexsorozat: [1, 2, 4]:

word1[1] már 'a'.
Módosítsa a word1[2] szót 'b'-re.
word1[4] már 'c'.

3. példa:

Bemenet: word1 = "aaaaaa", word2 = "aaabc"
Kimenet: []
Magyarázat:
Nincs érvényes indexsorozat.

4. példa:

Bemenet: word1 = "abc", word2 = "ab"
Kimenet: [0,1]

Korlátozások:

1 <= word2.length < word1.length <= 3 * 10^5
A szó1 és a szó2 csak kisbetűket tartalmaz angolul.

Adott két karakterlánc word1 és word2.
Egy x karakterláncot akkor nevezünk majdnem egyenlőnek y-jal, ha x-ben legfeljebb egy karaktert tudunk úgy megváltoztatni, hogy az megegyezzen y-jal.
A seq indexsorozatot akkor nevezzük érvényesnek, ha:

Az indexek növekvő sorrendbe vannak rendezve.
Ha a word1-ben ezekben az indexekben lévő karaktereket ugyanabban a sorrendben kapcsoljuk össze, akkor olyan karakterláncot kapunk, amely majdnem egyenlő a word2-vel.

Az indexek lexikográfiailag legkisebb érvényes sorozatát jelentő word2.length méretű tömböt adja vissza. Ha nincs ilyen indexsorozat, akkor egy üres tömböt ad vissza.
Vegyük észre, hogy a válasznak a lexikográfiailag legkisebb tömböt kell ábrázolnia, nem pedig az indexek által alkotott megfelelő karakterláncot.

1. példa:

Bemenet: word1 = "vbcca", word2 = "abc""
Kimenet: [0,1,2]
Magyarázat:
Az indexek lexikográfiailag legkisebb érvényes sorozata a [0, 1, 2]:

A word1[0]-t 'a'-ra kell változtatni.
word1[1] már 'b'.
word1[2] már 'c'.

2. példa:

Bemenet: word1 = "bacdc", word2 = "abc"
Kimenet: [1,2,4]
Magyarázat:
Az indexek lexikográfiailag legkisebb érvényes sorozata az [1, 2, 4]:

word1[1] már 'a'.
A word1[2]-t változtassuk 'b'-re.
A word1[4] már 'c'.

3. példa:

Bemenet: word1 = "aaaaaa", word2 = "aaabc"
Kimenet: []
Magyarázat:
Nincs érvényes indexsorozat.

4. példa:

Bemenet: word1 = "abc", word2 = "ab"
Kimenet: [0,1]

Korlátozások:

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


Kap két karakterláncot, s és mintát.
Egy x karakterláncot majdnem y-nak tekintünk, ha legfeljebb egy karaktert változtathatunk meg x-ben, hogy azonos legyen y-nal.
Egy s részsztring legkisebb kezdő indexét adja eredményül, amely majdnem egyenlő a mintával. Ha nincs ilyen index, adja vissza a -1 értéket.
Az alkarakterlánc egy karakterláncon belüli folytonos, nem üres karaktersorozat.

1. példa:

Bemenet: s = "abcdefg", pattern = "bcdffg"
Kimenet: 1
Magyarázat:
Az s[1..6] == "bcdefg" alsztring átalakítható "bcdffg"-vé, ha az s[4]-et "f"-re változtatjuk.

2. példa:

Bemenet: s = "ababbababa", pattern = "bacaba"
Kimenet: 4
Magyarázat:
Az s[4..9] == "bababa" alsztring átalakítható "bacaba"-vá, ha az s[6]-ot "c"-re változtatjuk.

3. példa:

Bemenet: s = "abcd", pattern = "dba"
Kimenet: -1

4. példa:

Bemenet: s = "dde", pattern = "d"
Kimenet: 0

Korlátok:

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

Követő kérdés: Meg tudná oldani a problémát, ha legfeljebb k egymást követő karakter változtatható meg?

Kapsz két húrt és mintát.
Egy x karakterláncot majdnem egyenlőnek nevezünk y-val, ha legfeljebb egy karaktert változtathatunk meg az x-ben, hogy az azonos legyen y-val.
Egy részkarakterlánc legkisebb kezdőindexét adja vissza s-ben, amely majdnem egyenlő a mintával. Ha nem létezik ilyen index, adja vissza a -1 értéket.
A részkarakterlánc a karakterláncon belüli, egymást követő, nem üres karaktersorozat.

1. példa:

Bemenet: s = "abcdefg", minta = "bcdffg"
Kimenet: 1
Magyarázat:
Az s[1..6] == "bcdefg" részkarakterlánc átalakítható "bcdffg"-re, ha s[4]-et "f"-re változtat.

2. példa:

Bemenet: s = "ababbababa", minta = "bacaba"
Kimenet: 4
Magyarázat:
Az s[4..9] == "bababa" részkarakterlánc átalakítható "bacaba"-ra, ha s[6]-t "c"-re változtat.

3. példa:

Bemenet: s = "abcd", minta = "dba"
Kimenet: -1

4. példa:

Bemenet: s = "dde", minta = "d"
Kimenet: 0

Korlátozások:

1 <= pattern.length < s.length <= 10^5
s és a minta csak kis angol betűkből áll.

Utánkövetés: Meg tudod oldani a problémát, ha legfeljebb k egymást követő karaktert lehet megváltoztatni?

Kapsz két húrt és mintát.
Egy x karakterláncot majdnem egyenlőnek nevezünk y-val, ha legfeljebb egy karaktert változtathatunk meg az x-ben, hogy az azonos legyen y-val.
Egy részkarakterlánc legkisebb kezdőindexét adja vissza s-ben, amely majdnem egyenlő a mintával. Ha nem létezik ilyen index, adja vissza a -1 értéket.
A részkarakterlánc a karakterláncon belüli, egymást követő, nem üres karaktersorozat.

Példa 1:

Bemenet: s = "abcdefg", pattern = "bcdffg"
Kimenet: 1
Magyarázat:
Az s[1..6] == "bcdefg" részkarakterlánc átalakítható "bcdffg"-re, ha s[4]-et "f"-re változtat.

Példa 2:

Bemenet: s = "ababbababa", pattern = "bacaba"
Kimenet: 4
Magyarázat:
Az s[4..9] == "bababa" részkarakterlánc átalakítható "bacaba"-ra, ha s[6]-t "c"-re változtat.

Példa 3:

Bemenet: s = "abcd", pattern = "dba"
Kimenet: -1

Példa 4:

Bemenet: s = "dde", pattern = "d"
Kimenet: 0

Korlátozások:

1 <= pattern.length < s.length <= 10^5
s és a minta csak kis angol betűkből áll.

Utánkövetés: Meg tudod oldani a problémát, ha legfeljebb k egymást követő karaktert lehet megváltoztatni?