Узор AtCoder-овог тапета може се представити на xy-равни на следећи начин:

- Равни су подељени следећим типовима линија:

- x = n (где је n цео број)

- y = n (где је n паран број)

- x + y = n (где је n паран број)

- Свака област је обојена црно или бело. Свака две суседне области дуж једне од ових линија су обојене различитим бојама.

- Област која садржи (0.5, 0.5) је обојена црно.

Следећа слика приказује део узорка.

Дати су вам цели бројеви A, B, C, D. Размотрите правоугаоник чије су странице паралелне x- и y-осама, са доњим левим теменом у (A, B) и горњим десним теменом у (C, D). Израчунајте површину области обојених црно унутар овог правоугаоника, и испишите дуплу вредност те површине. Може се доказати да ће излазна вредност бити цео број.

Улаз

Улаз се даје из Стандардног Улаза у следећем формату:
A B C D

Излаз

Испишите одговор у једној линији.

Ограничења

- -10^9 \leq A, B, C, D \leq 10^9
- A < C и B < D.
- Све улазне вредности су цели бројеви.

Пример Улаз 1

0 0 3 3

Пример Излаз 1

10

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

Површина је 5, па испишите дуплу вредност: 10.

Пример Улаз 2

-1 -2 1 3

Пример Излаз 2

11

Површина је 5.5, што није цео број, али излазна вредност је цео број.

Пример Улаз 3

-1000000000 -1000000000 1000000000 1000000000

Пример Излаз 3

4000000000000000000

Ово је случај са највећим правоугаоником, где излаз и даље стаје у 64-битни потписани цео број.

Узор AtCoder-овог тапета може се представити на xy-равни на следећи начин:

- Равни су подељени следећим типовима линија:

- x = n (где је n цео број)

- y = n (где је n паран број)

- x + y = n (где је n паран број)

- Свака област је обојена црно или бело. Свака две суседне области дуж једне од ових линија су обојене различитим бојама.

- Област која садржи (0.5, 0.5) је обојена црно.

Следећа слика приказује део узорка.

Дати су вам цели бројеви A, B, C, D. Размотрите правоугаоник чије су странице паралелне x- и y-осама, са доњим левим теменом у (A, B) и горњим десним теменом у (C, D). Израчунајте површину области обојених црно унутар овог правоугаоника, и испишите дуплу вредност те површине. Може се доказати да ће излазна вредност бити цео број.

Улаз

Улаз се даје из Стандардног Улаза у следећем формату:
A B C D

Излаз

Испишите одговор у једној линији.

Ограничења

- -10^9 \leq A, B, C, D \leq 10^9
- A < C и B < D.
- Све улазне вредности су цели бројеви.

Пример Улаз 1

0 0 3 3

Пример Излаз 1

10

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

Површина је 5, па испишите дуплу вредност: 10.

Пример Улаза 2

-1 -2 1 3

Пример Излаза 2

11

Површина је 5.5, што није цео број, али излазна вредност је цео број.

Пример Улаза 3

-1000000000 -1000000000 1000000000 1000000000

Пример Излаза 3

4000000000000000000

Ово је случај са највећим правоугаоником, где излаз и даље стаје у 64-битни потписани цео број.


Ово је интерактиван проблем (где ваш програм интерактује са судијом преко уноса и излаза).
Дат вам је позитиван цео број N и цели бројеви L и R такви да је 0 \leq L \leq R < 2^N. Судија има скривени низ A = (A_0, A_1, \dots, A_{2^N-1}) који се састоји из целих бројева између 0 и 99, укључујући.

Ваш циљ је да пронађете остатак када се A_L + A_{L+1} + \dots + A_R подели са 100. Међутим, не можете директно знати вредности елемената у низу A. Уместо тога, можете питати судију следеће питање:

- Изаберите не-негативне целе бројеве i и j такве да је 2^i(j+1) \leq 2^N. Нека је l = 2^i j и r = 2^i (j+1) - 1. Питајте за остатак када се A_l + A_{l+1} + \dots + A_r подели са 100.

Нека је m минималан број питања потребан да се одреди остатак када се A_L + A_{L+1} + \dots + A_R подели са 100 за било који низ A. Потребно је да нађете овај остатак унутар m питања.

Улаз и излаз

Ово је интерактиван проблем (где ваш програм интерактује са судијом преко уноса и излаза).
Прво, прочитајте целе бројеве N, L и R са Стандардног улаза:
N L R

Затим, понављајте постављање питања док не можете одредити остатак када се A_L + A_{L+1} + \dots + A_R подели са 100. Свако питање треба да буде исписано у следећем формату:
? i j

Овде, i и j морају задовољавати следеће ограничења:

- i и j су не-негативни цели бројеви.
- 2^i(j+1) \leq 2^N

Одговор на питање ће бити дат у следећем формату са стандардног улаза:
T

Овде је T одговор на питање, односно остатак када се A_l + A_{l+1} + \dots + A_r подели са 100, где је l = 2^i j и r = 2^i (j+1) - 1.
Ако i и j не задовољавају ограничења, или ако број питања премаши m, тада ће T бити -1.
Ако судија врати -1, ваш програм се већ сматра нетачним. У том случају, одмах прекините програм.
Када одредите остатак када се A_L + A_{L+1} + \dots + A_R подели са 100, испишите остатак S у следећем формату и одмах прекините програм:
! S

Улаз и излаз

Ово је интерактиван проблем (где ваш програм интерактује са судијом преко улаза и излаза).
Прво, прочитајте целе бројеве N, L и R са Стандардног улаза:
N L R

Затим, понављајте постављање питања док не можете одредити остатак када се A_L + A_{L+1} + \dots + A_R подели са 100. Свако питање треба да буде исписано у следећем формату:
? i j

Овде, i и j морају задовољавати следеће услове:

- i и j су не-негативни цели бројеви.
- 2^i(j+1) \leq 2^N

Одговор на питање ће бити дат у следећем формату са Стандардног улаза:
T

Овде је T одговор на питање, односно остатак када се A_l + A_{l+1} + \dots + A_r подели са 100, где је l = 2^i j и r = 2^i (j+1) - 1.
Ако i и j не задовољавају ограничења, или ако број питања премаши m, тада ће T бити -1.
Ако судија врати -1, ваш програм се већ сматра нетачним. У том случају, одмах прекините програм.
Када одредите остатак када се A_L + A_{L+1} + \dots + A_R подели са 100, испишите остатак S у следећем формату и одмах прекините програм:
! S

Ограничења

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Све вредности улаза су цели бројеви.

Ово је интерактивни проблем (где ваш програм комуницира са судијом путем улаза и излаза).
Дат вам је позитиван цео број Н и цели бројеви Л и Р такви да је 0 \leq L \leq R < 2^N. Судија има скривени низ A = (A_0, A_1, \dots, A_{2^N-1}) који се састоји од целих бројева између 0 и 99, укључујући.
Ваш циљ је да пронађете остатак када се A_L + A_{L+1} + \dots + A_R подели са 100. Међутим, не можете директно знати вредности елемената у низу А. Уместо тога, можете питати судију да следеће питање:

- Изаберите ненегативне целе бројеве и и ј такве да је 2^i(j+1) \leq 2^N. Нека је l = 2^i j и r = 2^i (j+1) - 1. Затражите остатак када се A_l + A_{l+1} + \dots + A_R подели са 100.

Нека је м минимални број питања потребан за одређивање остатка када се A_l + A_{l+1} + \dots + A_r подели са 100 за било коју секвенцу А. Овај остатак морате пронаћи унутар м питања.

Улаз и излаз

Ово је интерактивни проблем (где ваш програм комуницира са судијом путем улаза и излаза).
Прво прочитајте целе бројеве Н, Л и Р из стандардног уноса:
N L R

Затим понављајте постављање питања док не можете да одредите остатак када је A_L + A_{L+1} + \dots + A_R подељено са 100. Свако питање треба да буде одштампано у следећем формату:
? i j

Овде i и ј морају да задовоље следећа ограничења:

- i и ј су ненегативни цели бројеви.
- 2^i(j+1) \leq 2^N

Одговор на питање ће бити дат у следећем формату из Стандардног уноса:
Т

Овде је Т одговор на питање, а то је остатак када се A_l + A_{l+1} + \dots + A_r подели са 100, где је l = 2^i j и r = 2^i (j+1) - 1.
Ако i и ј не задовољавају ограничења, или ако број питања прелази м, онда ће Т бити -1.
Ако судија врати -1, ваш програм се већ сматра нетачним. У том случају, одмах затворите програм.
Када одредите остатак када је A_L + A_{L+1} + \dots + A_R подељен са 100, одштампајте остатак С у следећем формату и одмах затворите програм:
! S

Улаз и излаз

Ово је интерактивни проблем (где ваш програм комуницира са судијом путем улаза и излаза).
Прво прочитајте целе бројеве N, L и R из стандардног уноса:
N L R

Затим понављајте постављање питања док не можете да одредите остатак када је A_L + A_{L+1} + \dots + A_R подељено са 100. Свако питање треба да буде одштампано у следећем формату:
? i j

Овде i и ј морају да задовоље следећа ограничења:

- i и ј су ненегативни цели бројеви.
- 2^i(j+1) \leq 2^N

Одговор на питање ће бити дат у следећем формату из Стандардног уноса:
Т

Овде је Т одговор на питање, а то је остатак када се A_l + A_{l+1} + \dots + A_r подели са 100, где је l = 2^i j и r = 2^i (j+1) - 1.
Ако и и ј не задовољавају ограничења, или ако број питања прелази м, онда ће Т бити -1.
Ако судија врати -1, ваш програм се већ сматра нетачним. У том случају, одмах затворите програм.
Када одредите остатак када је A_L + A_{L+1} + \dots + A_R подељен са 100, одштампајте остатак С у следећем формату и одмах затворите програм:
! S

Ограничења

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Све улазне вредности су цели бројеви.

Ovo je interaktivan problem (gde vaš program interaguje sa sudijom putem ulaza i izlaza).
Dati su vam pozitivni ceo broj N i celobrojni brojevi L i R, tako da važi 0 \leq L \leq R < 2^N. Sudija ima skrivenu sekvencu A = (A_0, A_1, \dots, A_{2^N-1}) koja se sastoji od celobrojnih vrednosti između 0 i 99, uključujući.

Vaš cilj je da pronađete ostatak kada je A_L + A_{L+1} + \dots + A_R podeljeno sa 100. Međutim, ne možete direktno da znate vrednosti elemenata u sekvenci A. Umesto toga, možete postaviti sudiji sledeće pitanje:

- Izaberite nenegativne cele brojeve i i j, tako da važi 2^i(j+1) \leq 2^N. Neka l = 2^i j i r = 2^i (j+1) - 1. Pitajte za ostatak kada je A_l + A_{l+1} + \dots + A_r podeljeno sa 100.

Neka m bude minimalan broj pitanja potrebnih da se odredi ostatak kada je A_L + A_{L+1} + \dots + A_R podeljeno sa 100 za bilo koju sekvencu A. Morate da pronađete ovaj ostatak u m pitanjima.

Ulaz i izlaz

Ovo je interaktivan problem (gde vaš program interaguje sa sudijom putem ulaza i izlaza).
 Prvo pročitajte cele brojeve N, L i R sa standardnog ulaza:
N L R

Затим, понављајте постављање питања док не можете одредити остатак када се A_L + A_{L+1} + \dots + A_R подели са 100. Свако питање треба да буде исписано у следећем формату:
? i j

Овде, i и j морају задовољавати следеће услове:

- i и j су не-негативни цели бројеви.
- 2^i(j+1) \leq 2^N

Одговор на питање ће бити дат у следећем формату са стандардног улаза:
T

Овде је T одговор на питање, односно остатак када се A_l + A_{l+1} + \dots + A_r подели са 100, где је l = 2^i j и r = 2^i (j+1) - 1.
Ако i и j не задовољавају услове, или ако број питања премаши m, тада ће T бити -1.
Ако судија врати -1, ваш програм се већ сматра нетачним. У том случају, одмах прекините програм.
Када одредите остатак када се A_L + A_{L+1} + \dots + A_R подели са 100, испишите остатак S у следећем формату и одмах прекините програм:
! S

Улаз и излаз

Ово је интерактиван проблем (где ваш програм интерактује са судијом преко уноса и излаза).
Прво, прочитајте целе бројеве N, L и R са стандардног улаза:
N L R

Затим, понављајте постављање питања док не можете одредити остатак када се A_L + A_{L+1} + \dots + A_R подели са 100. Свако питање треба да буде исписано у следећем формату:
? i j

Овде, i и j морају задовољавати следеће услове:

- i и j су не-негативни цели бројеви.
- 2^i(j+1) \leq 2^N

Одговор на питање ће бити дат у следећем формату са стандардног улаза:
T

Овде је T одговор на питање, односно остатак када се A_l + A_{l+1} + \dots + A_r подели са 100, где је l = 2^i j и r = 2^i (j+1) - 1.
Ако i и j не задовољавају услове, или ако број питања премаши m, тада ће T бити -1.
Ако судија врати -1, ваш програм се већ сматра нетачним. У том случају, одмах прекините програм.
Када одредите остатак када се A_L + A_{L+1} + \dots + A_R подели са 100, испишите остатак S у следећем формату и одмах прекините програм:
! S

Ограничења

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Све вредности уноса су цели бројеви.


Дате су вам две секвенце A = (A_1, A_2, ..., A_N) и B = (B_1, B_2, ..., B_M). Сви елементи секвенци A и B су међусобно различити. Одредите да ли секвенца C = (C_1, C_2, ..., C_{N+M}), формирана тако што су сви елементи A и B сортирани у растућем редоследу, садржи два узастопна елемента који се појављују у A.

Улаз

Улаз се даје са стандардног улаза у следећем формату:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Излаз

Ако C садржи два узастопна елемента која се појављују у A, испишите Yes; у супротном, испишите No.

Ограничења

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M су различити.
- Све вредности улаза су цели бројеви.

Пример улаза 1

3 2
3 2 5
4 1

Пример излаза 1

Yes

C=(1,2,3,4,5). Пошто 2 и 3 из A настају узастопно у C, испишите Yes.

Пример улаза 2

3 2
3 1 5
4 2

Пример излаза 2

No

C=(1,2,3,4,5). Пошто ниједан пар елемената из A не наступа узастопно у C, испишите No.

Пример улаза 3

1 1
1
2

Пример излаза 3

No

Дат вам је низ A=(A_1,A_2,\dots,A_N) дужине Н и низ B=(B_1,B_2,\dots,B_M) дужине М. Сви елементи А и Б су међусобно различити . Одредите да ли низ C=(C_1,C_2,\dots,C_{N+M}) формиран сортирањем свих елемената А и Б у растућем редоследу садржи два узастопна елемента који се појављују у А.

Инпут

Улаз се даје из стандардног уноса у следећем формату:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Излаз

Ако Ц садржи два узастопна елемента која се појављују у А, одштампајте Yes; у супротном, штампајте No.

Ограничења

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M су различите.
- Све улазне вредности су цели бројеви.

Пример уноса 1

3 2
3 2 5
4 1

Пример излаза 1

Yes

C=(1,2,3,4,5). Пошто се 2 и 3 из А јављају узастопно у C, одштампајте Yes.

Пример уноса 2

3 2
3 2 5
4 1

Пример излаза 2

No

C=(1,2,3,4,5). Пошто се два елемента из А не појављују узастопно у C, одштампајте No.

Пример уноса 3

1 1
1
2

Пример излаза 3

No

Дате су вам секвенце A=(A_1,A_2,\dots,A_N) дужине N и B=(B_1,B_2,\dots,B_M) дужине M. Овде су сви елементи A и B међусобно различити. Потребно је утврдити да ли низ C=(C_1,C_2,\dots,C_{N+M}) формиран сортирањем свих елемената A и B у растућем редоследу садржи два узастопна елемента који се појављују у A.

Улаз

Улаз се даје са Стандардног улаза у следећем формату:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Излаз

Ако C садржи два узастопна елемента који се појављују у A, исписати Yes; у супротном, исписати No.

Ограничења

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M су различити.
- Сви улазни подаци су цели бројеви.

Пример улаза 1

3 2
3 2 5
4 1

Пример излаза 1

Yes

C=(1,2,3,4,5). Пошто 2 и 3 из A појављују узастопно у C, испишите Yes.

Пример улаза 2

3 2
3 1 5
4 2

Пример излаза 2

No

C=(1,2,3,4,5). Пошто се ника два елемента из A не појављују узастопно у C, исписати No.

Пример улаза 3

1 1
1
2

Пример излаза 3

No


Постоји мрежа димензија Н × Н, где ћелија у и-том реду (рачунајући одозго) и ј-ој колони (рачунајући са леве стране) садржи цео број Н × (и-1) + ј.
Током Т потеза биће објављени цели бројеви. На и-том потезу се објављује цео број А_и, а ћелија која садржи А_и је означена. Одредите потез којим је Бинго први постигнут. Ако Бинго није постигнут унутар Т потеза, одштампајте -1.
Овде, постизање Бинга значи испуњавање најмање једног од следећих услова:

Постоји ред у коме су означене све Н ћелије.
Постоји колона у којој су означене све Н ћелије.
Постоји дијагонална линија (од горњег левог до доњег десног угла или од горњег десног до доњег левог угла) у којој су означене све Н ћелије.

Инпут

Улаз се даје из стандардног уноса у следећем формату:
Н Т
А_1 А_2 \лдотс А_Т

Излаз

Ако је Бинго постигнут унутар Т потеза, одштампајте број потеза на којима је Бинго први пут постигнут; у супротном, исписати -1.

Ограничења

- 2 \лек Н \лек 2 \пута 10^3
- 1 \лек Т \лек \мин(Н^2, 2 \пута 10^5)
- 1 \лек А_и \лек Н^2
- А_и \нек А_ј ако и \нек ј.
- Све улазне вредности су цели бројеви.

Пример уноса 1

3 5
5 1 8 9 7

Пример излаза 1

4

Стање мреже се мења на следећи начин. Бинго је први постигнут у потезу 4.

Пример уноса 2

3 5
4 2 9 7 5

Пример излаза 2

-1

Бинго није постигнут у року од пет потеза, па испиши -1.

Пример уноса 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Пример излаза 3

9

Дата постоји мрежа величине N \times N, где ћелија у i-том реду од врха и j-тој колони од леве стране садржи цео број N \times (i-1) + j.
Током T потеза, биће објављивани цели бројеви. На потезу i, објављује се цео број A_i, и ћелија која садржи A_i је означена. Одредите потез током којег се први пут постиже Бинго. Ако Бинго није постигнут унутар T потеза, испишите -1.
Овде, постићи Бинго значи задовољити бар један од следећих услова:

- Постоји ред у којем су све N ћелије означене.
- Постоји колона у којој су све N ћелије означене.
- Постоји дијагонала (од горњег левог до доњег десног угла или од горњег десног до доњег левог угла) у којој су све N ћелије означене.

Input

The input is given from Standard Input in the following format:
N T
A_1 A_2 \ldots A_T

Output

If Бинго is achieved within T turns, print the turn number on which Бинго is achieved for the first time; otherwise, print -1.

Constraints

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j if i \neq j.
- All input values are integers.

Sample Input 1

3 5
5 1 8 9 7

Sample Output 1

4

The state of the grid changes as follows. Бинго is achieved for the first time on Turn 4.

Sample Input 2

3 5
4 2 9 7 5

Sample Output 2

-1

Бинго is not achieved within five turns, so print -1.

Sample Input 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Sample Output 3

9

Дата постоји мрежа величине N \times N, где ћелија у i-том реду од врха и j-тој колони од леве стране садржи цео број N \times (i-1) + j.
Током T потеза, биће објављивани цели бројеви. На потезу i, објављује се цео број A_i, и ћелија која садржи A_i је означена. Одаберите потез током којег се први пут постиже Бинго. Ако Бинго није постигнут унутар T потеза, испишите -1.
Овде, постићи Бинго значи задовољити бар један од следећих услова:

- Постоји ред у којем су све N ћелије означене.
- Постоји колона у којој су све N ћелије означене.
- Постоји дијагонала (од горњег левог до доњег десног угла или од горњег десног до доњег левог угла) у којој су све N ћелије означене.

Улаз

Улаз се даје из Стандарда у следећем формату:
N T
A_1 A_2 \ldots A_T

Излаз

Ако је Бинго постигнут унутар T потеза, испишите број потеза на којем је Бинго први пут постигнут; у супротном, испишите -1.

Ограничења

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j ако i \neq j.
- Све улазне вредности су цели бројеви.

Пример улаза 1

3 5
5 1 8 9 7

Пример излаза 1

4

Стање на решетки се мења на следећи начин. Бинго је постигнут по први пут на Потезу 4.

Пример улаза 2

3 5
4 2 9 7 5

Пример излаза 2

-1

Бинго није постигнут унутар пет потеза, тако да се исписује -1.

Пример улаза 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Пример излаза 3

9


Такахашијеву торту је појео неко. Три су осумњичена: особа 1, особа 2 и особа 3.
Два су сведока, Ринго и Снуке. Ринго се сећа да особа А није кривилац, а Снуке се сећа да особа Б није кривилац.
Одредите да ли се кривилац може јединствено идентификовати на основу сећања двојице сведока. Ако се кривилац може идентификовати, испишите број особе.

Улаз

Улаз се даје са Стандардног улаза у следећем формату:
A B

Излаз

Ако се на основу сећања двоје сведока може јединствено идентификовати кривац, испишите број особе; у супротном, испишите -1.

Ограничења

- 1 \leq A, B \leq 3
- Све улазне вредности су цели бројеви.

Пример улаза 1

1 2

Пример излаза 1

3

На основу сећања двоје сведока, може се одредити да је особа 3 кривац.

Пример улаза 2

1 1

Пример излаза 2

-1

На основу сећања двоје сведока, не може се одредити да ли је особа 2 или особа 3 кривац. Стога, испишите -1.

Пример улаза 3

3 1

Пример излаза 3

2

Тадахашијев колач је неко појео. Постоје три осумњичена: особа 1, особа 2 и особа 3. Постоје два сведока, Ринго и Снуке. Ринго се сећа да особа А није кривац, а Снуке се сећа да особа Б није кривац. Одредите да ли се кривац може јединствено идентификовати на основу сећања двоје сведока. Ако се кривац може идентификовати, испишите број особе.

Улаз

Улаз се даје са Стандардног улаза у следећем формату:
A B

Излаз

Ако се на основу сећања двоје сведока може јединствено идентификовати кривац, испишите број особе; у супротном, испишите -1.

Ограничења

- 1 \leq A, B \leq 3
- Све улазне вредности су цели бројеви.

Пример улаза 1

1 2

Пример излаза 1

3

На основу сећања двоје сведока, може се одредити да је особа 3 кривац.

Пример улаза 2

1 1

Пример излаза 2

-1

На основу сећања двоје сведока, не може се одредити да ли је особа 2 или особа 3 кривац. Стога, испишите -1.

Пример улаза 3

3 1

Пример излаза 3

2

Тадахашијев колач је неко појео. Постоје три осумњичена: особа 1, особа 2 и особа 3.
Постоје два сведока, Ринго и Снуке. Ринго се сећа да особа А није кривац, а Снуке се сећа да особа Б није кривац.
Одредите да ли се кривац може јединствено идентификовати на основу сећања двоје сведока. Ако се кривац може идентификовати, испишите број особе.

Улаз

Улаз се даје са Стандардног улаза у следећем формату:
A B

Излаз

Ако се кривац може јединствено утврдити на основу сећања двојице сведока, исписати број особе; у супротном, исписати -1.

Ограничења

- 1 \leq A, B \leq 3
- Све улазне вредности су цели бројеви.

Пример улаза 1

1 2

Пример излаза 1

3

На основу сећања двоје сведока, може се одредити да је особа 3 кривац.

Пример улаза 2

1 1

Пример излаза 2

-1

На основу сећања двоје сведока, не може се одредити да ли је особа 2 или особа 3 кривац. Дакле, испишите -1.

Пример улаза 3

3 1

Пример излаза 3

2


Дати су вам N интервала реалних бројева. i-ти (1 ≤ i ≤ N) интервал је [l_i, r_i]. Пронађите број парова (i, j) (1 ≤ i < j ≤ N) такав да i-ти и j-ти интервали имају пресек.

Улаз

Улаз се даје са стандардног улаза у следећем формату:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Излаз

Испишите одговор.

Ограничења

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Све улазне вредности су цели бројеви.

Пример улаза 1

3
1 5
7 8
3 7

Пример излаза 1

2

Дати интервали су [1,5], [7,8], [3,7]. Међу њима, 1-ви и 3-ти интервал се секу, као и 2-ри и 3-ти интервал, тако да је одговор 2.

Пример улаза 2

3
3 4
2 5
1 6

Пример излаза 2

3

Пример улаза 3

2
1 2
3 4

Пример излаза 3

0

Дат вам је N интервала реалних бројева. i-th (1 \leq i \leq N) интервал је [l_i, r_i]. Пронађите број парова (i, j)\,(1 \leq i < j \leq N) таквих да се i-th и j-th интервали секу.

Улаз

Улаз се даје са Стандардног улаза у следећем формату:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Излаз

Испишите одговор.

Ограничења

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Сви улазни подаци су цели бројеви.

Пример улаза 1

3
1 5
7 8
3 7

Пример излаза 1

2

Дати интервали су [1,5], [7,8], [3,7]. Међу њима, 1. и 3. интервал се пресеку, као и 2. и 3. интервал, па је одговор 2.

Пример улаза 2

3
3 4
2 5
1 6

Пример излаза 2

3

Пример улаза 3

2
1 2
3 4

Пример излаза 3

0

Дато вам је Н интервала реалних бројева.  i-ти (1 \leq i \leq N) интервал је  [l_i, r_i]. Одредити број парова (i, j),(1 \leq i < j \leq N) тако да се и-ти и ј-ти интервали секу.

Инпут

Улаз се даје из стандардног уноса у следећем формату:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Излаз

Одштампајте одговор.

Ограничења

-2 \leq N \leq 5 \times 10^5
-0 \leq l_i < r_i \leq 10^9
- Све улазне вредности су цели бројеви.

Пример уноса 1

3
1 5
7 8
3 7

Пример излаза 1

2

Дати интервали су [1,5], [7,8], [3,7]. Међу њима се секу 1. и 3. интервал, као и 2. и 3. интервал, па је одговор 2.

Пример уноса 2

3
3 4
2 5
1 6

Пример излаза 2

3

Пример уноса 3

2
1 2
3 4

Пример излаза 3

0


Дата вам је низ apple величине n и низ capacity величине m. Постоји n пакета где i-ти пакет садржи apple[i] јабуке. Постоји и m кутија, и i-та кутија има капацитет capacity[i] јабука. Вратите минималан број кутија које треба да изаберете како бисте прераспоредили ових n пакета јабука у кутије. Запамтите да јабуке из истог пакета могу бити распоређене у различите кутије.

Пример 1:

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

Пример 2:

Улаз: apple = [5,5,5], capacity = [2,4,2,7]
Излаз: 4
Објашњење: Мораћемо да искористимо све кутије.

Ограничења:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
Улаз се генерише тако да је могуће прерасподелити пакете јабука у кутије.

Дат вам је низ apple величине n и низ capacity величине m. Постоји n пакета где i-ти пакет садржи apple[i] јабуке. Постоји и m кутија, и i-та кутија има капацитет capacity[i] јабука. Вратите минималан број кутија које треба да изаберете како бисте прераспоредили ових n пакета јабука у кутије. Запамтите да јабуке из истог пакета могу бити распоређене у различите кутије.

Пример 1:

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

Пример 2:

Улаз: apple = [5,5,5], capacity = [2,4,2,7]
Излаз: 4
Објашњење: Биће потребно користити све кутије.

Ограничења:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
Улаз је генерисан тако да је могуће прераспоредити пакете јабука у кутије.

Дат вам је низ јабуке величине n и низ capacity величине m.
Постоји n паковања где i-то паковање садржи apple[i] јабука. Постоји m кутија, а i-та кутија има капацитет capacity[i] јабука.
Вратите минималан број кутија који треба да изаберете да бисте перерасподелили ова n паковања јабука у кутије.
Напомена: Јабуке из истог паковања могу се расподелити у различите кутије.

Пример 1:

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

Пример 2:

Унос: apple = [5,5,5], capacity = [2,4,2,7]
Излаз: 4
Објашњење: Биће потребно користити све кутије.

Ограничења:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
Улаз је генерисан тако да је могуће прераспоредити пакете јабука у кутије.


Дат вам је низ срећа дужине n и позитиван цео број k.
Постоји n деце која стоје у реду, где i-то дете има вредност среће happiness[i]. Желите да изаберете k деце од ових n деце у k потеза.
У сваком потезу, када изаберете дете, вредност среће све деце која још нису изабрана смањује се за 1. Имајте на уму да вредност среће не може постати негативна и смањује се само ако је позитивна.
Вратите максималан збир вредности среће изабране деце који можете постићи избором k деце.

Пример 1:

Улаз: happiness = [1,2,3], k = 2
Излаз: 4
Објашњење: Можемо изабрати 2 детета на следећи начин:
- Изаберите дете са вредношћу среће == 3. Вредност среће преостале деце постаје [0,1].
- Изаберите дете са вредношћу среће == 1. Вредност среће преостале деце постаје [0]. Имајте на уму да вредност среће не може постати мања од 0.
Збир вредности среће изабране деце је 3 + 1 = 4.

Пример 2:

Улаз: happiness = [1,1,1,1], k = 2
Излаз: 1
Објашњење: Можемо изабрати 2 детета на следећи начин:
- Изаберите било које дете са вредношћу среће == 1. Вредност среће преостале деце постаје [0,0,0].
- Изаберите дете са вредношћу среће == 0. Вредност среће преостале деце постаје [0,0].
Збир вредности среће изабране деце је 1 + 0 = 1.

Пример 3:

Улаз: happiness = [2,3,4,5], k = 1
Излаз: 5
Објашњење: Можемо изабрати 1 дете на следећи начин:
- Изаберите дете са вредношћу среће == 5. Вредност среће преостале деце постаје [1,2,3].
Збир вредности среће изабране деце је 5.

Ограничења:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n

Добили сте низу, срећу дужине n и позитиван цели број к.
У реду на чекању се налазе, где i-то дете има срећу среће[i]. Желите да одаберете к деце из ових н деце у к корака.
На сваком кораку, када одаберете дете, вредност среће свих деце која нису одабрана до сада смањује се за 1. Имајте на уму да вредност среће не може постати негативна и само се смањи само ако је то позитивно.
Вратите максималну суму вредности среће изабране деце коју можете постићи одабиром К деце.

Пример 1:

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

Пример 2:

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

Пример 3:

Улаз: happiness = [2,3,4,5], k = 1
Излаз: 5
Објашњење: Можемо изабрати 1 дете на следећи начин:
- Изаберите дете са вредношћу среће == 5. вредност среће преостале деце постаје [1,2,3].
Збир вредности среће одабране деце је 5.

Ограничења:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n

Дат вам је низ happiness дужине n и позитиван цели број k.
Постоји n деце која стоје у реду, где i-то дете има вредност среће happiness[i]. Желите да изаберете k деце од ових n деце у k кругова.
У сваком кругу, када изаберете дете, вредност среће све деце која још нису изабрана смањује се за 1. Имајте на уму да вредност среће не може постати негативна и смањује се само ако је позитивна.
Вратите максимални збир вредности среће изабране деце који можете постићи одабиром k деце.

Пример 1:

Улаз: happiness = [1,2,3], k = 2
Излаз: 4
Објашњење: Можемо изабрати 2 детета на следећи начин:
- Изаберите дете са вредношћу среће == 3. Вредност среће преостале деце постаје [0,1].
- Изаберите дете са вредношћу среће == 1. Вредност среће преостале деце постаје [0]. Имајте на уму да вредност среће не може постати мања од 0.
Збир вредности среће изабране деце је 3 + 1 = 4.

Пример 2:

Улаз: happiness = [1,1,1,1], k = 2
Излаз: 1
Објашњење: Можемо изабрати 2 детета на следећи начин:
- Изаберите било које дете са вредношћу среће == 1. Вредност среће преостале деце постаје [0,0,0].
- Изаберите дете са вредношћу среће == 0. Вредност среће преостале деце постаје [0,0].
Збир вредности среће изабране деце је 1 + 0 = 1.

Пример 3:

Улаз: happiness = [2,3,4,5], k = 1
Излаз: 5
Објашњење: Можемо изабрати 1 дете на следећи начин:
- Изаберите дете са вредношћу среће == 5. Вредност среће преостале деце постаје [1,2,3].
Збир вредности среће изабране деце је 5.

Ограничења:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n


Дат вам је низ arr величине n који се састоји од непразних низова.
Пронађите низ answer величине n тако да:

- answer[i] буде најкраћи подниз arr[i] који се не јавља као подниз у било којем другом низу у arr. Ако постоје више таквих подниза, answer[i] треба да буде лексикографски најмањи. Ако не постоји такав подниз, answer[i] треба да буде празан низ.

Вратите низ answer.

Пример 1:

Улаз: `arr = ["cab","ad","bad","c"]`
Излаз: `["ab","","ba",""]`
Објашњење: Имамо следеће:
- За стринг "cab", најкраћи подниз који се не појављује у било ком другом стрингу је или "ca" или "ab", бирамо лексикографски мањи подниз, што је "ab".
- За стринг "ad", не постоји подниз који се не појављује у било ком другом стрингу.
- За стринг "bad", најкраћи подниз који се не појављује у било ком другом стрингу је "ba".
- За стринг "c", не постоји подниз који се не појављује у било ком другом стрингу.

Пример 2:

Улаз: `arr = ["abc","bcd","abcd"]`
Излаз: `["","","abcd"]`
Објашњење: Имамо следеће:
- За стринг "abc", не постоји подниз који се не појављује у било ком другом стрингу.
- За стринг "bcd", не постоји подниз који се не појављује у било ком другом стрингу.
- За стринг "abcd", најкраћи подниз који се не појављује у било ком другом стрингу је "abcd".

Ограничења:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] се састоји само од малих слова енглеске азбуке.

Дат вам је низ арр величине н који се састоји од непразних стрингова.
Пронађите одговор низа стрингова величине н тако да:

answer[i] је најкраћи подниз arr[i] који се не појављује као подниз у било ком другом стрингу у arr, ако постоји више таквих поднизова, answer[i] треба бити лексикографски најмањи. Ако не постоји такав подниз, answer[i] треба бити празан стринг.

Врати одговор низа.

Пример 1:

Улаз: аrr = ["cab","ad","bad","c"]
Излаз: ["ab","","ba",""]
Објашњење: Имамо следеће:
-За стринг "cab", најкраћи подниз који се не појављује у било ком другом стрингу је или "ca" или "ab", бирамо лексикографски мањи подниз, што је "ab".
-За стринг "ad", не постоји подниз који се не појављује у било ком другом стрингу.
-За стринг "bad", најкраћи подниз који се не појављује у било ком другом стрингу је "ba".
-За стринг "c", не постоји подниз који се не појављује у било ком другом стрингу.

Пример 2:

Улаз: arr = ["abc","bcd","abcd"]
Излаз: ["","","abcd"]
Објашњење: Имамо следеће:
- За стринг "abc", не постоји подниз који се не појављује ни у једном другом низу.
- За стринг "bcd", не постоји подниз који се не појављује ни у једном другом низу.
- За стринг "abcd", најкраћи подниз који се не појављује ни у једном другом низу је "abcd".

Ограничења:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] се састоји само од малих енглеских слова.

Дата вам је низ `arr` величине `n` који се састоји од ненула стрингова.
Пронађите стринг низ `answer` величине `n` такав да:

`answer[i]` је најкраћи подниз `arr[i]` који се не појављује као подниз у било ком другом стрингу у `arr`, ако постоји више таквих поднизова, `answer[i]` треба бити лексикографски најмањи. Ако не постоји такав подниз, `answer[i]` треба бити празан стринг.

Вратити низ answer.

Пример 1:

Улаз: arr = ["cab","ad","bad","c"]
Излаз: ["ab","","ba",""]
Објашњење: Имамо следеће:
- За стринг "cab", најкраћи подниз који се не појављује у било ком другом стрингу је или "ca" или "ab", бирамо лексикографски мањи подниз, што је "ab".
- За стринг "ad", не постоји подниз који се не појављује у било ком другом стрингу.
- За стринг "bad", најкраћи подниз који се не појављује у било ком другом стрингу је "ba".
- За стринг "c", не постоји подниз који се не појављује у било ком другом стрингу.

Пример 2:

Улаз: `arr = ["abc","bcd","abcd"]`
Излаз: `["","","abcd"]`
Објашњење: Имамо следеће:
- За стринг "abc", не постоји подниз који се не појављује у било ком другом стрингу.
- За стринг "bcd", не постоји подниз који се не појављује у било ком другом стрингу.
- За стринг "abcd", најкраћи подниз који се не појављује у било ком другом стрингу је "abcd".

Ограничења:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] се састоји само од малих слова енглеске абецеде.


Дат вам је низ целих бројева nums дужине n и позитиван непаран број k.
Снага x подниза дефинисана је као:
снага = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1, где је sum[i] збир елемената у i-том подниз.
Тачније, снага је збир (-1)^i+1 * sum[i] * (x - i + 1) за све i тако да важи 1 <= i <= x.

Потребно је да изаберете k непоклопљених подниза из низа nums, тако да њихова снага буде максимална.
Вратите максималну могућу снагу која се може добити.
Напомена: Изабрани поднизови не морају покривати цео низ.

Пример 1:

Унос: `nums = [1,2,3,-1,2]`, `k = 3`
Излаз: `22`
Објашњење: Најбољи могући начин за избор 3 под-низа је: `nums[0..2]`, `nums[3..3]`, и `nums[4..4]`. Снага је `(1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22`.

Пример 2:

Унос: `nums = [12,-2,-2,-2,-2]`, `k = 5`
Излаз: `64`
Објашњење: Једини могући начин за избор 5 неповезаних под-низова је: `nums[0..0]`, `nums[1..1]`, `nums[2..2]`, `nums[3..3]`, и `nums[4..4]`. Снага је `12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64`.

Пример 3:

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

Ограничења:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k је непаран.

Дат вам је низ целих бројева nums са индексима почевши од 0 и дужине n, и позитиван непаран цео број k.
Снага од x под-арраи је дефинисана као strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1 где је sum[i] збир елемената у i-тој под-низу. Формално,strength је збир (-1)^i+1 * sum[i] * (x - i + 1) за сва i тако да је 1 <= i <= x.
Потребно је да изаберете k неповезаних под-низова из nums, тако да је њихова снага максимална.
Вратите максималну могућу снагу која се може добити.
Напомена: изабрани под-низови не морају покривати цео низ.

Пример 1:

Улаз: nums = [1,2,3,-1,2], k = 3
Излаз: 22
Објашњење: Најбољи могући начин за избор 3 под-низа је: nums[0..2], nums[3..3], и nums[4..4]. Strength је (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Пример 2:

Улаз: nums = [12,-2,-2,-2,-2], k = 5
Излаз: 64
Објашњење: Једини могући начин за избор 5 неповезаних под-низова је:  nums[0..2], nums[3..3], и nums[4..4]. Strength је 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Пример 3:

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

Ограничења:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k је непаран.

Добијате 0-индексирани низ целих бројева дужине н, и позитиван непаран цео број к.
Снага од x под-арраи је дефинисана као снага = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1 где је sum[i] збир елемената у i-тој под-низу. Формално, снага је збир (-1)^i+1 * sum[i] * (x - i + 1) за сва i тако да је 1 <= i <= x.
Потребно је да изаберете к дисјунктне поднизове из бројева, тако да је њихова снага максимална.
Вратите максималну могућу снагу која се може добити.
Имајте на уму да изабрани поднизови не морају да покривају цео низ.

Пример 1:

Улаз : nums = [1,2,3,-1,2], к = 3
излаз : 22
Објашњење: Најбољи могући начин да изаберете 3 подниза је: nums [0..2], nums [3..3] и nums [4..4]. Снага је (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Пример 2:

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

Пример 3:

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

Ограничења:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
к је чудно.


Дат је низ s, пронађите било који подниз дужине 2 који се такође налази у обрнутом низу s.
Вратите true ако такав подниз постоји, у супротном вратите false.

Пример 1:

Улаз: s = "leetcode"
Излаз: true
Објашњење: Подниз "ee" је дужине 2 који је такође присутан у reverse(s) == "edocteel".

Пример 2:

Улаз: s = "abcba"
Излаз: true
Објашњење: Сви поднизови дужине 2 "ab", "bc", "cb", "ba" су такође присутни у reverse(s) == "abcba".

Пример 3:

Улаз: s = "abcd"
Излаз: false
Објашњење: Не постоји подниз дужине 2 у s, који је такође присутан у обрнутом низу s.

Ограничења:

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

С обзиром на низ s, пронађи било који подниз дужине 2 који је такође присутан у обрнутом делу s.
Врати true ако такав подниз постоји, и false у супротном.

Пример 1:

Улаз : s = "leetcode
Излаз : true
Објашњење : Субстринг "ее" је дужине 2 који је такође присутан у reverse(s) == "edocteel".

Пример 2:

Улаз : s = "abcba"
Излаз : true
Објашњење : Сви поднизови дужине 2 "ab", "bc", "cb", "ba" су такође присутни у reverse(s) == "abcba".

Пример 3:

Улаз : s = "abcd"
Излаз : false
Објашњење : Не постоји подниз дужине 2 у s, који је такође присутан у обрнутом од s.

Ограничења:

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

Дат је низ s, пронађи било који подниз дужине 2 који је такође присутан у обрнутом низу s.
Врати true ако такав подниз постоји, и false у супротном.

Пример 1:

Улаз: s = "leetcode"
Излаз: true
Објашњење: Подниз "ee" је дужине 2 који је такође присутан у reverse(s) == "edocteel".

Пример 2:

Улаз: s = "abcba"
Излаз: true
Објашњење: Сви поднизови дужине 2 "ab", "bc", "cb", "ba" су такође присутни у reverse(s) == "abcba".

Пример 3:

Улаз: s = "abcd"
Излаз: false
Објашњење: Не постоји подниз дужине 2 у s, који је такође присутан у обрнутом низу s.

Ограничења:

1 <= s.length <= 100
\( s \) се састоји само од малих енглеских слова.


Дат је стринг s и карактер c. Вратите укупан број подстрингова од s који почињу и завршавају се са c.

Пример 1:

Улаз: s = "abada", c = "a"
Излаз: 6
Објашњење: Подстрингови који почињу и завршавају се са "a" су: "abada", "abada", "abada", "abada", "abada", "abada".

Пример 2:

Улаз: s = "zzz", c = "z"
Излаз: 6
Објашњење: Укупно има 6 подстрингова у s и сви почињу и завршавају се са "z".

Ограничења:

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

Дајете вам низ s и лик c. Вратите укупан број поднизови с који се започне и завршава са c.

Пример 1:

Улаз: s = "abada", c = "a"
Излаз: 6
Објашњење: Подземље које почињу и завршавају са "a" су: "abada", "abada", "abada", "abada", "abada", "abada".

Пример 2:

Улаз: s = "zzz", c = "z"
Излаз: 6
Објашњење: У s свега је укупно 6 поднизови и сви почетак и завршава са "z".

Ограничења:

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

Дат је стринг s и карактер c. Врати укупан број подстрингова од s који почињу и завршавају се са c.

Пример 1:

Улаз:s = "abada", c = "a"
Излаз: 6
Објашњење: Подстрингови који почињу и завршавају се са "a" су: "abada", "abada", "abada", "abada", "abada", "abada".

Пример 2:

Улаз: s = "zzz", c = "z"
Излаз: 6
Објашњење: Укупно има 6 подстрингова у s и сви почињу и завршавају се са "z".

Ограничења:

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


Dobija se string `word` i ceo broj `k`.
Smatramo da je string `word` \(k\)-poseban ako za sve indekse \(i\) i \(j\) u stringu važi:
\(|\text{freq}(\text{word}[i]) - \text{freq}(\text{word}[j])| \leq k\).

Ovde, \(\text{freq}(x)\) označava učestalost karaktera \(x\) u stringu `word`, a \(|y|\) apsolutnu vrednost broja \(y\).
Povratna vrednost treba da bude minimalan broj karaktera koje je potrebno obrisati kako bi `word` postao \(k\)-poseban.

Primer 1:

Ulaz: `word = "aabcaba"`, `k = 0`
Izlaz: 3
Objašnjenje: `word` možemo učiniti \(0\)-posebnim brisanjem 2 pojavljivanja karaktera `"a"` i 1 pojavljivanja karaktera `"c"`.
Rezultujući string postaje `"baba"` gde važi \(\text{freq}('a') = \text{freq}('b') = 2\).

Primer 2:

Ulaz: `word = "dabdcbdcdcd"`, `k = 2`
Izlaz: 2
Objašnjenje: `word` možemo učiniti \(2\)-posebnim brisanjem 1 pojavljivanja karaktera `"a"` i 1 pojavljivanja karaktera `"d"`.
Rezultujući string postaje `"bdcbdcdcd"` gde važi \(\text{freq}('b') = 2\), \(\text{freq}('c') = 3\), i \(\text{freq}('d') = 4\).

Primer 3

Ulaz: `word = "aaabaaa"`, `k = 2`
Izlaz: 1
Objašnjenje: `word` možemo učiniti \(2\)-posebnim brisanjem 1 pojavljivanja karaktera `"b"`.
Rezultujući string postaje `"aaaaaa"` gde učestalost svakog karaktera sada iznosi \(6\).

Ograničenja:

\(1 \leq \text{word.length} \leq 10^5\)
\(0 \leq k \leq 10^5\)
`word` se sastoji isključivo od malih slova engleske abecede.

Дат је низ речи и целобројни k.
Сматрамо да је реч k-специјална ако важи |freq(word[i]) - freq(word[j])| <= k за све индексе i и j у низу.
Овде, freq(x) означава фреквенцију карактера x у речи, а |y| означава апсолутну вредност y.
Вратите минималан број карактера које треба обрисати да би реч постала k-специјална.

Пример 1:

Ulaz: word = "aabcaba", k = 0
Izlaz: 3
Objašnjenje: Реч можемо учинити 0-специјалном брисањем 2 појаве "a" и 1 појаве "c". Стога, реч постаје једнака "baba" где је freq('a') == freq('b') == 2.

Пример 2:

Ulaz: word = "dabdcbdcdcd", k = 2
Izlaz: 2
Objašnjenje: Реч можемо учинити 2-специјалном брисањем 1 појаве "a" и 1 појаве "d". Стога, реч постаје једнака "bdcbdcdcd" где је freq('b') == 2, freq('c') == 3, и freq('d') == 4.

Пример 3:

Ulaz: word = "aaabaaa", k = 2
Izlaz: 1
Objašnjenje: Реч можемо учинити 2-специјалном брисањем 1 појаве "b". Стога, реч постаје једнака "aaaaaa" где је учесталост сваког слова сада равномерно 6.

Ограничења:

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

Дат вам је низ слова word и цео број k.
Сматрамо да је низ word k-специјалан ако је |freq(word[i]) - freq(word[j])| <= k за све индексе i и j у низу.
Ту, freq(x) означава учесталост карактера x у низу word, а |y| означава апсолутну вредност y.
Вратите минималан број карактера који треба да избришете како би низ word био k-специјалан.

Пример 1:

Улаз: word = "aabcaba", k = 0
Излаз: 3
Објашњењe: Реч можемо учинити 0-специјалном брисањем 2 појаве "a" и 1 појаве "c". Стога, реч постаје једнака "baba" где је freq('a') == freq('b') == 2.

Пример 2:

Улаз: word = "dabdcbdcdcd", k = 2
Излаз: 2
Објашњење: Реч можемо учинити 2-специјалном брисањем 1 појаве "a" и 1 појаве "d". Стога, реч постаје једнака "bdcbdcdcd" где је freq('b') == 2, freq('c') == 3, и freq('d') == 4.

Пример 3:

Улаз: word = "aaabaaa", k = 2
Излаз: 1
Објашњење: Реч можемо учинити 2-специјалном брисањем 1 појаве "b". Стога, реч постаје једнака "aaaaaa" где је учесталост сваког слова сада равномерно 6.

Ограничења:

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


Дат вам је бинарни низ `nums` дужине `n`, позитиван цео број `k` и ненегативан цео број `maxChanges`.
Алица игра игру, где је циљ да Алица покупи `k` јединица из `nums` користећи минималан број потеза. Када игра почиње, Алица бира било који индекс `aliceIndex` у опсегу `[0, n - 1]` и стоји тамо. Ако је `nums[aliceIndex] == 1`, Алица покупи јединицу и `nums[aliceIndex]` постаје 0 (ово се не рачуна као потез). Након тога, Алица може направити било који број потеза (укључујући нула потеза) где у сваком потезу Алица мора да изврши тачно једну од следећих акција:

Изабери било који индекс `j != aliceIndex` такав да је `nums[j] == 0` и постави `nums[j] = 1`. Ова акција се може извршити највише `maxChanges` пута.
Изабери било која два суседна индекса `x` и `y` (|x - y| == 1) таква да је `nums[x] == 1`, `nums[y] == 0`, онда замени њихове вредности (постави `nums[y] = 1` и `nums[x] = 0`). Ако је `y == aliceIndex`, Алица покупи јединицу након овог потеза и `nums[y]` постаје 0.

Врати минимум броја потеза потребних да би Алица покупила тачно `k` јединица.

Пример 1:

Улаз: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Излаз: 3
Објашњење: Алица може покупити 3 јединице у 3 потеза, ако Алица изведе следеће акције у сваком потезу када је на `aliceIndex == 1`:

На почетку игре Алица покупи јединицу и `nums[1]` постаје 0. `nums` постаје [1,1,1,0,0,1,1,0,0,1].
Изабери `j == 2` и изврши акцију првог типа. `nums` постаје [1,0,1,0,0,1,1,0,0,1].
Изабери `x == 2` и `y == 1`, и изврши акцију другог типа. `nums` постаје [1,1,0,0,0,1,1,0,0,1]. Пошто је `y == aliceIndex`, Алица покупи јединицу и `nums` постаје [1,0,0,0,0,1,1,0,0,1].
Изабери `x == 0` и `y == 1`, и изврши акцију другог типа. `nums` постаје [0,1,0,0,0,1,1,0,0,1]. Пошто је `y == aliceIndex`, Алица покупи јединицу и `nums` постаје [0,0,0,0,0,1,1,0,0,1].

Напомена да је могуће да Алица покупи 3 јединице користећи неки други редослед од 3 потеза.

Пример 2:

Улаз: nums = [0,0,0,0], k = 2, maxChanges = 3
Излаз: 4
Објашњење: Алица може покупити 2 јединице у 4 потеза, ако Алица изведе следеће акције у сваком потезу када је на `aliceIndex == 0`:

Изабери `j == 1` и изврши акцију првог типа. `nums` постаје [0,1,0,0].
Изабери `x == 1` и `y == 0`, и изврши акцију другог типа. `nums` постаје [1,0,0,0]. Пошто је `y == aliceIndex`, Алица покупи јединицу и `nums` постаје [0,0,0,0].
Изабери `j == 1` поново и изврши акцију првог типа. `nums` постаје [0,1,0,0].
Изабери `x == 1` и `y == 0` поново и изврши акцију другог типа. `nums` постаје [1,0,0,0]. Пошто је `y == aliceIndex`, Алица покупи јединицу и `nums` постаје [0,0,0,0].

Ограничења:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

Дат вам је бинарни низ бројева дужине n, позитиван цео број к и ненегативан цео број максЧанжес.
Алиса игра игру у којој је циљ да Алиса покупи к јединица од бројева користећи минимални број потеза. Када игра почне, Алиса узима било који индекс алицеИндек у опсегу[0, n - 1] и стоји тамо. Ако је nums[алицеИндек] == 1 , Алиса преузима јединицу и nums[алицеИндек] постаје 0 (ово се не рачуна као потез). Након овога, Алиса може да направи било који број потеза (укључујући нулу) при чему у сваком потезу Алиса мора да изврши тачно једну од следећих радњи:

Изаберите било који индекс ј != алицеИндек тако да је nums[ј] == 0 и поставите nums[ј] = 1. Ова радња се може извршити највише пута максЧанжес.
Изаберите било која два суседна индекса к и и (|x - y| == 1)  тако да су nums[x] == 1, nums[y] == 0, а затим замените њихове вредности (поставите nums[y] = 1 и nums [x] = 0). Ако је y == aliceIndex, Алиса преузима онај после овог потеза и nums[y] постаје 0.

Врати минимални број потеза који је Алиса потребан да изабере тачно к.

Пример 1:

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

 На почетку игре Алиса подиже јединицу и nums[1] постаје 0. nums постаје [1,1,1,0,0,1,1,0,0,1].
Изаберите ј == 2 и извршите акцију првог типа. бројеви постају [1,0,1,0,0,1,1,0,0,1]
Изаберите к == 2 и и == 1 и извршите радњу другог типа. nums постаје [1,1,0,0,0,1,1,0,0,1]. Како је y == aliceIndex, Алиса преузима јединицу и nums постају [1,0,0,0,0,1,1,0,0,1].
Изаберите к == 0 и и == 1 и извршите радњу другог типа. nums постаје [0,1,0,0,0,1,1,0,0,1]. Како је y == aliceIndex, Алиса преузима јединицу и nums постају [0,0,0,0,0,1,1,0,0,1].

Имајте на уму да је можда могуће да Алиса покупи 3 потеза користећи неки други низ од 3 потеза.

Пример 2:

Улаз: nums = [0,0,0,0], k = 2, maxChanges = 3
Излаз: 4
Објашњење: Алиса може покупити 2 у 4 потеза, ако Алиса изврши следеће радње у сваком потезу када стоји на алицеИндек == 0:

Изаберите ј == 1 и извршите акцију првог типа. nums постаје [0,1,0,0].
Изаберите к == 1 и и == 0 и извршите радњу другог типа. nums постаје [1,0,0,0]. Како је y == aliceIndex, Алиса преузима јединицу и бројеви постају [0,0,0,0].
Изаберите ј == 1 и извршите акцију првог типа. nums постаје [0,1,0,0].
ИзаберитеАлиса игра игру у којој је циљ да купи к јединица из низа бројева користећи минимални број потеза к == 1 и и == 0 и извршите радњу другог типа. nums постаје [1,0,0,0]. Како је y == aliceIndex, Алиса преузима јединицу и бројеви постају [0,0,0,0].

Ограничења:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k

Дат вам је бинарни низ nums дужине n, позитиван цео број k и ненегативан цео број maxChanges.
Алица игра игру, где је циљ да Алица покупи k јединица из nums користећи минималан број потеза. Када игра почиње, Алица бира било који индекс aliceIndex у опсегу [0, n - 1] и стоји тамо. Ако је nums[aliceIndex] == 1, Алица покупи јединицу и nums[aliceIndex] постаје 0 (ово се не рачуна као потез). Након тога, Алица може направити било који број потеза (укључујући нула потеза) где у сваком потезу Алица мора да изврши тачно једну од следећих акција:

Изабери било који индекс j != aliceIndex такав да је nums[j] == 0 и постави nums[j] = 1. Ова акција се може извршити највише maxChanges пута.
Изабери било која два суседна индекса x и y (|x - y| == 1) таква да је nums[x] == 1, nums[y] == 0, онда замени њихове вредности (постави nums[y] = 1 и nums[x] = 0). Ако је y == aliceIndex, Алица покупи јединицу након овог потеза и nums[y]` постаје 0.

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

Пример 1:

Улаз: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Излаз: 3
Објашњење: Алица може покупити 3 јединице у 3 потеза, ако Алица изведе следеће акције у сваком потезу када је на `aliceIndex == 1`:

На почетку игре Алица покупи јединицу и nums[1] постаје 0. nums постаје [1,1,1,0,0,1,1,0,0,1].
Изаберите j == 2 и изврши акцију првог типа. nums постаје [1,0,1,0,0,1,1,0,0,1].
Изаберите x == 2 и y == 1, и изврши акцију другог типа. nums постаје [1,1,0,0,0,1,1,0,0,1]. Пошто је y == aliceIndex, Алица покупи јединицу и nums постаје [1,0,0,0,0,1,1,0,0,1].
Изабери x == 0 и y == 1, и изврши акцију другог типа. nums постаје [0,1,0,0,0,1,1,0,0,1]. Пошто је y == aliceIndex, Алица покупи јединицу и nums постаје [0,0,0,0,0,1,1,0,0,1].

Напомена да је могуће да Алица покупи 3 јединице користећи неки други редослед од 3 потеза.

Пример 2:

Улаз: nums = [0,0,0,0], k = 2, maxChanges = 3
Излаз: 4
Објашњење: Алиса може да покупи 2 јединице у 4 потеза, ако Алиса изврши следеће акције у сваком потезу када се налази на aliceIndex == 0:

Изаберите j == 1  и изврши акцију првог типа. nums постаје [0,1,0,0].
Изаберите x == 1  и y == 0, и изврши акцију другог типа. nums постаје [1,0,0,0]. Пошто је y == aliceIndex, Алица покупи јединицу и nums постаје [0,0,0,0].
Изаберите  j == 1 поново и изврши акцију првог типа. nums постаје [0,1,0,0].
Изаберите x == 1 и y == 0 поново и извршите акцију другог типа. nums постаје [1,0,0,0]. Пошто је y == aliceIndex, Алица покупи јединицу и nums постаје [0,0,0,0].

Ограничења:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k


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

Пример 1:

Улаз: s = "bcbbbcba"
Излаз: 4
Објашњење:
Следећи подстринг има дужину од 4 и садржи највише два појављивања сваког карактера: "bcbbbcba".
Пример 2:

Улаз: s = "aaaa"
Излаз: 2
Објашњење:
Следећи подстринг има дужину од 2 и садржи највише два појављивања сваког карактера: "aaaa".

Ограничења:

2 <= s.length <= 100
s се састоји само од малих слова енглеске азбуке.

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

Пример 1:

Улаз : s = "bcbbbcba"
излаз : 4
Објашњење:
Следећи подстринг има дужину 4 и садржи највише два појављивања сваког знака: "bcbbbcba".
Пример 2:

Улаз : s = "aaaa"
излаз : 2
Објашњење:
Следећи подстринг има дужину од 2 и садржи највише два појављивања сваког знака: "аааа".

Ограничења:

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

Serbian:
Data je string s, vratite maksimalnu dužinu podstringa tako da on sadrži najviše dva pojavljivanja svakog karaktera.

Primer 1:

Ulaz:s = "bcbbbcba"
Izlaz: 4
Objašnjenje:
Sledeći podstring ima dužinu 4 i sadrži najviše dva pojavljivanja svakog karaktera: "bcbbbcba".

Primer 2:

Ulaz: s = "aaaa"
Izlaz: 2
Objašnjenje:
Sledeći podstring ima dužinu 2 i sadrži najviše dva pojavljivanja svakog karaktera: "aaaa".

Ograničenja:

2 <= s.length <= 100
s se sastoji samo od malih engleskih slova.


Дат је позитиван цео број k. На почетку, имате низ nums = [1].
Можете извршити било коју од следећих операција на низу било који број пута (могуће нула):

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

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

Пример 1:

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

Повећајте елемент за 1 три пута. Резултујући низ је nums = [4].
Дуплирајте елемент два пута. Резултујући низ је nums = [4,4,4].

Збир коначног низа је 4 + 4 + 4 = 12 што је веће или једнако k = 11.
Укупан број извршених операција је 3 + 2 = 5.

Пример 2:

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

Ограничења:

1 <= k <= 10^5

Дат вам је позитиван цео број k. У почетку имате низ nums = [1].
Можете извршити било коју од следећих операција на низу било који број пута (могуће и нула пута):

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

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

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

Увећати елемент за 1 три пута. Резултујући низ је nums = [4].
Дуплицирати елемент два пута. Резултујући низ је nums = [4,4,4].

Збир коначног низа је 4 + 4 + 4 = 12 што је веће или једнако k = 11.
Укупан број извршених операција је 3 + 2 = 5.

Пример 2:

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

Ограничења:

1 <= k <= 10^5

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

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

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

Пример 1:

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

Повећајте елемент за 1 три пута. Добијени низ је nums = [4].
Дуплирајте елемент два пута. Добијени низ је nums = [4,4,4].

Збир коначног низа је 4 + 4 + 4 = 12 што је веће или једнако к = 11.
Укупан број извршених операција је 3 + 2 = 5.

Пример 2:

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

Ограничења:

1 <= k <= 10^5


Проблем обухвата праћење учесталости ID-ева у колекцији која се мења током времена. Имате два низа целих бројева, nums и freq, једнаке дужине n. Сваки елемент у nums представља ID, а одговарајући елемент у freq указује колико пута тај ID треба додати или уклонити из колекције на сваком кораку.

Додавање ID-ева: Ако је freq[i] позитиван, то значи да се freq[i] ID-ева са вредношћу nums[i] додају у колекцију на кораку i.
Уклањање ID-ева: Ако је freq[i] негативан, то значи да се -freq[i] ID-ева са вредношћу nums[i] уклањају из колекције на кораку i.

Вратите низ ans дужине n, где ans[i] представља број најчешћег ID-а у колекцији након i-тог корака. Ако је колекција празна на било ком кораку, ans[i] треба да буде 0 за тај корак.

Пример 1:

Унос: nums = [2,3,2,1], freq = [3,2,-3,1]
Излаз: [3,3,2,2]
Објашњење:
Након корака 0, имамо 3 ID-а са вредношћу 2. Тако да је ans[0] = 3.
Након корака 1, имамо 3 ID-а са вредношћу 2 и 2 ID-а са вредношћу 3. Тако да је ans[1] = 3.
Након корака 2, имамо 2 ID-а са вредношћу 3. Тако да је ans[2] = 2.
Након корака 3, имамо 2 ID-а са вредношћу 3 и 1 ID са вредношћу 1. Тако да је ans[3] = 2.

Пример 2:

Унос: nums = [5,5,3], freq = [2,-2,1]
Излаз: [2,0,1]
Објашњење:
Након корака 0, имамо 2 ID-а са вредношћу 5. Тако да је ans[0] = 2.
Након корака 1, нема ID-ева. Тако да је ans[1] = 0.
Након корака 2, имамо 1 ID са вредношћу 3. Тако да је ans[2] = 1.

Ограничења:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Унос је генерисан тако да појављивања ID-а неће бити негативна ни на једном кораку.

Проблем обухвата праћење учесталости ID-ева у колекцији која се мења током времена. Имате два низа целих бројева, nums и freq, једнаке дужине n. Сваки елемент у nums представља ID, а одговарајући елемент у freq указује колико пута тај ID треба додати или уклонити из колекције на сваком кораку.

Додавање ID-ева: Ако је freq[i] позитиван, то значи да се freq[i] ID-ева са вредношћу nums[i] додају у колекцију на кораку i.
Уклањање ID-ева: Ако је freq[i] негативан, то значи да се -freq[i] ID-ева са вредношћу nums[i] уклањају из колекције на кораку i.

Вратите низ ans дужине n, где ans[i] представља број најчешћег ID-а у колекцији након i-тог корака. Ако је колекција празна на било ком кораку, ans[i] треба да буде 0 за тај корак.

Пример 1:

Улаз: nums = [2,3,2,1], freq = [3,2,-3,1]
Излаз: [3,3,2,2]
Објашњење:
Након корака 0, имамо 3 ID-а са вредношћу 2. Тако да је ans[0] = 3.
Након корака 1, имамо 3 ID-а са вредношћу 2 и 2 ID-а са вредношћу 3. Тако да је ans[1] = 3.
Након корака 2, имамо 2 ID-а са вредношћу 3. Тако да је ans[2] = 2.
Након корака 3, имамо 2 ID-а са вредношћу 3 и 1 ID са вредношћу 1. Тако да је ans[3] = 2.

Пример 2:

Улаз: nums = [5,5,3], freq = [2,-2,1]
Излаз: [2,0,1]
Објашњење:
Након корака 0, имамо 2 ID-а са вредношћу 5. Тако да је ans[0] = 2.
Након корака 1, нема ID-ева. Тако да је ans[1] = 0.
Након корака 2, имамо 1 ID са вредношћу 3. Тако да је ans[2] = 1.

Ограничења:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Улаз је генерисан тако да појављивања ID-а неће бити негативна ни на једном кораку.

Проблем укључује праћење учесталости IDs у колекцији која се мења током времена. Имате два низа целих бројева, nums и freq, једнаке дужине n. Сваки елемент у nums представља ID, а одговарајући елемент у freq показује колико пута тај ID треба додати или уклонити из колекције у сваком кораку.

Додавање IDs: Ако је freq[i] позитиван, то значи да се IDs freq[i] са вредношћу nums[i] додају колекцији у кораку i.
Уклањање IDs: Ако је freq[i] негативан, то значи да су IDs -freq[i] са вредношћу nums[i] уклоњени из колекције у кораку i.

Врати низ анс дужине n, где ans[i] представља број најчешћих ID у колекцији после i^th корака. Ако је колекција празна у било ком кораку, ans[i] би требало да буде 0 за тај корак.

Пример 1:

Улаз: nums = [2,3,2,1], freq = [3,2,-3,1]
Излаз: [3,3,2,2]
Објашњење:
После корака 0, имамо 3 IDs са вредношћу 2. Дакле, ans[0] = 3.
После корака 1, имамо 3 IDs са вредношћу 2 и 2 IDs са вредношћу 3. Дакле, ans[1] = 3.
После корака 2, имамо 2 IDs са вредношћу 3. Дакле, ans[2] = 2.
После корака 3, имамо 2 IDs са вредношћу 3 и 1 ID са вредношћу 1. Дакле, ans[3] = 2.

Пример 2:

Улаз: nums = [5,5,3], freq = [2,-2,1]
Излаз: [2,0,1]
Објашњење:
После корака 0, имамо 2 IDs са вредношћу 5. Дакле, ans[0] = 2.
Након корака 1, нема IDs. Дакле, ans[1] = 0.
После корака 2, имамо 1 ID са вредношћу 3. Дакле, ans[2] = 1.

Ограничења:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Улаз се генерише тако да појављивања ID неће бити негативна ни у једном кораку.


Дате су вам две низе стрингова wordsContainer и wordsQuery.
За сваки wordsQuery[i], потребно је пронаћи стринг из wordsContainer који има најдужи заједнички суфикс са wordsQuery[i]. Ако два или више стрингова из wordsContainer имају најдужи заједнички суфикс, пронађите стринг који је најкраћи по дужини. Ако постоје два или више таквих стрингова исте најкраће дужине, пронађите онај који се појављује раније у wordsContainer.
Вратите низ целих бројева ans, где је ans[i] индекс стринга у wordsContainer који има најдужи заједнички суфикс са wordsQuery[i].

Пример 1:

Унос: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Излаз: [1,1,1]
Објашњење:
Погледајмо сваки wordsQuery[i] појединачно:

За wordsQuery[0] = "cd", стрингови из wordsContainer који деле најдужи заједнички суфикс "cd" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 1 јер има најкраћу дужину од 3.
За wordsQuery[1] = "bcd", стрингови из wordsContainer који деле најдужи заједнички суфикс "bcd" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 1 јер има најкраћу дужину од 3.
За wordsQuery[2] = "xyz", нема стринга из wordsContainer који дели заједнички суфикс. Стога је најдужи заједнички суфикс "", који деле стрингови на индексу 0, 1 и 2. Међу њима, одговор је стринг на индексу 1 јер има најкраћу дужину од 3.

Пример 2:

Унос: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Излаз: [2,0,2]
Објашњење:
Погледајмо сваки wordsQuery[i] појединачно:

За wordsQuery[0] = "gh", стрингови из wordsContainer који деле најдужи заједнички суфикс "gh" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 2 јер има најкраћу дужину од 6.
За wordsQuery[1] = "acbfgh", само стринг на индексу 0 дели најдужи заједнички суфикс "fgh". Зато је он одговор, иако је стринг на индексу 2 краћи.
За wordsQuery[2] = "acbfegh", стрингови из wordsContainer који деле најдужи заједнички суфикс "gh" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 2 јер има најкраћу дужину од 6.

Ограничења:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] се састоји само од малих енглеских слова.
wordsQuery[i] се састоји само од малих енглеских слова.
Збир дужина wordsContainer[i] је највише 5 * 10^5.
Збир дужина wordsQuery[i] је највише 5 * 10^5.

да су вам дати два низова жица речиЦонтаинер и ВорксКуери.
За сваку wordsQuery[i], потребно је пронаћи низ карактера из wordsContainer који има најдужи заједнички суфикс са wordsQuery[i]. Ако постоје два или више стрингова у wordsContainer који деле најдужи заједнички суфикс, пронађите низ карактера који је најкраћи по дужини. Ако постоје два или више таквих стрингова који имају исту најмању дужину, пронађите онај који се раније појављује у wordsContainer.
Вратите низ целих бројева АнС, где је индекс низа у ВордЦонтаинер који има најдужи заједнички суфикс са ВордКуери [i].

Пример 1:

Улаз: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Излаз: [1,1,1]
Објашњење:
Погледајмо сваку ВордКуери [и] одвојено:

За wordsQuery[0] = "cd", стрингови из wordsContainer који деле најдужи заједнички суфикс "cd" су на индексима 0, 1 и 2. Међу њима, одговор је низ карактера на индексу 1 јер има најкраћу дужину од 3.
За wordsQuery[1] = "bcd", стрингови из wordsContainer који деле најдужи заједнички суфикс "bcd" су на индексима 0, 1 и 2. Међу њима, одговор је низ карактера на индексу 1 јер има најкраћу дужину од 3.
За wordsQuery[2] = "xyz", нема стринга из wordsContainer који дели заједнички суфикс. Стога је најдужи заједнички суфикс "", који деле стрингови на индексу 0, 1 и 2. Међу њима, одговор је низ карактера на индексу 1 јер има најкраћу дужину од 3.

Пример 2:

Улаз: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Излаз: [2,0,2]
Објашњење:
Погледајмо сваку ВордКуери [и] одвојено:

За wordsQuery[0] = "gh", стрингови из wordsContainer који деле најдужи заједнички суфикс "gh" су на индексима 0, 1 и 2. Међу њима, одговор је низ карактера на индексу 2 јер има најкраћу дужину од 6.
За wordsQuery[1] = "acbfgh", само низ карактера на индексу 0 дели најдужи заједнички суфикс "fgh". Зато је он одговор, иако је низ карактера на индексу 2 краћи.
За wordsQuery[2] = "acbfegh", стрингови из wordsContainer који деле најдужи заједнички суфикс "gh" су на индексима 0, 1 и 2. Међу њима, одговор је низ карактера на индексу 2 јер има најкраћу дужину од 6.

Ограничења:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] се састоји само од малих енглеских слова.
wordsQuery[i] се састоји само од малих енглеских слова.
Збир дужина wordsContainer[i] је највише 5 * 10^5.
Збир дужина wordsQuery[i] је највише 5 * 10^5.

Дате су вам две низе стрингова wordsContainer и wordsQuery.
За сваку wordsQuery[i], потребно је пронаћи стринг из wordsContainer који има најдужи заједнички суфикс са wordsQuery[i]. Ако постоје два или више стрингова у wordsContainer који деле најдужи заједнички суфикс, пронађите стринг који је најкраћи по дужини. Ако постоје два или више таквих стрингова који имају исту најмању дужину, пронађите онај који се раније појављује у wordsContainer.
Вратите низ целих бројева ans, где је ans[i] индекс стринга у wordsContainer који има најдужи заједнички суфикс са wordsQuery[i].

Пример 1:

Унос: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Излаз: [1,1,1]
Објашњење:
Погледајмо сваки wordsQuery[i] појединачно:

За wordsQuery[0] = "cd", стрингови из wordsContainer који деле најдужи заједнички суфикс "cd" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 1 јер има најкраћу дужину од 3.
За wordsQuery[1] = "bcd", стрингови из wordsContainer који деле најдужи заједнички суфикс "bcd" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 1 јер има најкраћу дужину од 3.
За wordsQuery[2] = "xyz", нема стринга из wordsContainer који дели заједнички суфикс. Због тога је најдужи заједнички суфикс "", који деле стрингови на индексу 0, 1 и 2. Међу њима, одговор је стринг на индексу 1 јер има најкраћу дужину од 3.

Пример 2:

Улаз: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Излаз: [2,0,2]
Објашњење:
Погледајмо сваки wordsQuery[i] појединачно:

За wordsQuery[0] = "gh", стрингови из wordsContainer који деле најдужи заједнички суфикс "gh" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 2 јер има најкраћу дужину од 6.
За wordsQuery[1] = "acbfgh", само стринг на индексу 0 дели најдужи заједнички суфикс "fgh". Зато је он одговор, иако је стринг на индексу 2 краћи.
За wordsQuery[2] = "acbfegh", стрингови из wordsContainer који деле најдужи заједнички суфикс "gh" су на индексима 0, 1 и 2. Међу њима, одговор је стринг на индексу 2 јер има најкраћу дужину од 6.

Ограничења:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] се састоји само од малих енглеских слова.
wordsQuery[i] се састоји само од малих енглеских слова.
Збир дужина wordsContainer[i] је највише 5 * 10^5.
Збир дужина wordsQuery[i] је највише 5 * 10^5.


Цео број дељив сумом својих цифара назива се Харшадов број. Дат вам је цео број x. Вратите збир цифара x ако је x Харшадов број, иначе вратите -1.

Пример 1:

Улаз: x = 18
Излаз: 9
Објашњење:
Збир цифара x је 9. 18 је дељиво са 9, дакле 18 је Харшадов број и одговор је 9.

Пример 2:

Улаз: x = 23
Излаз: -1
Објашњење:
Збир цифара x је 5. 23 није дељиво са 5, дакле 23 није Харшадов број и одговор је -1.

Ограничења:

1 <= x <= 100


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

Пример 1:

Улаз: nums = [0,1,1,1]
Излаз: 5
Објашњење:
Следећи поднизови су наизменични: [0], [1], [1], [1] и [0,1].

Пример 2:

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

Ограничења:

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

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

Пример 1:

Улаз: nums = [0,1,1,1]
Излаз: 5
Објашњење:
Следећи поднизови су наизменични: [0], [1], [1], [1] и [0,1].

Пример 2:

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

Ограничења:

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

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

Пример 1:

Улаз: nums = [0,1,1,1]
Излаз: 5
Објашњење:
Следећи поднизови се смењују: [0], [1], [1], [1] и [0,1].

Пример 2:

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

Ограничења:

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


Дат је низ тачака `points` који представља целобројне координате неких тачака на 2D равни, где је `points[i] = [x_i, y_i]`.
Раздаљина између две тачке је дефинисана као њихова Менхетенова раздаљина.
Вратите најмању могућу вредност максималне раздаљине између било које две тачке уклањањем тачно једне тачке.

Пример 1:

Улаз: points = [[3,10],[5,15],[10,2],[4,4]]
Излаз: 12
Објашњење:
Максимална раздаљина након уклањања сваке тачке је следећа:

Након уклањања тачке 0, максимална раздаљина је између тачака (5, 15) и (10, 2), што је |5 - 10| + |15 - 2| = 18.
Након уклањања тачке 1, максимална раздаљина је између тачака (3, 10) и (10, 2), што је |3 - 10| + |10 - 2| = 15.
Након уклањања тачке 2, максимална раздаљина је између тачака (5, 15) и (4, 4), што је |5 - 4| + |15 - 4| = 12.
Након уклањања тачке 3, максимална раздаљина је између тачака (5, 15) и (10, 2), што је |5 - 10| + |15 - 2| = 18.

12 је најмања могућа максимална раздаљина између било које две тачке након уклањања тачно једне тачке.

Пример 2:

Улаз: points = [[1,1],[1,1],[1,1]]
Излаз: 0
Објашњење:
Уклањање било које од тачака резултира максималном раздаљином између било које две тачке од 0.

Ограничења:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

Дат је низ тачака points који представља целобројне координате неких тачака на 2D равни, где је points[i] = [x_i, y_i].
Раздаљина између две тачке је дефинисана као њихова Менхетенова раздаљина.
Вратите најмању могућу вредност максималне раздаљине између било које две тачке уклањањем тачно једне тачке.

Пример 1:

Улаз: points = [[3,10],[5,15],[10,2],[4,4]]
Излаз: 12
Објашњење:
Максимална раздаљина након уклањања сваке тачке је следећа:

Након уклањања тачке 0, максимална раздаљина је између тачака (5, 15) и (10, 2), што је |5 - 10| + |15 - 2| = 18.
Након уклањања тачке 1, максимална раздаљина је између тачака (3, 10) и (10, 2), што је |3 - 10| + |10 - 2| = 15.
Након уклањања тачке 2, максимална раздаљина је између тачака (5, 15) и (4, 4), што је |5 - 4| + |15 - 4| = 12.
Након уклањања тачке 3, максимална раздаљина је између тачака (5, 15) и (10, 2), што је |5 - 10| + |15 - 2| = 18.

12 је најмања могућа максимална раздаљина између било које две тачке након уклањања тачно једне тачке.

Пример 2:

Улаз: points = [[1,1],[1,1],[1,1]]
Излаз: 0
Објашњење:
Уклањање било које од тачака резултира максималном раздаљином између било које две тачке од 0.

Ограничења:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8


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

Пример 1:

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

Пример 2:

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

Пример 3:

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

Ограничења:

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

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

Пример 1:

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

Пример 2:

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

Пример 3:

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

ОГРАНИЧЕЊА:

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

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

Пример 1:

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

Пример 2:

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

Пример 3:

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

Ограничења:

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


Дат је низ s и цео број k.
Дефинишите функцију distance(s_1, s_2) између два низ s_1 и s_2 исте дужине n као:

Збир минималних растојања између s_1[i] и s_2[i] када су карактери од 'a' до 'z' постављени у цикличном редоследу, за све i у опсегу [0, n - 1].

На пример, distance("ab", "cd") == 4, и distance("a", "z") == 1.
Можете променити било које слово у s у било које друго мало енглеско слово, било колико пута.
Вратите низ који означава лексикографски најмањи низ t који можете добити након неких промена, тако да је distance(s, t) <= k.

Пример 1:

Улаз: s = "zbbz", k = 3
Излаз: "aaaz"
Објашњење:
Промените s у "aaaz". Растојање између "zbbz" и "aaaz" је једнако k = 3.

Пример 2:

Улаз: s = "xaxcd", k = 4
Излаз: "aawcd"
Објашњење:
Растојање између "xaxcd" и "aawcd" је једнако k = 4.

Пример 3:

Улаз: s = "lol", k = 0
Излаз: "lol"
Објашњење:
Немогуће је променити било који карактер јер је k = 0.

Ограничења:

1 <= s.length <= 100
0 <= k <= 2000
s се састоји само од малих енглеских слова.

Дат вам је низ с и цео број к.
Дефинишите растојање функције(s_1, s_2)  између два низа s_1 и s_2 исте дужине н као:

Збир минималног растојања између s_1[i] и s_2[i] када су знакови од 'а' до 'з' постављени у цикличном редоследу, за све и у опсегу [0, n - 1].

На пример, растојање("ab", "cd") == 4, а растојање("a", "z") == 1.
Можете променити било које слово од с у било које друго мало слово енглеског језика, било који број пута.
Вратите стринг који означава лексикографски најмањи стринг т који можете да добијете након неких измена, тако да дистанце(s, t) <= k.

Пример 1:

Улаз: s = "zbbz", k = 3
Излаз: "aaaz"
Објашњење:
Промените с у "аааз". Растојање између "зббз" и "аааз" је једнако к = 3.

Пример 2:

Улаз: s = "xaxcd", k = 4
Излаз: "aawcd"
Објашњење:
Растојање између "какцд" и "аавцд" је једнако к = 4.

Пример 3:

Улаз: s = "lol", k = 0
Излаз: "lol"
Објашњење:
Немогуће је променити било који карактер као к = 0.

Ограничења:

1 <= s.length <= 100
0 <= k <= 2000
с се састоји само од малих енглеских слова.

Дата је ниска s и цео број k.
Дефинишите функцију distance(s_1, s_2) између две ниске s_1 и s_2 исте дужине n као:

Збир минималних растојања између s_1[i] и s_2[i] када су карактери од 'a' до 'z' постављени у цикличном редоследу, за све i у опсегу [0, n - 1].

На пример, distance("ab", "cd") == 4, и distance("a", "z") == 1.
Можете променити било које слово у s у било које друго мало енглеско слово, било колико пута.
Вратите никсу која означава лексикографску најмању ниску ни t која можете добити након неких промена, тако да је distance(s, t) <= k.

Пример 1:

Улаз: s = "zbbz", k = 3
Излаз: "aaaz"
Објашњење:
Промените s у "aaaz". Растојање између "zbbz" и "aaaz" је једнако k = 3.

Пример 2:

Улаз: s = "xaxcd", k = 4
Излаз: "aawcd"
Објашњење:
Растојање између "xaxcd" и "aawcd" је једнако k = 4.

Пример 3:

Улаз: s = "lol", k = 0
Излаз: "lol"
Објашњење:
Немогуће је променити било који карактер јер је k = 0.

Ограничења:

1 <= s.length <= 100
0 <= k <= 2000
s се састоји само од малих енглеских слова.


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

Пример 1:

Улаз: nums = [2,5,6,8,5], k = 4
Излаз: 2
Објашњење:
Можемо одузети један од nums[1] и nums[4] да добијемо [2, 4, 6, 8, 4]. Медијана резултујућег низа је једнака k.

Пример 2:

Улаз: nums = [2,5,6,8,5], k = 7
Излаз: 3
Објашњење:
Можемо додати један на nums[1] два пута и додати један на nums[2] једном да добијемо [2, 7, 7, 8, 5].

Пример 3:

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

Ограничења:

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

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

Пример 1:

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

Пример 2:

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

Пример 3:

Улаз: nums = [1,2,3,4,5,6], к = 4
Излаз: 0
Објашњење:
Медијан низа је већ једнак к.

Ограничења:

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

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

Пример 1:

Улаз: nums = [2,5,6,8,5], k = 4
Излаз: 2
Објашњење:
Можемо одузети један од nums[1] и nums[4] да добијемо [2, 4, 6, 8, 4]. Медијана резултујућег низа је једнака k.

Пример 2:

Улаз: nums = [2,5,6,8,5], k = 7
Излаз: 3
Објашњење:
Можемо додати један на nums[1] два пута и додати један на nums[2] једном да добијемо [2, 7, 7, 8, 5].

Пример 3:

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

Ограничења:

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


Дат вам је низ s који представља време у 12-часовном формату где су неке цифре (можда ниједна) заменљене са "?".
12-часовна времена су форматирана као "HH:MM", где је HH између 00 и 11, а MM између 00 и 59. Најраније време у 12-часовном формату је 00:00, а најкасније је 11:59.
Треба да замените све "?" знакове у s са цифрама тако да време које добијемо резултујућим низом буде важеће 12-часовно време и буде најкасније могуће.
Вратите резултујући низ.

Пример 1:

Унос: s = "1?:?4"
Излаз: "11:54"
Објашњење: Најкасније време у 12-часовном формату које можемо добити заменом знакова "?" је "11:54".

Пример 2:

Унос: s = "0?:5?"
Излаз: "09:59"
Објашњење: Најкасније време у 12-часовном формату које можемо добити заменом знакова "?" је "09:59".

Ограничења:

s.length == 5
s[2] је једнака знаку ":".
Сви знакови осим s[2] су цифре или знакови "?".
Унос је генерисан тако да постоји бар једно време између "00:00" и "11:59" које можете добити након замене знакова "?".

Dobijate string s koji predstavlja vreme u 12-časovnom formatu, gde su neki od brojeva (moguće nijedan) zamenjeni sa "?".
Vremena u 12-časovnom formatu su formatirana kao "HH:MM", gde je HH između 00 i 11, a MM između 00 i 59. Najranije vreme u 12-časovnom formatu je 00:00, a najkasnije je 11:59.
Morate zameniti sve karaktere "?" u s sa ciframa tako da vreme koje dobijemo rezultujućim stringom bude važeće 12-časovno vreme i bude što je moguće najkasnije.
Vratite dobijeni string.

Пример 1:

Унос: s = "1?:?4"
Излаз: "11:54"
Objašnjenje: Najkasnije 12-časovno vreme koje možemo postići zamenom karaktera "?" je "11:54".

Пример 2:

Унос: s = "0?:5?"
Излаз: "09:59"
Објашњење: Најкасније време у 12-часовном формату које можемо добити заменом знакова "?" је "09:59".

Ограничења:

s.length == 5
s[2] је једнака знаку ":".
Сви знакови осим s[2] су цифре или знакови "?".
Унос је генерисан тако да постоји бар једно време између "00:00" и "11:59" које можете добити након замене знакова "?".

Дат је стринг s који представља време у 12-часовном формату где су неке од цифара (могуће ниједна) замењене са "?".
Време у 12-часовном формату је обликовано као "HH:MM", где је HH између 00 и 11, а MM између 00 и 59. Најраније време у 12-часовном формату је 00:00, а најкасније је 11:59.
Треба да замените све знакове "?" у s са цифрама тако да време које добијете буде валидно у 12-часовном формату и да буде што касније.
Вратите резултујући стринг.

Пример 1:

Улаз: s = "1?:?4"
Излаз: "11:54"
Објашњење: Најкасније време у 12-часовном формату које можемо добити заменом знакова "?" је "11:54".

Пример 2:

Улаз: s = "0?:5?"
Излаз: "09:59"
Објашњење: Најкасније време у 12-часовном формату које можемо добити заменом знакова "?" је "09:59".

Ограничења:

s.length == 5
s[2] је једнака знаку ":".
Сви знакови осим s[2] су цифре или знакови "?".
Улаз је генерисан тако да постоји бар једно време између "00:00" и "11:59" које можете добити након замене знакова "?".


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

Пример 1:

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

Пример 2:

Улаз: nums = [4,8,2,8]
Излаз: 0
Објашњење: nums[2] је прост. Пошто постоји само један прост број, одговор је |2 - 2| = 0.

Ограничења:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
Улаз је генерисан тако да у nums постоји бар један прост број.

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

Пример 1:

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

Пример 2:

Улаз: nums = [4,8,2,8]
Излаз: 0
Објашњење: nums[2] је прост. Пошто постоји само један прост број, одговор је |2 - 2| = 0.

Ограничења:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
Улаз је генерисан тако да у nums постоји бар један прост број.

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

Пример 1:

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

Пример 2:

Улаз: nums = [4,8,2,8]
Излаз: 0
Објашњење: nums[2] је прост. Пошто постоји само један прост број, одговор је |2 - 2| = 0.

Ограничења:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
Улаз је генерисан тако да број простих бројева у nums буде најмање један.


Дат вам је низ целих бројева coins који представљају новчиће различитих апоена и цео број k.
Имате неограничен број новчића сваког апоена. Међутим, није дозвољено комбиновање новчића различитих апоена.
Вратите k^th најмањи износ који се може направити коришћењем ових новчића.

Пример 1:

Улаз: coins = [3,6,9], k = 3
Излаз: 9
Објашњење: Дати новчићи могу направити следеће износе:
Новчић 3 производи вишекратнике од 3: 3, 6, 9, 12, 15, итд.
Новчић 6 производи вишекратнике од 6: 6, 12, 18, 24, итд.
Новчић 9 производи вишекратнике од 9: 9, 18, 27, 36, итд.
Сви дати новчићи заједно производе: 3, 6, 9, 12, 15, итд.

Пример 2:

Улаз: coins = [5,2], k = 7
Излаз: 12
Објашњење: Дати новчићи могу направити следеће износе:
Новчић 5 производи вишекратнике од 5: 5, 10, 15, 20, итд.
Новчић 2 производи вишекратнике од 2: 2, 4, 6, 8, 10, 12, итд.
Сви дати новчићи заједно производе: 2, 4, 5, 6, 8, 10, 12, 14, 15, итд.

Ограничења:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins садржи међусобно различите целобројне вредности.

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

Пример 1:

Улаз: coins = [3,6,9], k = 3
Излаз: 9
Објашњење: Дати новчићи могу чинити следеће износе:
Новчић 3 производи вишекратнике од 3: 3, 6, 9, 12, 15, итд.
Новчић 6 производи вишекратнике од 6: 6, 12, 18, 24, итд.
Новчић 9 производи вишекратнике 9: 9, 18, 27, 36 итд.
Сви новчићи заједно производе: 3, 6, 9, 12, 15, итд.

Пример 2:

Улаз: coins = [5,2], k = 7
Излаз: 12
Објашњење: Дати новчићи могу чинити следеће износе:
Новчић 5 производи вишекратнике од 5: 5, 10, 15, 20, итд.
Новчић 2 производи вишекратнике 2: 2, 4, 6, 8, 10, 12, итд.
Сви новчићи заједно производе: 2, 4, 5, 6, 8, 10, 12, 14, 15, итд.

Ограничења:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
кованице садрже у пару различите целе бројеве.

Дат вам је низ целих бројева coins, који представљају новчиће различитих апоена, и цео број k.
Имате неограничен број новчића сваког апоена. Међутим, није дозвољено комбиновати новчиће различитих апоена.
Вратите k-ту најмању вредност која се може направити користећи ове новчиће.

Пример 1:

Улаз: coins = [3,6,9], k = 3
Излаз: 9
Објашњење: Дати новчићи могу направити следеће износе:
Новчић 3 производи вишекратнике од 3: 3, 6, 9, 12, 15, итд.
Новчић 6 производи вишекратнике од 6: 6, 12, 18, 24, итд.
Новчић 9 производи вишекратнике од 9: 9, 18, 27, 36, итд.
Сви дати новчићи заједно производе: 3, 6, 9, 12, 15, итд.

Пример 2:

Улаз: coins = [5,2], k = 7
Излаз: 12
Објашњење: Дати новчићи могу направити следеће износе:
Новчић 5 производи вишекратнике од 5: 5, 10, 15, 20, итд.
Новчић 2 производи вишекратнике од 2: 2, 4, 6, 8, 10, 12, итд.
Сви дати новчићи заједно производе: 2, 4, 5, 6, 8, 10, 12, 14, 15, итд.

Ограничења:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins садржи међусобно различите целобројне вредности.


Дати су вам два низа, nums и andValues, дужине n и m респективно.
Вредност низа је једнака последњем елементу тог низа.
Потребно је поделити nums у m дисјунктних континуираних подниза, тако да за i-ти подниз [l_i, r_i], битовски И (AND) елемената подниза је једнак andValues[i]. Другим речима, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] за све 1 <= i <= m, где & представља битовски И (AND) оператор.
Вратити минималан могући збир вредности m поднизова у које је nums подељен. Ако није могуће поделити nums у m поднизова који задовољавају ове услове, вратити -1.

Пример 1:

Улаз: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Излаз: `12`
Објашњење:
Једини могући начин да се подели `nums` је:

[1,4] јер 1 & 4 == 0.
[3] јер је битовски И једноелементног подниза сам елемент.
[3] јер је битовски И једноелементног подниза сам елемент.
[2] јер је битовски И једноелементног подниза сам елемент.

Сума вредности ових поднизова је 4 + 3 + 3 + 2 = 12.

Пример 2:

Улаз: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Излаз: 17
Објашњење:
Постоје три начина да се подели `nums`:

[[2,3,5],[7,7,7],[5]] са сумом вредности 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] са сумом вредности 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] са сумом вредности 7 + 7 + 5 == 19.

Минималан могући збир вредности је 17.

Пример 3:

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

Ограничења:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Дати су вам два низа, `nums` и `andValues`, дужине `n` и `m` респективно.
Вредност низа је једнака последњем елементу тог низа.
Потребно је поделити `nums` у `m` дисјунктних континуираних подниза, тако да за `i`-ти подниз `[l_i, r_i]`, битовски И AND елемената подниза је једнак `andValues[i]`. Другим речима, `nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i]` за све `1 <= i <= m`, где `&` представља битовски И AND оператор.
Вратити минималан могући збир вредности `m` поднизова у које је `nums` подељен. Ако није могуће поделити `nums` у `m` поднизова који задовољавају ове услове, вратити `-1`.

Пример 1:

Улаз: `nums = [1,4,3,3,2]`, `andValues = [0,3,3,2]`
Излаз: `12`
Објашњење:
Једини могући начин да се подели `nums` је:

`[1,4]` јер `1 & 4 == 0`.
`[3]` јер је битовски И једноелементног подниза сам елемент.
`[3]` јер је битовски И једноелементног подниза сам елемент.
`[2]` јер је битовски И једноелементног подниза сам елемент.

Сума вредности ових поднизова је `4 + 3 + 3 + 2 = 12`.

Пример 2:

Улаз: `nums = [2,3,5,7,7,7,5]`, `andValues = [0,7,5]`
Излаз: `17`
Објашњење:
Постоје три начина да се подели `nums`:

`[[2,3,5],[7,7,7],[5]]` са сумом вредности `5 + 7 + 5 == 17`.
`[[2,3,5,7],[7,7],[5]]` са сумом вредности `7 + 7 + 5 == 19`.
`[[2,3,5,7,7],[7],[5]]` са сумом вредности `7 + 7 + 5 == 19`.

Минималан могући збир вредности је `17`.

Пример 3:

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

Ограничења:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Дат вам је два низа nums и andValues дужине n и m, редом.
Вредност низа је једнака последњем елементу тог низа.
Треба да поделите nums на m различитих, континуираних подниза тако да за i-ти подниз [l_i, r_i], битовски AND елемената подниза буде једнака andValues[i], другим речима, nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] за све 1 <= i <= m, where & представља битовски AND оператор.
Вратите минималну могућу суму вредности m подниза у које је подељен nums. Ако није могуће поделити nums на m подниза који задовољавају ове услове, вратите -1.

Пример 1:

Улаз: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Излаз: 12
Објашњење:
Једини могући начин да се подели nums је:

[1,4] јер 1 & 4 == 0.
[3] јер је битовски И једноелементног подниза сам елемент.
[3] јер је битовски И једноелементног подниза сам елемент.
[2] јер је битовски И једноелементног подниза сам елемент.

Сума вредности ових поднизова је 4 + 3 + 3 + 2 = 12.

Пример 2:

Улаз: nums = [2,3,5,7,7,7,5], andValues = [0,7,5]
Излаз: 17
Објашњење:
Постоје три начина да се подели nums:

[[2,3,5],[7,7,7],[5]] са сумом вредности 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] са сумом вредности 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] са сумом вредности 7 + 7 + 5 == 19.

Минималан могући збир вредности је 17.

Пример 3:

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

Ограничења:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5


Дат вам је низ целих бројева nums који садржи позитивне целе бројеве. Дефинишемо функцију encrypt такву да encrypt(x) замењује сваки цифру у x са највећом цифром у x. На пример, encrypt(523) = 555 и encrypt(213) = 333.
Вратите збир шифрованих елемената.

Пример 1:

Улаз: nums = [1,2,3]
Излаз: 6
Објашњење: Шифровани елементи су [1,2,3]. Збир шифрованих елемената је 1 + 2 + 3 == 6.

Пример 2:

Улаз: nums = [10,21,31]
Излаз: 66
Објашњење: Шифровани елементи су [11,22,33]. Збир шифрованих елемената је 11 + 22 + 33 == 66.

Ограничења:

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

Добијате целобројни низ nums који садрже позитивне целе бројеве. Дефинишемо функцију шифровања тако да шифруј(x) замењује сваку цифру у x са највећом цифром у x. На пример, шифруј(523) = 555 и шифруј(213) = 333.
Вратите збир шифрованих елемената.

Пример 1:

Улаз : nums = [1,2,3]
излаз : 6
Објашњење : Шифровани елементи су [1,2,3]. Збир шифрованих елемената је 1 + 2 + 3 = 6.

Пример 2:

Улаз : nums = [10,21,31]
излаз : 66
Објашњење : Шифровани елементи су [11,22,33]. Збир шифрованих елемената је 11 + 22 + 33 = 66.

Ограничења:

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

Dati su vam celobrojni niz nums koji sadrži pozitivne brojeve. Definišemo funkciju encrypt tako da encrypt(x) zamenjuje svaku cifru u broju x sa najvećom cifrom u tom broju. Na primer, encrypt(523) = 555 i encrypt(213) = 333.
Vratite sumu enkriptovanih elemenata.

Primer 1:

Ulaz:nums = [1,2,3]
Izlaz: 6
Objašnjenje: Enkriptovani elementi su [1,2,3]. Suma enkriptovanih elemenata je 1 + 2 + 3 == 6.

Primer 2:

Ulaz:nums = [10,21,31]
Izlaz:66
Objašnjenje: Enkriptovani elementi su [11,22,33]. Suma enkriptovanih elemenata je 11 + 22 + 33 == 66.

Ograničenja:

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