Egy versenyen n csapat van számozva 0-tól n-1-ig.
Adott egy n * n méretű 0 indexű 2D logikai mátrix rács. Minden i, j esetén, hogy 0 <= i, j <= n - 1 és i != j csapat az i csapat erősebb, mint a j csapat, ha rács[i][j] == 1, ellenkező esetben a j csapat erősebb, mint az i csapat .
Az a csapat lesz a bajnokság bajnoka, ha nincs b csapat, amely erősebb az a csapatnál.
Adja vissza azt a csapatot, amelyik a bajnokság bajnoka lesz.

1. példa:

Bemenet: grid = [[0,1],[0,0]]
Kimenet: 0
Magyarázat: Két csapat vesz részt ezen a tornán.
grid[0][1] == 1 azt jelenti, hogy a 0. csapat erősebb, mint az 1. csapat. Tehát a 0. csapat lesz a bajnok.

2. példa:

Bemenet: grid = [[0,0,1],[1,0,1],[0,0,0]]
Kimenet: 1
Magyarázat: Három csapat vesz részt ezen a tornán.
grid[1][0] == 1 azt jelenti, hogy az 1. csapat erősebb, mint a 0. csapat.
grid[1][2] == 1 azt jelenti, hogy az 1. csapat erősebb, mint a 2. csapat.
Így az 1-es csapat lesz a bajnok.

Korlátozások:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] értéke 0 vagy 1.
Minden i grid[i][i] értéke 0.
Minden i, j esetén, hogy i != j,grid[i][j] != grid[j][i].
A bemenet úgy jön létre, hogy ha az a csapat erősebb, mint a b, és a b csapat erősebb, mint a c, akkor az a csapat erősebb, mint a c.

Egy versenyen n csapat van 0-tól n - 1-ig számozva.
Adott egy n * n méretű 0-indexelt 2D logikai mátrixrács.  Minden i, j esetén 0 <= i, j <= n - 1 és i != j az i csapat erősebb, mint a j csapat, ha rács[i][j] == 1, egyébként a j csapat erősebb, mint az i csapat.
Az A csapat lesz a torna bajnoka, ha nincs B csapat, amely erősebb az A csapatnál.
Küldje vissza azt a csapatot, amely a verseny bajnoka lesz.

1. példa:

Bemenet: grid = [[0,1],[0,0]]
Kimenet: 0
Magyarázat: Két csapat van ezen a tornán.
grid[0][1] == 1 azt jelenti, hogy a 0. csapat erősebb, mint az 1. csapat.  Tehát a 0. csapat lesz a bajnok.

2. példa:

Bemenet: grid = [[0,0,1],[1,0,1],[0,0,0]]
Kimenet: 1
Magyarázat: Három csapat van ezen a tornán.
grid[1][0] == Az 1 azt jelenti, hogy az 1. csapat erősebb, mint a 0. csapat.
grid[1][2] == Az 1 azt jelenti, hogy az 1. csapat erősebb, mint a 2. csapat.
Tehát az 1-es csapat lesz a bajnok.

Korlátok:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] is either 0 or 1.
For all i grid[i][i] is 0.
For all i, j that i != j, grid[i][j] != grid[j][i].
A bemenet úgy jön létre, hogy ha az a csapat erősebb, mint b csapat, és a b csapat erősebb, mint c csapat, akkor az a csapat erősebb, mint a c csapat.

Egy versenyen n csapat van számozva 0-tól n-1-ig.
Adott egy n * n méretű 0 indexű 2D logikai mátrix rács. Minden i, j esetén, hogy 0 <= i, j <= n - 1 és i != j csapat az i csapat erősebb, mint a j csapat, ha grid[i][j] == 1, ellenkező esetben a j csapat erősebb, mint az i csapat .
Az a csapat lesz a bajnokság bajnoka, ha nincs b csapat, amely erősebb az a csapatnál.
Adja vissza azt a csapatot, amelyik a bajnokság bajnoka lesz.

1. példa:

Bemenet: grid = [[0,1],[0,0]]
Kimenet: 0
Magyarázat: Két csapat vesz részt ezen a tornán.
grid[0][1] == 1 azt jelenti, hogy a 0. csapat erősebb, mint az 1. csapat. Tehát a 0. csapat lesz a bajnok.

2. példa:

Bemenet: grid = [[0,0,1],[1,0,1],[0,0,0]]
Kimenet: 1
Magyarázat: Három csapat vesz részt ezen a tornán.
grid[1][0] == 1 azt jelenti, hogy az 1. csapat erősebb, mint a 0. csapat.
grid[1][2] == 1 azt jelenti, hogy az 1. csapat erősebb, mint a 2. csapat.
Így az 1-es csapat lesz a bajnok.

Korlátozások:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] vagy 0 vagy 1.
Minden i esetén grid[i][i] 0.
Minden i, j esetén, ahol i != j, grid[i][j] != grid[j][i].
A bemenet úgy jön létre, hogy ha az a csapat erősebb, mint a b, és a b csapat erősebb, mint a c, akkor az a csapat erősebb, mint a c.


Adott két 0-indexált egész számtömb, nums1 és nums2, mindkettő hossza n.
Egy sor műveletet végezhetsz (esetleg egyet sem).
Egy műveletben kiválasztunk egy i indexet a [0, n - 1] tartományban, és felcseréljük a nums1[i] és nums2[i] értékeit.
A feladatunk az, hogy megtaláljuk a következő feltételek teljesítéséhez szükséges minimális műveletszámot:

nums1[n - 1] egyenlő a nums1 összes eleme közül a legnagyobb értékkel, azaz nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] egyenlő a nums2 összes elemének maximális értékével, azaz nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Visszaad egy egész számot, amely a mindkét feltétel teljesítéséhez szükséges minimális műveletszámot jelöli, vagy -1, ha mindkét feltétel nem teljesíthető.

Példa 1:

Bemenet: nums1 = [1,2,7], nums2 = [4,5,3]
Kimenet: 1
Magyarázat: Ebben a példában az i = 2 indexszel lehet műveletet végezni.
Ha nums1[2] és nums2[2] felcserélésre kerül, akkor nums1 [1,2,3], nums2 pedig [4,5,7] lesz.
Most már mindkét feltétel teljesül.
Kimutatható, hogy a minimálisan elvégzendő műveletek száma 1.
A válasz tehát 1.

Példa 2:

Bemenet: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Kimenet: 2
Magyarázat: Ebben a példában a következő műveletek végezhetők el:
Első művelet az i = 4 indexszel.
A nums1[4] és a nums2[4] felcserélésekor a nums1 [2,3,4,5,4], a nums2 pedig [8,8,4,4,9] lesz.
Egy másik művelet az i = 3 index használatával.
Amikor a nums1[3] és a nums2[3] felcserélődik, a nums1 [2,3,4,4,4], a nums2 pedig [8,8,4,5,9] lesz.
Most már mindkét feltétel teljesül.
Kimutatható, hogy a minimálisan szükséges műveletek száma 2.
A válasz tehát 2.

Példa 3:

Bemenet: nums1 = [1,5,4], nums2 = [2,5,3]
Kimenet: -1
Magyarázat: Ebben a példában nem lehetséges mindkét feltétel teljesülése.
A válasz tehát -1.

Korlátozások:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9

Két 0-indexelt egész tömböt kapunk, a nums1-et és a nums2-t, mindkettő n hosszúságú.
Műveletek sorozatát hajthatja végre (esetleg egyiket sem).
Egy műveletben kiválaszt egy i indexet a [0, n - 1] tartományban, és felcseréli a nums1[i] és a nums2[i] értékeit.
Az Ön feladata, hogy megtalálja az alábbi feltételek teljesítéséhez szükséges minimális számú műveletet:

nums1[n - 1] egyenlő a nums1 összes eleme közötti maximális értékkel, azaz nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]) .
nums2[n - 1] egyenlő a nums2 összes eleme közötti maximális értékkel, azaz nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]) .

Egy egész számot ad vissza, amely a mindkét feltétel teljesítéséhez szükséges műveletek minimális számát jelöli, vagy -1-et, ha nem teljesíthető mindkét feltétel.

1. példa:

Bemenet: nums1 = [1,2,7], nums2 = [4,5,3]
Kimenet: 1
Magyarázat: Ebben a példában egy művelet végrehajtható az i = 2 index használatával.
Ha a nums1[2] és a nums2[2] felcserélődnek, a nums1-ből [1,2,3], a nums2-ból pedig [4,5,7] lesz.
Most mindkét feltétel teljesül.
Megmutatható, hogy a végrehajtandó műveletek minimális száma 1.
Tehát a válasz: 1.

2. példa:

Bemenet: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Kimenet: 2
Magyarázat: Ebben a példában a következő műveletek hajthatók végre:
Az első művelet az i = 4 index használatával.
Amikor a nums1[4] és a nums2[4] felcserélődnek, a nums1-ből [2,3,4,5,4], a nums2-ból pedig [8,8,4,4,9] lesz.
Egy másik művelet az i = 3 index használatával.
Amikor anums1[3] és a nums2[3] felcserélődnek, a nums1-ből [2,3,4,4,4], a nums2-ból pedig [8,8,4,5,9] lesz.
Most mindkét feltétel teljesül.
Megmutatható, hogy a végrehajtandó műveletek minimális száma 2.
Tehát a válasz: 2.

3. példa:

Bemenet: nums1 = [1,5,4], nums2 = [2,5,3]
Kimenet: -1
Magyarázat: Ebben a példában nem lehet mindkét feltételt teljesíteni.
Tehát a válasz -1.

Korlátozások:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9

Két, 0-indexált egész számokat tartalmazó tömböt kapsz, nums1 és nums2, amelyek hossza n.
Megengedett, hogy egy sor műveletet (esetleg egyet sem) hajts végre.
Egy művelet során egy i indexet választasz a [0, n - 1] tartományban, és felcseréled nums1[i] és nums2[i] értékeit.
A feladatod az, hogy megtaláld a minimális számú műveletet, amellyel teljesíthetők a következő feltételek:

nums1[n - 1] egyenlő a nums1 összes elemének maximumával, azaz nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] egyenlő a nums2 összes elemének maximumával, azaz nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Adj vissza egy egész számot, amely a szükséges minimális műveletek számát jelöli a feltételek teljesítéséhez, vagy -1-et, ha lehetetlen mindkét feltételt teljesíteni.

Példa 1:

Bemenet: nums1 = [1,2,7], nums2 = [4,5,3]
Kimenet: 1
Magyarázat: Ebben a példában egy művelet végezhető az i = 2 index használatával.
Amikor nums1[2] és nums2[2] fel van cserélve, nums1 lesz [1,2,3] és nums2 lesz [4,5,7].
Mindkét feltétel most teljesül.
Bizonyítható, hogy a minimális műveletek száma 1.
Tehát a válasz 1.

Példa 2:

Bemenet: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Kimenet: 2
Magyarázat: Ebben a példában a következő műveletek végezhetők:
Első művelet az i = 4 index használatával.
Amikor nums1[4] és nums2[4] fel van cserélve, nums1 lesz [2,3,4,5,4], és nums2 lesz [8,8,4,4,9].
Egy másik művelet az i = 3 index használatával.
Amikor nums1[3] és nums2[3] fel van cserélve, nums1 lesz [2,3,4,4,4], és nums2 lesz [8,8,4,5,9].
Mindkét feltétel most teljesül.
Bizonyítható, hogy a minimális műveletek száma 2.
Tehát a válasz 2.

Példa 3:

Bemenet: nums1 = [1,5,4], nums2 = [2,5,3]
Kimenet: -1
Magyarázat: Ebben a példában nem lehetséges mindkét feltételt teljesíteni.
Tehát a válasz -1.

Korlátozások:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9


Adott három a, b és n egész szám (a XOR x) * (b XOR x) maximális értékét adja vissza, ahol 0 <= x < 2^n.
Mivel a válasz túl nagy lehet, adja vissza modulo 10^9 + 7.
Vegye figyelembe, hogy az XOR a bitenkénti XOR művelet.

Példa 1:

Bemenet: a = 12, b = 5, n = 4
Kimenet: 98
Magyarázat: Ha x = 2, (a XOR x) = 14 és (b XOR x) = 7. Tehát (a XOR x) * (b XOR x) = 98.
Megmutatható, hogy 98 az (a XOR x) * (b XOR x) maximális értéke minden 0 <= x < 2^n esetén.

Példa 2:

Bemenet: a = 6, b = 7, n = 5
Kimenet: 930
Magyarázat: Ha x = 25, (a XOR x) = 31 és (b XOR x) = 30. Ezért (a XOR x) * (b XOR x) = 930.
Megmutatható, hogy 930 az (a XOR x) * (b XOR x) maximális értéke minden 0 <= x < 2^n esetén.
Példa 3:

Bemenet: a = 1, b = 6, n = 3
Kimenet: 12
Magyarázat: Ha x = 5, (a XOR x) = 4 és (b XOR x) = 3. Tehát (a XOR x) * (b XOR x) = 12.
Megmutatható, hogy 12 az (a XOR x) * (b XOR x) maximális értéke minden 0 <= x < 2^n esetén.

Korlátozások:

0 <= a, b < 2^50
0 <= n <= 50

Adott három a, b és n egész szám (a XOR x) * (b XOR x) maximális értékét adja vissza, ahol 0 <= x < 2^n.
Mivel a válasz túl nagy lehet, adja vissza modulo 10^9 + 7.
Vegye figyelembe, hogy az XOR a bitenkénti XOR művelet.

1. példa:

Bemenet: a = 12, b = 5, n = 4
Kimenet: 98
Magyarázat: Ha x = 2, (a XOR x) = 14 és (b XOR x) = 7. Tehát (a XOR x) * (b XOR x) = 98.
Megmutatható, hogy 98 az (a XOR x) * (b XOR x) maximális értéke minden 0 <= x < 2^n esetén.

2. példa:

Bemenet: a = 6, b = 7, n = 5
Kimenet: 930
Magyarázat: Ha x = 25, (a XOR x) = 31 és (b XOR x) = 30. Ezért (a XOR x) * (b XOR x) = 930.
Megmutatható, hogy 930 az (a XOR x) * (b XOR x) maximális értéke minden 0 <= x < 2^n esetén.
3. példa:

Bemenet: a = 1, b = 6, n = 3
Kimenet: 12
Magyarázat: Ha x = 5, (a XOR x) = 4 és (b XOR x) = 3. Tehát (a XOR x) * (b XOR x) = 12.
Megmutatható, hogy 12 az (a XOR x) * (b XOR x) maximális értéke minden 0 <= x < 2^n esetén.

Korlátozások:

0 <= a, b < 2^50
0 <= n <= 50


Adott egy 0-indexált egész számtömb nums. Az x és y egész számok egy párját erős párnak nevezzük, ha kielégíti a feltételt:

|x - y| <= min(x, y)

Két olyan egész számot kell kiválasztanod a numsból, amelyek erős párt alkotnak, és bitenkénti XOR-juk a tömb összes erős párja közül a legnagyobb.
A nums tömbben található összes lehetséges erős pár közül a maximális XOR értéket adja vissza.
Vegyük figyelembe, hogy ugyanazt az egész számot kétszer is kiválaszthatjuk egy pár alkotásához.

Példa 1:

Bemenet: nums = [1,2,3,4,5]
Kimenet: 7
Magyarázat: A nums tömbben 11 erős pár van: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 4), (3, 5), (4, 4), (4, 5) és (5, 5).
A maximális lehetséges XOR ezekből a párokból 3 XOR 4 = 7.

2. példa:

Bemenet: nums = [10,100]
Kimenet: 0
Magyarázat: A nums tömbben 2 erős pár van: (10, 10) és (100, 100).
A maximálisan lehetséges XOR ezekből a párokból 10 XOR 10 = 0, mivel a (100, 100) pár is 100 XOR 100 = 0-t ad.

Példa 3:

Bemenet: nums = [5,6,25,30]
Kimenet: 7
Magyarázat: A nums tömbben 6 erős pár van: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) és (30, 30).
A maximális lehetséges XOR ezekből a párokból 25 XOR 30 = 7, mivel az egyetlen másik nem nulla XOR érték az 5 XOR 6 = 3.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot. Az x és y egész számpárt erős párnak nevezzük, ha teljesíti a következő feltételt:

|x - y| <= min(x, y)

Ki kell választani két egész számot a számokból úgy, hogy erős párt képezzenek, és bitenkénti XOR-értékük a maximum legyen a tömb összes erős párja között.
Adja vissza a maximális XOR értéket a tömbszámok összes lehetséges erős párja közül.
Ne feledje, hogy ugyanazt az egész számot kétszer kiválaszthatja egy pár létrehozásához.

1. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: 7
Magyarázat: A tömbszámokban 11 erős pár található: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3) , 4), (3, 5), (4, 4), (4, 5) és (5, 5).
Ezekből a párokból a lehetséges maximális XOR 3 XOR 4 = 7.

2. példa:

Bemenet: szám = [10 100]
Kimenet: 0
Magyarázat: A tömbszámokban 2 erős pár található: (10, 10) és (100, 100).
Az ezekből a párokból lehetséges maximális XOR 10 XOR 10 = 0, mivel a (100, 100) pár 100 XOR 100 = 0-t is ad.

3. példa:

Bemenet: nums = [5,6,25,30]
Kimenet: 7
Magyarázat: A tömbszámokban 6 erős pár található: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) és (30, 30).
Ezekből a párokból a lehetséges maximális XOR 25 XOR 30 = 7, mivel az egyetlen másik nem nulla XOR érték 5 XOR 6 = 3.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot. Az x és y egész számpárt erős párnak nevezzük, ha teljesíti a következő feltételt:

|x - y| <= min(x, y)

Ki kell választani két egész számot a számokból úgy, hogy erős párt képezzenek, és bitenkénti XOR-értékük a maximum legyen a tömb összes erős párja között.
Adja vissza a maximális XOR értéket a tömbszámok összes lehetséges erős párja közül.
Ne feledje, hogy ugyanazt az egész számot kétszer kiválaszthatja egy pár létrehozásához.

1. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: 7
Magyarázat: A tömbszámokban 11 erős pár található: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3) , 4), (3, 5), (4, 4), (4, 5) és (5, 5).
Ezekből a párokból a lehetséges maximális XOR 3 XOR 4 = 7.

2. példa:

Bemenet: nums = [10,100]
Kimenet: 0
Magyarázat: A tömbszámokban 2 erős pár található: (10, 10) és (100, 100).
Az ezekből a párokból lehetséges maximális XOR 10 XOR 10 = 0, mivel a (100, 100) pár 100 XOR 100 = 0-t is ad.

3. példa:

Bemenet: nums = [5,6,25,30]
Kimenet: 7
Magyarázat: A tömbszámokban 6 erős pár található: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) és (30, 30).
Ezekből a párokból a lehetséges maximális XOR 25 XOR 30 = 7, mivel az egyetlen másik nem nulla XOR érték 5 XOR 6 = 3.

Korlátozások:

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


Adott egy 0-indexált, szavakból és egy x karakterből álló tömb.
Az x karaktert tartalmazó szavak indexeinek tömbjét adja vissza.
Vegyük figyelembe, hogy a visszaadott tömb tetszőleges sorrendben állhat.

Példa 1:

Bemenet: words = ["leet","code"], x = "e"
Kimenet: [0,1]
Magyarázat: Az "e" mindkét szóban előfordul: "leet" és "kód". Ezért a 0 és 1 indexeket adjuk vissza.

Példa 2:

Bemenet: words = ["abc","bcd","aaaa","cbc"], x = "a"
Kimenet: [0,2]
Magyarázat: Az "a" az "abc" és az "aaaa" szókban fordul elő. Ezért a 0 és 2 indexeket adjuk vissza.

Példa 3:

Bemenet: words = ["abc","bcd","aaaa","cbc"], x = "z"
Kimenet: []
Magyarázat: A "z" egyik szóban sem fordul elő. Ezért egy üres tömböt adunk vissza.

Korlátozások:

1 <= words.length <= 50
1 <= words[i].length <= 50
x egy kisbetűs angol betű.
words[i] csak kisbetűs angol betűkből áll.

Kapsz egy 0-indexelt karakterlánc-szavakat és egy x karaktert.
Az x karaktert tartalmazó szavakat képviselő indexek tömbjét adja vissza.
Vegye figyelembe, hogy a visszaadott tömb bármilyen sorrendben lehet.

1. példa:

Bemenet: words = ["leet", "code"], x = "e"
Kimenet: [0,1]
Magyarázat: "e" mindkét szóban előfordul: "leet" és "code". Ezért 0 és 1 indexet adunk vissza.

2. példa:

Bemenet: words = ["abc", "bcd", "aaaa","cbc"], x = "a"
Kimenet: [0,2]
Magyarázat: "a" az "abc" és az "aaaa" szóban fordul elő. Ezért a 0 és 2 indexet adjuk vissza.

3. példa:

Bemenet: words = ["abc", "bcd", "aaaa", "cbc"], x = "z"
Kimenet: []
Magyarázat: "z" egyik szóban sem fordul elő. Ezért egy üres tömböt adunk vissza.

Korlátozások:

1 <= words.length <= 50
1 <= words[i].length <= 50
x egy kis angol betű.
A szavak[i] csak kisbetűket tartalmaz angolul.

Kapsz egy 0-indexelt sztring words és egy x karaktert.
Az x karaktert tartalmazó szavakat képviselő indexek tömbjét adja vissza.
Vegye figyelembe, hogy a visszaadott tömb bármilyen sorrendben lehet.

1. példa:

Bemenet: words = ["leet","code"], x = "e"
Kimenet: [0,1]
Magyarázat: "e" mindkét szóban előfordul: "leet" és "code". Ezért 0 és 1 indexet adunk vissza.

2. példa:

Bemenet: words = ["abc","bcd","aaaa","cbc"], x = "a"
Kimenet: [0,2]
Magyarázat: "a" az "abc" és az "aaaa" szóban fordul elő. Ezért a 0 és 2 indexet adjuk vissza.

3. példa:

Bemenet: words = ["abc","bcd","aaaa","cbc"], x = "z"
Kimenet: []
Magyarázat: "z" egyik szóban sem fordul elő. Ezért egy üres tömböt adunk vissza.

Korlátozások:

1 <= words.length <= 50
1 <= words[i].length <= 50
x egy kis angol betű.
A words[i] csak kisbetűket tartalmaz angolul.


Egy asztalon n golyó van, mindegyik golyónak fekete vagy fehér színe van.
Kapunk egy 0 indexű bináris s n hosszúságú sztringet, ahol 1 és 0 fekete és fehér golyókat jelöl.
Minden lépésben kiválaszthat két szomszédos golyót, és felcserélheti őket.
Tegye vissza a minimális számú lépést, hogy az összes fekete golyót jobbra, a fehér golyókat pedig balra csoportosítsa.

1. példa:

Bemenet: s = "101"
Kimenet: 1
Magyarázat: Az összes fekete golyót jobbra csoportosíthatjuk a következő módon:
- Swap s[0] és s[1], s = "011".
Kezdetben az 1-esek nincsenek csoportosítva, ezért legalább 1 lépés szükséges ahhoz, hogy jobbra csoportosítsák őket.
2. példa:

Bemenet: s = "100"
Kimenet: 2
Magyarázat: Az összes fekete golyót jobbra csoportosíthatjuk a következő módon:
- Swap s[0] és s[1], s = "010".
- Swap s[1] és s[2], s = "001".
Bizonyítható, hogy a szükséges lépések minimális száma 2.

3. példa:

Bemenet: s = "0111"
Kimenet: 0
Magyarázat: Az összes fekete golyó már jobbra csoportosítva van.

Korlátozások:

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

Egy asztalon n golyó van, mindegyik golyónak fekete vagy fehér színe van.
Kapunk egy 0 indexű bináris s n hosszúságú sztringet, ahol 1 és 0 fekete és fehér golyókat jelöl.
Minden lépésben kiválaszthat két szomszédos labdát, és felcserélheti őket.
Tegye vissza a minimális számú lépést, hogy az összes fekete golyót jobbra, a fehér golyókat pedig balra csoportosítsa.

1. példa:

Bemenet: s = "101"
Kimenet: 1
Magyarázat: Az összes fekete golyót jobbra csoportosíthatjuk a következő módon:
- Csere s[0] és s[1], s = "011".
Kezdetben az 1-esek nincsenek csoportosítva, ezért legalább 1 lépés szükséges a jobb oldali csoportosításukhoz.
2. példa:

Bemenet: s = "100"
Kimenet: 2
Magyarázat: Az összes fekete golyót jobbra csoportosíthatjuk a következő módon:
- Csere s[0] és s[1], s = "010".
- Csere s[1] és s[2], s = "001".
Bizonyítható, hogy a szükséges lépések minimális száma 2.

3. példa:

Bemenet: s = "0111"
Kimenet: 0
Magyarázat: Az összes fekete golyó már jobbra csoportosítva van.

Korlátozások:

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

Egy asztalon n golyó van, minden golyó fekete vagy fehér színű.
Kapsz egy 0-indexelt bináris s karakterláncot, amelynek hossza n, ahol 1 és 0 fekete-fehér golyókat jelent.
Minden lépésben két szomszédos golyót választhat, és kicserélheti őket.
Adja vissza a lépések minimális számát az összes fekete golyó jobbra és az összes fehér golyó balra csoportosításához.

1. példa:

Bemenet: s = "101"
Kimenet: 1
Magyarázat: Az összes fekete golyót jobbra csoportosíthatjuk a következő módon:
- Swap s[0] és s[1], s = "011".
Kezdetben az 1-esek nincsenek csoportosítva, így legalább 1 lépésre van szükség a jobb oldali csoportosításhoz.
2. példa:

Bemenet: s = "100"
Kimenet: 2
Magyarázat: Az összes fekete golyót jobbra csoportosíthatjuk a következő módon:
- Swap s[0] és s[1], s = "010".
- Swap s[1] és s[2], s = "001".
Bizonyítható, hogy a szükséges lépések minimális száma 2.

3. példa:

Bemenet: s = "0111"
Kimenet: 0
Magyarázat: Az összes fekete golyó már jobbra van csoportosítva.

Korlátok:

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


Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
A következő műveletet legfeljebb k alkalommal hajthatja végre a tömbön:

Válasszon ki egy tetszőleges i indexet a tömbből, és növelje vagy csökkentse a nus[i] értéket 1-gyel.

A végső tömb pontszáma a tömb leggyakrabban előforduló elemének gyakorisága.
Adja vissza az elérhető maximális pontszámot.
Egy elem gyakorisága az adott elem előfordulásának száma a tömbben.

Példa 1:

Bemenet: nums = [1,2,6,4], k = 3
Kimenet: 3
Magyarázat: A következő műveleteket végezhetjük el a tömbön:
- Válassza az i = 0 értéket, és növelje a nums[0] értékét 1-gyel. A kapott tömb a [2,2,6,4].
- Válassza az i = 3-at, és csökkentse a nums[3] értékét 1-gyel. A kapott tömb [2,2,6,3].
- Válassza ki az i = 3-at, és csökkentse a nums[3] értékét 1-gyel. A kapott tömb a [2,2,6,2].
A 2-es elem a leggyakrabban előforduló a végső tömbben, így a pontszámunk 3.
Kimutatható, hogy ennél jobb eredményt nem tudunk elérni.

Példa 2:

Bemenet: nums = [1,4,4,2,4], k = 0
Kimenet: 3
Magyarázat: Nem tudunk műveleteket alkalmazni, így a pontszámunk az eredeti tömb leggyakrabban előforduló elemének gyakorisága lesz, ami 3.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
A tömbön legfeljebb k időpontban hajthatja végre a következő műveletet:

Válasszon ki egy i indexet a tömbből, és növelje vagy csökkentse a számokat [i] 1-gyel.

A végső tömb pontszáma a tömb leggyakoribb elemének gyakorisága.
Adja vissza az elérhető maximális pontszámot.
Egy elem gyakorisága az adott elem előfordulásainak száma a tömbben.

1. példa:

Bemenet: szám = [1,2,6,4], k = 3
Kimenet: 3
Magyarázat: A következő műveleteket hajthatjuk végre a tömbön:
- Válassza az i = 0 lehetőséget, és növelje a számok[0] értékét 1-gyel. Az eredményül kapott tömb [2,2,6,4].
- Válassza az i = 3 lehetőséget, és csökkentse a számok[3] értékét 1-gyel. Az eredményül kapott tömb [2,2,6,3].
- Válassza az i = 3 lehetőséget, és csökkentse a számok[3] értékét 1-gyel. Az eredményül kapott tömb [2,2,6,2].
A 2-es elem a leggyakoribb a végső tömbben, így pontszámunk 3.
Megmutatható, hogy nem érhetünk el jobb pontszámot.

2. példa:

Bemenet: nums = [1,4,4,2,4], k = 0
Kimenet: 3
Magyarázat: Nem alkalmazhatunk semmilyen műveletet, így pontszámunk az eredeti tömb leggyakoribb elemének gyakorisága lesz, ami 3.

Korlátok:

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

Adott egy 0-indexált egész szám tömb nums és egy egész szám k.
A tömbön legfeljebb k-szor végezhetjük el a következő műveletet:

Válasszuk ki a tömb bármely i indexét, és növeljük vagy csökkentsük a nums[i] értékét 1-gyel.

A végső tömb pontszáma a tömb leggyakoribb elemének gyakorisága.
Adja vissza a maximálisan elérhető pontszámot.
Egy elem gyakorisága az adott elem előfordulási száma a tömbben.

Példa 1:

Bemenet: nums = [1,2,6,4], k = 3
Kimenet: 3
Magyarázat: A következő műveleteket végezhetjük a tömbön:
- Válasszuk i = 0-t, és növeljük a nums[0] értékét 1-gyel. Az így kapott tömb [2,2,6,4] lesz.
- Válasszuk i = 3, és csökkentsük a nums[3] értékét 1-gyel. A kapott tömb [2,2,6,3].
- Válasszuk i = 3, és csökkentsük a nums[3] értékét 1-gyel. A kapott tömb [2,2,6,2].
A 2. elem a leggyakoribb a végső tömbben, így a pontszámunk 3.
Megmutatható, hogy ennél jobb pontszámot nem tudunk elérni.

2. példa:

Bemenet: nums = [1,4,4,4,2,4], k = 0
Kimenet: 3
Magyarázat: Így a pontszámunk az eredeti tömb leggyakoribb elemének a gyakorisága lesz, ami 3.

Korlátozások:

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


Kapsz két pozitív egész számot, n és határértéket.
Adja vissza az n cukorka 3 gyermek között történő szétosztásának teljes számát úgy, hogy egyetlen gyermek se kapjon több édességet a limitnél.

1. példa:

Bemenet: n = 5, limit = 2
Kimenet: 3
Magyarázat: Háromféleképpen lehet 5 cukorkát kiosztani úgy, hogy egyetlen gyerek se kapjon 2-nél többet: (1, 2, 2), (2, 1, 2) és (2, 2, 1).

2. példa:

Bemenet: n = 3, limit = 3
Kimenet: 10
Magyarázat: 10 módja van 3 cukorka kiosztásának úgy, hogy egyetlen gyerek se kapjon 3 cukorkánál többet: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0) ), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) és (3, 0, 0).

Korlátozások:

1 <= n <= 50
1 <= limit <= 50

Adott két pozitív egész szám, n és határérték.
Adja meg az n cukorka 3 gyerek között történő szétosztásának összes módját úgy, hogy egyik gyerek se kapjon több cukorkát, mint a határérték.

Példa 1:

Bemenet: n = 5, limit = 2
Kimenet: 3
Magyarázat: Az 5 cukorka elosztásának 3 módja van úgy, hogy egyetlen gyerek se kapjon 2 cukorkánál többet: (1, 2, 2), (2, 1, 2) és (2, 2, 1).

2. példa:

Bemenet: n = 3, limit = 3
Kimenet: 10
Magyarázat: Tízféleképpen lehet úgy elosztani 3 cukorkát, hogy egyetlen gyerek se kapjon 3 cukorkánál többet: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) és (3, 0, 0).

Korlátozások:

1 <= n <= 50
1 <= limit <= 50


Egy n egész számot kapsz.
Az s karakterláncot akkor nevezzük jónak, ha csak kisbetűs angol karaktereket tartalmaz, és át lehet rendezni az s karaktereit úgy, hogy az új karakterlánc a "leet" karakterláncot tartalmazza.
Például:

Az "lteer" karakterlánc jó, mert átrendezhetjük "leetr"-re.
A "letl" nem jó, mert nem tudjuk átrendezni úgy, hogy a "leet" karakterláncot tartalmazza.

Az n hosszúságú jó karakterláncok teljes számát adja vissza.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
A részkarakterlánc egy karakterláncon belüli összefüggő karaktersorozat.

1. példa:

Bemenet: n = 4
Kimenet: 12
Magyarázat: A 12 karakterlánc, amely átrendezhető, hogy "leet" legyen részkarakterláncként: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete" , "ltee", "teel", "tele" és "tlee".

2. példa:

Bemenet: n = 10
Kimenet: 83943898
Magyarázat: A 10 hosszúságú karakterláncok száma, amelyek átrendezhetők, hogy a "leet" legyen részkarakterlánc, 526083947580. Ezért a válasz 526083947580 % (10^9 + 7) = 83943898.

Korlátozások:

1 <= n <= 10^5

Egy n egész számot kapsz.
Az s karakterláncot akkor nevezzük jónak, ha csak kisbetűs angol karaktereket tartalmaz, és át lehet rendezni az s karaktereit úgy, hogy az új karakterlánc a "leet" karakterláncot tartalmazza.
Például:

Az "lteer" karakterlánc jó, mert átrendezhetjük "leetr"-re.
A "letl" nem jó, mert nem tudjuk átrendezni úgy, hogy a "leet" karakterláncot tartalmazza.

Az n hosszúságú jó karakterláncok teljes számát adja vissza.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
A részkarakterlánc egy karakterláncon belüli összefüggő karaktersorozat.

példa 1:

Bemenet: n = 4
Kimenet: 12
Magyarázat: A 12 karakterlánc, amely átrendezhető, hogy "leet" legyen részkarakterláncként: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete" , "ltee", "teel", "tele" és "tlee".

példa 2:

Bemenet: n = 10
Kimenet: 83943898
Magyarázat: A 10 hosszúságú karakterláncok száma, amelyek átrendezhetők, hogy a "leet" legyen részkarakterlánc, 526083947580. Ezért a válasz 526083947580 % (10^9 + 7) = 83943898.

Korlátozások:

1 <= n <= 10^5

Adott egy egész n szám.
Egy s karakterláncot akkor nevezünk jónak, ha csak kisbetűs angol karaktereket tartalmaz, és az s karaktereit úgy lehet átrendezni, hogy az új karakterlánc részsorozatként tartalmazza a „leet” szót.
Például:

Az "lteer" karakterlánc jó, mert átrendezhetjük, hogy "leetr" legyen .
A "letl" nem jó, mert nem tudjuk átrendezni úgy, hogy a "leet" szót tartalmazza részkarakterláncként.

Az n hosszúságú jó karakterláncok teljes számát adja vissza.
Mivel a válasz nagy lehet, adjuk vissza modulo 10^9 + 7.
A részlánc egy karakterláncon belüli összefüggő karaktersorozat.

Példa 1:

Bemenet: n = 4
Kimenet: 12
Magyarázat: A 12 húr, amely átrendezhető úgy, hogy a "leet" legyen az alhúrja: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" és "tlee".

Példa 2:

Bemenet: n = 10
Kimenet: 83943898
Magyarázat: A 10 hosszúságú húrok száma, amelyek átrendezhetők úgy, hogy "leet" legyen részkarakterlánc, 526083947580. Ezért a válasz 526083947580% (10^9 + 7) = 83943898.

Korlátozások:

1 <= n <= 10^5


Adott egy 0-indexelt, páros hosszúságú, n karakterből álló s string.
Továbbá, adott egy 0-indexelt kétdimenziós, egész számokat tartalmazó queries tömb, ahol queries[i] = [a_i, b_i, c_i, d_i].
Minden egyes lekérdezésnél az alábbi műveletek végezhetők:

Átrendezheted a karaktereket az s[a_i:b_i] részsztringben, ahol 0 <= a_i <= b_i < n / 2.
Átrendezheted a karaktereket az s[c_i:d_i] részsztringben, ahol n / 2 <= c_i <= d_i < n.
Minden lekérdezésnél el kell döntenünk, hogy lehetséges-e a műveletek végrehajtásával palindrómmá alakítani az s stringet.
Minden lekérdezés független a többitől.
Válaszolj egy 0-indexelt válasz tömbbel, ahol answer[i] == true, ha lehetséges palindrómmá tenni az s stringet az i-edik lekérdezés által meghatározott műveletek végrehajtásával, és false egyébként.

Egy részsztring egy összefüggő karakterlánc egy stringben.
s[x:y] az x indextől az y indexig tartó karaktereket jelenti az s stringben, mindkét index inkluzív.

Példa 1:

Bemenet: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Kimenet: [true,true]
Magyarázat:
Ebben a példában két lekérdezés van:

Az első lekérdezésnél:
a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
Tehát, átrendezhetjük s[1:1] => abcabc és s[3:5] => abcabc.
Ahhoz, hogy az s palindrómmá váljon, az s[3:5] részt át lehet rendezni abccba formára.
Most az s palindrómmá válik, tehát answer[0] = true.

A második lekérdezésnél:
a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
Tehát, átrendezhetjük s[0:2] => abcabc és s[5:5] => abcabc.
Az s[0:2] részt át lehet rendezni cbaabc formára, és most az s palindrómmá válik.
Tehát answer[1] = true.

Példa 2:

Bemenet: s = "abbcdecbba", queries = [[0,2,7,9]]
Kimenet: [false]
Magyarázat:
Ebben a példában csak egy lekérdezés van:
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Átrendezhetjük s[0:2] => abbcdecbba és s[7:9] => abbcdecbba.
De nem lehetséges palindrómmá tenni az s-t, mert s[3:6] nem palindróma.
Tehát answer[0] = false.

Példa 3:

Bemenet: s = "acbcab", queries = [[1,2,4,5]]
Kimenet: [true]
Magyarázat:
Ebben a példában csak egy lekérdezés van:
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Átrendezhetjük s[1:2] => acbcab és s[4:5] => acbcab.
Ahhoz, hogy az s palindrómmá váljon, az s[1:2] részt át lehet rendezni abccab-ra, és az s[4:5] részt át lehet rendezni abccba-ra.
Most az s palindrómmá válik, tehát answer[0] = true.

Korlátok:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n páros.
s csak kis angol betűkből áll.

Kapsz egy 0-indexelt s karakterláncot, amelynek páros hosszúságú n.
Kap egy 0 indexelt 2D egész tömböt is, ahol a queries[i] = [a_i, b_i, c_i, d_i].
Minden i lekérdezéshez a következő műveleteket hajthatja végre:

Rendezze át a karaktereket az s[a_i:b_i] alkarakterláncon belül, ahol 0 <= a_i <= b_i < n / 2.
Rendezze át a karaktereket az s[c_i:d_i] alsztringen belül, ahol n / 2 <= c_i <= d_i < n.

Minden lekérdezésnél az a feladat, hogy meghatározza, hogy lehetséges-e palindromot készíteni a műveletek végrehajtásával.
Minden lekérdezésre a többitől függetlenül válaszol a rendszer.
0 indexelt tömbválaszt ad vissza, ahol answer[i] == igaz, ha az i^th lekérdezésben meghatározott műveletek végrehajtásával palindrommá lehet tenni s-t, egyébként pedig hamis.

A részkarakterlánc karakterek összefüggő sorozata egy karakterláncon belül.
Az s[x:y] az x indextől az y indexig terjedő karakterekből álló részkarakterláncot jelöli s-ben, mindkettőt beleértve.

1. példa:

Bemenet:  s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Kimenet: [true,true]
Magyarázat: Ebben a példában két lekérdezés van:
Az első lekérdezésben:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Tehát megengedett az s[1:1] => abcabc és az s[3:5] => abcabc átrendezése.
- Ahhoz, hogy s palindrom legyen, s[3:5] átrendezhető => abccba-ra.
- Most s egy palindrom. Tehát válasz[0] = igaz.
A második lekérdezésben:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Tehát megengedett az s[0:2] => abcabc és az s[5:5] => abcabc átrendezése.
- Ahhoz, hogy s palindrom legyen, s[0:2] átrendezhető => cbaabc-ra.
- Most s egy palindrom. Tehát válasz[1] = igaz.

2. példa:

Bemenet: s = "abbcdecbba", queries = [[0,2,7,9]]
Kimenet: [false]
Magyarázat: Ebben a példában csak egy lekérdezés van.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Tehát átrendezheti az s[0:2] = > abbcdecbba és az s[7:9] = > abbcdecbba átrendezését.
Nem lehet palindrommá tenni ezeket a részszálakat, mert az s[3:6] nem palindrom.
Tehát válasz[0] = false.
3. példa:

Bemenet: s = "acbcab", queries = [[1,2,4,5]]
Kimenet: [true]
Magyarázat: Ebben a példában csak egy lekérdezés van.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Tehát átrendezheti az s[1:2] => acbcab és s[4:5] = > acbcab értékeket.
Ahhoz, hogy s egy palindrom legyen, az s[1:2] átrendezhető, hogy abccab legyen.
Ezután az s[4:5] átrendezhető, hogy abccbává váljon.
Most s egy palindrom. Tehát válasz[0] =true.

Korlátok:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n páros.
s csak kisbetűs angol betűkből áll.

Kapunk egy 0 indexű s karakterláncot, amelynek páros hossza n.
Kapsz még egy 0-indexelt 2D egész tömböt, lekérdezéseket, ahol queries[i] = [a_i, b_i, c_i, d_i].
Minden i lekérdezésnél a következő műveleteket hajthatja végre:

Rendezd át a karaktereket az s[a_i:b_i] részkarakterláncon belül, ahol 0 <= a_i <= b_i < n / 2.
Rendezd át a karaktereket az s[c_i:d_i] részkarakterláncon belül, ahol n / 2 <= c_i <= d_i < n.

Minden lekérdezésnél az a feladata, hogy megállapítsa, lehetséges-e s palindromot készíteni a műveletek végrehajtásával.
Minden kérdésre a többitől függetlenül válaszol.
0-indexelt tömbválaszt ad vissza, ahol a answer[i] == igaz, ha lehetséges s palindrommá tenni az i^. lekérdezés által meghatározott műveletek végrehajtásával, és hamis egyébként.

A részkarakterlánc egy karakterláncon belüli összefüggő karaktersorozat.
Az s[x:y] azt a részkarakterláncot jelöli, amely az x indextől az y indexig terjedő karakterekből áll s-ben, mindkettőt beleértve.

1. példa:

Bemenet: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Kimenet:  [true,true]
Magyarázat: Ebben a példában két lekérdezés van:
Az első lekérdezésben:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Tehát átrendezheti az s[1:1] => abcabc és az s[3:5] => abcabc értékeket.
- Ahhoz, hogy s palindrom legyen, az s[3:5] átrendezhető => abccba-ra.
- Nos, s egy palindrom. Tehát  answer[0] = true.
A második lekérdezésben:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Tehát az s[0:2] => abcabc és az s[5:5] => abcabc átrendezése megengedett.
- Ahhoz, hogy s palindrom legyen, az s[0:2]-t átrendezhetjük => cbaabc-re.
- Nos, s egy palindrom. Tehát answer[1] = true.

2. példa:

Bemenet: s = "abbcdecbba", queries = [[0,2,7,9]]
Kimenet: [false]
Magyarázat: Ebben a példában csak egy lekérdezés van.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Tehát átrendezheti az s[0:2] => abbcdecbba és az s[7:9] => abbcdecbba paramétereket.
Nem lehet s-t palindromává tenni ezen részkarakterláncok átrendezésével, mert az s[3:6] nem palindrom.
Tehát answer[0] = false.
3. példa:

Bemenet: s = "acbcab", lekérdezések = [[1,2,4,5]]
Kimenet: [true]
Magyarázat: Ebben a példában csak egy lekérdezés van.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Tehát átrendezheti az s[1:2] => acbcab és az s[4:5] => acbcab értékeket.
A palindrom létrehozásához az s[1:2] átrendezhető abccab-ra.
Ezután az s[4:5] átrendezhető abccba-ra.
Nos, s egy palindrom. answer[0] = true.

Korlátozások:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n páros.
s csak kis angol betűkből áll.


Két 0 indexelt egész tömböt kap, nums1 és nums2 n és m méretben.
Fontolja meg a következő értékek kiszámítását:

Az i indexek száma úgy, hogy 0 <= i < n és nums1[i] legalább egyszer előfordul nums2-ben.
Az i indexek száma úgy, hogy 0 <= i < m és nums2[i] legalább egyszer előfordul nums1-ben.

Egy 2-es méretű egész tömbválaszt ad vissza, amely a fenti sorrendben tartalmazza a két értéket.

1. példa:

Bemenet: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Kimenet: [3,4]
Magyarázat: Az értékeket a következőképpen számítjuk ki:
- A nums1 1., 2. és 3. indexében lévő elemek legalább egyszer előfordulnak nums2-ben. Tehát az első érték 3.
- A nums2 0, 1, 3 és 4 indexében lévő elemek legalább egyszer előfordulnak nums1-ben. Tehát a második érték 4.

2. példa:

Bemenet: nums1 = [3,4,2,3], nums2 = [1,5]
Kimenet: [0,0]
Magyarázat: A két tömb között nincsenek közös elemek, ezért a két érték 0 lesz.

Korlátok:

n == nums1.length
m == nums2.length
1 < = n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Adott két 0-indexált egész számtömb nums1 és nums2, amelyek n és m méretűek.
Tekintsük a következő értékek kiszámítását:

Az i indexek száma úgy, hogy 0 <= i < n és nums1[i] legalább egyszer előfordul nums2-ben.
Azon i indexek száma, amelyeknél 0 <= i < m és nums2[i] legalább egyszer előfordul nums1-ben.

Visszaad egy 2 méretű egész számtömb válaszát, amely a két értéket a fenti sorrendben tartalmazza.

Példa 1:

Bemenet: nums1 = [4,3,2,3,3,1], nums2 = [2,2,5,2,3,6].
Kimenet: [3,4]
Magyarázat: Az értékeket a következőképpen számoljuk ki:
- A nums1-ben az 1, 2 és 3 indexű elemek legalább egyszer előfordulnak a nums2-ben. Az első érték tehát 3.
- A nums2 0, 1, 3 és 4 indexű elemei legalább egyszer előfordulnak a nums1-ben. Tehát a második érték 4.

2. példa:

Bemenet: nums1 = [3,4,2,3], nums2 = [1,5].
Kimenet: [0,0]
Magyarázat: A két tömb között nincsenek közös elemek, így a két érték 0 lesz.

Korlátozások:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Két 0-indexelt egész szám tömböt kapsz, nums1 és nums2, amelyek méretei n és m, respectivamente.
Vegyük fontolóra a következő értékek kiszámítását:

Az i indexek számát, ahol 0 <= i < n, és nums1[i] legalább egyszer előfordul nums2-ben.
Az i indexek számát, ahol 0 <= i < m, és nums2[i] legalább egyszer előfordul nums1-ben.

Térj vissza egy egész szám tömbbel, amelynek mérete 2, és tartalmazza a két értéket a fenti sorrendben.

 Példa 1:

Input: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Output: [3,4]
Magyarázat: A következőképpen számoljuk ki az értékeket:
- A nums1 1-es, 2-es és 3-as indexén lévő elemek legalább egyszer előfordulnak nums2-ben. Tehát az első ér
- A nums2 0-ás, 1-es, 3-as és 4-es indexén lévő elemek legalább egyszer előfordulnak nums1-ben. Tehát a második érték 4.

Példa 2:

Input: nums1 = [3,4,2,3], nums2 = [1,5]
Output: [0,0]
Magyarázat: Nincs közös elem a két tömb között, így a két érték 0 lesz.

Korlátozások:

n == nums1.hossza
m == nums2.hossza
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100


Három karakterláncot kapsz: s1, s2 és s3. Ezen a három karakterláncon annyiszor is el lehet végezni a következő műveletet, ahányszor csak szeretné.
Egy műveletben kiválaszthatunk egyet a három karakterlánc közül úgy, hogy annak hossza legalább 2 legyen, és törölje a jobb szélső karaktert.
Adja vissza a minimális számú műveletet, amelyet el kell végeznie ahhoz, hogy a három karakterlánc egyenlő legyen, ha van mód arra, hogy egyenlővé tegye őket, ellenkező esetben adjon vissza -1-et.

példa 1:

Bemenet: s1 = "abc", s2 = "abb", s3 = "ab"
Kimenet: 2
Magyarázat: Az s1 és s2 műveletek egyszeri végrehajtása három egyenlő karakterláncot eredményez.
Kimutatható, hogy kettőnél kevesebb művelettel nem lehet egyenlővé tenni őket.
példa 2:

Bemenet: s1 = "dac", s2 = "bac", s3 = "cac"
Kimenet: -1
Magyarázat: Mivel az s1 és s2 bal szélső betűi nem egyenlőek, nem lehetnek egyenlőek akárhány művelet után sem. Tehát a válasz -1.

Korlátozások:

1 <= s1.length, s2.length, s3.length <= 100
Az s1, s2 és s3 csak kis angol betűket tartalmaz.

Három karakterláncot kap: s1, s2 és s3. A következő műveletet annyiszor kell végrehajtania ezen a három karakterláncon, ahányszor csak akarja.
Egy műveletben kiválaszthatja a három karakterlánc egyikét úgy, hogy a hossza legalább 2 legyen, és törölheti a jobb szélső karakterét.
Adja vissza a három karakterlánc egyenlővé tételéhez szükséges műveletek minimális számát, ha van mód arra, hogy egyenlőek legyenek, ellenkező esetben adja vissza a -1 értéket.

1. példa:

Bemenet: s1 = "abc", s2 = "abb", s3 = "ab"
Kimenet: 2
Magyarázat: Az s1 és s2 műveletek egyszeri végrehajtása három egyenlő karakterlánchoz vezet.
Megmutatható, hogy nincs mód arra, hogy kettőnél kevesebb művelettel egyenlővé tegyük őket.
2. példa:

Bemenet: s1 = "dac", s2 = "bac", s3 = "cac"
Kimenet: -1
Magyarázat: Mivel az s1 és s2 bal szélső betűi nem egyenlők, tetszőleges számú művelet után sem lehetnek egyenlők. Tehát a válasz -1.

Korlátok:

1 <= s1.length, s2.length, s3.length <= 100
Az s1, s2 és s3 csak kisbetűs angol betűkből áll.

Három karakterláncot kapsz: s1, s2 és s3. Ezen a három karakterláncon annyiszor kell végrehajtania a következő műveletet, ahányszor csak akarja.
Egy műveletben kiválaszthatunk egyet a három karakterlánc közül úgy, hogy annak hossza legalább 2 legyen, és törölje a jobb szélső karaktert.
Adja vissza a minimális számú műveletet, amelyet el kell végeznie ahhoz, hogy a három karakterlánc egyenlő legyen, ha van mód arra, hogy egyenlővé tegye őket, ellenkező esetben adjon vissza -1-et.

1. példa:

Bemenet: s1 = "abc", s2 = "abb", s3 = "ab"
Kimenet: 2
Magyarázat: Az s1 és s2 műveletek egyszeri végrehajtása három egyenlő karakterláncot eredményez.
Kimutatható, hogy kettőnél kevesebb művelettel nem lehet egyenlővé tenni őket.
2. példa:

Bemenet: s1 = "dac", s2 = "bac", s3 = "cac"
Kimenet: -1
Magyarázat: Mivel az s1 és s2 bal szélső betűi nem egyenlőek, nem lehetnek egyenlőek akárhány művelet után sem. Tehát a válasz -1.

Korlátozások:

1 <= s1.length, s2.length, s3.length <= 100
Az s1, s2 és s3 csak kis angol betűket tartalmaz.


Ön egy gyümölcspiacon van, ahol különféle egzotikus gyümölcsök láthatók.
Kapsz egy 1-től kezdődő árakat, ahol az árak[i] az i^edik gyümölcs megvásárlásához szükséges érmék számát jelöli.
A gyümölcspiac a következő kínálattal rendelkezik:

Ha az i^edik gyümölcsöt [i] érmék áron vásárolja meg, a következő i gyümölcsöket ingyen kaphatja meg.

Ne feledje, hogy még ha ingyenesen is elviheti a gyümölcsöt, akkor is megvásárolhatja [j] érmékért, hogy új ajánlatot kapjon.
Adja vissza az összes gyümölcs megszerzéséhez szükséges minimális számú érmét.

Példa 1:

Bemenet: prices = [3,1,2]
Kimenet: 4
Magyarázat: A gyümölcsöket a következőképpen szerezheti be:
- Vásárolja meg az 1. gyümölcsöt 3 érmével, a 2. gyümölcsöt ingyen viheti.
- Vásárolja meg a 2. gyümölcsöt 1 érmével, a 3. gyümölcsöt ingyen viheti.
- Vigye ingyen a 3^. gyümölcsöt.
Ne feledje, hogy bár a 2. gyümölcsöt ingyen elvihette, azért vásárolta meg, mert az optimálisabb.
Bizonyítható, hogy az összes gyümölcs megszerzéséhez szükséges minimális érmék száma 4.

Példa 2:

Bemenet: prices = [1,10,1,1]
Kimenet: 2
Magyarázat: A gyümölcsöket a következőképpen szerezheti be:
- Vásárolja meg az 1. gyümölcsöt 1 érmével, a 2. gyümölcsöt ingyen viheti.
- A 2., gyümölcsöt vigye ingyen.
- Vásárolja meg a 3. gyümölcsöt 1 érméért, a 4. gyümölcsöt ingyen viheti.
- Vigye ingyen a 4.gyümölcsöt.
Bizonyítható, hogy 2 az összes gyümölcs megszerzéséhez szükséges minimális érme.

Korlátozások:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

Ön egy gyümölcspiacon van, ahol különféle egzotikus gyümölcsök láthatók.
Kap egy 1-indexű árakat", ahol az árak[i] az i^edik gyümölcs megvásárlásához szükséges érmék számát jelöli.
A gyümölcspiac a következő kínálattal rendelkezik:

Ha az i^edik gyümölcsöt i érmékért vásárolja meg, a következő i gyümölcsöket ingyen kaphatja meg.

Ne feledje, hogy még ha ingyenesen is elviheti a gyümölcsöt, akkor is megvásárolhatja [j] érmékért, hogy új ajánlatot kapjon.
Adja vissza az összes gyümölcs megszerzéséhez szükséges minimális számú érmét.

1. példa:

Bemenet: prices = [3,1,2]
Kimenet: 4
Magyarázat: A gyümölcsöket a következőképpen szerezheti be:
- Vásárolja meg az 1. gyümölcsöt 3 érmével, a 2. gyümölcsöt ingyen viheti.
- Vásárolja meg a 2. gyümölcsöt 1 érmével, a 3. gyümölcsöt ingyen viheti.
- Vigye ingyen a 3. gyümölcsöt.
Ne feledje, hogy bár a 2. gyümölcsöt ingyen elvihette, azért vásárolta meg, mert az optimálisabb.
Bizonyítható, hogy az összes gyümölcs megszerzéséhez szükséges minimális érmék száma 4.

2. példa:

Bemenet: prices= [1,10,1,1]
Kimenet: 2
Magyarázat: A gyümölcsöket a következőképpen szerezheti be:
- Vásárolja meg az 1. gyümölcsöt 1 érmével, a 2. gyümölcsöt ingyen viheti.
- a 2. gyümölcsöt vigye ingyen.
- Vásárolja meg a 3. gyümölcsöt 1 érméért, a 4. gyümölcsöt ingyen viheti.
- Vigye ingyen a 4. gyümölcsöt.
Bizonyítható, hogy az összes gyümölcs megszerzéséhez szükséges minimális érmék száma 2.

Korlátozások:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

Egy gyümölcspiacon vagy, ahol különböző egzotikus gyümölcsök vannak kiállítva.
Adott egy 1-indexált árak tömb, ahol az árak[i] az i^-edik gyümölcs megvásárlásához szükséges érmék számát jelöli.
A gyümölcspiac a következő kínálattal rendelkezik:

Ha megvásárolod az i^-edik gyümölcsöt prices[i] érméért, akkor a következő i gyümölcsöt ingyen kapod.

Megjegyezzük, hogy ha a j gyümölcsöt ingyen veheted is el, akkor is megvásárolhatod azt prices[j] érmékért, hogy újabb ajánlatot kapj.
Adja vissza az összes gyümölcs megszerzéséhez szükséges minimális érmeszámot.

Példa 1:

Input: prices = [3,1,2]
Kimenet: 4
Magyarázat: A gyümölcsöket a következőképpen szerezhetjük be:
- Vásárolja meg az 1^st gyümölcsöt 3 érmével, a 2^st gyümölcsöt ingyen veheti el.
- Vásárolja meg a 2^. gyümölcsöt 1 érmével, a 3^. gyümölcsöt ingyen veheti el.
- A 3^. gyümölcsöt ingyen veheti el.
Vedd figyelembe, hogy bár a 2^. gyümölcsöt ingyen elvihetted volna, mégis megvetted, mert az optimálisabb.
Bebizonyítható, hogy 4 a minimálisan szükséges érmék száma az összes gyümölcs megszerzéséhez.

2. példa:

Bemenet: prices = [1,10,1,1]
Kimenet: 2
Magyarázat: A gyümölcsöket a következőképpen szerezhetjük be:
- Vásárolja meg az 1^st gyümölcsöt 1 érmével, a 2^st gyümölcsöt ingyen veheti el.
- A 2^. gyümölcsöt ingyen veheted el.
- Vásárolja meg a 3^. gyümölcsöt 1 érméért, a 4^. gyümölcsöt ingyen elviheti.
- Vegye el a 4^t^h gyümölcsöt ingyen.
Bizonyítható, hogy 2 a minimálisan szükséges érmék száma az összes gyümölcs megszerzéséhez.

Korlátozások:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5


Adott egy s karakterlánc és egy pozitív egész szám k.
Legyen a magánhangzók és mássalhangzók száma a karakterláncban.
Egy karakterlánc akkor szép, ha:

magánhangzók == mássalhangzók.
(magánhangzók * mássalhangzók) % k == 0, vagyis a magánhangzók és mássalhangzók szorzata osztható k-val.

Visszaadja a nem üres szép részláncok számát az adott s karakterláncban.
A részlánc a karakterek összefüggő sorozata egy karakterláncban.
Az angolban a magánhangzó betűi az 'a', 'e', 'i', 'o' és 'u'.
A mássalhangzó betűk az angolban minden betű, kivéve a magánhangzókat.

1. példa:

Bemenet:s = "baeyh", k = 2
Kimenet: 2
Magyarázat: A megadott karakterláncban 2 szép részlánc van.
-"baeyh" részlánc, magánhangzók = 2 (["a",e"]), mássalhangzók = 2 (["y","h"]).
Láthatjuk, hogy az "aeyh" karakterlánc szép, mivel magánhangzók == mássalhangzók és magánhangzók * mássalhangzók % k == 0.
-"baeyh" részlánc, magánhangzók = 2 (["a",e"]), mássalhangzók = 2 (["b","y"]).
Láthatjuk, hogy a "baey" karakterlánc szép, mivel magánhangzók == mássalhangzók és magánhangzók * mássalhangzók % k == 0.
Megmutatható, hogy az adott karakterláncban csak 2 szép részlánc van.

2. példa:

Bemenet:s = "abba", k = 1
Kimenet: 3
Magyarázat: A megadott karakterláncban 3 szép részlánc van.
- "abba" részlánc,magánhangzók = 1 (["a"]), mássalhangzók = 1 (["b"]).
- "abba" részlánc, magánhangzók = 1 (["a"]), mássalhangzók = 1 (["b"]).
- "abba" részlánc, magánhangzók = 2 (["a","a"]), mássalhangzók = 2 (["b","b"]).
Kimutatható, hogy az adott karakterláncban csak 3 szép részlánc van.

3. példa:

Bemenet: s = "bcdf", k = 1
Kimenet: 0
Magyarázat: A megadott karakterláncban nincsenek szép részláncok.

Korlátozások:

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

Kapsz egy s karakterláncot és egy k pozitív egész számot.
Legyen a magánhangzók és mássalhangzók egy karakterlánc magán- és mássalhangzóinak száma.
Egy húr akkor szép, ha:

magánhangzók == mássalhangzók.
(magánhangzók * mássalhangzók) % k == 0, más értelemben a magánhangzók és mássalhangzók szorzata osztható k-val.

Visszaadja a nem üres szép részkarakterláncok számát az adott karakterláncban s.
A részkarakterlánc egy karakterláncban összefüggő karaktersorozat.
A magánhangzók angol betűi az „a”, „e”, „i”, „o” és „u”.
Az angolban a mássalhangzó betűk a magánhangzók kivételével minden betű.

1. példa:

Bemenet: s = "baeyh", k = 2
Kimenet: 2
Magyarázat: Az adott karakterláncban 2 gyönyörű részkarakterlánc található.
- "baeyh" részkarakterlánc, magánhangzók = 2 (["a", e"]), mássalhangzók = 2 (["y", "h"]).
Láthatjuk, hogy az "aeyh" karakterlánc gyönyörű magánhangzóként == mássalhangzók és magánhangzók * mássalhangzók % k == 0.
- "baeyh" részkarakterlánc, magánhangzók = 2 (["a", e"]), mássalhangzók = 2 (["b", "y"]).
Láthatjuk, hogy a "baey" karakterlánc gyönyörű magánhangzóként == mássalhangzók és magánhangzók * mássalhangzók % k == 0.
Megmutatható, hogy az adott karakterláncban csak 2 gyönyörű részkarakterlánc van.

2. példa:

Bemenet: s = "abba", k = 1
Kimenet: 3
Magyarázat: Az adott karakterláncban 3 gyönyörű részkarakterlánc található.
- "abba" részkarakterlánc, magánhangzók = 1 (["a"]), mássalhangzók = 1 (["b"]).
- "abba" részkarakterlánc, magánhangzók = 1 (["a"]), mássalhangzók = 1 (["b"]).
- "abba" részkarakterlánc, magánhangzók = 2 (["a", "a"]), mássalhangzók = 2 (["b", "b"]).
Megmutatható, hogy az adott karakterláncban csak 3 gyönyörű részkarakterlánc található.

3. példa:

Bemenet: s = "bcdf", k = 1
Kimenet: 0
Magyarázat: Az adott karakterláncban nincsenek gyönyörű részkarakterláncok.

Korlátozások:

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

Adott egy s string és egy pozitív egész szám k.
Legyen magánhangzók és mássalhangzók a magánhangzók és mássalhangzók száma egy stringben.
Egy string szép, ha:

magánhangzók == mássalhangzók.
(magánhangzók * mássalhangzók) % k == 0, más szavakkal a magánhangzók és mássalhangzók szorzata osztható k-val.

Add vissza a nem üres szép részstringek számát az adott s stringben.
Egy részstring egy összefüggő karakterek sorozata egy stringben.
Az angol nyelvben a magánhangzó betűk: 'a', 'e', 'i', 'o', és 'u'.
Az angol nyelvben a mássalhangzó betűk minden mást jelentenek, mint a magánhangzók.

1. példa:

Input: s = "baeyh", k = 2
Output: 2
Magyarázat: 2 szép részstring van az adott stringben.
- Részstring "baeyh", magánhangzók = 2 (["a",e"]), mássalhangzók = 2 (["y","h"]).
Látható, hogy a "aeyh" string szép, mivel magánhangzók == mássalhangzók és magánhangzók * mássalhangzók % k == 0.
- Részstring "baeyh", magánhangzók = 2 (["a",e"]), mássalhangzók = 2 (["b","y"]).
Látható, hogy a "baey" string szép, mivel magánhangzók == mássalhangzók és magánhangzók * mássalhangzók % k == 0.
Megmutatható, hogy csak 2 szép részstring van az adott stringben.

2. példa:

Input: s = "abba", k = 1
Output: 3
Magyarázat: 3 szép részstring van az adott stringben.
- Részstring "abba", magánhangzók = 1 (["a"]), mássalhangzók = 1 (["b"]).
- Részstring "abba", magánhangzók = 1 (["a"]), mássalhangzók = 1 (["b"]).
- Részstring "abba", magánhangzók = 2 (["a","a"]), mássalhangzók = 2 (["b","b"]).
Megmutatható, hogy csak 3 szép részstring van az adott stringben.

3. példa:

Input: s = "bcdf", k = 1
Output: 0
Magyarázat: Nincsenek szép részstringek az adott stringben.

Feltételek:

1 <= s.length <= 1000
1 <= k <= 1000
s csak angol kisbetűket tartalmaz.


Adott egy 0-indexált egész számtömb nums.
Tetszőleges számú műveletet végezhetünk, ahol minden művelet során kiválasztjuk a tömb egy altömbjét, és kicseréljük annak elemeinek összegével. Ha például az adott tömb [1,3,5,6], és kiválasztjuk a [3,5] altömböt, akkor a tömb [1,8,6]-ra fog átalakulni.
Visszaadja egy nem csökkenő tömb maximális hosszát, amely a műveletek alkalmazása után kialakítható.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

Példa 1:

Bemenet: nums = [5,2,2]
Kimenet: 1
Magyarázat: Ez a 3 hosszúságú tömb nem monoton növekvő.
Két lehetőségünk van arra, hogy a tömb hossza kettő legyen.
Először is, a [2,2] altömböt választva a tömböt [5,4]-re alakítjuk át.
Másodszor, ha az [5,2] altömböt választjuk, a tömböt [7,2]-re alakítjuk át.
E két módon a tömb nem monoton növekvő.
Ha pedig az [5,2,2] altömböt választjuk, és kicseréljük [9]-re, akkor nem csökkenő lesz.
A válasz tehát 1.

Példa 2:

Input: nums = [1,2,3,4].
Kimenet: 4
Magyarázat: A tömb nem csökkenő. A válasz tehát 4.

Példa 3:

Bemenet: nums = [4,3,2,6]
Kimenet: 3
Magyarázat: Ha a [3,2]-t [5]-re cseréljük, akkor a megadott tömböt [4,5,6]-ra alakítjuk, ami nem csökkenő.
Mivel az adott tömb nem monoton növekvő, a maximálisan lehetséges válasz 3.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot.
Bármilyen számú műveletet végrehajthat, ahol minden művelet magában foglalja a tömb egy altömbjének kiválasztását, és annak elemeinek összegével való helyettesítését. Például, ha az adott tömb [1,3,5,6], és a [3,5] altömböt választja, a tömb [1,8,6]-ra konvertálódik.
Egy nem csökkenő tömb maximális hosszát adja vissza, amely a műveletek alkalmazása után elkészíthető.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [5,2,2]
Kimenet: 1
Magyarázat: Ez a 3-as hosszúságú tömb nem nem csökkenő.
Kétféleképpen tudjuk a tömb hosszát ketté tenni.
Először is, a [2,2] altömb kiválasztása a tömböt [5,4]-re alakítja.
Másodszor, az [5,2] altömb kiválasztása a tömböt [7,2]-re alakítja.
Ezen a két módon a tömb nem nem csökkenő.
És ha az [5,2,2] alsort választjuk, és lecseréljük a [9]-re, akkor nem csökken.
Tehát a válasz 1.

2. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 4
Magyarázat: A tömb nem csökkenő. Tehát a válasz 4.

3. példa:

Bemenet: nums = [4,3,2,6]
Kimenet: 3
Magyarázat: A [3,2] helyére [5]-re cserélve az adott tömböt [4,5,6]-ra alakítja, ami nem csökken.
Mivel az adott tömb nem nem-csökkenő, ezért a maximális válasz a 3.

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb számot.
Bármilyen számú műveletet végrehajthat, ahol minden művelet magában foglalja a tömb egy altömbjének kiválasztását, és annak elemeinek összegével való helyettesítését. Például, ha az adott tömb [1,3,5,6], és a [3,5] altömböt választja, a tömb [1,8,6]-ra konvertálódik.
A műveletek alkalmazása után elkészíthető nem csökkenő tömb maximális hosszát adja vissza.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [5,2,2]
Kimenet: 1
Magyarázat: Ez a 3-as hosszúságú tömb nem csökkenő.
Két módon tudjuk csökkenteni a tömb hosszát 2-re.
Először is, a [2,2] altömb kiválasztása a tömböt [5,4]-re alakítja.
Másodszor, az [5,2] altömb kiválasztása a tömböt [7,2]-re alakítja.
Ezen a két módon a tömb nem csökkenő.
És ha az [5,2,2] alsort választjuk, és lecseréljük a [9]-re, akkor a tömb nem csökkenő lesz.
Tehát a válasz 1.

2. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 4
Magyarázat: A tömb nem csökkenő. Tehát a válasz 4.

3. példa:

Bemenet: nums = [4,3,2,6]
Kimenet: 3
Magyarázat: A [3,2] helyére [5]-re cserélve az adott tömböt [4,5,6]-ra alakítja, ami nem csökken.
Mivel az adott tömb nem nem-csökkenő, ezért a maximális válasz a 3.

Korlátozások:

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


Kapunk egy 0-indexelt tömböt, amely pozitív egész számokból áll.
Egy tömb partícióját akkor nevezzük jónak, ha egy vagy több összefüggő résztömbből áll, és nincs két résztömb, amely ugyanazt a számot tartalmaz.
Adjuk vissza a jó partíciók teljes számát.
Mivel a válasz nagy lehet, adjuk vissza a eredményt modulo 10^9 + 7.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 8
Magyarázat: A 8 lehetséges jó partíció a következő: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]) és ([1,2,3,4]).

2. példa:

Bemenet: nums = [1,1,1,1]
Kimenet: 1
Magyarázat: Az egyetlen lehetséges jó partíció: ([1,1,1,1]).

3. példa:

Bemenet: nums = [1,2,1,3]
Kimenet: 2
Magyarázat: A 2 lehetséges jó partíció: ([1,2,1], [3]) és ([1,2,1,3]).

Korlátok:

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

Kapsz egy 0-indexelt tömbszámot, amely pozitív egész számokból áll.
Egy tömb egy vagy több összefüggő altömbre történő felosztását jónak nevezzük, ha nincs két altömb azonos számmal.
A számokból álló jó partíciók teljes számát adja vissza.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.

példa 1:

Bemenet: nums = [1,2,3,4]
Kimenet: 8
Magyarázat: A 8 lehetséges jó partíció: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2) ,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4 ]), ([1,2,3], [4]), és ([1,2,3,4]).

példa 2:

Bemenet: nums = [1,1,1,1]
Kimenet: 1
Magyarázat: Az egyetlen lehetséges jó partíció: ([1,1,1,1]).

példa 3:

Bemenet: nums = [1,2,1,3]
Kimenet: 2
Magyarázat: A 2 lehetséges jó partíció a következő: ([1,2,1], [3]) és ([1,2,1,3]).

Korlátozások:

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

Kapsz egy 0-indexelt tömb számokat, amelyek pozitív egész számokból állnak.
Egy tömb egy vagy több összefüggő altömbre történő felosztását jónak nevezzük, ha nincs két altömb azonos számmal.
A számokból álló jó partíciók teljes számát adja vissza.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.

1. példa:

Bemenet: nums = [1,2,3,4]
Kimenet: 8
Magyarázat: A 8 lehetséges jó partíció: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2) ,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4 ]), ([1,2,3], [4]) és ([1,2,3,4]).

2. példa:

Bemenet: nums = [1,1,1,1]
Kimenet: 1
Magyarázat: Az egyetlen lehetséges jó partíció: ([1,1,1,1]).

3. példa:

Bemenet: nums = [1,2,1,3]
Kimenet: 2
Magyarázat: A 2 lehetséges jó partíció a következő: ([1,2,1], [3]) és ([1,2,1,3]).

Korlátozások:

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


Adott egy egész szám tömb nums és egy pozitív egész szám k.
Adja vissza azon altömbök számát, amelyekben a nums maximális eleme legalább k-szor szerepel az adott altömbben.
Az altömb egy tömbön belüli elemek összefüggő sorozata.

1. példa:

bemenet: nums = [1,3,2,3,3], k = 2
Kimenet: 6
Magyarázat: A 3 elemet legalább 2-szer tartalmazó altáblák a következők: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] és [3,3].

2. példa:

Bemenet: nums = [1,4,2,1], k = 3
Kimenet: 0
Magyarázat: Egyetlen altömb sem tartalmazza legalább 3-szor a 4-es elemet.

Korlátozások:

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

Kapsz egy egész számok tömbje és egy pozitív egész számot k .
Azon résztömbök számát adja eredményül, ahol a numok maximális eleme legalább k alkalommal megjelenik az adott résztömbben.
A résztömb elemek összefüggő sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [1,3,2,3,3], k = 2
Kimenet: 6
Magyarázat: A 3 elemet legalább 2-szer tartalmazó résztömbök a következők: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] és [3,3].

2. példa:

Bemenet: nums = [1,4,2,1], k = 3
Kimenet: 0
Magyarázat: Egyetlen altömb sem tartalmazza legalább 3-szor a 4 elemet.

Korlátok:

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

Adott egy egész számokból álló tömb, a neve nums, és egy pozitív egész szám, k.
Add vissza azon részlisták számát, ahol a nums legnagyobb eleme legalább k alkalommal jelenik meg abban a részlistában.
Egy részlista az elemek egy összefüggő sorozata egy tömbön belül.

Példa 1:

Bemenet: nums = [1,3,2,3,3], k = 2
Kimenet: 6
Magyarázat: Azok a részlisták, amelyek tartalmazzák az elemet 3 legalább 2-szer: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] és [3,3].

Példa 2:

Bemenet: nums = [1,4,2,1], k = 3
Kimenet: 0
Magyarázat: Egyik részlista sem tartalmazza az elemet 4 legalább 3-szor.

Korlátozások:

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


Adott egy 0 indexű, pozitív egész számokból álló nums tömb és egy pozitív egész szám határérték.
Egyetlen műveletben választhatunk két tetszőleges i és j indexet, és felcserélhetjük nums[i] és nums[j] értékeit, ha |nums[i] - nums[j]| <= limit.
Visszaadja a lexikográfiailag legkisebb tömböt, amely a művelet tetszőleges számú elvégzésével elérhető.
Egy a tömb lexikográfiailag kisebb, mint egy b tömb, ha az a és b tömb első olyan pozíciójában, ahol a és b különbözik, az a tömbnek van egy olyan eleme, amely kisebb, mint a b megfelelő eleme. Például a [2,10,3] tömb lexikográfiailag kisebb, mint a [10,2,3] tömb, mert 0 indexnél és 2 < 10-nél különböznek.

Példa 1:

Bemenet:nums = [1,5,3,9,8], limit = 2
Kimenet: [1,3,5,8,9]
Magyarázat: A műveletet 2-szer alkalmazzuk:
- Cserélje fel a nums[1]-t a nums[2]-vel. A tömb [1,3,5,9,8] lesz.
- Cseréljük fel a nums[3]-t a nums[4]-gyel. A tömb [1,3,5,8,9] lesz.
Több művelettel nem kaphatunk lexikográfiailag kisebb tömböt.
Megjegyezzük, hogy előfordulhat, hogy különböző műveletekkel ugyanazt az eredményt kapjuk.

2. példa:

Bemenet:nums = [1,7,6,18,2,1], limit = 3
Kimenet: [1,6,7,18,1,2]
Magyarázat: A műveletet 3-szor alkalmazzuk:
- Cserélje fel a nums[1]-t a nums[2]-vel. A tömb [1,6,7,18,2,1] lesz.
- Cseréljük fel a nums[0]-t a nums[4]-gyel. A tömb [2,6,7,18,1,1] lesz.
- Cseréljük ki a nums[0]-t a nums[5]-re. A tömb [1,6,7,18,1,2] lesz.
Több művelettel nem kaphatunk lexikográfiailag kisebb tömböt.

3. példa:

Bemenet: nums = [1,7,28,19,10], limit = 3
Kimenet: [1,7,28,19,10]
Magyarázat: Az [1,7,28,19,10] a lexikográfiailag legkisebb tömb, amit kaphatunk, mert a műveletet nem tudjuk alkalmazni két indexen.

Korlátozások:

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

Kapsz egy 0-indexelt pozitív egész számokból álló tömböt és egy pozitív egész számkorlátot.
Egy műveletben választhat két i és j indexet, és felcserélheti a számokat[i] és a nums[j], ha |nums[i] - nums[j]| <= limit.
Adja vissza a lexikográfiailag legkisebb tömböt, amely a művelet tetszőleges számú végrehajtásával elérhető.
Egy a tömb lexikográfiailag kisebb, mint egy b tömb, ha az első helyen, ahol a és b különbözik, az a tömbnek olyan eleme van, amely kisebb, mint a b tömb megfelelő eleme. Például a [2,10,3] tömb lexikográfiailag kisebb, mint a [10,2,3] tömb, mert 0 és 2 < 10 indexnél különböznek.

1. példa:

Bemenet: nums = [1,5,3,9,8], limit = 2
Kimenet: [1,3,5,8,9]
Magyarázat: Alkalmazza a műveletet kétszer:
- Cserélje fel a nums[1] a nums[2]. A tömb értéke [1,3,5,9,8]
- Cserélje fel a nums[3] a nums[4]. A tömb értéke [1,3,5,8,9]
Lexikográfiailag kisebb tömböt nem kaphatunk több művelet alkalmazásával.
Vegye figyelembe, hogy különböző műveletekkel ugyanazt az eredményt lehet elérni.

2. példa:

Bemenet: nums = [1,7,6,18,2,1], limit = 3
Kimenet: [1,6,7,18,1,2]
Magyarázat: Alkalmazza a műveletet háromszor:
- Cserélje fel a nums[1] a nums[2]. A tömb értéke [1,6,7,18,2,1]
- Cserélje fel a nums[0] a nums[4]. A tömb a következő lesz: [2,6,7,18,1,1]
- Cserélje fel a nums[0] a nums[5]. A tömb a következő lesz: [1,6,7,18,1,2]
Lexikográfiailag kisebb tömböt nem kaphatunk több művelet alkalmazásával.

3. példa:

Bemenet: nums = [1,7,28,19,10],  limit  = 3
Kimenet: [1,7,28,19,10]
Magyarázat: [1,7,28,19,10] a lexikográfiailag legkisebb tömb, amelyet megkaphatunk, mert nem tudjuk alkalmazni a műveletet két indexre sem.

Korlátozások:

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

Kapsz egy 0-indexelt pozitív egész számokból álló tömböt és egy pozitív egész számkorlátot.
Egy műveletben választhat két i és j indexet, és felcserélheti a számokat[i] és a számokat[j], ha |számok[i] - számok[j]| <= limit.
Adja vissza a lexikográfiailag legkisebb tömböt, amely a művelet tetszőleges számú végrehajtásával elérhető.
Egy a tömb lexikográfiailag kisebb, mint egy b tömb, ha az első helyen, ahol a és b különbözik, az a tömbnek olyan eleme van, amely kisebb, mint a b tömb megfelelő eleme. Például a [2,10,3] tömb lexikográfiailag kisebb, mint a [10,2,3] tömb, mert 0 és 2 < 10 indexnél különböznek.

1. példa:

Bemenet: nums = [1,5,3,9,8], limit = 2
Kimenet: [1,3,5,8,9]
Magyarázat: Alkalmazza a műveletet kétszer:
- Cserélje fel a számokat[1] a számokkal[2]. A tömb értéke [1,3,5,9,8]
- Cserélje fel a számokat[3] a számokkal[4]. A tömb értéke [1,3,5,8,9]
Lexikográfiailag kisebb tömböt nem kaphatunk több művelet alkalmazásával.
Vegye figyelembe, hogy különböző műveletekkel ugyanazt az eredményt lehet elérni.

2. példa:

Bemenet: nums = [1,7,6,18,2,1], limit = 3
Kimenet: [1,6,7,18,1,2]
Magyarázat: Alkalmazza a műveletet háromszor:
- Cserélje fel a számokat[1] a számokkal[2]. A tömb a következő lesz: [1,6,7,18,2,1]
- Cserélje fel a számokat[0] a számokkal[4]. A tömb a következő lesz: [2,6,7,18,1,1]
- Cserélje fel a számokat[0] a számokkal[5]. A tömb értéke [1,6,7,18,1,2]
Lexikográfiailag kisebb tömböt nem kaphatunk több művelet alkalmazásával.

3. példa:

Bemenet: nums = [1,7,28,19,10], limit = 3
Kimenet: [1,7,28,19,10]
Magyarázat: [1,7,28,19,10] a lexikográfiailag legkisebb tömb, amelyet megkaphatunk, mert nem tudjuk alkalmazni a műveletet két indexre sem.

Korlátozások:

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


Adott egy 0-indexelt egész szám tömb batteryPercentages, amely hossza n, és az n darab, 0-indexelt eszköz akkumulátorának százalékos arányát jelöli.
Az Ön feladata minden i eszköz tesztelése 0-tól n-1-ig, a következő tesztműveletek végrehajtásával:

Ha batteryPercentages[i] nagyobb, mint 0:

Növelje a tesztelt eszközök számát.
Csökkentse 1-gyel az [i + 1, n - 1] tartományba eső j indexű eszközök akkumulátorának százalékos arányát, biztosítva, hogy az akkumulátor százalékos aránya soha ne csökkenjen 0 alá, azaz az akkumulátor azaz batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Ugrás a következő eszközre.

Ellenkező esetben teszt elvégzése nélkül lépjen a következő eszközre.

Egy egész számot ad vissza, amely a tesztelni kívánt eszközök számát jelöli a tesztműveletek sorrendjének végrehajtása után.

Példa 1:

Bemenet: batteryPercentages = [1,1,2,1,3]
Kimenet: 3
Magyarázat: A tesztműveletek végrehajtása sorrendben a 0. eszköztől kezdve:
A 0. eszköznél, batteryPercentages[0] > 0, tehát van most 1 tesztelt eszköz, és a batteryPercentages így változik: [1,0,1,0,2].
Az 1. eszköznél, batteryPercentages[1] == 0, tehát továbblépünk a következő eszközre tesztelés nélkül.
A 2. eszköznél, batteryPercentages[2] > 0, tehát van most 2 tesztelt eszköz, és a batteryPercentages így változik: [1,0,1,0,1].
A 3. eszköznél, batteryPercentages[3] == 0, tehát továbblépünk a következő eszközre tesztelés nélkül.
A 4. eszköznél, batteryPercentages[4] > 0, tehát van most 3 tesztelt eszköz, és a batteryPercentages változatlan marad.
Tehát a válasz: 3.

Példa 2:

Bemenet: batteryPercentages = [0,1,2]
Kimenet: 2
Magyarázat: A tesztműveletek végrehajtása sorrendben a 0. eszköztől kezdve:
A 0. eszköznél, batteryPercentages[0] == 0, tehát továbblépünk a következő eszközre tesztelés nélkül.
Az 1. eszköznél, batteryPercentages[1] > 0, tehát van most 1 tesztelt eszköz, és a batteryPercentages így változik: [0,1,1].
A 2. eszköznél, batteryPercentages[2] > 0, tehát van most 2 tesztelt eszköz, és a batteryPercentages változatlan marad.
Tehát a válasz: 2.

Korlátozások:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

Adott egy n hosszúságú, 0 indexű egész számtömb batteryPercentages, amely az n 0 indexű eszköz akkumulátorának százalékos arányát jelöli.
A feladatunk az, hogy minden i eszközt 0-tól n-1-ig terjedő sorrendben teszteljünk a következő tesztműveletek elvégzésével:

Ha az batteryPercentages[i] értéke nagyobb, mint 0:

Növeljük a tesztelt eszközök számát.
Csökkentse az [i + 1, n - 1] tartományban lévő j indexű eszközök akkumulátorának százalékos értékét 1-gyel, biztosítva, hogy az akkumulátoruk százalékos értéke soha ne menjen 0 alá, azaz batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Lépjünk a következő eszközre.

Ellenkező esetben lépjünk a következő eszközre anélkül, hogy bármilyen tesztet végeznénk.

Visszaad egy egész számot, amely a tesztműveletek sorrendben történő elvégzése után tesztelt eszközök számát jelöli.

Példa 1:

bemenet: batteryPercentages = [1,1,2,1,3]
Kimenet: 3
Magyarázat: A tesztműveletek végrehajtása a 0. eszközzel kezdődő sorrendben:
A 0. eszköznél az batteryPercentages[0] > 0, tehát most 1 tesztelt eszköz van, és az batteryPercentages [1,0,1,0,2] lesz.
Az 1. eszköznél a batteryPercentages[1] == 0, tehát tesztelés nélkül lépünk a következő eszközre.
A 2. eszköznél a batteryPercentages[2] > 0, tehát már 2 tesztelt eszköz van, és a batteryPercentages értéke [1,0,1,1,0,1] lesz.
A 3. eszköznél a batteryPercentages[3] == 0, tehát tesztelés nélkül lépünk a következő eszközre.
A 4. eszköznél a batteryPercentages[4] > 0, így már 3 tesztelt eszköz van, és a batteryPercentages nem változik.
A válasz tehát 3.

2. példa:

bemenet: batteryPercentages = [0,1,2]
Kimenet: 2
Magyarázat: A tesztműveletek végrehajtása a 0. eszközzel kezdődő sorrendben:
A 0. eszköznél az batteryPercentages[0] == 0, így tesztelés nélkül lépünk a következő eszközre.
Az 1. eszköznél a batteryPercentages[1] > 0, tehát már 1 tesztelt eszköz van, és a batteryPercentages [0,1,1] lesz.
A 2. eszköznél a batteryPercentages[2] > 0, így most már 2 tesztelt eszköz van, és a batteryPercentages nem változik.
A válasz tehát 2.

Korlátozások:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

Kapunk egy 0 indexű egész szám tömböt, amely n hosszúságú akkumulátor százalékaokat jelöl, amelyek n 0 indexű eszköz akkumulátorának batteryPercentages jelölik.
Az Ön feladata minden i eszköz tesztelése 0-tól n-1-ig, a következő tesztműveletek végrehajtásával:

Ha az akkumulátor batteryPercentages[i] nagyobb, mint 0:

Növelje a tesztelt eszközök számát egyel
Csökkentse 1-gyel az [i + 1, n - 1] tartományba eső j indexű eszközök akkumulátorának batteryPercentage, biztosítva, hogy az akkumulátor akkumulátor százaléka soha ne csökkenjen 0 alá, azaz az batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Ugrás a következő eszközre.

Ellenkező esetben teszt elvégzése nélkül lépjen a következő eszközre.

Egy egész számot ad vissza, amely a tesztelni kívánt eszközök számát jelöli a tesztműveletek sorrendjének végrehajtása után.

1. példa:

Bemenet: batteryPercentages  = [1,1,2,1,3]
Kimenet: 3
Magyarázat: A tesztműveletek végrehajtása sorrendben a 0. eszköztől kezdve:
A 0 eszköznél az batteryPercentages[0] > 0, tehát 1 tesztelt eszköz van, és az batteryPercentages értéke [1,0,1,0,2] lesz.
Az 1. eszköznél az batteryPercentages[1] == 0, tehát tesztelés nélkül lépünk a következő eszközre.
A 2. eszköznél az batteryPercentages[2] > 0, tehát 2 tesztelt eszköz van, és az batteryPercentages értéke [1,0,1,0,1] lesz.
A 3. eszköznél az batteryPercentages[3] == 0, tehát tesztelés nélkül lépünk a következő eszközre.
A 4. eszköznél az batteryPercentages[4] > 0, tehát 3 tesztelt eszköz van, és az akkumulátor százalékos értéke változatlan marad.
Tehát a válasz: 3.

2. példa:

Bemenet: batteryPercentages = [0,1,2]
Kimenet: 2
Magyarázat: A tesztműveletek végrehajtása sorrendben a 0. eszköztől kezdve:
A 0 eszköznél az batteryPercentages[0] == 0, tehát tesztelés nélkül lépünk a következő eszközre.
Az 1. eszköznél a batteryPercentages[1] > 0, tehát most 1 tesztelt eszköz van, és az akkumulátor százalékos értéke [0,1,1] lesz.
A 2. eszköznél az batteryPercentages[2] > 0, tehát 2 tesztelt eszköz van, és az akkumulátor százalékos értéke változatlan marad.
Tehát a válasz: 2.

Korlátozások:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100


Egy 0-indexelt tömböt kapunk, hegy néven. A feladatod, hogy megtaláld az összes csúcsot a hegy tömbben. Adj vissza egy tömböt, amely a csúcsok indexeit tartalmazza tetszőleges sorrendben.
Megjegyzések:

Egy csúcs olyan elem, amely szigorúan nagyobb, mint a szomszédos elemei.
A tömb első és utolsó elemei nem lehetnek csúcsok.

Példa 1:

Bemenet: mountain = [2,4,4]
Kimenet: []
Magyarázat: mountain[0] és mountain[2] nem lehet csúcs, mert ezek a tömb első és utolsó elemei.
mountain[1] sem lehet csúcs, mert nem szigorúan nagyobb, mint mountain[2].
Tehát a válasz [].

Példa 2:

Bemenet: mountain = [1,4,3,8,5]
Kimenet: [1,3]
Magyarázat: mountain[0] és mountain[4] nem lehetnek csúcsok, mert ezek a tömb első és utolsó elemei.
mountain[2] sem lehet csúcs, mert nem szigorúan nagyobb, mint mountain[3] és mountain[1].
De mountain[1] és mountain[3] szigorúan nagyobbak a szomszédos elemeiknél.
Tehát a válasz [1,3].

Korlátozások:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Kapsz egy 0 indexű hegytömb. Az Ön feladata, hogy megtalálja az összes csúcsot a hegytömbben.
Olyan tömböt ad vissza, amely az adott tömb csúcsainak indexeiből áll, tetszőleges sorrendben.
Megjegyzések:

A csúcs olyan elem, amely szigorúan nagyobb, mint a szomszédos elemei.
A tömb első és utolsó eleme nem csúcs.

1. példa:

Bemenet: mountain  = [2,4,4]
Kimenet: []
Magyarázat: "mountain[0] és "mountain[2] nem lehet csúcs, mert ezek a tömb első és utolsó elemei.
"mountain[1] szintén nem lehet csúcs, mert nem szigorúan nagyobb, mint a "mountain[2].
Tehát a válasz: [].

2. példa:

Bemenet: mountain = [1,4,3,8,5]
Kimenet: [1,3]
Magyarázat: "mountain[0] és "mountain[4] nem lehet csúcs, mert ezek a tömb első és utolsó elemei.
"mountain[2] szintén nem lehet csúcs, mert nem szigorúan nagyobb a hegynél[3] és a hegynél[1].
De a "mountain [1] és a "mountain [3] szigorúan nagyobb, mint a szomszédos elemei.
Tehát a válasz: [1,3].

Korlátozások:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Kapsz egy 0-indexelt tömbhegyet. Az Ön feladata, hogy megtalálja a hegyi tömb összes csúcsát.
Olyan tömböt ad vissza, amely az adott tömb csúcsainak indexeiből áll, bármilyen sorrendben.
Notes:

A csúcs olyan elem, amely szigorúan nagyobb, mint a szomszédos elemek.
A tömb első és utolsó eleme nem csúcs.

1. példa:

Bemenet: mountain = [2,4,4]
Kimenet: []
Magyarázat: mountain[0] és mountain[2] nem lehet csúcs, mert ezek a tömb első és utolsó elemei.
mountain[1] szintén nem lehet csúcs, mert nem szigorúan nagyobb, mint mountain[2].
Tehát a válasz [].

2. példa:

Bemenet: mountain = [1,4,3,8,5]
Kimenet: [1,3]
Magyarázat: mountain[0] és mountain[4] nem lehet csúcs, mert ezek a tömb első és utolsó elemei.
mountain[2] szintén nem lehet csúcs, mert nem szigorúan nagyobb, mint mountain[3] és mountain[1].
De mountain[1] és mountain[3] szigorúan nagyobbak, mint a szomszédos elemek.
Tehát a válasz [1,3].

Korlátok:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100


Adott egy string word és egy egész szám k.
A szó s részláncának egy részlánca teljes, ha:

Minden karakter az s-ben pontosan k alkalommal fordul elő.
Két szomszédos karakter közötti különbség legfeljebb 2. Vagyis az s-ben szereplő két szomszédos c1 és c2 karakter esetében az abszolút különbség az ábécében elfoglalt helyükben legfeljebb 2.

A szó teljes részsorozatainak számát adja vissza.
A részlánc egy karakterlánc nem üres, összefüggő karaktersorozata.

Példa 1:

Bemenet: word = "igigee", k = 2
Kimenet: 3
Magyarázat: A teljes részláncok, ahol minden karakter pontosan kétszer szerepel, és a szomszédos karakterek közötti különbség legfeljebb 2, a következők: igigee, igigee, igigee.

Példa 2:

Bemenet: word = "aaabbbccc", k = 3
Kimenet: 6
Magyarázat: Azok a teljes részláncok, amelyekben minden karakter pontosan háromszor fordul elő, és a szomszédos karakterek közötti különbség legfeljebb 2: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Korlátozások:

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

Egy word karakterláncot és egy egész k számot kapunk.
Egy s részkarakterlánc akkor teljes, ha:

Minden s karakter pontosan k-szer fordul elő.
Két szomszédos karakter közötti különbség legfeljebb 2. Vagyis bármely két szomszédos c1 és c2 karakter esetén s-ben az ábécében elfoglalt helyük abszolút különbsége legfeljebb 2.

Adja vissza a word teljes részkarakterláncainak számát.
Egy részkarakterlánc egy nem üres, folytonos karaktersorozat egy karakterláncban.

Példa 1:

Bemenet: word = "igigee", k = 2
Kimenet: 3
Magyarázat: A teljes részkarakterláncok, ahol minden karakter pontosan kétszer jelenik meg, és a szomszédos karakterek közötti különbség legfeljebb 2, a következők: igigee, igigee, igigee.

Példa 2:

Bemenet: word = "aaabbbccc", k = 3
Kimenet: 6
Magyarázat: A teljes részkarakterláncok, ahol minden karakter pontosan háromszor jelenik meg, és a szomszédos karakterek közötti különbség legfeljebb 2 lehet: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Korlátozások:

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

Kapsz egy karakterlánc szót és egy k egész számot.
A szó s részkarakterlánca akkor teljes, ha:

Minden s karakter pontosan k-szer fordul elő.
Két szomszédos karakter közötti különbség legfeljebb 2. Vagyis bármely két szomszédos c1 és c2 karakter esetén s-ben az ábécében elfoglalt helyük abszolút különbsége legfeljebb 2.

Visszaadja a szó teljes részkarakterláncainak számát.
A részkarakterlánc egy karakterlánc nem üres, összefüggő karaktersorozata.

1. példa:

Bemenet: word = "igigee", k = 2
Kimenet: 3
Magyarázat: A teljes részkarakterláncok, ahol minden karakter pontosan kétszer jelenik meg, és a szomszédos karakterek közötti különbség legfeljebb 2, a következők: igigee, igigee, igigee.

2. példa:

Bemenet: word = "aaabbbccc", k = 3
Kimenet: 6
Magyarázat: A teljes részkarakterláncok, ahol minden karakter pontosan háromszor jelenik meg, és a szomszédos karakterek közötti különbség legfeljebb 2 lehet: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Korlátozások:

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


Kapsz egy n egész számot és egy 0-indexelt egész tömböt, amelyek növekvő sorrendben vannak rendezve.
n gyermek áll a sorban a 0-tól n-1-ig rendelt pozíciókkal. A betegtömb a fertőző betegséggel fertőzött gyerekek pozícióit tartalmazza. Az i pozícióban lévő fertőzött átterjesztheti a betegséget az i - 1 és i + 1 pozíciókban lévő közvetlen szomszédos gyermekei közül, ha léteznek, és jelenleg nem fertőzöttek. Legfeljebb egy gyermek, aki korábban nem volt fertőzött, egy másodperc alatt megfertőződhet a betegséggel.
Kimutatható, hogy véges számú másodperc után a sorban álló összes gyerek megfertőződik a betegséggel. A fertőzési szekvencia azoknak a pozícióknak a sorrendje, amelyekben az összes nem fertőzött megfertőződik a betegséggel. Adja vissza a lehetséges fertőzési sorozatok teljes számát.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
Ne feledje, hogy a fertőzési szekvencia nem tartalmazza azoknak a gyermekeknek a pozícióit, akik már az elején megfertőződtek a betegséggel.

1. példa:

Bemenet: n = 5, sick = [0,4]
Kimenet: 4
Magyarázat: Az 1., 2. és 3. pozícióban lévő gyerekek kezdetben nem fertőzöttek. 4 lehetséges fertőzési szekvencia van:
- Az 1. és 3. pozícióban lévő gyerekek megfertőződhetnek, mivel az ő pozíciójuk szomszédos a fertőzött 0 és 4 gyermekekkel. Az 1. pozícióban lévő gyermek fertőződik meg először.
Most a 2. pozícióban lévő gyermek szomszédos az 1. pozícióban lévő gyermekkel, aki fertőzött, és a 3. pozícióban lévő gyermek szomszédos a 4. pozícióban lévő gyermekkel, aki fertőzött, így bármelyikük megfertőződhet. A 2. pozícióban lévő gyermek megfertőződik.
Végül a 3. pozícióban lévő gyermek megfertőződik, mivel szomszédos a 2. és 4. pozícióban lévő gyermekekkel, akik fertőzöttek. A fertőzés sorrendje [1,2,3].
- Az 1. és 3. pozícióban lévő gyermek megfertőződhetnek, mert pozíciójuk szomszédos a fertőzött 0. és 4. pozícióban lévőgyermekkel. Az 1. pozícióban lévő gyermek fertőződik meg először.
Most a 2. pozícióban lévő gyermek szomszédos az 1. pozícióban lévő gyermekkel, aki fertőzött, és a 3. pozícióban lévő gyermek szomszédos a 4. pozícióban lévő gyermekkel, aki fertőzött, így bármelyikük megfertőződhet. A 3. pozícióban lévő gyermek megfertőződik.
Végül a 2. pozícióban lévő gyermek megfertőződik, mert szomszédos az 1. és 3. pozícióban lévő gyermekekkel, akik fertőzöttek. A fertőzés sorrendje [1,3,2].
- A fertőzés sorrendje [3,1,2]. A gyermekek megbetegedésének sorrendje: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].
- A fertőzés sorrendje [3,2,1]. A gyermekek megbetegedésének sorrendje: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].

2. példa:

Bemenet: n = 4, sick  = [1]
Kimenet: 3
Magyarázat: A 0., 2. és 3. pozícióban lévő gyermek kezdetben nem fertőzöttek. Három lehetséges fertőzési szekvencia létezik:
- A fertőzés sorrendje [0,2,3]. A gyermekek megbetegedésének sorrendje: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- A fertőzés sorrendje [2,0,3]. A gyermekek megbetegedésének sorrendje: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- A fertőzés sorrendje [2,3,0]. A gyermekek megbetegedésének sorrendje: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].

Korlátozások:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick is sorted in increasing order.

Kapsz egy n egész számot és egy 0-indexelt egész tömböt, amelyek növekvő sorrendben vannak rendezve.
n gyermek áll a sorban a 0-tól n-1-ig rendelt pozíciókkal. A betegtömb a fertőző betegséggel fertőzött gyerekek pozícióit tartalmazza. Az i pozícióban lévő fertőzött gyermek átterjesztheti a betegséget az i - 1 és i + 1 pozíciókban lévő közvetlen szomszédos gyermekei közül, ha léteznek, és jelenleg nem fertőzöttek. Legfeljebb egy korábban nem fertőzött gyermek fertőződhet meg a betegséggel egy másodperc alatt.
Kimutatható, hogy véges másodpercek után a sorban álló összes gyerek megfertőződik a betegséggel. A fertőzési szekvencia azoknak a pozícióknak a sorrendje, amelyekben az összes nem fertőzött gyermek megfertőződik a betegséggel. Adja vissza a lehetséges fertőzési sorozatok teljes számát.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
Vegye figyelembe, hogy a fertőzési szekvencia nem tartalmazza azoknak a gyermekeknek a pozícióit, akik már az elején megfertőződtek a betegséggel.

1. példa:

Bemenet: n = 5, sick = [0,4]
Kimenet: 4
Magyarázat: Az 1., 2. és 3. pozícióban lévő gyerekek kezdetben nem fertőzöttek. 4 lehetséges fertőzési szekvencia van:
- Az 1. és 3. pozícióban lévő gyerekek megfertőződhetnek, mivel az ő pozíciójuk szomszédos a fertőzött 0 és 4 gyermekekkel. Az 1. pozícióban lévő gyermek fertőződik meg először.
Most a 2. pozícióban lévő gyermek szomszédos az 1. pozícióban lévő gyermekkel, aki fertőzött, és a 3. pozícióban lévő gyermek szomszédos a 4. pozícióban lévő gyermekkel, aki fertőzött, így bármelyikük megfertőződhet. A 2. pozícióban lévő gyermek megfertőződik.
Végül a 3. pozícióban lévő gyermek megfertőződik, mert szomszédos a 2. és 4. pozícióban lévő gyermekekkel, akik fertőzöttek. A fertőzés sorrendje [1,2,3].
- Az 1. és 3. pozícióban lévő gyerekek megfertőződhetnek, mert pozíciójuk szomszédos a fertőzött 0. és 4. pozícióban lévő gyerekekkel. Az 1. pozícióban lévő gyermek fertőződik meg először.
Most a 2. pozícióban lévő gyermek szomszédos az 1. pozícióban lévő gyermekkel, aki fertőzött, és a 3. pozícióban lévő gyermek szomszédos a 4. pozícióban lévő gyermekkel, aki fertőzött, így bármelyikük megfertőződhet. A 3. pozícióban lévő gyermek megfertőződik.
Végül a 2. pozícióban lévő gyermek megfertőződik, mert szomszédos az 1. és 3. pozícióban lévő gyermekekkel, akik fertőzöttek. A fertőzés sorrendje [1,3,2].
- A fertőzés sorrendje [3,1,2]. A gyermekek megbetegedésének sorrendje: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].
- A fertőzés sorrendje [3,2,1]. A gyermekek megbetegedésének sorrendje: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].

2. példa:

Bemenet: n = 4, sick = [1]
Kimenet: 3
Magyarázat: A 0., 2. és 3. pozícióban lévő gyerekek kezdetben nem fertőzöttek. Három lehetséges fertőzési szekvencia létezik:
- A fertőzés sorrendje [0,2,3]. A gyermekek megbetegedésének sorrendje: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- A fertőzés sorrendje [2,0,3]. A gyermekek megbetegedésének sorrendje: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- A fertőzés sorrendje [2,3,0]. A gyermekek megbetegedésének sorrendje: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].

Korlátozások:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
a betegek növekvő sorrendben vannak válogatva.

Kap egy n egész számot és egy 0 indexelt egész tömböt, amely növekvő sorrendben van rendezve.
N gyermek áll egy sorban, 0-tól n - 1-ig terjedő pozíciókkal. A beteg tömb tartalmazza a fertőző betegséggel fertőzött gyermekek helyzetét. Az i pozícióban lévő fertőzött gyermek terjesztheti a betegséget bármelyik közvetlen szomszédos gyermekére az i - 1 és i + 1 pozíciókban, ha léteznek és jelenleg nem fertőzöttek. Legfeljebb egy gyermek, aki korábban nem volt fertőzött, egy másodperc alatt megfertőződhet a betegséggel.
Kimutatható, hogy véges számú másodperc elteltével a sorban lévő összes gyermek megfertőződik a betegséggel. A fertőzési szekvencia azoknak a pozícióknak a sorrendje, amelyekben az összes nem fertőzött gyermek megfertőződik a betegséggel. A lehetséges fertőzési szekvenciák teljes számát adja vissza.
Mivel a válasz nagy lehet, adja vissza modulo 10^9 + 7.
Ne feledje, hogy a fertőzési szekvencia nem tartalmazza azoknak a gyermekeknek a helyzetét, akik már a betegség kezdetén fertőzöttek voltak.

1. példa:

Bemenet: n = 5, sick = [0,4]
Kimenet: 4
Magyarázat: Az 1., 2. és 3. pozícióban lévő gyermekek kezdetben nem fertőzöttek. 4 lehetséges fertőzési szekvencia létezik:
- Az 1. és 3. pozícióban lévő gyermekek megfertőződhetnek, mivel pozíciójuk szomszédos a 0. és 4. fertőzött gyermekekkel. Először az 1. pozícióban lévő gyermek fertőződik meg.
Most a 2. pozícióban lévő gyermek szomszédos az 1. pozícióban lévő gyermekkel, aki fertőzött, és a 3. pozícióban lévő gyermek szomszédos a 4. pozícióban lévő gyermekkel, aki fertőzött, ezért bármelyikük megfertőződhet. A 2. pozícióban lévő gyermek megfertőződik.
Végül a 3. pozícióban lévő gyermek megfertőződik, mert a 2. és 4. pozícióban lévő fertőzött gyermekek szomszédságában van. A fertőzési szekvencia [1,2,3].
- Az 1. és 3. pozícióban lévő gyermekek megfertőződhetnek, mert pozíciójuk szomszédos a 0. és 4. fertőzött gyermekekkel. Először az 1. pozícióban lévő gyermek fertőződik meg.
Most a 2. pozícióban lévő gyermek szomszédos az 1. pozícióban lévő gyermekkel, aki fertőzött, és a 3. pozícióban lévő gyermek szomszédos a 4. pozícióban lévő gyermekkel, aki fertőzött, ezért bármelyikük megfertőződhet. A 3. pozícióban lévő gyermek megfertőződik.
Végül a 2. pozícióban lévő gyermek megfertőződik, mert az 1. és 3. pozícióban lévő fertőzött gyermekek szomszédságában van. A fertőzés szekvenciája [1,3,2].
- A fertőzési szekvencia [3,1,2]. A gyermekek betegségének fertőzési sorrendje a következőképpen tekinthető: [0,1,2,3,4] = > [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- A fertőzés szekvenciája [3,2,1]. A gyermekek betegségének fertőzési sorrendje a következőképpen tekinthető: [0,1,2,3,4] = > [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

2. példa:

Bemenet: n = 4, sick = [1]
Kimenet: 3
Magyarázat: A 0., 2. és 3. pozícióban lévő gyermekek kezdetben nem fertőzöttek. 3 lehetséges fertőzési szekvencia létezik:
- A fertőzési szekvencia [0,2,3]. A gyermekek betegségfertőzésének sorrendje a következőképpen tekinthető: [0,1,2,3] = > [0,1,2,3] = > [0,1,2,3] = > [0,1,2,3].
- A fertőzés szekvenciája [2,0,3]. A gyermekek betegségfertőzésének sorrendje a következőképpen tekinthető: [0,1,2,3] = > [0,1,2,3] = > [0,1,2,3] = > [0,1,2,3].
- A fertőzési szekvencia [2,3,0]. A gyermekek betegségfertőzésének sorrendje a következőképpen tekinthető: [0,1,2,3] = > [0,1,2,3] = > [0,1,2,3] = > [0,1,2,3].

Korlátok:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
A beteg növekvő sorrendben van rendezve.


Kapsz egy egész tömb számot és egy k egész számot.
Egy x elem frekvenciája az a szám, ahányszor előfordul egy tömbben.
Egy tömböt akkor nevezünk jónak, ha a tömb minden elemének frekvenciája kisebb vagy egyenlő k-val.
A számok leghosszabb jó résztömbjének hosszát adja eredményül.
A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [1,2,3,1,2,3,1,2], k = 2
Kimenet: 6
Magyarázat: A lehető leghosszabb jó résztömb az [1,2,3,1,2,3], mivel az 1, 2 és 3 értékek legfeljebb kétszer fordulnak elő ebben a résztömbben. Vegye figyelembe, hogy a [2,3,1,2,3,1] és a [3,1,2,3,1,2] altömbök is jók.
Megmutatható, hogy nincsenek 6-nál hosszabb jó altömbök.

2. példa:

Bemenet: nums = [1,2,1,2,1,2,1,2], k = 1
Kimenet: 2
Magyarázat: A lehető leghosszabb jó résztömb az [1,2], mivel az 1 és 2 értékek legfeljebb egyszer fordulnak elő ebben a résztömbben. Megjegyezzük, hogy a [2,1] résztömb is jó.
Megmutatható, hogy nincsenek jó altömbök, amelyek hossza nagyobb, mint 2.

3. példa:

Bemenet: nums = [5,5,5,5,5,5,5], k = 4
Kimenet: 4
Magyarázat: A lehető leghosszabb jó résztömb az [5,5,5,5], mivel az 5 érték 4-szer fordul elő ebben a résztömbben.
Megmutatható, hogy nincsenek jó altömbök, amelyek hossza nagyobb, mint 4.

Korlátok:

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

Kapsz egy egész tömb számot és egy k egész számot.
Egy x elem gyakorisága az, hogy hányszor fordul elő egy tömbben.
Egy tömböt akkor nevezünk jónak, ha a tömb minden elemének gyakorisága kisebb vagy egyenlő, mint k.
A számok leghosszabb jó altömbjének hosszát adja vissza.
Az altömb egy tömbön belüli elemek összefüggő, nem üres sorozata.

1. példa:

Bemenet: nums = [1,2,3,1,2,3,1,2], k = 2
Kimenet: 6
Magyarázat: A lehető leghosszabb jó altömb [1,2,3,1,2,3], mivel az 1, 2 és 3 értékek legfeljebb kétszer fordulnak elő ebben az altömbben. Figyeljük meg, hogy a [2,3,1,2,3,1] és a [3,1,2,3,1,2] altömbök is jók.
Kimutatható, hogy nincsenek jó, 6-nál hosszabb altömbök.

2. példa:

Bemenet: nums = [1,2,1,2,1,2,1,2], k = 1
Kimenet: 2
Magyarázat: A lehető leghosszabb jó altömb [1,2], mivel az 1 és 2 értékek legfeljebb egyszer fordulnak elő ebben az altömbben. Vegyük észre, hogy a [2,1] altömb is jó.
Kimutatható, hogy nincsenek jó, 2-nél hosszabb altömbök.

3. példa:

Bemenet: nums = [5,5,5,5,5,5,5], k = 4
Kimenet: 4
Magyarázat: A lehető leghosszabb jó altömb [5,5,5,5], mivel az 5-ös érték 4-szer fordul elő ebben az altömbben.
Kimutatható, hogy nincsenek 4-nél hosszabb altömbök.

Korlátozások:

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

Kapsz egy egész tömb számot és egy k egész számot.
Egy x elem frekvenciája az a szám, ahányszor előfordul egy tömbben.
Egy tömböt akkor nevezünk jónak, ha a tömb minden elemének frekvenciája kisebb vagy egyenlő k-val.
A számok leghosszabb jó résztömbjének hosszát adja eredményül.
A résztömb elemek folytonos, nem üres sorozata egy tömbön belül.

1. példa:

Bemenet: nums = [1,2,3,1,2,3,1,2], k = 2
Kimenet: 6
Magyarázat: A lehető leghosszabb jó résztömb az [1,2,3,1,2,3], mivel az 1, 2 és 3 értékek legfeljebb kétszer fordulnak elő ebben a résztömbben. Vegye figyelembe, hogy a [2,3,1,2,3,1] és a [3,1,2,3,1,2] altömbök is jók.
Megmutatható, hogy nincsenek 6-nál hosszabb jó altömbök.

2. példa:

Bemenet: nums= [1,2,1,2,1,2,1,2], k = 1
Kimenet: 2
Magyarázat: A lehető leghosszabb jó résztömb az [1,2], mivel az 1 és 2 értékek legfeljebb egyszer fordulnak elő ebben a résztömbben. Megjegyezzük, hogy a [2,1] résztömb is jó.
Megmutatható, hogy nincsenek jó altömbök, amelyek hossza nagyobb, mint 2.

3. példa:

Bemenet: nums = [5,5,5,5,5,5,5], k = 4
Kimenet: 4
Magyarázat: A lehető leghosszabb jó résztömb az [5,5,5,5], mivel az 5 érték 4-szer fordul elő ebben a résztömbben.
Megmutatható, hogy nincsenek jó altömbök, amelyek hossza nagyobb, mint 4.

Korlátok:

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


Adott egy 0-indexált, páros hosszúságú egész számtömb nums és egy üres arr tömb is. Alice és Bob úgy döntöttek, hogy játszanak egy játékot, ahol minden fordulóban Alice és Bob egy lépést tesz. A játék szabályai a következők:

Minden fordulóban először Alice eltávolítja a legkisebb elemet a numsból, majd Bob is ugyanezt teszi.
Most először Bob fogja az eltávolított elemet az arr tömbhöz csatolni, majd Alice teszi ugyanezt.
A játék addig folytatódik, amíg a nums ki nem ürül.

Az eredményül kapott arr tömb visszaadása.

Példa 1:

Bemenet: nums = [5,4,2,3]
Kimenet: [3,2,5,4]
Magyarázat: Az első körben Alice először eltávolítja a 2-t, majd Bob eltávolítja a 3-at. Ezután az arr-ban először Bob csatolja a 3-at, majd Alice a 2-őt. Tehát arr = [3,2].
A második forduló elején a nums = [5,4]. Most először Alice eltávolítja a 4-et, majd Bob az 5-öt. Ezután mindketten beillesztik az arr-t, ami így [3,2,5,4] lesz.

Példa 2:

Bemenet: nums = [2,5]
Kimenet: [5,2]
Magyarázat: Az első körben Alice először eltávolítja a 2-t, majd Bob eltávolítja az 5-öt. Ezután az arr-ban először Bob appendál, majd Alice appendál. Tehát arr = [5,2].

Korlátozások:

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

Kapsz egy 0-indexelt egész tömb páros hosszúságú számokat, és van egy üres tömb is. Alice és Bob úgy döntött, hogy olyan játékot játszanak, ahol Alice és Bob minden körben egy mozdulatot tesznek. A játék szabályai a következők:

Minden körben először Alice eltávolítja a minimális elemet a számokból, majd Bob ugyanezt teszi.
Most először Bob hozzáfűzi az eltávolított elemet az arr tömbhöz, majd Alice ugyanezt teszi.
A játék addig folytatódik, amíg a számok ki nem ürülnek.

Adja vissza a kapott arr tömböt.

1. példa:

Bemenet: nums = [5,4,2,3]
Kimenet: [3,2,5,4]
Magyarázat: Az első körben először Alice eltávolít 2-t, majd Bob 3-at. Ezután az arr-ben először Bob hozzáfűzi a 3-at, majd Alice hozzáfűzi a 2-t. Tehát arr = [3,2].
A második kör elején a számok = [5,4]. Most először Alice eltávolít 4-et, majd Bob 5-öt. Ezután mindkettő hozzáfűzi az arr-t, amiből [3,2,5,4] lesz.

2. példa:

Bemenet: nums = [2,5]
Kimenet: [5,2]
Magyarázat: Az első körben először Alice eltávolít 2-t, majd Bob 5-öt. Ezután először Bob hozzáfűzi, majd Alice hozzáfűzi. Tehát arr = [5,2].

Korlátozások:

1 <= nums.length <= 100
1 <= nums[i] <= 100
számok.hossz % 2 == 0

Kapsz egy 0-indexelt egész tömb számát páros hosszúságú, és van egy üres tömb arr is. Alice és Bob úgy döntöttek, hogy játszanak egy játékot, ahol minden körben Alice és Bob egy lépést tesz. A játékszabályok a következők:

Minden körben először Alice eltávolítja a minimális elemet a numokból, majd Bob ugyanezt teszi.
Most először Bob hozzáfűzi az eltávolított elemet az arr tömbhöz, majd Alice ugyanezt teszi.
A játék addig folytatódik, amíg a nums üres nem lesz.

Adja vissza az eredményül kapott tömböt arr.

1. példa:

Bemenet: nums = [5,4,2,3]
Kimenet: [3,2,5,4]
Magyarázat: Az első körben először Alice távolítja el a 2-t, majd Bob a 3-at. Ezután az arr-ban először Bob hozzáfűzi a 3-at, majd Alice hozzáfűzi a 2-t. Tehát arr = [3,2].
A második kör elején nums = [5,4]. Most először Alice távolítja el a 4-et, majd Bob az 5-öt. Ezután mindkettő hozzáfűzi az arr-t, amely [3,2,5,4] lesz.

2. példa:

Bemenet: nums = [2,5]
Kimenet: [5,2]
Magyarázat: Az első körben először Alice távolít el 2-t, majd Bob 5-öt. Aztán az arr-ban először Bob hozzáfűzi, majd Alice hozzáfűzi. Tehát arr = [5,2].

Korlátok:

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