Máte dané kladné celé číslo days, které představuje celkový počet dní, kdy je zaměstnanec k dispozici pro práci (počínaje dnem 1). Máte také poskytnuté 2D pole meetings o velikosti n, kde meetings[i] = [start_i, end_i] představuje počáteční a koncový den schůzky i (včetně).
Vrátí počet dní, kdy je zaměstnanec k dispozici pro práci, ale nejsou naplánovány žádné schůzky.
Poznámka: Schůzky se mohou překrývat.

Příklad 1:

Vstup: days = 10, meetings = [[5,7],[1,3],[9,10]]
Výstup: 2
Vysvětlení:
Žádná schůzka není naplánována na 4. a 8. den.

Příklad 2:

Vstup: days = 5, meetings = [[2,4],[1,3]]
Výstup: 1
Vysvětlení:
Žádná schůzka není naplánována na 5. den.

Příklad 3:

Vstup: days = 6, meetings = [[1,6]]
Výstup: 0
Vysvětlení:
Schůzky jsou naplánovány na všechny pracovní dny.

Omezení:

1 <= days <= 10^9
1 <= meetings.length <= 10^5
meetings[i].length == 2
1 <= meetings[i][0] <= meetings[i][1] <= days

Je zadáno kladné celé číslo dnů, které představuje celkový počet dnů, kdy je zaměstnanec k dispozici pro práci (počínaje dnem 1). Dále je dáno 2D pole meetings o velikosti n, kde meetings[i] = [start_i, end_i] představuje počáteční a koncový den schůzky i (včetně).
Vraťte počet dnů, kdy je zaměstnanec k dispozici pro práci, ale nejsou naplánovány žádné schůzky.
Poznámka: Schůzky se mohou překrývat.

Příklad 1:

Vstup: dny = 10, schůzky = [[5,7],[1,3],[9,10]].
Výstup: 2
Vysvětlení:
Na 4^. a 8^. den není naplánována žádná schůzka.

Příklad 2:

Vstup: dny = 5, schůzky = [[2,4],[1,3]].
Výstup: 1
Vysvětlení:
Na 5^. den není naplánována žádná schůzka.

Příklad 3:

Vstup: dny = 6, schůzky = [[1,6]].
Výstup: 0
Vysvětlení:
Schůzky jsou naplánovány na všechny pracovní dny.

Omezení:

1 <= dnů <= 10^9
1 <= meetings.length <= 10^5
meetings[i].length == 2
1 <= meetings[i][0] <= meetings[i][1] <= days

Je dáno kladné celé číslo dnů, které představuje celkový počet dnů, kdy je zaměstnanec k dispozici pro práci (počínaje dnem 1). Dále je dáno 2D pole meetings o velikosti n, kde meetings[i] = [start_i, end_i] představuje počáteční a koncový den schůzky i (včetně).
Vraťte počet dnů, kdy je zaměstnanec k dispozici pro práci, ale nejsou naplánovány žádné schůzky.
Poznámka: Schůzky se mohou překrývat.

Příklad 1:

Vstup: dny = 10, schůzky = [[5,7],[1,3],[9,10]].
Výstup: 2
Vysvětlení:
Na 4^. a 8^. den není naplánována žádná schůzka.

Příklad 2:

Vstup: dny = 5, schůzky = [[2,4],[1,3]].
Výstup: 1
Vysvětlení:
Na 5^. den není naplánována žádná schůzka.

Příklad 3:

Vstup: dny = 6, schůzky = [[1,6]].
Výstup: 0
Vysvětlení:
Schůzky jsou naplánovány na všechny pracovní dny.

Omezení:

1 <= dnů <= 10^9
1 <= meetings.length <= 10^5
meetings[i].length == 2
1 <= meetings[i][0] <= meetings[i][1] <= days


Máte pole nums a celé číslo k. Je třeba najít podpole z nums tak, aby absolutní rozdíl mezi k a bitovým OR prvků podpole byl co nejmenší. Jinými slovy, vyberte podpole nums[l..r], takže |k - (nums[l] OR nums[l + 1] ... OR nums[r])| je minimální.
Vraťte minimální možnou hodnotu absolutního rozdílu.
Podpole je souvislá neprázdná posloupnost prvků v rámci pole.

Příklad 1:

Vstup: nums = [1,2,4,5], k = 3
Výstup: 0
Vysvětlení:
Podpole nums[0..1] má OR hodnotu 3, což dává minimální absolutní rozdíl |3 - 3| = 0.

Příklad 2:

Vstup: nums = [1,3,1,3], k = 2
Výstup: 1
Vysvětlení:
Podpole nums[1..1] má OR hodnotu 3, což dává minimální absolutní rozdíl |3 - 2| = 1.

Příklad 3:

Vstup: nums = [1], k = 10
Výstup: 9
Vysvětlení:
Existuje jedno podpole s OR hodnotou 1, což dává minimální absolutní rozdíl |10 - 1| = 9.

Omezení:

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

Je dáno pole nums a celé číslo k. Je třeba najít takové podpole nums, aby absolutní rozdíl mezi k a NEBO prvků podpole byl co nejmenší. Jinými slovy, vyberte takové pole nums[l..r], aby |k - (nums[l] NEBO nums[l + 1] ... NEBO nums[r])| bylo minimální.
Vraťte minimální možnou hodnotu absolutního rozdílu.
Dílčí pole je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [1,2,4,5], k = 3
Výstup: 0
Vysvětlení:
podpole nums[0..1] má hodnotu OR 3, což dává minimální absolutní rozdíl |3 - 3| = 0.

Příklad 2:

Vstup: nums = [1,3,1,3], k = 2
Výstup: 1
Vysvětlení:
podpole nums[1..1] má hodnotu OR 3, což dává minimální absolutní rozdíl |3 - 2| = 1.

Příklad 3:

Vstup: nums = [1], k = 10
Výstup: 9
Vysvětlení:
Je zde jediné podpole s hodnotou OR 1, které dává minimální absolutní rozdíl |10 - 1| = 9.

Omezení:

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

Je dáno pole nums a celé číslo k. Je třeba najít takové podpole nums, aby absolutní rozdíl mezi k a bitovou OR prvků podpole byl co nejmenší. Jinými slovy, vyberte takové pole nums[l..r], aby |k - (nums[l] OR nums[l + 1] ... OR nums[r])| bylo minimální.
Vraťte minimální možnou hodnotu absolutního rozdílu.
Dílčí pole je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [1,2,4,5], k = 3
Výstup: 0
Vysvětlení:
Podpole nums[0..1] má hodnotu OR 3, která udává minimální absolutní rozdíl |3 - 3| = 0.
Příklad 2:

Vstup: nums = [1,3,1,3], k = 2
Výstup: 1
Vysvětlení:
Podpole nums[1..1] má hodnotu OR 3, která udává minimální absolutní rozdíl |3 - 2| = 1.

Příklad 3:

Vstup: nums = [1], k = 10
Výstup: 9
Vysvětlení:
Je zde jediné podřetězce s hodnotou OR 1, které dává minimální absolutní rozdíl |10 - 1| = 9.

Omezení:

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


Jsou vám dána dvě kladná celá čísla n a k. Ve frontě stojí n dětí očíslovaných od 0 do n - 1 v pořadí zleva doprava.
Zpočátku dítě 0 drží míč a směr předávání míče je směrem doprava. Po každé vteřině ho dítě držící míč předá dítěti vedle sebe. Jakmile míč dosáhne jednoho konce čáry, tj. dítě 0 nebo dítě n - 1, směr přihrávky se obrátí.
Vraťte číslo dítěte, které dostane míček po k sekundách.

Příklad 1:

Vstup: n = 3, k = 5
Výstup: 1
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Příklad 2:

Vstup: n = 5, k = 6
Výstup: 2
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Příklad 3:

Vstup: n = 4, k = 2
Výstup: 2
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Omezení:

2 <= n <= 50
1 <= k <= 50

Máte dvě kladná celá čísla n a k. Je n dětí očíslovaných od 0 do n - 1, které stojí v řadě od leva doprava.
Na začátku dítě 0 drží míč a směr jeho podávání je doprava. Po každé sekundě dítě s míčem ho předá dalšímu dítěti vedle něj. Jakmile míč dosáhne konce řady, tj. dítě 0 nebo dítě n - 1, směr podávání se obrací.
Vraťte číslo dítěte, které obdrží míč po k sekundách.

Příklad 1:

Vstup: n = 3, k = 5
Výstup: 1
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Příklad 2:

Vstup: n = 5, k = 6
Výstup: 2
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Příklad 3:

Vstup: n = 4, k = 2
Výstup: 2
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Omezení:

2 <= n <= 50
1 <= k <= 50

Jsou vám dána dvě kladná celá čísla n a k. Ve frontě stojí n dětí očíslovaných od 0 do n - 1 v pořadí zleva doprava.
Zpočátku dítě 0 drží míč a směr přihrání míče je správným směrem. Po každé vteřině ho dítě držící míč předá dítěti vedle sebe. Jakmile míč dosáhne jednoho konce čáry, tj. dítě 0 nebo dítě n - 1, směr přihrávky se obrátí.
Vraťte číslo dítěte, které dostane míček po k sekundách.

Příklad 1:

Vstup: n = 3, k = 5
Výstup: 1
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Příklad 2:

Vstup: n = 5, k = 6
Výstup: 2
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Příklad 3:

Vstup: n = 4, k = 2
Výstup: 2
Vysvětlení:

Čas uplynul
Děti

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Omezení:

2 <= n <= 50
1 <= k <= 50


Jsou vám dána dvě celá čísla n a k.
Zpočátku začnete s polem a o n celých číslech, kde a[i] = 1 pro všechna 0 <= i <= n - 1. Po každé sekundě současně aktualizujete každý prvek tak, aby byl součtem všech jeho předchozích prvků plus samotný prvek. Například po jedné sekundě zůstane a[0] stejné, a[1] se změní na a[0] + a[1], a[2] se změní na a[0] + a[1] + a[2], a tak dále.
Vraťte hodnotu a[n - 1] po k sekundách.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: n = 4, k = 5
Výstup: 56
Vysvětlení:

Druhý
Stav po

0
[1,1,1,1]

1
[1,2,3,4]

2
[1,3,6,10]

3
[1,4,10,20]

4
[1,5,15,35]

5
[1,6,21,56]

Příklad 2:

Vstup: n = 5, k = 3
Výstup: 35
Vysvětlení:

Druhý
Stav po

0
[1,1,1,1,1]

1
[1,2,3,4,5]

2
[1,3,6,10,15]

3
[1,4,10,20,35]

Omezení:

1 <= n, k <= 1000


Máte pole celých čísel rewardValues délky n, představující hodnoty odměn.
Na začátku je vaše celková odměna x rovna 0 a všechny indexy nejsou označeny. Je povoleno provádět následující operaci libovolně mnohokrát:

Vyberte neoznačený index i z rozmezí [0, n - 1].
Pokud rewardValues[i] je větší než vaše aktuální celková odměna x, pak přidejte rewardValues[i] k x (tj. x = x + rewardValues[i]), a označte index i.

Vraťte celé číslo vyjadřující maximální celkovou odměnu, kterou můžete získat optimálním prováděním operací.

Příklad 1:

Vstup: rewardValues = [1,1,3,3]
Výstup: 4
Vysvětlení:
Během operací můžeme zvolit označit indexy 0 a 2 v pořadí, a celková odměna bude 4, což je maximum.

Příklad 2:

Vstup: rewardValues = [1,6,4,3,2]
Výstup: 11
Vysvětlení:
Označte indexy 0, 2 a 1 v pořadí. Celková odměna pak bude 11, což je maximum.

Omezení:

1 <= rewardValues.length <= 2000
1 <= rewardValues[i] <= 2000

Dostanete celočíselné pole odměnyValues délky n, které představují hodnoty odměn.
Zpočátku je vaše celková odměna x 0 a všechny indexy jsou neoznačené. Následující operaci můžete provést libovolný počet opakování:

Vyberte neoznačený index i z rozsahu [0, n - 1].
Pokud je odměnaValues[i] větší než vaše aktuální celková odměna x, přidejte odměnuValues[i] k x (tj. x = x + odměnaValues[i]) a označte index i.

Vraťte celé číslo označující maximální celkovou odměnu, kterou můžete získat optimálním prováděním operací.

Příklad 1:

Vstup: odměnaValues = [1,1,3,3]
Výstup: 4
Vysvětlení:
Při operacích si můžeme zvolit označení indexů 0 a 2 v pořadí a celková odměna bude 4, což je maximum.

Příklad 2:

Vstup: odměnaValues = [1,6,4,3,2]
Výstup: 11
Vysvětlení:
Označte indexy 0, 2 a 1 v pořadí. Celková odměna pak bude 11, což je maximum.

Omezení:

1 <= odměnaValues.length <= 2000
1 <= odměnaValues[i] <= 2000


Dané celočíselné pole hodiny představující časy v hodinách vraťte celé číslo označující počet dvojic i, j, kde i < j a hodiny[i] + hodiny[j] tvoří celý den.
Úplný den je definován jako doba trvání, která je přesným násobkem 24 hodin.
Například 1 den je 24 hodin, 2 dny jsou 48 hodin, 3 dny jsou 72 hodin a tak dále.

Příklad 1:

Vstup: hodiny = [12,12,30,24,24]
Výstup: 2
Vysvětlení:
Dvojice indexů, které tvoří celý den, jsou (0, 1) a (3, 4).

Příklad 2:

Vstup: hodiny = [72,48,24,3]
Výstup: 3
Vysvětlení:
Dvojice indexů, které tvoří celý den, jsou (0, 1), (0, 2) a (1, 2).

Omezení:

1 <= hodin.length <= 100
1 <= hodin[i] <= 10^9

Máme-li celočíselné pole hodin reprezentující časy v hodinách, vrátíme celé číslo označující počet párů i, j kde i < j a hours[i] + hours[j] tvoří celý den.
Celý den je definován jako doba trvání, která je přesným násobkem 24 hodin.
Například 1 den je 24 hodin, 2 dny jsou 48 hodin, 3 dny jsou 72 hodin atd.

Příklad 1:

Vstup: hours = [12,12,30,24,24]
Výstup: 2
Vysvětlení:
Páry indexů, které tvoří celý den, jsou (0, 1) a (3, 4).

Příklad 2:

Vstup: hours = [72,48,24,3]
Výstup: 3
Vysvětlení:
Páry indexů, které tvoří celý den, jsou (0, 1), (0, 2) a (1, 2).

Omezení:

1 <= hodiny.length <= 100
1 <= hours[i] <= 10^9


Kouzelník má různé kouzla.
Je vám dáno pole power, kde každý prvek představuje poškození kouzla. Několik kouzel může mít stejnou hodnotu poškození.
Je známo, že pokud se kouzelník rozhodne seslat kouzlo s poškozením power[i], nemůže seslat žádné kouzlo s poškozením power[i] - 2, power[i] - 1, power[i] + 1 nebo power[i] + 2.
Každé kouzlo lze seslat pouze jednou.
Vraťte maximální možné celkové poškození, které může kouzelník způsobit.

Příklad 1:

Vstup: power = [1,1,3,4]
Výstup: 6
Vysvětlení:
Maximální možné poškození 6 je dosaženo sesláním kouzel 0, 1, 3 s poškozením 1, 1, 4.

Příklad 2:

Vstup: power = [7,1,6,6]
Výstup: 13
Vysvětlení:
Maximální možné poškození 13 je dosaženo sesláním kouzel 1, 2, 3 s poškozením 1, 6, 6.

Omezení:

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

Kouzelník má různá kouzla.
Dostanete pole síly, kde každý prvek představuje poškození kouzla. Více kouzel může mít stejnou hodnotu poškození.
Je známou skutečností, že pokud se kouzelník rozhodne seslat kouzlo se zraněním power[i], nemůže seslat žádné kouzlo se zraněním power[i] - 2, power[i] - 1, power[i] + 1 nebo síla[i] + 2.
Každé kouzlo lze seslat pouze jednou.
Vraťte maximální možné celkové poškození, které může kouzelník seslat.

Příklad 1:

Vstup: síla = [1,1,3,4]
Výstup: 6
Vysvětlení:
Maximální možné poškození 6 je způsobeno sesíláním kouzel 0, 1, 3 se poškozením 1, 1, 4.

Příklad 2:

Vstup: síla = [7,1,6,6]
Výstup: 13
Vysvětlení:
Maximální možné poškození 13 je způsobeno sesíláním kouzel 1, 2, 3 se poškozením 1, 6, 6.

Omezení:

1 <= síla.length <= 10^5
1 <= síla[i] <= 10^9

Kouzelník má různá kouzla.
Je vám dána síla pole, kde každý prvek představuje poškození kouzla. Více kouzel může mít stejnou hodnotu poškození.
Je známým faktem, že pokud se kouzelník rozhodne seslat kouzlo s poškozením power[i], nemůže seslat žádné kouzlo s poškozením power[i] - 2, power[i] - 1, power[i] + 1, nebo power[i] + 2.
Každé kouzlo může být sesláno pouze jednou.
Vrátí maximální možné celkové poškození, které může kouzelník seslat.

Příklad 1:

Vstup: power = [1,1,3,4]
Výstup: 6
Vysvětlení:
Maximální možné poškození 6 je způsobeno sesláním kouzel 0, 1, 3 s poškozením 1, 1, 4.

Příklad 2:

Vstup: power = [7,1,6,6]
Výstup: 13
Vysvětlení:
Maximální možné poškození 13 je způsobeno sesláním kouzel 1, 2, 3 s poškozením 1, 6, 6.

Omezení:

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


Vrchol v poli arr je prvek, který je větší než jeho předchozí a následující prvek v arr.
Dostanete celočíselné pole nums a 2D celočíselné pole dotazů.
Musíte zpracovat dotazy dvou typů:

dotazy[i] = [1, l_i, r_i], určují počet vrcholových prvků v podpole nums[l_i..r_i].
dotazy[i] = [2, index_i, val_i], změňte nums[index_i] na val_i.

Vrátí odpověď pole obsahující výsledky dotazů prvního typu v pořadí.
Poznámky:

První a poslední prvek pole nebo podpole nemůže být vrchol.

Příklad 1:

Vstup: nums = [3,1,4,2,5], dotazy = [[2,3,4],[1,0,4]]
Výstup: [0]
Vysvětlení:
První dotaz: Změníme nums[3] na 4 a nums se stane [3,1,4,4,5].
Druhý dotaz: Počet píků v [3,1,4,4,5] je 0.

Příklad 2:

Vstup: nums = [4,1,4,2,1,5], dotazy = [[2,2,4],[1,0,2],[1,0,4]]
Výstup: [0,1]
Vysvětlení:
První dotaz: nums[2] by se měl stát 4, ale už je nastaven na 4.
Druhý dotaz: Počet píků v [4,1,4] je 0.
Třetí dotaz: Druhá 4 je vrchol v [4,1,4,2,1].

Omezení:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= dotazy.length <= 10^5
dotazy[i][0] == 1 nebo dotazy[i][0] == 2
Za to všechno:

dotazy[i][0] == 1: 0 <= dotazy[i][1] <= dotazy[i][2] <= nums.length - 1
dotazy[i][0] == 2: 0 <= dotazy[i][1] <= nums.length - 1, 1 <= dotazy[i][2] <= 10^5

Vrchol v poli arr je prvek, který je větší než jeho předchozí a následující prvek v poli arr.
Je dáno celočíselné pole nums a celočíselné pole 2D queries.
Musíte zpracovat dotazy dvou typů:

Dotazy[i] = [1, l_i, r_i], určete počet prvků vrcholu v dílčím poli nums[l_i..r_i].
queries[i] = [2, index_i, val_i], změňte nums[index_i] na val_i.

Vrátí pole odpověď obsahující výsledky dotazů prvního typu v pořadí.
Poznámky:

První a poslední prvek pole nebo podoblasti nemůže být vrcholem.

Příklad 1:

Vstup: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]].
Výstup: [0]
Vysvětlení:
První dotaz: Změníme nums[3] na 4 a nums se stane [3,1,4,4,5].
Druhý dotaz: Počet vrcholů v [3,1,4,4,5] je 0.

Příklad 2:

Vstup: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]].
Výstup: [0,1]
Vysvětlení:
První dotaz: nums[2] by se mělo stát 4, ale je již nastaveno na 4.
Druhý dotaz: Počet vrcholů v [4,1,4] je 0.
Třetí dotaz: Druhý dotaz: 4 je vrchol v [4,1,4,2,1].

Omezení:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 or queries[i][0] == 2
Pro všechna i, která:

queries[i][0] == 1: 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

Vrchol v poli arr je prvek, který je větší než jeho předchozí a následující prvek v arr.
Dostanete celočíselné pole nums a 2D celočíselné pole dotazů.
Musíte zpracovat dotazy dvou typů:

dotazy[i] = [1, l_i, r_i], určují počet vrcholových prvků v podpole nums[l_i..r_i].
dotazy[i] = [2, index_i, val_i], změňte nums[index_i] na val_i.

Vrátí odpověď pole obsahující výsledky dotazů prvního typu v pořadí.
Poznámky:

První a poslední prvek pole nebo podpole nemůže být vrchol.

Příklad 1:

Vstup: nums = [3,1,4,2,5], dotazy = [[2,3,4],[1,0,4]]
Výstup: [0]
Vysvětlení:
První dotaz: Změníme nums[3] na 4 a nums se stane [3,1,4,4,5].
Druhý dotaz: Počet píků v [3,1,4,4,5] je 0.

Příklad 2:

Vstup: nums = [4,1,4,2,1,5], dotazy = [[2,2,4],[1,0,2],[1,0,4]]
Výstup: [0,1]
Vysvětlení:
První dotaz: nums[2] by měl být 4, ale už je nastaven na 4.
Druhý dotaz: Počet píků v [4,1,4] je 0.
Třetí dotaz: Druhá 4 je vrchol v [4,1,4,2,1].

Omezení:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= dotazy.length <= 10^5
dotazy[i][0] == 1 nebo dotazy[i][0] == 2
Za to všechno:

dotazy[i][0] == 1: 0 <= dotazy[i][1] <= dotazy[i][2] <= nums.length - 1
dotazy[i][0] == 2: 0 <= dotazy[i][1] <= nums.length - 1, 1 <= dotazy[i][2] <= 10^5


Máte pole čísel typu float nazvané `averages`, které je původně prázdné. Dále máte pole `nums` obsahující `n` celých čísel, kde `n` je sudé. Opakujte následující postup `n / 2` krát:

Odstraňte nejmenší prvek, `minElement`, a největší prvek, `maxElement`, z pole `nums`. Přidejte hodnotu `(minElement + maxElement) / 2` do pole `averages`.

Vraťte nejmenší prvek v poli `averages`.

Příklad 1:

Vstup: `nums = [7,8,3,4,15,13,4,1]`
Výstup: `5.5`
Vysvětlení:

| krok | nums | averages |
|------|------|----------|
| 0    | [7,8,3,4,15,13,4,1] | []       |
| 1    | [7,8,3,4,13,4]      | [8]      |
| 2    | [7,8,4,4]           | [8,8]    |
| 3    | [7,4]               | [8,8,6]  |
| 4    | []                  | [8,8,6,5.5] |

Nejmenší prvek pole `averages`, 5.5, je vrácen.

Příklad 2:

Vstup: `nums = [1,9,8,3,10,5]`
Výstup: `5.5`
Vysvětlení:

| krok | nums   | averages |
|------|--------|----------|
| 0    | [1,9,8,3,10,5] | []       |
| 1    | [9,8,3,5]      | [5.5]    |
| 2    | [8,5]           | [5.5,6]  |
| 3    | []              | [5.5,6,6.5] |

Příklad 3:

Vstup: `nums = [1,2,3,7,8,9]`
Výstup: `5.0`
Vysvětlení:

| krok | nums     | averages |
|------|----------|----------|
| 0    | [1,2,3,7,8,9] | []     |
| 1    | [2,3,7,8]   | [5]     |
| 2    | [3,7]       | [5,5]   |
| 3    | []          | [5,5,5] |

Máte pole průměrů čísel s plovoucí desetinnou čárkou, které je zpočátku prázdné. Máte k dispozici pole n celých čísel, kde n je sudé.
Následující postup opakujete n/2krát:

Odstraňte z nums nejmenší prvek minElement a největší prvek maxElement.
Přidejte (minElement + maxElement) / 2 k průměrům.

Vraťte minimální prvek v průměrech.

Příklad 1:

Vstup: nums = [7,8,3,4,15,13,4,1]
Výstup: 5.5
Vysvětlení:

krok
nums
průměry

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

Vrátí se nejmenší prvek průměrů, 5,5.
Příklad 2:

Vstup: nums = [1,9,8,3,10,5]
Výstup: 5.5
Vysvětlení:

krok
nums
průměry

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Příklad 3:

Vstup: nums = [1,2,3,7,8,9]
Výstup: 5.0
Vysvětlení:

krok
nums
průměry

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5,5]

3
[]
[5,5,5]

Omezení:

2 <= n == nums.length <= 50
n je sudé.
1 <= nums[i] <= 50

Máte pole průměrů čísel čísel s pohyblivou řádovou čárkou, které je zpočátku prázdné. Dostanete pole s počtem n celých čísel, kde n je sudé.
Následující postup opakujte n / 2 krát:

Odeberte nejmenší prvek minElement a největší prvek maxElement z nums.
Přidejte (minElement + maxElement) / 2 k průměrům.

Vraťte minimální prvek v průměrech.

Příklad 1:

Vstup: nums = [7,8,3,4,15,13,4,1]
Výstup: 5.5
Vysvětlení:

krok
nums
průměry

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

Vrátí se nejmenší prvek průměrů čísel, 5.5.
Příklad 2:

Vstup: nums = [1,9,8,3,10,5]
Výstup: 5.5
Vysvětlení:

krok
nums
průměry

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Příklad 3:

Vstup: nums = [1,2,3,7,8,9]
Výstup: 5.0
Vysvětlení:

krok
nums
průměry

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5.5]

3
[]
[5,5,5]

Omezení:

2 <= n ==  nums.length<= 50
n je sudé.
1 <= nums[i] <= 50


Máte dané 2D binární pole grid. Najděte obdélník s horizontálními a vertikálními stranami s nejmenší plochou, tak aby všechny jedničky v grid ležely uvnitř tohoto obdélníku. Vraťte nejmenší možnou plochu obdélníku.

Příklad 1:

Vstup: grid = [[0,1,0],[1,0,1]]
Výstup: 6
Vysvětlení:

Nejmenší obdélník má výšku 2 a šířku 3, takže jeho plocha je 2 * 3 = 6.

Příklad 2:

Vstup: grid = [[1,0],[0,0]]
Výstup: 1
Vysvětlení:

Nejmenší obdélník má výšku i šířku 1, takže jeho plocha je 1 * 1 = 1.

Omezení:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] je buď 0 nebo 1.
Vstup je generován tak, že v grid je alespoň jedna jednička.

Dostanete 2D binární mřížku pole. Najděte obdélník s vodorovnou a svislou stranou s nejmenší plochou tak, aby všechny jedničky v mřížce ležely uvnitř tohoto obdélníku.
Vraťte minimální možnou plochu obdélníku.

Příklad 1:

Vstup: mřížka = [[0,1,0],[1,0,1]]
Výstup: 6
Vysvětlení:

Nejmenší obdélník má výšku 2 a šířku 3, má tedy plochu 2 * 3 = 6.

Příklad 2:

Vstup: mřížka = [[1,0],[0,0]]
Výstup: 1
Vysvětlení:

Nejmenší obdélník má výšku i šířku 1, takže jeho plocha je 1 * 1 = 1.

Omezení:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] je buď 0 nebo 1.
Vstup je generován tak, že v mřížce je alespoň jedna 1.

Máte dané 2D binární pole grid. Najděte obdélník s horizontálními a vertikálními stranami s nejmenší plochou, tak aby všechny jedničky v grid ležely uvnitř tohoto obdélníku. Vraťte nejmenší možnou plochu obdélníku.

Příklad 1:

Vstup: grid = [[0,1,0],[1,0,1]]
Výstup: 6
Vysvětlení:

Nejmenší obdélník má výšku 2 a šířku 3, tak má plochu z 2 * 3 = 6.

Příklad 2:

Vstup: grid = [[1,0],[0,0]]
Výstup: 1
Vysvětlení:

Nejmenší obdélník má výšku i šířku 1, takže jeho plocha je 1 * 1 = 1.

Omezení:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] je buď 0 nebo 1.
Vstup je generován tak, že v grid je alespoň jedna jednička.


Mějme celočíselné pole nums s délkou n.
Náklady na podpole nums[l..r], kde 0 <= l <= r < n, jsou definovány jako:
cost(l, r) = nums[l] − nums[l + 1] + ... + nums[r] * (−1)^r − l
Vaším úkolem je rozdělit nums na podpoleh tak, aby byly celkové náklady na podpoleh maximalizovány, přičemž každý prvek musí patřit právě jednomu podpoli.
Formálně, pokud je nums rozděleno do k podpoleh, kde k > 1, na indexech i_1, i_2, ..., i_k − 1, kde 0 <= i_1 < i_2 < ... < i_k − 1 < n − 1, potom celkové náklady budou:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Vraťte celé číslo označující maximální celkové náklady na podpoleh po optimálním rozdělení pole.
Poznámka: Pokud nums není rozděleno na podpoleh, tj. k = 1, celkové náklady jsou jednoduše cost(0, n - 1).

Příklad 1:

Vstup: nums = [1,-2,3,4]
Výstup: 10
Vysvětlení:
Jedním ze způsobů, jak maximalizovat celkové náklady, je rozdělení [1, -2, 3, 4] na podpoleh [1, -2, 3] a [4]. Celkové náklady budou (1 + 2 + 3) + 4 = 10.

Příklad 2:

Vstup: nums = [1,-1,1,-1]
Výstup: 4
Vysvětlení:
Jedním ze způsobů, jak maximalizovat celkové náklady, je rozdělení [1, -1, 1, -1] na podpoleh [1, -1] a [1, -1]. Celkové náklady budou (1 + 1) + (1 + 1) = 4.

Příklad 3:

Vstup: nums = [0]
Výstup: 0
Vysvětlení:
Nemůžeme pole dále rozdělit, takže odpověď je 0.

Příklad 4:

Vstup: nums = [1,-1]
Výstup: 2
Vysvětlení:
Výběr celého pole poskytuje celkové náklady 1 + 1 = 2, což je maximum.

Omezení:

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

Dostanete celočíselné pole nums s délkou n.
Cena dílčího pole nums[l..r], kde 0 <= l <= r < n, je definována jako:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Vaším úkolem je rozdělit nums do podpolí tak, aby celkové náklady na podpole byly maximalizovány, a zajistit, aby každý prvek patřil přesně do jednoho podpole.
Formálně, pokud jsou čísla rozdělena do k podpolí, kde k > 1, u indexů i_1, i_2, ..., i_k − 1, kde 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, pak celkové náklady budou:
cena(0, i_1) + cena(i_1 + 1, i_2) + ... + cena(i_k − 1 + 1, n − 1)
Vrátí celé číslo označující maximální celkové náklady na podpole po optimálním rozdělení pole.
Poznámka: Pokud nums nejsou rozděleny do podpolí, tj. k = 1, celkové náklady jsou jednoduše náklady (0, n - 1).

Příklad 1:

Vstup: nums = [1,-2,3,4]
Výstup: 10
Vysvětlení:
Jedním ze způsobů, jak maximalizovat celkové náklady, je rozdělení [1, -2, 3, 4] do dílčích polí [1, -2, 3] a [4]. Celková cena bude (1 + 2 + 3) + 4 = 10.

Příklad 2:

Vstup: nums = [1,-1,1,-1]
Výstup: 4
Vysvětlení:
Jedním ze způsobů, jak maximalizovat celkové náklady, je rozdělení [1, -1, 1, -1] do dílčích polí [1, -1] a [1, -1]. Celková cena bude (1 + 1) + (1 + 1) = 4.

Příklad 3:

Vstup: nums = [0]
Výstup: 0
Vysvětlení:
Pole nemůžeme dále rozdělit, takže odpověď je 0.

Příklad 4:

Vstup: nums = [1,-1]
Výstup: 2
Vysvětlení:
Výběr celého pole dává celkové náklady 1 + 1 = 2, což je maximum.

Omezení:

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

Je zadáno celočíselné pole nums o délce n.
Cena dílčího pole nums[l..r], kde 0 <= l <= r < n, je definována jako:
náklady(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (-1)^r - l
Vaším úkolem je rozdělit nums do podmnožin tak, aby celkové náklady těchto podmnožin byly maximální, přičemž každý prvek patří přesně do jedné podmnožiny.
Formálně vzato, pokud je nums rozděleno na k podpolí, kde k > 1, na indexech i_1, i_2, ..., i_k - 1, kde 0 <= i_1 < i_2 < .... < i_k - 1 < n - 1, pak celkové náklady budou:
náklady(0, i_1) + náklady(i_1 + 1, i_2) + ... + cost(i_k - 1 + 1, n - 1)
Vrátí celé číslo označující maximální celkové náklady na dílčí pole po optimálním rozdělení pole.
Poznámka: Pokud nums není rozděleno na dílčí pole, tj. k = 1, jsou celkové náklady jednoduše cost(0, n - 1).

Příklad 1:

Vstup: nums = [1,-2,3,4]
Výstup: 10
Vysvětlení:
Jedním ze způsobů, jak maximalizovat celkové náklady, je rozdělit [1, -2, 3, 4] na dílčí pole [1, -2, 3] a [4]. Celkové náklady budou (1 + 2 + 3) + 4 = 10.

Příklad 2:

Vstup: nums = [1,-1,1,-1]
Výstup: 4
Vysvětlení:
Jedním ze způsobů, jak maximalizovat celkové náklady, je rozdělit [1,-1,1,-1] na dílčí pole [1,-1] a [1,-1]. Celkové náklady budou (1 + 1) + (1 + 1) = 4.

Příklad 3:

Vstup: nums = [0]
Výstup: 0
Vysvětlení:
Odpověď: Pole nemůžeme dále rozdělit, takže odpověď je 0.

Příklad 4:

Vstup: nums = [1,-1]
Výstup: 2
Vysvětlení:
Výběr celého pole dává celkové náklady 1 + 1 = 2, což je maximum.

Omezení:

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


Máte dána dvě celá čísla, red a blue, která představují počet červených a modrých kuliček. Musíte tyto kuličky uspořádat tak, aby vytvořily trojúhelník, kde 1. řada bude mít 1 kuličku, 2. řada bude mít 2 kuličky, 3. řada bude mít 3 kuličky, a tak dále.
Všechny kuličky v jedné řadě by měly mít stejnou barvu a sousední řady by měly mít různé barvy.
Vrátit maximální výšku trojúhelníku, které lze dosáhnout.

Příklad 1:

Vstup: red = 2, blue = 4
Výstup: 3
Vysvětlení:

Jediné možné uspořádání je zobrazené výše.

Příklad 2:

Vstup: red = 2, blue = 1
Výstup: 2
Vysvětlení:

Jediné možné uspořádání je zobrazené výše.

Příklad 3:

Vstup: red = 1, blue = 1
Výstup: 1

Příklad 4:

Vstup: red = 10, blue = 1
Výstup: 2
Vysvětlení:

Jediné možné uspořádání je zobrazené výše.

Omezení:

1 <= red, blue <= 100

Dostanete dvě celá čísla, červenou a modrou, představující počet červených a modrých kuliček. Tyto koule musíte uspořádat tak, aby tvořily trojúhelník tak, aby 1^. řada měla 1 míč, 2^. řada měla 2 míče, 3^. řada měla 3 míče a tak dále.
Všechny koule v určitém řádku by měly mít stejnou barvu a sousední řádky by měly mít různé barvy.
Vrátí maximální možnou výšku trojúhelníku.

Příklad 1:

Vstup: red = 2, blue = 4
Výstup: 3
Vysvětlení:

Jediné možné uspořádání je uvedeno výše.

Příklad 2:

Vstup: red = 2, blue = 1
Výstup: 2
Vysvětlení:

Jediné možné uspořádání je uvedeno výše.

Příklad 3:

Vstup: red = 1, blue = 1
Výstup: 1

Příklad 4:

Vstup: red = 10, blue = 1
Výstup: 2
Vysvětlení:

Jediné možné uspořádání je uvedeno výše.

Omezení:

1 <= red, blue <= 100

Dostanete dvě celá čísla červená a modrá představující počet červených a modrých kuliček. Tyto koule musíte uspořádat tak, aby tvořily trojúhelník tak, že 1^ řada bude mít 1 kouli, 2^ řada bude mít 2 koule, 3^ řada bude mít 3 koule a tak dále.
Všechny koule v určité řadě by měly mít stejnou barvu a sousední řady by měly mít různé barvy.
Vraťte maximální výšku trojúhelníku, které lze dosáhnout.

Příklad 1:

Vstup: červená = 2, modrá = 4
Výstup: 3
Vysvětlení:

Jediné možné uspořádání je uvedeno výše.

Příklad 2:

Vstup: červená = 2, modrá = 1
Výstup: 2
Vysvětlení:

Jediné možné uspořádání je uvedeno výše.

Příklad 3:

Vstup: červená = 1, modrá = 1
Výstup: 1

Příklad 4:

Vstup: červená = 10, modrá = 1
Výstup: 2
Vysvětlení:

Jediné možné uspořádání je uvedeno výše.

Omezení:

1 <= red, blue <= 100


Dostanete celočíselné pole nums.
Dílčí posloupnost čísel s délkou x se nazývá platná, pokud splňuje:

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

Vrátí délku nejdelší platné dílčí posloupnosti čísel.
Podsekvence je pole, které lze odvodit z jiného pole odstraněním některých nebo žádných prvků, aniž by se změnilo pořadí zbývajících prvků.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 4
Vysvětlení:
Nejdelší platná podsekvence je [1, 2, 3, 4].

Příklad 2:

Vstup: nums = [1,2,1,1,2,1,2]
Výstup: 6
Vysvětlení:
Nejdelší platná podsekvence je [1, 2, 1, 2, 1, 2].

Příklad 3:

Vstup: nums = [1,3]
Výstup: 2
Vysvětlení:
Nejdelší platná podsekvence je [1, 3].

Omezení:

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


Existují dva neorientované stromy s n a m uzly očíslovanými od 0 do n - 1, resp. od 0 do m - 1. Jsou dána dvě dvourozměrná celočíselná pole edges1 a edges2 o délkách n - 1, resp. m - 1, kde edges1[i] = [a_i, b_i] označuje, že v prvním stromu existuje hrana mezi uzly a_i a b_i, a edges2[i] = [u_i, v_i] označuje, že v druhém stromu existuje hrana mezi uzly u_i a v_i.
Jeden uzel z prvního stromu musíte spojit s jiným uzlem z druhého stromu hranou.
Vraťte minimální možný průměr výsledného stromu.
Průměr stromu je délka nejdelší cesty mezi libovolnými dvěma uzly stromu.

Příklad 1:

Vstup: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Výstup: 3
Vysvětlení:
Strom o průměru 3 získáme spojením uzlu 0 z prvního stromu s libovolným uzlem z druhého stromu.

Příklad 2:

Vstup: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Výstup: 5
Vysvětlení:
Strom o průměru 5 získáme spojením uzlu 0 z prvního stromu s uzlem 0 z druhého stromu.

Omezení:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Vstup je generován tak, že hrany1 a hrany2 představují platné stromy.

Existují dva neorientované stromy s n a m uzly, očíslované od 0 do n - 1 a od 0 do m - 1. Jsou vám dány dvě 2D celočíselné pole edges1 a edges2 o délkách n - 1 a m - 1, kde edges1[i] = [a_i, b_i] označuje, že existuje hrana mezi uzly a_i a b_i v prvním stromu a edges2[i] = [u_i, v_i] označuje, že existuje hrana mezi uzly u_i a v_i v druhém stromu. Musíte propojit jeden uzel z prvního stromu s dalším uzlem z druhého stromu hranou. Vraťte minimální možný průměr výsledného stromu. Průměr stromu je délka nejdelší cesty mezi dvěma uzly ve stromu.

Příklad 1:

Vstup: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Výstup: 3
Vysvětlení:
Můžeme získat strom s průměrem 3 propojením uzlu 0 z prvního stromu s libovolným uzlem z druhého stromu.

Příklad 2:

Vstup: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Výstup: 5
Vysvětlení:
Můžeme získat strom s průměrem 5 propojením uzlu 0 z prvního stromu s uzlem 0 z druhého stromu.

Omezení:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Vstup je generován tak, že edges1 a edges2 představují platné stromy.

Existují dva neorientované stromy s n a m uzly, číslované od 0 do n - 1 a od 0 do m - 1, v tomto pořadí. Jsou vám dána dvě 2D celočíselná pole hrany1 a hrany2 o délkách n - 1 a m - 1, v tomto pořadí, kde edges1[i] = [a_i, b_i] značí, že mezi uzly a_i a b_i v prvním stromu a edges2[i] = [u_i, v_i] označuje, že mezi uzly u_i a v_i ve druhém stromu existuje hrana.
Jeden uzel z prvního stromu musíte spojit hranou s dalším uzlem z druhého stromu.
Vraťte minimální možný průměr výsledného stromu.
Průměr stromu je délka nejdelší cesty mezi libovolnými dvěma uzly ve stromu.

Příklad 1:

Vstup: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Výstup: 3
Vysvětlení:
Strom o průměru 3 získáme spojením uzlu 0 z prvního stromu s libovolným uzlem z druhého stromu.

Příklad 2:

Zadání: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Výstup: 5
Vysvětlení:
Strom o průměru 5 získáme spojením uzlu 0 z prvního stromu s uzlem 0 z druhého stromu.

Omezení:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Vstup je generován tak, že hrany1 a hrany2 představují platné stromy.


Je dán řetězec s a celé číslo k. Zašifrujte řetězec pomocí následujícího algoritmu:

Pro každý znak c v s nahraďte c k^tým znakem po c v řetězci (cyklickým způsobem).

Vrátí zašifrovaný řetězec.

Příklad 1:

Vstup: s = "dart", k = 3
Výstup: "tdar"
Vysvětlení:

Pro i = 0, 3^tí znak po 'd' je 't'.
Pro i = 1, 3^tí znak po 'a' je 'd'.
Pro i = 2, 3^tí znak po 'r' je 'a'.
Pro i = 3, 3^tí znak po 't' je 'r'.

Příklad 2:

Vstup: s = "aaa", k = 1
Výstup: "aaa"
Vysvětlení:
Jelikož jsou všechny znaky stejné, zašifrovaný řetězec bude také stejný.

Omezení:

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

Je zadán řetězec s a celé číslo k. Řetězec zašifrujte pomocí následujícího algoritmu:

Pro každý znak c v řetězci s nahraďte c k^th znakem za c v řetězci (cyklicky).

Vraťte zašifrovaný řetězec.

Příklad 1:

Vstup: s = „dart“, k = 3
Výstup: „tdar“
Vysvětlení:

Pro i = 0 je 3^tý znak za „d“ „t“.
Pro i = 1 je 3^tý znak za „a“ „d“.
Pro i = 2 je 3^tý znak za „r“ „a“.
Pro i = 3 je 3^. znak za „t“ „r“.

Příklad 2:

Vstup: s = „aaa“, k = 1
Výstup: „aaa“
Vysvětlení:
Protože jsou všechny znaky stejné, bude stejný i zašifrovaný řetězec.

Omezení:

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

Dostanete řetězec s a celé číslo k. Zašifrujte řetězec pomocí následujícího algoritmu:

Pro každý znak c v s nahraďte c k^-tým znakem po c v řetězci (cyklickým způsobem).

Vraťte zašifrovaný řetězec.

Příklad 1:

Vstup: s = "dart", k = 3
Výstup: "tdar"
Vysvětlení:

Pro i = 0 je 3^ znak po 'd' 't'.
Pro i = 1 je 3^ znak po 'a' 'd'.
Pro i = 2 je 3^ znak po 'r' 'a'.
Pro i = 3 je 3^ znak po 't' 'r'.

Příklad 2:

Vstup: s = "aaa", k = 1
Výstup: "aaa"
Vysvětlení:
Protože jsou všechny znaky stejné, bude stejný i zašifrovaný řetězec.

Omezení:

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


Je dán kladný celočíselný n.
Binární řetězec x je platný, pokud všechny jeho podřetězce délky 2 obsahují alespoň jednu "1".
Vraťte všechny platné řetězce délky n v libovolném pořadí.

Příklad 1:

Vstup: n = 3
Výstup: ["010","011","101","110","111"]
Vysvětlení:
Platné řetězce délky 3 jsou: "010", "011", "101", "110" a "111".

Příklad 2:

Vstup: n = 1
Výstup: ["0","1"]
Vysvětlení:
Platné řetězce délky 1 jsou: "0" a "1".

Omezení:

1 <= n <= 18

Je zadáno celé kladné číslo n.
Binární řetězec x je platný, pokud všechny podřetězce x délky 2 obsahují alespoň jednu „1“.
Vraťte všechny platné řetězce délky n v libovolném pořadí.

Příklad 1:

Vstup: n = 3
Výstup: [„010“,„011“,„101“,„110“,„111“]
Vysvětlení:
Platné řetězce délky 3 jsou: „010“, ‚011‘, ‚101‘, ‚110‘ a ‚111‘.

Příklad 2:

Vstup: n = 1
Výstup: [„0“, „1“]
Vysvětlení:
Platné řetězce délky 1 jsou: „0“ a ‚1‘.

Omezení:

1 <= n <= 18


Je dána 2D matice znaků grid, kde grid[i][j] je buď 'X', 'Y' nebo '.', vraťte počet submaticí, které obsahují:

grid[0][0]
stejnou frekvenci 'X' a 'Y'.
alespoň jedno 'X'.

Příklad 1:

Vstup: grid = [["X","Y","."],["Y",".","."]]
Výstup: 3
Vysvětlení:

Příklad 2:

Vstup: grid = [["X","X"],["X","Y"]]
Výstup: 0
Vysvětlení:
Žádná submatice nemá stejnou frekvenci 'X' a 'Y'.

Příklad 3:

Vstup: grid = [[".","."],[".","."]]
Výstup: 0
Vysvětlení:
Žádná submatice nemá alespoň jedno 'X'.

Omezení:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] je buď 'X', 'Y' nebo '.'.

Při zadání 2D matice znaků, kde grid[i][j] je buď 'X', 'Y', nebo '.', vraťte počet dílčích matic, které obsahují:

mřížka[0][0]
stejnou četnost znaků „X“ a „Y“.
alespoň jedno „X“.

Příklad 1:

Vstup: grid = [[„X“, „Y“,„.“],[„Y“,„.“,„.“]]
Výstup: 3
Vysvětlení:

Příklad 2:

Vstup: grid = [[„X“, „X“],[„X“, „Y“]]
Výstup: 0
Vysvětlení:
Žádná dílčí matice nemá stejnou četnost „X“ a „Y“.

Příklad 3:

Vstup: grid = [[„.“,„.“],[„.“,„.“]]
Výstup: 0
Vysvětlení:
Žádná dílčí matice nemá alespoň jedno „X“.

Omezení:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] je buď „X“, „Y“, nebo „.“.

Při zadání 2D matice znaků, kde grid[i][j] je buď 'X', 'Y', nebo '.', vraťte počet dílčích matic, které obsahuje:

grid[0][0]
stejnou četnost znaků'X' a'Y'.
alespoň jedno 'X'.

Příklad 1:

Vstup: grid = [["X","Y","."],["Y",".","."]]
Výstup: 3
Vysvětlení:

Příklad 2:

Vstup: grid = [["X","X"],["X","Y"]]
Výstup: 0
Vysvětlení:
Žádná dílčí matice nemá stejnou četnost  'X' a'Y'.

Příklad 3:

Vstup: grid =  [[".","."],[".","."]]
Výstup: 0
Vysvětlení:
Žádná dílčí matice nemá alespoň jedno 'X'.

Omezení:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] je buď'X', 'Y', nebo '.'.


Je dána řetězec target, pole řetězců words a pole celých čísel costs, obě pole mají stejnou délku.
Představte si prázdný řetězec s.
Můžete provést následující operaci libovolný početkrát (včetně nuly):

Vyberte index i v rozmezí [0, words.length - 1].
Připojte words[i] k s.
Cena operace je costs[i].

Vraťte minimální cenu pro zajištění, aby se s rovnalo target. Pokud to není možné, vraťte -1.

Příklad 1:

Vstup: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Výstup: 7
Vysvětlení:
Minimální cena může být dosažena provedením následujících operací:

Zvolte index 1 a připojte "abc" k s za cenu 1, výsledkem je s = "abc".
Zvolte index 2 a připojte "d" k s za cenu 1, výsledkem je s = "abcd".
Zvolte index 4 a připojte "ef" k s za cenu 5, výsledkem je s = "abcdef".

Příklad 2:

Vstup: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Výstup: -1
Vysvětlení:
Není možné zajistit, aby se s rovnalo target, proto vracíme -1.

Omezení:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Celkový součet words[i].length je menší nebo roven 5 * 10^4.
target a words[i] obsahují pouze malá písmena anglické abecedy.
1 <= costs[i] <= 10^4

Je zadán cíl řetězce, pole řetězcových slov a pole celočíselných nákladů, přičemž obě pole mají stejnou délku.
Představte si prázdný řetězec s.
Následující operaci můžete provést libovolný početkrát (včetně nuly):

Zvolte index i v rozsahu [0, words.length - 1].
Přidejte slova[i] do s.
Cena operace je costs[i].

Vraťte minimální náklady, aby se s rovnalo cíli. Pokud to není možné, vraťte -1.

Příklad 1:

Vstup: target = „abcdef“, words = [„abdef“, „abc“, „d“, „def“, „ef“], costs = [100,1,1,10,5]
Výstup: 7
Vysvětlení:
Minimálních nákladů lze dosáhnout provedením následujících operací:

Vyberte index 1 a připojte „abc“ k s s náklady 1, čímž vznikne s = „abc“.
Vyberte index 2 a připojte „d“ k s s náklady 1, výsledkem je s = „abcd“.
Vyberte index 4 a připojte k s „ef“ za cenu 5, výsledkem bude s = „abcdef“.

Příklad 2:

Vstup: cíl = „aaaa“, slova = [„z“, „zz“, „zzz“], náklady = [1,10,100].
Výstup: -1
Vysvětlení:
Není možné, aby se s rovnalo cíli, proto vrátíme -1.

Omezení:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Celkový součet slov[i].length je menší nebo roven 5 * 10^4.
Cíl a slova[i] se skládají pouze z malých anglických písmen.
1 <= náklady[i] <= 10^4

Dostanete cílový řetězec, pole slov řetězců a cenu celočíselného pole, přičemž obě pole mají stejnou délku.
Představte si prázdný řetězec s.
Následující operaci můžete provést libovolný počet opakování (včetně nuly):

Vyberte index i v rozsahu [0, délka slov - 1].
Připojte slova[i] k s.
Náklady na provoz jsou náklady[i].

Vraťte minimální cenu, aby se s rovnalo cíli. Pokud to není možné, vraťte -1.

Příklad 1:

Vstup: target = "abcdef", slova = ["abdef","abc","d","def","ef"], náklady = [100,1,1,10,5]
Výstup: 7
Vysvětlení:
Minimální náklady lze dosáhnout provedením následujících operací:

Vyberte index 1 a připojte "abc" k s za cenu 1, výsledkem je s = "abc".
Vyberte index 2 a připojte "d" k s za cenu 1, výsledkem je s = "abcd".
Vyberte index 4 a připojte "ef" k s za cenu 5, výsledkem je s = "abcdef".

Příklad 2:

Vstup: cíl = "aaaa", slova = ["z","zz","zzz"], náklady = [1 10 100]
Výstup: -1
Vysvětlení:
Je nemožné, aby se s rovnalo cíli, takže vrátíme -1.

Omezení:

1 <= target.length <= 5 * 10^4
1 <= slova.length == náklady.length <= 5 * 10^4
1 <= slova[i].length <= cíl.length
Celkový součet slov[i].length je menší nebo roven 5 * 10^4.
target a slova[i] se skládají pouze z malých anglických písmen.
1 <= náklady[i] <= 10^4


Je-li řetězec s obsahující pouze číslice, vraťte lexikograficky nejmenší řetězec, který lze získat po záměně sousedních číslic v s nejvýše jednou se stejnou paritou.
Číslice mají stejnou paritu, pokud jsou obě liché nebo obě sudé. Například 5 a 9, stejně jako 2 a 4, mají stejnou paritu, zatímco 6 a 9 nikoli.

Příklad 1:

Vstup: s = "45320"
Výstup: "43520"
Vysvětlení:
s[1] == '5' a s[2] == '3' mají obě stejnou paritu a jejich záměnou vznikne lexikograficky nejmenší řetězec.

Příklad 2:

Vstup: s = "001"
Výstup: "001"
Vysvětlení:
Není třeba provádět swap, protože s je již lexikograficky nejmenší.

Omezení:

2 <= s.length <= 100
s se skládá pouze z číslic.

Je-li dán řetězec s obsahující pouze číslice, vrátí lexikograficky nejmenší řetězec, který lze získat po prohození sousedních číslic v s se stejnou paritou nejvýše jednou.
Číslice mají stejnou paritu, pokud jsou obě liché nebo obě sudé. Například 5 a 9, stejně jako 2 a 4, mají stejnou paritu, zatímco 6 a 9 ne.

Příklad 1:

Vstup: s = "45320"
Výstup: "43520"
Vysvětlení:
s[1] == '5' a s[2] == '3' mají stejnou paritu a jejich prohození má za následek lexikograficky nejmenší řetězec.

Příklad 2:

Vstup: s = "001"
Výstup: "001"
Vysvětlení:
Není třeba provádět prohození, protože s je již lexikograficky nejmenší.

Omezení:

2 <= s.length <= 100
s se skládá pouze z číslic.


Existuje dort m x n, který je třeba nakrájet na 1 x 1 kusy.
Jsou vám dána celá čísla m, n a dvě pole:

vodorovný řez o velikosti m - 1, kde vodorovný řez[i] představuje náklady na řezání podél vodorovné čáry i.
svislý řez o velikosti n - 1, kde svislý řez[j] představuje náklady na řezání podél svislé čáry j.

V jedné operaci si můžete vybrat jakýkoli kus dortu, který ještě není čtverec 1 x 1, a provést jeden z následujících řezů:

Řez podél vodorovné čáry i za cenu vodorovný řez[i].
Řez podél svislé čáry j za cenu vertikálního řezu[j].

Po rozkrojení se dort rozdělí na dva odlišné kusy.
Cena řezu závisí pouze na počáteční ceně linky a nemění se.
Vraťte minimální celkové náklady na nakrájení celého dortu na 1 x 1 díl.

Příklad 1:

Vstup: m = 3, n = 2, vodorovný řez = [1,3], svislý řez = [5]
Výstup: 13
Vysvětlení:

Proveďte řez na svislé čáře 0 s cenou 5, aktuální celková cena je 5.
Proveďte vodorovný řez 0 v dílčí mřížce 3 x 1 s cenou 1.
Proveďte vodorovný řez 0 v dílčí mřížce 3 x 1 s cenou 1.
Proveďte vodorovný řez 1 v dílčí mřížce 2 x 1 s cenou 3.
Proveďte vodorovný řez 1 v dílčí mřížce 2 x 1 s cenou 3.

Celková cena je 5 + 1 + 1 + 3 + 3 = 13.

Příklad 2:

Vstup: m = 2, n = 2, vodorovný řez = [7], svislý řez = [4]
Výstup: 15
Vysvětlení:

Proveďte řez na vodorovné čáře 0 s cenou 7.
Proveďte řez na svislé čáře 0 na dílčí mřížce 1 x 2 s cenou 4.
Proveďte řez na svislé čáře 0 na dílčí mřížce 1 x 2 s cenou 4.

Celková cena je 7 + 4 + 4 = 15.

Omezení:

1 <= m, n <= 20
vodorovná délka řezu == m - 1
vertikální délka řezu == n - 1
1 <= vodorovný řez[i], vertikální řez[i] <= 10^3

K dispozici je m x n dort, který je třeba rozkrájet na 1 x 1 kus.
Jsou vám dána celá čísla m, n a dvě pole:

horizontalCut o velikosti m - 1, kde horizontalCut[i] představuje náklady na řez podél vodorovné linie i.
verticalCut o velikosti n - 1, kde verticalCut [j] představuje náklady na řez podél svislé čáry j.

V jedné operaci si můžete vybrat libovolný kousek dortu, který ještě není čtverec 1 x 1, a provést jeden z následujících řezů:

Řez podél vodorovné čáry i za cenu příkazu horizontalCut[i].
Řez podél svislé čáry j za cenu příkazu verticalCut[j].

Po rozříznutí se kousek dortu rozdělí na dva odlišné kusy.
Náklady na řez závisí pouze na počátečních nákladech na linku a nemění se.
Vraťte minimální celkové náklady na rozřezání celého dortu na 1 x 1 kus.

Příklad 1:

Vstup: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Výstup: 13
Vysvětlení:

Proveďte řez na svislé přímce 0 s cenou 5, aktuální celková cena je 5.
Proveďte řez na vodorovné čáře 0 na podmřížce 3 x 1 s cenou 1.
Proveďte řez na vodorovné čáře 0 na podmřížce 3 x 1 s cenou 1.
Proveďte řez na vodorovné čáře 1 na podmřížce 2 x 1 s cenou 3.
Proveďte řez na vodorovné čáře 1 na podmřížce 2 x 1 s cenou 3.

Celkové náklady jsou 5 + 1 + 1 + 3 + 3 = 13.

Příklad 2:

Vstup: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Výstup: 15
Vysvětlení:

Proveďte řez na vodorovné přímce 0 s cenou 7.
Proveďte řez na svislé čáře 0 na podmřížce 1 x 2 s cenou 4.
Proveďte řez na svislé čáře 0 na podmřížce 1 x 2 s cenou 4.

Celkové náklady jsou 7 + 4 + 4 = 15.

Omezení:

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

K dispozici je m x n dort, který je třeba rozkrájet na 1 x 1 kus.
Jsou vám dána celá čísla m, n a dvě pole:

horizontalCut o velikosti m - 1, kde horizontalCut[i] představuje náklady na řez podél vodorovné linie i.
verticalCut o velikosti n - 1, kde verticalCut [j] představuje náklady na řez podél svislé čáry j.

V jedné operaci si můžete vybrat libovolný kousek dortu, který ještě není čtverec 1 x 1, a provést jeden z následujících řezů:

Řez podél vodorovné čáry i za cenu příkazu horizontalCut[i].
Řez podél svislé čáry j za cenu verticalCut[j].

Po rozříznutí se kousek dortu rozdělí na dva odlišné kusy.
Náklady na řez závisí pouze na počátečních nákladech na linku a nemění se.
Vraťte minimální celkové náklady na rozřezání celého dortu na 1 x 1 kus.

Příklad 1:

Vstup: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Výstup: 13

Vysvětlení:

Proveďte řez na svislé přímce 0 s cenou 5, aktuální celková cena je 5.
Proveďte řez na vodorovné čáře 0 na podmřížce 3 x 1 s cenou 1.
Proveďte řez na vodorovné čáře 0 na podmřížce 3 x 1 s cenou 1.
Proveďte řez na vodorovné čáře 1 na podmřížce 2 x 1 s cenou 3.
Proveďte řez na vodorovné čáře 1 na podmřížce 2 x 1 s cenou 3.

Celkové náklady jsou 5 + 1 + 1 + 3 + 3 = 13.

Příklad 2:

Vstup: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Výstup: 15
Vysvětlení:

Proveďte řez na vodorovné přímce 0 s cenou 7.
Proveďte řez podél svislé čáry 0 na podmřížce 1 x 2 s cenou 4.
Proveďte řez podél svislé čáry 0 na podmřížce 1 x 2 s cenou 4.

Celkové náklady jsou 7 + 4 + 4 = 15.

Omezení:

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


Byli ti zadány dvě kladná celá čísla n a k.
Můžeš si vybrat libovolný bit v binární reprezentaci n, který je roven 1, a změnit ho na 0.
Vrať počet změn potřebných k tomu, aby se n rovnalo k. Pokud to není možné, vrať -1.

Příklad 1:

Vstup: n = 13, k = 4
Výstup: 2
Vysvětlení:
Binární reprezentace n a k jsou zpočátku n = (1101)_2 a k = (0100)_2.
Můžeme změnit první a čtvrtý bit n. Výsledné celé číslo je n = (0100)_2 = k.

Příklad 2:

Vstup: n = 21, k = 21
Výstup: 0
Vysvětlení:
n a k jsou si už rovna, takže nejsou potřeba žádné změny.

Příklad 3:

Vstup: n = 14, k = 13
Výstup: -1
Vysvětlení:
Není možné udělat, aby se n rovnalo k.

Omezení:

1 <= n, k <= 10^6

Jsou vám dána dvě kladná celá čísla n a k.
Můžete si vybrat libovolný bit v binární reprezentaci n, který se rovná 1, a změnit jej na 0.
Vrátí počet změn potřebných k tomu, aby se n rovnalo k. Pokud to není možné, vraťte -1.

Příklad 1:

Vstup: n = 13, k = 4
Výstup: 2
Vysvětlení:
Zpočátku jsou binární reprezentace n a k n = (1101)_2 ak = (0100)_2.
Můžeme změnit první a čtvrtý bit n. Výsledné celé číslo je n = (0100)_2 = k.

Příklad 2:

Vstup: n = 21, k = 21
Výstup: 0
Vysvětlení:
n a k jsou již stejné, takže není potřeba žádných změn.

Příklad 3:

Vstup: n = 14, k = 13
Výstup: -1
Vysvětlení:
Není možné, aby se n rovnalo k.

Omezení:

1 <= n, k <= 10^6

Máte dvě kladná celá čísla n a k.
Můžete si vybrat libovolný bit v binární reprezentaci n, který je roven 1, a změnit ho na 0.
Vraťte počet změn potřebných k tomu, aby se n rovnalo k. Pokud to není možné, vraťte -1.

Příklad 1:

Vstup: n = 13, k = 4
Výstup: 2
Vysvětlení:
Binární reprezentace n a k jsou zpočátku n = (1101)_2 a k = (0100)_2.
Můžeme změnit první a čtvrtý bit n. Výsledné celé číslo je n = (0100)_2 = k.

Příklad 2:

Vstup: n = 21, k = 21
Výstup: 0
Vysvětlení:
n a k jsou již rovna, takže nejsou potřeba žádné změny.

Příklad 3:

Vstup: n = 14, k = 13
Výstup: -1
Vysvětlení:
Není možné udělat n rovno k.

Omezení:

1 <= n, k <= 10^6


Alice a Bob hrají hru na řetězci.
Je dán řetězec s, Alice a Bob se budou střídat ve hře, kde Alice začíná jako první:

Ve svém tahu musí Alice odstranit libovolný neprázdný podřetězec z s, který obsahuje lichý počet samohlásek.
Ve svém tahu musí Bob odstranit libovolný neprázdný podřetězec z s, který obsahuje sudý počet samohlásek.

První hráč, který nemůže ve svém tahu provést tah, prohrává hru. Předpokládáme, že Alice i Bob hrají optimálně.
Vrátí true, pokud hra vyhraje Alice, jinak false.
Anglické samohlásky jsou: a, e, i, o a u.

Příklad 1:

Vstup: s = "leetcoder"
Výstup: true
Vysvětlení:
Alice může vyhrát hru následujícím způsobem:

Alice hraje první, může smazat podtržený podřetězec v s = "leetcoder", který obsahuje 3 samohlásky. Výsledný řetězec je s = "der".
Bob hraje druhý, může smazat podtržený podřetězec v s = "der", který obsahuje 0 samohlásek. Výsledný řetězec je s = "er".
Alice hraje třetí, může smazat celý řetězec s = "er", který obsahuje 1 samohlásku.
Bob hraje čtvrtý, protože řetězec je prázdný, nemůže Bob provést platný tah. Takže Alice vyhrává hru.

Příklad 2:

Vstup: s = "bbcd"
Výstup: false
Vysvětlení:
Alice nemá žádný platný tah ve svém prvním tahu, takže Alice prohrává hru.

Omezení:

1 <= s.length <= 10^5
s sestává pouze z malých anglických písmen.

Alice a Bob hrají hru na provázku.
Dostanete řetězec s, Alice a Bob se budou střídat v následující hře, kde Alice začíná jako první:

Na tahu Alice musí odstranit jakýkoli neprázdný podřetězec z s, který obsahuje lichý počet samohlásek.
Když je na řadě Bob, musí z s odstranit jakýkoli neprázdný podřetězec, který obsahuje sudý počet samohlásek.

První hráč, který ve svém tahu nemůže provést tah, prohrává hru. Předpokládáme, že Alice i Bob hrají optimálně.
Vraťte true, pokud Alice vyhraje hru, a false v opačném případě.
Anglické samohlásky jsou: a, e, i, o a u.

Příklad 1:

Vstup: s = "leetcoder"
Výstup: pravda
Vysvětlení:
Alice může vyhrát hru následovně:

Alice hraje první, může smazat podtržený podřetězec v s = "leetcoder", který obsahuje 3 samohlásky. Výsledný řetězec je s = "der".
Bob hraje jako druhý, může smazat podtržený podřetězec v s = "der", který obsahuje 0 samohlásek. Výsledný řetězec je s = "er".
Alice hraje třetí, může smazat celý řetězec s = "er", který obsahuje 1 samohlásku.
Bob hraje čtvrtý, protože řetězec je prázdný, Bob nemá žádnou platnou hru. Alice tedy vyhrává hru.

Příklad 2:

Vstup: s = "bbcd"
Výstup: nepravda
Vysvětlení:
V prvním tahu pro Alici neexistuje žádná platná hra, takže Alice hru prohrává.

Omezení:

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

Alice a Bob hrají hru na řetězci.
Je dán řetězec s, Alice a Bob budou střídavě hrát následující hru, kde Alice začíná jako první:

Na tahu je Alice, která musí z řetězce s odstranit libovolný neprázdný podřetězec, který obsahuje lichý počet samohlásek.
Na tahu je Bob, který musí z řetězce s odstranit libovolný neprázdný podřetězec, který obsahuje sudý počet samohlásek.

První hráč, který ve svém tahu nemůže provést tah, prohrává hru. Předpokládáme, že Alice i Bob hrají optimálně.
Vraťte hodnotu true, pokud Alice vyhraje hru, a false v opačném případě.
Anglické samohlásky jsou: a, e, i, o a u.

Příklad 1:

Vstup: s = „leetcoder“
Výstup: true
Vysvětlení:
Alice může vyhrát následujícím způsobem:

Alice hraje jako první, může vymazat podtržený podřetězec v s = „leetcoder“, který obsahuje 3 samohlásky. Výsledný řetězec je s = „der“.
Bob hraje jako druhý, může smazat podtržený podřetězec v s = „der“, který obsahuje 0 samohlásek. Výsledný řetězec je s = „er“.
Alice hraje jako třetí, může vymazat celý řetězec s = „er“, který obsahuje 1 samohlásku.
Bob hraje jako čtvrtý, protože řetězec je prázdný, není pro něj žádná platná hra. Alice tedy hru vyhrává.

Příklad 2:

Vstup: s = „bbcd“
Výstup: false
Vysvětlení:
V prvním tahu Alice není žádná platná hra, takže Alice prohrává.

Omezení:

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


Máte binární řetězec s.
Na řetězci můžete provést následující operaci libovolněkrát:

Vyberte libovolný index `i` z řetězce, kde `i + 1 < s.length` a `s[i] == '1'` a `s[i + 1] == '0'`.
Posuňte znak `s[i]` doprava, dokud nedosáhne konce řetězce nebo dalšího znaku `'1'`. Například, pokud `s = "010010"` a vyberete `i = 1`, výsledný řetězec bude `s = "000110"`.
Vraťte maximální počet operací, které můžete provést.

Příklad 1:

Vstup: s = "1001101"
Výstup: 4
Vysvětlení:
Můžeme provést následující operace:
Vyberte index i = 0. Výsledný řetězec je s = "0011101".
Vyberte index i = 4. Výsledný řetězec je s = "0011011".
Vyberte index i = 3. Výsledný řetězec je s = "0010111".
Vyberte index i = 2. Výsledný řetězec je s = "0001111".

Příklad 2:

Vstup: s = "00111"
Výstup: 0

Omezení:

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

Dostanete binární řetězec s.
Následující operaci můžete s řetězcem provést libovolněkrát:

Vyberte libovolný index i z řetězce, kde i + 1 < s.length tak, že s[i] == '1' a s[i + 1] == '0'.
Posuňte znak s[i] doprava, dokud nedosáhne konce řetězce nebo jiné '1'. Například pro s = "010010", pokud zvolíme i = 1, výsledný řetězec bude s = "000110".

Vraťte maximální počet operací, které můžete provést.

Příklad 1:

Vstup: s = "1001101"
Výstup: 4
Vysvětlení:
Můžeme provádět následující operace:

Zvolte index i = 0. Výsledný řetězec je s = "0011101".
Zvolte index i = 4. Výsledný řetězec je s = "0011011".
Zvolte index i = 3. Výsledný řetězec je s = "0010111".
Zvolte index i = 2. Výsledný řetězec je s = "0001111".

Příklad 2:

Vstup: s = "00111"
Výstup: 0

Omezení:

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


Jsou vám dána dvě kladná celočíselná pole nums a target, o stejné délce.
V jedné operaci můžete vybrat libovolné podpole čísel a zvýšit nebo snížit každý prvek v tomto podpoli o 1.
Vrátí minimální počet operací potřebných k tomu, aby se čísla rovnala cíli pole.

Příklad 1:

Vstup: nums = [3,5,1,2], target = [4,6,2,4]
Výstup: 2
Vysvětlení:
Provedeme následující operace, aby se čísla rovnala cíli:
- Zvyšte nums [0..3] o 1, nums = [4,6,2,3].
- Zvyšte nums[3..3] o 1, nums = [4,6,2,4].

Příklad 2:

Vstup: nums = [1,3,2], target = [2,1,4]
Výstup: 5
Vysvětlení:
Provedeme následující operace, aby se čísla rovnala cíli:
- Zvyšte nums [0..0] o 1, nums = [2,3,2].
- Snížení nums[1..1] o 1, nums = [2,2,2].
- Snížení nums[1..1] o 1, nums = [2,1,2].
- Zvyšte nums[2..2] o 1, nums = [2,1,3].
- Zvyšte nums[2..2] o 1, nums = [2,1,4].

Omezení:

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

Jsou vám dána dvě kladná celočíselná pole nums a target o stejné délce.
V jedné operaci můžete vybrat libovolné podpole čísel a zvýšit nebo snížit každý prvek v tomto podpoli o 1.
Vrátí minimální počet operací potřebných k tomu, aby se čísla rovnala cíli pole.

Příklad 1:

Vstup: nums = [3,5,1,2], cíl = [4,6,2,4]
Výstup: 2
Vysvětlení:
Provedeme následující operace, aby se čísla rovnala cíli:
- Zvýšit nums[0..3] o 1, nums = [4,6,2,3].
- Zvýšit nums[3..3] o 1, nums = [4,6,2,4].

Příklad 2:

Vstup: nums = [1,3,2], cíl = [2,1,4]
Výstup: 5
Vysvětlení:
Provedeme následující operace, aby se čísla rovnala cíli:
- Zvýšit nums[0..0] o 1, nums = [2,3,2].
- Snížit nums[1..1] o 1, nums = [2,2,2].
- Snížit nums[1..1] o 1, nums = [2,1,2].
- Zvýšit nums[2..2] o 1, nums = [2,1,3].
- Zvýšit nums[2..2] o 1, nums = [2,1,4].

Omezení:

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


Je vám dáno pole kladných celých čísel.
Alice a Bob hrají hru. Ve hře si Alice může vybrat buď všechna jednociferná čísla, nebo všechna dvouciferná čísla z čísel a zbytek čísel dostane Bob. Alice vyhrává, pokud je součet jejích čísel striktně větší než součet Bobových čísel.
Return true, pokud Alice může tuto hru vyhrát, v opačném případě vrátí falešný.

Příklad 1:

Vstup: nums = [1,2,3,4,10]
Výstup: false
Vysvětlení:
Alice nemůže vyhrát výběrem jednociferných nebo dvouciferných čísel.

Příklad 2:

Vstup: nums = [1,2,3,4,5,14]
Výstup: true
Vysvětlení:
Alice může vyhrát výběrem jednociferných čísel, jejichž součet se rovná 15.

Příklad 3:

Vstup: nums = [5,5,5,25]
Výstup: true
Vysvětlení:
Alice může vyhrát výběrem dvouciferných čísel, která mají součet rovný 25.

Omezení:

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

Jste dáni pole kladných celých čísel nums.
Alice a Bob hrají hru. Ve hře si Alice může vybrat buď všechna jednočíselná čísla, nebo všechna dvojčíselná čísla z nums, a zbytek čísel je přiřazen Bobovi. Alice vyhraje, pokud je součet jejích čísel striktně větší než součet Bobových čísel.
Vrátit true, pokud Alice může tuto hru vyhrát, jinak vrátit false.

Příklad 1:

Vstup: nums = [1,2,3,4,10]
Výstup: false
Vysvětlení:
Alice nemůže vyhrát výběrem buď jednočíselných, nebo dvojčíselných čísel.

Příklad 2:

Vstup: nums = [1,2,3,4,5,14]
Výstup: true
Vysvětlení:
Alice může vyhrát výběrem jednočíselných čísel, která mají součet rovný 15.

Příklad 3:

Vstup: nums = [5,5,5,25]
Výstup: true
Vysvětlení:
Alice může vyhrát výběrem dvojčíselných čísel, která mají součet rovný 25.

Omezení:

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

Dostanete pole kladných celých čísel.
Alice a Bob hrají hru. Ve hře si Alice může vybrat buď všechna jednociferná čísla, nebo všechna dvouciferná čísla z čísel a zbytek čísel dostane Bob. Alice vyhraje, pokud je součet jejích čísel přísně větší než součet Bobových čísel.
Vraťte true, pokud Alice může tuto hru vyhrát, jinak vraťte false.

Příklad 1:

Vstup: nums = [1,2,3,4,10]
Výstup: nepravda
Vysvětlení:
Alice nemůže vyhrát výběrem jednociferných nebo dvouciferných čísel.

Příklad 2:

Vstup: nums = [1,2,3,4,5,14]
Výstup: pravda
Vysvětlení:
Alice může vyhrát výběrem jednociferných čísel, jejichž součet se rovná 15.

Příklad 3:

Vstup: nums = [5,5,5,25]
Výstup: pravda
Vysvětlení:
Alice může vyhrát výběrem dvouciferných čísel, jejichž součet se rovná 25.

Omezení:

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


Jsou vám dána 2 kladná celá čísla l a r. Pro libovolné číslo x se všechny kladné dělitele x kromě x nazývají vlastní dělitelé x.
Číslo se nazývá speciální, pokud má právě 2 vlastní dělitelé. Například:

Číslo 4 je speciální, protože má vlastní dělitelé 1 a 2.
Číslo 6 není zvláštní, protože má vlastní dělitelé 1, 2 a 3.

Vrátí počet čísel v rozsahu [l, r], která nejsou speciální.

Příklad 1:

Vstup: l = 5, r = 7
Výstup: 3
Vysvětlení:
V rozsahu [5, 7] nejsou žádná speciální čísla.

Příklad 2:

Vstup: l = 4, r = 16
Výstup: 11
Vysvětlení:
Speciální čísla v rozsahu [4, 16] jsou 4 a 9.

Omezení:

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

Máte dána 2 kladná celá čísla l a r. Pro jakékoliv číslo x, všechny kladné dělitele x kromě x samotného nazýváme vlastními děliteli x.
Číslo nazveme speciálním, pokud má přesně 2 vlastní dělitele. Například:

Číslo 4 je speciální, protože má vlastní dělitele 1 a 2.
Číslo 6 není speciální, protože má vlastní dělitele 1, 2 a 3.

Vraťte počet čísel v rozsahu [l, r], která nejsou speciální.

Příklad 1:

Vstup: l = 5, r = 7
Výstup: 3
Vysvětlení:
V rozsahu [5, 7] nejsou žádná speciální čísla.

Příklad 2:

Vstup: l = 4, r = 16
Výstup: 11
Vysvětlení:
Speciálními čísly v rozsahu [4, 16] jsou 4 a 9.

Omezení:

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

Jsou vám dána 2 kladná celá čísla l a r. Pro jakékoli číslo x se všichni kladní dělitelé x kromě x nazývají vlastní dělitelé x.
Číslo se nazývá speciální, pokud má přesně 2 správné dělitele. Například:

Číslo 4 je zvláštní, protože má správné dělitele 1 a 2.
Číslo 6 není zvláštní, protože má správné dělitele 1, 2 a 3.

Vrátí počet čísel v rozsahu [l, r], která nejsou speciální.

Příklad 1:

Vstup: l = 5, r = 7
Výstup: 3
Vysvětlení:
V rozsahu [5, 7] nejsou žádná speciální čísla.

Příklad 2:

Vstup: l = 4, r = 16
Výstup: 11
Vysvětlení:
Speciální čísla v rozsahu [4, 16] jsou 4 a 9.

Omezení:

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


Máte binární řetězec s.
Vraťte počet podřetězců s dominujícími jedničkami.
Řetězec má dominující jedničky, pokud je počet jedniček v řetězci větší nebo roven druhé mocnině počtu nul v řetězci.

Příklad 1:

Vstup: s = "00011"
Výstup: 5
Vysvětlení:
Podřetězce s dominujícími jedničkami jsou zobrazeny v tabulce níže.

\[
\begin{array}{ccc}
i & j & s[i..j] & \text{Počet nul} & \text{Počet jedniček} \\
\hline
3 & 3 & 1 & 0 & 1 \\
4 & 4 & 1 & 0 & 1 \\
2 & 3 & 01 & 1 & 1 \\
3 & 4 & 11 & 0 & 2 \\
2 & 4 & 011 & 1 & 2 \\
\end{array}
\]

Příklad 2:

Vstup: s = "101101"
Výstup: 16
Vysvětlení:
Podřetězce s nedominujícími jedničkami jsou uvedeny v tabulce níže.
Jelikož celkově existuje 21 podřetězců a 5 z nich má nedominující jedničky, vyplývá, že existuje 16 podřetězců s dominujícími jedničkami.

\[
\begin{array}{ccc}
i & j & s[i..j] & \text{Počet nul} & \text{Počet jedniček} \\
\hline
1 & 1 & 0 & 1 & 0 \\
4 & 4 & 0 & 1 & 0 \\
1 & 4 & 0110 & 2 & 2 \\
0 & 4 & 10110 & 2 & 3 \\
1 & 5 & 01101 & 2 & 3 \\
\end{array}
\]

Omezení:

1 <= s.length <= 4 \times 10^4
s se skládá pouze z znaků '0' a '1'.

Dostanete binární řetězec s.
Vraťte počet podřetězců s dominantními.
Řetězec má dominantní jedničky, pokud je počet jedniček v řetězci větší nebo roven druhé mocnině počtu nul v řetězci.

Příklad 1:

Vstup: s = "00011"
Výstup: 5
Vysvětlení:
Podřetězce s dominantními jsou uvedeny v tabulce níže.

i
j
s[i..j]
Počet nul
Počet jedniček

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Příklad 2:

Vstup: s = "101101"
Výstup: 16
Vysvětlení:
Podřetězce s nedominantními jsou uvedeny v tabulce níže.
Protože existuje celkem 21 podřetězců a 5 z nich má nedominantní, vyplývá z toho, že existuje 16 podřetězců s dominantními.

i
j
s[i..j]
Počet nul
Počet jedniček

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Omezení:

1 <= s.length <= 4 * 10^4
s se skládá pouze ze znaků '0' a '1'.

Je vám zadán binární řetězec s.
Vrátí počet podřetězců s dominantními jedničkami.
Řetězec má dominantní jedničky, pokud je počet jedniček v řetězci větší nebo roven druhé mocnině počtu nul v řetězci.

Příklad 1:

Vstup: s = "00011"
Výstup: 5
Vysvětlení:
Podřetězce s dominantními jsou uvedeny v tabulce níže.

i
j
s[i.. j]
Počet nul
Počet kusů

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Příklad 2:

Vstup: s = "101101"
Výstup: 16
Vysvětlení:
Podřetězce s nedominantními jedničkami jsou uvedeny v tabulce níže.
Protože existuje celkem 21 podřetězců a 5 z nich má nedominantní, vyplývá z toho, že existuje 16 podřetězců s dominantními.

i
j
s[i.. j]
Počet nul
Počet jedniček

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Omezení:

1 <= s.length <= 4 * 10^4
s se skládá pouze ze znaků "0" a "1".


Jsou dána dvě celá kladná čísla xCorner a yCorner a 2D pole circles, kde circles[i] = [x_i, y_i, r_i] označuje kružnici se středem v bodě (x_i, y_i) a poloměrem r_i.
V souřadnicové rovině je obdélník s levým dolním rohem v počátku a pravým horním rohem na souřadnici (xCorner, yCorner). Je třeba ověřit, zda existuje cesta z levého dolního rohu do pravého horního rohu taková, aby celá cesta ležela uvnitř obdélníku, nedotýkala se žádné kružnice ani v ní neležela a dotýkala se obdélníku pouze ve dvou rozích.
Vraťte true, pokud taková cesta existuje, a false v opačném případě.

Příklad 1:

Vstup: xCorner = 3, yCorner = 4, circles = [[2,1,1]].
Výstup: true
Vysvětlení:

Černá křivka ukazuje možnou cestu mezi (0, 0) a (3, 4).

Příklad 2:

Vstup: xCorner = 3, yCorner = 3, circles = [[1,1,2]].
Výstup: false
Vysvětlení:

Z (0, 0) do (3, 3) neexistuje žádná cesta.

Příklad 3:

Vstup: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]].
Výstup: false
Vysvětlení:

Z (0, 0) do (3, 3) neexistuje žádná cesta.

Příklad 4:

Vstup: xCorner = 4, yCorner = 4, circles = [[5,5,1]].
Výstup: true
Vysvětlení:

Omezení:

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

Jsou vám dána dvě kladná celá čísla xCorner a yCorner a 2D pole kruhů, kde kruhy[i] = [x_i, y_i, r_i] označují kruh se středem v (x_i, y_i) a poloměrem r_i.
V souřadnicové rovině je obdélník s levým spodním rohem na počátku a pravým horním rohem na souřadnici (xCorner, yCorner). Musíte zkontrolovat, zda existuje cesta z levého dolního rohu do pravého horního rohu tak, že celá cesta leží uvnitř obdélníku, nedotýká se ani neleží uvnitř žádného kruhu a dotýká se obdélníku pouze ve dvou rozích.
Pokud taková cesta existuje, Vrátí hodnotu True, pokud taková cesta existuje, jinak vrátí False.

Příklad 1:

Vstup: xCorner = 3, yCorner = 4, kruhy = [[2,1,1]]
Výstup: pravda
Vysvětlení:

Černá křivka ukazuje možnou cestu mezi (0, 0) a (3, 4).

Příklad 2:

Vstup: xCorner = 3, yCorner = 3, kruhy = [[1,1,2]]
Výstup: nepravda
Vysvětlení:

Neexistuje žádná cesta od (0, 0) do (3, 3).

Příklad 3:

Vstup: xCorner = 3, yCorner = 3, kruhy = [[2,1,1],[1,2,1]]
Výstup: nepravda
Vysvětlení:

Neexistuje žádná cesta od (0, 0) do (3, 3).

Příklad 4:

Vstup: xCorner = 4, yCorner = 4, kruhy = [[5,5,1]]
Výstup: pravda
Vysvětlení:

Omezení:

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

Jsou vám dána dvě kladná celá čísla xCorner a yCorner a 2D pole kruhů, kde kruhy[i] = [x_i, y_i, r_i] označují kruh se středem v (x_i, y_i) a poloměrem r_i.
V souřadnicové rovině je obdélník s levým spodním rohem na počátku a pravým horním rohem na souřadnici (xCorner, yCorner). Musíte zkontrolovat, zda existuje cesta z levého dolního rohu do pravého horního rohu tak, že celá cesta leží uvnitř obdélníku, nedotýká se ani neleží uvnitř žádného kruhu a dotýká se obdélníku pouze ve dvou rozích.
Pokud taková cesta existuje, vrátí hodnotu true a v opačném případě vrátí hodnotu false.

Příklad 1:

Vstup: xCorner = 3, yCorner = 4, kruhy = [[2,1,1]]
Výstup: pravda
Vysvětlení:

Černá křivka ukazuje možnou cestu mezi (0, 0) a (3, 4).

Příklad 2:

Vstup: xCorner = 3, yCorner = 3, kruhy = [[1,1,2]]
Výstup: nepravda
Vysvětlení:

Neexistuje žádná cesta od (0, 0) do (3, 3).

Příklad 3:

Vstup: xCorner = 3, yCorner = 3, kruhy = [[2,1,1],[1,2,1]]
Výstup: nepravda
Vysvětlení:

Neexistuje žádná cesta od (0, 0) do (3, 3).

Příklad 4:

Vstup: xCorner = 4, yCorner = 4, kruhy = [[5,5,1]]
Výstup: pravda
Vysvětlení:

Omezení:

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


Je vám dáno celé číslo n a 2D pole celých čísel queries.
Je tu n měst očíslovaných od 0 do n - 1. Na začátku existuje jednosměrná silnice z města i do města i + 1 pro všechna 0 <= i < n - 1.
queries[i] = [u_i, v_i] představuje přidání nové jednosměrné silnice z města u_i do města v_i. Po každém dotazu je třeba najít délku nejkratší cesty z města 0 do města n - 1.
Vraťte pole answer, kde pro každé i v rozsahu [0, queries.length - 1] je answer[i] délkou nejkratší cesty z města 0 do města n - 1 po zpracování prvních i + 1 dotazů.

Příklad 1:

Vstup: n = 5, queries = [[2,4],[0,2],[0,4]]
Výstup: [3,2,1]
Vysvětlení:

Po přidání silnice z 2 do 4 je délka nejkratší cesty z 0 do 4 rovna 3.

Po přidání silnice z 0 do 2 je délka nejkratší cesty z 0 do 4 rovna 2.

Po přidání silnice z 0 do 4 je délka nejkratší cesty z 0 do 4 rovna 1.

Příklad 2:

Vstup: n = 4, queries = [[0,3],[0,2]]
Výstup: [1,1]
Vysvětlení:

Po přidání silnice z 0 do 3 je délka nejkratší cesty z 0 do 3 rovna 1.

Po přidání silnice z 0 do 2 zůstává délka nejkratší cesty rovna 1.

Omezení:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Neexistují žádné opakované cesty mezi dotazy.

Je vám dáno celé číslo n a 2D pole celých čísel queries.
Existuje n měst očíslovaných od 0 do n - 1. Zpočátku existuje jednosměrná silnice z města i do města i + 1 pro všechna 0 ≤ i < n - 1.
queries[i] = [u_i, v_i] představuje přidání nové jednosměrné silnice z města u_i do města v_i. Po každém dotazu musíte najít délku nejkratší cesty z města 0 do města n - 1.
Vrátí pole answer, kde pro každé i v rozsahu [0, queries.length - 1] je answer[i] délkou nejkratší cesty z města 0 do města n - 1 po zpracování prvních i + 1 queries.

Příklad 1:

Vstup: n = 5, queries = [[2,4],[0,2],[0,4]]
Výstup: [3,2,1]
Vysvětlení:

Po přidání silnice z 2 do 4 je délka nejkratší cesty z 0 do 4 3.

Po přidání silnice z 0 do 2 je délka nejkratší cesty z 0 do 4 2.

Po přidání silnice z 0 do 4 je délka nejkratší cesty z 0 do 4 1.

Příklad 2:

Vstup: n = 4, queries = [[0,3],[0,2]]
Výstup: [1,1]
Vysvětlení:

Po přidání silnice z 0 do 3 je délka nejkratší cesty z 0 do 3 1.

Po přidání silnice z 0 do 2 zůstává délka nejkratší cesty 1.

Omezení:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Mezi dotazy nejsou žádné opakované silnice.

Dostanete celočíselné n a 2D celočíselné pole dotazů.
Existuje n měst očíslovaných od 0 do n - 1. Zpočátku existuje jednosměrná silnice z města i do města i + 1 pro všechna 0 <= i < n - 1.
dotazy[i] = [u_i, v_i] představuje přidání nové jednosměrné silnice z města u_i do města v_i. Po každém dotazu musíte najít délku nejkratší cesty z města 0 do města n - 1.
Vrátí pole odpovědí, kde pro každé i v rozsahu [0, dotazy.length - 1] je odpověď[i] délka nejkratší cesty z města 0 do města n - 1 po zpracování prvních i + 1 dotazů..

Příklad 1:

Vstup: n = 5, dotazy = [[2,4],[0,2],[0,4]]
Výstup: [3,2,1]
Vysvětlení:

Po přidání cesty z 2 na 4 je délka nejkratší cesty nejkratší cesty z 0 na 4 3.

Po přidání cesty z 0 na 2 je délka nejkratší cesty nejkratší cesty z 0 na 4 2.

Po přidání cesty z 0 na 4 je délka nejkratší cesty z 0 na 4 1.

Příklad 2:

Vstup: n = 4, dotazy = [[0,3],[0,2]]
Výstup: [1,1]
Vysvětlení:

Po přidání cesty z 0 na 2 je délka nejkratší cesty z 0 na 3 1.

Po přidání cesty z 0 na 2 zůstane délka nejkratší cesty 1.

Omezení:

3 <= n <= 500
1 <= dotazy.length <= 500
dotazy[i].length == 2
0 <= dotazy[i][0] < dotazy[i][1] < n
1 < dotazy[i][1] - dotazy[i][0]
Mezi dotazy nejsou žádné opakující se cesty.


Jsou zde červené a modré dlaždice uspořádané kruhově. Je vám dáno pole celých čísel colors a 2D pole celých čísel queries. Barva dlaždice i je reprezentována colors[i]:

colors[i] == 0 znamená, že dlaždice i je červená.
colors[i] == 1 znamená, že dlaždice i je modrá.

Střídající se skupina je souvislý podmnožina dlaždic v kruhu se střídajícími se barvami (každá dlaždice ve skupině kromě první a poslední má jinou barvu než její sousední dlaždice ve skupině). Musíte zpracovat dotazy dvou typů:

queries[i] = [1, size_i], určit počet střídajících se skupin velikosti size_i.
queries[i] = [2, index_i, color_i], změnit colors[index_i] na color_i.

Vrátit pole answer obsahující výsledky dotazů prvního typu v pořadí.
Všimněte si, že protože colors představuje kruh, první a poslední dlaždice jsou považovány za sousední.

Příklad 1:

Vstup: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Výstup: [2]
Vysvětlení:

První dotaz:
Změnit colors[1] na 0.

Druhý dotaz:
Počet střídajících se skupin o velikosti 4:

Příklad 2:

Vstup: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Výstup: [2,0]
Vysvětlení:

První dotaz:
Počet střídajících se skupin o velikosti 3:

Druhý dotaz: colors se nezmění.
Třetí dotaz: Neexistuje žádná střídající se skupina o velikosti 5.

Omezení:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 nebo queries[i][0] == 2
Pro všechna i, která platí:

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

Existuje několik červených a modrých dlaždic uspořádaných kruhově. Dostanete pole celých čísel reprezentujících barvy a dotazy na pole 2D celých čísel.
Barva dlaždice i je reprezentována barvami[i]:

barvy[i] == 0 znamená, že dlaždice i je červená.
barvy[i] == 1 znamená, že dlaždice i je modrá.

Střídavá skupina je souvislá podmnožina dlaždic v kruhu se střídajícími se barvami (každá dlaždice ve skupině kromě první a poslední má jinou barvu než sousední dlaždice ve skupině).
Musíte zpracovat dotazy dvou typů:

dotazy[i] = [1, velikost_i], určit počet střídajících se skupin s velikostí velikost_i.
dotazy[i] = [2, index_i, barva_i], změnit barvy[index_i] na barvu_i.

Vrátí odpověď pole obsahující výsledky dotazů prvního typu v pořadí.
Všimněte si, že protože barvy představují kruh, první a poslední dlaždice jsou považovány za vedle sebe.

Příklad 1:

Vstup: barvy = [0,1,1,0,1], dotazy = [[2,1,0],[1,4]]
Výstup: [2]
Vysvětlení:

První dotaz:
Změňte barvy[1] na 0.

Druhý dotaz:
Počet střídajících se skupin o velikosti 4:

Příklad 2:

Vstup: barvy = [0,0,1,0,1,1], dotazy = [[1,3],[2,3,0],[1,5]]
Výstup: [2,0]
Vysvětlení:

První dotaz:
Počet střídajících se skupin o velikosti 3:

Druhý dotaz: barvy se nezmění.
Třetí dotaz: Neexistuje žádná alternativní skupina s velikostí 5.

Omezení:

4 <= barvy.length <= 5 * 10^4
0 <= barvy[i] <= 1
1 <= dotazy.length <= 5 * 10^4
dotazy[i][0] == 1 nebo dotazy[i][0] == 2
Za to všechno:

dotazy[i][0] == 1: dotazy[i].length == 2, 3 <= dotazy[i][1] <= barvy.length - 1
dotazy[i][0] == 2: dotazy[i].length == 3, 0 <= dotazy[i][1] <= barvy.length - 1, 0 <= dotazy[i][2] < = 1

Existuje několik červených a modrých dlaždic uspořádaných kruhově. Dostanete pole celých barev a dotazy na pole 2D celých čísel.
Barva dlaždice i je reprezentována barvami[i]:

barvy[i] == 0 znamená, že dlaždice i je červená.
barvy[i] == 1 znamená, že dlaždice i je modrá.

Střídavá skupina je souvislá podmnožina dlaždic v kruhu se střídajícími se barvami (každá dlaždice ve skupině kromě první a poslední má jinou barvu než sousední dlaždice ve skupině).
Musíte zpracovat dotazy dvou typů:

dotazy[i] = [1, velikost_i], určit počet střídajících se skupin s velikostí velikost_i.
dotazy[i] = [2, index_i, barva_i], změnit barvy[index_i] na barvu_i.

Vrátí odpověď pole obsahující výsledky dotazů prvního typu v pořadí.
Všimněte si, že protože barvy představují kruh, první a poslední dlaždice jsou považovány za vedle sebe.

Příklad 1:

Vstup: barvy = [0,1,1,0,1], dotazy = [[2,1,0],[1,4]]
Výstup: [2]
Vysvětlení:

První dotaz:
Změňte barvy[1] na 0.

Druhý dotaz:
Počet střídajících se skupin o velikosti 4:

Příklad 2:

Vstup: barvy = [0,0,1,0,1,1], dotazy = [[1,3],[2,3,0],[1,5]]
Výstup: [2,0]
Vysvětlení:

První dotaz:
Počet střídajících se skupin o velikosti 3:

Druhý dotaz: barvy se nezmění.
Třetí dotaz: Neexistuje žádná alternativní skupina s velikostí 5.

Omezení:

4 <= barvy.length <= 5 * 10^4
0 <= barvy[i] <= 1
1 <= dotazy.length <= 5 * 10^4
dotazy[i][0] == 1 nebo dotazy[i][0] == 2
Za to všechno:

dotazy[i][0] == 1: dotazy[i].length == 2, 3 <= dotazy[i][1] <= barvy.length - 1
dotazy[i][0] == 2: dotazy[i].length == 3, 0 <= dotazy[i][1] <= barvy.length - 1, 0 <= dotazy[i][2] < = 1


V maticové mřížce n x n je had, který se může pohybovat ve čtyřech možných směrech. Každá buňka v mřížce je identifikována pozicí: grid[i][j] = (i * n) + j.
Had začíná na buňce 0 a následuje po sekvenci příkazů.
Dostanete celé číslo n reprezentující velikost mřížky a pole řetězců příkazů, kde každý příkaz je buď "UP", "RIGHT", "DOWN" a "LEFT". Je zaručeno, že had zůstane uvnitř hranic mřížky po celou dobu svého pohybu.
Vrátí pozici poslední buňky, ve které had po provedení příkazů skončí.

Příklad 1:

Vstup: n = 2, commands = ["RIGHT","DOWN"]
Výstup: 3
Vysvětlení:

0
1

2
3

0
1

2
3

0
1

2
3

Příklad 2:

Vstup: n = 3, commands = ["DOWN","RIGHT","UP"]
Výstup: 1
Vysvětlení:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8
Omezení:

2 <= n <= 10
1 <= commands.length <= 100
příkazy se skládají pouze z příkazů "UP", "RIGHT", "DOWN" a "LEFT".
Vstup je generován tak, aby se had nepohyboval mimo hranice.

V maticové mřížce n x n je had a může se pohybovat ve čtyřech možných směrech. Každá buňka v mřížce je označena pozicí: mřížka[i][j] = (i * n) + j.
Had začíná v buňce 0 a následuje sekvenci příkazů.
Dostanete celé číslo n představující velikost mřížky a pole řetězcových příkazů, kde každý příkaz[i] je buď "NAHORU", "VPRAVO", "DOLŮ" a "VLEVO". Je zaručeno, že had zůstane po celou dobu svého pohybu uvnitř hranic mřížky.
Vraťte pozici poslední buňky, kde had skončí po provedení příkazů.

Příklad 1:

Vstup: n = 2, příkazy = ["VPRAVO","DOLŮ"]
Výstup: 3
Vysvětlení:

0
1

2
3

0
1

2
3

0
1

2
3

Příklad 2:

Vstup: n = 3, příkazy = ["DOWN","RIGHT","UP"]
Výstup: 1
Vysvětlení:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Omezení:

2 <= n <= 10
1 <= příkazy.length <= 100
příkazy sestávají pouze z „NAHORU“, „VPRAVO“, „DOLŮ“ a „VLEVO“.
Vstup je generován tak, že se had nebude pohybovat mimo hranice.

V maticové mřížce n x n se nachází had, který se může pohybovat čtyřmi možnými směry. Každé políčko v mřížce je identifikováno polohou: grid[i][j] = (i * n) + j.
Had začíná v buňce 0 a postupuje podle posloupnosti příkazů.
Je dáno celé číslo n představující velikost mřížky a pole řetězců příkazů, kde každý příkaz[i] je buď „NAHORU“, „VPRAVO“, „DOLŮ“ a „VLEVO“. Je zaručeno, že had zůstane po celou dobu svého pohybu v hranicích mřížky.
Vraťte pozici poslední buňky, ve které had po provedení příkazů skončí.

Příklad 1:

Vstup: n = 2, příkazy = [„RIGHT“, „DOWN“]
Výstup: 3
Vysvětlení:

0
1

2
3

0
1

2
3

0
1

2
3

Příklad 2:

Vstup: n = 3, příkazy = [„DOLŮ“, „VPRAVO“, „NAHORU“]
Výstup: 1
Vysvětlení:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Omezení:

2 <= n <= 10
1 <= commands.length <= 100
příkazy se skládají pouze z „UP“, „RIGHT“, „DOWN“ a „LEFT“.
Vstup je generován tak, aby se had nepohyboval mimo ohraničení.


Dostanete pole kladných celých čísel délky n.
Dvojici nezáporných celých polí (arr1, arr2) říkáme monotónní, pokud:

Délka obou polí je n.
arr1 je monotónně neklesající, jinými slovy arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 je monotónně nerostoucí, jinými slovy arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] pro všechna 0 <= i <= n - 1.

Vraťte počet monotónních dvojic.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [2,3,2]
Výstup: 4
Vysvětlení:
Dobré páry jsou:

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

Příklad 2:

Vstup: nums = [5,5,5,5]
Výstup: 126

Omezení:

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

Máte pole kladných celých čísel `nums` délky `n`.
Pár polí nepodporných celých čísel `(arr1, arr2)` nazýváme monotónním, pokud platí:

Délky obou polí jsou `n`.
`arr1` je monotónně neklesající, jinými slovy `arr1[0] <= arr1[1] <= ... <= arr1[n - 1]`.
`arr2` je monotónně nerostoucí, jinými slovy `arr2[0] >= arr2[1] >= … >= arr2[n - 1]`.
`arr1[i] + arr2[i] == nums[i]` pro všechna `0 <= i <= n - 1`.

Vrátí počet monotónních párů.
Protože odpověď může být velmi velká, vrátí ji modulo 10^9 + 7.

Příklad 1:

Vstup: `nums = [2,3,2]`
Výstup: `4`
Vysvětlení:
Dobrými páry jsou:

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

Příklad 2:

Vstup: `nums = [5,5,5,5]`
Výstup: `126`

Omezení:

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

Je zadáno pole kladných celých čísel n o délce n.
Dvojici polí nezáporných celých čísel (arr1, arr2) nazýváme monotónní, jestliže:

délky obou polí jsou rovny n.
arr1 je monotónně neklesající, jinými slovy arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 je monotónně nerostoucí, jinými slovy arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] pro všechny 0 <= i <= n - 1.

Vrátí počet monotónních dvojic.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [2,3,2]
Výstup: 4
Vysvětlení:
Vhodné dvojice jsou:

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

Příklad 2:

Vstup: nums = [5,5,5,5]
Výstup: 126

Omezení:

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


Máte daný řetězec s.
Vaším úkolem je opakovaně odstraňovat všechny číslice provedením této operace:

Smažte první číslici a nejbližší znak, který není číslicí, vlevo od ní.

Vrátí výsledný řetězec po odstranění všech číslic.

Příklad 1:

Vstup: s = "abc"
Výstup: "abc"
Vysvětlení:
V řetězci není žádná číslice.

Příklad 2:

Vstup: s = "cb34"
Výstup: ""
Vysvětlení:
Nejprve provedeme operaci na s[2] a s se stane "c4".
Potom provedeme operaci na s[1] a s se stane "".

Omezení:

1 <= s.length <= 100
s se skládá pouze z malých písmen anglické abecedy a číslic.
Vstup je generován tak, že je možné smazat všechny číslice.

Je vám dán řetězec s.
Vaším úkolem je odstranit všechny číslice opakovaným prováděním této operace:

Smažte první číslici a nejbližší nečíslicový znak vlevo od ní.

Po odstranění všech číslic vraťte výsledný řetězec.

Příklad 1:

Vstup: s = "abc"
Výstup: "abc"
Vysvětlení:
V řetězci není žádná číslice.

Příklad 2:

Vstup: s = "cb34"
Výstup: ""
Vysvětlení:
Nejprve použijeme operaci na s[2] a s se stane "c4".
Potom použijeme operaci na s[1] a s se stane "".

Omezení:

1 <= s.length <= 100
s se skládá pouze z malých anglických písmen a číslic.
Vstup je generován tak, že je možné smazat všechny číslice.

Je zadán řetězec s.
Vaším úkolem je opakovaným provedením této operace odstranit všechny číslice:

Odstraňte první číslici a nejbližší neciferný znak nalevo od ní.

Vraťte výsledný řetězec po odstranění všech číslic.

Příklad 1:

Vstup: s = „abc“
Výstup: „abc“
Vysvětlení:
V řetězci není žádná číslice.

Příklad 2:

Vstup: s = „cb34“
Výstup: „“
Vysvětlení:
Nejprve použijeme operaci na s[2] a z s se stane „c4“.
Poté použijeme operaci na s[1] a z s se stane „“.

Omezení:

1 <= s.length <= 100
s se skládá pouze z malých anglických písmen a číslic.
Vstup je generován tak, aby bylo možné vymazat všechny číslice.


Soutěž se skládá z n hráčů očíslovaných od 0 do n - 1.
Je dáno celočíselné pole skills o velikosti n a kladné celé číslo k, kde skills[i] je úroveň dovedností hráče i. Všechna celá čísla v skills jsou jedinečná.
Všichni hráči stojí ve frontě v pořadí od hráče 0 po hráče n - 1.
Soutěžní proces probíhá následovně:

První dva hráči ve frontě hrají hru a vyhrává hráč s vyšší úrovní dovedností.
Po skončení hry zůstává vítěz na začátku fronty a poražený jde na její konec.

Vítězem soutěže se stává hráč, který jako první vyhraje k her v řadě.
Vraťte počáteční index vítězného hráče.

Příklad 1:

Vstup: dovednosti = [4,2,6,3,9], k = 2
Výstup: 2
Vysvětlení:
Na začátku je fronta hráčů [0,1,2,3,4]. Proběhne následující proces:

Hráči 0 a 1 hrají hru, protože dovednosti hráče 0 jsou vyšší než dovednosti hráče 1, vyhrává hráč 0. Výsledná fronta je [0,2,3,4,1].
Hráči 0 a 2 hrají hru, protože dovednost hráče 2 je vyšší než dovednost hráče 0, vyhrává hráč 2. Výsledná fronta je [2,3,4,1,0].
Hráči 2 a 3 hrají hru, protože dovednost hráče 2 je vyšší než dovednost hráče 3, vyhrává hráč 2. Výsledná fronta je [2,4,1,0,3].

Hráč 2 vyhrál k = 2 hry v řadě, takže vítězem je hráč 2.

Příklad 2:

Vstup: dovednosti = [2,5,4], k = 3
Výstup: 1
Vysvětlení:
Na začátku je fronta hráčů [0,1,2]. Proběhne následující proces:

Hráči 0 a 1 hrají hru, protože dovednosti hráče 1 jsou vyšší než dovednosti hráče 0, vyhrává hráč 1. Výsledná fronta je [1,2,0].
Hráči 1 a 2 hrají hru, protože dovednost hráče 1 je vyšší než dovednost hráče 2, vyhrává hráč 1. Výsledná fronta je [1,0,2].
Hráči 1 a 0 hrají hru, protože dovednosti hráče 1 jsou vyšší než dovednosti hráče 0, vyhrává hráč 1. Výsledná fronta je [1,2,0].

Hráč 1 vyhrál k = 3 hry v řadě, takže vítězem je hráč 1.

Omezení:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Všechna celá čísla v dovednostech jsou jedinečná.

Soutěž se skládá z n hráčů očíslovaných od 0 do n - 1.
Je vám dáno celočíselné pole dovedností o velikosti n a kladné celé číslo k, kde dovednosti[i] je úroveň dovedností hráče i. Všechna celá čísla v dovednostech jsou jedinečná.
Všichni hráči stojí ve frontě v pořadí od hráče 0 po hráče n - 1.
Průběh soutěže je následující:

První dva hráči ve frontě hrají hru a hráč s vyšší úrovní dovedností vyhrává.
Po skončení hry zůstává vítěz na začátku fronty a poražený jde na její konec.

Vítězem soutěže se stává hráč, který jako první vyhraje k partií v řadě.
Vrátí počáteční index vítězného hráče.

Příklad 1:

Vstup: skills = [4,2,6,3,9], k = 2
Výstup: 2
Vysvětlení:
Zpočátku je fronta hráčů [0,1,2,3,4]. Dojde k následujícímu procesu:

Hráči 0 a 1 hrají hru, protože dovednost hráče 0 je vyšší než dovednost hráče 1, hráč 0 vyhrává. Výsledná fronta je [0,2,3,4,1].
Hráči 0 a 2 hrají hru, protože dovednost hráče 2 je vyšší než dovednost hráče 0, vyhrává hráč 2. Výsledná fronta je [2,3,4,1,0].
Hráči 2 a 3 hrají hru, protože dovednost hráče 2 je vyšší než dovednost hráče 3, hráč 2 vyhrává. Výsledná fronta je [2,4,1,0,3].

Hráč 2 vyhrál k = 2 hry v řadě, takže vítězem se stává hráč 2.

Příklad 2:

Vstup: skills = [2,5,4], k = 3
Výstup: 1
Vysvětlení:
Zpočátku je fronta hráčů [0,1,2]. Dojde k následujícímu procesu:

Hráči 0 a 1 hrají hru, protože dovednost hráče 1 je vyšší než dovednost hráče 0, vyhrává hráč 1. Výsledná fronta je [1,2,0].
Hráči 1 a 2 hrají hru, protože dovednost hráče 1 je vyšší než dovednost hráče 2, hráč 1 vyhrává. Výsledná fronta je [1,0,2].
Hráči 1 a 0 hrají partii, protože dovednost hráče 1 je vyšší než dovednost hráče 0, vyhrává hráč 1. Výsledná fronta je [1,2,0].

Hráč 1 vyhrál k = 3 hry v řadě, takže vítězem se stává hráč 1.

Omezení:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Všechna celá čísla v dovednostech jsou jedinečná.

Soutěž se skládá z n hráčů očíslovaných od 0 do n - 1.
Je vám dáno celé číslo array skills velikosti n a kladné celé číslo k, kde skills[i] je úroveň dovedností hráče i. Všechna celá čísla v skills jsou jedinečná.
Všichni hráči stojí v řadě od hráče 0 do hráče n - 1.
Proces soutěže je následující:

První dva hráči v řadě hrají hru a hráč s vyšší úrovní dovedností vyhrává.
Po hře zůstane vítěz na začátku řady a poražený jde na její konec.

Vítězem soutěže se stává první hráč, který vyhraje k her po sobě.
Vraťte počáteční index vítězného hráče.

Příklad 1:

Vstup: skills = [4,2,6,3,9], k = 2
Výstup: 2
Vysvětlení:
Zpočátku je řada hráčů [0,1,2,3,4]. Probíhá následující proces:

Hráči 0 a 1 hrají hru, protože dovednost hráče 0 je vyšší než dovednost hráče 1, hráč 0 vyhrává. Výsledná řada je [0,2,3,4,1].
Hráči 0 a 2 hrají hru, protože dovednost hráče 2 je vyšší než dovednost hráče 0, hráč 2 vyhrává. Výsledná řada je [2,3,4,1,0].
Hráči 2 a 3 hrají hru, protože dovednost hráče 2 je vyšší než dovednost hráče 3, hráč 2 vyhrává. Výsledná řada je [2,4,1,0,3].

Hráč 2 vyhrál k = 2 hry po sobě, takže vítězem je hráč 2.

Příklad 2:

Vstup: skills = [2,5,4], k = 3
Výstup: 1
Vysvětlení:
Zpočátku je řada hráčů [0,1,2]. Probíhá následující proces:

Hráči 0 a 1 hrají hru, protože dovednost hráče 1 je vyšší než dovednost hráče 0, hráč 1 vyhrává. Výsledná řada je [1,2,0].
Hráči 1 a 2 hrají hru, protože dovednost hráče 1 je vyšší než dovednost hráče 2, hráč 1 vyhrává. Výsledná řada je [1,0,2].
Hráči 1 a 0 hrají hru, protože dovednost hráče 1 je vyšší než dovednost hráče 0, hráč 1 vyhrává. Výsledná řada je [1,2,0].

Hráč 1 vyhrál k = 3 hry po sobě, takže vítězem je hráč 1.

Omezení:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Všechna celá čísla v skills jsou jedinečná.


Je dáno celočíselné pole nums a nezáporné celé číslo k. Řada celých čísel seq se nazývá dobrá, pokud existuje nejvýše k indexů i v rozsahu [0, seq.length - 2] takových, že seq[i] != seq[i + 1].
Vraťte maximální možnou délku dobré podposloupnosti nums.

Příklad 1:

Vstup: nums = [1,2,1,1,3], k = 2
Výstup: 4
Vysvětlení:
Maximální délka podposloupnosti je [1,2,1,1,3].

Příklad 2:

Vstup: nums = [1,2,3,4,5,1], k = 0
Výstup: 2
Vysvětlení:
Maximální délka podposloupnosti je [1,2,3,4,5,1].

Omezení:

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

Je dáno celočíselné pole nums a nezáporné celé číslo k. Řada celých čísel seq se nazývá dobrá, pokud existuje nejvýše k indexů i v rozsahu [0, seq.length - 2] takových, že seq[i] != seq[i + 1].
Vraťte maximální možnou délku dobré podposloupnosti nums.

Příklad 1:

Vstup: nums = [1,2,1,1,3], k = 2
Výstup: 4
Vysvětlení:
Maximální délka podsekvence je [1,2,1,1,3].

Příklad 2:

Vstup: nums = [1,2,3,4,5,1], k = 0
Výstup: 2
Vysvětlení:
Maximální délka podsekvence je [1,2,3,4,5,1].

Omezení:

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

Dostanete celočíselné pole nums a nezáporné celé číslo k. Posloupnost celých čísel seq se nazývá dobrá, pokud existuje nejvýše k indexů i v rozsahu [0, délka sekvence - 2] tak, že seq[i] != seq[i + 1].
Vraťte maximální možnou délku dobré podposloupnost num.

Příklad 1:

Vstup: nums = [1,2,1,1,3], k = 2
Výstup: 4
Vysvětlení:
Maximální délka dílčí sekvence je [1,2,1,1,3].

Příklad 2:

Vstup: nums = [1,2,3,4,5,1], k = 0
Výstup: 2
Vysvětlení:
Maximální délka dílčí sekvence je 2, například [1,1] nebo [2,2].

Omezení:

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


Máte dané celočíselné pole nums. V jedné operaci můžete přičíst nebo odečíst 1 z libovolného prvku pole nums.
Vraťte minimální počet operací k tomu, aby všechny prvky pole nums byly dělitelné 3.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 3
Vysvětlení:
Všechny prvky pole mohou být učiněny dělitelnými 3 použitím 3 operací:

Odečtení 1 od 1.
Přičtení 1 k 2.
Odečtení 1 od 4.

Příklad 2:

Vstup: nums = [3,6,9]
Výstup: 0

Omezení:

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

Dostanete celočíselné pole nums. V jedné operaci můžete přidat nebo odečíst 1 od libovolného prvku nums.
Vraťte minimální počet operací, aby byly všechny prvky num dělitelné 3.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 3
Vysvětlení:
Všechny prvky pole mohou být dělitelné 3 pomocí 3 operací:

Odečíst 1 od 1.
Přidejte 1 ke 2.
Odečtěte 1 od 4.

Příklad 2:

Vstup: nums = [3,6,9]
Výstup: 0

Omezení:

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


Máte binární pole nums.
Na poli můžete provést následující operaci libovolně mnohokrát (případně i nula):

Vyberte libovolné 3 po sobě jdoucí prvky z pole a všechny je otočte.

Otočení prvku znamená změnu jeho hodnoty z 0 na 1 a z 1 na 0.
Vraťte minimální počet operací potřebných k tomu, aby všechny prvky v nums byly rovny 1. Pokud to není možné, vraťte -1.

Příklad 1:

Vstup: nums = [0,1,1,1,0,0]
Výstup: 3
Vysvětlení:
Můžeme provést následující operace:

Vyberte prvky na indexech 0, 1 a 2. Výsledné pole je nums = [1,0,0,1,0,0].
Vyberte prvky na indexech 1, 2 a 3. Výsledné pole je nums = [1,1,1,0,0,0].
Vyberte prvky na indexech 3, 4 a 5. Výsledné pole je nums = [1,1,1,1,1,1].

Příklad 2:

Vstup: nums = [0,1,1,1]
Výstup: -1
Vysvětlení:
Není možné udělat všechny prvky rovné 1.

Omezení:

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

Je vám přiděleno binární pole nums.
S polem můžete provést následující operaci libovolným počtem opakování (možná nula):

Vyberte libovolné 3 po sobě jdoucí prvky z pole a všechny je invertujte.

Překlopení elementu znamená změnu jeho hodnoty z 0 na 1 a z 1 na 0.
Vrátí minimální počet operací potřebných k tomu, aby se všechny prvky v číslech rovnaly 1. Pokud to není možné, vraťte hodnotu -1.

Příklad 1:

Vstup: nums  = [0,1,1,1,0,0]
Výstup: 3
Vysvětlení:
Můžeme provádět následující operace:

Vyberte prvky v indexech 0, 1 a 2. Výsledná matice je nums = [1,0,0,1,0,0].
Vyberte prvky v indexech 1, 2 a 3. Výsledná matice je nums = [1,1,1,0,0,0].
Vyberte prvky v indexech 3, 4 a 5. Výsledná matice je nums = [1,1,1,1,1].

Příklad 2:

Vstup: nums  = [0,1,1,1]
Výstup: -1
Vysvětlení:
Není možné, aby se všechny prvky rovnaly 1.

Omezení:

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

Dostanete binární pole nums.
Následující operaci můžete na poli provést libovolněkrát (možná nula):

Vyberte libovolné 3 po sobě jdoucí prvky z pole a otočte je všechny.

Překlopení prvku znamená změnu jeho hodnoty z 0 na 1 a z 1 na 0.
Vrátí minimální počet operací potřebných k tomu, aby se všechny prvky v číslech rovnaly 1. Pokud to není možné, vraťte -1.

Příklad 1:

Vstup: nums = [0,1,1,1,0,0]
Výstup: 3
Vysvětlení:
Můžeme provádět následující operace:

Vyberte prvky na indexech 0, 1 a 2. Výsledné pole je nums = [1,0,0,1,0,0].
Vyberte prvky na indexech 1, 2 a 3. Výsledné pole je nums = [1,1,1,0,0,0].
Vyberte prvky na indexech 3, 4 a 5. Výsledné pole je nums = [1,1,1,1,1,1].

Příklad 2:

Vstup: nums = [0,1,1,1]
Výstup: -1
Vysvětlení:
Není možné, aby se všechny prvky rovnaly 1.

Omezení:

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


Je dáno celé číslo n a 2D pole requirements, kde requirements[i] = [end_i, cnt_i] představuje koncový index a počet inverzí každého požadavku.
Dvojice indexů (i, j) z celočíselného pole nums se nazývá inverze, jestliže:

i < j a nums[i] > nums[j]

Vraťte počet permutací perm z [0, 1, 2, ..., n - 1] takových, že pro všechny požadavky[i] má perm[0..end_i] přesně cnt_i inverzí.
Protože odpověď může být velmi rozsáhlá, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: n = 3, požadavky = [[2,2],[0,0]].
Výstup: 2
Vysvětlení:
Dvě permutace jsou:

[2, 0, 1]

Prefix [2, 0, 1] má inverze (0, 1) a (0, 2).
Prefix [2] má 0 inverzí.

[1, 2, 0]

Prefix [1, 2, 0] má inverze (0, 2) a (1, 2).
Prefix [1] má 0 inverzí.

Příklad 2:

Vstup: n = 3, požadavky = [[2,2],[1,1],[0,0]].
Výstup: 1
Vysvětlení:
Jediná vyhovující permutace je [2, 0, 1]:

Prefix [2, 0, 1] má inverze (0, 1) a (0, 2).
Prefix [2, 0] má inverzi (0, 1).
Prefix [2] má 0 inverzí.

Příklad 3:

Vstup: n = 2, požadavky = [[0,0],[1,0]].
Výstup: 1
Vysvětlení:
Jediná vyhovující permutace je [0, 1]:

Prefix [0] má 0 inverzí.
Prefix [0, 1] má inverzi (0, 1).

Omezení:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
Vstup je generován tak, že existuje alespoň jedno i, které je takové, že end_i == n - 1.
Vstup je generován tak, že všechna end_i jsou jedinečná.

Dostanete celé číslo n a požadavky na 2D pole, kde požadavky[i] = [end_i, cnt_i] představují koncový index a počet inverzí každého požadavku.
Dvojice indexů (i, j) z celočíselného pole nums se nazývá inverze, pokud:

i < ja nums[i] > nums[j]

Vraťte počet permutací perm [0, 1, 2, ..., n - 1] tak, že pro všechny požadavky[i] má perm[0..end_i] přesně cnt_i inverze.
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: n = 3, požadavky = [[2,2],[0,0]]
Výstup: 2
Vysvětlení:
Tyto dvě permutace jsou:

[2, 0, 1]

Prefix [2, 0, 1] má inverze (0, 1) a (0, 2).
Prefix [2] má 0 inverzí.

[1, 2, 0]

Prefix [1, 2, 0] má inverze (0, 2) a (1, 2).
Prefix [1] má 0 inverzí.

Příklad 2:

Vstup: n = 3, požadavky = [[2,2],[1,1],[0,0]]
Výstup: 1
Vysvětlení:
Jediná uspokojivá permutace je [2, 0, 1]:

Prefix [2, 0, 1] má inverze (0, 1) a (0, 2).
Prefix [2, 0] má inverzi (0, 1).
Prefix [2] má 0 inverzí.

Příklad 3:

Vstup: n = 2, požadavky = [[0,0],[1,0]]
Výstup: 1
Vysvětlení:
Jediná uspokojivá permutace je [0, 1]:

Prefix [0] má 0 inverzí.
Prefix [0, 1] má inverzi (0, 1).

Omezení:

2 <= n <= 300
1 <= požadavky.length <= n
požadavky[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
Vstup je generován tak, že existuje alespoň jedno i takové, že end_i == n - 1.
Vstup je generován tak, že všechny end_i jsou jedinečné.