Je vám dán celočíselný seznam coins představující mince různých nominálních hodnot a celé číslo k.
Máte nekonečný počet mincí každé nominální hodnoty. Nesmíte ale kombinovat mince různých nominálních hodnot.
Vraťte k-tou nejmenší částku, kterou lze vyrobit pomocí těchto mincí.

Příklad 1:

Vstup: coins = [3,6,9], k = 3
Výstup: 9
Vysvětlení: Dané mince mohou vytvořit následující částky:
Mince 3 produkuje násobky 3: 3, 6, 9, 12, 15, atd.
Mince 6 produkuje násobky 6: 6, 12, 18, 24, atd.
Mince 9 produkuje násobky 9: 9, 18, 27, 36, atd.
Všechny mince dohromady produkují: 3, 6, 9, 12, 15, atd.

Příklad 2:

Vstup: coins = [5,2], k = 7
Výstup: 12
Vysvětlení: Dané mince mohou vytvořit následující částky:
Mince 5 produkuje násobky 5: 5, 10, 15, 20, atd.
Mince 2 produkuje násobky 2: 2, 4, 6, 8, 10, 12, atd.
Všechny mince dohromady produkují: 2, 4, 5, 6, 8, 10, 12, 14, 15, atd.

Omezení:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins obsahuje párově různé celé čísla.

Je dáno celočíselné pole mincí představující mince různých nominálních hodnot a celé číslo k.
Máte nekonečný počet mincí každé nominální hodnoty. Není však dovoleno kombinovat mince různých nominálních hodnot.
Vraťte k^tou nejmenší částku, kterou lze z těchto mincí vyrobit.

Příklad 1:

Vstup: mince = [3,6,9], k = 3
Výstup:  9
Vysvětlení: Z daných mincí lze vytvořit následující částky:
Mince 3 vytváří násobky 3: 3, 6, 9, 12, 15 atd.
Mince 6 vytváří násobky 6: 6, 12, 18, 24 atd.
Mince 9 vytváří násobky 9: 9, 18, 27, 36 atd.
Všechny mince dohromady vytvářejí: 3, 6, 9, 12, 15 atd.

Příklad 2:

Vstup: mince = [5,2], k = 7
Výstup: 12
Vysvětlení: Z daných mincí lze vytvořit následující částky:
Mince 5 vytváří násobky 5: 5, 10, 15, 20 atd.
Mince 2 vytváří násobky 2: 2, 4, 6, 8, 10, 12 atd.
Všechny mince dohromady tvoří násobky: 2, 4, 5, 6, 8, 10, 12, 14, 15 atd.

Omezení:

1 <= mince.length <= 15
1 <= mince[i] <= 25
1 <= k <= 2 * 10^9
mince obsahují párově různá celá čísla.

Translated with DeepL.com (free version)

Je ti zadán celočíselný seznam coins, který představuje mince různých nominálních hodnot a celé číslo k.
Máš nekonečný počet mincí každé nominální hodnoty, ale nesmíš kombinovat mince různých nominálních hodnot.
Vrať k-tou nejmenší částku, kterou lze vyrobit pomocí těchto mincí.

Příklad 1:

Vstup: coins = [3,6,9], k = 3
Výstup: 9
Vysvětlení: Dané mince mohou vytvořit následující částky:
Mince 3 produkuje násobky 3: 3, 6, 9, 12, 15, atd.
Mince 6 produkuje násobky 6: 6, 12, 18, 24, atd.
Mince 9 produkuje násobky 9: 9, 18, 27, 36, atd.
Všechny mince dohromady produkují: 3, 6, 9, 12, 15, atd.

Příklad 2:

Vstup: coins = [5,2], k = 7
Výstup: 12
Vysvětlení: Dané mince mohou vytvořit následující částky:
Mince 5 produkuje násobky 5: 5, 10, 15, 20, atd.
Mince 2 produkuje násobky 2: 2, 4, 6, 8, 10, 12, atd.
Všechny mince dohromady produkují: 2, 4, 5, 6, 8, 10, 12, 14, 15, atd.

Omezení:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins obsahuje párově různé celé čísla.


Dány jsou dva pole nums a andValues o délce n a m.

Hodnota pole je rovna poslednímu prvku tohoto pole.

Je třeba rozdělit nums na m disjunktních souvislých podpolí tak, aby pro i-té podpole [l_i, r_i] platilo, že bitový AND prvků podpole je roven andValues[i], jinými slovy nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] pro všechny 1 <= i <= m, kde & představuje bitový operátor AND.

Vrátit minimální možný součet hodnot m podpolí, na které je nums rozděleno. Pokud není možné nums rozdělit na m podpolí splňujících tyto podmínky, vrátit -1.

Příklad 1:

Vstup: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Výstup: 12
Vysvětlení:
Jediný možný způsob, jak rozdělit nums je:

[1,4] protože 1 & 4 == 0.
[3] protože bitový AND jednoelementového podpole je samotný prvek.
[3] protože bitový AND jednoelementového podpole je samotný prvek.
[2] protože bitový AND jednoelementového podpole je samotný prvek.

Součet hodnot pro tato podpolí je 4 + 3 + 3 + 2 = 12.

Příklad 2:

Vstup: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Výstup: 17
Vysvětlení:
Existují tři způsoby, jak rozdělit nums:

[[2,3,5],[7,7,7],[5]] s celkovým součtem hodnot 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] s celkovým součtem hodnot 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] s celkovým součtem hodnot 7 + 7 + 5 == 19.

Minimální možný součet hodnot je 17.

Příklad 3:

Vstup: nums = [1,2,3,4], andValues = [2]
Výstup: -1
Vysvětlení:
Bitový AND celého pole nums je 0. Protože neexistuje žádný možný způsob, jak rozdělit nums do jediného podpole, aby bitový AND prvků byl 2, vrátit -1.

Omezení:

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

Jsou zadána dvě pole nums a andValues o délce n, resp. m.
Hodnota pole je rovna poslednímu prvku tohoto pole.
Musíte rozdělit nums na m nesouvislých a souvislých podpoli tak, aby pro i^té podpole [l_i, r_i] bylo bitové AND prvků podpole rovno aHodnoty[i], jinými slovy, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == aHodnoty[i] pro všechna 1 <= i <= m, kde & představuje operátor bitového AND.
Vrátí minimální možný součet hodnot m dílčích polí, na které je nums rozděleno. Pokud není možné rozdělit nums na m dílčích polí splňujících tyto podmínky, vraťte -1.

Příklad 1:

Vstup: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Výstup: 12
Vysvětlení:
Jediný možný způsob dělení nums je:

[1,4], protože bitové AND celého pole nums je 0 1 & 4 == 0.
[3] bitové AND jednoprvkového podpole je tento prvek sám o sobě.
[3] bitové AND jednoprvkového podpole je tento prvek sám o sobě.
[2] bitové AND jednoprvkového podpole je tento prvek sám o sobě.

Součet hodnot těchto dílčích polí je 4 + 3 + 3 + 2 = 12.

Příklad 2:

Vstup: nums = [2,3,5,7,7,7,5], andValues = [0,7,5].
Výstup: 17
Vysvětlení:
Existují tři způsoby dělení nums:

[2,3,5],[7,7,7],[5]], přičemž součet hodnot 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] se součtem hodnot 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] se součtem hodnot 7 + 7 + 5 == 19.

Minimální možný součet hodnot je 17.

Příklad 3:

Vstup: nums = [1,2,3,4], andValues = [2]
Výstup: -1
Vysvětlení:
protože bitové AND celého pole nums je 0 není možné rozdělit nums na jedno podpole, aby bitové AND prvků bylo 2, vrátíme -1.

Omezení:

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

Jsou vám dána dvě pole, nums a andValues, délky n a m.
Hodnota pole je rovna poslednímu prvku tohoto pole.
Musíte rozdělit pole nums na m nesouvislých, ale souvislých podpolí takových, že pro i^-té podpole [l_i, r_i] je bitové AND prvků podpole rovno andValues[i], jinými slovy, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] pro všechny 1 <= i <= m, kde & představuje bitový operátor AND.
Vrací minimální možný součet hodnot m podpolí, na která jsou pole nums rozdělena. Pokud není možné rozdělit pole nums na m podpolí splňujících tyto podmínky, vraťte hodnotu -1.

Příklad 1:

Vstup: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Výstup: 12
Vysvětlení:
ediný možný způsob, jak rozdělit pole nums, je:

[1,4] jako 1 & 4 == 0.
[3] jako bitový AND podpole jednoho prvku je tento prvek sám.
[3] jako bitový AND podpole jednoho prvku je tento prvek sám.
[2] jako bitový AND podpole jednoho prvku je tento prvek sám.

Součet hodnot pro tato podpole je 4 + 3 + 3 + 2 = 12.

Příklad 2:

Vstup: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Výstup: 17
Vysvětlení:
Existují tři způsoby, jak rozdělit pole nums:

[[2,3,5],[7,7,7],[5]] se součtem hodnot 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] se součtem hodnot 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] se součtem hodnot 7 + 7 + 5 == 19.

Minimální možný součet hodnot je 17.

Příklad 3:

Vstup:  nums = [1,2,3,4], andValues = [2]
Výstup: -1
Vysvětlení:
Bitový AND celého pole je 0. Protože neexistuje žádný způsob, jak rozdělit nums do jednoho podpole, aby bylo bitové AND prvků 2, vrátí hodnotu -1.

Omezení:

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


Je zadáno celočíselné pole nums obsahující celá kladná čísla. Definujeme funkci encrypt tak, že encrypt(x) nahradí každou číslici v x největší číslicí v x. Například encrypt(523) = 555 a encrypt(213) = 333.
Vrátíme součet zašifrovaných prvků.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 6
Vysvětlení: Zašifrované prvky jsou [1,2,3]. Součet zašifrovaných prvků je 1 + 2 + 3 == 6.

Příklad 2:

Vstup: nums = [10,21,31]
Výstup: 66
Vysvětlení: Zašifrované prvky jsou [11,22,33]. Součet zašifrovaných prvků je 11 + 22 + 33 == 66.

Omezení:

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

Dostanete celočíselné pole nums obsahující kladná celá čísla. Funkci encrypt definujeme tak, že encrypt(x) nahradí každou číslici v x největší číslicí v x. Například encrypt(523) = 555 a encrypt(213) = 333.
Vrátí součet zašifrovaných prvků.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 6
Vysvětlení: Zašifrované prvky jsou [1,2,3]. Součet zašifrovaných prvků je 1 + 2 + 3 == 6.

Příklad 2:

Vstup: nums = [10,21,31]
Výstup: 66
Vysvětlení: Zašifrované prvky jsou [11,22,33]. Součet zašifrovaných prvků je 11 + 22 + 33 == 66.

Omezení:

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

Je vám dáno celočíselné pole nums obsahující kladná čísla. Definujeme funkci encrypt tak, že encrypt(x) nahradí každou číslici v x největší číslicí v x. Například, encrypt(523) = 555 a encrypt(213) = 333.
Vrátit součet zašifrovaných prvků.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 6
Vysvětlení: Zašifrované prvky jsou [1,2,3]. Součet zašifrovaných prvků je 1 + 2 + 3 == 6.

Příklad 2:

Vstup: nums = [10,21,31]
Výstup: 66
Vysvětlení: Zašifrované prvky jsou [11,22,33]. Součet zašifrovaných prvků je 11 + 22 + 33 == 66.

Omezení:

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


Máte 0-indexované pole nums velikosti n, které se skládá z kladných celých čísel.
Dále máte 2D pole queries o velikosti m, kde queries[i] = [index_i, k_i].
Zpočátku jsou všechny prvky pole neoznačené.
Musíte aplikovat m dotazů na pole podle pořadí, kde při i-tém dotazu provedete následující:

Označte prvek na indexu index_i, pokud již není označen.
Potom označte k_i neoznačených prvků v poli s nejmenšími hodnotami. Pokud existuje více takových prvků, označte ty s nejmenšími indexy. A pokud je méně než k_i neoznačených prvků, pak označte všechny z nich.

Vrátí pole answer velikosti m, kde answer[i] je součet neoznačených prvků v poli po i-tém dotazu.

Příklad 1:

Vstup: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Výstup: [8,3,0]
Vysvětlení:
Provádíme následující dotazy na poli:

Označte prvek na indexu 1 a 2 nejmenší neoznačené prvky s nejmenšími indexy, pokud existují, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 2 + 2 + 3 + 1 = 8.
Označte prvek na indexu 3, jelikož je již označen, přeskočíme ho. Potom označíme 3 nejmenší neoznačené prvky s nejmenšími indexy, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 3.
Označte prvek na indexu 4, jelikož je již označen, přeskočíme ho. Potom označíme 2 nejmenší neoznačené prvky s nejmenšími indexy, pokud existují, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 0.

Příklad 2:

Vstup: nums = [1,4,2,3], queries = [[0,1]]
Výstup: [7]
Vysvětlení: Provádíme jeden dotaz, kterým označujeme prvek na indexu 0 a označujeme nejmenší prvek mezi neoznačenými prvky. Označené prvky budou nums = [1,4,2,3] a součet neoznačených prvků je 4 + 3 = 7.

Omezení:

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

Dostanete 0-indexované pole čísel o velikosti n sestávající z kladných celých čísel.
Dostanete také 2D pole dotazů o velikosti m, kde dotazy[i] = [index_i, k_i].
Zpočátku jsou všechny prvky pole neoznačené.
Musíte použít m dotazů na pole v pořadí, kde na i^tém dotazu provedete následující:

Označte prvek na indexu index_i, pokud již není označen.
Poté označte k_i neoznačených prvků v poli s nejmenšími hodnotami. Pokud existuje více takových prvků, označte ty s nejmenšími indexy. A pokud existuje méně než k_i neoznačených prvků, označte je všechny.

Vrátí odpověď pole o velikosti m, kde odpověď[i] je součet neoznačených prvků v poli po i^tém dotazu.

Příklad 1:

Vstup: nums = [1,2,2,1,2,3,1], dotazy = [[1,2],[3,3],[4,2]]
Výstup: [8,3,0]
Vysvětlení:
Na pole provádíme následující dotazy:

Označte prvek na indexu 1 a 2 nejmenších neoznačených prvků s nejmenšími indexy, pokud existují, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 2 + 2 + 3 + 1 = 8.
Označte prvek na indexu 3, protože je již označen, přeskočíme jej. Poté označíme 3 nejmenší neoznačené prvky nejmenšími indexy, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 3.
Označte prvek na indexu 4, protože je již označen, přeskočíme jej. Potom označíme 2 nejmenší neoznačené prvky nejmenšími indexy, pokud existují, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 0.

Příklad 2:

Vstup: nums = [1,4,2,3], dotazy = [[0,1]]
Výstup: [7]
Vysvětlení: Provedeme jeden dotaz, kterým je označení prvku na indexu 0 a označení nejmenšího prvku mezi neoznačenými prvky. Označené prvky budou nums = [1,4,2,3] a součet neoznačených prvků je 4 + 3 = 7.

Omezení:

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

Dostanete pole nums indexované 0 o velikosti n, které se skládá z kladných celých čísel.
Dostanete také 2D pole dotazů o velikosti m, kde queries[i] = [index_i, k_i].
Zpočátku nejsou všechny prvky pole označeny.
Na pole je třeba aplikovat m dotazy v pořadí, kde na i^tý dotaz provedete následující:

Označte element na indexové index_i pokud již není označen.
Poté označte k_i neoznačené prvky v poli s nejmenšími hodnotami. Pokud existuje více takových prvků, označte ty s nejmenšími indexy. A pokud existuje méně než k_i neoznačených elementů, označte je všechny.

Vrátí odpověď pole o velikosti m, kde answer[i] je součet neoznačených prvků v poli po i^tém dotazu.

Příklad 1:

Vstup: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Výstup: [8,3,0]
Vysvětlení:
Na poli provádíme následující dotazy:

Označte element na indexu 1 a 2 nejmenších neoznačených elementů s nejmenšími indexy, pokud existují, označené elementy jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 2 + 2 + 3 + 1 = 8.
Označte prvek na indexu 3, protože je již označen, přeskočíme jej. Poté označíme 3 nejmenší neoznačené prvky s nejmenšími indexy, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 3.
Označte prvek na indexu 4, protože je již označen, přeskočíme jej. Poté označíme 2 nejmenší neoznačené prvky nejmenšími indexy, pokud existují, označené prvky jsou nyní nums = [1,2,2,1,2,3,1]. Součet neoznačených prvků je 0.

Příklad 2:

Vstup: nums = [1,4,2,3], queries = [[0,1]]
Výstup: [7]
Vysvětlení: Provedeme jeden dotaz, který označí prvek na indexu 0 a označí nejmenší prvek mezi neoznačenými prvky. Označené prvky budou nums = [1,4,2,3] a součet neoznačených prvků je 4 + 3 = 7.

Omezení:

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


Je vám dán řetězec s. s[i] je buď malé anglické písmeno nebo '?'.
Pro řetězec t o délce m obsahující pouze malá anglická písmena definujeme funkci cost(i) pro index i jako počet znaků roven t[i], který se vyskytl před ním, tj. v rozsahu [0, i - 1].
Hodnota t je součtem cost(i) pro všechny indexy i.
Například pro řetězec t = "aab":

cost(0) = 0
cost(1) = 1
cost(2) = 0
Hodnota "aab" je tedy 0 + 1 + 0 = 1.

Vaším úkolem je nahradit všechny výskyty znaku "?" ve slově s libovolným malým anglickým písmenem tak, aby byla minimalizována hodnota písmene s.
Vrátí řetězec označující změněný řetězec s nahrazenými výskyty znaku '?'. Pokud existuje více řetězců, jejichž výsledkem je minimální hodnota, vrátí lexikograficky nejmenší z nich.

Příklad 1:

Vstup: s = "???"
Výstup: "abc"
Vysvětlení: V tomto příkladu můžeme nahradit výskyty '?' tak, aby se s rovnalo "abc".
Pro "abc" platí, že cost(0) = 0, cost(1) = 0 a cost(2) = 0.
Hodnota "abc" je 0.
Některé další modifikace s, které mají hodnotu 0, jsou "cba", "abz" a "hey".
Ze všech vybíráme lexikograficky nejmenší.

Příklad 2:

Vstup: s = "a?a?"
Výstup: "abac"
Vysvětlení: V tomto příkladu lze výskyty slova '?' nahradit tak, aby se s rovnalo "abac".
Pro "abac" platí, že cost(0) = 0, cost(1) = 0, cost(2) = 1 a cost(3) = 0.
Hodnota "abac" je 1.

Omezení:

1 <= s.length <= 10^5
s[i] je buď malé anglické písmeno nebo '?'.

Je vám dán řetězec s. s[i] je buď malé anglické písmeno nebo '?'.
Pro řetězec t o délce m obsahující pouze malá anglická písmena definujeme funkci náklady(i) pro index i jako počet znaků rovný t[i], které se objevily před ním, tj. v rozsahu [0, i - 1].
Hodnota t je součtem nákladů (i) pro všechny indexy i.
Například pro řetězec t = "aab":

náklady(0) = 0
náklady(1) = 1
náklady(2) = 0
Hodnota "aab" je tedy 0 + 1 + 0 = 1.

Vaším úkolem je nahradit všechny výskyty '?' v s s libovolným malým anglickým písmenem, takže hodnota s je minimalizována.
Vrátíte řetězec označující upravený řetězec s nahrazenými výskyty '?'. Pokud existuje více řetězců s minimální hodnotou, vraťte lexikograficky nejmenší.

Příklad 1:

Vstup: s = "???"
Výstup: "abc"
Vysvětlení: V tomto příkladu můžeme nahradit výskyty '?' aby se s rovnalo "abc".
Pro „abc“ cost(0) = 0, cost(1) = 0 a cost(2) = 0.
Hodnota "abc" je 0.
Některé další modifikace s, které mají hodnotu 0, jsou "cba", "abz" a "hey".
Mezi všemi vybíráme lexikograficky nejmenší.

Příklad 2:

Vstup: s = "a?a?"
Výstup: "abac"
Vysvětlení: V tomto příkladu jsou výskyty '?' lze nahradit, aby se s rovnalo "abac".
Pro „abac“ cost(0) = 0, cost(1) = 0, cost(2) = 1 a cost(3) = 0.
Hodnota "abac" je 1.

Omezení:

1 <= s délka <= 10^5
s[i] je buď malé anglické písmeno nebo '?'.

Je vám dán řetězec s. s[i] je buď malé anglické písmeno nebo '?'.
Pro řetězec t o délce m obsahující pouze malá anglická písmena definujeme funkci cost(i) pro index i jako počet znaků rovný t[i], které se objevily před ním, tj. v rozsahu [0, i - 1].
Hodnota t je součtem nákladů (i) pro všechny indexy i.
Například pro řetězec t = "aab":

cena(0) = 0
cena(1) = 1
cena(2) = 0
Hodnota "aab" je tedy 0 + 1 + 0 = 1.

Vaším úkolem je nahradit všechny výskyty '?' v s s libovolným malým anglickým písmenem, takže hodnota s je minimalizována.
Vrátí řetězec označující upravený řetězec s nahrazenými výskyty '?'. Pokud existuje více řetězců, jejichž výsledkem je minimální hodnota, vraťte lexikograficky nejmenší.

Příklad 1:

Vstup: s = "???"
Výstup: "abc"
Vysvětlení: V tomto příkladu můžeme nahradit výskyty '?' aby se s rovnalo "abc".
Pro "abc“ cost(0) = 0, cost(1) = 0 a cost(2) = 0.
Hodnota "abc" je 0.
Některé další modifikace s, které mají hodnotu 0, jsou "cba", "abz" a "hey".
Mezi všemi vybíráme lexikograficky nejmenší.

Příklad 2:

Vstup: s = "a?a?"
Výstup: "abac"
Vysvětlení: V tomto příkladu jsou výskyty '?' lze nahradit, aby se s rovnalo "abac".
Pro "abac“ cost(0) = 0, cost(1) = 0, cost(2) = 1 a cost(3) = 0.
Hodnota "abac" je 1.

Omezení:

1 <= s.length <= 10^5
s[i] je buď malé anglické písmeno nebo '?'.


Je vám dáno celočíselné pole nums délky n a kladné celé číslo k.
síla celočíselného pole je definována jako počet podposloupností, jejichž součet je roven k.
Vraťtesoučet sil všech podposloupností z nums.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup:   nums = [1,2,3], k = 3
Výstup:   6
Vysvětlení:
Existuje 5 podposloupností nums s nenulovou silou:

Podposloupnost [1,2,3] má 2 podposloupnosti se součtem == 3: [1,2,3] a [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].

Proto je odpověď 2 + 1 + 1 + 1 + 1 = 6.

Příklad 2:

Vstup:   nums = [2,3,3], k = 5
Výstup:   4
Vysvětlení:
Existují 3 podposloupnosti nums s nenulovou silou:

Podposloupnost [2,3,3] má 2 podposloupnosti se součtem == 5: [2,3,3] a [2,3,3].
Podposloupnost [2,3,3] má 1 podposloupnost se součtem == 5: [2,3,3].
Podposloupnost [2,3,3] má 1 podposloupnost se součtem == 5: [2,3,3].

Proto je odpověď 2 + 1 + 1 = 4.

Příklad 3:

Vstup:   nums = [1,2,3], k = 7
Výstup:   0
Vysvětlení: Neexistuje žádná podposloupnost se součtem 7. Proto mají všechny podposloupnosti nums sílu = 0.

Omezení:

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

Je dáno celočíselné pole nums délky n a kladné celé číslo k.
Mocnina pole celých čísel je definována jako počet podřetězců, jejichž součet je roven k.
Vraťte součet mocnin všech podřetězců pole nums.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3], k = 3
Výstup:   6
Vysvětlení:
Existuje 5 podřetězců nums s nenulovou mocninou:

V podřetězci [1,2,3] jsou 2 podřetězce se součtem == 3: [1,2,3] a [1,2,3].
podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].

Proto je odpověď 2 + 1 + 1 + 1 + 1 = 6.

Příklad 2:

Vstup: nums = [2,3,3], k = 5
Výstup:   4
Vysvětlení:
Existují 3 podřetězce nums s nenulovou mocninou:

V podřetězci [2,3,3] jsou 2 podřetězce se součtem == 5: [2,3,3] a [2,3,3].
podposloupnost [2,3,3] má 1 podposloupnost se součtem == 5: [2,3,3].
podposloupnost [2,3,3] má 1 podposloupnost se součtem == 5: [2,3,3].

Odpověď je tedy 2 + 1 + 1 = 4.

Příklad 3:

Vstup: nums = [1,2,3], k = 7
Výstup:   0
Vysvětlení: Neexistuje žádná posloupnost se součtem 7. Proto mají všechny následné posloupnosti nums mocninu = 0.

Omezení:

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

Je vám dáno celočíselné pole nums o délce n a kladné celé číslo k.
Síla pole celých čísel je definována jako počet podposloupností s jejich součtem rovným k.
Vrátí součet mocniny všech podposloupností nums.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3], k = 3
Výstup: 6
Vysvětlení:
Existuje 5 podposloupností nums s nenulovým výkonem:

Podposloupnost [1,2,3] má 2 podposloupnosti se součtem == 3: [1,2,3] a [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].
Podposloupnost [1,2,3] má 1 podposloupnost se součtem == 3: [1,2,3].

Odpověď je tedy 2 + 1 + 1 + 1 + 1 = 6.

Příklad 2:

Vstup: nums = [2,3,3], k = 5
Výstup: 4
Vysvětlení:
Existují 3 podposloupnosti nums s nenulovým výkonem:

Podposloupnost [2,3,3] má 2 podposloupnosti se součtem == 5: [2,3,3] a [2,3,3].
Podposloupnost [2,3,3] má 1 podposloupnost se součtem == 5: [2,3,3].
Podposloupnost [2,3,3] má 1 podposloupnost se součtem == 5: [2,3,3].

Odpověď je tedy 2 + 1 + 1 = 4.

Příklad 3:

Vstup: nums = [1,2,3], k = 7
Výstup: 0
Vysvětlení: Neexistuje žádná podposloupnost se součtem 7. Proto všechny podposloupnosti nums mají mocninu = 0.

Omezení:

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


Máte pole **nums** obsahující nezáporná celá čísla a celé číslo **k**.
Pole se nazývá speciální, pokud jeho bitové **OR** pro všechny jeho prvky je alespoň **k**.
Vrátí délku nejkratší speciální neprázdné podpole z **nums**, nebo vrátí **-1**, pokud žádné speciální podpole neexistuje.

Příklad 1:

Vstup: nums = [1,2,3], k = 2
Výstup: 1
Vysvětlení:
Podposloupnost [3] má OR 3. Tudíž, vracíme 1.

Příklad 2:

Vstup: nums = [2,1,8], k = 10
Výstup: 3
Vysvětlení:
Podposloupnost [2,1,8] má hodnotu OR 11. Tudíž, vracíme 3.

Příklad 3:

Vstup: **nums = [1,2]**, **k = 0**
Výstup: **1**
Vysvětlení:
Podpole **[1]** má hodnotu operátoru **OR** rovnou 1. Proto vracíme 1.

Omezení:

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

Dostanete pole s čísly nezáporných celých čísel a celé číslo k.
Pole se nazývá speciální, pokud je bitové OR všech jeho prvků alespoň k.
Vrátí délku nejkratšího speciálního neprázdného podpole nums, nebo vrátí -1, pokud žádné speciální podpole neexistuje.

Příklad 1:

Vstup: nums = [1,2,3], k = 2
Výstup: 1
Vysvětlení:
Podpole [3] má hodnotu OR 3. Vrátíme se tedy 1.

Příklad 2:

Vstup: nums = [2,1,8], k = 10
Výstup: 3
Vysvětlení:
Podpole [2,1,8] má hodnotu OR 11. Vrátíme se tedy 3.

Příklad 3:

Vstup: nums = [1,2], k = 0
Výstup: 1
Vysvětlení:
Podpole [1] má hodnotu OR 1. Vrátíme se tedy 1.

Omezení:

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

Je zadáno pole nums nezáporných celých čísel a celé číslo k.
Pole se nazývá speciální, pokud bitová OR všech jeho prvků je alespoň k.
Vraťte délku nejkratšího speciálního neprázdného pole nums nebo vraťte -1, pokud žádné speciální pole neexistuje.

Příklad 1:

Vstup: nums = [1,2,3], k = 2
Výstup: 1
Vysvětlení:
Podpole [3] má hodnotu bitové OR 3. Proto vracíme 1.

Příklad 2:

Vstup: nums = [2,1,8], k = 10
Výstup: 3
Vysvětlení:
Podpole [2,1,8] má hodnotu bitové OR 11. Proto vracíme 3.

Příklad 3:

Vstup: nums = [1,2], k = 0
Výstup: 1
Vysvětlení:
Podpole [3] má hodnotu bitové OR 3. Proto vracíme 1.

Omezení:

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


Dostanete binární pole možné délky n.
Alice a Bob hrají hru, která se skládá z n úrovní. Některé úrovně ve hře nelze vymazat, zatímco jiné lze vymazat vždy. Konkrétně, pokud je to možné[i] == 0, pak i^-tou úroveň nelze vymazat pro oba hráče. Hráč získá 1 bod za vyčištění úrovně a ztratí 1 bod, pokud se mu nepodaří ji vyčistit.
Na začátku hry Alice odehraje několik úrovní v daném pořadí počínaje 0^-tou úrovní, po které bude Bob hrát zbytek úrovní.
Alice chce znát minimální počet úrovní, které by měla hrát, aby získala více bodů než Bob, pokud oba hráči hrají optimálně, aby maximalizovali své body.
Vraťte minimální počet úrovní, které by Alice měla hrát, aby získala více bodů. Pokud to není možné, vraťte -1.
Pamatujte, že každý hráč musí hrát alespoň 1 úroveň.

Příklad 1:

Vstup: možný = [1,0,1,0]
Výstup: 1
Vysvětlení:
Podívejme se na všechny úrovně, do kterých může Alice hrát:

Pokud Alice hraje pouze úroveň 0 a Bob hraje zbytek úrovní, Alice má 1 bod, zatímco Bob má -1 + 1 - 1 = -1 bod.
Pokud Alice hraje do úrovně 1 a Bob hraje zbytek úrovní, Alice má 1 - 1 = 0 bodů, zatímco Bob má 1 - 1 = 0 bodů.
Pokud Alice hraje do úrovně 2 a Bob hraje zbytek úrovní, Alice má 1 - 1 + 1 = 1 bod, zatímco Bob má -1 bod.

Alice musí hrát minimálně 1 úroveň, aby získala více bodů.

Příklad 2:

Vstup: možný = [1,1,1,1,1]
Výstup: 3
Vysvětlení:
Podívejme se na všechny úrovně, do kterých může Alice hrát:

Pokud Alice hraje pouze úroveň 0 a Bob hraje zbytek úrovní, Alice má 1 bod, zatímco Bob má 4 body.
Pokud Alice hraje do úrovně 1 a Bob hraje zbytek úrovní, Alice má 2 body, zatímco Bob má 3 body.
Pokud Alice hraje do úrovně 2 a Bob hraje zbytek úrovní, Alice má 3 body, zatímco Bob má 2 body.
Pokud Alice hraje do úrovně 3 a Bob hraje zbytek úrovní, Alice má 4 body, zatímco Bob má 1 bod.

Alice musí hrát minimálně 3 úrovně, aby získala více bodů.

Příklad 3:

Vstup: možný = [0,0]
Výstup: -1
Vysvětlení:
Jediný možný způsob je, že oba hráči odehrají každý 1 úroveň. Alice hraje úroveň 0 a ztrácí 1 bod. Bob hraje úroveň 1 a ztrácí 1 bod. Protože oba hráči mají stejné body, Alice nemůže získat více bodů než Bob.

Omezení:

2 <= n == možné.length <= 10^5
možné[i] je buď 0 nebo 1.


Dostanete celé pole čísel délky n a kladné celé číslo k.
Mocnina podposloupnosti je definována jako minimální absolutní rozdíl mezi libovolnými dvěma prvky v podsekvenci.
Vraťte součet mocnin všech dílčích posloupností čísel, které mají délku rovnou k.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3,4], k = 3
Výstup: 4
Vysvětlení:
Existují 4 podsekvence v počtech, které mají délku 3: [1,2,3], [1,3,4], [1,2,4] a [2,3,4]. Součet mocnin je |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Příklad 2:

Vstup: nums = [2,2], k = 2
Výstup: 0
Vysvětlení:
Jediná podposloupnost v počtech, která má délku 2, je [2,2]. Součet mocnin je |2 - 2| = 0.

Příklad 3:

Vstup: nums = [4,3,-1], k = 2
Výstup: 10
Vysvětlení:
Existují 3 dílčí posloupnosti v číslech, které mají délku 2: [4,3], [4,-1] a [3,-1]. Součet mocnin je |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Omezení:

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

Dostanete celé pole čísel délky n a kladné celé číslo k.
Mocnina podposloupnosti je definována jako minimální absolutní rozdíl mezi libovolnými dvěma prvky v podsekvenci.
Vraťte součet mocnin všech dílčích posloupností čísel, které mají délku rovnou k.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3,4], k = 3
Výstup: 4
Vysvětlení:
Existují 4 dílčí posloupnosti v počtech, které mají délku 3: [1,2,3], [1,3,4], [1,2,4] a [2,3,4]. Součet mocnin je |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Příklad 2:

Vstup: nums = [2,2], k = 2
Výstup: 0
Vysvětlení:
Jediná podposloupnost v počtech, která má délku 2, je [2,2]. Součet mocnin je |2 - 2| = 0.

Příklad 3:

Vstup: nums = [4,3,-1], k = 2
Výstup: 10
Vysvětlení:
Existují 3 dílčí posloupnosti v číslech, které mají délku 2: [4,3], [4,-1] a [3,-1]. Součet mocnin je |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Omezení:

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

Je zadáno celočíselné pole nums délky n a kladné celé číslo k.
Mocnina posloupnosti je definována jako minimální absolutní rozdíl mezi libovolnými dvěma prvky v posloupnosti.
Vraťte součet mocnin všech podřetězců nums, jejichž délka je rovna k.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [1,2,3,4], k = 3
Výstup: 4
Vysvětlení:
V nums jsou 4 podřetězce o délce 3: [1,2,3], [1,3,4], [1,2,4] a [2,3,4]. Součet mocnin je |2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4.

Příklad 2:

Vstup: nums = [2,2], k = 2
Výstup: 0
Vysvětlení:
Jediná posloupnost v nums, která má délku 2, je [2,2]. Součet mocnin je |2 - 2| = 0.

Příklad 3:

Vstup: nums = [4,3,-1], k = 2
Výstup: 10
Vysvětlení:
V nums jsou 3 podřetězce o délce 2: [4,3], [4,-1] a [3,-1]. Součet mocnin je |4 - 3| + |4 - (-1)| + |3 - (-1)| = 10.

Omezení:

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


Je dán řetězec s. Skóre řetězce je definováno jako součet absolutních rozdílů mezi ASCII hodnotami sousedních znaků. Vraťte skóre řetězce s.

Příklad 1:

Vstup: s = "hello"
Výstup: 13
Vysvětlení:
ASCII hodnoty znaků v s jsou: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Skóre řetězce s by tedy bylo |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Příklad 2:

Vstup: s = "zaz"
Výstup: 50
Vysvětlení:
ASCII hodnoty znaků v s jsou: 'z' = 122, 'a' = 97. Skóre řetězce s by tedy bylo |122 - 97| + |97 - 122| = 25 + 25 = 50.

Omezení:

2 <= s.length <= 100
s se skládá pouze z malých písmen anglické abecedy.

Byl vám poskytnut řetězec \(s\). Skóre řetězce je definováno jako součet absolutních rozdílů mezi ASCII hodnotami sousedních znaků.
Vraťte skóre řetězce \(s\).

Příklad 1:

Vstup: s = "hello"
Výstup: 13
Vysvětlení:
ASCII hodnoty znaků v s jsou: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Skóre řetězce s by tedy bylo |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Příklad 2:

Vstup: s = "zaz"
Výstup: 50
Vysvětlení:
ASCII hodnoty znaků v s jsou: 'z' = 122, 'a' = 97. Skóre řetězce s by tedy bylo |122 - 97| + |97 - 122| = 25 + 25 = 50.

Omezení:

2 <= s.length <= 100
s se skládá pouze z malých písmen anglické abecedy.

Je vám dán řetězec s. Skóre řetězce je definováno jako součet absolutního rozdílu mezi hodnotami ASCII sousedních znaků.
Vrátí skóre s.

Příklad 1:

Vstup: s = "hello"
Výstup: 13
Vysvětlení:
ASCII hodnoty znaků v s jsou: 'h' = 104, 'e' = 101, 'l' = 108, 'o' = 111. Skóre s by tedy bylo |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

Příklad 2:

Vstup: s = "zaz"
Výstup: 50
Vysvětlení:
ASCII hodnoty znaků v s jsou: 'z' = 122, 'a' = 97. Skóre s by tedy bylo |122 - 97| + |97 - 122| = 25 + 25 = 50.

Omezení:

2 <= s.length <= 100
s se skládá pouze z malých anglických písmen.


Dostanete pole kladných celých čísel.
Vrátí počet podpolí nums, kde první a poslední prvek podpole se rovná největšímu prvku v podpoli.

Příklad 1:

Vstup: nums = [1,4,3,3,2]
Výstup: 6
Vysvětlení:
Existuje 6 podpolí, jejichž první a poslední prvek se rovná největšímu prvku podpole:

podpole [1,4,3,3,2] s největším prvkem 1. První prvek je 1 a poslední prvek je také 1.
podpole [1,4,3,3,2] s největším prvkem 4. První prvek je 4 a poslední prvek je také 4.
podpole [1,4,3,3,2] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [1,4,3,3,2] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [1,4,3,3,2] s největším prvkem 2. První prvek je 2 a poslední prvek je také 2.
podpole [1,4,3,3,2] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.

Vracíme se tedy 6.

Příklad 2:

Vstup: nums = [3,3,3]
Výstup: 6
Vysvětlení:
Existuje 6 podpolí, jejichž první a poslední prvek se rovná největšímu prvku podpole:

podpole [3,3,3] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3] s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.

Vracíme se tedy 6.

Příklad 3:

Vstup: nums = [1]
Výstup: 1
Vysvětlení:
Existuje jediné podpole čísel, která je [1] s největším prvkem 1. První prvek je 1 a poslední prvek je také 1.
Proto se vracíme 1.

Omezení:

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

Je zadáno pole kladných celých čísel nums.
Vraťte počet podpolí nums, kde první a poslední prvek podpole je roven největšímu prvku v podpole.

Příklad 1:

Vstup: nums = [1,4,3,3,2]
Výstup: 6
Vysvětlení:
Je zde 6 dílčích polí, jejichž první a poslední prvek se rovná největšímu prvku dílčího pole:

Nums: podřetězec [1,4,3,3,2], jehož největší prvek je 1. První prvek je 1 a poslední prvek je také 1.
podřetězec [1,4,3,3,2], jehož největší prvek je 4. První prvek je 4 a poslední prvek je také 4.
podřetězec [1,4,3,3,2], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.
podřetězec [1,4,3,3,2], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.
podřetězec [1,4,3,3,2], jehož největší prvek je 2. První prvek je 2 a poslední prvek je také 2.
podřetězec [1,4,3,3,2], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.

Proto vracíme 6.

Příklad 2:

Vstup: nums = [3,3,3]
Výstup: 6
Vysvětlení:
Je zde 6 dílčích polí, jejichž první a poslední prvek se rovná největšímu prvku dílčího pole:

podřetězec [3,3,3], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.
podřetězec [3,3,3], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.
podřetězec [3,3,3], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.
podřetězec [3,3,3], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.
podřetězec [3,3,3], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.
podřetězec [3,3,3], jehož největší prvek je 3. První prvek je 3 a poslední prvek je také 3.

Proto vracíme 6.

Příklad 3:

Vstup: nums = [1]
Výstup: 1
Vysvětlení:
V poli nums je jediné podřetězce [1], jehož největším prvkem je 1. První prvek je 1 a poslední prvek je také 1.
Proto vracíme 1.

Omezení:

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

Dáné je pole kladných celých čísel nums.
Vraťte počet podpolí z nums, kde první a poslední prvek podpole jsou rovny největšímu prvku v podpoli.

Příklad 1:

Vstup: nums = [1,4,3,3,2]
Výstup: 6
Vysvětlení:
Existuje 6 podpolí, kde první a poslední prvek se rovná největšímu prvku v podpoli:

podpole [1,4,3,3,2], s největším prvkem 1. První prvek je 1 a poslední prvek je také 1.
podpole [1,4,3,3,2], s největším prvkem 4. První prvek je 4 a poslední prvek je také 4.
podpole [1,4,3,3,2], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [1,4,3,3,2], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [1,4,3,3,2], s největším prvkem 2. První prvek je 2 a poslední prvek je také 2.
podpole [1,4,3,3,2], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.

Takže vracíme 6.

Příklad 2:

Vstup: nums = [3,3,3]
Výstup: 6
Vysvětlení:
Existuje 6 podpolí, kde první a poslední prvek se rovná největšímu prvku v podpoli:

podpole [3,3,3], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.
podpole [3,3,3], s největším prvkem 3. První prvek je 3 a poslední prvek je také 3.

Takže vracíme 6.

Příklad 3:

Vstup: nums = [1]
Výstup: 1
Vysvětlení:
Existuje jediná podpole z nums, která je [1], s největším prvkem 1. První prvek je 1 a poslední prvek je také 1.
Takže vracíme 1.

Omezení:

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


Je dán řetězec word. Písmeno se nazývá speciální, pokud se v řetězci vyskytuje jak ve formě malého, tak velkého písmene.
Vraťte počet speciálních písmen v řetězci word.

Příklad 1:

Vstup: word = "aaAbcBC"
Výstup: 3
Vysvětlení:
Speciálními znaky v řetězci jsou 'a', 'b' a 'c'.

Příklad 2:

Vstup: word = "abc"
Výstup: 0
Vysvětlení:
Žádný znak v řetězci se nevyskytuje ve velkém písmenu.

Příklad 3:

Vstup: word = "abBCab"
Výstup: 1
Vysvětlení:
Jediným speciálním znakem v řetězci je 'b'.

Omezení:

1 <= word.length <= 50
word se skládá pouze z malých a velkých anglických písmen.

Je vám přiděleno řetězcové slovo. Písmeno se nazývá speciální, pokud se ve Wordu vyskytuje malými i velkými písmeny.
Vrátí počet speciálních písmen ve wordu.

Příklad 1:

Vstup: word = "aaAbcBC"
Výstup: 3
Vysvětlení:
Speciální znaky ve slově jsou 'a', 'b' a 'c'.

Příklad 2:

Vstup: word = "abc"
Výstup: 0
Vysvětlení:
Žádný znak ve Wordu se nezobrazuje velkými písmeny.

Příklad 3:

Vstup: word = "abBCab"
Výstup: 1
Vysvětlení:
Jediným speciálním znakem ve Wordu je 'b'.

Omezení:

1 <= word.length <= 50
word se skládá pouze z malých a velkých anglických písmen.

Je zadáno řetězcové slovo. Písmeno se nazývá speciální, pokud se ve slově vyskytuje jak malými, tak velkými písmeny.
Vraťte počet speciálních písmen ve slově.

Příklad 1:

Vstup: slovo = „aaAbcBC“
Výstup: 3
Vysvětlení:
Speciální znaky ve slově jsou „a“, „b“ a „c“.

Příklad 2:

Vstup: word = „abc“
Výstup: 0
Vysvětlení:
Žádný znak ve slově není napsán velkými písmeny.

Příklad 3:

Vstup: slovo = „abBCab“
Výstup: 1
Vysvětlení:
Jediným speciálním znakem ve slově je 'b'.

Omezení:

1 <= word.length <= 50
slovo se skládá pouze z malých a velkých anglických písmen.


Máte k dispozici dva pole čísel stejné délky, `nums1` a `nums2`.
Ke každému prvku v poli `nums1` bylo přičteno (nebo v případě záporných čísel odečteno) celé číslo reprezentované proměnnou x.
V důsledku toho se pole čísel `nums1` stává rovné poli `nums2`. Dvě pole čísel jsou považována za rovná, pokud obsahují stejná čísla se stejnými frekvencemi.
Vraťte celé číslo `x`.

Příklad 1:

Vstup: nums1 = [2,6,4], nums2 = [9,7,5]
Výstup: 3
Vysvětlení:
Celé číslo přidané ke každému prvku nums1 je 3.

Příklad 2:

Vstup: nums1 = [10], nums2 = [5]
Výstup: -5
Vysvětlení:
K celé číslu přidanému ke každému prvku nums1 je -5.

Příklad 3:

Vstup: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Výstup: 0
Vysvětlení:
K celé číslu přidanému ke každému prvku nums1 je 0.

Omezení:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Testovací případy jsou generovány takovým způsobem, že existuje celé číslo x, takže nums1 se může stát rovno nums2 přidáním x ke každému prvku nums1.

Dostanete dvě pole stejné délky, nums1 a nums2.
Každý prvek v nums1 byl zvětšen (nebo zmenšen v případě záporného) o celé číslo, reprezentované proměnnou x.
V důsledku toho se číslo1 bude rovnat číslu2. Dvě pole jsou považována za stejná, pokud obsahují stejná celá čísla se stejnými frekvencemi.
Vrátí celé číslo x.

Příklad 1:

Vstup: nums1 = [2,6,4], nums2 = [9,7,5]
Výstup: 3
Vysvětlení:
Celé číslo přidané ke každému prvku nums1 je 3.

Příklad 2:

Vstup: nums1 = [10], nums2 = [5]
Výstup: -5
Vysvětlení:
Celé číslo přidané ke každému prvku nums1 je -5.

Příklad 3:

Vstup: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Výstup: 0
Vysvětlení:
Celé číslo přidané ke každému prvku nums1 je 0.

Omezení:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Testovací případy jsou generovány tak, že existuje celé číslo x takové, že nums1 se může rovnat nums2 přidáním x ke každému prvku nums1.

Máte dva pole stejné délky, nums1 a nums2.
Každý prvek v nums1 byl zvýšen (nebo snížen v případě záporného čísla) o celé číslo, které je reprezentováno proměnnou x.
Výsledkem je, že nums1 se stane rovno nums2. Dvě pole jsou považována za rovná, když obsahují stejná celá čísla se stejnou frekvencí.
Vraťte celé číslo x.

Příklad 1:

Vstup: nums1 = [2,6,4], nums2 = [9,7,5]
Výstup: 3
Vysvětlení:
K celé číslu přidanému ke každému prvku nums1 je 3.

Příklad 2:

Vstup: nums1 = [10], nums2 = [5]
Výstup: -5
Vysvětlení:
K celé číslu přidanému ke každému prvku nums1 je -5.

Příklad 3:

Vstup: nums1 = [1,1,1,1], nums2 = [1,1,1,1]
Výstup: 0
Vysvětlení:
K celé číslu přidanému ke každému prvku nums1 je 0.

Omezení:

1 <= nums1.length == nums2.length <= 100
0 <= nums1[i], nums2[i] <= 1000
Testovací případy jsou generovány takovým způsobem, že existuje celé číslo x, takže nums1 se může stát rovno nums2 přidáním x ke každému prvku nums1.


Jsou dána dvě celá čísla n a x. Je třeba sestrojit pole kladných celých čísel nums velikosti n, kde pro každé 0 <= i < n - 1 je nums[i + 1] větší než nums[i] a výsledkem operace bitové AND mezi všemi prvky nums je x.
Vraťte minimální možnou hodnotu nums[n - 1].

Příklad 1:

Vstup: n = 3, x = 4
Výstup: 6
Vysvětlení:
n může být [4,5,6] a jeho posledním prvkem je 6.

Příklad 2:

Vstup: n = 2, x = 7
Výstup: 15
Vysvětlení:
nums může být [7,15] a jeho posledním prvkem je 15.

Omezení:

1 <= n, x <= 10^8

Jsou vám dána dvě celá čísla n a x. Musíte zkonstruovat pole kladných celých čísel nums velikosti n, kde pro každý 0 <= i < n - 1 platí, že nums[i + 1] je větší než nums[i], a výsledek bitové operace AND mezi všemi prvky nums je x.
Vrátí minimální možnou hodnotu nums[n - 1].

Příklad 1:

Vstup: n = 3, x = 4
Výstup: 6
Vysvětlení:
nums může být [4,5,6] a jeho poslední prvek je 6.

Příklad 2:

Vstup: n = 2, x = 7
Výstup: 15
Vysvětlení:
nums může být [7,15] a jeho poslední prvek je 15.

Omezení:

1 <= n, x <= 10^8


Je zadáno celočíselné pole nums. Pole jedinečnosti nums je setříděné pole, které obsahuje počet odlišných prvků všech dílčích polí nums. Jinými slovy je to setříděné pole složené z distinct(nums[i..j]), pro všechny 0 <= i <= j < nums.length.
Zde distinct(nums[i..j]) označuje počet odlišných prvků v podoblasti, která začíná na indexu i a končí na indexu j.
Vrátí medián pole jedinečnosti nums.
Všimněte si, že medián pole je definován jako prostřední prvek pole, pokud je seřazeno v neklesajícím pořadí. Pokud jsou pro medián dvě možnosti, vezme se menší z obou hodnot.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 1
Vysvětlení:
Pole jedinečnosti čísel je [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])], které se rovná [1, 1, 1, 2, 2, 3]. Pole jedinečnosti má medián 1. Odpověď je tedy 1.

Příklad 2:

Vstup: nums = [3,4,3,4,5]
Výstup: 2
Vysvětlení:
Pole jedinečnosti nums je [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Pole jedinečnosti má medián 2. Odpověď je tedy 2.

Příklad 3:

Vstup: nums = [4,3,5,4]
Výstup: 2
Vysvětlení:
Pole jedinečnosti nums je [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3]. Pole jedinečnosti má medián 2. Proto je odpověď 2.

Omezení:

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

Dané je celé číslo pole `nums`. Pole unikátních hodnot `nums` je seřazené pole, které obsahuje počet unikátních prvků všech podpolí pole `nums`. Jinými slovy, jedná se o seřazené pole sestávající z distinct(nums[i..j]) pro všechna 0 <= i <= j < nums.length.
Zde distinct(nums[i..j]) označuje počet unikátních prvků v podpoli, které začíná na indexu i a končí na indexu j.
Vraťte medián pole unikátních hodnot `nums`.
Uvědomte si, že medián pole je definován jako střední prvek pole, když je seřazeno ve vzestupném pořadí. Pokud existují dvě možnosti pro medián, vezme se menší z obou hodnot.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 1
Vysvětlení:
Pole unikátních hodnot `nums` je [distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])] což je rovno [1, 1, 1, 2, 2, 3]. Pole unikátních hodnot má medián 1. Proto je odpověď 1.

Příklad 2:

Vstup: nums = [3,4,3,4,5]
Výstup: 2
Vysvětlení:
Pole unikátních hodnot `nums` je [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Pole unikátních hodnot má medián 2. Proto je odpověď 2.

Příklad 3:

Vstup: nums = [4,3,5,4]
Výstup: 2
Vysvětlení:
Unikátní pole pole `nums` je [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. pole unikátnych hodnot má medián 2. Proto je odpověď 2.

Omezení:

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

Dostanete celočíselné pole nums. Jedinečnost pole nums je seřazené pole, které obsahuje počet odlišných prvků všech podpolí nums. Jinými slovy, je to seřazené pole skládající se z různých(nums[i..j]), pro všechny 0 <= i <= j < nums.length.
Zde different(nums[i..j]) označuje počet odlišných prvků v dílčím poli, které začíná na indexu i a končí na indexu j.
Vraťte medián pole jedinečnosti čísel.
Všimněte si, že medián pole je definován jako střední prvek pole, když je seřazeno v neklesajícím pořadí. Pokud existují dvě možnosti pro medián, použije se menší z těchto dvou hodnot.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 1
Vysvětlení:
Jedinečné pole nums je [distinct(nums[0..0]), different(nums[1..1]), different(nums[2..2]), different(nums[0..1]) , different(nums[1..2]), different(nums[0..2])] což se rovná [1, 1, 1, 2, 2, 3]. Pole jedinečnosti má medián 1. Proto je odpověď 1.

Příklad 2:

Vstup: nums = [3,4,3,4,5]
Výstup: 2
Vysvětlení:
Pole jedinečnosti čísel je [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]. Pole jedinečnosti má medián 2. Proto je odpověď 2.

Příklad 3:

Vstup: nums = [4,3,5,4]
Výstup: 2
Vysvětlení:
Pole jednoznačnosti čísel je [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]. Pole jedinečnosti má medián 2. Proto je odpověď 2.

Omezení:

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


Slovo je považováno za platné, pokud:

Obsahuje minimálně 3 znaky.
Obsahuje pouze číslice (0-9) a anglická písmena (malá a velká).
Obsahuje alespoň jednu samohlásku.
Obsahuje alespoň jednu souhlásku.

Je zadán řetězec slov.
Vrátí true, pokud je slovo platné, jinak vrátí false.
Poznámky:

'a', 'e', 'i', 'o', 'u' a jejich velká písmena jsou samohlásky.
Souhláska je anglické písmeno, které není samohláskou.

Příklad 1:

Vstup: slovo = „234Adas“
Výstup: true
Vysvětlení:
Toto slovo splňuje podmínky.

Příklad 2:

Vstup: slovo = „b3“
Výstup: false
Vysvětlení:
Délka tohoto slova je menší než 3 a nemá samohlásku.

Příklad 3:

Vstup: slovo = „a3$e“
Výstup: false
Vysvětlení:
Toto slovo obsahuje znak „$“ a nemá souhlásku.

Omezení:

1 <= word.length <= 20
slovo se skládá z velkých a malých anglických písmen, číslic, znaků '@', '#' a '$'.

Slovo se považuje za platné, pokud:

Obsahuje minimálně 3 znaky.
Obsahuje pouze číslice (0-9) a anglická písmena (velká a malá).
Obsahuje alespoň jednu samohlásku.
Obsahuje alespoň jednu souhlásku.

Je vám přiděleno řetězcové slovo.
Vrátí hodnotu true, pokud je slovo platné, v opačném případě vrátí hodnotu false.
Poznámky:

'a', 'e', 'i', 'o', 'u' a jejich velká písmena jsou samohlásky.
Souhláska je anglické písmeno, které není samohláskou.

Příklad 1:

Vstup: word = "234Adas"
Výstup: true
Vysvětlení:
Toto slovo splňuje podmínky.

Příklad 2:

Vstup: word = "b3"
Výstup: false
Vysvětlení:
Délka tohoto slova je menší než 3 a nemá samohlásku.

Příklad 3:

Vstup: word = "a3$e"
Výstup: false
Vysvětlení:
Toto slovo obsahuje znak '$' a nemá souhlásku.

Omezení:

1 <= word.length <= 20
word se skládá z anglických velkých a malých písmen, číslic, '@', '#' a '$'.

Slovo je považováno za platné, pokud:

Obsahuje minimálně 3 znaky.
Obsahuje pouze číslice (0-9) a anglická písmena (velká a malá písmena).
Obsahuje alespoň jednu samohlásku.
Obsahuje alespoň jednu souhlásku.

Dostanete řetězcové slovo.
Vraťte hodnotu true, pokud je slovo platné, v opačném případě vrátí hodnotu false.
Poznámky:

'a', 'e', 'i', 'o', 'u' a jejich velká písmena jsou samohlásky.
Souhláska je anglické písmeno, které není samohláskou.

Příklad 1:

Vstup: word = "234Adas"
Výstup: pravda
Vysvětlení:
Toto slovo splňuje podmínky.

Příklad 2:

Vstup: slovo = "b3"
Výstup: nepravda
Vysvětlení:
Délka tohoto slova je menší než 3 a nemá samohlásku.

Příklad 3:

Vstup: word = "a3$e"
Výstup: nepravda
Vysvětlení:
Toto slovo obsahuje znak '$' a nemá souhlásku.

Omezení:

1 <= délka slova <= 20
slovo se skládá z anglických velkých a malých písmen, číslic, '@', '#' a '$'.


Mějme řetězec word délky n a celé číslo k takové, že k dělí n.
V jedné operaci můžete vybrat libovolné dva indexy i a j, které jsou dělitelné k, a poté nahradit podřetězec délky k začínající na i podřetězcem délky k začínajícím na j. To znamená, že nahradíte podřetězec word[i..i + k - 1] podřetězcem word[j..j + k - 1].
Vraťte minimální počet operací potřebných k tomu, aby byl řetězec word k-periodický.
Říkáme, že řetězec word je k-periodický, existuje-li nějaký řetězec s délky k, takový, že lze word získat zřetězením řetězce s libovolný početkrát. Například, pokud word == "ababab", pak je word 2-periodický pro s = "ab".

Příklad 1:

Vstup: word = "leetcodeleet", k = 4
Výstup: 1
Vysvětlení:
Můžeme získat 4-periodický řetězec volbou i = 4 a j = 0. Po této operaci se word stane "leetleetleet".

Příklad 2:

Vstup: word = "leetcoleet", k = 2
Výstup: 3
Vysvětlení:
Můžeme získat 2-periodický řetězec použitím operací v tabulce níže.

\[
\begin{array}{c|c|c}
i & j & \text{word} \\
\hline
0 & 2 & \text{etetcoleet} \\
4 & 0 & \text{etetetleet} \\
6 & 0 & \text{etetetetet} \\
\end{array}
\]

Omezení:

1 \leq n == \text{word.length} \leq 10^5
1 \leq k \leq \text{word.length}
k \text{ dělí } \text{word.length}.
\text{word sestává pouze z malých anglických písmen.}

Dostanete řetězcové slovo o velikosti n a celé číslo k takové, že k dělí n.
V jedné operaci můžete vybrat libovolné dva indexy i a j, které jsou dělitelné k, pak nahradit podřetězec délky k začínající na i podřetězcem délky k začínající na j. To znamená, že nahraďte podřetězec slovo[i..i + k - 1] podřetězcem slovo[j..j + k - 1].
Vrátí minimální počet operací potřebných k tomu, aby slovo bylo k-periodické.
Říkáme, že slovo je k-periodické, pokud existuje nějaký řetězec s délky k takový, že slovo lze získat zřetězením s libovolným počtem opakování. Například, pokud slovo == „ababab“, pak slovo je 2-periodické pro s = „ab“.

Příklad 1:

Vstup: slovo = "leetcodeleet", k = 4
Výstup: 1
Vysvětlení:
Můžeme získat 4-periodický řetězec výběrem i = 4 a j = 0. Po této operaci se slovo rovná "leetleetleet".

Příklad 2:

Vstup: slovo = "leetcoleet", k = 2
Výstup: 3
Vysvětlení:
Pomocí operací v tabulce níže můžeme získat 2periodický řetězec.

i
j
slovo

0
2
etetcoleet

4
0
etetetleet

6
0
etetetetet

Omezení:

1 <= n == délka slova <= 10^5
1 <= k <= délka slova
k dělí slovo.length.
slovo se skládá pouze z malých anglických písmen.


Dán je řetězec s, o kterém je známo, že je spojením anagramů nějakého řetězce t.
Vraťte minimální možnou délku řetězce t.
Anagram je vytvořen přeskupením písmen řetězce. Například "aab", "aba" a "baa" jsou anagramy "aab".

Příklad 1:

Vstup: s = "abba"
Výstup: 2
Vysvětlení:
Jedním z možných řetězců t by mohl být "ba".

Příklad 2:

Vstup: s = "cdef"
Výstup: 4
Vysvětlení:
Jedním z možných řetězců t by mohl být "cdef", všimněte si, že t může být rovno s.

Omezení:

1 <= s.length <= 10^5
s obsahuje pouze malá písmena anglické abecedy.

Je vám dán řetězec s, o kterém je známo, že je zřetězením anagramů nějakého řetězce t.
Vraťte minimální možnou délku řetězce t.
Přeskupení je tvořeno přeskupením písmen řetězce. Například „aab“, „aba“ a „baa“ jsou anagramy „aab“.

Příklad 1:

Vstup: s = "abba"
Výstup: 2
Vysvětlení:
Jeden možný řetězec t může být "ba".

Příklad 2:

Vstup: s = "cdef"
Výstup: 4
Vysvětlení:
Jeden možný řetězec t může být "cdef", všimněte si, že t se může rovnat s.

Omezení:

1 <= s.length <= 10^5
s se skládají pouze z malých anglických písmen.


Je zadáno pole celých čísel nums a dvě celá čísla cost1 a cost2. Můžete provést libovolný počet následujících operací:

Zvolte index i z nums a zvětšete nums[i] o 1 pro cost1.
Zvolte dva různé indexy i, j z čísel nums a zvětšete čísla nums[i] a nums[j] o 1 pro náklady cost2.

Vraťte minimální náklady potřebné k tomu, aby se všechny prvky v poli rovnaly.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [4,1], cost1 = 5, cost2 = 2
Výstup: 15
Vysvětlení:
Pro vyrovnání hodnot lze provést následující operace:

Zvyšte nums[1] o 1 za cenu 5. nums se stane [4,2].
Zvyšte nums[1] o 1 za cenu 5. nums se stane [4,3].
Zvyšte nums[1] o 1 za cenu 5. nums se stane [4,4].

Celkové náklady jsou 15.

Příklad 2:

Vstup: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Výstup: 6
Vysvětlení:
Pro vyrovnání hodnot lze provést následující operace:

Zvyšte nums[0] a nums[1] o 1 za cenu 1. Z nums se stane [3,4,3,3,5].
Zvyšte nums[0] a nums[2] o 1 za cenu 1. Z nums se stane [4,4,4,3,5].
Zvyšte nums[0] a nums[3] o 1 za cenu 1. Z nums se stane [5,4,4,4,5].
Zvyšte nums[1] a nums[2] o 1 za cenu 1. Z nums se stane [5,5,5,4,5].
Zvyšte nums[3] o 1 za cenu 2. Z nums se stane [5,5,5,5,5].

Celkové náklady jsou 6.

Příklad 3:

Vstup: nums = [3,5,3], cost1 = 1, cost2 = 3
Výstup: 4
Vysvětlení:
Pro rovnost hodnot lze provést následující operace:

Zvyšte nums[0] o 1 za cenu 1. nums se stane [4,5,3].
Zvyšte nums[0] o 1 za cenu 1. nums se stane [5,5,3].
Zvyšte nums[2] o 1 za cenu 1. nums se stane [5,5,4].
Zvyšte nums[2] o 1 za cenu 1. nums se stane [5,5,5].

Celkové náklady jsou 4.

Omezení:

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

Máte dané celočíselné pole nums a dvě celá čísla cost1 a cost2. Můžete provádět některou z následujících operací libovolněkrát:

Vyberte index i z nums a zvyšte nums[i] o 1 za cenu cost1.
Vyberte dva různé indexy i, j, z nums a zvyšte nums[i] a nums[j] o 1 za cenu cost2.

Vrátit minimální náklad potřebný k tomu, aby se všechny prvky v poli staly stejné.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [4,1], cost1 = 5, cost2 = 2
Výstup: 15
Vysvětlení:
Následující operace mohou být provedeny ke srovnání hodnot:

Zvyšte nums[1] o 1 za cenu 5. nums se stává [4,2].
Zvyšte nums[1] o 1 za cenu 5. nums se stává [4,3].
Zvyšte nums[1] o 1 za cenu 5. nums se stává [4,4].

Celkový náklad je 15.

Příklad 2:

Vstup: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Výstup: 6
Vysvětlení:
Následující operace mohou být provedeny ke srovnání hodnot:

Zvyšte nums[0] a nums[1] o 1 za cenu 1. nums se stává [3,4,3,3,5].
Zvyšte nums[0] a nums[2] o 1 za cenu 1. nums se stává [4,4,4,3,5].
Zvyšte nums[0] a nums[3] o 1 za cenu 1. nums se stává [5,4,4,4,5].
Zvyšte nums[1] a nums[2] o 1 za cenu 1. nums se stává [5,5,5,4,5].
Zvyšte nums[3] o 1 za cenu 2. nums se stává [5,5,5,5,5].

Celkový náklad je 6.

Příklad 3:

Vstup: nums = [3,5,3], cost1 = 1, cost2 = 3
Výstup: 4
Vysvětlení:
Následující operace mohou být provedeny ke srovnání hodnot:

Zvyšte nums[0] o 1 za cenu 1. nums se stává [4,5,3].
Zvyšte nums[0] o 1 za cenu 1. nums se stává [5,5,3].
Zvyšte nums[2] o 1 za cenu 1. nums se stává [5,5,4].
Zvyšte nums[2] o 1 za cenu 1. nums se stává [5,5,5].

Celkový náklad je 4.

Omezení:

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

Dostanete celočíselné pole nums a dvě celá čísla cost1 a cost2. Můžete provádět kteroukoli z následujících operací libovolný počet opakování:

Vyberte index i z nums a zvyšte nums[i] o 1 za cenu cost1.
Vyberte dva různé indexy i, j, z nums a zvyšte nums[i] a nums[j] o 1 za cenu cost2.

Vraťte minimální náklady potřebné k tomu, aby byly všechny prvky v poli stejné.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [4,1], cost1 = 5, cost2 = 2
Výstup: 15
Vysvětlení:
Aby se všechny hodnoty srovnaly, lze provést následující operace:

Zvyšte nums[1] o 1 za cenu 5. nums se změní na [4,2].
Zvyšte nums[1] o 1 za cenu 5. nums se změní na [4,3].
Zvyšte nums[1] o 1 za cenu 5. nums se změní na [4,4].

Celková cena je 15.

Příklad 2:

Vstup: nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
Výstup: 6
Vysvětlení:
Aby se všechny hodnoty srovnaly, lze provést následující operace:

Zvyšte nums[0] a nums[1] o 1 za cenu 1. nums se změní na [3,4,3,3,5].
Zvyšte nums[0] a nums[2] o 1 za cenu 1. nums se změní na [4,4,4,3,5].
Zvyšte nums[0] a nums[3] o 1 za cenu 1. nums se změní na [5,4,4,4,5].
Zvyšte nums[1] a nums[2] o 1 za cenu 1. nums se změní na [5,5,5,4,5].
Zvyšte nums[3] o 1 za cenu 2. nums se změní na [5,5,5,5,5].

Celková cena je 6.

Příklad 3:

Vstup: nums = [3,5,3], cost1 = 1, cost2 = 3
Výstup: 4
Vysvětlení:
Aby se všechny hodnoty srovnaly, lze provést následující operace:

Zvyšte nums[0] o 1 za cenu 1. nums se stane [4,5,3].
Zvyšte nums[0] o 1 za cenu 1. nums se stane [5,5,3].
Zvyšte nums[2] o 1 za cenu 1. nums se změní na [5,5,4].
Zvyšte nums[2] o 1 za cenu 1. nums se stane [5,5,5].

Celková cena je 4.

Omezení:

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


Dostanete 2D maticovou mřížku o velikosti 3 x 3 sestávající pouze ze znaků 'B' a 'W'. Znak 'W' představuje bílou barvu a znak 'B' představuje černou barvu.
Vaším úkolem je změnit barvu maximálně jedné buňky tak, aby matice měla čtverec 2 x 2, kde jsou všechny buňky stejné barvy.
Vraťte true, pokud je možné vytvořit čtverec 2 x 2 stejné barvy, v opačném případě vraťte false.

Příklad 1:

Vstup: mřížka = [["B","W","B"],["B","W","W"],["B","W","B"]]
Výstup: pravda
Vysvětlení:
To lze provést změnou barvy mřížky[0][2].

Příklad 2:

Vstup: mřížka = [["B","W","B"],["W","B","W"],["B","W","B"]]
Výstup: nepravda
Vysvětlení:
Nelze to provést změnou nejvýše jedné buňky.

Příklad 3:

Vstup: mřížka = [["B","W","B"],["B","W","W"],["B","W","W"]]
Výstup: pravda
Vysvětlení:
Mřížka již obsahuje čtverec 2 x 2 stejné barvy.

Omezení:

délka mřížky == 3
mřížka[i].length == 3
grid[i][j] je buď 'W' nebo 'B'.

Je vám dána 2D matice grid o velikosti 3 x 3, která se skládá pouze z písmen 'B' a 'W'. Znak 'W' představuje bílou barvu a znak 'B' představuje černou barvu.
Vaším úkolem je změnit barvu nejvýše jedné buňky tak, aby matice obsahovala čtverec 2 x 2, ve kterém jsou všechny buňky stejné barvy.
Vraťte true, pokud je možné vytvořit čtverec 2 x 2 stejné barvy, jinak vraťte false.

Příklad 1:

Vstup: grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Výstup: true
Vysvětlení:
To lze provést změnou barvy grid[0][2].

Příklad 2:

Vstup: grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
Výstup: false
Vysvětlení:
To není možné provést změnou nejvýše jedné buňky.

Příklad 3:

Vstup: grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
Výstup: true
Vysvětlení:
Matice již obsahuje čtverec 2 x 2 stejné barvy.

Omezení:

grid.length == 3
grid[i].length == 3
grid[i][j] je buď 'W' nebo 'B'.

Dostanete 2D maticovou mřížku o velikosti 3 x 3 sestávající pouze ze znaků 'B' a 'W'. Znak 'W' představuje bílou barvu a znak 'B' představuje černou barvu.
Vaším úkolem je změnit barvu maximálně jedné buňky tak, aby matice měla čtverec 2 x 2, kde jsou všechny buňky stejné barvy.
Vraťte true, pokud je možné vytvořit čtverec 2 x 2 stejné barvy, v opačném případě vraťte false.
Příklad 1:
Vstup:grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
Výstup: true
Vysvětlení:
To lze provést změnou barvy mřížka[0][2].
Příklad 2:
Vstup:  grid= [["B","W","B"],["W","B","W"],["B","W","B"]]
Výstup: false
Vysvětlení:
Nelze to provést změnou nejvýše jedné buňky.
Příklad 3:
Vstup:  grid= [["B","W","B"],["B","W","W"],["B","W","W"]]
Výstup: true
Vysvětlení:
Mřížka již obsahuje čtverec 2 x 2 stejné barvy.
Omezení:
grid.length == 3
grid[i].length == 3
grid[i][j] je buď 'W' nebo 'B'.


Dostanete 2D booleovskou maticovou mřížku.
Vraťte celé číslo, které je počtem pravoúhlých trojúhelníků, které lze vytvořit pomocí 3 prvků mřížky tak, aby všechny měly hodnotu 1.
Poznámka:

Kolekce 3 prvků mřížky je pravoúhlý trojúhelník, pokud je jeden z jejích prvků ve stejném řádku s jiným prvkem a ve stejném sloupci s třetím prvkem. Tyto 3 prvky nemusí být vedle sebe.

Příklad 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Vstup: mřížka = [[0,1,0],[0,1,1],[0,1,0]]
Výstup: 2
Vysvětlení:
Existují dva pravoúhlé trojúhelníky.

Příklad 2:

1
0
0
0

0
1
0
1

1
0
0
0

Vstup: mřížka = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Výstup: 0
Vysvětlení:
Neexistují žádné pravoúhlé trojúhelníky.

Příklad 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Vstup: mřížka = [[1,0,1],[1,0,0],[1,0,0]]
Výstup: 2
Vysvětlení:
Existují dva pravoúhlé trojúhelníky.

Omezení:

1 <= grid.length <= 1000
1 <= grid[i].length <= 1000
0 <= grid[i][j] <= 1

Dostanete 2D booleovskou maticovou mřížku.
Vraťte celé číslo, které je počtem pravoúhlých trojúhelníků, které lze vytvořit pomocí 3 prvků mřížky tak, aby všechny měly hodnotu 1.
Poznámka:

Kolekce 3 prvků mřížky je pravoúhlý trojúhelník, pokud je jeden z jejích prvků ve stejném řádku s jiným prvkem a ve stejném sloupci s třetím prvkem. Tyto 3 prvky nemusí být vedle sebe.

Příklad 1:

0
1
0

0
1
1

0
1
0

0
1
0

0
1
1

0
1
0

Vstup: mřížka = [[0,1,0],[0,1,1],[0,1,0]]
Výstup: 2
Vysvětlení:
Existují dva pravoúhlé trojúhelníky.

Příklad 2:

1
0
0
0

0
1
0
1

1
0
0
0

Vstup: mřížka = [[1,0,0,0],[0,1,0,1],[1,0,0,0]]
Výstup: 0
Vysvětlení:
Neexistují žádné pravoúhlé trojúhelníky.

Příklad 3:

1
0
1

1
0
0

1
0
0

1
0
1

1
0
0

1
0
0

Vstup: mřížka = [[1,0,1],[1,0,0],[1,0,0]]
Výstup: 2
Vysvětlení:
Existují dva pravoúhlé trojúhelníky.

Omezení:

1 <= délka mřížky <= 1000
1 <= mřížka[i].length <= 1000
0 <= mřížka[i][j] <= 1


Jsou dána 3 celá kladná čísla: nula, jedna a limit.
Binární pole arr se nazývá stabilní, jestliže:

Počet výskytů čísla 0 v arr je přesně nula.
Počet výskytů 1 v arr je přesně jedna.
Každé dílčí pole arr s velikostí větší než limit musí obsahovat jak 0, tak 1.

Vraťte celkový počet stabilních binárních polí.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nula = 1, jedna = 1, limit = 2
Výstup: 2
Vysvětlení:
Dvě možná stabilní binární pole jsou [1,0] a [0,1], protože obě pole mají jedinou 0 a jedinou 1 a žádné podpole nemá délku větší než 2.

Příklad 2:

Vstup: nula = 1, jedna = 2, limit = 1
Výstup: 1
Vysvětlení:
Jediné možné stabilní binární pole je [1,0,1].
Všimněte si, že binární pole [1,1,0] a [0,1,1] mají podpole délky 2 se stejnými prvky, a proto nejsou stabilní.

Příklad 3:

Vstup: nula = 3, jedna = 3, limit = 2
Výstup: 14
Vysvětlení:
Všechna možná stabilní binární pole jsou [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] a [1,1,0,1,0,0].

Omezení:

1 <= nula, jedna, limit <= 200

Máte dány 3 kladná celá čísla zero, one a limit.
Binární pole arr je stabilní, pokud:

Počet výskytů 0 v arr je přesně zero.
Počet výskytů 1 v arr je přesně one.
Každé podpole arr s velikostí větší než limit musí obsahovat jak 0, tak 1.

Vrátit celkový počet stabilních binárních polí.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: zero = 1, one = 1, limit = 2
Výstup: 2
Vysvětlení:
Dvě možná stabilní binární pole jsou [1,0] a [0,1], protože obě pole mají jedno 0 a jedno 1, a žádné podpole nemá délku větší než 2.

Příklad 2:

Vstup: zero = 1, one = 2, limit = 1
Výstup: 1
Vysvětlení:
Jediné možné stabilní binární pole je [1,0,1].
Poznamenejte si, že binární pole [1,1,0] a [0,1,1] mají podpole o délce 2 s identickými prvky, proto nejsou stabilní.

Příklad 3:

Vstup: zero = 3, one = 3, limit = 2
Výstup: 14
Vysvětlení:
Všechna možná stabilní binární pole jsou [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] a [1,1,0,1,0,0].

Omezení:

1 <= zero, one, limit <= 200

Jsou vám dána 3 kladná celá čísla nula, jedna a limita.
Binární pole arr se nazývá stabilní, pokud:

Počet výskytů 0 v arr je přesně zero.
Počet výskytů 1 v arr je přesně one.
Každé pole arr s velikostí větší než limit musí obsahovat 0 i 1.

Vrátí celkový počet stabilních binárních polí.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: zero = 1, one = 1, limit = 2
Výstup: 2
Vysvětlení:
Dvě možná stabilní binární pole jsou [1,0] a [0,1], protože obě pole mají jednu 0 a jednu 1 a žádné pole nemá délku větší než 2.

Příklad 2:

Vstup: zero = 1, one = 2, limit = 1
Výstup: 1
Vysvětlení:
Jediné možné stabilní binární pole je [1,0,1].
Všimněte si, že binární pole [1,1,0] a [0,1,1] mají pole délky 2 se stejnými prvky, a proto nejsou stabilní.

Příklad 3:

Vstup: zero = 3,one = 3, limit = 2
Výstup: 14
Vysvětlení:
Všechna možná stabilní binární pole jsou [0,0,1,0,1,1], [0,0,1,1,0,1], [0,1,0,0,1,1], [0,1,0,1,0,1], [0,1,0,1,1,0], [0,1,1,0,0,1], [0,1,1,0,1,0], [1,0,0,1,0,1], [1,0,0,1,1,0], [1,0,1,0,0,1], [1,0,1,0,1,0], [1,0,1,1,0,0], [1,1,0,0,1,0] a [1,1,0,1,0,0].

Omezení:

1 <=  zero, one, limit <= 200


Máte dány dva řetězce s a t, kde každý znak se vyskytuje maximálně jednou v s a t je permutací s.
Rozdíl permutací mezi s a t je definován jako součet absolutních rozdílů mezi indexem výskytu každého znaku v s a indexem výskytu téhož znaku v t.
Vrátit rozdíl permutací mezi s a t.

Příklad 1:

Vstup: s = "abc", t = "bac"
Výstup: 2
Vysvětlení:
Pro s = "abc" a t = "bac" je rozdíl permutací s a t roven součtu:

Absolutní rozdíl mezi indexem výskytu "a" v s a indexem výskytu "a" v t.
Absolutní rozdíl mezi indexem výskytu "b" v s a indexem výskytu "b" v t.
Absolutní rozdíl mezi indexem výskytu "c" v s a indexem výskytu "c" v t.

To znamená, že rozdíl permutací mezi s a t je roven |0 - 1| + |2 - 2| + |1 - 0| = 2.

Příklad 2:

Vstup: s = "abcde", t = "edbac"
Výstup: 12
Vysvětlení: Rozdíl permutací mezi s a t je roven |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Omezení:

1 <= s.length <= 26
Každý znak se vyskytuje maximálně jednou v s.
t je permutací s.
s obsahuje pouze malá písmena anglické abecedy.

Jsou vám dány dva řetězce s a t takové, že každý znak se v s vyskytuje nejvýše jednou a t je permutací s.
Permutační rozdíl mezi s a t je definován jako součet absolutního rozdílu mezi indexem výskytu každého znaku v s a indexem výskytu stejného znaku v t.
Vraťte permutační rozdíl mezi s a t.

Příklad 1:

Vstup: s = "abc", t = "bac"
Výstup: 2
Vysvětlení:
Pro s = "abc" a t = "bac" se permutační rozdíl s a t rovná součtu:

Absolutní rozdíl mezi indexem výskytu "a" v s a indexem výskytu "a" v t.
Absolutní rozdíl mezi indexem výskytu "b" v s a indexem výskytu "b" v t.
Absolutní rozdíl mezi indexem výskytu "c" v s a indexem výskytu "c" v t.

To znamená, že permutační rozdíl mezi s a t je roven |0 - 1| + |2 - 2| + |1 - 0| = 2.

Příklad 2:

Vstup: s = "abcde", t = "edbac"
Výstup: 12
Vysvětlení: Permutační rozdíl mezi s a t je roven |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Omezení:

1 <= délka s <= 26
Každý znak se v s vyskytuje nejvýše jednou.
t je permutace s.
s se skládá pouze z malých anglických písmen.

Jsou dány dva řetězce s a t tak, že každý znak se v s vyskytuje nejvýše jednou a t je permutací s.
Permutační rozdíl mezi s a t je definován jako součet absolutních rozdílů mezi indexem výskytu každého znaku v s a indexem výskytu stejného znaku v t.
Vraťte permutační rozdíl mezi s a t.

Příklad 1:

Vstup: s = „abc“, t = „bac“
Výstup: 2
Vysvětlení:
Pro s = „abc“ a t = „bac“ je permutační rozdíl s a t roven součtu:

Absolutní rozdíl mezi indexem výskytu „a“ v s a indexem výskytu „a“ v t.
absolutního rozdílu mezi indexem výskytu „b“ v s a indexem výskytu „b“ v t.
Absolutní rozdíl mezi indexem výskytu „c“ v s a indexem výskytu „c“ v t.

To znamená, že permutační rozdíl mezi s a t je roven |0 - 1| + |2 - 2| + |1 - 0| = 2.

Příklad 2:

Vstup: s = „abcde“, t = „edbac“
Výstup: 12
Vysvětlení: Permutační rozdíl mezi s a t je roven |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Omezení:

1 <= s.length <= 26
Každý znak se v s vyskytuje nejvýše jednou.
t je permutace s.
s se skládá pouze z malých anglických písmen.


V mystické kobce stojí v řadě n kouzelníků. Každý kouzelník má atribut, který vám dodává energii. Někteří kouzelníci vám mohou dávat negativní energii, což znamená, že vám energii berou.
Byl jsi proklet tak, že po přijetí energie od kouzelníka i budeš okamžitě přenesen ke kouzelníkovi (i + k). Tento proces se bude opakovat, dokud se nedostanete ke kouzelníkovi, kde (i + k) neexistuje.
Jinými slovy, zvolíte si výchozí bod a pak se teleportujete k skoky, dokud nedosáhnete konce posloupnosti kouzelníků, přičemž během cesty absorbujete veškerou energii.
Máte zadáno pole energie a celé číslo k. Vraťte maximální možnou energii, kterou můžete získat.

Příklad 1:

Vstup: energie = [5,2,-10,-5,1], k = 3
Výstup: 3
Vysvětlení: Vycházíme-li z kouzelníka 1, který pohltí 2 + 1 = 3, získáme celkovou energii 3.

Příklad 2:

Vstup: energie = [-2,-3,-1], k = 2
Výstup: -1
Vysvětlení: Počínaje kouzelníkem 2 můžeme získat celkovou energii -1.

Omezení:

1 <= energy.length <= 10^5
-1000 <= energie[i] <= 1000
1 <= k <= energy.length - 1

V mystické kobce stojí v řadě n kouzelníků. Každý kouzelník má vlastnost, která vám dodává energii. Někteří mágové vám mohou dát negativní energii, což znamená, že vám energii berou.
Byli jste prokleti takovým způsobem, že po nasátí energie od mága i budete okamžitě přeneseni k mágovi (i + k). Tento proces se bude opakovat tak dlouho, dokud nedojdete k mágovi, kde (i + k) neexistuje.
Jinými slovy, vyberete si výchozí bod a poté se teleportujete s k skoky, dokud nedosáhnete konce sekvence kouzelníků, přičemž během cesty absorbujete veškerou energii.
Je vám dána energie pole a celé číslo k. Vraťte maximální možnou energii, kterou můžete získat.

Příklad 1:

Příkon: energy = [5,2,-10,-5,1], k = 3
Výstup: 3
Vysvětlení: Můžeme získat celkovou energii 3 tím, že začneme od kouzelníka 1 absorbovat 2 + 1 = 3.

Příklad 2:

Příkon: energy = [-2,-3,-1], k = 2
Výstup: -1
Vysvětlení: Můžeme získat celkovou energii -1 tím, že začneme od kouzelníka 2.

Omezení:

1 <= energy.length <= 10^5
-1000 <= energy [i] <= 1000
1 <= k <= energy.length - 1

V mystickém žaláři stojí v řadě n kouzelníků. Každý kouzelník má atribut, který vám dodává energii. Někteří kouzelníci vám mohou dát negativní energii, což znamená, že vám energii berou.
Byli jste prokleti takovým způsobem, že po absorbování energie z kouzelníka i budete okamžitě přeneseni ke kouzelníkovi (i + k). Tento proces se bude opakovat, dokud nedosáhnete kouzelníka, kde (i + k) neexistuje.
Jinými slovy, vyberete si výchozí bod a poté se teleportujete pomocí k skoků, dokud nedosáhnete konce sekvence kouzelníků, přičemž během cesty absorbujete veškerou energii.
Je vám dána energie pole a celé číslo k. Vraťte maximum možné energie, kterou můžete získat.

Příklad 1:

Vstup: energie = [5,2,-10,-5,1], k = 3
Výstup: 3
Vysvětlení: Můžeme získat celkovou energii 3 tím, že začneme od kouzelníka 1 absorbujícího 2 + 1 = 3.

Příklad 2:

Vstup: energie = [-2,-3,-1], k = 2
Výstup: -1
Vysvětlení: Můžeme získat celkovou energii -1 tím, že začneme od kouzelníka 2.

Omezení:

1 <= energie.length <= 10^5
-1000 <= energie[i] <= 1000
1 <= k <= energie.length - 1


Pole je považováno za zvláštní, pokud každá dvojice jeho sousedních prvků obsahuje dvě čísla s různou paritou.
Je dáno pole celých čísel nums. Vraťte true, pokud je nums speciální pole, jinak vraťte false.

Příklad 1:

Vstup: nums = [1]
Výstup: true
Vysvětlení:
Je zde pouze jeden prvek. Odpověď je tedy true.

Příklad 2:

Vstup: nums = [2,1,4]
Výstup: true
Vysvětlení:
(2,1) a (1,4) a obě obsahují čísla s různou paritou. Odpověď je tedy true.

Příklad 3:

Vstup: nums = [4,3,1,6]
Výstup: false
Vysvětlení:
nums[1] a nums[2] jsou obě liché. Odpověď je tedy false.

Omezení:

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

Pole je považováno za speciální, pokud každá dvojice sousedních prvků obsahuje dvě čísla s různou paritou.
Dostanete pole celých čísel a čísel. Vraťte hodnotu true, pokud je nums speciální pole, v opačném případě vrátí hodnotu false.

Příklad 1:

Vstup: nums = [1]
Výstup: pravda
Vysvětlení:
Existuje pouze jeden prvek. Takže odpověď je pravdivá.

Příklad 2:

Vstup: nums = [2,1,4]
Výstup: pravda
Vysvětlení:
Existují pouze dva páry: (2,1) a (1,4) a oba obsahují čísla s různou paritou. Takže odpověď je pravdivá.

Příklad 3:

Vstup: nums = [4,3,1,6]
Výstup: nepravda
Vysvětlení:
nums[1] a nums[2] jsou obě liché. Takže odpověď je nepravdivá.

Omezení:

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


Jste dán pole nums skládající se z kladných celých čísel, kde všechna čísla mají stejný počet číslic.
Ciferný rozdíl mezi dvěma celými čísly je počet různých číslic, které jsou na stejné pozici ve dvou celých číslech.
Vraťte součet ciferných rozdílů mezi všemi dvojicemi celých čísel v nums.

Příklad 1:

Vstup: nums = [13,23,12]
Výstup: 4
Vysvětlení:
Máme následující:
- Ciferný rozdíl mezi 13 a 23 je 1.
- Ciferný rozdíl mezi 13 a 12 je 1.
- Ciferný rozdíl mezi 23 a 12 je 2.
Takže celkový součet ciferných rozdílů mezi všemi dvojicemi celých čísel je 1 + 1 + 2 = 4.

Příklad 2:

Vstup: nums = [10,10,10,10]
Výstup: 0
Vysvětlení:
Všechna celá čísla v poli jsou stejná. Takže celkový součet ciferných rozdílů mezi všemi dvojicemi celých čísel bude 0.

Omezení:

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Všechna celá čísla v nums mají stejný počet číslic.

Dostanete pole nums skládající se z kladných celých čísel, kde všechna celá čísla mají stejný počet číslic.
ciferný rozdíl mezi dvěma celými čísly je počet různých číslic, které jsou ve dvou celých v poli nums na stejné pozici.
Vraťte součet ciferných rozdílů mezi všemi páry celých čísel v poli nums.

Příklad 1:

Vstup: nums = [13,23,12]
Výstup: 4
Vysvětlení:
Máme následující:
- ciferný rozdíl mezi 13 a 23 je 1.
- ciferný rozdíl mezi 13 a 12 je 1.
- ciferný rozdíl mezi 23 a 12 je 2.
Takže celkový součet ciferných rozdílů mezi všemi páry celých čísel je 1 + 1 + 2 = 4.

Příklad 2:

Vstup: nums = [10,10,10,10]
Výstup: 0
Vysvětlení:
Všechna celá čísla v poli jsou stejná. Takže celkový součet ciferných rozdílů mezi všemi páry celých čísel bude 0.

Omezení:

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Všechna celá čísla v poli nums mají stejný počet číslic.

Dostanete pole nums skládající se z kladných celých čísel, kde všechna celá čísla mají stejný počet číslic.
Číselný rozdíl mezi dvěma celými čísly je počet různých číslic, které jsou ve dvou celých číslech na stejné pozici.
Vraťte součet ciferných rozdílů mezi všemi páry celých čísel v číslech.

Příklad 1:

Vstup: nums = [13,23,12]
Výstup: 4
Vysvětlení:
Máme následující:
- Číselný rozdíl mezi 13 a 23 je 1.
- Číselný rozdíl mezi 13 a 12 je 1.
- Číselný rozdíl mezi 23 a 12 je 2.
Takže celkový součet ciferných rozdílů mezi všemi páry celých čísel je 1 + 1 + 2 = 4.

Příklad 2:

Vstup: nums = [10,10,10,10]
Výstup: 0
Vysvětlení:
Všechna celá čísla v poli jsou stejná. Takže celkový součet ciferných rozdílů mezi všemi páry celých čísel bude 0.

Omezení:

2 <= nums.length <= 10^5
1 <= nums[i] < 10^9
Všechna celá čísla v číslech mají stejný počet číslic.


Je vám přiděleno nezáporné celé číslo k. Existuje schodiště s nekonečným počtem schodů, přičemž nejnižší schodiště má číslo 0.
Alice má celočíselný skok s počáteční hodnotou 0. Začíná na schodišti 1 a chce dosáhnout schodiště k pomocí libovolného počtu operací. Pokud je na schodišti i, v jedné operaci může:

Jděte dolů na schodiště i - 1. Tuto operaci nelze použít po sobě nebo na schodišti 0.
Jděte nahoru na schod i + 2^skok. A pak se skok změní na skok + 1.

Vraťte celkový počet cest, kterými se Alice může dostat na schodiště k.
Všimněte si, že je možné, že Alice dosáhne schodiště k a provede nějaké operace, aby znovu dosáhla schodiště k.

Příklad 1:

Vstup: k = 0
Výstup: 2
Vysvětlení:
2 možné způsoby, jak dosáhnout schodiště 0, jsou:

Alice začíná na schodech 1.

Pomocí operace prvního typu sestoupí o 1 schod dolů, aby dosáhla schodiště 0.

Alice začíná na schodech 1.

Pomocí operace prvního typu sestoupí o 1 schod dolů, aby dosáhla schodiště 0.
Pomocí operace druhého typu vystoupí po 2^0 schodech, aby dosáhla schodiště 1.
Pomocí operace prvního typu sestoupí o 1 schod dolů, aby dosáhla schodiště 0.

Příklad 2:

Vstup: k = 1
Výstup: 4
Vysvětlení:
4 možné způsoby, jak dosáhnout schodiště 1, jsou:

Alice začíná u schodiště 1. Alice je u schodiště 1.
Alice začíná na schodech 1.

Pomocí operace prvního typu sestoupí o 1 schod dolů, aby dosáhla schodiště 0.
Pomocí operace druhého typu vystoupí po 2^0 schodech, aby dosáhla schodiště 1.

Alice začíná na schodech 1.

Pomocí operace druhého typu vystoupí 2^0 schody, aby dosáhla schodiště 2.
Pomocí operace prvního typu sestoupí 1 schod, aby dosáhla schodiště 1.

Alice začíná na schodech 1.

Pomocí operace prvního typu sestoupí o 1 schod dolů, aby dosáhla schodiště 0.
Pomocí operace druhého typu vystoupí po 2^0 schodech, aby dosáhla schodiště 1.
Pomocí operace prvního typu sestoupí o 1 schod dolů, aby dosáhla schodiště 0.
Pomocí operace druhého typu vystoupí po 2^1 schodech, aby dosáhla schodiště 2.
Pomocí operace prvního typu sestoupí 1 schod, aby dosáhla schodiště 1.

Omezení:

0 <= k <= 10^9

Je vám dáno nezáporné celé číslo k. Existuje schodiště s nekonečným počtem schodišť, přičemž nejnižší schodiště má číslo 0.
Alice má celočíselný skok s počáteční hodnotou 0. Začíná na schodišti 1 a chce se dostat ke schodišti k pomocí libovolného počtu operací. Pokud je na schodech i, při jedné operaci může:

Sejděte dolů ke schodišti i - 1. Tuto operaci nelze použít postupně ani na schodišti 0.
Vyjděte ke schodům i + 2^skok. A pak se skok změní na skok + 1.

Vrátí celkový počet způsobů, kterými se Alice může dostat ke schodišti k.
Všimněte si, že je možné, že Alice dosáhne schodiště k a provede některé operace, aby se ke schodišti k znovu dostala.

Příklad 1:

Vstup: k = 0
Výstup: 2
Vysvětlení:
2 možné způsoby, jak se dostat ke schodišti 0, jsou:

Alice začíná u schodiště 1.

Při použití operace prvního typu sejde po 1 schodech dolů a dostane se ke schodišti 0.

Alice začíná u schodiště 1.

Při použití operace prvního typu sejde po 1 schodech dolů a dostane se ke schodišti 0.
Pomocí operace druhého typu vystoupá po 2^0 schodech, aby se dostala ke schodišti 1.
Při použití operace prvního typu sejde po 1 schodech dolů a dostane se ke schodišti 0.

Příklad 2:

Vstup: k = 1
Výstup: 4
Vysvětlení:
4 možné způsoby, jak se dostat ke schodišti 1, jsou:

Alice začíná u schodiště 1. Alice je na schodech 1.
Alice začíná u schodiště 1.

Při použití operace prvního typu sejde po 1 schodech dolů a dostane se ke schodišti 0.
Pomocí operace druhého typu vystoupá po 2^0 schodech, aby se dostala ke schodišti 1.

Alice začíná u schodiště 1.

Pomocí operace druhého typu vystoupá po 2^0 schodech, aby se dostala ke schodišti 2.
Pomocí operace prvního typu sejde po 1 schodech dolů, aby se dostala ke schodišti 1.

Alice začíná u schodiště 1.

Při použití operace prvního typu sejde po 1 schodech dolů a dostane se ke schodišti 0.
Pomocí operace druhého typu vystoupá po 2^0 schodech, aby se dostala ke schodišti 1.
Při použití operace prvního typu sejde po 1 schodech dolů a dostane se ke schodišti 0.
Pomocí operace druhého typu vystoupá po 2^1 schodech, aby se dostala ke schodišti 2.
Pomocí operace prvního typu sejde po 1 schodech dolů, aby se dostala ke schodišti 1.

Omezení:

0 <= k <= 10^9


Jsou vám dána 2 celočíselná pole nums1 a nums2 délek n a m. Dostanete také kladné celé číslo k.
Dvojice (i, j) se nazývá dobrá, pokud nums1[i] je dělitelné nums2[j] * k (0 <= i <= n - 1, 0 <= j <= m - 1).
Vraťte celkový počet dobrých párů.

Příklad 1:

Vstup: nums1 = [1,3,4], nums2 = [1,3,4], k = 1
Výstup: 5
Vysvětlení:
Těchto 5 dobrých párů je (0, 0), (1, 0), (1, 1), (2, 0) a (2, 2).
Příklad 2:

Vstup: nums1 = [1,2,4,12], nums2 = [2,4], k = 3
Výstup: 2
Vysvětlení:
Dva dobré páry jsou (3, 0) a (3, 1).

Omezení:

1 <= n, m <= 50
1 <= nums1[i], nums2[j] <= 50
1 <= k <= 50


Je dáno slovo jako řetězec, zkomprimujte ho pomocí následujícího algoritmu:

Začněte s prázdným řetězcem `comp`. Dokud `word` není prázdný, použijte následující operaci:

Odstraňte maximální délku prefixu `word`, který je tvořen opakujícím se znakem `c` maximálně 9krát. Připojte délku prefixu následovanou `c` k `comp`.

Vraťte řetězec `comp`.

Příklad 1:

Vstup: `word = "abcde"`
Výstup: `"1a1b1c1d1e"`
Vysvětlení: Zpočátku `comp = ""`. Operaci aplikujte 5krát, přičemž jako prefix v každé operaci zvolte "a", "b", "c", "d" a "e". Pro každý prefix připojte "1" následované znakem k `comp`.

Příklad 2:

Vstup: `word = "aaaaaaaaaaaaaabb"`
Výstup: `"9a5a2b"`
Vysvětlení: Zpočátku `comp = ""`. Operaci aplikujte 3krát, přičemž jako prefix v každé operaci zvolte "aaaaaaaaa", "aaaaa" a "bb".

Pro prefix "aaaaaaaaa" připojte "9" následované "a" k `comp`.
Pro prefix "aaaaa" připojte "5" následované "a" k `comp`.
Pro prefix "bb" připojte "2" následované "b" k `comp`.

Omezení:

1 <= `word.length` <= 2 * 10^5
`word` se skládá pouze z malých písmen anglické abecedy.

Zadejte řetězec word a zkomprimujte jej pomocí následujícího algoritmu:

Začněte prázdným řetězcem comp. Pokud slovo není prázdné, použijte následující operaci:

Odstraňte prefix slova o maximální délce tvořený jedním znakem c, který se opakuje nejvýše 9krát.
Připojte ke slovu comp délku prefixu následovaného znakem c.

Vraťte řetězec comp.

Příklad 1:

Vstup: slovo = „abcde“
Výstup: „1a1b1c1d1e“.
Vysvětlení:
Na začátku je comp = „“. Použijte operaci pětkrát, přičemž v každé operaci zvolte jako prefix „a“, „b“, „c“, „d“ a „e“.
Ke každému znaku připojte „1“ následované znakem.

Příklad 2:

Vstup: slovo = „aaaaaaaaaaaaaaaaaabb“
Výstup: „9a5a2b“
Vysvětlení:
Na začátku je comp = „“. Použijte operaci třikrát, přičemž v každé operaci zvolte jako prefix „aaaaaaaaa“, „aaaaa“ a „bb“.

Pro předponu „aaaaaaaaa“ připojte ke comp „9“ následované „a“.
Pro předponu „aaaaa“ připojte ke komp „5“ následované „a“.
Pro předponu „bb“ připojte ke komp „2“ následovanou „b“.

Omezení:

1 <= word.length <= 2 * 10^5
slovo se skládá pouze z malých anglických písmen.

Zkomprimujte zadané řetězcové slovo pomocí následujícího algoritmu:

Začněte s prázdným řetězcem comp. Zatímco slovo není prázdné, použijte následující operaci:

Odstraňte předponu maximální délky slova tvořenou jedním znakem c opakujícím se maximálně 9krát.
Připojte délku předpony následovanou c k comp.

Vraťte řetězec comp.

Příklad 1:

Vstup: slovo = "abcde"
Výstup: "1a1b1c1d1e"
Vysvětlení:
Zpočátku comp = "". Aplikujte operaci 5krát, přičemž v každé operaci vyberte jako předponu "a", "b", "c", "d" a "e".
Pro každou předponu připojte „1“ následované znakem.

Příklad 2:

Vstup: word = "aaaaaaaaaaaaaabb"
Výstup: "9a5a2b"
Vysvětlení:
Zpočátku comp = "". Aplikujte operaci 3krát, přičemž v každé operaci vyberte jako předponu „aaaaaaaaa“, „aaaaa“ a „bb“.

Pro předponu "aaaaaaaaa" přidejte "9" následované "a" ke komp.
Pro předponu "aaaaa" připojte "5" následované "a" ke komp.
Pro předponu "bb" připojte "2" následované "b" ke komp.

Omezení:

1 <= délka slova <= 2 * 10^5
slovo se skládá pouze z malých anglických písmen.


Pole `nums` je tvořeno celými čísly. Je vám také dáno 2D pole `queries`, kde `queries[i] = [pos_i, x_i]`.
Pro dotaz i nejprve nastavíme `nums[pos_i]` na `x_i`, pak vypočítáme odpověď na dotaz i, což je maximální součet subsekvence z `nums`, kde nejsou vybrány žádné dva sousední prvky.
Vrátíme součet odpovědí na všechny dotazy.
Protože konečná odpověď může být velmi velká, vraťte ji modulo \(10^9 + 7\).
Subsekvence je pole, které lze odvodit z jiného pole odstraněním některých nebo žádných prvků bez změny pořadí zbývajících prvků.

Příklad 1:

Vstup: nums = [3,5,9], queries = [[1,-2],[0,-3]]
Výstup: 21
Vysvětlení:
Po 1. dotazu je `nums = [3,-2,9]` a maximální součet subsekvence s nesousedními prvky je 3 + 9 = 12.
Po 2. dotazu je `nums = [-3,-2,9]` a maximální součet subsekvence s nesousedními prvky je 9.

Příklad 2:

Vstup: nums = [0,-1], queries = [[0,-5]]
Výstup: 0
Vysvětlení:
Po 1. dotazu je `nums = [-5,-1]` a maximální součet subsekvence s nesousedními prvky je 0 (vybrání prázdné subsekvence).

Omezení:

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5

Je zadáno pole nums složené z celých čísel. Dále je dáno 2D pole queries, kde queries[i] = [pos_i, x_i].
Pro dotaz i nejprve nastavíme hodnotu nums[pos_i] rovnou x_i, poté vypočítáme odpověď na dotaz i, která je maximálním součtem podřetězce nums, v němž nejsou vybrány dva sousední prvky.
Vrátíme součet odpovědí na všechny dotazy.
Protože výsledná odpověď může být velmi velká, vrátíme ji modulo 10^9 + 7.
Podřetězec je pole, které lze odvodit z jiného pole odstraněním některých nebo žádných prvků, aniž by se změnilo pořadí zbývajících prvků.

Příklad 1:

Vstup: nums = [3,5,9], queries = [[1,-2],[0,-3]].
Výstup: 21
Vysvětlení:
Po 1^prvním dotazu je nums = [3,-2,9] a maximální součet podřetězce s nesousedními prvky je 3 + 9 = 12.
Po 2^dotazu je nums = [-3,-2,9] a maximální součet podřetězce s nesousedními prvky je 9.

Příklad 2:

Vstup: nums = [0,-1], queries = [[0,-5]].
Výstup: 0
Vysvětlení:
Po 1^prvním dotazu je nums = [-5,-1] a maximální součet podřetězce s nesousedními prvky je 0 (volba prázdného podřetězce).

Omezení:

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= queries.length <= 5 * 10^4
queries[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5

Dostanete pole nums skládající se z celých čísel. Dostanete také 2D pole dotazů, kde dotazy[i] = [pos_i, x_i].
Pro dotaz i nejprve nastavíme nums[pos_i] rovné x_i, poté vypočítáme odpověď na dotaz i, což je maximální součet podposloupnosti nums, kde nejsou vybrány žádné dva sousední prvky.
Vraťte součet odpovědí na všechny dotazy.
Protože konečná odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.
Podsekvence je pole, které lze odvodit z jiného pole odstraněním některých nebo žádných prvků, aniž by se změnilo pořadí zbývajících prvků.

Příklad 1:

Vstup: nums = [3,5,9], dotazy = [[1,-2],[0,-3]]
Výstup: 21
Vysvětlení:
Po prvním dotazu je nums = [3,-2,9] a maximální součet podsekvence s nesousedícími prvky je 3 + 9 = 12.
Po 2^nd dotazu je nums = [-3,-2,9] a maximální součet podsekvence s nesousedícími prvky je 9.

Příklad 2:

Vstup: nums = [0,-1], dotazy = [[0,-5]]
Výstup: 0
Vysvětlení:
Po 1^st dotazu je nums = [-5,-1] a maximální součet podsekvence s nesousedícími prvky je 0 (výběr prázdné podsekvence).

Omezení:

1 <= nums.length <= 5 * 10^4
-10^5 <= nums[i] <= 10^5
1 <= dotazy.length <= 5 * 10^4
dotazy[i] == [pos_i, x_i]
0 <= pos_i <= nums.length - 1
-10^5 <= x_i <= 10^5


Je dán řetězec s, který je potřeba rozdělit na jeden nebo více vyvážených podřetězců. Například, pokud s == "ababcc", pak ("abab", "c", "c"), ("ab", "abc", "c") a ("ababcc") jsou všechno platná rozdělení, ale ("a", "bab", "cc"), ("aba", "bc", "c") a ("ab", "abcc") nejsou. Nevyvážené podřetězce jsou označeny tučně.
Vrátit minimální počet podřetězců, do kterých lze s rozdělit.
Poznámka: Vyvážený řetězec je řetězec, ve kterém se každý znak v řetězci vyskytuje stejný početkrát.

Příklad 1:

Vstup: s = "fabccddg"
Výstup: 3
Vysvětlení:
Řetězec s můžeme rozdělit na 3 podřetězce následujícími způsoby: ("fab", "ccdd", "g") nebo ("fabc", "cd", "dg").

Příklad 2:

Vstup: s = "abababaccddb"
Výstup: 2
Vysvětlení:
Řetězec s můžeme rozdělit na 2 podřetězce takto: ("abab", "abaccddb").

Omezení:

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

Při zadání řetězce s je třeba jej rozdělit na jeden nebo více vyvážených podřetězců. Například pokud s == „ababcc“, pak („abab“, „c“, „c“), („ab“, „abc“, „c“) a („ababcc“) jsou všechny platné rozdělení, ale („a“, „bab“, „cc“), („aba“, „bc“, „c“) a („ab“, „abcc“) ne. Nevyvážené podřetězce jsou zvýrazněny tučně.
Vrátí minimální počet podřetězců, na které lze rozdělit s.
Poznámka: Vyvážený řetězec je takový řetězec, kde se každý znak v řetězci vyskytuje stejný početkrát.

Příklad 1:

Vstup: s = „fabccddg“
Výstup: 3
Vysvětlení:
Řetězec s můžeme rozdělit na 3 podřetězce jedním z následujících způsobů: („fab, ‚ccdd‘, ‚g‘) nebo (“fabc“, ‚cd‘, ‚dg‘).

Příklad 2:

Vstup: s = „abababaccddb“
Výstup: 2
Vysvětlení:
Řetězec s můžeme rozdělit na 2 podřetězce takto: („abab“, „abaccddb“).

Omezení:

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

Vzhledem k tomu, že řetězec s, musíte jej rozdělit na jeden nebo více vyvážených podřetězců. Pokud například s == "ababcc", pak ("abab", "c", "c"), ("ab", "abc", "c") a ("ababcc") jsou všechny platné oddíly, ale ("a", "bab", "cc"), ("aba", "bc", "c") a ("ab", "abcc") nejsou. Nevyvážené podřetězce jsou vyznačeny tučně.
Vraťte minimální počet podřetězců, do kterých můžete rozdělit s.
Poznámka: Vyvážený řetězec je řetězec, kde se každý znak v řetězci vyskytuje stejně často.

Příklad 1:

Vstup: s = "fabccddg"
Výstup: 3
Vysvětlení:
Řetězce s můžeme rozdělit na 3 podřetězce jedním z následujících způsobů: ("fab, "ccdd", "g") nebo ("fabc", "cd", "dg").

Příklad 2:

Vstup: s = "abababaccddb"
Výstup: 2
Vysvětlení:
Řetězce s můžeme rozdělit na 2 podřetězce takto: ("abab", "abaccddb").

Omezení:

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


Výkonné pole pro celé číslo x je nejkratší seřazené pole mocnin dvou, které dává součet x. Například výkonné pole pro 11 je [1, 2, 8].
Pole big_nums je vytvořeno zřetězením výkonných polí pro každé kladné celé číslo i ve vzestupném pořadí: 1, 2, 3 a tak dále. Big_nums tedy začíná jako [1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...].
Dostanete dotazy 2D celočíselné matice, kde pro dotazy[i] = [od_i, do_i, mod_i] byste měli vypočítat (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i .
Vraťte odpověď celočíselného pole tak, že odpověď[i] je odpovědí na i^tý dotaz.

Příklad 1:

Vstup: dotazy = [[1,3,7]]
Výstup: [4]
Vysvětlení:
Je tam jeden dotaz.
big_nums[1..3] = [2,1,2]. Jejich součin je 4. Zbytek 4 pod 7 je 4.

Příklad 2:

Vstup: dotazy = [[2,5,3],[7,7,4]]
Výstup: [2,2]
Vysvětlení:
Existují dva dotazy.
První dotaz: big_nums[2..5] = [1,2,4,1]. Jejich součin je 8. Zbytek 8 pod 3 je 2.
Druhý dotaz: big_nums[7] = 2. Zbytek 2 pod 4 je 2.

Omezení:

1 <= dotazy.length <= 500
dotazy[i].length == 3
0 <= dotazy[i][0] <= dotazy[i][1] <= 10^15
1 <= dotazy[i][2] <= 10^5

Mocné pole pro celé číslo x je nejkratší seřazené pole mocnin dvou, které se sčítají do x. Například výkonné pole pro 11 je [1, 2, 8].
Pole big_nums je vytvořeno zřetězením mocných polí pro každé kladné celé číslo i ve vzestupném pořadí: 1, 2, 3 a tak dále. Začíná tedy big_nums jako [1, 2, 1, 2, 4, 1, 4, 2, 4, 8, ...].
Dostanete 2D celočíselné maticové dotazy, kde pro queries[i] = [from_i, to_i, mod_i] byste měli vypočítat (big_nums[from_i] * big_nums[from_i + 1] * ... * big_nums[to_i]) % mod_i.
Vrátí odpověď na celé číslo pole takovou, že answer[i] je odpovědí na i^tý dotaz.

Příklad 1:

Vstup: queries = [[1,3,7]]
Výstup: [4]
Vysvětlení:
Je zde jeden dotaz.
big_nums[1..3] = [2,1,2]. Jejich součin je 4. Zbytek 4 pod 7 je 4.

Příklad 2:

Vstup: queries = [[2,5,3],[7,7,4]]
Výstup: [2,2]
Vysvětlení:
Existují dva dotazy.
První dotaz: big_nums[2..5] = [1,2,4,1]. Součin z nich je 8. Zbytek 8 pod 3 je 2.
Druhý dotaz: big_nums[7] = 2. Zbytek z 2 pod 4 je 2.

Omezení:

1 <= queries.length <= 500
queries[i].length == 3
0 <= queries[i][0] <= queries[i][1] <= 10^15
1 <= queries[i][2] <= 10^5


Máte pole nums, kde se každé číslo v poli objevuje buď jednou nebo dvakrát.
Vraťte bitový XOR všech čísel, která se v poli objevují dvakrát, nebo 0, pokud se žádné číslo neobjevuje dvakrát.

Příklad 1:

Vstup: nums = [1,2,1,3]
Výstup: 1
Vysvětlení:
Jediné číslo, které se v poli nums objevuje dvakrát, je 1.

Příklad 2:

Vstup: nums = [1,2,3]
Výstup: 0
Vysvětlení:
Žádné číslo se v poli nums neobjevuje dvakrát.

Příklad 3:

Vstup: nums = [1,2,2,1]
Výstup: 3
Vysvětlení:
Čísla 1 a 2 se objevují dvakrát. 1 XOR 2 == 3.

Omezení:

1 <= nums.length <= 50
1 <= nums[i] <= 50
Každé číslo v nums se objevuje buď jednou nebo dvakrát.

Dostanete pole nums, kde se každé číslo v poli objeví jednou nebo dvakrát.
Vraťte bitovou hodnotu XOR všech čísel, která se v poli objeví dvakrát, nebo 0, pokud se žádné číslo neobjeví dvakrát.

Příklad 1:

Vstup: nums = [1,2,1,3]
Výstup: 1
Vysvětlení:
Jediné číslo, které se v počtech objevuje dvakrát, je 1.

Příklad 2:

Vstup: nums = [1,2,3]
Výstup: 0
Vysvětlení:
Žádné číslo se v počtech neobjevuje dvakrát.

Příklad 3:

Vstup: nums = [1,2,2,1]
Výstup: 3
Vysvětlení:
Čísla 1 a 2 se objevila dvakrát. 1 XOR 2 == 3.

Omezení:

1 <= nums.length <= 50
1 <= nums[i] <= 50
Každé číslo v číslech se objeví jednou nebo dvakrát.

Jsou vám dana pole čísel, kde se každé číslo v poli objeví buď jednou, nebo dvakrát.
vrátíte bitový XOR všech čísel, která se v poli objeví dvakrát, nebo 0, pokud se žádné číslo nevyskytuje dvakrát.

Příklad 1:

Vstup: nums = [1,2,1,3]
Výstup: 1
Vysvětlení:
Jediné číslo, které se objevuje dvakrát V poli, je 1.

Příklad 2:

Vstup: nums = [1,2,3]
Výstup: 0
Vysvětlení:
Žádné číslo se neobjevuje dvakrát v číslech.

Příklad 3:

Vstup: nums = [1,2,2,1]
Výstup: 3
Vysvětlení:
Čísla 1 a 2 se objevila dvakrát. 1 XOR 2 == 3.

Omezení:

1 <= nums.length <= 50
1 <= nums[i] <= 50
Každé číslo v poli se objeví buď jednou, nebo dvakrát.


Dostanete celočíselné pole nums, dotazy na celočíselné pole a celé číslo x.
Pro každý dotaz[i] musíte najít index dotazů[i]^-tý výskyt x v poli nums. Pokud je výskytů x méně než queries[i], odpověď pro daný dotaz by měla být -1.
Vrátí celočíselné pole obsahující odpovědi na všechny dotazy.

Příklad 1:

Vstup: nums = [1,3,1,7], dotaz = [1,3,2,4], x = 1
Výstup: [0,-1,2,-1]
Vysvětlení:

Pro první dotaz je první výskyt 1 na indexu 0.
Pro 2. (druhý) dotaz existují pouze dva výskyty 1 v nums, takže odpověď je -1.
Pro třetí dotaz je druhý výskyt 1 na indexu 2.
U 4. (čtvrtý) dotazu jsou pouze dva výskyty 1 v nums, takže odpověď je -1.

Příklad 2:

Vstup: nums = [1,2,3], dotaz = [10], x = 5
Výstup: [-1]
Vysvětlení:

Pro 1^st dotaz 5 neexistuje v nums, takže odpověď je -1.

Omezení:

1 <= nums.length, queries.length <= 10^5
1 <= dotaz[i] <= 10^5
1 <= nums[i], x <= 10^4

Je zadáno celočíselné pole nums, celočíselné pole queries a celé číslo x.
Pro každý dotaz[i] musíte najít index queries[i]^-tého výskytu x v poli nums. Pokud je výskytů x méně než queries[i], odpověď by měla být -1 pro daný dotaz.
Vraťte celočíselné pole answer obsahující odpovědi na všechny dotazy.

Příklad 1:

Vstup: nums = [1,3,1,7], queries = [1,3,2,4], x = 1
Výstup: [0,-1,2,-1]
Vysvětlení:

Pro 1. (první) dotaz je první výskyt 1 na indexu 0.
Pro 2. dotaz jsou v poli nums pouze dvojí výskyt 1, takže odpověď je -1.
Pro 3. (třetí) dotaz je druhý výskyt 1 na indexu 2.
U 4. (čtvrtý). dotazu jsou v nums pouze dva výskyty 1, takže odpověď je -1.

Příklad 2:

Vstup: nums = [1,2,3], dotaz = [10], x = 5
Výstup: [-1]
Vysvětlení:

Pro 1. (první) dotaz 5 v nums neexistuje, takže odpověď je -1.

Omezení:

1 <= nums.length, queries.length <= 10^5
1 <= queries[i] <= 10^5
1 <= nums[i], x <= 10^4

Dostanete celočíselné pole nums, celočíselné pole dotazů a celé číslo x.
Pro každý queries[i] musíte najít index queries[i]^-tého výskytu x v poli nums. Pokud existuje méně než query[i] výskytů x dotazů, odpověď by měla být -1 pro daný dotaz.
Vrátí odpověď v celočíselném poli obsahující odpovědi na všechny dotazy.

Příklad 1:

Vstup: nums = [1,3,1,7], queries = [1,3,2,4], x = 1
Výstup: [0,-1,2,-1]
Vysvětlení:

Pro dotaz 1^st je první výskyt 1 v indexu 0.
Pro dotaz 2^nd existují pouze dva výskyty 1 v nums, takže odpověď je -1.
Pro dotaz 3^rd je druhý výskyt 1 v indexu 2.
Pro 4^tý dotaz existují pouze dva výskyty 1 v nums, takže odpověď je -1.

Příklad 2:

Vstup: nums = [1,2,3], queries = [10], x = 5
Výstup: [-1]
Vysvětlení:

Pro dotaz 1^st 5 neexistuje v nums, takže odpověď je -1.

Omezení:

1 <= nums.length, queries.length <= 10^5
1 <= queries[i] <= 10^5
1 <= nums[i], x <= 10^4