Két karakterlánctömböt kap: wordsContainer tömb és wordsQuery.
Minden wordsQuery[i] esetében meg kell találnia egy karakterláncot a wordsContainer tömb fájlból, amely a leghosszabb közös utótaggal rendelkezik a wordsQuery[i] utótaggal. Ha két vagy több sztring van a wordsContainer tömb mezőben, amelyek a leghosszabb közös utótaggal rendelkeznek, keresse meg a legkisebb hosszúságú sztringet. Ha két vagy több ilyen sztring azonos legkisebb hosszúságú, keresse meg azt, amelyik korábban előfordult a wordsContainer tömb fájlban.
Egész számok tömbjét adja vissza, ahol ans[i] annak a karakterláncnak az indexe a wordsContainer tömb mezőben, amely a leghosszabb közös utótaggal rendelkezik a wordsQuery[i] utótaggal.

1. példa:

Bemenet: wordsContainer tömb = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Kimenet: [1,1,1]
Magyarázat:
Nézzük meg az egyes szavakatQuery[i] külön-külön:

A wordsQuery[0] = "cd" esetén a wordsContainer tömb leghosszabb közös "cd" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen találhatók. Ezek közül a válasz az 1-es indexű karakterlánc, mert ennek a legrövidebb hossza 3.
A wordsQuery[1] = "bcd" esetében a wordsContainer tömb leghosszabb közös "bcd" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen vannak. Ezek közül a válasz az 1-es indexű karakterlánc, mert ennek a legrövidebb hossza 3.
A wordsQuery[2] = "xyz" esetében a wordsContainer tömb nem tartalmaz közös utótaggal rendelkező karakterláncot. Ezért a leghosszabb közös utótag a "", amely a 0, 1 és 2 indexű karakterláncokkal van megosztva. Ezek közül a válasz az 1-es indexű karakterlánc, mert ennek a legrövidebb hossza 3.

2. példa:

Bemenet: wordsContainer tömb = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Kimenet: [2,0,2]
Magyarázat:
Nézzük meg az egyes wordsQuery[i] külön-külön:

A wordsQuery[0] = "gh" esetén a wordsContainer tömb leghosszabb közös "gh" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen vannak. Ezek közül a válasz a 2-es indexű karakterlánc, mert ennek a legrövidebb hossza 6.
A wordsQuery[1] = "acbfgh" esetében csak a 0 indexben lévő karakterlánc osztozik a leghosszabb közös "fgh" utótaggal. Ezért ez a válasz, még akkor is, ha a 2. indexben lévő karakterlánc rövidebb.
A wordsQuery[2] = "acbfegh" esetén a wordsContainer tömb leghosszabb közös "gh" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen találhatók. Ezek közül a válasz a 2-es indexű karakterlánc, mert ennek a legrövidebb hossza 6.

Korlátok:

1 <= wordsContainer tömb.length, wordsQuery.length <= 10^4
1 <= wordsContainer tömb[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer tömb[i] csak kisbetűs angol betűkből áll.
wordsQuery[i] csak kisbetűs angol betűkből áll.
A wordsContainer[i].length összege legfeljebb 5 * 10^5.
A szavakLekérdezés[i].length összege legfeljebb 5 * 10^5.

Két tömböt kapsz a wordsContainer és a wordsQuery karakterláncokból.
Minden egyes WordQuery[i] szóhoz meg kell találnia egy olyan karakterláncot awordContainerből, amelynek a leghosszabb közös utótagja van a Query[i] szavakkal. Ha két vagy több karakterlánc van a wordsContainerben, amelyek a leghosszabb közös utótaggal rendelkeznek, keresse meg a legkisebb hosszúságú karakterláncot. Ha van két vagy több ilyen karakterlánc, amelyeknek azonos a legkisebb hossza, keresse meg azt, amelyik korábban előfordult a wordsContainerben.
Egy ans egész számokból álló tömböt ad vissza, ahol az ans[i] annak a wordsContainer-ben lévő karakterláncnak az indexe, amelyiknek a leghosszabb közös utótagja van a Query[i] szavakkal.

1. példa:

Bemenet: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Kimenet: [1,1,1]
Magyarázat:
Nézzük meg az egyes Lekérdezés[i] szavakat külön:

WordsQuery[0] = "cd" esetén a WordsContainerből a leghosszabb közös "cd" utótaggal rendelkező karakterláncok a 0, 1 és 2 indexeknél vannak. Ezek közül a válasz az 1. indexnél lévő karakterlánc, mivel ennek a legrövidebb a 3.
A wordsQuery[1] = "bcd" esetén a wordsContainerből a leghosszabb közös "bcd" utótaggal rendelkező karakterláncok a 0, 1 és 2 indexeknél találhatók. Ezek közül a válasz az 1. indexnél lévő karakterlánc, mivel ennek a legrövidebb a 3.
A wordsQuery[2] = "xyz" esetén nincs olyan karakterlánc a wordsContainerből, amely közös utótaggal rendelkezik. Ezért a leghosszabb közös utótag a "", amelyet a 0, 1 és 2 indexű karakterláncokkal osztanak meg. Ezek közül a válasz az 1. indexű karakterlánc, mivel ennek a legrövidebb a 3.

2. példa:

Bemenet: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Kimenet: [2,0,2]
Magyarázat:
Nézzük meg az egyes Lekérdezés[i] szavakat külön:

A WordsQuery[0] = "gh" esetén a wordsContainerből a leghosszabb közös "gh" utótaggal rendelkező karakterláncok a 0, 1 és 2 indexeknél találhatók. Ezek közül a válasz a 2. indexnél lévő karakterlánc, mivel ennek a legrövidebb a 6.
WordsQuery[1] = "acbfgh" esetén csak a 0 indexű karakterlánc osztja meg a leghosszabb közös "fgh" utótagot. Ezért ez a válasz, bár a 2. indexnél rövidebb a karakterlánc.
A WordsQuery[2] = "acbfegh" esetén a wordsContainerből a leghosszabb közös "gh" utótaggal rendelkező karakterláncok a 0, 1 és 2 indexeknél találhatók. Ezek közül a válasz a 2. indexnél lévő karakterlánc, mivel ennek a legrövidebb a 6.

Korlátozások:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] csak kisbetűs angol betűkből áll.
wordsQuery[i] csak kisbetűs angol betűkből áll.
A wordsContainer[i].length összege legfeljebb 5 * 10^5.
A wordsQuery[i].length összege legfeljebb 5 * 10^5.

Két karakterlánctömböt kap: wordsContainer és wordsQuery.
Minden wordsQuery[i] esetében meg kell találnia egy karakterláncot a wordsContainer tömbből, amely a leghosszabb közös utótaggal rendelkezik a wordsQuery[i] utótaggal. Ha két vagy több sztring van a wordsContainer tömbben, amelyek a leghosszabb közös utótaggal rendelkeznek, keresse meg a legkisebb hosszúságú sztringet. Ha két vagy több ilyen sztring azonos legkisebb hosszúságú, keresse meg azt, amelyik korábban előfordult a wordsContainer fájlban.
Egy egész számokból álló tömböt ad vissza, ahol ans[i] annak a karakterláncnak az indexe a wordsContainer tömbben, amely a leghosszabb közös utótaggal rendelkezik a wordsQuery[i] utótaggal.

1. példa:

Bemenet: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Kimenet: [1,1,1]
Magyarázat:
Nézzük meg az egyes wordsQuery[i]-t külön-külön:

A wordsQuery[0] = "cd" esetén a wordsContainer leghosszabb közös "cd" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen találhatók. Ezek közül a válasz az 1-es indexű karakterlánc, mert ennek a legrövidebb hossza 3.
A wordsQuery[1] = "bcd" esetében a wordsContainer leghosszabb közös "bcd" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen vannak. Ezek közül a válasz az 1-es indexű karakterlánc, mert ennek a legrövidebb hossza 3.
A wordsQuery[2] = "xyz" esetében a wordsContainer nem tartalmaz közös utótaggal rendelkező karakterláncot. Ezért a leghosszabb közös utótag a "", amely a 0, 1 és 2 indexű karakterláncokkal van megosztva. Ezek közül a válasz az 1-es indexű karakterlánc, mert ennek a legrövidebb hossza 3.

2. példa:

Bemenet: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Kimenet: [2,0,2]
Magyarázat:
Nézzük meg az egyes wordsQuery[i] külön-külön:

A wordsQuery[0] = "gh" esetén a wordsContainer leghosszabb közös "gh" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen vannak. Ezek közül a válasz a 2-es indexű karakterlánc, mert ennek a legrövidebb hossza 6.
A wordsQuery[1] = "acbfgh" esetében csak a 0 indexben lévő karakterlánc osztozik a leghosszabb közös "fgh" utótaggal. Ezért ez a válasz, még akkor is, ha a 2. indexben lévő karakterlánc rövidebb.
A wordsQuery[2] = "acbfegh" esetén a wordsContainer leghosszabb közös "gh" utótaggal rendelkező karakterláncai a 0, 1 és 2 indexen találhatók. Ezek közül a válasz a 2-es indexű karakterlánc, mert ennek a legrövidebb hossza 6.

Korlátok:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] csak kisbetűs angol betűkből áll.
wordsQuery[i] csak kisbetűs angol betűkből áll.
A wordsContainer[i].length összege legfeljebb 5 * 10^5.
A wordsQuery[i].length összege legfeljebb 5 * 10^5.


Egy egész szám, amely osztható a számjegyei összegével, Harshad-számnak nevezik. Adott egy x egész szám. Add vissza az x számjegyeinek összegét, ha x Harshad-szám, különben add vissza a -1-et.

Példa 1:

Bemenet: x = 18
Kimenet: 9
Magyarázat:
Az x számjegyeinek összege 9. A 18 osztható 9-cel. Tehát a 18 Harshad-szám és a válasz 9.

Példa 2:

Bemenet: x = 23
Kimenet: -1
Magyarázat:
Az x számjegyeinek összege 5. A 23 nem osztható 5-tel. Tehát a 23 nem Harshad-szám és a válasz -1.

Korlátozások:

1 <= x <= 100

A számjegyei összegével osztható egész számot Harshad-számnak mondjuk. Adott egy x egész szám. Adja vissza x számjegyeinek összegét, ha x Harshad-szám, ellenkező esetben -1-et ad vissza.

1. példa:

Bemenet: x = 18
Kimenet: 9
Magyarázat:
Az x számjegyeinek összege 9. A 18 osztható 9-cel. Tehát a 18 egy Harshad-szám, és a válasz 9.

2. példa:

Bemenet: x = 23
Kimenet: -1
Magyarázat:
Az x számjegyeinek összege 5. A 23 nem osztható 5-tel. Tehát a 23 nem Harshad-szám, és a válasz -1.

Korlátozások:

1 <= x <= 100

A számjegyeinek összegével osztható egész számot Harshad-számnak nevezzük. Adott egy egész szám x. Adja vissza x számjegyeinek összegét, ha x egy Harshad-szám, ellenkező esetben adja vissza -1-et.

Példa 1:

Bemenet: x = 18
Kimenet: 9
Magyarázat:
Tehát a 18 egy Harshad-szám, és a válasz 9.

Példa 2:

Bemenet: x = 23
Kimenet: -1
Magyarázat:
A 23 nem osztható 5-tel. Tehát a 23 nem Harshad-szám, és a válasz -1.

Korlátozások:

1 <= x <= 100


Adott egy nums bináris tömb.
Egy résztömböt váltakozónak nevezünk, ha a résztömbben nincs két szomszédos elem, amelynek értéke megegyezik.
Adja vissza a nums-ban lévő váltakozó altömbök számát.

Példa 1:

Bemenet: nums = [0,1,1,1]
Kimenet: 5
Magyarázat:
A következő altáblák váltakoznak: [0], [1], [1], [1] és [0,1].

Példa 2:

Bemenet: nums = [1,0,1,0]
Kimenet: 10
Magyarázat:
A tömb minden altáblája váltakozó. Összesen 10 lehetséges altömböt választhatunk.

Korlátozások:

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

Kapsz egy bináris tömb számokat.
Az altömböt váltakozónak nevezzük, ha az altömbben nincs két szomszédos elemnek azonos értéke.
A váltakozó altömbök számát adja vissza számokban.

1. példa:

Bemenet: nums  = [0,1,1,1]
Kimenet: 5
Magyarázat:
A következő altömbök váltakoznak: [0], [1], [1], [1] és [0,1].

2. példa:

Bemenet: nums  = [1,0,1,0]
Kimenet: 10
Magyarázat:
A tömb minden altömbje váltakozik. 10 lehetséges altömb közül választhatunk.

Korlátozások:

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

Bináris tömb numokat kap.
Egy résztömböt váltakozónak nevezünk, ha a résztömb két szomszédos elemének nincs azonos értéke.
A váltakozó résztömbök számát adja vissza számban.

1. példa:

Bemenet: nums = [0,1,1,1]
Kimenet: 5
Magyarázat:
A következő résztömbök váltakoznak: [0], [1], [1], [1] és [0,1].

2. példa:

Bemenet: nums = [1,0,1,0]
Kimenet: 10
Magyarázat:
A tömb minden résztömbje váltakozik. 10 lehetséges altömb közül választhatunk.

Korlátok:

1 <= nums.length <= 10^5
A nums[i] értéke 0 vagy 1.


Kapunk egy tömbpontokat, amelyek egy 2D sík egyes pontjainak egész koordinátáit reprezentálják, ahol pontok[i] = [x_i, y_i].
A két pont közötti távolság a manhattani távolságuk.
Pontosan egy pont eltávolításával adja vissza bármely két pont közötti maximális távolság minimális lehetséges értékét.

1. példa:

Bemenet: points = [[3,10], [5,15], [10,2], [4,4]]
Kimenet: 12
Magyarázat:
A maximális távolság az egyes pontok eltávolítása után a következő:

A 0^-edik pont eltávolítása után a maximális távolság az (5, 15) és (10, 2) pontok között van, ami |5 - 10| + |15 - 2| = 18.
Az 1^. pont eltávolítása után a maximális távolság a (3, 10) és (10, 2) pontok között van, ami |3 - 10| + |10 - 2| = 15.
A 2^. pont eltávolítása után a maximális távolság az (5, 15) és (4, 4) pontok között van, ami |5 - 4| + |15 - 4| = 12.
A 3^. pont eltávolítása után a maximális távolság az (5, 15) és (10, 2) pontok között van, ami |5 - 10| + |15 - 2| = 18.

12 a legkisebb lehetséges maximális távolság bármely két pont között pontosan egy pont eltávolítása után.

2. példa:

Bemenet: points = [[1,1],[1,1],[1,1]]
Kimenet: 0
Magyarázat:
Bármely pont eltávolítása azt eredményezi, hogy a két pont közötti maximális távolság 0.

Korlátozások:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

Kapunk egy tömbpontokat, amelyek egy 2D sík egyes pontjainak egész koordinátáit reprezentálják, ahol points[i] = [x_i, y_i].
A két pont közötti távolság a manhattani távolságuk.
Pontosan egy pont eltávolításával adja vissza a két pont közötti maximális távolság minimális lehetséges értékét.

1. példa:

Bemenet: points = [[3,10], [5,15], [10,2], [4,4]]
Kimenet: 12
Magyarázat:
A maximális távolság az egyes pontok eltávolítása után a következő:

Ha a 0. pontot eltávolítjuk, a maximális távolság a (5, 15) és (10, 2) pontok között van, amely |5 - 10| + |15 - 2| = 18.
Ha az 1. pontot eltávolítjuk, a maximális távolság a (3, 10) és (10, 2) pontok között van, amely |3 - 10| + |10 - 2| = 15.
Ha a 2. pontot eltávolítjuk, a maximális távolság a (5, 15) és (4, 4) pontok között van, amely |5 - 4| + |15 - 4| = 12.
Ha a 3. pontot eltávolítjuk, a maximális távolság a (5, 15) és (10, 2) pontok között van, amely |5 - 10| + |15 - 2| = 18.

12 a legkisebb lehetséges maximális távolság bármely két pont között pontosan egy pont eltávolítása után.

2. példa:

Bemenet: points = [[1,1],[1,1],[1,1]]
Kimenet: 0
Magyarázat:
Bármely pont eltávolítása azt eredményezi, hogy a két pont közötti maximális távolság 0.

Korlátozások:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

Egy 2D-s síkon található pontok egész számú koordinátáit reprezentáló points tömböt kapunk, ahol a points[i] = [x_i, y_i].
Két pont közötti távolságot Manhattan-távolságként határozzuk meg.
Adja vissza a két tetszőleges pont közötti maximális távolság minimálisan lehetséges értékét, pontosan egy pont eltávolításával.

1. példa:

Bemenet: points = [[3,10],[5,15],[10,2],[4,4]]
Kimenet: 12
Magyarázat:
A maximális távolság az egyes pontok eltávolítása után a következő:

A 0^. pont eltávolítása után a maximális távolság az (5, 15) és (10, 2) pontok között van, ami |5 - 10| + |15 - 2| = 18.
Az 1^. pont eltávolítása után a legnagyobb távolság a (3, 10) és a (10, 2) pontok között van, ami |3 - 10| + |10 - 2| = 15.
A 2^. pont eltávolítása után a legnagyobb távolság az (5, 15) és (4, 4) pontok között van, ami |5 - 4| + |15 - 4| = 12.
A 3^. pont eltávolítása után a legnagyobb távolság az (5, 15) és (10, 2) pontok között van, ami |5 - 10| + |15 - 2| = 18.

Pontosan egy pont eltávolítása után a 12 a legkisebb lehetséges maximális távolság két pont között.

2. példa:

Bemenet: points = [[1,1],[1,1],[1,1]]
Kimenet: 0
Magyarázat:
Ha bármelyik pontot eltávolítjuk, akkor a két pont közötti maximális távolság 0 lesz.

Korlátozások:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8


Egész számokból álló tömböt kapsz. A számok leghosszabb altömbjének hosszát adja vissza, amely vagy szigorúan növekszik, vagy szigorúan csökken.

1. példa:

Bemenet: nums = [1,4,3,3,2]
Kimenet: 2
Magyarázat:
A számok szigorúan növekvő altömbjei: [1], [2], [3], [3], [4] és [1,4].
A számok szigorúan csökkenő altömbjei: [1], [2], [3], [3], [4], [3,2] és [4,3].
Ezért visszaadjuk a 2-t.

2. példa:

Bemenet: nums = [3,3,3,3]
Kimenet: 1
Magyarázat:
A számok szigorúan növekvő altömbjei: [3], [3], [3] és [3].
A számok szigorúan csökkenő altömbjei a [3], [3], [3] és [3].
Ezért visszaadjuk az 1-et.

3. példa:

Bemenet: nums = [3,2,1]
Kimenet: 3
Magyarázat:
A számok szigorúan növekvő altömbjei: [3], [2] és [1].
A számok szigorúan csökkenő altömbjei: [3], [2], [1], [3,2], [2,1] és [3,2,1].
Ezért visszaadjuk a 3-at.

Korlátozások:

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

Egész számok tömbjét kapja. A számok leghosszabb résztömbjének hosszát adja eredményül, amely vagy szigorúan növekszik, vagy szigorúan csökken.

1. példa:

Bemenet: nums = [1,4,3,3,2]
Kimenet: 2
Magyarázat:
A numok szigorúan növekvő résztömbjei a következők: [1], [2], [3], [3], [4] és [1,4].
A numok szigorúan csökkenő résztömbjei a következők: [1], [2], [3], [3], [4], [3,2] és [4,3].
Ezért visszatérünk 2.

2. példa:

Bemenet: nums = [3,3,3,3]
Kimenet: 1
Magyarázat:
A numok szigorúan növekvő résztömbjei a [3], [3], [3] és [3].
A numok szigorúan csökkenő résztömbjei a [3], [3], [3] és [3].
Ezért visszatérünk 1.

3. példa:

Bemenet: nums = [3,2,1]
Kimenet: 3
Magyarázat:
A numok szigorúan növekvő résztömbjei a [3], [2] és [1].
A numok szigorúan csökkenő résztömbjei a következők: [3], [2], [1], [3,2], [2,1] és [3,2,1].
Ezért visszatérünk 3.

Korlátok:

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

Egy egész számokat tartalmazó nums tömböt kapsz. Térj vissza a leghosszabb szigorúan növekvő vagy szigorúan csökkenő nums részhalmaz hosszával.

Példa 1:

Bemenet: nums = [1,4,3,3,2]
Kimenet: 2
Magyarázat:
A nums szigorúan növekvő részhalmazai: [1], [2], [3], [3], [4], és [1,4].
A nums szigorúan csökkenő részhalmazai: [1], [2], [3], [3], [4], [3,2], és [4,3].
Ezért a visszatérési érték 2.

Példa 2:

Bemenet: nums = [3,3,3,3]
Kimenet: 1
Magyarázat:
A nums szigorúan növekvő részhalmazai: [3], [3], [3], és [3].
A nums szigorúan csökkenő részhalmazai: [3], [3], [3], és [3].
Ezért a visszatérési érték 1.

Példa 3:

Bemenet: nums = [3,2,1]
Kimenet: 3
Magyarázat:
A nums szigorúan növekvő részhalmazai: [3], [2], és [1].
A nums szigorúan csökkenő részhalmazai: [3], [2], [1], [3,2], [2,1], és [3,2,1].
Ezért a visszatérési érték 3.

Korlátozások:

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


Adott egy s karakterlánc és egy k egész szám.
Definiálj egy distance(s_1, s_2) függvényt két azonos hosszúságú s_1 és s_2 karakterlánc között, mint:

A minimális távolságok összegét s_1[i] és s_2[i] között, amikor a 'a' és 'z' karakterek ciklikusan vannak elhelyezve, minden i tartományban [0, n - 1].

Például, distance("ab", "cd") == 4, és distance("a", "z") == 1.
Bármelyik s betűt megváltoztathatod bármely másik kisbetűs angol betűre, bármennyi alkalommal.
Adj vissza egy karakterláncot, amely az lexicógrafikusan legkisebb karakterlánc t, amit megkaphatsz néhány változtatás után úgy, hogy distance(s, t) <= k.

Példa 1:

Bemenet: s = "zbbz", k = 3
Kimenet: "aaaz"
Magyarázat:
A s-t megváltoztatjuk "aaaz"-ra. A "zbbz" és "aaaz" közötti távolság egyenlő k = 3 értékkel.

Példa 2:

Bemenet: s = "xaxcd", k = 4
Kimenet: "aawcd"
Magyarázat:
A "xaxcd" és "aawcd" közötti távolság egyenlő k = 4 értékkel.

Példa 3:

Bemenet: s = "lol", k = 0
Kimenet: "lol"
Magyarázat:
Nem lehetséges bármely karaktert megváltoztatni, mivel k = 0.

Korlátozások:

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

Kapsz egy s karakterláncot és egy k egész számot.
Határozzon meg egy függvénytávolságot (s_1, s_2) két n hosszúságú s_1 és s_2 karakterlánc között, mint:

Az s_1[i] és s_2[i] közötti legkisebb távolság összege, amikor az "a" és "z" közötti karakterek ciklikus sorrendben vannak elhelyezve, a [0, n - 1] tartomány összes i-jére.

Például: távolság("ab", "cd") == 4, és távolság("a", "z") == 1.
Bármely s betűt tetszőleges számú alkalommal megváltoztathatja bármely más kisbetűs angol betűre.
Adjon vissza egy karakterláncot, amely a lexikográfiailag legkisebb t karakterláncot jelöli, amelyet néhány változtatás után kaphat, úgy, hogy távolság(ok, t) <= k.

1. példa:

Bemenet: s = "zbbz", k = 3
Kimenet: "aaaz"
Magyarázat:
Módosítsa az s-t "aaaz" -ra. A "zbbz" és az "aaaz" közötti távolság k = 3.

2. példa:

Bemenet: s = "xaxcd", k = 4
Kimenet: "aawcd"
Magyarázat:
Az "xaxcd" és az "aawcd" közötti távolság k = 4.

3. példa:

Bemenet: s = "lol", k = 0
Kimenet: "lol"
Magyarázat:
Lehetetlen megváltoztatni bármely karaktert k = 0-ként.

Korlátok:

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

Kapsz egy s karakterláncot és egy k egész számot.
Határozzon meg egy függvénytávolságot (s_1, s_2) két, n hosszúságú s_1 és s_2 karakterlánc között, mint:

Az s_1[i] és s_2[i] közötti minimális távolság összege, ha az 'a' és 'z' közötti karakterek ciklikus sorrendben vannak elhelyezve, a [0, n - 1] tartományban lévő összes i-re.

Például distance("ab", "cd") == 4 és distance("a", "z") == 1.
Bármilyen s betűt bármilyen más angol kisbetűre módosíthat, tetszőleges számú alkalommal.
Adjon vissza egy karakterláncot, amely a lexikográfiailag legkisebb t karakterláncot jelöli, amelyet néhány változtatás után kaphat, úgy, hogy távolság(ok, t) <= k.

1. példa:

Bemenet: s = "zbbz", k = 3
Kimenet: "aaaz"
Magyarázat:
Módosítsa az s-t "aaaz"-ra. A "zbbz" és az "aaaz" közötti távolság k = 3.

2. példa:

Bemenet: s = "xaxcd", k = 4
Kimenet: "aawcd"
Magyarázat:
Az "xaxcd" és az "aawcd" közötti távolság k = 4.

3. példa:

Bemenet: s = "lol", k = 0
Kimenet: "lol"
Magyarázat:
Lehetetlen bármilyen karaktert megváltoztatni, ha k = 0.

Korlátozások:

1 <= s.length <= 100
0 <= k <= 2000
s csak kis angol betűkből áll.


Meg van adva egy egész számokból álló tömb, nums, és egy nemnegatív egész szám, k. Egy művelet során bármelyik elemet növelheti vagy csökkentheti 1-gyel.
Adja vissza a minimális műveletek számát, amelyek szükségesek ahhoz, hogy a nums mediánja k legyen.
Egy tömb mediánja a tömb középső eleme, amikor az nem csökkenő sorrendben van rendezve. Ha a mediánra két választási lehetőség van, akkor a kettő közül a nagyobbat kell venni.

1. példa:

Bemenet: nums = [2,5,6,8,5], k = 4
Kimenet: 2
Magyarázat:
Kivonhatunk egyet a nums[1] és nums[4] értékéből, hogy [2, 4, 6, 8, 4] legyen. Az így kapott tömb mediánja egyenlő k-val.

2. példa:

Bemenet: nums = [2,5,6,8,5], k = 7
Kimenet: 3
Magyarázat:
Hozzáadhatunk egyet a nums[1]-hez kétszer és a nums[2]-höz egyszer, hogy [2, 7, 7, 8, 5] legyen.

3. példa:

Bemenet: nums = [1,2,3,4,5,6], k = 4
Kimenet: 0
Magyarázat:
A tömb mediánja már egyenlő k-val.

Korlátozások:

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

Adunk egy egész számokból álló tömböt és egy nem negatív k egész számot. Egy műveletben bármelyik elemet növelheti vagy csökkentheti 1-gyel.
Adja vissza a minimális számú műveletet, amely ahhoz szükséges, hogy a számok mediánja egyenlő legyen k-val.
Egy tömb mediánja a tömb középső eleme, ha nem csökkenő sorrendbe rendezi. Ha a mediánnak két választási lehetősége van, akkor a két érték közül a nagyobbat veszik figyelembe.

1. példa:

Bemenet: nums = [2,5,6,8,5], k = 4
Kimenet: 2
Magyarázat:
Kivonhatunk egyet a nums[1] és nums[4] elemekből, hogy megkapjuk a [2, 4, 6, 8, 4] értéket. A kapott tömb mediánja egyenlő k-val.

2. példa:

Bemenet: nums = [2,5,6,8,5], k = 7
Kimenet: 3
Magyarázat:
Hozzáadhatunk egyet a nums[1]-hez kétszer, és egyszer hozzáadhatunk egyet a számokhoz[2], hogy megkapjuk a [2, 7, 7, 8, 5] értéket.

3. példa:

Bemenet: nums = [1,2,3,4,5,6], k = 4
Kimenet: 0
Magyarázat:
A tömb mediánja már egyenlő k-val.

Korlátozások:

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

Adott egy egész szám tömb nums és egy nemnegatív egész szám k. Egy művelettel bármelyik elemet növelhetjük vagy csökkenthetjük 1-gyel.
Adja meg, hogy hány művelet szükséges legalább ahhoz, hogy a nums mediánja egyenlő legyen k-val a nums mediánja egyenlő legyen k-val.
Egy tömb mediánja a tömb középső eleme, ha a tömböt nem csökkenő sorrendbe rendezzük. Ha két lehetőség van a mediánra, akkor a két érték közül a nagyobbat választjuk.

Példa 1:

Bevitel: nums = [2,5,6,8,5], k = 4
Kimenet: 2
Magyarázat:
A nums[1]-ből és a nums[4]-ből kivonhatunk egyet, hogy [2, 4, 6, 8, 4]-et kapjunk. Az így kapott tömb mediánja egyenlő k-val.

2. példa:

Bemenet: nums = [2,5,6,8,5], k = 7
Kimenet: 3
Magyarázat:
A nums[1]-hez kétszer adhatunk egyet, a nums[2]-hez pedig egyszer egyet, hogy [2, 7, 7, 8, 5]-t kapjunk.

3. példa:

Bemenet: nums = [1,2,3,4,5,6], k = 4
Kimenet: 0
Magyarázat:
A tömb mediánja már egyenlő k-val.

Korlátozások:

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


Kapsz egy s karakterláncot, amely egy 12 órás formátumidőt jelent, ahol néhány számjegy (esetleg egyik sem) "?"-re van cserélve.
A 12 órás időpontok formátuma "ÓÓ:PP", ahol ÓÓ 00 és 11 között, a MM pedig 00 és 59 között van. A legkorábbi 12 órás időpont 00:00, a legkésőbbi pedig 11:59.
Cserélnie kell az összes "?" karakterek s-ben olyan számjegyekkel, hogy az eredményül kapott karakterlánc által kapott idő érvényes 12 órás formátumú, és a lehető legkésőbbi idő.
Adja vissza a kapott karakterláncot.

1. példa:

Bemenet: s = "1?:?4"
Kimenet: "11:54"
Magyarázat: A legutóbbi 12 órás formázási idő, amelyet a "?" karakterekkel elérhetünk, "11:54".

2. példa:

Bemenet: s = "0?:5?"
Kimenet: "09:59"
Magyarázat: A legutóbbi 12 órás formázási idő, amelyet a "?" karakterekkel elérhetünk, "09:59".

Korlátozások:

s.length == 5
s[2] egyenlő a ":" karakterrel.
Az s[2] kivételével minden karakter számjegy vagy "?" karakterek.
A bemenet úgy jön létre, hogy a "00:00" és "11:59" között legalább egy idő legyen, amelyet a "?" karakterekkel elérhetünk.

Kapsz egy s karakterláncot, amely 12 órás formátumidőt jelent, ahol néhány számjegy (esetleg egyik sem) "?"-re van cserélve.
A 12 órás időpontok formátuma "ÓÓ:PP", ahol ÓÓ 00 és 11 között, a MM pedig 00 és 59 között van. A legkorábbi 12 órás időpont 00:00, a legkésőbbi pedig 11:59.
Cserélnie kell az összes "?" karakterek s-ben olyan számjegyekkel, hogy az eredményül kapott karakterlánc által kapott idő érvényes 12 órás formátumú és a lehető legkésőbbi idő.
Adja vissza a kapott karakterláncot.

1. példa:

Bemenet: s = "1?:?4"
Kimenet: "11:54"
Magyarázat: A legutóbbi 12 órás formázási idő, amelyet a "?" karakter "11:54".

2. példa:

Bemenet: s = "0?:5?"
Kimenet: "09:59"
Magyarázat: A legutóbbi 12 órás formázási idő, amelyet a '?' karakterekkel elérhetünk, '09:59'

Korlátozások:

s.length == 5
s[2] egyenlő a ":" karakterrel.
Az s[2] kivételével minden karakter számjegy vagy "?" karakterek.
A bemenet úgy jön létre, hogy a '?' karaktereket cserélve legalább egy időpontot el lehet érni '00:00' és '11:59' között

Kap egy s karakterláncot, amely egy 12 órás formátumidőt képvisel, ahol néhány számjegyet (esetleg egyet sem) "?" -ra cserélnek.
A 12 órás idők "ÓÓ:MM" formátumban vannak formázva, ahol a HH 00 és 11 között, az MM pedig 00 és 59 között van. A legkorábbi 12 órás idő 00:00, a legkésőbbi pedig 11:59.
Az s-ben lévő összes "?" karaktert számjegyekre kell cserélni úgy, hogy az eredményül kapott karakterlánccal kapott idő érvényes 12 órás formátumidő legyen, és a lehető legkésőbbi legyen.
Adja vissza az eredményül kapott karakterláncot.

1. példa:

Bemenet: s = "1?:?4"
kimenet: "11:54"
Magyarázat: A "?" karakterek cseréjével elérhető legutóbbi 12 órás formátumidő a "11:54".

2. példa:

Bemenet: s = "0?:5?"
Kimenet: "09:59"
Magyarázat: A "?" karakterek cseréjével elérhető legutolsó 12 órás formátumidő a "09:59".

Korlátok:

s.length == 5
s[2] egyenlő a ":" karakterrel.
Az s[2] kivételével minden karakter számjegy vagy "?" karakter.
A bemenet úgy jön létre, hogy a "00:00" és a "11:59" között legalább egy időpont beszerezhető a "?" karakterek cseréje után.


Adott egy egész szám tömb nums.
Adjon vissza egy olyan egész számot, amely a nums két (nem feltétlenül különböző) prímszámának indexe közötti maximális távolság.

Példa 1:

Bemenet: nums = [4,2,9,5,3]
Kimenet: 3
Magyarázat: nums[1], nums[3] és nums[4] prímszámok. A válasz tehát |4 - 1| = 3.

Példa 2:

Bemenet: nums = [4,8,2,8]
Kimenet: 0
Magyarázat: nums[2] prímszám. Mivel csak egy prímszám van, a válasz |2 - 2| = 0.

Korlátozások:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
A bemenetet úgy generáljuk, hogy a nums-ban lévő prímszámok száma legalább egy legyen.

Kap egy egész számokból álló tömböt.
Adjon vissza egy egész számot, amely a két (nem feltétlenül különböző) prímszám indexei közötti maximális távolságot jelenti a tömbben.

Példa 1:

Bemenet: nums = [4,2,9,5,3]
Kimenet: 3
Magyarázat: a számok[1], számok[3] és számok[4] prímszámok. Tehát a válasz |4 - 1| = 3.

Példa 2:

Bemenet: nums = [4,8,2,8]
Kimenet: 0
Magyarázat: a számok[2] prím. Mivel csak egy prímszám van, a válasz |2 - 2| = 0.

Korlátozások:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
A bemenetet úgy állítjuk elő, hogy a tömbben legalább egy prímszám legyen.

Kapsz egy egész tömb számát.
Olyan egész számot ad vissza, amely két (nem feltétlenül eltérő) prímszám indexei közötti maximális távolságot jelenti számokban.

1. példa:

Bemenet: nums = [4,2,9,5,3]
Kimenet: 3
Magyarázat: a számok[1], számok[3] és számok[4] prímszámok. Tehát a válasz |4 - 1| = 3.

2. példa:

Bemenet: nums = [4,8,2,8]
Kimenet: 0
Magyarázat: a számok[2] prím. Mivel csak egy prímszám van, a válasz |2 - 2| = 0.

Korlátozások:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
A bemenet úgy jön létre, hogy a számokban lévő prímszámok száma legalább egy legyen.


Kapsz egy egész tömb érméket, amelyek különböző címletű érméket képviselnek, és egy k egész számot.
Minden címletből végtelen számú érme van. Különböző címletű érméket azonban nem kombinálhat.
Adja vissza a k^edik legkisebb összeget, amelyet ezekkel az érmékkel lehet előállítani.

1. példa:

Bemenet: coins = [3,6,9], k = 3
Kimenet: 9
Magyarázat: Az adott érmék a következő összegeket tehetik ki:
A 3. érme a 3 többszörösét adja: 3, 6, 9, 12, 15 stb.
A 6-os érme a 6 többszörösét adja: 6, 12, 18, 24 stb.
A 9-es érme a 9 többszörösét adja: 9, 18, 27, 36 stb.
Az összes érme együttesen a következőt eredményezi: 3, 6, 9, 12, 15 stb.

2. példa:

Bemenet: coins = [5,2], k = 7
Kimenet: 12
Magyarázat: Az adott érmék a következő összegeket tehetik ki:
Az 5-ös érme az 5 többszörösét adja: 5, 10, 15, 20 stb.
A 2. érme a 2 többszörösét adja: 2, 4, 6, 8, 10, 12 stb.
Az összes érme együttesen a következőt eredményezi: 2, 4, 5, 6, 8, 10, 12, 14, 15 stb.

Korlátozások:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
Az érmék páronként különálló egész számokat tartalmaznak.

Kap egy egész számokból álló tömböt, amely különböző címletű érméket képvisel, amelyek különböző címletű érméket képviselnek, és egy egész k számot.
Minden címletből végtelen számú érme van. Különböző címletű érméket azonban nem kombinálhat.
Adja vissza a k-adik legkisebb összeget, amelyet ezekből az érmékből elő lehet állítani.

1. példa:

Bemenet: coins = [3,6,9], k = 3
Kimenet: 9
Magyarázat: Az adott érmék a következő összegeket tehetik ki:
A 3. érme a 3 többszöröseit állítja elő: 3, 6, 9, 12, 15 stb.
A 6. érme a 6: 6, 12, 18, 24 stb. többszöröseit állítja elő.
A 9-es érme a 9: 9, 18, 27, 36 stb. többszöröseit állítja elő.
Az összes érme együtt: 3, 6, 9, 12, 15 stb.

2. példa:

Bemenet: coins = [5,2], k = 7
Kimenet: 12
Magyarázat: Az adott érmék a következő összegeket tehetik ki:
Az 5 címletű érme a 5 többszöröseit állítja elő: 5, 10, 15, 20 stb.
A 2. érme a 2: 2, 4, 6, 8, 10, 12 stb. többszöröseit állítja elő.
Az összes érme együttesen: 2, 4, 5, 6, 8, 10, 12, 14, 15 stb.

Korlátok:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
Az érmék különböző, páronként különálló egész számokat jelölnek.


Két tömböt kap, nums és andN és m hosszúságú értékek.
A tömb értéke megegyezik a tömb utolsó elemével.
A számokat m diszjunkt összefüggő résztömbökre kell osztanunk úgy, hogy az i^-edik résztömb [l_i, r_i] esetében az altömbelemek bitenkénti AND értéke egyenlő legyen ésÉrtékek[i], más szóval nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] mind az 1 <= i <= m, ahol & a bitenkénti AND operátort jelöli.
Visszaadja az m résztömbök értékeinek minimális lehetséges összegét, a számok fel vannak osztva. Ha nem lehet a számokat m résztömbökre osztani, amelyek megfelelnek ezeknek a feltételeknek, akkor adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Kimenet: 12
Magyarázat:
A számok felosztásának egyetlen lehetséges módja:

[1,4] mivel 1 & 4 == 0.
[3] mivel az egyelemű résztömb bitenkénti ÉS értéke maga az elem.
[3] mivel az egyelemű résztömb bitenkénti ÉS értéke maga az elem.
[2] mivel az egyelemű résztömb bitenkénti ÉS értéke maga az elem.

Ezen altömbök értékeinek összege 4 + 3 + 3 + 2 = 12.

2. példa:

Bemenet: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Kimenet: 17
Magyarázat:
A számok felosztásának három módja van:

[[2,3,5],[7,7,7],[5]] az értékek összege 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] az értékek összege 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] az értékek összege 7 + 7 + 5 == 19.

Az értékek minimális lehetséges összege 17.

3. példa:

Bemenet: nums = [1,2,3,4], andValues = [2]
Kimenet: -1
Magyarázat:
A teljes tömb bitenkénti AND értéke 0. Mivel nincs mód arra, hogy a számokat egyetlen résztömbre osszuk, hogy a 2. elemek bitenkénti AND értéke legyen, adja vissza a -1 értéket.

Korlátozások:

1 <= n == számok.hossz <= 10^4
1 <= m == ésÉrtékek.hossz <= min(n, 10)
1 <= szám[i] < 10^5
0 <= ésÉrtékek[j] < 10^5

Két tömb számot és és értéket kap, amelyek n és m hosszúak.
Egy tömb értéke megegyezik a tömb utolsó elemével.
A számokat m diszjunkt összefüggő altömbre kell felosztani úgy, hogy az i^-edik altömb [l_i, r_i] esetén az altömb elemek bitenkénti ÉS értéke egyenlő legyen andValues[i]-val, más szóval számok[l_i] & számok[ l_i + 1] & ... & számok[r_i] == ésértékek[i] mind az 1-hez <= i <= m, ahol & a bitenkénti ÉS operátort jelenti.
Return az m altömb értékeinek minimális lehetséges összegét a számokat kell felosztani. Ha nem lehet a számokat olyan m altömbre felosztani, amelyek kielégítik ezeket a feltételeket, akkor -1-et adjon vissza.

1. példa:

Bemenet: nums = [1,4,3,3,2] andValues = [0,3,3,2]
Kimenet: 12
Magyarázat:
A számok felosztásának egyetlen lehetséges módja:

[1,4] mint 1 & 4 == 0.
[3], mivel az egyelemes altömb bitenkénti ÉS értéke maga az elem.
[3], mivel az egyelemes altömb bitenkénti ÉS értéke maga az elem.
[2], mivel az egyelemes altömb bitenkénti ÉS értéke maga az elem.

Ezen altömbök értékeinek összege 4 + 3 + 3 + 2 = 12.

2. példa:

Bemenet: nums = [2,3,5,7,7,7,5] andValues = [0,7,5]
Kimenet: 17
Magyarázat:
A számok felosztásának három módja van:

[[2,3,5],[7,7,7],[5]] az 5 + 7 + 5 == 17 értékek összegével.
[[2,3,5,7],[7,7],[5]] a 7 + 7 + 5 == 19 értékek összegével.
[[2,3,5,7,7],[7],[5]] a 7 + 7 + 5 == 19 értékek összegével.

Az értékek minimális lehetséges összege 17.

3. példa:

Bemenet: nums = [1,2,3,4] andValues = [2]
Kimenet: -1
Magyarázat:
A teljes tömb számának bitenkénti ÉS értéke 0. Mivel nincs mód arra, hogy a számokat egyetlen altömbre ossza fel, hogy a 2. elemek bitenkénti ÉS értéke legyen, a -1 értéket adja vissza.

Korlátozások:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Két tömböt kap, nums és andValues, m hosszúságú értékekkel.
A tömb értéke a tömb utolsó eleme.
A számokat m darab diszjunkt, összefüggő résztömbökre kell osztanunk úgy, hogy az i^-edik résztömb [l_i, r_i] esetében az altömbelemek bitenkénti AND értéke egyenlő legyen ésÉrtékek[i], más szóval nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] mind az 1 <= i <= m, ahol & a bitenkénti AND operátort jelöli.
Visszaadja az m résztömbök értékeinek minimális lehetséges összegét, a számok fel vannak osztva. Ha nem lehet a számokat m résztömbökre osztani, amelyek megfelelnek ezeknek a feltételeknek, akkor adja vissza a -1 értéket.

1. példa:

Bemenet: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Kimenet: 12
Magyarázat:
A számok felosztásának egyetlen lehetséges módja:

[1,4] mint 1 & 4 == 0.
[3] mivel az egyelemű résztömb bitenkénti ÉS értéke maga az elem.
[3] mivel az egyelemű résztömb bitenkénti ÉS értéke maga az elem.
[2] mivel az egyelemű résztömb bitenkénti ÉS értéke maga az elem.

Ezen altömbök értékeinek összege 4 + 3 + 3 + 2 = 12.

2. példa:

Bemenet: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Kimenet: 17
Magyarázat:
A számok felosztásának három módja van:

[[2,3,5],[7,7,7],[5]] az 5 + 7 + 5 értékek összegével == 17.
[[2,3,5,7],[7,7],[5]] a 7 + 7 + 5 értékek összegével == 19.
[[2,3,5,7,7],[7],[5]] a 7 + 7 + 5 == 19 értékek összegével.

Az értékek minimális lehetséges összege 17.

3. példa:

Bemenet: nums = [1,2,3,4], andValues = [2]
Kimenet: -1
Magyarázat:
A teljes tömb bitenkénti AND értéke 0. Mivel nincs mód arra, hogy a számokat egyetlen résztömbre osszuk, hogy a 2. elemek bitenkénti AND értéke legyen, adja vissza a -1 értéket.

Korlátok:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5


Egy egész számokból álló tömböt kapsz, amely pozitív egészeket tartalmaz. Definiálunk egy encrypt függvényt, amely úgy cseréli le az x minden számjegyét, hogy az x legnagyobb számjegyével helyettesíti azt. Például, encrypt(523) = 555 és encrypt(213) = 333.
Add vissza az titkosított elemek összegét.

1. példa:

Input: nums = [1,2,3]
Output: 6
Magyarázat: A titkosított elemek [1,2,3]. A titkosított elemek összege 1 + 2 + 3 == 6.

2. példa:

Input: nums = [10,21,31]
Output: 66
Magyarázat: A titkosított elemek [11,22,33]. A titkosított elemek összege 11 + 22 + 33 == 66.

Korlátozások:

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

You are given an integer array, amely pozitív egész számokat tartalmaz. Definiálunk egy titkosító függvényt úgy, hogy az encrypt(x) minden x számjegyet helyettesít az x legnagyobb számjegyével. Például: encrypt(523) = 555 és encrypt(213) = 333.
A adjon vissza a titkosított elemek összegét.

Példa 1:

Bemenet: nums = [1,2,3]
Kimenet: 6
Magyarázat: A titkosított elemek [1,2,3]. A titkosított elemek összege 1 + 2 + 3 == 6.

Példa 2:

Bemenet: nums = [10,21,31]
Kimenet: 66
Magyarázat: A titkosított elemek [11,22,33]. A titkosított elemek összege 11 + 22 + 33 == 66.

Korlátok:

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

Kapsz egy egész tömb számokat, amelyek pozitív egész számokat tartalmaznak. Egy encrypt függvényt definiálunk úgy, hogy az encrypt(x) az x minden számjegyét lecseréli x legnagyobb számjegyére. Például titkosítás(523) = 555 és titkosítás(213) = 333.
A titkosított elemek összegét adja vissza.

1. példa:

Bemenet: nums = [1,2,3]
Kimenet: 6
Magyarázat: A titkosított elemek [1,2,3]. A titkosított elemek összege 1 + 2 + 3 == 6.

2. példa:

Bemenet: nums = [10,21,31]
Kimenet: 66
Magyarázat: A titkosított elemek [11,22,33]. A titkosított elemek összege 11 + 22 + 33 == 66.

Korlátozások:

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


Kapsz egy 0-indexelt tömb n méretű számát, amely pozitív egész számokból áll.
Kap egy m méretű 2D tömb lekérdezést is, ahol queries[i] = [index_i, k_i].
Kezdetben a tömb összes eleme jelöletlen.
Az m lekérdezéseket sorrendben kell alkalmazni a tömbre, ahol az i^th lekérdezésnél a következőket kell tennie:

Jelölje meg az elemet az indexben index_i, ha még nincs megjelölve.
Ezután jelölje meg k_i jelöletlen elemeket a tömbben a legkisebb értékekkel. Ha több ilyen elem létezik, jelölje meg azokat, amelyek a legkisebb indexekkel rendelkeznek. És ha kevesebb, mint k_i jelöletlen elem létezik, akkor jelölje meg mindegyiket.

Egy m méretű tömbválaszt ad vissza, ahol answer[i] a tömb jelöletlen elemeinek összege az i^th lekérdezés után.

1. példa:

Bemenet: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Kimenet: [8,3,0]
Magyarázat:
A következő lekérdezéseket végezzük a tömbön:

Jelölje meg az elemet az 1-es indexen, és a legkisebb jelöletlen elemek közül a 2-t a legkisebb indexekkel, ha léteznek, a jelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 2 + 2 + 3 + 1 = 8.
Jelölje meg az elemet a 3. indexen, mivel már meg van jelölve, kihagyjuk. Ezután a legkisebb jelöletlen elemek közül 3-at jelölünk a legkisebb indexekkel, a jelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 3.
Jelölje meg az elemet a 4. indexen, mivel már meg van jelölve, kihagyjuk. Ezután a legkisebb jelöletlen elemek közül 2-t jelölünk a legkisebb indexekkel, ha léteznek, a jelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 0.

2. példa:

Bemenet: nums = [1,4,2,3], queries = [[0,1]]
Kimenet: [7]
Magyarázat: Egy lekérdezést végzünk, amely megjelöli az elemet a 0 indexen, és megjelöli a legkisebb elemet a jelöletlen elemek között. A megjelölt elemek nums = [1,4,2,3], és a jelöletlen elemek összege 4 + 3 = 7.

Korlátok:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1

Kapsz egy 0-indexelt tömb számokat, amelyek n méretűek, és pozitív egész számokból állnak.
Kapsz egy m méretű 2D tömb lekérdezéseket is, ahol lekérdezések[i] = [index_i, k_i].
Kezdetben a tömb minden eleme jelöletlen.
A tömbön m lekérdezést kell sorrendben alkalmazni, ahol az i^. lekérdezésnél a következőket kell tennie:

Jelölje meg az elemet az index_i indexnél, ha még nincs megjelölve.
Ezután jelölje meg k_i jelöletlen elemet a tömbben a legkisebb értékkel. Ha több ilyen elem létezik, jelölje meg a legkisebb indexűeket. És ha kevesebb, mint k_i jelöletlen elem létezik, akkor jelölje meg mindegyiket.

Egy m méretű tömbválaszt ad vissza, ahol a válasz[i] a tömb jelöletlen elemeinek összege az i^. lekérdezés után.

Példa 1:

Bemenet: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Kimenet: [8,3,0]
Magyarázat:
A következő lekérdezéseket hajtjuk végre a tömbön:

Jelölje meg az elemet az 1. indexnél, és a legkisebb jelöletlen elemek közül a 2. legkisebb indexszel, ha léteznek, a megjelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 2 + 2 + 3 + 1 = 8.
Jelölje az elemet a 3-as indexnél, mivel már meg van jelölve, kihagyjuk. Ezután a legkisebb jelöletlen elemek közül 3-at jelölünk meg a legkisebb indexekkel, a jelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 3.
Jelölje az elemet a 4-es indexnél, mivel már meg van jelölve, kihagyjuk. Ezután megjelölünk 2 legkisebb jelöletlen elemet a legkisebb indexekkel, ha vannak, a jelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 0.

Példa 2:

Bemenet: nums = [1,4,2,3], queries = [[0,1]]
Kimenet: [7]
Magyarázat: Elvégzünk egy lekérdezést, amely az elemet 0 indexen jelöli meg, és a legkisebb elemet jelöli meg a jelöletlen elemek közül. A megjelölt elemek nums = [1,4,2,3], a jelöletlen elemek összege pedig 4 + 3 = 7.

Korlátozások:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1

Kapsz egy 0-indexelt tömb számokat, amelyek n méretűek, és pozitív egész számokból állnak.
Kapsz egy m méretű 2D tömb lekérdezéseket is, ahol queries[i] = [index_i, k_i].
Kezdetben a tömb minden eleme jelöletlen.
A tömbön m lekérdezést kell sorrendben alkalmazni, ahol az i^. lekérdezésnél a következőket kell tennie:

Jelölje meg az elemet az index_i indexnél, ha még nincs megjelölve.
Ezután jelölje meg k_i jelöletlen elemet a tömbben a legkisebb értékkel. Ha több ilyen elem létezik, jelölje meg a legkisebb indexűeket. És ha kevesebb, mint k_i jelöletlen elem létezik, akkor jelölje meg mindegyiket.

Egy m méretű tömbválaszt ad vissza, ahol a válasz[i] a tömb jelöletlen elemeinek összege az i^. lekérdezés után.

1. példa:

Bemenet: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Kimenet: [8,3,0]
Magyarázat:
A következő lekérdezéseket hajtjuk végre a tömbön:

Jelölje meg az elemet az 1. indexnél, és a legkisebb jelöletlen elemek közül a 2. legkisebb indexű elemet, ha létezik, a megjelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 2 + 2 + 3 + 1 = 8.
Jelölje az elemet a 3-as indexnél, mivel már meg van jelölve, kihagyjuk. Ezután a legkisebb jelöletlen elemek közül 3-at jelölünk a legkisebb indexekkel, a megjelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 3.
Jelölje az elemet a 4-es indexnél, mivel már meg van jelölve, kihagyjuk. Ezután megjelölünk 2 legkisebb jelöletlen elemet a legkisebb indexekkel, ha léteznek, a jelölt elemek most nums = [1,2,2,1,2,3,1]. A jelöletlen elemek összege 0.

2. példa:

Bemenet: nums = [1,4,2,3], queries = [[0,1]]
Kimenet: [7]
Magyarázat: Egy lekérdezést végzünk, ami az elemet 0 indexen jelöli meg, és a legkisebb elemet jelöli meg a jelöletlen elemek közül. A megjelölt elemek száma = [1,4,2,3], a jelöletlen elemek összege pedig 4 + 3 = 7.

Korlátozások:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1


Egy adott s karakterláncot kaptunk. Az s[i] vagy egy kisbetűs angol betű, vagy '?'.

Egy olyan t karakterláncra, amely m hosszúságú és csak kisbetűs angol betűkből áll, a cost(i) függvényt egy i indexre úgy definiáljuk, mint azon karakterek számát, amelyek t[i]-vel egyenlők és előtte jelentek meg, azaz a [0, i - 1] tartományban.

t értéke a cost(i) összege minden i indexre.

Például, a t = "aab" karakterláncra:

cost(0) = 0
cost(1) = 1
cost(2) = 0
Ennek megfelelően, az "aab" értéke 0 + 1 + 0 = 1.

Feladatod, hogy az összes '?' előfordulást kisbetűs angol betűkre cseréld az s-ben úgy, hogy s értéke minimális legyen.

Vissza kell adni egy karakterláncot, amely az átalakított s-t jelöli a '?' helyettesítésekkel. Ha több olyan karakterlánc is van, amelynek minimális az értéke, a lexikografikusan legkisebbet kell visszaadni.

1. példa:

Input:   s = "???"
Output:   "abc"
Magyarázat: Ebben a példában a '?' előfordulásait úgy cserélhetjük le, hogy az s "abc"-vé váljon. Az "abc" esetén cost(0) = 0, cost(1) = 0, és cost(2) = 0. Az "abc" értéke 0. Néhány más módosítás, amelynek értéke 0, például a "cba", "abz", és "hey". Ezek közül a lexikografikusan legkisebbet választjuk.

2. példa:

Input:  s = "a?a?"
Output:  "abac"
Magyarázat: Ebben a példában a '?' előfordulásait úgy cserélhetjük le, hogy az s "abac"-cé váljon. Az "abac" esetén cost(0) = 0, cost(1) = 0, cost(2) = 1, és cost(3) = 0. Az "abac" értéke 1.

Feltételek:

1 <= s.length <= 10^5
s[i] vagy egy kisbetűs angol betű, vagy '?'.

Kapsz egy s-t. Az s[i] vagy kisbetűs angol betű, vagy "?".
Egy m hosszúságú, csak kisbetűs angol betűket tartalmazó t karakterlánc esetében az i index cost(i) függvényét az előtte megjelenő t[i]-vel egyenlő karakterek számaként határozzuk meg, azaz a [0, i - 1] tartományban.
A t értéke az összes i index költségének (i) összege.
Például a t = "aab" karakterlánc esetében:

cost(0) = 0
cost(1) = 1
cost(2) = 0
Ezért az "aab" értéke 0 + 1 + 0 = 1.

Az Ön feladata, hogy az s-ben lévő "?" összes előfordulását bármilyen kisbetűs angol betűvel helyettesítse, hogy az s értéke minimális legyen.
A módosított karakterláncot jelölő karakterláncot ad vissza a "?" helyett. Ha több karakterlánc eredménye a minimális érték, adja vissza a lexikográfiailag legkisebb értéket.

1. példa:

Bemenet: s = "???"
Kimenet: "abc"
Magyarázat: Ebben a példában lecserélhetjük a "?" előfordulásait, hogy s egyenlő legyen az "abc" -vel.
Az "abc" cost(0) = 0, cost(1) = 0, és cost(2) = 0.
Az "abc" értéke 0.
Az s néhány más módosítása, amelynek értéke 0, a "cba", "abz" és "hey".
Mindegyikük közül a lexikográfiailag legkisebbet választjuk.

2. példa:

Bemenet: s = "a?a?"
Kimenet: "abac"
Magyarázat: Ebben a példában a "?" előfordulásai helyettesíthetők, hogy s egyenlő legyen az "abac" -val.
Az "abac" cost(0) = 0, cost(1) = 0, cost(2) = 1, és cost(3) = 0.
Az "abac" értéke 1.

Korlátok:

1 <= s.length <= 10^5
Az s[i] vagy kisbetűs angol betű, vagy '?'.

Egy karakterláncot kapsz s. Az s[i] vagy kisbetű angol betű, vagy '?'.
Egy olyan t karakterláncra, amely m hosszúságú és csak kisbetűs angol betűkből áll, a cost(i) függvényt egy i indexre úgy definiáljuk, mint azon karakterek számát, amelyek t[i]-vel egyenlők és előtte jelentek meg, azaz a [0, i - 1] tartományban.
t értéke a cost(i) összege minden i indexre.
Például a t = "aab" karakterlánchoz:

cost(0) = 0
cost(1) = 1
cost(2) = 0
Ezért az "aab" értéke 0 + 1 + 0 = 1.

Az Ön feladata a '?' összes előfordulásának lecserélése s-ben tetszőleges angol kisbetűvel, hogy az s értéke minimális legyen.
Egy karakterláncot ad vissza, amely a módosított karakterláncot jelöli, és a helyettesített '?' előfordulásaival. Ha több karakterlánc is eredményezi a minimális értéket, akkor a lexikográfiailag legkisebbet adja vissza.

1. példa:

Bemenet: s = "???"
Kimenet: "abc"
Magyarázat: Ebben a példában lecserélhetjük a '?' előfordulásait. hogy s egyenlő legyen az "abc"-vel.
Az "abc" esetén cost(0) = 0, cost(1) = 0, és cost(2) = 0.
Az "abc" értéke 0.
Az s néhány egyéb 0 értékű módosítása a "cba", "abz" és a "hey".
Mindegyik közül a lexikográfiailag legkisebbet választjuk.

2. példa:

Bemenet: s = "a?a?"
Kimenet: "abac"
Magyarázat: Ebben a példában a '?' lecserélhető, hogy s egyenlő legyen az "abac"-kal.
Az "abac" esetén cost(0) = 0, cost(1) = 0, cost(2) = 1, és cost(3) = 0.
Az "abac" értéke 1.

Korlátozások:

1 <= s.length <= 10^5
s[i] vagy egy kisbetűs angol betű, vagy '?'.


Kapunk egy n hosszúságú egész tömböt és egy k pozitív egész számot.
Az egész számok tömbjének hatványát úgy definiáljuk, mint az alsorozatok számát, amelyek összege k.
A számok összes részsorozatának hatványösszegét adja eredményül.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10 ^ 9 + 7.

1. példa:

Bemenet:   nums = [1,2,3], k = 3
Kimenet:   6
Magyarázat:
A nem nulla teljesítményű numok 5 alszekvenciája van:

Az [1,2,3] részsorozatnak 2 részsorozata van, amelyek összege == 3: [1,2,3] és [1,2,3].
Az [1,2,3] részsorozatnak 1 részsorozata van, amelynek összege == 3: [1,2,3].
Az [1,2,3] részsorozatnak 1 részsorozata van, amelynek összege == 3: [1,2,3].
Az [1,2,3] részsorozatnak 1 részsorozata van, amelynek összege == 3: [1,2,3].
Az [1,2,3] részsorozatnak 1 részsorozata van, amelynek összege == 3: [1,2,3].

Ezért a válasz 2 + 1 + 1 + 1 + 1 = 6.

2. példa:

Bemenet:   nums = [2,3,3], k = 5
Kimenet:   4
Magyarázat:
A nem nulla teljesítményű numok 3 részsorozata van:

A [2,3,3] részsorozatnak 2 részsorozata van, amelyek összege == 5: [2,3,3] és [2,3,3].
A [2,3,3] részsorozatnak 1 részsorozata van, amelynek összege == 5: [2,3,3].
A [2,3,3] részsorozatnak 1 részsorozata van, amelynek összege == 5: [2,3,3].

Ezért a válasz 2 + 1 + 1 = 4.

3. példa:

Bemenet:   nums = [1,2,3], k = 7
Kimenet:   0
Magyarázat: Nem létezik 7-es összegű részsorozat. Ezért a numok minden részsorozatának hatványa = 0.

Korlátok:

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100

Adunk egy n hosszúságú egész tömböt és egy k pozitív egész számot.
Egy egész számok tömbjének hatványa a k-val egyenlő részsorozatok száma.
A számok összes részsorozatának hatványösszegét adja vissza.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [1,2,3], k = 3
Kimenet: 6
Magyarázat:
A számoknak 5 részsorozata van, amely hatványe nem nulla:

Az [1,2,3] részsorozatnak 2 olyan részsorozata van, amely összege == 3: [1,2,3] és [1,2,3].
Az [1,2,3] részsorozatnak 1 olyan részsorozata van, amelynek összege == 3: [1,2,3].
Az [1,2,3] részsorozatnak 1 olyan részsorozata van, amelynek összege == 3: [1,2,3].
Az [1,2,3] részsorozatnak 1 olyan részsorozata van, amelynek összege == 3: [1,2,3].
Az [1,2,3] részsorozatnak 1 olyan részsorozata van, amelynek összege == 3: [1,2,3].

Ezért a válasz 2 + 1 + 1 + 1 + 1 = 6.

2. példa:

Bemenet:   nums = [2,3,3], k = 5
Kimenet: 4
Magyarázat:
A számoknak 3 részsorozata van, amely hatványe nem nulla:

A [2,3,3] részsorozatnak 2 részsorozata van, amely összege == 5: [2,3,3] és [2,3,3].
A [2,3,3] részsorozatnak 1 olyan részsorozata van, amelynek összege == 5: [2,3,3].
A [2,3,3] részsorozatnak 1 olyan részsorozata van, amelynek összege == 5: [2,3,3].

Ezért a válasz 2 + 1 + 1 = 4.

3. példa:

Bemenet:  nums = [1,2,3], k = 7
Kimenet: 0
Magyarázat: Nem létezik 7-es összegű részsorozat. Ezért a számok összes részsorozatának hatványa = 0.

Korlátozások:

1 <= n <= 100
1 <= nums[i] <= 10^4
1 <= k <= 100


Kapsz egy tömböt, amely nemnegatív egész számokat és egy k egész számot tartalmaz.
Egy tömböt akkor nevezünk speciálisnak, ha minden elemének bitenkénti VAGY értéke legalább k.
Adja vissza a legrövidebb speciális, nem üres számok altömb hosszát, vagy adja vissza a -1-et, ha nincs speciális altömb.

1. példa:

Bemenet: nums  = [1,2,3], k = 2
Kimenet: 1
Magyarázat:
A [3] altömb VAGY értéke 3. Ezért 1-et adunk vissza.

2. példa:

Bemenet: nums  = [2,1,8], k = 10
Kimenet: 3
Magyarázat:
A [2,1,8] altömb VAGY értéke 11. Ezért 3-at adunk vissza.

3. példa:

Bemenet: nums  = [1,2], k = 0
Kimenet: 1
Magyarázat:
Az [1] altömb VAGY értéke 1. Ezért 1-et adunk vissza.

Korlátozások:

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64

Kapsz egy tömbszámot nem negatív egész számokból és egy k egész számból.
Egy tömböt speciálisnak nevezünk, ha az összes elemének bitenkénti OR értéke legalább k.
A számok legrövidebb speciális, nem üres résztömbjének hosszát adja eredményül, vagy -1 értéket ad vissza, ha nincs speciális résztömb.

1. példa:

Bemenet: nums = [1,2,3], k = 2
Kimenet: 1
Magyarázat:
A [3] résztömb OR értéke 3. Ezért visszatérünk 1.

2. példa:

Bemenet: nums = [2,1,8], k = 10
Kimenet: 3
Magyarázat:
A [2,1,8] résztömb OR értéke 11. Ezért visszatérünk 3.

3. példa:

Bemenet: nums = [1,2], k = 0
Kimenet: 1
Magyarázat:
A(z) [1] résztömb OR értéke 1. Ezért visszatérünk 1.

Korlátok:

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64

Kapsz egy tömbszámú nemnegatív egész számokat és egy k egész számot.
Egy tömböt akkor nevezünk speciálisnak, ha minden elemének bitenkénti VAGY értéke legalább k.
Adja vissza a legrövidebb speciális, nem üres számok altömb hosszát, vagy adja vissza a -1-et, ha nincs speciális altömb.

Példa 1:

Bemenet: nums = [1,2,3], k = 2
Kimenet: 1
Magyarázat:
A [3] altömb VAGY értéke 3. Ezért 1-et adunk vissza.

Példa 2:

Bemenet: nums = [2,1,8], k = 10
Kimenet: 3
Magyarázat:
A [2,1,8] altömb VAGY értéke 11. Ezért 3-at adunk vissza.

Példa 3:

Bemenet: nums = [1,2], k = 0
Kimenet: 1
Magyarázat:
Az [1] altömb VAGY értéke 1. Ezért 1-et adunk vissza.

Korlátozások:

1 <= nums.length <= 50
0 <= nums[i] <= 50
0 <= k < 64


Egy possible n hosszúságú bináris tömböt kapunk.
Alice és Bob egy n szintből álló játékot játszanak. A játék egyes szintjeit lehetetlen törölni, míg mások mindig törölhetők. Különösen, ha possible[i] == 0, akkor az i^-edik szintet lehetetlen mindkét játékos számára törölni. Egy játékos 1 pontot kap, ha megtisztítja a szintet, és 1 pontot veszít, ha nem tudja teljesíteni.
A játék elején Alice néhány szint a megadott sorrendben játszik a 0^. szinttől kezdve, majd Bob a többi szint játszik.
Alice tudni akarja, hány szintet kell játszania, hogy több pontot szerezzen, mint Bob, ha mindkét játékos optimálisan játszik a pontjaik maximalizálása érdekében.
Adja vissza azt a minimális szintet, amelyet Alice-nek meg kell játszania, hogy több pontot szerezzen. Ha ez nem lehetséges, adjon vissza -1-et.
Vegye figyelembe, hogy minden játékosnak legalább 1 szintet kell játszania.

1. példa:

Bemenet: possible = [1,0,1,0]
Kimenet: 1
Magyarázat:
Nézzük meg, hogy Alice milyen szinteken tud játszani:

Ha Alice csak a 0. szinten játszik, Bob pedig a többi szinten, Alice 1 pontot kap, míg Bob -1 + 1 - 1 = -1 pont.
Ha Alice az 1. szintig játszik, és Bob a többi szintet, Alice-nek 1-1 = 0 pontja van, míg Bobnak 1-1 = 0 pontja van.
Ha Alice a 2. szintig játszik, és Bob a többi szintet, Alice 1 - 1 + 1 = 1 pontot kap, míg Bob -1 pontot.

Alice-nek legalább 1 szintet kell játszania, hogy több pontot szerezzen, mint Bob.
2. példa:

Bemenet: possible = [1,1,1,1,1]
Kimenet: 3
Magyarázat:
Nézzük meg, hogy Alice milyen szinteken tud játszani:

Ha Alice csak a 0. szinten játszik, Bob pedig a többi szinten, Alice 1 pontot kap, míg Bob 4 pontot.
Ha Alice az 1. szintig játszik, Bob pedig a többi szintet, Alice 2 pontot kap, míg Bob 3 pontot.
Ha Alice a 2. szintig játszik, Bob pedig a többi szintet, Alice 3 pontot kap, míg Bob 2 pontot.
Ha Alice a 3. szintig játszik, és Bob a többi szintet, Alice 4 pontot kap, míg Bob 1 pontot.

Alice-nek legalább 3 szintet kell játszania, hogy több pontot szerezzen.

3. példa:

Bemenet: possible = [0,0]
Kimenet: -1
Magyarázat:
Az egyetlen lehetséges módja, hogy mindkét játékos 1-1 szintet játsszon. Alice 0. szintet játszik és 1 pontot veszít. Bob 1. szintet játszik és 1 pontot veszít. Mivel mindkét játékos egyenlő pontokkal rendelkezik, Alice nem tud több pontot szerezni, mint Bob.

Korlátozások:

2 <= n == possible.length <= 10^5
possible[i] 0 vagy 1.

Egy lehetséges n hosszúságú bináris tömböt kapunk.
Alice és Bob egy n szintből álló játékot játszanak. A játék egyes szintjeit lehetetlen törölni, míg mások mindig törölhetők. Különösen, ha lehetséges[i] == 0, akkor az i^-edik szintet lehetetlen mindkét játékos számára törölni. Egy játékos 1 pontot kap egy szint leküzdésekor, és 1 pontot veszít, ha nem sikerül teljesítenie.
A játék elején Alice néhány pályát a megadott sorrendben játszik a 0^. szinttől kezdve, majd Bob a többi pályán játszik.
Alice tudni akarja, hány szintet kell játszania, hogy több pontot szerezzen, mint Bob, ha mindkét játékos optimálisan játszik a pontjaik maximalizálása érdekében.
Adja vissza azt a minimális szintet, amelyet Alice-nek meg kell játszania, hogy több pontot szerezzen. Ha ez nem lehetséges, adjon vissza -1-et.
Vegye figyelembe, hogy minden játékosnak legalább 1 szintet kell játszania.

1. példa:

Bemenet: possible = [1,0,1,0]
Kimenet: 1
Magyarázat:
Nézzük meg, hogy Alice milyen szinteken tud játszani:

Ha Alice csak a 0. szinten játszik, Bob pedig a többi szinten, Alice 1 pontot kap, míg Bob -1 + 1 - 1 = -1 pont.
Ha Alice az 1. szintig játszik, és Bob a többi szintet, Alice-nek 1-1 = 0 pontja van, míg Bobnak 1-1 = 0 pontja van.
Ha Alice a 2. szintig játszik, és Bob a többi szintet, Alice 1 - 1 + 1 = 1 pontot kap, míg Bob -1 pontot.

Alice-nek legalább 1 szintet kell játszania, hogy több pontot szerezzen.

2. példa:

Bemenet: possible = [1,1,1,1,1]
Kimenet: 3
Magyarázat:
Nézzük meg, hogy Alice milyen szinteken tud játszani:

Ha Alice csak a 0. szinten játszik, Bob pedig a többi szinten, Alice 1 pontot kap, míg Bob 4 pontot.
Ha Alice az 1. szintig játszik, Bob pedig a többi szintet, Alice 2 pontot kap, míg Bob 3 pontot.
Ha Alice a 2. szintig játszik, Bob pedig a többi szintet, Alice 3 pontot kap, míg Bob 2 pontot.
Ha Alice a 3. szintig játszik, és Bob a többi szintet, Alice 4 pontot kap, míg Bob 1 pontot.

Alice-nek legalább 3 szintet kell játszania, hogy több pontot szerezzen.

3. példa:

Bemenet: possible = [0,0]
Kimenet: -1
Magyarázat:
Az egyetlen lehetséges módja, hogy mindkét játékos 1-1 szintet játsszon. Alice 0. szintet játszik és 1 pontot veszít. Bob 1. szintet játszik és 1 pontot veszít. Mivel mindkét játékos egyenlő pontokkal rendelkezik, Alice nem tud több pontot szerezni, mint Bob.

Korlátozások:

2 <= n == possible.length <= 10^5
lehetséges [i] 0 vagy 1.

Adott egy n hosszúságú lehetséges bináris tömb.
Alice és Bob egy játékot játszanak, amely n szintből áll. A játék egyes szintjeit lehetetlen teljesíteni, míg mások mindig teljesíthetők. Különösen, ha possible[i] == 0, akkor az i^-edik szintet mindkét játékos számára lehetetlen teljesíteni. A játékos 1 pontot kap egy szint megtisztításáért, és 1 pontot veszít, ha nem sikerül azt megtisztítani.
A játék kezdetén Alice a 0^. szinttel kezdve a megadott sorrendben játszik néhány szintet, majd Bob játssza le a többi szintet.
Alice azt szeretné tudni, hogy hány szintet kell legalább játszania ahhoz, hogy több pontot szerezzen, mint Bob, ha mindkét játékos optimálisan játszik a pontjai maximalizálására.
Adjuk vissza, hogy Alice-nak hány szintet kell legalább játszania ahhoz, hogy több pontot szerezzen. Ha ez nem lehetséges, akkor adjuk vissza a -1 értéket.
Megjegyezzük, hogy minden játékosnak legalább 1 szintet kell játszania.

Példa 1:

Bemenet: possible = [1,0,1,0]
Kimenet: 1
Magyarázat:
Nézzük meg az összes szintet, ameddig Alice játszhat:

Ha Alice csak a 0. szintet játssza, Bob pedig a többi szintet, akkor Alice-nak 1 pontja van, míg Bobnak -1 + 1 - 1 = -1 pontja.
Ha Alice az 1. szintig játszik, Bob pedig a többi szintet, akkor Alice-nak 1 - 1 = 0 pontja van, míg Bobnak 1 - 1 = 0 pontja.
Ha Alice a 2. szintig játszik, Bob pedig a többi szintet, akkor Alice-nak 1 - 1 + 1 = 1 pontja van, míg Bobnak -1 pontja.

Alice-nak legalább 1 szintet kell játszania, hogy több pontot szerezzen.

Példa 2:

Bemenet: possible = [1,1,1,1,1]
Kimenet: 3
Magyarázat:
Nézzük meg az összes szintet, ameddig Alice játszhat:

Ha Alice csak a 0. szintet játssza, Bob pedig a többi szintet, akkor Alice-nak 1 pontja van, míg Bobnak 4 pontja.
Ha Alice az 1. szintig játszik, Bob pedig a többi szintet, akkor Alice-nak 2 pontja van, míg Bobnak 3 pontja.
Ha Alice a 2. szintig játszik, Bob pedig a többi szintet is, akkor Alice-nak 3 pontja van, míg Bobnak 2 pontja.
Ha Alice a 3. szintig játszik, Bob pedig a többi szintig, akkor Alice-nak 4 pontja van, míg Bobnak 1 pontja.

Alice-nak legalább 3 szintet kell játszania, hogy több pontot szerezzen.

Példa 3:

Bemenet: possible = [0,0]
Kimenet: -1
Magyarázat:
Az egyetlen lehetséges út az, hogy mindkét játékos egy-egy szintet játszik. Alice a 0. szintet játssza, és 1 pontot veszít. Bob az 1. szintet játssza, és 1 pontot veszít. Mivel mindkét játékosnak egyenlő pontjai vannak, Alice nem szerezhet több pontot, mint Bob.

Korlátozások:

2 <= n == possible.length <= 10^5
possible[i] vagy 0 vagy 1.


Kapunk egy n hosszúságú egész tömböt és egy k pozitív egész számot.
A részsorozat hatványa a részsorozat bármely két eleme közötti minimális abszolút különbség.
A k hosszúságú számok összes részsorozata hatványainak összegét adja eredményül.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [1,2,3,4], k = 3
Kimenet: 4
Magyarázat:
A 3 hosszúságú számokban 4 részsorozat van: [1,2,3], [1,3,4], [1,2,4] és [2,3,4]. A hatványok összege |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

2. példa:

Bemenet: nums = [2,2], k = 2
Kimenet: 0
Magyarázat:
Az egyetlen részsorozat számban, amelynek hossza 2, a [2,2]. A hatványok összege |2 - 2| = 0.

3. példa:

Bemenet: nums = [4,3,-1], k = 2
Kimenet: 10
Magyarázat:
A 2 hosszúságú számokban 3 részsorozat van: [4,3], [4,-1] és [3,-1]. A hatványok összege |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Korlátok:

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n

Adunk egy n hosszúságú egész tömböt és egy k pozitív egész számot.
Egy részsorozat hatványa a részsorozat bármely két eleme közötti minimális abszolút különbség.
Az összes olyan részsorozat hatványának összegét adja vissza, amelynek hossza k egyenlő.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.

Példa 1:

Bemenet: nums = [1,2,3,4], k = 3
Kimenet: 4
Magyarázat:
Négy részsorozat van a számokban, amelyek hossza 3: [1,2,3], [1,3,4], [1,2,4] és [2,3,4]. A hatványok összege |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Példa 2:

Bemenet: nums = [2,2], k = 2
Kimenet: 0
Magyarázat:
A számokban szereplő egyetlen részsorozat, amelynek hossza 2, a [2,2]. A hatványok összege |2 - 2| = 0.

Példa 3:

Bemenet: nums = [4,3,-1], k = 2
Kimenet: 10
Magyarázat:
Három részsorozat van a számokban, amelyek hossza 2: [4,3], [4,-1] és [3,-1]. A hatványok összege |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Korlátozások:

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n

Adunk egy n hosszúságú egész tömböt és egy k pozitív egész számot.
Egy részsorozat hatványa a részsorozat bármely két eleme közötti minimális abszolút különbség.
Az összes olyan részsorozat hatványának összegét adja vissza, amelynek hossza k egyenlő.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [1,2,3,4], k = 3
Kimenet: 4
Magyarázat:
Négy részsorozat van a számokban, amelyek hossza 3: [1,2,3], [1,3,4], [1,2,4] és [2,3,4]. A hatványok összege |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

2. példa:

Bemenet: nums = [2,2], k = 2
Kimenet: 0
Magyarázat:
A számokban szereplő egyetlen részsorozat, amelynek hossza 2, a [2,2]. A hatványok összege |2 - 2| = 0.

3. példa:

Bemenet: nums = [4,3,-1], k = 2
Kimenet: 10
Magyarázat:
A számokban 3 részsorozat van, amelyek hossza 2: [4,3], [4,-1] és [3,-1]. A hatványok összege |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Korlátozások:

2 <= n == nums.length <= 50
-10^8 <= nums[i] <= 10^8
2 <= k <= n


Kapsz egy s karakterláncot. A karakterlánc pontszáma a szomszédos karakterek ASCII-értékei közötti abszolút különbség összege.
Adja vissza az s pontszámot.

1. példa:

Bemenet: s = "hello"
Kimenet: 13
Magyarázat:
Az s-ben szereplő karakterek ASCII-értékei: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Tehát az s pontszáma |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

2. példa:

Bemenet: s = "zaz"
Kimenet: 50
Magyarázat:
Az s-ben szereplő karakterek ASCII-értékei a következők: 'z' = 122, 'a' = 97. Tehát az s pontszáma |122 - 97| + |97 - 122| = 25 + 25 = 50.

Korlátozások:

2 <= s.length <= 100
s csak kis angol betűkből áll.

A karakterlánc pontszámát a szomszédos karakterek ASCII-értékei közötti abszolút különbség összegeként határozzuk meg.
Adja vissza az s pontszámát.

Példa 1:

Bemenet: s = "hello"
Kimenet: 13
Magyarázat:
Az s-ben szereplő karakterek ASCII-értékei a következők: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Az s pontszáma tehát |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

2. példa:

Bemenet: s ="zaz"
Kimenet: 50
Magyarázat:
Az s-ben szereplő karakterek ASCII-értékei a következők: 'z' = 122, 'a' = 97. Az s pontszáma tehát |122 - 97| + |97 - 122| = 25 + 25 = 50.

Korlátozások:

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

Kapsz egy s karakterláncot. A karakterlánc pontszáma a szomszédos karakterek ASCII-értékei közötti abszolút különbség összege.
Adja vissza az s pontszámát.

1. példa:

Bemenet: s = "hello"
Kimenet: 13
Magyarázat:
Az s karaktereinek ASCII értékei: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Tehát az s pontszáma |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

2. példa:

Bemenet: s = "zaz"
Kimenet: 50
Magyarázat:
Az s karaktereinek ASCII értékei: 'z' = 122, 'a' = 97. Tehát az s pontszáma |122 - 97| + |97 - 122| = 25 + 25 = 50.

Korlátok:

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


Pozitív egész számokból álló tömböt kapsz.
A számokból álló altömbök számát adja vissza, ahol az altömb első és utolsó eleme egyenlő az altömb legnagyobb elemével.

1. példa:

Bemenet: nums = [1,4,3,3,2]
Kimenet: 6
Magyarázat:
6 altömb van, amelyek első és utolsó eleme megegyezik az altömb legnagyobb elemével:

altömb [1,4,3,3,2], legnagyobb eleme 1. Az első elem 1 és az utolsó elem is 1.
altömb [1,4,3,3,2], legnagyobb eleme 4. Az első elem 4 és az utolsó elem is 4.
altömb [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
altömb [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
altömb [1,4,3,3,2], legnagyobb eleme 2. Az első elem 2 és az utolsó elem is 2.
altömb [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.

Ezért visszaadjuk a 6-ot.

2. példa:

Bemenet: nums = [3,3,3]
Kimenet: 6
Magyarázat:
6 altömb van, amelyek első és utolsó eleme megegyezik az altömb legnagyobb elemével:

altömb [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
altömb [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
altömb [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
altömb [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
altömb [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
altömb [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.

Ezért visszaadjuk a 6-ot.

3. példa:

Bemenet: nums = [1]
Kimenet: 1
Magyarázat:
A számok egyetlen altömbje [1], legnagyobb eleme 1. Az első elem 1 és az utolsó elem is 1.
Ezért visszaadjuk az 1-et.

Korlátozások:

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

Pozitív egész számokból álló tömböt kapsz.
A számokból álló altömbök számát adja vissza, ahol az altömb első és utolsó eleme egyenlő az altömb legnagyobb elemével.

1. példa:

Bemenet: nums = [1,4,3,3,2]
Kimenet: 6
Magyarázat:
6 altömb van, amelyek első és utolsó eleme megegyezik az altömb legnagyobb elemével:

alsor [1,4,3,3,2], legnagyobb eleme 1. Az első elem 1 és az utolsó elem is 1.
alsor [1,4,3,3,2], legnagyobb eleme 4. Az első elem 4 és az utolsó elem is 4.
alsor [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
alsor [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
alsor [1,4,3,3,2], legnagyobb eleme 2. Az első elem 2 és az utolsó elem is 2.
alsor [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.

Ezért visszaadjuk a 6-ot.

2. példa:

Bemenet: nums = [3,3,3]
Kimenet: 6
Magyarázat:
6 altömb van, amelyek első és utolsó eleme megegyezik az altömb legnagyobb elemével:

alsor [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
alsor [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
alsor [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
alsor [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
alsor [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.
alsor [3,3,3], legnagyobb eleme 3. Az első elem 3 és az utolsó elem is 3.

Ezért visszaadjuk a 6-ot.

3. példa:

Bemenet: nums = [1]
Kimenet: 1
Magyarázat:
A számoknak egyetlen altömbje [1], legnagyobb eleme 1. Az első elem 1 és az utolsó elem is 1.
Ezért visszaadjuk az 1-et.

Korlátozások:

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

Kapsz egy sor pozitív egész számot, nums.
A számok résztömbjeinek számát adja eredményül, ahol a résztömb első és utolsó eleme megegyezik a résztömb legnagyobb elemével.

1. példa:

Bemenet: nums = [1,4,3,3,2]
Kimenet: 6
Magyarázat:
6 altömb van, amelyek első és utolsó eleme megegyezik a résztömb legnagyobb elemével:

[1,4,3,3,2] résztömb, legnagyobb eleme 1. Az első elem 1, az utolsó elem pedig szintén 1.
[1,4,3,3,2] résztömb, legnagyobb eleme 4. Az első elem 4, az utolsó elem pedig szintén 4.
résztömb [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.
résztömb [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.
[1,4,3,3,2] résztömb, legnagyobb eleme 2. Az első elem 2, az utolsó elem pedig szintén 2.
résztömb [1,4,3,3,2], legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.

Ezért visszatérünk 6.

2. példa:

Bemenet: nums = [3,3,3]
Kimenet: 6
Magyarázat:
6 altömb van, amelyek első és utolsó eleme megegyezik a résztömb legnagyobb elemével:

[3,3,3] résztömb, legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.
[3,3,3] résztömb, legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.
[3,3,3] résztömb, legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.
[3,3,3] résztömb, legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.
[3,3,3] résztömb, legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.
[3,3,3] résztömb, legnagyobb eleme 3. Az első elem 3, és az utolsó elem is 3.

Ezért visszatérünk 6.

3. példa:

Bemenet: nums = [1]
Kimenet: 1
Magyarázat:
A numoknak egyetlen résztömbje van, amely [1], legnagyobb eleme 1. Az első elem 1, az utolsó elem pedig szintén 1.
Ezért visszatérünk 1.

Korlátok:

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


Kapsz egy karakterláncot. Egy betűt különlegesnek nevezünk, ha kisbetűvel és nagybetűvel is megjelenik a szóban.
Adja vissza a speciális betűk számát szóban.

1. példa:

Bemenet: word = "aaAbcBC"
Kimenet: 3
Magyarázat:
A szó speciális karakterei az "a", a "b" és a "c".

2. példa:

Bemenet: word = "abc"
Kimenet: 0
Magyarázat:
A szóban egyetlen karakter sem jelenik meg nagybetűvel.

3. példa:

Bemenet: word = "abBCab"
Kimenet: 1
Magyarázat:
Az egyetlen speciális karakter a szóban a "b".

Korlátok:

1 <= word.length <= 50
szó csak kis- és nagybetűkből áll.

Kapsz egy string szót. Egy betűt különlegesnek nevezünk, ha a szóban kis- és nagybetűvel is szerepel.
Adja vissza a Word speciális betűinek számát.

1. példa:

Bemenet: word = "aaAbcBC"
Kimenet: 3
Magyarázat:
A Word speciális karakterei az „a”, „b” és „c”.

2. példa:

Bemenet: word = "abc"
Kimenet: 0
Magyarázat:
A szóban egyetlen karakter sem jelenik meg nagybetűvel.

3. példa:

Bemenet: word = "abBCab"
Kimenet: 1
Magyarázat:
A szó egyetlen speciális karaktere a „b”.

Korlátozások:

1 <= word.length <= 50
szó csak kis- és nagybetűkből áll angolul.

Kapsz egy string szót. Egy betűt különlegesnek nevezünk, ha a szóban kis- és nagybetűvel is szerepel.
Adja vissza a Word speciális betűinek számát.

Példa 1:

Bemenet: word = "aaAbcBC"
Kimenet: 3
Magyarázat:
A Word speciális karakterei az „a”, „b” és „c”.

Példa 2:

Bemenet: word = "abc"
Kimenet: 0
Magyarázat:
A szóban egyetlen karakter sem jelenik meg nagybetűvel.

Példa 3:

Bemenet: word = "abBCab"
Kimenet: 1
Magyarázat:
A szó egyetlen speciális karaktere a „b”.

Korlátozások:

1 <= word.length <= 50
szó csak kis- és nagybetűkből áll angolul.


Adott két azonos hosszúságú tömb, nums1 és nums2.
A nums1 minden elemét megnöveltük (vagy csökkentettük, ha negatív) egy egész számmal, amelyet az x változó képvisel.
Ennek eredményeképpen nums1 egyenlő lesz nums2-vel. Két tömb akkor tekinthető egyenlőnek, ha ugyanazokat az egész számokat tartalmazzák azonos gyakorisággal.
Az x egész számot adja vissza.

Példa 1:

Bemenet: nums1 = [2,6,4], nums2 = [9,7,5].
Kimenet: 3
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám 3.

Példa 2:

Bemenet: nums1 = [10], nums2 = [5].
Kimenet: -5
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám -5.

Példa 3:

Bemenet: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Kimenet: 0
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám 0.

Korlátozások:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
A teszteseteket úgy generáljuk, hogy van egy olyan egész szám x, hogy nums1 úgy válhat egyenlővé nums2-vel, hogy a nums1 minden eleméhez hozzáadjuk x-et.

Két egyenlő hosszúságú tömböt kapsz, a szám1-et és a szám2-t.
A nums1 minden eleme meg lett növelve (vagy negatív esetén csökkentve) egy egész számmal, amelyet az x változó képvisel.
Ennek eredményeként a szám1 egyenlő lesz a szám2-vel. Két tömb akkor tekinthető egyenlőnek, ha ugyanazokat az egész számokat és azonos gyakorisággal tartalmazzák.
Adja vissza az x egész számot.

1. példa:

Bemenet:  nums1 = [2,6,4],  nums2 = [9,7,5]
Kimenet: 3
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám 3.

2. példa:

Bemenet:  nums1 = [10],  nums2 = [5]
Kimenet: -5
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám -5.

3. példa:

Bemenet:  nums1 = [1,1,1,1],  nums2 = [1,1,1,1]
Kimenet: 0
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám 0.

Korlátozások:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
A teszteseteket úgy állítjuk elő, hogy van egy x egész szám, így a nums1 egyenlővé válhat a szám2-vel, ha x-et adunk a nums1 minden eleméhez.

Két egyenlő hosszúságú tömböt kapsz, a szám1 és a szám2.
A nums1 minden eleme meg lett növelve (vagy negatív esetén csökkentve) egy egész számmal, amelyet az x változó képvisel.
Ennek eredményeként a szám1 egyenlő lesz a szám2-vel. Két tömb akkor tekinthető egyenlőnek, ha ugyanazokat az egész számokat és azonos gyakorisággal tartalmazzák.
Adja vissza az x egész számot.

Példa 1:

Bemenet: nums1 = [2,6,4], nums2 = [9,7,5]
Kimenet: 3
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám 3.

Példa 2:

Bemenet: nums1 = [10], nums2 = [5]
Kimenet: -5
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám -5.

Példa 3:

Bemenet: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Kimenet: 0
Magyarázat:
A nums1 minden eleméhez hozzáadott egész szám 0.

Korlátozások:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
A teszteseteket úgy állítjuk elő, hogy van egy x egész szám, így a nums1 egyenlővé válhat a szám2-vel, ha x-et adunk a nums1 minden eleméhez.


Két n és x egész számot kap. Létre kell hoznunk egy n méretű pozitív egész számok tömbjét, ahol minden 0 <= i < n - 1 esetén a nums[i + 1] nagyobb, mint a nums[i], és a bitenkénti AND művelet eredménye a nums összes eleme között x.
nums[n - 1] legkisebb lehetséges értékét adja eredményül.

1. példa:

Bemenet: n = 3, x = 4
Kimenet: 6
Magyarázat:
nums lehetnek [4,5,6], és az utolsó eleme 6.

2. példa:

Bemenet: n = 2, x = 7
Kimenet: 15
Magyarázat:
nums lehetnek [7,15], és az utolsó eleme 15.

Korlátok:

1 <= n, x <= 10^8

Két n és x egész számot kapsz. Meg kell alkotnia egy n méretű pozitív egész számokból álló tömböt, ahol minden 0 <= i < n - 1 esetén a szám[i + 1] nagyobb, mint a szám[i], és az összes elem közötti bitenkénti ÉS művelet eredménye a számokból x.
A számok[n - 1] minimális lehetséges értékét adja vissza.

1. példa:

Bemenet: n = 3, x = 4
Kimenet: 6
Magyarázat:
A számok [4,5,6] lehetnek, utolsó eleme pedig 6.

2. példa:

Bemenet: n = 2, x = 7
Kimenet: 15
Magyarázat:
A számok [7,15] lehetnek, utolsó eleme pedig 15.

Korlátozások:

1 <= n, x <= 10^8

Két n és x egész számot kap. Létre kell hoznunk egy n méretű pozitív egész számok tömbjét, ahol minden 0 <= i < n - 1 esetén a nums[i + 1] nagyobb, mint a nums[i], és a bitenkénti AND művelet eredménye a nums összes eleme között x.
A szám[n - 1] legkisebb lehetséges értékét adja eredményül.

1. példa:

Bemenet: n = 3, x = 4
Kimenet: 6
Magyarázat:
A számok lehetnek [4,5,6], és az utolsó eleme 6.

2. példa:

Bemenet: n = 2, x = 7
Kimenet: 15
Magyarázat:
A számok lehetnek [7,15], és az utolsó eleme 15.

Korlátok:

1 <= n, x <= 10^8


Kap egy egész tömb nums-t. A számok egyediségi tömbje az a rendezett tömb, amely a számok összes résztömbjének különböző elemeit tartalmazza. Más szóval, ez egy rendezett tömb, amely distinct(nums[i.. j]), minden 0 <= i <= j < nums.length.
Itt distinct(nums[i.. j]) jelöli... az i indexszel kezdődő és a j indexszel végződő résztömb különálló elemeinek számát jelöli.
A számok egyediségi tömbjének mediánját adja eredményül.
Vegye figyelembe, hogy a tömb mediánja a tömb középső elemeként van definiálva, ha nem csökkenő sorrendbe van rendezve. Ha egy mediánnak két választási lehetősége van, akkor a két érték közül a kisebbet veszi a rendszer.

1. példa:

Bemenet: nums = [1,2,3]
Kimenet: 1
Magyarázat:
A számok egyediségi tömbje: [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])], ami egyenlő [1, 1, 1, 2, 2, 3]. Az egyediség tömb mediánja 1. Ezért a válasz 1.

2. példa:

Bemenet: nums = [3,4,3,4,5]
Kimenet: 2
Magyarázat:
A számok egyediségi tömbje [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Az egyediség tömb mediánja 2. Ezért a válasz 2.

3. példa:

Bemenet: nums = [4,3,5,4]
Kimenet: 2
Magyarázat:
A számok egyediségi tömbje [1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3]. Az egyediség tömb mediánja 2. Ezért a válasz 2.

Korlátok:

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

Kapsz egy egész tömb számát. A számok egyediségi tömbje az a rendezett tömb, amely a számok összes altömbjének különböző elemeinek számát tartalmazza. Más szavakkal, ez egy rendezett tömb, amely külön(számok[i..j]) áll, minden 0 <= i <= j < számok.hosszúság esetén.
Itt a megkülönböztető(számok[i..j]) az altömb különböző elemeinek számát jelöli, amely az i indexnél kezdődik és a j indexnél végződik.
A számok egyediségi tömbjének mediánját adja vissza.
Vegye figyelembe, hogy egy tömb mediánja a tömb középső eleme, ha nem csökkenő sorrendbe rendezi. Ha a mediánnak két választási lehetősége van, akkor a két érték közül a kisebbet veszik figyelembe.

1. példa:

Bemenet: nums = [1,2,3]
Kimenet: 1
Magyarázat:
A számok egyediségi tömbje: [különböző(számok[0..0]), különböző(nums[1..1]), különböző(nums[2..2]), különböző(nums[0..1]) , különböző(nums[1..2]), különböző(nums[0..2])], amely egyenlő a következővel: [1, 1, 1, 2, 2, 3]. Az egyediségi tömb mediánja 1. Ezért a válasz 1.

2. példa:

Bemenet: nums = [3,4,3,4,5]
Kimenet: 2
Magyarázat:
A számok egyediségi tömbje [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Az egyediségi tömb mediánja 2. Ezért a válasz 2.

3. példa:

Bemenet: nums = [4,3,5,4]
Kimenet: 2
Magyarázat:
A számok egyediségi tömbje [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. Az egyediségi tömb mediánja 2. Ezért a válasz 2.

Korlátozások:

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

Egy egész számokat tartalmazó tömböt, nums-t kaptál. A nums egyediség tömbje a rendezett tömb, amely a nums összes részhalmaza különböző elemeinek számát tartalmazza. Másképpen fogalmazva, ez egy olyan rendezett tömb, amely a számait tartalmazza: distinct(nums[i..j]), minden 0 <= i <= j < nums.length esetén.
Itt a distinct(nums[i..j]) azt jelöli, hogy hány különböző elem van a részhalmazban, amely az i indexnél kezdődik és a j indexnél végződik.
Add vissza a nums egyediség tömbjének mediánját.
Megjegyzed, hogy egy tömb mediánja az a tömb középső eleme, amikor a tömb nem-csökkenő sorrendben van rendezve. Ha két választás van a mediánra, akkor a két érték közül a kisebbet kell venni.

1. példa:
Bemenet: nums = [1,2,3]
Kimenet: 1
Magyarázat:
A nums egyediség tömbje [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])] amely egyenlő [1, 1, 1, 2, 2, 3]. Az egyediség tömb mediánja 1. Ezért a válasz 1.

2. példa:
Bement: nums = [3,4,3,4,5]
Kimenet: 2
Magyarázat:
A nums egyediség tömbje [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Az egyediség tömb mediánja 2. Ezért a válasz 2.

3. példa:
Bemenet: nums = [4,3,5,4]
Kimenet: 2
Magyarázat:
A nums egyediség tömbje [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. Az egyediség tömb mediánja 2. Ezért a válasz 2.

Korlátok:

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


Egy szó akkor érvényes, ha:

Legalább 3 karakterből áll.
Csak számjegyeket (0-9) és angol betűket (nagy- és kisbetűs) tartalmaz.
Tartalmaz legalább egy magánhangzót.
Tartalmaz legalább egy mássalhangzót.

Adott egy karakterlánc szó.
Adj vissza true értéket, ha a szó érvényes, különben adj vissza false értéket.
Megjegyzések:

'a', 'e', 'i', 'o', 'u' és ezek nagybetűs alakjai magánhangzók.
A mássalhangzó olyan angol betű, amely nem magánhangzó.

Példa 1:

Bemenet: word = "234Adas"
Kimenet: true
Magyarázat:
Ez a szó megfelel a feltételeknek.

Példa 2:

Bemenet: word = "b3"
Kimenet: false
Magyarázat:
Ennek a szónak a hossza kevesebb, mint 3, és nincs benne magánhangzó.

Példa 3:

Bemenet: word = "a3$e"
Kimenet: false
Magyarázat:
Ez a szó '$' karaktert tartalmaz, és nincs benne mássalhangzó.

Korlátozások:

1 <= word.length <= 20
word angol nagy- és kisbetűket, számjegyeket, '@', '#' és '$' karaktereket tartalmaz.

Egy szó akkor tekinthető érvényesnek, ha:

Legalább 3 karaktert tartalmaz.
Csak számjegyeket (0-9) és angol betűket (nagy- és kisbetűket) tartalmaz.
Legalább egy magánhangzót tartalmaz.
Legalább egy mássalhangzót tartalmaz.

Kapsz egy karakterláncot.
Igaz értéket ad vissza, ha a szó érvényes, ellenkező esetben hamis értéket ad vissza.
Notes:

"a", "e", "i", "o", "u", és nagybetűik magánhangzók.
A mássalhangzó egy angol betű, amely nem magánhangzó.

1. példa:

Bemenet: word = "234Adas"
Kimenet: true
Magyarázat:
Ez a szó kielégíti a feltételeket.

2. példa:

Bemenet: word = "b3"
Kimenet: false
Magyarázat:
Ennek a szónak a hossza kevesebb, mint 3, és nincs magánhangzója.

3. példa:

Bemenet: word = "a3$e"
Kimenet: false
Magyarázat:
Ez a szó "$" karaktert tartalmaz, és nincs mássalhangzója.

Korlátok:

1 <= word.length <= 20
szó angol kis- és nagybetűkből, számjegyekből, '@', '#' és '$' karakterekből áll.

Egy szó akkor tekinthető érvényesnek, ha:

Minimum 3 karaktert tartalmaz.
Csak számjegyeket (0-9) és angol betűket (kis- és nagybetűket) tartalmaz.
Legalább egy magánhangzót tartalmaz.
Legalább egy mássalhangzót tartalmaz.

Kapsz egy string szót.
Igaz, ha a szó érvényes, ellenkező esetben hamis értéket ad vissza.
Megjegyzések:

'a', 'e', 'i', 'o', 'u', és ezek nagybetűi magánhangzók.
A mássalhangzó egy angol betű, amely nem magánhangzó.

1. példa:

Bemenet: word = "234Adas"
Kimenet: igaz
Magyarázat:
Ez a szó megfelel a feltételeknek.

2. példa:

Bemenet: word = "b3"
Kimenet: hamis
Magyarázat:
Ennek a szónak a hossza kevesebb, mint 3, és nem tartalmaz magánhangzót.

3. példa:

Bemenet: word = "a3$e"
Kimenet: hamis
Magyarázat:
Ez a szó „$” karaktert tartalmaz, és nincs mássalhangzója.

Korlátozások:

1 <= word.length <= 20
word consists of English uppercase and lowercase letters, digits, '@', '#', and '$'.


Kapsz egy n méretű karakterláncszót és egy k egész számot, amelyre k osztja n-t.
Egy műveletben kiválaszthat tetszőleges két i és j indexet, amelyek oszthatók k-val, majd az i-től kezdődő k hosszúságú részkarakterláncot lecserélheti a j-től kezdődő k hosszúságú részkarakterláncra. Azaz cserélje ki a részstring szót [i..i + k - 1] a részstring szóra [j..j + k - 1].
Visszaadja a minimális számú műveletet, amely szükséges ahhoz, hogy a szó k-periodikus legyen.
Azt mondjuk, hogy a szó k-periodikus, ha van olyan k hosszúságú s karakterlánc, amelyre szót kaphatunk s tetszőleges számú összefűzésével. Például, ha a szó == „ababab”, akkor a szó 2-periodikus, ha s = „ab”.

1. példa:

Bemenet: szó = "leetcodeleet", k = 4
Kimenet: 1
Magyarázat:
4-periodikus karakterláncot kaphatunk, ha kiválasztjuk az i = 4 és j = 0 értékeket. A művelet után a szó egyenlő lesz a "leetleetleet"-vel.

2. példa:

Bemenet: szó = "leetcoleet", k = 2
Kimenet: 3
Magyarázat:
Az alábbi táblázatban található műveletek alkalmazásával 2-periodikus karakterláncot kaphatunk.

én
j
szó

0
2
etetcoleet

4
0
etetetleet

6
0
etettetet

Korlátozások:

1 <= n == word.length <= 10^5
1 <= k <= word.length
k osztja a szót.hosszúság.
szó csak kisbetűs angol betűkből áll.

Kapsz egy n méretű karakterláncszót és egy k egész számot, amelyre k osztja n-t.
Egy műveletben kiválaszthat tetszőleges két i és j indexet, amelyek oszthatók k-val, majd az i-től kezdődő k hosszúságú részkarakterláncot lecserélheti a j-től kezdődő k hosszúságú részkarakterláncra. Azaz cserélje ki az alsztring szót [i..i + k - 1] a részstring szóra [j..j + k - 1].
Visszaadja a minimális számú műveletet, amely szükséges ahhoz, hogy a szó k-periodikus legyen.
Azt mondjuk, hogy a szó k-periodikus, ha van olyan k hosszúságú s karakterlánc, amelyre szót kaphatunk s tetszőleges számú összefűzésével. Például, ha a szó == „ababab”, akkor a szó 2-periodikus, ha s = „ab”.

példa 1:

Bemenet: szó = "leetcodeleet", k = 4
Kimenet: 1
Magyarázat:
4 periódusos karakterláncot kaphatunk, ha kiválasztjuk az i = 4 és j = 0 értékeket. A művelet után a szó egyenlő lesz a "leetleetleet"-vel.

példa 2:

Bemenet: szó = "leetcoleet", k = 2
Kimenet: 3
Magyarázat:
Az alábbi táblázatban található műveletek alkalmazásával 2-periodikus karakterláncot kaphatunk.

én
j
szó

0
2
etetcoleet

4
0
etetetleet

6
0
etettetet

Korlátozások:

1 <= n == szó.hosszúság <= 10^5
1 <= k <= szó.hosszúság
k osztja a szót.hosszúság.
szó csak kisbetűs angol betűkből áll.

Kapunk egy n méretű karakterláncszót, és egy k egész számot úgy, hogy k osztja n-t.
Egy műveletben kiválaszthat bármely két i és j indexet, amelyek oszthatók k-val, majd lecserélheti a k hosszúságú alsztringet i-vel kezdődő k hosszúságú részsztringre, amely j-től kezdődik. Ez azt jelenti, hogy cserélje ki az alkarakterlánc szót[i.. i + k - 1] az alkarakterlánccal[j.. j + k - 1].
A k-periodikussá tételhez szükséges műveletek minimális számát adja vissza.
Azt mondjuk, hogy a szó k-periodikus, ha van olyan k hosszúságú s karakterlánc, amely tetszőleges számú s összefűzésével nyerhető. Például, ha word == "ababab", akkor a szó 2-periodikus az s = "ab" esetén.

1. példa:

Bemenet: word = "leetcodeleet", k = 4
Kimenet: 1
Magyarázat:
4 periodikus karakterláncot kaphatunk i = 4 és j = 0 kiválasztásával. A művelet után a szó egyenlő lesz a "leetleetleet" -vel.

2. példa:

Bemenet: word = "leetcoleet", k = 2
Kimenet: 3
Magyarázat:
2 periodikus karakterláncot kaphatunk az alábbi táblázatban szereplő műveletek alkalmazásával.

én
j
szó

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

Korlátok:

1 <= n == word.length <= 10^5
1 <= k <= word.length
k osztja a szó hosszát.
szó csak kisbetűs angol betűkből áll.


Kapsz egy s karakterláncot, amelyről ismert, hogy valamilyen t karakterlánc anagrammáinak összefűzése.
Visszaadja a t karakterlánc lehetséges minimális hosszát.
Az anagramma egy karakterlánc betűinek átrendezésével jön létre. Például az „aab”, „aba” és „baa” az „aab” anagrammái.

Példa 1:

Bemenet: s = "abba"
Kimenet: 2
Magyarázat:
Az egyik lehetséges t karakterlánc a "ba" lehet.

Példa 2:

Bemenet: s = "cdef"
Kimenet: 4
Magyarázat:
Az egyik lehetséges t karakterlánc a "cdef" lehet, figyeljük meg, hogy t egyenlő lehet s-vel.

Korlátozások:

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

Kapsz egy s karakterláncot, amelyről ismert, hogy valamilyen t karakterlánc anagrammáinak összefűzése.
Visszaadja a t karakterlánc lehetséges minimális hosszát.
Az anagramma egy karakterlánc betűinek átrendezésével jön létre. Például az „aab”, „aba” és „baa” az „aab” anagrammái.

1. példa:

Bemenet: s = "abba"
Kimenet: 2
Magyarázat:
Az egyik lehetséges t karakterlánc a "ba" lehet.

2. példa:

Bemenet: s = "cdef"
Kimenet: 4
Magyarázat:
Egy lehetséges t karakterlánc lehet "cdef", figyeljük meg, hogy t egyenlő lehet s-vel.

Korlátozások:

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

Adott egy s karakterlánc, amelyről tudjuk, hogy valamilyen t karakterlánc anagrammáinak láncolata.
Adja vissza a t karakterlánc lehetséges legkisebb hosszát.
Egy anagramma egy karakterlánc betűinek átrendezésével jön létre. Például az „aab”, „aba” és „baa” az „aab” anagrammái.

Példa 1:

Bemenet: s = "abba"
Kimenet: 2
Magyarázat:
Egy lehetséges t karakterlánc lehet "ba".

Példa 2:

Bemenet: s = "cdef"
Kimenet: 4
Magyarázat:
Megjegyezzük, hogy a t lehet egyenlő az s-sel.

Korlátozások:

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


Egy egész számokból álló nums tömböt és két egész számot, cost1 és cost2, kapunk. Az alábbi műveletek egyikét tetszőleges számú alkalommal végrehajthatjuk:

Válassz egy i indexet a nums-ból, és növeld meg nums[i] értékét 1-gyel cost1 költségért.
Válassz két különböző i, j indexet a nums-ból, és növeld meg nums[i] és nums[j] értékét 1-gyel cost2 költségért.

Add vissza a minimális költséget, amely szükséges ahhoz, hogy a tömb összes eleme egyenlő legyen.
Mivel a válasz nagyon nagy lehet, add vissza a 10^9 + 7 modult.

1. példa:

Input: nums = [4,1], cost1 = 5, cost2 = 2
Output: 15
Magyarázat:
Az alábbi műveletek hajthatók végre, hogy az értékek egyenlők legyenek:

Növeld meg nums[1] értékét 1-gyel 5 költségért. nums lesz [4,2].
Növeld meg nums[1] értékét 1-gyel 5 költségért. nums lesz [4,3].
Növeld meg nums[1] értékét 1-gyel 5 költségért. nums lesz [4,4].

A teljes költség 15.

2. példa:

Input: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Output: 6
Magyarázat:
Az alábbi műveletek hajthatók végre, hogy az értékek egyenlők legyenek:

Növeld meg nums[0] és nums[1] értékét 1-gyel 1 költségért. nums lesz [3,4,3,3,5].
Növeld meg nums[0] és nums[2] értékét 1-gyel 1 költségért. nums lesz [4,4,4,3,5].
Növeld meg nums[0] és nums[3] értékét 1-gyel 1 költségért. nums lesz [5,4,4,4,5].
Növeld meg nums[1] és nums[2] értékét 1-gyel 1 költségért. nums lesz [5,5,5,4,5].
Növeld meg nums[3] értékét 1-gyel 2 költségért. nums lesz [5,5,5,5,5].

A teljes költség 6.

3. példa:

Input: nums = [3,5,3], cost1 = 1, cost2 = 3
Output: 4
Magyarázat:
Az alábbi műveletek hajthatók végre, hogy az értékek egyenlők legyenek:

Növeld meg nums[0] értékét 1-gyel 1 költségért. nums lesz [4,5,3].
Növeld meg nums[0] értékét 1-gyel 1 költségért. nums lesz [5,5,3].
Növeld meg nums[2] értékét 1-gyel 1 költségért. nums lesz [5,5,4].
Növeld meg nums[2] értékét 1-gyel 1 költségért. nums lesz [5,5,5].

A teljes költség 4.

Feltételek:

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

Adunk egy egész nums tömböt és két egész számot: cost1 és cost2. A következő műveletek bármelyikét tetszőleges számú alkalommal elvégezheti:

Válasszon egy indexet i a nums-ból, és növelje a nums[i] értéket 1-gyel a költség1 költségéhez.
Válasszon két különböző i, j indexet a nums-ból, és növelje a nums[i] és nums[j] értékeket 1-gyel a költség2 költsége érdekében.

Adja vissza a minimális költséget, amely ahhoz szükséges, hogy a tömb minden eleme egyenlő legyen.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [4,1], cost1 = 5, cost2 = 2
Kimenet: 15
Magyarázat:
A következő műveletek végezhetők az értékek egyenlővé tételéhez:

Növeld meg nums[1] értékét 1-gyel 5 költségért. nums lesz [4,2].
Növeld meg nums[1] értékét 1-gyel 5 költségért. nums lesz [4,3].
Növeld meg nums[1] értékét 1-gyel 5 költségért. nums lesz [4,4].

A teljes költség 15.

2. példa:

Bemenet: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Kimenet: 6
Magyarázat:
A következő műveletek végezhetők az értékek egyenlővé tételéhez:

Növeld meg nums[0] és nums[1] értékét 1-gyel 1 költségért. nums lesz [3,4,3,3,5].
Növeld meg nums[0] és nums[2] értékét 1-gyel 1 költségért. nums lesz [4,4,4,3,5].
Növeld meg nums[0] és nums[3] értékét 1-gyel 1 költségért. nums lesz [5,4,4,4,5].
Növeld meg nums[1] és nums[2] értékét 1-gyel 1 költségért. nums lesz [5,5,5,4,5].
Növeld meg nums[3] értékét 1-gyel 2 költségért. nums lesz [5,5,5,5,5].

A teljes költség 6.

3. példa:

Bemenet: nums = [3,5,3], cost1 = 1, cost2 = 3
Kimenet: 4
Magyarázat:
A következő műveletek végezhetők az értékek egyenlővé tételéhez:

Növeld meg nums[0] értékét 1-gyel 1 költségért. nums lesz [4,5,3].
Növeld meg nums[0] értékét 1-gyel 1 költségért. nums lesz [5,5,3].
Növeld meg nums[2] értékét 1-gyel 1 költségért. nums lesz [5,5,4].
Növeld meg nums[2] értékét 1-gyel 1 költségért. nums lesz [5,5,5].

A teljes költség 4.

Korlátozások:

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

Kap egy egész tömb számot és két egész számot: cost1 és cost2. A következő műveletek bármelyikét tetszőleges számú alkalommal végrehajthatja:

Válasszon egy i indexet a számok közül, és növelje a nums[i] számot 1-gyel a költség1 költségéhez.
Válasszon két különböző i, j indexet a nums közül, és növelje a nums [i] és nums[j] indexeket 1-gyel a költséghez2.

A tömb összes elemének egyenlővé tételéhez szükséges minimális költséget adja vissza.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10 ^ 9 + 7.

1. példa:

Bemenet: nums = [4,1], cost1 = 5, cost2 = 2
Kimenet: 15
Magyarázat:
Az értékek egyenlővé tételéhez a következő műveletek hajthatók végre:

Növelje nums[1] 1-gyel 5 költséggel. nums lesz [4,2].
Növelje nums[1] 1-gyel 5 költséggel. nums lesz [4,3].
Növelje nums[1] 1-gyel 5 költséggel. nums lesz [4,4].

A teljes költség 15.

2. példa:

Bemenet: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Kimenet: 6
Magyarázat:
Az értékek egyenlővé tételéhez a következő műveletek hajthatók végre:

Növelje nums[0] és nums[1] 1-gyel, így 1 költséggel jár. A nums [3,4,3,3,5] lesz.
Növelje nums[0] és nums[2] 1-gyel, így 1-es költséggel jár. A nums [4,4,4,3,5] lesz.
Növelje nums[0] és nums[3] 1-gyel, így 1-es költséggel jár. A nums [5,4,4,4,5] lesz.
Növelje nums[1] és nums2] 1-gyel, így 1-es költséggel jár. nums lesz [5,5,5,4,5].
Növelje nums[3] 1-gyel 2 költséggel. A nums [5,5,5,5,5] lesz.

A teljes költség 6.

3. példa:

Bemenet: nums = [3,5,3], cost1 = 1, cost2 = 3
Kimenet: 4
Magyarázat:
Az értékek egyenlővé tételéhez a következő műveletek hajthatók végre:

Növelje nums[0] 1-gyel 1-es költséggel. A nums [4,5,3] lesz.
Növelje nums[0] 1-gyel 1-es költséggel. A nums [5,5,3] lesz.
Növelje nums[2] 1-gyel 1-es költséggel. nums [5,5,4] lesz.
Növelje nums[2] 1-gyel 1-es költséggel. A nums [5,5,5] lesz.

A teljes költség 4.

Korlátok:

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


Kap egy 3 x 3 méretű 2D mátrixrácsot, amely csak 'B' és 'W' karakterekből áll. A 'W' karakter a fehér, a 'B' karakter pedig a fekete színt jelöli.
Az Ön feladata, hogy legfeljebb egy cella színét megváltoztassa úgy, hogy a mátrixnak 2 x 2 négyzete legyen, ahol minden cella azonos színű.
Visszatérési igaz érték, ha lehetséges azonos színű 2 x 2 négyzet létrehozása, ellenkező esetben hamis értéket ad vissza.

1. példa:

Bemenet: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Kimenet: true
Magyarázat:
Ez elvégezhető a rács[0][2] cella színének megváltoztatásával.

2. példa:

Bemenet: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Kimenet: false
Magyarázat:
Ezt nem lehet legfeljebb egy cella megváltoztatásával megtenni.

3. példa:

Bemenet: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Kimenet: true
Magyarázat:
A rács már tartalmaz egy azonos színű 2 x 2 négyzetet.

Korlátok:

grid.length == 3
grid[i].length == 3
grid[i][j] vagy 'W' vagy  'B'.

Egy 3 x 3 méretű 2D mátrix rácsot kap, amely csak „B” és „W” karakterekből áll. A „W” karakter a fehér színt, a „B” karakter a fekete színt jelöli.
Az a feladatod, hogy legfeljebb egy cella színét változtasd meg úgy, hogy a mátrixnak legyen egy 2 x 2-es négyzete, ahol minden cella azonos színű.
Adjon vissza igaz értéket, ha lehetséges 2 x 2-es azonos színű négyzet létrehozása, ellenkező esetben adjon vissza hamis értéket.

1. példa:

Bemenet: grid = [["B", "W", "B"], ["B", "W", "W"], ["B", "W", "B"]]
Kimenet: igaz
Magyarázat:
Ezt meg lehet tenni a rács[0][2] cella színének megváltoztatásával.

2. példa:

Bemenet: grid = [["B", "W", "B"], ["W", "B", "W"], ["B", "W", "B"]]
Kimenet: hamis
Magyarázat:
Ezt nem lehet megtenni legfeljebb egy cella színének megváltoztatásával.

3. példa:

Bemenet: grid = [["B", "W", "B"], ["B", "W", "W"], ["B", "W", "W"]]
Kimenet: igaz
Magyarázat:
A rács már tartalmaz egy 2 x 2-es azonos színű négyzetet.

Korlátozások:

grid.length == 3
grid[i].length == 3
grid[i][j] is either 'W' or 'B'.

Kap egy 3 x 3 méretű 2D mátrixrácsot, amely csak "B" és "W" karakterekből áll. A "W" karakter a fehér, a "B" karakter pedig a fekete színt jelöli.
Az Ön feladata, hogy legfeljebb egy cella színét megváltoztassa úgy, hogy a mátrixnak 2 x 2 négyzete legyen, ahol minden cella azonos színű.
Visszatérési igaz érték, ha lehetséges azonos színű 2 x 2 négyzet létrehozása, ellenkező esetben hamis értéket ad vissza.

1. példa:

Bemenet:  grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Kimenet: true
Magyarázat:
Ez a rács színének megváltoztatásával végezhető el[0][2].

2. példa:

Bemenet: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Kimenet: hamis
Magyarázat:
Ezt nem lehet legfeljebb egy cella megváltoztatásával megtenni.

3. példa:

Bemenet: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Kimenet: true
Magyarázat:
A rács már tartalmaz egy azonos színű 2 x 2 négyzetet.

Korlátok:

grid.length == 3
grid[i].length == 3
grid[i][j] vagy "W" vagy "B".