Дат вам је низ позитивних целих бројева `nums` с 0-индексирањем и позитиван цео број `limit`.
У једној операцији можете изабрати било која два индекса `i` и `j` и заменити `nums[i]` и `nums[j]` ако је `|nums[i] - nums[j]| <= limit`.
Вратите лексикографски најмањи низ који се може добити извођењем операције неограничено пута.
Низ `a` је лексикографски мањи од низа `b` ако на првој позицији где `a` и `b` разликују, низ `a` има елемент који је мањи од одговарајућег елемента у `b`. На пример, низ `[2,10,3]` је лексикографски мањи од низа `[10,2,3]` јер се разликују на индексу 0 и `2 < 10`.

Пример 1:

Улаз: nums = [1,5,3,9,8], limit = 2
Излаз: [1,3,5,8,9]
Објашњење: Примените операцију 2 пута:
- Замените nums[1] са nums[2]. Низ постаје [1,3,5,9,8]
- Замените nums[3] са nums[4]. Низ постаје [1,3,5,8,9]
Не можемо добити лексикографски мањи низ применом било које друге операције.
Важно је напоменути да је могуће добити исти резултат применом различитих операција.

Пример 2:

Улаз: nums = [1,7,6,18,2,1], limit = 3
Излаз: [1,6,7,18,1,2]
Објашњење: Примените операцију 3 пута:
- Замените nums[1] са nums[2]. Низ постаје [1,6,7,18,2,1]
- Замените nums[0] са nums[4]. Низ постаје [2,6,7,18,1,1]
- Замените nums[0] са nums[5]. Низ постаје [1,6,7,18,1,2]
Не можемо добити лексикографски мањи низ применом било које друге операције.

Пример 3:

Улаз: nums = [1,7,28,19,10], limit = 3
Излаз: [1,7,28,19,10]
Објашњење: [1,7,28,19,10] је лексикографски најмањи низ који можемо добити јер не можемо применити операцију на било која два индекса.

Ограничења:

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

Дат вам је 0-индексиран низ позитивних целих бројева nums и позитиван број limit.
У једној операцији, можете изабрати било које два индекса i и j и заменити nums[i] и nums[j] ако је |nums[i] - nums[j]| <= limit.
Вратите лексикографски најмањи низ који се може добити извођењем операције било који број пута.
Низ a је лексикографски мањи од низа b ако се у првој позицији на којој се a и b разликују, елемент низа a буде мањи од одговарајућег елемента у низу b. На пример, низ [2,10,3] је лексикографски мањи од низа [10,2,3] јер се разликују на индексу 0 и 2 < 10.

Пример 1:

Улаз: nums = [1,5,3,9,8], limit = 2
Излаз: [1,3,5,8,9]
Објашњење: Примените операцију 2 пута:
- Замените nums[1] са nums[2]. Низ постаје [1,3,5,9,8]
- Замените nums[3] са nums[4]. Низ постаје [1,3,5,8,9]
Не можемо добити лексикографски мањи низ применом било које друге операције.
Важно је напоменути да је могуће добити исти резултат применом различитих операција.

Пример 2:

Улаз: nums = [1,7,6,18,2,1], limit = 3
Излаз: [1,6,7,18,1,2]
Објашњење: Примените операцију 3 пута:
- Замените nums[1] са nums[2]. Низ постаје [1,6,7,18,2,1]
- Замените nums[0] са nums[4]. Низ постаје [2,6,7,18,1,1]
- Замените nums[0] са nums[5]. Низ постаје [1,6,7,18,1,2]
Не можемо добити лексикографски мањи низ применом било које друге операције.

Пример 3:

Улаз: nums = [1,7,28,19,10], limit = 3
Излаз: [1,7,28,19,10]
Објашњење: [1,7,28,19,10] је лексикографски најмањи низ који можемо добити јер не можемо применити операцију на било која два индекса.

Ограничења:

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

Дат вам је низ позитивних целих бројева nums с 0-индексирањем и позитиван цео број limit.
У једној операцији можете изабрати било која два индекса i и j и заменити nums[i] и nums[j] ако је |nums[i] - nums[j]| <= limit.
Вратите лексикографски најмањи низ који се може добити извођењем операције неограничено пута.
Низ a је лексикографски мањи од низа b ако на првој позицији где a и b разликују, низ a има елемент који је мањи од одговарајућег елемента у b. На пример, низ [2,10,3] је лексикографски мањи од низа [10,2,3] јер се разликују на индексу 0 и 2 < 10.

Пример 1:

Улаз: nums = [1,5,3,9,8], limit = 2
Излаз: [1,3,5,8,9]
Објашњење: Примените операцију 2 пута:
- Замените nums[1] са nums[2]. Низ постаје [1,3,5,9,8]
- Замените nums[3] са nums[4]. Низ постаје [1,3,5,8,9]
Не можемо добити лексикографски мањи низ применом било које друге операције.
Важно је напоменути да је могуће добити исти резултат применом различитих операција.

Пример 2:

Улаз: nums = [1,7,6,18,2,1], limit = 3
Излаз: [1,6,7,18,1,2]
Објашњење: Примените операцију 3 пута:
- Замените nums[1] са nums[2]. Низ постаје [1,6,7,18,2,1]
- Замените nums[0] са nums[4]. Низ постаје [2,6,7,18,1,1]
- Замените nums[0] са nums[5]. Низ постаје [1,6,7,18,1,2]
Не можемо добити лексикографски мањи низ применом било које друге операције.

Пример 3:

Улаз: nums = [1,7,28,19,10], limit = 3
Излаз: [1,7,28,19,10]
Објашњење: [1,7,28,19,10] је лексикографски најмањи низ који можемо добити јер не можемо применити операцију на било која два индекса.

Ограничења:

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


Дат вам је низ целих бројева batteryPercentages са индексом 0 дужине n, који означава проценте батерије за n уређаја са индексом 0.
Ваш задатак је да тестирате сваки уређај i редоследом од 0 до n - 1, извођењем следећих тест операција:

Ако је batteryPercentages[i] веће од 0:

Повећајте број тестираног уређаја.
Смањите проценте батерије свих уређаја са индексом j у опсегу [i + 1, n - 1] за 1, осигуравајући да проценат њихове батерије никад не падне испод 0, тј. batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Прелазимо на следећи уређај.

У супротном, идите на следећи уређај без извођења било каквог теста.

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

Пример 1:

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

Пример 2:

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

Ограничења:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

Дат вам је 0-индексирани низ целих бројева batteryPercentages дужине n, који представља проценат батерије n 0-индексираних уређаја.
Ваш задатак је да тестирате сваки уређај i од 0 до n - 1, извршавајући следеће тест операције:

Ако је batteryPercentages[i] веће од 0:

Повећајте број тестираних уређаја.
Смањите проценат батерије свих уређаја са индексима j у опсегу [i + 1, n - 1] за 1, осигуравајући да њихов проценат батерије не буде мањи од 0, тј. batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
Прелазите на следећи уређај.

У супротном, прелазите на следећи уређај без извођења теста.

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

Пример 1:

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

Пример 2:

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

Ограничења:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100

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

Ако је batteryPercentages[i] већа од 0:

Повећајте број тестираних уређаја.
Смањите проценат батерије свих уређаја са индексима ј у опсегу [i + 1, n - 1] за 1, обезбеђујући да њихов проценат батерије никада не падне испод 0, тј. batteryPercentages[j] = max(0, batteryPercentages[j] - 1)
Пређите на следећи уређај.

У супротном, пређите на следећи уређај без вршења било каквог теста.

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

Пример 1:

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

Пример 2:

Улаз: batteryPercentages = [0,1,2]
Излаз: 2
Објашњење: Извођење тестних операција по редоследу почевши од уређаја 0:
На уређају 0, batteryPercentages[0] == 0, тако да прелазимо на следећи уређај без тестирања.
На уређају 1, batteryPercentages[1] > 0, тако да сада постоји 1 тестирани уређај, а batteryPercentages постаје [0,1,1].
На уређају 2, batteryPercentages[2] > 0, тако да сада постоје 2 тестирана уређаја, а batteryPercentages остаје исти.
Дакле, одговор је 2.

Ограничења:

1 <= n == batteryPercentages.length <= 100
0 <= batteryPercentages[i] <= 100


Дат вам је 0-индексиран низ планине. Ваш задатак је да пронађете све врхове у планинском низу.
Врати низ који се састоји од индекса врхова у датом низу било којим редоследом.
напомене:

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

Пример 1:

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

Пример 2:

Улаз: mountain = [1,4,3,8,5]
Излаз: [1,3]
Објашњење: mountain[0] и mountain[4] не могу бити врх јер су први и последњи елементи низа.
mountain[2] такође не може бити врх јер није стриктно већа од mountain[3] и mountain[1].
Али mountain [1] и mountain[3] су стриктно веће од својих суседних елемената.
Дакле, одговор је [1,3].

Ограничења:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

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

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

Пример 1:

Улаз: планина = [2,4,4]
Излаз: []
Објашњење: Планина [0] и планина [2] не могу бити bрх јер су први и последњи елементи низа.
планина[1] Такође не може бити bрх јер то није строго веће од планина[2].
Дакле, одговор је [].

Пример 2:

Улаз: планина = [1,4,3,8,5]
Излаз: [1,3]
Објашњење: планина [0] и планина [4] не могу бити bрх јер су први и последњи елементи низа.
планина [2] Такође не може бити bрх јер то није строго веће од планина [3] и планина [1].
Али планина [1] и планина [3] су строго веће од њихових суседних елемената.
Дакле, одговор је [1,3].

ОГРАНИЧЕЊА:

3 <= планина.length <= 100
1 <= планина[i] <= 100

Дат вам је низ mountain са индексирањем од 0. Ваш задатак је да пронађете све врхове у низу mountain.
Вратите низ који се састоји од индекса врхова у датом низу било којим редоследом.
Напомене:

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

Пример 1:

Улаз: mountain = [2,4,4]
Излаз: []
Објашњење: mountain[0] и mountain[2] не могу бити врхови јер су први и последњи елементи низа.
mountain[1] такође не може бити врх јер није строго већи од mountain[2].
Тако је одговор [].

Пример 2:

Улаз: mountain = [1,4,3,8,5]
Излаз: [1,3]
Објашњење: mountain[0] и mountain[4] не могу бити врхови јер су први и последњи елементи низа.
mountain[2] такође не може бити врх јер није строго већи од mountain[3] и mountain[1].
Али, mountain[1] и mountain[3] су строго већи од својих суседних елемената.
Тако је одговор [1,3].

Ограничења:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100


Дата вам је низ word и цео број k.
Подниз s низа word је потпуни ако:

Сваки карактер у s се јавља тачно k пута.
Разлика између два суседна карактера је највише 2. То јест, за било која два суседна карактера c1 и c2 у s, апсолутна разлика у њиховим позицијама у абецеди је највише 2.

Вратите број комплетних поднизова низа word.
Подниз је непразан непрекидан низ карактера у низу.

Пример 1:

Улаз: word = "igigee", k = 2
Излаз: 3
Објашњење: Комплетни поднизови где се сваки карактер појављује тачно два пута и разлика између суседних карактера је највише 2 су: igigee, igigee, igigee.

Пример 2:

Улаз: word = "aaabbbccc", k = 3
Излаз: 6
Објашњење: Комплетни поднизови где се сваки карактер појављује тачно три пута и разлика између суседних карактера је највише 2 су: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Ограничења:

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

Дате вам је реч низа и цео број к.
Подниз речи је потпун ако:

Сваки знак у с се појављује тачно к пута.
Разлика између два суседна знака је највише 2. То јест, за било која два суседна знака c1 и c2 у s, апсолутна разлика у њиховим позицијама у абецеди је највише 2.

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

Пример 1:

Улаз: реч = "igigee", к = 2
Излаз: 3
Објашњење: Комплетни поднизови где се сваки знак појављује тачно два пута и разлика између суседних карактера је највише 2 су: igigee, igigee, igigee.

Пример 2:

Улаз: реч = "аааbbbccc", к = 3
Излаз: 6
Објашњење: Комплетни поднизови у којима се сваки знак појављује тачно три пута и разлика између суседних карактера је највише 2 су:
aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Ограничења:
1 <= word.length <= 10^5
word consists only of lowercase English letters.
1 <= k <= дужина речи

Дати су вам стринг word и цео број k.
Подстринг s речи `word` је потпун ако:

- Сваки карактер у s се појављује тачно k пута.
- Разлика између два узастопна карактера је највише 2. То значи, за било која два узастопна карактера c1 и c2 у s, апсолутна разлика у њиховим позицијама у азбучи је највише 2.

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

Пример 1:

Улаз: word = "igigee", k = 2
Излаз: 3
Објашњење: Комплетни поднизови где се сваки карактер појављује тачно два пута и разлика између суседних карактера је највише 2 су: igigee, igigee, igigee.

Пример 2:

Улаз: word = "aaabbbccc", k = 3
Излаз: 6
Објашњење: Комплетни поднизови где се сваки карактер појављује тачно три пута и разлика између суседних карактера је највише 2 су: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Ограничења:

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


Дат вам је цео број n и 0-индексирани низ целих бројева sick, који је сортиран растућим редоследом.
Постоји n деце која стоје у реду са позицијама од 0 до n - 1. Низ sick садржи позиције деце која су заражена заразном болешћу. Заражено дете на позицији i може проширити болест на било које од своје двоје непосредних суседа на позицијама i - 1 и i + 1, ако они постоје и тренутно нису заражени. У највише једној секунди, једно дете које претходно није било заражено може постати заражено.

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

Пошто одговор може бити велики, вратити га модуло 10^9 + 7.
Напомена: Секвенца инфекције не садржи позиције деце која су већ била заражена на почетку.

Пример 1:

Унос: n = 5, sick = [0,4]
Излаз: 4
Објашњење: Деца на позицијама 1, 2 и 3 нису заражена на почетку. Постоје 4 могуће секвенце инфекције:
- Деца на позицијама 1 и 3 могу се заразити јер су њихове позиције суседне зараженој деци 0 и 4. Дете на позицији 1 се зарази прво.
Сада, дете на позицији 2 је суседно детету на позицији 1 које је заражено, а дете на позицији 3 је суседно детету на позицији 4 које је заражено, тако да било које од њих може бити заражено. Дете на позицији 2 се зарази.
На крају, дете на позицији 3 се зарази јер је суседно деци на позицијама 2 и 4 која су заражена. Секвенца инфекције је [1,2,3].
- Деца на позицијама 1 и 3 могу се заразити јер су њихове позиције суседне зараженој деци 0 и 4. Дете на позицији 1 се зарази прво.
Сада, дете на позицији 2 је суседно детету на позицији 1 које је заражено, а дете на позицији 3 је суседно детету на позицији 4 које је заражено, тако да било које од њих може бити заражено. Дете на позицији 3 се зарази.
На крају, дете на позицији 2 се зарази јер је суседно деци на позицијама 1 и 3 која су заражена. Секвенца инфекције је [1,3,2].
- Секвенца инфекције је [3,1,2]. Редослед заражавања децом може се посматрати као: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- Секвенца инфекције је [3,2,1]. Редослед заражавања децом може се посматрати као: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Пример 2:

Улаз: n = 4, sick = [1]
Излаз: 3
Објашњење: Деца на позицијама 0, 2 и 3 нису заражена на почетку. Постоје 3 могуће секвенце инфекције:
- Секвенца инфекције је [0,2,3]. Редослед заражавања децом може се посматрати као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Секвенца инфекције је [2,0,3]. Редослед заражавања децом може се посматрати као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Секвенца инфекције је [2,3,0]. Редослед заражавања децом може се посматрати као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Ограничења:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick је сортиран у растућем редоследу.

Дат вам је цео број н и 0 индексирани низ целих бројева болан који је сортиран по растућем редоследу.
Постоји н деце која стоје у реду са позицијама од 0 до н - 1 које су им додељене. У низу болесних налазе се позиције деце заражене неком заразном болешћу. Заражено дете на позицији и може да прошири болест на било коју од својих непосредно суседних деце на позицијама и - 1 и и + 1 ако постоје и тренутно нису заражене. Највише једно дете које раније није било заражено може да се зарази болешћу у једној секунди.
Може се показати да ће се после коначног броја секунди сва деца у реду заразити болешћу. Редослед инфекције је секвенцијални редослед позиција у којима се сва незаражена деца заразе болешћу. Врати укупан број могућих секвенци инфекције.
Пошто је одговор можда велики, вратите га по модулу 10^9 + 7.
Имајте на уму да секвенца инфекције не садржи положаје деце која су већ била заражена болешћу у почетку.

Пример 1:

Улаз: n = 5, sick = [0,4]
Излаз: 4
Објашњење: Деца на позицијама 1, 2 и 3 нису инфицирана у почетку. Постоје 4 могуће секвенце инфекције:
- Деца на позицијама 1 и 3 могу да се заразе јер су њихове позиције суседне зараженој деци 0 и 4. Дете на позицији 1 се прво зарази.
Сада, дете на позицији 2 је поред детета на позицији 1 које је заражено, а дете на позицији 3 је у близини детета на позицији 4 које је заражено, тако да било које од њих може да се зарази. Дете на позицији 2 се инфицира.
Коначно, дете на позицији 3 се инфицира јер је у близини деце на позицијама 2 и 4 која су заражена. Редослед инфекције је [1,2,3].
- Деца на позицијама 1 и 3 могу да се заразе јер су њихови положаји у близини заражене деце 0 и 4. Дете на позицији 1 се прво зарази.
Сада, дете на позицији 2 је поред детета на позицији 1 које је заражено, а дете на позицији 3 је у близини детета на позицији 4 које је заражено, тако да било које од њих може да се зарази. Дете на позицији 3 се инфицира.
Коначно, дете на позицији 2 се инфицира јер је у близини деце на позицијама 1 и 3 која су заражена. Редослед инфекције је [1,3,2].
- Редослед инфекције је [3,1,2]. Редослед заразе болести код деце може се видети као:[0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- Редослед инфекције је [3,2,1]. Редослед заразе болести код деце може се видети као: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Пример 2:

Улаз: n = 4, sick = [1]
Излаз: 3
Објашњење: Деца на позицијама 0, 2 и 3 нису инфицирана у почетку. Постоје 3 могуће секвенце инфекције:
- Редослед инфекције је [0,2,3]. Редослед заразе болести код деце може се посматрати као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Редослед инфекције је [2,0,3]. Редослед заразе болести код деце може се посматрати као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Редослед инфекције је [2,3,0]. Редослед заразе болести код деце може се посматрати као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Ограничења:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
болесни се сортирају по растућем редоследу.

Дат вам је цео број n и 0-индексирани низ целих бројева sick који је сортиран у растућем редоследу.
У реду је n деце, са позицијама од 0 до n - 1 додељеним сваком детету. Низ sick садржи позиције деце која су заражена инфективном болешћу. Заражено дете на позицији i може пренети болест на било које од својих непосредних суседа на позицијама i - 1 и i + 1 ако они постоје и тренутно нису заражени. Највише једно дете које није било заражено може се заразити у једној секунди.

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

Напомена: Секвенца инфекције не садржи позиције деце која су већ била заражена болешћу на почетку.
Пример 1:

Унос: n = 5, sick = [0,4]
Излаз: 4
Објашњење: Деца на позицијама 1, 2 и 3 нису заражена на почетку. Постоје 4 могуће секвенце инфекције:
- Деца на позицијама 1 и 3 могу се заразити јер су њихове позиције суседне зараженој деци 0 и 4. Дете на позицији 1 се зарази прво.
Сада, дете на позицији 2 је суседно детету на позицији 1 које је заражено, а дете на позицији 3 је суседно детету на позицији 4 које је заражено, тако да било које од њих може бити заражено. Дете на позицији 2 се зарази.
На крају, дете на позицији 3 се зарази јер је суседно деци на позицијама 2 и 4 која су заражена. Секвенца инфекције је [1,2,3].
- Деца на позицијама 1 и 3 могу се заразити јер су њихове позиције суседне зараженој деци 0 и 4. Дете на позицији 1 се зарази прво.
Сада, дете на позицији 2 је суседно детету на позицији 1 које је заражено, а дете на позицији 3 је суседно детету на позицији 4 које је заражено, тако да било које од њих може бити заражено. Дете на позицији 3 се зарази.
На крају, дете на позицији 2 се зарази јер је суседно деци на позицијама 1 и 3 која су заражена. Секвенца инфекције је [1,3,2].
- Секвенца инфекције је [3,1,2]. Редослед инфекције болешћу код деце може се видети као: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].
- Секвенца инфекције је [3,2,1]. Редослед инфекције болешћу код деце може се видети као: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4].

Пример 2:

Унос: n = 4, sick = [1]
Излаз: 3
Објашњење: Деца на позицијама 0, 2 и 3 нису заражена на почетку. Постоје 3 могуће секвенце инфекције:
- Секвенца инфекције је [0,2,3]. Редослед инфекције болешћу код деце може се видети као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Секвенца инфекције је [2,0,3]. Редослед инфекције болешћу код деце може се видети као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].
- Секвенца инфекције је [2,3,0]. Редослед инфекције болешћу код деце може се видети као: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3].

Ограничења:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick је сортиран у растућем редоследу.


Дат вам је низ целих бројева nums и цели број k.
Учесталост елемента x је број пута колико се он појављује у низу.
Низ се назива добрим ако је учесталост сваког елемента у овом низу мања или једнака k.
Вратите дужину најдужег доброг подниза низа nums.
Подниз је непрекидан непразан низ елемената унутар низа.

Пример 1:

Улаз: nums = [1,2,3,1,2,3,1,2], k = 2
Излаз: 6
Објашњење: Најдужи могући добар подниз је [1,2,3,1,2,3] јер се вредности 1, 2 и 3 појављују највише два пута у овом поднизу. Напомена да су поднизови [2,3,1,2,3,1] и [3,1,2,3,1,2] такође добри.
Може се показати да не постоје добри поднизови са дужином већом од 6.

Пример 2:

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

Пример 3:

Улаз: nums = [5,5,5,5,5,5,5], k = 4
Излаз: 4
Објашњење: Најдужи могући добар подниз је [5,5,5,5] јер се вредност 5 појављује 4 пута у овом поднизу.
Може се показати да не постоје добри поднизови са дужином већом од 4.

Ограничења:

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

Дат вам је низ цео-числених nums и цео број k.
Фреквенција елемента x је број пута када се он појављује у низу.
Низ се назива добрим ако је фреквенција сваког елемента у овом низу мања или једнака k.
Вратите дужину најдужег доброг подниза од nums.
Подниз је непрекинута непразна секвенца елемената унутар низа.

Пример 1:

Улаз: nums = [1,2,3,1,2,3,1,2], k = 2
Излаз: 6
Објашњење: Најдужи могући добар подниз је [1,2,3,1,2,3] јер се вредности 1, 2 и 3 појављују највише два пута у овом поднизу. Напомена да су поднизови [2,3,1,2,3,1] и [3,1,2,3,1,2] такође добри.
Може се показати да не постоје добри поднизови са дужином већом од 6.

Пример 2:

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

Пример 3:

Улаз: nums = [5,5,5,5,5,5,5], k = 4
Излаз: 4
Објашњење: Најдужи могући добар подниз је [5,5,5,5] јер се вредност 5 појављује 4 пута у овом поднизу.
Може се показати да не постоје добри поднизови са дужином већом од 4.

Ограничења:

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


Дат вам је низ целих бројева nums који има парну дужину, као и празан низ arr. Алисе и Боб су одлучили да играју игру у којој ће у сваком кругу Алисе и Боб направити један потез. Правила игре су следећа:

У сваком кругу, прво ће Алисе уклонити најмањи елемент из низа nums, а затим Боб исто то учинити.
Након тога, прво ће Боб додати уклоњени елемент у низ arr, а затим ће Алисе учинити исто.
Игра ће се наставити све док низ nums не постане празан.

Вратите резултујући низ arr.

Пример 1:

Улаз: nums = [5,4,2,3]
Излаз: [3,2,5,4]
Објашњење: У првом кругу, прво Алисе уклања 2, а затим Боб уклања 3. Затим, у низ arr, прво Боб додаје 3, а затим Алисе додаје 2. Тако да је arr = [3, 2].
На почетку другог круга, nums = [5, 4]. Сада, прво Алисе уклања 4, а затим Боб уклања 5. Затим обоје додају у arr, који постаје [3, 2, 5, 4].

Пример 2:

Улаз: nums = [2,5]
Излаз: [5,2]
Објашњење: У првом кругу, прво Алисе уклања 2, а затим Боб уклања 5. Затим, у низ arr, прво Боб додаје 5, а затим Алисе додаје 2. Тако да је arr = [5, 2].

Ограничења:

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

Дат вам је низ целих бројева \( nums \) са индексирањем од 0 и парном дужином, а постоји и празан низ \( arr \). Алис и Боб су одлучили да играју игру у којој ће у сваком кругу Алис и Боб предузети један потез. Правила игре су следећа:

У сваком кругу, прво Алис уклања минимални елемент из \( nums \), а затим Боб ради исто.
Сада, прво Боб додаје уклоњени елемент у низ \( arr \), а затим Алис ради исто.
Игра се наставља док \( nums \) не постане празан.

Вратите резултујући низ \( arr \).

Пример 1:

Улаз: nums = [5,4,2,3]
Излаз: [3,2,5,4]
Објашњење: У првом кругу, прво Алис уклања 2, а затим Боб уклања 3. Затим у \( arr \) прво Боб додаје 3, а онда Алис додаје 2. Тако \( arr = [3,2] \).
На почетку другог круга, \( nums = [5,4] \). Сада, прво Алис уклања 4, а затим Боб уклања 5. Затим обоје додају у \( arr \) који постаје [3,2,5,4].

Пример 2:

Улаз: nums = [2,5]
Излаз: [5,2]
Објашњење: У првом кругу, прво Алис уклања 2, а затим Боб уклања 5. Затим у \( arr \) прво Боб додаје, а онда Алис додаје. Тако \( arr = [5,2] \).

Ограничења:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0Дат вам је низ целих бројева \( nums \) са индексирањем од 0 и парном дужином, а постоји и празан низ \( arr \). Алис и Боб су одлучили да играју игру у којој ће у сваком кругу Алис и Боб предузети један потез. Правила игре су следећа:

У сваком кругу, прво Алис уклања минимални елемент из \( nums \), а затим Боб ради исто.
Сада, прво Боб додаје уклоњени елемент у низ \( arr \), а затим Алис ради исто.
Игра се наставља док \( nums \) не постане празан.

Вратите резултујући низ \( arr \).

Пример 1:

Улаз: nums = [5,4,2,3]
Излаз: [3,2,5,4]
Објашњење: У првом кругу, прво Алис уклања 2, а затим Боб уклања 3. Затим у \( arr \) прво Боб додаје 3, а онда Алис додаје 2. Тако \( arr = [3,2] \).
На почетку другог круга, \( nums = [5,4] \). Сада, прво Алис уклања 4, а затим Боб уклања 5. Затим обоје додају у \( arr \) који постаје [3,2,5,4].

Пример 2:

Улаз: nums = [2,5]
Излаз: [5,2]
Објашњење: У првом кругу, прво Алис уклања 2, а затим Боб уклања 5. Затим у \( arr \) прво Боб додаје, а онда Алис додаје. Тако \( arr = [5,2] \).

Ограничења:

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

Дат вам је низ целих бројева nums са индексирањем од 0 и парном дужином, а постоји и празан низ arr. Алис и Боб су одлучили да играју игру у којој ће у сваком кругу Алис и Боб предузети један потез. Правила игре су следећа:

У сваком кругу, прво Алис уклања минимални елемент из nums, а затим Боб ради исто.
Сада, прво Боб додаје уклоњени елемент у низ arr, а затим Алис ради исто.
Игра се наставља док nums не постане празан.

Вратите резултујући низ arr .

Пример 1:

Улаз: nums = [5,4,2,3]
Излаз: [3,2,5,4]
Објашњење: У првом кругу, прво Алис уклања 2, а затим Боб уклања 3. Затим у arr прво Боб додаје 3, а онда Алис додаје 2. Тако arr = [3,2].
На почетку другог круга, nums = [5,4]. Сада, прво Алис уклања 4, а затим Боб уклања 5. Затим обоје додају у arr који постаје [3,2,5,4].

Пример 2:

Улаз: nums = [2,5]
Излаз: [5,2]
Објашњење: У првом кругу, прво Алис уклања 2, а затим Боб уклања 5. Затим у arr прво Боб додаје, а онда Алис додаје. Тако arr = [5,2].

Ограничења:

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


Добијате 0-индексирану 2D целобројну матричну мрежу величине н * н са вредностима у опсегу [1, n^2]. Сваки цео број се појављује тачно једном, осим а који се појављује два пута и б који недостаје. Задатак је да се пронађу бројеви који се понављају и недостају а и б.
Вратите целобројни низ индексиран 0 анс величине 2 где је ans[0] једнак а ans[1] једнако б.

Пример 1:

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

Пример 2:

Улаз : grid = [[9,1,7],[8,9,2],[3,4,6]]
Излаз : [9,5]
Објашњење : Број 9 се понавља и број 5 недостаје, тако да је одговор [9,5].

Ограничења:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
За све x где је 1 <= x <= n * n постоји тачно један x који није једнак ниједном од чланова grid.
За све x где је 1 <= x <= n * n постоји тачно један x који је једнак тачно два члана grid.
За све x где је 1 <= x <= n * n осим за два од њих постоји тачно један пар i, j где је 0 <= i, j <= n - 1 и grid[i][j] == x.

Дат вам је нула-индиковани 2D целобројни матрица "grid" величине n * n са вредностима у опсегу [1, n^2]. Свакој целој броју се појављује тачно једном, осим броја a који се појављује два пута и броја b који недостаје. Задатак је да пронађете понављајући и недостајући бројеве a и b.
Вратите нула-индиковани целобројни низ ans величине 2 где ans[0] је a и ans[1] је b.

Пример 1:

Улаз: grid = [[1,3],[2,2]]
Излаз: [2,4]
Објашњење: Број 2 се понавља, а број 4 недостаје, тако да је одговор [2,4].

Пример 2:

Улаз: grid = [[9,1,7],[8,9,2],[3,4,6]]
Излаз: [9,5]
Објашњење: Број 9 се понавља, а број 5 недостаје, тако да је одговор [9,5].

Ограничења:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
За све x где је 1 <= x <= n * n постоји тачно један x који није једнак ниједном од чланова grid.
За све x где је 1 <= x <= n * n постоји тачно један x који је једнак тачно два члана grid.
За све x где је 1 <= x <= n * n осим за два од њих постоји тачно један пар i, j где је 0 <= i, j <= n - 1 и grid[i][j] == x.

Добићете 0-индексирану 2D целобројну матричну мрежу величине n * n са вредностима у опсегу [1, n^2]. Сваки цео број се појављује тачно једном осим а који се појављује два пута и б који недостаје. Задатак је пронаћи бројеве а и б који се понављају и недостају.
Врати 0-индексирани низ целих бројева анс величине 2 где је анс[0] једнако а, а анс[1] једнако б.

Пример 1:

Улаз: grid = [[1,3],[2,2]]
Излаз: [2,4]
Објашњење: Број 2 се понавља, а број 4 недостаје па је одговор [2,4].

Пример 2:

Улаз: grid = [[9,1,7],[8,9,2],[3,4,6]]
Излаз: [9,5]
Објашњење: Број 9 се понавља, а број 5 недостаје па је одговор [9,5].

Ограничења:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
За све x где је 1 <= x <= n * n постоји тачно један x који није једнак ниједном од чланова grid.
За све x где је 1 <= x <= n * n постоји тачно један x који је једнак тачно два члана grid.
За све x где је 1 <= x <= n * n осим за два од њих постоји тачно један пар i, j где је 0 <= i, j <= n - 1 и grid[i][j] == x.


Дати су два низа целих бројева nums1 и nums2 дужине n.
Морате уклонити n / 2 елемената из nums1 и n / 2 елемената из nums2. Након уклањања, преостали елементи из nums1 и nums2 се додају у скуп s.
Вратите максималну могућу величину скупа s.

Пример 1:

Улаз: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Излаз: 2
Објашњење: Уклањамо две појаве 1 из nums1 и nums2. Након уклањања, низови постају једнаки nums1 = [2,2] и nums2 = [1,1]. Дакле, s = {1,2}.
Може се показати да је 2 максимална могућа величина скупа s након уклањања.

Пример 2:

Улаз: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Излаз: 5
Објашњење: Уклањамо 2, 3 и 6 из nums1, као и 2 и две појаве 3 из nums2. Након уклањања, низови постају једнаки nums1 = [1,4,5] и nums2 = [2,3,2]. Дакле, s = {1,2,3,4,5}.
Може се показати да је 5 максимална могућа величина скупа s након уклањања.

Пример 3:

Улаз: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Излаз: 6
Објашњење: Уклањамо 1, 2 и 3 из nums1, као и 4, 5 и 6 из nums2. Након уклањања, низови постају једнаки nums1 = [1,2,3] и nums2 = [4,5,6]. Дакле, s = {1,2,3,4,5,6}.
Може се показати да је 6 максимална могућа величина скупа s након уклањања.

Ограничења:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n је паран broj.
1 <= nums1[i], nums2[i] <= 10^9

Дати су вам два целобројна низа nums1 и nums2 са индексима почевши од 0 и парне дужине n.
Морате уклонити n / 2 елемената из nums1 и n / 2 елемената из nums2. Након уклањања, преостале елементе из nums1 и nums2 убацујете у скуп s.
Вратите максималну могућу величину скупа s.

Пример 1:

Улаз: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Излаз: 2
Објашњење: Уклањамо две појаве 1 из nums1 и nums2. Након уклањања, низови постају једнаки nums1 = [2,2] и nums2 = [1,1]. Дакле, s = {1,2}.
Може се показати да је 2 максимална могућа величина скупа с након уклањања.

Пример 2:

Улаз: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Излаз: 5
Објашњење: Уклањамо 2, 3 и 6 из nums1, као и 2 и две појаве 3 из nums2. Након уклањања, низови постају једнаки nums1 = [1,4,5] и nums2 = [2,3,2]. Дакле, s = {1,2,3,4,5}.
Може се показати да је 5 максимална могућа величина скупа с након уклањања.

Пример 3:

Улаз: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Излаз: 6
Објашњење: Уклањамо 1, 2 и 3 из бројева 1, као и 4, 5 и 6 из бројева 2. Након уклањања, низови постају једнаки nums1 = [1,2,3] и nums2 = [4,5,6]. Дакле, s = {1,2,3,4,5,6}.
Може се показати да је 6 максимална могућа величина скупа с након уклањања.

Ограничења:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n је паран.
1 <= nums1[i], nums2[i] <= 10^9

Дата су вам два низа целих бројева nums1 и nums2 са индексима од 0 и парне дужине n.
Морате уклонити n / 2 елемената из низа nums1 и n / 2 елемената из низа nums2. Након уклањања, преостале елементе из низова nums1 и nums2 убацујете у скуп s.
Вратите максималну могућу величину скупа s.

Пример 1:

Унос: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Излаз: 2
Објашњење: Уклањамо две појаве 1 из nums1 и nums2. Након уклањања, низови постају једнаки nums1 = [2,2] и nums2 = [1,1]. Дакле, s = {1,2}.
Може се показати да је 2 максимална могућа величина скупа s након уклањања.

Пример 2:

Унос: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Излаз: 5
Објашњење: Уклањамо 2, 3 и 6 из nums1, као и 2 и две појаве 3 из nums2. Након уклањања, низови постају једнаки nums1 = [1,4,5] и nums2 = [2,3,2]. Дакле, s = {1,2,3,4,5}.
Може се показати да је 5 максимална могућа величина скупа s након уклањања.

Пример 3:

Унос: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Излаз: 6
Објашњење: Уклањамо 1, 2 и 3 из nums1, као и 4, 5 и 6 из nums2. Након уклањања, низови постају једнаки nums1 = [1,2,3] и nums2 = [4,5,6]. Дакле, s = {1,2,3,4,5,6}.
Може се показати да је 6 максимална могућа величина скупа s након уклањања.

Ограничења:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n је паран.
1 <= nums1[i], nums2[i] <= 10^9


Дат вам је низ целих бројева nums са нула-индексирањем дужине n.
Дозвољено вам је да извршите специјалан потез било који број пута (укључујући нулу) на nums. У једном специјалном потезу извршавате следеће кораке редом:

Изаберите индекс i у опсегу [0, n - 1], и позитиван цео број x.
Додајте |nums[i] - x| на укупан трошак.
Промените вредност nums[i] на x.

Палиндромски број је позитиван цео број који остаје исти када му се цифре обрну. На пример, 121, 2552 и 65756 су палиндромски бројеви, док 24, 46, 235 нису палиндромски бројеви.
Низ се сматра еквалиндромским ако су сви елементи у низу једнаки целом броју y, где је y палиндромски број мањи од 10^9.
Вратите цео број који означава минималан могући укупни трошак да се nums учини еквалиндромским извођењем било ког броја специјалних потеза.

Пример 1:

Улаз: nums = [1,2,3,4,5]
Излаз: 6
Објашњење: Низ можемо учинити еквалиндромским тако што ћемо променити све елементе у 3, што је палиндромски број. Трошак промене низа у [3,3,3,3,3] коришћењем 4 специјална потеза дат је са |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Може се показати да промена свих елемената у било који палиндромски број осим 3 не може бити постигнута по нижем трошку.

Пример 2:

Улаз: nums = [10,12,13,14,15]
Излаз: 11
Објашњење: Низ можемо учинити еквалиндромским тако што ћемо променити све елементе у 11, што је палиндромски број. Трошак промене низа у [11,11,11,11,11] коришћењем 5 специјалних потеза дат је са |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Може се показати да промена свих елемената у било који палиндромски број осим 11 не може бити постигнута по нижем трошку.

Пример 3:

Улаз: nums = [22,33,22,33,22]
Излаз: 22
Објашњење: Низ можемо учинити еквалиндромским тако што ћемо променити све елементе у 22, што је палиндромски број. Трошак промене низа у [22,22,22,22,22] коришћењем 2 специјална потеза дат је са |33 - 22| + |33 - 22| = 22.
Може се показати да промена свих елемената у било који палиндромски број осим 22 не може бити постигнута по нижем трошку.

Ограничења:

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

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

Изаберите индекс i у опсегу [0, n - 1] и позитиван цео број x.
Додајте |nums[i] - x| у укупни трошак.
Промените вредност nums[i] на x.

Палиндромски број је позитиван цео број који остаје исти када се његове цифре обрну. На пример, 121, 2552 и 65756 су палиндромски бројеви, док 24, 46, 235 нису палиндромски бројеви.
Низ се сматра "equalindromic" ако су сви елементи низа једнаки неком целобројном y, где је y палиндромски број мањи од 10^9.
Вратите цео број који представља минималан могући укупан трошак да се nums постигне као "equalindromic" извршавањем било којег броја специјалних потеза.

Пример 1:

Унос: nums = [1,2,3,4,5]
Излаз: 6
Објашњење: Низ можемо учинити еквалиндромским тако што ћемо променити све елементе у 3, што је палиндромски број. Трошак промене низа у [3,3,3,3,3] коришћењем 4 специјална потеза дат је са |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Може се показати да промена свих елемената у било који палиндромски број осим 3 не може бити постигнута по нижем трошку.

Пример 2:

Унос: nums = [10,12,13,14,15]
Излаз: 11
Објашњење: Низ можемо учинити еквалиндромским тако што ћемо променити све елементе у 11, што је палиндромски број. Трошак промене низа у [11,11,11,11,11] коришћењем 5 специјалних потеза дат је са |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Може се показати да промена свих елемената у било који палиндромски број осим 11 не може бити постигнута по нижем трошку.

Пример 3:

Унос: nums = [22,33,22,33,22]
Излаз: 22
Објашњење: Низ можемо учинити еквалиндромским тако што ћемо променити све елементе у 22, што је палиндромски број. Трошак промене низа у [22,22,22,22,22] коришћењем 2 специјална потеза дат је са |33 - 22| + |33 - 22| = 22.
Може се показати да промена свих елемената у било који палиндромски број осим 22 не може бити постигнута по нижем трошку.

Ограничења:

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

Дат вам је 0-индексирани низ целих бројева нумс дужине n.
Дозвољено вам је да изведете посебан потез било који број пута (укључујући нулу) на бројевима. У једном посебном потезу изводите следеће кораке по редоследу:

Изаберите индекс i у опсегу [0, n - 1] и позитиван цео број x.
Додајте |nums[i] - x| на укупан трошак.
Промените вредност nums[i] на x.

Палиндромски број је позитиван цео број који остаје исти када се његове цифре обрну. На пример, 121, 2552 и 65756 су палиндромски бројеви, док 24, 46, 235 нису палиндромски бројеви.
Низ се сматра једнакоиндромним ако су сви елементи у низу једнаки целом броју и, где је и палиндромски број мањи од 10^9.
Врати цео број који означава минимални могући укупни трошак да би бројеви били једнаки индромним извођењем било ког броја специјалних потеза.

Пример 1:

Улаз: nums = [1,2,3,4,5]
Излаз: 6
Објашњење: Можемо учинити низ једнаким индромним променом свих елемената у 3 што је палиндромски број. Цена промене низа у [3,3,3,3,3] коришћењем 4 специјална потеза је дата са |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Може се показати да се промена свих елемената у било који палиндромски број осим 3 не може постићи по нижој цени.

Пример 2:

Улаз: nums = [10,12,13,14,15]
Излаз: 11
Објашњење: Можемо учинити низ једнаким индромним променом свих елемената у 11 што је палиндромски број. Цена промене низа у [11,11,11,11,11] коришћењем 5 специјалних потеза је дата са |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Може се показати да се промена свих елемената у било који палиндромски број осим 11 не може постићи по нижој цени.

Пример 3:

Улаз: nums = [22,33,22,33,22]
Излаз: 22
Објашњење: Можемо учинити низ једнаким индромним променом свих елемената у 22 што је палиндромски број. Цена промене низа у [22,22,22,22,22] коришћењем 2 специјална потеза је дата са |33 - 22| + |33 - 22| = 22.
Може се показати да се промена свих елемената у било који палиндромски број осим 22 не може постићи по нижој цени.

Ограничења:

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


Дат је стринг word који је индексиран од нуле.
У једној операцији можете да изаберете било који индекс i из word и промените word[i] у било које малим слово енглеског језика.
Вратите минимални број операција потребних за уклањање свих суседних скоро-једнаких знакова из word.
Два знака a и b су скоро једнака ако је a == b или a и b суседни у абецеди.

Пример 1:

Улаз: word = "aaaaa"
Излаз: 2
Објашњење: Можемо променити  word у "acaca"  која нема суседне скоро - једнаке знакове.
Може се показати да је минимални број операција потребних за уклањање свих суседних скоро-једнаких знакова из word 2.

Пример 2:

ИНПУТ: word = "abddez"
Излаз: 2
Објашњење: Можемо променити word у "ybdoez" која нема суседне скоро - једнаке знакове.
Може се показати да је минимални број операција потребних за уклањање свих суседних скоро-једнаких знакова из word 2.
Пример 3:

Улаз: word = "zyxyxyz"
Излаз: 3
Објашњење: Можемо променити word у "zaxaxaz" који нема суседне скоро - једнаке знакове.
Може се показати да је минимални број операција потребних за уклањање свих суседних скоро-једнаких знакова из word 3.

Ограничења:

1 <= word.length <= 100
Реч се састоји само у малим словима енглеског језика.

Дат вам је низ знакова word индексиран од 0.
У једној операцији можете одабрати било који индекс i низа word и променити word[i] у било које мало слово енглеске абецеде.
Вратите минималан број операција потребних да уклоните све суседне скоро-једнаке знакове из низа word.
Два знака a и b су скоро-једнака ако је a == b или ако су a и b суседни у абецеди.

Пример 1:

Улаз: word = "aaaaa"
Излаз: 2
Објашњење: Можемо променити word у "acaca" које нема суседне скоро-једнаке карактере.
Може се показати да је минималан број операција потребних за уклањање свих суседних скоро-једнаких знакова из низа word једнак 2.

Пример 2:

Улаз: word = "abddez"
Излаз: 2
Објашњење: Можемо променити word у "ybdoez" које нема суседне скоро-једнаке карактере.
Може се показати да је минимални број операција потребних да се уклоне сви суседни скоро-једнаки карактери из word једнак 2.

Пример 3:

Input: word = "zyxyxyz"
Output: 3
Објашњење: Можемо променити word у "zaxaxaz" које нема суседне скоро-једнаке карактере.
Може се показати да је минимални број операција потребних да се уклоне сви суседни скоро-једнаки карактери из word једнак 3.
Ограничења:

1 <= word.length <= 100
word се састоји само од малих слова енглеског језика.

Дат вам је низ word са индексом 0.
У једној операцији, можете изабрати било који индекс i у речи и променити word[i] у било коју малу енглеску слово.
Вратите минималан број операција који је потребан да се уклоне сви суседни скоро-једнаки знакови из речи.
Два знака a и b су скоро-једнаки ако је a == b или ако су a и b суседи у алфабету.

Пример 1:

Input: word = "aaaaa"
Output: 2
Објашњење: Можемо променити word у "acaca" које нема суседне скоро-једнаке карактере.
Може се показати да је минимални број операција потребних да се уклоне сви суседни скоро-једнаки карактери из word 2.

Пример 2:

Input: word = "abddez"
Output: 2
Објашњење: Можемо променити word у "ybdoez" које нема суседне скоро-једнаке карактере.
Може се показати да је минимални број операција потребних да се уклоне сви суседни скоро-једнаки карактери из word 2.

Пример 3:

Input: word = "zyxyxyz"
Output: 3
Објашњење: Можемо променити word у "zaxaxaz" које нема суседне скоро-једнаке карактере.
Може се показати да је минимални број операција потребних да се уклоне сви суседни скоро-једнаки карактери из word 3.

Ограничења:

1 <= word.length <= 100
word се састоји само од малих слова енглеског језика.


Дат вам је 0-индексни целобројни низ coins, који представља вредности расположивих новчића, и цео број target.
Цело број x је доступан ако постоји подпоследица coins која се сумира на x.
Вратите минималан број новчића било које вредности које треба додати у низ тако да сваки цео број у опсегу [1, target] буде доступан.
Подпоследица низа је нови непрзани низ који се формира из оригиналног низа брисањем неких (можда ниједног) елемената без нарушавања релативних позиција преосталих елемената.

Пример 1:

Улаз: coins = [1,4,10], target = 19
Излаз: 2
Објашњење: Треба да додамо новчиће 2 и 8. Резултујући низ ће бити [1,2,4,8,10].
Може се показати да су сви цели бројеви од 1 до 19 доступни из резултујућег низа, и да је 2 минималан број новчића који треба додати у низ.

Пример 2:

Улаз: coins = [1,4,10,5,7,19], target = 19
Излаз: 1
Објашњење: Треба само да додамо новчић 2. Резултујући низ ће бити [1,2,4,5,7,10,19].
Може се показати да су сви цели бројеви од 1 до 19 доступни из резултујућег низа, и да је 1 минималан број новчића који треба додати у низ.

Пример 3:

Улаз: coins = [1,1,1], target = 20
Излаз: 3
Објашњење: Треба да додамо новчиће 4, 8 и 16. Добијен низ ће бити [1,1,1,4,8,16].
Може се показати да су сви цели бројеви од 1 до 20 доступни из резултујућег низа, и да је 3 минималан број новчића који треба додати у низ.

Ограничења:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

Добили сте кованице са низ целих бројева са 0-индексацијом, који представљају вредности кованица и цели циљ.
цели број x је могуће добити ако постоји подсеквенција кованица које сумира на x.
Вратите минимални број кованица било које вредности које је потребно додати на низ тако да је сваки цели број у домету  [1, target] може се добити.
Подсеквенција низа је нови не-празан низ који је формиран из оригиналног низа брисањем неких (вероватно ниједног) елемената без ометања релативних положаја преосталих елемената.

Пример 1:

Улаз: coins = [1,4,10], target = 19
Излаз: 2
Објашњење: Морамо да додамо кованице 2 и 8. Резултирајући низ ће бити [1,2,4,8,10].
Може се показати да се сви цели бројеви од 1 до 19 могу добити из резултирајућег низа и да је 2 минимални број кованица које је потребно додати у низ.

Пример 2:

Улаз: coins = [1,4,10,5,7,19], target = 19
Излаз: 1
Објашњење: Морамо само да додамо новчић 2. Резултирајући низ ће бити [1,2,4,5,7,10,19].
Може се показати да су сви цели бројеви од 1 до 19 могући из резултирајућег низа и да је 1 минимални број кованица које је потребно додати у низ.

Пример 3:

Улаз: coins = [1,1,1], target = 20
Излаз: 3
Објашњење: Морамо да додамо кованице 4, 8 и 16. Резултирајући низ ће бити [1,1,1,4,8,16].
Може се показати да су сви цели бројеви од 1 до 20 доступни из резултирајућег низа и да је 3 минимални број кованица које је потребно додати у низ.

Ограничења:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target

Дат вам је 0-индексиран цео број новчића, који представљају вредности доступних новчића и целобројни циљ.
Цео број x се може добити ако постоји подниз новчића који збир са x.
Вратите минимални број новчића било које вредности које треба додати низу тако да сваки цео број у опсегу [1, target] буде доступан.
Подсеквенца низа је нови непразан низ који се формира од оригиналног низа брисањем неких (вероватно ниједног) елемената без нарушавања релативних положаја преосталих елемената.

Пример 1:

Улаз: coins = [1,4,10], target = 19
Излаз: 2
Објашњење: Морамо да додамо новчиће 2 и 8. Добијени низ ће бити [1,2,4,8,10].
Може се показати да се из резултујућег низа могу добити сви цели бројеви од 1 до 19, а да је 2 минимални број новчића који треба додати у низ.

Пример 2:

Улаз: coins = [1,4,10,5,7,19], target = 19
Излаз: 1
Објашњење: Треба само да додамо новчић 2. Добијени низ ће бити [1,2,4,5,7,10,19].
Може се показати да се из резултујућег низа могу добити сви цели бројеви од 1 до 19 и да је 1 минимални број новчића који треба додати низу.

Пример 3:

Улаз: coins = [1,1,1], target = 20
Излаз: 3
Објашњење: Морамо да додамо новчиће 4, 8 и 16. Добијени низ ће бити [1,1,1,4,8,16].
Може се показати да се из резултујућег низа могу добити сви цели бројеви од 1 до 20, а да је 3 минимални број новчића који треба додати низу.

Ограничења:

1 <= target <= 10^5
1 <= coins.length <= 10^5
1 <= coins[i] <= target


Дат је низ s са индексима од 0 и цео број k.
Треба да изведете следеће операције партиционисања док низ s не постане празан:

1. Одаберите најдужи префикс низа s који садржи највише k различитих карактера.
2. Уклоните тај префикс из низа s и повећајте број партиција за један. Преостали карактери (ако их има) у низу s задржавају свој почетни редослед.

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

Пример 1:

Улаз: s = "accca", k = 2
Излаз: 3
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, s[2] се може променити у 'b'.
s постаје "acbca".
Операције се сада могу извести на следећи начин док s не постане празан:
- Изабери најдужи префикс који садржи највише 2 различита карактера, "acbca".
- Избриши префикс, и s постаје "bca". Број партиција је сада 1.
- Изабери најдужи префикс који садржи највише 2 различита карактера, "bca".
- Избриши префикс, и s постаје "a". Број партиција је сада 2.
- Изабери најдужи префикс који садржи највише 2 различита карактера, "a".
- Избриши префикс, и s постаје празан. Број партиција је сада 3.
Према томе, одговор је 3.
Може се показати да није могуће добити више од 3 партиције.

Пример 2:

Улаз: s = "aabaab", k = 3
Излаз: 1
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, можемо оставити s онаквим какав јесте.
Операције се сада могу извести на следећи начин док s не постане празан:
- Изабери најдужи префикс који садржи највише 3 различита карактера, "aabaab".
- Избриши префикс, и s постаје празан. Број партиција постаје 1.
Према томе, одговор је 1.
Може се показати да није могуће добити више од 1 партиције.

Пример 3:

Улаз: s = "xxyz", k = 1
Излаз: 4
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, s[1] се може променити у 'a'.
s постаје "xayz".
Операције се сада могу извести на следећи начин док s не постане празан:
- Изабери најдужи префикс који садржи највише 1 различит карактер, "xayz".
- Избриши префикс, и s постаје "ayz". Број партиција је сада 1.
- Изабери најдужи префикс који садржи највише 1 различит карактер, "ayz".
- Избриши префикс, и s постаје "yz". Број партиција је сада 2.
- Изабери најдужи префикс који садржи највише 1 различит карактер, "yz".
- Избриши префикс, и s постаје "z". Број партиција је сада 3.
- Изабери најдужи префикс који садржи највише 1 различит карактер, "z".
- Избриши префикс, и s постаје празан. Број партиција је сада 4.
Према томе, одговор је 4.
Може се показати да није могуће добити више од 4 партиције.

Ограничења:

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

Dati su vam string indeksiran od 0, s, i ceo broj k.
Potrebno je da izvršite sledeće operacije particionisanja dok string s ne postane prazan:

- Izaberite najduži prefiks stringa s koji sadrži najviše k različitih karaktera.
- Izbrišite taj prefiks iz s i povećajte broj particija za jedan. Preostali karakteri (ako ih ima) u s zadržavaju svoj početni redosled.

Pre izvođenja operacija, dozvoljeno vam je da promenite najviše jedan indeks u s u neko drugo malo slovo engleskog alfabeta.
Vratite ceo broj koji predstavlja maksimalan broj rezultujućih particija nakon operacija tako što ćete optimalno promeniti najviše jedan indeks.

Пример 1:

Улаз: s = "accca", k = 2
Излаз: 3
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, s[2] се може променити у 'b'.
s постаје "acbca".
Операције се сада могу извести на следећи начин док s не постане празан:
- Изабери најдужи префикс који садржи највише 2 различита карактера, "acbca".
- Избриши префикс, и s постаје "bca". Број партиција је сада 1.
- Изабери најдужи префикс који садржи највише 2 различита карактера, "bca".
- Избриши префикс, и s постаје "a". Број партиција је сада 2.
- Изабери најдужи префикс који садржи највише 2 различита карактера, "a".
- Избриши префикс, и s постаје празан. Број партиција је сада 3.
Према томе, одговор је 3.
Може се показати да није могуће добити више од 3 партиције.

Пример 2:

Улаз: s = "aabaab", k = 3
Излаз: 1
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, можемо оставити s онаквим какав јесте.
Операције се сада могу извести на следећи начин док s не постане празан:
- Изабери најдужи префикс који садржи највише 3 различита карактера, "aabaab".
- Избриши префикс, и s постаје празан. Број партиција постаје 1.
Према томе, одговор је 1.
Може се показати да није могуће добити више од 1 партиције.

Пример 3:

Улаз: s = "xxyz", k = 1
Излаз: 4
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, s[1] се може променити у 'a'.
s постаје "xayz".
Операције се сада могу извести на следећи начин док s не постане празан:
- Изабери најдужи префикс који садржи највише 1 различит карактер, "xayz".
- Избриши префикс, и s постаје "ayz". Број партиција је сада 1.
- Изабери најдужи префикс који садржи највише 1 различит карактер, "ayz".
- Избриши префикс, и s постаје "yz". Број партиција је сада 2.
- Изабери најдужи префикс који садржи највише 1 различит карактер, "yz".
- Избриши префикс, и s постаје "z". Број партиција је сада 3.
- Изабери најдужи префикс који садржи највише 1 различит карактер, "z".
- Избриши префикс, и s постаје празан. Број партиција је сада 4.
Према томе, одговор је 4.
Може се показати да није могуће добити више од 4 партиције.

Ограничења:

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

Дат је стринг s са индексирањем од 0 и цео број k.
Потребно је извршити следеће операције партиционисања све док s не буде празан:

Изаберите најдужи префикс од s који садржи највише k различитих карактера.
Обришите тај префикс из s и повећајте број партиција за један. Преостали карактери (ако их има) у s задржавају свој почетни редослед.

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

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

Пример 1:

Улаз: s = "accca", k = 2
Излаз: 3
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, s[2] се може променити у 'b'.
s постаје "acbca".
Операције се сада могу извести на следећи начин док s не постане празан:
- Изаберите најдужи префикс који садржи највише 2 различита карактера, "acbca".
- Избришите префикс, и s постаје "bca". Број партиција је сада 1.
- Изаберите најдужи префикс који садржи највише 2 различита карактера, "bca".
- Избришите префикс, и s постаје "a". Број партиција је сада 2.
- Изаберите најдужи префикс који садржи највише 2 различита карактера, "a".
- Избришите префикс, и s постаје празан. Број партиција је сада 3.
Према томе, одговор је 3.
Може се покаже да није могуће добити више од 3 партиције.

Пример 2:

Улаз: s = "aabaab", k = 3
Излаз: 1
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, можемо оставити s онаквим какав јесте.
Операције се сада могу извести на следећи начин док s не постане празан:
- Изаберите најдужи префикс који садржи највише 3 различита карактера, "aabaab".
- Избришите префикс, и s постаје празан. Број партиција постаје 1.
Према томе, одговор је 1.
Може се показати да није могуће добити више од 1 партиције.

Пример 3:

Улаз: s = "xxyz", k = 1
Излаз: 4
Објашњење: У овом примеру, да би се максимизирао број резултујућих партиција, s[1] се може променити у 'a'.
s постаје "xayz".
Операције се сада могу извести на следећи начин док s не постане празан:
- Изаберите најдужи префикс који садржи највише 1 различит карактер, "xayz".
- Избришите префикс, и s постаје "ayz". Број партиција је сада 1.
- Изаберите најдужи префикс који садржи највише 1 различит карактер, "ayz".
- Избришите префикс, и s постаје "yz". Број партиција је сада 2.
- Изаберите најдужи префикс који садржи највише 1 различит карактер, "yz".
- Избришите префикс, и s постаје "z". Број партиција је сада 3.
- Изаберите најдужи префикс који садржи највише 1 различит карактер, "z".
- Избришите префикс, и s постаје празан. Број партиција је сада 4.
Према томе, одговор је 4.
Може се показати да није могуће добити више од 4 партиције.

Ограничења:

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


Дата вам је 0-индексирани 2Д низ `variables` где је `variables[i] = [a_i, b_i, c_i, m_i]`, и цео број `target`.
Индекс `i` је добар ако важи следећа формула:

0 <= i < variables.length
((a_i^b_i % 10)^c_i) % m_i == target

Вратите низ који се састоји од добрих индекса у било којем редоследу.

Пример 1:

Улаз: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Излаз: [0,2]
Објашњење: За сваки индекс `i` у низу variables:
1) За индекс 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) За индекс 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) За индекс 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Због тога враћамо [0,2] као одговор.

Пример 2:

Улаз: variables = [[39,3,1000,1000]], target = 17
Излаз: []
Објашњење: За сваки индекс `i` у низу variables:
1) За индекс 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Због тога враћамо [] као одговор.

Ограничења:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Дат вам је 0-индексирани 2D низ variables где variables[i] = [a_i, b_i, c_i, m_i], и целобројни број target.
Индекс i је добар ако важи следећа формула:

$0 \leq i < variables.length$
$((a_i^{b_i} \% 10)^{c_i}) \% m_i = target$

Вратите низ који се састоји од добрих индекса у било ком редоследу.

Пример 1:

Унос: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Излаз: [0,2]
Објашњење: За сваки индекс `i` у низу variables:
1) За индекс 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) За индекс 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) За индекс 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Због тога враћамо [0,2] као одговор.

Пример 2:

Унос: variables = [[39,3,1000,1000]], target = 17
Излаз: []
Објашњење: За сваки индекс `i` у низу variables:
1) За индекс 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Због тога враћамо [] као одговор.

Ограничења:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3

Дата вам је 0-индексирани 2Д низ `variables` где је `variables[i] = [a_i, b_i, c_i, m_i]`, и цео број `target`.
Индекс `i` је добар ако важи следећа формула:

0 <= i < variables.length
((a_i^b_i % 10)^c_i) % m_i == target

Вратите низ који се састоји од добрих индекса у било којем редоследу.

Пример 1:

Унос: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Излаз: [0,2]
Објашњење: За сваки индекс `i` у низу variables:
1) За индекс 0, variables[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) За индекс 1, variables[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) За индекс 2, variables[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Због тога враћамо [0,2] као одговор.

Пример 2:

Унос: variables = [[39,3,1000,1000]], target = 17
Излаз: []
Објашњење: За сваки индекс `i` у низу variables:
1) За индекс 0, variables[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Због тога враћамо [] као одговор.

Ограничења:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3


Дати су вам два 0-индексирана стринга source и target, оба дужине n и састављена од малих енглеских слова. Такође су вам дати два 0-индексирана низа карактера original и changed, као и један низ целих бројева cost, где cost[i] представља цену промене карактера original[i] у карактер changed[i].
Започињете са стрингом source. У једној операцији, можете одабрати карактер x из стринга и променити га у карактер y по цени z ако постоји неки индекс j такав да cost[j] == z, original[j] == x, и changed[j] == y.
Вратите минималну цену за претварање стринга source у стринг target користећи било који број операција. Ако је немогуће претворити source у target, вратите -1.
Напомена: Могу постојати индекси i, j такви да је original[j] == original[i] и changed[j] == changed[i].

Пример 1:

Улаз: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Излаз: 28
Објашњење: Да би се стринг "abcd" конвертовао у стринг "acbe":
- Променити вредност на индексу 1 са 'b' на 'c' по цени од 5.
- Променити вредност на индексу 2 са 'c' на 'e' по цени од 1.
- Променити вредност на индексу 2 са 'e' на 'b' по цени од 2.
- Променити вредност на индексу 3 са 'd' на 'e' по цени од 20.
Укупна цена је 5 + 1 + 2 + 20 = 28.
Може се показати да је ово најмања могућа цена.

Пример 2:

Улаз: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Излаз: 12
Објашњење: Да би се променио карактер 'a' у 'b', потребно је прво променити карактер 'a' у 'c' по цени од 1, а затим променити карактер 'c' у 'b' по цени од 2, за укупну цену од 1 + 2 = 3. Да би се све појаве 'a' промениле у 'b', укупна цена је 3 * 4 = 12.

Пример 3:

Улаз: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Излаз: -1
Објашњење: Немогуће је конвертовати source у target, јер вредност на индексу 3 не може бити промењена са 'd' на 'e'.

Ограничења:

1 <= source.length == target.length <= 10^5
source, target се састоје од малих слова енглеске абецеде.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] су мала слова енглеске абецеде.
1 <= cost[i] <= 10^6
original[i] != changed[i]

Дати су вам два низова 0-индексирана стринга source и target, оба дужине n и састављена од малих слова енглеске абецеде. Такође су вам дати два 0-индексирана ниска original и changed, као и низ целих бројева cost, где cost[i] представља цену промене карактера original[i] на карактер changed[i].
Почињете са стрингом source. У једној операцији можете изабрати карактер x из стринга и променити га у карактер y по цени z ако постоји неки индекс j такав да је cost[j] == z, original[j] == x и changed[j] == y.
Вратите минималну цену за конвертовање стринга source у стринг target користећи било који број операција. Ако је немогуће конвертовати source у target, вратите -1.
Имајте у виду да могу постојати индекси i и j такав да је original[j] == original[i] и changed[j] == changed[i].

Пример 1:

Input: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Output: 28
Објашњење: Да би се стринг "abcd" конвертовао у стринг "acbe":
- Променити вредност на индексу 1 са 'b' на 'c' по цени од 5.
- Променити вредност на индексу 2 са 'c' на 'e' по цени од 1.
- Променити вредност на индексу 2 са 'e' на 'b' по цени од 2.
- Променити вредност на индексу 3 са 'd' на 'e' по цени од 20.
Укупна цена је 5 + 1 + 2 + 20 = 28.
Може се показати да је ово најмања могућа цена.

Пример 2:

Input: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Output: 12
Објашњење: Да би се променио карактер 'a' у 'b', потребно је прво променити карактер 'a' у 'c' по цени од 1, а затим променити карактер 'c' у 'b' по цени од 2, за укупну цену од 1 + 2 = 3. Да би се све појаве 'a' промениле у 'b', укупна цена је 3 * 4 = 12.

Пример 3:

Input: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Output: -1
Објашњење: Немогуће је конвертовати source у target, јер вредност на индексу 3 не може бити промењена са 'd' на 'e'.

Ограничења:

1 <= source.length == target.length <= 10^5
source, target се састоје од малих слова енглеске абецеде.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] су мала слова енглеске абецеде.
1 <= cost[i] <= 10^6
original[i] != changed[i]


Дат вам је низ целих бројева nums индексиран са 0.
Префикс nums[0..i] је секвенцијалан ако за све 1 <= j <= i важи nums[j] = nums[j - 1] + 1. Нарочито, префикс који се састоји само од nums[0] је секвенцијалан.
Вратите најмањи цео број x који недостаје из nums такав да је x већи или једнак збиру најдужег секвенцијалног префикса.

Пример 1:

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

Пример 2:

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

Ограничења:

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

Дат вам је низ целих бројева nums индексиран са 0.
Префикс nums[0..i] је секвенцијалан ако за све 1 <= j <= i важи nums[j] = nums[j - 1] + 1. Нарочито, префикс који се састоји само од nums[0] је секвенцијалан.
Вратите најмањи цео број x који недостаје из nums такав да је x већи или једнак збиру најдужег секвенцијалног префикса.

Пример 1:

Unos: nums = [1,2,3,2,5]
Izlaz: 6
Објашњење: Најдужи секвенцијални префикс од nums је [1,2,3] са збиром 6. 6 није у низу, дакле, 6 је најмањи недостајући број који је већи или једнак збиру најдужег секвенцијалног префикса.

Пример 2:

Unos: nums = [3,4,5,1,12,14,13]
Izlaz: 15
Објашњење: Најдужи секвенцијални префикс од nums је [3,4,5] са збиром 12. 12, 13, и 14 припадају низу, док 15 не. Дакле, 15 је најмањи недостајући број који је већи или једнак збиру најдужег секвенцијалног префикса.

Ограничења:

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

Дат вам је низ целих бројева nums индексиран са 0.
Префикс nums[0..i] је секвенцијалан ако за све 1 <= j <= i важи nums[j] = nums[j - 1] + 1. Нарочито, префикс који се састоји само од nums[0] је секвенцијалан.
Вратите најмањи цео број x који недостаје из nums такав да је x већи или једнак збиру најдужег секвенцијалног префикса.

Пример 1:

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

Пример 2:

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

Ограничења:

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


Дати су вам два позитивна цела броја x и y.
У једној операцији, можете извршити једну од четири следеће операције:

Поделити x са 11 ако је x дељив са 11.
Поделити x са 5 ако је x дељив са 5.
Смањити x за 1.
Повећати x за 1.

Врати минималан број операција потребних да x и y буду једнаки.

Пример 1:

Улаз: x = 26, y = 1
Излаз: 3
Објашњење: Можемо учинити 26 једнаким 1 применом следећих операција:
1. Смањити x за 1
2. Поделити x са 5
3. Поделити x са 5
Може се показати да је 3 минималан број операција потребан да 26 буде једнако 1.

Пример 2:

Улаз: x = 54, y = 2
Излаз: 4
Објашњење: Можемо учинити 54 једнаким 2 применом следећих операција:
1. Повећати x за 1
2. Поделити x са 11
3. Поделити x са 5
4. Повећати x за 1
Може се показати да је 4 минималан број операција потребан да 54 буде једнако 2.

Пример 3:

Улаз: x = 25, y = 30
Излаз: 5
Објашњење: Можемо учинити 25 једнаким 30 применом следећих операција:
1. Повећати x за 1
2. Повећати x за 1
3. Повећати x за 1
4. Повећати x за 1
5. Повећати x за 1
Може се показати да је 5 минималан број операција потребан да 25 буде једнако 30.

Ограничења:

1 <= x, y <= 10^4

Дата су вам два позитивна цела броја, x и y.
У једној операцији можете извршити једну од следеће четири операције:

- Поделити x са 11 ако је x дељив са 11.
- Поделити x са 5 ако је x дељив са 5.
- Смањити xза 1.
- Повећати x за 1.

Вратите минималан број операција потребних да `x` и `y` постану једнаки.

Пример 1:

Улаз: x = 26, y = 1
Излаз: 3
Објашњење: Можемо учинити 26 једнаким 1 применом следећих операција:
1. Смањити x за 1
2. Поделити x са 5
3. Поделити x са 5
Може се показати да је 3 минималан број операција потребан да 26 буде једнако 1.

Пример 2:

Улаз: x = 54, y = 2
Излаз: 4
Објашњење: Можемо учинити 54 једнаким 2 применом следећих операција:
1. Повећати x за 1
2. Поделити x са 11
3. Поделити x са 5
4. Повећати x за 1
Може се показати да је 4 минималан број операција потребан да 54 буде једнако 2.

Пример 3:

Улаз: x = 25, y = 30
Излаз: 5
Објашњење: Можемо учинити 25 једнаким 30 применом следећих операција:
1. Повећати x за 1
2. Повећати x за 1
3. Повећати x за 1
4. Повећати x за 1
5. Повећати x за 1
Може се показати да је 5 минималан број операција потребан да 25 буде једнако 30.

Ограничења:

1 <= x, y <= 10^4


Dat je ceo broj \( k \) i ceo broj \( x \).
Razmotrite \( s \) kao binarni zapis celog broja \( \text{num} \), indeksiran od 1. Cena broja \( \text{num} \) je broj vrednosti \( i \) za koje važi \( i \% x == 0 \) i \( s[i] \) je postavljen bit (bit sa vrednošću 1).
Vratite najveći ceo broj \( \text{num} \) takav da je suma cena svih brojeva od 1 do \( \text{num} \) manja ili jednaka \( k \).

Напомена:

У бинарном представљању броја постављен бит је бит вредности 1.
Бинарни приказ броја ће бити индексиран са десна на лево. На пример, ако је s == 11100, s[4] == 1 и s[2] == 0.

Пример 1:

Улаз: k = 9, x = 1
Излаз: 6
Објашњење: Бројеви 1, 2, 3, 4, 5 и 6 могу се написати у бинарном облику као "1", "10", "11", "100", "101" и "110" респективно.
Пошто је x једнако 1, цена сваког броја је број постављених битова.
Број постављених битова у овим бројевима је 9. Дакле, збир цена првих 6 бројева је 9.
Дакле, одговор је 6.

Пример 2:

Улаз: k = 7, x = 2
Излаз: 9
Објашњење: Пошто је x једнако 2, требало би проверавати само парне^те битове.
Други бит бинарног приказа бројева 2 и 3 је постављен бит. Дакле, збир њихових цена је 2.
Други бит бинарног приказа бројева 6 и 7 је постављен бит. Дакле, збир њихових цена је 2.
Четврти бит бинарног приказа бројева 8 и 9 је постављен бит док њихов други бит није. Дакле, збир њихових цена је 2.
Бројеви 1, 4 и 5 немају постављене битове у својим парним^тим битовима у бинарном приказу. Дакле, збир њихових цена је 0.
Други и четврти бит бинарног приказа броја 10 су постављени битови. Дакле, његова цена је 2.
Збир цена првих 9 бројева је 6.
Пошто је збир цена првих 10 бројева 8, одговор је 9.

Ограничења:

1 <= k <= 10^15
1 <= x <= 8

Дат је цео број k и цео број x.
Размотримо да је s бинарни приказ целог броја num са индексима почевши од 1. Цена броја num је број i тако да i % x == 0 и s[i] је постављен бит.
Вратити највећи целобројни num такав да је збир цена свих бројева од 1 до num мањи или једнак k.

Напомена:

У бинарном представљању броја постављен бит је бит вредности 1.
Бинарни приказ броја ће бити индексиран са десна на лево. На пример, ако је s == 11100, s[4] == 1 и s[2] == 0.

Пример 1:

Улаз: k = 9, x = 1
Излаз: 6
Објашњење: Бројеви 1, 2, 3, 4, 5 и 6 могу се написати у бинарном облику као "1", "10", "11", "100", "101" и "110" респективно.
Пошто је x једнако 1, цена сваког броја је број постављених битова.
Број постављених битова у овим бројевима је 9. Дакле, збир цена првих 6 бројева је 9.
Дакле, одговор је 6.

Пример 2:

Улаз: k = 7, x = 2
Излаз: 9
Објашњење: Пошто је x једнако 2, требало би проверавати само парне^те битове.
Други бит бинарног приказа бројева 2 и 3 је постављен бит. Дакле, збир њихових цена је 2.
Други бит бинарног приказа бројева 6 и 7 је постављен бит. Дакле, збир њихових цена је 2.
Четврти бит бинарног приказа бројева 8 и 9 је постављен бит док њихов други бит није. Дакле, збир њихових цена је 2.
Бројеви 1, 4 и 5 немају постављене битове у својим парним^тим битовима у бинарном приказу. Дакле, збир њихових цена је 0.
Други и четврти бит бинарног приказа броја 10 су постављени битови. Дакле, његова цена је 2.
Збир цена првих 9 бројева је 6.
Пошто је збир цена првих 10 бројева 8, одговор је 9.

Ограничења:

1 <= k <= 10^15
1 <= x <= 8

Дат је цео број k и цео број x.
Размотримо да је s бинарни приказ целог броја num са индексима почевши од 1. Цена броја num је број i тако да i % x == 0 и s[i] је постављен бит.
Вратити највећи целобројни num такав да је збир цена свих бројева од 1 до num мањи или једнак k.
Напомена:

У бинарном представљању броја постављен бит је бит вредности 1.
Бинарни приказ броја ће бити индексиран са десна на лево. На пример, ако је s == 11100, s[4] == 1 and s[2] == 0.

Пример 1:

Улаз: k = 9, x = 1
Излаз: 6
Објашњење: Бројеви 1, 2, 3, 4, 5 и 6 могу се написати у бинарном облику као "1", "10", "11", "100", "101" и "110" респективно.
Пошто је x једнако 1, цена сваког броја је број постављених битова.
Број постављених битова у овим бројевима је 9. Дакле, збир цена првих 6 бројева је 9.
Дакле, одговор је 6.

Пример 2:

Улаз: k = 7, x = 2
Излаз: 9
Објашњење: Пошто је x једнако 2, требало би проверавати само парне^те битове.
Други бит бинарног приказа бројева 2 и 3 је постављен бит. Дакле, збир њихових цена је 2.
Други бит бинарног приказа бројева 6 и 7 је постављен бит. Дакле, збир њихових цена је 2.
Четврти бит бинарног приказа бројева 8 и 9 је постављен бит док њихов други бит није. Дакле, збир њихових цена је 2.
Бројеви 1, 4 и 5 немају постављене битове у својим парним^тим битовима у бинарном приказу. Дакле, збир њихових цена је 0.
Други и четврти бит бинарног приказа броја 10 су постављени битови. Дакле, његова цена је 2.
Збир цена првих 9 бројева је 6.
Пошто је збир цена првих 10 бројева 8, одговор је 9.

Ограничења:

1 <= k <= 10^15
1 <= x <= 8


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

Пример 1:

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

Пример 2:

Улаз: nums = [1,2,3,4,5]
Излаз: 5
Објашњење: Сви елементи у низу имају фреквенцију 1 која је максимална.
Дакле, број елемената у низу са максималном фреквенцијом је 5.

Ограничења:

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

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

Пример 1:

Input: nums = [1,2,2,3,1,4]
Output: 4
Објашњење: Елементи 1 и 2 имају фреквенцију 2 која је максимална фреквенција у низу.
Дакле, број елемената у низу са максималном фреквенцијом је 4.

Пример 2:

Input: nums = [1,2,3,4,5]
Output: 5
Објашњење: Сви елементи у низу имају фреквенцију 1 која је максимална.
Дакле, број елемената у низу са максималном фреквенцијом је 5.

Ограничења:

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

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

Пример 1:

Input: nums = [1,2,2,3,1,4]
Output: 4
Објашњење: Елементи 1 и 2 имају фреквенцију 2 која је максимална фреквенција у низу.
Дакле, број елемената у низу са максималном фреквенцијом је 4.

Пример 2:

Input: nums = [1,2,3,4,5]
Output: 5
Објашњење: Сви елементи у низу имају фреквенцију 1 која је максимална.
Дакле, број елемената у низу са максималном фреквенцијом је 5.

Ограничења:

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


Дати су вам три цела броја start, finish и limit. Такође вам је дат низ s индексиран од 0 који представља позитиван цео број. Позитиван цео број x назива се моћним ако се завршава са s (другим речима, s је суфикс од x) и свака цифра у x је највише limit. Вратите укупан број моћних целих бројева у опсегу [start..finish]. Низ x је суфикс низа y ако и само ако је x подниз од y који почиње од неког индекса (укључујући 0) у y и протеже се до индекса y.length - 1. На пример, 25 је суфикс од 5125 док 512 није.

Пример 1:

Унос: start = 1, finish = 6000, limit = 4, s = "124"
Излаз: 5
Објашњење: Моћни цели бројеви у опсегу [1..6000] су 124, 1124, 2124, 3124 и 4124. Сви ови цели бројеви имају сваку цифру <= 4 и "124" као суфикс. Напомињемо да 5124 није моћан број јер је прва цифра 5 која је већа од 4. Може се показати да постоји само 5 моћних бројева у овом опсегу.

Пример 2:

Унос: start = 15, finish = 215, limit = 6, s = "10"
Излаз: 2
Објашњење: Моћни цели бројеви у опсегу [15..215] су 110 и 210. Сви ови цели бројеви имају сваку цифру <= 6 и "10" као суфикс. Може се показати да постоје само 2 моћна броја у овом опсегу.

Пример 3:

Унос: start = 1000, finish = 2000, limit = 4, s = "3000"
Излаз: 0
Објашњење: Сви цели бројеви у опсегу [1000..2000] су мањи од 3000, па "3000" не може бити суфикс ниједног броја у овом опсегу.

Ограничења:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s се састоји само од цифара које су највише limit.
s нема водеће нуле.

Дати су вам три цела броја start, finish и limit. Такође вам је дат низ s индексиран од 0 који представља позитиван цео број. Позитиван цео број x назива се моћним ако се завршава са s (другим речима, s је суфикс од x) и свака цифра у x је највише limit. Вратите укупан број моћних целих бројева у опсегу [start..finish]. Низ x је суфикс низа y ако и само ако је x подниз од y који почиње од неког индекса (укључујући 0) у y и протеже се до индекса y.length - 1. На пример, 25 је суфикс од 5125 док 512 није.

Пример 1:

Улаз: start = 1, finish = 6000, limit = 4, s = "124"
Излаз: 5
Објашњење: Моћни цели бројеви у опсегу [1..6000] су 124, 1124, 2124, 3124 и 4124. Сви ови цели бројеви имају сваку цифру <= 4 и "124" као суфикс. Напомињемо да 5124 није моћан број јер је прва цифра 5 која је већа од 4. Може се показати да постоји само 5 моћних бројева у овом опсегу.

Пример 2:

Улаз: start = 15, finish = 215, limit = 6, s = "10"
Излаз: 2
Објашњење: Моћни цели бројеви у опсегу [15..215] су 110 и 210. Сви ови цели бројеви имају сваку цифру <= 6 и "10" као суфикс. Може се показати да постоје само 2 моћна броја у овом опсегу.

Пример 3:

Улаз: start = 1000, finish = 2000, limit = 4, s = "3000"
Излаз: 0
Објашњење: Сви цели бројеви у опсегу [1000..2000] су мањи од 3000, па "3000" не може бити суфикс ниједног броја у овом опсегу.

Ограничења:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s се састоји само од цифара које су највише limit.
s нема водеће нуле.

Dat je tri cela broja: `start`, `finish` i `limit`. Takođe, dat je 0-indeksirani string `s` koji predstavlja pozitivan ceo broj.
Pozitivan ceo broj `x` se naziva moćan ako se završava sa `s` (drugim rečima, `s` je sufiks broja `x`) i ako je svaka cifra u `x` manja ili jednaka vrednosti `limit`.  Vrati ukupan broj moćnih celih brojeva u opsegu `[start..finish]`.

String `x` je sufiks stringa `y` ako i samo ako je `x` podstring `y` koji počinje na nekom indeksu (uključujući 0) u `y` i proteže se do indeksa `y.length - 1`. Na primer, `25` je sufiks broja `5125`, dok `512` nije.

Пример 1:

Унос: start = 1, finish = 6000, limit = 4, s = "124"
Излаз: 5
Објашњење: Моћни цели бројеви у опсегу [1..6000] су 124, 1124, 2124, 3124 и 4124. Сви ови цели бројеви имају сваку цифру <= 4 и "124" као суфикс. Напомињемо да 5124 није моћан број јер је прва цифра 5 која је већа од 4. Може се показати да постоји само 5 моћних бројева у овом опсегу.

Пример 2:

Унос: start = 15, finish = 215, limit = 6, s = "10"
Излаз: 2
Објашњење: Моћни цели бројеви у опсегу [15..215] су 110 и 210. Сви ови цели бројеви имају сваку цифру <= 6 и "10" као суфикс. Може се показати да постоје само 2 моћна броја у овом опсегу.

Пример 3:

Унос: start = 1000, finish = 2000, limit = 4, s = "3000"
Излаз: 0
Објашњење: Сви цели бројеви у опсегу [1000..2000] су мањи од 3000, па "3000" не може бити суфикс ниједног броја у овом опсегу.

Ограничења:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s се састоји само од цифара које су највише limit.
s нема водеће нуле.


Дат вам је низ целих бројева индексираних од 0, nums, који садржи позитивне целе бројеве.
Ваш задатак је да минимализујете дужину низа nums извођењем следећих операција било који број пута (укључујући нулу):

Изаберите два различита индекса i и j из низа nums, тако да је nums[i] > 0 и nums[j] > 0.
Уметните резултат nums[i] % nums[j] на крај низа nums.
Обришите елементе на индексима i и j из низа nums.

Вратите цео број који означава минималну дужину низа nums након извођења операције било који број пута.

Пример 1:

Input: nums = [1,4,3,1]
Output: 1
Објашњење: Један начин да се минимализује дужина низа је следећи:
Операција 1: Изаберите индексе 2 и 1, уметните nums[2] % nums[1] на крај и постаје [1,4,3,1,3], затим обришите елементе на индексима 2 и 1.
nums постаје [1,1,3].
Операција 2: Изаберите индексе 1 и 2, уметните nums[1] % nums[2] на крај и постаје [1,1,3,1], затим обришите елементе на индексима 1 и 2.
nums постаје [1,1].
Операција 3: Изаберите индексе 1 и 0, уметните nums[1] % nums[0] на крај и постаје [1,1,0], затим обришите елементе на индексима 1 и 0.
nums постаје [0].
Дужина низа nums се не може више смањити. Зато је одговор 1.
Може се показати да је 1 минимално достижна дужина.
Пример 2:

Input: nums = [5,5,5,10,5]
Output: 2
Објашњење: Један начин да се минимализује дужина низа је следећи:
Операција 1: Изаберите индексе 0 и 3, уметните nums[0] % nums[3] на крај и постаје [5,5,5,10,5,5], затим обришите елементе на индексима 0 и 3.
nums постаје [5,5,5,5].
Операција 2: Изаберите индексе 2 и 3, уметните nums[2] % nums[3] на крај и постаје [5,5,5,5,0], затим обришите елементе на индексима 2 и 3.
nums постаје [5,5,0].
Операција 3: Изаберите индексе 0 и 1, уметните nums[0] % nums[1] на крај и постаје [5,5,0,0], затим обришите елементе на индексима 0 и 1.
nums постаје [0,0].
Дужина низа nums се не може више смањити. Зато је одговор 2.
Може се показати да је 2 минимално достижна дужина.
Пример 3:

Input: nums = [2,3,4]
Output: 1
Објашњење: Један начин да се минимализује дужина низа је следећи:
Операција 1: Изаберите индексе 1 и 2, уметните nums[1] % nums[2] на крај и постаје [2,3,4,3], затим обришите елементе на индексима 1 и 2.
nums постаје [2,3].
Операција 2: Изаберите индексе 1 и 0, уметните nums[1] % nums[0] на крај и постаје [2,3,1], затим обришите елементе на индексима 1 и 0.
nums постаје [1].
Дужина низа nums се не може више смањити. Зато је одговор 1.
Може се показати да је 1 минимално достижна дужина.

Ограничења:

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

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

Изаберите два различита индекса i и j из низа nums, тако да је nums[i] > 0 и nums[j] > 0.
Уметните резултат nums[i] % nums[j] на крај низа nums.
Обришите елементе на индексима i и j из низа nums.

Вратите цео број који означава минималну дужину низа nums након извођења операције било који број пута.

Пример 1:

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

Улаз: nums = [5,5,5,10,5]
Излаз: 2
Објашњење: Један начин да се минимализује дужина низа је следећи:
Операција 1: Изаберите индексе 0 и 3, уметните nums[0] % nums[3] на крај и постаје [5,5,5,10,5,5], затим обришите елементе на индексима 0 и 3.
nums постаје [5,5,5,5].
Операција 2: Изаберите индексе 2 и 3, уметните nums[2] % nums[3] на крај и постаје [5,5,5,5,0], затим обришите елементе на индексима 2 и 3.
nums постаје [5,5,0].
Операција 3: Изаберите индексе 0 и 1, уметните nums[0] % nums[1] на крај и постаје [5,5,0,0], затим обришите елементе на индексима 0 и 1.
nums постаје [0,0].
Дужина низа nums се не може више смањити. Дакле, одговор је 2.
Може се показати да је 2 минимално достижна дужина.
Пример 3:

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

Ограничења:

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

Дат вам је низ целих бројева индексираних од 0, nums, који садржи позитивне целе бројеве.
Ваш задатак је да минимализујете дужину низа nums извођењем следећих операција било који број пута (укључујући нулу):
Изаберите два различита индекса i и j из низа nums, тако да је nums[i] > 0 и nums[j] > 0.
Уметните резултат nums[i] % nums[j] на крај низа nums.
Обришите елементе на индексима i и j из низа nums.

Вратите цео број који означава минималну дужину низа nums након извођења операције било који број пута.

Пример 1:

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

Улаз: nums = [5,5,5,10,5]
Излаз: 2
Објашњење: Један од начина да се минимизира дужина низа је следећи:
Операција 1: Изаберите индексе 0 и 3, уметните nums[0] % nums[3] на крај и постаје [5,5,5,10,5,5], затим обришите елементе на индексима 0 и 3.
nums постаје [5,5,5,5].
Операција 2: Изаберите индексе 2 и 3, уметните nums[2] % nums[3] на крај и постаје [5,5,5,5,0], затим обришите елементе на индексима 2 и 3.
nums постаје [5,5,0].
Операција 3: Изаберите индексе 0 и 1, уметните nums[0] % nums[1] на крај и постаје [5,5,0,0], затим обришите елементе на индексима 0 и 1.
nums постаје [0,0].
Дужина низа nums се не може више смањити. Зато је одговор 2.
Може се показати да је 2 минимално достижна дужина.
Пример 3:

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

Ограничења:

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


Дат вам је низ индексиран са 0, низ s, низ a, низ b и целобројни k.
Индекс i је леп ако:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Постоји индекс „j“ такав да:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

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

Пример 1:

Улаз: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Излаз: [16,33]
Објашњење: Постоје 2 лепа индекса: [16,33].
- Индекс 16 је леп јер је s[16..17] == "my" и постоји индекс 4 са s[4..11] == "squirrel" и |16 - 4| <= 15.
- Индекс 33 је леп јер је s[33..34] == "my" и постоји индекс 18 са s[18..25] == "squirrel" и |33 - 18| <= 15.
Тако враћамо [16,33] као резултат.

Пример 2:

Улаз: s = "abcd", a = "a", b = "a", k = 4
Излаз: [0]
Објашњење: Постоји 1 леп индекс: [0].
- Индекс 0 је леп јер је s[0..0] == "a" и постоји индекс 0 са s[0..0] == "a" и |0 - 0| <= 4.
Тако враћамо [0] као резултат.

Ограничења:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a и b садрже само мала енглеска слова.

Добили сте се на 0-iндексираном низу, стринг a, низ b и цели број к.
Индекс је прелеп ако:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Постоји индекс Ј тако да:

0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k

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

Пример 1:

ИНПУТ: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Излаз: [16,33]
Објашњење: Постоје 2 прелепа индекса: [16,33].
- Индекс 16 је леп као с [16..17] =="my" и постоји индекс 4 са s[4..11] == "squirrel" и |16 - 4| <= 15
- Индекс 33 је прелепо као и [33..34] == "my" и постоји индекс 18 са s[18..25] == "squirrel" и |33 - 18| <= 15.
Тако се враћа [16,33] као резултат

Пример 2:

ИНПУТ: s = "abcd", a = "a", b = "a", k = 4
Излаз: [0]
Објашњење: Постоји 1 леп индекс: [0].
- Индекс 0 је леп као с [0..0] == "a" и постоји индекс 0 са [0..0] == "a" и | 0 - 0 | <= 4.
Тако се враћамо као резултат.

ОГРАНИЧЕЊА:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, а и б садрже само мала слова енглеског језика.

Дати су вам низ s са индексом 0, низ a, низ b и целобројни k.

0 <= i <= s.дужина - a.дужина
s[i..(i + a.дужина - 1)] == a
Постоји индекс „j“ такав да:

0 <= j <= s.дужина - b.дужина
s[j..(j + b.дужина - 1)] == b
|j - i| <= k

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

Пример 1:

Улаз: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Излаз: [16,33]
Објашњење: Постоје 2 лепа индекса: [16,33].
- Индекс 16 је леп јер је s[16..17] == "my" и постоји индекс 4 са s[4..11] == "squirrel" и |16 - 4| <= 15.
- Индекс 33 је леп јер је s[33..34] == "my" и постоји индекс 18 са s[18..25] == "squirrel" и |33 - 18| <= 15.
Тако враћамо [16,33] као резултат.

Пример 2:

Улаз: s = "abcd", a = "a", b = "a", k = 4
Излаз: [0]
Објашњење: Постоји 1 леп индекс: [0].
- Индекс 0 је леп јер је s[0..0] == "a" и постоји индекс 0 са s[0..0] == "a" и |0 - 0| <= 4.
Тако враћамо [0] као резултат.

Ограничења:

1 <= k <= s.дужина <= 10^5
1 <= a.дужина, b.дужина <= 10
s, a и b садрже само мала слова енглеске абецеде.


Дат је низ позитивних целих бројева nums.
Морате проверити да ли је могуће изабрати два или више елемената у низу тако да битовски OR изабраних елемената има најмање једну задњу нулу у својој бинарној репрезентацији.
На пример, бинарна репрезентација броја 5, што је "101", нема задње нуле, док бинарна репрезентација броја 4, што је "100", има две задње нуле.
Вратите true ако је могуће изабрати два или више елемената чији битовски OR има задње нуле, у супротном вратите false.

Пример 1:

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

Пример 2:

Улаз: nums = [2,4,8,16]
Излаз: true
Објашњење: Ако изаберемо елементе 2 и 4, њихов битовски OR је 6, што има бинарну репрезентацију "110" са једном задњом нулом.
Други могући начини избора елемената који имају задње нуле у бинарној репрезентацији њиховог битовског OR-а су: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), и (2, 4, 8, 16).

Пример 3:

Улаз: nums = [1,3,5,7,9]
Излаз: false
Објашњење: Не постоји начин да се изаберу два или више елемената тако да имају задње нуле у бинарној репрезентацији њиховог битовског OR-а.

Ограничења:

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

Here is the translation of the given text into Serbian (Cyrillic script):

Дат вам је низ позитивних целих бројева nums.
Треба да проверите да ли је могуће изабрати два или више елемената из низа тако да битовски ОР изабраних елемената има бар једну задњу нулу у свом бинарном представљању.
На пример, бинарно представљање броја 5, које је "101", нема задње нуле, док бинарно представљање броја 4, које је "100", има две задње нуле.

Вратите true ако је могуће изабрати два или више елемената чији битовски ОР има задње нуле, вратите false у супротном.

Пример 1:

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

Пример 2:

Улаз: nums = [2,4,8,16]
Излаз: true
Објашњење: Ако изаберемо елементе 2 и 4, њихов битовски OR је 6, што има бинарну репрезентацију "110" са једном задњом нулом.
Други могући начини избора елемената који имају задње нуле у бинарној репрезентацији њиховог битовског OR-а су: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), и (2, 4, 8, 16).

Пример 3:

Улаз: nums = [1,3,5,7,9]
Излаз: false
Објашњење: Не постоји начин да се изаберу два или више елемената тако да имају задње нуле у бинарној репрезентацији њиховог битовског OR-а.

Ограничења:

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