Sie erhalten zwei 0-indizierte Ganzzahlarrays nums1 und nums2 der Größen n bzw. m.
Erwägen Sie die Berechnung der folgenden Werte:

Die Anzahl der Indizes i, so dass 0 <= i < n und nums1[i] mindestens einmal in nums2 vorkommt.
Die Anzahl der Indizes i, so dass 0 <= i < m und nums2[i] mindestens einmal in nums1 vorkommt.

Gibt eine ganzzahlige Array-Antwort der Größe 2 zurück, die die beiden Werte in der oben genannten Reihenfolge enthält.

Beispiel 1:

Eingabe: Nums1 = [4,3,2,3,1], Nums2 = [2,2,5,2,3,6]
Ausgabe: [3,4]
Erläuterung: Wir berechnen die Werte wie folgt:
- Die Elemente an den Indizes 1, 2 und 3 in nums1 kommen mindestens einmal in nums2 vor. Der erste Wert ist also 3.
- Die Elemente an den Indizes 0, 1, 3 und 4 in nums2 kommen mindestens einmal in nums1 vor. Der zweite Wert ist also 4.

Beispiel 2:

Eingabe: Nums1 = [3,4,2,3], Nums2 = [1,5]
Ausgabe: [0,0]
Erläuterung: Es gibt keine gemeinsamen Elemente zwischen den beiden Arrays, daher sind die beiden Werte 0.

Einschränkungen:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Sie erhalten zwei 0-Indexed Integer Arrays nums1 und nums2 der Größen n bzw. m.
Berechnen Sie die folgenden Werte:

Die Anzahl der Indizes i, so dass 0 <= i <n und nums1 [i] mindestens einmal in nums2 auftritt.
Die Anzahl der Indizes i, so dass 0 <= i <m und nums2 [i] mindestens einmal in nums1 auftritt.

Geben Sie eine Ganzzahlarray -Antwort von Größe 2 zurück, die die beiden Werte in der obigen Reihenfolge enthält.

Beispiel 1:

Eingabe: nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
Ausgabe: [3,4]
Erläuterung: Wir berechnen die Werte wie folgt:
- Die Elemente an den Indizes 1, 2 und 3 in NUMS1 treten mindestens einmal in NUMS2 auf. Der erste Wert ist also 3.
- Die Elemente bei den Indizes 0, 1, 3 und 4 in NUMS2 treten mindestens einmal in NUMS1 auf. Der zweite Wert ist also 4.

Beispiel 2:

Eingabe: nums1 = [3,4,2,3], nums2 = [1,5]
Ausgabe: [0,0]
Erläuterung: Es gibt keine gemeinsamen Elemente zwischen den beiden Arrays, sodass die beiden Werte 0 betragen.

Einschränkungen:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= nums1[i], nums2[i] <= 100

Sie erhalten zwei 0-indizierte Ganzzahlarrays nums1 und nums2 der Größen n bzw. m.
Erwägen Sie die Berechnung der folgenden Werte:

Die Anzahl der Indizes i, so dass 0 <= i < n und nums1[i] mindestens einmal in nums2 vorkommt.
Die Anzahl der Indizes i, so dass 0 <= i < m und nums2[i] mindestens einmal in nums1 vorkommt.

Gibt eine ganzzahlige Array-Antwort der Größe 2 zurück, die die beiden Werte in der oben genannten Reihenfolge enthält.

Beispiel 1:

Eingabe: Nums1 = [4,3,2,3,1], Nums2 = [2,2,5,2,3,6]
Ausgabe: [3,4]
Erläuterung: Wir berechnen die Werte wie folgt:
- Die Elemente an den Indizes 1, 2 und 3 in nums1 kommen mindestens einmal in nums2 vor. Der erste Wert ist also 3.
- Die Elemente an den Indizes 0, 1, 3 und 4 in nums2 kommen mindestens einmal in nums1 vor. Der zweite Wert ist also 4.

Beispiel 2:

Eingabe: Nums1 = [3,4,2,3], Nums2 = [1,5]
Ausgabe: [0,0]
Erläuterung: Es gibt keine gemeinsamen Elemente zwischen den beiden Arrays, daher sind die beiden Werte 0.

Einschränkungen:

n == nums1.length
m == nums2.length
1 <= n, m <= 100
1 <= Anzahl1[i], Anzahl2[i] <= 100


Sie erhalten drei Zeichenketten s1, s2 und s3. Sie müssen die folgende Operation mit diesen drei Zeichenfolgen so oft durchführen, wie Sie wollen.
In einer Operation können Sie eine der drei Zeichenketten so auswählen, dass ihre Länge mindestens 2 beträgt, und das Zeichen ganz rechts aus der Zeichenkette löschen.
Geben Sie die minimale Anzahl von Operationen zurück, die Sie durchführen müssen, um die drei Zeichenketten gleich zu machen, wenn es eine Möglichkeit gibt, sie gleich zu machen, ansonsten geben Sie -1 zurück.

Beispiel 1:

Eingabe: s1 = "abc", s2 = "abb", s3 = "ab"
Ausgabe: 2
Erläuterung: Führt man die Operationen auf s1 und s2 einmal durch, so erhält man drei gleiche Zeichenketten.
Es kann gezeigt werden, dass es keine Möglichkeit gibt, sie mit weniger als zwei Operationen gleich zu machen.
Beispiel 2:

Eingabe: s1 = "dac", s2 = "bac", s3 = "cac"
Ausgabe: -1
Erläuterung: Da die ganz linken Buchstaben von s1 und s2 nicht gleich sind, können sie nach einer beliebigen Anzahl von Operationen nicht mehr gleich sein. Die Antwort ist also -1.

Randbedingungen:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 und s3 bestehen nur aus englischen Kleinbuchstaben.

Sie erhalten drei Zeichenfolgen s1, s2 und s3. Sie müssen die folgende Operation für diese drei Zeichenfolgen so oft ausführen, wie Sie möchten.
In einem Vorgang können Sie eine dieser drei Zeichenfolgen so auswählen, dass ihre Länge mindestens 2 beträgt, und das Zeichen ganz rechts daraus löschen.
Geben Sie die Mindestanzahl an Operationen zurück, die Sie ausführen müssen, um die drei Zeichenfolgen gleich zu machen, wenn es eine Möglichkeit gibt, sie gleich zu machen. Andernfalls geben Sie -1 zurück.

Beispiel 1:

Eingabe: s1 = „abc“, s2 = „abb“, s3 = „ab“
Ausgabe: 2
Erläuterung: Die einmalige Ausführung von Operationen an s1 und s2 führt zu drei gleichen Zeichenfolgen.
Es kann gezeigt werden, dass es keine Möglichkeit gibt, sie mit weniger als zwei Operationen gleich zu machen.
Beispiel 2:

Eingabe: s1 = „dac“, s2 = „bac“, s3 = „cac“
Ausgabe: -1
Erläuterung: Da die Buchstaben ganz links von s1 und s2 nicht gleich sind, können sie nach beliebig vielen Operationen nicht gleich sein. Die Antwort lautet also -1.

Einschränkungen:

1 <= s1.length, s2.length, s3.length <= 100
s1, s2 und s3 bestehen nur aus englischen Kleinbuchstaben.


Sie befinden sich auf einem Obstmarkt, auf dem verschiedene Arten exotischer Früchte ausgestellt sind.
Sie erhalten ein 1-indiziertes Array „prices“, wobei „prices[i]“ die Anzahl der Münzen angibt, die zum Kauf der i^ten Frucht benötigt werden.
Der Obstmarkt hat folgendes Angebot:

Wenn Sie die i^-te Frucht zu Preisen[i]-Münzen kaufen, können Sie die nächste i-te Frucht kostenlos erhalten.

Beachten Sie, dass Sie Früchte j zwar kostenlos erhalten, diese aber dennoch für Preise[j]-Münzen kaufen können, um ein neues Angebot zu erhalten.
Geben Sie die Mindestanzahl an Münzen zurück, die zum Erwerb aller Früchte erforderlich ist.

Beispiel 1:

Eingabe: prices= [3,1,2]
Ausgabe: 4
Erklärung: Sie können die Früchte wie folgt erwerben:
- Kaufe die 1. Frucht mit 3 Münzen, die 2. Frucht darfst du kostenlos nehmen.
- Kaufe die 2. Frucht mit 1 Münze, die 3. Frucht darfst du kostenlos nehmen.
- Nehmen Sie die 3. Frucht kostenlos.
Beachten Sie, dass Sie die zweite Frucht zwar kostenlos nehmen durften, diese aber gekauft haben, weil sie optimaler ist.
Es kann nachgewiesen werden, dass 4 die Mindestanzahl an Münzen ist, die zum Erwerb aller Früchte benötigt wird.

Beispiel 2:

Eingabe: prices= [1,10,1,1]
Ausgabe: 2
Erklärung: Sie können die Früchte wie folgt erwerben:
- Kaufe die 1. Frucht mit 1 Münze, die 2. Frucht darfst du kostenlos nehmen.
- Nehmen Sie die 2. Frucht kostenlos.
- Kaufen Sie die 3. Frucht für 1 Münze, die 4. Frucht dürfen Sie kostenlos nehmen.
- Nehmen Sie die 4^t^h-Früchte kostenlos.
Es kann nachgewiesen werden, dass 2 die Mindestanzahl an Münzen ist, die zum Erwerb aller Früchte benötigt wird.

Einschränkungen:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5

Sie befinden sich auf einem Obstmarkt, auf dem verschiedene Arten exotischer Früchte ausgestellt sind.
Sie erhalten ein 1-indiziertes Array „Preise“, wobei „Preise[i]“ die Anzahl der Münzen angibt, die zum Kauf der i^ten Frucht benötigt werden.
Der Obstmarkt hat folgendes Angebot:

Wenn Sie die i^-te Frucht zu Preisen[i]-Münzen kaufen, können Sie die nächste i-te Frucht kostenlos erhalten.

Beachten Sie, dass Sie Früchte j auch dann erhalten können, wenn Sie sie kostenlos erhalten, sie aber dennoch für Preise[j]-Münzen kaufen können, um ein neues Angebot zu erhalten.
Geben Sie die Mindestanzahl an Münzen zurück, die zum Erwerb aller Früchte erforderlich ist.

Beispiel 1:

Eingabe: Preise = [3,1,2]
Ausgabe: 4
Erklärung: Sie können die Früchte wie folgt erwerben:
- Kaufe die 1. Frucht mit 3 Münzen, die 2. Frucht darfst du kostenlos nehmen.
- Kaufe die 2. Frucht mit 1 Münze, die 3. Frucht darfst du kostenlos nehmen.
- Nehmen Sie die 3. Frucht kostenlos.
Beachten Sie, dass Sie die zweite Frucht zwar kostenlos nehmen durften, diese aber gekauft haben, weil sie optimaler ist.
Es kann nachgewiesen werden, dass 4 die Mindestanzahl an Münzen ist, die zum Erwerb aller Früchte benötigt wird.

Beispiel 2:

Eingabe: Preise = [1,10,1,1]
Ausgabe: 2
Erklärung: Sie können die Früchte wie folgt erwerben:
- Kaufe die 1. Frucht mit 1 Münze, die 2. Frucht darfst du kostenlos nehmen.
- Nehmen Sie die 2. Frucht kostenlos.
- Kaufen Sie die 3. Frucht für 1 Münze, die 4. Frucht dürfen Sie kostenlos nehmen.
- Nehmen Sie die 4^t^h-Früchte kostenlos.
Es kann nachgewiesen werden, dass 2 die Mindestanzahl an Münzen ist, die zum Erwerb aller Früchte benötigt wird.

Einschränkungen:

1 <= Preise.Länge <= 1000
1 <= Preise[i] <= 10^5

Sie befinden sich auf einem Obstmarkt mit verschiedenen Arten von exotischen Früchten.
Sie erhalten eine 1-indizierte Array-Preise, bei der die Preise [i] die Anzahl der Münzen bezeichnen, die für den Kauf der I^th Frucht benötigt werden.
Der Obstmarkt hat das folgende Angebot:

Wenn Sie das Frucht zu das i-te Frucht zu Preisen[i] Münzen kaufen, können Sie die nächste i-te Früchte kostenlos bekommen.

Beachten Sie, dass Sie es auch dann für Preise[j] Münzen kaufen können, um ein neues Angebot zu erhalten.
Geben Sie die Mindestanzahl von Münzen zurück, die zum Erwerb aller Früchte benötigt werden.

Beispiel 1:

Eingabe: prices = [3,1,2]
Ausgabe: 4
Erläuterung: Sie können die Früchte wie folgt erwerben:
- Kaufen Sie die 1. Frucht mit 3 Münzen, Sie dürfen die 2^nd Frucht kostenlos nehmen.
- Kaufen Sie die 2^nd Frucht mit 1 Münze, Sie dürfen die 3^rd -Früchte kostenlos nehmen.
- Nehmen Sie die 3^rd Frucht kostenlos.
Beachten Sie, dass Sie es gekauft haben, obwohl Sie die 2. Frucht kostenlos nehmen durften, weil es optimaler ist.
Es kann nachgewiesen werden, dass 4 die Mindestanzahl von Münzen ist, die zum Erwerb aller Früchte benötigt werden.

Beispiel 2:

Eingabe: prices = [1,10,1,1]
Ausgabe: 2
Erläuterung: Sie können die Früchte wie folgt erwerben:
- Kaufen Sie die 1^st -Früchte mit 1 Münze, Sie dürfen die 2^nd Frucht kostenlos nehmen.
- Nehmen Sie die 2^nd Frucht kostenlos.
- Kaufen Sie die 3. Frucht für 1 Münze, Sie dürfen die 4^th -Frucht kostenlos nehmen.
- Nehmen Sie die 4. Frucht kostenlos.
Es kann nachgewiesen werden, dass 2 die Mindestanzahl von Münzen ist, die für den Erwerb aller Früchte benötigt werden.

Einschränkungen:

1 <= prices.length <= 1000
1 <= prices[i] <= 10^5


Sie erhalten eine Zeichenfolge s und eine positive ganze Zahl k.
Vokale und Konsonanten seien die Anzahl der Vokale und Konsonanten in einer Zeichenfolge.
Eine Saite ist schön, wenn:

Vokale == Konsonanten.
(Vokale * Konsonanten) % k == 0, mit anderen Worten, die Multiplikation von Vokalen und Konsonanten ist durch k teilbar.

Gibt die Anzahl der nicht leeren schönen Teilzeichenfolgen in den angegebenen Zeichenfolgen zurück.
Ein Teilstring ist eine zusammenhängende Folge von Zeichen in einem String.
Vokalbuchstaben im Englischen sind „a“, „e“, „i“, „o“ und „u“.
Konsonantenbuchstaben im Englischen sind alle Buchstaben außer Vokalen.

Beispiel 1:

Eingabe: s = „baeyh“, k = 2
Ausgabe: 2
Erläuterung: Die angegebene Zeichenfolge enthält zwei schöne Teilzeichenfolgen.
- Teilzeichenfolge „baeyh“, Vokale = 2 ([„a“, e“]), Konsonanten = 2 ([„y“, „h“]).
Sie können sehen, dass die Zeichenfolge „aeyh“ als Vokale == Konsonanten und Vokale * Konsonanten % k == 0 schön ist.
- Teilzeichenfolge „baeyh“, Vokale = 2 ([„a“, e“]), Konsonanten = 2 ([„b“, „y“]).
Sie können sehen, dass die Zeichenfolge „baey“ als Vokale == Konsonanten und Vokale * Konsonanten % k == 0 schön ist.
Es kann gezeigt werden, dass der gegebene String nur 2 schöne Teilstrings enthält.

Beispiel 2:

Eingabe: s = „abba“, k = 1
Ausgabe: 3
Erläuterung: Die angegebene Zeichenfolge enthält drei schöne Teilzeichenfolgen.
- Teilzeichenfolge „abba“, Vokale = 1 ([„a“]), Konsonanten = 1 ([„b“]).
- Teilzeichenfolge „abba“, Vokale = 1 ([„a“]), Konsonanten = 1 ([„b“]).
- Teilzeichenfolge „abba“, Vokale = 2 ([„a“, „a“]), Konsonanten = 2 ([„b“, „b“]).
Es kann gezeigt werden, dass der gegebene String nur 3 schöne Teilstrings enthält.

Beispiel 3:

Eingabe: s = „bcdf“, k = 1
Ausgabe: 0
Erläuterung: Die angegebene Zeichenfolge enthält keine schönen Teilzeichenfolgen.

Einschränkungen:

1 <= s.length <= 1000
1 <= k <= 1000
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenfolge s und eine positive ganze Zahl k.
Vokale und Konsonanten seien die Anzahl der Vokale und Konsonanten in einer Zeichenfolge.
Eine Zeichenkette ist schön, wenn:

Vokale == Konsonanten.
(Vokale * Konsonanten) % k == 0, mit anderen Worten, die Multiplikation von Vokalen und Konsonanten ist durch k teilbar.

Gibt die Anzahl der nicht leeren schönen Teilzeichenfolgen in den angegebenen Zeichenfolgen zurück.
Ein substring ist eine zusammenhängende Folge von Zeichen in einem String.
Vokalbuchstaben im Englischen sind 'a', 'e', 'i', 'o',  und 'u'.
Konsonantenbuchstaben im Englischen sind alle Buchstaben außer Vokalen.

Beispiel 1:

Eingabe: s = "baeyh", k = 2
Ausgabe: 2
Erläuterung: Die angegebene Zeichenfolge enthält zwei schöne Teilzeichenfolgen.
- Teilzeichenfolge "baeyh", Vokale = 2 (["a",e"]), Konsonanten = 2 (["y","h"]).
Sie können sehen, dass die Zeichenfolge "aeyh" wenn Vokale == Konsonanten und Vokale * Konsonanten % k == 0 schön ist.
- Teilzeichenfolge "baeyh", Vokale = 2 (["a",e"]), Konsonanten = 2 (["b","y"]).
Sie können sehen, dass die Zeichenfolge "baey" wenn Vokale == Konsonanten und Vokale * Konsonanten % k == 0 schön ist.
Es kann gezeigt werden, dass der gegebene String nur 2 schöne substrings enthält.

Beispiel 2:

Eingabe: s = "abba", k = 1
Ausgabe: 3
Erläuterung: Die angegebene Zeichenfolge enthält drei schöne Teilzeichenfolgen.
- Teilzeichenfolge "abba", Vokale = 1 (["a"]), Konsonanten = 1 (["b"]).
- Teilzeichenfolge "abba", Vokale = 1 (["a"]), Konsonanten = 1 (["b"]).
- Teilzeichenfolge "abba", Vokale = 2 (["a","a"]), Konsonanten = 2 (["b","b"]).
Es kann gezeigt werden, dass der gegebene String nur 3 schöne substrings enthält.

Beispiel 3:

Eingabe: s = "bcdf", k = 1
Ausgabe: 0
Erläuterung: Die angegebene Zeichenfolge enthält keine schönen Teilzeichenfolgen.

Einschränkungen:

1 <= s.length <= 1000
1 <= k <= 1000
s besteht nur aus englischen Kleinbuchstaben.


Du hast ein 0-indiziertes Ganzzahl-Array nums.
Du kannst eine beliebige Anzahl von Operationen durchführen, wobei jede Operation das Auswählen eines Teilarrays des Arrays und dessen Ersetzen durch die Summe seiner Elemente beinhaltet. Zum Beispiel, wenn das gegebene Array [1,3,5,6] ist und du das Teilarray [3,5] auswählst, wird das Array zu [1,8,6].
Gib die maximale Länge eines nicht abnehmenden Arrays zurück, die nach Durchführung von Operationen erreicht werden kann.
Ein Teilarray ist eine zusammenhängende, nicht leere Sequenz von Elementen innerhalb eines Arrays.

Beispiel 1:

Input: nums = [5,2,2]
Output: 1
Erklärung: Dieses Array mit der Länge 3 ist nicht nicht-abnehmend.
Wir haben zwei Möglichkeiten, das Array auf Länge zwei zu bringen.
Erstens, die Auswahl des Teilarrays [2,2] konvertiert das Array zu [5,4].
Zweitens, die Auswahl des Teilarrays [5,2] konvertiert das Array zu [7,2].
In diesen beiden Fällen ist das Array nicht nicht-abnehmend.
Und wenn wir das Teilarray [5,2,2] auswählen und es durch [9] ersetzen, wird es nicht-abnehmend.
Also ist die Antwort 1.

Beispiel 2:

Input: nums = [1,2,3,4]
Output: 4
Erklärung: Das Array ist nicht-abnehmend. Also ist die Antwort 4.

Beispiel 3:

Input: nums = [4,3,2,6]
Output: 3
Erklärung: Das Ersetzen von [3,2] durch [5] konvertiert das gegebene Array zu [4,5,6], das nicht-abnehmend ist.
Da das gegebene Array nicht nicht-abnehmend ist, ist die maximal mögliche Antwort 3.

Constraints:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums.
Sie können eine beliebige Anzahl von Operationen ausführen, wobei jede Operation die Auswahl eines Unterarrays des Arrays und dessen Ersetzung durch die Summe seiner Elemente umfasst. Wenn das angegebene Array beispielsweise [1,3,5,6] ist und Sie das Unterarray [3,5] auswählen, wird das Array in [1,8,6] konvertiert.
Gibt die maximale Länge eines nicht abnehmenden Arrays zurück, die nach der Anwendung von Operationen erstellt werden kann.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [5,2,2]
Ausgabe: 1
Erläuterung: Dieses Array mit der Länge 3 ist nicht nicht abnehmend.
Wir haben zwei Möglichkeiten, die Array-Länge auf zwei zu erhöhen.
Wenn Sie zunächst das Subarray [2,2] auswählen, wird das Array in [5,4] konvertiert.
Zweitens wird durch Auswahl des Subarrays [5,2] das Array in [7,2] konvertiert.
Auf diese beiden Arten ist das Array nicht nicht abnehmend.
Und wenn wir das Subarray [5,2,2] wählen und es durch [9] ersetzen, wird es nicht abnehmend.
Die Antwort ist also 1.

Beispiel 2:

Eingabe: nums = [1,2,3,4]
Ausgabe: 4
Erläuterung: Das Array nimmt nicht ab. Die Antwort ist also 4.

Beispiel 3:

Eingabe: nums = [4,3,2,6]
Ausgabe: 3
Erläuterung: Durch Ersetzen von [3,2] durch [5] wird das angegebene Array in [4,5,6] konvertiert, das nicht abnehmend ist.
Da das angegebene Array nicht nicht abnehmend ist, ist die maximal mögliche Antwort 3.

Einschränkungen:

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

Sie erhalten eine 0-indiziert Integer Array nums.
Sie können eine beliebige Anzahl von Operationen ausführen, wobei bei jeder Operation ein Unterbarray des Arrays ausgewählt und durch die Summe seiner Elemente ersetzt wird. Wenn das angegebene Array beispielsweise [1,3,5,6] beträgt und Sie Unterarray [3,5] auswählen, werden das Array in [1,8,6] wird.
Geben Sie die maximale Länge eines nicht abgeschreck Arrays zurück, das nach Anwendung von Operationen erfolgen kann.
Ein Subtarray ist eine zusammenhängende nicht leere Abfolge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [5,2,2]
Ausgabe: 1
Erklärung: Dieses Array mit Länge 3 ist nicht nicht abgeschreckt.
Wir haben zwei Möglichkeiten, die Arraylänge zwei zu machen.
Zunächst wird die Auswahl von Unterarray [2,2] das Array in [5,4].
Zweitens wird die Auswahl von Unterarray [5,2] das Array in [7,2].
In diesen beiden Arten ist das Array nicht nicht abfällt.
Und wenn wir Unterarray [5,2,2] wählen und es durch [9] ersetzen, wird es nicht abgeschreckt.
Die Antwort ist also 1.

Beispiel 2:

Eingabe: nums = [1,2,3,4]
Ausgabe: 4
Erklärung: Das Array ist nicht abgeschreckt. Die Antwort ist also 4.

Beispiel 3:

Eingabe: nums = [4,3,2,6]
Ausgabe: 3
Erklärung: Das Ersetzen von [3,2] durch [5] wird das angegebene Array in [4,5,6], das nicht abfällt.
Da das angegebene Array nicht nicht abfällt, beträgt die maximal mögliche Antwort 3.

Einschränkungen:

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


Du hast ein 0-indiziertes Array nums, das aus positiven ganzen Zahlen besteht.
Eine Partition eines Arrays in ein oder mehrere zusammenhängende Teilarrays wird als gut bezeichnet, wenn keine zwei Teilarrays die gleiche Zahl enthalten.
Gib die Gesamtzahl der guten Partitionen von nums zurück.
Da die Antwort groß sein kann, gib sie modulo 10^9 + 7 zurück.

Beispiel 1:

Input: nums = [1,2,3,4]
Output: 8
Erläuterung: Die 8 möglichen guten Partitionen sind: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), und ([1,2,3,4]).

Beispiel 2:

Input: nums = [1,1,1,1]
Output: 1
Erläuterung: Die einzige mögliche gute Partition ist: ([1,1,1,1]).

Beispiel 3:

Input: nums = [1,2,1,3]
Output: 2
Erläuterung: Die 2 möglichen guten Partitionen sind: ([1,2,1], [3]) und ([1,2,1,3]).

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums, das aus positiven ganzen Zahlen besteht.
Eine Aufteilung eines Arrays in ein oder mehrere zusammenhängende Subarrays wird als gut bezeichnet, wenn keine zwei Subarrays die gleiche Anzahl enthalten.
Gibt die Gesamtzahl der guten Partitionen von nums zurück.
Da die Antwort groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: nums = [1,2,3,4]
Ausgabe: 8
Erläuterung: Die 8 möglichen guten Partitionen sind: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2 ,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4 ]), ([1,2,3], [4]) und ([1,2,3,4]).

Beispiel 2:

Eingabe: nums = [1,1,1,1]
Ausgabe: 1
Erläuterung: Die einzig mögliche gute Partition ist: ([1,1,1,1]).

Beispiel 3:

Eingabe: nums = [1,2,1,3]
Ausgabe: 2
Erläuterung: Die zwei möglichen guten Partitionen sind: ([1,2,1], [3]) und ([1,2,1,3]).

Einschränkungen:

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


Sie erhalten ein ganzzahliges Array nums und eine positive Ganzzahl k.
Gibt die Anzahl der Unterarrays zurück, in denen das maximale Element von nums mindestens k-mal in diesem Unterarray vorkommt.
Ein Subarray ist eine zusammenhängende Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,3,2,3,3], k = 2
Ausgang: 6
Erklärung: Die Subarrays, die das Element 3 mindestens 2 Mal enthalten, sind: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] und [3,3].

Beispiel 2:

Eingabe: nums = [1,4,2,1], k = 3
Ausgang: 0
Erklärung: Kein Subarray enthält das Element 4 mindestens 3 Mal.

Zwänge:

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

Sie erhalten ein ganzzahliges Array nums und eine positive ganze Zahl k.
Gibt die Anzahl der Subarrays zurück, in denen das maximale Element von nums mindestens k-mal in diesem Subarray vorkommt.
Ein Subarray ist eine zusammenhängende Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,3,2,3,3], k = 2
Ausgabe: 6
Erläuterung: Die Subarrays, die das Element 3 mindestens zweimal enthalten, sind: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2, 3,3], [2,3,3] und [3,3].

Beispiel 2:

Eingabe: Zahlen = [1,4,2,1], k = 3
Ausgabe: 0
Erläuterung: Kein Subarray enthält das Element 4 mindestens dreimal.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums und eine positive ganze Zahl k.
Gibt die Anzahl der Subarrays zurück, in denen das maximale Element von nums mindestens k-mal in diesem Subarray vorkommt.
Ein Subarray ist eine zusammenhängende Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,3,2,3,3], k = 2
Ausgabe: 6
Erläuterung: Die Subarrays, die das Element 3 mindestens zweimal enthalten, sind: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2, 3,3], [2,3,3] und [3,3].

Beispiel 2:

Eingabe: nums = [1,4,2,1], k = 3
Ausgabe: 0
Erläuterung: Kein Subarray enthält das Element 4 mindestens dreimal.

Einschränkungen:

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


Sie erhalten eine 0-indizierte Anordnung positiver ganzer Zahlen nums und eine positive ganze Zahl limit.
In einer Operation können Sie zwei beliebige Indizes i und j wählen und nums[i] und nums[j] vertauschen, wenn |nums[i] - nums[j]| <= limit.
Gibt das lexikografisch kleinste Array zurück, das durch beliebig häufiges Ausführen der Operation erhalten werden kann.
Ein Array a ist lexikografisch kleiner als ein Array b, wenn an der ersten Position, an der sich a und b unterscheiden, das Array a ein Element hat, das kleiner ist als das entsprechende Element in b. Zum Beispiel ist das Array [2,10,3] lexikografisch kleiner als das Array [10,2,3], weil sie sich bei Index 0 und 2 < 10 unterscheiden.

Beispiel 1:

Eingabe: nums = [1,5,3,9,8], limit = 2
Ausgang: [1,3,5,8,9]
Erklärung: Wenden Sie die Operation 2 Mal an:
- Vertauschen Sie nums[1] mit nums[2]. Das Feld wird zu [1,3,5,9,8].
- Vertausche nums[3] mit nums[4]. Das Feld wird zu [1,3,5,8,9].
Wir können kein lexikographisch kleineres Array erhalten, indem wir weitere Operationen anwenden.
Beachten Sie, dass es möglich sein kann, das gleiche Ergebnis zu erzielen, indem Sie verschiedene Vorgänge ausführen.

Beispiel 2:

Eingabe: nums = [1,7,6,18,2,1], limit = 3
Ausgang: [1,6,7,18,1,2]
Erklärung: Wenden Sie die Operation 3 Mal an:
- Vertauschen Sie nums[1] mit nums[2]. Die Anordnung wird zu [1,6,7,18,2,1].
- Vertausche nums[0] mit nums[4]. Die Anordnung wird zu [2,6,7,18,1,1].
- Tausche nums[0] mit nums[5]. Die Anordnung wird zu [1,6,7,18,1,2].
Wir können kein lexikographisch kleineres Array erhalten, indem wir weitere Operationen anwenden.

Beispiel 3:

Eingabe: nums = [1,7,28,19,10], limit = 3
Ausgang: [1,7,28,19,10]
Erklärung: [1,7,28,19,10] ist das lexikographisch kleinste Array, das wir erhalten können, da wir die Operation nicht auf zwei beliebige Indizes anwenden können.

Zwänge:

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

Sie erhalten ein 0-indiziertes Array positiver Ganzzahlen und eine positive Ganzzahl-Grenze.
In einer Operation können Sie zwei beliebige Indizes i und j auswählen und nums[i] und nums[j] vertauschen, wenn |nums[i] - nums[j]| <= Grenze.
Gibt das lexikographisch kleinste Array zurück, das durch beliebig oft ausgeführte Operation erhalten werden kann.
Ein Array a ist lexikografisch kleiner als ein Array b, wenn Array a an der ersten Position, an der sich a und b unterscheiden, ein Element enthält, das kleiner als das entsprechende Element in b ist. Beispielsweise ist das Array [2,10,3] lexikografisch kleiner als das Array [10,2,3], da sie sich bei Index 0 und 2 < 10 unterscheiden.

Beispiel 1:

Eingabe: Nums = [1,5,3,9,8], Grenze = 2
Ausgabe: [1,3,5,8,9]
Erläuterung: Führen Sie den Vorgang zweimal durch:
- Tausche Nums[1] mit Nums[2]. Das Array wird zu [1,3,5,9,8]
- Tausche Nums[3] mit Nums[4]. Das Array wird zu [1,3,5,8,9]
Wir können kein lexikographisch kleineres Array erhalten, indem wir weitere Operationen anwenden.
Beachten Sie, dass es möglich sein kann, das gleiche Ergebnis zu erzielen, indem Sie verschiedene Vorgänge ausführen.

Beispiel 2:

Eingabe: Nums = [1,7,6,18,2,1], Grenze = 3
Ausgabe: [1,6,7,18,1,2]
Erläuterung: Führen Sie die Operation dreimal durch:
- Tausche Nums[1] mit Nums[2]. Das Array wird zu [1,6,7,18,2,1]
- Tausche Nums[0] mit Nums[4]. Das Array wird zu [2,6,7,18,1,1]
- Tausche Nums[0] mit Nums[5]. Das Array wird zu [1,6,7,18,1,2]
Wir können kein lexikographisch kleineres Array erhalten, indem wir weitere Operationen anwenden.

Beispiel 3:

Eingabe: Nums = [1,7,28,19,10], Grenze = 3
Ausgabe: [1,7,28,19,10]
Erläuterung: [1,7,28,19,10] ist das lexikographisch kleinste Array, das wir erhalten können, da wir die Operation nicht auf zwei beliebige Indizes anwenden können.

Einschränkungen:

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

Du hast ein 0-indiziertes Array positiver Ganzzahlen nums und eine positive Ganzzahl limit.
In einer Operation kannst du zwei beliebige Indizes i und j auswählen und nums[i] und nums[j] vertauschen, wenn |nums[i] - nums[j]| <= limit.
Gib das lexikografisch kleinste Array zurück, das durch beliebig viele Ausführungen der Operation erhalten werden kann.
Ein Array a ist lexikografisch kleiner als ein Array b, wenn an der ersten Position, an der a und b sich unterscheiden, Array a ein Element hat, das kleiner als das entsprechende Element in b ist. Zum Beispiel ist das Array [2,10,3] lexikografisch kleiner als das Array [10,2,3], weil sie sich an Index 0 unterscheiden und 2 < 10.

Beispiel 1:

Input: nums = [1,5,3,9,8], limit = 2
Output: [1,3,5,8,9]
Erklärung: Führe die Operation 2 Mal durch:
- Vertausche nums[1] mit nums[2]. Das Array wird [1,3,5,9,8]
- Vertausche nums[3] mit nums[4]. Das Array wird [1,3,5,8,9]
Wir können kein lexikografisch kleineres Array erhalten, indem wir weitere Operationen ausführen.
Es könnte möglich sein, das gleiche Ergebnis durch andere Operationen zu erzielen.

Beispiel 2:

Input: nums = [1,7,6,18,2,1], limit = 3
Output: [1,6,7,18,1,2]
Erklärung: Führe die Operation 3 Mal durch:
- Vertausche nums[1] mit nums[2]. Das Array wird [1,6,7,18,2,1]
- Vertausche nums[0] mit nums[4]. Das Array wird [2,6,7,18,1,1]
- Vertausche nums[0] mit nums[5]. Das Array wird [1,6,7,18,1,2]
Wir können kein lexikografisch kleineres Array erhalten, indem wir weitere Operationen ausführen.

Beispiel 3:

Input: nums = [1,7,28,19,10], limit = 3
Output: [1,7,28,19,10]
Erklärung: [1,7,28,19,10] ist das lexikografisch kleinste Array, das wir erhalten können, da wir die Operation bei keinem Paar von Indices anwenden können.

Constraints:

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


Sie erhalten ein 0-indiziertes ganzzahliges Array „batteryPercentages“ mit der Länge n, das die Batterieprozentsätze von n 0-indizierten Geräten angibt.
Ihre Aufgabe besteht darin, jedes Gerät i in der Reihenfolge von 0 bis n - 1 zu testen, indem Sie die folgenden Testoperationen durchführen:

Wenn „batteryPercentages[i]“ größer als 0 ist:

Erhöhen Sie die Anzahl der getesteten Geräte.
Verringern Sie den Batterieprozentsatz aller Geräte mit Indizes j im Bereich [i + 1, n – 1] um 1 und stellen Sie sicher, dass ihr Batterieprozentsatz niemals unter 0 fällt, d. h. BatteryPercentages[j] = max(0, BatteryPercentages[j] – 1).
Wechseln Sie zum nächsten Gerät.

Andernfalls wechseln Sie zum nächsten Gerät, ohne einen Test durchzuführen.

Gibt eine Ganzzahl zurück, die die Anzahl der Geräte angibt, die getestet werden, nachdem die Testvorgänge der Reihe nach ausgeführt wurden.

Beispiel 1:

Eingabe: BatteryPercentages = [1,1,2,1,3]
Ausgabe: 3
Erläuterung: Durchführung der Testvorgänge der Reihe nach, beginnend mit Gerät 0:
Bei Gerät 0 ist „batteryPercentages[0]“ > 0, es gibt also jetzt 1 getestetes Gerät und „batteryPercentages“ wird zu [1,0,1,0,2].
Bei Gerät 1 ist „batteryPercentages[1]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 2 ist „batteryPercentages[2]“ > 0, sodass jetzt zwei getestete Geräte vorhanden sind und „batteryPercentages“ zu [1,0,1,0,1] wird.
Bei Gerät 3 ist „batteryPercentages[3]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 4 ist „batteryPercentages[4]“ > 0, es gibt also jetzt 3 getestete Geräte und „batteryPercentages“ bleibt gleich.
Die Antwort ist also 3.

Beispiel 2:

Eingabe: BatteryPercentages = [0,1,2]
Ausgabe: 2
Erläuterung: Durchführen der Testvorgänge in der angegebenen Reihenfolge, beginnend mit Gerät 0:
Bei Gerät 0 ist „batteryPercentages[0]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 1 ist „batteryPercentages[1]“ > 0, es gibt also jetzt 1 getestetes Gerät und „batteryPercentages“ wird zu [0,1,1].
Bei Gerät 2 ist „batteryPercentages[2]“ > 0, es gibt also jetzt zwei getestete Geräte und „batteryPercentages“ bleibt gleich.
Die Antwort ist also 2.

Einschränkungen:

1 <= n == batteryPercentages.length <= 100
0 <= batteriePercentages[i] <= 100

Sie erhalten ein 0-indiziertes ganzzahliges Array „batteryPercentages“ mit der Länge n, das die Batterieprozentsätze von n 0-indizierten Geräten angibt.
Ihre Aufgabe besteht darin, jedes Gerät i in der Reihenfolge von 0 bis n - 1 zu testen, indem Sie die folgenden Testoperationen durchführen:

Wenn „batteryPercentages[i]“ größer als 0 ist:

Erhöhen Sie die Anzahl der getesteten Geräte.
Verringern Sie den Batterieprozentsatz aller Geräte mit Indizes j im Bereich [i + 1, n – 1] um 1 und stellen Sie sicher, dass ihr Batterieprozentsatz niemals unter 0 fällt, d. h. BatteryPercentages[j] = max(0, BatteryPercentages[j] – 1).
Wechseln Sie zum nächsten Gerät.

Andernfalls wechseln Sie zum nächsten Gerät, ohne einen Test durchzuführen.

Gibt eine Ganzzahl zurück, die die Anzahl der Geräte angibt, die getestet werden, nachdem die Testvorgänge der Reihe nach ausgeführt wurden.

Beispiel 1:

Eingabe: BatteryPercentages = [1,1,2,1,3]
Ausgabe: 3
Erläuterung: Durchführen der Testvorgänge in der angegebenen Reihenfolge, beginnend mit Gerät 0:
Bei Gerät 0 ist „batteryPercentages[0]“ > 0, es gibt also jetzt 1 getestetes Gerät und „batteryPercentages“ wird zu [1,0,1,0,2].
Bei Gerät 1 ist „batteryPercentages[1]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 2 ist „batteryPercentages[2]“ > 0, sodass jetzt zwei getestete Geräte vorhanden sind und „batteryPercentages“ zu [1,0,1,0,1] wird.
Bei Gerät 3 ist „batteryPercentages[3]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 4 ist „batteryPercentages[4]“ > 0, es gibt also jetzt 3 getestete Geräte und „batteryPercentages“ bleibt gleich.
Die Antwort ist also 3.

Beispiel 2:

Eingabe: BatteryPercentages = [0,1,2]
Ausgabe: 2
Erläuterung: Durchführen der Testvorgänge in der angegebenen Reihenfolge, beginnend mit Gerät 0:
Bei Gerät 0 ist „batteryPercentages[0]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 1 ist „batteryPercentages[1]“ > 0, es gibt also jetzt 1 getestetes Gerät und „batteryPercentages“ wird zu [0,1,1].
Bei Gerät 2 ist „batteryPercentages[2]“ > 0, es gibt also jetzt zwei getestete Geräte und „batteryPercentages“ bleibt gleich.
Die Antwort ist also 2.

Einschränkungen:

1 <= n == batteryPercentages.length <= 100
0 <= batteriePercentages[i] <= 100

Sie erhalten ein 0-indiziertes ganzzahliges Array „batteryPercentages“ mit der Länge n, das die Batterieprozentsätze von n 0-indizierten Geräten angibt.
Ihre Aufgabe besteht darin, jedes Gerät i in der Reihenfolge von 0 bis n - 1 zu testen, indem Sie die folgenden Testoperationen durchführen:

Wenn „batteryPercentages[i]“ größer als 0 ist:

Erhöhen Sie die Anzahl der getesteten Geräte.
Verringern Sie den Batterieprozentsatz aller Geräte mit den Indizes j im Bereich [i + 1, n – 1] um 1 und stellen Sie sicher, dass ihr Batterieprozentsatz niemals unter 0 fällt, d. h. BatteryPercentages[j] = max(0, BatteryPercentages[j] – 1).
Wechseln Sie zum nächsten Gerät.

Andernfalls wechseln Sie zum nächsten Gerät, ohne einen Test durchzuführen.

Gibt eine Ganzzahl zurück, die die Anzahl der Geräte angibt, die getestet werden, nachdem die Testvorgänge der Reihe nach ausgeführt wurden.

Beispiel 1:

Eingabe: BatteryPercentages = [1,1,2,1,3]
Ausgabe: 3
Erläuterung: Durchführen der Testvorgänge in der angegebenen Reihenfolge, beginnend mit Gerät 0:
Bei Gerät 0 ist „batteryPercentages[0]“ > 0, es gibt also jetzt 1 getestetes Gerät und „batteryPercentages“ wird zu [1,0,1,0,2].
Bei Gerät 1 ist „batteryPercentages[1]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 2 ist „batteryPercentages[2]“ > 0, sodass jetzt zwei getestete Geräte vorhanden sind und „batteryPercentages“ zu [1,0,1,0,1] wird.
Bei Gerät 3 ist „batteryPercentages[3]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 4 ist „batteryPercentages[4]“ > 0, es gibt also jetzt 3 getestete Geräte und „batteryPercentages“ bleibt gleich.
Die Antwort ist also 3.

Beispiel 2:

Eingabe: BatteryPercentages = [0,1,2]
Ausgabe: 2
Erläuterung: Durchführen der Testvorgänge in der angegebenen Reihenfolge, beginnend mit Gerät 0:
Bei Gerät 0 ist „batteryPercentages[0]“ == 0, sodass wir ohne Tests zum nächsten Gerät wechseln.
Bei Gerät 1 ist „batteryPercentages[1]“ > 0, es gibt also jetzt 1 getestetes Gerät und „batteryPercentages“ wird zu [0,1,1].
Bei Gerät 2 ist „batteryPercentages[2]“ > 0, es gibt also jetzt zwei getestete Geräte und „batteryPercentages“ bleibt gleich.
Die Antwort ist also 2.

Einschränkungen:

1 <= n == batteryPercentages.length <= 100
0 <= batteriePercentages[i] <= 100


Du hast ein 0-indiziertes Array namens "mountain". Deine Aufgabe ist es, alle Gipfel im "mountain"-Array zu finden. Gib ein Array zurück, das die Indizes der Gipfel im gegebenen Array in beliebiger Reihenfolge enthält.
Hinweise:

Ein Gipfel ist definiert als ein Element, das strikt größer ist als seine benachbarten Elemente.
Die ersten und letzten Elemente des Arrays sind kein Gipfel.

Beispiel 1:

Input: mountain = [2,4,4]
Output: []
Erklärung: mountain[0] und mountain[2] können keine Gipfel sein, da sie die ersten und letzten Elemente des Arrays sind.
mountain[1] kann ebenfalls kein Gipfel sein, da es nicht strikt größer ist als mountain[2].
Die Antwort ist also [].

Beispiel 2:

Input: mountain = [1,4,3,8,5]
Output: [1,3]
Erklärung: mountain[0] und mountain[4] können keine Gipfel sein, da sie die ersten und letzten Elemente des Arrays sind.
mountain[2] kann ebenfalls kein Gipfel sein, da es nicht strikt größer ist als mountain[3] und mountain[1].
Aber mountain[1] und mountain[3] sind strikt größer als ihre benachbarten Elemente.
Die Antwort ist also [1,3].

Einschränkungen:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Sie erhalten einen 0-indizierten Array-Berg. Ihre Aufgabe ist es, alle Gipfel der Bergkette zu finden.
Gibt ein Array zurück, das aus Indizes von Peaks im angegebenen Array in beliebiger Reihenfolge besteht.
Hinweise:

Ein Peak ist als ein Element definiert, das unbedingt größer ist als seine Nachbarelemente.
Das erste und letzte Element des Arrays sind kein Peak.

Beispiel 1:

Eingabe: mountain = [2,4,4]
Ausgabe: []
Erläuterung: Berg[0] und Berg[2] können kein Gipfel sein, da sie das erste und letzte Element des Arrays sind.
Berg[1] kann auch kein Gipfel sein, da er nicht unbedingt größer als Berg[2] ist.
Die Antwort lautet also [].

Beispiel 2:

Eingabe: mountain = [1,4,3,8,5]
Ausgabe: [1,3]
Erläuterung: Berg[0] und Berg[4] können kein Gipfel sein, da sie das erste und letzte Element des Arrays sind.
Berg[2] kann auch kein Gipfel sein, da er nicht unbedingt größer als Berg[3] und Berg[1] ist.
Aber Berg [1] und Berg [3] sind streng genommen größer als ihre Nachbarelemente.
Die Antwort lautet also [1,3].

Einschränkungen:

3 <= mountain.length <= 100
1 <= mountain[i] <= 100

Sie erhalten einen 0-indizierten Array-Berg. Ihre Aufgabe ist es, alle Gipfel der Bergkette zu finden.
Gibt ein Array zurück, das aus Indizes von Peaks im angegebenen Array in beliebiger Reihenfolge besteht.
Hinweise:

Ein Peak ist als ein Element definiert, das unbedingt größer ist als seine Nachbarelemente.
Das erste und letzte Element des Arrays sind kein Peak.

Beispiel 1:

Eingabe: Berg = [2,4,4]
Ausgabe: []
Erläuterung: Berg[0] und Berg[2] können kein Gipfel sein, da sie das erste und letzte Element des Arrays sind.
Berg[1] kann auch kein Gipfel sein, da er nicht unbedingt größer als Berg[2] ist.
Die Antwort lautet also [].

Beispiel 2:

Eingabe: Berg = [1,4,3,8,5]
Ausgabe: [1,3]
Erläuterung: Berg[0] und Berg[4] können kein Gipfel sein, da sie das erste und letzte Element des Arrays sind.
Berg[2] kann auch kein Gipfel sein, da er nicht unbedingt größer als Berg[3] und Berg[1] ist.
Aber Berg [1] und Berg [3] sind streng genommen größer als ihre Nachbarelemente.
Die Antwort lautet also [1,3].

Einschränkungen:

3 <= Berglänge <= 100
1 <= Berg[i] <= 100


Sie erhalten ein Zeichenfolgenwort und eine Ganzzahl k.
Eine Teilzeichenfolge s eines Wortes ist vollständig, wenn:

Jedes Zeichen in s kommt genau k-mal vor.
Der Unterschied zwischen zwei benachbarten Zeichen beträgt höchstens 2. Das heißt, für zwei benachbarte Zeichen c1 und c2 in s beträgt der absolute Unterschied in ihren Positionen im Alphabet höchstens 2.

Gibt die Anzahl der vollständigen Teilzeichenfolgen eines Wortes zurück.
Eine Teilzeichenfolge ist eine nicht leere zusammenhängende Folge von Zeichen in einer Zeichenfolge.

Beispiel 1:

Eingabe: Wort = „igigee“, k = 2
Ausgabe: 3
Erläuterung: Die vollständigen Teilzeichenfolgen, bei denen jedes Zeichen genau zweimal vorkommt und der Unterschied zwischen benachbarten Zeichen höchstens 2 beträgt, sind: igigee, igigee, igigee.

Beispiel 2:

Eingabe: Wort = „aaabbbccc“, k = 3
Ausgabe: 6
Erläuterung: Die vollständigen Teilzeichenfolgen, in denen jedes Zeichen genau dreimal vorkommt und der Unterschied zwischen benachbarten Zeichen höchstens 2 beträgt, sind: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Einschränkungen:

1 <= Wortlänge <= 10^5
Das Wort besteht nur aus englischen Kleinbuchstaben.
1 <= k <= Wortlänge


Sie erhalten eine Ganzzahl n und ein 0-indiziertes Ganzzahlarray sick, das in aufsteigender Reihenfolge sortiert ist.
In einer Warteschlange stehen n Kinder, denen die Positionen 0 bis n – 1 zugewiesen sind. Das Feld „Krank“ enthält die Positionen der Kinder, die mit einer Infektionskrankheit infiziert sind. Ein infiziertes Kind an Position i kann die Krankheit auf jedes seiner unmittelbar benachbarten Kinder an Position i - 1 und i + 1 übertragen, sofern diese existieren und derzeit nicht infiziert sind. Höchstens ein Kind, das zuvor nicht infiziert war, kann sich in einer Sekunde mit der Krankheit infizieren.
Es lässt sich zeigen, dass sich nach einer endlichen Anzahl von Sekunden alle Kinder in der Warteschlange mit der Krankheit infizieren. Eine Infektionssequenz ist die Reihenfolge der Positionen, an denen alle nicht infizierten Kinder mit der Krankheit infiziert werden. Geben Sie die Gesamtzahl der möglichen Infektionssequenzen zurück.
Da die Antwort groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Beachten Sie, dass eine Infektionssequenz keine Positionen von Kindern enthält, die bereits zu Beginn mit der Krankheit infiziert waren.

Beispiel 1:

Eingabe: n = 5, sick = [0,4]
Ausgabe: 4
Erläuterung: Kinder an den Positionen 1, 2 und 3 sind zunächst nicht infiziert. Es gibt 4 mögliche Infektionssequenzen:
- Die Kinder an den Positionen 1 und 3 können infiziert werden, da ihre Positionen an die infizierten Kinder 0 und 4 angrenzen. Das Kind an Position 1 infiziert sich zuerst.
Nun grenzt das Kind an Position 2 an das Kind an Position 1, das infiziert ist, und das Kind an Position 3 an das Kind an Position 4, das infiziert ist, sodass beide infiziert werden können. Das Kind an Position 2 infiziert sich.
Schließlich infiziert sich das Kind an Position 3, weil es an infizierte Kinder an Position 2 und 4 angrenzt. Die Infektionssequenz ist [1,2,3].
- Die Kinder an den Positionen 1 und 3 können infiziert werden, da ihre Positionen an die infizierten Kinder 0 und 4 angrenzen. Das Kind an Position 1 infiziert sich zuerst.
Nun grenzt das Kind an Position 2 an das Kind an Position 1, das infiziert ist, und das Kind an Position 3 an das Kind an Position 4, das infiziert ist, sodass beide infiziert werden können. Das Kind an Position 3 infiziert sich.
Schließlich wird das Kind an Position 2 infiziert, weil es an infizierte Kinder an Position 1 und 3 angrenzt. Die Infektionssequenz ist [1,3,2].
- Die Infektionssequenz ist [3,1,2]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].
- Die Infektionssequenz ist [3,2,1]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].

Beispiel 2:

Eingabe: n = 4, sick = [1]
Ausgabe: 3
Erläuterung: Kinder an den Positionen 0, 2 und 3 sind zunächst nicht infiziert. Es gibt 3 mögliche Infektionssequenzen:
- Die Infektionssequenz ist [0,2,3]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- Die Infektionssequenz ist [2,0,3]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- Die Infektionssequenz ist [2,3,0]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].

Einschränkungen:

2 <= n <= 10^5
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
Krankmeldungen werden in aufsteigender Reihenfolge sortiert.

Sie erhalten eine Ganzzahl n und ein 0-indiziertes Ganzzahlarray sick, das in aufsteigender Reihenfolge sortiert ist.
In einer Warteschlange stehen n Kinder, denen die Positionen 0 bis n – 1 zugewiesen sind. Das Feld „Krank“ enthält die Positionen der Kinder, die mit einer Infektionskrankheit infiziert sind. Ein infiziertes Kind an Position i kann die Krankheit auf jedes seiner unmittelbar benachbarten Kinder an Position i - 1 und i + 1 übertragen, sofern diese existieren und derzeit nicht infiziert sind. Höchstens ein Kind, das zuvor nicht infiziert war, kann sich in einer Sekunde mit der Krankheit infizieren.
Es lässt sich zeigen, dass sich nach einer endlichen Anzahl von Sekunden alle Kinder in der Warteschlange mit der Krankheit infizieren. Eine Infektionssequenz ist die Reihenfolge der Positionen, an denen alle nicht infizierten Kinder mit der Krankheit infiziert werden. Geben Sie die Gesamtzahl der möglichen Infektionssequenzen zurück.
Da die Antwort groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Beachten Sie, dass eine Infektionssequenz keine Positionen von Kindern enthält, die bereits zu Beginn mit der Krankheit infiziert waren.

Beispiel 1:

Eingabe: n = 5, krank = [0,4]
Ausgabe: 4
Erläuterung: Kinder an den Positionen 1, 2 und 3 sind zunächst nicht infiziert. Es gibt 4 mögliche Infektionssequenzen:
- Die Kinder an den Positionen 1 und 3 können infiziert werden, da ihre Positionen an die infizierten Kinder 0 und 4 angrenzen. Das Kind an Position 1 infiziert sich zuerst.
Nun grenzt das Kind an Position 2 an das Kind an Position 1, das infiziert ist, und das Kind an Position 3 an das Kind an Position 4, das infiziert ist, sodass beide infiziert werden können. Das Kind an Position 2 infiziert sich.
Schließlich wird das Kind an Position 3 infiziert, weil es an infizierte Kinder an Position 2 und 4 angrenzt. Die Infektionssequenz ist [1,2,3].
- Die Kinder an den Positionen 1 und 3 können infiziert werden, da ihre Positionen an die infizierten Kinder 0 und 4 angrenzen. Das Kind an Position 1 infiziert sich zuerst.
Nun grenzt das Kind an Position 2 an das Kind an Position 1, das infiziert ist, und das Kind an Position 3 an das Kind an Position 4, das infiziert ist, sodass beide infiziert werden können. Das Kind an Position 3 infiziert sich.
Schließlich wird das Kind an Position 2 infiziert, weil es an infizierte Kinder an Position 1 und 3 angrenzt. Die Infektionssequenz ist [1,3,2].
- Die Infektionssequenz ist [3,1,2]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].
- Die Infektionssequenz ist [3,2,1]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4 ] => [0,1,2,3,4].

Beispiel 2:

Eingabe: n = 4, krank = [1]
Ausgabe: 3
Erläuterung: Kinder an den Positionen 0, 2 und 3 sind zunächst nicht infiziert. Es gibt 3 mögliche Infektionssequenzen:
- Die Infektionssequenz ist [0,2,3]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- Die Infektionssequenz ist [2,0,3]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].
- Die Infektionssequenz ist [2,3,0]. Die Infektionsreihenfolge der Krankheit bei den Kindern kann wie folgt angesehen werden: [0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0, 1,2,3].

Einschränkungen:

2 <= n <= 10^5
1 <= Krankenlänge <= n - 1
0 <= krank[i] <= n - 1
krank ist in aufsteigender Reihenfolge sortiert.


Sie erhalten ein ganzzahliges Array nums und eine ganze Zahl k.
Die Häufigkeit eines Elements x gibt an, wie oft es in einem Array vorkommt.
Ein Array heißt gut, wenn die Häufigkeit jedes Elements in diesem Array kleiner oder gleich k ist.
Gibt die Länge des längsten guten Subarrays von Nums zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,3,1,2,3,1,2], k = 2
Ausgabe: 6
Erläuterung: Das längstmögliche gute Subarray ist [1,2,3,1,2,3], da die Werte 1, 2 und 3 in diesem Subarray höchstens zweimal vorkommen. Beachten Sie, dass die Subarrays [2,3,1,2,3,1] und [3,1,2,3,1,2] ebenfalls gut sind.
Es kann gezeigt werden, dass es keine guten Subarrays mit einer Länge von mehr als 6 gibt.

Beispiel 2:

Eingabe: nums = [1,2,1,2,1,2,1,2], k = 1
Ausgabe: 2
Erläuterung: Das längstmögliche gute Subarray ist [1,2], da die Werte 1 und 2 in diesem Subarray höchstens einmal vorkommen. Beachten Sie, dass das Subarray [2,1] ebenfalls gut ist.
Es kann gezeigt werden, dass es keine guten Subarrays mit einer Länge von mehr als 2 gibt.

Beispiel 3:

Eingabe: nums = [5,5,5,5,5,5,5], k = 4
Ausgabe: 4
Erläuterung: Das längstmögliche gute Subarray ist [5,5,5,5], da der Wert 5 in diesem Subarray viermal vorkommt.
Es kann gezeigt werden, dass es keine guten Subarrays mit einer Länge von mehr als 4 gibt.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums und eine ganze Zahl k.
Die Häufigkeit eines Elements x gibt an, wie oft es in einem Array vorkommt.
Ein Array heißt gut, wenn die Häufigkeit jedes Elements in diesem Array kleiner oder gleich k ist.
Gibt die Länge des längsten guten Subarrays von Nums zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,3,1,2,3,1,2], k = 2
Ausgabe: 6
Erläuterung: Das längstmögliche gute Subarray ist [1,2,3,1,2,3], da die Werte 1, 2 und 3 in diesem Subarray höchstens zweimal vorkommen. Beachten Sie, dass die Subarrays [2,3,1,2,3,1] und [3,1,2,3,1,2] ebenfalls gut sind.
Es kann gezeigt werden, dass es keine guten Subarrays mit einer Länge von mehr als 6 gibt.

Beispiel 2:

Eingabe: nums = [1,2,1,2,1,2,1,2], k = 1
Ausgabe: 2
Erläuterung: Das längstmögliche gute Subarray ist [1,2], da die Werte 1 und 2 in diesem Subarray höchstens einmal vorkommen. Beachten Sie, dass das Subarray [2,1] ebenfalls gut ist.
Es kann gezeigt werden, dass es keine guten Subarrays mit einer Länge von mehr als 2 gibt.

Beispiel 3:

Eingabe: nums = [5,5,5,5,5,5,5], k = 4
Ausgabe: 4
Erläuterung: Das längstmögliche gute Subarray ist [5,5,5,5], da der Wert 5 in diesem Subarray viermal vorkommt.
Es kann gezeigt werden, dass es keine guten Subarrays mit einer Länge von mehr als 4 gibt.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums und eine ganze Zahl k.
Die Häufigkeit eines Elements x ist die Anzahl, mit der es in einer Matrix vorkommt.
Ein Array wird als gut bezeichnet, wenn die Häufigkeit jedes Elements in diesem Array kleiner oder gleich k ist.
Gibt die Länge des längsten guten Subarrays von nums zurück.
Ein Subarray ist eine zusammenhängende, nicht leere Folge von Elementen innerhalb eines Arrays.

Beispiel 1:

Eingabe: nums = [1,2,3,1,2,3,1,2], k = 2
Ausgabe: 6
Erläuterung: Die längste mögliche gute Teilmenge ist [1,2,3,1,2,3], da die Werte 1, 2 und 3 höchstens zweimal in dieser Teilmenge vorkommen. Man beachte, dass die Teilfelder [2,3,1,2,3,1] und [3,1,2,3,1,2] ebenfalls gut sind.
Es kann gezeigt werden, dass es keine guten Teilfelder mit einer Länge von mehr als 6 gibt.

Beispiel 2:

Eingabe: nums = [1,2,1,2,1,2,1,2], k = 1
Ausgabe: 2
Erläuterung: Die längste mögliche gute Teilmenge ist [1,2], da die Werte 1 und 2 höchstens einmal in dieser Teilmenge vorkommen. Man beachte, dass auch die Teilmenge [2,1] gut ist.
Es kann gezeigt werden, dass es keine guten Teilfelder mit einer Länge von mehr als 2 gibt.

Beispiel 3:

Eingabe: nums = [5,5,5,5,5,5,5], k = 4
Ausgabe: 4
Erläuterung: Die längste mögliche gute Teilmenge ist [5,5,5,5], da der Wert 5 in dieser Teilmenge 4 mal vorkommt.
Es kann gezeigt werden, dass es keine guten Teilfelder mit einer Länge von mehr als 4 gibt.

Randbedingungen:

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


Sie erhalten ein 0-indiziertes Ganzzahl-Array nums gerader Länge und es gibt auch ein leeres Array arr. Alice und Bob beschlossen, ein Spiel zu spielen, bei dem Alice und Bob in jeder Runde einen Zug machen. Die Spielregeln lauten wie folgt:

In jeder Runde entfernt zuerst Alice das minimale Element aus Nums, und dann macht Bob dasselbe.
Jetzt hängt zuerst Bob das entfernte Element im Array arr an, und dann macht Alice dasselbe.
Das Spiel geht weiter, bis Nums leer ist.

Gibt das resultierende Array arr zurück.

Beispiel 1:

Eingabe: nums = [5,4,2,3]
Ausgabe: [3,2,5,4]
Erläuterung: In Runde eins entfernt Alice zuerst 2 und dann Bob 3. Dann hängt in arr zuerst Bob 3 und dann Alice 2 an. Also arr = [3,2].
Zu Beginn der zweiten Runde ist nums = [5,4]. Jetzt entfernt zuerst Alice 4 und dann entfernt Bob 5. Dann hängen beide in arr an, was zu [3,2,5,4] wird.

Beispiel 2:

Eingabe: nums = [2,5]
Ausgabe: [5,2]
Erläuterung: In Runde eins entfernt Alice zuerst 2 und dann Bob 5. Dann hängt in arr zuerst Bob an und dann hängt Alice an. Also arr = [5,2].

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array nums gerader Länge und es gibt auch ein leeres Array arr. Alice und Bob beschlossen, ein Spiel zu spielen, bei dem Alice und Bob in jeder Runde einen Zug machen. Die Spielregeln lauten wie folgt:

In jeder Runde entfernt zuerst Alice das minimale Element aus Nums, und dann macht Bob dasselbe.
Jetzt hängt zuerst Bob das entfernte Element im Array arr an, und dann macht Alice dasselbe.
Das Spiel geht weiter, bis Nums leer ist.

Gibt das resultierende Array arr zurück.

Beispiel 1:

Eingabe: nums = [5,4,2,3]
Ausgabe: [3,2,5,4]
Erläuterung: In Runde eins entfernt Alice zuerst 2 und dann Bob 3. Dann hängt in arr zuerst Bob 3 und dann Alice 2 an. Also arr = [3,2].
Zu Beginn der zweiten Runde ist nums = [5,4]. Jetzt entfernt zuerst Alice 4 und dann entfernt Bob 5. Dann hängen beide in arr an, was zu [3,2,5,4] wird.

Beispiel 2:

Eingabe: nums = [2,5]
Ausgabe: [5,2]
Erläuterung: In Runde eins entfernt Alice zuerst 2 und dann Bob 5. Dann hängt in arr zuerst Bob an und dann hängt Alice an. Also arr = [5,2].

Einschränkungen:

1 <= Anzahl.Länge <= 100
1 <= nums[i] <= 100
nums.length % 2 == 0


Sie erhalten ein 0-indiziertes 2D-Ganzzahlmatrixgitter der Größe n * n mit Werten im Bereich [1, n^2]. Jede Ganzzahl kommt genau einmal vor, mit Ausnahme von a, das zweimal vorkommt und b, das fehlt. Die Aufgabe besteht darin, die sich wiederholenden und fehlenden Zahlen a und b zu finden.
Gibt ein 0-indiziertes ganzzahliges Array der Größe 2 zurück, wobei ans[0] gleich a und ans[1] gleich b ist.

Beispiel 1:

Eingabe: grid = [[1,3],[2,2]]
Ausgabe: [2,4]
Erläuterung: Nummer 2 wird wiederholt und Nummer 4 fehlt, daher lautet die Antwort [2,4].

Beispiel 2:

Eingabe: grid = [[9,1,7],[8,9,2],[3,4,6]]
Ausgabe: [9,5]
Erläuterung: Nummer 9 wird wiederholt und Nummer 5 fehlt, daher lautet die Antwort [9,5].

Einschränkungen:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Für alle x mit 1 <= x <= n * n gibt es genau ein x, das keinem der Gitterelemente entspricht.
Für alle x mit 1 <= x <= n * n gibt es genau ein x, das genau zwei der Gitterelemente entspricht.
Für alle x mit 1 <= x <= n * n außer zwei davon gibt es genau ein Paar von i, j mit 0 <= i, j <= n - 1 and grid[i][j] == x.

Sie erhalten ein 0-indiziertes 2D-Ganzzahlmatrixgitter der Größe n * n mit Werten im Bereich [1, n^2]. Jede Ganzzahl kommt genau einmal vor, mit Ausnahme von a, das zweimal vorkommt und b, das fehlt. Die Aufgabe besteht darin, die sich wiederholenden und fehlenden Zahlen a und b zu finden.
Gibt ein 0-indiziertes ganzzahliges Array der Größe 2 zurück, wobei ans[0] gleich a und ans[1] gleich b ist.

Beispiel 1:

Eingabe: Gitter = [[1,3],[2,2]]
Ausgabe: [2,4]
Erläuterung: Nummer 2 wird wiederholt und Nummer 4 fehlt, daher lautet die Antwort [2,4].

Beispiel 2:

Eingabe: Gitter = [[9,1,7],[8,9,2],[3,4,6]]
Ausgabe: [9,5]
Erläuterung: Nummer 9 wird wiederholt und Nummer 5 fehlt, daher lautet die Antwort [9,5].

Einschränkungen:

2 <= n == grid.length == grid[i].length <= 50
1 <= Gitter[i][j] <= n * n
Für alle x mit 1 <= x <= n * n gibt es genau ein x, das keinem der Gitterelemente entspricht.
Für alle x mit 1 <= x <= n * n gibt es genau ein x, das genau zwei der Gitterelemente entspricht.
Für alle x mit 1 <= x <= n * n außer zwei davon gibt es genau ein Paar von i, j mit 0 <= i, j <= n - 1 und Grid[i][j] == x.

Sie erhalten ein 0-indiziert 2D-Ganzzahl-Matrixgitter von Größe N * n mit Werten im Bereich [1, n^2]. Jede Ganzzahl erscheint genau einmal außer einem, das zweimal erscheint und B fehlt. Die Aufgabe besteht darin, die wiederholenden und fehlenden Zahlen a und b zu finden.
Geben Sie ein 0-Indexed Integer Array ANS von Größe 2 zurück, wobei ans[0] entspricht a und ans[1] entspricht b.

Beispiel 1:

Eingabe:  grid = [[1,3],[2,2]]
Ausgabe: [2,4]
Erläuterung: Zahl 2 wird wiederholt und Zahl 4 fehlt, sodass die Antwort [2,4] lautet.

Beispiel 2:

Eingabe: grid = [[9,1,7],[8,9,2],[3,4,6]]
Ausgabe: [9,5]
Erläuterung: Zahl 9 wird wiederholt und Zahl 5 fehlt, daher lautet die Antwort [9,5].

Einschränkungen:

2 <= n == grid.length == grid[i].length <= 50
1 <= grid[i][j] <= n * n
Für alle x im Bereich 1 <= x <= n * n gibt es genau ein x, das nicht in den Gitterwerten vorkommt.
Für alle x, dass 1 <= x <= n * n genau ein x ist, das genau zwei der Gittermitglieder entspricht.
Für alle x, dass 1 <= x <= n * n außer zwei von ihnen es gibt ein genau ein Paar i, j, dass 0 <= i, j <= n - 1 und grid [i] [j] == x.


Sie erhalten zwei 0-indizierte Ganzzahlarrays nums1 und nums2 mit gerader Länge n.
Sie müssen n/2 Elemente aus nums1 und n/2 Elemente aus nums2 entfernen. Nach dem Entfernen fügen Sie die verbleibenden Elemente von nums1 und nums2 in eine Menge s ein.
Gibt die maximal mögliche Größe der Menge s zurück.

Beispiel 1:

Eingabe: Nums1 = [1,2,1,2], Nums2 = [1,1,1,1]
Ausgabe: 2
Erläuterung: Wir entfernen zwei Vorkommen von 1 aus nums1 und nums2. Nach den Entfernungen werden die Arrays gleich nums1 = [2,2] und nums2 = [1,1]. Daher ist s = {1,2}.
Es kann gezeigt werden, dass 2 die maximal mögliche Größe der Menge s nach den Entfernungen ist.

Beispiel 2:

Eingabe: Nums1 = [1,2,3,4,5,6], Nums2 = [2,3,2,3,2,3]
Ausgabe: 5
Erläuterung: Wir entfernen 2, 3 und 6 aus Nums1 sowie 2 und zwei Vorkommen von 3 aus Nums2. Nach den Entfernungen werden die Arrays gleich nums1 = [1,4,5] und nums2 = [2,3,2]. Daher ist s = {1,2,3,4,5}.
Es kann gezeigt werden, dass 5 die maximal mögliche Größe der Menge s nach den Entfernungen ist.

Beispiel 3:

Eingabe: Nums1 = [1,1,2,2,3,3], Nums2 = [4,4,5,5,6,6]
Ausgabe: 6
Erläuterung: Wir entfernen 1, 2 und 3 aus Nums1 sowie 4, 5 und 6 aus Nums2. Nach den Entfernungen werden die Arrays gleich nums1 = [1,2,3] und nums2 = [4,5,6]. Daher ist s = {1,2,3,4,5,6}.
Es kann gezeigt werden, dass 6 die maximal mögliche Größe der Menge s nach den Entfernungen ist.

Einschränkungen:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n ist gerade.
1 <= nums1[i], nums2[i] <= 10^9

Sie erhalten zwei 0-indizierte ganzzahlige Arrays nums1 und nums2 mit der geraden Länge n.
Sie müssen n / 2 Elemente aus nums1 und n / 2 Elemente aus nums2 entfernen. Nach dem Entfernen fügen Sie die verbleibenden Elemente von nums1 und nums2 in eine Menge s ein.
Gibt die maximal mögliche Größe des Satzes s zurück.

Beispiel 1:

Eingabe: nums1 = [1,2,1,2], nums2 = [1,1,1,1]
Ausgang: 2
Erklärung: Wir entfernen zwei Vorkommen von 1 aus nums1 und nums2. Nach dem Entfernen werden die Arrays gleich nums1 = [2,2] und nums2 = [1,1]. Daher ist s = {1,2}.
Es kann gezeigt werden, dass 2 die maximal mögliche Größe des Sets s nach den Entfernungen ist.

Beispiel 2:

Eingabe: nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
Ausgang: 5
Erklärung: Wir entfernen 2, 3 und 6 aus Zahlen1 sowie 2 und zwei Vorkommen von 3 aus Zahlen2. Nach dem Entfernen werden die Arrays gleich nums1 = [1,4,5] und nums2 = [2,3,2]. Daher ist s = {1,2,3,4,5}.
Es kann gezeigt werden, dass 5 die maximal mögliche Größe des Sets s nach den Entfernungen ist.

Beispiel 3:

Eingabe: nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
Ausgang: 6
Erklärung: Wir entfernen 1, 2 und 3 aus Zahlen1 sowie 4, 5 und 6 aus Zahlen2. Nach dem Entfernen werden die Arrays gleich nums1 = [1,2,3] und nums2 = [4,5,6]. Daher ist s = {1,2,3,4,5,6}.
Es kann gezeigt werden, dass 6 die maximal mögliche Größe des Sets s nach den Entfernungen ist.

Zwänge:

n == nums1.length == nums2.length
1 <= n <= 2 * 10^4
n ist gerade.
1 <= nums1[i], nums2[i] <= 10^9


Sie erhalten ein 0-indiziertes Ganzzahlarray nums mit der Länge n.
Sie dürfen einen Spezialzug beliebig oft (einschließlich null) auf Nums ausführen. In einem Spezialzug führen Sie die folgenden Schritte der Reihe nach aus:

Wählen Sie einen Index i im Bereich [0, n - 1] und eine positive ganze Zahl x.
Fügen Sie |nums[i] - x| hinzu zu den Gesamtkosten.
Ändern Sie den Wert von nums[i] in x.

Eine palindromische Zahl ist eine positive ganze Zahl, die gleich bleibt, wenn ihre Ziffern umgekehrt werden. Beispielsweise sind 121, 2552 und 65756 palindromische Zahlen, während 24, 46, 235 keine palindromischen Zahlen sind.
Ein Array gilt als gleichindromisch, wenn alle Elemente im Array gleich einer ganzen Zahl y sind, wobei y eine palindromische Zahl kleiner als 10^9 ist.
Gibt eine Ganzzahl zurück, die die minimal möglichen Gesamtkosten angibt, um Zahlen durch die Ausführung einer beliebigen Anzahl von Spezialbewegungen gleich zu machen.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: 6
Erläuterung: Wir können das Array gleichindromisch machen, indem wir alle Elemente auf 3 ändern, was eine palindromische Zahl ist. Die Kosten für die Änderung des Arrays auf [3,3,3,3,3] unter Verwendung von 4 Spezialbewegungen betragen |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Es kann gezeigt werden, dass die Änderung aller Elemente auf eine andere palindromische Zahl als 3 nicht mit geringeren Kosten erreicht werden kann.

Beispiel 2:

Eingabe: nums = [10,12,13,14,15]
Ausgabe: 11
Erläuterung: Wir können das Array gleichindromisch machen, indem wir alle Elemente auf 11 ändern, was eine palindromische Zahl ist. Die Kosten für die Änderung des Arrays auf [11,11,11,11,11] unter Verwendung von 5 Spezialbewegungen betragen |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Es kann gezeigt werden, dass die Änderung aller Elemente auf eine andere palindromische Zahl als 11 nicht mit geringeren Kosten erreicht werden kann.

Beispiel 3:

Eingabe: nums = [22,33,22,33,22]
Ausgabe: 22
Erläuterung: Wir können das Array gleichindromisch machen, indem wir alle Elemente auf 22 ändern, was eine palindromische Zahl ist. Die Kosten für die Änderung des Arrays auf [22,22,22,22,22] unter Verwendung von 2 Spezialbewegungen betragen |33 - 22| + |33 - 22| = 22.
Es kann gezeigt werden, dass die Änderung aller Elemente auf eine andere palindromische Zahl als 22 nicht mit geringeren Kosten erreicht werden kann.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Integer-Array nums mit der Länge n.
Sie dürfen eine besondere Bewegung (einschließlich Null) in nums ausführen. In einem besonderen Zug führen Sie die folgenden Schritte in der Reihenfolge aus:

Wählen Sie einen Index i aus dem Bereich [0, n - 1] und eine positive ganze Zahl x.
Add |nums[i] - x| zu den Gesamtkosten.
Ändern Sie den Wert von nums[i] auf x.

Eine palindromische Zahl ist eine positive Ganzzahl, die bei Umkehrung ihrer Ziffern gleich bleibt. Zum Beispiel sind 121, 2552 und 65756 palindromische Zahlen, während 24, 46, 235 keine palindromischen Zahlen sind.
Ein Array gilt als gleichindrom, wenn alle Elemente im Array gleich einer Ganzzahl y sind, wobei y eine palindromische Zahl von weniger als 10^9 ist.
Geben Sie eine Ganzzahl zurück, die die minimalen möglichen Gesamtkosten bezeichnet, um NUMS gleichindrom zu machen, indem eine beliebige Anzahl von speziellen Bewegungen durchgeführt wird.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: 6
Erläuterung: Wir können das Feld gleichindromisch machen, indem wir alle Elemente auf 3 ändern, was eine palindromische Zahl ist. Die Kosten für die Änderung der Anordnung in [3,3,3,3,3] mit 4 speziellen Zügen sind gegeben durch |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
Es kann gezeigt werden, dass das Ändern aller Elemente in eine andere palindromische Zahl als 3 nicht zu niedrigeren Kosten erreicht werden kann.

Beispiel 2:

Eingabe: nums = [10,12,13,14,15]
Ausgabe: 11
Erläuterung: Wir können das Array gleichindrom machen, indem wir alle Elemente auf 11 ändern, was eine palindromische Zahl ist. Die Kosten für die Änderung des Arrays auf [11,11,11,11,11] unter Verwendung von 5 Sonderbewegungen sind |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
Es kann gezeigt werden, dass das Ändern aller Elemente in eine andere palindromische Zahl als 11 nicht zu geringeren Kosten erreicht werden kann.

Beispiel 3:

Eingabe: nums = [22,33,22,33,22]
Ausgabe: 22
Erläuterung: Wir können das Feld gleichindromisch machen, indem wir alle Elemente in 22 ändern, was eine palindromische Zahl ist. Die Kosten für die Änderung des Feldes in [22,22,22,22,22] mit 2 speziellen Zügen sind gegeben durch |33 - 22| + |33 - 22| = 22.
Es kann gezeigt werden, dass das Ändern aller Elemente in eine andere palindromische Zahl als 22 nicht zu geringeren Kosten erreicht werden kann.

Einschränkungen:

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


Sie erhalten eine Zeichenkette Wort mit dem Index 0.
In einer Operation können Sie einen beliebigen Index i von word wählen und word[i] in einen beliebigen englischen Kleinbuchstaben ändern.
Geben Sie die minimale Anzahl von Operationen zurück, die erforderlich sind, um alle benachbarten fast gleichen Zeichen aus Wort zu entfernen.
Zwei Zeichen a und b sind fast gleich, wenn a == b oder a und b im Alphabet benachbart sind.

Beispiel 1:

Eingabe: word = "aaaaa"
Ausgabe: 2
Erläuterung: Wir können Wort in „acaca“ umwandeln, das keine benachbarten fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die minimale Anzahl von Operationen, die erforderlich ist, um alle benachbarten fast gleichen Zeichen aus Wort zu entfernen, 2 ist.

Beispiel 2:

Eingabe: word = "abddez"
Ausgabe: 2
Erläuterung: Wir können Wort in „ybdoez“ ändern, das keine benachbarten fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die minimale Anzahl von Operationen, die erforderlich ist, um alle benachbarten fast gleichen Zeichen aus Wort zu entfernen, 2 ist.
Beispiel 3:

Eingabe: word = "zyxyxyz"
Ausgabe: 3
Erläuterung: Wir können Wort in „zaxaxaz“ umwandeln, das keine benachbarten fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die minimale Anzahl von Operationen, die benötigt wird, um alle benachbarten fast gleichen Zeichen aus Wort zu entfernen, 3 ist.

Randbedingungen:

1 <= word.length <= 100
Wort besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein 0-indiziertes Zeichenfolgenwort.
In einem Vorgang können Sie einen beliebigen Index i eines Wortes auswählen und Wort[i] in einen beliebigen englischen Kleinbuchstaben ändern.
Gibt die minimale Anzahl an Operationen zurück, die erforderlich sind, um alle benachbarten, fast gleichen Zeichen aus dem Wort zu entfernen.
Zwei Zeichen a und b sind nahezu gleich, wenn a == b oder a und b im Alphabet benachbart sind.

Beispiel 1:

Eingabe: Wort = „aaaaa“
Ausgabe: 2
Erläuterung: Wir können das Wort in „Acaca“ ändern, das keine angrenzenden, fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die Mindestanzahl an Operationen, die erforderlich sind, um alle benachbarten nahezu gleichen Zeichen aus einem Wort zu entfernen, 2 beträgt.

Beispiel 2:

Eingabe: Wort = „abddez“
Ausgabe: 2
Erläuterung: Wir können das Wort in „ybdoez“ ändern, das keine angrenzenden, fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die Mindestanzahl an Operationen, die erforderlich sind, um alle benachbarten nahezu gleichen Zeichen aus einem Wort zu entfernen, 2 beträgt.
Beispiel 3:

Eingabe: Wort = „zyxyxyz“
Ausgabe: 3
Erläuterung: Wir können das Wort in „zaxaxaz“ ändern, das keine angrenzenden, fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die Mindestanzahl an Operationen, die zum Entfernen aller benachbarten nahezu gleichen Zeichen aus einem Wort erforderlich sind, 3 beträgt.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Zeichenfolgenwort.
In einem Vorgang können Sie einen beliebigen Index i eines Wortes auswählen und Wort[i] in einen beliebigen englischen Kleinbuchstaben ändern.
Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um alle angrenzenden fast gleichen Zeichen aus dem Wort zu entfernen.
Zwei Zeichen a und b sind nahezu gleich, wenn a == b oder a und b im Alphabet benachbart sind.

Beispiel 1:

Eingabe: word = "aaaaa"
Ausgabe: 2
Erläuterung: Wir können das Wort in „Acaca“ ändern, das keine angrenzenden, fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die Mindestanzahl an Operationen, die zum Entfernen aller benachbarten nahezu gleichen Zeichen aus einem Wort erforderlich sind, 2 beträgt.

Beispiel 2:

Eingabe: word = "abddez"
Ausgabe: 2
Erläuterung: Wir können das Wort in „ybdoez“ ändern, das keine angrenzenden, fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die Mindestanzahl an Operationen, die zum Entfernen aller benachbarten nahezu gleichen Zeichen aus einem Wort erforderlich sind, 2 beträgt.
Beispiel 3:

Eingabe: word = "zyxyxyz"
Ausgabe: 3
Erläuterung: Wir können das Wort in „zaxaxaz“ ändern, das keine angrenzenden, fast gleichen Zeichen hat.
Es kann gezeigt werden, dass die Mindestanzahl an Operationen, die erforderlich sind, um alle benachbarten nahezu gleichen Zeichen aus einem Wort zu entfernen, 3 beträgt.

Einschränkungen:

1 <= word.length <= 100
Das Wort besteht nur aus englischen Kleinbuchstaben.


Sie erhalten ein 0-indiziertes ganzzahliges Array von Münzen, das die Werte der verfügbaren Münzen darstellt, und ein ganzzahliges Ziel.
Eine ganze Zahl x ist erhältlich, wenn es eine Teilfolge von Münzen gibt, deren Summe x ergibt.
Gibt die Mindestanzahl an Münzen mit beliebigem Wert zurück, die dem Array hinzugefügt werden müssen, damit jede ganze Zahl im Bereich [1, Ziel] erhältlich ist.
Eine Teilsequenz eines Arrays ist ein neues, nicht leeres Array, das aus dem ursprünglichen Array gebildet wird, indem einige (möglicherweise keine) Elemente gelöscht werden, ohne die relativen Positionen der verbleibenden Elemente zu beeinträchtigen.

Beispiel 1:

Eingabe: Münzen = [1,4,10], Ziel = 19
Ausgabe: 2
Erläuterung: Wir müssen die Münzen 2 und 8 hinzufügen. Das resultierende Array wird [1,2,4,8,10] sein.
Es kann gezeigt werden, dass alle ganzen Zahlen von 1 bis 19 aus dem resultierenden Array erhältlich sind und dass 2 die Mindestanzahl an Münzen ist, die dem Array hinzugefügt werden müssen.

Beispiel 2:

Eingabe: Münzen = [1,4,10,5,7,19], Ziel = 19
Ausgabe: 1
Erläuterung: Wir müssen nur die Münze 2 hinzufügen. Das resultierende Array wird [1,2,4,5,7,10,19] sein.
Es kann gezeigt werden, dass alle ganzen Zahlen von 1 bis 19 aus dem resultierenden Array erhältlich sind und dass 1 die Mindestanzahl an Münzen ist, die dem Array hinzugefügt werden müssen.

Beispiel 3:

Eingabe: Münzen = [1,1,1], Ziel = 20
Ausgabe: 3
Erläuterung: Wir müssen die Münzen 4, 8 und 16 hinzufügen. Das resultierende Array ist [1,1,1,4,8,16].
Es kann gezeigt werden, dass alle ganzen Zahlen von 1 bis 20 aus dem resultierenden Array erhältlich sind und dass 3 die Mindestanzahl an Münzen ist, die dem Array hinzugefügt werden müssen.

Einschränkungen:

1 <= Ziel <= 10^5
1 <= Münzen.Länge <= 10^5
1 <= Münzen[i] <= Ziel

Sie erhalten ein 0-indiziertes Integer-Array 'Münzen'..., die die Werte der verfügbaren Münzen darstellt, und ein ganzzahliges Ziel.
Eine Ganzzahl X ist erhältlich, wenn es eine Untersequenz von Münzen gibt, die zu x beträgt.
Geben Sie die minimale Anzahl von Münzen eines beliebigen Werts zurück, der dem Array hinzugefügt werden muss, damit jede Ganzzahl im Bereich [1, Ziel] erhältlich ist.
Eine Untersequenz eines Arrays ist ein neues nicht leeres Array, das aus dem ursprünglichen Array gebildet wird, indem einige (möglicherweise keine) der Elemente gelöscht werden, ohne die relativen Positionen der verbleibenden Elemente zu stören.

Beispiel 1:

Eingabe: coins = [1,4,10], target = 19
Ausgabe: 2
Erläuterung: Wir müssen Münzen 2 und 8 hinzufügen. Das resultierende Array wird [1,2,4,8,10] sein.
Es kann gezeigt werden, dass alle Ganzzahlen von 1 bis 19 aus dem resultierenden Array erhältlich sind und 2 die Mindestanzahl von Münzen ist, die dem Array hinzugefügt werden müssen.

Beispiel 2:

Eingabe: coins = [1,4,10,5,7,19], target = 19
Ausgabe: 1
Erläuterung: Wir müssen nur die Münze hinzufügen 2. Das resultierende Array wird [1,2,4,5,7,10,19] sein.
Es kann gezeigt werden, dass alle Ganzzahlen von 1 bis 19 aus dem resultierenden Array erhältlich sind und dass 1 die minimale Anzahl von Münzen ist, die dem Array hinzugefügt werden müssen.

Beispiel 3:

Eingabe: coins = [1,1,1], target = 20
Ausgabe: 3
Erläuterung: Wir müssen Münzen 4, 8 und 16 hinzufügen. Das resultierende Array wird [1,1,1,4,8,16] sein.
Es kann gezeigt werden, dass alle Ganzzahlen von 1 bis 20 aus dem resultierenden Array erhältlich sind und dass 3 die minimale Anzahl von Münzen ist, die dem Array hinzugefügt werden müssen.

Einschränkungen:

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


Sie erhalten eine 0-indizierte Zeichenfolge s und eine Ganzzahl k.
Sie müssen die folgenden Partitionierungsvorgänge ausführen, bis s leer ist:

Wählen Sie das längste Präfix von s, das höchstens k verschiedene Zeichen enthält.
Löschen Sie das Präfix von s und erhöhen Sie die Anzahl der Partitionen um eins. Die übrigen Zeichen (falls vorhanden) in s behalten ihre ursprüngliche Reihenfolge bei.

Vor den Operationen dürfen Sie höchstens einen Index in s in einen anderen englischen Kleinbuchstaben ändern.
Geben Sie eine Ganzzahl zurück, die die maximale Anzahl der resultierenden Partitionen nach den Vorgängen angibt, indem Sie optimalerweise höchstens einen Index zum Ändern auswählen.

Beispiel 1:

Eingabe: s = „accca“, k = 2
Ausgabe: 3
Erläuterung: Um in diesem Beispiel die Anzahl der resultierenden Partitionen zu maximieren, kann s[2] in „b“ geändert werden.
s wird zu „acbca“.
Die Operationen können nun wie folgt durchgeführt werden, bis s leer wird:
- Wählen Sie das längste Präfix mit höchstens zwei unterschiedlichen Zeichen, „acbca“.
- Löschen Sie das Präfix und s wird zu „bca“. Die Anzahl der Partitionen beträgt jetzt 1.
- Wählen Sie das längste Präfix mit höchstens zwei unterschiedlichen Zeichen, „bca“.
- Löschen Sie das Präfix und s wird zu „a“. Die Anzahl der Partitionen beträgt jetzt 2.
- Wählen Sie das längste Präfix mit höchstens zwei unterschiedlichen Zeichen, „a“.
- Löschen Sie das Präfix und s wird leer. Die Anzahl der Partitionen beträgt jetzt 3.
Daher lautet die Antwort 3.
Es kann gezeigt werden, dass es nicht möglich ist, mehr als 3 Partitionen zu erhalten.
Beispiel 2:

Eingabe: s = „aabaab“, k = 3
Ausgabe: 1
Erläuterung: In diesem Beispiel können wir s unverändert lassen, um die Anzahl der resultierenden Partitionen zu maximieren.
Die Operationen können nun wie folgt durchgeführt werden, bis s leer wird:
- Wählen Sie das längste Präfix mit höchstens drei verschiedenen Zeichen, „aabaab“.
- Löschen Sie das Präfix und s wird leer. Die Anzahl der Partitionen beträgt 1.
Daher ist die Antwort 1.
Es kann gezeigt werden, dass es nicht möglich ist, mehr als eine Partition zu erhalten.

Beispiel 3:

Eingabe: s = „xxyz“, k = 1
Ausgabe: 4
Erläuterung: Um in diesem Beispiel die Anzahl der resultierenden Partitionen zu maximieren, kann s[1] in „a“ geändert werden.
s wird zu „xayz“.
Die Operationen können nun wie folgt durchgeführt werden, bis s leer wird:
- Wählen Sie das längste Präfix, das höchstens ein eindeutiges Zeichen enthält, „xayz“.
- Löschen Sie das Präfix und s wird zu „ayz“. Die Anzahl der Partitionen beträgt jetzt 1.
- Wählen Sie das längste Präfix, das höchstens ein eindeutiges Zeichen enthält, „ayz“.
- Löschen Sie das Präfix und s wird zu „yz“. Die Anzahl der Partitionen beträgt jetzt 2.
- Wählen Sie das längste Präfix, das höchstens ein eindeutiges Zeichen enthält, „yz“.
- Löschen Sie das Präfix und s wird zu „z“. Die Anzahl der Partitionen beträgt jetzt 3.
- Wählen Sie das längste Präfix, das höchstens ein eindeutiges Zeichen enthält, „z“.
- Löschen Sie das Präfix und s wird leer. Die Anzahl der Partitionen beträgt jetzt 4.
Daher lautet die Antwort 4.
Es kann gezeigt werden, dass es nicht möglich ist, mehr als 4 Partitionen zu erhalten.

Einschränkungen:

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

Sie erhalten eine 0-indizierte Zeichenkette s und eine Ganzzahl k.
Sie müssen die folgenden Partitionierungsvorgänge ausführen, bis s leer ist:

Wählen Sie das längste Präfix von s, das höchstens k unterschiedliche Zeichen enthält.
Löschen Sie das Präfix von s, und erhöhen Sie die Anzahl der Partitionen um eins. Die verbleibenden Zeichen (falls vorhanden) in s behalten ihre ursprüngliche Reihenfolge bei.

Vor den Operationen dürfen Sie höchstens einen Index in s in einen anderen englischen Kleinbuchstaben ändern.
Gibt eine Ganzzahl zurück, die die maximale Anzahl der resultierenden Partitionen nach den Operationen angibt, indem optimal maximal ein Index ausgewählt wird, der geändert werden soll.

Beispiel 1:

Eingabe: s = "accca", k = 2
Ausgang: 3
Erläuterung: Um in diesem Beispiel die Anzahl der resultierenden Partitionen zu maximieren, kann s[2] in „b“ geändert werden.
s wird zu „acbca“.
Die Operationen können nun wie folgt durchgeführt werden, bis s leer wird:
- Wählen Sie das längste Präfix, das höchstens 2 unterschiedliche Zeichen enthält, „acbca“.
- Löschen Sie das Präfix, und s wird zu „bca“. Die Anzahl der Partitionen ist nun 1.
- Wählen Sie das längste Präfix mit höchstens 2 verschiedenen Zeichen, „bca“.
- Löschen Sie das Präfix, und s wird zu „a“. Die Anzahl der Partitionen ist nun 2.
- Wählen Sie das längste Präfix mit höchstens 2 verschiedenen Zeichen, „a“.
- Löschen Sie das Präfix, und s wird leer. Die Anzahl der Partitionen ist nun 3.
Daher lautet die Antwort 3.
Es kann gezeigt werden, dass es nicht möglich ist, mehr als 3 Partitionen zu erhalten.
Beispiel 2:

Eingabe: s = "aabaab", k = 3
Ausgang: 1
Erklärung: Um in diesem Beispiel die Anzahl der resultierenden Partitionen zu maximieren, können wir s so belassen, wie es ist.
Die Operationen können nun wie folgt ausgeführt werden, bis s leer wird:
- Wählen Sie das längste Präfix mit maximal 3 verschiedenen Zeichen, „aabaab“.
- Löschen Sie das Präfix, und s wird leer. Die Anzahl der Partitionen wird zu 1.
Daher lautet die Antwort 1.
Es kann gezeigt werden, dass es nicht möglich ist, mehr als 1 Partition zu erhalten.

Beispiel 3:

Eingang: s = "xxyz", k = 1
Ausgang: 4
Erläuterung: Um in diesem Beispiel die Anzahl der resultierenden Partitionen zu maximieren, kann s[1] in „a“ geändert werden.
s wird zu „xayz“.
Die Operationen können nun wie folgt durchgeführt werden, bis s leer wird:
- Wählen Sie das längste Präfix, das höchstens 1 eindeutiges Zeichen enthält, „xayz“.
- Löschen Sie das Präfix, und s wird zu „ayz“. Die Anzahl der Partitionen ist nun 1.
- Wählen Sie das längste Präfix, das höchstens 1 eindeutiges Zeichen enthält, „ayz“.
- Löschen Sie das Präfix, und s wird zu „yz“. Die Anzahl der Partitionen ist nun 2.
- Wählen Sie das längste Präfix, das höchstens 1 eindeutiges Zeichen enthält, „yz“.
- Löschen Sie das Präfix, und s wird zu „z“. Die Anzahl der Partitionen ist nun 3.
- Wählen Sie das längste Präfix, das höchstens 1 eindeutiges Zeichen enthält, „z“.
- Löschen Sie das Präfix, und s wird leer. Die Anzahl der Partitionen ist nun 4.
Die Antwort lautet also 4.
Es kann gezeigt werden, dass es nicht möglich ist, mehr als 4 Partitionen zu erhalten.

Zwänge:

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


Sie erhalten eine 0-indizierte 2D-Array-Variable mit Variablen[i] = [a_i, b_i, c_i, m_i] und ein ganzzahliges Ziel.
Ein Index i ist gut, wenn die folgende Formel gilt:

0 <= i < Variablen.Länge
((a_i^bi % 10)^ci) % m_i == Ziel

Gibt ein Array zurück, das aus guten Indizes in beliebiger Reihenfolge besteht.

Beispiel 1:

Eingabe: Variablen = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], Ziel = 2
Ausgabe: [0,2]
Erläuterung: Für jeden Index i im Variablenarray:
1) Für den Index 0, Variablen[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Für den Index 1, Variablen[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Für den Index 2, Variablen[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Daher geben wir als Antwort [0,2] zurück.

Beispiel 2:

Eingabe: Variablen = [[39,3,1000,1000]], Ziel = 17
Ausgabe: []
Erläuterung: Für jeden Index i im Variablenarray:
1) Für den Index 0, Variablen[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Daher geben wir [] als Antwort zurück.

Einschränkungen:

1 <= Variablen.Länge <= 100
Variablen[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= Ziel <= 10^3

Sie erhalten eine 0-indizierte 2D-Array-Variable, wobei variables[i] = [a_i, b_i, c_i, m_i] und ein ganzzahliges Ziel.
Ein Index i ist gut, wenn die folgende Formel gilt:

0 <= i < variables.length
((a_i^bi % 10)^ci) % m_i == target

Gibt ein Array zurück, das aus guten Indizes in beliebiger Reihenfolge besteht.

Beispiel 1:

Eingabe: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
Ausgang: [0,2]
Erklärung: Für jeden Index i im Variablen-Array:
1) Für den Index 0 sind die Variablen[0] = [2,3,3,10], (2^3 % 10)^3 % 10 = 2.
2) Für den Index 1 sind die Variablen[1] = [3,3,3,1], (3^3 % 10)^3 % 1 = 0.
3) Für den Index 2 sind die Variablen[2] = [6,1,1,4], (6^1 % 10)^1 % 4 = 2.
Daher geben wir [0,2] als Antwort zurück.

Beispiel 2:

Eingabe: variables = [[39,3,1000,1000]], target = 17
Ausgabe: []
Erklärung: Für jeden Index i im Variablen-Array:
1) Für den Index 0 sind die Variablen[0] = [39,3,1000,1000], (39^3 % 10)^1000 % 1000 = 1.
Daher geben wir [] als Antwort zurück.

Zwänge:

1 <= variables.length <= 100
variables[i] == [a_i, b_i, c_i, m_i]
1 <= a_i, b_i, c_i, m_i <= 10^3
0 <= target <= 10^3


Sie erhalten zwei mit 0 indizierte Zeichenfolgen Quelle und Ziel, beide mit der Länge n und bestehend aus englischen Kleinbuchstaben. Sie erhalten außerdem zwei 0-indizierte Zeichenarrays „Original“ und „Geändert“ sowie ein ganzzahliges Array „Kosten“, wobei „Kosten[i]“ die Kosten für die Änderung des Zeichens „Original[i]“ in das Zeichen „Geändert[i]“ darstellt.
Sie beginnen mit der String-Quelle. In einer Operation können Sie ein Zeichen x aus der Zeichenfolge auswählen und es mit Kosten von z in das Zeichen y ändern, wenn ein Index j mit Kosten[j] == z, Original[j] == x und vorhanden ist geändert[j] == y.
Gibt den Mindestaufwand für die Konvertierung der String-Quelle in das String-Ziel mit einer beliebigen Anzahl von Vorgängen zurück. Wenn es nicht möglich ist, die Quelle in das Ziel zu konvertieren, geben Sie -1 zurück.
Beachten Sie, dass es Indizes i, j geben kann, so dass original[j] == original[i] und geändert[j] == geändert[i] ist.

Beispiel 1:

Eingabe: Quelle = „abcd“, Ziel = „acbe“, Original = [„a“, „b“, „c“, „c“, „e“, „d“], geändert = [„b“,“ c“, „b“, „e“, „b“, „e“], Kosten = [2,5,5,1,2,20]
Ausgabe: 28
Erläuterung: So konvertieren Sie die Zeichenfolge „abcd“ in die Zeichenfolge „acbe“:
- Ändern Sie den Wert bei Index 1 von „b“ zu „c“ zum Preis von 5.
- Ändern Sie den Wert an Index 2 von „c“ zu „e“ zum Preis von 1.
- Ändern Sie den Wert bei Index 2 von „e“ zu „b“ zum Preis von 2.
- Ändern Sie den Wert an Index 3 von „d“ zu „e“ zum Preis von 20.
Die Gesamtkosten betragen 5 + 1 + 2 + 20 = 28.
Es kann gezeigt werden, dass dies die minimal möglichen Kosten sind.

Beispiel 2:

Eingabe: Quelle = „aaaa“, Ziel = „bbbb“, Original = [„a“, „c“], geändert = [„c“, „b“], Kosten = [1,2]
Ausgabe: 12
Erläuterung: Um das Zeichen „a“ in „b“ zu ändern, ändern Sie das Zeichen „a“ in „c“ zum Preis von 1 und anschließend das Zeichen „c“ in „b“ zum Preis von 2, also insgesamt Kosten von 1 + 2 = 3. Um alle Vorkommen von „a“ in „b“ zu ändern, fallen Gesamtkosten von 3 * 4 = 12 an.

Beispiel 3:

Eingabe: Quelle = „abcd“, Ziel = „abce“, Original = [„a“], geändert = [„e“], Kosten = [10000]
Ausgabe: -1
Erläuterung: Die Konvertierung von Quelle in Ziel ist nicht möglich, da der Wert an Index 3 nicht von „d“ in „e“ geändert werden kann.

Einschränkungen:

1 <= Quelllänge == Ziellänge <= 10^5
Quelle und Ziel bestehen aus englischen Kleinbuchstaben.
1 <= cost.length == original.length == changes.length <= 2000
original[i], changes[i] sind englische Kleinbuchstaben.
1 <= Kosten[i] <= 10^6
original[i] != geändert[i]

Sie erhalten zwei 0-indizierte Zeichenfolgen, source und target, beide mit der Länge n und bestehend aus englischen Kleinbuchstaben. Sie erhalten außerdem zwei 0-indizierte Zeichenarrays, original und changed, und ein ganzzahliges Array, cost, wobei cost[i] die cost für die Änderung des Zeichens original[i] in das Zeichen changed[i] darstellt.
Sie beginnen mit der Zeichenfolge source. In einem Vorgang können Sie ein Zeichen x aus der Zeichenfolge auswählen und es zu einem cost von z in das Zeichen y ändern, wenn ein Index j existiert, sodass cost[j] == z, original[j] == x und changed[j] == y.
Gibt die cost zurück, um die Zeichenfolge source in die Zeichenfolge target mit einer beliebigen Anzahl von Vorgängen zu konvertieren. Wenn es unmöglich ist, source in target zu konvertieren, geben Sie -1 zurück.
Beachten Sie, dass es Indizes i, j geben kann, sodass original[j] == original[i] and changed[j] == changed[i].

Beispiel 1:

Eingabe: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Ausgabe: 28
Erklärung: So konvertieren Sie die Zeichenfolge „abcd“ in die Zeichenfolge „acbe“:
- Ändern Sie den Wert am Index 1 von „b“ in „c“ zu einem cost von 5.
- Ändern Sie den Wert am Index 2 von „c“ in „e“ zu einem cost von 1.
- Ändern Sie den Wert am Index 2 von „e“ in „b“ zu einem cost von 2.
- Ändern Sie den Wert am Index 3 von „d“ in „e“ zu einem cost von 20.
Die cost betragen 5 + 1 + 2 + 20 = 28.
Es lässt sich zeigen, dass dies die minimal möglichen cost sind.

Beispiel 2:

Eingabe: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Ausgabe: 12
Erklärung: Um das Zeichen „a“ in „b“ zu ändern, ändern Sie das Zeichen „a“ in „c“ zu cost von 1, gefolgt von der Änderung des Zeichens „c“ in „b“ zu cost von 2, was cost von 1 + 2 = 3 ergibt. Um alle Vorkommen von „a“ in „b“ zu ändern, fallen cost von 3 * 4 = 12 an.

Beispiel 3:

Eingabe: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Ausgabe: -1
Erklärung: Es ist unmöglich, die source in das target umzuwandeln, da der Wert bei Index 3 nicht von „d“ in „e“ changed werden kann.

Einschränkungen:

1 <= source.length == target.length <= 10^5
source, target bestehen aus englischen Kleinbuchstaben.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] sind englische Kleinbuchstaben.
1 <= cost[i] <= 10^6
original[i] != changed[i]

You are given two 0-indexed strings source and target, both of length n and consisting of lowercase English letters. You are also given two 0-indexed character arrays original and changed, and an integer array cost, where cost[i] represents the cost of changing the character original[i] to the character changed[i].
You start with the string source. In one operation, you can pick a character x from the string and change it to the character y at a cost of z if there exists any index j such that cost[j] == z, original[j] == x, and changed[j] == y.
Return the minimum cost to convert the string source to the string target using any number of operations. If it is impossible to convert source to target, return -1.
Note that there may exist indices i, j such that original[j] == original[i] and changed[j] == changed[i].

Example 1:

Input: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Output: 28
Explanation: To convert the string "abcd" to string "acbe":
- Change value at index 1 from 'b' to 'c' at a cost of 5.
- Change value at index 2 from 'c' to 'e' at a cost of 1.
- Change value at index 2 from 'e' to 'b' at a cost of 2.
- Change value at index 3 from 'd' to 'e' at a cost of 20.
The total cost incurred is 5 + 1 + 2 + 20 = 28.
It can be shown that this is the minimum possible cost.

Example 2:

Input: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Output: 12
Explanation: To change the character 'a' to 'b' change the character 'a' to 'c' at a cost of 1, followed by changing the character 'c' to 'b' at a cost of 2, for a total cost of 1 + 2 = 3. To change all occurrences of 'a' to 'b', a total cost of 3 * 4 = 12 is incurred.

Example 3:

Input: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Output: -1
Explanation: It is impossible to convert source to target because the value at index 3 cannot be changed from 'd' to 'e'.

Constraints:

1 <= source.length == target.length <= 10^5
source, target consist of lowercase English letters.
1 <= cost.length == original.length == changed.length <= 2000
original[i], changed[i] are lowercase English letters.
1 <= cost[i] <= 10^6
original[i] != changed[i]


Sie erhalten ein 0-indiziertes Array von Ganzzahlen nums.
Ein Präfix nums[0..i] ist sequenziell, für alle 1 <= j <= i, nums[j] = nums[j - 1] + 1. Insbesondere ist das Präfix, das nur aus nums[0] besteht, sequenziell.
Gib die kleinste ganze Zahl x zurück, die in nums fehlt, sodass x größer oder gleich der Summe des längsten sequenziellen Präfixes ist.

Beispiel 1:

Input: nums = [1,2,3,2,5]
Output: 6
Erläuterung: Das längste sequenzielle Präfix von nums ist [1,2,3] mit einer Summe von 6. 6 ist nicht im Array, daher ist 6 die kleinste fehlende ganze Zahl, die größer oder gleich der Summe des längsten sequenziellen Präfixes ist.

Beispiel 2:
Input: nums = [3,4,5,1,12,14,13]
Output: 15
Erläuterung: Das längste sequenzielle Präfix von nums ist [3,4,5] mit einer Summe von 12. 12, 13 und 14 befinden sich im Array, während 15 nicht darin ist.
Daher ist 15 die kleinste fehlende ganze Zahl, die größer oder gleich der Summe des längsten sequenziellen Präfixes ist.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array von ganzen Zahlen nums.
Ein Präfix nums[0..i] ist fortlaufend, wenn für alle 1 <= j <= i, nums[j] = nums[j - 1] + 1 ist. Insbesondere ist das Präfix, das nur aus nums[0] besteht, sequenziell.
Gibt die kleinste ganze Zahl x zurück, die in den Zahlen fehlt, sodass x größer oder gleich der Summe des längsten sequenziellen Präfixes ist.

Beispiel 1:

Eingabe: nums = [1,2,3,2,5]
Ausgang: 6
Erklärung: Das längste sequenzielle Präfix von Zahlen ist [1,2,3] mit einer Summe von 6. 6 ist nicht im Array, daher ist 6 die kleinste fehlende Ganzzahl, die größer oder gleich der Summe des längsten sequenziellen Präfixes ist.

Beispiel 2:

Eingabe: nums = [3,4,5,1,12,14,13]
Ausgang: 15
Erklärung: Das längste sequenzielle Präfix von nums ist [3,4,5] mit einer Summe von 12. 12, 13 und 14 gehören zum Array, während 15 dies nicht tut. Daher ist 15 die kleinste fehlende Ganzzahl, die größer oder gleich der Summe des längsten sequenziellen Präfixes ist.

Zwänge:

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

Sie erhalten ein 0-indiziertes Array von Ganzzahlen.
Ein Präfix nums[0..i] ist sequentiell, wenn für alle 1 <= j <= i nums[j] = nums[j - 1] + 1 ist. Insbesondere ist das Präfix, das nur aus nums[0] besteht sequentiell.
Gibt die kleinste Ganzzahl x zurück, die in Nums fehlt, sodass x größer oder gleich der Summe des längsten sequentiellen Präfixes ist.

Beispiel 1:

Eingabe: nums = [1,2,3,2,5]
Ausgabe: 6
Erläuterung: Das längste sequentielle Präfix von Nums ist [1,2,3] mit einer Summe von 6. 6 ist nicht im Array, daher ist 6 die kleinste fehlende Ganzzahl, die größer oder gleich der Summe des längsten sequentiellen Präfixes ist.

Beispiel 2:

Eingabe: nums = [3,4,5,1,12,14,13]
Ausgabe: 15
Erläuterung: Das längste sequentielle Präfix von Nums ist [3,4,5] mit einer Summe von 12. 12, 13 und 14 gehören zum Array, 15 jedoch nicht. Daher ist 15 die kleinste fehlende ganze Zahl, die größer oder gleich der Summe des längsten sequentiellen Präfixes ist.

Einschränkungen:

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


Du hast zwei positive ganze Zahlen x und y.
In einem Schritt kannst du eine der folgenden vier Operationen ausführen:

Dividiere x durch 11, wenn x ein Vielfaches von 11 ist.
Dividiere x durch 5, wenn x ein Vielfaches von 5 ist.
Verringere x um 1.
Erhöhe x um 1.

Gib die minimale Anzahl von Operationen zurück, die erforderlich sind, um x und y gleich zu machen.

Beispiel 1:

Eingabe: x = 26, y = 1
Ausgabe: 3
Erläuterung: Wir können 26 gleich 1 machen, indem wir die folgenden Operationen anwenden:
1. Verringere x um 1
2. Dividiere x durch 5
3. Dividiere x durch 5
Es kann gezeigt werden, dass 3 die minimale Anzahl von Operationen ist, um 26 gleich 1 zu machen.

Beispiel 2:

Eingabe: x = 54, y = 2
Ausgabe: 4
Erläuterung: Wir können 54 gleich 2 machen, indem wir die folgenden Operationen anwenden:
1. Erhöhe x um 1
2. Dividiere x durch 11
3. Dividiere x durch 5
4. Erhöhe x um 1
Es kann gezeigt werden, dass 4 die minimale Anzahl von Operationen ist, um 54 gleich 2 zu machen.

Beispiel 3:

Eingabe: x = 25, y = 30
Ausgabe: 5
Erläuterung: Wir können 25 gleich 30 machen, indem wir die folgenden Operationen anwenden:
1. Erhöhe x um 1
2. Erhöhe x um 1
3. Erhöhe x um 1
4. Erhöhe x um 1
5. Erhöhe x um 1
Es kann gezeigt werden, dass 5 die minimale Anzahl von Operationen ist, um 25 gleich 30 zu machen.

Einschränkungen:

1 <= x, y <= 10^4

Sie erhalten zwei positive ganze Zahlen x und y.
In einem Vorgang können Sie einen der vier folgenden Vorgänge ausführen:

Teilen Sie x durch 11, wenn x ein Vielfaches von 11 ist.
Teilen Sie x durch 5, wenn x ein Vielfaches von 5 ist.
Dekrementieren Sie x um 1.
x um 1 erhöhen.

Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um x und y gleich zu machen.

Beispiel 1:

Eingabe: x = 26, y = 1
Ausgabe: 3
Erläuterung: Wir können 26 gleich 1 machen, indem wir die folgenden Operationen anwenden:
1. Dekrementieren Sie x um 1
2. Teilen Sie x durch 5
3. Teilen Sie x durch 5
Es kann gezeigt werden, dass 3 die minimale Anzahl von Operationen ist, die erforderlich sind, um 26 gleich 1 zu machen.

Beispiel 2:

Eingabe: x = 54, y = 2
Ausgabe: 4
Erläuterung: Wir können 54 gleich 2 machen, indem wir die folgenden Operationen anwenden:
1. x um 1 erhöhen
2. Teilen Sie x durch 11
3. Teilen Sie x durch 5
4. Erhöhen Sie x um 1
Es kann gezeigt werden, dass 4 die minimale Anzahl von Operationen ist, die erforderlich sind, um 54 gleich 2 zu machen.

Beispiel 3:

Eingabe: x = 25, y = 30
Ausgabe: 5
Erläuterung: Wir können 25 gleich 30 machen, indem wir die folgenden Operationen anwenden:
1. x um 1 erhöhen
2. Erhöhen Sie x um 1
3. Erhöhen Sie x um 1
4. Erhöhen Sie x um 1
5. Erhöhen Sie x um 1
Es kann gezeigt werden, dass 5 die Mindestanzahl an Operationen ist, die erforderlich sind, um 25 gleich 30 zu machen.

Einschränkungen:

1 <= x, y <= 10^4


Sie erhalten eine ganze Zahl k und eine ganze Zahl x.
Betrachten Sie s als die 1-indizierte Binärdarstellung einer Ganzzahl. Der Preis einer Zahl num ist die Anzahl der i, so dass i % x == 0 und s[i] ein gesetztes Bit ist.
Gibt die größte ganze Zahl num zurück, sodass die Summe der Preise aller Zahlen von 1 bis num kleiner oder gleich k ist.
Notiz:

In der binären Darstellung einer Zahl ist das gesetzte Bit ein Bit mit dem Wert 1.
Die binäre Darstellung einer Zahl wird von rechts nach links indiziert. Wenn beispielsweise s == 11100, s[4] == 1 und s[2] == 0.

Beispiel 1:

Eingabe: k = 9, x = 1
Ausgabe: 6
Erläuterung: Die Zahlen 1, 2, 3, 4, 5 und 6 können in binärer Darstellung als „1“, „10“, „11“, „100“, „101“ bzw. „110“ geschrieben werden.
Da x gleich 1 ist, ist der Preis jeder Zahl die Anzahl ihrer gesetzten Bits.
Die Anzahl der gesetzten Bits in diesen Zahlen beträgt 9. Die Summe der Preise der ersten 6 Zahlen beträgt also 9.
Die Antwort ist also 6.
Beispiel 2:

Eingabe: k = 7, x = 2
Ausgabe: 9
Erläuterung: Da x gleich 2 ist, sollten wir nur die geraden Bits überprüfen.
Das zweite Bit der binären Darstellung der Zahlen 2 und 3 ist ein gesetztes Bit. Die Summe ihrer Preise beträgt also 2.
Das zweite Bit der binären Darstellung der Zahlen 6 und 7 ist ein gesetztes Bit. Die Summe ihrer Preise beträgt also 2.
Das vierte Bit der binären Darstellung der Zahlen 8 und 9 ist ein gesetztes Bit, das zweite Bit jedoch nicht. Die Summe ihrer Preise beträgt also 2.
Die Zahlen 1, 4 und 5 haben in ihrer binären Darstellung keine gesetzten Bits in ihren geraden Bits. Die Summe ihrer Preise ist also 0.
Das zweite und das vierte Bit der binären Darstellung der Zahl 10 sind gesetzte Bits. Der Preis beträgt also 2.
Die Summe der Preise der ersten 9 Zahlen beträgt 6.
Da die Summe der Preise der ersten 10 Zahlen 8 beträgt, lautet die Antwort 9.

Einschränkungen:

1 <= k <= 10^15
1 <= x <= 8

Sie erhalten eine Ganzzahl k und eine Ganzzahl x.
Betrachten Sie S sei die 1-indizierte binäre Darstellung einer ganzzahligen Zahl. Der Preis für eine Zahl num ist die Anzahl der i, so dass i % x == 0 und S [i] ein festgelegtes Bit ist.
Geben Sie die größte Ganzzahl zurück, so dass Die Summe der Preise aller Zahlen von 1 bis num kleiner oder gleich k beträgt.
Notiz:

In der binären Darstellung eines Zahlensatzes ist ein Bit etwas Wert 1.
Die binäre Darstellung einer Zahl wird von rechts nach links indiziert. Zum Beispiel, wenn s == 11100, s [4] == 1 und s [2] == 0.

Beispiel 1:

Eingabe: k = 9, x = 1
Ausgabe: 6
Erläuterung: Die Zahlen 1, 2, 3, 4, 5 und 6 können in binärer Darstellung als "1", "10", "11", "100", "101" bzw. "110" geschrieben werden.
Da x gleich 1 ist, ist der Preis jeder Zahl die Anzahl seiner festgelegten Bits.
Die Anzahl der festgelegten Bits in diesen Zahlen beträgt 9. Die Summe der Preise der ersten 6 Zahlen beträgt also 9.
Die Antwort ist also 6.
Beispiel 2:

Eingabe: k = 7, x = 2
Ausgabe: 9
Erläuterung: Da x gleich 2 ist, sollten wir nur geraden Bits überprüfen.
Das zweite Bit der binären Darstellung von Zahlen 2 und 3 ist ein festgelegtes Bit. Die Summe ihrer Preise beträgt also 2.
Das zweite Bit der binären Darstellung der Zahlen 6 und 7 ist ein festgelegter Bit. Die Summe ihrer Preise beträgt also 2.
Das vierte Stück binärer Darstellung der Zahlen 8 und 9 ist ein festgelegtes Bit, aber ihr zweites Stück nicht. Die Summe ihrer Preise beträgt also 2.
Die Nummern 1, 4 und 5 haben in ihrer binären Darstellung keine Bits in ihren geraden Bits gesetzt. Die Summe ihrer Preise beträgt also 0.
Das zweite und das vierte Bit der binären Darstellung der Zahl 10 sind ein festgelegtes Bit. Der Preis beträgt also 2.
Die Summe der Preise der ersten 9 Zahlen beträgt 6.
Da die Summe der Preise der ersten 10 Zahlen 8 beträgt, beträgt die Antwort 9.

Einschränkungen:

1 <= k <= 10^15
1 <= x <= 8