Sie erhalten ein 0-indiziertes Ganzzahl-Array „Nums“ und einen Ganzzahl-Schwellenwert.
Finden Sie die Länge des längsten Unterarrays von Nums, das bei Index l beginnt und bei Index r endet (0 <= l <= r < Nums.length), das die folgenden Bedingungen erfüllt:

nums[l] % 2 == 0
Für alle Indizes i im Bereich [l, r - 1] gilt nums[i] % 2 != nums[i + 1] % 2
Für alle Indizes i im Bereich [l, r] ist nums[i] <= Schwellenwert

Gibt eine Ganzzahl zurück, die die Länge des längsten solchen Subarrays angibt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [3,2,5,4], threshold = 5
Ausgabe: 3
Erläuterung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 1 beginnt und bei r = 3 => [2,5,4] endet. Dieses Subarray erfüllt die Bedingungen.
Daher ist die Antwort die Länge des Subarrays, 3. Wir können zeigen, dass 3 die maximal erreichbare Länge ist.
Beispiel 2:

Eingabe: nums = [1,2], threshold = 2
Ausgabe: 1
Erläuterung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 1 beginnt und bei r = 1 => [2] endet.
Es erfüllt alle Bedingungen und wir können zeigen, dass 1 die maximal erreichbare Länge ist.

Beispiel 3:

Eingabe: nums = [2,3,4,5], threshold = 4
Ausgabe: 3
Erläuterung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 0 beginnt und bei r = 2 => [2,3,4] endet.
Es erfüllt alle Bedingungen.
Daher ist die Antwort die Länge des Subarrays, 3. Wir können zeigen, dass 3 die maximal erreichbare Länge ist.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes ganzzahliges Array nums und einen ganzzahligen Schwellenwert.
Ermitteln Sie die Länge des längsten Unterarrays von nums, das bei Index l beginnt und bei Index r endet (0 <= l <= r < nums.length), das die folgenden Bedingungen erfüllt:

nums[l] % 2 == 0
Für alle Indizes i im Bereich [l, r - 1], nums[i] % 2 != nums[i + 1] % 2
Für alle Indizes i im Bereich [l, r], nums[i] <= Schwellenwert

Gibt eine Ganzzahl zurück, die die Länge des längsten solchen Subarrays angibt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Sequenz von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [3,2,5,4], threshold = 5
Ausgang: 3
Erklärung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 1 beginnt und bei r = 3 = > [2,5,4] endet. Dieses Subarray erfüllt die Bedingungen.
Daher ist die Antwort die Länge des Subarrays, 3. Wir können zeigen, dass 3 die maximal mögliche erreichbare Länge ist.
Beispiel 2:

Eingabe: nums = [1,2], threshold = 2
Ausgang: 1
Erklärung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 1 beginnt und bei r = 1 = > [2] endet.
Es erfüllt alle Bedingungen und wir können zeigen, dass 1 die maximal mögliche erreichbare Länge ist.

Beispiel 3:

Eingabe: nums = [2,3,4,5], threshold = 4
Ausgang: 3
Erklärung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 0 beginnt und bei r = 2 = > [2,3,4] endet.
Es erfüllt alle Bedingungen.
Daher ist die Antwort die Länge des Subarrays, 3. Wir können zeigen, dass 3 die maximal mögliche erreichbare Länge ist.

Zwänge:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array „Nums“ und einen Ganzzahl-Schwellenwert.
Finden Sie die Länge des längsten Subarrays von Nums, das bei Index l beginnt und bei Index r endet (0 <= l <= r < Nums.length), das die folgenden Bedingungen erfüllt:

nums[l] % 2 == 0
Für alle Indizes i im Bereich [l, r - 1] gilt nums[i] % 2 != nums[i + 1] % 2
Für alle Indizes i im Bereich [l, r] gilt nums[i] <= Schwellenwert

Gibt eine Ganzzahl zurück, die die Länge des längsten solchen Subarrays angibt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: Zahlen = [3,2,5,4], Schwellenwert = 5
Ausgabe: 3
Erläuterung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 1 beginnt und bei r = 3 => [2,5,4] endet. Dieses Subarray erfüllt die Bedingungen.
Daher ist die Antwort die Länge des Subarrays, 3. Wir können zeigen, dass 3 die maximal erreichbare Länge ist.
Beispiel 2:

Eingabe: Zahlen = [1,2], Schwellenwert = 2
Ausgabe: 1
Erläuterung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 1 beginnt und bei r = 1 => [2] endet.
Es erfüllt alle Bedingungen und wir können zeigen, dass 1 die maximal erreichbare Länge ist.

Beispiel 3:

Eingabe: Zahlen = [2,3,4,5], Schwellenwert = 4
Ausgabe: 3
Erläuterung: In diesem Beispiel können wir das Subarray auswählen, das bei l = 0 beginnt und bei r = 2 => [2,3,4] endet.
Es erfüllt alle Bedingungen.
Daher ist die Antwort die Länge des Subarrays, 3. Wir können zeigen, dass 3 die maximal erreichbare Länge ist.

Einschränkungen:

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


Sie erhalten ein binäres Array nums.
Ein Subarray eines Arrays ist gut, wenn es genau ein Element mit dem Wert 1 enthält.
Geben Sie eine ganze Zahl zurück, die die Anzahl der Möglichkeiten angibt, das Array nums in gute Subarrays zu unterteilen. Da die Zahl zu groß sein kann, wird sie modulo 10^9 + 7 zurückgegeben.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [0,1,0,0,1]
Ausgabe: 3
Erläuterung: Es gibt 3 Möglichkeiten, nums in gute Subarrays aufzuteilen:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Beispiel 2:

Eingabe: nums = [0,1,0]
Ausgabe: 1
Erläuterung: Es gibt 1 Möglichkeit, nums in gute Subarrays aufzuteilen:
- [0,1,0]

Beschränkungen:

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

Sie erhalten ein binäres Array nums.
Ein Subarray eines Arrays ist gut, wenn es genau ein Element mit dem Wert 1 enthält.
Gibt eine Ganzzahl zurück, die die Anzahl der Möglichkeiten angibt, die Array-Zahlen in gute Unterarrays aufzuteilen. Da die Zahl möglicherweise zu groß ist, geben Sie sie modulo 10^9 + 7 zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [0,1,0,0,1]
Ausgabe: 3
Erläuterung: Es gibt drei Möglichkeiten, Nums in gute Subarrays aufzuteilen:
- [0,1] [0,0,1]
- [0,1,0] [0,1]
- [0,1,0,0] [1]

Beispiel 2:

Eingabe: nums = [0,1,0]
Ausgabe: 1
Erläuterung: Es gibt eine Möglichkeit, Nums in gute Subarrays aufzuteilen:
- [0,1,0]

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Ganzzahl-Array nums. Ein Subarray von Nums heißt kontinuierlich, wenn:

Seien i, i + 1, ..., j_ die Indizes im Subarray. Dann gilt für jedes Indexpaar i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Gibt die Gesamtzahl der kontinuierlichen Subarrays zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [5,4,2,4]
Ausgabe: 8
Erläuterung:
Kontinuierliches Subarray der Größe 1: [5], [4], [2], [4].
Kontinuierliches Subarray der Größe 2: [5,4], [4,2], [2,4].
Kontinuierliches Subarray der Größe 3: [4,2,4].
Es gibt keine Unterarrys der Größe 4.
Gesamte kontinuierliche Subarrays = 4 + 3 + 1 = 8.
Es kann gezeigt werden, dass es keine kontinuierlichen Subarrays mehr gibt.

Beispiel 2:

Eingabe: nums = [1,2,3]
Ausgabe: 6
Erläuterung:
Kontinuierliches Subarray der Größe 1: [1], [2], [3].
Kontinuierliches Subarray der Größe 2: [1,2], [2,3].
Kontinuierliches Subarray der Größe 3: [1,2,3].
Gesamte kontinuierliche Subarrays = 3 + 2 + 1 = 6.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums. Ein Subarray von nums wird als kontinuierlich bezeichnet, wenn:

Sei i, i + 1, ..., j_ die Indizes im Subarray. Dann ist für jedes Paar von Indizes i <= i_1, i_2 <= j, 0 <= |nums[i_1] - nums[i_2]| <= 2.

Gibt die Gesamtzahl der zusammenhängenden Unterfelder zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [5,4,2,4]
Ausgabe: 8
Erläuterung:
Fortlaufende Teilreihe der Größe 1: [5], [4], [2], [4].
Kontinuierliche Teilreihe der Größe 2: [5,4], [4,2], [2,4].
Kontinuierliche Teilreihe der Größe 3: [4,2,4].
Es gibt keine Unterfelder der Größe 4.
Gesamtzahl der kontinuierlichen Unterfelder = 4 + 3 + 1 = 8.
Es kann gezeigt werden, dass es keine weiteren kontinuierlichen Unterfelder gibt.

Beispiel 2:

Eingabe: nums = [1,2,3]
Ausgabe: 6
Erläuterung:
Fortlaufende Teilreihe der Größe 1: [1], [2], [3].
Kontinuierliche Teilmenge der Größe 2: [1,2], [2,3].
Kontinuierliche Teilreihe der Größe 3: [1,2,3].
Kontinuierliche Teilfelder insgesamt = 3 + 2 + 1 = 6.

Beschränkungen:

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


Sie erhalten zwei 0-indizierte Ganzzahlarrays nums1 und nums2 der Länge n.
Definieren wir ein weiteres 0-indiziertes Ganzzahlarray, nums3, mit der Länge n. Für jeden Index i im Bereich [0, n - 1] können Sie nums3[i] entweder nums1[i] oder nums2[i] zuweisen.
Ihre Aufgabe besteht darin, die Länge des längsten nicht abnehmenden Subarrays in nums3 zu maximieren, indem Sie seine Werte optimal wählen.
Gibt eine Ganzzahl zurück, die die Länge des längsten nicht abnehmenden Subarrays in nums3 darstellt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: Nums1 = [2,3,1], Nums2 = [1,2,1]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
Das Subarray beginnt bei Index 0 und endet bei Index 1, [2,2], und bildet ein nicht abnehmendes Subarray der Länge 2.
Wir können zeigen, dass 2 die maximal erreichbare Länge ist.
Beispiel 2:

Eingabe: Nums1 = [1,3,2,1], Nums2 = [2,2,3,4]
Ausgabe: 4
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Das gesamte Array bildet ein nicht abnehmendes Subarray der Länge 4 und ist damit die maximal erreichbare Länge.

Beispiel 3:

Eingabe: Nums1 = [1,1], Nums2 = [2,2]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums1[1]] => [1,1].
Das gesamte Array bildet ein nicht abnehmendes Subarray der Länge 2 und ist damit die maximal erreichbare Länge.

Einschränkungen:

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

Sie erhalten zwei 0-indizierte Ganzzahl-Arrays nums1 und nums2 der Länge n.
Definieren wir ein weiteres 0-indiziertes Ganzzahlarray, nums3, mit der Länge n. Für jeden Index i im Bereich [0, n - 1] können Sie nums3[i] entweder nums1[i] oder nums2[i] zuweisen.
Ihre Aufgabe besteht darin, die Länge des längsten nicht abnehmenden Subarrays in nums3 zu maximieren, indem Sie seine Werte optimal wählen.
Gibt eine Ganzzahl zurück, die die Länge des längsten nicht abnehmenden Subarrays in nums3 darstellt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: Nums1 = [2,3,1], Nums2 = [1,2,1]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
Das Subarray beginnt bei Index 0 und endet bei Index 1, [2,2], und bildet ein nicht abnehmendes Subarray der Länge 2.
Wir können zeigen, dass 2 die maximal erreichbare Länge ist.
Beispiel 2:

Eingabe: Nums1 = [1,3,2,1], Nums2 = [2,2,3,4]
Ausgabe: 4
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Das gesamte Array bildet ein nicht abnehmendes Subarray der Länge 4 und ist damit die maximal erreichbare Länge.

Beispiel 3:

Eingabe: Nums1 = [1,1], Nums2 = [2,2]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums1[1]] => [1,1].
Das gesamte Array bildet ein nicht abnehmendes Subarray der Länge 2 und ist damit die maximal erreichbare Länge.

Einschränkungen:

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

Sie erhalten zwei 0-indizierte Ganzzahl-Arrays nums1 und nums2 der Länge n.
Definieren wir ein weiteres 0-indiziertes Ganzzahlarray, nums3, mit der Länge n. Für jeden Index i im Bereich [0, n - 1] können Sie nums3[i] entweder nums1[i] oder nums2[i] zuweisen.
Ihre Aufgabe besteht darin, die Länge des längsten nicht abnehmenden Subarrays in nums3 zu maximieren, indem Sie seine Werte optimal wählen.
Gibt eine Ganzzahl zurück, die die Länge des längsten nicht abnehmenden Subarrays in nums3 darstellt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums1 = [2,3,1], nums = [1,2,1]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
Das Subarray beginnt bei Index 0 und endet bei Index 1, [2,2], und bildet ein nicht abnehmendes Subarray der Länge 2.
Wir können zeigen, dass 2 die maximal erreichbare Länge ist.
Beispiel 2:

Eingabe: nums1 = [1,3,2,1], nums = [2,2,3,4]
Ausgabe: 4
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
Das gesamte Array bildet ein nicht abnehmendes Subarray der Länge 4 und ist damit die maximal erreichbare Länge.

Beispiel 3:

Eingabe: nums1 = [1,1], nums2 = [2,2]
Ausgabe: 2
Erläuterung: Eine Möglichkeit, nums3 zu konstruieren, ist:
nums3 = [nums1[0], nums1[1]] => [1,1].
Das gesamte Array bildet ein nicht abnehmendes Subarray der Länge 2 und ist damit die maximal erreichbare Länge.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Ganzzahl-Array nums. Ein Subarray s der Länge m heißt alternierend, wenn:

m ist größer als 1.
s_1 = s_0 + 1.
Das 0-indizierte Subarray s sieht aus wie [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. Mit anderen Worten: s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1 usw. bis zu s[m - 1] - s[m - 2] = ( -1)^m.

Gibt die maximale Länge aller vorhandenen alternierenden Subarrays in Zahlen zurück oder -1, wenn kein solches Subarray vorhanden ist.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [2,3,4,3,4]
Ausgabe: 4
Erläuterung: Die alternierenden Subarrays sind [3,4], [3,4,3] und [3,4,3,4]. Die längste davon ist [3,4,3,4] und hat die Länge 4.

Beispiel 2:

Eingabe: nums = [4,5,6]
Ausgabe: 2
Erläuterung: [4,5] und [5,6] sind die einzigen zwei alternierenden Subarrays. Sie haben beide die Länge 2.

Einschränkungen:

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

Sie erhalten eine 0-in-Indexed Integer Array nums. Ein Subarrays von Länge m wird als abwechselnd bezeichnet, wenn:

m ist größer als 1.
s_1 = s_0 + 1.
Die 0-indexed SubaRray s sieht aus wie [s_0, s_1, s_0, s_1,...,s_(m-1) % 2]. In anderen Worten, s_1 - s_0 = 1, s_2 - s_1 = -1, s_3 - s_2 = 1, s_4 - s_3 = -1 und so weiter bis zu s[m - 1] - s[m - 2] = ( -1)^m.

Geben Sie die maximale Länge aller in NUMS vorhandenen abwechselnden Unterbarrays zurück oder -1, wenn kein solcher Unterarray vorhanden ist.
Ein Subtarray ist eine zusammenhängende nicht leere Abfolge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [2,3,4,3,4]
Ausgabe: 4
Erläuterung: Die abwechselnden Subtarrays sind [3,4], [3,4,3] und [3,4,3,4]. Die längste davon ist [3,4,3,4], das von Länge 4 ist.

Beispiel 2:

Eingabe: nums = [4,5,6]
Ausgabe: 2
Erläuterung: [4,5] und [5,6] sind die einzigen zwei abwechselnden Subtarrays. Sie sind beide von Länge 2.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Array nums, das aus positiven ganzen Zahlen besteht.
Sie können den folgenden Vorgang beliebig oft für das Array ausführen:

Wählen Sie eine ganze Zahl i mit 0 <= i < nums.length - 1 und nums[i] <= nums[i + 1]. Ersetzen Sie das Element nums[i + 1] durch nums[i] + nums[i + 1] und löschen Sie das Element nums[i] aus dem Array.

Gibt den Wert des größten Elements zurück, das Sie möglicherweise im endgültigen Array erhalten können.

Beispiel 1:

Eingabe: nums = [2,3,7,9,3]
Ausgabe: 21
Erläuterung: Wir können die folgenden Operationen auf das Array anwenden:
- Wählen Sie i = 0. Das resultierende Array wird nums = [5,7,9,3] sein.
- Wählen Sie i = 1. Das resultierende Array wird nums = [5,16,3] sein.
- Wählen Sie i = 0. Das resultierende Array wird nums = [21,3] sein.
Das größte Element im endgültigen Array ist 21. Es kann gezeigt werden, dass wir kein größeres Element erhalten können.

Beispiel 2:

Eingabe: nums = [5,3,3]
Ausgabe: 11
Erläuterung: Wir können die folgenden Operationen für das Array ausführen:
- Wählen Sie i = 1. Das resultierende Array wird nums = [5,6] sein.
- Wählen Sie i = 0. Das resultierende Array wird nums = [11] sein.
Das endgültige Array enthält nur ein Element, nämlich 11.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums, die aus positiven Ganzzahlen besteht.
Sie können die folgende Operation auf dem Array jederzeit durchführen:

Wählen Sie eine Ganzzahl I, so dass  0 <= i < nums.length - 1 und nums[i] <= nums[i + 1].Ersetzen Sie das Element nums[i + 1] durch nums[i] + nums[i + 1] und löschen Sie das Element nums[i] aus dem Array.

Geben Sie den Wert des größten Elements zurück, das Sie möglicherweise im endgültigen Array erhalten können.

Beispiel 1:

Eingabe: nums = [2,3,7,9,3]
Ausgabe: 21
Erläuterung: Wir können die folgenden Vorgänge auf das Array anwenden:
- Wählen Sie i = 0. Das resultierende Array ist nums = [5,7,9,3].
- Wählen Sie i = 1. Das resultierende Array ist nums = [5,16,3].
- Wählen Sie i = 0. Das resultierende Array ist nums = [21,3].
Das größte Element im endgültigen Array ist 21. Es kann gezeigt werden, dass wir kein größeres Element erhalten können.

Beispiel 2:

Eingabe: nums = [5,3,3]
Ausgabe: 11
Erläuterung: Wir können die folgenden Operationen im Array ausführen:
- Wählen Sie i = 1. Das resultierende Array ist nums = [5,6].
- Wählen Sie i = 0. Das resultierende Array ist nums = [11].
Es gibt nur ein Element im endgültigen Array, das 11 ist.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums, das aus positiven ganzen Zahlen besteht.
Sie können den folgenden Vorgang beliebig oft für das Array ausführen:

Wählen Sie eine ganze Zahl i mit 0 <= i < nums.length - 1 und nums[i] <= nums[i + 1]. Ersetzen Sie das Element nums[i + 1] durch nums[i] + nums[i + 1] und löschen Sie das Element nums[i] aus dem Array.

Gibt den Wert des größten Elements zurück, das Sie möglicherweise im endgültigen Array erhalten können.

Beispiel 1:

Eingabe: nums = [2,3,7,9,3]
Ausgabe: 21
Erläuterung: Wir können die folgenden Operationen auf das Array anwenden:
- Wählen Sie i = 0. Das resultierende Array wird nums = [5,7,9,3] sein.
- Wählen Sie i = 1. Das resultierende Array wird nums = [5,16,3] sein.
- Wählen Sie i = 0. Das resultierende Array wird nums = [21,3] sein.
Das größte Element im endgültigen Array ist 21. Es kann gezeigt werden, dass wir kein größeres Element erhalten können.

Beispiel 2:

Eingabe: nums = [5,3,3]
Ausgabe: 11
Erläuterung: Wir können die folgenden Operationen für das Array ausführen:
- Wählen Sie i = 1. Das resultierende Array ist nums = [5,6].
- Wählen Sie i = 0. Das resultierende Array wird nums = [11] sein.
Das endgültige Array enthält nur ein Element, nämlich 11.

Einschränkungen:

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


Sie erhalten eine ganze Zahl n. Wir sagen, dass zwei ganze Zahlen x und y ein Primzahlenpaar bilden, wenn:

1 <= x <= y <= n
x + y == n
x und y sind Primzahlen

Gibt die 2D-sortierte Liste der Primzahlpaare [x_i, y_i] zurück. Die Liste sollte in aufsteigender Reihenfolge von x_i sortiert werden. Wenn überhaupt keine Primzahlpaare vorhanden sind, wird ein leeres Array zurückgegeben.
Hinweis: Eine Primzahl ist eine natürliche Zahl größer als 1 mit nur zwei Faktoren, sich selbst und 1.

Beispiel 1:

Eingabe: n = 10
Ausgabe: [[3,7],[5,5]]
Erläuterung: In diesem Beispiel gibt es zwei Primzahlpaare, die die Kriterien erfüllen.
Diese Paare sind [3,7] und [5,5] und wir geben sie in der sortierten Reihenfolge zurück, wie in der Problemstellung beschrieben.

Beispiel 2:

Eingabe: n = 2
Ausgabe: []
Erläuterung: Wir können zeigen, dass es kein Primzahlenpaar gibt, das eine Summe von 2 ergibt, also geben wir ein leeres Array zurück.

Einschränkungen:

1 <= n <= 10^6


In einem Unternehmen gibt es n Mitarbeiter, die von 0 bis n - 1 nummeriert sind. Jeder Mitarbeiter i hat für hours[i] Stunden im Unternehmen gearbeitet.
Das Unternehmen verlangt, dass jeder Mitarbeiter mindestens target Stunden arbeitet.
Du erhältst ein 0-indiziertes Array von nicht-negativen ganzen Zahlen hours der Länge n und eine nicht-negative ganze Zahl target.
Gib die Anzahl der Mitarbeiter zurück, die mindestens target Stunden gearbeitet haben.

Beispiel 1:

Input: hours = [0,1,2,3,4], target = 2
Output: 3
Erklärung: Das Unternehmen möchte, dass jeder Mitarbeiter mindestens 2 Stunden arbeitet.
- Mitarbeiter 0 hat 0 Stunden gearbeitet und das Ziel nicht erreicht.
- Mitarbeiter 1 hat 1 Stunde gearbeitet und das Ziel nicht erreicht.
- Mitarbeiter 2 hat 2 Stunden gearbeitet und das Ziel erreicht.
- Mitarbeiter 3 hat 3 Stunden gearbeitet und das Ziel erreicht.
- Mitarbeiter 4 hat 4 Stunden gearbeitet und das Ziel erreicht.
Es gibt 3 Mitarbeiter, die das Ziel erreicht haben.

Beispiel 2:

Input: hours = [5,1,4,2,2], target = 6
Output: 0
Erklärung: Das Unternehmen möchte, dass jeder Mitarbeiter mindestens 6 Stunden arbeitet.
Es gibt 0 Mitarbeiter, die das Ziel erreicht haben.

Constraints:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

Es gibt n Mitarbeiter in einem Unternehmen, nummeriert von 0 bis n - 1. Jeder Mitarbeiter hat Stunden[i] Stunden im Unternehmen gearbeitet.
Das Unternehmen verlangt von jedem Mitarbeiter, dass er mindestens die Sollstundenzahl leistet.
Sie erhalten ein 0-indiziertes Array nicht negativer Ganzzahlen in Stunden der Länge n und ein nicht negatives Ganzzahlziel.
Gibt die Ganzzahl zurück, die die Anzahl der Mitarbeiter angibt, die mindestens die Zielstunden gearbeitet haben.

Beispiel 1:

Eingabe: hours = [0,1,2,3,4], target = 2
Ausgabe: 3
Erläuterung: Das Unternehmen möchte, dass jeder Mitarbeiter mindestens 2 Stunden arbeitet.
- Mitarbeiter 0 hat 0 Stunden gearbeitet und das Ziel nicht erreicht.
- Mitarbeiter 1 hat 1 Stunde gearbeitet und das Ziel nicht erreicht.
- Mitarbeiter 2 hat 2 Stunden gearbeitet und das Ziel erreicht.
- Mitarbeiter 3 hat 3 Stunden gearbeitet und das Ziel erreicht.
- Mitarbeiter 4 hat 4 Stunden gearbeitet und das Ziel erreicht.
Es gibt 3 Mitarbeiter, die das Ziel erreicht haben.

Beispiel 2:

Eingabe: hours = [5,1,4,2,2], target = 6
Ausgabe: 0
Erläuterung: Das Unternehmen möchte, dass jeder Mitarbeiter mindestens 6 Stunden arbeitet.
Es gibt 0 Mitarbeiter, die das Ziel erreicht haben.

Einschränkungen:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5

In einem Unternehmen gibt es n Mitarbeiter, die von 0 bis n - 1 nummeriert sind. Jeder Mitarbeiter i hat in dem Unternehmen Stunden[i] gearbeitet.
Das Unternehmen verlangt von jedem Mitarbeiter, dass er mindestens Sollstunden arbeitet.
Sie erhalten ein 0-indiziertes Array von nicht-negativen ganzen Zahlen Stunden der Länge n und eine nicht-negative ganze Zahl Ziel.
Geben Sie die ganze Zahl zurück, die die Anzahl der Angestellten angibt, die mindestens die Sollstunden geleistet haben.

Beispiel 1:

Eingabe: hours = [0,1,2,3,4], target = 2
Ausgabe: 3
Erläuterung: Das Unternehmen möchte, dass jeder Mitarbeiter mindestens 2 Stunden arbeitet.
- Mitarbeiter 0 hat 0 Stunden gearbeitet und das Ziel nicht erreicht.
- Mitarbeiter 1 hat 1 Stunde gearbeitet und die Vorgabe nicht erfüllt.
- Mitarbeiter 2 hat 2 Stunden gearbeitet und die Vorgabe erfüllt.
- Mitarbeiter 3 hat 3 Stunden gearbeitet und die Vorgabe erfüllt.
- Mitarbeiter 4 hat 4 Stunden gearbeitet und die Vorgabe erfüllt.
Es gibt 3 Mitarbeiter, die die Vorgabe erfüllt haben.

Beispiel 2:

Eingabe: hours = [5,1,4,2,2], target = 6
Ausgabe: 0
Erläuterung: Das Unternehmen möchte, dass jeder Mitarbeiter mindestens 6 Stunden arbeitet.
Es gibt 0 Mitarbeiter, die das Ziel erreicht haben.

Randbedingungen:

1 <= n == hours.length <= 50
0 <= hours[i], target <= 10^5


Ihre Aufgabe besteht darin, bei drei Strings a, b und c einen String zu finden, der die Mindestlänge hat und alle drei Strings als Teilstrings enthält.
Wenn mehrere solcher Zeichenfolgen vorhanden sind, wird die lexikografisch kleinste Zeichenfolge zurückgegeben.
Gibt eine Zeichenfolge zurück, die die Antwort auf das Problem angibt.
Notizen

Eine Zeichenfolge a ist lexikographisch kleiner als eine Zeichenfolge b (gleicher Länge), wenn Zeichenfolge a an der ersten Position, an der sich a und b unterscheiden, einen Buchstaben enthält, der früher im Alphabet erscheint als der entsprechende Buchstabe in b.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen innerhalb eines Strings.

Beispiel 1:

Eingabe: a = „abc“, b = „bca“, c = „aaa“
Ausgabe: „aaabca“
Erläuterung: Wir zeigen, dass „aaabca“ alle angegebenen Zeichenfolgen enthält: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Es kann gezeigt werden, dass die Länge der resultierenden Zeichenfolge mindestens 6 betragen würde und „aaabca“ die lexikografisch kleinste Zeichenfolge ist.
Beispiel 2:

Eingabe: a = „ab“, b = „ba“, c = „aba“
Ausgabe: „aba“
Erläuterung: Wir zeigen, dass die Zeichenfolge „aba“ alle angegebenen Zeichenfolgen enthält: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Da die Länge von c 3 beträgt, würde die Länge der resultierenden Zeichenfolge mindestens 3 betragen. Es kann gezeigt werden, dass „aba“ die lexikografisch kleinste Zeichenfolge ist.

Einschränkungen:

1 <= a.länge, b.länge, c.länge <= 100
a, b, c bestehen nur aus englischen Kleinbuchstaben.

Bei drei Strings a, b und c besteht Ihre Aufgabe darin, einen String zu finden, der die Mindestlänge hat und alle drei Strings als Teilstrings enthält.
Wenn mehrere solcher Zeichenfolgen vorhanden sind, wird die lexikografisch kleinste Zeichenfolge zurückgegeben.
Gibt eine Zeichenfolge zurück, die die Antwort auf das Problem angibt.
Notizen

Eine Zeichenfolge a ist lexikographisch kleiner als eine Zeichenfolge b (gleicher Länge), wenn Zeichenfolge a an der ersten Position, an der sich a und b unterscheiden, einen Buchstaben enthält, der früher im Alphabet erscheint als der entsprechende Buchstabe in b.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen innerhalb eines Strings.

Beispiel 1:

Eingabe: a = „abc“, b = „bca“, c = „aaa“
Ausgabe: „aaabca“
Erläuterung: Wir zeigen, dass „aaabca“ alle angegebenen Zeichenfolgen enthält: a = ans[2...4], b = ans[3..5], c = ans[0..2]. Es kann gezeigt werden, dass die Länge der resultierenden Zeichenfolge mindestens 6 betragen würde und „aaabca“ die lexikografisch kleinste Zeichenfolge ist.
Beispiel 2:

Eingabe: a = „ab“, b = „ba“, c = „aba“
Ausgabe: „aba“
Erläuterung: Wir zeigen, dass die Zeichenfolge „aba“ alle angegebenen Zeichenfolgen enthält: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Da die Länge von c 3 beträgt, würde die Länge der resultierenden Zeichenfolge mindestens 3 betragen. Es kann gezeigt werden, dass „aba“ die lexikografisch kleinste Zeichenfolge ist.

Einschränkungen:

1 <= a.länge, b.länge, c.länge <= 100
a, b, c bestehen nur aus englischen Kleinbuchstaben.


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

Wählen Sie ein beliebiges Unterarray der Größe k aus dem Array und verringern Sie alle seine Elemente um 1.

Geben Sie „true“ zurück, wenn Sie alle Array-Elemente auf 0 setzen können, andernfalls „false“.
Ein Subarray ist ein zusammenhängender, nicht leerer Teil eines Arrays.

Beispiel 1:

Eingabe: nums = [2,2,3,1,1,0], k = 3
Ausgabe: wahr
Erläuterung: Wir können die folgenden Operationen ausführen:
- Wählen Sie das Subarray [2,2,3]. Das resultierende Array wird nums = [1,1,2,1,1,0] sein.
- Wählen Sie das Subarray [2,1,1]. Das resultierende Array wird nums = [1,1,1,0,0,0] sein.
- Wählen Sie das Subarray [1,1,1]. Das resultierende Array wird nums = [0,0,0,0,0,0] sein.

Beispiel 2:

Eingabe: nums = [1,3,1,1], k = 2
Ausgabe: falsch
Erläuterung: Es ist nicht möglich, alle Array-Elemente auf 0 zu setzen.

Einschränkungen:

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

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

Wählen Sie ein beliebiges Subarray der Größe k aus dem Array und verringern Sie alle seine Elemente um 1.

Geben Sie true zurück, wenn Sie alle Elemente des Arrays gleich 0 machen können, oder andernfalls false.
Ein Subarray ist ein zusammenhängender, nicht leerer Teil eines Arrays.

Beispiel 1:

Eingabe: nums = [2,2,3,1,1,0], k = 3
Ausgabe: wahr
Erläuterung: Wir können die folgenden Operationen durchführen:
- Wähle das Subarray [2,2,3]. Das resultierende Array ist nums = [1,1,2,1,1,0].
- Wählen Sie das Subarray [2,1,1]. Das resultierende Array wird nums = [1,1,1,0,0,0] sein.
- Wählen Sie das Subarray [1,1,1]. Der resultierende Bereich ist nums = [0,0,0,0,0,0].

Beispiel 2:

Eingabe: nums = [1,3,1,1], k = 2
Ausgabe: false
Erläuterung: Es ist nicht möglich, alle Elemente der Matrix gleich 0 zu machen.

Randbedingungen:

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


Partitionieren Sie s bei gegebener Zeichenfolge s und einer ganzen Zahl k in k Teilzeichenfolgen, sodass die Summe der Anzahl der Buchstabenänderungen, die erforderlich sind, um jede Teilzeichenfolge in ein Halbpalindrom umzuwandeln, minimiert wird.
Gibt eine Ganzzahl zurück, die die Mindestanzahl der erforderlichen Buchstabenänderungen angibt.
Notizen

Ein String ist ein Palindrom, wenn er von links nach rechts und von rechts nach links auf die gleiche Weise gelesen werden kann.
Eine Zeichenfolge mit einer Länge von len wird als Halbpalindrom betrachtet, wenn es eine positive ganze Zahl d gibt, so dass 1 <= d < len und len % d == 0, und wenn wir Indizes nehmen, die das gleiche Modulo von d haben, sie ein Palindrom bilden. Beispielsweise sind „aa“, „aba“, „adbgad“ und „abab“ Halbpalindrome, „a“, „ab“ und „abca“ jedoch nicht.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen innerhalb eines Strings.

Beispiel 1:

Eingabe: s = „abcac“, k = 2
Ausgabe: 1
Erläuterung: Wir können s in die Teilzeichenfolgen „ab“ und „cac“ unterteilen. Die Zeichenfolge „cac“ ist bereits ein Halbpalindrom. Wenn wir „ab“ in „aa“ ändern, wird es zu einem Halbpalindrom mit d = 1.
Es kann gezeigt werden, dass es keine Möglichkeit gibt, die Zeichenfolge „abcac“ in zwei Halbpalindrom-Teilzeichenfolgen zu unterteilen. Daher wäre die Antwort mindestens 1.
Beispiel 2:

Eingabe: s = „abcdef“, k = 2
Ausgabe: 2
Erläuterung: Wir können es in die Teilzeichenfolgen „abc“ und „def“ unterteilen. Jeder der Teilstrings „abc“ und „def“ erfordert eine Änderung, um zu einem Halbpalindrom zu werden. Wir benötigen also insgesamt zwei Änderungen, um alle Teilstrings zu Halbpalindromen zu machen.
Es kann gezeigt werden, dass wir die gegebene Zeichenfolge nicht so in zwei Teilzeichenfolgen aufteilen können, dass weniger als zwei Änderungen erforderlich wären.
Beispiel 3:

Eingabe: s = „aabbaa“, k = 3
Ausgabe: 0
Erläuterung: Wir können es in die Teilzeichenfolgen „aa“, „bb“ und „aa“ unterteilen.
Die Saiten „aa“ und „bb“ sind bereits Halbpalindrome. Somit ist die Antwort Null.

Einschränkungen:

2 <= s.length <= 200
1 <= k <= s.length / 2
s besteht nur aus englischen Kleinbuchstaben.

Gegeben eine Zeichenkette s und eine ganze Zahl k, teile s in k Teilstrings, sodass die Summe der notwendigen Buchstabenänderungen, um jeden Teilstring in ein Semi-Palindrom zu verwandeln, minimiert wird.
Gib eine ganze Zahl zurück, die die minimale Anzahl der erforderlichen Buchstabenänderungen angibt.
Hinweise:

Eine Zeichenkette ist ein Palindrom, wenn sie von links nach rechts und von rechts nach links gleich gelesen werden kann.
Eine Zeichenkette mit der Länge len gilt als Semi-Palindrom, wenn es eine positive ganze Zahl d gibt, sodass 1 <= d < len und len % d == 0, und wenn wir Indizes nehmen, die dasselbe Modulo von d haben, bilden sie ein Palindrom. Zum Beispiel sind "aa", "aba", "adbgad" und "abab" Semi-Palindrome, während "a", "ab" und "abca" es nicht sind.
Ein Teilstring ist eine zusammenhängende Zeichenfolge innerhalb einer Zeichenkette.

Beispiel 1:

Eingabe: s = "abcac", k = 2
Ausgabe: 1
Erklärung: Wir können s in die Teilstrings "ab" und "cac" unterteilen. Der String "cac" ist bereits ein Semi-Palindrom. Wenn wir "ab" in "aa" ändern, wird es ein Semi-Palindrom mit d = 1.
Es kann gezeigt werden, dass es keine Möglichkeit gibt, die Zeichenkette "abcac" in zwei Semi-Palindrom-Teilstrings zu unterteilen. Daher wäre die Antwort mindestens 1.
Beispiel 2:

Eingabe: s = "abcdef", k = 2
Ausgabe: 2
Erklärung: Wir können es in die Teilstrings "abc" und "def" unterteilen. Jeder der Teilstrings "abc" und "def" erfordert eine Änderung, um ein Semi-Palindrom zu werden, daher benötigen wir insgesamt 2 Änderungen, um alle Teilstrings zu Semi-Palindromen zu machen.
Es kann gezeigt werden, dass wir die gegebene Zeichenkette nicht in zwei Teilstrings unterteilen können, sodass weniger als 2 Änderungen erforderlich wären.
Beispiel 3:

Eingabe: s = "aabbaa", k = 3
Ausgabe: 0
Erklärung: Wir können es in die Teilstrings "aa", "bb" und "aa" unterteilen.
Die Zeichenketten "aa" und "bb" sind bereits Semi-Palindrome. Daher ist die Antwort null.

Einschränkungen:

2 <= s.length <= 200
1 <= k <= s.length / 2
s besteht nur aus kleinen englischen Buchstaben.


Teilen Sie bei einem gegebenen Array von Zeichenfolgen und einem Zeichentrennzeichen jede Zeichenfolge durch ein Trennzeichen in Zeichenfolgen auf.
Gibt ein Array von Zeichenfolgen zurück, das die neuen Zeichenfolgen enthält, die nach den Teilungen gebildet wurden, mit Ausnahme leerer Zeichenfolgen.
Notizen

Das Trennzeichen wird verwendet, um zu bestimmen, wo die Aufteilung erfolgen soll, es ist jedoch nicht in den resultierenden Zeichenfolgen enthalten.
Eine Aufteilung kann zu mehr als zwei Zeichenfolgen führen.
Die resultierenden Zeichenfolgen müssen dieselbe Reihenfolge beibehalten, wie sie ursprünglich angegeben wurden.

Beispiel 1:

Eingabe: Zeichenfolgen = [„eins.zwei.drei“, „vier.fünf“, „sechs“], Trennzeichen = „.“
Ausgabe: [„eins“, „zwei“, „drei“, „vier“, „fünf“, „sechs“]
Erläuterung: In diesem Beispiel teilen wir wie folgt auf:

„eins.zwei.drei“ zerfällt in „eins“, „zwei“, „drei“
„four.fünf“ zerfällt in „vier“, „fünf“
„six“ spaltet sich in „six“

Daher ist das resultierende Array [„eins“, „zwei“, „drei“, „vier“, „fünf“, „sechs“].
Beispiel 2:

Eingabe: Zeichenfolgen = ["$einfach$", "$problem$"], Trennzeichen = "$"
Ausgabe: [„einfach“, „problem“]
Erläuterung: In diesem Beispiel teilen wir wie folgt auf:

„$easy$“ wird in „einfach“ aufgeteilt (ohne leere Zeichenfolgen)
„$problem$“ wird in „problem“ aufgeteilt (ohne leere Zeichenfolgen)

Daher ist das resultierende Array [„einfach“, „problem“].

Beispiel 3:

Eingabe: Zeichenfolgen= ["|||"], Trennzeichen = "|"
Ausgabe: []
Erläuterung: In diesem Beispiel ist die resultierende Aufteilung von „|||“ enthält nur leere Zeichenfolgen, daher geben wir ein leeres Array [] zurück.

Einschränkungen:

1 <= Zeichenfolgen.Länge <= 100
1 <= Zeichenfolgen[i].Länge <= 20
Zeichen in Wörtern[i] sind entweder englische Kleinbuchstaben oder Zeichen aus der Zeichenfolge „.,|$#@“ (ohne Anführungszeichen).
Trennzeichen ist ein Zeichen aus der Zeichenfolge „.,|$#@“ (ohne Anführungszeichen)

Given an array of strings words and a character separator, split each string in words by separator.
Return an array of strings containing the new strings formed after the splits, excluding empty strings.
Notes

separator is used to determine where the split should occur, but it is not included as part of the resulting strings.
A split may result in more than two strings.
The resulting strings must maintain the same order as they were initially given.

Example 1:

Input: words = ["one.two.three","four.five","six"], separator = "."
Output: ["one","two","three","four","five","six"]
Explanation: In this example we split as follows:

"one.two.three" splits into "one", "two", "three"
"four.five" splits into "four", "five"
"six" splits into "six"

Hence, the resulting array is ["one","two","three","four","five","six"].
Example 2:

Input: words = ["$easy$","$problem$"], separator = "$"
Output: ["easy","problem"]
Explanation: In this example we split as follows:

"$easy$" splits into "easy" (excluding empty strings)
"$problem$" splits into "problem" (excluding empty strings)

Hence, the resulting array is ["easy","problem"].

Example 3:

Input: words = ["|||"], separator = "|"
Output: []
Explanation: In this example the resulting split of "|||" will contain only empty strings, so we return an empty array [].

Constraints:

1 <= words.length <= 100
1 <= words[i].length <= 20
characters in words[i] are either lowercase English letters or characters from the string ".,|$#@" (excluding the quotes)
separator is a character from the string ".,|$#@" (excluding the quotes)

Teilen Sie bei einem gegebenen Array von Zeichenfolgen und einem Zeichentrennzeichen jede Zeichenfolge durch ein Trennzeichen in Zeichenfolgen auf.
Gibt ein Array von Zeichenfolgen zurück, das die neuen Zeichenfolgen enthält, die nach den Teilungen gebildet wurden, mit Ausnahme leerer Zeichenfolgen.
Notizen

Das Trennzeichen wird verwendet, um zu bestimmen, wo die Aufteilung erfolgen soll, es ist jedoch nicht in den resultierenden Zeichenfolgen enthalten.
Eine Aufteilung kann zu mehr als zwei Zeichenfolgen führen.
Die resultierenden Zeichenfolgen müssen dieselbe Reihenfolge beibehalten, wie sie ursprünglich angegeben wurden.

Beispiel 1:

Eingabe: Zeichenfolgen = [„eins.zwei.drei“, „vier.fünf“, „sechs“], Trennzeichen = „.“
Ausgabe: [„eins“, „zwei“, „drei“, „vier“, „fünf“, „sechs“]
Erläuterung: In diesem Beispiel teilen wir wie folgt auf:

„eins.zwei.drei“wird aufgeteilt in „eins“, „zwei“, „drei“
„four.fünf“ wird aufgeteilt in „vier“, „fünf“
„six“ wird aufgeteilt in „six“

Daher ist das resultierende Array [„eins“, „zwei“, „drei“, „vier“, „fünf“, „sechs“].
Beispiel 2:

Eingabe: Zeichenfolgen = [„$einfach$", „$problem$"], Trennzeichen = „$"
Ausgabe: [„einfach“, „problem“]
Erläuterung: In diesem Beispiel teilen wir wie folgt auf:

„$easy$“ wird in „easy“ aufgeteilt (ohne leere Zeichenfolgen)
„$problem$“ wird in „problem“ aufgeteilt (ohne leere Zeichenfolgen)

Daher ist das resultierende Array [„einfach“, „problem“].

Beispiel 3:

Eingabe: Zeichenfolgen= [„|||"], Trennzeichen = „|"
Ausgabe: []
Erläuterung: In diesem Beispiel ist die resultierende Aufteilung von „|||“ enthält nur leere Zeichenfolgen, daher geben wir ein leeres Array [] zurück.

Einschränkungen:

1 <= Zeichenfolgen.Länge <= 100
1 <= Zeichenfolgen[i].Länge <= 20
Zeichen in Wörtern[i] sind entweder englische Kleinbuchstaben oder Zeichen aus der Zeichenfolge „.,|$#@“ (ohne Anführungszeichen).
Trennzeichen ist ein Zeichen aus der Zeichenfolge „.,|$#@“ (ohne Anführungszeichen)


Gegeben sind zwei positive ganze Zahlen n und x.
Die Anzahl der Möglichkeiten, n zurückzugeben, kann als Summe der x^ten Potenz eindeutiger positiver Ganzzahlen ausgedrückt werden, mit anderen Worten, als Anzahl der Mengen eindeutiger Ganzzahlen [n_1, n_2, ..., n_k], wobei n = n_1^ x + n_2^x + ... + n_k^x.
Da das Ergebnis sehr groß sein kann, geben Sie es modulo 10^9 + 7 zurück.
Wenn beispielsweise n = 160 und x = 3, ist eine Möglichkeit, n auszudrücken, n = 2^3 + 3^3 + 5^3.

Beispiel 1:

Eingabe: n = 10, x = 2
Ausgabe: 1
Erläuterung: Wir können n wie folgt ausdrücken: n = 3^2 + 1^2 = 10.
Es kann gezeigt werden, dass dies die einzige Möglichkeit ist, 10 als Summe der 2. Potenz eindeutiger ganzer Zahlen auszudrücken.

Beispiel 2:

Eingabe: n = 4, x = 1
Ausgabe: 2
Erläuterung: Wir können n auf folgende Weise ausdrücken:
- n = 4^1 = 4.
- n = 3^1 + 1^1 = 4.

Einschränkungen:

1 <= n <= 300
1 <= x <= 5


Teilen Sie eine binäre Zeichenkette s in eine oder mehrere Teilzeichenketten auf, so dass jede Teilzeichenkette schön ist.
Eine Zeichenkette ist schön, wenn:

Sie enthält keine führenden Nullen.
Sie ist die binäre Darstellung einer Zahl, die eine Potenz von 5 ist.

Gib die minimale Anzahl von Teilzeichenketten in einer solchen Partition zurück. Wenn es unmöglich ist, die Zeichenkette s in schöne Teilzeichenketten zu partitionieren, wird -1 zurückgegeben.
Eine Teilzeichenkette ist eine zusammenhängende Folge von Zeichen in einer Zeichenkette.

Beispiel 1:

Eingabe: s = "1011"
Ausgabe: 2
Erläuterung: Wir können die gegebene Zeichenkette in [„101“, „1“] zerlegen.
- Die Zeichenkette „101“ enthält keine führenden Nullen und ist die binäre Darstellung der ganzen Zahl 5^1 = 5.
- Die Zeichenkette „1“ enthält keine führenden Nullen und ist die binäre Darstellung der ganzen Zahl 5^0 = 1.
Es kann gezeigt werden, dass 2 die minimale Anzahl von schönen Teilzeichenfolgen ist, in die s unterteilt werden kann.

Beispiel 2:

Eingabe: s = "111"
Ausgabe: 3
Erläuterung: Wir können die gegebene Zeichenkette in [„1“, „1“, „1“] zerlegen.
- Die Zeichenkette „1“ enthält keine führenden Nullen und ist die binäre Darstellung der ganzen Zahl 5^0 = 1.
Es kann gezeigt werden, dass 3 die minimale Anzahl von schönen Teilzeichenfolgen ist, in die s unterteilt werden kann.

Beispiel 3:

Eingabe: s = "0"
Ausgabe: -1
Erläuterung: Wir können die gegebene Zeichenkette nicht in schöne Teilstrings aufteilen.

Constraints:

1 <= s.length <= 15
s[i] is either '0' or '1'.

Partitionieren Sie eine gegebene Binärzeichenfolge s in eine oder mehrere Teilzeichenfolgen, sodass jede Teilzeichenfolge schön ist.
Eine Saite ist schön, wenn:

Es enthält keine führenden Nullen.
Es ist die binäre Darstellung einer Zahl, die eine Potenz von 5 ist.

Gibt die minimale Anzahl von Teilzeichenfolgen in einer solchen Partition zurück. Wenn es unmöglich ist, die Zeichenfolge s in schöne Teilzeichenfolgen zu unterteilen, geben Sie -1 zurück.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen in einem String.

Beispiel 1:

Eingabe: s = „1011“
Ausgabe: 2
Erläuterung: Wir können die angegebene Zeichenfolge in [„101“, „1“] paritieren.
- Die Zeichenfolge „101“ enthält keine führenden Nullen und ist die binäre Darstellung der Ganzzahl 5^1 = 5.
- Die Zeichenfolge „1“ enthält keine führenden Nullen und ist die binäre Darstellung der Ganzzahl 5^0 = 1.
Es kann gezeigt werden, dass 2 die minimale Anzahl schöner Teilzeichenfolgen ist, in die s unterteilt werden kann.

Beispiel 2:

Eingabe: s = „111“
Ausgabe: 3
Erläuterung: Wir können die gegebene Zeichenfolge in [„1“, „1“, „1“] paritieren.
- Die Zeichenfolge „1“ enthält keine führenden Nullen und ist die binäre Darstellung der Ganzzahl 5^0 = 1.
Es kann gezeigt werden, dass 3 die minimale Anzahl schöner Teilzeichenfolgen ist, in die s unterteilt werden kann.

Beispiel 3:

Eingabe: s = „0“
Ausgabe: -1
Erläuterung: Wir können die angegebene Zeichenfolge nicht in schöne Teilzeichenfolgen unterteilen.

Einschränkungen:

1 <= s.length <= 15
s[i] ist entweder '0' oder '1'.


Sie erhalten ein String und ein Array verbotener Zeichenfolgen.
Eine Zeichenfolge wird als gültig bezeichnet, wenn keine ihrer Teilzeichenfolgen in der verbotenen Zeichenfolge vorhanden ist.
Gibt die Länge des längsten gültigen Teilstrings des Stringworts zurück.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen in einem String, möglicherweise leer.

Beispiel 1:

Eingabe: Wort = „cbaaaabc“, verboten = [„aaa“, „cb“]
Ausgabe: 4
Erläuterung: Es gibt 11 gültige Teilzeichenfolgen im Wort: „c“, „b“, „a“, „ba“, „aa“, „bc“, „baa“, „aab“, „ab“, „abc“ und „aabc“. Die Länge des längsten gültigen Teilstrings beträgt 4.
Es lässt sich zeigen, dass alle anderen Teilstrings entweder „aaa“ oder „cb“ als Teilstring enthalten.
Beispiel 2:

Eingabe: Wort = „Leetcode“, verboten = [„de“, „le“, „e“]
Ausgabe: 4
Erläuterung: Es gibt 11 gültige Teilzeichenfolgen im Wort: „l“, „t“, „c“, „o“, „d“, „tc“, „co“, „od“, „tco“, „cod“, und „tcod“. Die Länge des längsten gültigen Teilstrings beträgt 4.
Es lässt sich zeigen, dass alle anderen Teilstrings entweder „de“, „le“ oder „e“ als Teilstring enthalten.

Einschränkungen:

1 <= Länge des Wortes <= 10^5
Das Wort besteht nur aus englischen Kleinbuchstaben.
1 <= Länge der verbotenen Zeichenketten <= 10^5
1 <= Länge von verboten[i] <= 10
verboten[i] besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein Zeichenfolgenwort und ein Array von Zeichenfolgen, die verboten sind.
Ein String wird als gültig bezeichnet, wenn keiner seiner Teilstrings in forbidden vorhanden ist.
Gibt die Länge der längsten gültigen Teilzeichenfolge des Zeichenfolgenworts zurück.
Eine Teilzeichenfolge ist eine zusammenhängende Folge von Zeichen in einer Zeichenfolge, die möglicherweise leer ist.

Beispiel 1:

Eingabe: word = "cbaaaabc", forbidden = ["aaa","cb"]
Ausgang: 4
Erklärung: Es gibt 11 gültige Teilzeichenfolgen in Word: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" und "aabc". Die Länge der längsten gültigen Teilzeichenfolge beträgt 4.
Es kann gezeigt werden, dass alle anderen Teilstrings entweder "aaa" oder "cb" als Teilstring enthalten.
Beispiel 2:

Eingabe: word = "leetcode", forbidden = ["de","le","e"]
Ausgang: 4
Erklärung: Es gibt 11 gültige Teilzeichenfolgen in Word: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod" und "tcod". Die Länge der längsten gültigen Teilzeichenfolge beträgt 4.
Es kann gezeigt werden, dass alle anderen Teilstrings entweder "de", "le" oder "e" als Teilstring enthalten.

Zwänge:

1 <= word.length <= 10^5
word besteht nur aus englischen Kleinbuchstaben.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein String und ein Array verbotener Zeichenfolgen.
Eine Zeichenfolge wird als gültig bezeichnet, wenn keine ihrer Teilzeichenfolgen in der verbotenen Zeichenfolge vorhanden ist.
Gibt die Länge des längsten gültigen Teilstrings des des Strings zurück.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen in einem String, möglicherweise leer.

Beispiel 1:

Eingabe: Wort = „cbaaaabc“, verboten = [„aaa“, „cb“]
Ausgabe: 4
Erläuterung: Es gibt 11 gültige Teilstrings im Wort: „c“, „b“, „a“, „ba“, „aa“, „bc“, „baa“, „aab“, „ab“, „abc“ und „aabc“. Die Länge des längsten gültigen Teilstrings beträgt 4.
Es lässt sich zeigen, dass alle anderen Teilstrings entweder „aaa“ oder „cb“ als Teilstring enthalten.
Beispiel 2:

Eingabe: Wort = „Leetcode“, verboten = [„de“, „le“, „e“]
Ausgabe: 4
Erläuterung: Es gibt 11 gültige Teilstrings im Wort: „l“, „t“, „c“, „o“, „d“, „tc“, „co“, „od“, „tco“, „cod“, und „tcod“. Die Länge des längsten gültigen Teilstrings beträgt 4.
Es lässt sich zeigen, dass alle anderen Teilstrings entweder „de“, „le“ oder „e“ als Teilstring enthalten.

Einschränkungen:

1 <= Länge des Wortes <= 10^5
Das Wort besteht nur aus englischen Kleinbuchstaben.
1 <= Länge der verbotenen String <= 10^5
1 <= Länge von verboten[i] <= 10
verboten[i] besteht nur aus englischen Kleinbuchstaben.


Ihre Laptop-Tastatur ist fehlerhaft und jedes Mal, wenn Sie ein „i“ darauf eingeben, wird die von Ihnen geschriebene Zeichenfolge umgekehrt. Die Eingabe anderer Zeichen funktioniert wie erwartet.
Sie erhalten eine mit 0 indizierte Zeichenfolge s und geben jedes Zeichen von s über Ihre fehlerhafte Tastatur ein.
Geben Sie die letzte Zeichenfolge zurück, die auf Ihrem Laptop-Bildschirm angezeigt wird.

Beispiel 1:

Eingabe: s = „string“
Ausgabe: „rtsng“
Erläuterung:
Nach Eingabe des ersten Zeichens lautet der Text auf dem Bildschirm „s“.
Nach dem zweiten Zeichen lautet der Text „st“.
Nach dem dritten Zeichen lautet der Text „str“.
Da das vierte Zeichen ein „i“ ist, wird der Text umgekehrt und zu „rts“.
Nach dem fünften Zeichen lautet der Text „rtsn“.
Nach dem sechsten Zeichen lautet der Text „rtsng“.
Daher geben wir „rtsng“ zurück.

Beispiel 2:

Eingabe: s = „poiinter“
Ausgabe: „ponter“
Erläuterung:
Nach dem ersten Zeichen lautet der Text auf dem Bildschirm „p“.
Nach dem zweiten Zeichen lautet der Text „po“.
Da das dritte von Ihnen eingegebene Zeichen ein „i“ ist, wird der Text umgekehrt und zu „op“.
Da das vierte Zeichen, das Sie eingeben, ein „i“ ist, wird der Text umgekehrt und zu „po“.
Nach dem fünften Zeichen lautet der Text „pon“.
Nach dem sechsten Zeichen lautet der Text „pont“.
Nach dem siebten Zeichen lautet der Text „ponte“.
Nach dem achten Zeichen lautet der Text „ponter“.
Deshalb geben wir „ponter“ zurück.

Einschränkungen:

1 <= s.length <= 100
s besteht aus englischen Kleinbuchstaben.
s[0] != 'i'

Ihre Laptop-Tastatur ist fehlerhaft und jedes Mal, wenn Sie ein „i“ darauf eingeben, wird die von Ihnen geschriebene Zeichenfolge umgekehrt. Die Eingabe anderer Zeichen funktioniert wie erwartet.
Sie erhalten eine mit 0 indizierte Zeichenfolge s und geben jedes Zeichen von s über Ihre fehlerhafte Tastatur ein.
Geben Sie die letzte Zeichenfolge zurück, die auf Ihrem Laptop-Bildschirm angezeigt wird.

Beispiel 1:

Eingabe: s = „string“
Ausgabe: „rtsng“
Erläuterung:
Nach Eingabe des ersten Zeichens lautet der Text auf dem Bildschirm „s“.
Nach dem zweiten Zeichen lautet der Text „st“.
Nach dem dritten Zeichen lautet der Text „str“.
Da das vierte Zeichen ein „i“ ist, wird der Text umgekehrt und zu „rts“.
Nach dem fünften Zeichen lautet der Text „rtsn“.
Nach dem sechsten Zeichen lautet der Text „rtsng“.
Daher geben wir „rtsng“ zurück.

Beispiel 2:

Eingabe: s = "ponter"
Ausgabe: "ponter"
Erläuterung:
Nach dem ersten Zeichen lautet der Text auf dem Bildschirm „p“.
Nach dem zweiten Zeichen lautet der Text „po“.
Da das dritte von Ihnen eingegebene Zeichen ein „i“ ist, wird der Text umgekehrt und zu „op“.
Da das vierte Zeichen, das Sie eingeben, ein „i“ ist, wird der Text umgekehrt und zu „po“.
Nach dem fünften Zeichen lautet der Text „pon“.
Nach dem sechsten Zeichen lautet der Text „pont“.
Nach dem siebten Zeichen lautet der Text „ponte“.
Nach dem achten Zeichen lautet der Text „ponter“.
Deshalb geben wir „ponter“ zurück.

Einschränkungen:

1 <= s.length <= 100
s besteht aus englischen Kleinbuchstaben.
s[0] != 'i'


Bei einer 0-indizierten Zeichenfolge s wird s permutiert, um eine neue Zeichenfolge t zu erhalten, sodass Folgendes gilt:

Alle Konsonanten bleiben an ihrem ursprünglichen Platz. Formaler, wenn es einen Index i mit 0 <= i < s.length gibt, so dass s[i] ein Konsonant ist, dann ist t[i] = s[i].
Die Vokale müssen in der nicht absteigenden Reihenfolge ihrer ASCII-Werte sortiert werden. Formaler ausgedrückt darf t[i] für Paare von Indizes i, j mit 0 <= i < j < s.length, so dass s[i] und s[j] Vokale sind, keinen höheren ASCII-Wert als t[j] haben.

Geben Sie die resultierende Zeichenfolge zurück.
Die Vokale sind 'a', 'e', 'i', 'o' und 'u' und können in Klein- oder Großbuchstaben erscheinen. Konsonanten umfassen alle Buchstaben, die keine Vokale sind.

Beispiel 1:

Eingabe: s = "lEetcOde"
Ausgang: "lEOtcede"
Erklärung: 'E', 'O' und 'e' sind die Vokale in s; 'l', 't', 'c' und 'd' sind alle Konsonanten. Die Vokale werden nach ihren ASCII-Werten sortiert und die Konsonanten bleiben an den gleichen Stellen.

Beispiel 2:

Eingang: s = "lYmpH"
Ausgang: "lYmpH"
Erklärung: Es gibt keine Vokale in s (alle Zeichen in s sind Konsonanten), daher geben wir "lYmpH" zurück.

Zwänge:

1 <= s.length <= 10^5
s besteht nur aus Buchstaben des englischen Alphabets in Groß- und Kleinbuchstaben.

Permutieren Sie bei gegebener 0-indizierter Zeichenfolge s, um eine neue Zeichenfolge t zu erhalten, sodass:

Alle Konsonanten bleiben an ihrem ursprünglichen Platz. Formeller ausgedrückt: Wenn es einen Index i mit 0 <= i < s.length gibt, sodass s[i] ein Konsonant ist, dann ist t[i] = s[i].
Die Vokale müssen in nicht absteigender Reihenfolge ihrer ASCII-Werte sortiert werden. Formaler ausgedrückt: Für Indexpaare i, j mit 0 <= i < j < s.length, sodass s[i] und s[j] Vokale sind, darf t[i] keinen höheren ASCII-Wert haben als t[ J].

Gibt die resultierende Zeichenfolge zurück.
Die Vokale sind „a“, „e“, „i“, „o“ und „u“ und können in Klein- oder Großbuchstaben geschrieben werden. Zu den Konsonanten zählen alle Buchstaben, die keine Vokale sind.

Beispiel 1:

Eingabe: s = „lEetcOde“
Ausgabe: „lEOtcede“
Erklärung: „E“, „O“ und „e“ sind die Vokale in s; „l“, „t“, „c“ und „d“ sind alles Konsonanten. Die Vokale werden nach ihren ASCII-Werten sortiert und die Konsonanten bleiben an den gleichen Stellen.

Beispiel 2:

Eingabe: s = „lYmpH“
Ausgabe: „lYmpH“
Erläuterung: Es gibt keine Vokale in s (alle Zeichen in s sind Konsonanten), daher geben wir „lYmpH“ zurück.

Einschränkungen:

1 <= s.length <= 10^5
s besteht nur aus Buchstaben des englischen Alphabets in Groß- und Kleinschreibung.


Ein Element x eines ganzzahligen Arrays arr der Länge m ist dominant, wenn freq(x) * 2 > m, wobei freq(x) die Anzahl des Vorkommens von x in arr ist. Beachten Sie, dass diese Definition impliziert, dass arr höchstens ein dominantes Element haben kann.
Sie erhalten ein 0-indiziertes Ganzzahlarray der Länge n mit einem dominanten Element.
Sie können nums an einem Index i in zwei Arrays nums[0, ..., i] und nums[i + 1, ..., n - 1] aufteilen, aber die Aufteilung ist nur gültig, wenn:

0 <= i < n - 1
nums[0, ..., i] und nums[i + 1, ..., n - 1] haben das gleiche dominante Element.

Hier bezeichnet nums[i, ..., j] das Subarray von nums, das bei Index i beginnt und bei Index j endet, wobei beide Enden inklusive sind. Insbesondere wenn j < i, dann bezeichnet nums[i, ..., j] ein leeres Subarray.
Gibt den minimalen Index einer gültigen Aufteilung zurück. Wenn keine gültige Aufteilung vorhanden ist, geben Sie -1 zurück.

Beispiel 1:

Eingabe: nums = [1,2,2,2]
Ausgabe: 2
Erläuterung: Wir können das Array an Index 2 teilen, um die Arrays [1,2,2] und [2] zu erhalten.
Im Array [1,2,2] ist Element 2 dominant, da es zweimal im Array vorkommt und 2 * 2 > 3 ist.
In Array [2] ist Element 2 dominant, da es einmal im Array vorkommt und 1 * 2 > 1 ist.
Sowohl [1,2,2] als auch [2] haben dasselbe dominante Element wie Nums, daher handelt es sich um eine gültige Aufteilung.
Es kann gezeigt werden, dass Index 2 der minimale Index einer gültigen Aufteilung ist.
Beispiel 2:

Eingabe: nums = [2,1,3,1,1,1,7,1,2,1]
Ausgabe: 4
Erläuterung: Wir können das Array bei Index 4 teilen, um die Arrays [2,1,3,1,1] und [1,7,1,2,1] zu erhalten.
Im Array [2,1,3,1,1] ist Element 1 dominant, da es dreimal im Array vorkommt und 3 * 2 > 5 ist.
Im Array [1,7,1,2,1] ist Element 1 dominant, da es dreimal im Array vorkommt und 3 * 2 > 5 ist.
Sowohl [2,1,3,1,1] als auch [1,7,1,2,1] haben das gleiche dominante Element wie Nums, daher ist dies eine gültige Aufteilung.
Es kann gezeigt werden, dass Index 4 der minimale Index einer gültigen Aufteilung ist.
Beispiel 3:

Eingabe: nums = [3,3,3,3,7,2,2]
Ausgabe: -1
Erläuterung: Es kann gezeigt werden, dass keine gültige Aufteilung vorliegt.

Einschränkungen:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums hat genau ein dominantes Element.

Ein Element x eines ganzzahligen Arrays arr der Länge m ist dominant, wenn freq(x) * 2 > m ist, wobei freq(x) die Anzahl der Vorkommen von x in arr ist. Beachten Sie, dass diese Definition impliziert, dass arr höchstens ein dominantes Element haben kann.
Sie erhalten ein 0-indiziertes ganzzahliges Array nums der Länge n mit einem dominanten Element.
Sie können die Anzahl bei einem Index i in zwei Arrays aufteilen: nums[0, ..., i] und nums[i + 1, ..., n - 1], aber die Aufteilung ist nur gültig, wenn:

0 <= i < n - 1
nums[0, ..., i] und nums[i + 1, ..., n - 1] haben das gleiche dominante Element.

Hier bezeichnet nums[i, ..., j] das Unterarray von nums, das bei Index i beginnt und bei Index j endet, wobei beide Enden inklusiv sind. Insbesondere wenn j < i ist, dann bezeichnet nums[i, ..., j] ein leeres Subarray.
Gibt den minimalen Index einer gültigen Teilung zurück. Wenn keine gültige Teilung vorhanden ist, wird -1 zurückgegeben.

Beispiel 1:

Eingabe: nums = [1,2,2,2]
Ausgang: 2
Erklärung: Wir können das Array bei Index 2 aufteilen, um die Arrays [1,2,2] und [2] zu erhalten.
Im Array [1,2,2] ist Element 2 dominant, da es zweimal im Array und 2 * 2 > 3 vorkommt.
Im Array [2] ist Element 2 dominant, da es einmal im Array und 1 * 2 > 1 vorkommt.
Sowohl [1,2,2] als auch [2] haben das gleiche dominante Element wie Zahlen, daher handelt es sich um eine gültige Aufteilung.
Es kann gezeigt werden, dass Index 2 der Mindestindex eines gültigen Splits ist.
Beispiel 2:

Eingabe: nums = [2,1,3,1,1,1,7,1,2,1]
Ausgang: 4
Erklärung: Wir können das Array bei Index 4 aufteilen, um die Arrays [2,1,3,1,1] und [1,7,1,2,1] zu erhalten.
Im Array [2,1,3,1,1] ist Element 1 dominant, da es dreimal im Array und 3 * 2 > 5 vorkommt.
Im Array [1,7,1,2,1] ist Element 1 dominant, da es dreimal im Array und 3 * 2 > 5 vorkommt.
Sowohl [2,1,3,1,1] als auch [1,7,1,2,1] haben das gleiche dominante Element wie Zahlen, daher handelt es sich um eine gültige Aufteilung.
Es kann gezeigt werden, dass Index 4 der Mindestindex eines gültigen Splits ist.
Beispiel 3:

Eingabe: nums = [3,3,3,3,7,2,2]
Ausgang: -1
Erklärung: Es kann gezeigt werden, dass es keinen gültigen Split gibt.

Zwänge:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums hat genau ein dominantes Element.


Sie erhalten ein 0-indiziertes Array nums und eine nicht negative Ganzzahl k.
In einem Vorgang können Sie Folgendes tun:

Wählen Sie einen Index i, der noch nie zuvor ausgewählt wurde, aus dem Bereich [0, nums.length - 1].
Ersetzen Sie nums[i] durch eine beliebige ganze Zahl aus dem Bereich [nums[i] - k, nums[i] + k].

Das Schöne am Array ist die Länge der längsten Teilsequenz, die aus gleichen Elementen besteht.
Gibt die maximal mögliche Schönheit der Array-Nummern zurück, nachdem die Operation beliebig oft angewendet wurde.
Beachten Sie, dass Sie den Vorgang nur einmal auf jeden Index anwenden können.
Eine Teilsequenz eines Arrays ist ein neues Array, das aus dem ursprünglichen Array generiert wird, indem einige Elemente (möglicherweise keines) gelöscht werden, ohne die Reihenfolge der verbleibenden Elemente zu ändern.

Beispiel 1:

Eingabe: nums = [4,6,1,2], k = 2
Ausgabe: 3
Erläuterung: In diesem Beispiel wenden wir die folgenden Operationen an:
- Wählen Sie Index 1, ersetzen Sie ihn durch 4 (aus dem Bereich [4,8]), nums = [4,4,1,2].
- Wählen Sie Index 3, ersetzen Sie ihn durch 4 (aus dem Bereich [0,4]), nums = [4,4,1,4].
Nach den angewendeten Operationen beträgt die Schönheit der Array-Nummern 3 (Teilfolge bestehend aus den Indizes 0, 1 und 3).
Es kann bewiesen werden, dass 3 die maximal mögliche Länge ist, die wir erreichen können.

Beispiel 2:

Eingabe: nums = [1,1,1,1], k = 10
Ausgabe: 4
Erläuterung: In diesem Beispiel müssen wir keine Operationen anwenden.
Das Schöne an den Array-Nummern ist 4 (gesamtes Array).

Einschränkungen:

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

Sie erhalten eine 0-indiziertes Array nums und eine nicht negative Ganzzahl k.
In einer Operation können Sie Folgendes ausführen:

Wählen Sie einen Index I, der zuvor noch nicht aus dem Bereich ausgewählt wurde [0, nums.Length - 1].
Ersetzen Sie nums [i] durch eine beliebige Ganzzahl aus dem Bereich [nums [i] - k, nums [i] + k].

Die Schönheit des Arrays ist die Länge der längsten Sequenz, die aus gleichen Elementen besteht.
Geben Sie die maximal mögliche Schönheit der Array nums zurück, nachdem Sie den Operation jederzeit angewendet haben.
Beachten Sie, dass Sie den Operation nur einmal auf jeden Index anwenden können.
Eine Untersequenz eines Arrays ist ein neues Array, das aus dem ursprünglichen Array erzeugt wird, indem einige Elemente (möglicherweise keine) gelöscht werden, ohne die Reihenfolge der verbleibenden Elemente zu ändern.

Beispiel 1:

Eingabe: nums = [4,6,1,2], k = 2
Ausgabe: 3
Erläuterung: In diesem Beispiel wenden wir die folgenden Operationen an:
- Wählen Sie den Index 1 und ersetzen Sie ihn durch 4 (aus Bereich [4,8]), nums = [4,4,1,2].
- Wählen Sie Index 3, ersetzen Sie es durch 4 (aus Bereich [0,4]), nums = [4,4,1,4].
Nach den angewandten Operationen beträgt die Schönheit der Array nums 3 (die Subsequenz bestehend aus Indizes 0, 1 und 3).
Es kann nachgewiesen werden, dass 3 die maximale erreichbare Länge ist.

Beispiel 2:

Eingabe: nums = [1,1,1,1], k = 10
Ausgabe: 4
Erläuterung: In diesem Beispiel müssen wir keine Operationen anwenden.
Die Schönheit der Array nums ist 4 (ganzes Array).

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums und eine nicht negative Ganzzahl k.
In einem Vorgang können Sie Folgendes tun:

Wählen Sie einen Index i, der noch nie zuvor ausgewählt wurde, aus dem Bereich [0, nums.length - 1].
Ersetzen Sie nums[i] durch eine beliebige ganze Zahl aus dem Bereich [nums[i] - k, nums[i] + k].

Das Schöne am Array ist die Länge der längsten Teilsequenz, die aus gleichen Elementen besteht.
Gibt die maximal mögliche Schönheit der Array-Nummern zurück, nachdem die Operation beliebig oft angewendet wurde.
Beachten Sie, dass Sie den Vorgang nur einmal auf jeden Index anwenden können.
Eine Teilsequenz eines Arrays ist ein neues Array, das aus dem ursprünglichen Array generiert wird, indem einige Elemente (möglicherweise keines) gelöscht werden, ohne die Reihenfolge der verbleibenden Elemente zu ändern.

Beispiel 1:

Eingabe: Zahlen = [4,6,1,2], k = 2
Ausgabe: 3
Erläuterung: In diesem Beispiel wenden wir die folgenden Operationen an:
- Wählen Sie Index 1, ersetzen Sie ihn durch 4 (aus dem Bereich [4,8]), Nums = [4,4,1,2].
- Wählen Sie Index 3, ersetzen Sie ihn durch 4 (aus dem Bereich [0,4]), Nums = [4,4,1,4].
Nach den angewendeten Operationen beträgt die Schönheit der Array-Nummern 3 (Teilfolge bestehend aus den Indizes 0, 1 und 3).
Es kann bewiesen werden, dass 3 die maximal mögliche Länge ist, die wir erreichen können.

Beispiel 2:

Eingabe: Zahlen = [1,1,1,1], k = 10
Ausgabe: 4
Erläuterung: In diesem Beispiel müssen wir keine Operationen anwenden.
Das Schöne an den Array-Nummern ist 4 (gesamtes Array).

Einschränkungen:

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


Du hast ein ganzzahliges Array nums gegeben. Wir betrachten ein Array als gut, wenn es eine Permutation eines Arrays base[n] ist.
base[n] = [1, 2, ..., n - 1, n, n] (mit anderen Worten, es ist ein Array der Länge n + 1, das die Zahlen 1 bis n - 1 genau einmal enthält, plus zwei Vorkommen von n). Zum Beispiel ist base[1] = [1, 1] und base[3] = [1, 2, 3, 3].
Gib true zurück, wenn das gegebene Array gut ist, andernfalls gib false zurück.
Hinweis: Eine Permutation von Ganzzahlen stellt eine Anordnung dieser Zahlen dar.

Beispiel 1:

Input: nums = [2, 1, 3]
Output: false
Erklärung: Da das maximale Element des Arrays 3 ist, ist der einzige Kandidat n, für den dieses Array eine Permutation von base[n] sein könnte, n = 3. Allerdings hat base[3] vier Elemente, aber das Array nums hat drei. Daher kann es keine Permutation von base[3] = [1, 2, 3, 3] sein. Daher ist die Antwort false.

Beispiel 2:

Input: nums = [1, 3, 3, 2]
Output: true
Erklärung: Da das maximale Element des Arrays 3 ist, ist der einzige Kandidat n, für den dieses Array eine Permutation von base[n] sein könnte, n = 3. Es ist zu erkennen, dass nums eine Permutation von base[3] = [1, 2, 3, 3] ist (indem man das zweite und vierte Element in nums tauscht, erreicht man base[3]). Daher ist die Antwort true.
Beispiel 3:

Input: nums = [1, 1]
Output: true
Erklärung: Da das maximale Element des Arrays 1 ist, ist der einzige Kandidat n, für den dieses Array eine Permutation von base[n] sein könnte, n = 1. Es ist zu erkennen, dass nums eine Permutation von base[1] = [1, 1] ist. Daher ist die Antwort true.
Beispiel 4:

Input: nums = [3, 4, 4, 1, 2, 1]
Output: false
Erklärung: Da das maximale Element des Arrays 4 ist, ist der einzige Kandidat n, für den dieses Array eine Permutation von base[n] sein könnte, n = 4. Allerdings hat base[4] fünf Elemente, aber das Array nums hat sechs. Daher kann es keine Permutation von base[4] = [1, 2, 3, 4, 4] sein. Daher ist die Antwort false.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array mit nums. Wir betrachten ein Array als gut, wenn es eine Permutation einer Basis-Array[n] ist.
base[n] = [1, 2, ..., n - 1, n, n] (mit anderen Worten, es ist ein Array der Länge n + 1, das 1 bis n - 1 genau einmal enthält, plus zwei Vorkommen von N). Zum Beispiel: Basis[1] = [1, 1] und Basis[3] = [1, 2, 3, 3].
Gibt „true“ zurück, wenn das angegebene Array gut ist, andernfalls wird „false“ zurückgegeben.
Hinweis: Eine Permutation ganzer nums stellt eine Anordnung dieser nums dar.

Beispiel 1:

Eingabe: nums = [2, 1, 3]
Ausgabe: false
Erläuterung: Da das maximale Element des Arrays 3 ist, ist n = 3 der einzige Kandidat n, für den dieses Array eine Permutation von Basis[n] sein könnte. Basis[3] hat jedoch vier Elemente, Array nums jedoch drei. Daher kann es sich nicht um eine Permutation von Basis[3] = [1, 2, 3, 3] handeln. Die Antwort ist also false.

Beispiel 2:

Eingabe: nums = [1, 3, 3, 2]
Ausgabe: true
Erläuterung: Da das maximale Element des Arrays 3 ist, ist n = 3 der einzige Kandidat n, für den dieses Array eine Permutation von Basis[n] sein könnte. Es ist ersichtlich, dass nums eine Permutation von Basis[3] = [1, 2, 3, 3] ist. (durch Vertauschen des zweiten und vierten Elements in nums erreichen wir Basis[3]). Daher ist die Antwort true.
Beispiel 3:

Eingabe: nums = [1, 1]
Ausgabe: true
Erläuterung: Da das maximale Element des Arrays 1 ist, ist n = 1 der einzige Kandidat n, für den dieses Array eine Permutation von base[n] sein könnte. Es ist ersichtlich, dass nums eine Permutation von base[1] = ist [1, 1]. Daher ist die Antwort true.
Beispiel 4:

Eingabe: nums = [3, 4, 4, 1, 2, 1]
Ausgabe: false
Erläuterung: Da das maximale Element des Arrays 4 ist, ist n = 4 der einzige Kandidat n, für den dieses Array eine Permutation von Basis[n] sein könnte. Basis[4] hat jedoch fünf Elemente, Array nums jedoch sechs. Daher kann es sich nicht um eine Permutation von Basis[4] = [1, 2, 3, 4, 4] handeln. Die Antwort ist also false.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array mit Zahlen. Wir betrachten ein Array als gut, wenn es eine Permutation einer Array-Basis[n] ist.
base[n] = [1, 2, ..., n - 1, n, n] (mit anderen Worten, es ist ein Array der Länge n + 1, das 1 bis n - 1 genau einmal enthält, plus zwei Vorkommen von N). Zum Beispiel: Basis[1] = [1, 1] und Basis[3] = [1, 2, 3, 3].
Gibt „true“ zurück, wenn das angegebene Array gut ist, andernfalls wird „false“ zurückgegeben.
Hinweis: Eine Permutation ganzer Zahlen stellt eine Anordnung dieser Zahlen dar.

Beispiel 1:

Eingabe: nums = [2, 1, 3]
Ausgabe: falsch
Erläuterung: Da das maximale Element des Arrays 3 ist, ist n = 3 der einzige Kandidat n, für den dieses Array eine Permutation von Basis[n] sein könnte. Basis[3] hat jedoch vier Elemente, Array nums jedoch drei. Daher kann es sich nicht um eine Permutation von Basis[3] = [1, 2, 3, 3] handeln. Die Antwort ist also falsch.

Beispiel 2:

Eingabe: nums = [1, 3, 3, 2]
Ausgabe: wahr
Erläuterung: Da das maximale Element des Arrays 3 ist, ist n = 3 der einzige Kandidat n, für den dieses Array eine Permutation von base[n] sein könnte. Es ist ersichtlich, dass nums eine Permutation von base[3] = ist [1, 2, 3, 3] (durch Vertauschen des zweiten und vierten Elements in Zahlen erreichen wir Basis[3]). Daher ist die Antwort wahr.
Beispiel 3:

Eingabe: nums = [1, 1]
Ausgabe: wahr
Erläuterung: Da das maximale Element des Arrays 1 ist, ist n = 1 der einzige Kandidat n, für den dieses Array eine Permutation von base[n] sein könnte. Es ist ersichtlich, dass nums eine Permutation von base[1] = ist [1, 1]. Daher ist die Antwort wahr.
Beispiel 4:

Eingabe: nums = [3, 4, 4, 1, 2, 1]
Ausgabe: falsch
Erläuterung: Da das maximale Element des Arrays 4 ist, ist n = 4 der einzige Kandidat n, für den dieses Array eine Permutation von Basis[n] sein könnte. Basis[4] hat jedoch fünf Elemente, Array nums jedoch sechs. Daher kann es sich nicht um eine Permutation von Basis[4] = [1, 2, 3, 4, 4] handeln. Die Antwort ist also falsch.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Ganzzahlarray nums und eine positive Ganzzahl x.
Sie befinden sich zunächst auf Position 0 im Array und können nach folgenden Regeln weitere Positionen ansteuern:

Wenn Sie sich derzeit in Position i befinden, können Sie zu jeder Position j wechseln, sodass i < j ist.
Für jede Position i, die Sie besuchen, erhalten Sie eine Punktzahl von nums[i].
Wenn Sie von einer Position i zu einer Position j wechseln und die Paritäten von nums[i] und nums[j] unterschiedlich sind, verlieren Sie eine Punktzahl von x.

Geben Sie die maximale Gesamtpunktzahl zurück, die Sie erreichen können.
Beachten Sie, dass Sie zunächst nums[0] Punkte haben.

Beispiel 1:

Eingabe: Zahlen = [2,3,6,1,9,2], x = 5
Ausgabe: 13
Erläuterung: Wir können die folgenden Positionen im Array besuchen: 0 -> 2 -> 3 -> 4.
Die entsprechenden Werte sind 2, 6, 1 und 9. Da die ganzen Zahlen 6 und 1 unterschiedliche Paritäten haben, führt der Zug 2 -> 3 dazu, dass Sie einen Punktestand von x = 5 verlieren.
Die Gesamtpunktzahl beträgt: 2 + 6 + 1 + 9 – 5 = 13.

Beispiel 2:

Eingabe: Zahlen = [2,4,6,8], x = 3
Ausgabe: 20
Erläuterung: Alle ganzen Zahlen im Array haben die gleichen Paritäten, sodass wir sie alle besuchen können, ohne Punkte zu verlieren.
Die Gesamtpunktzahl beträgt: 2 + 4 + 6 + 8 = 20.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes ganzzahliges Array nums und eine positive ganze Zahl x.
Sie befinden sich anfangs an Position 0 in der Matrix und können andere Positionen nach den folgenden Regeln besuchen:

Wenn Sie sich gerade an der Position i befinden, können Sie zu jeder Position j gehen, die i < j ist.
Für jede Position i, die Sie besuchen, erhalten Sie eine Punktzahl von nums[i].
Wenn Sie sich von einer Position i zu einer Position j bewegen und die Paritäten von nums[i] und nums[j] sich unterscheiden, dann verlieren Sie eine Punktzahl von x.

Geben Sie die maximale Gesamtpunktzahl zurück, die Sie erreichen können.
Beachten Sie, dass Sie anfangs nums[0] Punkte haben.

Beispiel 1:

Eingabe: nums = [2,3,6,1,9,2], x = 5
Ausgabe: 13
Erläuterung: Wir können die folgenden Positionen im Array besuchen: 0 -> 2 -> 3 -> 4.
Die entsprechenden Werte sind 2, 6, 1 und 9. Da die Zahlen 6 und 1 unterschiedliche Paritäten haben, verliert man mit dem Zug 2 -> 3 eine Punktzahl von x = 5.
Die Gesamtpunktzahl ist somit: 2 + 6 + 1 + 9 - 5 = 13.

Beispiel 2:

Eingabe: nums = [2,4,6,8], x = 3
Ausgabe: 20
Erläuterung: Alle Zahlen in der Matrix haben die gleiche Parität, so dass wir sie alle besuchen können, ohne Punkte zu verlieren.
Die Gesamtpunktzahl ist: 2 + 4 + 6 + 8 = 20.

Beschränkungen:

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


Sie erhalten ein 0-indiziertes Ganzzahl-Array nums. Sie müssen die maximale Summe eines Zahlenpaars aus Zahlen ermitteln, sodass die maximale Ziffer in beiden Zahlen gleich ist.
Gibt die maximale Summe oder -1 zurück, wenn kein solches Paar existiert.

Beispiel 1:

Eingabe: nums = [51,71,17,24,42]
Ausgabe: 88
Erläuterung:
Für i = 1 und j = 2 haben nums[i] und nums[j] gleiche maximale Ziffern mit einer Paarsumme von 71 + 17 = 88.
Für i = 3 und j = 4 haben nums[i] und nums[j] gleiche maximale Ziffern mit einer Paarsumme von 24 + 42 = 66.
Es kann gezeigt werden, dass es keine anderen Paare mit gleichen maximalen Ziffern gibt, daher lautet die Antwort 88.
Beispiel 2:

Eingabe: nums = [1,2,3,4]
Ausgabe: -1
Erläuterung: In Zahlen mit gleicher Höchstzahl an Ziffern existiert kein Paar.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes ganzzahliges Array nums. Sie müssen die maximale Summe eines Paares von Zahlen aus nums finden, so dass die höchste Ziffer in beiden Zahlen gleich ist.
Geben Sie die maximale Summe zurück oder -1, wenn kein solches Paar existiert.

Beispiel 1:

Eingabe: nums = [51,71,17,24,42]
Ausgabe: 88
Erläuterung:
Für i = 1 und j = 2 haben nums[i] und nums[j] die gleiche maximale Anzahl von Ziffern mit einer Paarsumme von 71 + 17 = 88.
Für i = 3 und j = 4 haben nums[i] und nums[j] die gleiche höchste Ziffer mit einer Paarsumme von 24 + 42 = 66.
Es kann gezeigt werden, dass es keine anderen Paare mit gleichen Maximalziffern gibt, also ist die Antwort 88.
Beispiel 2:

Eingabe: nums = [1,2,3,4]
Ausgabe: -1
Erläuterung: In nums gibt es kein Paar mit gleichen maximalen Ziffern.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Ganzzahlarray nums, ein Ganzzahlmodulo und eine Ganzzahl k.
Ihre Aufgabe besteht darin, die Anzahl der Subarrays zu ermitteln, die interessant sind.
Ein Subarray nums[l..r] ist interessant, wenn die folgende Bedingung erfüllt ist:

Sei cnt die Anzahl der Indizes i im Bereich [l, r], so dass nums[i] % modulo == k. Dann ist cnt % modulo == k.

Gibt eine Ganzzahl zurück, die die Anzahl der interessanten Subarrays angibt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: Zahlen = [3,2,4], Modulo = 2, k = 1
Ausgabe: 3
Erläuterung: In diesem Beispiel sind die interessanten Subarrays:
Das Subarray nums[0..0] ist [3].
- Es gibt nur einen Index, i = 0, im Bereich [0, 0], der nums[i] % modulo == k erfüllt.
- Daher ist cnt = 1 und cnt % modulo == k.
Das Subarray nums[0..1] ist [3,2].
- Es gibt nur einen Index, i = 0, im Bereich [0, 1], der nums[i] % modulo == k erfüllt.
- Daher ist cnt = 1 und cnt % modulo == k.
Das Subarray nums[0..2] ist [3,2,4].
- Es gibt nur einen Index, i = 0, im Bereich [0, 2], der nums[i] % modulo == k erfüllt.
- Daher ist cnt = 1 und cnt % modulo == k.
Es kann gezeigt werden, dass es keine weiteren interessanten Subarrays gibt. Die Antwort ist also 3.
Beispiel 2:

Eingabe: Zahlen = [3,1,9,6], Modulo = 3, k = 0
Ausgabe: 2
Erläuterung: In diesem Beispiel sind die interessanten Subarrays:
Das Subarray nums[0..3] ist [3,1,9,6].
- Es gibt drei Indizes i = 0, 2, 3 im Bereich [0, 3], die nums[i] % modulo == k erfüllen.
- Daher ist cnt = 3 und cnt % modulo == k.
Das Subarray nums[1..1] ist [1].
- Es gibt keinen Index i im Bereich [1, 1], der nums[i] % modulo == k erfüllt.
- Daher ist cnt = 0 und cnt % modulo == k.
Es kann gezeigt werden, dass es keine weiteren interessanten Subarrays gibt. Die Antwort ist also 2.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes ganzzahliges Array nums, ein ganzzahliges Modulo und eine ganze Zahl k.
Ihre Aufgabe ist es, die Anzahl der Subarrays zu ermitteln, die interessant sind.
Ein Subarray nums[l.. r] ist interessant, wenn die folgende Bedingung zutrifft:

Sei cnt die Anzahl der Indizes i im Bereich [l, r], so dass nums[i] % modulo == k. Dann ist cnt % modulo == k.

Gibt eine Ganzzahl zurück, die die Anzahl interessanter Subarrays angibt.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Sequenz von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [3,2,4], modulo = 2, k = 1
Ausgang: 3
Erklärung: In diesem Beispiel sind die interessanten Subarrays:
Das Subarray nums[0..0], das ist [3].
- Es gibt nur einen Index, i = 0, im Bereich [0, 0], der nums[i] % modulo == k erfüllt.
- Daraus ergibt sich cnt = 1 und cnt % modulo == k.
Das Subarray nums[0..1], das ist [3,2].
- Es gibt nur einen Index, i = 0, im Bereich [0, 1], der nums[i] % modulo == k erfüllt.
- Daraus ergibt sich cnt = 1 und cnt % modulo == k.
Das Subarray nums[0..2], das ist [3,2,4].
- Es gibt nur einen Index, i = 0, im Bereich [0, 2], der nums[i] % modulo == k erfüllt.
- Daraus ergibt sich cnt = 1 und cnt % modulo == k.
Es kann gezeigt werden, dass es keine weiteren interessanten Subarrays gibt. Die Antwort lautet also 3.
Beispiel 2:

Eingabe: nums = [3,1,9,6], modulo = 3, k = 0
Ausgang: 2
Erklärung: In diesem Beispiel sind die interessanten Subarrays:
Das Subarray nums[0..3], das [3,1,9,6] ist.
- Es gibt drei Indizes, i = 0, 2, 3, im Bereich [0, 3], die nums[i] % modulo == k erfüllen.
- Daraus ergibt sich cnt = 3 und cnt % modulo == k.
Das Subarray nums[1..1], das ist [1].
- Es gibt keinen Index i im Bereich [1, 1], der nums[i] % modulo == k erfüllt.
- Daraus ergibt sich cnt = 0 und cnt % modulo == k.
Es kann gezeigt werden, dass es keine weiteren interessanten Subarrays gibt. Die Antwort lautet also 2.

Zwänge:

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


Sie erhalten ein Array mit der Länge n und einer Ganzzahl m. Sie müssen feststellen, ob es möglich ist, das Array in n nicht leere Arrays aufzuteilen, indem Sie eine Reihe von Schritten ausführen.
In jedem Schritt können Sie ein vorhandenes Array (das möglicherweise das Ergebnis vorheriger Schritte ist) mit einer Länge von mindestens zwei auswählen und es in zwei Subarrays aufteilen, wenn für jedes resultierende Subarray mindestens eine der folgenden Bedingungen gilt:

Die Länge des Subarrays beträgt eins oder
Die Summe der Elemente des Subarrays ist größer oder gleich m.

Gibt „true“ zurück, wenn Sie das angegebene Array in n Arrays aufteilen können, andernfalls geben Sie „false“ zurück.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [2, 2, 1], m = 4
Ausgabe: wahr
Erläuterung: Wir können das Array im ersten Schritt in [2, 2] und [1] aufteilen. Dann können wir im zweiten Schritt [2, 2] in [2] und [2] aufteilen. Infolgedessen ist die Antwort wahr.
Beispiel 2:

Eingabe: nums = [2, 1, 3], m = 5
Ausgabe: falsch
Erläuterung: Wir können versuchen, das Array auf zwei verschiedene Arten aufzuteilen: Die erste Möglichkeit besteht darin, [2, 1] und [3] zu haben, und die zweite Möglichkeit besteht darin, [2] und [1, 3] zu haben. Beide Möglichkeiten sind jedoch ungültig. Die Antwort ist also falsch.
Beispiel 3:

Eingabe: nums = [2, 3, 3, 2, 3], m = 6
Ausgabe: wahr
Erläuterung: Wir können das Array im ersten Schritt in [2, 3, 3, 2] und [3] aufteilen. Dann können wir im zweiten Schritt [2, 3, 3, 2] in [2, 3, 3] und [2] aufteilen. Dann können wir im dritten Schritt [2, 3, 3] in [2] und [3, 3] aufteilen. Und im letzten Schritt können wir [3, 3] in [3] und [3] aufteilen. Infolgedessen ist die Antwort wahr.

Einschränkungen:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

Sie erhalten ein Array mit der Länge n und einer Ganzzahl m. Sie müssen feststellen, ob es möglich ist, das Array in n nicht leere Arrays aufzuteilen, indem Sie eine Reihe von Schritten ausführen.
In jedem Schritt können Sie ein vorhandenes Array (das möglicherweise das Ergebnis vorheriger Schritte ist) mit einer Länge von mindestens zwei auswählen und es in zwei Subarrays aufteilen, wenn für jedes resultierende Subarray mindestens eine der folgenden Bedingungen gilt:

Die Länge des Subarrays beträgt eins oder
Die Summe der Elemente des Subarrays ist größer oder gleich m.

Gibt „true“ zurück, wenn Sie das angegebene Array in n Arrays aufteilen können, andernfalls geben Sie „false“ zurück.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [2, 2, 1], m = 4
Ausgabe: wahr
Erläuterung: Wir können das Array im ersten Schritt in [2, 2] und [1] aufteilen. Dann können wir im zweiten Schritt [2, 2] in [2] und [2] aufteilen. Infolgedessen ist die Antwort wahr.
Beispiel 2:

Eingabe: Zahlen = [2, 1, 3], m = 5
Ausgabe: falsch
Erläuterung: Wir können versuchen, das Array auf zwei verschiedene Arten aufzuteilen: Die erste Möglichkeit besteht darin, [2, 1] und [3] zu haben, und die zweite Möglichkeit besteht darin, [2] und [1, 3] zu haben. Beide Möglichkeiten sind jedoch ungültig. Die Antwort ist also falsch.
Beispiel 3:

Eingabe: nums = [2, 3, 3, 2, 3], m = 6
Ausgabe: wahr
Erläuterung: Wir können das Array im ersten Schritt in [2, 3, 3, 2] und [3] aufteilen. Dann können wir im zweiten Schritt [2, 3, 3, 2] in [2, 3, 3] und [2] aufteilen. Dann können wir im dritten Schritt [2, 3, 3] in [2] und [3, 3] aufteilen. Und im letzten Schritt können wir [3, 3] in [3] und [3] aufteilen. Im Ergebnis ist die Antwort wahr.

Einschränkungen:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200

Sie erhalten ein Array mit der Länge n und einer Ganzzahl m. Sie müssen feststellen, ob es möglich ist, das Array in n nicht leere Arrays aufzuteilen, indem Sie eine Reihe von Schritten ausführen.
In jedem Schritt können Sie ein vorhandenes Array (das möglicherweise das Ergebnis vorheriger Schritte ist) mit einer Länge von mindestens zwei auswählen und es in zwei Subarrays aufteilen, wenn für jedes resultierende Subarray mindestens eine der folgenden Bedingungen gilt:

Die Länge des Subarrays beträgt eins oder
Die Summe der Elemente des Subarrays ist größer oder gleich m.

Gibt „true“ zurück, wenn Sie das angegebene Array in n Arrays aufteilen können, andernfalls geben Sie „false“ zurück.
Hinweis: Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [2, 2, 1], m = 4
Ausgabe: wahr
Erläuterung: Wir können das Array im ersten Schritt in [2, 2] und [1] aufteilen. Dann können wir im zweiten Schritt [2, 2] in [2] und [2] aufteilen. Infolgedessen ist die Antwort wahr.
Beispiel 2:

Eingabe: Zahlen = [2, 1, 3], m = 5
Ausgabe: falsch
Erläuterung: Wir können versuchen, das Array auf zwei verschiedene Arten aufzuteilen: Die erste Möglichkeit besteht darin, [2, 1] und [3] zu haben, und die zweite Möglichkeit besteht darin, [2] und [1, 3] zu haben. Beide Möglichkeiten sind jedoch ungültig. Die Antwort ist also falsch.
Beispiel 3:

Eingabe: nums = [2, 3, 3, 2, 3], m = 6
Ausgabe: wahr
Erläuterung: Wir können das Array im ersten Schritt in [2, 3, 3, 2] und [3] aufteilen. Dann können wir im zweiten Schritt [2, 3, 3, 2] in [2, 3, 3] und [2] aufteilen. Dann können wir im dritten Schritt [2, 3, 3] in [2] und [3, 3] aufteilen. Und im letzten Schritt können wir [3, 3] in [3] und [3] aufteilen. Infolgedessen ist die Antwort wahr.

Einschränkungen:

1 <= n == nums.length <= 100
1 <= nums[i] <= 100
1 <= m <= 200


Bei einem 0-indizierten Array nums der Länge n und einem Ziel wird die Anzahl der Paare (i, j) zurückgegeben, da 0 <= i < j < n und nums[i] + nums[j] < Ziel.

Beispiel 1:

Eingabe: nums = [-1,1,2,3,1], Ziel = 2
Ausgabe: 3
Erklärung: Es gibt 3 Indexpaare, die die Bedingungen in der Anweisung erfüllen:
- (0, 1), da 0 < 1 und nums[0] + nums[1] = 0 < Ziel
- (0, 2), da 0 < 2 und nums[0] + nums[2] = 1 < Ziel
- (0, 4), da 0 < 4 und nums[0] + nums[4] = 0 < Ziel
Beachten Sie, dass (0, 3) nicht gezählt wird, da nums[0] + nums[3] nicht strikt kleiner als das Ziel ist.

Beispiel 2:

Eingabe: nums = [-6,2,5,-2,-7,-1,3], Ziel = -2
Ausgabe: 10
Erklärung: Es gibt 10 Indexpaare, die die Bedingungen in der Anweisung erfüllen:
- (0, 1) da 0 < 1 und nums[0] + nums[1] = -4 < Ziel
- (0, 3) da 0 < 3 und nums[0] + nums[3] = -8 < Ziel
- (0, 4) da 0 < 4 und nums[0] + nums[4] = -13 < Ziel
- (0, 5) da 0 < 5 und nums[0] + nums[5] = -7 < Ziel
- (0, 6) da 0 < 6 und nums[0] + nums[6] = -3 < Ziel
- (1, 4) da 1 < 4 und nums[1] + nums[4] = -5 < Ziel
- (3, 4) da 3 < 4 und nums[3] + nums[4] = -9 < Ziel
- (3, 5) da 3 < 5 und nums[3] + nums[5] = -3 < Ziel
- (4, 5) da 4 < 5 und nums[4] + nums[5] = -8 < Ziel
- (4, 6) da 4 < 6 und nums[4] + nums[6] = -4 < Ziel

Einschränkungen:

1 <= nums.length == n <= 50
-50 <= nums[i], Ziel <= 50

Bei einem 0-indizierten Integer-Array nums der Länge n und einem Integer-Ziel wird die Anzahl der Paare (i, j) zurückgegeben, wobei 0 <= i < j < n und nums[i] + nums[j] < target.

Beispiel 1:

Eingabe: nums = [-1,1,2,3,1], target = 2
Ausgabe: 3
Erklärung: Es gibt 3 Indexpaare, die die Bedingungen in der Anweisung erfüllen:
- (0, 1), da 0 < 1 und nums[0] + nums[1] = 0 < target
- (0, 2), da 0 < 2 und nums[0] + nums[2] = 1 < target
- (0, 4), da 0 < 4 und nums[0] + nums[4] = 0 < target
Beachten Sie, dass (0, 3) nicht gezählt wird, da nums[0] + nums[3] nicht strikt kleiner als das Ziel ist.

Beispiel 2:

Eingabe: nums = [-6,2,5,-2,-7,-1,3], target = -2
Ausgabe: 10
Erklärung: Es gibt 10 Indexpaare, die die Bedingungen in der Anweisung erfüllen:
- (0, 1) da 0 < 1 und nums[0] + nums[1] = -4 < target
- (0, 3) da 0 < 3 und nums[0] + nums[3] = -8 < target
- (0, 4) da 0 < 4 und nums[0] + nums[4] = -13 < target
- (0, 5) da 0 < 5 und nums[0] + nums[5] = -7 < target
- (0, 6) da 0 < 6 und nums[0] + nums[6] = -3 < target
- (1, 4) da 1 < 4 und nums[1] + nums[4] = -5 < target
- (3, 4) da 3 < 4 und nums[3] + nums[4] = -9 < target
- (3, 5) da 3 < 5 und nums[3] + nums[5] = -3 < target
- (4, 5) da 4 < 5 und nums[4] + nums[5] = -8 < target
- (4, 6) da 4 < 6 und nums[4] + nums[6] = -4 < target

Einschränkungen:

1 <= nums.length == n <= 50
-50 <= nums[i], target <= 50

Geben Sie bei einem 0-indizierten Integer-Array der Länge n und einem Integer-Ziel die Anzahl der Paare (i, j) zurück, wobei 0 <= i < j < n und nums[i] + nums[j] < Ziel ist.

Beispiel 1:

Eingabe: Nums = [-1,1,2,3,1], Ziel = 2
Ausgabe: 3
Erläuterung: Es gibt 3 Indexpaare, die die Bedingungen in der Anweisung erfüllen:
- (0, 1) da 0 < 1 und nums[0] + nums[1] = 0 < Ziel
- (0, 2) da 0 < 2 und nums[0] + nums[2] = 1 < Ziel
- (0, 4) da 0 < 4 und nums[0] + nums[4] = 0 < Ziel
Beachten Sie, dass (0, 3) nicht gezählt wird, da nums[0] + nums[3] nicht unbedingt kleiner als das Ziel ist.

Beispiel 2:

Eingabe: Nums = [-6,2,5,-2,-7,-1,3], Ziel = -2
Ausgabe: 10
Erläuterung: Es gibt 10 Indexpaare, die die Bedingungen in der Anweisung erfüllen:
- (0, 1) da 0 < 1 und nums[0] + nums[1] = -4 < Ziel
- (0, 3) da 0 < 3 und nums[0] + nums[3] = -8 < Ziel
- (0, 4) da 0 < 4 und nums[0] + nums[4] = -13 < Ziel
- (0, 5) da 0 < 5 und nums[0] + nums[5] = -7 < Ziel
- (0, 6) da 0 < 6 und nums[0] + nums[6] = -3 < Ziel
- (1, 4) da 1 < 4 und nums[1] + nums[4] = -5 < Ziel
- (3, 4) da 3 < 4 und nums[3] + nums[4] = -9 < Ziel
- (3, 5) da 3 < 5 und nums[3] + nums[5] = -3 < Ziel
- (4, 5) da 4 < 5 und nums[4] + nums[5] = -8 < Ziel
- (4, 6) da 4 < 6 und nums[4] + nums[6] = -4 < Ziel

Einschränkungen:

1 <= nums.length == n <= 50
-50 <= nums[i], Ziel <= 50


Sie erhalten ein 0-indiziertes Array usageLimits der Länge n.
Ihre Aufgabe besteht darin, Gruppen mit Zahlen von 0 bis n - 1 zu erstellen und sicherzustellen, dass jede Zahl, i, nicht mehr als usageLimits[i] Mal insgesamt in allen Gruppen verwendet wird. Darüber hinaus müssen Sie die folgenden Bedingungen erfüllen:

Jede Gruppe muss aus unterschiedlichen Nummern bestehen, was bedeutet, dass innerhalb einer einzelnen Gruppe keine doppelten Nummern zulässig sind.
Jede Gruppe (mit Ausnahme der ersten) muss eine Länge haben, die genau größer ist als die der vorherigen Gruppe.

Gibt eine ganze Zahl zurück, die die maximale Anzahl von Gruppen angibt, die Sie erstellen können, während diese Bedingungen erfüllt sind.

Beispiel 1:

Eingabe: usageLimits = [1,2,5]
Ausgang: 3
Erklärung: In diesem Beispiel können wir höchstens einmal 0, höchstens zweimal 1 und höchstens fünfmal 2 verwenden.
Eine Möglichkeit, die maximale Anzahl von Gruppen zu erstellen und gleichzeitig die Bedingungen zu erfüllen, ist:
Gruppe 1 enthält die Zahl [2].
Gruppe 2 enthält die Zahlen [1,2].
Gruppe 3 enthält die Zahlen [0,1,2].
Es kann gezeigt werden, dass die maximale Anzahl der Gruppen 3 beträgt.
Der Ausgang ist also 3.
Beispiel 2:

Eingabe: usageLimits = [2,1,2]
Ausgang: 2
Erklärung: In diesem Beispiel können wir 0 höchstens zweimal, 1 höchstens einmal und 2 höchstens zweimal verwenden.
Eine Möglichkeit, die maximale Anzahl von Gruppen zu erstellen und gleichzeitig die Bedingungen zu erfüllen, ist:
Gruppe 1 enthält die Zahl [0].
Gruppe 2 enthält die Zahlen [1,2].
Es kann gezeigt werden, dass die maximale Anzahl von Gruppen 2 beträgt.
Der Ausgang ist also 2.

Beispiel 3:

Eingabe: usageLimits = [1,1]
Ausgang: 1
Erklärung: In diesem Beispiel können wir sowohl 0 als auch 1 maximal einmal verwenden.
Eine Möglichkeit, die maximale Anzahl von Gruppen zu erstellen und gleichzeitig die Bedingungen zu erfüllen, ist:
Gruppe 1 enthält die Zahl [0].
Es kann gezeigt werden, dass die maximale Anzahl der Gruppen 1 beträgt.
Der Ausgang ist also 1.

Zwänge:

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

Sie erhalten ein 0-indiziertes Array mit der Länge n.
Ihre Aufgabe besteht darin, Gruppen mit Zahlen von 0 bis n - 1 zu erstellen und sicherzustellen, dass jede Zahl i in allen Gruppen insgesamt nicht öfter als useLimits[i]-mal verwendet wird. Sie müssen außerdem die folgenden Bedingungen erfüllen:

Jede Gruppe muss aus unterschiedlichen Nummern bestehen, was bedeutet, dass innerhalb einer einzelnen Gruppe keine doppelten Nummern zulässig sind.
Jede Gruppe (außer der ersten) muss unbedingt länger sein als die vorherige Gruppe.

Gibt eine Ganzzahl zurück, die die maximale Anzahl von Gruppen angibt, die Sie erstellen können, während diese Bedingungen erfüllt sind.

Beispiel 1:

Eingabe: useLimits = [1,2,5]
Ausgabe: 3
Erläuterung: In diesem Beispiel können wir 0 höchstens einmal, 1 höchstens zweimal und 2 höchstens fünfmal verwenden.
Eine Möglichkeit, die maximale Anzahl an Gruppen zu erstellen und gleichzeitig die Bedingungen zu erfüllen, ist:
Gruppe 1 enthält die Nummer [2].
Gruppe 2 enthält die Zahlen [1,2].
Gruppe 3 enthält die Zahlen [0,1,2].
Es lässt sich zeigen, dass die maximale Gruppenanzahl 3 beträgt.
Die Ausgabe ist also 3.
Beispiel 2:

Eingabe: useLimits = [2,1,2]
Ausgabe: 2
Erläuterung: In diesem Beispiel können wir 0 höchstens zweimal, 1 höchstens einmal und 2 höchstens zweimal verwenden.
Eine Möglichkeit, die maximale Anzahl an Gruppen zu erstellen und gleichzeitig die Bedingungen zu erfüllen, ist:
Gruppe 1 enthält die Zahl [0].
Gruppe 2 enthält die Zahlen [1,2].
Es kann gezeigt werden, dass die maximale Anzahl von Gruppen 2 beträgt.
Die Ausgabe ist also 2.

Beispiel 3:

Eingabe: useLimits = [1,1]
Ausgabe: 1
Erläuterung: In diesem Beispiel können wir sowohl 0 als auch 1 höchstens einmal verwenden.
Eine Möglichkeit, die maximale Anzahl an Gruppen zu erstellen und gleichzeitig die Bedingungen zu erfüllen, ist:
Gruppe 1 enthält die Zahl [0].
Es kann gezeigt werden, dass die maximale Anzahl von Gruppen 1 beträgt.
Die Ausgabe ist also 1.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Array nums mit n ganzen Zahlen.
Jede Sekunde führen Sie den folgenden Vorgang am Array aus:

Ersetzen Sie für jeden Index i im Bereich [0, n - 1] nums[i] entweder durch nums[i], nums[(i - 1 + n) % n] oder nums[(i + 1) % n ].

Beachten Sie, dass alle Elemente gleichzeitig ersetzt werden.
Gibt die Mindestanzahl an Sekunden zurück, die erforderlich sind, um alle Elemente im Array nums gleich zu machen.

Beispiel 1:

Eingabe: nums = [1,2,1,2]
Ausgabe: 1
Erläuterung: Wir können das Array auf folgende Weise in 1 Sekunde ausgleichen:
- Ersetzen Sie in der ersten Sekunde die Werte an jedem Index durch [nums[3],nums[1],nums[3],nums[3]]. Nach dem Ersetzen ist nums = [2,2,2,2].
Es kann nachgewiesen werden, dass 1 Sekunde die Mindestanzahl an Sekunden ist, die zum Ausgleichen des Arrays benötigt wird.

Beispiel 2:

Eingabe: nums = [2,1,3,3,2]
Ausgabe: 2
Erläuterung: Wir können das Array auf folgende Weise in 2 Sekunden ausgleichen:
- Ersetzen Sie in der ersten Sekunde die Werte an jedem Index durch [nums[0],nums[2],nums[2],nums[2],nums[3]]. Nach dem Ersetzen ist nums = [2,3,3,3,3].
- Ersetzen Sie in der zweiten Sekunde die Werte an jedem Index durch [nums[1],nums[1],nums[2],nums[3],nums[4]]. Nach dem Ersetzen ist nums = [3,3,3,3,3].
Es kann nachgewiesen werden, dass 2 Sekunden die Mindestanzahl an Sekunden sind, die zum Ausgleichen des Arrays benötigt werden.

Beispiel 3:

Eingabe: nums = [5,5,5,5]
Ausgabe: 0
Erläuterung: Wir müssen keine Operationen ausführen, da alle Elemente im anfänglichen Array gleich sind.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums mit n ganzen Zahlen.
Zu jeder Sekunde führen Sie die folgende Operation an dem Array durch:

Für jeden Index i im Bereich [0, n - 1] ersetzen Sie nums[i] entweder durch nums[i], nums[(i - 1 + n) % n] oder nums[(i + 1) % n].

Beachten Sie, dass alle Elemente gleichzeitig ersetzt werden.
Gibt die minimale Anzahl von Sekunden zurück, die benötigt wird, um alle Elemente im Array nums gleich zu machen.

Beispiel 1:

Eingabe: nums = [1,2,1,2]
Ausgabe: 1
Erläuterung: Wir können das Array in 1 Sekunde auf folgende Weise ausgleichen:
- Ersetze in der 1^sten Sekunde die Werte bei jedem Index durch [nums[3],nums[1],nums[3],nums[3]]. Nach der Ersetzung ist nums = [2,2,2,2].
Es kann bewiesen werden, dass 1 Sekunde die minimale Zeitspanne ist, die für den Ausgleich des Arrays benötigt wird.

Beispiel 2:

Eingabe: nums = [2,1,3,3,2]
Ausgabe: 2
Erläuterung: Wir können das Array in 2 Sekunden auf folgende Weise ausgleichen:
- Ersetze in der 1^sten Sekunde die Werte an jedem Index durch [nums[0],nums[2],nums[2],nums[2],nums[3]]. Nach der Ersetzung ist nums = [2,3,3,3,3,3].
- In der 2^. Sekunde werden die Werte bei jedem Index durch [nums[1],nums[1],nums[2],nums[3],nums[4]] ersetzt. Nach der Ersetzung ist nums = [3,3,3,3,3,3].
Es kann bewiesen werden, dass 2 Sekunden die minimale Zeitspanne ist, die zum Ausgleichen des Arrays benötigt wird.

Beispiel 3:

Eingabe: nums = [5,5,5,5]
Ausgabe: 0
Erläuterung: Wir brauchen keine Operationen durchzuführen, da alle Elemente in der Ausgangsmatrix gleich sind.

Randbedingungen:

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


Ermitteln Sie anhand zweier positiver Ganzzahlen niedrig und hoch, die als Zeichenfolgen dargestellt werden, die Anzahl der Schrittzahlen im inklusiven Bereich [niedrig, hoch].
Eine Schrittzahl ist eine ganze Zahl, bei der alle benachbarten Ziffern eine absolute Differenz von genau 1 haben.
Gibt eine Ganzzahl zurück, die die Anzahl der Schrittzahlen im inklusiven Bereich [niedrig, hoch] angibt.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Hinweis: Eine Schrittnummer sollte keine führende Null haben.

Beispiel 1:

Eingabe: niedrig = „1“, hoch = „11“
Ausgabe: 10
Erläuterung: Die Schrittzahlen im Bereich [1,11] sind 1, 2, 3, 4, 5, 6, 7, 8, 9 und 10. Der Bereich umfasst insgesamt 10 Schrittzahlen. Daher beträgt die Ausgabe 10.
Beispiel 2:

Eingabe: niedrig = „90“, hoch = „101“
Ausgabe: 2
Erläuterung: Die Schrittzahlen im Bereich [90,101] sind 98 und 101. Es gibt insgesamt 2 Schrittzahlen im Bereich. Daher ist die Ausgabe 2.

Einschränkungen:

1 <= int(low) <= int(high) < 10^100
1 <= niedrige Länge, hohe Länge <= 100
niedrig und hoch bestehen nur aus Ziffern.
low und high haben keine führenden Nullen.

Ermitteln Sie anhand zweier positiver Ganzzahlen niedrig und hoch, die als Zeichenfolgen dargestellt werden, die Anzahl der Schrittzahlen im inklusiven Bereich [niedrig, hoch].
Eine Schrittzahl ist eine ganze Zahl, bei der alle benachbarten Ziffern eine absolute Differenz von genau 1 haben.
Gibt eine Ganzzahl zurück, die die Anzahl der Schrittzahlen im inklusiven Bereich [niedrig, hoch] angibt.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Hinweis: Eine Schrittnummer sollte keine führende Null haben.

Beispiel 1:

Eingabe: low = "1", high = "11"
Ausgabe: 10
Erläuterung: Die Schrittzahlen im Bereich [1,11] sind 1, 2, 3, 4, 5, 6, 7, 8, 9 und 10. Der Bereich umfasst insgesamt 10 Schrittzahlen. Daher beträgt die Ausgabe 10.
Beispiel 2:

Eingabe: low = "90", high = "101"
Ausgabe: 2
Erläuterung: Die Schrittzahlen im Bereich [90,101] sind 98 und 101. Es gibt insgesamt 2 Schrittzahlen im Bereich. Daher ist die Ausgabe 2.

Einschränkungen:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
niedrig und hoch bestehen nur aus Ziffern.
low und high haben keine führenden Nullen.

Finden Sie bei zwei positiven Ganzzahlen, die niedrig und hoch als Zeichenketten dargestellt werden, die Anzahl der Schrittzahlen im inklusiven Bereich [niedrig, hoch].
Eine Schrittnummer ist eine Ganzzahl, so dass alle ihre angrenzenden Ziffern einen absoluten Unterschied von genau 1 haben.
Gibt eine Ganzzahl zurück, die die Anzahl der Schrittzahlen im inklusiven Bereich [niedrig, hoch] bezeichnet.
Da die Antwort sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Hinweis: Eine Schrittnummer sollte keinen führenden Nullpunkt haben.

Beispiel 1:

Eingabe: low = "1", high = "11"
Ausgabe: 10
Erläuterung: Die Schrittzahlen im Bereich [1,11] betragen 1, 2, 3, 4, 5, 6, 7, 8, 9 und 10. Es gibt insgesamt 10 Schrittzahlen im Bereich. Daher ist die Ausgabe 10.
Beispiel 2:

Eingabe: low = "90", high = "101"
Ausgabe: 2
Erläuterung: Die Sprungzahlen im Bereich [90,101] betragen 98 und 101. Es gibt insgesamt 2 Schrittzahlen im Bereich. Daher beträgt der Ausgang 2.

Einschränkungen:

1 <= int(low) <= int(high) < 10^100
1 <= low.length, high.length <= 100
Niedrig und hoch bestehen nur aus Ziffern.
Niedrig und hoch haben keine führenden Nullen.