Máte n procesorů, z nichž každý má 4 jádra a n * 4 úkoly, které je třeba provést, takže každé jádro by mělo provádět pouze jeden úkol.
S ohledem na celočíselné pole processorTime indexované hodnotou 0 představující čas, kdy je každý procesor poprvé k dispozici, a celočíselné pole s indexem 0 představující čas potřebný k provedení každé úlohy, vrací minimální čas, kdy byly všechny úlohy provedeny procesory.
Poznámka: Každé jádro provádí úlohu nezávisle na ostatních.

Příklad 1:

Vstup: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Výstup: 16
Vysvětlení:
Optimální je přiřadit úlohy na indexech 4, 5, 6, 7 prvnímu procesoru, který bude k dispozici v čase = 8, a úkoly na indexech 0, 1, 2, 3 druhému procesoru, který bude k dispozici v čase = 10.
Doba, za kterou první procesor dokončí provádění všech úloh = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Čas potřebný druhým procesorem k dokončení provádění všech úloh = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Lze tedy ukázat, že minimální doba potřebná k provedení všech úloh je 16.
Příklad 2:

Vstup: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Výstup: 23
Vysvětlení:
Optimální je přiřadit úlohy v indexech 1, 4, 5, 6 prvnímu procesoru, který bude k dispozici v čase = 10, a úkoly v indexech 0, 2, 3, 7 druhému procesoru, který bude k dispozici v čase = 20.
Doba, za kterou první procesor dokončí provádění všech úloh = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Čas potřebný k dokončení provádění všech úloh druhému procesoru = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Lze tedy ukázat, že minimální doba potřebná k provedení všech úloh je 23.

Omezení:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= čas procesoru[i] <= 10^9
1 <= úkoly[i] <= 10^9
tasks.length == 4 * n

Máte n procesorů, z nichž každý má 4 jádra a n * 4 úloh, které je třeba provést, takže každé jádro by mělo provádět pouze jednu úlohu.
Vzhledem k tomu, že 0-indexované celočíselné pole procesorTime představuje čas, kdy je každý procesor poprvé dostupný, a 0-indexované celočíselné pole představuje čas potřebný k provedení každé úlohy, vrátí minimální čas, kdy byly všechny úlohy prováděné procesory.
Poznámka: Každé jádro provádí úlohu nezávisle na ostatních.

Příklad 1:

Vstup: procesorTime = [8,10], úlohy = [2,2,3,1,8,7,4,5]
Výstup: 16
Vysvětlení:
Optimální je přiřadit úlohy na indexech 4, 5, 6, 7 prvnímu procesoru, který bude dostupný v čase = 8, a úlohy na indexech 0, 1, 2, 3 druhému procesoru, který bude dostupný v čase = 10 .
Čas potřebný prvnímu procesoru k dokončení všech úloh = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Čas, který druhý procesor potřebuje k dokončení všech úloh = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Lze tedy ukázat, že minimální čas potřebný k provedení všech úkolů je 16.
Příklad 2:

Vstup: procesorTime= [10,20], úlohy = [2,3,1,2,5,8,4,3]
Výstup: 23
Vysvětlení:
Optimální je přiřadit úlohy na indexech 1, 4, 5, 6 prvnímu procesoru, který bude dostupný v čase = 10, a úlohy na indexech 0, 2, 3, 7 druhému procesoru, který bude dostupný v čase = 20. .
Čas potřebný prvnímu procesoru k dokončení všech úloh = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Čas, který potřebuje druhý procesor k dokončení všech úloh = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Lze tedy prokázat, že minimální čas potřebný k provedení všech úkolů je 23.

Omezení:

1 <= n == procesorTime.length <= 25000
1 <= úkoly.length <= 10^5
0 <= procesorTime[i] <= 10^9
1 <= úkoly[i]<= 10^9
úkoly.length == 4 * n

Máte n procesorů, z nichž každý má 4 jádra a n * 4 úkoly, které je třeba provést, takže každé jádro by mělo provádět pouze jeden úkol.
S ohledem na celočíselné pole processorTime indexované hodnotou 0 představující čas, kdy je každý procesor poprvé k dispozici, a celočíselné pole s indexem 0 představující čas potřebný k provedení každé úlohy, vrací minimální čas, kdy byly všechny úlohy provedeny procesory.
Poznámka: Každé jádro provádí úlohu nezávisle na ostatních.

Příklad 1:

Vstup: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Výstup: 16
Vysvětlení:
Optimální je přiřadit úlohy na indexech 4, 5, 6, 7 prvnímu procesoru, který bude k dispozici v čase = 8, a úkoly na indexech 0, 1, 2, 3 druhému procesoru, který bude k dispozici v čase = 10.
Doba, za kterou první procesor dokončí provádění všech úloh = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Čas potřebný druhým procesorem k dokončení provádění všech úloh = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Lze tedy ukázat, že minimální doba potřebná k provedení všech úloh je 16.
Příklad 2:

Vstup: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Výstup: 23
Vysvětlení:
Optimální je přiřadit úlohy v indexech 1, 4, 5, 6 prvnímu procesoru, který bude k dispozici v čase = 10, a úkoly v indexech 0, 2, 3, 7 druhému procesoru, který bude k dispozici v čase = 20.
Doba, za kterou první procesor dokončí provádění všech úloh = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Čas potřebný k dokončení provádění všech úloh druhému procesoru = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Lze tedy ukázat, že minimální doba potřebná k provedení všech úloh je 23.

Omezení:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n


Je zadáno pole celých čísel nums s indexem 0 a kladné celé číslo k.
S polem můžete libovolně mnohokrát provést následující operaci:

Zvolte libovolné dva různé indexy i a j a současně aktualizujte hodnoty nums[i] na (nums[i] AND nums[j]) a nums[j] na (nums[i] OR nums[j]). Zde OR označuje bitovou operaci OR a AND označuje bitovou operaci AND.

Z výsledného pole je třeba vybrat k prvků a vypočítat součet jejich čtverců.
Vraťte maximální součet čtverců, kterého můžete dosáhnout.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [2,6,5,8], k = 2
Výstup: 261
Vysvětlení: S polem můžeme provádět následující operace:
- Zvolíme i = 0 a j = 3, pak změníme nums[0] na (2 AND 8) = 0 a nums[3] na (2 OR 8) = 10. Výsledné pole je nums = [0,6,5,10].
- Zvolte i = 2 a j = 3, pak změňte nums[2] na (5 AND 10) = 0 a nums[3] na (5 OR 10) = 15. Výsledné pole je nums = [0,6,0,15].
Z výsledného pole můžeme vybrat prvky 15 a 6. Součet čtverců je 15^2 + 6^2 = 261.
Lze ukázat, že to je maximální hodnota, kterou můžeme získat.

Příklad 2:

Vstup: nums = [4,5,4,7], k = 3
Výstup: 90
Vysvětlení: Nepotřebujeme použít žádné operace.
Můžeme vybrat prvky 7, 5 a 4 se součtem čtverců: 7^2 + 5^2 + 4^2 = 90.
Lze ukázat, že to je maximální hodnota, kterou můžeme získat.

Omezení:

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

Dostanete 0-indexované celé číslo pole nums a kladné celé číslo k.
Následující operaci můžete na poli provést libovolněkrát:

Vyberte libovolné dva odlišné indexy ia j a současně aktualizujte hodnoty nums[i] na (nums[i] AND nums[j]) a nums[j] na (nums[i] OR nums[j]). Zde OR označuje bitovou operaci OR a AND označuje bitovou operaci AND.

Musíte vybrat k prvků z konečného pole a vypočítat součet jejich čtverců.
Vraťte maximální součet čtverců, kterých můžete dosáhnout.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [2,6,5,8], k = 2
Výstup: 261
Vysvětlení: S polem můžeme provádět následující operace:
- Zvolte i = 0 a j = 3, poté změňte nums[0] na (2 AND 8) = 0 a nums[3] na (2 NEBO 8) = 10. Výsledné pole je nums = [0,6,5 ,10].
- Zvolte i = 2 a j = 3, poté změňte nums[2] na (5 AND 10) = 0 a nums[3] na (5 NEBO 10) = 15. Výsledné pole je nums = [0,6,0 ,15].
Můžeme si vybrat prvky 15 a 6 z výsledného pole. Součet čtverců je 15^2 + 6^2 = 261.
Dá se ukázat, že je to maximální hodnota, kterou můžeme získat.

Příklad 2:

Vstup: nums = [4,5,4,7], k = 3
Výstup: 90
Vysvětlení: Nepotřebujeme provádět žádné operace.
Můžeme zvolit prvky 7, 5 a 4 se součtem čtverců: 7^2 + 5^2 + 4^2 = 90.
Dá se ukázat, že je to maximální hodnota, kterou můžeme získat.

Omezení:

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

Dostanete celé pole s indexem 0 nums a kladné celé číslo k.
S polem můžete provést následující operaci libovolněkrát:

Zvolte libovolné dva různé indexy i a j a současně aktualizujte hodnoty nums[i] na (nums[i] AND nums[j]) a nums[j] na (nums[i] OR nums[j]). V tomto případě OR označuje bitovou operaci OR a AND označuje bitovou operaci AND.

Musíte vybrat k prvků z výsledného pole a vypočítat součet jejich čtverců.
Vrací maximální součet čtverců, kterého můžete dosáhnout.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [2,6,5,8], k = 2
Výstup: 261
Vysvětlení: S polem můžeme provádět následující operace:
- Zvolte i = 0 a j = 3, pak změňte nums[0] na (2 AND 8) = 0 a nums[3] na (2 OR 8) = 10. Výsledná matice je nums = [0,6,5,10].
- Zvolte i = 2 a j = 3, pak změňte nums[2] na (5 AND 10) = 0 a nums[3] na (5 OR 10) = 15. Výsledná matice je nums = [0,6,0,15].
Z výsledného pole si můžeme vybrat prvky 15 a 6. Součet čtverců je 15^2 + 6^2 = 261.
Lze ukázat, že toto je maximální hodnota, kterou můžeme získat.

Příklad 2:

Vstup: nums = [4,5,4,7], k = 3
Výstup: 90
Vysvětlení: Nemusíme aplikovat žádné operace.
Můžeme vybrat prvky 7, 5 a 4 se součtem čtverců: 7^2 + 5^2 + 4^2 = 90.
Lze ukázat, že toto je maximální hodnota, kterou můžeme získat.

Omezení:

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


Dostanete 0-indexované celočíselné pole nums.
Vraťte maximální hodnotu přes všechny trojice indexů (i, j, k) tak, že i < j < k. Pokud mají všechny takové trojice zápornou hodnotu, vraťte 0.
Hodnota trojice indexů (i, j, k) je rovna (nums[i] - nums[j]) * nums[k].

Příklad 1:

Vstup: nums = [12,6,1,2,7]
Výstup: 77
Vysvětlení: Hodnota trojice (0, 2, 4) je (nums[0] - nums[2]) * nums[4] = 77.
Lze ukázat, že neexistují žádné uspořádané trojice indexů s hodnotou větší než 77.

Příklad 2:

Vstup: nums = [1,10,3,4,19]
Výstup: 133
Vysvětlení: Hodnota trojice (1, 2, 4) je (nums[1] - nums[2]) * nums[4] = 133.
Lze ukázat, že neexistují žádné uspořádané trojice indexů s hodnotou větší než 133.

Příklad 3:

Vstup: nums = [1,2,3]
Výstup: 0
Vysvětlení: Jediný uspořádaný triplet indexů (0, 1, 2) má zápornou hodnotu (nums[0] - nums[1]) * nums[2] = -3. Odpověď by tedy byla 0.

Omezení:

3 <= nums.length <= 100
1 <= nums[i] <= 10^6

Je zadáno celočíselné pole nums s indexem 0.
Vraťte maximální hodnotu nad všemi trojicemi indexů (i, j, k) tak, že i < j < k. Pokud mají všechny takové trojice zápornou hodnotu, vraťte 0.
Hodnota trojice indexů (i, j, k) je rovna (nums[i] - nums[j]) * nums[k].

Příklad 1:

Vstup: nums = [12,6,1,2,7]
Výstup: 77
Vysvětlení: Hodnota trojice (0, 2, 4) je (nums[0] - nums[2]) * nums[4] = 77.
Lze ukázat, že neexistuje žádná uspořádaná trojice indexů s hodnotou větší než 77.

Příklad 2:

Vstup: nums = [1,10,3,4,19]
Výstup: 133
Vysvětlení: Hodnota trojice (1, 2, 4) je (nums[1] - nums[2]) * nums[4] = 133.
Lze ukázat, že neexistuje žádná uspořádaná trojice indexů s hodnotou větší než 133.

Příklad 3:

Vstup: nums = [1,2,3]
Výstup: 0
Vysvětlení: Jediná uspořádaná trojice indexů (0, 1, 2) má zápornou hodnotu (nums[0] - nums[1]) * nums[2] = -3. Proto by odpověď byla 0.

Omezení:

3 <= nums.length <= 100
1 <= nums[i] <= 10^6

Je vám dáno celé číslo pole `nums` indexované od nuly.
Vraťte maximální hodnotu pro všechny trojice indexů (i, j, k) takové, že i < j < k. Pokud mají všechny takové trojice hodnotu zápornou, vraťte 0.
Hodnota trojice indexů (i, j, k) je rovna (nums[i] - nums[j]) * nums[k].

Příklad 1:

Vstup: nums = [12,6,1,2,7]
Výstup: 77
Vysvětlení: Hodnota trojice (0, 2, 4) je (nums[0] - nums[2]) * nums[4] = 77.
Lze ukázat, že neexistují žádné uspořádané trojice indexů s hodnotou větší než 77.

Příklad 2:

Vstup: nums = [1,10,3,4,19]
Výstup: 133
Vysvětlení: Hodnota trojice (1, 2, 4) je (nums[1] - nums[2]) * nums[4] = 133.
Lze ukázat, že neexistují žádné uspořádané trojice indexů s hodnotou větší než 133.

Příklad 3:

Vstup: nums = [1,2,3]
Výstup: 0
Vysvětlení: Jediná uspořádaná trojice indexů (0, 1, 2) má zápornou hodnotu (nums[0] - nums[1]) * nums[2] = -3. Proto by odpověď byla 0.

Omezení:

3 <= nums.length <= 100
1 <= nums[i] <= 10^6


Máte dáno celočíselné pole nums indexované od 0.
Počet různých hodnot v podpoli nums je definován jako:

Nechť nums[i..j] je podpole nums, skládající se ze všech indexů od i do j tak, že 0 <= i <= j < nums.length. Poté počet různých hodnot v nums[i..j] je nazýván počet různých hodnot nums[i..j].

Vraťte součet čtverců počtů různých hodnot ve všech podpoli pole nums.
Podpole je souvislá neprázdná posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [1,2,1]
Výstup: 15
Vysvětlení: Šest možných podpolí je:
[1]: 1 různá hodnota
[2]: 1 různá hodnota
[1]: 1 různá hodnota
[1,2]: 2 různé hodnoty
[2,1]: 2 různé hodnoty
[1,2,1]: 2 různé hodnoty
Součet čtverců počtů různých hodnot ve všech podpoli je roven 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Příklad 2:

Vstup: nums = [1,1]
Výstup: 3
Vysvětlení: Tři možná podpole jsou:
[1]: 1 různá hodnota
[1]: 1 různá hodnota
[1,1]: 1 různá hodnota
Součet čtverců počtů různých hodnot ve všech podpoli je roven 1^2 + 1^2 + 1^2 = 3.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums.
Jednoznačný počet podskupiny čísel je definován jako:

Nechť nums[i..j] je podpole num sestávající ze všech indexů od i do j tak, že 0 <= i <= j < nums.length. Potom se počet odlišných hodnot v nums[i..j] nazývá odlišný počet nums[i..j].

Vrátí součet druhých mocnin různých počtů všech podpolí čísel.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [1,2,1]
Výstup: 15
Vysvětlení: Šest možných podpolí je:
[1]: 1 odlišná hodnota
[2]: 1 odlišná hodnota
[1]: 1 odlišná hodnota
[1,2]: 2 různé hodnoty
[2,1]: 2 různé hodnoty
[1,2,1]: 2 různé hodnoty
Součet druhých mocnin různých počtů ve všech podpolích se rovná 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Příklad 2:

Vstup: nums = [1,1]
Výstup: 3
Vysvětlení: Tři možná podpole jsou:
[1]: 1 odlišná hodnota
[1]: 1 odlišná hodnota
[1,1]: 1 odlišná hodnota
Součet druhých mocnin různých počtů ve všech podpolích je roven 1^2 + 1^2 + 1^2 = 3.

Omezení:

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

Dostanete pole celých čísel s indexem 0.
počet různých hodnot podpole čísel je definován jako:

Nechť nums[i.. j] je podpole čísel skládající se ze všech indexů od i do j takových, že 0 <= i <= j < nums.length. Pak počet různých hodnot v nums[i.. j] se nazývá odlišný počet nums[i.. j].

Vrátí součet druhých mocnin počtů různých hodnot všech podpolí čísel.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [1,2,1]
Výstup: 15
Vysvětlení: Šest možných podpolí je:
[1]: 1 odlišná hodnota
[2]: 1 odlišná hodnota
[1]: 1 odlišná hodnota
[1,2]: 2 různé hodnoty
[2,1]: 2 různé hodnoty
[1,2,1]: 2 různé hodnoty
Součet druhých mocnin různých počtů ve všech podpolích je roven 1^2 + 1^2 + 1^2 + 2^2 + 2^2 = 15.

Příklad 2:

Vstup: nums = [1,1]
Výstup: 3
Vysvětlení: Tři možná podpole jsou:
[1]: 1 odlišná hodnota
[1]: 1 odlišná hodnota
[1,1]: 1 odlišná hodnota
Součet druhých mocnin různých počtů ve všech podpolích je roven 1^2 + 1^2 + 1^2 = 3.

Omezení:

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


Je dáno polem řetězců s indexem 0 slova, kde words[i] je buď kladné celé číslo reprezentované jako řetězec, nebo řetězec "prev".
Začněte iterovat od začátku pole; Pro každý řetězec "prev" zobrazený ve slovech najděte poslední navštívené celé číslo ve slovech, které je definováno takto:

Nechť k je počet po sobě jdoucích "prev" řetězců, které jsme dosud viděli (obsahujících aktuální řetězec). Nechť nums je 0-indexované pole celých čísel, které jsme dosud viděli, a nums_reverse být opakem nums, pak celé číslo na (k - 1)^th indexu nums_reverse bude posledním navštíveným celým číslem pro tento "prev".
Pokud je k větší než celkový počet navštívených celých čísel, pak poslední navštívené celé číslo bude mít hodnotu -1.

Vrátí celočíselné pole obsahující naposledy navštívená celá čísla.

Příklad 1:

Vstup: words = ["1","2","prev","prev","prev"]
Výstup: [2,1,-1]
Vysvětlení:
Pro "prev" při index = 2 bude poslední navštívené celé číslo 2, protože zde je počet po sobě jdoucích řetězců "prev" 1 a v poli reverse_nums bude 2 prvním prvkem.
Pro "prev" v index = 3 bude poslední navštívené celé číslo 1, protože jsou navštíveny celkem dva po sobě jdoucí řetězce "prev" včetně tohoto "prev" a 1 je druhé naposledy navštívené celé číslo.
Pro "prev" s index = 4 bude poslední navštívené celé číslo -1, protože jsou navštíveny celkem tři po sobě jdoucí řetězce "prev" včetně tohoto "prev", ale celkový počet navštívených celých čísel je dvě.

Příklad 2:

Vstup: words = ["1","prev","2","prev","prev"]
Výstup: [1,2,1]
Vysvětlení:
Pro "prev" v index = 1 bude poslední navštívené celé číslo 1.
Pro "prev" v index = 3 bude poslední navštívené celé číslo 2.
Pro "prev" s index = 4 bude poslední navštívené celé číslo 1, protože jsou navštíveny celkem dva po sobě jdoucí řetězce "prev" včetně tohoto "prev" a 1 je druhé naposledy navštívené celé číslo.

Omezení:

1 <= words.length <= 100
words[i] == "prev" nebo 1 <= int(words[i]) <= 100

Je dáno pole řetězců words s indexem 0, kde words[i] je buď celé kladné číslo reprezentované jako řetězec, nebo řetězec „prev“.
Začněte iterovat od začátku pole; pro každý řetězec "prev" vyskytující se ve words najděte poslední navštívené celé číslo ve words, které je definováno takto:

Nechť k je počet dosud viděných po sobě jdoucích řetězců „prev“ (obsahujících aktuální řetězec). Nechť nums je pole dosud viděných celých čísel s indexem 0 a nums_reverse je reverzní číslo nums, pak celé číslo na (k - 1)^-tém indexu nums_reverse bude posledním navštíveným celým číslem pro tento „prev“.
Pokud je k větší než celkový počet navštívených celých čísel, pak poslední navštívené celé číslo bude -1.

Vrátí pole celých čísel obsahující poslední navštívená celá čísla.

Příklad 1:

Vstup: words = [„1“, „2“, „prev“, „prev“, „prev“]
Výstup: [2,1,-1]
Vysvětlení:
Pro „prev“ na indexu = 2 bude poslední navštívené celé číslo 2, protože zde je počet po sobě jdoucích řetězců „prev“ 1 a v poli reverse_nums bude 2 prvním prvkem.
Pro „prev“ na indexu = 3 bude poslední navštívené celé číslo 1, protože jsou navštíveny celkem dva po sobě jdoucí řetězce „prev“ včetně tohoto „prev“ a 1 je druhé poslední navštívené celé číslo.
Pro „prev“ na indexu = 4 bude poslední navštívené celé číslo -1, protože jsou navštíveny celkem tři po sobě jdoucí řetězce „prev“ včetně tohoto „prev“, ale celkový počet navštívených celých čísel je dva.

Příklad 2:

Vstup: words = [„1“, „prev“, „2“, „prev“, „prev“]
Výstup: [1,2,1]
Vysvětlení:
Pro „prev“ na indexu = 1 bude poslední navštívené celé číslo 1.
Pro „prev“ na indexu = 3 bude poslední navštívené celé číslo 2.
Pro „prev“ na indexu = 4 bude poslední navštívené celé číslo 1, protože jsou navštíveny celkem dva po sobě jdoucí řetězce „prev“ včetně tohoto „prev“ a 1 je druhé poslední navštívené celé číslo.

Omezení:

1 <= words.length <= 100
words[i] == „prev“ nebo 1 <= int(words[i]) <= 100

Dané 0-indexované pole řetězců slov, kde slova[i] je buď kladné celé číslo reprezentované jako řetězec, nebo řetězec "předchozí".
Začněte iterovat od začátku pole; pro každý „předchozí“ řetězec zobrazený ve slovech najděte poslední navštívené celé číslo ve slovech, které je definováno takto:

Nechť k je počet po sobě jdoucích "předchozích" řetězců, které jsme dosud viděli (obsahujících aktuální řetězec). Nechť nums je 0-indexované pole celých čísel, které jsme dosud viděli, a nums_reverse je opak nums, pak celé číslo na (k - 1)^-tém indexu nums_reverse bude posledním navštíveným celým číslem pro toto "předchozí".
Pokud je k větší než celkový počet navštívených celých čísel, pak poslední navštívené celé číslo bude -1.

Vrátí celočíselné pole obsahující poslední navštívená celá čísla.

Příklad 1:

Vstup: slova = ["1","2","předchozí","předchozí","předchozí"]
Výstup: [2,1,-1]
Vysvětlení:
Pro "předchozí" na index = 2 bude poslední navštívené celé číslo 2, protože zde je počet po sobě jdoucích "předchozí" řetězců 1 a v poli nums_reverse bude 2 prvním prvkem.
Pro "předchozí" na index = 3 bude poslední navštívené celé číslo 1, protože jsou celkem dva po sobě jdoucí "předchozí" řetězce včetně tohoto "předchozí", které jsou navštíveny, a 1 je druhé naposledy navštívené celé číslo.
Pro "předchozí" na index = 4 bude poslední navštívené celé číslo -1, protože jsou celkem tři po sobě jdoucí "předchozí" řetězce včetně tohoto "předchozí", které jsou navštíveny, ale celkový počet navštívených celých čísel jsou dvě.

Příklad 2:

Vstup: slova = ["1","předchozí","2","předchozí","předchozí"]
Výstup: [1,2,1]
Vysvětlení:
Pro "předchozí" na index = 1 bude poslední navštívené celé číslo 1.
Pro "předchozí" na index = 3 bude poslední navštívené celé číslo 2.
Pro "předchozí" na index = 4 bude poslední navštívené celé číslo 1, protože jsou celkem dva po sobě jdoucí "předchozí" řetězce včetně tohoto "předchozí", které jsou navštíveny, a 1 je druhé naposledy navštívené celé číslo.

Omezení:

1 <= slova.length <= 100
slova[i] == "předchozí" nebo 1 <= int(slova[i]) <= 100


Je vám dáno celočíselné pole `nums` s indexováním od 0 a délkou `n`.
Chceme seskupit indexy tak, aby každý index `i` v rozmezí [0, n - 1] byl přiřazen přesně jedné skupině.
Přiřazení skupiny je platné, pokud platí následující podmínky:

Pro každou skupinu `g` mají všechny indexy `i` přiřazené ke skupině `g` stejnou hodnotu v `nums`.
Pro libovolné dvě skupiny `g_1` a `g_2` nesmí rozdíl mezi počtem indexů přiřazených `g_1` a `g_2` překročit 1.

Vraťte celé číslo označující minimální počet skupin potřebných k vytvoření platného přiřazení skupin.

Příklad 1:

Vstup: nums = [3,2,3,2,3]
Výstup: 2
Vysvětlení: Jedním ze způsobů, jak mohou být indexy přiřazeny do 2 skupin, je následující, kde hodnoty v hranatých závorkách jsou indexy:
skupina 1 -> [0,2,4]
skupina 2 -> [1,3]
Všechny indexy jsou přiřazeny jedné skupině.
Ve skupině 1 je `nums[0] == nums[2] == nums[4]`, takže všechny indexy mají stejnou hodnotu.
Ve skupině 2 je `nums[1] == nums[3]`, takže všechny indexy mají stejnou hodnotu.
Počet indexů přiřazených skupině 1 je 3 a počet indexů přiřazených skupině 2 je 2.
Jejich rozdíl nepřekračuje 1.
Není možné použít méně než 2 skupiny, protože pro použití pouze 1 skupiny musí mít všechny indexy přiřazené do této skupiny stejnou hodnotu.
Proto je odpověď 2.

Příklad 2:

Vstup: nums = [10,10,10,3,1,1]
Výstup: 4
Vysvětlení: Jedním ze způsobů, jak mohou být indexy přiřazeny do 4 skupin, je následující, kde hodnoty v hranatých závorkách jsou indexy:
skupina 1 -> [0]
skupina 2 -> [1,2]
skupina 3 -> [3]
skupina 4 -> [4,5]
Přiřazení skupin výše splňuje obě podmínky.
Lze ukázat, že není možné vytvořit platné přiřazení s použitím méně než 4 skupin.
Proto je odpověď 4.

Omezení:

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

Dostanete 0-indexované celé pole čísel délky n.
Indexy chceme seskupit tak, aby každý index i v rozsahu [0, n - 1] byl přiřazen právě jedné skupině.
Skupinové přiřazení je platné, pokud jsou splněny následující podmínky:

Pro každou skupinu g mají všechny indexy i přiřazené skupině g stejnou hodnotu v číslech.
Pro žádné dvě skupiny g_1 a g_2 by rozdíl mezi počtem indexů přiřazených k g_1 a g_2 neměl překročit 1.

Vrátí celé číslo označující minimální počet skupin potřebných k vytvoření platného skupinového přiřazení.

Příklad 1:

Vstup: nums = [3,2,3,2,3]
Výstup: 2
Vysvětlení: Jedním ze způsobů, jak lze indexy přiřadit 2 skupinám, je následující, kde hodnoty v hranatých závorkách jsou indexy:
skupina 1 -> [0,2,4]
skupina 2 -> [1,3]
Všechny indexy jsou přiřazeny do jedné skupiny.
Ve skupině 1 nums[0] == nums[2] == nums[4], takže všechny indexy mají stejnou hodnotu.
Ve skupině 2 nums[1] == nums[3], takže všechny indexy mají stejnou hodnotu.
Počet indexů přiřazených skupině 1 je 3 a počet indexů přiřazených skupině 2 je 2.
Jejich rozdíl nepřesahuje 1.
Není možné použít méně než 2 skupiny, protože pro použití pouze 1 skupiny musí mít všechny indexy přiřazené k této skupině stejnou hodnotu.
Odpověď je tedy 2.
Příklad 2:

Vstup: nums = [10,10,10,3,1,1]
Výstup: 4
Vysvětlení: Jedním ze způsobů, jak mohou být indexy přiřazeny do 4 skupin, je následující, kde hodnoty v hranatých závorkách jsou indexy:
skupina 1 -> [0]
skupina 2 -> [1,2]
skupina 3 -> [3]
skupina 4 -> [4,5]
Výše uvedené skupinové zadání splňuje obě podmínky.
Lze ukázat, že není možné vytvořit platné přiřazení pomocí méně než 4 skupin.
Odpověď je tedy 4.

Omezení:

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

Je vám dáno celé pole indexované 0 o délce n.
Indexy chceme seskupit tak, aby pro každý index i v rozsahu [0, n - 1] byl přiřazen právě do jedné skupiny.
Přiřazení skupiny je platné, pokud jsou splněny následující podmínky:

Pro každou skupinu g mají všechny indexy i přiřazené ke skupině g stejnou hodnotu v číslech.
Pro jakékoli dvě skupiny g_1 a g_2 by rozdíl mezi počtem indexů přiřazených g_1 a g_2 neměl překročit 1.

Vrátí celé číslo označující minimální počet skupin potřebných k vytvoření platného přiřazení skupiny.

Příklad 1:

Vstup: nums = [3,2,3,2,3]
Výstup: 2
Vysvětlení: Jedním ze způsobů, jak lze indexy přiřadit do 2 skupin, je následující, kde hodnoty v hranatých závorkách jsou indexy:
skupina 1 -> [0,2,4]
skupina 2 -> [1,3]
Všechny indexy jsou přiřazeny do jedné skupiny.
Ve skupině 1 jsou nums[0] == nums[2] == nums[4], takže všechny indexy mají stejnou hodnotu.
Ve skupině 2 jsou nums[1] == nums[3], takže všechny indexy mají stejnou hodnotu.
Počet indexů přiřazených ke skupině 1 je 3 a počet indexů přiřazených ke skupině 2 je 2.
Jejich rozdíl nepřesahuje 1.
Není možné použít méně než 2 skupiny, protože aby bylo možné použít pouze 1 skupinu, musí mít všechny indexy přiřazené k této skupině stejnou hodnotu.
Odpověď je tedy 2.
Příklad 2:

Vstup: nums = [10,10,10,3,1,1]
Výstup: 4
Vysvětlení: Jedním ze způsobů, jak lze indexy přiřadit do 4 skupin, je následující, kde hodnoty v hranatých závorkách jsou indexy:
skupina 1 -> [0]
skupina 2 -> [1,2]
skupina 3 -> [3]
skupina 4 -> [4,5]
Výše uvedené přiřazení skupiny splňuje obě podmínky.
Lze ukázat, že není možné vytvořit platný úkol s použitím méně než 4 skupin.
Odpověď je tedy 4.

Omezení:

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


Jsou vám dána dvě pole nums1 a nums2 skládající se z kladných celých čísel.
Musíte nahradit všechny 0 v obou polích striktně kladnými celými čísly tak, aby součet prvků obou polí byl stejný.
Vrátí minimální stejný součet, který můžete získat, nebo -1, pokud to není možné.

Příklad 1:

Vstup: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Výstup: 12
Vysvětlení: Nuly můžeme nahradit následujícím způsobem:
- Nahraďte dvě 0 v nums1 hodnotami 2 a 4. Výsledná matice je nums1 = [3,2,2,1,4].
- Nahraďte 0 v nums2 hodnotou 1. Výsledné pole je nums2 = [6,5,1].
Obě pole mají stejný součet 12. Lze ukázat, že je to minimální součet, který můžeme získat.

Příklad 2:

Vstup: nums1 = [2,0,2,0], nums2 = [1,4]
Výstup: -1
Vysvětlení: Není možné dosáhnout toho, aby součet obou polí byl stejný.

Omezení:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

Jsou vám dána dvě pole nums1 a nums2 sestávající z kladných celých čísel.
Všechny nuly v obou polích musíte nahradit striktně kladnými celými čísly tak, aby se součet prvků obou polí rovnal.
Vraťte minimální rovný součet, který můžete získat, nebo -1, pokud to není možné.

Příklad 1:

Vstup: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Výstup: 12
Vysvětlení: Můžeme nahradit 0 následujícím způsobem:
- Nahraďte dvě 0 v nums1 hodnotami 2 a 4. Výsledné pole je nums1 = [3,2,2,1,4].
- Nahraďte 0 v nums2 hodnotou 1. Výsledné pole je nums2 = [6,5,1].
Obě pole mají stejný součet 12. Lze ukázat, že je to minimální součet, který můžeme získat.

Příklad 2:

Vstup: nums1 = [2,0,2,0], nums2 = [1,4]
Výstup: -1
Vysvětlení: Je nemožné, aby se součet obou polí rovnal.

Omezení:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6


Jsou vám dána kladná celá čísla n a m.
Definujte dvě celá čísla, num1 a num2, následovně:

číslo1: Součet všech celých čísel v rozsahu [1, n], která nejsou dělitelná m.
číslo2: Součet všech celých čísel v rozsahu [1, n], která jsou dělitelná m.

Vraťte celé číslo num1 - num2.

Příklad 1:

Vstup: n = 10, m = 3
Výstup: 19
Vysvětlení: V uvedeném příkladu:
- Celá čísla v rozsahu [1, 10], která nejsou dělitelná 3, jsou [1,2,4,5,7,8,10], num1 je součet těchto celých čísel = 37.
- Celá čísla v rozsahu [1, 10], která jsou dělitelná 3, jsou [3,6,9], num2 je součet těchto celých čísel = 18.
Jako odpověď vrátíme 37 - 18 = 19.

Příklad 2:

Vstup: n = 5, m = 6
Výstup: 15
Vysvětlení: V uvedeném příkladu:
- Celá čísla v rozsahu [1, 5], která nejsou dělitelná 6, jsou [1,2,3,4,5], num1 je součet těchto celých čísel = 15.
- Celá čísla v rozsahu [1, 5], která jsou dělitelná 6, jsou [], num2 je součet těchto celých čísel = 0.
Jako odpověď vrátíme 15 - 0 = 15.

Příklad 3:

Vstup: n = 5, m = 1
Výstup: -15
Vysvětlení: V uvedeném příkladu:
- Celá čísla v rozsahu [1, 5], která nejsou dělitelná 1, jsou [], num1 je součet těchto celých čísel = 0.
- Celá čísla v rozsahu [1, 5], která jsou dělitelná 1, jsou [1,2,3,4,5], num2 je součet těchto celých čísel = 15.
Jako odpověď vrátíme 0 - 15 = -15.

Omezení:

1 <= n, m <= 1000

Máte dány kladné celé čísla (n) a (m).
Definujte dvě celá čísla, ( text{num1} ) a ( text{num2} ), následovně:

- ( text{num1} ): Součet všech celých čísel v intervalu ([1, n]), která nejsou dělitelná číslem (m).
- ( text{num2} \): Součet všech celých čísel v intervalu \([1, n]\), která jsou dělitelná číslem \(m\).

Vrátit celé číslo \( \text{num1} - \text{num2} \).

Příklad 1:

Vstup: n = 10, m = 3
Výstup: 19
Vysvětlení: V daném příkladu:
- Celá čísla v rozmezí [1, 10], která nejsou dělitelná 3, jsou [1,2,4,5,7,8,10], num1 je součet těchto čísel = 37.
- Celá čísla v rozmezí [1, 10], která jsou dělitelná 3, jsou [3,6,9], num2 je součet těchto čísel = 18.
Vrátíme 37 - 18 = 19 jako odpověď.

Příklad 2:

Vstup: n = 5, m = 6
Výstup: 15
Vysvětlení: V daném příkladu:
- Celá čísla v rozmezí [1, 5], která nejsou dělitelná 6, jsou [1,2,3,4,5], num1 je součet těchto čísel = 15.
- Celá čísla v rozmezí [1, 5], která jsou dělitelná 6, jsou [], num2 je součet těchto čísel = 0.
Vrátíme 15 - 0 = 15 jako odpověď.

Příklad 3:

Vstup: n = 5, m = 1
Výstup: -15
Vysvětlení: V daném příkladu:
- Celá čísla v rozmezí [1, 5], která nejsou dělitelná 1, jsou [], num1 je součet těchto čísel = 0.
- Celá čísla v rozmezí [1, 5], která jsou dělitelná 1, jsou [1,2,3,4,5], num2 je součet těchto čísel = 15.
Vrátíme 0 - 15 = -15 jako odpověď.

Omezení:

1 <= n, m <= 1000


Máte binární řetězec s s 0-indexováním, který má sudou délku.
Řetězec je krásný, pokud je možné jej rozdělit na jednu nebo více podřetězců tak, že:

Každý podřetězec má sudou délku.
Každý podřetězec obsahuje pouze 1 nebo pouze 0.

Můžete změnit libovolný znak v s na 0 nebo 1.
Vraťte minimální počet změn potřebných k tomu, aby byl řetězec s krásný.

Příklad 1:

Vstup: s = "1001"
Výstup: 2
Vysvětlení: Změníme s[1] na 1 a s[3] na 0, abychom získali řetězec "1100".
Je vidět, že řetězec "1100" je krásný, protože jej můžeme rozdělit na "11|00".
Lze dokázat, že 2 je minimální počet změn potřebných k tomu, aby byl řetězec krásný.

Příklad 2:

Vstup: s = "10"
Výstup: 1
Vysvětlení: Změníme s[1] na 1, abychom získali řetězec "11".
Je vidět, že řetězec "11" je krásný, protože jej můžeme rozdělit na "11".
Lze dokázat, že 1 je minimální počet změn potřebných k tomu, aby byl řetězec krásný.

Příklad 3:

Vstup: s = "0000"
Výstup: 0
Vysvětlení: Není třeba provádět žádné změny, protože řetězec "0000" je již krásný.

Omezení:

2 <= s.length <= 10^5
s má sudou délku.
s[i] je buď '0' nebo '1'.

Je dán binární řetězec s indexem 0 a sudou délkou.
Řetězec je krásný, pokud je možné jej rozdělit na jeden nebo více podřetězců tak, že:

Každý podřetězec má sudou délku.
Každý podřetězec obsahuje pouze jedničky nebo pouze nuly.

Každý znak v s lze změnit na 0 nebo 1.
Vraťte minimální počet změn potřebných ke krásný řetězce s.

Příklad 1:

Vstup: s = „1001“
Výstup: 2
Vysvětlení: Změníme s[1] na 1 a s[3] na 0, abychom získali řetězec „1100“.
Je vidět, že řetězec „1100“ je krásný, protože ho můžeme rozdělit na „11|00“.
Lze dokázat, že 2 je minimální počet změn potřebných k tomu, aby byl řetězec krásný.

Příklad 2:

Vstup: s = „10“
Výstup: 1
Vysvětlení: Změníme s[1] na 1, abychom získali řetězec „11“.
Je vidět, že řetězec „11“ je krásný, protože ho můžeme rozdělit na „11“.
Lze dokázat, že 1 je minimální počet změn potřebných k tomu, aby byl řetězec krásný.

Příklad 3:

Vstup: s = „0000“
Výstup: 0
Vysvětlení: Není třeba provádět žádné změny, protože řetězec „0000“ je již krásný.

Omezení:

2 <= s.length <= 10^5
s má sudou délku.
s[i] je buď '0', nebo '1'.

Dostanete binární řetězec s indexem 0, který má sudou délku.
Řetězec je krásný, pokud je možné jej rozdělit na jeden nebo více podřetězců tak, že:

Každý podřetězec má sudou délku.
Každý podřetězec obsahuje pouze 1 nebo pouze 0.

Libovolný znak v s můžete změnit na 0 nebo 1.
Vraťte minimální počet změn potřebných k tomu, aby byl řetězec krásný.

Příklad 1:

Vstup: s = "1001"
Výstup: 2
Vysvětlení: Změníme s[1] na 1 a s[3] na 0, abychom dostali řetězec "1100".
Je vidět, že řetězec "1100" je krásný, protože jej můžeme rozdělit na "11|00".
Lze prokázat, že 2 je minimální počet změn potřebných k tomu, aby byl řetězec krásný.

Příklad 2:

Vstup: s = "10"
Výstup: 1
Vysvětlení: Změníme s[1] na 1, abychom dostali řetězec "11".
Je vidět, že řetězec "11" je krásný, protože jej můžeme rozdělit na "11".
Lze prokázat, že 1 je minimální počet změn potřebných k tomu, aby byl řetězec krásný.

Příklad 3:

Vstup: s = "0000"
Výstup: 0
Vysvětlení: Nemusíme provádět žádné změny, protože řetězec "0000" je již krásný.

Omezení:

2 <= s.length <= 10^5
s má sudou délku.
s[i] je buď '0' nebo '1'.


Máte zadané pole nums s indexy začínajícími od 0, které obsahuje celá čísla.
Trojice indexů (i, j, k) je horská, pokud:

i < j < k
nums[i] < nums[j] a nums[k] < nums[j]

Vrátit minimální možnou sumu horské trojice v nums. Pokud taková trojice neexistuje, vraťte -1.

Příklad 1:

Vstup: nums = [8,6,1,5,3]
Výstup: 9
Vysvětlení: Trojice (2, 3, 4) je horská trojice se součtem 9, protože:
- 2 < 3 < 4
- nums[2] < nums[3] a nums[4] < nums[3]
A součet této trojice je nums[2] + nums[3] + nums[4] = 9. Může být prokázáno, že neexistují horské trojice s menším součtem než 9.

Příklad 2:

Vstup: nums = [5,4,8,7,10,2]
Výstup: 13
Vysvětlení: Trojice (1, 3, 5) je horská trojice se součtem 13, protože:
- 1 < 3 < 5
- nums[1] < nums[3] a nums[5] < nums[3]
A součet této trojice je nums[1] + nums[3] + nums[5] = 13. Může být prokázáno, že neexistují horské trojice s menším součtem než 13.

Příklad 3:

Vstup: nums = [6,5,4,3,4,5]
Výstup: -1
Vysvětlení: Může být prokázáno, že neexistují horské trojice v nums.

Podmínky:

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

Dostanete 0-indexované pole s počtem celých čísel.
Trojice indexů (i, j, k) je hora, pokud:

i < j < k
nums[i] < nums[j] a nums[k] < nums[j]

Vraťte minimální možný součet trojice horských čísel. Pokud žádný takový triplet neexistuje, vraťte -1.

Příklad 1:

Vstup: nums = [8,6,1,5,3]
Výstup: 9
Vysvětlení: Trojice (2, 3, 4) je horská trojice se součtem 9, protože:
- 2 < 3 < 4
- nums[2] < nums[3] a nums[4] < nums[3]
A součet této trojice je nums[2] + nums[3] + nums[4] = 9. Lze ukázat, že neexistují žádné horské trojice se součtem menším než 9.

Příklad 2:

Vstup: nums = [5,4,8,7,10,2]
Výstup: 13
Vysvětlení: Trojice (1, 3, 5) je horská trojice o součtu 13, protože:
- 1 < 3 < 5
- nums[1] < nums[3] a nums[5] < nums[3]
A součet této trojice je nums[1] + nums[3] + nums[5] = 13. Lze ukázat, že neexistují žádné horské trojice se součtem menším než 13.

Příklad 3:

Vstup: nums = [6,5,4,3,4,5]
Výstup: -1
Vysvětlení: Lze prokázat, že v nums nejsou žádná horská trojčata.

Omezení:

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


Je zadáno pole celočíselných čísel s indexem 0 a celé číslo k.
K-or z nums je nezáporné celé číslo, které splňuje následující podmínky:

i^tý bit je v K-or nastaven tehdy a jen tehdy, když existuje alespoň k prvků nums, v nichž je nastaven bit i.

Vraťte K-or z nums.
Všimněte si, že bit i je nastaven v x, jestliže (2^i AND x) == 2^i, kde AND je operátor bitové operace AND.

Příklad 1:

Vstup: nums = [7,12,9,8,9,15], k = 4
Výstup: 9
Vysvětlení: Bit 0 je nastaven na nums[0], nums[2], nums[4] a nums[5].
Bit 1 je nastaven na nums[0] a nums[5].
Bit 2 je nastaven na nums[0], nums[1] a nums[5].
Bit 3 je nastaven na nums[1], nums[2], nums[3], nums[4] a nums[5].
Pouze bity 0 a 3 jsou nastaveny alespoň v k prvcích pole a bity i >= 4 nejsou nastaveny v žádném z prvků pole. Proto je odpověď 2^0 + 2^3 = 9.

Příklad 2:

Vstup: nums = [2,12,1,11,4,5], k = 6
Výstup: 0
Vysvětlení: Protože k == 6 == nums.length, je 6-or pole rovno bitovému AND všech jeho prvků. Proto je odpověď 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Příklad 3:

Vstup: nums = [10,8,5,9,11,6,8], k = 1
Výstup: 15
Vysvětlení: Protože k == 1, je 1-or pole rovno bitovému OR všech jeho prvků. Proto je odpověď 10 NEBO 8 NEBO 5 NEBO 9 NEBO 11 NEBO 6 NEBO 8 = 15.

Omezení:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length

Dostanete 0-indexované celočíselné pole nums a celé číslo k.
K-nebo nums je nezáporné celé číslo, které splňuje následující:

I^-tý bit je nastaven v K-nebo právě tehdy, když existuje alespoň k prvků nums, ve kterých je nastaven bit i.

Vraťte K-nebo čísel.
Všimněte si, že bit i je nastaven v x pokud (2^i AND x) == 2^i. kde AND je bitový operátor AND.

Příklad 1:

Vstup: nums = [7,12,9,8,9,15], k = 4
Výstup: 9
Vysvětlení: Bit 0 je nastaven na nums[0], nums[2], nums[4] a nums[5].
Bit 1 je nastaven na nums[0] a nums[5].
Bit 2 je nastaven na nums[0], nums[1] a nums[5].
Bit 3 je nastaven na nums[1], nums[2], nums[3], nums[4] a nums[5].
Pouze bity 0 a 3 jsou nastaveny v alespoň k prvcích pole a bity i >= 4 nejsou nastaveny v žádném z prvků pole. Odpověď je tedy 2^0 + 2^3 = 9.

Příklad 2:

Vstup: nums = [2,12,1,11,4,5], k = 6
Výstup: 0
Vysvětlení: Protože k == 6 == nums.length, 6-nebo pole je rovno bitovému AND všech jeho prvků. Odpověď je tedy 2 A 12 A 1 A 11 A 4 A 5 = 0.

Příklad 3:

Vstup: nums = [10,8,5,9,11,6,8], k = 1
Výstup: 15
Vysvětlení: Protože k == 1, 1-nebo pole se rovná bitovému OR všech jeho prvků. Odpověď je tedy 10 NEBO 8 NEBO 5 NEBO 9 NEBO 11 NEBO 6 NEBO 8 = 15.

Omezení:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= počty.length

Je vám zadáno celé pole indexované číslem 0 a celé číslo k.
K-or čísel je nezáporné celé číslo, které splňuje následující podmínky:

i^-tý bit je nastaven v K-or právě tehdy, když existuje alespoň k prvků nums, ve kterých je bit i nastaven.

Vrátí hodnotu K-nebo čísel.
Všimněte si, že bit i je nastaven v x if (2^i AND x) == 2^i, kde AND je bitový operátor AND.

Příklad 1:

Vstup: nums = [7,12,9,8,9,15], k = 4
Výstup: 9
Vysvětlení: Bit 0 je nastaven na nums[0], nums[2], nums[4] a nums[5].
Bit 1 je nastaven na nums[0] a nums[5].
Bit 2 je nastaven na nums[0], nums[1] a nums[5].
Bit 3 je nastaven na nums[1], nums[2], nums[3], nums[4] a nums[5].
Pouze bity 0 a 3 jsou nastaveny alespoň v k prvcích pole a bity i >= 4 nejsou nastaveny v žádném z prvků pole. Odpověď je tedy 2^0 + 2^3 = 9.

Příklad 2:

Vstup: nums = [2,12,1,11,4,5], k = 6
Výstup: 0
Vysvětlení: Protože k == 6 == nums.length, 6-or pole se rovná bitovému AND všech jeho prvků. Výsledek je tedy 2 A 12 A 1 A 11 A 4 A 5 = 0.

Příklad 3:

Vstup: nums = [10,8,5,9,11,6,8], k = 1
Výstup: 15
Vysvětlení: Protože k == 1, 1-or pole se rovná bitovému OR všech jeho prvků. Odpověď je tedy 10 NEBO 8 NEBO 5 NEBO 9 NEBO 11 NEBO 6 NEBO 8 = 15.

Omezení:

1 <= nums.length <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.length


Dostanete pole celých čísel s indexem 0.
Podposloupnost nums, která má délku k a skládá se z indexů i_0 < i_1 < ... < i_k-1, je vyvážená, pokud platí: nums[i_j] - nums[i_j-1] >= i_j - i_j-1, pro každé j v rozsahu [1, k - 1].

Podposloupnost čísel mající délku 1 je považována za vyváženou.
Vrátíte celé číslo, které označuje maximální možný součet prvků ve vyvážené podposloupnosti čísel.
Podposloupnost pole je nové neprázdné pole, které je vytvořeno z původního pole odstraněním některých (možná žádných) prvků, aniž by došlo k narušení relativních pozic zbývajících prvků.

Příklad 1:

Vstup: nums = [3,3,5,6]
Výstup: 14
Vysvětlení: V tomto příkladu lze vybrat podsekvenci [3,5,6] skládající se z indexů 0, 2 a 3.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Jedná se tedy o vyváženou podposloupnost a její součet je maximální mezi vyváženými podposloupnostmi čísel.
Platná je také podposloupnost skládající se z indexů 1, 2 a 3.
Lze ukázat, že není možné získat vyváženou podposloupnost s větším součtem než 14.
Příklad 2:

Vstup: nums = [5,-1,-3,8]
Výstup: 13
Vysvětlení: V tomto příkladu lze vybrat podposloupnost [5,8] skládající se z indexů 0 a 3.
nums[3] - nums[0] >= 3 - 0.
Jedná se tedy o vyváženou podposloupnost a její součet je maximální mezi vyváženými podposloupnostmi čísel.
Lze ukázat, že není možné získat vyváženou podposloupnost se součtem větším než 13.

Příklad 3:

Vstup: nums = [-2,-1]
Výstup: -1
Vysvětlení: V tomto příkladu lze vybrat podsekvenci [-1].
Je to vyvážená podposloupnost a její součet je maximální mezi vyváženými podposloupnostmi čísel.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums.
Dílčí posloupnost čísel o délce k sestávající z indexů i_0 < i_1 < ... < i_k-1 je vyvážená, pokud platí následující:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, pro každé j v rozsahu [1, k - 1].

Dílčí posloupnost num s délkou 1 je považována za vyváženou.
Vrátí celé číslo označující maximální možný součet prvků ve vyvážené dílčí posloupnosti čísel.
Podsekvence pole je nové neprázdné pole, které se vytvoří z původního pole odstraněním některých (možná žádných) prvků, aniž by došlo k narušení relativních pozic zbývajících prvků.

Příklad 1:

Vstup: nums = [3,3,5,6]
Výstup: 14
Vysvětlení: V tomto příkladu lze vybrat podsekvenci [3,5,6] sestávající z indexů 0, 2 a 3.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Jde tedy o vyváženou podposloupnost a její součet je maximum mezi vyváženými podposloupnostmi num.
Podposloupnost skládající se z indexů 1, 2 a 3 je rovněž platná.
Lze ukázat, že není možné získat vyváženou podposloupnost se součtem větším než 14.
Příklad 2:

Vstup: nums = [5,-1,-3,8]
Výstup: 13
Vysvětlení: V tomto příkladu lze vybrat podsekvenci [5,8] skládající se z indexů 0 a 3.
nums[3] - nums[0] >= 3 - 0.
Jde tedy o vyváženou podposloupnost a její součet je maximum mezi vyváženými podposloupnostmi num.
Lze ukázat, že není možné získat vyváženou podposloupnost se součtem větším než 13.

Příklad 3:

Vstup: nums = [-2,-1]
Výstup: -1
Vysvětlení: V tomto příkladu lze vybrat podsekvenci [-1].
Je to vyvážená podposloupnost a její součet je maximum mezi vyváženými podposloupnostmi num.

Omezení:

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

Je zadáno celočíselné pole nums s indexem 0.
Podřetězec nums má délku k a skládá se z indexů i_0 < i_1 < ... < i_k-1 je vyvážená, pokud platí následující:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, pro každé j v rozsahu [1, k - 1].

Podřetězec nums o délce 1 je považována za vyváženou.
Vraťte celé číslo označující maximální možný součet prvků ve vyvážené posloupnosti nums.
Podřetězec pole je nové neprázdné pole, které vznikne z původního pole vymazáním některých (případně žádných) prvků, aniž by se narušila relativní pozice zbývajících prvků.

Příklad 1:

Vstup: nums = [3,3,5,6]
Výstup: 14
Vysvětlení: V tomto příkladu lze vybrat posloupnost [3,5,6] složená z indexů 0, 2 a 3.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Jedná se tedy o vyváženou posloupnost a její součet je maximem mezi vyváženými posloupnostmi nums.
Platná je také podřetězec složený z indexů 1, 2 a 3.
Lze ukázat, že není možné získat vyvážený podřetězec se součtem větším než 14.
Příklad 2:

Vstup: nums = [5,-1,-3,8]
Výstup: 13
Vysvětlení: V tomto příkladu lze vybrat posloupnost [5,8] složená z indexů 0 a 3.
nums[3] - nums[0] >= 3 - 0.
Je to tedy vyvážená podřetězec a jeho součet je maximální mezi vyváženými podřetězci nums.
Lze ukázat, že nelze získat vyváženou podřetězec se součtem větším než 13.

Příklad 3:

Vstup: nums = [-2,-1]
Výstup: -1
Vysvětlení: V tomto příkladu lze vybrat následnou sekvenci [-1].
Je to vyvážený podřetězec a její součet je maximální mezi vyváženými posloupnostmi nums.

Omezení:

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


V turnaji je n týmů očíslovaných od 0 do n - 1.
Je dána 2D logická matice s indexem 0 o velikosti n * n. Pro všechna i, j, která 0 <= i, j <= n - 1 a i != j je tým i silnější než tým j, pokud grid[i][j] == 1, jinak je tým j silnější než tým i.
Tým a se stane vítězem turnaje, pokud neexistuje tým b, který by byl silnější než tým a.
Vraťte tým, který bude šampionem turnaje.

Příklad 1:

Vstup: mřížka = [[0,1],[0,0]]
Výstup: 0
Vysvětlení: V tomto turnaji jsou dva týmy.
grid[0][1] == 1 znamená, že tým 0 je silnější než tým 1. Šampionem se tedy stane tým 0.

Příklad 2:

Vstup: grid = [[0,0,1],[1,0,1],[0,0,0]].
Výstup: 1
Vysvětlení: V tomto turnaji jsou tři týmy.
grid[1][0] == 1 znamená, že tým 1 je silnější než tým 0.
grid[1][2] == 1 znamená, že tým 1 je silnější než tým 2.
Šampionem se tedy stane tým 1.

Omezení:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] je buď 0, nebo 1.
Pro všechna i je grid[i][i] 0.
Pro všechna i, j, která i != j, grid[i][j] != grid[j][i].
Vstup je generován tak, že pokud je tým a silnější než tým b a tým b je silnější než tým c, pak je tým a silnější než tým c.

V turnaji je n týmů očíslovaných od 0 do n - 1.
Je dána mřížka 2D booleovské matice indexovaná indexem 0 o velikosti n * n. Pro všechna i, j že 0 <= i, j <= n - 1 a i != j tým i je silnější než tým j if grid[i][j] == 1, jinak je tým j silnější než tým i.
Tým A se stane vítězem turnaje, pokud nebude k dispozici žádný tým B, který by byl silnější než tým A.
Vraťte tým, který se stane šampionem turnaje.

Příklad 1:

Vstup: grid = [[0,1],[0,0]]
Výstup: 0
Vysvětlení: Na tomto turnaji jsou dva týmy.
grid[0][1] == 1 znamená, že tým 0 je silnější než tým 1. Takže tým 0 bude šampionem.

Příklad 2:

Vstup: grid = [[0,0,1],[1,0,1],[0,0,0]]
Výstup: 1
Vysvětlení: V tomto turnaji jsou tři týmy.
grid[1][0] == 1 znamená, že tým 1 je silnější než tým 0.
grid[1][2] == 1 znamená, že tým 1 je silnější než tým 2.
Takže tým 1 bude šampionem.

Omezení:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] je buď 0 nebo 1.
Pro vše i grid[i][i] je 0.
Pro všechna i, j, že i != j, grid[i][j] != grid[j][i].
Vstup je generován tak, že pokud je tým a silnější než tým b a tým b je silnější než tým c, pak je tým a silnější než tým c.

Je n týmů číslovaných od 0 do n - 1 v turnaji.
Je dána 0-indexovaná 2D logická matice grid o rozměru n * n. Pro všechna i, j taková, že 0 <= i, j <= n - 1 a i != j, tým i je silnější než tým j, pokud grid[i][j] == 1, jinak je tým j silnější než tým i.
Tým a bude šampiónem turnaje, pokud neexistuje tým b, který je silnější než tým a.
Vrátí tým, který bude šampiónem turnaje.

Příklad 1:

Vstup: grid = [[0,1],[0,0]]
Výstup: 0
Vysvětlení: V tomto turnaji jsou dva týmy.
grid[0][1] == 1 znamená, že tým 0 je silnější než tým 1. Takže tým 0 bude šampiónem.

Příklad 2:

Vstup: grid = [[0,0,1],[1,0,1],[0,0,0]]
Výstup: 1
Vysvětlení: V tomto turnaji jsou tři týmy.
grid[1][0] == 1 znamená, že tým 1 je silnější než tým 0.
grid[1][2] == 1 znamená, že tým 1 je silnější než tým 2.
Takže tým 1 bude šampiónem.

Omezení:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] je buď 0 nebo 1.
Pro všechna i, grid[i][i] je 0.
Pro všechna i, j taková, že i != j, grid[i][j] != grid[j][i].
Vstup je generován tak, že pokud tým a je silnější než tým b a tým b je silnější než tým c, pak tým a je silnější než tým c.


Dostanete dvě 0-indexovaná celočíselná pole, nums1 a nums2, přičemž obě mají délku n.
Můžete provádět řadu operací (možná žádné).
V operaci vyberete index i v rozsahu [0, n - 1] a zaměníte hodnoty nums1[i] a nums2[i].
Vaším úkolem je najít minimální počet operací potřebných ke splnění následujících podmínek:

nums1[n - 1] se rovná maximální hodnotě mezi všemi prvky nums1, tj. nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]) .
nums2[n - 1] se rovná maximální hodnotě mezi všemi prvky nums2, tj. nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]) .

Vraťte celé číslo označující minimální počet operací potřebných ke splnění obou podmínek, nebo -1, pokud není možné splnit obě podmínky.

Příklad 1:

Vstup: nums1 = [1,2,7], nums2 = [4,5,3]
Výstup: 1
Vysvětlení: V tomto příkladu lze operaci provést pomocí indexu i = 2.
Když jsou nums1[2] a nums2[2] prohozeny, nums1 se změní na [1,2,3] a nums2 se změní na [4,5,7].
Obě podmínky jsou nyní splněny.
Lze ukázat, že minimální počet operací, které je třeba provést, je 1.
Takže odpověď je 1.

Příklad 2:

Vstup: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Výstup: 2
Vysvětlení: V tomto příkladu lze provést následující operace:
První operace s indexem i = 4.
Když jsou nums1[4] a nums2[4] prohozeny, nums1 se změní na [2,3,4,5,4] a nums2 se změní na [8,8,4,4,9].
Další operace s indexem i = 3.
Když jsou nums1[3] a nums2[3] prohozeny, nums1 se změní na [2,3,4,4,4] a nums2 se změní na [8,8,4,5,9].
Obě podmínky jsou nyní splněny.
Lze ukázat, že minimální počet operací, které je třeba provést, jsou 2.
Takže odpověď je 2.

Příklad 3:

Vstup: nums1 = [1,5,4], nums2 = [2,5,3]
Výstup: -1
Vysvětlení: V tomto příkladu není možné splnit obě podmínky.
Takže odpověď je -1.

Omezení:

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

Máte dva celočíselné pole s 0-indexem, nums1 a nums2, obě mají délku n.
Je povoleno provádět řadu operací (možná žádné).
Při jedné operaci vyberete index i v rozsahu [0, n - 1] a prohodíte hodnoty nums1[i] a nums2[i].
Vaším úkolem je najít minimální počet operací potřebných k uspokojení následujících podmínek:

nums1[n - 1] je rovno maximální hodnotě mezi všemi prvky nums1, tj. nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] je rovno maximální hodnotě mezi všemi prvky nums2, tj. nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Vrátit celé číslo označující minimální počet operací potřebných k splnění obou podmínek, nebo -1, pokud není možné obě podmínky splnit.

Příklad 1:

Vstup: nums1 = [1,2,7], nums2 = [4,5,3]
Výstup: 1
Vysvětlení: V tomto příkladu lze provést operaci pomocí indexu i = 2.
Když nums1[2] a nums2[2] prohodíme, nums1 se stane [1,2,3] a nums2 se stane [4,5,7].
Obě podmínky jsou nyní splněny.
Lze ukázat, že minimální počet operací potřebných k provedení je 1.
Takže odpověď je 1.

Příklad 2:

Vstup: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Výstup: 2
Vysvětlení: V tomto příkladu lze provést následující operace:
První operace pomocí indexu i = 4.
Když nums1[4] a nums2[4] prohodíme, nums1 se stane [2,3,4,5,4], a nums2 se stane [8,8,4,4,9].
Další operace pomocí indexu i = 3.
Když nums1[3] a nums2[3] prohodíme, nums1 se stane [2,3,4,4,4], a nums2 se stane [8,8,4,5,9].
Obě podmínky jsou nyní splněny.
Lze ukázat, že minimální počet operací potřebných k provedení je 2.
Takže odpověď je 2.

Příklad 3:

Vstup: nums1 = [1,5,4], nums2 = [2,5,3]
Výstup: -1
Vysvětlení: V tomto příkladu není možné splnit obě podmínky.
Takže odpověď je -1.

Omezení:

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

Jsou vám dána dvě 0-indexovaná celočíselná pole, nums1 a nums2, přičemž obě mají délku n.
Můžete provádět řadu operací (možná žádné).
V operaci vyberete index i v rozsahu [0, n - 1] a zaměníte hodnoty nums1[i] a nums2[i].
Vaším úkolem je najít minimální počet operací potřebných ke splnění následujících podmínek:

nums1[n - 1] se rovná maximální hodnotě mezi všemi prvky nums1, tj. nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]) .
nums2[n - 1] se rovná maximální hodnotě mezi všemi prvky nums2, tj. nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]) .

Vraťte celé číslo označující minimální počet operací potřebných ke splnění obou podmínek, nebo -1, pokud není možné splnit obě podmínky.

Příklad 1:

Vstup: nums1 = [1,2,7], nums2 = [4,5,3]
Výstup: 1
Vysvětlení: V tomto příkladu lze operaci provést pomocí indexu i = 2.
Když jsou nums1[2] a nums2[2] prohozeny, nums1 se změní na [1,2,3] a nums2 se změní na [4,5,7].
Obě podmínky jsou nyní splněny.
Lze ukázat, že minimální počet operací, které je třeba provést, je 1.
Takže odpověď je 1.

Příklad 2:

Vstup: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Výstup: 2
Vysvětlení: V tomto příkladu lze provést následující operace:
První operace s indexem i = 4.
Když jsou nums1[4] a nums2[4] prohozeny, nums1 se změní na [2,3,4,5,4] a nums2 se změní na [8,8,4,4,9].
Další operace s indexem i = 3.
Když jsou nums1[3] a nums2[3] prohozeny, nums1 se změní na [2,3,4,4,4] a nums2 se změní na [8,8,4,5,9].
Obě podmínky jsou nyní splněny.
Lze ukázat, že minimální počet operací, které je třeba provést, jsou 2.
Takže odpověď je 2.

Příklad 3:

Vstup: nums1 = [1,5,4], nums2 = [2,5,3]
Výstup: -1
Vysvětlení: V tomto příkladu není možné splnit obě podmínky.
Takže odpověď je -1.

Omezení:

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


Jsou-li dána tři celá čísla a, b a n, vrátí maximální hodnotu (a XOR x) * (b XOR x), kde 0 <= x < 2^n.
Protože odpověď může být příliš velká, vraťte ji modulo 10^9 + 7.
Všimněte si, že XOR je bitová operace XOR.

Příklad 1:

Vstup: a = 12, b = 5, n = 4
Výstup: 98
Vysvětlení: Pro x = 2, (a XOR x) = 14 a (b XOR x) = 7. Tedy (a XOR x) * (b XOR x) = 98.
Lze ukázat, že 98 je maximální hodnota (a XOR x) * (b XOR x) pro všechna 0 <= x < 2^n.

Příklad 2:

Vstup: a = 6, b = 7, n = 5
Výstup: 930
Vysvětlení: Pro x = 25, (a XOR x) = 31 a (b XOR x) = 30. Tedy (a XOR x) * (b XOR x) = 930.
Lze ukázat, že 930 je maximální hodnota (a XOR x) * (b XOR x) pro všechna 0 <= x < 2^n.
Příklad 3:

Vstup: a = 1, b = 6, n = 3
Výstup: 12
Vysvětlení: Pro x = 5, (a XOR x) = 4 a (b XOR x) = 3. Tedy (a XOR x) * (b XOR x) = 12.
Lze ukázat, že 12 je maximální hodnota (a XOR x) * (b XOR x) pro všechna 0 <= x < 2^n.

Omezení:

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

Při zadání tří celých čísel a, b a n vrátí maximální hodnotu (a XOR x) * (b XOR x), kde 0 <= x < 2^n.
Protože odpověď může být příliš velká, vraťte ji modulo 10^9 + 7.
Všimněte si, že XOR je bitová operace XOR.

Příklad 1:

Vstup: a = 12, b = 5, n = 4
Výstup: 98
Vysvětlení: Pro x = 2, (a XOR x) = 14 a (b XOR x) = 7. Tedy (a XOR x) * (b XOR x) = 98.
Lze ukázat, že 98 je maximální hodnota (a XOR x) * (b XOR x) pro všechny 0 <= x < 2^n.

Příklad 2:

Vstup: a = 6, b = 7, n = 5
Výstup: 930
Vysvětlení: Pro x = 25, (a XOR x) = 31 a (b XOR x) = 30. Tedy (a XOR x) * (b XOR x) = 930.
Lze ukázat, že 930 je maximální hodnota (a XOR x) * (b XOR x) pro všechny 0 <= x < 2^n.
Příklad 3:

Vstup: a = 1, b = 6, n = 3
Výstup: 12
Vysvětlení: Pro x = 5, (a XOR x) = 4 a (b XOR x) = 3. Tedy (a XOR x) * (b XOR x) = 12.
Lze ukázat, že 12 je maximální hodnota (a XOR x) * (b XOR x) pro všechny 0 <= x < 2^n.

Omezení:

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

Při zadání tří celých čísel a, b a n vraťte maximální hodnotu (a XOR x) * (b XOR x), kde 0 <= x < 2^n.
Protože odpověď může být příliš velká, vraťte ji modulo 10^9 + 7.
Všimněte si, že XOR je bitová operace XOR.

Příklad 1:

Vstup: a = 12, b = 5, n = 4
Výstup: 98
Vysvětlení: Pro x = 2 platí, že (a XOR x) = 14 a (b XOR x) = 7. Proto (a XOR x) * (b XOR x) = 98.
Lze prokázat, že 98 je maximální hodnota (a XOR x) * (b XOR x) pro všechny 0 <= x < 2^n.

Příklad 2:

Vstup: a = 6, b = 7 , n = 5
Výstup: 930
Vysvětlení: Pro x = 25, (a XOR x) = 31 a (b XOR x) = 30. Proto (a XOR x) * (b XOR x) = 930.
Lze ukázat, že 930 je maximální hodnota (a XOR x) * (b XOR x) pro všechny 0 <= x < 2^n.
Příklad 3:

Vstup: a = 1, b = 6, n = 3
Výstup: 12
Vysvětlení: Pro x = 5, (a XOR x) = 4 a (b XOR x) = 3. Proto (a XOR x) * (b XOR x) = 12.
Lze ukázat, že 12 je maximální hodnota (a XOR x) * (b XOR x) pro všechny 0 <= x < 2^n.

Omezení:

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


Máte zadané celočíselné pole nums s indexováním od nuly. Dvojice celých čísel x a y se nazývá silná dvojice, pokud splňuje podmínku:

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

Musíte vybrat dvě celá čísla z nums tak, aby tvořila silnou dvojici a jejich bitový XOR byl maximální mezi všemi silnými dvojicemi v poli.
Vraťte maximální hodnotu XOR ze všech možných silných dvojic v poli nums.
Všimněte si, že můžete vytvořit dvojici i se stejným celým číslem dvakrát.

Příklad 1:

Vstup: nums = [1,2,3,4,5]
Výstup: 7
Vysvětlení: V poli nums je 11 silných dvojic: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) a (5, 5).
Maximální možný XOR z těchto dvojic je 3 XOR 4 = 7.

Příklad 2:

Vstup: nums = [10,100]
Výstup: 0
Vysvětlení: V poli nums jsou 2 silné dvojice: (10, 10) a (100, 100).
Maximální možný XOR z těchto dvojic je 10 XOR 10 = 0, jelikož dvojice (100, 100) také dává 100 XOR 100 = 0.

Příklad 3:

Vstup: nums = [5,6,25,30]
Výstup: 7
Vysvětlení: V poli nums je 6 silných dvojic: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) a (30, 30).
Maximální možný XOR z těchto dvojic je 25 XOR 30 = 7, protože jiná nenulová hodnota XOR je 5 XOR 6 = 3.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums. Dvojice celých čísel x a y se nazývá silná dvojice, pokud splňuje podmínku:

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

Musíte vybrat dvě celá čísla z čísel tak, aby tvořila silný pár a jejich bitové XOR bylo maximum ze všech silných párů v poli.
Vraťte maximální hodnotu XOR ze všech možných silných párů v poli nums.
Všimněte si, že můžete vybrat stejné celé číslo dvakrát a vytvořit pár.

Příklad 1:

Vstup: nums = [1,2,3,4,5]
Výstup: 7
Vysvětlení: V poli čísel je 11 silných párů: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3 , 4), (3, 5), (4, 4), (4, 5) a (5, 5).
Maximální možný XOR z těchto párů je 3 XOR 4 = 7.

Příklad 2:

Vstup: nums = [10 100]
Výstup: 0
Vysvětlení: V poli čísel jsou 2 silné páry: (10, 10) a (100, 100).
Maximální možný XOR z těchto párů je 10 XOR 10 = 0, protože pár (100, 100) také dává 100 XOR 100 = 0.

Příklad 3:

Vstup: nums = [5,6,25,30]
Výstup: 7
Vysvětlení: V poli čísel je 6 silných párů: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) a (30, 30).
Maximální možný XOR z těchto párů je 25 XOR 30 = 7, protože jediná další nenulová hodnota XOR je 5 XOR 6 = 3.

Omezení:

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


Je zadáno pole řetězců slov s indexem 0 a znak x.
Vraťte pole indexů představující slova, která obsahují znak x.
Všimněte si, že vrácené pole může být v libovolném pořadí.

Příklad 1:

Vstup: words = [„leet“, „code“], x = „e“
Výstup: [0,1]
Vysvětlení: „e“ se vyskytuje v obou slovech: „leet“ i ‚code‘. Proto vracíme indexy 0 a 1.

Příklad 2:

Vstup: slova = [„abc“, „bcd“, „aaaa“, „cbc“], x = „a“
Výstup: [0,2]
Vysvětlení: „a“ se vyskytuje ve slovech ‚abc‘ a ‚aaaa‘. Proto vracíme indexy 0 a 2.

Příklad 3:

Vstup: slova = [„abc“, „bcd“, „aaaa“, „cbc“], x = „z“
Výstup: []
Vysvětlení: „z“ se nevyskytuje v žádném ze slov. Proto vracíme prázdné pole.

Omezení:

1 <= words.length <= 50
1 <= words[i].length <= 50
x je malé anglické písmeno.
Slova[i] se skládají pouze z malých anglických písmen.

Je zadáno pole řetězců slov s indexem 0 a znak x.
Vraťte pole indexů představující slova, která obsahují znak x.
Všimněte si, že vrácené pole může být v libovolném pořadí.

Příklad 1:

Vstup: words = [„leet“, "code“], x = „e“
Výstup: [0,1]
Vysvětlení: "e“ se vyskytuje v obou slovech: "leet“ i ‚code‘. Proto vracíme indexy 0 a 1.

Příklad 2:

Vstup: slova = ["abc“, "bcd“, "aaaa“, "cbc“], x = "a“
Výstup: [0,2]
Vysvětlení: "a“ se vyskytuje ve slovech ‚abc‘ a ‚aaaa‘. Proto vracíme indexy 0 a 2.

Příklad 3:

Vstup: slova = ["abc“, "bcd“, "aaaa“, "cbc“], x = "z“
Výstup: []
Vysvětlení: "z“ se nevyskytuje v žádném ze slov. Proto vracíme prázdné pole.

Omezení:

1 <= words.length <= 50
1 <= words[i].length <= 50
x je malé anglické písmeno.
Slova[i] se skládají pouze z malých anglických písmen.

Máte 0-indexované pole řetězců `words` a znak `x`.
Vrátí pole indexů slov reprezentujících slova, která obsahují znak `x`.
oznámka:, že vrácené pole může být v libovolném pořadí.

Příklad 1:

Vstup: words = ["leet","code"], x = "e"
Výstup: [0,1]
Vysvětlení: "e" se vyskytuje v obou slovech: "leet" a "code". Proto vrátíme indexy 0 a 1.

Příklad 2:

Vstup: words = ["abc","bcd","aaaa","cbc"], x = "a"
Výstup: [0,2]
Vysvětlení: Znak `"a"` se vyskytuje v obou slovech: `"leet"` a `"code"`. Proto vracíme indexy 0 a 1.

Příklad 3:

Vstup: words = ["abc","bcd","aaaa","cbc"], x = "z"
Výstup: []
Vysvětlení: "z" se nevyskytuje v žádném ze slov. Proto vrátíme prázdné pole.

Omezení:

1 ≤ `words.length` ≤ 50
1 ≤ `words[i].length` ≤ 50
`x` je malým písmenem anglické abecedy.
`words[i]` obsahuje pouze malá písmena anglické abecedy.


Na stole je n kuliček, každá koule má černou nebo bílou barvu.
Dostanete binární řetězec s indexovaný 0 o délce n, kde 1 a 0 představují černé a bílé koule.
V každém kroku si můžete vybrat dvě sousední koule a prohodit je.
Vraťte se o minimální počet kroků, abyste seskupili všechny černé koule doprava a všechny bílé koule doleva.

Příklad 1:

Vstup: s = "101"
Výstup: 1
Vysvětlení: Všechny černé koule můžeme seskupit napravo následujícím způsobem:
- Zaměňte s[0] a s[1], s = "011".
Zpočátku nejsou jedničky seskupeny, k jejich seskupení doprava je potřeba alespoň 1 krok.
Příklad 2:

Vstup: s = "100"
Výstup: 2
Vysvětlení: Všechny černé koule můžeme seskupit vpravo následujícím způsobem:
- Zaměňte s[0] a s[1], s = "010".
- Zaměňte s[1] a s[2], s = "001".
Lze prokázat, že minimální počet potřebných kroků je 2.

Příklad 3:

Vstup: s = "0111"
Výstup: 0
Vysvětlení: Všechny černé koule jsou již seskupeny vpravo.

Omezení:

1 <= n == s.length <= 10^5
s[i] je buď '0' nebo '1'.

Na stole je n kuliček, každá kulička má černou nebo bílou barvu.
Je dán binární řetězec s indexem 0 o délce n, kde 1 a 0 představují černou, resp. bílou kouli.
V každém kroku můžete vybrat dvě sousední kuličky a vyměnit je.
Vraťte minimální počet kroků, aby se všechny černé kuličky seskupily vpravo a všechny bílé vlevo.

Příklad 1:

Vstup: s ="101"
Výstup: 1
Vysvětlení: Všechny černé kuličky můžeme seskupit doprava následujícím způsobem:
- Vyměňte s[0] a s[1], s = "011".
Zpočátku nejsou jedničky seskupeny dohromady, což vyžaduje alespoň 1 krok k jejich seskupení doprava.
Příklad 2:

Vstup: s ="100"
Výstup: 2
Vysvětlení: Všechny černé kuličky můžeme seskupit doprava následujícím způsobem:
- Vyměňte s[0] a s[1], s =  "010".
- Prohoďte s[1] a s[2], s ="001“.
Lze dokázat, že minimální počet potřebných kroků je 2.

Příklad 3:

Vstup: s ="0111"
Výstup: 0
Vysvětlení: Všechny černé kuličky jsou již seskupeny vpravo.

Omezení:

1 <= n == s.length <= 10^5
s[i] je buď '0', nebo '1'.

Na stole je n kuliček, každá kulička má černou nebo bílou barvu.
Je dán binární řetězec s indexem 0 o délce n, kde 1 a 0 představují černou, resp. bílou kouli.
V každém kroku můžete vybrat dvě sousední kuličky a vyměnit je.
Vraťte minimální počet kroků, aby se všechny černé kuličky seskupily vpravo a všechny bílé vlevo.

Příklad 1:

Vstup: s = „101“
Výstup: 1
Vysvětlení: Všechny černé kuličky můžeme seskupit doprava následujícím způsobem:
- Swap s[0] a s[1], s = „011“.
Zpočátku nejsou jedničky seskupeny dohromady, což vyžaduje alespoň 1 krok k jejich seskupení doprava.
Příklad 2:

Vstup: s = „100“
Výstup: 2
Vysvětlení: Všechny černé kuličky můžeme seskupit doprava následujícím způsobem:
- Swap s[0] a s[1], s = „010“.
- Swap s[1] a s[2], s = „001“.
Lze dokázat, že minimální počet potřebných kroků je 2.

Příklad 3:

Vstup: s = „0111“
Výstup: 0
Vysvětlení: Všechny černé kuličky jsou již seskupeny vpravo.

Omezení:

1 <= n == s.length <= 10^5
s[i] je buď '0', nebo '1'.


Máte dané celočíselné pole `nums` s nulovým indexováním a celé číslo `k`.
Na poli můžete provést následující operaci nejvýše `k`krát:

Vyberte libovolný index `i` z pole a zvyšte nebo snižte hodnotu `nums[i]` o 1.

Skóre výsledného pole je četnost nejčastějšího prvku v poli.
Vraťte maximální skóre, kterého můžete dosáhnout.
Četnost prvku je počet jeho výskytů v poli.

Příklad 1:

Vstup: nums = [1,2,6,4], k = 3
Výstup: 3
Vysvětlení: Můžeme provést následující operace na poli:
- Vyberte `i = 0` a zvýšte hodnotu `nums[0]` o 1. Výsledné pole je [2,2,6,4].
- Vyberte `i = 3` a snižte hodnotu `nums[3]` o 1. Výsledné pole je [2,2,6,3].
- Vyberte `i = 3` a snižte hodnotu `nums[3]` o 1. Výsledné pole je [2,2,6,2].
Prvek 2 je nejčastější ve finálním poli, takže naše skóre je 3.
Lze ukázat, že nelze dosáhnout lepšího skóre.

Příklad 2:

Vstup: nums = [1,4,4,2,4], k = 0
Výstup: 3
Vysvětlení: Nemůžeme aplikovat žádné operace, takže naše skóre bude frekvence nejčastějšího prvku v původním poli, což je 3.

Omezení:

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

Je vám zadáno celé pole s indexem 0, nums a celé číslo k.
Na poli můžete provést následující operaci nanejvýš v k-krát:

Vyberte libovolný index i z pole a zvyšte nebo snižte nums[i] o 1.

Skóre výsledného pole je frekvence nejfrekventovanějšího prvku v poli.
Vraťte maximální skóre, kterého můžete dosáhnout.
Frekvence prvku je počet výskytů tohoto prvku v poli.

Příklad 1:

Vstup: nums = [1,2,6,4], k = 3
Výstup: 3
Vysvětlení: S polem můžeme provádět následující operace:
- Zvolte i = 0 a zvyšte hodnotu nums[0] o 1. Výsledné pole je [2,2,6,4].
- Zvolte i = 3 a snižte hodnotu nums[3] o 1. Výsledné pole je [2,2,6,3].
- Zvolte i = 3 a snižte hodnotu nums[3] o 1. Výsledné pole je [2,2,6,2].
Prvek 2 je ve výsledném poli nejčastější, takže naše skóre je 3.
Dá se ukázat, že lepšího skóre dosáhnout nemůžeme.

Příklad 2:

Vstup: nums = [1,4,4,2,4], k = 0
Výstup: 3
Vysvětlení: Nemůžeme použít žádné operace, takže naše skóre bude frekvence nejčastějšího prvku v původním poli, což je 3.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums a celé číslo k.
Následující operaci můžete na poli provést nejvýše kkrát:

Vyberte libovolný index i z pole a zvyšte nebo snižte num[i] o 1.

Skóre konečného pole je frekvence nejčastějšího prvku v poli.
Vraťte maximální skóre, kterého můžete dosáhnout.
Frekvence prvku je počet výskytů tohoto prvku v poli.

Příklad 1:

Vstup: nums = [1,2,6,4], k = 3
Výstup: 3
Vysvětlení: S polem můžeme provádět následující operace:
- Zvolte i = 0 a zvyšte hodnotu nums[0] o 1. Výsledné pole je [2,2,6,4].
- Zvolte i = 3 a snižte hodnotu nums[3] o 1. Výsledné pole je [2,2,6,3].
- Zvolte i = 3 a snižte hodnotu nums[3] o 1. Výsledné pole je [2,2,6,2].
Prvek 2 je v konečném poli nejčastější, takže naše skóre je 3.
Dá se ukázat, že lepšího skóre dosáhnout nemůžeme.

Příklad 2:

Vstup: nums = [1,4,4,2,4], k = 0
Výstup: 3
Vysvětlení: Nemůžeme použít žádné operace, takže naše skóre bude frekvence nejčastějšího prvku v původním poli, což je 3.

Omezení:

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


Jsou vám dána dvě kladná celá čísla n a limit.
Vrátí celkový počet způsobů, jak rozdělit n bonbónů mezi 3 děti tak, aby žádné dítě nedostalo více než limit bonbóny.

Příklad 1:

Vstup: n = 5, limit = 2
Výstup: 3
Vysvětlení: Existují 3 způsoby, jak rozdělit 5 bonbónů tak, aby žádné dítě nedostalo více než 2 bonbóny: (1, 2, 2), (2, 1, 2) a (2, 2, 1).

Příklad 2:

Vstup: n = 3, limit = 3
Výstup: 10
Vysvětlení: Existuje 10 způsobů, jak rozdělit 3 bonbóny tak, aby žádné dítě nedostalo více než 3 bonbóny: (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) a (3, 0, 0).

Omezení:

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

Jsou vám dána dvě kladná celá čísla n a limita.
Vraťte celkový počet způsobů, jak rozdělit n bonbónů mezi 3 děti tak, aby žádné dítě nedostalo více než limit bonbonů.

Příklad 1:

Vstup: n = 5, limit = 2
Výstup: 3
Vysvětlení: Existují 3 způsoby, jak rozdat 5 bonbonů tak, aby žádné dítě nedostalo více než 2 bonbony: (1, 2, 2), (2, 1, 2) a (2, 2, 1).

Příklad 2:

Vstup: n = 3, limit = 3
Výstup: 10
Vysvětlení: Existuje 10 způsobů, jak distribuovat 3 bonbóny tak, aby žádné dítě nedostalo více než 3 bonbóny: (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) a (3, 0, 0).

Omezení:

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


Je vám dáno celé číslo n.
Řetězec s se nazývá dobrý, pokud obsahuje pouze malá písmena v angličtině a je možné změnit uspořádání znaků s tak, aby nový řetězec obsahoval jako podřetězec "leet".
Například:

Řetězec "lteer" je dobrý, protože jej můžeme přeskupit do podoby "leetr" .
"letl" není dobré, protože jej nemůžeme změnit tak, aby obsahoval "leet" jako podřetězec.

Vraťte celkový počet dobrých řetězců délky n.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.
Podřetězec je souvislá sekvence znaků v řetězci.

Příklad 1:

Vstup: n = 4
Výstup: 12
Vysvětlení: 12 řetězců, které lze přeskupit tak, aby měly jako podřetězec "leet", jsou: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete" , "ltee", "teel", "tele" a "tlee".

Příklad 2:

Vstup: n = 10
Výstup: 83943898
Vysvětlení: Počet řetězců o délce 10, které lze přeskupit tak, aby měly "leet" jako podřetězec, je 526083947580. Odpověď je tedy 526083947580 % (10^9 + 7) = 83943898.

Omezení:

1 <= n <= 10^5

Je vám dáno celé číslo n.
Řetězec s se nazývá dobrý, pokud obsahuje pouze malá písmena anglických znaků a je možné změnit uspořádání znaků s tak, aby nový řetězec obsahoval "leet" jako podřetězec.
Například:

Řetězec "lteer" je dobrý, protože jej můžeme přeuspořádat do podoby "leetr" .
"letl" není dobré, protože ho nemůžeme přeuspořádat tak, aby obsahovalo "leet" jako podřetězec.

Vrátí celkový počet dobrých řetězců o délce n.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.
Podřetězec je souvislá posloupnost znaků v řetězci.

Příklad 1:

Vstup: n = 4
Výstup: 12
Vysvětlení: 12 řetězců, které lze přeuspořádat tak, aby měly "leet" jako podřetězec, jsou: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele" a "tlee".

Příklad 2:

Vstup: n = 10
Výstup: 83943898
Vysvětlení: Počet řetězců o délce 10, které lze přeuspořádat tak, aby měly "leet" jako podřetězec, je 526083947580. Odpověď je tedy 526083947580 % (10^9 + 7) = 83943898.

Omezení:

1 <= n <= 10^5


Máš daný řetězec `s` indexovaný od 0 s délkou `n`, která je sudá.
Je ti také dáno dvourozměrné pole celočíselných hodnot indexované od 0, `queries`, kde `queries[i] = [a_i, b_i, c_i, d_i]`.
Pro každý dotaz `i` můžeš provést následující operace:

1. Přeskupit znaky v podřetězci `s[a_i:b_i]`, kde `0 <= a_i <= b_i < n / 2`.
2. Přeskupit znaky v podřetězci `s[c_i:d_i]`, kde `n / 2 <= c_i <= d_i < n`.

Pro každý dotaz máš za úkol určit, zda je možné vytvořit z `s` palindrom provedením uvedených operací.
Každý dotaz se vyhodnocuje nezávisle na ostatních.
Vrátíš pole `answer` indexované od 0, kde `answer[i] == true`, pokud je možné vytvořit z `s` palindrom na základě operací specifikovaných `i`-tým dotazem, a `false` jinak.

Podřetězec je souvislá sekvence znaků v řetězci.
`s[x:y]` představuje podřetězec složený ze znaků od indexu `x` do indexu `y` včetně.

Příklad 1:

Vstup: `s = "abcabc"`, `queries = [[1,1,3,5],[0,2,5,5]]`
Výstup: `[true,true]`
Vysvětlení: V tomto příkladu jsou dva dotazy:
V prvním dotazu:
- `a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5`.
- Takže je povoleno přeskupit `s[1:1] => abcabc` a `s[3:5] => abcabc`.
- Pro vytvoření z `s` palindrom může být `s[3:5]` přeskupeno, aby se stalo => `abccba`.
- Nyní je `s` palindrom. Proto `answer[0] = true`.
Ve druhém dotazu:
- `a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5`.
- Takže je povoleno přeskupit `s[0:2] => abcabc` a `s[5:5] => abcabc`.
- Pro vytvoření z `s` palindrom může být `s[0:2]` přeskupeno, aby se stalo => `cbaabc`.
- Nyní je `s` palindrom. Proto `answer[1] = true`.

Příklad 2:

Vstup: `s = "abbcdecbba"`, `queries = [[0,2,7,9]]`
Výstup: `[false]`
Vysvětlení: V tomto příkladu je pouze jeden dotaz.
`a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9`.
Takže je povoleno přeskupit `s[0:2] => abbcdecbba` a `s[7:9] => abbcdecbba`.
Není možné vytvořit z `s` palindrom přeskupením těchto podřetězců, protože `s[3:6]` není palindrom.
Proto `answer[0] = false`.

Příklad 3:

Vstup: `s = "acbcab"`, `queries = [[1,2,4,5]]`
Výstup: `[true]`
Vysvětlení: V tomto příkladu je pouze jeden dotaz.
`a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5`.
Takže je povoleno přeskupit `s[1:2] => acbcab` a `s[4:5] => acbcab`.
Pro vytvoření z `s` palindrom může být `s[1:2]` přeskupeno, aby se stalo `abccab`.
Pak může být `s[4:5]` přeskupeno, aby se stalo `abccba`.
Nyní je `s` palindrom. Proto `answer[0] = true`.

Omezení:

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 je sudé.
`s` se skládá pouze z malých písmen anglické abecedy.

Je vám dána 0-indexovaná řetězec s se sudou délkou n.
Také je vám dána 0-indexovaná 2D celočíselná pole, queries, kde queries[i] = [a_i, b_i, c_i, d_i].
Pro každý dotaz i máte povoleno provést následující operace:

Přeskupit znaky v rámci podřetězce s[a_i:b_i], kde 0 <= a_i <= b_i < n / 2.
Přeskupit znaky v rámci podřetězce s[c_i:d_i], kde n / 2 <= c_i <= d_i < n.

Pro každý dotaz je vaším úkolem zjistit, zda je možné vytvořit z s palindrom provedením těchto operací.
Každý dotaz je zodpovídán nezávisle na ostatních.
Vrátíte 0-indexované pole answer, kde answer[i] == true pokud je možné vytvořit z s palindrom pomocí operací specifikovaných  i^th

 dotazem, a false v opačném případě.

Podřetězec je souvislá sekvence znaků v řetězci.
s[x:y] představuje podřetězec složený ze znaků od indexu x po index  y v s, oba včetně.

Příklad 1:

Vstup: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Výstup: [true,true]
Vysvětlení: V tomto příkladu jsou dva dotazy:
V prvním dotazu:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Takže je povoleno přeskupit s[1:1] => abcabc a s[3:5] => abcabc.
- Pro vytvoření z s palindrom může být s[3:5] přeskupeno, aby se stalo => abccba.
- Nyní je s palindrom. Proto answer[0] = true.
Ve druhém dotazu:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5`.
- Takže je povoleno přeskupit s[0:2] => abcabc a s[5:5] => abcabc.
- Pro vytvoření z s palindrom může být s[0:2] přeskupeno, aby se stalo => cbaabc.
- Nyní je s palindrom. Proto answer[1] = true.

Příklad 2:

Vstup: s = "abbcdecbba", queries = [[0,2,7,9]]
Výstup: [false]
Vysvětlení: V tomto příkladu je pouze jeden dotaz.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Takže je povoleno přeskupit s[0:2] => abbcdecbba a s[7:9] => abbcdecbba`.
Není možné vytvořit z s palindrom přeskupením těchto podřetězců, protože s[3:6] není palindrom.
Proto answer[0] = false.

Příklad 3:

Vstup: s = "acbcab", queries = [[1,2,4,5]]
Výstup: [true]
Vysvětlení: V tomto příkladu je pouze jeden dotaz.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Takže je povoleno přeskupit s[1:2] => acbcab a s[4:5] => acbcab.
Pro vytvoření z s palindrom může být s[1:2] přeskupeno, aby se stalo abccab.
Pak může být s[4:5] přeskupeno, aby se stalo abccba.
Nyní je s palindrom. Proto answer[0] = true.

Omezení:

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 je sudé.
s se skládá pouze z malých písmen anglické abecedy.

Dostanete řetězec s indexem 0, který má sudou délku n.
Dostanete také 2D celočíselné pole indexované 0, queries, kde queries[i] = [a_i, b_i, c_i, d_i].
U každého dotazu i můžete provádět následující operace:

Uspořádejte znaky v podřetězci s[a_i:b_i], kde 0 <= a_i <= b_i < n / 2.
Uspořádejte znaky v podřetězci s[c_i:d_i], kde n / 2 <= c_i <= d_i < n.

U každého dotazu je vaším úkolem určit, zda je možné provedením operací vytvořit palindrom.
Každý dotaz je zodpovězen nezávisle na ostatních.
Vrátí odpověď 0-indexovaného pole, kde answer[i] == true, pokud je možné vytvořit palindrom provedením operací specifikovaných i^-tým dotazem, a false jinak.

Podřetězec je souvislá posloupnost znaků v řetězci.
S[x:y] představuje podřetězec skládající se ze znaků od indexu X do indexu Y v S, oba včetně.

Příklad 1:

Vstup: s = "abcabc", queries= [[1,1,3,5],[0,2,5,5]]
Výstup:  [true,true]
Vysvětlení: V tomto příkladu existují dva dotazy:
V prvním dotazu:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Takže můžete změnit uspořádání s[1:1] => abcabc a s[3:5] => abcabc.
- Aby se z s stal palindrom, může být s[3:5] přeskupeno tak, aby se stalo => abccba.
- S je palindrom. Takže answer[0] = true.
Ve druhém dotazu:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Takže můžete změnit uspořádání s[0:2] => abcabc a s[5:5] => abcabc.
- Aby se z s stal palindrom, může být s[0:2] přeskupeno tak, aby se stalo => cbaabc.
- S je palindrom. Takže answer[1] = true.

Příklad 2:

Vstup: s = "abbcdecbba", queries = [[0,2,7,9]]
Výstup: [false]
Vysvětlení: V tomto příkladu existuje pouze jeden dotaz.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Můžete tedy změnit uspořádání s[0:2] => abbcdecbba a s[7:9] => abbcdecbba.
Není možné vytvořit s palindrom přeskupením těchto podřetězců, protože s[3:6] není palindrom.
Takže answer[0] = false.
Příklad 3:

Vstup: s = "acbcab", queries = [[1,2,4,5]]
Výstup: [true]
Vysvětlení: V tomto příkladu existuje pouze jeden dotaz.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Můžete tedy změnit uspořádání s[1:2] => acbcab a s[4:5] => acbcab.
Aby se z palindromu stal palindrom, může být s[1:2] přeskupen tak, aby se stal abccab.
Poté může být s[4:5] přeskupeno tak, aby se stalo abccba.
S je palindrom. Takže answer[0] = true.

Omezení:

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 je sudé.
s se skládá pouze z malých anglických písmen.


Jsou vám dány dvě 0-indexované celočíselné pole nums1 a nums2 o velikosti n a m.

Zvažte výpočet následujících hodnot:

Počet indexů i takových, že 0 <= i < n a nums1[i] se vyskytuje alespoň jednou v nums2.
Počet indexů i takových, že 0 <= i < m a nums2[i] se vyskytuje alespoň jednou v nums1.

Vrátíte celočíselné pole answer o velikosti 2 obsahující obě hodnoty v uvedeném pořadí.

Příklad 1:

Vstup: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Výstup: [3,4]
Vysvětlení: Hodnoty vypočítáme následovně:
- Prvky na indexech 1, 2 a 3 v nums1 se vyskytují alespoň jednou v nums2. První hodnota je tedy 3.
- Prvky na indexech 0, 1, 3 a 4 v nums2 se vyskytují alespoň jednou v nums1. Druhá hodnota je tedy 4.

Příklad 2:

Vstup: nums1 = [3,4,2,3], nums2 = [1,5]
Výstup: [0,0]
Vysvětlení: Mezi oběma poli nejsou žádné společné prvky, takže obě hodnoty budou 0.

Omezení:

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

Získáte dvě 0-indexovaná celočíselná pole nums1 a nums2 o velikostech n a m, v tomto pořadí.
Zvažte výpočet následujících hodnot:

Počet indexů i takový, že 0 <= i < n a nums1[i] se vyskytuje alespoň jednou v nums2.
Počet indexů i takový, že 0 <= i < ma nums2[i] se v nums1 vyskytuje alespoň jednou.

Vrátí odpověď celočíselného pole velikosti 2 obsahující dvě hodnoty ve výše uvedeném pořadí.

Příklad 1:

Vstup: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Výstup: [3,4]
Vysvětlení: Hodnoty vypočítáme následovně:
- Prvky na indexech 1, 2 a 3 v nums1 se vyskytují alespoň jednou v nums2. Takže první hodnota je 3.
- Prvky na indexech 0, 1, 3 a 4 v nums2 se vyskytují alespoň jednou v nums1. Takže druhá hodnota je 4.

Příklad 2:

Vstup: nums1 = [3,4,2,3], nums2 = [1,5]
Výstup: [0,0]
Vysvětlení: Mezi těmito dvěma poli nejsou žádné společné prvky, takže dvě hodnoty budou 0.

Omezení:

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

Dostanete dvě celočíselná pole indexovaná 0 nums1 a nums2 o velikostech n a m.
Zvažte výpočet následujících hodnot:

Počet indexů i takový, že 0 <= i < n a nums1[i] se vyskytuje alespoň jednou v nums2.
Počet indexů i takový, že 0 <= i < m a nums2[i] se vyskytuje alespoň jednou v nums1.

Vrátí odpověď celočíselného pole o velikosti 2 obsahující dvě hodnoty ve výše uvedeném pořadí.

Příklad 1:

Vstup: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Výstup: [3,4]
Vysvětlení: Hodnoty vypočítáme následovně:
- Prvky v indexech 1, 2 a 3 v nums1 se vyskytují alespoň jednou v nums2. První hodnota je tedy 3.
- Prvky v indexech 0, 1, 3 a 4 v nums2 se vyskytují alespoň jednou v nums1. Druhá hodnota je tedy 4.

Příklad 2:

Vstup: nums1 = [3,4,2,3], nums2 = [1,5]
Výstup: [0,0]
Vysvětlení: Mezi těmito dvěma poli nejsou žádné společné prvky, takže dvě hodnoty budou 0.

Omezení:

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


Dostanete tři řetězce s1, s2 a s3. Na těchto třech řetězcích musíte provést následující operaci, kolikrát chcete.
V jedné operaci si můžete vybrat jeden z těchto tří řetězců, který má délku alespoň 2, a smazat jeho pravý znak.
Vraťte minimální počet operací, které musíte provést, aby byly tři řetězce stejné, pokud existuje způsob, jak je učinit stejnými, jinak vraťte -1.

Příklad 1:

Vstup: s1 = "abc", s2 = "abb", s3 = "ab"
Výstup: 2
Vysvětlení: Provádění operací na s1 a s2 jednou povede ke třem stejným řetězcům.
Je možné ukázat, že neexistuje způsob, jak je udělat stejné s méně než dvěma operacemi.

Příklad 2:

Vstup: s1 = "dac", s2 = "bac", s3 = "cac"
Výstup: -1
Vysvětlení: Protože nejlevější písmena s1 a s2 nejsou stejná, nemohou být stejné po jakémkoli počtu operací. Odpověď je tedy -1.

Omezení:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 a s3 se skládají pouze z malých anglických písmen.

Jsou dány tři řetězce s1, s2 a s3. S těmito třemi řetězci musíte provést následující operaci tolikrát, kolikrát chcete.
Při jedné operaci můžete vybrat jeden z těchto tří řetězců tak, aby jeho délka byla alespoň 2, a vymazat jeho nejpravější znak.
Vraťte minimální počet operací, které musíte provést, aby se tyto tři řetězce rovnaly, pokud existuje způsob, jak je rovnat, jinak vraťte -1.

Příklad 1:

Vstup: s1 = „abc“, s2 = „abb“, s3 = „ab“
Výstup: 2
Vysvětlení: Provedení operací s1 a s2 jednou povede ke třem stejným řetězcům.
Lze ukázat, že neexistuje způsob, jak je učinit rovnými pomocí méně než dvou operací.
Příklad 2:

Vstup: s1 = „dac“, s2 = „bac“, s3 = „cac“.
Výstup: -1
Vysvětlení: Protože písmena s1 a s2, která jsou nejvíce vlevo, se nerovnají, nemohou se rovnat po žádném počtu operací. Odpověď je tedy -1.

Omezení:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 a s3 se skládají pouze z malých anglických písmen.


Jste na trhu s ovocem, kde jsou vystaveny různé druhy exotického ovoce.
Je vám dáno pole prices s indexováním od 1, kde prices[i] udává počet mincí potřebných k zakoupení i-tého ovoce.
Trh s ovocem má následující nabídku:

Pokud si zakoupíte i-té ovoce za prices[i] mincí, můžete získat dalších i ovoce zdarma.

Všimněte si, že i když můžete vzít ovoce j zdarma, stále jej můžete zakoupit za prices[j] mincí a získat novou nabídku.
Vrátit minimální počet mincí potřebných k získání všech ovoci.

Příklad 1:

Vstup: prices = [3,1,2]
Výstup: 4
Vysvětlení: Můžete získat ovoce následovně:
- Zakoupit 1.st ovoce za 3 mince, máte povoleno vzít 2. ovoce zdarma.
- Zakoupit 2. ovoce za 1 minci, máte povoleno vzít 3. ovoce zdarma.
- Vzít 3. ovoce zdarma.
Všimněte si, že i když jste mohli vzít 2. ovoce zdarma, zakoupili jste ho, protože je to optimálnější.
Lze dokázat, že 4 je minimální počet mincí potřebných k získání všech ovocí.

Příklad 2:

Vstup: prices = [1,10,1,1]
Výstup: 2
Vysvětlení: Můžete získat ovoce následovně:
- Zakoupit 1. ovoce za 1 minci, máte povoleno vzít 2. ovoce zdarma.
- Vzít 2. ovoce zdarma.
- Zakoupit 3. ovoce za 1 minci, máte povoleno vzít 4. ovoce zdarma.
- Vzít 4. ovoce zdarma.
Lze dokázat, že 2 je minimální počet mincí potřebných k získání všech ovoci.

Omezení:

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

Jste na trhu s ovocem, kde je vystaveno několik druhů exotického ovoce.
Máte pole prices indexované od 1, kde prices[i] označuje počet mincí potřebných k zakoupení i-tého ovoce.
Na trhu s ovocem platí následující nabídka:

Pokud zakoupíte i-té ovoce za `prices[i]` mincí, můžete získat následujících i kusů ovoce zdarma.

Poznámka: I když můžete vzít ovoce j zdarma, stále jej můžete zakoupit za prices[j] mincí, abyste získali novou nabídku.
Vraťte minimální počet mincí potřebných k získání veškerého ovoce.
Příklad 1:

Vstup: prices = [3,1,2]
Výstup: 4
Vysvětlení: Můžete získat ovoce následovně:
- Zakoupit 1. ovoce za 3 mince, můžete vzít 2. ovoce zdarma.
- Zakoupit 2. ovoce za 1 minci, můžete vzít 3. ovoce zdarma.
- Vzít 3. ovoce zdarma.
Všimněte si, že i když jste mohli vzít 2. ovoce zdarma, zakoupili jste ho, protože je to optimálnější.
Lze dokázat, že 4 je minimální počet mincí potřebných k získání všech ovoce.

Příklad 2:

Vstup: prices = [1,10,1,1]
Výstup: 2
Vysvětlení: Můžete získat ovoce následovně:
- Zakoupit 1. ovoce za 1 minci, můžete vzít 2. ovoce zdarma.
- Vzít 2. ovoce zdarma.
- Zakoupit 3. ovoce za 1 minci, můžete vzít 4. ovoce zdarma.
- Vzít 4. ovoce zdarma.
Lze dokázat, že 2 je minimální počet mincí potřebných k získání všech ovoce.

Omezení:

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

Nacházíte se na ovocném trhu, kde jsou vystaveny různé druhy exotického ovoce.
Dostanete 1-indexované pole cen, kde prices[i] označuje počet mincí potřebných k nákupu i^tého ovoce.
Ovocný trh má následující nabídku:

Pokud si zakoupíte i^th ovoce za prices [i] mincí, můžete získat další i ovoce zdarma.

Všimněte si, že i když si můžete vzít ovoce j zdarma, stále si ho můžete koupit za prices[j] mince a získat tak novou nabídku.
Vraťte minimální počet mincí potřebných k získání všech plodů.

Příklad 1:

Vstup: prices = [3,1,2]
Výstup: 4
Vysvětlení: Ovoce můžete získat následovně:
- Kupte si 1^. ovoce za 3 mince, 2^. ovoce si můžete vzít zdarma.
- Kupte si 2^. ovoce za 1 minci, 3^. ovoce si můžete vzít zdarma.
- Vezměte si 3^. ovoce zdarma.
Všimněte si, že i když vám bylo dovoleno vzít si 2^. ovoce zdarma, koupili jste si ho, protože je to optimálnější.
Lze dokázat, že 4 je minimální počet mincí potřebných k získání všech plodů.

Příklad 2:

Vstup: prices = [1,10,1,1]
Výstup: 2
Vysvětlení: Ovoce můžete získat následovně:
- Kupte si 1^. ovoce za 1 minci, 2^. ovoce si můžete vzít zdarma.
- Vezměte si 2^. ovoce zdarma.
- Kupte si 3^. ovoce za 1 minci, 4^. ovoce si můžete vzít zdarma.
- Vezměte si ovoce 4^t^h zdarma.
Lze dokázat, že 2 je minimální počet mincí potřebných k získání všech plodů.

Omezení:

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


Dostanete řetězec s a kladné celé číslo k.
Nechť samohlásky a souhlásky jsou počtem samohlásek a souhlásek v řetězci.
Řetězec je krásný, pokud:

samohlásky == souhlásky.
(samohlásky * souhlásky) % k == 0, jinými slovy násobení samohlásek a souhlásek je dělitelné k.

Vrátí počet neprázdných krásných podřetězců v daném řetězci s.
Podřetězec je souvislá sekvence znaků v řetězci.
Samohláska v angličtině jsou 'a', 'e', 'i', 'o' a 'u'.
Souhláska jsou v angličtině každé písmeno kromě samohlásek.

Příklad 1:

Vstup: s = "baeyh", k = 2
Výstup: 2
Vysvětlení: V daném řetězci jsou 2 krásné podřetězce.
- Podřetězec "baeyh", samohlásky = 2 (["a",e"]), souhlásky = 2 (["y","h"]).
Můžete vidět, že řetězec „aeyh“ je krásný, protože počet samohlásek se rovná počtu souhlásek a jejich součin je dělitelný k.
- Podřetězec "baeyh", samohlásky = 2 (["a",e"]), souhlásky = 2 (["b","y"]).
Můžete vidět, že řetězec "baey" je krásný jako samohlásky == souhlásky a samohlásky * souhlásky % k == 0.
Lze ukázat, že v daném řetězci jsou pouze 2 krásné podřetězce.

Příklad 2:

Vstup: s = "abba", k = 1
Výstup: 3
Vysvětlení: V daném řetězci jsou 3 krásné podřetězce.
- Podřetězec "abba", samohlásky = 1 (["a"]), souhlásky = 1 (["b"]).
- Podřetězec "abba", samohlásky = 1 (["a"]), souhlásky = 1 (["b"]).
- Podřetězec "abba", samohlásky = 2 (["a","a"]), souhlásky = 2 (["b","b"]).
Lze ukázat, že v daném řetězci jsou pouze 3 krásné podřetězce.

Příklad 3:

Vstup: s = "bcdf", k = 1
Výstup: 0
Vysvětlení: V daném řetězci nejsou žádné krásné podřetězce.

Omezení:

1 <= s.length <= 1000
1 <= k <= 1000
s se skládá pouze z malých anglických písmen.

Je vám dán řetězec s a kladné celé číslo k.
Nechť samohlásky a souhlásky jsou počtem samohlásek a souhlásek v řetězci.
Řetězec je krásný, pokud:

vowels == consonants.
(vowels * consonants) % k == 0, jinými slovy násobení samohlásek a souhlásek je dělitelné k.

Vrátí počet neprázdných krásných podřetězců v daném řetězci s.
Podřetězec je souvislá posloupnost znaků v řetězci.
Samohlásková písmena v angličtině jsou 'a', 'e', 'i', 'o' a 'u'.
Písmena souhlásek v angličtině jsou všechna písmena kromě samohlásek.

Příklad 1:

Vstup: s = "baeyh", k = 2
Výstup: 2
Vysvětlení: V daném řetězci jsou 2 krásné podřetězce.
- Podřetězec "baeyh", vowels = 2 (["a",e"]), consonants = 2 (["y","h"]).
Vidíte, že řetězec "aeyh" je krásný jako vowels == consonants a vowels * consonants % k == 0.
- Podřetězec "baeyh", vowels = 2 (["a",e"]), consonants = 2 (["b","y"]).
Vidíte, že řetězec "baey" je krásný jako vowels == consonants a vowels * consonants % k == 0.
Lze ukázat, že v daném řetězci jsou pouze 2 krásné podřetězce.

Příklad 2:

Vstup: s = "abba", k = 1
Výstup: 3
Vysvětlení: V daném řetězci jsou 3 krásné podřetězce.
- Podřetězec "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).
- Podřetězec "abba", vowels = 1 (["a"]), consonants = 1 (["b"]).
- Podřetězec "abba", vowels = 2 (["a","a"]), consonants = 2 (["b","b"]).
Lze ukázat, že v daném řetězci jsou pouze 3 krásné podřetězce.

Příklad 3:

Vstup: s = "bcdf", k = 1
Výstup: 0
Vysvětlení: V daném řetězci nejsou žádné krásné podřetězce.

Omezení:

1 <= s.length <= 1000
1 <= k <= 1000
s se skládá pouze z anglických malých písmen.

Dostanete řetězec s a kladné celé číslo k.
Nechť samohlásky a souhlásky jsou počtem samohlásek a souhlásek v řetězci.
Řetězec je krásný, pokud:

samohlásky == souhlásky.
(samohlásky * souhlásky) % k == 0, jinými slovy násobení samohlásek a souhlásek je dělitelné k.

Vrátí počet neprázdných krásných podřetězců v daném řetězci s.
Podřetězec je souvislá sekvence znaků v řetězci.
Samohláska v angličtině jsou 'a', 'e', 'i', 'o' a 'u'.
Souhláska jsou v angličtině každé písmeno kromě samohlásek.

Příklad 1:

Vstup: s = "baeyh", k = 2
Výstup: 2
Vysvětlení: V daném řetězci jsou 2 krásné podřetězce.
- Podřetězec "baeyh", samohlásky = 2 (["a",e"]), souhlásky = 2 (["y","h"]).
Můžete vidět, že řetězec „aeyh“ je krásný jako samohlásky == souhlásky a samohlásky * souhlásky % k == 0.
- Podřetězec "baeyh", samohlásky = 2 (["a",e"]), souhlásky = 2 (["b","y"]).
Můžete vidět, že řetězec "baey" je krásný jako samohlásky == souhlásky a samohlásky * souhlásky % k == 0.
Lze ukázat, že v daném řetězci jsou pouze 2 krásné podřetězce.

Příklad 2:

Vstup: s = "abba", k = 1
Výstup: 3
Vysvětlení: V daném řetězci jsou 3 krásné podřetězce.
- Podřetězec "abba", samohlásky = 1 (["a"]), souhlásky = 1 (["b"]).
- Podřetězec "abba", samohlásky = 1 (["a"]), souhlásky = 1 (["b"]).
- Podřetězec "abba", samohlásky = 2 (["a","a"]), souhlásky = 2 (["b","b"]).
Lze ukázat, že v daném řetězci jsou pouze 3 krásné podřetězce.

Příklad 3:

Vstup: s = "bcdf", k = 1
Výstup: 0
Vysvětlení: V daném řetězci nejsou žádné krásné podřetězce.

Omezení:

1 <= s.length <= 1000
1 <= k <= 1000
s se skládá pouze z malých anglických písmen.


Dostanete 0-indexované celočíselné pole nums.
Můžete provádět libovolný počet operací, přičemž každá operace zahrnuje výběr podpole pole a jeho nahrazení součtem jeho prvků. Pokud je například dané pole [1,3,5,6] a vyberete podpole [3,5], pole se převede na [1,8,6].
Vrátí maximální délku neklesajícího pole, kterou lze vytvořit po použití operací.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [5,2,2]
Výstup: 1
Vysvětlení: Toto pole s délkou 3 není neklesající.
Máme dva způsoby, jak vytvořit pole délky dvě.
Nejprve výběrem podpole [2,2] převedete pole na [5,4].
Za druhé, výběrem podpole [5,2] převedete pole na [7,2].
Těmito dvěma způsoby není pole neklesající.
A pokud zvolíme podpole [5,2,2] a nahradíme jej [9], stane se neklesající.
Takže odpověď je 1.

Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: 4
Vysvětlení: Pole neklesá. Takže odpověď je 4.

Příklad 3:

Vstup: nums = [4,3,2,6]
Výstup: 3
Vysvětlení: Nahrazení [3,2] za [5] převede dané pole na [4,5,6], které není klesající.
Protože dané pole není neklesající, maximální možná odpověď je 3.

Omezení:

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

Je zadáno celočíselné pole nums s indexem 0.
Můžete provést libovolný počet operací, kde každá operace spočívá v..., přičemž každá operace spočívá ve vybrání dílčího pole pole a jeho nahrazení součtem jeho prvků. Například pokud je dané pole [1,3,5,6] a vyberete podřetězec [3,5], pole se převede na [1,8,6].
Vrátí maximální délku neklesajícího pole, kterou lze vytvořit po použití operací.
Podřetězec je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [5,2,2]
Výstup: 1
Vysvětlení: Toto pole o délce 3 není neklesající.
Máme dvě možnosti, jak z pole délky 2 udělat pole délky 2.
Za prvé, výběrem podřetězce [2,2] převedeme pole na [5,4].
Za druhé, zvolením podřetězec [5,2] převedeme pole na [7,2].
Při těchto dvou způsobech není pole neklesající.
A pokud zvolíme podřetězec [5,2,2] a nahradíme ji [9], stane se neklesající.
Odpověď je tedy 1.

Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: 4
Vysvětlení: Pole je neklesající. Odpověď je tedy 4.

Příklad 3:

Vstup: nums = [4,3,2,6]
Výstup: 3
Vysvětlení: Výměnou [3,2] za [5] se zadané pole převede na [4,5,6], které neklesá.
Protože dané pole není neklesající, maximální možná odpověď je 3.

Omezení:

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

Máte zadané celočíselné pole nums s indexováním od 0.
Můžete provést libovolný počet operací, kde každá operace zahrnuje výběr subpole pole a jeho nahrazení součtem jeho prvků. Například, pokud je dané pole [1,3,5,6] a vyberete subpole [3,5], pole se změní na [1,8,6].
Vrátí maximální délku neklesajícího pole, které lze vytvořit po aplikaci operací.
Subpole je souvislý nepustý sled prvků v poli.

Příklad 1:

Vstup: nums = [5,2,2]
Výstup: 1
Vysvětlení: Toto pole s délkou 3 není neklesající.
Máme dva způsoby, jak přeměnit pole na délku dva.
Za prvé, výběr subpole [2,2] přemění pole na [5,4].
Za druhé, výběr subpole [5,2] přemění pole na [7,2].
V těchto dvou případech pole není neklesající.
A pokud vybereme subpole [5,2,2] a nahradíme ho [9], stane se neklesajícím.
Takže odpověď je 1.

Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: 4
Vysvětlení: Pole je neklesající. Takže odpověď je 4.

Příklad 3:

Vstup: nums = [4,3,2,6]
Výstup: 3
Vysvětlení: Nahrazení [3,2] za [5] přemění dané pole na [4,5,6], které je neklesající.
Protože dané pole není neklesající, maximální možná odpověď je 3.

Omezení:

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


Je vám dáno pole s indexem 0 s názvem nums, které obsahuje kladná celá čísla. Rozdělení pole na jednu nebo více souvislých podpolí se nazývá dobré, pokud žádné dvě podpole neobsahují stejné číslo. Vraťte celkový počet dobrých rozdělení nums. Jelikož odpověď může být velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 8
Vysvětlení: 8 možných dobrých rozdělení je: ([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]) a ([1,2,3,4]).

Příklad 2:

Vstup: nums = [1,1,1,1]
Výstup: 1
Vysvětlení: Jediné možné dobré rozdělení je: ([1,1,1,1]).

Příklad 3:

Vstup: nums = [1,2,1,3]
Výstup: 2
Vysvětlení: 2 možná dobrá rozdělení jsou: ([1,2,1], [3]) a ([1,2,1,3]).

Omezení:

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

Dostanete 0-indexované pole nums skládající se z kladných celých čísel.
Rozdělení pole do jednoho nebo více souvislých podpolí se nazývá dobré, pokud žádná dvě podpole neobsahují stejné číslo.
Vraťte celkový počet dobrých oddílů nums.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 8
Vysvětlení: 8 možných dobrých oddílů je: ([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]), a ([1,2,3,4]).

Příklad 2:

Vstup: nums = [1,1,1,1]
Výstup: 1
Vysvětlení: Jediný možný dobrý oddíl je: ([1,1,1,1]).

Příklad 3:

Vstup: nums = [1,2,1,3]
Výstup: 2
Vysvětlení: 2 možné dobré oddíly jsou: ([1,2,1], [3]) a ([1,2,1,3]).

Omezení:

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

Dostanete pole indexované 0 skládající se z kladných celých čísel.
Rozdělení pole na jedno nebo více souvislých podpolí se nazývá dobré, pokud žádná dvě podpole neobsahují stejné číslo.
Vraťte celkový počet dobrých oddílů pole.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 8
Vysvětlení: 8 možných dobrých oddílů je: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]) a ([1,2,3,4]).

Příklad 2:

Vstup: nums = [1,1,1,1]
Výstup: 1
Vysvětlení: ediný možný dobrý oddíl je: ([1,1,1,1]).

Příklad 3:

Vstup: nums = [1,2,1,3]
Výstup: 2
Vysvětlení: 2 možné dobré oddíly jsou: ([1,2,1], [3]) a ([1,2,1,3]).

Omezení:

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


Máte dané pole celých čísel nums a kladné celé číslo k.
Vraťte počet podpolí, kde se maximální prvek z nums v tomto podpoli objevuje alespoň k-krát.
Podpole je souvislá posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [1,3,2,3,3], k = 2
Výstup: 6
Vysvětlení: Podpole, která obsahují prvek 3 alespoň dvakrát, jsou: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] a [3,3].

Příklad 2:

Vstup: nums = [1,4,2,1], k = 3
Výstup: 0
Vysvětlení: Žádné podpole neobsahuje prvek 4 alespoň třikrát.

Omezení:

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

Dostanete celočíselné pole nums a kladné celé číslo k.
Vrátí počet podpolí, kde se maximální prvek nums vyskytuje alespoň kkrát v tomto podpoli.
Podpole je souvislá posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [1,3,2,3,3], k = 2
Výstup: 6
Vysvětlení: Podpole, která obsahují prvek 3 alespoň 2krát, jsou: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2, 3,3], [2,3,3] a [3,3].

Příklad 2:

Vstup: nums = [1,4,2,1], k = 3
Výstup: 0
Vysvětlení: Žádné podpole neobsahuje prvek 4 alespoň třikrát.

Omezení:

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

Je zadáno celočíselné pole nums a kladné celé číslo k.
Vraťte počet podpolí, v nichž se maximální prvek nums vyskytuje v daném podpole alespoň kkrát.
Podoblast je souvislá posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [1,3,2,3,3], k = 2
Výstup: 6
Vysvětlení: Dílčí pole, která obsahují prvek 3 alespoň 2krát, jsou: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] a [3,3].

Příklad 2:

Vstup: nums = [1,4,2,1], k = 3
Výstup: 0
Vysvětlení: Žádné podřetězce neobsahují prvek 4 alespoň 3krát.

Omezení:

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