Sie erhalten positive ganze Zahlen n und Ziel.
Ein Array nums ist schön, wenn es die folgenden Bedingungen erfüllt:

nums.length == n.
Zahlen bestehen aus paarweise unterschiedlichen positiven ganzen Zahlen.
Es gibt keine zwei unterschiedlichen Indizes, i und j, im Bereich [0, n – 1], so dass nums[i] + nums[j] == Ziel ist.

Gibt die kleinstmögliche Summe zurück, die ein schönes Array haben könnte, Modulo 10^9 + 7.

Beispiel 1:

Eingabe: n = 2, Ziel = 3
Ausgabe: 4
Erläuterung: Wir können sehen, dass nums = [1,3] schön ist.
- Das Array nums hat die Länge n = 2.
- Das Array nums besteht aus paarweise unterschiedlichen positiven Ganzzahlen.
- Es gibt keine zwei unterschiedlichen Indizes, i und j, mit nums[i] + nums[j] == 3.
Es kann bewiesen werden, dass 4 die kleinstmögliche Summe ist, die ein schönes Array haben könnte.

Beispiel 2:

Eingabe: n = 3, Ziel = 3
Ausgabe: 8
Erläuterung: Wir können sehen, dass nums = [1,3,4] schön ist.
- Das Array nums hat die Länge n = 3.
- Das Array nums besteht aus paarweise unterschiedlichen positiven Ganzzahlen.
- Es gibt keine zwei unterschiedlichen Indizes, i und j, mit nums[i] + nums[j] == 3.
Es kann bewiesen werden, dass 8 die kleinstmögliche Summe ist, die ein schönes Array haben könnte.

Beispiel 3:

Eingabe: n = 1, Ziel = 1
Ausgabe: 1
Erläuterung: Wir können sehen, dass nums = [1] schön ist.

Einschränkungen:

1 <= n <= 10^9
1 <= Ziel <= 10^9

Sie erhalten positive ganze Zahlen n und Ziel.
Ein Array nums ist schön, wenn es die folgenden Bedingungen erfüllt:

nums.length == n.
Zahlen bestehen aus paarweise unterschiedlichen positiven ganzen Zahlen.
Es gibt keine zwei unterschiedlichen Indizes, i und j, im Bereich [0, n – 1], so dass nums[i] + nums[j] == Ziel ist.

Gibt die kleinstmögliche Summe zurück, die ein schönes Array Modulo 10^9 + 7 haben könnte.

Beispiel 1:

Eingabe: n = 2, Ziel = 3
Ausgabe: 4
Erläuterung: Wir können sehen, dass nums = [1,3] schön ist.
- Das Array nums hat die Länge n = 2.
- Das Array nums besteht aus paarweise unterschiedlichen positiven Ganzzahlen.
- Es gibt keine zwei unterschiedlichen Indizes, i und j, mit nums[i] + nums[j] == 3.
Es kann bewiesen werden, dass 4 die kleinstmögliche Summe ist, die ein schönes Array haben könnte.

Beispiel 2:

Eingabe: n = 3, Ziel = 3
Ausgabe: 8
Erläuterung: Wir können sehen, dass nums = [1,3,4] schön ist.
- Das Array nums hat die Länge n = 3.
- Das Array nums besteht aus paarweise unterschiedlichen positiven Ganzzahlen.
- Es gibt keine zwei unterschiedlichen Indizes, i und j, mit nums[i] + nums[j] == 3.
Es kann bewiesen werden, dass 8 die kleinstmögliche Summe ist, die ein schönes Array haben könnte.

Beispiel 3:

Eingabe: n = 1, Ziel = 1
Ausgabe: 1
Erläuterung: Wir können sehen, dass nums = [1] schön ist.

Einschränkungen:

1 <= n <= 10^9
1 <= Ziel <= 10^9

Sie erhalten positive ganze Zahlen n und Ziel.
Ein Array nums ist schön, wenn es die folgenden Bedingungen erfüllt:

nums.length == n.
Zahlen bestehen aus paarweise unterschiedlichen positiven ganzen Zahlen.
Es gibt keine zwei unterschiedlichen Indizes, i und j, im Bereich [0, n – 1], so dass nums[i] + nums[j] == Ziel ist.

Gibt die kleinstmögliche Summe zurück, die ein schönes Array haben könnte, Modulo 10^9 + 7.

Beispiel 1:

Eingabe: n = 2, Ziel = 3
Ausgabe: 4
Erläuterung: Wir können sehen, dass nums = [1,3] schön ist.
- Das Array nums hat die Länge n = 2.
- Das Array nums besteht aus paarweise unterschiedlichen positiven Ganzzahlen.
- Es gibt keine zwei unterschiedlichen Indizes, i und j, mit nums[i] + nums[j] == 3.
Es kann bewiesen werden, dass 4 die minimal mögliche Summe ist, die ein schönes Array haben könnte.

Beispiel 2:

Eingabe: n = 3, Ziel = 3
Ausgabe: 8
Erläuterung: Wir können sehen, dass nums = [1,3,4] schön ist.
- Das Array nums hat die Länge n = 3.
- Das Array nums besteht aus paarweise unterschiedlichen positiven Ganzzahlen.
- Es gibt keine zwei unterschiedlichen Indizes, i und j, mit nums[i] + nums[j] == 3.
Es kann bewiesen werden, dass 8 die kleinstmögliche Summe ist, die ein schönes Array haben könnte.

Beispiel 3:

Eingabe: n = 1, Ziel = 1
Ausgabe: 1
Erläuterung: Wir können sehen, dass nums = [1] schön ist.

Einschränkungen:

1 <= n <= 10^9
1 <= Ziel <= 10^9


Sie erhalten eine Binärzeichenfolge s und eine Ganzzahl k.
Eine Binärzeichenfolge erfüllt die k-Einschränkung, wenn eine der folgenden Bedingungen zutrifft:

Die Anzahl der Nullen in der Zeichenfolge beträgt höchstens k.
Die Anzahl der Einsen in der Zeichenfolge beträgt höchstens k.

Gibt eine Ganzzahl zurück, die die Anzahl der Teilzeichenfolgen von s angibt, die die k-Einschränkung erfüllen.

Beispiel 1:

Eingabe: s = „10101“, k = 1
Ausgabe: 12
Erläuterung:
Jeder Teilstring von s außer den Teilstrings „1010“, „10101“ und „0101“ erfüllt die k-Einschränkung.

Beispiel 2:

Eingabe: s = „1010101“, k = 2
Ausgabe: 25
Erläuterung:
Jeder Teilstring von s mit Ausnahme der Teilstrings mit einer Länge größer als 5 erfüllt die k-Einschränkung.

Beispiel 3:

Eingabe: s = „11111“, k = 1
Ausgabe: 15
Erläuterung:
Alle Teilzeichenfolgen von s erfüllen die k-Einschränkung.

Einschränkungen:

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

Sie erhalten eine Binärzeichenfolge s und eine Ganzzahl k.
Eine Binärzeichenfolge erfüllt die k-Einschränkung, wenn eine der folgenden Bedingungen zutrifft:

Die Anzahl der Nullen in der Zeichenfolge beträgt höchstens k.
Die Anzahl der Einsen in der Zeichenfolge beträgt höchstens k.

Gibt eine Ganzzahl zurück, die die Anzahl der Teilzeichenfolgen von s angibt, die die k-Einschränkung erfüllen.

Beispiel 1:

Eingabe: s = „10101“, k = 1
Ausgabe: 12
Erläuterung:
Jeder Teilstring von s außer den Teilstrings „1010“, „10101“ und „0101“ erfüllt die k-Einschränkung.

Beispiel 2:

Eingabe: s = „1010101“, k = 2
Ausgabe: 25
Erläuterung:
Jeder Teilstring von s mit Ausnahme der Teilstrings mit einer Länge größer als 5 erfüllt die k-Einschränkung.

Beispiel 3:

Eingabe: s = „11111“, k = 1
Ausgabe: 15
Erläuterung:
Alle Teilzeichenfolgen von s erfüllen die k-Einschränkung.

Einschränkungen:

1 <= s.length <= 50
1 <= k <= s.länge
s[i] ist entweder '0' oder '1'.


Ein futuristischer Sportwissenschaftler gibt Ihnen zwei ganzzahlige Arrays „energyDrinkA“ und „energyDrinkB“ mit der gleichen Länge n. Diese Arrays stellen die Energieschübe pro Stunde dar, die durch zwei verschiedene Energy-Drinks, A und B, bereitgestellt werden.
Sie möchten Ihren gesamten Energieschub maximieren, indem Sie einen Energy-Drink pro Stunde trinken. Wenn Sie jedoch von einem Energy-Drink auf ein anderes umsteigen möchten, müssen Sie eine Stunde warten, um Ihr System zu reinigen (was bedeutet, dass Sie in dieser Stunde keinen Energieschub erhalten).
Geben Sie den maximalen Gesamtenergieschub zurück, den Sie in den nächsten n Stunden gewinnen können.
Beachten Sie, dass Sie mit dem Konsum eines der beiden Energy-Drinks beginnen können.

Beispiel 1:

Eingabe: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Ausgabe: 5
Erläuterung:
Um einen Energieschub von 5 zu erreichen, trinken Sie nur den energyDrinkA (oder nur B).

Beispiel 2:

Eingabe: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Ausgabe: 7
Erläuterung:
Um einen Energieschub von 7 zu erhalten:

Trinken Sie in der ersten Stunde den energyDrinkA.
Steigen Sie auf den energyDrinkB um und wir verlieren den Energieschub der zweiten Stunde.
Holen Sie sich in der dritten Stunde den Energieschub des Getränks B.

Einschränkungen:

n == energieDrinkA.length == energieDrinkB.länge
3 <= n <= 10^5
1 <= energieDrinkA[i], energieDrinkB[i] <= 10^5

Ein futuristischer Sportwissenschaftler gibt Ihnen zwei ganzzahlige Arrays energyDrinkA und energyDrinkB gleicher Länge n. Diese Arrays stellen die Energieschübe pro Stunde dar, die von zwei verschiedenen Energy-Drinks, A bzw. B, bereitgestellt werden.
Sie möchten Ihren Gesamtenergieschub maximieren, indem Sie einen Energydrink pro Stunde trinken. Wenn Sie jedoch von einem Energy-Drink zum anderen wechseln möchten, müssen Sie eine Stunde warten, um Ihr System zu reinigen (was bedeutet, dass Sie in dieser Stunde keinen Energieschub erhalten).
Gib den maximalen Energieschub zurück, den du in den nächsten n Stunden erhalten kannst.
Beachten Sie, dass Sie mit dem Konsum eines der beiden Energy-Drinks beginnen können.

Beispiel 1:

Eingabe: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Ausgang: 5
Erklärung:
Um einen Energieschub von 5 zu erhalten, trinken Sie nur den Energy Drink A (oder nur B).

Beispiel 2:

Eingabe: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Ausgang: 7
Erklärung:
Um einen Energieschub von 7 zu erhalten:

Trinken Sie in der ersten Stunde den Energy Drink A.
Wechselt man auf den Energy Drink B, verliert man den Energieschub der zweiten Stunde.
Gewinnen Sie den Energieschub des Getränks B in der dritten Stunde.

Zwänge:

n == energyDrinkA.length == energyDrinkB.length
3 <= n <= 10^5
1 <= energyDrinkA[i], energyDrinkB[i] <= 10^5

Ein futuristischer Sportwissenschaftler gibt Ihnen zwei ganzzahlige Arrays „energyDrinkA“ und „energyDrinkB“ mit der gleichen Länge n. Diese Arrays stellen die Energieschübe pro Stunde dar, die durch zwei verschiedene Energy-Drinks, A und B, bereitgestellt werden.
Sie möchten Ihren gesamten Energieschub maximieren, indem Sie einen Energy-Drink pro Stunde trinken. Wenn Sie jedoch von einem Energy-Drink auf ein anderes umsteigen möchten, müssen Sie eine Stunde warten, um Ihr System zu reinigen (was bedeutet, dass Sie in dieser Stunde keinen Energieschub erhalten).
Geben Sie den maximalen Gesamtenergieschub zurück, den Sie in den nächsten n Stunden gewinnen können.
Beachten Sie, dass Sie mit dem Konsum eines der beiden Energy-Drinks beginnen können.

Beispiel 1:

Eingabe: EnergyDrinkA = [1,3,1], EnergyDrinkB = [3,1,1]
Ausgabe: 5
Erläuterung:
Um einen Energieschub von 5 zu erreichen, trinken Sie nur den Energydrink A (oder nur B).

Beispiel 2:

Eingabe: EnergyDrinkA = [4,1,1], EnergyDrinkB = [1,1,3]
Ausgabe: 7
Erläuterung:
Um einen Energieschub von 7 zu erhalten:

Trinken Sie in der ersten Stunde den Energydrink A.
Steigen Sie auf den Energydrink B um und wir verlieren den Energieschub der zweiten Stunde.
Holen Sie sich in der dritten Stunde den Energieschub des Getränks B.

Einschränkungen:

n == energieDrinkA.length == energieDrinkB.länge
3 <= n <= 10^5
1 <= energieDrinkA[i], energieDrinkB[i] <= 10^5


Sie erhalten zwei positive ganze Zahlen n und k.
Eine ganze Zahl x heißt k-palindromisch, wenn:

x ist ein Palindrom.
x ist durch k teilbar.

Gibt die größte Ganzzahl mit n Ziffern (als Zeichenfolge) zurück, die k-palindromisch ist.
Beachten Sie, dass die Ganzzahl keine führenden Nullen enthalten darf.

Beispiel 1:

Eingabe: n = 3, k = 5
Ausgabe: „595“
Erläuterung:
595 ist die größte k-palindromische Ganzzahl mit 3 Ziffern.

Beispiel 2:

Eingabe: n = 1, k = 4
Ausgabe: „8“
Erläuterung:
4 und 8 sind die einzigen k-palindromischen ganzen Zahlen mit einer Ziffer.

Beispiel 3:

Eingabe: n = 5, k = 6
Ausgabe: „89898“

Einschränkungen:

1 <= n <= 10^5
1 <= k <= 9

Gegeben sind zwei positive ganze Zahlen n und k.
Eine ganze Zahl x wird k-palindromisch genannt, wenn:

x ein Palindrom ist.
x durch k teilbar ist.

Geben Sie die größte ganze Zahl mit n Ziffern (als String) zurück, die k-palindromisch ist.
Beachten Sie, dass die ganze Zahl keine führenden Nullen haben darf.

Beispiel 1:

Eingabe: n = 3, k = 5
Ausgabe: „595“
Erläuterung:
595 ist die größte k-palindromische ganze Zahl mit 3 Ziffern.

Beispiel 2:

Eingabe: n = 1, k = 4
Ausgabe: „8“
Erläuterung:
4 und 8 sind die einzigen k-palindromischen ganzen Zahlen mit 1 Stelle.

Beispiel 3:

Eingabe: n = 5, k = 6
Ausgabe: „89898“

Beschränkungen:

1 <= n <= 10^5
1 <= k <= 9


Du hast ein ganzzahliges Array `nums`, eine Ganzzahl `k` und einen Ganzzahl-Multiplikator.
Du musst `k` Operationen auf `nums` durchführen. In jeder Operation:

Finde den minimalen Wert `x` in `nums`. Wenn der minimale Wert mehrmals vorkommt, wähle den, der zuerst erscheint.
Ersetze den ausgewählten minimalen Wert `x` mit `x * multiplikator`.

Gib ein Ganzzahl-Array zurück, das den Endzustand von `nums` nach allen `k` Operationen darstellt.

Beispiel 1:

Input: nums = [2,1,3,5,6], k = 5, multiplier = 2
Output: [8,4,6,5,6]
Erläuterung:

| Operation        | Ergebnis           |
|------------------|--------------------|
| Nach Operation 1 | [2, 2, 3, 5, 6]   |
| Nach Operation 2 | [4, 2, 3, 5, 6]   |
| Nach Operation 3 | [4, 4, 3, 5, 6]   |
| Nach Operation 4 | [4, 4, 6, 5, 6]   |
| Nach Operation 5 | [8, 4, 6, 5, 6]   |

Beispiel 2:

Input: nums = [1,2], k = 3, multiplier = 4
Output: [16,8]
Erläuterung:

| Operation        | Ergebnis           |
|------------------|--------------------|
| Nach Operation 1 | [4, 2]             |
| Nach Operation 2 | [4, 8]             |
| Nach Operation 3 | [16, 8]            |

Bedingungen:

1 <= nums.length <= 100
1 <= nums[i] <= 100
1 <= k <= 10
1 <= multiplier <= 5

Sie erhalten ein ganzzahliges Array nums, eine ganze Zahl k und einen ganzzahligen Multiplikator.
Sie müssen k Operationen für Zahlen ausführen. Bei jedem Vorgang:

Finden Sie den Mindestwert x in nums. Wenn der Mindestwert mehrfach vorkommt, wählen Sie den zuerst angezeigten Wert aus.
Ersetzen Sie den ausgewählten Mindestwert x durch x * Multiplikator.

Gibt ein ganzzahliges Array zurück, das den Endzustand von nums angibt, nachdem alle k Operationen ausgeführt wurden.

Beispiel 1:

Eingabe: nums = [2,1,3,5,6], k = 5, Multiplikator = 2
Ausgabe: [8,4,6,5,6]
Erläuterung:

Betrieb
Ergebnis

Nach der Operation 1
[2, 2, 3, 5, 6]

Nach Operation 2
[4, 2, 3, 5, 6]

Nach Operation 3
[4, 4, 3, 5, 6]

Nach der Operation 4
[4, 4, 6, 5, 6]

Nach der Operation 5
[8, 4, 6, 5, 6]

Beispiel 2:

Eingabe: nums = [1,2], k = 3, Multiplikator = 4
Ausgabe: [16,8]
Erläuterung:

Betrieb
Ergebnis

Nach der Operation 1
[4, 2]

Nach Operation 2
[4, 8]

Nach Operation 3
[16, 8]

Einschränkungen:

1 <= Anzahl.Länge <= 100
1 <= nums[i] <= 100
1 <= k <= 10
1 <= Multiplikator <= 5

Sie erhalten eine Ganzzahl -Array -nums, eine Ganzzahl k und einen Ganzzahl -Multiplikator.
Sie müssen k -Operationen auf nums ausführen. In jeder Operation:

Finden Sie den Mindestwert x in nums. Wenn der Mindestwert mehrere Ereignisse vorliegt, wählen Sie die zuerst angezeigte.
Ersetzen Sie den ausgewählten Mindestwert x durch x * Multiplikator.

Gibt ein Ganzzahl -Array zurück, das den endgültigen Zustand der NUMS nach der Durchführung aller k -Operationen bezeichnet.

Beispiel 1:

Eingabe: nums = [2,1,3,5,6], k = 5, multiplier = 2
Ausgabe: [8,4,6,5,6]
Erläuterung:

Betrieb
Ergebnis

Nach Operation 1
[2, 2, 3, 5, 6]

Nach Operation 2
[4, 2, 3, 5, 6]

Nach Operation 3
[4, 4, 3, 5, 6]

Nach Operation 4
[4, 4, 6, 5, 6]

Nach Operation 5
[8, 4, 6, 5, 6]

Beispiel 2:

Eingabe: nums = [1,2], k = 3, multiplier = 4
Ausgabe: [16,8]
Erläuterung:

Betrieb
Ergebnis

Nach Operation 1
[4, 2]

Nach Operation 2
[4, 8]

Nach Operation 3
[16, 8]

Einschränkungen:

1 <= nums.length <= 100
1 <= nums[i] <= 100
1 <= k <= 10
1 <= multiplier <= 5


Sie erhalten ein Array nums, das aus positiven ganzen Zahlen besteht.
Wir nennen in diesem Problem zwei ganze Zahlen x und y nahezu gleich, wenn beide ganzen Zahlen gleich werden können, nachdem die folgende Operation höchstens einmal ausgeführt wurde:

Wählen Sie entweder x oder y und vertauschen Sie zwei beliebige Ziffern innerhalb der gewählten Zahl.

Gibt die Anzahl der Indizes i und j in nums zurück, wobei i < j ist, sodass nums[i] und nums[j] nahezu gleich sind.
Beachten Sie, dass eine Ganzzahl nach der Ausführung einer Operation führende Nullen haben darf.

Beispiel 1:

Eingabe: nums = [3,12,30,17,21]
Ausgabe: 2
Erläuterung:
Die nahezu gleichen Elementpaare sind:

3 und 30. Durch Vertauschen von 3 und 0 in 30 erhalten Sie 3.
12 und 21. Durch Vertauschen von 1 und 2 in 12 erhält man 21.

Beispiel 2:

Eingabe: nums = [1,1,1,1,1]
Ausgabe: 10
Erläuterung:
Alle zwei Elemente im Array sind nahezu gleich.

Beispiel 3:

Eingabe: nums = [123,231]
Ausgabe: 0
Erläuterung:
Wir können keine zwei Ziffern von 123 oder 231 vertauschen, um die andere zu erreichen.

Einschränkungen:

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

Sie erhalten eine Array -nums, die aus positiven Ganzzahlen besteht.
Wir nennen zwei Ganzzahlen x und y in diesem Problem fast gleich, wenn beide Ganzzahlen nach der Ausführung der folgenden Operation höchstens einmal werden können:

Wählen Sie entweder x oder y und tauschen Sie zwei Ziffern innerhalb der gewählten Zahl aus.

Gibt die Anzahl der Indizes i und j in nums zurück, wobei i < j ist, so dass nums[i] und nums[j] fast gleich sind.
Beachten Sie, dass eine Ganzzahl nach der Durchführung einer Operation führende Nullen haben kann.

Beispiel 1:

Eingabe: nums = [3,12,30,17,21]
Ausgabe: 2
Erläuterung:
Die fast gleichen Elementpaare sind:

3 und 30. Durch Tausch von 3 und 0 in 30 erhalten Sie 3.
12 und 21. Durch den Austausch von 1 und 2 in 12 bekommen Sie 21.

Beispiel 2:

Eingabe: nums = [1,1,1,1,1]
Ausgabe: 10
Erläuterung:
Alle zwei Elemente im Array sind fast gleich.

Beispiel 3:

Eingabe: nums = [123,231]
Ausgabe: 0
Erläuterung:
Wir können keine zwei Ziffern von 123 oder 231 tauschen, um den anderen zu erreichen.

Einschränkungen:

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

Du hast ein Array nums, das aus positiven ganzen Zahlen besteht.
Wir nennen zwei ganze Zahlen x und y in diesem Problem fast gleich, wenn beide Zahlen nach maximal einmaligem Ausführen der folgenden Operation gleich werden können:

Wähle entweder x oder y und tausche zwei Ziffern innerhalb der gewählten Zahl.

Gib die Anzahl der Indizes i und j in nums zurück, wobei i < j, so dass nums[i] und nums[j] fast gleich sind.
Beachte, dass es erlaubt ist, dass eine ganze Zahl nach Ausführen einer Operation führende Nullen hat.

Beispiel 1:

Input: nums = [3,12,30,17,21]
Output: 2
Erklärung:
Die fast gleichen Paare von Elementen sind:

3 und 30. Durch Tauschen von 3 und 0 in 30 erhältst du 3.
12 und 21. Durch Tauschen von 1 und 2 in 12 erhältst du 21.

Beispiel 2:

Input: nums = [1,1,1,1,1]
Output: 10
Erklärung:
Jedes Paar von Elementen im Array ist fast gleich.

Beispiel 3:

Input: nums = [123,231]
Output: 0
Erklärung:
Wir können keine zwei Ziffern von 123 oder 231 tauschen, um das andere zu erreichen.

Einschränkungen:

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


Sie erhalten zwei Zeichenfolgen, Koordinaten1 und Koordinaten2, die die Koordinaten eines Quadrats auf einem 8 x 8-Schachbrett darstellen.
Unten ist das Schachbrett als Referenz.

Gibt „true“ zurück, wenn diese beiden Quadrate die gleiche Farbe haben, andernfalls „false“.
Die Koordinate stellt immer ein gültiges Schachbrettfeld dar. Die Koordinate hat immer zuerst den Buchstaben (der ihre Spalte angibt) und dann die Zahl (die ihre Zeile angibt).

Beispiel 1:

Eingabe: Koordinate1 = „a1“, Koordinate2 = „c3“
Ausgabe: wahr
Erläuterung:
Beide Quadrate sind schwarz.

Beispiel 2:

Eingabe: Koordinate1 = „a1“, Koordinate2 = „h3“
Ausgabe: falsch
Erläuterung:
Das Quadrat „a1“ ist schwarz und „h3“ ist weiß.

Einschränkungen:

Koordinaten1.Länge == Koordinaten2.Länge == 2
'a' <= Koordinate1[0], Koordinate2[0] <= 'h'
'1' <= Koordinate1[1], Koordinate2[1] <= '8'

Sie erhalten zwei Zeichenfolgen, Koordinaten1 und Koordinaten2, die die Koordinaten eines Quadrats auf einem 8 x 8-Schachbrett darstellen.
Unten ist das Schachbrett als Referenz.

Gibt „true“ zurück, wenn diese beiden Quadrate die gleiche Farbe haben, andernfalls „false“.
Die Koordinate stellt immer ein gültiges Schachbrettfeld dar. Die Koordinate hat immer zuerst den Buchstaben (der ihre Spalte angibt) und dann die Zahl (die ihre Zeile angibt).

Beispiel 1:

Eingabe: coordinate1 = "a1", coordinate2 = "c3"
Ausgabe: wahr
Erläuterung:
Beide Quadrate sind schwarz.

Beispiel 2:

Eingabe: coordinate1 = "a1", coordinate2 = "h3"
Ausgabe: falsch
Erläuterung:
Das Quadrat „a1“ ist schwarz und „h3“ ist weiß.

Einschränkungen:

coordinate1.length == coordinate2.length == 2
'a' <= coordinate1[0], coordinate2[0] <= 'h'
'1' <= coordinate1[1], coordinate2[1] <= '8'


Es gibt eine unendliche 2D-Ebene.
Sie erhalten eine positive ganze Zahl k. Sie erhalten außerdem ein 2D-Array-Abfragen, das die folgenden Abfragen enthält:

query[i] = [x, y]: Erstellen Sie ein Hindernis an der Koordinate (x, y) in der Ebene. Es ist gewährleistet, dass sich bei dieser Abfrage an dieser Koordinate kein Hindernis befindet.

Nach jeder Abfrage müssen Sie die Entfernung des k^-nächsten Hindernisses vom Ursprung ermitteln.
Gibt ein ganzzahliges Array mit Ergebnissen zurück, wobei results[i] das k^-nächste Hindernis nach der Abfrage i angibt, oder results[i] == -1, wenn es weniger als k Hindernisse gibt.
Beachten Sie, dass es zunächst nirgendwo Hindernisse gibt.
Der Abstand eines Hindernisses an der Koordinate (x, y) vom Ursprung ist durch |x| gegeben + |y|.

Beispiel 1:

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

Zunächst gibt es 0 Hindernisse.
Nach Abfragen[0] gibt es weniger als 2 Hindernisse.
Nach Abfragen[1] gibt es Hindernisse in den Abständen 3 und 7.
Nach Abfragen[2] gibt es Hindernisse in den Entfernungen 3, 5 und 7.
Nach Abfragen[3] gibt es Hindernisse in den Entfernungen 3, 3, 5 und 7.

Beispiel 2:

Eingabe: queries = [[5,5],[4,4],[3,3]], k = 1
Ausgabe: [10,8,6]
Erläuterung:

Nach Abfragen[0] gibt es ein Hindernis im Abstand 10.
Nach Abfragen[1] gibt es Hindernisse in den Entfernungen 8 und 10.
Nach Abfragen[2] gibt es Hindernisse in den Entfernungen 6, 8 und 10.

Einschränkungen:

1 <= queries.length <= 2 * 10^5
Alle Abfragen[i] sind eindeutig.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

Es gibt eine unendliche 2D-Ebene.
Sie erhalten eine positive ganze Zahl k. Sie erhalten außerdem ein 2D-Array-Abfragen, das die folgenden Abfragen enthält:

query[i] = [x, y]: Erstellen Sie ein Hindernis an der Koordinate (x, y) in der Ebene. Es ist gewährleistet, dass sich bei dieser Abfrage an dieser Koordinate kein Hindernis befindet.

Nach jeder Abfrage müssen Sie die Entfernung des k^-nächsten Hindernisses vom Ursprung ermitteln.
Gibt ein ganzzahliges Array mit Ergebnissen zurück, wobei results[i] das k^-nächste Hindernis nach der Abfrage i angibt, oder results[i] == -1, wenn es weniger als k Hindernisse gibt.
Beachten Sie, dass es zunächst nirgendwo Hindernisse gibt.
Der Abstand eines Hindernisses an der Koordinate (x, y) vom Ursprung ist durch |x| gegeben + |y|.

Beispiel 1:

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

Zunächst gibt es 0 Hindernisse.
Nach Abfragen[0] gibt es weniger als 2 Hindernisse.
Nach Abfragen[1] gibt es Hindernisse in den Abständen 3 und 7.
Nach Abfragen[2] gibt es Hindernisse in den Entfernungen 3, 5 und 7.
Nach Abfragen[3] gibt es Hindernisse in den Entfernungen 3, 3, 5 und 7.

Beispiel 2:

Eingabe: Abfragen = [[5,5],[4,4],[3,3]], k = 1
Ausgabe: [10,8,6]
Erläuterung:

Nach Abfragen[0] gibt es ein Hindernis im Abstand 10.
Nach Abfragen[1] gibt es Hindernisse in den Entfernungen 8 und 10.
Nach Abfragen[2] gibt es Hindernisse in den Entfernungen 6, 8 und 10.

Einschränkungen:

1 <= query.length <= 2 * 10^5
Alle Abfragen[i] sind eindeutig.
-10^9 <= Abfragen[i][0], Abfragen[i][1] <= 10^9
1 <= k <= 10^5


Sie erhalten eine 2D-Matrix-Raster, bestehend aus positiven ganzen Zahlen.
Sie müssen eine oder mehrere Zellen aus der Matrix auswählen, sodass die folgenden Bedingungen erfüllt sind:

Keine zwei ausgewählten Zellen befinden sich in derselben Zeile der Matrix.
Die Werte in der Menge der ausgewählten Zellen sind einzigartig.

Ihre Punktzahl ist die Summe der Werte der ausgewählten Zellen.
Geben Sie die maximale Punktzahl zurück, die Sie erreichen können.

Beispiel 1:

Eingabe: grid = [[1,2,3],[4,3,2],[1,1,1]]
Ausgabe: 8
Erläuterung:

Wir können die Zellen mit den Werten 1, 3 und 4 auswählen, die oben farbig markiert sind.

Beispiel 2:

Eingabe: grid = [[8,7,6],[8,3,2]]
Ausgabe: 15
Erläuterung:

Wir können die Zellen mit den Werten 7 und 8 auswählen, die oben farbig markiert sind.

Einschränkungen:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100

Sie erhalten ein 2D -Matrixgitter, das aus positiven Ganzzahlen besteht.
Sie müssen eine oder mehrere Zellen aus der Matrix auswählen, sodass die folgenden Bedingungen erfüllt sind:

Keine zwei ausgewählten Zellen befinden sich in derselben Zeile der Matrix.
Die Werte in der Menge ausgewählter Zellen sind eindeutig.

Ihre Punktzahl ist die Summe der Werte der ausgewählten Zellen.
Geben Sie die maximale Punktzahl zurück, die Sie erzielen können.

Beispiel 1:

Eingabe: grid = [[1,2,3],[4,3,2],[1,1,1]]
Ausgabe: 8
Erläuterung:

Wir können die Zellen mit Werten 1, 3 und 4 auswählen, die oben gefärbt sind.

Beispiel 2:

Eingabe: grid = [[8,7,6],[8,3,2]]
Ausgabe: 15
Erläuterung:

Wir können die Zellen mit den oben gefärbten Werten 7 und 8 auswählen.

Einschränkungen:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100

Sie erhalten ein 2D-Matrixgitter, das aus positiven ganzen Zahlen besteht.
Sie müssen eine oder mehrere Zellen aus der Matrix auswählen, sodass die folgenden Bedingungen erfüllt sind:

Keine zwei ausgewählten Zellen befinden sich in derselben Zeile der Matrix.
Die Werte im Satz ausgewählter Zellen sind eindeutig.

Ihre Punktzahl ist die Summe der Werte der ausgewählten Zellen.
Geben Sie die maximale Punktzahl zurück, die Sie erreichen können.

Beispiel 1:

Eingabe: Gitter = [[1,2,3],[4,3,2],[1,1,1]]
Ausgabe: 8
Erläuterung:

Wir können die oben gefärbten Zellen mit den Werten 1, 3 und 4 auswählen.

Beispiel 2:

Eingabe: Gitter = [[8,7,6],[8,3,2]]
Ausgabe: 15
Erläuterung:

Wir können die oben gefärbten Zellen mit den Werten 7 und 8 auswählen.

Einschränkungen:

1 <= Gitterlänge, Gitter[i].Länge <= 10
1 <= Gitter[i][j] <= 100


Sie erhalten ein Array mit n Ganzzahlen und ein 2D-Integer-Array mit Abfragen der Größe q, wobei Abfragen[i] = [l_i, r_i].
Für jede Abfrage müssen Sie den maximalen XOR-Score eines beliebigen Subarrays von nums[l_i..r_i] ermitteln.
Der XOR-Score eines Arrays a wird ermittelt, indem die folgenden Operationen wiederholt auf a angewendet werden, sodass nur ein Element übrig bleibt, nämlich der Score:

Ersetzen Sie gleichzeitig a[i] durch a[i] XOR a[i + 1] für alle Indizes i außer dem letzten.
Entfernen Sie das letzte Element von a.

Gibt eine Array-Antwort der Größe q zurück, wobei Antwort[i] die Antwort auf die Abfrage i ist.

Beispiel 1:

Eingabe: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Ausgabe: [12,60,60]
Erläuterung:
In der ersten Abfrage hat nums[0..2] 6 Subarrays [2], [8], [4], [2, 8], [8, 4] und [2, 8, 4] mit jeweils a jeweiligen XOR-Score von 2, 8, 4, 10, 12 und 6. Die Antwort für die Abfrage ist 12, der größte aller XOR-Scores.
In der zweiten Abfrage ist das Subarray von nums[1..4] mit dem höchsten XOR-Score nums[1..4] mit einem Score von 60.
In der dritten Abfrage ist das Subarray von nums[0..5] mit dem höchsten XOR-Score nums[1..4] mit einem Score von 60.

Beispiel 2:

Eingabe: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Ausgabe: [7,14,11,14,5]
Erläuterung:

Index
nums[l_i..r_i]
Maximales XOR-Score-Subarray
Maximaler Subarray-XOR-Score

0
[0, 7, 3, 2]
[7]
7

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

2
[3, 2, 8]
[3, 2, 8]
11

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

4
[5, 1]
[5]
5

Einschränkungen:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == query.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1

Sie erhalten ein Array mit n Ganzzahlen und ein 2D-Integer-Array mit Abfragen der Größe q, wobei Abfragen[i] = [l_i, r_i].
Für jede Abfrage müssen Sie den maximalen XOR-Score eines beliebigen Subarrays von nums[l_i..r_i] ermitteln.
Der XOR-Score eines Arrays a wird durch wiederholtes Anwenden der folgenden Operationen auf a ermittelt, sodass nur ein Element übrig bleibt, nämlich der Score:

Ersetzen Sie gleichzeitig a[i] durch a[i] XOR a[i + 1] für alle Indizes i außer dem letzten.
Entfernen Sie das letzte Element von a.

Gibt eine Array-Antwort der Größe q zurück, wobei Antwort[i] die Antwort auf die Abfrage i ist.

Beispiel 1:

Eingabe: Zahlen = [2,8,4,32,16,1], Abfragen = [[0,2],[1,4],[0,5]]
Ausgabe: [12,60,60]
Erläuterung:
In der ersten Abfrage hat nums[0..2] 6 Subarrays [2], [8], [4], [2, 8], [8, 4] und [2, 8, 4] mit jeweils a jeweiligen XOR-Score von 2, 8, 4, 10, 12 und 6. Die Antwort für die Abfrage ist 12, der größte aller XOR-Scores.
In der zweiten Abfrage ist das Subarray von nums[1..4] mit dem höchsten XOR-Score nums[1..4] mit einem Score von 60.
In der dritten Abfrage ist das Subarray von nums[0..5] mit dem höchsten XOR-Score nums[1..4] mit einem Score von 60.

Beispiel 2:

Eingabe: Zahlen = [0,7,3,2,8,5,1], Abfragen = [[0,3],[1,5],[2,4],[2,6],[5, 6]]
Ausgabe: [7,14,11,14,5]
Erläuterung:

Index
nums[l_i..r_i]
Maximales XOR-Score-Subarray
Maximaler Subarray-XOR-Score

0
[0, 7, 3, 2]
[7]
7

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

2
[3, 2, 8]
[3, 2, 8]
11

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

4
[5, 1]
[5]
5

Einschränkungen:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == query.length <= 10^5
query[i].length == 2
Abfragen[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1

Sie erhalten eine Array nums von n -Zahlen und ein 2D-Integer-Array queries der Größe q, wobei queries[i] = [l_i, r_i].
Für jede Abfrage müssen Sie die maximale XOR -Bewertung einer Teilarray von nums[l_i..r_i] finden.
Die XOR-Punktzahl eines Arrays a wird gefunden, indem die folgenden Operationen wiederholt auf a angewendet werden, so dass nur ein Element übrig bleibt, dh die Punktzahl:

Ersetzen Sie gleichzeitig a[i] durch a[i] XOR a[i + 1] für alle Indizes i außer dem letzten.
Entfernen Sie das letzte Element von a.

Gibt ein Array answer der Größe q zurück, bei der Antwort [i] die Antwort auf die Abfrage i ist.

Beispiel 1:

Eingabe: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Ausgabe: [12,60,60]
Erläuterung:
In der ersten Abfrage hat nums[0..2] 6 Teilarrays [2], [8], [4], [2, 8], [8, 4] und [2, 8, 4] jeweils mit der jeweiligen XOR-Punktzahl von 2, 8, 4, 10, 12 und 6. Die Antwort für die Abfrage beträgt 12, die größte aller XOR -Ergebnisse.
In der zweiten Abfrage ist das Teilarray von nums[1..4] mit der größten XOR-Punktzahl nums[1..4] mit einer Punktzahl von 60.
In der dritten Abfrage beträgt die Subtarray von nums[0..5] mit der größten XOR -Punktzahl nums[1..4] mit einer Punktzahl von 60.

Beispiel 2:

Eingabe: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Ausgabe: [7,14,11,14,5]
Erläuterung:

Index
nums [l_i..r_i]
Maximales XOR-Score-Teilarray
Maximale XOR-Punktzahl des Teilarrays

0
[0, 7, 3, 2]
[7]
7

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

2
[3, 2, 8]
[3, 2, 8]
11

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

4
[5, 1]
[5]
5

Einschränkungen:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1


Sie erhalten eine Datumszeichenfolge, die ein gregorianisches Kalenderdatum im Format jjjj-mm-tt darstellt.
Das Datum kann in seiner Binärdarstellung geschrieben werden, die man erhält, indem man Jahr, Monat und Tag in ihre Binärdarstellungen ohne führende Nullen umwandelt und sie im Jahr-Monat-Tag-Format aufschreibt.
Gibt die binäre Darstellung des Datums zurück.

Beispiel 1:

Eingabe: Datum = "2080-02-29"
Ausgabe: "100000100000-10-11101"
Erläuterung:
100000100000, 10 und 11101 sind die binären Darstellungen von 2080, 02 bzw. 29.

Beispiel 2:

Eingabe: Datum = "1900-01-01"
Ausgabe: "11101101100-1-1"
Erläuterung:
11101101100, 1 und 1 sind die binären Darstellungen von 1900, 1 bzw. 1.

Einschränkungen:

date.length == 10
date[4] == date[7] == '-', und alle anderen date[i]s sind Ziffern.
Die Eingabe wird so generiert, dass das Datum ein gültiges gregorianisches Kalenderdatum zwischen dem 1. Januar 1900 und dem 31. Dezember 2100 (beide einschließlich) darstellt.

Sie erhalten eine Binärdarstellung, die ein gregorianisches Kalenderdatum im Format jjjj-mm-tt darstellt.
Das Datum kann in seiner Binärdarstellung geschrieben werden, die man erhält, indem man Jahr, Monat und Tag in ihre Binärdarstellungen ohne führende Nullen umwandelt und sie im Jahr-Monat-Tag-Format aufschreibt.
Gibt die binäre Darstellung des Datums zurück.

Beispiel 1:

Eingabe: Datum = „2080-02-29“
Ausgabe: „100000100000-10-11101“
Erläuterung:
100000100000, 10 und 11101 sind die binären Darstellungen von 2080, 02 und 29.

Beispiel 2:

Eingabe: Datum = „1900-01-01“
Ausgabe: „11101101100-1-1“
Erläuterung:
11101101100, 1 und 1 sind die binären Darstellungen von 1900, 1 und 1.

Einschränkungen:

date.length == 10
date[4] == date[7] == '-', und alle anderen date[i]s sind Ziffern.
Die Eingabe wird so generiert, dass das Datum ein gültiges gregorianisches Kalenderdatum zwischen dem 1. Januar 1900 und dem 31. Dezember 2100 (beide einschließlich) darstellt.

Sie erhalten eine Datumszeichenfolge, die ein gregorianisches Kalenderdatum im Format jjjj-mm-tt darstellt.
Das Datum kann in seiner Binärdarstellung geschrieben werden, die man erhält, indem man Jahr, Monat und Tag in ihre Binärdarstellungen ohne führende Nullen umwandelt und sie im Jahr-Monat-Tag-Format aufschreibt.
Gibt die binäre Darstellung des Datums zurück.

Beispiel 1:

Eingabe: Datum = „2080.02.29.“
Ausgabe: „100000100000-10-11101“
Erläuterung:
100000100000, 10 und 11101 sind die binären Darstellungen von 2080, 02 bzw. 29.

Beispiel 2:

Eingabe: Datum = „1900.01.01.“
Ausgabe: „11101101100-1-1“
Erläuterung:
11101101100, 1 und 1 sind die binären Darstellungen von 1900, 1 bzw. 1.

Einschränkungen:

date.length == 10
date[4] == date[7] == '-', und alle anderen date[i]s sind Ziffern.
Die Eingabe wird so generiert, dass das Datum ein gültiges gregorianisches Kalenderdatum zwischen dem 1. Januar 1900 und dem 31. Dezember 2100 (beide einschließlich) darstellt.


Sie erhalten ein Array aus ganzen Zahlen start und eine ganze Zahl d, die n Intervalle [start[i], start[i] + d] darstellen.
Sie werden aufgefordert, n ganze Zahlen auszuwählen, wobei die i^te ganze Zahl zum i^ten Intervall gehören muss. Die Punktzahl der ausgewählten ganzen Zahlen ist definiert als die minimale absolute Differenz zwischen zwei beliebigen ausgewählten ganzen Zahlen.
Gibt die maximal mögliche Punktzahl der ausgewählten Ganzzahlen zurück.

Beispiel 1:

Eingabe: Start = [6,0,3], d = 2
Ausgabe: 4
Erläuterung:
Die maximal mögliche Punktzahl kann durch Auswahl der Ganzzahlen 8, 0 und 4 erreicht werden. Die Punktzahl dieser gewählten Ganzzahlen beträgt min(|8 - 0|, |8 - 4|, |0 - 4|), was 4 entspricht.

Beispiel 2:

Eingabe: Start = [2,6,13,13], d = 5
Ausgabe: 5
Erläuterung:
Die maximal mögliche Punktzahl kann durch Auswahl der ganzen Zahlen erhalten werden: 2, 7, 13 und 18. Die Punktzahl dieser ausgewählten ganzen Zahlen beträgt min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|), was 5 entspricht.

Einschränkungen:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Sie erhalten eine Reihe von ganzen Zahlen start und eine ganze Zahl d, die n Intervalle [start[i], start[i] + d] darstellen.
Sie werden gebeten, n ganze Zahlen auszuwählen, wobei die i^-te ganze Zahl zum i^-ten Intervall gehören muss. Die Punktzahl der gewählten Ganzzahlen ist definiert als die kleinste absolute Differenz zwischen zwei beliebigen Ganzzahlen, die gewählt wurden.
Geben Sie die maximal mögliche Punktzahl der gewählten ganzen Zahlen zurück.

Beispiel 1:

Eingabe: start = [6,0,3], d = 2
Ausgabe: 4
Erläuterung:
Die maximal mögliche Punktzahl erhält man durch die Wahl der ganzen Zahlen 8, 0 und 4. Die Punktzahl dieser gewählten ganzen Zahlen ist min(|8 - 0|, |8 - 4|, |0 - 4|), was gleich 4 ist.

Beispiel 2:

Eingabe: start = [2,6,13,13], d = 5
Ausgabe: 5
Erläuterung:
Die maximal mögliche Punktzahl erhält man, wenn man die ganzen Zahlen 2, 7, 13 und 18 wählt. Die Punktzahl dieser gewählten ganzen Zahlen ist min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|), was gleich 5 ist.

Randbedingungen:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Sie erhalten ein Array aus ganzen Zahlen start und eine ganze Zahl d, die n Intervalle [start[i], start[i] + d] darstellen.
Sie werden aufgefordert, n ganze Zahlen auszuwählen, wobei die i^te ganze Zahl zum i^ten Intervall gehören muss. Die Punktzahl der ausgewählten Ganzzahlen ist definiert als die minimale absolute Differenz zwischen zwei beliebigen ausgewählten Ganzzahlen.
Gibt die maximal mögliche Punktzahl der ausgewählten Ganzzahlen zurück.

Beispiel 1:

Eingabe: Start = [6,0,3], d = 2
Ausgabe: 4
Erläuterung:
Die maximal mögliche Punktzahl kann durch Auswahl der Ganzzahlen 8, 0 und 4 erreicht werden. Die Punktzahl dieser gewählten Ganzzahlen beträgt min(|8 - 0|, |8 - 4|, |0 - 4|), was 4 entspricht.

Beispiel 2:

Eingabe: Start = [2,6,13,13], d = 5
Ausgabe: 5
Erläuterung:
Die maximal mögliche Punktzahl kann durch Auswahl der ganzen Zahlen erhalten werden: 2, 7, 13 und 18. Die Punktzahl dieser ausgewählten ganzen Zahlen beträgt min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|), was 5 entspricht.

Einschränkungen:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9


Sie erhalten ein ganzzahliges Array nums der Länge n.
Ihr Ziel ist es, bei Index 0 zu beginnen und Index n - 1 zu erreichen. Sie können nur zu Indizes springen, die größer als Ihr aktueller Index sind.
Die Punktzahl für einen Sprung vom Index i zum Index j wird als (j – i) * nums[i] berechnet.
Geben Sie die maximal mögliche Gesamtpunktzahl bis zum Erreichen des letzten Index zurück.

Beispiel 1:

Eingabe: nums = [1,3,1,5]
Ausgabe: 7
Erläuterung:
Springen Sie zunächst zu Index 1 und dann zum letzten Index. Das Endergebnis ist 1 * 1 + 2 * 3 = 7.

Beispiel 2:

Eingabe: nums = [4,3,1,3,2]
Ausgabe: 16
Erläuterung:
Springen Sie direkt zum letzten Index. Das Endergebnis ist 4 * 4 = 16.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums der Länge n.
Ihr Ziel ist es, bei Index 0 zu beginnen und Index n - 1 zu erreichen. Sie können nur zu Indizes springen, die größer als Ihr aktueller Index sind.
Die Punktzahl für einen Sprung von Index i zu Index j wird wie folgt berechnet: (j - i) * nums[i].
Geben Sie die maximal mögliche Gesamtpunktzahl zurück, wenn Sie den letzten Index erreichen.

Beispiel 1:

Eingabe: nums = [1,3,1,5]
Ausgang: 7
Erklärung:
Springen Sie zuerst zum Index 1 und dann zum letzten Index. Das Endergebnis ist 1 * 1 + 2 * 3 = 7.

Beispiel 2:

Eingabe: nums = [4,3,1,3,2]
Ausgang: 16
Erklärung:
Springen Sie direkt zum letzten Index. Das Endergebnis ist 4 * 4 = 16.

Zwänge:

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


Es gibt ein 50 x 50 großes Schachbrett mit einem Springer und einigen Bauern darauf. Sie erhalten zwei Ganzzahlen kx und ky, wobei (kx, ky) die Position des Springers angibt, und ein 2D-Array positions, wobei positions[i] = [x_i, y_i] die Position der Bauern auf dem Schachbrett angibt.
Alice und Bob spielen ein rundenbasiertes Spiel, bei dem Alice zuerst spielt. Im Zug jedes Spielers:

Der Spieler wählt einen Bauern aus, der noch auf dem Brett steht, und schlägt ihn mit dem Springer in möglichst wenigen Zügen. Beachten Sie, dass der Spieler einen beliebigen Bauern auswählen kann. Möglicherweise handelt es sich jedoch nicht um einen, der in der geringsten Anzahl von Zügen geschlagen werden kann.
Beim Schlagen des ausgewählten Bauern kann der Springer andere Bauern weitergeben, ohne sie zu schlagen. In diesem Zug kann nur der ausgewählte Bauer geschlagen werden.

Alice versucht, die Summe der Züge beider Spieler zu maximieren, bis keine Bauern mehr auf dem Brett sind, während Bob versucht, sie zu minimieren.
Gibt die maximale Gesamtzahl der während des Spiels gemachten Züge zurück, die Alice erreichen kann, vorausgesetzt, dass beide Spieler optimal spielen.
Beachten Sie, dass ein Schachspringer in einem Zug acht mögliche Positionen hat, zu denen er ziehen kann, wie unten dargestellt. Jede Bewegung besteht aus zwei Zellen in einer Himmelsrichtung und dann einer Zelle in einer orthogonalen Richtung.

Beispiel 1:

Eingabe: kx = 1, ky = 1, Positionen = [[0,0]]
Ausgabe: 4
Erläuterung:

Der Springer benötigt 4 Züge, um den Bauern bei (0, 0) zu erreichen.

Beispiel 2:

Eingabe: kx = 0, ky = 2, Positionen = [[1,1],[2,2],[3,3]]
Ausgabe: 8
Erläuterung:

Alice wählt den Bauern bei (2, 2) und schlägt ihn in zwei Zügen: (0, 2) -> (1, 4) -> (2, 2).
Bob wählt den Bauern bei (3, 3) und schlägt ihn in zwei Zügen: (2, 2) -> (4, 1) -> (3, 3).
Alice wählt den Bauern bei (1, 1) und schlägt ihn in vier Zügen: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1) .

Beispiel 3:

Eingabe: kx = 0, ky = 0, Positionen = [[1,2],[2,4]]
Ausgabe: 3
Erläuterung:

Alice wählt den Bauern bei (2, 4) und schlägt ihn in zwei Zügen: (0, 0) -> (1, 2) -> (2, 4). Beachten Sie, dass der Bauer bei (1, 2) nicht geschlagen wird.
Bob wählt den Bauern bei (1, 2) und schlägt ihn in einem Zug: (2, 4) -> (1, 2).

Einschränkungen:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positionen[i].length == 2
0 <= Positionen[i][0], Positionen[i][1] <= 49
Alle Positionen[i] sind eindeutig.
Die Eingabe wird so generiert, dass positions[i] != [kx, ky] für alle 0 <= i < positions.length gilt.

Es gibt ein 50 x 50 großes Schachbrett mit einem Springer und einigen Bauern darauf. Sie erhalten zwei Ganzzahlen kx und ky, wobei (kx, ky) die Position des Springers angibt, und ein 2D-Array positions, wobei positions[i] = [x_i, y_i] die Position der Bauern auf dem Schachbrett angibt.
Alice und Bob spielen ein rundenbasiertes Spiel, bei dem Alice zuerst spielt. Im Zug jedes Spielers:

Der Spieler wählt einen Bauern aus, der noch auf dem Brett steht, und schlägt ihn mit dem Springer in möglichst wenigen Zügen. Beachten Sie, dass der Spieler einen beliebigen Bauern auswählen kann. Möglicherweise handelt es sich jedoch nicht um einen, der in der geringsten Anzahl von Zügen geschlagen werden kann.
Beim Schlagen des ausgewählten Bauern kann der Springer andere Bauern weitergeben, ohne sie zu schlagen. In diesem Zug kann nur der ausgewählte Bauer geschlagen werden.

Alice versucht, die Summe der Züge beider Spieler zu maximieren, bis keine Bauern mehr auf dem Brett sind, während Bob versucht, sie zu minimieren.
Gibt die maximale Gesamtzahl der während des Spiels ausgeführten Züge zurück, die Alice erreichen kann, vorausgesetzt, dass beide Spieler optimal spielen.
Beachten Sie, dass ein Schachspringer in einem Zug acht mögliche Positionen hat, zu denen er ziehen kann, wie unten dargestellt. Jede Bewegung besteht aus zwei Zellen in einer Himmelsrichtung und dann einer Zelle in einer orthogonalen Richtung.

Beispiel 1:

Eingabe: kx = 1, ky = 1, Positionen = [[0,0]]
Ausgabe: 4
Erläuterung:

Der Springer benötigt 4 Züge, um den Bauern bei (0, 0) zu erreichen.

Beispiel 2:

Eingabe: kx = 0, ky = 2, Positionen = [[1,1],[2,2],[3,3]]
Ausgabe: 8
Erläuterung:

Alice wählt den Bauern bei (2, 2) und schlägt ihn in zwei Zügen: (0, 2) -> (1, 4) -> (2, 2).
Bob wählt den Bauern bei (3, 3) und schlägt ihn in zwei Zügen: (2, 2) -> (4, 1) -> (3, 3).
Alice wählt den Bauern bei (1, 1) und schlägt ihn in vier Zügen: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1) .

Beispiel 3:

Eingabe: kx = 0, ky = 0, Positionen = [[1,2],[2,4]]
Ausgabe: 3
Erläuterung:

Alice wählt den Bauern bei (2, 4) und schlägt ihn in zwei Zügen: (0, 0) -> (1, 2) -> (2, 4). Beachten Sie, dass der Bauer bei (1, 2) nicht geschlagen wird.
Bob wählt den Bauern bei (1, 2) und schlägt ihn in einem Zug: (2, 4) -> (1, 2).

Einschränkungen:

0 <= kx, ky <= 49
1 <= positionen.länge <= 15
positionen[i].length == 2
0 <= Positionen[i][0], Positionen[i][1] <= 49
Alle Positionen[i] sind eindeutig.
Die Eingabe wird so generiert, dass positions[i] != [kx, ky] für alle 0 <= i < positions.length gilt.

Es gibt ein 50 x 50 großes Schachbrett mit einem Springer und einigen Bauern darauf. Sie erhalten zwei Ganzzahlen kx und ky, wobei (kx, ky) die Position des Springers angibt, und ein 2D-Array positions, wobei positions[i] = [x_i, y_i] die Position der Bauern auf dem Schachbrett angibt.
Alice und Bob spielen ein rundenbasiertes Spiel, bei dem Alice zuerst spielt. Im Zug jedes Spielers:

Der Spieler wählt einen Bauern aus, der noch auf dem Brett steht, und schlägt ihn mit dem Springer in möglichst wenigen Zügen. Beachten Sie, dass der Spieler einen beliebigen Bauern auswählen kann. Möglicherweise handelt es sich jedoch nicht um einen, der in der geringsten Anzahl von Zügen geschlagen werden kann.
Beim Schlagen des ausgewählten Bauern kann der Springer andere Bauern weitergeben, ohne sie zu schlagen. In diesem Zug kann nur der ausgewählte Bauer geschlagen werden.

Alice versucht, die Summe der Züge beider Spieler zu maximieren, bis keine Bauern mehr auf dem Brett sind, während Bob versucht, sie zu minimieren.
Gibt die maximale Gesamtzahl der während des Spiels gemachten Züge zurück, die Alice erreichen kann, vorausgesetzt, dass beide Spieler optimal spielen.
Beachten Sie, dass ein Schachspringer in einem Zug acht mögliche Positionen hat, zu denen er ziehen kann, wie unten dargestellt. Jede Bewegung besteht aus zwei Zellen in einer Himmelsrichtung und dann einer Zelle in einer orthogonalen Richtung.

Beispiel 1:

Eingabe: kx = 1, ky = 1, Positionen = [[0,0]]
Ausgabe: 4
Erläuterung:

Der Springer benötigt 4 Züge, um den Bauern bei (0, 0) zu erreichen.

Beispiel 2:

Eingabe: kx = 0, ky = 2, Positionen = [[1,1],[2,2],[3,3]]
Ausgabe: 8
Erläuterung:

Alice wählt den Bauern bei (2, 2) und schlägt ihn in zwei Zügen: (0, 2) -> (1, 4) -> (2, 2).
Bob wählt den Bauern bei (3, 3) und schlägt ihn in zwei Zügen: (2, 2) -> (4, 1) -> (3, 3).
Alice wählt den Bauern bei (1, 1) und schlägt ihn in vier Zügen: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1) .

Beispiel 3:

Eingabe: kx = 0, ky = 0, Positionen = [[1,2],[2,4]]
Ausgabe: 3
Erläuterung:

Alice wählt den Bauern bei (2, 4) und schlägt ihn in zwei Zügen: (0, 0) -> (1, 2) -> (2, 4). Beachten Sie, dass der Bauer bei (1, 2) nicht geschlagen wird.
Bob wählt den Bauern bei (1, 2) und schlägt ihn in einem Zug: (2, 4) -> (1, 2).

Einschränkungen:

0 <= kx, ky <= 49
1 <= positionen.länge <= 15
positionen[i].length == 2
0 <= Positionen[i][0], Positionen[i][1] <= 49
Alle Positionen[i] sind eindeutig.
Die Eingabe wird so generiert, dass positions[i] != [kx, ky] für alle 0 <= i < positions.length gilt.


Sie erhalten ein ganzzahliges Array a der Größe 4 und ein weiteres ganzzahliges Array b der Größe mindestens 4.
Sie müssen 4 Indizes i_0, i_1, i_2 und i_3 aus dem Array b auswählen, sodass i_0 < i_1 < i_2 < i_3 gilt. Ihre Punktzahl entspricht dem Wert a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Geben Sie die maximale Punktzahl zurück, die Sie erreichen können.

Beispiel 1:

Eingabe: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Ausgabe: 26
Erläuterung:
Wir können die Indizes 0, 1, 2 und 5 wählen. Die Punktzahl beträgt 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Beispiel 2:

Eingabe: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Ausgabe: -1
Erläuterung:
Wir können die Indizes 0, 1, 3 und 4 wählen. Die Punktzahl beträgt (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4 ) = -1.

Einschränkungen:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Sie erhalten ein Ganzzahlarray A von Größe 4 und ein weiteres Ganzzahl -Array B von mindestens 4.
Sie müssen 4 Indizes i_0, i_1, i_2 und i_3 aus dem Array B auswählen, so dass i_0 <i_1 <i_2 <i_3. Ihre Punktzahl entspricht dem Wert a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Geben Sie die maximale Punktzahl zurück, die Sie erzielen können.

Beispiel 1:

Eingabe: a = [3,2,5,6], b = [2, -6,4, -5, -3,2, -7]
Ausgabe: 26
Erläuterung:
Wir können die Indizes 0, 1, 2 und 5 auswählen. Die Punktzahl beträgt 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.

Beispiel 2:

Eingabe: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Ausgabe: -1
Erläuterung:
Wir können die Indizes 0, 1, 3 und 4 auswählen. Die Punktzahl lautet (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) ) = -1.

Einschränkungen:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5


Sie erhalten eine Reihe von Strings und ein Zielstring.
Eine Zeichenfolge x wird als gültig bezeichnet, wenn x ein Präfix einer Zeichenfolge in Wörtern ist.
Geben Sie die minimale Anzahl gültiger Zeichenfolgen zurück, die zum Ziel zusammengefügt werden können. Wenn es nicht möglich ist, ein Ziel zu bilden, geben Sie -1 zurück.

Beispiel 1:

Eingabe: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Ausgabe: 3
Erläuterung:
Die Zielzeichenfolge kann durch Verkettung gebildet werden:

Präfix der Länge 2 von Wörtern [1], d.h. "aa".
Präfix der Länge 3 von Wörtern[2], d.h. "bcd".
Präfix der Länge 3 von Wörtern[0], d.h. "abc".

Beispiel 2:

Eingabe: words = ["abababab","ab"], target = "ababaababa"
Ausgabe: 2
Erläuterung:
Die Zielzeichenfolge kann durch Verkettung gebildet werden:

Präfix der Länge 5 der Wörter [0], d.h. "ababa".
Präfix der Länge 5 der Wörter [0], d.h. "ababa".

Beispiel 3:

Eingabe: words = ["abcdef"], target = "xyz"
Ausgabe: -1

Einschränkungen:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
Die Eingabe wird so generiert, dass sum(words[i].length) <= 10^5.
Wörter[i] besteht nur aus englischen Kleinbuchstaben.
1 <= target.length <= 5 * 10^3
Ziel besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein Array von Zeichenfolgenwörtern und ein Zeichenfolgenziel.
Eine Zeichenfolge x heißt gültig, wenn x ein Präfix einer beliebigen Zeichenfolge in Wörtern ist.
Gibt die Mindestanzahl gültiger Zeichenfolgen zurück, die zu einem Ziel verkettet werden können. Wenn es nicht möglich ist, ein Ziel zu bilden, geben Sie -1 zurück.

Beispiel 1:

Eingabe: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Ausgabe: 3
Erläuterung:
Die Zielzeichenfolge kann durch Verketten gebildet werden:

Präfix der Länge 2 von words[1], also „aa“.
Präfix der Länge 3 von words[2], also „bcd“.
Präfix der Länge 3 von words[0], also „ABC“.

Beispiel 2:

Eingabe: words= ["abababab", "ab"], Ziel = "ababaababa"
Ausgabe: 2
Erläuterung:
Die Zielzeichenfolge kann durch Verketten gebildet werden:

Präfix der Länge 5 von words[0], also „ababa“.
Präfix der Länge 5 von words[0], also „ababa“.

Beispiel 3:

Eingabe: words = ["abcdef"], Ziel = "xyz"
Ausgabe: -1

Einschränkungen:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
Die Eingabe wird so generiert, dass sum(words[i].length) <= 10^5 ist.
words[i] besteht nur aus englischen Kleinbuchstaben.
1 <= target.length <= 5 * 10^3
target besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein Array von Zeichenfolgenwörtern und ein Zeichenfolgenziel.
Eine Zeichenfolge x heißt gültig, wenn x ein Präfix einer beliebigen Zeichenfolge in Wörtern ist.
Gibt die Mindestanzahl gültiger Zeichenfolgen zurück, die zu einem Ziel verkettet werden können. Wenn es nicht möglich ist, ein Ziel zu bilden, geben Sie -1 zurück.

Beispiel 1:

Eingabe: Wörter = ["abc", "aaaaa", "bcdef"], Ziel = "aabcdabc"
Ausgabe: 3
Erläuterung:
Die Zielzeichenfolge kann durch Verketten gebildet werden:

Präfix der Länge 2 von Wörtern[1], also „aa“.
Präfix der Länge 3 von Wörtern[2], also „bcd“.
Präfix der Länge 3 von Wörtern[0], also „abc“.

Beispiel 2:

Eingabe: Wörter = ["abababab", "ab"], Ziel = "ababaababa"
Ausgabe: 2
Erläuterung:
Die Zielzeichenfolge kann durch Verketten gebildet werden:

Präfix der Länge 5 von Wörtern[0], also „ababa“.
Präfix der Länge 5 von Wörtern[0], also „ababa“.

Beispiel 3:

Eingabe: Wörter = ["abcdef"], Ziel = "xyz"
Ausgabe: -1

Einschränkungen:

1 <= Wörter.Länge <= 100
1 <= Wörter[i].Länge <= 5 * 10^3
Die Eingabe wird so generiert, dass sum(words[i].length) <= 10^5 ist.
„words[i]“ besteht nur aus englischen Kleinbuchstaben.
1 <= Ziellänge <= 5 * 10^3
target besteht nur aus englischen Kleinbuchstaben.


Sie erhalten ein Array von ganzen Zahlen der Länge n und einer positiven ganzen Zahl k.
Die Leistung eines Arrays ist definiert als:

Das maximale Element, wenn alle Elemente aufeinanderfolgend und in aufsteigender Reihenfolge sortiert sind.
-1 andernfalls.

Sie müssen die Potenz aller Subarrays von Zahlen der Größe k ermitteln.
Gibt ein ganzzahliges Array results der Größe n - k + 1 zurück, wobei results[i] die Potenz von nums[i..(i + k - 1)] ist.

Beispiel 1:

Eingabe: nums = [1,2,3,4,3,2,5], k = 3
Ausgang: [3,4,-1,-1,-1]
Erklärung:
Es gibt 5 Subarrays von Zahlen der Größe 3:

[1, 2, 3] mit dem maximalen Element 3.
[2, 3, 4] mit dem maximalen Element 4.
[3, 4, 3] deren Elemente nicht aufeinanderfolgend sind.
[4, 3, 2], deren Elemente nicht sortiert sind.
[3, 2, 5], deren Elemente nicht aufeinanderfolgend sind.

Beispiel 2:

Eingabe: nums = [2,2,2,2,2], k = 4
Ausgang: [-1,-1]

Beispiel 3:

Eingabe: nums = [3,2,3,2,3,2], k = 2
Ausgang: [-1,3,-1,3,-1]

Zwänge:

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

Sie erhalten ein Array von ganzen Zahlen der Länge n und einer positiven ganzen Zahl k.
Die Leistung eines Arrays ist definiert als:

Sein maximales Element, wenn alle seine Elemente aufeinanderfolgend und in aufsteigender Reihenfolge sortiert sind.
-1 sonst.

Sie müssen die Potenz aller Subarrays von Zahlen der Größe k ermitteln.
Gibt ein ganzzahliges Array mit Ergebnissen der Größe n - k + 1 zurück, wobei Ergebnisse[i] die Potenz von nums[i..(i + k - 1)] ist.

Beispiel 1:

Eingabe: Zahlen = [1,2,3,4,3,2,5], k = 3
Ausgabe: [3,4,-1,-1,-1]
Erläuterung:
Es gibt 5 Unterarrays mit Zahlen der Größe 3:

[1, 2, 3] mit dem maximalen Element 3.
[2, 3, 4] mit dem maximalen Element 4.
[3, 4, 3], deren Elemente nicht aufeinanderfolgend sind.
[4, 3, 2], deren Elemente nicht sortiert sind.
[3, 2, 5], deren Elemente nicht aufeinanderfolgend sind.

Beispiel 2:

Eingabe: Zahlen = [2,2,2,2,2], k = 4
Ausgabe: [-1,-1]

Beispiel 3:

Eingabe: nums = [3,2,3,2,3,2], k = 2
Ausgabe: [-1,3,-1,3,-1]

Einschränkungen:

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


Sie erhalten ein m x n 2D-Array, das ein Schachbrett darstellt, wobei board[i][j] den Wert der Zelle (i, j) repräsentiert.
Türme in derselben Zeile oder Spalte greifen sich gegenseitig an. Sie müssen drei Türme so auf dem Schachbrett platzieren, dass sich die Türme nicht gegenseitig angreifen.
Geben Sie die maximale Summe der Zellenwerte zurück, auf denen die Türme platziert sind.

Beispiel 1:

Eingabe: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Ausgabe: 4
Erläuterung:

Wir können die Türme auf den Feldern (0, 2), (1, 3) und (2, 1) platzieren, so dass die Summe 1 + 1 + 2 = 4 beträgt.

Beispiel 2:

Eingabe: board = [[1,2,3],[4,5,6],[7,8,9]]
Ausgabe: 15
Erläuterung:
Wir können die Türme auf den Feldern (0, 0), (1, 1) und (2, 2) platzieren, so dass die Summe 1 + 5 + 9 = 15 beträgt.

Beispiel 3:

Eingabe: board = [[1,1,1],[1,1,1],[1,1,1]]
Ausgabe: 3
Erläuterung:
Wir können die Türme auf den Feldern (0, 2), (1, 1) und (2, 0) platzieren, so dass die Summe 1 + 1 + 1 = 3 beträgt.

Randbedingungen:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

Sie erhalten ein m x n 2D-Array-Board, das ein Schachbrett darstellt, wobei board[i][j] den Wert der Zelle (i, j) darstellt.
Türme in derselben Reihe oder Spalte greifen sich gegenseitig an. Sie müssen drei Türme so auf dem Schachbrett platzieren, dass die Türme sich nicht gegenseitig angreifen.
Gibt die maximale Summe der Zellenwerte zurück, auf denen die Türme platziert sind.

Beispiel 1:

Eingabe: Board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Ausgabe: 4
Erläuterung:

Wir können die Türme in den Zellen (0, 2), (1, 3) und (2, 1) platzieren, für eine Summe von 1 + 1 + 2 = 4.

Beispiel 2:

Eingabe: Board = [[1,2,3],[4,5,6],[7,8,9]]
Ausgabe: 15
Erläuterung:
Wir können die Türme in den Zellen (0, 0), (1, 1) und (2, 2) platzieren, für eine Summe von 1 + 5 + 9 = 15.

Beispiel 3:

Eingabe: Board = [[1,1,1],[1,1,1],[1,1,1]]
Ausgabe: 3
Erläuterung:
Wir können die Türme in den Zellen (0, 2), (1, 1) und (2, 0) platzieren, für eine Summe von 1 + 1 + 1 = 3.

Einschränkungen:

3 <= m == Board.length <= 100
3 <= n == Brett[i].length <= 100
-10^9 <= Board[i][j] <= 10^9

Sie erhalten ein m x n 2D-Array-Board, das ein Schachbrett darstellt, wobei board[i][j] den Wert der Zelle (i, j) darstellt.
Türme in derselben Reihe oder Spalte greifen sich gegenseitig an. Sie müssen drei Türme so auf dem Schachbrett platzieren, dass die Türme sich nicht gegenseitig angreifen.
Gibt die maximale Summe der Zellenwerte zurück, auf denen die Türme platziert sind.

Beispiel 1:

Eingabe: Board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Ausgabe: 4
Erläuterung:

Wir können die Türme in den Zellen (0, 2), (1, 3) und (2, 1) platzieren, für eine Summe von 1 + 1 + 2 = 4.

Beispiel 2:

Eingabe: Brett = [[1,2,3],[4,5,6],[7,8,9]]
Ausgabe: 15
Erläuterung:
Wir können die Türme in den Zellen (0, 0), (1, 1) und (2, 2) platzieren, für eine Summe von 1 + 5 + 9 = 15.

Beispiel 3:

Eingabe: Board = [[1,1,1],[1,1,1],[1,1,1]]
Ausgabe: 3
Erläuterung:
Wir können die Türme in den Zellen (0, 2), (1, 1) und (2, 0) platzieren, für eine Summe von 1 + 1 + 1 = 3.

Einschränkungen:

3 <= m == Brett.länge <= 100
3 <= n == board[i].length <= 100
-10^9 <= Board[i][j] <= 10^9


Sie erhalten drei positive ganze Zahlen num1, num2 und num3.
Der Schlüssel von num1, num2 und num3 ist als vierstellige Zahl definiert, sodass:

Wenn eine Zahl weniger als vier Ziffern hat, wird sie zunächst mit führenden Nullen aufgefüllt.
Die i^te Ziffer (1 <= i <= 4) des Schlüssels wird generiert, indem die kleinste Ziffer unter den i^ten Ziffern von num1, num2 und num3 genommen wird.

Gibt den Schlüssel der drei Zahlen ohne führende Nullen (falls vorhanden) zurück.

Beispiel 1:

Eingabe: num1 = 1, num2 = 10, num3 = 1000
Ausgabe: 0
Erläuterung:
Beim Auffüllen wird Nummer1 zu „0001“, Nummer2 zu „0010“ und Nummer3 bleibt „1000“.

Die 1. Ziffer des Schlüssels ist min(0, 0, 1).
Die 2. Ziffer des Schlüssels ist min(0, 0, 0).
Die 3. Ziffer des Schlüssels ist min(0, 1, 0).
Die 4. Stelle des Schlüssels ist min(1, 0, 0).

Daher ist der Schlüssel „0000“, also 0.

Beispiel 2:

Eingabe: num1 = 987, num2 = 879, num3 = 798
Ausgabe: 777

Beispiel 3:

Eingabe: num1 = 1, num2 = 2, num3 = 3
Ausgabe: 1

Einschränkungen:

1 <= num1, num2, num3 <= 9999

Sie erhalten drei positive Ganzzahlen num1, num2 und num3.
Der Schlüssel von num1, num2 und num3 ist als vierstellige Zahl definiert, sodass:

Wenn eine Zahl weniger als vier Ziffern hat, wird sie zunächst mit führenden Nullen aufgefüllt.
Die i^te Ziffer (1 <= i <= 4) des Schlüssels wird generiert, indem die kleinste Ziffer unter den i^ten Ziffern von num1, num2 und num3 genommen wird.

Gibt den Schlüssel der drei Zahlen ohne führende Nullen (falls vorhanden) zurück.

Beispiel 1:

Eingabe: num1 = 1, num2 = 10, num3 = 1000
Ausgabe: 0
Erläuterung:
Beim Auffüllen wird Nummer1 zu „0001“, Nummer2 zu „0010“ und Nummer3 bleibt „1000“.

Die 1. Ziffer des Schlüssels ist min(0, 0, 1).
Die 2. Ziffer des Schlüssels ist min(0, 0, 0).
Die 3. Ziffer des Schlüssels ist min(0, 1, 0).
Die 4. Stelle des Schlüssels ist min(1, 0, 0).

Daher ist der Schlüssel „0000“, also 0.

Beispiel 2:

Eingabe: Nummer1 = 987, Nummer2 = 879, Nummer3 = 798
Ausgabe: 777

Beispiel 3:

Eingabe: num1 = 1, num2 = 2, num3 = 3
Ausgabe: 1

Einschränkungen:

1 <= num1, num2, num3 <= 9999

Sie erhalten drei positive ganze Zahlen num1, num2 und num3.
Der Schlüssel von num1, num2 und num3 ist als vierstellige Zahl definiert, sodass:

Wenn eine Zahl weniger als vier Ziffern hat, wird sie zunächst mit führenden Nullen aufgefüllt.
Die i^te Ziffer (1 <= i <= 4) des Schlüssels wird generiert, indem die kleinste Ziffer unter den i^ten Ziffern von num1, num2 und num3 genommen wird.

Gibt den Schlüssel der drei Zahlen ohne führende Nullen (falls vorhanden) zurück.

Beispiel 1:

Eingabe: num1 = 1, num2 = 10, num3 = 1000
Ausgabe: 0
Erläuterung:
Beim Auffüllen wird Nummer1 zu „0001“, Nummer2 zu „0010“ und Nummer3 bleibt „1000“.

Die 1. Ziffer des Schlüssels ist min(0, 0, 1).
Die 2. Ziffer des Schlüssels ist min(0, 0, 0).
Die 3. Ziffer des Schlüssels ist min(0, 1, 0).
Die 4. Stelle des Schlüssels ist min(1, 0, 0).

Daher ist der Schlüssel „0000“, also 0.

Beispiel 2:

Eingabe: Nummer1 = 987, Nummer2 = 879, Nummer3 = 798
Ausgabe: 777

Beispiel 3:

Eingabe: num1 = 1, num2 = 2, num3 = 3
Ausgabe: 1

Einschränkungen:

1 <= num1, num2, num3 <= 9999


Sie erhalten eine Zeichenfolge s der Länge n und eine Ganzzahl k, wobei n ein Vielfaches von k ist. Ihre Aufgabe besteht darin, die Zeichenfolge s in eine neue Zeichenfolge namens result zu hashen, die eine Länge von n / k hat.
Teilen Sie zunächst s in n / k Teilzeichenfolgen mit einer Länge von jeweils k auf. Initialisieren Sie das Ergebnis dann als leere Zeichenfolge.
Für jeden Teilstring in der Reihenfolge von Anfang an:

Der Hashwert eines Zeichens ist der Index dieses Zeichens im englischen Alphabet (z. B. „a“ → 0, „b“ → 1, ..., „z“ → 25).
Berechnen Sie die Summe aller Hashwerte der Zeichen im Teilstring.
Ermitteln Sie den Rest dieser Summe, wenn Sie ihn durch 26 dividieren. Dies wird als hashedChar bezeichnet.
Identifizieren Sie das Zeichen im englischen Kleinbuchstabenalphabet, das hashedChar entspricht.
Hängen Sie dieses Zeichen an das Ende des Ergebnisses an.

Ergebnis zurückgeben.

Beispiel 1:

Eingabe: s = „abcd“, k = 2
Ausgabe: „bf“
Erläuterung:
Erster Teilstring: „ab“, 0 + 1 = 1, 1 % 26 = 1, result[0] = „b“.
Zweiter Teilstring: „cd“, 2 + 3 = 5, 5 % 26 = 5, result[1] = „f“.

Beispiel 2:

Eingabe: s = „mxz“, k = 3
Ausgabe: „i“
Erläuterung:
Der einzige Teilstring: „mxz“, 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = „i“.

Einschränkungen:

1 <= k <= 100
k <= s.length <= 1000
s.length ist durch k teilbar.
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenkette s der Länge n und eine ganze Zahl k, wobei n ein Vielfaches von k ist. Ihre Aufgabe ist es, die Zeichenkette s in eine neue Zeichenkette namens Ergebnis zu hashen, die eine Länge von n / k hat.
Teilen Sie zunächst s in n / k Teilstrings, jeder mit einer Länge von k. Initialisieren Sie dann Ergebnis als leere Zeichenkette.
Für jede Teilzeichenkette in der Reihenfolge von Anfang an:

Der Hash-Wert eines Zeichens ist der Index dieses Zeichens im englischen Alphabet (z. B.'a' → 0, 'b' → 1, ..., 'z' → 25).
Berechnen Sie die Summe der Hash-Werte in der Teilzeichenkette.
Ermitteln Sie den Rest dieser Summe, geteilt durch 26, der als hashedChar bezeichnet wird.
Identifizieren Sie das Zeichen im englischen Kleinbuchstabenalphabet, das hashedChar entspricht.
Hängen Sie dieses Zeichen an das Ende von Ergebnis an.

Geben Sie das Ergebnis zurück.

Beispiel 1:

Eingabe: s = "abcd", k = 2
Ausgabe: „bf“
Erklärung:
Erster Teilstring: „ab“, 0 + 1 = 1, 1 % 26 = 1, Ergebnis[0] = 'b'.
Zweite Teilzeichenkette: „cd“, 2 + 3 = 5, 5 % 26 = 5, Ergebnis[1] = 'f'.

Beispiel 2:

Eingabe: s = "mxz", k = 3
Ausgabe: „i“
Erklärung:
Die einzige Teilzeichenkette: „mxz“, 12 + 23 + 25 = 60, 60 % 26 = 8, Ergebnis[0] = 'i'.

Beschränkungen:

1 <= k <= 100
k <= s.length <= 1000
s.length ist durch k teilbar.
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenfolge s der Länge n und eine Ganzzahl k, wobei n ein Vielfaches von k ist. Ihre Aufgabe besteht darin, die Zeichenfolge s in eine neue Zeichenfolge namens result zu hashen, die eine Länge von n / k hat.
Teilen Sie zunächst s in n / k Teilzeichenfolgen mit einer Länge von jeweils k auf. Initialisieren Sie das Ergebnis dann als leere Zeichenfolge.
Für jeden Teilstring in der Reihenfolge von Anfang an:

Der Hashwert eines Zeichens ist der Index dieses Zeichens im englischen Alphabet (z. B. „a“ → 0, „b“ → 1, ..., „z“ → 25).
Berechnen Sie die Summe aller Hashwerte der Zeichen im Teilstring.
Ermitteln Sie den Rest dieser Summe, wenn Sie ihn durch 26 dividieren. Dies wird als hashedChar bezeichnet.
Identifizieren Sie das Zeichen im englischen Kleinbuchstaben, das hashedChar entspricht.
Hängen Sie dieses Zeichen an das Ende des Ergebnisses an.

Ergebnis zurückgeben.

Beispiel 1:

Eingabe: s = „abcd“, k = 2
Ausgabe: „bf“
Erläuterung:
Erster Teilstring: „ab“, 0 + 1 = 1, 1 % 26 = 1, result[0] = „b“.
Zweiter Teilstring: „cd“, 2 + 3 = 5, 5 % 26 = 5, result[1] = „f“.

Beispiel 2:

Eingabe: s = „mxz“, k = 3
Ausgabe: „i“
Erläuterung:
Der einzige Teilstring: „mxz“, 12 + 23 + 25 = 60, 60 % 26 = 8, result[0] = „i“.

Einschränkungen:

1 <= k <= 100
k <= s.length <= 1000
s.length ist durch k teilbar.
s besteht nur aus englischen Kleinbuchstaben.


Sie erhalten zwei positive ganze Zahlen n und k.
Eine ganze Zahl x heißt k-palindromisch, wenn:

x ist ein Palindrom.
x ist durch k teilbar.

Eine ganze Zahl heißt gut, wenn ihre Ziffern so umgeordnet werden können, dass sie eine k-palindromische ganze Zahl bilden. Beispielsweise kann für k = 2 2020 neu angeordnet werden, um die k-palindromische Ganzzahl 2002 zu bilden, wohingegen 1010 nicht neu angeordnet werden kann, um eine k-palindromische Ganzzahl zu bilden.
Gibt die Anzahl guter Ganzzahlen mit n Ziffern zurück.
Beachten Sie, dass jede Ganzzahl keine führenden Nullen haben darf, weder vor noch nach der Neuanordnung. Beispielsweise kann 1010 nicht in 101 umgewandelt werden.

Beispiel 1:

Eingabe: n = 3, k = 5
Ausgabe: 27
Erläuterung:
Einige der guten ganzen Zahlen sind:

551, weil es zu 515 umgeordnet werden kann.
525, weil es bereits k-palindromisch ist.

Beispiel 2:

Eingabe: n = 1, k = 4
Ausgabe: 2
Erläuterung:
Die beiden guten ganzen Zahlen sind 4 und 8.

Beispiel 3:

Eingabe: n = 5, k = 6
Ausgabe: 2468

Einschränkungen:

1 <= n <= 10
1 <= k <= 9

Sie erhalten zwei positive Ganzzahlen n und k.
Eine Ganzzahl x wird K-Palindrom genannt, wenn:

x ist ein Palindrom.
x ist teilbar durch k.

Eine Ganzzahl wird als gut bezeichnet, wenn seine Ziffern neu angeordnet werden können, um eine k-palindromische Ganzzahl zu bilden. Zum Beispiel kann 2020 für k = 2 neu angeordnet werden, um die k-palindromische Ganzzahl 2002 zu bilden, während 1010 nicht neu ordnet werden kann, um eine K-Palindrom-Ganzzahl zu bilden.
Geben Sie die Anzahl guter Ganzzahlen zurück, die N -Ziffern enthalten.
Beachten Sie, dass eine Ganzzahl weder vor noch nach der Neuordnung führende Nullen haben darf. Beispielsweise kann 1010 nicht so umgeordnet werden, um 101 zu bilden.

Beispiel 1:

Eingabe: n = 3, k = 5
Ausgabe: 27
Erläuterung:
Einige der guten Ganzzahlen sind:

551, weil es mit 515 neu angeordnet werden kann.
525 weil es bereits K-Palindrom ist.

Beispiel 2:

Eingabe: n = 1, k = 4
Ausgabe: 2
Erläuterung:
Die beiden guten Ganzzahlen sind 4 und 8.

Beispiel 3:

Eingabe: n = 5, k = 6
Ausgabe: 2468

Einschränkungen:

1 <= n <= 10
1 <= k <= 9


Sie erhalten eine ganzzahlige Potenz und zwei ganzzahlige Arrays für Schaden und Gesundheit, beide mit der Länge n.
Bob hat n Feinde, wobei der Feind i Bob Schaden[i] Schadenspunkte pro Sekunde zufügt, solange er am Leben ist (d. h. Gesundheit[i] > 0).
Jede Sekunde, nachdem die Feinde Bob Schaden zugefügt haben, wählt er einen der noch lebenden Feinde aus und fügt ihm Schadenspunkte zu.
Bestimmen Sie die Mindestgesamtmenge an Schadenspunkten, die Bob zugefügt wird, bevor alle n Feinde tot sind.

Beispiel 1:

Eingabe: Kraft = 4, Schaden = [1,2,3,4], Gesundheit = [4,5,6,8]
Ausgabe: 39
Erläuterung:

Greife Feind 3 in den ersten zwei Sekunden an, danach geht Feind 3 zu Boden. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 10 + 10 = 20 Punkte.
Greife in den nächsten zwei Sekunden Feind 2 an, woraufhin Feind 2 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 6 + 6 = 12 Punkte.
Greife Feind 0 in der nächsten Sekunde an, woraufhin Feind 0 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 3 Punkte.
Greife in den nächsten zwei Sekunden Feind 1 an, woraufhin Feind 1 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 2 + 2 = 4 Punkte.

Beispiel 2:

Eingabe: Kraft = 1, Schaden = [1,1,1,1], Gesundheit = [1,2,3,4]
Ausgabe: 20
Erläuterung:

Greife Feind 0 in der ersten Sekunde an, woraufhin Feind 0 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 4 Punkte.
Greife in den nächsten zwei Sekunden Feind 1 an, woraufhin Feind 1 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 3 + 3 = 6 Punkte.
Greife in den nächsten drei Sekunden Feind 2 an, woraufhin Feind 2 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 2 + 2 + 2 = 6 Punkte.
Greife Feind 3 in den nächsten vier Sekunden an, woraufhin Feind 3 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 1 + 1 + 1 + 1 = 4 Punkte.

Beispiel 3:

Eingabe: Kraft = 8, Schaden = [40], Gesundheit = [59]
Ausgabe: 320

Einschränkungen:

1 <= Leistung <= 10^4
1 <= n == Schaden.Länge == Gesundheit.Länge <= 10^5
1 <= Schaden[i], Gesundheit[i] <= 10^4

Sie erhalten eine ganzzahlige Kraft und zwei ganzzahlige Arrays für Schaden und Gesundheit, beide mit der Länge n.
Bob hat n Feinde, wobei der Feind i Bob Schaden[i] Schadenspunkte pro Sekunde zufügt, solange er am Leben ist (d. h. Gesundheit[i] > 0).
Jede Sekunde, nachdem die Feinde Bob Schaden zugefügt haben, wählt er einen der noch lebenden Feinde aus und fügt ihm Schadenspunkte zu.
Bestimmen Sie die minimale Gesamtzahl an Schadenspunkten, die Bob zugefügt werden, bevor alle n Feinde tot sind.

Beispiel 1:

Eingabe: Kraft = 4, Schaden = [1,2,3,4], Gesundheit = [4,5,6,8]
Ausgabe: 39
Erläuterung:

Greife Feind 3 in den ersten zwei Sekunden an, danach geht Feind 3 zu Boden. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 10 + 10 = 20 Punkte.
Greife in den nächsten zwei Sekunden Feind 2 an, woraufhin Feind 2 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 6 + 6 = 12 Punkte.
Greife Feind 0 in der nächsten Sekunde an, woraufhin Feind 0 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 3 Punkte.
Greife in den nächsten zwei Sekunden Feind 1 an, woraufhin Feind 1 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 2 + 2 = 4 Punkte.

Beispiel 2:

Eingabe: Kraft = 1, Schaden = [1,1,1,1], Gesundheit = [1,2,3,4]
Ausgabe: 20
Erläuterung:

Greife Feind 0 in der ersten Sekunde an, woraufhin Feind 0 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 4 Punkte.
Greife in den nächsten zwei Sekunden Feind 1 an, woraufhin Feind 1 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 3 + 3 = 6 Punkte.
Greife in den nächsten drei Sekunden Feind 2 an, woraufhin Feind 2 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 2 + 2 + 2 = 6 Punkte.
Greife Feind 3 in den nächsten vier Sekunden an, woraufhin Feind 3 zu Boden geht. Die Anzahl der Schadenspunkte, die Bob zugefügt werden, beträgt 1 + 1 + 1 + 1 = 4 Punkte.

Beispiel 3:

Eingabe: Kraft = 8, Schaden = [40], Gesundheit = [59]
Ausgabe: 320

Einschränkungen:

1 <= Kraft <= 10^4
1 <= n == Schaden.Länge == Gesundheit.Länge <= 10^5
1 <= Schaden[i], Gesundheit[i] <= 10^4

Sie erhalten eine Ganzzahl power und zwei Ganzzahl -Arrays Schäden und Gesundheit, beide mit Länge n.
Bob hat n Feinde, bei denen Feind i wird Bob damage[i] Schadenspunkte pro Sekunde zufügen, während sie am Leben sind (d. H. Gesundheit [i]> 0).
jede Sekunde, nachdem die Feinde Bob Schaden zugefügt haben, wählt er einen der Feinde, die noch leben, und fügt ihm power Schadenspunkte zu.
Bestimmen Sie die minimale Gesamtmenge an Schadenspunkten, die Bob zugefügt werden, bevor alle N -Feinde tot sind.

Beispiel 1:

Eingabe: power = 4, damage = [1,2,3,4], health = [4,5,6,8]
Ausgabe: 39
Erläuterung:

Angriff der Feind 3 In den ersten zwei Sekunden, woraufhin der Feind 3 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob mit 10 + 10 = 20 Punkten befasst sind.
Angriff der Feind 2 in den nächsten zwei Sekunden, wonach der Feind 2 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob befasst sind, 6 + 6 = 12 Punkte.
Angriff Feind 0 In der nächsten Sekunde, woraufhin der Feind 0 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob mitgeteilt werden, 3 Punkte.
Angriff der Feind 1 In den nächsten zwei Sekunden, woraufhin der Feind 1 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob mit 2 + 2 = 4 Punkten befasst sind.

Beispiel 2:

Eingabe: power = 1, damage = [1,1,1,1], health = [1,2,3,4]
Ausgabe: 20
Erläuterung:

Angriff der Feind 0 in der ersten Sekunde, woraufhin der Feind 0 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob erhoben werden, 4 Punkte.
Angriff der Feind 1 In den nächsten zwei Sekunden, wonach der Feind 1 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob mit 3 + 3 = 6 Punkten befasst sind.
Angriff der Feind 2 In den nächsten drei Sekunden, woraufhin der Feind 2 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob befasst sind, 2 + 2 + 2 = 6 Punkte.
Angriff der Feind 3 in den nächsten vier Sekunden, wonach der Feind 3 sinkt, beträgt die Anzahl der Schadenspunkte, die Bob erhoben werden, 1 + 1 + 1 + 1 = 4 Punkte.

Beispiel 3:

Eingabe: power = 8, damage = [40], health = [59]
Ausgabe: 320

Einschränkungen:

1 <= power <= 10^4
1 <= n == damage.length == health.length <= 10^5
1 <= damage[i], health[i] <= 10^4


Sie erhalten ein mxn-Binärmatrixgitter und eine ganzzahlige Gesundheit.
Sie beginnen in der oberen linken Ecke (0, 0) und möchten zur unteren rechten Ecke gelangen (m - 1, n - 1).
Sie können sich von einer Zelle nach oben, unten, links oder rechts zur nächsten benachbarten Zelle bewegen, solange Ihre Gesundheit positiv bleibt.
Zellen (i, j) mit Grid[i][j] = 1 gelten als unsicher und verringern Ihre Gesundheit um 1.
Geben Sie true zurück, wenn Sie die letzte Zelle mit einem Gesundheitswert von 1 oder mehr erreichen können, andernfalls false.

Beispiel 1:

Eingabe: Gitter = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], Gesundheit = 1
Ausgabe: wahr
Erläuterung:
Die letzte Zelle kann sicher erreicht werden, indem man die grauen Zellen unten entlang geht.

Beispiel 2:

Eingabe: Gitter = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0, 0,1,0,1,0]], Gesundheit = 3
Ausgabe: falsch
Erläuterung:
Um die letzte Zelle sicher zu erreichen, sind mindestens 4 Gesundheitspunkte erforderlich.

Beispiel 3:

Eingabe: Gitter = [[1,1,1],[1,0,1],[1,1,1]], Gesundheit = 5
Ausgabe: wahr
Erläuterung:
Die letzte Zelle kann sicher erreicht werden, indem man die grauen Zellen unten entlang geht.

Jeder Pfad, der nicht durch die Zelle (1, 1) führt, ist unsicher, da Ihre Gesundheit beim Erreichen der letzten Zelle auf 0 sinkt.

Einschränkungen:

m == Gitterlänge
n == Gitter[i].Länge
1 <= m, n <= 50
2 <= m * n
1 <= Gesundheit <= m + n
Grid[i][j] ist entweder 0 oder 1.

Sie erhalten ein mxn-Binärmatrixgitter und eine ganzzahlige Gesundheit.
Sie beginnen in der oberen linken Ecke (0, 0) und möchten zur unteren rechten Ecke gelangen (m - 1, n - 1).
Sie können sich von einer Zelle nach oben, unten, links oder rechts zur nächsten benachbarten Zelle bewegen, solange Ihre Gesundheit positiv bleibt.
Zellen (i, j) mit Grid[i][j] = 1 gelten als unsicher und verringern Ihre Gesundheit um 1.
Geben Sie „true“ zurück, wenn Sie die letzte Zelle mit einem Gesundheitswert von 1 oder mehr erreichen können, andernfalls „false“.

Beispiel 1:

Eingabe: Gitter = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], Gesundheit = 1
Ausgabe: wahr
Erläuterung:
Die letzte Zelle kann sicher erreicht werden, indem man die grauen Zellen unten entlang geht.

Beispiel 2:

Eingabe: Gitter = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0, 0,1,0,1,0]], Gesundheit = 3
Ausgabe: falsch
Erläuterung:
Um die letzte Zelle sicher zu erreichen, sind mindestens 4 Gesundheitspunkte erforderlich.

Beispiel 3:

Eingabe: Gitter = [[1,1,1],[1,0,1],[1,1,1]], Gesundheit = 5
Ausgabe: wahr
Erläuterung:
Die letzte Zelle kann sicher erreicht werden, indem man die grauen Zellen unten entlang geht.

Jeder Pfad, der nicht durch die Zelle (1, 1) führt, ist unsicher, da Ihre Gesundheit beim Erreichen der letzten Zelle auf 0 sinkt.

Einschränkungen:

m == Gitterlänge
n == Gitter[i].Länge
1 <= m, n <= 50
2 <= m * n
1 <= Gesundheit <= m + n
Grid[i][j] ist entweder 0 oder 1.

Sie erhalten ein m x n binäres Matrixgitter und eine ganzzahlige Gesundheit.
Du startest in der oberen linken Ecke (0, 0) und möchtest in die untere rechte Ecke (m - 1, n - 1) gelangen.
Sie können von einer Zelle nach oben, unten, links oder rechts von einer Zelle in eine andere benachbarte Zelle wechseln, solange Ihre Gesundheit positiv bleibt.
Zellen (i, j) mit Gitter[i][j] = 1 gelten als unsicher und verringern Ihre Gesundheit um 1.
Gibt true zurück, wenn Sie die letzte Zelle mit einem Integritätswert von 1 oder mehr erreichen können, andernfalls false.

Beispiel 1:

Eingabe: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
Ausgabe: true
Erklärung:
Die letzte Zelle kann sicher erreicht werden, indem man entlang der grauen Zellen unten geht.

Beispiel 2:

Eingabe: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
Ausgabe: falsch
Erklärung:
Es werden mindestens 4 Lebenspunkte benötigt, um die letzte Zelle sicher zu erreichen.

Beispiel 3:

Eingabe: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
Ausgabe: true
Erklärung:
Die letzte Zelle kann sicher erreicht werden, indem man entlang der grauen Zellen unten geht.

Jeder Weg, der nicht durch die Zelle (1, 1) führt, ist unsicher, da deine Gesundheit auf 0 sinkt, wenn du die letzte Zelle erreichst.

Zwänge:

m == grid.length
n == grid[i].length
1 <= m, n <= 50
2 <= m * n
1 <= health <= m + n
grid[i][j] ist entweder 0 oder 1.


Sie erhalten ein ganzzahliges Array nums und eine positive ganze Zahl k.
Der Wert einer Sequenz seq der Größe 2 * x ist definiert als:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Gibt den Maximalwert einer beliebigen Teilfolge von Zahlen mit der Größe 2 * k zurück.

Beispiel 1:

Eingabe: nums  = [2,6,7], k = 1
Ausgabe: 5
Erläuterung:
Die Teilfolge [2, 7] hat den Maximalwert 2 XOR 7 = 5.

Beispiel 2:

Eingabe: nums = [4,2,5,6,7], k = 2
Ausgabe: 2
Erläuterung:
Die Teilfolge [4, 5, 6, 7] hat den Maximalwert von (4 OR 5) XOR (6 OR 7) = 2.

Einschränkungen:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Sie erhalten ein ganzzahliges Array nums und eine positive ganze Zahl k.
Der Wert einer Sequenz seq der Größe 2 * x ist definiert als:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Gibt den Maximalwert einer beliebigen Teilfolge von Zahlen mit der Größe 2 * k zurück.

Beispiel 1:

Eingabe: Zahlen = [2,6,7], k = 1
Ausgabe: 5
Erläuterung:
Die Teilfolge [2, 7] hat den Maximalwert 2 XOR 7 = 5.

Beispiel 2:

Eingabe: Zahlen = [4,2,5,6,7], k = 2
Ausgabe: 2
Erläuterung:
Die Teilfolge [4, 5, 6, 7] hat den Maximalwert von (4 OR 5) XOR (6 OR 7) = 2.

Einschränkungen:

2 <= nums.length <= 400
1 <= nums[i] < 2^7
1 <= k <= nums.length / 2

Sie erhalten eine Ganzzahl -Array -nums und eine positive Ganzzahl k.
Der Wert einer Sequenz sek von Größe 2 * x wird definiert als:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).

Geben Sie den Maximalwert einer Subsequenz von nums mit Größe 2 * k zurück.

Beispiel 1:

Eingabe: nums = [2,6,7], k = 1
Ausgabe: 5
Erläuterung:
Die Untersequenz [2, 7] hat den Maximalwert von 2 XOR 7 = 5.

Beispiel 2:

Eingabe: nums = [4,2,5,6,7], k = 2
Ausgabe: 2
Erläuterung:
Die Untersequenz [4, 5, 6, 7] hat den Maximalwert von (4 OR 5) XOR (6 OR 7) = 2.

Einschränkungen:

2 <= nums.length <= 400
1 <= nums [i] <2^7
1 <= k <= nums.length / 2


Sie erhalten ein 2D-Array aus ganzzahligen Koordinaten der Länge n und einer ganzen Zahl k, wobei 0 <= k < n.
Koordinaten[i] = [x_i, y_i] gibt den Punkt (x_i, y_i) in einer 2D-Ebene an.
Ein zunehmender Pfad der Länge m ist als Liste von Punkten (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m) definiert, sodass:

x_i < x_i + 1 und y_i < y_i + 1 für alle i mit 1 <= i < m.
(x_i, y_i) liegt in den angegebenen Koordinaten für alle i, wobei 1 <= i <= m.

Gibt die maximale Länge eines zunehmenden Pfades zurück, der Koordinaten[k] enthält.

Beispiel 1:

Eingabe: Koordinaten = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Ausgabe: 3
Erläuterung:
(0, 0), (2, 2), (5, 3) ist der längste ansteigende Pfad, der (2, 2) enthält.

Beispiel 2:

Eingabe: Koordinaten = [[2,1],[7,0],[5,6]], k = 2
Ausgabe: 2
Erläuterung:
(2, 1), (5, 6) ist der längste ansteigende Pfad, der (5, 6) enthält.

Einschränkungen:

1 <= n == Koordinaten.Länge <= 10^5
Koordinaten[i].length == 2
0 <= Koordinaten[i][0], Koordinaten[i][1] <= 10^9
Alle Elemente in Koordinaten sind unterschiedlich.
0 <= k <= n - 1

Sie erhalten eine 2D-Matrix von ganzzahligen Koordinaten der Länge n und eine ganze Zahl k, wobei 0 <= k < n.
coordinates[i] = [x_i, y_i] bezeichnet den Punkt (x_i, y_i) in einer 2D-Ebene.
Ein ansteigender Pfad der Länge m ist definiert als eine Liste von Punkten (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_m, y_m), so dass:

x_i < x_i + 1 und y_i < y_i + 1 für alle i mit 1 <= i < m.
(x_i, y_i) liegt in den gegebenen Koordinaten für alle i mit 1 <= i <= m.

Gibt die maximale Länge eines ansteigenden Pfades zurück, der Koordinaten[k] enthält.

Beispiel 1:

Eingabe: coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1
Ausgabe: 3
Erläuterung:
(0, 0), (2, 2), (5, 3) ist der längste ansteigende Pfad, der (2, 2) enthält.

Beispiel 2:

Eingabe: coordinates = [[2,1],[7,0],[5,6]], k = 2
Ausgabe: 2
Erläuterung:
(2, 1), (5, 6) ist der längste ansteigende Pfad, der (5, 6) enthält.

Randbedingungen:

1 <= n == coordinates.length <= 10^5
coordinates[i].length == 2
0 <= coordinates[i][0], coordinates[i][1] <= 10^9
Alle Elemente in Koordinaten sind eindeutig.
0 <= k <= n - 1


Sie erhalten ein Array von Strings message und ein Array von Strings bannedWords.
Ein Array von Wörtern wird als Spam betrachtet, wenn mindestens zwei Wörter darin enthalten sind, die genau mit einem Wort in bannedWords übereinstimmen.
Gibt true zurück, wenn das Array message Spam ist, und false andernfalls.

Beispiel 1:

Eingabe: message = ["hello","world","leetcode"], bannedWords = ["world","hello"]
Ausgabe: true
Erläuterung:
Die Wörter „hello“ und „world“ aus dem message-Array erscheinen beide im bannedWords-Array.

Beispiel 2:

Eingabe: message = ["hello","programming","fun"], bannedWords = ["world","programming","leetcode"]
Ausgabe: false
Erläuterung:
Nur ein Wort aus dem message-Array („programming“) kommt im bannedWords-Array vor.

Beschränkungen:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] und bannedWords[i] bestehen nur aus englischen Kleinbuchstaben.

Sie erhalten ein Array von Zeichenfolgen „message“ und ein Array von Zeichenfolgen „bannedWords“.
Ein Array von Wörtern gilt als Spam, wenn es mindestens zwei Wörter enthält, die genau mit einem Wort in bannedWords übereinstimmen.
Gibt „true“ zurück, wenn es sich bei der Array-Nachricht um Spam handelt, andernfalls „false“.

Beispiel 1:

Eingabe: message = ["hello", "world", "leetcode"], bannedWords = ["world", "hello"]
Ausgabe: wahr
Erläuterung:
Die Wörter „hello“ und „world“ aus dem Nachrichtenarray erscheinen beide im bannedWords-Array.

Beispiel 2:

Eingabe: message = ["hello", "programming", "fun"], bannedWords = ["world", "programming", "leetcode"]
Ausgabe: falsch
Erläuterung:
Nur ein Wort aus dem Nachrichtenarray („Programmierung“) erscheint im bannedWords-Array.

Einschränkungen:

1 <= message.length, bannedWords.length <= 10^5
1 <= message[i].length, bannedWords[i].length <= 15
message[i] und bannedWords[i] bestehen nur aus englischen Kleinbuchstaben.


Sie erhalten eine Ganzzahl „mountainHeight“, die die Höhe eines Berges angibt.
Sie erhalten außerdem ein ganzzahliges Array workerTimes, das die Arbeitszeit der Arbeiter in Sekunden darstellt.
Die Arbeiter arbeiten gleichzeitig daran, die Höhe des Berges zu reduzieren. Für Arbeiter i:

Um die Höhe des Berges um x zu verringern, sind workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x Sekunden erforderlich. Zum Beispiel:

Um die Höhe des Berges um 1 zu reduzieren, sind workerTimes[i] Sekunden erforderlich.
Um die Höhe des Berges um 2 zu reduzieren, sind workerTimes[i] + workerTimes[i] * 2 Sekunden usw. erforderlich.

Gibt eine Ganzzahl zurück, die die Mindestanzahl an Sekunden darstellt, die die Arbeiter benötigen, um die Höhe des Berges auf 0 zu bringen.

Beispiel 1:

Eingabe: mountainHeight = 4, workerTimes = [2,1,1]
Ausgabe: 3
Erläuterung:
Eine Möglichkeit, die Höhe des Berges auf 0 zu reduzieren, ist:

Arbeiter 0 reduziert die Höhe um 1, wobei workerTimes[0] = 2 Sekunden benötigt.
Arbeiter 1 reduziert die Höhe um 2, wobei workerTimes[1] + workerTimes[1] * 2 = 3 Sekunden beträgt.
Arbeiter 2 reduziert die Höhe um 1, wobei workerTimes[2] = 1 Sekunde beträgt.

Da sie gleichzeitig arbeiten, beträgt die benötigte Mindestzeit max(2, 3, 1) = 3 Sekunden.

Beispiel 2:

Eingabe: MountainHeight = 10, workerTimes = [3,2,2,4]
Ausgabe: 12
Erläuterung:

Arbeiter 0 reduziert die Höhe um 2, wobei workerTimes[0] + workerTimes[0] * 2 = 9 Sekunden benötigt.
Arbeiter 1 reduziert die Höhe um 3, wobei workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 Sekunden beträgt.
Arbeiter 2 reduziert die Höhe um 3, wobei workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 Sekunden beträgt.
Arbeiter 3 reduziert die Höhe um 2, wobei workerTimes[3] + workerTimes[3] * 2 = 12 Sekunden beträgt.

Die Anzahl der benötigten Sekunden beträgt max(9, 12, 12, 12) = 12 Sekunden.

Beispiel 3:

Eingabe: mountainHeight = 5, workerTimes = [1]
Ausgabe: 15
Erläuterung:
In diesem Beispiel gibt es nur einen Arbeiter, daher lautet die Antwort workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Einschränkungen:

1 <= Berghöhe <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Sie erhalten eine Ganzzahl „mountainHeight“, die die Höhe eines Berges angibt.
Sie erhalten außerdem ein ganzzahliges Array workerTimes, das die Arbeitszeit der Arbeiter in Sekunden darstellt.
Die Arbeiter arbeiten gleichzeitig daran, die Höhe des Berges zu verringern. Für Arbeiter i:

Um die Höhe des Berges um x zu verringern, sind workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x Sekunden erforderlich. Zum Beispiel:

Um die Höhe des Berges um 1 zu reduzieren, sind workerTimes[i] Sekunden erforderlich.
Um die Höhe des Berges um 2 zu reduzieren, sind workerTimes[i] + workerTimes[i] * 2 Sekunden usw. erforderlich.

Gibt eine Ganzzahl zurück, die die Mindestanzahl an Sekunden darstellt, die die Arbeiter benötigen, um die Höhe des Berges auf 0 zu bringen.

Beispiel 1:

Eingabe: mountainHeight = 4, workerTimes = [2,1,1]
Ausgabe: 3
Erläuterung:
Eine Möglichkeit, die Höhe des Berges auf 0 zu reduzieren, ist:

Arbeiter 0 reduziert die Höhe um 1, wobei workerTimes[0] = 2 Sekunden benötigt.
Arbeiter 1 reduziert die Höhe um 2, wobei workerTimes[1] + workerTimes[1] * 2 = 3 Sekunden beträgt.
Arbeiter 2 reduziert die Höhe um 1, wobei workerTimes[2] = 1 Sekunde beträgt.

Da sie gleichzeitig arbeiten, beträgt die benötigte Mindestzeit max(2, 3, 1) = 3 Sekunden.

Beispiel 2:

Eingabe: MountainHeight = 10, workerTimes = [3,2,2,4]
Ausgabe: 12
Erläuterung:

Arbeiter 0 reduziert die Höhe um 2, wobei workerTimes[0] + workerTimes[0] * 2 = 9 Sekunden benötigt.
Arbeiter 1 reduziert die Höhe um 3, wobei workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 Sekunden beträgt.
Arbeiter 2 reduziert die Höhe um 3, wobei workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 Sekunden beträgt.
Arbeiter 3 reduziert die Höhe um 2, wobei workerTimes[3] + workerTimes[3] * 2 = 12 Sekunden beträgt.

Die Anzahl der benötigten Sekunden beträgt max(9, 12, 12, 12) = 12 Sekunden.

Beispiel 3:

Eingabe: mountainHeight = 5, workerTimes = [1]
Ausgabe: 15
Erläuterung:
In diesem Beispiel gibt es nur einen Arbeiter, daher lautet die Antwort workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Einschränkungen:

1 <= mountainHeight <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6

Sie erhalten eine Ganzzahl „mountainHeight“, die die Höhe eines Berges angibt.
Sie erhalten außerdem ein ganzzahliges Array workerTimes, das die Arbeitszeit der Arbeiter in Sekunden darstellt.
Die Arbeiter arbeiten gleichzeitig daran, die Höhe des Berges zu reduzieren. Für Arbeiter i:

Um die Höhe des Berges um x zu verringern, sind workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x Sekunden erforderlich. Zum Beispiel:

Um die Höhe des Berges um 1 zu reduzieren, sind workerTimes[i] Sekunden erforderlich.
Um die Höhe des Berges um 2 zu reduzieren, sind workerTimes[i] + workerTimes[i] * 2 Sekunden usw. erforderlich.

Gibt eine Ganzzahl zurück, die die Mindestanzahl an Sekunden darstellt, die die Arbeiter benötigen, um die Höhe des Berges auf 0 zu bringen.

Beispiel 1:

Eingabe: mountainHeight = 4, workerTimes = [2,1,1]
Ausgabe: 3
Erläuterung:
Eine Möglichkeit, die Höhe des Berges auf 0 zu reduzieren, ist:

Arbeiter 0 reduziert die Höhe um 1, wobei workerTimes[0] = 2 Sekunden benötigt.
Arbeiter 1 reduziert die Höhe um 2, wobei workerTimes[1] + workerTimes[1] * 2 = 3 Sekunden beträgt.
Arbeiter 2 reduziert die Höhe um 1, wobei workerTimes[2] = 1 Sekunde beträgt.

Da sie gleichzeitig arbeiten, beträgt die benötigte Mindestzeit max(2, 3, 1) = 3 Sekunden.

Beispiel 2:

Eingabe: MountainHeight = 10, WorkerTimes = [3,2,2,4]
Ausgabe: 12
Erläuterung:

Arbeiter 0 reduziert die Höhe um 2, wobei workerTimes[0] + workerTimes[0] * 2 = 9 Sekunden benötigt.
Arbeiter 1 reduziert die Höhe um 3, wobei workerTimes[1] + workerTimes[1] * 2 + workerTimes[1] * 3 = 12 Sekunden beträgt.
Arbeiter 2 reduziert die Höhe um 3, wobei workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 Sekunden beträgt.
Arbeiter 3 reduziert die Höhe um 2, wobei workerTimes[3] + workerTimes[3] * 2 = 12 Sekunden beträgt.

Die Anzahl der benötigten Sekunden beträgt max(9, 12, 12, 12) = 12 Sekunden.

Beispiel 3:

Eingabe: mountainHeight = 5, workerTimes = [1]
Ausgabe: 15
Erläuterung:
In diesem Beispiel gibt es nur einen Arbeiter, daher lautet die Antwort workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15.

Einschränkungen:

1 <= Berghöhe <= 10^5
1 <= workerTimes.length <= 10^4
1 <= workerTimes[i] <= 10^6


Sie erhalten zwei Zeichenketten wort1 und wort2.
Eine Zeichenkette x wird als gültig bezeichnet, wenn x so umgeordnet werden kann, dass sie Wort2 als Präfix hat.
Geben Sie die Gesamtzahl der gültigen Teilzeichenfolgen von wort1 zurück.

Beispiel 1:

Eingabe: word1 = "bcca", word2 = "abc"
Ausgabe: 1
Erläuterung:
Die einzige gültige Teilzeichenkette ist „bcca“, die mit „abc“ als Präfix zu „abcc“ umgeordnet werden kann.

Beispiel 2:

Eingabe: word1 = "abcabc", word2 = "abc"
Ausgabe: 10
Erläuterung:
Alle Teilzeichenfolgen außer Teilzeichenfolgen der Größe 1 und der Größe 2 sind gültig.

Beispiel 3:

Eingabe: word1 = "abcabc", word2 = "aaabc"
Ausgabe: 0

Beschränkungen:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
word1 und word2 bestehen nur aus englischen Kleinbuchstaben.

Sie erhalten zwei Zeichenfolgen, Wort1 und Wort2.
Eine Zeichenfolge x heißt gültig, wenn x so umgestaltet werden kann, dass es Wort2 als Präfix hat.
Gibt die Gesamtzahl der gültigen Teilzeichenfolgen von Wort1 zurück.

Beispiel 1:

Eingabe: Wort1 = „bcca“, Wort2 = „abc“
Ausgabe: 1
Erläuterung:
Der einzig gültige Teilstring ist „bcca“, der in „abcc“ mit „abc“ als Präfix umgestellt werden kann.

Beispiel 2:

Eingabe: Wort1 = „abcabc“, Wort2 = „abc“
Ausgabe: 10
Erläuterung:
Alle Teilzeichenfolgen außer Teilzeichenfolgen der Größe 1 und Größe 2 sind gültig.

Beispiel 3:

Eingabe: Wort1 = „abcabc“, Wort2 = „aaabc“
Ausgabe: 0

Einschränkungen:

1 <= wort1.länge <= 10^5
1 <= wort2.länge <= 10^4
Wort1 und Wort2 bestehen nur aus englischen Kleinbuchstaben.

Sie erhalten zwei Zeichenfolgen, Wort1 und Wort2.
Eine Zeichenfolge x heißt gültig, wenn x so umgestaltet werden kann, dass es Wort2 als Präfix hat.
Gibt die Gesamtzahl der gültigen Teilzeichenfolgen von Wort1 zurück.

Beispiel 1:

Eingabe: word1 = "bcca", word2 = "abc"
Ausgabe: 1
Erläuterung:
Der einzig gültige Teilstring ist "bcca", der in "abcc" mit "abc" als Präfix umgestellt werden kann.

Beispiel 2:

Eingabe: word1 = "abcabc", word2 = "abc"
Ausgabe: 10
Erläuterung:
Alle Teilzeichenfolgen außer Teilzeichenfolgen der Größe 1 und Größe 2 sind gültig.

Beispiel 3:

Eingabe: word1 = "abcabc", word2 = "aaabc"
Ausgabe: 0

Einschränkungen:

1 <= word1.length <= 10^5
1 <= word2.length <= 10^4
Wort1 und Wort2 bestehen nur aus englischen Kleinbuchstaben.


Alice und Bob spielen ein Spiel. Zu Beginn hat Alice eine Zeichenkette word = "a".
Man gibt ihr eine positive ganze Zahl k.
Nun bittet Bob Alice, die folgende Operation für immer durchzuführen:

Erzeugen Sie eine neue Zeichenkette, indem Sie jedes Zeichen in Wort durch das nächste Zeichen im englischen Alphabet ersetzen und an das ursprüngliche Wort anhängen.

Zum Beispiel erzeugt die Operation an „c“ „cd“ und die Operation an „zb“ erzeugt „zbac“.
Gibt den Wert des k^-ten Zeichens in Wort zurück, nachdem genügend Operationen durchgeführt wurden, so dass Wort mindestens k Zeichen enthält.
Beachten Sie, dass das Zeichen „z“ in der Operation in „a“ geändert werden kann.

Beispiel 1:

Eingabe: k = 5
Ausgabe: „b“
Erläuterung:
Am Anfang ist das word = "a". Wir müssen die Operation dreimal durchführen:

Die erzeugte Zeichenfolge ist „b“, das Wort wird zu „ab“.
Die erzeugte Zeichenfolge ist „bc“, das Wort wird zu „abbc“.
Die erzeugte Zeichenfolge ist „bccd“, das Wort wird zu „abbcbccd“.

Beispiel 2:

Eingabe: k = 10
Ausgabe: „c“

Beschränkungen:

1 <= k <= 500

Alice und Bob spielen ein Spiel. Anfangs hat Alice ein Zeichenfolgenwort = „a“.
Sie erhalten eine positive ganze Zahl k.
Jetzt wird Bob Alice bitten, die folgende Operation für immer auszuführen:

Erzeugen Sie eine neue Zeichenfolge, indem Sie jedes Zeichen im Wort durch das nächste Zeichen im englischen Alphabet ersetzen und es an das ursprüngliche Wort anhängen.

Wenn Sie beispielsweise die Operation für „c“ ausführen, wird „cd“ generiert, und wenn Sie die Operation für „zb“ ausführen, wird „zbac“ generiert.
Gibt den Wert des k^ten Zeichens in Wort zurück, nachdem genügend Operationen durchgeführt wurden, damit Wort mindestens k Zeichen hat.
Beachten Sie, dass das Zeichen „z“ in der Operation in „a“ geändert werden kann.

Beispiel 1:

Eingabe: k = 5
Ausgabe: „b“
Erläuterung:
Anfangs ist Wort = „a“. Wir müssen die Operation dreimal durchführen:

Die generierte Zeichenfolge ist „b“, das Wort wird zu „ab“.
Die generierte Zeichenfolge ist „bc“, das Wort wird zu „abbc“.
Die generierte Zeichenfolge ist „bccd“, das Wort wird zu „abbcbccd“.

Beispiel 2:

Eingabe: k = 10
Ausgabe: „c“

Einschränkungen:

1 <= k <= 500

Alice und Bob spielen ein Spiel. Anfangs hat Alice ein Zeichenfolgenwort = „a“.
Sie erhalten eine positive ganze Zahl k.
Jetzt wird Bob Alice bitten, die folgende Operation für immer auszuführen:

Erzeugen Sie eine neue Zeichenfolge, indem Sie jedes Zeichen im Wort durch das nächste Zeichen im englischen Alphabet ersetzen und es an das ursprüngliche Wort anhängen.

Wenn Sie beispielsweise die Operation für „c“ ausführen, wird „cd“ generiert, und wenn Sie die Operation für „zb“ ausführen, wird „zbac“ generiert.
Gibt den Wert des k^ten Zeichens in Wort zurück, nachdem genügend Operationen durchgeführt wurden, damit Wort mindestens k Zeichen hat.
Beachten Sie, dass das Zeichen „z“ in der Operation in „a“ geändert werden kann.

Beispiel 1:

Eingabe: k = 5
Ausgabe: „b“
Erläuterung:
Anfangs ist word = „a“. Wir müssen die Operation dreimal durchführen:

Die generierte Zeichenfolge ist „b“, das wordwird zu „ab“.
Die generierte Zeichenfolge ist „bc“, das wordwird zu „abbc“.
Die generierte Zeichenfolge ist „bccd“, das wordwird zu „abbcbccd“.

Beispiel 2:

Eingabe: k = 10
Ausgabe: „c“

Einschränkungen:

1 <= k <= 500


Gegeben sind eine Zeichenkette Wort und eine nicht-negative ganze Zahl k.
Geben Sie die Gesamtzahl der Teilzeichenfolgen von Wort zurück, die jeden Vokal ('a', 'e', 'i', 'o' und 'u') mindestens einmal und genau k Konsonanten enthalten.

Beispiel 1:

Eingabe: word = "aeioqq", k = 1
Ausgabe: 0
Erläuterung:
Es gibt keine Teilzeichenkette mit allen Vokalen.

Beispiel 2:

Eingabe: word = "aeiou", k = 0
Ausgabe: 1
Erläuterung:
Die einzige Teilfolge mit allen Vokalen und null Konsonanten ist wort[0..4], also „aeiou“.

Beispiel 3:

Eingabe: word = "ieaouqqieaouqq", k = 1
Ausgabe: 3
Erläuterung:
Die Teilstrings mit jedem Vokal und einem Konsonanten sind:

word[0..5], das ist „ieaouq“.
word[6..11], das ist „qieaou“.
word[7..12], das ist „ieaouq“.

Beschränkungen:

5 <= word.length <= 250
Wort besteht nur aus englischen Kleinbuchstaben.
0 <= k <= word.length - 5

Sie erhalten ein Zeichenfolgenwort und eine nicht negative ganze Zahl k.
Gibt die Gesamtzahl der Teilzeichenfolgen eines Wortes zurück, die jeden Vokal („a“, „e“, „i“, „o“ und „u“) mindestens einmal und genau k Konsonanten enthalten.

Beispiel 1:

Eingabe: Wort = „aeioqq“, k = 1
Ausgabe: 0
Erläuterung:
Es gibt keine Teilzeichenfolge bei jedem Vokal.

Beispiel 2:

Eingabe: Wort = „aeiou“, k = 0
Ausgabe: 1
Erläuterung:
Der einzige Teilstring mit jedem Vokal und null Konsonanten ist Wort[0..4], das „aeiou“ ist.

Beispiel 3:

Eingabe: Wort = „ieaouqqieaouqq“, k = 1
Ausgabe: 3
Erläuterung:
Die Teilzeichenfolgen mit jedem Vokal und einem Konsonanten sind:

Wort[0..5], das „ieaouq“ ist.
Wort[6..11], das „qieaou“ ist.
Wort[7..12], das „ieaouq“ ist.

Einschränkungen:

5 <= Wortlänge <= 250
Das Wort besteht nur aus englischen Kleinbuchstaben.
0 <= k <= Wortlänge - 5

Sie erhalten eine Zeichenkette und eine nicht negative ganze Zahl k.
Gibt die Anzahl der Zeichenkette zurück, die jeden Vokal („a“, „e“, „i“, „o“ und „u“) mindestens einmal und genau k Konsonanten enthalten.

Beispiel 1:

Eingabe: Zeichenkette = „aeioqq“, k = 1
Ausgabe: 0
Erläuterung:
Es gibt keine Zeichenkette, die jeden Vokal enthält.

Beispiel 2:

Eingabe: Zeichenkette = „aeiou“, k = 0
Ausgabe: 1
Erläuterung:
Der einzige Teilstring mit jedem Vokal und null Konsonanten ist Zeichenkette[0..4], das „aeiou“ ist.

Beispiel 3:

Eingabe: Zeichenkette= „ieaouqqieaouqq“, k = 1
Ausgabe: 3
Erläuterung:
Die Zeichenkette mit jedem Vokal und einem Konsonanten sind:

Zeichenkette[0..5], das „ieaouq“ ist.
Zeichenkette[6..11], das „qieaou“ ist.
Zeichenkette[7..12], das „ieaouq“ ist.

Einschränkungen:

5 <= Wortlänge <= 250
Das Zeichenkette besteht nur aus englischen Kleinbuchstaben.
0 <= k <= Wortlänge - 5