Sie erhalten ein Array nums und eine Ganzzahl k. Sie müssen ein Subarray von Zahlen finden, bei dem die absolute Differenz zwischen k und dem bitweisen ODER der Subarray-Elemente so klein wie möglich ist. Mit anderen Worten, wählen Sie ein Subarray nums[l..r] aus, so dass |k - (nums[l] OR nums[l + 1] ... OR nums[r])| ist minimal.
Gibt den minimal möglichen Wert der absoluten Differenz zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,4,5], k = 3
Ausgabe: 0
Erläuterung:
Das Subarray nums[0..1] hat den ODER-Wert 3, was die minimale absolute Differenz |3 - 3| ergibt = 0.

Beispiel 2:

Eingabe: nums = [1,3,1,3], k = 2
Ausgabe: 1
Erläuterung:
Das Subarray nums[1..1] hat den ODER-Wert 3, was die minimale absolute Differenz |3 - 2| ergibt = 1.

Beispiel 3:

Eingabe: nums = [1], k = 10
Ausgabe: 9
Erläuterung:
Es gibt ein einzelnes Subarray mit dem ODER-Wert 1, was die minimale absolute Differenz |10 - 1| ergibt = 9.

Einschränkungen:

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

Sie erhalten ein Array nums und eine Ganzzahl k. Sie müssen ein Subarray von Zahlen finden, bei dem die absolute Differenz zwischen k und dem bitweisen ODER der Subarray-Elemente so klein wie möglich ist. Mit anderen Worten, wählen Sie ein Subarray nums[l..r] aus, so dass |k - (nums[l] OR nums[l + 1] ... OR nums[r])| ist minimal.
Gibt den minimal möglichen Wert der absoluten Differenz zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: Zahlen = [1,2,4,5], k = 3
Ausgabe: 0
Erläuterung:
Das Subarray nums[0..1] hat den ODER-Wert 3, was die minimale absolute Differenz |3 - 3| ergibt = 0.

Beispiel 2:

Eingabe: nums = [1,3,1,3], k = 2
Ausgabe: 1
Erläuterung:
Das Subarray nums[1..1] hat den ODER-Wert 3, was die minimale absolute Differenz |3 - 2| ergibt = 1.

Beispiel 3:

Eingabe: Zahlen = [1], k = 10
Ausgabe: 9
Erläuterung:
Es gibt ein einzelnes Subarray mit dem ODER-Wert 1, was die minimale absolute Differenz |10 - 1| ergibt = 9.

Einschränkungen:

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


Gegeben sind zwei positive ganze Zahlen n und k. Es gibt n Kinder, die von 0 bis n - 1 nummeriert sind und in einer Schlange von links nach rechts stehen.
Zu Beginn hält Kind 0 einen Ball in der Hand, und die Richtung, in der der Ball weitergegeben wird, ist nach rechts. Nach jeder Sekunde gibt das Kind, das den Ball hält, ihn an das Kind neben ihm weiter. Sobald der Ball eines der beiden Enden der Reihe erreicht, d. h. Kind 0 oder Kind n - 1, wird die Weitergaberichtung umgedreht.
Geben Sie die Nummer des Kindes zurück, das den Ball nach k Sekunden erhalten hat.

Beispiel 1:

Eingabe: n = 3, k = 5
Ausgabe: 1
Erläuterung:

Verstrichene Zeit
Kinder

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Beispiel 2:

Eingabe: n = 5, k = 6
Ausgabe: 2
Erläuterung:

Verstrichene Zeit
Kinder

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Beispiel 3:

Eingabe: n = 4, k = 2
Ausgabe: 2
Erläuterung:

Verstrichene Zeit
Kinder

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Beschränkungen:

2 <= n <= 50
1 <= k <= 50

Sie erhalten zwei positive ganze Zahlen n und k. Es gibt n Kinder mit den Nummern 0 bis n-1, die in der Reihenfolge von links nach rechts in einer Schlange stehen.
Zunächst hält Kind 0 einen Ball und die Passrichtung des Balls ist in die richtige Richtung. Nach jeder Sekunde gibt das Kind, das den Ball hält, ihn an das Kind neben ihm weiter. Sobald der Ball eines der Enden der Linie erreicht, d. h. Kind 0 oder Kind n - 1, wird die Passrichtung umgekehrt.
Geben Sie die Nummer des Kindes zurück, das nach k Sekunden den Ball erhält.

Beispiel 1:

Eingabe: n = 3, k = 5
Ausgabe: 1
Erläuterung:

Zeit verstrichen
Kinder

0
[0, 1, 2]

1
[0, 1, 2]

2
[0, 1, 2]

3
[0, 1, 2]

4
[0, 1, 2]

5
[0, 1, 2]

Beispiel 2:

Eingabe: n = 5, k = 6
Ausgabe: 2
Erläuterung:

Zeit verstrichen
Kinder

0
[0, 1, 2, 3, 4]

1
[0, 1, 2, 3, 4]

2
[0, 1, 2, 3, 4]

3
[0, 1, 2, 3, 4]

4
[0, 1, 2, 3, 4]

5
[0, 1, 2, 3, 4]

6
[0, 1, 2, 3, 4]

Beispiel 3:

Eingabe: n = 4, k = 2
Ausgabe: 2
Erläuterung:

Zeit verstrichen
Kinder

0
[0, 1, 2, 3]

1
[0, 1, 2, 3]

2
[0, 1, 2, 3]

Einschränkungen:

2 <= n <= 50
1 <= k <= 50


Ihnen werden zwei ganze Zahlen n und k gegeben.
Sie beginnen mit einem Array a aus n ganzen Zahlen, wobei a[i] = 1 für alle 0 <= i <= n - 1 ist. Nach jeder Sekunde aktualisieren Sie gleichzeitig jedes Element, so dass es die Summe aller vorangehenden Elemente plus das Element selbst ist. Zum Beispiel bleibt nach einer Sekunde a[0] gleich, a[1] wird zu a[0] + a[1], a[2] wird zu a[0] + a[1] + a[2] usw.
Geben Sie den Wert von a[n - 1] nach k Sekunden zurück.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: n = 4, k = 5
Ausgabe: 56
Erläuterung:

Zweite
Zustand nach

0
[1,1,1,1]

1
[1,2,3,4]

2
[1,3,6,10]

3
[1,4,10,20]

4
[1,5,15,35]

5
[1,6,21,56]

Beispiel 2:

Eingabe: n = 5, k = 3
Ausgabe: 35
Erläuterung:

Zweite
Zustand nach

0
[1,1,1,1,1]

1
[1,2,3,4,5]

2
[1,3,6,10,15]

3
[1,4,10,20,35]

Beschränkungen:

1 <= n, k <= 1000

Sie erhalten zwei ganze Zahlen n und k.
Zunächst beginnen Sie mit einem Array a aus n ganzen Zahlen, wobei a[i] = 1 für alle 0 <= i <= n - 1. Nach jeder Sekunde aktualisieren Sie jedes Element gleichzeitig so, dass es die Summe aller seiner vorhergehenden Elemente plus ist Element selbst. Nach einer Sekunde bleibt beispielsweise a[0] gleich, a[1] wird zu a[0] + a[1], a[2] wird zu a[0] + a[1] + a[2], und so weiter.
Gibt den Wert von a[n - 1] nach k Sekunden zurück.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: n = 4, k = 5
Ausgabe: 56
Erläuterung:

Zweite
Zustand danach

0
[1,1,1,1]

1
[1,2,3,4]

2
[1,3,6,10]

3
[1,4,10,20]

4
[1,5,15,35]

5
[1,6,21,56]

Beispiel 2:

Eingabe: n = 5, k = 3
Ausgabe: 35
Erläuterung:

Zweite
Zustand danach

0
[1,1,1,1,1]

1
[1,2,3,4,5]

2
[1,3,6,10,15]

3
[1,4,10,20,35]

Einschränkungen:

1 <= n, k <= 1000


Sie erhalten ein ganzzahliges Array „rewardValues“ der Länge n, das die Werte der Belohnungen darstellt.

Anfangs ist Ihre Gesamtbelohnung x 0 und alle Indizes sind unmarkiert. Sie dürfen die folgende Operation beliebig oft durchführen:

Wählen Sie einen unmarkierten Index i aus dem Bereich [0, n - 1].

Wenn „rewardValues[i]“ größer als Ihre aktuelle Gesamtbelohnung x ist, addieren Sie „rewardValues[i]“ zu x (d. h. x = x + „rewardValues[i]“) und markieren Sie den Index i.

Geben Sie eine Ganzzahl zurück, die die maximale Gesamtbelohnung angibt, die Sie durch optimale Durchführung der Operationen erhalten können.

Beispiel 1:

Eingabe: rewardValues = [1,1,3,3]
Ausgabe: 4
Erklärung:
Während der Operationen können wir die Indizes 0 und 2 der Reihe nach markieren, und die Gesamtbelohnung beträgt 4, was das Maximum ist.

Beispiel 2:

Eingabe: rewardValues = [1,6,4,3,2]
Ausgabe: 11
Erklärung:
Markieren Sie die Indizes 0, 2 und 1 der Reihe nach. Die Gesamtbelohnung beträgt dann 11, was das Maximum ist.

Einschränkungen:

1 <= rewardValues.length <= 2000
1 <= rewardValues[i] <= 2000

Sie erhalten ein ganzzahliges Array „rewardValues“ der Länge n, das die Werte der Belohnungen darstellt.
Zu Beginn beträgt Ihre Gesamtbelohnung x 0 und alle Indizes sind nicht markiert. Sie dürfen den folgenden Vorgang beliebig oft ausführen:

Wählen Sie einen unmarkierten Index i aus dem Bereich [0, n - 1].
Wenn Belohnungswerte[i] größer als Ihre aktuelle Gesamtbelohnung x ist, dann addieren Sie Belohnungswerte[i] zu x (d. h. x = x + Belohnungswerte[i]) und markieren Sie den Index i.

Geben Sie eine Ganzzahl zurück, die die maximale Gesamtbelohnung angibt, die Sie durch optimale Ausführung der Vorgänge erhalten können.

Beispiel 1:

Eingabe: Belohnungswerte = [1,1,3,3]
Ausgabe: 4
Erläuterung:
Während der Operationen können wir die Indizes 0 und 2 der Reihe nach markieren, und die Gesamtbelohnung beträgt 4, was das Maximum darstellt.

Beispiel 2:

Eingabe: Belohnungswerte = [1,6,4,3,2]
Ausgabe: 11
Erläuterung:
Markieren Sie die Indizes 0, 2 und 1 der Reihe nach. Die Gesamtbelohnung beträgt dann 11, was dem Maximum entspricht.

Einschränkungen:

1 <= rewardValues.length <= 2000
1 <= rewardValues[i] <= 2000

Sie erhalten ein ganzzahliges Array rewardValues der Länge n, das die Werte der Belohnungen darstellt.
Zu Beginn ist Ihre Gesamtprämie x 0, und alle Indizes sind nicht markiert. Sie können den folgenden Vorgang beliebig oft ausführen:

Wählen Sie einen unmarkierten Index i aus dem Bereich [0, n - 1].
Wenn rewardValues[i] größer ist als Ihre aktuelle Gesamtprämie x, addieren Sie rewardValues[i] zu x (d. h. x = x + rewardValues[i]) und markieren Sie den Index i.

Geben Sie eine ganze Zahl zurück, die die maximale Gesamtbelohnung angibt, die Sie durch optimales Ausführen der Operationen erhalten können.

Beispiel 1:

Eingabe: rewardValues = [1,1,3,3]
Ausgang: 4
Erklärung:
Während der Operationen können wir wählen, die Indizes 0 und 2 der Reihe nach zu markieren, und die Gesamtbelohnung beträgt 4, was das Maximum ist.

Beispiel 2:

Eingabe: rewardValues = [1,6,4,3,2]
Ausgang: 11
Erklärung:
Markieren Sie die Indizes 0, 2 und 1 der Reihe nach. Die Gesamtbelohnung beträgt dann 11, was das Maximum ist.

Zwänge:

1 <= rewardValues.length <= 2000
1 <= rewardValues[i] <= 2000


Geben Sie bei einem ganzzahligen Array „hours“, das Zeiten in Stunden darstellt, eine Ganzzahl zurück, die die Anzahl der Paare i, j angibt, wobei i < j und hours[i] + hours[j] einen vollständigen Tag bilden.
Ein vollständiger Tag ist definiert als eine Zeitdauer, die ein genaues Vielfaches von 24 Stunden ist.
Beispiel: 1 Tag hat 24 Stunden, 2 Tage 48 Stunden, 3 Tage 72 Stunden und so weiter.

Beispiel 1:

Eingabe: hours = [12,12,30,24,24]
Ausgabe: 2
Erklärung:
Die Indexpaare, die einen vollständigen Tag bilden, sind (0, 1) und (3, 4).

Beispiel 2:

Eingabe: hours = [72,48,24,3]
Ausgabe: 3
Erklärung:
Die Indexpaare, die einen vollständigen Tag bilden, sind (0, 1), (0, 2) und (1, 2).

Einschränkungen:

1 <= hours.length <= 100
1 <= hours[i] <= 10^9

Geben Sie bei einem gegebenen ganzzahligen Array „Stunden“, das Zeiten in Stunden darstellt, eine Ganzzahl zurück, die die Anzahl der Paare i, j angibt, wobei i < j und Stunden[i] + Stunden[j] einen vollständigen Tag bilden.
Ein vollständiger Tag ist definiert als eine Zeitdauer, die ein genaues Vielfaches von 24 Stunden ist.
Beispielsweise entspricht 1 Tag 24 Stunden, 2 Tage 48 Stunden, 3 Tage 72 Stunden und so weiter.

Beispiel 1:

Eingabe: Stunden = [12,12,30,24,24]
Ausgabe: 2
Erläuterung:
Die Indexpaare, die einen vollständigen Tag bilden, sind (0, 1) und (3, 4).

Beispiel 2:

Eingabe: Stunden = [72,48,24,3]
Ausgabe: 3
Erläuterung:
Die Indexpaare, die einen vollständigen Tag bilden, sind (0, 1), (0, 2) und (1, 2).

Einschränkungen:

1 <= Stunden.Länge <= 100
1 <= Stunden[i] <= 10^9


Ein Magier hat verschiedene Zaubersprüche.
Du erhältst eine Kraft-Array, bei der jedes Element den Schaden eines Zaubers darstellt. Mehrere Zauber können den gleichen Schadenswert haben.
Es ist eine bekannte Tatsache, dass, wenn ein Magier sich entscheidet, einen Zauber mit einem Schaden von Kraft[i] zu wirken, er keinen Zauber mit einem Schaden von Kraft[i] - 2, Kraft[i] - 1, Kraft[i] + 1 oder Kraft[i] + 2 wirken kann.
Jeder Zauber kann nur einmal gewirkt werden.
Gibt den maximal möglichen Gesamtschaden zurück, den ein Magier wirken kann.

Beispiel 1:

Eingang: power = [1,1,3,4]
Ausgang: 6
Erklärung:
Der maximal mögliche Schaden von 6 wird durch das Wirken der Zauber 0, 1, 3 mit dem Schaden 1, 1, 4 erzeugt.

Beispiel 2:

Eingang: power = [7,1,6,6]
Ausgang: 13
Erklärung:
Der maximal mögliche Schaden von 13 wird durch das Wirken der Zauber 1, 2, 3 mit dem Schaden 1, 6, 6 erzeugt.

Einschränkungen:

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

Ein Zauberer verfügt über verschiedene Zaubersprüche.
ie erhalten ein Kraft-Array, bei der jedes Element den Schaden eines Zaubers darstellt. Mehrere Zauber können den gleichen Schadenswert haben.
Es ist bekannt, dass ein Magier, wenn er beschließt, einen Zauber mit einem Kraft[i] zu wirken, keinen Zauberspruch mit einem Kraft[i] - 2, Kraft[i] - 1, Kraft[i] + 1 oder Kraft[i] + 2 wirken kann.
Jeder Zauber kann nur einmal gewirkt werden.
Erstatte den maximal möglichen Gesamtschaden, den ein Magier wirken kann.

Beispiel 1:

Eingabe: power = [1,1,3,4]
Ausgabe: 6
Erläuterung:
Der maximal mögliche Schaden von 6 wird durch das Wirken der Zauber 0, 1, 3 mit Schaden 1, 1, 4 erzeugt.

Beispiel 2:

Eingabe: power = [7,1,6,6]
Ausgabe: 13
Erläuterung:
Der maximal mögliche Schaden von 13 wird durch das Wirken der Zauber 1, 2, 3 mit Schaden 1, 6, 6 erzeugt.

Einschränkungen:

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

Ein Zauberer verfügt über verschiedene Zaubersprüche.
Sie erhalten ein Array namens Kraft, bei der jedes Element den Schaden eines Zaubers darstellt. Mehrere Zauber können den gleichen Schadenswert haben.
Es ist bekannt, dass ein Magier, wenn er beschließt, einen Zauber mit einem Kraftschaden[i] zu wirken, keinen Zauberspruch mit einem Kraftschaden[i] - 2, Kraft[i] - 1, Kraft[i] - 2, Kraft[i] - 1, Kraft[i] + 1 oder Kraft[i] + 2 wirken kann.
Jeder Zauber kann nur einmal gewirkt werden.
Geben Sie den maximal möglichen Gesamtschaden zurück, den ein Magier wirken kann.

Beispiel 1:

Eingabe: Kraft = [1,1,3,4]
Ausgabe: 6
Erläuterung:
Der maximal mögliche Schaden von 6 wird durch das Wirken der Zauber 0, 1, 3 mit Schaden 1, 1, 4 erzeugt.

Beispiel 2:

Eingabe: Kraft = [7,1,6,6]
Ausgabe: 13
Erläuterung:
Der maximal mögliche Schaden von 13 wird durch das Wirken der Zauber 1, 2, 3 mit Schaden 1, 6, 6 erzeugt.

Einschränkungen:

1 <= Kraft.Länge <= 10^5
1 <= Kraft[i] <= 10^9


Ein Peak in einem Array arr ist ein Element, das größer ist als sein vorheriges und nächstes Element in arr.
Sie erhalten ein Integer-Array „Nums“ und ein 2D-Integer-Array für Abfragen.
Sie müssen zwei Arten von Abfragen verarbeiten:

query[i] = [1, l_i, r_i], bestimmt die Anzahl der Peak-Elemente im Subarray nums[l_i..r_i].
query[i] = [2, index_i, val_i], ändern Sie nums[index_i] in val_i.

Gibt eine Array-Antwort zurück, die die Ergebnisse der Abfragen des ersten Typs in der Reihenfolge enthält.
Hinweise:

Das erste und das letzte Element eines Arrays oder Subarrays dürfen kein Peak sein.

Beispiel 1:

Eingabe: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Ausgabe: [0]
Erläuterung:
Erste Abfrage: Wir ändern nums[3] in 4 und nums wird zu [3,1,4,4,5].
Zweite Abfrage: Die Anzahl der Peaks in [3,1,4,4,5] ist 0.

Beispiel 2:

Eingabe: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Ausgabe: [0,1]
Erläuterung:
Erste Abfrage: nums[2] sollte 4 werden, ist aber bereits auf 4 gesetzt.
Zweite Abfrage: Die Anzahl der Peaks in [4,1,4] ist 0.
Dritte Abfrage: Die zweite 4 ist ein Peak in [4,1,4,2,1].

Einschränkungen:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 or queries[i][0] == 2
Für alles was ich sage:

queries[i][0] == 1: 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

Ein Höhepunkt in einem Array -ARR ist ein Element, das größer ist als sein vorheriges und nächstes Element in arr.
Sie erhalten eine Integer -Array -NUMS und ein 2D -Integer -Array -Abfragen.
Sie müssen Abfragen von zwei Typen bearbeiten:

queries[i] = [1, l_i, r_i], bestimmen Sie die Anzahl der Peakelemente in den SubaRray -nums [l_i..r_i].
queries[i] = [2, index_i, val_i], ändern Sie nums [index_i] in val_i.

Geben Sie eine Array -Antwort zurück, die die Ergebnisse der Abfragen des ersten Typs in der Reihenfolge enthält.
Anmerkungen:

Das erste und das letzte Element eines Arrays oder einer Subtarray kann kein Höhepunkt sein.

Beispiel 1:

Eingabe: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Ausgabe: [0]
Erläuterung:
Erste Abfrage: Wir wechseln die nums [3] auf 4 und die nums wird [3,1,4,4,5].
Zweite Abfrage: Die Anzahl der Peaks in der [3,1,4,4,5] beträgt 0.

Beispiel 2:

Eingabe: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Ausgabe: [0,1]
Erläuterung:
Erste Abfrage: nums [2] sollte 4 werden, ist jedoch bereits auf 4 gesetzt.
Zweite Abfrage: Die Anzahl der Peaks in der [4,1,4] beträgt 0.
Dritte Abfrage: Die zweite 4 ist ein Höhepunkt in der [4,1,4,2,1].

Einschränkungen:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 or queries[i][0] == 2
Für alles ich das:

queries[i][0] == 1: 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

Ein Peak in einem Array arr ist ein Element, das größer ist als sein vorheriges und nächstes Element in arr.
Sie erhalten ein Integer-Array „Nums“ und ein 2D-Integer-Array für Abfragen.
Sie müssen zwei Arten von Abfragen verarbeiten:

query[i] = [1, l_i, r_i], bestimmt die Anzahl der Peak-Elemente im Subarray nums[l_i..r_i].
query[i] = [2, index_i, val_i], ändern Sie nums[index_i] in val_i.

Gibt eine Array-Antwort zurück, die die Ergebnisse der Abfragen des ersten Typs in der Reihenfolge enthält.
Hinweise:

Das erste und das letzte Element eines Arrays oder Subarrays dürfen kein Peak sein.

Beispiel 1:

Eingabe: Zahlen = [3,1,4,2,5], Abfragen = [[2,3,4],[1,0,4]]
Ausgabe: [0]
Erläuterung:
Erste Abfrage: Wir ändern nums[3] in 4 und nums wird zu [3,1,4,4,5].
Zweite Abfrage: Die Anzahl der Peaks in [3,1,4,4,5] ist 0.

Beispiel 2:

Eingabe: Zahlen = [4,1,4,2,1,5], Abfragen = [[2,2,4],[1,0,2],[1,0,4]]
Ausgabe: [0,1]
Erläuterung:
Erste Abfrage: nums[2] sollte 4 werden, ist aber bereits auf 4 gesetzt.
Zweite Abfrage: Die Anzahl der Peaks in [4,1,4] ist 0.
Dritte Abfrage: Die zweite 4 ist ein Peak in [4,1,4,2,1].

Einschränkungen:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= query.length <= 10^5
query[i][0] == 1 oder query[i][0] == 2
Für alles was ich sage:

Abfragen[i][0] == 1: 0 <= Abfragen[i][1] <= Abfragen[i][2] <= nums.length - 1
Abfragen[i][0] == 2: 0 <= Abfragen[i][1] <= nums.length - 1, 1 <= Abfragen[i][2] <= 10^5


Sie haben ein Array von Gleitkommazahlen-Durchschnittswerten, das zunächst leer ist. Sie erhalten ein Array mit n ganzen Zahlen, wobei n gerade ist.
Den folgenden Vorgang wiederholen Sie n/2 Mal:

Entfernen Sie das kleinste Element, minElement, und das größte Element, maxElement, aus Nums.
Addiere (minElement + maxElement) / 2 zu den Durchschnittswerten.

Gibt das minimale Element in Durchschnittswerten zurück.

Beispiel 1:

Eingabe: nums = [7,8,3,4,15,13,4,1]
Ausgabe: 5,5
Erläuterung:

Schritt
Zahlen
Durchschnittswerte

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5,5]

Das kleinste Durchschnittselement, 5,5, wird zurückgegeben.
Beispiel 2:

Eingabe: nums = [1,9,8,3,10,5]
Ausgabe: 5,5
Erläuterung:

Schritt
Zahlen
Durchschnittswerte

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Beispiel 3:

Eingabe: nums = [1,2,3,7,8,9]
Ausgabe: 5.0
Erläuterung:

Schritt
Zahlen
Durchschnittswerte

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5,5]

3
[]
[5,5,5]

Einschränkungen:

2 <= n == nums.length <= 50
n ist gerade.
1 <= nums[i] <= 50

Sie haben ein Array von Gleitkommazahlen-Durchschnittswerten, das zunächst leer ist. Sie erhalten ein Array mit n ganzen Zahlen, wobei n gerade ist.
Den folgenden Vorgang wiederholen Sie n/2 Mal:

Entfernen Sie das kleinste Element, minElement, und das größte Element, maxElement, aus Nums.
Addiere (minElement + maxElement) / 2 zu den Durchschnittswerten.

Gibt das minimale Element in Durchschnittswerten zurück.

Beispiel 1:

Eingabe: nums = [7,8,3,4,15,13,4,1]
Ausgabe: 5,5
Erläuterung:

Schritt
Zahlen
Durchschnittswerte

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5,5]

Das kleinste Durchschnittselement, 5,5, wird zurückgegeben.
Beispiel 2:

Eingabe: nums = [1,9,8,3,10,5]
Ausgabe: 5,5
Erläuterung:

Schritt
Zahlen
Durchschnittswerte

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

Beispiel 3:

Eingabe: nums = [1,2,3,7,8,9]
Ausgabe: 5,0
Erläuterung:

Schritt
Zahlen
Durchschnittswerte

0
[1,2,3,7,8,9]
[]

1
[2,3,7,8]
[5]

2
[3,7]
[5,5]

3
[]
[5,5,5]

Einschränkungen:

2 <= n == nums.length <= 50
n ist gerade.
1 <= nums[i] <= 50


Sie erhalten ein 2D-Binärarray-grid. Suchen Sie ein Rechteck mit horizontalen und vertikalen Seiten und der kleinsten Fläche, sodass alle Einsen im Raster innerhalb dieses Rechtecks liegen.
Gibt die kleinstmögliche Fläche des Rechtecks zurück.

Beispiel 1:

Eingabe: grid = [[0,1,0],[1,0,1]]
Ausgabe: 6
Erläuterung:

Das kleinste Rechteck hat eine Höhe von 2 und eine Breite von 3, also eine Fläche von 2 * 3 = 6.

Beispiel 2:

Eingabe: grid = [[1,0],[0,0]]
Ausgabe: 1
Erläuterung:

Das kleinste Rechteck hat sowohl Höhe als auch Breite 1, daher beträgt seine Fläche 1 * 1 = 1.

Einschränkungen:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] ist entweder 0 oder 1.
Die Eingabe wird so generiert, dass mindestens eine 1 im grid vorhanden ist.

Sie erhalten ein 2D-Binärarray-Gitter. Suchen Sie ein Rechteck mit horizontalen und vertikalen Seiten und der kleinsten Fläche, sodass alle Einsen im Raster innerhalb dieses Rechtecks liegen.
Gibt die kleinstmögliche Fläche des Rechtecks zurück.

Beispiel 1:

Eingabe: Gitter = [[0,1,0],[1,0,1]]
Ausgabe: 6
Erläuterung:

Das kleinste Rechteck hat eine Höhe von 2 und eine Breite von 3, also eine Fläche von 2 * 3 = 6.

Beispiel 2:

Eingabe: Gitter = [[1,0],[0,0]]
Ausgabe: 1
Erläuterung:

Das kleinste Rechteck hat sowohl Höhe als auch Breite 1, daher beträgt seine Fläche 1 * 1 = 1.

Einschränkungen:

1 <= Gitterlänge, Gitter[i].Länge <= 1000
Grid[i][j] ist entweder 0 oder 1.
Die Eingabe wird so generiert, dass im Raster mindestens eine 1 vorhanden ist.

Sie erhalten ein 2D-Binärarray-Gitter. Suchen Sie ein Rechteck mit horizontalen und vertikalen Seiten und der kleinsten Fläche, sodass alle Einsen im Raster innerhalb dieses Rechtecks liegen.
Gibt die kleinstmögliche Fläche des Rechtecks zurück.

Beispiel 1:

Eingabe: Gitter = [[0,1,0],[1,0,1]]
Ausgabe: 6
Erläuterung:

Das kleinste Rechteck hat eine Höhe von 2 und eine Breite von 3, also eine Fläche von 2 * 3 = 6.

Beispiel 2:

Eingabe: Gitter = [[1,0],[0,0]]
Ausgabe: 1
Erläuterung:

Das kleinste Rechteck hat sowohl Höhe als auch Breite 1, daher beträgt seine Fläche 1 * 1 = 1.

Einschränkungen:

1 <= Gitterlänge, Gitter[i].Länge <= 1000
Grid[i][j] ist entweder 0 oder 1.
Die Eingabe wird so generiert, dass mindestens eine 1 im Raster vorhanden ist.


Sie erhalten ein ganzzahliges Array nums mit der Länge n.
Die Kosten eines Subarrays nums[l..r], wobei 0 <= l <= r < n ist, sind definiert als:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Ihre Aufgabe besteht darin, nums so in Subarrays aufzuteilen, dass die Gesamtkosten der Subarrays maximiert werden und sichergestellt wird, dass jedes Element zu genau einem Subarray gehört.
Wenn nums formal in k Subarrays aufgeteilt wird, wobei k > 1 ist, bei den Indizes i_1, i_2, ..., i_k − 1, wobei 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, dann Die Gesamtkosten betragen:
Kosten(0, i_1) + Kosten(i_1 + 1, i_2) + ... + Kosten(i_k − 1 + 1, n − 1)
Gibt eine Ganzzahl zurück, die die maximalen Gesamtkosten der Unterarrays nach optimaler Aufteilung des Arrays angibt.
Hinweis: Wenn nums nicht in Unterarrays aufgeteilt ist, d. h. k = 1, betragen die Gesamtkosten einfach cost(0, n – 1).

Beispiel 1:

Eingabe: nums = [1,-2,3,4]
Ausgabe: 10
Erläuterung:
Eine Möglichkeit, die Gesamtkosten zu maximieren, besteht darin, [1, -2, 3, 4] in die Unterarrays [1, -2, 3] und [4] aufzuteilen. Die Gesamtkosten betragen (1 + 2 + 3) + 4 = 10.

Beispiel 2:

Eingabe: nums = [1,-1,1,-1]
Ausgabe: 4
Erläuterung:
Eine Möglichkeit, die Gesamtkosten zu maximieren, besteht darin, [1, -1, 1, -1] in die Unterarrays [1, -1] und [1, -1] aufzuteilen. Die Gesamtkosten betragen (1 + 1) + (1 + 1) = 4.

Beispiel 3:

Eingabe: nums = [0]
Ausgabe: 0
Erläuterung:
Wir können das Array nicht weiter aufteilen, daher ist die Antwort 0.

Beispiel 4:

Eingabe: nums = [1,-1]
Ausgabe: 2
Erläuterung:
Bei Auswahl des gesamten Arrays ergeben sich Gesamtkosten von 1 + 1 = 2, was dem Maximum entspricht.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums mit der Länge n.
Die Kosten für ein Subarray nums[l.. r], wobei 0 <= l <= r < n, definiert ist als:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Ihre Aufgabe besteht darin, nums in Subarrays aufzuteilen, so dass die Gesamtkosten der Subarrays maximiert werden, wobei sichergestellt wird, dass jedes Element zu genau einem Subarray gehört.
Wenn nums formal in k Subarrays aufgeteilt wird, wobei k > 1, bei den Indizes i_1, i_2, ..., i_k − 1, wobei 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1 ist, dann betragen die Gesamtkosten:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
Gibt eine Ganzzahl zurück, die die maximalen Gesamtkosten der Subarrays angibt, nachdem das Array optimal aufgeteilt wurde.
Hinweis: Wenn nums nicht in Subarrays aufgeteilt wird, d.h. k = 1, sind die Gesamtkosten einfach cost(0, n - 1).

Beispiel 1:

Eingabe: nums = [1,-2,3,4]
Ausgang: 10
Erklärung:
Eine Möglichkeit, die Gesamtkosten zu maximieren, besteht darin, [1, -2, 3, 4] in die Subarrays [1, -2, 3] und [4] aufzuteilen. Die Gesamtkosten betragen (1 + 2 + 3) + 4 = 10.

Beispiel 2:

Eingabe: nums = [1,-1,1,-1]
Ausgang: 4
Erklärung:
Eine Möglichkeit, die Gesamtkosten zu maximieren, besteht darin, [1, -1, 1, -1] in die Subarrays [1, -1] und [1, -1] aufzuteilen. Die Gesamtkosten betragen (1 + 1) + (1 + 1) = 4.

Beispiel 3:

Eingabe: nums = [0]
Ausgang: 0
Erklärung:
Wir können das Array nicht weiter aufteilen, daher lautet die Antwort 0.

Beispiel 4:

Eingabe: Anzahl = [1,-1]
Ausgang: 2
Erklärung:
Die Auswahl des gesamten Arrays ergibt Gesamtkosten von 1 + 1 = 2, was das Maximum ist.

Zwänge:

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

Sie erhalten ein ganzzahliges Array nums mit der Länge n.
Die Kosten eines Subarrays nums[l..r], wobei 0 <= l <= r < n ist, sind definiert als:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
Ihre Aufgabe besteht darin, Zahlen so in Subarrays aufzuteilen, dass die Gesamtkosten der Subarrays maximiert werden und sichergestellt wird, dass jedes Element zu genau einem Subarray gehört.
Wenn nums formal in k Subarrays aufgeteilt wird, wobei k > 1 ist, bei den Indizes i_1, i_2, ..., i_k − 1, wobei 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1, dann Die Gesamtkosten betragen:
Kosten(0, i_1) + Kosten(i_1 + 1, i_2) + ... + Kosten(i_k − 1 + 1, n − 1)
Gibt eine Ganzzahl zurück, die die maximalen Gesamtkosten der Unterarrays nach optimaler Aufteilung des Arrays angibt.
Hinweis: Wenn nums nicht in Unterarrays aufgeteilt ist, d. h. k = 1, betragen die Gesamtkosten einfach cost(0, n - 1).

Beispiel 1:

Eingabe: nums = [1,-2,3,4]
Ausgabe: 10
Erläuterung:
Eine Möglichkeit, die Gesamtkosten zu maximieren, besteht darin, [1, -2, 3, 4] in die Unterarrays [1, -2, 3] und [4] aufzuteilen. Die Gesamtkosten betragen (1 + 2 + 3) + 4 = 10.

Beispiel 2:

Eingabe: nums = [1,-1,1,-1]
Ausgabe: 4
Erläuterung:
Eine Möglichkeit, die Gesamtkosten zu maximieren, besteht darin, [1, -1, 1, -1] in die Unterarrays [1, -1] und [1, -1] aufzuteilen. Die Gesamtkosten betragen (1 + 1) + (1 + 1) = 4.

Beispiel 3:

Eingabe: nums = [0]
Ausgabe: 0
Erläuterung:
Wir können das Array nicht weiter aufteilen, daher ist die Antwort 0.

Beispiel 4:

Eingabe: nums = [1,-1]
Ausgabe: 2
Erläuterung:
Bei Auswahl des gesamten Arrays ergeben sich Gesamtkosten von 1 + 1 = 2, was dem Maximum entspricht.

Einschränkungen:

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


Sie erhalten zwei ganze Zahlen, Rot und Blau, die die Anzahl der roten und blauen Kugeln darstellen. Sie müssen diese Kugeln so anordnen, dass sie ein Dreieck bilden, sodass in der 1. Reihe 1 Kugel, in der 2. Reihe 2 Kugeln, in der 3. Reihe 3 Kugeln usw. liegen.
Alle Kugeln in einer bestimmten Reihe sollten die gleiche Farbe haben und benachbarte Reihen sollten unterschiedliche Farben haben.
Gibt die maximal erreichbare Höhe des Dreiecks zurück.

Beispiel 1:

Eingabe: Rot = 2, Blau = 4
Ausgabe: 3
Erläuterung:

Die einzig mögliche Anordnung ist oben dargestellt.

Beispiel 2:

Eingabe: Rot = 2, Blau = 1
Ausgabe: 2
Erläuterung:

Die einzig mögliche Anordnung ist oben dargestellt.

Beispiel 3:

Eingabe: Rot = 1, Blau = 1
Ausgabe: 1

Beispiel 4:

Eingabe: Rot = 10, Blau = 1
Ausgabe: 2
Erläuterung:

Die einzig mögliche Anordnung ist oben dargestellt.

Einschränkungen:

1 <= rot, blau <= 100

Sie erhalten zwei ganze Zahlen, Rot und Blau, die die Anzahl der roten und blauen Kugeln darstellen. Sie müssen diese Kugeln so anordnen, dass sie ein Dreieck bilden, sodass in der 1. Reihe 1 Kugel, in der 2. Reihe 2 Kugeln, in der 3. Reihe 3 Kugeln usw. liegen.
Alle Kugeln in einer bestimmten Reihe sollten die gleiche Farbe haben und benachbarte Reihen sollten unterschiedliche Farben haben.
Gibt die maximal erreichbare Höhe des Dreiecks zurück.

Beispiel 1:

Eingabe: red = 2, blue = 4
Ausgabe: 3
Erläuterung:

Die einzig mögliche Anordnung ist oben dargestellt.

Beispiel 2:

Eingabe: red = 2, blue = 1
Ausgabe: 2
Erläuterung:

Die einzig mögliche Anordnung ist oben dargestellt.

Beispiel 3:

Eingabe: red = 1, blue = 1
Ausgabe: 1

Beispiel 4:

Eingabe: red = 10, blue = 1
Ausgabe: 2
Erläuterung:

Die einzig mögliche Anordnung ist oben dargestellt.

Einschränkungen:

1 <= red, blue <= 100

Sie erhalten zwei ganze Zahlen rot und blau, die die Anzahl roter und blau gefärbter Kugeln darstellen. Sie müssen diese Bälle anordnen, um ein Dreieck zu bilden, sodass die 1^st -Reihe 1 Ball hat, die 2^nd -Reihe 2 Kugeln, die 3^rd -Reihe hat 3 Bälle und so weiter.
Alle Kugeln in einer bestimmten Reihe sollten die gleiche Farbe haben, und angrenzende Zeilen sollten unterschiedliche Farben haben.
Geben Sie die maximale Höhe des Dreiecks zurück, das erreicht werden kann.

Beispiel 1:

Eingabe: red = 2, blue = 4
Ausgabe: 3
Erläuterung:

Die einzige mögliche Anordnung ist oben gezeigt.

Beispiel 2:

Eingabe: red = 2, blue = 1
Ausgabe: 2
Erläuterung:

Die einzige mögliche Anordnung ist oben gezeigt.

Beispiel 3:

Eingabe: red = 1, blue = 1
Ausgabe: 1

Beispiel 4:

Eingabe: red = 10, blue = 1
Ausgabe: 2
Erläuterung:

Die einzige mögliche Anordnung ist oben gezeigt.

Einschränkungen:

1 <= red, blue <= 100


Sie erhalten ein ganzzahliges Array mit Zahlen.
Eine Teilfolge sub von nums mit der Länge x heißt gültig, wenn sie Folgendes erfüllt:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Gibt die Länge der längsten gültigen Teilfolge von Zahlen zurück.
Eine Teilsequenz ist ein Array, das von einem anderen Array abgeleitet werden kann, indem einige oder keine Elemente gelöscht werden, ohne die Reihenfolge der verbleibenden Elemente zu ändern.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgabe: 4
Erläuterung:
Die längste gültige Teilsequenz ist [1, 2, 3, 4].

Beispiel 2:

Eingabe: nums = [1,2,1,1,2,1,2]
Ausgabe: 6
Erläuterung:
Die längste gültige Teilsequenz ist [1, 2, 1, 2, 1, 2].

Beispiel 3:

Eingabe: nums = [1,3]
Ausgabe: 2
Erläuterung:
Die längste gültige Teilsequenz ist [1, 3].

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums.
Eine Teilsequenz von nums mit der Länge x wird als gültig bezeichnet, wenn sie folgende Anforderungen erfüllt:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Gibt die Länge der längsten gültigen Teilsequenz von nums zurück.
Eine Teilsequenz ist ein Array, das von einem anderen Array abgeleitet werden kann, indem einige oder keine Elemente gelöscht werden, ohne die Reihenfolge der verbleibenden Elemente zu ändern.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgang: 4
Erklärung:
Die längste gültige Teilsequenz ist [1, 2, 3, 4].

Beispiel 2:

Eingabe: nums = [1,2,1,1,2,1,2]
Ausgang: 6
Erklärung:
Die längste gültige Teilsequenz ist [1, 2, 1, 2, 1, 2].

Beispiel 3:

Eingabe: nums = [1,3]
Ausgang: 2
Erklärung:
Die längste gültige Teilsequenz ist [1, 3].

Zwänge:

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

Du hast ein ganzzahliges Array nums.
Eine Teilfolge sub von nums mit der Länge x wird als gültig bezeichnet, wenn sie erfüllt:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

Gib die Länge der längsten gültigen Teilfolge von nums zurück.
Eine Teilfolge ist ein Array, das von einem anderen Array abgeleitet werden kann, indem einige oder keine Elemente gelöscht werden, ohne die Reihenfolge der verbleibenden Elemente zu ändern.

Beispiel 1:

Input: nums = [1,2,3,4]
Output: 4
Erläuterung:
Die längste gültige Teilfolge ist [1, 2, 3, 4].

Beispiel 2:

Input: nums = [1,2,1,1,2,1,2]
Output: 6
Erläuterung:
Die längste gültige Teilfolge ist [1, 2, 1, 2, 1, 2].

Beispiel 3:

Input: nums = [1,3]
Output: 2
Erläuterung:
Die längste gültige Teilfolge ist [1, 3].

Einschränkungen:

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


Es existieren zwei ungerichtete Bäume mit n und m Knoten, nummeriert von 0 bis n - 1 bzw. von 0 bis m - 1. Sie erhalten zwei 2D-Integer-Arrays edges1 und edges2 mit den Längen n - 1 bzw. m - 1, wobei edges1[i] = [a_i, b_i] anzeigt, dass es eine Kante zwischen den Knoten a_i und b_i im ersten Baum gibt, und edges2[i] = [u_i, v_i] anzeigt, dass es eine Kante zwischen den Knoten u_i und v_i im zweiten Baum gibt.
Sie müssen einen Knoten aus dem ersten Baum mit einem anderen Knoten aus dem zweiten Baum mit einer Kante verbinden.
Geben Sie den minimal möglichen Durchmesser des resultierenden Baumes zurück.
Der Durchmesser eines Baumes ist die Länge des längsten Pfades zwischen zwei beliebigen Knoten im Baum.

Beispiel 1:

Eingabe: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Ausgabe: 3
Erläuterung:
Wir können einen Baum mit einem Durchmesser von 3 erhalten, indem wir den Knoten 0 aus dem ersten Baum mit einem beliebigen Knoten aus dem zweiten Baum verbinden.

Beispiel 2:

Eingabe: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Ausgabe: 5
Erläuterung:
Wir können einen Baum mit einem Durchmesser von 5 erhalten, indem wir den Knoten 0 aus dem ersten Baum mit dem Knoten 0 aus dem zweiten Baum verbinden.

Einschränkungen:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Die Eingabe ist so generiert, dass edges1 und edges2 gültige Bäume darstellen.

Es existieren zwei ungerichtete Bäume mit n und m Knoten, nummeriert von 0 bis n - 1 bzw. von 0 bis m - 1. Sie erhalten zwei 2D-Integer-Arrays „Kanten1“ und „Kanten2“ mit den Längen n – 1 bzw. m – 1, wobei Kanten1[i] = [a_i, b_i] angibt, dass es eine Kante zwischen den Knoten a_i und b_i im ersten Baum und Kanten2 gibt [i] = [u_i, v_i] zeigt an, dass es im zweiten Baum eine Kante zwischen den Knoten u_i und v_i gibt.
Sie müssen einen Knoten des ersten Baums mit einem anderen Knoten des zweiten Baums über eine Kante verbinden.
Gibt den minimal möglichen Durchmesser des resultierenden Baums zurück.
Der Durchmesser eines Baumes ist die Länge des längsten Pfades zwischen zwei beliebigen Knoten im Baum.

Beispiel 1:

Eingabe: Kanten1 = [[0,1],[0,2],[0,3]], Kanten2 = [[0,1]]
Ausgabe: 3
Erläuterung:
Wir können einen Baum mit dem Durchmesser 3 erhalten, indem wir Knoten 0 des ersten Baums mit einem beliebigen Knoten des zweiten Baums verbinden.

Beispiel 2:

Eingabe: Kanten1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], Kanten2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Ausgabe: 5
Erläuterung:
Wir können einen Baum mit einem Durchmesser von 5 erhalten, indem wir Knoten 0 des ersten Baums mit Knoten 0 des zweiten Baums verbinden.

Einschränkungen:

1 <= n, m <= 10^5
Kanten1.Länge == n - 1
Kanten2.Länge == m - 1
Kanten1[i].Länge == Kanten2[i].Länge == 2
Kanten1[i] = [a_i, b_i]
0 <= a_i, b_i < n
Kanten2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Die Eingabe wird so generiert, dass Kanten1 und Kanten2 gültige Bäume darstellen.

Es gibt zwei ungerichtete Bäume mit n- und m -Knoten, die von 0 bis n - 1 bzw. von 0 bis m - 1 nummeriert sind. Sie erhalten zwei 2D -Integer -Arrays -Kanten1 und Kanten2 der Längen n - 1 und m - 1, wobei die Kanten1 [i] = [a_i, b_i] angeben, dass es eine Kante zwischen Knoten a_i und b_i im ersten Baum und Kanten2 gibt [i] = [u_i, v_i] zeigt an, dass zwischen den Knoten u_i und v_i im zweiten Baum eine Kante gibt.
Sie müssen einen Knoten vom ersten Baum mit einem anderen Knoten aus dem zweiten Baum mit einer Kante anschließen.
Geben Sie den minimalen möglichen Durchmesser des resultierenden Baumes zurück.
Der Durchmesser eines Baumes ist die Länge des längsten Pfades zwischen zwei beliebigen Knoten im Baum.

Beispiel 1:

Eingabe: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Ausgabe: 3
Erläuterung:
Wir können einen Baum mit Durchmesser 3 erhalten, indem wir Knoten 0 vom ersten Baum mit jedem Knoten aus dem zweiten Baum anschließen.

Beispiel 2:

Eingabe: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Ausgabe: 5
Erläuterung:
Wir können einen Baum mit Durchmesser 5 erhalten, indem wir Knoten 0 vom ersten Baum mit dem Knoten 0 aus dem zweiten Baum anschließen.

Einschränkungen:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
Die Eingabe wird so erzeugt, dass Kanten1 und Kanten2 gültige Bäume darstellen.


Sie erhalten eine Zeichenfolge s und eine ganze Zahl k. Verschlüsseln Sie die Zeichenfolge mit dem folgenden Algorithmus:

Für jedes Zeichen c in s ersetzen Sie c durch das k-te Zeichen nach c in der Zeichenkette (zyklisch).

Geben Sie die verschlüsselte Zeichenkette zurück.

Beispiel 1:

Eingabe: s = "dart", k = 3
Ausgabe: „tdar“
Erläuterung:

Für i = 0 ist das 3^te Zeichen nach 'd' 't'.
Für i = 1 ist das 3^te Zeichen nach 'a' das 'd'.
Für i = 2 ist das 3^te Zeichen nach 'r' 'a'.
Für i = 3 ist das 3^te Zeichen nach 't' 'r'.

Beispiel 2:

Eingabe: s = "aaa", k = 1
Ausgabe: „aaa“
Erläuterung:
Da alle Zeichen gleich sind, wird auch die verschlüsselte Zeichenfolge gleich sein.

Beschränkungen:

1 <= s.length <= 100
1 <= k <= 10^4
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenfolge s und eine Ganzzahl k. Verschlüsseln Sie die Zeichenfolge mit dem folgenden Algorithmus:

Ersetzen Sie für jedes Zeichen c in s c durch das k-te Zeichen nach c in der Zeichenfolge (zyklisch).

Gibt die verschlüsselte Zeichenfolge zurück.

Beispiel 1:

Eingabe: s = „dart“, k = 3
Ausgabe: „tdar“
Erläuterung:

Für i = 0 ist das dritte Zeichen nach „d“ „t“.
Für i = 1 ist das dritte Zeichen nach „a“ „d“.
Für i = 2 ist das dritte Zeichen nach „r“ „a“.
Für i = 3 ist das dritte Zeichen nach „t“ „r“.

Beispiel 2:

Eingabe: s = „aaa“, k = 1
Ausgabe: „aaa“
Erläuterung:
Da alle Zeichen gleich sind, ist auch die verschlüsselte Zeichenfolge gleich.

Einschränkungen:

1 <= s.length <= 100
1 <= k <= 10^4
s besteht nur aus englischen Kleinbuchstaben.


Sie erhalten eine positive ganze Zahl n.
Eine Binärzeichenfolge x ist gültig, wenn alle Teilzeichenfolgen von x der Länge 2 mindestens eine „1“ enthalten.
Gibt alle gültigen Zeichenfolgen mit der Länge n in beliebiger Reihenfolge zurück.

Beispiel 1:

Eingabe: n = 3
Ausgabe: ["010", "011", "101", "110", "111"]
Erläuterung:
Die gültigen Zeichenfolgen der Länge 3 sind: „010“, „011“, „101“, „110“ und „111“.

Beispiel 2:

Eingabe: n = 1
Ausgabe: [„0“, „1“]
Erläuterung:
Die gültigen Zeichenfolgen der Länge 1 sind: „0“ und „1“.

Einschränkungen:

1 <= n <= 18

Sie erhalten eine positive ganze Zahl n.
Ein binärer String x ist gültig, wenn alle Teilstrings von x der Länge 2 mindestens eine "1" enthalten.
Gibt alle gültigen Zeichenfolgen mit der Länge n in beliebiger Reihenfolge zurück.

Beispiel 1:

Eingabe: n = 3
Ausgabe: ["010", "011", "101", "110", "111"]
Erläuterung:
Die gültigen Zeichenfolgen der Länge 3 sind: "010", "011", "101", "110" und "111".

Beispiel 2:

Eingabe: n = 1
Ausgabe: ["0","1"]
Erläuterung:
Die gültigen Zeichenfolgen der Länge 1 sind: "0" und "1".

Einschränkungen:

1 <= n <= 18


Geben Sie bei einem gegebenen 2D-Zeichenmatrixgitter, bei dem Grid[i][j] entweder „X“, „Y“ oder „.“ ist, die Anzahl der Untermatrizen zurück, die Folgendes enthalten:

Gitter[0][0]
eine gleiche Häufigkeit von „X“ und „Y“.
mindestens ein „X“.

Beispiel 1:

Eingabe: Gitter = [["X","Y","."],["Y",".","."]]
Ausgabe: 3
Erläuterung:

Beispiel 2:

Eingabe: Gitter = [["X","X"],["X","Y"]]
Ausgabe: 0
Erläuterung:
Keine Submatrix hat die gleiche Häufigkeit von „X“ und „Y“.

Beispiel 3:

Eingabe: Grid = [[".","."],[".","."]]
Ausgabe: 0
Erläuterung:
Keine Submatrix hat mindestens ein „X“.

Einschränkungen:

1 <= Gitterlänge, Gitter[i].Länge <= 1000
Grid[i][j] ist entweder 'X', 'Y' oder '.'.


Sie erhalten eine Zielzeichenkette, ein Array von Zeichenketten words und ein Integer-Array costs, beide Arrays mit der gleichen Länge.
Stellen Sie sich eine leere Zeichenkette s vor.
Sie können die folgende Operation beliebig oft durchführen (einschließlich Null):

Wählen Sie einen Index i aus dem Bereich [0, words.length - 1].
Hängen Sie words[i] an s an.
Die Kosten der Operation sind costs[i].

Gib die minimalen Kosten zurück, um s gleich dem Ziel zu machen. Wenn das nicht möglich ist, gib -1 zurück.

Beispiel 1:

Eingabe: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Ausgabe: 7
Erläuterung:
Die minimalen Kosten können durch die folgenden Operationen erreicht werden:

Wählen Sie den Index 1 und hängen Sie „abc“ an s an, was 1 kostet und s = "abc" ergibt.
Wählen Sie Index 2 und hängen Sie „d“ an s an, was 1 kostet und s = "abcd" ergibt.
Wählen Sie Index 4 und hängen Sie „ef“ an s an, was 5 kostet und s = "abcdef" ergibt.

Beispiel 2:

Eingabe: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Ausgabe: -1
Erläuterung:
Es ist unmöglich, s gleich target zu machen, also geben wir -1 zurück.

Beschränkungen:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Die Gesamtsumme von words[i].length ist kleiner als oder gleich 5 * 10^4.
target und words[i] bestehen nur aus englischen Kleinbuchstaben.
1 <= costs[i] <= 10^4

Sie erhalten ein String-Ziel, ein Array aus String-Worten und ein Integer-Array mit Kosten, wobei beide Arrays die gleiche Länge haben.
Stellen Sie sich eine leere Zeichenfolge s vor.
Sie können den folgenden Vorgang beliebig oft (einschließlich null) ausführen:

Wählen Sie einen Index i im Bereich [0, words.length - 1].
Wörter[i] an s anhängen.
Die Betriebskosten sind Kosten[i].

Gibt die Mindestkosten zurück, um s gleich dem Ziel zu machen. Wenn dies nicht möglich ist, geben Sie -1 zurück.

Beispiel 1:

Eingabe: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Ausgabe: 7
Erläuterung:
Die minimalen Kosten können durch die Durchführung der folgenden Vorgänge erreicht werden:

Wählen Sie Index 1 aus und hängen Sie „abc“ zum Preis von 1 an s an, was zu s = „abc“ führt.
Wählen Sie Index 2 und hängen Sie „d“ zum Preis von 1 an s an, was zu s = „abcd“ führt.
Wählen Sie Index 4 und hängen Sie „ef“ zum Preis von 5 an s an, was zu s = „abcdef“ führt.

Beispiel 2:

Eingabe: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Ausgabe: -1
Erläuterung:
Es ist unmöglich, s gleich target zu machen, also geben wir -1 zurück.

Einschränkungen:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
Die Gesamtsumme der Wörter[i].length ist kleiner oder gleich 5 * 10^4.
„target“ und „words[i]“ bestehen nur aus englischen Kleinbuchstaben.
1 <= costs[i] <= 10^4

Sie erhalten ein String-Ziel, ein Array mit Strings und Wörtern sowie ein Integer-Array mit Kosten, wobei beide Arrays die gleiche Länge haben.
Stellen Sie sich eine leere Zeichenfolge s vor.
Sie können den folgenden Vorgang beliebig oft (einschließlich null) ausführen:

Wählen Sie einen Index i im Bereich [0, Wörter.Länge - 1].
Wörter[i] an s anhängen.
Die Betriebskosten sind Kosten[i].

Gibt die Mindestkosten zurück, um s gleich dem Ziel zu machen. Wenn dies nicht möglich ist, geben Sie -1 zurück.

Beispiel 1:

Eingabe: Ziel = „abcdef“, Wörter = [„abdef“, „abc“, „d“, „def“, „ef“], Kosten = [100,1,1,10,5]
Ausgabe: 7
Erläuterung:
Die minimalen Kosten können durch die Durchführung der folgenden Vorgänge erreicht werden:

Wählen Sie Index 1 aus und hängen Sie „abc“ zum Preis von 1 an s an, was zu s = „abc“ führt.
Wählen Sie Index 2 und hängen Sie „d“ zum Preis von 1 an s an, was zu s = „abcd“ führt.
Wählen Sie Index 4 und hängen Sie „ef“ zum Preis von 5 an s an, was zu s = „abcdef“ führt.

Beispiel 2:

Eingabe: Ziel = „aaaa“, Wörter = [„z“, „zz“, „zzz“], Kosten = [1,10,100]
Ausgabe: -1
Erläuterung:
Es ist unmöglich, s gleich target zu machen, also geben wir -1 zurück.

Einschränkungen:

1 <= Ziellänge <= 5 * 10^4
1 <= Wörter.Länge == Kosten.Länge <= 5 * 10^4
1 <= Wörter[i].Länge <= Ziel.Länge
Die Gesamtsumme der Wörter[i].length ist kleiner oder gleich 5 * 10^4.
„target“ und „words[i]“ bestehen nur aus englischen Kleinbuchstaben.
1 <= kostet[i] <= 10^4


Geben Sie bei einer gegebenen Zeichenfolge s, die nur Ziffern enthält, die lexikographisch kleinste Zeichenfolge zurück, die erhalten werden kann, nachdem benachbarte Ziffern in s höchstens einmal mit derselben Parität ausgetauscht wurden.
Ziffern haben die gleiche Parität, wenn beide ungerade oder beide gerade sind. Beispielsweise haben 5 und 9 sowie 2 und 4 die gleiche Parität, während dies bei 6 und 9 nicht der Fall ist.

Beispiel 1:

Eingabe: s = „45320“
Ausgabe: „43520“
Erläuterung:
s[1] == '5' und s[2] == '3' haben beide die gleiche Parität, und wenn man sie vertauscht, erhält man die lexikografisch kleinste Zeichenfolge.

Beispiel 2:

Eingabe: s = „001“
Ausgabe: „001“
Erläuterung:
Es ist nicht erforderlich, einen Austausch durchzuführen, da s bereits das lexikografisch kleinste ist.

Einschränkungen:

2 <= s.length <= 100
s besteht nur aus Ziffern.

Geben Sie bei einer Zeichenkette s, die nur Ziffern enthält, die lexikografisch kleinste Zeichenkette zurück, die man erhält, wenn man benachbarte Ziffern in s höchstens einmal mit der gleichen Parität vertauscht.
Ziffern haben die gleiche Parität, wenn beide ungerade oder beide gerade sind. Zum Beispiel haben 5 und 9 sowie 2 und 4 die gleiche Parität, 6 und 9 hingegen nicht.

Beispiel 1:

Eingabe: s = "45320"
Ausgabe: „43520“
Erläuterung:
s[1] == '5' und s[2] == '3' haben beide die gleiche Parität, und durch Vertauschen erhält man die lexikografisch kleinste Zeichenkette.

Beispiel 2:

Eingabe: s = "001"
Ausgabe: „001“
Erläuterung:
Es ist nicht nötig, einen Tausch durchzuführen, da s bereits das lexikografisch kleinste ist.

Randbedingungen:

2 <= s.length <= 100
s besteht nur aus Ziffern.


Es gibt einen m x n -Kuchen, der in 1 x 1 Stücke geschnitten werden muss.
Sie erhalten Ganzzahlen m, n und zwei Arrays:

Horizontalschnitt der Größe m - 1, wobei horizontalCut[i] die Kosten für den Schnitt entlang der horizontalen Linie i darstellt.
Vertikalschnitt der Größe n - 1, wobei verticalCut[j] die Kosten für den Schnitt entlang der vertikalen Linie j darstellt.

In einer Operation können Sie jedes Stück Kuchen auswählen, das noch kein 1 x 1 Quadrat ist, und einen der folgenden Schnitte durchführen:

Schneiden Sie entlang einer horizontalen Linie i zu einem Preis von horizontalCut[i].
Schneiden Sie entlang einer vertikalen Linie j zu einem Preis von verticalCut[j].

Nach dem Schnitt ist das Stück Kuchen in zwei unterschiedliche Stücke unterteilt.
Die Kosten einer Kürzung hängen nur von den anfänglichen Kosten der Linie ab und ändert sich nicht.
Geben Sie die minimalen Gesamtkosten zurück, um den gesamten Kuchen in 1 x 1 Stücke zu schneiden.

Beispiel 1:

Eingabe: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
Ausgabe: 13
Erläuterung:

Führen Sie einen Schnitt auf der vertikalen Linie 0 mit Kosten 5 durch, die aktuellen Gesamtkosten betragen 5.
Führen Sie einen Schnitt auf der horizontalen Linie 0 des 3 x 1 Subgrids mit Kosten 1 durch.
Führen Sie einen Schnitt auf der horizontalen Linie 0 des 3 x 1 Subgrids mit Kosten 1 durch.
Führen Sie einen Schnitt auf der horizontalen Linie 1 auf 2 x 1 Subgrid mit Kosten 3 durch.
Führen Sie einen Schnitt auf der horizontalen Linie 1 auf 2 x 1 Subgrid mit Kosten 3 durch.

Die Gesamtkosten betragen 5 + 1 + 1 + 3 + 3 = 13.

Beispiel 2:

Eingabe: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Ausgabe: 15
Erläuterung:

Führen Sie einen Schnitt an der horizontalen Linie 0 mit Kosten 7 durch.
Führen Sie einen Schnitt auf der vertikalen Linie 0 auf 1 x 2 Subgrid mit Kosten 4 durch.
Führen Sie einen Schnitt auf der vertikalen Linie 0 auf 1 x 2 Subgrid mit Kosten 4 durch.

Die Gesamtkosten betragen 7 + 4 + 4 = 15.

Einschränkungen:

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3

Es gibt einen m x n Kuchen, der in 1 x 1 Stücke geschnitten werden muss.
Sie erhalten Ganzzahlen m, n und zwei Arrays:

horizontalCut der Größe m - 1, wobei horizontalCut[i] die Kosten für den Schnitt entlang der horizontalen Linie i darstellt.
VerticalCut der Größe n - 1, wobei VerticalCut[j] die Kosten für den Schnitt entlang der vertikalen Linie j darstellt.

In einem Arbeitsgang können Sie ein beliebiges Kuchenstück auswählen, das noch kein 1 x 1-Quadrat ist, und einen der folgenden Schnitte ausführen:

Schneiden Sie entlang einer horizontalen Linie i zum Preis von horizontalCut[i].
Schneiden Sie entlang einer vertikalen Linie j zum Preis von VerticalCut[j].

Nach dem Schneiden wird das Kuchenstück in zwei einzelne Stücke geteilt.
Die Kosten für einen Schnitt hängen nur von den Anschaffungskosten der Linie ab und ändern sich nicht.
Geben Sie die minimalen Gesamtkosten zurück, um den gesamten Kuchen in 1 x 1 Stücke zu schneiden.

Beispiel 1:

Eingabe: m = 3, n = 2, horizontalCut = [1,3], VerticalCut = [5]
Ausgabe: 13
Erläuterung:

Führen Sie einen Schnitt an der vertikalen Linie 0 mit Kosten von 5 durch. Die aktuellen Gesamtkosten betragen 5.
Führen Sie einen Schnitt an der horizontalen Linie 0 auf dem 3 x 1-Untergitter mit Kosten von 1 durch.
Führen Sie einen Schnitt an der horizontalen Linie 0 auf dem 3 x 1-Untergitter mit Kosten von 1 durch.
Führen Sie einen Schnitt an der horizontalen Linie 1 auf dem 2 x 1-Untergitter mit Kosten von 3 durch.
Führen Sie einen Schnitt an der horizontalen Linie 1 auf dem 2 x 1-Untergitter mit Kosten von 3 durch.

Die Gesamtkosten betragen 5 + 1 + 1 + 3 + 3 = 13.

Beispiel 2:

Eingabe: m = 2, n = 2, horizontalCut = [7], VerticalCut = [4]
Ausgabe: 15
Erläuterung:

Führen Sie einen Schnitt auf der horizontalen Linie 0 mit Kosten von 7 durch.
Führen Sie einen Schnitt an der vertikalen Linie 0 auf dem 1 x 2-Untergitter mit Kosten von 4 durch.
Führen Sie einen Schnitt an der vertikalen Linie 0 auf dem 1 x 2-Untergitter mit Kosten von 4 durch.

Die Gesamtkosten betragen 7 + 4 + 4 = 15.

Einschränkungen:

1 <= m, n <= 20
horizontalCut.length == m - 1
VerticalCut.length == n - 1
1 <= horizontalCut[i], VerticalCut[i] <= 10^3


Sie erhalten zwei positive ganze Zahlen n und k.
Sie können ein beliebiges Bit in der binären Darstellung von n wählen, das gleich 1 ist, und es in 0 ändern.
Geben Sie die Anzahl der Änderungen zurück, die nötig sind, um n gleich k zu machen. Ist dies unmöglich, geben Sie -1 zurück.

Beispiel 1:

Eingabe: n = 13, k = 4
Ausgabe: 2
Erläuterung:
Zu Beginn sind die binären Darstellungen von n und k n = (1101)_2 und k = (0100)_2.
Wir können das erste und vierte Bit von n ändern. Die resultierende ganze Zahl ist n = (0100)_2 = k.

Beispiel 2:

Eingabe: n = 21, k = 21
Ausgabe: 0
Erläuterung:
n und k sind bereits gleich, es sind also keine Änderungen erforderlich.

Beispiel 3:

Eingabe: n = 14, k = 13
Ausgabe: -1
Erläuterung:
Es ist nicht möglich, n gleich k zu machen.

Nebenbedingungen:

1 <= n, k <= 10^6

Sie erhalten zwei positive ganze Zahlen n und k.
Sie können jedes Bit in der binären Darstellung von n auswählen, das gleich 1 ist, und es in 0 ändern.
Gibt die Anzahl der Änderungen zurück, die erforderlich sind, um n gleich k zu machen. Wenn dies nicht möglich ist, geben Sie -1 zurück.

Beispiel 1:

Eingabe: n = 13, k = 4
Ausgabe: 2
Erläuterung:
Anfänglich sind die binären Darstellungen von n und k n = (1101)_2 und k = (0100)_2.
Wir können das erste und vierte Bit von n ändern. Die resultierende ganze Zahl ist n = (0100)_2 = k.

Beispiel 2:

Eingabe: n = 21, k = 21
Ausgabe: 0
Erläuterung:
n und k sind bereits gleich, daher sind keine Änderungen erforderlich.

Beispiel 3:

Eingabe: n = 14, k = 13
Ausgabe: -1
Erläuterung:
Es ist nicht möglich, n gleich k zu machen.

Einschränkungen:

1 <= n, k <= 10^6


Alice und Bob spielen ein Spiel mit einer Zeichenkette.
Sie erhalten eine Zeichenfolge s, Alice und Bob spielen abwechselnd das folgende Spiel, bei dem Alice zuerst beginnt:

Wenn Alice an der Reihe ist, muss sie eine nicht leere Teilzeichenfolge aus s entfernen, die eine ungerade Anzahl an Vokalen enthält.
Wenn Bob an der Reihe ist, muss er eine nicht leere Teilzeichenfolge aus s entfernen, die eine gerade Anzahl an Vokalen enthält.

Der erste Spieler, der in seinem Zug keinen Zug machen kann, verliert das Spiel. Wir gehen davon aus, dass sowohl Alice als auch Bob optimal spielen.
Gibt true zurück, wenn Alice das Spiel gewinnt, andernfalls false.
Die englischen Vokale sind: a, e, i, o und u.

Beispiel 1:

Eingabe: s = „leetcoder“
Ausgabe: wahr
Erläuterung:
Alice kann das Spiel wie folgt gewinnen:

Alice spielt zuerst, sie kann den unterstrichenen Teilstring in s = „leetcoder“ löschen, der 3 Vokale enthält. Die resultierende Zeichenfolge ist s = „der“.
Bob spielt als Zweiter, er kann den unterstrichenen Teilstring in s = „der“ löschen, der 0 Vokale enthält. Die resultierende Zeichenfolge ist s = „er“.
Alice spielt als Dritte, sie kann die gesamte Zeichenfolge s = „er“ löschen, die 1 Vokal enthält.
Bob spielt als Vierter, da die Zeichenkette leer ist, gibt es für Bob kein gültiges Spiel. Also gewinnt Alice das Spiel.

Beispiel 2:

Eingabe: s = „bbcd“
Ausgabe: falsch
Erläuterung:
Für Alice gibt es in ihrem ersten Zug kein gültiges Spiel, also verliert Alice das Spiel.

Einschränkungen:

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

Alice und Bob spielen ein Spiel mit einer Zeichenkette.
Sie erhalten eine Zeichenfolge s, Alice und Bob spielen abwechselnd das folgende Spiel, bei dem Alice zuerst beginnt:

Wenn Alice an der Reihe ist, muss sie eine nicht leere Teilzeichenfolge aus s entfernen, die eine ungerade Anzahl an Vokalen enthält.
Wenn Bob an der Reihe ist, muss er eine nicht leere Teilzeichenfolge aus s entfernen, die eine gerade Anzahl an Vokalen enthält.

Der erste Spieler, der in seinem Zug keinen Zug machen kann, verliert das Spiel. Wir gehen davon aus, dass sowohl Alice als auch Bob optimal spielen.
Gibt true zurück, wenn Alice das Spiel gewinnt, andernfalls false.
Die englischen Vokale sind: a, e, i, o und u.

Beispiel 1:

Eingabe: s = „leetcoder“
Ausgabe: wahr
Erläuterung:
Alice kann das Spiel wie folgt gewinnen:

Alice spielt zuerst, sie kann den unterstrichenen Teilstring in s = „leetcoder“ löschen, der 3 Vokale enthält. Die resultierende Zeichenfolge ist s = „der“.
Bob spielt als Zweiter, er kann den unterstrichenen Teilstring in s = „der“ löschen, der 0 Vokale enthält. Die resultierende Zeichenfolge ist s = „er“.
Alice spielt als Dritte, sie kann die gesamte Zeichenfolge s = „er“ löschen, die 1 Vokal enthält.
Bob spielt als Vierter, da die Zeichenfolge leer ist, gibt es für Bob kein gültiges Spiel. Also gewinnt Alice das Spiel.

Beispiel 2:

Eingabe: s = „bbcd“
Ausgabe: falsch
Erläuterung:
Für Alice gibt es in ihrem ersten Zug kein gültiges Spiel, also verliert Alice das Spiel.

Einschränkungen:

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

Alice und Bob spielen ein Spiel an einer Schnur.
Du bekommst eine Zeichenfolge s, Alice und Bob spielen abwechselnd das folgende Spiel, bei dem Alice zuerst beginnt:

Wenn Alice an der Reihe ist, muss sie jede nicht leere Teilzeichenfolge aus s entfernen, die eine ungerade Anzahl von Vokalen enthält.
Wenn Bob an der Reihe ist, muss er jede nicht-leere Teilzeichenkette aus s entfernen, die eine gerade Anzahl von Vokalen enthält.

Der erste Spieler, der in seinem Zug keinen Zug machen kann, verliert das Spiel. Wir gehen davon aus, dass sowohl Alice als auch Bob optimal spielen.
Gibt true zurück, wenn Alice das Spiel gewinnt, andernfalls false.
Die englischen Vokale sind: a, e, i, o und u.

Beispiel 1:

Eingabe: s = "leetcoder"
Ausgabe: true
Erklärung:
Alice kann das Spiel wie folgt gewinnen:

Alice spielt zuerst, sie kann den unterstrichenen Teilstring in s = "leetcoder" löschen, der 3 Vokale enthält. Die resultierende Zeichenfolge ist s = "der".
Bob spielt als Zweiter, er kann den unterstrichenen Teilstring in s = "der" löschen, der 0 Vokale enthält. Die resultierende Zeichenfolge ist s = "er".
Alice spielt die dritte, sie kann die ganze Zeichenkette s = "er" löschen, die 1 Vokal enthält.
Bob spielt die vierte, da die Saite leer ist, gibt es für Bob kein gültiges Spiel. Also gewinnt Alice das Spiel.

Beispiel 2:

Eingabe: s = "bbcd"
Ausgabe: false
Erklärung:
Es gibt kein gültiges Spiel für Alice in ihrem ersten Zug, also verliert Alice das Spiel.

Zwänge:

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


Sie erhalten eine binäre Zeichenfolge s.
Sie können die folgende Operation beliebig oft für die Zeichenfolge ausführen:

Wählen Sie einen beliebigen Index i aus der Zeichenfolge, wobei i + 1 < s.length gilt, sodass s[i] == '1' und s[i + 1] == '0' gilt.
Verschieben Sie das Zeichen s[i] nach rechts, bis es das Ende der Zeichenfolge oder eine weitere „1“ erreicht. Wenn wir beispielsweise für s = „010010“ i = 1 wählen, lautet die resultierende Zeichenfolge s = „000110“.

Gibt die maximale Anzahl von Vorgängen zurück, die Sie ausführen können.

Beispiel 1:

Eingabe: s = „1001101“
Ausgabe: 4
Erläuterung:
Wir können die folgenden Operationen durchführen:

Wählen Sie Index i = 0. Die resultierende Zeichenfolge ist s = „0011101“.
Wählen Sie Index i = 4. Die resultierende Zeichenfolge ist s = „0011011“.
Wählen Sie Index i = 3. Die resultierende Zeichenfolge ist s = „0010111“.
Wählen Sie Index i = 2. Die resultierende Zeichenfolge ist s = „0001111“.

Beispiel 2:

Eingabe: s = „00111“
Ausgabe: 0

Einschränkungen:

1 <= s.length <= 10^5
s[i] ist entweder '0' oder '1'.

Sie erhalten eine binäre Zeichenkette s.
Sie können die folgende Operation in der Zeichenfolge beliebig viele Male ausführen:

Wählen Sie einen beliebigen Index i aus der Zeichenfolge, in der i + 1 < s.length und s[i] == '1' und s[i + 1] == '0' .
Bewegen Sie den Zeichenkette s[i] nach rechts, bis er das Ende der Zeichenkette oder ein anderes '1' erreicht. Wenn wir beispielsweise für s = "010010" i = 1 wählen, ist die resultierende Zeichenfolge s = "000110".

Geben Sie die maximale Anzahl von Vorgängen zurück, die Sie ausführen können.

Beispiel 1:

Eingabe: s = "1001101"
Ausgabe: 4
Erläuterung:
Wir können die folgenden Operationen ausführen:

Wählen Sie Index i = 0. Die resultierende Zeichenfolge lautet s = "0011101".
Wählen Sie Index i = 4. Die resultierende Zeichenfolge lautet s = "0011011".
Wählen Sie Index i = 3. Die resultierende Zeichenfolge lautet s = "0010111".
Wählen Sie Index i = 2. Die resultierende Zeichenfolge lautet s = "0001111".

Beispiel 2:

Eingabe: s = "00111"
Ausgabe: 0

Einschränkungen:

1 <= s.length <= 10^5
s[i] ist entweder '0' oder '1'.


Sie erhalten zwei positive Ganzzahlarrays nums und target mit derselben Länge.
In einem einzigen Vorgang können Sie ein beliebiges Subarray mit Zahlen auswählen und jedes Element innerhalb dieses Subarrays um 1 erhöhen oder dekrementieren.
Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um nums dem Array-Ziel anzupassen.

Beispiel 1:

Eingabe: Nums = [3,5,1,2], Ziel = [4,6,2,4]
Ausgabe: 2
Erläuterung:
Wir werden die folgenden Operationen durchführen, um nums gleich dem Ziel zu machen:
- Erhöhe nums[0..3] um 1, nums = [4,6,2,3].
- Erhöhe nums[3..3] um 1, nums = [4,6,2,4].

Beispiel 2:

Eingabe: Nums = [1,3,2], Ziel = [2,1,4]
Ausgabe: 5
Erläuterung:
Wir werden die folgenden Operationen durchführen, um nums gleich dem Ziel zu machen:
- Nums[0..0] um 1 erhöhen, Nums = [2,3,2].
- Nums[1..1] um 1 dekrementieren, Nums = [2,2,2].
- Nums[1..1] um 1 dekrementieren, Nums = [2,1,2].
- Erhöhe nums[2..2] um 1, nums = [2,1,3].
- Erhöhe nums[2..2] um 1, nums = [2,1,4].

Einschränkungen:

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

Sie erhalten zwei positive Ganzzahlarrays nums und target mit derselben Länge.
In einem einzigen Vorgang können Sie ein beliebiges Subarray mit Zahlen auswählen und jedes Element innerhalb dieses Subarrays um 1 erhöhen oder dekrementieren.
Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um nums dem Array-Ziel anzupassen.

Beispiel 1:

Eingabe: nums = [3,5,1,2], target = [4,6,2,4]
Ausgabe: 2
Erläuterung:
Wir werden die folgenden Operationen durchführen, um nums gleich dem Ziel zu machen:
- Erhöhe nums[0..3] um 1, nums = [4,6,2,3].
- Erhöhe nums[3..3] um 1, nums = [4,6,2,4].

Beispiel 2:

Eingabe: nums = [1,3,2], target = [2,1,4]
Ausgabe: 5
Erläuterung:
Wir werden die folgenden Operationen durchführen, um nums gleich dem Ziel zu machen:
- Nums[0..0] um 1 erhöhen, Nums = [2,3,2].
- Nums[1..1] um 1 dekrementieren, Nums = [2,2,2].
- Nums[1..1] um 1 dekrementieren, Nums = [2,1,2].
- Erhöhe nums[2..2] um 1, nums = [2,1,3].
- Erhöhe nums[2..2] um 1, nums = [2,1,4].

Einschränkungen:

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


Sie erhalten ein Array positiver Ganzzahlen nums.
Alice und Bob spielen ein Spiel. Im Spiel kann Alice entweder alle einstelligen Zahlen oder alle zweistelligen Zahlen aus nums auswählen, und die restlichen Zahlen werden Bob gegeben. Alice gewinnt, wenn die Summe ihrer Zahlen strikt größer ist als die Summe von Bobs Zahlen.
Gibt true zurück, wenn Alice dieses Spiel gewinnen kann, andernfalls false.

Beispiel 1:

Eingabe: nums = [1,2,3,4,10]
Ausgabe: false
Erklärung:
Alice kann nicht gewinnen, wenn sie entweder einstellige oder zweistellige Zahlen wählt.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5,14]
Ausgabe: true
Erklärung:
Alice kann gewinnen, indem sie einstellige Zahlen wählt, deren Summe 15 ergibt.

Beispiel 3:

Eingabe: nums = [5,5,5,25]
Ausgabe: true
Erklärung:
Alice kann gewinnen, indem sie zweistellige Zahlen wählt, deren Summe 25 ergibt.

Einschränkungen:

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

Sie erhalten ein Array positiver  integers nums.
Alice und Bob spielen ein Spiel. Im Spiel kann Alice entweder alle einstelligen nums oder alle zweistelligen nums aus nums auswählen, und die restlichen nums werden an Bob gegeben. Alice gewinnt, wenn die Summe ihrer nums streng größer ist als die Summe von Bobs nums.
Geben Sie „true“ zurück, wenn Alice dieses Spiel gewinnen kann, andernfalls geben Sie „false“ zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,4,10]
Ausgabe: falsch
Erläuterung:
Alice kann nicht gewinnen, indem sie einstellige oder zweistellige nums wählt.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5,14]
Ausgabe: wahr
Erläuterung:
Alice kann gewinnen, indem sie einstellige nums wählt, deren Summe 15 beträgt.

Beispiel 3:

Eingabe: nums = [5,5,5,25]
Ausgabe: wahr
Erläuterung:
Alice kann gewinnen, indem sie zweistellige nums wählt, deren Summe 25 beträgt.

Einschränkungen:

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

Sie erhalten ein Feld mit positiven ganzen Zahlen nums.
Alice und Bob spielen ein Spiel. In dem Spiel kann Alice entweder alle einstelligen oder alle zweistelligen Zahlen aus nums auswählen, und die restlichen Zahlen werden Bob gegeben. Alice gewinnt, wenn die Summe ihrer Zahlen strikt größer ist als die Summe von Bobs Zahlen.
Gib true zurück, wenn Alice dieses Spiel gewinnen kann, andernfalls gib false zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,4,10]
Ausgabe: false
Erläuterung:
Alice kann weder mit einstelligen noch mit zweistelligen Zahlen gewinnen.

Beispiel 2:

Eingabe: nums = [1,2,3,4,5,14]
Ausgabe: true
Erläuterung:
Alice kann gewinnen, wenn sie einstellige Zahlen wählt, deren Summe gleich 15 ist.

Beispiel 3:

Eingabe: nums = [5,5,5,25]
Ausgabe: true
Erläutern Sie:
Alice kann gewinnen, wenn sie zweistellige Zahlen wählt, deren Summe gleich 25 ist.

Randbedingungen:

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


Sie erhalten zwei positive ganze Zahlen l und r. Für jede Zahl x heißen alle positiven Teiler von x außer x die echten Teiler von x.
Eine Zahl heißt speziell, wenn sie genau 2 echte Teiler hat. Zum Beispiel:

Die Zahl 4 ist speziell, weil sie die richtigen Teiler 1 und 2 hat.
Die Zahl 6 ist nicht speziell, da sie die richtigen Teiler 1, 2 und 3 hat.

Gibt die Anzahl der Zahlen im Bereich [l, r] zurück, die nicht speziell sind.

Beispiel 1:

Eingabe: l = 5, r = 7
Ausgabe: 3
Erläuterung:
Im Bereich [5, 7] gibt es keine Sonderzahlen.

Beispiel 2:

Eingabe: l = 4, r = 16
Ausgabe: 11
Erläuterung:
Die Sonderzahlen im Bereich [4, 16] sind 4 und 9.

Einschränkungen:

1 <= l <= r <= 10^9


Sie erhalten eine binäre Zeichenfolge s.
Gibt die Anzahl der Teilzeichenfolgen mit dominanten Einsen zurück.
Eine Zeichenfolge hat dominante Einsen, wenn die Anzahl der Einsen in der Zeichenfolge größer oder gleich dem Quadrat der Anzahl der Nullen in der Zeichenfolge ist.

Beispiel 1:

Eingabe: s = „00011“
Ausgabe: 5
Erläuterung:
Die Teilzeichenfolgen mit dominanten Einsen sind in der folgenden Tabelle aufgeführt.

i
j
s[i..j]
Anzahl der Nullen
Anzahl Einsen

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Beispiel 2:

Eingabe: s = „101101“
Ausgabe: 16
Erläuterung:
Die Teilzeichenfolgen mit nicht dominanten Einsen sind in der folgenden Tabelle aufgeführt.
Da es insgesamt 21 Teilzeichenfolgen gibt und 5 davon nicht dominante Einsen haben, folgt daraus, dass es 16 Teilzeichenfolgen mit dominanten Einsen gibt.

i
j
s[i..j]
Anzahl der Nullen
Anzahl Einsen

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Einschränkungen:

1 <= s.length <= 4 * 10^4
s besteht nur aus den Zeichen „0“ und „1“.

Sie erhalten eine binäre Zeichenfolge s.
Gibt die Anzahl der Teilzeichenfolgen mit dominanten zurück.
Eine Zeichenfolge hat dominante Einsen, wenn die Anzahl der Einsen in der Zeichenfolge größer oder gleich dem Quadrat der Anzahl der Nullen in der Zeichenfolge ist.

Beispiel 1:

Eingabe: s = "00011"
Ausgabe: 5
Erläuterung:
Die Teilzeichenfolgen mit dominanten Einsen sind in der folgenden Tabelle aufgeführt.

i
j
s[i..j]
Anzahl der Nullen
Anzahl der Einsen

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Beispiel 2:

Eingabe: s = "101101"
Ausgabe: 16
Erläuterung:
Die Teilzeichenfolgen mit nicht dominanten sind in der folgenden Tabelle aufgeführt.
Da es insgesamt 21 Teilzeichenfolgen gibt und 5 davon nicht dominante Zeichenketten haben, folgt daraus, dass es 16 Teilzeichenfolgen mit dominanten Zeichenketten gibt.

i
j
s[i..j]
Number of Zeros
Number of Ones

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Einschränkungen:

1 <= s.length <= 4 * 10^4
s besteht nur aus den Zeichen „0“ und „1“.

Es wird dir ein binärer String s gegeben.
Gib die Anzahl der Teilstrings mit dominierenden Einsen zurück.
Ein String hat dominante Einsen, wenn die Anzahl der Einsen im String größer oder gleich dem Quadrat der Anzahl der Nullen im String ist.

Beispiel 1:

Eingabe: s = "00011"
Ausgabe: 5
Erklärung:
Die Teilstrings mit dominierenden Einsen sind in der unten stehenden Tabelle gezeigt.

i
j
s[i..j]
Anzahl der Nullen
Anzahl der Einsen

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

Beispiel 2:

Eingabe: s = "101101"
Ausgabe: 16
Erklärung:
Die Teilstrings mit nicht-dominanten Einsen sind in der folgenden Tabelle dargestellt.
Da es insgesamt 21 Teilstrings gibt und 5 davon nicht-dominante Einsen haben, folgt daraus, dass es 16 Teilstrings mit dominanten Einsen gibt.

i
j
s[i..j]
Anzahl der Nullen
Anzahl der Einsen

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

Bedingungen:

1 <= s.length <= 4 * 10^4
s besteht nur aus den Zeichen '0' und '1'.


Sie erhalten zwei positive ganze Zahlen xCorner und yCorner sowie ein 2D-Array Kreise, wobei Circles[i] = [x_i, y_i, r_i] einen Kreis mit Mittelpunkt bei (x_i, y_i) und Radius r_i bezeichnet.
In der Koordinatenebene befindet sich ein Rechteck, dessen untere linke Ecke am Ursprung und dessen obere rechte Ecke an der Koordinate (xCorner, yCorner) liegt. Sie müssen prüfen, ob es einen Pfad von der unteren linken Ecke zur oberen rechten Ecke gibt, sodass der gesamte Pfad innerhalb des Rechtecks liegt, keinen Kreis berührt oder darin liegt und das Rechteck nur an den beiden Ecken berührt.
Gibt „true“ zurück, wenn ein solcher Pfad existiert, andernfalls „false“.

Beispiel 1:

Eingabe: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
Ausgabe: wahr
Erläuterung:

Die schwarze Kurve zeigt einen möglichen Pfad zwischen (0, 0) und (3, 4).

Beispiel 2:

Eingabe: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
Ausgabe: falsch
Erläuterung:

Es existiert kein Pfad von (0, 0) nach (3, 3).

Beispiel 3:

Eingabe: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
Ausgabe: falsch
Erläuterung:

Es existiert kein Pfad von (0, 0) nach (3, 3).

Beispiel 4:

Eingabe: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
Ausgabe: wahr
Erläuterung:

Einschränkungen:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

Sie erhalten zwei positive ganze Zahlen xCorner und yCorner sowie ein 2D-Array Kreise, wobei Circles[i] = [x_i, y_i, r_i] einen Kreis mit Mittelpunkt bei (x_i, y_i) und Radius r_i bezeichnet.
In der Koordinatenebene befindet sich ein Rechteck, dessen untere linke Ecke am Ursprung und dessen obere rechte Ecke an der Koordinate (xCorner, yCorner) liegt. Sie müssen prüfen, ob es einen Pfad von der unteren linken Ecke zur oberen rechten Ecke gibt, sodass der gesamte Pfad innerhalb des Rechtecks liegt, keinen Kreis berührt oder darin liegt und das Rechteck nur an den beiden Ecken berührt.
Gibt „true“ zurück, wenn ein solcher Pfad existiert, andernfalls „false“.

Beispiel 1:

Eingabe: xCorner = 3, yCorner = 4, Kreise = [[2,1,1]]
Ausgabe: wahr
Erläuterung:

Die schwarze Kurve zeigt einen möglichen Pfad zwischen (0, 0) und (3, 4).

Beispiel 2:

Eingabe: xCorner = 3, yCorner = 3, Kreise = [[1,1,2]]
Ausgabe: falsch
Erläuterung:

Es existiert kein Pfad von (0, 0) nach (3, 3).

Beispiel 3:

Eingabe: xCorner = 3, yCorner = 3, Kreise = [[2,1,1],[1,2,1]]
Ausgabe: falsch
Erläuterung:

Es existiert kein Pfad von (0, 0) nach (3, 3).

Beispiel 4:

Eingabe: xCorner = 4, yCorner = 4, Kreise = [[5,5,1]]
Ausgabe: wahr
Erläuterung:

Einschränkungen:

3 <= xCorner, yCorner <= 10^9
1 <= Kreise.Länge <= 1000
Kreise[i].Länge == 3
1 <= x_i, y_i, r_i <= 10^9


Gegeben ist eine Ganzzahl n und ein 2D-Ganzzahl-Array queries.
Es gibt n Städte, die von 0 bis n - 1 nummeriert sind. Anfänglich gibt es eine unidirektionale Straße von Stadt i zu Stadt i + 1 für alle 0 <= i < n - 1.
queries[i] = [u_i, v_i] repräsentiert die Hinzufügung einer neuen unidirektionalen Straße von Stadt u_i nach Stadt v_i. Nach jeder Anfrage musst du die Länge des kürzesten Weges von Stadt 0 zu Stadt n - 1 herausfinden.
Gib ein Array answer zurück, wobei für jedes i im Bereich [0, queries.length - 1] answer[i] die Länge des kürzesten Weges von Stadt 0 zu Stadt n - 1 nach der Verarbeitung der ersten i + 1 Anfragen ist.

Beispiel 1:

Input: n = 5, queries = [[2,4],[0,2],[0,4]]
Output: [3,2,1]
Erläuterung:

Nach der Hinzufügung der Straße von 2 nach 4 beträgt die Länge des kürzesten Weges von 0 nach 4 3.

Nach der Hinzufügung der Straße von 0 nach 2 beträgt die Länge des kürzesten Weges von 0 nach 4 2.

Nach der Hinzufügung der Straße von 0 nach 4 beträgt die Länge des kürzesten Weges von 0 nach 4 1.

Beispiel 2:

Input: n = 4, queries = [[0,3],[0,2]]
Output: [1,1]
Erläuterung:

Nach der Hinzufügung der Straße von 0 nach 3 beträgt die Länge des kürzesten Weges von 0 nach 3 1.

Nach der Hinzufügung der Straße von 0 nach 2 bleibt die Länge des kürzesten Weges 1.

Einschränkungen:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Es gibt keine doppelten Straßen unter den Anfragen.

Sie erhalten eine Ganzzahl n und eine 2D-Ganzzahl-Array-Abfrage.
Es gibt n Städte, die von 0 bis n - 1 nummeriert sind. Zunächst gibt es eine unidirektionale Straße von Stadt i zu Stadt i + 1 für alle 0 <= i < n - 1.
query[i] = [u_i, v_i] stellt die Hinzufügung einer neuen unidirektionalen Straße von der Stadt u_i zur Stadt v_i dar. Nach jeder Abfrage müssen Sie die Länge des kürzesten Weges von Stadt 0 zu Stadt n - 1 ermitteln.
Gibt eine Array-Antwort zurück, wobei für jedes i im Bereich [0, query.length – 1] Antwort[i] die Länge des kürzesten Pfads von Stadt 0 zu Stadt n – 1 nach Verarbeitung der ersten i + 1 Abfragen ist.

Beispiel 1:

Eingabe: n = 5, queries = [[2,4],[0,2],[0,4]]
Ausgabe: [3,2,1]
Erläuterung:

Nach Addition der Straße von 2 bis 4 beträgt die Länge des kürzesten Weges von 0 bis 4 3.

Nach Addition der Straße von 0 bis 2 beträgt die Länge des kürzesten Weges von 0 bis 4 2.

Nach Addition der Straße von 0 bis 4 beträgt die Länge des kürzesten Weges von 0 bis 4 1.

Beispiel 2:

Eingabe: n = 4, queries = [[0,3],[0,2]]
Ausgabe: [1,1]
Erläuterung:

Nach Addition der Straße von 0 bis 3 beträgt die Länge des kürzesten Weges von 0 bis 3 1.

Nach der Addition der Straße von 0 auf 2 bleibt die Länge des kürzesten Weges 1.

Einschränkungen:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
Unter den Abfragen gibt es keine wiederholten Straßen.

Sie erhalten eine Ganzzahl n und eine 2D-Ganzzahl-Array-Abfrage.
Es gibt n Städte, die von 0 bis n - 1 nummeriert sind. Zunächst gibt es eine unidirektionale Straße von Stadt i zu Stadt i + 1 für alle 0 <= i < n - 1.
query[i] = [u_i, v_i] stellt die Hinzufügung einer neuen unidirektionalen Straße von der Stadt u_i zur Stadt v_i dar. Nach jeder Abfrage müssen Sie die Länge des kürzesten Weges von Stadt 0 zu Stadt n – 1 ermitteln.
Gibt eine Array-Antwort zurück, wobei für jedes i im Bereich [0, query.length – 1] Antwort[i] die Länge des kürzesten Pfads von Stadt 0 zu Stadt n – 1 nach Verarbeitung der ersten i + 1 Abfragen ist.

Beispiel 1:

Eingabe: n = 5, Abfragen = [[2,4],[0,2],[0,4]]
Ausgabe: [3,2,1]
Erläuterung:

Nach Addition der Straße von 2 bis 4 beträgt die Länge des kürzesten Weges von 0 bis 4 3.

Nach Addition der Straße von 0 bis 2 beträgt die Länge des kürzesten Weges von 0 bis 4 2.

Nach Addition der Straße von 0 bis 4 beträgt die Länge des kürzesten Weges von 0 bis 4 1.

Beispiel 2:

Eingabe: n = 4, Abfragen = [[0,3],[0,2]]
Ausgabe: [1,1]
Erläuterung:

Nach Addition der Straße von 0 bis 3 beträgt die Länge des kürzesten Weges von 0 bis 3 1.

Nach der Addition der Straße von 0 auf 2 bleibt die Länge des kürzesten Weges 1.

Einschränkungen:

3 <= n <= 500
1 <= query.length <= 500
query[i].length == 2
0 <= Abfragen[i][0] < Abfragen[i][1] < n
1 < Abfragen[i][1] - Abfragen[i][0]
Unter den Abfragen gibt es keine wiederholten Straßen.


Rote und blaue Kacheln sind kreisförmig angeordnet. Sie erhalten ein Array von Ganzzahlen, das die Farben darstellt, und ein 2D-Array von Abfragen.
Die Farbe der Fliese i wird durch Farben[i] dargestellt:

Farben [i] == 0 bedeutet, dass die Fliese I rot ist.
Farben [i] == 1 bedeutet, dass die Fliese I blau ist.

Eine abwechselnde Gruppe ist eine zusammenhängende Untergruppe von Kacheln im Kreis, bei der die Farben abwechseln (jede Fliese, außer der ersten und letzten, hat eine andere Farbe als ihre Nachbarn).
Sie müssen Abfragen von zwei Typen verarbeiten:

Abfragen [i] = [1, size_i], bestimmen Sie die Anzahl der alternierenden Gruppen mit Größe size_i.
Abfragen [i] = [2, index_i, color_i], ändern Sie die Farben [index_i] in color_i.

Geben Sie ein Array zurück, das die Ergebnisse der Abfragen des ersten Typs in der Reihenfolge enthält.
Beachten Sie, dass die ersten und letzten Kacheln als nebeneinander angesehen werden, da die Farben einen Kreis bilden.

Beispiel 1:

Eingabe:colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Ausgabe: [2]
Erläuterung:

Erste Abfrage:
Ändern Sie die Farben [1] auf 0.

Zweite Abfrage:
Anzahl der abwechselnden Gruppen mit Größe 4:

Beispiel 2:

Eingabe: Farben = [0,0,1,0,1,1], Abfragen = [[1,3], [2,3,0], [1,5]]
Ausgabe: [2,0]
Erläuterung:

Erste Abfrage:
Anzahl der abwechselnden Gruppen mit Größe 3:

Zweite Abfrage: Farben ändern sich nicht.
Dritte Abfrage: Es gibt keine abwechselnde Gruppe mit Größe 5.

Einschränkungen:

4 <= Farben.length <= 5 * 10^4
0 <= Farben[i] <= 1
1 <= Abfragen.Length <= 5 * 10^4
Abfragen [i] [0] == 1 oder Abfragen [i] [0] == 2
Für alles ich das:

Abfragen [i] [0] == 1: Abfragen [i] .Length == 2, 3 <= Abfragen [i] [1] <= Farben.length - 1
Abfragen [i] [0] == 2: Abfragen [i] .Length == 3, 0 <= Abfragen [i] [1] <= Farben.length - 1, 0 <= Abfragen [i] [2] < = 1

Es gibt einige kreisförmig angeordnete rote und blaue Kacheln. Sie erhalten ein Array von Ganzzahlen, das die Farben darstellt, und ein 2D-Ganzzahlarray mit Abfragen.
Die Farbe der Kachel i wird durch farben[i] dargestellt:

farben[i] == 0 bedeutet, dass die Kachel i rot ist.
farben[i] == 1 bedeutet, dass Kachel i blau ist.

Eine alternierende Gruppe ist eine zusammenhängende Teilmenge von Kacheln im Kreis mit wechselnden farben (jede Kachel in der Gruppe außer der ersten und letzten hat eine andere Farbe als die benachbarten Kacheln in der Gruppe).
Sie müssen zwei Arten von Abfragen verarbeiten:

query[i] = [1, size_i], bestimmt die Anzahl der alternierenden Gruppen mit der Größe size_i.
query[i] = [2, index_i, color_i], ändert farben[index_i] in color_i.

Gibt eine Array-Antwort zurück, die die Ergebnisse der Abfragen des ersten Typs in der Reihenfolge enthält.
Beachten Sie, dass die ersten und letzten Kacheln als nebeneinander liegend betrachtet werden, da farben einen Kreis darstellen.

Beispiel 1:

Eingabe: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
Ausgabe: [2]
Erläuterung:

Erste Abfrage:
Ändern Sie die farben[1] auf 0.

Zweite Abfrage:
Anzahl der Wechselgruppen mit Größe 4:

Beispiel 2:

Eingabe: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
Ausgabe: [2,0]
Erläuterung:

Erste Abfrage:
Anzahl der Wechselgruppen mit Größe 3:

Zweite Abfrage: farben ändern sich nicht.
Dritte Abfrage: Es gibt keine Wechselgruppe mit Größe 5.

Einschränkungen:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
Für alle i, für die gilt:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

Es gibt einige kreisförmig angeordnete rote und blaue Kacheln. Sie erhalten ein Array von Ganzzahlen, das die Farben darstellt, und ein 2D-Array von Abfragen.
Die Farbe der Kachel i wird durch farben[i] dargestellt:

farben[i] == 0 bedeutet, dass die Kachel i rot ist.
farben[i] == 1 bedeutet, dass Kachel i blau ist.

Eine alternierende Gruppe ist eine zusammenhängende Teilmenge von Kacheln im Kreis, bei der die Farben wechseln. (jede Kachel in der Gruppe außer der ersten und letzten hat eine andere Farbe als die benachbarten Kacheln in der Gruppe).
You have to process queries of two types:

query[i] = [1, size_i], bestimmt die Anzahl der alternierenden Gruppen mit der Größe size_i.
query[i] = [2, index_i, color_i], ändern Sie farben[index_i] in color_i.

Gibt ein Array zurück, das die Ergebnisse der Abfragen des ersten Typs in der Reihenfolge enthält.
Beachten Sie, dass die ersten und letzten Kacheln als nebeneinander liegend betrachtet werden, da farben einen Kreis darstellen.

Beispiel 1:

Eingabe: farben = [0,1,1,0,1], query = [[2,1,0],[1,4]]
Ausgabe: [2]
Erläuterung:

Erste Abfrage:
Ändern Sie die farben[1] auf 0.

Zweite Abfrage:
Anzahl der Wechselgruppen mit Größe 4:

Beispiel 2:

Eingabe: farben = [0,0,1,0,1,1], query = [[1,3],[2,3,0],[1,5]]
Ausgabe: [2,0]
Erläuterung:

Erste Abfrage:
Anzahl der Wechselgruppen mit Größe 3:

Zweite Abfrage: Die Farben der Kacheln ändern sich nicht.
Dritte Abfrage: Es gibt keine Wechselgruppe mit Größe 5.

Einschränkungen:

4 <= farben.length <= 5 * 10^4
0 <= farben[i] <= 1
1 <= query.length <= 5 * 10^4
query[i][0] == 1 oder query[i][0] == 2
Für alle i, die folgende Bedingungen erfüllen:

query[i][0] == 1: query[i].length == 2, 3 <= query[i][1] <= farben.length - 1
query[i][0] == 2: query[i].length == 3, 0 <= query[i][1] <= farben.length - 1, 0 <= query[i][2] < = 1


Es gibt eine Schlange in einem n x n-Matrixgitter und kann sich in vier mögliche Richtungen bewegen. Jede Zelle im Gitter wird durch die Position identifiziert: Gitter[i][j] = (i * n) + j.
Die Schlange beginnt bei Zelle 0 und folgt einer Befehlsfolge.
Sie erhalten eine Ganzzahl n, die die Größe des Rasters darstellt, und ein Array von Zeichenfolgen commands, wobei jeder Befehl[i] entweder „UP“, „RIGHT“, „DOWN“ und „LEFT“ ist. Es ist garantiert, dass die Schlange während ihrer gesamten Bewegung innerhalb der Gittergrenzen bleibt.
Gibt die Position der letzten Zelle zurück, in der die Schlange nach der Ausführung von commands landet.

Beispiel 1:

Eingabe: n = 2, commands = ["RIGHT", "DOWN"]
Ausgabe: 3
Erläuterung:

0
1

2
3

0
1

2
3

0
1

2
3

Beispiel 2:

Eingabe: n = 3, commands = ["DOWN", "RIGHT", "UP"]
Ausgabe: 1
Erläuterung:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Einschränkungen:

2 <= n <= 10
1 <= commands.length <= 100
commands bestehen nur aus „UP“, „RIGHT“, „DOWN“ und „LEFT“.
Die Eingabe wird so generiert, dass sich die Schlange nicht über die Grenzen hinaus bewegt.

Es gibt eine Schlange in einem n x n Gitter und kann sich in vier möglichen Richtungen bewegen. Jede Zelle im Raster wird durch die Position identifiziert: Gitter [i] [j] = (i * n) + j.
Die Schlange beginnt in der Zelle 0 und folgt einer Folge von Befehlen.
Sie erhalten eine ganze Zahl n, die die Größe des Gitters angibt, und eine Reihe von String-Befehlen, wobei jeder Befehl[i] entweder „OBEN“, „RECHTS“, „RUNTER“ oder „LINKS“ ist. Es ist garantiert, dass die Schlange während ihrer gesamten Bewegung innerhalb der Gittergrenzen bleibt.
Geben Sie die Position der endgültigen Zelle zurück, in der die Schlange nach der Ausführung von Befehlen endet.

Beispiel 1:

Eingabe: n = 2, commands = ["RIGHT","DOWN"]
Ausgabe: 3
Erläuterung:

0
1

2
3

0
1

2
3

0
1

2
3

Beispiel 2:

Eingabe: n = 3, commands = ["DOWN","RIGHT","UP"]
Ausgabe: 1
Erläuterung:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Einschränkungen:

2 <= n <= 10
1 <= commands.length <= 100
Die Befehle bestehen nur aus „UP“, „RIGHT“, „DOWN“ und „LEFT“.
Die Eingabe wird so generiert, dass sich die Schlange nicht außerhalb der Grenzen bewegt.

In einem n x n-Matrixgitter befindet sich eine Schlange, die sich in vier mögliche Richtungen bewegen kann. Jede Zelle im Matrixgitter wird durch die Position identifiziert: Matrixgitter[i][j] = (i * n) + j.
Die Schlange beginnt bei Zelle 0 und folgt einer Befehlsfolge.
Sie erhalten eine ganzzahlige Zahl n, die die Größe des Rasters darstellt, und ein Array von Zeichenfolgenbefehlen, wobei jeder Befehl[i] entweder "UP", "RIGHT", "DOWN", und "LEFT" ist. Es ist garantiert, dass die Schlange während ihrer gesamten Bewegung innerhalb der Gittergrenzen bleibt.
Gibt die Position der letzten Zelle zurück, in der die Schlange nach der Ausführung von Befehlen landet.

Beispiel 1:

Eingabe: n = 2, Befehle = ["RIGHT","DOWN"]
Ausgabe: 3
Erläuterung:

0
1

2
3

0
1

2
3

0
1

2
3

Beispiel 2:

Eingabe: n = 3, Befehle = ["DOWN", "RIGHT", "UP"]
Ausgabe: 1
Erläuterung:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Einschränkungen:

2 <= n <= 10
1 <= commands.length <= 100
Befehle bestehen nur aus "UP", "RIGHT", "DOWN", and "LEFT".
Die Eingabe wird so generiert, dass sich die Schlange nicht über die Grenzen hinaus bewegt.


Sie erhalten ein Array positiver Ganzzahlen der Länge n.
Wir nennen ein Paar nicht negativer ganzzahliger Arrays (arr1, arr2) monoton, wenn:

Die Längen beider Arrays betragen n.
arr1 ist monoton nicht abnehmend, mit anderen Worten: arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 ist monoton nicht steigend, mit anderen Worten: arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] für alle 0 <= i <= n - 1.

Gibt die Anzahl monotoner Paare zurück.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: nums = [2,3,2]
Ausgabe: 4
Erläuterung:
Die guten Paare sind:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Beispiel 2:

Eingabe: nums = [5,5,5,5]
Ausgabe: 126

Einschränkungen:

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

Sie erhalten eine Reihe von positiven ganzen Zahlen nums der Länge n.
Wir nennen ein Paar von nicht-negativen Ganzzahl-Arrays (arr1, arr2) monoton, wenn:

Die Längen beider Arrays sind n.
arr1 ist monoton nicht-abnehmend, mit anderen Worten: arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 ist monoton nicht-erhöhend, d. h. arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] für alle 0 <= i <= n - 1.

Gibt die Anzahl der monotonen Paare zurück.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: nums = [2,3,2]
Ausgabe: 4
Erläuterung:
Die guten Paare sind:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

Beispiel 2:

Eingabe: nums = [5,5,5,5]
Ausgabe: 126

Beschränkungen:

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


Sie erhalten eine Zeichenfolge s.
Ihre Aufgabe besteht darin, alle Ziffern zu entfernen, indem Sie diesen Vorgang wiederholt ausführen:

Löschen Sie die erste Ziffer und das nächste nichtstellige Zeichen links davon.

Gibt die resultierende Zeichenfolge zurück, nachdem alle Ziffern entfernt wurden.

Beispiel 1:

Eingabe: s = „abc“
Ausgabe: „abc“
Erläuterung:
Die Zeichenfolge enthält keine Ziffer.

Beispiel 2:

Eingabe: s = „cb34“
Ausgabe: ""
Erläuterung:
Zuerst wenden wir die Operation auf s[2] an und s wird zu „c4“.
Dann wenden wir die Operation auf s[1] an und s wird zu „“.

Einschränkungen:

1 <= s.length <= 100
s besteht nur aus englischen Kleinbuchstaben und Ziffern.
Die Eingabe wird so generiert, dass das Löschen aller Ziffern möglich ist.


Ein Wettbewerb besteht aus n Spielern, die von 0 bis n - 1 nummeriert sind.
Sie erhalten ein ganzzahliges Array von Fähigkeiten der Größe n und einer positiven ganzen Zahl k, wobei skills[i] die Fähigkeitsstufe von Spieler i ist. Alle ganzen Zahlen in Fähigkeiten sind eindeutig.
Alle Spieler stehen in der Reihenfolge von Spieler 0 bis Spieler n – 1 in einer Warteschlange.
Der Wettbewerbsprozess ist wie folgt:

Die ersten beiden Spieler in der Warteschlange spielen ein Spiel und der Spieler mit der höheren Fähigkeitsstufe gewinnt.
Nach dem Spiel bleibt der Gewinner am Anfang der Warteschlange und der Verlierer am Ende.

Der Gewinner des Wettbewerbs ist der erste Spieler, der k Spiele in Folge gewinnt.
Gibt den Anfangsindex des Gewinners zurück.

Beispiel 1:

Eingabe: Fähigkeiten = [4,2,6,3,9], k = 2
Ausgabe: 2
Erläuterung:
Zu Beginn beträgt die Spielerwarteschlange [0,1,2,3,4]. Es findet folgender Vorgang statt:

Spieler 0 und 1 spielen ein Spiel, da die Fähigkeiten von Spieler 0 höher sind als die von Spieler 1, Spieler 0 gewinnt. Die resultierende Warteschlange ist [0,2,3,4,1].
Spieler 0 und 2 spielen ein Spiel, da die Fähigkeiten von Spieler 2 höher sind als die von Spieler 0, Spieler 2 gewinnt. Die resultierende Warteschlange ist [2,3,4,1,0].
Spieler 2 und 3 spielen ein Spiel, da die Fähigkeiten von Spieler 2 höher sind als die von Spieler 3, Spieler 2 gewinnt. Die resultierende Warteschlange ist [2,4,1,0,3].

Spieler 2 hat k = 2 Spiele hintereinander gewonnen, der Gewinner ist also Spieler 2.

Beispiel 2:

Eingabe: Fähigkeiten = [2,5,4], k = 3
Ausgabe: 1
Erläuterung:
Zu Beginn beträgt die Spielerwarteschlange [0,1,2]. Es findet folgender Vorgang statt:

Spieler 0 und 1 spielen ein Spiel, da die Fähigkeiten von Spieler 1 höher sind als die von Spieler 0, Spieler 1 gewinnt. Die resultierende Warteschlange ist [1,2,0].
Spieler 1 und 2 spielen ein Spiel, da die Fähigkeiten von Spieler 1 höher sind als die von Spieler 2, Spieler 1 gewinnt. Die resultierende Warteschlange ist [1,0,2].
Spieler 1 und 0 spielen ein Spiel, da die Fähigkeiten von Spieler 1 höher sind als die von Spieler 0, Spieler 1 gewinnt. Die resultierende Warteschlange ist [1,2,0].

Spieler 1 hat k = 3 Spiele hintereinander gewonnen, der Gewinner ist also Spieler 1.

Einschränkungen:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= Fähigkeiten[i] <= 10^6
Alle ganzen Zahlen in Fähigkeiten sind eindeutig.

Ein Wettbewerb besteht aus n Spielern, die von 0 bis n - 1 nummeriert sind.
Sie erhalten ein ganzzahliges Array von Skills der Größe n und eine positive Ganzzahl k, wobei Skills[i] die Fähigkeitsstufe von Spieler i ist. Alle Ganzzahlen in Skills sind eindeutig.
Alle Spieler stehen in einer Warteschlange in der Reihenfolge von Spieler 0 bis Spieler n - 1.
Der Wettbewerbsablauf ist wie folgt:

Die ersten beiden Spieler in der Warteschlange spielen ein Spiel, und der Spieler mit der höheren Fähigkeitsstufe gewinnt.
Nach dem Spiel bleibt der Gewinner am Anfang der Warteschlange, und der Verlierer geht ans Ende.

Der Gewinner des Wettbewerbs ist der erste Spieler, der k Spiele in Folge gewinnt.
Gibt den Anfangsindex des Gewinners zurück.

Beispiel 1:

Eingabe: skills = [4,2,6,3,9], k = 2
Ausgabe: 2
Erklärung:
Anfangs ist die Warteschlange der Spieler [0,1,2,3,4]. Dabei läuft folgender Prozess ab:

Spieler 0 und 1 spielen ein Spiel. Da die Fertigkeit von Spieler 0 höher ist als die von Spieler 1, gewinnt Spieler 0. Die resultierende Warteschlange lautet [0,2,3,4,1].
Spieler 0 und 2 spielen ein Spiel. Da die Fertigkeit von Spieler 2 höher ist als die von Spieler 0, gewinnt Spieler 2. Die resultierende Warteschlange lautet [2,3,4,1,0].
Spieler 2 und 3 spielen ein Spiel. Da die Fertigkeit von Spieler 2 höher ist als die von Spieler 3, gewinnt Spieler 2. Die resultierende Warteschlange lautet [2,4,1,0,3].

Spieler 2 hat k = 2 Spiele in Folge gewonnen, also ist Spieler 2 der Gewinner.

Beispiel 2:

Eingabe: skills = [2,5,4], k = 3
Ausgabe: 1
Erklärung:
Anfangs lautet die Warteschlange der Spieler [0,1,2]. Dabei läuft folgender Prozess ab:

Spieler 0 und 1 spielen ein Spiel. Da die Fertigkeit von Spieler 1 höher ist als die von Spieler 0, gewinnt Spieler 1. Die resultierende Warteschlange lautet [1,2,0].
Spieler 1 und 2 spielen ein Spiel. Da die Fertigkeit von Spieler 1 höher ist als die von Spieler 2, gewinnt Spieler 1. Die resultierende Warteschlange lautet [1,0,2].
Spieler 1 und 0 spielen ein Spiel. Da die Fertigkeit von Spieler 1 höher ist als die von Spieler 0, gewinnt Spieler 1. Die resultierende Warteschlange lautet [1,2,0].

Spieler 1 hat k = 3 Spiele in Folge gewonnen, also ist Spieler 1 der Gewinner.

Einschränkungen:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Alle Ganzzahlen in Skills sind eindeutig.

Ein Wettbewerb besteht aus n Spielern, die von 0 bis n - 1 nummeriert sind.
Sie erhalten ein ganzzahliges Array skills der Größe n und eine positive Ganzzahl k, wobei skills[i] die Fähigkeitsstufe von Spieler i ist. Alle ganzen Zahlen in Skills sind einzigartig.
Alle Spieler stehen in einer Warteschlange in der Reihenfolge von Spieler 0 bis Spieler n - 1.
Der Ablauf des Wettbewerbs läuft wie folgt ab:

Die ersten beiden Spieler in der Warteschlange spielen ein Spiel, und der Spieler mit der höheren Fähigkeitsstufe gewinnt.
Nach dem Spiel bleibt der Gewinner am Anfang der Warteschlange und der Verlierer kommt ans Ende.

Der Gewinner des Wettbewerbs ist der erste Spieler, der k Spiele in Folge gewinnt.
Gibt den Anfangsindex des Gewinners zurück.

Beispiel 1:

Eingabe: skills = [4,2,6,3,9], k = 2
Ausgang: 2
Erklärung:
Zu Beginn ist die Warteschlange der Spieler [0,1,2,3,4]. Der folgende Prozess läuft ab:

Die Spieler 0 und 1 spielen ein Spiel, da das Können von Spieler 0 höher ist als das von Spieler 1, gewinnt Spieler 0. Die resultierende Warteschlange ist [0,2,3,4,1].
Die Spieler 0 und 2 spielen ein Spiel, da die Fähigkeiten von Spieler 2 höher sind als die von Spieler 0, gewinnt Spieler 2. Die resultierende Warteschlange ist [2,3,4,1,0].
Die Spieler 2 und 3 spielen ein Spiel, da das Können von Spieler 2 höher ist als das von Spieler 3, gewinnt Spieler 2. Die resultierende Warteschlange ist [2,4,1,0,3].

Spieler 2 hat k = 2 Spiele in Folge gewonnen, also ist der Gewinner Spieler 2.

Beispiel 2:

Eingabe: skills = [2,5,4], k = 3
Ausgang: 1
Erklärung:
Zu Beginn beträgt die Warteschlange der Spieler [0,1,2]. Der folgende Prozess läuft ab:

Die Spieler 0 und 1 spielen ein Spiel, da die Fähigkeiten von Spieler 1 höher sind als die von Spieler 0, gewinnt Spieler 1. Die resultierende Warteschlange ist [1,2,0].
Die Spieler 1 und 2 spielen ein Spiel, da das Können von Spieler 1 höher ist als das von Spieler 2, gewinnt Spieler 1. Die resultierende Warteschlange ist [1,0,2].
Die Spieler 1 und 0 spielen ein Spiel, da das Können von Spieler 1 höher ist als das von Spieler 0, gewinnt Spieler 1. Die resultierende Warteschlange ist [1,2,0].

Spieler 1 hat k = 3 Spiele in Folge gewonnen, also ist der Gewinner Spieler 1.

Zwänge:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
Alle ganzen Zahlen in Skills sind einzigartig.


Sie erhalten ein ganzzahliges Array nums und eine nicht negative ganze Zahl k. Eine Folge ganzer Zahlen seq heißt gut, wenn es höchstens k Indizes i im Bereich [0, seq.length - 2] gibt, so dass seq[i] != seq[i + 1].
Gibt die maximal mögliche Länge einer guten Teilfolge von Nums zurück.

Beispiel 1:

Eingabe: nums = [1,2,1,1,3], k = 2
Ausgabe: 4
Erläuterung:
Die maximale Länge einer guten Teilsequenz ist [1,2,1,1,3].

Beispiel 2:

Eingabe: nums = [1,2,3,4,5,1], k = 0
Ausgabe: 2
Erläuterung:
Die maximale Länge einer guten Teilsequenz ist [1,2,3,4,5,1].

Einschränkungen:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)

Sie erhalten ein ganzzahliges Array nums und eine nicht negative ganze Zahl k. Eine Folge ganzer Zahlen seq heißt gut, wenn es höchstens k Indizes i im Bereich [0, seq.length - 2] gibt, so dass seq[i] != seq[i + 1].
Gibt die maximal mögliche Länge einer guten Teilfolge von Nums zurück.

Beispiel 1:

Eingabe: nums = [1,2,1,1,3], k = 2
Ausgabe: 4
Erläuterung:
Die maximale Länge einer Teilsequenz beträgt [1,2,1,1,3].

Beispiel 2:

Eingabe: nums = [1,2,3,4,5,1], k = 0
Ausgabe: 2
Erläuterung:
Die maximale Länge einer Teilsequenz beträgt [1,2,3,4,5,1].

Einschränkungen:

1 <= nums.Länge <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)

Sie erhalten eine Ganzzahl-Array-nums und eine nicht negative Ganzzahl k. Eine Abfolge von Ganzzahlen SEQ wird als gut bezeichnet, wenn es höchstens k -Indizes I im Bereich [0, seq.Length - 2] gibt, so dass seq[i] != seq[i + 1].
Geben Sie die maximal mögliche Länge einer guten Subsequenz von nums zurück.

Beispiel 1:

Eingabe: nums = [1,2,1,1,3], k = 2
Ausgabe: 4
Erläuterung:
Die maximale Länge einer guten Teilfolge ist 4, z.B. [1,2,1,1,3].

Beispiel 2:

Eingabe: nums = [1,2,3,4,5,1], k = 0
Ausgabe: 2
Erläuterung:
Die maximale Länge der Sequenz beträgt [1,2,3,4,5,1].

Einschränkungen:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)


Sie erhalten ein Array von ganzen Zahlen. In einem Vorgang können Sie zu jedem Element von nums 1 addieren oder davon subtrahieren.
Gibt die Mindestanzahl an Operationen zurück, um alle Elemente von nums durch 3 teilbar zu machen.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgabe: 3
Erläuterung:
Alle Array-Elemente können mit drei Operationen durch 3 teilbar gemacht werden:

Subtrahiere 1 von 1.
Addiere 1 zu 2.
Subtrahiere 1 von 4.

Beispiel 2:

Eingabe: nums = [3,6,9]
Ausgabe: 0

Einschränkungen:

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

Sie erhalten eine Ganzzahlarray nums. In einer Operation können Sie 1 von jedem Element von nums hinzufügen oder abziehen.
Geben Sie die Mindestanzahl von Operationen zurück, um alle Elemente der nums durch 3 teilbar zu machen.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgabe: 3
Erläuterung:
Alle Array-Elemente können mit 3 Operationen durch 3 teilbar gemacht werden:

Subtrahieren Sie 1 von 1.
Fügen Sie 1 zu 2 hinzu.
Subtrahieren Sie 1 von 4.

Beispiel 2:

Eingabe: nums = [3,6,9]
Ausgabe: 0

Einschränkungen:

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


Sie erhalten ein binäres Array nums.
Sie können die folgende Operation mit dem Array beliebig oft (möglicherweise null) durchführen:

Wählen Sie 3 beliebige aufeinanderfolgende Elemente aus dem Array aus und drehen Sie sie alle um.

Das Umdrehen eines Elements bedeutet, dass sein Wert von 0 auf 1 und von 1 auf 0 geändert wird.
Geben Sie die minimale Anzahl von Operationen zurück, die erforderlich sind, um alle Elemente in nums gleich 1 zu machen. Ist dies unmöglich, geben Sie -1 zurück.

Beispiel 1:

Eingabe: nums = [0,1,1,1,0,0]
Ausgabe: 3
Erläuterung:
Wir können die folgenden Operationen durchführen:

Wähle die Elemente bei den Indizes 0, 1 und 2. Die resultierende Anordnung ist nums = [1,0,0,1,0,0].
Wähle die Elemente bei den Indizes 1, 2 und 3. Die resultierende Anordnung ist nums = [1,1,1,0,0,0].
Wählen Sie die Elemente bei den Indizes 3, 4 und 5. Die resultierende Anordnung ist nums = [1,1,1,1,1,1,1].

Beispiel 2:

Eingabe: nums = [0,1,1,1]
Ausgabe: -1
Erläuterung:
Es ist unmöglich, alle Elemente gleich 1 zu machen.

Einschränkungen:

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

Sie erhalten ein binäres Array nums.
Sie können den folgenden Vorgang beliebig oft (möglicherweise null) für das Array ausführen:

Wählen Sie drei beliebige aufeinanderfolgende Elemente aus dem Array aus und drehen Sie sie alle um.

Das Umdrehen eines Elements bedeutet, seinen Wert von 0 auf 1 und von 1 auf 0 zu ändern.
Gibt die minimale Anzahl an Operationen zurück, die erforderlich sind, um alle Elemente in nums auf 1 zu bringen. Wenn dies nicht möglich ist, geben Sie -1 zurück.

Beispiel 1:

Eingabe: nums = [0,1,1,1,0,0]
Ausgabe: 3
Erläuterung:
Wir können die folgenden Operationen durchführen:

Wählen Sie die Elemente mit den Indizes 0, 1 und 2 aus. Das resultierende Array ist nums = [1,0,0,1,0,0].
Wählen Sie die Elemente mit den Indizes 1, 2 und 3 aus. Das resultierende Array ist nums = [1,1,1,0,0,0].
Wählen Sie die Elemente mit den Indizes 3, 4 und 5 aus. Das resultierende Array ist nums = [1,1,1,1,1,1].

Beispiel 2:

Eingabe: nums = [0,1,1,1]
Ausgabe: -1
Erläuterung:
Es ist unmöglich, alle Elemente gleich 1 zu machen.

Einschränkungen:

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