Sie erhalten ein Array nums, das aus positiven ganzen Zahlen besteht.
Geben Sie die Gesamthäufigkeiten der Elemente in nums zurück, die die maximale Häufigkeit haben, sodass alle Elemente die maximale Häufigkeit aufweisen.
Die Häufigkeit eines Elements ist die Anzahl der Vorkommen dieses Elements im Array.

Beispiel 1:

Eingabe: nums = [1,2,2,3,1,4]
Ausgabe: 4
Erklärung: Die Elemente 1 und 2 haben eine Frequenz von 2, was der maximalen Frequenz im Array entspricht.
Die Anzahl der Elemente im Array mit der maximalen Häufigkeit beträgt also 4.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: 5
Erklärung: Alle Elemente des Arrays haben eine Frequenz von 1, was das Maximum ist.
Die Anzahl der Elemente im Array mit der maximalen Häufigkeit beträgt also 5.

Einschränkungen:

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

Sie erhalten ein Array nums, das aus positiven ganzen Zahlen besteht.
Geben Sie die Gesamthäufigkeiten der Elemente in Zahlen zurück, sodass diese Elemente alle die maximale Häufigkeit haben.
Die Häufigkeit eines Elements ist die Anzahl der Vorkommen dieses Elements im Array.

Beispiel 1:

Eingabe: nums = [1,2,2,3,1,4]
Ausgabe: 4
Erläuterung: Die Elemente 1 und 2 haben eine Frequenz von 2, was der maximalen Frequenz im Array entspricht.
Die Anzahl der Elemente im Array mit maximaler Häufigkeit beträgt also 4.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: 5
Erläuterung: Alle Elemente des Arrays haben eine Häufigkeit von 1, was dem Maximum entspricht.
Die Anzahl der Elemente im Array mit maximaler Häufigkeit beträgt also 5.

Einschränkungen:

1 <= Anzahl.Länge <= 100
1 <= nums[i] <= 100


Sie erhalten drei ganze Zahlen: Start, Ende und Limit. Sie erhalten außerdem eine 0-indizierte Zeichenfolge s, die eine positive Ganzzahl darstellt.
Eine positive ganze Zahl x heißt mächtig, wenn sie mit s endet (mit anderen Worten, s ist ein Suffix von x) und jede Ziffer in x höchstens begrenzt ist.
Gibt die Anzahl der mächtigen Ganzzahlen im Bereich [Start..Ende] zurück.
Eine Zeichenfolge x ist genau dann ein Suffix einer Zeichenfolge y, wenn x eine Teilzeichenfolge von y ist, die an einem Index (einschließlich 0) in y beginnt und sich bis zum Index y erstreckt. Länge - 1. Beispielsweise ist 25 ein Suffix von 5125, 512 jedoch nicht.

Beispiel 1:

Eingabe: Start = 1, Ende = 6000, Limit = 4, s = „124“
Ausgabe: 5
Erläuterung: Die mächtigen Ganzzahlen im Bereich [1..6000] sind 124, 1124, 2124, 3124 und 4124. Alle diese Ganzzahlen haben jede Ziffer <= 4. und „124“ als Suffix. Beachten Sie, dass 5124 keine mächtige Ganzzahl ist, da die erste Ziffer 5 ist, was größer als 4 ist.
Es kann gezeigt werden, dass es in diesem Bereich nur 5 mächtige ganze Zahlen gibt.

Beispiel 2:

Eingabe: Start = 15, Ende = 215, Limit = 6, s = „10“
Ausgabe: 2
Erläuterung: Die mächtigen Ganzzahlen im Bereich [15..215] sind 110 und 210. Alle diese Ganzzahlen haben jeweils eine Ziffer <= 6 und „10“ als Suffix.
Es kann gezeigt werden, dass es in diesem Bereich nur zwei mächtige ganze Zahlen gibt.

Beispiel 3:

Eingabe: Start = 1000, Ende = 2000, Limit = 4, s = „3000“
Ausgabe: 0
Erläuterung: Alle Ganzzahlen im Bereich [1000..2000] sind kleiner als 3000, daher kann „3000“ kein Suffix einer Ganzzahl in diesem Bereich sein.

Einschränkungen:

1 <= Start <= Ende <= 10^15
1 <= Grenze <= 9
1 <= s.length <= floor(log_10(Ende)) + 1
s besteht nur aus numerischen Ziffern, die jeweils <= Grenze sind.
s hat keine führenden Nullen.

Sie erhalten drei ganze Zahlen für Start, Ende und Limit. Sie erhalten auch eine 0-indizierte Zeichenkette s, die eine positive ganze Zahl darstellt.
Eine positive Ganzzahl x wird als mächtig bezeichnet, wenn sie mit s endet (mit anderen Worten, s ist ein Suffix von x) und jede Ziffer in x höchstens eine Grenze darstellt.
Geben Sie die Gesamtzahl der mächtigen ganzen Zahlen im Bereich [start.. Ende] zurück.
Ein String x ist ein Suffix eines Strings y, wenn x ein Teilstring von y ist, der ab einem Index (einschließlich 0) in y beginnt und bis zum Ende von y reicht. Zum Beispiel ist 25 ein Suffix von 5125, während 512 es nicht ist.

Beispiel 1:

Eingabe: start = 1, finish = 6000, limit = 4, s = "124"
Ausgang: 5
Erklärung: Die mächtigen ganzen Zahlen im Bereich [1..6000] sind 124, 1124, 2124, 3124 und 4124. Alle diese ganzen Zahlen haben jede Ziffer <= 4 und „124“ als Suffix. Beachten Sie, dass 5124 keine mächtige Ganzzahl ist, da die erste Ziffer 5 ist, was größer als 4 ist.
Es kann gezeigt werden, dass es in diesem Bereich nur 5 leistungsfähige ganze Zahlen gibt.

Beispiel 2:

Eingabe: start = 15, finish = 215, limit = 6, s = "10"
Ausgang: 2
Erklärung: Die mächtigen ganzen Zahlen im Bereich [15..215] sind 110 und 210. Alle diese ganzen Zahlen haben jede Ziffer <= 6 und „10“ als Suffix.
Es kann gezeigt werden, dass es in diesem Bereich nur 2 leistungsfähige ganze Zahlen gibt.

Beispiel 3:

Eingabe: start = 1000, finish = 2000, limit = 4, s = "3000"
Ausgang: 0
Erklärung: Alle ganzen Zahlen im Bereich [1000..2000] sind kleiner als 3000, daher kann „3000“ kein Suffix einer ganzen Zahl in diesem Bereich sein.

Zwänge:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s besteht nur aus numerischen Ziffern, die höchstens limit sind.
s hat keine führenden Nullen.

Sie erhalten drei ganze Zahlen: Start, Ende und Limit. Sie erhalten außerdem eine 0-indizierte Zeichenfolge s, die eine positive Ganzzahl darstellt.
Eine positive ganze Zahl x heißt mächtig, wenn sie mit s endet (mit anderen Worten, s ist ein Suffix von x) und jede Ziffer in x höchstens begrenzt ist.
Gibt die Gesamtzahl der leistungsstarken Ganzzahlen im Bereich [Start..Ende] zurück.
Eine Zeichenfolge x ist genau dann ein Suffix einer Zeichenfolge y, wenn x eine Teilzeichenfolge von y ist, die an einem Index (einschließlich 0) in y beginnt und sich bis zum Index y erstreckt. Länge - 1. Beispielsweise ist 25 ein Suffix von 5125, 512 jedoch nicht.

Beispiel 1:

Eingabe: start = 1, finish = 6000, limit = 4, s = "124"
Ausgabe: 5
Erläuterung: Die leistungsstarken Ganzzahlen im Bereich [1..6000] sind 124, 1124, 2124, 3124 und 4124. Alle diese Ganzzahlen haben jeweils eine Ziffer <= 4 und „124“ als Suffix. Beachten Sie, dass 5124 keine leistungsstarke Ganzzahl ist, da die erste Ziffer 5 ist, was größer als 4 ist.
Es kann gezeigt werden, dass es in diesem Bereich nur 5 leistungsstarke ganze Zahlen gibt.

Beispiel 2:

Eingabe: start = 15, finish = 215, limit = 6, s = "10"
Ausgabe: 2
Erläuterung: Die leistungsstarken Ganzzahlen im Bereich [15..215] sind 110 und 210. Alle diese Ganzzahlen haben jeweils eine Ziffer <= 6 und „10“ als Suffix.
Es kann gezeigt werden, dass es in diesem Bereich nur zwei leistungsstarke ganze Zahlen gibt.

Beispiel 3:

Eingabe: start = 1000, finish = 2000, limit = 4, s = "3000"
Ausgabe: 0
Erläuterung: Alle Ganzzahlen im Bereich [1000..2000] sind kleiner als 3000, daher kann „3000“ kein Suffix einer Ganzzahl in diesem Bereich sein.

Einschränkungen:

1 <= start <= finish <= 10^15
1 <= limit <= 9
1 <= s.length <= floor(log_10(finish)) + 1
s besteht nur aus numerischen Ziffern, die höchstens begrenzt sind.
s hat keine führenden Nullen.


Sie erhalten ein 0-indiziertes ganzzahliges Array nums, das positive ganze Zahlen enthält.
Ihre Aufgabe besteht darin, die Länge von Nums zu minimieren, indem Sie die folgenden Vorgänge beliebig oft ausführen (einschließlich Null):

Wählen Sie zwei unterschiedliche Indizes i und j aus den Zahlen, sodass nums[i] > 0 and nums[j] > 0.
Fügen Sie das Ergebnis von nums[i] % nums[j] am Ende von nums ein.
Löschen Sie die Elemente bei den Indizes i und j aus den Zahlen.

Gibt eine ganze Zahl zurück, die die Mindestlänge von nums angibt, nachdem der Vorgang beliebig oft ausgeführt wurde.

Beispiel 1:

Eingabe: nums = [1,4,3,1]
Ausgang: 1
Erklärung: Eine Möglichkeit, die Länge des Arrays zu minimieren, ist wie folgt:
Vorgang 1: Wählen Sie die Indizes 2 und 1 aus, fügen Sie am Ende nums[2] % nums[1] ein, und es wird [1,4,3,1,3], dann löschen Sie die Elemente bei den Indizes 2 und 1.
nums wird zu [1,1,3].
Vorgang 2: Wählen Sie die Indizes 1 und 2 aus, fügen Sie am Ende nums[1] % nums[2] ein, und es wird [1,1,3,1], dann löschen Sie die Elemente bei den Indizes 1 und 2.
nums wird zu [1,1].
Vorgang 3: Wählen Sie die Indizes 1 und 0 aus, fügen Sie am Ende nums[1] % nums[0] ein, und es wird [1,1,0], dann löschen Sie die Elemente bei den Indizes 1 und 0.
NUMS wird zu [0].
Die Länge der nums kann nicht weiter verkürzt werden. Daher lautet die Antwort 1.
Es kann gezeigt werden, dass 1 die minimal erreichbare Länge ist.
Beispiel 2:

Eingabe: nums = [5,5,5,10,5]
Ausgang: 2
Erklärung: Eine Möglichkeit, die Länge des Arrays zu minimieren, ist wie folgt:
Vorgang 1: Wählen Sie die Indizes 0 und 3 aus, fügen Sie am Ende nums[0] % nums[3] ein und es wird [5,5,5,10,5,5], dann löschen Sie die Elemente bei den Indizes 0 und 3.
nums wird zu [5,5,5,5].
Vorgang 2: Wählen Sie die Indizes 2 und 3 aus, fügen Sie am Ende nums[2] % nums[3] ein, und es wird [5,5,5,5,0], dann löschen Sie die Elemente bei den Indizes 2 und 3.
nums wird zu [5,5,0].
Vorgang 3: Wählen Sie die Indizes 0 und 1 aus, fügen Sie am Ende nums[0] % nums[1] ein, und es wird [5,5,0,0], dann löschen Sie die Elemente bei den Indizes 0 und 1.
nums wird zu [0,0].
Die Länge der nums kann nicht weiter verkürzt werden. Daher lautet die Antwort 2.
Es kann gezeigt werden, dass 2 die minimal erreichbare Länge ist.
Beispiel 3:

Eingabe: nums = [2,3,4]
Ausgang: 1
Erklärung: Eine Möglichkeit, die Länge des Arrays zu minimieren, ist wie folgt:
Vorgang 1: Wählen Sie die Indizes 1 und 2 aus, fügen Sie am Ende nums[1] % nums[2] ein und es wird [2,3,4,3], dann löschen Sie die Elemente bei den Indizes 1 und 2.
nums wird zu [2,3].
Vorgang 2: Wählen Sie die Indizes 1 und 0 aus, fügen Sie am Ende nums[1] % nums[0] ein und es wird [2,3,1], dann löschen Sie die Elemente bei den Indizes 1 und 0.
nums wird zu [1].
Die Länge der nums kann nicht weiter verkürzt werden. Daher lautet die Antwort 1.
Es kann gezeigt werden, dass 1 die minimal erreichbare Länge ist.

Zwänge:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array „nums“, das positive Ganzzahlen enthält.
Ihre Aufgabe besteht darin, die Länge von Nums zu minimieren, indem Sie die folgenden Operationen beliebig oft (einschließlich null) ausführen:

Wählen Sie zwei unterschiedliche Indizes i und j aus nums aus, sodass nums[i] > 0 und nums[j] > 0 ist.
Fügen Sie das Ergebnis von nums[i] % nums[j] am Ende von nums ein.
Löschen Sie die Elemente an den Indizes i und j aus nums.

Gibt eine Ganzzahl zurück, die die Mindestlänge von Zahlen angibt, nachdem die Operation beliebig oft ausgeführt wurde.

Beispiel 1:

Eingabe: nums = [1,4,3,1]
Ausgabe: 1
Erläuterung: Eine Möglichkeit, die Länge des Arrays zu minimieren, ist wie folgt:
Vorgang 1: Wählen Sie die Indizes 2 und 1 aus, fügen Sie nums[2] % nums[1] am Ende ein und es wird zu [1,4,3,1,3], dann löschen Sie Elemente an den Indizes 2 und 1.
nums wird zu [1,1,3].
Vorgang 2: Wählen Sie die Indizes 1 und 2 aus, fügen Sie nums[1] % nums[2] am Ende ein und es wird zu [1,1,3,1], dann löschen Sie Elemente an den Indizes 1 und 2.
nums wird zu [1,1].
Vorgang 3: Wählen Sie die Indizes 1 und 0 aus, fügen Sie nums[1] % nums[0] am Ende ein und es wird zu [1,1,0], dann löschen Sie Elemente bei den Indizes 1 und 0.
nums wird zu [0].
Die Länge von Nummern kann nicht weiter reduziert werden. Daher ist die Antwort 1.
Es kann gezeigt werden, dass 1 die minimal erreichbare Länge ist.
Beispiel 2:

Eingabe: Zahlen = [5,5,5,10,5]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, die Länge des Arrays zu minimieren, ist wie folgt:
Vorgang 1: Wählen Sie die Indizes 0 und 3 aus, fügen Sie nums[0] % nums[3] am Ende ein und es wird zu [5,5,5,10,5,5], dann löschen Sie Elemente bei den Indizes 0 und 3.
nums wird zu [5,5,5,5].
Vorgang 2: Wählen Sie die Indizes 2 und 3 aus, fügen Sie nums[2] % nums[3] am Ende ein und es wird zu [5,5,5,5,0], dann löschen Sie Elemente an den Indizes 2 und 3.
nums wird zu [5,5,0].
Vorgang 3: Wählen Sie die Indizes 0 und 1 aus, fügen Sie nums[0] % nums[1] am Ende ein und es wird zu [5,5,0,0], dann löschen Sie Elemente bei den Indizes 0 und 1.
nums wird zu [0,0].
Die Länge von Nummern kann nicht weiter reduziert werden. Daher lautet die Antwort 2.
Es kann gezeigt werden, dass 2 die minimal erreichbare Länge ist.
Beispiel 3:

Eingabe: nums = [2,3,4]
Ausgabe: 1
Erläuterung: Eine Möglichkeit, die Länge des Arrays zu minimieren, ist wie folgt:
Vorgang 1: Wählen Sie die Indizes 1 und 2 aus, fügen Sie nums[1] % nums[2] am Ende ein und es wird zu [2,3,4,3], dann löschen Sie Elemente an den Indizes 1 und 2.
nums wird zu [2,3].
Vorgang 2: Wählen Sie die Indizes 1 und 0 aus, fügen Sie nums[1] % nums[0] am Ende ein und es wird zu [2,3,1], dann löschen Sie Elemente bei den Indizes 1 und 0.
nums wird zu [1].
Die Länge von Nummern kann nicht weiter reduziert werden. Daher ist die Antwort 1.
Es kann gezeigt werden, dass 1 die minimal erreichbare Länge ist.

Einschränkungen:

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


Sie erhalten eine 0-indizierte Zeichenfolge s, eine Zeichenfolge a, eine Zeichenfolge b und eine Ganzzahl k.
Ein Index i ist schön, wenn:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Es gibt einen Index j, so dass:

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

Gibt das Array zurück, das schöne Indizes in sortierter Reihenfolge vom kleinsten zum größten enthält.

Beispiel 1:

Eingabe: s = „isawsquirrelnearmysquirrelhouseohmy“, a = „my“, b = „squirrel“, k = 15
Ausgabe: [16,33]
Erläuterung: Es gibt zwei schöne Indizes: [16,33].
- Der Index 16 ist schön als s[16..17] == „my“ und es gibt einen Index 4 mit s[4..11] == „squirrel“ und |16 - 4| <= 15.
- Der Index 33 ist schön als s[33..34] == „my“ und es gibt einen Index 18 mit s[18..25] == „squirrel“ und |33 - 18| <= 15.
Somit geben wir als Ergebnis [16,33] zurück.

Beispiel 2:

Eingabe: s = „abcd“, a = „a“, b = „a“, k = 4
Ausgabe: [0]
Erläuterung: Es gibt 1 schönen Index: [0].
- Der Index 0 ist schön als s[0..0] == "a" und es gibt einen Index 0 mit s[0..0] == "a" und |0 - 0| <= 4.
Somit geben wir als Ergebnis [0] zurück.

Einschränkungen:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a und b enthalten nur englische Kleinbuchstaben.

Sie erhalten eine Zeichenkette s mit dem Index 0, eine Zeichenkette a, eine Zeichenkette b und eine ganze Zahl k.
Ein Index i ist schön, wenn:

0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
Es gibt einen Index j, der so beschaffen ist, dass:

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

Gibt das Array zurück, das schöne Indizes in sortierter Reihenfolge vom kleinsten zum größten enthält.

Beispiel 1:

Eingabe: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Ausgabe: [16,33]
Erläuterung: Es gibt 2 schöne Indizes: [16,33].
- Der Index 16 ist schön wie s[16..17] == "my" und es existiert ein Index 4 mit s[4..11] == "squirrel" und |16 - 4| <= 15.
- Der Index 33 ist schön wie s[33..34] == "my" und es existiert ein Index 18 mit s[18..25] == "squirrel" und |33 - 18| <= 15.
Wir geben also [16,33] als Ergebnis zurück.

Beispiel 2:

Eingabe: s = "abcd", a = "a", b = "a", k = 4
Ausgabe: [0]
Erläuterung: Es gibt 1 schönen Index: [0].
- Der Index 0 ist schön, da s[0..0] == "a" ist und es einen Index 0 mit s[0..0] == "a" und |0 - 0| <= 4 gibt.
Wir geben also [0] als Ergebnis zurück.

Beschränkungen:

1 <= k <= s.length <= 10^5
1 <= a.length, b.length <= 10
s, a, und b enthalten nur englische Kleinbuchstaben.


Sie erhalten ein Array positiver ganzer Zahlen nums.
Sie müssen prüfen, ob es möglich ist, zwei oder mehr Elemente im Array so auszuwählen, dass das bitweise OR der ausgewählten Elemente mindestens eine nachgestellte Null in seiner binären Darstellung hat.
Zum Beispiel hat die binäre Darstellung von 5, die "101" ist, keine nachfolgenden Nullen, während die binäre Darstellung von 4, die "100" ist, zwei nachfolgende Nullen hat.
Gibt true zurück, wenn es möglich ist, zwei oder mehr Elemente auszuwählen, deren bitweises OR nachfolgende Nullen hat, andernfalls wird false zurückgegeben.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: true
Erklärung: Wenn wir die Elemente 2 und 4 auswählen, ist ihr bitweises OR 6, was die binäre Darstellung "110" mit einer nachgestellten Null hat.

Beispiel 2:

Eingabe: nums = [2,4,8,16]
Ausgabe: true
Erklärung: Wenn wir die Elemente 2 und 4 auswählen, ist ihr bitweises OR 6, was die binäre Darstellung "110" mit einer nachgestellten Null hat.
Andere mögliche Möglichkeiten zum Auswählen von Elementen, die in der binären Darstellung ihres bitweisen OR nachgestellte Nullen aufweisen sollen, sind: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) und (2, 4, 8, 16).

Beispiel 3:

Eingabe: nums = [1,3,5,7,9]
Ausgabe: falsch
Erklärung: Es gibt keine Möglichkeit, zwei oder mehr Elemente auszuwählen, die in der binären Darstellung ihres bitweisen OR nachgestellte Nullen haben.

Zwänge:

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

Sie haben ein Array positiver Ganzzahlen namens nums.
Sie müssen überprüfen, ob es möglich ist, zwei oder mehr Elemente im Array auszuwählen, sodass das bitweise ODER der ausgewählten Elemente mindestens eine abschließende Null in seiner binären Darstellung hat.
Zum Beispiel hat die binäre Darstellung von 5, die "101" ist, keine abschließenden Nullen, während die binäre Darstellung von 4, die "100" ist, zwei abschließende Nullen hat.
Geben Sie true zurück, wenn es möglich ist, zwei oder mehr Elemente auszuwählen, deren bitweises ODER abschließende Nullen hat, andernfalls false.

Beispiel 1:

Input: nums = [1,2,3,4,5]
Output: true
Erläuterung: Wenn wir die Elemente 2 und 4 auswählen, ist ihr bitweises OR 6, das die binäre Darstellung "110" mit einer abschließenden Null hat.

Beispiel 2:

Input: nums = [2,4,8,16]
Output: true
Erläuterung: Wenn wir die Elemente 2 und 4 auswählen, ist ihr bitweises OR 6, das die binäre Darstellung "110" mit einer abschließenden Null hat.
Andere mögliche Auswahlen, um abschließende Nullen in der binären Darstellung ihres bitweisen OR zu haben, sind: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) und (2, 4, 8, 16).

Beispiel 3:

Input: nums = [1,3,5,7,9]
Output: false
Erläuterung: Es gibt keine Möglichkeit, zwei oder mehr Elemente auszuwählen, um abschließende Nullen in der binären Darstellung ihres bitweisen OR zu haben.

Einschränkungen:

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

Sie erhalten ein Array positiver Ganzzahlen.
Sie müssen prüfen, ob es möglich ist, zwei oder mehr Elemente im Array so auszuwählen, dass das bitweise ODER der ausgewählten Elemente in seiner binären Darstellung mindestens eine nachgestellte Null aufweist.
Beispielsweise hat die binäre Darstellung von 5, die „101“ ist, keine nachgestellten Nullen, wohingegen die binäre Darstellung von 4, die „100“ ist, zwei nachgestellte Nullen hat.
Geben Sie „true“ zurück, wenn es möglich ist, zwei oder mehr Elemente auszuwählen, deren bitweises ODER nachgestellte Nullen hat, andernfalls geben Sie „false“ zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: wahr
Erläuterung: Wenn wir die Elemente 2 und 4 auswählen, ist ihr bitweises ODER 6, was die binäre Darstellung „110“ mit einer nachgestellten Null hat.

Beispiel 2:

Eingabe: nums = [2,4,8,16]
Ausgabe: wahr
Erläuterung: Wenn wir die Elemente 2 und 4 auswählen, ist ihr bitweises ODER 6, was die binäre Darstellung „110“ mit einer nachgestellten Null hat.
Andere mögliche Möglichkeiten, Elemente so auszuwählen, dass sie in der binären Darstellung ihres bitweisen ODER nachgestellte Nullen haben, sind: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16) und (2, 4, 8, 16).

Beispiel 3:

Eingabe: nums = [1,3,5,7,9]
Ausgabe: falsch
Erläuterung: Es gibt keine Möglichkeit, zwei oder mehr Elemente so auszuwählen, dass sie in der binären Darstellung ihres bitweisen OR nachgestellte Nullen haben.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine positive Ganzzahl k.
Sie können die folgende Operation beliebig oft auf das Array anwenden:

Wählen Sie ein beliebiges Element des Arrays und drehen Sie ein wenig in seiner binären Darstellung. Ein Bit umzudrehen bedeutet, eine 0 in eine 1 zu ändern oder umgekehrt.

Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um das bitweise XOR aller Elemente des endgültigen Arrays gleich k zu machen.
Beachten Sie, dass Sie führende Nullbits in der binären Darstellung von Elementen umdrehen können. Beispielsweise können Sie für die Zahl (101)_2 das vierte Bit umdrehen und erhalten (1101)_2.

Beispiel 1:

Eingabe: nums = [2,1,3,4], k = 1
Ausgabe: 2
Erläuterung: Wir können die folgenden Operationen ausführen:
- Wählen Sie Element 2, das 3 == (011)_2 ist, wir drehen das erste Bit um und erhalten (010)_2 == 2. Nums wird zu [2,1,2,4].
- Wählen Sie Element 0, das 2 == (010)_2 ist, wir drehen das dritte Bit um und erhalten (110)_2 = 6. nums wird zu [6,1,2,4].
Das XOR der Elemente des endgültigen Arrays ist (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Es kann gezeigt werden, dass wir das XOR nicht in weniger als 2 Operationen gleich k machen können.

Beispiel 2:

Eingabe: nums = [2,0,2,0], k = 0
Ausgabe: 0
Erläuterung: Das XOR der Elemente des Arrays ist (2 XOR 0 XOR 2 XOR 0) == 0 == k. Es ist also keine Operation erforderlich.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine positive Ganzzahl k.
Sie können die folgende Operation beliebig oft auf das Array anwenden:

Wählen Sie ein beliebiges Element des Arrays und drehen Sie ein wenig in seiner binären Darstellung. Ein Bit umzudrehen bedeutet, eine 0 in eine 1 zu ändern oder umgekehrt.

Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um das bitweise XOR aller Elemente des endgültigen Arrays gleich k zu machen.
Beachten Sie, dass Sie führende Nullbits in der binären Darstellung von Elementen umdrehen können. Beispielsweise können Sie für die Zahl (101)_2 das vierte Bit umdrehen und erhalten (1101)_2.

Beispiel 1:

Eingabe: nums = [2,1,3,4], k = 1
Ausgabe: 2
Erläuterung: Wir können die folgenden Operationen ausführen:
- Wählen Sie Element 2, das 3 == (011)_2 ist, wir drehen das erste Bit um und erhalten (010)_2 == 2. Nums wird zu [2,1,2,4].
- Wählen Sie Element 0, das 2 == (010)_2 ist, wir drehen das dritte Bit um und erhalten (110)_2 = 6. nums wird zu [6,1,2,4].
Das XOR der Elemente des endgültigen Arrays ist (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Es kann gezeigt werden, dass wir das XOR nicht in weniger als 2 Operationen gleich k machen können.

Beispiel 2:

Eingabe: Zahlen = [2,0,2,0], k = 0
Ausgabe: 0
Erläuterung: Das XOR der Elemente des Arrays ist (2 XOR 0 XOR 2 XOR 0) == 0 == k. Es ist also keine Operation erforderlich.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes ganzzahliges Array nums und eine positive Ganzzahl k.
Sie können den folgenden Vorgang beliebig oft auf das Array anwenden:

Wählen Sie ein beliebiges Element des Arrays aus und drehen Sie ein Bit in seiner binären Darstellung. Ein bisschen umzudrehen bedeutet, eine 0 in 1 zu ändern oder umgekehrt.

Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um das bitweise XOR aller Elemente des endgültigen Arrays gleich k zu machen.
Beachten Sie, dass Sie führende Null-Bits in der binären Darstellung von Elementen umdrehen können. Für die Zahl (101)_2 können Sie z. B. das vierte Bit umdrehen und (1101)_2 erhalten.

Beispiel 1:

Eingabe: nums = [2,1,3,4], k = 1
Ausgang: 2
Erklärung: Wir können die folgenden Operationen durchführen:
- Wählen Sie Element 2, das 3 == (011)_2 ist, wir drehen das erste Bit um und erhalten (010)_2 == 2. nums wird zu [2,1,2,4].
- Wählen Sie Element 0, das 2 == (010)_2 ist, drehen wir das dritte Bit um und erhalten (110)_2 = 6. nums wird zu [6,1,2,4].
Der XOR der Elemente des endgültigen Arrays ist (6 XOR 1 XOR 2 XOR 4) == 1 == k.
Es kann gezeigt werden, dass wir das XOR nicht in weniger als 2 Operationen gleich k machen können.

Beispiel 2:

Eingabe: nums = [2,0,2,0], k = 0
Ausgang: 0
Erklärung: Der XOR der Elemente des Arrays ist (2 XOR 0 XOR 2 XOR 0) == 0 == k. Es ist also keine Operation erforderlich.

Zwänge:

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


Sie erhalten ein 2D-Integer-Array mit 0-Indizierung und Dimensionen.
Für alle Indizes i, 0 <= i < Dimensions.Length, repräsentiert Dimensions[i][0] die Länge und Dimensions[i][1] repräsentiert die Breite des Rechtecks i.
Gibt die Fläche des Rechtecks mit der längsten Diagonale zurück. Wenn es mehrere Rechtecke mit der längsten Diagonale gibt, wird die Fläche des Rechtecks mit der größten Fläche zurückgegeben.

Beispiel 1:

Eingabe: Abmessungen = [[9,3],[8,6]]
Ausgabe: 48
Erläuterung:
Für Index = 0, Länge = 9 und Breite = 3. Diagonale Länge = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9,487.
Für Index = 1, Länge = 8 und Breite = 6. Diagonale Länge = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Das Rechteck am Index 1 hat also eine größere diagonale Länge, daher geben wir Fläche = 8 * 6 = 48 zurück.

Beispiel 2:

Eingabe: Abmessungen = [[3,4],[4,3]]
Ausgabe: 12
Erläuterung: Die Länge der Diagonalen ist für beide gleich, also 5, also maximale Fläche = 12.

Einschränkungen:

1 <= Abmessungen.Länge <= 100
Dimensions[i].length == 2
1 <= Dimensionen[i][0], Dimensionen[i][1] <= 100

Sie erhalten ein ganzzahliges 2D-Array mit 0 Indizes für dimensions.
Für alle Indizes i, 0 <= i < dimensions.length, steht dimensions[i][0] für die Länge und dimensions[i][1] für die Breite des Rechtecks i.
Gibt die Fläche des Rechtecks mit der längsten Diagonale zurück. Wenn es mehrere Rechtecke mit der längsten Diagonale gibt, wird die Fläche des Rechtecks mit der größten Fläche zurückgegeben.

Beispiel 1:

Eingabe: dimensions = [[9,3],[8,6]]
Ausgabe: 48
Erläuterung:
Für Index = 0, length = 9 und width = 3. Diagonale length = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
Für Index = 1, length = 8 und width = 6. Diagonale length = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
Das Rechteck mit dem Index 1 hat also eine größere Diagonallänge, daher ergibt sich die area = 8 * 6 = 48.

Beispiel 2:

Eingabe: dimensions = [[3,4],[4,3]]
Ausgabe: 12
Erläuterung: Die Länge der Diagonale ist für beide gleich, nämlich 5, also ist die maximale area = 12.

Beschränkungen:

1 <= dimensions.length <= 100
dimensions[i].length == 2
1 <= dimensions[i][0], dimensions[i][1] <= 100


Sie erhalten ein 0-indiziertes Array positiver Ganzzahlen.
Ein Subarray von Nums wird als incremovable bezeichnet, wenn Nums beim Entfernen des Subarrays strikt zunimmt. Beispielsweise ist das Subarray [3, 4] ein unveränderliche Subarray von [5, 3, 4, 6, 7], da durch das Entfernen dieses Subarrays das Array [5, 3, 4, 6, 7] in [5, 6, 7], die streng ansteigend ist.
Gibt die Gesamtzahl der nicht entfernbaren Subarrays von Nums zurück.
Beachten Sie, dass ein leeres Array als streng ansteigend betrachtet wird.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgabe: 10
Erläuterung: Die 10 unveränderlichen Subarrays sind: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] und [1,2,3,4], da durch das Entfernen eines dieser Subarrays wird nums streng ansteigend. Beachten Sie, dass Sie kein leeres Subarray auswählen können.

Beispiel 2:

Eingabe: nums = [6,5,7,8]
Ausgabe: 7
Erläuterung: Die 7 unveränderlichen Subarrays sind: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] und [6,5,7 ,8].
Es kann gezeigt werden, dass es in Nums nur 7 nicht entfernbare Subarrays gibt.

Beispiel 3:

Eingabe: nums = [8,7,6,6]
Ausgabe: 3
Erläuterung: Die drei unveränderlichen Subarrays sind: [8,7,6], [7,6,6] und [8,7,6,6]. Beachten Sie, dass [8,7] kein unveränderliches Subarray ist, da nach dem Entfernen von [8,7] nums zu [6,6] wird, das in aufsteigender, aber nicht streng steigender Reihenfolge sortiert wird.

Einschränkungen:

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

Sie erhalten eine 0-indiziert Auswahl positiver Zahlen.
Eine Unterarray von nums wird als entfernbar bezeichnet, wenn nums nach dem Entfernen des Unterarrays streng wächst. Zum Beispiel ist das Subarray [3, 4] ein inkremovierbares Unterarray von [5, 3, 4, 6, 7], da das Entfernen dieses Subtarrays das Array [5, 3, 4, 6, 7] auf [5, 6, ändert. 7] was streng zunimmt.
Geben Sie die Gesamtzahl der entfernbaren Unterarrays von nums zurück.
Beachten Sie, dass ein leeres Array als streng wachsend betrachtet wird.
Ein Unterarray ist eine zusammenhängende nicht leere Abfolge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgabe: 10
Erläuterung: Die 10 inkremovablen Unterarrays sind: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] und [1,2,3,4], weil beim Entfernen einer dieser SubaRrays -nums streng zunimmt. Beachten Sie, dass Sie kein leeres Unterarray auswählen können.

Beispiel 2:

Eingabe: nums = [6,5,7,8]
Ausgabe: 7
Erläuterung: Die 7 inkremovablen Subtarrays sind: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] und [6,5,7 , 8].
Es kann gezeigt werden, dass es in nums nur 7 inkremovable Subtarrays gibt.

Beispiel 3:

Eingabe: nums = [8,7,6,6]
Ausgabe: 3
Erläuterung: Die 3 inkremovablen Subtarrays sind: [8,7,6], [7,6,6] und [8,7,6,6]. Beachten Sie, dass [8,7] kein inkremovierbares Unterarray ist, da nach dem Entfernen von [8,7] nums [6,6], was in aufsteigender Reihenfolge sortiert, aber nicht strikt zunimmt.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array positiver Ganzzahlen.
Ein Subarray von Nums wird als incremovable bezeichnet, wenn Nums beim Entfernen des Subarrays strikt zunimmt. Beispielsweise ist das Subarray [3, 4] ein entfernbar, sodass das Array streng ansteigend wird Subarray von [5, 3, 4, 6, 7], da durch das Entfernen dieses Subarrays das Array [5, 3, 4, 6, 7] in [5, 6, 7], das streng ansteigend ist.
Gibt die Gesamtzahl der entfernbar, sodass das Array streng ansteigend wird Subarrays von Nums zurück.
Beachten Sie, dass ein leeres Array als streng ansteigend betrachtet wird.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgabe: 10
Erläuterung: Die 10 entfernbar, sodass das Array streng ansteigend wird Subarrays sind: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] und [1,2,3,4], da die Anzahl beim Entfernen eines dieser Subarrays streng ansteigt. Beachten Sie, dass Sie kein leeres Subarray auswählen können.

Beispiel 2:

Eingabe: nums = [6,5,7,8]
Ausgabe: 7
Erläuterung: Die 7 entfernbar, sodass das Array streng ansteigend wird Subarrays sind: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] und [6,5,7 ,8].
Es kann gezeigt werden, dass es in Nums nur 7 entfernbar, sodass das Array streng ansteigend wird Subarrays gibt.

Beispiel 3:

Eingabe: nums = [8,7,6,6]
Ausgabe: 3
Erläuterung: Die drei entfernbar, sodass das Array streng ansteigend wird Subarrays sind: [8,7,6], [7,6,6] und [8,7,6,6]. Beachten Sie, dass [8,7] kein entfernbar, sodass das Array streng ansteigend wird Subarray ist, da nach dem Entfernen von [8,7] nums zu [6,6] wird, das in aufsteigender, aber nicht streng steigender Reihenfolge sortiert wird.

Einschränkungen:

1 <= nums.Länge <= 50
1 <= nums[i] <= 50


Du hast ein 0-indexiertes ganzzahliges Array nums und eine Ganzzahl k.
In einem Vorgang kannst du einen beliebigen Index i von nums auswählen, so dass 0 <= i < nums.length - 1, und nums[i] und nums[i + 1] mit einem einzigen Vorkommen von nums[i] & nums[i + 1] ersetzen, wobei & den bitweisen AND-Operator darstellt.
Gib den kleinsten möglichen Wert des bitweisen OR der verbleibenden Elemente von nums nach maximal k Vorgängen zurück.

Beispiel 1:

Input: nums = [3,5,3,2,7], k = 2
Output: 3
Erläuterung: Nehmen wir folgende Operationen vor:
1. Ersetze nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [1,3,2,7] wird.
2. Ersetze nums[2] und nums[3] durch (nums[2] & nums[3]), so dass nums gleich [1,3,2] wird.
Das bitweise OR des endgültigen Arrays ist 3.
Es kann gezeigt werden, dass 3 der kleinste mögliche Wert des bitweisen OR der verbleibenden Elemente von nums nach maximal k Vorgängen ist.
Beispiel 2:

Input: nums = [7,3,15,14,2,8], k = 4
Output: 2
Erläuterung: Nehmen wir folgende Operationen vor:
1. Ersetze nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [3,15,14,2,8] wird.
2. Ersetze nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [3,14,2,8] wird.
3. Ersetze nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [2,2,8] wird.
4. Ersetze nums[1] und nums[2] durch (nums[1] & nums[2]), so dass nums gleich [2,0] wird.
Das bitweise OR des endgültigen Arrays ist 2.
Es kann gezeigt werden, dass 2 der kleinste mögliche Wert des bitweisen OR der verbleibenden Elemente von nums nach maximal k Vorgängen ist.

Beispiel 3:

Input: nums = [10,7,10,3,9,14,9,4], k = 1
Output: 15
Erläuterung: Ohne Anwendung von Operationen ist das bitweise OR von nums 15.
Es kann gezeigt werden, dass 15 der kleinste mögliche Wert des bitweisen OR der verbleibenden Elemente von nums nach maximal k Vorgängen ist.

Beschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine Ganzzahl k.
In einer Operation können Sie einen beliebigen Index i von Nums auswählen, sodass 0 <= i < Nums.length - 1 ist, und Nums[i] und Nums[i + 1] durch ein einzelnes Vorkommen von Nums[i] und Nums[i + 1] ersetzen, wobei & den bitweisen UND-Operator darstellt.
Gibt den minimal möglichen Wert des bitweisen ODER der verbleibenden Elemente von nums zurück, nachdem höchstens k Operationen angewendet wurden.

Beispiel 1:

Eingabe: nums = [3,5,3,2,7], k = 2
Ausgabe: 3
Erläuterung: Lassen Sie uns die folgenden Operationen ausführen:
1. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), sodass nums gleich [1,3,2,7] wird.
2. Ersetzen Sie nums[2] und nums[3] durch (nums[2] & nums[3]), sodass nums gleich [1,3,2] wird.
Das bitweise Oder des endgültigen Arrays ist 3.
Es kann gezeigt werden, dass 3 der minimal mögliche Wert des bitweisen ODER der verbleibenden Elemente von nums nach Anwendung von höchstens k Operationen ist.
Beispiel 2:

Eingabe: nums = [7,3,15,14,2,8], k = 4
Ausgabe: 2
Erläuterung: Lassen Sie uns die folgenden Operationen ausführen:
1. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), sodass nums gleich [3,15,14,2,8] wird.
2. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), sodass nums gleich [3,14,2,8] wird.
3. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), sodass nums gleich [2,2,8] wird.
4. Ersetzen Sie nums[1] und nums[2] durch (nums[1] & nums[2]), sodass nums gleich [2,0] wird.
Das bitweise Oder des endgültigen Arrays ist 2.
Es kann gezeigt werden, dass 2 der minimal mögliche Wert des bitweisen ODER der verbleibenden Elemente von nums ist, nachdem höchstens k Operationen angewendet wurden.

Beispiel 3:

Eingabe: nums = [10,7,10,3,9,14,9,4], k = 1
Ausgabe: 15
Erläuterung: Ohne die Anwendung irgendwelcher Operationen beträgt das bitweise Oder von nums 15.
Es kann gezeigt werden, dass 15 der minimal mögliche Wert des bitweisen ODER der verbleibenden Elemente von nums ist, nachdem höchstens k Operationen angewendet wurden.

Einschränkungen:

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

Sie erhalten eine 0-indiziert Integer Array nums und eine Ganzzahl k.
In einer Operation können Sie einen beliebigen Index i von nums wählen, so dass 0 <= i < nums.length - 1 gilt, und nums[i] und nums[i + 1] durch ein einzelnes Vorkommen von nums[i] & nums[i + 1] ersetzen, wobei & für den bitweisen AND-Operator steht.
Gibt den minimal möglichen Wert des bitweise oder der verbleibenden Elemente von nums nach den meisten k -Operationen zurück.

Beispiel 1:

Eingabe: nums = [3,5,3,2,7], k = 2
Ausgabe: 3
Erläuterung: Lassen Sie uns folgende Operationen ausführen:
1. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [1,3,2,7] wird.
2. Ersetzen Sie nums[2] und nums[3] durch (nums[2] & nums[3]), so dass nums gleich [1,3,2] wird.
Das bitweise oder der endgültige Array beträgt 3.
Es kann gezeigt werden, dass 3 der minimal mögliche Wert des bitweise oder der verbleibenden Elemente von NUMs nach Anwendung nach der Anwendung von höchstens k Operationen ist.
Beispiel 2:

Eingabe: nums = [7,3,15,14,2,8], k = 4
Ausgabe: 2
Erläuterung: Lassen Sie uns folgende Operationen ausführen:
1. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [3,15,14,2,8] wird.
2. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [3,14,2,8] wird.
3. Ersetzen Sie nums[0] und nums[1] durch (nums[0] & nums[1]), so dass nums gleich [2,2,8] wird.
4. Ersetzen Sie nums[1] und nums[2] durch (nums[1] & nums[2]), so dass nums gleich [2,0] wird.
Das bitweise oder der endgültige Array beträgt 2.
Es kann gezeigt werden, dass 2 der minimal mögliche Wert des Bitweisens oder der verbleibenden Elemente von nums nach Anwendung nach der Anwendung von höchstens k Operationen ist.

Beispiel 3:

Eingabe: nums = [10,7,10,3,9,14,9,4], k = 1
Ausgabe: 15
Erläuterung: Ohne Operationen beträgt die bitweise oder von nums 15.
Es kann gezeigt werden, dass 15 der minimal mögliche Wert des bitweise oder der verbleibenden Elemente von nums nach Anwendung nach der Anwendung von höchstens k Operationen ist.

Einschränkungen:

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


Sie erhalten ein Array positiver Ganzzahlen der Länge n.
Ein Polygon ist eine geschlossene ebene Figur mit mindestens drei Seiten. Die längste Seite eines Polygons ist kleiner als die Summe seiner anderen Seiten.
Umgekehrt, wenn Sie k (k >= 3) positive reelle Zahlen a_1, a_2, a_3, ..., a_k haben, wobei a_1 <= a_2 <= a_3 <= ... <= a_k und a_1 + a_2 + a_3 + . .. + a_k-1 > a_k, dann existiert immer ein Polygon mit k Seiten, deren Längen a_1, a_2, a_3, ..., a_k sind.
Der Umfang eines Polygons ist die Summe der Längen seiner Seiten.
Gibt den größtmöglichen Umfang eines Polygons zurück, dessen Seiten aus Zahlen gebildet werden können, oder -1, wenn es nicht möglich ist, ein Polygon zu erstellen.

Beispiel 1:

Eingabe: nums = [5,5,5]
Ausgabe: 15
Erläuterung: Das einzig mögliche Polygon, das aus Zahlen erstellt werden kann, hat drei Seiten: 5, 5 und 5. Der Umfang beträgt 5 + 5 + 5 = 15.

Beispiel 2:

Eingabe: nums = [1,12,1,2,5,50,3]
Ausgabe: 12
Erläuterung: Das Polygon mit dem größten Umfang, der aus Zahlen erstellt werden kann, hat 5 Seiten: 1, 1, 2, 3 und 5. Der Umfang ist 1 + 1 + 2 + 3 + 5 = 12.
Wir können kein Polygon mit 12 oder 50 als längster Seite haben, da es nicht möglich ist, zwei oder mehr kleinere Seiten einzubeziehen, deren Summe größer ist als jede dieser Seiten.
Es lässt sich zeigen, dass der größtmögliche Umfang 12 beträgt.

Beispiel 3:

Eingabe: Zahlen = [5,5,50]
Ausgabe: -1
Erläuterung: Es gibt keine Möglichkeit, aus Zahlen ein Polygon zu bilden, da ein Polygon mindestens 3 Seiten hat und 50 > 5 + 5.

Einschränkungen:

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

Sie erhalten eine Reihe von positiven Ganzzahlen nums von Länge n.
Ein Polygon ist eine geschlossene Ebene mit mindestens 3 Seiten. Die längste Seite eines Polygons ist kleiner als die Summe seiner anderen Seiten.
Wenn Sie umgekehrt k (k> = 3) positive reelle Zahlen a_1, a_2, a_3, ..., a_k haben, wobei a_1 <= a_2 <= a_3 <= ... <= a_k und a_1 + a_2 + a_3 +. .. + a_k-1> a_k, dann gibt es immer ein Polygon mit k-Seiten, deren Längen a_1, a_2, a_3, ..., a_k sind.
Der Umfang eines Polygons ist die Summe der Längen seiner Seiten.
Geben Sie den größtmöglichen Umfang eines Polygons zurück, dessen Seiten aus nums gebildet werden können, oder -1, wenn es nicht möglich ist, ein Polygon zu erstellen.

Beispiel 1:

Eingabe: nums = [5,5,5]
Ausgabe: 15
Erläuterung: Das einzig mögliche Polygon, das aus NUMS hergestellt werden kann, hat 3 Seiten: 5, 5 und 5. Der Umfang beträgt 5 + 5 + 5 = 15.

Beispiel 2:

Eingabe: nums = [1,12,1,2,5,50,3]
Ausgabe: 12
Erläuterung: Das Polygon mit dem größten Umfang, der aus NUMS hergestellt werden kann, hat 5 Seiten: 1, 1, 2, 3 und 5. Der Umfang beträgt 1 + 1 + 2 + 3 + 5 = 12.
Wir können kein Polygon mit 12 oder 50 als längste Seite haben, da es nicht möglich ist, 2 oder mehr kleinere Seiten mit einer größeren Summe aufzunehmen als beide.
Es kann gezeigt werden, dass der größtmögliche Umfang 12 ist.

Beispiel 3:

Eingabe: nums = [5,5,50]
Ausgabe: -1
Erläuterung: Es gibt keine Möglichkeit, ein Polygon aus nums zu bilden, da ein Polygon mindestens 3 Seiten und 50> 5 + 5 hat.

Einschränkungen:

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


Sie erhalten ein Array von ganzen Zahlen der Länge n.
Die Kosten eines Arrays sind der Wert seines ersten Elements. Beispielsweise betragen die Kosten von [1,2,3] 1, während die Kosten von [3,4,1] 3 betragen.
Sie müssen Nums in drei disjunkte zusammenhängende Subarrays aufteilen.
Geben Sie die minimal mögliche Summe der Kosten dieser Unterarrays zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,12]
Ausgabe: 6
Erläuterung: Der bestmögliche Weg, drei Unterarrays zu bilden, ist: [1], [2] und [3,12] mit einem Gesamtaufwand von 1 + 2 + 3 = 6.
Die anderen Möglichkeiten, 3 Subarrays zu bilden, sind:
- [1], [2,3] und [12] zu einem Gesamtpreis von 1 + 2 + 12 = 15.
- [1,2], [3] und [12] zu einem Gesamtpreis von 1 + 3 + 12 = 16.

Beispiel 2:

Eingabe: nums = [5,4,3]
Ausgabe: 12
Erläuterung: Der bestmögliche Weg, 3 Subarrays zu bilden, ist: [5], [4] und [3] mit einem Gesamtaufwand von 5 + 4 + 3 = 12.
Es kann gezeigt werden, dass 12 die minimal erreichbaren Kosten sind.

Beispiel 3:

Eingabe: nums = [10,3,1,1]
Ausgabe: 12
Erläuterung: Der bestmögliche Weg, drei Subarrays zu bilden, ist: [10,3], [1] und [1] mit einem Gesamtaufwand von 10 + 1 + 1 = 12.
Es kann gezeigt werden, dass 12 die minimal erreichbaren Kosten sind.

Einschränkungen:

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

Sie erhalten ein Array ganzer Zahlen der Länge n.
Die Kosten eines Arrays sind der Wert seines ersten Elements. Beispielsweise betragen die Kosten von [1,2,3] 1, während die Kosten von [3,4,1] 3 betragen.
Sie müssen Nums in drei disjunkte zusammenhängende Subarrays aufteilen.
Geben Sie die minimal mögliche Summe der Kosten dieser Unterarrays zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,12]
Ausgabe: 6
Erläuterung: Der bestmögliche Weg, drei Unterarrays zu bilden, ist: [1], [2] und [3,12] mit einem Gesamtaufwand von 1 + 2 + 3 = 6.
Die anderen Möglichkeiten, 3 Subarrays zu bilden, sind:
- [1], [2,3] und [12] zu einem Gesamtpreis von 1 + 2 + 12 = 15.
- [1,2], [3] und [12] zu einem Gesamtpreis von 1 + 3 + 12 = 16.

Beispiel 2:

Eingabe: nums = [5,4,3]
Ausgabe: 12
Erläuterung: Der bestmögliche Weg, 3 Subarrays zu bilden, ist: [5], [4] und [3] mit einem Gesamtaufwand von 5 + 4 + 3 = 12.
Es kann gezeigt werden, dass 12 die minimal erreichbaren Kosten sind.

Beispiel 3:

Eingabe: nums = [10,3,1,1]
Ausgabe: 12
Erläuterung: Der bestmögliche Weg, drei Subarrays zu bilden, ist: [10,3], [1] und [1] mit einem Gesamtaufwand von 10 + 1 + 1 = 12.
Es kann gezeigt werden, dass 12 die minimal erreichbaren Kosten sind.

Einschränkungen:

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

Gegeben ist ein Array von ganzen Zahlen der Länge `n`.
Die Kosten eines Arrays sind der Wert seines ersten Elements. Zum Beispiel sind die Kosten von [1,2,3] 1, während die Kosten von [3,4,1] 3 sind.
Du musst Nummer in 3 disjunkte zusammenhängende Teilarrays unterteilen.
Gib die kleinstmögliche Summe der Kosten dieser Teilarrays zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,12]
Ausgabe: 6
Erklärung: Der beste Weg, 3 Teilarrays zu bilden, ist: [1], [2] und [3,12] mit Gesamtkosten von 1 + 2 + 3 = 6.
Die anderen möglichen Wege, um 3 Teilarrays zu bilden, sind:
- [1], [2,3] und [12] mit Gesamtkosten von 1 + 2 + 12 = 15.
- [1,2], [3] und [12] mit Gesamtkosten von 1 + 3 + 12 = 16.

Beispiel 2:

Eingabe: nums = [5,4,3]
Ausgabe: 12
Erklärung: Der beste Weg, 3 Teilarrays zu bilden, ist: [5], [4] und [3] mit Gesamtkosten von 5 + 4 + 3 = 12.
Es kann gezeigt werden, dass 12 die minimal erreichbaren Kosten sind.

Beispiel 3:

Eingabe: nums = [10,3,1,1]
Ausgabe: 12
Erklärung: Der beste Weg, 3 Teilarrays zu bilden, ist: [10,3], [1] und [1] mit Gesamtkosten von 10 + 1 + 1 = 12.
Es kann gezeigt werden, dass 12 die minimal erreichbaren Kosten sind.

Beschränkungen:

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


Du hast ein Array nums der Länge n und eine positive ganze Zahl k.
Ein Subarray von nums wird als gut bezeichnet, wenn der absolute Unterschied zwischen seinem ersten und letzten Element genau k beträgt, also ist der Subarray nums[i..j] gut, wenn |nums[i] - nums[j]| == k.
Gib die maximale Summe eines guten Subarrays von nums zurück. Wenn es keine guten Subarrays gibt, gib 0 zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5,6], k = 1
Ausgabe: 11
Erläuterung: Der absolute Unterschied zwischen dem ersten und letzten Element muss für ein gutes Subarray 1 sein. Alle guten Subarrays sind: [1,2], [2,3], [3,4], [4,5] und [5,6]. Die maximale Subarraysumme ist 11 für das Subarray [5,6].

Beispiel 2:

Eingabe: nums = [-1,3,2,4,5], k = 3
Ausgabe: 11
Erläuterung: Der absolute Unterschied zwischen dem ersten und letzten Element muss für ein gutes Subarray 3 sein. Alle guten Subarrays sind: [-1,3,2] und [2,4,5]. Die maximale Subarraysumme ist 11 für das Subarray [2,4,5].

Beispiel 3:

Eingabe: nums = [-1,-2,-3,-4], k = 2
Ausgabe: -6
Erläuterung: Der absolute Unterschied zwischen dem ersten und letzten Element muss für ein gutes Subarray 2 sein. Alle guten Subarrays sind: [-1,-2,-3] und [-2,-3,-4]. Die maximale Subarraysumme ist -6 für das Subarray [-1,-2,-3].

Beschränkungen:

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

Sie erhalten ein Array mit der Länge n und einer positiven ganzen Zahl k.
Ein Subarray von Nums heißt gut, wenn die absolute Differenz zwischen seinem ersten und letzten Element genau k beträgt, mit anderen Worten, das Subarray Nums[i..j] ist gut, wenn |nums[i] - Nums[j]| == k.
Gibt die maximale Summe eines guten Subarrays von Nums zurück. Wenn keine guten Subarrays vorhanden sind, geben Sie 0 zurück.

Beispiel 1:

Eingabe: Zahlen = [1,2,3,4,5,6], k = 1
Ausgabe: 11
Erläuterung: Für ein gutes Subarray muss die absolute Differenz zwischen dem ersten und dem letzten Element 1 sein. Alle guten Subarrays sind: [1,2], [2,3], [3,4], [4,5] und [5,6]. Die maximale Subarray-Summe beträgt 11 für das Subarray [5,6].

Beispiel 2:

Eingabe: Zahlen = [-1,3,2,4,5], k = 3
Ausgabe: 11
Erläuterung: Für ein gutes Subarray muss die absolute Differenz zwischen dem ersten und dem letzten Element 3 betragen. Alle guten Subarrays sind: [-1,3,2] und [2,4,5]. Die maximale Subarray-Summe beträgt 11 für das Subarray [2,4,5].

Beispiel 3:

Eingabe: nums = [-1,-2,-3,-4], k = 2
Ausgabe: -6
Erläuterung: Für ein gutes Subarray muss die absolute Differenz zwischen dem ersten und dem letzten Element 2 betragen. Alle guten Subarrays sind: [-1,-2,-3] und [-2,-3,-4]. Die maximale Subarray-Summe beträgt -6 für das Subarray [-1,-2,-3].

Einschränkungen:

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

Sie erhalten ein Array nums der Länge n und eine positive Ganzzahl k.
Eine Subarray von NUMs wird als gut bezeichnet, wenn der absolute Unterschied zwischen seinem ersten und dem letzten Element genau k ist, mit anderen Worten, die Subarray -nums[i..j] gut ist, wenn |nums[i] - nums[j]| == k.
Geben Sie die maximale Summe eines guten Subarrays von nums zurück. Wenn es keine guten Subarray gibt, kehren Sie 0 zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5,6], k = 1
Ausgabe: 11
Erläuterung: Der absolute Unterschied zwischen dem ersten und dem letzten Element muss 1 für ein gutes Subarray sein. Alle guten Subarray sind: [1,2], [2,3], [3,4], [4,5] und [5,6]. Die maximale Summe des Subarrays beträgt 11 für das Subarray [5,6].

Beispiel 2:

Eingabe: nums = [-1,3,2,4,5], k = 3
Ausgabe: 11
Erläuterung: Der absolute Unterschied zwischen dem ersten und dem letzten Element muss 3 für eine gute Subarray sein. Alle guten Subarray sind: [-1,3,2] und [2,4,5]. Die maximale Subarray -Summe beträgt 11 für die Subarray [2,4,5].

Beispiel 3:

Eingabe: nums = [-1, -2, -3, -4], k = 2
Ausgabe: -6
Erläuterung: Der absolute Unterschied zwischen dem ersten und dem letzten Element muss 2 für ein gutes Subarray sein. Alle guten Subarray sind: [-1,-2,-3], und [-2,-3,-4]. Die maximale Subarray-Summe beträgt -6 für das Subarray [-1,-2,-3].

Einschränkungen:

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


Sie erhalten eine Zeichenfolge s, die aus englischen Kleinbuchstaben besteht.
Eine Zeichenfolge wird als speziell bezeichnet, wenn sie nur aus einem einzigen Zeichen besteht. Zum Beispiel ist die Zeichenkette „abc“ nicht speziell, während die Zeichenketten „ddd“, „zz“ und „f“ speziell sind.
Gibt die Länge der längsten speziellen Teilzeichenkette von s zurück, die mindestens dreimal vorkommt, oder -1, wenn keine spezielle Teilzeichenkette mindestens dreimal vorkommt.
Eine Teilzeichenkette ist eine zusammenhängende, nicht leere Folge von Zeichen innerhalb einer Zeichenkette.

Beispiel 1:

Eingabe: s = "aaaa"
Ausgabe: 2
Erläuterung: Die längste spezielle Teilzeichenkette, die dreimal vorkommt, ist „aa“: Teilzeichenketten „aaaa“, „aaaa“, und „aaaa“.
Es kann gezeigt werden, dass die maximal erreichbare Länge 2 ist.

Beispiel 2:

Eingabe: s = "abcdef"
Ausgabe: -1
Erläuterung: Es gibt keine spezielle Teilzeichenkette, die mindestens dreimal vorkommt. Daher wird -1 zurückgegeben.

Beispiel 3:

Eingabe: s = "abcaba"
Ausgabe: 1
Erläuterung: Die längste spezielle Teilzeichenkette, die dreimal vorkommt, ist „a“: Teilzeichenketten „abcaba“, „abcaba“, und „abcaba“.
Es kann gezeigt werden, dass die maximal erreichbare Länge 1 ist.

Constraints:

3 <= s.length <= 50
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenfolge s, die aus englischen Kleinbuchstaben besteht.
Eine Zeichenfolge wird als speziell bezeichnet, wenn sie nur aus einem einzigen Zeichen besteht. Beispielsweise ist die Zeichenfolge „abc“ nichts Besonderes, wohingegen die Zeichenfolgen „ddd“, „zz“ und „f“ etwas Besonderes sind.
Gibt die Länge des längsten speziellen Teilstrings von s zurück, der mindestens dreimal vorkommt, oder -1, wenn kein spezieller Teilstring mindestens dreimal vorkommt.
Ein Teilstring ist eine zusammenhängende, nicht leere Folge von Zeichen innerhalb eines Strings.

Beispiel 1:

Eingabe: s = „aaaa“
Ausgabe: 2
Erläuterung: Die längste spezielle Teilzeichenfolge, die dreimal vorkommt, ist „aa“: Teilzeichenfolgen „aaaa“, „aaaa“ und „aaaa“.
Es kann gezeigt werden, dass die maximal erreichbare Länge 2 beträgt.

Beispiel 2:

Eingabe: s = "abcdef"
Ausgabe: -1
Erläuterung: Es gibt keine spezielle Teilzeichenfolge, die mindestens dreimal vorkommt. Daher Rückgabe -1.

Beispiel 3:

Eingabe: s = „abcaba“
Ausgabe: 1
Erläuterung: Die längste spezielle Teilzeichenfolge, die dreimal vorkommt, ist „a“: Teilzeichenfolgen „abcaba“, „abcaba“ und „abcaba“.
Es kann gezeigt werden, dass die maximal erreichbare Länge 1 beträgt.

Einschränkungen:

3 <= s.length <= 50
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenfolge s, die aus englischen Kleinbuchstaben besteht.
Eine Zeichenfolge wird als speziell bezeichnet, wenn sie nur aus einem einzigen Zeichen besteht. Beispielsweise ist die Zeichenfolge „abc“ nicht speziell, während die Zeichenfolgen „ddd“, „zz“ und „f“ speziell sind.
Gibt die Länge des längsten speziellen Teilstrings von s zurück, der mindestens dreimal vorkommt, oder -1, wenn kein spezieller Teilstring mindestens dreimal vorkommt.
Ein Teilstring ist eine zusammenhängende, nicht leere Folge von Zeichen innerhalb eines Strings.

Beispiel 1:

Eingabe: s = „aaaa“
Ausgabe: 2
Erläuterung: Die längste spezielle Teilzeichenfolge, die dreimal vorkommt, ist „aa“: Teilzeichenfolgen „aaaa“, „aaaa“ und „aaaa“.
Es kann gezeigt werden, dass die maximal erreichbare Länge 2 beträgt.

Beispiel 2:

Eingabe: s = "abcdef"
Ausgabe: -1
Erläuterung: Es gibt keine spezielle Teilzeichenfolge, die mindestens dreimal vorkommt. Daher Rückgabe -1.

Beispiel 3:

Eingabe: s = „abcaba“
Ausgabe: 1
Erläuterung: Die längste spezielle Teilzeichenfolge, die dreimal vorkommt, ist „a“: Teilzeichenfolgen „abcaba“, „abcaba“ und „abcaba“.
Es kann gezeigt werden, dass die maximal erreichbare Länge 1 beträgt.

Einschränkungen:

3 <= s.length <= 50
s besteht nur aus englischen Kleinbuchstaben.


Du hast ein 0-indiziertes ganzzahliges Array nums der Größe n und ein 0-indiziertes ganzzahliges Array pattern der Größe m, bestehend aus den Zahlen -1, 0 und 1. Ein Teilarray nums[i..j] der Größe m + 1 wird als übereinstimmend mit dem Muster betrachtet, wenn die folgenden Bedingungen für jedes Element pattern[k] zutreffen:

nums[i + k + 1] > nums[i + k] falls pattern[k] == 1.
nums[i + k + 1] == nums[i + k] falls pattern[k] == 0.
nums[i + k + 1] < nums[i + k] falls pattern[k] == -1.

Gib die Anzahl der Teilarrays in nums zurück, die dem Muster entsprechen.

Beispiel 1:

Input: nums = [1,2,3,4,5,6], pattern = [1,1]
Output: 4
Erläuterung: Das Muster [1,1] gibt an, dass wir nach streng steigenden Teilarrays der Größe 3 suchen. Im Array nums entsprechen die Teilarrays [1,2,3], [2,3,4], [3,4,5] und [4,5,6] diesem Muster.
Daher gibt es 4 Teilarrays in nums, die dem Muster entsprechen.

Beispiel 2:

Input: nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
Output: 2
Erläuterung: Hier gibt das Muster [1,0,-1] an, dass wir nach einer Sequenz suchen, bei der die erste Zahl kleiner ist als die zweite, die zweite gleich der dritten, und die dritte größer als die vierte ist. Im Array nums entsprechen die Teilarrays [1,4,4,1] und [3,5,5,3] diesem Muster.
Daher gibt es 2 Teilarrays in nums, die dem Muster entsprechen.

Beschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array der Größe n und ein 0-indiziertes Ganzzahl-Array-Muster der Größe m, bestehend aus den Ganzzahlen -1, 0 und 1.
Ein Subarray nums[i..j] der Größe m + 1 soll mit dem Muster übereinstimmen, wenn die folgenden Bedingungen für jedes Elementmuster[k] gelten:

nums[i + k + 1] > nums[i + k], wenn Muster[k] == 1.
nums[i + k + 1] == nums[i + k], wenn Muster[k] == 0.
nums[i + k + 1] < nums[i + k], wenn Muster[k] == -1.

Gibt die Anzahl der Subarrays in nums zurück, die dem Muster entsprechen.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5,6], Muster = [1,1]
Ausgabe: 4
Erläuterung: Das Muster [1,1] zeigt an, dass wir nach streng ansteigenden Subarrays der Größe 3 suchen. In den Array-Nums sind die Subarrays [1,2,3], [2,3,4], [3,4, 5] und [4,5,6] entsprechen diesem Muster.
Daher gibt es in Nums 4 Subarrays, die dem Muster entsprechen.

Beispiel 2:

Eingabe: nums = [1,4,4,1,3,5,5,3], Muster = [1,0,-1]
Ausgabe: 2
Erläuterung: Hier zeigt das Muster [1,0,-1] an, dass wir nach einer Sequenz suchen, bei der die erste Zahl kleiner als die zweite, die zweite gleich der dritten und die dritte größer als die vierte ist. In den Array-Nummern stimmen die Subarrays [1,4,4,1] und [3,5,5,3] mit diesem Muster überein.
Daher gibt es in Nums zwei Subarrays, die dem Muster entsprechen.

Einschränkungen:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == Muster.Länge < n
-1 <= Muster[i] <= 1

Sie erhalten ein 0-indiziertes Ganzzahl-Array der Größe n und ein 0-indiziertes Ganzzahl-Array-Muster der Größe m, bestehend aus den Ganzzahlen -1, 0 und 1.
Ein Subarray nums[i..j] der Größe m + 1 soll mit dem Muster übereinstimmen, wenn die folgenden Bedingungen für jedes Elementmuster[k] gelten:

nums[i + k + 1] > nums[i + k], wenn Muster[k] == 1.
nums[i + k + 1] == nums[i + k], wenn Muster[k] == 0.
nums[i + k + 1] <nums[i + k], wenn Muster[k] == -1.

Gibt die Anzahl der Subarrays in nums zurück, die dem Muster entsprechen.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5,6], Muster = [1,1]
Ausgabe: 4
Erläuterung: Das Muster [1,1] zeigt an, dass wir nach streng aufsteigenden Unterfeldern der Größe 3 suchen. In dem Array nums entsprechen die Subarrays [1,2,3], [2,3,4], [3,4,5] und [4,5,6] diesem Muster.
Es gibt also 4 Subarrays in nums, die dem Muster entsprechen.

Beispiel 2:

Eingabe: nums = [1,4,4,1,3,5,5,3], Muster = [1,0,-1]
Ausgabe: 2
Erläuterung: Hier zeigt das Muster [1,0,-1] an, dass wir nach einer Sequenz suchen, bei der die erste Zahl kleiner als die zweite, die zweite gleich der dritten und die dritte größer als die vierte ist. In den Array-Nummern stimmen die Subarrays [1,4,4,1] und [3,5,5,3] mit diesem Muster überein.
Daher gibt es in Nums zwei Subarrays, die dem Muster entsprechen.

Einschränkungen:

2 <= n == nums.length <= 100
1 <= nums[i] <= 10^9
1 <= m == Muster.Länge < n
-1 <= Muster[i] <= 1


Alice und Bob spielen ein rundenbasiertes Spiel auf einem runden, von Blumen umgebenen Feld. Der Kreis stellt das Feld dar, und zwischen Alice und Bob befinden sich x Blumen im Uhrzeigersinn und dazwischen y Blumen entgegen dem Uhrzeigersinn.
Das Spiel läuft wie folgt ab:

Alice ist als erste an der Reihe.
In jeder Runde muss ein Spieler entweder die Richtung im oder gegen den Uhrzeigersinn wählen und eine Blume von dieser Seite pflücken.
Wenn am Ende des Zuges überhaupt keine Blumen mehr übrig sind, fängt der aktuelle Spieler seinen Gegner und gewinnt das Spiel.

Bei zwei gegebenen ganzen Zahlen, n und m, besteht die Aufgabe darin, die Anzahl möglicher Paare (x, y) zu berechnen, die die folgenden Bedingungen erfüllen:

Alice muss das Spiel nach den beschriebenen Regeln gewinnen.
Die Anzahl der Blumen x im Uhrzeigersinn muss im Bereich [1,n] liegen.
Die Anzahl der Blumen y gegen den Uhrzeigersinn muss im Bereich [1,m] liegen.

Gibt die Anzahl möglicher Paare (x, y) zurück, die die in der Anweisung genannten Bedingungen erfüllen.

Beispiel 1:

Eingabe: n = 3, m = 2
Ausgabe: 3
Erläuterung: Die folgenden Paare erfüllen die in der Anweisung beschriebenen Bedingungen: (1,2), (3,2), (2,1).

Beispiel 2:

Eingabe: n = 1, m = 1
Ausgabe: 0
Erläuterung: Keine Paare erfüllen die in der Anweisung beschriebenen Bedingungen.

Einschränkungen:

1 <= n, m <= 10^5

Alice und Bob spielen ein rundenbasiertes Spiel auf einem kreisförmigen Feld, das von Blumen umgeben ist. Der Kreis stellt das Feld dar, und zwischen Alice und Bob befinden sich x Blumen im Uhrzeigersinn und zwischen ihnen y Blumen gegen den Uhrzeigersinn.
Das Spiel läuft wie folgt ab:

Alice ist an der Reihe.
In jedem Zug muss ein Spieler entweder die Richtung im Uhrzeigersinn oder gegen den Uhrzeigersinn wählen und eine Blume von dieser Seite pflücken.
Am Ende des Zuges, wenn gar keine Blumen mehr übrig sind, schlägt der aktuelle Spieler seinen Gegner und gewinnt das Spiel.

Bei zwei ganzen Zahlen, n und m, besteht die Aufgabe darin, die Anzahl der möglichen Paare (x, y) zu berechnen, die die Bedingungen erfüllen:

Alice muss das Spiel nach den beschriebenen Regeln gewinnen.
Die Anzahl der Blüten x im Uhrzeigersinn muss im Bereich [1,n] liegen.
Die Anzahl der Blüten y gegen den Uhrzeigersinn muss im Bereich [1,m] liegen.

Gibt die Anzahl der möglichen Paare (x, y) zurück, die die in der Anweisung genannten Bedingungen erfüllen.

Beispiel 1:

Eingang: n = 3, m = 2
Ausgang: 3
Erläuterung: Die folgenden Paare erfüllen die in der Anweisung beschriebenen Bedingungen: (1,2), (3,2), (2,1).

Beispiel 2:

Eingang: n = 1, m = 1
Ausgang: 0
Erläuterung: Kein Paar erfüllt die in der Anweisung beschriebenen Bedingungen.

Zwänge:

1 <= n, m <= 10^5


Sie erhalten ein 0-indiziertes Array positiver Ganzzahlen.
In einem Vorgang können Sie zwei beliebige benachbarte Elemente vertauschen, wenn sie die gleiche Anzahl gesetzter Bits haben. Sie können diesen Vorgang beliebig oft ausführen (einschließlich null).
Geben Sie „true“ zurück, wenn Sie das Array sortieren können, andernfalls geben Sie „false“ zurück.

Beispiel 1:

Eingabe: nums = [8,4,2,30,15]
Ausgabe: wahr
Erläuterung: Schauen wir uns die binäre Darstellung jedes Elements an. Die Zahlen 2, 4 und 8 haben jeweils ein gesetztes Bit mit binärer Darstellung „10“, „100“ bzw. „1000“. Die Zahlen 15 und 30 haben jeweils vier gesetzte Bits mit binärer Darstellung „1111“ und „11110“.
Wir können das Array mit 4 Operationen sortieren:
- Tausche Nums[0] mit Nums[1]. Diese Operation ist gültig, da 8 und 4 jeweils ein gesetztes Bit haben. Das Array wird zu [4,8,2,30,15].
- Tausche Nums[1] mit Nums[2]. Diese Operation ist gültig, da 8 und 2 jeweils ein gesetztes Bit haben. Das Array wird zu [4,2,8,30,15].
- Tausche Nums[0] mit Nums[1]. Diese Operation ist gültig, da 4 und 2 jeweils ein gesetztes Bit haben. Das Array wird zu [2,4,8,30,15].
- Tausche Nums[3] mit Nums[4]. Diese Operation ist gültig, da 30 und 15 jeweils vier gesetzte Bits haben. Das Array wird zu [2,4,8,15,30].
Das Array wurde sortiert, daher geben wir true zurück.
Beachten Sie, dass es möglicherweise andere Operationssequenzen gibt, die das Array ebenfalls sortieren.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: wahr
Erläuterung: Das Array ist bereits sortiert, daher geben wir true zurück.

Beispiel 3:

Eingabe: nums = [3,16,8,4,2]
Ausgabe: falsch
Erläuterung: Es kann gezeigt werden, dass es nicht möglich ist, das Eingabearray mit beliebig vielen Operationen zu sortieren.

Einschränkungen:

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

Sie erhalten eine 0-indizierte Auswahl positiver Zahlen.
In einer Operation können Sie zwei benachbarte Elemente austauschen, wenn sie die gleiche Anzahl von festgelegten Bits haben. Sie dürfen diesen Vorgang jederzeit (einschließlich Null) ausführen.
Geben Sie true zurück, wenn Sie das Array sortieren können, sonst return false zurück.

Beispiel 1:

Eingabe: nums = [8,4,2,30,15]
Ausgabe: true
Erläuterung: Schauen wir uns die binäre Darstellung jedes Elements an. Die Zahlen 2, 4 und 8 haben je ein gesetztes Bit mit der Binärdarstellung „10“, „100“ bzw. „1000“. Die Zahlen 15 und 30 haben je vier gesetzte Bits mit der Binärdarstellung „1111“ und „11110“.
Wir können das Array mit 4 Operationen sortieren:
- nums [0] mit nums [1] tauschen. Diese Operation ist gültig, da 8 und 4 jeweils ein set Bit haben. Das Array wird [4,8,2,30,15].
- nums [1] mit nums [2] tauschen. Diese Operation ist gültig, da 8 und 2 jeweils ein set Bit haben. Das Array wird [4,2,8,30,15].
- nums [0] mit nums [1] tauschen. Diese Operation ist gültig, da 4 und 2 jeweils ein set Bit haben. Das Array wird [2,4,8,30,15].
- nums [3] mit nums [4] tauschen. Diese Operation ist gültig, da 30 und 15 jeweils vier festgelegte Bits haben. Das Array wird [2,4,8,15,30].
Das Array ist sortiert geworden, daher kehren wir wahr.
Beachten Sie, dass es andere Operationssequenzen geben kann, die auch das Array sortieren.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: true
Erläuterung: Das Array ist bereits sortiert, daher geben wir true zurück.

Beispiel 3:

Eingabe: nums = [3,16,8,4,2]
Ausgabe: false
Erläuterung: Es kann gezeigt werden, dass es nicht möglich ist, das Eingangsarray mit einer beliebigen Anzahl von Operationen zu sortieren.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array positiver Ganzzahlen.
In einem Vorgang können Sie zwei beliebige benachbarte Elemente vertauschen, wenn sie die gleiche Anzahl gesetzter Bits haben. Sie können diesen Vorgang beliebig oft (einschließlich null) ausführen.
Geben Sie „true“ zurück, wenn Sie das Array sortieren können, andernfalls geben Sie „false“ zurück.

Beispiel 1:

Eingabe: nums = [8,4,2,30,15]
Ausgabe: wahr
Erläuterung: Schauen wir uns die binäre Darstellung jedes Elements an. Die Zahlen 2, 4 und 8 haben jeweils ein gesetztes Bit mit binärer Darstellung „10“, „100“ bzw. „1000“. Die Zahlen 15 und 30 haben jeweils vier gesetzte Bits mit binärer Darstellung „1111“ und „11110“.
Wir können das Array mit 4 Operationen sortieren:
- Tausche nums[0] mit nums[1]. Diese Operation ist gültig, da 8 und 4 jeweils ein gesetztes Bit haben. Das Array wird zu [4,8,2,30,15].
- Tausche Nums[1] mit Nums[2]. Diese Operation ist gültig, da 8 und 2 jeweils ein gesetztes Bit haben. Das Array wird zu [4,2,8,30,15].
- Tausche Nums[0] mit Nums[1]. Diese Operation ist gültig, da 4 und 2 jeweils ein gesetztes Bit haben. Das Array wird zu [2,4,8,30,15].
- Tausche Nums[3] mit Nums[4]. Diese Operation ist gültig, da 30 und 15 jeweils vier gesetzte Bits haben. Das Array wird zu [2,4,8,15,30].
Das Array wurde sortiert, daher geben wir true zurück.
Beachten Sie, dass es möglicherweise andere Operationssequenzen gibt, die das Array ebenfalls sortieren.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: wahr
Erläuterung: Das Array ist bereits sortiert, daher geben wir true zurück.

Beispiel 3:

Eingabe: nums = [3,16,8,4,2]
Ausgabe: falsch
Erläuterung: Es kann gezeigt werden, dass es nicht möglich ist, das Eingabearray mit beliebig vielen Operationen zu sortieren.

Einschränkungen:

1 <= Anzahl.Länge <= 100
1 <= nums[i] <= 2^8


Sie erhalten zwei 1-indizierte Integer-Arrays, nums und changeIndices, mit den Längen n bzw. m.
Zunächst sind alle Indizes in Nums nicht markiert. Ihre Aufgabe besteht darin, alle Indizes in Zahlen zu markieren.
In jeder Sekunde, s, in der Reihenfolge von 1 bis m (einschließlich), können Sie eine der folgenden Operationen ausführen:

Wählen Sie einen Index i im Bereich [1, n] und dekrementieren Sie nums[i] um 1.
Wenn nums[changeIndices[s]] gleich 0 ist, markieren Sie den Index changeIndices[s].
Nichts tun.

Gibt eine Ganzzahl zurück, die die früheste Sekunde im Bereich [1, m] angibt, wenn alle Indizes in Nums durch optimale Auswahl von Operationen markiert werden können, oder -1, wenn dies unmöglich ist.

Beispiel 1:

Eingabe: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Ausgabe: 8
Erläuterung: In diesem Beispiel haben wir 8 Sekunden. Die folgenden Operationen können durchgeführt werden, um alle Indizes zu markieren:
Sekunde 1: Wählen Sie Index 1 und dekrementieren Sie nums[1] um eins. nums wird zu [1,2,0].
Sekunde 2: Wählen Sie Index 1 und dekrementieren Sie nums[1] um eins. nums wird zu [0,2,0].
Sekunde 3: Wählen Sie Index 2 und dekrementieren Sie nums[2] um eins. nums wird zu [0,1,0].
Sekunde 4: Wählen Sie Index 2 und dekrementieren Sie nums[2] um eins. nums wird zu [0,0,0].
Zweite 5: Markieren Sie den Index changeIndices[5], der Index 3 markiert, da nums[3] gleich 0 ist.
Zweiter 6: Markieren Sie den Index changeIndices[6], der Index 2 markiert, da nums[2] gleich 0 ist.
Zweite 7: Nichts tun.
Zweiter 8: Markieren Sie den Index changeIndices[8], der Index 1 markiert, da nums[1] gleich 0 ist.
Jetzt sind alle Indizes markiert.
Es lässt sich zeigen, dass es nicht möglich ist, alle Indizes vor der 8. Sekunde zu markieren.
Daher ist die Antwort 8.

Beispiel 2:

Eingabe: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Ausgabe: 6
Erläuterung: In diesem Beispiel haben wir 7 Sekunden. Die folgenden Operationen können durchgeführt werden, um alle Indizes zu markieren:
Sekunde 1: Wählen Sie Index 2 und dekrementieren Sie nums[2] um eins. nums wird zu [1,2].
Sekunde 2: Wählen Sie Index 2 und dekrementieren Sie nums[2] um eins. nums wird zu [1,1].
Sekunde 3: Wählen Sie Index 2 und dekrementieren Sie nums[2] um eins. nums wird zu [1,0].
Zweiter 4: Markieren Sie den Index changeIndices[4], der Index 2 markiert, da nums[2] gleich 0 ist.
Sekunde 5: Wählen Sie Index 1 und dekrementieren Sie nums[1] um eins. nums wird zu [0,0].
Zweiter 6: Markieren Sie den Index changeIndices[6], der Index 1 markiert, da nums[1] gleich 0 ist.
Jetzt sind alle Indizes markiert.
Es lässt sich zeigen, dass es nicht möglich ist, alle Indizes vor der 6. Sekunde zu markieren.
Daher lautet die Antwort 6.

Beispiel 3:

Eingabe: nums = [0,1], changeIndices = [2,2,2]
Ausgabe: -1
Erläuterung: In diesem Beispiel ist es unmöglich, alle Indizes zu markieren, da Index 1 nicht in changeIndices enthalten ist.
Daher ist die Antwort -1.

Einschränkungen:

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

Sie erhalten zwei 1-indizierte ganzzahlige Arrays, nums und changeIndices, mit den Längen n bzw. m.
Zu Beginn sind alle Indizes in Zahlen nicht markiert. Ihre Aufgabe ist es, alle Indizes in Zahlen zu markieren.
In jeder Sekunde s in der Reihenfolge von 1 bis m (einschließlich) können Sie eine der folgenden Operationen ausführen:

Wählen Sie einen Index i im Bereich [1, n] und dekrementieren Sie nums[i] um 1.
Wenn nums[changeIndices[s]] gleich 0 ist, markieren Sie den Index changeIndices[s].
Nichts tun.

Gibt eine Ganzzahl zurück, die die früheste Sekunde im Bereich [1, m] angibt, wenn alle Indizes in Zahlen markiert werden können, indem Operationen optimal ausgewählt werden, oder -1, wenn dies nicht möglich ist.

Beispiel 1:

Eingabe: nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1]
Ausgang: 8
Erklärung: In diesem Beispiel haben wir 8 Sekunden Zeit. Die folgenden Vorgänge können ausgeführt werden, um alle Indizes zu markieren:
Zweite 1: Wählen Sie Index 1 und dekrementieren Sie die Zahlen[1] um eins. nums wird zu [1,2,0].
Sekunde 2: Wählen Sie Index 1 und dekrementieren Sie nums[1] um eins. nums wird zu [0,2,0].
Sekunde 3: Wählen Sie Index 2 und dekrementieren Sie die Zahlen[2] um eins. nums wird zu [0,1,0].
Sekunde 4: Wählen Sie Index 2 und dekrementieren Sie die Zahlen[2] um eins. NUMS wird zu [0,0,0].
Zweite 5: Markieren Sie den Index changeIndices[5], der Index 3 markiert, da nums[3] gleich 0 ist.
Zweite 6: Markieren Sie den Index changeIndices[6], der Index 2 markiert, da nums[2] gleich 0 ist.
Sekunde 7: Tun Sie nichts.
Zweite 8: Markieren Sie den Index changeIndices[8], der Index 1 markiert, da nums[1] gleich 0 ist.
Nun sind alle Indizes markiert.
Es kann gezeigt werden, dass es nicht möglich ist, alle Indizes vor der 8. Sekunde zu markieren.
Daher lautet die Antwort 8.

Beispiel 2:

Eingabe: nums = [1,3], changeIndices = [1,1,1,2,1,1,1]
Ausgang: 6
Erklärung: In diesem Beispiel haben wir 7 Sekunden Zeit. Die folgenden Vorgänge können ausgeführt werden, um alle Indizes zu markieren:
Sekunde 1: Wählen Sie Index 2 und dekrementieren Sie die Zahlen[2] um eins. nums wird zu [1,2].
Sekunde 2: Wählen Sie Index 2 und dekrementieren Sie nums[2] um eins. nums wird zu [1,1].
Sekunde 3: Wählen Sie Index 2 und dekrementieren Sie die Zahlen[2] um eins. nums wird zu [1,0].
Zweite 4: Markieren Sie den Index changeIndices[4], der Index 2 markiert, da nums[2] gleich 0 ist.
Sekunde 5: Wählen Sie Index 1 und dekrementieren Sie nums[1] um eins. nums wird zu [0,0].
Zweite 6: Markieren Sie den Index changeIndices[6], der Index 1 markiert, da nums[1] gleich 0 ist.
Nun sind alle Indizes markiert.
Es kann gezeigt werden, dass es nicht möglich ist, alle Indizes vor der 6. Sekunde zu markieren.
Daher lautet die Antwort 6.

Beispiel 3:

Eingabe: nums = [0,1], changeIndices = [2,2,2]
Ausgang: -1
Erläuterung: In diesem Beispiel ist es unmöglich, alle Indizes zu markieren, da sich Index 1 nicht in changeIndices befindet.
Daher lautet die Antwort -1.

Zwänge:

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


Sie erhalten ein 0-indiziertes Zeichenfolgenwort und eine Ganzzahl k.
In jeder Sekunde müssen Sie die folgenden Vorgänge ausführen:

Entfernen Sie die ersten k Zeichen des Wortes.
Fügen Sie beliebige k Zeichen am Ende des Wortes hinzu.

Beachten Sie, dass Sie nicht unbedingt dieselben Zeichen hinzufügen müssen, die Sie entfernt haben. Sie müssen jedoch jede Sekunde beide Vorgänge ausführen.
Gibt die Mindestzeit größer als Null zurück, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 1:

Eingabe: Wort = „Abacaba“, k = 3
Ausgabe: 2
Erläuterung: In der ersten Sekunde entfernen wir die Zeichen „aba“ aus dem Präfix des Wortes und fügen die Zeichen „bac“ am Ende des Wortes hinzu. Somit wird das Wort gleichbedeutend mit „cababac“.
In der zweiten Sekunde entfernen wir die Zeichen „cab“ aus dem Präfix des Wortes und fügen „aba“ am Ende des Wortes hinzu. Dadurch wird das Wort gleichbedeutend mit „abacaba“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 2 Sekunden die Mindestzeit größer als Null ist, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 2:

Eingabe: Wort = „Abacaba“, k = 4
Ausgabe: 1
Erläuterung: In der ersten Sekunde entfernen wir die Zeichen „abac“ aus dem Präfix des Wortes und fügen die Zeichen „caba“ am Ende des Wortes hinzu. Somit wird das Wort gleichbedeutend mit „abacaba“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 1 Sekunde die Mindestzeit größer als Null ist, die erforderlich ist, damit ein Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 3:

Eingabe: Wort = „abcbabcd“, k = 2
Ausgabe: 4
Erläuterung: Jede Sekunde entfernen wir die ersten beiden Zeichen des Wortes und fügen dieselben Zeichen am Ende des Wortes hinzu.
Nach 4 Sekunden entspricht das Wort „abcbabcd“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 4 Sekunden die Mindestzeit größer als Null sind, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Einschränkungen:

1 <= Wortlänge <= 50
1 <= k <= Wortlänge
Das Wort besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein 0-indiziertes ZeichenfolgenWort und eine Ganzzahl k.
In jeder Sekunde müssen Sie die folgenden Vorgänge ausführen:

Entfernen Sie die ersten k Zeichen des Wortes.
Fügen Sie beliebige k Zeichen am Ende des Wortes hinzu.

Beachten Sie, dass Sie nicht unbedingt dieselben Zeichen hinzufügen müssen, die Sie entfernt haben. Sie müssen jedoch jede Sekunde beide Vorgänge ausführen.
Gibt die Mindestzeit größer als Null zurück, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 1:

Eingabe: Wort = „Abacaba“, k = 3
Ausgabe: 2
Erläuterung: In der ersten Sekunde entfernen wir die Zeichen „aba“ aus dem Präfix des Wortes und fügen die Zeichen „bac“ am Ende des Wortes hinzu. Somit wird das Wort gleichbedeutend mit „cababac“.
In der zweiten Sekunde entfernen wir die Zeichen „cab“ aus dem Präfix des Wortes und fügen „aba“ am Ende des Wortes hinzu. Dadurch wird das Wort gleichbedeutend mit „abacaba“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 2 Sekunden die Mindestzeit größer als Null ist, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 2:

Eingabe: Wort = „Abacaba“, k = 4
Ausgabe: 1
Erläuterung: In der ersten Sekunde entfernen wir die Zeichen „abac“ aus dem Präfix des Wortes und fügen am Ende des Wortes die Zeichen „caba“ hinzu. Dadurch wird das Wort gleichbedeutend mit „abacaba“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 1 Sekunde die Mindestzeit größer als Null ist, die erforderlich ist, damit ein Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 3:

Eingabe: Wort = „abcbabcd“, k = 2
Ausgabe: 4
Erläuterung: Jede Sekunde entfernen wir die ersten beiden Zeichen des Wortes und fügen dieselben Zeichen am Ende des Wortes hinzu.
Nach 4 Sekunden entspricht das Wort „abcbabcd“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 4 Sekunden die Mindestzeit größer als Null sind, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Einschränkungen:

1 <= Wortlänge <= 50
1 <= k <= Wortlänge
Das Wort besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein 0-indiziertes Zeichenfolgenwort und eine Ganzzahl k.
In jeder Sekunde müssen Sie die folgenden Vorgänge ausführen:

Entfernen Sie die ersten k Zeichen des Wortes.
Fügen Sie beliebige k Zeichen am Ende des Wortes hinzu.

Beachten Sie, dass Sie nicht unbedingt dieselben Zeichen hinzufügen müssen, die Sie entfernt haben. Sie müssen jedoch jede Sekunde beide Vorgänge ausführen.
Gibt die Mindestzeit größer als Null zurück, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 1:

Eingabe: Wort = „Abacaba“, k = 3
Ausgabe: 2
Erläuterung: In der ersten Sekunde entfernen wir die Zeichen „aba“ aus dem Präfix des Wortes und fügen die Zeichen „bac“ am Ende des Wortes hinzu. Somit wird das Wort gleichbedeutend mit „cababac“.
In der zweiten Sekunde entfernen wir die Zeichen „cab“ aus dem Präfix des Wortes und fügen „aba“ am Ende des Wortes hinzu. Dadurch wird das Wort gleichbedeutend mit „abacaba“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 2 Sekunden die Mindestzeit größer als Null ist, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 2:

Eingabe: Wort = „Abacaba“, k = 4
Ausgabe: 1
Erläuterung: In der ersten Sekunde entfernen wir die Zeichen „abac“ aus dem Präfix des Wortes und fügen am Ende des Wortes die Zeichen „caba“ hinzu. Dadurch wird das Wort gleichbedeutend mit „abacaba“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 1 Sekunde die Mindestzeit größer als Null ist, die erforderlich ist, damit ein Wort in seinen ursprünglichen Zustand zurückkehrt.

Beispiel 3:

Eingabe: Wort = „abcbabcd“, k = 2
Ausgabe: 4
Erläuterung: Jede Sekunde entfernen wir die ersten beiden Zeichen des Wortes und fügen dieselben Zeichen am Ende des Wortes hinzu.
Nach 4 Sekunden entspricht das Wort „abcbabcd“ und kehrt in seinen Ausgangszustand zurück.
Es kann gezeigt werden, dass 4 Sekunden die Mindestzeit größer als Null sind, die erforderlich ist, damit das Wort in seinen ursprünglichen Zustand zurückkehrt.

Einschränkungen:

1 <= Wortlänge <= 50
1 <= k <= Wortlänge
Das Wort besteht nur aus englischen Kleinbuchstaben.


Sie erhalten ein 0-indiziertes Array nums, das aus positiven Ganzzahlen besteht.
Anfangs können Sie den Wert eines beliebigen Elements im Array um höchstens 1 erhöhen.
Danach müssen Sie ein oder mehrere Elemente aus dem endgültigen Array so auswählen, dass diese Elemente aufeinanderfolgend sind, wenn sie in zunehmender Reihenfolge sortiert werden. Beispielsweise sind die Elemente [3, 4, 5] aufeinanderfolgend, während [3, 4, 6] und [1, 1, 2, 3] nicht sind.
Geben Sie die maximale Anzahl von Elementen zurück, die Sie auswählen können.

Beispiel 1:

Eingabe: nums = [2,1,5,1,1]
Ausgabe: 3
Erläuterung: Wir können die Elemente an den Indizes 0 und 3 erhöhen. Das resultierende Array lautet nums = [3,1,5,2,1].
Wir wählen die Elemente [3,1,5,2,1] aus und sortieren sie, um [1,2,3] zu erhalten, die aufeinanderfolgend sind.
Es kann gezeigt werden, dass wir nicht mehr als 3 aufeinanderfolgende Elemente auswählen können.
Beispiel 2:

Eingabe: nums = [1,4,7,10]
Ausgabe: 1
Erläuterung: Die maximalen aufeinanderfolgenden Elemente, die wir auswählen können, ist 1.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums, das aus positiven ganzen Zahlen besteht.
Zunächst können Sie den Wert jedes Elements im Array um höchstens 1 erhöhen.
Danach müssen Sie ein oder mehrere Elemente aus dem endgültigen Array auswählen, sodass diese Elemente bei der Sortierung in aufsteigender Reihenfolge aufeinander folgen. Beispielsweise sind die Elemente [3, 4, 5] aufeinanderfolgend, während [3, 4, 6] und [1, 1, 2, 3] dies nicht sind.
Gibt die maximale Anzahl von Elementen zurück, die Sie auswählen können.

Beispiel 1:

Eingabe: nums = [2,1,5,1,1]
Ausgabe: 3
Erläuterung: Wir können die Elemente bei den Indizes 0 und 3 erhöhen. Das resultierende Array ist nums = [3,1,5,2,1].
Wir wählen die Elemente [3,1,5,2,1] aus und sortieren sie, um [1,2,3] zu erhalten, die aufeinanderfolgend sind.
Es kann gezeigt werden, dass wir nicht mehr als 3 aufeinanderfolgende Elemente auswählen können.
Beispiel 2:

Eingabe: nums = [1,4,7,10]
Ausgabe: 1
Erläuterung: Die maximale Anzahl aufeinanderfolgender Elemente, die wir auswählen können, ist 1.

Einschränkungen:

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


Sie erhalten ein Array positiver Ganzzahlen.
Sie müssen eine Teilmenge von Zahlen auswählen, die die folgende Bedingung erfüllt:

Sie können die ausgewählten Elemente in einem 0-indizierten Array so platzieren, dass es dem Muster folgt: [x, x^2, x^4, ..., x^k/2, x^k, x^k/2, ..., x^4, x^2, x] (Beachten Sie, dass k jede nicht negative Potenz von 2 sein kann). Beispielsweise folgen [2, 4, 16, 4, 2] und [3, 9, 3] dem Muster, während [2, 4, 8, 4, 2] dies nicht tut.

Gibt die maximale Anzahl von Elementen in einer Teilmenge zurück, die diese Bedingungen erfüllt.

Beispiel 1:

Eingabe: nums = [5,4,1,2,2]
Ausgabe: 3
Erläuterung: Wir können die Teilmenge {4,2,2} auswählen, die im Array als [2,4,2] platziert werden kann, was dem Muster 2^2 == 4 folgt. Daher lautet die Antwort 3.

Beispiel 2:

Eingabe: nums = [1,3,2,4]
Ausgabe: 1
Erläuterung: Wir können die Teilmenge {1} auswählen, die im Array als [1] platziert werden kann, was dem Muster folgt. Daher ist die Antwort 1. Beachten Sie, dass wir auch die Teilmengen {2}, {4} oder {3} hätten auswählen können. Möglicherweise gibt es mehrere Teilmengen, die dieselbe Antwort liefern.

Einschränkungen:

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


Sie erhalten eine Zeichenfolge s.
Erwägen Sie, die folgende Operation auszuführen, bis s leer wird:

Entfernen Sie für jedes Alphabetzeichen von „a“ bis „z“ das erste Vorkommen dieses Zeichens in s (falls vorhanden).

Nehmen wir zum Beispiel anfänglich s = „aabcbbca“. Wir führen folgende Operationen durch:

Entfernen Sie die unterstrichenen Zeichen s = „aabcbbca“. Die resultierende Zeichenfolge ist s = „abbca“.
Entfernen Sie die unterstrichenen Zeichen s = „abbca“. Die resultierende Zeichenfolge ist s = „ba“.
Entfernen Sie die unterstrichenen Zeichen s = „ba“. Die resultierende Zeichenfolge ist s = "".

Gibt den Wert der Zeichenfolge s direkt vor der Anwendung der letzten Operation zurück. Im obigen Beispiel lautet die Antwort „ba“.

Beispiel 1:

Eingabe: s = "aabcbbca"
Ausgabe: „ba“
Erläuterung: In der Erklärung erläutert.

Beispiel 2:

Eingabe: s = „abcd“
Ausgabe: „abcd“
Erläuterung: Wir führen die folgende Operation durch:
- Entfernen Sie die unterstrichenen Zeichen s = „abcd“. Die resultierende Zeichenfolge ist s = "".
Die Zeichenfolge direkt vor der letzten Operation ist „abcd“.

Einschränkungen:

1 <= s.length <= 5 * 10^5
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenkette s.
Erwägen Sie, den folgenden Vorgang auszuführen, bis s leer wird:

Entfernen Sie für jedes Buchstabenzeichen von 'a' bis 'z' das erste Vorkommen dieses Zeichens in s (falls vorhanden).

Lassen Sie zum Beispiel initial s = "aabcbbca" sein. Wir führen die folgenden Vorgänge durch:

Entfernen Sie die unterstrichenen Zeichen s = "aabcbbca". Die resultierende Zeichenfolge ist s = "abbca".
Entfernen Sie die unterstrichenen Zeichen s = "abbca". Die resultierende Zeichenfolge ist s = "ba".
Entfernen Sie die unterstrichenen Zeichen s = "ba". Die resultierende Zeichenfolge ist s = "".

Geben Sie den Wert der Zeichenfolge s direkt vor dem Anwenden des letzten Vorgangs zurück. Im obigen Beispiel lautet die Antwort "ba".

Beispiel 1:

Eingabe: s = "aabcbbca"
Ausgang: "ba"
Erklärung: Wird in der Erklärung erklärt.

Beispiel 2:

Eingang: s = "abcd"
Ausgang: "abcd"
Erklärung: Wir führen die folgende Operation durch:
- Entfernen Sie die unterstrichenen Zeichen s = "abcd". Die resultierende Zeichenfolge ist s = "".
Die Zeichenfolge kurz vor der letzten Operation lautet "abcd".

Zwänge:

1 <= s.length <= 5 * 10^5
s besteht nur aus englischen Kleinbuchstaben.


Sie erhalten ein 0-indiziertes String-Array mit Wörtern.
Definieren wir eine boolesche Funktion isPrefixAndSuffix, die zwei Zeichenfolgen akzeptiert, str1 und str2:

isPrefixAndSuffix(str1, str2) gibt true zurück, wenn str1 sowohl ein Präfix als auch ein Suffix von str2 ist, andernfalls false.

Beispielsweise ist isPrefixAndSuffix("aba", "ababa") wahr, weil "aba" ein Präfix von "ababa" und auch ein Suffix ist, isPrefixAndSuffix("abc", "abcd") ist jedoch falsch.
Gibt eine Ganzzahl zurück, die die Anzahl der Indexpaare (i, j) angibt, sodass i < j und isPrefixAndSuffix(words[i], Words[j]) wahr ist.

Beispiel 1:

Eingabe: Wörter = ["a", "aba", "ababa", "aa"]
Ausgabe: 4
Erläuterung: In diesem Beispiel sind die gezählten Indexpaare:
i = 0 und j = 1, weil isPrefixAndSuffix("a", "aba") wahr ist.
i = 0 und j = 2, weil isPrefixAndSuffix("a", "ababa") wahr ist.
i = 0 und j = 3, weil isPrefixAndSuffix("a", "aa") wahr ist.
i = 1 und j = 2, weil isPrefixAndSuffix("aba", "ababa") wahr ist.
Daher lautet die Antwort 4.
Beispiel 2:

Eingabe: Wörter = ["pa", "papa", "ma", "mama"]
Ausgabe: 2
Erläuterung: In diesem Beispiel sind die gezählten Indexpaare:
i = 0 und j = 1, weil isPrefixAndSuffix("pa", "papa") wahr ist.
i = 2 und j = 3, weil isPrefixAndSuffix("ma", "mama") wahr ist.
Daher lautet die Antwort 2.
Beispiel 3:

Eingabe: Wörter = ["abab", "ab"]
Ausgabe: 0
Erläuterung: In diesem Beispiel ist das einzige gültige Indexpaar i = 0 und j = 1 und isPrefixAndSuffix("abab", "ab") ist falsch.
Daher ist die Antwort 0.

Einschränkungen:

1 <= Wörter. Länge <= 50
1 <= Wörter[i].Länge <= 10
„words[i]“ besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine 0-indizierte Zeichenfolgen-Array-Wörter.
Definieren wir eine boolesche Funktion isPrefixAndSuffix, die zwei Zeichenfolgen, str1 und str2, akzeptiert:

isPrefixAndSuffix(str1, str2) gibt true zurück, wenn str1 sowohl ein Präfix als auch ein Suffix von str2 ist, andernfalls false.

Zum Beispiel ist isPrefixAndSuffix(„aba“, „ababa“) wahr, weil „aba“ ein Präfix von „ababa“ und auch ein Suffix ist, aber isPrefixAndSuffix(„abc“, „abcd“) ist falsch.
Gibt eine ganze Zahl zurück, die die Anzahl der Indexpaare (i, j) angibt, bei denen i < j ist und isPrefixAndSuffix(words[i], words[j]) wahr ist.

Beispiel 1:

Eingabe: words = ["a","aba","ababa","aa"]
Ausgang: 4
Erläuterung: In diesem Beispiel sind die gezählten Indexpaare:
i = 0 und j = 1, weil isPrefixAndSuffix(„a“, „aba“) wahr ist.
i = 0 und j = 2, weil isPrefixAndSuffix(„a“, „ababa“) wahr ist.
i = 0 und j = 3, weil isPrefixAndSuffix(„a“, „aa“) wahr ist.
i = 1 und j = 2, weil isPrefixAndSuffix(„aba“, „ababa“) wahr ist.
Daher lautet die Antwort 4.
Beispiel 2:

Eingabe: words = ["pa","papa","ma","mama"]
Ausgang: 2
Erläuterung: In diesem Beispiel sind die gezählten Indexpaare:
i = 0 und j = 1, weil isPrefixAndSuffix(„pa“, „papa“) wahr ist.
i = 2 und j = 3, weil isPrefixAndSuffix(„ma“, „mama“) wahr ist.
Daher lautet die Antwort 2.
Beispiel 3:

Eingabe: words = ["abab","ab"]
Ausgang: 0
Erläuterung: In diesem Beispiel ist das einzige gültige Indexpaar i = 0 und j = 1, und isPrefixAndSuffix(„abab“, „ab“) ist false.
Daher lautet die Antwort 0.

Zwänge:

1 <= words.length <= 50
1 <= words[i].length <= 10
words[i] besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein 0-indiziertes String-Array mit Wörtern.
Definieren wir eine boolesche Funktion isPrefixAndSuffix, die zwei Zeichenfolgen akzeptiert, str1 und str2:

isPrefixAndSuffix(str1, str2) gibt true zurück, wenn str1 sowohl ein Präfix als auch ein Suffix von str2 ist, andernfalls false.

Beispielsweise ist isPrefixAndSuffix("aba", "ababa") wahr, weil "aba" ein Präfix von "ababa" und auch ein Suffix ist, isPrefixAndSuffix("abc", "abcd") ist jedoch falsch.
Gibt eine Ganzzahl zurück, die die Anzahl der Indexpaare (i, j) angibt, sodass i < j und isPrefixAndSuffix(words[i], Words[j]) wahr ist.

Beispiel 1:

Eingabe: words = ["a", "aba", "ababa", "aa"]
Ausgabe: 4
Erläuterung: In diesem Beispiel sind die gezählten Indexpaare:
i = 0 und j = 1, weil isPrefixAndSuffix("a", "aba") wahr ist.
i = 0 und j = 2, weil isPrefixAndSuffix("a", "ababa") wahr ist.
i = 0 und j = 3, weil isPrefixAndSuffix("a", "aa") wahr ist.
i = 1 und j = 2, weil isPrefixAndSuffix("aba", "ababa") wahr ist.
Daher lautet die Antwort 4.
Beispiel 2:

Eingabe: words = ["pa", "papa", "ma", "mama"]
Ausgabe: 2
Erläuterung: In diesem Beispiel sind die gezählten Indexpaare:
i = 0 und j = 1, weil isPrefixAndSuffix("pa", "papa") wahr ist.
i = 2 und j = 3, weil isPrefixAndSuffix("ma", "mama") wahr ist.
Daher lautet die Antwort 2.
Beispiel 3:

Eingabe: words = ["abab", "ab"]
Ausgabe: 0
Erläuterung: In diesem Beispiel ist das einzige gültige Indexpaar i = 0 und j = 1 und isPrefixAndSuffix("abab", "ab") ist falsch.
Daher ist die Antwort 0.

Einschränkungen:

1 <= words. Länge <= 50
1 <= words[i].Länge <= 10
words[i] besteht nur aus englischen Kleinbuchstaben.


Eine Ameise steht an einer Grenze. Manchmal geht es nach links und manchmal nach rechts.
Sie erhalten ein Array mit ganzen Zahlen ungleich Null. Die Ameise beginnt, Zahlen vom ersten Element bis zum Ende zu lesen. Bei jedem Schritt bewegt es sich entsprechend dem Wert des aktuellen Elements:

Wenn nums[i] < 0 ist, bewegt es sich um -nums[i] Einheiten nach links.
Wenn nums[i] > 0, bewegt es sich um nums[i] Einheiten nach rechts.

Gibt an, wie oft die Ameise zur Grenze zurückkehrt.
Hinweise:

Auf beiden Seiten der Grenze gibt es einen unendlichen Raum.
Wir prüfen erst, ob sich die Ameise auf der Grenze befindet, nachdem sie |nums[i]| bewegt hat Einheiten. Mit anderen Worten: Wenn die Ameise während ihrer Bewegung die Grenze überschreitet, zählt sie nicht.

Beispiel 1:

Eingabe: nums = [2,3,-5]
Ausgabe: 1
Erklärung: Nach dem ersten Schritt befindet sich die Ameise 2 Schritte rechts von der Grenze.
Nach dem zweiten Schritt befindet sich die Ameise 5 Schritte rechts von der Grenze.
Nach dem dritten Schritt steht die Ameise an der Grenze.
Die Antwort ist also 1.

Beispiel 2:

Eingabe: nums = [3,2,-3,-4]
Ausgabe: 0
Erklärung: Nach dem ersten Schritt befindet sich die Ameise 3 Schritte rechts von der Grenze.
Nach dem zweiten Schritt befindet sich die Ameise 5 Schritte rechts von der Grenze.
Nach dem dritten Schritt befindet sich die Ameise 2 Schritte rechts von der Grenze.
Nach dem vierten Schritt befindet sich die Ameise 2 Schritte links von der Grenze.
Die Ameise kehrte nie zur Grenze zurück, daher ist die Antwort 0.

Einschränkungen:

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

Eine Ameise steht an einer Grenze. Manchmal geht es nach links und manchmal nach rechts.
Sie erhalten ein Array von Ganzzahlen ungleich Null. Die Ameise beginnt, Zahlen vom ersten Element bis zum Ende zu lesen. Bei jedem Schritt bewegt es sich entsprechend dem Wert des aktuellen Elements:

Wenn nums[i] < 0 ist, bewegt es sich um -nums[i] Einheiten nach links.
Wenn nums[i] > 0, bewegt es sich um nums[i] Einheiten nach rechts.

Gibt an, wie oft die Ameise zur Grenze zurückkehrt.
Hinweise:

Auf beiden Seiten der Grenze gibt es einen unendlichen Raum.
Wir prüfen erst, ob sich die Ameise auf der Grenze befindet, nachdem sie |nums[i]| bewegt hat Einheiten. Mit anderen Worten: Wenn die Ameise während ihrer Bewegung die Grenze überschreitet, zählt sie nicht.

Beispiel 1:

Eingabe: nums = [2,3,-5]
Ausgabe: 1
Erklärung: Nach dem ersten Schritt befindet sich die Ameise 2 Schritte rechts von der Grenze.
Nach dem zweiten Schritt befindet sich die Ameise 5 Schritte rechts von der Grenze.
Nach dem dritten Schritt steht die Ameise an der Grenze.
Die Antwort ist also 1.

Beispiel 2:

Eingabe: nums = [3,2,-3,-4]
Ausgabe: 0
Erklärung: Nach dem ersten Schritt befindet sich die Ameise 3 Schritte rechts von der Grenze.
Nach dem zweiten Schritt befindet sich die Ameise 5 Schritte rechts von der Grenze.
Nach dem dritten Schritt befindet sich die Ameise 2 Schritte rechts von der Grenze.
Nach dem vierten Schritt befindet sich die Ameise 2 Schritte links von der Grenze.
Die Ameise kehrte nie zur Grenze zurück, daher ist die Antwort 0.

Einschränkungen:

1 <= Anzahl.Länge <= 100
-10 <= nums[i] <= 10
nums[i] != 0

Eine Ameise steht an einer Grenze. Manchmal geht es nach links und manchmal nach rechts.
Sie erhalten ein Array mit ganzen Zahlen ungleich Null. Die Ameise beginnt, Zahlen vom ersten Element bis zum Ende zu lesen. Bei jedem Schritt bewegt es sich entsprechend dem Wert des aktuellen Elements:

Wenn nums[i] < 0 ist, bewegt es sich um -nums[i] Einheiten nach links.
Wenn nums[i] > 0, bewegt es sich um nums[i] Einheiten nach rechts.

Gibt an, wie oft die Ameise zur Grenze zurückkehrt.
Hinweise:

Auf beiden Seiten der Grenze gibt es einen unendlichen Raum.
Wir prüfen erst, ob sich die Ameise auf der Grenze befindet, nachdem sie |nums[i]| bewegt hat Einheiten. Mit anderen Worten: Wenn die Ameise während ihrer Bewegung die Grenze überschreitet, zählt sie nicht.

Beispiel 1:

Eingabe: nums = [2,3,-5]
Ausgabe: 1
Erklärung: Nach dem ersten Schritt befindet sich die Ameise 2 Schritte rechts von der Grenze.
Nach dem zweiten Schritt befindet sich die Ameise 5 Schritte rechts von der Grenze.
Nach dem dritten Schritt steht die Ameise an der Grenze.
Die Antwort ist also 1.

Beispiel 2:

Eingabe: nums = [3,2,-3,-4]
Ausgabe: 0
Erklärung: Nach dem ersten Schritt befindet sich die Ameise 3 Schritte rechts von der Grenze.
Nach dem zweiten Schritt befindet sich die Ameise 5 Schritte rechts von der Grenze.
Nach dem dritten Schritt befindet sich die Ameise 2 Schritte rechts von der Grenze.
Nach dem vierten Schritt befindet sich die Ameise 2 Schritte links von der Grenze.
Die Ameise kehrte nie zur Grenze zurück, daher ist die Antwort 0.

Einschränkungen:

1 <= Anzahl.Länge <= 100
-10 <= nums[i] <= 10
nums[i] != 0


Du hast einen 0-indizierten String s, der von einem Benutzer eingegeben wurde. Ein Wechsel einer Taste erfolgt, wenn eine andere Taste als die zuletzt verwendete genutzt wird. Zum Beispiel hat s = "ab" einen Wechsel der Taste, während s = "bBBb" keinen Tastwechsel hat.
Gib die Anzahl der Male zurück, bei denen der Benutzer die Taste wechseln musste.
Hinweis: Modifier wie Shift oder Caps Lock werden beim Wechseln der Taste nicht gezählt, das heißt, wenn ein Benutzer den Buchstaben 'a' und dann den Buchstaben 'A' eingibt, wird dies nicht als Wechsel der Taste gewertet.

Beispiel 1:

Input: s = "aAbBcC"
Output: 2
Erklärung:
Von s[0] = 'a' zu s[1] = 'A' gibt es keinen Wechsel der Taste, da Caps Lock oder Shift nicht gezählt werden.
Von s[1] = 'A' zu s[2] = 'b' gibt es einen Wechsel der Taste.
Von s[2] = 'b' zu s[3] = 'B' gibt es keinen Wechsel der Taste, da Caps Lock oder Shift nicht gezählt werden.
Von s[3] = 'B' zu s[4] = 'c' gibt es einen Wechsel der Taste.
Von s[4] = 'c' zu s[5] = 'C' gibt es keinen Wechsel der Taste, da Caps Lock oder Shift nicht gezählt werden.

Beispiel 2:

Input: s = "AaAaAaaA"
Output: 0
Erklärung: Es gibt keinen Wechsel der Taste, da nur die Buchstaben 'a' und 'A' gedrückt werden, was keinen Tastwechsel erfordert.

Constraints:

1 <= s.length <= 100
s besteht nur aus Groß- und Kleinbuchstaben des englischen Alphabets.

Sie erhalten eine 0-indizierte Zeichenfolge, die von einem Benutzer eingegeben wurde. Beim Ändern eines Schlüssels handelt es sich um die Verwendung eines anderen Schlüssels als des zuletzt verwendeten Schlüssels. Zum Beispiel hat s = „ab“ eine Schlüsseländerung, während s = „bBBb“ keine hat.
Gibt an, wie oft der Benutzer den Schlüssel ändern musste.
Hinweis: Modifikatoren wie Umschalttaste oder Feststelltaste werden bei der Änderung der Taste nicht berücksichtigt. Das heißt, wenn ein Benutzer den Buchstaben „a“ und dann den Buchstaben „A“ eingibt, wird dies nicht als Tastenänderung betrachtet.

Beispiel 1:

Eingabe: s = „aAbBcC“
Ausgabe: 2
Erläuterung:
Von s[0] = 'a' bis s[1] = 'A' gibt es keinen Tastenwechsel, da die Feststelltaste oder Umschalttaste nicht gezählt wird.
Von s[1] = 'A' zu s[2] = 'b' gibt es einen Schlüsselwechsel.
Von s[2] = 'b' bis s[3] = 'B' gibt es keinen Tastenwechsel, da die Feststelltaste oder Umschalttaste nicht gezählt wird.
Von s[3] = 'B' zu s[4] = 'c' gibt es einen Tastenwechsel.
Von s[4] = 'c' bis s[5] = 'C' gibt es keinen Tastenwechsel, da die Feststelltaste oder Umschalttaste nicht gezählt wird.

Beispiel 2:

Eingabe: s = „AaAaAaaA“
Ausgabe: 0
Erläuterung: Es gibt keinen Schlüsselwechsel, da nur die Buchstaben „a“ und „A“ gedrückt werden, was keinen Schlüsselwechsel erfordert.

Einschränkungen:

1 <= s.length <= 100
s besteht nur aus englischen Groß- und Kleinbuchstaben.

Sie erhalten eine 0-indizierte Zeichenfolge s, die von einem Benutzer eingegeben wurde. Das Ändern eines Schlüssels ist definiert als die Verwendung eines Schlüssels, der sich vom zuletzt verwendeten Schlüssel unterscheidet. Zum Beispiel hat s = "ab" eine Änderung eines Schlüssels, während s = "bBBb" keine hat.
Gibt an, wie oft der Benutzer den Schlüssel ändern musste.
Hinweis: Modifikatoren wie Umschalt oder Feststelltaste werden beim Ändern der Taste nicht gezählt, d. h., wenn ein Benutzer den Buchstaben "a" und dann den Buchstaben "a" eingibt, wird dies nicht als Änderung des Schlüssels gewertet.

Beispiel 1:

Eingang: s = "aAbBcC"
Ausgang: 2
Erklärung:
Von s[0] = 'a' bis s[1] = 'A' ändert sich die Taste nicht, da die Feststelltaste oder die Umschalttaste nicht gezählt werden.
Von s[1] = 'A' zu s[2] = 'b' gibt es einen Tastenwechsel.
Von s[2] = 'b' bis s[3] = 'B' ändert sich die Taste nicht, da die Feststelltaste oder die Umschalttaste nicht gezählt werden.
Von s[3] = 'B' zu s[4] = 'c' gibt es eine Tastenwechsel.
Von s[4] = 'c' bis s[5] = 'C' ändert sich die Taste nicht, da die Feststelltaste oder die Umschalttaste nicht gezählt werden.

Beispiel 2:

Eingabe: s = "AaAaAaaA"
Ausgang: 0
Erklärung: Es erfolgt kein Tastenwechsel, da nur die Buchstaben 'a' und 'A' gedrückt werden, was keinen Tastenwechsel erfordert.

Einschränkungen:

1 <= s.length <= 100
s besteht nur aus englischen Groß- und Kleinbuchstaben.