Két egész számot, red és blue, kapsz, amelyek a piros és kék színű golyók számát jelképezik. Ezeket a golyókat úgy kell elrendezni, hogy egy háromszöget formáljanak, ahol az 1^st sorban 1 golyó lesz, a 2^nd sorban 2 golyó, a 3^rd sorban 3 golyó, és így tovább.
Egy adott sorban lévő összes golyónak azonos színűnek kell lennie, és a szomszédos soroknak különböző színűeknek kell lenniük.
Add vissza a háromszög elérhető maximális magasságát.

Példa 1:

Input: red = 2, blue = 4
Output: 3
Magyarázat:

Az egyetlen lehetséges elrendezés a fentiek szerint van bemutatva.

Példa 2:

Input: red = 2, blue = 1
Output: 2
Magyarázat:

Az egyetlen lehetséges elrendezés a fentiek szerint van bemutatva.

Példa 3:

Input: red = 1, blue = 1
Output: 1

Példa 4:

Input: red = 10, blue = 1
Output: 2
Magyarázat:

Az egyetlen lehetséges elrendezés a fentiek szerint van bemutatva.

Feltételek:

1 <= red, blue <= 100

Adott két egész szám, a piros és a kék, amelyek a piros és a kék színű golyók számát jelölik. Ezeket a golyókat úgy kell elrendezned, hogy egy háromszöget alkossanak úgy, hogy az 1^. sorban 1 golyó legyen, a 2^. sorban 2 golyó, a 3^. sorban 3 golyó, és így tovább.
Egy adott sorban minden golyónak egyforma színűnek kell lennie, a szomszédos sorokban pedig különböző színűnek.
Adja vissza a háromszög maximálisan elérhető magasságát.

Példa 1:

Bemenet: red = 2, blue = 4
Kimenet: 3
Magyarázat:

Az egyetlen lehetséges elrendezés a fent látható.

2. példa:

Bemenet:red = 2, blue = 1
Kimenet: 2
Magyarázat:

Az egyetlen lehetséges elrendezés a fent látható.

Példa 3:

Bemenet:red = 1, blue = 1
Kimenet: 1

4. példa:

Bemenet: red = 10, blue = 1
Kimenet: 2
Magyarázat:

Az egyetlen lehetséges elrendezés a fent látható.

Korlátozások:

1 <= red, blue <= 100

Két egész számot kapsz, red és blue, amelyek a piros és kék színű labdák számát jelölik. Ezután el kell rendezned ezeket a labdákat egy háromszöget alkotva, úgy, hogy az 1. sorban 1 labda legyen, a 2. sorban 2 labda, a 3. sorban 3 labda, és így tovább.
Minden labdának egy adott sorban ugyanazon a színen kell lennie, és a szomszédos soroknak különböző színűeknek kell lenniük.
Térj vissza a háromszög maximális magasságával, amely elérhető.

 Példa 1:

Input: red = 2, blue = 4
Output: 3
Magyarázat:

Az egyetlen lehetséges elrendezés a fenti képen látható.

Példa 2:

Input: red = 2, blue = 1
Output: 2
Magyarázat:

Az egyetlen lehetséges elrendezés a fenti képen látható.

Példa 3:

Input: red = 1, blue = 1
Output: 1

Példa 4:

Input: red = 10, blue = 1
Output: 2
Magyarázat:

Az egyetlen lehetséges elrendezés a fenti képen látható.

 Korlátozások:

1 <= red, blue <= 100


Kap egy egész tömb nums-t.
Az x hosszúságú számok részsorozatát érvényesnek nevezzük, ha kielégíti:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

A számok leghosszabb érvényes részsorozatának hosszát adja eredményül.
Az alsorozat olyan tömb, amely egy másik tömbből származtatható néhány elem törlésével vagy anélkül, hogy megváltoztatná a fennmaradó elemek sorrendjét.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 4
Magyarázat:
A leghosszabb érvényes részsorozat az [1, 2, 3, 4].

2. példa:

Bemenet: nums = [1,2,1,1,2,1,2]
Kimenet: 6
Magyarázat:
A leghosszabb érvényes részsorozat az [1, 2, 1, 2, 1, 2].

3. példa:

Bemenet: nums = [1,3]
Kimenet: 2
Magyarázat:
A leghosszabb érvényes részsorozat az [1, 3].

Korlátok:

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

Kapsz egy egész tömb számát.
A számok x hosszúságú részsorozatát érvényesnek nevezzük, ha teljesíti:

(al[0] + al[1]) % 2 == (al[1] + al[2]) % 2 == ... == (al[x - 2] + al[x - 1]) % 2.

A számok leghosszabb érvényes részsorozatának hosszát adja vissza.
Az alsorozat olyan tömb, amely egy másik tömbből származtatható úgy, hogy néhány elemet vagy egyetlen elemet sem töröl a többi elem sorrendjének megváltoztatása nélkül.

Példa 1:

Bemenet: nums = [1,2,3,4]
Kimenet: 4
Magyarázat:
A leghosszabb érvényes részsorozat az [1, 2, 3, 4].

Példa 2:

Bemenet: nums = [1,2,1,1,2,1,2]
Kimenet: 6
Magyarázat:
A leghosszabb érvényes részsorozat az [1, 2, 1, 2, 1, 2].

Példa 3:

Bemenet: nums = [1,3]
Kimenet: 2
Magyarázat:
A leghosszabb érvényes részsorozat [1, 3].

Korlátozások:

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


Két irányítatlan fa létezik n és m csomópontokkal, 0-tól n - 1-ig és 0-tól m - 1-ig számozva. Két 2D egész tömböt kapunk, az edges1 és az edges2 n - 1 és m - 1 hosszúságban, ahol az edges1[i] = [a_i, b_i] azt jelzi, hogy él van az első fa a_i és b_i csomópontjai között, és edges2[i] = [u_i, v_i] azt jelzi, hogy él van a második fa u_i és v_i csomópontjai között.
Az első fa egyik csomópontját össze kell kapcsolnia a második fa másik csomópontjával.
Adja vissza a kapott fa lehető legkisebb átmérőjét.
A fa átmérője a fa bármely két csomópontja közötti leghosszabb út hossza.

1. példa:

Bemenet: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Kimenet: 3
Magyarázat:
A 3 átmérőjű fát úgy kaphatjuk meg, hogy az első fa 0. csomópontját összekapcsoljuk a második fa bármely csomópontjával.

2. példa:

Bemenet: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Kimenet: 5
Magyarázat:
5 átmérőjű fát kaphatunk, ha az első fa 0. csomópontját összekapcsoljuk a második fa 0. csomópontjával.

Korlátok:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
A bemenet úgy jön létre, hogy az élek1 és élek2 érvényes fákat képviselnek.

Két irányítatlan fa létezik n és m csomópontokkal, 0-tól n - 1-ig és 0-tól m - 1-ig számozva. Két 2D egész tömböt kapunk, az éleket1 és az éleket2 n - 1 és m - 1 hosszúságban, ahol az élek1[i] = [a_i, b_i] azt jelzi, hogy él van az első fa a_i és b_i csomópontjai között, és élek2[i] = [u_i, v_i] azt jelzi, hogy él van a második fa u_i és v_i csomópontjai között.
Az első fa egyik csomópontját össze kell kapcsolnia a második fa másik csomópontjával.
Adja vissza a kapott fa lehető legkisebb átmérőjét.
A fa átmérője a fa bármely két csomópontja közötti leghosszabb út hossza.

1. példa:

Bemenet: élek1 = [[0,1],[0,2],[0,3]], élek2 = [[0,1]]
Kimenet: 3
Magyarázat:
A 3 átmérőjű fát úgy kaphatjuk meg, hogy az első fa 0. csomópontját összekapcsoljuk a második fa bármely csomópontjával.

2. példa:

Bemenet: élek1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], élek2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Kimenet: 5
Magyarázat:
5 átmérőjű fát kaphatunk, ha az első fa 0. csomópontját összekapcsoljuk a második fa 0. csomópontjával.

Korlátok:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
A bemenet úgy jön létre, hogy az élek1 és élek2 érvényes fákat képviselnek.

Létezik két irányítatlan fa n és m csomóponttal, számozásuk 0-tól n-1-ig, illetve 0-tól m-1-ig. Két 2D egész tömb élek1 és élek2 n - 1, illetve m - 1 hosszúságúak, ahol az élek1[i] = [a_i, b_i] azt jelzik, hogy van él az első fa a_i és b_i csomópontjai és az élek2[i] = [u_i, v_i] azt jelzi, hogy van él a második fa u_i és v_i csomópontjai között. [i] = [u_i, v_i] azt jelzi, hogy a második fa u_i és v_i csomópontjai között él van.
Össze kell kötnie az első fából származó egyik csomópontot egy éllel rendelkező második fa másik csomópontjával.
Adja vissza a kapott fa minimális lehetséges átmérőjét.
A fa átmérője a fa bármely két csomópontja közötti leghosszabb út hossza.

1. példa:

Bemenet: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Kimenet: 3
Magyarázat:
3-as átmérőjű fát kaphatunk, ha az első fa 0-s csomópontját összekötjük a második fa bármely csomópontjával.

2. példa:

Bemenet: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Kimenet: 5
Magyarázat:
5-ös átmérőjű fát kaphatunk, ha az első fa 0-s csomópontját összekötjük a második fa 0-s csomópontjával.

Korlátozások:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
A bemenet úgy jön létre, hogy az élek1 és az élek2 érvényes fákat képviseljenek.


Kapsz egy s karakterláncot és egy k egész számot. Titkosítsa a karakterláncot a következő algoritmussal:

Minden c karakternél cserélje ki a c karaktert a c utáni k^edik karakterre a karakterláncban (ciklikus módon).

Adja vissza a titkosított karakterláncot.

1. példa:

Bemenet: s = "dart", k = 3
Kimenet: "tdar"
Magyarázat:

Ha i = 0, a 3^. karakter a 'd' után a 't'.
Ha i = 1, az 'a' utáni 3^. karakter a 'd'.
i = 2 esetén az 'r' utáni 3^. karakter az 'a'.
i = 3 esetén a 't' utáni 3^. karakter az 'r'.

2. példa:

Bemenet: s = "aaa", k = 1
Kimenet: "aaa"
Magyarázat:
Mivel az összes karakter azonos, a titkosított karakterlánc is ugyanaz lesz.

Korlátozások:

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

Kapsz egy s karakterláncot és egy k egész számot. titkosítsa a karakterláncot a következő algoritmussal a következő algoritmussal:

Minden c karakternél cserélje ki a c karaktert a c utáni k-edik karakterre a karakterláncban (ciklikus módon).

Adja vissza a titkosított karakterláncot.

1. példa:

Bemenet: s = "dart", k = 3
Kimenet: "tdar"
Magyarázat:

Ha i = 0, a 3.-ik karakter a 'd' után a 't'.
Ha i = 1, az 'a' utáni 3.-ik karakter a 'd'.
i = 2 esetén az 'r' utáni 3.-ik karakter az 'a'.
i = 3 esetén a 't' utáni 3.-ik karakter az 'r'.

2. példa:

Bemenet: s = "aaa", k = 1
Kimenet: "aaa"
Magyarázat:
Mivel az összes karakter azonos, a titkosított karakterlánc is ugyanaz lesz.

Korlátozások:

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

Kapsz egy s karakterláncot és egy k egész számot. Titkosítsa a karakterláncot a következő algoritmussal:

Minden c karakternél s-ben cserélje ki a c-t a c utáni k^-edik karakterre a karakterláncban (ciklikus módon).

Adja vissza a titkosított karakterláncot.

1. példa:

Bemenet: s = "dart", k = 3
Kimenet: "tdar"
Magyarázat:

i = 0 esetén a 'd' utáni 3^rd karakter 't'.
i = 1 esetén az 'a' utáni 3^rd karakter 'd'.
i = 2 esetén az "r" utáni 3^. karakter "a".
i = 3 esetén a 3^rd karakter a 't' után 'r'.

2. példa:

Bemenet: s = "aaa", k = 1
Kimenet: "aaa"
Magyarázat:
Mivel az összes karakter ugyanaz, a titkosított karakterlánc is ugyanaz lesz.

Korlátok:

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


Kapsz egy n pozitív egész számot.
Az x bináris karakterlánc akkor érvényes, ha az összes 2 hosszúságú részstring tartalmaz legalább egy „1”-et.
Minden érvényes n hosszúságú karakterlánc visszaadása tetszőleges sorrendben.

1. példa:

Bemenet: n = 3
Kimenet: ["010", "011", "101", "110", "111"]
Magyarázat:
Az érvényes 3 hosszúságú karakterláncok a következők: "010", "011", "101", "110" és "111".

2. példa:

Bemenet: n = 1
Kimenet: ["0","1"]
Magyarázat:
Az érvényes 1 hosszúságú karakterláncok a következők: "0" és "1".

Korlátozások:

1 <= n <= 18

Pozitív egész számot kapsz n.
Az x bináris karakterlánc akkor érvényes, ha minden x hosszúságú 2 alkarakterlánc tartalmaz legalább egy "1" -et.
Az összes n hosszúságú érvényes karakterláncot adja vissza, bármilyen sorrendben.

1. példa:

Bemenet: n = 3
Kimenet: ["010","011","101","110","111"]
Magyarázat:
A 3 hosszúságú érvényes karakterláncok a következők: "010", "011", "101", "110" és "111".

2. példa:

Bemenet: n = 1
Kimenet: ["0","1"]
Magyarázat:
Az 1 hosszúságú érvényes karakterláncok a következők: "0" és "1".

Korlátok:

1 < = n <= 18

Kapsz egy n pozitív egész számot.
Az x bináris karakterlánc akkor érvényes, ha az összes 2 hosszúságú részstring tartalmaz legalább egy „1”-et.
Minden érvényes n hosszúságú karakterlánc visszaadása tetszőleges sorrendben.

1. példa:

Bemenet: n = 3
Kimenet: ["010", "011", "101", "110", "111"]
Magyarázat:
Az érvényes 3 hosszúságú karakterláncok a következők: "010", "011", "101", "110" és "111".

2. példa:

Bemenet: n = 1
Kimenet: ["0","1"]
Magyarázat:
Az érvényes 1 hosszúságú karakterláncok: "0" és "1".

Korlátozások:

1 <= n <= 18


Adott egy kétdimenziós karakter mátrix, `grid`, ahol `grid[i][j]` lehet 'X', 'Y' vagy '.', add vissza azon rész-mátrixok számát, melyek tartalmazzák:

`grid[0][0]`
'X' és 'Y' egyenlő gyakorisággal fordulnak elő.
Legalább egy 'X'-et tartalmaz.

1. példa:

Bemenet: grid = [["X","Y","."],["Y",".","."]]
Kimenet: 3
Magyarázat:

2. példa:

Bemenet: grid = [["X","X"],["X","Y"]]
Kimenet: 0
Magyarázat:
Nincs olyan rész-mátrix, ahol az 'X' és 'Y' egyenlő gyakorisággal fordulna elő.

3. példa:

Bemenet: grid = [[".","."],[".","."]]
Kimenet: 0
Magyarázat:
Nincs olyan rész-mátrix, amely legalább egy 'X'-et tartalmaz.

Korlátok:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] lehet 'X', 'Y', vagy '.'.

Adott egy 2D karaktermátrix rács, ahol a grid[i][j] vagy 'X', 'Y' vagy '.', a következőket tartalmazó részmátrixok számát adja vissza:

rács[0][0]
'X' és 'Y' azonos gyakorisága.
legalább egy „X”.

1. példa:

Bemenet: grid = [["X","Y","."],["Y",".","."]]
Kimenet: 3
Magyarázat:

2. példa:

Bemenet: grid = [["X", "X"], ["X", "Y"]]
Kimenet: 0
Magyarázat:
Egyetlen almátrixnak sincs egyenlő frekvenciája 'X' és 'Y'.

3. példa:

Bemenet: grid = [[",",""],[".","."]]
Kimenet: 0
Magyarázat:
Egyetlen almátrixban sem található legalább egy „X”.

Korlátozások:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] is either 'X', 'Y', or '.'.

Adott egy 2D karaktermátrix rács, ahol a grid[i][j] 'X', 'Y' vagy '.', adja vissza azoknak a szubmátrixoknak a számát, amelyek tartalmazzák:

grid[0][0]
az "X" és az "Y" egyenlő gyakorisága.
legalább egy "X".

1. példa:

Bemenet: grid = [["X","Y","."],["Y",".","."]]
Kimenet: 3
Magyarázat:

2. példa:

Bemenet: grid = [["X","X"],["X","Y"]]
Kimenet: 0
Magyarázat:
Egyetlen almátrixnak sincs azonos frekvenciája "X" és "Y".

3. példa:

Bemenet: grid = [[".","."],[".","."]]
Kimenet: 0
Magyarázat:
Egyetlen almátrixnak sincs legalább egy "X".

Korlátok:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] lehet 'X', 'Y' vagy '.'.


Kapsz egy karakterlánc célt, egy karakterláncszavak tömbjét és egy egész szám tömb költségeit, mindkét tömb azonos hosszúságú.
Képzeljünk el egy üres karakterláncot s.
A következő műveletet tetszőleges számú alkalommal végrehajthatja (beleértve a nullát is):

Válasszon egy i indexet a [0, words.length - 1] tartományban.
Fűzd hozzá words[i] értéket s-hez.
A művelet költsége costs[i].

Adja vissza a minimális költséget, hogy s egyenlő legyen a céllal. Ha ez nem lehetséges, adjon vissza -1-et.

1. példa:

Bemenet: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Kimenet: 7
Magyarázat:
A minimális költség a következő műveletek végrehajtásával érhető el:

Válassza ki az 1-es indexet, és fűzze hozzá az "abc"-t az s-hez 1 költséggel, így s = "abc" lesz.
Válassza ki a 2-es indexet, és 1-es költséggel fűzze hozzá a "d"-t az s-hez, így s = "abcd" lesz.
Válassza ki a 4-es indexet, és fűzze hozzá az "ef"-et az s-hez 5-ös költséggel, így s = "abcdef" lesz.

2. példa:

Bemenet: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Kimenet: -1
Magyarázat:
Lehetetlen, hogy s egyenlő legyen a céllal, ezért -1-et adunk vissza.

Korlátozások:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
words[i].length összegének teljes összege legfeljebb 5 * 10^4.
target és words[i] csak kisbetűs angol betűkből áll.
1 <= costs[i] <= 10^4

Adott egy target string, egy words string tömb és egy costs egész szám tömb, mindkét tömb azonos hosszúságú.
Képzeljünk el egy üres s stringet.
A következő műveletet tetszőleges számú alkalommal végrehajthatjuk (beleértve a nullát is):

Válassz egy i indexet a [0, words.length - 1] tartományban.
Fűzd hozzá words[i] értéket s-hez.
A művelet költsége costs[i].

Add vissza a minimális költséget, amely szükséges s-nek target-té alakításához. Ha nem lehetséges, térj vissza -1-gyel.

1. példa:

Input: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Output: 7
Magyarázat:
A minimális költség az alábbi műveletek végrehajtásával érhető el:

Válaszd az 1-es indexet, és fűzd hozzá az "abc" értéket s-hez 1-es költséggel, ekkor s = "abc".
Válaszd a 2-es indexet, és fűzd hozzá a "d" értéket s-hez 1-es költséggel, ekkor s = "abcd".
Válaszd a 4-es indexet, és fűzd hozzá az "ef" értéket s-hez 5-ös költséggel, ekkor s = "abcdef".

2. példa:

Input: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Output: -1
Magyarázat:
Nem lehetséges s-t a target-té alakítani, így visszaadjuk -1.

Korlátozások:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
words[i].length összegének teljes összege legfeljebb 5 * 10^4.
target és words[i] csak kisbetűs angol betűkből áll.
1 <= costs[i] <= 10^4

Kap egy sztringcélt, egy karakterlánc-szavak tömbjét és egy egész tömb költségeit, mindkettő azonos hosszúságú tömb.
Képzeljünk el egy üres s karakterláncot.
A következő műveletet tetszőleges számú alkalommal elvégezheti (beleértve a nullát is):

Válasszon egy i indexet a [0, words.length - 1] tartományban.
Szavak hozzáfűzése [i] az s-hez.
A működési költség költség[i].

Adja vissza a minimális költséget, hogy s egyenlő legyen a céllal. Ha ez nem lehetséges, adja vissza a -1 értéket.

1. példa:

Bemenet: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Kimenet: 7
Magyarázat:
A minimális költség a következő műveletek végrehajtásával érhető el:

Válassza ki az 1-es indexet, és fűzze hozzá az "abc" -t s-hez 1 költséggel, ami s = "abc" értéket eredményez.
Válassza ki a 2. indexet, és fűzze hozzá a "d" betűt s-hez 1 költséggel, ami s = "abcd" értéket eredményez.
Válassza ki a 4-es indexet, és fűzze hozzá az "ef" szót s-hez 5 költséggel, ami s = "abcdef" eredményt eredményez.

2. példa:

Bemenet: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Kimenet: -1
Magyarázat:
Lehetetlen s egyenlő a céllal, ezért -1-et adunk vissza.

Korlátok:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
A szavak teljes összege[i].length kisebb vagy egyenlő, mint 5 * 10^4.
cél és szavak[i] csak kisbetűs angol betűkből állnak.
1 <= costs[i] <= 10^4


Adott egy s karakterlánc, amely csak számjegyeket tartalmaz, adja vissza a lexikográfiailag legkisebb karakterláncot, amely az s szomszédos számjegyeinek azonos paritással történő cseréje után legfeljebb egyszer kapható.
A számjegyek paritása azonos, ha mindkettő páratlan vagy mindkettő páros. Például az 5 és a 9, valamint a 2 és 4 azonos paritással rendelkezik, míg a 6 és 9 nem.

1. példa:

Bemenet: s = "45320"
Kimenet: "43520"
Magyarázat:
Az s[1] == '5' és az s[2] == '3' paritása megegyezik, és felcserélve lexikográfiailag legkisebb karakterláncot kapunk.

2. példa:

Bemenet: s = "001"
Kimenet: "001"
Magyarázat:
Nincs szükség cserére, mert lexikográfiailag már s a legkisebb.

Korlátok:

2 <= s.length <= 100
s csak számjegyekből áll.

Adott egy s karakterlánc, amely csak számjegyeket tartalmaz, akkor azt a lexikográfiailag legkisebb karakterláncot adja vissza, amelyet az s-ben lévő szomszédos számjegyek legfeljebb egyszeri azonos paritású felcserélése után kaphatunk.
A számjegyek azonos paritásúak, ha mindkettő páratlan vagy mindkettő páros. Például 5 és 9, valamint 2 és 4 azonos paritású, míg 6 és 9 nem.

1. példa:

Bemenet: s = "45320"
Kimenet: "43520"
Magyarázat:
s[1] == '5' és s[2] == '3' azonos paritású, és felcserélésük a lexikográfiailag legkisebb karakterláncot eredményezi.

2. példa:

Bemenet: s = "001"
Kimenet: "001"
Magyarázat:
Nincs szükség cserére, mert az s már lexikográfiailag a legkisebb.

Korlátozások:

2 <= s.length <= 100
s csak számjegyekből áll.


Van egy m x n méretű torta, amelyet 1 x 1 darabra kell vágni.
Adott m, n egész számok és két tömb:

ahol a horizontalCut[i] az i vízszintes vonal mentén történő vágás költségét jelenti.
verticalCut n - 1 méretű, ahol verticalCut[j] a j függőleges vonal mentén történő vágás költségét jelenti.

Egy műveletben kiválaszthatjuk bármelyik tortadarabot, amely még nem 1 x 1 négyzet, és elvégezhetjük az alábbi vágások egyikét:

Vágás az i vízszintes vonal mentén a horizontalCut[i] költséggel.
Vágás a j függőleges vonal mentén a verticalCut[j] költséggel.

A vágás után a tortadarabot két különböző darabra osztjuk.
A vágás költsége csak a vonal kezdeti költségétől függ, és nem változik.
Adja vissza a teljes torta 1 x 1 darabra vágásának minimális összköltségét.

Példa 1:

Bemenet: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5].
Kimenet: 13
Magyarázat:

Végezzen vágást a 0 függőleges vonalon 5 költséggel, a jelenlegi összköltség 5.
Végezze el a vágást a 0 vízszintes vonalon a 3 x 1 alrácson 1 költséggel.
Végezze el a vágást a 0 vízszintes vonalon a 3 x 1 alrácson 1 költséggel.
Végezzen vágást az 1. vízszintes vonalon a 2 x 1 alrácson 3 költséggel.
Végezzen vágást az 1. vízszintes vonalon a 2 x 1 alrácson 3 költséggel.

A teljes költség 5 + 1 + 1 + 3 + 3 = 13.

Példa 2:

Bemenet: m = 2, n = 2, horizontalCut = [7], verticalCut = [4].
Kimenet: 15
Magyarázat:

Végezzen vágást a 0 vízszintes vonalon 7 költséggel.
Végezze el a vágást a 0 függőleges vonalon az 1 x 2 alrácson 4 költséggel.
Végezze el a vágást a 0 függőleges vonalon az 1 x 2 alrácson 4 költséggel.

A teljes költség 7 + 4 + 4 = 15.

Korlátozások:

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3

Van egy m x n torta, amit 1 x 1 darabra kell vágni.
Kapsz egy m, n egész számot és két tömböt:

m - 1 méretű vízszintes vágás, ahol a vízszintes vágás[i] az i vízszintes vonal mentén történő vágás költségét jelenti.
n - 1 méretű függőleges vágás, ahol a függőlegesVágás[j] a j függőleges vonal mentén történő vágás költségét jelenti.

Egy művelettel kiválaszthat bármilyen tortát, amely még nem 1 x 1 négyzet, és végrehajthatja a következő vágások egyikét:

Vágás egy vízszintes i vonal mentén vízszintesVágás[i] költséggel.
Vágás függőleges j vonal mentén függőlegesVágás[j] költséggel.

A vágás után a tortadarabot két különálló részre osztjuk.
A vágás költsége csak a vonal kezdeti költségétől függ, és nem változik.
A teljes torta 1 x 1 darabra vágásához adja vissza a minimális összköltséget.

1. példa:

Bemenet: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Kimenet: 13
Magyarázat:

Végezzen vágást a 0 függőleges vonalon 5 költséggel, a jelenlegi összköltség 5.
Végezzen egy vágást a 0 vízszintes vonalon 3 x 1 részrácson 1 költséggel.
Végezzen egy vágást a 0 vízszintes vonalon 3 x 1 részrácson 1 költséggel.
Végezzen vágást az 1. vízszintes vonalon a 2 x 1 részrácson 3-as költséggel.
Végezzen vágást az 1. vízszintes vonalon a 2 x 1 részrácson 3-as költséggel.

A teljes költség 5 + 1 + 1 + 3 + 3 = 13.

2. példa:

Bemenet: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Kimenet: 15
Magyarázat:

Végezzen vágást a 0 vízszintes vonalon 7 költséggel.
Végezzen vágást a 0 függőleges vonalon 1 x 2-es alrácson 4-es költséggel.
Végezzen vágást a 0 függőleges vonalon 1 x 2-es alrácson 4-es költséggel.

A teljes költség 7 + 4 + 4 = 15.

Korlátozások:

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3


Két pozitív egész számot kapunk n és k.
Az n bináris ábrázolásában bármelyik bitet kiválaszthatja, amely egyenlő 1-gyel, és megváltoztathatja 0-ra.
Adja vissza az ahhoz szükséges módosítások számát, hogy n egyenlő legyen k-val. Ha ez lehetetlen, térjen vissza -1.

1. példa:

Bemenet: n = 13, k = 4
Kimenet: 2
Magyarázat:
Kezdetben n és k bináris ábrázolásai n = (1101)_2 és k = (0100)_2.
Megváltoztathatjuk az n első és negyedik bitjét. Az eredményül kapott egész szám n = (0100)_2 = k.

2. példa:

Bemenet: n = 21, k = 21
Kimenet: 0
Magyarázat:
n és k már egyenlő, így nincs szükség változtatásokra.

3. példa:

Bemenet: n = 14, k = 13
Kimenet: -1
Magyarázat:
Nem lehet n egyenlő k-val.

Korlátok:

1 <= n, k <= 10^6

Kapsz két pozitív egész számot, n és k.
Az n bináris ábrázolásában bármely olyan bitet kiválaszthat, amely egyenlő 1-gyel, és megváltoztathatja 0-ra.
Adja vissza a változtatások számát ahhoz, hogy n egyenlő legyen k-val. Ha ez nem lehetséges, adjon vissza -1-et.

1. példa:

Bemenet: n = 13, k = 4
Kimenet: 2
Magyarázat:
Kezdetben n és k bináris reprezentációi n = (1101)_2 és k = (0100)_2.
Megváltoztathatjuk n első és negyedik bitjét. A kapott egész szám n = (0100)_2 = k.

2. példa:

Bemenet: n = 21, k = 21
Kimenet: 0
Magyarázat:
n és k már egyenlőek, tehát nincs szükség változtatásra.

3. példa:

Bemenet: n = 14, k = 13
Kimenet: -1
Magyarázat:
Nem lehet egyenlővé tenni n-t k-val.

Korlátozások:

1 <= n, k <= 10^6


Alice és Bob egy húron játszanak.
Kapsz egy s karakterláncot, Alice és Bob felváltva játsszák a következő játékot, ahol Alice kezd először:

Alice sorában el kell távolítania minden nem üres részstringet az s-ből, amely páratlan számú magánhangzót tartalmaz.
Bob körében el kell távolítania minden nem üres részstringet az s-ből, amely páros számú magánhangzót tartalmaz.

Az első játékos, aki a saját körében nem tud lépést tenni, elveszíti a játékot. Feltételezzük, hogy Alice és Bob is optimálisan játszanak.
Igazat ad vissza, ha Alice megnyeri a játékot, és hamis értéket egyébként.
Az angol magánhangzók: a, e, i, o és u.

1. példa:

Bemenet: s = "leetcoder"
Kimenet: true
Magyarázat:
Alice a következőképpen nyerheti meg a játékot:

Alice játszik először, ő törölheti az aláhúzott részstringet az s = "leetcoder"-ben, amely 3 magánhangzót tartalmaz. Az eredményül kapott karakterlánc s = "der".
Bob másodikként játszik, törölheti a 0 magánhangzót tartalmazó s = "der" karakterlánc aláhúzott részét. Az eredményül kapott karakterlánc s = "er".
Alice harmadikként játszik, törölheti az egész s = "er" karakterláncot, amely 1 magánhangzót tartalmaz.
Bob negyedikként játszik, mivel a húr üres, Bob számára nincs érvényes játék. Így Alice megnyeri a játékot.

2. példa:

Bemenet: s = "bbcd"
Kimenet: false
Magyarázat:
Alice számára nincs érvényes játék az első körben, így Alice elveszíti a játékot.

Korlátozások:

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

Alice és Bob játszanak egy húron.
Kapsz egy húrt, Alice és Bob felváltva játsszák a következő játékot, ahol Alice kezd először:

Alice során törölnie kell az s-ből bármely nem üres részkarakterláncot, amely páratlan számú magánhangzót tartalmaz.
Bob viszont el kell távolítania minden nem üres részkarakterláncot az s-ből, amely páros számú magánhangzót tartalmaz.

Az első játékos, aki nem tud lépni a sorában, elveszíti a játékot. Feltételezzük, hogy Alice és Bob is optimálisan játszik.
Adj vissza igaz értéket, ha Alice nyer, és hamis értéket egyébként.
Az angol magánhangzók: a, e, i, o és u.

1. példa:

Bemenet: s = "leetcoder"
Kimenet: true
Magyarázat:
Alice a következőképpen nyerheti meg a játékot:

Alice játszik először, törölheti az aláhúzott részkarakterláncot az s = "leetcoder" -ben, amely 3 magánhangzót tartalmaz. Az eredményül kapott karakterlánc s = "der".
Bob másodikként játszik, törölheti az aláhúzott alkarakterláncot az s = "der" -ben, amely 0 magánhangzót tartalmaz. Az eredményül kapott karakterlánc s = "er".
Alice harmadikként játszik, törölheti az egész s = "er" karakterláncot, amely 1 magánhangzót tartalmaz.
Bob negyedikként játszik, mivel a karakterlánc üres, nincs érvényes játék Bob számára. Tehát Alice megnyeri a játékot.

2. példa:

Bemenet: s = "bbcd"
Kimenet: false
Magyarázat:
Alice számára nincs érvényes játék az első körben, így Alice elveszíti a játékot.

Korlátok:

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

Alice és Bob játszanak egy játékot egy húron.
Kapsz egy karakterláncot, Alice és Bob felváltva játsszák a következő játékot, ahol Alice kezd először:

Alice sorában el kell távolítania bármely nem üres részstringet az s karakterláncból, amely páratlan számú magánhangzót tartalmaz.
Bob körében el kell távolítania bármely nem üres részstringet az s karakterláncból, amely páros számú magánhangzót tartalmaz.

Az első játékos, aki a saját körében nem tud lépést tenni, elveszíti a játékot. Feltételezzük, hogy Alice és Bob is optimálisan játszanak.
Igazat ad vissza, ha Alice megnyeri a játékot, és hamis értéket egyébként.
Az angol magánhangzók: a, e, i, o és u.

1. példa:

Bemenet: s = "leetcoder"
Kimenet: true
Magyarázat:
Alice a következőképpen nyerheti meg a játékot:

Alice játszik először, ő törölheti az aláhúzott részstringet az s = "leetcoder"-ben, amely 3 magánhangzót tartalmaz. Az eredményül kapott karakterlánc s = "der".
Bob másodikként játszik, törölheti a 0 magánhangzót tartalmazó s = "der" karakterlánc aláhúzott részét. Az eredményül kapott karakterlánc s = "er".
Alice harmadikként játszik, törölheti a teljes s = "er" karakterláncot, amely 1 magánhangzót tartalmaz.
Bob negyedikként játszik, mivel a karakterlánc üres, nincs érvényes játék Bob számára. Így Alice megnyeri a játékot.

2. példa:

Bemenet: s = "bbcd"
Kimenet: false
Magyarázat:
Alice számára nincs érvényes játék az első körben, így Alice elveszíti a játékot.

Korlátozások:

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


Adott egy s bináris karakterlánc.
A karakterláncon tetszőlegesen sokszor elvégezhetjük a következő műveletet:

Válasszunk ki egy olyan i indexet a karakterláncból, ahol i + 1 < s.length, úgy, hogy s[i] == '1' és s[i + 1] == '0'.
Mozgassa az s[i] karaktert jobbra, amíg el nem éri a karakterlánc végét vagy egy másik "1" -et. Például s = "010010" esetén, ha i = 1-et választunk, a kapott karakterlánc s = "000110" lesz.

Visszaadja a maximálisan elvégezhető műveletek számát.

Példa 1:

Bemenet: s = "1001101"
Kimenet: 4
Magyarázat:
A következő műveleteket végezhetjük el:

Válasszuk az i = 0 indexet. Az eredmény s ="0011101".
Válasszuk az i = 4 indexet. A kapott karakterlánc s = "0011011".
Válasszuk az i = 3 indexet. A kapott karakterlánc s = "0010111".
Válassza az i = 2 indexet. A kapott karakterlánc s = "0001111".

Példa 2:

Bemenet: s = "00111"
Kimenet: 0

Korlátozások:

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

Kapsz egy bináris karakterláncot s.
A következő műveletet tetszőleges számú alkalommal végrehajthatja a karakterláncon:

Válasszon ki egy tetszőleges i indexet a karakterláncból, ahol i + 1 < s.length úgy, hogy s[i] == '1' és s[i + 1] == '0'.
Mozgassa az s[i] karaktert jobbra, amíg el nem éri a karakterlánc végét vagy egy másik '1'-et. Például s = "010010" esetén, ha i = 1-et választunk, az eredményül kapott karakterlánc s = "000110" lesz.

Adja vissza a végrehajtható műveletek maximális számát.

1. példa:

Bemenet: s = "1001101"
Kimenet: 4
Magyarázat:
A következő műveleteket tudjuk elvégezni:

Válassza az i = 0 indexet. A kapott karakterlánc s = "0011101".
Válassza az i = 4 indexet. Az eredményül kapott karakterlánc s = "0011011".
Válassza az i = 3 indexet. A kapott karakterlánc s = "0010111".
Válassza az i = 2 indexet. A kapott karakterlánc s = "0001111".

2. példa:

Bemenet: s = "00111"
Kimenet: 0

Korlátozások:

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

Kapsz egy bináris karakterláncot s.
A következő műveletet tetszőleges számú alkalommal végrehajthatja a karakterláncon:

Válasszon ki egy tetszőleges i indexet a karakterláncból, ahol i + 1 < s.length úgy, hogy s[i] == '1' és s[i + 1] == '0'.
Mozgassa az s[i] karaktert jobbra, amíg el nem éri a karakterlánc végét vagy egy másik '1'-et. Például s = "010010" esetén, ha i = 1-et választunk, akkor a kapott karakterlánc s = "000110" lesz.

Adja vissza a végrehajtható műveletek maximális számát.

Példa 1:

Bemenet: s = "1001101"
Kimenet: 4
Magyarázat:
A következő műveleteket tudjuk elvégezni:

Válassza az i = 0 indexet. A kapott karakterlánc s = "0011101".
Válassza az i = 4 indexet. Az eredményül kapott karakterlánc s = "0011011".
Válassza az i = 3 indexet. A kapott karakterlánc s = "0010111".
Válassza az i = 2 indexet. A kapott karakterlánc s = "0001111".

Példa 2:

Bemenet: s = "00111"
Kimenet: 0

Korlátozások:

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


Két pozitív egész számokat tartalmazó tömböt kapsz: nums és target, amelyek azonos hosszúságúak.
Egyetlen művelet során ki tudsz választani a nums egy tetszőleges rész-tömbjét, és minden elemet ezen a rész-tömbön belül növelhetsz vagy csökkenthetsz 1-gyel.
Add vissza a szükséges minimális műveletek számát, hogy a nums-t egyenlővé tedd a target tömbbel.

1. példa:

Bemenet: nums = [3,5,1,2], target = [4,6,2,4]
Kimenet: 2
Magyarázat:
A következő műveleteket hajtjuk végre, hogy a számokat egyenlővé tegyük a céllal:
- Növeld a nums[0..3] értékét 1-gyel, nums = [4,6,2,3].
- Növeld a nums[3..3] értékét 1-gyel, nums = [4,6,2,4].

2. példa:

Bemenet: nums = [1,3,2], target = [2,1,4]
Kimenet: 5
Magyarázat:
A következő műveleteket hajtjuk végre, hogy a nums egyenlővé tegyük a céllal:
- A nums[0..0] növelése 1-gyel, a nums = [2,3,2].
- Csökkentse a nums[1..1] 1-gyel, a nums = [2,2,2].
- Csökkentse a nums[1..1] 1-gyel, a nums = [2,1,2].
- A nums[2..2] növelése 1-gyel, a nums = [2,1,3].
- A nums[2..2] növelése 1-gyel, a nums = [2,1,4].

Korlátozások:

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

Kap két pozitív egész tömböt, a nums és a target, azonos hosszúságúakat.
Egyetlen művelettel kijelölheti a számok bármely résztömbjét, és a résztömb minden elemét 1-gyel növelheti vagy csökkentheti.
Visszaadja azt a minimális műveletszámot, amely ahhoz szükséges, hogy a számok egyenlőek legyenek a tömbcéllal.

1. példa:

Bemenet: nums = [3,5,1,2], target = [4,6,2,4]
Output: 2
Kimenet: 2
Magyarázat:
A következő műveleteket hajtjuk végre, hogy a számok egyenlőek legyenek a céllal:
- Növeljük nums[0..3] 1-gyel, nums = [4,6,2,3].
- Növekmény nums[3..3] 1-gyel, nums = [4,6,2,4].

2. példa:

Bemenet: nums = [1,3,2], target = [2,1,4]
Kimenet: 5
Magyarázat:
A következő műveleteket hajtjuk végre, hogy a számok egyenlőek legyenek a céllal:
- Növekmény nums[0..0] 1-gyel, nums = [2,3,2].
- Csökkentjük nums[1..1] 1-gyel, nums = [2,2,2].
- Csökkenő számok[1..1] 1-gyel, nums = [2,1,2].
- Növeljük nums[2..2] 1-gyel, nums = [2,1,3].
- Növekmény nums[2..2] 1-gyel, nums = [2,1,4].

Korlátok:

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

Két azonos hosszúságú pozitív egész tömb, szám és cél.
Egyetlen művelettel kiválaszthatja a számokból álló tetszőleges altömböt, és 1-gyel növelheti vagy csökkentheti az adott altömb minden elemét.
Adja vissza a minimális számú műveletet ahhoz, hogy a számok megegyezzenek a tömb céljával.

1. példa:

Bemenet: nums = [3,5,1,2], target = [4,6,2,4]
Kimenet: 2
Magyarázat:
A következő műveleteket hajtjuk végre, hogy a számokat egyenlővé tegyük a céllal:
- A nums[0..3] növelése 1-gyel, a nums = [4,6,2,3].
- A nums[3..3] növelése 1-gyel, a nums = [4,6,2,4].

2. példa:

Bemenet: nums = [1,3,2], target = [2,1,4]
Kimenet: 5
Magyarázat:
A következő műveleteket hajtjuk végre, hogy a számokat egyenlővé tegyük a céllal:
- A nums[0..0] növelése 1-gyel, anums = [2,3,2].
- Csökkentse a nums[1..1] 1-gyel, a nums = [2,2,2].
- Csökkentse a nums[1..1] 1-gyel, a nums = [2,1,2].
- A nums[2..2] növelése 1-gyel, a nums = [2,1,3].
- A nums[2..2] növelése 1-gyel, anums = [2,1,4].

Korlátozások:

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


Kapsz egy sor pozitív egész számot, nums.
Alice és Bob játszmában játszanak. A játékban Alice kiválaszthatja az összes egyjegyű számot vagy az összes kétjegyű számot a számok közül, a többi számot pedig Bob kapja. Alice akkor nyer, ha a számok összege szigorúan nagyobb, mint Bob számainak összege.
Visszatérés igaz, ha Alice meg tudja nyerni ezt a játékot, különben hamis értéket ad vissza.

1. példa:

Bemenet: nums = [1,2,3,4,10]
Kimenet: false
Magyarázat:
Alice nem nyerhet sem egyjegyű, sem kétjegyű számok választásával.

2. példa:

Bemenet: nums = [1,2,3,4,5,14]
Kimenet: true
Magyarázat:
Alice nyerhet, ha egyjegyű számokat választ, amelyek összege 15.

3. példa:

Bemenet: nums = [5,5,5,25]
Kimenet: true
Magyarázat:
Alice nyerhet, ha kétjegyű számokat választ, amelyek összege 25.

Korlátok:

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

Adott egy tömb pozitív egész számok nums.
Alice és Bob egy játékot játszanak. A játékban Alice vagy az összes egyjegyű számot, vagy az összes kétjegyű számot választhatja ki a numsból, a többi számot pedig Bob kapja meg. Alice akkor nyer, ha az ő számainak összege szigorúan nagyobb, mint Bob számainak összege.
Visszaadja a true értéket, ha Alice megnyerheti ezt a játékot, ellenkező esetben false értéket ad vissza.

1. példa:

Bemenet:nums = [1,2,3,4,10]
Kimenet: false
Magyarázat:
Alice sem egy-, sem kétjegyű számok kiválasztásával nem nyerhet.

2. példa:

Bemenet: nums = [1,2,3,4,5,14]
Kimenet: true
Magyarázat:
Alice nyerhet olyan egyjegyű számok kiválasztásával, amelyek összege 15-ös.

3. példa:

Bemenet: nums = [5,5,5,25]
Kimenet: true
Explanation:
Alice nyerhet, ha olyan kétszámjegyű számokat választ, amelyek összege 25-ös.

Korlátozások:

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

Pozitív egész számokból álló tömböt kapsz.
Alice és Bob játszanak. A játékban Alice vagy az összes egyjegyű számot, vagy az összes kétjegyű számot kiválaszthatja a számokból, a többi számot pedig Bob kapja. Alice nyer, ha a számok összege szigorúan nagyobb, mint Bob számainak összege.
Igazat ad vissza, ha Alice meg tudja nyerni ezt a játékot, ellenkező esetben hamis értéket ad vissza.

1. példa:

Bemenet: nums = [1,2,3,4,10]
Kimenet: hamis
Magyarázat:
Alice nem nyerhet az egy- vagy kétjegyű számok kiválasztásával.

2. példa:

Bemenet: nums = [1,2,3,4,5,14]
Kimenet: igaz
Magyarázat:
Alice nyerhet, ha olyan egyjegyű számokat választ, amelyek összege 15.

3. példa:

Bemenet: nums = [5,5,5,25]
Kimenet: igaz
Magyarázat:
Alice nyerhet, ha olyan kétjegyű számokat választ, amelyek összege 25.

Korlátozások:

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


Két pozitív egész számot l és r kapsz. Bármely x szám esetén x összes pozitív osztója, kivéve x-et, az x valódi osztóinak nevezik. Egy számot akkor nevezünk különlegesnek, ha pontosan 2 valódi osztóval rendelkezik. Például:

A 4 szám különleges, mert valódi osztói 1 és 2.
A 6 szám nem különleges, mert valódi osztói 1, 2 és 3.

Add vissza a [l, r] intervallumban található nem különleges számok számát.

1. példa:

Input: l = 5, r = 7
Output: 3
Magyarázat:
Nincsenek különleges számok az [5, 7] intervallumban.

2. példa:

Input: l = 4, r = 16
Output: 11
Magyarázat:
A különleges számok a [4, 16] intervallumban: 4 és 9.

Feltételek:

1 <= l <= r <= 10^9

Kapsz 2 pozitív egész számot: l és r. Bármely x szám esetén x minden pozitív osztóját x-et kivéve x megfelelő osztójának nevezzük.
Egy számot akkor nevezünk speciálisnak, ha pontosan 2 megfelelő osztója van. Például:

A 4-es szám különleges, mert megfelelő osztói 1 és 2.
A 6-os szám nem különleges, mert megfelelő osztói vannak: 1, 2 és 3.

Adja vissza az [l, r] tartományba eső, nem speciális számok számát.

1. példa:

Bemenet: l = 5, r = 7
Kimenet: 3
Magyarázat:
Nincsenek speciális számok az [5, 7] tartományban.

2. példa:

Bemenet: l = 4, r = 16
Kimenet: 11
Magyarázat:
A speciális számok a [4, 16] tartományban a 4 és a 9.

Korlátozások:

1 <= l <= r <= 10^9

Kapsz 2 pozitív egész számot, l és r. Bármely x szám esetén x minden pozitív osztóját x-et kivéve x megfelelő osztójának nevezzük.
Egy számot akkor nevezünk speciálisnak, ha pontosan 2 megfelelő osztója van. Például:

A 4-es szám különleges, mert megfelelő osztói vannak 1-nek és 2-nek.
A 6-os szám nem különleges, mert megfelelő osztói 1, 2 és 3 vannak.

Adja vissza az [l, r] tartományba eső, nem speciális számok számát.

1. példa:

Bemenet: l = 5, r = 7
Kimenet: 3
Magyarázat:
Az [5, 7] tartományban nincsenek speciális számok.

2. példa:

Bemenet: l = 4, r = 16
Kimenet: 11
Magyarázat:
A [4, 16] tartományban a speciális számok a 4 és a 9.

Korlátozások:

1 <= l <= r <= 10^9


Adott egy s bináris karakterlánc.
Adja vissza a domináns egyesekkel rendelkező részláncok számát.
Egy karakterláncnak akkor van domináns egyese, ha a karakterláncban lévő egyesek száma nagyobb vagy egyenlő a karakterláncban lévő nullák számának négyzetével.

1. példa:

Bemenet: s = "00011"
Kimenet: 5
Magyarázat:
A domináns részsorok az alábbi táblázatban láthatók.

i
j
s[i..j]
Nullák száma
Egyek száma

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

2. példa:

Bevitel: s = "101101"”
Kimenet: 16
Magyarázat:
A nem domináns részsorok az alábbi táblázatban láthatók.
Mivel összesen 21 részsorozat van, és ezek közül 5 nem domináns, ebből következik, hogy 16 domináns részsorozat van.

i
j
s[i..j]
Nulla szám
Egyek száma

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Korlátozások:

1 <= s.length <= 4 * 10^4
s csak „0” és „1” karakterekből áll.

Kapsz egy bináris karakterláncot s.
Adja vissza a domináns karakterláncok számát.
Egy karakterláncnak vannak dominánsai, ha a karakterláncban lévő egyesek száma nagyobb vagy egyenlő, mint a karakterlánc nulláinak négyzete.

1. példa:

Bemenet: s = "00011"
Kimenet: 5
Magyarázat:
A domináns karakterláncokat az alábbi táblázat mutatja.

én
j
s[i..j]
Nullák száma
Egyesek száma

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

2. példa:

Bemenet: s = "101101"
Kimenet: 16
Magyarázat:
A nem domináns karakterláncokat az alábbi táblázat mutatja.
Mivel összesen 21 részkarakterlánc van, és ebből 5 nem domináns, ebből az következik, hogy 16 részstring van dominánssal.

én
j
s[i..j]
Nullák száma
Egyesek száma

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Korlátozások:

1 <= s.length <= 4 * 10^41 <= s.hossz <= 4 * 10^4
s csak '0' és '1' karakterekből áll.

Kapsz egy bináris karakterláncot s.
Adja vissza a domináns karakterláncok számát.
Egy karakterláncnak vannak dominánsai, ha a karakterláncban lévő egyesek száma nagyobb vagy egyenlő, mint a karakterlánc nulláinak négyzete.

1. példa:

Bemenet: s = "00011"
Kimenet: 5
Magyarázat:
A domináns karakterláncokat az alábbi táblázat mutatja.

i
j
s[i..j]
Nullák száma
Egyesek száma

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

2. példa:

Bemenet: s = "101101"
Kimenet: 16
Magyarázat:
A nem domináns karakterláncokat az alábbi táblázat mutatja.
Mivel összesen 21 részkarakterlánc van, és ebből 5 nem domináns, ebből az következik, hogy 16 részstring van dominánssal.

i
j
s[i..j]
Nullák száma
Egyesek száma

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Korlátozások:

1 <= s.length <= 4 * 10^4
s csak '0' és '1' karakterekből áll.


Kapunk két pozitív egész számot, xCorner és yCorner, valamint egy 2D tömb köröket, ahol a circles[i] = [x_i, y_i, r_i] olyan kört jelöl, amelynek középpontja (x_i, y_i) és sugara r_i.
A koordinátasíkban van egy téglalap, amelynek bal alsó sarka az origónál, a jobb felső sarok pedig a koordinátánál (xCorner, yCorner). Ellenőriznie kell, hogy van-e olyan útvonal a bal alsó saroktól a jobb felső sarokig, hogy a teljes útvonal a téglalapon belül legyen, ne érintsen vagy feküdjön bele egyetlen körbe sem, és csak a téglalapot a két sarkánál érinti.
Igaz, ha létezik ilyen elérési út, hamis értéket ad vissza.

Példa 1:

Bemenet: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Kimenet: true
Magyarázat:

A fekete görbe egy lehetséges utat mutat (0, 0) és (3, 4) között.

Példa 2:

Bemenet: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Kimenet: false
Magyarázat:

Nem létezik elérési út (0, 0) és (3, 3) között.

Példa 3:

Bemenet: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Kimenet: false
Magyarázat:

Nem létezik elérési út (0, 0) és (3, 3) között.

Példa 4:

Bemenet: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Kimenet: true
Magyarázat:

Korlátozások:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

Két pozitív egész számot kapunk, az xCorner és az yCorner, valamint egy 2D tömbköröket, ahol a körök[i] = [x_i, y_i, r_i] egy kört jelöl, amelynek középpontja (x_i, y_i) és sugara r_i.
A koordinátasíkon van egy téglalap, amelynek bal alsó sarka az origónál, jobb felső sarka pedig a koordinátánál (xCorner, yCorner). Ellenőriznie kell, hogy van-e olyan út a bal alsó saroktól a jobb felső sarokig, hogy az egész útvonal a téglalapon belül legyen, ne érintse meg vagy feküdjön egyetlen körön belül sem, és csak a két sarkon érintse meg a téglalapot.
Igaz értéket ad vissza, ha létezik ilyen elérési út, egyébként pedig hamis.

1. példa:

Bemenet: xCorner = 3, yCorner = 4, körök = [[2,1,1]]
Kimenet: true
Magyarázat:

A fekete görbe a (0, 0) és (3, 4) közötti lehetséges útvonalat mutatja.

2. példa:

Bemenet: xCorner = 3, yCorner = 3,circles= [[1,1,2]]
Kimenet: hamis
Magyarázat:

Nincs elérési út (0, 0) és (3, 3) között.

3. példa:

Bemenet: xCorner = 3, yCorner = 3, circles  = [[2,1,1],[1,2,1]]
Kimenet: hamis
Magyarázat:

Nincs elérési út (0, 0) és (3, 3) között.

4. példa:

Bemenet: xCorner = 4, yCorner = 4, körök = [[5,5,1]]
Kimenet: true
Magyarázat:

Korlátok:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

Két pozitív egész számot kapunk, az xCorner és az yCorner, valamint egy 2D tömbköröket, ahol circles[i] = [x_i, y_i, r_i] egy kört jelöl, amelynek középpontja (x_i, y_i) és sugara r_i.
A koordinátasíkon van egy téglalap, amelynek bal alsó sarka az origónál, jobb felső sarka pedig a koordinátánál (xCorner, yCorner). Ellenőriznie kell, hogy van-e olyan út a bal alsó saroktól a jobb felső sarokig, hogy az egész útvonal a téglalapon belül legyen, ne érintse meg vagy feküdjön egyetlen körön belül sem, és csak a két sarkon érintse meg a téglalapot.
Igaz értéket ad vissza, ha létezik ilyen elérési út, egyébként pedig hamis.

1. példa:

Bemenet: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Kimenet: true
Magyarázat:

A fekete görbe a (0, 0) és (3, 4) közötti lehetséges útvonalat mutatja.

2. példa:

Bemenet: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Kimenet: false
Magyarázat:

Nincs elérési út (0, 0) és (3, 3) között.

3. példa:

Bemenet: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Kimenet: false
Magyarázat:

Nincs elérési út (0, 0) és (3, 3) között.

4. példa:

Bemenet: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Kimenet: true
Magyarázat:

Korlátok:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9


Adott egy egész szám n és egy 2D-s egész szám tömb lekérdezések.

Van n város, amelyek 0-tól n - 1-ig vannak számozva. Kezdetben van egy egyirányú út a város i-ből város i + 1 felé minden 0 <= i < n - 1 esetén.

queries[i] = [u_i, v_i] egy új egyirányú út hozzáadását jelenti a város u_i-ből város v_i felé. Minden lekérdezés után meg kell találnod a legrövidebb út hosszát a város 0-tól város n - 1-ig.

Egy válasz tömböt kell visszaadni, ahol minden i esetén a [0, queries.length - 1] tartományban, answer[i] a legrövidebb út hossza a város 0-tól város n - 1-ig az első i + 1 lekérdezés feldolgozása után.

Példa 1:

Bemenet: n = 5, queries = [[2,4],[0,2],[0,4]]
Kimenet: [3,2,1]
Magyarázat:

A 2-ből 4-be vezető út hozzáadása után a 0-tól 4-ig tartó legrövidebb út hossza 3.

A 0-ból 2-be vezető út hozzáadása után a 0-tól 4-ig tartó legrövidebb út hossza 2.

A 0-ból 4-be vezető út hozzáadása után a 0-tól 4-ig tartó legrövidebb út hossza 1.

Példa 2:

Bemenet: n = 4, queries = [[0,3],[0,2]]
Kimenet: [1,1]
Magyarázat:

A 0-ból 3-ba vezető út hozzáadása után a 0-tól 3-ig tartó legrövidebb út hossza 1.

A 0-ból 2-be vezető út hozzáadása után a legrövidebb út hossza továbbra is 1.

Korlátozások:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
A lekérdezések között nincsenek ismétlődő utak.

Kap egy n egész és egy 2D egész tömb lekérdezést.
N város van 0-tól n - 1-ig számozva. Kezdetben egyirányú út van az i városból az i + 1 városba minden 0 <= i < n - 1 számára.
queries[i] = [u_i, v_i] egy új, egyirányú út hozzáadását jelenti a City u_i és a City v_i között. Minden lekérdezés után meg kell találnia a legrövidebb út hosszát a 0 várostól az n - 1 városig.
Adjon vissza egy tömbválaszt, ahol a [0, queries.length - 1] tartomány minden i-jére a answer[i] a 0 várostól az n - 1 városig vezető legrövidebb út hossza az első i + 1 lekérdezés feldolgozása után.

1. példa:

Bemenet: n = 5, queries = [[2,4],[0,2],[0,4]]
Kimenet: [3,2,1]
Magyarázat:

Az út 2-től 4-ig történő hozzáadása után a legrövidebb út hossza 0-tól 4-ig 3.

Az út 0-tól 2-ig történő hozzáadása után a legrövidebb út hossza 0-tól 4-ig 2.

Az út 0-tól 4-ig történő hozzáadása után a legrövidebb út hossza 0-tól 4-ig 1.

2. példa:

Bemenet: n = 4, queries = [[0,3],[0,2]]
Kimenet: [1,1]
Magyarázat:

Az út 0-tól 3-ig történő hozzáadása után a legrövidebb út hossza 0-tól 3-ig 1.

Az út 0-ról 2-re történő hozzáadása után a legrövidebb út hossza 1 marad.

Korlátok:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
A lekérdezések között nincsenek ismétlődő utak.

Egy n egész szám és egy 2D egész tömb lekérdezést kapunk.
n város van számozva 0-tól n-1-ig. Kezdetben minden 0 <= i < n - 1 esetén van egy egyirányú út i városból i + 1 városba.
queries[i] = [u_i, v_i] egy új egyirányú út hozzáadását jelenti u_i városból v_i városba. Minden lekérdezés után meg kell találnia a legrövidebb út hosszát 0 várostól n - 1 városig.
Adjon vissza egy tömbválaszt, ahol a [0, queries.length - 1] tartomány minden i-jére a válasz[i] a legrövidebb út hossza 0 városból n - 1 városba az első i + 1 lekérdezések feldolgozása után.

1. példa:

Bemenet: n = 5, queries = [[2,4],[0,2],[0,4]]
Kimenet: [3,2,1]
Magyarázat:

A 2-től 4-ig terjedő út hozzáadása után a 0-tól 4-ig tartó legrövidebb út hossza 3.

Az út 0-tól 2-ig való hozzáadása után a legrövidebb út hossza 0-tól 4-ig 2.

Az út 0-tól 4-ig történő hozzáadása után a legrövidebb út hossza 0-tól 4-ig 1.

2. példa:

Bemenet: n = 4, queries = [[0,3],[0,2]]
Kimenet: [1,1]
Magyarázat:

Az út 0-tól 3-ig történő hozzáadása után a legrövidebb út hossza 0-tól 3-ig 1.

Az út 0-ról 2-re való hozzáadása után a legrövidebb út hossza 1 marad.

Korlátozások:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
A lekérdezések között nincsenek ismétlődő utak.


Vannak körkörösen elhelyezett piros és kék lapkák. Egy egész számokból álló színtömböt és egy 2D egész számok tömb lekérdezést kap.
Az i csempe színét a színek [i] képviselik:

colors[i] == 0 azt jelenti, hogy az i csempe piros.
colors[i] == 1 azt jelenti, hogy az i csempe kék.

A váltakozó csoport a kör lapkáinak összefüggő részhalmaza váltakozó színekkel (a csoport minden lapkája, kivéve az első és az utolsó, más színű, mint a csoport szomszédos lapkái).
Két típusú lekérdezést kell feldolgoznia:

queries[i] = [1, méret_i], határozza meg a változó csoportok számát size_i mérettel.
queries[i] = [2, index_i, color_i], módosítsa a színeket[index_i] színre_i.

Adjon vissza egy tömbválaszt, amely sorrendben tartalmazza az első típusú lekérdezések eredményeit.
Vegye figyelembe, hogy mivel a színek egy kört jelölnek, az első és az utolsó lapkát egymás mellett lévőnek tekintjük.

1. példa:

Bemenet: colors = [0,1,1,0,1], queries= [[2,1,0],[1,4]]
Kimenet: [2]
Magyarázat:

Első lekérdezés:
Módosítsa a színeket[1] 0-ra.

Második lekérdezés:
A 4-es méretű váltakozó csoportok száma:

2. példa:

Bemenet: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0], [1,5]]
Kimenet: [2,0]
Magyarázat:

Első lekérdezés:
A 3-as méretű váltakozó csoportok száma:

Második kérdés: a színek nem változnak.
Harmadik lekérdezés: Nincs 5-ös méretű váltakozó csoport.

Korlátozások:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
Mindazért, ami:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Néhány piros és kék csempe van körkörösen elrendezve. Adott egy tömb egész számok színei és egy 2D egész számok tömbje lekérdezések.
Az i csempe színét a colors[i] jelöli:

colors[i] == 0 azt jelenti, hogy az i csempe piros.
colors[i] == 1 azt jelenti, hogy az i csempe kék.

A váltakozó csoport a körben lévő csempék egy összefüggő részhalmaza, amelynek színei váltakoznak (a csoportban az első és az utolsó csempe kivételével minden egyes csempe más színű, mint a csoportban lévő szomszédos csempéké).
Kétféle típusú lekérdezést kell feldolgoznia:

queries[i] = [1, size_i], határozza meg a size_i méretű váltakozó csoportok számát.
lekérdezések[i] = [2, index_i, color_i], a colors[index_i] színt változtassa color_i-re.

Visszaad egy tömbválaszt, amely az első típusú lekérdezések eredményeit tartalmazza sorrendben.
Vegyük észre, hogy mivel a színek egy kört ábrázolnak, az első és az utolsó csempet egymás mellett lévőnek tekintjük.

Példa 1:

Bemenet: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Kimenet: [2]
Magyarázat:

Első lekérdezés:
A colors[1] értékét 0-ra változtatja.

Második lekérdezés:
A 4-es méretű váltakozó csoportok száma:

Példa 2:

Bemenet: colors = [0,0,1,0,1,1,1], queries = [[1,3],[2,3,0],[1,5]]
Kimenet: [2,0]
Magyarázat:

Első lekérdezés:
A 3 méretű váltakozó csoportok száma:

Második lekérdezés: A színek nem változnak.
Harmadik lekérdezés: Nincs 5 méretű váltakozó csoport.

Korlátozások:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
lekérdezések[i][0] == 1 vagy lekérdezések[i][0] == 2
Minden i-re, amely:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1.

Vannak körkörösen elhelyezett piros és kék lapkák. Egy egész számokból álló színtömböt és egy 2D egész számok tömb lekérdezést kap.
Az i csempe színét a colors[i] képviselik:

colors[i] == 0 azt jelenti, hogy az i csempe piros.
colors[i] == 1 azt jelenti, hogy az i csempe kék.

A váltakozó csoport a körben lévő lapkák egybefüggő részhalmaza váltakozó színekkel (a csoport minden lapkája, kivéve az első és az utolsó, más színű, mint a csoport szomszédos lapkái).
Két típusú lekérdezést kell feldolgoznia:

queries[i] = [1, size_i], határozd meg a size_i méretű váltakozó csoportok számát.
queries[i] = [2, index_i, color_i], változtasd meg colors[index_i] értékét color_i-re.

Adjon vissza egy tömbválaszt, amely sorrendben tartalmazza az első típusú lekérdezések eredményeit.
Vegye figyelembe, hogy mivel a színek egy kört jelölnek, az első és az utolsó lapkát egymás mellett lévőnek tekintjük.

1. példa:

Bemenet: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Kimenet: [2]
Magyarázat:

Első lekérdezés:
Módosítsa a colors[1] 0-ra.

Második lekérdezés:
A 4-es méretű váltakozó csoportok száma:

2. példa:

Bemenet: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Kimenet: [2,0]
Magyarázat:

Első lekérdezés:
A 3-as méretű váltakozó csoportok száma:

Második kérdés: a színek nem változnak.
Harmadik lekérdezés: Nincs 5-ös méretű váltakozó csoport.

Korlátozások:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 vagy queries[i][0] == 2
Az összes i esetén:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1


Egy kígyó található egy n x n-es mátrix rácsban, és négy lehetséges irányba mozoghat. A rács minden celláját a következő pozíció azonosítja: grid[i][j] = (i * n) + j.
A kígyó a 0 cellából indul, és követi a parancsok sorozatát.
Adott egy egész szám n, amely a rács méretét jelöli, és egy parancsokból álló tömb, ahol minden command[i] lehet "UP", "RIGHT", "DOWN" és "LEFT". Garantált, hogy a kígyó a rács határain belül marad a mozgása során.
Add vissza annak a végső cellának a pozícióját, ahol a kígyó a parancsok végrehajtása után végződik.

Példa 1:

Bemenet: n = 2, commands = ["RIGHT","DOWN"]
Kimenet: 3
Magyarázat:

0
1

2
3

0
1

2
3

0
1

2
3

Példa 2:

Bemenet: n = 3, commands = ["DOWN","RIGHT","UP"]
Kimenet: 1
Magyarázat:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Korlátozások:

2 <= n <= 10
1 <= commands.length <= 100
A parancsok csak "UP", "RIGHT", "DOWN" és "LEFT" elemeket tartalmaznak.
A bemenet úgy van generálva, hogy a kígyó nem mozoghat a határokon kívülre.

Van egy kígyó egy n x n mátrixrácsban, és négy lehetséges irányban mozoghat. A rács minden celláját a pozíció azonosítja:  grid[i][j] = (i * n) + j.
A kígyó a 0. cellából indul, és parancsok sorozatát követi.
Kap egy n egész számot, amely a rács méretét jelöli, és egy sor karakterlánc-parancsot, ahol minden parancs[i] "UP", "RIGHT", "DOWN" és "LEFT". Garantált, hogy a kígyó mozgása során a rács határain belül marad.
Adja vissza az utolsó cella helyzetét, ahol a kígyó a parancsok végrehajtása után véget ér.

1. példa:

Bemenet: n = 2, parancsok = ["RIGHT","DOWN"]
Kimenet: 3
Magyarázat:

0
1

2
3

0
1

2
3

0
1

2
3

2. példa:

Bemenet:n = 3, commands = ["DOWN","RIGHT","UP"]
Kimenet: 1
Magyarázat:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Korlátok:

2 <= n <= 10
1 <= commands.length <= 100
commands consists only of "UP", "RIGHT", "DOWN", and "LEFT".
A bemenet úgy jön létre, hogy a kígyó nem mozdul el a határokon kívül.

Van egy kígyó egy n x n mátrixrácsban, és négy lehetséges irányba tud mozogni. A rács minden celláját a következő pozíció azonosítja: grid[i][j] = (i * n) + j.
A kígyó a 0. cellától indul, és parancssort követ.
Kapsz egy n egész számot, amely a rács méretét jelöli, és egy stringparancsok tömbjét, ahol minden parancs [i] „FEL”, „JOBBRA”, „LE” és „BALRA”. Garantált, hogy a kígyó mozgása során a rács határain belül marad.
Adja vissza az utolsó cella pozícióját, ahol a kígyó a parancsok végrehajtása után végez.

1. példa:

Bemenet: n = 2, commands =["RIGHT","DOWN"]
Kimenet: 3
Magyarázat:

0
1

2
3

0
1

2
3

0
1

2
3

2. példa:

Bemenet: n = 3, commands = ["DOWN","RIGHT","UP"]
Kimenet: 1
Magyarázat:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Korlátozások:

2 <= n <= 10
1 <= commands.length <= 100
commands csak "UP", "RIGHT", "DOWN" és "LEFT" elemeket tartalmaz.
A bemenet úgy van generálva, hogy a kígyó nem mozoghat a határokon kívülre.


Egy n hosszúságú pozitív egész számokból álló tömböt kapunk.
Egy pár nem negatív egész tömböt (arr1, arr2) monotonnak nevezünk, ha:

Mindkét tömb hossza n.
arr1 monoton nem csökkenő, más szóval arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
Az arr2 monoton nem növekvő, vagyis arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == számok[i] minden 0 <= i <= n - 1 esetén.

Adja vissza a monoton párok számát.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [2,3,2]
Kimenet: 4
Magyarázat:
A jó párok a következők:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

2. példa:

Bemenet: nums = [5,5,5,5]
Kimenet: 126

Korlátozások:

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

Adott egy n hosszúságú, pozitív egész számokból álló nums tömb.
Egy (arr1, arr2) nemnegatív egész számokból álló pár monoton, ha:

Mindkét tömb hossza n.
arr1 monoton nem csökkenő, más szóval: arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 monoton nem növekvő, más szóval arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] minden 0 <= i <= n - 1 esetén.

A monoton párok számának visszaadása.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

Példa 1:

Bemenet: nums = [2,3,2]
Kimenet: 4
Magyarázat:
A jó párok a következők:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

2. példa:

Bemenet nums = [5,5,5,5]
Kimenet: 126

Korlátozások:

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

Egy n hosszúságú pozitív egész számokból álló tömböt kapunk.
Egy pár nem negatív egész tömböt (arr1, arr2) monotonnak nevezünk, ha:

Mindkét tömb hossza n.
arr1 monoton nem csökkenő, más szóval arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
Az arr2 monoton nem növekvő, vagyis arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == számok[i] minden 0 <= i <= n - 1 esetén.

Adja vissza a monoton párok számát.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums= [2,3,2]
Kimenet: 4
Magyarázat:
A jó párok a következők:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

2. példa:

Bemenet: nums = [5,5,5,5]
Kimenet: 126

Korlátozások:

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


Kapsz egy s karakterláncot.
Az Ön feladata az összes számjegy eltávolítása a következő művelet ismételt végrehajtásával:

Törölje az első számjegyet és a legközelebbi nem számjegyű karaktert a bal oldalon.

Az összes számjegy eltávolítása után adja vissza a kapott karakterláncot.

1. példa:

Bemenet: s = "abc"
Kimenet: "abc"
Magyarázat:
A karakterláncban nincs számjegy.

2. példa:

Bemenet: s = "cb34"
Kimenet: ""
Magyarázat:
Először alkalmazzuk az s[2] műveletet, és s-ből "c4" lesz.
Ezután alkalmazzuk az s[1] műveletet, és s-ből "" lesz.

Korlátozások:

1 <= s.length <= 100
s csak kisbetűs angol betűkből és számjegyekből áll.
A bemenet úgy jön létre, hogy az összes számjegyet törölni lehessen.

Adott egy s karakterlánc.
A feladat az, hogy a művelet ismételt végrehajtásával minden számjegyet eltávolítson:

Töröljük az első számjegyet és a tőle balra lévő legközelebbi nem számjegyet.

Az összes számjegy eltávolítása után adja vissza a kapott karakterláncot.

Példa 1:

Bemenet: s ="abc"
Kimenet: "abc"
Magyarázat:
A karakterláncban nincs számjegy.

Példa 2:

Bemenet: s = "cb34"
Kimenet:""
Magyarázat:
Először alkalmazzuk a műveletet s-re[2], és s "c4" lesz.
Ezután alkalmazzuk a műveletet s[1]-re, és s lesz "".

Korlátozások:

1 <= s.length <= 100
s csak kisbetűs angol betűkből és számjegyekből áll.
A bemenetet úgy generáljuk, hogy az összes számjegyet törölni lehessen.


Egy verseny n játékosból áll, amelyek 0-tól n - 1-ig vannak számozva.
Kapsz egy egész szám tömböt, skills, amelynek mérete n, és egy pozitív egész számot, k, ahol skills[i] az i. játékos készségi szintje. Minden egész szám a skills tömbben egyedi.
Minden játékos sorban áll, 0-ás játékostól n - 1-es játékosig.
A verseny folyamata a következő:

 A sorban az első két játékos játszik egy játékot, és az a játékos nyer, akinek magasabb a készségi szintje.
 A játék után a győztes a sor elején marad, a vesztes pedig a sor végére kerül.

A verseny győztese az első játékos, aki k egymást követő játékot megnyer.
Térj vissza a győztes játékos kezdeti indexével.

 Példa 1:

Input: skills = [4,2,6,3,9], k = 2
Output: 2
Magyarázat:
Kezdetben a játékosok sora [0,1,2,3,4]. A következő folyamat történik:

 A 0-ás és 1-es játékos játszik egy játékot, mivel a 0-ás játékos készsége magasabb, mint az 1-es játékosé, így a 0-ás játékos nyer. Az eredményül kapott sor [0,2,3,4,1].
A 0-ás és 2-es játékos játszik egy játékot, mivel a 2-es játékos készsége magasabb, mint a 0-ás játékosé, így a 2-es játékos nyer. Az eredményül kapott sor [2,3,4,1,0].
A 2-es és 3-as játékos játszik egy játékot, mivel a 2-es játékos készsége magasabb, mint a 3-as játékosé, így a 2-es játékos nyer. Az eredményül kapott sor [2,4,1,0,3].

A 2-es játékos megnyert k = 2 egymást követő játékot, így a győztes a 2-es játékos.

Példa 2:

 Input: skills = [2,5,4], k = 3
Output: 1
Magyarázat:
Kezdetben a játékosok sora [0,1,2]. A következő folyamat történik:

A 0-ás és 1-es játékos játszik egy játékot, mivel az 1-es játékos készsége magasabb, mint a 0-ás játékosé, így az 1-es játékos nyer. Az eredményül kapott sor [1,2,0].
 Az 1-es és 2-es játékos játszik egy játékot, mivel az 1-es játékos készsége magasabb, mint a 2-es játékosé, így az 1-es játékos nyer. Az eredményül kapott sor [1,0,2].
Az 1-es és 0-ás játékos játszik egy játékot, mivel az 1-es játékos készsége magasabb, mint a 0-ás játékosé, így az 1-es játékos nyer. Az eredményül kapott sor [1,2,0].

 Az 1-es játékos megnyert k = 3 egymást követő játékot, így a győztes az 1-es játékos.

Korlátozások:

 n == skills.hossza
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Minden egész szám a skills tömbben egyedi.

Egy verseny n játékosból áll, akik 0-tól n-1-ig vannak számozva.
Kapsz egy n méretű készségeket és egy pozitív egész számot, ahol a skill[i] az i játékos képzettségi szintje. A készségekben szereplő összes egész szám egyedi.
Minden játékos sorban áll a 0-tól az n-1 játékosig.
A verseny menete a következő:

A sorban az első két játékos játszik egy játékot, és a magasabb képzettségi szinttel rendelkező játékos nyer.
A játék után a győztes a sor elején marad, a vesztes pedig a végére.

A verseny győztese az első játékos, aki zsinórban k játékot nyer.
Adja vissza a nyertes játékos kezdeti indexét.

1. példa:

Bemenet: skills = [4,2,6,3,9], k = 2
Kimenet: 2
Magyarázat:
Kezdetben a játékosok sora [0,1,2,3,4]. A következő folyamat történik:

A 0 és az 1 játékosok játszanak egy játékot, mivel a 0 játékos képessége magasabb, mint az 1. játékosé, ezért a 0 játékos nyer. Az eredményül kapott sor [0,2,3,4,1].
A 0 és 2 játékosok játszanak egy játékot, mivel a 2. játékos képessége magasabb, mint a 0 játékosé, ezért a 2. játékos nyer. Az eredményül kapott sor: [2,3,4,1,0].
A 2. és 3. játékos játszik egy játékot, mivel a 2. játékos képessége magasabb, mint a 3. játékosé, ezért a 2. játékos nyer. Az eredményül kapott sor: [2,4,1,0,3].

A 2. játékos k = 2 játékot nyert egymás után, tehát a 2. játékos nyer.

2. példa:

Bemenet: skills = [2,5,4], k = 3
Kimenet: 1
Magyarázat:
Kezdetben a játékosok sora [0,1,2]. A következő folyamat történik:

A 0 és az 1 játékosok játszanak egy játékot, mivel az 1. játékos képessége magasabb, mint a 0 játékosé, ezért az 1. játékos nyer. Az eredményül kapott sor: [1,2,0].
Az 1. és 2. játékos játszik egy játékot, mivel az 1. játékos képessége magasabb, mint a 2. játékosé, ezért az 1. játékos nyer. Az eredményül kapott sor: [1,0,2].
Az 1. és a 0. játékos játszik egy játékot, mivel az 1. játékos képessége magasabb, mint a 0. játékos, ezért az 1. játékos nyer. Az eredményül kapott sor: [1,2,0].

Az 1. játékos k = 3 játékot nyert egymás után, tehát az 1. játékos nyer.

Korlátozások:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
A készségekben szereplő összes egész szám egyedi.

A verseny n játékosból áll, akiket 0-tól n-1-ig számoznak.
Adott egy n méretű, egész számú skill tömb és egy pozitív egész szám k, ahol a skills[i] az i játékos képzettségi szintje. A skills minden egész száma egyedi.
Az összes játékos egy sorban áll a 0-tól n - 1 játékosig terjedő sorrendben.
A verseny folyamata a következő:

A sorban álló első két játékos játszik egy játékot, és a magasabb képességszinttel rendelkező játékos nyer.
A játék után a győztes a sor elején marad, a vesztes pedig a sor végére kerül.

A verseny győztese az a játékos, aki először nyer k játékot egymás után.
Visszaadjuk a győztes játékos kezdeti indexét.

1. példa:

Bemenet: Skills = [4,2,6,3,9], k = 2
Kimenet: 2
Magyarázat:
A játékosok sora kezdetben [0,1,2,3,4]. A következő folyamat játszódik le:

A 0 és az 1 játékosok játszanak egy játékot, mivel a 0 játékos képessége nagyobb, mint az 1 játékosé, a 0 játékos nyer. Az így kapott sor [0,2,3,4,1].
A 0 és 2 játékosok játszanak egy játékot, mivel a 2 játékos képessége nagyobb, mint a 0 játékosé, a 2 játékos nyer. Az így kapott sor [2,3,4,1,0].
A 2 és 3 játékosok játszanak egy játékot, mivel a 2 játékos képessége nagyobb, mint a 3 játékosé, a 2 játékos nyer. Az így kapott sor [2,4,1,0,3].

A 2. játékos k = 2 játékot nyert egymás után, tehát a győztes a 2. játékos.

2. példa:

Bemenet: skills = [2,5,4], k = 3
Kimenet: 1
Magyarázat:
A játékosok sora kezdetben [0,1,2]. A következő folyamat játszódik le:

A 0 és az 1 játékosok játszanak egy játékot, mivel az 1 játékos képessége nagyobb, mint a 0 játékosé, az 1 játékos nyer. Az így kapott sor [1,2,0].
Az 1 és 2 játékosok játszanak egy játékot, mivel az 1 játékos képessége nagyobb, mint a 2 játékosé, az 1 játékos nyer. Az így kapott sor [1,0,2].
Az 1 és 0 játékosok játszanak egy játékot, mivel az 1 játékos képessége nagyobb, mint a 0 játékosé, az 1 játékos nyer. Az így kapott sor [1,2,0].

Az 1. játékos k = 3 játékot nyert egymás után, tehát a győztes az 1. játékos.

Korlátozások:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
A készségek összes egész száma egyedi.


Adunk egy egész számokból álló tömböt és egy nem negatív k egész számot. Egy egész számok sorozatát jónak nevezzük, ha legfeljebb k i index van a [0, seq.length - 2] tartományban úgy, hogy seq[i] != seq[i + 1].
Adjuk vissza a számokból álló jó részsorozat maximális hosszát.

1. példa:

Bemenet: nums = [1,2,1,1,3], k = 2
Kimenet: 4
Magyarázat:
A maximális hosszúságú részsorozat [1,2,1,1,3].

2. példa:

Bemenet: nums = [1,2,3,4,5,1], k = 0
Kimenet: 2
Magyarázat:
A maximális hosszúságú részsorozat [1,2,3,4,5,1].

Korlátozások:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)

Adott egy nums egész számtömb és egy nemnegatív egész szám k. A seq egész számok sorozatát jónak nevezzük, ha a [0, seq.length - 2] tartományban legfeljebb k index i van, úgy, hogy seq[i] != seq[i + 1].
A nums jó részsorozatának maximális lehetséges hosszát adja vissza.

Példa 1:

Bemenet:  nums = [1,2,1,1,3]. k = 2
Kimenet: 4
Magyarázat:
A maximális hosszúságú részfolyamat a [1,2,1,1,1,3].

2. példa:

Bemenet: nums = [1,2,3,4,5,1], k = 0
Kimenet: 2
Magyarázat:
A maximális hosszúságú rész sorozat, a [1,2,3,4,5,1].

Korlátozások:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)


Kapsz egy egész számokból álló tömböt. Egy műveletben a tömb bármely eleméből hozzáadhat vagy kivonhat 1-et.
Adj vissza a műveletek minimális számát, hogy a számok összes eleme osztható legyen 3-mal.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 3
Magyarázat:
Az összes tömbelem 3 művelettel 3-mal oszthatóvá tehető:

Vonjunk ki 1-et 1-ből.
Adjunk hozzá 1-et a 2-hez.
Vonjunk ki 1-et 4-ből.

2. példa:

Bemenet: nums = [3,6,9]
Kimenet: 0

Korlátozások:

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

Kapsz egy egész számokból álló tömböt Egy műveletben a tömb bármely eleméből hozzáadhat vagy kivonhat 1-et.
Adjon vissza a műveletek minimális számát. hogy a számok összes eleme osztható legyen 3-mal.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 3
Magyarázat:
Az összes tömbelem 3 művelettel 3-mal oszthatóvá tehető.
Vonjunk ki 1-et 1-ből.
Adjunk hozzá 1-et a 2-hez.
Vonjunk ki 1-et 4-ből.

2. példa:

Bemenet: nums = [3,6,9]
Kimenet: 0

Korlátozások:

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

Kap egy egész tömb nums-t. Egy műveletben hozzáadhat vagy kivonhat 1-et a nums bármely eleméből.
Adja vissza a műveletek minimális számát, hogy a számok összes eleme osztható legyen 3-mal.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 3
Magyarázat:
A tömb összes eleme oszthatóvá tehető 3-mal 3 művelettel:

Vonjon ki 1-et 1-ből.
Adjon hozzá 1-et 2-hez.
Vonjon ki 1-et 4-ből.

2. példa:

Bemenet: nums = [3,6,9]
Kimenet: 0

Korlátok:

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


Adott egy bináris tömb, nums.
Az alábbi műveletet tetszőleges számú alkalommal (akár nulla alkalommal is) végezheted el a tömbön:

Válassz ki bármely 3 egymást követő elemet a tömbből, és fordítsd meg mindegyiket.

Egy elem felfordítása azt jelenti, hogy az értéke 0-ról 1-re, illetve 1-ről 0-ra változik.
Add vissza a minimális számú műveletet, amely szükséges ahhoz, hogy a nums összes eleme 1 legyen. Ha ez lehetetlen, add vissza a -1 értéket.

Példa 1:

Bemenet: nums = [0,1,1,1,0,0]
Kimenet: 3
Magyarázat:
Az alábbi műveleteket végezhetjük el:

Válaszd ki a 0., 1. és 2. indexű elemeket. Az eredményül kapott tömb: nums = [1,0,0,1,0,0].
Válaszd ki az 1., 2. és 3. indexű elemeket. Az eredményül kapott tömb: nums = [1,1,1,0,0,0].
Válaszd ki a 3., 4. és 5. indexű elemeket. Az eredményül kapott tömb: nums = [1,1,1,1,1,1].

Példa 2:

Bemenet: nums = [0,1,1,1]
Kimenet: -1
Magyarázat:
Lehetetlen az összes elemet 1-re változtatni.

Korlátozások:

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

Bináris tömb nums kap.
A következő műveletet tetszőleges számú alkalommal (esetleg nulla) elvégezheti a tömbön:

Válasszon ki 3 egymást követő elemet a tömbből, és fordítsa meg mindegyiket.

Egy elem megfordítása azt jelenti, hogy értékét 0-ról 1-re és 1-ről 0-ra változtatja.
Visszaadja azt a minimális műveletszámot, amely ahhoz szükséges, hogy a számban lévő összes elem egyenlő legyen 1-gyel. Ha ez lehetetlen, térjen vissza -1.

1. példa:

Bemenet: nums = [0,1,1,1,0,0]
Kimenet: 3
Magyarázat:
A következő műveleteket végezhetjük el:

Válassza ki a 0, 1 és 2 indexek elemeit. Az eredményül kapott tömb nums = [1,0,0,1,0,0].
Válassza ki az elemeket az 1., 2. és 3. indexben. Az eredményül kapott tömb nums = [1,1,1,0,0,0].
Válassza ki a 3., 4. és 5. indexen található elemeket. Az eredményül kapott tömb nums = [1,1,1,1,1,1].

2. példa:

Bemenet: nums = [0,1,1,1]
Kimenet: -1
Magyarázat:
Lehetetlen, hogy minden elem egyenlő legyen 1-vel.

Korlátok:

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

Kapsz egy bináris tömb számokat.
A következő műveletet tetszőleges számú alkalommal (esetleg nullával) elvégezheti a tömbön:

Válasszon ki bármelyik 3 egymást követő elemet a tömbből, és fordítsa meg mindegyiket.

Egy elem átfordítása az értékének 0-ról 1-re, illetve 1-ről 0-ra való megváltoztatását jelenti.
Adja vissza a műveletek minimális számát ahhoz, hogy minden elem 1-gyel egyenlő legyen. Ha ez nem lehetséges, adjon vissza -1-et.

1. példa:

Bemenet: nums = [0,1,1,1,0,0]
Kimenet: 3
Magyarázat:
A következő műveleteket tudjuk elvégezni:

Válassza ki a 0, 1 és 2 indexű elemeket. A kapott tömb a következő: nums = [1,0,0,1,0,0].
Válassza ki az 1., 2. és 3. indexű elemeket. A kapott tömb a következő: nums = [1,1,1,0,0,0].
Válassza ki a 3., 4. és 5. index elemeit. A kapott tömb a következő: nums = [1,1,1,1,1,1].

2. példa:

Bemenet: nums = [0,1,1,1]
Kimenet: -1
Magyarázat:
Lehetetlen, hogy minden elem egyenlő legyen 1-gyel.

Korlátozások:

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


Adunk egy n egész számot és egy 2D tömb követelményeit, ahol a követelmények[i] = [end_i, cnt_i] az egyes követelmények végindexét és inverziószámát jelenti.
Egy egész tömbből származó indexpárt (i, j) inverziónak nevezünk, ha:

i < j and nums[i] > nums[j]

A [0, 1, 2, ..., n - 1] permutációk számát adja vissza úgy, hogy az összes követelmény[i] esetén a perm[0..end_i] pontosan cnt_i inverziót tartalmazzon.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: n = 3, követelmények = [[2,2],[0,0]]
Kimenet: 2
Magyarázat:
A két permutáció a következő:

[2, 0, 1]

A [2, 0, 1] előtag inverziókkal rendelkezik (0, 1) és (0, 2).
A [2] előtag 0 inverziót tartalmaz.

[1, 2, 0]

Az [1, 2, 0] előtag inverziókkal rendelkezik (0, 2) és (1, 2).
Az [1] előtag 0 inverziót tartalmaz.

2. példa:

Bemenet: n = 3, követelmények = [[2,2], [1,1], [0,0]]
Kimenet: 1
Magyarázat:
Az egyetlen kielégítő permutáció a [2, 0, 1]:

A [2, 0, 1] előtag inverziókkal rendelkezik (0, 1) és (0, 2).
A [2, 0] előtag inverzióval rendelkezik (0, 1).
A [2] előtag 0 inverziót tartalmaz.

3. példa:

Bemenet: n = 2, követelmények = [[0,0],[1,0]]
Kimenet: 1
Magyarázat:
Az egyetlen kielégítő permutáció a [0, 1]:

A [0] előtag 0 inverziót tartalmaz.
A [0, 1] előtag inverzióval rendelkezik (0, 1).

Korlátozások:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
A bemenetet úgy állítjuk elő, hogy legyen legalább egy olyan i, amelyre end_i == n - 1.
A bemenet úgy jön létre, hogy minden end_i egyedi legyen.

Adunk egy n egész számot és egy 2D tömb követelményeit, ahol a requirements[i] = [end_i, cnt_i] az egyes követelmények végindexét és inverziószámát jelenti.
Egy egész tömbből származó indexpárt (i, j) inverziónak nevezünk, ha:

i < j és nums[i] > nums[j]

A [0, 1, 2, ..., n - 1] permutációk számát adja vissza úgy, hogy az összes követelmény[i] esetén a perm[0..end_i] pontosan cnt_i inverziót tartalmazzon.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: n = 3, requirements = [[2,2],[0,0]]
Kimenet: 2
Magyarázat:
A két permutáció a következő:

[2, 0, 1]

A [2, 0, 1] előtag inverziókkal rendelkezik (0, 1) és (0, 2).
A [2] előtag 0 inverziót tartalmaz.

[1, 2, 0]

Az [1, 2, 0] előtag inverziókkal rendelkezik (0, 2) és (1, 2).
Az [1] előtag 0 inverziót tartalmaz.

2. példa:

Bemenet: n = 3, requirements = [[2,2],[1,1],[0,0]]
Kimenet: 1
Magyarázat:
Az egyetlen kielégítő permutáció a [2, 0, 1]:

A [2, 0, 1] előtag inverziókkal rendelkezik (0, 1) és (0, 2).
A [2, 0] előtag inverzióval rendelkezik (0, 1).
A [2] előtag 0 inverziót tartalmaz.

3. példa:

Bemenet: n = 2, requirements = [[0,0],[1,0]]
Kimenet: 1
Magyarázat:
Az egyetlen kielégítő permutáció a [0, 1]:

A [0] előtag 0 inverziót tartalmaz.
A [0, 1] előtag inverzióval rendelkezik (0, 1).

Korlátozások:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
A bemenetet úgy állítjuk elő, hogy legyen legalább egy olyan i, amelyre end_i == n - 1.
A bemenet úgy jön létre, hogy minden end_i egyedi legyen.

Kap egy n egész számot és egy 2D tömbkövetelményt, ahol requirements[i] = [end_i, cnt_i] az egyes követelmények végindexét és inverziószámát jelöli.
Egy egész tömb számából származó indexpárt (i, j) inverziónak nevezünk, ha:

i < j és nums[i] > nums[j]

Adja vissza a perm permutációk számát [0, 1, 2, ..., n - 1] úgy, hogy minden követelmény[i] esetén a perm[0..end_i] pontosan cnt_i inverzióval rendelkezik.
Mivel a válasz nagyon nagy lehet, adja vissza modulo 10 ^ 9 + 7.

1. példa:

Bemenet:n = 3, requirements = [[2,2],[0,0]]
Kimenet: 2
Magyarázat:
A két permutáció a következő:

[2, 0, 1]

A [2, 0, 1] előtag inverziókkal rendelkezik (0, 1) és (0, 2).
A(z) [2] előtag 0 inverzióval rendelkezik.

[1, 2, 0]

Az [1, 2, 0] előtag inverziókkal rendelkezik (0, 2) és (1, 2).
Az [1] előtag 0 inverzióval rendelkezik.

2. példa:

Bemenet: n = 3, requirements = [[2,2],[1,1],[0,0]]
Kimenet: 1
Magyarázat:
Az egyetlen kielégítő permutáció a [2, 0, 1]:

A [2, 0, 1] előtag inverziókkal rendelkezik (0, 1) és (0, 2).
A [2, 0] előtag inverziója (0, 1).
A(z) [2] előtag 0 inverzióval rendelkezik.

3. példa:

Bemenet: n = 2, requirements = [[0,0],[1,0]]
Kimenet: 1
Magyarázat:
Az egyetlen kielégítő permutáció a [0, 1]:

A [0] előtag 0 inverzióval rendelkezik.
A [0, 1] előtag inverziója (0, 1).

Korlátok:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
A bemenetet úgy generáljuk, hogy legalább egy i legyen úgy, hogy end_i == n - 1.
A bemenet úgy jön létre, hogy minden end_i egyedi legyen.


Van egy kör piros és kék csempékből. Adott egy egész számokat tartalmazó tömb, colors. Az i-edik csempe színét a colors[i] jelöli:

colors[i] == 0 azt jelenti, hogy az i-edik csempe piros.
colors[i] == 1 azt jelenti, hogy az i-edik csempe kék.

Minden 3 egymást követő csempe a körben, amelyek váltakozó színekkel rendelkeznek (a középső csempe eltérő színű a bal és a jobb oldali csempéktől), váltakozó csoportnak nevezzük.
Adja vissza a váltakozó csoportok számát.
Ne feledje, hogy mivel a colors egy kört ábrázol, az első és az utolsó csempéket egymás mellettinek kell tekinteni.

Példa 1:

Bemenet: colors = [1,1,1]
Kimenet: 0
Magyarázat:

Példa 2:

Bemenet: colors = [0,1,0,0,1]
Kimenet: 3
Magyarázat:

Váltakozó csoportok:

Korlátozások:

3 <= colors.length <= 100
0 <= colors[i] <= 1

Van egy kör piros és kék csempe. Adott egy egész számokból álló színtömb, colors. Az i csempe színét a színtömb [i] képviselik:

colors[i] == 0 azt jelenti, hogy az i-edik csempe piros.
colors[i] == 1 azt jelenti, hogy az i-edik csempe kék.

A körben minden 3 összefüggő lapkát váltakozó színekkel (a középső csempe színe eltér a bal és jobb oldali lapkától) váltakozó csoportnak nevezzük.
Adja vissza a váltakozó csoportok számát.
Vegye figyelembe, hogy mivel a színtömb egy kört jelölnek, az első és az utolsó lapkát egymás mellett lévőnek tekintjük.

1. példa:

Bemenet: colors = [1,1,1]
Kimenet: 0
Magyarázat:

2. példa:

Bemenet: colors = [0,1,0,0,1]
Kimenet: 3
Magyarázat:

Váltakozó csoportok:

Korlátozások:

3 <= colors.length <= 100
0 <= colors[i] <= 1

Van egy piros és kék csempe kör. Egy egész számokból álló tömböt kap, amely a csempék színeit jelöli. Az i csempe színét színek[i] jelölik:

colors[i] == 0 azt jelenti, hogy az i csempe piros.
colors[i] == 1 azt jelenti, hogy az i csempe kék.

A körben minden 3 szomszédos csempe váltakozó színekkel (a középső csempe színe eltér a bal és jobb lapkától) váltakozó csoportnak nevezik.
A váltakozó csoportok számát adja eredményül.
Vegye figyelembe, hogy mivel a színek egy kört jelölnek, az első és az utolsó csempe egymás mellett van.

1. példa:

Bemenet: colors = [1,1,1]
Kimenet: 0
Magyarázat:

2. példa:

Bemenet: colors = [0,1,0,0,1]
Kimenet: 3
Magyarázat:

Váltakozó csoportok:

Korlátok:

3 <= colors.length <= 100
0 <= colors[i] <= 1


Kapsz egy egész tömb enemyEnergiákat, amelyek a különböző ellenségek energiaértékeit jelölik.
Kapsz egy egész áramerősséget is, amely a kezdetben meglévő energiamennyiséget jelöli.
0 ponttal kezdesz, és kezdetben az összes ellenséget nem jelölted meg.
A következő műveletek bármelyikét nullával vagy többször is végrehajthatja, hogy pontokat szerezzen:

Válassz egy jelöletlen ellenséget, i, amelyre igaz, hogy currentEnergy >= enemyEnergies[i]. Az ezen opció választása esetén:

1 pontot kapsz.
Az Ön energiáját az ellenség energiája csökkenti, azaz currentEnergy = currentEnergy - enemyEnergies[i].

Ha legalább 1 pontod van, választhatsz egy jelöletlen ellenséget, pl. Ezt az opciót választva:

Az Ön energiája az ellenség energiájával növekszik, azaz currentEnergy = currentEnergy + enemyEnergies[i].
Az i ellenség meg van jelölve.

Egy egész számot ad vissza, amely a műveletek optimális végrehajtásával végül elérhető maximális pontokat jelöli.

1. példa:

Bemenet: enemyEnergies = [3,2,2], currentEnergy = 2
Kimenet: 3
Magyarázat:
Az alábbi műveletek végrehajtásával 3 pontot lehet szerezni, ami a maximum:

Első művelet az 1-es ellenségen: a pontok 1-gyel nőnek, és a currentEnergy 2-vel csökken. Tehát pontok = 1, és currentEnergy = 0.
Második művelet a 0-s ellenségen: currentEnergy 3-mal nő, és a 0-s ellenség jelöltté válik. Tehát pontok = 1, currentEnergy = 3, és jelölt ellenségek = [0].
Első művelet a 2-es ellenségen: a pontok 1-gyel nőnek, és a currentEnergy 2-vel csökken. Tehát pontok = 2, currentEnergy = 1, és jelölt ellenségek = [0].
Második művelet a 2-es ellenségen: currentEnergy 2-vel nő, és a 2-es ellenség jelöltté válik. Tehát pontok = 2, currentEnergy = 3, és jelölt ellenségek = [0, 2].
Első művelet az 1-es ellenségen: a pontok 1-gyel nőnek, és a currentEnergy 2-vel csökken. Tehát pontok = 3, currentEnergy = 1, és jelölt ellenségek = [0, 2].

2. példa:

Bemenet: enemyEnergies = [2], currentEnergy = 10
Kimenet: 5
Magyarázat:
Az első művelet 5-szöri végrehajtása 0 ellenségen a maximális pontszámot eredményezi.

Korlátozások:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

Kapsz egy egész számtömböt enemyEnergies, amely a különböző ellenségek energiaértékeit jelöli.
Kapsz továbbá egy egész számot currentEnergy, amely a kezdeti energiádat jelöli.
Kezdetben 0 ponttal indulsz, és az összes ellenség kezdetben jelöletlen.
A következő műveletek bármelyikét nulla vagy többször is elvégezheted, hogy pontokat szerezz:

Válassz egy olyan i jelöletlen ellenséget, hogy currentEnergy >= enemyEnergies[i]. Ezt a lehetőséget választva:

1 pontot nyersz.
A te energiád csökken az ellenség energiájával, azaz currentEnergy = currentEnergy - enemyEnergies[i].

Ha van legalább 1 pontod, választhatsz egy nem jelölt ellenséget, i. Ezt az opciót választva:

Az energiád az ellenség energiájával nő, azaz currentEnergy = currentEnergy + enemyEnergies[i].
Az i ellenség jelölve van.

Visszaad egy egész számot, amely azt a maximális pontot jelöli, amelyet a végén a műveletek optimális elvégzésével megszerezhetsz.

Példa 1:

Bemenet: enemyEnergies = [3,2,2], currentEnergy = 2
Kimenet: 3
Magyarázat:
A következő műveletekkel 3 pontot kaphatunk, ami a maximum:

Első művelet az 1-es ellenségen: a pontok 1 ponttal nőnek, a currentEnergy pedig 2 ponttal csökken. Tehát a pontok = 1, a currentEnergy pedig = 0.
Második művelet a 0. ellenségen: a currentEnergy 3 ponttal nő, és a 0. ellenséget megjelöli. Tehát pontok = 1, currentEnergy = 3, és a megjelölt ellenség = [0].
Első művelet a 2. ellenségen: a pontok 1-re nőnek, és az aktuális energia 2-re csökken. Tehát a pontok = 2, az aktuális energia = 1, és a megjelölt ellenség = [0].
Második művelet a 2. ellenségen: az currentEnergy 2-vel nő, és a 2. ellenséget megjelöltük. Tehát, pontok = 2, currentEnergy = 3, és megjelölt ellenségek = [0, 2].
Első művelet az 1-es ellenségen: a pontok 1-re nőnek, és az aktuális energia 2-re csökken. Tehát a pontok = 3, az aktuális energia = 1, és a megjelölt ellenségek = [0, 2].

Példa 2:

Bemenet: enemyEnergies = [2], currentEnergy = 10
Kimenet: 5
Magyarázat:
Az első művelet 5-szörös végrehajtása a 0 ellenségen a maximális pontszámot eredményezi.

Korlátozások:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

Kapsz egy egész tömb enemyEnergiákat, amelyek a különböző ellenségek energiaértékeit jelölik.
Kapsz egy egész áramerősséget is, amely az eredeti energiamennyiséget jelöli.
0 ponttal kezdesz, és kezdetben az összes ellenséget nem jelölted meg.
A következő műveletek bármelyikét nullával vagy többször is végrehajthatja, hogy pontokat szerezzen:

Válasszon egy jelöletlen ellenséget, i-t úgy, hogy az aktuálisEnergia >= ellenségEnergiák[i]. Ezt az opciót választva:

1 pontot kapsz.
Az Ön energiáját az ellenség energiája csökkenti, azaz aktuálisEnergia = aktuálisEnergia - ellenségEnergiák[i].

Ha legalább 1 pontja van, választhat egy jelöletlen ellenséget, pl. Ezt az opciót választva:

Az Ön energiája az ellenség energiájával növekszik, azaz aktuálisEnergia = aktuálisEnergia + ellenségEnergiák[i].
Az i. ellenség megjelölve lesz.

Egy egész számot ad vissza, amely a műveletek optimális végrehajtásával végül elérhető maximális pontokat jelöli.

1. példa:

Bemenet: enemyEnergies = [3,2,2], currentEnergy = 2
Kimenet: 3
Magyarázat:
Az alábbi műveletek végrehajtásával 3 pontot lehet elérni, ami a maximum:

Első művelet az 1. ellenségen: a pontok 1-gyel nőnek, az aktuálisEnergia pedig 2-vel csökken. Tehát a pontok = 1, az aktuálisEnergia = 0.
Második művelet a 0. ellenségen: az aktuális energia 3-mal nő, és az ellenség 0-val van megjelölve. Tehát a pontok = 1, az aktuális energia = 3 és a jelölt ellenségek = [0].
Első művelet a 2. ellenségen: a pontok 1-gyel nőnek, az aktuálisEnergia 2-vel csökken. Tehát a pontok = 2, a aktuálisEnergia = 1 és a megjelölt ellenségek = [0].
Második művelet a 2. ellenségen: aktuális Az energia 2-vel nő, és az ellenség 2 megjelölve. Tehát a pontok = 2, a aktuálisEnergia = 3 és a jelölt ellenségek = [0, 2].
Első művelet az 1. ellenségen: a pontok 1-gyel nőnek, az aktuálisEnergia 2-vel csökken. Tehát a pontok = 3, a aktuálisEnergia = 1 és a megjelölt ellenségek = [0, 2].

2. példa:

Bemenet: enemyEnergies = [2], currentEnergy = 10
Kimenet: 5
Magyarázat:
Az első művelet 5-szöri végrehajtása 0 ellenségen a maximális pontszámot eredményezi.

Korlátozások:

1 <= ellenségEnergiák.hossz <= 10^5
1 <= ellenségEnergiák[i] <= 10^9
0 <= áramenergia <= 10^9


Adott egy nums egész számokból álló tömb és egy k egész szám, adja vissza a nums azon altömbjeinek számát, ahol az altömb elemeinek bitenkénti ÉS-je egyenlő k-val.

Példa 1:

Input: nums = [1,1,1], k = 1
Kimenet: 6
Magyarázat:
Minden altábla csak 1-eseket tartalmaz.

Példa 2:

Bemenet: nums = [1,1,2], k = 1
Kimenet: 3
Magyarázat:
Az 1 AND értékű altáblák a következők: [1,1,2], [1,1,2], [1,1,2].

Példa 3:

Bevitel: nums = [1,2,3], k = 2
Kimenet: 2
Magyarázat:
A 2 AND értékű altáblák a következők: [1,2,3], [1,2,3].

Korlátozások:

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

Adott egy egész számokat tartalmazó tömb, nums, és egy egész szám, k. Vissza kell adni azon résztömbök számát a nums-ban, ahol a résztömb elemeinek bitenkénti ÉS művelete k-val egyenlő.

1. példa:

Bemenet: nums = [1,1,1], k = 1
Kimenet: 6
Magyarázat:
Minden rész tömb csak 1-est tartalmaz.

2. példa:

Bemenet: nums = [1,1,2], k = 1
Kimenet: 3
Magyarázat:
Az 1-es ÉS értékű Altömb a következők: [1,1,2], [1,1,2], [1,1,2].

3. példa:

Bemenet: nums = [1,2,3], k = 2
Kimenet: 2
Magyarázat:
A 2-es ÉS értékű Altömb: [1,2,3], [1,2,3].

Korlátozások:

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

Adott egy egy egész számokból álló tömb (nums) és egy egész szám (k), adja vissza azoknak a számoknak a számát, ahol az altömb elemeinek bitenkénti ÉS értéke k.

1. példa:

Bemenet: nums= [1,1,1], k = 1
Kimenet: 6
Magyarázat:
Minden altömb csak 1-est tartalmaz.

2. példa:

Bemenet: nums = [1,1,2], k = 1
Kimenet: 3
Magyarázat:
Az 1-es ÉS értékű altömb a következők: [1,1,2], [1,1,2], [1,1,2].

3. példa:

Bemenet: nums = [1,2,3], k = 2
Kimenet: 2
Magyarázat:
A 2-es ÉS értékű altömb: [1,2,3], [1,2,3].

Korlátozások:

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


Két pozitív egész számot kap, x és y, amelyek a 75, illetve 10 értékű érmék számát jelölik.
Alice és Bob játszanak. Minden körben, kezdve Alice-szel, a játékosnak 115 összértékű érméket kell felvennie. Ha a játékos nem tudja megtenni, elveszíti a játékot.
Adja meg annak a játékosnak a nevét, aki megnyeri a játékot, ha mindkét játékos optimálisan játszik.

1. példa:

Bemenet: x = 2, y = 7
Kimenet: "Alice"
Magyarázat:
A játék egyetlen körrel ér véget:

Alice kiválaszt 1 75 értékű érmét és 4 10 értékű érmét.

2. példa:

Bemenet: x = 4, y = 11
Kimenet: "Bob"
Magyarázat:
A játék 2 körrel ér véget:

Alice kiválaszt 1 75 értékű érmét és 4 10 értékű érmét.
Bob kiválaszt 1 75 értékű érmét és 4 10 értékű érmét.

Korlátozások:

1 <= x, y <= 100

Két pozitív x és y egész számot kap, amelyek a 75 és 10 értékű érmék számát jelölik.
Alice és Bob játszmában játszanak. Minden fordulóban, Alice-től kezdve, a játékosnak 115 összértékű érméket kell felvennie. Ha a játékos erre nem képes, elveszíti a játékot.
Adja vissza annak a játékosnak a nevét, aki megnyeri a játékot, ha mindkét játékos optimálisan játszik.

1. példa:

Bemenet: x = 2, y = 7
Kimenet: "Alice"
Magyarázat:
A játék egyetlen körben ér véget:

Alice 1 érmét választ 75 értékben és 4 érmét 10 értékben.

2. példa:

Bemenet: x = 4, y = 11
Kimenet: "Bob"
Magyarázat:
A játék 2 körben ér véget:

Alice 1 érmét választ 75 értékben és 4 érmét 10 értékben.
Bob kiválaszt 1 érmét 75 értékben és 4 érmét 10 értékben.

Korlátok:

1 < = x, y <= 100


Kapsz egy s karakterláncot.
A következő folyamatot tetszőleges számú alkalommal végrehajthatja s-en:

Válasszon egy i indexet a karakterláncban úgy, hogy legalább egy olyan karakter legyen az i indextől balra, amely egyenlő s[i]-vel, és legalább egy karakter jobbra, amely szintén egyenlő s[i]-vel.
Törölje az i indextől balra lévő legközelebbi karaktert, amely egyenlő az s[i]-vel.
Törölje az i indextől jobbra lévő legközelebbi karaktert, amely egyenlő az s[i]-vel.

Adja vissza a végső karakterlánc s minimális hosszát, amelyet elérhet.

Példa 1:

Bemenet: s = "abaacbcbb"
Kimenet: 5
Magyarázat:
A következő műveleteket végezzük:

Válassza a 2. indexet, majd távolítsa el a 0 és 3 indexnél lévő karaktereket. A kapott karakterlánc a következő: s = "bacbcbb".
Válassza a 3. indexet, majd távolítsa el a 0 és 5 indexnél lévő karaktereket. A kapott karakterlánc a következő: s = "acbcb".

Példa 2:

Bemenet: s = "aa"
Kimenet: 2
Magyarázat:
Nem tudunk semmilyen műveletet végrehajtani, ezért visszaadjuk az eredeti karakterlánc hosszát.

Korlátozások:

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

Kapsz egy s karakterláncot.
A következő folyamatot tetszőleges számú alkalommal végrehajthatja s-en:

Válasszon egy i indexet a karakterláncban úgy, hogy legalább egy olyan karakter legyen az i indextől balra, amely egyenlő s[i]-vel, és legalább egy karakter jobbra, amely szintén egyenlő s[i]-vel.
Törölje az i indextől balra lévő legközelebbi karaktert, amely egyenlő az s[i]-vel.
Törölje az i indextől jobbra lévő legközelebbi karaktert, amely egyenlő az s[i]-vel.

Adja vissza a végső karakterlánc s minimális hosszát, amelyet elérhet.

1. példa:

Bemenet: s = "abaacbcbb"
Kimenet: 5
Magyarázat:
A következő műveleteket végezzük:

Válassza a 2. indexet, majd távolítsa el a 0 és 3 indexnél lévő karaktereket. A kapott karakterlánc a következő: s = "bacbcbb".
Válassza a 3. indexet, majd távolítsa el a 0 és 5 indexnél lévő karaktereket. A kapott karakterlánc a következő: s = "acbcb".

2. példa:

Bemenet: s = "aa"
Kimenet: 2
Magyarázat:
Nem tudunk semmilyen műveletet végrehajtani, ezért visszaadjuk az eredeti karakterlánc hosszát.

Korlátozások:

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

Kapsz egy s karakterláncot.
A következő folyamatot tetszőleges számú alkalommal végrehajthatja:

Válasszon egy i indexet a karakterláncban úgy, hogy az i indextől balra legalább egy karakter legyen, amely egyenlő s[i]-vel, és legalább egy karakter jobbra, amely szintén egyenlő s[i]-vel.
Törölje az i indextől balra található legközelebbi karaktert, amely egyenlő az s[i]-vel.
Törölje az i index jobb oldalán lévő legközelebbi karaktert, amely egyenlő s[i]-vel.

Az utolsó s karakterlánc minimális hosszát adja vissza.

1. példa:

Bemenet: s = "abaacbcbb"
Kimenet: 5
Magyarázat:
A következő műveleteket végezzük:

Válassza a 2-es indexet, majd távolítsa el a 0-s és 3-as indexből származó karaktereket. A kapott karakterlánc s = "bacbcbb".
Válassza a 3-as indexet, majd távolítsa el a karaktereket a 0 és 5 indexből. A kapott karakterlánc s = "acbcb".

2. példa:

Bemenet: s = "aa"
Kimenet: 2
Magyarázat:
Nem tudunk semmilyen műveletet végrehajtani, ezért visszaadjuk az eredeti karakterlánc hosszát.

Korlátok:

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


Adott egy nums egész számokat tartalmazó tömb, amelynek mérete n, ahol n páros, és egy egész szám k. A tömbön elvégezhetünk bizonyos változtatásokat, ahol egy változtatás során bármely elemet kicserélhetjük a 0 és k közötti bármely egész számra. Valamennyi változtatást (akár egyet sem) el kell végeznie úgy, hogy a végső tömb megfeleljen a következő feltételnek:

Létezik egy X egész szám, hogy abs(a[i] - a[n - i - 1]) = X az összes (0 <= i < n) esetén.

Adja vissza a minimális számú változtatást, amely szükséges a fenti feltétel teljesítéséhez.

Példa 1:

Bemenet: nums = [1,0,1,2,4,3], k = 4
Kimenet: 2
Magyarázat:
El tudjuk végezni a következő változtatásokat:

Cseréljük le a nums[1] értékét 2-re. Az eredményül kapott tömb: nums = [1,2,1,2,4,3].
Cseréljük le a nums[3] értékét 3-ra. Az eredményül kapott tömb: nums = [1,2,1,3,4,3].

Az X egész szám 2 lesz.

Példa 2:

Bemenet: nums = [0,1,2,3,3,6,5,4], k = 6
Kimenet: 2
Magyarázat:
Elvégezhetjük a következő műveleteket:

Cseréljük le a nums[3] értékét 0-ra. Az eredményül kapott tömb: nums = [0,1,2,0,3,6,5,4].
Cseréljük le a nums[4] értékét 4-re. Az eredményül kapott tömb: nums = [0,1,2,0,4,6,5,4].

Az X egész szám 4 lesz.

Korlátozások:

2 <= n == nums.length <= 10^5
n páros.
0 <= nums[i] <= k <= 10^5

Adott egy n méretű nums egész számtömb, ahol n páros, és egy k egész szám.
A tömbön elvégezhetsz néhány változtatást, ahol egy változtatással a tömb bármely elemét a 0 és k közötti tartomány bármely egész számával helyettesítheted.
Néhány változtatást kell végrehajtanod (esetleg egyet sem) úgy, hogy a végső tömb megfeleljen a következő feltételnek:

Létezik olyan X egész szám, hogy abs(a[i] - a[n - i - 1]) = X minden (0 <= i < n) esetén.

Adja vissza a fenti feltétel teljesítéséhez szükséges minimális számú változtatást.

Példa 1:

Bemenet: nums = [1,0,1,2,4,3], k = 4
Kimenet: 2
Magyarázat:
A következő változtatásokat hajthatjuk végre:

A nums[1] helyébe 2 lép. Az eredmény a nums = [1,2,1,2,4,3]. tömb lesz.
A nums[3] helyébe 3 lép. Az eredmény a nums = [1,2,1,1,3,4,3] tömb lesz.

Az X egész szám 2 lesz.

2. példa:

Bemenet: nums = [0,1,2,3,3,3,6,5,4], k = 6
Kimenet: 2
Magyarázat:
A következő műveleteket tudjuk elvégezni:

A nums[3] helyébe 0 lép. Az eredmény a nums = [0,1,2,0,3,6,5,4] tömb lesz.
A nums[4]-et helyettesítsük 4-gyel. Az eredmény a nums = [0,1,2,0,4,6,5,4].

Az X egész szám 4 lesz.

Korlátozások:

2 <= n == nums.length <= 10^5
n is even.
0 <= nums[i] <= k <= 10^5

Adunk egy n elemű egész számokból álló tömböt, ahol n páros, és egy k egész számot.
A tömbön végrehajthat néhány változtatást, ahol egy változtatás során a tömb bármely elemét lecserélheti tetszőleges egész számra a 0-tól k-ig terjedő tartományban.
El kell végeznie néhány módosítást (esetleg egyet sem), hogy a végső tömb megfeleljen a következő feltételnek:

Létezik olyan X egész szám, hogy abs(a[i] - a[n - i - 1]) = X for all (0 <= i < n).

Adja vissza a fenti feltétel teljesítéséhez szükséges minimális számú változtatást.

1. példa:

Bemenet: nums= [1,0,1,2,4,3], k = 4
Kimenet: 2
Magyarázat:
A következő változtatásokat tudjuk végrehajtani:

Cserélje le a nums[1] 2-vel. Az eredményül kapott tömb a következő: nums = [1,2,1,2,4,3].
Cserélje le a nums3] 3-mal. A kapott tömb a következő: nums = [1,2,1,3,4,3].

Az X egész szám 2 lesz.

2. példa:

Bemenet: nums = [0,1,2,3,3,6,5,4], k = 6
Kimenet: 2
Magyarázat:
A következő műveleteket tudjuk elvégezni:

Cserélje le a nums[3] 0-ra. Az eredményül kapott tömb a következő: nums = [0,1,2,0,3,6,5,4].
Cserélje le a nums[4] 4-gyel. Az eredményül kapott tömb a következő: nums = [0,1,2,0,4,6,5,4].

Az X egész szám 4 lesz.

Korlátozások:

2 <= n == nums.length <= 10^5
n is even.
0 <= nums[i] <= k <= 10^5