Máte dány dvě celá čísla, num a t.
Celé číslo x se nazývá dosažitelné, pokud se může stát rovným num po provedení následující operace nejvýše t-krát:

Zvyšte nebo snižte x o 1 a současně zvyšte nebo snižte num o 1.

Vraťte maximální možné dosažitelné číslo. Je možné dokázat, že existuje alespoň jedno dosažitelné číslo.

Příklad 1:

Vstup: num = 4, t = 1
Výstup: 6
Vysvětlení: Maximální dosažitelné číslo je x = 6; může se stát rovným num po provedení této operace:
1- Snižte x o 1 a zvyšte num o 1. Nyní, x = 5 a num = 5.
Je možné dokázat, že neexistuje žádné dosažitelné číslo větší než 6.

Příklad 2:

Vstup: num = 3, t = 2
Výstup: 7
Vysvětlení: Maximální dosažitelné číslo je x = 7; po provedení těchto operací bude x rovno num:
1- Snižte x o 1 a zvyšte num o 1. Nyní, x = 6 a num = 4.
2- Snižte x o 1 a zvyšte num o 1. Nyní, x = 5 a num = 5.
Je možné dokázat, že neexistuje žádné dosažitelné číslo větší než 7.

Omezení:

1 <= num, t <= 50

Jsou dána dvě celá čísla, num a t.
Celé číslo x se nazývá dosažitelné, pokud se může rovnat číslu num po použití následující operace nejvýše tkrát:

Zvětšete nebo zmenšete x o 1 a současně zvětšete nebo zmenšete num o 1.

Vraťte maximální možné dosažitelné číslo. Lze dokázat, že existuje alespoň jedno dosažitelné číslo.

Příklad 1:

Vstup: num = 4, t = 1
Výstup: 6
Vysvětlení: Maximální dosažitelné číslo je x = 6; po provedení této operace se může rovnat num:
Lze dokázat, že neexistuje žádné dosažitelné číslo větší než 6.
Nyní je x = 5 a num = 5.

Příklad 2:

Vstup: num = 3, t = 2
Výstup: 7
Vysvětlení: Po provedení těchto operací se x bude rovnat num:

    "1- Snižte x o 1 a zvyšte num o 1. Nyní je x = 6 a num = 4."
    "2- Snižte x o 1 a zvyšte num o 1. Nyní je x = 5 a num = 5."

Lze dokázat, že neexistuje žádné dosažitelné číslo větší než 7.

Omezení:

1 <= num, t <= 50

Jsou vám dána dvě celá čísla, num a t.
Celé číslo x se nazývá dosažitelné, pokud se může rovnat num po použití následující operace ne více než tkrát:

Zvyšte nebo snižte x o 1 a současně zvyšte nebo snižte číslo o 1.

Vraťte maximální možný dosažitelný číslo. Lze prokázat, že existuje alespoň jedno dosažitelné číslo.

Příklad 1:

Vstup: num = 4, t = 1
Výstup: 6
Vysvětlení: Maximální dosažitelný číslo je x = 6; po provedení této operace se může rovnat num:
1- Snižte x o 1 a zvyšte num o 1. Nyní x = 5 a num = 5.
Lze prokázat, že neexistuje žádné dosažitelné číslo větší než 6.

Příklad 2:

Vstup: num = 3, t = 2
Výstup: 7
Vysvětlení: Maximální dosažitelný číslo je x = 7; po provedení těchto operací se x bude rovnat num:
1- Snižte x o 1 a zvyšte num o 1. Nyní x = 6 a num = 4.
2- Snižte x o 1 a zvyšte num o 1. Nyní x = 5 a num = 5.
Lze prokázat, že neexistuje žádné dosažitelné číslo větší než 7.

Omezení:

1 <= num, t <= 50


Je dán řetězec s složený z malých písmen anglické abecedy a je dovoleno na něm provádět operace. V jedné operaci můžete nahradit znak v s jiným malým písmenem anglické abecedy.
Vaším úkolem je vytvořit z s palindrom s minimálním počtem operací. Pokud existuje více palindromů, které mohou být vytvořeny s minimálním počtem operací, vytvořte lexikograficky nejmenší.
Ř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 v abecedě vyskytuje dříve než odpovídající písmeno v b.
Vraťte výsledný palindrom.

Příklad 1:

Vstup: s = "egcfe"
Výstup: "efcfe"
Vysvětlení: Minimální počet operací, jak udělat z "egcfe" palindrom, je 1, a lexikograficky nejmenší palindrom, který můžeme získat změnou jednoho znaku, je "efcfe", změnou 'g'.

Příklad 2:

Vstup: s = "abcd"
Výstup: "abba"
Vysvětlení: Minimální počet operací, jak udělat z "abcd" palindrom, je 2, a lexikograficky nejmenší palindrom, který můžeme získat změnou dvou znaků, je "abba".

Příklad 3:

Vstup: s = "seven"
Výstup: "neven"
Vysvětlení: Minimální počet operací, jak udělat z "seven" palindrom, je 1, a lexikograficky nejmenší palindrom, který můžeme získat změnou jednoho znaku, je "neven".

Omezení:

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

Je vám dán řetězec s skládající se z malých anglických písmen a můžete s ním provádět operace. V jedné operaci můžete nahradit znak ve znaku s jiným malým anglickým písmenem.
Vaším úkolem je vytvořit palindrom s co nejmenším počtem operací. Pokud existuje více palindromů, které lze vytvořit s minimálním počtem operací, udělejte lexikograficky nejmenší.
Ř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.
Vraťte výsledný řetězec palindromu.

Příklad 1:

Vstup: s = "egcfe"
Výstup: "efcfe"
Vysvětlení: Minimální počet operací pro vytvoření "egcfe" jako palindromu je 1 a lexikograficky nejmenší řetězec palindromu, který můžeme získat úpravou jednoho znaku, je "efcfe", změnou "g".

Příklad 2:

Vstup: s = "abcd"
Výstup: "abba"
Vysvětlení: Minimální počet operací pro vytvoření "abcd" jako palindromu jsou 2 a lexikograficky nejmenší řetězec palindromu, který můžeme získat úpravou dvou znaků, je "abba".

Příklad 3:

Vstup: s = "seven"
Výstup: "neven"
Vysvětlení: Minimální počet operací pro vytvoření "seven" palindromu je 1 a lexikograficky nejmenší řetězec palindromu, který můžeme získat úpravou jednoho znaku, je "neven".

Omezení:

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

Dostanete řetězec s skládající se z malých anglických písmen a můžete s ním provádět operace. V jedné operaci můžete nahradit znak v s jiným malým anglickým písmenem.
Vaším úkolem je vytvořit z palindromu s co nejmenším počtem operací. Pokud existuje více palindromů, které lze vytvořit s použitím minimálního počtu operací, udělejte ten lexikograficky nejmenší.
Ř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.
Vraťte výsledný řetězec palindromu.

Příklad 1:

Vstup: s = "egcfe"
Výstup: "efcfe"
Vysvětlení: Minimální počet operací pro vytvoření palindromu z „egcfe“ je 1 a lexikograficky nejmenší řetězec palindromu, který můžeme získat úpravou jednoho znaku, je „efcfe“ změnou „g“.

Příklad 2:

Vstup: s = "abcd"
Výstup: "abba"
Vysvětlení: Minimální počet operací pro vytvoření "abcd" na palindrom je 2 a lexikograficky nejmenší řetězec palindromu, který můžeme získat úpravou dvou znaků, je "abba".

Příklad 3:

Vstup: s = "sedm"
Výstup: "ani"
Vysvětlení: Minimální počet operací pro vytvoření "sedmi" palindromem je 1 a lexikograficky nejmenší řetězec palindromu, který můžeme získat úpravou jednoho znaku, je "neven".

Omezení:

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


Máte zadaný binární řetězec `s` délky `n` s 0-indexováním, na kterém můžete provádět dva typy operací:

1. Vyberte index `i` a invertujte všechny znaky od indexu `0` do indexu `i` (včetně), s náklady `i + 1`.
2. Vyberte index `i` a invertujte všechny znaky od indexu `i` do indexu `n - 1` (včetně), s náklady `n - i`.

Vrátí minimální náklady na to, aby všechny znaky v řetězci byly stejné.
Invertování znaku znamená, že pokud jeho hodnota je `'0'`, stane se `'1'`, a naopak.

Příklad 1:

Vstup: s = "0011"
Výstup: 2
Vysvětlení: Aplikujte druhou operaci s \( i = 2 \) pro získání \( s = "0000" \) za cenu 2. Lze ukázat, že 2 je minimální náklad na to, aby byly všechny znaky stejné.

Příklad 2:

Vstup: s = "010101"
Výstup: 9
Vysvětlení: Aplikujte první operaci s \( i = 2 \) pro získání \( s = "101101" \) za cenu 3.
Aplikujte první operaci s \( i = 1 \) pro získání \( s = "011101" \) za cenu 2.
Aplikujte první operaci s \( i = 0 \) pro získání \( s = "111101" \) za cenu 1.
Aplikujte druhou operaci s \( i = 4 \) pro získání \( s = "111110" \) za cenu 2.
Aplikujte druhou operaci s \( i = 5 \) pro získání \( s = "111111" \) za cenu 1.
Celková cena na to, aby byly všechny znaky stejné, je 9. Lze ukázat, že 9 je minimální náklad na to, aby byly všechny znaky stejné.

Omezení:

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

Dostanete binární řetězec s indexovaný 0 o délce n, na který můžete použít dva typy operací:

Zvolte index i a invertujte všechny znaky z indexu 0 na index i (oba včetně), s cenou i + 1
Zvolte index i a invertujte všechny znaky z indexu i na index n - 1 (oba včetně), s cenou n - i

Vraťte minimální náklady, aby byly všechny znaky řetězce stejné.
Invertovat znak znamená, že pokud je jeho hodnota "0", stane se "1" a naopak.

Příklad 1:

Vstup: s = "0011"
Výstup: 2
Vysvětlení: Použijte druhou operaci s i = 2, abyste získali s = "0000" za cenu 2. Lze ukázat, že 2 je minimální cena za to, aby byly všechny znaky stejné.

Příklad 2:

Vstup: s = "010101"
Výstup: 9
Vysvětlení: Použijte první operaci s i = 2 a získejte s = "101101" za cenu 3.
Použijte první operaci s i = 1 a získejte s = "011101" za cenu 2.
Použijte první operaci s i = 0 a získejte s = "111101" za cenu 1.
Použijte druhou operaci s i = 4 a získejte s = "111110" za cenu 2.
Použijte druhou operaci s i = 5 a získejte s = "111111" za cenu 1.
Celkové náklady na vytvoření stejných znaků jsou 9. Lze ukázat, že 9 je minimální cena za to, aby byly všechny znaky stejné.

Omezení:

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

Dostanete 0-indexovaný binární řetězec s délky n, na kterém můžete použít dva typy operací:

Vyberte index i a invertujte všechny znaky z indexu 0 na index i (oba včetně), s cenou i + 1
Vyberte index i a invertujte všechny znaky z indexu i na index n - 1 (oba včetně), s cenou n - i

Vraťte minimální cenu, aby byly všechny znaky řetězce stejné.
Invertovat znak znamená, že pokud je jeho hodnota '0', stane se '1' a naopak.

Příklad 1:

Vstup: s = "0011"
Výstup: 2
Vysvětlení: Aplikujte druhou operaci s i = 2, abyste získali s = "0000" za cenu 2. Lze ukázat, že 2 je minimální cena, aby byly všechny znaky stejné.

Příklad 2:

Vstup: s = "010101"
Výstup: 9
Vysvětlení: Použijte první operaci s i = 2, abyste získali s = "101101" za cenu 3.
Použijte první operaci s i = 1, abyste získali s = "011101" za cenu 2.
Použijte první operaci s i = 0, abyste získali s = "111101" za cenu 1.
Aplikujte druhou operaci s i = 4, abyste získali s = "111110" za cenu 2.
Aplikujte druhou operaci s i = 5, abyste získali s = "111111" za cenu 1.
Celková cena za to, aby si všechny postavy byly rovny, je 9. Lze ukázat, že 9 je minimální cena, aby se všechny postavy srovnaly.

Omezení:

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


Při zadání kladného celého čísla num reprezentovaného jako řetězec vrátí celé číslo num bez koncových nul jako řetězec.

Příklad 1:

Vstup: num = „51230100“
Výstup: „512301“
Vysvětlení: Celé číslo „51230100“ má 2 koncové nuly, odstraníme je a vrátíme celé číslo „512301“.

Příklad 2:

Vstup: num = „123“
Výstup: „123“
Vysvětlení: Celé číslo „123“ nemá koncové nuly, vracíme celé číslo „123“.

Omezení:

1 <= num.length <= 1000
num se skládá pouze z číslic.
num nemá žádné počáteční nuly.

Zadané kladné celé číslo reprezentované jako řetězec vraťte celé číslo bez koncových nul jako řetězec.

Příklad 1:

Vstup: num = "51230100"
Výstup: "512301"
Vysvětlení: Celé číslo "51230100" má 2 koncové nuly, odstraníme je a vrátíme celé číslo "512301".

Příklad 2:

Vstup: num = "123"
Výstup: "123"
Vysvětlení: Celé číslo "123" nemá žádné koncové nuly, vrátíme celé číslo "123".

Omezení:

1 <= num.length <= 1000
num se skládá pouze z číslic.
num nemá žádné úvodní nuly.

Je dáno kladný celé číslo num reprezentované jako řetězec, vraťte celé číslo num bez koncových nul jako řetězec.

Příklad 1:

Vstup: num = "51230100"
Výstup: "512301"
Vysvětlení: Celé číslo "51230100" má 2 koncové nuly, odstraníme je a vrátíme celé číslo "512301".

Příklad 2:

Vstup: num = "123"
Výstup: "123"
Vysvětlení: Celé číslo "123" nemá žádné koncové nuly, vrátíme celé číslo "123".

Omezení:

1 <= num.length <= 1000
num se skládá pouze z číslic.
num nemá žádné úvodní nuly.


Dostanete celé číslo n, které se skládá přesně ze 3 číslic.
Číslo n nazýváme fascinujícím, pokud po následující úpravě výsledné číslo obsahuje všechny číslice od 1 do 9 právě jednou a neobsahuje žádné nuly:

Zřetězte n čísly 2 * n a 3 * n.

Vrátí hodnotu true, pokud je n fascinující, nebo false v opačném případě.
Zřetězení dvou čísel znamená jejich spojení. Například zřetězení čísel 121 a 371 je 121371.

Příklad 1:

Vstup: n = 192
Výstup: true
Vysvětlení: Zřetězíme čísla n = 192 a 2 * n = 384 a 3 * n = 576. Výsledné číslo je 192384576. Toto číslo obsahuje všechny číslice od 1 do 9 právě jednou.

Příklad 2:

Vstup: n = 100
Výstup: false
Vysvětlení: Zřetězíme čísla n = 100 a 2 * n = 200 a 3 * n = 300. Výsledné číslo je 100200300. Toto číslo nesplňuje žádnou z podmínek.

Omezení:

100 <= n <= 999

Dostanete celé číslo n, které se skládá z přesně 3 číslic.
Číslo n nazýváme fascinujícím, pokud po následující úpravě výsledné číslo obsahuje všechny číslice od 1 do 9 právě jednou a neobsahuje žádnou nulu:

Spojte n s čísly 2 * n a 3 * n.

Vraťte true, pokud je n fascinující, nebo nepravdu v opačném případě.
Zřetězení dvou čísel znamená jejich spojení dohromady. Například zřetězení 121 a 371 je 121371.

Příklad 1:

Vstup: n = 192
Výstup: pravda
Vysvětlení: Zřetězíme čísla n = 192 a 2 * n = 384 a 3 * n = 576. Výsledné číslo je 192384576. Toto číslo obsahuje všechny číslice od 1 do 9 právě jednou.

Příklad 2:

Vstup: n = 100
Výstup: nepravda
Vysvětlení: Zřetězíme čísla n = 100 a 2 * n = 200 a 3 * n = 300. Výsledné číslo je 100200300. Toto číslo nesplňuje žádnou z podmínek.

Omezení:

100 <= n <= 999


Je dána řetězec s s indexováním od 0, opakovaně proveďte následující operaci libovolněkrát:

Vyberte index i v řetězci a nechť c je znak na pozici i. Smažte nejbližší výskyt c vlevo od i (pokud existuje) a nejbližší výskyt c vpravo od i (pokud existuje).

Vaším úkolem je minimalizovat délku s provedením výše uvedené operace libovolněkrát.
Vraťte celé číslo označující délku minimalizovaného řetězce.

Příklad 1:

Vstup: s = "aaabc"
Výstup: 3
Vysvětlení: V tomto příkladu je s "aaabc". Můžeme začít výběrem znaku 'a' na indexu 1. Pak odstraníme nejbližší 'a' vlevo od indexu 1, což je na indexu 0, a nejbližší 'a' vpravo od indexu 1, což je na indexu 2. Po této operaci se řetězec změní na "abc". Jakákoli další operace na řetězci ho nezmění. Proto je délka minimalizovaného řetězce 3.

Příklad 2:

Vstup: s = "cbbd"
Výstup: 3
Vysvětlení: Můžeme začít se znakem 'b' na indexu 1. Neexistuje výskyt 'b' vlevo od indexu 1, ale je jeden vpravo na indexu 2, takže odstraníme 'b' na indexu 2. Řetězec se změní na "cbd" a další operace ho nezmění. Tedy minimalizovaná délka je 3.

Příklad 3:

Vstup: s = "dddaaa"
Výstup: 2
Vysvětlení: Můžeme začít se znakem 'd' na indexu 1. Nejbližší výskyt 'd' vlevo je na indexu 0 a nejbližší výskyt 'd' vpravo je na indexu 2. Smažeme oba indexy 0 a 2, takže řetězec se změní na "daaa". V novém řetězci můžeme vybrat znak 'a' na indexu 2. Nejbližší výskyt 'a' vlevo je na indexu 1 a nejbližší výskyt 'a' vpravo je na indexu 3. Smažeme oba a řetězec se změní na "da". Dále jej nelze minimalizovat, takže minimalizovaná délka je 2.

Omezení:

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

Vzhledem k řetězci s indexovaným 0 opakovaně proveďte následující operaci, kolikrát:

Vyberte index i v řetězci a nechejte c je znak na pozici i. Odstraňte nejbližší výskyt c nalevo od i (pokud existuje) a nejbližší výskyt c napravo od i (pokud existuje).

Vaším úkolem je minimalizovat délku s opakovaným provedením výše uvedené operace.
Vrátí celé číslo označující délku minimalizovaného řetězce.

Příklad 1:

Vstup: s = "aaabc"
Výstup: 3
Vysvětlení: V tomto příkladu je s "aaabc". Můžeme začít výběrem znaku „a“ na indexu 1. Poté odstraníme nejbližší „a“ nalevo od indexu 1, které je na indexu 0, a nejbližší „a“ napravo od indexu 1, což je na indexu 2. Po této operaci se řetězec změní na "abc". Jakákoli další operace, kterou na řetězci provedeme, jej ponechá beze změny. Proto je délka minimalizovaného řetězce 3.
Příklad 2:

Vstup: s = "cbbd"
Výstup: 3
Vysvětlení: Za tímto účelem můžeme začít znakem „b“ na indexu 1. Nalevo od indexu 1 se nevyskytuje „b“, ale napravo na indexu 2 je jedno, takže vymažeme „b“ na index 2. Řetězec se změní na "cbd" a další operace jej ponechá beze změny. Minimální délka je tedy 3.

Příklad 3:

Vstup: s = "dddaaa"
Výstup: 2
Vysvětlení: Za tímto účelem můžeme začít znakem „d“ na indexu 1. Nejbližší výskyt „d“ nalevo je na indexu 0 a nejbližší výskyt „d“ napravo je na indexu 2. Smažeme oba indexy 0 a 2, takže řetězec se stane "daaa". V novém řetězci můžeme vybrat znak „a“ na indexu 2. Nejbližší výskyt „a“ nalevo od něj je na indexu 1 a nejbližší výskyt „a“ napravo je na indexu 3. Smažeme oba a řetězec se stane "da". Nemůžeme to dále minimalizovat, takže minimalizovaná délka je 2.

Omezení:

1 <= s.length <= 100
s obsahuje pouze malá anglická písmena

Je dána řetězec s s indexováním od 0, opakovaně proveďte následující operaci libovolněkrát:

Vyberte index i v řetězci a nechť c je znak na pozici i. Smažte nejbližší výskyt c vlevo od i (pokud existuje) a nejbližší výskyt c vpravo od i (pokud existuje).

Vaším úkolem je minimalizovat délku s provedením výše uvedené operace libovolněkrát.
Vraťte celé číslo označující délku minimalizovaného řetězce.

Příklad 1:

Input: \(s = "aaabc"\)
Output: 3
Explanation: V tomto příkladu je \(s = "aaabc"\). Můžeme začít výběrem znaku 'a' na indexu 1. Poté odstraníme nejbližší 'a' vlevo od indexu 1, což je na indexu 0, a nejbližší 'a' vpravo od indexu 1, což je na indexu 2. Po této operaci se řetězec změní na "abc". Další operace na řetězci nezmění nic. Proto je délka minimalizovaného řetězce 3.

Příklad 2

Input: \(s = "cbbd"\)
Output: 3
Explanation: V tomto případě můžeme začít se znakem 'b' na indexu 1. Neexistuje žádný výskyt 'b' vlevo od indexu 1, ale vpravo je jeden na indexu 2, takže odstraníme 'b' na indexu 2. Řetězec se změní na "cbd" a další operace jej nezmění. Proto je minimalizovaná délka 3.

Příklad 3:

Input: (s = dddaaa)
Output: 2
Explanation: V tomto případě můžeme začít se znakem 'd' na indexu 1. Nejbližší výskyt 'd' vlevo od indexu 1 je na indexu 0 a nejbližší výskyt 'd' vpravo od indexu 1 je na indexu 2. Oba odstraníme, takže řetězec se změní na "daaa". V novém řetězci můžeme vybrat znak 'a' na indexu 2. Nejbližší výskyt 'a' vlevo od indexu 2 je na indexu 1 a nejbližší výskyt 'a' vpravo od indexu 2 je na indexu 3. Oba odstraníme a řetězec se změní na "da". Dále už řetězec nelze minimalizovat, takže minimalizovaná délka je 2.

Omezení:
1 ≤ \(s.\text{length}\) ≤ 100
\(s\) obsahuje pouze malá písmena anglické abecedy.


Je vám dáno pole celých čísel nums s indexováním od 0 a je vám povoleno procházet mezi jeho indexy. Mezi indexy i a j, kde i != j, můžete procházet tehdy a jen tehdy, když platí gcd(nums[i], nums[j]) > 1, kde gcd je největší společný dělitel.
Vaším úkolem je určit, zda pro každou dvojici indexů i a j v nums, kde i < j, existuje posloupnost průchodů, která nás přenese z i do j.
Vraťte true, pokud je možné procházet mezi všemi takovými dvojicemi indexů, nebo false jinak.

Příklad 1:

Vstup: nums = [2,3,6]
Výstup: true
Vysvětlení: V tomto příkladu existují 3 možné dvojice indexů: (0, 1), (0, 2) a (1, 2).
Chcete-li se dostat z indexu 0 do indexu 1, můžeme použít posloupnost průchodů 0 -> 2 -> 1, kde se pohybujeme z indexu 0 do indexu 2, protože gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, a pak se pohybujeme z indexu 2 do indexu 1, protože gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Chcete-li se dostat z indexu 0 do indexu 2, můžeme jít přímo, protože gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Stejně tak, chceme-li se dostat z indexu 1 do indexu 2, můžeme jít přímo, protože gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Příklad 2:

Vstup: nums = [3,9,5]
Výstup: false
Vysvětlení: Žádná posloupnost průchodů nás nedokáže přenést z indexu 0 do indexu 2 v tomto příkladu. Proto vracíme false.

Příklad 3:

Vstup: nums = [4,3,12,8]
Výstup: true
Vysvětlení: Existuje 6 možných dvojic indexů, mezi kterými lze procházet: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) a (2, 3). Pro každou dvojici existuje platná posloupnost průchodů, takže vracíme true.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums a můžete procházet mezi jeho indexy. Mezi indexem i a indexem j, i != j se můžete pohybovat právě tehdy, když gcd(nums[i], nums[j]) > 1, kde gcd je největší společný dělitel.
Vaším úkolem je určit, zda pro každou dvojici indexů i a j v nums, kde i < j, existuje posloupnost průchodů, která nás může vést z i do j.
Vraťte true, pokud je možné procházet mezi všemi takovými páry indexů, nebo false jinak.

Příklad 1:

Vstup: nums = [2,3,6]
Výstup: pravda
Vysvětlení: V tomto příkladu existují 3 možné dvojice indexů: (0, 1), (0, 2) a (1, 2).
K přechodu z indexu 0 na index 1 můžeme použít sekvenci průchodů 0 -> 2 -> 1, kde se přesuneme z indexu 0 na index 2, protože gcd(nums[0], nums[2]) = gcd(2 , 6) = 2 > 1 a poté se přesuňte z indexu 2 na index 1, protože gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Chcete-li přejít z indexu 0 na index 2, můžeme přejít přímo, protože gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Podobně, pokud chcete přejít z indexu 1 na index 2, můžeme jít přímo, protože gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Příklad 2:

Vstup: nums = [3,9,5]
Výstup: nepravda
Vysvětlení: Žádná sekvence průchodů nás v tomto příkladu nemůže dostat z indexu 0 na index 2. Takže vracíme false.

Příklad 3:

Vstup: nums = [4,3,12,8]
Výstup: pravda
Vysvětlení: Existuje 6 možných párů indexů, které lze procházet mezi: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) a (2, 3). Pro každý pár existuje platná sekvence průchodů, takže vrátíme hodnotu true.

Omezení:

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

Je vám dáno celočíselné pole nums indexované od 0 a je vám umožněno procházet mezi jeho indexy. Můžete procházet mezi indexem i a indexem j, i != j, pouze pokud gcd(nums[i], nums[j]) > 1, kde gcd je největší společný dělitel.
Vaším úkolem je určit, zda pro každou dvojici indexů i a j v nums, kde i < j, existuje sekvence průchodů, která nás může dostat z i do j. Vraťte true, pokud je možné procházet mezi všemi takovými dvojicemi indexů, nebo false v opačném případě.

Příklad 1:

Vstup: nums = [2,3,6]
Výstup: true
Vysvětlení: V tomto příkladu existují 3 možné dvojice indexů: (0, 1), (0, 2) a (1, 2).
Pro přechod z indexu 0 na index 1 můžeme použít sekvenci průchodů 0 -> 2 -> 1, kde se přesuneme z indexu 0 na index 2, protože gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, a pak se přesuneme z indexu 2 na index 1, protože gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
Pro přechod z indexu 0 na index 2 můžeme jít přímo, protože gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Stejně tak pro přechod z indexu 1 na index 2 můžeme jít přímo, protože gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.

Příklad 2:

Vstup: nums = [3,9,5]¨
Výstup: false
Vysvětlení: V tomto příkladu neexistuje žádná sekvence průchodů, která by nás mohla dostat z indexu 0 na index 2. Proto vracíme false.

Příklad 3:

Vstup: nums = [4,3,12,8]
Výstup: true
Vysvětlení: Existuje 6 možných dvojic indexů, mezi kterými lze procházet: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3) a (2, 3). Pro každou dvojici existuje platná sekvence průchodů, takže vracíme true.


Dostanete řetězec s, který se skládá pouze z malých anglických písmen. V jedné operaci můžete provést následující:

Vyberte libovolný neprázdný podřetězec s, případně celý řetězec, a poté nahraďte každý jeho znak předchozím znakem anglické abecedy. Například „b“ je převedeno na „a“ a „a“ je převedeno na „z“.

Vraťte lexikograficky nejmenší řetězec, který můžete získat po provedení výše uvedené operace přesně jednou.
Podřetězec je souvislá sekvence znaků v řetězci.
Řetězec x je lexikograficky menší než řetězec y stejné délky, pokud je x[i] před y[i] v abecedním pořadí pro první pozici i tak, že x[i] != y[i].

Příklad 1:

Vstup: s = "cbabc"
Výstup: "baabc"
Vysvětlení: Operaci aplikujeme na podřetězec začínající na indexu 0 a končící na indexu 1 včetně.
Lze prokázat, že výsledný řetězec je lexikograficky nejmenší.

Příklad 2:

Vstup: s = "acbbc"
Výstup: "abaab"
Vysvětlení: Operaci aplikujeme na podřetězec začínající na indexu 1 a končící na indexu 4 včetně.
Lze prokázat, že výsledný řetězec je lexikograficky nejmenší.

Příklad 3:

Vstup: s = "leetcode"
Výstup: "kddsbncd"
Vysvětlení: Operaci aplikujeme na celý řetězec.
Lze prokázat, že výsledný řetězec je lexikograficky nejmenší.

Omezení:

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

Dostanete řetězec skládající se pouze z malých anglických písmen. V jedné operaci můžete provést následující akce:

Vyberte libovolný neprázdný podřetězec s, případně celý řetězec, a pak každý z jeho znaků nahraďte předchozím znakem anglické abecedy. Například "b" se převede na "a" a "a" se převede na "z".

Vrátí lexikograficky nejmenší řetězec, který můžete získat po provedení výše uvedené operace právě jednou.
Podřetězec je souvislá posloupnost znaků v řetězci.
Řetězec x je lexikograficky menší než řetězec y stejné délky, pokud x[i] je před y[i] v abecedním pořadí pro první pozici i takovou, že x[i] != y[i].

Příklad 1:

Vstup: s = "cbabc"
Výstup: "baabc"
Vysvětlení: Operaci aplikujeme na podřetězec začínající na indexu 0 a končící na indexu 1 včetně.
Lze dokázat, že výsledný řetězec je lexikograficky nejmenší.

Příklad 2:

Vstup: s = "acbbc"
Výstup: "abaab"
Vysvětlení: Operaci aplikujeme na podřetězec začínající na indexu 1 a končící na indexu 4 včetně.
Lze dokázat, že výsledný řetězec je lexikograficky nejmenší.

Příklad 3:

Vstup: s = "leetcode"
Výstup: "kddsbncd"
Vysvětlení: Operaci aplikujeme na celý řetězec.
Lze dokázat, že výsledný řetězec je lexikograficky nejmenší.

Omezení:

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

Je zadán řetězec s, který se skládá pouze z malých anglických písmen. Jednou operací můžete provést následující:

Vybrat libovolný neprázdný podřetězec řetězce s, případně celý řetězec, a pak nahradit každý jeho znak předchozím znakem anglické abecedy. Například znak 'b' se převede na znak 'a' a znak 'a' se převede na znak 'z'.

Vraťte lexikograficky nejmenší řetězec, který lze získat po provedení výše uvedené operace přesně jednou.
Podřetězec je souvislá posloupnost znaků v řetězci.
Řetězec x je lexikograficky menší než řetězec y stejné délky, jestliže x[i] je před y[i] v abecedním pořadí na první pozici i tak, že x[i] != y[i].

Příklad 1:

Vstup: s = „cbabc“
Výstup: „baabc“
Vysvětlení: Operaci aplikujeme na podřetězec začínající na indexu 0 a končící na indexu 1 včetně.
Lze dokázat, že výsledný řetězec je lexikograficky nejmenší.

Příklad 2:

Vstup: s = „acbbc“
Výstup: „abaab“
Vysvětlení: Operaci aplikujeme na podřetězec začínající na indexu 1 a končící na indexu 4 včetně.
Lze dokázat, že výsledný řetězec je lexikograficky nejmenší.

Příklad 3:

Vstup: s = „leetcode“
Výstup: „kddsbncd“
Vysvětlení: Operaci aplikujeme na celý řetězec.
Lze dokázat, že výsledný řetězec je lexikograficky nejmenší.

Omezení:

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


Je vám dáno celočíselné pole `nums` indexované od nuly. Dvojice indexů `i, j`, kde `0 <= i < j < nums.length`, se nazývá krásná, pokud první cifra `nums[i]` a poslední cifra `nums[j]` jsou navzájem nesoudělné. Vraťte celkový počet krásných dvojic v `nums`. Dvě celá čísla `x` a `y` jsou nesoudělná, pokud neexistuje celé číslo větší než 1, které by dělilo obě z nich. Jinými slovy, `x` a `y` jsou nesoudělná, pokud `gcd(x, y) == 1`, kde `gcd(x, y)` je největší společný dělitel čísel `x` a `y`.

Příklad 1:

Vstup: nums = [2,5,1,4]
Výstup: 5
Vysvětlení: Existuje 5 krásných dvojic v `nums`:
Když `i = 0` a `j = 1`: první cifra `nums[0]` je 2 a poslední cifra `nums[1]` je 5. Můžeme potvrdit, že 2 a 5 jsou nesoudělné, protože `gcd(2,5) == 1`.
Když `i = 0` a `j = 2`: první cifra `nums[0]` je 2 a poslední cifra `nums[2]` je 1. Opravdu, `gcd(2,1) == 1`.
Když `i = 1` a `j = 2`: první cifra `nums[1]` je 5 a poslední cifra `nums[2]` je 1. Opravdu, `gcd(5,1) == 1`.
Když `i = 1` a `j = 3`: první cifra `nums[1]` je 5 a poslední cifra `nums[3]` je 4. Opravdu, `gcd(5,4) == 1`.
Když `i = 2` a `j = 3`: první cifra `nums[2]` je 1 a poslední cifra `nums[3]` je 4. Opravdu, `gcd(1,4) == 1`.
Proto vracíme 5.

Příklad 2:

Vstup: nums = [11,21,12]
Výstup: 2
Vysvětlení: Existují 2 krásné dvojice:
Když `i = 0` a `j = 1`: první cifra `nums[0]` je 1 a poslední cifra `nums[1]` je 1. Opravdu, `gcd(1,1) == 1`.
Když `i = 0` a `j = 2`: první cifra `nums[0]` je 1 a poslední cifra `nums[2]` je 2. Opravdu, `gcd(1,2) == 1`.
Proto vracíme 2.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums. Dvojice indexů i, j, kde 0 <= i < j < nums.length se nazývá krásná, pokud první číslice nums[i] a poslední číslice nums[j] jsou coprime.
Vraťte celkový počet krásných párů v číslech.
Dvě celá čísla x a y jsou násobně nesoudělná, pokud neexistuje žádné celé číslo větší než 1, které je obě dělí. Jinými slovy, x a y jsou násobně nesoudělná, jestliže gcd(x, y) == 1, kde gcd(x, y) je největší společný dělitel x a y.

Příklad 1:

Vstup: nums = [2,5,1,4]
Výstup: 5
Vysvětlení: Existuje 5 krásných párů v číslech:
Když i = 0 a j = 1: první číslice nums[0] je 2 a poslední číslice nums[1] je 5. Můžeme potvrdit, že 2 a 5 jsou coprime, protože gcd(2,5) = = 1.
Když i = 0 a j = 2: první číslice nums[0] je 2 a poslední číslice nums[2] je 1. Gcd(2,1) == 1.
Když i = 1 a j = 2: první číslice nums[1] je 5 a poslední číslice nums[2] je 1. Gcd(5,1) == 1.
Když i = 1 a j = 3: první číslice nums[1] je 5 a poslední číslice nums[3] je 4. Gcd(5,4) == 1.
Když i = 2 a j = 3: první číslice nums[2] je 1 a poslední číslice nums[3] je 4. Gcd(1,4) == 1.
Vracíme tedy 5.

Příklad 2:

Vstup: nums = [11,21,12]
Výstup: 2
Vysvětlení: Existují 2 krásné páry:
Když i = 0 a j = 1: první číslice nums[0] je 1 a poslední číslice nums[1] je 1. Gcd(1,1) == 1.
Když i = 0 a j = 2: první číslice nums[0] je 1 a poslední číslice nums[2] je 2. Gcd(1,2) == 1.
Vracíme tedy 2.

Omezení:

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

Dostanete číslo celého pole s indexem 0. Dvojice indexů i, j kde 0 <= i < j < nums.length se nazývá krásná, pokud první číslice nums[i] a poslední číslice nums[j] jsou nesoudělné.
Vrátí celkový počet krásných párů v číslech.
Dvě celá čísla x a y jsou souprvočíselná, pokud neexistuje žádné celé číslo větší než 1, které je obě dělí. Jinými slovy, x a y jsou soudělné, pokud gcd(x, y) == 1, kde gcd(x, y) je největší společný dělitel x a y.

Příklad 1:

Vstup: nums = [2,5,1,4]
Výstup: 5
Vysvětlení: Existuje 5 krásných párů v číslech:
Když i = 0 a j = 1: první číslice nums [0] je 2 a poslední číslice nums [1] je 5. Můžeme potvrdit, že 2 a 5 jsou nesoudělné, protože gcd(2,5) == 1.
Když i = 0 a j = 2: první číslice nums [0] je 2 a poslední číslice nums [2] je 1. Vskutku, gcd(2,1) == 1.
Když i = 1 a j = 2: první číslice nums[1] je 5 a poslední číslice nums[2] je 1. Vskutku, gcd(5,1) == 1.
Když i = 1 a j = 3: první číslice z nums[1] je 5 a poslední číslice z nums[3] je 4. Vskutku, gcd(5,4) == 1.
Když i = 2 a j = 3: první číslice nums[2] je 1 a poslední číslice nums[3] je 4. Vskutku, gcd(1,4) == 1.
Vrátíme tedy 5.

Příklad 2:

Vstup: nums = [11,21,12]
Výstup: 2
Vysvětlení: Existují 2 krásné páry:
Když i = 0 a j = 1: první číslice čísla [0] je 1 a poslední číslice čísla [1] je 1. Vskutku, gcd(1,1) == 1.
Když i = 0 a j = 2: první číslice ve slově nums[0] je 1 a poslední číslice ve slově nums[2] je 2. Vskutku, gcd(1,2) == 1.
Vrátíme tedy 2.

Omezení:

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


Máte dáno pole celých čísel `nums` s indexováním od 0 a celé číslo `k`.
Podpole se nazývá rovné, pokud jsou všechny jeho prvky stejné. Upozorňujeme, že prázdné podpole je považováno za rovné.
Vraťte délku nejdelšího možného rovného podpole po smazání nejvýše `k` prvků z `nums`.
Podpole je spojitá, případně prázdná sekvence prvků uvnitř pole.

Příklad 1:

Vstup: `nums = [1,3,2,3,1,3], k = 3`
Výstup: `3`
Vysvětlení: Je optimální smazat prvky na indexu 2 a indexu 4.
Po jejich smazání se `nums` stane rovné `[1, 3, 3, 3]`.
Nejdéle rovné podpole začíná na indexu 1 a končí na indexu 3 s délkou 3.
Je prokázáno, že není možné vytvořit delší rovná podpole.

 Příklad 2:

Vstup: `nums = [1,1,2,2,1,1], k = 2`
Výstup: `4`
Vysvětlení: Je optimální smazat prvky na indexu 2 a indexu 3.
Po jejich smazání se `nums` stane rovné `[1, 1, 1, 1]`.
Pole samotné je rovné podpole, takže odpověď je 4.
Je prokázáno, že není možné vytvořit delší rovná podpole.

Omezení:

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

Je vám zadáno celé pole s indexem 0, nums a celé číslo k.
Podpole se nazývá stejné, pokud jsou všechny jeho prvky stejné. Všimněte si, že prázdné podpole je stejné podpole.
Vrátí délku nejdelšího možného stejného podpole po odstranění nejvýše k prvků z nums.
Podpole je souvislá, případně prázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [1,3,2,3,1,3], k = 3
Výstup: 3
Vysvětlení: Optimální je odstranit prvky na indexu 2 a indexu 4.
Po jejich odstranění se čísla budou rovnat [1, 3, 3, 3].
Nejdelší stejné podpole začíná na i = 1 a končí na j = 3 s délkou rovnou 3.
Lze dokázat, že již nelze vytvářet žádná stejná podpole.

Příklad 2:

Vstup: nums = [1,1,2,2,1,1], k = 2
Výstup: 4
Vysvětlení: Optimální je odstranit prvky na indexu 2 a indexu 3.
Po jejich odstranění se čísla budou rovnat [1, 1, 1, 1].
Samotné pole je stejné podpole, takže odpověď je 4.
Lze dokázat, že již nelze vytvářet žádná stejná podpole.

Omezení:

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

Je zadáno pole celých čísel nums s indexem 0 a celé číslo k.
Dílčí pole se nazývá rovné, pokud se všechny jeho prvky rovnají. Všimněte si, že prázdné podpole je rovné podpole.
Vraťte délku nejdelšího možného rovného podřetězce po odstranění nejvýše k prvků z nums.
Podmnožina je souvislá, případně prázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [1,3,2,3,1,3], k = 3
Výstup: 3
Vysvětlení: Je optimální vymazat prvky s indexy 2 a 4.
Po jejich vymazání se nums bude rovnat [1, 3, 3, 3].
Nejdelší stejné podřetězce začínají v bodě i = 1 a končí v bodě j = 3 a jejich délka je rovna 3.
Lze dokázat, že žádné delší rovné podřetězce nelze vytvořit.

Příklad 2:

Vstup: nums = [1,1,2,2,1,1], k = 2
Výstup: 4
Vysvětlení: Je optimální vymazat prvky na indexech 2 a 3.
Po jejich vymazání se nums bude rovnat [1, 1, 1, 1].
Samotné pole je rovné podpoli, takže odpověď je 4.
Lze dokázat, že již nelze vytvořit žádné rovné podpole.

Omezení:

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


Máte dáno celé číslo n, které označuje celkový počet serverů, a 2D celočíselné pole logs s indexováním od 0, kde logs[i] = [server_id, time] označuje, že server s id server_id obdržel požadavek v čase time. Dále je vám dáno celé číslo x a celočíselné pole queries s indexováním od 0. Vraťte celočíselné pole arr s indexováním od 0 a délkou queries.length, kde arr[i] představuje počet serverů, které neobdržely žádné požadavky během časového intervalu [queries[i] - x, queries[i]]. Všimněte si, že časové intervaly jsou inkluzivní.

Příklad 1:

Vstup: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Výstup: [1,2]
Vysvětlení:
Pro queries[0]: Servery s id 1 a 2 dostávají požadavky v době trvání [5, 10]. Proto pouze server 3 nedostane žádné požadavky.
Pro queries[1]: Pouze server s id 2 dostává žádosti v době trvání [6,11]. Proto servery s id 1 a 3 jsou jedinými servery, které během tohoto období nedostanou žádné žádosti.

Příklad 2:

Vstup: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Výstup: [0,1]
Vysvětlení:
Pro queries[0]: Všechny servery dostanou alespoň jeden požadavek v době trvání [1, 3].
Pro queries[1]: Pouze server s id 3 nedostane žádnou žádost v době trvání [2,4].

Omezení:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6

Byl ti zadán integer celého čísla n, který označuje celkový počet serverů, a 2D celočíselné pole logs s indexováním od 0, kde logs[i] = [server_id, time]. To označuje, že server s id server_id obdržel požadavek v čase time. Dále je ti zadáno celé číslo x a celočíselné pole queries s indexováním od 0. Vrať celočíselné pole arr s indexováním od 0 a délkou queries.length, kde arr[i] představuje počet serverů, které neobdržely žádné požadavky během časového intervalu [queries[i] - x, queries[i]]. Všimni si, že časové intervaly jsou inkluzivní.

Příklad 1:

Vstup: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
Výstup: [1,2]
Vysvětlení:
Pro queries[0]: Servery s id 1 a 2 dostávají požadavky v době trvání [5, 10]. Proto žádné požadavky nedostane pouze server 3.
Pro queries[1]: Pouze server s id 2 dostává žádosti v době trvání [6,11]. Proto jsou jedinými servery, které během tohoto období nedostanou žádné žádosti, servery s id 1 a 3.

Příklad 2:

Vstup: n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
Výstup: [0,1]
Vysvětlení:
Pro queries[0]: Všechny servery dostanou alespoň jeden požadavek v době trvání [1, 3].
Pro queries[1]: Žádnou žádost v době trvání [2,4] nedostane pouze server s id 3.

Omezení:

1 <= n <= 10^5
1 <= logs.length <= 10^5
1 <= queries.length <= 10^5
logs[i].length == 2
1 <= logs[i][0] <= n
1 <= logs[i][1] <= 10^6
1 <= x <= 10^5
x < queries[i] <= 10^6


Je vám dáno celočíselné pole s indexem od 0 s názvem `nums`, které reprezentuje počáteční pozice některých kuliček. Jsou vám také dána dvě celočíselná pole s indexem od 0 s názvy `moveFrom` a `moveTo`, která mají stejnou délku. Během kroků v délce `moveFrom.length` změníte pozice kuliček. V i-tém kroku přesunete všechny kuličky z pozice `moveFrom[i]` na pozici `moveTo[i]`. Po dokončení všech kroků vraťte seřazený seznam obsazených pozic. Poznámky:

Pozici nazýváme obsazenou, pokud je v této pozici alespoň jedna kulička.
Na jedné pozici může být více kuliček.

Příklad 1:

Vstup: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Výstup: [5,6,8,9]
Vysvětlení: Na začátku jsou kuličky na pozicích 1,6,7,8.
V kroku i = 0 přesuneme kuličky z pozice 1 na pozici 2. Poté jsou obsazeny pozice 2,6,7,8.
V kroku i = 1 přesuneme kuličky z pozice 7 na pozici 9. Poté jsou obsazeny pozice 2,6,8,9.
V kroku i = 2 přesuneme kuličky z pozice 2 na pozici 5. Poté jsou obsazeny pozice 5,6,8,9.
Na konci jsou finální pozice obsahující alespoň jednu kuličku [5,6,8,9].

Příklad 2:

Vstup: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Výstup: [2]
Vysvětlení: Na začátku jsou kuličky na pozicích [1,1,3,3].
V kroku i = 0 přesuneme všechny kuličky z pozice 1 na pozici 2. Poté jsou kuličky na pozicích [2,2,3,3].
V kroku i = 1 přesuneme všechny kuličky z pozice 3 na pozici 2. Poté jsou kuličky na pozicích [2,2,2,2].
Protože 2 je jediná obsazená pozice, vrátíme [2].

Omezení:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Testovací případy jsou takové, že v moveFrom[i] je alespoň jedna kulička v okamžiku, kdy chceme aplikovat i-tý přesun.

Dostanete 0-indexované celé pole čísel reprezentující počáteční pozice některých kuliček. Dostanete také dvě celočíselná pole indexovaná 0 moveFrom a moveTo stejné délky.
V průběhu kroků moveFrom.length budete měnit pozice kuliček. Na i^-tém kroku přesunete všechny kuličky na pozici moveFrom[i] do pozice moveTo[i].
Po dokončení všech kroků vraťte seřazený seznam obsazených pozic.
Poznámky:

Pozici nazýváme obsazenou, pokud je v této pozici alespoň jedna kulička.
Na jedné pozici může být více kuliček.

Příklad 1:

Vstup: čísla = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Výstup: [5,6,8,9]
Vysvětlení: Zpočátku jsou kuličky na pozicích 1,6,7,8.
V kroku i = 0 posuneme kuličky na pozici 1 do pozice 2. Poté jsou obsazeny pozice 2,6,7,8.
V kroku i = 1st posuneme kuličky na pozici 7 do pozice 9. Poté jsou obsazeny pozice 2,6,8,9.
V kroku i = 2nd posuneme kuličky na pozici 2 do pozice 5. Poté jsou obsazeny pozice 5,6,8,9.
Na konci jsou konečné pozice obsahující alespoň jednu kuličku [5,6,8,9].
Příklad 2:

Vstup: čísla = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Výstup: [2]
Vysvětlení: Zpočátku jsou kuličky v pozicích [1,1,3,3].
V kroku i = 0 přesuneme všechny kuličky na pozici 1 do pozice 2. Poté jsou kuličky na pozicích [2,2,3,3].
V kroku i = 1st posuneme všechny kuličky na pozici 3 do pozice 2. Pak jsou kuličky na pozicích [2,2,2,2].
Protože 2 je jediná obsazená pozice, vrátíme se [2].

Omezení:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Testovací případy jsou generovány tak, aby v okamžiku, kdy chceme použít i^tý tah, byla v moveFrom[i] alespoň kulička.

Dostanete 0-indexované celé pole čísel reprezentující počáteční pozice některých kuliček. Dostanete také dvě celočíselná pole indexovaná 0 moveFrom a moveTo stejné délky.
V průběhu kroků moveFrom.length budete měnit pozice kuliček. Na i^-tém kroku přesunete všechny kuličky na pozici moveFrom[i] do pozice moveTo[i].
Po dokončení všech kroků vraťte seřazený seznam obsazených pozic.
Poznámky:

Pozici nazýváme obsazenou, pokud je v této pozici alespoň jedna kulička.
Na jedné pozici může být více kuliček.

Příklad 1:

Vstup: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
Výstup: [5,6,8,9]
Vysvětlení: Zpočátku jsou kuličky na pozicích 1,6,7,8.
V kroku i = 0th posuneme kuličky na pozici 1 do pozice 2. Poté jsou obsazeny pozice 2,6,7,8.
V kroku i = 1st posuneme kuličky na pozici 7 do pozice 9. Poté jsou obsazeny pozice 2,6,8,9.
V kroku i = 2nd posuneme kuličky na pozici 2 do pozice 5. Poté jsou obsazeny pozice 5,6,8,9.
Na konci jsou konečné pozice obsahující alespoň jednu kuličku [5,6,8,9].
Příklad 2:

Vstup: nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
Výstup: [2]
Vysvětlení: Zpočátku jsou kuličky v pozicích [1,1,3,3].
V kroku i = 0th přesuneme všechny kuličky na pozici 1 do pozice 2. Poté jsou kuličky na pozicích [2,2,3,3].
V kroku i = 1st posuneme všechny kuličky na pozici 3 do pozice 2. Pak jsou kuličky na pozicích [2,2,2,2].
Protože 2 je jediná obsazená pozice, vrátíme se [2].

Omezení:

1 <= nums.length <= 10^5
1 <= moveFrom.length <= 10^5
moveFrom.length == moveTo.length
1 <= nums[i], moveFrom[i], moveTo[i] <= 10^9
Testovací případy jsou generovány tak, aby v okamžiku, kdy chceme použít i^tý tah, byla v moveFrom[i] alespoň kulička.


Jsou zadána dvě celá čísla num1 a num2.
V jedné operaci můžete zvolit celé číslo i v rozsahu [0, 60] a od num1 odečíst 2^i + num2.
Vraťte celé číslo označující minimální počet operací potřebných k tomu, aby se num1 rovnalo 0.
Pokud není možné, aby se num1 rovnalo 0, vraťte -1.

Příklad 1:

Vstup: num1 = 3, num2 = -2
Výstup: 3
Vysvětlení: Následujícími operacemi můžeme z hodnoty 3 udělat hodnotu 0:
- Zvolíme i = 2 a od 3 odečteme 2^2 + (-2), 3 - (4 + (-2)) = 1.
- Zvolíme i = 2 a od 1 odečteme 2^2 + (-2), 1 - (4 + (-2)) = -1.
- Zvolíme i = 0 a od -1 odečteme 2^0 + (-2), (-1) - (1 + (-2)) = 0.
Lze dokázat, že 3 je minimální počet operací, které musíme provést.

Příklad 2:

Vstup: num1 = 5, num2 = 7
Výstup: -1
Vysvětlení: Lze dokázat, že danou operací nelze 5 rovnat 0.

Omezení:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

Máte dána dvě celá čísla num1 a num2.
V jedné operaci můžete zvolit celé číslo i v rozsahu [0, 60] a odečíst 2^i + num2 od num1.
Vrátí celé číslo označující minimální počet operací potřebných k tomu, aby se num1 rovnalo 0.
Pokud není možné udělat num1 rovné 0, vraťte -1.

Příklad 1:

Vstup: num1 = 3, num2 = -2
Výstup: 3
Vysvětlení: Můžeme udělat 3 rovné 0 následujícími operacemi:
- Zvolíme i = 2 a odečteme 2^2 + (-2) od 3, 3 - (4 + (-2)) = 1.
- Zvolíme i = 2 a odečteme 2^2 + (-2) od 1, 1 - (4 + (-2)) = -1.
- Zvolíme i = 0 a odečteme 2^0 + (-2) od -1, (-1) - (1 + (-2)) = 0.
Lze dokázat, že 3 je minimální počet operací, které musíme provést.

Příklad 2:

Vstup: num1 = 5, num2 = 7
Výstup: -1
Vysvětlení: Lze dokázat, že není možné udělat 5 rovné 0 s danou operací.

Omezení:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9

Byly ti zadány dva integery celých čísel num1 a num2.
V jedné operaci můžeš zvolit celé číslo i v rozsahu [0, 60] a odečíst 2^i + num2 od num1.
Vrať celé číslo označující minimální počet operací potřebných k tomu, aby se num1 rovnalo 0.
Pokud nelze num1 rovné 0, vraťte -1.

Příklad 1:

Vstup: num1 = 3, num2 = -2
Výstup: 3
Vysvětlení: Můžeme udělat 3 rovné 0 následujícími operacemi:
- Zvolíme i = 2 a odečteme 2^2 + (-2) od 3, 3 - (4 + (-2)) = 1.
- Zvolíme i = 2 a odečteme 2^2 + (-2) od 1, 1 - (4 + (-2)) = -1.
- Zvolíme i = 0 a odečteme 2^0 + (-2) od -1, (-1) - (1 + (-2)) = 0.
Jak bylo dokázáno, 3 je minimální počet operací, které musíme provést.

Příklad 2:

Vstup: num1 = 5, num2 = 7
Výstup: -1
Vysvětlení: Lze dokázat, že není možné udělat 5 rovné 0 s danou operací.

Omezení:

1 <= num1 <= 10^9
-10^9 <= num2 <= 10^9


Máte dány dva celočíselné pole s indexováním od 0, nums1 a nums2, obě délky n, a 2D pole queries s indexováním od 1, kde queries[i] = [x_i, y_i].
Pro i-tý dotaz najděte maximální hodnotu nums1[j] + nums2[j] mezi všemi indexy j (0 <= j < n), kde nums1[j] >= x_i a nums2[j] >= y_i, nebo -1, pokud neexistuje takové j, které splňuje podmínky.
Vraťte pole answer, kde answer[i] je odpověď na i-tý dotaz.

Příklad 1:

Vstup: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Výstup: [6,10,7]
Vysvětlení:
Pro 1. dotaz x_i = 4 a y_i = 1, můžeme vybrat index j = 0, protože nums1[j] >= 4 a nums2[j] >= 1. Součet nums1[j] + nums2[j] je 6 a můžeme ukázat, že 6 je maximum, které můžeme získat.

Pro 2. dotaz x_i = 1 a y_i = 3, můžeme vybrat index j = 2, protože nums1[j] >= 1 a nums2[j] >= 3. Součet nums1[j] + nums2[j] je 10 a můžeme ukázat, že 10 je maximum, které můžeme získat.

Pro 3. dotaz x_i = 2 a y_i = 5, můžeme vybrat index j = 3, protože nums1[j] >= 2 a nums2[j] >= 5. Součet nums1[j] + nums2[j] je 7 a můžeme ukázat, že 7 je maximum, které můžeme získat.

Proto vrátíme [6,10,7].

Příklad 2:

Vstup: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Výstup: [9,9,9]
Vysvětlení: U tohoto příkladu můžeme použít index j = 2 pro všechny dotazy, protože splňuje podmínky pro každý dotaz.

Příklad 3:

Vstup: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Výstup: [-1]
Vysvětlení: U tohoto příkladu je jeden dotaz s x_i = 3 a y_i = 3. Pro každý index j, buď nums1[j] < x_i nebo nums2[j] < y_i. Proto neexistuje řešení.

Omezení:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9

Máte dány dva celočíselné pole s indexováním od 0, nums1 a nums2, obě délky n, a 2D pole queries s indexováním od 1, kde queries[i] = [x_i, y_i].
Pro i-tý dotaz najděte maximální hodnotu nums1[j] + nums2[j] mezi všemi indexy j (0 <= j < n), kde nums1[j] >= x_i a nums2[j] >= y_i, nebo -1, pokud neexistuje takové j, které splňuje podmínky.
Vraťte pole answer, kde answer[i] je odpověď na i-tý dotaz.

Příklad 1:

Vstup: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
Výstup: [6,10,7]
Vysvětlení:
Pro 1. dotaz x_i = 4 a y_i = 1, můžeme vybrat index j = 0, protože nums1[j] >= 4 a nums2[j] >= 1. Součet nums1[j] + nums2[j] je 6 a můžeme ukázat, že 6 je maximum, které můžeme získat.

Pro 2. dotaz x_i = 1 a y_i = 3, můžeme vybrat index j = 2, protože nums1[j] >= 1 a nums2[j] >= 3. Součet nums1[j] + nums2[j] je 10 a můžeme ukázat, že 10 je maximum, které můžeme získat.

Pro 3. dotaz x_i = 2 a y_i = 5, můžeme vybrat index j = 3, protože nums1[j] >= 2 a nums2[j] >= 5. Součet nums1[j] + nums2[j] je 7 a můžeme ukázat, že 7 je maximum, které můžeme získat.

Proto vrátíme [6,10,7].

Příklad 2:

Vstup: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
Výstup: [9,9,9]
Vysvětlení: V tomto příkladu můžeme použít index j = 2 pro všechny dotazy, protože splňuje podmínky pro každý dotaz.

Příklad 3:

Vstup: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Výstup: [-1]
Vysvětlení: V tomto příkladu je jeden dotaz s x_i = 3 a y_i = 3. Pro každý index j, buď nums1[j] < x_i nebo nums2[j] < y_i. Proto neexistuje řešení.

Omezení:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][0] and y_i == queries[i][1]

Jsou zadána dvě 0-indexovaná celočíselná pole nums1 a nums2, každé o délce n, a 1-indexované 2D pole queries, kde queries[i] = [x_i, y_i].
Pro i^tý dotaz najděte maximální hodnotu nums1[j] + nums2[j] mezi všemi indexy j (0 <= j < n), kde nums1[j] >= x_i a nums2[j] >= y_i, nebo -1, pokud neexistuje žádné j splňující omezení.
Vrátí pole answer, kde answer[i] je odpověď na i^-th dotaz.

Příklad 1:

Vstup: nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]].
Výstup: [6,10,7]
Vysvětlení:
Pro 1. dotaz x_i = 4 a y_i = 1 můžeme vybrat index j = 0, protože nums1[j] >= 4 a nums2[j] >= 1. Součet nums1[j] + nums2[j] je 6 a můžeme ukázat, že 6 je maximum, které můžeme získat.

Pro druhý dotaz x_i = 1 a y_i = 3 můžeme vybrat index j = 2, protože nums1[j] >= 1 a nums2[j] >= 3. Součet nums1[j] + nums2[j] je 10 a můžeme ukázat, že 10 je maximum, které můžeme získat.

Pro třetí dotaz x_i = 2 a y_i = 5 můžeme vybrat index j = 3, protože nums1[j] >= 2 a nums2[j] >= 5. Součet nums1[j] + nums2[j] je 7 a můžeme ukázat, že 7 je maximum, které můžeme získat.

Proto vrátíme [6,10,7].

Příklad 2:

Vstup: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]].
Výstup: [9,9,9]
Vysvětlení: Pro tento příklad můžeme pro všechny queries použít index j = 2, protože splňuje omezení pro každý dotaz.

Příklad 3:

 Vstup: nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
Výstup: [-1]
Vysvětlení: V tomto příkladu je jeden query s x_i = 3 a y_i = 3. Pro každý index j platí, že buď nums1[j] < x_i, nebo nums2[j] < y_i. Proto neexistuje žádné řešení.

Omezení:

nums1.length == nums2.length
n == nums1.length
1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 10^9
1 <= queries.length <= 10^5
queries[i].length == 2
x_i == queries[i][1]
y_i == queries[i][2]
1 <= x_i, y_i <= 10^9


Je zadáno 1-indexované celočíselné pole nums délky n.
Prvek nums[i] pole nums se nazývá zvláštní, pokud i dělí n, tj. n % i == 0.
Vraťte součet čtverců všech speciálních prvků nums.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 21
Vysvětlení: V nums jsou přesně 3 speciální prvky: nums[1], protože 1 dělí 4, nums[2], protože 2 dělí 4, a nums[4], protože 4 dělí 4.
Součet čtverců všech speciálních prvků nums je tedy nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Příklad 2:

Vstup: nums = [2,7,1,19,18,3]
Výstup: 63
Vysvětlení: V nums jsou přesně 4 zvláštní prvky: nums[1], protože 1 dělí 6, nums[2], protože 2 dělí 6, nums[3], protože 3 dělí 6, a nums[6], protože 6 dělí 6.
Součet čtverců všech zvláštních prvků nums je tedy nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Omezení:

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

Dostanete 1-indexované celočíselné pole num délky n.
Prvek nums[i] z nums se nazývá speciální, pokud i dělí n, tj. n % i == 0.
Vraťte součet druhých mocnin všech speciálních prvků nums.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 21
Vysvětlení: V nums jsou přesně 3 speciální prvky: nums[1] protože 1 dělí 4, nums[2] protože 2 dělí 4 a nums[4] protože 4 dělí 4.
Součet druhých mocnin všech speciálních prvků nums je tedy nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Příklad 2:

Vstup: nums = [2,7,1,19,18,3]
Výstup: 63
Vysvětlení: V nums jsou přesně 4 speciální prvky: nums[1] protože 1 dělí 6, nums[2] protože 2 dělí 6, nums[3] protože 3 dělí 6 a nums[6] protože 6 dělí 6.
Součet druhých mocnin všech speciálních prvků nums je tedy nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums [6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Omezení:

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

Je vám dáno 1-indexované celé pole s čísly délky n.
Prvek nums[i] z nums se nazývá speciální, pokud i dělí n, tj. n % i == 0.
Vrátí součet druhých mocnin všech speciálních prvků čísel.

Příklad 1:

Vstup: nums = [1,2,3,4]
Výstup: 21
Vysvětlení: V nums jsou přesně 3 speciální prvky: nums[1] protože 1 dělí 4, nums[2] protože 2 dělí 4 a nums[4] protože 4 dělí 4.
Součet druhých mocnin všech speciálních prvků nums je tedy nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21.

Příklad 2:

Vstup: nums = [2,7,1,19,18,3]
Výstup: 63
Vysvětlení: V nums jsou přesně 4 speciální prvky: nums[1], protože 1 dělí 6, nums[2], protože 2 dělí 6, nums[3] protože 3 dělí 6, a nums[6], protože 6 dělí 6.
Součet druhých mocnin všech speciálních prvků nums je tedy nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63.

Omezení:

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


Je zadáno pole celých kladných čísel nums.
Rozdělte nums na dvě pole, nums1 a nums2, tak, že:

Každý prvek pole nums patří buď do pole nums1, nebo do pole nums2.
Obě pole nejsou prázdná.
Hodnota rozdělení je minimalizována.

Hodnota rozdělení je |max(nums1) - min(nums2)|.
Zde max(nums1) označuje maximální prvek pole nums1 a min(nums2) označuje minimální prvek pole nums2.
Vraťte celé číslo označující hodnotu takového rozdělení.

Příklad 1:

Vstup: nums = [1,3,2,4]
Výstup: 1
Vysvětlení: Můžeme rozdělit pole nums na nums1 = [1,2] a nums2 = [3,4].
- Maximální prvek pole nums1 je roven 2.
- Minimální prvek pole nums2 je roven 3.
Hodnota rozdělení je |2 - 3| = 1.
Lze dokázat, že 1 je minimální hodnota ze všech oddílů.

Příklad 2:

Vstup: nums = [100,1,10]
Výstup: 9
Vysvětlení: Pole nums můžeme rozdělit na nums1 = [10] a nums2 = [100,1].
- Maximální prvek pole nums1 je roven 10.
- Minimální prvek pole nums2 je roven 1.
Hodnota rozdělení je |10 - 1| = 9.
Lze dokázat, že 9 je minimální hodnota ze všech oddílů.

Omezení:

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

Dostanete kladné celé číslo pole nums.
Rozdělte čísla do dvou polí, nums1 a nums2, takže:

Každý prvek pole nums patří buď do pole nums1 nebo do pole nums2.
Obě pole nejsou prázdná.
Hodnota oddílu je minimalizována.

Hodnota oddílu je |max(nums1) - min(nums2)|.
Zde max(nums1) označuje maximální prvek pole nums1 a min(nums2) označuje minimální prvek pole nums2.
Vraťte celé číslo označující hodnotu takového oddílu.

Příklad 1:

Vstup: nums = [1,3,2,4]
Výstup: 1
Vysvětlení: Pole nums můžeme rozdělit na nums1 = [1,2] a nums2 = [3,4].
- Maximální prvek pole nums1 je roven 2.
- Minimální prvek pole nums2 je roven 3.
Hodnota oddílu je |2 - 3| = 1.
Lze prokázat, že 1 je minimální hodnota ze všech oddílů.

Příklad 2:

Vstup: nums = [100,1,10]
Výstup: 9
Vysvětlení: Pole nums můžeme rozdělit na nums1 = [10] a nums2 = [100,1].
- Maximální prvek pole nums1 je roven 10.
- Minimální prvek pole nums2 je roven 1.
Hodnota oddílu je |10 - 1| = 9.
Lze prokázat, že 9 je minimální hodnota ze všech oddílů.

Omezení:

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


Je zadáno pole slov s indexem 0, které se skládá z různých řetězců.
Řetězec slov[i] lze spárovat s řetězcem slov[j], jestliže:

Řetězec slov[i] je roven obrácenému řetězci slov[j].
0 <= i < j < words.length.

Vrátí maximální počet dvojic, které lze vytvořit z pole words.
Všimněte si, že každý řetězec může patřit nejvýše do jedné dvojice.

Příklad 1:

Vstup: slova = ["cd", "ac", "dc", "ca", "zz"]
Výstup: 2
Vysvětlení: V tomto příkladu můžeme vytvořit 2 dvojice řetězců následujícím způsobem:
- Párujeme 0^tý řetězec s 2^tým řetězcem, protože obrácený řetězec slova[0] je „dc“ a je roven slovům[2].
- Párujeme 1^tý řetězec s 3^tým řetězcem, protože obrácený řetězec slova[1] je „ca“ a je roven slovům[3].
Lze dokázat, že 2 je maximální počet dvojic, které lze vytvořit.
Příklad 2:

Vstup: slova = ["ab", "ba", "cc"]
Výstup: 1
Vysvětlení: V tomto příkladu můžeme vytvořit 1 pár řetězců následujícím způsobem:
- Párujeme 0^tý řetězec s 1^tým řetězcem, protože obrácený řetězec words[1] je „ab“ a je roven words[0].
Lze dokázat, že 1 je maximální počet dvojic, které lze vytvořit.

Příklad 3:

Vstup: slova = ["aa", "ab"]
Výstup: 0
Vysvětlení: V tomto příkladu nejsme schopni vytvořit žádnou dvojici řetězců.

Omezení:

1 <= words.length <= 50
words[i].length == 2
Slova se skládají z různých řetězců.
slova[i] obsahují pouze malá anglická písmena.

Je zadáno pole slov s indexem 0, které se skládá z různých řetězců.
Řetězec words[i] lze spárovat s řetězcem words[j], jestliže:

řetězec words[i] je roven obrácenému řetězci words[j].
0 <= i < j < words.length.

Vrátí maximální počet dvojic, které lze vytvořit z pole words.
Všimněte si, že každý řetězec může patřit nejvýše do jedné dvojice.

Příklad 1:

Vstup: words = [„cd“, „ac“, „dc“, „ca“, „zz“]
Výstup: 2
Vysvětlení: V tomto příkladu můžeme vytvořit 2 dvojice řetězců následujícím způsobem:
- Párujeme 0^tý řetězec s 2^tým řetězcem, protože obrácený řetězec slova[0] je „dc“ a je roven words[2].
- Párujeme 1^tý řetězec s 3^tým řetězcem, protože obrácený řetězec slova[1] je „ca“ a je roven words[3].
Lze dokázat, že 2 je maximální počet dvojic, které lze vytvořit.
Příklad 2:

Vstup: words = [„ab“, „ba“, „cc“]
Výstup: 1
Vysvětlení: V tomto příkladu můžeme vytvořit 1 pár řetězců následujícím způsobem:
- Párujeme 0^tý řetězec s 1^tým řetězcem, protože obrácený řetězec words[1] je „ab“ a je roven words[0].
Lze dokázat, že 1 je maximální počet dvojic, které lze vytvořit.

Příklad 3:

Vstup: words = [„aa“, „ab“]
Výstup: 0
Vysvětlení: V tomto příkladu nejsme schopni vytvořit žádnou dvojici řetězců.

Omezení:

1 <= words.length <= 50
words[i].length == 2
Slova se skládají z různých řetězců.
words[i] obsahují pouze malá anglická písmena.

Dostanete pole slova s indexem 0, které se skládá z odlišných řetězců.
Řetězcová slova[i] lze spárovat s řetězcovými slovy[j], pokud:

Řetězec slova[i] se rovná obrácenému řetězci slova[j].
0 <= i < j < slova.length.

Vrátí maximální počet párů, které lze vytvořit z pole slova.
Všimněte si, že každý slova může patřit nejvýše do jednoho páru.

Příklad 1:

Vstup: slova = ["cd","ac","dc","ca","zz"]
Výstup: 2
Vysvětlení: V tomto příkladu můžeme vytvořit 2 páry řetězců následujícím způsobem:
- Spárujeme 0. (nultý) slova s 2^-tým řetězcem, protože obrácený slova word[0] je "dc" a je roven slovům[2].
- Spárujeme 1. (první) slova s 3^řetězcem, protože obrácený slova slova[1] je "ca" a rovná se slovům[3].
Lze prokázat, že 2 je maximální počet párů, které lze vytvořit z tohoto pole.
Příklad 2:

Vstup: slova = ["ab","ba","cc"]
Výstup: 1
Vysvětlení: V tomto příkladu můžeme vytvořit 1 pár řetězců následujícím způsobem:
- Spárujeme 0^tý slova s 1^tým řetězcem, protože obrácený slova slova[1] je "ab" a rovná se slovům[0].
Lze prokázat, že 1 je maximální počet párů, které lze vytvořit.

Příklad 3:

Vstup: slova = ["aa","ab"]
Výstup: 0
Vysvětlení: V tomto příkladu nejsme schopni vytvořit žádný pár řetězců.

Omezení:

1 <= slova.length <= 50
slova[i].length == 2
slova se skládají z různých řetězců.
words[i] obsahuje pouze malá anglická písmena.


Je zadáno pole celých čísel nums s indexem 0, které obsahuje n různých kladných celých čísel. Permutace pole nums se nazývá speciální, jestliže:

Pro všechny indexy 0 <= i < n - 1 platí, že buď nums[i] % nums[i+1] == 0, nebo nums[i+1] % nums[i] == 0.

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

Příklad 1:

Vstup: nums = [2,3,6]
Výstup: 2
Vysvětlení: [3,6,2] a [2,6,3] jsou dvě speciální permutace nums.

Příklad 2:

Vstup: nums = [1,4,3]
Výstup: 2
Vysvětlení: [3,1,4] a [4,1,3] jsou dvě speciální permutace nums.

Omezení:

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

Máte zadané celočíselné pole nums s n indexovanými od 0 obsahující n různých kladných celých čísel. Permutace pole nums se nazývá speciální, pokud:

Pro všechny indexy 0 <= i < n - 1 platí buď nums[i] % nums[i+1] == 0 nebo nums[i+1] % nums[i] == 0.

Vraťte celkový počet speciálních permutací. Jelikož odpověď může být velká, vraťte ji modulo 10^9 + 7.

Příklad 1:

Vstup: nums = [2,3,6]
Výstup: 2
Vysvětlení: [3,6,2] a [2,6,3] jsou dvě speciální permutace pole nums.

Příklad 2:

Vstup: nums = [1,4,3]
Výstup: 2
Vysvětlení: [3,1,4] a [4,1,3] jsou dvě speciální permutace pole nums.

Omezení:

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

Dostanete 0-indexované celé pole nums obsahující n různých kladných celých čísel. Permutace num se nazývá speciální, pokud:

Pro všechny indexy 0 <= i < n - 1, buď nums[i] % nums[i+1] == 0, nebo nums[i+1] % nums[i] == 0.

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

Příklad 1:

Vstup: nums = [2,3,6]
Výstup: 2
Vysvětlení: [3,6,2] a [2,6,3] jsou dvě speciální permutace num.

Příklad 2:

Vstup: nums = [1,4,3]
Výstup: 2
Vysvětlení: [3,1,4] a [4,1,3] jsou dvě speciální permutace num.

Omezení:

2 <= počet.length <= 14
1 <= nums[i] <= 10^9


Číslo nevyváženosti 0-indexovaného celočíselného pole arr délky n je definováno jako počet indexů v sarr = sorted(arr) tak, že:

0 <= i < n - 1, a
sarr[i+1] - sarr[i] > 1

Zde je sorted(arr) funkce, která vrací setříděnou verzi arr.
Při zadání 0-indexovaného celočíselného pole nums vrátí součet nevyvážených čísel všech jeho dílčích polí.
Podpole je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [2,3,1,4]
Výstup: 3
Vysvětlení: Existují 3 dílčí pole s nenulovými nevyváženými čísly:
- Dílčí pole [3, 1] s nevyváženým číslem 1.
- Dílčí pole [3, 1, 4] s číslem nevyváženosti 1.
- Dílčí pole [1, 4] s číslem nevyváženosti 1.
Číslo nevyváženosti všech ostatních dílčích polí je 0. Součet čísel nevyváženosti všech dílčích polí nums je tedy 3.

Příklad 2:

Vstup: nums = [1,3,3,3,5]
Výstup: 8
Vysvětlení: Existuje 7 dílčích polí s nenulovými nevyváženými čísly:
- Dílčí pole [1, 3] s nevyváženým číslem 1.
- Dílčí pole [1, 3, 3] s číslem nevyváženosti 1.
- Dílčí pole [1, 3, 3, 3] s číslem nevyváženosti 1.
- Dílčí pole [1, 3, 3, 3, 5] s nevyvážeností 2.
- Dílčí pole [3, 3, 3, 5] s nevyvážeností 1.
- Dílčí pole [3, 3, 5] s nevyvážeností 1.
- Dílčí pole [3, 5] s číslem nevyváženosti 1.
Číslo nevyváženosti všech ostatních dílčích polí je 0. Součet čísel nevyváženosti všech dílčích polí nums je tedy 8.

Omezení:

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

Nerovnovážné číslo celočíselného pole arr s nulovým indexem o délce n je definováno jako počet indexů v sarr = sorted(arr) takových, že:

0 <= i < n - 1, a
sarr[i+1] - sarr[i] > 1

Zde, sorted(arr) je funkce, která vrací seřazenou verzi arr.
Je dáno celočíselné pole nums s nulovým indexem. Vrátit součet nerovnovážných čísel všech jeho podpolí.
Podpole je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [2,3,1,4]
Výstup: 3
Vysvětlení: Existují 3 podpola s nenulovými nerovnovážnými čísly:
- Podpole [3, 1] s nerovnovážným číslem 1.
- Podpole [3, 1, 4] s nerovnovážným číslem 1.
- Podpole [1, 4] s nerovnovážným číslem 1.
Nerovnovážné číslo všech ostatních podpolí je 0. Celkový součet nerovnovážných čísel všech podpolí nums je tedy 3.

Příklad 2:

Vstup: nums = [1,3,3,3,5]
Výstup: 8
Vysvětlení: Existuje 7 podpolí s nenulovými nerovnovážnými čísly:
- Podpole [1, 3] s nerovnovážným číslem 1.
- Podpole [1, 3, 3] s nerovnovážným číslem 1.
- Podpole [1, 3, 3, 3] s nerovnovážným číslem 1.
- Podpole [1, 3, 3, 3, 5] s nerovnovážným číslem 2.
- Podpole [3, 3, 3, 5] s nerovnovážným číslem 1.
- Podpole [3, 3, 5] s nerovnovážným číslem 1.
- Podpole [3, 5] s nerovnovážným číslem 1.
Nerovnovážné číslo všech ostatních podpolí je 0. Celkový součet nerovnovážných čísel všech podpolí nums je tedy 8.

Omezení:

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

Číslo nevyváženosti 0-indexovaného celočíselného pole arr délky n je definováno jako počet indexů v sarr = sorted(arr) tak, že:

0 <= i < n - 1 a
sarr[i+1] - sarr[i] > 1

Zde je sort(arr) funkcí, která vrací seřazenou verzi arr.
Vzhledem k nulovému indexovanému celočíselnému počtu čísel vraťte součet čísel nevyvážeností všech jeho podpolí.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [2,3,1,4]
Výstup: 3
Vysvětlení: Existují 3 podpole s nenulovými čísly nevyváženosti:
- Subarray [3, 1] s číslem nerovnováhy 1.
- Subarray [3, 1, 4] s číslem nerovnováhy 1.
- Subarray [1, 4] s číslem nerovnováhy 1.
Číslo nevyváženosti všech ostatních podpolí je 0. Součet čísel nevyvážeností všech podpolí num je tedy 3.

Příklad 2:

Vstup: nums = [1,3,3,3,5]
Výstup: 8
Vysvětlení: Existuje 7 dílčích polí s nenulovými čísly nevyváženosti:
- Subarray [1, 3] s číslem nerovnováhy 1.
- Subarray [1, 3, 3] s číslem nerovnováhy 1.
- Subarray [1, 3, 3, 3] s číslem nerovnováhy 1.
- Subarray [1, 3, 3, 3, 5] s číslem nerovnováhy 2.
- Subarray [3, 3, 3, 5] s číslem nerovnováhy 1.
- Subarray [3, 3, 5] s číslem nerovnováhy 1.
- Subarray [3, 5] s číslem nerovnováhy 1.
Číslo nevyváženosti všech ostatních podpolí je 0. Součet čísel nevyvážeností všech podpolí čísel je tedy 8.

Omezení:

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


Máte dané tři celá čísla x, y a z.
Máte x řetězců rovných "AA", y řetězců rovných "BB" a z řetězců rovných "AB". Chcete vybrat některé (případně všechny nebo žádné) z těchto řetězců a zřetězit je v libovolném pořadí, abyste vytvořili nový řetězec. Tento nový řetězec nesmí obsahovat "AAA" ani "BBB" jako podřetězec.
Vrátí maximální možnou délku nového řetězce.
Podřetězec je sousledná neprázdná sekvence znaků v rámci řetězce.

Příklad 1:

Vstup: x = 2, y = 5, z = 1
Výstup: 12
Vysvětlení: Můžeme zřetězit řetězce "BB", "AA", "BB", "AA", "BB" a "AB" v tomto pořadí. Pak náš nový řetězec je "BBAABBAABBAB".
Tento řetězec má délku 12 a můžeme ukázat, že není možné sestavit řetězec delší.

Příklad 2:

Vstup: x = 3, y = 2, z = 2
Výstup: 14
Vysvětlení: Můžeme zřetězit řetězce "AB", "AB", "AA", "BB", "AA", "BB" a "AA" v tomto pořadí. Pak náš nový řetězec je "ABABAABBAABBAA".
Tento řetězec má délku 14 a můžeme ukázat, že není možné sestavit řetězec delší.

Omezení:

1 <= x, y, z <= 50

Jsou dána tři celá čísla x, y a z.
Řetězce x se rovnají „AA“, řetězce y se rovnají „BB“ a řetězce z se rovnají „AB“. Chcete vybrat některé (případně všechny nebo žádné) z těchto řetězců a spojit je v určitém pořadí tak, aby vznikl nový řetězec. Tento nový řetězec nesmí obsahovat jako podřetězec „AAA“ nebo „BBB“.
Vraťte maximální možnou délku nového řetězce.
Podřetězec je souvislá neprázdná posloupnost znaků v řetězci.

Příklad 1:

Vstup: x = 2, y = 5, z = 1
Výstup: 12
Vysvětlení: V tomto pořadí můžeme spojit řetězce „BB“, „AA“, „BB“, „AA“, „BB“ a „AB“. Náš nový řetězec pak bude „BBAABBAABBAB“.
Tento řetězec má délku 12 a můžeme ukázat, že nelze sestrojit řetězec delší.

Příklad 2:

Vstup: x = 3, y = 2, z = 2
Výstup: 14
Vysvětlení: V tomto pořadí můžeme spojit řetězce „AB“, „AB“, „AA“, „BB“, „AA“, „BB“ a „AA“. Náš nový řetězec pak bude „ABABAABBAABBAA“.
Tento řetězec má délku 14 a my můžeme ukázat, že nelze sestrojit řetězec delší.

Omezení:

1 <= x, y, z <= 50

Jsou vám dána tři celá čísla x, y a z.
Máte x řetězců rovných „AA“, y řetězců rovných „BB“ a z řetězců rovných „AB“. Chcete si vybrat některé (možná všechny nebo žádné) z těchto řetězců a zřetězit je v nějakém pořadí, aby vytvořily nový řetězec. Tento nový řetězec nesmí obsahovat "AAA" nebo "BBB" jako podřetězec.
Vraťte maximální možnou délku nového řetězce.
Podřetězec je souvislá neprázdná sekvence znaků v řetězci.

Příklad 1:

Vstup: x = 2, y = 5, z = 1
Výstup: 12
Vysvětlení: Řetězce "BB", "AA", "BB", "AA", "BB" a "AB" můžeme spojit v tomto pořadí. Pak je náš nový řetězec "BBAABBAABBAB".
Tento řetězec má délku 12 a můžeme ukázat, že je nemožné sestrojit řetězec delší délky.

Příklad 2:

Vstup: x = 3, y = 2, z = 2
Výstup: 14
Vysvětlení: Řetězce "AB", "AB", "AA", "BB", "AA", "BB" a "AA" můžeme spojit v tomto pořadí. Pak je náš nový řetězec "ABABABAABBAABBAA".
Tento řetězec má délku 14 a můžeme ukázat, že je nemožné sestrojit řetězec delší délky.

Omezení:

1 <= x, y, z <= 50


Je zadáno pole slov s indexem 0 obsahující n řetězců.
Definujme operaci join(x, y) mezi dvěma řetězci x a y jako jejich spojení do xy. Pokud se však poslední znak řetězce x rovná prvnímu znaku řetězce y, jeden z nich se odstraní.
Například join(„ab“, „ba“) = „aba“ a join(„ab“, „cde“) = „abcde“.
Je třeba provést n - 1 operací join. Nechť str_0 = words[0]. Počínaje i = 1 až po i = n - 1 můžete pro i^tou operaci provést jednu z následujících operací:

Udělejte str_i = join(str_i - 1, words[i]).
Udělejte str_i = join(words[i], str_i - 1).

Vaším úkolem je minimalizovat délku str_n - 1.
Vraťte celé číslo označující minimální možnou délku str_n - 1.

Příklad 1:

Vstup: words = [„aa“, „ab“, „bc“]
Výstup: 4
Vysvětlení: V tomto příkladu můžeme provádět operace spojování v následujícím pořadí, abychom minimalizovali délku str_2:
str_0 = „aa“
str_1 = join(str_0, „ab“) = „aab“
str_2 = join(str_1, „bc“) = „aabc“
Lze ukázat, že minimální možná délka str_2 je 4.
Příklad 2:

Vstup: words = [„ab“, „b“]
Výstup: 2
Vysvětlení: V tomto příkladu je str_0 = „ab“, existují dva způsoby, jak získat str_1:
join(str_0, „b“) =„ab“ nebo join(„b“, str_0) =„bab“.
První řetězec, „ab“, má minimální délku. Proto je odpověď 2.

Příklad 3:

Vstup: words = [„aaa“, „c“, „aba“]
Výstup: 6
Vysvětlení: V tomto příkladu můžeme provádět operace spojování v následujícím pořadí, abychom minimalizovali délku str_2:
str_0 = „aaa“
str_1 = join(str_0, „c“) = „aaac“
str_2 = join(„aba“, str_1) = „abaaac“
Lze ukázat, že minimální možná délka str_2 je 6.

Omezení:

1 <= words.length <= 1000
1 <= words[i].length <= 50
Každý znak ve words[i] je anglické malé písmeno

Je zadáno pole slov s indexem 0 obsahující n řetězců.
Definujme operaci join(x, y) mezi dvěma řetězci x a y jako jejich spojení do xy. Pokud se však poslední znak řetězce x rovná prvnímu znaku řetězce y, jeden z nich se odstraní.
Například join("ab", "ba") = "aba" and join("ab", "cde") = "abcde".
Je třeba provést n - 1 operací join. Nechť str_0 = words[0]. Počínaje i = 1 až po i = n - 1 můžete pro i^tou operaci provést jednu z následujících operací:

Udělejte str_i = join(str_i - 1, words[i]).
Make str_i = join(words[i], str_i - 1)

Vaším úkolem je minimalizovat délku str_n - 1.
Vraťte celé číslo označující minimální možnou délku str_n - 1.

Příklad 1:

Vstup: words = ["aa","ab","bc"]
Výstup: 4
Vysvětlení: V tomto příkladu můžeme provádět operace spojování v následujícím pořadí, abychom minimalizovali délku str_2:
str_0 ="aa"
str_1 = join(str_0, „ab“) ="aab"
str_2 = join(str_1, „bc“) =  "aabc"
Lze ukázat, že minimální možná délka str_2 je 4.
Příklad 2:

Vstup: words = ["ab","b"]
Výstup: 2
Vysvětlení: V tomto příkladu je str_0 = "ab", existují dva způsoby, jak získat str_1:
join(str_0,  "b") = "ab" nebo join("b", str_0) = "bab".
První řetězec,  "ab", má minimální délku. Proto je odpověď 2.

Příklad 3:

Vstup: words = "aaa","c","aba"]
Výstup: 6
Vysvětlení: V tomto příkladu můžeme provádět operace spojování v následujícím pořadí, abychom minimalizovali délku str_2:
str_0 ="aaa"
str_1 = join(str_0, „c“) = "aaac"
str_2 = join(„aba“, str_1) = "abaaac"
Lze ukázat, že minimální možná délka str_2 je 6.

Omezení:

1 <= words.length <= 1000
1 <= words[i].length <= 50
Každý znak ve words[i] je anglické malé písmeno

Dostanete pole slov indexovaných 0 obsahující n řetězců.
Definujme operaci spojení (x, y) mezi dvěma řetězci x a y jako jejich zřetězení do xy. Pokud se však poslední znak znaku x rovná prvnímu znaku znaku y, jeden z nich se odstraní.
Například join("ab", "ba") = "aba" a join("ab", "cde") = "abcde".
je třeba provést n - 1 operací spojení. Nechť str_0 = words[0]. Počínaje i = 1 až i = n - 1 můžete pro i^tou operaci provést jednu z následujících akcí:

Make str_i = join(str_i - 1, words[i])
Make str_i = join(words[i], str_i - 1)

Vaším úkolem je minimalizovat délku str_n - 1.
Vrací celé číslo označující minimální možnou délku str_n - 1.

Příklad 1:

Vstup: words = ["aa","ab","bc"]
Výstup: 4
Vysvětlení: V tomto příkladu můžeme provádět operace spojení v následujícím pořadí, abychom minimalizovali délku str_2:
str_0 = "aa"
str_1 = join(str_0, "ab") = "aab"
str_2 = join(str_1, "bc") = "aabc"
Lze ukázat, že minimální možná délka str_2 je 4.
Příklad 2:

Vstup: words = ["ab","b"]
Výstup: 2
Vysvětlení: V tomto příkladu str_0 = "ab" existují dva způsoby, jak získat str_1:
join(str_0, "b") = "ab" nebo join("b", str_0) = "bab".
První řetězec, "ab", má minimální délku. Odpověď je tedy 2.

Příklad 3:

Vstup: words = ["aaa","c","aba"]
Výstup: 6
Vysvětlení: V tomto příkladu můžeme provádět operace spojení v následujícím pořadí, abychom minimalizovali délku str_2:
str_0 = "aaa"
str_1 = join(str_0, "c") = "aaac"
str_2 = join("aba", str_1) = "abaaac"
Lze ukázat, že minimální možná délka str_2 je 6.

Omezení:

1 <= words.length <= 1000
1 <= words[i].length <= 50
Každý znak ve slovech[i] je anglické malé písmeno


Máte k dispozici pole nums s n celými čísly a celé číslo target, indexované od nuly. Původně se nacházíte na indexu 0. V jednom kroku můžete skočit z indexu i na jakýkoliv index j, pro který platí:

0 <= i < j < n
-target <= nums[j] - nums[i] <= target

Vrátí maximální počet skoků, které můžete udělat, abyste dosáhli indexu n - 1.
Pokud neexistuje způsob, jak dosáhnout indexu n - 1, vraťte -1.

Příklad 1:

Input: nums = [1,3,6,4,1,2], target = 2
Output: 3
Vysvětlení: Pro přechod z indexu 0 na index n - 1 s maximálním počtem skoků můžete provést následující skokovou posloupnost:
- Skočte z indexu 0 na index 1.
- Skočte z indexu 1 na index 3.
- Skočte z indexu 3 na index 5.
Lze dokázat, že neexistuje jiná skoková posloupnost, která přejde z 0 na n - 1 s více než 3 skoky. Proto je odpověď 3.

Příklad 2:

Input: nums = [1,3,6,4,1,2], target = 3
Output: 5
Vysvětlení: Pro přechod z indexu 0 na index n - 1 s maximálním počtem skoků můžete provést následující skokovou posloupnost:
- Skočte z indexu 0 na index 1.
- Skočte z indexu 1 na index 2.
- Skočte z indexu 2 na index 3.
- Skočte z indexu 3 na index 4.
- Skočte z indexu 4 na index 5.
Lze dokázat, že neexistuje jiná skoková posloupnost, která přejde z 0 na n - 1 s více než 5 skoky. Proto je odpověď 5.

Příklad 3:

Input: nums = [1,3,6,4,1,2], target = 0
Output: -1
Vysvětlení: Lze dokázat, že neexistuje žádná skoková posloupnost, která přejde z 0 na n - 1. Proto je odpověď -1.

Omezení:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= target <= 2 * 10^9

Dostanete pole indexované 0, nums n celých čísel a celočíselný cíl.
Zpočátku jste umístěni na indexu 0. V jednom kroku můžete přeskočit z indexu i na libovolný index j tak, že:

0 <= i < j < n
-target <= nums[j] - nums[i] <= cíl

Vrátí maximální počet skoků, které můžete provést k dosažení indexu n - 1.
Pokud neexistuje způsob, jak dosáhnout indexu n - 1, vrátí hodnotu -1.

Příklad 1:

Vstup: nums = [1,3,6,4,1,2], target = 2
Výstup: 3
Vysvětlení: Chcete-li přejít z indexu 0 na index n - 1 s maximálním počtem skoků, můžete provést následující sekvenci skoků:
- Skok z indexu 0 na index 1.
- Skok z indexu 1 na index 3.
- Skok z indexu 3 na index 5.
Lze dokázat, že neexistuje žádná jiná sekvence skoků, která by šla od 0 do n - 1 s více než 3 skoky. Odpověď je tedy 3.
Příklad 2:

Vstup: nums = [1,3,6,4,1,2], target = 3
Výstup: 5
Vysvětlení: Chcete-li přejít z indexu 0 na index n - 1 s maximálním počtem skoků, můžete provést následující sekvenci skoků:
- Skok z indexu 0 na index 1.
- Skok z indexu 1 na index 2.
- Skok z indexu 2 na index 3.
- Skok z indexu 3 na index 4.
- Skok z indexu 4 na index 5.
Lze dokázat, že neexistuje žádná jiná sekvence skoků, která by šla od 0 do n - 1 s více než 5 skoky. Odpověď je tedy 5.
Příklad 3:

Vstup: nums = [1,3,6,4,1,2], target = 0
Výstup: -1
Vysvětlení: Lze dokázat, že neexistuje žádná přeskakovací sekvence, která by šla od 0 do n - 1. Odpověď je tedy -1.

Omezení:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= cíl <= 2 * 10^9

Dostanete 0-indexované pole s počtem n celých čísel a celočíselným cílem.
Zpočátku jste umístěni na indexu 0. V jednom kroku můžete přeskočit z indexu i na jakýkoli index j, takže:

0 <= i < j < n
-target <= nums[j] - nums[i] <= cíl

Vraťte maximální počet skoků, které můžete provést, abyste dosáhli indexu n - 1.
Pokud neexistuje způsob, jak dosáhnout indexu n - 1, vraťte hodnotu -1.

Příklad 1:

Vstup: nums = [1,3,6,4,1,2], cíl = 2
Výstup: 3
Vysvětlení: Chcete-li přejít z indexu 0 na index n - 1 s maximálním počtem skoků, můžete provést následující sekvenci skoků:
- Skok z indexu 0 na index 1.
- Skok z indexu 1 na index 3.
- Skok z indexu 3 na index 5.
Lze prokázat, že neexistuje žádná jiná skoková sekvence, která by šla od 0 do n - 1 s více než 3 skoky. Odpověď je tedy 3.
Příklad 2:

Vstup: nums = [1,3,6,4,1,2], cíl = 3
Výstup: 5
Vysvětlení: Chcete-li přejít z indexu 0 na index n - 1 s maximálním počtem skoků, můžete provést následující sekvenci skoků:
- Skok z indexu 0 na index 1.
- Skok z indexu 1 na index 2.
- Skok z indexu 2 na index 3.
- Skok z indexu 3 na index 4.
- Skok z indexu 4 na index 5.
Lze prokázat, že neexistuje žádná jiná skoková sekvence, která by se pohybovala od 0 do n - 1 s více než 5 skoky. Odpověď je tedy 5.
Příklad 3:

Vstup: nums = [1,3,6,4,1,2], cíl = 0
Výstup: -1
Vysvětlení: Lze dokázat, že neexistuje žádná skoková sekvence, která by se pohybovala od 0 do n - 1. Odpověď je tedy -1.

Omezení:

2 <= nums.length == n <= 1000
-10^9 <= nums[i] <= 10^9
0 <= cíl <= 2 * 10^9


Je zadáno pole nums složené z celých kladných čísel.
Dílčí pole pole nazýváme úplné, pokud je splněna následující podmínka:

Počet rozdílných prvků v dílčím poli je roven počtu rozdílných prvků v celém poli.

Vraťte počet úplných dílčích polí.
Podmnožina je souvislá neprázdná část pole.

Příklad 1:

Vstup: nums = [1,3,1,2,2]
Výstup: 4
Vysvětlení: Úplná dílčí pole jsou následující: [1,3,1,2], [1,3,1,2,2], [3,1,2] a [3,1,2,2].

Příklad 2:

Vstup: nums = [5,5,5,5]
Výstup: 10
Vysvětlení: Pole se skládá pouze z celého čísla 5, takže každé podpole je kompletní. Počet dílčích polí, které můžeme zvolit, je 10.

Omezení:

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

Dostanete pole nums skládající se z kladných celých čísel.
Dílčí pole pole nazýváme kompletní, pokud je splněna následující podmínka:

Počet odlišných prvků v dílčím poli se rovná počtu odlišných prvků v celém poli.

Vraťte počet úplných podpolí.
Podpole je souvislá neprázdná část pole.

Příklad 1:

Vstup: nums = [1,3,1,2,2]
Výstup: 4
Vysvětlení: Kompletní podpole jsou následující: [1,3,1,2], [1,3,1,2,2], [3,1,2] a [3,1,2,2].

Příklad 2:

Vstup: nums = [5,5,5,5]
Výstup: 10
Vysvětlení: Pole se skládá pouze z celého čísla 5, takže každé podpole je kompletní. Počet podpolí, které si můžeme vybrat, je 10.

Omezení:

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

Je vám dáno pole nums sestávající z kladných celých čísel.
Podpole pole nazýváme úplným, pokud je splněna následující podmínka:

Počet různých prvků v podpoli je roven počtu různých prvků v celém poli.

Vraťte počet úplných podpolí.
Podpole je souvislá neprázdná část pole.

Příklad 1:

Vstup: nums = [1,3,1,2,2]
Výstup: 4
Vysvětlení: Úplná podpole jsou následující: [1,3,1,2], [1,3,1,2,2], [3,1,2] a [3,1,2,2].

Příklad 2:

Vstup: nums = [5,5,5,5]
Výstup: 10
Vysvětlení: Pole obsahuje pouze celé číslo 5, takže jakékoliv podpole je úplné. Počet podpolí, které můžeme vybrat, je 10.

Omezení:

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


Vůz má dvě palivové nádrže. Máte dvě celá čísla, mainTank představující množství paliva v hlavní nádrži v litrech a additionalTank představující množství paliva v přídavné nádrži v litrech.
Vůz má spotřebu 10 km na litr. Kdykoli se v hlavní nádrži spotřebuje 5 litrů paliva, pokud je v přídavné nádrži alespoň 1 litr paliva, bude 1 litr paliva převeden z přídavné nádrže do hlavní nádrže.
Vraťte maximální vzdálenost, kterou lze ujet.
Poznámka: Vstřikování z přídavné nádrže není spojité. Dochází k němu náhle a okamžitě pro každých spotřebovaných 5 litrů.

Příklad 1:

Vstup: mainTank = 5, additionalTank = 10
Výstup: 60
Vysvětlení:
Po spotřebě 5 litrů paliva zbývá (5 - 5 + 1) = 1 litr paliva a ujetá vzdálenost je 50 km.
Po spotřebě dalšího 1 litru paliva se žádné palivo do hlavní nádrže nevtlačí a hlavní nádrž se vyprázdní.
Celková ujetá vzdálenost je 60 km.

Příklad 2:

Vstup: mainTank = 1, additionalTank = 2
Výstup: 10
Vysvětlení:
Po spotřebě 1 litru paliva se hlavní nádrž vyprázdní.
Celková ujetá vzdálenost je 10 km.

Omezení:

1 <= mainTank, additionalTank <= 100

Nákladní auto má dvě palivové nádrže. Dostanete dvě celá čísla, hlavní nádrž představuje palivo přítomné v hlavní nádrži v litrech a přídavná nádrž představuje palivo přítomné v přídavné nádrži v litrech.
nákladní auto má spotřebu 10 km na litr. Kdykoli dojde k vyčerpání 5 litrů paliva v hlavní nádrži, pokud má přídavná nádrž alespoň 1 litr paliva, převede se 1 litr paliva z přídavné nádrže do hlavní nádrže.
Vraťte maximální vzdálenost, kterou lze ujet.
Poznámka: Převod z přídavné nádrže není kontinuální. Stává se to náhle a okamžitě na každých 5 spotřebovaných litrů.

Příklad 1:

Vstup: hlavní nádrž = 5, přídavná nádrž = 10
Výstup: 60
Vysvětlení:
Po spotřebování 5 litrů paliva je zbývající palivo (5 - 5 + 1) = 1 litr a ujetá vzdálenost je 50 km.
Po spotřebování dalšího 1 litru paliva se do hlavní nádrže nevstříkne žádné palivo a hlavní nádrž se vyprázdní.
Celková ujetá vzdálenost je 60 km.

Příklad 2:

Vstup: hlavní nádrž = 1, přídavná nádrž = 2
Výstup: 10
Vysvětlení:
Po spotřebování 1 litru paliva se hlavní nádrž vyprázdní.
Celková ujetá vzdálenost je 10 km.

Omezení:

1 <= hlavní nádrž, další nádrž <= 100

Vůz má dvě palivové nádrže. Dostal si zadána dvě celá čísla, mainTank představující množství paliva v hlavní nádrži v litrech a additionalTank představující množství paliva v přídavné nádrži v litrech.
Vůz má spotřebu 10 km na litr. Kdykoli se v hlavní nádrži spotřebuje 5 litrů paliva, pokud je v přídavné nádrži alespoň 1 litr paliva, bude 1 litr paliva převeden z přídavné nádrže do hlavní nádrže.
Vrať maximální vzdálenost, kterou lze ujet.
Poznámka: Vstřikování z přídavné nádrže není nepřetržité. Dochází k němu náhle po každých 5 spotřebovaných litrech.

Příklad 1:

Vstup: mainTank = 5, additionalTank = 10
Výstup: 60
Vysvětlení:
Po spotřebě 5 litrů paliva zbývá (5 - 5 + 1) = 1 litr paliva a ujetá vzdálenost je 50 km.
Po spotřebě dalšího 1 litru paliva se žádné palivo do hlavní nádrže nevtlačí a hlavní nádrž se vyprázdní.
Celková ujetá vzdálenost je 60 km.

Příklad 2:

Vstup: mainTank = 1, additionalTank = 2
Výstup: 10
Vysvětlení:
Po spotřebě 1 litru paliva se hlavní nádrž vyprázdní.
Celková ujetá vzdálenost je 10 km.

Omezení:

1 <= mainTank, additionalTank <= 100


Máte 0-indexované pole celých čísel nums a celé číslo threshold. Najděte délku nejdelší podpole nums začínajícího na indexu l a končícího na indexu r (0 <= l <= r < nums.length), které splňuje následující podmínky:

nums[l] % 2 == 0
Pro všechny indexy i v rozsahu [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Pro všechny indexy i v rozsahu [l, r], nums[i] <= threshold

Vrátí celé číslo označující délku nejdelšího takového podpole.
Poznámka: Podpole je souvislá neprázdná posloupnost prvků v rámci pole.

Příklad 1:

Vstup: nums = [3,2,5,4], threshold = 5
Výstup: 3
Vysvětlení: V tomto příkladu můžeme vybrat podpole, které začíná na l = 1 a končí na r = 3 => [2,5,4]. Toto podpole splňuje podmínky.
Odpovědí je tedy délka podpole, 3. Můžeme ukázat, že 3 je maximální dosažitelná délka.
Příklad 2:

Vstup: nums = [1,2], threshold = 2
Výstup: 1
Vysvětlení: V tomto příkladu můžeme vybrat podpole, které začíná na l = 1 a končí na r = 1 => [2].
Splňuje všechny podmínky a můžeme ukázat, že 1 je maximální dosažitelná délka.

Příklad 3:

Vstup: nums = [2,3,4,5], threshold = 4
Výstup: 3
Vysvětlení: V tomto příkladu můžeme vybrat podpole, které začíná na l = 0 a končí na r = 2 => [2,3,4].
Splňuje všechny podmínky.
Odpovědí je tedy délka podpole, 3. Můžeme ukázat, že 3 je maximální dosažitelná délka.

Omezení:

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

Dostanete 0-indexované celočíselné pole čísel, čísla a celočíselnou prahovou hodnotu.
Určete délku nejdelšího podpole čísel začínajících indexem l a končících indexem r (0 <= l <= r < nums.length), které splňuje následující podmínky:

nums[l] % 2 == 0
Pro všechny indexy i v rozsahu [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Pro všechny indexy i v rozsahu [l, r], nums[i] <= threshold

Vrátí celé číslo označující délku nejdelšího takového podpole.
Poznámka: Podpole je souvislá neprázdná posloupnost prvků v poli.

Příklad 1:

Vstup: nums = [3,2,5,4], threshold = 5
Výstup: 3
Vysvětlení: V tomto příkladu můžeme vybrat podpole, které začíná na l = 1 a končí na r = 3 = > [2,5,4]. Tento podsoubor splňuje podmínky.
Odpovědí je tedy délka podpole, 3. Můžeme ukázat, že 3 je maximální možná dosažitelná délka.
Příklad 2:

Vstup: nums = [1,2], threshold = 2
Výstup: 1
Vysvětlení: V tomto příkladu můžeme vybrat podpole, které začíná na l = 1 a končí na r = 1 = > [2].
Splňuje všechny podmínky a můžeme ukázat, že 1 je maximální možná dosažitelná délka.

Příklad 3:

Vstup: nums = [2,3,4,5], threshold = 4
Výstup: 3
Vysvětlení: V tomto příkladu můžeme vybrat podpole, které začíná na l = 0 a končí na r = 2 = > [2,3,4].
Splňuje všechny podmínky.
Odpovědí je tedy délka podpole, 3. Můžeme ukázat, že 3 je maximální možná dosažitelná délka.

Omezení:

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


Je zadáno binární pole nums.
Dílčí pole pole je dobré, pokud obsahuje přesně jeden prvek s hodnotou 1.
Vraťte celé číslo označující počet způsobů rozdělení pole nums na dobrá podpole. Protože číslo může být příliš velké, vraťte jej modulo 10^9 + 7.
Dílčí pole je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [0,1,0,0,1]
Výstup: 3
Vysvětlení: Existují 3 způsoby, jak rozdělit nums do dobrých dílčích polí:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Příklad 2:

Vstup: nums = [0,1,0]
Výstup: 1
Vysvětlení: Existuje 1 způsob, jak rozdělit nums na dobrá dílčí pole:
- [0,1,0]

Omezení:

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

Je vám dán binární pole nums.
Podpole pole je dobré, pokud obsahuje přesně jeden prvek s hodnotou 1.
Vraťte celé číslo označující počet způsobů, jak rozdělit pole nums na dobrá podpola. Jelikož počet může být příliš velký, vraťte ho modulo 10^9 + 7.
Podpole je souvislá neprázdná posloupnost prvků uvnitř pole.

Příklad 1:

Vstup: nums = [0,1,0,0,1]
Výstup: 3
Vysvětlení: Existují 3 způsoby, jak rozdělit nums na dobrá podpola:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Příklad 2:

Vstup: nums = [0,1,0]
Výstup: 1
Vysvětlení: Existuje 1 způsob, jak rozdělit nums na dobrá podpola:
- [0,1,0]

Omezení:

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

Je vám přiděleno binární pole nums.
Podpole pole je dobré, pokud obsahuje právě jeden prvek s hodnotou 1.
Vrátí celé číslo označující počet způsobů, jak rozdělit čísla pole na správná podpole. Protože číslo může být příliš velké, vraťte jej modulo 10^9 + 7.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [0,1,0,0,1]
Výstup: 3
Vysvětlení: Existují 3 způsoby, jak rozdělit čísla na dobrá podpole:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Příklad 2:

Vstup: nums = [0,1,0]
Výstup: 1
Vysvětlení: Existuje 1 způsob, jak rozdělit čísla na dobrá podpole:
- [0,1,0]

Omezení:

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


Je vám dána 0-indexované celočíselné pole nums. Podpole nums se nazývá kontinuální, pokud:
Nechť i, i + 1, ..., j_ jsou indexy v podpoli. Pak pro každý pár indexů i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Vraťte celkový počet spojitých podpolí.
Podpole je souvislá neprázdná posloupnost prvků v rámci pole.

Příklad 1:

Vstup: nums = [5,4,2,4]
Výstup: 8
Vysvětlení:
Spojité podpole velikosti 1: [5], [4], [2], [4].
Spojité podpole velikosti 2: [5,4], [4,2], [2,4].
Spojité podpole velikosti 3: [4,2,4].
Nejsou žádná podpole velikosti 4.
Celkový počet spojitých podpolí = 4 + 3 + 1 = 8.
Lze ukázat, že neexistují žádná další spojitá podpole.

Příklad 2:

Vstup: nums = [1,2,3]
Výstup: 6
Vysvětlení:
Spojité podpole velikosti 1: [1], [2], [3].
Spojité podpole velikosti 2: [1,2], [2,3].
Spojité podpole velikosti 3: [1,2,3].
Celkový počet spojitých podpolí = 3 + 2 + 1 = 6.

Omezení:

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

Dostanete 0-indexované celočíselné pole nums. Podskupina num se nazývá spojitá, pokud:

Nechť i, i + 1, ..., j_ jsou indexy v dílčím poli. Potom pro každou dvojici indexů i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Vrátí celkový počet souvislých podpolí.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [5,4,2,4]
Výstup: 8
Vysvětlení:
Spojité podpole velikosti 1: [5], [4], [2], [4].
Spojité podpole velikosti 2: [5,4], [4,2], [2,4].
Spojité podpole velikosti 3: [4,2,4].
Neexistují žádné podskupiny velikosti 4.
Celkový počet spojitých podpolí = 4 + 3 + 1 = 8.
Lze ukázat, že již neexistují žádná spojitá podpole.

Příklad 2:

Vstup: nums = [1,2,3]
Výstup: 6
Vysvětlení:
Spojité podpole velikosti 1: [1], [2], [3].
Spojité podpole velikosti 2: [1,2], [2,3].
Spojité podpole velikosti 3: [1,2,3].
Celkový počet spojitých podpolí = 3 + 2 + 1 = 6.

Omezení:

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

Dostanete nums celého pole s indexem 0. Podpole nums se nazývá kontinuální, pokud:

Nechť i, i + 1, ..., j_ být indexy v podpoli. Pak pro každou dvojici indexů i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Vrátí celkový počet kontinuálních podpolí.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [5,4,2,4]
Výstup: 8
Vysvětlení:
Kontinuální podpole o velikosti 1: [5], [4], [2], [4].
Spojitý podpole o velikosti 2: [5,4], [4,2], [2,4].
Spojitý podpole o velikosti 3: [4,2,4].
Nejsou zde žádná podpole velikosti 4.
Celkový počet spojitých podpolí = 4 + 3 + 1 = 8.
Lze ukázat, že již neexistují žádná kontinuální podpole.

Příklad 2:

Vstup: nums = [1,2,3]
Výstup: 6
Vysvětlení:
Kontinuální podpole o velikosti 1: [1], [2], [3].
Spojité podpole o velikosti 2: [1,2], [2,3].
Spojitý podpole o velikosti 3: [1,2,3].
Celkový počet spojitých podpolí = 3 + 2 + 1 = 6.

Omezení:

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


Máte dva celočíselné pole nums1 a nums2 s 0-indexováním délky n. Definujme další celočíselné pole s 0-indexováním, nums3, délky n. Pro každý index i v rozsahu [0, n - 1] můžete přiřadit buď nums1[i] nebo nums2[i] do nums3[i]. Vaším úkolem je maximalizovat délku nejdelší neklesající podpole v nums3 výběrem jeho hodnot optimálně. Vraťte celé číslo reprezentující délku nejdelšího neklesajícího podpole v nums3. Poznámka: Podpole je souvislá neprazdná sekvence prvků v poli.

Příklad 1:

Vstup: nums1 = [2,3,1], nums2 = [1,2,1]
Výstup: 2
Vysvětlení: Jeden způsob, jak vytvořit nums3, je:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
Podpole začínající od indexu 0 a končící na indexu 1, [2,2], tvoří neklesající podpole délky 2.
Můžeme ukázat, že 2 je maximální dosažitelná délka.

Příklad 2:

Vstup: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Výstup: 4
Vysvětlení: Jeden způsob, jak vytvořit nums3, je:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Celé pole tvoří neklesající podpole délky 4, což je maximální dosažitelná délka.

Příklad 3:

Vstup: nums1 = [1,1], nums2 = [2,2]
Výstup: 2
Vysvětlení: Jeden způsob, jak vytvořit nums3, je:
nums3 = [nums1[0], nums1[1]] => [1,1].
Celé pole tvoří neklesající podpole délky 2, což je maximální dosažitelná délka.

Omezení:

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

Dostanete dvě 0-indexovaná celočíselná pole nums1 a nums2 délky n.
Definujme další 0-indexované celočíselné pole, nums3, délky n. Pro každý index i v rozsahu [0, n - 1] můžete přiřadit buď nums1[i] nebo nums2[i] k nums3[i].
Vaším úkolem je maximalizovat délku nejdelšího neklesajícího podpole v nums3 optimálním výběrem jeho hodnot.
Vrátí celé číslo představující délku nejdelšího neklesajícího podpole v nums3.
Poznámka: Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums1 = [2,3,1], nums2 = [1,2,1]
Výstup: 2
Vysvětlení: Jeden způsob, jak vytvořit nums3, je:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
Podpole začínající indexem 0 a končící indexem 1, [2,2] tvoří neklesající podpole délky 2.
Můžeme ukázat, že 2 je maximální dosažitelná délka.
Příklad 2:

Vstup: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Výstup: 4
Vysvětlení: Jeden způsob, jak vytvořit nums3, je:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Celé pole tvoří neklesající podpole délky 4, což z něj činí maximální dosažitelnou délku.

Příklad 3:

Vstup: nums1 = [1,1], nums2 = [2,2]
Výstup: 2
Vysvětlení: Jeden způsob, jak vytvořit nums3, je:
nums3 = [nums1[0], nums1[1]] => [1,1].
Celé pole tvoří neklesající podpole délky 2, což z něj činí maximální dosažitelnou délku.

Omezení:

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

Dostanete dvě celočíselná pole indexovaná 0 nums1 a nums2 o délce n.
Definujme další celočíselné pole indexované 0, nums3, o délce n. Pro každý index i v rozsahu [0, n - 1] můžete přiřadit buď nums1[i] nebo nums2[i] k nums3[i].
Vaším úkolem je maximalizovat délku nejdelšího neklesajícího podpole v nums3 optimálním výběrem jeho hodnot.
Vrátí celé číslo představující délku nejdelšího neklesajícího podpole v nums3.
Poznámka: Podpole je souvislá neprázdná posloupnost prvků v poli.

Příklad 1:

Vstup: nums1 = [2,3,1], nums2 = [1,2,1]
Výstup: 2
Vysvětlení: Jeden ze způsobů, jak vytvořit nums3 je:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
Podpole začínající indexem 0 a končící indexem 1, [2,2], tvoří neklesající podpole o délce 2.
Můžeme ukázat, že 2 je maximální dosažitelná délka.
Příklad 2:

Vstup: nums1 = [1,3,2,1], nums2 = [2,2,3,4]
Výstup: 4
Vysvětlení: Jeden ze způsobů, jak vytvořit nums3 je:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Celé pole tvoří nezmenšující se podpole o délce 4, což z něj činí maximální dosažitelnou délku.

Příklad 3:

Vstup: nums1 = [1,1], nums2 = [2,2]
Výstup: 2
Vysvětlení: Jeden ze způsobů, jak vytvořit nums3 je:
nums3 = [nums1[0], nums1[1]] => [1,1].
Celé pole tvoří nezmenšující se podpole o délce 2, což z něj činí maximální dosažitelnou délku.

Omezení:

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


Dostanete 0-indexované celočíselné pole nums. Dílčí pole s o délce m se nazývá střídavé, pokud:

m je větší než 1.
s_1 = s_0 + 1.
0-indexované podpole s vypadá jako [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Jinými slovy, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1 a tak dále až do s[m - 1] - s[m - 2] = ( -1)^m.

Vrátí maximální délku všech alternujících podpolí přítomných v číslech nebo -1, pokud žádné takové podpole neexistuje.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [2,3,4,3,4]
Výstup: 4
Vysvětlení: Alternativní podpole jsou [3,4], [3,4,3] a [3,4,3,4]. Nejdelší z nich je [3,4,3,4], který má délku 4.

Příklad 2:

Vstup: nums = [4,5,6]
Výstup: 2
Vysvětlení: [4,5] a [5,6] jsou jediná dvě střídající se podpole. Oba mají délku 2.

Omezení:

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

Dostanete číslo celého pole s indexem 0. Podpole s o délce m se nazývá střídavé, pokud:

m je větší než 1.
s_1 = s_0 + 1.
Podpole s indexované hodnotou 0 vypadá takto: [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Jinými slovy, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1, a tak dále až do s[m - 1] - s[m - 2] = (-1)^m.

Vrátí maximální délku všech střídajících se podpolí přítomných v číslech nebo -1, pokud žádné takové podpole neexistuje.
Podpole je souvislá neprázdná sekvence prvků v poli.

Příklad 1:

Vstup: nums = [2,3,4,3,4]
Výstup: 4
Vysvětlení: Střídají se podpole jsou [3,4], [3,4,3] a [3,4,3,4]. Nejdelší z nich je [3,4,3,4], který má délku 4.

Příklad 2:

Vstup: nums = [4,5,6]
Výstup: 2
Vysvětlení: [4,5] a [5,6] jsou jediná dvě střídající se podpole. Oba jsou délky 2.

Omezení:

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

Máte zadané pole celých čísel nums s indexací od 0. Podpole s délku m je nazýváno střídavé, pokud:

m je větší než 1.
s_1 = s_0 + 1.
Podpole s s indexací od 0 vypadá jako [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Jinými slovy, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1 a tak dále až po s[m - 1] - s[m - 2] = (-1)^m.

Vraťte maximální délku všech střídavých podpolí, která se nacházejí v nums, nebo -1, pokud takové podpole neexistuje.
Podpole je souvislá neprázdná sekvence prvků v rámci pole.

Příklad 1:

Vstup: nums = [2,3,4,3,4]
Výstup: 4
Vysvětlení: Střídavá podpole jsou [3,4], [3,4,3] a [3,4,3,4]. Nejdelší z nich je [3,4,3,4], které má délku 4.

Příklad 2:

Vstup: nums = [4,5,6]
Výstup: 2
Vysvětlení: [4,5] a [5,6] jsou jediná dvě střídavá podpole. Obě mají délku 2.

Omezení:

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