Adott egy pozitív egész szám, n, adja vissza az n büntetőszámát.
Az n büntetőszámát úgy definiáljuk, mint az összes olyan i egész szám négyzetének összegét, amely:

1 <= i <= n
Az i * i decimális ábrázolása felosztható összefüggő részsorozatokra úgy, hogy ezen részsorozatok egész számértékeinek összege egyenlő legyen i-vel.

Példa 1:

Bemenet: n = 10
Kimenet: 182
Magyarázat: Az állításban szereplő feltételeknek pontosan 3 olyan i egész szám felel meg:
- 1, mivel 1 * 1 = 1
- 9, mivel 9 * 9 = 81, és 81 felosztható 8 + 1-re.
- 10, mivel 10 * 10 = 100 és 100 felosztható 10 + 0-ra.
Ezért a 10 büntetőszáma 1 + 81 + 100 = 182.

Példa 2:

Bemenet: n = 37
Kimenet: 1478
Magyarázat: Az állításban szereplő feltételeknek pontosan 4 olyan i egész szám felel meg:
- 1, mivel 1 * 1 = 1.
- 9, mivel 9 * 9 = 81, és 81 felosztható 8 + 1-re.
- 10, mivel 10 * 10 = 100 és 100 felosztható 10 + 0-ra.
- 36, mivel 36 * 36 = 1296 és 1296 felosztható 1 + 29 + 6-ra.
Ezért a 37 büntetőszáma 1 + 81 + 100 + 1296 = 1478.

Korlátozások:

1 <= n <= 1000

Adott egy n pozitív egész szám, adja vissza az n büntetési számot.
Az n büntetésszám az összes i egész szám négyzetének összegeként definiálható úgy, hogy:

1 <= i <= n
Az i * i decimális reprezentációja felosztható összefüggő részkarakterláncokra úgy, hogy ezen részkarakterláncok egész értékeinek összege egyenlő i-vel.

1. példa:

Bemenet: n = 10
Kimenet: 182
Magyarázat: Pontosan 3 i egész szám teljesíti az utasításban szereplő feltételeket:
- 1, mivel 1 * 1 = 1
- 9, mivel a 9 * 9 = 81 és a 81 felosztható 8 + 1-re.
- 10, mivel a 10 * 10 = 100 és a 100 felosztható 10 + 0-ra.
Ezért a 10-es büntetés száma 1 + 81 + 100 = 182

2. példa:

Bemenet: n = 37
Kimenet: 1478
Magyarázat: Pontosan 4 i egész szám teljesíti az utasításban szereplő feltételeket:
- 1, mivel 1 * 1 = 1.
- 9, mivel a 9 * 9 = 81 és a 81 felosztható 8 + 1-re.
- 10, mivel a 10 * 10 = 100 és a 100 felosztható 10 + 0-ra.
- 36, mivel a 36 * 36 = 1296 és az 1296 particionálható 1 + 29 + 6-ra.
Ezért a 37-es büntetés száma 1 + 81 + 100 + 1296 = 1478

Korlátozások:

1 <= n <= 1000

Adott egy pozitív n egész szám, adja vissza az n büntetési számot.
Az n büntetési száma az összes i egész szám négyzetének összege úgy, hogy:

1 < = i <= n
Az i * i decimális ábrázolása folytonos részsztringekre osztható úgy, hogy ezen alsztringek egész értékeinek összege i-vel egyenlő.

1. példa:

Bemenet: n = 10
Kimenet: 182
Magyarázat: Pontosan 3 i egész szám van, amelyek megfelelnek az állítás feltételeinek:
- 1 mivel 1 * 1 = 1
- 9, mivel 9 * 9 = 81 és 81 8 + 1-re osztható.
- 10, mivel 10 * 10 = 100 és 100 10 + 0-ra osztható.
Ezért a 10-es büntetési szám 1 + 81 + 100 = 182

2. példa:

Bemenet: n = 37
Kimenet: 1478
Magyarázat: Pontosan 4 i egész szám van, amelyek megfelelnek az állítás feltételeinek:
- 1 mivel 1 * 1 = 1.
- 9, mivel 9 * 9 = 81 és 81 8 + 1-re osztható.
- 10, mivel 10 * 10 = 100 és 100 10 + 0-ra osztható.
- 36, mivel 36 * 36 = 1296 és 1296 1 + 29 + 6-ra osztható.
Ezért a 37-es büntetési szám 1 + 81 + 100 + 1296 = 1478

Korlátok:

1 < = n <= 1000


Adott két 0 indexű, n méretű egész számtömb, a költség és az idő, amelyek az n különböző fal festéséhez szükséges költségeket, illetve az ehhez szükséges időt jelölik. Két festő áll rendelkezésre:

Egy fizetett festő, aki az i^-edik falat idő[i] időegység alatt festi le, és költség[i] pénzegységet vesz el.
Egy ingyenes festő, aki 1 időegység alatt bármelyik falat lefesti, és költsége 0. Az ingyenes festő azonban csak akkor használható, ha a fizetős festő már foglalt.

Visszaadja az n fal festéséhez szükséges minimális pénzösszeget.

Példa 1:

Bemenet: cost = [1,2,3,2], time = [1,2,3,2]
Kimenet: 3
Magyarázat: A 0 és 1 indexű falakat a fizetett festő fogja lefesteni, és ez 3 egységnyi időt vesz igénybe; eközben a szabad festő a 2 és 3 indexű falakat 2 egységnyi idő alatt, ingyenesen fogja lefesteni. Így a teljes költség 1 + 2 = 3.

2. példa:

Bemenet: cost = [2,3,4,2], time = [1,1,1,1].
Kimenet: 4
Magyarázat: A 0 és 3 indexű falakat a fizetett festő fogja lefesteni, és ez 2 egységnyi időt vesz igénybe; eközben az ingyenes festő az 1 és 2 indexű falakat fogja lefesteni, ingyen, 2 egységnyi idő alatt. Így a teljes költség 2 + 2 = 4.

Korlátozások:

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

Kapsz két 0 indexű egész tömböt, költséget és időt, n méretben, amelyek a költségeket és az n különböző fal festéséhez szükséges időt jelentik. Két festő áll rendelkezésre:

Fizetett festő, aki idő[i] időegységben festi le az i^edik falat, és cost[i] egységnyi pénzbe kerül.
Ingyenes festő, aki bármilyen falat lefest 1 időegység alatt 0 költséggel. Az ingyenes festő azonban csak akkor vehető igénybe, ha a fizetett festő már foglalt.

Adja vissza az n falfestéshez szükséges minimális pénzt.

1. példa:

Bemenet:  cost = [1,2,3,2], time = [1,2,3,2]
Kimenet: 3
Magyarázat: A 0 és 1 indexű falakat a fizetett festő fogja lefesteni, és ez 3 egységnyi időt vesz igénybe; eközben az ingyenes festő a 2-es és 3-as indexű falakat 2 egységnyi idő alatt ingyenesen lefesti. Így a teljes költség 1 + 2 = 3.

2. példa:

Bemenet: cost = [2,3,4,2], time = [1,1,1,1]
Kimenet: 4
Magyarázat: A 0 és 3 indexű falakat a fizetett festő fogja lefesteni, és ez 2 egységnyi időt vesz igénybe; eközben az ingyenes festő 2 időegység alatt ingyenesen lefesti az 1-es és 2-es indexű falakat. Így a teljes költség 2 + 2 = 4.

Korlátozások:

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

Kapsz két 0 indexű egész tömböt, költséget és időt, n méretben, amelyek a költségeket és az n különböző fal festéséhez szükséges időt jelentik. Két festő áll rendelkezésre:

Fizetett festő, aki idő[i] időegységben festi le az i^edik falat, és pénz[i] egységnyi pénzbe kerül.
Ingyenes festő, aki bármilyen falat lefest 1 időegység alatt 0 költséggel. Az ingyenes festő azonban csak akkor vehető igénybe, ha a fizetett festő már foglalt.

Adja vissza az n falfestéshez szükséges minimális pénzt.

1. példa:

Bemenet: cost = [1,2,3,2], time = [1,2,3,2]
Kimenet: 3
Magyarázat: A 0 és 1 indexű falakat a fizetett festő fogja lefesteni, és ez 3 egységnyi időt vesz igénybe; eközben az ingyenes festő a 2-es és 3-as indexű falakat 2 egységnyi idő alatt ingyenesen lefesti. Így a teljes költség 1 + 2 = 3.

2. példa:

Bemenet: cost = [2,3,4,2], time = [1,1,1,1]
Kimenet: 4
Magyarázat: A 0 és 3 indexű falakat a fizetett festő fogja lefesteni, és ez 2 egységnyi időt vesz igénybe; eközben az ingyenes festő 2 időegység alatt ingyenesen lefesti az 1-es és 2-es indexű falakat. Így a teljes költség 2 + 2 = 4.

Korlátozások:

1 <= cost.length <= 500
költség.hossz == idő.hossz
1 <= cost[i] <= 10^6
1 <= time[i] <= 500


Meg van adva egy 0-indexált egész számokból álló nums tömb, amely mérete n, és a különböző csokoládék begyűjtési költségét jelöli. Az i indexű csokoládé begyűjtési költsége nums[i]. Minden csokoládé más típusú, és kezdetben az i indexű csokoládé az i-edik típusú.

Egy művelettel a következőt hajthatod végre x költséggel:

Egyidejűleg megváltoztathatod az i-edik típusú csokoládét az ((i + 1) mod n)-edik típusúra minden csokoládé esetében.

Add vissza a minimális költséget, amely az összes típusú csokoládék begyűjtéséhez szükséges, figyelembe véve, hogy tetszőleges számú műveletet végrehajthatsz.

Példa 1:

Bemenet: nums = [20,1,15], x = 5
Kimenet: 13
Magyarázat: Kezdetben a csokoládé típusok [0,1,2]. Megvesszük az 1-es típusú csokoládét 1-es költséggel. Most végrehajtjuk a műveletet 5-ös költséggel, és a csokoládé típusok [1,2,0] lesznek. Megvesszük a 2-es típusú csokoládét 1-es költséggel. Újra végrehajtjuk a műveletet 5-ös költséggel, és a csokoládé típusok [2,0,1] lesznek. Megvesszük a 0-ik típusú csokoládét 1-es költséggel. Így a teljes költség (1 + 5 + 1 + 5 + 1) = 13. Bizonyítható, hogy ez az optimális.

Példa 2:

Bemenet: nums = [1,2,3], x = 4
Kimenet: 6
Magyarázat: Összegyűjtjük mindhárom típusú csokoládét a saját árán anélkül, hogy műveletet hajtanánk végre. Ezért a teljes költség 1 + 2 + 3 = 6.

Korlátozások:

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

Kap egy 0-indexelt egész számokból álló tömböt, amely n elemű amelyek a különböző csokoládék összegyűjtésének költségét jelentik. A csokoládé i. indexű helyen található elemének költsége nums[i]. Minden csokoládé más típusú, és kezdetben az i indexű csokoládé az i. típusú.
Egy műveletben a következőket teheti x felmerülő költséggel:

Egyidejűleg módosítsa az i. típusú csokoládét ((i + 1) mod n). típusúra minden csokoládé esetében.

Mindenféle csokoládé összegyűjtésének minimális költségét adja vissza, mivel annyi műveletet hajthat végre, amennyit csak szeretne.

1. példa:

Bemenet: nums = [20,1,15], x = 5
Kimenet: 13
Magyarázat: Kezdetben a csokoládé típusok [0,1,2]. Az 1. típusú csokoládét 1 költséggel vásároljuk meg.
Most 5-ös költséggel hajtjuk végre a műveletet, és a csokoládék fajtái [1,2,0] lesznek. A 2. típusú csokoládét 1 költséggel vásároljuk meg.
Most ismét 5-ös költséggel hajtjuk végre a műveletet, és a csokoládéfajták [2,0,1] lesznek. A 0^-edik csokoládét 1 áron vásároljuk meg.
Így a teljes költség (1 + 5 + 1 + 5 + 1) = 13 lesz. Bebizonyíthatjuk, hogy ez az optimális.

2. példa:

Bemenet: nums = [1,2,3], x = 4
Kimenet: 6
Magyarázat: Mindhárom fajta csokoládét saját áron, műveletek elvégzése nélkül gyűjtjük össze. Ezért a teljes költség 1 + 2
Korlátozások:

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

Kap egy 0-indexelt egész számokból álló tömböt, amelynek mérete n, és amely a különböző csokoládék gyűjtésének költségeit képviseli. amelyek a különböző csokoládék gyűjtésének költségeit képviselik. A csokoládé összegyűjtésének költsége az i indexen nums[i]. Minden csokoládé más típusú, és kezdetben az i indexű csokoládé i^ típusú.
Egy műveletben x költséggel a következőt teheti.

Egyidejűleg változtassa meg az i^th típusú csokoládét ((i + 1) mod n)^th típusra az összes csokoládé esetében.

Térjen vissza a minimális költségre minden típusú csokoládé gyűjtésére, mivel annyi műveletet hajthat végre, amennyit csak akar.

1. példa:

Bemenet: nums = [20,1,15], x = 5
Kimenet: 13
Magyarázat: Kezdetben a csokoládé típusok [0,1,2]. Az 1. típusú csokoládét 1-es áron vásároljuk meg.
Most 5 költséggel hajtjuk végre a műveletet, és a csokoládék típusai [1,2,0] lesznek. A 2. típusú csokoládét 1-es áron vásároljuk meg.
Most ismét 5-ös költséggel végezzük el a műveletet, és a csokoládétípusok [2,0,1] lesznek. A 0. típusú csokoládét 1-es áron vásároljuk meg
Így a teljes költség (1 + 5 + 1 + 5 + 1) = 13 lesz. Bebizonyíthatjuk, hogy ez optimális.

2. példa:

Bemenet: nums = [1,2,3], x = 4
Kimenet: 6
Magyarázat: Mindhárom típusú csokoládét saját árán gyűjtjük össze, bármilyen művelet elvégzése nélkül. Ezért a teljes költség 1 + 2 + 3 = 6.

Korlátok:

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


Két egész számot kapunk, n és k.
A különböző pozitív egész számok tömbjét k-elkerülő tömbnek nevezzük, ha nem létezik olyan különálló elempár, amely k-ra összegződik.
Egy n hosszúságú k-elkerülő tömb lehető legkisebb összegét adja eredményül.

1. példa:

Bemenet: n = 5, k = 4
Kimenet: 18
Magyarázat: Tekintsük a k-elkerülő tömböt [1,2,4,5,6], amelynek összege 18.
Bizonyítható, hogy nincs 18-nál kisebb k-elkerülő tömb.

2. példa:

Bemenet: n = 2, k = 6
Kimenet: 3
Magyarázat: Megalkothatjuk az [1,2] tömböt, amelynek összege 3.
Bizonyítható, hogy nincs k-elkerülő tömb, amelynek összege kisebb, mint 3.

Korlátok:

1 < = n, k <= 50

Két egész számot kapsz, n és k.
Az eltérő pozitív egész számokból álló tömböt k-elkerülő tömbnek nevezzük, ha nem létezik olyan különálló elempár, amelynek összege k.
Egy n hosszúságú k-elkerülő tömb lehetséges legkisebb összegét adja vissza.

példa 1:

Bemenet: n = 5, k = 4
Kimenet: 18
Magyarázat: Tekintsük a k-elkerülő tömböt [1,2,4,5,6], amelynek összege 18.
Bizonyítható, hogy nincs 18-nál kisebb összegű k-elkerülő tömb.

példa 2:

Bemenet: n = 2, k = 6
Kimenet: 3
Magyarázat: Összeállíthatjuk az [1,2] tömböt, amelynek összege 3.
Bizonyítható, hogy nincs 3-nál kisebb összegű k-elkerülő tömb.

Korlátozások:

1 <= n, k <= 50


Két egész számot kapsz, num és t.
Egy egész számot akkor nevezünk elérhetőnek, ha legfeljebb t alkalommal alkalmazva a következő műveletet, az x egyenlővé válhat a num-mal:

Növeld vagy csökkentsd x-et 1-gyel, és egyidejűleg növeld vagy csökkentsd num-ot 1-gyel.

Add vissza a maximálisan elérhető számot. Bizonyítható, hogy létezik legalább egy elérhető szám.

1. példa:

Bemenet: num = 4, t = 1
Kimenet: 6
Magyarázat: A maximálisan elérhető szám x = 6; az alábbi művelet elvégzése után x egyenlő lehet num-mal:
1- Csökkentsd x-et 1-gyel, és növeld num-ot 1-gyel. Most x = 5 és num = 5.
Bizonyítható, hogy nincs 6-nál nagyobb elérhető szám.

2. példa:

Bemenet: num = 3, t = 2
Kimenet: 7
Magyarázat: A maximálisan elérhető szám x = 7; az alábbi műveletek elvégzése után x egyenlő lesz num-mal:
1- Csökkentsd x-et 1-gyel, és növeld num-ot 1-gyel. Most x = 6 és num = 4.
2- Csökkentsd x-et 1-gyel, és növeld num-ot 1-gyel. Most x = 5 és num = 5.
Bizonyítható, hogy nincs 7-nél nagyobb elérhető szám.

Korlátok:

1 <= num, t <= 50

Két egész számot kap, num és t.
Egy x egész számot akkor nevezünk elérhetőnek, ha a következő művelet legfeljebb t-szer történő alkalmazása után egyenlő lehet nummal:

Növelje vagy csökkentse x-et 1-gyel, és egyidejűleg növelje vagy csökkentse num 1-gyel.

Adja vissza a maximálisan elérhető számot. Bizonyítható, hogy létezik legalább egy elérhető szám.

1. példa:

Bemenet: num = 4, t = 1
Kimenet: 6
Magyarázat: A maximálisan elérhető szám x = 6; A művelet végrehajtása után x egyenlő lesz a nummal:
1- Csökkentse az x-et 1-gyel, és növelje a számot 1-gyel. Most x = 5 és num = 5.
Bizonyítható, hogy nincs 6-nál nagyobb elérhető szám.

2. példa:

Bemenet: num = 3, t = 2
Kimenet: 7
Magyarázat: A maximálisan elérhető szám x = 7; A műveletek végrehajtása után x egyenlő lesz a számmal:
1- Csökkentse az x-et 1-gyel, és növelje a számot 1-gyel. Most x = 6 és num = 4.
2- Csökkentse az x-et 1-gyel, és növelje a számot 1-gyel. Most x = 5 és num = 5.
Bizonyítható, hogy nincs 7-nél nagyobb elérhető szám.

Korlátok:

1 <= num, t <= 50

Két egész számot és t-t kapsz.
Egy x egész számot akkor nevezünk elérhetőnek, ha a következő művelet végrehajtása után legfeljebb t-szer válhat egyenlővé num-mal:

Növelje vagy csökkentse x-et 1-gyel, és ezzel egyidejűleg növelje vagy csökkentse a számot 1-gyel.

Adja vissza a maximálisan elérhető számot. Bizonyítható, hogy létezik legalább egy elérhető szám.

1. példa:

Bemenet: num = 4, t = 1
Kimenet: 6
Magyarázat: A maximálisan elérhető szám x = 6; az alábbi művelet elvégzése után x egyenlő lehet num-mal:
1- Csökkentsd x-et 1-gyel, és növeld num-ot 1-gyel. Most x = 5 és num = 5.
Bizonyítható, hogy nincs 6-nál nagyobb elérhető szám.

2. példa:

Bemenet: num = 3, t = 2
Kimenet: 7
Magyarázat: A maximálisan elérhető szám x = 7; az alábbi műveletek elvégzése után x egyenlő lesz num-mal:
1- Csökkentsd x-et 1-gyel, és növeld num-ot 1-gyel. Most x = 6 és num = 4.
2- Csökkentsd x-et 1-gyel, és növeld num-ot 1-gyel. Most x = 5 és num = 5.
Bizonyítható, hogy nincs 7-nél nagyobb elérhető szám.

Korlátozások:

1 <= num, t <= 50


Adott egy s karakterlánc, amely kisbetűs angol betűkből áll, és műveleteket végezhet rajta. Az egyik műveletben az s-ben szereplő karaktert egy másik kisbetűs angol betűvel helyettesítheted.
A feladatod az, hogy s-t a lehető legkevesebb művelettel palindrómává alakítsd. Ha több olyan palindrom is van, amely a minimális számú művelettel elkészíthető, akkor a lexikográfiailag legkisebbet készítsd el.
Egy a karakterlánc lexikográfiailag kisebb, mint egy (azonos hosszúságú) b karakterlánc, ha az a és b karakterlánc első olyan pozíciójában, ahol a és b különbözik, az a karakterláncban van egy olyan betű, amely korábban szerepel az ábécében, mint a b megfelelő betűje.
Az eredményül kapott palindromos karakterláncot adja vissza.

Példa 1:

Bevitel: s = „egcfe”
Kimenet: „efcfe”
Magyarázat: Az „egcfe” palindrómává alakításához szükséges műveletek minimális száma 1, és a lexikográfiailag legkisebb palindromos karakterlánc, amelyet egy karakter módosításával kaphatunk, az „efcfe”, a 'g' megváltoztatásával.

2. példa:

Bemenet: s = "abcd"
Kimenet: "abba"
Magyarázat: Az „abcd” palindrómává alakításához szükséges műveletek minimális száma 2, és a lexikográfiailag legkisebb palindromos karakterlánc, amelyet két karakter módosításával kaphatunk, az „abba”.

3. példa:

Bemenet: s ="seven"
Kimenet:"neven"
Magyarázat: A „seven” palindrómává alakításához szükséges műveletek minimális száma 1, és a lexikográfiailag legkisebb palindrómás karakterlánc, amelyet egy karakter módosításával kaphatunk, a „neven”.

Korlátozások:

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

Egy s karakterláncot kapsz, amely kisbetűs angol betűkből áll, és engedélyezve van, hogy műveleteket végezz rajta. Egy művelet során egy karaktert kicserélhetsz a s-ben egy másik kisbetűs angol betűre.
A feladatod, hogy a lehető legkevesebb művelettel palindrómmá tedd s-t. Ha több palindróma is létrehozható a minimum műveletekkel, akkor a lexikografikusan legkisebbet hozd létre.
Egy a karakterlánc lexikografikusan kisebb, mint egy b karakterlánc (ugyanakkora hosszúságú), ha azon a helyen, ahol az a és b eltér, az a karakterláncban lévő betű korábban szerepel az ABC-ben, mint a megfelelő betű a b-ben.
Térj vissza az eredményül kapott palindróma karakterlánccal.

Példa 1:

Input: s = "egcfe"
Output: "efcfe"
Magyarázat: A minimális műveletek száma, amellyel az "egcfe" karakterláncot palindrómává tehetjük, 1, és a lexikografikusan legkisebb palindróma, amit egy karakter módosításával elérhetünk, az "efcfe", ha a 'g'-t változtatjuk.

Példa 2:

Input: s = "abcd"
Output: "abba"
Magyarázat: A minimális műveletek száma, amellyel az "abcd" karakterláncot palindrómává tehetjük, 2, és a lexikografikusan legkisebb palindróma, amit két karakter módosításával elérhetünk, az "abba".

Példa 3:

Input: s = "seven"
Output: "neven"
Magyarázat: A minimális műveletek száma, amellyel a "seven" karakterláncot palindrómává tehetjük, 1, és a lexikografikusan legkisebb palindróma, amit egy karakter módosításával elérhetünk, az "neven".

 Korlátozások:

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

Kapsz egy kis angol betűkből álló s karakterláncot, amelyen műveleteket hajthatsz végre. Az egyik műveletben lecserélheti az s-ben lévő karaktert egy másik kisbetűre.
Az Ön feladata, hogy egy palindromot készítsen a lehető legkisebb számú művelettel. Ha több palindrom is elkészíthető a minimális számú művelettel, akkor a lexikográfiailag legkisebbet állítsa be.
Az a karakterlánc lexikográfiailag kisebb, mint egy b karakterlánc (ugyanolyan hosszú), ha az első helyen, ahol a és b különbözik, az a karakterláncnak van egy olyan betűje, amely korábban jelenik meg az ábécében, mint a b megfelelő betűje.
Adja vissza a kapott palindrom karakterláncot.

1. példa:

Bemenet: s = "egcfe"
Kimenet: "efcfe"
Magyarázat: Az "egcfe" palindrommá alakításához szükséges műveletek minimális száma 1, és a lexikográfiailag legkisebb palindrom karakterlánc, amelyet egy karakter módosításával kaphatunk, az "efcfe" a 'g' megváltoztatásával.

2. példa:

Bemenet: s = "abcd"
Kimenet: "abba"
Magyarázat: Az "abcd" palindrommá alakításához szükséges műveletek minimális száma 2, és a lexikográfiailag legkisebb palindrom karakterlánc, amelyet két karakter módosításával kaphatunk, az "abba".

3. példa:

Bemenet: s = "seven"
Kimenet: "neven"
Magyarázat: A "hét" palindrom létrehozásához szükséges műveletek minimális száma 1, és a lexikográfiailag legkisebb palindrom karakterlánc, amelyet egy karakter módosításával kaphatunk, a "neven".

Korlátozások:

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


Kap egy 0-indexelt n hosszúságú bináris karakterláncot, amelyen kétféle műveletet alkalmazhat:

Válasszon egy i indexet, és fordítsa meg az összes karaktert a 0 indexről az i indexre (mindkettőt beleértve), i + 1 költséggel
Válasszon egy i indexet, és fordítsa meg az összes karaktert az i indexről n - 1 indexre (mindkettőt beleértve), n - i költséggel

Adja vissza a minimális költséget, hogy a karakterlánc összes karaktere egyenlő legyen.
Egy karakter invertálása azt jelenti, hogy ha az értéke "0", akkor "1" lesz, és fordítva.

1. példa:

Bemenet: s = "0011"
Kimenet: 2
Magyarázat: Alkalmazza a második műveletet i = 2 értékkel, hogy s = "0000" értéket kapjon 2 költséggel. Megmutatható, hogy a 2 a minimális költség, hogy minden karakter egyenlő legyen.

2. példa:

Bemenet: s = "010101"
Kimenet: 9
Magyarázat: Alkalmazza az első műveletet i = 2 értékkel, hogy megkapja az s = "101101" értéket 3 költséggel.
Alkalmazza az első műveletet i = 1 értékkel, hogy s = "011101" értéket kapjon 2 költséggel.
Alkalmazza az első műveletet i = 0 értékkel, hogy s = "111101" értéket kapjon 1 költséggel.
Alkalmazza a második műveletet i = 4 értékkel, hogy megkapja az s = "111110" értéket 2 költséggel.
Alkalmazza a második műveletet i = 5 értékkel, hogy s = "111111" értéket kapjon 1 költséggel.
Az összes karakter egyenlővé tételének teljes költsége 9. Megmutatható, hogy a 9 a minimális költség, hogy minden karakter egyenlő legyen.

Korlátok:

1 <= s.length == n <= 10^5
s[i] értéke "0" vagy "1"

Kapunk egy n hosszúságú 0 indexű bináris karakterláncot, amelyen kétféle műveletet alkalmazhatunk:

Válasszon egy indexet i, és fordítsa meg az összes karaktert 0 indexről i indexre (mindkettőt beleértve), i + 1 költséggel
Válasszon egy i indexet, és fordítsa meg az összes karaktert az i indexről az n - 1 indexre (mindkettőt beleértve), n - i költséggel

Adja vissza a minimális költséget, hogy a karakterlánc minden karaktere egyenlő legyen.
A karakter megfordítása azt jelenti, hogy ha értéke '0', akkor '1' lesz, és fordítva.

1. példa:

Bemenet: s = "0011"
Kimenet: 2
Magyarázat: Alkalmazza a második műveletet i = 2-vel, hogy s = "0000"-t kapjon 2 költség mellett. Megmutatható, hogy 2 az összes karakter egyenlővé tételének minimális költsége.

2. példa:

Bemenet: s = "010101"
Kimenet: 9
Magyarázat: Alkalmazza az első műveletet i = 2-vel, hogy megkapja az s = "101101" értéket 3 költséggel.
Alkalmazza az első műveletet i = 1-gyel, hogy s = "011101" legyen 2 költséggel.
Alkalmazza az első műveletet i = 0-val, hogy s = "111101" legyen 1 költséggel.
Alkalmazza a második műveletet i = 4-gyel, hogy s = "111110" legyen 2 költséggel.
Alkalmazza a második műveletet i = 5-tel, hogy megkapja az s = "111111" értéket 1 költséggel.
Az összes karakter egyenlővé tételének teljes költsége 9. Megmutatható, hogy 9 az összes karakter egyenlővé tételének minimális költsége.

Korlátozások:

1 <= s.length == n <= 10^5
s[i] is either '0' or '1'

Kapunk egy n hosszúságú 0 indexű bináris karakterláncot, amelyen kétféle műveletet alkalmazhatunk:

Válasszon egy indexet i, és fordítsa meg az összes karaktert 0 indexről i indexre (mindkettőt beleértve), i + 1 költséggel
Válasszon egy i indexet, és fordítsa meg az összes karaktert az i indexről az n - 1 indexre (mindkettőt beleértve), n - i költséggel

Adja vissza a minimális költséget, hogy a karakterlánc minden karaktere egyenlő legyen.
A karakter megfordítása azt jelenti, hogy ha értéke '0', akkor '1' lesz, és fordítva.

1. példa:

Bemenet: s = "0011"
Kimenet: 2
Magyarázat: Alkalmazza a második műveletet i = 2-vel, hogy s = "0000"-t kapjon 2 költség mellett. Megmutatható, hogy 2 az összes karakter egyenlővé tételének minimális költsége.

2. példa:

Bemenet: s = "010101"
Kimenet: 9
Magyarázat: Alkalmazza az első műveletet i = 2-vel, hogy megkapja az s = "101101" értéket 3 költséggel.
Alkalmazza az első műveletet i = 1-gyel, hogy s = "011101" legyen 2 költséggel.
Alkalmazza az első műveletet i = 0-val, hogy s = "111101" legyen 1 költséggel.
Alkalmazza a második műveletet i = 4-gyel, hogy s = "111110" legyen 2 költséggel.
Alkalmazza a második műveletet i = 5-tel, hogy s = "111111" legyen 1 költséggel.
Az összes karakter egyenlővé tételének teljes költsége 9. Megmutatható, hogy 9 az összes karakter egyenlővé tételének minimális költsége.

Korlátozások:

1 <= s.length == n <= 10^5
s[i] '0' vagy '1'


Adott egy sztringként ábrázolt pozitív egész szám, adja vissza az egész számot karakterláncként, anélkül hogy záró nullákat tartalmazna.

1. példa:

Bemenet: num = "51230100"
Kimenet: "512301"
Magyarázat: Az "51230100" egész számnak 2 záró nullája van, eltávolítjuk őket, és egész számot adunk vissza "512301".

2. példa:

Bemenet: num = "123"
Kimenet: "123"
Magyarázat: A "123" egész számnak nincs záró nullája, a "123" egész számot adjuk vissza.

Korlátok:

1 <= num.length <= 1000
A szám csak számjegyekből áll.
A num számnak nincs kezdő nullája.

Adott egy sztringként ábrázolt pozitív egész szám, adja vissza az egész számot anélkül, hogy karakterláncként záró nullákat adna vissza.

1. példa:

Bemenet: num = "51230100"
Kimenet: "512301"
Magyarázat: Az "51230100" egész számnak 2 záró nullája van, eltávolítjuk őket, és egész számot adunk vissza "512301".

2. példa:

Bemenet: num = "123"
Kimenet: "123"
Magyarázat: A "123" egész számnak nincs záró nullája, a "123" egész számot adjuk vissza.

Korlátok:

1 <= num.length <= 1000
num consists of only digits.
num doesn't have any leading zeros.

Egy pozitív egész számot, amely karakterláncként van megadva, vissza kell adni az egész számot a végén található nullák nélkül, szintén karakterláncként.

Példa 1:

Bemenet: num = "51230100"
Kimenet: "512301"
Magyarázat: Az "51230100" egész szám végén 2 nulla van, eltávolítjuk őket és visszaadjuk az "512301" egész számot.

Példa 2:

Bemenet: num = "123"
Kimenet: "123"
Magyarázat: Az "123" egész számnak nincs végén nulla, visszaadjuk az "123" egész számot.

Korlátozások:

1 <= num.length <= 1000
num csak számjegyekből áll.
num nem tartalmaz vezető nullákat.


Kapsz egy n egész számot, amely pontosan 3 számjegyből áll.
Lenyűgözőnek nevezzük az n számot, ha a következő módosítás után a kapott szám pontosan egyszer tartalmazza az összes számjegyet 1-től 9-ig, és nem tartalmaz 0-t:

Kösd össze n-t a 2 * n és 3 * n számokkal.

Adja vissza az igaz értéket, ha n lenyűgöző, vagy hamis értéket egyébként.
Két szám összefűzése azt jelenti, hogy összekapcsoljuk őket. Például a 121 és 371 összefűzése 121371.

1. példa:

Bemenet: n = 192
Kimenet: true
Magyarázat: Összefűzzük az n = 192 és 2 * n = 384 és 3 * n = 576 számokat. Az eredményül kapott szám: 192384576. Ez a szám pontosan egyszer tartalmazza az összes számjegyet 1-től 9-ig.

2. példa:

Bemenet: n = 100
Kimenet: false
Magyarázat: Összefűzzük az n = 100 és a 2 * n = 200 és a 3 * n = 300 számokat. Az eredményül kapott szám 100200300. Ez a szám egyik feltételnek sem felel meg.

Korlátozások:

100 <= n <= 999

Adott egy n egész szám, amely pontosan 3 számjegyből áll.
Az n számot akkor nevezzük lenyűgözőnek, ha a következő módosítás után a kapott szám pontosan egyszer tartalmazza az összes számjegyet 1-től 9-ig, és nem tartalmaz 0-t sem:

Az n-t láncoljuk össze a 2 * n és a 3 * n számokkal.

Adjon vissza true-t, ha n lenyűgöző, vagy false-t, ha nem.
Két szám összefűzése azt jelenti, hogy összekapcsoljuk őket. Például a 121 és a 371 számok összekapcsolása 121371.

Példa 1:

Bemenet: n = 192
Kimenet: true
Magyarázat: Az n = 192 és 2 * n = 384 és 3 * n = 576 számokat kapcsoljuk össze. A kapott szám a 192384576. Ez a szám pontosan egyszer tartalmazza az összes számjegyet 1-től 9-ig.

2. példa:

Bemenet: n = 100
Kimenet: false
Magyarázat: Az n = 100 és a 2 * n = 200 és a 3 * n = 300 számokat összekapcsoljuk. A kapott szám a 100200300. Ez a szám egyik feltételnek sem felel meg.

Korlátozások:

100 <= n <= 999

Kapsz egy n egész számot, amely pontosan 3 számjegyből áll.
Az n számot akkor nevezzük lenyűgözőnek, ha a következő módosítás után a kapott szám pontosan egyszer tartalmazza az összes számjegyet 1-től 9-ig, és nem tartalmaz 0-t:

Fűzzük össze n-t a 2 * n és 3 * n számokkal.

Visszatérés igaz, ha n lenyűgöző, vagy hamis egyébként.
Két szám összefűzése azt jelenti, hogy összekapcsoljuk őket. Például a 121 és a 371 összefűzése 121371.

1. példa:

Bemenet: n = 192
Kimenet: true
Magyarázat: Az n = 192 és 2 * n = 384 és 3 * n = 576 számokat összefűzzük. A kapott szám 192384576. Ez a szám pontosan egyszer tartalmazza az 1-től 9-ig terjedő összes számjegyet.

2. példa:

Bemenet: n = 100
Kimenet: hamis
Magyarázat: Összefűzzük az n = 100 és 2 * n = 200 és 3 * n = 300 számokat. A kapott szám 100200300. Ez a szám egyik feltételnek sem felel meg.

Korlátok:

100 < = n <= 999


Ha 0 indexelt s karakterláncot használ, ismételje meg a következő műveletet tetszőleges számú alkalommal:

Válasszon egy i indexet a karakterláncban, és legyen c az i pozícióban lévő karakter. Törölje a c legközelebbi előfordulását az i-től balra (ha van ilyen) és a c legközelebbi előfordulását az i-től jobbra (ha van ilyen).

Az Ön feladata, hogy minimalizálja az s hosszát a fenti művelet tetszőleges számú végrehajtásával.
A kis méretű karakterlánc hosszát jelölő egész számot ad eredményül.

1. példa:

Bemenet: s = "aaabc"
Kimenet: 3
Magyarázat: Ebben a példában s az "aaabc". Kezdjük azzal, hogy kiválasztjuk az "a" karaktert az 1. indexben. Ezután eltávolítjuk a legközelebbi  'a' -t az 1. indextől balra, amely a 0. indexnél van, és a legközelebbi  'a' -t az 1. indextől jobbra, amely a 2. indexnél van. A művelet után a karakterlánc "abc" lesz. A karakterláncon végzett minden további művelet változatlan marad. Ezért a minimalizált karakterlánc hossza 3.
2. példa:

Bemenet: s = "cbbd"
Kimenet: 3
Magyarázat: Ehhez kezdhetjük a 'b' karakterrel az 1. indexben. Az 1. indextől balra nincs 'b' előfordulása, de a 2. indextől jobbra van egy, ezért a 2. indexből töröljük a 'b' betűt. A karakterlánc "cbd" lesz, és a további műveletek változatlanok maradnak. Ezért a minimalizált hossz 3.

3. példa:

Bemenet: s = "dddaaa"
Kimenet: 2
Magyarázat: Ehhez kezdhetjük a  'd' karakterrel az 1. indexben. A tőle balra lévő  'd' legközelebbi előfordulása a 0-as indexnél, a tőle jobbra lévő  'd' legközelebbi előfordulása pedig a 2-es indexnél található. A 0-s és a 2-es indexet is töröljük, így a karakterlánc "daaa" lesz. Az új karakterláncban kiválaszthatjuk az "a" karaktert a 2. indexben. A tőle balra lévő 'a' legközelebbi előfordulása az 1-es, a tőle jobbra lévő 'a' legközelebbi előfordulása pedig a 3-as indexnél található. Mindkettőt töröljük, és a karakterlánc "da" lesz. Ezt nem tudjuk tovább minimalizálni, így a minimalizált hossz 2.

Korlátok:

1 <= s.length <= 100
s csak kisbetűs angol betűket tartalmaz

Ha 0 indexelt s karakterláncot használ, ismételje meg a következő műveletet tetszőleges számú alkalommal:

Válasszon egy i indexet a karakterláncban, és legyen c az i pozícióban lévő karakter. Törölje a c legközelebbi előfordulását az i-től balra (ha van ilyen) és a c legközelebbi előfordulását az i-től jobbra (ha van ilyen).

Az Ön feladata, hogy minimalizálja az s hosszát a fenti művelet tetszőleges számú végrehajtásával.
A kis méretű karakterlánc hosszát jelölő egész számot ad eredményül.

1. példa:

Bemenet: s = "aaabc"
Kimenet: 3
Magyarázat: Ebben a példában s az "aaabc". Kezdjük azzal, hogy kiválasztjuk az "a" karaktert az 1. indexben. Ezután eltávolítjuk a legközelebbi "a" -t az 1. indextől balra, amely a 0. indexnél van, és a legközelebbi "a" -t az 1. indextől jobbra, amely a 2. indexnél van. A művelet után a karakterlánc "abc" lesz. A karakterláncon végzett minden további művelet változatlan marad. Ezért a minimalizált karakterlánc hossza 3.
2. példa:

Bemenet: s = "cbbd"
Kimenet: 3
Magyarázat: Ehhez kezdhetjük a "b" karakterrel az 1. indexben. Az 1. indextől balra nincs "b" előfordulása, de a 2. indextől jobbra van egy, ezért a 2. indexből töröljük a "b" betűt. A karakterlánc "cbd" lesz, és a további műveletek változatlanok maradnak. Ezért a minimalizált hossz 3.

3. példa:

Bemenet: s = "dddaaa"
Kimenet: 2
Magyarázat: Ehhez kezdhetjük a "d" karakterrel az 1. indexben. A tőle balra lévő "d" legközelebbi előfordulása a 0-as indexnél, a tőle jobbra lévő "d" legközelebbi előfordulása pedig a 2-es indexnél található. A 0-s és a 2-es indexet is töröljük, így a karakterlánc "daaa" lesz. Az új karakterláncban kiválaszthatjuk az "a" karaktert a 2. indexben. A tőle balra lévő "a" legközelebbi előfordulása az 1-es, a tőle jobbra lévő "a" legközelebbi előfordulása pedig a 3-as indexnél található. Mindkettőt töröljük, és a karakterlánc "da" lesz. Ezt nem tudjuk tovább minimalizálni, így a minimalizált hossz 2.

Korlátok:

1 < = s.hossz <= 100
s csak kisbetűs angol betűket tartalmaz

Adott egy 0-indexelt string s, amelyen tetszőleges számú alkalommal végezzük el az alábbi műveletet:

Válassz egy i indexet a stringben, és tekints c-re, mint az i. pozícióban lévő karakterre. Töröld a c legközelebbi előfordulását balról az i-hez (ha van ilyen), és a c legközelebbi előfordulását jobbról az i-hez (ha van ilyen).

A feladatod, hogy minimalizáld az s hosszát a fenti művelet tetszőleges számú végrehajtásával.
Térj vissza egy egész számmal, amely a minimalizált string hosszát jelzi.

 Példa 1:

Input: s = "aaabc"
Output: 3
Magyarázat: Ebben a példában s = "aaabc". Először az 'a' karaktert választjuk ki az 1-es indexen. Ezt követően eltávolítjuk az index 1-hez legközelebb eső 'a'-t balról, amely az index 0-nál található, és a legközelebbi 'a'-t jobbról, amely az index 2-nél van. Ezt követően a string "abc"-vé válik. Bármilyen további művelet, amit végrehajtunk a stringen, nem változtat rajta. Ezért a minimalizált string hossza 3.
Példa 2:

Input: s = "cbbd"
Output: 3
Magyarázat: Ehhez kezdhetjük az 'b' karakterrel az 1-es indexen. Nincs 'b' előfordulás balról az 1-es indexhez, de van egy jobbról az index 2-nél, ezért töröljük a 2-es indexen lévő 'b'-t. A string "cbd"-vé válik, és további műveletek nem változtatnak rajta. Ezért a minimalizált hossz 3.

Példa 3:

 Input: s = "dddaaa"
Output: 2
 Magyarázat: Ehhez kezdhetjük a 'd' karakterrel az 1-es indexen. A legközelebbi 'd' előfordulás balról az 0-ás indexen, és a legközelebbi 'd' előfordulás jobbról a 2-es indexen található. Töröljük mindkét indexet (0 és 2), így a string "daaa"-vá válik. Az új stringben választhatjuk az 'a' karaktert a 2-es indexen. A legközelebbi 'a' előfordulás balról az 1-es indexen, és a legközelebbi 'a' előfordulás jobbról a 3-as indexen található. Töröljük mindkettőt, így a string "da"-vá válik. Ezt már nem tudjuk tovább minimalizálni, így a minimalizált hossz 2.

 Korlátozások:

1 <= s.hosszúság <= 100
s csak kisbetűs angol karaktereket tartalmaz


Adott egy 0 indexű egész számtömb nums, és az indexei között haladhatunk. Az i és j index között, i != j, akkor és csak akkor léphetünk át, ha gcd(nums[i], nums[j]) > 1, ahol gcd a legnagyobb közös osztó.
A feladatunk az, hogy meghatározzuk, hogy a nums minden olyan i és j indexpárjára, ahol i < j, létezik-e olyan traverzálási sorozat, amely i-ből j-be vezethet.
Adjunk vissza true-t, ha minden ilyen indexpár között lehetséges a keresztezés, vagy false-t, ha nem.

1. példa:

Bemenet: nums = [2,3,6]
Kimenet: true
Magyarázat: Ebben a példában 3 lehetséges indexpár van: (0, 1), (0, 2) és (1, 2).
A 0 indexről az 1-es indexre a 0 -> 2 -> 1 átjárási sorozatot használhatjuk, ahol a 0 indexről a 2-es indexre lépünk, mert gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, majd a 2-es indexről az 1-es indexre lépünk, mert gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
A 0 indexről a 2-es indexre közvetlenül mehetünk, mert gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Hasonlóképpen, ha az 1-es indexről a 2-es indexre akarunk menni, akkor is közvetlenül mehetünk, mert gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

2. példa:

Bemenet: nums = [3,9,5]
Kimenet: false
Magyarázat: Ebben a példában a 0 indexről a 2 indexre nem juthatunk el egyetlen átjárási sorozat segítségével sem. Ezért false-t adunk vissza.

3. példa:

Bemenet: nums = [4,3,12,8]
Kimenet: true
Magyarázat: A következő 6 lehetséges indexpár között lehet haladni: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) és (2, 3). Mindegyik párhoz létezik érvényes átjárási sorozat, ezért true-t adunk vissza.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számát, és áthaladhatsz az indexei között. Az i és a j index között i != j akkor és csak akkor lehet áthaladni, ha gcd(nums[i], nums[j]) > 1, ahol a gcd a legnagyobb közös osztó.
Az Ön feladata annak meghatározása, hogy minden i és j indexpárra, ahol i < j, létezik-e olyan bejárási sorozat, amely elvihet minket i-ből j-be.
Igaz, ha lehetséges az összes ilyen indexpár között áthaladni, vagy hamis értéket ad vissza.

1. példa:

Bemenet: nums = [2,3,6]
Kimenet: igaz
Magyarázat: Ebben a példában 3 lehetséges indexpár van: (0, 1), (0, 2) és (1, 2).
A 0 indexről az 1-es indexre való átlépéshez használhatjuk a 0 -> 2 -> 1 bejárások sorozatát, ahol a 0 indexről a 2-es indexre lépünk, mert gcd(nums[0], nums[2]) = gcd(2 , 6) = 2 > 1, majd lépjen a 2. indexről az 1. indexre, mert gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Ha a 0 indexről a 2. indexre akarunk lépni, akkor csak közvetlenül léphetünk, mert gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Hasonlóképpen, ha az 1. indexről a 2. indexre akarunk lépni, csak közvetlenül mehetünk, mert gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

2. példa:

Bemenet: nums = [3,9,5]
Kimenet: hamis
Magyarázat: Ebben a példában egyetlen bejárási sorozat sem vihet el minket a 0-tól a 2-es indexig. Tehát hamisat adunk vissza.

3. példa:

Bemenet: nums= [4,3,12,8]
Kimenet: igaz
Magyarázat: 6 lehetséges indexpárt lehet bejárni: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) és (2, 3). Minden párhoz létezik érvényes bejárási sorozat, így igazat adunk vissza.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számokat, és áthaladhatsz az indexei között. Az i és a j index között i != j akkor és csak akkor lehet áthaladni, ha gcd(számok[i], számok[j]) > 1, ahol a gcd a legnagyobb közös osztó.
Az Ön feladata annak meghatározása, hogy minden i és j indexpárra, ahol i < j, létezik-e olyan bejárási sorozat, amely elvihet minket i-ből j-be.
Igaz, ha lehetséges az összes ilyen indexpár között áthaladni, vagy hamis értéket ad vissza.

Példa 1:

Bemenet: nums = [2,3,6]
Kimenet: true
Magyarázat: Ebben a példában 3 lehetséges indexpár van: (0, 1), (0, 2) és (1, 2).
Az index 0-ról az index 1-re való eljutáshoz használhatjuk a 0 -> 2 -> 1 mozgássorozatot, ahol az index 0-ról az index 2-re lépünk, mert gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, majd az index 2-ről az index 1-re lépünk, mert gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Az index 0-ról az index 2-re akár közvetlenül is eljuthatunk, mert gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Ugyanígy, az index 1-ről az index 2-re szintén közvetlenül eljuthatunk, mert gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Példa 2:

Bemenet: nums = [3,9,5]
Kimenet: false
Magyarázat: Ebben a példában egyetlen bejárási sorozat sem vihet el minket a 0-tól a 2-es indexig. Tehát hamisat adunk vissza.

Példa 3:

Bemenet: nums = [4,3,12,8]
Kimenet: true
Magyarázat: 6 lehetséges indexpárt lehet bejárni: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) és (2, 3). Minden párhoz létezik érvényes bejárási sorozat, így igazat adunk vissza.

Korlátozások:

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


Adott egy s karakterlánc, amely csak kisbetűs angol betűkből áll. Egy műveletben a következőket teheti meg:

Válassza ki az s bármelyik nem üres részláncát, esetleg az egész karakterláncot, majd cserélje ki annak minden egyes karakterét az angol ábécé előző karakterére. Például a 'b'-t 'a'-ra, az 'a'-t pedig 'z'-re alakítja.

Adja vissza a lexikográfiailag legkisebb karakterláncot, amelyet a fenti művelet pontosan egyszeri elvégzése után kapunk.
A részlánc a karakterek összefüggő sorozata egy karakterláncban.
Egy x karakterlánc lexikográfiailag kisebb, mint egy azonos hosszúságú y karakterlánc, ha x[i] az első i pozícióban az alfabetikus sorrendben y[i] elé kerül, úgy, hogy x[i] != y[i].

Példa 1:

Bemenet: s = "cbabc"
Kimenet: "baabc"
Magyarázat: A műveletet a 0 indexszel kezdődő és az 1-es indexszel bezárólag végződő részláncra alkalmazzuk.
Bizonyítható, hogy a kapott karakterlánc a lexikográfiailag legkisebb.

Példa 2:

Bemenet: s = "acbbc"
Kimenet: "abaab"
Magyarázat: A műveletet az 1. indexszel kezdődő és a 4. indexszel bezárólag végződő részláncra alkalmazzuk.
Bizonyítható, hogy a kapott karakterlánc a lexikográfiailag legkisebb.

Példa 3:

Bemenet:s = "leetcode"
Kimenet:"kddsbncd"
Magyarázat: A műveletet a teljes karakterláncra alkalmazzuk.
Bizonyítható, hogy az eredményül kapott karakterlánc a lexikográfiailag legkisebb.

Korlátozások:

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

Kapsz egy s karakterláncot, amely csak kisbetűket tartalmaz angolul. Egy művelettel a következőket teheti:

Jelölje ki az s bármely nem üres részkarakterláncát, esetleg a teljes karakterláncot, majd cserélje ki minden egyes karakterét az angol ábécé előző karakterére. Például a „b” „a”-ra, az „a” pedig „z”-re.

Adja vissza azt a lexikográfiailag legkisebb karakterláncot, amelyet a fenti művelet végrehajtása után kaphat, pontosan egyszer.
A részkarakterlánc egy karakterláncban összefüggő karaktersorozat.
Egy x karakterlánc lexikográfiailag kisebb, mint egy azonos hosszúságú y karakterlánc, ha x[i] az első i pozícióban y[i] elé kerül, így x[i] != y[i].

1. példa:

Bemenet: s = "cbabc"
Kimenet: "baabc"
Magyarázat: Alkalmazzuk a műveletet a 0 indextől kezdődő és az 1-es indexre végződő részkarakterláncra.
Bizonyítható, hogy a kapott karakterlánc lexikográfiailag a legkisebb.

2. példa:

Bemenet: s = "acbbc"
Kimenet: "abaab"
Magyarázat: Alkalmazzuk a műveletet az 1-es indexszel kezdődő és a 4-es indexszel végződő karakterláncra.
Bizonyítható, hogy a kapott karakterlánc lexikográfiailag a legkisebb.

3. példa:

Bemenet: s = "leetcode"
Kimenet: "kddsbncd"
Magyarázat: A műveletet a teljes karakterláncra alkalmazzuk.
Bizonyítható, hogy a kapott karakterlánc lexikográfiailag a legkisebb.

Korlátozások:

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

Kapsz egy s karakterláncot, amely csak kisbetűket tartalmaz angolul. Egy művelettel a következőket teheti:

Jelölje ki az s bármely nem üres részkarakterláncát, esetleg a teljes karakterláncot, majd cserélje ki minden egyes karakterét az angol ábécé előző karakterére. Például a „b” „a”-ra, az „a” pedig „z”-re.

Adja vissza azt a lexikográfiailag legkisebb karakterláncot, amelyet a fenti művelet végrehajtása után kaphat, pontosan egyszer.
A részkarakterlánc egy karakterláncban összefüggő karaktersorozat.
Egy x karakterlánc lexikográfiailag kisebb, mint egy azonos hosszúságú y karakterlánc, ha x[i] az első i pozícióban y[i] elé kerül, így x[i] != y[i].

példa 1:

Bemenet: s = "cbabc"
Kimenet: "baabc"
Magyarázat: Alkalmazzuk a műveletet a 0 indextől kezdődő és az 1-es indexre végződő részkarakterláncra.
Bizonyítható, hogy a kapott karakterlánc lexikográfiailag a legkisebb.

példa 2:

Bemenet: s = "acbbc"
Kimenet: "abaab"
Magyarázat: Alkalmazzuk a műveletet az 1-es indexszel kezdődő és a 4-es indexszel végződő karakterláncra.
Bizonyítható, hogy a kapott karakterlánc lexikográfiailag a legkisebb.

példa 3:

Bemenet: s = "leetcode"
Kimenet: "kddsbncd"
Magyarázat: A műveletet a teljes karakterláncra alkalmazzuk.
Bizonyítható, hogy a kapott karakterlánc lexikográfiailag a legkisebb.

Korlátozások:

1 <= s.length <= 3 * 10^5
s angol kisbetűkből áll


Van egy 0-indexelt egész számokat tartalmazó tömböd, amit nums-nak hívnak. Egy indexpár i, j, ahol 0 <= i < j < nums.length, "szépnek" nevezzük, ha nums[i] első számjegye és nums[j] utolsó számjegye relatív prímek.
Vissza kell adni a szép párok számát a nums-ban.
Két x és y egész szám koprím, ha nincs 1-nél nagyobb egész, amely mindkettőt osztja. Más szavakkal, x és y koprím, ha gcd(x, y) == 1, ahol gcd(x, y) x és y legnagyobb közös osztója.

Példa 1:

Bemenet: nums = [2,5,1,4]
Kimenet: 5
Magyarázat: 5 szép pár van a nums-ban:
Amikor i = 0 és j = 1: nums[0] első számjegye 2, és nums[1] utolsó számjegye 5. Megerősíthetjük, hogy 2 és 5 relatív prímek, mivel gcd(2,5) == 1.
Amikor i = 0 és j = 2: nums[0] első számjegye 2, és nums[2] utolsó számjegye 1. Valóban, gcd(2,1) == 1.
Amikor i = 1 és j = 2: nums[1] első számjegye 5, és nums[2] utolsó számjegye 1. Valóban, gcd(5,1) == 1.
Amikor i = 1 és j = 3: nums[1] első számjegye 5, és nums[3] utolsó számjegye 4. Valóban, gcd(5,4) == 1.
Amikor i = 2 és j = 3: nums[2] első számjegye 1, és nums[3] utolsó számjegye 4. Valóban, gcd(1,4) == 1.
Így visszaadjuk az 5-öt.

Példa 2:

Bemenet: nums = [11,21,12]
Kimenet: 2
Magyarázat: 2 gyönyörű pár van:
Amikor i = 0 és j = 1: nums[0] első számjegye 1, és nums[1] utolsó számjegye 1. Valóban, gcd(1,1) == 1.
Amikor i = 0 és j = 2: nums[0] első számjegye 1, és nums[2] utolsó számjegye 2. Valóban, gcd(1,2) == 1.
Így visszaadjuk a 2-t.

Korlátozások:

2 <= nums.length <= 100
1 <= nums[i] <= 9999
nums[i] % 10 != 0

Kap egy 0 indexelt egész tömb számát. Az i, j indexpár, ahol 0 <= i < j < számok.length akkor nevezhető szépnek, ha a számok[i] első számjegye és számok ms[j] utolsó számjegye egymással relatív prím.
A gyönyörű párok teljes számát adja vissza a tömbben.
Két x és y egész szám egymással relatív prím, ha nincs 1-nél nagyobb egész szám, amely mindkettőt osztja. Más szóval x és y egymással relatív prímek, ha gcd(x, y) == 1, ahol gcd(x, y) x és y legnagyobb közös osztója.

1. példa:

Bemenet: szám = [2,5,1,4]
Kimenet: 5
Magyarázat: 5 gyönyörű pár van a tömbben:
Ha i = 0 és j = 1: a szám[0] első számjegye 2, a szám[1] utolsó számjegye pedig 5. Megerősíthetjük, hogy a 2 és az 5 egymással relatív prím, mivel gcd(2,5) == 1.
Ha i = 0 és j = 2: a számok[0] első számjegye 2, a számok[2] utolsó számjegye pedig 1. Valóban, gcd(2,1) == 1.
Ha i = 1 és j = 2: a számok[1] első számjegye 5, a számok[2] utolsó számjegye pedig 1. Valóban, gcd(5,1) == 1.
Ha i = 1 és j = 3: a számok[1] első számjegye 5, a számok[3] utolsó számjegye pedig 4. Valóban, gcd(5,4) == 1.
Ha i = 2 és j = 3: a számok[2] első számjegye 1, a számok[3] utolsó számjegye pedig 4. Valóban, gcd(1,4) == 1.
Így visszatérünk 5.

2. példa:

Bemenet: számok = [11,21,12]
Kimenet: 2
Magyarázat: 2 gyönyörű pár van:
Ha i = 0 és j = 1: a szám[0] első számjegye 1, a szám[1] utolsó számjegye pedig 1. Valóban, gcd(1,1) == 1.
Ha i = 0 és j = 2: a szám[0] első számjegye 1, a szám[2] utolsó számjegye pedig 2. Valóban, gcd(1,2) == 1.
Így visszatérünk 2.

Korlátok:

2 <= szám.hossz <= 100
1 <= SZÁM[i] <= 9999
szám[i] % 10 != 0

Adott egy 0-indexált egész számtömb nums. Egy i, j indexpárt, ahol 0 <= i < j < nums.length, akkor nevezünk szépnek, ha a nums[i] első és a nums[j] utolsó számjegye koprime.
Visszaadja a nums-ban lévő szép párok teljes számát.
Két egész szám x és y akkor coprime, ha nincs olyan 1-nél nagyobb egész szám, amely mindkettőt osztja. Más szóval, x és y akkor coprime, ha gcd(x, y) == 1, ahol gcd(x, y) x és y legnagyobb közös osztója.

Példa 1:

Bemenet: nums = [2,5,1,4]
Kimenet: 5
Magyarázat: A nums-ban 5 szép pár van:
Ha i = 0 és j = 1: a nums[0] első számjegye 2, a nums[1] utolsó számjegye pedig 5. Megerősíthetjük, hogy 2 és 5 koprime, hiszen gcd(2,5) == 1.
Ha i = 0 és j = 2: a nums[0] első számjegye 2, a nums[2] utolsó számjegye pedig 1. Valóban, gcd(2,1) == 1.
Ha i = 1 és j = 2: a nums[1] első számjegye 5, és a nums[2] utolsó számjegye 1. Valóban, gcd(5,1) == 1.
Ha i = 1 és j = 3: a nums[1] első számjegye 5, a nums[3] utolsó számjegye pedig 4. Valóban, gcd(5,4) == 1.
Ha i = 2 és j = 3: a nums[2] első számjegye 1, és a nums[3] utolsó számjegye 4. Valóban, gcd(1,4) == 1.
Így tehát 5-t adunk vissza.

2. példa:

Bemenet: nums = [11,21,12]
Kimenet: 2
Magyarázat: 2 szép pár van:
Ha i = 0 és j = 1: a nums[0] első számjegye 1, és a nums[1] utolsó számjegye 1. Valóban, gcd(1,1) == 1.
Amikor i = 0 és j = 2: a nums[0] első számjegye 1, és a nums[2] utolsó számjegye 2. Valóban, gcd(1,2) == 1.
Így tehát 2-t adunk vissza.

Korlátozások:

2 <= nums.length <= 100
1 <= nums[i] <= 9999
nums[i] % 10 != 0


Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Egy résztömböt egyenlőnek nevezünk, ha minden eleme egyenlő. Vegye figyelembe, hogy az üres résztömb egyenlő résztömb.
A lehető leghosszabb egyenlő résztömb hosszát adja eredményül, miután legfeljebb k elemet törölt a számokból.
Az altömb elemek folytonos, esetleg üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [1,3,2,3,1,3], k = 3
Kimenet: 3
Magyarázat: Optimális törölni a 2. és 4. index elemeit.
A törlés után nums egyenlőek lesznek [1, 3, 3, 3].
A leghosszabb egyenlő résztömb i = 1-nél kezdődik és j = 3-nál végződik, hossza 3.
Bebizonyítható, hogy már nem lehet egyenlő résztömböket létrehozni.

2. példa:

Bemenet: nums = [1,1,2,2,1,1], k = 2
Kimenet: 4
Magyarázat: Optimális a 2. és 3. index elemeinek törlése.
A törlés után nums egyenlővé válnak [1, 1, 1, 1].
Maga a tömb egyenlő résztömb, így a válasz 4.
Bebizonyítható, hogy már nem lehet egyenlő résztömböket létrehozni.

Korlátok:

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

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Egy résztömböt egyenlőnek nevezünk, ha minden eleme egyenlő. Vegye figyelembe, hogy az üres altömb egyenlő altömb.
A lehető leghosszabb egyenlő altömb hosszát adja vissza, miután a számokból legfeljebb k elemet törölt.
Az altömb egy összefüggő, esetleg üres elemsorozat egy tömbön belül.

1. példa:

Bemenet: nums = [1,3,2,3,1,3], k = 3
Kimenet: 3
Magyarázat: Optimális a 2. és 4. index elemeinek törlése.
Törlésük után a számok egyenlővé válnak [1, 3, 3, 3] értékkel.
A leghosszabb egyenlő altömb i = 1-nél kezdődik és j = 3-nál végződik, hossza 3.
Bebizonyosítható, hogy többé nem lehet egyenlő résztömböket létrehozni.

2. példa:

Bemenet: nums = [1,1,2,2,1,1], k = 2
Kimenet: 4
Magyarázat: Optimális a 2. és 3. index elemeinek törlése.
Törlésük után a számok egyenlővé válnak [1, 1, 1, 1] értékkel.
Maga a tömb egy egyenlő altömb, így a válasz 4.
Bebizonyosítható, hogy többé nem lehet egyenlő résztömböket létrehozni.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Egy résztömböt egyenlőnek nevezünk, ha minden eleme egyenlő. Vegye figyelembe, hogy az üres altömb egyenlő altömb.
A lehető leghosszabb egyenlő altömb hosszát adja vissza, miután a számokból legfeljebb k elemet törölt.
Az altömb egy összefüggő, esetleg üres elemsorozat egy tömbön belül.

Példa 1:

Bemenet: nums = [1,3,2,3,1,3], k = 3
Kimenet: 3
Magyarázat: Optimális a 2. és 4. index elemeinek törlése.
Törlésük után a számok egyenlővé válnak [1, 3, 3, 3] értékkel.
A leghosszabb egyenlő altömb i = 1-nél kezdődik és j = 3-nál végződik, hossza 3.
Bebizonyosítható, hogy többé nem lehet egyenlő résztömböket létrehozni.

Példa 2:

Bemenet: nums = [1,1,2,2,1,1], k = 2
Kimenet: 4
Magyarázat: Optimális a 2. és 3. index elemeinek törlése.
Törlésük után a számok egyenlővé válnak [1, 1, 1, 1] értékkel.
Maga a tömb egy egyenlő altömb, így a válasz 4.
Bebizonyosítható, hogy többé nem lehet egyenlő résztömböket létrehozni.

Korlátozások:

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


Egy n egész számot kap, amely a kiszolgálók teljes számát jelöli, és egy 2D 0-indexelt egész tömb naplókat, ahol a logs[i] = [szerver_azonosítója, idő] azt jelzi, hogy a szerver_id azonosítójú szerver adott időpontban kérést kapott.
Adott még egy x egész szám és egy 0-indexelt egész számokból álló tömb, amely a lekérdezések tartalmát reprezentálja.
Egy 0 indexű, queries.length hosszúságú egész tömböt ad vissza, ahol az arr[i] azon kiszolgálók számát jelenti, amelyek nem kaptak kérést a [queries[i] - x, queries[i]] időtartam alatt.
Vegye figyelembe, hogy az időintervallumok magukban foglalják.

Példa 1:

Bemenet: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Kimenet: [1,2]
Magyarázat:
Lekérdezésekhez[0]: Az 1-es és 2-es azonosítójú szerverek [5, 10] időtartam alatt kapnak kéréseket. Ezért csak a 3. szerver kap nulla kérést.
Lekérdezéseknél[1]: Csak a 2-es azonosítójú szerver kap [6,11] időtartamú kérést. Ezért az 1-es és 3-as azonosítójú szerverek az egyetlenek, amelyek nem kapnak kéréseket ezalatt az időszak alatt.

Példa 2:

Bemenet: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Kimenet: [0,1]
Magyarázat:
Queries[0] esetén: Minden szerver kap legalább egy kérést [1, 3] időtartama alatt.
Lekérdezéseknél[1]: Csak a 3-as azonosítójú szerver nem kap kérést a [2,4] időtartam alatt.

Korlátozások:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Kapsz egy n egész számot, amely a kiszolgálók teljes számát jelöli, és egy 2D 0 indexelt egész tömbnaplót, ahol logs[i] = [server_id, time] azt jelöli, hogy az id server_id azonosítóval rendelkező szerver kérést kapott az adott időpontban.
Egy x egész és egy 0 indexelt egész tömb lekérdezést is kap.
Egy 0 indexelt egész tömböt ad vissza arr of length queries.length ahol arr[i] azoknak a kiszolgálóknak a számát jelöli, amelyek nem kaptak kéréseket a [queries[i] - x, queries[i]] időintervallumban.
Vegye figyelembe, hogy az időintervallumok befogadóak.

1. példa:

Bemenet:  n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Kimenet: [1,2]
Magyarázat:
Lekérdezések esetén[0]: az 1-es és 2-es azonosítójú kiszolgálók [5, 10] időtartam alatt kapnak kéréseket. Ezért csak a 3. kiszolgáló kap nulla kérést.
Lekérdezések esetén [1] Csak a 2-es azonosítójú kiszolgáló kap [6,11] időtartamú kérést. Ezért az 1-es és 3-as azonosítójú kiszolgálók az egyetlenek, amelyek nem kapnak kéréseket ebben az időszakban.

2. példa:

Bemenet:  n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Kimenet: [0,1]
Magyarázat:
Lekérdezések esetén [0]： Minden kiszolgáló kap legalább egy kérést az [1, 3] időtartam alatt.
Lekérdezések esetén[1]: Csak a 3-as azonosítóval rendelkező kiszolgáló nem kap kérést a [2,4] időtartamban.

Korlátok:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Egy n egész számot kap, amely a kiszolgálók teljes számát jelöli, és egy 2D 0-indexelt egész tömb naplókat, ahol a logs[i] = [szerver_azonosítója, idő] azt jelzi, hogy a szerver_id azonosítójú szerver adott időpontban kérést kapott.
Adott még egy x egész szám és egy 0 indexelt egész tömb lekérdezések.
Egy 0 indexű, queries.length hosszúságú egész tömböt ad vissza, ahol az arr[i] azon kiszolgálók számát jelenti, amelyek nem kaptak kérést a [queries[i] - x, queries[i]] időtartam alatt.
Vegye figyelembe, hogy az időintervallumok magukban foglalják.

1. példa:

Bemenet: n = 3, logs= [[1,3], [2,6], [1,5]], x = 5, queries = [10,11]
Kimenet: [1,2]
Magyarázat:
Lekérdezésekhez[0]: Az 1-es és 2-es azonosítójú szerverek [5, 10] időtartam alatt kapnak kéréseket. Ezért csak a 3. szerver kap nulla kérést.
Lekérdezéseknél[1]: Csak a 2-es azonosítójú szerver kap [6,11] időtartamú kérést. Ezért az 1-es és 3-as azonosítójú szerverek az egyetlenek, amelyek nem kapnak kéréseket ezalatt az időszak alatt.

2. példa:

Bemenet: n = 3, logs = [[2,4], [2,1], [1,2], [3,1]], x = 2, queries = [3,4]
Kimenet: [0,1]
Magyarázat:
Queries[0] esetén: Minden szerver kap legalább egy kérést [1, 3] időtartama alatt.
Lekérdezéseknél[1]: Csak a 3-as azonosítójú szerver nem kap kérést a [2,4] időtartam alatt.

Korlátozások:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6


Meg van adva egy 0-indexált egész számokból álló tömb, a nums, ami néhány golyó kezdeti helyzetét képviseli. Továbbá meg van adva két 0-indexált egész számokból álló tömb, a moveFrom és moveTo, amelyek egyenlő hosszúságúak.

A moveFrom.length lépés során meg fogod változtatni a golyók helyzetét. Az i^edik lépésnél az összes golyót a moveFrom[i] helyzetből a moveTo[i] helyzetbe mozgatod.

Miután minden lépést befejeztél, add vissza a foglalt helyek rendezett listáját.

Megjegyzések:

Egy helyet foglaltnak nevezünk, ha legalább egy golyó van ott.
Lehet több golyó is egyetlen helyzetben.

Példa 1:

Bemenet: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Kimenet: [5,6,8,9]
Magyarázat: Kezdetben a golyók a 1,6,7,8 pozíciókban vannak.
Az i = 0. lépésnél a golyókat az 1-es pozícióról a 2-es pozícióra mozgatjuk. Ekkor a 2,6,7,8 pozíciók foglaltak.
Az i = 1. lépésnél a golyókat a 7-es pozícióról a 9-es pozícióra mozgatjuk. Ekkor a 2,6,8,9 pozíciók foglaltak.
Az i = 2. lépésnél a golyókat a 2-es pozícióról az 5-ös pozícióra mozgatjuk. Ekkor az 5,6,8,9 pozíciók foglaltak.
A végén a golyókat tartalmazó pozíciók [5,6,8,9].
Példa 2:

Bemenet: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Kimenet: [2]
Magyarázat: Kezdetben a golyók az [1,1,3,3] pozíciókban vannak.
Az i = 0. lépésnél minden golyót az 1-es pozícióról a 2-es pozícióra mozgatunk. Ekkor a golyók a [2,2,3,3] pozíciókban vannak.
Az i = 1. lépésnél minden golyót a 3-as pozícióról a 2-es pozícióra mozgatunk. Ekkor a golyók a [2,2,2,2] pozíciókban vannak.
Mivel csak a 2-es pozíció foglalt, visszaadjuk a [2]-t.

Korlátozások:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
A tesztesetek úgy vannak kialakítva, hogy legalább egy golyó van a moveFrom[i] helyzetben abban a pillanatban, amikor alkalmazni akarjuk az i^edik mozgást.

Adott egy 0 indexű egész számtömb nums, amely néhány golyó kezdeti pozícióját jelöli. Adott továbbá két 0 indexű, azonos hosszúságú egész számtömb moveFrom és moveTo.
A moveFrom.length lépéseken keresztül változtatod a golyók pozícióit. Az i^-edik lépésben a moveFrom[i] pozícióban lévő összes golyót a moveTo[i] pozícióba helyezzük át.
Az összes lépés elvégzése után adja vissza a betöltött pozíciók rendezett listáját.
Megjegyzések:

Egy pozíciót akkor nevezünk foglaltnak, ha legalább egy golyó van az adott pozícióban.
Egy pozícióban több golyó is lehet.

Példa 1:

Bemenet: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Kimenet: [5,6,8,9]
Magyarázat: Kezdetben a golyók az 1,6,7,8-as pozíciókban vannak.
Az i = 0. lépésnél az 1. pozícióban lévő golyókat a 2. pozícióba mozgatjuk. Ezután a 2,6,7,7,8-as pozíciókat elfoglaljuk.
Az i = 1. lépésnél a 7-es pozícióban lévő golyókat a 9-es pozícióba helyezzük. Ezután a 2,6,8,9-es pozíciók foglaltak.
Az i = 2. lépésnél a 2. pozícióban lévő golyókat áthelyezzük az 5. pozícióba. Ekkor az 5,6,8,9-es pozíciók foglaltak.
A végén a legalább egy golyót tartalmazó végső pozíciók a [5,6,8,8,9].
Példa 2:

Bemenet: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Kimenet: [2]
Magyarázat: Kezdetben a golyók az [1,1,3,3,3] pozíciókban vannak.
Az i = 0. lépésnél az 1. pozícióban lévő összes golyót a 2. pozícióba mozgatjuk. Ezután a golyók a [2,2,3,3,3] pozíciókban vannak.
Az i = 1. lépésnél a 3. pozícióban lévő összes golyót áthelyezzük a 2. pozícióba. Ekkor a golyók a [2,2,2,2,2] pozíciókban vannak.
Mivel a 2 az egyetlen elfoglalt pozíció, visszaadjuk a [2]-t.

Korlátozások:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
A teszteseteket úgy generáljuk, hogy a moveFrom[i]-ben legalább egy golyó legyen abban a pillanatban, amikor az i^-edik lépést akarjuk alkalmazni.

Kapsz egy 0-indexelt egész tömb számokat, amelyek egyes golyók kezdeti helyzetét reprezentálják. Kapsz még két egyenlő hosszúságú 0-indexelt egész szám tömböt a moveFrom és a moveTo.
A moveFrom.length lépések során megváltoztathatja a golyók helyzetét. Az i^. lépésben az összes golyót a moveFrom[i] pozícióban mozgatja a moveTo[i] pozícióba.
Az összes lépés végrehajtása után küldje vissza a foglalt pozíciók rendezett listáját.
Megjegyzések:

Elfoglaltnak nevezünk egy pozíciót, ha legalább egy márvány van abban a pozícióban.
Egy helyen több golyó is lehet.

1. példa:

Bevitel: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Kimenet: [5,6,8,9]
Magyarázat: Kezdetben a golyók az 1,6,7,8 pozícióban vannak.
Az i = 0. lépésnél az 1. pozícióban lévő golyókat a 2. pozícióba mozgatjuk. Ezután a 2, 6, 7, 8 pozíciókat foglaljuk el.
Az i = 1. lépésnél a 7. pozícióban lévő golyókat a 9. pozícióba mozgatjuk. Ezután a 2, 6, 8, 9 pozíciókat foglaljuk el.
Az i = 2. lépésnél a 2. pozícióban lévő golyókat az 5. pozícióba mozgatjuk. Ezután az 5, 6, 8, 9 pozíciókat foglaljuk el.
A végén a legalább egy golyót tartalmazó végső pozíciók [5,6,8,9].
2. példa:

Bemenet: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Kimenet: [2]
Magyarázat: Kezdetben a golyók az [1,1,3,3] pozíciókban vannak.
Az i = 0. lépésnél az 1. pozícióban lévő összes golyót a 2. pozícióba mozgatjuk. Ezután a golyók a [2,2,3,3] pozíciókban vannak.
Az i = 1. lépésnél a 3. pozícióban lévő összes golyót a 2. pozícióba mozgatjuk. Ezután a golyók a [2,2,2,2] pozíciókban vannak.
Mivel a 2 az egyetlen foglalt pozíció, visszatérünk [2].

Korlátozások:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
A tesztesetek úgy jönnek létre, hogy legalább egy golyó van a moveFrom[i]-ben abban a pillanatban, amikor az i^. lépést szeretnénk alkalmazni.


Két egész számot kapsz: num1 és num2.
Egy műveletben kiválaszthatja az i egész számot a [0, 60] tartományban, és kivonhatja a 2^i + num2-t a szám1-ből.
Adja vissza azt az egész számot, amely a műveletek minimális számát jelöli ahhoz, hogy a num1 0 legyen.
Ha lehetetlen, hogy a szám1 egyenlő legyen 0-val, adjon vissza -1-et.

1. példa:

Bemenet: num1 = 3, num2 = -2
Kimenet: 3
Magyarázat: A 3-at 0-val egyenlővé tehetjük a következő műveletekkel:
- Az i = 2 -t választjuk, és kivonjuk a 2^2 + (-2) értéket 3-ból, 3 - (4 + (-2)) = 1.
- Az i = 2-t választjuk, és 1-ből kivonjuk a 2^2 + (-2), 1 - (4 + (-2)) = -1.
- Az i = 0-t választjuk, és a -1-ből kivonjuk a 2^0 + (-2), (-1) - (1 + (-2)) = 0-t.
Bizonyítható, hogy 3 a minimális számú művelet, amit végre kell hajtanunk.

2. példa:

Bemenet: num1 = 5, num2 = 7
Kimenet: -1
Magyarázat: Bizonyítható, hogy az adott művelettel lehetetlen 5-öt 0-val egyenlővé tenni.

Korlátozások:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

Két egész számot kap, num1 és num2.
Egy műveletben kiválaszthatja az i egész számot a [0, 60] tartományban, és kivonhatja a 2^i + num2 számot a num1-ből.
Az egész számot adja vissza, amely azt a minimális műveletszámot jelöli, amely ahhoz szükséges, hogy a num1 értéke 0 legyen.
Ha lehetetlen a num1-et 0-ra tenni, adja vissza a -1 értéket.

1. példa:

Bemenet: num1 = 3, num2 = -2
Kimenet: 3
Magyarázat: A következő műveletekkel 3-at egyenlővé tehetünk 0-val:
- Kiválasztjuk i = 2 és kivonjuk a 2^2 + (-2) értéket 3, 3 - (4 + (-2)) = 1-ből.
- Válasszuk az i = 2-t, és vonjuk le a 2^2 + (-2) -t 1, 1 - (4 + (-2)) = -1-ből.
- Az i = 0 értéket választjuk, és kivonjuk a 2^0 + (-2) -1, (-1) - (1 + (-2)) = 0-ból.
Bizonyítható, hogy 3 a minimális műveletszám, amelyet végre kell hajtanunk.

2. példa:

Bemenet: num1 = 5, num2 = 7
Kimenet: -1
Magyarázat: Bizonyítható, hogy az adott művelettel lehetetlen 5-öt 0-val egyenlővé tenni.

Korlátok:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9


Adott két 0 indexű egész számtömb nums1 és nums2, amelyek mindegyike n hosszúságú, valamint egy 1-indexű 2D tömb queries, ahol queries[i] = [x_i, y_i].
Az i^-edik lekérdezéshez keressük meg a nums1[j] + nums2[j] maximális értékét az összes j index (0 <= j < n) között, ahol nums1[j] >= x_i és nums2[j] >= y_i, vagy -1, ha nincs olyan j, amely kielégíti a feltételeket.
Visszaad egy tömbi választ, ahol answer[i] az i^-edik lekérdezésre adott válasz.

Példa 1:

Input: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]].
Kimenet: [6,10,7]
Magyarázat:
Az 1. lekérdezésnél x_i = 4 és y_i = 1, a j = 0 indexet kiválaszthatjuk, mivel nums1[j] >= 4 és nums2[j] >= 1. A nums1[j] + nums2[j] összege 6, és megmutathatjuk, hogy 6 a maximálisan elérhető érték.

A 2. lekérdezésnél x_i = 1 és y_i = 3, a j = 2 indexet kiválaszthatjuk, mivel nums1[j] >= 1 és nums2[j] >= 3. A nums1[j] + nums2[j] összeg 10, és megmutathatjuk, hogy 10 a maximálisan elérhető érték.

A 3. lekérdezésnél x_i = 2 és y_i = 5, a j = 3 indexet kiválaszthatjuk, mivel nums1[j] >= 2 és nums2[j] >= 5. A nums1[j] + nums2[j] összege 7, és megmutathatjuk, hogy 7 a maximálisan elérhető érték.

Ezért [6,10,7] értéket adunk vissza.

2. példa:

Bemenet:nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Kimenet: [9,9,9]
Magyarázat: Ebben a példában minden lekérdezéshez használhatjuk a j = 2 indexet, mivel ez minden lekérdezéshez kielégíti a korlátozásokat.

3. példa:

Input: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Kimenet: [-1]
Magyarázat: Ebben a példában egy lekérdezés van x_i = 3 és y_i = 3 értékkel. Minden index, j esetében vagy nums1[j] < x_i vagy nums2[j] < y_i. Ezért nincs megoldás.

Korlátozások:

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

Két 0-indexelt egész szám tömb nums1 és szám2, mindegyik n hosszú, és egy 1 indexű 2D tömb lekérdezés, ahol queries[i] = [x_i, y_i].
Az i^. lekérdezéshez keresse meg a nums1[j] + szám2[j] maximális értékét az összes j index között (0 <= j < n), ahol nums1[j] >= x_i és szám2[j] >= y_i , vagy -1, ha nincs j, amely kielégíti a megszorításokat.
Adjon vissza egy tömbválaszt, ahol a válasz[i] az i^. lekérdezés válasza.

1. példa:

Bemenet: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Kimenet: [6,10,7]
Magyarázat:
Az x_i = 4 és y_i = 1 1. lekérdezéshez a j = 0 indexet választhatjuk, mivel nums1[j] >= 4 és nums2[j] >= 1. A nums1[j] + nums2[j] összege 6, és megmutathatjuk, hogy 6 a maximum, amit kaphatunk.

A 2. x_i = 1 és y_i = 3 lekérdezéshez a j = 2 indexet választhatjuk, mivel nums1[j] >= 1 és nums2[j] >= 3. A nums1[j] + nums2[j] összege 10, és megmutathatjuk, hogy 10 a maximum, amit kaphatunk.

A 3. x_i = 2 és y_i = 5 lekérdezéshez a j = 3 indexet választhatjuk, mivel nums1[j] >= 2 és nums2[j] >= 5. A nums1[j] + nums2[j] összege 7, és megmutathatjuk, hogy 7 a maximum, amit kaphatunk.

Ezért visszatérünk [6,10,7].

2. példa:

Bemenet: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4], [3,2], [1,1]]
Kimenet: [9,9,9]
Magyarázat: Ebben a példában az összes lekérdezéshez használhatjuk a j = 2 indexet, mivel az megfelel az egyes lekérdezésekre vonatkozó megszorításoknak.

3. példa:

Bemenet: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Kimenet: [-1]
Magyarázat: Ebben a példában van egy lekérdezés x_i = 3 és y_i = 3 értékkel. Minden j indexhez vagy nums1[j] < x_i, vagy nums2[j] < y_i. Ezért nincs megoldás.

Korlátozások:

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

Két 0-indexelt egész szám tömb nums1 és nums2, mindegyik n hosszú, és egy i. lekérdezés2D tömb lekérdezés, ahol queries[i] = [x_i, y_i].
Az i. lekérdezéshez keresse meg a nums1[j] + nums2[j] maximális értékét az összes j index között (0 <= j < n), ahol nums1[j] >= x_i és nums2[j] >= y_i , vagy -1, ha nincs j, amely kielégíti a megszorításokat.
Adjon vissza egy tömbválaszt, ahol answer[i] azi. lekérdezés válasza.

példa 1:

Bemenet: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1], [1,3], [2,5]]
Kimenet: [6,10,7]
Magyarázat:
Az x_i = 4 és y_i = 1 1. lekérdezéshez a j = 0 indexet választhatjuk, mivel nums1[j] >= 4 és nums2[j] >= 1. A nums1[j] + nums2[j] összege 6, és megmutathatjuk, hogy 6 a maximum, amit kaphatunk.

A 2. x_i = 1 és y_i = 3 lekérdezéshez a j = 2 indexet választhatjuk, mivel nums1[j] >= 1 és nums2[j] >= 3. A nums1[j] + nums2[j] összege 10, és megmutathatjuk, hogy 10 a maximum, amit kaphatunk.

A 3. x_i = 2 és y_i = 5 lekérdezéshez a j = 3 indexet választhatjuk, mivel nums1[j] >= 2 és nums2[j] >= 5. A nums1[j] + nums2[j] összege 7, és megmutathatjuk, hogy 7 a maximum, amit kaphatunk.

Ezért visszatérünk [6,10,7].

példa 2:

Bemenet: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4], [3,2], [1,1]]
Kimenet: [9,9,9]
Magyarázat: Ebben a példában az összes lekérdezéshez használhatjuk a j = 2 indexet, mivel az megfelel az egyes lekérdezésekre vonatkozó megszorításoknak.

példa 3:

Bemenet: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Kimenet: [-1]
Magyarázat: Ebben a példában van egy lekérdezés x_i = 3 és y_i = 3 értékkel. Minden j indexhez vagy nums1[j] < x_i, vagy nums2[j] < y_i. Ezért nincs megoldás.

Korlátozások:

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


Egy 1-indexű, n hosszúságú egész szám tömb van megadva, melynek neve nums.
A nums egy elemét nums[i]-nek akkor nevezzük speciálisnak, ha i osztja n-et, azaz n % i == 0.
Add vissza a nums összes speciális elemének négyzetösszegét.

1. példa:

Input: nums = [1,2,3,4]
Output: 21
Magyarázat: Pontosan 3 speciális elem van a nums-ban: nums[1], mivel 1 osztja 4-et, nums[2], mivel 2 osztja 4-et, és nums[4], mivel 4 osztja 4-et.
Ezért a nums összes speciális elemének négyzeteinek összege nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

2. példa:

Input: nums = [2,7,1,19,18,3]
Output: 63
Magyarázat: Pontosan 4 speciális elem van a nums-ban: nums[1], mivel 1 osztja 6-ot, nums[2], mivel 2 osztja 6-ot, nums[3], mivel 3 osztja 6-ot, és nums[6], mivel 6 osztja 6-ot.
Ezért a nums összes speciális elemének négyzeteinek összege nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Feltételek:

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

Kapsz egy 1 indexelt egész tömböt, amelynek hossza n.
A numok nums[i] elemét speciálisnak nevezzük, ha i osztja n-t, azaz n % i == 0.
A számok összes speciális elemének négyzetének összegét adja vissza.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 21
Magyarázat: A numokban pontosan 3 speciális elem van: nums[1], mivel 1 osztja a 4-et, nums[2] mivel 2 osztja a 4-et, és nums[4], mivel a 4 osztja a 4-et.
Ezért a nums összes speciális elemének négyzetének összege nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

2. példa:

Bemenet: nums = [2,7,1,19,18,3]
Kimenet: 63
Magyarázat: A numokban pontosan 4 speciális elem van: nums[1], mivel 1 osztja a 6-ot, nums[2] mivel 2 osztja a 6-ot, nums[3] mivel 3 osztja a 6-ot, és nums[6], mivel a 6 osztja a 6-ot.
Ezért a számok összes speciális elemének négyzetének összege nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Korlátok:

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

Egy n hosszúságú 1-indexelt egész tömböt kapunk.
Egy nums [i] elemet speciálisnak nevezünk, ha i osztja n-t, azaz n % i == 0.
Visszaadja a számok összes speciális elemének négyzetösszegét.

Példa 1:

Bemenet: nums = [1,2,3,4]
Kimenet: 21
Magyarázat: Pontosan 3 speciális elem van számokban: a számok[1], mivel az 1 osztja a 4-et, a szám[2], mivel a 2 osztja a 4-et, és a szám[4], mivel a 4 osztja a 4-et.
Ezért a számok összes speciális elemének négyzetösszege: számok[1] * számok[1] + számok[2] * számok[2] + számok[4] * számok[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Példa 2:

Bemenet: nums = [2,7,1,19,18,3]
Kimenet: 63
Magyarázat: Pontosan 4 speciális elem van számokban: a nums[1], mivel az 1 osztja a 6-ot, a szám[2], mivel a 2 osztja a 6-ot, a szám[3], mivel a 3 osztja a 6-ot, és a szám[6], mivel a 6 osztja a 6-ot.
Ezért a számok összes speciális elemének négyzetösszege: számok[1] * számok[1] + számok[2] * számok[2] + számok[3] * számok[3] + számok[6] * számok [6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Korlátozások:

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


Kapsz egy pozitív egész tömbszámot.
Partícionálja a számokat két tömbbe, a szám1 és a szám2 tömbbe úgy, hogy:

A nums tömb minden eleme a nums1 vagy a tömb2 tömbhöz tartozik.
Mindkét tömb nem üres.
A partíció értéke minimalizálva van.

A particionálás értéke |max(nums1) - min(nums2)|.
Itt a max(nums1) a nums1 tömb maximális elemét jelöli, a min(nums2) pedig a nums2 tömb minimális elemét jelöli.
Az ilyen partíció értékét jelölő egész számot adja vissza.

Példa 1:

Bemenet: nums = [1,3,2,4]
Kimenet: 1
Magyarázat: A tömb számait feloszthatjuk a következőre: nums1 = [1,2] és nums2 = [3,4].
- A nums1 tömb maximális eleme 2.
- A nums2 tömb minimális eleme 3.
A partíció értéke |2 - 3| = 1.
Bizonyítható, hogy 1 a minimális érték az összes partíció közül.

Példa 2:

Bemenet: nums = [100,1,10]
Kimenet: 9
Magyarázat: A tömb számait feloszthatjuk a következőre: nums1 = [10] és nums2 = [100,1].
- A nums1 tömb maximális eleme 10.
- A nums2 tömb minimális eleme 1.
A partíció értéke |10 - 1| = 9.
Bizonyítható, hogy a 9 a minimális érték az összes partíció közül.

Korlátozások:

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

Pozitív egész tömb számokat kap.
A számokat particionáljuk két tömbre, nums1 és nums2 számra úgy, hogy:

A tömb minden eleme vagy a tömbszám1 vagy a tömb nums2 eleméhez tartozik.
Mindkét tömb nem üres.
A partíció értéke minimális.

A partíció értéke: |max(nums1) - min(nums2)|.
Itt a max(nums1) a tömb nums1 maximális elemét, a min(nums2) pedig a tömb nums2 minimális elemét jelöli.
Az ilyen partíció értékét jelölő egész számot adja eredményül.

1. példa:

Bemenet: nums= [1,3,2,4]
Kimenet: 1
Magyarázat: A tömb numjait nums1 = [1,2] és nums2 = [3,4] számokra oszthatjuk.
- A nums1 tömb maximális eleme 2.
- A nums2 tömb minimális eleme 3.
A partíció értéke |2 - 3| = 1.
Bizonyítható, hogy az összes partíció közül 1 a minimális érték.

2. példa:

Bemenet: nums = [100,1,10]
Kimenet: 9
Magyarázat: A tömb numjait nums1 = [10] és nums2 = [100,1] számokra oszthatjuk.
- A nums1 tömb maximális eleme 10.
- A nums2 tömb minimális eleme egyenlő 1-gyel.
A partíció értéke |10 - 1| = 9.
Bizonyítható, hogy a 9 az összes partíció minimális értéke.

Korlátok:

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

Pozitív egész tömb számokat kap.
A számokat particionáljuk két tömbre, nums1 és nums2 számra úgy, hogy:

A tömb minden eleme vagy a tömb nums 1 vagy a tömb nums2 eleméhez tartozik.
Mindkét tömb nem üres.
A partíció értéke minimális.

A partíció értéke: |max(nums1) - min(nums2)|.
Itt a max(nums1) a tömb nums1 maximális elemét, a min(nums2) pedig a tömb nums2 minimális elemét jelöli.
Az ilyen partíció értékét jelölő egész számot adja eredményül.

1. példa:

Bemenet: nums = [1,3,2,4]
Kimenet: 1
Magyarázat: A tömb numjait nums1 = [1,2] és nums2 = [3,4] számokra oszthatjuk.
- A nums1 tömb maximális eleme 2.
- A nums2 tömb minimális eleme 3.
A partíció értéke |2 - 3| = 1.
Bizonyítható, hogy az összes partíció közül 1 a minimális érték.

2. példa:

Bemenet: nums = [100,1,10]
Kimenet: 9
Magyarázat: A tömb numjait nums1 = [10] és nums2 = [100,1] számokra oszthatjuk.
- A nums1 tömb maximális eleme 10.
- A nums2 tömb minimális eleme egyenlő 1-gyel.
A partíció értéke |10 - 1| = 9.
Bizonyítható, hogy a 9 az összes partíció minimális értéke.

Korlátok:

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


Adott egy 0-indexált, különböző karakterláncokból álló words tömb.
A words[i] karakterlánc párosítható a words[j] karakterlánccal, ha:

A words[i] karakterlánc megegyezik a words[j] fordított karakterláncával.
0 <= i < j < words.length.

A words tömbből képezhető párok maximális számát adja vissza.
Vegyük figyelembe, hogy minden karakterlánc legfeljebb egy párba tartozhat.

Példa 1:

Bemenet: words = [„cd”, „ac”, „dc”, „ca”, „zz”]
Kimenet: 2
Magyarázat: Ebben a példában 2 pár karakterláncot képezhetünk a következő módon:
- A 0^. sztringet párosítjuk a 2^. sztringgel, mivel a word[0] fordított sztringje „dc” és megegyezik a words[2]-vel.
- Az 1^. sztringet párosítjuk a 3^. sztringgel, mivel a word[1] fordított sztringje „ca” és egyenlő a words[3]-val.
Bebizonyítható, hogy 2 a maximálisan kialakítható párok száma.
2. példa:

Bemenet: words =["ab","ba","cc"]
Kimenet: 1
Magyarázat: Ebben a példában 1 pár karakterláncot képezhetünk a következő módon:
- A 0^-ik karakterláncot párosítjuk az 1^-ik karakterlánccal, mivel a words[1] fordított karakterlánca „ab”, és megegyezik a words[0]-val.
Bebizonyítható, hogy 1 a maximálisan képezhető párok száma.

3. példa:

Bemenet: words = ["aa","ab"]
Kimenet: 0
Magyarázat: Ebben a példában nem tudunk egyetlen karakterláncpárt sem alkotni.

Korlátozások:

1 <= words.length <= 50
szavak[i].length == 2
A words különböző karakterláncokból áll.
words[i] csak kisbetűs angol betűket tartalmaz.

Kap egy 0-indexelt tömböt, amely különböző szavakból áll. amelyek különböző karakterláncokból állnak.A szavak[i] karakterlánc párosítható a szavak[j] karakterláncsal, ha:

A szavak [i] karakterlánc egyenlő a szavak [j] fordított karakterláncával.
0 <= i < j < szavak.hossz.

Adjuk vissza a szavakból alkotható párok maximális számát."
Minden szó legfeljebb egy párba tartozhat.

1. példa:

Bemenet: words = ["cd","ac","dc","ca","zz"]
Kimenet: 2
Magyarázat: Ebben a példában a következő módon hozhatunk létre 2 karakterláncpárt:
- A 0^. karakterláncot párosítjuk a 2^. karakterlánccal, mivel a word[0] fordított karakterlánca "dc" és egyenlő a szavak[2]
- Az 1^. karakterláncot párosítjuk a 3^. karakterlánccal, mivel a szó[1] fordított karakterlánca "ca" és egyenlő a szavakkal[3].
Bizonyítható, hogy 2 a maximálisan kialakítható párok száma.
2. példa:

Bemenet: words = ["ab","ba","cc"]
Kimenet: 1
Magyarázat: Ebben a példában a következő módon hozhatunk létre 1 pár karakterláncot:
- A 0^. karakterláncot párosítjuk az 1^. karakterlánccal, mivel a szavak fordított karakterlánca[1] "ab" és egyenlő a szavakkal[0].
Bizonyítható, hogy 1 a maximálisan kialakítható párok száma.

3. példa:

Bemenet: words = ["aa","ab"]
Kimenet: 0
Magyarázat: Ebben a példában nem tudunk karakterláncpárt létrehozni.

Korlátozások:

1 <= words.length <= 50
words[i].length == 2
A szavak különböző karakterláncokból állnak.
A szavak[i] csak kisbetűket tartalmaz angolul.

Kap egy 0-indexelt tömb, amely különböző karakterláncokból áll.
Az [i] karakterláncok párosíthatók a [j] karakterláncokkal, ha:

A words[i] karakterlánc egyenlő a words[j] karakterlánc fordítottjával.
0 <= i < j < szavak.length.
Adjuk vissza a tömbből kialakítható párok maximális számát.
Vegye figyelembe, hogy minden sztring legfeljebb egy párhoz tartozhat..

1. példa:

Bemenet: words  = ["cd","ac","dc","ca","zz"]
Kimenet: 2
Magyarázat: Ebben a példában 2 karakterláncpárt alkothatunk a következő módon:
- A 0^-adik karakterláncot párosítjuk a 2^. karakterlánccal, mivel a szó[0] fordított karakterlánca "dc", és egyenlő a szavakkal[2].
- Az 1^st karakterláncot párosítjuk a 3^. karakterlánccal, mivel a fordított szósor[1] "ca" és egyenlő a szavakkal[3].
Bizonyítható, hogy 2 a kialakítható párok maximális száma.
2. példa:

Bemenet: words= ["ab","ba","cc"]
Kimenet: 1
Magyarázat: Ebben a példában 1 karakterláncpárt alkothatunk a következő módon:
- A 0^-adik karakterláncot párosítjuk az 1^st karakterlánccal, mivel a fordított szósor[1] "ab", és egyenlő a szavakkal[0].
Bizonyítható, hogy 1 a kialakítható párok maximális száma.

3. példa:

Bemenet: words = ["aa","ab"]
Kimenet: 0
Magyarázat: Ebben a példában nem tudunk karakterláncpárt alkotni.

Korlátok:

1 <= words.length <= 50
words[i] csak kisbetűs angol betűket tartalmaz
A szavak különálló karakterláncokból állnak.
words[i] csak kisbetűs angol betűket tartalmaz.


Adott egy 0-indexált egész szám tömb nums, amely n különböző pozitív egész számot tartalmaz. A nums permutációját akkor nevezzük speciálisnak, ha:

Minden 0 <= i < n - 1 index esetén nums[i] % nums[i+1] == 0 vagy nums[i+1] % nums[i] == 0.

Adja vissza a speciális permutációk teljes számát. Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.

Példa 1:

Bemenet: nums = [2,3,6]
Kimenet: 2
Magyarázat: A [3,6,2] és a [2,6,3] a nums két speciális permutációja.

2. példa:

Bemenet: nums = [1,4,3]
Kimenet: 2
Magyarázat: [3,1,4] és [4,1,3] a nums két speciális permutációja.

Korlátozások:

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

Kap egy 0 indexelt egész tömb számot, amely n különböző pozitív egész számot tartalmaz. A számok permutációját speciálisnak nevezzük, ha:

Minden 0 <= i < n - 1 indexre vagy nums[i] % nums[i+1] == 0 vagy nums[i+1] % nums[i] == 0.

A speciális permutációk teljes számát adja eredményül. Mivel a válasz nagy lehet, adja vissza modulo 10 ^ 9 + 7.

1. példa:

Bemenet: nums = [2,3,6]
Kimenet: 2
Magyarázat: [3,6,2] és [2,6,3] a számok két speciális permutációja.

2. példa:

Bemenet: nums = [1,4,3]
Kimenet: 2
Magyarázat: [3,1,4] és [4,1,3] a számok két speciális permutációja.

Korlátok:

Kap egy 0 indexelt egész tömb számot, amely n különböző pozitív egész számot tartalmaz. A számok permutációját speciálisnak nevezzük, ha:

Minden 0 <= i < n - 1 indexre vagy nums[i] % nums[i+1] == 0 vagy nums[i+1] % nums[i] == 0.

A speciális permutációk teljes számát adja eredményül. Mivel a válasz nagy lehet, adja vissza modulo 10 ^ 9 + 7.

1. példa:

Bemenet: nums = [2,3,6]
Kimenet: 2
Magyarázat: [3,6,2] és [2,6,3] a számok két speciális permutációja.

2. példa:

Bemenet: nums = [1,4,3]
Kimenet: 2
Magyarázat: [3,1,4] és [4,1,3] a számok két speciális permutációja.

Korlátok:

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

Egy 0-indexelt egész tömb számot kap, amely n különböző pozitív egész számot tartalmaz. A számok permutációját speciálisnak nevezzük, ha:

Minden 0 <= i < n - 1 index esetén teljesül, hogy nums[i] % nums[i+1] == 0 vagy nums[i+1] % nums[i] == 0.

A speciális permutációk teljes számát adja vissza. Mivel a válasz nagy lehet, küldje vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [2,3,6]
Kimenet: 2
Magyarázat: [3,6,2] és [2,6,3] a nums két speciális permutációja.

2. példa:

Bemenet: nums = [1,4,3]
Kimenet: 2
Magyarázat: [3,1,4] és [4,1,3] a nums két speciális permutációja.

Korlátozások:

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


Egy n hosszúságú arr 0 indexű egész tömb kiegyensúlyozatlansági számát a sarr = rendezett(arr) indexek számaként határozzuk meg, így:

0 <= i < n - 1, és
sarr[i+1] - sarr[i] > 1

Itt a sorted(arr) az a függvény, amely az arr rendezett változatát adja vissza.
Adott egy 0-indexelt egész tömb száma, adja vissza az összes altömb kiegyensúlyozatlansági számainak összegét.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [2,3,1,4]
Kimenet: 3
Magyarázat: 3 altömb van, amelyekben az egyensúlyhiány nem nulla:
- Alrendszer [3, 1] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 1, 4] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 4] 1-es kiegyensúlyozatlansági számmal.
Az összes többi altömb kiegyensúlyozatlansági száma 0. Ezért a számok összes altömbjének kiegyensúlyozatlansági számainak összege 3.

2. példa:

Bemenet: nums = [1,3,3,3,5]
Kimenet: 8
Magyarázat: 7 altömb van, amelyekben az egyensúlyhiány nem nulla:
- Alrendszer [1, 3] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 3, 3] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 3, 3, 3] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 3, 3, 3, 5] 2-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 3, 3, 5] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 3, 5] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 5] 1-es kiegyensúlyozatlansági számmal.
Az összes többi altömb kiegyensúlyozatlansági száma 0. Ezért a számok összes altömbjének kiegyensúlyozatlansági számainak összege 8.

Korlátozások:

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

Egy n hosszúságú arr 0 indexű egész tömb kiegyensúlyozatlansági számát a sarr = rendezett(arr) indexek számaként határozzuk meg, így:

0 <= i < n - 1, és
sarr[i+1] - sarr[i] > 1

Itt a sorted(arr) az a függvény, amely az arr rendezett változatát adja vissza.
Adott egy 0-indexelt egész tömb száma, adja vissza az összes altömb kiegyensúlyozatlansági számainak összegét.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: számok = [2,3,1,4]
Kimenet: 3
Magyarázat: 3 altömb rendelkezik nullától eltérő egyensúlyi számokkal:
- Alrendszer [3, 1] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 1, 4] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 4] 1-es kiegyensúlyozatlansági számmal.
Az összes többi altömb kiegyensúlyozatlansági száma 0. Ezért a számok összes altömbjének kiegyensúlyozatlansági számainak összege 3.

2. példa:

Bemenet: számok = [1,3,3,3,5]
Kimenet: 8
Magyarázat: 7 altömb van, amelyekben az egyensúlyhiány nem nulla:
- Alrendszer [1, 3] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 3, 3] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 3, 3, 3] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [1, 3, 3, 3, 5] 2-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 3, 3, 5] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 3, 5] 1-es kiegyensúlyozatlansági számmal.
- Alrendszer [3, 5] 1-es kiegyensúlyozatlansági számmal.
Az összes többi altömb kiegyensúlyozatlansági száma 0. Ezért a számok összes altömbjének kiegyensúlyozatlansági számainak összege 8.

Korlátozások:

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

Egy n hosszúságú 0-indexelt egész tömb arr kiegyensúlyozatlansági száma a sarr = sorted(arr) indexek számaként definiálható úgy, hogy:

0 < = i < n - 1, és
Sarr[i+1] - Sarr[i] 1>

Itt a sorted(arr) az a függvény, amely az arr rendezett verzióját adja vissza.
Adott egy 0 indexelt egész tömb nums, adja vissza az összes résztömbje egyensúlyhiányának összegét.
A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [2,3,1,4]
Kimenet: 3
Magyarázat: 3 olyan altömb van, amelynek nem nulla kiegyensúlyozatlansági száma van:
- [3, 1] résztömb 1-es kiegyensúlyozatlansági számmal.
- [3, 1, 4] résztömb 1-es kiegyensúlyozatlansági számmal.
- [1, 4] résztömb 1-es kiegyensúlyozatlansági számmal.
Az összes többi résztömb kiegyensúlyozatlansági száma 0. Ezért a numok összes résztömbjének egyensúlyhiányi számainak összege 3.

2. példa:

Bemenet: nums = [1,3,3,3,5]
Kimenet: 8
Magyarázat: 7 olyan altömb van, amelynek nem nulla kiegyensúlyozatlansági száma van:
- [1, 3] résztömb 1-es kiegyensúlyozatlansági számmal.
- [1, 3, 3] résztömb 1-es kiegyensúlyozatlansági számmal.
- [1, 3, 3, 3] résztömb 1-es kiegyensúlyozatlansági számmal.
- [1, 3, 3, 3, 5] résztömb 2-es kiegyensúlyozatlansági számmal.
- Subarray [3, 3, 3, 5] 1-es kiegyensúlyozatlansági számmal.
- [3, 3, 5] résztömb 1-es kiegyensúlyozatlansági számmal.
- [3, 5] résztömb 1-es kiegyensúlyozatlansági számmal.
Az összes többi résztömb kiegyensúlyozatlansági száma 0. Ezért a numok összes résztömbjének kiegyensúlyozatlansági számainak összege 8.

Korlátok:

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


Három x, y és z egész számot kapsz.
Van x karakterlánca "AA", y karakterlánca "BB" és z karakterlánca "AB". Ki akar választani néhányat (esetleg az összeset vagy egyiket sem), és valamilyen módon összefűzi őket, hogy új karakterláncot hozzon létre. Ez az új karakterlánc nem tartalmazhat "AAA" vagy "BBB" karakterláncot.
Az új karakterlánc maximális lehetséges hosszát adja vissza.
A részkarakterlánc a karakterláncon belüli, egymást követő, nem üres karaktersorozat.

1. példa:

Bemenet: x = 2, y = 5, z = 1
Kimenet: 12
Magyarázat: A "BB", "AA", "BB", "AA", "BB" és "AB" karakterláncokat ebben a sorrendben kapcsolhatjuk össze. Ezután az új karakterláncunk a "BBAABBAABBAB".
Ennek a karakterláncnak a hossza 12, és megmutathatjuk, hogy lehetetlen hosszabb hosszúságú karakterláncot létrehozni.

2. példa:

Bemenet: x = 3, y = 2, z = 2
Kimenet: 14
Magyarázat: Az "AB", "AB", "AA", "BB", "AA", "BB" és "AA" karakterláncokat ebben a sorrendben összekapcsolhatjuk. Ezután az új karakterláncunk az "ABABAABBAABBAA".
Ennek a karakterláncnak a hossza 14, és megmutathatjuk, hogy lehetetlen hosszabb hosszúságú karakterláncot létrehozni.

Korlátozások:

1 <= x, y, z <= 50

Adott három egész szám x, y és z.
Az x karakterláncok egyenlőek „AA”-val, az y karakterláncok egyenlőek „BB”-vel, a z karakterláncok egyenlőek „AB”-vel. Ki akarsz választani néhányat (esetleg az összeset vagy egyiket sem) ezek közül a karakterláncok közül, és valamilyen sorrendben összekapcsolni őket, hogy egy új karakterláncot alkosson. Ez az új karakterlánc nem tartalmazhat „AAA” vagy „BBB” részláncot.
Adja vissza az új karakterlánc maximális lehetséges hosszát.
A részlánc a karakterek egybefüggő, nem üres sorozata egy karakterláncon belül.

1. példa:

Bemenet: x = 2, y = 5, z = 1
Kimenet: 12
Magyarázat: A „BB”, „AA”, „BB”, „AA”, „BB”, „BB” és „AB” karakterláncokat ebben a sorrendben konkaktálhatjuk. Ekkor az új karakterláncunk „BBAABBAABBAB” lesz.
Ez a karakterlánc 12 hosszú, és megmutathatjuk, hogy ennél hosszabb karakterláncot nem lehet konstruálni.

2. példa:

Bemenet: x = 3, y = 2, z = 2
Kimenet: 14
Magyarázat: Az "AB", "AB", "AA", "BB", "AA", "BB" és "AA" karakterláncokat ebben a sorrendben illeszthetjük össze. Ezután az új karakterláncunk "ABABAABBAABBAA".
Ennek a karakterláncnak a hossza 14, és megmutathatjuk, hogy ennél hosszabb karakterláncot nem lehet konstruálni.

Korlátozások:

1 <= x, y, z <= 50

Három x, y és z egész számot kapsz.
Van x karakterlánca, amely egyenlő "AA", y karakterlánca "BB", és z karakterlánca egyenlő "AB". Ki akar választani néhányat (esetleg az összeset vagy egyiket sem), és valamilyen módon összefűzi őket, hogy új karakterláncot hozzon létre. Ez az új karakterlánc nem tartalmazhat "AAA" vagy "BBB" karakterláncot.
Az új karakterlánc maximális lehetséges hosszát adja vissza.
A részkarakterlánc a karakterláncon belüli, egymást követő, nem üres karaktersorozat.

Példa 1:

Bemenet: x = 2, y = 5, z = 1
Kimenet: 12
Magyarázat: A "BB", "AA", "BB", "AA", "BB" és "AB" karakterláncokat ebben a sorrendben kapcsolhatjuk össze. Ezután az új karakterláncunk a "BBAABBAABBAB".
Ennek a karakterláncnak a hossza 12, és megmutathatjuk, hogy lehetetlen hosszabb hosszúságú karakterláncot létrehozni.

Példa 2:

Bemenet: x = 3, y = 2, z = 2
Kimenet: 14
Magyarázat: Az "AB", "AB", "AA", "BB", "AA", "BB" és "AA" karakterláncokat ebben a sorrendben összekapcsolhatjuk. Ezután az új karakterláncunk az "ABABAABBAABBAA".
Ennek a karakterláncnak a hossza 14, és megmutathatjuk, hogy lehetetlen hosszabb hosszúságú karakterláncot létrehozni.

Korlátozások:

1 <= x, y, z <= 50


Kapsz egy 0-indexelt tömböt, amely n karakterláncot tartalmaz.
Határozzuk meg a join(x, y) összekapcsolási műveletet két x és y karakterlánc között, amelyek összefűzik őket xy-be. Ha azonban az x utolsó karaktere megegyezik y első karakterével, akkor az egyik törlődik.
Például join("ab", "ba") = "aba" és join("ab", "cde") = "abcde".
n - 1 összekapcsolási műveletet kell végrehajtania. Legyen str_0 = szavak[0]. Az i = 1-től kezdve egészen az i = n - 1-ig az i^edik művelethez a következők egyikét teheti:

Legyen str_i = join(str_i - 1, szavak[i])
Legyen str_i = join(szavak[i], str_i - 1)

Az Ön feladata az str_n - 1 hosszának minimalizálása.
Egy egész számot ad vissza, amely az str_n - 1 minimális lehetséges hosszát jelöli.

1. példa:

Bemenet: szavak = ["aa", "ab", "bc"]
Kimenet: 4
Magyarázat: Ebben a példában az összekapcsolási műveleteket a következő sorrendben hajthatjuk végre az str_2 hosszának minimalizálása érdekében:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Megmutatható, hogy az str_2 minimális lehetséges hossza 4.
2. példa:

Bemenet: szavak = ["ab","b"]
Kimenet: 2
Magyarázat: Ebben a példában az str_0 = "ab" kétféleképpen kaphatja meg az str_1-et:
join(str_0, "b") = "ab" vagy join("b", str_0) = "bab".
Az első karakterlánc, az "ab", a minimális hosszúságú. Ezért a válasz a 2.

3. példa:

Bemenet: szavak = ["aaa","c", "aba"]
Kimenet: 6
Magyarázat: Ebben a példában az összekapcsolási műveleteket a következő sorrendben hajthatjuk végre az str_2 hosszának minimalizálása érdekében:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Megmutatható, hogy az str_2 minimális lehetséges hossza 6.

Korlátozások:

1 <= szó.hossz <= 1000
1 <= szó[i].hossz <= 50
A szavakban [i] minden karakter angol kisbetű

Adott egy 0-indexált words tömb, amely n karakterláncot tartalmaz.
Definiáljunk egy join(x, y) műveletet join(x, y) két x és y karakterlánc között úgy, mint amelyek összekapcsolódnak xy-ba. Ha azonban az x utolsó karaktere megegyezik az y első karakterével, akkor az egyiket töröljük.
Például join(„ab”, „ba”) = „aba” és join(„ab”, „cde”) = „abcde”.
N - 1 join műveletet kell végrehajtani. Legyen str_0 = words[0]. Az i = 1-től kezdve i = n - 1-ig, az i^-edik műveletnél a következők valamelyikét végezhetjük:

Legyen str_i = join(str_i - 1, words[i])
Legyen str_i = join(words[i], str_i - 1)

A feladatunk az, hogy minimalizáljuk str_n - 1 hosszát.
Adjon vissza egy egész számot, amely a str_n - 1 lehetséges legkisebb hosszát jelöli.

Példa 1:

Bemenet: words = ["aa","ab","bc"]
Kimenet: 4
Magyarázat: Ebben a példában a következő sorrendben végezhetünk join műveleteket, hogy minimalizáljuk a str_2 hosszát:
str_0 = „aa”
str_1 = join(str_0, „ab”) = „aab”
str_2 = join(str_1, „bc”) = „aabc”
Megmutatható, hogy a str_2 lehetséges legkisebb hossza 4.
2. példa:

Bemenet: words = ["ab","b"]
Kimenet: 2
Magyarázat: Ebben a példában str_0 = „ab”, str_1 kétféleképpen kapható:
join(str_0, "b") = "ab" or join("b", str_0) = "bab".
Az első, „ab” karakterláncnak van a minimális hossza. A válasz tehát 2.

Példa 3:

Bemenet: words = ["aaa","c","aba"]
Kimenet: 6
Magyarázat: Ebben a példában a következő sorrendben végezhetünk join műveleteket, hogy minimalizáljuk a str_2 hosszát:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Megmutatható, hogy a str_2 lehetséges legkisebb hossza 6.

Korlátozások:

1 <= words.length <= 1000
1 <= words[i].length <= 50
A words[i] minden karaktere egy angol kisbetű.

Kapsz egy 0-indexelt tömböt, amely n karakterláncot tartalmaz.
Határozzuk meg a join(x, y) összekapcsolási műveletet két x és y karakterlánc között, amelyek összefűzik őket xy-be. Ha azonban az x utolsó karaktere megegyezik y első karakterével, akkor az egyik törlődik.
Például join("ab", "ba") = "aba" és join("ab", "cde") = "abcde".
n - 1 összekapcsolási műveletet kell végrehajtania. Legyen str_0 = words[0]. Az i = 1-től kezdve egészen az i = n - 1-ig az i^. művelethez a következők egyikét teheti:

Legyen str_i = join(str_i - 1, words[i])
Legyen str_i =join(words[i], str_i - 1)

Az Ön feladata az str_n - 1 hosszának minimalizálása.
Egy egész számot ad vissza, amely az str_n - 1 minimális lehetséges hosszát jelöli.

1. példa:

Bemenet: words = ["aa", "ab", "bc"]
Kimenet: 4
Magyarázat: Ebben a példában az összekapcsolási műveleteket a következő sorrendben hajthatjuk végre az str_2 hosszának minimalizálása érdekében:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Megmutatható, hogy az str_2 minimális lehetséges hossza 4.
2. példa:

Bemenet: words = ["ab","b"]
Kimenet: 2
Magyarázat: Ebben a példában az str_0 = "ab" kétféleképpen kaphatja meg az str_1-et:
join(str_0, "b") = "ab" vagy join("b", str_0) = "bab".
Az első karakterlánc, az "ab", a minimális hosszúságú. Ezért a válasz a 2.

3. példa:

Bemenet: words = ["aaa","c", "aba"]
Kimenet: 6
Magyarázat: Ebben a példában az összekapcsolási műveleteket a következő sorrendben hajthatjuk végre az str_2 hosszának minimalizálása érdekében:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Megmutatható, hogy az str_2 minimális lehetséges hossza 6.

Korlátozások:

1 <= words.length <= 1000
1 <= words[i].length <= 50
A szavakban [i] minden karakter egy angol kisbetű