Máte dané pole `nums` s indexy od 0, které se skládá z kladných čísel.
Na pole můžete provádět následující operaci libovolněkrát:

Zvolte celé číslo `i` tak, že 0 <= i < nums.length - 1 a nums[i] <= nums[i + 1]. Nahraďte prvek nums[i + 1] hodnotou nums[i] + nums[i + 1] a smažte prvek nums[i] z pole.

Vrátí hodnotu největšího prvku, který můžete v konečném poli získat.

Příklad 1:

Vstup: nums = [2,3,7,9,3]
Výstup: 21
Vysvětlení: Na pole můžeme aplikovat následující operace:
- Zvolte i = 0. Výsledné pole bude nums = [5,7,9,3].
- Zvolte i = 1. Výsledné pole bude nums = [5,16,3].
- Zvolte i = 0. Výsledné pole bude nums = [21,3].
Největší prvek v konečném poli je 21. Lze ukázat, že větší prvek nelze získat.

Příklad 2:

Vstup: nums = [5,3,3]
Výstup: 11
Vysvětlení: Na pole můžeme provést následující operace:
- Zvolte i = 1. Výsledné pole bude nums = [5,6].
- Zvolte i = 0. Výsledné pole bude nums = [11].
V konečném poli je pouze jeden prvek, což je 11.

Omezení:

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

Dostanete 0-indexované pole nums skládající se z kladných celých čísel.
Následující operaci můžete na poli provést libovolněkrát:

Vyberte celé číslo i takové, že 0 <= i < nums.length - 1 a nums[i] <= nums[i + 1]. Nahraďte prvek nums[i + 1] za nums[i] + nums[i + 1] a odstraňte prvek nums[i] z pole.

Vrátí hodnotu největšího prvku, který můžete získat v konečném poli.

Příklad 1:

Vstup: nums = [2,3,7,9,3]
Výstup: 21
Vysvětlení: Na pole můžeme použít následující operace:
- Zvolte i = 0. Výsledné pole bude nums = [5,7,9,3].
- Zvolte i = 1. Výsledné pole bude nums = [5,16,3].
- Zvolte i = 0. Výsledné pole bude nums = [21,3].
Největší prvek v konečném poli je 21. Lze ukázat, že nemůžeme získat větší prvek.

Příklad 2:

Vstup: nums = [5,3,3]
Výstup: 11
Vysvětlení: S polem můžeme provádět následující operace:
- Zvolte i = 1. Výsledné pole bude nums = [5,6].
- Zvolte i = 0. Výsledné pole bude nums = [11].
Ve finálním poli je pouze jeden prvek, kterým je 11.

Omezení:

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

Je dáno pole nums s indexem 0, které se skládá z celých kladných čísel.
S tímto polem můžete libovolně mnohokrát provést následující operaci:

Zvolte takové celé číslo i, aby 0 <= i < nums.length - 1 a nums[i] <= nums[i + 1]. Nahraďte prvek nums[i + 1] prvkem nums[i] + nums[i + 1] a prvek nums[i] z pole vymažte.

Vraťte hodnotu největšího prvku, kterou lze v konečném poli získat.

Příklad 1:

Vstup: nums = [2,3,7,9,3]
Výstup: 21
Vysvětlení: Na pole můžeme použít následující operace:
- Výsledné pole bude nums = [5,7,9,3].
- Zvolte i = 1. Výsledné pole bude nums = [5,16,3].
- Zvolte i = 0. Výsledné pole bude nums = [21,3].
Největší prvek výsledného pole je 21. Lze ukázat, že větší prvek nemůžeme získat.

Příklad 2:

Vstup: nums = [5,3,3]
Výstup: 11
Vysvětlení: S polem můžeme provádět následující operace:
- Zvolte i = 1. Výsledné pole bude nums = [5,6].
- Zvolte i = 0. Výsledné pole bude nums = [11].
Ve výsledném poli je pouze jeden prvek, a to 11.

Omezení:

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


Je dán celé číslo n. Říkáme, že dvě celá čísla x a y tvoří dvojici prvočísel pokud platí:

1 <= x <= y <= n
x + y == n
x a y jsou prvočísla

Vraťte 2D setříděný seznam dvojic prvočísel [x_i, y_i]. Seznam by měl být seřazený vzestupně podle x_i. Pokud žádné dvojice prvočísel neexistují, vraťte prázdné pole.
Poznámka: Prvočíslo je přirozené číslo větší než 1, které má pouze dva dělitele, samo sebe a 1.

Příklad 1:

Vstup: n = 10
Výstup: [[3,7],[5,5]]
Vysvětlení: V tomto příkladu existují dvě dvojice prvočísel, které splňují kritéria. Tyto dvojice jsou [3,7] a [5,5], a vracíme je v seřazeném pořadí, jak je popsáno v zadání úlohy.

Příklad 2:

Vstup: n = 2
Výstup: []
Vysvětlení: Můžeme ukázat, že neexistuje dvojice prvočísel, která by dala součet 2, takže vracíme prázdné pole.

Omezení:

1 <= n <= 10^6

Je vám dáno celé číslo n. Říkáme, že dvě celá čísla x a y tvoří dvojici prvočísel, pokud:

1 <= x <= y <= n
x + y == n
x a y jsou prvočísla

Vraťte 2D seřazený seznam dvojic prvočísel [x_i, y_i]. Seznam by měl být řazen ve vzestupném pořadí x_i. Pokud neexistují žádné dvojice prvočísel, vraťte prázdné pole.
Poznámka: Prvočíslo je přirozené číslo větší než 1 s pouze dvěma faktory, samo sebou a 1.

Příklad 1:

Vstup: n = 10
Výstup: [[3,7],[5,5]]
Vysvětlení: V tomto příkladu existují dva prvočísla, které splňují kritéria.
Tyto dvojice jsou [3,7] a [5,5] a vracíme je v seřazeném pořadí, jak je popsáno v zadání problému.

Příklad 2:

Vstup: n = 2
Výstup: []
Vysvětlení: Můžeme ukázat, že neexistuje žádný pár prvočísel, který dává součet 2, takže vrátíme prázdné pole.

Omezení:

1 <= n <= 10^6


Ve firmě je n zaměstnanců, očíslovaných od 0 do n - 1. Každý zaměstnanec i pracoval hodiny[i] hodin ve firmě.
Firma vyžaduje, aby každý zaměstnanec pracoval alespoň target hodin.
Máte zadané 0-indexované pole nezáporných celých čísel hours délky n a nezáporné celé číslo target.
Vraťte celé číslo označující počet zaměstnanců, kteří pracovali alespoň target hodin.

Příklad 1:

Vstup: hours = [0,1,2,3,4], target = 2
Výstup: 3
Vysvětlení: Společnost chce, aby každý zaměstnanec pracoval alespoň 2 hodiny.
- Zaměstnanec 0 pracoval 0 hodin a nesplnil cíl.
- Zaměstnanec 1 pracoval 1 hodinu a nesplnil cíl.
- Zaměstnanec 2 pracoval 2 hodiny a splnil cíl.
- Zaměstnanec 3 pracoval 3 hodiny a splnil cíl.
- Zaměstnanec 4 pracoval 4 hodiny a splnil cíl.
Jsou 3 zaměstnanci, kteří splnili cíl.

Příklad 2:

Vstup: hours = [5,1,4,2,2], target = 6
Výstup: 0
Vysvětlení: Společnost chce, aby každý zaměstnanec pracoval alespoň 6 hodin.
Jsou 0 zaměstnanci, kteří splnili cíl.

Omezení:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

Ve firmě je n zaměstnanců, kteří jsou očíslováni od 0 do n - 1. Každý zaměstnanec odpracoval ve firmě několik hodin.
Společnost vyžaduje, aby každý zaměstnanec pracoval alespoň v cílovém počtu hodin.
Dostanete pole s indexem 0 nezáporných celých čísel, hodin délky n a nezáporný celočíselný cíl.
Vrátí celé číslo označující počet zaměstnanců, kteří odpracovali alespoň cílové hodiny.

Příklad 1:

Vstup: hours = [0,1,2,3,4], target = 2
Výstup: 3
Vysvětlení: Společnost chce, aby každý zaměstnanec pracoval alespoň 2 hodiny.
- Zaměstnanec 0 pracoval 0 hodin a nesplnil cíl.
- Zaměstnanec 1 pracoval 1 hodinu a nesplnil cíl.
- Zaměstnanec 2 pracoval 2 hodiny a splnil cíl.
- Zaměstnanec 3 pracoval 3 hodiny a splnil cíl.
- Zaměstnanec 4 pracoval 4 hodiny a splnil cíl.
Cíl splnili 3 zaměstnanci.

Příklad 2:

Vstup: hours = [5,1,4,2,2], target = 6
Výstup: 0
Vysvětlení: Společnost chce, aby každý zaměstnanec pracoval alespoň 6 hodin.
Cíl splnilo 0 zaměstnanců.

Omezení:

1 <= n == hodiny.length <= 50
0 <= hours[i], target <= 10^5

Ve společnosti je n zaměstnanců, číslovaných od 0 do n - 1. Každý zaměstnanec i ve společnosti odpracoval hodiny[i] hodin.
Společnost vyžaduje, aby každý zaměstnanec pracoval alespoň cílových hodin.
Získáte 0-indexované pole nezáporných celých čísel hodin délky n a cíl nezáporných celých čísel.
Vraťte celé číslo označující počet zaměstnanců, kteří odpracovali alespoň cílových hodin.

Příklad 1:

Vstup: hodiny = [0,1,2,3,4], cíl = 2
Výstup: 3
Vysvětlení: Společnost chce, aby každý zaměstnanec pracoval alespoň 2 hodiny.
- Zaměstnanec 0 pracoval 0 hodin a nesplnil cíl.
- Zaměstnanec 1 pracoval 1 hodinu a nesplnil cíl.
- Zaměstnanec 2 pracoval 2 hodiny a splnil cíl.
- Zaměstnanec 3 pracoval 3 hodiny a splnil cíl.
- Zaměstnanec 4 pracoval 4 hodiny a splnil cíl.
Cíl splnili 3 zaměstnanci.

Příklad 2:

Vstup: hodiny = [5,1,4,2,2], cíl = 6
Výstup: 0
Vysvětlení: Společnost chce, aby každý zaměstnanec pracoval alespoň 6 hodin.
Cíl splnilo 0 zaměstnanců.

Omezení:

1 <= n == hodin.length <= 50
0 <= hodin[i], cíl <= 10^5


Zadané tři řetězce a, b a c je vaším úkolem najít řetězec, který má minimální délku a obsahuje všechny tři řetězce jako podřetězce.
Pokud existuje více takových řetězců, vraťte lexikograficky nejmenší.
Vraťte řetězec označující odpověď na problém.
Poznámky

Řetězec a je lexikograficky menší než řetězec b (stejné délky), pokud na první pozici, kde se a a b liší, má řetězec a písmeno, které se vyskytuje dříve v abecedě než odpovídající písmeno v b.
Podřetězec je souvislá sekvence znaků v řetězci.

Příklad 1:

Vstup: a = "abc", b = "bca", c = "aaa"
Výstup: "aaabca"
Vysvětlení: Ukážeme, že "aaabca" obsahuje všechny zadané řetězce: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Lze ukázat, že délka výsledného řetězce by byla minimálně 6 a „aaabca“ je lexikograficky nejmenší.
Příklad 2:

Vstup: a = "ab", b = "ba", c = "aba"
Výstup: "aba"
Vysvětlení: Ukážeme, že řetězec "aba" obsahuje všechny zadané řetězce: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Protože délka c je 3, délka výsledného řetězce by byla alespoň 3. Lze ukázat, že "aba" je lexikograficky nejmenší.

Omezení:

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

Dáno je tři řetězce a, b a c, vaším úkolem je najít řetězec, který má minimální délku a obsahuje všechny tři řetězce jako podřetězce.
Pokud existuje více takových řetězců, vraťte ten lexikograficky nejmenší.
Vraťte řetězec označující odpověď na problém.
Poznámky

Řetězec a je lexikograficky menší než řetězec b (stejné délky), pokud v první pozici, kde se a a b liší, má řetězec a písmeno, které se objevuje dříve v abecedě než odpovídající písmeno v b.
Podřetězec je souvislá posloupnost znaků v rámci řetězce.

Příklad 1:

Vstup: a = "abc", b = "bca", c = "aaa"
Výstup: "aaabca"
Vysvětlení: Ukážeme, že "aaabca" obsahuje všechny dané řetězce: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Může být ukázáno, že délka výsledného řetězce by byla alespoň 6 a "aaabca" je lexikograficky nejmenší.
Příklad 2:

Vstup: a = "ab", b = "ba", c = "aba"
Výstup: "aba"
Vysvětlení: Ukážeme, že řetězec "aba" obsahuje všechny dané řetězce: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Protože délka c je 3, délka výsledného řetězce by byla alespoň 3. Může být ukázáno, že "aba" je lexikograficky nejmenší.

Omezení:

1 <= a.length, b.length, c.length <= 100
a, b, c se skládají pouze z malých písmen anglické abecedy.

Máte-li tři řetězce a, b a c, vaším úkolem je najít řetězec, který má minimální délku a obsahuje všechny tři řetězce jako podřetězce.
Pokud existuje více takových řetězců, vrátí lexikograficky nejmenší z nich.
Vrátí řetězec označující odpověď na problém.
Poznámky

Řetězec a je lexikograficky menší než řetězec b (stejné délky), pokud na první pozici, kde se liší a a b, má řetězec a písmeno, které se v abecedě vyskytuje dříve než odpovídající písmeno v b.
Podřetězec je souvislá posloupnost znaků v řetězci.

Příklad 1:

Vstup: a = "abc", b = "bca", c = "aaa"
Výstup: "aaabca"
Vysvětlení: Ukážeme, že "aaabca" obsahuje všechny dané řetězce: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Lze ukázat, že délka výsledného řetězce by byla minimálně 6 a "aaabca" je lexikograficky nejmenší.
Příklad 2:

Vstup: a = "ab", b = "ba", c = "aba"
Výstup: "aba"
Vysvětlení: Ukážeme, že řetězec "aba" obsahuje všechny dané řetězce: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Protože délka c je 3, délka výsledného řetězce by byla alespoň 3. Lze ukázat, že "aba" je lexikograficky nejmenší.

Omezení:

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


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

Vyberte libovolnou podposloupnost velikosti k z pole a snižte všechny její prvky o 1.

Vraťte true, pokud můžete všechny prvky pole nastavit na 0, jinak vraťte false. Podposloupnost je souvislá neprázdná část pole.

Příklad 1:

Vstup: nums = [2,2,3,1,1,0], k = 3
Výstup: true
Vysvětlení: Můžeme provést následující operace:
- Vyberte podposloupnost [2,2,3]. Výsledné pole bude nums = [1,1,2,1,1,0].
- Vyberte podposloupnost [2,1,1]. Výsledné pole bude nums = [1,1,1,0,0,0].
- Vyberte podposloupnost [1,1,1]. Výsledné pole bude nums = [0,0,0,0,0,0].

Příklad 2:

Vstup: nums = [1,3,1,1], k = 2
Výstup: false
Vysvětlení: Není možné nastavit všechny prvky pole na 0.

Omezení:

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

Dostanete 0-indexované celé číslo pole nums a kladné celé číslo k.
Následující operaci můžete na pole použít kolikrát:

Vyberte libovolné podpole o velikosti k z pole a snižte všechny jeho prvky o 1.

Vraťte hodnotu true, pokud můžete nastavit všechny prvky pole na 0, v opačném případě na hodnotu false.
Podpole je souvislá neprázdná část pole.

Příklad 1:

Vstup: nums = [2,2,3,1,1,0], k = 3
Výstup: pravda
Vysvětlení: Můžeme provádět následující operace:
- Vyberte podpole [2,2,3]. Výsledné pole bude nums = [1,1,2,1,1,0].
- Vyberte podpole [2,1,1]. Výsledné pole bude nums = [1,1,1,0,0,0].
- Vyberte podpole [1,1,1]. Výsledné pole bude nums = [0,0,0,0,0,0].

Příklad 2:

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

Omezení:

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

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

Z pole vyberte libovolné podpole o velikosti k a zmenšete všechny jeho prvky o 1.

Vrátí hodnotu true, pokud můžete všechny prvky pole nastavit tak, aby se rovnaly 0, nebo false v opačném případě.
Podpole je souvislá neprázdná část pole.

Příklad 1:

Vstup: nums = [2,2,3,1,1,0], k = 3
Výstup: true
Vysvětlení: Můžeme provést následující operace:
- Vyberte podpole [2,2,3]. Výsledná matice bude mít nums = [1,1,2,1,1,0].
- Vyberte podpole [2,1,1]. Výsledné pole bude mít nums = [1,1,1,0,0,0].
- Vyberte podpole [1,1,1]. Výsledné pole bude mít nums = [0,0,0,0,0,0].

Příklad 2:

Vstup: nums = [1,3,1,1], k = 2
Výstup: false
Vysvětlení: Není možné, aby všechny prvky pole byly rovny 0.

Omezení:

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


Dáno-li řetězec s a celé číslo k, rozdělte s na k podřetězců tak, aby byl minimalizován součet změn počtu písmen potřebných k přeměně každého podřetězce na semi-palindrom.
Vrátí celé číslo označující minimální požadovaný počet změn písmen.
Poznámky

Řetězec je palindrom, pokud jej lze číst stejným způsobem zleva doprava a zprava doleva.
Řetězec s délkou len je považován za semi-palindrom, pokud existuje kladné celé číslo d takové, že 1 <= d < len a len % d == 0, a pokud vezmeme indexy, které mají stejné modulo podle d, tvoří palindrom. Například "aa", "aba", "adbgad" a "abab" jsou semi-palindrom a "a", "ab" a "abca" nejsou.
Podřetězec je souvislá posloupnost znaků v řetězci.

Příklad 1:

Vstup: s = "abcac", k = 2
Výstup: 1
Vysvětlení: S můžeme rozdělit na podřetězce "ab" a "cac". Řetězec "cac" je již semi-palindrom. Pokud změníme "ab" na "aa", stane se z toho semi-palindrom s d = 1.
Lze ukázat, že neexistuje způsob, jak rozdělit řetězec "abcac" na dva semi-palindromové podřetězce. Odpověď by tedy byla alespoň 1.
Příklad 2:

Vstup: s = "abcdef", k = 2
Výstup: 2
Vysvětlení: Můžeme jej rozdělit na podřetězce "abc" a "def". Každý z podřetězců "abc" a "def" vyžaduje jednu změnu, aby se stal semi-palindromem, takže potřebujeme celkem 2 změny, aby se všechny podřetězce staly semi-palindromem.
Lze ukázat, že daný řetězec nemůžeme rozdělit na dva podřetězce tak, že by to vyžadovalo méně než 2 změny.
Příklad 3:

Vstup: s = "aabbaa", k = 3
Výstup: 0
Vysvětlení: Můžeme jej rozdělit na podřetězce "aa", "bb" a "aa".
Řetězce "aa" a "bb" jsou již semipalindromy. Odpověď je tedy nula.

Omezení:

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

Daný řetězec sa celé číslo k, rozdělí s na k podřetězců tak, že součet počtu změn písmen požadovaných k přeměně každého podřetězce na polopalindrom je minimalizován.
Vrátí celé číslo označující minimální počet požadovaných změn písmen.
Poznámky

Řetězec je palindrom, pokud jej lze číst stejným způsobem zleva doprava a zprava doleva.
Řetězec s délkou len je považován za semipalindrom, pokud existuje kladné celé číslo d takové, že 1 <= d < len a len % d == 0, a vezmeme-li indexy, které mají stejné modulo jako d, tvoří palindrom. Například „aa“, „aba“, „adbgad“ a „abab“ jsou semipalindrom a „a“, „ab“ a „abca“ nikoli.
Podřetězec je souvislá sekvence znaků v řetězci.

Příklad 1:

Vstup: s = "abcac", k = 2
Výstup: 1
Vysvětlení: S můžeme rozdělit na podřetězce "ab" a "cac". Struna "cac" je již polopalindrom. Pokud změníme "ab“ na "aa“, stane se semipalindromem s d = 1.
Lze ukázat, že neexistuje způsob, jak rozdělit řetězec "abcac" na dva semi-palindromové podřetězce. Odpověď by tedy byla alespoň 1.
Příklad 2:

Vstup: s = "abcdef", k = 2
Výstup: 2
Vysvětlení: Můžeme to rozdělit na podřetězce "abc" a "def". Každý z podřetězců "abc" a "def" vyžaduje jednu změnu, aby se stal semipalindromem, takže potřebujeme celkem 2 změny, aby se všechny podřetězce staly semipalindromem.
Dá se ukázat, že daný řetězec nemůžeme rozdělit na dva podřetězce tak, aby to vyžadovalo méně než 2 změny.
Příklad 3:

Vstup: s = "aabbaa", k = 3
Výstup: 0
Vysvětlení: Můžeme to rozdělit na podřetězce "aa", "bb" a "aa".
Struny "aa" a "bb" jsou již semipalindromy. Odpověď je tedy nulová.

Omezení:

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

Zadaný řetězec s a celé číslo k, rozdělte s do k podřetězců tak, aby součet počtu změn písmen potřebných k tomu, aby se každý podřetězec změnil na semi-palindrom, byl minimální.
Vrátí celé číslo označující minimální počet potřebných změn písmen.
Poznámky

Řetězec je palindrom, pokud jej lze číst stejně zleva doprava i zprava doleva.
Řetězec s délkou len je považován za semi-palindrom, pokud existuje kladné celé číslo d tak, že 1 <= d < len a len % d == 0 a pokud vezmeme indexy, které mají stejné modulo podle d, tvoří palindrom. Například „aa“, „aba“, „adbgad“ a „abab“ jsou semi-palindromy a „a“, „ab“ a „abca“ nejsou.
Podřetězec je souvislá posloupnost znaků v řetězci.

Příklad 1:

Vstup: s = "abcac", k = 2
Výstup: 1
Vysvětlení: Můžeme rozdělit s na podřetězce „ab“ a „cac“. Řetězec „cac“ je již semi-palindrom. Pokud změníme „ab“ na „aa“, stane se semi-palindromem s d = 1.
Lze ukázat, že neexistuje žádný způsob, jak rozdělit řetězec „abcac“ na dva semi-palindromové podřetězce. Odpověď by tedy byla alespoň 1.
Příklad 2:

Vstup: s = "abcdef", k = 2
Výstup: 2
Vysvětlení: Můžeme je rozdělit na podřetězce „abc“ a „def“. Každý z podřetězců „abc“ a „def“ vyžaduje jednu změnu, aby se stal semi-palindromem, takže potřebujeme celkem 2 změny, aby se všechny podřetězce staly semi-palindromy.
Lze ukázat, že daný řetězec nelze rozdělit na dva podřetězce takovým způsobem, že by to vyžadovalo méně než 2 změny.
Příklad 3:

Vstup: s = "aabbaa", k = 3
Výstup: 0
Vysvětlení: Můžeme je rozdělit na podřetězce „aa“, „bb“ a „aa“.
Řetězce „aa“ a „bb“ jsou již semi-palindromy. Odpověď je tedy nula.

Omezení:

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


Je dáno pole řetězců words a znak separator, rozdělte každý řetězec v words podle separator.
Vrátíte pole řetězců obsahující nové řetězce vytvořené po rozdělení, s výjimkou prázdných řetězců.
Poznámky

separator se používá k určení, kde by mělo dojít k rozdělení, ale není zahrnut jako součást výsledných řetězců.
Rozdělení může mít za následek více než dva řetězce.
Výsledné řetězce musí zachovat stejné pořadí, v jakém byly původně zadány.

Příklad 1:

Vstup: words = ["one.two.three","four.five","six"], separator = "."
Výstup: ["one","two","three","four","five","six"]
Vysvětlení: V tomto příkladu rozdělujeme takto:

"one.two.three" se rozdělí na "one", "two", "three"
"four.five" se rozdělí na "four", "five"
"six" se rozdělí na "six"

Výsledné pole je tedy ["one","two","three","four","five","six"].
Příklad 2:

Vstup: words = ["$easy$","$problem$"], separator = "$"
Výstup: ["easy","problem"]
Vysvětlení: V tomto příkladu rozdělujeme takto:

"$easy$" se rozdělí na "easy" (s vyloučením prázdných řetězců)
"$problem$" se rozdělí na "problem" (s vyloučením prázdných řetězců)

Výsledné pole je tedy ["easy","problem"].

Příklad 3:

Vstup: words = ["|||"], separator = "|"
Výstup: []
Vysvětlení: V tomto příkladu výsledné rozdělení "|||" bude obsahovat pouze prázdné řetězce, takže vracíme prázdné pole [].

Omezení:

1 <= words.length <= 100
1 <= words[i].length <= 20
znaky v words[i] jsou buď malá písmena anglické abecedy nebo znaky z řetězce ".,|$#@" (bez uvozovek)
separator je znak z řetězce ".,|$#@" (bez uvozovek)

Na základě pole řetězců slov a oddělovače znaků rozdělte každý řetězec na slova oddělovačem.
Vrátí pole řetězců obsahující nové řetězce vytvořené po rozdělení, s výjimkou prázdných řetězců.
Poznámky

Oddělovač se používá k určení, kde by mělo dojít k rozdělení, ale není zahrnut jako součást výsledných řetězců.
Rozdělení může mít za následek více než dva řetězce.
Výsledné řetězce si musí zachovat stejné pořadí, v jakém byly původně zadány.

Příklad 1:

Vstup: words = ["one.two.three","four.five","six"], separator = "."
Výstup: ["one","two","three","four","five","six"]
Vysvětlení: V tomto příkladu jsme se rozdělili následovně:

"one.two.three" se rozdělí na "one", "two", "three"
"four.five" se dělí na "four", "five"
"six" se rozdělí na "six"

Výsledné pole je tedy ["one","two","three","four","five","six"].
Příklad 2:

Vstup: words = ["$easy$","$problem$"], separator = "$"
Výstup: ["easy","problem"]
Vysvětlení: V tomto příkladu jsme se rozdělili následovně:

"$easy$" se rozdělí na "easy" (kromě prázdných řetězců)
"$problem$" se rozdělí na "problem" (kromě prázdných řetězců)

Výsledné pole je tedy ["easy","problem"].

Příklad 3:

Vstup: words = ["|||"], separator = "|"
Výstup: []
Vysvětlení: V tomto příkladu bude výsledné rozdělení "|||" obsahovat pouze prázdné řetězce, takže vrátíme prázdné pole [].

Omezení:

1 <= words.length <= 100
1 <= words[i].length <= 20
znaky ve slovech[i] jsou buď malá anglická písmena nebo znaky z řetězce ".,|$#@" (kromě uvozovek)
separator je znak z řetězce ".,|$#@" (bez uvozovek)

Vzhledem k poli řetězců slov a oddělovači znaků rozdělte každý řetězec na slova oddělovačem.
Vrátí pole řetězců obsahujících nové řetězce vytvořené po rozdělení, s výjimkou prázdných řetězců.
Poznámky

separátor se používá k určení, kde by mělo dojít k rozdělení, ale není součástí výsledných řetězců.
Výsledkem rozdělení může být více než dva řetězce.
Výsledné řetězce musí zachovat stejné pořadí, v jakém byly původně zadány.

Příklad 1:

Vstup: words = ["one.two.three","four.five","six"], separator = "."
Výstup: ["one","two","three","four","five","six"]
Vysvětlení: V tomto příkladu jsme se rozdělili následovně:

"one.two.three" splits into "one", "two", "three"
"four.five" splits into "four", "five"
"six" splits into "six"

Výsledné pole je tedy ["one","two","three","four","five","six"].
Příklad 2:

Vstup: words = ["$easy$","$problem$"], separator = "$"
Výstup:["easy","problem"]
Vysvětlení: V tomto příkladu jsme rozdělili takto:

"$easy$" se rozdělí na "easy" (s výjimkou prázdných řetězců)
"$problem$" se rozdělí na "problem" (s výjimkou prázdných řetězců)

Výsledné pole je tedy ["snadné","problém"].

Příklad 3:

Vstup: words = ["|||"], separator = "|"
Výstup: []
Vysvětlení: V tomto příkladu výsledné rozdělení "|||" bude obsahovat pouze prázdné řetězce, takže vrátíme prázdné pole [].

Omezení:

1 <= words.length <= 100
1 <= words[i].length <= 20
znaky ve words[i] jsou buď malá anglická písmena, nebo znaky z řetězce ".,|$#@" (kromě uvozovek)
oddělovač je znak z řetězce ".,|$#@" (kromě uvozovek)


Jsou dána dvě kladná celá čísla n a x.
Vraťte počet způsobů, jak lze vyjádřit n jako součet x-té mocniny unikátních kladných celých čísel, jinými slovy počet sad unikátních celých čísel [n_1, n_2, ..., n_k], kde n = n_1^ x + n_2^x + ... + n_k^x.
Protože výsledek může být velmi velký, vraťte výsledek modulo 10^9 + 7.
Pokud například n = 160 a x = 3, jedním ze způsobů vyjádření n je n = 2^3 + 3^3 + 5^3.

Příklad 1:

Vstup: n = 10, x = 2
Výstup: 1
Vysvětlení: n můžeme vyjádřit takto: n = 3^2 + 1^2 = 10.
Lze ukázat, že je to jediný způsob, jak vyjádřit 10 jako součet druhé mocniny unikátních celých čísel.

Příklad 2:

Vstup: n = 4, x = 1
Výstup: 2
Vysvětlení: N můžeme vyjádřit následujícími způsoby:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Omezení:

1 <= n <= 300
1 <= x <= 5

Jsou dána dvě kladná celá čísla n a x.
Vraťte počet způsobů, jak lze vyjádřit n jako součet x^-té mocniny jedinečných kladných celých čísel, jinými slovy počet sad jedinečných celých čísel [n_1, n_2, ..., n_k], kde n = n_1^ x + n_2^x + ... + n_k^x.
Protože výsledek může být velmi velký, vraťte mu modulo 10^9 + 7.
Pokud například n = 160 a x = 3, jedním ze způsobů vyjádření n je n = 2^3 + 3^3 + 5^3.

Příklad 1:

Vstup: n = 10, x = 2
Výstup: 1
Vysvětlení: n můžeme vyjádřit takto: n = 3^2 + 1^2 = 10.
Lze ukázat, že je to jediný způsob, jak vyjádřit 10 jako součet druhé mocniny jedinečných celých čísel.

Příklad 2:

Vstup: n = 4, x = 1
Výstup: 2
Vysvětlení: N můžeme vyjádřit následujícími způsoby:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Omezení:

1 <= n <= 300
1 <= x <= 5


Daný binární řetězec s rozdělte řetězec na jeden nebo více podřetězců tak, aby každý podřetězec byl krásný.
Řetězec je krásný, pokud:

Neobsahuje úvodní nuly.
Je to binární reprezentace čísla, které je mocninou 5.

Vraťte minimální počet podřetězců v takovém oddílu. Pokud není možné rozdělit řetězce s na krásné podřetězce, vraťte -1.
Podřetězec je souvislá sekvence znaků v řetězci.

Příklad 1:

Vstup: s = "1011"
Výstup: 2
Vysvětlení: Daný řetězec můžeme rozdělit na ["101", "1"].
- Řetězec "101" neobsahuje úvodní nuly a je binární reprezentací celého čísla 5^1 = 5.
- Řetězec "1" neobsahuje úvodní nuly a je binární reprezentací celého čísla 5^0 = 1.
Lze ukázat, že 2 je minimální počet krásných podřetězců, na které lze s rozdělit.

Příklad 2:

Vstup: s = "111"
Výstup: 3
Vysvětlení: Daný řetězec můžeme rozdělit na ["1", "1", "1"].
- Řetězec "1" neobsahuje úvodní nuly a je binární reprezentací celého čísla 5^0 = 1.
Lze ukázat, že 3 je minimální počet krásných podřetězců, na které lze s rozdělit.

Příklad 3:

Vstup: s = "0"
Výstup: -1
Vysvětlení: Daný řetězec nemůžeme rozdělit na krásné podřetězce.

Omezení:

1 <= s.length <= 15
s[i] je buď '0' nebo '1'.

Máte-li binární řetězec s, rozdělte řetězec na jeden nebo více podřetězců tak, aby každý podřetězec byl krásný.
Řetězec je krásný, pokud:

Neobsahuje úvodní nuly.
Je to binární reprezentace čísla, které je mocninou 5.

Vrátí minimální počet podřetězců v takovém oddílu. Pokud není možné rozdělit řetězec s na krásné podřetězce, vraťte hodnotu -1.
Podřetězec je souvislá posloupnost znaků v řetězci.

Příklad 1:

Vstup: s = "1011"
Výstup: 2
Vysvětlení: Daný řetězec můžeme rozdělit na ["101", "1"].
- Řetězec "101" neobsahuje úvodní nuly a je binární reprezentací celého čísla 5^1 = 5.
- Řetězec "1" neobsahuje úvodní nuly a je binární reprezentací celého čísla 5^0 = 1.
Lze ukázat, že 2 je minimální počet krásných podřetězců, na které lze s rozdělit.

Příklad 2:

Vstup: s = "111"
Výstup: 3
Vysvětlení: Daný řetězec můžeme rozdělit na ["1", "1", "1"].
- Řetězec "1" neobsahuje úvodní nuly a je binární reprezentací celého čísla 5^0 = 1.
Lze ukázat, že 3 je minimální počet krásných podřetězců, na které lze s rozdělit.

Příklad 3:

Vstup: s = "0"
Výstup: -1
Vysvětlení: Daný řetězec nemůžeme rozdělit na krásné podřetězce.

Omezení:

1 <= s.length <= 15
s[i] is either '0' or '1'.


Máte daný řetězec word a pole řetězců forbidden.
Řetězec se nazývá platný, pokud žádný z jeho podřetězců není v forbidden.
Vrátit délku nejdelšího platného podřetězce řetězce word.
Podřetězec je souvislá posloupnost znaků v řetězci, případně prázdná.

Příklad 1:

Vstup: word = "cbaaaabc", forbidden = ["aaa","cb"]
Výstup: 4
Vysvětlení: V řetězci jsou 11 platných podřetězců: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" a "aabc". Délka nejdelšího platného podřetězce je 4.
Lze ukázat, že všechny ostatní podřetězce obsahují buď "aaa" nebo "cb" jako podřetězec.

Příklad 2:

Vstup: word = "leetcode", forbidden = ["de","le","e"]
Výstup: 4
Vysvětlení: V řetězci je 11 platných podřetězců: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" a "tcod". Délka nejdelšího platného podřetězce je 4.
Lze ukázat, že všechny ostatní podřetězce obsahují buď "de", "le" nebo "e" jako podřetězec.

Omezení:

1 <= word.length <= 10^5
word obsahuje pouze malá písmena anglické abecedy.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] obsahuje pouze malá písmena anglické abecedy.

Máte daný řetězec `word` a pole řetězců `forbidden`.
Řetězec je nazýván platným, pokud žádná z jeho podřetězců není obsažena v `forbidden`.
Vraťte délku nejdelšího platného podřetězce řetězce `word`.
Podřetězec je souvislá posloupnost znaků v řetězci, která může být i prázdná.

Příkl ad 1:

Vstup:
`word = "cbaaaabc"`, `forbidden = ["aaa","cb"]`
Výstup:
`4`
Vysvětlení:
V řetězci `word` je 11 platných podřetězců: `"c"`, `"b"`, `"a"`, `"ba"`, `"aa"`, `"bc" ,`"baa"`, `"aab"`, `"ab"`, "abc"` a `"aabc"`.
Délka nejdelšího platného podřetězce je 4.
Lze ukázat, že všechny ostatní podřetězce obsahují buď `"aaa"` nebo `"cb"` jako podřetězec.

Příklad 2:

Vstup: word = "leetcode", forbidden = ["de","le","e"]
Výstup: 4
Vysvětlení: V řetězci je 11 platných podřetězců: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" a "tcod". Délka nejdelšího platného podřetězce je 4.
Lze ukázat, že všechny ostatní podřetězce obsahují buď "de", "le" nebo "e" jako podřetězec.

Omezení:

1 <= word.length <= 10^5
word obsahuje pouze malá písmena anglické abecedy.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] obsahuje pouze malá písmena anglické abecedy.

Dostanete zakázané slovo řetězce a pole řetězců.
Řetězec se nazývá platný, pokud žádný z jeho podřetězců není přítomen v zakázaném.
Vrátí délku nejdelšího platného podřetězce slova řetězce.
Podřetězec je souvislá sekvence znaků v řetězci, případně prázdný.

Příklad 1:

Vstup: word = "cbaaaabc", forbidden = ["aaa","cb"]
Výstup: 4
Vysvětlení: Ve slově je 11 platných podřetězců: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" a "aabc". Délka nejdelšího platného podřetězce je 4.
Je možné ukázat, že všechny ostatní podřetězce obsahují buď "aaa" nebo "cb" jako podřetězec.
Příklad 2:

Vstup: word = "leetcode", forbidden = ["de","le","e"]
Výstup: 4
Vysvětlení: Ve slově je 11 platných podřetězců: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod", a "tcod". Délka nejdelšího platného podřetězce je 4.
Je možné ukázat, že všechny ostatní podřetězce obsahují buď "de", "le" nebo "e" jako podřetězec.

Omezení:

1 <= word.length <= 10^5
slovo se skládá pouze z malých anglických písmen.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
zakázané[i] se skládá pouze z malých anglických písmen.


Klávesnice vašeho notebooku je vadná a kdykoli na ni napíšete znak "i", obrátí se řetězec, který jste napsali. Psaní dalších znaků funguje podle očekávání.
Dostanete řetězec s indexovaný 0 a každý znak s zadáváte pomocí vadné klávesnice.
Vraťte poslední řetězec, který se bude zobrazovat na obrazovce vašeho notebooku.

Příklad 1:

Vstup: s = "string"
Výstup: "rtsng"
Vysvětlení:
Po zadání prvního znaku se na obrazovce objeví text "s".
Za druhým znakem je text "st".
Za třetím znakem je text "str".
Protože čtvrtý znak je "i", text se obrátí a změní se na "rts".
Za pátým znakem je text "rtsn".
Za šestým znakem je text "rtsng".
Proto vrátíme "rtsng".

Příklad 2:

Vstup: s = "poiinter"
Výstup: "ponter"
Vysvětlení:
Za prvním znakem je text na obrazovce "p".
Za druhým znakem je text "po".
Protože třetí znak, který zadáte, je 'i', text se obrátí a změní se na "op".
Protože čtvrtý znak, který zadáte, je "i", text se obrátí a změní se na "po".
Za pátým znakem je text "pon".
Za šestým znakem je text "pont".
Za sedmým znakem je text "ponte".
Za osmým znakem je text "ponter".
Proto vracíme "ponter".

Omezení:

1 <= s.length <= 100
s se skládá z malých anglických písmen.
s[0] != 'i'

Klávesnice vašeho notebooku je vadná a kdykoli na ní napíšete znak „i“, obrátí se napsaný řetězec. Psaní ostatních znaků funguje podle očekávání.
Máte zadán řetězec s indexem 0 s a pomocí vadné klávesnice píšete jednotlivé znaky řetězce s.
Vraťte výsledný řetězec, který se objeví na obrazovce vašeho notebooku.

Příklad 1:

Vstup: s = „string“
Výstup: „rtsng“
Vysvětlení:
Po zadání prvního znaku je na obrazovce text „s“.
Po zadání druhého znaku je text „st“.
Po třetím znaku je text „str“.
Protože čtvrtý znak je „i“, text se obrátí a stane se „rts“.
Po pátém znaku je text „rtsn“.
Po šestém znaku je text „rtsng“.
Proto vracíme „rtsng“.

Příklad 2:

Vstup: s = „poiinter“
Výstup: Výstup: „ponter“
Vysvětlení:
Po prvním znaku je na obrazovce text „p“.
Po druhém znaku je text „po“.
Protože třetí zadaný znak je „i“, text se obrátí a stane se „op“.
Protože čtvrtý znak, který zadáte, je „i“, text se obrátí a bude „po“.
Po pátém znaku je text „pon“.
Po šestém znaku je text „pont“.
Po sedmém znaku je text „ponte“.
Po osmém znaku je text „ponter“.
Proto vracíme „ponter“.

Omezení:

1 <= s.length <= 100
s se skládá z malých anglických písmen.
s[0] != 'i'

Klávesnice vašeho notebooku je vadná a kdykoli na ní napíšete znak „i“, převrátí řetězec, který jste napsali. Psaní dalších znaků funguje podle očekávání.
Dostanete řetězec s indexovaný 0 a každý znak s napíšete pomocí své vadné klávesnice.
Vraťte poslední řetězec, který bude na obrazovce vašeho notebooku.

Příklad 1:

Vstup: s = "řetězec"
Výstup: "rtsng"
Vysvětlení:
Po napsání prvního znaku je text na obrazovce "s".
Za druhým znakem je text "st".
Za třetím znakem je text "str".
Protože čtvrtý znak je 'i', text se obrátí a stane se z něj "rts".
Po pátém znaku je text "rtsn".
Po šestém znaku je text „rtsng“.
Proto vrátíme "rtsng".

Příklad 2:

Vstup: s = "ukazatel"
Výstup: "ponter"
Vysvětlení:
Po prvním znaku je text na obrazovce "p".
Po druhém znaku je text "po".
Vzhledem k tomu, že třetí znak, který napíšete, je „i“, text se obrátí a změní se na „op“.
Protože čtvrtý znak, který napíšete, je „i“, text se obrátí a změní se na „po“.
Po pátém znaku je text „pon“.
Po šestém znaku je text "pont".
Po sedmém znaku je text „ponte“.
Po osmém znaku je text "ponter".
Proto Vrátí se "ponter".

Omezení:

1 <= s.length <= 100
s se skládá z malých anglických písmen.
s[0] != 'i'


Je-li dán řetězec indexovaný 0 s, permutujte s, abyste získali nový řetězec t takový, že:

Všechny souhlásky zůstávají na svých původních místech. Formálněji, pokud existuje index i s 0 <= i < s.length takový, že s[i] je souhláska, pak t[i] = s[i].
Samohlásky musí být seřazeny v nesestupném pořadí podle jejich hodnot ASCII. Formálněji řečeno, pro páry indexů i, j s 0 <= i < j < s.length takovou, že s[i] a s[j] jsou samohlásky, pak t[i] nesmí mít vyšší hodnotu ASCII než t[j].

Vrátí výsledný řetězec.
Samohlásky jsou 'a', 'e', 'i', 'o' a 'u' a mohou se vyskytovat malými nebo velkými písmeny. Souhlásky obsahují všechna písmena, která nejsou samohláskami.

Příklad 1:

Vstup: s = "lEetcOde"
Výstup: "lEOtcede"
Vysvětlení: 'E', 'O' a 'e' jsou samohlásky ve slově s; 'l', 't', 'c' a 'd' jsou všechny souhlásky. Samohlásky jsou seřazeny podle svých hodnot ASCII a souhlásky zůstávají na stejných místech.

Příklad 2:

Vstup: s = "lYmpH"
Výstup: "lYmpH"
Vysvětlení: V s nejsou žádné samohlásky (všechny znaky v s jsou souhlásky), takže vrátíme "lYmpH".

Omezení:

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

Je dáno, že 0-indexovaný řetězec s vytvoří nový řetězec t tak, že:

Všechny souhlásky zůstanou na svých původních místech. Formálně řečeno, pokud existuje index i s 0 <= i < s.length tak, že s[i] je souhláska, pak t[i] = s[i].
Samohlásky musí být seřazeny v neklesajícím pořadí jejich ASCII hodnot. Formálně řečeno, pro páry indexů i, j s 0 <= i < j < s.length tak, že s[i] a s[j] jsou samohlásky, t[i] nesmí mít vyšší ASCII hodnotu než t[j].

Vrátí výsledný řetězec.
Samohlásky jsou 'a', 'e', 'i', 'o' a 'u' a mohou se objevovat v malých i velkých písmenech. Souhlásky zahrnují všechny písmena, která nejsou samohlásky.

Příklad 1:

Vstup: s = "lEetcOde"
Výstup: "lEOtcede"
Vysvětlení: 'E', 'O' a 'e' jsou samohlásky v s; 'l', 't', 'c' a 'd' jsou všechny souhlásky. Samohlásky jsou seřazeny podle jejich ASCII hodnot a souhlásky zůstávají na stejných místech.

Příklad 2:

Vstup: s = "lYmpH"
Výstup: "lYmpH"
Vysvětlení: V s nejsou žádné samohlásky (všechny znaky v s jsou souhlásky), takže vracíme "lYmpH".

Omezení:

1 <= s.length <= 10^5
s se skládá pouze z písmen anglické abecedy ve velkých a malých písmenech.

Vzhledem k 0-indexovanému řetězci s permutujte s, abyste získali nový řetězec t takový, že:

Všechny souhlásky zůstávají na svých původních místech. Formálněji, pokud existuje index i s 0 <= i < s.length tak, že s[i] je souhláska, pak t[i] = s[i].
Samohlásky musí být seřazeny v neklesajícím pořadí jejich hodnot ASCII. Formálněji, pro dvojice indexů i, j s 0 <= i < j < s.length tak, že s[i] a s[j] jsou samohlásky, pak t[i] nesmí mít vyšší hodnotu ASCII než t[ j].

Vraťte výsledný řetězec.
Samohlásky jsou 'a', 'e', 'i', 'o' a 'u' a mohou se objevit jako malá nebo velká písmena. Souhlásky zahrnují všechna písmena, která nejsou samohlásky.

Příklad 1:

Vstup: s = "lEetcOde"
Výstup: "lEOtcede"
Vysvětlení: 'E', 'O' a 'e' jsou samohlásky v s; 'l', 't', 'c' a 'd' jsou všechny souhlásky. Samohlásky jsou seřazeny podle jejich hodnot ASCII a souhlásky zůstávají na stejných místech.

Příklad 2:

Vstup: s = "lYmpH"
Výstup: "lYmpH"
Vysvětlení: V s nejsou žádné samohlásky (všechny znaky v s jsou souhlásky), takže vrátíme "lYmpH".

Omezení:

1 <= s.length <= 10^5
s se skládá pouze z písmen anglické abecedy ve velkých a malých písmenech.


Prvek x celočíselného pole arr délky m je dominantní, pokud freq(x) * 2 > m, kde freq(x) je počet výskytů x v arr. Tato definice znamená, že arr může mít nejvýše jeden dominantní prvek.
Je vám dáno 0-indexované celočíselné pole nums délky n s jedním dominantním prvkem.
Můžete rozdělit nums na indexu i do dvou polí nums[0, ..., i] a nums[i + 1, ..., n - 1], ale rozdělení je platné pouze pokud:

0 <= i < n - 1
nums[0, ..., i] a nums[i + 1, ..., n - 1] mají stejný dominantní prvek.

Zde nums[i, ..., j] označuje podpole nums začínající na indexu i a končící na indexu j, oba konce včetně. Zejména, pokud j < i, pak nums[i, ..., j] označuje prázdné podpole.
Vraťte minimální index platného rozdělení. Pokud neexistuje žádné platné rozdělení, vraťte -1.

Příklad 1:

Vstup: nums = [1,2,2,2]
Výstup: 2
Vysvětlení: Můžeme rozdělit pole na indexu 2, abychom získali pole [1,2,2] a [2].
V poli [1,2,2] je prvek 2 dominantní, protože se v poli vyskytuje dvakrát a 2 * 2 > 3.
V poli [2] je prvek 2 dominantní, protože se v poli vyskytuje jednou a 1 * 2 > 1.
Obě [1,2,2] a [2] mají stejný dominantní prvek jako nums, takže toto je platné rozdělení.
Lze ukázat, že index 2 je minimální index platného rozdělení.
Příklad 2:

Vstup: nums = [2,1,3,1,1,1,7,1,2,1]
Výstup: 4
Vysvětlení: Můžeme rozdělit pole na indexu 4, abychom získali pole [2,1,3,1,1] a [1,7,1,2,1].
V poli [2,1,3,1,1] je prvek 1 dominantní, protože se v poli vyskytuje třikrát a 3 * 2 > 5.
V poli [1,7,1,2,1] je prvek 1 dominantní, protože se v poli vyskytuje třikrát a 3 * 2 > 5.
Obě [2,1,3,1,1] a [1,7,1,2,1] mají stejný dominantní prvek jako nums, takže toto je platné rozdělení.
Lze ukázat, že index 4 je minimální index platného rozdělení.
Příklad 3:

Vstup: nums = [3,3,3,3,7,2,2]
Výstup: -1
Vysvětlení: Lze ukázat, že neexistuje žádné platné rozdělení.

Omezení:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums má přesně jeden dominantní prvek.

Prvek x celočíselného pole arr délky m je dominantní, pokud freq(x) * 2 > m, kde freq(x) je počet výskytů x v arr. Všimněte si, že z této definice vyplývá, že arr může mít nanejvýš jeden dominantní prvek.
Je vám dáno celé pole s indexem 0 o délce n s jedním dominantním prvkem.
Čísla v indexu i můžete rozdělit na dvě pole: nums[0, ..., i] a nums[i + 1, ..., n - 1], ale rozdělení je platné pouze tehdy, pokud:

0 <= i < n - 1
Nums[0, ..., i] a nums[i + 1, ..., n - 1] mají stejný dominantní prvek.

Zde nums[i, ..., j] označuje podpole nums začínajících indexem i a končících indexem j, přičemž oba konce jsou inkluzivní. Konkrétně, pokud j < i, pak nums[i, ..., j] označuje prázdný podpole.
Vrátí minimální index platného rozdělení. Pokud neexistuje žádné platné rozdělení, vrátí hodnotu -1.

Příklad 1:

Vstup: nums = [1,2,2,2]
Výstup: 2
Vysvětlení: Pole můžeme rozdělit na index 2 a získat pole [1,2,2] a [2].
V poli [1,2,2] je prvek 2 dominantní, protože se v poli vyskytuje dvakrát a 2 * 2 > 3.
V poli [2] je prvek 2 dominantní, protože se v poli vyskytuje jednou a 1 * 2 > 1.
Jak [1,2,2], tak [2] mají stejný dominantní prvek jako nums, takže se jedná o platné rozdělení.
Lze ukázat, že index 2 je minimální index platného rozdělení.
Příklad 2:

Vstup: nums = [2,1,3,1,1,1,7,1,2,1]
Výstup: 4
Vysvětlení: Můžeme rozdělit pole na indexu 4 a získat pole [2,1,3,1,1] a [1,7,1,2,1].
V poli [2,1,3,1,1] je prvek 1 dominantní, protože se v poli vyskytuje třikrát a 3 * 2 > 5.
V poli [1,7,1,2,1] je prvek 1 dominantní, protože se v poli vyskytuje třikrát a 3 * 2 > 5.
Jak [2,1,3,1,1], tak [1,7,1,2,1] mají stejný dominantní prvek jako nums, takže se jedná o platné rozdělení.
Lze ukázat, že index 4 je minimální index platného rozdělení.
Příklad 3:

Vstup: nums = [3,3,3,3,7,2,2]
Výstup: -1
Vysvětlení: Lze ukázat, že neexistuje žádné platné rozdělení.

Omezení:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
Funkce NUMS má právě jeden dominantní prvek.

Prvek x celočíselného pole arr délky m je dominantní, pokud freq(x) * 2 > m, kde freq(x) je počet výskytů x v arr. Všimněte si, že z této definice vyplývá, že arr může mít nejvýše jeden dominantní prvek.
Dostanete 0-indexované celé pole čísel délky n s jedním dominantním prvkem.
Čísla na indexu i můžete rozdělit do dvou polí nums[0, ..., i] a nums[i + 1, ..., n - 1], ale rozdělení je platné pouze v případě, že:

0 <= i < n - 1
nums[0, ..., i] a nums[i + 1, ..., n - 1] mají stejný dominantní prvek.

Zde nums[i, ..., j] označuje podskupinu num začínající na indexu i a končící na indexu j, přičemž oba konce jsou včetně. Konkrétně, jestliže j < i, pak nums[i, ..., j] označuje prázdné podpole.
Vraťte minimální index platného rozdělení. Pokud neexistuje žádné platné rozdělení, vrátí -1.

Příklad 1:

Vstup: nums = [1,2,2,2]
Výstup: 2
Vysvětlení: Můžeme rozdělit pole na index 2 a získat pole [1,2,2] a [2].
V poli [1,2,2] je prvek 2 dominantní, protože se v poli vyskytuje dvakrát a 2 * 2 > 3.
V poli [2] je prvek 2 dominantní, protože se v poli vyskytuje jednou a 1 * 2 > 1.
[1,2,2] i [2] mají stejný dominantní prvek jako nums, takže toto je platné rozdělení.
Lze ukázat, že index 2 je minimální index platného rozdělení.
Příklad 2:

Vstup: nums = [2,1,3,1,1,1,7,1,2,1]
Výstup: 4
Vysvětlení: Můžeme rozdělit pole na index 4 a získat pole [2,1,3,1,1] a [1,7,1,2,1].
V poli [2,1,3,1,1] je prvek 1 dominantní, protože se vyskytuje třikrát v poli a 3 * 2 > 5.
V poli [1,7,1,2,1] je prvek 1 dominantní, protože se vyskytuje třikrát v poli a 3 * 2 > 5.
[2,1,3,1,1] i [1,7,1,2,1] mají stejný dominantní prvek jako nums, takže toto je platné rozdělení.
Lze ukázat, že index 4 je minimální index platného rozdělení.
Příklad 3:

Vstup: nums = [3,3,3,3,7,2,2]
Výstup: -1
Vysvětlení: Lze ukázat, že neexistuje žádné platné rozdělení.

Omezení:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums má právě jeden dominantní prvek.


Je zadáno pole nums s indexem 0 a nezáporné celé číslo k.
Jednou operací můžete provést následující:

Zvolte z rozsahu [0, nums.length - 1] index i, který ještě nebyl zvolen.
Nahraďte nums[i] libovolným celým číslem z rozsahu [nums[i] - k, nums[i] + k].

Krása pole je délka nejdelší podřetězce složené ze stejných prvků.
Vraťte maximální možnou krásu pole nums po libovolném počtu použití operace.
Všimněte si, že na každý index lze operaci aplikovat pouze jednou.
Podsekvence pole je nové pole vytvořené z původního pole odstraněním některých prvků (případně žádných), aniž by se změnilo pořadí zbývajících prvků.

Příklad 1:

Vstup: nums = [4,6,1,2], k = 2
Výstup: 3
Vysvětlení: V tomto příkladu použijeme následující operace:
- Zvolíme index 1, nahradíme jej číslem 4 (z rozsahu [4,8]), nums = [4,4,1,2].
- Zvolíme index 3, nahradíme jej číslem 4 (z rozsahu [0,4]), nums = [4,4,1,4].
Po provedených operacích je krása pole nums 3 (posloupnost složená z indexů 0, 1 a 3).
Lze dokázat, že 3 je maximální možná délka, které můžeme dosáhnout.

Příklad 2:

Vstup: nums = [1,1,1,1], k = 10
Výstup: 4
Vysvětlení: V tomto příkladu nemusíme provádět žádné operace.
Krása pole nums je 4 (celé pole).

Omezení:

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

Dostanete nulové indexované číslo pole a nezáporné celé číslo k.
V jedné operaci můžete provést následující:

Vyberte index i, který dosud nebyl zvolen, z rozsahu [0, nums.length - 1].
Nahraďte nums[i] libovolným celým číslem z rozsahu [nums[i] - k, nums[i] + k].

Krása pole je v délce nejdelší podsekvence sestávající ze stejných prvků.
Po použití operace v libovolném počtu vraťte maximální možnou krásu čísel pole.
Všimněte si, že operaci můžete použít na každý index pouze jednou.
Podsekvence pole je nové pole vygenerované z původního pole odstraněním některých prvků (možná žádných), aniž by se změnilo pořadí zbývajících prvků.

Příklad 1:

Vstup: nums = [4,6,1,2], k = 2
Výstup: 3
Vysvětlení: V tomto příkladu použijeme následující operace:
- Zvolte index 1, nahraďte jej 4 (z rozsahu [4,8]), nums = [4,4,1,2].
- Zvolte index 3, nahraďte jej 4 (z rozsahu [0,4]), nums = [4,4,1,4].
Po aplikovaných operacích je krása čísel pole 3 (podsekvence skládající se z indexů 0, 1 a 3).
Dá se prokázat, že 3 je maximální možná délka, které můžeme dosáhnout.

Příklad 2:

Vstup: nums = [1,1,1,1], k = 10
Výstup: 4
Vysvětlení: V tomto příkladu nemusíme používat žádné operace.
Krása čísel pole je 4 (celé pole).

Omezení:

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

Dostanete 0-indexované pole nums a nezáporné celé číslo k.
V jedné operaci můžete provést následující akce:

Vyberte index i, který nebyl vybrán dříve z rozsahu [0, nums.length - 1].
Nahraďte nums[i] libovolným celým číslem z rozsahu [nums[i] - k, nums[i] + k].

Krása pole spočívá v délce nejdelší podsekvence skládající se ze stejných prvků.
Vrátí maximální možnou krásu čísel pole po použití operace libovolněkrát.
Všimněte si, že operaci můžete aplikovat na každý index pouze jednou.
Podsekvence pole je nové pole generované z původního pole odstraněním některých prvků (pravděpodobně žádných) beze změny pořadí zbývajících prvků.

Příklad 1:

Vstup: nums = [4,6,1,2], k = 2
Výstup: 3
Vysvětlení: V tomto příkladu použijeme následující operace:
- Vybereme index 1, nahraď ho 4 (z rozsahu [4,8]), nums = [4,4,1,2].
- Zvolte index 3, nahraďte jej indexem 4 (z rozsahu [0,4]), nums = [4,4,1,4].
Po použitých operacích je krása čísla pole 3 (podposloupnost skládající se z indexů 0, 1 a 3).
Dá se dokázat, že 3 je maximální možná délka, které můžeme dosáhnout.

Příklad 2:

Vstup: nums = [1,1,1,1], k = 10
Výstup: 4
Vysvětlení: V tomto příkladu nemusíme používat žádné operace.
Krása čísel pole je 4 (celé pole).

Omezení:

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


Je vám přiděleno celočíselné pole nums. Pole považujeme za dobré, pokud se jedná o permutaci báze base[n].
base[n] = [1, 2, ..., n - 1, n, n] (jinými slovy, je to pole délky n + 1, které obsahuje 1 až n - 1 právě jednou, plus dva výskyty n). Například base[1] = [1, 1] a base[3] = [1, 2, 3, 3].
Vrátí true, pokud je dané pole dobré, jinak vrátí false.
Poznámka: Permutace celých čísel představuje uspořádání těchto čísel.

Příklad 1:

Vstup: nums = [2, 1, 3]
Výstup: false
Vysvětlení: Protože maximální prvek pole je 3, jediným kandidátem n, pro který by toto pole mohlo být permutací báze[n], je n = 3. base[3] má však čtyři prvky, ale pole má tři. Nemůže se tedy jednat o permutaci base[3] = [1, 2, 3, 3]. Odpověď je tedy nepravdivá.

Příklad 2:

Vstup: nums = [1, 3, 3, 2]
Výstup: true
Vysvětlení: Protože maximální prvek pole je 3, jediným kandidátem n, pro který by toto pole mohlo být permutací báze[n], je n = 3. Je vidět, že nums je permutace čísla base[3] = [1, 2, 3, 3] (prohozením druhého a čtvrtého prvku v nums se dostaneme k base[3]). Odpověď je tedy pravdivá.
Příklad 3:

Vstup: nums = [1, 1]
Výstup: true
Vysvětlení: Protože maximální prvek pole je 1, jediným kandidátem n, pro kterého by toto pole mohlo být permutací base[n], je n = 1. Je vidět, že nums je permutací čísla base[1] = [1, 1]. Odpověď je tedy pravdivá.
Příklad 4:

Vstup: nums = [3, 4, 4, 1, 2, 1]
Výstup: false
Vysvětlení: Protože maximální prvek pole je 4, jediným kandidátem na n pro které toto pole může být permutací base[n], je n = 4. Nicméně, base[4] má pět prvků, ale pole nums má šest. Proto nemůže být permutací base[4] = [1, 2, 3, 4, 4]. Odpověď je tedy false.

Omezení:

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

Je vám dáno pole celých čísel nums. Považujeme pole za dobré, pokud je permutací pole base[n].
base[n] = [1, 2, ..., n - 1, n, n] (jinými slovy, je to pole délky n + 1, které obsahuje čísla od 1 do n - 1 přesně jednou, a dvakrát se vyskytující n). Například base[1] = [1, 1] a base[3] = [1, 2, 3, 3].
Vraťte true, pokud je dané pole dobré, jinak vraťte false.
Poznámka: Permutace celých čísel představuje uspořádání těchto čísel.

Příklad 1:

Vstup: nums = [2, 1, 3]
Výstup: false
Vysvětlení: Protože maximální prvek pole je 3, jediným kandidátem na n pro které toto pole může být permutací base[n], je n = 3. Nicméně, base[3] má čtyři prvky, ale pole nums má tři. Proto nemůže být permutací base[3] = [1, 2, 3, 3]. Odpověď je tedy false.

Příklad 2:

Vstup: nums = [1, 3, 3, 2]
Výstup: true
Vysvětlení: Protože maximální prvek pole je 3, jediným kandidátem na n pro které toto pole může být permutací base[n], je n = 3. Lze vidět, že nums je permutací base[3] = [1, 2, 3, 3] (přesunutím druhého a čtvrtého prvku v nums dosáhneme base[3]). Odpověď je tedy true.

Příklad 3:

Vstup: nums = [1, 1]
Výstup: true
Vysvětlení: Protože maximální prvek pole je 1, jediným kandidátem na n pro které toto pole může být permutací base[n], je n = 1. Lze vidět, že nums je permutací base[1] = [1, 1]. Odpověď je tedy true.

Příklad 4:

Vstup: nums = [3, 4, 4, 1, 2, 1]
Výstup: false
Vysvětlení: Protože maximální prvek pole je 4, jediným kandidátem na n pro které toto pole může být permutací base[n], je n = 4. Nicméně, base[4] má pět prvků, ale pole nums má šest. Proto nemůže být permutací base[4] = [1, 2, 3, 4, 4]. Odpověď je tedy false.

Omezení:

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

Je zadáno celočíselné pole nums. Pole považujeme za dobré, pokud je permutací pole base[n].
base[n] = [1, 2, ..., n - 1, n, n] (jinými slovy, je to pole délky n + 1, které obsahuje 1 až n - 1 přesně jednou a navíc dva výskyty n). Například base[1] = [1, 1] a base[3] = [1, 2, 3, 3].
Vrátí true, pokud je dané pole dobré, jinak vrátí false.
Poznámka: Permutace celých čísel představuje uspořádání těchto čísel.

Příklad 1:

Vstup: nums = [2, 1, 3]
Výstup: false
Vysvětlení: Protože maximální prvek pole je 3, jediným kandidátem n, pro které by toto pole mohlo být permutací báze[n], je n = 3. Báze[3] má však čtyři prvky, ale pole nums má tři. Proto nemůže být permutací báze[3] = [1, 2, 3, 3]. Odpověď je tedy nepravdivá.

Příklad 2:

Vstup: nums = [1, 3, 3, 2]
Výstup: true
Vysvětlení: Jelikož maximální prvek pole je 3, jediný kandidát n, pro který by toto pole mohlo být permutací báze[n], je n = 3. Je vidět, že nums je permutací báze[3] = [1, 2, 3, 3] (prohozením druhého a čtvrtého prvku v nums dosáhneme báze[3]). Odpověď je tedy pravdivá.
Příklad 3:

Vstup: nums = [1, 1]
Výstup: true
Vysvětlení: Protože maximální prvek pole je 1, jediným kandidátem n, pro který by toto pole mohlo být permutací báze[n], je n = 1. Je vidět, že nums je permutace báze[1] = [1, 1]. Odpověď je tedy pravdivá.
Příklad 4:

Vstup: nums = [3, 4, 4, 1, 2, 1].
Výstup: false
Vysvětlení: Protože maximální prvek pole je 4, jediným kandidátem n, pro který by toto pole mohlo být permutací báze[n], je n = 4. Základ[4] má však pět prvků, ale pole nums jich má šest. Proto nemůže být permutací báze[4] = [1, 2, 3, 4, 4]. Odpověď je tedy nepravdivá.

Omezení:

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


Máte zadané celé číslo pole nums s indexací od 0 a kladné celé číslo x.
Původně jste na pozici 0 v poli a můžete navštívit další pozice podle následujících pravidel:

Pokud jste aktuálně na pozici i, můžete se přesunout na jakoukoli pozici j, kde i < j.
Pro každou pozici i, kterou navštívíte, získáte skóre nums[i].
Pokud se přesunete z pozice i na pozici j a parity nums[i] a nums[j] se liší, ztratíte skóre x.

Vraťte maximální celkové skóre, které můžete získat.
Všimněte si, že původně máte body nums[0].

Příklad 1:

Vstup: nums = [2,3,6,1,9,2], x = 5
Výstup: 13
Vysvětlení: Můžeme navštívit následující pozice v poli: 0 -> 2 -> 3 -> 4.
Odpovídající hodnoty jsou 2, 6, 1 a 9. Jelikož celá čísla 6 a 1 mají různé parity, pohyb 2 -> 3 vás připraví o skóre x = 5.
Celkové skóre bude: 2 + 6 + 1 + 9 - 5 = 13.

Příklad 2:

Vstup: nums = [2,4,6,8], x = 3
Výstup: 20
Vysvětlení: Všechna čísla v poli mají stejné parity, takže můžeme navštívit všechna z nich, aniž bychom ztratili jakékoli skóre.
Celkové skóre je: 2 + 4 + 6 + 8 = 20.

Omezení:

2 <= nums.length <= 10^5
1 <= nums[i], x <= 10^6

Dostanete 0-indexované celé číslo pole nums a kladné celé číslo x.
Zpočátku jste na pozici 0 v poli a můžete navštívit další pozice podle následujících pravidel:

Pokud jste aktuálně v pozici i, můžete se přesunout do libovolné pozice j, takže i < j.
Za každou pozici i, kterou navštívíte, získáte skóre nums[i].
Pokud se přesunete z pozice i do pozice j a parity nums[i] a nums[j] se liší, ztratíte skóre x.

Vraťte maximální celkové skóre, které můžete získat.
Všimněte si, že zpočátku máte num[0] bodů.

Příklad 1:

Vstup: nums = [2,3,6,1,9,2], x = 5
Výstup: 13
Vysvětlení: Můžeme navštívit následující pozice v poli: 0 -> 2 -> 3 -> 4.
Odpovídající hodnoty jsou 2, 6, 1 a 9. Protože celá čísla 6 a 1 mají různé parity, tah 2 -> 3 způsobí, že ztratíte skóre x = 5.
Celkové skóre bude: 2 + 6 + 1 + 9 - 5 = 13.

Příklad 2:

Vstup: nums = [2,4,6,8], x = 3
Výstup: 20
Vysvětlení: Všechna celá čísla v poli mají stejné parity, takže je můžeme navštívit všechny bez ztráty skóre.
Celkové skóre je: 2 + 4 + 6 + 8 = 20.

Omezení:

2 <= nums.length <= 10^5
1 <= nums[i], x <= 10^6

Je zadáno pole celých čísel nums s indexem 0 a kladné celé číslo x.
Na začátku se nacházíte na pozici 0 v poli a další pozice můžete navštívit podle následujících pravidel:

Pokud se právě nacházíte na pozici i, pak se můžete přesunout na libovolnou pozici j takovou, že i < j.
Za každou pozici i, kterou navštívíte, získáte skóre nums[i].
Pokud se přesunete z pozice i na pozici j a parity nums[i] a nums[j] se liší, ztratíte skóre x.

Vraťte maximální celkové skóre, které můžete získat.
Všimněte si, že na začátku máte nums[0] bodů.

Příklad 1:

Vstup: nums = [2,3,6,1,9,2], x = 5
Výstup: 13
Vysvětlení: V poli můžeme navštívit následující pozice: 0 -> 2 -> 3 -> 4.
Odpovídající hodnoty jsou 2, 6, 1 a 9. Protože celá čísla 6 a 1 mají různé parity, tah 2 -> 3 způsobí ztrátu skóre x = 5.
Celkové skóre bude: 2 + 6 + 1 + 9 - 5 = 13.

Příklad 2:

Vstup: čísla = [2,4,6,8], x = 3
Výstup: 20
Vysvětlení: Všechna celá čísla v poli mají stejnou paritu, takže je můžeme navštívit všechna bez ztráty skóre.
Celkové skóre je: 2 + 4 + 6 + 8 = 20.

Omezení:

2 <= nums.length <= 10^5
1 <= nums[i], x <= 10^6


Dostanete 0-indexované celočíselné pole nums. Musíte najít maximální součet dvojice čísel tak, aby se maximální číslice v obou číslech rovnaly.
Vraťte maximální součet nebo -1, pokud žádný takový pár neexistuje.

Příklad 1:

Vstup: nums = [51,71,17,24,42]
Výstup: 88
Vysvětlení:
Pro i = 1 a j = 2 mají nums[i] a nums[j] stejnou maximální číslici s párovým součtem 71 + 17 = 88.
Pro i = 3 a j = 4 mají nums[i] a nums[j] stejnou maximální číslici s párovým součtem 24 + 42 = 66.
Lze ukázat, že neexistují žádné další páry se stejnou maximální číslici, takže odpověď je 88.
Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: -1
Vysvětlení: Neexistuje žádný pár v číslech se stejnou maximální číslicí.

Omezení:

2 <= nums.length <= 100
1 <= nums[i] <= 10^4

Dostanete 0-indexované celočíselné pole nums. Musíte najít maximální součet dvojice čísel tak, aby se maximální číslice v obou číslech rovnaly.
Vraťte maximální součet nebo -1, pokud žádný takový pár neexistuje.

Příklad 1:

Vstup: nums = [51,71,17,24,42]
Výstup: 88
Vysvětlení:
Pro i = 1 a j = 2 mají nums[i] a nums[j] stejnou maximální číslici s párovým součtem 71 + 17 = 88.
Pro i = 3 a j = 4 mají nums[i] a nums[j] stejnou maximální číslici s párovým součtem 24 + 42 = 66.
"Lze ukázat, že neexistují žádné další páry se stejnou maximální číslicí, takže odpověď je 88.
Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: -1
Vysvětlení: Neexistuje žádný pár se stejnou maximální číslicí.

Omezení:

2 <= nums.length <= 100
1 <= nums[i] <= 10^4

Dostanete pole celých čísel s indexem 0. Musíte najít maximální součet dvojice čísel z pole takových, aby měla obě čísla stejnou maximální číslici.
Vrátíte maximální součet nebo -1, pokud žádný takový pár neexistuje.

Příklad 1:

Vstup: nums = [51,71,17,24,42]
Výstup: 88
Vysvětlení:
Pro i = 1 a j = 2 mají nums[i] a nums[j] stejné maximální číslice s součtem 71 + 17 = 88.
Pro i = 3 a j = 4 mají nums[i] a nums[j] stejné maximální číslice s párovým součtem 24 + 42 = 66.
Lze ukázat, že neexistují další páry se stejnými maximálními číslicemi, takže odpověď je 88.
Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: -1
Vysvětlení: Neexistuje žádný pár v poli se stejnými maximálními číslicemi.

Omezení:

2 <= nums.length <= 100
1 <= nums[i] <= 10^4


Je zadáno pole celých čísel nums s indexem 0, celé číslo modulo a celé číslo k.
Vaším úkolem je zjistit počet dílčích polí, která jsou zajímavá.
Dílčí pole nums[l..r] je zajímavé, pokud platí následující podmínka:

Nechť cnt je počet indexů i v rozsahu [l, r] takových, že nums[i] % modulo == k. Pak cnt % modulo == k.

Vraťte celé číslo označující počet zajímavých dílčích polí.
Poznámka: Podoblast je souvislá neprázdná posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [3,2,4], modulo = 2, k = 1
Výstup: 3
Vysvětlení: V tomto příkladu jsou zajímavá dílčí pole:
Podpásmo nums[0..0], což je [3].
- V rozsahu [0, 0] je pouze jeden index, i = 0, který splňuje podmínku nums[i] % modulo == k.
- Proto cnt = 1 a cnt % modulo == k.
Podoblast nums[0..1], která je [3,2].
- V rozsahu [0, 1] existuje pouze jeden index, i = 0, který splňuje podmínku nums[i] % modulo == k.
- Proto cnt = 1 a cnt % modulo == k.
Podoblast nums[0..2], která je [3,2,4].
- V rozsahu [0, 2] existuje pouze jeden index, i = 0, který splňuje podmínku nums[i] % modulo == k.
- Proto cnt = 1 a cnt % modulo == k.
Lze ukázat, že neexistují žádná další zajímavá dílčí pole. Odpověď je tedy 3.
Příklad 2:

Vstup: nums = [3,1,9,6], modulo = 3, k = 0
Výstup: 2
Vysvětlení: V tomto příkladu jsou zajímavá dílčí pole:
Dílčí pole nums[0..3], což je [3,1,9,6].
- V rozsahu [0, 3] jsou tři indexy i = 0, 2, 3, které splňují podmínku nums[i] % modulo == k.
- Proto cnt = 3 a cnt % modulo == k.
Podoblast nums[1..1], která je [1].
- V rozsahu [1, 1] neexistuje žádný index i, který by splňoval podmínku nums[i] % modulo == k.
- Proto cnt = 0 a cnt % modulo == k.
Lze ukázat, že neexistují žádná další zajímavá dílčí pole. Odpověď je tedy 2.

Omezení:

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

Dostanete celé pole nums indexované číslem 0, celočíselným modulem a celým číslem k.
Vaším úkolem je zjistit počet podpolí, která jsou zajímavá.
Podpole nums[l.. r] je zajímavé, pokud platí následující podmínka:

Nechť cnt je počet indexů i v rozsahu [l, r] takový, že nums[i] % modulo == k. Pak cnt % modulo == k.

Vrací celé číslo označující počet zajímavých podpolí.
Poznámka: Podpole je souvislá neprázdná posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [3,2,4], modulo = 2, k = 1
Výstup: 3
Vysvětlení: V tomto příkladu jsou zajímavá podpole:
Podpole nums[0..0], což je [3].
- Existuje pouze jeden index, i = 0, v rozsahu [0, 0], který splňuje nums[i] % modulo == k.
- Tedy cnt = 1 a cnt % modulo == k.
Podpole nums[0..1], což je [3,2].
- Existuje pouze jeden index, i = 0, v rozsahu [0, 1], který splňuje nums[i] % modulo == k.
- Tedy cnt = 1 a cnt % modulo == k.
Podpole nums[0..2], což je [3,2,4].
- Existuje pouze jeden index, i = 0, v rozsahu [0, 2], který splňuje nums[i] % modulo == k.
- Tedy cnt = 1 a cnt % modulo == k.
Lze ukázat, že neexistují žádná další zajímavá podpole. Odpověď je tedy 3.
Příklad 2:

Vstup: nums = [3,1,9,6], modulo = 3, k = 0
Výstup: 2
Vysvětlení: V tomto příkladu jsou zajímavá podpole:
Podpole nums[0..3], což je [3,1,9,6].
- Existují tři indexy, i = 0, 2, 3, v rozsahu [0, 3], které splňují nums[i] % modulo == k.
- Tedy cnt = 3 a cnt % modulo == k.
Podpole nums[1..1], což je [1].
- V rozsahu [1, 1] neexistuje žádný index, i, který by splňoval nums[i] % modulo == k.
- Tedy cnt = 0 a cnt % modulo == k.
Lze ukázat, že neexistují žádná další zajímavá podpole. Odpověď je tedy 2.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums, celé číslo modulo a celé číslo k.
Vaším úkolem je najít počet podpolí, která jsou zajímavá.
Podpole nums[l..r] je zajímavé, pokud platí následující podmínka:

Nechť cnt je počet indexů i v rozsahu [l, r] takový, že nums[i] % modulo == k. Potom cnt % modulo == k.

Vraťte celé číslo označující počet zajímavých podpolí.
Poznámka: Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [3,2,4], modulo = 2, k = 1
Výstup: 3
Vysvětlení: V tomto příkladu jsou zajímavá podpole:
Podpole nums[0..0], což je [3].
- Existuje pouze jeden index, i = 0, v rozsahu [0, 0], který vyhovuje nums[i] % modulo == k.
- Proto cnt = 1 a cnt % modulo == k.
Podpole nums[0..1], což je [3,2].
- Existuje pouze jeden index, i = 0, v rozsahu [0, 1], který vyhovuje nums[i] % modulo == k.
- Proto cnt = 1 a cnt % modulo == k.
Podpole nus[0..2], což je [3,2,4].
- Existuje pouze jeden index, i = 0, v rozsahu [0, 2], který vyhovuje nums[i] % modulo == k.
- Proto cnt = 1 a cnt % modulo == k.
Lze ukázat, že neexistují žádná další zajímavá podpole. Takže odpověď je 3.
Příklad 2:

Vstup: nums = [3,1,9,6], modulo = 3, k = 0
Výstup: 2
Vysvětlení: V tomto příkladu jsou zajímavá podpole:
Podpole nus[0..3], což je [3,1,9,6].
- Existují tři indexy, i = 0, 2, 3, v rozsahu [0, 3], které splňují nums[i] % modulo == k.
- Proto cnt = 3 a cnt % modulo == k.
Podpole nums[1..1], což je [1].
- Neexistuje žádný index i v rozsahu [1, 1], který by vyhovoval nums[i] % modulo == k.
- Proto cnt = 0 a cnt % modulo == k.
Lze ukázat, že neexistují žádná další zajímavá podpole. Takže odpověď je 2.

Omezení:

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


Máte pole `nums` délky `n` a celé číslo `m`. Musíte zjistit, zda je možné rozdělit pole na `n` neprázdných polí provedením několika kroků.
V každém kroku můžete vybrat existující pole (které může být výsledkem předchozích kroků) o délce alespoň dvě a rozdělit ho na dvě podpole, pokud pro každé vzniklé podpole platí alespoň jedna z následujících podmínek:

- Délka podpole je jedna, nebo
- Součet prvků podpole je větší než nebo roven `m`.

Vraťte `true`, pokud můžete rozdělit dan pole na n polí, jinak vraťte false.
Poznámka: Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [2, 2, 1], m = 4
Výstup: true
Vysvětlení: Můžeme rozdělit pole na [2, 2] a [1] v prvním kroku. Poté můžeme v druhém kroku rozdělit [2, 2] na [2] a [2]. Výsledek je tedy true.

Příklad 2:

Vstup: nums = [2, 1, 3], m = 5
Výstup: false
Vysvětlení: Můžeme zkusit rozdělit pole dvěma různými způsoby: první způsob je mít [2, 1] a [3], a druhý způsob je mít [2] a [1, 3]. Avšak ani jeden z těchto způsobů není platný. Výsledek je tedy false.

Příklad 3:

Vstup: nums = [2, 3, 3, 2, 3], m = 6
Výstup: true
Vysvětlení: Můžeme rozdělit pole na [2, 3, 3, 2] a [3] v prvním kroku. Poté můžeme ve druhém kroku rozdělit [2, 3, 3, 2] na [2, 3, 3] a [2]. Ve třetím kroku můžeme rozdělit [2, 3, 3] na [2] a [3, 3]. A na závěr můžeme rozdělit [3, 3] na [3] a [3]. Výsledek je tedy true.

Omezení:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

Je vám dáno pole nums o délce n a celé číslo m. Musíte zjistit, zda je možné rozdělit pole na n neprázdných polí provedením řady kroků.
V každém kroku můžete vybrat existující pole (které může být výsledkem předchozích kroků) o délce alespoň dvě a rozdělit ho na dvě podpole, pokud pro každé výsledné podpole platí alespoň jedna z následujících podmínek:

Délka podpole je jedna, nebo
Součet prvků podpole je větší nebo roven m.

Vrátí true, pokud můžete dané pole rozdělit na n polí, jinak vrátí false.
Poznámka: Podpole je souvislá neprázdná posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [2, 2, 1], m = 4
Výstup: true
Vysvětlení: V prvním kroku můžeme pole rozdělit na [2, 2] a [1]. Ve druhém kroku pak můžeme rozdělit [2, 2] na [2] a [2]. V důsledku toho je odpověď pravdivá.
Příklad 2:

Vstup: nums = [2, 1, 3], m = 5
Výstup: false
Vysvětlení: Můžeme zkusit rozdělit pole dvěma různými způsoby: první způsob je mít [2, 1] a [3] a druhý způsob je mít [2] a [1, 3]. Oba tyto způsoby však nejsou platné. Odpověď je tedy nepravdivá.
Příklad 3:

Vstup: nums = [2, 3, 3, 2, 3], m = 6
Výstup: true
Vysvětlení: V prvním kroku můžeme pole rozdělit na [2, 3, 3, 2] a [3]. Ve druhém kroku pak můžeme rozdělit [2, 3, 3, 2] na [2, 3, 3] a [2]. Ve třetím kroku pak můžeme rozdělit [2, 3, 3] na [2] a [3, 3]. A v posledním kroku můžeme rozdělit [3, 3] na [3] a [3]. V důsledku toho je odpověď pravdivá.

Omezení:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

Je dáno pole nums délky n a celé číslo m. Je třeba určit, zda je možné pole rozdělit na n neprázdných polí provedením řady kroků.
V každém kroku můžete vybrat existující pole (které může být výsledkem předchozích kroků) o délce alespoň dvě a rozdělit ho na dvě podpole, pokud pro každé výsledné podpole platí alespoň jedna z následujících podmínek:

Délka dílčího pole je jedna, nebo
Součet prvků dílčího pole je větší nebo roven m.

Vrátí true, pokud lze dané pole rozdělit na n polí, jinak vrátí false.
Poznámka: Dílčí pole je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [2, 2, 1], m = 4
Výstup: true
Vysvětlení: V prvním kroku můžeme pole rozdělit na [2, 2] a [1]. Ve druhém kroku pak můžeme pole [2, 2] rozdělit na [2] a [2]. Výsledkem je odpověď true.
Příklad 2:

Vstup: nums = [2, 1, 3], m = 5
Výstup: false
Vysvětlení: Můžeme zkusit rozdělit pole dvěma různými způsoby: první způsob je mít [2, 1] a [3] a druhý způsob je mít [2] a [1, 3]. Oba tyto způsoby však nejsou platné. Odpověď je tedy nepravdivá.
Příklad 3:

Vstup: nums = [2, 3, 3, 2, 3], m = 6
Výstup: true
Vysvětlení: V prvním kroku můžeme pole rozdělit na [2, 3, 3, 2] a [3]. Ve druhém kroku pak můžeme pole [2, 3, 3, 2] rozdělit na [2, 3, 3] a [2]. Ve třetím kroku pak můžeme rozdělit [2, 3, 3] na [2] a [3, 3]. A v posledním kroku můžeme rozdělit [3, 3] na [3] a [3]. Výsledkem je, že odpověď je pravdivá.

Omezení:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200


Zadané 0-indexované celočíselné pole num délky n a celočíselný cíl vrátí počet párů (i, j), kde 0 <= i < j < n a nums[i] + nums[j] < cíl.

Příklad 1:

Vstup: nums = [-1,1,2,3,1], cíl = 2
Výstup: 3
Vysvětlení: Existují 3 páry indexů, které splňují podmínky v prohlášení:
- (0, 1) protože 0 < 1 a nums[0] + nums[1] = 0 < cíl
- (0, 2) protože 0 < 2 a nums[0] + nums[2] = 1 < cíl
- (0, 4) protože 0 < 4 a nums[0] + nums[4] = 0 < cíl
Všimněte si, že (0, 3) se nepočítá, protože nums[0] + nums[3] není striktně menší než cíl.

Příklad 2:

Vstup: nums = [-6,2,5,-2,-7,-1,3], cíl = -2
Výstup: 10
Vysvětlení: Existuje 10 párů indexů, které splňují podmínky v prohlášení:
- (0, 1) protože 0 < 1 a nums[0] + nums[1] = -4 < cíl
- (0, 3) protože 0 < 3 a nums[0] + nums[3] = -8 < cíl
- (0, 4) protože 0 < 4 a nums[0] + nums[4] = -13 < cíl
- (0, 5) protože 0 < 5 a nums[0] + nums[5] = -7 < cíl
- (0, 6) protože 0 < 6 a nums[0] + nums[6] = -3 < cíl
- (1, 4) protože 1 < 4 a nums[1] + nums[4] = -5 < cíl
- (3, 4) protože 3 < 4 a nums[3] + nums[4] = -9 < cíl
- (3, 5) protože 3 < 5 a nums[3] + nums[5] = -3 < cíl
- (4, 5) protože 4 < 5 a nums[4] + nums[5] = -8 < cíl
- (4, 6) protože 4 < 6 a nums[4] + nums[6] = -4 < cíl

Omezení:

1 <= nums.length == n <= 50
-50 <= nums[i], cíl <= 50

Je dáno celé pole nums s nulovým indexováním délky n a celé číslo target, vraťte počet dvojic (i, j), kde 0 <= i < j < n a nums[i] + nums[j] < target.

Příklad 1:

Vstup: nums = [-1,1,2,3,1], target = 2
Výstup: 3
Vysvětlení: Existují 3 dvojice indexů, které splňují podmínky uvedené v zadání:
- (0, 1) protože 0 < 1 a nums[0] + nums[1] = 0 < target
- (0, 2) protože 0 < 2 a nums[0] + nums[2] = 1 < target
- (0, 4) protože 0 < 4 a nums[0] + nums[4] = 0 < target
Upozorňujeme, že (0, 3) není započítán, protože nums[0] + nums[3] není přísně menší než target.

Příklad 2:

Vstup: nums = [-6,2,5,-2,-7,-1,3], target = -2
Výstup: 10
Vysvětlení: Existuje 10 dvojic indexů, které splňují podmínky uvedené v zadání:
- (0, 1) protože 0 < 1 a nums[0] + nums[1] = -4 < target
- (0, 3) protože 0 < 3 a nums[0] + nums[3] = -8 < target
- (0, 4) protože 0 < 4 a nums[0] + nums[4] = -13 < target
- (0, 5) protože 0 < 5 a nums[0] + nums[5] = -7 < target
- (0, 6) protože 0 < 6 a nums[0] + nums[6] = -3 < target
- (1, 4) protože 1 < 4 a nums[1] + nums[4] = -5 < target
- (3, 4) protože 3 < 4 a nums[3] + nums[4] = -9 < target
- (3, 5) protože 3 < 5 a nums[3] + nums[5] = -3 < target
- (4, 5) protože 4 < 5 a nums[4] + nums[5] = -8 < target
- (4, 6) protože 4 < 6 a nums[4] + nums[6] = -4 < target

Omezení:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Při zadání 0-indexovaného celočíselného pole nums délky n a celočíselného cíle vraťte počet dvojic (i, j), kde 0 <= i < j < n a nums[i] + nums[j] < cíl.

Příklad 1:

Vstup: nums = [-1,1,2,3,1], target = 2
Výstup: 3
Vysvětlení: V příkazu jsou 3 dvojice indexů, které splňují podmínky:
- (0, 1), protože 0 < 1 a nums[0] + nums[1] = 0 < target
- (0, 2), protože 0 < 2 a nums[0] + nums[2] = 1 < cíl
- (0, 4), protože 0 < 4 a nums[0] + nums[4] = 0 < cíl
Všimněte si, že (0, 3) se nepočítá, protože nums[0] + nums[3] není striktně menší než cíl.

Příklad 2:

Vstup: nums = [-6,2,5,-2,-7,-1,3], cíl = -2
Výstup: 10
Vysvětlení: V příkazu je 10 dvojic indexů, které splňují podmínky:
- (0, 1), protože 0 < 1 a nums[0] + nums[1] = -4 < target
- (0, 3), protože 0 < 3 a nums[0] + nums[3] = -8 < cíl
- (0, 4), protože 0 < 4 a nums[0] + nums[4] = -13 < cíl
- (0, 5), protože 0 < 5 a nums[0] + nums[5] = -7 < cíl
- (0, 6), protože 0 < 6 a nums[0] + nums[6] = -3 < cíl
- (1, 4), protože 1 < 4 a nums[1] + nums[4] = -5 < cíl
- (3, 4), protože 3 < 4 a nums[3] + nums[4] = -9 < cíl
- (3, 5), protože 3 < 5 a nums[3] + nums[5] = -3 < cíl
- (4, 5), protože 4 < 5 a nums[4] + nums[5] = -8 < cíl
- (4, 6), protože 4 < 6 a nums[4] + nums[6] = -4 < cíl

Omezení:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50


Je vám dáno 0-indexované pole usageLimits délky n.
Vaším úkolem je vytvořit skupiny s použitím čísel od 0 do n - 1, přičemž zajistíte, že každé číslo i nebude použito vícekrát než usageLimits[i] celkem ve všech skupinách. Musíte také splnit následující podmínky:

Každá skupina musí obsahovat různá čísla, což znamená, že v jedné skupině nejsou povolena duplicitní čísla.
Každá skupina (kromě první) musí mít délku přísně větší než předchozí skupina.

Návratovou hodnotou je celé číslo označující maximální počet skupin, které můžete vytvořit při splnění těchto podmínek.

Příklad 1:

Vstup: usageLimits = [1,2,5]
Výstup: 3
Vysvětlení: V tomto příkladu můžeme použít 0 maximálně jednou, 1 maximálně dvakrát a 2 maximálně pětkrát.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [2].
Skupina 2 obsahuje čísla [1,2].
Skupina 3 obsahuje čísla [0,1,2].
Lze ukázat, že maximální počet skupin je 3.
Výstup je tedy 3.

Příklad 2:

Vstup: usageLimits = [2,1,2]
Výstup: 2
Vysvětlení: V tomto příkladu můžeme použít 0 maximálně dvakrát, 1 maximálně jednou a 2 maximálně dvakrát.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [0].
Skupina 2 obsahuje čísla [1,2].
Lze ukázat, že maximální počet skupin je 2.
Výstup je tedy 2.

Příklad 3:

Vstup: usageLimits = [1,1]
Výstup: 1
Vysvětlení: V tomto příkladu můžeme použít 0 i 1 maximálně jednou.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [0].
Lze ukázat, že maximální počet skupin je 1.
Výstup je tedy 1.

Omezení:

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

Je vám poskytnuto pole usageLimits s indexem 0 délky n.
Vaším úkolem je vytvořit skupiny pomocí čísel od 0 do n - 1 a zajistit, aby každé číslo, i, nebylo použito více než usageLimits[i] krát celkem ve všech skupinách. Musíte také splnit následující podmínky:

Každá skupina se musí skládat z různých čísel, což znamená, že v rámci jedné skupiny nejsou povolena žádná duplicitní čísla.
Každá skupina (kromě první) musí mít délku striktně větší než předchozí skupina.

Vrátí celé číslo označující maximální počet skupin, které můžete vytvořit při splnění těchto podmínek.

Příklad 1:

Vstup: usageLimits = [1,2,5]
Výstup: 3
Vysvětlení: V tomto příkladu můžeme použít 0 maximálně jednou, 1 maximálně dvakrát a 2 maximálně pětkrát.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [2].
Skupina 2 obsahuje čísla [1,2].
Skupina 3 obsahuje čísla [0,1,2].
Lze ukázat, že maximální počet skupin je 3.
Výstup je tedy 3.
Příklad 2:

Vstup: usageLimits = [2,1,2]
Výstup: 2
Vysvětlení: V tomto příkladu můžeme použít 0 maximálně dvakrát, 1 maximálně jednou a 2 maximálně dvakrát.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [0].
Skupina 2 obsahuje čísla [1,2].
Lze ukázat, že maximální počet skupin jsou 2.
Výstup je tedy 2.

Příklad 3:

Vstup: usageLimits = [1,1]
Výstup: 1
Vysvětlení: V tomto příkladu můžeme použít 0 i 1 maximálně jednou.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [0].
Lze ukázat, že maximální počet skupin je 1.
Výstup je tedy 1.

Omezení:

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

Dostanete 0-indexované pole limity použití délky n.
Vaším úkolem je vytvořit skupiny pomocí čísel od 0 do n - 1 a zajistit, aby každé číslo, i, nebylo ve všech skupinách použito více než limity použití[i] celkem. Musíte také splnit následující podmínky:

Každá skupina musí obsahovat různá čísla, což znamená, že v rámci jedné skupiny nejsou povolena žádná duplicitní čísla.
Každá skupina (kromě první) musí mít striktně větší délku než předchozí skupina.

Vrátíte celé číslo označující maximální počet skupin, které můžete vytvořit při splnění těchto podmínek.

Příklad 1:

Vstup: limity použití = [1,2,5]
Výstup: 3
Vysvětlení: V tomto příkladu můžeme použít 0 maximálně jednou, 1 maximálně dvakrát a 2 maximálně pětkrát.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [2].
Skupina 2 obsahuje čísla [1,2].
Skupina 3 obsahuje čísla [0,1,2].
Lze ukázat, že maximální počet skupin je 3.
Takže výstup je 3.
Příklad 2:

Vstup: limity použití = [2,1,2]
Výstup: 2
Vysvětlení: V tomto příkladu můžeme použít 0 maximálně dvakrát, 1 maximálně jednou a 2 maximálně dvakrát.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [0].
Skupina 2 obsahuje čísla [1,2].
Lze ukázat, že maximální počet skupin je 2.
Takže výstup je 2.

Příklad 3:

Vstup: limity použití = [1,1]
Výstup: 1
Vysvětlení: V tomto příkladu můžeme použít 0 i 1 maximálně jednou.
Jedním ze způsobů, jak vytvořit maximální počet skupin při splnění podmínek, je:
Skupina 1 obsahuje číslo [0].
Lze ukázat, že maximální počet skupin je 1.
Takže výstup je 1.

Omezení:

1 <= limity použití.length <= 10^5
1 <= limity použití[i] <= 10^9


Je vám dáno pole `nums` indexované od 0 obsahující `n` celých čísel. Každou vteřinu provedete na tomto poli následující operaci:

Pro každý index `i` v rozsahu `[0, n - 1]` nahraďte `nums[i]` buď `nums[i]`, `nums[(i - 1 + n) % n]`, nebo `nums[(i + 1) % n]`.

Všimněte si, že všechny prvky jsou nahrazeny současně. Vraťte minimální počet sekund potřebných k tomu, aby všechny prvky v poli `nums` byly stejné.

Příklad 1:

Vstup: `nums = [1,2,1,2]`
Výstup: `1`
Vysvětlení: Pole můžeme srovnat do 1 sekundy následujícím způsobem:
- V 1. sekundě nahradíme hodnoty na každém indexu pomocí `[nums[3],nums[1],nums[3],nums[3]]`. Po náhradě je `nums = [2,2,2,2]`.
Lze dokázat, že 1 sekunda je minimální počet sekund potřebných pro srovnání pole.

Příklad 2:

Vstup: `nums = [2,1,3,3,2]`
Výstup: `2`
Vysvětlení: Pole můžeme srovnat do 2 sekund následujícím způsobem:
- V 1. sekundě nahradíme hodnoty na každém indexu pomocí `[nums[0],nums[2],nums[2],nums[2],nums[3]]`. Po náhradě je `nums = [2,3,3,3,3]`.
- Ve 2. sekundě nahradíme hodnoty na každém indexu pomocí `[nums[1],nums[1],nums[2],nums[3],nums[4]]`. Po náhradě je `nums = [3,3,3,3,3]`.
Lze dokázat, že 2 sekundy jsou minimální počet sekund potřebných pro srovnání pole.

Příklad 3:

Vstup: `nums = [5,5,5,5]`
Výstup: `0`
Vysvětlení: Nemusíme provádět žádné operace, protože všechny prvky v počátečním poli jsou stejné.

Omezení:

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

Dostanete pole nums indexované 0 obsahující n celých čísel.
Každou sekundu provedete s polem následující operaci:

Pro každý index i v rozsahu [0, n - 1] nahraďte nums[i] buď nums[i], nums[(i - 1 + n) % n] nebo nums[(i + 1) % n].

Všimněte si, že všechny prvky budou nahrazeny současně.
Vrátí minimální počet sekund potřebný k tomu, aby se všechny prvky v poli shodovaly.

Příklad 1:

Vstup: nums = [1,2,1,2]
Výstup: 1
Vysvětlení: Pole můžeme vyrovnat za 1 sekundu následujícím způsobem:
- V 1^. sekundě nahraďte hodnoty v každém indexu za [nums[3],nums[1],nums[3],nums[3]]. Po nahrazení jsou nums = [2,2,2,2].
Lze dokázat, že 1 sekunda je minimální doba sekund potřebná pro vyrovnání pole.

Příklad 2:

Vstup: nums = [2,1,3,3,2]
Výstup: 2
Vysvětlení: Pole můžeme vyrovnat za 2 sekundy následujícím způsobem:
- V 1^. sekundě nahraďte hodnoty v každém indexu za [nums[0],nums[2],nums[2],nums[3]]. Po nahrazení jsou nums = [2,3,3,3,3].
- Ve 2^. sekundě nahraďte hodnoty v každém indexu za [nums[1],nums[1],nums[2],nums[3],nums[4]]. Po nahrazení jsou nums = [3,3,3,3,3].
Lze dokázat, že 2 sekundy jsou minimální doba potřebná pro vyrovnání pole.

Příklad 3:

Vstup: nums= [5,5,5,5]
Výstup: 0
Vysvětlení: Nemusíme provádět žádné operace, protože všechny prvky v počátečním poli jsou stejné.

Omezení:

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

Je zadáno pole nums s indexem 0, které obsahuje n celých čísel.
V každé sekundě provedete nad polem následující operaci:

Pro každý index i v rozsahu [0, n - 1] nahraďte nums[i] buď nums[i], nums[(i - 1 + n) % n], nebo nums[(i + 1) % n].

Všimněte si, že všechny prvky budou nahrazeny současně.
Vraťte minimální počet sekund potřebných k tomu, aby se všechny prvky v poli nums rovnaly.

Příklad 1:

Vstup: nums = [1,2,1,2]
Výstup: 1
Vysvětlení: Nums je pole, které můžeme vyrovnat za 1 sekundu následujícím způsobem:
- V první sekundě nahradíme hodnoty na každém indexu hodnotami [nums[3],nums[1],nums[3],nums[3]]. Po nahrazení je nums = [2,2,2,2].
Lze dokázat, že 1 sekunda je minimální doba potřebná k vyrovnání pole.

Příklad 2:

Vstup: nums = [2,1,3,3,2].
Výstup: 2
Vysvětlení: Za 2 sekundy můžeme pole vyrovnat následujícím způsobem:
- V první sekundě nahradíme hodnoty na každém indexu hodnotami [nums[0],nums[2],nums[2],nums[2],nums[3]]. Po nahrazení je nums = [2,3,3,3,3].
- Ve druhé sekundě nahraďte hodnoty na každém indexu pomocí [nums[1],nums[1],nums[2],nums[3],nums[4]]. Po nahrazení je nums = [3,3,3,3,3].
Lze dokázat, že 2 sekundy jsou minimální doba potřebná k vyrovnání pole.

Příklad 3:

Vstup: nums = [5,5,5,5]
Výstup: 0
Vysvětlení: Nemusíme provádět žádné operace, protože všechny prvky v počátečním poli jsou stejné.

Omezení:

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


Jsou-li zadána dvě celá kladná čísla low a high reprezentovaná jako řetězce, najděte počet krokujících čísel v oboru [low, high] včetně.
Krokové číslo je takové celé číslo, že všechny jeho sousední číslice mají absolutní rozdíl přesně 1.
Vraťte celé číslo označující počet krokových čísel v inkluzivním rozsahu [low, high].
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.
Poznámka: Krokové číslo by nemělo mít úvodní nulu.

Příklad 1:

Vstup: low = „1“, high = „11“
Výstup: 10
Vysvětlení: Krokovací čísla v rozsahu [1,11] jsou 1, 2, 3, 4, 5, 6, 7, 8, 9 a 10. V rozsahu je celkem 10 krokových čísel. Výstupem je tedy 10.
Příklad 2:

Vstup: low = „90“, high = „101“
Výstup: 2
Vysvětlení: Krokovací čísla v rozsahu [90,101] jsou 98 a 101. V rozsahu jsou celkem 2 krokovací čísla. Výstupem je tedy číslo 2.

Omezení:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low a high se skládají pouze z číslic.
low a high nemají žádné počáteční nuly.

Zadaná dvě kladná celá čísla, nízká a vysoká, reprezentovaná jako řetězce, najděte počet krokových čísel v inkluzivním rozsahu [nízká, vysoká].
Krokové číslo je celé číslo, u něhož všechny jeho sousední číslice mají absolutní rozdíl přesně 1.
Vrátíte celé číslo označující počet krokových čísel v inkluzivním rozsahu [nízká, vysoká].
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.
Poznámka: Krokové číslo by nemělo mít úvodní nulu.

Příklad 1:

Vstup: nízký = "1", vysoký = "11"
Výstup: 10
Vysvětlení: Kroková čísla v rozsahu [1,11] jsou 1, 2, 3, 4, 5, 6, 7, 8, 9 a 10. V rozsahu je celkem 10 krokových čísel. Výstup je tedy 10.
Příklad 2:

Vstup: nízký = "90", vysoký = "101"
Výstup: 2
Vysvětlení: Kroková čísla v rozsahu [90,101] jsou 98 a 101. V rozsahu jsou celkem 2 kroková čísla. Výstup je tedy 2.

Omezení:

1 <= int(nízká) <= int(vysoká) < 10^100
1 <= nízká.length, vysoká.length <= 100
nízké a vysoké se skládají pouze z číslic.
nízké a vysoké nemají žádné úvodní nuly.

Jsou-li zadána dvě celá kladná čísla low a high reprezentovaná jako řetězce, najděte počet krokujících čísel v oboru [low, high] včetně.
Krokové číslo je takové celé číslo, že všechny jeho sousední číslice mají absolutní rozdíl přesně 1.
Vraťte celé číslo označující počet krokových čísel v inkluzivním rozsahu [low, high].
Protože odpověď může být velmi velká, vraťte ji modulo 10^9 + 7.
Poznámka: Krokové číslo by nemělo mít úvodní nulu.

Příklad 1:

Vstup: low = "1“, high = „11“
Výstup: 10
Vysvětlení: Krokovací čísla v rozsahu [1,11] jsou 1, 2, 3, 4, 5, 6, 7, 8, 9 a 10. V rozsahu je celkem 10 krokových čísel. Výstupem je tedy 10.
Příklad 2:

Vstup: low = "90“, high = "101“
Výstup: 2
Vysvětlení: Krokovací čísla v rozsahu [90,101] jsou 98 a 101. V rozsahu jsou celkem 2 krokovací čísla. Výstupem je tedy číslo 2.

Omezení:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
low a high se skládají pouze z číslic.
low a high nemají žádné počáteční nuly.


Jsou zadána dvě pole celých čísel s indexem 0 nums1 a nums2 stejné délky. Každou sekundu se pro všechny indexy 0 <= i < nums1.length zvýší hodnota nums1[i] o nums2[i]. Po provedení této operace můžete provést následující operaci:

Zvolte index 0 <= i < nums1.length a proveďte nums1[i] = 0.

Dále máte k dispozici celé číslo x.
Vraťte minimální čas, za který můžete dosáhnout toho, aby součet všech prvků nums1 byl menší nebo roven x, nebo -1, pokud to není možné.

Příklad 1:

Vstup: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Výstup: 3
Vysvětlení:
Pro 1. sekundu použijeme operaci na i = 0. Proto nums1 = [0,2+2,3+3] = [0,4,6].
Pro 2. sekundu použijeme operaci na i = 1. Proto nums1 = [0+1,0,6+3] = [1,0,9].
Pro 3. sekundu použijeme operaci na i = 2. Proto nums1 = [1+1,0+2,0] = [2,2,0].
Nyní je součet nums1 = 4. Lze ukázat, že tyto operace jsou optimální, proto vracíme 3.

Příklad 2:

Vstup: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Výstup: -1
Vysvětlení: Lze ukázat, že součet nums1 bude vždy větší než x, bez ohledu na to, jaké operace se provedou.

Omezení:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6

Dostanete dvě 0-indexovaná celočíselná pole nums1 a nums2 stejné délky. Každou sekundu pro všechny indexy 0 <= i < nums1.length se hodnota nums1[i] zvyšuje o nums2[i]. Poté, co to uděláte, můžete provést následující operaci:

Vyberte index 0 <= i < nums1.length a nastavte nums1[i] = 0.

Dostanete také celé číslo x.
Vraťte minimální čas, za který můžete udělat součet všech prvků nums1 menší nebo rovný x, nebo -1, pokud to není možné.

Příklad 1:

Vstup: nums1 = [1,2,3], nums2 = [1,2,3], x = 4
Výstup: 3
Vysvětlení:
Na 1. sekundu aplikujeme operaci na i = 0. Tedy nums1 = [0,2+2,3+3] = [0,4,6].
Na 2. sekundu aplikujeme operaci na i = 1. Tedy nums1 = [0+1,0,6+3] = [1,0,9].
Na 3. sekundu aplikujeme operaci na i = 2. Tedy nums1 = [1+1,0+2,0] = [2,2,0].
Nyní součet nums1 = 4. Lze ukázat, že tyto operace jsou optimální, takže vrátíme 3.

Příklad 2:

Vstup: nums1 = [1,2,3], nums2 = [3,3,3], x = 4
Výstup: -1
Vysvětlení: Lze ukázat, že součet nums1 bude vždy větší než x, bez ohledu na to, jaké operace budou provedeny.

Omezení:

1 <= nums1.length <= 10^3
1 <= nums1[i] <= 10^3
0 <= nums2[i] <= 10^3
nums1.length == nums2.length
0 <= x <= 10^6


Je dáno 2D pole celočíselných souřadnic a celé číslo k, kde souřadnice[i] = [x_i, y_i] jsou souřadnice i^tého bodu ve 2D rovině.
Vzdálenost mezi dvěma body (x_1, y_1) a (x_2, y_2) definujeme jako (x1 XOR x2) + (y1 XOR y2), kde XOR je bitová operace XOR.
Vraťte počet dvojic (i, j) takových, že i < j a vzdálenost mezi body i a j je rovna k.

Příklad 1:

Vstup: souřadnice = [[1,2],[4,2],[1,3],[5,2]], k = 5
Výstup: 2
Vysvětlení: Můžeme zvolit následující dvojice:
- (0,1): Protože máme (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Protože máme (1 XOR 5) + (3 XOR 2) = 5.

Příklad 2:

Vstup: souřadnice = [[1,3],[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Výstup: 10
Vysvětlení: Kterékoli dvě vybrané dvojice budou mít vzdálenost 0. Existuje 10 způsobů, jak vybrat dvě dvojice.

Omezení:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Dostanete souřadnice 2D celočíselného pole a celé číslo k, kde souřadnice[i] = [x_i, y_i] jsou souřadnice i^-tého bodu ve 2D rovině.
Vzdálenost mezi dvěma body (x_1, y_1) a (x_2, y_2) definujeme jako (x1 XOR x2) + (y1 XOR y2), kde XOR je bitová operace XOR.
Vraťte počet dvojic (i, j) takový že i < j a vzdálenost mezi body i a j je rovna k.

Příklad 1:

Zadání: souřadnice = [[1,2],[4,2],[1,3],[5,2]], k = 5
Výstup: 2
Vysvětlení: Můžeme zvolit následující dvojice:
- (0,1): Protože máme (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Protože máme (1 XOR 5) + (3 XOR 2) = 5.

Příklad 2:

Zadání: souřadnice = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
Výstup: 10
Vysvětlení: Jakékoli dva vybrané páry budou mít vzdálenost 0. Existuje 10 způsobů, jak vybrat dva páry.

Omezení:

2 <= souřadnice.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100

Dostanete 2D celočíselné souřadnice pole a celé číslo k, kde coordinates[i] = [x_i, y_i] jsou souřadnice i^tého bodu ve 2D rovině.
Vzdálenost mezi dvěma body (x_1, y_1) a (x_2, y_2) definujeme jako (x1 XOR x2) + (y1 XOR y2), kde XOR je bitová operace XOR.
Vrátí počet párů (i, j) takový, že i < j a vzdálenost mezi body i a j je rovna k.

Příklad 1:

Vstup: coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
Výstup: 2
Vysvětlení: Můžeme si vybrat následující páry:
- (0,1): Protože máme (1 XOR 4) + (2 XOR 2) = 5.
- (2,3): Protože máme (1 XOR 5) + (3 XOR 2) = 5.

Příklad 2:

Vstup: coordinates = [[1,3],[1,3],[1,3],[1,3]], k = 0
Výstup: 10
Vysvětlení: Jakékoli dva vybrané páry budou mít vzdálenost 0. Existuje 10 způsobů, jak si vybrat dva páry.

Omezení:

2 <= coordinates.length <= 50000
0 <= x_i, y_i <= 10^6
0 <= k <= 100


Máte dané pole celých čísel nums a dvě kladná celá čísla m a k.
Vraťte maximální součet ze všech téměř jedinečných podpolí délky k pole nums. Pokud takové podpole neexistuje, vraťte 0.
Podpole pole nums je téměř jedinečné, pokud obsahuje alespoň m různých prvků.
Podpole je souvislá neprázdná posloupnost prvků v rámci pole.

Příklad 1:

Vstup: nums = [2,6,7,3,1,7], m = 3, k = 4
Výstup: 18
Vysvětlení: Existují 3 téměř jedinečná podpolí velikosti k = 4. Tato podpolí jsou [2, 6, 7, 3], [6, 7, 3, 1] a [7, 3, 1, 7]. Mezi těmito podpolími má největší součet podpole [2, 6, 7, 3] se součtem 18.

Příklad 2:

Vstup: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Výstup: 23
Vysvětlení: Existuje 5 téměř jedinečných podpolí velikosti k. Tato podpolí jsou [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] a [4, 5, 4]. Mezi těmito podpolími má největší součet podpole [5, 9, 9] se součtem 23.

Příklad 3:

Vstup: nums = [1,2,1,2,1,2,1], m = 3, k = 3
Výstup: 0
Vysvětlení: Ve zadaném poli [1,2,1,2,1,2,1] neexistují žádná podpolí délky k = 3, která obsahují alespoň m = 3 různé prvky. Proto neexistují žádná téměř jedinečná podpolí a maximální součet je 0.

Omezení:

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

Dostanete celočíselné pole nums a dvě kladná celá čísla ma k.
Vraťte maximální součet ze všech téměř jedinečných podpolí délky k nums. Pokud žádné takové podpole neexistuje, vraťte 0.
Podskupina nums je téměř jedinečná, pokud obsahuje alespoň m různých prvků.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [2,6,7,3,1,7], m = 3, k = 4
Výstup: 18
Vysvětlení: Existují 3 téměř jedinečná podpole o velikosti k = 4. Tato podpole jsou [2, 6, 7, 3], [6, 7, 3, 1] a [7, 3, 1, 7]. Mezi těmito podpolemi je to s maximálním součtem [2, 6, 7, 3], které má součet 18.

Příklad 2:

Vstup: nums = [5,9,9,2,4,5,4], m = 1, k = 3
Výstup: 23
Vysvětlení: Existuje 5 téměř jedinečných podpolí o velikosti k. Tato podpole jsou [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5] a [4, 5, 4]. Mezi těmito podpolemi je to s maximálním součtem [5, 9, 9], které má součet 23.

Příklad 3:

Vstup: nums = [1,2,1,2,1,2,1], m = 3, k = 3
Výstup: 0
Vysvětlení: V daném poli [1,2,1,2,1,2,1] nejsou žádná podpole o velikosti k = 3, která by obsahovala alespoň m = 3 různé prvky. Proto neexistují žádná téměř jedinečná podpole a maximální součet je 0.

Omezení:

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= počet.length
1 <= nums[i] <= 10^9


Zpočátku máte na bankovním účtu zůstatek 100 dolarů.
Je vám přidělena celočíselná částka nákupu představující částku, kterou utratíte za nákup v dolarech.
V obchodě, kde budete nakupovat, je částka nákupu zaokrouhlena na nejbližší násobek 10. Jinými slovy, zaplatíte nezápornou částku roundedAmount, takže roundedAmount je násobek 10 a abs(roundedAmount - purchaseAmount ) je minimalizováno.
Pokud existuje více než jeden nejbližší násobek 10, vybere se největší násobek.
Po provedení nákupu v hodnotě nákupu vraťte celé číslo označující zůstatek na účtuČástka dolarů z obchodu.
Poznámka: 0 je v tomto problému považována za násobek 10.

Příklad 1:

Vstup: částka nákupu = 9
Výstup: 90
Vysvětlení: V tomto příkladu je nejbližší násobek 10 až 9 10. Zůstatek vašeho účtu tedy bude 100 – 10 = 90.

Příklad 2:

Vstup: částka nákupu = 15
Výstup: 80
Vysvětlení: V tomto příkladu existují dva nejbližší násobky 10 až 15: 10 a 20. Je tedy vybrán větší násobek, 20.
Zůstatek na vašem účtu tak bude 100 – 20 = 80.

Omezení:

0 <= purchaseAmount <= 100

Zpočátku máte na bankovním účtu zůstatek 100 dolarů.
Je vám zadáno celé číslo purchaseAmount, které představuje částku, kterou utratíte za nákup v dolarech.
V obchodě, kde nákup uskutečníte, se částka nákupu zaokrouhlí na nejbližší násobek 10. Jinými slovy, zaplatíte nezápornou částku, zaokrouhlenouAmount, takovou, aby zaokrouhlenáAmount byla násobkem 10 a abs(zaokrouhlenáAmount - nákupníAmount) byla minimální.
Pokud existuje více než jeden nejbližší násobek 10, vybere se největší násobek.
Vrátí celé číslo označující zůstatek na účtu po provedení nákupu v hodnotě dolarů purchaseAmount v obchodě.
Poznámka: V tomto problému se za násobek 10 považuje 0.

Příklad 1:

Vstup: purchaseAmount = 9
Výstup: 90
Vysvětlení: V tomto příkladu je nejbližším násobkem čísla 10 číslo 10. Zůstatek na účtu tedy bude 100 - 10 = 90.

Příklad 2:

Vstup: PurchaseAmount = 15
Výstup: 80
Vysvětlení: V tomto příkladu jsou dva nejbližší násobky 10 až 15: 10 a 20. Je tedy vybrán větší násobek, 20.
Zůstatek na účtu tedy bude 100 - 20 = 80.

Omezení:

0 <= PurchaseAmount <= 100

Zpočátku máte na bankovním účtu zůstatek 100 dolarů.
Je vám zadáno celé číslo purchaseAmount, které představuje částku, kterou utratíte za nákup v dolarech.
V obchodě, kde nákup provedete, se částka nákupu zaokrouhlí na nejbližší násobek 10. Jinými slovy, zaplatíte nezápornou částku, zaokrouhlenouAmount, takovou, aby zaokrouhlenáAmount byla násobkem 10 a abs(zaokrouhlenáAmount - nákupAmount) byla minimální.
Pokud existuje více než jeden nejbližší násobek 10, vybere se největší násobek.
Vrátí celé číslo označující zůstatek na účtu po provedení nákupu v hodnotě dolarů purchaseAmount v obchodě.
Poznámka: V tomto problému se za násobek 10 považuje 0.

Příklad 1:

Vstup: purchaseAmount = 9
Výstup: 90
Vysvětlení: V tomto příkladu je nejbližším násobkem čísla 10 číslo 10. Zůstatek na účtu tedy bude 100 - 10 = 90.

Příklad 2:

Vstup: PurchaseAmount = 15
Výstup: 80
Vysvětlení: V tomto příkladu jsou dva nejbližší násobky 10 až 15: 10 a 20. Proto je vybrán větší násobek, 20.
Zůstatek na účtu tedy bude 100 - 20 = 80.

Omezení:

0 <= PurchaseAmount <= 100


Je dán seznam řetězců words a řetězec s. Určete, zda je s akronymem pro words. Řetězec s je považován za akronym pro words, pokud může být vytvořen spojením prvního znaku každého řetězce v words v pořadí. Například "ab" může být vytvořeno z ["apple", "banana"], ale nemůže být vytvořeno z ["bear", "aardvark"]. Vrátí true, pokud s je akronymem pro words, a false jinak.

Příklad 1:

Input: words = ["alice","bob","charlie"], s = "abc"
Output: true
Vysvětlení: První znaky ve slovech "alice", "bob" a "charlie" jsou 'a', 'b' a 'c'. Proto s = "abc" je akronym.

Příklad 2:

Input: words = ["an","apple"], s = "a"
Output: false
Vysvětlení: První znaky ve slovech "an" a "apple" jsou 'a' a 'a'. Akronym vytvořený spojením těchto znaků je "aa". Proto s = "a" není akronym.

Příklad 3:

Input: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Output: true
Vysvětlení: Spojením prvního znaku slov v poli získáme řetězec "ngguoy". Proto s = "ngguoy" je akronym.

Omezení:

1 <= words.length <= 100
1 <= words[i].length <= 10
1 <= s.length <= 100
words[i] a s se skládají z malých anglických písmen.

Dané pole řetězcových slov a řetězec s určete, zda je s akronymem slov.
Řetězec s je považován za zkratku slov, pokud jej lze vytvořit zřetězením prvního znaku každého řetězce ve slovech v pořadí. Například "ab" může být vytvořeno z ["jablko", "banán"], ale nemůže být vytvořeno z ["medvěd", "aardvark"].
Vraťte true, pokud je s akronymem slov, a v opačném případě false.

Příklad 1:

Vstup: slova = ["alice","bob","charlie"], s = "abc"
Výstup: pravda
Vysvětlení: První znak ve slovech "alice", "bob" a "charlie" jsou 'a', 'b' a 'c'. S = "abc" je tedy zkratka.

Příklad 2:

Vstup: slova = ["an","apple"], s = "a"
Výstup: nepravda
Vysvětlení: První znak ve slovech „an“ a „apple“ jsou „a“ a „a“.
Zkratka vytvořená zřetězením těchto znaků je „aa“.
S = "a" tedy není zkratka.

Příklad 3:

Vstup: slova = ["nikdy","gonna","dát","up","on","you"], s = "ngguoy"
Výstup: pravda
Vysvětlení: Zřetězením prvního znaku slov v poli získáme řetězec "ngguoy".
S = "ngguoy" je tedy zkratka.

Omezení:

1 <= slova.length <= 100
1 <= slova[i].length <= 10
1 <= s.length <= 100
slova[i] a s se skládají z malých anglických písmen.