Je vám dáno pole kladných celých čísel s indexem od 0 zvané nums a kladné celé číslo limit.
V jedné operaci můžete zvolit libovolné dva indexy i a j a prohodit nums[i] a nums[j], pokud |nums[i] - nums[j]| <= limit.
Vraťte lexikograficky nejmenší pole, které lze získat provedením operace libovolný početkrát.
Pole a je lexikograficky menší než pole b, pokud v první pozici, kde se a a b liší, má pole a prvek, který je menší než odpovídající prvek v b. Například pole [2,10,3] je lexikograficky menší než pole [10,2,3], protože se liší na indexu 0 a 2 < 10.

Příklad 1:

Vstup: nums = [1,5,3,9,8], limit = 2
Výstup: [1,3,5,8,9]
Vysvětlení: Aplikujte operaci 2krát:
- Prohoďte nums[1] s nums[2]. Pole se stane [1,3,5,9,8]
- Prohoďte nums[3] s nums[4]. Pole se stane [1,3,5,8,9]
Nemůžeme získat lexikograficky menší pole prováděním dalších operací.
Všimněte si, že může být možné dosáhnout stejného výsledku různými operacemi.

Příklad 2:

Vstup: nums = [1,7,6,18,2,1], limit = 3
Výstup: [1,6,7,18,1,2]
Vysvětlení: Aplikujte operaci 3krát:
- Prohoďte nums[1] s nums[2]. Pole se stane [1,6,7,18,2,1]
- Prohoďte nums[0] s nums[4]. Pole se stane [2,6,7,18,1,1]
- Prohoďte nums[0] s nums[5]. Pole se stane [1,6,7,18,1,2]
Nemůžeme získat lexikograficky menší pole prováděním dalších operací.

Příklad 3:

Vstup: nums = [1,7,28,19,10], limit = 3
Výstup: [1,7,28,19,10]
Vysvětlení: [1,7,28,19,10] je lexikograficky nejmenší pole, které můžeme získat, protože nelze provést operaci na libovolných dvou indexech.

Omezení:

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

Je zadáno pole kladných celých čísel nums s indexem 0 a kladná celočíselná mez.
V jedné operaci můžete zvolit libovolné dva indexy i a j a prohodit nums[i] a nums[j], pokud |nums[i] - nums[j]| <= limit.
Vrátí lexikograficky nejmenší pole, které lze získat provedením operace libovolný početkrát.
Pole a je lexikograficky menší než pole b, pokud na první pozici, kde se a a b liší, má pole a prvek, který je menší než odpovídající prvek v b. Například pole [2,10,3] je lexikograficky menší než pole [10,2,3], protože se liší na indexu 0 a 2 < 10.

Příklad 1:

Vstup: nums = [1,5,3,9,8], limit = 2
Výstup: [1,3,5,8,9]
Vysvětlení: Použijte operaci 2krát:
- Vyměňte nums[1] za nums[2]. Z pole se stane [1,3,5,9,8].
- Prohoďte nums[3] s nums[4]. Z pole se stane [1,3,5,8,9].
Použitím dalších operací nemůžeme získat lexikograficky menší pole.
Všimněte si, že stejný výsledek může být možné získat provedením různých operací.

Příklad 2:

Vstup: nums = [1,7,6,18,2,1], limit = 3
Výstup: [1,6,7,18,1,2]
Vysvětlení: Použijte operaci třikrát:
- Vyměňte nums[1] za nums[2]. Z pole se stane [1,6,7,18,2,1].
- Prohoďte nums[0] s nums[4]. Z pole se stane [2,6,7,18,1,1].
- Vyměňte nums[0] za nums[5]. Z pole se stane [1,6,7,18,1,2].
Použitím dalších operací nemůžeme získat lexikograficky menší pole.

Příklad 3:

Vstup: nums = [1,7,28,19,10], limit = 3
Výstup: [1,7,28,19,10]
Vysvětlení: [1,7,28,19,10] je lexikograficky nejmenší pole, které můžeme získat, protože operaci nemůžeme použít na žádné dva indexy.

Omezení:

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

Dostanete 0-indexované pole kladných celých čísel a kladné celé číslo limit.
V jedné operaci si můžete vybrat libovolné dva indexy i a j a zaměnit nums[i] a nums[j] pokud |nums[i] - nums[j]| <= limit.
Vrátí lexikograficky nejmenší pole, které lze získat provedením operace libovolný počet opakování.
Pole a je lexikograficky menší než pole b, pokud na první pozici, kde se a a b liší, pole a obsahuje prvek, který je menší než odpovídající prvek v b. Například pole [2,10,3] je lexikograficky menší než pole [10,2,3], protože se liší indexem 0 a 2 < 10.

Příklad 1:

Vstup: nums = [1,5,3,9,8], limit = 2
Výstup: [1,3,5,8,9]
Vysvětlení: Aplikujte operaci 2krát:
- Zaměňte čísla[1] za čísla[2]. Pole se změní na [1,3,5,9,8]
- Zaměňte čísla[3] za čísla[4]. Pole se změní na [1,3,5,8,9]
Použitím dalších operací nemůžeme získat lexikograficky menší pole.
Všimněte si, že může být možné získat stejný výsledek provedením různých operací.

Příklad 2:

Vstup: nums = [1,7,6,18,2,1], limit = 3
Výstup: [1,6,7,18,1,2]
Vysvětlení: Aplikujte operaci 3krát:
- Zaměňte čísla[1] za čísla[2]. Pole se změní na [1,6,7,18,2,1]
- Zaměňte čísla[0] za čísla[4]. Pole se změní na [2,6,7,18,1,1]
- Zaměňte čísla[0] za čísla[5]. Pole se změní na [1,6,7,18,1,2]
Použitím dalších operací nemůžeme získat lexikograficky menší pole.

Příklad 3:

Vstup: nums = [1,7,28,19,10], limit = 3
Výstup: [1,7,28,19,10]
Vysvětlení: [1,7,28,19,10] je lexikograficky nejmenší pole, které můžeme získat, protože operaci nemůžeme použít na žádné dva indexy.

Omezení:

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


Máte dané 0-indexované celočíselné pole `batteryPercentages` o délce `n`, které označuje procento baterie `n` zařízení (0-indexováno). Vaším úkolem je otestovat každé zařízení `i` v pořadí od `0` do `n - 1` pomocí následujících testovacích operací:

- Pokud je `batteryPercentages[i]` větší než 0:
  - Zvyšte počet otestovaných zařízení.
  - Snižte procento baterie u všech zařízení s indexy `j` v rozsahu `[i + 1, n - 1]` o 1, přičemž zajistěte, že procento baterie nikdy neklesne pod 0, tj. `batteryPercentages[j] = max(0, batteryPercentages[j] - 1)`.
  - Přesuňte se k dalšímu zařízení.

 Jinak přejděte k dalšímu zařízení bez provádění jakéhokoliv testu.

Vraťte celé číslo označující počet zařízení, která budou otestována po provedení testovacích operací v pořadí.

Příklad 1:

Input: batteryPercentages = [1,1,2,1,3]
Output: 3

**Vysvětlení:** Testovací operace se provádějí v pořadí, počínaje zařízením 0:
- U zařízení 0 platí `batteryPercentages[0] > 0`, takže počet otestovaných zařízení je nyní 1, a `batteryPercentages` se změní na `[1,0,1,0,2]`.
- U zařízení 1 platí `batteryPercentages[1] == 0`, takže přejdeme k dalšímu zařízení bez testování.
- U zařízení 2 platí `batteryPercentages[2] > 0`, takže počet otestovaných zařízení je nyní 2, a `batteryPercentages` se změní na `[1,0,1,0,1]`.
- U zařízení 3 platí `batteryPercentages[3] == 0`, takže přejdeme k dalšímu zařízení bez testování.
- U zařízení 4 platí `batteryPercentages[4] > 0`, takže počet otestovaných zařízení je nyní 3, a `batteryPercentages` zůstane stejné.

Výsledek je tedy: `3`.
Příklad 2:

Vstup: batteryPercentages = [0,1,2]
Výstup: 2
Vysvětlení: Prováděním testovacích operací v pořadí počínaje zařízení 0:
U zařízení 0, batteryPercentages[0] == 0, takže přejdeme k dalšímu zařízení bez testování.
U zařízení 1, batteryPercentages[1] > 0, je nyní 1 testované zařízení a batteryPercentages se změní na [0,1,1].
U zařízení 2, batteryPercentages[2] > 0, jsou nyní 2 testovaná zařízení a batteryPercentages zůstává stejné.
Odpověď je tedy 2.

Omezení:

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

Je vám dáno pole celých čísel batteryPercentages s délkou n, které označuje procenta baterií n zařízení s indexem 0.
Vaším úkolem je otestovat každé zařízení i v pořadí od 0 do n - 1 provedením následujících testovacích operací:

Pokud je batteryPercentages[i] větší než 0:

Zvyšte počet testovaných zařízení.
Snižte procenta baterie všech zařízení s indexy j v rozsahu [i + 1, n - 1] o 1, zajistěte, aby procento jejich baterie nikdy nekleslo pod 0, tj. batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Přesuňte se k dalšímu zařízení.

Jinak přejděte k dalšímu zařízení bez provedení testu.

Vraťte celé číslo označující počet zařízení, která budou testována po provedení testovacích operací v pořadí.

Příklad 1:

Vstup: batteryPercentages = [1,1,2,1,3]
Výstup: 3
Vysvětlení: Prováděním testovacích operací v pořadí počínaje zařízení 0:
U zařízení 0, batteryPercentages[0] > 0, je nyní 1 testované zařízení a batteryPercentages se změní na [1,0,1,0,2].
U zařízení 1, batteryPercentages[1] == 0, takže přejdeme k dalšímu zařízení bez testování.
U zařízení 2, batteryPercentages[2] > 0, jsou nyní 2 testovaná zařízení a batteryPercentages se změní na [1,0,1,0,1].
U zařízení 3, batteryPercentages[3] == 0, takže přejdeme k dalšímu zařízení bez testování.
U zařízení 4, batteryPercentages[4] > 0, jsou nyní 3 testovaná zařízení a batteryPercentages zůstává stejné.
Odpověď je tedy 3.

Příklad 2:

Vstup: batteryPercentages = [0,1,2]
Výstup: 2
Vysvětlení: Prováděním testovacích operací v pořadí počínaje zařízení 0:
U zařízení 0, batteryPercentages[0] == 0, takže přejdeme k dalšímu zařízení bez testování.
U zařízení 1, batteryPercentages[1] > 0, je nyní 1 testované zařízení a batteryPercentages se změní na [0,1,1].
U zařízení 2, batteryPercentages[2] > 0, jsou nyní 2 testovaná zařízení a batteryPercentages zůstává stejné.
Odpověď je tedy 2.

Omezení:

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

Dostanete celočíselné pole batteryPercentages s indexem 0 s délkou n, označující procenta baterie n zařízení indexovaných 0.
Vaším úkolem je otestovat každé zařízení i v pořadí od 0 do n - 1 provedením následujících testovacích operací:

Pokud je batteryPercentages[i] větší než 0:

Zvyšte počet testovaných zařízení.
Snižte procento baterie všech zařízení s indexy j v rozsahu [i + 1, n - 1] o 1 a zajistěte, aby jejich procento baterie nikdy nekleslo pod 0, tj. batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Přejděte na další zařízení.

V opačném případě přejděte na další zařízení bez provedení jakéhokoli testu.

Vrátí celé číslo označující počet zařízení, která budou testována po provedení testovacích operací v uvedeném pořadí.

Příklad 1:

Vstup: batteryPercentages = [1,1,2,1,3]
Výstup: 3
Vysvětlení: Provádění testovacích operací v pořadí od zařízení 0:
Na device 0, batteryPercentages[0] > 0, takže nyní existuje 1 testované zařízení a batteryPercentages se změní na [1,0,1,0,2].
Na device 1, batteryPercentages[1] == 0, takže se přesuneme na další zařízení bez testování.
Na device 2, batteryPercentages[2] > 0, takže nyní existují 2 testovaná zařízení, a batteryPercentages se změní na [1,0,1,0,1].
Na device 3, batteryPercentages[3] == 0, takže se přesuneme na další zařízení bez testování.
Nadevice 4, batteryPercentages[4] > 0, takže nyní jsou testována 3 zařízení a batteryPercentages zůstává stejná.
Odpověď je tedy 3.

Příklad 2:

Vstup: batteryPercentages = [0,1,2]
Výstup: 2
Vysvětlení: Provádění testovacích operací v pořadí od zařízení 0:
Na device 0, batteryPercentages[0] == 0, takže se přesuneme na další zařízení bez testování.
Na device 1, batteryPercentages[1] > 0, takže nyní je 1 testované zařízení a batteryPercentages se změní na [0,1,1].
Na device 2, batteryPercentages[2] > 0, takže nyní jsou 2 testovaná zařízení a batteryPercentages zůstává stejná.
Odpověď je tedy 2.

Omezení:

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


Je dáno 0-indexovaným polem mountain. Vaším úkolem je najít všechny vrcholy v poli mountain.
Vraťte pole, které se skládá z indexů vrcholů v daném poli v libovolném pořadí.
Poznámky:

Vrchol je definován jako prvek, který je striktně větší než jeho sousední prvky.
První a poslední prvek pole nejsou vrcholy.

Příklad 1:

Vstup: mountain = [2,4,4]
Výstup: []
Vysvětlení: mountain[0] a mountain[2] nemohou být vrcholem, protože jsou první a poslední prvek pole.
mountain[1] také nemůže být vrcholem, protože není striktně větší než mountain[2].
Takže odpověď je [].

Příklad 2:

Vstup: mountain = [1,4,3,8,5]
Výstup: [1,3]
Vysvětlení: mountain[0] a mountain[4] nemohou být vrchol, protože jsou první a poslední prvek pole.
mountain[2] také nemůže být vrcholem, protože není striktně větší než mountain[3] a mountain[1].
Ale mountain[1] a mountain[3] jsou striktně větší než jejich sousední prvky.
Takže odpověď je [1,3].

Omezení:

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

Dostanete pole indexované 0, které představuje horu. Vaším úkolem je najít všechny vrcholy v horském poli.
Vrátíte pole, které se skládá z indexů vrcholů v daném poli v libovolném pořadí.
Poznámky:

Vrchol je definován jako prvek, který je přísně větší než jeho sousední prvky.
První a poslední prvek pole nejsou vrcholem.

Příklad 1:

Vstup: horské pole = [2,4,4]
Výstup: []
Vysvětlení: horské pole[0] a horské pole[2] nemohou být vrcholem, protože jsou prvním a posledním prvkem pole.
horské pole[1] také nemůže být vrcholem, protože není přísně větší než horské pole[2].
Takže odpověď je [].

Příklad 2:

Vstup: horské pole = [1,4,3,8,5]
Výstup: [1,3]
Vysvětlení: horské pole[0] a horské pole[4] nemohou být vrcholem, protože jsou prvním a posledním prvkem pole.
horské pole[2] také nemůže být vrcholem, protože není přísně větší než horské pole[3] a horské pole[1].
Ale horské pole[1] a horské pole[3] jsou přísně větší než jejich sousední prvky.
Takže odpověď je [1,3].

Omezení:

3 <= délka hory <= 100
1 <= horské pole[i] <= 100

Máte k dispozici pole s indexem 0. Vaším úkolem je najít všechny vrcholy v poli hor.
Vraťte pole, které se skládá z indexů vrcholů v daném poli v libovolném pořadí.
Poznámky:

Vrchol je definován jako prvek, který je striktně větší než jeho sousední prvky.
První a poslední prvek pole není vrcholem.

Příklad 1:

Vstup: mountain = [2,4,4]
Výstup: []
Vysvětlení: mountain[0] a mountain[2] nemohou být vrcholem, protože jsou prvním a posledním prvkem pole.
mountain[1] také nemůže být vrcholem, protože není striktně větší než mountain[2].
Odpověď je tedy [].

Příklad 2:

Vstup: mountain = [1,4,3,8,5]
Výstup: [1,3]
Vysvětlení: mountain[0] a mountain[4] nemohou být vrcholem, protože jsou prvním a posledním prvkem pole.
mountain[2] také nemůže být vrcholem, protože není striktně větší než mountain[3] a mountain[1].
Ale mountain [1] a mountain[3] jsou striktně větší než jejich sousední prvky.
Odpověď tedy zní [1,3].

Omezení:

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


Máte daný řetězec word a celé číslo k.
Podřetězec s řetězce word je úplný, pokud:

Každý znak v s se vyskytuje přesně k krát.
Rozdíl mezi dvěma sousedními znaky je nejvýše 2. To znamená, že pro jakékoli dva sousední znaky c1 a c2 v s je absolutní rozdíl jejich pozic v abecedě nejvýše 2.

Vrátí počet úplných podřetězců řetězce word.
Podřetězec je neprázdná souvislá sekvence znaků v řetězci.

Příklad 1:

Vstup: word = "igigee", k = 2
Výstup: 3
Vysvětlení: Úplné podřetězce, kde se každý znak objevuje přesně dvakrát a rozdíl mezi sousedními znaky je nejvýše 2, jsou: igigee, igigee, igigee.

Příklad 2:

Vstup: word = "aaabbbccc", k = 3
Výstup: 6
Vysvětlení: Úplné podřetězce, kde se každý znak objevuje přesně třikrát a rozdíl mezi sousedními znaky je nejvýše 2, jsou: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Omezení:

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

Je zadán řetězec word a celé číslo k.
Podřetězec s slova je úplný, jestliže:

Každý znak v s se vyskytuje přesně kkrát.
Rozdíl mezi dvěma sousedními znaky je nejvýše 2. To znamená, že pro libovolné dva sousední znaky c1 a c2 v s je absolutní rozdíl jejich pozic v abecedě nejvýše 2.

Vraťte počet úplných podřetězců slova.
Podřetězec je neprázdná souvislá posloupnost znaků v řetězci.

Příklad 1:

Vstup: word = „igigee“, k = 2
Výstup: 3
Vysvětlení: Úplné podřetězce, kde se každý znak vyskytuje přesně dvakrát a rozdíl mezi sousedními znaky je nejvýše 2, jsou: igigee, igigee, igigee.

Příklad 2:

Vstup: word = „aaabbbccc“, k = 3
Výstup: 6
Vysvětlení: Úplné podřetězce, kde se každý znak vyskytuje přesně třikrát a rozdíl mezi sousedními znaky je nejvýše 2, jsou: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Omezení:

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

Je zadán řetězec word a celé číslo k.
Podřetězec s slova je úplný, jestliže:

Každý znak v s se vyskytuje přesně kkrát.
Rozdíl mezi dvěma sousedními znaky je maximálně 2. To znamená, že pro libovolné dva sousední znaky c1 a c2 v s je absolutní rozdíl jejich pozic v abecedě nejvýše 2.

Vraťte počet úplných podřetězců slova.
Podřetězec je neprázdná souvislá posloupnost znaků v řetězci.

Příklad 1:

Vstup: word = „igigee“, k = 2
Výstup: 3
Vysvětlení: Úplné podřetězce, kde se každý znak vyskytuje přesně dvakrát a rozdíl mezi sousedními znaky je nejvýše 2, jsou: igigee, igigee, igigee.

Příklad 2:

Vstup: word = „aaabbbccc“, k = 3
Výstup: 6
Vysvětlení: Úplné podřetězce, kde se každý znak vyskytuje přesně třikrát a rozdíl mezi sousedními znaky je nejvýše 2, jsou: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Omezující podmínky:

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


Je zadáno celé číslo n a pole celých čísel s indexem 0 sick, které je seřazeno vzestupně.
Ve frontě stojí n dětí, kterým jsou přiřazeny pozice 0 až n - 1. Pole nemocných obsahuje pozice dětí, které jsou nakaženy infekční chorobou. Nakažené dítě na pozici i může šířit nemoc na některé ze svých bezprostředních sousedních dětí na pozicích i - 1 a i + 1, pokud existují a nejsou právě nakaženy. Během jedné sekundy se může nemocí nakazit nejvýše jedno dítě, které dosud nebylo nakaženo.
Lze ukázat, že po konečném počtu sekund se všechny děti ve frontě nakazí nemocí. Sekvence nakažení je pořadí pozic, v němž se všechny nenakažené děti nakazí nemocí. Vraťte celkový počet možných sekvencí infekce.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.
Všimněte si, že sekvence infekce neobsahuje pozice dětí, které již byly nakaženy nemocí na začátku.

Příklad 1:

Vstup: n = 5, nemocný = [0,4]
Výstup: 4
Vysvětlení: Děti na pozicích 1, 2 a 3 nejsou na začátku nakaženy. Existují 4 možné sekvence infekce:
- Děti na pozicích 1 a 3 se mohou nakazit, protože jejich pozice sousedí s nakaženými dětmi 0 a 4. Dítě na pozici 1 se nakazí jako první.
Nyní dítě na pozici 2 sousedí s dítětem na pozici 1, které je infikováno, a dítě na pozici 3 sousedí s dítětem na pozici 4, které je infikováno, proto se může nakazit kterékoli z nich. Dítě na pozici 2 se nakazí.
Nakonec se nakazí dítě na pozici 3, protože sousedí s dětmi na pozicích 2 a 4, které jsou nakažené. Pořadí infekce je [1,2,3].
- Děti na pozicích 1 a 3 se mohou nakazit, protože jejich pozice sousedí s nakaženými dětmi 0 a 4. Dítě na pozici 1 se nakazí jako první.
Nyní dítě na pozici 2 sousedí s dítětem na pozici 1, které je infikováno, a dítě na pozici 3 sousedí s dítětem na pozici 4, které je infikováno, proto se může nakazit kterékoli z nich. Dítě na pozici 3 se nakazí.
Nakonec se nakazí dítě na pozici 2, protože sousedí s dětmi na pozicích 1 a 3, které jsou nakažené. Pořadí infekce je [1,3,2].
- Pořadí infekce je [3,1,2]. Pořadí nakažení dětí nemocí lze vidět takto: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- Infekční posloupnost je [3,2,1]. Pořadí nákazy u dětí lze vidět takto: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Příklad 2:

Vstup: n = 4, sick = [1]
Výstup: 3
Vysvětlení: Děti na pozicích 0, 2 a 3 nejsou na začátku nakaženy. Existují 3 možné sekvence infekce:
- Infekční sekvence je [0,2,3]. Pořadí nakažení dětí nemocí lze vidět takto: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Pořadí infekce je [2,0,3]. Pořadí infekce onemocnění u dětí lze vidět takto: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Pořadí infekce je [2,3,0]. Pořadí infekce onemocnění u dětí lze vidět takto: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Omezení:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
Nemocní jsou seřazeni vzestupně.

Dostanete celé číslo n a 0-indexované celočíselné pole sick, které je seřazeno ve vzestupném pořadí.
Ve frontě stojí n potomků, kterým jsou přiřazeny pozice 0 až n - 1. Pole nemocných obsahuje pozice dětí, které jsou nakaženy infekční nemocí. Nakažené dítě na pozici i může přenést onemocnění na některé ze svých nejbližších sousedních dětí na pozicích i - 1 a i + 1, pokud existují a aktuálně nejsou infikovány. Maximálně jedno dítě, které dříve nebylo infikováno, se může nakazit nemocí během jedné sekundy.
Lze ukázat, že po konečném počtu sekund se nemocí nakazí všechny děti ve frontě. Infekční sekvence je postupné pořadí pozic, ve kterých se všechny neinfikované děti nakazí nemocí. Vrátí celkový počet možných sekvencí infekce.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.
Všimněte si, že infekční sekvence neobsahuje pozice dětí, které byly nemocí infikovány již na začátku.

Příklad 1:

Vstup: n = 5, sick = [0,4]
Výstup: 4
Vysvětlení: Děti na pozicích 1, 2 a 3 nejsou na začátku nakažené. Existují 4 možné infekční sekvence:
- Děti na pozicích 1 a 3 se mohou nakazit, protože jejich pozice sousedí s infikovanými dětmi 0 a 4. Dítě na pozici 1 se nakazí jako první.
Nyní dítě na pozici 2 sousedí s dítětem na pozici 1, které je infikováno, a dítě na pozici 3 sousedí s dítětem na pozici 4, které je infikováno, takže se může nakazit kterýkoli z nich. Dítě na pozici 2 se nakazí.
Nakonec se nakazí dítě na pozici 3, protože sousedí s dětmi na pozicích 2 a 4, které jsou infikovány. Sekvence infekce je [1,2,3].
- Děti na pozicích 1 a 3 se mohou nakazit, protože jejich pozice sousedí s nakaženými dětmi 0 a 4. Dítě na pozici 1 se nakazí jako první.
Nyní dítě na pozici 2 sousedí s dítětem na pozici 1, které je infikováno, a dítě na pozici 3 sousedí s dítětem na pozici 4, které je infikováno, takže se může nakazit kterýkoli z nich. Dítě na pozici 3 se nakazí.
Nakonec se nakazí dítě na pozici 2, protože sousedí s dětmi na pozicích 1 a 3, které jsou infikovány. Sekvence infekce je [1,3,2].
- Sekvence infekce je [3,1,2]. Pořadí infekce nemoci u dětí lze vidět takto: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- Sekvence infekce je [3,2,1]. Pořadí infekce nemoci u dětí lze vidět takto: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Příklad 2:

Vstup: n = 4, sick = [1]
Výstup: 3
Vysvětlení: Děti na pozicích 0, 2 a 3 nejsou na začátku infikovány. Existují 3 možné infekční sekvence:
- Sekvence infekce je [0,2,3]. Pořadí infekce nemoci u dětí lze vidět jako: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Sekvence infekce je [2,0,3]. Pořadí infekce nemoci u dětí lze vidět jako: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Sekvence infekce je [2,3,0]. Pořadí infekce nemoci u dětí lze vidět jako: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Omezení:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
Nemocné jsou řazeny ve vzestupném pořadí.

Je zadáno celé číslo n a pole celých čísel s indexem 0 sick, které je seřazeno vzestupně.
Ve frontě stojí n dětí, kterým jsou přiřazeny pozice 0 až n - 1. Pole nemocných obsahuje pozice dětí, které jsou nakaženy infekční nemoc. Nakažené dítě na pozici i může šířit nemoc na některé ze svých bezprostředních sousedních dětí na pozicích i - 1 a i + 1, pokud existují a nejsou právě nakaženy. Během jedné sekundy se může nemocí nakazit nejvýše jedno dítě, které dosud nebylo nakaženo.
Lze ukázat, že po konečném počtu sekund se všechny děti ve frontě nakazí nemocí. Sekvence nakažení je pořadí pozic, ve kterém se všechny nenakažené děti nakazí nemocí. Vraťte celkový počet možných sekvencí nemoc.
Protože odpověď může být velká, vraťte ji modulo 10^9 + 7.
Všimněte si, že sekvence nemoc neobsahuje pozice dětí, které již byly nakaženy nemocí na začátku.

Příklad 1:

Vstup: n = 5, nemocných = [0,4]
Výstup: 4
Vysvětlení: Děti na pozicích 1, 2 a 3 nejsou na začátku nakaženy. Existují 4 možné sekvence nemoc:
- Děti na pozicích 1 a 3 se mohou nakazit, protože jejich pozice sousedí s nakaženými dětmi 0 a 4. Dítě na pozici 1 se nakazí jako první.
Nyní dítě na pozici 2 sousedí s dítětem na pozici 1, které je infikováno, a dítě na pozici 3 sousedí s dítětem na pozici 4, které je infikováno, proto se může nakazit kterékoli z nich. Dítě na pozici 2 se nakazí.
Nakonec se nakazí dítě na pozici 3, protože sousedí s dětmi na pozicích 2 a 4, které jsou nakažené. Pořadí nemoc je [1,2,3].
- Děti na pozicích 1 a 3 se mohou nakazit, protože jejich pozice sousedí s nakaženými dětmi 0 a 4. Dítě na pozici 1 se nakazí jako první.
Nyní dítě na pozici 2 sousedí s dítětem na pozici 1, které je infikováno, a dítě na pozici 3 sousedí s dítětem na pozici 4, které je infikováno, proto se může nakazit kterékoli z nich. Dítě na pozici 3 se nakazí.
Nakonec se nakazí dítě na pozici 2, protože sousedí s dětmi na pozicích 1 a 3, které jsou nakažené. Pořadí nemoc je [1,3,2].
- Pořadí nemoc je [3,1,2]. Pořadí nakažení dětí nemocí lze vidět takto: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- Infekční posloupnost je [3,2,1]. Pořadí nákazy u dětí lze vidět takto: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Příklad 2:

Vstup: n = 4, nemocných = [1]
Výstup: 3
Vysvětlení: Děti na pozicích 0, 2 a 3 nejsou na začátku nakaženy. Existují 3 možné sekvence nemoc:
- Infekční sekvence je [0,2,3]. Pořadí nakažení dětí nemocí lze vidět takto: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Pořadí nemoc je [2,0,3]. Pořadí nemoc lze vidět takto: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Pořadí nemoc je [2,3,0]. Pořadí nemoc lze vidět takto: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Omezení:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
Pole nemocných je seřazeno vzestupně.


Je dáno celočíselné pole nums a celé číslo k. Frekvence prvku x je počet, kolikrát se v poli vyskytuje. Pole nazýváme dobré, pokud frekvence každého prvku v tomto poli je menší nebo rovna k. Vraťte délku nejdelšího dobrého podpole nums. Podpole je souvislá neprázdná posloupnost prvků v rámci pole.

Příklad 1:

Vstup: nums = [1,2,3,1,2,3,1,2], k = 2
Výstup: 6
Vysvětlení: Nejdelší možné dobré podpole je [1,2,3,1,2,3], protože hodnoty 1, 2 a 3 se v tomto podpole vyskytují maximálně dvakrát. Všimněte si, že podpole [2,3,1,2,3,1] a [3,1,2,3,1,2] jsou také dobrá.
Lze ukázat, že neexistují dobrá podpole s délkou větší než 6.

Příklad 2:

Vstup: nums = [1,2,1,2,1,2,1,2], k = 1
Výstup: 2
Vysvětlení: Nejdelší možné dobré podpole je [1,2], protože hodnoty 1 a 2 se v tomto podpole vyskytují maximálně jednou. Všimněte si, že podpole [2,1] je také dobré.
Lze ukázat, že neexistují dobrá podpole s délkou větší než 2.

Příklad 3:

Vstup: nums = [5,5,5,5,5,5,5], k = 4
Výstup: 4
Vysvětlení: Nejdelší možné dobré podpole je [5,5,5,5], protože hodnota 5 se v tomto podpole vyskytuje 4krát.
Lze ukázat, že neexistují dobrá podpole s délkou větší než 4.

Omezení:

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

Dostanete celočíselné pole nums a celé číslo k.
Frekvence prvku x je počet, kolikrát se vyskytuje v poli.
Pole se nazývá dobré, pokud frekvence každého prvku v tomto poli je menší nebo rovna k.
Vraťte délku nejdelšího dobrého podpole nums.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [1,2,3,1,2,3,1,2], k = 2
Výstup: 6
Vysvětlení: Nejdelší možné dobré podpole je [1,2,3,1,2,3], protože hodnoty 1, 2 a 3 se v tomto podpole vyskytují maximálně dvakrát. Všimněte si, že podpole [2,3,1,2,3,1] a [3,1,2,3,1,2] jsou také dobré.
Lze ukázat, že neexistují žádná dobrá podpole s délkou větší než 6.

Příklad 2:

Vstup: nums = [1,2,1,2,1,2,1,2], k = 1
Výstup: 2
Vysvětlení: Nejdelší možné dobré podpole je [1,2], protože hodnoty 1 a 2 se v tomto podpole vyskytují nejvýše jednou. Všimněte si, že podpole [2,1] je také dobré.
Lze ukázat, že neexistují žádná dobrá podpole s délkou větší než 2.

Příklad 3:

Vstup: nums = [5,5,5,5,5,5,5], k = 4
Výstup: 4
Vysvětlení: Nejdelší možné dobré podpole je [5,5,5,5], protože hodnota 5 se v tomto podpole vyskytuje 4krát.
Lze ukázat, že neexistují žádná dobrá podpole s délkou větší než 4.

Omezení:

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

Je zadáno celočíselné pole nums a celé číslo k.
Četnost prvku x je počet jeho výskytů v poli.
Pole se nazývá dobré, pokud je četnost každého prvku v tomto poli menší nebo rovna k.
Vraťte délku nejdelšího dobrého pole nums.
Podmnožina je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [1,2,3,1,2,3,1,2], k = 2
Výstup: 6
Vysvětlení: Nejdelší možné dobré podřetězce jsou [1,2,3,1,2,3], protože hodnoty 1, 2 a 3 se v tomto podřetězci vyskytují nejvýše dvakrát. Všimněte si, že dobrá jsou také podřetězce [2,3,1,2,3,1] a [3,1,2,3,1,2].
Lze ukázat, že neexistují žádná dobrá podřetězce s délkou větší než 6.

Příklad 2:

Vstup: nums = [1,2,1,2,1,2,1,2], k = 1
Výstup: 2
Vysvětlení: Nejdelší možné dobré podřetězce je [1,2], protože hodnoty 1 a 2 se v tomto podřetězci vyskytují nejvýše jednou. Všimněte si, že dobré je i podřetězce [2,1].
Lze ukázat, že neexistují žádná dobrá podřetězce o délce větší než 2.

Příklad 3:

Vstup: nums = [5,5,5,5,5,5,5], k = 4
Výstup: 4
Vysvětlení: Nejdelší možné dobré podřetězce je [5,5,5,5], protože hodnota 5 se v tomto podřetězci vyskytuje čtyřikrát.
Lze ukázat, že neexistují žádná dobrá podřetězce o délce větší než 4.

Omezení:

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


Je dáno pole celých čísel nums sudé délky s indexem 0 a také prázdné pole arr. Alice a Bob se rozhodli hrát hru, ve které v každém kole Alice a Bob provedou jeden tah. Pravidla hry jsou následující:

V každém kole nejprve Alice odstraní z nums minimální prvek a poté totéž udělá Bob.
Nyní nejprve Bob přidá odstraněný prvek do pole arr a poté Alice udělá totéž.
Hra pokračuje, dokud se nums nevyprázdní.

Vraťte výsledné pole arr.

Příklad 1:

Vstup: nums = [5,4,2,3]
Výstup: [3,2,5,4]
Vysvětlení: V prvním kole nejprve Alice odstraní 2 a poté Bob odstraní 3. Pak v arr nejprve Bob přidá 3 a pak Alice přidá 2. Takže arr = [3,2].
Na začátku druhého kola je nums = [5,4]. Nyní nejprve Alice odstraní 4 a poté Bob odstraní 5. Pak oba doplní čísla do arr, které se stane [3,2,5,4].

Příklad 2:

Vstup: nums = [2,5]
Výstup: [5,2]
Vysvětlení: V prvním kole nejprve Alice odstraní 2 a poté Bob odstraní 5. Pak v arr nejprve Bob přidá a pak Alice přidá. Takže arr = [5,2].

Omezení:

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

Dostanete 0-indexované celé pole čísel sudé délky a je zde také prázdné pole arr. Alice a Bob se rozhodli hrát hru, kde v každém kole Alice a Bob udělají jeden tah. Pravidla hry jsou následující:

Každé kolo nejprve Alice odstraní minimální prvek z nums a pak Bob udělá totéž.
Nyní nejprve Bob připojí odstraněný prvek do pole arr a pak Alice udělá totéž.
Hra pokračuje, dokud se num nevyprázdní.

Vraťte výsledné pole arr.

Příklad 1:

Vstup: nums = [5,4,2,3]
Výstup: [3,2,5,4]
Vysvětlení: V prvním kole nejprve Alice odebere 2 a poté Bob odebere 3. Potom v arr nejprve Bob přidá 3 a poté Alice přidá 2. Takže arr = [3,2].
Na začátku druhého kola, nums = [5,4]. Nyní nejprve Alice odebere 4 a poté Bob odebere 5. Poté oba připojí v arr, což se stane [3,2,5,4].

Příklad 2:

Vstup: nums = [2,5]
Výstup: [5,2]
Vysvětlení: V prvním kole nejprve Alice odebere 2 a poté Bob odebere 5. Poté v arr nejprve přidá Bob a poté Alice. Takže arr = [5,2].

Omezení:

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

Dostanete celé pole indexované 0 se sudou délkou a je zde také prázdné pole arr. Alice a Bob se rozhodli hrát hru, ve které v každém kole Alice a Bob udělají jeden tah. Pravidla hry jsou následující:

V každém kole nejprve Alice odstraní minimální prvek z nums a poté Bob udělá totéž.
Nyní nejprve Bob připojí odstraněný prvek do pole arr a poté Alice udělá totéž.
Hra pokračuje, dokud se čísla nevyprázdní.

Vrátí výsledné pole arr.

Příklad 1:

Vstup: nums = [5,4,2,3]
Výstup: [3,2,5,4]
Vysvětlení: V prvním kole nejprve Alice odstraní 2 a poté Bob odstraní 3. Pak v arr nejprve Bob připojí 3 a poté Alice připojí 2. Takže arr = [3,2].
Na začátku druhého kola jsou nums = [5,4]. Nyní nejprve Alice odstraní 4 a poté Bob odstraní 5. Pak se obě připojí do arr, což se stane [3,2,5,4].

Příklad 2:

Vstup: nums = [2,5]
Výstup: [5,2]
Vysvětlení: V prvním kole nejprve Alice odstraní 2 a poté Bob 5. Pak se v arr nejprve připojí Bob a poté Alice. Takže arr = [5,2].

Omezení:

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


Získáte 0-indexovanou 2D celočíselnou maticovou mřížku velikosti n * n s hodnotami v rozsahu [1, n^2]. Každé celé číslo se objeví přesně jednou, kromě a, které se objeví dvakrát, a b, které chybí. Úkolem je najít opakující se a chybějící čísla a a b.
Vrátí 0-indexované celočíselné pole ans velikosti 2, kde ans[0] se rovná a a ans[1] se rovná b.

Příklad 1:

Vstup: mřížka = [[1,3],[2,2]]
Výstup: [2,4]
Vysvětlení: Číslo 2 se opakuje a číslo 4 chybí, takže odpověď je [2,4].

Příklad 2:

Vstup: mřížka = [[9,1,7],[8,9,2],[3,4,6]]
Výstup: [9,5]
Vysvětlení: Číslo 9 se opakuje a číslo 5 chybí, takže odpověď je [9,5].

Omezení:

2 <= n == mřížka.length == mřížka[i].length <= 50
1 <= mřížka[i][j] <= n * n
Pro všechna x, která 1 <= x <= n * n existuje právě jedno x, které se nerovná žádnému z prvků mřížky.
Pro všechna x, která 1 <= x <= n * n existuje právě jedno x, které se rovná přesně dvěma členům mřížky.
Pro všechna x, která 1 <= x <= n * n kromě dvou z nich existuje přesně jeden pár i, j, že 0 <= i, j <= n - 1 a mřížka[i][j] == x.

Dostanete 2D celočíselnou matici indexovanou od 0 o velikosti n * n s hodnotami v rozsahu [1, n^2]. Každé celé číslo se objeví právě jednou kromě a, které se objeví dvakrát, a b, které chybí. Úkolem je najít opakující se a chybějící čísla a a b.
Vrátí celé pole indexované 0 ans o velikosti 2, kde ans[0] se rovná a a ans[1] se rovná b.

Příklad 1:

Vstup: grid = [[1,3],[2,2]]
Výstup: [2,4]
Vysvětlení: Číslo 2 se opakuje a číslo 4 chybí, takže odpověď je [2,4].

Příklad 2:

Vstup: grid = [[9,1,7],[8,9,2],[3,4,6]]
Výstup: [9,5]
Vysvětlení: Číslo 9 se opakuje a číslo 5 chybí, takže odpověď je [9,5].

Omezení:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Pro všechna x, která jsou 1 <= x <= n * n, existuje právě jedno x, které se nerovná žádnému z členů mřížky.
Pro všechna x, která jsou 1 <= x <= n * n, existuje přesně jedno x, které se rovná přesně dvěma členům mřížky.
Pro všechna x že 1 <= x <= n * n kromě dvou z nich existuje přesně jeden pár i, j že 0 <= i, j <= n - 1 a grid[i][j] == x.


Máte dvě celočíselná pole s nulovým indexováním `nums1` a `nums2` sudé délky `n`.
Musíte odstranit `n / 2` prvků z `nums1` a `n / 2` prvků z `nums2`. Po odstranění vložte zbývající prvky `nums1` a `nums2` do množiny `s`.
Vrátí maximální možnou velikost množiny `s`.

Příklad 1:

Vstup: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Výstup: 2
Vysvětlení: Odstraníme dvě výskyty 1 z `nums1` a `nums2`. Po odstranění se pole stanou `nums1 = [2,2]` a `nums2 = [1,1]`. Proto `s = {1,2}`.
Lze prokázat, že 2 je maximální možná velikost množiny `s` po odstranění.

Příklad 2:

Vstup: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Výstup: 5
Vysvětlení: Odstraníme 2, 3 a 6 z `nums1`, stejně jako 2 a dva výskyty 3 z `nums2`. Po odstranění se pole stanou `nums1 = [1,4,5]` a `nums2 = [2,3,2]`. Proto `s = {1,2,3,4,5}`.
Lze prokázat, že 5 je maximální možná velikost množiny `s` po odstranění.

Příklad 3:

Vstup: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Výstup: 6
Vysvětlení: Odstraníme 1, 2 a 3 z `nums1`, stejně jako 4, 5 a 6 z `nums2`. Po odstranění se pole stanou `nums1 = [1,2,3]` a `nums2 = [4,5,6]`. Proto `s = {1,2,3,4,5,6}`.
Lze prokázat, že 6 je maximální možná velikost množiny `s` po odstranění.

Omezení:

`n == nums1.length == nums2.length`
`1 <= n <= 2 * 10^4`
`n` je sudé.
`1 <= nums1[i], nums2[i] <= 10^9`

Dostanete dvě 0-indexovaná celočíselná pole nums1 a nums2 sudé délky n.
Musíte odstranit n / 2 prvků z nums1 a n / 2 prvků z nums2. Po odstranění vložíte zbývající prvky nums1 a nums2 do sady s.
Vraťte maximální možnou velikost množiny s.

Příklad 1:

Vstup: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Výstup: 2
Vysvětlení: Odstraníme dva výskyty 1 z nums1 a nums2. Po odstranění se pole stanou nums1 = [2,2] a nums2 = [1,1]. Proto s = {1,2}.
Lze ukázat, že 2 je maximální možná velikost sady s po odstranění.

Příklad 2:

Vstup: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Výstup: 5
Vysvětlení: Odebereme 2, 3 a 6 z nums1 a také 2 a dva výskyty 3 z nums2. Po odstranění se pole stanou nums1 = [1,4,5] a nums2 = [2,3,2]. Proto s = {1,2,3,4,5}.
Lze ukázat, že 5 je maximální možná velikost sady s po odstranění.

Příklad 3:

Vstup: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Výstup: 6
Vysvětlení: Odebereme 1, 2 a 3 z nums1 a také 4, 5 a 6 z nums2. Po odstranění se pole stanou nums1 = [1,2,3] a nums2 = [4,5,6]. Proto s = {1,2,3,4,5,6}.
Lze ukázat, že 6 je maximální možná velikost sady s po odstranění.

Omezení:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n je sudé.
1 <= nums1[i], nums2[i] <= 10^9

Jsou vám dána dvě 0-indexovaná celočíselná pole nums1 a nums2 sudé délky n.
Musíte odstranit n / 2 prvků z nums1 a n / 2 prvků z nums2. Po odstranění vložíte zbývající prvky nums1 a nums2 do sady s.
Vraťte maximální možnou velikost množiny s.

Příklad 1:

Vstup: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Výstup: 2
Vysvětlení: Odstraníme dva výskyty 1 z nums1 a nums2. Po odstranění se pole stanou nums1 = [2,2] a nums2 = [1,1]. Proto s = {1,2}.
Lze ukázat, že 2 je maximální možná velikost sady s po odstranění.

Příklad 2:

Vstup: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Výstup: 5
Vysvětlení: Odebereme 2, 3 a 6 z nums1 a také 2 a dva výskyty 3 z nums2. Po odstranění se pole stanou nums1 = [1,4,5] a nums2 = [2,3,2]. Proto s = {1,2,3,4,5}.
Lze ukázat, že 5 je maximální možná velikost sady s po odstranění.

Příklad 3:

Vstup: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Výstup: 6
Vysvětlení: Odebereme 1, 2 a 3 z nums1 a také 4, 5 a 6 z nums2. Po odstranění se pole stanou nums1 = [1,2,3] a nums2 = [4,5,6]. Proto s = {1,2,3,4,5,6}.
Lze ukázat, že 6 je maximální možná velikost sady s po odstranění.

Omezení:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n je sudé.
1 <= nums1[i], nums2[i] <= 10^9


Je vám dáno celočíselné pole `nums` o délce `n` s indexováním od nuly.
Je povoleno provést speciální tah libovolný početkrát (včetně nuly) na `nums`. V jednom speciálním tahu provedete následující kroky v pořadí:

Vyberte index `i` v rozsahu `[0, n - 1]` a kladné celé číslo `x`.
Přidejte `|nums[i] - x|` k celkovým nákladům.
Změňte hodnotu `nums[i]` na `x`.

Palindromické číslo je kladné celé číslo, které zůstává stejné, když jsou jeho číslice obráceny. Například, 121, 2552 a 65756 jsou palindromické čísla, zatímco 24, 46, 235 nejsou palindromické čísla.
Pole je považováno za `equalindromické`, pokud všechny prvky v poli jsou rovny číslu `y`, kde `y` je palindromické číslo menší než `10^9`.
Vraťte celé číslo označující minimální možné celkové náklady na to, aby `nums` bylo `equalindromické` pomocí libovolného počtu speciálních tahů.

Příklad 1:

Vstup: `nums = [1,2,3,4,5]`
Výstup: `6`
Vysvětlení: Můžeme pole změnit na `equalindromické` tím, že změníme všechny prvky na `3`, což je palindromické číslo. Náklady na změnu pole na `[3,3,3,3,3]` pomocí 4 speciálních tahů jsou dány jako `|1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6`.
Lze ukázat, že změna všech prvků na jakékoliv jiné palindromické číslo než `3` nemůže být dosažena s nižšími náklady.

Příklad 2:

Vstup: `nums = [10,12,13,14,15]`
Výstup: `11`
Vysvětlení: Můžeme pole změnit na `equalindromické` tím, že změníme všechny prvky na `11`, což je palindromické číslo. Náklady na změnu pole na `[11,11,11,11,11]` pomocí 5 speciálních tahů jsou dány jako `|10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11`.
Lze ukázat, že změna všech prvků na jakékoliv jiné palindromické číslo než `11` nemůže být dosažena s nižšími náklady.

Příklad 3:

Vstup: `nums = [22,33,22,33,22]`
Výstup: `22`
Vysvětlení: Můžeme pole změnit na `equalindromické` tím, že změníme všechny prvky na `22`, což je palindromické číslo. Náklady na změnu pole na `[22,22,22,22,22]` pomocí 2 speciálních tahů jsou dány jako `|33 - 22| + |33 - 22| = 22`.
Lze ukázat, že změna všech prvků na jakékoliv jiné palindromické číslo než `22` nemůže být dosažena s nižšími náklady.

Omezení:

1 <= n <= 10^5
1 <= nums[i] <= 10^9

Dostanete 0-indexované celočíselné pole nums s délkou n.
Speciální tah můžete provést libovolný počet opakování (včetně nuly) na nums. V jednom speciálním pohybu provedete následující kroky v pořadí:

Vyberte index i v rozsahu [0, n - 1] a kladné celé číslo x.
Přidejte |nums[i] - x| k celkovým nákladům.
Změňte hodnotu nums[i] na x.

Palindromické číslo je kladné celé číslo, které zůstává stejné, když jsou jeho číslice obráceny. Například 121, 2552 a 65756 jsou palindromická čísla, zatímco 24, 46, 235 nejsou palindromická čísla.
Pole je považováno za rovnoindromické, pokud se všechny prvky v poli rovnají celému číslu y, kde y je palindromické číslo menší než 10^9.
Vraťte celé číslo označující minimální možnou celkovou cenu, aby se nums vyrovnal indromickým provedením libovolného počtu speciálních tahů.

Příklad 1:

Vstup: nums = [1,2,3,4,5]
Výstup: 6
Vysvětlení: Pole můžeme učinit rovnoindromické změnou všech prvků na 3, což je palindromické číslo. Náklady na změnu pole na [3,3,3,3,3] pomocí 4 speciálních tahů jsou dány |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Lze ukázat, že změny všech prvků na jakékoli jiné palindromické číslo než 3 nelze dosáhnout s nižšími náklady.

Příklad 2:

Vstup: nums = [10,12,13,14,15]
Výstup: 11
Vysvětlení: Pole můžeme učinit rovnoindromické změnou všech prvků na 11, což je palindromické číslo. Náklady na změnu pole na [11,11,11,11,11] pomocí 5 speciálních tahů jsou dány |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Lze ukázat, že změny všech prvků na jakékoli jiné palindromické číslo než 11 nelze dosáhnout s nižšími náklady.

Příklad 3:

Vstup: nums = [22,33,22,33,22]
Výstup: 22
Vysvětlení: Pole můžeme učinit rovnoindromické změnou všech prvků na 22, což je palindromické číslo. Náklady na změnu pole na [22,22,22,22,22] pomocí 2 speciálních tahů jsou dány |33 - 22| + |33 - 22| = 22.
Lze ukázat, že změny všech prvků na jakékoli jiné palindromické číslo než 22 nelze dosáhnout s nižšími náklady.

Omezení:

1 <= n <= 10^5
1 <= nums[i] <= 10^9

Je vám dáno celé pole s indexem 0 a čísly o délce n.
Na číslech můžete provést speciální tah kolikrát (včetně nuly). V jednom speciálním tahu provedete následující kroky v uvedeném pořadí:

Vyberte index i v rozsahu [0, n - 1] a kladné celé číslo x.
Přidat |nums[i] - x| k celkovým nákladům.
Změňte hodnotu funkce nums[i] na x.

Palaindromické číslo je kladné celé číslo, které zůstává stejné, když jsou jeho číslice obráceny. Například 121, 2552 a 65756 jsou palindromická čísla, zatímco 24, 46, 235 nejsou palindromická čísla.
Pole se považuje za equalindromické, pokud jsou všechny prvky v poli rovny celému číslu y, kde y je palindromické číslo menší než 10^9.
Vrátí celé číslo označující minimální možné celkové náklady, aby se čísla rovnala provedením libovolného počtu speciálních tahů.

Příklad 1:

Vstup: nums = [1,2,3,4,5]
Výstup: 6
Vysvětlení: Pole můžeme udělat ekvalidromickým tím, že změníme všechny prvky na 3, což je palindromické číslo. Náklady na změnu pole na [3,3,3,3,3] pomocí 4 speciálních tahů jsou dány vztahem |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Lze ukázat, že změna všech prvků na jakékoli palindromické číslo jiné než 3 nemůže být dosažena s nižšími náklady.

Příklad 2:

Vstup: nums = [10,12,13,14,15]
Výstup: 11
Vysvětlení: Pole můžeme udělat ekvalizérem tím, že změníme všechny prvky na 11, což je palindromické číslo. Náklady na změnu pole na [11,11,11,11,11] pomocí 5 speciálních tahů jsou dány vztahem |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Lze ukázat, že změna všech prvků na jakékoli palindromické číslo jiné než 11 nemůže být dosažena s nižšími náklady.

Příklad 3:

Vstup: nums = [22,33,22,33,22]
Výstup: 22
Vysvětlení: Pole můžeme udělat ekvalizérem tím, že změníme všechny prvky na 22, což je palindromické číslo. Náklady na změnu pole na [22,22,22,22,22] pomocí 2 speciálních tahů jsou dány vztahem |33 - 22| + |33 - 22| = 22.
Lze ukázat, že změna všech prvků na jakékoli palindromické číslo jiné než 22 nemůže být dosažena s nižšími náklady.

Omezení:

1 <= n <= 10^5
1 <= nums[i] <= 10^9


Dostanete 0-indexované řetězcové slovo.
V jedné operaci můžete vybrat libovolný index i slova a změnit slovo[i] na jakékoli malé anglické písmeno.
Vrátí minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků ze slova.
Dva znaky a a b jsou téměř stejné, pokud a == b nebo a a b sousedí v abecedě.

Příklad 1:

Vstup: slovo = "aaaaa"
Výstup: 2
Vysvětlení: Můžeme změnit slovo na "acaca", které nemá žádné sousední téměř stejné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků ze slova je 2.

Příklad 2:

Vstup: slovo = "abddez"
Výstup: 2
Vysvětlení: Můžeme změnit slovo na "ybdoez", které nemá žádné sousední téměř stejné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků ze slova je 2.
Příklad 3:

Vstup: slovo = "zyxyxyz"
Výstup: 3
Vysvětlení: Můžeme změnit slovo na "zaxaxaz", které nemá žádné sousední téměř stejné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků ze slova je 3.

Omezení:

1 <= délka slova <= 100
slovo se skládá pouze z malých anglických písmen.

Dostanete řetězcové slovo indexované 0.
V jedné operaci můžete vybrat libovolný index i slova a změnit word[i] na libovolné malé anglické písmeno.
Vrátí minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků z wordu.
Dva znaky a a b jsou téměř stejné, pokud a == b nebo a a b jsou v abecedě vedle sebe.

Příklad 1:

Vstup: word = "aaaaa"
Výstup: 2
Vysvětlení: Můžeme změnit slovo na "acaca", které nemá žádné sousední téměř stejné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků ze slova je 2.

Příklad 2:

Vstup: word = "abddez"
Výstup: 2
Vysvětlení: Můžeme změnit slovo na "ybdoez", které nemá žádné sousední téměř stejné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků ze slova je 2.
Příklad 3:

Vstup: word = "zyxyxyz"
Výstup: 3
Vysvětlení: Můžeme změnit slovo na "zaxaxaz", které nemá žádné sousední téměř stejné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř stejných znaků ze slova je 3.

Omezení:

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

Je vám dán řetězec word s indexováním od 0.
V jedné operaci můžete vybrat libovolný index i řetězce word a změnit word[i] na libovolné malé písmeno anglické abecedy.
Vrátí minimální počet operací potřebných k odstranění všech sousedních téměř rovných znaků z word.
Dva znaky a a b jsou téměř rovné, pokud a == b nebo a a b jsou sousední v abecedě.

Příklad 1:

Vstup: word = "aaaaa"
Výstup: 2
Vysvětlení: Můžeme změnit word na "acaca", který nemá žádné sousední téměř rovné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř rovných znaků z word je 2.

Příklad 2:

Vstup: word = "abddez"
Výstup: 2
Vysvětlení: Můžeme změnit word na "ybdoez", který nemá žádné sousední téměř rovné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř rovných znaků z word je 2.

Příklad 3:

Vstup: word = "zyxyxyz"
Výstup: 3
Vysvětlení: Můžeme změnit word na "zaxaxaz", který nemá žádné sousední téměř rovné znaky.
Lze ukázat, že minimální počet operací potřebných k odstranění všech sousedních téměř rovných znaků z word je 3.

Omezení:

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


Je vám dáno pole celých čísel coins s indexováním od 0, které představuje hodnoty dostupných mincí, a celé číslo target. Celé číslo x je dosažitelné, pokud existuje podposloupnost mincí, která sečtena dá x. Vraťte minimální počet mincí libovolné hodnoty, které je třeba přidat do pole, aby každé celé číslo v rozsahu [1, target] bylo dosažitelné. Podposloupnost pole je nové neprázdné pole, které je vytvořeno z původního pole odstraněním některých (případně žádných) prvků, aniž by byla narušena relativní pozice zbývajících prvků.

Příklad 1:

Vstup: coins = [1,4,10], target = 19
Výstup: 2
Vysvětlení: Musíme přidat mince 2 a 8. Výsledné pole bude [1,2,4,8,10].
Můžeme ukázat, že všechna celá čísla od 1 do 19 jsou dosažitelná z výsledného pole a že 2 je minimální počet mincí, které je třeba přidat do pole.

Příklad 2:

Vstup: coins = [1,4,10,5,7,19], target = 19
Výstup: 1
Vysvětlení: Musíme přidat jen minci 2. Výsledné pole bude [1,2,4,5,7,10,19].
Můžeme ukázat, že všechna celá čísla od 1 do 19 jsou dosažitelná z výsledného pole a že 1 je minimální počet mincí, které je třeba přidat do pole.

Příklad 3:

Vstup: coins = [1,1,1], target = 20
Výstup: 3
Vysvětlení: Musíme přidat mince 4, 8 a 16. Výsledné pole bude [1,1,1,4,8,16].
Můžeme ukázat, že všechna celá čísla od 1 do 20 jsou dosažitelná z výsledného pole a že 3 je minimální počet mincí, které je třeba přidat do pole.

Omezení:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

Dostanete celočíselné pole mincí indexované 0, které představuje hodnoty dostupných mincí, a celočíselný cíl.
Celé číslo x lze získat, pokud existuje podposloupnost mincí, která se sčítá do x.
Vrátí minimální počet mincí libovolné hodnoty, které je třeba přidat do pole, aby bylo možné získat každé celé číslo v rozsahu [1, cíl].
Podsekvence pole je nové neprázdné pole, které je vytvořeno z původního pole odstraněním některých (možná žádných) prvků, aniž by došlo k narušení relativních pozic zbývajících prvků.

Příklad 1:

Vstup: coins = [1,4,10], target = 19
Výstup: 2
Vysvětlení: Musíme sečíst mince 2 a 8. Výsledná matice bude [1,2,4,8,10].
Lze ukázat, že z výsledného pole lze získat všechna celá čísla od 1 do 19 a že 2 je minimální počet mincí, které je třeba do pole přidat.

Příklad 2:

Vstup: coins = [1,4,10,5,7,19], target = 19
Výstup: 1
Vysvětlení: Stačí přidat minci 2. Výsledná matice bude [1,2,4,5,7,10,19].
Lze ukázat, že z výsledného pole lze získat všechna celá čísla od 1 do 19 a že 1 je minimální počet mincí, které je třeba do pole přidat.

Příklad 3:

Vstup: coins = [1,1,1], target = 20
Výstup: 3
Vysvětlení: Musíme sečíst mince 4, 8 a 16. Výsledná matice bude [1,1,1,4,8,16].
Lze ukázat, že z výsledného pole lze získat všechna celá čísla od 1 do 20 a že 3 je minimální počet mincí, které je třeba do pole přidat.

Omezení:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

Je zadáno pole mincí s indexem 0, které představuje hodnoty dostupných mincí, a celočíselný cíl.
Celé číslo x lze získat, pokud existuje posloupnost mincí, jejíž součet je roven x.
Vraťte minimální počet mincí libovolné hodnoty, které je třeba přidat do pole, aby bylo možné získat každé celé číslo v rozsahu [1, cíl].
Podřetězec pole je nové neprázdné pole, které vznikne z původního pole vymazáním některých (případně žádných) prvků, aniž by se narušila relativní pozice zbývajících prvků.

Příklad 1:

Vstup: mince = [1,4,10], cíl = 19
Výstup: 2
Vysvětlení: Potřebujeme sečíst mince 2 a 8. Výsledné pole bude [1,2,4,8,10].
Lze ukázat, že z výsledného pole lze získat všechna celá čísla od 1 do 19 a že 2 je minimální počet mincí, které je třeba do pole přidat.

Příklad 2:

Vstup: mince = [1,4,10,5,7,19], cíl = 19
Výstup: 1
Vysvětlení: Výsledné pole bude [1,2,4,5,7,10,19].
Lze ukázat, že z výsledného pole lze získat všechna celá čísla od 1 do 19 a že 1 je minimální počet mincí, které je třeba do pole přidat.

Příklad 3:

Vstup: mince = [1,1,1], cíl = 20
Výstup: 3
Vysvětlení: Potřebujeme sečíst mince 4, 8 a 16. Výsledné pole bude [1,1,1,4,8,16].
Lze ukázat, že z výsledného pole lze získat všechna celá čísla od 1 do 20 a že 3 je minimální počet mincí, které je třeba do pole přidat.

Omezení:

1 <= cíl <= 10^5
1 <= mince.length <= 10^5
1 <= coins[i] <= target


Máte řetězec s indexováním začínajícím od 0 a celé číslo k.
Máte provést následující operace rozdělení, dokud nebude s prázdný:

Vyberte nejdelší prefix řetězce s, který obsahuje nejvýše k různých znaků.
Odstraňte prefix z řetězce s a zvýšte počet dělení o jeden. Zbývající znaky (pokud nějaké jsou) v řetězci s si zachovávají svůj původní pořádek.

Před těmito operacemi můžete změnit maximálně jeden index v řetězci s na jiný malý anglický písmeno.
Vraťte celé číslo, které udává maximální počet vzniklých dělení po operacích, když optimálně vyberete maximálně jeden index k změně.

Příklad 1:

Vstup: s = "accca", k = 2
Výstup: 3
Vysvětlení: V tomto příkladu, aby byl maximalizován počet výsledných rozdělení, lze s[2] změnit na 'b'.
s se stane "acbca".
Operace mohou nyní proběhnout následovně, dokud není s prázdné:
- Vyberte nejdelší prefix obsahující nejvýše 2 různé znaky, "acbca".
- Odstraňte prefix a s se stane "bca". Počet rozdělení je nyní 1.
- Vyberte nejdelší prefix obsahující nejvýše 2 různé znaky, "bca".
- Odstraňte prefix a s se stane "a". Počet rozdělení je nyní 2.
- Vyberte nejdelší prefix obsahující nejvýše 2 různé znaky, "a".
- Odstraňte prefix a s se stane prázdné. Počet rozdělení je nyní 3.
Odpověď je tedy 3.
Lze ukázat, že není možné získat více než 3 rozdělení.

Příklad 2:

Vstup: s = "aabaab", k = 3
Výstup: 1
Vysvětlení: V tomto příkladu, aby byl maximalizován počet výsledných rozdělení, můžeme s ponechat tak, jak je.
Operace mohou nyní proběhnout následovně, dokud není s prázdné:
- Vyberte nejdelší prefix obsahující nejvýše 3 různé znaky, "aabaab".
- Odstraňte prefix a s se stane prázdné. Počet rozdělení se stává 1.
Odpověď je tedy 1.
Lze ukázat, že není možné získat více než 1 rozdělení.

Příklad 3:

Vstup: s = "xxyz", k = 1
Výstup: 4
Vysvětlení: V tomto příkladu, aby byl maximalizován počet výsledných rozdělení, lze s[1] změnit na 'a'.
s se stane "xayz".
Operace mohou nyní proběhnout následovně, dokud není s prázdné:
- Vyberte nejdelší prefix obsahující nejvýše 1 různý znak, "xayz".
- Odstraňte prefix a s se stane "ayz". Počet rozdělení je nyní 1.
- Vyberte nejdelší prefix obsahující nejvýše 1 různý znak, "ayz".
- Odstraňte prefix a s se stane "yz". Počet rozdělení je nyní 2.
- Vyberte nejdelší prefix obsahující nejvýše 1 různý znak, "yz".
- Odstraňte prefix a s se stane "z". Počet rozdělení je nyní 3.
- Vyberte nejdelší prefix obsahující nejvýše 1 různý znak, "z".
- Odstraňte prefix a s se stane prázdné. Počet rozdělení je nyní 4.
Odpověď je tedy 4.
Lze ukázat, že není možné získat více než 4 rozdělení.

Omezení:

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

Je zadán řetězec s indexem 0 a celé číslo k.
Máte provést následující operace rozdělení, dokud nebude s prázdný:

Vyberte nejdelší prefix s, který obsahuje nejvýše k různých znaků.
Odstraňte prefix z s a zvyšte počet oddílů o jeden. Zbývající znaky (pokud existují) v s si zachovají své původní pořadí.

Před těmito operacemi je dovoleno změnit nejvýše jeden index v s na jiné malé anglické písmeno.
Vraťte celé číslo označující maximální počet výsledných oddílů po operacích optimální volbou nejvýše jednoho indexu, který se má změnit.

Příklad 1:

Vstup: s = "accca", k = 2
Výstup: 3
Vysvětlení: V tomto příkladu lze pro maximalizaci počtu výsledných oddílů změnit s[2] na "b“.
s se stane"acbca“.
Operace lze nyní provádět následujícím způsobem, dokud se s nestane prázdným:
- Zvolte nejdelší prefix obsahující nejvýše 2 různé znaky, "acbca“.
- Vymažte prefix a z s se stane "bca“. Počet oddílů je nyní 1.
- Vyberte nejdelší prefix obsahující nejvýše 2 různé znaky, „bca“.
- Odstraňte předponu a z "s“ se stane "a“. Počet oddílů je nyní 2.
- Vyberte nejdelší prefix obsahující nejvýše 2 různé znaky, "a“.
- Odstraňte prefix a s se stane prázdným. Počet oddílů je nyní 3.
Odpověď je tedy 3.
Lze ukázat, že není možné získat více než 3 oddíly.
Příklad 2:

Vstup: s = "aabaab“, k = 3
Výstup: 1
Vysvětlení: V tomto příkladu můžeme pro maximalizaci počtu výsledných oddílů ponechat s tak, jak je.
Operace lze nyní provádět následujícím způsobem, dokud nebude s prázdné:
- Zvolte nejdelší prefix obsahující nejvýše 3 různé znaky,"aabaab“.
- Odstraňte prefix a s se stane prázdným. Počet oddílů se stane 1.
Odpověď je tedy 1.
Lze ukázat, že není možné získat více než 1 oddíl.

Příklad 3:

Vstup: s = "xxyz“, k = 1
Výstup: 4
Vysvětlení: V tomto příkladu lze pro maximalizaci počtu výsledných oddílů změnit s[1] na "a“.
s se stane"xayz“.
Operace lze nyní provádět následujícím způsobem, dokud se s nestane prázdným:
- Zvolte nejdelší prefix obsahující nejvýše 1 odlišný znak, "xayz“.
- Vymažte prefix a z s se stane "ayz“. Počet oddílů je nyní 1.
- Vyberte nejdelší prefix obsahující nejvýše 1 odlišný znak, "ayz“.
- Odstraňte předponu a z s se stane "yz“. Počet oddílů je nyní 2.
- Vyberte nejdelší prefix obsahující nejvýše 1 odlišný znak, "yz“.
- Odstraňte předponu a z "s“ se stane "z“. Počet oddílů je nyní 3.
- Vyberte nejdelší prefix obsahující nejvýše 1 odlišný znak, "z“.
- Vymažte prefix a s se stane prázdným. Počet oddílů je nyní 4.
Odpověď je tedy 4.
Lze ukázat, že není možné získat více než 4 oddíly.

Omezení:

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

Dostanete řetězec s indexovaný 0 a celé číslo k.
Dokud nebude s prázdné, budete provádět následující operace dělení:

Zvolte nejdelší předponu s obsahující maximálně k různých znaků.
Odstraňte předponu z s a zvyšte počet oddílů o jeden. Zbývající znaky (pokud existují) v s si zachovají své původní pořadí.

Před zahájením operací je možné změnit maximálně jeden index v s na jiné malé anglické písmeno.
Vrací celé číslo označující maximální počet výsledných oddílů po operacích optimálním výběrem maximálně jednoho indexu, který chcete změnit.

Příklad 1:

Vstup: s = "accca", k = 2
Výstup: 3
Vysvětlení: V tomto příkladu, aby se maximalizoval počet výsledných oddílů, lze parametr s[2] změnit na 'b'.
Z se stane "acbca".
Operace lze nyní provádět následujícím způsobem, dokud se s nevyprázdní:
- Vyberte nejdelší předponu obsahující maximálně 2 různé znaky, "acbca".
- Odstraňte předponu a z s se stane "bca". Počet oddílů je nyní 1.
- Vyberte nejdelší předponu obsahující maximálně 2 různé znaky, "bca".
- Odstraňte předponu a z "a". Počet oddílů je nyní 2.
- Vyberte nejdelší předponu obsahující maximálně 2 různé znaky, "a".
- Odstraňte předponu a znak s se vyprázdní. Počet oddílů je nyní 3.
Odpověď je tedy 3.
Lze ukázat, že není možné získat více než 3 oddíly.
Příklad 2:

Vstup: s = "aabaab", k = 3
Výstup: 1
Vysvětlení: V tomto příkladu můžeme pro maximalizaci počtu výsledných oddílů ponechat s tak, jak je.
Operace lze nyní provádět následujícím způsobem, dokud se s nevyprázdní:
- Vyberte nejdelší předponu obsahující maximálně 3 různé znaky, "aabaab".
- Odstraňte předponu a znak s se vyprázdní. Počet oddílů se změní na 1.
Odpověď je tedy 1.
Lze ukázat, že není možné získat více než 1 oddíl.

Příklad 3:

Vstup: s = "xxyz", k = 1
Výstup: 4
Vysvětlení: V tomto příkladu, aby se maximalizoval počet výsledných oddílů, lze parametr s[1] změnit na 'a'.
Z se stane "xayz".
Operace lze nyní provádět následujícím způsobem, dokud se s nevyprázdní:
- Vyberte nejdelší předponu obsahující maximálně 1 odlišný znak, "xayz".
- Odstraňte předponu a z s se stane "ayz". Počet oddílů je nyní 1.
- Vyberte nejdelší předponu obsahující maximálně 1 odlišný znak, "ayz".
- Odstraňte předponu a z "yz" se stane "yz". Počet oddílů je nyní 2.
- Vyberte nejdelší předponu obsahující maximálně 1 odlišný znak "yz".
- Odstraňte předponu a z s se stane "z". Počet oddílů je nyní 3.
- Vyberte nejdelší předponu obsahující maximálně 1 odlišný znak "z".
- Odstraňte předponu a znak s se vyprázdní. Počet oddílů je nyní 4.
Odpověď je tedy 4.
Lze ukázat, že není možné získat více než 4 oddíly.

Omezení:

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


Je vám dána 2D pole s nulovým indexem `variables`, kde `variables[i] = [a_i, b_i, c_i, m_i]`, a celé číslo `target`.
Index `i` je dobrý, pokud platí následující vzorec:

0 <= i < variables.length
((a_i^b_i % 10)^c_i) % m_i == target

Vraťte pole obsahující dobré indexy v libovolném pořadí.

Příklad 1:

Vstup: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Výstup: [0,2]
Vysvětlení: Pro každý index `i` v poli `variables`:
1) Pro index 0, `variables[0] = [2,3,3,10]`, (2^3 % 10)^3 % 10 = 2.
2) Pro index 1, `variables[1] = [3,3,3,1]`, (3^3 % 10)^3 % 1 = 0.
3) Pro index 2, `variables[2] = [6,1,1,4]`, (6^1 % 10)^1 % 4 = 2.
Proto vracíme [0,2] jako odpověď.

Příklad 2:

Vstup: variables = [[39,3,1000,1000]], target = 17
Výstup: []
Vysvětlení: Pro každý index `i` v poli `variables`:
1) Pro index 0, `variables[0] = [39,3,1000,1000]`, (39^3 % 10)^1000 % 1000 = 1.
Proto vracíme [] jako odpověď.

Omezení:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Je dáno pole 2D proměnných s indexem 0, kde proměnné[i] = [a_i, b_i, c_i, m_i], a celočíselný cíl.
Index i je dobrý, pokud platí následující vzorec:

0 <= i < proměnné.length
((a_i^bi % 10)^ci) % m_i == cílová hodnota

Vraťte pole složené z dobrých indexů v libovolném pořadí.

Příklad 1:

Vstup: proměnné = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], cíl = 2
Výstup: [0,2]
Vysvětlení: Pro každý index i v poli proměnných:
1) Pro index 0, proměnné[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Pro index 1, proměnné[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Pro index 2, proměnné[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Proto jako odpověď vracíme [0,2].

Příklad 2:

Vstup: proměnné = [[39,3,1000,1000]], cíl = 17
Výstup: []
Vysvětlení: Pro každý index i v poli proměnných:
1) Pro index 0, proměnné[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Proto jako odpověď vracíme [].

Omezení:

1 <= proměnné.length <= 100
proměnné[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= cíl <= 10^3

Je zadáno pole 2D proměnných s indexem 0, kde proměnné[i] = [a_i, b_i, c_i, m_i], a celočíselný cíl.
Index i je dobrý, pokud platí následující vzorec:

0 <= i <  variables.length
((a_i^bi % 10)^ci) % m_i == target

Vrátí pole složené z dobrých indexů v libovolném pořadí.

Příklad 1:

Vstup: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], cíl = 2
Výstup: [0,2]
Vysvětlení: Pro každý index i v poli proměnných:
1) Pro index 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Pro index 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Pro index 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Proto jako odpověď vrátíme [0,2].

Příklad 2:

Vstup: variables = [[39,3,1000,1000]], target = 17
Výstup: []
Vysvětlení: Pro každý index i v poli proměnných:
1) Pro index 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Proto jako odpověď vracíme [].

Omezení:

1 <= variables.length <= 100
proměnné[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= cíl <= 10^3


Dostanete dva řetězce indexované 0 source a target, oba o délce n a skládající se z malých anglických písmen. Jsou vám také poskytnuta dvě pole znaků s indexem 0, původní a změněná, a celočíselné pole cost, kde cost[i] představuje náklady na změnu původního znaku[i] na změněný changed[i].
Začnete se zdrojem řetězců. V jedné operaci můžete vybrat znak x z řetězce a změnit jej na znak y za cenu z, pokud existuje nějaký index j takový, že cost[j] == z, original[j] == x a changed[j] == y.
Vrátí minimální náklady na převod zdroje řetězce na cíl řetězce pomocí libovolného počtu operací. Pokud není možné převést zdroj na cíl, vrátí hodnotu -1.
Všimněte si, že mohou existovat indexy i, j takové, že original[j] == original[i] a changed[j] == changed[i].

Příklad 1:

Vstup: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Výstup: 28
Vysvětlení: Chcete-li převést řetězec "abcd" na řetězec "acbe":
- Změňte hodnotu indexu 1 z "b" na "c" za cenu 5.
- Změňte hodnotu indexu 2 z "c" na "e" za cenu 1.
- Změňte hodnotu indexu 2 z "e" na "b" za cenu 2.
- Změňte hodnotu indexu 3 z "d" na "e" za cenu 20.
Celkové vzniklé náklady jsou 5 + 1 + 2 + 20 = 28.
Lze prokázat, že se jedná o minimální možné náklady.

Příklad 2:

Vstup: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Výstup: 12
Vysvětlení: Chcete-li změnit znak "a" na "b", změňte znak "a" na "c" za cenu 1 a poté změňte znak "c" na "b" za cenu 2, za celkovou cenu 1 + 2 = 3. Chcete-li změnit všechny výskyty "a" na "b", jsou účtovány celkové náklady 3 * 4 = 12.

Příklad 3:

Vstup: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Výstup: -1
Vysvětlení: Není možné převést zdroj na cíl, protože hodnotu v indexu 3 nelze změnit z "d" na "e".

Omezení:

1 <= source.length == target.length <= 10^5
source, target se skládají z malých anglických písmen.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] jsou malá anglická písmena.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Jsou zadány dva řetězce s indexem 0, zdrojový a cílový, oba o délce n a skládající se z malých anglických písmen. Dále jsou zadána dvě pole znaků s indexem 0 original a changed a pole celých čísel cost, kde cost[i] představuje náklady na změnu znaku original[i] na znak changed[i].
Začínáte s řetězcem source. V jedné operaci můžete z řetězce vybrat znak x a změnit jej na znak y s náklady z, pokud existuje libovolný index j takový, že cost[j] == z, original[j] == x a changed[j] == y.
Vrátí minimální náklady na převod zdrojového řetězce na cílový řetězec pomocí libovolného počtu operací. Pokud není možné převést zdroj na cíl, vrátí se hodnota -1.
Všimněte si, že mohou existovat takové indexy i, j, že original[j] == original[i] a changed[j] == changed[i].

Příklad 1:

Vstup: source =  "abcd“, target =  "acbe“, original = [ "a“,  "b“,  "c“,  "c“,  "e“,  "d“], changed = [ "b“,  "c“,  "b“, "e“,  "b“,  "e“], cost = [2,5,5,1,2,20]
Výstup: 28
Vysvětlení: Převod řetězce  "abcd“ na řetězec  "acbe“:
- Změňte hodnotu na indexu 1 z  "b“ na  "c“ za cenu 5.
- Změňte hodnotu v indexu 2 z  "c“ na  "e“ za cenu 1.
- Změna hodnoty v indexu 2 z  "e“ na  "b“ za cenu 2.
- Změna hodnoty v indexu 3 z "d“ na  "e“ za cenu 20.
Celkové náklady jsou 5 + 1 + 2 + 20 = 28.
Lze ukázat, že se jedná o minimální možné náklady.

Příklad 2:

Vstup: zdroj =  "aaaa“, cíl =  "bbbb“, původní = [ "a“,  "c“], změněno = [ "c“, „b“], náklady = [1,2]
Výstup: 12
Vysvětlení: Pro změnu znaku „a“ na „b“ změňte znak „a“ na „c“ s náklady 1, následně změňte znak „c“ na „b“ s náklady 2, celkové náklady jsou 1 + 2 = 3. Chcete-li změnit všechny výskyty znaku „a“ na „b“, vzniknou celkové náklady 3 * 4 = 12.

Příklad 3:

Vstup: zdroj =  "abcd“, cíl =  "abce“, původní = [ "a“], změněno =   ["e“], náklady = [10000]
Výstup: -1
Vysvětlení: Není možné převést zdroj na cíl, protože hodnotu na indexu 3 nelze změnit z „d“ na „e“.

Omezení:

1 <= source.length == target.length <= 10^5
zdroj, cíl se skládají z malých anglických písmen.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] jsou malá anglická písmena.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Dostanete dva 0-indexované řetězce zdroj a cíl, oba o délce n a sestávající z malých anglických písmen. Dostanete také dvě 0-indexovaná pole znaků původní a změněná a cenu celočíselného pole, kde cena[i] představuje náklady na změnu původního znaku[i] na znak změněný[i].
Začnete se zdrojem řetězce. V jedné operaci můžete vybrat znak x z řetězce a změnit jej na znak y za cenu z, pokud existuje nějaký index j takový, že cena[j] == z, původní[j] == x a změněno[j] == y.
Vraťte minimální náklady na převod zdroje řetězce na cílový řetězec pomocí libovolného počtu operací. Pokud není možné převést zdroj na cíl, vraťte -1.
Všimněte si, že mohou existovat indexy i, j, že původní[j] == původní[i] a změněno[j] == změněno[i].

Příklad 1:

Vstup: zdroj = "abcd", cíl = "acbe", původní = ["a","b","c","c","e","d"], změněno = ["b"," c","b","e","b","e"], cena = [2,5,5,1,2,20]
Výstup: 28
Vysvětlení: Chcete-li převést řetězec "abcd" na řetězec "acbe":
- Změňte hodnotu na indexu 1 z „b“ na „c“ za cenu 5.
- Změňte hodnotu na indexu 2 z „c“ na „e“ za cenu 1.
- Změňte hodnotu na indexu 2 z „e“ na „b“ za cenu 2.
- Změňte hodnotu na indexu 3 z „d“ na „e“ za cenu 20.
Celkové vynaložené náklady jsou 5 + 1 + 2 + 20 = 28.
Lze prokázat, že jde o minimální možné náklady.

Příklad 2:

Vstup: zdroj = "aaaa", cíl = "bbbb", původní = ["a","c"], změněno = ["c","b"], cena = [1,2]
Výstup: 12
Vysvětlení: Chcete-li změnit znak 'a' na 'b', změňte znak 'a' na 'c' za cenu 1, následovanou změnou znaku 'c' na 'b' za cenu 2, celkem náklady 1 + 2 = 3. Ke změně všech výskytů 'a' na 'b' jsou vynaloženy celkové náklady 3 * 4 = 12.

Příklad 3:

Vstup: zdroj = "abcd", cíl = "abce", původní = ["a"], změněno = ["e"], cena = [10 000]
Výstup: -1
Vysvětlení: Je nemožné převést zdroj na cíl, protože hodnotu na indexu 3 nelze změnit z 'd' na 'e'.

Omezení:

1 <= source.length == target.length <= 10^5
zdroj, cíl se skládají z malých anglických písmen.
1 <= cena.length == původní.length == změněná.length <= 2000
původní[i], změněno[i] jsou malá anglická písmena.
1 <= náklady[i] <= 10^6
původní[i] != změněno[i]


Dostanete 0-indexované pole celých čísel nums.
Předpona nums[0..i] je sekvenční, pokud pro všechna 1 <= j <= i, nums[j] = nums[j - 1] + 1. Konkrétně je předpona skládající se pouze z nums[0] sekvenční.
Vrátí nejmenší celé číslo x chybějící z čísel tak, že x je větší nebo rovno součtu nejdelší sekvenční předpony.

Příklad 1:

Vstup: nums = [1,2,3,2,5]
Výstup: 6
Vysvětlení: Nejdelší sekvenční prefix nums je [1,2,3] se součtem 6. 6 není v poli, proto 6 je nejmenší chybějící celé číslo větší nebo rovné součtu nejdelšího sekvenčního prefixu.

Příklad 2:

Vstup: nums = [3,4,5,1,12,14,13]
Výstup: 15
Vysvětlení: Nejdelší sekvenční prefix nums je [3,4,5] se součtem 12. 12, 13 a 14 patří do pole, zatímco 15 ne. Proto 15 je nejmenší chybějící celé číslo větší nebo rovné součtu nejdelší sekvenční předpony.

Omezení:

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


Máte dvě kladná celá čísla x a y.
V jedné operaci můžete provést jednu ze čtyř následujících operací:

Dělit x číslem 11, pokud je x násobkem 11.
Dělit x číslem 5, pokud je x násobkem 5.
Zmenšit x o 1.
Zvětšit x o 1.

Vraťte minimální počet operací potřebných k tomu, aby se x a y rovnaly.

Příklad 1:

Vstup: x = 26, y = 1
Výstup: 3
Vysvětlení: Můžeme udělat 26 rovné 1 provedením následujících operací:
1. Zmenšit x o 1
2. Dělit x číslem 5
3. Dělit x číslem 5
Je možné ukázat, že 3 je minimální počet operací potřebný k tomu, aby se 26 rovnalo 1.

Příklad 2:

Vstup: x = 54, y = 2
Výstup: 4
Vysvětlení: Můžeme udělat 54 rovné 2 provedením následujících operací:
1. Zvýšit x o 1
2. Dělit x číslem 11
3. Dělit x číslem 5
4. Zvýšit x o 1
Je možné ukázat, že 4 je minimální počet operací potřebný k tomu, aby se 54 rovnalo 2.

Příklad 3:

Vstup: x = 25, y = 30
Výstup: 5
Vysvětlení: Můžeme udělat 25 rovné 30 provedením následujících operací:
1. Zvýšit x o 1
2. Zvýšit x o 1
3. Zvýšit x o 1
4. Zvýšit x o 1
5. Zvýšit x o 1
Je možné ukázat, že 5 je minimální počet operací potřebný k tomu, aby se 25 rovnalo 30.

Omezení:

1 <= x, y <= 10^4

Jsou vám dána dvě kladná celá čísla x a y.
V jedné operaci můžete provést jednu ze čtyř následujících operací:

Vydělte x 11, pokud je x násobkem 11.
Vydělte x 5, pokud je x násobkem 5.
Snížit x o 1.
Zvýšit x o 1.

Vraťte minimální počet operací potřebných k tomu, aby se x a y rovnaly.

Příklad 1:

Vstup: x = 26, y = 1
Výstup: 3
Vysvětlení: Můžeme udělat 26 rovných 1 použitím následujících operací:
1. Snižte x o 1
2. Vydělte x 5
3. Vydělte x 5
Lze ukázat, že 3 je minimální počet operací potřebných k tomu, aby se 26 rovnalo 1.

Příklad 2:

Vstup: x = 54, y = 2
Výstup: 4
Vysvětlení: Můžeme udělat 54 rovných 2 použitím následujících operací:
1. Zvyšte x o 1
2. Vydělte x 11
3. Vydělte x 5
4. Zvyšte x o 1
Lze ukázat, že 4 je minimální počet operací potřebných k tomu, aby se 54 rovnalo 2.

Příklad 3:

Vstup: x = 25, y = 30
Výstup: 5
Vysvětlení: Můžeme udělat 25 rovných 30 použitím následujících operací:
1. Zvyšte x o 1
2. Zvyšte x o 1
3. Zvyšte x o 1
4. Zvyšte x o 1
5. Zvyšte x o 1
Lze ukázat, že 5 je minimální počet operací potřebných k tomu, aby se 25 rovnalo 30.

Omezení:

1 <= x, y <= 10^4


Máte dáno celé číslo k a celé číslo x.
Uvažujte, že s je binární reprezentace celého čísla num s indexem začínajícím od 1. Cena čísla num je počet i, pro které platí i % x == 0 a s[i] je nastavený bit.
Vraťte největší celé číslo num takové, že součet cen všech čísel od 1 do num je menší nebo roven k.
Poznámka:

V binární reprezentaci čísla je nastavený bit bit s hodnotou 1.
Binární reprezentace čísla bude indexována zprava doleva. Například, pokud s == 11100, s[4] == 1 a s[2] == 0.

Příklad 1:

Vstup: k = 9, x = 1
Výstup: 6
Vysvětlení: Čísla 1, 2, 3, 4, 5 a 6 mohou být zapsána v binární reprezentaci jako "1", "10", "11", "100", "101" a "110".
Protože x je rovno 1, cena každého čísla je počet jeho nastavených bitů.
Počet nastavených bitů v těchto číslech je 9. Takže součet cen prvních 6 čísel je 9.
Takže odpověď je 6.
Příklad 2:

Vstup: k = 7, x = 2
Výstup: 9
Vysvětlení: Protože x je rovno 2, měli bychom zkontrolovat pouze sudé bity.
Druhý bit binární reprezentace čísel 2 a 3 je nastavený bit. Takže součet jejich cen je 2.
Druhý bit binární reprezentace čísel 6 a 7 je nastavený bit. Takže součet jejich cen je 2.
Čtvrtý bit binární reprezentace čísel 8 a 9 je nastavený bit, ale jejich druhý bit není. Takže součet jejich cen je 2.
Čísla 1, 4 a 5 nemají nastavené bity ve svých sudých bitech v binární reprezentaci. Takže součet jejich cen je 0.
Do binární reprezentace čísla 10 jsou druhý a čtvrtý bit nastavený. Takže jeho cena je 2.
Součet cen prvních 9 čísel je 6.
Protože součet cen prvních 10 čísel je 8, odpověď je 9.

Omezení:

1 <= k <= 10^15
1 <= x <= 8

Dostanete celé číslo k a celé číslo x.
Uvažujme, že s je binární reprezentace 1-indexovaného celočíselného čísla. Cena čísla je počet i takových, že i % x == 0 a s[i] je nastavený bit.
Vrátí největší celé číslo takové, že součet cen všech čísel od 1 do num je menší nebo roven k.
Poznámka:

V binární reprezentaci čísla je množinový bit bit o hodnotě 1.
Binární reprezentace čísla bude indexována zprava doleva. Například, pokud s == 11100, s[4] == 1 a s[2] == 0.

Příklad 1:

Vstup: k = 9, x = 1
Výstup: 6
Vysvětlení: Čísla 1, 2, 3, 4, 5 a 6 lze zapsat v binární reprezentaci jako "1", "10", "11", "100", "101" a "110".
Protože x se rovná 1, cena každého čísla je počet jeho množinových bitů.
Počet nastavených bitů v těchto číslech je 9. Takže součet cen prvních 6 čísel je 9.
Odpověď je tedy 6.
Příklad 2:

Vstup: k = 7, x = 2
Výstup: 9
Vysvětlení: Protože x se rovná 2, měli bychom zkontrolovat sudé bity.
Druhý bit binární reprezentace čísel 2 a 3 je nastavený bit. Součet jejich cen je tedy 2.
Druhý bit binární reprezentace čísel 6 a 7 je set bit. Součet jejich cen je tedy 2.
Čtvrtý bit binární reprezentace čísel 8 a 9 je nastavený bit, ale jejich druhý bit není. Součet jejich cen je tedy 2.
Čísla 1, 4 a 5 nemají množinové bity ve svých sudých^-tých bitech ve své binární reprezentaci. Takže součet jejich cen je 0.
Druhý a čtvrtý bit binární reprezentace čísla 10 jsou množinovým bitem. Jeho cena je tedy 2.
Součet cen prvních 9 čísel je 6.
Protože součet cen prvních 10 čísel je 8, výsledek je 9.

Omezení:

1 <= k <= 10^15
1 <= x <= 8

Dostanete celé číslo k a celé číslo x.
Uvažujme s je 1-indexovaná binární reprezentace celého čísla. Cena čísla num je počet i takový, že i % x == 0 a s[i] je nastavený bit.
Vraťte největší celé číslo takové, že součet cen všech čísel od 1 do num je menší nebo roven k.
Poznámka:

V binární reprezentaci bitu sady čísel je bit s hodnotou 1.
Binární reprezentace čísla bude indexována zprava doleva. Pokud například s == 11100, s[4] == 1 a s[2] == 0.

Příklad 1:

Vstup: k = 9, x = 1
Výstup: 6
Vysvětlení: Čísla 1, 2, 3, 4, 5 a 6 lze zapsat v binárním vyjádření jako "1", "10", "11", "100", "101" a "110".
Protože x se rovná 1, cena každého čísla je počet jeho nastavených bitů.
Počet nastavených bitů v těchto číslech je 9. Takže součet cen prvních 6 čísel je 9.
Takže odpověď je 6.
Příklad 2:

Vstup: k = 7, x = 2
Výstup: 9
Vysvětlení: Protože x se rovná 2, měli bychom zkontrolovat sudé^té bity.
Druhý bit binární reprezentace čísel 2 a 3 je nastavený bit. Takže součet jejich cen je 2.
Druhý bit binární reprezentace čísel 6 a 7 je nastavený bit. Takže součet jejich cen je 2.
Čtvrtý bit binární reprezentace čísel 8 a 9 je nastavený bit, ale jejich druhý bit nikoli. Takže součet jejich cen je 2.
Čísla 1, 4 a 5 nemají ve své binární reprezentaci nastavené bity v sudých^-tých bitech. Takže součet jejich cen je 0.
Druhý a čtvrtý bit binární reprezentace čísla 10 jsou nastavený bit. Jeho cena je tedy 2.
Součet cen prvních 9 čísel je 6.
Protože součet cen prvních 10 čísel je 8, odpověď je 9.

Omezení:

1 <= k <= 10^15
1 <= x <= 8


Je zadáno pole nums složené z celých kladných čísel.
Vraťte celkové četnosti prvků v poli nums tak, aby všechny tyto prvky měly maximální četnost.
Frekvence prvku je počet výskytů tohoto prvku v poli.

Příklad 1:

Vstup: nums = [1,2,2,3,1,4]
Výstup: 4
Vysvětlení: Prvky 1 a 2 mají frekvenci 2, což je maximální frekvence v poli.
Počet prvků v poli s maximální frekvencí je tedy 4.

Příklad 2:

Vstup: nums = [1,2,3,4,5]
Výstup: 5
Vysvětlení: Všechny prvky pole mají frekvenci 1, což je maximum.
Počet prvků v poli s maximální frekvencí je tedy 5.

Omezení:

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

Máte pole nums, které se skládá z kladných celých čísel.
Vraťte celkovou frekvenci prvků v nums, pro které mají tyto prvky maximální frekvenci.
Frekvence prvku je počet výskytů tohoto prvku v poli.

Příklad 1:

Vstup: nums = [1,2,2,3,1,4]
Výstup: 4
Vysvětlení: Prvky 1 a 2 mají frekvenci 2, což je maximální frekvence v poli.
Takže počet prvků v poli s maximální frekvencí je 4.

Příklad 2:

Vstup: nums = [1,2,3,4,5]
Výstup: 5
Vysvětlení: Všechny prvky pole mají frekvenci 1, což je maximum.
Takže počet prvků v poli s maximální frekvencí je 5.

Omezení:

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

Dostanete pole nums skládající se z kladných celých čísel.
Vraťte celkové frekvence prvků v počtech tak, aby všechny tyto prvky měly maximální frekvenci.
Frekvence prvku je počet výskytů tohoto prvku v poli.

Příklad 1:

Vstup: nums = [1,2,2,3,1,4]
Výstup: 4
Vysvětlení: Prvky 1 a 2 mají frekvenci 2, což je maximální frekvence v poli.
Takže počet prvků v poli s maximální frekvencí je 4.

Příklad 2:

Vstup: nums = [1,2,3,4,5]
Výstup: 5
Vysvětlení: Všechny prvky pole mají frekvenci 1, což je maximum.
Takže počet prvků v poli s maximální frekvencí je 5.

Omezení:

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


Jsou zadána tři celá čísla start, finish a limit. Dále je zadán řetězec s indexem 0, který představuje kladné celé číslo.
Kladné celé číslo x se nazývá silné, jestliže končí řetězcem s (jinými slovy, s je přípona x) a každá číslice v x je nejvýše limitní.
Vraťte celkový počet silných celých čísel v rozsahu [start..finish].
Řetězec x je příponou řetězce y tehdy a jen tehdy, když x je podřetězec y, který začíná od nějakého indexu (včetně 0) v y a sahá až k indexu y.length - 1. Například 25 je příponou řetězce 5125, zatímco 512 není.

Příklad 1:

Vstup: start = 1, finish = 6000, limit = 4, s = „124“
Výstup: 5
Vysvětlení: Výkonná celá čísla v rozsahu [1..6000] jsou 124, 1124, 2124, 3124 a 4124. Všechna tato celá čísla mají každou číslici <= 4 a „124“ jako příponu. Všimněte si, že 5124 není silné celé číslo, protože první číslice je 5, což je větší než 4.
Lze ukázat, že v tomto rozsahu je pouze 5 silných celých čísel.

Příklad 2:

Vstup: start = 15, finish = 215, limit = 6, s = „10“.
Výstup: 2
Vysvětlení: Silná celá čísla v rozsahu [15..215] jsou 110 a 210. Všechna tato celá čísla mají každou číslici <= 6 a jako příponu „10“.
Lze ukázat, že v tomto rozsahu jsou pouze 2 silná celá čísla.

Příklad 3:

Vstup: start = 1000, finish = 2000, limit = 4, s = „3000“.
Výstup: 0
Vysvětlení: Všechna celá čísla v rozsahu [1000..2000] jsou menší než 3000, proto „3000“ nemůže být přípona žádného celého čísla v tomto rozsahu.

Omezení:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s se skládá pouze z číslic, které jsou nejvýše limit.
s nemá počáteční nuly.

Jsou zadána tři celá čísla start, finish a limit. Dále je zadán řetězec s indexem 0, který představuje kladné celé číslo.
Kladné celé číslo x se nazývá silné, pokud končí řetězcem s (jinými slovy, s je přípona x) a každá číslice v x je nejvýše limitní.
Vraťte celkový počet silných celých čísel v rozsahu [start..finish].
Řetězec x je příponou řetězce y tehdy a jen tehdy, když x je podřetězec y, který začíná od nějakého indexu (včetně 0) v y a sahá až k indexu y.length - 1. Například 25 je příponou řetězce 5125, zatímco 512 není.

Příklad 1:

Vstup: start = 1, finish = 6000, limit = 4, s = "124"
Výstup: 5
Vysvětlení: Výkonná celá čísla v rozsahu [1..6000] jsou 124, 1124, 2124, 3124 a 4124. Všechna tato celá čísla mají každou číslici <= 4 a „124“ jako příponu. Všimněte si, že 5124 není silné celé číslo, protože první číslice je 5, což je větší než 4.
Lze ukázat, že v tomto rozsahu je pouze 5 silných celých čísel.

Příklad 2:

Vstup: start = 15, finish = 215, limit = 6, s =  "10"
Výstup: 2
Vysvětlení: Výkonná celá čísla v rozsahu [15..215] jsou 110 a 210. Všechna tato celá čísla mají každou číslici <= 6 a jako příponu „10“.
Lze ukázat, že v tomto rozsahu jsou pouze 2 silná celá čísla.

Příklad 3:

Vstup: start = 1000, finish = 2000, limit = 4, s ="3000"
Výstup: 0
Vysvětlení: Všechna celá čísla v rozsahu [1000..2000] jsou menší než 3000, proto „3000“ nemůže být přípona žádného celého čísla v tomto rozsahu.

Omezení:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s se skládá pouze z číslic, které jsou nejvýše limit.
s nemá počáteční nuly.

Máte dány tři celá čísla start, finish a limit. Máte také dáno 0-indexovaný řetězec s představující kladné celé číslo.
Kladné celé číslo x je nazýváno mocné, pokud končí s s (jinými slovy, s je sufixem x) a každá číslice v x je nejvýše limit.
Vraťte celkový počet mocných čísel v rozsahu [start..finish].
Řetězec x je sufixem řetězce y, právě když x je podřetězcem y, který začíná na nějakém indexu (včetně 0) v y a pokračuje až do indexu y.length - 1. Například, 25 je sufixem 5125, zatímco 512 není.

Příklad 1:

Vstup: start = 1, finish = 6000, limit = 4, s = "124"
Výstup: 5
Vysvětlení: Mocná čísla v rozsahu [1..6000] jsou 124, 1124, 2124, 3124 a 4124. Všechna tato čísla mají každou číslici <= 4 a "124" jako sufix. Všimněte si, že 5124 není mocné číslo, protože první číslice je 5, což je více než 4.
Lze ukázat, že v tomto rozsahu jsou pouze 5 mocných čísel.

Příklad 2:

Vstup: start = 15, finish = 215, limit = 6, s = "10"
Výstup: 2
Vysvětlení: Mocná čísla v rozsahu [15..215] jsou 110 a 210. Všechna tato čísla mají každou číslici <= 6 a "10" jako sufix.
Lze ukázat, že v tomto rozsahu jsou pouze 2 mocná čísla.

Příklad 3:

Vstup: start = 1000, finish = 2000, limit = 4, s = "3000"
Výstup: 0
Vysvětlení: Všechna čísla v rozsahu [1000..2000] jsou menší než 3000, tudíž "3000" nemůže být sufixem žádného čísla v tomto rozsahu.

Omezení:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s se skládá pouze z číslic, které jsou nejvýše limit.
s nemá úvodní nuly.


Dostanete 0-indexované celé pole nums obsahující kladná celá čísla.
Vaším úkolem je minimalizovat délku num provedením následujících operací libovolný počet opakování (včetně nuly):

Vyberte dva odlišné indexy i a j z nums, takže nums[i] > 0 a nums[j] > 0.
Vložte výsledek nums[i] % nums[j] na konec nums.
Odstraňte prvky u indexů i a j z nums.

Po provedení operace v libovolném počtu vraťte celé číslo označující minimální délku num.

Příklad 1:

Vstup: nums = [1,4,3,1]
Výstup: 1
Vysvětlení: Jedním ze způsobů, jak minimalizovat délku pole, je následující:
Operace 1: Vyberte indexy 2 a 1, vložte nums[2] % nums[1] na konec a stane se [1,4,3,1,3], poté odstraňte prvky u indexů 2 a 1.
nums se změní na [1,1,3].
Operace 2: Vyberte indexy 1 a 2, vložte nums[1] % nums[2] na konec a stane se [1,1,3,1], poté odstraňte prvky u indexů 1 a 2.
nums se změní na [1,1].
Operace 3: Vyberte indexy 1 a 0, vložte nums[1] % nums[0] na konec a stane se [1,1,0], poté odstraňte prvky u indexů 1 a 0.
nums se změní na [0].
Délku čísel nelze dále zkracovat. Odpověď je tedy 1.
Lze ukázat, že 1 je minimální dosažitelná délka.
Příklad 2:

Vstup: nums = [5,5,5,10,5]
Výstup: 2
Vysvětlení: Jedním ze způsobů, jak minimalizovat délku pole, je následující:
Operace 1: Vyberte indexy 0 a 3, vložte nums[0] % nums[3] na konec a stane se [5,5,5,10,5,5], poté odstraňte prvky u indexů 0 a 3.
nums se stává [5,5,5,5].
Operace 2: Vyberte indexy 2 a 3, vložte nums[2] % nums[3] na konec a stane se [5,5,5,5,0], poté odstraňte prvky u indexů 2 a 3.
nums se změní na [5,5,0].
Operace 3: Vyberte indexy 0 a 1, vložte nums[0] % nums[1] na konec a stane se [5,5,0,0], poté odstraňte prvky u indexů 0 a 1.
num se změní na [0,0].
Délku čísel nelze dále zkracovat. Odpověď je tedy 2.
Lze ukázat, že 2 je minimální dosažitelná délka.
Příklad 3:

Vstup: nums = [2,3,4]
Výstup: 1
Vysvětlení: Jedním ze způsobů, jak minimalizovat délku pole, je následující:
Operace 1: Vyberte indexy 1 a 2, vložte nums[1] % nums[2] na konec a stane se [2,3,4,3], poté odstraňte prvky u indexů 1 a 2.
nums se stává [2,3].
Operace 2: Vyberte indexy 1 a 0, vložte nums[1] % nums[0] na konec a stane se [2,3,1], poté odstraňte prvky u indexů 1 a 0.
nums se změní na [1].
Délku čísel nelze dále zkracovat. Odpověď je tedy 1.
Lze ukázat, že 1 je minimální dosažitelná délka.

Omezení:

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

Dostanete celé pole nums indexované číslem 0 obsahujícím kladná celá čísla.
Vaším úkolem je minimalizovat délku nums provedením následujících operací libovolným počtem opakování (včetně nuly):

Vyberte dva různé indexy i a j z čísel, tak, že nums [i] > 0 a nums [j] > 0.
Vložte výsledek nums[i] % nums[j] na konec nums.
Odstraňte prvky v indexech i a j z nums.

Vrátí celé číslo označující minimální délku nums po provedení operace libovolného počtu opakování.

Příklad 1:

Vstup: nums = [1,4,3,1]
Výstup: 1
Vysvětlení: Jedním ze způsobů, jak minimalizovat délku pole, je následující:
Operace 1: Vyberte indexy 2 a 1, vložte nums[2] % nums[1] na konec a stane se z něj [1,4,3,1,3], poté odstraňte prvky na indexech 2 a 1.
z čísel se stane [1,1,3].
Operace 2: Vyberte indexy 1 a 2, vložte nums[1] % nums[2] na konec a stane se z něj [1,1,3,1], poté odstraňte prvky na indexech 1 a 2.
z čísla se stane [1,1].
Operace 3: Vyberte indexy 1 a 0, vložte nums[1] % nums[0] na konec a stane se z něj [1,1,0], poté odstraňte prvky na indexech 1 a 0.
z čísla se stane [0].
Délku čísel nelze dále zkrátit. Odpověď je tedy 1.
Lze ukázat, že 1 je minimální dosažitelná délka.
Příklad 2:

Vstup: nums = [5,5,5,10,5]
Výstup: 2
Vysvětlení: Jedním ze způsobů, jak minimalizovat délku pole, je následující:
Operace 1: Vyberte indexy 0 a 3, vložte nums[0] % nums[3] na konec a stane se z něj [5,5,5,10,5,5], poté odstraňte prvky na indexech 0 a 3.
Z čísla se stane [5,5,5,5].
Operace 2: Vyberte indexy 2 a 3, vložte nums[2] % nums[3] na konec a stane se z něj [5,5,5,5,0], poté odstraňte prvky na indexech 2 a 3.
z čísel se stane [5,5,0].
Operace 3: Vyberte indexy 0 a 1, vložte nums[0] % nums[1] na konec a stane se z něj [5,5,0,0], poté odstraňte prvky na indexech 0 a 1.
z nums se stane [0,0].
Délku čísel nelze dále zkrátit. Odpověď je tedy 2.
Lze ukázat, že 2 je minimální dosažitelná délka.
Příklad 3:

Vstup: nums = [2,3,4]
Výstup: 1
Vysvětlení: Jedním ze způsobů, jak minimalizovat délku pole, je následující:
Operace 1: Vyberte indexy 1 a 2, vložte nums[1] % nums[2] na konec a stane se z něj [2,3,4,3], poté odstraňte prvky na indexech 1 a 2.
z čísel se stane [2,3].
Operace 2: Vyberte indexy 1 a 0, vložte nums[1] % nums[0] na konec a stane se z něj [2,3,1], poté odstraňte prvky na indexech 1 a 0.
z čísel se stane [1].
Délku čísel nelze dále zkrátit. Odpověď je tedy 1.
Lze ukázat, že 1 je minimální dosažitelná délka.

Omezení:

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


Dostanete řetězec s indexem 0, řetězec a, řetězec b a celé číslo k.
Index i je krásný, pokud:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Existuje index j takový, že:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Vrátí pole, které obsahuje krásné indexy v seřazeném pořadí od nejmenšího po největší.

Příklad 1:

Vstup: s =  "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Výstup: [16,33]
Vysvětlení: Existují 2 krásné indexy: [16,33].
- Index 16 je krásný jako s[16..17] == "my" a existuje index 4 s s[4..11] == "squirrel" a |16 - 4| <= 15.
- Index 33 je krásný jako s[33..34] == "my" a existuje index 18 s s[18..25] == "squirrel" a |33 - 18| <= 15.
Vracíme se tedy [16,33] jako výsledek.

Příklad 2:

Vstup: s = "abcd", a = "a", b = "a", k = 4
Výstup: [0]
Vysvětlení: Existuje 1 krásný index: [0].
- Index 0 je krásný jako s[0..0] == "a" a existuje index 0 s s[0..0] == "a" a |0 - 0| <= 4.
Jako výsledek tedy vrátíme [0].

Omezení:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
Písmena s, a a b obsahují pouze malá anglická písmena.

Dostanete řetězec s indexovaný 0, řetězec a, řetězec b a celé číslo k.
Index i je krásný, pokud platí:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Existuje takový index j, že:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Vraťte pole, které obsahuje krásné indexy v seřazeném pořadí od nejmenšího po největší.

Příklad 1:

Vstup: s = "isawsquirrelnearmysquirrelhouseohmy", a = "moje", b = "veverka", k = 15
Výstup: [16,33]
Vysvětlení: Existují 2 krásné indexy: [16,33].
- Index 16 je krásný jako s[16..17] == "moje" a existuje index 4 s s[4..11] == "veverka" a |16 - 4| <= 15.
- Index 33 je krásný jako s[33..34] == "moje" a existuje index 18 s s[18..25] == "veverka" a |33 - 18| <= 15.
Vrátíme tedy [16,33] jako výsledek.

Příklad 2:

Vstup: s = "abcd", a = "a", b = "a", k = 4
Výstup: [0]
Vysvětlení: Existuje 1 krásný index: [0].
- Index 0 je krásný jako s[0..0] == "a" a existuje index 0 s s[0..0] == "a" a |0 - 0| <= 4.
Jako výsledek tedy vrátíme [0].

Omezení:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a a b obsahují pouze malá anglická písmena.

Dostanete řetězec indexovaný od 0, řetězec a, řetězec b a celé číslo k.
Index i je krásný, pokud:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Existuje takový index j, že:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

Vraťte pole, které obsahuje krásné indexy v seřazeném pořadí od nejmenšího po největší.

Příklad 1:

Vstup: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "veverka", k = 15
Výstup: [16,33]
Vysvětlení: Existují 2 krásné indexy: [16,33].
- Index 16 je krásný protože s[16..17] == "my" a existuje index 4 s s[4..11] == "veverka" a |16 - 4| <= 15.
- Index 33 je krásný protože s[33..34] == "my" a existuje index 18 s s[18..25] == "veverka" a |33 - 18| <= 15.
Vrátíme tedy [16,33] protože výsledek.

Příklad 2:

Vstup: s = "abcd", a = "a", b = "a", k = 4
Výstup: [0]
Vysvětlení: Existuje 1 krásný index: [0].
- Index 0 je krásný protože s[0..0] == "a" a existuje index 0 s s[0..0] == "a" a |0 - 0| <= 4.
protože výsledek tedy vrátíme [0].

Omezení:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a a b obsahují pouze malá anglická písmena.


Je vám dáno pole kladných celých čísel nums.
Musíte zjistit, zda je možné vybrat dva nebo více prvků v poli tak, aby bitwise OR vybraných prvků měl alespoň jednu koncovou nulu ve své binární reprezentaci.
Například binární reprezentace čísla 5, což je "101", nemá žádné koncové nuly, zatímco binární reprezentace čísla 4, což je "100", má dvě koncové nuly.
Vraťte true, pokud je možné vybrat dva nebo více prvků, jejichž bitwise OR má koncové nuly, jinak vraťte false.

Příklad 1:

Input: nums = [1,2,3,4,5]
Output: true
Vysvětlení: Pokud vybereme prvky 2 a 4, jejich bitwise OR je 6, což má binární reprezentaci "110" s jednou koncovou nulou.

Příklad 2:

Input: nums = [2,4,8,16]
Output: true
Vysvětlení: Pokud vybereme prvky 2 a 4, jejich bitwise OR je 6, což má binární reprezentaci "110" s jednou koncovou nulou.
Další možné způsoby výběru prvků, aby měly koncové nuly v binární reprezentaci jejich bitwise OR, jsou: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) a (2, 4, 8, 16).

Příklad 3:

Input: nums = [1,3,5,7,9]
Output: false
Vysvětlení: Neexistuje žádný možný způsob, jak vybrat dva nebo více prvků, aby měly koncové nuly v binární reprezentaci jejich bitwise OR.

Omezení:

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

Je vám dáno pole kladných celých čísel.
Musíte zkontrolovat, zda je možné vybrat dva nebo více prvků v poli tak, aby bitové OR vybraných prvků mělo ve své binární reprezentaci alespoň jednu koncovou nulu.
Například binární vyjádření čísla 5, které je "101", nemá žádné koncové nuly, zatímco binární vyjádření čísla 4, které je "100", má dvě koncové nuly.
Return true Pokud je možné vybrat dva nebo více prvků, jejichž bitový OR má koncové nuly, v opačném případě vraťte hodnotu false.

Příklad 1:

Vstup: nums = [1,2,3,4,5]
Výstup: true
Vysvětlení: Pokud vybereme prvky 2 a 4, jejich bitové OR je 6, což má binární reprezentaci "110" s jednou koncovou nulou.

Příklad 2:

Vstup: nums = [2,4,8,16]
Výstup: true
Vysvětlení: Pokud vybereme prvky 2 a 4, jejich bitové OR je 6, což má binární reprezentaci "110" s jednou koncovou nulou.
Další možné způsoby výběru prvků, které budou mít koncové nuly v binární reprezentaci jejich bitového operátoru OR, jsou: (2, 8), (2, 16), (4, 8), (4, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), (4, 8, 16) a (2, 4, 8, 16).

Příklad 3:

Vstup: nums = [1,3,5,7,9]
Výstup: false
Vysvětlení: Neexistuje žádný způsob, jak vybrat dva nebo více prvků, které budou mít koncové nuly v binární reprezentaci jejich bitového operátoru OR.

Omezení:

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

Dostanete pole kladných celých čísel.
Musíte zkontrolovat, zda je možné vybrat dva nebo více prvků v poli tak, aby bitový OR vybraných prvků měl ve své binární reprezentaci alespoň jednu koncovou nulu.
Například binární reprezentace 5, což je "101", nemá žádné koncové nuly, zatímco binární reprezentace 4, což je "100", má dvě koncové nuly.
Vraťte hodnotu true, pokud je možné vybrat dva nebo více prvků, jejichž bitový operátor OR má koncové nuly, v opačném případě vrátí hodnotu false.

Příklad 1:

Vstup: nums = [1,2,3,4,5]
Výstup: pravda
Vysvětlení: Pokud vybereme prvky 2 a 4, jejich bitový OR je 6, což má binární reprezentaci "110" s jednou koncovou nulou.

Příklad 2:

Vstup: nums = [2,4,8,16]
Výstup: pravda
Vysvětlení: Pokud vybereme prvky 2 a 4, jejich bitový OR je 6, což má binární reprezentaci "110" s jednou koncovou nulou.
Další možné způsoby, jak vybrat prvky tak, aby měly koncové nuly v binární reprezentaci jejich bitového OR, jsou: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) a (2, 4, 8, 16).

Příklad 3:

Vstup: nums = [1,3,5,7,9]
Výstup: nepravda
Vysvětlení: Neexistuje žádný možný způsob, jak vybrat dva nebo více prvků tak, aby měly koncové nuly v binární reprezentaci jejich bitového OR.

Omezení:

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


Máte dáno pole celých čísel `nums` s indexováním od nuly a kladné celé číslo `k`.
Na pole můžete aplikovat následující operaci libovolněkrát:

Vyberte libovolný prvek pole a invertujte bit v jeho binární reprezentaci. Invertování bitu znamená změnu 0 na 1 nebo naopak.

Vraťte minimální počet operací potřebných k tomu, aby bitový XOR všech prvků výsledného pole byl roven `k`.
Všimněte si, že můžete invertovat vedoucí nula bity v binární reprezentaci prvků. Například pro číslo (101)_2 můžete invertovat čtvrtý bit a získat (1101)_2.

Příklad 1:

Vstup: nums = [2,1,3,4], k = 1
Výstup: 2
Vysvětlení: Můžeme provést následující operace:
- Vybereme prvek 2 což je 3 == (011)_2, invertujeme první bit a dostaneme (010)_2 == 2. `nums` se změní na [2,1,2,4].
- Vybereme prvek 0 což je 2 == (010)_2, invertujeme třetí bit a dostaneme (110)_2 = 6. `nums` se změní na [6,1,2,4].
XOR prvků výsledného pole je (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Lze ukázat, že není možné dosáhnout XOR rovného `k` s méně než 2 operacemi.

Příklad 2:

Vstup: nums = [2,0,2,0], k = 0
Výstup: 0
Vysvětlení: XOR prvků pole je (2 XOR 0 XOR 2 XOR 0) == 0 == k. Takže není potřeba žádná operace.

Omezení:

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

Je zadáno pole celých čísel nums s indexem 0 a kladné celé číslo k.
Následující operaci můžete na pole aplikovat libovolný početkrát:

Zvolte libovolný prvek pole a převraťte bit v jeho binární reprezentaci. Převrácení bitu znamená změnu 0 na 1 nebo naopak.

Vraťte minimální počet operací potřebných k tomu, aby se bitový XOR všech prvků výsledného pole rovnal k.
Všimněte si, že v binární reprezentaci prvků můžete převracet bity s vedoucí nulou. Například pro číslo (101)_2 můžete převrátit čtvrtý bit a získat (1101)_2.

Příklad 1:

Vstup: nums = [2,1,3,4], k = 1
Výstup: 2
Vysvětlení: Můžeme provést následující operace:
- Zvolíme prvek 2, který je 3 == (011)_2, přehodíme první bit a dostaneme (010)_2 == 2. nums se stane [2,1,2,4].
- Zvolíme prvek 0, který je 2 == (010)_2, přehodíme třetí bit a dostaneme (110)_2 = 6. z nums se stane [6,1,2,4].
XOR prvků výsledného pole je (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Lze ukázat, že nemůžeme provést XOR rovný k za méně než 2 operace.

Příklad 2:

Vstup: nums = [2,0,2,0], k = 0
Výstup: 0
Vysvětlení: XOR prvků pole je (2 XOR 0 XOR 2 XOR 0) == 0 == k. Není tedy potřeba žádná operace.

Omezení:

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