Дата су вам два позитивна цела броја, low и high.
Цео број x који се састоји од 2 * n цифара је симетричан ако је збир првих n цифара броја x једнак збиру последњих n цифара броја x. Бројеви са непарним бројем цифара никада нису симетрични.
Вратите број симетричних целих бројева у опсегу [low, high].

Пример 1:

Улаз: low = 1, high = 100
Излаз: 9
Објашњење: Постоји 9 симетричних целих бројева између 1 и 100: 11, 22, 33, 44, 55, 66, 77, 88 и 99.

Пример 2:

Улаз: low = 1200, high = 1230
Излаз: 4
Објашњење: Постоје 4 симетрична цела броја између 1200 и 1230: 1203, 1212, 1221 и 1230.

Ограничења:

1 <= low <= high <= 10^4

Дата су два позитивна цела броја low и high.
Цео број x који се састоји од 2 * n цифара је симетричан ако је збир првих n цифара x једнак збиру последњих n цифара x. Бројеви са непарним бројем цифара никада нису симетрични.
Вратите број симетричних цели бројева у опсегу [low, high].

Пример 1:

Улаз: low = 1, high = 100
Излаз: 9
Објашњење: Постоји 9 симетричних целих бројева између 1 и 100: 11, 22, 33, 44, 55, 66, 77, 88 и 99.

Пример 2:

Улаз: low = 1200, high = 1230
Излаз: 4
Објашњење: Постоје 4 симетрична цела броја између 1200 и 1230: 1203, 1212, 1221 и 1230.

Ограничења:

1 <= low <= high <= 10^4


Дате су вам две ниске s1 и s2, обе дужине 4, састављене од малих енглеских слова.
Можете применити следећу операцију на било коју од две ниске било који број пута:

Изаберите било која два индекса i и j таква да је j - i = 2, затим замените два знака на тим индексима у низу.

Вратите true ако можете учинити да ниске s1 и s2 буду једнаке, или false у супротном.

Пример 1:

Улаз: s1 = "abcd", s2 = "cdab"
Излаз: true
Објашњење: Можемо урадити следеће операције на s1:
- Изаберите индексе i = 0, j = 2. Резултујућа ниска је s1 = "cbad".
- Изаберите индексе i = 1, j = 3. Резултујућа ниска је s1 = "cdab" = s2.

Пример 2:

Улаз: s1 = "abcd", s2 = "dacb"
Излаз: false
Објашњење: Није могуће учинити да две ниске буду једнаке.

Ограничења:

s1.length == s2.length == 4
s1 и s2 се састоје само од малих енглеских слова.

С обзиром на две низови s1 и s2, обе дужине 4, који се састоје од малих слова на енглеском језику.
Следеће операције можете применити на било којој од два низа било који број пута:

Изаберите било која два индекса i и j таквих да j - i = 2, затим замените два лика на тим индексима у низу.

Вратите истина ако можете да направите низови С1 и С2 једнаке и лаж у супротном.

Пример 1:

ИНПУТ:  s1 = "abcd", s2 = "cdab"
Излаз: истина
Објашњење: Можемо да урадимо следеће операције на С1:
- Изаберите индексе i = 0, j = 2. Резултујућа ниска је s1 = "cbad".
- Изаберите индексе i = 1, j = 3. Резултујућа ниска је s1 = "cdab" = s2.

Пример 2:

ИНПУТ: s1 = "abcd", s2 = "dacb"
Излаз: лажно
Објашњење: Није могуће направити две низови једнаке.

Ограничења:

s1.length == s2.length == 4
s1 и s2 се састоје само од малих енглеских слова.


Дат је 0-индексни низ целих бројева nums и цео број x.
Пронађите минималну апсолутну разлику између два елемента у низу који су најмање x индекса размакнути.
Другим речима, нађите два индекса i и j таква да је abs(i - j) >= x и да је abs(nums[i] - nums[j]) минимализована.
Вратите цео број који представља минималну апсолутну разлику између два елемента који су удаљени барем x индекса.

Пример 1:

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

Пример 2:

Улаз: nums = [5,3,2,10,15], x = 1
Излаз: 1
Објашњење: Можемо изабрати nums[1] = 3 и nums[2] = 2.
Они су најмање 1 индекс раздвојени, а њихова апсолутна разлика је минимална, 1.
Може се показати да је 1 оптималан одговор.

Пример 3:

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

Ограничења:

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

Дат је 0-индексни низ целих бројева nums и цео број x.
Нађите минималну апсолутну разлику између два елемента у низу који су најмање x индекса размакнути.
Другим речима, нађите два индекса i и j таква да је abs(i - j) >= x и да је abs(nums[i] - nums[j]) минимализована.
Вратите цео број који представља минималну апсолутну разлику између два елемента који су удаљени најмање x индекса.

Пример 1:

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

Пример 2:

Унос: nums = [5,3,2,10,15], x = 1
Излаз: 1
Објашњење: Можемо изабрати nums[1] = 3 и nums[2] = 2.
Они су најмање 1 индекс раздвојени, а њихова апсолутна разлика је минимална, 1.
Може се показати да је 1 оптималан одговор.

Пример 3:

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

Ограничења:

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

Дат је 0-индексни низ целих бројева nums и цео број x.
Нађите минималну апсолутну разлику између два елемента у низу који су најмање x индекса размакнути.
Другим речима, нађите два индекса i и j таква да је abs(i - j) >= x и да је abs(nums[i] - nums[j]) минимализована.
Вратите цео број који означава минималну апсолутну разлику између два елемента који су најмање x индекса размакнути.

Пример 1:

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

Пример 2:

Унос: nums = [5,3,2,10,15], x = 1
Излаз: 1
Објашњење: Можемо изабрати nums[1] = 3 и nums[2] = 2.
Они су најмање 1 индекс раздвојени, а њихова апсолутна разлика је минимална, 1.
Може се показати да је 1 оптималан одговор.

Пример 3:

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

Ограничења:

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


Дати су вам позитивни цели бројеви low, high и k.
Број је леп ако испуњава оба следећа услова:

Број парних цифара у броју једнак је броју непарних цифара.
Број је дељив са k.

Вратите број лепих целих бројева у опсегу [low, high].

Пример 1:

Улаз: low = 10, high = 20, k = 3
Излаз: 2
Објашњење: Постоје 2 лепа цела броја у датом опсегу: [12,18].
- 12 је леп јер садржи 1 непарну цифру и 1 парну цифру, и дељив је са k = 3.
- 18 је леп јер садржи 1 непарну цифру и 1 парну цифру, и дељив је са k = 3.
Додатно можемо видети да:
- 16 није леп јер није дељив са k = 3.
- 15 није леп јер не садржи исти број парних и непарних цифара.
Може се показати да постоје само 2 лепа цела броја у датом опсегу.

Пример 2:

Улаз: low = 1, high = 10, k = 1
Излаз: 1
Објашњење: Постоји 1 леп цео број у датом опсегу: [10].
- 10 је леп јер садржи 1 непарну цифру и 1 парну цифру, и дељив је са k = 1.
Може се показати да постоји само 1 леп цео број у датом опсегу.

Пример 3:

Улаз: low = 5, high = 5, k = 2
Излаз: 0
Објашњење: Постоји 0 лепих целих бројева у датом опсегу.
- 5 није леп јер није дељив са k = 2 и не садржи исти број парних и непарних цифара.

Ограничења:

0 < low <= high <= 10^9
0 < k <= 20


Дат вам је два низа са индексима који почињу од 0: str1 и str2.
У операцији, изаберете скуп индекса у str1, и за сваки индекс i у том скупу, инкрементирате str1[i] на следећи карактер циклично. То значи да 'a' постаје 'b', 'b' постаје 'c', и тако даље, а 'z' постаје 'a'.
Вратите тачно ако је могуће учинити да str2 буде подниз str1 обављањем операције највише једном, и нетачно у супротном.

Напомена: Подниз низа је нови низ који се формира из оригиналног низа брисањем неких (можда ниједног) карактера, без нарушавања релативних позиција преосталих карактера.

Пример 1:

Улаз: str1 = "abc", str2 = "ad"
Излаз: true
Објашњење: Изаберите индекс 2 у str1.
Инкрементирајте str1[2] да постане 'd'.
Тако, str1 постаје "abd" и str2 је сада подсеквенца. Због тога, враћа се true.
Пример 2:

Улаз: str1 = "zc", str2 = "ad"
Излаз: true
Објашњење: Изаберите индексе 0 и 1 у str1.
Инкрементирајте str1[0] да постане 'a'.
Инкрементирајте str1[1] да постане 'd'.
Тако, str1 постаје "ad" и str2 је сада подсеквенца. Због тога, враћа се true.
Пример 3:

Input: str1 = "ab", str2 = "d"
Output: false
Објашњење: У овом примеру се може приказати да није могуће направити str2 подсеквенцом str1 користећи операцију највише једном.
Због тога, враћа се false.

Ограничења:

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

Дати су вам два стринга са индексом од 0, str1 и str2.
У једној операцији, изаберете скуп индекса у str1, и за сваки индекс i у том скупу, повећате str1[i] на следећи карактер циклично. То занчи да  'a' постаје 'b', 'b' постаје 'c', и тако даље, а 'z' постаје 'a'.
Вратите true ако је могуће направити да str2 као подниз од str1 извршавањем операције највише једном, иначе  вратите false. Напомена: Подниз ниске је нова ниска која се формира из оригиналне ниске брисањем неких (могуће ниједног) карактера, без нарушавања релативног редоследа преосталих карактера.

Пример 1:

Input: str1 = "abc", str2 = "ad"
Output: true
Објашњење: Изаберите индекс 2 у str1.
Увећајте str1[2] да постане 'd'.
Тако, str1 постаје "abd" и str2 је сада подсеквенца. Због тога, враћа се true.
Пример 2:

Input: str1 = "zc", str2 = "ad"
Output: true
Објашњење: Изаберите индексе 0 и 1 у str1.
Увећајте str1[0] да постане 'a'.
Увећајте str1[1] да постане 'd'.
Тако, str1 постаје "ad" и str2 је сада подсеквенца. Због тога, враћа се true.
Пример 3:

Input: str1 = "ab", str2 = "d"
Output: false
Објашњење: У ovom примеру се може приказати да није могуће направити str2 подсеквенцом str1 користећи операцију највише једном.
Због тога, враћа се false.

Ограничења:

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

Дати су вам два стринга са индексом од 0, str1 и str2.
У операцији, изаберете скуп индекса у str1, и за сваки индекс i у скупу, увећате str1[i] на следећи карактер циклично. То јест 'a' постаје 'b', 'b' постаје 'c', и тако даље, а 'z' постаје 'a'.
Вратите true ако је могуће направити да str2 буде подсеквенца str1 извршавањем операције највише једном, а false у супротном.
Напомена: Подсеквенца стринга је нови стринг који се формира из оригиналног стринга брисањем неких (можда ниједног) од карактера без нарушавања релативних позиција преосталих карактера.

Пример 1:

Input: str1 = "abc", str2 = "ad"
Output: true
Објашњење: Изаберите индекс 2 у str1.
Увећајте str1[2] да постане 'd'.
Тако, str1 постаје "abd" и str2 је сада подсеквенца. Због тога, враћа се true.
Пример 2:

Input: str1 = "zc", str2 = "ad"
Output: true
Објашњење: Изаберите индексе 0 и 1 у str1.
Увећајте str1[0] да постане 'a'.
Увећајте str1[1] да постане 'd'.
Тако, str1 постаје "ad" и str2 је сада подсеквенца. Због тога, враћа се true.
Пример 3:

Input: str1 = "ab", str2 = "d"
Output: false
Објашњење: У ovom примеру се може приказати да није могуће направити str2 подсеквенцом str1 користећи операцију највише једном.
Због тога, враћа се false.

Ограничења:

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


Дат је низ moves дужине n који се састоји само од карактера 'L', 'R' и '_'. Низ представља ваше кретање на бројевној прави почевши од координате 0.
При i-том потезу, можете изабрати један од следећих праваца:

померање улево ако је moves[i] = 'L' или moves[i] = '_'
померање удесно ако је moves[i] = 'R' или moves[i] = '_'

Вратите растојање од почетне тачке до најдаље тачке коју можете досећи након n потеза.

Пример 1:

Улаз: moves = "L_RL__R"
Излаз: 3
Објашњење: Најдаља тачка коју можемо досећи од почетне тачке 0 је тачка -3 кроз следећи низ потеза "LLRLLLR".

Пример 2:

Улаз: moves = "_R__LL_"
Излаз: 5
Објашњење: Најдаља тачка коју можемо досећи од почетне тачке 0 је тачка -5 кроз следећи низ потеза "LRLLLLL".

Пример 3:

Улаз: moves = "_______"
Излаз: 7
Објашњење: Најдаља тачка коју можемо досећи од почетне тачке 0 је тачка 7 кроз следећи низ потеза "RRRRRRR".

Ограничења:

1 <= moves.length == n <= 50
moves се састоји само од карактера 'L', 'R' и '_'.

Дат је низ потеза дужине н, који се састоји само од знакова 'Л', 'Р' и '_'. Низ представља ваше кретање на бројевној правој, почевши од почетне тачке 0.
Током и^-тог потеза, можете изабрати један од следећих праваца:

Иди лево ако мовес[и] = 'Л' или мовес[и] = '_'.
Идите десно ако мовес[и] = 'Р' или мовес[и] = '_'.

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

Пример 1:

Улаз: потези = "Л_РЛ__Р"
Излаз: 3
Објашњење: Најдаља тачка до које можемо доћи од почетка 0 је тачка -3 кроз следећи низ потеза "ЛЛРЛЛЛР".

Пример 2:

Улаз: потези = "_Р__ЛЛ_"
Излаз: 5
Објашњење: Најдаља тачка до које можемо доћи од почетка 0 је тачка -5 кроз следећи низ потеза "ЛРЛЛЛЛЛ".

Пример 3:

Улаз: потези = "_______"
Излаз: 7
Објашњење: Најдаља тачка до које можемо доћи од почетка 0 је тачка 7 кроз следећи низ потеза "РРРРРРРР".

Ограничења:

1 <= потези.дужина == н <= 50
потези се састоје само од знакова 'Л', 'Р' и '_'.


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

Уклоните суфикс од s дужине l где 0 < l < n и додајте га на почетак s.
На пример, нека је s = 'abcd', онда у једној операцији можете уклонити суфикс 'cd' и додати га на почетак s што даје s = 'cdab' .

Такође вам је дат цео број k. Вратите број начина на које s може бити трансформисан у t у тачно k операција.
Пошто одговор може бити велики, вратите га по модулу 10^9 + 7.

Пример 1:

Улаз: s = "abcd", t = "cdab", k = 2
Излаз: 2
Објашњење:
Први начин:
У првој операцији, изаберите суфикс са индекса = 3, па ће резултути s = "dabc".
У другој операцији, изаберите суфикс са индекса = 3, па ће резултути s = "cdab".

Други начин:
У првој операцији, изаберите суфикс са индекса = 1, па ће резултути s = "bcda".
У другој операцији, изаберите суфикс са индекса = 1, па ће резултути s = "cdab".

Пример 2:

Улаз: s = "ababab", t = "ababab", k = 1
Излаз: 2
Објашњење:
Први начин:
Изаберите суфикс са индекса = 2, па ће резултути s = "ababab".

Други начин:
Изаберите суфикс са индекса = 4, па ће резултути s = "ababab".

Ограничења:

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

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

Уклоните суфикс од s дужине l где 0 < l < n и додајте га на почетак s.
На пример, нека је s = 'abcd', онда у једној операцији можете уклонити суфикс 'cd' и додати га на почетак s што даје s = 'cdab'.

Такође вам је дат цео број к. Врати број начина на које се s може трансформисати у t у тачно к операција.
Пошто одговор може бити велики, вратите га по модулу 10^9 + 7.

Пример 1:

Улаз: s = "abcd", t = "cdab", k = 2
Излаз: 2
Објашњење:
Први начин:
У првој операцији, изаберите суфикс са индекса = 3, тако да резултујући s = "dabc".
У другој операцији, изаберите суфикс са индекса = 3, тако да резултујући s = "cdab".

Други начин:
У првој операцији, изаберите суфикс са индекса = 1, тако да резултујући s = "bcda".
У другој операцији, изаберите суфикс са индекса = 1, тако да резултујући s = "cdab".

Пример 2:

Улаз: s = "ababab", t = "ababab", k = 1
Излаз: 2
Објашњење:
Први начин:
Изаберите суфикс из индекса = 2, тако да добијете s = "ababab".

Други начин:
Изаберите суфикс са индекса = 2, тако да резултујући s = "ababab".

Ограничења:

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

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

Уклоните суфикс низа s дужине l где је 0 < l < n и додајте га на почетак низа s.
На пример, ако је s = 'abcd', онда у једној операцији можете уклонити суфикс 'cd' и додати га испред низа, што ће дати s = 'cdab'.

Тиме вам је такође дат цео број k. Вратите број начина на које низ s може да се трансформише у низ t у тачно k операција.
Пошто резултат може бити веома велики, вратите га модуло 10^9 + 7.

Пример 1:

Улаз: s = "abcd", t = "cdab", k = 2
Излаз: 2
Објашњење:
Први начин:
У првој операцији, изаберите суфикс са индекса = 3, тако да резултујући s = "dabc".
У другој операцији, изаберите суфикс са индекса = 3, тако да резултујући s = "cdab".

Други начин:
У првој операцији, изаберите суфикс са индекса = 1, тако да резултујући s = "bcda".
У другој операцији, изаберите суфикс са индекса = 1, тако да резултујући s = "cdab".

Пример 2:

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

Други начин:
Изаберите суфикс са индекса = 4, тако да резултујући s = "ababab".

Ограничења:

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


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

Изабери било који елемент низа nums[i] такав да је nums[i] > 1.
Уклони nums[i] из низа.
Додај два пута nums[i] / 2 на крај низа nums.

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

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

Пример 1:

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

Пример 2:

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

Пример 3:

Улаз: nums = [1,32,1], target = 35
Излаз: -1
Објашњење: Може се показати да не постоји секвенца операција која резултира у потнизу који збраја до 35.

Ограничења:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums се састоји само од ненегативних степена броја два.
1 <= target < 2^31

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

Изабери било који елемент низа nums[i] такав да је nums[i] > 1.
Уклони nums[i] из низа.
Додај два пута nums[i] / 2 на крај низа nums.

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

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

Пример 1:

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

Пример 2:

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

Улаз: nums = [1,32,1], target = 35
Излаз: -1
Објашњење: Може се показати да ниједан низ операција не доводи до поднизa који даје суму 35.

Ограничења:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums се састоји само од ненегативних степена броја два.
1 <= target < 2^31

Дат вам је 0 индексирани низ бројева који се састоји од ненегативних степена 2 и целобројног циља.
У једној операцији морате применити следеће промене на низ:
Изаберите било који елемент низа нумс[и] тако да је нумс[и] > 1.
Уклоните нумс[и] из низа.
Додајте два појављивања нумс[и] / 2 на крај бројева.
Врати минимални број операција које треба да извршите тако да нумс садржи подниз чији збир елемената треба да циља. Ако је немогуће добити такав низ, вратите -1.
Подсеквенца је низ који се може извести из другог низа брисањем неких или ниједног елемента без промене редоследа преосталих елемената.

Пример 1:
Улаз: nums = [1,2,8], target = 7
Излаз: 1
Објашњење: У првој операцији, изаберемо елемент nums[2]. Низ постаје равна nums = [1,2,4,4].
У овом тренутку, nums садржи подниз [1,2,4] који даје збир 7.
Може се показати да не постоји краћи низ операција који доводи до поднизова који дају збир 7.
Пример 2:
Улаз: nums = [1,32,1,2], target = 12
Излаз: 2
Објашњење: У првој операцији, изаберемо елемент nums[1]. Низ постаје равна nums = [1,1,2,16,16].
У другој операцији, изаберемо елемент nums[3]. Низ постаје равна nums = [1,1,2,16,8,8].
У овом тренутку, nums садржи подниз [1,1,2,8] који даје збир 12.
Може се показати да не постоји краћи низ операција који доводи до поднизова који дају збир 12.
Пример 3:
Улаз: nums = [1,32,1], target = 35
Излаз: -1
Објашњење: Може се показати да ниједан низ операција не доводи до поднизова који дају збир 35.

Ограничења:
1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums се састоји само од ненегативних степеника броја два.
1 <= target < 2^31


Датa је 2D матрица целих бројева grid димензија n * m индексирана од 0. Дефинишемо 2D матрицу `p` истих димензија као матрицу производа grid, ако је испуњен следећи услов:

Сваки елемент p[i][j] је израчунат као производ свих елемената у `grid` осим елемента grid[i][j]. Овај производ се потом узима по модулу 12345.

Вратити матрицу производа grid.

Пример 1:

Улаз: grid = [[1,2],[3,4]]
Излаз: [[24,12],[8,6]]
Објашњење: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Тако да је одговор [[24,12],[8,6]].
Пример 2:

Улаз: grid = [[12345],[2],[1]]
Излаз: [[2],[0],[0]]
Објашњење: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Тако да је p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Тако да је p[0][2] = 0.
Тако да је одговор [[2],[0],[0]].

Огтраничења:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Датa је 2D матрица целих бројева grid димензија n * m индексирана од 0. Дефинишемо 2D матрицу p истих димензија као матрицу производа grid, ако је испуњен следећи услов:

Сваки елемент p[i][j] је израчунат као производ свих елемената у grid осим елемента grid[i][j]. Овај производ се потом узима по модулу 12345.

Вратити матрицу производа grid.

Пример 1:

Улаз: grid = [[1,2],[3,4]]
Излаз: [[24,12],[8,6]]
Објашњење: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Тако да је одговор [[24,12],[8,6]].
Пример 2:

Улаз: grid = [[12345],[2],[1]]
Излаз: [[2],[0],[0]]
Објашњење: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Тако да је p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Тако да је p[0][2] = 0.
Тако да је одговор [[2],[0],[0]].

Огтраничења:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

Датa је 2D матрица целих бројева grid димензија n * m индексирана од 0. Дефинишемо 2D матрицу p истих димензија као матрицу производа grid, ако је испуњен следећи услов:

Сваки елемент p[i][j] је израчунат као производ свих елемената у grid осим елемента grid[i][j]. Овај производ се потом узима по модулу 12345.

Вратите матрицу производа grid.

Пример 1:

Улаз: grid = [[1,2],[3,4]]
Излаз: [[24,12],[8,6]]
Објашњење: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
Тако да је одговор [[24,12],[8,6]].
Пример 2:

Улаз: grid = [[12345],[2],[1]]
Излаз: [[2],[0],[0]]
Објашњење: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. Тако да је p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. Тако да је p[0][2] = 0.
Тако да је одговор [[2],[0],[0]].

Огтраничења:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9


Дат вам је низ целих бројева, индексиран од 0, под називом receiver дужине n, и цео број k.
Постоји n играча са јединственим идентификационим бројевима у опсегу [0, n - 1], који ће учествовати у игри додавања лопте. У низу receiver, receiver[i] представља идентификациони број играча који прима додавања од играча са идентификационим бројем i. Играчи могу додавати лопту сами себи, односно, могуће је да је receiver[i] = i.
Морате изабрати једног од n играча као почетног играча, и лопта ће се додати тачно k пута, почевши од изабраног играча.
За изабраног почетног играча са идентификационим бројем x, дефинишемо функцију f(x) која представља збир x и идентификационих бројева свих играча који приме лопту током k додавања, укључујући понављања. Другим речима: f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
Ваш задатак је да изаберете почетног играча са ID-јем x који максимизује вредност f(x).
Вратите цео број који означава максималну вредност функције.
Напомена: receiver може садржати дупликате.

Пример 1:

Број додавања
ИД пошиљаоца
ИД примаоца
x + ИД прималаца

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Улаз: receiver = [2,0,1], k = 4
Излаз: 6
Објашњење: Табела изнад приказује симулацију игре почевши од играча са ID-јем x = 2.
Из табеле, f(2) је једнако 6.
Може се показати да је 6 максимално достижива вредност функције.
Зато је излаз 6.

Пример 2:

Број додавања
ИД пошиљаоца
ИД примаоца
x + ИД прималаца

4

1
4
3
7

2
3
2
9

3
2
1
10

Улаз: receiver = [1,1,1,2,3], k = 3
Излаз: 10
Објашњење: Табела изнад приказује симулацију игре почевши од играча са ИД-јем x = 4.
Из табеле, f(4) је једнако 10.
Може се показати да је 10 максимално достижива вредност функције.
Зато је излаз 10.

Ограничења:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

```plaintext
Дат вам је низ целих бројева receiver са 0-базираним индексом дужине n и цео број k.
Постоји n играча са јединственим ID у опсегу [0, n - 1] који ће играти игру додавања лопте, и receiver[i] је ID играча који прима додавања од играча са ID-јем i. Играчи могу додавати сами себи, то јест receiver[i] може бити једнако i.
Морате изабрати једног од n играча као почетног играча за игру, и лопта ће бити додата тачно k пута почевши од изабраног играча.
За изабраног почетног играча са ID-јем x, дефинишемо функцију f(x) која означава збир x и ID-јева свих играча који примају лопту током k додавања, укључујући понављања. Другим речима, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
Ваш задатак је да изаберете почетног играча са ID-јем x који максимизује вредност f(x).
Вратите цео број који означава максималну вредност функције.
Напомена: receiver може садржати дупликате.

Пример 1:

Број додавања
ID пошиљаоца
ID примаоца
x + ID прималаца

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Улаз: receiver = [2,0,1], k = 4
Излаз: 6
Објашњење: Табела изнад приказује симулацију игре почевши од играча са ID-јем x = 2.
Из табеле, f(2) је једнако 6.
Може се показати да је 6 максимално достижива вредност функције.
Зато је излаз 6.

Пример 2:

Број додавања
ID пошиљаоца
ID примаоца
x + ID прималаца

4

1
4
3
7

2
3
2
9

3
2
1
10

Улаз: receiver = [1,1,1,2,3], k = 3
Излаз: 10
Објашњење: Табела изнад приказује симулацију игре почевши од играча са ID-јем x = 4.
Из табеле, f(4) је једнако 10.
Може се показати да је 10 максимално достижива вредност функције.
Зато је излаз 10.

Ограничења:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10
```

Дат вам је 0-индексиран пријемник низа целих бројева дужине н и цели број к.
Постоји n играча који имају јединствени ид у опсегу [0, n - 1] и који ће учествовати у игри са додавањем лопте, а receiver[i] је ид играча који прима додавање од играча са ид-ом i. Играчи могу да додају сами себи, тј. receiver[i] може бити једнак i.
Морате изабрати једног од n играча као почетног играча за игру, и лопта ће бити додата тачно k пута, почевши од изабраног играча.
За изабраног почетног играча са ид-ом x, дефинишемо функцију f(x) која означава суму x и ид-ова свих играча који примају лопту током k додавања, укључујући поновљене. Другим речима, f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x].
Ваш задатак је да изаберете почетног играча са ид-ом x који максимизује вредност функције f(x).
Вратите цео број који означава максималну вредност функције.
Напомена: receiver може садржати дупликате.

Пример 1:

Број додавања
ID пошиљаоца
ID примаоца
x + ID прималаца

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

Улаз: receiver = [2,0,1], k = 4
Излаз: 6
Објашњење: Табела изнад приказује симулацију игре почевши од играча са ID-јем x = 2.
Из табеле, f(2) је једнако 6.
Може се показати да је 6 максимално достижива вредност функције.
Зато је излаз 6.

Пример 2:

Број додавања
ID пошиљаоца
ID примаоца
x + ID прималаца

4

1
4
3
7

2
3
2
9

3
2
1
10

Улаз: receiver = [1,1,1,2,3], k = 3
Излаз: 10
Објашњење: Табела изнад приказује симулацију игре почевши од играча са ID-јем x = 4.
Из табеле, f(4) је једнако 10.
Може се показати да је 10 максимално достижива вредност функције.
Зато је излаз 10.

Ограничења:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10
```


Дат вам је два 0-индиксна бинарна низа s1 и s2, оба дужине n, и позитиван број x.
Можете извршити било коју од следећих операција на низу s1 онолико пута колико желите:

Изаберите два индекса i и j, и промените и s1[i] и s1[j]. Трошак ове операције је x.
Изаберите индекс i такав да i < n - 1 и промените и s1[i] и s1[i + 1]. Трошак ове операције је 1.

Вратите минимални трошак који је потребан да се низови s1 и s2 учине једнаким, или вратите -1 ако је то немогуће.
Напомена: Променити карактер значи променити га са 0 у 1 или обрнуто.

Пример 1:

Улаз: s1 = "1100011000", s2 = "0101001010", x = 2
Излаз: 4
Објашњење: Можемо извршити следеће операције:
- Изаберите i = 3 и примените другу операцију. Добили смо s1 = "1101111000".
- Изаберите i = 4 и примените другу операцију. Добили смо s1 = "1101001000".
- Изаберите i = 0 и j = 8 и примените прву операцију. Добили смо s1 = "0101001010" = s2.
Укупна цена је 1 + 1 + 2 = 4. Може се показати да је ово минимална могућа цена.

Пример 2:

Улаз: s1 = "10110", s2 = "00011", x = 4
Излаз: -1
Објашњење: Није могуће учинити два низа једнаким.

Ограничења:

n == s1.length == s2.length
1 <= n, x <= 500
s1 и s2 се састоје само од карактера '0' и '1'.

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

Изаберите два индекса и и ј, и окрените оба s1[i] и s1[j]. Цена ове операције је х.
Изаберите индекс и такав да је и < н - 1 и окрените оба s1[i] и s1[i + 1]. Цена ове операције је 1.

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

Пример 1:

Улаз: s1 = "1100011000", s2 = "0101001010", x = 2
Излаз: 4
Објашњење: Можемо да урадимо следеће операције:
- Изаберите и = 3 и примените другу операцију. Добијени низ је с1 = "1101111000".
- Изаберите и = 4 и примените другу операцију. Добијени низ је с1 = "1101001000".
- Изаберите и = 0 и ј = 8 и примените прву операцију. Добијени низ је с1 = "0101001010" = с2.
Укупан трошак је 1 + 1 + 2 = 4. Може се показати да је то најмањи могући трошак.

Пример 2:

Улаз: s1 = "10110", s2 = "00011", x = 4
Излаз: -1
Објашњење: Није могуће учинити два низа једнакима.

Ограничења:

n == s1.length == s2.length
1 <= n, x <= 500
с1 и с2 се састоје само од знакова '0' и '1'.

Дате су вам две 0-базиране бинарне ниске s1 и s2, обе дужине n, и позитиван цео број x.
Можете извршити било коју од следећих операција на низу s1 било који број пута:

Изаберите два индекса i и j, и промените s1[i] и s1[j]. Цена ове операције је x.
Изаберите индекс i тако да је i < n - 1 и промените s1[i] и s1[i + 1]. Цена ове операције је 1.

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

Пример 1:

Улаз: s1 = "1100011000", s2 = "0101001010", x = 2
Излаз: 4
Објашњење: Можемо извршити следеће операције:
- Изаберите i = 3 и примените другу операцију. Добили смо s1 = "1101111000".
- Изаберите i = 4 и примените другу операцију. Добили смо s1 = "1101001000".
- Изаберите i = 0 и j = 8 и примените прву операцију. Добили смо s1 = "0101001010" = s2.
Укупна цена је 1 + 1 + 2 = 4. Може се показати да је ово минимална могућа цена.

Пример 2:

Улаз: s1 = "10110", s2 = "00011", x = 4
Излаз: -1
Објашњење: Није могуће учинити два низа једнаким.

Ограничења:

n == s1.length == s2.length
1 <= n, x <= 500
s1 и s2 се састоје само од карактера '0' и '1'.


Дат вам је 0-индексирани 2Д низ целих бројева nums који представља координате аутомобила паркираних на линији. За било који индекс i, nums[i] = [start_i, end_i] где је start_i почетна тачка i-тог аутомобила, а end_i је крајња тачка i-тог аутомобила.
Вратите број целих тачака на линији које су покривене било којим делом аутомобила.

Пример 1:

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

Пример 2:

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

Ограничења:

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

Дат вам је 0 индексиран 2D целобројни низ бројева који представљају координате паркирања аутомобила на бројевној правој. За било који индекс i, nums[i] = [start_i, end_i] где је старт_и почетна тачка  i^th аутомобила, а end_i је завршна тачка i^th аутомобила.
Врати број целих тачака на линији које су прекривене било којим делом аутомобила.

Пример 1:

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

Пример 2:

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

Ограничења:

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

Дат вам је 0-индексирани 2D целобројни низ nums који представља координате аута који паркирају на бројачкој линији. За било који индекс i, nums[i] = [start_i, end_i] где је start_i почетна тачка i-ог аута, а end_i крајња тачка i-ог аута. Вратите број целих тачака на линији које су покривене било којим делом аута.

Пример 1:

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

Пример 2:

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

Ограничења:

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


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

Пример 1:

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

Пример 2:

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

Пример 3:

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

Ограничења:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
Улаз је генерисан тако да можете сакупити елементе 1, 2, ..., k.

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

Пример 1:

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

Пример 2:

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

Пример 3:

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

Ограничења:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
Улаз је генерисан тако да можете сакупити елементе 1, 2, ..., k.


Дат вам је низ  nums индексиран од 0, дужине n, који садржи различите позитивне целе бројеве.
Вратите минималан број померања удесно потребних да се nums сортира, или -1 ако то није могуће.
Померање удесно је дефинисано као померање елемента са индекса i на индекс (i + 1) % n, за све индексе.

Пример 1:

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

Пример 2:

Улаз: nums = [1,3,5]
Излаз: 0
Објашњење: nums је већ сортиран, стога је одговор 0.

Пример 3:

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

Ограничења:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums садржи различите целе бројеве.

Добијате 0-индексирани низ nums дужине н који садржи различите позитивне целе бројеве. Вратите минимални број десних смена потребних за сортирање елемената и -1 ако то није могуће.
Десни помак је дефинисан као померање елемента на индексу и на индекс (и + 1) % н, за све индексе.

Пример 1:

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

Пример 2:

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

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

ограничења:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums садржи различите целе бројеве.

Дат вам је 0-индексиран низ бројева дужине n који садржи различите позитивне целе бројеве. Вратите минимални број десних померања потребних за сортирање бројева и -1 ако то није могуће.
Десно померање се дефинише као померање елемента са индексом i на индекс (i + 1) % n, за све индексе.

Пример 1:

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

Пример 2:

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

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

Ограничења:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums садржи различите целе бројеве.


Дат вам је низ num који представља не-негативан цео број.
У једној операцији можете одабрати било коју цифру из низа num и обрисати је. Напомена: ако обришете све цифре из низа num, он постаје 0.
Вратите минималан број операција потребних да учините број num специјалним.
Цели број x се сматра специјалним ако је делив са 25.

Пример 1:

Улаз: num = "2245047"
Излаз: 2
Објашњење: Обришите цифре num[5] и num[6]. Резултујући број је "22450" који је специјалан јер је дељив са 25.
Може се показати да је 2 минималан број операција потребан да се добије специјалан број.
Пример 2:

Улаз: num = "2908305"
Излаз: 3
Објашњење: Обришите цифре num[3], num[4] и num[6]. Резултујући број је "2900" који је специјалан јер је дељив са 25.
Може се показати да је 3 минималан број операција потребан да се добије специјалан број.
Пример 3:

Улаз: num = "10"
Излаз: 1
Објашњење: Обришите цифру num[0]. Резултујући број је "0" који је специјалан јер је дељив са 25.
Може се показати да је 1 минималан број операција потребан да се добије специјалан број.

Ограничења:

1 <= num.length <= 100
num се састоји само од цифара '0' до '9'.
num не садржи водеће нуле.

Дат вам је стринг num који представља не-негативан цео број индексиран од 0.
У једној операцији можете изабрати било коју цифру из num и обрисати је. Имајте у виду да ако обришете све цифре из num, num постаје 0.
Вратите минималан број операција потребних да num постане специјалан.
Цео број x се сматра специјалним ако је дељив са 25.

Пример 1:

Улаз: num = "2245047"
Излаз: 2
Објашњење: Обришите цифре num[5] и num[6]. Резултујући број је "22450" који је специјалан јер је дељив са 25.
Може се показати да је 2 минималан број операција потребан да се добије специјалан број.
Пример 2:

Улаз: num = "2908305"
Излаз: 3
Објашњење: Обришите цифре num[3], num[4] и num[6]. Резултујући број је "2900" који је специјалан јер је дељив са 25.
Може се показати да је 3 минималан број операција потребан да се добије специјалан број.
Пример 3:

Улаз: num = "10"
Излаз: 1
Објашњење: Обришите цифру num[0]. Резултујући број је "0" који је специјалан јер је дељив са 25.
Може се показати да је 1 минималан број операција потребан да се добије специјалан број.

Ограничења:

1 <= num.length <= 100
num се састоји само од цифара '0' до '9'.
num не садржи водеће нуле.

Дат вам је стринг num који представља не-негативан цео број индексиран од 0.
У једној операцији можете изабрати било коју цифру из num и обрисати је. Имајте у виду да ако обришете све цифре из num, num постаје 0.
Вратите минималан број операција потребних да num постане посебан.
Цео број x се сматра посебним ако је дељив са 25.

Пример 1:

Улаз: num = "2245047"
Излаз: 2
Објашњење: Обришите цифре num[5] и num[6]. Добијени број је "22450" који је посебан јер је дељив са 25.
Може се показати да је 2 минималан број операција потребан да се добије посебан број.
Пример 2:

Улаз: num = "2908305"
Излаз: 3
Објашњење: Обришите цифре num[3], num[4] и num[6]. Добијени број је "2900" који је посебан јер је дељив са 25.
Може се показати да је 3 минималан број операција потребан да се добије посебан број.
Пример 3:

Улаз: num = "10"
Излаз: 1
Објашњење: Обришите цифру num[0]. Добијени број је "0", који је посебан јер је дељив са 25.
Може се показати да је 1 минималан број операција потребан да се добије посебан број.

Ограничења:

1 <= num.length <= 100
num се састоји само од цифара '0' до '9'.
num не садржи водеће нуле.


Дат вам је низ бројева nums који садржи n целих бројева, индексиран од 1
Сет бројева је потпун ако је производ сваког пара његових елемената савршени квадрат.
За подскуп скупа индекса {1, 2, ..., n} представљен као {i_1, i_2, ..., i_k}, дефинишемо збир елемената његових елемената као: nums[i_1] + nums[i_2] + ... + nums[i_k].
Вратите максималну збир елемената потпуног подскупа скупа индекса {1, 2, ..., n}.
Савршени квадрат је број који се може изразити као производ неког целог броја самим собом.

Пример 1:

Улаз: nums = [8,7,3,5,7,2,4,9]
Излаз: 16
Објашњење: Осим подскупова који се састоје од једног индекса, постоје два друга потпуна подскупа индекса: {1,4} и {2,8}.
Сума елемената који одговарају индексима 1 и 4 је једнака nums[1] + nums[4] = 8 + 5 = 13.
Сума елемената који одговарају индексима 2 и 8 је једнака nums[2] + nums[8] = 7 + 9 = 16.
Дакле, максимална збир елемената потпуног подскупа индекса је 16.

Пример 2:

Улаз: nums = [5,10,3,10,1,13,7,9,4]
Излаз: 19
Објашњење: Осим подскупова који се састоје од једног индекса, постоје четири друга потпуна подскупа индекса: {1,4}, {1,9}, {2,8}, {4,9}, и {1,4,9}.
Сума елемената који одговарају индексима 1 и 4 је једнака nums[1] + nums[4] = 5 + 10 = 15.
Сума елемената који одговарају индексима 1 и 9 је једнака nums[1] + nums[9] = 5 + 4 = 9.
Сума елемената који одговарају индексима 2 и 8 је једнака nums[2] + nums[8] = 10 + 9 = 19.
Сума елемената који одговарају индексима 4 и 9 је једнака nums[4] + nums[9] = 10 + 4 = 14.
Сума елемената који одговарају индексима 1, 4, и 9 је једнака nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Дакле, максимална збир елемената потпуног подскупа индекса је 19.

Ограничења:

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

Дат вам је низ бројева nums са n целих бројева, индексиран од 1.
Сет бројева је потпун ако је производ сваког пара његових елемената савршени квадрат.
За подскуп скупа индекса {1, 2, ..., n} представљен као {i_1, i_2, ..., i_k}, дефинишемо језгро-сума његових елемената као: nums[i_1] + nums[i_2] + ... + nums[i_k].
Вратите максималну језгро-сума потпуног подскупа скупа индекса {1, 2, ..., n}.
Савршени квадрат је број који се може изразити као производ неког целог броја самим собом.

Пример 1:

Улаз: nums = [8,7,3,5,7,2,4,9]
Излаз: 16
Објашњење: Осим подскупова који се састоје од једног индекса, постоје два друга потпуна подскупа индекса: {1,4} и {2,8}.
Сума елемената који одговарају индексима 1 и 4 је једнака nums[1] + nums[4] = 8 + 5 = 13.
Сума елемената који одговарају индексима 2 и 8 је једнака nums[2] + nums[8] = 7 + 9 = 16.
Дакле, максимална језгро-сума потпуног подскупа индекса је 16.

Пример 2:

Улаз: nums = [5,10,3,10,1,13,7,9,4]
Излаз: 19
Објашњење: Осим подскупова који се састоје од једног индекса, постоје четири друга потпуна подскупа индекса: {1,4}, {1,9}, {2,8}, {4,9}, и {1,4,9}.
Сума елемената који одговарају индексима 1 и 4 је једнака nums[1] + nums[4] = 5 + 10 = 15.
Сума елемената који одговарају индексима 1 и 9 је једнака nums[1] + nums[9] = 5 + 4 = 9.
Сума елемената који одговарају индексима 2 и 8 је једнака nums[2] + nums[8] = 10 + 9 = 19.
Сума елемената који одговарају индексима 4 и 9 је једнака nums[4] + nums[9] = 10 + 4 = 14.
Сума елемената који одговарају индексима 1, 4, и 9 је једнака nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Дакле, максимална језгро-сума потпуног подскупа индекса је 19.

Ограничења:

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

Дат вам је низ бројева nums који садржи n целих бројева, индексиран од 1.
Сет бројева је потпун ако је производ сваког пара његових елемената савршени квадрат.
За подскуп скупа индекса {1, 2, ..., n} представљен као {i_1, i_2, ..., i_k}, дефинишемо збир елемената његових елемената као: nums[i_1] + nums[i_2] + ... + nums[i_k].
Вратите максималну збир елемената комплетног подскупа скупа индекса {1, 2, ..., n}.
Савршени квадрат је број који се може изразити као производ неког целог броја самим собом.

Пример 1:

Улаз: nums = [8,7,3,5,7,2,4,9]
Излаз: 16
Објашњење: Осим подскупова који се састоје од једног индекса, постоје два друга комплетна подскупа индекса: {1,4} и {2,8}.
Сума елемената који одговарају индексима 1 и 4 је једнака nums[1] + nums[4] = 8 + 5 = 13.
Сума елемената који одговарају индексима 2 и 8 је једнака nums[2] + nums[8] = 7 + 9 = 16.
Дакле, максимална збир елеме ната потпуног подскупа индекса је 16.

Пример 2:

Улаз: nums = [5,10,3,10,1,13,7,9,4]
Излаз: 19
Објашњење: Осим подскупова који се састоје од једног индекса, постоје четири друга комплетна подскупа индекса: {1,4}, {1,9}, {2,8}, {4,9}, и {1,4,9}.
Сума елемената који одговарају индексима 1 и 4 је једнака nums[1] + nums[4] = 5 + 10 = 15.
Сума елемената који одговарају индексима 1 и 9 је једнака nums[1] + nums[9] = 5 + 4 = 9.
Сума елемената који одговарају индексима 2 и 8 је једнака nums[2] + nums[8] = 10 + 9 = 19.
Сума елемената који одговарају индексима 4 и 9 је једнака nums[4] + nums[9] = 10 + 4 = 14.
Сума елемената који одговарају индексима 1, 4, и 9 је једнака nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19.
Дакле, максимална збир елемената потпуног подскупа индекса је 19.

Ограничења:

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


Дат је бинарни низ s који садржи бар једну '1'.
Треба да преместите битове тако да добијени бинарни број буде највећи непаран бинарни број који може бити направљен из ове комбинације.
Вратите низ који представља највећи непаран бинарни број који може бити направљен из дате комбинације.
Имајте на уму да резултујући низ може имати водеће нуле.

Пример 1:

Улаз: s = "010"
Излаз: "001"
Објашњење: Пошто постоји само једна '1', она мора бити на последњој позицији. Дакле, одговор је "001".

Пример 2:

Улаз: s = "0101"
Излаз: "1001"
Објашњење: Једна од '1' мора бити на последњој позицији. Максималан број који може бити направљен са преосталим цифрама је "100". Дакле, одговор је "1001".

Ограничења:

1 <= s.length <= 100
s се састоји само од '0' и '1'.
s садржи бар једну '1'.

Дат је бинарни низ s који садржи бар једну '1'.
Треба да преместите битове тако да добијени бинарни број буде највећи непаран бинарни број који може бити направљен из ове комбинације.
Вратите низ који представља највећи непаран бинарни број који може бити направљен из дате комбинације.
Пазите да на уму да резултујући низ може имати водеће нуле.

Пример 1:

Улаз: s = "010"
Излаз: "001"
Објашњење: Пошто постоји само једна '1', она мора бити на последњој позицији. Дакле, одговор је "001".

Пример 2:

Улаз: s = "0101"
Излаз: "1001"
Објашњење: Једна од '1' мора бити на последњој позицији. Максималан број који може бити направљен са осталим цифрама је "100". Дакле, одговор је "1001".

Ограничења:

1 <= s.length <= 100
s се састоји само од '0' и '1'.
s садржи барем једну '1'.

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

Пример 1:

Улаз: s = "010"
Излаз: "001"
Објашњење: Пошто постоји само једно '1', оно мора бити на последњој позицији. Дакле, одговор је "001".

Пример 2:

Улаз: s = "0101"
Излаз: "1001"
Објашњење: Једна од '1 мора бити на последњој позицији. Максималан број који се може направити са преосталим цифрама је „100“. Дакле, одговор је "1001".

Ограничења:

1 <= s.length <= 100
s се састоји само од '0' и '1'.
s садржи најмање један '1'.


Дат је низ nums који се састоји од ненегативних целих бројева.
Дефинишемо скор подниза nums[l..r] за л <= р као nums[l] И nums[l + 1] И ... И nums[r] где је И битовска операција И.
Размотрите дељење низа на један или више поднизова тако да су задовољени следећи услови:

Сваки елемент низа припада тачно једном поднизу.
Збир скорова поднизова је минимално могућ.

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

Пример 1:

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

Пример 2:

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

Ограничења:

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

Дат вам је низ nums који се састоји од ненегативних целих бројева.
Дефинишемо скор подниза nums[l..r] за л <= р као nums[l] И nums[l + 1] И ... И nums[r] где је И битовска операција И.
Размотрите раздвајање низа на један или више поднизова тако да су испуњени следећи услови:

- Сваки елемент низа припада тачно једном поднизу.
- Збир резултата поднизова је минимално могућ.

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

Пример 1:

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

Пример 2:

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

Ограничења:

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

Дат је низ nums који се састоји од ненегативних целих бројева.
Дефинишемо скор подниза nums[l..r] за л <= р као nums[l] И nums[l + 1] И ... И nums[r] где је И битовска операција И.
Размотрите дељење низа на један или више поднизова тако да су задовољени следећи услови:

Сваки елемент низа припада тачно једном поднизу.
Збир резултата поднизова је најмањи могући.

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

Пример 1:

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

Пример 2:

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

Ограничења:

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


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

Изаберите два индекса, i и j, где је i < j, тако да nums[i] < nums[j].
Тада уклоните елементе са индекса i и j из nums. Остали елементи задржавају свој оригинални редослед, а низ се поново индексира.

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

Пример 1:

Улаз: nums = [1,3,4,9]
Излаз: 0
Објашњење: Иницијално, nums = [1, 3, 4, 9].
У првој операцији можемо изабрати индексе 0 и 1 јер nums[0] < nums[1] <=> 1 < 3.
Уклоните индексе 0 и 1, и nums постаје [4, 9].
За следећу операцију можемо изабрати индексе 0 и 1 јер nums[0] < nums[1] <=> 4 < 9.
Уклоните индексе 0 и 1, и nums постаје празан низ [].
Дакле, минимална остварива дужина је 0.

Пример 2:

Улаз: nums = [2,3,6,9]
Излаз: 0
Објашњење: Иницијално, nums = [2, 3, 6, 9].
У првој операцији можемо изабрати индексе 0 и 2 јер nums[0] < nums[2] <=> 2 < 6.
Уклоните индексе 0 и 2, и nums постаје [3, 9].
За следећу операцију можемо изабрати индексе 0 и 1 јер nums[0] < nums[1] <=> 3 < 9.
Уклоните индексе 0 и 1, и nums постаје празан низ [].
Дакле, минимална остварива дужина је 0.

Пример 3:

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

Ограничења:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums је сортиран у не-опадајућем редоследу.

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

Изаберите два индекса, i и ј, где i < j, тако да nums[i] < nums[ј].
Затим уклоните елементе на индексима и и ј из nums. Преостали елементи задржавају свој првобитни редослед, а низ се поново индексира.

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

Пример 1:

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

Улаз : nums = [2,3,6,9]
излаз : 0
Објашњење : У почетку, nums = [2, 3, 6, 9].
У првој операцији можемо изабрати индекс 0 и 2 јер nums[0] < nums[2] <=> 2 < 6.
Уклоните индексе 0 и 2, а нумс постаје [3, 9].
За следећу операцију, можемо да изаберемо индекс 0 и 1 јер nums[0] < nums[1] <=> 3 < 9.
Уклоните индексе 0 и 1, а нумс постаје празан низ [].
Дакле , минимална дужина која се може постићи је 0.

Пример 3:

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

Ограничења:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums је сортиран у не-опадајућем редоследу.

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

Изаберите два индекса, i и j, где је i < j, тако да важи nums[i] < nums[j].
Затим уклоните елементе на индексима i и j из nums. Преостали елементи задржавају свој првобитни редослед, а низ се поново индексира.

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

Пример 1:

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

Улаз: nums = [2,3,6,9]
Излаз: 0
Објашњење: У почетку су nums = [2, 3, 6, 9].
У првој операцији можемо изабрати индекс 0 и 2 јер су nums[0] < nums[2] <=> 2 < 6.
Уклоните индексе 0 и 2, а бројеви постају [3, 9].
За следећу операцију можемо изабрати индекс 0 и 1 јер су nums[0] < nums[1] <=> 3 < 9.
Уклоните индексе 0 и 1, а нумс постаје празан низ [].
Дакле, минимална дужина која се може постићи је 0.

Пример 3:

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

Ограничења:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums се сортира по неопадајућем редоследу.


Дат вам је низ `nums` индексиран са 0 који се састоји од целих бројева који нису негативни, и два цела броја `l` и `r`.
Вратите број под-вишескупова унутар `nums` где збир елемената у сваком подмноштву спада у инклузивни опсег [l, r].
Пошто одговор може бити велики, вратите га модуло 10^9 + 7.
Под-вишескуп је неуређена колекција елемената из низа у којем се дата вредност `x` може појавити 0, 1, ..., `occ[x]` пута, где је `occ[x]` број појављивања `x` у низу.
Напомена:

Два под-вишескупа су иста ако сортирање оба вишескупа резултује идентичним вишескупом.
Збир празног мноштва је 0.

Пример 1:

Унос: nums = [1,2,2,3], l = 6, r = 6
Излаз: 1
Објашњење: Једини подскуп од nums који има збир 6 је {1, 2, 3}.

Пример 2:

Унос: nums = [2,1,4,2,7], l = 1, r = 5
Излаз: 7
Објашњење: Подскупови од nums који имају збир унутар опсега [1, 5] су {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4}, и {1, 2, 2}.

Пример 3:

Унос: nums = [1,2,1,3,5,2], l = 3, r = 5
Излаз: 9
Објашњење: Подскупови од nums који имају збир унутар опсега [3, 5] су {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} и {1, 2, 2}.

Ограничења:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
Збир nums не прелази 2 * 10^4.
0 <= l <= r <= 2 * 10^4

Дат вам је низ индексиран од 0, nums, који садржи не-негативне целе бројеве, и два цела броја l и r.
Вратите број под-множина унутар nums где збир елемената сваког под-множина пада у опсег [l, r].
Пошто одговор може бити велики, вратите га модулом 10^9 + 7.
Подмноштво је неуређена колекција елемената из низа у којој вредност x може да се појави 0, 1, ..., occ[x] пута, где је occ[x] број појава x у низу.
Напомена:

- Два подмножја су иста ако и једно и друго сортирате и добијете идентична подмножја.
- Збир празног подмножја је 0.

Пример 1:

Унос: nums = [1,2,2,3], l = 6, r = 6
Излаз: 1
Објашњење: Једини подскуп од nums који има збир 6 је {1, 2, 3}.

Пример 2:

Унос: nums = [2,1,4,2,7], l = 1, r = 5
Излаз: 7
Објашњење: под-множине од nums који имају збир унутар опсега [1, 5] су {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4}, и {1, 2, 2}.

Пример 3:

Унос: nums = [1,2,1,3,5,2], l = 3, r = 5
Излаз: 9
Објашњење: под-множине од nums који имају збир унутар опсега [3, 5] су {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} и {1, 2, 2}.

Ограничења:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
Збир nums не прелази 2 * 10^4.
0 <= l <= r <= 2 * 10^4

Дат вам је низ nums индексиран од 0 који садржи ненегативне целе бројеве, као и два цела броја l и r.
Вратите број под-вишескупова унутар nums где збир елемената у сваком подмноштву спада у инклузивни опсег [l, r].
Пошто одговор може бити велики, вратите га модуло 10^9 + 7.
Под-вишескуп је неуређена колекција елемената из низа у којем се дата вредност x може појавити 0, 1, ..., occ[x] пута, где је occ[x] број појављивања x у низу.
Напомена:

Два подмултискупа су иста ако сортирањем оба подмултискупа добијемо идентичне мултискупове.
Збир празног мултискупа је 0.

Пример 1:

Улаз: nums = [1,2,2,3], l = 6, r = 6
Излаз: 1
Објашњење: Једини подскуп од nums који има збир 6 је {1, 2, 3}.

Пример 2:

Улазс: nums = [2,1,4,2,7], l = 1, r = 5
Излаз: 7
Објашњење: Подскупови од nums који имају збир унутар опсега [1, 5] су {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4}, и {1, 2, 2}.

Пример 3:

Улаз: nums = [1,2,1,3,5,2], l = 3, r = 5
Излаз: 9
Објашњење: Подскупови од nums који имају збир унутар опсега [3, 5] су {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} и {1, 2, 2}.

Ограничења:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
Збир nums не прелази 2 * 10^4.
0 <= l <= r <= 2 * 10^4


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

На пример, бинарна репрезентација броја 21 је 10101, која има 3 постављена бита.

Пример 1:

Улаз: nums = [5,10,1,5,2], k = 1
Излаз: 13
Објашњење: Бинарно представљање индекса је:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Индекси 1, 2, и 4 имају k = 1 постављених битова у њиховом бинарном представљању.
Тако да је одговор nums[1] + nums[2] + nums[4] = 13.
Пример 2:

Улаз: nums = [4,3,2,1], k = 2
Излаз: 1
Објашњење: Бинарно представљање индекса је:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Само индекс 3 има k = 2 постављених битова у свом бинарном представљању.
Зато је одговор nums[3] = 1.

Ограничења:

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

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

На пример, бинарна репрезентација 21 је 10101, која има 3 скупа бита.

Пример 1:

Улаз : nums = [5,10,1,5,2], к = 1
излаз : 13
Објашњење : Бинарна репрезентација индекса су:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Индекси 1, 2 и 4 имају к = 1 скуп битова у својој бинарној репрезентацији.
Дакле , одговор је nums[1] + nums[2] + nums[4] = 13.
Пример 2:

Улаз : nums = [4,3,2,1], к = 2
излаз : 1
Објашњење : Бинарна репрезентација индекса су:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Само индекс 3 има к = 2 скуп битова у својој бинарној репрезентацији.
Дакле , одговор је nums[3] = 1.

Ограничења:

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

Дат вам је 0-индексирани низ бројева бројева и цео број k.
Врати цео број који означава збир елемената у бројевима чији одговарајући индекси имају тачно k постављених битова у својој бинарној представи.
Постављени битови у целом броју су присутни 1 када је записано у бинарном облику.

На пример, бинарни приказ 21 је 10101, који има 3 постављена бита.

Пример 1:

Улаз: nums = [5,10,1,5,2], k = 1
Излаз: 13
Објашњење: Бинарни приказ индекса је:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
Индекси 1, 2 и 4 имају k = 1 сет битова у својој бинарној представи.
Дакле, одговор је nums[1] + nums[2] + nums[4] = 13.
Пример 2:

Улаз: nums = [4,3,2,1], k = 2
Излаз: 1
Објашњење: Бинарни приказ индекса је:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
Само индекс 3 има k = 2 постављена бита у својој бинарној представи.
Дакле, одговор је nums[3] = 1.

Ограничења:

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


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

- Изаберите два елемента са истим вредностима и обришите их из низа.
- Изаберите три елемента са истим вредностима и обришите их из низа.

Вратите минималан број операција потребних да се низ учини празним, или -1 ако то није могуће.
Пример 1:

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

Пример 2:

Улаз: nums = [2,1,2,2,3,3]
Излаз: -1
Објашњење: Немогуће је учинити низ празним.

Ограничења:

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

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

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

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

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

Пример 1:

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

Пример 2:

Улаз: nums = [2,1,2,2,3,3]
Излаз: -1
Објашњење: Немогуће је учинити низ празним.

Ограничења:

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

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

Изаберите два елемента једнаких вредности и избришите их из низа.
Изаберите три елемента једнаких вредности и избришите их из низа.

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

Пример 1:

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

Пример 2:

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

Ограничења:

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


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

- Ученик је изабран и укупан број изабраних ученика је строго већи од nums[i].
- Ученик није изабран и укупан број изабраних ученика је строго мањи од nums[i].

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

Пример 1:

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

Пример 2:

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

Ограничења:

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

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

Ученик је изабран и укупан број одабраних ученика је стриктно већи од nums[i].
Ученик није изабран и укупан број одабраних ученика је стриктно мањи од nums[i].

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

Пример 1:

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

Пример 2:

Улаз: nums = [6,0,3,3,6,7,2,7]
Излаз: 3
Објашњење:
Три могућа начина су:
Одељењски старешина бира ученика са index = 1 за формирање групе.
Одељењски старешина бира ученике са index = 1, 2, 3, 6 да формирају групу.
Одељењски старешина бира све ученике да формирају групу.

Ограничења:

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

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

i^th ученик ће бити срећан ако је испуњен један од следећих услова:

Ученик је изабран и укупан број изабраних ученика је строго већи од nums[i].
Ученик није изабран и укупан број изабраних ученика је строго мањи од nums[i].

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

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

Пример 2:

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

Ограничења:

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


Дат вам је нумерисан 0-индексирани низ целих бројева `nums` и цео број `target`.
Вратите дужину најдуже подпоследице `nums` која се сабира до `target`. Ако таква подпоследица не постоји, вратите -1.
Подпоследица је низ који се може добити из другог низа брисањем неких или ниједног елемента без промене редоследа преосталих елемената.

Пример 1:

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

Пример 2:

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

Пример 3:

Улаз: `nums = [1,1,5,4,5]`, `target = 3`
Излаз: -1
Објашњење: Може се показати да `nums` нема подпоследицу која се сабира до 3.

Ограничења:

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

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

Пример 1:

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

Пример 2:

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

Пример 3:

Улаз: nums = [1,1,5,4,5], target = 3
Излаз: -1
Објашњење: Може се показати да низ nums нема подниз који даје суму 3.

Ограничења:

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

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

Пример 1:

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

Пример 2:

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

Пример 3:

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

Ограничења:

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


Dat vam je 0-indeksirani niz maxHeights od n celih brojeva.
Vaš zadatak je da izgradite n toranja na koordinatnoj osi. i-ti toranj je izgrađen na koordinati i i ima visinu heights[i].
Konfiguracija toranja je lepa ako su ispunjeni sledeći uslovi:

1 <= heights[i] <= maxHeights[i]
heights je planinski niz.

Niz heights je planinski ako postoji indeks i takav da:

Za sve 0 < j <= i, heights[j - 1] <= heights[j]
Za sve i <= k < n - 1, heights[k + 1] <= heights[k]

Vraća se maksimalna moguća suma visina lepe konfiguracije kula.

Primer 1:

Ulaz: maxHeights = [5,3,4,1,1]
Izlaz: 13
Objašnjenje: Jedna lepa konfiguracija sa maksimalnom sumom je heights = [5,3,3,1,1]. Ova konfiguracija je lepa jer:
- 1 <= heights[i] <= maxHeights[i]
- heights je planina sa vrhom i = 0.
Može se pokazati da ne postoji druga lepa konfiguracija sa sumom visina većom od 13.
Primer 2:

Ulaz: maxHeights = [6,5,3,9,2,7]
Izlaz: 22
Objašnjenje: Jedna lepa konfiguracija sa maksimalnom sumom je heights = [3,3,3,9,2,2]. Ova konfiguracija je lepa jer:
- 1 <= heights[i] <= maxHeights[i]
- heights je planina sa vrhom i = 3.
Može se pokazati da ne postoji druga lepa konfiguracija sa sumom visina većom od 22.
Primer 3:

Ulaz: maxHeights = [3,2,5,5,2,3]
Izlaz: 18
Objašnjenje: Jedna lepa konfiguracija sa maksimalnom sumom je heights = [2,2,5,5,2,2]. Ova konfiguracija je lepa jer:
- 1 <= heights[i] <= maxHeights[i]
- heights je planina sa vrhom i = 2.
Napomena da, za ovu konfiguraciju, i = 3 takođe može biti smatran za vrh.
Može se pokazati da ne postoji druga lepa konfiguracija sa sumom visina većom od 18.

Ograničenja:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

Dobijate niz maxHeights sa n celobrojnih elemenata, indeksiran od 0.
Vaš zadatak je da izgradite n kula na koordinatnoj liniji. i-ta kula je izgrađena na koordinati i i ima visinu heights[i].
Konfiguracija kula je lepa ako su ispunjeni sledeći uslovi:

1 <= heights[i] <= maxHeights[i]
heights je planinski niz.

Niz heights je planinski ako postoji indeks i takav da:

Za sve 0 < j <= i, heights[j - 1] <= heights[j]
Za sve i <= k < n - 1, heights[k + 1] <= heights[k]

Vraća se maksimalna moguća suma visina lepe konfiguracije kula.

Primer 1:

Ulaz: maxHeights = [5,3,4,1,1]
Izlaz: 13
Objašnjenje: Jedna lepa konfiguracija sa maksimalnom sumom je heights = [5,3,3,1,1]. Ova konfiguracija je lepa jer:
- 1 <= heights[i] <= maxHeights[i]
- heights je planina sa vrhom i = 0.
Može se pokazati da ne postoji druga lepa konfiguracija sa sumom visina većom od 13.
Primer 2:

Ulaz: maxHeights = [6,5,3,9,2,7]
Izlaz: 22
Objašnjenje: Jedna lepa konfiguracija sa maksimalnom sumom je heights = [3,3,3,9,2,2]. Ova konfiguracija je lepa jer:
- 1 <= heights[i] <= maxHeights[i]
- heights je planina sa vrhom i = 3.
Može se pokazati da ne postoji druga lepa konfiguracija sa sumom visina većom od 22.
Primer 3:

Ulaz: maxHeights = [3,2,5,5,2,3]
Izlaz: 18
Objašnjenje: Jedna lepa konfiguracija sa maksimalnom sumom je heights = [2,2,5,5,2,2]. Ova konfiguracija je lepa jer:
- 1 <= heights[i] <= maxHeights[i]
- heights je planina sa vrhom i = 2.
Napomena da, za ovu konfiguraciju, i = 3 takođe može biti smatran za vrh.
Može se pokazati da ne postoji druga lepa konfiguracija sa sumom visina većom od 18.

Ograničenja:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

Дат вам је низ maxHeights дужине n који садржи цели бројеве. Ваш задатак је да изградите n торања на координатној линији. Торањ са индексом i се гради на координати i и има висину heights[i].

Конфигурација торања је лепа ако су испуњени следећи услови:

1 <= heights[i] <= maxHeights[i]
heights је планински низ.

Низ heights је планина ако постоји индекс i такав да:

- За сваки 0 < j <= i. важи heights[j - 1] <= heights[j].
- За сваки i <= k < n - 1, важи heights[k + 1] <= heights[k].

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

Пример 1:

Улаз: maxHeights = [5, 3, 4, 1, 1]
Излаз: 13
Објашњење: Једна лепа конфигурација са максималном сумом је heights = [5, 3, 3, 1, 1]. Ова конфигурација је лепа јер:
- 1 <= heights[i] <= maxHeights[i]
- heights је планина са врхом на i = 0.
Може се показати да не постоји друга лепа конфигурација са већом сумом висина од 13.

Пример 2:

Улаз: `maxHeights = [6, 5, 3, 9, 2, 7]`
Излаз: 22
Објашњење: Једна лепа конфигурација са максималном сумом је heights = [3, 3, 3, 9, 2, 2]. Ова конфигурација је лепа јер:
- 1 <= heights[i] <= maxHeights[i]
- heights је планина са врхом на i = 3.
Може се показати да не постоји друга лепа конфигурација са већом сумом висина од 22.

Пример 3:

Улаз: maxHeights = [3, 2, 5, 5, 2, 3]
Излаз: 18
Објашњење: Једна лепа конфигурација са максималном сумом је heights = [2, 2, 5, 5, 2, 2]. Ова конфигурација је лепа јер:
- 1 <= heights[i] <= maxHeights[i]
- heights је планина са врхом на i = 2.
Напомена: за ову конфигурацију, i = 3 такође може бити сматран врхом.
Може се показати да не постоји друга лепа конфигурација са већом сумом висина од 18.

Ограничења:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9


Дат вам је 0-индексиран низ бројева и целобројни target.
Низ infinite_nums који је индексиран од нуле је генерисан тако што су елементи низа nums бесконачно додавани самом себи.
Врати дужину најкраћег подниза низа бесконачни_бројеви са збиром једнаким циљу. Ако не постоји такав подниз врати -1.

Пример 1:

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

Пример 2:

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

Улаз: nums = [2,4,6,8], target = 3
Излаз: -1
Објашњење: У овом примеру infinite_nums = [2,4,6,8,2,4,6,8,...].
Може се доказати да не постоји подниз са збиром једнаким target = 3.

Ограничења:

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

Дат вам је низ са индексом 0, nums, и целобројна вредност target.
Низ са индексом 0, infinite_nums, генерише се бескрајним додавањем елемената низа nums себи.
Вратите дужину најкраћег подниза из низа infinite_nums чија је сума једнака target. Ако такав подниз не постоји, вратите -1.

Пример 1:

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

Пример 2:

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

Пример 3:

Улаз: nums = [2,4,6,8], target = 3
Излаз: -1
Објашњење: У овом примеру infinite_nums = [2,4,6,8,2,4,6,8,...].
Може се доказати да не постоји под-низ са збиром једнаким target = 3.

Ограничења:

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

Дат вам је низ бројева индексираних 0 и циљ са целим бројем.
Низ индексиран са 0 инфините_нумс се генерише бесконачним додавањем елемената нумс себи.
Врати дужину најкраћег подниза низа бесконачни_бројеви са збиром једнаким циљу. Ако не постоји такав подниз врати -1.

Пример 1:

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

Пример 2:

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

Пример 3:

Улаз: nums = [2,4,6,8], target = 3
Излаз: -1
Објашњење: У овом примеру infinite_nums = [2,4,6,8,2,4,6,8,...].
Може се доказати да не постоји подниз са збиром једнаким target = 3.

Ограничења:

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


Napomena : Ne prevodite nijedan LaTeX kod. Takođe, nemojte prevoditi sadržaj koji predstavlja kod (ulaz/izlaz) ili sintaksu programskih jezika, kao ni nazive promenljivih.

Problem:

Dati su vam binarni string `s` i pozitivan ceo broj `k`.
Podniz stringa `s` je lep ako tačno `k` cifara unutar njega iznosi 1.
Neka `len` predstavlja dužinu najkraćeg lepog podniza.
Vratite leksikografski najmanji lep podniz stringa `s` sa dužinom jednakom `len`. Ako `s` ne sadrži lep podniz, vratite prazan string.

String `a` je leksikografski veći od stringa `b` (iste dužine) ako se na prvoj poziciji na kojoj se `a` i `b` razlikuju, karakter u `a` razlikuje od odgovarajućeg karaktera u `b` tako što je striktno veći.

Na primer, "abcd" je leksikografski veći od "abcc" jer se prvi put razlikuju na četvrtom karakteru, i `d` je veće od `c`.

 Primer 1:

Ulaz: `s = "100011001"`, `k = 3`
Izlaz: `"11001"`
Objašnjenje: Postoji 7 lepih podnizova u ovom primeru:
1. Podniz "100011001".
2. Podniz "100011001".
3. Podniz "100011001".
4. Podniz "100011001".
5. Podniz "100011001".
6. Podniz "100011001".
7. Podniz "100011001".

Dužina najkraćeg lepog podniza je 5.

Пример 2:

Улаз: s = "1011", k = 2
Излаз: "11"
Објашњење: Постоје 3 лепа подниза у овом примеру:
1. Подниз "1011".
2. Подниз "1011".
3. Подниз "1011".
Дужина најкраћег лепог подниза је 2.
Лексикографски најмањи леп подниз са дужином 2 је подниз "11".

Пример 3:

Улаз: s = "000", k = 1
Излаз: ""
Објашњење: Не постоје лепи поднизови у овом примеру.

Ограничења:

1 <= s.length <= 100
1 <= k <= s.length

Дат вам је бинарни низ s и позитиван целобројни број k. Подниз низа s је леп ако број 1 у њему износи тачно k. Нека len буде дужина најкраћег лепог подниза.
Вратите лексикографски најмањи лепи подниз низа s који има дужину једнаку len. Ако низ s не садржи лепи подниз, вратите празан низ.
Низ a је лексикографски већи од низа b (исте дужине) ако се на првој позицији где се a и b разликују, a има знак који је строго већи од одговарајућег знака у b.

На пример, "abcd" је лексикографски већи од "abcc" јер се на четвртој позицији разликују, а d је веће од c.

Пример 1:

Улаз: s = "100011001", k = 3
Излаз: "11001"
Објашњење: Постоји 7 лепих поднизова у овом примеру:
1. Подниз "100011001".
2. Подниз "100011001".
3. Подниз "100011001".
4. Подниз "100011001".
5. Подниз "100011001".
6. Подниз "100011001".
7. Подниз "100011001".
Дужина најкраћег лепог подниза је 5.
Лексикографски најмањи леп подниз са дужином 5 је подниз "11001".

Пример 2:

Улаз: s = "1011", k = 2
Излаз: "11"
Објашњење: Постоје 3 лепа подниза у овом примеру:
1. Подниз "1011".
2. Подниз "1011".
3. Подниз "1011".
Дужина најкраћег лепог подниза је 2.
Лексикографски најмањи леп подниз са дужином 2 је подниз "11".

Пример 3:

Улаз: s = "000", k = 1
Излаз: ""
Објашњење: Не постоје лепи поднизови у овом примеру.

Ограничења:

1 <= s.length <= 100
1 <= k <= s.length

Дат вам је бинарни низ с и позитиван цео број k.
Подниз од с је леп ако је број 1 у њему тачно k.
Нека је лен дужина најкраћег лепог подниза.
Вратите лексикографски најмањи леп подниз низа s са дужином једнаком len. Ако s не садржи леп подниз, вратите празан низ.
Низ a је лексикографски већи од низа b (исте дужине) ако на првој позицији где се a и b разликују, a има карактер строго већи од одговарајућег карактера у b.

На пример, "abcd" је лексикографски већи од "abcc" јер је прва позиција на којој се разликују на четвртом знаку, а d је веће од c.

Пример 1:

Улаз: s = "100011001", k = 3
Излаз: "11001"
Објашњење: У овом примеру постоји 7 лепих подстрингова:
1. Подниз "100011001".
2. Подниз "100011001".
3. Подниз "100011001".
4. Подниз "100011001".
5. Подниз "100011001".
6. Подниз "100011001".
7. Подниз "100011001".
Дужина најкраћег лепог подниза је 5.
Лексикографски најмањи леп подниз дужине 5 је подниз „11001“.

Пример 2:

Улаз: s = "1011", k = 2
Излаз: "11"
Објашњење: У овом примеру постоје 3 прелепа подниза:
1. Подниз "1011".
2. Подниз "1011".
3. Подниз "1011".
Дужина најкраћег лепог подниза је 2.
Лексикографски најмањи леп подниз дужине 2 је подниз "11".

Пример 3:

Улаз: s = "000", k = 1
Излаз: ""
Објашњење: У овом примеру нема лепих поднизова.

Ограничења:

1 <= s.length <= 100
1 <= k <= s.length


Дат вам је n процесора, сваки са 4 језгра, и n * 4 задатака које треба извршити тако да свако језгро извршава само један задатак.
Дат вам је 0-индексиран низ целих бројева processorTime који представља време када сваки процесор постаје доступан први пут и 0-индексиран низ целих бројева tasks који представља време потребно за извршење сваког задатка.
Вратите минимално време када ће сви задаци бити извршени од стране процесора.
Напомена: Свако језгро извршава задатак независно од осталих.

Пример 1:

Улаз: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Излаз: 16
Објашњење:
Оптимално је доделити задатке на индексима 4, 5, 6, 7 првом процесору који постаје доступан у времену = 8, а задатке на индексима 0, 1, 2, 3 другом процесору који постаје доступан у времену = 10.
Време које први процесор треба да заврши извршавање свих задатака = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Време које други процесор треба да заврши извршавање свих задатака = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Дакле, може се показати да је минимално време потребно за извршавање свих задатака 16.

Пример 2:

Улаз: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Излаз: 23
Објашњење:
Оптимално је доделити задатке на индексима 1, 4, 5, 6 првом процесору који постаје доступан у времену = 10, а задатке на индексима 0, 2, 3, 7 другом процесору који постаје доступан у времену = 20.
Време које први процесор треба да заврши извршавање свих задатака = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Време које други процесор треба да заврши извршавање свих задатака = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.

Ограничења:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

Имаш Н процесоре који имају 4 језгре и n * 4 задатке који треба извршити тако да свако језгро треба да изврши само један задатак.
С обзиром на 0-индексирани низ целих бројева који представља време на којем сваки процесор постаје доступан први пут и 0-индексирани низ целих бројева који представљају време које је потребно да извршава сваки задатак, вратите минимално време када су сви задаци били извршава процесори.
Напомена: Свако језгро извршава задатак независно од осталих.

Пример 1:

Ulaz: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Излаз: 16
Објашњење:
Оптимално је доделити задатке на индексима 4, 5, 6, 7 на први процесор који постаје доступан у времену = 8, а задаци у индексима 0, 1, 2, 3 на други процесор који постаје доступан у времену = 10 .
Време које је први процесор потребно за завршетак свих задатака који ће завршити извршење свих задатака = мак (8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Време које је други процесор потребно за завршетак свих задатака да заврши извршење свих задатака = мак (10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Дакле, то се може показати да је потребно најмање време за извршавање свих задатака 16.
Пример 2:

Ulaz: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Излаз: 23
Објашњење:
Оптимално је доделити задатке у индексима 1, 4, 5, 6 на први процесор који постаје доступан у времену = 10, а задаци у индексима 0, 2, 3, 7 на други процесор који постаје доступан у времену = 20 .
Време је преузело први процесор да заврши извршење свих задатака = маx (10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Време које је други процесор потребно за завршетак свих задатака да заврши извршење свих задатака = маx (20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Дакле, то се може показати да је потребно најмање време за извршавање свих задатака 23.

ОГРАНИЧЕЊА:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

Дати су n процесора, од којих сваки има 4 језгра, и n * 4 задатака који треба да се изврше, тако да свако језгро извршава само један задатак.
Дати су низови целих бројева са индексом 0: processorTime, који представља време када сваки процесор постаје доступан по први пут, и tasks, који представља време потребно за извршење сваког задатка.
Вратите минимално време када су сви задаци извршени од стране процесора.
Напомена: Свако језгро извршава задатак независно од осталих.

Пример 1:

Ulaz: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Izlaz: 16
Објашњење:
Оптимално је дати задатке из индекса 4, 5, 6, 7 првом процесору који постаје доступан у времену = 8, и задатке из индекса 0, 1, 2, 3 другом процесору који постаје доступан у времену = 10.
Време које узима први процесор да заврши извршење свих задатака = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Време које узима други процесор да заврши извршење свих задатака = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Стога, може се показати да је минимално време за извршење свих задатака 16.

Пример 2:

Ulaz: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Izlaz: 23
Објашњење:
Оптимално је дати задатке из индекса 1, 4, 5, 6 првом процесору који постаје доступан у времену = 10, и задатке из индекса 0, 2, 3, 7 другом процесору који постаје доступан у времену = 20.
Време које узима први процесор да заврши извршење свих задатака = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Време које узима други процесор да заврши извршење свих задатака = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Стога, може се показати да је минимално време за извршење свих задатака 23.

Ограничења:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n


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

Изаберите било која два различита индекса i и j и истовремено ажурирајте вредности nums[i] на (nums[i] И nums[j]) и nums[j] на (nums[i] ИЛИ nums[j]). Овде, ИЛИ означава битовску операцију ИЛИ, а И означава битовску операцију И.

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

Пример 1:

Улаз: nums = [2,6,5,8], k = 2
Излаз: 261
Објашњење: Можемо извршити следеће операције на низу:
- Одаберите i = 0 и j = 3, затим промените nums[0] на (2 И 8) = 0 и nums[3] на (2 ИЛИ 8) = 10. Резултујући низ је nums = [0,6,5,10].
- Одаберите i = 2 и j = 3, затим промените nums[2] на (5 И 10) = 0 и nums[3] на (5 ИЛИ 10) = 15. Резултујући низ је nums = [0,6,0,15].
Можемо одабрати елементе 15 и 6 из коначног низа. Збир квадрата је 15^2 + 6^2 = 261.
Може се показати да је ово максимална вредност коју можемо добити.

Пример 2:

Улаз: nums = [4,5,4,7], k = 3
Излаз: 90
Објашњење: Не морамо примењивати ниједну операцију.
Можемо одабрати елементе 7, 5 и 4 са збиром квадрата: 7^2 + 5^2 + 4^2 = 90.
Може се показати да је ово максимална вредност коју можемо добити.

Ограничења:

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

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

Изаберите било која два различита индекса i и j и истовремено ажурирајте вредности nums[i] to (nums[i] AND nums[j]) and nums[j] to (nums[i] OR nums[j]). Овде, OR означава битовску операцију OR, а AND означава битовску операцију AND.

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

Пример 1:

Улаз: nums = [2,6,5,8], k = 2
Излаз: 261
Објашњење: Можемо извршити следеће операције на низу:
- Одаберите i = 0 и j = 3, затим промените nums[0] на (2 AND 8) = 0 and nums[3] to (2 OR 8) = 10. Резултујући низ је nums = [0,6,5,10].
- Одаберите i = 2 и j = 3, затим промените nums[2] на 5 AND 10) = 0 and nums[3] to (5 OR 10) = 15. Резултујући низ је nums = [0,6,0,15].
Можемо одабрати елементе 15 и 6 из коначног низа. Збир квадрата је 15^2 + 6^2 = 261.
Може се показати да је ово максимална вредност коју можемо добити.

Пример 2:

Улаз: nums = [4,5,4,7], k = 3
Излаз: 90
Објашњење: Не морамо примењивати ниједну операцију.
Можемо изабрати елементе 7, 5 и 4 са збиром квадрата: 7^2 + 5^2 + 4^2 = 90.
Може се показати да је ово максимална вредност коју можемо добити.

Ограничења:

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

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

Изаберите било која два различита индекса i и j и истовремено ажурирајте вредности nums[i] на (nums[i] И nums[j]) и nums[j] на (nums[i] ИЛИ nums[j]). Овде, ИЛИ означава битовску операцију ИЛИ, а И означава битовску операцију И.

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

Пример 1:

Улаз : nums = [2,6,5,8], к = 2
излаз : 261
Објашњење : Можемо да урадимо следеће операције на низу:
- Изаберите и = 0 и ј = 3, а затим промените nums[0] у (2 И 8) = 0 и nums[3] у (2 ИЛИ 8) = 10. Добијени низ је нумс = [0,6,5,10].
- Изаберите и = 2 и ј = 3, а затим промените nums[2] у (5 И 10) = 0 и nums[3] у (5 ОР 10) = 15. Добијени низ је нумс = [0,6,0,15].
Можемо изабрати елементе 15 и 6 из коначног низа. Збир квадрата је 15 ^ 2 + 6 ^ 2 = 261.
Може се показати да је ово максимална вредност коју можемо добити.

Пример 2:

Улаз : nums = [4,5,4,7], k = 3
излаз : 90
Објашњење : Не морамо да примењујемо никакве операције.
Можемо изабрати елементе 7, 5 и 4 са збиром квадрата: 7 ^ 2 + 5 ^ 2 + 4 ^ 2 = 90.
Може се показати да је ово максимална вредност коју можемо добити.

Ограничења:

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