Kapsz egy 0 indexű, n * n méretű 2D egész mátrix rácsot [1, n^2] tartományban lévő értékekkel. Minden egész pontosan egyszer jelenik meg, kivéve az a-t, amely kétszer jelenik meg, és a b-t, amely hiányzik. A feladat az ismétlődő és hiányzó a és b számok megkeresése.
Egy 0-indexelt ans egész tömböt ad vissza, amelynek mérete 2, ahol ans[0] egyenlő a-val és ans[1] egyenlő b-vel.

1. példa:

Bemenet: grid = [[1,3], [2,2]]
Kimenet: [2,4]
Magyarázat: A 2-es szám ismétlődik és a 4-es hiányzik, így a válasz [2,4].

2. példa:

Bemenet: grid = [[9,1,7], [8,9,2], [3,4,6]]
Kimenet: [9,5]
Magyarázat: A 9-es szám ismétlődik, és az 5-ös hiányzik, így a válasz [9,5].

Korlátozások:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Minden x-re, amely 1 <= x <= n * n, pontosan egy x nem egyenlő a rács egyik tagjával.
Minden x-re, amely 1 <= x <= n * n, pontosan egy x van, amely pontosan két rácstaggal egyenlő.
Minden x-re, amely 1 <= x <= n * n, kettő kivételével, pontosan egy i, j pár van, amely 0 <= i, j <= n - 1 és grid[i][j] == x.

Adott egy n * n méretű 0-indexelt 2D egész szám mátrix, amelynek értékei az [1, n^2] tartományban vannak. Minden egész szám pontosan egyszer jelenik meg, kivéve a, amely kétszer jelenik meg, és b, amely hiányzik. A feladat az ismétlődő és hiányzó a és b számok megtalálása.
Egy 0-indexelt, 2 elemű egész szám tömböt ad vissza, ahol ans[0] egyenlő a-val, ans[1] pedig b-vel, ahol ans[0] egyenlő a-val, ans[1] pedig b-vel.

1. példa:

Bemenet: grid = [[1,3],[2,2]]
Kimenet: [2,4]
Magyarázat: A 2-es szám ismétlődik, a 4-es pedig hiányzik, így a válasz [2,4].

2. példa:

Bemenet: grid = [[9,1,7],[8,9,2],[3,4,6]]
Kimenet: [9,5]
Magyarázat: A 9-es szám ismétlődik, az 5-ös pedig hiányzik, így a válasz [9,5].

Korlátok:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Minden x-re, hogy 1 <= x <= n * n pontosan egy x van, amely nem egyenlő a rács egyik tagjával sem.
Minden x-re, hogy 1 <= x <= n * n, pontosan egy x van, amely pontosan két rácstaggal egyenlő.
Minden x-re, hogy 1 <= x <= n * n, kettő kivételével, pontosan van egy pár i, j, hogy 0 <= i, j <= n - 1 és grid[i][j] == x.

Kapsz egy 0 indexű, n * n méretű 2D egész mátrix rácsot, amelynek értékei az [1, n^2] tartományba esnek. Minden egész pontosan egyszer jelenik meg, kivéve az a-t, amely kétszer jelenik meg, és a b-t, amely hiányzik. A feladat az ismétlődő és hiányzó a és b számok megkeresése.
Egy 2-es méretű ans 0 indexű egész tömböt ad vissza, ahol ans[0] egyenlő a-val és ans[1] b-vel.

Példa 1:

Bemenet: grid = [[1,3],[2,2]]
Kimenet: [2,4]
Magyarázat: A 2-es szám ismétlődik és a 4-es hiányzik, így a válasz [2,4].

Példa 2:

Bemenet: grid = [[9,1,7],[8,9,2],[3,4,6]]
Kimenet: [9,5]
Magyarázat: A 9-es szám ismétlődik, és az 5-ös hiányzik, így a válasz [9,5].

Megkötések:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Minden x-re, amely 1 <= x <= n * n, pontosan egy x nem egyenlő a rács egyik tagjával.
Minden x-re, amely 1 <= x <= n * n, pontosan egy x van, amely pontosan két rácstaggal egyenlő.
Minden x-re, amely 1 <= x <= n * n, kettő kivételével, pontosan egy i, j pár van, amely 0 <= i, j <= n - 1 és grid[i][j] == x.


Két 0 indexelt egész tömböt kap, nums1 és nums2 páros hosszúságú n.
El kell távolítania n / 2 elemet a nums1-ből és n / 2 elemet a nums2-ből. Az eltávolítások után beilleszti a nums1 és nums2 fennmaradó elemeit egy s halmazba.
Adja vissza az s halmaz maximális lehetséges méretét.

1. példa:

Bemenet: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Kimenet: 2
Magyarázat: Az 1 két előfordulását eltávolítjuk a nums1 és nums2 számokból. Az eltávolítások után a tömbök szám1 = [2,2] és nums2 = [1,1] egyenlővé válnak. Ezért s = {1,2}.
Kimutatható, hogy 2 az eltávolítások után a készlet maximális lehetséges mérete.

2. példa:

Bemenet: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Kimenet: 5
Magyarázat: Eltávolítjuk a 2, 3 és 6 számokat a nums1-ből, valamint a 2-t és a 3 két előfordulását a nums2-ből. Az eltávolítások után a tömbök szám1 = [1,4,5] és nums2 = [2,3,2] egyenlővé válnak. Ezért s = {1,2,3,4,5}.
Kimutatható, hogy 5 a készlet maximális lehetséges mérete az eltávolítások után.

3. példa:

Bemenet: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Kimenet: 6
Magyarázat: Eltávolítjuk az 1-et, 2-t és 3-at a nums1-ből, valamint a 4-et, 5-öt és 6-ot a nums2-ből. Az eltávolítások után a tömbök szám1 = [1,2,3] és nums2 = [4,5,6] számokkal egyenlővé válnak. Ezért s = {1,2,3,4,5,6}.
Kimutatható, hogy 6 a készletek maximális lehetséges mérete az eltávolítások után.

Korlátok:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n páros.
1 <= nums1[i], nums2[i] <= 10^9

Kap két 0-indexelt egész tömböt, nums1 és nums2 páros hosszúságú n.
El kell távolítania n/2 elemet a nums1-ből és n/2 elemet a nums2-ből. Az eltávolítások után a nums1 és nums2 fennmaradó elemeit beilleszti egy s halmazba.
Adja vissza az s halmaz maximális lehetséges méretét.

1. példa:

Bemenet: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Kimenet: 2
Magyarázat: Az 1 két előfordulását eltávolítjuk a nums1 és nums2 számokból. Az eltávolítások után a tömbök nums1 = [2,2] és nums2 = [1,1] egyenlővé válnak. Ezért s = {1,2}.
Kimutatható, hogy 2 a halmaz maximális lehetséges mérete az eltávolítások után.

2. példa:

Bemenet: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Kimenet: 5
Magyarázat: Eltávolítjuk a 2, 3 és 6 számokat a nums1-ből, valamint a 2-t és a 3 két előfordulását a nums2-ből. Az eltávolítások után a tömbök nums1 = [1,4,5] és nums2 = [2,3,2] egyenlővé válnak. Ezért s = {1,2,3,4,5}.
Kimutatható, hogy 5 a halmaz maximális lehetséges mérete az eltávolítások után.

3. példa:

Bemenet: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Kimenet: 6
Magyarázat: Eltávolítjuk az 1-et, 2-t és 3-at a nums1-ből, valamint a 4-et, 5-öt és 6-ot a nums2-ből. Az eltávolítások után a tömbök nums1 = [1,2,3] és nums2 = [4,5,6] számokkal egyenlővé válnak. Ezért s = {1,2,3,4,5,6}.
Kimutatható, hogy 6 a készletek maximális lehetséges mérete az eltávolítások után.

Korlátok:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n páros.
1 <= nums1[i], nums2[i] <= 10^9

Kapunk két 0-indexelt egész tömböt, szám1 és szám2 páros n hosszúságot.
El kell távolítania n/2 elemet a nums1-ből és n/2 elemet a nums2-ből. Az eltávolítások után a nums1 és nums2 fennmaradó elemeit beilleszted egy s halmazba.
Az s halmaz legnagyobb lehetséges méretét adja vissza.

példa 1:

Bemenet: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Kimenet: 2
Magyarázat: Eltávolítjuk az 1 két előfordulását a szám1 és a szám2 számokból. Az eltávolítások után a tömbök nums1 = [2,2] és nums2 = [1,1] értékkel egyenlőek. Ezért s = {1,2}.
Megmutatható, hogy 2 az s halmaz legnagyobb lehetséges mérete az eltávolítások után.

példa 2:

Bemenet: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Kimenet: 5
Magyarázat: Eltávolítjuk a 2, 3 és 6-ot a nums1-ből, valamint a 3-as 2-es és két előfordulását a nums2-ből. Az eltávolítások után a tömbök nums1 = [1,4,5] és nums2 = [2,3,2] értékkel egyenlőek. Ezért s = {1,2,3,4,5}.
Megmutatható, hogy 5 az s halmaz legnagyobb lehetséges mérete az eltávolítások után.

példa 3:

Bemenet: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Kimenet: 6
Magyarázat: Eltávolítjuk az 1-et, a 2-t és a 3-at a szám1-ből, valamint a 4-et, az 5-öt és a 6-ot a szám2-ból. Az eltávolítások után a tömbök nums1 = [1,2,3] és nums2 = [4,5,6] értékkel egyenlőek. Ezért s = {1,2,3,4,5,6}.
Megmutatható, hogy az eltávolítások után 6 a halmaz lehetséges legnagyobb mérete.

Korlátozások:

n == nums1.length == nums2.hossz
1 <= n <= 2 * 10^4
n páros.
1 <= nums1[i], nums2[i] <= 10^9


Adott egy n hosszúságú 0-indexált egész számokat tartalmazó tömb, melynek neve nums.
Bármennyi speciális lépést megtehetsz (beleértve a nullát is) a nums tömbön. Egy speciális lépés során a következő lépéseket hajtod végre sorrendben:

Válassz egy i indexet a [0, n - 1] tartományból, és egy pozitív x egész számot.
Add hozzá az összköltséghez |nums[i] - x| értéket.
Változtasd meg a nums[i] értékét x-re.

Egy palindrom szám olyan pozitív egész szám, amelynek számjegyei megfordítva ugyanazt a számot adják. Például 121, 2552 és 65756 palindrom számok, míg 24, 46, 235 nem azok.
Egy tömb akkor tekinthető egyenlőindromikusnak, ha a tömb összes eleme megegyezik egy y egész számmal, ahol y egy palindrom szám, amely kisebb, mint 10^9.
Adjon vissza egy egész számot, ami a nums-t egyenlőindromikussá tevő speciális lépések minimális összköltségét jelzi.

Példa 1:

Bemenet: nums = [1,2,3,4,5]
Kimenet: 6
Magyarázat: Az egyenlőindromikus tömb eléréséhez megváltoztathatjuk az összes elemet 3-ra, ami egy palindrom szám. A tömb [3,3,3,3,3] állapotra való változtatásának költsége 4 speciális lépést használva |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Kimutatható, hogy az összes elemet bármely más palindrom számra való változtatása, mint a 3, nem érhető el alacsonyabb költséggel.

Példa 2:

Bemenet: nums = [10,12,13,14,15]
Kimenet: 11
Magyarázat: Az egyenlőindromikus tömb eléréséhez megváltoztathatjuk az összes elemet 11-re, ami egy palindrom szám. A tömb [11,11,11,11,11] állapotra való változtatásának költsége 5 speciális lépést használva |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Kimutatható, hogy az összes elemet bármely más palindrom számra való változtatása, mint a 11, nem érhető el alacsonyabb költséggel.

Példa 3:

Bemenet: nums = [22,33,22,33,22]
Kimenet: 22
Magyarázat: Az egyenlőindromikus tömb eléréséhez megváltoztathatjuk az összes elemet 22-re, ami egy palindrom szám. A tömb [22,22,22,22,22] állapotra való változtatásának költsége 2 speciális lépést használva |33 - 22| + |33 - 22| = 22.
Kimutatható, hogy az összes elemet bármely más palindrom számra való változtatása, mint a 22, nem érhető el alacsonyabb költséggel.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számokat, amelyek hossza n.
Különleges mozdulatot tetszőleges számú alkalommal (beleértve a nullát is) hajthat végre a számokon. Egy speciális lépésben a következő lépéseket hajtja végre sorrendben:

Válasszon egy i indexet a [0, n - 1] tartományban és egy pozitív egész x számot.
|nums[i] - x| hozzáadása a teljes költséghez.
Módosítsa a nums[i] értékét x-re.

A palindrom szám egy pozitív egész szám, amely ugyanaz marad, ha számjegyeit megfordítják. Például a 121, 2552 és 65756 palindrom számok, míg a 24, 46, 235 nem palindrom számok.
Egy tömb akkor tekinthető egyenlő-indrómnak, ha a tömb összes eleme egyenlő egy y egész számmal, ahol y egy 10^9-nél kisebb palindrom szám.
Egy egész számot ad vissza, amely a lehető legkisebb összköltséget jelöli, hogy a numok egyenlőek legyenek tetszőleges számú speciális lépés végrehajtásával.

1. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: 6
Magyarázat: A tömböt egyenlővé tehetjük, ha az összes elemet 3-ra változtatjuk, ami egy palindrom szám. A tömb [3,3,3,3,3]-ra változtatásának költségét 4 speciális mozdulattal a |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Kimutatható, hogy az összes elem 3-tól eltérő palindrom számra történő megváltoztatása nem érhető el alacsonyabb költséggel.

2. példa:

Bemenet: nums = [10,12,13,14,15]
Kimenet: 11
Magyarázat: A tömböt egyenlővé tehetjük, ha minden elemet 11-re változtatunk, ami egy palindrom szám. A tömb [11,11,11,11,11] értékre történő módosításának költségét 5 speciális mozdulattal a |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Kimutatható, hogy az összes elem 11-től eltérő palindromszámra történő megváltoztatása nem érhető el alacsonyabb költséggel.

3. példa:

Bemenet: nums = [22,33,22,33,22]
Kimenet: 22
Magyarázat: A tömböt egyenlővé tehetjük, ha az összes elemet 22-re változtatjuk, ami egy palindrom szám. A tömb [22,22,22,22,22] értékre változtatásának költségét 2 speciális mozdulattal a |33 - 22| + |33 - 22| = 22.
Kimutatható, hogy az összes elem 22-től eltérő palindromszámra történő megváltoztatása nem érhető el alacsonyabb költséggel.

Korlátok:

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

Adott egy n hosszúságú 0-indexelt egész számokat tartalmazó tömb, melynek neve nums.
Bármennyi speciális lépést megtehetsz (beleértve a nullát is) a nums tömbön. Egy speciális lépés során a következő lépéseket hajtod végre sorrendben:

Válassz egy i indexet a [0, n - 1] tartományból, és egy pozitív x egész számot.
Add hozzá az összköltséghez |nums[i] - x| értéket.
Változtasd meg a nums[i] értékét x-re.

Egy palindrom szám olyan pozitív egész szám, amelynek számjegyei megfordítva ugyanazt a számot adják. Például 121, 2552 és 65756 palindrom számok, míg 24, 46, 235 nem azok.
Egy tömb akkor tekinthető egyenlőindromikusnak, ha a tömb összes eleme megegyezik egy y egész számmal, ahol y egy palindrom szám, amely kisebb, mint 10^9.
Adjon vissza egy egész számot, ami a nums-t egyenlőindromikussá tevő speciális lépések minimális összköltségét jelzi.

Példa 1:

Input: nums = [1,2,3,4,5]
Output: 6
Magyarázat: Az egyenlőindromikus tömb eléréséhez megváltoztathatjuk az összes elemet 3-ra, ami egy palindrom szám. A tömb [3,3,3,3,3] állapotra való változtatásának költsége 4 speciális lépést használva |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Kimutatható, hogy az összes elemet bármely más palindrom számra való változtatása, mint a 3, nem érhető el alacsonyabb költséggel.

Példa 2:

Input: nums = [10,12,13,14,15]
Output: 11
Magyarázat: Az egyenlőindromikus tömb eléréséhez megváltoztathatjuk az összes elemet 11-re, ami egy palindrom szám. A tömb [11,11,11,11,11] állapotra való változtatásának költsége 5 speciális lépést használva |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Kimutatható, hogy az összes elemet bármely más palindrom számra való változtatása, mint a 11, nem érhető el alacsonyabb költséggel.

Példa 3:

Input: nums = [22,33,22,33,22]
Output: 22
Magyarázat: Az egyenlőindromikus tömb eléréséhez megváltoztathatjuk az összes elemet 22-re, ami egy palindrom szám. A tömb [22,22,22,22,22] állapotra való változtatásának költsége 2 speciális lépést használva |33 - 22| + |33 - 22| = 22.
Kimutatható, hogy az összes elemet bármely más palindrom számra való változtatása, mint a 22, nem érhető el alacsonyabb költséggel.

Korlátozások:

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


Adott egy 0-indexált karakterlánc szó.
Egy művelet során kiválaszthatsz bármelyik word indexet i, és megváltoztathatod word[i]-t bármely kisbetűs angol betűre.
Add vissza a minimális műveletek számát, amely szükséges az összes szomszédos majdnem-egyenlő karakter eltávolításához a word-ből.
Két karakter a és b majdnem-egyenlő, ha a == b vagy a és b szomszédosak az ábécében.

Példa 1:

Bemenet: word = "aaaaa"
Kimenet: 2
Magyarázat: Megváltoztathatjuk a word-öt "acaca"-ra, amelyben nincs szomszédos majdnem-egyenlő karakter.
Megmutatható, hogy a minimális műveletek száma, amely szükséges az összes szomszédos majdnem-egyenlő karakter eltávolításához a word-ből, 2.

Példa 2:

Bemenet: word = "abddez"
Kimenet: 2
Magyarázat: Megváltoztathatjuk a word-öt "ybdoez"-re, amelyben nincs szomszédos majdnem-egyenlő karakter.
Megmutatható, hogy a minimális műveletek száma, amely szükséges az összes szomszédos majdnem-egyenlő karakter eltávolításához a word-ből, 2.

Példa 3:

Bemenet: word = "zyxyxyz"
Kimenet: 3
Magyarázat: Megváltoztathatjuk a word-öt "zaxaxaz"-ra, amelyben nincs szomszédos majdnem-egyenlő karakter.
Megmutatható, hogy a minimális műveletek száma, amely szükséges az összes szomszédos majdnem-egyenlő karakter eltávolításához a word-ből, 3.

Korlátozások:

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

Kap egy 0-indexelt karakterláncszót.
Egy művelettel kiválaszthatja a szó bármely i indexét, és a word[i] szót bármilyen kisbetűs angol betűre módosíthatja.
Visszaadja az összes szomszédos, majdnem egyenlő karakter eltávolításához szükséges műveletek minimális számát a szóból.
Két a és b karakter majdnem egyenlő, ha a == b vagy a és b szomszédos az ábécében.

1. példa:

Bemenet: word = "aaaaa"
Kimenet: 2
Magyarázat: Megváltoztathatjuk a szót "akác"-ra, amelynek nincsenek szomszédos, majdnem egyenlő karakterei.
Megmutatható, hogy az összes szomszédos, majdnem egyenlő karakter eltávolításához szükséges műveletek minimális száma 2.

2. példa:

Bemenet: word = "abddez"
Kimenet: 2
Magyarázat: Megváltoztathatjuk a szót "ybdoez"-re, amelynek nincsenek szomszédos, majdnem egyenlő karakterei.
Megmutatható, hogy az összes szomszédos, majdnem egyenlő karakter eltávolításához szükséges műveletek minimális száma 2.
3. példa:

Bemenet: word = "zyxyxyz"
Kimenet: 3
Magyarázat: Megváltoztathatjuk a szót "zaxaxaz"-ra, amelynek nincsenek szomszédos, majdnem egyenlő karakterei.
Megmutatható, hogy az összes szomszédos, majdnem egyenlő karakter eltávolításához szükséges műveletek minimális száma 3.

Korlátok:

1 <= word.length <= 100
szó csak kisbetűs angol betűkből áll.

Kapsz egy 0 indexű karakterlánc szót.
Egy műveletben kiválaszthatja a szó tetszőleges i indexét, és a szót [i] bármilyen kisbetűre módosíthatja.
Adja vissza a minimális számú műveletet ahhoz, hogy eltávolítsa az összes szomszédos majdnem egyenlő karaktert a Wordből.
Két a és b karakter majdnem egyenlő, ha a == b vagy a és b szomszédos az ábécében.

1. példa:

Bemenet: word = "aaaaa"
Kimenet: 2
Magyarázat: A szót "acaca"-ra változtathatjuk, amely nem tartalmaz közel azonos karaktereket.
Megmutatható, hogy a szóból az összes szomszédos majdnem egyenlő karakter eltávolításához szükséges műveletek minimális száma 2.

2. példa:

Bemenet: word = "abddez"
Kimenet: 2
Magyarázat: A szót "ybdoez"-re változtathatjuk, amely nem tartalmaz közel azonos karaktereket.
Megmutatható, hogy a szóból az összes szomszédos majdnem egyenlő karakter eltávolításához szükséges műveletek minimális száma 2.
3. példa:

Bemenet: word = "zyxyxyz"
Kimenet: 3
Magyarázat: A szót "zaxaxaz"-ra változtathatjuk, amely nem tartalmaz közel azonos karaktereket.
Megmutatható, hogy a szóból az összes szomszédos, majdnem egyenlő karakter eltávolításához szükséges műveletek minimális száma 3.

Korlátozások:

1 <= word.length <= 100
szó csak kisbetűs angol betűkből áll.


Kapsz egy 0-indexelt egész tömb érméket, amelyek a rendelkezésre álló érmék értékeit képviselik, és egy egész célt.
Egy x egész szám akkor érhető el, ha létezik olyan érmék részsorozata, amelynek összege x.
Adja vissza a tömbhöz hozzáadandó érmék minimális számát, hogy az [1, cél] tartományban minden egész szám elérhető legyen.
A tömb egy részsorozata egy új, nem üres tömb, amely az eredeti tömbből úgy jön létre, hogy néhány elemet (esetleg egyiket sem) töröl anélkül, hogy megzavarná a fennmaradó elemek egymáshoz viszonyított helyzetét.

1. példa:

Bemenet: coins = [1,4,10], target = 19
Kimenet: 2
Magyarázat: Hozzá kell adnunk a 2-es és 8-as érmét. Az eredményül kapott tömb [1,2,4,8,10] lesz.
Megmutatható, hogy a kapott tömbből 1-től 19-ig minden egész szám beszerezhető, és hogy 2 az érmék minimális száma, amelyet hozzá kell adni a tömbhöz.

2. példa:

Bemenet: coins = [1,4,10,5,7,19], target = 19
Kimenet: 1
Magyarázat: Csak a 2. érmét kell hozzáadnunk. A kapott tömb a következő lesz: [1,2,4,5,7,10,19].
Megmutatható, hogy a kapott tömbből 1-től 19-ig minden egész szám elérhető, és hogy 1 a minimális érmék száma, amelyet hozzá kell adni a tömbhöz.

3. példa:

Bemenet: coins = [1,1,1], target = 20
Kimenet: 3
Magyarázat: Hozzá kell adnunk a 4-es, 8-as és 16-os érméket. Az eredményül kapott tömb [1,1,1,4,8,16] lesz.
Megmutatható, hogy a kapott tömbből minden 1-től 20-ig terjedő egész szám elérhető, és hogy a 3 a minimális érmék száma, amelyet hozzá kell adni a tömbhöz.

Korlátozások:

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

Adott egy 0-indexált egész szám tömb, a rendelkezésre álló érmék értékét jelképező érmék, valamint egy egész szám célérték.
Egy x egész szám akkor kapható, ha létezik olyan érmék részsorozata, amelynek összege x.
Adja vissza a tömbhöz hozzáadandó bármely értékű érmék minimális számát, hogy a[1, target] tartományban minden egész szám elérhető legyen.
Egy tömb részsorozata egy új, nem üres tömb, amelyet az eredeti tömbből úgy képezünk, hogy néhány elemet (esetleg egyet sem) törölünk anélkül, hogy a megmaradó elemek relatív pozícióját megzavarnánk.

1. példa:

Bemenet: coins = [1,4,10], target = 19
Kimenet: 2
Magyarázat: Az érméket össze kell adnunk a 2-es és a 8-as érmét. Az eredményül kapott tömb [1,2,4,8,10] lesz.
Megmutatható, hogy a kapott tömbből az összes egész szám 1-től 19-ig elérhető, és hogy 2 a legkisebb számú érme, amit hozzá kell adni a tömbhöz.

2. példa:

Bemenet:coins = [1,4,10,5,7,19], target = 19
Kimenet: 1
Magyarázat: A kapott tömb [1,2,4,5,7,10,19] lesz.
Megmutatható, hogy az eredményül kapott tömbből az összes egész szám 1-től 19-ig elérhető, és hogy 1 a minimálisan hozzáadandó érmék száma a tömbhöz.

3. példa:

Bemenet: coins = [1,1,1], target = 20
Kimenet: 3
Magyarázat: Az érméket 4, 8 és 16 érmével kell összeadnunk. Az eredményül kapott tömb [1,1,1,4,8,16]. lesz.
Megmutatható, hogy a kapott tömbből az összes egész szám 1-től 20-ig elérhető, és hogy 3 a minimálisan hozzáadandó érmék száma a tömbhöz.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb érméket, amelyek a rendelkezésre álló érmék értékeit képviselik, és egy egész célt.
Egy x egész szám akkor érhető el, ha létezik olyan érmék részsorozata, amelynek összege x.
Adja vissza a tömbhöz hozzáadandó érmék minimális számát, hogy az [1, cél] tartományban minden egész szám elérhető legyen.
A tömb egy részsorozata egy új, nem üres tömb, amely az eredeti tömbből úgy jön létre, hogy néhány elemet (esetleg egyiket sem) töröl anélkül, hogy megzavarná a fennmaradó elemek egymáshoz viszonyított helyzetét.

Példa 1:

Bemenet: coins = [1,4,10], target = 19
Kimenet: 2
Magyarázat: Hozzá kell adnunk a 2-es és 8-as érmét. Az eredményül kapott tömb [1,2,4,8,10] lesz.
Megmutatható, hogy a kapott tömbből 1-től 19-ig minden egész szám beszerezhető, és hogy 2 az érmék minimális száma, amelyet hozzá kell adni a tömbhöz.

Példa 2:

Bemenet: coins = [1,4,10,5,7,19], target = 19
Kimenet: 1
Magyarázat: Csak a 2. érmét kell hozzáadnunk. A kapott tömb a következő lesz: [1,2,4,5,7,10,19].
Megmutatható, hogy a kapott tömbből 1-től 19-ig minden egész szám elérhető, és hogy 1 a minimális érmék száma, amelyet hozzá kell adni a tömbhöz.

Példa 3:

Bemenet: coins = [1,1,1], target = 20
Kimenet: 3
Magyarázat: Hozzá kell adnunk a 4-es, 8-as és 16-os érméket. Az eredményül kapott tömb [1,1,1,4,8,16] lesz.
Megmutatható, hogy a kapott tömbből minden 1-től 20-ig terjedő egész szám elérhető, és hogy a 3 a minimális érmék száma, amelyet hozzá kell adni a tömbhöz.

Korlátozások:

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


Kapsz egy 0 indexű s karakterláncot és egy k egész számot.
A következő particionálási műveleteket kell végrehajtania, amíg az s ki nem ürül:

Válassza ki az s leghosszabb előtagját, amely legfeljebb k különböző karaktert tartalmazhat.
Törölje az s előtagot, és növelje a partíciók számát eggyel. A fennmaradó karakterek (ha vannak) az s-ben megtartják kezdeti sorrendjüket.

A műveletek előtt legfeljebb egy indexet módosíthat az s-ben egy másik kisbetűs angol betűre.
A műveletek után az eredményül kapott partíciók maximális számát jelölő egész számot adjon vissza úgy, hogy optimálisan legfeljebb egy indexet választ a változtatáshoz.

1. példa:

Bemenet: s = "accca", k = 2
Kimenet: 3
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s[2] 'b'-re módosítható.
s "acbca" lesz.
A műveletek most az alábbiak szerint hajthatók végre, amíg az s ki nem ürül:
- Válassza ki a leghosszabb előtagot, amely legfeljebb 2 különböző karaktert tartalmazhat, „acbca”.
- Törölje az előtagot, és az s "bca" lesz. A partíciók száma most 1.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 2 különböző karaktert tartalmazhat, „bca”.
- Törölje az előtagot, és az s "a" lesz. A partíciók száma most 2.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 2 különböző karaktert tartalmazhat, „a”.
- Törölje az előtagot, és az s üres lesz. A partíciók száma most 3.
Ezért a válasz a 3.
Kimutatható, hogy 3 partíciónál több nem szerezhető be.
2. példa:

Bemenet: s = "aabaab", k = 3
Kimenet: 1
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s-t úgy hagyhatjuk, ahogy van.
A műveletek most az alábbiak szerint hajthatók végre, amíg az s ki nem ürül:
- Válassza ki a leghosszabb előtagot, amely legfeljebb 3 különböző karaktert tartalmazhat, "aabaab".
- Törölje az előtagot, és az s üres lesz. A partíciók száma 1 lesz.
Ezért a válasz az 1.
Kimutatható, hogy nem lehet 1 partíciónál több partíciót szerezni.

3. példa:

Bemenet: s = "xxyz", k = 1
Kimenet: 4
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s[1] 'a'-ra módosítható.
s "xayz" lesz.
A műveletek most az alábbiak szerint hajthatók végre, amíg az s ki nem ürül:
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmaz, „xayz”.
- Törölje az előtagot, és az s "ayz" lesz. A partíciók száma most 1.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmaz, "ayz".
- Törölje az előtagot, és az s "yz" lesz. A partíciók száma most 2.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmaz, "yz".
- Törölje az előtagot, és az s "z" lesz. A partíciók száma most 3.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmazhat ("z").
- Törölje az előtagot, és az s üres lesz. A partíciók száma most 4.
Ezért a válasz a 4.
Kimutatható, hogy 4 partíciónál több nem szerezhető be.

Korlátozások:

1 <= s.length <= 10^4
s csak kisbetűs angol betűkből áll.
1 <= k <= 26

Kapsz egy 0 indexelt s karakterláncot és egy k egész számot.
A következő particionálási műveleteket kell végrehajtania, amíg az s ki nem ürül:

Válassza ki az s leghosszabb előtagját, amely legfeljebb k különböző karaktert tartalmaz.
Törölje az előtagot az s-ből, és növelje a partíciók számát eggyel. Az s többi karaktere (ha van) megtartja kezdeti sorrendjét.

A műveletek előtt legfeljebb egy indexet válthat s-ben egy másik kisbetűs angol betűre.
Egy egész számot ad vissza, amely az eredményül kapott partíciók maximális számát jelöli a műveletek után, optimálisan kiválasztva legfeljebb egy indexet a módosításhoz.

1. példa:

Bemenet: s = "accca", k = 2
Kimenet: 3
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s[2] megváltoztatható 'b'-re.
s "acbca" lesz.
A műveletek most a következőképpen hajthatók végre, amíg s ki nem ürül:
- Válassza ki a leghosszabb, legfeljebb 2 különböző karaktert tartalmazó előtagot, az "acbca" -t.
- Törölje az előtagot, és s lesz "bca". A partíciók száma most 1.
- Válassza ki a leghosszabb, legfeljebb 2 különböző karaktert tartalmazó előtagot, a "bca" -t.
- Törölje az előtagot, és s lesz "a". A partíciók száma most 2.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 2 különböző karaktert tartalmaz, "a".
- Törölje az előtagot, és az s üres lesz. A partíciók száma most 3.
Ezért a válasz 3.
Kimutatható, hogy nem lehet 3-nál több partíciót beszerezni.
2. példa:

Bemenet: s = "aabaab", k = 3
Kimenet: 1
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében meghagyhatjuk az s-t úgy, ahogy van.
A műveletek most a következőképpen hajthatók végre, amíg s ki nem ürül:
- Válassza ki a leghosszabb, legfeljebb 3 különböző karaktert tartalmazó előtagot, az "aabaab" -ot.
- Törölje az előtagot, és az s üres lesz. A partíciók száma 1 lesz.
Ezért a válasz 1.
Kimutatható, hogy nem lehet 1-nél több partíciót beszerezni.

3. példa:

Bemenet: s = "xxyz", k = 1
Kimenet: 4
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s[1] megváltoztatható 'a'-ra.
s lesz "xayz".
A műveletek most a következőképpen hajthatók végre, amíg s ki nem ürül:
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 különböző karaktert tartalmaz, "xayz".
- Törölje az előtagot, és s lesz "ayz". A partíciók száma most 1.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 különböző karaktert tartalmaz, "ayz".
- Törölje az előtagot, és s "yz" lesz. A partíciók száma most 2.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 különböző karaktert tartalmaz, "yz".
- Törölje az előtagot, és s "z" lesz. A partíciók száma most 3.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 különböző karaktert tartalmaz, "z".
- Törölje az előtagot, és az s üres lesz. A partíciók száma most 4.
Ezért a válasz 4.
Kimutatható, hogy nem lehet 4-nél több partíciót beszerezni.

Korlátok:

1 <= s.length <= 10^4
s csak kisbetűs angol betűkből áll.
1 < = k <= 26

Kapsz egy 0 indexű s karakterláncot és egy k egész számot.
A következő particionálási műveleteket kell végrehajtania, amíg az s ki nem ürül:

Válassza ki az s leghosszabb előtagját, amely legfeljebb k különböző karaktert tartalmazhat.
Törölje az s előtagot, és növelje a partíciók számát eggyel. A fennmaradó karakterek (ha vannak) az s-ben megtartják kezdeti sorrendjüket.

A műveletek előtt legfeljebb egy indexet módosíthat az s-ben egy másik kisbetűs angol betűre.
A műveletek után az eredményül kapott partíciók maximális számát jelölő egész számot adjon vissza úgy, hogy optimálisan legfeljebb egy indexet választ a változtatáshoz.

1. példa:

Bemenet: s = "accca", k = 2
Kimenet: 3
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s[2] 'b'-re módosítható.
s "acbca" lesz.
A műveletek most az alábbiak szerint hajthatók végre, amíg az s ki nem ürül:
- Válassza ki a leghosszabb előtagot, amely legfeljebb 2 különböző karaktert tartalmazhat, „acbca”.
- Törölje az előtagot, és az s "bca" lesz. A partíciók száma most 1.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 2 különböző karaktert tartalmazhat, „bca”.
- Törölje az előtagot, és az s "a" lesz. A partíciók száma most 2.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 2 különböző karaktert tartalmazhat, „a”.
- Törölje az előtagot, és az s üres lesz. A partíciók száma most 3.
Ezért a válasz a 3.
Kimutatható, hogy 3 partíciónál több nem szerezhető be.
2. példa:

Bemenet: s = "aabaab", k = 3
Kimenet: 1
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s-t úgy hagyhatjuk, ahogy van.
A műveletek most az alábbiak szerint hajthatók végre, amíg az s ki nem ürül:
- Válassza ki a leghosszabb előtagot, amely legfeljebb 3 különböző karaktert tartalmazhat, "aabaab".
- Törölje az előtagot, és az s üres lesz. A partíciók száma 1 lesz.
Ezért a válasz az 1.
Kimutatható, hogy nem lehet 1 partíciónál több partíciót szerezni.

3. példa:

Bemenet: s = "xxyz", k = 1
Kimenet: 4
Magyarázat: Ebben a példában az eredményül kapott partíciók számának maximalizálása érdekében az s[1] 'a'-ra módosítható.
s "xayz" lesz.
A műveletek most az alábbiak szerint hajthatók végre, amíg az s ki nem ürül:
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmaz, „xayz”.
- Törölje az előtagot, és az s "ayz" lesz. A partíciók száma most 1.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmaz, "ayz".
- Törölje az előtagot, és az s "yz" lesz. A partíciók száma most 2.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmaz, "yz".
- Törölje az előtagot, és az s "z" lesz. A partíciók száma most 3.
- Válassza ki a leghosszabb előtagot, amely legfeljebb 1 megkülönböztető karaktert tartalmazhat ("z").
- Törölje az előtagot, és az s üres lesz. A partíciók száma most 4.
Ezért a válasz a 4.
Kimutatható, hogy nem lehet 4 partíciónál többet szerezni.

Korlátozások:

1 <= s.length <= 10^4
s csak kis angol betűkből áll.
1 <= k <= 26


Adott egy 0-indexált 2D-s változók tömb, ahol a változók[i] = [a_i, b_i, c_i, m_i], és egy egész számú cél.
Az i index akkor jó, ha a következő képlet érvényes:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

Visszaad egy jó indexekből álló tömböt tetszőleges sorrendben.

1. példa:

Bemenet:variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Kimenet: [0,2]
Magyarázat: A változótömb minden egyes i indexére:
1) A 0 index esetében a változók[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Az 1. indexhez a változók[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) A 2. index esetében a változók[2] =[6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Ezért válaszként [0,2] értéket adunk vissza.

2. példa:

Bemenet: variables = [[39,3,1000,1000]], target = 17
Kimenet: []
Magyarázat: A változótömb minden egyes i indexére:
1) A 0 index esetén: variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Ezért válaszként [] értéket adunk vissza.

Korlátozások:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Kapsz egy 0-indexelt 2D tömbváltozót, ahol a változók [i] = [a_i, b_i, c_i, m_i], és egy egész cél.
Egy i index akkor jó, ha a következő képlet teljesül:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == cél

Jó indexekből álló tömb visszaadása tetszőleges sorrendben.

1. példa:

Bemenet: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Kimenet: [0,2]
Magyarázat: A változótömb minden i indexéhez:
1) A 0 index esetén a változók [0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Az 1. indexhez a változók [1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) A 2. indexhez a változók [2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Ezért válaszként a [0,2]-t adjuk vissza.

2. példa:

Bemenet: variables = [[39,3,1000,1000]], target = 17
Kimenet: []
Magyarázat: Minden egyes i indexhez a változók tömbjében:
1) A 0 index esetén a változók [0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Ezért válaszként a []-t adjuk vissza.

Korlátozások:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Kapsz egy 0-indexelt 2D tömbváltozót, ahol a változók [i] = [a_i, b_i, c_i, m_i], és egy egész cél.
Egy i index akkor jó, ha a következő képlet teljesül:

0 <= i < változók.hosszúság
((a_i^bi % 10)^ci) % m_i == cél

Jó indexekből álló tömb visszaadása tetszőleges sorrendben.

1. példa:

Bemenet: variables = [[2,3,3,10], [3,3,3,1], [6,1,1,4]], cél = 2
Kimenet: [0,2]
Magyarázat: A változótömb minden i indexéhez:
1) A 0 index esetén a variables [0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Az 1. indexhez a variablesv [1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) A 2. indexhez a variables [2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Ezért válaszként a [0,2]-t adjuk vissza.

2. példa:

Bemenet: variables = [[39,3,1000,1000]], cél = 17
Kimenet: []
Magyarázat: A változótömb minden i indexéhez:
1) A 0 index esetén a variables [0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Ezért válaszként a []-t adjuk vissza.

Korlátozások:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3


Két 0-indexelt karakterláncot kap, amelyek forrása és célja, mindkettő n hosszú és kisbetűs angol betűkből áll. Ezenkívül kap két 0-indexelt karaktertömböt, eredeti és módosított karaktertömböt, valamint egy egész szám tömb költségét, ahol a költség[i] az eredeti[i] karakter megváltoztatásának költségét jelenti a megváltoztatott [i] karakterre.
Kezdje a forrás karakterlánc adataival. Az egyik műveletben kiválaszthat egy x karaktert a karakterláncból, és megváltoztathatja azt y karakterre z költséggel, ha létezik olyan j index, amelynek költsége[j] == z, eredeti[j] == x, és megváltozott[j] == y.
Tetszőleges számú művelettel adja vissza a minimális költséget a karakterlánc-forrás karakterlánccéllá konvertálásához. Ha lehetetlen a forrást a célba konvertálni, adjon vissza -1-et.
Vegyük észre, hogy létezhetnek olyan i, j indexek, hogy eredeti[j] == eredeti[i] és megváltozott[j] == megváltozott[i].

1. példa:

Bemenet: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Kimenet: 28
Magyarázat: Az "abcd" karakterlánc átalakítása "acbe" karakterláncra:
- Módosítsa az 1. index értékét „b”-ről „c”-re 5-ös költséggel.
- Módosítsa a 2. index értékét „c”-ről „e”-re 1 költséggel.
- Módosítsa a 2-es index értékét „e”-ről „b”-re 2-es költséggel.
- Módosítsa a 3-as index értékét „d”-ről „e”-re 20 költséggel.
A teljes felmerülő költség 5 + 1 + 2 + 20 = 28.
Kimutatható, hogy ez a lehető legkisebb költség.

2. példa:

Bemenet: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Kimenet: 12
Magyarázat: Ha az „a” karaktert „b”-re kívánja változtatni, akkor az „a” karaktert „c”-re cserélje 1-es áron, majd a „c” karaktert „b”-re cserélje 2-vel, összesen 1 + 2 = 3 költsége. Az „a” összes előfordulásának „b”-re való módosításához 3 * 4 = 12 összköltség merül fel.

3. példa:

Bemenet: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Kimenet: -1
Magyarázat: A forrást nem lehet céllá konvertálni, mert a 3. index értéke nem módosítható 'd'-ről 'e'-re.

Korlátozások:

1 <= source.length == target.length <= 10^5
source, target consist of lowercase English letters.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] are lowercase English letters.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Két 0 indexelt karakterláncot kap, a forrást és a célt, mindkettő n hosszúságú és kisbetűs angol betűkből áll. Kapsz két 0 indexelt karaktertömböt is eredeti és módosított, valamint egy egész tömb költségét, ahol a cost[i] az eredeti karakter megváltoztatásának költségét jelenti[i] a megváltoztatott karakterre[i].
A forrás karakterláncból kezdve, Az egyik műveletben kiválaszthat egy x karaktert a karakterláncból, és y karakterre módosíthatja z költséggel, ha létezik olyan j index, amely cost[j] == z, original[j] == x, és changed[j] == y.
Adja vissza a sztringforrás sztringcéllá alakításának minimális költségét tetszőleges számú művelettel. Ha lehetetlen a forrást céllá konvertálni, adja vissza a -1 értéket.
Megjegyezzük, hogy létezhetnek i, j indexek úgy, hogy original[j] == original[i] és changed[j] == changed[i].

1. példa:

Bemenet: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Kimenet: 28
Magyarázat: Az "abcd" karakterlánc átalakítása "acbe" karakterlánccá:
- Az 1. index értékének megváltoztatása "b"-ről "c"-re 5-ös költséggel.
- A 2. index értékének megváltoztatása "c"-ről "e"-re 1 költséggel.
- A 2. index értékének megváltoztatása "e"-ről "b"-re 2-es költséggel.
- A 3. index értékét "d"-ről "e"-re változtassuk 20-as költséggel.
A teljes felmerült költség 5 + 1 + 2 + 20 = 28.
Kimutatható, hogy ez a lehető legkisebb költség.

2. példa:

Bemenet: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Kimenet: 12
Magyarázat: Az "a" karakter "b"-re változtatásához változtassuk meg az "a" karaktert "c"-re 1 költséggel, majd a "c" karaktert "b"-re változtassuk 2 költséggel, 1 + 2 = 3 összköltséggel. Az "a" összes előfordulásának "b" -re történő megváltoztatásához 3 * 4 = 12 összköltség merül fel.

3. példa:

Bemenet: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Kimenet: -1
Magyarázat: Lehetetlen a forrást céllá alakítani, mert a 3. index értéke nem változtatható meg "d"-ről "e"-re.

Korlátok:

1 <= source.length == target.length <= 10^5
source, target consist of lowercase English letters.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] are lowercase English letters.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Két 0-indexelt karakterláncot kap, amelyek forrása és célja, mindkettő n hosszú és kisbetűs angol betűkből áll. Ezenkívül kap két 0-indexelt karaktertömböt, eredeti és módosított karaktertömböt, valamint egy egész szám tömb költségét, ahol a költség[i] az eredeti[i] karakter megváltoztatásának költségét jelenti a megváltoztatott [i] karakterre.
Kezdje a karakterlánc forrásával. Az egyik műveletben kiválaszthat egy x karaktert a karakterláncból, és megváltoztathatja azt y karakterre z költséggel, ha létezik olyan j index, amelynek költsége[j] == z, eredeti[j] == x, és megváltozott[j] == y.
Tetszőleges számú művelettel adja vissza a minimális költséget a karakterlánc-forrás karakterlánccéllá konvertálásához. Ha lehetetlen a forrást céllá konvertálni, adjon vissza -1-et.
Vegyük észre, hogy létezhetnek olyan i, j indexek, hogy eredeti[j] == eredeti[i] és megváltozott[j] == megváltozott[i].

Példa 1:

Bemenet: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Kimenet: 28
Magyarázat: Az "abcd" karakterlánc átalakítása "acbe" karakterláncra:
- Módosítsa az 1. index értékét „b”-ről „c”-re 5-ös költséggel.
- Módosítsa a 2. index értékét „c”-ről „e”-re 1 költséggel.
- Módosítsa a 2-es index értékét „e”-ről „b”-re 2-es költséggel.
- Módosítsa a 3-as index értékét „d”-ről „e”-re 20 költséggel.
A teljes felmerülő költség 5 + 1 + 2 + 20 = 28.
Kimutatható, hogy ez a lehető legkisebb költség.

Példa 2:

Bemenet: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Kimenet: 12
Magyarázat: Ha az „a” karaktert „b”-re kívánja változtatni, akkor az „a” karaktert „c”-re cserélje 1-es áron, majd a „c” karaktert „b”-re cserélje 2-vel, összesen 1 + 2 = 3 költsége. Az „a” összes előfordulásának „b”-re való módosításához 3 * 4 = 12 összköltség merül fel.

Példa 3:

Bemenet: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Kimenet: -1
Magyarázat: A forrást nem lehet céllá konvertálni, mert a 3. index értéke nem módosítható 'd'-ről 'e'-re.

Korlátozások:

1 <= source.length == target.length <= 10^5
source, target kisbetűs angol betűkből állnak.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] kisbetűs angol betűk.
1 <= cost[i] <= 10^6
original[i] != changed[i]


Adott egy 0-indexelt egész számokból álló tömb.
A nums[0..i] előtag akkor szekvenciális, ha mind az 1 <= j <= i esetén nums[j] = nums[j - 1] + 1. Különösen a csak nums[0] előtag szekvenciális.
A számokból hiányzó legkisebb x egész számot adja eredményül úgy, hogy x nagyobb vagy egyenlő legyen a leghosszabb szekvenciális előtag összegével.

1. példa:

Bemenet: nums= [1,2,3,2,5]
Kimenet: 6
Magyarázat: A nums leghosszabb szekvenciális előtagja [1,2,3], 6 összeggel. A 6 nincs a tömbben, ezért a 6 a legkisebb hiányzó egész szám, amely nagyobb vagy egyenlő a leghosszabb szekvenciális előtag összegével.

2. példa:

Bemenet: nums = [3,4,5,1,12,14,13]
Kimenet: 15
Magyarázat: A számok leghosszabb szekvenciális előtagja [3,4,5], 12 összeggel. A 12, 13 és 14 a tömbhöz tartozik, míg a 15 nem. Ezért a 15 a legkisebb hiányzó egész szám, amely nagyobb vagy egyenlő a leghosszabb szekvenciális előtag összegével.

Korlátok:

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

Kap egy 0-indexelt tömböt egész nums.
A nums[0..i] előtag akkor szekvenciális, ha mind az 1 <= j <= i esetén nums[j] = nums[j - 1] + 1. Különösen a csak nums[0] előtag szekvenciális.
A számokból hiányzó legkisebb x egész számot adja eredményül úgy, hogy x nagyobb vagy egyenlő legyen a leghosszabb szekvenciális előtag összegével.

1. példa:

Bemenet: nums = [1,2,3,2,5]
Kimenet: 6
Magyarázat: A numok leghosszabb szekvenciális előtagja [1,2,3], 6 összeggel. A 6 nincs a tömbben, ezért a 6 a legkisebb hiányzó egész szám, amely nagyobb vagy egyenlő a leghosszabb szekvenciális előtag összegével.

2. példa:

Bemenet: nums = [3,4,5,1,12,14,13]
Kimenet: 15
Magyarázat: A nums leghosszabb szekvenciális előtagja [3,4,5], 12 összeggel. A 12, 13 és 14 a tömbhöz tartozik, míg a 15 nem. Ezért a 15 a legkisebb hiányzó egész szám, amely nagyobb vagy egyenlő a leghosszabb szekvenciális előtag összegével.

Korlátok:

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

Kapsz egy 0-indexelt egész számokból álló tömböt.
Egy nums[0..i] prefix akkor szekvenciális, ha minden 1 <= j <= i esetén nums[j] = nums[j - 1] + 1. Különösen, a csak nums[0]-t tartalmazó prefix szekvenciális.
A számokból hiányzó legkisebb x egész számot adja vissza úgy, hogy x nagyobb vagy egyenlő, mint a leghosszabb szekvenciális előtag összege.

Példa 1:

Bemenet: nums = [1,2,3,2,5]
Kimenet: 6
Magyarázat: A számok leghosszabb szekvenciális előtagja [1,2,3], összege 6. A 6 nincs a tömbben, ezért a 6 a legkisebb hiányzó egész szám, amely nagyobb vagy egyenlő a leghosszabb szekvenciális előtag összegével.

Példa 2:

Bemenet: nums = [3,4,5,1,12,14,13]
Kimenet: 15
Magyarázat: A számok leghosszabb szekvenciális előtagja [3,4,5] 12 összeggel. A 12, 13 és 14 a tömbhöz tartozik, míg a 15 nem. Ezért a 15 a legkisebb hiányzó egész szám, amely nagyobb vagy egyenlő, mint a leghosszabb szekvenciális előtag összege.

Korlátozások:

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


Két pozitív egész számot kapsz, x és y.
Egy műveletben a következő négy művelet egyikét végezheti el:

Osszuk x-et 11-gyel, ha x 11 többszöröse.
Osszuk x-et 5-tel, ha x 5 többszöröse.
Csökkentse x-et 1-gyel.
Növelje x-et 1-gyel.

Adja vissza az x és y egyenlővé tételéhez szükséges műveletek minimális számát.

1. példa:

Bemenet: x = 26, y = 1
Kimenet: 3
Magyarázat: A 26-ot egyenlővé tehetjük 1-gyel a következő műveletek alkalmazásával:
1. Csökkentse x-et 1-gyel
2. Oszd el x-et 5-tel
3. Oszd el x-et 5-tel
Megmutatható, hogy a 3 a műveletek minimális száma ahhoz, hogy 26 egyenlő legyen 1-gyel.

2. példa:

Bemenet: x = 54, y = 2
Kimenet: 4
Magyarázat: Az 54-et egyenlővé tehetjük 2-vel a következő műveletek alkalmazásával:
1. Növelje x-et 1-gyel
2. Ossza el x-et 11-gyel
3. Oszd el x-et 5-tel
4. Növelje x-et 1-gyel
Megmutatható, hogy 4 a minimális műveletek száma, amelyek ahhoz szükségesek, hogy 54 egyenlő legyen 2-vel.

3. példa:

Bemenet: x = 25, y = 30
Kimenet: 5
Magyarázat: A következő műveletek alkalmazásával 25-öt egyenlővé tehetünk 30-zal:
1. Növelje x-et 1-gyel
2. Növelje x-et 1-gyel
3. Növelje x-et 1-gyel
4. Növelje x-et 1-gyel
5. Növelje x-et 1-gyel
Megmutatható, hogy az 5 a minimális műveletek száma ahhoz, hogy 25 egyenlő legyen 30-cal.

Korlátozások:

1 <= x, y <= 10^4

Adott két pozitív egész szám, x és y.
Egy műveletben a következő négy művelet egyikét végezheti el:

Osszuk x-et 11-gyel, ha x 11 többszöröse.
Osszuk x-et 5-tel, ha x 5 többszöröse.
Csökkentse x-et 1-gyel.
Növelje x-et 1-gyel.

Adja vissza az x és y egyenlővé tételéhez szükséges műveletek minimális számát.

1. példa:

Bemenet: x = 26, y = 1
Kimenet: 3
Magyarázat: A 26-ot egyenlővé tehetjük 1-gyel a következő műveletek alkalmazásával:
1. Csökkentse x-et 1-gyel
2. Oszd el x-et 5-tel
3. Ossza el x-et 5-tel
Megmutatható, hogy a 3 a műveletek minimális száma ahhoz, hogy 26 egyenlő legyen 1-gyel.

2. példa:

Bemenet: x = 54, y = 2
Kimenet: 4
Magyarázat: Az 54-et egyenlővé tehetjük 2-vel a következő műveletek alkalmazásával:
1. Növelje x-et 1-gyel
2. Ossza el x-et 11-gyel
3. Oszd el x-et 5-tel
4. Növelje x-et 1-gyel
Megmutatható, hogy 4 a minimális műveletek száma, amelyek ahhoz szükségesek, hogy 54 egyenlő legyen 2-vel.

3. példa:

Bemenet: x = 25, y = 30
Kimenet: 5
Magyarázat: A következő műveletek alkalmazásával 25-öt egyenlővé tehetünk 30-zal:
1. Növelje x-et 1-gyel
2. Növelje x-et 1-gyel
3. Növelje x-et 1-gyel
4. Növelje x-et 1-gyel
5. Növelje x-et 1-gyel
Megmutatható, hogy az 5 a minimális műveletek száma ahhoz, hogy 25 egyenlő legyen 30-cal.

Korlátozások:

1 <= x, y <= 10^4

Adott két pozitív egész szám x és y.
Egy műveletben elvégezheted a következő négy művelet egyikét:

Oszd el x-et 11-gyel, ha x 11 többszöröse.
Oszd el x-et 5-tel, ha x 5 többszöröse.
Csökkentse x-et 1-gyel.
Növeljük x-et 1-gyel.

Adja vissza az x és y egyenlővé tételéhez szükséges műveletek minimális számát.

Példa 1:

Bemenet: x = 26, y = 1
Kimenet: 3
Magyarázat: A következő műveletek alkalmazásával 26-ot egyenlővé tehetjük 1-gyel:
1. Csökkentjük x-et 1-gyel
2. Osszuk el x-et 5-tel
3. Oszd el x-et 5-tel
Kimutatható, hogy 3 a minimálisan szükséges műveletek száma ahhoz, hogy 26 egyenlő legyen 1-gyel.

Példa 2:

Bemenet: x = 54, y = 2
Kimenet: 4
Magyarázat: A következő műveletek alkalmazásával tudjuk 54-et 2-vel egyenlővé tenni:
1. x 1-gyel történő növelése
2. Osszuk el x-et 11-gyel
3. Oszd el x-et 5-tel
4. Inkrementáljuk x-et 1-gyel
Kimutatható, hogy 4 a minimálisan szükséges műveletek száma ahhoz, hogy 54 egyenlő legyen 2-vel.

Példa 3:

Bemenet: x = 25, y = 30
Kimenet: 5
Magyarázat: A következő műveletek alkalmazásával tudjuk a 25-öt egyenlővé tenni a 30-cal:
1. x 1-gyel történő növelése
2. Növeljük x-et 1-gyel
3. x 1-gyel való növelése
4. x 1-gyel történő növelése
5. x 1-gyel történő növelése
Kimutatható, hogy 5 a minimálisan szükséges műveletek száma ahhoz, hogy 25 egyenlő legyen 30-zal.

Korlátozások:

1 <= x, y <= 10^4


Egy egész számot k és egy egész számot x kaptál.

Tegyük fel, hogy s egy num egész szám 1-indexált bináris ábrázolása. Egy num szám ára azon i-k száma, amelyekre i % x == 0 és s[i] egy beállított bit.
Add vissza a legnagyobb num egész számot, amelyre az 1-től num-ig terjedő számok árainak összege legfeljebb k.

Megjegyzés:

Egy bináris ábrázolásban a beállított bit 1 értékű bit.
Egy szám bináris ábrázolása jobbról balra lesz indexelve. Például ha s == 11100, akkor s[4] == 1 és s[2] == 0.

Példa 1:

Bemenet: k = 9, x = 1
Kimenet: 6
Magyarázat: Az 1, 2, 3, 4, 5 és 6 számok bináris ábrázolása "1", "10", "11", "100", "101" és "110" lesz.
Mivel x egyenlő 1-gyel, minden szám ára a beállított bitek száma.
Ezekben a számokban a beállított bitek száma 9. Tehát az első 6 szám árainak összege 9.
Tehát a válasz 6.

Példa 2:

Bemenet: k = 7, x = 2
Kimenet: 9
Magyarázat: Mivel x egyenlő 2-vel, csak a párosodik^th biteket kell ellenőriznünk.
A 2 és 3 számok bináris ábrázolásának második bitje beállított bit. Így összegük 2.
A 6 és 7 számok bináris ábrázolásának második bitje beállított bit. Így összegük 2.
A 8 és 9 számok bináris ábrázolásának negyedik bitje beállított bit, de a második bitjük nem. Így összegük 2.
Az 1, 4 és 5 számoknak nincs beállított bitjük a bináris ábrázolásuk párosodik^th bitjeiben. Így összegük 0.
A 10 szám bináris ábrázolásának második és negyedik bitje beállított bit. Így ára 2.
Az első 9 szám árainak összege 6.
Mivel az első 10 szám árainak összege 8, a válasz 9.

Korlátozások:

1 <= k <= 10^15
1 <= x <= 8

Kapsz egy k egész számot és egy x egész számot.
Tekintsük s-nek egy egész szám 1-indexelt bináris ábrázolását. A szám ára num az i-k száma úgy, hogy i % x == 0 és s[i] egy beállított bit.
A legnagyobb egész számot úgy adjuk vissza, hogy az 1-től numig terjedő összes szám árának összege kisebb vagy egyenlő legyen k-val.
Jegyzet:

A számkészlet bitjének bináris ábrázolásában egy 1-es értékű bit van.
A szám bináris ábrázolása jobbról balra lesz indexelve. Például, ha s == 11100, s[4] == 1 és s[2] == 0.

1. példa:

Bemenet: k = 9, x = 1
Kimenet: 6
Magyarázat: Az 1, 2, 3, 4, 5 és 6 számok bináris ábrázolásban felírhatók "1", "10", "11", "100", "101" és "110" formában.
Mivel x egyenlő 1-gyel, az egyes számok ára a beállított bitek száma.
A beállított bitek száma ezekben a számokban 9. Tehát az első 6 szám árának összege 9.
Tehát a válasz 6.
2. példa:

Bemenet: k = 7, x = 2
Kimenet: 9
Magyarázat: Mivel x egyenlő 2-vel, csak a páros^ biteket kell ellenőriznünk.
A 2. és 3. számok bináris ábrázolásának második bitje egy meghatározott bit. Tehát áraik összege 2.
A 6. és 7. számok bináris ábrázolásának második bitje egy meghatározott bit. Tehát áraik összege 2.
A 8-as és 9-es számok bináris ábrázolásának negyedik bitje egy meghatározott bit, de a második bitjük nem. Tehát áraik összege 2.
Az 1-es, 4-es és 5-ös számok bináris ábrázolásában nincsenek halmazbitek páros^ bitjeikben. Tehát áraik összege 0.
A 10-es szám bináris ábrázolásának második és negyedik bitje egy meghatározott bit. Tehát az ára 2.
Az első 9 szám árának összege 6.
Mivel az első 10 szám árának összege 8, a válasz 9.

Korlátok:

1 <= k <= 10^15
1 < = x <= 8

Kapsz egy k egész számot és egy x egész számot.
Tekintsük s-t egy egész szám 1-indexelt bináris ábrázolásának. A num szám ára az i-ek száma úgy, hogy i % x == 0 és s[i] egy beállított bit.
Adja vissza a legnagyobb egész számot úgy, hogy az 1-től num-ig terjedő összes szám árának összege kisebb vagy egyenlő k-val.
Jegyzet:

Egy számkészlet bináris ábrázolásában a bit értéke 1.
Egy szám bináris reprezentációja jobbról balra indexelve lesz. Például, ha s == 11100, s[4] == 1 és s[2] == 0.

1. példa:

Bemenet: k = 9, x = 1
Kimenet: 6
Magyarázat: Az 1, 2, 3, 4, 5 és 6 számok bináris ábrázolásban "1", "10", "11", "100", "101" és "110" formában írhatók fel.
Mivel x egyenlő 1-gyel, minden szám ára a beállított bitek száma.
Ezekben a számokban a beállított bitek száma 9. Tehát az első 6 szám árának összege 9.
Tehát a válasz: 6.
2. példa:

Bemenet: k = 7, x = 2
Kimenet: 9
Magyarázat: Mivel x egyenlő 2-vel, csak a páros^-edik bitet kell ellenőriznünk.
A 2. és 3. szám bináris ábrázolásának második bitje egy beállított bit. Tehát az áruk összege 2.
A 6-os és 7-es számok bináris ábrázolásának második bitje egy beállított bit. Tehát az áruk összege 2.
A 8-as és 9-es számok bináris ábrázolásának negyedik bitje beállított bit, de a második bitjük nem. Tehát az áruk összege 2.
Az 1-es, 4-es és 5-ös számok páros^-edik bitjeiben nincsenek beállított bitek a bináris ábrázolásukban. Tehát áraik összege 0.
A 10-es szám bináris ábrázolásának második és negyedik bitje egy beállított bit. Tehát az ára 2.
Az első 9 szám árának összege 6.
Mivel az első 10 szám árának összege 8, a válasz 9.

Korlátozások:

1 <= k <= 10^15
1 <= x <= 8


Kap egy tömböt, amely pozitív egész számokat tartalmaz.
Az elemek teljes gyakoriságát adja vissza számban úgy, hogy ezek az elemek mind a maximális frekvenciával rendelkezzenek.
Egy elem gyakorisága az elem előfordulásainak száma a tömbben.

1. példa:

Bemenet: nums = [1,2,2,3,1,4]
Kimenet: 4
Magyarázat: Az 1 és 2 számok frekvenciája 2, ami a tömb maximális frekvenciája.
Tehát a maximális gyakoriságú elemek száma 4.

2. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: 5
Magyarázat: A tömb minden elemének frekvenciája 1, ami a maximum.
Tehát a tömb elemeinek maximális gyakorisága 5.

Korlátok:

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

Kapsz egy pozitív egész számokból álló tömböt.
Adja vissza az elemek teljes gyakoriságát számokban úgy, hogy ezeknek az elemeknek a maximális frekvenciája legyen.
Egy elem gyakorisága az adott elem előfordulásának száma a tömbben.

1. példa:

Bemenet: nums = [1,2,2,3,1,4]
Kimenet: 4
Magyarázat: Az 1 és 2 elemek frekvenciája 2, ami a tömb maximális frekvenciája.
Tehát a tömb maximális gyakoriságú elemeinek száma 4.

2. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: 5
Magyarázat: A tömb minden elemének gyakorisága 1, ami a maximum.
Tehát a tömb maximális gyakoriságú elemeinek száma 5.

Korlátozások:

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


Három egész számot kaptál: start, finish és limit. Továbbá egy 0-indexű karakterláncot s, amely egy pozitív egész számot képvisel.
Egy pozitív egész számot x akkor nevezünk erősnek, ha s-re végződik (más szóval, s x egy suffixe), és x minden számjegye legfeljebb limit.
Add vissza az erős egész számok teljes számát a [start..finish] tartományban.
Egy x karakterlánc y egy suffixe, ha és csak akkor, ha x y egy olyan részszövege, amely valamely indexről (beleértve a 0-t) indul y-ban és kiterjed az y.length - 1 indexig. Például a 25 egy suffixe az 5125-nek, míg az 512 nem.

Példa 1:

Input: start = 1, finish = 6000, limit = 4, s = "124"
Output: 5
Magyarázat: Az erős egész számok a [1..6000] tartományban: 124, 1124, 2124, 3124 és 4124. Mindezek az egész számok minden számjegye <= 4, és "124"-re végződnek. Megjegyzendő, hogy az 5124 nem erős szám, mert az első számjegy 5, amely nagyobb mint 4.
Megmutatható, hogy ebben a tartományban csak 5 erős szám van.

Példa 2:

Input: start = 15, finish = 215, limit = 6, s = "10"
Output: 2
Magyarázat: Az erős egész számok a [15..215] tartományban: 110 és 210. Mindezek az egész számok minden számjegye <= 6, és "10"-re végződnek.
Megmutatható, hogy ebben a tartományban csak 2 erős szám van.

Példa 3:

Input: start = 1000, finish = 2000, limit = 4, s = "3000"
Output: 0
Magyarázat: A [1000..2000] tartományban lévő összes egész szám kisebb mint 3000, ennélfogva "3000" nem lehet egyetlen szám suffixe sem ebben a tartományban.

Feltételek:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s csak limitnél legfeljebb számjegyeket tartalmaz.
s nem tartalmaz vezető nullákat.

Adott három egész szám: start, finish és limit. Adott továbbá egy 0 indexű s karakterlánc, amely egy pozitív egész számot jelöl.
Egy x pozitív egész számot erősnek nevezünk, ha s-re végződik (más szóval s az x utótagja), és x minden egyes számjegye legfeljebb limit.
A [start..finish] tartományban lévő erős egész számok teljes számát adja vissza.
Egy x karakterlánc akkor és csak akkor az y karakterlánc utótagja, ha x az y olyan részlánc, amely az y valamely indexétől (beleértve a 0-t is) indul és az y.length - 1 indexig tart. Például 25 az 5125 utótagja, míg 512 nem.

1. példa:

Bemenet: start = 1, finish = 6000, limit = 4, s = "124"
Kimenet: 5
Magyarázat: Az [1..6000] tartomány hathatós egész számai: 124, 1124, 2124, 3124 és 4124. Mindezen egész számok minden számjegye <= 4, és "124" utótag. Vegye figyelembe, hogy az 5124 nem hatékony egész szám, mert az első számjegy 5, ami nagyobb, mint 4.
Megmutatható, hogy ebben a tartományban csak 5 erős egész szám van.

2. példa:

Bemenet: start = 15, finish = 215, limit = 6, s = "10"
Kimenet: 2
Magyarázat: A [15..215] tartományban az erős egész számok 110 és 210. Mindegyik egész számnak minden egyes számjegye <= 6, és „10” az utótagja.
Kimutatható, hogy ebben a tartományban csak 2 erős egész szám van.

3. példa:

Bemenet: start = 1000, finish = 2000, limit = 4, s = "3000"
Kimenet: 0
Magyarázat: Az [1000..2000] tartományban lévő összes egész szám kisebb, mint 3000, ezért a "3000" nem lehet egyetlen egész szám utótagja sem ebben a tartományban.

Korlátozások:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s csak olyan számjegyekből áll, amelyek legfeljebb limit.
s nem tartalmaz vezető nullákat.

Három egész számot kap: kezdő, befejező és határérték. Kapsz egy 0-indexelt karakterláncot is, amely pozitív egész számot jelent.
Egy x pozitív egész számot akkor nevezünk erősnek, ha s-re végződik (más szóval, s az x utótagja), és az x-ben lévő minden számjegy legfeljebb határérték.
A [start..finish] tartományban lévő erőteljes egész számok teljes számát adja vissza.
Az x karakterlánc akkor és csak akkor utótagja az y karakterláncnak, ha x az y olyan részkarakterlánca, amely az y valamely indexéből indul ki (beleértve a 0-t is), és az y indexig terjed. hossza - 1. Például a 25 az y utótagja 5125, míg az 512 nem.

1. példa:

Bemenet: start = 1, finish = 6000, limit = 4, s = "124"
Kimenet: 5
Magyarázat: Az [1..6000] tartományban az erős egész számok a 124, 1124, 2124, 3124 és, 4124. Ezeknek az egész számoknak minden számjegye <= 4, és "124" utótag. Vegye figyelembe, hogy az 5124 nem erős egész szám, mert az első számjegy 5, ami nagyobb, mint 4.
Kimutatható, hogy ebben a tartományban csak 5 erős egész szám található.

2. példa:

Bemenet: start = 15, finish = 215, limit = 6, s = "10"
Kimenet: 2
Magyarázat: A [15..215] tartományban az erős egész számok a 110 és a 210. Ezeknek az egész számoknak minden számjegye <= 6, és "10" utótag.
Kimutatható, hogy ebben a tartományban csak 2 erős egész szám található.

3. példa:

Bemenet: start = 1000, finish = 2000, limit = 4, s = "3000"
Kimenet: 0
Magyarázat: Az [1000...2000] tartományban minden egész kisebb 3000-nél, ezért a "3000" nem lehet egész szám utótagja ebben a tartományban.

Korlátozások:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s csak numerikus számjegyekből áll, amelyek legfeljebb határértékek.
s-ben nincsenek kezdő nullák.


Legyen adott egy 0-indexált egész számokat tartalmazó nums tömb, amely pozitív egész számokat tartalmaz.
A feladat az, hogy minimalizáld a nums hosszát az alábbi műveletek tetszőleges számú (beleértve a nullát is) elvégzésével:

Válassz ki két különböző i és j indexet a nums-ból, úgy hogy nums[i] > 0 és nums[j] > 0.
Helyezd el nums[i] % nums[j] értékét a nums végére.
Töröld a nums i és j indexű elemeit.

Adj vissza egy egész számot, amely a nums minimális hosszát jelöli a művelet tetszőleges számú végrehajtása után.

Példa 1:

Bemenet: nums = [1,4,3,1]
Kimenet: 1
Magyarázat: Egy lehetséges mód a tömb hosszának minimalizálására a következő:
1. művelet: Válaszd ki a 2. és 1. indexet, helyezd el a nums[2] % nums[1] értékét a végére, ekkor a tömb [1,4,3,1,3] lesz, majd töröld a 2. és 1. index elemeit.
nums így [1,1,3] lesz.
2. művelet: Válaszd ki az 1. és 2. indexet, helyezd el a nums[1] % nums[2] értékét a végére, ekkor a tömb [1,1,3,1] lesz, majd töröld az 1. és 2. index elemeit.
nums így [1,1] lesz.
3. művelet: Válaszd ki az 1. és 0. indexet, helyezd el a nums[1] % nums[0] értékét a végére, ekkor a tömb [1,1,0] lesz, majd töröld az 1. és 0. index elemeit.
nums így [0] lesz.
A nums hosszát nem lehet tovább csökkenteni. Ezért a válasz 1.
Bizonyítható, hogy 1 a minimálisan elérhető hossz.

Példa 2:

Bement: nums = [5,5,5,10,5]
Kimenet: 2
Magyarázat: Egy lehetséges mód a tömb hosszának minimalizálására a következő:
1. művelet: Válaszd ki a 0. és 3. indexet, helyezd el a nums[0] % nums[3] értékét a végére, ekkor a tömb [5,5,5,10,5,5] lesz, majd töröld a 0. és 3. index elemeit.
nums így [5,5,5,5] lesz.
2. művelet: Válaszd ki a 2. és 3. indexet, helyezd el a nums[2] % nums[3] értékét a végére, ekkor a tömb [5,5,5,5,0] lesz, majd töröld a 2. és 3. index elemeit.
nums így [5,5,0] lesz.
3. művelet: Válaszd ki a 0. és 1. indexet, helyezd el a nums[0] % nums[1] értékét a végére, ekkor a tömb [5,5,0,0] lesz, majd töröld a 0. és 1. index elemeit.
nums így [0,0] lesz.
A nums hosszát nem lehet tovább csökkenteni. Ezért a válasz 2.
Bizonyítható, hogy 2 a minimálisan elérhető hossz.

Példa 3:

Bemenet: nums = [2,3,4]
Kimenet: 1
Magyarázat: Egy lehetséges mód a tömb hosszának minimalizálására a következő:
1. művelet: Válaszd ki az 1. és 2. indexet, helyezd el a nums[1] % nums[2] értékét a végére, ekkor a tömb [2,3,4,3] lesz, majd töröld az 1. és 2. index elemeit.
nums így [2,3] lesz.
2. művelet: Válaszd ki az 1. és 0. indexet, helyezd el a nums[1] % nums[0] értékét a végére, ekkor a tömb [2,3,1] lesz, majd töröld az 1. és 0. index elemeit.
nums így [1] lesz.
A nums hosszát nem lehet tovább csökkenteni. Ezért a válasz 1.
Bizonyítható, hogy 1 a minimálisan elérhető hossz.

Korlátozások:

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

Kap egy 0 indexelt egész tömb nums, amely pozitív egész számokat tartalmaz.
A feladat a nums hosszának minimalizálása a következő műveletek tetszőleges számú végrehajtásával (beleértve a nullát is):

Válasszon ki két különböző i és j indexet a numok közül úgy, hogy a nums[i] > 0, a nums[j] pedig > 0.
Szúrja be a nums[i] % nums[j] eredményét a nums végére.
Törölje az i és j indexek elemeit a nums-ból.

A szám minimális hosszát jelölő egész számot ad vissza a művelet tetszőleges számú végrehajtása után.

1. példa:

Bemenet: nums = [1,4,3,1]
Kimenet: 1
Magyarázat: A tömb hosszának minimalizálásának egyik módja a következő:
1. művelet: Válassza ki a 2. és 1. indexet, szúrjon be nums[2] % nums[1] a végére, és ez [1,4,3,1,3] lesz, majd törölje az elemeket a 2. és 1. indexből.
A nums [1,1,3] lesz.
2. művelet: Válassza ki az 1. és 2. indexet, szúrjon be nums[1] % nums[2] a végére, és ez lesz az [1,1,3,1], majd törölje az elemeket az 1. és 2. indexből.
A nums [1,1] lesz.
3. művelet: Válassza ki az 1. és a 0. indexet, szúrjon be nums[1] % nums[0] a végére, és ez lesz az [1,1,0], majd törölje az elemeket az 1. és 0. indexből.
A nums [0] lesz.
A számok hossza nem csökkenthető tovább. Ezért a válasz 1.
Kimutatható, hogy 1 a minimálisan elérhető hossz.
2. példa:

Bemenet: nums = [5,5,5,10,5]
Kimenet: 2
Magyarázat: A tömb hosszának minimalizálásának egyik módja a következő:
1. művelet: Válassza ki a 0 és 3 indexet, szúrjon be nums[0] % nums[3] a végére, és ez [5,5,5,10,5,5] lesz, majd törölje az elemeket a 0 és 3 indexből.
A nums [5,5,5,5] lesz.
2. művelet: Válassza ki a 2. és 3. indexet, szúrjon be nums[2] % nums[3] a végére, és ez [5,5,5,5,0] lesz, majd törölje az elemeket a 2. és 3. indexből.
A nums [5,5,0] lesz.
3. művelet: Válassza ki a 0 és 1 indexet, szúrjon be nums[0] % nums[1] értéket a végére, és ez [5,5,0,0] lesz, majd törölje az elemeket a 0 és 1 indexeknél.
A nums [0,0] lesz.
A nums hossza nem csökkenthető tovább. Ezért a válasz 2.
Kimutatható, hogy 2 a minimálisan elérhető hossz.
3. példa:

Bemenet: nums = [2,3,4]
Kimenet: 1
Magyarázat: A tömb hosszának minimalizálásának egyik módja a következő:
1. művelet: Válassza ki az 1. és 2. indexet, szúrjon be nums[1] % nums[2] a végére, és ez [2,3,4,3] lesz, majd törölje az elemeket az 1. és 2. indexből.
nums lesz [2,3].
2. művelet: Válassza ki az 1. és a 0. indexet, szúrjon be nums[1] % nums[0] a végére, és ez lesz a [2,3,1], majd törölje az elemeket az 1. és 0. indexből.
A nums [1] lesz.
A számok hossza nem csökkenthető tovább. Ezért a válasz 1.
Kimutatható, hogy 1 a minimálisan elérhető hossz.

Korlátok:

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

Kapsz egy 0-indexelt egész számokat, amelyek pozitív egész számokat tartalmaznak.
Az Ön feladata a számok hosszának minimalizálása a következő műveletek tetszőleges számú (nullát is beleértve) végrehajtásával:

Válasszon ki két különálló i és j indexet a számok közül úgy, hogy a nums[i] > 0 és a nums[j] > 0.
A számok végére írja be a nums[i] % nums[j] eredményét.
Törölje a számokból az i és j indexek elemeit.

A művelet tetszőleges számú végrehajtása után adjon vissza egy egész számot, amely a számok minimális hosszát jelöli.

1. példa:

Bemenet: nums = [1,4,3,1]
Kimenet: 1
Magyarázat: A tömb hosszának minimalizálásának egyik módja a következő:
1. művelet: Válassza ki a 2. és 1. indexet, szúrja be a nums[2] % num[1] a végére, és ez lesz [1,4,3,1,3], majd törölje a 2. és 1. indexnél lévő elemeket.
A számokból [1,1,3] lesz.
2. művelet: Válassza ki az 1. és 2. indexet, szúrja be a nums[1] % nums[2] a végére, és ez lesz [1,1,3,1], majd törölje az 1. és 2. indexnél lévő elemeket.
számokból [1,1] lesz.
3. művelet: Válassza ki az 1-es és 0-s indexet, a végére szúrja be a nums[1] % nums[0] értéket, és ez lesz [1,1,0], majd törölje az 1-es és 0-s indexeknél lévő elemeket.
a számokból [0] lesz.
A számok hossza nem csökkenthető tovább. Ezért a válasz az 1.
Megmutatható, hogy 1 a minimális elérhető hossz.
2. példa:

Bemenet: nums = [5,5,5,10,5]
Kimenet: 2
Magyarázat: A tömb hosszának minimalizálásának egyik módja a következő:
1. művelet: Válassza ki a 0 és a 3 indexet, szúrja be a nums[0] % nums[3] a végére, és ez lesz [5,5,5,10,5,5], majd törölje a 0 és 3 indexnél lévő elemeket.
számokból [5,5,5,5] lesz.
2. művelet: Válassza ki a 2. és 3. indexet, szúrja be a nums[2] % num[3] a végére, és ez lesz [5,5,5,5,0], majd törölje az elemeket a 2. és 3. indexnél.
számokból [5,5,0] lesz.
3. művelet: Válassza ki a 0 és 1 indexet, a végére szúrja be a nums[0] % nums[1] értéket, és ez lesz [5,5,0,0], majd törölje a 0 és 1 indexnél lévő elemeket.
a számokból [0,0] lesz.
A számok hossza nem csökkenthető tovább. Ezért a válasz a 2.
Megmutatható, hogy 2 a minimális elérhető hossz.
3. példa:

Bemenet: nums = [2,3,4]
Kimenet: 1
Magyarázat: A tömb hosszának minimalizálásának egyik módja a következő:
1. művelet: Válassza ki az 1-es és 2-es indexet, szúrja be a nums[1] % nums[2] a végére, és ez lesz [2,3,4,3], majd törölje az 1-es és 2-es indexnél lévő elemeket.
számokból [2,3] lesz.
2. művelet: Válassza ki az 1-es és 0-s indexet, a végére szúrja be a nums[1] % nums[0] értéket, és ez lesz [2,3,1], majd törölje az 1-es és 0-s indexeknél lévő elemeket.
A számokból [1] lesz.
A számok hossza nem csökkenthető tovább. Ezért a válasz az 1.
Megmutatható, hogy 1 a minimális elérhető hossz.

Korlátozások:

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


Kapsz egy 0 indexű s karakterláncot, egy a karakterláncot, egy b karakterláncot és egy k egész számot.
Egy index i akkor szép, ha:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Létezik egy j index:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Adja vissza a gyönyörű indexeket tartalmazó tömböt a legkisebbtől a legnagyobbig rendezett sorrendben.

Példa 1:

Bemenet: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Kimenet: [16,33]
Magyarázat: 2 gyönyörű index van: [16,33].
- A 16-os index szép, mivel s[16..17] == "my" és létezik egy 4-es index, amelyre s[4..11] == "squirrel" és |16 - 4| <= 15.
- A 33-as index szép, mivel s[33..34] == "my" és létezik egy 18-as index, amelyre s[18..25] == "squirrel" és |33 - 18| <= 15.
Ezért a visszatérés [16,33].

Példa 2:

Bemenet: s = "abcd", a = "a", b = "a", k = 4
Kimenet: [0]
Magyarázat: Van 1 gyönyörű index: [0].
- A 0-ás index szép, mivel s[0..0] == "a" és létezik egy 0-ás index, amelyre s[0..0] == "a" és |0 - 0| <= 4.
Ezért a visszatérés [0].

Korlátozások:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
Az s, a és b csak kisbetűket tartalmaz angolul.

Kapsz egy 0 indexű s karakterláncot, egy a, egy b karakterláncot és egy k egész számot.
Egy index i akkor gyönyörű, ha:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Létezik egy j index:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Adja vissza a gyönyörű indexeket tartalmazó tömböt a legkisebbtől a legnagyobbig rendezett sorrendben.

1. példa:

Bemenet: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Kimenet: [16,33]
Magyarázat: 2 gyönyörű index van: [16,33].
- A 16-os index gyönyörű, mint s[16..17] == "én" és létezik egy 4-es index s[4..11] == "squirrel" és |16 - 4| <= 15.
- A 33-as index gyönyörű, mint s[33..34] == "én" és létezik egy 18-as index s[18..25] == "squirrel" és |33 - 18| <= 15.
Így eredményként a [16,33]-at adjuk vissza.

2. példa:

Bemenet: s = "abcd", a = "a", b = "a", k = 4
Kimenet: [0]
Magyarázat: Van 1 gyönyörű index: [0].
- A 0-s index gyönyörű, mint s[0..0] == "a", és létezik 0-s index s[0..0] == "a" és |0 - 0| <= 4.
Így eredményként a [0]-t adjuk vissza.

Korlátozások:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
Az s, a és b csak kisbetűket tartalmaz angolul.

Kapsz egy 0-indexelt s karakterláncot, egy a karakterláncot, egy b karakterláncot és egy k egész számot.
Egy i index akkor szép, ha:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Létezik olyan j index, amely:

0 <= j <= s.length - b.length
s[j.. (j + b.length - 1)]  == b
|j - i|  <= k

Adja vissza a gyönyörű indexeket tartalmazó tömböt a legkisebbtől a legnagyobbig terjedő sorrendben.

1. példa:

Bemenet: "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Kimenet: [16,33]
Magyarázat: 2 gyönyörű index van: [16,33].
- A 16-os index gyönyörű, mivel s[16..17] == "my", és létezik egy 4-es index s[4..11] == "squirrel" és |16 - 4| <= 15.
- A 33-as index gyönyörű, mivel s[33..34] =="my" , és létezik egy 18-as index s[18..25] ==  "squirrel" és |33 - 18| <= 15.
Így [16,33] visszatérünk eredményként.

2. példa:

Bemenet: s = "abcd", a = "a", b = "a", k = 4
Kimenet: [0]
Magyarázat: Van 1 szép index: [0].
- A 0 index gyönyörű, mivel s[0..0] == "a", és létezik 0 index s[0..0] == "a" és |0 - 0| <= 4.
Így eredményként [0]-t adunk vissza.

Korlátok:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
Az s, a és b csak kisbetűs angol betűket tartalmaz.


Kap egy tömböt pozitív egész számokból, nums.
Ellenőrizze, hogy lehetséges-e két vagy több elemet kiválasztani a tömbből úgy, hogy a kiválasztott elemek bitenkénti OR bináris ábrázolásában legalább egy záró nulla legyen.
Például az 5 bináris ábrázolása, amely "101", nem tartalmaz záró nullákat, míg a 4 bináris ábrázolása, amely "100", két záró nullával rendelkezik.
Igaz értéket ad vissza, ha ki lehet jelölni két vagy több olyan elemet, amelynek bitenkénti OR záró nullája van, ellenkező esetben hamis értéket ad vissza.

1. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: true

Magyarázat: Ha kiválasztjuk a 2. és 4. elemet, bitenkénti VAGY értéke 6, amelynek bináris ábrázolása "110", egy záró nullával.

2. példa:

Bemenet: nums = [2,4,8,16]
Kimenet: true
Magyarázat: Ha kiválasztjuk a 2. és 4. elemet, bitenkénti VAGY értéke 6, amelynek bináris ábrázolása "110", egy záró nullával.
A bitenkénti OR bináris ábrázolásában záró nullákkal rendelkező elemek kiválasztásának további lehetséges módjai: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) és (2, 4, 8, 16).

3. példa:

Bemenet: nums = [1,3,5,7,9]
Kimenet: false
Magyarázat: Nincs mód arra, hogy két vagy több elemet kijelöljünk úgy, hogy a bitenkénti OR bináris ábrázolásában záró nullák legyenek.

Korlátok:

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

Kap egy tömb pozitív egész számokat, amit nums-nak hívnak.
Ellenőrizni kell, hogy lehetséges-e két vagy több elemet kiválasztani a tömbben úgy, hogy a kiválasztott elemek bitenkénti VAGY legalább egy záró nulla legyen a bináris ábrázolásában.
Például az 5 bináris reprezentációja, amely "101", nem tartalmaz záró nullákat, míg a 4 bináris reprezentációja, amely "100", két záró nullával rendelkezik.
Igazat ad vissza, ha ki lehet választani két vagy több olyan elemet, amelyek bitenkénti VAGY záró nullákat tartalmaznak, ellenkező esetben false értéket ad vissza.

1. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: true
Magyarázat: Ha kiválasztjuk a 2-es és 4-es elemeket, a bitenkénti VAGY 6, aminek a bináris reprezentációja "110" egy nullával.

2. példa:

Bemenet: nums = [2,4,8,16]
Kimenet: true
Magyarázat: Ha kiválasztjuk a 2-es és 4-es elemeket, a bitenkénti VAGY 6, aminek a bináris reprezentációja "110" egy nullával.
Az elemek kiválasztásának további lehetséges módjai, hogy a bitenkénti VAGY bináris ábrázolásában nullák legyenek a végén: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) és (2, 4, 8, 16).

3. példa:

Bemenet: nums = [1,3,5,7,9]
Kimenet: false
Magyarázat: Nem lehet két vagy több elemet kiválasztani úgy, hogy a bitenkénti VAGY bináris megjelenítésében nullák legyenek.

Korlátozások:

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

Egy pozitív egész számokat tartalmazó tömb, nums van megadva.
Meg kell vizsgálni, hogy lehetséges-e kiválasztani két vagy több elemet a tömbből úgy, hogy a kiválasztott elemek bitwise OR-ja legalább egy záró nullát tartalmazzon a bináris ábrázolásában.
Például az 5 bináris ábrázolása, amely "101", nem tartalmaz záró nullát, míg a 4 bináris ábrázolása, amely "100", két záró nullát tartalmaz.
Adjon vissza trút, ha lehetséges kiválasztani két vagy több elemet, amelyek bitwise OR-ja záró nullát tartalmaz, különben adjon vissza falsot.

1. példa:

Input: nums = [1,2,3,4,5]
Output: true
Magyarázat: Ha kiválasztjuk a 2 és 4 elemeket, azok bitwise OR-ja 6, amelynek bináris ábrázolása "110", ami egy záró nullát tartalmaz.

2. példa:

Input: nums = [2,4,8,16]
Output: true
Magyarázat: Ha kiválasztjuk a 2 és 4 elemeket, azok bitwise OR-ja 6, amelynek bináris ábrázolása "110", ami egy záró nullát tartalmaz.
Más lehetséges módok az elemek kiválasztására, hogy a bitwise OR bináris ábrázolása záró nullát tartalmazzon: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), és (2, 4, 8, 16).

3. példa:

Input: nums = [1,3,5,7,9]
Output: false
Magyarázat: Nincs lehetséges mód két vagy több elem kiválasztására, hogy a bitwise OR bináris ábrázolása záró nullát tartalmazzon.

Feltételek:

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


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

Válasszuk ki a tömb bármelyik elemét, és fordítsunk fel egy bitet a bináris ábrázolásában. Egy bit felfordítása azt jelenti, hogy a 0-t 1-re vagy fordítva változtatjuk.

Adja meg a műveletek minimálisan szükséges számát ahhoz, hogy a végső tömb összes elemének bitenkénti XOR-ja egyenlő legyen k-val.
Vegye figyelembe, hogy az elemek bináris reprezentációjában a vezető nulla biteket megfordíthatja. Például a (101)_2 szám esetében a negyedik bitet megfordítva (1101)_2-t kapunk.

Példa 1:

Bemenet: nums = [2,1,3,4], k = 1
Kimenet: 2
Magyarázat: A következő műveleteket tudjuk elvégezni:
- Válasszuk ki a 2. elemet, ami 3 == (011)_2, megfordítjuk az első bitet, és megkapjuk (010)_2 == 2. nums [2,1,2,4] lesz.
- Válasszuk ki a 0 elemet, ami 2 == (010)_2, fordítsuk meg a harmadik bitet, és kapjuk (110)_2 = 6. nums [6,1,2,4] lesz.
A végső tömb elemeinek XOR-ja (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Megmutatható, hogy 2 műveletnél kevesebbel nem tudjuk az XOR-t k-val egyenlővé tenni.

2. példa:

Bemenet: nums = [2,0,2,0], k = 0
Kimenet: 0
Magyarázat: A tömb elemeinek XOR-ja (2 XOR 0 XOR 2 XOR 0) == 0 == k. Tehát nincs szükség műveletre.

Korlátozások:

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

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

Válassz ki bármely elemet a tömbből, és változtass meg egy bitet a bináris ábrázolásában. Bit megváltoztatása azt jelenti, hogy egy 0-t 1-re vagy fordítva alakítasz.

Add vissza a minimális műveletek számát, amelyek szükségesek ahhoz, hogy a végső tömb összes elemének bitenkénti XOR-ja egyenlő legyen k-val.
Megjegyzés: Megváltoztathatod a vezető nulla biteket az elemek bináris ábrázolásában is. Például a (101)_2 számnál megváltoztathatod a negyedik bitet, és megkapod (1101)_2-t.

1. példa:

Bemenet: nums = [2,1,3,4], k = 1
Kimenet: 2
Magyarázat: Az alábbi műveleteket hajthatjuk végre:
- Válaszd ki a 2-es elemet, amely 3 == (011)_2, változtasd meg az első bitet és megkapod (010)_2 == 2. nums [2,1,2,4] lesz.
- Válaszd ki a 0-ás elemet, amely 2 == (010)_2, változtasd meg a harmadik bitet és megkapod (110)_2 = 6. nums [6,1,2,4] lesz.
Az elemek XOR-ja a végső tömbben (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Megmutatható, hogy kevesebb mint 2 művelettel nem lehet elérni, hogy az XOR egyenlő legyen k-val.

2. példa:

Bemenet: nums = [2,0,2,0], k = 0
Kimenet: 0
Magyarázat: Az elemek XOR-ja a tömbben (2 XOR 0 XOR 2 XOR 0) == 0 == k. Tehát semmilyen műveletre nincs szükség.

Feltételek:

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

Egy 0-indexelt egész számokból álló nums tömböt és egy pozitív egész számot, k-t kapsz.
Bármennyi alkalommal alkalmazhatod a következő műveletet a tömbön:

Válassz ki bármelyik elemet a tömbből, és flipelj egy bitet annak bináris ábrázolásában. A bit flipelése azt jelenti, hogy egy 0-t 1-re, vagy fordítva, 1-et 0-ra változtatsz.

Térj vissza a minimális műveletek számával, amely szükséges ahhoz, hogy a végső tömb összes elemének bitwise XOR-ja egyenlő legyen k-val.
Ne feledd, hogy a vezető nulla biteket is flipelheted az elemek bináris ábrázolásában. Például, a (101)_2 szám esetén flipelheted a negyedik bitet, és (1101)_2-t kapasz.

Példa 1:

Input: nums = [2,1,3,4], k = 1
Output: 2
Magyarázat: A következő műveleteket végezhetjük el:
- Válasszuk a 2. elemet, amely 3 == (011)_2, flipeljük az első bitet, és (010)_2-t kapunk == 2. A **nums** tömb [2,1,2,4]-re változik.
- Válasszuk a 0. elemet, amely 2 == (010)_2, flipeljük a harmadik bitet, és (110)_2-t kapunk = 6. A **nums** tömb [6,1,2,4]-re változik.
A végső tömb elemeinek XOR-ja (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Bebizonyítható, hogy kevesebb mint 2 művelettel nem tudjuk elérni, hogy az XOR egyenlő legyen k-val.

Példa 2:

 Input: nums = [2,0,2,0], k = 0
Output: 0
Magyarázat: A tömb elemeinek XOR-ja (2 XOR 0 XOR 2 XOR 0) == 0 == k. Így nincs szükség műveletre.

Korlátozások:

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


Adott egy 2D 0-indexált egész számú tömb dimenziói.
Minden i indexre, 0 <= i < dimensions.length, dimensions[i][0] az i téglalap hosszát, dimensions[i][1] pedig a szélességét jelöli.
A leghosszabb átlóval rendelkező téglalap területét adja vissza. Ha több téglalap is rendelkezik a leghosszabb átlóval, akkor annak a téglalapnak a területét adja vissza, amelynek a legnagyobb a területe.

Példa 1:

Bemenet: dimensions = [[9,3],[8,6]]
Kimenet: 48
Magyarázat:
For index = 0, length = 9 and width = 3. Diagonal length = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
For index = 1, length = 8 and width = 6. Diagonal length = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Tehát az 1-es indexű téglalapnak nagyobb az átlóhossza, ezért a terület = 8 * 6 = 48.

Példa 2:

Bemenet: dimensions = [[3,4],[4,3]]
Kimenet: 12
Magyarázat: Az átló hossza mindkettőnél azonos, ami 5, így a maximális terület = 12.

Korlátozások:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

Kapsz egy 2D 0-indexelt egész tömb méreteit.
Minden i indexnél 0 <= i < dimenziók.hosszúság, a méretek[i][0] a hosszát, a méretek[i][1] pedig az i téglalap szélességét jelenti.
Adja vissza a leghosszabb átlójú téglalap területét. Ha több téglalap van a leghosszabb átlóval, akkor adja vissza a legnagyobb területű téglalap területét.

1. példa:

Bemenet: dimensions = [[9,3],[8,6]]
Kimenet: 48
Magyarázat:
Ha index = 0, hosszúság = 9 és szélesség = 3. Átlóhossz = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9,487.
Ha index = 1, hosszúság = 8 és szélesség = 6. Átlóhossz = sqrt(8 * 8 + 6 * 6) = négyzet(100) = 10.
Tehát az 1-es indexű téglalap átlója nagyobb, ezért a terület = 8 * 6 = 48 értéket adjuk vissza.

2. példa:

Bemenet: dimensions = [[3,4],[4,3]]
Kimenet: 12
Magyarázat: Az átló hossza mindkettőnél azonos, ami 5, tehát a maximális terület = 12.

Korlátozások:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100

Kapsz egy 2D 0-indexelt egész tömb méreteit.
Minden i indexnél 0 <= i < dimenziók.hosszúság, a méretek[i][0] a hosszát, a méretek[i][1] pedig az i téglalap szélességét jelenti.
Adja vissza a leghosszabb átlójú téglalap területét. Ha több téglalap van a leghosszabb átlóval, akkor adja vissza a legnagyobb területű téglalap területét.

1. példa:

Bemenet: dimensions = [[9,3], [8,6]]
Kimenet: 48
Magyarázat:
Ha index = 0, hosszúság = 9 és szélesség = 3. Átlóhossz = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9,487.
Ha index = 1, hosszúság = 8 és szélesség = 6. Átlóhossz = sqrt(8 * 8 + 6 * 6) = négyzet(100) = 10.
Tehát az 1-es indexű téglalap átlója nagyobb, ezért a terület = 8 * 6 = 48 értéket adjuk vissza.

2. példa:

Bemenet: dimensions = [[3,4], [4,3]]
Kimenet: 12
Magyarázat: Az átló hossza mindkettőnél azonos, ami 5, tehát a maximális area = 12.

Korlátozások:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100


Kapsz egy 0-indexelt tömböt pozitív egész számokból.
A numok egy résztömbjét eltávolíthatatlannak nevezzük, ha a nums szigorúan növekszik a résztömb eltávolításakor. Például a [3, 4] résztömb az [5, 3, 4, 6, 7] eltávolíthatatlan résztömbje, mert ennek az altömbnek az eltávolítása az [5, 3, 4, 6, 7] tömböt [5, 6, 7] -re változtatja, ami szigorúan növekszik.
A számok eltávolíthatatlan résztömbjeinek teljes számát adja eredményül.
Vegye figyelembe, hogy egy üres tömb szigorúan növekszik.
A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 10
Magyarázat: A 10 eltávolíthatatlan résztömb a következő: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] és [1,2,3,4], mert ezen altömbök bármelyikének eltávolításakor a számok szigorúan növekednek. Ne feledje, hogy üres résztömböt nem jelölhet ki.

2. példa:

Bemenet: nums = [6,5,7,8]
Kimenet: 7
Magyarázat: A 7 eltávolíthatatlan résztömb a következő: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] és [6,5,7,8].
Megmutatható, hogy csak 7 eltávolíthatatlan altömb van a számokban.

3. példa:

Bemenet: nums = [8,7,6,6]
Kimenet: 3
Magyarázat: A 3 eltávolíthatatlan résztömb a következő: [8,7,6], [7,6,6] és [8,7,6,6]. Megjegyezzük, hogy a [8,7] nem kiiktathatatlan résztömb, mert a [8,7] eltávolítása után a numok [6,6] lesznek, amely növekvő sorrendbe van rendezve, de nem szigorúan növekszik.

Korlátok:

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

Kapsz egy 0-indexelt pozitív egész számokból álló tömböt.
A számokból álló alcsoportot incremovable-nak nevezzük, ha a számok az altömb eltávolításakor szigorúan növekszik. Például a [3, 4] altömb az [5, 3, 4, 6, 7] incredibly altömbje, mivel ennek az altömbnek az eltávolítása az [5, 3, 4, 6, 7] tömböt [5, 6, 7], amely szigorúan növekszik.
Visszaadja a számok eltávolítható altömbeinek teljes számát.
Vegye figyelembe, hogy az üres tömb szigorúan növekvőnek minősül.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums= [1,2,3,4]
Kimenet: 10
Magyarázat: A 10 eltávolítható altömb a következő: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] és [1,2,3,4], mert ezen altömbök bármelyikének eltávolításával a számok szigorúan növekszik. Vegye figyelembe, hogy nem választhat ki üres altömböt.

2. példa:

Bemenet: nums = [6,5,7,8]
Kimenet: 7
Magyarázat: A 7 eltávolítható altömb a következő: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] és [6,5,7 ,8].
Megmutatható, hogy számokban csak 7 eltávolítható altömb van.

3. példa:

Bemenet: nums = [8,7,6,6]
Kimenet: 3
Magyarázat: A 3 eltávolítható altömb a következő: [8,7,6], [7,6,6] és [8,7,6,6]. Megjegyzendő, hogy a [8,7] incredibly altömb, mert a [8,7] eltávolítása után a számokból [6,6] lesz, ami növekvő sorrendben van rendezve, de nem szigorúan növekszik.

Korlátozások:

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

Kapsz egy 0-indexelt pozitív egész számokból álló tömböt.
A számokból álló alcsoportot incremovable-nek nevezzük, ha a számok az altömb eltávolításakor szigorúan növekszik. Például a [3, 4] altömb az [5, 3, 4, 6, 7] nem eltávolítható altömbje, mivel ennek az altömbnek az eltávolítása az [5, 3, 4, 6, 7] tömböt [5, 6, 7], amely szigorúan növekszik.
Visszaadja a számok eltávolítható altömbeinek teljes számát.
Vegye figyelembe, hogy az üres tömb szigorúan növekvőnek minősül.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

Példa 1:

Bemenet: nums = [1,2,3,4]
Kimenet: 10
Magyarázat: A 10 eltávolítható altömb a következő: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] és [1,2,3,4], mert ezen altömbök bármelyikének eltávolításával a számok szigorúan növekednek. Vegye figyelembe, hogy nem választhat ki üres altömböt.

Példa 2:

Bemenet: nums = [6,5,7,8]
Kimenet: 7
Magyarázat: A 7 eltávolítható altömb a következő: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] és [6,5,7 ,8].
Megmutatható, hogy számokban csak 7 eltávolítható altömb van.

Példa 3:

Bemenet: nums = [8,7,6,6]
Kimenet: 3
Magyarázat: A 3 eltávolítható altömb a következő: [8,7,6], [7,6,6] és [8,7,6,6]. Megjegyzendő, hogy a [8,7] nem eltávolítható altömb, mert a [8,7] eltávolítása után a számokból [6,6] lesz, ami növekvő sorrendben van rendezve, de nem szigorúan növekszik.

Korlátozások:

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


Egy 0-indextől kezdődő egész számokból álló tömböt, `nums`-t, és egy egész számot, `k`-t kapunk.
Egy művelet során kiválaszthatjuk a `nums` bármely indexét, `i`, úgy, hogy 0 <= i < nums.length - 1, és kicserélhetjük `nums[i]` és `nums[i + 1]` elemeket `nums[i] & nums[i + 1]` egyetlen előfordulására, ahol a `&` a bitenkénti ÉS operátort jelenti.
Adjuk vissza a minimális lehetséges értékét a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

1. példa:

Input: nums = [3,5,3,2,7], k = 2
Output: 3
Magyarázat: Hajtsuk végre a következő műveleteket:
1. Cserélje le a nums[0] és a nums[1] a (nums[0] & nums[1]) értékre, hogy a számok nums legyenek [1,3,2,7]-vel.
2. Cserélje le a nums[2] és a nums[3] a (nums[2] és a nums[3]) értékre, hogy a számok nums legyenek [1,3,2]-vel.
A végső tömb bitenkénti VAGY-ja 3.
Megmutatható, hogy 3 a minimális lehetséges értéke a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

2. példa:

Input: nums = [7,3,15,14,2,8], k = 4
Output: 2
Magyarázat: Hajtsuk végre a következő műveleteket:
1. Cserélje le a nums[0] és a nums[1] a (nums[0] & nums[1]) értékre, hogy a nums egyenlők legyenek [3,15,14,2,8]-val.
2. Cserélje le a nums[0] és a nums[1] a (nums[0] & nums[1]) értékre, hogy a nums egyenlők legyenek [3,14,2,8]-val.
3. Cserélje le a nums[0] és a nums[1] a (nums[0] & nums[1]) értékre, hogy a nums egyenlők legyenek [2,2,8]-val.
4. Cserélje le a nums[1] és nums[2] a (nums[1] és nums[2]) értékre, hogy a nums egyenlők legyenek [2,0]-val.
A végső tömb bitenkénti VAGY-ja 2.
Megmutatható, hogy 2 a minimális lehetséges értéke a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

3. példa:

Input: nums = [10,7,10,3,9,14,9,4], k = 1
Output: 15
Magyarázat: Művelet alkalmazása nélkül a `nums` bitenkénti VAGY-ja 15.
Megmutatható, hogy 15 a minimális lehetséges értéke a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

Feltételek:

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

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Egy műveletben kiválaszthatja a számok bármely i indexét úgy, hogy 0 <= i < nums.length - 1, és helyettesítse a nums[i] és nums[i + 1] számokat a nums[i] & nums[i + 1] egyetlen előfordulásával, ahol & a bitenkénti AND operátort jelöli.
A számok fennmaradó elemei bitenkénti VAGY értékének minimális lehetséges értékét adja eredményül legfeljebb k művelet alkalmazása után.

1. példa:

Bemenet: nums = [3,5,3,2,7], k = 2
Kimenet: 3
Magyarázat: Hajtsuk végre a következő műveleteket:
1. Cserélje ki nums[0] és nums[1] a (nums[0] & nums[1]) kifejezésre, hogy a számok egyenlőek legyenek [1,3,2,7].
2. Cserélje ki nums[2] és nums[3] a (nums[2] & nums[3]) kifejezésre, hogy nums egyenlőek legyenek [1,3,2].
A végső tömb bitenkénti vagy értéke 3.
Megmutatható, hogy 3 a numok fennmaradó elemei bitenkénti OR értékének minimális lehetséges értéke legfeljebb k művelet alkalmazása után.
2. példa:

Bemenet: nums = [7,3,15,14,2,8], k = 4
Kimenet: 2
Magyarázat: Hajtsuk végre a következő műveleteket:
1. Cserélje ki nums[0] és nums[1] a (nums[0] & nums[1]) kifejezésre, hogy nums egyenlőek legyenek [3,15,14,2,8].
2. Cserélje ki nums [0] és nums [1] a következőre: (nums [0] & nums [1]) úgy, hogy nums egyenlőek legyenek [3,14,2,8].
3. Cserélje ki nums[0] és nums[1] a (nums[0] & nums[1]) kifejezésre, hogy nums egyenlőek legyenek [2,2,8].
4. Cserélje ki nums [1] és nums [2] a következőre: (nums[1] & nums[2]), hogy nums egyenlőek legyenek [2,0].
A végső tömb bitenkénti vagy értéke 2.
Megmutatható, hogy 2 a numok fennmaradó elemeinek bitenkénti OR minimális lehetséges értéke a legtöbb k művelet alkalmazása után.

3. példa:

Bemenet:nums = [10,7,10,3,9,14,9,4], k = 1
Kimenet: 15
Magyarázat: Műveletek alkalmazása nélkül a bitenkénti vagy nums értéke 15.
Megmutatható, hogy 15 a numok fennmaradó elemei bitenkénti VAGY értékének minimális lehetséges értéke legfeljebb k művelet alkalmazása után.

Korlátok:

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

Egy 0-indextől kezdődő egész számokból álló tömböt, `nums`-t, és egy egész számot, `k`-t kapunk.
Egy művelet során kiválaszthatjuk a `nums` bármely indexét, `i`, úgy, hogy 0 <= i < nums.length - 1, és kicserélhetjük `nums[i]` és `nums[i + 1]` elemeket `nums[i] & nums[i + 1]` egyetlen előfordulására, ahol a `&` a bitenkénti ÉS operátort jelenti.
Add vissza a minimális lehetséges értékét a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

Példa 1:

Bemenet: nums = [3,5,3,2,7], k = 2
Kimenet: 3
Magyarázat: Hajtsd végre a következő műveleteket:
1. Cseréld le `nums[0]` és `nums[1]` elemeket `(nums[0] & nums[1])`-re, így `nums` egyenlő lesz `[1,3,2,7]`.
2. Cseréld le `nums[2]` és `nums[3]` elemeket `(nums[2] & nums[3])`-re, így `nums` egyenlő lesz `[1,3,2]`.
A végső tömb bitenkénti VAGY-ja 3.
Megmutatható, hogy 3 a minimális lehetséges értéke a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

Példa 2:

Bemenet: nums = [7,3,15,14,2,8], k = 4
Kimenet: 2
Magyarázat: Hajtsuk végre a következő műveleteket:
1. Cseréld le `nums[0]` és `nums[1]` elemeket `(nums[0] & nums[1])`-re, így `nums` egyenlő lesz `[3,15,14,2,8]`.
2. Cseréld le `nums[0]` és `nums[1]` elemeket `(nums[0] & nums[1])`-re, így `nums` egyenlő lesz `[3,14,2,8]`.
3. Cseréld le `nums[0]` és `nums[1]` elemeket `(nums[0] & nums[1])`-re, így `nums` egyenlő lesz `[2,2,8]`.
4. Cseréld le `nums[1]` és `nums[2]` elemeket `(nums[1] & nums[2])`-re, így `nums` egyenlő lesz `[2,0]`.
A végső tömb bitenkénti VAGY-ja 2.
Megmutatható, hogy 2 a minimális lehetséges értéke a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

Példa 3:

Bemenet: nums = [10,7,10,3,9,14,9,4], k = 1
Kimenet: 15
Magyarázat: Művelet alkalmazása nélkül a `nums` bitenkénti VAGY-ja 15.
Megmutatható, hogy 15 a minimális lehetséges értéke a fennmaradó `nums` elemek bitenkénti VAGY-jának, legfeljebb `k` művelet alkalmazása után.

Korlátozások:

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


Kapsz egy tömböt pozitív egész számokból, n hosszúságú számokat.
A sokszög egy zárt sík alak, amelynek legalább 3 oldala van. A sokszög leghosszabb oldala kisebb, mint a többi oldalának összege.
Ezzel szemben, ha k (k >= 3) pozitív valós száma van a_1, a_2, a_3, ..., a_k ahol a_1 <= a_2 <= a_3 <= ... <= a_k és a_1 + a_2 + a_3 + ... + a_k-1 > a_k, akkor mindig létezik egy sokszög k oldallal, amelynek hossza a_1, a_2, a_3,  ..., a_k.
A sokszög kerülete az oldalak hosszának összege.
Egy olyan sokszög lehető legnagyobb kerületét adja vissza, amelynek oldalai numokból alakíthatók ki, vagy -1-et, ha nem lehet sokszöget létrehozni.

1. példa:

Bemenet: nums = [5,5,5]
Kimenet: 15
Magyarázat: Az egyetlen lehetséges sokszögnek, amely számokból készíthető, 3 oldala van: 5, 5 és 5. A kerület 5 + 5 + 5 = 15.

2. példa:

Bemenet: nums = [1,12,1,2,5,50,3]
Kimenet: 12
Magyarázat: A legnagyobb kerületű sokszögnek, amely számokból állhat, 5 oldala van: 1, 1, 2, 3 és 5. A kerület 1 + 1 + 2 + 3 + 5 = 12.
Nem lehet olyan sokszögünk, amelynek leghosszabb oldala 12 vagy 50, mert nem lehet 2 vagy több kisebb oldalt felvenni, amelyek nagyobb összegűek, mint bármelyikük.
Kimutatható, hogy a lehető legnagyobb kerület 12.

3. példa:

Bemenet: nums = [5,5,50]
Kimenet: -1
Magyarázat: A számokból nem lehet sokszöget alkotni, mivel a sokszögnek legalább 3 oldala van, és 50 > 5 + 5.

Korlátok:

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

Egy n hosszúságú pozitív egész számokból álló tömböt kapunk.
A sokszög egy zárt síkú figura, amelynek legalább 3 oldala van. Egy sokszög leghosszabb oldala kisebb, mint a többi oldalának összege.
Fordítva, ha van k (k >= 3) pozitív valós szám a_1, a_2, a_3, ..., a_k ahol a_1 <= a_2 <= a_3 <= ... <= a_k és a_1 + a_2 + a_3 + . .. + a_k-1 > a_k, akkor mindig létezik egy k oldalú sokszög, amelynek hossza a_1, a_2, a_3, ..., a_k.
Egy sokszög kerülete az oldalak hosszának összege.
Egy olyan sokszög lehetséges legnagyobb kerületét adja vissza, amelynek oldalai számokból alakíthatók ki, vagy -1-et, ha nem lehet sokszöget létrehozni.

1. példa:

Bemenet: nums = [5,5,5]
Kimenet: 15
Magyarázat: Az egyetlen lehetséges sokszögnek, amely számokból készíthető, 3 oldala van: 5, 5 és 5. A kerülete 5 + 5 + 5 = 15.

2. példa:

Bemenet: nums = [1,12,1,2,5,50,3]
Kimenet: 12
Magyarázat: A számokból készíthető legnagyobb kerületű sokszögnek 5 oldala van: 1, 1, 2, 3 és 5. A kerülete 1 + 1 + 2 + 3 + 5 = 12.
Nem lehet olyan sokszög, amelynek a leghosszabb oldala 12 vagy 50, mert nem lehet 2 vagy több kisebb oldalt belefoglalni, amelyek összege bármelyiknél nagyobb.
Megmutatható, hogy a lehető legnagyobb kerület a 12.

3. példa:

Bemenet: nums = [5,5,50]
Kimenet: -1
Magyarázat: Számokból nem lehet sokszöget képezni, mivel egy sokszögnek legalább 3 oldala van, és 50 > 5 + 5.

Korlátozások:

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

Egy n hosszúságú pozitív egész számokból álló tömböt kapunk.
A sokszög egy zárt síkú alakzat, amelynek legalább 3 oldala van. Egy sokszög leghosszabb oldala kisebb, mint a többi oldalának összege.
Fordítva, ha van k (k >= 3) pozitív valós szám a_1, a_2, a_3, ..., a_k ahol a_1 <= a_2 <= a_3 <= ... <= a_k és a_1 + a_2 + a_3 + . .. + a_k-1 > a_k, akkor mindig létezik egy k oldalú sokszög, amelynek hossza a_1, a_2, a_3, ..., a_k.
Egy sokszög kerülete az oldalak hosszának összege.
Egy olyan sokszög lehetséges legnagyobb kerületét adja vissza, amelynek oldalai számokból alakíthatók ki, vagy -1-et, ha nem lehet sokszöget létrehozni.

Példa 1:

Bemenet: nums = [5,5,5]
Kimenet: 15
Magyarázat: Az egyetlen lehetséges sokszögnek, amely számokból készíthető, 3 oldala van: 5, 5 és 5. A kerülete 5 + 5 + 5 = 15.

Példa 2:

Bemenet: nums = [1,12,1,2,5,50,3]
Kimenet: 12
Magyarázat: A számokból készíthető legnagyobb kerületű sokszögnek 5 oldala van: 1, 1, 2, 3 és 5. A kerülete 1 + 1 + 2 + 3 + 5 = 12.
Nem lehet olyan sokszög, amelynek a leghosszabb oldala 12 vagy 50, mert nem lehet 2 vagy több kisebb oldalt belefoglalni, amelyek összege bármelyiknél nagyobb.
Megmutatható, hogy a lehető legnagyobb kerület a 12.

Példa 3:

Bemenet: nums = [5,5,50]
Kimenet: -1
Magyarázat: Számokból nem lehet sokszöget képezni, mivel egy sokszögnek legalább 3 oldala van, és 50 > 5 + 5.

Korlátozások:

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