Дат вам је низ целих бројева hours који представљају време у сатима. Вратите целобројну вредност која означава број парова i, j где је i < j и где је hours[i] + hours[j] број који чини комплетан дан.
Комплетан дан је дефинисан као временски период који је тачан вишеструки од 24 сата.
На пример, 1 дан је 24 сата, 2 дана је 48 сати, 3 дана је 72 сата, и тако даље.

Пример 1:

Улаз: hours = [12,12,30,24,24]
Излаз: 2
Објашњење:
Парови индекса који чине цео дан су (0, 1) и (3, 4).

Пример 2:

Улаз: hours = [72,48,24,3]
Излаз: 3
Објашњење:
Парови индекса који чине цео дан су (0, 1), (0, 2) и (1, 2).

Ограничења:

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

Дат је низ целих бројева hours који представљају времена у часовима, вратите цео број који означава број парова i, j где је i < j и hours[i] + hours[j] чини цео дан.
Цео дан се дефинише као временско трајање које је тачан вишеструки од 24 сата.
На пример, 1 дан је 24 сата, 2 дана је 48 сати, 3 дана су 72 сата, итд.

Пример 1:

Улаз: hours = [12,12,30,24,24]
Излаз: 2
Објашњење:
Парови индекса који чине цео дан су (0, 1) и (3, 4).

Пример 2:

Улаз: hours = [72,48,24,3]
Излаз: 3
Објашњење:
Парови индекса који чине цео дан су (0, 1), (0, 2) и (1, 2).

Ограничења:

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

Дат вам је низ целих бројева hours који представљају време у сатима. Вратите цео број који означава број парова i, j где је i < j и hours[i] + hours[j]чини комплетан дан.
Комплетан дан је дефинисан као временски период који је тачан вишеструки од 24 сата.
На пример, 1 дан је 24 сата, 2 дана је 48 сати, 3 дана је 72 сата и тако даље.

Пример 1:

Улаз: hours = [12,12,30,24,24]
Излаз: 2
Објашњење:
Парови индекса који чине цео дан су (0, 1) и (3, 4).

Пример 2:

Улаз: hours = [72,48,24,3]
Излаз: 3
Објашњење:
Парови индекса који чине цео дан су (0, 1), (0, 2) и (1, 2).

Ограничења:

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


Маг има разне чаролије.
Дата вам је низ power, где сваки елемент представља штету чаролије. Више чаролија може имати исту вредност штете.
Познато је да ако маг одлучи да баци чаролију са штетом power[i], не може бацити чаролију са штетом power[i] - 2, power[i] - 1, power[i] + 1 или power[i] + 2.
Свака чаролија може се бацити само једном.
Вратите максималну могућу укупну штету коју маг може нанети.

Пример 1:

Улаз: power = [1,1,3,4]
Излаз: 6
Објашњење:
Максимална могућа штета од 6 се добија бацањем чаролија 0, 1, 3 са штетом 1, 1, 4.

Пример 2:

Улаз: power = [7,1,6,6]
Излаз: 13
Објашњење:
Максимална могућа штета од 13 се добија бацањем чаролија 1, 2, 3 са штетом 1, 6, 6.

Ограничења:

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

Магичар има различите чаролија.
Дат вам је низ `power`, где сваки елемент представља штету чаролија. више чаролија може имати исту вредност штете.
Познато је да ако магичар одлучи да изведе чинију са штетом power[i], не може извести чинију са штетом power[i] - 2, power[i] - 1, power[i] + 1 или power[i] + 2.
Свака чинија може бити изведена само једном.
Вратите максималну могућу укупну штету коју магичар може извршити.

Пример 1:

Улаз: power = [1,1,3,4]
Излаз: 6
Објашњење:
Максимална могућа штета од 6 се добија бацањем чаролија 0, 1, 3 са штетом 1, 1, 4.

Пример 2:

Улаз: power = [7,1,6,6]
Излаз: 13
Објашњење:
Максимална могућа штета од 13 се добија бацањем чаролија 1, 2, 3 са штетом 1, 6, 6.

Ограничења:

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

Маг има различите чаролије.
Дата вам је низ power, где сваки елемент представља штету чаролије. Више чаролија може имати исту вредност штете.
Познато је да ако маг одлучи да баци чаролију са штетом power[i], не може бацити чаролију са штетом power[i] - 2, power[i] - 1, power[i] + 1 или power[i] + 2.
Свака чаролија може бити бачена само једном.
Вратите максималну могућу укупну штету коју маг може направити.

Пример 1:

Улаз: power = [1,1,3,4]
Излаз: 6
Објашњење:
Максимална могућа штета од 6 се добија бацањем чаролија 0, 1, 3 са штетом 1, 1, 4.

Пример 2:

Улаз: power = [7,1,6,6]
Излаз: 13
Објашњење:
Максимална могућа штета од 13 се добија бацањем чаролија 1, 2, 3 са штетом 1, 6, 6.

Ограничења:

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


Пик у низу arr је елемент који је већи од свог претходног и следећег елемента у arr.
Дат је целобројни низ nums и 2D целобројни низ queries.
Потребно је обрадити упите два типа:

queries[i] = [1, l_i, r_i], одредити број пик елемената у поднизу nums[l_i..r_i].
queries[i] = [2, index_i, val_i], променити nums[index_i] у val_i.

Вратити низ answer који садржи резултате упита првог типа по редоследу.
Напомене:

Први и последњи елемент низа или подниза не могу бити пик.

Пример 1:

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

Пример 2:

Унос: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Излаз: [0,1]
Објашњење:
Први упит: nums[2] би требало да постане 4, али је већ постављен на 4.
Други упит: Број пикова у [4,1,4] је 0.
Трећи упит: Друго 4 је пик у [4,1,4,2,1].

Ограничења:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 или queries[i][0] == 2
За све i где:

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

Врх у низу низа је елемент који је већи од свог претходног и следећег елемента у Арру.
Добили сте низа целих бројева и 2D низ упита.
Морате да обрађујете упите две врсте:

queries[i] = [1, l_i, r_i], одредити врх елемената у поднизу nums[l_i..r_i].
queries[i] = [2, index_i, val_i], променити nums[index_i] у val_i.

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

Први и последњи елемент низа или Субараја не могу бити врхунац.

Пример 1:

Улаз: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Излаз: [0]
Објашњење:
Први упит: мењамо nums[3] у 4 и nums постаје [3,1,4,4,5].
Други упит: Број врхова у [3,1,4,4,5] је 0.

Пример 2:

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

Ограничења:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 или queries[i][0] == 2
За све i где:

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

Пик у низу arr је елемент који је већи од свог претходног и следећег елемента у arr.
Дат је целобројни низ nums и 2D целобројни низ queries.
Потребно је обрадити упите два типа:

queries[i] = [1, l_i, r_i], одредити број пик елемената у поднизу nums[l_i..r_i].
queries[i] = [2, index_i, val_i], променити nums[index_i] у val_i.

Врати се низ answer који садржи резултате упита првог типа по редоследу.
Напомене:

Први и последњи елемент низа или подниза не могу бити пик.

Пример 1:

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

Пример 2:

Улаз: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Излаз: [0,1]
Објашњење:
Први упит: nums[2] би требало да постане 4, али је већ постављен на 4.
Други упит: Број пикова у [4,1,4] је 0.
Трећи упит: Друго 4 је пик у [4,1,4,2,1].

Ограничења:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 или queries[i][0] == 2
За све i где:

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


Имате низ реалних бројева averages који је иницијално празан. Дат вам је низ nums од n целих бројева где је n паран.
Понављате следећу процедуру n / 2 пута:

Уклоните најмањи елемент, minElement, и највећи елемент maxElement, из nums.
Додајте (minElement + maxElement) / 2 у averages.

Вратите најмањи елемент из averages.

Пример 1:

Улаз: nums = [7,8,3,4,15,13,4,1]
Излаз: 5.5
Објашњење:

| корак | nums        | averages  |
|-------|-------------|-----------|
| 0     | [7,8,3,4,15,13,4,1] | []        |
| 1     | [7,8,3,4,13,4]      | [8]       |
| 2     | [7,8,4,4]           | [8,8]     |
| 3     | [7,4]               | [8,8,6]   |
| 4     | []                  | [8,8,6,5.5]|

Најмањи елемент из averages, 5.5, је враћен.

Пример 2:

Улаз: nums = [1,9,8,3,10,5]
Излаз: 5.5
Објашњење:

| корак | nums        | averages  |
|-------|-------------|-----------|
| 0     | [1,9,8,3,10,5] | []        |
| 1     | [9,8,3,5]      | [5.5]     |
| 2     | [8,5]          | [5.5,6]   |
| 3     | []             | [5.5,6,6.5]|

Пример 3:

Улаз: nums = [1,2,3,7,8,9]
Излаз: 5.0
Објашњење:

| корак | nums        | averages  |
|-------|-------------|-----------|
| 0     | [1,2,3,7,8,9] | []        |
| 1     | [2,3,7,8]      | [5]       |
| 2     | [3,7]          | [5,5]     |
| 3     | []             | [5,5,5]   |

Ограничења:

2 <= n == nums.length <= 50
n је паран.
1 <= nums[i] <= 50

Имате низ реалних бројева averages који је иницијално празан. Дат вам је низ nums од n целих бројева где је n паран.
Понављате следећу процедуру n / 2 пута:

Уклоните најмањи елемент, minElement, и највећи елемент maxElement, из nums.
Додајте (minElement + maxElement) / 2 у averages.

Вратите најмањи елемент из averages.

Пример 1:

Улаз: nums = [7,8,3,4,15,13,4,1]
Излаз: 5.5
Објашњење:

корак
nums
averages

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

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

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

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

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

Најмањи елемент из averages, 5.5, је враћен.

Пример 2:

Улаз: nums = [1,9,8,3,10,5]
Излаз: 5.5
Објашњење:

корак
nums
averages

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

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

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Пример 3:

Улаз: nums = [1,2,3,7,8,9]
Излаз: 5.0
Објашњење:

корак
nums
averages

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

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

2
[3,7]
[5,5]

3
[]
[5,5,5]

Ограничења:

2 <= n == nums.length <= 50
n је паран.
1 <= nums[i] <= 50

Имате низ реалних бројева averages који је иницијално празан. Дат вам је низ целих бројева nums дужине n, где је n парано.
Понављате следећу процедуру n / 2 пута:

Уклоните најмањи елемент, minElement, и највећи елемент, maxElement, из nums.
Додајте (minElement + maxElement) / 2 у averages.

Вратите најмањи елемент у averages.
Пример 1:

Улаз: nums = [7,8,3,4,15,13,4,1]
Излаз: 5.5
Објашњење:

| корак | nums        | averages  |
|-------|-------------|-----------|
| 0     | [7,8,3,4,15,13,4,1] | []        |
| 1     | [7,8,3,4,13,4]      | [8]       |
| 2     | [7,8,4,4]           | [8,8]     |
| 3     | [7,4]               | [8,8,6]   |
| 4     | []                  | [8,8,6,5.5]|

Најмањи елемент из averages, 5.5, је враћен.

Пример 2:

Улаз: nums = [1,9,8,3,10,5]
Излаз: 5.5
Објашњење:

| корак | nums        | averages  |
|-------|-------------|-----------|
| 0     | [1,9,8,3,10,5] | []        |
| 1     | [9,8,3,5]      | [5.5]     |
| 2     | [8,5]          | [5.5,6]   |
| 3     | []             | [5.5,6,6.5]|

Пример 3:

Улаз: nums = [1,2,3,7,8,9]
Излаз: 5.0
Објашњење:

| корак | nums        | averages  |
|-------|-------------|-----------|
| 0     | [1,2,3,7,8,9] | []        |
| 1     | [2,3,7,8]      | [5]       |
| 2     | [3,7]          | [5,5]     |
| 3     | []             | [5,5,5]   |

Ограничења:

2 <= n == nums.length <= 50
n је паран.
1 <= nums[i] <= 50


Дата вам је 2D бинарни низ `grid`. Нађите правоугаоник са хоризонталним и вертикалним странама са најмањом површином, тако да сви елементи са вредношћу 1 у `grid` леже унутар тог правоугаоника. Вратите минималну могућу површину правоугаоника.

Пример 1:

Улаз: `grid = [[0,1,0],[1,0,1]]`
Излаз: `6`
Објашњење:

Најмањи правоугаоник има висину 2 и ширину 3, тако да има површину 2 * 3 = 6.

Пример 2:

Улаз: `grid = [[1,0],[0,0]]`
Излаз: `1`
Објашњење:

Најмањи правоугаоник има и висину и ширину 1, тако да његова површина износи 1 * 1 = 1.

Ограничења:

1 <= `grid.length`, `grid[i].length` <= 1000
`grid[i][j]` је или 0 или 1.
Улаз је тако генерисан да у `grid` постоји бар један елемент са вредношћу 1.

Дат вам је 2Д бинарни низ grid. Треба да пронађете правоаграни са хоризонталним и вертикалним странама најмањег подручја, тако да све јединице у grid леже унутар овог правоугластог облика.

Вратите минималну могућу површину тог правоугластог облика.

Пример 1:

Улаз: grid = [[0,1,0],[1,0,1]]
Излаз: 6
Објашњење:

Најмањи правоугаоник има висину 2 и ширину 3, тако да има површину 2 * 3 = 6.

Пример 2:

Улаз: grid = [[1,0],[0,0]]
Излаз: 1
Објашњење:

Најмањи правоугаоник има и висину и ширину 1, тако да његова површина износи 1 * 1 = 1.

Ограничења:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] је или 0 или 1.
Улаз је тако генерисан да у grid постоји бар један елемент са вредношћу 1.

Дат вам је дводимензионални бинарни низ grid. Пронађите правоугаоник са хоризонталним и вертикалним странама са најмањом површином, тако да се сви елементи са вредношћу 1 у grid налазе унутар тог правоугаоника.
Вратите минимално могућу површину тог правоугаоника.

Пример 1:

Улаз: grid = [[0,1,0],[1,0,1]]
Излаз: 6
Објашњење:

Најмањи правоугаоник има висину 2 и ширину 3, тако да има површину 2 * 3 = 6.

Пример 2:

Улаз: grid = [[1,0],[0,0]]
Излаз: 1
Објашњење:

Најмањи правоугаоник има и висину и ширину 1, тако да његова површина износи 1 * 1 = 1.

Ограничења:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] is either 0 or 1.
Улаз је тако генерисан да у grid постоји бар један елемент са вредношћу 1.


Дат вам је низ целих бројева nums дужине n.
Трошак подниза nums[l..r], где је 0 <= l <= r < n, дефинисан је као:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Ваш задатак је да поделите nums у поднизове тако да је укупна цена поднизова максимизована, осигуравајући да сваки елемент припада тачно једном поднизу.
Формално, ако је nums подељен на k поднизова, где је k > 1, на индексима i_1, i_2, ..., i_k − 1, где је 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, онда ће укупан трошак бити:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Вратите цео број који означава максимални укупан трошак поднизова након што се низ оптимално подели.
Напомена: Ако nums није подељен на поднизове, тј. k = 1, укупни трошак је једноставно cost(0, n - 1).

Пример 1:

Улаз: nums = [1,-2,3,4]
Излаз: 10
Објашњење:
Један начин да се максимизира укупан трошак је да се [1, -2, 3, 4] подели на поднизове [1, -2, 3] и [4]. Укупан трошак ће бити (1 + 2 + 3) + 4 = 10.

Пример 2:

Улаз: nums = [1,-1,1,-1]
Излаз: 4
Објашњење:
Један начин да се максимизира укупан трошак је да се [1, -1, 1, -1] подели на поднизове [1, -1] и [1, -1]. Укупан трошак ће бити (1 + 1) + (1 + 1) = 4.

Пример 3:

Улаз: nums = [0]
Излаз: 0
Објашњење:
Не можемо даље поделити низ, па је одговор 0.

Пример 4:

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

Ограничења:

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

Дат вам је низ целих бројева дужине n.
Трошак подниза nums[l..r], где је 0 <= l <= r < n, дефинисан је као:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Ваш задатак је да поделите бројеве у поднизе тако да укупна цена подниза буде максимизирана, обезбеђујући да сваки елемент припада тачно једном поднизу.
Формално, ако је нумс подељен на к поднизова, где је k > 1, на индексима i_1, i_2, ..., i_k − 1, где је 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, онда ће укупан трошак бити:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Врати цео број који означава максималну укупну цену поднизова након што се низ оптимално подели.
Напомена: Ако nums није подељен на поднизове, тј. k = 1, укупни трошак је једноставно cost(0, n - 1).

Пример 1:

Улаз: nums = [1,-2,3,4]
Излаз: 10
Објашњење:
Један начин да се максимизира укупан трошак је да се [1, -2, 3, 4] подели на поднизове [1, -2, 3] и [4]. Укупан трошак ће бити (1 + 2 + 3) + 4 = 10.

Пример 2:

Улаз: nums = [1,-1,1,-1]
Излаз: 4
Објашњење:
Један од начина да се максимизира укупни трошак је цепањем [1, -1, 1, -1] у поднисе [1, -1] и [1, -1]. Укупан трошак ће бити (1 + 1) + (1 + 1) = 4.

Пример 3:

Улаз: nums = [0]
Излаз: 0
Објашњење:
Не можемо даље да делимо низ, тако да је одговор 0.

Пример 4:

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

Ограничења:

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

Дат вам је низ целих бројева nums дужине n.
Трошак подниза nums[l..r], где је 0 <= l <= r < n, дефинисан је као:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Ваш задатак је да поделите nums на поднизове тако да се укупни трошак поднизова максимизује, осигуравајући да сваки елемент припада тачно једном поднизу.
Формално, ако је nums подељен на k поднизова, где је k > 1, на индексима i_1, i_2, ..., i_k − 1, где је 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, онда ће укупан трошак бити:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Вратите цео број који означава максимални укупан трошак поднизова након што се низ оптимално подели.
Напомена: Ако nums није подељен на поднизове, тј. k = 1, укупни трошак је једноставно cost(0, n - 1).

Пример 1:

Улаз: nums = [1,-2,3,4]
Излаз: 10
Објашњење:
Један начин да се максимизира укупан трошак је да се [1, -2, 3, 4] подели на поднизове [1, -2, 3] и [4]. Укупан трошак ће бити (1 + 2 + 3) + 4 = 10.

Пример 2:

Улаз: nums = [1,-1,1,-1]
Излаз: 4
Објашњење:
Један начин да се максимизира укупан трошак је да се [1, -1, 1, -1] подели на поднизове [1, -1] и [1, -1]. Укупан трошак ће бити (1 + 1) + (1 + 1) = 4.

Пример 3:

Улаз: nums = [0]
Излаз: 0
Објашњење:
Не можемо даље поделити низ, па је одговор 0.

Пример 4:

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

Ограничења:

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


Дана су вам два цела броја red и blue, који представљају број црвених и плавих лопти.
Потребно је да распоредите ове лопте тако да формирате троугао, где ће у 1. реду бити 1 лопта, у 2. реду 2 лопте, у 3. реду 3 лопте, и тако даље.
Све лопте у одређеном реду треба да буду исте боје, а суседни редови треба да имају различите боје.
Вратите максималну висину троугла која се може постићи.

Пример 1:

Улаз: red = 2, blue = 4
Излаз: 3
Објашњење:

Једини могући распоред је приказан изнад.

Пример 2:

Улаз: red = 2, blue = 1
Излаз: 2
Објашњење:

Једини могући распоред је приказан изнад.

Пример 3:

Улаз: red = 1, blue = 1
Излаз: 1

Пример 4:

Улаз: red = 10, blue = 1
Излаз: 2
Објашњење:

Једини могући распоред је приказан изнад.

Ограничења:

1 <= red, blue <= 100

Дат вам је два цела броја, red и blue, који представљају број црвених и плавих лопти. Треба да распоредите ове лопте тако да формирате троугао, где ће 1^ви имати 1 лопту, 2^ги ће имати 2 лопте, 3^ћи ће имати 3 лопте, и тако даље.
Све лопте у одређеном реду треба да буду исте боје, а суседни редови треба да имају различите боје.
Вратите максималну висину троугла која може да се постигне.

Пример 1:

Улаз: red = 2, blue = 4
Излаз: 3
Објашњење:

Једини могући распоред је приказан изнад.

Пример 2:

Улаз: red = 2, blue = 1
Излаз: 2
Објашњење:

Једини могући распоред је приказан изнад.

Пример 3:

Улаз: red = 1, blue = 1
Излаз: 1

Пример 4:

Улаз: red = 10, blue = 1
Излаз: 2
Објашњење:

Једини могући распоред је приказан изнад.

Ограничења:

1 <= red, blue <= 100

Дају вам се два цела броја црвени и плави који представљају број црвених и плавих лоптица. Морате да поређате ове куглице тако да формирају троугао тако да ће први ред имати 1 лопту, други ред ће имати 2 лопте, трећи ред ће имати 3 лопте, и тако даље.
Све лопте у одређеном реду треба да буду исте боје, а суседни редови треба да имају различите боје.
Вратите максималну висину троугла која се може постићи.

Пример 1:

Улаз: red = 2, blue = 4
Излаз: 3
Објашњење:

Једини могући аранжман је приказан изнад.

Пример 2:

Улаз: red = 2, blue = 1
Излаз: 2
Објашњење:

Једини могући аранжман је приказан изнад.

Пример 3:

Улаз: red = 1, blue = 1
Излаз: 1

Пример 4:

Улаз: red = 10, blue = 1
Излаз: 2
Објашњење:

Једини могући аранжман је приказан изнад.

Ограничења:

1 <= red, blue <= 100


Dati su vam celobrojni niz `nums`.
Podsekvenca `sub` niza `nums` sa dužinom `x` se naziva validnom ako zadovoljava:

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

Vratite dužinu najduže validne podsekvence niza `nums`.
Podsekvenca je niz koji se može dobiti iz drugog niza brisanjem nekih ili svih elemenata bez menjanja redosleda preostalih elemenata.

Пример 1:

Улаз: nums = [1,2,3,4]
Излаз: 4
Објашњење:
Најдужи важећи подниз је [1, 2, 3, 4].

Пример 2:

Улаз: nums = [1,2,1,1,2,1,2]
Излаз: 6
Објашњење:
Најдужи важећи подниз је [1, 2, 1, 2, 1, 2].

Пример 3:

Улаз: nums = [1,3]
Излаз: 2
Објашњење:
Најдужи важећи подниз је [1, 3].

Ограничења:

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

Добијате целобројни низ nums.
Подниз sub низа nums са дужином x се назива важећим ако испуњава:

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

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

Пример 1:

Улаз : nums = [1,2,3,4]
излаз : 4
Објашњење:
Најдужа важећа подниз је [1, 2, 3, 4].

Пример 2:

Улаз : nums = [1,2,1,1,2,1,2]
излаз : 6
Објашњење:
Најдужа важећа подниз је [1, 2, 1, 2, 1, 2].

Пример 3:

Улаз : nums = [1,3]
излаз : 2
Објашњење:
Најдужа важећа подниз је [1, 3].

Ограничења:

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

Дат је цео бројевни низ nums.
Подниз sub низа nums са дужином x се назива важећим ако испуњава:

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

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

Пример 1:

Улаз: nums = [1,2,3,4]
Излаз: 4
Објашњење:
Најдужи важећи подниз је [1, 2, 3, 4].

Пример 2:

Улаз: nums = [1,2,1,1,2,1,2]
Излаз: 6
Објашњење:
Најдужи важећи подниз је [1, 2, 1, 2, 1, 2].

Пример 3:

Улаз: nums = [1,3]
Излаз: 2
Објашњење:
Најдужи важећи подниз је [1, 3].

Ограничења:

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


Постоје два неусмерена дрвета са n и m чворова, нумерисана од 0 до n - 1 и од 0 до m - 1, респективно. Дате су вам две 2D целобројне матрице edges1 и edges2 дужине n - 1 и m - 1, респективно, где је edges1[i] = [a_i, b_i] показатељ да постоји грана између чворова a_i и b_i у првом дрвету и edges2[i] = [u_i, v_i] показатељ да постоји грана између чворова u_i и v_i у другом дрвету.
Морате повезати један чвор из првог дрвета са другим чвором из другог дрвета са граном.
Вратите најмањи могући пречник резултујућег дрвета.
Пречник дрвета је дужина најдужег пута између било која два чвора у дрвету.

Пример 1:

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

Пример 2:

Улаз: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Излаз: 5
Објашњење:
Можемо добити дрво пречника 5 повезивањем чвора 0 из првог дрвата са чвором 0 из другог дрвета.

Ограничења:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Улазни подаци су генерисани тако да edges1 и edges2 представљају ваљно дрво.

Постоје два неусмерена стабла са n и m чворова, нумерисана од 0 до n - 1 и од 0 до m - 1, респективно. Дате су вам две 2D целобројне матрице edges1 и edges2 дужине n - 1 и m - 1, респективно, где је edges1[i] = [a_i, b_i] показатељ да постоји грана између чворова a_i и b_i у првом стаблу и edges2[i] = [u_i, v_i] показатељ да постоји грана између чворова u_i и v_i у другом стаблу.
Морате повезати један чвор из првог стабла са другим чвором из другог стабла са граном.
Вратите најмањи могући пречник резултујућег стабла.
Пречник стабла је дужина најдужег пута између било која два чвора у стаблу.

Пример 1:

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

Пример 2:

Улаз: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Излаз: 5
Објашњење:
Стабло пречника 5 можемо добити повезивањем чвора 0 из првог стабла са чвором 0 из другог стабла.

Ограничења:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Улаз се генерише тако да ивице1 и ивице2 представљају важећа стабла.

Постоје два неусмерена стабла са n и m чворова, нумерисана од 0 до n - 1 и од 0 до m - 1, респективно. Дате су вам две 2D целобројне матрице edges1 и edges2 дужине n - 1 и m - 1, респективно, где је edges1[i] = [a_i, b_i] показатељ да постоји грана између чворова a_i и b_i у првом стаблу и edges2[i] = [u_i, v_i] показатељ да постоји грана између чворова u_i и v_i у другом стаблу.
Морате повезати један чвор из првог стабла са другим чвором из другог стабла са ивицом.
Вратите минимални могући пречник добијеног стабла.
Пречник стабла је дужина најдужег пута између било која два чвора у стаблу.

Пример 1:

Улаз : edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
излаз : 3
Објаљњење:
Можемо добити дрво пречника 3 повезивањем чвора 0 из првог стабла са било којим чвором из другог стабла.

Пример 2:

Улаз : edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
излаз : 5
Објаљњење:
Можемо добити стабло пречника 5 повезивањем чвора 0 из првог стабла са чвором 0 из другог стабла.

Ограничења:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Улаз се генерише тако да edges1 и edges2 представљају валидна стабла.


Evo prevoda na srpski jezik:

Date su vam string s i celobrojni k. Enkriptujte string koristeći sledeći algoritam:

Za svaki karakter c u s, zamenite c sa k-tim karakterom koji se nalazi nakon c u stringu (u cikličnom obliku).

Vratite enkriptovani string.

Пример 1:

Улаз: s = "dart", k = 3
Излаз: "tdar"
Објашњење:

За i = 0, 3-ти знак после 'd' је 't'.
За i = 1, 3-ти знак после 'a' је 'd'.
За i = 2, 3-ти знак после 'r' је 'a'.
За i = 3, 3-ти знак после 't' је 'r'.

Пример 2:

Улаз: s = "aaa", k = 1
Излаз: "aaa"
Објашњење:
Како су сви знакови исти, шифровани низ ће такође бити исти.

Ограничења:

1 <= s.дужина <= 100
1 <= k <= 10^4
s se sastoji samo od malih engleskih slova.

Дат вам је низ s и цео број к. Шифрујте стринг користећи следећи алгоритам:

За сваки знак c у s, замените c к^-тим знаком после c у низу (на цикличан начин).

Вратите шифровани стринг.

Пример 1:

Улаз: s = "dart", k = 3
Излаз: "tdar"
Објашњење:

За i = 0, 3-ти знак после 'd' је 't'.
За i = 1, 3-ти знак после 'a' је 'd'.
За i = 2, 3-ти знак после 'r' је 'a'.
За i = 3, 3-ти знак после 't' је 'r'.

Пример 2:

Улаз: s = "aaa", k = 1
Излаз: "ааа"
Објашњење:
Пошто су сви знакови исти, шифровани низ ће такође бити исти.

Ограничења:

1 <= s.дужина <= 100
1 <= k <= 10^4
s се састоји само од малих енглеских слова.

Дат вам је низ s и цео број k. Шифрујте низ користећи следећи алгоритам:

За свако слово c у низу s, замените c са k-тим словом после c у низу (на цикличан начин).

Вратите шифровани низ.

Пример 1:

Улаз: s = "dart", k = 3
Излаз: "tdar"
Објашњење:

За i = 0, 3-ти знак после 'd' је 't'.
За i = 1, 3-ти знак после 'a' је 'd'.
За i = 2, 3-ти знак после 'r' је 'a'.
За i = 3, 3-ти знак после 't' је 'r'.

Пример 2:

Улаз: s = "aaa", k = 1
Излаз: "aaa"
Објашњење:
Како су сви знакови исти, шифровани низ ће такође бити исти.

Ограничења:

1 <= s.дужина <= 100
1 <= k <= 10^4
s се састоји само од малих енглеских слова.


Дат вам је позитиван целобројни n.
Бинарни низ x је важећи ако сваки подниз x дужине 2 садржи барем један "1".
Вратите све важеће низове дужине n, у било ком редоследу.

Пример 1:

Улаз: n = 3
Излаз: ["010","011","101","110","111"]
Објашњење:
Важећи низови дужине 3 су: "010", "011", "101", "110" и "111".

Пример 2:

Улаз: n = 1
Излаз: ["0","1"]
Објашњење:
Важећи низови дужине 1 су: "0" и "1".

Ограничења:

1 <= n <= 18

Дајете позитиван цели број n.
Бинарни стринг x важи ако све субстрингови дужине 2 дужине 2 садрже најмање један "1".
Вратите све Важећи стрингови дужине Н, у било којем редоследу.

Пример 1:

Улаз: n = 3
Излаз: ["010", "011", "101", "110", "111"]
Објашњење:
Важеће стринг дужине 3 су: "010", "011", "101", "110" и "111".

Пример 2:

Улаз: n = 1
Излаз: ["0", "1"]
Објашњење:
Валидни стрингови дужине 1 су: "0" и "1".

Ограничења:

1 <= n <= 18

Дат је позитиван цео број n.
Бинарни низ x је важећи ако сви поднизи од x дужине 2 садрже барем једну "1".
Вратите све важеће низове дужине n, било којим редоследом.

Пример 1:

Улаз: n = 3
Излаз: ["010","011","101","110","111"]
Објашњење:
Ваљни низови дужине 3 су: "010", "011", "101", "110" и "111".

Пример 2:

Улаз: n = 1
Излаз: ["0","1"]
Објашњење:
Ваљни низови дужине 1 су: "0" и "1".

Ограничења:

1 <= n <= 18


Датa je 2D matrica karaktera grid, gde je grid[i][j] ili 'X', 'Y', ili '.', vratite broj podmatrica koje sadrže:

grid[0][0]
jednaku frekvenciju 'X' i 'Y'.
barem jedan 'X'.

Primer 1:

Ulaz: grid = [["X","Y","."],["Y",".","."]]
Izlaz: 3
Objašnjenje:

Primer 2:

Ulaz: grid = [["X","X"],["X","Y"]]
Izlaz: 0
Objašnjenje:
Nijedna podmatrica nema jednaku frekvenciju 'X' i 'Y'.

Primer 3:

Ulaz: grid = [[".","."],[".","."]]
Izlaz: 0
Objašnjenje:
Nijedna podmatrica nema barem jedan 'X'.

Ograničenja:

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

Датa je 2D матрикс карактера grid, gde je grid[i][j] ili 'X', 'Y', ili '.', вратите број подматрица које садрже:

grid[0][0]
једнаку учесталост 'X' и 'Y'.
најмање један 'X'.

Пример 1:

Улаз: grid = [["X","Y","."],["Y",".","."]]
Излаз: 3
Објашњење:

Пример 2:

Улаз: grid = [["X","X"],["X","Y"]]
Излаз: 0
Објашњење:
Нема подматрица које имају једнаку учесталост 'X' и 'Y'.

Пример 3:

Улаз: grid = [[".","."],[".","."]]
Излаз: 0
Објашњење: Нема подматрица које садрже бар један 'X'.

Ограничења:

1 ≤ grid.length, grid[i].length ≤ 1000
grid[i][j] је или 'X', 'Y', или '.'.

Датa je 2D matrica karaktera grid, gde je grid[i][j] ili 'X', 'Y', ili '.', vratite broj podmatrica koje sadrže:

grid[0][0]
једнаку фреквенцију 'X' и 'Y'.
најмање једно 'X'.

Пример 1:

Улаз: grid = [["X","Y","."],["Y",".","."]]
Излаз: 3
Објашњење:

Пример 2:

Улаз: grid = [["X","X"],["X","Y"]]
Излаз: 0
Објашњење:
Ниједна подматрица нема једнаку фреквенцију 'X' и 'Y'.

Пример 3:

Улаз: grid = [[".","."],[".","."]]
Излаз: 0
Објашњење:
Ниједна подматрица нема бар један 'X'.

Ограничења:

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


Дат је стринг target, низ стрингова words и низ целих бројева costs, при чуму су оба низа исте дужине.
Замислите празан стринг s.
Можете извршити следећу операцију било који број пута (укључујући нулу):

Изаберите индекс i у опсегу [0, words.length - 1].
Додајте words[i] у s.
Трошак операције је costs[i].

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

Пример 1:

Улаз: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Излаз: 7
Објашњење:
Минимални трошак се може постићи извођењем следећих операција:

Изаберите индекс 1 и додајте "abc" у s са трошком од 1, резултује s = "abc".
Изаберите индекс 2 и додајте "d" у s са трошком од 1, резултује s = "abcd".
Изаберите индекс 4 и додајте "ef" у s са трошком од 5, резултује s = "abcdef".

Пример 2:

Улаз: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Излаз: -1
Објашњење:
Немогуће је да s постане једнако target, па враћамо -1.

Ограничења:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Укупна сума words[i].length је мања или једнака 5 * 10^4.
target и words[i] се састоје само од малих енглеских слова.
1 <= costs[i] <= 10^4

Дат вам је циљ стрингова, низ речи низа и цена низа целих бројева, оба низа исте дужине.
Замислите празан низ s.
Можете извршити следећу операцију било који број пута (укључујући нулу):

Изаберите индекс i у опсегу [0, words.length - 1].
Додајте words[i] у s.
Трошкови рада су costs[i].

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

Пример 1:

Улаз: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Излаз: 7
Објашњење:
Минимални трошак се може постићи извођењем следећих операција:

Изаберите индекс 1 и додајте "abc" у с по цени од 1, што резултира s = "abc".
Изаберите индекс 2 и додајте "d" на с по цени од 1, што резултира s = "abcd".
Изаберите индекс 4 и додајте "ef" на с по цени од 5, што резултира s = "abcdef".

Пример 2:

Улаз: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Излаз: -1
Објашњење:
Немогуће је учинити с једнаким циљу, па враћамо -1.

Ограничења:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Укупан збир words[i].length је мањи или једнак 5 * 10^4.
циљ и words[i] се састоје само од малих слова енглеског језика.
1 <= costs[i] <= 10^4

Дата је ниска target, низ ниски words и низ целих бројева costs, оба низа исте дужине.

Замислите празну ниску s.

Можете извршити следећу операцију било који број пута (укључујући нулу):

Изаберите индекс i у опсегу [0, words.length - 1].
Додајте words[i] у s.
Трошак операције је costs[i].

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

Пример 1:

Улаз: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Излаз: 7
Објашњење:
Минимални трошак се може постићи извођењем следећих операција:

Изаберите индекс 1 и додајте "abc" у s са трошком од 1, резултује s = "abc".
Изаберите индекс 2 и додајте "d" у s са трошком од 1, резултује s = "abcd".
Изаберите индекс 4 и додајте "ef" у s са трошком од 5, резултује s = "abcdef".

Пример 2:

Улаз: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Излаз: -1
Објашњење:
Немогуће је да s постане једнако target, па враћамо -1.

Ограничења:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Укупна сума words[i].length је мања или једнака 5 * 10^4.
target и words[i] се састоје само од малих енглеских слова.
1 <= costs[i] <= 10^4


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

Цифре имају исти паритет ако су обе непарне или обе парне. На пример, 5 и 9, као и 2 и 4, имају исти паритет, док 6 и 9 немају.

Пример 1:

Улаз: s = "45320"
Излаз: "43520"
Објашњење:
s[1] == '5' и s[2] == '3' имају исти паритет, и замена њих резултује лексикографски најмањом ниском.

Пример 2:

Улаз: s = "001"
Излаз: "001"
Објашњење:
Нема potrebe за извођењем размене јер је s већ лексикографски најмањи.

Ограничења:

2 <= s.length <= 100
s се састоји само од цифара.

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

Цифре имају исти паритет ако су обе непарне или обе парне. На пример, 5 и 9, као и 2 и 4, имају исти паритет, док 6 и 9 немају.

Пример 1:

Улаз: s = "45320"
Излаз: "43520"
Објашњење:
s[1] == '5' и s[2] == '3' имају исти паритет, и њихова замена резултује лексикографски најмањом ниском.

Пример 2:

Улаз: s = "001"
Излаз: "001"
Објашњење:
Нема потребе за свапом јер је s већ лексикографски најмања.

Ограничења:

2 <= s.length <= 100
s се састоји само од цифара.

Дата је ниска s која садржи само цифре. Вратите лексикографски најмању ниску која се може добити након што се у s барима са истим паритетом изврши замена суседних цифара највише једном.
Цифре имају исти паритет ако су оба непарна или су оба парна. На пример, 5 и 9, као и 2 и 4, имају исти паритет, док 6 и 9 немају.

Пример 1:

Улаз : с = "45320"
Излаз : "43520"
Објаљњење:
с[1 ] = = '5' и с[2] = = '3' оба имају исти паритет, а њихова замена резултира лексикографски најмањим низом.

Пример 2:

Улаз : с = "001"
Излаз : "001"
Објаљњење:
Нема потребе за извођењем замене јер је с већ лексикографски најмањи.

Ограничења:

2 <= s.length <= 100
с се састоји само од цифара.


Постоји тортa величине m x n која треба да се исече на 1 x 1 делове.
Дати су вам цели бројеви m, n и два низа:

horizontalCut величине m - 1, где horizontalCut[i] представља трошак резања дуж хоризонталне линије i.
verticalCut величине n - 1, где verticalCut[j] представља трошак резања дуж вертикалне линије j.

У једној операцији, можете изабрати било који комад торте који још није 1 x 1 квадрат и извршити један од следећих резова:

Резање дуж хоризонталне линије i по цени horizontalCut[i].
Резање дуж вертикалне линије j по цени verticalCut[j].

Након резања, комад торте се дели на два различита комада.
Трошак реза зависи само од почетног трошка линије и не мења се.
Вратите минимални укупни трошак да се цела торта исече на 1 x 1 делове.

Пример 1:

Улаз: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Излаз: 13
Објашњење:

Извршите рез на вертикалној линији 0 са трошком 5, тренутни укупни трошак је 5.
Извршите рез на хоризонталној линији 0 на 3 x 1 подматрици са трошком 1.
Извршите рез на хоризонталној линији 0 на 3 x 1 подматрици са трошком 1.
Извршите рез на хоризонталној линији 1 на 2 x 1 подматрици са трошком 3.
Извршите рез на хоризонталној линији 1 на 2 x 1 подматрици са трошком 3.

Укупан трошак је 5 + 1 + 1 + 3 + 3 = 13.

Пример 2:

Улаз: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Излаз: 15
Објашњење:

Извршите рез на хоризонталној линији 0 са трошком 7.
Извршите рез на вертикалној линији 0 на 1 x 2 подматрици са трошком 4.
Извршите рез на вертикалној линији 0 на 1 x 2 подматрици са трошком 4.

Укупан трошак је 7 + 4 + 4 = 15.

Ограничења:

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

Постоји м к н колач који треба исећи на 1 к 1 комаде.
Дати су вам цели бројеви м, н и два низа:

хоризонталЦут величине м - 1, где хоризонталЦут[и] представља цену сечења дуж хоризонталне линије и.
вертицалЦут величине н - 1, где вертицалЦут[ј] представља цену сечења дуж вертикалне линије ј.

У једној операцији, можете одабрати било који комад торте који још није квадрат 1 к 1 и извршити један од следећих резова:

Исеците дуж хоризонталне линије и по цени хоризонталЦут[и].
Исеците дуж вертикалне линије ј по цени од вертицалЦут[ј].

Након реза, комад торте се дели на два различита дела.
Цена реза зависи само од почетне цене линије и не мења се.
Вратите минимални укупни трошак за сечење целе торте на 1 к 1 комад.

Пример 1:

Улаз: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Излаз: 13
Објашњење:

Извршите рез на вертикалној линији 0 са ценом 5, тренутни укупни трошак је 5.
Извршите рез на хоризонталној линији 0 на дел 3 к 1 са ценом 1.
Извршите рез на хоризонталној линији 0 на дел 3 к 1 са ценом 1.
Извршите рез на хоризонталној линији 1 на дел 2 к 1 са ценом 3.
Извршите рез на хоризонталној линији 1 на дел 2 к 1 са ценом 3.

Укупан трошак је 5 + 1 + 1 + 3 + 3 = 13.

Пример 2:

Улаз: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Излаз: 15
Објашњење:

Извршите рез на хоризонталној линији 0 са ценом 7.
Извршите рез на вертикалној линији 0 на дел 1 к 2 са ценом 4.
Извршите рез на вертикалној линији 0 на дел 1 к 2 са ценом 4.

Укупна цена је 7 + 4 + 4 = 15.

Ограничења:

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

Имамо торту величине m x n која треба да се исече на комаде величине 1 x 1. Дати су целобројни m, n, и два низа:

- horizontalCut величине m - 1, где horizontalCut[i] представља цену резања по хоризонталној линији i.
- verticalCut величине n-1, где verticalCut[j] представља цену резања по вертикалној линији j.

У једној операцији, можете изабрати било који део торте који још није 1 x 1 квадрат и извршити један од следећих резова:

- Резање по хоризонталној линији i по цени horizontalCut[i].
- Резање по вертикалној линији j по цени verticalCut[j].

Након резања, део торте се дели на два различита дела. Цена резања зависи само од почетне цене линије и не мења се.

Вратите минималну укупну цену засецања целе торте на 1 x 1 комаде.

Пример 1:

Улаз:
m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Излаз: 13
Објашњење:

1. Изврши резање по вертикалној линији 0 са ценом 5, тренутни укупни трошак је 5.
2. Изврши резање по хоризонталној линији 0 на 3 x 1 подгрид са ценом 1.
3. Изврши резање по хоризонталној линији 0 на 3 x 1 подгрид са ценом 1.
4. Изврши резање по хоризонталној линији 1 на 2 x 1 подгрид са ценом 3.
5. Изврши резање по хоризонталној линији 1 на 2 x 1 подгрид са ценом 3.

Укупни трошак је 5 + 1 + 1 + 3 + 3 = 13.

Пример 2:

Улаз:
m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Излаз: 15
Објашњење:

1. Изврши резање по хоризонталној линији 0 са ценом 7.
2. Изврши резање по вертикалној линији 0 на 1 x 2 подгрид са ценом 4.
3. Изврши резање по вертикалној линији 0 на 1 x 2 подгрид са ценом 4.

Укупни трошак је 7 + 4 + 4 = 15.

Ограничења:

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


Дати су вам два позитивна цела броја n и k.
Можете изабрати било који бит у бинарном приказу броја n који је једнак 1 и променити га у 0.
Вратите број промена потребних да n постане једнак k. Ако је немогуће, вратите -1.

Пример 1:

Улаз: n = 13, k = 4
Излаз: 2
Објашњење:
Првобитно, бинарни прикази n и k су n = (1101)_2 и k = (0100)_2.
Можемо променити први и четврти бит броја n. Резултујући број је n = (0100)_2 = k.

Пример 2:

Улаз: n = 21, k = 21
Излаз: 0
Објашњење:
n и k су већ једнаки, тако да промене нису потребне.

Пример 3:

Улаз: n = 14, k = 13
Излаз: -1
Објашњење:
Није могуће да n постане једнак k.

Ограничења:

1 <= n, k <= 10^6

Дата су вам два позитивна цела броја n и k.
Можете одабрати било који бит у бинарној представи н који је једнак 1 и променити га на 0.
Врати број промена потребних да би n било једнако k. Ако је немогуће, вратите -1.

Пример 1:

Улаз: n = 13, k = 4
Излаз: 2
Објашњење:
У почетку, бинарни прикази n и k су n = (1101) и k = (0100)_2.
Можемо да променимо први n четврти бит од н. Добијени цео број је n = (0100)_2 = k.

Пример 2:

Улаз: n = 21, k = 21
Излаз: 0
Објашњење:
n и k су већ једнаки, тако да нису потребне промене.

Пример 3:

Улаз: n = 14, k = 13
Излаз: -1
Објашњење:
Није могуће учинити n једнаким k.

Ограничења:

1 <= n, k <= 10^6

Дати су вам два позитивна цела броја n и k.
Можете изабрати било који бит у бинарној представи броја n који је једнак 1 и променити га у 0.
Вратите број потребних измена да би n постао једнак k. Ако то није могуће, вратите -1.

Пример 1:

Улаз: n = 13, k = 4
Излаз: 2
Објашњење:
Првобитно, бинарни прикази n и k су n = (1101)_2 и k = (0100)_2.
Можемо променити први и четврти бит броја n. Резултујући број је n = (0100)_2 = k.

Пример 2:

Улаз: n = 21, k = 21
Излаз: 0
Објашњење:
n и k су већ једнаки, тако да промене нису потребне.

Пример 3:

Улаз: n = 14, k = 13
Излаз: -1
Објашњење:
Није могуће да n постане једнак k.

Ограничења:

1 <= n, k <= 10^6


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

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

Први играч који не може да направи потез на свом потезу губи игру. Претпостављамо да и Алисе и Боб играју оптимално.
Вратите true ако Алице победи игру, а false у супротном.
Енглески самогласници су: а, е, и, о и у.

Пример 1:

Унос: s = "leetcoder"
Излаз: true
Објашњење:
Алисе може победити у игри на следећи начин:

Алисе игра прва, може избрисати подвучени подниз у s = "leetcoder" који садржи 3 самогласника. Резултујући низ је s = "der".
Боб игра други, може избрисати подвучени подниз у s = "der" који садржи 0 самогласника. Резултујући низ је s = "er".
Алисе игра трећа, може избрисати цео низ s = "er" који садржи 1 самогласник.
Боб игра четврти, пошто је низ празан, нема важећег потеза за Боба. Тако да Алисе побеђује у игри.

Пример 2:

Унос: s = "bbcd"
Излаз: false
Објашњење:
Нема важећег потеза за Алису у њеном првом потезу, тако да Алисе губи игру.

Ограничења:

1 <= s.length <= 10^5
s се састоји само од енглеских малих слова.

Алице и Боб играју игру на низу.
Дат вам је низ s, Алиса и Боб ће наизменично играти следећу игру где Алиса прва почиње:

На пotezu Алице мора да уклони било које непразно подстринг од С која садржи непаран број самогласника.
На Бобовом пotezu мора да уклони било које непразно подстринг од С која садржи парни број самогласника.

Први играч који не може да крене на њихов потез изгуби игру. Претпостављамо да су и Алице и Боб оптимално играли.
Вратите ТРУЕ ако Алице побјеђује у игри и лажно иначе.
Енглески самогласници су: a, e, i, o и u.

Пример 1:

Унос: s = "leetcoder"
Излаз: true
Објашњење:
Алице може освојити игру на следећи начин:

Алице игра прво, она може да избрише подвучено подстринг у =  "leetcoder" који садржи 3 самогласника. Добијени низ је с = "der".
Боб игра друго, може да избрише подвучено подстринг у S = der" који садржи 0 самогласника. Добијени низ је s = "er".
Алице игра треће, она може да избрише цео низ s = "er". која садржи 1 самогласник.
Боб игра четврту, јер је низ празан, не постоји валидна игра за Боба. Тако Алице побјеђује у игри.

Пример 2:

Унос: s = "bbcd"
Излаз: false
Објашњење:
Нема важеће игре за Алице у свом првом кораку, па Алице изгуби игру.

Ограничења:

1 <= s.length <= 10^5
s се састоји само од енглеских малих слова.

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

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

Први играч који не може да направи потез на свом потезу губи игру. Претпостављамо да и Алиса и Боб играју оптимално.
Вратите true ако Алиса побеђује у игри, а false у супротном.
Енглески самогласници су: a, e, i, o и u.

Пример 1:

Улаз: s = "leetcoder"
Излаз: true
Објашњење:
Алиса може победити у игри на следећи начин:

Алиса игра прва, она може да обрише подвучени подниз у s = "leetcoder" који садржи 3 самогласника. Добијен низ је s = "der".
Боб игра други, он може да обрише подвучени подниз у s = "der" који садржи 0 самогласника. Добијен низ је s = "er".
Алиса игра трећа, она може да обрише цео низ s = "er" који садржи 1 самогласник.
Боб игра четврти, пошто је низ празан, нема ваљаног потеза за Боба. Тако Алиса побеђује у игри.

Пример 2:

Улаз: s = "bbcd"
Излаз: false
Објашњење:
Нема ваљног потеза за Алису у њеном првом потезу, тако да Алиса губи игру.

Ограничења:

1 <= s.length <= 10^5
s се састоји само од енглеских малих слова.


Дат вам je бинарни низ s.
Можете извршити следећу операцију на низу било који број пута:

Изаберите било који индекс i из низа где је i + 1 < s.length такo да s[i] == '1' и s[i + 1] == '0'.
Померите карактер s[i] удесно док не дође до краја низа или другог '1'.

На пример, за s = "010010", ако изаберемо i = 1, резултујући низ ће бити s = "000110".

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

Пример 1:

Улаз: s = "1001101"
Излаз: 4
Објашњење:
Можемо извршити следеће операције:

Изаберите индекс i = 0. Резултујући низ је s = "0011101".
Изаберите индекс i = 4. Резултујући низ је s = "0011011".
Изаберите индекс i = 3. Резултујући низ је s = "0010111".
Изаберите индекс i = 2. Резултујући низ је s = "0001111".

Пример 2:

Улаз: s = "00111"
Излаз: 0

Ограничења:

1 <= s.length <= 10^5
s[i] је или '0' или '1'.

Дат вам је бинарни низ s.

Можете извршити следећу операцију на низу било који број пута:

Изаберите било који индекс i из низа где је i + 1 < s.length такo да s[i] == '1' и s[i + 1] == '0'.
Померите карактер s[i] удесно док не дође до краја низа или другог '1'.

На пример, за s = "010010", ако изаберемо i = 1, резултујући низ ће бити s = "000110".

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

Пример 1:

Улаз: s = "1001101"
Излаз: 4
Објашњење:
Можемо извршити следеће операције:

Изаберите индекс i = 0. Резултујући низ је s = "0011101".
Изаберите индекс i = 4. Резултујући низ је s = "0011011".
Изаберите индекс i = 3. Резултујући низ је s = "0010111".
Изаберите индекс i = 2. Резултујући низ је s = "0001111".

Пример 2:

Улаз: s = "00111"
Излаз: 0

Ограничења:

1 <= s.length <= 10^5
s[i] је или '0' или '1'.

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

Изаберите било који индекс i из стринга где је i + 1 < s.дужина тако да је s[i] == '1' и s[i + 1] == '0'.
Померите знак s[i] удесно док не дође до краја низа или другог '1'. На пример, за s = "010010", ако изаберемо i = 1, резултујући низ ће бити s = "000110".

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

Пример 1:

Улаз: s = "1001101"
Излаз: 4
Објашњење:
Можемо извршити следеће операције:

Изаберите индекс i = 0. Добијени низ је s = "0011101".
Изаберите индекс i = 4. Добијени низ је s = "0011011".
Изаберите индекс i = 3. Добијени низ је s = "0010111".
Изаберите индекс i = 2. Добијени низ је s = "0001111".

Пример 2:

Улаз: s = "00111"
Излаз: 0

Ограничења:

1 <= s.length <= 10^5
s[i] је или '0' или '1'.


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

Пример 1:

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

Пример 2:

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

Ограничења:

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

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

Пример 1:

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

Пример 2:

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

Ограничења:

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

Дате су вам две низa позитивних целих бројева, nums и target, исте дужине.
У једној операцији можете изабрати било који подниз низа nums и повећати или смањити сваки елемент у том поднизу за 1.
Вратите минималан број операција потребних да низ nums постане једнак низу target.

Пример 1:

Улаз: nums = [3,5,1,2], target = [4,6,2,4]
Излаз: 2
Објашњење:
Извршићемо следеће операције да бисмо низ nums изједначили са nizom target:
- Повеће се nums[0..3] за 1, nums = [4,6,2,3].
- Повеће се nums[3..3] за 1, nums = [4,6,2,4].

Пример 2:

Улаз: nums = [1,3,2], target = [2,1,4]
Излаз: 5
Објашњење:
Извршићемо следеће операције да бисмо низ nums изједначили са nizom target:
- Повеће се nums[0..0] за 1, nums = [2,3,2].
- Смање се nums[1..1] за 1, nums = [2,2,2].
- Смање се nums[1..1] за 1, nums = [2,1,2].
- Повеће сеnums[2..2] за 1, nums = [2,1,3].
- Повеће се nums[2..2] за 1, nums = [2,1,4].

Ограничења:

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


Дат вам је низ позитивних целих бројева nums.
Алица и Боб играју игру. У игри, Алица може изабрати или све једноцифрене бројеве или све двоцифрене бројеве из nums, а остатак бројева се даје Бобу. Алица побеђује ако је збир њених бројева строго већи од збира Бобових бројева.
Вратите true ако Алица може да победи у овој игри, иначе вратите false.

Пример 1:

Улаз: nums = [1,2,3,4,10]
Излаз: false
Објашњење:
Алиса не може да победи избором или једноцифрених или двоцифрених бројева.

Пример 2:

Улаз: nums = [1,2,3,4,5,14]
Излаз: true
Објашњење:
Алиса може да победи избором једноцифрених бројева који имају збир 15.

Пример 3:

Улаз: nums = [5,5,5,25]
Излаз: true
Објашњење:
Алица може да победи бирајући двоцифрене бројеве који имају збир једнак 25.

Ограничења:

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

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

Пример 1:

Улаз: nums = [1,2,3,4,10]
Излаз: false
Објашњење:
Алиса не може да победи бирањем једноцифреног или двоцифреног броја.

Пример 2:

Улаз: nums = [1,2,3,4,5,14]
Излаз: true
Објашњење:
Алиса може победити бирајући једноцифрене бројеве који имају збир једнак 15.

Пример 3:

Улаз: nums = [5,5,5,25]
Излаз: true
Објашњење:
Алиса може победити бирајући двоцифрене бројеве који имају збир једнак 25.

Ограничења:

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

Дат вам је низ позитивних целих бројева nums. Алисе и Боб играју игру. У игри, Алисе може да изабере или све једноцифрене бројеве или све двоцифрене бројеве из низа nums, а остали бројеви ће припасти Бобу. Алисе побеђује ако је збир њених бројева строго већи од збира Бобових бројева.
Вратите true ако Алице може да победи у овој игри, иначе вратите false.

Пример 1:

Улаз: nums = [1,2,3,4,10]
Излаз: false
Објашњење:
Алице не може да победи бирајући ни једноцифрене ни двоцифрене бројеве.

Пример 2:

Улаз: nums = [1,2,3,4,5,14]
Излаз: true
Објашњење:
Алице може да победи бирајући једноцифрене бројеве који имају збир једнак 15.

Пример 3:

Улаз: nums = [5,5,5,25]
Излаз: true
Објашњење:
Алице може да победи бирајући двоцифрене бројеве који имају збир једнак 25.

Ограничења:

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


Дате су вам два позитивна цела броја l и r. За било који број x, сви позитивни делиоци од x осим x називају се прави делиоци броја x. Број се назива посебним ако има тачно 2 права делиоца. На пример:

Број 4 је посебан јер има праве делиоце 1 и 2.
Број 6 није посебан јер има праве делиоце 1, 2 и 3.

Вратите број бројева у опсегу [l, r] који нису посебни.

Пример 1:

Улаз: l = 5, r = 7
Излаз: 3
Објашњење:
Нема посебних бројева у опсегу [5, 7].

Пример 2:

Улаз: l = 4, r = 16
Излаз: 11
Објашњење:
Посебни бројеви у опсегу [4, 16] су 4 и 9.

Ограничења:

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

Дају вам 2 позитивна цела броја l и r. За било који број x, све позитивне делитељи x осим x називају се правилним делизорима x.
Број се назива посебним ако има тачно две сопствени делитељи. На пример:

Број 4 је посебан јер има одговарајуће делитељи 1 и 2.
Број 6 није посебан јер има одговарајуће делитељи 1, 2 и 3.

Вратите број бројева у опсегу [l, r] који нису посебни.

Пример 1:

Улаз:  l = 5, r = 7
Излаз: 3
Објашњење:
У опсегу [5, 7] нема посебних бројева.

Пример 2:

Улаз: l = 4, r = 16
Излаз: 11
Објашњење:
Посебни бројеви у опсегу [4, 16] су 4 и 9.

ОГРАНИЧЕЊА:

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

Дат вам је 2 позитивна цела броја l и r. За било који број x, сви позитивни делиоци броја x осим самог x називају се правим делиоцима броја x.
Број се назива специјалан ако има тачно 2 правa делиоца. На пример:

Број 4 је специјалан јер има праве делиоце 1 и 2.
Број 6 није специјалан јер има праве делиоце 1, 2 и 3.

Вратите број бројева у опсегу [l, r] који нису специјални.

Пример 1:

Улаз: l = 5, r = 7
Излаз: 3
Објашњење:
Нема посебних бројева у опсегу [5, 7].

Пример 2:

Улаз: l = 4, r = 16
Излаз: 11
Објашњење:
Посебни бројеви у опсегу [4, 16] су 4 и 9.

Ограничења:

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


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

Пример 1:

Улаз: s = "00011"
Излаз: 5
Објашњење:
Поднизови са доминантним јединицама су приказани у табели испод.

|  i  |  j  |  s[i..j]  |  Број нула  |  Број јединица  |
|-----|-----|-----------|-------------|-----------------|
|  3  |  3  |      1    |      0      |        1        |
|  4  |  4  |      1    |      0      |        1        |
|  2  |  3  |     01    |      1      |        1        |
|  3  |  4  |     11    |      0      |        2        |
|  2  |  4  |    011    |      1      |        2        |

Пример 2:

Улаз: s = "101101"
Излаз: 16
Објашњење:
Поднизови са недоминантним јединицама су приказани у табели испод.
Пошто постоји укупно 21 подниз и 5 њих имају недоминантне јединице, следи да постоји 16 поднизова са доминантним јединицама.

|  i  |  j  |  s[i..j]  |  Број нула  |  Број јединица  |
|-----|-----|-----------|-------------|-----------------|
|  1  |  1  |      0    |      1      |        0        |
|  4  |  4  |      0    |      1      |        0        |
|  1  |  4  |    0110   |      2      |        2        |
|  0  |  4  |   10110   |      2      |        3        |
|  1  |  5  |   01101   |      2      |        3        |

Ограничења:

1 <= s.length <= 4 * 10^4
s се састоји само од знакова '0' и '1'.

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

Пример 1:

Улаз: s = "00011"
Излаз: 5
Објашњење:
Подручје са доминантним јединица приказане су у доњој табели.

i
j
s[i..j]
Број нула
Број оних

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Пример 2:

Улаз: s = "101101"
Излаз: 16
Објашњење:
Подручје са не-доминантним јединица приказане су у доњој табели.
Пошто је у укупно 21 подстринг, а 5 њих има не-доминантне, слиједи да са доминантним има 16 подстицаја.

i
j
s[i..j]
Број нула
Број оних

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Ограничења:

1 <= s.length <= 4 * 10^4
s се састоји само од знакова '0' и '1'.

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

Пример 1:

Улаз: s = "00011"
Излаз: 5
Објашњење:
Подниске са доминантним јединицама су приказане у табели испод.

i
j
s[i..j]
Број нула
Број јединица

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Пример 2:

Улаз: s = "101101"
Излаз: 16
Објашњење:
Подниске са недоминантним јединицама су приказане у табели испод.
Пошто постоји укупно 21 подниску и 5 њих имају недоминантне јединице, следи да постоји 16 поднисака са доминантним јединицама.

i
j
s[i..j]
Број нула
Број јединица

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Ограничења:

1 <= s.length <= 4 * 10^4
s се састоји само од знакова '0' и '1'.


Дати су вам два позитивна цела броја xCorner и yCorner, и 2D низ circles, где circles[i] = [x_i, y_i, r_i] представља круг са центром у (x_i, y_i) и радијусом r_i.
Постоји правоугаоник у координатном систему чији је доњи леви угао на пореклу, а горњи десни угао на координатама (xCorner, yCorner). Треба да проверите да ли постоји пут од доњег левог угла до горњег десног угла, тај пут мора бити унутар правоугаоника, не сме да додирује или буде унутар било ког круга, и додирује правоугаоник само на два угла.
Вратите true ако такав пут постоји, а false у супротном.

Пример 1:

Улаз: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Излаз: true
Објашњење:

Црна крива показује могући пут између (0, 0) и (3, 4).

Пример 2:

Улаз: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Излаз: false
Објашњење:

Пут не постоји од (0, 0) до (3, 3).

Пример 3:

Улаз: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Излаз: false
Објашњење:

Пут не постоји од (0, 0) до (3, 3).

Пример 4:

Улаз: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Излаз: true
Објашњење:

Ограничења:

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

Дати су вам два позитивна цела броја xCorner и yCorner, као и 2D низ circles, где circles[i] = [x_i, y_i, r_i] представља круг са центром на (x_i, y_i) и радијусом r_i.
Постоји правоугаоник на координатној равни чији је доњи леви угао у пореклу, а горњи десни угао на координатама (xCorner, yCorner). Треба да проверите да ли постоји пут од доњег левог угла до горњег десног угла такав да цео пут лежи унутар правоугаоника, не дотиче ниједан круг и дотиче правоугаоник само на два угла.
Вратите true ако такав пут постоји, а false у супротном.

Пример 1:
Улаз: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Излаз: true
Објашњење:
Црна крива показује могући пут између (0, 0) и (3, 4).

Пример 2:
Улаз: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Излаз: false
Објашњење:
Не постоји пут од (0, 0) до (3, 3).

Пример 3:
Улаз: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Излаз: false
Објашњење:
Не постоји пут од (0, 0) до (3, 3).

Пример 4:
Улаз: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Излаз: true
Објашњење:

Ограничења:
3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

Дају вам се два позитивна цела броја xCorner и yCorner, и 2D низ circles, где је circles[i] = [x_i, y_i, r_i] означавају круг са центром у (x_i, y_i) и полупречником r_i.
У координатној равни налази се правоугаоник са доњим левим углом у почетку и горњим десним углом у координати (xCorner, yCorner). Потребно је да проверите да ли постоји путања од доњег левог до горњег десног угла тако да цела путања лежи унутар правоугаоника, да се не додирује или лежи унутар било ког круга и да додирује правоугаоник само у два угла.
Вратите труе ако таква путања постоји и фалсе у супротном.

Пример 1:

Улаз: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Излаз: true
Објашњење:

Црна крива показује могућу путању између (0, 0) и (3, 4).

Пример 2:

Улаз: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Излаз: false
Објашњење:

Не постоји пут од (0, 0) до (3, 3).

Пример 3:

Улаз: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Излаз: false
Објашњење:

Не постоји пут од (0, 0) до (3, 3).

Пример 4:

Улаз: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Излаз: true
Објашњење:

Ограничења:

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


Дат вам је цео број n и 2D низ целих бројева queries.
Постоји n градова који су номиновани од 0 до n - 1. Иницијално, постоји једносмерна пут који води из града i у град i + 1 за све 0 <= i < n - 1.
queries[i] = [u_i, v_i] представља додавање новог једносмерног пута из града u_i у град v_i. Након сваког упита, треба да пронађете дужину најкраћег пута од града 0 до града n - 1.
Вратите низ answer где ће за сваки i у опсегу [0, queries.length - 1], answer[i] бити дужина најкраћег пута од града 0 до града n - 1 након обраде првих i + 1 упита.

Пример 1:

Унос: n = 5, queries = [[2,4],[0,2],[0,4]]
Излаз: [3,2,1]
Објашњење:

Након додавања пута од 2 до 4, дужина најкраће путање од 0 до 4 је 3.

Након додавања пута од 0 до 2, дужина најкраће путање од 0 до 4 је 2.

Након додавања пута од 0 до 4, дужина најкраће путање од 0 до 4 је 1.

Пример 2:

Унос: n = 4, queries = [[0,3],[0,2]]
Излаз: [1,1]
Објашњење:

Након додавања пута од 0 до 3, дужина најкраће путање од 0 до 3 је 1.

Након додавања пута од 0 до 2, дужина најкраће путање остаје 1.

Ограничења:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Нема понављаних путева међу упитима.

Дат је цео број n и 2D низ целих бројева queries.
Постоји n градова нумерисаних од 0 до n - 1. У почетку, постоји једносмеран пут од града i до града i + 1 за све 0 <= i < n - 1.
queries[i] = [u_i, v_i] представља додавање новог једносмерног пута од града u_i до града v_i. Након сваког упита, треба пронаћи дужину најкраће путање од града 0 до града n - 1.
Вратите низ answer где је за свако i у опсегу [0, queries.length - 1], answer[i] дужина најкраће путање од града 0 до града n - 1 након обраде првих i + 1 упита.

Primer 1:

Ulaz: n = 5, queries = [[2,4],[0,2],[0,4]]
Izlaz: [3,2,1]
Objašnjenje::

Nakon dodavanja puta od 2 do 4, dužina najkraće putanje od 0 do 4 je 3.

Nakon dodavanja puta od 0 do 2, dužina najkraće putanje od 0 do 4 je 2.

Nakon dodavanja puta od 0 do 4, dužina najkraće putanje od 0 do 4 je 1.

Primer 2:

Ulaz: n = 4, queries = [[0,3],[0,2]]
Izlaz: [1,1]

Objašnjenje:

Nakon dodavanja puta od 0 do 3, dužina najkraće putanje od 0 do 3 je 1.

Nakon dodavanja puta od 0 do 2, dužina najkraće putanje ostaje 1.

Ограничења:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Нема понављаних путева међу упитима.

Добијате целоброј н и 2D целобројни низ упита.
Постоји н градова нумерисаних од 0 до n - 1. У почетку, постоји једносмерни пут од града и до града i + 1 за све 0 <= i < n - 1.
queries[i] = [u_i, v_i] представља додавање новог једносмерног пута од градске у_и до градске в_и. Након сваког упита, потребно је да пронађете дужину најкраће стазе од града 0 до града n - 1.
Вратите низ answer где је за свако i у опсегу [0, queries.length - 1], answer[i] дужина најкраће путање од града 0 до града n - 1 након обраде првих i + 1 упита.

Пример 1:

Улаз : n = 5, queries = [[2,4],[0,2],[0,4]]
Излаз : [3,2,1]
Објаљњење:

Након додавања пута од 2 до 4, дужина најкраће стазе од 0 до 4 је 3.

Након додавања пута од 0 до 2, дужина најкраће стазе од 0 до 4 је 2.

Након додавања пута од 0 до 4, дужина најкраће стазе од 0 до 4 је 1.

Пример 2:

Улаз : n = 4, queries = [[0,3],[0,2]]
Излаз : [1,1]
Објаљњење:

Након додавања пута од 0 до 3, дужина најкраћег пута од 0 до 3 је 1.

Након додавања пута од 0 до 2, дужина најкраћег пута остаје 1.

Ограничења:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Међу упитима нема поновљених путева.


Постоје црвене и плаве плочице распоређене у кругу. Дат вам је низ целих бројева colors и 2D низ целих бројева queries.
Боја плочице i је представљена са colors[i]:

colors[i] == 0 значи да је плочица i црвена.
colors[i] == 1 значи да је плочица i плава.

Алтернативна група је континуирани подскуп плочица у кругу са алтернативним бојама (свака плочица у групи осим прве и последње има различиту боју од својих суседних плочица у групи). Потребно је обрадити упите две врсте:

queries[i] = [1, size_i], одредите број алтернативних група са величином size_i.
queries[i] = [2, index_i, color_i], промените colors[index_i] на color_i.

Вратите низ answer који садржи резултате упита првог типа по редоследу. Запазите да пошто colors представља круг, прва и последња плочица се сматрају суседним.

Пример 1:

Input: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Output: [2]
Објашњење:

Први упит:
Промените colors[1] у 0.

Други упит:
Број алтернативних група са величином 4:

Пример 2:

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

Први упит:
Број алтернативних група са величином 3:

Други упит: colors се неће променити.
Трећи упит: Нема алтернативне групе са величином 5.

Ограничења:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 или queries[i][0] == 2
За све i то:

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

Постоје неке црвене и плаве плочице распоређене кружно. Дат вам је низ боја целих бројева и упити низа 2D целих бројева.
Боја плочице i је представљена colors[i]:

colors[i] == 0 значи да је плочица i црвена.
colors[i] == 1 значи да је плочица i плава.

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

queries[i] = [1, size_i], одреди број наизменичних група са величином size_i.
queries[i] = [2, index_i, color_i], промените боје [index_i] у color_i.

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

Пример 1:

Улаз: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Излаз: [2]
Објашњење:

Први упит:
Промените colors[1] у 0.

Други упит:
Број наизменичних група величине 4:

Пример 2:

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

Први упит:
Број наизменичних група величине 3:

Други упит: боје се неће променити.
Трећи упит: Не постоји наизменична група величине 5.

Ограничења:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
За све i то:

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

Постоје неке црвене и плаве плочице распоређене кружно. Дат вам је низ боја целих бројева и упити низа 2Д целих бројева.
Боја плочице i је представљена са colors[i]:

colors[i] == 0 значи да је плочица i црвена.
colors[i] == 1 значи да је плочица i плава.

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

queries[i] = [1, size_i], одредите број алтернативних група са величином size_i.
queries[i] = [2, index_i, color_i], промените colors[index_i] на color_i.

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

Пример 1:

Улаз: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Излаз: [2]
Објашњење:

Први упит:
Промените colors[1] у 0.

Други упит:
Број наизменичних група величине 4:

Пример 2:

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

Први упит:
Број наизменичних група величине 3:

Други упит: боје се неће променити.
Трећи упит: Не постоји наизменична група величине 5.

Ограничења:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 или queries[i][0] == 2
За све то:

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


У матрици величине n×n налази се змија која може да се помера у четири могућа правца. Свака ћелија у мрежи идентификована је позицијом: grid[i][j] = (i * n) + j.
Змија почиње у ћелији 0 и прати низ команди.
Дат је цео број n који представља величину мреже и низ стрингова commands где је свака команда[i] или "UP", "RIGHT", "DOWN", или "LEFT". Загарантовано је да ће змија остати унутар граница мреже током кретања.
Вратите позицију финалне ћелије где змија завршава након извршавања команди.

Пример 1:

Улаз: n = 2, commands = ["RIGHT","DOWN"]
Излаз: 3
Објашњење:

0
1

2
3

0
1

2
3

0
1

2
3

Пример 2:

Улаз: n = 3, commands = ["DOWN","RIGHT","UP"]
Излаз: 1
Објашњење:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Ограничења:

2 <= n <= 10
1 <= commands.length <= 100
commands садрже само "UP", "RIGHT", "DOWN", и "LEFT".
Улаз је генерисан тако да змија неће изаћи ван граница.

У матрици величине n x n налази се змија која може да се помера у четири могућа правца. Свака ћелија у матрици је идентификована позицијом: grid[i][j] = (i * n) + j.
Змија почиње у ћелији 0 и прати низ команди.
Дат вам је цео број n који представља величину матрице и низ стрингова команди где свака команда[i] је или "UP", "RIGHT", "DOWN" или "LEFT". Гарантовано је да ће змија остати унутар граница матрице током целог свог кретања.
Вратите позицију последње ћелије у којој се змија завршава након извршавања свих команди.

Пример 1:

Улаз: n = 2, commands = ["RIGHT","DOWN"]
Излаз: 3
Објашњење:

0
1

2
3

0
1

2
3

0
1

2
3

Пример 2:

Улаз: n = 3, commands = ["DOWN","RIGHT","UP"]
Излаз: 1
Објашњење:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Ограничења:

2 <= n <= 10
1 <= commands.length <= 100
команде садрже само "UP", "RIGHT", "DOWN", и "LEFT".
Улаз је генерисан тако да змија неће изаћи ван граница.

Постоји змија у н к н матричној мрежи и може се кретати у четири могућа правца. Свака ћелија у мрежи је идентификована позицијом: grid[i][j] = (i * n) + j.
Змија почиње у ћелији 0 и прати низ команди.
Дат је цео број n који представља величину мреже и низ стрингова commands где је свака команда[i] или "UP", "RIGHT", "DOWN", или "LEFT".Загарантовано је да ће змија остати унутар граница мреже током кретања.
Вратите позицију завршне ћелије где змија завршава након извршавања команди.

Пример 1:

Улаз: n = 2, commands = ["RIGHT","DOWN"]
Излаз: 3
Објашњење:

0
1

2
3

0
1

2
3

0
1

2
3

Пример 2:

Улаз: n = 3, commands = ["DOWN","RIGHT","UP"]
Излаз: 1
Објашњење:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Ограничења:

2 <= n <= 10
1 <= commands.length <= 100
команде садрже само "UP", "RIGHT", "DOWN", и "LEFT".
Улаз се генерише тако да се змија неће померити ван граница.


Дат вам је низ позитивних целих бројева nums дужине n.
Позивамо пар низова целих бројева (arr1, arr2) монотонским ако:

Дужине оба низа су n.
arr1 је монотонски не-опадајући, другим речима, arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 је монотонски не-растајући, другим речима, arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] за све 0 <= i <= n - 1.

Вратите број монотонских парова.
Пошто одговор може бити веома велики, вратите га модуло 10^9 + 7.

Пример 1:

Улаз: nums = [2,3,2]
Излаз: 4
Објашњење:
Добри парови су:

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

Пример 2:

Улаз: nums = [5,5,5,5]
Излаз: 126

Ограничења:

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

Дат вам је низ позитивних целих бројева `nums` дужине `n`.
Позивамо пар низова целих бројева (arr1, arr2) монотонским ако:

Дужине оба низа су `n`.
`arr1` је монотонски не-опадајући, другим речима, `arr1[0] <= arr1[1] <= ... <= arr1[n - 1]`.
`arr2` је монотонски не-растајући, другим речима, `arr2[0] >= arr2[1] >= ... >= arr2[n - 1]`.
`arr1[i] + arr2[i] == nums[i]` за све `0 <= i <= n - 1`.

Вратите број монотонских парова.
Пошто одговор може бити веома велики, вратите га модуло `10^9 + 7`.

Пример 1:

Улаз: nums = [2,3,2]
Излаз: 4
Објашњење:
Добри парови су:

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

Пример 2:

Улаз: nums = [5,5,5,5]
Излаз: 126

Ограничења:

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

Дат вам је низ позитивних целих бројева дужине n.
Пар низова ненегативних целих бројева (arr1, arr2) називамо монотоним ако:

Дужине оба низа су n.
arr1 је монотоно неопадајућа, другим речима, arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 је монотоно не повећава, другим речима, arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] за све 0 <= i <= n - 1.

Врати број монотоних парова.
Пошто одговор може бити веома велики, вратите га по модулу 10^9 + 7.

Пример 1:

Улаз: nums = [2,3,2]
Излаз: 4
Објашњење:
Добри парови су:

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

Пример 2:

Улаз: nums  = [5,5,5,5]
Излаз: 126

Ограничења:

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


Дат вам је низ карактера s.
Ваш задатак је да уклоните све цифре поновљеним извођењем ове операције:

Обришите прву цифру и најближи нецифрени карактер са њене леве стране.

Вратите резултујући низ након што уклоните све цифре.

Пример 1:

Улаз: s = "abc"
Излаз: "abc"
Објашњење:
Нема цифре у стрингу.

Пример 2:

Улаз: s = "cb34"
Излаз: ""
Објашњење:
Прво примењујемо операцију на s[2], и s постаје "c4".
Затим примењујемо операцију на s[1], и s постаје "".

Ограничења:

1 <= s.length <= 100
s се састоји само од малих енглеских слова и цифара.
Улаз је генерисан тако да је могуће избрисати све цифре.

Дата је ниска s.
Ваш задатак је да уклоните све цифре понављајући ову операцију:

Избришите прву цифру и најближи знак који није цифра лево од ње.

Вратите резултујућу ниску након уклањања свих цифри.

Пример 1:

Улаз: s = "abc"
Излаз: "abc"
Објашњење:
Нема цифре у ниској.

Пример 2:

Улаз: s = "cb34"
Излаз: ""
Објашњење:
Прво примењујемо операцију на s[2], и s постаје "c4".
Затим примењујемо операцију на s[1], и s постаје "".

Ограничења:

1 <= s.length <= 100
s се састоји само од малих енглеских слова и цифара.
Улаз је генерисан тако да је могуће избрисати све цифре.

Дат је стринг s.
Ваш задатак је да уклоните све цифре понављајући ову операцију:

Избришите прву цифру и најближи знак који није цифра лево од ње.

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

Пример 1:

Улаз: s = "abc"
Излаз: "abc"
Објашњење:
Нема цифре у стрингу.

Пример 2:

Улаз: s = "cb34"
Излаз: ""
Објашњење:
Прво примењујемо операцију на s[2], и s постаје "c4".
Затим примењујемо операцију на s[1], и s постаје "".

Ограничења:

1 <= s.length <= 100
s се састоји само од малих енглеских слова и цифара.
Улаз је генерисан тако да је могуће избрисати све цифре.


Такмичење се састоји од n играча бројеваних од 0 до n - 1.
Дат вам је низ целих бројева skills дужине n и позитиван цео број k, где је skills[i] ниво вештине играча i. Сви цели бројеви у skills су јединствени.
Сви играчи стоје у реду по редоследу од играча 0 до играча n - 1.
Процес такмичења је следећи:

Прва два играча у реду играју партију, и играч са вишим нивоом вештине побеђује.
Након партије, победник остаје на почетку реда, а губитник иде на крај реда.

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

Пример 1:

Улаз: skills = [4,2,6,3,9], k = 2
Излаз: 2
Објашњење:
У почетку, ред играча је [0,1,2,3,4]. Следећи процес се дешава:

Играч 0 и 1 играју партију, пошто је вештина играча 0 већа од вештине играча 1, играч 0 побеђује. Резултујући ред је [0,2,3,4,1].
Играч 0 и 2 играју партију, пошто је вештина играча 2 већа од вештине играча 0, играч 2 побеђује. Резултујући ред је [2,3,4,1,0].
Играч 2 и 3 играју партију, пошто је вештина играча 2 већа од вештине играча 3, играч 2 побеђује. Резултујући ред је [2,4,1,0,3].

Играч 2 је победио k = 2 партије узастопно, тако да је победник играч 2.

Пример 2:

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

Играч 0 и 1 играју партију, пошто је вештина играча 1 већа од вештине играча 0, играч 1 побеђује. Резултујући ред је [1,2,0].
Играч 1 и 2 играју партију, пошто је вештина играча 1 већа од вештине играча 2, играч 1 побеђује. Резултујући ред је [1,0,2].
Играч 1 и 0 играју партију, пошто је вештина играча 1 већа од вештине играча 0, играч 1 побеђује. Резултујући ред је [1,2,0].

Играч 1 је победио k = 3 партије узастопно, тако да је победник играч 1.

Ограничења:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Сви цели бројеви у skills су јединствени.

Такмичење се састоји од н играча нумерисаних од 0 до n - 1.
Добијате целобројни низ вештина величине н и позитиван цео број к, где је скиллс[и] ниво вештине играча и. Сви цели бројеви у вештинама су јединствени.
Сви играчи стоје у реду по реду од играча 0 до играча n - 1.
Конкурсни процес је следећи:

Прва два играча у реду играју игру, а играч са вишим нивоом вештине побеђује.
Након игре, победник остаје на почетку реда, а губитник иде до краја.

Победник такмичења је први играч који освоји к игара заредом.
Вратите почетни индекс победничког играча.

Пример 1:

Улаз : skills = [4,2,6,3,9], k = 2
излаз : 2
Објаљњење:
У почетку, ред играча је [0,1,2,3,4]. Следећи процес се дешава:

Играчи 0 и 1 играју игру, пошто је вештина играча 0 већа од вештине играча 1, играч 0 побеђује. Добијени ред је [0,2,3,4,1].
Играчи 0 и 2 играју игру, јер је вештина играча 2 већа од вештине играча 0, играч 2 побеђује. Добијени ред је [2,3,4,1,0].
Играчи 2 и 3 играју игру, јер је вештина играча 2 већа од вештине играча 3, играч 2 побеђује. Добијени ред је [2,4,1,0,3].

Играч 2 је освојио к = 2 игре заредом, тако да је победник играч 2.

Пример 2:

Улаз : skills = [2,5,4], k = 3
излаз : 1
Објаљњење:
У почетку, ред играча је [0,1,2]. Следећи процес се дешава:

Играчи 0 и 1 играју игру, пошто је вештина играча 1 већа од вештине играча 0, играч 1 побеђује. Добијени ред је [1,2,0].
Играчи 1 и 2 играју игру, пошто је вештина играча 1 већа од вештине играча 2, играч 1 побеђује. Добијени ред је [1,0,2].
Играчи 1 и 0 играју игру, пошто је вештина играча 1 већа од вештине играча 0, играч 1 побеђује. Добијени ред је [1,2,0].

Играч 1 је освојио к = 3 утакмице заредом, тако да је победник играч 1.

Ограничења:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Сви цели бројеви у вештинама су јединствени.

Такмичење се састоји од n играча који су нумерисани од 0 до n - 1.
Дат вам је низ целих бројева skills дужине n и целобројни број k, где skills[i] представља ниво вештине играча i. Сви елементи у skills су јединствени.
Сви играчи стоје у реду по редоследу од играча 0 до играча n - 1.
Процес такмичења је следећи:

Прва два играча у реду играју иргу, и играч са вишим нивоом вештине побеђује.
Након игре, победник остаје на почетку реда, а губитник иде на крај реда.

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

Пример 1:

Улаз: skills = [4,2,6,3,9], k = 2
Излаз: 2
Објашњење:
У почетку, ред играча је [0,1,2,3,4]. Следећи процес се дешава:

Играч 0 и 1 играју игру, пошто је вештина играча 0 већа од вештине играча 1, играч 0 побеђује. Резултујући ред је [0,2,3,4,1].
Играч 0 и 2 играју игру, пошто је вештина играча 2 већа од вештине играча 0, играч 2 побеђује. Резултујући ред је [2,3,4,1,0].
Играч 2 и 3 играју игру, пошто је вештина играча 2 већа од вештине играча 3, играч 2 побеђује. Резултујући ред је [2,4,1,0,3].

Играч 2 је победио k = 2 игре узастопно, тако да је победник играч 2.

Пример 2:

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

Играч 0 и 1 играју игру, пошто је вештина играча 1 већа од вештине играча 0, играч 1 побеђује. Резултујући ред је [1,2,0].
Играч 1 и 2 играју игру, пошто је вештина играча 1 већа од вештине играча 2, играч 1 побеђује. Резултујући ред је [1,0,2].
Играч 1 и 0 играју игру, пошто је вештина играча 1 већа од вештине играча 0, играч 1 побеђује. Резултујући ред је [1,2,0].

Играч 1 је победио k = 3 игре узастопно, тако да је победник играч 1.

Ограничења:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Сви цели бројеви у skills су јединствени.


Дат вам је низ целих бројева nums и не-негативан целобројни број k. Секвенца целих бројева seq се зове добром ако постоји највише k индекса i у опсегу [0, seq.length - 2] за које важи да је seq[i] != seq[i + 1].
Вратите максималну могућу дужину добре подсеквенце низа nums.

Пример 1:

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

Пример 2:

Унос: nums = [1,2,3,4,5,1], k = 0
Излаз: 2
Објашњење:
Максимални подниз је [1,2,3,4,5,1].

Ограничења:

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

Добијате цео низ нумс и не-негативан цео број к. Низ целих бројева сеq се назива добрим ако постоји највише к индекса и у опсегу [0, seq.length - 2] такав да seq[i] != seq[i + 1].
Вратите максималну могућу дужину добре подсеквенце бројева.

Пример 1:

Улаз : nums = [1,2,1,1,3], к = 2
излаз : 4
Објаљњење:
Максимална дужина подсеквенца је [1,2,1,1,3].

Пример 2:

Улаз : nums = [1,2,3,4,5,1], к = 0
излаз : 2
Објаљњење:
Максимална дужина подсеквенца је [1,2,3,4,5,1].

Ограничења:

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

Дат је низ целих бројева nums и ненегативан цео број k. Низ целих бројева seq се назива добрим ако постоји највише k индекса i у опсегу [0, seq.length - 2] за које је seq[i] != seq[i + 1].
Вратите максималну могућу дужину доброг подниза од nums.

Пример 1:

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

Пример 2:

Улаз: nums = [1,2,3,4,5,1], k = 0
Излаз: 2
Објашњење:
Максимални подниз је [1,2,3,4,5,1].

Ограничења:

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


Дат вам је низ целих бројева nums. У једној операцији можете додати или одузети 1 од било ког елемента низа nums.
Вратите минималан број операција који је потребан да сви елементи низа буду дељиви са 3.

Пример 1:

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

Одузети 1 од 1.
Додати 1 на 2.
Одузети 1 од 4.

Пример 2:

Улаз: nums = [3,6,9]
Излаз: 0

Ограничења:

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

Дат вам је целобројни низ бројева. У једној операцији, можете додати или одузети 1 од било ког елемента бројева.
Вратите минимални број операција да би сви елементи бројева били дељиви са 3.

Пример 1:

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

Одузмите 1 од 1.
Додајте 1 до 2.
Одузми 1 од 4.

Пример 2:

Улаз: бројеви = [3,6,9]
Излаз: 0

Ограничења:

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

Дат је низ целих бројева nums. У једној операцији, можете додати или одузети 1 од било ког елемента низа nums. Вратите минимални број операција да би сви елементи низа nums били дељиви са 3.

Пример 1:

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

Одузети 1 од 1.
Додати 1 на 2.
Одузети 1 од 4.

Пример 2:

Улаз: nums = [3,6,9]
Излаз: 0

Ограничења:

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


Дат вам је бинарни низ nums.
Можете извршити следећу операцију над низом било који број пута (могуће и нула пута):

Изаберите било која 3 узастопна елемента из низа и инвертујте сва три.

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

Пример 1:

Улаз: nums = [0,1,1,1,0,0]
Излаз: 3
Објашњење:
Можемо урадити следеће операције:

Изаберите елементе на индексима 0, 1 и 2. Резултујући низ је nums = [1,0,0,1,0,0].
Изаберите елементе на индексима 1, 2 и 3. Резултујући низ је nums = [1,1,1,0,0,0].
Изаберите елементе на индексима 3, 4 и 5. Резултујући низ је nums = [1,1,1,1,1,1].

Пример 2:

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

Ограничења:

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

Дат вам је бинарни низ nums.
Можете извршити следећу операцију на низу било који број пута (можда и ниједном):

Изаберите било која 3 узастопна елемента из низа и пребаците све њих.

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

Пример 1:

Улаз: nums = [0,1,1,1,0,0]
Излаз: 3
Објашњење:
Можемо урадити следеће операције:

Изаберите елементе на индексима 0, 1 и 2. Резултујући низ је nums = [1,0,0,1,0,0].
Изаберите елементе на индексима 1, 2 и 3. Резултујући низ је nums = [1,1,1,0,0,0].
Изаберите елементе на индексима 3, 4 и 5. Резултујући низ је nums = [1,1,1,1,1,1].

Пример 2:

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

Ограничења:

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

Дат вам је бинарни низ бројева.
Можете да урадите следећу операцију на низу било који број пута (могуће нула):

Изаберите било која 3 узастопна елемента из низа и окрените их све.

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

Пример 1:

Улаз: nums = [0,1,1,1,0,0]
Излаз: 3
Објашњење:
Можемо да урадимо следеће операције:

Изаберите елементе са индексима 0, 1 и 2. Добијени низ је nums = [1,0,0,1,0,0].
Изаберите елементе са индексима 1, 2 и 3. Добијени низ је nums = [1,1,1,0,0,0].
Изаберите елементе са индексима 3, 4 и 5. Добијени низ је nums = [1,1,1,1,1,1].

Пример 2:

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

Ограничења:

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


Дат вам је цео број n и 2D низ requirements, где је requirements[i] = [end_i, cnt_i] представљен крајњи индекс и број инверзија сваког захтева. Пар индекса (i, j) из целобројног низа nums назива се инверзијом ако:

i < j и nums[i] > nums[j]

Вратите број пермутација perm од [0, 1, 2, ..., n - 1] тако да за све requirements[i], perm[0..end_i] има тачно cnt_i инверзија.
Пошто одговор може бити веома велики, вратите га модуло 10^9 + 7.

Пример 1:

Input: n = 3, requirements = [[2,2],[0,0]]
Output: 2
Објашњење:
Две пермутације су:

[2, 0, 1]

Префикс [2, 0, 1] има инверзије (0, 1) и (0, 2).
Префикс [2] има 0 инверзија.

[1, 2, 0]

Префикс [1, 2, 0] има инверзије (0, 2) и (1, 2).
Префикс [1] има 0 инверзија.

Пример 2:

Input: n = 3, requirements = [[2,2],[1,1],[0,0]]
Output: 1
Објашњење:
Једина задовољавајућа пермутација је [2, 0, 1]:

Префикс [2, 0, 1] има инверзије (0, 1) и (0, 2).
Префикс [2, 0] има инверзију (0, 1).
Префикс [2] има 0 инверзија.

Пример 3:

Input: n = 2, requirements = [[0,0],[1,0]]
Output: 1
Објашњење:
Једина задовољавајућа пермутација је [0, 1]:

Префикс [0] има 0 инверзија.
Префикс [0, 1] има инверзију (0, 1).

Ограничења:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
Улаз је генерисан тако да постоји бар један i такав да је end_i == n - 1.
Улаз је генерисан тако да су сви end_i јединствени.

Дат вам је цео број н и захтеви 2Д низа, где requirements[i] = [end_i, cnt_i] представљају крајњи индекс и број инверзије сваког захтева.
Пар индекса (i, j) из низа целих бројева назива се инверзија ако:

i < j and nums[i] > nums[j]

Врати број пермутација перм од [0, 1, 2, ..., n - 1] тако да за све requirements[i], perm[0..end_i] има тачно cnt_i инверзије.
Пошто одговор може бити веома велики, вратите га по модулу 10^9 + 7.

Пример 1:

Улаз: n = 3, requirements = [[2,2],[0,0]]
Излаз: 2
Објашњење:
Две пермутације су:

[2, 0, 1]

Префикс [2, 0, 1] има инверзије (0, 1) и (0, 2).
Префикс [2] има 0 инверзија.

[1, 2, 0]

Префикс [1, 2, 0] има инверзије (0, 2) и (1, 2).
Префикс [1] има 0 инверзија.

Пример 2:

Улаз: n = 3, requirements = [[2,2],[1,1],[0,0]]
Излаз: 1
Објашњење:
Једина задовољавајућа пермутација је [2, 0, 1]:

Префикс [2, 0, 1] има инверзије (0, 1) и (0, 2).
Префикс [2, 0] има инверзију (0, 1).
Префикс [2] има 0 инверзија.

Пример 3:

Улаз: n = 2, requirements = [[0,0],[1,0]]
Излаз: 1
Објашњење:
Једина задовољавајућа пермутација је [0, 1]:

Префикс [0] има 0 инверзија.
Префикс [0, 1] има инверзију (0, 1).

Ограничења:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
Улаз се генерише тако да постоји најмање један и такав да је end_i == n - 1.
Улаз се генерише тако да су сви енд_и јединствени.


Постоји круг црвених и плавих плочица. Дат вам је низ целих бројева colors. Боја плочице i је представљена са colors[i]:

colors[i] == 0 значи да је плочица i црвена.
colors[i] == 1 значи да је плочица i плава.

Свака 3 узастопна плочице у кругу са наизменичним бојама (средња плочица има различиту боју од леве и десне плочице) назива се наизменична група.
Вратите број наизменичних група.

Запазите да пошто colors представља круг, прва и последња плочица се сматрају суседима.

Пример 1:

Улаз: colors = [1,1,1]
Излаз: 0
Објашњење:

Пример 2:

Улаз: colors = [0,1,0,0,1]
Излаз: 3
Објашњење:

Наизменичне групе:

Ограничења:

3 <= colors.length <= 100
0 <= colors[i] <= 1

Постоји круг црвених и плавих плочица. Дат вам је низ боја целих бројева. Боја плочице и је представљена са colors[i]:

colors[i] == 0 значи да је плочица i црвена.
colors[i] == 1 значи да је плочица i плава.

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

Пример 1:

Улаз: colors = [1,1,1]
Излаз: 0
Објашњење:

Пример 2:

Улаз: colors = [0,1,0,0,1]
Излаз: 3
Објашњење:

Наизменичне групе:

Ограничења:

3 <= colors.length <= 100
0 <= colors[i] <= 1

Дат вам је круг црвених и плавих плочица. Дат вам је низ целих бројева colors. Боја плочице i је представљена са colors[i]:

- colors[i] == 0 означава да је плочица i црвена.
- colors[i] == 1 означава да је плочица i плава.

Свака 3 континуиране плочице у кругу са наизменичним бојама (средња плочица има различиту боју од плочица са леве и десне стране) се зове наизменична група.
Вратите број наизменичних група.
Напомена: пошто colors представља круг, прва и последња плочица се сматрају суседним.

Пример 1:

Улаз: colors = [1,1,1]
Излаз: 0
Објашњење:

Пример 2:

Улаз: colors = [0,1,0,0,1]
Излаз: 3
Објашњење:

Наизменичне групе:

Ограничења:

3 <= colors.length <= 100
0 <= colors[i] <= 1