Sie erhalten ein 0-indiziertes Array von Ganzzahlen und ein Ziel.
Geben Sie die Länge der längsten Teilfolge von nums zurück, die die Summe des Ziels ergibt. Wenn keine solche Teilsequenz existiert, geben Sie -1 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,5], Ziel = 9
Ausgabe: 3
Erläuterung: Es gibt 3 Teilfolgen mit einer Summe von 9: [4,5], [1,3,5] und [2,3,4]. Die längsten Teilsequenzen sind [1,3,5] und [2,3,4]. Daher lautet die Antwort 3.

Beispiel 2:

Eingabe: Nums = [4,1,3,2,1,5], Ziel = 7
Ausgabe: 4
Erläuterung: Es gibt 5 Teilfolgen mit einer Summe von 7: [4,3], [4,1,2], [4,2,1], [1,1,5] und [1,3,2 ,1]. Die längste Teilsequenz ist [1,3,2,1]. Daher lautet die Antwort 4.

Beispiel 3:

Eingabe: Nums = [1,1,5,4,5], Ziel = 3
Ausgabe: -1
Erläuterung: Es kann gezeigt werden, dass nums keine Teilfolge mit der Summe 3 hat.

Einschränkungen:

1 <= nums.Länge <= 1000
1 <= nums[i] <= 1000
1 <= Ziel <= 1000

Sie erhalten ein 0-indiziertes Array von Ganzzahlen und ein Ganzzahlziel.
Gibt die Länge der längsten Teilfolge von Zahlen zurück, die in der Summe das Ziel ergibt. Wenn keine solche Teilsequenz existiert, geben Sie -1 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,5], target = 9
Ausgabe: 3
Erläuterung: Es gibt 3 Teilfolgen mit einer Summe von 9: [4,5], [1,3,5] und [2,3,4]. Die längsten Teilsequenzen sind [1,3,5] und [2,3,4]. Daher lautet die Antwort 3.

Beispiel 2:

Eingabe: nums = [4,1,3,2,1,5], target = 7
Ausgabe: 4
Erläuterung: Es gibt 5 Teilfolgen mit einer Summe von 7: [4,3], [4,1,2], [4,2,1], [1,1,5] und [1,3,2 ,1]. Die längste Teilsequenz ist [1,3,2,1]. Daher lautet die Antwort 4.

Beispiel 3:

Eingabe: nums = [1,1,5,4,5], target = 3
Ausgabe: -1
Erläuterung: Es kann gezeigt werden, dass nums keine Teilfolge hat, die in der Summe 3 ergibt.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array aus ganzen Zahlen, nums und einem ganzzahligen Ziel.
Gibt die Länge der längsten Teilsequenz von nums zurück, die sich zum Ziel summiert. Wenn keine solche Teilsequenz vorhanden ist, wird -1 zurückgegeben.
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,5], target = 9
Ausgang: 3
Erklärung: Es gibt 3 Teilsequenzen mit einer Summe gleich 9: [4,5], [1,3,5] und [2,3,4]. Die längsten Teilsequenzen sind [1,3,5] und [2,3,4]. Daher lautet die Antwort 3.

Beispiel 2:

Eingabe: nums = [4,1,3,2,1,5], target = 7
Ausgang: 4
Erklärung: Es gibt 5 Teilsequenzen mit einer Summe gleich 7: [4,3], [4,1,2], [4,2,1], [1,1,5] und [1,3,2,1]. Die längste Teilsequenz ist [1,3,2,1]. Die Antwort lautet also 4.

Beispiel 3:

Eingabe: nums = [1,1,5,4,5], target = 3
Ausgang: -1
Erklärung: Es kann gezeigt werden, dass Nums keine Teilsequenz hat, die sich zu 3 summiert.

Zwänge:

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


Sie erhalten ein 0-indiziertes Array maxHeights mit n ganzen Zahlen.
Sie haben die Aufgabe, n Türme entlang der Koordinatenlinie zu bauen. Der i^-te Turm ist an der Koordinate i gebaut und hat eine Höhe von heights[i].
Eine Turmkonfiguration ist schön, wenn die folgenden Bedingungen erfüllt sind:

1 <= heights[i] <= maxHeights[i]
Heights ist ein Gebirgsmassiv.

Array-Höhen sind ein Berg, wenn es einen Index i gibt, so dass:

Für alle 0 < j <= i, heights[j - 1] <= heights[j]
Für alle i <= k < n - 1, heights[k + 1] <= heights[k]

Geben Sie die maximal mögliche Höhensumme einer schönen Turmkonfiguration zurück.

Beispiel 1:

Eingabe: maxHeights = [5,3,4,1,1]
Ausgabe: 13
Erläuterung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [5,3,3,1,1]. Diese Konfiguration ist wunderschön, weil:
- 1 <= heights[i] <= maxHeights[i]
- Höhen ist ein Berg mit Gipfel i = 0.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Höhensumme von mehr als 13 gibt.
Beispiel 2:

Eingabe: maxHeights = [6,5,3,9,2,7]
Ausgabe: 22
Erläuterung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [3,3,3,9,2,2]. Diese Konfiguration ist wunderschön, weil:
- 1 <= heights[i] <= maxHeights[i]
- Höhen ist ein Berg mit Gipfel i = 3.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Höhensumme von mehr als 22 gibt.
Beispiel 3:

Eingabe: maxHeights = [3,2,5,5,2,3]
Ausgabe: 18
Erläuterung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [2,2,5,5,2,2]. Diese Konfiguration ist wunderschön, weil:
- 1 <= heights[i] <= maxHeights[i]
- Höhen ist ein Berg mit Gipfel i = 2.
Beachten Sie, dass i = 3 für diese Konfiguration auch als Peak betrachtet werden kann.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Höhensumme von mehr als 18 gibt.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array maxHeights von n ganzen Zahlen.
Sie haben die Aufgabe, n Türme in der Koordinatenlinie zu bauen. Der i^te Turm ist an der Koordinate i gebaut und hat eine Höhe von heights[i].
Eine Konfiguration von Türmen ist schön, wenn die folgenden Bedingungen zutreffen:

1 <= heights[i] <= maxHeights[i]
Heights ist ein Bergform.

Array heights ist ein Berg, wenn es einen Index i gibt, der:

Für alle 0 < j <= i, heights[j - 1] <= heights[j]
Für alle i <= k < n - 1, heights[k + 1] <= heights[k]

Gibt die maximal mögliche Summe der Höhen einer schönen Konfiguration von Türmen zurück.

Beispiel 1:

Eingabe: maxHeights = [5,3,4,1,1]
Ausgabe: 13
Erklärung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [5,3,3,1,1]. Diese Konfiguration ist aus folgenden Gründen schön:
- 1 <= heights[i] <= maxHeights[i]
- heights ist ein Berg mit dem Gipfel i = 0.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Summe von Höhen größer als 13 gibt.
Beispiel 2:

Eingabe: maxHeights = [6,5,3,9,2,7]
Ausgabe: 22
Erklärung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [3,3,3,9,2,2]. Diese Konfiguration ist aus folgenden Gründen schön:
- 1 <= heights[i] <= maxHeights[i]
- Heights ist ein Berg mit dem Gipfel i = 3.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Summe von Höhen größer als 22 gibt.
Beispiel 3:

Eingabe: maxHeights = [3,2,5,5,2,3]
Ausgabe: 18
Erklärung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [2,2,5,5,2,2]. Diese Konfiguration ist aus folgenden Gründen schön:
- 1 <= heights[i] <= maxHeights[i]
- Heights ist ein Berg mit dem Gipfel i = 2.
Beachten Sie, dass i = 3 für diese Konfiguration auch als Spitze betrachtet werden kann.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Summe von Höhen größer als 18 gibt.

Zwänge:

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

Sie erhalten ein 0-indiziertes Array maxHeights mit n Ganzzahlen.
Sie haben die Aufgabe, n Türme entlang der Koordinatenlinie zu bauen. Der i^-te Turm ist an der Koordinate i gebaut und hat eine Höhe von heights[i].
Eine Turmkonfiguration ist schön, wenn die folgenden Bedingungen erfüllt sind:

1 <= heights[i] <= maxHeights[i]
Heights ist ein Gebirgsmassiv.

Array-Höhen sind ein Berg, wenn es einen Index i gibt, so dass:

Für alle 0 < j <= i, heights[j - 1] <= heights[j]
Für alle i <= k < n - 1, heights[k + 1] <= heights[k]

Geben Sie die maximal mögliche Höhensumme einer schönen Turmkonfiguration zurück.

Beispiel 1:

Eingabe: maxHeights = [5,3,4,1,1]
Ausgabe: 13
Erläuterung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [5,3,3,1,1]. Diese Konfiguration ist wunderschön, weil:
- 1 <= heights[i] <= maxHeights[i]
- Höhen ist ein Berg mit Gipfel i = 0.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Höhensumme von mehr als 13 gibt.
Beispiel 2:

Eingabe: maxHeights = [6,5,3,9,2,7]
Ausgabe: 22
Erläuterung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [3,3,3,9,2,2]. Diese Konfiguration ist wunderschön, weil:
- 1 <= heights[i] <= maxHeights[i]
- Höhen ist ein Berg mit Gipfel i = 3.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Höhensumme von mehr als 22 gibt.
Beispiel 3:

Eingabe: maxHeights = [3,2,5,5,2,3]
Ausgabe: 18
Erläuterung: Eine schöne Konfiguration mit einer maximalen Summe ist heights = [2,2,5,5,2,2]. Diese Konfiguration ist wunderschön, weil:
- 1 <= heights[i] <= maxHeights[i]
- Höhen ist ein Berg mit Gipfel i = 2.
Beachten Sie, dass i = 3 für diese Konfiguration auch als Peak betrachtet werden kann.
Es kann gezeigt werden, dass es keine andere schöne Konfiguration mit einer Höhensumme von mehr als 18 gibt.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Array nums und ein ganzzahliges Ziel.
Ein 0-indiziertes Array infinite_nums wird generiert, indem die Elemente von nums unendlich an sich selbst angehängt werden.
Gibt die Länge des kürzesten Subarrays des Arrays infinite_nums mit einer Summe zurück, die dem Ziel entspricht. Wenn es kein solches Subarray gibt, gibt -1 zurück.

Beispiel 1:

Eingabe: nums = [1,2,3], target = 5
Ausgabe: 2
Erklärung: In diesem Beispiel infinite_nums = [1,2,3,1,2,3,1,2,...].
Das Subarray im Bereich [1,2] hat die Summe gleich Ziel = 5 und die Länge = 2.
Es kann bewiesen werden, dass 2 die kürzeste Länge eines Subarrays mit der Summe gleich Ziel = 5 ist.

Beispiel 2:

Eingabe: nums = [1,1,1,2,3], target = 4
Ausgabe: 2
Erklärung: In diesem Beispiel infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...].
Das Subarray im Bereich [4,5] hat die Summe gleich target = 4 und Länge = 2.
Es kann bewiesen werden, dass 2 die kürzeste Länge eines Subarrays mit der Summe gleich target = 4 ist.

Beispiel 3:

Eingabe: nums = [2,4,6,8], target = 3
Ausgabe: -1
Erklärung: In diesem Beispiel infinite_nums = [2,4,6,8,2,4,6,8,...].
Es kann bewiesen werden, dass es kein Subarray mit der Summe gleich target = 3 gibt.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums und ein ganzzahliges target .
Ein 0-indiziertes Array infinite_nums wird generiert, indem die Elemente von nums unendlich an sich selbst angehängt werden.
Gibt die length des kürzesten Subarrays des Arrays infinite_nums mit einer Summe zurück, die dem target entspricht. Wenn es kein solches Subarray gibt, gibt -1 zurück.

Beispiel 1:

Eingabe: nums = [1,2,3], target = 5
Ausgabe: 2
Erklärung: In diesem Beispiel infinite_nums = [1,2,3,1,2,3,1,2,...].
Das Subarray im Bereich [1,2] hat die Summe gleich target = 5 und die length = 2.
Es kann bewiesen werden, dass 2 die kürzeste length eines Subarrays mit der Summe gleich target = 5 ist.

Beispiel 2:

Eingabe: nums = [1,1,1,2,3], target = 4
Ausgabe: 2
Erklärung: In diesem Beispiel infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...].
Das Subarray im Bereich [4,5] hat die Summe gleich target = 4 und die length = 2.
Es kann bewiesen werden, dass 2 die kürzeste length eines Subarrays mit der Summe gleich target = 4 ist.

Beispiel 3:

Eingabe: nums = [2,4,6,8], target = 3
Ausgabe: -1
Erklärung: In diesem Beispiel infinite_nums = [2,4,6,8,2,4,6,8,...].
Es kann bewiesen werden, dass es kein Subarray mit der Summe gleich target = 3 gibt.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array „nums“ und ein ganzzahliges Ziel.
Ein 0-indiziertes Array „infinite_nums“ wird durch unendliches Anhängen der Elemente von „nums“ an sich selbst generiert.
Gibt die Länge des kürzesten Unterarrays des Arrays infinite_nums mit einer Summe gleich dem Ziel zurück. Wenn es kein solches Subarray gibt, geben Sie -1 zurück.

Beispiel 1:

Eingabe: Nums = [1,2,3], Ziel = 5
Ausgabe: 2
Erläuterung: In diesem Beispiel unendliche_nums = [1,2,3,1,2,3,1,2,...].
Das Subarray im Bereich [1,2] hat die Summe Ziel = 5 und Länge = 2.
Es kann bewiesen werden, dass 2 die kürzeste Länge eines Subarrays mit einer Summe von Ziel = 5 ist.

Beispiel 2:

Eingabe: Nums = [1,1,1,2,3], Ziel = 4
Ausgabe: 2
Erläuterung: In diesem Beispiel unendliche_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...].
Das Subarray im Bereich [4,5] hat die Summe Ziel = 4 und Länge = 2.
Es kann bewiesen werden, dass 2 die kürzeste Länge eines Subarrays mit einer Summe von Ziel = 4 ist.

Beispiel 3:

Eingabe: Nums = [2,4,6,8], Ziel = 3
Ausgabe: -1
Erläuterung: In diesem Beispiel unendliche_nums = [2,4,6,8,2,4,6,8,...].
Es kann bewiesen werden, dass es kein Subarray mit einer Summe von Ziel = 3 gibt.

Einschränkungen:

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


Sie erhalten eine binäre Zeichenfolge s und eine positive ganze Zahl k.
Ein Teilstring von s ist schön, wenn die Anzahl der Einsen darin genau k ist.
Sei len die Länge des kürzesten schönen Teilstrings.
Gibt den lexikografisch kleinsten schönen Teilstring von String s mit einer Länge gleich len zurück. Wenn s keinen schönen Teilstring enthält, wird ein leerer String zurückgegeben.
Eine Zeichenfolge a ist lexikographisch größer als eine Zeichenfolge b (gleicher Länge), wenn a an der ersten Position, an der sich a und b unterscheiden, ein Zeichen enthält, das strikt größer ist als das entsprechende Zeichen in b.

Beispielsweise ist „abcd“ lexikografisch größer als „abcc“, da die erste Position, an der sie sich unterscheiden, beim vierten Zeichen liegt und d größer als c ist.

Beispiel 1:

Eingabe: s = „100011001“, k = 3
Ausgabe: „11001“
Erläuterung: In diesem Beispiel gibt es 7 schöne Teilzeichenfolgen:
1. Der Teilstring „100011001“.
2. Der Teilstring „100011001“.
3. Der Teilstring „100011001“.
4. Der Teilstring „100011001“.
5. Der Teilstring „100011001“.
6. Der Teilstring „100011001“.
7. Der Teilstring „100011001“.
Die Länge des kürzesten schönen Teilstrings beträgt 5.
Der lexikografisch kleinste schöne Teilstring mit der Länge 5 ist der Teilstring „11001“.

Beispiel 2:

Eingabe: s = „1011“, k = 2
Ausgabe: „11“
Erläuterung: In diesem Beispiel gibt es drei schöne Teilzeichenfolgen:
1. Die Teilzeichenfolge „1011“.
2. Die Teilzeichenfolge „1011“.
3. Die Teilzeichenfolge „1011“.
Die Länge des kürzesten schönen Teilstrings beträgt 2.
Der lexikografisch kleinste schöne Teilstring mit der Länge 2 ist der Teilstring „11“.

Beispiel 3:

Eingabe: s = „000“, k = 1
Ausgabe: ""
Erläuterung: In diesem Beispiel gibt es keine schönen Teilzeichenfolgen.

Einschränkungen:

1 <= s.length <= 100
1 <= k <= s.länge


Sie haben n Prozessoren mit jeweils 4 Kernen und n * 4 Aufgaben, die ausgeführt werden müssen, sodass jeder Kern nur eine Aufgabe ausführen sollte.
Geben Sie anhand eines 0-indizierten Ganzzahl-Arrays „processorTime“, das die Zeit angibt, zu der jeder Prozessor zum ersten Mal verfügbar wird, und eines 0-indizierten Ganzzahl-Arrays „tasks“, das die Zeit darstellt, die zum Ausführen jeder Aufgabe benötigt wird, die Mindestzeit zurück, nach der alle Aufgaben ausgeführt wurden von den Auftragsverarbeitern ausgeführt.
Hinweis: Jeder Kern führt die Aufgabe unabhängig von den anderen aus.

Beispiel 1:

Eingabe: Prozessorzeit = [8,10], Aufgaben = [2,2,3,1,8,7,4,5]
Ausgabe: 16
Erläuterung:
Es ist optimal, die Aufgaben mit den Indizes 4, 5, 6, 7 dem ersten Prozessor zuzuweisen, der zum Zeitpunkt = 8 verfügbar wird, und die Aufgaben mit den Indizes 0, 1, 2, 3 dem zweiten Prozessor zuzuweisen, der zum Zeitpunkt = 10 verfügbar wird .
Zeit, die der erste Prozessor benötigt, um die Ausführung aller Aufgaben abzuschließen = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Zeit, die der zweite Prozessor benötigt, um die Ausführung aller Aufgaben abzuschließen = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Somit kann gezeigt werden, dass die Mindestzeit, die zur Ausführung aller Aufgaben benötigt wird, 16 beträgt.
Beispiel 2:

Eingabe: Prozessorzeit = [10,20], Aufgaben = [2,3,1,2,5,8,4,3]
Ausgabe: 23
Erläuterung:
Es ist optimal, die Aufgaben mit den Indizes 1, 4, 5, 6 dem ersten Prozessor zuzuweisen, der zum Zeitpunkt = 10 verfügbar wird, und die Aufgaben mit den Indizes 0, 2, 3, 7 dem zweiten Prozessor zuzuweisen, der zum Zeitpunkt = 20 verfügbar wird .
Zeit, die der erste Prozessor benötigt, um die Ausführung aller Aufgaben abzuschließen = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Zeit, die der zweite Prozessor benötigt, um die Ausführung aller Aufgaben abzuschließen = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Somit kann gezeigt werden, dass die Mindestzeit, die zur Ausführung aller Aufgaben benötigt wird, 23 beträgt.

Einschränkungen:

1 <= n ==processorTime.length <= 25000
1 <= Aufgaben.Länge <= 10^5
0 <= Prozessorzeit[i] <= 10^9
1 <= Aufgaben[i] <= 10^9
Aufgaben.Länge == 4 * n

Sie haben N -Prozessoren, die jeweils 4 Kerne und N * 4 Aufgaben haben, die so ausgeführt werden müssen, dass jeder Kern nur eine Aufgabe ausführen sollte.
Bei einer 0-indiziert Integer Array Processortime, die die Zeit darstellt, zu der jeder Prozessor zum ersten Mal verfügbar ist, und eine 0-inxzierte Ganzzahl-Array tasks, die die Zeit zur Ausführung jeder Aufgabe darstellt ausgeführt.
Hinweis: Jeder Kern führt die Aufgaben unabhängig von den anderen aus.

Beispiel 1:

Eingabe: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Ausgabe: 16
Erläuterung:
Es ist optimal, die Aufgaben mit den Indizes 4, 5, 6, 7 dem ersten Prozessor zuzuweisen, der zum Zeitpunkt = 8 verfügbar wird, und die Aufgaben mit den Indizes 0, 1, 2, 3 dem zweiten Prozessor, der zum Zeitpunkt = 10 verfügbar wird.
Die Zeit, die der erste Prozessor benötigt, um alle Aufgaben abzuschließen = max (8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
Die Zeit, die der zweite Prozessor benötigt, um die Ausführung aller Aufgaben zu beenden = max (10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
Daher kann gezeigt werden, dass die Mindestzeit für die Ausführung aller Aufgaben 16 beträgt.
Beispiel 2:

Eingabe: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Ausgabe: 23
Erläuterung:
Es ist optimal, die Aufgaben mit den Indizes 1, 4, 5, 6 dem ersten Prozessor zuzuweisen, der zur Zeit = 10 verfügbar wird, und die Aufgaben mit den Indizes 0, 2, 3, 7 dem zweiten Prozessor, der zur Zeit = 20 verfügbar wird.
Zeit, die der erste Prozessor benötigt, um die Ausführung aller Tasks zu beenden = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18.
Zeit, die der zweite Prozessor benötigt, um die Ausführung aller Tasks zu beenden = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23.
Daraus ergibt sich, dass die Mindestzeit für die Ausführung aller Aufgaben 23 beträgt.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes ganzzahliges Array nums und eine positive ganze Zahl k.
Sie können die folgende Operation mit dem Array beliebig oft durchführen:

Wählen Sie zwei beliebige Indizes i und j aus, und aktualisieren Sie gleichzeitig die Werte von nums[i] auf (nums[i] AND nums[j]) und nums[j] auf (nums[i] OR nums[j]). Hier bezeichnet OR die bitweise OR-Operation, und AND bezeichnet die bitweise AND-Operation.

Sie müssen k Elemente aus dem endgültigen Array auswählen und die Summe ihrer Quadrate berechnen.
Geben Sie die maximale Summe der Quadrate zurück, die Sie erreichen können.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: nums = [2,6,5,8], k = 2
Ausgabe: 261
Erläuterung: Wir können die folgenden Operationen mit dem Array durchführen:
- Wählen Sie i = 0 und j = 3, dann ändern Sie nums[0] in (2 AND 8) = 0 und nums[3] in (2 OR 8) = 10. Die resultierende Matrix ist nums = [0,6,5,10].
- Wählen Sie i = 2 und j = 3, dann ändern Sie nums[2] in (5 AND 10) = 0 und nums[3] in (5 OR 10) = 15. Die resultierende Anordnung ist nums = [0,6,0,15].
Wir können die Elemente 15 und 6 aus dem endgültigen Array auswählen. Die Summe der Quadrate ist 15^2 + 6^2 = 261.
Es kann gezeigt werden, dass dies der maximale Wert ist, den wir erhalten können.

Beispiel 2:

Eingabe: nums = [4,5,4,7], k = 3
Ausgabe: 90
Erläuterung: Wir brauchen keine Operationen anzuwenden.
Wir können die Elemente 7, 5 und 4 mit einer Summe von Quadraten wählen: 7^2 + 5^2 + 4^2 = 90.
Es kann gezeigt werden, dass dies der maximale Wert ist, den wir erhalten können.

Randbedingungen:

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

Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine positive Ganzzahl k.
Sie können den folgenden Vorgang beliebig oft für das Array ausführen:

Wählen Sie zwei beliebige unterschiedliche Indizes i und j und aktualisieren Sie gleichzeitig die Werte von nums[i] auf (nums[i] AND nums[j]) und nums[j] auf (nums[i] OR nums[j]). Hier bezeichnet OR die bitweise ODER-Verknüpfung und AND bezeichnet die bitweise UND-Verknüpfung.

Sie müssen k Elemente aus dem endgültigen Array auswählen und die Summe ihrer Quadrate berechnen.
Geben Sie die maximale Quadratsumme zurück, die Sie erreichen können.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: Zahlen = [2,6,5,8], k = 2
Ausgabe: 261
Erläuterung: Wir können die folgenden Operationen für das Array ausführen:
- Wählen Sie i = 0 und j = 3 und ändern Sie dann nums[0] in (2 AND 8) = 0 und nums[3] in (2 OR 8) = 10. Das resultierende Array ist nums = [0,6,5 ,10].
- Wählen Sie i = 2 und j = 3, ändern Sie dann nums[2] in (5 AND 10) = 0 und nums[3] in (5 OR 10) = 15. Das resultierende Array ist nums = [0,6,0 ,15].
Wir können die Elemente 15 und 6 aus dem endgültigen Array auswählen. Die Summe der Quadrate beträgt 15^2 + 6^2 = 261.
Es kann gezeigt werden, dass dies der maximale Wert ist, den wir erhalten können.

Beispiel 2:

Eingabe: Zahlen = [4,5,4,7], k = 3
Ausgabe: 90
Erläuterung: Wir müssen keine Operationen anwenden.
Wir können die Elemente 7, 5 und 4 mit einer Quadratsumme wählen: 7^2 + 5^2 + 4^2 = 90.
Es kann gezeigt werden, dass dies der maximale Wert ist, den wir erhalten können.

Einschränkungen:

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


Du erhältst ein 0-indiziertes ganzzahliges Array nums.
Gib den maximalen Wert aller Tripel von Indizes (i, j, k) zurück, so dass i < j < k. Wenn alle solchen Tripel einen negativen Wert haben, gib 0 zurück.
Der Wert eines Tripels von Indizes (i, j, k) ist gleich (nums[i] - nums[j]) * nums[k].

Beispiel 1:

Input: nums = [12,6,1,2,7]
Output: 77
Erläuterung: Der Wert des Tripels (0, 2, 4) ist (nums[0] - nums[2]) * nums[4] = 77.
Es kann gezeigt werden, dass es keine geordneten Tripel von Indizes mit einem Wert größer als 77 gibt.

Beispiel 2:

Input: nums = [1,10,3,4,19]
Output: 133
Erläuterung: Der Wert des Tripels (1, 2, 4) ist (nums[1] - nums[2]) * nums[4] = 133.
Es kann gezeigt werden, dass es keine geordneten Tripel von Indizes mit einem Wert größer als 133 gibt.

Beispiel 3:

Input: nums = [1,2,3]
Output: 0
Erläuterung: Das einzige geordnete Tripel von Indizes (0, 1, 2) hat einen negativen Wert von (nums[0] - nums[1]) * nums[2] = -3. Daher wäre die Antwort 0.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums.
Geben Sie den Maximalwert über alle Indextripel (i, j, k) zurück, sodass i < j < k. Wenn alle diese Tripel einen negativen Wert haben, wird 0 zurückgegeben.
Der Wert eines Tripletts von Indizes (i, j, k) ist gleich (nums[i] - nums[j]) * nums[k].

Beispiel 1:

Eingabe: nums = [12,6,1,2,7]
Ausgabe: 77
Erläuterung: Der Wert des Tripletts (0, 2, 4) ist (nums[0] - nums[2]) * nums[4] = 77.
Es kann gezeigt werden, dass es keine geordneten Indextripel mit einem Wert größer als 77 gibt.

Beispiel 2:

Eingabe: nums = [1,10,3,4,19]
Ausgabe: 133
Erläuterung: Der Wert des Tripletts (1, 2, 4) ist (nums[1] - nums[2]) * nums[4] = 133.
Es kann gezeigt werden, dass es keine geordneten Indextripel mit einem Wert größer als 133 gibt.

Beispiel 3:

Eingabe: nums = [1,2,3]
Ausgabe: 0
Erläuterung: Das einzige geordnete Triplett der Indizes (0, 1, 2) hat einen negativen Wert von (nums[0] - nums[1]) * nums[2] = -3. Daher wäre die Antwort 0.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes ganzzahliges Array nums.
Die eindeutige Anzahl eines Unterarrays von nums ist definiert als:

Sei nums[i.. j] ein Unterarray von nums, das aus allen Indizes von i bis j besteht, so dass 0 <= i <= j < nums.length ist. Dann ist die Anzahl der unterschiedlichen Werte in nums[i.. J] ist die eindeutige Anzahl von nums[i.. j].

Geben Sie die Summe der Quadrate der unterschiedlichen Zählungen aller Unterarrays von nums zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Sequenz von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,1]
Ausgabe: 15
Erklärung: Sechs mögliche Subarrays sind:
[1]: 1 eindeutiger Wert
[2]: 1 eindeutiger Wert
[1]: 1 eindeutiger Wert
[1,2]: 2 unterschiedliche Werte
[2,1]: 2 unterschiedliche Werte
[1,2,1]: 2 unterschiedliche Werte
Die Summe der Quadrate der unterschiedlichen Zählungen in allen Subarrays ist gleich 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Beispiel 2:

Eingabe: nums = [1,1]
Ausgabe: 3
Erklärung: Drei mögliche Subarrays sind:
[1]: 1 eindeutiger Wert
[1]: 1 eindeutiger Wert
[1,1]: 1 eindeutiger Wert
Die Summe der Quadrate der unterschiedlichen Zählungen in allen Subarrays ist gleich 1^2 + 1^2 + 1^2 = 3.

Zwänge:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums.
Die eindeutige Anzahl eines Subarrays von Nums ist definiert als:

Sei nums[i..j] ein Subarray von nums, das aus allen Indizes von i bis j besteht, so dass 0 <= i <= j < nums.length. Dann wird die Anzahl der unterschiedlichen Werte in nums[i..j] als eindeutige Anzahl von nums[i..j] bezeichnet.

Gibt die Summe der Quadrate der unterschiedlichen Zählungen aller Subarrays von Nums zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,1]
Ausgabe: 15
Erläuterung: Sechs mögliche Unterarrays sind:
[1]: 1 eindeutiger Wert
[2]: 1 eindeutiger Wert
[1]: 1 eindeutiger Wert
[1,2]: 2 unterschiedliche Werte
[2,1]: 2 unterschiedliche Werte
[1,2,1]: 2 unterschiedliche Werte
Die Summe der Quadrate der unterschiedlichen Zählungen in allen Subarrays ist gleich 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Beispiel 2:

Eingabe: nums = [1,1]
Ausgabe: 3
Erläuterung: Drei mögliche Unterarrays sind:
[1]: 1 eindeutiger Wert
[1]: 1 eindeutiger Wert
[1,1]: 1 eindeutiger Wert
Die Summe der Quadrate der unterschiedlichen Zählungen in allen Subarrays ist gleich 1^2 + 1^2 + 1^2 = 3.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums.
Die eindeutige Anzahl eines Subarrays von Nums ist definiert als:

Sei nums[i..j] ein Subarray von nums, das aus allen Indizes von i bis j besteht, sodass 0 <= i <= j < nums.length ist. Dann wird die Anzahl der unterschiedlichen Werte in nums[i..j] als eindeutige Anzahl von nums[i..j] bezeichnet.

Gibt die Summe der Quadrate der unterschiedlichen Zählungen aller Subarrays von Nums zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,1]
Ausgabe: 15
Erläuterung: Sechs mögliche Unterarrays sind:
[1]: 1 eindeutiger Wert
[2]: 1 eindeutiger Wert
[1]: 1 eindeutiger Wert
[1,2]: 2 unterschiedliche Werte
[2,1]: 2 unterschiedliche Werte
[1,2,1]: 2 unterschiedliche Werte
Die Summe der Quadrate der unterschiedlichen Zählungen in allen Subarrays ist gleich 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15.

Beispiel 2:

Eingabe: nums = [1,1]
Ausgabe: 3
Erläuterung: Drei mögliche Unterarrays sind:
[1]: 1 eindeutiger Wert
[1]: 1 eindeutiger Wert
[1,1]: 1 eindeutiger Wert
Die Summe der Quadrate der unterschiedlichen Zählungen in allen Subarrays ist gleich 1^2 + 1^2 + 1^2 = 3.

Einschränkungen:

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


Gegeben ein 0-indizierter Array von Strings words, wobei words[i] entweder eine positive ganze Zahl in Form eines Strings oder der String "prev" ist. Beginne mit der Iteration vom Anfang des Arrays; für jeden "prev"-String, der in words gesehen wird, finde die zuletzt besuchte ganze Zahl in words, wie folgt definiert:

Sei k die Anzahl der bisher gesehenen aufeinanderfolgenden "prev"-Strings (einschließlich des aktuellen Strings). Sei Nummer der 0-indizierte Array von bisher gesehenen ganzen Zahlen und sei nums_reverse die Umkehrung von nums, dann ist die ganze Zahl an der (k - 1)-ten Stelle von nums_reverse die zuletzt besuchte ganze Zahl für dieses "prev".
Wenn k größer ist als die insgesamt besuchten ganzen Zahlen, ist die zuletzt besuchte ganze Zahl -1.

Gib ein Integer-Array zurück, das die zuletzt besuchten ganzen Zahlen enthält.

Beispiel 1:

Eingabe: words = ["1","2","prev","prev","prev"]
Ausgabe: [2,1,-1]
Erläuterung:
Für "prev" an Index = 2 wird die zuletzt besuchte ganze Zahl 2 sein, da hier die Anzahl der aufeinanderfolgenden "prev"-Strings 1 ist und im Array reverse_nums 2 das erste Element ist.
Für "prev" an Index = 3 wird die zuletzt besuchte ganze Zahl 1 sein, da insgesamt zwei aufeinanderfolgende "prev"-Strings einschließlich dieses "prev" besucht wurden, und 1 die zweitletzte besuchte ganze Zahl ist.
Für "prev" an Index = 4 wird die zuletzt besuchte ganze Zahl -1 sein, da insgesamt drei aufeinanderfolgende "prev"-Strings einschließlich dieses "prev" besucht wurden, aber die Gesamtzahl der besuchten ganzen Zahlen zwei ist.

Beispiel 2:

Eingabe: words = ["1","prev","2","prev","prev"]
Ausgabe: [1,2,1]
Erläuterung:
Für "prev" an Index = 1 wird die zuletzt besuchte ganze Zahl 1 sein.
Für "prev" an Index = 3 wird die zuletzt besuchte ganze Zahl 2 sein.
Für "prev" an Index = 4 wird die zuletzt besuchte ganze Zahl 1 sein, da insgesamt zwei aufeinanderfolgende "prev" Strings einschließlich dieses "prev" besucht wurden, und 1 die zweitletzte besuchte ganze Zahl ist.

Einschränkungen:

1 <= words.length <= 100
words[i] == "prev" oder 1 <= int(words[i]) <= 100

Gegeben sei ein 0-indiziertes Array von Zeichenfolgenwörtern, wobei Wörter[i] entweder eine positive ganze Zahl ist, die als Zeichenfolge dargestellt wird, oder die Zeichenfolge „prev“.
Beginnen Sie mit der Iteration vom Anfang des Arrays. Für jede in Wörtern vorkommende „prev“-Zeichenfolge die zuletzt besuchte Ganzzahl in Wörtern, die wie folgt definiert ist:

Sei k die Anzahl der bisher gesehenen aufeinanderfolgenden „prev“ Zeichenfolgen (die die aktuelle Zeichenfolge enthalten). Sei nums das 0-indizierte Array der bisher gesehenen Ganzzahlen und nums_reverse die Umkehrung von nums, dann ist die Ganzzahl am (k - 1)^-ten Index von nums_reverse die zuletzt besuchte Ganzzahl für dieses „prev“.
Wenn k größer als die Gesamtzahl der besuchten Ganzzahlen ist, ist die zuletzt besuchte Ganzzahl -1.

Gibt ein Ganzzahl-Array zurück, das die zuletzt besuchten Ganzzahlen enthält.

Beispiel 1:

Eingabe: Wörter = ["1", "2", "prev", "prev", "prev"]
Ausgabe: [2,1,-1]
Erläuterung:
Für „prev“ bei Index = 2 ist die zuletzt besuchte Ganzzahl 2, da es der erste aufeinanderfolgende „prev“-String ist und 2 das erste Element in „reverse_nums“ ist.
Für „prev“ bei Index = 3 ist die zuletzt besuchte Ganzzahl 1, da es insgesamt zwei aufeinanderfolgende „prev“-Strings einschließlich dieser „prev“ gibt, die besucht werden, und 1 die vorletzte besuchte Ganzzahl ist.
Für „prev“ bei Index = 4 ist die zuletzt besuchte Ganzzahl -1, da insgesamt drei aufeinanderfolgende „prev“-Zeichenfolgen einschließlich dieser „prev“ besucht werden, die Gesamtzahl der besuchten Ganzzahlen jedoch zwei beträgt.

Beispiel 2:

Eingabe: Wörter = ["1", "prev", "2", "prev", "prev"]
Ausgabe: [1,2,1]
Erläuterung:
Für „prev“ bei Index = 1 ist die zuletzt besuchte Ganzzahl 1.
Für „prev“ bei Index = 3 ist die zuletzt besuchte Ganzzahl 2.
Für „prev“ bei Index = 4 ist die zuletzt besuchte Ganzzahl 1, da es insgesamt zwei aufeinanderfolgende „prev“-Strings einschließlich dieser „prev“ gibt, die besucht werden, und 1 die vorletzte besuchte Ganzzahl ist.

Einschränkungen:

1 <= Wörter.Länge <= 100
Wörter[i] == "prev" oder 1 <= int(Wörter[i]) <= 100

Gegeben sei ein Array mit 0-Index von Zeichenfolgen, in dem „words“ steht, wobei „words[i]“ entweder eine positive Ganzzahl ist, die als Zeichenfolge dargestellt wird, oder die Zeichenfolge „prev“.

Beginnen Sie mit der Iteration am Anfang des Arrays. Suchen Sie für jede in „words“ angezeigte Zeichenfolge „prev“ die zuletzt besuchte Ganzzahl in „words“, die wie folgt definiert ist:

K sei die Anzahl der bisher angezeigten aufeinanderfolgenden Zeichenfolgen „prev“ (die die aktuelle Zeichenfolge enthalten). Nums sei das Array mit 0-Index von bisher angezeigten Ganzzahlen und nums_reverse die Umkehrung von nums. Dann ist die Ganzzahl am (k - 1)^ten Index von nums_reverse die zuletzt besuchte Ganzzahl für diese Zeichenfolge „prev“.

Wenn k größer ist als die Gesamtzahl der besuchten Ganzzahlen, ist die zuletzt besuchte Ganzzahl -1.

Gibt ein Array mit Ganzzahlen zurück, das die zuletzt besuchten Ganzzahlen enthält.

Beispiel 1:

Eingabe: words = ["1","2","prev","prev","prev"]
Ausgabe: [2,1,-1]
Erklärung:
Für "prev" bei Index = 2 ist die zuletzt besuchte Ganzzahl 2, da hier die Anzahl der aufeinanderfolgenden "prev"-Zeichenfolgen 1 ist und im Array reverse_nums 2 das erste Element ist.

Für "prev" bei Index = 3 ist die zuletzt besuchte Ganzzahl 1, da insgesamt zwei aufeinanderfolgende "prev"-Zeichenfolgen einschließlich dieses "prev" besucht werden und 1 die vorletzte besuchte Ganzzahl ist.

Für "prev" bei Index = 4 ist die zuletzt besuchte Ganzzahl -1, da insgesamt drei aufeinanderfolgende "prev"-Zeichenfolgen einschließlich dieses "prev" besucht werden, die Gesamtzahl der besuchten Ganzzahlen jedoch zwei ist.

Beispiel 2:

Eingabe: words = ["1","prev","2","prev","prev"]
Ausgabe: [1,2,1]
Erklärung:
Für "prev" bei Index = 1 ist die zuletzt besuchte Ganzzahl 1.
Für "prev" bei Index = 3 ist die zuletzt besuchte Ganzzahl 2.
Für "prev" bei Index = 4 ist die zuletzt besuchte Ganzzahl 1, da insgesamt zwei aufeinanderfolgende "prev"-Zeichenfolgen einschließlich dieses "prev" besucht werden und 1 die vorletzte besuchte Ganzzahl ist.

Einschränkungen:

1 <= words.length <= 100
words[i] == "prev" or 1 <= int(words[i]) <= 100


Du hast ein 0-indexiertes Integer-Array namens nums der Länge n gegeben.
Wir möchten die Indizes gruppieren, sodass jedem Index i im Bereich [0, n - 1] genau eine Gruppe zugeordnet wird.
Eine Gruppenzuweisung ist gültig, wenn die folgenden Bedingungen erfüllt sind:

Für jede Gruppe g haben alle Indizes i, die der Gruppe g zugeordnet sind, denselben Wert in nums.
Für zwei beliebige Gruppen g_1 und g_2 darf der Unterschied zwischen der Anzahl der Indizes, die g_1 bzw. g_2 zugeordnet sind, 1 nicht überschreiten.

Gib eine ganze Zahl zurück, die die minimale Anzahl von Gruppen angibt, die benötigt werden, um eine gültige Gruppenzuweisung zu erstellen.

Beispiel 1:

Input: nums = [3,2,3,2,3]
Output: 2
Erläuterung: Eine Möglichkeit, wie die Indizes 2 Gruppen zugewiesen werden können, ist wie folgt, wobei die Werte in eckigen Klammern Indizes sind:
Gruppe 1 -> [0,2,4]
Gruppe 2 -> [1,3]
Alle Indizes sind einer Gruppe zugeordnet.
In Gruppe 1 gilt nums[0] == nums[2] == nums[4], sodass alle Indizes denselben Wert haben.
In Gruppe 2 gilt nums[1] == nums[3], sodass alle Indizes denselben Wert haben.
Die Anzahl der Indizes, die Gruppe 1 zugeordnet sind, ist 3, und die Anzahl der Indizes, die Gruppe 2 zugeordnet sind, ist 2.
Ihr Unterschied überschreitet nicht 1.
Es ist nicht möglich, weniger als 2 Gruppen zu verwenden, da in diesem Fall alle Indizes der Gruppe denselben Wert haben müssen.
Daher lautet die Antwort 2.
Beispiel 2:

Input: nums = [10,10,10,3,1,1]
Output: 4
Erläuterung: Eine Möglichkeit, wie die Indizes 4 Gruppen zugewiesen werden können, ist wie folgt, wobei die Werte in eckigen Klammern Indizes sind:
Gruppe 1 -> [0]
Gruppe 2 -> [1,2]
Gruppe 3 -> [3]
Gruppe 4 -> [4,5]
Die oben stehende Gruppenzuweisung erfüllt beide Bedingungen.
Es kann gezeigt werden, dass es nicht möglich ist, eine gültige Zuweisung mit weniger als 4 Gruppen zu erstellen.
Daher lautet die Antwort 4.

Beschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahlarray der Länge n.
Wir wollen die Indizes so gruppieren, dass jeder Index i im Bereich [0, n – 1] genau einer Gruppe zugeordnet wird.
Eine Gruppenzuordnung ist gültig, wenn folgende Bedingungen erfüllt sind:

Für jede Gruppe g haben alle der Gruppe g zugeordneten Indizes den gleichen Wert in Zahlen.
Für zwei beliebige Gruppen g_1 und g_2 sollte die Differenz zwischen der Anzahl der g_1 und g_2 zugewiesenen Indizes 1 nicht überschreiten.

Gibt eine Ganzzahl zurück, die die Mindestanzahl von Gruppen angibt, die zum Erstellen einer gültigen Gruppenzuweisung erforderlich sind.

Beispiel 1:

Eingabe: nums = [3,2,3,2,3]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, die Indizes zwei Gruppen zuzuordnen, ist wie folgt, wobei die Werte in eckigen Klammern Indizes sind:
Gruppe 1 -> [0,2,4]
Gruppe 2 -> [1,3]
Alle Indizes werden einer Gruppe zugeordnet.
In Gruppe 1 ist nums[0] == nums[2] == nums[4], sodass alle Indizes den gleichen Wert haben.
In Gruppe 2 gilt nums[1] == nums[3], sodass alle Indizes den gleichen Wert haben.
Die Anzahl der der Gruppe 1 zugewiesenen Indizes beträgt 3 und die Anzahl der der Gruppe 2 zugewiesenen Indizes beträgt 2.
Ihre Differenz überschreitet nicht 1.
Es ist nicht möglich, weniger als 2 Gruppen zu verwenden, da für die Verwendung nur einer Gruppe alle dieser Gruppe zugewiesenen Indizes denselben Wert haben müssen.
Daher lautet die Antwort 2.
Beispiel 2:

Eingabe: nums = [10,10,10,3,1,1]
Ausgabe: 4
Erläuterung: Eine Möglichkeit, die Indizes vier Gruppen zuzuordnen, ist wie folgt, wobei die Werte in eckigen Klammern Indizes sind:
Gruppe 1 -> [0]
Gruppe 2 -> [1,2]
Gruppe 3 -> [3]
Gruppe 4 -> [4,5]
Die obige Gruppenzuordnung erfüllt beide Bedingungen.
Es kann gezeigt werden, dass es nicht möglich ist, mit weniger als 4 Gruppen eine gültige Zuordnung zu erstellen.
Daher lautet die Antwort 4.

Einschränkungen:

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


Sie erhalten zwei Arrays nums1 und nums2, die aus positiven Ganzzahlen bestehen.
Sie müssen alle Nullen in beiden Arrays durch streng positive ganze Zahlen ersetzen, sodass die Summe der Elemente beider Arrays gleich wird.
Geben Sie die minimale gleiche Summe zurück, die Sie erhalten können, oder -1, wenn dies nicht möglich ist.

Beispiel 1:

Eingabe: Nums1 = [3,2,0,1,0], Nums2 = [6,5,0]
Ausgabe: 12
Erläuterung: Wir können Nullen auf folgende Weise ersetzen:
- Ersetzen Sie die beiden Nullen in nums1 durch die Werte 2 und 4. Das resultierende Array ist nums1 = [3,2,2,1,4].
- Ersetzen Sie die 0 in nums2 durch den Wert 1. Das resultierende Array ist nums2 = [6,5,1].
Beide Arrays haben eine gleiche Summe von 12. Es kann gezeigt werden, dass dies die minimale Summe ist, die wir erhalten können.

Beispiel 2:

Eingabe: Nums1 = [2,0,2,0], Nums2 = [1,4]
Ausgabe: -1
Erläuterung: Es ist unmöglich, die Summe beider Arrays gleich zu machen.

Einschränkungen:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

Sie erhalten zwei Arrays nums1 und nums2, die aus positiven ganzen Zahlen bestehen.
Sie müssen alle Nullen in beiden Arrays durch streng positive ganze Zahlen ersetzen, sodass die Summe der Elemente beider Arrays gleich wird.
Geben Sie die minimale gleiche Summe zurück, die Sie erhalten können, oder -1, wenn dies nicht möglich ist.

Beispiel 1:

Eingabe: Nums1 = [3,2,0,1,0], Nums2 = [6,5,0]
Ausgabe: 12
Erläuterung: Wir können Nullen auf folgende Weise ersetzen:
- Ersetzen Sie die beiden Nullen in nums1 durch die Werte 2 und 4. Das resultierende Array ist nums1 = [3,2,2,1,4].
- Ersetzen Sie die 0 in nums2 durch den Wert 1. Das resultierende Array ist nums2 = [6,5,1].
Beide Arrays haben eine gleiche Summe von 12. Es kann gezeigt werden, dass dies die minimale Summe ist, die wir erhalten können.

Beispiel 2:

Eingabe: Nums1 = [2,0,2,0], Nums2 = [1,4]
Ausgabe: -1
Erläuterung: Es ist unmöglich, die Summe beider Arrays gleich zu machen.

Einschränkungen:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

Sie erhalten zwei Felder nums1 und nums2, die aus positiven ganzen Zahlen bestehen.
Ersetzen Sie alle 0en in beiden Feldern durch streng positive ganze Zahlen, so dass die Summe der Elemente beider Felder gleich wird.
Geben Sie die minimale gleiche Summe zurück, die Sie erhalten können, oder -1, wenn dies unmöglich ist.

Beispiel 1:

Eingabe: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Ausgabe: 12
Erläuterung: Wir können 0's auf folgende Weise ersetzen:
- Ersetze die beiden 0en in nums1 durch die Werte 2 und 4. Das Ergebnis ist nums1 = [3,2,2,1,4].
- Ersetzen Sie die 0 in nums2 durch den Wert 1. Die resultierende Anordnung ist nums2 = [6,5,1].
Beide Arrays haben die gleiche Summe von 12. Es kann gezeigt werden, dass dies die kleinste Summe ist, die wir erhalten können.

Beispiel 2:

Eingabe: nums1 = [2,0,2,0], nums2 = [1,4]
Ausgabe: -1
Erläuterung: Es ist unmöglich, die Summe der beiden Arrays gleich zu machen.

Randbedingungen:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6


Sie erhalten positive ganze Zahlen n und m.
Definieren Sie zwei ganze Zahlen, num1 und num2, wie folgt:

num1: Die Summe aller ganzen Zahlen im Bereich [1, n], die nicht durch m teilbar sind.
num2: Die Summe aller ganzen Zahlen im Bereich [1, n], die durch m teilbar sind.

Gibt die ganze Zahl num1 - num2 zurück.

Beispiel 1:

Eingabe: n = 10, m = 3
Ausgabe: 19
Erklärung: Im gegebenen Beispiel:
- Ganzzahlen im Bereich [1, 10], die nicht durch 3 teilbar sind, sind [1,2,4,5,7,8,10], num1 ist die Summe dieser ganzen Zahlen = 37.
- Ganzzahlen im Bereich [1, 10], die durch 3 teilbar sind, sind [3,6,9], num2 ist die Summe dieser ganzen Zahlen = 18.
Wir geben 37 - 18 = 19 als Antwort zurück.

Beispiel 2:

Eingabe: n = 5, m = 6
Ausgabe: 15
Erklärung: Im gegebenen Beispiel:
- Ganzzahlen im Bereich [1, 5], die nicht durch 6 teilbar sind, sind [1,2,3,4,5], num1 ist die Summe dieser ganzen Zahlen = 15.
- Ganzzahlen im Bereich [1, 5], die durch 6 teilbar sind, sind [], num2 ist die Summe dieser ganzen Zahlen = 0.
Wir geben 15 - 0 = 15 als Antwort zurück.

Beispiel 3:

Eingabe: n = 5, m = 1
Ausgabe: -15
Erklärung: Im gegebenen Beispiel:
- Ganzzahlen im Bereich [1, 5], die nicht durch 1 teilbar sind, sind [], num1 ist die Summe dieser ganzen Zahlen = 0.
- Ganzzahlen im Bereich [1, 5], die durch 1 teilbar sind, sind [1,2,3,4,5], num2 ist die Summe dieser ganzen Zahlen = 15.
Wir geben 0 - 15 = -15 als Antwort zurück.

Einschränkungen:

1 <= n, m <= 1000

Sie erhalten positive ganze Zahlen n und m.
Definieren Sie zwei Ganzzahlen, num1 und num2, wie folgt:

num1: Die Summe aller ganzen Zahlen im Bereich [1, n], die nicht durch m teilbar sind.
num2: Die Summe aller ganzen Zahlen im Bereich [1, n], die durch m teilbar sind.

Gibt die ganze Zahl num1 - num2 zurück.

Beispiel 1:

Eingabe: n = 10, m = 3
Ausgabe: 19
Erläuterung: Im gegebenen Beispiel:
- Ganzzahlen im Bereich [1, 10], die nicht durch 3 teilbar sind, sind [1,2,4,5,7,8,10], num1 ist die Summe dieser Ganzzahlen = 37.
- Ganzzahlen im Bereich [1, 10], die durch 3 teilbar sind, sind [3,6,9], num2 ist die Summe dieser Ganzzahlen = 18.
Als Antwort geben wir 37 - 18 = 19 zurück.

Beispiel 2:

Eingabe: n = 5, m = 6
Ausgabe: 15
Erläuterung: Im gegebenen Beispiel:
- Ganzzahlen im Bereich [1, 5], die nicht durch 6 teilbar sind, sind [1,2,3,4,5], num1 ist die Summe dieser Ganzzahlen = 15.
- Ganzzahlen im Bereich [1, 5], die durch 6 teilbar sind, sind [], num2 ist die Summe dieser Ganzzahlen = 0.
Als Antwort geben wir 15 - 0 = 15 zurück.

Beispiel 3:

Eingabe: n = 5, m = 1
Ausgabe: -15
Erläuterung: Im gegebenen Beispiel:
- Ganzzahlen im Bereich [1, 5], die nicht durch 1 teilbar sind, sind [], num1 ist die Summe dieser Ganzzahlen = 0.
- Ganzzahlen im Bereich [1, 5], die durch 1 teilbar sind, sind [1,2,3,4,5], num2 ist die Summe dieser Ganzzahlen = 15.
Als Antwort geben wir 0 - 15 = -15 zurück.

Einschränkungen:

1 <= n, m <= 1000


Sie erhalten eine 0-indizierte Binärzeichenfolge s mit gerader Länge.
Eine Zeichenfolge ist schön, wenn sie in eine oder mehrere Teilzeichenfolgen unterteilt werden kann, sodass:

Jede Teilzeichenfolge eine gerade Länge hat.
Jede Teilzeichenfolge nur 1en oder nur 0en enthält.

Sie können jedes Zeichen in s in 0 oder 1 ändern.
Gibt die Mindestanzahl an Änderungen zurück, die erforderlich sind, um die Zeichenfolge s schön zu machen.

Beispiel 1:

Eingabe: s = "1001"
Ausgabe: 2
Erklärung: Wir ändern s[1] in 1 und s[3] in 0, um die Zeichenfolge "1100" zu erhalten.
Man kann sehen, dass die Zeichenfolge "1100" schön ist, weil wir sie in "11|00" unterteilen können.
Es lässt sich beweisen, dass 2 die Mindestanzahl an Änderungen ist, die erforderlich sind, um die Zeichenfolge schön zu machen.

Beispiel 2:

Eingabe: s = "10"
Ausgabe: 1
Erklärung: Wir ändern s[1] in 1, um die Zeichenfolge „11“ zu erhalten.
Man kann sehen, dass die Zeichenfolge "11" schön ist, weil wir sie in "11"aufteilen können.
Es lässt sich beweisen, dass 1 die Mindestanzahl an Änderungen ist, die erforderlich sind, um die Zeichenfolge schön zu machen.

Beispiel 3:

Eingabe: s = "0000"
Ausgabe: 0
Erklärung: Wir müssen keine Änderungen vornehmen, da die Zeichenfolge "0000" bereits schön ist.

Einschränkungen:

2 <= s.length <= 10^5
s hat eine gerade Länge.
s[i] is either '0' or '1'.

Sie erhalten eine 0-indizierte Binärzeichenkette s mit einer geraden Länge.
Eine Zeichenfolge ist schön, wenn es möglich ist, sie in eine oder mehrere Teilzeichenfolgen zu partitionieren, wie folgt:

Jede Teilzeichenfolge hat eine gerade Länge.
Jede Teilzeichenfolge enthält nur 1en oder nur 0en.

Sie können jedes Zeichen in s in 0 oder 1 ändern.
Gibt die minimale Anzahl von Änderungen zurück, die erforderlich sind, um die Zeichenkette s schön zu machen.

Beispiel 1:

Eingang: s = "1001"
Ausgang: 2
Erklärung: Wir ändern s[1] auf 1 und s[3] auf 0, um den String "1100" zu erhalten.
Es ist zu sehen, dass die Zeichenkette "1100" schön ist, weil wir sie in "11|00" unterteilen können.
Es kann nachgewiesen werden, dass 2 die minimale Anzahl von Änderungen ist, die erforderlich sind, um die Saite schön zu machen.

Beispiel 2:

Eingang: s = "10"
Ausgang: 1
Erklärung: Wir ändern s[1] in 1, um den String "11" zu erhalten.
Es ist zu sehen, dass die Zeichenkette "11" schön ist, weil wir sie in "11" unterteilen können.
Es kann nachgewiesen werden, dass 1 die minimale Anzahl von Änderungen ist, die erforderlich sind, um die Saite schön zu machen.

Beispiel 3:

Eingang: s = "0000"
Ausgang: 0
Erklärung: Wir müssen keine Änderungen vornehmen, da die Zeichenkette "0000" bereits schön ist.

Zwänge:

2 <= s.length <= 10^5
s hat eine gerade Länge.
s[i] ist entweder '0' oder '1'.

Sie erhalten eine 0-indizierte Binärzeichenfolge s mit gerader Länge.
Ein String ist schön, wenn es möglich ist, ihn in einen oder mehrere Teilstrings zu unterteilen, sodass:

Jeder Teilstring hat eine gerade Länge.
Jeder Teilstring enthält nur Einsen oder nur Nullen.

Sie können jedes Zeichen in s in 0 oder 1 ändern.
Gibt die Mindestanzahl an Änderungen zurück, die erforderlich sind, um die Zeichenfolge schön zu machen.

Beispiel 1:

Eingabe: s = „1001“
Ausgabe: 2
Erläuterung: Wir ändern s[1] auf 1 und s[3] auf 0, um die Zeichenfolge „1100“ zu erhalten.
Es ist ersichtlich, dass die Zeichenfolge „1100“ schön ist, weil wir sie in „11|00“ unterteilen können.
Es kann bewiesen werden, dass 2 die Mindestanzahl an Änderungen ist, die erforderlich sind, um die Zeichenfolge schön zu machen.

Beispiel 2:

Eingabe: s = „10“
Ausgabe: 1
Erläuterung: Wir ändern s[1] auf 1, um die Zeichenfolge „11“ zu erhalten.
Es ist ersichtlich, dass die Zeichenfolge „11“ schön ist, weil wir sie in „11“ unterteilen können.
Es kann bewiesen werden, dass 1 die Mindestanzahl an Änderungen ist, die erforderlich sind, um die Zeichenfolge schön zu machen.

Beispiel 3:

Eingabe: s = „0000“
Ausgabe: 0
Erläuterung: Wir müssen keine Änderungen vornehmen, da die Zeichenfolge „0000“ bereits schön ist.

Einschränkungen:

2 <= s.length <= 10^5
s hat eine gleichmäßige Länge.
s[i] ist entweder '0' oder '1'.


Sie erhalten ein 0-indiziertes Array mit ganzen nums.
Ein Triplett der Indizes (i, j, k) ist ein Berg, wenn:

i < j < k
nums[i] < nums[j] und nums[k] < nums[j]

Gibt die kleinstmögliche Summe eines Bergtripletts von nums zurück. Wenn kein solches Triplett existiert, geben Sie -1 zurück.

Beispiel 1:

Eingabe: nums = [8,6,1,5,3]
Ausgabe: 9
Erläuterung: Triplett (2, 3, 4) ist ein Bergtriplett mit der Summe 9, da:
- 2 < 3 < 4
- nums[2] < nums[3] und nums[4] < nums[3]
Und die Summe dieses Tripletts ist nums[2] + nums[3] + nums[4] = 9. Es kann gezeigt werden, dass es keine Bergtripel mit einer Summe von weniger als 9 gibt.

Beispiel 2:

Eingabe: nums = [5,4,8,7,10,2]
Ausgabe: 13
Erläuterung: Triplett (1, 3, 5) ist ein Bergtriplett der Summe 13, da:
- 1 < 3 < 5
- nums[1] < nums[3] und nums[5] < nums[3]
Und die Summe dieses Tripletts ist nums[1] + nums[3] + nums[5] = 13. Es kann gezeigt werden, dass es keine Bergtripel mit einer Summe von weniger als 13 gibt.

Beispiel 3:

Eingabe: nums = [6,5,4,3,4,5]
Ausgabe: -1
Erläuterung: Es kann gezeigt werden, dass es in Nums keine Bergtripel gibt.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array mit einer Anzahl von Ganzzahlen.
Ein Triplett der Indizes (i, j, k) ist ein Berg, wenn:

i < j < k
nums[i] < nums[j] und nums[k] < nums[j]

Gibt die kleinstmögliche Summe eines Bergtripletts von Zahlen zurück. Wenn kein solches Triplett existiert, geben Sie -1 zurück.

Beispiel 1:

Eingabe: nums = [8,6,1,5,3]
Ausgabe: 9
Erläuterung: Triplett (2, 3, 4) ist ein Bergtriplett der Summe 9, da:
- 2 < 3 < 4
- nums[2] < nums[3] and nums[4] < nums[3]
Und die Summe dieses Tripletts ist nums[2] + nums[3] + nums[4] = 9. Es kann gezeigt werden, dass es keine Bergtripel mit einer Summe von weniger als 9 gibt.

Beispiel 2:

Eingabe: nums = [5,4,8,7,10,2]
Ausgabe: 13
Erläuterung: Triplett (1, 3, 5) ist ein Bergtriplett der Summe 13, da:
- 1 < 3 < 5
- nums[1] < nums[3] and nums[5] < nums[3]
Und die Summe dieses Tripletts ist nums[1] + nums[3] + nums[5] = 13. Es kann gezeigt werden, dass es keine Bergtripel mit einer Summe von weniger als 13 gibt.

Beispiel 3:

Eingabe: nums = [6,5,4,3,4,5]
Ausgabe: -1
Erläuterung: Es kann gezeigt werden, dass es in Nums keine Bergtripel gibt.

Einschränkungen:

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

Sie erhalten ein Array nums mit 0 Indizes aus ganzen Zahlen.
Ein Triplett von Indizes (i, j, k) ist ein Berg, wenn:

i < j < k
nums[i] < nums[j] und nums[k] < nums[j]

Gibt die kleinstmögliche Summe eines Berg-Tripels von nums zurück. Wenn kein solches Triplett existiert, wird -1 zurückgegeben.

Beispiel 1:

Eingabe: nums = [8,6,1,5,3]
Ausgabe: 9
Erläuterung: Das Triplett (2, 3, 4) ist ein Bergtriplett der Summe 9, da:
- 2 < 3 < 4
- nums[2] < nums[3] und nums[4] < nums[3]
Und die Summe dieses Tripletts ist nums[2] + nums[3] + nums[4] = 9. Es kann gezeigt werden, dass es keine Bergtriolen mit einer Summe von weniger als 9 gibt.

Beispiel 2:

Eingabe: nums = [5,4,8,7,10,2]
Ausgabe: 13
Erläuterung: Das Triplett (1, 3, 5) ist ein Bergtriplett der Summe 13, da:
- 1 < 3 < 5
- nums[1] < nums[3] und nums[5] < nums[3]
Und die Summe dieses Tripletts ist nums[1] + nums[3] + nums[5] = 13. Es kann gezeigt werden, dass es keine Bergtriolen mit einer Summe von weniger als 13 gibt.

Beispiel 3:

Eingabe: nums = [6,5,4,3,4,5]
Ausgabe: -1
Erläuterung: Es kann gezeigt werden, dass es keine Bergtriolen in nums gibt.

Randbedingungen:

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


Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine Ganzzahl k.
Das K-or von nums ist eine nicht negative ganze Zahl, die Folgendes erfüllt:

Das i^-te Bit wird im K-Oder genau dann gesetzt, wenn es mindestens k Elemente von Nums gibt, in denen das Bit i gesetzt ist.

Gibt das K-oder von Nums zurück.
Beachten Sie, dass ein Bit i in x gesetzt wird, wenn (2^i AND x) == 2^i, wobei AND der bitweise UND-Operator ist.

Beispiel 1:

Eingabe: nums = [7,12,9,8,9,15], k = 4
Ausgabe: 9
Erläuterung: Bit 0 ist bei nums[0], nums[2], nums[4] und nums[5] gesetzt.
Bit 1 ist auf nums[0] und nums[5] gesetzt.
Bit 2 ist auf nums[0], nums[1] und nums[5] gesetzt.
Bit 3 ist auf nums[1], nums[2], nums[3], nums[4] und nums[5] gesetzt.
In mindestens k Elementen des Arrays sind nur die Bits 0 und 3 gesetzt, und in keinem der Elemente des Arrays sind die Bits i >= 4 gesetzt. Daher lautet die Antwort 2^0 + 2^3 = 9.

Beispiel 2:

Eingabe: nums = [2,12,1,11,4,5], k = 6
Ausgabe: 0
Erläuterung: Da k == 6 == nums.length, ist das 6-ODER des Arrays gleich dem bitweisen UND aller seiner Elemente. Daher lautet die Antwort 2 UND 12 UND 1 UND 11 UND 4 UND 5 = 0.

Beispiel 3:

Eingabe: nums = [10,8,5,9,11,6,8], k = 1
Ausgabe: 15
Erläuterung: Da k == 1 ist, ist das 1-Oder des Arrays gleich dem bitweisen ODER aller seiner Elemente. Daher lautet die Antwort 10 ODER 8 ODER 5 ODER 9 ODER 11 ODER 6 ODER 8 = 15.

Einschränkungen:

1 <= nums.Länge <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.Länge

Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine Ganzzahl k.
Das K-or von nums ist eine nicht negative ganze Zahl, die Folgendes erfüllt:

Das i^-te Bit wird im K-Oder genau dann gesetzt, wenn es mindestens k Elemente von Nums gibt, in denen das Bit i gesetzt ist.

Gibt das K-oder von Nums zurück.
Beachten Sie, dass ein Bit i in x gesetzt ist, wenn (2^i AND x) == 2^i, wobei AND der bitweise AND-Operator ist.

Beispiel 1:

Eingabe: nums = [7,12,9,8,9,15], k = 4
Ausgabe: 9
Erläuterung: Bit 0 ist bei nums[0], nums[2], nums[4] und nums[5] gesetzt.
Bit 1 ist auf nums[0] und nums[5] gesetzt.
Bit 2 ist auf nums[0], nums[1] und nums[5] gesetzt.
Bit 3 ist auf nums[1], nums[2], nums[3], nums[4] und nums[5] gesetzt.
In mindestens k Elementen des Arrays sind nur die Bits 0 und 3 gesetzt, und in keinem der Elemente des Arrays sind die Bits i >= 4 gesetzt. Daher lautet die Antwort 2^0 + 2^3 = 9.

Beispiel 2:

Eingabe: nums = [2,12,1,11,4,5], k = 6
Ausgabe: 0
Erläuterung: Da k == 6 == nums.length, ist das 6-OR des Arrays gleich dem bitweisen AND aller seiner Elemente. Daher lautet die Antwort 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0.

Beispiel 3:

Eingabe: nums = [10,8,5,9,11,6,8], k = 1
Ausgabe: 15
Erläuterung: Da k == 1 ist, ist das 1-OR des Arrays gleich dem bitweisen OR aller seiner Elemente. Daher lautet die Antwort 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15.

Einschränkungen:

1 <= Anzahl.Länge <= 50
0 <= nums[i] < 2^31
1 <= k <= Anzahl.Länge

Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine Ganzzahl k.
Das K-or von nums ist eine nicht negative ganze Zahl, die Folgendes erfüllt:

Das i^-te Bit wird im K-Oder genau dann gesetzt, wenn es mindestens k Elemente von Nums gibt, in denen das Bit i gesetzt ist.

Gibt das K-oder von Nums zurück.
Beachten Sie, dass ein Bit i in x gesetzt ist, wenn (2^i AND x) == 2^i, wobei AND der bitweise UND-Operator bezeichnet.

Beispiel 1:

Eingabe: nums = [7,12,9,8,9,15], k = 4
Ausgabe: 9
Erläuterung: Bit 0 ist bei nums[0], nums[2], nums[4] und nums[5] gesetzt.
Bit 1 ist auf nums[0] und nums[5] gesetzt.
Bit 2 ist auf nums[0], nums[1] und nums[5] gesetzt.
Bit 3 ist auf nums[1], nums[2], nums[3], nums[4] und nums[5] gesetzt.
In mindestens k Elementen des Arrays sind nur die Bits 0 und 3 gesetzt, und in keinem der Elemente des Arrays sind die Bits i >= 4 gesetzt. Daher lautet die Antwort 2^0 + 2^3 = 9.

Beispiel 2:

Eingabe: nums = [2,12,1,11,4,5], k = 6
Ausgabe: 0
Erläuterung: Da k == 6 == nums.length, ist das 6-bitwise AND des Arrays gleich dem bitweisen AND aller seiner Elemente. Daher lautet die Antwort 2 OR 12 OR 1 OR 11 OR 4 OR 5 = 0.

Beispiel 3:

Eingabe: nums = [10,8,5,9,11,6,8], k = 1
Ausgabe: 15
Erläuterung: Da k == 1 ist, ist das 1-Oder des Arrays gleich dem bitweisen OR aller seiner Elemente. Daher lautet die Antwort 10 AND 8 AND 5 AND 9 AND 11 AND 6 AND 8 = 15.

Einschränkungen:

1 <= nums.Länge <= 50
0 <= nums[i] < 2^31
1 <= k <= nums.Länge


Sie erhalten ein 0-indiziertes Ganzzahl-Array nums.
Eine Teilfolge von Zahlen mit der Länge k und bestehend aus den Indizes i_0 < i_1 < ... < i_k-1 ist ausgeglichen, wenn Folgendes gilt:

nums[i_j] - nums[i_j-1] >= i_j - i_j-1, für jedes j im Bereich [1, k - 1].

Eine Teilfolge von Zahlen mit der Länge 1 gilt als ausgeglichen.
Gibt eine Ganzzahl zurück, die die maximal mögliche Summe von Elementen in einer ausgeglichenen Teilfolge von Zahlen angibt.
Eine Teilsequenz eines Arrays ist ein neues, nicht leeres Array, das aus dem ursprünglichen Array gebildet wird, indem einige (möglicherweise keine) Elemente gelöscht werden, ohne die relativen Positionen der verbleibenden Elemente zu beeinträchtigen.

Beispiel 1:

Eingabe: nums = [3,3,5,6]
Ausgabe: 14
Erläuterung: In diesem Beispiel kann die Teilsequenz [3,5,6] bestehend aus den Indizes 0, 2 und 3 ausgewählt werden.
Zahlen[2] - Zahlen[0] >= 2 - 0.
Zahlen[3] - Zahlen[2] >= 3 - 2.
Daher handelt es sich um eine ausgeglichene Teilfolge, und ihre Summe ist das Maximum unter den ausgeglichenen Teilfolgen von Zahlen.
Die Teilfolge bestehend aus den Indizes 1, 2 und 3 ist ebenfalls gültig.
Es kann gezeigt werden, dass es nicht möglich ist, eine ausgeglichene Teilfolge mit einer Summe größer als 14 zu erhalten.
Beispiel 2:

Eingabe: nums = [5,-1,-3,8]
Ausgabe: 13
Erläuterung: In diesem Beispiel kann die Teilsequenz [5,8] bestehend aus den Indizes 0 und 3 ausgewählt werden.
Zahlen[3] - Zahlen[0] >= 3 - 0.
Daher handelt es sich um eine ausgeglichene Teilfolge, und ihre Summe ist das Maximum unter den ausgeglichenen Teilfolgen von Zahlen.
Es kann gezeigt werden, dass es nicht möglich ist, eine ausgeglichene Teilfolge mit einer Summe größer als 13 zu erhalten.

Beispiel 3:

Eingabe: nums = [-2,-1]
Ausgabe: -1
Erläuterung: In diesem Beispiel kann die Teilsequenz [-1] ausgewählt werden.
Es handelt sich um eine ausgeglichene Teilfolge, und ihre Summe ist das Maximum unter den ausgeglichenen Teilfolgen von Zahlen.

Einschränkungen:

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

Sie erhalten eine 0-indiziert Integer Array nums.
Eine Teilfolge von nums mit Länge k und bestehend aus den Indizes i_0 <i_1 <... <i_k-1 ist ausgeglichen, wenn das Folgende gilt:

nums[i_j] - nums[i_j - 1] >= i_j - i_j-1, für jeden j im Bereich [1, k - 1].

Eine Teilsequenz von nums mit der Länge 1 gilt als ausgeglichen.
Gibt eine ganze Zahl zurück, die die maximal mögliche Summe von Elementen in einer ausgeglichenen Teilsequenz von Zahlen angibt.
Eine Teilsequenz eines Arrays ist ein neues, nicht leeres Array, das aus dem ursprünglichen Array gebildet wird, indem einige (möglicherweise keine) der Elemente gelöscht werden, ohne die relativen Positionen der verbleibenden Elemente zu stören.

Beispiel 1:

Eingabe: nums = [3,3,5,6]
Ausgabe: 14
Erklärung: In diesem Beispiel kann die Teilsequenz [3,5,6] bestehend aus den Indizes 0, 2 und 3 ausgewählt werden.
nums[2] - nums[0] >= 2 - 0.
nums[3] - nums[2] >= 3 - 2.
Daher ist es eine ausgeglichene Teilsequenz, und ihre Summe ist das Maximum unter den ausgeglichenen Teilsequenzen von nums.
Die Teilsequenz bestehend aus den Indizes 1, 2 und 3 ist ebenfalls gültig.
Es kann gezeigt werden, dass es nicht möglich ist, eine ausgeglichene Teilsequenz mit einer Summe größer als 14 zu erhalten.
Beispiel 2:

Eingabe: nums = [5,-1,-3,8]
Ausgabe: 13
Erklärung: In diesem Beispiel kann die Teilsequenz [5,8] bestehend aus den Indizes 0 und 3 ausgewählt werden.
nums[3] - nums[0] >= 3 - 0.
Daher ist es eine ausgeglichene Teilsequenz, und ihre Summe ist das Maximum unter den ausgeglichenen Teilsequenzen von nums.
Es kann gezeigt werden, dass es nicht möglich ist, eine ausgeglichene Teilsequenz mit einer Summe größer als 13 zu erhalten.

Beispiel 3:

Eingabe: nums = [-2,-1]
Ausgabe: -1
Erklärung: In diesem Beispiel kann die Teilsequenz [-1] ausgewählt werden.
Es handelt sich um eine ausgeglichene Teilsequenz, und ihre Summe ist das Maximum unter den ausgeglichenen Teilsequenzen von nums.

Einschränkungen:

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


In einem Turnier gibt es n Teams, nummeriert von 0 bis n - 1.
Gegeben sei ein 0-indiziertes 2D-Boolesches Matrixraster der Größe n * n. Für alle i, j mit 0 <= i, j <= n - 1 und i != j ist Team i stärker als Team j, wenn grid[i][j] == 1, andernfalls ist Team j stärker als Team i.
Team a wird Turniersieger, wenn es kein Team b gibt, das stärker ist als Team a.
Gibt das Team zurück, das Turniersieger wird.

Beispiel 1:

Eingabe: grid = [[0,1],[0,0]]
Ausgabe: 0
Erklärung: In diesem Turnier gibt es zwei Teams.
grid[0][1] == 1 bedeutet, dass Team 0 stärker ist als Team 1. Also wird Team 0 der Champion.

Beispiel 2:

Eingabe: grid = [[0,0,1],[1,0,1],[0,0,0]]
Ausgabe: 1
Erklärung: Es gibt drei Teams in diesem Turnier.
grid[1][0] == 1 bedeutet, dass Team 1 stärker ist als Team 0.
grid[1][2] == 1 bedeutet, dass Team 1 stärker ist als Team 2.
Team 1 wird also der Champion.

Einschränkungen:

n == grid.length
n == grid[i].length
2 <= n <= 100
grid[i][j] ist entweder 0 oder 1.
Für alle i ist grid[i][i] 0.
Für alle i, j, bei denen i != j ist, ist grid[i][j] != grid[j][i].
Die Eingabe wird so generiert, dass, wenn Team A stärker ist als Team B und Team B stärker ist als Team C, dann ist Team A stärker als Team C.

In einem Turnier gibt es n Teams mit den Nummern 0 bis n - 1.
Gegeben sei ein 0-indiziertes 2D-Boolesches Matrixgitter der Größe n * n. Für alle i, j mit 0 <= i, j <= n - 1 und i != j ist Team i stärker als Team j, wenn Grid[i][j] == 1, andernfalls ist Team j stärker als Team i .
Team A wird der Champion des Turniers, wenn es kein Team B gibt, das stärker ist als Team A.
Geben Sie das Team zurück, das der Champion des Turniers sein wird.

Beispiel 1:

Eingabe: Gitter = [[0,1],[0,0]]
Ausgabe: 0
Erläuterung: Es gibt zwei Mannschaften in diesem Turnier.
Grid[0][1] == 1 bedeutet, dass Team 0 stärker ist als Team 1. Team 0 wird also der Champion sein.

Beispiel 2:

Eingabe: Gitter = [[0,0,1],[1,0,1],[0,0,0]]
Ausgabe: 1
Erläuterung: An diesem Turnier nehmen drei Mannschaften teil.
Grid[1][0] == 1 bedeutet, dass Team 1 stärker ist als Team 0.
Grid[1][2] == 1 bedeutet, dass Team 1 stärker ist als Team 2.
Team 1 wird also der Champion sein.

Einschränkungen:

n == Gitterlänge
n == Gitter[i].Länge
2 <= n <= 100
Grid[i][j] ist entweder 0 oder 1.
Für alle i ist Grid[i][i] 0.
Für alle i, j, die i != j, Grid[i][j] != Grid[j][i].
Die Eingabe wird so generiert, dass, wenn Team a stärker ist als Team b und Team b stärker ist als Team c, dann Team a stärker ist als Team c.


Sie erhalten zwei 0-indizierte ganzzahlige Arrays, nums1 und nums2, die beide die Länge n haben.
Sie dürfen eine Reihe von Vorgängen ausführen (möglicherweise keine).
In einer Operation wählen Sie einen Index i im Bereich [0, n - 1] aus und vertauschen die Werte von nums1[i] und nums2[i].
Ihre Aufgabe besteht darin, die Mindestanzahl von Vorgängen zu ermitteln, die erforderlich sind, um die folgenden Bedingungen zu erfüllen:

nums1[n - 1] ist gleich dem Maximalwert unter allen Elementen von nums1, d.h. nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]).
nums2[n - 1] ist gleich dem Maximalwert unter allen Elementen von nums2, d.h. nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]).

Gibt eine ganze Zahl zurück, die die Mindestanzahl von Vorgängen angibt, die erforderlich sind, um beide Bedingungen zu erfüllen, oder -1, wenn es unmöglich ist, beide Bedingungen zu erfüllen.

Beispiel 1:

Eingabe: nums1 = [1,2,7], nums2 = [4,5,3]
Ausgang: 1
Erläuterung: In diesem Beispiel kann eine Operation mit dem Index i = 2 ausgeführt werden.
Wenn nums1[2] und nums2[2] vertauscht werden, wird nums1 zu [1,2,3] und nums2 zu [4,5,7].
Beide Bedingungen sind nun erfüllt.
Es kann gezeigt werden, dass die Mindestanzahl der auszuführenden Operationen 1 beträgt.
Die Antwort lautet also 1.

Beispiel 2:

Eingabe: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Ausgang: 2
Erläuterung: In diesem Beispiel können die folgenden Vorgänge ausgeführt werden:
Erste Operation mit dem Index i = 4.
Wenn nums1[4] und nums2[4] vertauscht werden, wird nums1 zu [2,3,4,5,4] und nums2 zu [8,8,4,4,9].
Eine weitere Operation mit dem Index i = 3.
Wenn nums1[3] und nums2[3] vertauscht werden, wird nums1 zu [2,3,4,4,4] und nums2 zu [8,8,4,5,9].
Beide Bedingungen sind nun erfüllt.
Es kann gezeigt werden, dass die Mindestanzahl der auszuführenden Operationen 2 beträgt.
Die Antwort lautet also 2.

Beispiel 3:

Eingabe: nums1 = [1,5,4], nums2 = [2,5,3]
Ausgang: -1
Erläuterung: In diesem Beispiel ist es nicht möglich, beide Bedingungen zu erfüllen.
Die Antwort lautet also -1.

Zwänge:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9

Sie erhalten zwei 0-indizierte Ganzzahl-Arrays, nums1 und nums2, beide mit der Länge n.
Sie dürfen eine Reihe von Vorgängen ausführen (möglicherweise keine).
In einer Operation wählen Sie einen Index i im Bereich [0, n – 1] aus und tauschen die Werte von nums1[i] und nums2[i] aus.
Ihre Aufgabe besteht darin, die Mindestanzahl an Operationen zu ermitteln, die erforderlich sind, um die folgenden Bedingungen zu erfüllen:

nums1[n - 1] ist gleich dem Maximalwert aller Elemente von nums1, d. h. nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]) .
nums2[n - 1] ist gleich dem Maximalwert aller Elemente von nums2, d. h. nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]) .

Geben Sie eine Ganzzahl zurück, die die Mindestanzahl an Operationen angibt, die erforderlich sind, um beide Bedingungen zu erfüllen, oder -1, wenn es unmöglich ist, beide Bedingungen zu erfüllen.

Beispiel 1:

Eingabe: Nums1 = [1,2,7], Nums2 = [4,5,3]
Ausgabe: 1
Erläuterung: In diesem Beispiel kann eine Operation mit Index i = 2 ausgeführt werden.
Wenn Nums1[2] und Nums2[2] vertauscht werden, wird Nums1 zu [1,2,3] und Nums2 zu [4,5,7].
Beide Bedingungen sind nun erfüllt.
Es kann gezeigt werden, dass die Mindestanzahl der auszuführenden Operationen 1 beträgt.
Die Antwort ist also 1.

Beispiel 2:

Eingabe: Nums1 = [2,3,4,5,9], Nums2 = [8,8,4,4,4]
Ausgabe: 2
Erläuterung: In diesem Beispiel können die folgenden Operationen ausgeführt werden:
Erste Operation mit Index i = 4.
Wenn Nums1[4] und Nums2[4] vertauscht werden, wird Nums1 zu [2,3,4,5,4] und Nums2 zu [8,8,4,4,9].
Eine weitere Operation mit Index i = 3.
Wenn Nums1[3] und Nums2[3] vertauscht werden, wird Nums1 zu [2,3,4,4,4] und Nums2 zu [8,8,4,5,9].
Beide Bedingungen sind nun erfüllt.
Es kann gezeigt werden, dass die Mindestanzahl der auszuführenden Operationen 2 beträgt.
Die Antwort ist also 2.

Beispiel 3:

Eingabe: Nums1 = [1,5,4], Nums2 = [2,5,3]
Ausgabe: -1
Erläuterung: In diesem Beispiel ist es nicht möglich, beide Bedingungen zu erfüllen.
Die Antwort lautet also -1.

Einschränkungen:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9

Sie erhalten zwei 0-indizierte Ganzzahl-Arrays, nums1 und nums2, beide mit der Länge n.
Sie dürfen eine Reihe von Vorgängen ausführen (möglicherweise keine).
In einer Operation wählen Sie einen Index i im Bereich [0, n – 1] aus und tauschen die Werte von nums1[i] und nums2[i] aus.
Ihre Aufgabe besteht darin, die Mindestanzahl an Operationen zu ermitteln, die erforderlich sind, um die folgenden Bedingungen zu erfüllen:

nums1[n - 1] ist gleich dem Maximalwert aller Elemente von nums1, d. h. nums1[n - 1] = max(nums1[0], nums1[1], ..., nums1[n - 1]) .
nums2[n - 1] ist gleich dem Maximalwert aller Elemente von nums2, d. h. nums2[n - 1] = max(nums2[0], nums2[1], ..., nums2[n - 1]) .

Gibt eine Ganzzahl zurück, die die Mindestanzahl an Operationen angibt, die erforderlich sind, um beide Bedingungen zu erfüllen, oder -1, wenn es unmöglich ist, beide Bedingungen zu erfüllen.

Beispiel 1:

Eingabe: nums1 = [1,2,7], nums2 = [4,5,3]
Ausgabe: 1
Erläuterung: In diesem Beispiel kann eine Operation mit Index i = 2 ausgeführt werden.
Wenn Nums1[2] und Nums2[2] vertauscht werden, wird Nums1 zu [1,2,3] und Nums2 zu [4,5,7].
Beide Bedingungen sind nun erfüllt.
Es kann gezeigt werden, dass die Mindestanzahl der auszuführenden Operationen 1 beträgt.
Die Antwort ist also 1.

Beispiel 2:

Eingabe: nums1 = [2,3,4,5,9], nums2 = [8,8,4,4,4]
Ausgabe: 2
Erläuterung: In diesem Beispiel können die folgenden Operationen ausgeführt werden:
Erste Operation mit Index i = 4.
Wenn Nums1[4] und Nums2[4] vertauscht werden, wird Nums1 zu [2,3,4,5,4] und Nums2 zu [8,8,4,4,9].
Eine weitere Operation mit Index i = 3.
Wenn Nums1[3] und Nums2[3] vertauscht werden, wird Nums1 zu [2,3,4,4,4] und Nums2 zu [8,8,4,5,9].
Beide Bedingungen sind nun erfüllt.
Es kann gezeigt werden, dass die Mindestanzahl der auszuführenden Operationen 2 beträgt.
Die Antwort ist also 2.

Beispiel 3:

Eingabe: nums1 = [1,5,4], nums2 = [2,5,3]
Ausgabe: -1
Erläuterung: In diesem Beispiel ist es nicht möglich, beide Bedingungen zu erfüllen.
Die Antwort lautet also -1.

Einschränkungen:

1 <= n == nums1.length == nums2.length <= 1000
1 <= nums1[i] <= 10^9
1 <= nums2[i] <= 10^9


Gib bei drei ganzen Zahlen a, b und n den maximalen Wert von (a XOR x) * (b XOR x) zurück, wobei 0 <= x < 2^n.
Da die Antwort möglicherweise zu groß ist, geben Sie sie modulo 10^9 + 7 zurück.
Beachten Sie, dass XOR die bitweise XOR-Operation ist.

Beispiel 1:

Eingabe: a = 12, b = 5, n = 4
Ausgabe: 98
Erläuterung: Für x = 2 ist (a XOR x) = 14 und (b XOR x) = 7. Daher ist (a XOR x) * (b XOR x) = 98.
Es kann gezeigt werden, dass 98 der maximale Wert von (a XOR x) * (b XOR x) für alle 0 <= x < 2^n ist.

Beispiel 2:

Eingabe: a = 6, b = 7 , n = 5
Ausgabe: 930
Erläuterung: Für x = 25, (a XOR x) = 31 und (b XOR x) = 30. Daraus folgt: (a XOR x) * (b XOR x) = 930.
Es kann gezeigt werden, dass 930 der maximale Wert von (a XOR x) * (b XOR x) für alle 0 <= x < 2^n ist.
Beispiel 3:

Eingabe: a = 1, b = 6, n = 3
Ausgabe: 12
Erläuterung: Für x = 5 ist (a XOR x) = 4 und (b XOR x) = 3. Daher ist (a XOR x) * (b XOR x) = 12.
Es kann gezeigt werden, dass 12 der maximale Wert von (a XOR x) * (b XOR x) für alle 0 <= x < 2^n ist.

Nebenbedingungen:

0 <= a, b < 2^50
0 <= n <= 50

Geben Sie bei gegebenen drei ganzen Zahlen a, b und n den Maximalwert von (a XOR x) * (b XOR x) zurück, wobei 0 <= x < 2^n.
Da die Antwort möglicherweise zu groß ist, geben Sie sie modulo 10^9 + 7 zurück.
Beachten Sie, dass XOR die bitweise XOR-Operation ist.

Beispiel 1:

Eingabe: a = 12, b = 5, n = 4
Ausgabe: 98
Erläuterung: Für x = 2 ist (a XOR x) = 14 und (b XOR x) = 7. Daher ist (a XOR x) * (b XOR x) = 98.
Es kann gezeigt werden, dass 98 der Maximalwert von (a XOR x) * (b XOR x) für alle 0 <= x < 2^n ist.

Beispiel 2:

Eingabe: a = 6, b = 7, n = 5
Ausgabe: 930
Erläuterung: Für x = 25 ist (a XOR x) = 31 und (b XOR x) = 30. Daher ist (a XOR x) * (b XOR x) = 930.
Es kann gezeigt werden, dass 930 der Maximalwert von (a XOR x) * (b XOR x) für alle 0 <= x < 2^n ist.
Beispiel 3:

Eingabe: a = 1, b = 6, n = 3
Ausgabe: 12
Erläuterung: Für x = 5 ist (a XOR x) = 4 und (b XOR x) = 3. Daher ist (a XOR x) * (b XOR x) = 12.
Es kann gezeigt werden, dass 12 der Maximalwert von (a XOR x) * (b XOR x) für alle 0 <= x < 2^n ist.

Einschränkungen:

0 <= a, b < 2^50
0 <= n <= 50


Sie erhalten ein 0-indiziertes ganzzahliges Array nums. Ein Paar ganzer Zahlen x und y wird als starkes Paar bezeichnet, wenn es die folgende Bedingung erfüllt:

|x - y| <= min(x, y)

Sie müssen zwei ganze Zahlen aus nums auswählen, so dass sie ein starkes Paar bilden, und ihr bitweises XOR ist das Maximum unter allen starken Paaren im Array.
Gibt den maximalen XOR-Wert aus allen möglichen starken Paaren im Array nums zurück.
Beachten Sie, dass Sie dieselbe ganze Zahl zweimal auswählen können, um ein Paar zu bilden.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgang: 7
Erklärung: Es gibt 11 starke Paare in den Array nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) und (5, 5).
Der maximal mögliche XOR aus diesen Paaren beträgt 3 XOR 4 = 7.

Beispiel 2:

Eingabe: nums = [10,100]
Ausgang: 0
Erklärung: Es gibt 2 starke Paare in den Array nums: (10, 10) und (100, 100).
Der maximal mögliche XOR aus diesen Paaren beträgt 10 XOR 10 = 0, da das Paar (100, 100) ebenfalls 100 XOR 100 = 0 ergibt.

Beispiel 3:

Eingabe: nums = [5,6,25,30]
Ausgang: 7
Erklärung: Es gibt 6 starke Paare in den Array nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) und (30, 30).
Der maximal mögliche XOR aus diesen Paaren beträgt 25 XOR 30 = 7, da der einzige andere XOR-Wert ungleich Null 5 XOR 6 = 3 ist.

Zwänge:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums. Ein Paar ganzer Zahlen x und y wird als starkes Paar bezeichnet, wenn es die Bedingung erfüllt:

|x - y| <= min(x, y)

Sie müssen zwei Ganzzahlen aus Zahlen auswählen, sodass sie ein starkes Paar bilden und ihr bitweises XOR das Maximum unter allen starken Paaren im Array ist.
Gibt den maximalen XOR-Wert aller möglichen starken Paare im Array nums zurück.
Beachten Sie, dass Sie dieselbe Ganzzahl zweimal auswählen können, um ein Paar zu bilden.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: 7
Erläuterung: Es gibt 11 starke Paare im Array nums: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3 , 4), (3, 5), (4, 4), (4, 5) und (5, 5).
Das maximal mögliche XOR aus diesen Paaren ist 3 XOR 4 = 7.

Beispiel 2:

Eingabe: nums = [10.100]
Ausgabe: 0
Erläuterung: Es gibt zwei starke Paare in den Array-Nummern: (10, 10) und (100, 100).
Das maximal mögliche XOR aus diesen Paaren ist 10 XOR 10 = 0, da das Paar (100, 100) auch 100 XOR 100 = 0 ergibt.

Beispiel 3:

Eingabe: nums = [5,6,25,30]
Ausgabe: 7
Erläuterung: Es gibt 6 starke Paare in den Array-Nummern: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) und (30, 30).
Das maximal mögliche XOR aus diesen Paaren ist 25 XOR 30 = 7, da der einzige andere XOR-Wert ungleich Null 5 XOR 6 = 3 ist.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums. Ein Paar ganzer Zahlen x und y wird als starkes Paar bezeichnet, wenn es die Bedingung erfüllt:

|x - y| <= min(x, y)

Sie müssen zwei Ganzzahlen aus nums auswählen, sodass sie ein starkes Paar bilden und ihr bitweises XOR das Maximum aller starken Paare im Array ist.
Gibt den maximalen XOR-Wert aller möglichen starken Paare im Array nums zurück.
Beachten Sie, dass Sie dieselbe Ganzzahl zweimal auswählen können, um ein Paar zu bilden.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: 7
Erläuterung: Im Array nums gibt es 11 starke Paare.: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3 , 4), (3, 5), (4, 4), (4, 5) und (5, 5).
Das maximal mögliche XOR aus diesen Paaren ist 3 XOR 4 = 7.

Beispiel 2:

Eingabe: nums = [10, 100]
Ausgabe: 0
Erläuterung: Im Array nums gibt es zwei starke Paare: (10, 10) und (100, 100).
Das maximal mögliche XOR aus diesen Paaren ist 10 XOR 10 = 0, da das Paar (100, 100) auch 100 XOR 100 = 0 ergibt.

Beispiel 3:

Eingabe: nums = [5,6,25,30]
Ausgabe: 7
Erläuterung: Es gibt 6 starke Paare in den Array nums: (5, 5), (5, 6), (6, 6), (25, 25), (25, 30) und (30, 30).
Das maximal mögliche XOR aus diesen Paaren ist 25 XOR 30 = 7, da der einzige andere XOR-Wert ungleich Null 5 XOR 6 = 3 ist.

Einschränkungen:

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


Du hast ein 0-indiziertes Array von Zeichenketten words und ein Zeichen x.
Gebe ein Array von Indizes zurück, das die Wörter repräsentiert, die das Zeichen x enthalten.
Beachte, dass das zurückgegebene Array in beliebiger Reihenfolge sein kann.

Beispiel 1:

Eingabe: words = ["leet","code"], x = "e"
Ausgabe: [0,1]
Erläuterung: "e" kommt in beiden Wörtern vor: "leet" und "code". Daher geben wir die Indizes 0 und 1 zurück.

Beispiel 2:

Eingabe: words = ["abc","bcd","aaaa","cbc"], x = "a"
Ausgabe: [0,2]
Erläuterung: "a" kommt in "abc" und "aaaa" vor. Daher geben wir die Indizes 0 und 2 zurück.

Beispiel 3:

Eingabe: words = ["abc","bcd","aaaa","cbc"], x = "z"
Ausgabe: []
Erläuterung: "z" kommt in keinem der Wörter vor. Daher geben wir ein leeres Array zurück.

Einschränkungen:

1 <= words.length <= 50
1 <= words[i].length <= 50
x ist ein kleiner englischer Buchstabe.
words[i] besteht nur aus kleinen englischen Buchstaben.

Sie erhalten ein 0-indiziertes Array aus Zeichenfolgen, Wörtern und einem Zeichen x.
Gibt ein Array von Indizes zurück, die die Wörter darstellen, die das Zeichen x enthalten.
Beachten Sie, dass das zurückgegebene Array eine beliebige Reihenfolge haben kann.

Beispiel 1:

Eingabe: Wörter = ["leet", "code"], x = "e"
Ausgabe: [0,1]
Erläuterung: „e“ kommt in beiden Wörtern vor: „leet“ und „code“. Daher geben wir die Indizes 0 und 1 zurück.

Beispiel 2:

Eingabe: Wörter = ["abc", "bcd", "aaaa", "cbc"], x = "a"
Ausgabe: [0,2]
Erläuterung: „a“ kommt in „abc“ und „aaaa“ vor. Daher geben wir die Indizes 0 und 2 zurück.

Beispiel 3:

Eingabe: Wörter = ["abc", "bcd", "aaaa", "cbc"], x = "z"
Ausgabe: []
Erläuterung: „z“ kommt in keinem der Wörter vor. Daher geben wir ein leeres Array zurück.

Einschränkungen:

1 <= Wörter. Länge <= 50
1 <= Wörter[i].Länge <= 50
x ist ein kleiner englischer Buchstabe.
„words[i]“ besteht nur aus englischen Kleinbuchstaben.


Auf einem Tisch liegen n Bälle, jeder Ball hat die Farbe Schwarz oder Weiß.
Sie erhalten eine 0-indizierte Binärzeichenfolge s der Länge n, wobei 1 und 0 jeweils schwarze und weiße Kugeln darstellen.
In jedem Schritt können Sie zwei benachbarte Bälle auswählen und diese austauschen.
Geben Sie die Mindestanzahl an Schritten zurück, um alle schwarzen Kugeln rechts und alle weißen Kugeln links zu gruppieren.

Beispiel 1:

Eingabe: s = „101“
Ausgabe: 1
Erläuterung: Wir können alle schwarzen Kugeln auf der rechten Seite wie folgt gruppieren:
- Vertausche s[0] und s[1], s = „011“.
Anfangs werden Einsen nicht gruppiert, sodass mindestens ein Schritt erforderlich ist, um sie nach rechts zu gruppieren.
Beispiel 2:

Eingabe: s = „100“
Ausgabe: 2
Erläuterung: Wir können alle schwarzen Kugeln auf der rechten Seite wie folgt gruppieren:
- Vertausche s[0] und s[1], s = „010“.
- Vertausche s[1] und s[2], s = „001“.
Es kann nachgewiesen werden, dass die Mindestanzahl der erforderlichen Schritte 2 beträgt.

Beispiel 3:

Eingabe: s = „0111“
Ausgabe: 0
Erläuterung: Alle schwarzen Kugeln sind bereits rechts gruppiert.

Einschränkungen:

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

Auf einem Tisch liegen n Bälle, jeder Ball hat die Farbe Schwarz oder Weiß.
Sie erhalten eine 0-indizierte Binärzeichenfolge s der Länge n, wobei 1 und 0 jeweils schwarze und weiße Kugeln darstellen.
In jedem Schritt können Sie zwei benachbarte Bälle auswählen und diese austauschen.
Geben Sie die Mindestanzahl an Schritten zurück, um alle schwarzen Kugeln rechts und alle weißen Kugeln links zu gruppieren.

Beispiel 1:

Eingabe: s = „101“
Ausgabe: 1
Erläuterung: Wir können alle schwarzen Kugeln auf der rechten Seite wie folgt gruppieren:
- Vertausche s[0] und s[1], s = „011“.
Anfangs werden Einsen nicht gruppiert, so dass mindestens ein Schritt erforderlich ist, um sie nach rechts zu gruppieren.
Beispiel 2:

Eingabe: s = „100“
Ausgabe: 2
Erläuterung: Wir können alle schwarzen Kugeln auf der rechten Seite wie folgt gruppieren:
- Vertausche s[0] und s[1], s = „010“.
- Vertausche s[1] und s[2], s = „001“.
Es kann nachgewiesen werden, dass die Mindestanzahl der erforderlichen Schritte 2 beträgt.

Beispiel 3:

Eingabe: s = „0111“
Ausgabe: 0
Erläuterung: Alle schwarzen Kugeln sind bereits rechts gruppiert.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine Ganzzahl k.
Sie können die folgende Operation höchstens k-mal für das Array ausführen:

Wählen Sie einen beliebigen Index i aus dem Array und erhöhen oder verringern Sie nums[i] um 1.

Die Punktzahl des endgültigen Arrays ist die Häufigkeit des häufigsten Elements im Array.
Geben Sie die maximale Punktzahl zurück, die Sie erreichen können.
Die Häufigkeit eines Elements ist die Anzahl der Vorkommen dieses Elements im Array.

Beispiel 1:

Eingabe: nums = [1,2,6,4], k = 3
Ausgabe: 3
Erläuterung: Wir können die folgenden Operationen für das Array ausführen:
- Wählen Sie i = 0 und erhöhen Sie den Wert von nums[0] um 1. Das resultierende Array ist [2,2,6,4].
- Wählen Sie i = 3 und verringern Sie den Wert von nums[3] um 1. Das resultierende Array ist [2,2,6,3].
- Wählen Sie i = 3 und verringern Sie den Wert von nums[3] um 1. Das resultierende Array ist [2,2,6,2].
Das Element 2 ist im endgültigen Array am häufigsten, daher beträgt unsere Punktzahl 3.
Es lässt sich zeigen, dass wir kein besseres Ergebnis erzielen können.

Beispiel 2:

Eingabe: nums = [1,4,4,2,4], k = 0
Ausgabe: 3
Erläuterung: Wir können keine Operationen anwenden, daher ist unser Score die Häufigkeit des häufigsten Elements im ursprünglichen Array, also 3.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine Ganzzahl k.
Sie können den folgenden Vorgang höchstens k-mal am Array ausführen:

Wählen Sie einen beliebigen Index i aus dem Array und erhöhen oder verringern Sie nums[i] um 1.

Die Punktzahl des endgültigen Arrays ist die Häufigkeit des häufigsten Elements im Array.
Geben Sie die maximale Punktzahl zurück, die Sie erreichen können.
Die Häufigkeit eines Elements ist die Anzahl der Vorkommen dieses Elements im Array.

Beispiel 1:

Eingabe: Zahlen = [1,2,6,4], k = 3
Ausgabe: 3
Erläuterung: Wir können die folgenden Operationen für das Array ausführen:
- Wählen Sie i = 0 und erhöhen Sie den Wert von nums[0] um 1. Das resultierende Array ist [2,2,6,4].
- Wählen Sie i = 3 und verringern Sie den Wert von nums[3] um 1. Das resultierende Array ist [2,2,6,3].
- Wählen Sie i = 3 und verringern Sie den Wert von nums[3] um 1. Das resultierende Array ist [2,2,6,2].
Das Element 2 ist im endgültigen Array am häufigsten, daher beträgt unsere Punktzahl 3.
Es lässt sich zeigen, dass wir kein besseres Ergebnis erzielen können.

Beispiel 2:

Eingabe: Zahlen = [1,4,4,2,4], k = 0
Ausgabe: 3
Erläuterung: Wir können keine Operationen anwenden, daher ist unser Score die Häufigkeit des häufigsten Elements im ursprünglichen Array, also 3.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes ganzzahliges Array nums und eine ganze Zahl k.
Sie können die folgende Operation höchstens k-mal mit der Matrix durchführen:

Wählen Sie einen beliebigen Index i aus der Matrix und erhöhen oder verringern Sie nums[i] um 1.

Die Punktzahl der endgültigen Matrix ist die Häufigkeit des häufigsten Elements in der Matrix.
Geben Sie die maximale Punktzahl zurück, die Sie erreichen können.
Die Häufigkeit eines Elements ist die Anzahl der Vorkommen dieses Elements im Array.

Beispiel 1:

Eingabe: nums = [1,2,6,4], k = 3
Ausgabe: 3
Erläuterung: Wir können die folgenden Operationen mit dem Array durchführen:
- Wählen Sie i = 0 und erhöhen Sie den Wert von nums[0] um 1. Das resultierende Array ist [2,2,6,4].
- Wählen Sie I = 3 und verringern Sie den Wert von nums[3] um 1. Das resultierende Array ist [2,2,6,3].
- Wählen Sie I = 3 und verringern Sie den Wert von nums[3] um 1. Das resultierende Array ist [2,2,6,2].
Das Element 2 ist das häufigste im endgültigen Array, also ist unser Ergebnis 3.
Es kann gezeigt werden, dass wir keine bessere Punktzahl erreichen können.

Beispiel 2:

Eingabe: nums = [1,4,4,2,4], k = 0
Ausgabe: 3
Erläuterung: Da wir keine Operationen anwenden können, ist unsere Punktzahl die Häufigkeit des häufigsten Elements im ursprünglichen Array, das ist 3.

Beschränkungen:

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


Sie erhalten zwei positive ganze Zahlen n und limit.
Gibt die Gesamtzahl der Möglichkeiten zurück, n Bonbons unter 3 Kindern zu verteilen, sodass kein Kind mehr als die maximale Anzahl an Bonbons erhält.

Beispiel 1:

Eingabe: n = 5, limit = 2
Ausgabe: 3
Erklärung: Es gibt drei Möglichkeiten, 5 Bonbons so zu verteilen, dass kein Kind mehr als 2 Bonbons bekommt: (1, 2, 2), (2, 1, 2) und (2, 2, 1).

Beispiel 2:

Eingabe: n = 3, limit = 3
Ausgabe: 10
Erklärung: Es gibt 10 Möglichkeiten, 3 Bonbons so zu verteilen, dass kein Kind mehr als 3 Bonbons bekommt: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0 ), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) und (3, 0, 0).

Einschränkungen:

1 <= n <= 50
1 <= limit <= 50

Sie erhalten zwei positive Ganzzahlen n und limit.
Geben Sie die Gesamtzahl der Möglichkeiten zurück, n -Bonbons auf 3 Kinder zu verteilen, so dass kein Kind mehr als limit Bonbons erhält.

Beispiel 1:

Eingabe: n = 5, limit = 2
Ausgabe: 3
Erläuterung: Es gibt 3 Möglichkeiten, 5 Süßigkeiten so zu verteilen, dass kein Kind mehr als 2 Süßigkeiten erhält: (1, 2, 2), (2, 1, 2) und (2, 2, 1).

Beispiel 2:

Eingabe: n = 3, limit = 3
Ausgabe: 10
Erläuterung: Es gibt 10 Möglichkeiten, 3 Süßigkeiten zu verteilen, so dass kein Kind mehr als 3 Süßigkeiten erhält: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0) ), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) und (3, 0, 0).

Einschränkungen:

1 <= n <= 50
1 <= limit <= 50

Sie erhalten zwei positive ganze Zahlen n und limit.
Gibt die Gesamtzahl der Möglichkeiten zurück, n Bonbons unter 3 Kindern zu verteilen, sodass kein Kind mehr als die maximale Anzahl an Bonbons erhält.

Beispiel 1:

Eingabe: n = 5, Grenze = 2
Ausgabe: 3
Erklärung: Es gibt drei Möglichkeiten, 5 Bonbons so zu verteilen, dass kein Kind mehr als 2 Bonbons bekommt: (1, 2, 2), (2, 1, 2) und (2, 2, 1).

Beispiel 2:

Eingabe: n = 3, Grenze = 3
Ausgabe: 10
Erklärung: Es gibt 10 Möglichkeiten, 3 Bonbons so zu verteilen, dass kein Kind mehr als 3 Bonbons bekommt: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0 ), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) und (3, 0, 0).

Einschränkungen:

1 <= n <= 50
1 <= Grenze <= 50


Sie erhalten eine ganze Zahl n.
Eine Zeichenkette s wird als gut bezeichnet, wenn sie nur englische Kleinbuchstaben enthält und es möglich ist, die Zeichen von s so umzuordnen, dass die neue Zeichenkette „leet“ als Teilzeichenfolge enthält.
Ein Beispiel:

Die Zeichenfolge „lteer“ ist gut, weil wir sie zu „leetr“ umformen können.
„letl“ ist nicht gut, weil wir sie nicht so umordnen können, dass sie ‚leet‘ als Teilzeichenfolge enthält.

Geben Sie die Gesamtzahl der guten Zeichenketten der Länge n zurück.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Eine Teilzeichenkette ist eine zusammenhängende Folge von Zeichen innerhalb einer Zeichenkette.

Beispiel 1:

Eingabe: n = 4
Ausgabe: 12
Erläuterung: Die 12 Zeichenfolgen, die so umgeordnet werden können, dass sie „leet“ als Teilzeichenfolge enthalten, sind: „eelt“, „eetl“, „elet“, „elte“, „etel“, „etle“, „leet“, „lete“, „ltee“, „teel“, „tele“, und „tlee“.

Beispiel 2:

Eingabe: n = 10
Ausgabe: 83943898
Erläuterung: Die Anzahl der Strings mit der Länge 10, die so umgeordnet werden können, dass sie „leet“ als Teilstring enthalten, ist 526083947580. Die Antwort lautet also 526083947580 % (10^9 + 7) = 83943898.

Randbedingungen:

1 <= n <= 10^5

Sie erhalten eine ganze Zahl n.
Ein String s heißt gut, wenn er nur englische Kleinbuchstaben enthält und es möglich ist, die Zeichen von s so umzuordnen, dass der neue String „leet“ als Teilstring enthält.
Zum Beispiel:

Die Zeichenfolge „lteer“ ist gut, weil wir sie so umordnen können, dass sie „leetr“ ergibt.
„letl“ ist nicht gut, da wir es nicht so umordnen können, dass es „leet“ als Teilzeichenfolge enthält.

Gibt die Gesamtzahl der guten Strings der Länge n zurück.
Da die Antwort groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen innerhalb eines Strings.

Beispiel 1:

Eingabe: n = 4
Ausgabe: 12
Erläuterung: Die 12 Zeichenfolgen, die neu angeordnet werden können, um „leet“ als Teilzeichenfolge zu haben, sind: „eelt“, „eetl“, „elet“, „elte“, „etel“, „etle“, „leet“, „lete“ , „ltee“, „teel“, „tele“ und „tlee“.

Beispiel 2:

Eingabe: n = 10
Ausgabe: 83943898
Erläuterung: Die Anzahl der Zeichenfolgen mit der Länge 10, die neu angeordnet werden können, um „leet“ als Teilzeichenfolge zu haben, beträgt 526083947580. Daher lautet die Antwort 526083947580 % (10^9 + 7) = 83943898.

Einschränkungen:

1 <= n <= 10^5


Sie erhalten eine 0-indizierte Zeichenfolge s mit einer geraden Länge n.
Sie erhalten außerdem ein 0-indiziertes 2D-Integer-Array, Abfragen, wobei Abfragen[i] = [a_i, b_i, c_i, d_i].
Für jede Abfrage i dürfen Sie die folgenden Operationen ausführen:

Ordnen Sie die Zeichen innerhalb der Teilzeichenfolge s[a_i:b_i] neu an, wobei 0 <= a_i <= b_i < n / 2.
Ordnen Sie die Zeichen innerhalb der Teilzeichenfolge s[c_i:d_i] neu an, wobei n / 2 <= c_i <= d_i < n.

Ihre Aufgabe besteht darin, für jede Abfrage zu bestimmen, ob es möglich ist, durch Ausführen der Operationen ein Palindrom zu erstellen.
Jede Anfrage wird unabhängig von den anderen beantwortet.
Gibt eine 0-indizierte Array-Antwort zurück, wobei answer[i] == true ist, wenn es möglich ist, s zu einem Palindrom zu machen, indem durch die i^-te Abfrage angegebene Operationen ausgeführt werden, andernfalls false.

Ein Teilstring ist eine zusammenhängende Folge von Zeichen innerhalb eines Strings.
s[x:y] stellt die Teilzeichenfolge dar, die aus Zeichen vom Index x bis zum Index y in s (beide einschließlich) besteht.

Beispiel 1:

Eingabe: s = „abcabc“, Abfragen = [[1,1,3,5],[0,2,5,5]]
Ausgabe: [wahr, wahr]
Erläuterung: In diesem Beispiel gibt es zwei Abfragen:
In der ersten Abfrage:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Sie dürfen also s[1:1] => abcabc und s[3:5] => abcabc neu anordnen.
- Um s zu einem Palindrom zu machen, kann s[3:5] in => abccba umgeordnet werden.
- Nun, s ist ein Palindrom. Antwort[0] = wahr.
In der zweiten Abfrage:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Sie dürfen also s[0:2] => abcabc und s[5:5] => abcabc neu anordnen.
- Um s zu einem Palindrom zu machen, kann s[0:2] in => cbaabc umgeordnet werden.
- Nun, s ist ein Palindrom. Antwort[1] = wahr.

Beispiel 2:

Eingabe: s = „abbcdecbba“, Abfragen = [[0,2,7,9]]
Ausgabe: [falsch]
Erläuterung: In diesem Beispiel gibt es nur eine Abfrage.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Sie dürfen also s[0:2] => abbcdecbba und s[7:9] => abbcdecbba neu anordnen.
Es ist nicht möglich, s durch Umordnen dieser Teilzeichenfolgen zu einem Palindrom zu machen, da s[3:6] kein Palindrom ist.
Antwort[0] = falsch.
Beispiel 3:

Eingabe: s = „acbcab“, Abfragen = [[1,2,4,5]]
Ausgabe: [wahr]
Erläuterung: In diesem Beispiel gibt es nur eine Abfrage.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Sie dürfen also s[1:2] => acbcab und s[4:5] => acbcab neu anordnen.
Um s zu einem Palindrom zu machen, kann s[1:2] in abccab umgeordnet werden.
Dann kann s[4:5] neu angeordnet werden, um abccba zu werden.
Nun ist s ein Palindrom. Antwort[0] = wahr.

Einschränkungen:

2 <= n == s.length <= 10^5
1 <= query.length <= 10^5
query[i].length == 4
a_i == Abfragen[i][0], b_i == Abfragen[i][1]
c_i == Abfragen[i][2], d_i == Abfragen[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n ist gerade.
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine 0-indizierte Zeichenfolge s mit einer geraden Länge n.
Sie erhalten außerdem ein 0-indiziertes 2D-Integer-Array, Abfragen, wobei Abfragen[i] = [a_i, b_i, c_i, d_i].
Für jede Abfrage i dürfen Sie die folgenden Operationen ausführen:

Ordnen Sie die Zeichen innerhalb der Teilzeichenfolge s[a_i:b_i] neu an, wobei 0 <= a_i <= b_i < n / 2.
Ordnen Sie die Zeichen innerhalb der Teilzeichenfolge s[c_i:d_i] neu an, wobei n / 2 <= c_i <= d_i < n.

Ihre Aufgabe besteht darin, für jede Abfrage zu bestimmen, ob es möglich ist, durch Ausführen der Operationen ein Palindrom zu erstellen.
Jede Anfrage wird unabhängig von den anderen beantwortet.
Gibt eine 0-indizierte Array-Antwort zurück, wobei answer[i] == true ist, wenn es möglich ist, s zu einem Palindrom zu machen, indem durch die i^-te Abfrage angegebene Operationen ausgeführt werden, andernfalls false.

Ein Teilstring ist eine zusammenhängende Folge von Zeichen innerhalb eines Strings.
s[x:y] stellt die Teilzeichenfolge dar, die aus Zeichen vom Index x bis zum Index y in s (beide einschließlich) besteht.

Beispiel 1:

Eingabe: s = „abcabc“, Abfragen = [[1,1,3,5],[0,2,5,5]]
Ausgabe: [wahr, wahr]
Erläuterung: In diesem Beispiel gibt es zwei Abfragen:
In der ersten Abfrage:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Sie dürfen also s[1:1] => abcabc und s[3:5] => abcabc neu anordnen.
- Um s zu einem Palindrom zu machen, kann s[3:5] in => abccba umgeordnet werden.
- Nun, s ist ein Palindrom. Antwort[0] = wahr.
In der zweiten Abfrage:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Sie dürfen also s[0:2] => abcabc und s[5:5] => abcabc neu anordnen.
- Um s zu einem Palindrom zu machen, kann s[0:2] neu angeordnet werden, um => cbaabc zu werden.
- Nun, s ist ein Palindrom. Antwort[1] = wahr.

Beispiel 2:

Eingabe: s = „abbcdecbba“, Abfragen = [[0,2,7,9]]
Ausgabe: [falsch]
Erläuterung: In diesem Beispiel gibt es nur eine Abfrage.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Sie dürfen also s[0:2] => abbcdecbba und s[7:9] => abbcdecbba neu anordnen.
Es ist nicht möglich, s durch Umordnen dieser Teilzeichenfolgen zu einem Palindrom zu machen, da s[3:6] kein Palindrom ist.
Antwort[0] = falsch.
Beispiel 3:

Eingabe: s = „acbcab“, Abfragen = [[1,2,4,5]]
Ausgabe: [wahr]
Erläuterung: In diesem Beispiel gibt es nur eine Abfrage.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Sie dürfen also s[1:2] => acbcab und s[4:5] => acbcab neu anordnen.
Um s zu einem Palindrom zu machen, kann s[1:2] in abccab umgeordnet werden.
Dann kann s[4:5] neu angeordnet werden, um abccba zu werden.
Nun ist s ein Palindrom. Antwort[0] = wahr.

Einschränkungen:

2 <= n == s.length <= 10^5
1 <= query.length <= 10^5
query[i].length == 4
a_i == Abfragen[i][0], b_i == Abfragen[i][1]
c_i == Abfragen[i][2], d_i == Abfragen[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n ist gerade.
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine 0-indiziert-Zeichenkette mit einer gleichmäßigen Länge n.
Sie erhalten auch ein 0-indiziertes 2D-Integer-Array, Abfragen, wobei queries[i] = [a_i, b_i, c_i, d_i].
Für jede Abfrage i dürfen Sie die folgenden Vorgänge ausführen:

Ordnen Sie die Zeichen innerhalb des Substrings s[a_i: b_i] neu an, wobei 0 <= a_i <= b_i <n / 2.
Ordnen Sie die Zeichen innerhalb der Substring s[c_i: d_i] neu an, wobei n / 2 <= c_i <= d_i <n.

Für jede Abfrage ist es Ihre Aufgabe, festzustellen, ob es möglich ist, s durchzuführen, indem Sie die Operationen ausführen.
Jede Abfrage wird unabhängig von den anderen beantwortet.
Geben Sie eine 0-indiziert-Array-Antwort zurück, in der answer[i] == true, wenn es möglich ist, s zu einem Palindrom zu machen, indem Operationen durch die i^th-Abfrage und ansonsten falsch ausgeführt werden.

Ein Substring ist eine zusammenhängende Abfolge von Zeichen innerhalb einer Zeichenfolge.
s[x:y] repräsentiert das Substring, das aus Zeichen aus dem Index x bis in Index y in s besteht, beide inklusive.

Beispiel 1:

Eingabe: s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
Ausgabe: [true,true]
Erläuterung: In diesem Beispiel gibt es zwei Abfragen:
In der ersten Abfrage:
- a_0 = 1, b_0 = 1, c_0 = 3, d_0 = 5.
- Es ist also erlaubt, s[1:1] => abcabc und s[3:5] => abcabc umzustellen.
- Um s zu einem Palindrom zu machen, kann s[3:5] neu angeordnet werden, um abccba zu werden.
- Jetzt ist s ein Palindrom. Also ist answer[0] = true.
In der zweiten Abfrage:
- a_1 = 0, b_1 = 2, c_1 = 5, d_1 = 5.
- Sie dürfen also s[0:2] => abcabc und s[5:5] => abcabc umstellen.
- Um S zu einem Palindrom zu machen, kann s [0: 2] neu angeordnet werden, um zu become => cbaabc.
- Jetzt ist s ein Palindrom. Also ist answer[1] = true.

Beispiel 2:

Eingabe: s = "abbcdecbba", queries = [[0,2,7,9]]
Ausgabe: [false]
Erläuterung: In diesem Beispiel gibt es nur eine Abfrage.
a_0 = 0, b_0 = 2, c_0 = 7, d_0 = 9.
Sie dürfen s[0:2] => abbcdecbba und s[7:9] => abbcdecbba. neu ordnen.
Es ist nicht möglich, s zu einem Palindrom zu machen, indem diese Substrings neu angeordnet werden, da s[3:6] kein Palindrom ist.
Also ist answer[0] = false.
Beispiel 3:

Eingabe: s = "acbcab", queries = [[1,2,4,5]]
Ausgabe:[true]
Erläuterung: In diesem Beispiel gibt es nur eine Abfrage.
a_0 = 1, b_0 = 2, c_0 = 4, d_0 = 5.
Sie dürfen  s[1:2] => acbcab und s[4:5] => acbcab neu ordnen.
Um s[1:2] zu einem Palindrom zu machen, kann es neu angeordnet werden, um abccab zu werden.
Dann kann S [4: 5] neu angeordnet werden, um abccba zu werden.
Jetzt ist s ein Palindrom. answer[0] = true.

Einschränkungen:

2 <= n == s.length <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 4
a_i == queries[i][0], b_i == queries[i][1]
c_i == queries[i][2], d_i == queries[i][3]
0 <= a_i <= b_i < n / 2
n / 2 <= c_i <= d_i < n
n ist gerade.
s besteht nur aus englischen Kleinbuchstaben.