Máte dány dva řetězce word1 a word2.
Řetězec x je nazýván platným, pokud může být přeuspořádán tak, aby měl word2 jako předponu.
Vraťte celkový počet platných podřetězců řetězce word1.

Příklad 1:

Vstup: word1 = "bcca", word2 = "abc"
Výstup: 1
Vysvětlení:
Jediný platný podřetězec je "bcca", který může být přeuspořádán na "abcc" s "abc" jako předponou.

Příklad 2:

Vstup: word1 = "abcabc", word2 = "abc"
Výstup: 10
Vysvětlení:
Všechny podřetězce kromě podřetězců velikosti 1 a velikosti 2 jsou platné.

Příklad 3:

Vstup: word1 = "abcabc", word2 = "aaabc"
Výstup: 0

Omezení:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 a word2 se skládají pouze z malých písmen anglické abecedy.

Jsou vám dány dva řetězce slovo1 a slovo2.
Řetězec x se nazývá platný, pokud lze x přeuspořádat tak, aby měl slovo2 jako předponu.
Vrátí celkový počet platných podřetězců slova1.

Příklad 1:

Vstup: slovo1 = "bcca", slovo2 = "abc"
Výstup: 1
Vysvětlení:
Jediný platný podřetězec je "bcca", který lze přeskupit na "abcc" s "abc" jako předponou.

Příklad 2:

Vstup: slovo1 = "abcabc", slovo2 = "abc"
Výstup: 10
Vysvětlení:
Všechny podřetězce kromě podřetězců velikosti 1 a velikosti 2 jsou platné.

Příklad 3:

Vstup: slovo1 = "abcabc", slovo2 = "aaabc"
Výstup: 0

Omezení:

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

Jsou vám dány dva řetězce: word1 a word2.
Řetězec x se nazývá platný, pokud x lze přeuspořádat tak, aby měl jako předponu word2.
Vrátí celkový počet platných podřetězců word1.

Příklad 1:

Vstup: word1 = "bcca", word2 = "abc"
Výstup: 1
Vysvětlení:
Jediným platným podřetězcem je "bcca", který lze přeuspořádat na "abcc" s předponou "abc".

Příklad 2:

Vstup: word1 = "abcabc", word2 = "abc"
Výstup: 10
Vysvětlení:
Všechny podřetězce kromě podřetězců velikosti 1 a velikosti 2 jsou platné.

Příklad 3:

Vstup: word1 = "abcabc", word2 = "aaabc"
Výstup: 0

Omezení:

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


Alice a Bob hrají hru. Na začátku má Alice řetězec word = "a".
Máte k dispozici kladné celé číslo k.
Bob nyní požádá Alici, aby navěky prováděla následující operaci:

Vytvořte nový řetězec změnou každého znaku v word na jeho následující znak v anglické abecedě a připojte ho k původnímu word.

Například provedení operace na "c" vytvoří "cd" a provedení operace na "zb" vytvoří "zbac".
Vrátit hodnotu k-tého znaku ve word, po dostatečném počtu operací, aby word měl alespoň k znaků.
Všimněte si, že znak 'z' může být při operaci změněn na 'a'.

Příklad 1:

Vstup: k = 5
Výstup: "b"
Vysvětlení:
Na začátku je word = "a". Operaci musíme provést třikrát:

Vygenerovaný řetězec je "b", word se stává "ab".
Vygenerovaný řetězec je "bc", word se stává "abbc".
Vygenerovaný řetězec je "bccd", word se stává "abbcbccd".

Příklad 2:

Vstup: k = 10
Výstup: "c"

Omezení:

1 <= k <= 500

Alice a Bob hrají hru. Zpočátku má Alice řetězcové word = "a".
Je vám dáno kladné celé číslo k.
Nyní Bob požádá Alici, aby navždy provedla následující operaci:

Vygenerujte nový řetězec tak, že změníte každý znak ve slově na jeho další znak v anglické abecedě a připojíte jej k původnímu slovu.

Například provedení operace na "c" vygeneruje "cd" a provedení operace na "zb" vygeneruje "zbac".
Vrátí hodnotu k^tého znaku ve wordu po provedení dostatečného počtu operací, aby word měl alespoň k znaků.
Všimněte si, že znak "z" lze v operaci změnit na "a".

Příklad 1:

Vstup: k = 5
Výstup: "b"
Vysvětlení:
Zpočátku word = "a". Operaci musíme provést třikrát:

Vygenerovaný řetězec je "b", slovo se změní na "ab".
Vygenerovaný řetězec je "bc", slovo se změní na "abbc".
Vygenerovaný řetězec je "bccd", slovo se změní na "abbcbccd".

Příklad 2:

Vstup: k = 10
Výstup: "c"

Omezení:

1 <= k <= 500

Alice a Bob hrají hru. Na začátku má Alice řetězec word = "a".
Je dáno celé kladné číslo k.
Nyní Bob požádá Alici, aby navždy provedla následující operaci:

Vygenerujte nový řetězec tak, že každý znak slova změníte na další znak anglické abecedy a připojíte jej k původnímu slovu.

Například provedením operace na"c" vznikne "cd" a provedením operace na "zb" vznikne "zbac".
Vraťte hodnotu k^tého znaku ve slově poté, co bylo provedeno tolik operací, aby slovo mělo alespoň k znaků.
Všimněte si, že znak'z' lze při operaci změnit na'a'.

Příklad 1:

Vstup: k = 5
Výstup: "b"
Vysvětlení:
Na začátku je slovo ="a" . Operaci musíme provést třikrát:

Vygenerovaný řetězec je "b", ze slova se stane "ab".
Vygenerovaný řetězec je "bc", ze slova se stane"abbc".
Vygenerovaný řetězec je"bccd", ze slova se stane "abbcbccd".

Příklad 2:

Vstup: k = 10
Výstup: "c"

Omezení:

1 <= k <= 500


Máte daný řetězec word a nezáporné celé číslo k.
Vraťte celkový počet podřetězců z word, které obsahují každou samohlásku ('a', 'e', 'i', 'o' a 'u') alespoň jednou a přesně k souhlásek.

Příklad 1:

Vstup: word = "aeioqq", k = 1
Výstup: 0
Vysvětlení:
Neexistuje žádný podřetězec se všemi samohláskami.

Příklad 2:

Vstup: word = "aeiou", k = 0
Výstup: 1
Vysvětlení:
Jediný podřetězec se všemi samohláskami a nulou souhlásek je word[0..4], což je "aeiou".

Příklad 3:

Vstup: word = "ieaouqqieaouqq", k = 1
Výstup: 3
Vysvětlení:
Podřetězce se všemi samohláskami a jednou souhláskou jsou:

word[0..5], což je "ieaouq".
word[6..11], což je "qieaou".
word[7..12], což je "ieaouq".

Omezení:

5 <= word.length <= 250
word se skládá pouze z malých písmen anglické abecedy.
0 <= k <= word.length - 5

Dostanete řetězcové slovo a nezáporné celé číslo k.
Vrátí celkový počet podřetězců slova, které obsahují každou samohlásku ('a', 'e', 'i', 'o' a 'u') alespoň jednou a přesně k souhlásek.

Příklad 1:

Vstup: slovo = "aeioqq", k = 1
Výstup: 0
Vysvětlení:
Neexistuje žádný podřetězec, který obsahuje všechny samohlásky.

Příklad 2:

Vstup: slovo = "aeiou", k = 0
Výstup: 1
Vysvětlení:
Jediný podřetězec s každou samohláskou a nulovými souhláskami je slovo[0..4], což je "aeiou".

Příklad 3:

Vstup: slovo = "ieaouqqieaouqq", k = 1
Výstup: 3
Vysvětlení:
Podřetězce s každou samohláskou a jednou souhláskou jsou:

slovo[0..5], což je "ieaouq".
slovo[6..11], což je „qieaou“.
slovo[7..12], což je "ieaouq".

Omezení:

5 <= délka slova <= 250
slovo se skládá pouze z malých anglických písmen.
0 <= k <= délka slova - 5

Je vám dáno řetězcové slovo a nezáporné celé číslo k.
Vrátí celkový počet podřetězců slova, které obsahují každou samohlásku ("a", 'e', 'i', 'o' a 'u') alespoň jednou a přesně k souhlásek.

Příklad 1:

Vstup: word = "aeioqq", k = 1
Výstup: 0
Vysvětlení:
U každé samohlásky není žádný podřetězec.

Příklad 2:

Vstup: word = "aeiou", k = 0
Výstup: 1
Vysvětlení:
Jediný podřetězec s každou samohláskou a bez souhlásek je word[0..4], což je "aeiou".

Příklad 3:

Vstup: word = "ieaouqqieaouqq", k = 1
Výstup: 3
Vysvětlení:
Podřetězce s každou samohláskou a jednou souhláskou jsou:

word[0..5], což je "ieaouq".
word[6..11], což je "qieaou".
word[7..12], což je "ieaouq".

Omezení:

5 <= word.length <= 250
word se skládá pouze z malých písmen anglické abecedy.
0 <= k <= word.length - 5


Máte pole celých čísel `nums` o velikosti 3.
Vraťte maximální možné číslo, jehož binární reprezentace může být vytvořena spojením binárních reprezentací všech prvků v `nums` v nějakém pořadí.
Poznámka: Binární reprezentace jakéhokoli čísla neobsahuje vedoucí nuly.

Příklad 1:

Vstup: `nums = [1,2,3]`
Výstup: 30
Vysvětlení: Spojením čísel v pořadí `[3, 1, 2]` získáme výsledek "11110", což je binární reprezentace čísla 30.

Příklad 2:

Vstup: `nums = [2,8,16]`
Výstup: 1296
Vysvětlení: Spojením čísel v pořadí `[2, 8, 16]` získáme výsledek "10100010000", což je binární reprezentace čísla 1296.

Omezení:

nums.length == 3
1 <= nums[i] <= 127

Máte pole celých čísel nums o velikosti 3.
Vraťte největší možné číslo, jehož binární reprezentace může být vytvořena zřetězením binárních reprezentací všech prvků v nums v libovolném pořadí.
Všimněte si, že binární reprezentace žádného čísla neobsahuje počáteční nuly.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 30
Vysvětlení:
Zřetězte čísla v pořadí [3, 1, 2] a získáte výsledek "11110", což je binární reprezentace čísla 30.

Příklad 2:

Vstup: nums = [2,8,16]
Výstup: 1296
Vysvětlení:
Zřetězte čísla v pořadí [2, 8, 16] a získáte výsledek "10100010000", což je binární reprezentace čísla 1296.

Omezení:

nums.length == 3
1 <= nums[i] <= 127

Dostanete pole celých čísel o velikosti 3.
Vraťte maximální možné číslo, jehož binární reprezentace může být vytvořena zřetězením binární reprezentace všech prvků v počtech v určitém pořadí.
Všimněte si, že binární reprezentace libovolného čísla neobsahuje úvodní nuly.

Příklad 1:

Vstup: nums = [1,2,3]
Výstup: 30
Vysvětlení:
Spojením čísel v pořadí [3, 1, 2] dostanete výsledek "11110", což je binární reprezentace 30.

Příklad 2:

Vstup: nums = [2,8,16]
Výstup: 1296
Vysvětlení:
Spojením čísel v pořadí [2, 8, 16] získáte výsledek "10100010000", což je binární reprezentace 1296.

Omezení:

nums.length == 3
1 <= nums[i] <= 127


Máte dáno celé číslo pole nums délky n a pole celých čísel queries.
Nechť gcdPairs označuje pole získané vypočtením GCD všech možných dvojic (nums[i], nums[j]), kde 0 <= i < j < n, a poté seřazením těchto hodnot ve vzestupném pořadí.
Pro každý dotaz queries[i] je třeba najít prvek na indexu queries[i] v gcdPairs.
Vrátí celé číslo pole answer, kde answer[i] je hodnota na gcdPairs[queries[i]] pro každý dotaz.
Termín gcd(a, b) označuje největší společný dělitel a a b.

Příklad 1:

Vstup: nums = [2,3,4], queries = [0,2,2]
Výstup: [1,2,2]
Vysvětlení:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Po seřazení ve vzestupném pořadí, gcdPairs = [1, 1, 2].
Odpověď je tedy [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Příklad 2:

Vstup: nums = [4,4,2,1], queries = [5,3,1,0]
Výstup: [4,2,1,1]
Vysvětlení:
gcdPairs seřazené ve vzestupném pořadí je [1, 1, 1, 2, 2, 4].

Příklad 3:

Vstup: nums = [2,2], queries = [0,0]
Výstup: [2,2]
Vysvětlení:
gcdPairs = [2].

Omezení:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Dostanete celočíselné pole num délky n a dotazy na celočíselné pole.
Nechť gcdPairs označuje pole získané výpočtem GCD všech možných párů (nums[i], nums[j]), kde 0 <= i < j < n, a následným seřazením těchto hodnot ve vzestupném pořadí.
Pro každý dotaz queries[i] musíte najít prvek v index queries[i] v gcdPairs.
Vrátí odpověď celočíselného pole, kde answer[i] je hodnota v gcdPairs[queries[i]] pro každý dotaz.
Výraz gcd(a, b) označuje největšího společného dělitele a a b.

Příklad 1:

Vstup:  nums = [2,3,4], queries = [0,2,2]
Výstup: [1,2,2]
Vysvětlení:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1] .
Po seřazení ve vzestupném pořadí je gcdPairs = [1, 1, 2].
Odpověď je tedy [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Příklad 2:

Vstup:nums = [4,4,2,1], queries = [5,3,1,0]
Výstup: [4,2,1,1]
Vysvětlení:
gcdPairs seřazené vzestupně je [1, 1, 1, 2, 2, 4].

Příklad 3:

Vstup: nums = [2,2], queries = [0,0]
Výstup: [2,2]
Vysvětlení:
gcdPairs = [2].

Omezení:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2

Je vám zadáno celočíselné pole o délce n a celočíselné pole se dotazuje.
Nechť gcdPairs označuje pole získané výpočtem GCD všech možných párů (nums[i], nums[j]), kde 0 <= i < j < n, a následným seřazením těchto hodnot ve vzestupném pořadí.
Pro každý dotaz queries[i] musíte najít element na index queries[i] v gcdPairs.
Vrátí odpověď na celočíselné pole, kde answer[i] je hodnota v gcdPairs[queries[i]] pro každý dotaz.
Termín gcd(a, b) označuje největšího společného dělitele a a b.

Příklad 1:

Vstup: nums = [2,3,4], queries = [0,2,2]
Výstup: [1,2,2]
Vysvětlení:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Po seřazení ve vzestupném pořadí je gcdPairs = [1, 1, 2].
Odpověď je tedy [gcdPairs[dotazy[0]], gcdPairs[dotazy[1]], gcdPairs[dotazy[2]]] = [1, 2, 2].

Příklad 2:

Vstup: nums = [4,4,2,1], queries = [5,3,1,0]
Výstup: [4,2,1,1]
Vysvětlení:
gcdPairs seřazené ve vzestupném pořadí je [1, 1, 1, 2, 2, 4].

Příklad 3:

Vstup: nums = [2,2], queries = [0,0]
Výstup: [2,2]
Vysvětlení:
gcdPairs = [2].

Omezení:

2 <= n == nums.length <= 10^5
1 <= nums[i] <= 5 * 10^4
1 <= queries.length <= 10^5
0 <= queries[i] < n * (n - 1) / 2


Je zadáno celočíselné pole nums.
Každý prvek pole nums nahradíte součtem jeho číslic.
Vraťte minimální prvek v nums po všech nahrazeních.

Příklad 1:

Vstup: nums = [10,12,13,14]
Výstup: 1
Vysvětlení:
Po všech výměnách se z nums stane [1, 3, 4, 5] s minimálním prvkem 1.

Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: 1
Vysvětlení:
Po všech výměnách se z nums stane [1, 2, 3, 4] s minimálním prvkem 1.

Příklad 3:

Vstup: nums = [999,19,199]
Výstup: 10
Vysvětlení:
Po všech nahrazeních se z nums stane [27, 10, 19] s minimálním prvkem 10.

Omezení:

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

Je vám dáno pole celých čísel nums.
Nahradíte každý prvek v nums součtem jeho číslic.
Vrátíte minimální prvek v nums po všech nahrazeních.

Příklad 1:

Vstup: nums = [10,12,13,14]
Výstup: 1
Vysvětlení:
nums se po všech nahrazeních stane [1, 3, 4, 5], s minimálním prvkem 1.

Příklad 2:

Vstup: nums = [1,2,3,4]
Výstup: 1
Vysvětlení:
nums se po všech nahrazeních stane [1, 2, 3, 4], s minimálním prvkem 1.

Příklad 3:

Vstup: nums = [999,19,199]
Výstup: 10
Vysvětlení:
nums se po všech nahrazeních stane [27, 10, 19], s minimálním prvkem 10.

Omezení:

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


Je zadáno pole maximumHeight, kde maximumHeight[i] označuje maximální výšku, kterou lze i^té věži přiřadit.
Vaším úkolem je přiřadit každé věži takovou výšku, aby:

Výška i^té věže je kladné celé číslo a nepřesahuje maximumHeight[i].
Žádné dvě věže nemají stejnou výšku.

Vraťte maximální možný celkový součet výšek věží. Pokud není možné výšky přiřadit, vraťte -1.

Příklad 1:

Vstup: maximumHeight = [2,3,4,3]
Výstup: 10
Vysvětlení:
Výšky můžeme přiřadit následujícím způsobem: [1, 2, 4, 3].

Příklad 2:

Vstup: maximumHeight = [15,10]
Výstup: 25
Vysvětlení:
Výšky můžeme přiřadit následujícím způsobem: [15, 10].

Příklad 3:

Vstup: maximumHeight = [2,2,1]
Výstup: -1
Vysvětlení:
Není možné přiřadit každému indexu kladnou výšku tak, aby žádné dvě věže neměly stejnou výšku.

Omezení:

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

Máš pole maximumHeight, kde maximumHeight[i] udává maximální výšku, kterou lze přiřadit i-té věži.
Tvým úkolem je přiřadit výšku každé věži tak, aby:

Výška i-té věže byla kladné celé číslo a nepřesahovala maximumHeight[i].
Žádné dvě věže neměly stejnou výšku.

Vrátit maximální možný celkový součet výšek věží. Pokud není možné přiřadit výšky, vrátit -1.

Příklad 1:

Vstup: maximumHeight = [2,3,4,3]
Výstup: 10
Vysvětlení:
Můžeme přiřadit výšky následujícím způsobem: [1, 2, 4, 3].

Příklad 2:

Vstup: maximumHeight = [15,10]
Výstup: 25
Vysvětlení:
Můžeme přiřadit výšky následujícím způsobem: [15, 10].

Příklad 3:

Vstup: maximumHeight = [2,2,1]
Výstup: -1
Vysvětlení:
Není možné přiřadit kladné výšky každému indexu tak, aby žádné dvě věže neměly stejnou výšku.

Omezení:

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

Dostanete pole maximumHeight, kde maximumHeight[i] označuje maximální výšku, kterou lze i^té věži přiřadit.
Vaším úkolem je přiřadit výšku každé věži tak, aby:

Výška i^té věže je kladné celé číslo a nepřesahuje maximumHeight[i].
Žádné dvě věže nemají stejnou výšku.

Vraťte maximální možný celkový součet výšek věží. Pokud není možné přiřadit výšky, vraťte -1.

Příklad 1:

Vstup: maximumHeight = [2,3,4,3]
Výstup: 10
Vysvětlení:
Výšky můžeme přiřadit následujícím způsobem: [1, 2, 4, 3].

Příklad 2:

Vstup: maximumHeight = [15,10]
Výstup: 25
Vysvětlení:
Výšky můžeme přiřadit následujícím způsobem: [15, 10].

Příklad 3:

Vstup: maximumHeight = [2,2,1]
Výstup: -1
Vysvětlení:
Je nemožné přiřadit kladné výšky každému indexu, aby žádné dvě věže neměly stejnou výšku.

Omezení:

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


Jsou vám dány dva řetězce: word1 a word2.
Řetězec x se nazývá téměř rovný y, pokud můžete změnit maximálně jeden znak v x tak, aby byl identický s y.
Posloupnost indexů seq se nazývá platná, pokud:

Indexy jsou seřazeny vzestupně.
Zřetězení znaků v těchto indexech ve word1 ve stejném pořadí vede k řetězci, který je téměř roven word2.

Vrátí pole velikosti word2.length představující lexikograficky nejmenší platnou sekvenci indexů. Pokud žádná taková posloupnost indexů neexistuje, vrátí prázdné pole.
Všimněte si, že odpověď musí reprezentovat lexikograficky nejmenší pole, nikoli odpovídající řetězec tvořený těmito indexy.

Příklad 1:

Vstup: word1 = "vbcca", word2 = "abc"
Výstup: [0,1,2]
Vysvětlení:
Lexikograficky nejmenší platná posloupnost indexů je [0, 1, 2]:

Změňte word1[0] na 'a'.
word1[1] je již 'b'.
word1[2] je již 'c'.

Příklad 2:

Vstup: word1 = "bacdc", word2 = "abc"
Výstup: [1,2,4]
Vysvětlení:
Lexikograficky nejmenší platná posloupnost indexů je [1, 2, 4]:

word1[1] je již 'a'.
Změňte word1[2] na 'b'.
word1[4] je již 'c'.

Příklad 3:

Vstup: word1 = "aaaaaa", word2 = "aaabc"
Výstup: []
Vysvětlení:
Neexistuje žádná platná posloupnost indexů.

Příklad 4:

Vstup: word1 = "abc", word2 = "ab"
Výstup: [0,1]

Omezení:

1 <= word2.length < word1.length <= 3 * 10^5
word1 a word2 se skládají pouze z malých anglických písmen.

Jsou vám dány dva řetězce slovo1 a slovo2.
Řetězec x se nazývá téměř rovný y, pokud můžete změnit maximálně jeden znak v x, aby byl shodný s y.
Posloupnost indexů seq se nazývá platná, pokud:

Indexy jsou seřazeny vzestupně.
Zřetězením znaků na těchto indexech ve word1 ve stejném pořadí vznikne řetězec, který je téměř roven slovu2.

Vrátí pole délky slovo2.length představující lexikograficky nejmenší platnou posloupnost indexů. Pokud žádná taková sekvence indexů neexistuje, vraťte prázdné pole.
Všimněte si, že odpověď musí být lexikograficky nejmenší pole, nikoli odpovídající řetězec tvořený těmito indexy.

Příklad 1:

Vstup: slovo1 = "vbcca", slovo2 = "abc"
Výstup: [0,1,2]
Vysvětlení:
Lexikograficky nejmenší platná posloupnost indexů je [0, 1, 2]:

Změňte slovo1[0] na „a“.
slovo1[1] je již 'b'.
slovo1[2] je již 'c'.

Příklad 2:

Vstup: slovo1 = "bacdc", slovo2 = "abc"
Výstup: [1,2,4]
Vysvětlení:
Lexikograficky nejmenší platná posloupnost indexů je [1, 2, 4]:

slovo1[1] je již 'a'.
Změňte slovo1[2] na „b“.
slovo1[4] je již 'c'.

Příklad 3:

Vstup: slovo1 = "aaaaaa", slovo2 = "aaabc"
Výstup: []
Vysvětlení:
Neexistuje žádná platná posloupnost indexů.

Příklad 4:

Vstup: slovo1 = "abc", slovo2 = "ab"
Výstup: [0,1]

Omezení:

1 <= slovo2.length < slovo1.length <= 3 * 10^5
slovo1 a slovo2 se skládají pouze z malých anglických písmen.

Jsou vám dány dva řetězce slovo1 a slovo2.
Řetězec x se nazývá téměř rovný y, pokud můžete změnit maximálně jeden znak v x, aby byl shodný s y.
Posloupnost indexů seq se nazývá platná, pokud:

Indexy jsou seřazeny vzestupně.
Zřetězením znaků na těchto indexech ve word1 ve stejném pořadí vznikne řetězec, který je téměř roven slovu2.

Vrátí pole velikosti slovo2.length představující lexikograficky nejmenší platnou posloupnost indexů. Pokud žádná taková sekvence indexů neexistuje, vraťte prázdné pole.
Všimněte si, že odpověď musí představovat lexikograficky nejmenší pole, nikoli odpovídající řetězec tvořený těmito indexy.

Příklad 1:

Vstup: slovo1 = "vbcca", slovo2 = "abc"
Výstup: [0,1,2]
Vysvětlení:
Lexikograficky nejmenší platná posloupnost indexů je [0, 1, 2]:

Změňte slovo1[0] na „a“.
slovo1[1] je již 'b'.
slovo1[2] je již 'c'.

Příklad 2:

Vstup: slovo1 = "bacdc", slovo2 = "abc"
Výstup: [1,2,4]
Vysvětlení:
Lexikograficky nejmenší platná posloupnost indexů je [1, 2, 4]:

slovo1[1] je již 'a'.
Změňte slovo1[2] na „b“.
slovo1[4] je již 'c'.

Příklad 3:

Vstup: slovo1 = "aaaaaa", slovo2 = "aaabc"
Výstup: []
Vysvětlení:
Neexistuje žádná platná posloupnost indexů.

Příklad 4:

Vstup: slovo1 = "abc", slovo2 = "ab"
Výstup: [0,1]

Omezení:

1 <= slovo2.length < slovo1.length <= 3 * 10^5
slovo1 a slovo2 se skládají pouze z malých anglických písmen.


Máte dva řetězce s a pattern.
Řetězec x je nazýván téměř shodným s y, pokud můžete změnit nanejvýš jeden znak v x, aby byl identický s y.
Vraťte nejmenší počáteční index podřetězce v s, který je téměř shodný s pattern. Pokud takový index neexistuje, vraťte -1.
Podřetězec je souvislá neprázdná sekvence znaků v rámci řetězce.

Příklad 1:

Vstup: s = "abcdefg", pattern = "bcdffg"
Výstup: 1
Vysvětlení:
Podřetězec s[1..6] == "bcdefg" může být převeden na "bcdffg" změnou s[4] na "f".

Příklad 2:

Vstup: s = "ababbababa", pattern = "bacaba"
Výstup: 4
Vysvětlení:
Podřetězec s[4..9] == "bababa" může být převeden na "bacaba" změnou s[6] na "c".

Příklad 3:

Vstup: s = "abcd", pattern = "dba"
Výstup: -1

Příklad 4:

Vstup: s = "dde", pattern = "d"
Výstup: 0

Omezení:

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

Doplněk: Dokázali byste vyřešit problém, pokud může být změněno nanejvýš k po sobě jdoucích znaků?

Jsou vám dány dva řetězce a vzor.
Řetězec x se nazývá téměř rovný y, pokud můžete změnit maximálně jeden znak v x tak, aby byl identický s y.
Vrátí nejmenší počáteční index podřetězce v s, který je téměř roven vzoru. Pokud žádný takový index neexistuje, vrátí hodnotu -1.
Podřetězec je souvislá neprázdná posloupnost znaků v řetězci.

Příklad 1:

Vstup: s = "abcdefg", pattern = "bcdffg"
Výstup: 1
Vysvětlení:
Podřetězec s[1..6] == "bcdefg" lze převést na "bcdffg" změnou s[4] na "f".

Příklad 2:

Vstup: s = "ababbababa", pattern = "bacaba"
Výstup: 4
Vysvětlení:
Podřetězec s[4..9] == "bababa" lze převést na "bacaba" změnou s[6] na "c".

Příklad 3:

Vstup: s = "abcd", pattern = "dba"
Výstup: -1

Příklad 4:

Vstup: s = "dde", pattern = "d"
Výstup: 0

Omezení:

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

Pokračování: Mohli byste problém vyřešit, pokud by bylo možné změnit maximálně k po sobě jdoucích znaků?

Máte k dispozici dva řetězce s a vzor.
Řetězec x se nazývá téměř shodný s y, pokud můžete změnit nejvýše jeden znak v x tak, aby byl shodný s y.
Vraťte nejmenší počáteční index podřetězce v s, který se téměř rovná vzoru. Pokud žádný takový index neexistuje, vrátí se -1.
Podřetězec je souvislá neprázdná posloupnost znaků v řetězci.

Příklad 1:

Vstup: s = „abcdefg“, vzor = „bcdffg“
Výstup: 1
Vysvětlení:
Podřetězec s[1..6] == „bcdefg“ lze převést na „bcdffg“ změnou s[4] na „f“.

Příklad 2:

Vstup: s = „ababbababa“, vzor = „bacaba“
Výstup: 4
Vysvětlení:
Podřetězec s[4..9] == „bababa“ lze převést na „bacaba“ změnou s[6] na „c“.

Příklad 3:

Vstup: s = „abcd“, vzor = „dba“
Výstup: -1

Příklad 4:

Vstup: s = „dde“, vzor = „d“
Výstup: 0

Omezení:

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

Doplnění: Dokázali byste vyřešit problém, pokud lze změnit nejvýše k po sobě jdoucích znaků?