Дат вам је бинарни стринг s и цео број k.
Бинарни стринг задовољава k-ограничење ако је испуњен један од следећих услова:

Број нула у низу је највише k.
Број јединица у низу је највише k.

Вратите цео број који представља број поднизова стринга s који задовољавају k-ограничење.

Пример 1:

Улаз: s = "10101", k = 1
Излаз: 12
Објашњење:
Сваки подниз од s осим поднизова "1010", "10101" и "0101" задовољава k-ограничење.

Пример 2:

Улаз: s = "1010101", k = 2
Излаз: 25
Објашњење:
Сваки подниз од s осим поднизова дужине веће од 5 задовољава k-ограничење.

Пример 3:

Улаз: s = "11111", k = 1
Излаз: 15
Објашњење:
Сви поднизови од s задовољавају k-ограничење.

Ограничења:

1 <= s.length <= 50
1 <= k <= s.length
s[i] је или '0' или '1'.

Дат вам је бинарни низ s и цео број k.
Бинарни низ задовољава k-ограничење ако је испуњен било који од следећих услова:

Број 0 у низу је највише k.
Број 1 у низу је највише k.
Вратите цео број који представља број поднизава низа s који задовољавају k-ограничење.

Пример 1:

Улаз: s = "10101", k = 1
Излаз: 12
Објашњење:
Сваки подниз од s осим поднизова "1010", "10101" и "0101" задовољава k-ограничење.

Пример 2:

Улаз: s = "1010101", k = 2
Излаз: 25
Објашњење:
Сваки подниз од s осим поднизова дужине веће од 5 задовољава k-ограничење.

Пример 3:

Улаз: s = "11111", k = 1
Излаз: 15
Објашњење:
Сви поднизови од s задовољавају k-ограничење.

Ограничења:

1 <= s.length <= 50
1 <= k <= s.length
s[i] је или '0' или '1'.

Дат вам је бинарни стринг с и цео број k.
Бинарни стринг задовољава к-ограничење ако важи било који од следећих услова:

Број 0 у низу је највише k.
Број 1 у низу је највише k.

Врати цео број који означава број поднизова од с који задовољавају k-ограничење.

Пример 1:

Улаз: s = "10101", k = 1
Излаз: 12
Објашњење:
Сваки подниз од с осим поднизова "1010", "10101" и "0101" задовољава к-ограничење.

Пример 2:

Улаз: s = "1010101", k = 2
Излаз: 25
Објашњење:
Сваки подниз од с осим подниза дужине веће од 5 задовољава к-ограничење.

Пример 3:

Улаз: s = "11111", k = 1
Излаз: 15
Објашњење:
Сви поднизови од с задовољавају k-ограничење.

Ограничења:

1 <= s.length <= 50
1 <= k <= s.length
s[i] је или '0' или '1'.


Дат вам је два низа целих бројева energyDrinkA и energyDrinkB исте дужине n, које представљају подстицаје за енергију по сату које пружају два различита енергетска напитака, A и B, респективно.
Желите да максимизирате укупни подстицај енергије тако што ћете пити један енергетски напитака сваког сата. Међутим, ако желите да прелазите са једног енергетског напитака на други, потребно је да сачекате један сат да очистите свој организам (што значи да нећете добити никакав подстицај енергије у том сату).
Вратите максимални укупни подстицај енергије који можете добити у наредних n сати.
Напомена: Можете започети конзумирање било ког од ова два енергетска напитака.

Пример 1:

Унос: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Излаз: 5
Објашњење:
Да бисте добили енергетски подстицај од 5, пијте само енергетско пиће A (или само B).

Пример 2:

Унос: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Излаз: 7
Објашњење:
Да бисте добили енергетски подстицај од 7:

Пијте енергетско пиће A први сат.
Пребаците се на енергетско пиће B и губимо енергетски подстицај другог сата.
Добијте енергетски подстицај пића B трећег сата.

Ограничења:

n == energyDrinkA.length == energyDrinkB.length
3 <= n <= 10^5
1 <= energyDrinkA[i], energyDrinkB[i] <= 10^5

Дати су вам два низа целих бројева, energyDrinkA и energyDrinkB, исте дужине n, од стране футуристичког спортског научника. Ови низови представљају појачања енергије по сату која пружају два различита енергетска напитака, A и B, редом.

Желите да максимизирате своје укупно појачање енергије пијући један енергетски напитак по сату. Међутим, ако желите да пређете са једног енергетског напитка на други, морате да сачекате један сат да бисте очистили свој организам (што значи да у том сату нећете добити никакво појачање енергије).

Вратите највеће укупно појачање енергије које можете добити у наредних n сати.

Напомена: Можете започети конзумирање било којег од ова два енергетска напитака.

Пример 1:

Унос: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Излаз: 5
Објашњење:
Да бисте добили енергетски подстицај од 5, пијте само енергетско пиће A (или само B).

Пример 2:

Унос: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Излаз: 7
Објашњење:
Да бисте добили појачање енергије од 7:

Пијте енергетски напитак A прву сатницу.
Пребаците се на енергетски напитак B и изгубићемо појачање енергије у другој сатници.
Добије се појачање енергије од напитка B у трећој сатници.

Ограничења:

n == energyDrinkA.length == energyDrinkB.length
3 <= n <= 10^5
1 <= energyDrinkA[i], energyDrinkB[i] <= 10^5

Футуристички спортски научник вам даје два низа целих бројева енергиДринкА и енергиДринкБ исте дужине н. Ови низови представљају повећање енергије по сату које обезбеђују два различита енергетска пића, А и Б, респективно.
Желите да максимизирате свој укупни пораст енергије испијањем једног енергетског пића на сат. Међутим, ако желите да пређете са конзумирања једног енергетског пића на други, потребно је да сачекате један сат да бисте очистили свој систем (што значи да нећете добити никакво повећање енергије за тај сат).
Вратите максимално повећање укупне енергије које можете добити у наредних н сати.
Имајте на уму да можете почети да конзумирате било које од два енергетска пића.

Пример 1:

Улаз: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Излаз: 5
Објашњење:
Да бисте добили повећање енергије од 5, пијте само енергетски напитак А (или само Б).

Пример 2:

Улаз: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Излаз: 7
Објашњење:
Да бисте добили повећање енергије од 7:

Први сат попијте енергетски напитак А.
Пребаците се на енергетски напитак Б и губимо енергију за други сат.
Добијте повећање енергије од пића Б у трећем сату.

Ограничења:

n == energyDrinkA.length == energyDrinkB.length
3 <= n <= 10^5
1 <= energyDrinkA[i], energyDrinkB[i] <= 10^5


Дати су два позитивна цела броја n и k.
Цели број x се зове k-палиндром ако:

- x је палиндром.
- x је делљив са k.

Вратите највећи број који има n цифара (као низ) и који је k-палиндром.
Напомена: Цео број не сме имати водеће нуле.

Пример 1:

Улаз: n = 3, k = 5
Излаз: "595"
Објашњење:
595 је највећи k-палиндром са 3 цифре.

Пример 2:

Улаз: n = 1, k = 4
Излаз: "8"
Објашњење:
4 и 8 су једини k-палиндроми са 1 цифром.

Пример 3:

Улаз: n = 5, k = 6
Излаз: "89898"

Ограничења:

1 <= n <= 10^5
1 <= k <= 9

Датa су два позитивна цела броја n и k.
Цели број x се назива k-палиндромом ако:

x је палиндром.
x је дељив са k.

Вратите највећи број са n цифара (као стринг) који је k-палиндром.
Напомена: Број не сме имати водеће нуле.

Пример 1:

Улаз: n = 3, k = 5
Излаз: "595"
Објашњење:
595 је највећи k-палиндром са 3 цифре.

Пример 2:

Улаз: n = 1, k = 4
Излаз: "8"
Објашњење:
4 и 8 су једини k-палиндроми са 1 цифром.

Пример 3:

Улаз: n = 5, k = 6
Излаз: "89898"

Ограничења:

1 <= n <= 10^5
1 <= k <= 9

Dati su vam dva pozitivna cela broja, **n** i **k**.
Ceo broj **x** naziva se **k-palindromskim** ako:

- **x** je palindrom.
- **x** je deljiv sa **k**.

Vratite najveći ceo broj sa **n** cifara (kao string) koji je **k-palindromski**.
Napomena: Broj ne sme imati vodeće nule.

Primer 1:

Ulaz:
`n = 3, k = 5`
Izlaz:
`"595"`

**Objašnjenje**
595 je najveći k-palindromski broj sa 3 cifre.

Primer 2:**

**Ulaz:**
`n = 1, k = 4`
*Izlaz:*
`"8"`

Objašnjenje:
4 i 8 su jedini k-palindromski brojevi sa 1 cifrom.

---

Primer 3:**

**Ulaz:**
`n = 5, k = 6`
**Izlaz:**
`"89898"`

Ograničenja:

- \(1 \leq n \leq 10^5\)
- \(1 \leq k \leq 9\)


Дат вам је низ целих бројева nums, цео број k, и цео број multiplier. Треба да изведете k операција на nums. У свакој операцији:

Пронађите минималну вредност x у nums. Ако има више истих минималних вредности, изаберите ону која се прва јавља. Замените изабрану минималну вредност x са x * multiplier.

Вратите низ целих бројева који означава коначно стање nums након извршавања свих k операција.

Пример 1:

Улаз: nums = [2,1,3,5,6], k = 5, multiplier = 2 Излаз: [8,4,6,5,6] Објашњење:

Операција
Резултат

Након операције 1
[2, 2, 3, 5, 6]

Након операције 2
[4, 2, 3, 5, 6]

Након операције 3
[4, 4, 3, 5, 6]

Након операције 4
[4, 4, 6, 5, 6]

Након операције 5
[8, 4, 6, 5, 6]

Пример 2:

Улаз: nums = [1,2], k = 3, multiplier = 4 Излаз: [16,8] Објашњење:

Операција
Резултат

Након операције 1
[4, 2]

Након операције 2
[4, 8]

Након операције 3
[16, 8]

Ограничења:

1 <= nums.length <= 100 1 <= nums[i] <= 100 1 <= k <= 10 1 <= multiplier <= 5

Дат вам је низ целих бројева nums, цео број k и цео број multiplier.
Потребно је да извршите k операција на низу `nums`. У свакој операцији:

1. Нађите минималну вредност x у низу. Ако постоји више понављања минималне вредности, изаберите ону која се појављује прва.
2. Замена изабране минималне вредности s са x * multiplier.

Вратите целобројни низ који приказује коначни статус низа nums након што су извршене све k операције.

Пример 1:

Улаз: nums = [2,1,3,5,6], k = 5, multiplier = 2 Излаз: [8,4,6,5,6] Објашњење:

Операција
Резултат

Након операције 1
[2, 2, 3, 5, 6]

Након операције 2
[4, 2, 3, 5, 6]

Након операције 3
[4, 4, 3, 5, 6]

Након операције 4
[4, 4, 6, 5, 6]

Након операције 5
[8, 4, 6, 5, 6]

Пример 2:

Улаз: nums = [1,2], k = 3, multiplier = 4 Излаз: [16,8] Објашњење:

Операција
Резултат

Након операције 1
[4, 2]

Након операције 2
[4, 8]

Након операције 3
[16, 8]

Ограничења:

1 <= nums.length <= 100 1 <= nums[i] <= 100 1 <= k <= 10 1 <= multiplier <= 5


Дат је низ nums који се састоји од позитивних целих бројева.
У овом проблему кажемо да су два цела броја x и y скоро једнака ако оба броја могу постати једнака након извршења следеће операције највише једном:

Одаберите x или y и замените било која два цифре у изабраном броју.

Вратите број индекса i и j у nums где је i < j тако да су nums[i] и nums[j] скоро једнаки.
Напомена да је дозвољено да цели број има водеће нуле након извршења операције.

Пример 1:

Улаз: nums = [3,12,30,17,21]
Излаз: 2
Објашњење:
Скоро једнаки парови елемената су:

3 и 30. Заменом 3 и 0 у 30 добијамо 3.
12 и 21. Заменом 1 и 2 у 12 добијамо 21.

Пример 2:

Улаз: nums = [1,1,1,1,1]
Излаз: 10
Објашњење:
Свака два елемента у низу су скоро једнака.

Пример 3:

Улаз: nums = [123,231]
Излаз: 0
Објашњење:
Не можемо заменити било која два цифре у 123 или 231 да би постигли други.

Ограничења:

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

Дат је низ nums који се састоји од позитивних целих бројева.
У овом проблему кажемо да су два цела броја x и y скоро једнака ако оба броја могу постати једнака након извршења следеће операције највише једном:

Изаберите или x или y и замените било која два цифре у изабраном броју.

Вратите број индекса i и j у nums где је i < j тако да су nums[i] и nums[j] скоро једнаки.
Напомена да је дозвољено да цели број има водеће нуле након извршења операције.

Пример 1:

Улаз: nums = [3,12,30,17,21]
Излаз: 2
Објашњење:
Скоро једнаки парови елемената су:

3 и 30. Заменом 3 и 0 у 30 добијате 3.
12 и 21. Заменом 1 и 2 у 12 добијате 21.

Пример 2:

Улаз: nums = [1,1,1,1,1]
Излаз: 10
Објашњење:
Свака два елемента у низу су скоро једнака.

Пример 3:

Улаз: nums = [123,231]
Излаз: 0
Објашњење:
Не можемо заменити било која два цифре у 123 или 231 да би постигли други.

Ограничења:

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


Дати су вам два низа, coordinate1 и coordinate2, који представљају координате поља на шаховској табли 8 x 8.
Испод је шаховска табла за референцу.

Вратите true ако ова два поља имају исту боју, а false у супротном.
Координата ће увек представљати валидно поље на шаховској табли. Координата ће увек имати слово прво (које указује на колону), а број други (који указује на ред).

Пример 1:

Улаз: coordinate1 = "a1", coordinate2 = "c3"
Излаз: true
Објашњење:
Оба квадрата су црна.

Пример 2:

Улаз: coordinate1 = "a1", coordinate2 = "h3"
Излаз: false
Објашњење:
Квадрат "a1" је црн, а "h3" је бео.

Ограничења:

coordinate1.length == coordinate2.length == 2
'a' <= coordinate1[0], coordinate2[0] <= 'h'
'1' <= coordinate1[1], coordinate2[1] <= '8'

Дати су вам два низа, coordinate1 и coordinate2, који представљају координате поља на шаховској табли 8 x 8.
Испод се налази шаховска табла за референцу.

Вратите true ако ова два поља имају исту боју, а false у супротном.
Координата ће увек представљати валидно поље на шаховској табли. Координата ће увек прво имати слово (које указује на њену колону), а затим број (који указује на њен ред).

Пример 1:

Улаз: coordinate1 = "a1", coordinate2 = "c3"
Излаз: true
Објашњење:
Оба квадрата су црна.

Пример 2:

Улаз: coordinate1 = "a1", coordinate2 = "h3"
Излаз: false
Објашњење:
Квадрат "a1" је црн, а "h3" је бео.

Ограничења:

coordinate1.length == coordinate2.length == 2
'a' <= coordinate1[0], coordinate2[0] <= 'h'
'1' <= coordinate1[1], coordinate2[1] <= '8'

Дата су вам два низа, coordinate1 и coordinate2, који представљају координате поља на шаховској табли димензија 8 x 8.
Испод је шаховска табла за референцу.
Вратите true ако ова два поља имају исту боју, у супротном вратите false.
Координате ће увек представљати важеће поље на шаховској табли. Координате ће увек имати слово прво (што означава колону) и број друго (што означава ред).
Пример 1:
Пример 1:
Улаз: coordinate1 = "a1", coordinate2 = "c3"
Излаз: true
Објашњење:
Оба поља су црна.
Пример 2:
Улаз: coordinate1 = "a1", coordinate2 = "h3"
Излаз: false
Објашњење:
Поље "a1" је црно, а "h3" је бело.

Ограничења:
coordinate1.length == coordinate2.length == 2
'a' <= coordinate1[0], coordinate2[0] <= 'h'
'1' <= coordinate1[1], coordinate2[1] <= '8'


Постоји бесконачна 2D раван.
Дат вам је позитиван цео број k. Такође вам је дат 2D низ queries, који садржи следеће упите:

queries[i] = [x, y]: Поставите препреку на координати (x, y) у равни. Гарантовано је да на овој координати нема препреке када се овај упит направи.

Након сваког упита, треба пронаћи раздаљину до k^те најближе препреке од порекла.
Врати низ целих бројева results где results[i] означава k^ту најближу препреку након упита i, или results[i] == -1 ако има мање од k препрека.
Напомиње се да у почетку нема препрека нигде.
Раздаљина препреке на координати (x, y) од порекла дата је са |x| + |y|.

Пример 1:

Улаз: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Излаз: [-1,7,5,3]
Објашњење:

У почетку нема препрека.
Након queries[0], има мање од 2 препреке.
Након queries[1], постоје препреке на раздаљинама 3 и 7.
Након queries[2], постоје препреке на раздаљинама 3, 5, и 7.
Након queries[3], постоје препреке на раздаљинама 3, 3, 5, и 7.

Пример 2:

Улаз: queries = [[5,5],[4,4],[3,3]], k = 1
Излаз: [10,8,6]
Објашњење:

Након queries[0], постоји препрека на раздаљини 10.
Након queries[1], постоје препреке на раздаљинама 8 и 10.
Након queries[2], постоје препреке на раздаљинама 6, 8, и 10.

Ограничења:

1 <= queries.length <= 2 * 10^5
Сви queries[i] су јединствени.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

Постоји бесконачна дводимензионална раван.
Дат је позитиван цео број k. Такође је дат низ queries који садржи следеће упите:

queries[i] = [x, y]: Поставите препреку на координати (x, y) у равни. Гарантовано је да на овој координати нема препреке када се овај упит направи.

Након сваког упита, треба пронаћи раздаљину до k^те најближе препреке од порекла.
Врати низ целих бројева results где results[i] означава k^ту најближу препреку након упита i, или results[i] == -1 ако има мање од k препрека.
Напомиње се да у почетку нема препрека нигде.
Раздаљина препреке на координати (x, y) од порекла дата је са |x| + |y|.

Пример 1:

Улаз: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Излаз: [-1,7,5,3]
Објашњење:

У почетку нема препрека.
Након queries[0], има мање од 2 препреке.
Након queries[1], постоје препреке на раздаљинама 3 и 7.
Након queries[2], постоје препреке на раздаљинама 3, 5, и 7.
Након queries[3], постоје препреке на раздаљинама 3, 3, 5, и 7.

Пример 2:

Улаз: queries = [[5,5],[4,4],[3,3]], k = 1
Излаз: [10,8,6]
Објашњење:

Након queries[0], постоји препрека на раздаљини 10.
Након queries[1], постоје препреке на раздаљинама 8 и 10.
Након queries[2], постоје препреке на раздаљинама 6, 8, и 10.

Ограничења:

1 <= queries.length <= 2 * 10^5
Сви queries[i] су јединствени.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

Дат је бесконачан 2D план.
Дат вам је позитиван цео број k. Такође вам је дат 2D низ upita који садржи следеће upite:

queries[i] = [x, y]: Поставите препреку на координату (x, y) на плочи. Гарантовано је да на овој координати не постоји препрека када се овај упит изврши.

Након сваког упита, морате да пронађете растојање k^th најближе препреке од порекла.
Вратите целобројни низ резултата где results[i] означава k^th најближу препреку након упита i, или results[i] == -1 ако има мање од k препрека.
Напомена: Почиње са тим да на почетку нигде нема препрека.
Растојање препреке на координатама (x, y) од порекла је дата са |x| + |y|.

Пример 1:

Улаз: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Излаз: [-1,7,5,3]
Објашњење:

У почетку нема препрека.
Након queries[0], има мање од 2 препреке.
Након queries[1], постоје препреке на раздаљинама 3 и 7.
Након queries[2], постоје препреке на раздаљинама 3, 5, и 7.
Након queries[3], постоје препреке на раздаљинама 3, 3, 5, и 7.

Пример 2:

Улаз: queries = [[5,5],[4,4],[3,3]], k = 1
Излаз: [10,8,6]
Објашњење:

Након queries[0], постоји препрека на раздаљини 10.
Након queries[1], постоје препреке на раздаљинама 8 и 10.
Након queries[2], постоје препреке на раздаљинама 6, 8, и 10.

Ограничења:

1 <= queries.length <= 2 * 10^5
Сви queries[i] су јединствени.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5


Дат вам је 2Д матрица grid која се састоји од позитивних целих бројева.
Морате изабрати једну или више ћелија из матрице тако да су испуњени следећи услови:

- Нема две изабране ћелије које су у истом реду матрице.
- Вредности у скупу изабраних ћелија су јединствене.

Ваш резултат ће бити збир вредности изабраних ћелија.
Вратите максималан резултат који можете постићи.

Пример 1:

Улаз: grid = [[1,2,3],[4,3,2],[1,1,1]]
Излаз: 8
Објашњење:

Можемо одабрати ћелије са вредностима 1, 3, и 4 које су обојене изнад.

Пример 2:

Улаз: grid = [[8,7,6],[8,3,2]]
Излаз: 15
Објашњење:

Можемо одабрати ћелије са вредностима 7 и 8 које су обојене изнад.

Ограничења:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100

Добићете 2D матричну мрежу која се састоји од позитивних целих бројева.
Морате да изаберете једну или више ћелија из матрице тако да су испуњени следећи услови:

Не постоје две изабране ћелије у истом реду матрице.
Вредности у скупу изабраних ћелија су јединствене.

Ваш резултат ће бити збир вредности изабраних ћелија.
Вратите максималан резултат који можете постићи.

Пример 1:

Улаз: grid = [[1,2,3],[4,3,2],[1,1,1]]
Излаз: 8
Објашњење:

Можемо изабрати ћелије са вредностима 1, 3 и 4 које су обојене изнад.

Пример 2:

Улаз: grid = [[8,7,6],[8,3,2]]
Излаз: 15
Објашњење:

Можемо изабрати ћелије са вредностима 7 и 8 које су обојене изнад.

Ограничења:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100

Датa вам је 2D Матрица grid састављена од позитивних целих бројева.
Треба да одаберете једну или више ћелија из матрице тако да су задовољени следећи услови:

Ниједне две одабране ћелије нису у истом реду матрице.
Вредности у сету одабраних ћелија су јединствене.

Ваш резултат ће бити збир вредности одабраних ћелија.
Вратите максималан резултат који можете постићи.

Пример 1:

Улаз: grid = [[1,2,3],[4,3,2],[1,1,1]]
Излаз: 8
Објашњење:

Можемо одабрати ћелије са вредностима 1, 3, и 4 које су обојене изнад.

Пример 2:

Улаз: grid = [[8,7,6],[8,3,2]]
Излаз: 15
Објашњење:

Можемо одабрати ћелије са вредностима 7 и 8 које су обојене изнад.

Ограничења:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100


Дат вам је низ `nums` од `n` целих бројева и дводимензионални низ целих бројева `queries` величине `q`, где је `queries[i] = [l_i, r_i]`.
За сваки упит потребно је пронаћи максимални XOR скор било ког подниза `nums[l_i..r_i]`.
XOR скор низа `a` се налази поновљеним примењивањем следећих операција на `a` док не остане само један елемент, који је скор:

Истовремено замените `a[i]` са `a[i] XOR a[i + 1]` за све индексе `i` осим последњег.
Уклоните последњи елемент низа `a`.

Вратите низ `answer` величине `q` где је `answer[i]` одговор за упит `i`.

Пример 1:

```
Улаз: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Излаз: [12,60,60]
Објашњење:
У првом упиту, `nums[0..2]` има 6 поднизова [2], [8], [4], [2, 8], [8, 4], и [2, 8, 4] сваки са одговарајућим XOR скором 2, 8, 4, 10, 12 и 6. Одговор за упит је 12, највећи од свих XOR скорова.
У другом упиту, подниз од `nums[1..4]` са највећим XOR скором је `nums[1..4]` са скором 60.
У трећем упиту, подниз од `nums[0..5]` са највећим XOR скором је `nums[1..4]` са скором 60.
```

Пример 2:

```
Улаз: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Излаз: [7,14,11,14,5]
Објашњење:
```

| Индекс | nums[l_i..r_i] | Подниз са максималним XOR скором | Максимални XOR скор подниза |
|--------|---------------|--------------------------------|-----------------------------|
|   0    | [0, 7, 3, 2]  | [7]                           | 7                           |
|   1    | [7, 3, 2, 8, 5] | [7, 3, 2, 8]                 | 14                          |
|   2    | [3, 2, 8]     | [3, 2, 8]                     | 11                          |
|   3    | [3, 2, 8, 5, 1] | [2, 8, 5, 1]                 | 14                          |
|   4    | [5, 1]        | [5]                           | 5                           |

Constraints:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1

Дати су вам низ целих бројева nums дужине n и 2D низ целих бројева queries величине q, где је queries[i] = [l_i, r_i].
За сваки упит, морате наћи максималну XOR вредност било ког подниза из nums[l_i..r_i].
XOR вредност низа a се добија тако што се неколико пута примењују следеће операције на a, тако да на крају остане само један елемент, што је резултат:

Истовремено замените a[i] са a[i] XOR a[i + 1] за све индексе i, осим последњег.
Уклоните последњи елемент низа.

Вратите низ answer дужине q где је answer[i] одговор на упит i.

Пример 1:

Улаз: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Излаз: [12,60,60]
Објашњење:
У првом упиту, nums[0..2] има 6 поднизова: [2], [8], [4], [2, 8], [8, 4], и [2, 8, 4], сваки са одговарајућом XOR вредношћу: 2, 8, 4, 10, 12, и 6. Одговор за упит је 12, што је највећа XOR вредност.
У другом упиту, подниз nums[1..4] са највећом XOR вредношћу је nums[1..4] са вредношћу 60.
У трећем упиту, подниз nums[0..5] са највећом XOR вредношћу је nums[1..4] са вредношћу 60.

Пример 2:

Улаз: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Излаз: [7,14,11,14,5]
Објашњење:

Индекс
nums[l_i..r_i]
Подниз са максималном XOR вредношћу
Максимална XOR вредност подниза

0
[0, 7, 3, 2]
[7]
7

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

2
[3, 2, 8]
[3, 2, 8]
11

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

4
[5, 1]
[5]
5

Ограничења:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1.

Дат је низ целих бројева nums дужине n, и 2D низ целих бројева queries величине q, где је queries[i] = [l_i, r_i]. За сваки упит, морате пронаћи максималан XOR резултат било ког подниза низа nums[l_i..r_i]. XOR резултат низа a се налази поновним примењивањем следећих операција на a тако да остане само један елемент, који је резултат:

Истовремено замените `a[i]` са `a[i] XOR a[i + 1]` за све индексе `i` осим последњег.
Уклоните последњи елемент низа `a`.

Вратите низ `answer` величине `q` где је `answer[i]` одговор за упит `i`.

Пример 1:

```
Улаз: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Излаз: [12,60,60]
Објашњење:
У првом упиту, `nums[0..2]` има 6 поднизова [2], [8], [4], [2, 8], [8, 4], и [2, 8, 4] сваки са одговарајућим XOR скором 2, 8, 4, 10, 12 и 6. Одговор за упит је 12, највећи од свих XOR скорова.
У другом упиту, подниз од `nums[1..4]` са највећим XOR скором је `nums[1..4]` са скором 60.
У трећем упиту, подниз од `nums[0..5]` са највећим XOR скором је `nums[1..4]` са скором 60.
```

Пример 2:

```
Улаз: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Излаз: [7,14,11,14,5]
Објашњење:
```

| Индекс | nums[l_i..r_i] | Подниз са максималним XOR скором | Максимални XOR скор подниза |
|--------|---------------|--------------------------------|-----------------------------|
|   0    | [0, 7, 3, 2]  | [7]                           | 7                           |
|   1    | [7, 3, 2, 8, 5] | [7, 3, 2, 8]                 | 14                          |
|   2    | [3, 2, 8]     | [3, 2, 8]                     | 11                          |
|   3    | [3, 2, 8, 5, 1] | [2, 8, 5, 1]                 | 14                          |
|   4    | [5, 1]        | [5]                           | 5                           |

Constraints:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1


Дат вам је низ датума који представља Грегоријански календарски датум у формату yyyy-mm-dd.
Датум може бити написан у његовом бинарном представљању добијеном претварањем године, месеца и дана у њихова бинарна представљања без водећих нула и записивањем их у формату година-месец-дан.
Вратите бинарно представљање датума.

Пример 1:

Улаз: date = "2080-02-29"
Излаз: "100000100000-10-11101"
Објашњење:
100000100000, 10 и 11101 су бинарне репрезентације 2080, 02 и 29 респективно.

Пример 2:

Улаз: date = "1900-01-01"
Излаз: "11101101100-1-1"
Објашњење:
11101101100, 1 и 1 су бинарне репрезентације 1900, 1 и 1 респективно.

Ограничења:

date.length == 10
date[4] == date[7] == '-', а сви други date[i] су цифре.
Улаз је генерисан тако да date представља важећи датум у Грегоријанском календару између 1. јануара 1900. и 31. децембра 2100. (оба укључена).

Дат вам је низ датума који представља датум по грегоријанском календару у формату yyyy-mm-dd.
датум се може записати у његовој бинарној представи добијеној претварањем године, месеца и дана у њихове бинарне репрезентације без икаквих водећих нула и записивањем у формату година-месец-дан.
Врати бинарни приказ датума.

Пример 1:

Улаз: date = "2080-02-29"
Излаз: "100000100000-10-11101"
Објашњење:
100000100000, 10 и 11101 су бинарни прикази 2080, 02 и 29 респективно.

Пример 2:

Унос: date = "1900-01-01"
Излаз: "11101101100-1-1"
Објашњење:
11101101100, 1 и 1 су бинарни прикази 1900, 1 и 1.

Ограничења:

date.length == 10
date[4] == date[7] == '-', а сви остали date[i] су цифре.
Унос се генерише тако да датум представља важећи датум по грегоријанском календару између 1. јануара 1900. и 31. децембра 2100. године (укључујући оба).

Дат је стринг date који који представља датум по грегоријанском календару у формату yyyy-mm-dd.
date се може записати у бинарном облику тако што се година, месец и дан конвертују у њихове бинарне репрезентације без водећих нула, а затим се записују у формату година-месец-дан.
Вратите бинарну репрезентацију датума.

Пример 1:

Улаз: date = "2080-02-29"
Излаз: "100000100000-10-11101"
Објашњење:
100000100000, 10 и 11101 су бинарне репрезентације 2080, 02 и 29 респективно.

Пример 2:

Улаз: date = "1900-01-01"
Излаз: "11101101100-1-1"
Објашњење:
11101101100, 1 и 1 су бинарне репрезентације 1900, 1 и 1 респективно.

Ограничења:

date.length == 10
date[4] == date[7] == '-', а сви други date[i] су цифре.
Улаз је генерисан тако да date представља важећи датум у Грегоријанском календару између 1. јануара 1900. и 31. децембра 2100. (оба укључена).


Дат је низ целих бројева `start` и цео број `d`, који представљају `n` интервала [start[i], start[i] + d].
Потребно је одабрати `n` целих бројева где `i`-ти број мора припадати `i`-том интервалу. Оценa изабраних бројева дефинисана је као минимална апсолутна разлика између било која два изабрана броја.
Вратите максималну могућу оцену изабраних бројева.

Пример 1:

Инпут: start = [6,0,3], d = 2
Оутпут: 4
Објашњење:
Максимална могућа оцена се може добити одабиром бројева: 8, 0 и 4. Оцена ових изабраних бројева је min(|8 - 0|, |8 - 4|, |0 - 4|) што износи 4.

Пример 2:

Инпут: start = [2,6,13,13], d = 5
Оутпут: 5
Објашњење:
Максимална могућа оцена се може добити одабиром бројева: 2, 7, 13 и 18. Оцена ових изабраних бројева је min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) што износи 5.

Ограничења:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Дат вам је низ целих бројева start и цео број d, који представља n интервала [start[i], start[i] + d]. Тражи се да изаберете n целих бројева где i-ти број мора припадати i-тном интервалу. Резултат изабраних бројева дефинисан је као минимална апсолутна разлика између било која два изабрана броја. Вратите максимални могући резултат изабраних бројева.

Пример 1:

Инпут: start = [6,0,3], d = 2
Оутпут: 4
Објашњење:
Максимална могућа оцена се може добити одабиром бројева: 8, 0 и 4. Оцена ових изабраних бројева је min(|8 - 0|, |8 - 4|, |0 - 4|) што износи 4.

Пример 2:

Инпут: start = [2,6,13,13], d = 5
Оутпут: 5
Објашњење:
Максимална могућа оцена се може добити одабиром бројева: 2, 7, 13 и 18. Оцена ових изабраних бројева је min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) што износи 5.

Ограничења:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Дат вам је низ целих бројева start и цео број d, који представља n интервала [start[i], start[i] + d].
Задат вам је задатак да изаберете n целих бројева где i^ти целоброј мора припадати i^том интервалу. Оцену изабраних целих бројева дефинише најмања апсолутна разлика између било која два изабрана броја.
Вратите максималну могућу оцену изабраних целих бројева.

Пример 1:

Улаз: start = [6,0,3], d = 2
Излаз: 4
Објашњење:
Максимална могућа оцена се може добити одабиром бројева: 8, 0 и 4. Оцена ових изабраних бројева је min(|8 - 0|, |8 - 4|, |0 - 4|) што је једнако 4.

Пример 2:

Улаз: start = [2,6,13,13], d = 5
Излаз: 5
Објашњење:
Максимална могућа оцена се може добити одабиром бројева: 2, 7, 13 и 18. Оцена ових изабраних бројева је min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) што је једнако 5.

Ограничења:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9


Дат вам је низ целих бројева nums дужине n.
Ваш циљ је да започнете на индексу 0 и дођете до индекса n - 1. Можете скакати само на индексе који су већи од вашег тренутног индекса.
Поени за скок са индекса i на индекс `j` израчунавају се као (j - i) * nums[i].
Вратите максималан могући укупан резултат до тренутка када дођете до последњег индекса.

Пример 1:

Улаз: nums = [1,3,1,5]
Излаз: 7
Објашњење:
Прво скочите на индекс 1, а затим на последњи индекс. Коначан резултат је 1 * 1 + 2 * 3 = 7.

Пример 2:

Улаз: nums = [4,3,1,3,2]
Излаз: 16
Објашњење:
Скочите директно на последњи индекс. Коначан резултат је 4 * 4 = 16.

Ограничења:

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

Дат вам је низ целих бројева nums дужине n.
Ваш циљ је да почнете од индекса 0 и стигнете до индекса n - 1. Можете скочити само на индексе веће од тренутног индекса.
Број поена за скок са индекса i на индекс j рачуна се као (j - i) * nums[i].
Вратите максимални могући укупан број поена који можете добити до тренутка када достигнете последњи индекс.

Пример 1:

Улаз: nums = [1,3,1,5]
Излаз: 7
Објашњење:
Прво скочите на индекс 1, а затим на последњи индекс. Коначан резултат је 1 * 1 + 2 * 3 = 7.

Пример 2:

Улаз: nums = [4,3,1,3,2]
Излаз: 16
Објашњење:
Скочите директно на последњи индекс. Коначан резултат је 4 * 4 = 16.

Ограничења:

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

Добили сте цели број ниже број дужине n.
Ваш циљ је да започнете на индексу 0 и досећи индекс n - 1. Можете прескочити само на индекс веће од вашег тренутног индекса.
Резултат за скок са индекса i у Индекс j се израчунава као (j - i) * nums[i].
Вратите максимални могући укупни резултат до тренутка када дођете до последњег индекса.

Пример 1:

Улаз: nums = [1,3,1,5]
Излаз: 7
Објашњење:
Прво, скочите на индекс 1, а затим скочите на последњи индекс. Коначни резултат је 1 * 1 + 2 * 3 = 7.

Пример 2:

Улаз: nums = [4,3,1,3,2]
Излаз: 16
Објашњење:
Скочите директно на последњи индекс. Коначни резултат је 4 * 4 = 16.

Ограничења:

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


На шаховској табли 50 x 50 налази се један коњ и неки пиони. Дата су вам два цела броја kx и ky где (kx, ky) означава позицију коња, и дводимензионални низ positions где positions[i] = [x_i, y_i] означава позицију пионира на табли.

Алиса и Боб играју игру на потезе, где Алиса игра прва. У потезу сваког играча:

Играч бира пион који још увек постоји на табли и заробљава га коњем у најмање могућих потеза. Имајте на уму да играч може изабрати било који пион, то можда не мора бити онај који се може заробити у најмање потеза. У процесу заробљавања изабраног пиона, коњ може проћи поред других пиона без да их зароби. Само изабрани пион може бити заробљен у том потезу.

Алиса покушава да максимизира збир броја потеза који су играчи направили док не нестане свих пиона на табли, док Боб покушава да их минимизира. Врати максималан укупан број потеза који су направљени током игре који Алиса може постићи, под претпоставком да оба играча играју оптимално. Имајте на уму да у једном потезу, шаховски коњ има осам могућих позиција на које може да се помера, као што је илустровано испод. Сваки потез је две ћелије у кардиналном смеру, затим једна ћелија у ортогоналном смеру.

Пример 1:

Улаз: kx = 1, ky = 1, positions = [[0,0]]
Излаз: 4
Објашњење:

Коњ прави 4 потеза да дође до пиона на (0, 0).

Пример 2:

Улаз: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Излаз: 8
Објашњење:

Алиса бира пиона на (2, 2) и заробљава га у два потеза: (0, 2) -> (1, 4) -> (2, 2).
Боб бира пиона на (3, 3) и заробљава га у два потеза: (2, 2) -> (4, 1) -> (3, 3).
Алиса бира пиона на (1, 1) и заробљава га у четири потеза: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Пример 3:

Улаз: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Излаз: 3
Објашњење:

Алиса бира пиона на (2, 4) и заробљава га у два потеза: (0, 0) -> (1, 2) -> (2, 4). Имајте на уму да пион на (1, 2) није заробљен.
Боб бира пиона на (1, 2) и заробљава га у један потез: (2, 4) -> (1, 2).

Ограничења:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Све positions[i] су јединствене.
Улазни подаци су генерисани тако да positions[i] != [kx, ky] за све 0 <= i < positions.length.

Дат вам је шаховска табла 50 x 50 са једним коњем и неким пешацима на њој. Дати су вам два цела броја kx и ky где (kx, ky) означава позицију коња, и 2D низ pоложај где positions[i] = [x_i, y_i] означава позицију пешака на шаховској табли.

Алисе и Боб играју игру наизменичним редоследом, где Алисе иде прва. У сваком потезу:

Играч одабира једног пешака који још увек постоји на табли и хвата га коњем у најмање могућих потеза. Напомена: Играч може одабрати било ког пешака, он није обавезан да изабере оног који може бити ухваћен у најмање потеза.
Током хватања одабраног пешака, коњ може проћи поред других пешака без да их ухвати. Само одабрани пешак може бити ухваћен у овом потезу.

Алисе покушава да максимизује збир броја потеза које оба играча направе док на табли више нема пешака, док Боб покушава да их минимизује.
Вратите максималан укупан број потеза који Алиса може постићи током игре, претпостављајући да оба играча играју оптимално.
Напомена: У једном потезу, шаховски коњ има осам могућих позиција на које може да се помери, као што је приказано у наставку. Сваки потез подразумева да коњ направи два корака у једном кардиналном правцу, а затим један корак у ортогоналном правцу.

Пример 1:

Улаз: kx = 1, ky = 1, positions = [[0,0]]
Излаз: 4
Објашњење:

Коњ прави 4 потеза да дође до пиона на (0, 0).

Пример 2:

Улаз: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Излаз: 8
Објашњење:

Алисе бира пиона на (2, 2) и заробљава га у два потеза: (0, 2) -> (1, 4) -> (2, 2).
Боб бира пиона на (3, 3) и заробљава га у два потеза: (2, 2) -> (4, 1) -> (3, 3).
Алисе бира пиона на (1, 1) и заробљава га у четири потеза: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Пример 3:

Улаз: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Излаз: 3
Објашњење:

Алисе бира пиона на (2, 4) и заробљава га у два потеза: (0, 0) -> (1, 2) -> (2, 4). Имајте на уму да пион на (1, 2) није заробљен.
Боб бира пиона на (1, 2) и заробљава га у један потез: (2, 4) -> (1, 2).

Ограничења:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Све positions[i] су јединствене.
Улазни подаци су генерисани тако да positions[i] != [kx, ky] за све 0 <= i < positions.length.

Постоји шаховска табла величине 50 x 50 са једним скакачем и неколико пешака на њој. Добијате два цела броја kx и ky где (kx, ky) означава положај скакача, а 2D низ позиција где  positions[i] = [x_i, y_i] означавају положај пешака на шаховској табли.
Алиса и Боб играју турн-басед игру, где Алиса иде први. На реду сваког играча:

Играч бира пешака који још увек постоји на табли и заробљава га са скакачем у што мање потеза. Имајте на уму да играч може да изабере било ког пешака, то можда неће бити онај који може бити заробљен у најмањем броју потеза.
У процесу заробљавања изабраног пешака, скакач може проћи поред других пешака без да их зароби. У овом потезу може бити заробљен само изабрани пешак.

Алиса покушава да максимизира збир потеза које су оба играча направила све док више нема пешака на табли, док Боб покушава да их минимизира.
Вратите максималан укупан број потеза направљених током игре које Алиса може постићи, под претпоставком да оба играча играју оптимално.
Имајте на уму да у једном потезу, шаховски скакач има осам могућих позиција на које се може кретати, као што је приказано испод. Сваки потез су две ћелије у кардиналном правцу, а затим једна ћелија у ортогоналном правцу.

Пример 1:

Улаз : kx = 1, ky = 1, positions = [[0,0]]
излаз : 4
Објаљњење:

Скакачу је потребно 4 потеза да дође до пешака на (0, 0).

Пример 2:

Улаз : kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
излаз : 8
Објаљњење:

Алиса бира пешака у (2, 2) и хвата га у два потеза: (0, 2) -> (1, 4) -> (2, 2).
Боб бира пешака на (3, 3) и хвата га у два потеза: (2, 2) -> (4, 1) -> (3, 3).
Алиса бира пешака на (1, 1) и заробљава га у четири потеза: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

Пример 3:

Улаз : kx = 0, ky = 0, positions = [[1,2],[2,4]]
излаз : 3
Објаљњење:

Алиса бира пешака на (2, 4) и хвата га у два потеза: (0, 0) -> (1, 2) -> (2, 4). Приметите да пешак на (1, 2) није заробљен.
Боб бира пешака на (1, 2) и хвата га у једном потезу: (2, 4) -> (1, 2).

Ограничења:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
Све positions[i] су јединствене.
Улаз се генерише тако да positions[i] != [kx, ky] за све 0 <= i < positions.length.


Дат је цео бројевни низ a величине 4 и још један цели бројевни низ b величине најмање 4.
Потребно је изабрати 4 индекса i_0, i_1, i_2 и i_3 из низа b тако да важи i_0 < i_1 < i_2 < i_3. Ваш резултат ће бити једнак вредности a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Вратите максималне поене које можете постићи.

Пример 1:

Улаз: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Излаз: 26
Објашњење:
Можемо изабрати индексе 0, 1, 2 и 5. Резултат ће бити 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Пример 2:

Улаз: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Излаз: -1
Објашњење:
Можемо изабрати индексе 0, 1, 3 и 4. Резултат ће бити (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Ограничења:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Добијате цео низ а величине 4 и други цео низ б величине најмање 4.
Потребно је да изаберете 4 индекса i_0, i_1, i_2 и i_3 из низа б тако да i_0 < i_1 < i_2 < i_3. Ваш резултат ће бити једнак вредности a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Вратите максимални резултат који можете постићи.

Пример 1:

Улаз : a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
излаз : 26
Објаљњење:
Можемо изабрати индексе 0, 1, 2 и 5. Резултат ће бити 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Пример 2:

Улаз : a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
излаз : -1
Објаљњење:
Можемо изабрати индексе 0, 1, 3 и 4. Резултат ће бити (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Ограничења:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Дати су вам цеоарни низ a величине 4 и други цеоарни низ b величине најмање 4.
Потребно је да изаберете 4 индекса i_0, i_1, i_2 и i_3 из низа b тако да важи i_0 < i_1 < i_2 < i_3.
Ваш резултат ће бити једнак вредности a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Вратите максималан резултат који можете постићи.

Пример 1:

Унос: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Излаз: 26
Објашњење:
Можемо изабрати индексе 0, 1, 2 и 5. Резултат ће бити 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Пример 2:

Унос: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Излаз: -1
Објашњење:
Можемо изабрати индексе 0, 1, 3 и 4. Резултат ће бити (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.

Ограничења:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5


Dati su niz stringova `words` i string `target`.
String `x` se smatra validnim ako je `x` prefiks bilo kog stringa u nizu `words`.
Vratiti minimalan broj validnih stringova koji se mogu konkatenirati da bi se formirao `target`.
Ako nije moguće formirati `target`, vratiti `-1`.

---

Primer 1:

Ulaz: `words = ["abc","aaaaa","bcdef"]`, `target = "aabcdabc"`
Izlaz: `3`
Objašnjenje:
String `target` se može formirati konkatenacijom:

- Prefiksa dužine `2` iz `words[1]`, tj. `"aa"`.
- Prefiksa dužine `3` iz `words[2]`, tj. `"bcd"`.
- Prefiksa dužine `3` iz `words[0]`, tj. `"abc"`.

Primer 2:

Ulaz: `words = ["abababab","ab"]`, `target = "ababaababa"`
Izlaz: `2`
Objašnjenje:
String `target` se može formirati konkatenacijom:

- Prefiksa dužine `5` iz `words[0]`, tj. `"ababa"`.
- Prefiksa dužine `5` iz `words[0]`, tj. `"ababa"`.

Primer 3

Ulaz: `words = ["abcdef"]`, `target = "xyz"`
Izlaz: `-1`

Ograničenja:

- \(1 \leq \text{words.length} \leq 100\)
- \(1 \leq \text{words}[i].\text{length} \leq 5 \times 10^3\)
- Ulaz je generisan tako da \( \text{sum}(\text{words}[i].\text{length}) \leq 10^5 \).
- `words[i]` se sastoji samo od malih slova engleskog alfabeta.
- \(1 \leq \text{target.length} \leq 5 \times 10^3\)
- `target` se sastoji samo od malih slova engleskog alfabeta.

Дат вам је низ стрингова words и стринг target. Стринг x се назива валидним ако је x префикс било ког стринга у words. Вратите минималан број валидних стрингова који могу бити конкатенисани да би се формирао target. Ако није могуће формирати target, вратите -1.

Пример 1:

Улаз: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Излаз: 3
Објашњење:
Стринг target може бити формиран конкатенацијом:

Префикс дужине 2 из words[1], тј. "aa".
Префикс дужине 3 из words[2], тј. "bcd".
Префикс дужине 3 из words[0], тј. "abc".

Пример 2:

Улаз: words = ["abababab","ab"], target = "ababaababa"
Излаз: 2
Објашњење:
Стринг target може бити формиран конкатенацијом:

Префикс дужине 5 из words[0], тј. "ababa".
Префикс дужине 5 из words[0], тј. "ababa".

Пример 3:

Улаз: words = ["abcdef"], target = "xyz"
Излаз: -1

Ограничења:

1 <= words.length <= 100
1 <= words[i].length <= 5 \times 10^3
Улаз је генерисан тако да је збир дуљина words[i] <= 10^5.
words[i] се састоји само од малих слова енглеске абецеде.
1 <= target.length <= 5 \times 10^3
target се састоји само од малих слова енглеске абецеде.

Дат вам је низ низова words и низ target.
Низ x се назива валидним ако је x префикс било ког низа из words. Вратите минимални број валидних низова који се могу конкатеновати да формирају target. Ако није могуће формирати target, вратите -1.

Пример 1:

Улаз: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Излаз: 3
Објашњење:
Стринг target може бити формиран конкатенацијом:

Префикс дужине 2 из words[1], тј. "aa".
Префикс дужине 3 из words[2], тј. "bcd".
Префикс дужине 3 из words[0], тј. "abc".

Пример 2:

Улаз: words = ["abababab","ab"], target = "ababaababa"
Излаз: 2
Објашњење:
Стринг target може бити формиран конкатенацијом:

Префикс дужине 5 из words[0], тј. "ababa".
Префикс дужине 5 из words[0], тј. "ababa".

Пример 3:

Улаз: words = ["abcdef"], target = "xyz"
Излаз: -1

Ограничења:

1 <= words.length <= 100
1 <= words[i].length <= 5 \times 10^3
Улаз је генерисан тако да је збир дуљина words[i] <= 10^5.
words[i] се састоји само од малих слова енглеске абецеде.
1 <= target.length <= 5 \times 10^3
target се састоји само од малих слова енглеске абецеде.


Дат је низ целих бројева nums дужине n и позитиван цео број k.
Снага низа је дефинисана као:

Његов максимални елемент ако су сви његови елементи узастопни и сортирани у растућем редоследу.
-1 иначе.

Потребно је наћи снагу свих под-низова nums величине k.
Вратите низ целих бројева results величине n - k + 1, где је results[i] снага nums[i..(i + k - 1)].

Пример 1:

Улаз: nums = [1,2,3,4,3,2,5], k = 3
Излаз: [3,4,-1,-1,-1]
Објашњење:
Постоји 5 под-низова nums величине 3:

[1, 2, 3] са максималним елементом 3.
[2, 3, 4] са максималним елементом 4.
[3, 4, 3] чији елементи нису узастопни.
[4, 3, 2] чији елементи нису сортирани.
[3, 2, 5] чији елементи нису узастопни.

Пример 2:

Улаз: nums = [2,2,2,2,2], k = 4
Излаз: [-1,-1]

Пример 3:

Улаз: nums = [3,2,3,2,3,2], k = 2
Излаз: [-1,3,-1,3,-1]

Ограничења:

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

Дат вам је низ целих бројева nums дужине n и позитиван цео број k.
Снага низа дефинисана је на следећи начин:

Његов максимални елемент ако су сви елементи узастопни и сортирани растућим редом.
-1 у супротном случају.
Потребно је пронаћи снагу свих поднизова nums величине k.
Вратите низ целих бројева results величине n - k + 1, где је results[i] снага nums[i..(i + k - 1)].

Пример 1:

Улаз: nums = [1,2,3,4,3,2,5], k = 3
Излаз: [3,4,-1,-1,-1]
Објашњење:
Постоји 5 под-низова nums величине 3:

[1, 2, 3] са максималним елементом 3.
[2, 3, 4] са максималним елементом 4.
[3, 4, 3] чији елементи нису узастопни.
[4, 3, 2] чији елементи нису сортирани.
[3, 2, 5] чији елементи нису узастопни.

Пример 2:

Улаз: nums = [2,2,2,2,2], k = 4
Излаз: [-1,-1]

Пример 3:

Улаз: nums = [3,2,3,2,3,2], k = 2
Излаз: [-1,3,-1,3,-1]

Ограничења:

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

Дат је низ целих бројева nums дужине n и позитиван цео број k.
Снага низа је дефинисана као:

Његов максимални елемент ако су сви његови елементи узастопни и сортирани у растућем редоследу.
-1 иначе.

Потребно је пронаћи снагу свих под-низова nums величине k.
Вратите низ целих бројева results величине n - k + 1, где је results[i] снага nums[i..(i + k - 1)].

Пример 1:

Улаз: nums = [1,2,3,4,3,2,5], k = 3
Излаз: [3,4,-1,-1,-1]
Објашњење:
Постоји 5 под-низова nums величине 3:

[1, 2, 3] са максималним елементом 3.
[2, 3, 4] са максималним елементом 4.
[3, 4, 3] чији елементи нису узастопни.
[4, 3, 2] чији елементи нису сортирани.
[3, 2, 5] чији елементи нису узастопни.

Пример 2:

Улаз: nums = [2,2,2,2,2], k = 4
Излаз: [-1,-1]

Пример 3:

Улаз: nums = [3,2,3,2,3,2], k = 2
Излаз: [-1,3,-1,3,-1]

Ограничења:

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


Dati ste m x n 2D niz **board** koji predstavlja šahovsku tablu, gde **board[i][j]** predstavlja vrednost polja \((i, j)\).
Topovi u istoj vrsti ili koloni napadaju jedni druge. Potrebno je postaviti tri topa na šahovsku tablu tako da se topovi ne napadaju.
Vratite maksimalni zbir vrednosti polja na kojima su postavljeni topovi.

---

**Primer 1:**

```
Ulaz: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Izlaz: 4
Objašnjenje:
Topove možemo postaviti na polja (0, 2), (1, 3) i (2, 1), gde je zbir 1 + 1 + 2 = 4.

Primer 2:

Ulaz: board = [[1,2,3],[4,5,6],[7,8,9]]
Izlaz: 15
Objašnjenje:
Topove možemo postaviti na polja (0, 0), (1, 1) i (2, 2), gde je zbir 1 + 5 + 9 = 15.

Primer 3:

Ulaz: board = [[1,1,1],[1,1,1],[1,1,1]]
Izlaz: 3
Objašnjenje:
Topove možemo postaviti na polja (0, 2), (1, 1) i (2, 0), gde je zbir 1 + 1 + 1 = 3.

Ograničenja

- \(3 \leq m = \text{board.length} \leq 100\)
- \(3 \leq n = \text{board[i].length} \leq 100\)
- \(-10^9 \leq \text{board[i][j]} \leq 10^9\)

Дат је m x n 2D низ табела који представља шаховску таблу, где board[i][j] представља вредност ћелије (i, j). Топови у истом реду или колони нападају један другог. Треба да поставите три топа на шаховској табли тако да се топови не нападају. Вратите максималну суму вредности ћелија на којима су постављени топови.

Пример 1:

Улаз: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Излаз: 4
Објашњење:

Можемо поставити топове у ћелије (0, 2), (1, 3) и (2, 1) за суму 1 + 1 + 2 = 4.

Пример 2:

Улаз: board = [[1,2,3],[4,5,6],[7,8,9]]
Излаз: 15
Објашњење:
Можемо поставити топове у ћелије (0, 0), (1, 1) и (2, 2) за суму 1 + 5 + 9 = 15.

Пример 3:

Улаз: board = [[1,1,1],[1,1,1],[1,1,1]]
Излаз: 3
Објашњење:
Можемо поставити топове у ћелије (0, 2), (1, 1) и (2, 0) за суму 1 + 1 + 1 = 3.

Ограничења:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

Дат вам је 2Д низ board димензија m x n који представља шаховску таблу, где board[i][j] представља вредност поља (i, j).
Топови који се налазе у истом реду или колони нападају један другог. Потребно је поставити три топа на шаховску таблу тако да се топови међусобно не нападају.
Вратите максималан збир вредности поља на којима су топови постављени.

Пример 1:

Улаз: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Излаз: 4
Објашњење:

Можемо поставити топове у поља (0, 2), (1, 3) и (2, 1) за збир 1 + 1 + 2 = 4.

Пример 2:

Улаз: board = [[1,2,3],[4,5,6],[7,8,9]]
Излаз: 15
Објашњење:
Можемо поставити топове у поља (0, 0), (1, 1) и (2, 2) за збир 1 + 5 + 9 = 15.

Пример 3:

Улаз: board = [[1,1,1],[1,1,1],[1,1,1]]
Излаз: 3
Објашњење:
Можемо поставити топове у поља (0, 2), (1, 1) и (2, 0) за збир 1 + 1 + 1 = 3.

Ограничења:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9


Дати су вам три позитивна броја num1, num2 и num3. Кључ бројева num1, num2 и num3 је дефинисан као четвороцифрени број на следећи начин:

По почетку, ако неки број има мање од четири цифре, биће допуњен водечим нулама.
i-та цифра (1 <= i <= 4) кључа се генерише узимањем најмање цифре међу i-тим цифрама бројева num1, num2 и num3.

Вратите кључ ова три броја без водечих нула (ако их има).

Пример 1:

Улаз: num1 = 1, num2 = 10, num3 = 1000
Излаз: 0
Објашњење:
Након допуњавања, num1 постаје "0001", num2 постаје "0010", а num3 остаје "1000".

1-ва цифра кључа је min(0, 0, 1).
2-ра цифра кључа је min(0, 0, 0).
3-ћа цифра кључа је min(0, 1, 0).
4-та цифра кључа је min(1, 0, 0).

Следствено, кључ је "0000", односно 0.

Пример 2:

Улаз: num1 = 987, num2 = 879, num3 = 798
Излаз: 777

Пример 3:

Улаз: num1 = 1, num2 = 2, num3 = 3
Излаз: 1

Ограничења:

1 <= num1, num2, num3 <= 9999

Дајете три позитивне целе бројеве num1, num2 и num3.
Кључ num1, num2 и num3 је дефинисан као четвороцифрени број, као што је следеће:

У почетку, ако било који број има мање од четири цифре, подстављен је водећим нулама.
i-та цифра (1 <= i <= 4) кључа се генерише узимањем најмање цифре међу i-тим цифрама бројева num1, num2 и num3.

Вратите кључ три броја без водећих нула (ако их има).

Пример 1:

Улаз: num1 = 1, num2 = 10, num3 = 1000
Излаз: 0
Објашњење:
На паддинг-у, num1 постаје "0001", num2 постаје "0010", а num3 остаје "1000".

1-та цифра кључа је мин (0, 0, 1).
2-та цифра кључа је мин (0, 0, 0).
3-та цифра кључа је мин (0, 1, 0).
4-та цифра кључа је мин (1, 0, 0).

Дакле, кључ је "0000", тј. 0.

Пример 2:

Улаз: num1 = 987, num2 = 879, num3 = 798
Излаз: 777

Пример 3:

Улаз: num1 = 1, num2 = 2, num3 = 3
Излаз: 1

ОГРАНИЧЕЊА:

1 <= num1, num2, num3 <= 9999

Дати су вам три позитивна цела броја num1, num2 и num3.
Кључ бројева num1, num2 и num3 је дефинисан као четвороцифрени број тако да:

Иницијално, ако било који број има мање од четири цифре, додају се водеће нуле.
i-th цифра (1 <= i <= 4) кључа се генерише узимањем најмање цифре међу i-th цифрама бројева num1, num2 и num3.

Вратите кључ ова три броја без водећих нула (ако их има).

Пример 1:

Улаз: num1 = 1, num2 = 10, num3 = 1000
Излаз: 0
Објашњење:
При додавању водећих нула, num1 постаје "0001", num2 постаје "0010", а num3 остаје "1000".

1-ва цифра кључа је min(0, 0, 1).
2-ра цифра кључа је min(0, 0, 0).
3-ћа цифра кључа је min(0, 1, 0).
4-та цифра кључа је min(1, 0, 0).

Следствено, кључ је "0000", односно 0.

Пример 2:

Улаз: num1 = 987, num2 = 879, num3 = 798
Излаз: 777

Пример 3:

Улаз: num1 = 1, num2 = 2, num3 = 3
Излаз: 1

Ограничења:

1 <= num1, num2, num3 <= 9999


Имате задат низ s дужине n и цео број k, где је n вишефолд к. Твој задатак је да хешираш низ s у нови низ који се зове резултат, а који има дужину n / k.
Прво, поделите s на n / k поднизова, сваки дужине k. Затим, иницијализујте резултат као празан низ.
За сваки подниз, редом од почетка:

Хеш вредност карактера је индекс тог карактера у енглеском алфабету ( нпр. 'a' → 0, 'b' → 1, ..., 'z' → 25).
Израчунајте збир свих хеш вредности карактера у подстрингу.
Пронађите остатак овог збира када се подели са 26, што се назива hashedChar.
Идентификујте карактер у енглеском алфабету малих слова који одговара hashedChar.
Додајте тај карактер на крај резултата result.

Врати се резултат.

Пример 1:

Улаз: s = "abcd", k = 2
Излаз: "bf"
Објашњење:
Први подниз: "ab", 0 + 1 = 1, 1 % 26 = 1, result[0] = 'b'.
Други подниз: "cd", 2 + 3 = 5, 5 % 26 = 5, result[1] = 'f'.

Пример 2:

Улаз: s = "mxz", k = 3
Излаз: "i"
Објашњење:
Једини подниз: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = 'i'.

Ограничења:

1 <= k <= 100
k <= s.length <= 1000
s.length је делив са k.
s садржи само мала слова енглеског језика.

Имаш задат низ \( s \) дужине \( n \) и цео број \( k \), где је \( n \) више од \( k \). Твој задатак је да хешираш низ \( s \) у нови низ који се зове резултат, а који има дужину \( n / k \).
Прво, подели \( s \) на \( n / k \) поднизова, сваки дужине \( k \). Затим, иницијализуј резултат као празан низ.
За сваки подниз, редом од почетка:

Хеш вредност карактера је индекс тог карактера у енглеској азбуци (нпр. 'a' → 0, 'b' → 1, ..., 'z' → 25).
Израчунај збир свих хеш вредности карактера у поднизу.
Пронађи остатак овог збира када се подели са 26, што се назива hashedChar.
Идентификуј карактер у енглеској азбуци који одговара hashedChar.
Додај тај карактер на крај резултата.

Врати резултат.

Пример 1:

Улаз: s = "abcd", k = 2
Излаз: "bf"
Објашњење:
Први подниз: "ab", 0 + 1 = 1, 1 % 26 = 1, резултат[0] = 'b'.
Други подниз: "cd", 2 + 3 = 5, 5 % 26 = 5, резултат[1] = 'f'.

Пример 2:

Улаз: s = "mxz", k = 3
Излаз: "i"
Објашњење:
Једини подниз: "mxz", 12 + 23 + 25 = 60, 60 % 26 = 8, резултат[0] = 'i'.

Ограничења:

1 <= k <= 100
k <= s.length <= 1000
s.length је делив без остатка са k.
s садржи само мала слова енглеске азбуке.


Дати су вам два позитивна цела броја n и k.
Цео број x се назива k-палиндром ако:

x је палиндром.
x је дељив са k.

Цео број се назива добар ако се његове цифре могу реаранжирати да формирају k-палиндром. На пример, за k = 2, 2020 се може реаранжирати да формира k-палиндром 2002, док се 1010 не може реаранжирати да формира k-палиндром.
Вратите број добрих бројева који садрже n цифара.
Напомињемо да цео број не сме имати водеће нуле, ни пре ни после реаранжирања. На пример, 1010 се не може реаранжирати у 101.

Пример 1:

Улаз: n = 3, k = 5
Излаз: 27
Објашњење:
Неки од добрих бројева су:

551 јер се може реаранжирати у 515.
525 јер је већ k-палиндром.

Пример 2:

Улаз: n = 1, k = 4
Излаз: 2
Објашњење:
Два добра броја су 4 и 8.

Пример 3:

Улаз: n = 5, k = 6
Излаз: 2468

Ограничења:

1 <= n <= 10
1 <= k <= 9

Добијате два позитивна цела броја н и к.
Цео број x се зове к-палиндромски ако:

x је палиндром.
x је дељив са к.

Цео број се назива добрим ако се његове цифре могу преуредити да формирају к-палиндромски цео број. На пример, за к = 2, 2020 се може преуредити да формира к-палиндромски цео број 2002, док се 1010 не може преуредити да формира к-палиндромски цео број.
Врати број добрих целих бројева који садрже н цифара.
Имајте на уму да било који цео број не сме да има водеће нуле, ни пре ни после преуређења. На пример, 1010 се не може преуредити да формира 101.

Пример 1:

Улаз : н = 3, к = 5
излаз : 27
Објаљњење:
Неки од добрих целих бројева су:

551 јер се може преуредити да се формира 515.
525 јер је већ к-палиндромски.

Пример 2:

Улаз : н = 1, к = 4
излаз : 2
Објаљњење:
Два добра цела броја су 4 и 8.

Пример 3:

Улаз : н = 5, к = 6
излаз : 2468

Ограничења:

1 < = н < = 10
1 < = к < = 9

Дати су вам два позитивна цела броја n и k.
Цео број x се назива k-палиндром ако:

x је палиндром.
x је дељив са k.

Цео број се назива добар ако се његове цифре могу прередити да формирају k-палиндром. На пример, за k = 2, 2020 се може прередити да формира k-палиндром 2002, док се 1010 не може прередити да формира k-палиндром.
Вратите број добрих бројева који садрже n цифара.
Напомињемо да цео број не сме имати водеће нуле, ни пре ни после прередивања. На пример, 1010 се не може прередити у 101.

Пример 1:

Улаз: n = 3, k = 5
Излаз: 27
Објашњење:
Неки од добрих целих бројева су:

551 јер се може прередити да формира 515.
525 јер је већ k-палиндромски.

Пример 2:

Улаз: n = 1, k = 4
Излаз: 2
Објашњење:
Два добра цела броја су 4 и 8.

Пример 3:

Улаз: n = 5, k = 6
Излаз: 2468

Ограничења:

1 <= n <= 10
1 <= k <= 9


Дат је цео број power и два низа целих бројева damage и health, оба дужине n.
Боб има n непријатеља, где ће непријатељ i нанети Бобу damage[i] поена штете у секунди док је жив (тј. health[i] > 0).
Сваки секунд, након што непријатељи нанесу штету Бобу, он бира једног од непријатеља који је још увек жив и наноси му power поена штете.
Одреди минималан укупни број поена штете који ће бити нанесени Бобу пре него што сви n непријатељи буду мртви.

Пример 1:

Унос: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Излаз: 39
Објашњење:

Нападни непријатеља 3 у прве две секунде, након чега ће непријатељ 3 пасти, број поена штете нанесених Бобу је 10 + 10 = 20 поена.
Нападни непријатеља 2 у наредне две секунде, након чега ће непријатељ 2 пасти, број поена штете нанесених Бобу је 6 + 6 = 12 поена.
Нападни непријатеља 0 у наредној секунди, након чега ће непријатељ 0 пасти, број поена штете нанесених Бобу је 3 поена.
Нападни непријатеља 1 у наредне две секунде, након чега ће непријатељ 1 пасти, број поена штете нанесених Бобу је 2 + 2 = 4 поена.

Пример 2:

Унос: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Излаз: 20
Објашњење:

Нападни непријатеља 0 у првој секунди, након чега ће непријатељ 0 пасти, број поена штете нанесених Бобу је 4 поена.
Нападни непријатеља 1 у наредне две секунде, након чега ће непријатељ 1 пасти, број поена штете нанесених Бобу је 3 + 3 = 6 поена.
Нападни непријатеља 2 у наредне три секунде, након чега ће непријатељ 2 пасти, број поена штете нанесених Бобу је 2 + 2 + 2 = 6 поена.
Нападни непријатеља 3 у наредне четири секунде, након чега ће непријатељ 3 пасти, број поена штете нанесених Бобу је 1 + 1 + 1 + 1 = 4 поена.

Пример 3:

Унос: power = 8, damage = [40], health = [59]
Излаз: 320

Ограничења:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Дат вам је целобројна вредност power и два низа целих бројева damage и health, оба дужине n.
Боб има n непријатеља, где непријатељ i наноси Бобу damage[i] поена штете по секунди док су живи (тј. health[i] > 0).
Сваки секунд, након што непријатељи нане Бобу штету, он бира једног од непријатеља који су још увек живи и наноси им power поена штете.
Одредите минималну укупну количину поена штете која ће бити нанесена Бобу пре него што сви n непријатељи буду мртви.
Пример 1:

Унос: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Излаз: 39
Објашњење:

Нападај непријатеља 3 у прве две секунде, након чега ће непријатељ 3 пасти, број поена штете нанесених Бобу је 10 + 10 = 20 поена.
Нападај непријатеља 2 у наредне две секунде, након чега ће непријатељ 2 пасти, број поена штете нанесених Бобу је 6 + 6 = 12 поена.
Нападај непријатеља 0 у наредној секунди, након чега ће непријатељ 0 пасти, број поена штете нанесених Бобу је 3 поена.
Нападај непријатеља 1 у наредне две секунде, након чега ће непријатељ 1 пасти, број поена штете нанесених Бобу је 2 + 2 = 4 поена.

Пример 2:

Унос: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Излаз: 20
Објашњење:

Нападај непријатеља 0 у првој секунди, након чега ће непријатељ 0 пасти, број поена штете нанесених Бобу је 4 поена.
Нападај непријатеља 1 у наредне две секунде, након чега ће непријатељ 1 пасти, број поена штете нанесених Бобу је 3 + 3 = 6 поена.
Нападај непријатеља 2 у наредне три секунде, након чега ће непријатељ 2 пасти, број поена штете нанесених Бобу је 2 + 2 + 2 = 6 поена.
Нападај непријатеља 3 у наредне четири секунде, након чега ће непријатељ 3 пасти, број поена штете нанесених Бобу је 1 + 1 + 1 + 1 = 4 поена.

Пример 3:

Унос: power = 8, damage = [40], health = [59]
Излаз: 320

Ограничења:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4

Дат вам је цео број power и два целобројна низа damage и health, оба дужине n.
Боб има n непријатеља, где ће непријатељ i нанети Бобу damage[i] поена штете у секунди док је жив (тј. health[i] > 0).
Сваки секунд, након што непријатељи нанесу штету Бобу, он бира једног од непријатеља који је још увек жив и наноси му power поена штете.
Одреди минималан укупни број поена штете који ће бити нанесени Бобу пре него што сви n непријатељи буду мртви.

Пример 1:

Улаз: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Излаз: 39
Објашњење:

Нападните непријатеља  3 у прве две секунде, након чега ће непријатељ 3 пасти, број поена штете нанесених Бобу је 10 + 10 = 20 поена.
Нападните непријатеља 2 у наредне две секунде, након чега ће непријатељ 2 пасти, број поена штете нанесених Бобу је 6 + 6 = 12 поена.
Нападните непријатеља 0 у наредној секунди, након чега ће непријатељ 0 пасти, број поена штете нанесених Бобу је 3 поена.
Нападните непријатеља 1 у наредне две секунде, након чега ће непријатељ 1 пасти, број поена штете нанесених Бобу је 2 + 2 = 4 поена.

Пример 2:

Улаз: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Излаз: 20
Објашњење:

Нападните непријатеља 0 у првој секунди, након чега ће непријатељ 0 пасти, број поена штете нанесених Бобу је 4 поена.
Нападните непријатеља 1 у наредне две секунде, након чега ће непријатељ 1 пасти, број поена штете нанесених Бобу је 3 + 3 = 6 поена.
Нападните непријатеља 2 у наредне три секунде, након чега ће непријатељ 2 пасти, број поена штете нанесених Бобу је 2 + 2 + 2 = 6 поена.
Нападните непријатеља 3 у наредне четири секунде, након чега ће непријатељ 3 пасти, број поена штете нанесених Бобу је 1 + 1 + 1 + 1 = 4 поена.

Пример 3:

Улаз: power = 8, damage = [40], health = [59]
Излаз: 320

Ограничења:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4


Датa је бинарнa м x n матрица grid и цео број health.
Почињете у горњем левом углу (0, 0) и желите да стигнете до доњег десног угла (m - 1, n - 1).
Можете се кретати горе, доле, лево или десно из једне ћелије у другу суседну ћелију све док вам здравље остаје позитивно.
Ћелије (i, j) где је grid[i][j] = 1 се сматрају небезбедним и смањују ваше здравље за 1.
Вратите true ако можете стићи до крајње ћелије са вредношћу здравља од 1 или више, иначе вратите false.

Пример 1:

Input: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Output: true
Објашњење:
До крајње ћелије се може безбедно стићи ходањем дуж сивих ћелија испод.

Пример 2:

Input: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Output: false
Објашњење:
Минимално је потребно 4 поена здравља да бисте безбедно стигли до крајње ћелије.

Пример 3:

Input: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Output: true
Објашњење:
До крајње ћелије се може безбедно стићи ходањем дуж сивих ћелија испод.

Било који пут који не пролази кроз ћелију (1, 1) је небезбедан јер ће вам здравље пасти на 0 када дођете до крајње ћелије.

Ограничења:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] је 0 или 1.

Датa је бинарнa м x n матрица grid и цео број health.
Почињете у горњем левом углу (0, 0) и желите да стигнете до доњег десног угла (m - 1, n - 1).
Можете се кретати горе, доле, лево или десно из једне ћелије у другу суседну ћелију све док вам здравље остаје позитивно.
Ћелије (i, j) где је grid[i][j] = 1 се сматрају небезбедним и смањују ваше здравље за 1.
Вратите true ако можете стићи до крајње ћелије са вредношћу здравља од 1 или више, иначе вратите false.

Пример 1:

Улаз: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Излаз: true
Објашњење:
До крајње ћелије се може безбедно стићи ходањем дуж сивих ћелија испод.

Пример 2:

Улаз: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Излаз: false
Објашњење:
Минимално је потребно 4 поена здравља да бисте безбедно стигли до крајње ћелије.

Пример 3:

Улаз: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Излаз: true
Објашњење:
До крајње ћелије се може безбедно стићи ходањем дуж сивих ћелија испод.

Било који пут који не пролази кроз ћелију (1, 1) је небезбедан јер ће вам здравље пасти на 0 када дођете до крајње ћелије.

Ограничења:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] је 0 или 1.

Imate m x n binarnu matricu grid i celo broj zdravlja.

Počinjete u gornjem levom kutu (0, 0) i želite da stignete do donjeg desnog kuta (m - 1, n - 1). Možete se kretati gore, dole, levo ili desno sa jednog ćelije na drugu susednu ćeliju sve dok vaše zdravlje ostaje pozitivno. Ćelije (i, j) sa grid[i][j] = 1 se smatraju nesigurnim i smanjuju vaše zdravlje za 1.

Vrati true ako možete da stignete do poslednje ćelije sa vrednošću zdravlja od 1 ili više, i false u suprotnom.

Primer 1:

Ulaz:grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Izlaz:true
Objašnjenje:
Poslednja ćelija može biti sigurno dostignuta hodajući duž sivih ćelija ispod.

Primer 2:

Ulaz:grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Izlaz:false
Objašnjenje:
Minimalno 4 poena zdravlja je potrebno da bi se sigurno stiglo do poslednje ćelije.

Primer 3:

Ulaz:grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Izlaz:true
Objašnjenje:
Poslednja ćelija može biti sigurno dostignuta hodajući duž sivih ćelija ispod.

Svaki put koji ne prolazi kroz ćeliju (1, 1) je nesiguran jer će vaše zdravlje pasti na 0 kada stignete do poslednje ćelije.

Ograničenja:

- m == grid.length
- n == grid[i].length
- 1 <= m, n <= 50
- 2 <= m * n
- 1 <= health <= m + n
- grid[i][j] je ili 0 ili 1.


Дат вам је низ целих бројева nums и позитиван целобројни k.
Вредност секвенце seq величине 2 * x дефинисана је као:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Вратите максималну вредност било које подсеквенце из nums величине 2 * k.

Пример 1:

Унос: nums = [2,6,7], k = 1
Излаз: 5
Објашњење:
Подсеквенца [2, 7] има максималну вредност 2 XOR 7 = 5.

Пример 2:

Унос: nums = [4,2,5,6,7], k = 2
Излаз: 2
Објашњење:
Подсеквенца [4, 5, 6, 7] има максималну вредност (4 OR 5) XOR (6 OR 7) = 2.

Ограничења:

2 <= length nums <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Дат вам је низ целих бројева nums и позитиван цео број k.
Вредност низa seq величине 2 * x је дефинисана као:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Вратите максималну вредност било које подсеквенце из nums величине 2 * k.

Пример 1:

Улаз: nums = [2,6,7], k = 1
Излаз: 5
Објашњење:
Подсеквенца [2, 7] има максималну вредност 2 XOR 7 = 5.

Пример 2:

Улаз: nums = [4,2,5,6,7], k = 2
Излаз: 2
Објашњење:
Подсеквенца [4, 5, 6, 7] има максималну вредност (4 OR 5) XOR (6 OR 7) = 2.

Ограничења:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Добијате цео низ нумс и позитиван цео број к.
Вредност секвенце секвенце величине 2 * к је дефинисана као:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Вратите максималну вредност било које подсеквенце бројева који имају величину 2 * к.

Пример 1:

Улаз : nums = [2,6,7], к = 1
излаз : 5
Објаљњење:
Субсеквенца [2, 7] има максималну вредност 2 XOR 7 = 5.

Пример 2:

Улаз : nums = [4,2,5,6,7], к = 2
излаз : 2
Објаљњење:
Субсеквенца [4, 5, 6, 7] има максималну вредност (4 OR 5) XOR (6 OR 7) = 2.

Ограничења:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2


Дат вам је 2D низ целих бројева координата дужине n и цео број k, где 0 <= k < n.
coordinates[i] = [x_i, y_i] означава тачку (x_i, y_i) у 2D равни.
Растући пут дужине m дефинише се као списак тачака (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) тако да:

x_i < x_i + 1 и y_i < y_i + 1 за све i где 1 <= i < m.
(x_i, y_i) је у датим coordinates за све i где 1 <= i <= m.

Вратити максималну дужину растуће путање која садржи coordinates[k].

Пример 1:

Input: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Output: 3
Објашњење:
(0, 0), (2, 2), (5, 3) је најдужа растућа путања која укључује (2, 2).

Пример 2:

Input: coordinates = [[2,1],[7,0],[5,6]], k = 2
Output: 2
Објашњење:
(2, 1), (5, 6) је најдужа растућа путања која укључује (5, 6).

Ограничења:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Сви елементи у coordinates су различити.
0 <= k <= n - 1

Дат вам је 2D низ целих бројева coordinates дужине n и цео број k, где 0 <= k < n.
coordinates[i] = [x_i, y_i] означава тачку (x_i, y_i) у 2D равни.
Растућа путања дужине m дефинисана је као листа тачака (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) тако да:

x_i < x_i + 1 и y_i < y_i + 1 за све i где 1 <= i < m.
(x_i, y_i) је у датим coordinates за све i где 1 <= i <= m.

Вратити максималну дужину растуће путање која садржи coordinates[k].

Пример 1:

Input: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Output: 3
Објашњење:
(0, 0), (2, 2), (5, 3) је најдужа растућа путања која укључује (2, 2).

Пример 2:

Input: coordinates = [[2,1],[7,0],[5,6]], k = 2
Output: 2
Објашњење:
(2, 1), (5, 6) је најдужа растућа путања која укључује (5, 6).

Ограничења:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Сви елементи у coordinates су различити.
0 <= k <= n - 1

Дат вам је 2D низ координата целих бројева дужине n и цели број k, где је 0 <= k < n.
coordinates[i] = [x_i, y_i] означава тачку (x_i, y_i) у 2D равни.
Растући пут дужине м је дефинисан као листа тачака (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) тако да:

x_i < x_i + 1 и y_i < y_i + 1 за све и где је 1 <= i < m.
(x_i, y_i) је у датим координатама за све и где је 1 <= i <= m.

Врати максималну дужину растуће путање која садржи coordinates[k].

Пример 1:

Улаз: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Излаз: 3
Објашњење:
(0, 0), (2, 2), (5, 3) је најдужа растућа путања која садржи (2, 2).

Пример 2:

Улаз: coordinates = [[2,1],[7,0],[5,6]], k = 2
Излаз: 2
Објашњење:
(2, 1), (5, 6) је најдужи растући пут који садржи (5, 6).

Ограничења:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Сви елементи у координатама су различити.
0 <= k <= n - 1


Дат је низ стрингова message и низ стрингова bannedWords.
Низ речи се сматра спамом ако постоје најмање две речи у њему које се тачно поклапају са било којом речју из bannedWords.
Вратите true ако је низ message спам, а у супротном вратите false.

Пример 1:

Улаз: message = ["hello","world","leetcode"] , bannedWords = ["world","hello"]
Излаз: true
Објашњење:
Речи "hello" и "world" из низа message обе се појављују у низу bannedWords.

Пример 2:

Улаз: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Излаз: false
Објашњење:
Само једна реч из низа message ("programming") појављује се у низу bannedWords.

Ограничења:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
Низови message и bannedWords се састоје само од малих слова енглеске азбуке.

Добијате низ стрингс поруке и низ стрингова баннедWордс.
Низ речи се сматра спамом ако у њему постоје најмање две речи које тачно одговарају било којој речи у баннедWордс.
Врати истина ако је порука низа спам, а лажна у супротном.

Пример 1:

Улаз : message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Излаз :  true
Објаљњење:
Речи "hello" и "world"  из низа порука појављују се у низу баннедWордс.

Пример 2:

Инпут : message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Излаз : false
Објаљњење:
Само једна реч из низа порука ("програмирање") се појављује у низу баннедWордс.

Ограничења:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] и баннедWords[i] се састоје само од малих енглеских слова.

Дат је вам низ низова порука message и низ низова забрањених речи bannedWords.
Низ речи се сматра спамом ако се у њему налазе најмање две речи које се тачно поклапају са неком речју из bannedWords.
Вратите true ако је низ message спам, а false у супротном.

Пример 1:

Улаз: message = ["hello", "world", "leetcode"], bannedWords = ["world", "hello"]
Излаз: true
Објашњење:
Речи "hello" и "world" из низа message се појављују у низу bannedWords.

Пример 2:

Улаз: message = ["hello", "programming", "fun"], bannedWords = ["world", "programming", "leetcode"]
Излаз: `false`
Објашњење:
Само једна реч из низа message ("programming") се појављује у низу bannedWords.

Ограничења:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i]  и bannedWords[i] се састоје само од малих слова енглеске азбуке.


Дат вам је цео број mountainHeight који означава висину планине.
Дат вам је и низ целих бројева workerTimes који представља радно време радника у секундама.
Радници раде истовремено на смањењу висине планине. За радника i:

Да би се смањила висина планине за x, потребно је workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x секунди. На пример:

Да би се смањила висина планине за 1, потребно је workerTimes[i] секунди.
Да би се смањила висина планине за 2, потребно је workerTimes[i] + workerTimes[i] * 2 секунди, и тако даље.

Вратите цео број који представља минималан број секунди потребан да радници смање висину планине на 0.

Пример 1:

Улаз: mountainHeight = 4, workerTimes = [2,1,1]
Излаз: 3
Објашњење:
Један начин на који се висина планине може смањити на 0 је:

Радник 0 смањује висину за 1, узимајући workerTimes[0] = 2 секунде.
Радник 1 смањује висину за 2, узимајући workerTimes[1] + workerTimes[1] * 2 = 3 секунде.
Радник 2 смањује висину за 1, узимајући workerTimes[2] = 1 секунда.

Пошто раде истовремено, минимално време је max(2, 3, 1) = 3 секунде.

Пример 2:

Улаз: mountainHeight = 10, workerTimes = [3,2,2,4]
Излаз: 12
Објашњење:

Радник 0 смањује висину за 2, узимајући workerTimes[0] + workerTimes[0] * 2 = 9 секунди.
Радник 1 смањује висину за 3, узимајући workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 секунди.
Радник 2 смањује висину за 3, узимајући workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 секунди.
Радник 3 смањује висину за 2, узимајући workerTimes[3] + workerTimes[3] * 2 = 12 секунди.

Број секунди потребан је max(9, 12, 12, 12) = 12 секунди.

Пример 3:

Улаз: mountainHeight = 5, workerTimes = [1]
Излаз: 15
Објашњење:
Постоји само један радник у овом примеру, тако да је одговор workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Ограничења:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Дат је цео број mountainHeight који означава висину планине. Такође је дат низ целих бројева workerTimes који представља радно време радника у секундама. Радници раде истовремено на смањивању висине планине. За радника i:

Да би се смањила висина планине за x, потребно је workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x секунди. На пример:

Да би се смањила висина планине за 1, потребно је workerTimes[i] секунди.
Да би се смањила висина планине за 2, потребно је workerTimes[i] + workerTimes[i] * 2 секунде, и тако даље.

Вратите цео број који представља минималан број секунди потребних радницима да висина планине буде 0.

Пример 1:

Улаз: mountainHeight = 4, workerTimes = [2,1,1]
Излаз: 3
Објашњење:
Један начин на који се висина планине може смањити на 0 је:

Радник 0 смањује висину за 1, узимајући workerTimes[0] = 2 секунде.
Радник 1 смањује висину за 2, узимајући workerTimes[1] + workerTimes[1] * 2 = 3 секунде.
Радник 2 смањује висину за 1, узимајући workerTimes[2] = 1 секунда.

Пошто раде истовремено, минимално време је max(2, 3, 1) = 3 секунде.

Пример 2:

Улаз: mountainHeight = 10, workerTimes = [3,2,2,4]
Излаз: 12
Објашњење:

Радник 0 смањује висину за 2, узимајући workerTimes[0] + workerTimes[0] * 2 = 9 секунди.
Радник 1 смањује висину за 3, узимајући workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 секунди.
Радник 2 смањује висину за 3, узимајући workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 секунди.
Радник 3 смањује висину за 2, узимајући workerTimes[3] + workerTimes[3] * 2 = 12 секунди.

Број секунди потребан је max(9, 12, 12, 12) = 12 секунди.

Пример 3:

Улаз: mountainHeight = 5, workerTimes = [1]
Излаз: 15
Објашњење:
Постоји само један радник у овом примеру, тако да је одговор workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Ограничења:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Дат вам је целобројна висина планине која представља висину планине.
Такође, дат вам је целобројни низ воркерТимес који представља радно време радника у секундама.
Радници истовремено раде на смањењу висине планине. За радника и:

За смањење висине планине за к потребно је воркерТимес[и] + воркерТимес[и] * 2 + ... + воркерТимес[и] * к секунди. на пример:

ВоркерТимес[и] секунди је потребно да смањи висину планине за 1.
За смањење висине планине за 2 потребно је воркерТимес[и] + воркерТимес[и] * 2 секунде, и тако даље.

Врати цео број који представља минимални број секунди потребних радницима да смање висину планине на 0.

Пример 1:

Улаз: висина планине = 4, време радника = [2,1,1]
Излаз: 3
Објашњење: Један од начина да смањите висину планине на 0 је:

Радник 0 смањује висину за 1, што траје воркерТимес[0] = 2 секунде.
Радник 1 смањује висину за 2, што траје воркерТимес[1] + воркерТимес[1] * 2 = 3 секунде.
Радник 2 смањује висину за 1, што траје воркерТимес[2] = 1 секунду.

Пошто раде истовремено, минимално потребно време је мак(2, 3, 1) = 3 секунде.

Пример 2:

Улаз: висина планине = 10, време радника = [3,2,2,4]
Излаз: 12
Објашњење:

Радник 0 смањује висину за 2, што траје воркерТимес[0] + воркерТимес[0] * 2 = 9 секунди.
Радник 1 смањује висину за 3, што траје воркерТимес[1] + воркерТимес[1] * 2 + воркерТимес[1] * 3 = 12 секунди.
Воркер 2 смањује висину за 3, што траје воркерТимес[2] + воркерТимес[2] * 2 + воркерТимес[2] * 3 = 12 секунди.
Радник 3 смањује висину за 2, што траје воркерТимес[3] + воркерТимес[3] * 2 = 12 секунди.

Број потребних секунди је мак(9, 12, 12, 12) = 12 секунди.

Пример 3:

Улаз: висина планине = 5, време радника = [1]
Излаз: 15
Објашњење:
У овом примеру постоји само један радник, па је одговор воркерТимес[0] + воркерТимес[0] * 2 + воркерТимес[0] * 3 + воркерТимес[0] * 4 + воркерТимес[0] * 5 = 15.

Ограничења:

1 <= висина планине <= 10^5
1 <= воркерТимес.ленгтх <= 10^4
1 <= воркерТимес[и] <= 10^6


Дате су вам две стринг варијабле word1 и word2.
Стринг x се назива важећим ако може да се преуреди тако да word2 буде префикс.
Вратите укупан број важећих подстрингова од word1.

Пример 1:

Улаз: word1 = "bcca", word2 = "abc"
Излаз: 1
Објашњење:
Једина важећа подниска је "bcca" која се може прередити у "abcc" тако да "abc" буде префикс.

Пример 2:

Улаз: word1 = "abcabc", word2 = "abc"
Излаз: 10
Објашњење:
Све подниске осим подниски величине 1 и величине 2 су важеће.

Пример 3:

Улаз: word1 = "abcabc", word2 = "aaabc"
Излаз: 0

Ограничења:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 и word2 се састоје само од малих слова енглеског алфабета.

Дате су вам два низа word1 и word2.
Низ x се назива важећим ако се x може преуредити тако да има word2. као префикс.
Врати укупан број важећих подстрингова word1.

Пример 1:

Улаз: word1 = "bcca", word2 = "abc"
Излаз: 1
Објашњење:
Једини важећи подниз је „бцца“ који се може преуредити у „абцц“ са „абц“ као префиксом.

Пример 2:

Улаз: word1 = "abcabc", word2 = "abc"
Излаз: 10
Објашњење:
Сви поднизови осим поднизова величине 1 и величине 2 су важећи.

Пример 3:

Улаз: word1 = "abcabc", word2 = "aaabc"
Излаз: 0

Ограничења:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 и word2 cастоје се само од малих слова енглеског језика.

Дате су две ниске word1 и word2.
Ниска x се назива ваљном ако се x може прередити тако да word2 буде префикс.
Вратите укупан број ваљних подниски од word1.

Пример 1:

Улаз: word1 = "bcca", word2 = "abc"
Излаз: 1
Објашњење:
Једина ваљна подниска је "bcca" која се може прередити у "abcc" тако да "abc" буде префикс.

Пример 2:

Улаз: word1 = "abcabc", word2 = "abc"
Излаз: 10
Објашњење:
Све подниске осим подниски величине 1 и величине 2 су ваљне.

Пример 3:

Улаз: word1 = "abcabc", word2 = "aaabc"
Излаз: 0

Ограничења:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 и word2 се састоје само од малих слова енглеске абецеде.


Алиса и Боб играју игру. Почетно, Алиса има низ word = "a".
Дат вам је позитиван цео број k.
Сада ће Боб од Алисе тражити да изврши следећу операцију на бескрајно:

Генеришите нови низ тако што ћете сваки карактер у word променити у његов следећи карактер у енглеском алфабету и додати га на оригинални низ.

На пример, извршавање операције на "c" даје "cd", а извршавање операције на "zb" даје "zbac".
Вратите вредност k-тог карактера у низу word, након што су извршене довољне операције тако да word садржи најмање k карактера.
Напомена: Карактер 'z' може се променити у 'a' у овој операцији.

Пример 1:

Улаз: k = 5
Излаз: "b"
Објашњење:
На почетку, word = "a". Морамо извршити операцију три пута:

Генерисана реч је "b", word постаје "ab".
Генерисана реч је "bc", word постаје "abbc".
Генерисана реч је "bccd", word постаје "abbcbccd".

Пример 2:

Улаз: k = 10
Излаз: "c"

Ограничења:

1 <= k <= 500

Алиса и Боб играју игру. На почетку, Алиса има никсу word = "a".
Дат вам је позитиван цео број k.
Сада ће Боб тражити од Алисе да заувек изводи следећу операцију:

Генерише нову ниску тако што ће сваки карактер у word променити у следећи карактер енглеске абецеде и припојити је оригиналној ниски.

На пример, извођење операције на "c" генерише "cd", а извођење операције на "zb" генерише "zbac".
Вратите вредност k^ог карактера у word, након што је извршено довољно операција да word има најмање k карактера.
Напомена: карактер 'z' може бити промењен у 'a' у операцији.

Пример 1:

Улаз: k = 5
Излаз: "b"
Објашњење:
На почетку, word = "a". Морамо извршити операцију три пута:

Генерисана ниска је "b", word постаје "ab".
Генерисана ниска је "bc", word постаје "abbc".
Генерисана ниска је "bccd", word постаје "abbcbccd".

Пример 2:

Улаз: k = 10
Излаз: "c"

Ограничења:

1 <= k <= 500

Алиса и Боб играју игру. На почетку, Алиса има реч word = "a".
Дат вам је позитиван цео број k.
Сада ће Боб тражити од Алисе да заувек изводи следећу операцију:

Генерише нову реч тако што ће сваки карактер у word променити у следећи карактер енглеске абецеде и припојити је оригиналној речи.

На пример, извођење операције на "c" генерише "cd", а извођење операције на "zb" генерише "zbac".
Вратите вредност k^ог карактера у word, након што је извршено довољно операција да word има најмање k карактера.
Напомена: карактер 'z' може бити промењен у 'a' у операцији.

Пример 1:

Улаз: k = 5
Излаз: "b"
Објашњење:
На почетку, word = "a". Морамо извршити операцију три пута:

Генерисана реч је "b", word постаје "ab".
Генерисана реч је "bc", word постаје "abbc".
Генерисана реч је "bccd", word постаје "abbcbccd".

Пример 2:

Улаз: k = 10
Излаз: "c"

Ограничења:

1 <= k <= 500


Дат је низ word и ненегативан цео број k.
Вратите укупан број поднизова од word који садрже сваки самогласник ('a', 'e', 'i', 'o', и 'u') барем једном и тачно k сугласника.

Пример 1:

Улаз: word = "aeioqq", k = 1
Излаз: 0
Објашњење:
Не постоји подниз са сваким самогласником.

Пример 2:

Улаз: word = "aeiou", k = 0
Излаз: 1
Објашњење:
Једини подниз са сваким самогласником и нула сугласника је word[0..4], који је "aeiou".

Пример 3:

Улаз: word = "ieaouqqieaouqq", k = 1
Излаз: 3
Објашњење:
Поднизови са сваким самогласником и једним сугласником су:

word[0..5], који је "ieaouq".
word[6..11], који је "qieaou".
word[7..12], који је "ieaouq".

Ограничења:

5 <= word.length <= 250
word се састоји само од малих слова енглеске абецеде.
0 <= k <= word.length - 5

Дат вам је низ word и не-негативан цео број k. Вратите укупан број поднизова низа word који садрже сваки самогласник ('a', 'e', 'i', 'o', и 'u') барем једном и тачно k сугласника.

Пример 1:

Улаз: word = "aeioqq", k = 1
Излаз: 0
Објашњење:
Не постоји подстринг са сваким самогласником.

Пример 2:

Улаз: word = "aeiou", k = 0
Излаз: 1
Објашњење:
Једини подстринг са сваким самогласником и нула сугласника је word[0..4], који је "aeiou".

Пример 3:

Улаз: word = "ieaouqqieaouqq", k = 1
Излаз: 3
Објашњење:
Подстрингови са сваким самогласником и једним сугласником су:

word[0..5], који је "ieaouq".
word[6..11], који је "qieaou".
word[7..12], који је "ieaouq".

Ограничења:

5 <= word.length <= 250
word се састоји само од малих слова енглеске абецеде.
0 <= k <= word.length - 5

Дате вам је реч низа и ненегативан цео број к.
Врати укупан број поднизова речи који садрже сваки самогласник ('a', 'e', 'i', 'o', и 'u') најмање једном и тачно к сугласника.

Пример 1:

Улаз: word = "aeioqq", k = 1
Излаз: 0
Објашњење:
Не постоји подниз са сваким самогласником.

Пример 2:

Улаз: word = "aeiou", k = 0
Излаз: 1
Објашњење:
Једини подниз са сваким самогласником и нултим сугласницима је реч [0..4], што је "аеиоу".

Пример 3:

Улаз: word = "ieaouqqieaouqq", k = 1
Излаз: 3
Објашњење:
Поднизови са сваким самогласником и једним сугласником су:

word[0..5], што је "ieaouq".
word[6..11]], што је "qieaou".
word[7..12], што је "ieaouq".

Ограничења:

5 <= word.length <= 250
реч се састоји само од малих енглеских слова.
0 <= k <= word.length - 5


Дат вам је низ целих бројева nums величине 3.
Вратите највећи могући број чија се бинарна репрезентација може формирати спајањем бинарних репрезентација свих елемената у nums у неком редоследу.
Имајте у виду да бинарна репрезентација било ког броја не садржи водеће нуле.

Пример 1:

Улаз: nums = [1,2,3]
Излаз: 30
Објашњење:
Конкатенишите бројеве у редоследу [3, 1, 2] да бисте добили резултат "11110", што је бинарни запис броја 30.

Пример 2:

Улаз: nums = [2,8,16]
Излаз: 1296
Објашњење:
Конкатенишите бројеве у редоследу [2, 8, 16] да бисте добили резултат "10100010000", што је бинарни запис броја 1296.

Ограничења:

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

Дат вам је низ целих бројева nums величине 3.
Вратите максималан могући број чија бинарна репрезентација може бити формиран конкатенацијом бинарних репрезентација свих елемената у nums у неком редоследу.
Напомена да бинарна репрезентација било ког броја не садржи водеће нуле.

Пример 1:

Улаз: nums = [1,2,3]
Излаз: 30
Објашњење:
Конкатенишите бројеве у редоследу [3, 1, 2] да бисте добили резултат "11110", што је бинарни запис броја 30.

Пример 2:

Улаз: nums = [2,8,16]
Излаз: 1296
Објашњење:
Конкатенишите бројеве у редоследу [2, 8, 16] да бисте добили резултат "10100010000", што је бинарни запис броја 1296.

Ограничења:

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

Дат вам је низ целих бројева величине 3.
Врати максимални могући број чија се бинарна репрезентација може формирати спајањем бинарног приказа свих елемената у бројевима у неком редоследу.
Имајте на уму да бинарни приказ било ког броја не садржи водеће нуле.

Пример 1:

Улаз: nums = [1,2,3]
Излаз: 30
Објашњење:
Спојите бројеве у редоследу [3, 1, 2] да бисте добили резултат „11110“, који је бинарни приказ броја 30.

Пример 2:

Улаз: nums = [2,8,16]
Излаз: 1296
Објашњење:
Спојите бројеве у редоследу [2, 8, 16] да бисте добили резултат „10100010000“, који је бинарни приказ 1296.

Ограничења:

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


Дат је цели бројни низ nums дужине n и цели бројни низ queries.
Нека gcdPairs означава низ добијен израчунавањем НЗД свих могућих парова (nums[i], nums[j]), где је 0 <= i < j < n, а затим сортирањем тих вредности у растућем редоследу.
За сваки upit queries[i], потребно је пронаћи елемент на индексу queries[i] у gcdPairs.
Вратите цели бројни низ answer, где је answer[i] вредност gcdPairs[queries[i]] за сваки упит.
Термин gcd(a, b) означава највећи заједнички делилац од a и b.

Пример 1:

Улаз: nums = [2,3,4], queries = [0,2,2]
Излаз: [1,2,2]
Објашњење:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Након сортирања у растућем редоследу, gcdPairs = [1, 1, 2].
Дакле, одговор је [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Пример 2:

Улаз: nums = [4,4,2,1], queries = [5,3,1,0]
Излаз: [4,2,1,1]
Објашњење:
gcdPairs сортиран у растућем редоследу је [1, 1, 1, 2, 2, 4].

Пример 3:

Улаз: nums = [2,2], queries = [0,0]
Излаз: [2,2]
Објашњење:
gcdPairs = [2].

Ограничења:

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

Дат вам је низ целих бројева дужине н и низ упита целих бројева.
Нека гцдПаирс означи низ добијен израчунавањем НЗД (највећег заједничког делиоца) свих могућих парова (нумс[и], нумс[ј]), где је 0 <= и < ј < н, а затим сортирањем ових вредности у растућем ред.
За сваки упит куериес[и], потребно је пронаћи елемент у индексу куериес[и] у низу гцдПаирс.
Врати одговор низа целог броја, где је ансвер[и] вредност у индексу гцдПаирс[куериес[и]] за сваки упит.
Термин гцд(а, б) означава највећи заједнички делилац бројева а и б.

Пример 1:

Улаз: бројеви = [2,3,4], упити = [0,2,2]
Излаз: [1,2,2]
Објашњење:
гцдПаирс = [гцд(бројеви[0], бројеви[1]), гцд(бројеви[0], бројеви[2]), гцд(бројеви[1], бројеви[2])] = [1, 2, 1].
Након сортирања у растућем редоследу, гцдПаирс = [1, 1, 2].
Дакле, одговор је [гцдПаирс[куериес[0]], гцдПаирс[куериес[1]], гцдПаирс[куериес[2]]] = [1, 2, 2].

Пример 2:

Улаз: бројеви = [4,4,2,1], упити = [5,3,1,0]
Излаз: [4,2,1,1]
Објашњење:
гцдПаирс, сортирани у растућем редоследу, је [1, 1, 1, 2, 2, 4].

Пример 3:

Улаз: бројеви = [2,2], упити = [0,0]
Излаз: [2,2]
Објашњење:
гцдПаирс = [2].

Ограничења:
2 <= н == нумс.ленгтх <= 10^5
1 <= бројеви[и] <= 5 * 10^4
1 <= куериес.ленгтх <= 10^5
0 <= упити[и] < н * (н - 1) / 2

Дат је низ цели бројни nums дужине n и цели бројни низ queries.
Нека gcdPairs означава низ добијен израчунавањем GCD свих могућих парова (nums[i], nums[j]), где је 0 <= i < j < n, а затим сортирањем тих вредности у растућем редоследу.
За сваки upit queries[i], потребно је пронаћи елемент на индексу queries[i] у gcdPairs.
Вратите цели бројни низ answer, где је answer[i] вредност gcdPairs[queries[i]] за сваки упит.
Термин gcd(a, b) означава највећи заједнички делилац од a и b.

Пример 1:

Улаз: nums = [2,3,4], queries = [0,2,2]
Излаз: [1,2,2]
Објашњење:
gcdPairs = [gcd(nums[0], nums[1]), gcd(nums[0], nums[2]), gcd(nums[1], nums[2])] = [1, 2, 1].
Након сортирања у растућем редоследу, gcdPairs = [1, 1, 2].
Дакле, одговор је [gcdPairs[queries[0]], gcdPairs[queries[1]], gcdPairs[queries[2]]] = [1, 2, 2].

Пример 2:

Улаз: nums = [4,4,2,1], queries = [5,3,1,0]
Излаз: [4,2,1,1]
Објашњење:
gcdPairs сортиран у растућем редоследу је [1, 1, 1, 2, 2, 4].

Пример 3:

Улаз: nums = [2,2], queries = [0,0]
Излаз: [2,2]
Објашњење:
gcdPairs = [2].

Ограничења:

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


Дат је низ целих бројева `nums`.
Замените сваки елемент у `nums` са збиром његових цифара.
Вратите минимални елемент у `nums` након свих замена.

Пример 1:

Улаз: nums = [10,12,13,14]
Излаз: 1
Објашњење:
`nums` постаје [1, 3, 4, 5] након свих замена, са минималним елементом 1.

Пример 2:

Улаз: nums = [1,2,3,4]
Излаз: 1
Објашњење:
`nums` постаје [1, 2, 3, 4] након свих замена, са минималним елементом 1.

Пример 3:

Улаз: nums = [999,19,199]
Излаз: 10
Објашњење:
`nums` постаје [27, 10, 19] након свих замена, са минималним елементом 10.

Ограничења:

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

Дат је низ целих бројева nums.
Замените сваки елемент у nums са сумом његових цифара.
Вратите минимални елемент у nums након свих замена.

Пример 1:

Улаз: nums = [10,12,13,14]
Излаз: 1
Објашњење:
nums постаје [1, 3, 4, 5] након свих замена, са минималним елементом 1.

Пример 2:

Улаз: nums = [1,2,3,4]
Излаз: 1
Објашњење:
nums постаје [1, 2, 3, 4] након свих замена, са минималним елементом 1.

Пример 3:

Улаз: nums = [999,19,199]
Излаз: 10
Објашњење:
nums постаје [27, 10, 19] након свих замена, са минималним елементом 10.

Ограничења:

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

Дат вам је целобројни низ бројева.
Сваки елемент у бројевима замењујете збиром његових цифара.
Вратите минимални елемент у бројевима након свих замена.

Пример 1:

Улаз: nums = [10,12,13,14]
Излаз: 1
Објашњење:
нумс постаје [1, 3, 4, 5] након свих замена, са минималним елементом 1.

Пример 2:

Улаз: nums = [1,2,3,4]
Излаз: 1
Објашњење:
нумс постаје [1, 2, 3, 4] након свих замена, са минималним елементом 1.

Пример 3:

Улаз: nums = [999,19,199]
Излаз: 10
Објашњење:
нумс постаје [27, 10, 19] након свих замена, са минималним елементом 10.

Ограничења:

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


Дат вам је низ maximumHeight, где maximumHeight[i] означава максималну висину коју i-ти торањ може имати.
Ваш задатак је да доделите висину сваком торњу тако да:

Висина i-тог торња буде позитиван цео број и да не прелази maximumHeight[i].
Ниједна два торња немају исту висину.

Вратите највећи могући укупан збир висина торњева. Ако није могуће доделити висине, вратите -1.

Пример 1:

Улаз: maximumHeight = [2,3,4,3]
Излаз: 10
Објашњење:
Можемо доделити висине на следећи начин: [1, 2, 4, 3].

Пример 2:

Улаз: maximumHeight = [15,10]
Излаз: 25
Објашњење:
Можемо доделити висине на следећи начин: [15, 10].

Пример 3:

Улаз: maximumHeight = [2,2,1]
Излаз: -1
Објашњење:
Немогуће је доделити позитивне висине сваком индексу тако да ниједна два торња немају исту висину.

Ограничења:

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

Дат вам је низ maximumHeight, где maximumHeight[i] представља максималну висину која може бити додељена i-тој кули.
Ваш задатак је да додиелите висину свакој кули тако да:

- Висина i-те куле буде позитиван цео број и не пређе maximumHeight[i].
- Није дозвољено да две куле имају исту висину.

Вратите максимални могући укупни збир висина кула. Ако није могуће додијелити висине, вратите -1.

Пример 1:

Улаз: maximumHeight = [2,3,4,3]
Излаз: 10
Објашњење:
Можемо доделити висине на следећи начин: [1, 2, 4, 3].

Пример 2:

Улаз: maximumHeight = [15,10]
Излаз: 25
Објашњење:
Можемо доделити висине на следећи начин: [15, 10].

Пример 3:

Улаз: maximumHeight = [2,2,1]
Излаз: -1
Објашњење:
Немогуће је доделити позитивне висине сваком индексу тако да ниједна два торња немају исту висину.

Ограничења:

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

Дат вам је низ макимумХеигхт, где максимумХеигхт[и] означава максималну висину којој i^th торањ може да се додели.
Ваш задатак је да доделите висину свакој кули тако да:

Висина i^th куле је позитиван цео број и не прелази максималну maximumHeight[i].
Не постоје две куле исте висине.

Врати максималну могућу укупну суму висина торња. Ако није могуће доделити висине, вратите -1.

Пример 1:

Улаз: maximumHeight = [2,3,4,3]
Излаз: 10
Објашњење:
Висине можемо доделити на следећи начин: [1, 2, 4, 3].

Пример 2:

Улаз: maximumHeight = [15,10]
Излаз: 25
Објашњење:
Висине можемо доделити на следећи начин: [15, 10].

Пример 3:

Улаз: maximumHeight = [2,2,1]
Излаз: -1
Објашњење:
Немогуће је доделити позитивне висине сваком индексу тако да нема две куле исте висине.

Ограничења:

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