Egy n hosszúságú egész számokból álló tömböt kapunk.
Egy tömb költsége az első elemének értéke. Például az [1,2,3] költsége 1, míg a [3,4,1] költsége 3.
A számokat fel kell osztania 3 nem összefüggő altömbre.
Adja vissza ezen altömbök költségének minimális lehetséges összegét.

1. példa:

Bemenet: nums  = [1,2,3,12]
Kimenet: 6
Magyarázat: A lehető legjobb módja 3 altömb kialakításának: [1], [2] és [3,12] 1 + 2 + 3 = 6 összköltséggel.
A másik lehetséges módja 3 altömb létrehozásának:
- [1], [2,3] és [12] 1 + 2 + 12 = 15 összköltséggel.
- [1,2], [3] és [12] 1 + 3 + 12 = 16 összköltséggel.

2. példa:

Bemenet: nums  = [5,4,3]
Kimenet: 12
Magyarázat: A lehető legjobb módja 3 altömb kialakításának: [5], [4] és [3] 5 + 4 + 3 = 12 összköltséggel.
Kimutatható, hogy 12 az elérhető minimális költség.

3. példa:

Bemenet: nums  = [10,3,1,1]
Kimenet: 12
Magyarázat: A lehető legjobb módja 3 altömb kialakításának: [10,3], [1] és [1] 10 + 1 + 1 = 12 összköltséggel.
Kimutatható, hogy 12 az elérhető minimális költség.

Korlátozások:

3 <= n <= 50
1 <= nums[i] <= 50

Egy n hosszúságú egész számokból álló tömböt kapunk.
Egy tömb költsége az első elemének az értéke. Például az [1,2,3] költsége 1, míg a [3,4,1] költsége 3.
A számokat fel kell osztania 3 nem összefüggő altömbre.
Adja vissza ezen altömbök költségének minimális lehetséges összegét.

1. példa:

Bemenet: nums = [1,2,3,12]
Kimenet: 6
Magyarázat: A lehető legjobb módja 3 altömb kialakításának: [1], [2] és [3,12] 1 + 2 + 3 = 6 összköltséggel.
A másik lehetséges módja 3 altömb létrehozásának:
- [1], [2,3] és [12] 1 + 2 + 12 = 15 összköltséggel.
- [1,2], [3] és [12] 1 + 3 + 12 = 16 összköltséggel.

2. példa:

Bemenet: nums = [5,4,3]
Kimenet: 12
Magyarázat: A lehető legjobb módja 3 altömb kialakításának: [5], [4] és [3] 5 + 4 + 3 = 12 összköltséggel.
Kimutatható, hogy 12 az elérhető minimális költség.

3. példa:

Bemenet: nums = [10,3,1,1]
Kimenet: 12
Magyarázat: A lehető legjobb módja 3 altömb kialakításának: [10,3], [1] és [1] 10 + 1 + 1 = 12 összköltséggel.
Kimutatható, hogy 12 az elérhető minimális költség.

Korlátozások:

3 <= n <= 50
1 <= nums[i] <= 50

Egész számok tömbjét kapja, n hosszúságú számokat.
A tömb költsége az első elem értéke. Például az [1,2,3] költsége 1, míg a [3,4,1] költsége 3.
A számokat 3 diszjunkt összefüggő résztömbre kell osztani.
Adja vissza a résztömbök költségének lehető legkisebb összegét.

1. példa:

Bemenet: nums = [1,2,3,12]
Kimenet: 6
Magyarázat: A lehető legjobb módja annak, hogy 3 résztömböt hozzunk létre: [1], [2] és [3,12] 1 + 2 + 3 = 6 összköltséggel.
A 3 altömb kialakításának további lehetséges módjai a következők:
- [1], [2,3] és [12] 1 + 2 + 12 = 15 összköltséggel.
- [1,2], [3] és [12] 1 + 3 + 12 = 16 összköltséggel.

2. példa:

Bemenet: nums = [5,4,3]
Kimenet: 12
Magyarázat: A lehető legjobb módja annak, hogy 3 résztömböt hozzunk létre: [5], [4] és [3] 5 + 4 + 3 = 12 összköltséggel.
Kimutatható, hogy 12 az elérhető minimális költség.

3. példa:

Bemenet: nums = [10,3,1,1]
Kimenet: 12
Magyarázat: A lehető legjobb módja annak, hogy 3 résztömböt alakítsunk ki: [10,3], [1] és [1] 10 + 1 + 1 = 12 összköltséggel.
Kimutatható, hogy 12 az elérhető minimális költség.

Korlátok:

3 <= n <= 50
1 <= nums[i] <= 50


Kapsz egy n hosszúságú tömböt és egy k pozitív egész számot.
A számok altömbjét akkor nevezzük jónak, ha az első és az utolsó eleme közötti abszolút különbség pontosan k, vagyis a nums[i..j] altömb akkor jó, ha |nums[i] - nums[j]| == k.
Egy jó résztömb maximális összegét adja vissza. Ha nincsenek jó altáblák, adjon vissza 0-t.

Példa 1:

Bemenet: nums = [1,2,3,4,5,6], k = 1
Kimenet: 11
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 1-nek kell lennie egy jó altömbhöz. Az összes jó altömb a következő: [1,2], [2,3], [3,4], [4,5] és [5,6]. A maximális részösszeg 11 az [5,6] résztömbhöz.

Példa 2:

Bemenet: nums = [-1,3,2,4,5], k = 3
Kimenet: 11
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 3-nak kell lennie egy jó altömbhöz. Az összes jó altömb a következő: [-1,3,2] és [2,4,5]. A maximális részösszeg 11 a [2,4,5] résztömbhöz.

Példa 3:

Bemenet: nums = [-1,-2,-3,-4], k = 2
Kimenet: -6
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 2-nek kell lennie egy jó altömbhöz. Az összes jó altömb a következő: [-1,-2,-3] és [-2,-3,-4]. A maximális részösszeg -6 a [-1,-2,-3] altömbhöz.

Korlátozások:

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

Kapsz egy n hosszúságú tömböt és egy k pozitív egész számot.
A számok altömbjét akkor nevezzük jónak, ha az első és az utolsó eleme közötti abszolút különbség pontosan k, vagyis a nums[i..j] altömb akkor jó, ha |szám[i] - szám[j]| == k.
Egy jó résztömb maximális összegét adja vissza. Ha nincsenek jó altáblák, adjon vissza 0-t.

1. példa:

Bemenet: nums = [1,2,3,4,5,6], k = 1
Kimenet: 11
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 1-nek kell lennie egy jó altömbhöz. Az összes jó altömb a következő: [1,2], [2,3], [3,4], [4,5] és [5,6]. A maximális részösszeg 11 az [5,6] résztömbhöz.

2. példa:

Bemenet: nums = [-1,3,2,4,5], k = 3
Kimenet: 11
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 3-nak kell lennie egy jó altömbhöz. Az összes jó altömb a következő: [-1,3,2] és [2,4,5]. A maximális részösszeg 11 a [2,4,5] résztömbhöz.

3. példa:

Bemenet: számok = [-1,-2,-3,-4], k = 2
Kimenet: -6
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 2-nek kell lennie egy jó altömbhöz. Az összes jó altömb a következő: [-1,-2,-3] és [-2,-3,-4]. A maximális részösszeg -6 a [-1,-2,-3] altömbhöz.

Korlátozások:

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

Kapsz egy n hosszúságú tömbszámot és egy k pozitív egész számot.
A numok egy résztömbjét akkor nevezzük jónak, ha az első és az utolsó elem közötti abszolút különbség pontosan k, más szóval a nums[i. j] akkor jó, ha |nums[i] - nums[j]| == k.
A számok jó résztömbjének maximális összegét adja eredményül. Ha nincsenek jó résztömbök, adja vissza a 0 értéket.

1. példa:

Bemenet: nums = [1,2,3,4,5,6], k = 1
Kimenet: 11
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 1-nek kell lennie egy jó résztömbhöz. Az összes jó résztömb: [1,2], [2,3], [3,4], [4,5] és [5,6]. A résztömb maximális összege 11 a résztömb esetében [5,6].

2. példa:

Bemenet: nums = [-1,3,2,4,5], k = 3
Kimenet: 11
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 3-nak kell lennie egy jó résztömbhöz. Az összes jó résztömb: [-1,3,2] és [2,4,5]. A résztömb maximális összege 11 a [2,4,5] résztömb esetében.

3. példa:

Bemenet: nums = [-1,-2,-3,-4], k = 2
Kimenet: -6
Magyarázat: Az első és az utolsó elem közötti abszolút különbségnek 2-nek kell lennie egy jó résztömbhöz. Az összes jó résztömb: [-1,-2,-3] és [-2,-3,-4]. A résztömb maximális összege -6 a [-1,-2,-3] résztömb esetében.

Korlátok:

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


Kapsz egy s karakterláncot, amely angol kisbetűkből áll.
Egy karakterláncot speciálisnak nevezünk, ha csak egyetlen karakterből áll. Például az "abc" karakterlánc nem különleges, míg a "ddd", "zz" és "f" karakterlánc különleges.
Az s leghosszabb speciális részkarakterláncának hosszát adja vissza, amely legalább háromszor fordul elő, vagy -1, ha nem fordul elő speciális részkarakterlánc legalább háromszor.
A részkarakterlánc egy karakterláncon belüli, egymást követő, nem üres karaktersorozat.

1. példa:

Bemenet: s = "aaaa"
Kimenet: 2
Magyarázat: A háromszor előforduló leghosszabb speciális karakterlánc az „aa”: „aaaa”, „aaaa” és „aaaa” részstring.
Megmutatható, hogy a maximális elérhető hossz 2.

2. példa:

Bemenet: s = "abcdef"
Kimenet: -1
Magyarázat: Nem létezik olyan speciális részkarakterlánc, amely legalább háromszor előfordulna. Ezért vissza -1.

3. példa:

Bemenet: s = "abcaba"
Kimenet: 1
Magyarázat: A háromszor előforduló leghosszabb speciális karakterlánc az "a": "abcaba", "abcaba" és "abcaba" részkarakterlánc.
Megmutatható, hogy a maximális elérhető hossz 1.

Korlátozások:

3 <= s.length <= 50
s csak kis angol betűkből áll.

Kapsz egy s karakterláncot, amely angol kisbetűkből áll.
Egy karakterláncot speciálisnak nevezünk, ha csak egyetlen karakterből áll. Például az "abc" karakterlánc nem különleges, míg a "ddd", "zz" és "f" karakterlánc különleges.
Az s leghosszabb speciális részkarakterláncának hosszát adja vissza, amely legalább háromszor előfordul, vagy -1, ha nem fordul elő speciális részkarakterlánc legalább háromszor.
A részkarakterlánc a karakterláncon belüli, egymást követő, nem üres karaktersorozat.

1. példa:

Bemenet: s = "aaaa"
Kimenet: 2
Magyarázat: A háromszor előforduló leghosszabb speciális karakterlánc az „aa”: „aaaa”, „aaaa” és „aaaa” részstring.
Megmutatható, hogy a maximális elérhető hossz 2.

2. példa:

Bemenet: s = "abcdef"
Kimenet: -1
Magyarázat: Nem létezik olyan speciális részkarakterlánc, amely legalább háromszor előfordulna. Ezért vissza -1.

3. példa:

Bemenet: s = "abcaba"
Kimenet: 1
Magyarázat: A háromszor előforduló leghosszabb speciális karakterlánc az "a": "abcaba", "abcaba" és "abcaba" részkarakterlánc.
Megmutatható, hogy a maximális elérhető hossz 1.

Korlátozások:

3 <= s.length <= 50
s csak kis angol betűkből áll.

Kapsz egy s karakterláncot, amely kisbetűs angol betűkből áll.
Egy karakterláncot különlegesnek nevezünk, ha csak egyetlen karakterből áll. Például az "abc" karakterlánc nem különleges, míg a "ddd", "zz" és "f" karakterláncok speciálisak.
Az s leghosszabb speciális részkarakterláncának hosszát adja eredményül, amely legalább háromszor előfordul, vagy -1-et, ha nincs legalább háromszor speciális részkarakterlánc.
Az alkarakterlánc egy karakterláncon belüli folytonos, nem üres karaktersorozat.

1. példa:

Bemenet: s = "aaaa"
Kimenet: 2
Magyarázat: A leghosszabb speciális szubsztring, amely háromszor fordul elő, az "aa": "aaaa", "aaaa" és "aaaa" alkarakterláncok.
Kimutatható, hogy az elérhető maximális hossz 2.

2. példa:

Bemenet: s = "abcdef"
Kimenet: -1
Magyarázat: Nincs olyan speciális részkarakterlánc, amely legalább háromszor előfordulna. Ezért visszatérés -1.

3. példa:

Bemenet: s = "abcaba"
Kimenet: 1
Magyarázat: A leghosszabb speciális szubsztring, amely háromszor fordul elő, az "a": "abcaba", "abcaba" és "abcaba" részsztringek.
Kimutatható, hogy az elérhető maximális hossz 1.

Korlátok:

3 <= s.length <= 50
s csak kisbetűs angol betűkből áll.


Adott egy n méretű, 0-indexált egész szám tömb nums, és egy m méretű, 0-indexált egész szám tömb pattern, amely -1, 0 és 1 egész számokból áll.
Egy nums\[i..j\] méretű rész-tömböt akkor tekintünk illeszkedőnek a pattern-hez, ha a következő feltételek teljesülnek minden pattern\[k\] elem esetén:

nums\[i + k + 1\] > nums\[i + k\], ha pattern\[k\] == 1.
nums\[i + k + 1\] == nums\[i + k\], ha pattern\[k\] == 0.
nums\[i + k + 1\] < nums\[i + k\], ha pattern\[k\] == -1.

Adja vissza a nums-ban lévő, a pattern-hez illeszkedő rész-tömbök számát.

Példa 1:

Bemenet: nums = [1,2,3,4,5,6], pattern = [1,1]
Kimenet: 4
Magyarázat: A mintázat [1,1] azt jelzi, hogy szigorúan növekvő, 3 elemű rész-tömböket keresünk. A nums tömbben a következő rész-tömbök egyeznek ezzel a mintával: [1,2,3], [2,3,4], [3,4,5] és [4,5,6].
Így 4 rész-tömb van a nums-ban, amely illeszkedik a mintához.

Példa 2:

Bemenet: nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Kimenet: 2
Magyarázat: Itt a mintázat [1,0,-1] azt jelzi, hogy olyan sorozatot keresünk, ahol az első szám kisebb a másodiknál, a második egyenlő a harmadikkal, és a harmadik nagyobb a negyediknél. A nums tömbben a következő rész-tömbök illenek erre a mintára: [1,4,4,1] és [3,5,5,3].
Így 2 rész-tömb van a nums-ban, amely illeszkedik a mintához.

Korlátozások:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1

Kap egy 0-indexelt egész tömb számot n méretben, és egy 0-indexelt egész tömb mintát m méretben, amely -1, 0 és 1 egész számokból áll.
Egy résztömb nums[i.. j] m + 1 méretről akkor mondható, hogy megfelel a mintának, ha a következő feltételek érvényesek minden elemmintára[k]:

SZÁM[i + K + 1] > Szám[i + K] ha minta[k] == 1.
nums[i + k + 1] ==nums[i + k] ha pattern[k] == 0.
SZÁM[i + K + 1] < SZÁM[i + K] Ha minta[k] == -1.

A mintának megfelelő résztömbök számát adja vissza a tömbben

1. példa:

Bemenet: nums = [1,2,3,4,5,6], pattern = [1,1]
Kimenet: 4
Magyarázat: Az [1,1] minta azt jelzi, hogy szigorúan növekvő 3-as méretű résztömböket keresünk. A tömbszámokban az [1,2,3], [2,3,4], [3,4,5] és [4,5,6] résztömbök megfelelnek ennek a mintának.
Ezért 4 résztömb van a a tömbben, amelyek megfelelnek a mintának.

2. példa:

Bemenet: nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Kimenet: 2
Magyarázat: Itt az [1,0,-1] minta azt jelzi, hogy olyan sorozatot keresünk, ahol az első szám kisebb, mint a második, a második egyenlő a harmadikkal, és a harmadik nagyobb, mint a negyedik. A tömb számaiban az [1,4,4,1] és a [3,5,5,3] résztömbök megfelelnek ennek a mintának.
Ezért 2 résztömb van a a tömbben, amelyek megfelelnek a mintának.

Korlátok:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1

Kap egy 0-indexelt egész tömb számot n méretben, és egy 0-indexelt egész tömb mintát m méretben, amely -1, 0 és 1 egész számokból áll.
Egy résztömb nums[i.. j] m + 1 méretről akkor mondható, hogy megfelel a mintának, ha a következő feltételek érvényesek minden elemmintára[k]:

nums[i + K + 1] > nums[i + K] ha pattern[k] == 1.
nums[i + k + 1] == nums[i + k] if pattern[k] == 0.
nums[i + K + 1] < nums[i + K] Ha pattern[k] == -1.

A mintának megfelelő résztömbök számát adja vissza számban.

1. példa:

Bemenet: nums = [1,2,3,4,5,6], pattern = [1,1]
Kimenet: 4
Magyarázat: Az [1,1] pattern azt jelzi, hogy szigorúan növekvő 3-as méretű résztömböket keresünk. A tömbszámokban az [1,2,3], [2,3,4], [3,4,5] és [4,5,6] résztömbök megfelelnek ennek a mintának.
Ezért 4 résztömb van a számban, amelyek megfelelnek a mintának.

2. példa:

Bemenet: nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Kimenet: 2
Magyarázat: Itt az [1,0,-1] minta azt jelzi, hogy olyan sorozatot keresünk, ahol az első szám kisebb, mint a második, a második egyenlő a harmadikkal, és a harmadik nagyobb, mint a negyedik. A tömb számaiban az [1,4,4,1] és a [3,5,5,3] résztömbök megfelelnek ennek a mintának.
Ezért 2 résztömb van a nums, amelyek megfelelnek a mintának.

Korlátok:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == pattern.length < n
-1 <= pattern[i] <= 1


Alice és Bob körökre osztott játékot játszanak egy virágokkal körülvett kör alakú mezőn. A kör a mezőt ábrázolja, és Alice és Bob között x virág van az óramutató járásával megegyező irányban, közöttük pedig y virág az óramutató járásával ellentétes irányban.
A játék a következőképpen zajlik:

Alice veszi az első kanyart.
A játékosnak minden körben az óramutató járásával megegyező vagy azzal ellentétes irányt kell választania, és választania kell egy virágot arról az oldalról.
A kör végén, ha már egyáltalán nem marad virág, az aktuális játékos elkapja ellenfelét és megnyeri a játékot.

Adott két egész szám, n és m, a feladat az, hogy kiszámítsuk a lehetséges párok számát (x, y), amelyek teljesítik a feltételeket:

Alice-nek meg kell nyernie a játékot a leírt szabályok szerint.
A virágok x számának az óramutató járásával megegyező irányban az [1,n] tartományban kell lennie.
Az y virágok számának az óramutató járásával ellentétes irányban az [1,m] tartományban kell lennie.

Adja vissza a lehetséges párok számát (x, y), amelyek megfelelnek az utasításban említett feltételeknek.

1. példa:

Bemenet: n = 3, m = 2
Kimenet: 3
Magyarázat: A következő párok teljesítik az utasításban leírt feltételeket: (1,2), (3,2), (2,1).

2. példa:

Bemenet: n = 1, m = 1
Kimenet: 0
Magyarázat: Egyetlen pár sem felel meg az utasításban leírt feltételeknek.

Korlátozások:

1 <= n, m <= 10^5

Alice és Bob körökre osztott játékot játszanak egy virágokkal körülvett kör alakú mezőn. A kör a mezőt jelképezi, és Alice és Bob között x virág van az óramutató járásával megegyező irányban, és y virág az óramutató járásával ellentétes irányban közöttük.
A játék a következőképpen folytatódik:

Alice megteszi az első fordulatot.
Minden körben a játékosnak ki kell választania az óramutató járásával megegyező vagy az óramutató járásával ellentétes irányt, és ki kell választania egy virágot arról az oldalról.
A kör végén, ha egyáltalán nem marad virág, az aktuális játékos elfogja ellenfelét és megnyeri a játékot.

Két egész szám, n és m esetén a feladat a feltételeknek megfelelő lehetséges párok (x, y) számának kiszámítása:

Alice-nek meg kell nyernie a játékot a leírt szabályok szerint.
Az x virágok számának az óramutató járásával megegyező irányban az [1,n] tartományban kell lennie.
Az y virágok számának az óramutató járásával ellentétes irányban [1,m] tartományban kell lennie.

Adja vissza azoknak a lehetséges pároknak a számát (x, y), amelyek megfelelnek az utasításban említett feltételeknek.

1. példa:

Bemenet: n = 3, m = 2
Kimenet: 3
Magyarázat: A következő párok megfelelnek a nyilatkozatban leírt feltételeknek: (1,2), (3,2), (2,1).

2. példa:

Bemenet: n = 1, m = 1
Kimenet: 0
Magyarázat: Egyetlen pár sem felel meg az állításban leírt feltételeknek.

Korlátok:

1 <= n, m <= 10^5

Alice és Bob körökre osztott játékot játszanak egy virágokkal körülvett kör alakú mezőn. A kör a mezőt jelöli, és Alice és Bob között x virág van az óramutató járásával megegyező irányban, közöttük pedig y virág az óramutató járásával ellentétes irányban.
A játék a következőképpen zajlik:

Alice veszi az első kanyart.
A játékosnak minden körben az óramutató járásával megegyező vagy azzal ellentétes irányt kell választania, és választania kell egy virágot arról az oldalról.
A kör végén, ha már egyáltalán nem marad virág, az aktuális játékos elkapja ellenfelét és megnyeri a játékot.

Adott két egész szám, n és m, a feladat az, hogy kiszámítsuk a lehetséges párok számát (x, y), amelyek teljesítik a feltételeket:

Alice-nek meg kell nyernie a játékot a leírt szabályok szerint.
A virágok x számának az óramutató járásával megegyező irányban az [1,n] tartományban kell lennie.
Az y virágok számának az óramutató járásával ellentétes irányban az [1,m] tartományban kell lennie.

Adja vissza a lehetséges párok számát (x, y), amelyek megfelelnek az utasításban említett feltételeknek.

Példa 1:

Bemenet: n = 3, m = 2
Kimenet: 3
Magyarázat: A következő párok megfelelnek az utasításban leírt feltételeknek: (1,2), (3,2), (2,1).

Példa 2:

Bemenet: n = 1, m = 1
Kimenet: 0
Magyarázat: Egyetlen pár sem felel meg az utasításban leírt feltételeknek.

Korlátozások:

1 <= n, m <= 10^5


Adott egy 0 indexű, pozitív egész számokból álló nums tömb.
Egy művelettel felcserélhetünk két szomszédos elemet, ha ugyanannyi beállított bitjük van. Ezt a műveletet tetszőleges számúszor (beleértve a nullát is) végezheted el.
Igazat ad vissza, ha a tömböt rendezni tudja, különben hamisat ad vissza.

Példa 1:

Bemenet: nums = [8,4,2,30,15]
Kimenet: true
Magyarázat: Nézzük meg minden elem bináris ábrázolását. A 2, 4 és 8 számok egy-egy beállított bitet tartalmaznak „10”, „100” és „1000” bináris ábrázolással. A 15-ös és a 30-as számok egyenként négy beállított bitet tartalmaznak „1111” és „11110” bináris ábrázolással.
A tömböt 4 művelettel rendezhetjük:
- Felcseréljük a nums[0]-t a nums[1]-vel. Ez a művelet azért érvényes, mert a 8 és a 4 egy-egy beállított bittel rendelkezik. A tömb [4,8,2,30,15] lesz.
- A nums[1] felcserélése a nums[2]-vel. Ez a művelet érvényes, mert 8 és 2 egy-egy beállított bitje van. A tömb [4,2,8,30,15] lesz.
- Cseréljük fel a nums[0]-t a nums[1]-vel. Ez a művelet érvényes, mert a 4 és a 2 egy-egy beállított bitje van. A tömb [2,4,8,30,15] lesz.
- Cseréljük fel a nums[3]-t a nums[4]-gyel. Ez a művelet érvényes, mert 30 és 15 mindegyikének négy beállított bitje van. A tömb [2,4,8,15,30] lesz.
A tömb rendezetté vált, ezért true-t adunk vissza.
Megjegyezzük, hogy lehetnek más műveletsorozatok is, amelyek szintén rendezik a tömböt.

2. példa:

Bemenet: nums = [1,2,3,4,5].
Kimenet: true
Magyarázat: A tömb már rendezett, ezért true-t adunk vissza.

Példa 3:

Bemenet: nums = [3,16,8,4,2]
Kimenet: false
Magyarázat: Megmutatható, hogy a bemeneti tömböt nem lehet rendezni semmilyen műveletszámmal.

Korlátozások:

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

Kapsz egy 0-indexelt pozitív egész számokból álló tömböt.
Egy műveletben bármely két szomszédos elemet felcserélhet, ha azonos számú beállított bittel rendelkeznek. Ezt a műveletet tetszőleges számú alkalommal elvégezheti (beleértve a nullát is).
Igaz értéket ad vissza, ha rendezni tudja a tömböt, ellenkező esetben hamis értéket ad vissza.

Példa 1:

Bemenet: nums = [8,4,2,30,15]
Kimenet: true
Magyarázat: Nézzük meg minden elem bináris ábrázolását. A 2-es, 4-es és 8-as számoknak egy-egy beállított bitje van, amelyek bináris ábrázolása „10”, „100” és „1000”. A 15-ös és 30-as számoknak négy beállított bitje van, binárisan "1111" és "11110".
A tömböt 4 művelettel rendezhetjük:
- Cserélje fel a számokat[0] a számokkal[1]. Ez a művelet érvényes, mert a 8-nak és a 4-nek egy-egy set bitje van. A tömb a következőre változik: [4,8,2,30,15].
- Cserélje fel a számokat[1] a számokkal[2]. Ez a művelet érvényes, mert a 8-nak és a 2-nek egy-egy set bitje van. A tömb a következőre változik: [4,2,8,30,15].
- Cserélje fel a számokat[0] a számokkal[1]. Ez a művelet érvényes, mert a 4-nek és a 2-nek egy-egy set bitje van. A tömb a következő lesz: [2,4,8,30,15].
- Cserélje fel a számokat[3] a számokkal[4]. Ez a művelet érvényes, mert a 30-as és a 15-ösnek négy beállított bitje van. A tömb értéke [2,4,8,15,30] lesz.
A tömb rendezett lett, ezért igazat adunk vissza.
Vegye figyelembe, hogy lehetnek más műveleti sorozatok is, amelyek szintén rendezik a tömböt.

Példa 2:

Bemenet: nums = [1,2,3,4,5]
Kimenet: true
Magyarázat: A tömb már rendezve van, ezért igazat adunk vissza.

Példa 3:

Bemenet: nums = [3,16,8,4,2]
Kimenet: false
Magyarázat: Kimutatható, hogy a bemeneti tömb nem rendezhető tetszőleges számú művelettel.

Korlátozások:

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

Kapsz egy 0-indexelt pozitív egész számokból álló tömböt.
Egy műveletben bármely két szomszédos elemet felcserélhet, ha azonos számú beállított bittel rendelkeznek. Ezt a műveletet tetszőleges számú alkalommal elvégezheti (beleértve a nullát is).
Igaz értéket ad vissza, ha rendezheti a tömböt, ellenkező esetben hamis értéket ad vissza.

1. példa:

Bemenet: nums = [8,4,2,30,15]
Kimenet: igaz
Magyarázat: Nézzük meg minden elem bináris ábrázolását. A 2-es, 4-es és 8-as számoknak egy-egy beállított bitje van, amelyek bináris ábrázolása „10”, „100” és „1000”. A 15-ös és 30-as számoknak négy beállított bitje van, binárisan "1111" és "11110".
A tömböt 4 művelettel rendezhetjük:
- Cserélje fel a számokat[0] a számokkal[1]. Ez a művelet érvényes, mert a 8-nak és a 4-nek egy-egy set bitje van. A tömb értéke [4,8,2,30,15].
- Cserélje fel a számokat[1] a számokkal[2]. Ez a művelet érvényes, mert a 8-nak és a 2-nek egy-egy set bitje van. A tömb a következőre változik: [4,2,8,30,15].
- Cserélje fel a számokat[0] a számokkal[1]. Ez a művelet érvényes, mert a 4-nek és a 2-nek egy-egy set bitje van. A tömb a következő lesz: [2,4,8,30,15].
- Cserélje fel a számokat[3] a számokkal[4]. Ez a művelet érvényes, mert a 30-as és a 15-ösnek négy beállított bitje van. A tömb [2,4,8,15,30] lesz.
A tömb rendezett lett, ezért igazat adunk vissza.
Vegye figyelembe, hogy lehetnek más műveleti sorozatok is, amelyek szintén rendezik a tömböt.

2. példa:

Bemenet: nums = [1,2,3,4,5]
Kimenet: igaz
Magyarázat: A tömb már rendezve van, ezért igazat adunk vissza.

3. példa:

Bemenet: nums = [3,16,8,4,2]
Kimenet: hamis
Magyarázat: Kimutatható, hogy a bemeneti tömb nem rendezhető tetszőleges számú művelettel.

Korlátozások:

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


Adott két 1-indexált egész számtömb, nums és changeIndices, amelyek hossza n és m.
Kezdetben a nums összes indexe jelöletlen. A feladatunk az, hogy a nums összes indexét jelöljük.
Minden másodpercben, s, az 1-től m-ig (beleértve) terjedő sorrendben a következő műveletek egyikét végezheti el:

Válasszunk ki egy i indexet az [1, n] tartományban, és csökkentsük a nums[i] értékét 1-gyel.
Ha nums[changeIndices[s]] egyenlő 0-val, jelöljük meg az indexet changeIndices[s].
Ne tegyen semmit.

Adjon vissza egy egész számot, amely a [1, m] tartomány legkorábbi másodpercét jelöli, ha a nums összes indexét optimális műveletválasztással meg lehet jelölni, vagy -1-et, ha ez nem lehetséges.

Példa 1:

Bemenet: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Kimenet: 8
Magyarázat: Ebben a példában 8 másodperc áll rendelkezésünkre. Az összes index megjelölésére a következő műveletek végezhetők el:
Második 1: Válasszuk ki az 1-es indexet és csökkentsük eggyel a nums[1] értékét. nums [1,2,0] lesz.
Második 2: Válasszuk ki az 1-es indexet és csökkentsük eggyel a nums[1]-t. A nums [0,2,0] lesz.
Második 3: Válasszuk ki a 2. indexet és csökkentsük nums[2]-t eggyel. nums [0,1,0] lesz.
Második 4: Válasszuk ki a 2. indexet és csökkentsük nums[2]-t eggyel. nums [0,0,0] lesz.
Második 5: Jelöljük meg a changeIndices[5] indexet, ami a 3-as indexet jelöli, mivel nums[3] egyenlő 0-val.
Második 6: Jelöljük az index changeIndices[6]-t, amely a 2. indexet jelöli, mivel nums[2] egyenlő 0-val.
Második 7: Ne csináljunk semmit.
Második 8: Jelöljük az index changeIndices[8] indexet, amely az 1-es indexet jelöli, mivel nums[1] egyenlő 0-val.
Most már minden indexet megjelöltünk.
Megmutatható, hogy a 8. másodpercnél korábban nem lehet minden indexet megjelölni.
A válasz tehát 8.

Példa 2:

Bemenet: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Kimenet: 6
Magyarázat: Ebben a példában 7 másodperc áll rendelkezésünkre. Az összes index megjelölésére a következő műveletek végezhetők el:
Második 1: Válasszuk ki a 2. indexet, és csökkentsük eggyel a nums[2]-t. A nums [1,2] lesz.
Második 2: Válasszuk ki a 2. indexet, és csökkentsük a nums[2]-t eggyel. nums [1,1] lesz.
Második 3: Válasszuk ki a 2. indexet és csökkentsük a nums[2]-t eggyel. nums [1,0] lesz.
Második 4: Jelöljük meg az index changeIndices[4]-t, ami a 2-es indexet jelöli, mivel nums[2] egyenlő 0-val.
Második 5: Válasszuk ki az 1-es indexet és decrementáljuk eggyel nums[1]-t. nums [0,0] lesz.
Második 6: Jelöljük meg az indexet changeIndices[6], ami az 1-es indexet jelöli, mivel nums[1] egyenlő 0-val.
Most már minden indexet megjelöltünk.
Megmutatható, hogy a 6. másodpercnél korábban nem lehet minden indexet jelölni.
Ezért a válasz 6.

Példa 3:

Bemenet: nums = [0,1], changeIndices = [2,2,2]
Kimenet: -1
Magyarázat: Ebben a példában nem lehet minden indexet megjelölni, mert az 1. index nincs a changeIndices-ben.
Ezért a válasz -1.

Korlátozások:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n

Két 1-al kezdődő egész számokból álló tömb kapunk, a számokat és a changeIndexeket, amelyek n és m hosszúak.
Kezdetben minden számban szereplő index jelöletlen. Az Ön feladata, hogy minden indexet számokkal jelöljön meg.
Minden másodpercben, s, 1-től m-ig (beleértve) a következő műveletek egyikét hajthatja végre:

Válasszon egy i indexet az [1, n] tartományban, és csökkentse a számok[i] 1-gyel.
Ha a számok[changeIndexes[s]] egyenlő 0-val, jelölje be az index changeIndexes[s] indexet.
Ne csinálj semmit.

Az [1, m] tartomány legkorábbi másodpercét jelölő egész számot ad vissza, ha minden index számban jelölhető a műveletek optimális megválasztásával, vagy -1-et, ha ez lehetetlen.

Példa 1:

Bemenet: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Kimenet: 8
Magyarázat: Ebben a példában 8 másodpercünk van. A következő műveletek végezhetők az összes index megjelölésére:
Második 1: Válassza ki az 1. indexet, és csökkentse a számokat [1] eggyel. a számok [1,2,0]-ként változnak.
Második 2: Válassza ki az 1. indexet, és csökkentse a számokat [1] eggyel. a számokból [0,2,0] lesz.
Második 3: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. a számokból [0,1,0] lesz.
Második 4: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. a számokból [0,0,0] lesz.
Második 5: Jelölje be az indexet, amely a changeIndexes[5] értékével megegyezik, azaz a 3-as indexet, mivel a számok[3] 0-val egyenlő.
Második 6: Jelölje be az index changeIndexes[6] értéket, ami a 2-es indexet jelöli, mivel a számok[2] 0-val egyenlő.
Második 7: Ne csinálj semmit.
Második 8: Jelölje be az index changeIndexes[8] értéket, amely az 1-es indexet jelöli, mivel a számok[1] 0-val egyenlő.
Most már minden index meg lett jelölve.
Megmutatható, hogy nem lehet minden indexet a 8. másodpercnél korábban megjelölni.
Tehát a válasz a 8.

Példa 2:

Bemenet: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Kimenet: 6
Magyarázat: Ebben a példában 7 másodpercünk van. A következő műveletek végezhetők az összes index megjelölésére:
Második 1: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. számokból [1,2] lesz.
Második 2: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. számokból [1,1] lesz.
Második 3: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. a számokból [1,0] lesz.
Második 4: Jelölje be az index changeIndexes[4] értéket, amely a 2-es indexet jelöli, mivel a számok[2] 0-val egyenlő.
Második 5: Válassza ki az 1. indexet, és csökkentse a számokat [1] eggyel. a számokból [0,0] lesz.
Második 6: Jelölje be az index changeIndexes[6] értéket, amely az 1-es indexet jelöli, mivel a számok[1] 0-val egyenlő.
Most már minden index meg lett jelölve.
Megmutatható, hogy nem lehet minden indexet a 6. másodpercnél korábban megjelölni.
Ezért a válasz a 6.

Példa 3:

Bemenet: nums = [0,1], changeIndices = [2,2,2]
Kimenet: -1
Magyarázat: Ebben a példában lehetetlen megjelölni az összes indexet, mert az 1. index nincs a changeIndexesben.
Ezért a válasz -1.

Korlátozások:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n

Két 1-indexelt egész tömböt kapunk, a számokat és a changeIndexeket, amelyek n és m hosszúak.
Kezdetben minden számban szereplő index jelöletlen. Az Ön feladata, hogy minden indexet számokkal jelöljön meg.
Minden másodpercben, s, 1-től m-ig (beleértve) a következő műveletek egyikét hajthatja végre:

Válasszon egy i indexet az [1, n] tartományban, és csökkentse a számokat [i] 1-gyel.
Ha a számok[changeIndexes[s]] egyenlő 0-val, jelölje be az index changeIndexes[s] indexet.
Ne csinálj semmit.

Az [1, m] tartomány legkorábbi másodpercét jelölő egész számot ad vissza, ha minden index számban jelölhető a műveletek optimális megválasztásával, vagy -1-et, ha ez lehetetlen.

1. példa:

Bemenet: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Kimenet: 8
Magyarázat: Ebben a példában 8 másodpercünk van. A következő műveletek végezhetők az összes index megjelölésére:
Második 1: Válassza ki az 1. indexet, és csökkentse a számokat [1] eggyel. a számokból [1,2,0] lesz.
Második 2: Válassza ki az 1. indexet, és csökkentse a számokat [1] eggyel. a számokból [0,2,0] lesz.
Második 3: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. a számokból [0,1,0] lesz.
Második 4: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. a számokból [0,0,0] lesz.
Második 5: Jelölje be az index changeIndexes[5] értéket, amely a 3-as indexet jelöli, mivel a számok[3] 0-val egyenlő.
Második 6: Jelölje be az index changeIndexes[6] értéket, ami a 2-es indexet jelöli, mivel a számok[2] 0-val egyenlő.
Második 7: Ne csinálj semmit.
Második 8: Jelölje be az index changeIndexes[8] értéket, amely az 1-es indexet jelöli, mivel a számok[1] 0-val egyenlő.
Most már minden index meg lett jelölve.
Megmutatható, hogy nem lehet minden indexet a 8. másodpercnél korábban megjelölni.
Tehát a válasz a 8.

2. példa:

Bemenet: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Kimenet: 6
Magyarázat: Ebben a példában 7 másodpercünk van. A következő műveletek végezhetők az összes index megjelölésére:
Második 1: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. számokból [1,2] lesz.
Második 2: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. számokból [1,1] lesz.
Második 3: Válassza ki a 2. indexet, és csökkentse a számokat [2] eggyel. a számokból [1,0] lesz.
Második 4: Jelölje be az index changeIndexes[4] értéket, amely a 2-es indexet jelöli, mivel a számok[2] 0-val egyenlő.
Második 5: Válassza ki az 1. indexet, és csökkentse a számokat [1] eggyel. a számokból [0,0] lesz.
Második 6: Jelölje be az index changeIndexes[6] értéket, amely az 1-es indexet jelöli, mivel a számok[1] 0-val egyenlő.
Most már minden index meg lett jelölve.
Megmutatható, hogy nem lehet minden indexet a 6. másodpercnél korábban megjelölni.
Ezért a válasz a 6.

3. példa:

Bemenet: nums = [0,1], changeIndices = [2,2,2]
Kimenet: -1
Magyarázat: Ebben a példában lehetetlen megjelölni az összes indexet, mert az 1. index nem szerepel a changeIndexesben.
Ezért a válasz -1.

Korlátozások:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 10^9
1 <= m == changeIndices.length <= 2000
1 <= changeIndices[i] <= n


Adott egy 0-indexált karakterlánc szó és egy egész szám k.
Minden másodpercben a következő műveleteket kell végrehajtani:

Távolítsd el az első k karaktert a word-ből.
Adj hozzá tetszőleges k karaktert a word végéhez.

Megjegyzés: nem szükséges ugyanazokat a karaktereket hozzáadnod, amelyeket eltávolítottál. Azonban minden másodpercben mindkét műveletet el kell végezni.
Add vissza a minimális, nullánál nagyobb időt, amire szükség van, hogy a word visszatérjen eredeti állapotába.

Példa 1:

Bemenet: word = "abacaba", k = 3
Kimenet: 2
Magyarázat: Az 1. másodpercben eltávolítjuk az "aba" karaktereket a word előtagjából, és hozzáadjuk a "bac" karaktereket a word végéhez. Így a word "cababac" lesz.
A 2. másodpercben eltávolítjuk a "cab" karaktereket a word előtagjából, és hozzáadjuk az "aba" karaktereket a word végéhez. Így a word "abacaba" lesz, és visszatér eredeti állapotába.
Megmutatható, hogy 2 másodperc a minimális, nullánál nagyobb idő, amire szükség van, hogy a word visszatérjen eredeti állapotába.

Példa 2:

Bemenet: word = "abacaba", k = 4
Kimenet: 1
Magyarázat: Az 1. másodpercben eltávolítjuk az "abac" karaktereket a word előtagjából, és hozzáadjuk a "caba" karaktereket a word végéhez. Így a word "abacaba" lesz, és visszatér eredeti állapotába.
Megmutatható, hogy 1 másodperc a minimális, nullánál nagyobb idő, amire szükség van, hogy a word visszatérjen eredeti állapotába.

Példa 3:

Bemenet: word = "abcbabcd", k = 2
Kimenet: 4
Magyarázat: Minden másodpercben eltávolítjuk az első 2 karaktert a word-ből, és hozzáadjuk ugyanazokat a karaktereket a word végéhez.
4 másodperc elteltével a word "abcbabcd" lesz, és visszatér eredeti állapotába.
Megmutatható, hogy 4 másodperc a minimális, nullánál nagyobb idő, amire szükség van, hogy a word visszatérjen eredeti állapotába.

Korlátozások:

1 <= word.length <= 50
1 <= k <= word.length
word csak kisbetűs angol betűkből áll.

Kapsz egy 0 indexelt karakterláncszót és egy k egész számot.
Minden másodpercben a következő műveleteket kell végrehajtania:

Távolítsa el a szó első k karakterét.
Adjon hozzá bármilyen k karaktert a szó végéhez.

Ne feledje, hogy nem feltétlenül kell hozzáadnia ugyanazokat a karaktereket, amelyeket eltávolított. Azonban mindkét műveletet másodpercenként végre kell hajtania.
A nullánál hosszabb minimális idő visszaadása ahhoz, hogy a word visszatérjen eredeti állapotába.

1. példa:

Bemenet: word = "abacaba", k = 3
Kimenet: 2
Magyarázat: Az 1. másodpercben eltávolítjuk az "aba" karaktereket a szó előtagjából, és hozzáadjuk a "bac" karaktereket a szó végéhez. Így a szó egyenlő lesz a "cababac" -val.
A 2. másodpercben eltávolítjuk a "cab" karaktereket a szó előtagjából, és hozzáadjuk az "aba" szót a szó végéhez. Így a szó egyenlővé válik az "abacaba" -val, és visszatér eredeti állapotába.
Megmutatható, hogy 2 másodperc a nullánál hosszabb minimális idő, amely ahhoz szükséges, hogy a szó visszatérjen eredeti állapotába.

2. példa:

Bemenet: word = "abacaba", k = 4
Kimenet: 1
Magyarázat: Az 1. másodpercben eltávolítjuk az "abac" karaktereket a szó előtagjából, és hozzáadjuk a "caba" karaktereket a szó végéhez. Így a szó egyenlővé válik az "abacaba" -val, és visszatér eredeti állapotába.
Kimutatható, hogy 1 másodperc a nullánál hosszabb minimális idő, amely ahhoz szükséges, hogy a szó visszatérjen eredeti állapotába.

3. példa:

Bemenet: word = "abcbabcd", k = 2
Kimenet: 4
Magyarázat: Minden másodpercben eltávolítjuk a szó első 2 karakterét, és ugyanazokat a karaktereket adjuk hozzá a szó végéhez.
4 másodperc elteltével a szó egyenlővé válik az "abcbabcd" kifejezéssel, és visszatér eredeti állapotába.
Megmutatható, hogy 4 másodperc a nullánál hosszabb minimális idő, amely ahhoz szükséges, hogy a szó visszatérjen eredeti állapotába.

Korlátok:

1 <= word.length <= 50
1 <= k <= word.length
szó csak kisbetűs angol betűkből áll.


Kapsz egy 0-indexelt tömbszámot, amely pozitív egész számokból áll.
Kezdetben a tömb bármely elemének értékét legfeljebb 1-gyel növelheti.
Ezt követően ki kell választania egy vagy több elemet a végső tömbből úgy, hogy ezek az elemek egymást követő sorrendben legyenek. Például a [3, 4, 5] elemek egymást követik, míg a [3, 4, 6] és az [1, 1, 2, 3] nem.
A kiválasztható elemek maximális számát adja vissza.

1. példa:

Bemenet: nums= [2,1,5,1,1]
Kimenet: 3
Magyarázat: A 0 és 3 indexnél növelhetjük az elemeket. A kapott tömb a következő: nums = [3,1,5,2,1].
Kijelöljük a [3,1,5,2,1] elemeket, majd rendezzük őket, hogy megkapjuk az [1,2,3]-t, amelyek egymás után következnek.
Megmutatható, hogy nem tudunk 3-nál több egymást követő elemet kiválasztani.
2. példa:

Bemenet: nums = [1,4,7,10]
Kimenet: 1
Magyarázat: Legfeljebb 1 egymást követő elem választható.

Korlátozások:

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

Kap egy 0-indexelt tömböt, amely pozitív egész számokból áll.
Kezdetben a tömb bármely elemének értékét legfeljebb 1-gyel növelhet.
Ezt követően ki kell választania egy vagy több elemet a végső tömbből úgy, hogy ezek az elemek egymást kövesek, ha növekvő sorrendben vannak rendezve. Például a [3, 4, 5] elemek egymást követik, míg a [3, 4, 6] és [1, 1, 2, 3] elemek nem.
Adjuk vissza a kijelölhető elemek maximális számát.

1. példa:

Bemenet: nums = [2,1,5,1,1]
Kimenet: 3
Magyarázat: Növelhetjük az elemeket a 0 és 3 indexeknél. Az eredményül kapott tömb nums = [3,1,5,2,1].
Kiválasztjuk a [3,1,5,2,1] elemeket, és rendezzük őket, hogy megkapjuk az [1,2,3] elemeket, amelyek egymást követik.
Megmutatható, hogy nem lehet 3-nál több egymást követő elemet kiválasztani.
2. példa:

Bemenet: nums = [1,4,7,10]
Kimenet: 1
Magyarázat: A maximálisan kiválasztható egymást követő elemek 1.

Korlátok:

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

Kapsz egy 0-indexelt tömb számokat, amelyek pozitív egész számokból állnak.
Kezdetben a tömb bármely elemének értékét legfeljebb 1-gyel növelheti.
Ezt követően ki kell jelölnie egy vagy több elemet a végső tömbből úgy, hogy ezek az elemek egymást követő sorrendben legyenek, ha növekvő sorrendbe rendezik őket. Például a [3, 4, 5] elemek egymást követik, míg a [3, 4, 6] és az [1, 1, 2, 3] nem.
A kiválasztható elemek maximális számát adja vissza.

1. példa:

Bemenet: nums = [2,1,5,1,1]
Kimenet: 3
Magyarázat: A 0 és 3 indexnél növelhetjük az elemeket. A kapott tömb a következő: nums = [3,1,5,2,1].
Kiválasztjuk a [3,1,5,2,1] elemeket, majd rendezzük őket, hogy megkapjuk az [1,2,3] elemeket, amelyek egymás után következnek.
Megmutatható, hogy 3-nál több egymást követő elemet nem tudunk kiválasztani.
2. példa:

Bemenet: nums = [1,4,7,10]
Kimenet: 1
Magyarázat: Legfeljebb 1 egymást követő elem választható.

Korlátozások:

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


Adott egy pozitív egész számokat tartalmazó tömb, nums.
Ki kell választanod egy nums részhalmazát, amely megfelel a következő feltételnek:

Az így kiválasztott elemeket el lehet helyezni egy 0-indexű tömbben úgy, hogy követik a mintát: [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Megjegyzés: k lehet bármely nemnegatív 2 hatványa). Például, a [2, 4, 16, 4, 2] és a [3, 9, 3] követi a mintát, míg a [2, 4, 8, 4, 2] nem.

Add vissza a legnagyobb elemszámú részhalmazt, amely megfelel ezeknek a feltételeknek.

1. példa:

Bemenet: nums = [5,4,1,2,2]
Kimenet: 3
Magyarázat: Kiválaszthatjuk a {4,2,2} részhalmazt, amely elhelyezhető a tömbben mint [2,4,2], ami követi a mintát, és 2^2 == 4. A válasz ezért 3.

2. példa:

Bemenet: nums = [1,3,2,4]
Kimenet: 1
Magyarázat: Kiválaszthatjuk a {1} részhalmazt, amely elhelyezhető a tömbben mint [1], ami követi a mintát. Ezért a válasz 1. Megjegyzés: a {2}, {4} vagy {3} részhalmazok is választhatók, több részhalmaz is adhatja azonos választ.

Korlátozások:

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

Kapsz egy sor pozitív egész számot, nums.
Ki kell választania a számok egy részhalmazát, amely megfelel a következő feltételnek:

A kijelölt elemeket elhelyezheti egy 0 indexelt tömbben úgy, hogy az a következő mintát kövesse: [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Ne feledje, hogy k lehet a 2 bármely nem negatív hatványa). Például a [2, 4, 16, 4, 2] és [3, 9, 3] követi a mintát, míg a [2, 4, 8, 4, 2] nem.

Egy részhalmaz elemeinek maximális számát adja eredményül, amely megfelel ezeknek a feltételeknek.

1. példa:

Bemenet: nums = [5,4,1,2,2]
Kimenet: 3
Magyarázat: Kiválaszthatjuk a {4,2,2} részhalmazt, amely a tömbbe helyezhető [2,4,2] néven, amely követi a mintát és 2^2 == 4. Ezért a válasz 3.

2. példa:

Bemenet: nums = [1,3,2,4]
Kimenet: 1
Magyarázat: Kiválaszthatjuk a {1} részhalmazt, amely a mintát követve [1] -ként helyezhető el a tömbben. Ezért a válasz 1. Vegye figyelembe, hogy kiválaszthattuk volna a {2}, {4} vagy {3} részhalmazokat is, több részhalmaz is lehet, amelyek ugyanazt a választ adják.

Korlátok:

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

Pozitív egész számokból álló tömböt kapsz.
Ki kell választania a számok egy részhalmazát, amely megfelel a következő feltételnek:

A kiválasztott elemeket elhelyezheti egy 0-indexelt tömbben úgy, hogy az a mintát kövesse: [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Megjegyzendő, hogy k a 2 bármely nemnegatív hatványa lehet). Például a [2, 4, 16, 4, 2] és [3, 9, 3] követi a mintát, míg a [2, 4, 8, 4, 2] nem.

Egy részhalmaz elemeinek maximális számát adja vissza, amely megfelel ezeknek a feltételeknek.

1. példa:

Bemenet: nums = [5,4,1,2,2]
Kimenet: 3
Magyarázat: Kiválaszthatjuk a {4,2,2} részhalmazt, amely [2,4,2]-ként helyezhető el a tömbben, amely követi a mintát és 2^2 == 4. Ezért a válasz 3.

2. példa:

Bemenet: nums = [1,3,2,4]
Kimenet: 1
Magyarázat: Kiválaszthatjuk az {1} részhalmazt, amely a mintát követő [1]-ként helyezhető el a tömbben. Ezért a válasz 1. Ne feledje, hogy a {2}, {4} vagy {3} részhalmazokat is kiválaszthattuk volna, több részhalmaz is lehet, amelyek ugyanazt a választ adják.

Korlátozások:

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


Kapsz egy s karakterláncot.
Fontolja meg a következő művelet végrehajtását, amíg az s üres nem lesz:

Az 'a'-tól 'z'-ig tartó minden betű esetén távolítsa el az első előfordulást az s-ben (ha létezik).

Például legyen kezdetben s = "aabcbbca". A következő műveleteket végezzük:

Távolítsa el az aláhúzott karaktereket s = "aabcbbca". A kapott karakterlánc s = "abbca".
Távolítsa el az aláhúzott s = "abbca" karaktereket. Az eredményül kapott karakterlánc s = "ba".
Távolítsa el az aláhúzott s = "ba" karaktereket. Az eredményül kapott karakterlánc s = "".

Az utolsó művelet alkalmazása előtt adja vissza az s karakterlánc értékét. A fenti példában a válasz "ba".

1. példa:

Bemenet: s = "aabcbbca"
Kimenet: "ba"
Magyarázat: A nyilatkozatban kifejtve.

2. példa:

Bemenet: s = "abcd"
Kimenet: "abcd"
Magyarázat: A következő műveletet hajtjuk végre:
- Távolítsa el az aláhúzott karaktereket s = "abcd". Az eredményül kapott karakterlánc s = "".
Az utolsó művelet előtti karakterlánc „abcd”.

Korlátozások:

1 <= s.length <= 5 * 10^5
s csak kis angol betűkből áll.

Kapsz egy s karakterláncot.
Fontolja meg a következő művelet végrehajtását, amíg az s üres nem lesz:

Az ábécé minden karakteréből "a"-tól "z"-ig távolítsa el az adott karakter első előfordulását s-ből (ha létezik).

Például kezdetben s = "aabcbbca". A következő műveleteket végezzük:

Távolítsa el az aláhúzott s = "aabcbbca" karaktereket. A kapott karakterlánc s = "abbca".
Távolítsa el az aláhúzott s = "abbca" karaktereket. A kapott karakterlánc s = "ba".
Távolítsa el az aláhúzott s = "ba" karaktereket. Az eredményül kapott karakterlánc s = "".

Az s karakterlánc értékét adja vissza közvetlenül az utolsó művelet alkalmazása előtt. A fenti példában a válasz "ba".

1. példa:

Bemenet: s = "aabcbbca"
Kimenet: "ba"
Magyarázat: A nyilatkozatban kifejtve.

2. példa:

Bemenet: s = "abcd"
Kimenet: "abcd"
Magyarázat: A következő műveletet végezzük:
- Távolítsa el az aláhúzott s = "abcd" karaktereket. Az eredményül kapott karakterlánc s = "".
Az utolsó művelet előtti karakterlánc az "abcd".

Korlátok:

1 <= s.hossz <= 5 * 10^5
s csak kisbetűs angol betűkből áll.

Kapsz egy s karakterláncot.
Fontolja meg a következő művelet végrehajtását, amíg az s üres nem lesz:

Az ábécé minden karakteréből "a"-tól "z"-ig távolítsa el az adott karakter első előfordulását s-ből (ha létezik).

Például kezdetben s = "aabcbbca". A következő műveleteket végezzük:

Távolítsa el az aláhúzott s = "aabcbbca" karaktereket. A kapott karakterlánc s = "abbca".
Távolítsa el az aláhúzott s = "abbca" karaktereket. A kapott karakterlánc s = "ba".
Távolítsa el az aláhúzott s = "ba" karaktereket. Az eredményül kapott karakterlánc s = "".

Az s karakterlánc értékét adja vissza közvetlenül az utolsó művelet alkalmazása előtt. A fenti példában a válasz "ba".

1. példa:

Bemenet: s = "aabcbbca"
Kimenet: "ba"
Magyarázat: A nyilatkozatban kifejtve.

2. példa:

Bemenet: s = "abcd"
Kimenet: "abcd"
Magyarázat: A következő műveletet végezzük:
- Távolítsa el az aláhúzott s = "abcd" karaktereket. Az eredményül kapott karakterlánc s = "".
Az utolsó művelet előtti karakterlánc az "abcd".

Korlátok:

1 <= s.length <= 5 * 10^5
s csak kisbetűs angol betűkből áll.


0 indexelt karakterlánctömb szavakat kap.
Definiáljunk egy logikai függvényt, isPrefixAndSuffix, amely két sztringet vesz fel: str1 és str2:

isPrefixAndSuffix(str1, str2) igaz értéket ad vissza, ha az str1 az str2 előtagja és utótagja is, egyébként pedig hamis.

Például az isPrefixAndSuffix("aba", "ababa") igaz, mert az "aba" az "ababa" előtagja és egyben utótagja is, de az isPrefixAndSuffix("abc", "abcd") hamis.
Egy egész számot ad vissza, amely az indexpárok (i, j) számát jelöli úgy, hogy i < j, és isPrefixAndSuffix(words[i], words[j]) igaz.

1. példa:

Bemenet: words = ["a","aba","ababa","aa"]
Kimenet: 4
Magyarázat: Ebben a példában a megszámlált indexpárok a következők:
i = 0 és j = 1, mert isPrefixAndSuffix("a", "aba") igaz.
i = 0 és j = 2, mert isPrefixAndSuffix("a", "ababa") igaz.
i = 0 és j = 3, mert isPrefixAndSuffix("a", "aa") igaz.
i = 1 és j = 2, mert isPrefixAndSuffix("aba", "ababa") igaz.
Ezért a válasz 4.
2. példa:

Bemenet: words = ["pa","papa","ma","mama"]
Kimenet: 2
Magyarázat: Ebben a példában a megszámlált indexpárok a következők:
i = 0 és j = 1, mert isPrefixAndSuffix("pa", "papa") igaz.
i = 2 és j = 3, mert isPrefixAndSuffix("ma", "mama") igaz.
Ezért a válasz 2.
3. példa:

Bemenet: words = ["abab","ab"]
Kimenet: 0
Magyarázat: Ebben a példában az egyetlen érvényes indexpár i = 0 és j = 1, és isPrefixAndSuffix("abab", "ab") hamis.
Ezért a válasz 0.

Korlátok:

1 <= words.length <= 50
1 <= words[i].length <= 10
words[i] csak kisbetűs angol betűkből áll.

Adott egy 0-indexált string tömb words.
Definiáljunk egy boolean függvényt isPrefixAndSuffix, amely két stringet, str1-et és str2-t vesz fel:

isPrefixAndSuffix(str1, str2) true-t ad vissza, ha str1 egyszerre előtagja és utótagja str2-nek, és false-t, ha nem.

Például az isPrefixAndSuffix(„aba”, „ababa”) igaz, mert „aba” az „ababa” előtagja és utótagja is, de az isPrefixAndSuffix(„abc”, „abcd”) hamis.
Visszaad egy egész számot, amely az olyan indexpárok (i, j) számát jelöli, ahol i < j, és az isPrefixAndSuffix(words[i], words[j]) igaz.

Példa 1:

Bemenet: words = ["a","aba","ababa","aa"]
Kimenet: 4
Magyarázat: Ebben a példában a megszámlált indexpárok a következők:
i = 0 és j = 1, mert az isPrefixAndSuffix("a", "aba") igaz.
i = 0 és j = 2, mert az isPrefixAndSuffix("a", "ababa") igaz.
i = 0 és j = 3, mert az isPrefixAndSuffix("a", "aa") igaz.
i = 1 és j = 2, mert az isPrefixAndSuffix("aba", "ababa") igaz.
A válasz tehát 4.
2. példa:

Bemenet: words = ["pa","papa","ma","mama"]
Kimenet: 2
Magyarázat: Ebben a példában a megszámlált indexpárok a következők:
i = 0 és j = 1, mert az isPrefixAndSuffix("pa", "papa") igaz.
i = 2 és j = 3, mert az isPrefixAndSuffix("ma", "mama") igaz.
Ezért a válasz 2.
3. példa:

Bemenet: words = ["abab","ab"]
Kimenet: 0
Magyarázat: Ebben a példában az egyetlen érvényes indexpár i = 0 és j = 1, és az isPrefixAndSuffix("abab", "ab") hamis.
Ezért a válasz 0.

Korlátozások:

1 <= words.length <= 50
1 <= words[i].length <= 10
words[i] csak kisbetűs angol betűkből áll.

Kapsz egy 0-indexelt karakterlánc tömbszavakat.
Adjunk meg egy logikai függvényt: PrefixAndSuffix, amely két karakterláncot vesz fel, str1 és str2:

isPrefixAndSuffix(str1, str2) igazat ad vissza, ha az str1 az str2 előtagja és utótagja is, egyébként pedig false.

Például az isPrefixAndSuffix("aba", "ababa") igaz, mert az "aba" az "ababa" előtagja és egy utótagja is, de az isPrefixAndSuffix("abc", "abcd") hamis.
Egy egész számot ad vissza, amely az indexpárok (i, j) számát jelöli úgy, hogy i < j, és isPrefixAndSuffix(szavak[i], szavak[j]) igaz.

1. példa:

Bemenet: words = ["a", "aba", "ababa", "aa"]
Kimenet: 4
Magyarázat: Ebben a példában a megszámolt indexpárok a következők:
i = 0 és j = 1, mert az isPrefixAndSuffix("a", "aba") igaz.
i = 0 és j = 2, mert az isPrefixAndSuffix("a", "ababa") igaz.
i = 0 és j = 3, mert az isPrefixAndSuffix("a", "aa") igaz.
i = 1 és j = 2, mert az isPrefixAndSuffix("aba", "ababa") igaz.
Ezért a válasz a 4.
2. példa:

Bevitel: words = ["pa","papa","ma","mama"]
Kimenet: 2
Magyarázat: Ebben a példában a megszámolt indexpárok a következők:
i = 0 és j = 1, mert az isPrefixAndSuffix("pa", "papa") igaz.
i = 2 és j = 3, mert az isPrefixAndSuffix("ma", "mama") igaz.
Ezért a válasz a 2.
3. példa:

Bemenet: words = ["abab","ab"]
Kimenet: 0
Magyarázat: Ebben a példában az egyetlen érvényes indexpár az i = 0 és a j = 1, és az isPrefixAndSuffix("abab", "ab") hamis.
Ezért a válasz 0.

Korlátozások:

1 <= words.length <= 50
1 <= words[i].length <= 10
A szavak[i] csak kisbetűket tartalmaz angolul.


Egy hangya a határon van. Néha balra, néha jobbra megy.
Megadjuk a nullától eltérő egész számokból álló tömböt. A hangya elkezdi a számokat olvasni az első elemétől a végéig. Minden lépésnél az aktuális elem értékének megfelelően mozog:

Ha a szám[i] < 0, akkor -nums[i] egységekkel balra mozog.
Ha a szám[i] > 0, akkor a szám[i] egységekkel jobbra mozog.

Adja meg, hányszor tér vissza a hangya a határhoz.
Megjegyzések:

A határ mindkét oldalán végtelen tér van.
Csak a |nums[i]| elmozdulása után ellenőrizzük, hogy a hangya a határon van-e egységek. Más szóval, ha a hangya mozgása során átlépi a határt, az nem számít.

példa 1:

Bemenet: nums = [2,3,-5]
Kimenet: 1
Magyarázat: Az első lépés után a hangya 2 lépéssel jobbra van a határtól.
A második lépés után a hangya 5 lépéssel jobbra van a határtól.
A harmadik lépés után a hangya a határon van.
Tehát a válasz 1.

példa 2:

Bemenet: nums = [3,2,-3,-4]
Kimenet: 0
Magyarázat: Az első lépés után a hangya 3 lépéssel jobbra van a határtól.
A második lépés után a hangya 5 lépéssel jobbra van a határtól.
A harmadik lépés után a hangya 2 lépéssel jobbra van a határtól.
A negyedik lépés után a hangya 2 lépéssel balra van a határtól.
A hangya soha nem tért vissza a határhoz, így a válasz 0.

Korlátozások:

1 <= nums.length <= 100
-10 <= nums[i] <= 10
nums[i] != 0

Egy hangya a határon van. Néha balra, néha jobbra megy.
Megadjuk a nullától eltérő egész számokból álló tömböt. A hangya elkezdi a számokat olvasni az első elemétől a végéig. Minden lépésnél az aktuális elem értékének megfelelően mozog:

Ha a szám[i] < 0, akkor -nums[i] egységekkel balra mozog.
Ha a szám[i] > 0, akkor a szám[i] egységekkel jobbra mozog.

Adja meg, hányszor tér vissza a hangya a határhoz.
Megjegyzések:

A határ mindkét oldalán végtelen tér van.
Csak a |nums[i]| elmozdulása után ellenőrizzük, hogy a hangya a határon van-e egységek. Más szóval, ha a hangya mozgása során átlépi a határt, az nem számít.

1. példa:

Bemenet: nums = [2,3,-5]
Kimenet: 1
Magyarázat: Az első lépés után a hangya 2 lépéssel jobbra van a határtól.
A második lépés után a hangya 5 lépéssel jobbra van a határtól.
A harmadik lépés után a hangya a határon van.
Tehát a válasz 1.

2. példa:

Bemenet: nums = [3,2,-3,-4]
Kimenet: 0
Magyarázat: Az első lépés után a hangya 3 lépéssel jobbra van a határtól.
A második lépés után a hangya 5 lépéssel jobbra van a határtól.
A harmadik lépés után a hangya 2 lépéssel jobbra van a határtól.
A negyedik lépés után a hangya 2 lépéssel balra van a határtól.
A hangya soha nem tért vissza a határhoz, így a válasz 0.

Korlátozások:

1 <= nums.length <= 100
-10 <= nums[i] <= 10
nums[i] != 0

Egy hangya van egy határon. Néha balra, néha jobbra megy.
Nem nulla egész számok tömbjét kapja. A hangya elkezdi olvasni a számokat az első elemétől a végéig. Minden lépésben az aktuális elem értékének megfelelően mozog:

Ha a nums[i] < 0, akkor -nums[i] egységekkel balra mozog.
Ha a nums[i] > 0, akkor nums[i] egységekkel jobbra mozog.

Adja vissza, hogy a hangya hányszor tér vissza a határra.
Notes:

A határ mindkét oldalán végtelen tér van.
Csak akkor ellenőrizzük, hogy a hangya a határon van-e, miután elmozdult |nums[i]| Egységek. Más szóval, ha a hangya mozgása közben átlépi a határt, akkor nem számít.

1. példa:

Bemenet: nums = [2,3,-5]
Kimenet: 1
Magyarázat: Az első lépés után a hangya 2 lépéssel jobbra van a határtól.
A második lépés után a hangya 5 lépésre van a határtól jobbra.
A harmadik lépés után a hangya a határon van.
Tehát a válasz 1.

2. példa:

Bemenet: nums = [3,2,-3,-4]
Kimenet: 0
Magyarázat: Az első lépés után a hangya 3 lépésre van a határtól jobbra.
A második lépés után a hangya 5 lépésre van a határtól jobbra.
A harmadik lépés után a hangya 2 lépéssel jobbra van a határtól.
A negyedik lépés után a hangya 2 lépéssel balra van a határtól.
A hangya soha nem tért vissza a határra, így a válasz 0.

Korlátok:

1 <= nums.length <= 100
-10 <= nums[i] <= 10
nums[i] != 0


Egy 0-indexelt stringet, s, kaptál, amelyet egy felhasználó gépelt be. A billentyűk váltásának meghatározása az utoljára használt billentyűtől különböző billentyű használatát jelenti. Például s = "ab" esetén van billentyűváltás, míg s = "bBBb" esetén nincs.
Adja vissza, hogy a felhasználónak hányszor kellett billentyűt váltania.
Megjegyzés: Az olyan módosítók, mint a shift vagy a caps lock, nem számítanak a billentyűváltásba, tehát ha a felhasználó 'a' betűt írt, majd 'A' betűt, az nem tekintendő billentyűváltásnak.

1. példa:
Bemenet: s = "aAbBcC"
Kimenet: 2
Magyarázat:
s[0] = 'a'-tól s[1] = 'A'-ig nincs billentyűváltás, mivel a caps lock vagy a shift nem számít.
s[1] = 'A'-tól s[2] = 'b'-ig van billentyűváltás.
s[2] = 'b'-től s[3] = 'B'-ig nincs billentyűváltás, mivel a caps lock vagy a shift nem számít.
s[3] = 'B'-től s[4] = 'c'-ig van billentyűváltás.
s[4] = 'c'-től s[5] = 'C'-ig nincs billentyűváltás, mivel a caps lock vagy a shift nem számít.

2. példa:
Bemenet: s = "AaAaAaaA"
Kimenet: 0
Magyarázat: Nincs billentyűváltás, mivel csak az 'a' és 'A' betűk lettek megnyomva, ami nem igényel billentyűváltást.

Korlátozások:

1 <= s.length <= 100
s csak nagybetűs és kisbetűs angol betűkből áll.

Egy felhasználó által begépelt 0-indexelt karakterláncot kapsz. A kulcs megváltoztatása az utoljára használt kulcstól eltérő kulcs használata. Például az s = "ab" kulcs változást tartalmaz, míg az s = "bBBb" nem rendelkezik.
Adja meg, hogy a felhasználónak hányszor kellett kulcsot cserélnie.
Megjegyzés: Az olyan módosítók, mint a shift vagy a caps lock nem számítanak bele a billentyű megváltoztatásába, vagyis ha a felhasználó beírta az „a” betűt, majd az „A” betűt, akkor az nem számít billentyűváltásnak.

1. példa:

Bemenet: s = "aAbBcC"
Kimenet: 2
Magyarázat:
S[0] = 'a' értékről s[1] = 'A' értékre nem változik a billentyű, mivel a caps lock vagy a shift nem számít.
Az s[1] = 'A' értékről s[2] = 'b' értékre a kulcs megváltozik.
S[2] = 'b' értékről s[3] = 'B' értékre nem változik a billentyű, mivel a caps lock vagy a shift nem számít.
Az s[3] = 'B' értékről s[4] = 'c' értékre a kulcs megváltozik.
S[4] = 'c' értékről s[5] = 'C' értékre nem változik a billentyű, mivel a caps lock vagy a shift nem számít.

2. példa:

Bemenet: s = "AaAaAaaA"
Kimenet: 0
Magyarázat: Nincs gombcsere, mivel csak az 'a' és 'A' betűket nyomják le, ami nem igényli a billentyű megváltoztatását.

Korlátozások:

1 <= s.length <= 100
s csak nagy- és kisbetűkből áll angolul.

Kap egy 0 indexelt s karakterláncot, amelyet egy felhasználó ír be. A kulcs módosítása az utoljára használt kulcstól eltérő kulcs használata. Például az s = "ab" kulcsváltozással rendelkezik, míg az s = "bBBb" nem rendelkezik ilyennel.
Visszaadja, hogy a felhasználónak hányszor kellett módosítania a kulcsot.
Megjegyzés: Az olyan módosítók, mint a shift vagy a caps lock, nem számítanak bele a billentyű módosításába, azaz ha a felhasználó beírta az "a" betűt, majd az "A" betűt, akkor az nem számít billentyűváltásnak.

1. példa:

Bemenet: s = "aAbBcC"
Kimenet: 2
Magyarázat:
s[0] = 'a' és s[1] = 'A' között nincs billentyűcsere, mivel a caps lock vagy shift nem számít.
s[1] = 'A'-ról s[2] = 'b'-re változik a kulcs.
s[2] = 'b'-től s[3] = 'B'-ig nincs billentyűcsere, mivel a caps lock vagy shift nem számít.
s[3] = 'B'-ről s[4] = 'c'-re változik a kulcs.
s[4] = 'c' és s[5] = 'C' között nincs billentyűcsere, mivel a caps lock vagy shift nem számít.

2. példa:

Bemenet: s = "AaAaAaaA"
Kimenet: 0
Magyarázat: Nincs kulcscsere, mivel csak az "a" és "A" betűket nyomja meg, ami nem igényel kulcscserét.

Korlátok:

1 <= s.length <= 100
s csak kis- és nagybetűkből áll.


Egy 0-indexelt karakterlánc-tömböt kapunk, amelyek n hosszúságúak és 0-indexelt karakterláncokat tartalmaznak.
A következő műveletet tetszőleges számú alkalommal végezheti el (beleértve a nullát is):

Válassza ki az i, j, x és y egész számokat úgy, hogy 0 <= i, j < n, 0 <= x < szavak[i][x].hossz, 0 <= y < szavak[j].hossz, és cserélje fel a karaktereket szavak[i][x] és szavak[j][y].

Egy egész számot ad vissza, amely jelöli a szavak maximális palindromszámát, néhány művelet végrehajtása után.
Megjegyzés: i és j egyenlő lehet a művelet során.

Példa 1:

Bemenet: words = ["abbb","ba","aa"]
Kimenet: 3
Magyarázat: Ebben a példában az egyik módja a maximális palindrómák elérésének a következő:
Válassza i = 0, j = 1, x = 0, y = 0, így cseréljük a words[0][0] és words[1][0] karaktereket. A words így néz ki: ["bbbb","aa","aa"].
Minden karakterlánc a words-ben most palindróma.
Ezért a maximálisan elérhető palindrómák száma 3.
Példa 2:

Bemenet: words = ["abc","ab"]
Kimenet: 2
Magyarázat: Ebben a példában az egyik módja a maximális palindrómák elérésének a következő:
Válassza i = 0, j = 1, x = 1, y = 0, így cseréljük a words[0][1] és words[1][0] karaktereket. A words így néz ki: ["aac","bb"].
Válassza i = 0, j = 0, x = 1, y = 2, így cseréljük a words[0][1] és words[0][2] karaktereket. A words így néz ki: ["aca","bb"].
Mindkét szó most palindróma.
Ezért az elérhető palindromok maximális száma 2.

Példa 3:

Bemenet: words = ["cd","ef","a"]
Kimenet: 1
Magyarázat: Ebben a példában nincs szükség semmilyen művelet végrehajtására.
A words-ben van egy palindróma, "a".
Kimutatható, hogy egynél több palindromot nem lehet kapni akárhány műtét után.
Ezért a válasz az 1.

Korlátozások:

1 <= words.length <= 1000
1 <= words[i].length <= 100
words[i] csak kisbetűs angol betűkből áll.

Egy 0-indexelt karakterlánc-tömböt kapunk, amelyek n hosszúságúak és 0-indexelt karakterláncokat tartalmaznak.
A következő műveletet tetszőleges számú alkalommal végezheti el (beleértve a nullát is):

Válassza ki az i, j, x és y egész számokat úgy, hogy 0 <= i, j < n, 0 <= x < szavak[i].hossz, 0 <= y < szavak[j].hossz, és cserélje fel a karaktereket szavakkal [i][x] és szavak[j][y].

Egy egész számot ad vissza, amely jelöli a szavak maximális számú palindromját, néhány művelet végrehajtása után.
Megjegyzés: i és j egyenlő lehet egy művelet során.

1. példa:

Bemenet: words = ["abbb", "ba", "aa"]
Kimenet: 3
Magyarázat: Ebben a példában a palindromok maximális számának elérésének egyik módja a következő:
Válassza az i = 0, j = 1, x = 0, y = 0 értéket, így felcseréljük a szavakat[0][0] és a szavakat[1][0]. szavakból ["bbbb", "aa", "aa"] lesz.
A szavak összes karakterlánca most palindrom.
Ezért az elérhető palindromok maximális száma 3.
2. példa:

Bemenet: words = ["abc","ab"]
Kimenet: 2
Magyarázat: Ebben a példában a palindromok maximális számának elérésének egyik módja a következő:
Válassza az i = 0, j = 1, x = 1, y = 0 értéket, így felcseréljük a szavakat[0][1] és a szavakat[1][0]. szavakból ["aac","bb"] lesz.
Válassza az i = 0, j = 0, x = 1, y = 2 lehetőséget, így felcseréljük a szavakat[0][1] és a szavakat[0][2]. szavakból ["aca","bb"] lesz.
Mindkét húr most palindrom.
Ezért az elérhető palindromok maximális száma 2.

3. példa:

Bemenet: words = ["cd","ef","a"]
Kimenet: 1
Magyarázat: Ebben a példában nincs szükség semmilyen művelet végrehajtására.
Az "a" szavakban egy palindrom található.
Kimutatható, hogy egynél több palindromot nem lehet kapni akárhány műtét után.
Ezért a válasz az 1.

Korlátozások:

1 <= words.length <= 1000
1 <= words[i].length <= 100
words[i] consists only of lowercase English letters.

Kap egy 0-indexelt sztring tömböt, amely tartalmaz szavakat, amelyek hossza n és 0-indexelt karakterláncokat tartalmaz.
A következő műveletet tetszőleges számú alkalommal hajthatja végre (beleértve a nullát is):

Válasszon i, j, x és y egész számokat úgy, hogy 0 <= i, j < n, 0 <= x < words[i].length, 0 <= y < words[i].length, és cserélje fel a karaktereket: words[i][x] és words[j][y].

Egy művelet végrehajtása után visszaad egy egész számot, amely a szavakban található palindromok maximális számát jelöli.
Megjegyzés: i és j egyenlő lehet egy művelet során.

1. példa:

Bemenet: words = ["abbb","ba","aa"]
Kimenet: 3
Magyarázat: Ebben a példában a palindromok maximális számának megszerzésének egyik módja:
Válassza az i = 0, j = 1, x = 0, y = 0 lehetőséget, így felcseréljük words[0][0] és words[1][0]. A words ["bbbb", "aa", "aa"] lesznek.
Minden szó most palindrom.
Ezért az elérhető palindromok maximális száma 3.
2. példa:

Bemenet: words = ["abc","ab"]
Kimenet: 2
Magyarázat: Ebben a példában a palindromok maximális számának megszerzésének egyik módja:
Válassza az i = 0, j = 1, x = 1, y = 0 lehetőséget, így felcseréljük words[0][1] és words[1][0]. words ["AAC","BB"] lesznek.
Válassza az i = 0, j = 0, x = 1, y = 2 lehetőséget, így felcseréljük words[0][1] és words[0][2]. words ["aca", "bb"] lesznek.
Mindkét húr most palindrom.
Ezért az elérhető palindromok maximális száma 2.

3. példa:

Bemenet: words = ["cd","ef","a"]
Kimenet: 1
Magyarázat: Ebben a példában nincs szükség semmilyen művelet végrehajtására.
Van egy palindrom az "a" szavakban.
Kimutatható, hogy tetszőleges számú műtét után nem lehet egynél több palindromot kapni.
Ezért a válasz 1.

Korlátok:

1 <= words.length <= 1000
1 <= words[i].length <= 100
words[i] csak kisbetűs angol betűkből áll.


A nums nevű egész számok tömbje esetén a következő műveletet hajthatja végre, miközben a nums legalább 2 elemet tartalmaz:

Válassza ki a nums első két elemét, és törölje őket.

A művelet pontszáma a törölt elemek összege.
A feladat az, hogy megtalálja a végrehajtható műveletek maximális számát, hogy minden művelet azonos pontszámmal rendelkezzen.
Adja vissza a fent említett feltételnek megfelelő lehetséges műveletek maximális számát.

1. példa:

Bemenet: nums = [3,2,1,4,5]
Kimenet: 2
Magyarázat: A következő műveleteket hajtjuk végre:
- Az első két elem törlése, pontszám 3 + 2 = 5, nums = [1,4,5].
- Törölje az első két elemet, pontszám 1 + 4 = 5, nums = [5].
Nem tudunk több műveletet végrehajtani, mivel a numok csak 1 elemet tartalmaznak.
2. példa:

Bemenet: nums = [3,2,6,1,4]
Kimenet: 1
Magyarázat: A következő műveleteket hajtjuk végre:
- Az első két elem törlése, pontszám 3 + 2 = 5, nums = [6,1,4].
Nem tudunk több műveletet végrehajtani, mivel a következő művelet pontszáma nem egyezik meg az előzővel.

Korlátok:

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

Ha adott egy nums nevű egész számok listája, akkor a következő műveletet hajthatja végre, miközben a számok legalább 2 elemet tartalmaznak:

Válassza ki a elem első két elemét, és törölje őket.

A művelet pontszáma a törölt elemek összege.
Az Ön feladata, hogy megtalálja a legtöbb olyan műveletet, amelyek mindegyike ugyanolyan pontszámot érnek el.
Adja vissza a lehetséges legtöbb műveletet, amelyek megfelelnek a fent említett feltételnek.

1. példa:

Bemenet: nums = [3,2,1,4,5]
Kimenet: 2
Magyarázat: A következő műveleteket hajtjuk végre:
- Törölje az első két elemet, ahol a pontszám 3 + 2 = 5, nums = [1,4,5].
- Törölje az első két elemet, 1 + 4 = 5, nums = [5].
Nem tudunk több műveletet végrehajtani, mivel a tömbben csak 1 elem maradt.
2. példa:

Bemenet: nums = [3,2,6,1,4]
Kimenet: 1
Magyarázat: A következő műveleteket hajtjuk végre:
- Törölje az első két elemet, ahol a pontszám 3 + 2 = 5, nums = [6,1,4].
Nem tudunk több műveletet végrehajtani, mivel a következő művelet pontszáma nem egyezik meg az előzővel.

Korlátozások:

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

Ha adott egy nums nevű egész számok listája, akkor a következő műveletet hajthatja végre, miközben a számok legalább 2 elemet tartalmaznak:

Válassza ki a szám első két elemét, és törölje őket.

A művelet pontszáma a törölt elemek összege.
Az Ön feladata, hogy megtalálja a legtöbb olyan műveletet, amelyek mindegyike ugyanolyan pontszámot érnek el.
Adja vissza a lehetséges legtöbb műveletet, amelyek megfelelnek a fent említett feltételnek.

Példa 1:

Bemenet: nums = [3,2,1,4,5]
Kimenet: 2
Magyarázat: A következő műveleteket hajtjuk végre:
- Törölje az első két elemet, ahol a pontszám 3 + 2 = 5, nums = [1,4,5].
- Törölje az első két elemet, 1 + 4 = 5, nums = [5].
Nem tudunk több műveletet végrehajtani, mivel a számok csak 1 elemet tartalmaznak.
Példa 2:

Bemenet: nums = [3,2,6,1,4]
Kimenet: 1
Magyarázat: A következő műveleteket hajtjuk végre:
- Törölje az első két elemet, ahol a pontszám 3 + 2 = 5, nums = [6,1,4].
Nem tudunk több műveletet végrehajtani, mivel a következő művelet pontszáma nem egyezik meg az előzővel.

Korlátozások:

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


Páros hosszúságú egész tömbszámot kap. A tömböt két részre kell osztania nums1 és nums2 úgy, hogy:

nums1.length == nums2.length == nums.length / 2.
A nums1 elemnek különálló elemeket kell tartalmaznia.
A nums2-nek különálló elemeket is tartalmaznia kell.

Igaz értéket ad vissza, ha lehetséges a tömb felosztása, egyébként pedig hamis.

1. példa:

Bemenet: nums = [1,1,2,2,3,4]
Kimenet: true
Magyarázat: A számok felosztásának egyik lehetséges módja a nums1 = [1,2,3] és nums2 = [1,2,4].

2. példa:

Bemenet: nums = [1,1,1,1]
Kimenet: false
Magyarázat: A számok felosztásának egyetlen lehetséges módja a nums1 = [1,1] és nums2 = [1,1]. A nums1 és a nums2 sem tartalmaz különálló elemeket. Ezért hamis értéket adunk vissza.

Korlátok:

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

Kapsz egy egész számokból álló tömb páros hosszúságú számokat. A tömböt két részre, szám1 és szám2 részre kell osztania, így:

szám1.length == nums2.length == nums.length / 2.
A nums1-nek különálló elemeket kell tartalmaznia.
A nums2-nek különálló elemeket is tartalmaznia kell.

Igaz értéket ad vissza, ha lehetséges a tömb felosztása, és hamis értéket egyébként.

1. példa:

Bemenet: nums = [1,1,2,2,3,4]
Kimenet: igaz
Magyarázat: A számok felosztásának egyik lehetséges módja a nums1 = [1,2,3] és a nums2 = [1,2,4].

2. példa:

Bemenet: nums = [1,1,1,1]
Kimenet: hamis
Magyarázat: A számok felosztásának egyetlen lehetséges módja a nums1 = [1,1] és a nums2 = [1,1]. A nums1 és a nums2 nem tartalmaz különálló elemeket. Ezért hamisat adunk vissza.

Korlátozások:

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

Kapsz egy egész tömb páros hosszúságú nums. A tömböt két részre, nums1 és nums2 részre kell osztania, így:

nums1.length == nums2.length == nums.length / 2.
A nums1-nek különálló elemeket kell tartalmaznia.
A nums2-nek különálló elemeket is tartalmaznia kell.

Igaz értéket ad vissza, ha lehetséges a tömb felosztása, és hamis értéket egyébként.

1. példa:

Bemenet: nums = [1,1,2,2,3,4]
Kimenet: igaz
Magyarázat: A számok felosztásának egyik lehetséges módja a nums1 = [1,2,3] és nums2 = [1,2,4].

2. példa:

Bemenet: nums = [1,1,1,1]
Kimenet: hamis
Magyarázat: A számok felosztásának egyetlen lehetséges módja a nums1 = [1,1] és nums2 = [1,1]. Mind nums1, mind nums2 nem tartalmaz különálló elemeket. Ezért hamisat adunk vissza.

Korlátozások:

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


Két tömböt kapunk pozitív egész számokkal: arr1 és arr2.
A pozitív egész szám előtagja olyan egész szám, amelyet egy vagy több számjegye alkot, a bal szélső számjegyétől kezdve. Például a 123 az 12345 egész szám előtagja, míg a 234 nem.
Két a és b egész szám közös előtagja egy c egész szám, így c mind a, mind b előtagja. Például az 5655359 és az 56554 közös 565-ös előtaggal rendelkezik, míg az 1223 és a 43456 nem rendelkezik közös előtaggal.
Meg kell találnia a leghosszabb közös előtag hosszát az egész számok (x, y) összes párja között úgy, hogy x az arr1-hez tartozik, y pedig az arr2-hez.
Az összes pár leghosszabb közös előtagjának hosszát adja vissza. Ha nincs közös előtag közöttük, adja vissza a 0 értéket.

1. példa:

Bemenet: arr1 = [1,10,100], arr2 = [1000]
Kimenet: 3
Magyarázat: 3 pár van (arr1[i], arr2[j]):
- Az (1, 1000) leghosszabb közös előtagja 1.
- A (10, 1000) leghosszabb közös előtagja 10.
- A (100, 1000) leghosszabb közös előtagja 100.
A leghosszabb közös előtag 100, hossza 3.

2. példa:

Bemenet: arr1 = [1,2,3], arr2 = [4,4,4]
Kimenet: 0
Magyarázat: Egyetlen párnak sincs közös előtagja (arr1[i], arr2[j]), ezért 0-t adunk vissza.
Vegye figyelembe, hogy az ugyanazon tömb elemei közötti közös előtagok nem számítanak.

Korlátok:

1 <= arr1.length, arr2.length <= 5 * 10^4
1 <= arr1[i], arr2[i] <= 10^8

Kapunk két tömböt pozitív egész számokkal arr1 és arr2.
A pozitív egész szám előtagja egy vagy több számjegyéből álló egész szám, amely a bal szélső számjegyétől kezdődik. Például a 123 az 12345 egész szám előtagja, míg a 234 nem.
Két a és b egész szám közös előtagja egy c egész szám, így c mind a, mind b előtagja. Például az 5655359 és az 56554 közös előtagja 565, míg az 1223-nak és a 43456-nak nincs közös előtagja.
Meg kell találni a leghosszabb közös előtag hosszát az összes (x, y) egész számpár között úgy, hogy x az arr1-hez, y pedig az arr2-hez tartozik.
Az összes pár közül a leghosszabb közös előtag hosszát adja vissza. Ha nincs közös előtag közöttük, adja vissza a 0-t.

1. példa:

Bemenet: arr1 = [1,10,100], arr2 = [1000]
Kimenet: 3
Magyarázat: 3 pár van (arr1[i], arr2[j]):
- Az (1, 1000) leghosszabb közös előtagja az 1.
- A (10, 1000) leghosszabb közös előtagja a 10.
- A (100, 1000) leghosszabb közös előtagja a 100.
A leghosszabb közös előtag a 100, amelynek hossza 3.

2. példa:

Bemenet: arr1 = [1,2,3], arr2 = [4,4,4]
Kimenet: 0
Magyarázat: Egyik párhoz sem létezik közös előtag (arr1[i], arr2[j]), ezért 0-t adunk vissza.
Vegye figyelembe, hogy az azonos tömb elemei közötti közös előtagok nem számítanak.

Korlátozások:

1 <= arr1.length, arr2.length <= 5 * 10^4
1 <= arr1[i], arr2[i] <= 10^8


Adott egy 0-indexált egész szám tömb nums és egy egész szám k.
Egy művelettel eltávolíthatod a nums legkisebb elemének egyik előfordulását.
Add vissza a minimális műveletek számát, amelyek szükségesek ahhoz, hogy a tömb összes eleme nagyobb vagy egyenlő legyen k-nál.
Példa 1:

Bemenet: nums = [2,11,10,1,3], k = 10
Kimenet: 3
Magyarázat: Egy művelet után nums az alábbiakkal egyenlő lesz: [2, 11, 10, 3].
Két művelet után nums az alábbiakkal egyenlő lesz: [11, 10, 3].
Három művelet után nums az alábbiakkal egyenlő lesz: [11, 10].
Ebben a fázisban nums összes eleme nagyobb vagy egyenlő 10-nél, így abbahagyhatjuk.
Megmutatható, hogy 3 a minimális műveletek száma, amely szükséges ahhoz, hogy a tömb összes eleme nagyobb vagy egyenlő legyen 10-nél.

Példa 2:

Bemenet: nums = [1,1,2,4,9], k = 1
Kimenet: 0
Magyarázat: A tömb összes eleme nagyobb vagy egyenlő 1-nél, így nem szükséges műveleteket alkalmazni nums-ra.

Példa 3:

Bemenet: nums = [1,1,2,4,9], k = 9
Kimenet: 4
Magyarázat: csak egyetlen eleme van nums-nak, amely nagyobb vagy egyenlő 9-nél, így 4-szer kell műveleteket alkalmaznunk nums-ra.

Korlátozások:

1 <= nums.length <= 50
1 <= nums[i] <= 10^9
1 <= k <= 10^9
A bemenet úgy van generálva, hogy legalább egy index i létezik, amelyre nums[i] >= k.

Kap egy 0 indexelt egész tömb számát és egy k egész számot.
Egy művelettel eltávolíthatja a nums legkisebb elemének egy előfordulását.
Adja vissza a minimálisan szükséges műveletek számát, hogy a tömb minden eleme nagyobb vagy egyenlő legyen k-val.

1. példa:

Bemenet:nums = [2,11,10,1,3], k = 10
Kimenet: 3
Magyarázat: Egy művelet után nums egyenlővé válnak [2, 11, 10, 3].
Két művelet után nums egyenlőek lesznek [11, 10, 3].
Három művelet után nums egyenlőek lesznek [11, 10].
Ebben a szakaszban a numok összes eleme nagyobb vagy egyenlő 10-nél, így megállhatunk.
Megmutatható, hogy 3 a szükséges műveletek minimális száma, hogy a tömb minden eleme nagyobb vagy egyenlő legyen 10-nél.

2. példa:

Bemenet: nums = [1,1,2,4,9], k = 1
Kimenet: 0
Magyarázat: A tömb minden eleme nagyobb vagy egyenlő 1-gyel, így nem kell semmilyen műveletet alkalmaznunk a numokra.
3. példa:

Bemenet: nums = [1,1,2,4,9], k = 9
Kimenet: 4
Magyarázat: a numoknak csak egyetlen eleme nagyobb vagy egyenlő 9-cel, ezért a műveleteket 4-szer kell alkalmaznunk a számokon.

Korlátok:

1 <= nums.length <= 50
1 <= nums[i] <= 10^9
1 <= k <= 10^9
A bemenet úgy jön létre, hogy legalább egy i index legyen úgy, hogy nums[i] >= k.

Kapsz egy 0-indexelt egész tömb számot és egy k egész számot.
Egy művelettel eltávolíthatja a számok legkisebb elemét egy alkalommal.
Adja vissza a szükséges minimális számú műveletet, hogy a tömb minden eleme nagyobb vagy egyenlő legyen k-nál.

1. példa:

Bemenet: nums  = [2,11,10,1,3], k = 10
Kimenet: 3
Magyarázat: Egy művelet után a számok egyenlővé válnak [2, 11, 10, 3] értékkel.
Két művelet után a számok egyenlővé válnak a [11, 10, 3] értékkel.
Három művelet után a számok egyenlővé válnak a [11, 10] értékkel.
Ebben a szakaszban a számok összes eleme nagyobb vagy egyenlő 10-nél, így meg tudjuk állni.
Megmutatható, hogy 3 a szükséges műveletek minimális száma ahhoz, hogy a tömb minden eleme nagyobb vagy egyenlő legyen 10-nél.

2. példa:

Bemenet: nums = [1,1,2,4,9], k = 1
Kimenet: 0
Magyarázat: A tömb minden eleme nagyobb vagy egyenlő, mint 1, így nem kell semmilyen műveletet végrehajtanunk a számokra.
3. példa:

Bemenet: nums = [1,1,2,4,9], k = 9
Kimenet: 4
Magyarázat: a számoknak csak egyetlen eleme nagyobb vagy egyenlő 9-nél, ezért a műveleteket 4-szer kell végrehajtanunk a számokra.

Korlátozások:

1 <= nums.length <= 50
1 <= nums[i] <= 10^9
1 <= k <= 10^9
A bemenetet úgy állítjuk elő, hogy legyen legalább egy olyan i index, amelyre nums[i] >= k.


Adott egy n hosszúságú nums különböző egész számok 1-indexált tömbje.
A nums összes elemét el kell osztani két tömb arr1 és arr2 között n művelettel. Az első műveletben csatoljuk nums[1]-t arr1-hez. A második műveletben csatolja nums[2]-t arr2-hez. Ezután az i^-edik műveletben:

Ha az arr1 utolsó eleme nagyobb, mint az arr2 utolsó eleme, akkor a nums[i]-t csatoljuk az arr1-hez. Ellenkező esetben a nums[i] elemet csatoljuk arr2-hez.

A tömb eredményét az arr1 és arr2 tömbök összekapcsolásával kapjuk. Például, ha arr1 == [1,2,3] és arr2 == [4,5,6], akkor az eredmény = [1,2,3,4,5,6].
Visszaadja a tömb eredményét.

Példa 1:

Bemenet: nums = [2,1,3]
Kimenet: [2,3,1]
Magyarázat: Az első két művelet után arr1 = [2] és arr2 = [1].
A 3^. műveletben, mivel arr1 utolsó eleme nagyobb, mint arr2 utolsó eleme (2 > 1), a nums[3]-t csatoljuk arr1-hez.
A 3 művelet után arr1 = [2,3] és arr2 = [1].
Tehát az összefűzéssel képzett tömb eredménye [2,3,1].

2. példa:

Bemenet: nums = [5,4,3,8]
Kimenet: [5,3,4,8]
Magyarázat: Az első két művelet után arr1 = [5] és arr2 = [4].
A 3^. műveletben, mivel arr1 utolsó eleme nagyobb, mint arr2 utolsó eleme (5 > 4), a nums[3]-t csatoljuk arr1-hez, így arr1 [5,3] lesz.
A 4^. műveletben, mivel arr2 utolsó eleme nagyobb, mint arr1 utolsó eleme (4 > 3), csatoljuk a nums[4]-et arr2-hez, így arr2 [4,8] lesz.
A 4 művelet után arr1 = [5,3] és arr2 = [4,8].
Tehát az összefűzéssel képzett tömb eredménye [5,3,4,8].

Korlátozások:

3 <= n <= 50
1 <= nums[i] <= 100
A nums minden eleme különálló.

Az n hosszúságú, különböző egész számokat tartalmazó, 1-indexelt nums tömb adott.
A nums összes elemét el kell osztania két arr1 és arr2 tömb között n művelettel. Az első műveletben fűzze hozzá a nums[1] az arr1-hez. A második műveletben fűzze hozzá a nums[2] az arr2-hez. Ezt követően az i^. műveletben:

Ha az arr1 utolsó eleme nagyobb, mint az arr2 utolsó eleme, fűzze hozzá a nums[i] az arr1-hez. Ellenkező esetben fűzze hozzá a számokat[i] az arr2-hez.

A tömb eredménye az arr1 és arr2 tömbök összefűzésével jön létre. Például, ha arr1 == [1,2,3] és arr2 == [4,5,6], akkor az eredmény = [1,2,3,4,5,6].
Adja vissza a tömb eredményét.

1. példa:

Bemenet: nums = [2,1,3]
Kimenet: [2,3,1]
Magyarázat: Az első 2 művelet után arr1 = [2] és arr2 = [1].
A 3^. műveletben, mivel az arr1 utolsó eleme nagyobb, mint az arr2 utolsó eleme (2 > 1), adjon hozzá nums[3] az arr1-hez.
3 művelet után arr1 = [2,3] és arr2 = [1].
Így az összefűzéssel kapott tömb eredménye [2,3,1].

2. példa:

Bemenet: nums = [5,4,3,8]
Kimenet: [5,3,4,8]
Magyarázat: Az első 2 művelet után arr1 = [5] és arr2 = [4].
A 3^. műveletben, mivel az arr1 utolsó eleme nagyobb, mint az arr2 utolsó eleme (5 > 4), fűzze hozzá a nums[3] az arr1-hez, így arr1 lesz [5,3].
A 4^. műveletben, mivel az arr2 utolsó eleme nagyobb, mint az arr1 utolsó eleme (4 > 3), a nums[4] hozzáfűzi az arr2-hez, így arr2 lesz [4,8].
4 művelet után arr1 = [5,3] és arr2 = [4,8].
Így az összefűzéssel kapott tömb eredménye [5,3,4,8].

Korlátozások:

3 <= n <= 50
1 <= nums[i] <= 100
A nums minden eleme különböző.

Kapunk egy 1-indexelt tömböt, amelyek különböző, n hosszúságú egész számokat tartalmaznak.
A nums összes elemét el kell osztania két arr1 és arr2 tömb között n művelettel. Az első műveletben fűzze hozzá a számokat[1] az arr1-hez. A második műveletben fűzze hozzá a számokat[2] az arr2-hez. Ezt követően az i^. műveletben:

Ha az arr1 utolsó eleme nagyobb, mint az arr2 utolsó eleme, fűzze hozzá a számokat[i] az arr1-hez. Ellenkező esetben fűzze hozzá a számokat[i] az arr2-hez.

A tömb eredménye az arr1 és arr2 tömbök összefűzésével jön létre. Például, ha arr1 == [1,2,3] és arr2 == [4,5,6], akkor az eredmény = [1,2,3,4,5,6].
Adja vissza a tömb eredményét.

1. példa:

Bemenet: nums = [2,1,3]
Kimenet: [2,3,1]
Magyarázat: Az első 2 művelet után arr1 = [2] és arr2 = [1].
A 3^. műveletben, mivel az arr1 utolsó eleme nagyobb, mint az arr2 utolsó eleme (2 > 1), adjon hozzá számokat[3] az arr1-hez.
3 művelet után arr1 = [2,3] és arr2 = [1].
Így az összefűzéssel kapott tömb eredménye [2,3,1].

2. példa:

Bemenet: nums = [5,4,3,8]
Kimenet: [5,3,4,8]
Magyarázat: Az első 2 művelet után arr1 = [5] és arr2 = [4].
A 3^. műveletben, mivel az arr1 utolsó eleme nagyobb, mint az arr2 utolsó eleme (5 > 4), fűzze hozzá a számokat[3] az arr1-hez, így arr1 lesz [5,3].
A 4^. műveletben, mivel az arr2 utolsó eleme nagyobb, mint az arr1 utolsó eleme (4 > 3), a számokat[4] hozzáfűzi az arr2-hez, így arr2 lesz [4,8].
4 művelet után arr1 = [5,3] és arr2 = [4,8].
Így az összefűzéssel kapott tömb eredménye [5,3,4,8].

Korlátozások:

3 <= n <= 50
1 <= nums[i] <= 100
A számokban szereplő összes elem különálló.


Takahashi és Aoki N meccset játszottak.
Kapsz egy N hosszúságú S karakterláncot, amely e játékok eredményeit jelzi.
Takahashi nyerte az i-edik játékot, ha az S i-edik karaktere T, és Aoki nyerte meg, ha az A.
Az összesített győztes Takahashi és Aoki között az, aki több meccset nyert, mint a másik.
Ha ugyanannyi győzelmet arattak, akkor az összesített győztes az, aki előbb érte el ezt a számú győzelmet.
Keresse meg az összesített győztest: Takahashi vagy Aoki.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
S

Kimenet

Ha az összesített győztes Takahashi, nyomtasson T; ha Aoki, nyomtasd ki az A-t.

Korlátozások

- 1\leq N \leq 100
- N egy egész szám.
- S egy N hosszúságú karakterlánc, amely T-ből és A-ból áll.

Mintabevitel 1

5
TTAAT

Mintakimenet 1

T

Takahashi három játszmát nyert, Aoki pedig kettőt.
Így az összesített győztes Takahashi, aki több meccset nyert.

Mintabevitel 2

6
ATTATA

Mintakimenet 2

T

Takahashi és Aoki is három játszmát nyert.
Takahashi három győzelmet ért el az ötödik játszmában, Aoki pedig a hatodik játszmában.
Így az összesített győztes Takahashi, aki előbb ért el három győzelmet.

Minta bemenet 3

1
A

Mintakimenet 3

A

Takahashi és Aoki N játékokat játszottak.
Kapsz egy S hosszúságú S karakterláncot, amely ezeknek a játékoknak az eredményeit képviseli.
Takahashi megnyerte az i-edik játékot, ha az S i-edik karaktere T, és Aoki megnyerte azt a játékot, ha A.
A Takahashi és Aoki közötti összesített győztes az, aki több játékot nyert, mint a másik.
Ha ugyanannyi győzelmük volt, akkor az az összesített győztes, aki először érte el ezt a győzelmszámot.
Keresse meg az összesített győztest: Takahashi vagy Aoki.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
S

Hozam

Ha az összesített győztes Takahashi, nyomtasson T-t; ha Aoki, nyomtassa ki az A-t.

Korlátok

- 1\leq N \leq 100
- N egész szám.
- S egy N hosszúságú karakterlánc, amely T-ből és A-ból áll.

1. minta bemenet

5
TTAAT

Minta output: 1

T

Takahashi három játékot nyert, Aoki pedig kettőt.
Így az összesített győztes Takahashi, aki több játékot nyert.

2. minta bemenet

6
ATTATA

2. mintakimenet

T

Takahashi és Aoki is három játékot nyert.
Takahashi három győzelmet ért el az ötödik játékban, Aoki pedig a hatodik játékban.
Így az összesített győztes Takahashi, aki három győzelmet ért el először.

3. minta bemenet

1
Egy

Minta kimenet 3

Egy

Takahashi és Aoki N játékokat játszottak.
Kapsz egy S hosszúságú S karakterláncot, amely ezeknek a játékoknak az eredményeit képviseli.
Takahashi megnyerte az i-edik játékot, ha az S i-edik karaktere T, és Aoki megnyerte azt a játékot, ha A.
A Takahashi és Aoki közötti összesített győztes az, aki több játékot nyert, mint a másik.
Ha ugyanannyi győzelmük volt, akkor az az összesített győztes, aki először érte el ezt a győzelmszámot.
Keresse meg az összesített győztest: Takahashi vagy Aoki.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
S

Hozam

Ha az összesített győztes Takahashi, nyomtasson T-t; ha Aoki, nyomtassa ki az A-t.

Korlátok

- 1\leq N \leq 100
- N egész szám.
- S egy N hosszúságú karakterlánc, amely T-ből és A-ból áll.

1. minta bemenet

5
TTAAT

1. minta kimenet

T

Takahashi három játékot nyert, Aoki pedig kettőt.
Így az összesített győztes Takahashi, aki több játékot nyert.

2. minta bemenet

6
ATTATA

2. minta kimenet

T

Takahashi és Aoki is három játékot nyert.
Takahashi három győzelmet ért el az ötödik játékban, Aoki pedig a hatodik játékban.
Így az összesített győztes Takahashi, aki három győzelmet ért el először.

3. minta bemenet

1
A

3. minta kimenet

A


Van egy N hosszúságú sorozatunk, amely pozitív egész számokból áll: A=(A_1,\ldots,A_N). Bármely két szomszédos kifejezés eltérő értékű.
Szúrjunk be néhány számot ebbe a sorozatba a következő eljárással.

- Ha A-ban minden szomszédos tagpár abszolút különbsége 1, fejezze be az eljárást.
- Legyen A_i, A_{i+1} az A kezdetéhez legközelebb eső szomszédos tagok párja, amelyek abszolút különbsége nem 1.
- Ha A_i < A_{i+1}, szúrja be az A_i+1,A_i+2,\ldots,A_{i+1}-1 A_i és A_{i+1} közé.
- Ha A_i > A_{i+1}, szúrja be az A_i-1,A_i-2,\ldots,A_{i+1}+1-et A_i és A_{i+1} közé.

- Térjen vissza az 1. lépéshez.

Nyomtassa ki a sorozatot az eljárás végén.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 A_2 \ldots A_N

Kimenet

Nyomtassa ki a kifejezéseket a sorrendben az eljárás végén, szóközzel elválasztva.

Korlátozások

- 2 \leq N \leq 100
- 1 \leq A_i \leq 100
- A_i \neq A_{i+1}
- A bemenetben szereplő összes érték egész szám.

1. minta bemenet

4
2 5 1 2

1. minta kimenet

2 3 4 5 4 3 2 1 2

A kezdeti sorozat (2,5,1,2). Az eljárás a következőképpen zajlik.

- Szúrjon be 3,4-et az első tag 2 és a második tag 5 közé, így létrejön a sorozat (2,3,4,5,1,2).
- Szúrjon be 4,3,2-t a negyedik tag 5 és az ötödik tag 1 közé, így a sorozat (2,3,4,5,4,3,2,1,2) lesz.

2. minta bemenet

6
3 4 5 6 5 4

2. minta kimenet

3 4 5 6 5 4

Beillesztés nem hajtható végre.

Van egy N hosszúságú sorozatunk, amely pozitív egész számokból áll: A=(A_1,\ldots,A_N). Bármely két szomszédos kifejezés eltérő értékű.
Szúrjunk be néhány számot ebbe a sorozatba a következő eljárással.

- Ha A-ban minden szomszédos tagpár abszolút különbsége 1, fejezze be az eljárást.
- Legyen A_i, A_{i+1} az A kezdetéhez legközelebb eső szomszédos tagok párja, amelyek abszolút különbsége nem 1.
- Ha A_i < A_{i+1}, szúrja be az A_i+1,A_i+2,\ldots,A_{i+1}-1 A_i és A_{i+1} közé.
- Ha A_i > A_{i+1}, szúrja be az A_i-1,A_i-2,\ldots,A_{i+1}+1-et A_i és A_{i+1} közé.

- Térjen vissza az 1. lépéshez.

Az eljárás végén nyomtassa ki a sorozatot.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 A_2 \ldots A_N

Kimenet

Nyomtassa ki a kifejezéseket a sorrendben az eljárás végén, szóközzel elválasztva.

Korlátozások

- 2 \leq N \leq 100
- 1 \leq A_i \leq 100
- A_i \neq A_{i+1}
- A bemenetben szereplő összes érték egész szám.

1. minta bemenet

4
2 5 1 2

1. minta kimenet

2 3 4 5 4 3 2 1 2

A kezdeti sorozat a (2,5,1,2). Az eljárás a következőképpen zajlik.

- Szúrjon be 3,4-et az első tag 2 és a második tag 5 közé, így létrejön a sorozat (2,3,4,5,1,2).
- Szúrjon be 4,3,2-t a negyedik tag 5 és az ötödik tag 1 közé, így a sorozat (2,3,4,5,4,3,2,1,2) lesz.

2. minta bemenet

6
3 4 5 6 5 4

2. minta kimenet

3 4 5 6 5 4

Beillesztés nem hajtható végre.

Van egy N hosszúságú, pozitív egész számokból álló sorozatunk: A=(A_1,\ldots,A_N). Bármely két szomszédos tagnak különböző értéke van.
Illesszünk be néhány számot ebbe a sorozatba a következő eljárással.

- Ha A-ban minden szomszédos tagpár abszolút különbsége 1, akkor fejezzük be az eljárást.
- Legyen A_i, A_{i+1} az A kezdetéhez legközelebbi szomszédos kifejezések azon párja, amelyek abszolút különbsége nem 1.
- Ha A_i < A_{i+1}, akkor illesszük be A_i+1,A_i+2,\ldots,A_{i+1}-1 A_i és A_{i+1} közé.
- Ha A_i > A_{i+1}, illesszük be A_i-1,A_i-2,\ldots,A_{i+1}+1 A_i és A_{i+1} között.

- Térjünk vissza az 1. lépéshez.

Az eljárás befejezésekor nyomtassa ki a sorozatot.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 A_2 \ldots A_N

Kimenet

Az eljárás befejezésekor a szekvenciában lévő kifejezéseket nyomtatja ki szóközökkel elválasztva.

Korlátozások

- 2 \leq N \leq 100
- 1 \leq A_i \leq 100
- A_i \neq A_{i+1}
- A bemenet minden értéke egész szám.

Minta bemenet 1

4
2 5 1 2

Minta kimenet 1

2 3 4 5 4 3 2 1 2

A kezdeti sorozat (2,5,1,2). Az eljárás a következőképpen zajlik.

- Helyezzük be a 3,4-et az első 2. és a második 5. kifejezés közé, így a sorozat (2,3,4,5,1,2) lesz.
- A 4,3,2-t illesszük be a negyedik 5. és az ötödik 1. tag közé, így a sorozat (2,3,4,5,4,3,2,1,2) lesz.

Minta bemenet 2

6
3 4 5 6 5 4

Minta kimenet 2

3 4 5 6 5 4

Beillesztés nem végezhető.


Az egyjátékos kártyajáték népszerű az AtCoder Inc.-ben.
A játék minden kártyáján van egy kisbetűs angol betű vagy a @ szimbólum. Minden fajtához rengeteg kártya van.
A játék a következőképpen megy.

- Rendezzen ugyanannyi kártyát két sorba.
- Cserélje ki az egyes kártyákat @ karakterre a következő kártyák egyikével: a, t, c, o, d, e, r.
- Ha a két kártyasor egybeesik, akkor nyersz. Ellenkező esetben veszít.

A játék megnyeréséhez a következő csalást kell végrehajtania.

- Az 1. lépés után szabadon rendezheti át a kártyákat egy sorban, amikor csak akarja.

Két S és T karakterláncot kap, amelyek az 1. lépés utáni két sort képviselik. Határozza meg, hogy lehetséges-e nyerni a megengedett csalással.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
S
T

Kimenet

Ha lehetséges nyerni engedélyezett csalással, nyomtassa ki Igen; ellenkező esetben nyomtassa ki Nem.

Korlátok

- Az S és a T kisbetűs angol betűkből és @-ból áll.
- Az S és T hossza egyenlő, és 1 és 2\times 10^5 között van.

1. minta bemenet

ch@ku@ai
choku@@i

1.minta kimenet

Yes

A @s lecserélheti úgy, hogy mindkét sor chokudai legyen.

2. minta bemenet

ch@kud@i
akidu@ho

2. minta kimenet

Yes

Megcsalhatja és kicserélheti a @s úgy, hogy mindkét sor chokudai legyen.

3. minta bemenet

Aoki
@ok@

Minta kimenet 3

No

Még csalással sem nyerhetsz.

4.minta bemenet

aa
bb

4.minta kimenet

No

Az egyjátékos kártyajáték népszerű az AtCoder Inc.-nél.
A játékban minden kártyán van egy kis angol betű vagy a @ szimbólum. Rengeteg kártya van minden fajtához.
A játék a következőképpen zajlik.

- Rendezzünk két sorban ugyanannyi kártyát.
- Cserélje ki az egyes kártyákat @-ra a következő kártyák egyikére: a, t, c, o, d, e, r.
- Ha a két kártyasor egybeesik, nyersz. Ellenkező esetben veszít.

A játék megnyeréséhez a következő csalást kell végrehajtania.

- Az 1. lépés után bármikor szabadon átrendezheti a kártyákat egy sorban.

Két S és T karakterláncot kapsz, amelyek az 1. lépés után meglévő két sort jelképezik. Határozza meg, hogy lehetséges-e nyerni a csalással.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
S
T

Kimenet

Ha lehetséges csalás mellett nyerni, nyomtasson Igen; ellenkező esetben a nyomtatási sz.

Korlátozások

- S és T kis angol betűkből és @-ból áll.
- S és T hossza egyenlő, és 1 és 2 \x 10^5 között van.

minta bemenet 1

ch@ku@ai
choku@@i

minta kimenet 1

Yes

Cserélheti a @ jeleket, így mindkét sor chokudai lesz.

minta bemenet 2

ch@kud@i
akidu@ho

minta kimenet 3

Yes

Megcsalhatja és lecserélheti a @-kat, így mindkét sor chokudai lesz.

Minta bemenet 3

aoki
@Rendben@

minta kimenet 3

No

Még csalással sem nyerhetsz.

minta bemenet 4

aa
bb

minta kimenet 4

No

Az egyjátékos kártyajáték népszerű az AtCoder Inc.-nél.
A játékban minden kártyán van egy kis angol betű vagy a @ szimbólum. Rengeteg kártya van minden fajtához.
A játék a következőképpen zajlik.

- Rendezzünk két sorban ugyanannyi kártyát.
- Cserélje ki az egyes kártyákat @-ra a következő kártyák egyikére: a, t, c, o, d, e, r.
- Ha a két kártyasor egybeesik, nyersz. Ellenkező esetben veszít.

A játék megnyeréséhez a következő csalást kell végrehajtania.

- Az 1. lépés után bármikor szabadon átrendezheti a kártyákat egy sorban.

Két S és T karakterláncot kapsz, amelyek az 1. lépés után meglévő két sort jelképezik. Határozza meg, hogy lehetséges-e nyerni a csalással.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
S
T

Kimenet

Ha lehetséges csalás mellett nyerni, nyomtasson Yes; ellenkező esetben a nyomtatási No.

Korlátozások

- S és T kis angol betűkből és @-ból áll.
- S és T hossza egyenlő, és 1 és 2 \x 10^5 között van.

1. minta bemenet

ch@ku@ai
choku@@i

1. minta kimenet

Yes

Cserélheti a @ jeleket, így mindkét sor chokudai lesz.

2. minta bemenet

ch@kud@i
akidu@ho

2. minta kimenet

Yes

Megcsalhatja és lecserélheti a @-kat, így mindkét sor chokudai lesz.

Minta bemenet 3

aoki
@Rendben@

3. minta kimenet

No

Még csalással sem nyerhetsz.

4. minta bemenet

aa
bb

4. minta kimenet

No


Kapsz egy N egész számot és egy S karakterláncot, amely 0, 1 és ?-ből áll.
Legyen T azoknak az értékeknek a halmaza, amelyeket mindegyik ? S-ben 0-val vagy 1-gyel, és az eredményt bináris egész számként értelmezi.
Például, ha S=?0?, akkor T=\lbrace 000_{(2)},001_{(2)},100_{(2)},101_{(2)}\rbrace=\lbrace 0,1,4,5\rbrace.
Nyomtassa ki (tizedes egész számként) a T legnagyobb értékét, amely kisebb vagy egyenlő N-nél.
Ha T nem tartalmaz N-nél kisebb vagy egyenlő értéket, akkor helyette -1-et írjon ki.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
S
N

Kimenet

Nyomtassa ki a választ.

Korlátozások

- S is a string consisting of 0, 1, and ?.
- The length of S is between 1 and 60, inclusive.
- 1\leq N \leq 10^{18}
- N is an integer.

1. minta bemenet

?0?
2

1. minta kimenet

1

Ahogy a problémakifejezésben látható, T=\lbrace 0,1,4,5\rbrace.
Közülük 0 és 1 kisebb vagy egyenlő, mint N, ezért a legnagyobbat, az 1-et kell kinyomtatni.

2. minta bemenet

101
4

2. minta kimenet

-1

Van T=\lbrace 5\rbrace, amely nem tartalmaz N-nél kisebb vagy azzal egyenlő értéket.

Minta bemenet 3

?0?
1000000000000000000

3. minta kimenet

5

Adunk egy N egész számot és egy S karakterláncot, amely 0, 1 és ?
Legyen T azoknak az értékeknek a halmaza, amelyeket mindegyik ? S-ben 0-val vagy 1-gyel, és az eredményt bináris egész számként értelmezi.
Például, ha S= ?0?, akkor T=\lbrace 000_{(2)},001_{(2)},100_{(2)},101_{(2)}\rbrace=\lbrace 0,1,4,5\rbrace.
Nyomtassa ki (tizedes egész számként) a T legnagyobb értékét, amely kisebb vagy egyenlő N-nél.
Ha T nem tartalmaz N-nél kisebb vagy egyenlő értéket, akkor helyette -1-et írjon ki.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
S
N

Kimenet

Nyomtassa ki a választ.

Korlátozások

- S egy karakterlánc, amely 0-ból, 1-ből és ?-ből áll.
- S hossza 1 és 60 között van, beleértve.
- 1\leq N \leq 10^{18}
- N egy egész szám.

Mintabemenet 1

?0?
2

Mintakimenet 1

1

Ahogy a problémakifejezésben is látható, T=\lbrace 0,1,4,5\rbrace.
Közülük 0 és 1 kisebb vagy egyenlő, mint N, ezért a legnagyobbat, az 1-et kell kinyomtatni.

Mintabevitel 2

101
4

Mintakimenet 2

-1

Van T=\lbrace 5\rbrace, amely nem tartalmaz N-nél kisebb vagy azzal egyenlő értéket.

Mintabemenet 3

?0?
100000000000000000

Mintakimenet 3

5

Adott egy N egész szám és egy S karakterlánc, amely 0, 1 és ? értékekből áll.
Legyen T azoknak az értékeknek a halmaza, amelyeket úgy kaphatunk, hogy az S-ben szereplő minden ?-t 0-ra vagy 1-re cserélünk, és az eredményt bináris egész számként értelmezzük.
Például, ha S= ?0?, akkor T=\lbrace 000_{(2)},001_{(2)},100_{(2)},101_{(2)}\rbrace=\lbrace 0,1,4,5\rbrace.
Írja ki (tizedes egész számként) a T legnagyobb értékét, amely kisebb vagy egyenlő N-nel.
Ha T nem tartalmaz N-nél kisebb vagy azzal egyenlő értéket, akkor helyette -1-et írjunk ki.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
S
N

Kimenet

A válasz kiírása.

Korlátozások

- S egy 0, 1 és ? karakterlánc.
- Az S hossza 1 és 60 között van.
- 1\leq N \leq 10^{18}
- N egy egész szám.

Beviteli minta 1

?0?
2

Minta kimenet 1

1

A feladatmegoldás szerint T=\lbrace 0,1,4,5\rbrace.
Ezek közül a 0 és az 1 kisebb vagy egyenlő N-nél, ezért a legnagyobbat, az 1-et kell kiírni.

 Minta Bemenet 2

101
4

Kimeneti minta 2

-1

T=\lbrace 5\rbrace, amely nem tartalmaz N-nél kisebb vagy azzal egyenlő értéket.

Minta bemenet 3

?0?
1000000000000000000

Minta kimenet 3

5