Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Sie erhalten eine positive ganze Zahl N und ganze Zahlen L und R, so dass 0 \leq L \leq R < 2^N. Der Richter hat eine versteckte Folge A = (A_0, A_1, \dots, A_{2^N-1}), die aus ganzen Zahlen zwischen 0 und 99 (einschließlich) besteht.
Ihr Ziel ist es, den Rest zu finden, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Allerdings können Sie die Werte der Elemente in der Folge A nicht direkt kennen. Stattdessen können Sie den Richter fragen folgende Frage:

- Wählen Sie nichtnegative ganze Zahlen i und j, so dass 2^i(j+1) \leq 2^N. Sei l = 2^i j und r = 2^i (j+1) - 1. Fragen Sie nach dem Rest, wenn A_l + A_{l+1} + \dots + A_r durch 100 geteilt wird.

Sei m die Mindestanzahl an Fragen, die erforderlich sind, um den Rest zu bestimmen, wenn A_L + A_{L+1} + \dots + A_R für jede Folge A durch 100 geteilt wird. Sie müssen diesen Rest innerhalb von m Fragen finden.

Eingabe und Ausgabe

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Lesen Sie zunächst die ganzen Zahlen N, L und R aus der Standardeingabe:
N L R

Stellen Sie dann so oft Fragen, bis Sie den Rest ermitteln können, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Jede Frage sollte im folgenden Format gedruckt format:
? i j

Hier müssen i und j die folgenden Einschränkungen erfüllen:

- i und j sind nicht negative ganze Zahlen.
- 2^i(j+1) \leq 2^N

Die Antwort auf die Frage wird im folgenden Format von der Standardeingabe gegeben:
T

Hier ist T die Antwort auf die Frage, die der Rest ist, wenn A_l + A_{l+1} + \dots + A_r durch 100 geteilt wird, wobei l = 2^i j und r = 2^i (j+1) - 1.
Wenn i und j die Einschränkungen nicht erfüllen oder die Anzahl der Fragen m überschreitet, ist T -1.
Wenn der Richter -1 zurückgibt, gilt Ihr Programm bereits als fehlerhaft. Beenden Sie in diesem Fall das Programm sofort.
Sobald Sie den Rest ermittelt haben, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird, geben Sie den Rest S im folgenden Format aus und beenden Sie das Programm sofort:
! S

Eingabe und Ausgabe

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Lesen Sie zunächst die ganzen Zahlen N, L und R aus der Standardeingabe:
N L R

Stellen Sie dann so oft Fragen, bis Sie den Rest ermitteln können, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Jede Frage sollte im folgenden Format gedruckt werden:
? i j

Hier müssen i und j die folgenden Einschränkungen erfüllen:

- i und j sind nicht negative ganze Zahlen.
- 2^i(j+1) \leq 2^N

Die Antwort auf die Frage wird im folgenden Format von der Standardeingabe gegeben:
T

Hier ist T die Antwort auf die Frage, die der Rest ist, wenn A_l + A_{l+1} + \dots + A_r durch 100 geteilt wird, wobei l = 2^i j und r = 2^i (j+1) - 1.
Wenn i und j die Einschränkungen nicht erfüllen oder die Anzahl der Fragen m überschreitet, ist T -1.
Wenn der Richter -1 zurückgibt, gilt Ihr Programm bereits als fehlerhaft. Beenden Sie in diesem Fall das Programm sofort.
Sobald Sie den Rest ermittelt haben, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird, geben Sie den Rest S im folgenden Format aus und beenden Sie das Programm sofort:
! S

Einschränkungen

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Alle Eingabewerte sind ganze Zahlen.

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Sie erhalten eine positive Ganzzahl N und Ganzzahlen L und R, so dass 0 \leq L \leq R < 2^N. Der Richter hat eine versteckte Sequenz a = (a_0, a_1, \ dots, a_ {2^n-1}), die aus Ganzzahlen zwischen 0 und 99 besteht, einschließlich.
Ihr Ziel ist es, den Rest zu finden, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt ist. Sie können jedoch nicht direkt die Werte der Elemente in der Sequenz A kennen folgende Frage:

- Wählen Sie nicht negative Ganzzahlen i und j so, dass 2^i (j+1) \ leq 2^n. Sei l = 2^i j und r = 2^i (j + 1) - 1. Fragen Sie nach dem Rest, wenn a_l + a_ {l + 1} + \ dots + a_r durch 100 geteilt ist.

Sei M die minimale Anzahl von Fragen, die erforderlich sind, um den Rest zu ermitteln, wenn A_l + A_{l+1} + \dots + A_r für jede Sequenz A durch 100 geteilt wird. Sie müssen diesen Rest innerhalb von M -Fragen finden.

Eingang und Ausgabe

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Lesen Sie zunächst die Ganzzahlen N, L und R aus der Standardeingabe:
N L R

Wiederholen Sie dann Fragen, bis Sie den Rest ermitteln können, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Jede Frage sollte im folgenden Format gedruckt werden:
? I J.

Hier müssen ich und j die folgenden Einschränkungen erfüllen:

- i und j sind nicht negative Ganzzahlen.
- 2^i (j+1) \ leq 2^n

Die Antwort auf die Frage wird im folgenden Format aus Standardeingabe angegeben:
T

Hier ist t die Antwort auf die Frage, die der Rest ist, wenn A_l + A_{l+1} + \dots + A_r durch 100 geteilt wird, wobei l = 2^i j und r = 2^i (j + 1) - 1.
Wenn i und j die Einschränkungen nicht erfüllen oder wenn die Anzahl der Fragen M überschreitet, dann ist T -1.
Wenn der Richter -1 zurückgibt, gilt Ihr Programm bereits als falsch. Beenden Sie in diesem Fall das Programm sofort.
Sobald Sie den Rest ermittelt haben, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird, drucken Sie den Rest S im folgenden Format und beenden Sie das Programm sofort:
! S

Eingang und Ausgabe

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Lesen Sie zunächst die Ganzzahlen N, L und R aus der Standardeingabe:
N L R

Wiederholen Sie dann Fragen, bis Sie den Rest ermitteln können, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Jede Frage sollte im folgenden Format gedruckt werden:
? I J.

Hier müssen i und j die folgenden Einschränkungen erfüllen:

- i und j sind nicht negative Ganzzahlen.
- 2^i(j+1) \leq 2^N

Die Antwort auf die Frage wird im folgenden Format aus Standardeingabe angegeben:
T

Hier ist T die Antwort auf die Frage, die der Rest ist, wenn A_l + A_{l+1} + \dots + A_r durch 100 geteilt wird, wobei l = 2^i j und r = 2^i (j + 1) - 1.
Wenn i und j die Einschränkungen nicht erfüllen oder wenn die Anzahl der Fragen M überschreitet, dann ist T -1.
Wenn der Richter -1 zurückgibt, gilt Ihr Programm bereits als falsch. Beenden Sie in diesem Fall das Programm sofort.
Sobald Sie den Rest ermittelt haben, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird, drucken Sie den Rest S im folgenden Format und beenden Sie das Programm sofort:
! S

Einschränkungen

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Alle Eingabewerte sind Ganzzahlen.

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Sie erhalten eine positive ganze Zahl N und ganze Zahlen L und R, so dass 0 \leq L \leq R < 2^N. Der Richter hat eine versteckte Folge A = (A_0, A_1, \dots, A_{2^N-1}), die aus ganzen Zahlen zwischen 0 und 99 (einschließlich) besteht.
Ihr Ziel ist es, den Rest zu finden, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Allerdings können Sie die Werte der Elemente in der Folge A nicht direkt kennen. Stattdessen können Sie den Richter fragen folgende Frage:

- Wählen Sie nichtnegative ganze Zahlen i und j, so dass 2^i(j+1) \leq 2^N. Sei l = 2^i j und r = 2^i (j+1) - 1. Fragen Sie nach dem Rest, den Rest von A_L + A_{L+1} + \dots + A_R modulo 100.

Sei m die minimale Anzahl an Fragen, die erforderlich sind, um den Rest zu bestimmen, wenn A_L + A_{L+1} + \dots + A_R für jede Folge A durch 100 geteilt wird. Sie müssen diesen Rest innerhalb von m Fragen finden.

Eingabe und Ausgabe

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Lesen Sie zunächst die ganzen Zahlen N, L und R aus der Standardeingabe:
N L R

Stellen Sie dann so oft Fragen, bis Sie den Rest ermitteln können, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Jede Frage sollte im folgenden Format gedruckt werden:
? i j

Hier müssen i und j die folgenden Einschränkungen erfüllen:

- i und j sind nicht negative ganze Zahlen.
- 2^i(j+1) \leq 2^N

Die Antwort auf die Frage wird im folgenden Format von der Standardeingabe gegeben:
T

Hier ist T die Antwort auf die Frage, die der Rest ist, wenn A_l + A_{l+1} + \dots + A_r durch 100 geteilt wird, wobei l = 2^i j und r = 2^i (j+1) - 1.
Wenn i und j die Einschränkungen nicht erfüllen oder die Anzahl der Fragen m überschreitet, ist T -1.
Wenn der Richter -1 zurückgibt, gilt Ihr Programm bereits als fehlerhaft. Beenden Sie in diesem Fall das Programm sofort.
Sobald Sie den Rest ermittelt haben, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird, geben Sie den Rest S im folgenden Format aus und beenden Sie das Programm sofort:
! S

Eingabe und Ausgabe

Dies ist ein interaktives Problem (bei dem Ihr Programm über Eingabe und Ausgabe mit dem Richter interagiert).
Lesen Sie zunächst die ganzen Zahlen N, L und R aus der Standardeingabe:
N L R

Stellen Sie dann so oft Fragen, bis Sie den Rest ermitteln können, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird. Jede Frage sollte im folgenden Format gedruckt werden:
? i j

Hier müssen i und j die folgenden Einschränkungen erfüllen:

- i und j sind nicht negative ganze Zahlen.
- 2^i(j+1) \leq 2^N

Die Antwort auf die Frage wird im folgenden Format von der Standardeingabe gegeben:
T

Hier ist T die Antwort auf die Frage, die der Rest ist, wenn A_l + A_{l+1} + \dots + A_r durch 100 geteilt wird, wobei l = 2^i j und r = 2^i (j+1) - 1.
Wenn i und j die Einschränkungen nicht erfüllen oder die Anzahl der Fragen m überschreitet, ist T -1.
Wenn der Richter -1 zurückgibt, gilt Ihr Programm bereits als fehlerhaft. Beenden Sie in diesem Fall das Programm sofort.
Sobald Sie den Rest ermittelt haben, wenn A_L + A_{L+1} + \dots + A_R durch 100 geteilt wird, geben Sie den Rest S im folgenden Format aus und beenden Sie das Programm sofort:
! S

Einschränkungen

- 1 \leq N \leq 18
- 0 \leq L \leq R \leq 2^N - 1
- Alle Eingabewerte sind ganze Zahlen.


Du hast eine Sequenz A=(A_1,A_2,\dots,A_N) der Länge N und eine Sequenz B=(B_1,B_2,\dots,B_M) der Länge M gegeben. Hierbei sind alle Elemente von A und B paarweise verschieden. Bestimme, ob die Sequenz C=(C_1,C_2,\dots,C_{N+M}), die durch Sortieren aller Elemente von A und B in aufsteigender Reihenfolge entsteht, zwei aufeinanderfolgende Elemente enthält, die in A erscheinen.

Eingabe

Die Eingabe erfolgt über Standard Input im folgenden Format:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Ausgabe

Falls C zwei aufeinanderfolgende Elemente aus A enthält, gib Yes aus; andernfalls gib No aus.

Beschränkungen

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M sind verschieden.
- Alle Eingabewerte sind ganze Zahlen.

Beispiel Eingabe 1

3 2
3 2 5
4 1

Beispiel Ausgabe 1

Yes

C=(1,2,3,4,5). Da 2 und 3 aus A aufeinanderfolgend in C vorkommen, gib Yes aus.

Beispiel Eingabe 2

3 2
3 1 5
4 2

Beispiel Ausgabe 2

No

C=(1,2,3,4,5). Da keine zwei Elemente aus A aufeinanderfolgend in C vorkommen, gib No aus.

Beispiel Eingabe 3

1 1
1
2

Beispiel Ausgabe 3

No

Sie erhalten eine Folge A=(A_1,A_2,\dots,A_N) der Länge N und eine Folge B=(B_1,B_2,\dots,B_M) der Länge M. Hier sind alle Elemente von A und B eindeutig . Bestimmen Sie, ob die Sequenz C=(C_1,C_2,\dots,C_{N+M}), die durch Sortieren aller Elemente von A und B in aufsteigender Reihenfolge gebildet wird, zwei aufeinanderfolgende Elemente enthält, die in A erscheinen.

Eingabe

Die Eingabe erfolgt über die Standardeingabe im folgenden Format:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Ausgabe

Wenn C zwei aufeinanderfolgende Elemente enthält, die in A erscheinen, geben Sie „Yes“ aus; andernfalls geben Sie Nein aus.

Einschränkungen

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M sind unterschiedlich.
- Alle Eingabewerte sind ganze Zahlen.

Beispieleingabe 1

3 2
3 2 5
4 1

Beispielausgabe 1

Yes

C=(1,2,3,4,5). Da 2 und 3 aus A nacheinander in C vorkommen, geben Sie „Yes“ aus.

Beispieleingabe 2

3 2
3 1 5
4 2

Beispielausgabe 2

No

C=(1,2,3,4,5). Da in C keine zwei Elemente aus A nacheinander vorkommen, geben Sie No aus.

Beispieleingabe 3

1 1
1
2

Beispielausgabe 3

No

Sie erhalten eine Folge A=(A_1,A_2,\dots,A_N) der Länge N und eine Folge B=(B_1,B_2,\dots,B_M) der Länge M. Hier sind alle Elemente von A und B paarweise verschieden. Bestimmen Sie, ob die Sequenz C=(C_1,C_2,\dots,C_{N+M}), die durch Sortieren aller Elemente von A und B in aufsteigender Reihenfolge gebildet wird, zwei aufeinanderfolgende Elemente enthält, die in A erscheinen.

Eingabe

Die Eingabe erfolgt über die Standardeingabe im folgenden Format:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_M

Ausgabe

Wenn C zwei aufeinanderfolgende Elemente enthält, die in A erscheinen, geben Sie „Yes“ aus; andernfalls geben Sie Nein aus.

Einschränkungen

- 1 \leq N, M \leq 100
- 1 \leq A_i, B_j \leq 200
- A_1, A_2, \dots, A_N, B_1, B_2, \dots, B_M sind unterschiedlich.
- Alle Eingabewerte sind ganze Zahlen.

Beispieleingabe 1

3 2
3 2 5
4 1

Beispielausgabe 1

Yes

C=(1,2,3,4,5). Da 2 und 3 aus A nacheinander in C vorkommen, geben Sie „Yes“ aus.

Beispieleingabe 2

3 2
3 1 5
4 2

Beispielausgabe 2

No

C=(1,2,3,4,5). Da in C keine zwei Elemente aus A nacheinander vorkommen, geben Sie No aus.

Beispieleingabe 3

1 1
1
2

Beispielausgabe 3

No


Es gibt ein N \times N-Gitter, wobei die Zelle in der i-ten Zeile von oben und der j-ten Spalte von links die ganze Zahl N \times (i-1) + j enthält.
In T-Runden werden ganze Zahlen bekannt gegeben. In Turn i wird die ganze Zahl A_i bekannt gegeben und die Zelle, die A_i enthält, wird markiert. Bestimmen Sie die Runde, in der Bingo zum ersten Mal erreicht wird. Wenn Bingo nicht innerhalb von T Runden erreicht wird, geben Sie -1 aus.
Bingo zu erreichen bedeutet hier, mindestens eine der folgenden Bedingungen zu erfüllen:

- Es gibt eine Zeile, in der alle N-Zellen markiert sind.
- Es gibt eine Spalte, in der alle N-Zellen markiert sind.
- Es gibt eine diagonale Linie (von links oben nach rechts unten oder von rechts oben nach links unten), in der alle N Zellen markiert sind.

Eingang

Die Eingabe erfolgt über die Standardeingabe im folgenden Format:
N T
A_1 A_2 \ldots A_T

Ausgabe

Wenn Bingo innerhalb von T Runden erreicht wird, drucken Sie die Rundennummer aus, in der Bingo zum ersten Mal erreicht wird. andernfalls drucken Sie -1.

Einschränkungen

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j wenn i \neq j.
- Alle Eingabewerte sind ganze Zahlen.

Beispieleingabe 1

3 5
5 1 8 9 7

Beispielausgabe 1

4

Der Zustand des Gitters ändert sich wie folgt. Bingo wird zum ersten Mal in Runde 4 erreicht.

Beispieleingabe 2

3 5
4 2 9 7 5

Beispielausgabe 2

-1

Bingo wird nicht innerhalb von fünf Runden erreicht, also geben Sie -1 aus.

Beispieleingabe 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Beispielausgabe 3

9

Es gibt ein N times N Gitter, wobei die Zelle in der i-ten Zeile von oben und die j-te Spalte von links die ganze Zahl N times (i-1) + j enthält.
Über T-Kurven werden ganze Zahlen angesagt. In Runde i wird die ganze Zahl A_i angesagt, und die Zelle, die A_i enthält, wird markiert. Bestimmen Sie, in welchem Zug Bingo zum ersten Mal erreicht wird. Wenn Bingo nicht innerhalb von T Runden erreicht wird, geben Sie -1 aus.
Hier bedeutet Bingo zu erreichen, mindestens eine der folgenden Bedingungen zu erfüllen:

- Es existiert eine Zeile, in der alle N Zellen markiert sind.
- Es existiert eine Spalte, in der alle N Zellen markiert sind.
- Es existiert eine diagonale Linie (von links oben nach rechts unten oder von rechts oben nach links unten), in der alle N Zellen markiert sind.

Eingabe

Die Eingabe erfolgt aus der Standardeingabe im folgenden Format:
N T
A_1 A_2 \ldots A_T

Ausgabe

Wenn Bingo innerhalb von T Runden erreicht wird, drucken Sie die Zugnummer, an der Bingo zum ersten Mal erreicht wird; Andernfalls geben Sie -1 aus.

Zwänge

- 2 \leq N \leq 2 \times 10^3
- 1 \leq T \leq \min(N^2, 2 \times 10^5)
- 1 \leq A_i \leq N^2
- A_i \neq A_j if i \neq j.
- Alle Eingabewerte sind ganze Zahlen.

Beispiel-Eingang 1

3 5
5 1 8 9 7

Beispiel-Ausgabe 1

4

Der Zustand des Rasters ändert sich wie folgt. Bingo wird zum ersten Mal in Runde 4 erreicht.

Beispiel-Eingang 2

3 5
4 2 9 7 5

Beispiel-Ausgabe 2

-1

Bingo wird nicht innerhalb von fünf Runden erreicht, also print -1.

Beispiel-Eingang 3

4 12
13 9 6 5 2 7 16 14 8 3 10 11

Beispiel-Ausgabe 3

9


Takahashis Kuchen wurde von jemandem gegessen. Es gibt drei Verdächtige: Person 1, Person 2 und Person 3.
Es gibt zwei Zeugen, Ringo und Snuke. Ringo erinnert sich, dass Person A nicht der Täter ist, und Snuke erinnert sich, dass Person B nicht der Täter ist.
Stellen Sie anhand der Erinnerungen der beiden Zeugen fest, ob der Täter eindeutig identifiziert werden kann. Wenn der Täter identifiziert werden kann, drucken Sie die Nummer der Person aus.

Eingang

Die Eingabe erfolgt über die Standardeingabe im folgenden Format:
A B

Ausgabe

Wenn der Täter anhand der Erinnerungen der beiden Zeugen eindeutig identifiziert werden kann, tragen Sie die Nummer der Person ein; andernfalls drucken Sie -1.

Einschränkungen

- 1 \leq A, B \leq 3
- Alle Eingabewerte sind ganze Zahlen.

Beispieleingabe 1

1 2

Beispielausgabe 1

3

Aus den Erinnerungen der beiden Zeugen lässt sich ermitteln, dass Person 3 der Täter ist.

Beispieleingabe 2

1 1

Beispielausgabe 2

-1

Aus den Erinnerungen der beiden Zeugen lässt sich nicht feststellen, ob Person 2 oder Person 3 der Täter ist. Drucken Sie daher -1.

Beispieleingabe 3

3 1

Beispielausgabe 3

2

Takahashis Kuchen wurde von jemandem gegessen. Es gibt drei Verdächtige: Person 1, Person 2 und Person 3.
Es gibt zwei Zeugen, Ringo und Snuke. Ringo erinnert sich, dass Person A nicht der Täter ist, und Snuke erinnert sich, dass Person B nicht der Täter ist.
Bestimmen Sie, ob der Täter basierend auf den Erinnerungen der beiden Zeugen eindeutig identifiziert werden kann. Wenn der Täter identifiziert werden kann, geben Sie die Nummer der Person aus.

Eingabe

Die Eingabe erfolgt über die Standardeingabe im folgenden Format:
A B

Ausgabe

Wenn der Täter basierend auf den Erinnerungen der beiden Zeugen eindeutig identifiziert werden kann, geben Sie die Nummer der Person aus; andernfalls drucken Sie -1.

Einschränkungen

- 1 \leq A, B \leq 3
- Alle Eingabewerte sind ganze Zahlen.

Beispiel Eingabe 1

1 2

Beispiel Ausgabe 1

3

Aus den Erinnerungen der beiden Zeugen kann festgestellt werden, dass Person 3 der Täter ist.

Beispiel Eingabe 2

1 1

Beispiel Ausgabe 2

-1

Aus den Erinnerungen der beiden Zeugen kann nicht bestimmt werden, ob Person 2 oder Person 3 der Täter ist. Daher wird -1 ausgegeben.

Beispiel Eingabe 3

3 1

Beispiel Ausgabe 3

2

Takahashis Kuchen wurde von jemandem gegessen. Es gibt drei Verdächtige: Person 1, Person 2 und Person 3.
Es gibt zwei Zeugen, Ringo und Snuke. Ringo erinnert sich, dass Person A nicht der Täter ist, und Snuke erinnert sich, dass Person B nicht der Täter ist.
Stellen Sie anhand der Erinnerungen der beiden Zeugen fest, ob der Täter eindeutig identifiziert werden kann. Wenn der Täter identifiziert werden kann, drucken Sie die Nummer der Person aus.

Eingang

Die Eingabe erfolgt über die Standardeingabe im folgenden Format:
A B

Ausgabe

Wenn der Täter anhand der Erinnerungen der beiden Zeugen eindeutig identifiziert werden kann, tragen Sie die Nummer der Person ein; andernfalls drucken Sie -1.

Einschränkungen

- 1 \leq A, B \leq 3
- Alle Eingabewerte sind ganze Zahlen.

Beispieleingabe 1

1 2

Beispielausgabe 1

3

Aus den Erinnerungen der beiden Zeugen lässt sich ermitteln, dass Person 3 der Täter ist.

Beispieleingabe 2

1 1

Beispielausgabe 2

-1

Aus den Erinnerungen der beiden Zeugen lässt sich nicht ermitteln, ob Person 2 oder Person 3 der Täter ist. Drucken Sie daher -1.

Beispieleingabe 3

3 1

Beispielausgabe 3

2


Sie erhalten N Intervalle von reellen Zahlen. Das i-te (1 \leq i \leq N) Intervall ist [l_i, r_i]. Finde die Anzahl der Paare (i, j)\,(1 \leq i < j \leq N), so dass sich das i-te und j-te Intervall schneiden.

Eingabe

Die Eingabe erfolgt über die Standardeingabe in folgendem Format:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Ausgabe

Druckt die Antwort.

Einschränkungen

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Alle Eingabewerte sind ganze Zahlen.

Beispiel Eingabe 1

3
1 5
7 8
3 7

Beispiel Ausgang 1

2

Die gegebenen Intervalle sind [1,5], [7,8], [3,7]. Davon schneiden sich das 1. und das 3. Intervall sowie das 2. und das 3. Intervall, so dass die Antwort 2 lautet.

Beispiel Eingabe 2

3
3 4
2 5
1 6

Beispiel Ausgang 2

3

Probe Eingang 3

2
1 2
3 4

Probe Ausgang 3

0

Sie erhalten N Intervalle reeller Zahlen. Das i-te (1 \leq i \leq N) Intervall ist [l_i, r_i]. Finden Sie die Anzahl der Paare (i, j)\,(1 \leq i < j \leq N), sodass sich das i-te und das j-te Intervall schneiden.

Eingang

Die Eingabe erfolgt über die Standardeingabe im folgenden Format:
N
l_1 r_1
l_2 r_2
\vdots
l_N r_N

Ausgabe

Drucken Sie die Antwort aus.

Einschränkungen

- 2 \leq N \leq 5 \times 10^5
- 0 \leq l_i < r_i \leq 10^9
- Alle Eingabewerte sind ganze Zahlen.

Beispieleingabe 1

3
1 5
7 8
3 7

Beispielausgabe 1

2

Die angegebenen Intervalle sind [1,5], [7,8], [3,7]. Davon überschneiden sich das 1. und 3. Intervall sowie das 2. und 3. Intervall, sodass die Antwort 2 ist.

Beispieleingabe 2

3
3 4
2 5
1 6

Beispielausgabe 2

3

Beispieleingabe 3

2
1 2
3 4

Beispielausgabe 3

0


Sie erhalten ein Array-Apfel der Größe n und eine Array-Kapazität der Größe m.
Es gibt n Packungen, wobei die i^te Packung apple[i] Äpfel enthält. Es gibt auch m Kisten, und die i-te Kiste hat eine Kapazität von Kapazität[i] Äpfeln.
Geben Sie die Mindestanzahl an Kisten zurück, die Sie auswählen müssen, um diese n Packungen Äpfel in Kisten umzuverteilen.
Beachten Sie, dass Äpfel aus derselben Packung in verschiedene Kartons verteilt werden können.

Beispiel 1:

Eingabe: Apfel = [1,3,2], Kapazität = [4,3,1,5,2]
Ausgabe: 2
Erläuterung: Wir werden Kartons mit den Kapazitäten 4 und 5 verwenden.
Es ist möglich, die Äpfel zu verteilen, da die Gesamtkapazität größer oder gleich der Gesamtzahl der Äpfel ist.

Beispiel 2:

Eingabe: Apfel = [5,5,5], Kapazität = [2,4,2,7]
Ausgabe: 4
Erläuterung: Wir müssen alle Kisten verwenden.

Einschränkungen:

1 <= n == apple.length <= 50
1 <= m == Kapazität.Länge <= 50
1 <= Apfel[i], Kapazität[i] <= 50
Der Input wird so generiert, dass es möglich ist, Apfelpakete in Kartons umzuverteilen.

Sie erhalten einen Array 'Apfel' der Größe n und eine Array 'Kapazität' der Größe m.
Es gibt n Packungen, bei denen die i^th Packung apple[i] Äpfel enthält. Es gibt auch m-Boxen, und die i^th Karton hat eine Kapazität von capacity[i] Äpfeln.
Geben Sie die Mindestanzahl von Kartons zurück, die Sie auswählen müssen, um diese n Packungen Äpfel in Kartons zu verteilen.
Beachten Sie, dass Äpfel aus der gleichen Packung in verschiedene Kisten verteilt werden können.

Beispiel 1:

Eingang: apple = [1,3,2], capacity = [4,3,1,5,2]
Ausgang: 2
Erklärung: Wir werden Boxen mit den Kapazitäten 4 und 5 verwenden.
Es ist möglich, die Äpfel zu verteilen, da die Gesamtkapazität größer oder gleich der Gesamtzahl der Äpfel ist.

Beispiel 2:

Eingang: apple = [5,5,5], capacity = [2,4,2,7]
Ausgang: 4
Erklärung: Wir müssen alle Boxen verwenden.

Einschränkungen:

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
Der Input wird so generiert, dass es möglich ist, Packungen mit Äpfeln in Kisten umzuverteilen.


Sie erhalten ein Array happiness der Länge n und eine positive ganze Zahl k.
Es stehen n Kinder in einer Schlange, wobei das i^te Kind den Glückswert Glück[i] hat. Sie möchten aus diesen n Kindern in k Runden k Kinder auswählen.
Wenn Sie in jeder Runde ein Kind auswählen, verringert sich der Glückswert aller Kinder, die bisher nicht ausgewählt wurden, um 1. Beachten Sie, dass der Glückswert nicht negativ werden kann und nur verringert wird, wenn er positiv ist.
Gibt die maximale Summe der Glückswerte der ausgewählten Kinder zurück, die Sie durch Auswahl von k Kindern erreichen können.

Beispiel 1:

Eingabe: Glück = [1,2,3], k = 2
Ausgabe: 4
Erläuterung: Wir können zwei Kinder auf folgende Weise auswählen:
- Wählen Sie das Kind mit dem Glückswert == 3 aus. Der Glückswert der verbleibenden Kinder beträgt [0,1].
- Wählen Sie das Kind mit dem Glückswert == 1 aus. Der Glückswert des verbleibenden Kindes wird [0]. Beachten Sie, dass der Glückswert nicht kleiner als 0 werden kann.
Die Summe der Glückswerte der ausgewählten Kinder beträgt 3 + 1 = 4.

Beispiel 2:

Eingabe: Glück = [1,1,1,1], k = 2
Ausgabe: 1
Erläuterung: Wir können zwei Kinder auf folgende Weise auswählen:
- Wählen Sie ein beliebiges Kind mit dem Glückswert == 1 aus. Der Glückswert der verbleibenden Kinder beträgt [0,0,0].
- Wählen Sie das Kind mit dem Glückswert == 0 aus. Der Glückswert des verbleibenden Kindes wird [0,0].
Die Summe der Glückswerte der ausgewählten Kinder beträgt 1 + 0 = 1.

Beispiel 3:

Eingabe: Glück = [2,3,4,5], k = 1
Ausgabe: 5
Erläuterung: Wir können 1 Kind auf folgende Weise auswählen:
- Wählen Sie das Kind mit dem Glückswert == 5 aus. Der Glückswert der verbleibenden Kinder beträgt [1,2,3].
Die Summe der Glückswerte der ausgewählten Kinder beträgt 5.

Einschränkungen:

1 <= n == happiness.length <= 2 * 10^5
1 <= Glück[i] <= 10^8
1 <= k <= n

Sie erhalten ein Array happiness der Länge n und eine positive ganze Zahl k.
Es stehen n Kinder in einer Schlange, wobei das i^te Kind den Glückswert Glück[i] hat. Sie möchten aus diesen n Kindern in k Runden k Kinder auswählen.
Wenn Sie in jeder Runde ein Kind auswählen, verringert sich der Glückswert aller Kinder, die bisher nicht ausgewählt wurden, um 1. Beachten Sie, dass der Glückswert nicht negativ werden kann und nur dann verringert wird, wenn er positiv ist.
Gibt die maximale Summe der Glückswerte der ausgewählten Kinder zurück, die Sie durch Auswahl von k Kindern erreichen können.

Beispiel 1:

Eingabe: Glück = [1,2,3], k = 2
Ausgabe: 4
Erläuterung: Wir können zwei Kinder auf folgende Weise auswählen:
- Wählen Sie das Kind mit dem Glückswert == 3 aus. Der Glückswert der verbleibenden Kinder beträgt [0,1].
- Wählen Sie das Kind mit dem Glückswert == 1 aus. Der Glückswert des verbleibenden Kindes wird [0]. Beachten Sie, dass der Glückswert nicht kleiner als 0 werden kann.
Die Summe der Glückswerte der ausgewählten Kinder beträgt 3 + 1 = 4.

Beispiel 2:

Eingabe: Glück = [1,1,1,1], k = 2
Ausgabe: 1
Erläuterung: Wir können zwei Kinder auf folgende Weise auswählen:
- Wählen Sie ein beliebiges Kind mit dem Glückswert == 1 aus. Der Glückswert der verbleibenden Kinder beträgt [0,0,0].
- Wählen Sie das Kind mit dem Glückswert == 0 aus. Der Glückswert des verbleibenden Kindes wird [0,0].
Die Summe der Glückswerte der ausgewählten Kinder beträgt 1 + 0 = 1.

Beispiel 3:

Eingabe: Glück = [2,3,4,5], k = 1
Ausgabe: 5
Erläuterung: Wir können 1 Kind auf folgende Weise auswählen:
- Wählen Sie das Kind mit dem Glückswert == 5 aus. Der Glückswert der verbleibenden Kinder beträgt [1,2,3].
Die Summe der Glückswerte der ausgewählten Kinder beträgt 5.

Einschränkungen:

1 <= n == happiness.length <= 2 * 10^5
1 <= Glück[i] <= 10^8
1 <= k <= n

Sie erhalten ein Array happiness der Länge n und eine positive ganze Zahl k.
Es stehen n Kinder in einer Warteschlange, in der das i^te Kind den Glückswert Glück[i] hat. Sie möchten aus diesen n Kindern in k Runden k Kinder auswählen.
In jedem Zug, wenn du ein Kind auswählst, verringert sich der Glückswert aller Kinder, die bisher nicht ausgewählt wurden, um 1. Beachten Sie, dass der Glückswert nicht negativ werden kann und nur dann dekrementiert wird, wenn er positiv ist.
Gibt die maximale Summe der Glückswerte der ausgewählten Kinder zurück, die Sie durch Auswahl von k Kindern erreichen können.

Beispiel 1:

Eingabe: happiness = [1,2,3], k = 2
Ausgang: 4
Erklärung: Wir können 2 Kinder auf folgende Weise auswählen:
- Wähle das Kind mit dem Glückswert == 3 aus. Der Glückswert der verbleibenden Kinder wird zu [0,1].
- Wählen Sie das Kind mit dem Glückswert == 1 aus. Der Glückswert des verbleibenden Kindes wird zu [0]. Beachten Sie, dass der Glückswert nicht kleiner als 0 werden kann.
Die Summe der Glückswerte der ausgewählten Kinder ist 3 + 1 = 4.

Beispiel 2:

Eingabe: happiness = [1,1,1,1], k = 2
Ausgang: 1
Erklärung: Wir können 2 Kinder auf folgende Weise auswählen:
- Wählen Sie ein beliebiges Kind mit dem Glückswert == 1. Der Glückswert der verbleibenden Kinder wird zu [0,0,0].
- Wählen Sie das Kind mit dem Glückswert == 0 aus. Der Glückswert des verbleibenden Kindes wird zu [0,0].
Die Summe der Glückswerte der ausgewählten Kinder ist 1 + 0 = 1.

Beispiel 3:

Eingabe: happiness = [2,3,4,5], k = 1
Ausgang: 5
Erklärung: Wir können 1 Kind auf folgende Weise auswählen:
- Wählen Sie das Kind mit dem Glückswert == 5 aus. Der Glückswert der verbleibenden Kinder wird zu [1,2,3].
Die Summe der Glückswerte der ausgewählten Kinder beträgt 5.

Zwänge:

1 <= n == happiness.length <= 2 * 10^5
1 <= happiness[i] <= 10^8
1 <= k <= n


Sie erhalten ein Array arr der Größe n, das aus nicht leeren Zeichenfolgen besteht.
Finden Sie eine String-Array-Antwort der Größe n, sodass:

Antwort[i] ist der kürzeste Teilzeichenfolge von arr[i], der in keinem anderen String in arr als Teilzeichenfolge vorkommt. Wenn mehrere solcher Teilzeichenfolgen vorhanden sind, sollte Antwort[i] die lexikografisch kleinste sein. Und wenn kein solcher Teilzeichenfolge existiert, sollte Antwort[i] ein leerer String sein.

Gibt die Array-Antwort zurück.

Beispiel 1:

Eingabe: arr = ["cab", "ad", "bad", "c"]
Ausgabe: ["ab","","ba",""]
Erläuterung: Wir haben Folgendes:
- Für die Zeichenfolge „cab“ ist die kürzeste Teilzeichenfolge, die in keiner anderen Zeichenfolge vorkommt, entweder „ca“ oder „ab“. Wir wählen die lexikografisch kleinere Teilzeichenfolge, nämlich „ab“.
- Für die Zeichenfolge „ad“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.
- Für die Zeichenfolge „bad“ ist die kürzeste Teilzeichenfolge, die in keiner anderen Zeichenfolge vorkommt, „ba“.
- Für die Zeichenfolge „c“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.

Beispiel 2:

Eingabe: arr = ["abc", "bcd", "abcd"]
Ausgabe: ["","","abcd"]
Erläuterung: Wir haben Folgendes:
- Für die Zeichenfolge „abc“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.
- Für die Zeichenfolge „bcd“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.
- Für die Zeichenfolge „abcd“ ist die kürzeste Teilzeichenfolge, die in keiner anderen Zeichenfolge vorkommt, „abcd“.

Einschränkungen:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein Array arr der Größe n, das aus nicht leeren Zeichenketten besteht.
Finden Sie ein String-Array answer der Größe n so, dass:

answer[i] ist die kürzeste Teilzeichenkette von arr[i], die nicht als Teilzeichenkette in einer anderen Zeichenkette in arr vorkommt. Wenn mehrere solcher Teilstrings existieren, sollte answer[i] der lexikografisch kleinste sein. Und wenn keine solche Teilzeichenkette existiert, sollte answer[i] eine leere Zeichenkette sein.

Gibt das Array answer zurück.

Beispiel 1:

Eingabe: arr = ["cab","ad","bad","c"]
Ausgabe: [„ab“,„“, „ba“,„“]
Erläuterung: Wir haben Folgendes:
- Für die Zeichenkette „cab“ ist die kürzeste Teilzeichenkette, die in keiner anderen Zeichenkette vorkommt, entweder „ca“ oder „ab“, wir wählen die lexikografisch kleinere Teilzeichenkette, also „ab“.
- Für die Zeichenkette „ad“ gibt es keine Teilzeichenkette, die nicht in einer anderen Zeichenkette vorkommt.
- Für die Zeichenkette „bad“ ist die kürzeste Teilzeichenkette, die in keiner anderen Zeichenkette vorkommt, „ba“.
- Für die Zeichenkette „c“ gibt es keine Teilzeichenkette, die nicht in einer anderen Zeichenkette vorkommt.

Beispiel 2:

Eingabe: arr = ["abc","bcd","abcd"]
Ausgabe: [„“,„“, „abcd“]
Erläuterung: Wir haben Folgendes:
- Für die Zeichenkette „abc“ gibt es keine Teilzeichenkette, die nicht in einer anderen Zeichenkette vorkommt.
- Für die Zeichenfolge „bcd“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.
- Für die Zeichenfolge „abcd“ ist die kürzeste Teilzeichenkette, die in keiner anderen Zeichenfolge vorkommt, „abcd“.

Beschränkungen:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein Array arr der Größe n, das aus nicht leeren Zeichenfolgen besteht.
Finden Sie eine String-Array-Antwort der Größe n, sodass:

Antwort[i] ist der kürzeste Teilstring von arr[i], der in keinem anderen String in arr als Teilstring vorkommt. Wenn mehrere solcher Teilzeichenfolgen vorhanden sind, sollte Antwort[i] die lexikografisch kleinste sein. Und wenn kein solcher Teilstring existiert, sollte Antwort[i] ein leerer String sein.

Gibt die Array-Antwort zurück.

Beispiel 1:

Eingabe: arr = ["cab", "ad", "bad", "c"]
Ausgabe: ["ab","",ba",""]
Erläuterung: Wir haben Folgendes:
- Für die Zeichenfolge „cab“ ist die kürzeste Teilzeichenfolge, die in keiner anderen Zeichenfolge vorkommt, entweder „ca“ oder „ab“. Wir wählen die lexikografisch kleinere Teilzeichenfolge, nämlich „ab“.
- Für die Zeichenfolge „ad“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.
- Für die Zeichenfolge „bad“ ist die kürzeste Teilzeichenfolge, die in keiner anderen Zeichenfolge vorkommt, „ba“.
- Für die Zeichenfolge „c“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.

Beispiel 2:

Eingabe: arr = ["abc", "bcd", "abcd"]
Ausgabe: ["","","abcd"]
Erläuterung: Wir haben Folgendes:
- Für die Zeichenfolge „abc“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.
- Für die Zeichenfolge „bcd“ gibt es keine Teilzeichenfolge, die nicht in einer anderen Zeichenfolge vorkommt.
- Für die Zeichenfolge „abcd“ ist die kürzeste Teilzeichenfolge, die in keiner anderen Zeichenfolge vorkommt, „abcd“.

Einschränkungen:

n == arr.length
2 <= n <= 100
1 <= arr[i].length <= 20
arr[i] besteht nur aus englischen Kleinbuchstaben.


Sie erhalten ein 0-indiziertes Array von ganzen Zahlen der Länge n und einer positiven ungeraden ganzen Zahl k.
Die Stärke von x Subarrays ist definiert als Stärke = Summe[1] * x – Summe[2] * (x – 1) + Summe[3] * (x – 2) – Summe[4] * (x – 3) + ... + sum[x] * 1 wobei sum[i] die Summe der Elemente im i^-ten Subarray ist. Formal ist die Stärke die Summe von (-1)^i+1 * sum[i] * (x - i + 1) über alle i, sodass 1 <= i <= x.
Sie müssen k disjunkte Subarrays aus Nums auswählen, sodass ihre Stärke maximal ist.
Geben Sie die maximal mögliche Stärke zurück, die erhalten werden kann.
Beachten Sie, dass die ausgewählten Unterarrays nicht das gesamte Array abdecken müssen.

Beispiel 1:

Eingabe: nums = [1,2,3,-1,2], k = 3
Ausgabe: 22
Erläuterung: Der bestmögliche Weg, 3 Subarrays auszuwählen, ist: nums[0..2], nums[3..3] und nums[4..4]. Die Stärke beträgt (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Beispiel 2:

Eingabe: nums = [12,-2,-2,-2,-2], k = 5
Ausgabe: 64
Erläuterung: Die einzig mögliche Möglichkeit, 5 disjunkte Subarrays auszuwählen, ist: Nums[0..0], Nums[1..1], Nums[2..2], Nums[3..3] und Nums[4. .4]. Die Stärke beträgt 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Beispiel 3:

Eingabe: nums = [-1,-2,-3], k = 1
Ausgabe: -1
Erläuterung: Der beste Weg, ein Subarray auszuwählen, ist: nums[0..0]. Die Stärke beträgt -1.

Einschränkungen:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k ist ungerade.

Sie erhalten ein 0-indiziertes Array von ganzen Zahlen nums der Länge n und eine positive ungerade ganze Zahl k.
Die Stärke von x Subarrays ist definiert als Stärke = Summe[1] * x - Summe[2] * (x - 1) + Summe[3] * (x - 2) - Summe[4] * (x - 3) + ... + sum[x] * 1, wobei sum[i] die Summe der Elemente im i-ten Subarray ist. Formal ist die Stärke die Summe von (-1)^i+1 * sum[i] * (x - i + 1) über alle i, so dass 1 <= i <= x ist.
Sie müssen k disjunkte Unterfelder von nums auswählen, so dass ihre Stärke maximal ist.
Geben Sie die maximal mögliche Stärke zurück, die erzielt werden kann.
Beachten Sie, dass die ausgewählten Unterfelder nicht das gesamte Feld abdecken müssen.

Beispiel 1:

Eingabe: nums = [1,2,3,-1,2], k = 3
Ausgabe: 22
Erläuterung: Der bestmögliche Weg, 3 Subarrays auszuwählen, ist: nums[0..2], nums[3..3] und nums[4..4]. Die Stärke ist (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Beispiel 2:

Eingabe: nums = [12,-2,-2,-2,-2], k = 5
Ausgabe: 64
Erläuterung: Die einzige Möglichkeit, 5 disjunkte Subarrays auszuwählen, ist: nums[0..0], nums[1..1], nums[2..2], nums[3..3], und nums[4..4]. Die Stärke ist 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Beispiel 3:

Eingabe: nums = [-1,-2,-3], k = 1
Ausgabe: -1
Erläuterung: Der bestmögliche Weg, 1 Subarray auszuwählen, ist: nums[0..0]. Die Stärke ist -1.

Randbedingungen:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k ist ungerade.

Sie erhalten ein 0-indiziertes Array von ganzen Zahlen der Länge n und einer positiven ungeraden ganzen Zahl k.
Die Stärke von x Subarrays ist definiert als strength = sum[1] * x - sum[2] * (x - 1) + sum[3] * (x - 2) - sum[4] * (x - 3) + ... + sum[x] * 1 wobei sum[i] die Summe der Elemente im i^-ten Subarray ist. Formal ist die Stärke die Summe von (-1)^i+1 * sum[i] * (x - i + 1) über alle i, sodass 1 <= i <= x.
Sie müssen k disjunkte Subarrays aus Nums auswählen, sodass ihre Stärke maximal ist.
Geben Sie die maximal mögliche Stärke zurück, die erhalten werden kann.
Beachten Sie, dass die ausgewählten Unterarrays nicht das gesamte Array abdecken müssen.

Beispiel 1:

Eingabe: nums = [1,2,3,-1,2], k = 3
Ausgabe: 22
Erläuterung: Der bestmögliche Weg, 3 Subarrays auszuwählen, ist: nums[0..2], nums[3..3] und nums[4..4]. Die Stärke beträgt (1 + 2 + 3) * 3 - (-1) * 2 + 2 * 1 = 22.

Beispiel 2:

Eingabe: nums = [12,-2,-2,-2,-2], k = 5
Ausgabe: 64
Erläuterung: Die einzig mögliche Möglichkeit, 5 disjunkte Subarrays auszuwählen, ist: Nums[0..0], Nums[1..1], Nums[2..2], Nums[3..3] und Nums[4. .4]. Die Stärke beträgt 12 * 5 - (-2) * 4 + (-2) * 3 - (-2) * 2 + (-2) * 1 = 64.

Beispiel 3:

Eingabe: nums = [-1,-2,-3], k = 1
Ausgabe: -1
Erläuterung: Der beste Weg, ein Subarray auszuwählen, ist: nums[0..0]. Die Stärke beträgt -1.

Einschränkungen:

1 <= n <= 10^4
-10^9 <= nums[i] <= 10^9
1 <= k <= n
1 <= n * k <= 10^6
k ist ungerade.


Gegeben ein String s, finde irgendeine Teilfolge der Länge 2, die auch im umgekehrten String von s vorhanden ist.
Gib true zurück, wenn eine solche Teilfolge existiert, andernfalls gib false zurück.

Beispiel 1:

Eingabe: s = "leetcode"
Ausgabe: true
Erklärung: Die Teilfolge "ee" hat die Länge 2 und ist auch in reverse(s) == "edocteel" vorhanden.

Beispiel 2:

Eingabe: s = "abcba"
Ausgabe: true
Erklärung: Alle Teilfolgen der Länge 2 "ab", "bc", "cb", "ba" sind auch in reverse(s) == "abcba" vorhanden.

Beispiel 3:

Eingabe: s = "abcd"
Ausgabe: false
Erklärung: Es gibt keine Teilfolge der Länge 2 in s, die auch im umgekehrten String von s vorhanden ist.

Beschränkungen:

1 <= s.length <= 100
s besteht nur aus kleinen englischen Buchstaben.

Finden Sie bei gegebener Zeichenfolge s eine beliebige Teilzeichenfolge der Länge 2, die auch in der Umkehrung von s vorhanden ist.
Gibt „true“ zurück, wenn ein solcher Teilstring existiert, andernfalls „false“.

Beispiel 1:

Eingabe: s = „leetcode“
Ausgabe: wahr
Erläuterung: Der Teilstring „ee“ hat die Länge 2, die auch in reverse(s) == „edocteel“ vorhanden ist.

Beispiel 2:

Eingabe: s = „abcba“
Ausgabe: wahr
Erläuterung: Alle Teilzeichenfolgen der Länge 2 „ab“, „bc“, „cb“, „ba“ sind auch in reverse(s) == „abcba“ vorhanden.

Beispiel 3:

Eingabe: s = „abcd“
Ausgabe: falsch
Erläuterung: In s gibt es keinen Teilstring der Länge 2, der auch in der Umkehrung von s vorhanden ist.

Einschränkungen:

1 <= s.length <= 100
s besteht nur aus englischen Kleinbuchstaben.


Sie erhalten eine Zeichenfolge s und ein Zeichen c. Gibt die Gesamtzahl der Teilzeichenfolgen von s zurück, die mit c beginnen und enden.

Beispiel 1:

Eingabe: s = „abada“, c = „a“
Ausgabe: 6
Erläuterung: Teilzeichenfolgen, die mit „a“ beginnen und enden, sind: „abada“, „abada“, „abada“, „abada“, „abada“, „abada“.

Beispiel 2:

Eingabe: s = „zzz“, c = „z“
Ausgabe: 6
Erläuterung: Es gibt insgesamt 6 Teilzeichenfolgen in s und alle beginnen und enden mit „z“.

Einschränkungen:

1 <= s.length <= 10^5
s und c bestehen nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenfolge s und ein Zeichen c. Gibt die Gesamtzahl der Teilzeichenfolgen von s zurück, die mit c beginnen und enden.

Beispiel 1:

Eingabe: s = "abada", c = "a"
Ausgabe: 6
Erläuterung: Teilzeichenfolgen, die mit „a“ beginnen und enden, sind: "a" are: "abada", "abada", "abada", "abada", "abada", "abada".

Beispiel 2:

Eingabe: s = "zzz", c = "z"
Ausgabe: 6
Erläuterung: Es gibt insgesamt 6 Teilzeichenfolgen in s und alle beginnen und enden mit "z".

Einschränkungen:

1 <= s.length <= 10^5
s und c bestehen nur aus englischen Kleinbuchstaben.


Sie erhalten ein Zeichenfolgenwort und eine Ganzzahl k.
Wir betrachten ein Wort als k-speziell, wenn |freq(Wort[i]) - freq(Wort[j])| <= k für alle Indizes i und j in der Zeichenkette.
Hier bezeichnet freq(x) die Häufigkeit des Zeichens x in Word und |y| bezeichnet den absoluten Wert von y.
Gibt die Mindestanzahl von Zeichen zurück, die gelöscht werden müssen, um das Wort k-spezifisch zu machen.

Beispiel 1:

Eingabe: word = "aabcaba", k = 0
Ausgabe: 3
Erklärung: Wir können das Wort 0 zu etwas Besonderem machen, indem wir 2 Vorkommen von "a" und 1 Vorkommen von "c" löschen. Daher wird das Wort gleich "baba", wobei freq('a') == freq('b') == 2.

Beispiel 2:

Eingabe: word = "dabdcbdcdcd", k = 2
Ausgabe: 2
Erklärung: Wir können das Wort 2 zu etwas Besonderem machen, indem wir 1 Vorkommen von "a" und 1 Vorkommen von "d" löschen. Daher wird das Wort gleich "bdcbdcdcd", wobei freq('b') == 2, freq('c') == 3 und freq('d') == 4 ist.

Beispiel 3:

Eingabe: word = "aaabaaa", k = 2
Ausgabe: 1
Erklärung: Wir können das Wort 2 zu etwas Besonderem machen, indem wir 1 Vorkommen von "b" löschen. Daher wird das Wort gleich "aaaaaa", wobei die Häufigkeit jedes Buchstabens jetzt einheitlich 6 ist.

Zwänge:

1 <= word.length <= 10^5
0 <= k <= 10^5
word besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein Wort und eine Ganzzahl k.
Wir betrachten Wort als k-speziell, wenn |freq(word[i]) - freq(word[j])| <= k für alle Indizes i und j im String.
Hier bezeichnet freq(x) die Häufigkeit des Zeichens x im Wort und |y| bezeichnet den absoluten Wert von y.
Gibt die Mindestanzahl an Zeichen zurück, die gelöscht werden müssen, um das Wort k-speziell zu machen.

Beispiel 1:

Eingabe: word = „aabcaba“, k = 0
Ausgabe: 3
Erläuterung: Wir können das Wort 0-special, indem wir zwei Vorkommen von „a“ und ein Vorkommen von „c“ löschen. Daher wird das Wort gleich „baba“, wobei freq('a') == freq('b') == 2 ist.

Beispiel 2:

Eingabe: word = „dabdcbdcdcd“, k = 2
Ausgabe: 2
Erläuterung: Wir können Wort 2-special, indem wir ein Vorkommen von „a“ und ein Vorkommen von „d“ löschen. Daher wird das Wort gleich „bdcbdcdcd“, wobei freq('b') == 2, freq('c') == 3 und freq('d') == 4.

Beispiel 3:

Eingabe: word = „aaabaaa“, k = 2
Ausgabe: 1
Erläuterung: Wir können das Wort 2 zu etwas Besonderem machen, indem wir ein Vorkommen von „b“ löschen. Daher wird das Wort gleich „aaaaaa“, wobei die Häufigkeit jedes Buchstabens nun einheitlich 6 beträgt.

Einschränkungen:

1 <= word.length <= 10^5
0 <= k <= 10^5
Das Wort besteht nur aus englischen Kleinbuchstaben.

Sie erhalten ein Zeichenfolgenwort und eine Ganzzahl k.
Wir betrachten Wort als k-speziell, wenn |freq(word[i]) - freq(word[j])| <= k für alle Indizes i und j im String.
Hier bezeichnet freq(x) die Häufigkeit des Zeichens x im Wort und |y| bezeichnet den absoluten Wert von y.
Gibt die Mindestanzahl an Zeichen zurück, die gelöscht werden müssen, um das Wort k-speziell zu machen.

Beispiel 1:

Eingabe: Wort = „aabcaba“, k = 0
Ausgabe: 3
Erläuterung: Wir können das Wort 0 zu etwas Besonderem machen, indem wir zwei Vorkommen von „a“ und ein Vorkommen von „c“ löschen. Daher wird das Wort gleich „baba“, wobei freq('a') == freq('b') == 2 ist.

Beispiel 2:

Eingabe: Wort = „dabdcbdcdcd“, k = 2
Ausgabe: 2
Erläuterung: Wir können das Wort 2 zu etwas Besonderem machen, indem wir ein Vorkommen von „a“ und ein Vorkommen von „d“ löschen. Daher wird das Wort gleich „bdcbdcdcd“, wobei freq('b') == 2, freq('c') == 3 und freq('d') == 4 ist.

Beispiel 3:

Eingabe: Wort = „aaabaaa“, k = 2
Ausgabe: 1
Erläuterung: Wir können das Wort 2 zu etwas Besonderem machen, indem wir ein Vorkommen von „b“ löschen. Daher wird das Wort gleich „aaaaaa“, wobei die Häufigkeit jedes Buchstabens nun einheitlich 6 beträgt.

Einschränkungen:

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


Sie erhalten ein binäres Array nums der Länge n, eine positive ganze Zahl k und eine nicht negative ganze Zahl maxChanges.
Alice spielt ein Spiel, bei dem das Ziel darin besteht, dass Alice mit möglichst wenigen Zügen k Einsen aus Zahlen erhält. Wenn das Spiel beginnt, nimmt Alice einen beliebigen Index aliceIndex im Bereich [0, n - 1] und stellt sich dort hin. Wenn nums[aliceIndex] == 1 ist, nimmt Alice die Eins und nums[aliceIndex] wird 0 (dies zählt nicht als Zug). Danach kann Alice beliebig viele Züge machen (einschließlich null), wobei Alice in jedem Zug genau eine der folgenden Aktionen ausführen muss:

Wählen Sie einen beliebigen Index j != aliceIndex aus, sodass nums[j] == 0 ist, und setzen Sie nums[j] = 1. Diese Aktion kann maximal maxChanges-Zeiten ausgeführt werden.
Wählen Sie zwei beliebige benachbarte Indizes x und y (|x - y| == 1) aus, sodass nums[x] == 1, nums[y] == 0, und tauschen Sie dann ihre Werte aus (setzen Sie nums[y] = 1 und nums [x] = 0). Wenn y == aliceIndex, nimmt Alice die Eins nach diesem Zug auf und nums[y] wird 0.

Gibt die Mindestanzahl an Zügen zurück, die Alice benötigt, um genau k Züge auszuwählen.

Beispiel 1:

Eingabe: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1
Ausgabe: 3
Erklärung: Alice kann in 3 Zügen 3 Einsen aufnehmen, wenn Alice in jedem Zug die folgenden Aktionen ausführt, während sie bei aliceIndex == 1 steht:

 Zu Beginn des Spiels nimmt Alice die Eins und nums[1] wird zu 0. nums wird zu [1,1,1,0,0,1,1,0,0,1].
Wählen Sie j == 2 und führen Sie eine Aktion des ersten Typs aus. nums wird zu [1,0,1,0,0,1,1,0,0,1]
Wählen Sie x == 2 und y == 1 und führen Sie eine Aktion des zweiten Typs aus. nums wird zu [1,1,0,0,0,1,1,0,0,1]. Als y == aliceIndex nimmt Alice die Eins auf und nums wird zu [1,0,0,0,0,1,1,0,0,1].
Wählen Sie x == 0 und y == 1 und führen Sie eine Aktion des zweiten Typs aus. nums wird zu [0,1,0,0,0,1,1,0,0,1]. Als y == aliceIndex nimmt Alice die Eins auf und nums wird zu [0,0,0,0,0,1,1,0,0,1].

Beachten Sie, dass es Alice möglicherweise möglich ist, mit einer anderen Abfolge von 3 Zügen 3 Einsen aufzunehmen.

Beispiel 2:

Eingabe: nums = [0,0,0,0], k = 2, maxChanges = 3
Ausgabe: 4
Erklärung: Alice kann in 4 Zügen 2 Einsen aufnehmen, wenn Alice in jedem Zug die folgenden Aktionen ausführt, während sie bei aliceIndex == 0 steht:

Wählen Sie j == 1 und führen Sie eine Aktion des ersten Typs aus. nums wird zu [0,1,0,0].
Wählen Sie x == 1 und y == 0 und führen Sie eine Aktion des zweiten Typs aus. nums wird zu [1,0,0,0]. Als y == aliceIndex nimmt Alice die Eins auf und nums wird zu [0,0,0,0].
Wählen Sie j == 1 erneut aus und führen Sie eine Aktion des ersten Typs aus. nums wird zu [0,1,0,0].
Wählen Sie erneut x == 1 und y == 0 und führen Sie eine Aktion des zweiten Typs aus. nums wird zu [1,0,0,0]. Als y == aliceIndex nimmt Alice die Eins auf und nums wird zu [0,0,0,0].

Einschränkungen:

2 <= n <= 10^5
0 <= nums[i] <= 1
1 <= k <= 10^5
0 <= maxChanges <= 10^5
maxChanges + sum(nums) >= k


Geben Sie bei gegebener Zeichenfolge s die maximale Länge einer Teilzeichenfolge zurück, sodass sie höchstens zwei Vorkommen jedes Zeichens enthält.

Beispiel 1:

Eingabe: s = „bcbbbcba“
Ausgabe: 4
Erläuterung:
Der folgende Teilstring hat eine Länge von 4 und enthält höchstens zwei Vorkommen jedes Zeichens: „bcbbbcba“.
Beispiel 2:

Eingabe: s = „aaaa“
Ausgabe: 2
Erläuterung:
Der folgende Teilstring hat eine Länge von 2 und enthält höchstens zwei Vorkommen jedes Zeichens: „aaaa“.

Einschränkungen:

2 <= s.length <= 100
s besteht nur aus englischen Kleinbuchstaben.

Gib bei einer Zeichenkette s die maximale Länge einer Teilzeichenkette zurück, so dass sie höchstens zwei Vorkommen jedes Zeichens enthält.

Beispiel 1:

Eingabe: s = "bcbbbcba"
Ausgabe: 4
Erläuterung:
Die folgende Teilzeichenkette hat eine Länge von 4 und enthält höchstens zwei Vorkommen der einzelnen Zeichen: „bcbbbcba“.
Beispiel 2:

Eingabe: s = "aaaa"
Ausgabe: 2
Erläuterung:
Die folgende Teilzeichenkette hat eine Länge von 2 und enthält höchstens zwei Vorkommen eines jeden Zeichens: „aaaa“.

Beschränkungen:

2 <= s.length <= 100
s besteht nur aus englischen Kleinbuchstaben.


Sie erhalten eine positive ganze Zahl k. Zunächst haben Sie ein Array nums = [1].
Sie können jeden der folgenden Vorgänge beliebig oft (möglicherweise null) am Array ausführen:

Wählen Sie ein beliebiges Element im Array und erhöhen Sie seinen Wert um 1.
Duplizieren Sie ein beliebiges Element im Array und fügen Sie es am Ende des Arrays hinzu.

Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um die Summe der Elemente des endgültigen Arrays größer oder gleich k zu machen.

Beispiel 1:

Eingabe: k = 11
Ausgabe: 5
Erläuterung:
Wir können die folgenden Operationen für das Array nums = [1] ausführen:

Erhöhen Sie das Element dreimal um 1. Das resultierende Array ist nums = [4].
Duplizieren Sie das Element zweimal. Das resultierende Array ist nums = [4,4,4].

Die Summe des endgültigen Arrays beträgt 4 + 4 + 4 = 12, was größer oder gleich k = 11 ist.
Die Gesamtzahl der durchgeführten Operationen beträgt 3 + 2 = 5.

Beispiel 2:

Eingabe: k = 1
Ausgabe: 0
Erläuterung:
Die Summe des ursprünglichen Arrays ist bereits größer oder gleich 1, sodass keine Operationen erforderlich sind.

Einschränkungen:

1 <= k <= 10^5


Das Problem besteht darin, die Häufigkeit von IDs in einer Sammlung zu verfolgen, die sich im Laufe der Zeit ändert. Sie haben zwei ganzzahlige Arrays, nums und freq, mit der gleichen Länge n. Jedes Element in nums stellt eine ID dar, und das entsprechende Element in freq gibt an, wie oft diese ID bei jedem Schritt zur Sammlung hinzugefügt oder daraus entfernt werden soll.

Hinzufügen von IDs: Wenn freq[i] positiv ist, bedeutet dies, dass freq[i]-IDs mit dem Wert nums[i] in Schritt i zur Sammlung hinzugefügt werden.
Entfernen von IDs: Wenn freq[i] negativ ist, bedeutet dies, dass -freq[i] IDs mit dem Wert nums[i] in Schritt i aus der Sammlung entfernt werden.

Gibt ein Array ans der Länge n zurück, wobei ans[i] die Anzahl der häufigsten IDs in der Sammlung nach dem i^-ten Schritt darstellt. Wenn die Sammlung zu irgendeinem Schritt leer ist, sollte ans[i] für diesen Schritt 0 sein.

Beispiel 1:

Eingabe: Nums = [2,3,2,1], Freq = [3,2,-3,1]
Ausgabe: [3,3,2,2]
Erläuterung:
Nach Schritt 0 haben wir 3 IDs mit dem Wert 2. Also ans[0] = 3.
Nach Schritt 1 haben wir 3 IDs mit dem Wert 2 und 2 IDs mit dem Wert 3. Also ans[1] = 3.
Nach Schritt 2 haben wir 2 IDs mit dem Wert 3. Also ans[2] = 2.
Nach Schritt 3 haben wir 2 IDs mit dem Wert 3 und 1 ID mit dem Wert 1. Also ans[3] = 2.

Beispiel 2:

Eingabe: Nums = [5,5,3], Freq = [2,-2,1]
Ausgabe: [2,0,1]
Erläuterung:
Nach Schritt 0 haben wir 2 IDs mit dem Wert 5. Also ans[0] = 2.
Nach Schritt 1 sind keine IDs mehr vorhanden. Also ans[1] = 0.
Nach Schritt 2 haben wir 1 ID mit dem Wert 3. Also ans[2] = 1.

Einschränkungen:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Die Eingabe wird so generiert, dass das Vorkommen einer ID in keinem Schritt negativ ist.

Das Problem beinhaltet die Verfolgung der Häufigkeit von IDs in einer Sammlung, die sich im Laufe der Zeit ändert. Es gibt zwei ganzzahlige Arrays, nums und freq, gleicher Länge n. Jedes Element in nums repräsentiert eine ID, und das entsprechende Element in freq gibt an, wie oft diese ID in jedem Schritt zu der Sammlung hinzugefügt oder daraus entfernt werden soll.

Hinzufügen von IDs: Wenn freq[i] positiv ist, bedeutet dies, dass freq[i] IDs mit dem Wert nums[i] im Schritt i zur Sammlung hinzugefügt werden.
Entfernen von IDs: Wenn freq[i] negativ ist, bedeutet dies, dass -freq[i] IDs mit dem Wert nums[i] im Schritt i aus der Sammlung entfernt werden.

Gib ein Array ans der Länge n zurück, wobei ans[i] die Anzahl der häufigsten IDs in der Sammlung nach dem i-ten Schritt darstellt. Ist die Sammlung zu einem beliebigen Schritt leer, sollte ans[i] für diesen Schritt 0 sein.

Beispiel 1:

Input: nums = [2,3,2,1], freq = [3,2,-3,1]
Output: [3,3,2,2]
Erläuterung:
Nach Schritt 0 haben wir 3 IDs mit dem Wert 2. Daher ist ans[0] = 3.
Nach Schritt 1 haben wir 3 IDs mit dem Wert 2 und 2 IDs mit dem Wert 3. Daher ist ans[1] = 3.
Nach Schritt 2 haben wir 2 IDs mit dem Wert 3. Daher ist ans[2] = 2.
Nach Schritt 3 haben wir 2 IDs mit dem Wert 3 und 1 ID mit dem Wert 1. Daher ist ans[3] = 2.

Beispiel 2:

Input: nums = [5,5,3], freq = [2,-2,1]
Output: [2,0,1]
Erläuterung:
Nach Schritt 0 haben wir 2 IDs mit dem Wert 5. Daher ist ans[0] = 2.
Nach Schritt 1 gibt es keine IDs. Daher ist ans[1] = 0.
Nach Schritt 2 haben wir 1 ID mit dem Wert 3. Daher ist ans[2] = 1.

Einschränkungen:

1 <= nums.length == freq.length <= 10^5
1 <= nums[i] <= 10^5
-10^5 <= freq[i] <= 10^5
freq[i] != 0
Die Eingabe ist so generiert, dass die Vorkommen einer ID zu keinem Zeitpunkt negativ sein werden.


Sie erhalten zwei Arrays mit Zeichenfolgen: wordsContainer und wordsQuery.
Für jede wordsQuery[i] müssen Sie eine Zeichenfolge aus wordsContainer finden, die das längste gemeinsame Suffix mit wordsQuery[i] hat. Wenn es in wordsContainer zwei oder mehr Zeichenfolgen gibt, die das längste gemeinsame Suffix haben, suchen Sie die Zeichenfolge mit der kürzesten Länge. Wenn es zwei oder mehr solcher Zeichenfolgen mit der gleichen kürzesten Länge gibt, suchen Sie die Zeichenfolge, die früher in wordsContainer vorkam.
Gibt ein Array mit Ganzzahlen ans zurück, wobei ans[i] der Index der Zeichenfolge in wordsContainer ist, die das längste gemeinsame Suffix mit wordsQuery[i] hat.

Beispiel 1:

Eingabe: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"]
Ausgabe: [1,1,1]
Erklärung:
Sehen wir uns jedes wordsQuery[i] einzeln an:

Für wordsQuery[0] = "cd" befinden sich Zeichenfolgen aus wordsContainer, die das längste gemeinsame Suffix "cd" aufweisen, an den Indizes 0, 1 und 2. Darunter ist die Antwort die Zeichenfolge an Index 1, da sie mit 3 die kürzeste Länge hat.
Für wordsQuery[1] = "bcd" befinden sich Zeichenfolgen aus wordsContainer, die das längste gemeinsame Suffix "bcd" aufweisen, an den Indizes 0, 1 und 2. Darunter ist die Antwort die Zeichenfolge an Index 1, da sie mit 3 die kürzeste Länge hat.
Für wordsQuery[2] = "xyz" gibt es keine Zeichenfolge aus wordsContainer, die ein gemeinsames Suffix. Daher ist das längste gemeinsame Suffix "", das mit den Zeichenfolgen an den Indizes 0, 1 und 2 geteilt wird. Unter diesen ist die Antwort die Zeichenfolge an Index 1, da sie die kürzeste Länge von 3 hat.

Beispiel 2:

Eingabe: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Ausgabe: [2,0,2]
Erklärung:
Sehen wir uns jede wordsQuery[i] einzeln an:

Für wordsQuery[0] = "gh" befinden sich Zeichenfolgen aus wordsContainer, die das längste gemeinsame Suffix "gh" teilen, an den Indizes 0, 1 und 2. Unter diesen ist die Antwort die Zeichenfolge an Index 2, da sie die kürzeste Länge von 6 hat.
Für wordsQuery[1] = "acbfgh" teilt nur die Zeichenfolge an Index 0 das längste gemeinsame Suffix "fgh". Daher ist es die Antwort, auch wenn die Zeichenfolge am Index 2 kürzer ist.
Für wordsQuery[2] = „acbfegh“ befinden sich Zeichenfolgen von wordsContainer, die das längste gemeinsame Suffix „gh“ aufweisen, an den Indizes 0, 1 und 2. Unter diesen ist die Antwort die Zeichenfolge am Index 2, da sie mit 6 die kürzeste Länge hat.

Einschränkungen:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] besteht nur aus englischen Kleinbuchstaben.
wordsQuery[i] besteht nur aus englischen Kleinbuchstaben.
Die Summe von wordsContainer[i].length beträgt höchstens 5 * 10^5.
Die Summe von wordsQuery[i].length beträgt höchstens 5 * 10^5.

Sie erhalten zwei Arrays von Strings wordsContainer und wordsQuery.
Für jede wordsQuery [i] müssen Sie eine Zeichenfolge aus wordsContainer finden, die das längste gemeinsame Suffix mit wordsQuery [i] hat. Wenn es zwei oder mehr Zeichenfolgen in wordsContainer gibt, die das längste gemeinsame Suffix haben, finden Sie die Zeichenfolge, die die kleinste Länge hat. Wenn es zwei oder mehr solcher Zeichenfolgen gibt, die die gleiche kleinste Länge haben, finden Sie die, die zuvor in Wortencontainer aufgetreten ist.
Geben Sie eine Reihe von Ganzzahlen zurück, wobei ANS [i] der Index der Zeichenfolge in wordsContainer ist, das das längste gemeinsame Suffix mit wordsQuery [i] hat.

Beispiel 1:

Eingabe: wordsContainer = ["abcd","bcd","xbcd"], wordsQuery= ["cd","bcd","xyz"]
Ausgabe: [1,1,1]
Erläuterung der Beispiele:
Schauen wir uns die einzelnen Abfragen separat an:

Für wordsQuery[0] = "cd" befinden sich die Zeichenketten aus wordsContainer, die das längste gemeinsame Suffix „cd“ haben, bei den Indizes 0, 1 und 2. Von diesen ist die Antwort die Zeichenkette mit dem Index 1, da sie die kürzeste Länge von 3 hat.
Für wordsQuery[1] = "bcd" befinden sich die Zeichenketten aus wordsContainer, die das längste gemeinsame Suffix „bcd“ haben, bei den Indizes 0, 1 und 2. Von diesen ist die Antwort die Zeichenkette bei Index 1, da sie die kürzeste Länge von 3 hat.
Für wordsQuery[2] = "xyz" gibt es keine Zeichenfolge aus wordsContainer, die ein gemeinsames Suffix hat. Das längste gemeinsame Suffix ist daher „“, das mit den Zeichenketten bei Index 0, 1 und 2 geteilt wird. Von diesen ist die Antwort die Zeichenkette mit dem Index 1, weil sie die kürzeste Länge von 3 hat.

Beispiel 2:

Eingabe: wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"]
Ausgabe: [2,0,2]
Erläuterung der Beispiele:
Schauen wir uns die einzelnen Abfragen separat an:

Für wordsQuery[0] = "gh" befinden sich die Zeichenketten aus wordsContainer, die das längste gemeinsame Suffix „gh“ haben, bei den Indizes 0, 1 und 2. Von diesen ist die Antwort die Zeichenkette bei Index 2, da sie die kürzeste Länge von 6 hat.
Bei wordsQuery[1] = "acbfgh" hat nur die Zeichenfolge bei Index 0 das längste gemeinsame Suffix „fgh“. Sie ist also die Antwort, auch wenn die Zeichenfolge bei Index 2 kürzer ist.
Für wordsQuery[2] = "acbfegh" befinden sich bei den Indizes 0, 1 und 2 Zeichenketten aus wordsContainer, die das längste gemeinsame Suffix „gh“ haben. Von diesen ist die Antwort die Zeichenkette bei Index 2, da sie die kürzeste Länge von 6 hat.

Einschränkungen:

1 <= wordsContainer.length, wordsQuery.length <= 10^4
1 <= wordsContainer[i].length <= 5 * 10^3
1 <= wordsQuery[i].length <= 5 * 10^3
wordsContainer[i] besteht nur aus englischen Kleinbuchstaben.
WordsQuery [i] besteht nur aus englischen Kleinbuchstaben.
Summe von Wordscontainer [i]. Die Länge ist höchstens 5 * 10^5.
Summe der wordsQuery [i]. Die Länge ist höchstens 5 * 10^5.

Sie erhalten zwei Arrays mit den Zeichenfolgen „wordsContainer“ und „wordsQuery“.
Für jede WordQuery[i] müssen Sie eine Zeichenfolge aus WordContainer finden, die das längste gemeinsame Suffix mit WordQuery[i] hat. Wenn es in WordsContainer zwei oder mehr Zeichenfolgen gibt, die das längste gemeinsame Suffix haben, suchen Sie die Zeichenfolge mit der kleinsten Länge. Wenn es zwei oder mehr solcher Zeichenfolgen mit der gleichen kleinsten Länge gibt, suchen Sie die Zeichenfolge, die zuvor im WordContainer aufgetreten ist.
Gibt ein Array von ganzen Zahlen ans zurück, wobei ans[i] der Index der Zeichenfolge in WordsContainer ist, die das längste gemeinsame Suffix mit WordsQuery[i] hat.

Beispiel 1:

Eingabe: WordsContainer = [„abcd“, „bcd“, „xbcd“], WordsQuery = [„cd“, „bcd“, „xyz“]
Ausgabe: [1,1,1]
Erläuterung:
Schauen wir uns jedes Wort anQuery[i] separat:

Für „wordsQuery[0] = „cd““ befinden sich Zeichenfolgen aus „wordsContainer“, die das längste gemeinsame Suffix „cd“ haben, an den Indizes 0, 1 und 2. Unter diesen ist die Antwort die Zeichenfolge an Index 1, da sie die kürzeste Länge hat 3.
Für „wordsQuery[1] = „bcd“ befinden sich Zeichenfolgen aus „wordsContainer“, die das längste gemeinsame Suffix „bcd“ haben, an den Indizes 0, 1 und 2. Unter diesen ist die Antwort die Zeichenfolge an Index 1, da sie die kürzeste Länge hat 3.
Für WordsQuery[2] = „xyz“ gibt es keine Zeichenfolge aus WordsContainer, die ein gemeinsames Suffix hat. Daher ist das längste gemeinsame Suffix „“, das mit Zeichenfolgen an Index 0, 1 und 2 geteilt wird. Unter diesen ist die Antwort die Zeichenfolge an Index 1, da sie die kürzeste Länge von 3 hat.

Beispiel 2:

Eingabe: WordsContainer = ["abcdefgh", "poiuygh", "ghghgh"], WordsQuery = ["gh", "acbfgh", "acbfegh"]
Ausgabe: [2,0,2]
Erläuterung:
Schauen wir uns jedes Wort anQuery[i] separat:

Für „wordsQuery[0] = „gh“ befinden sich Zeichenfolgen aus „wordsContainer“, die das längste gemeinsame Suffix „gh“ haben, an den Indizes 0, 1 und 2. Unter diesen ist die Antwort die Zeichenfolge an Index 2, da sie die kürzeste Länge hat 6.
Für WordsQuery[1] = „acbfgh“ hat nur die Zeichenfolge bei Index 0 das längste gemeinsame Suffix „fgh“. Daher ist es die Antwort, auch wenn die Zeichenfolge bei Index 2 kürzer ist.
Für „wordsQuery[2] = „acbfegh“ befinden sich Zeichenfolgen aus „wordsContainer“, die das längste gemeinsame Suffix „gh“ haben, an den Indizes 0, 1 und 2. Unter diesen ist die Antwort die Zeichenfolge an Index 2, da sie die kürzeste Länge hat 6.

Einschränkungen:

1 <= wörterContainer.länge, wörterQuery.länge <= 10^4
1 <= WordsContainer[i].length <= 5 * 10^3
1 <= WordsQuery[i].length <= 5 * 10^3
WordsContainer[i] besteht nur aus englischen Kleinbuchstaben.
WordsQuery[i] besteht nur aus englischen Kleinbuchstaben.
Die Summe der WörterContainer[i].length beträgt höchstens 5 * 10^5.
Die Summe der WörterQuery[i].length beträgt höchstens 5 * 10^5.


Eine ganze Zahl, die durch die Summe ihrer Ziffern teilbar ist, wird Harshad-Zahl genannt. Sie erhalten eine ganze Zahl x. Gibt die Summe der Ziffern von x zurück, wenn x eine Harshad-Zahl ist, andernfalls wird -1 zurückgegeben.

Beispiel 1:

Eingabe: x = 18
Ausgabe: 9
Erläuterung:
Die Ziffernsumme von x ist 9. 18 ist durch 9 teilbar. 18 ist also eine Harshad-Zahl und die Antwort ist 9.

Beispiel 2:

Eingabe: x = 23
Ausgabe: -1
Erläuterung:
Die Ziffernsumme von x ist 5. 23 ist nicht durch 5 teilbar. 23 ist also keine Harshad-Zahl und die Antwort ist -1.

Einschränkungen:

1 <= x <= 100


Sie erhalten ein binäres Array nums.
Wir nennen ein Subarray alternierend, wenn keine zwei benachbarten Elemente im Subarray den gleichen Wert haben.
Gibt die Anzahl der alternierenden Subarrays in Zahlen zurück.

Beispiel 1:

Eingabe: nums = [0,1,1,1]
Ausgabe: 5
Erläuterung:
Die folgenden Subarrays wechseln sich ab: [0], [1], [1], [1] und [0,1].

Beispiel 2:

Eingabe: nums = [1,0,1,0]
Ausgabe: 10
Erläuterung:
Jedes Unterarray des Arrays ist alternierend. Es gibt 10 mögliche Unterarrays, die wir auswählen können.

Einschränkungen:

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

Sie erhalten eine ein binäres Array nums.
Wir nennen eine Unterarray, ein Unterarray abwechselnd, wenn keine zwei benachbarten Elemente im Subtarray den gleichen Wert haben.
Geben Sie die Anzahl der alternierenden Subtarrays in NUMS zurück.

Beispiel 1:

Eingabe: nums = [0,1,1,1]
Ausgabe: 5
Erläuterung:
Die folgenden Subtarrays wechseln sich abwechselnd: [0], [1], [1], [1] und [0,1].

Beispiel 2:

Eingabe: nums = [1,0,1,0]
Ausgabe: 10
Erläuterung:
Jedes Subtarray des Arrays wechselt sich. Es gibt 10 mögliche Subtarrays, die wir wählen können.

Einschränkungen:

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


Sie erhalten ein Array von Punkten, die ganzzahlige Koordinaten einiger Punkte auf einer 2D-Ebene darstellen, wobei points[i] = [x_i, y_i].
Die Entfernung zwischen zwei Punkten wird als ihre Manhattan-Entfernung definiert.
Gibt den minimal möglichen Wert für den maximalen Abstand zwischen zwei beliebigen Punkten zurück, indem genau ein Punkt entfernt wird.

Beispiel 1:

Eingabe: points = [[3,10],[5,15],[10,2],[4,4]]
Ausgang: 12
Erklärung:
Die maximale Entfernung nach dem Entfernen der einzelnen Punkte ist wie folgt:

Nach dem Entfernen des 0^ten Punktes beträgt der maximale Abstand zwischen den Punkten (5, 15) und (10, 2), d.h. |5 - 10| + |15 - 2| = 18.
Nach dem Entfernen des 1^. Punktes beträgt der maximale Abstand zwischen den Punkten (3, 10) und (10, 2), also |3 - 10| + |10 - 2| = 15.
Nach dem Entfernen des 2^. Punktes beträgt der maximale Abstand zwischen den Punkten (5, 15) und (4, 4) |5 - 4| + |15 - 4| = 12.
Nach dem Entfernen des 3^. Punktes beträgt der maximale Abstand zwischen den Punkten (5, 15) und (10, 2), d.h. |5 - 10| + |15 - 2| = 18.

12 ist der minimal mögliche maximale Abstand zwischen zwei beliebigen Punkten, nachdem genau ein Punkt entfernt wurde.

Beispiel 2:

Eingabe: points = [[1,1],[1,1],[1,1]]
Ausgang: 0
Erklärung:
Wenn Sie einen der Punkte entfernen, ergibt sich der maximale Abstand zwischen zwei beliebigen Punkten von 0.

Zwänge:

3 <= points.length <= 10^5
points[i].length == 2
1 <= points[i][0], points[i][1] <= 10^8

Sie erhalten ein Array-Punkte, die ganzzahlige Koordinaten einiger Punkte auf einer 2D-Ebene darstellen, wobei Punkte[i] = [x_i, y_i].
Der Abstand zwischen zwei Punkten wird als Manhattan-Abstand definiert.
Gibt den minimal möglichen Wert für den maximalen Abstand zwischen zwei beliebigen Punkten zurück, indem genau ein Punkt entfernt wird.

Beispiel 1:

Eingabe: Punkte = [[3,10],[5,15],[10,2],[4,4]]
Ausgabe: 12
Erläuterung:
Der maximale Abstand nach dem Entfernen jedes Punktes beträgt:

Nach dem Entfernen des 0^-ten Punkts liegt der maximale Abstand zwischen den Punkten (5, 15) und (10, 2), also |5 - 10| + |15 - 2| = 18.
Nach dem Entfernen des 1^. Punktes liegt der maximale Abstand zwischen den Punkten (3, 10) und (10, 2), also |3 - 10| + |10 - 2| = 15.
Nach dem Entfernen des 2. Punktes beträgt der maximale Abstand zwischen den Punkten (5, 15) und (4, 4) |5 - 4| + |15 - 4| = 12.
Nach dem Entfernen des 3. Punktes liegt der maximale Abstand zwischen den Punkten (5, 15) und (10, 2), also |5 - 10| + |15 - 2| = 18.

12 ist der minimal mögliche maximale Abstand zwischen zwei beliebigen Punkten, nachdem genau ein Punkt entfernt wurde.

Beispiel 2:

Eingabe: Punkte = [[1,1],[1,1],[1,1]]
Ausgabe: 0
Erläuterung:
Das Entfernen eines Punktes führt dazu, dass der maximale Abstand zwischen zwei beliebigen Punkten 0 beträgt.

Einschränkungen:

3 <= Punkte.Länge <= 10^5
Punkte[i].Länge == 2
1 <= Punkte[i][0], Punkte[i][1] <= 10^8


Sie erhalten ein Array mit ganzen nums. Geben Sie die Länge des längsten Subarrays von nums zurück, das entweder streng ansteigend oder streng abnehmend ist.

Beispiel 1:

Eingabe: nums = [1,4,3,3,2]
Ausgabe: 2
Erläuterung:
Die streng ansteigenden Unterarrays von nums sind [1], [2], [3], [3], [4] und [1,4].
Die streng abnehmenden Unterarrays von nums sind [1], [2], [3], [3], [4], [3,2] und [4,3].
Daher geben wir 2 zurück.

Beispiel 2:

Eingabe: nums = [3,3,3,3]
Ausgabe: 1
Erläuterung:
Die streng ansteigenden Unterarrays von nums sind [3], [3], [3] und [3].
Die streng abnehmenden Unterarrays von nums sind [3], [3], [3] und [3].
Daher geben wir 1 zurück.

Beispiel 3:

Eingabe: nums = [3,2,1]
Ausgabe: 3
Erläuterung:
Die streng ansteigenden Unterarrays von nums sind [3], [2] und [1].
Die streng abnehmenden Unterarrays von nums sind [3], [2], [1], [3,2], [2,1] und [3,2,1].
Daher geben wir 3 zurück.

Einschränkungen:

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

Sie erhalten ein Array von ganzen Zahlen nums. Gibt die Länge des längsten Unterarrays von nums zurück, das entweder streng ansteigend oder streng abnehmend ist.

Beispiel 1:

Eingabe: nums = [1,4,3,3,2]
Ausgang: 2
Erklärung:
Die streng ansteigenden Subarrays von nums sind [1], [2], [3], [3], [4] und [1,4].
Die streng absteigenden Subarrays von nums sind [1], [2], [3], [3], [4], [3,2] und [4,3].
Daher geben wir 2 zurück.

Beispiel 2:

Eingabe: nums = [3,3,3,3]
Ausgang: 1
Erklärung:
Die streng ansteigenden Subarrays von nums sind [3], [3], [3] und [3].
Die streng abnehmenden Subarrays von nums sind [3], [3], [3] und [3].
Daher geben wir 1 zurück.

Beispiel 3:

Eingabe: nums = [3,2,1]
Ausgang: 3
Erklärung:
Die streng ansteigenden Subarrays von nums sind [3], [2] und [1].
Die streng abnehmenden Subarrays von nums sind [3], [2], [1], [3,2], [2,1] und [3,2,1].
Daher geben wir 3 zurück.

Zwänge:

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

Sie erhalten ein Array mit ganzen nums. Gibt die Länge des längsten Unterarrays zurück, das entweder streng ansteigend oder streng abnehmend ist.

Beispiel 1:

Eingabe: nums = [1,4,3,3,2]
Ausgabe: 2
Erläuterung:
Die streng ansteigenden Unterarrays sind [1], [2], [3], [3], [4] und [1,4].
Die streng abnehmenden Unterarrays von nums sind [1], [2], [3], [3], [4], [3,2] und [4,3].
Daher geben wir 2 zurück.

Beispiel 2:

Eingabe: nums = [3,3,3,3]
Ausgabe: 1
Erläuterung:
Die streng ansteigenden Unterarrays sind [3], [3], [3] und [3].
Die streng abnehmenden Unterarrays von nums sind [3], [3], [3] und [3].
Daher geben wir 1 zurück.

Beispiel 3:

Eingabe: nums = [3,2,1]
Ausgabe: 3
Erläuterung:
Die streng ansteigenden Unterarrays sind [3], [2] und [1].
Die streng abnehmenden Unterarrays von nums sind [3], [2], [1], [3,2], [2,1] und [3,2,1].
Daher geben wir 3 zurück.

Einschränkungen:

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


Du hast einen String s und eine ganze Zahl k.
Definiere eine Funktion distance(s_1, s_2) zwischen zwei Strings s_1 und s_2 gleicher Länge n als:

Die Summe der minimalen Entfernungen zwischen s_1[i] und s_2[i], wenn die Buchstaben von 'a' bis 'z' in einer zyklischen Reihenfolge angeordnet sind, für alle i im Bereich [0, n - 1].

Zum Beispiel, distance("ab", "cd") == 4 und distance("a", "z") == 1.
Du kannst jeden Buchstaben von s in einen anderen Kleinbuchstaben des englischen Alphabets beliebig oft ändern.
Gib einen String zurück, der den lexikographisch kleinsten String t darstellt, den du nach einigen Änderungen erhalten kannst, so dass distance(s, t) <= k.

Beispiel 1:

Input: s = "zbbz", k = 3
Output: "aaaz"
Erklärung:
Ändere s zu "aaaz". Die Entfernung zwischen "zbbz" und "aaaz" beträgt k = 3.

Beispiel 2:

Input: s = "xaxcd", k = 4
Output: "aawcd"
Erklärung:
Die Entfernung zwischen "xaxcd" und "aawcd" beträgt k = 4.

Beispiel 3:

Input: s = "lol", k = 0
Output: "lol"
Erklärung:
Es ist unmöglich, irgendein Zeichen zu ändern, da k = 0.

Constraints:

1 <= s.length <= 100
0 <= k <= 2000
s besteht nur aus Kleinbuchstaben des englischen Alphabets.

Sie erhalten eine Zeichenfolge s und eine Ganzzahl k.
Definieren Sie eine Funktion distance(s_1, s_2) zwischen zwei Strings s_1 und s_2 gleicher Länge n als:

Die Summe des Mindestabstands zwischen s_1[i] und s_2[i], wenn die Zeichen von „a“ bis „z“ in zyklischer Reihenfolge angeordnet sind, für alle i im Bereich [0, n – 1].

Beispielsweise ist distance("ab", "cd") == 4 und distance("a", "z") == 1.
Sie können jeden Buchstaben des s beliebig oft in einen anderen englischen Kleinbuchstaben ändern.
Gibt einen String zurück, der den lexikografisch kleinsten String t angibt, den Sie nach einigen Änderungen erhalten können, sodass distance(s, t) <= k ist.

Beispiel 1:

Eingabe: s = „zbbz“, k = 3
Ausgabe: „aaaz“
Erläuterung:
Ändern Sie s in „aaaz“. Der Abstand zwischen „zbbz“ und „aaaz“ beträgt k = 3.

Beispiel 2:

Eingabe: s = „xaxcd“, k = 4
Ausgabe: „aawcd“
Erläuterung:
Der Abstand zwischen „xaxcd“ und „aawcd“ beträgt k = 4.

Beispiel 3:

Eingabe: s = „lol“, k = 0
Ausgabe: „lol“
Erläuterung:
Es ist unmöglich, irgendein Zeichen zu ändern, da k = 0.

Einschränkungen:

1 <= s.length <= 100
0 <= k <= 2000
s besteht nur aus englischen Kleinbuchstaben.

Sie erhalten eine Zeichenkette s und eine ganze Zahl k.
Definieren Sie eine Funktion distance(s_1, s_2) zwischen zwei Strings s_1 und s_2 der gleichen Länge n als:

Die Summe des minimalen Abstands zwischen s_1[i] und s_2[i], wenn die Zeichen von 'a' bis 'z' in einer zyklischen Reihenfolge angeordnet sind, für alle i im Bereich [0, n - 1].

Zum Beispiel: Abstand("ab", "cd") == 4 und Abstand("a", "z") == 1.
Sie können jeden Buchstaben von s beliebig oft in einen anderen englischen Kleinbuchstaben ändern.
Geben Sie eine Zeichenkette zurück, die die lexikografisch kleinste Zeichenkette t angibt, die Sie nach einigen Änderungen erhalten können, so dass distance(s, t) <= k ist.

Beispiel 1:

Eingabe: s = "zbbz", k = 3
Ausgabe: „aaaz“
Erläuterung:
Ändere s in „aaaz“. Der Abstand zwischen „zbbz“ und „aaaz“ ist gleich k = 3.

Beispiel 2:

Eingabe: s = "xaxcd", k = 4
Ausgabe: „aawcd“
Erläuterung:
Der Abstand zwischen „xaxcd“ und „aawcd“ ist gleich k = 4.

Beispiel 3:

Eingabe: s = "lol", k = 0
Ausgabe: „lol“
Erläuterung:
Es ist unmöglich, irgendein Zeichen zu ändern, da k = 0 ist.

Beschränkungen:

1 <= s.length <= 100
0 <= k <= 2000
s besteht nur aus englischen Kleinbuchstaben.


Sie erhalten ein ganzzahliges Array nums und eine nicht negative ganze Zahl k. In einem Vorgang können Sie jedes Element um 1 erhöhen oder verringern.
Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um den Median der Zahlen gleich k zu machen.
Der Median eines Arrays wird als das mittlere Element des Arrays definiert, wenn es in nicht absteigender Reihenfolge sortiert ist. Wenn es zwei Möglichkeiten für einen Median gibt, wird der größere der beiden Werte genommen.

Beispiel 1:

Eingabe: nums = [2,5,6,8,5], k = 4
Ausgabe: 2
Erläuterung:
Wir können eins von nums[1] und nums[4] subtrahieren, um [2, 4, 6, 8, 4] zu erhalten. Der Median des resultierenden Arrays ist gleich k.

Beispiel 2:

Eingabe: nums = [2,5,6,8,5], k = 7
Ausgabe: 3
Erläuterung:
Wir können zweimal eins zu nums[1] und einmal eins zu nums[2] hinzufügen, um [2, 7, 7, 8, 5] zu erhalten.

Beispiel 3:

Eingabe: nums = [1,2,3,4,5,6], k = 4
Ausgabe: 0
Erläuterung:
Der Median des Arrays ist bereits gleich k.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums und eine nicht-negative Ganzzahl k. In einem Arbeitsgang können Sie jedes Element um 1 vergrößern oder verkleinern.
Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um den Median der nums gleich k zu machen.
Der Median eines Arrays wird als mittleres Element des Arrays definiert, wenn es in nicht absteigender Reihenfolge sortiert wird. Wenn es zwei Möglichkeiten für einen Median gibt, wird der größere der beiden Werte verwendet.

Beispiel 1:

Eingabe: nums = [2,5,6,8,5], k = 4
Ausgang: 2
Erklärung:
Wir können eins von nums[1] und nums[4] subtrahieren, um [2, 4, 6, 8, 4] zu erhalten. Der Median des resultierenden Arrays ist gleich k.

Beispiel 2:

Eingabe: nums = [2,5,6,8,5], k = 7
Ausgang: 3
Erklärung:
Wir können zweimal eins zu nums[1] addieren und einmal eins zu nums[2] addieren, um [2, 7, 7, 8, 5] zu erhalten.

Beispiel 3:

Eingabe: nums = [1,2,3,4,5,6], k = 4
Ausgang: 0
Erklärung:
Der Median des Arrays ist bereits gleich k.

Zwänge:

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

Sie erhalten ein ganzzahliges Array nums und eine nicht negative ganze Zahl k. In einem Vorgang können Sie jedes Element um 1 erhöhen oder verringern.
Gibt die minimale Anzahl von Operationen zurück, die erforderlich sind, um den Median der Zahlen gleich k zu machen.
Der Median eines Arrays wird als das mittlere Element des Arrays definiert, wenn es in nicht absteigender Reihenfolge sortiert ist. Wenn es zwei Möglichkeiten für einen Median gibt, wird der größere der beiden Werte genommen.

Beispiel 1:

Eingabe: Zahlen = [2,5,6,8,5], k = 4
Ausgabe: 2
Erläuterung:
Wir können eins von nums[1] und nums[4] subtrahieren, um [2, 4, 6, 8, 4] zu erhalten. Der Median des resultierenden Arrays ist gleich k.

Beispiel 2:

Eingabe: Zahlen = [2,5,6,8,5], k = 7
Ausgabe: 3
Erläuterung:
Wir können zweimal eins zu nums[1] und einmal eins zu nums[2] hinzufügen, um [2, 7, 7, 8, 5] zu erhalten.

Beispiel 3:

Eingabe: Zahlen = [1,2,3,4,5,6], k = 4
Ausgabe: 0
Erläuterung:
Der Median des Arrays ist bereits gleich k.

Einschränkungen:

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


Sie erhalten eine Zeichenfolge s, die eine 12-stündige Formatierungszeit darstellt, bei der einige der Ziffern (möglicherweise keine) durch ein "?" ersetzt werden.
12-Stunden-Zeiten werden als "HH:MM" formatiert, wobei HH zwischen 00 und 11 und MM zwischen 00 und 59 liegt. Die früheste 12-Stunden-Zeit ist 00:00, und die späteste ist 11:59.
Sie müssen alle "?"-Zeichen in s durch Ziffern ersetzen, so dass die Zeit, die wir durch die resultierende Zeichenfolge erhalten, eine gültige Formatierungszeit von 12 Stunden ist und die spätestmögliche ist.
Geben Sie die resultierende Zeichenfolge zurück.

Beispiel 1:

Eingabe: s = "1?:?4"
Ausgabe: "11:54"
Beschreibung: Die späteste 12-Stunden-Formatierungszeit, die wir durch das Ersetzen von "?"-Zeichen erreichen können, ist "11:54".

Beispiel 2:

Eingabe: s = "0?:5?"
Ausgabe: "09:59"
Erklärung: Die späteste 12-Stunden-Formatierungszeit, die wir durch das Ersetzen von "?"-Zeichen erreichen können, ist "09:59".

Zwänge:

s.length == 5
s[2] ist gleich dem Zeichen ":".
Alle Zeichen außer s[2] sind Ziffern oder "?"-Zeichen.
Die Eingabe wird so generiert, dass es mindestens eine Zeit zwischen "00:00" und "11:59" gibt, die Sie nach dem Ersetzen der Zeichen "?" erhalten können.

Sie erhalten eine Zeichenfolge, die eine Zeit im 12-Stunden-Format darstellt, wobei einige Ziffern (möglicherweise keine) durch ein „?“ ersetzt werden.
12-Stunden-Zeiten werden als „HH:MM“ formatiert, wobei HH zwischen 00 und 11 und MM zwischen 00 und 59 liegt. Die früheste 12-Stunden-Zeit ist 00:00 und die späteste 11:59.
Sie müssen alle „?“ ersetzen. Zeichen in s mit Ziffern, so dass die Zeit, die wir durch die resultierende Zeichenfolge erhalten, eine gültige Zeit im 12-Stunden-Format ist und die späteste mögliche ist.
Gibt die resultierende Zeichenfolge zurück.

Beispiel 1:

Eingabe: s = „1?:?4“
Ausgabe: „11:54“
Erläuterung: Die späteste 12-Stunden-Formatzeit, die wir durch Ersetzen von „?“ erreichen können. Zeichen ist „11:54“.

Beispiel 2:

Eingabe: s = „0?:5?“
Ausgabe: „09:59“
Erläuterung: Die späteste 12-Stunden-Formatzeit, die wir durch Ersetzen von „?“ erreichen können. Zeichen ist „09:59“.

Einschränkungen:

s.Länge == 5
s[2] ist gleich dem Zeichen „:“.
Alle Zeichen außer s[2] sind Ziffern oder „?“ Charaktere.
Die Eingabe wird so generiert, dass es mindestens eine Uhrzeit zwischen „00:00“ und „11:59“ gibt, die Sie nach dem Ersetzen des „?“ erhalten können. Charaktere.


Du hast ein ganzzahliges Array nums.
Gib eine Ganzzahl zurück, die die maximale Distanz zwischen den Indizes von zwei (nicht unbedingt unterschiedlichen) Primzahlen in nums ist.

Beispiel 1:

Eingabe: nums = [4,2,9,5,3]
Ausgabe: 3
Erklärung: nums[1], nums[3], und nums[4] sind Primzahlen. Die Antwort ist also |4 - 1| = 3.

Beispiel 2:

Eingabe: nums = [4,8,2,8]
Ausgabe: 0
Erklärung: nums[2] ist eine Primzahl. Da es nur eine Primzahl gibt, ist die Antwort |2 - 2| = 0.

Bedingungen:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
Die Eingabe ist so erstellt, dass die Anzahl der Primzahlen in nums mindestens eins ist.

Sie erhalten ein ganzzahliges Array mit Zahlen.
Gibt eine Ganzzahl zurück, die den maximalen Abstand zwischen den Indizes zweier (nicht unbedingt unterschiedlicher) Primzahlen in Zahlen darstellt.

Beispiel 1:

Eingabe: nums = [4,2,9,5,3]
Ausgabe: 3
Erläuterung: Zahlen[1], Zahlen[3] und Zahlen[4] sind Primzahlen. Die Antwort lautet also |4 - 1| = 3.

Beispiel 2:

Eingabe: nums = [4,8,2,8]
Ausgabe: 0
Erläuterung: nums[2] ist eine Primzahl. Da es nur eine Primzahl gibt, lautet die Antwort |2 - 2| = 0.

Einschränkungen:

1 <= nums.length <= 3 * 10^5
1 <= nums[i] <= 100
Die Eingabe wird so generiert, dass die Anzahl der Primzahlen in den Zahlen mindestens eins beträgt.


Sie erhalten ein ganzzahliges Array coins, das Münzen mit unterschiedlichen Nennwerten darstellt, und einen ganzzahligen Wert k.
Sie haben eine unendliche Anzahl von Münzen jeder Nennwert. Es ist jedoch nicht erlaubt, Münzen mit unterschiedlichen Nennwerten zu kombinieren.
Geben Sie den k-ten kleinsten Betrag zurück, der mit diesen Münzen hergestellt werden kann.

Beispiel 1:

Eingabe: coins = [3,6,9], k = 3
Ausgabe: 9
Erklärung: Die gegebenen Münzen können die folgenden Beträge ergeben:
Münze 3 erzeugt Vielfache von 3: 3, 6, 9, 12, 15, usw.
Münze 6 erzeugt Vielfache von 6: 6, 12, 18, 24, usw.
Münze 9 erzeugt Vielfache von 9: 9, 18, 27, 36, usw.
Alle zusammen erzeugen: 3, 6, 9, 12, 15, usw.

Beispiel 2:

Eingabe: coins = [5,2], k = 7
Ausgabe: 12
Erklärung: Die gegebenen Münzen können die folgenden Beträge ergeben:
Münze 5 erzeugt Vielfache von 5: 5, 10, 15, 20, usw.
Münze 2 erzeugt Vielfache von 2: 2, 4, 6, 8, 10, 12, usw.
Alle zusammen erzeugen: 2, 4, 5, 6, 8, 10, 12, 14, 15, usw.

Einschränkungen:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins enthält paarweise verschiedene ganze Zahlen.

Sie erhalten eine ganzzahlige Anordnung von Münzen, die Münzen verschiedener Nennwerte darstellen, und eine ganze Zahl k.
Sie haben eine unendliche Anzahl von Münzen jedes Wertes. Es ist jedoch nicht erlaubt, Münzen verschiedener Nennwerte zu kombinieren.
Geben Sie den k^-ten kleinsten Betrag zurück, der mit diesen Münzen gebildet werden kann.

Beispiel 1:

Eingabe: coins = [3,6,9], k = 3
Ausgabe:  9
Erläuterung: Die gegebenen Münzen können die folgenden Beträge ergeben:
Münze 3 ergibt Vielfache von 3: 3, 6, 9, 12, 15, usw.
Münze 6 ergibt das Vielfache von 6: 6, 12, 18, 24, usw.
Münze 9 ergibt das Vielfache von 9: 9, 18, 27, 36, usw.
Alle Münzen zusammen ergeben: 3, 6, 9, 12, 15, usw.

Beispiel 2:

Eingabe: coins = [5,2], k = 7
Ausgabe: 12
Erläuterung: Die gegebenen Münzen können die folgenden Beträge ergeben:
Münze 5 ergibt Vielfache von 5: 5, 10, 15, 20, usw.
Münze 2 ergibt das Vielfache von 2: 2, 4, 6, 8, 10, 12, usw.
Alle Münzen zusammen ergeben: 2, 4, 5, 6, 8, 10, 12, 14, 15, usw.

Beschränkungen:

1 <= coins.length <= 15
1 <= coins[i] <= 25
1 <= k <= 2 * 10^9
coins enthält paarweise unterschiedliche ganze Zahlen.

Sie erhalten ein ganzzahliges Array von Münzen, das Münzen verschiedener Nennwerte darstellt, und eine ganze Zahl k.
Sie haben unendlich viele Münzen jedes Nennwerts. Es ist jedoch nicht gestattet, Münzen unterschiedlicher Stückelung zu kombinieren.
Geben Sie den k^kleinsten Betrag zurück, der mit diesen Münzen verdient werden kann.

Beispiel 1:

Eingabe: Münzen = [3,6,9], k = 3
Ausgabe: 9
Erläuterung: Die gegebenen Münzen können folgende Beträge ergeben:
Münze 3 ergibt ein Vielfaches von 3: 3, 6, 9, 12, 15 usw.
Münze 6 ergibt ein Vielfaches von 6: 6, 12, 18, 24 usw.
Münze 9 ergibt ein Vielfaches von 9: 9, 18, 27, 36 usw.
Alle Münzen zusammen ergeben: 3, 6, 9, 12, 15 usw.

Beispiel 2:

Eingabe: Münzen = [5,2], k = 7
Ausgabe: 12
Erläuterung: Die gegebenen Münzen können folgende Beträge ergeben:
Münze 5 ergibt ein Vielfaches von 5: 5, 10, 15, 20 usw.
Münze 2 ergibt ein Vielfaches von 2: 2, 4, 6, 8, 10, 12 usw.
Alle Münzen zusammen ergeben: 2, 4, 5, 6, 8, 10, 12, 14, 15 usw.

Einschränkungen:

1 <= Münzen.Länge <= 15
1 <= Münzen[i] <= 25
1 <= k <= 2 * 10^9
Münzen enthalten paarweise unterschiedliche ganze Zahlen.


Sie erhalten zwei Arrays nums und andValues der Länge n bzw. m.
Der Wert eines Arrays entspricht dem letzten Element dieses Arrays.
Sie müssen nums in m disjunkte zusammenhängende Subarrays aufteilen, sodass für das i^-te Subarray [l_i, r_i] das bitweise UND der Subarray-Elemente gleich andValues[i] ist, mit anderen Worten, nums[l_i] & nums[ l_i + 1] & ... & nums[r_i] == andValues[i] für alle 1 <= i <= m, wobei & den bitweisen UND-Operator darstellt.
Gibt die kleinstmögliche Summe der Werte der m Subarrays zurück, in die Nums unterteilt ist. Wenn es nicht möglich ist, Nums in m Subarrays aufzuteilen, die diese Bedingungen erfüllen, wird -1 zurückgegeben.

Beispiel 1:

Eingabe: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Ausgabe: 12
Erläuterung:
Die einzig mögliche Möglichkeit, Zahlen zu dividieren, ist:

[1,4] als 1 & 4 == 0.
[3] da das bitweise UND eines einzelnen Element-Subarrays dieses Element selbst ist.
[3] da das bitweise UND eines einzelnen Element-Subarrays dieses Element selbst ist.
[2] da das bitweise UND eines einzelnen Element-Subarrays dieses Element selbst ist.

Die Summe der Werte für diese Subarrays beträgt 4 + 3 + 3 + 2 = 12.

Beispiel 2:

Eingabe: Zahlen = [2,3,5,7,7,7,5] und Werte = [0,7,5]
Ausgabe: 17
Erläuterung:
Es gibt drei Möglichkeiten, Zahlen zu dividieren:

[[2,3,5],[7,7,7],[5]] mit der Summe der Werte 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] mit der Summe der Werte 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] mit der Summe der Werte 7 + 7 + 5 == 19.

Die minimal mögliche Summe der Werte beträgt 17.

Beispiel 3:

Eingabe: nums = [1,2,3,4], andValues = [2]
Ausgabe: -1
Erläuterung:
Das bitweise UND der gesamten Array-Zahlen ist 0. Da es keine Möglichkeit gibt, Zahlen in ein einzelnes Unterarray aufzuteilen, um das bitweise UND der Elemente 2 zu erhalten, geben Sie -1 zurück.

Einschränkungen:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5

Sie erhalten zwei Arrays nums und andValues der Länge n bzw. m.
Der Wert eines Arrays entspricht dem letzten Element dieses Arrays.
Sie müssen nums in m disjunkte zusammenhängende Subarrays aufteilen, sodass für das i^-te Subarray [l_i, r_i] das bitweise UND der Subarray-Elemente gleich andValues[i] ist, mit anderen Worten, nums[l_i] & nums[ l_i + 1] & ... & nums[r_i] == andValues[i] für alle 1 <= i <= m, wobei & den bitweisen UND-Operator darstellt.
Gibt die minimal mögliche Summe der Werte der m Subarrays zurück, in die Nums unterteilt ist. Wenn es nicht möglich ist, Nums in m Subarrays aufzuteilen, die diese Bedingungen erfüllen, wird -1 zurückgegeben.

Beispiel 1:

Eingabe: nums = [1,4,3,3,2], andValues = [0,3,3,2]
Ausgabe: 12
Erläuterung:
Die einzig mögliche Möglichkeit, Zahlen zu dividieren, ist:

[1,4] als 1 & 4 == 0.
[3] da das bitweise UND eines einzelnen Element-Subarrays dieses Element selbst ist.
[3] da das bitweise UND eines einzelnen Element-Subarrays dieses Element selbst ist.
[2] da das bitweise UND eines einzelnen Element-Subarrays dieses Element selbst ist.

Die Summe der Werte für diese Subarrays beträgt 4 + 3 + 3 + 2 = 12.

Beispiel 2:

Eingabe: Zahlen = [2,3,5,7,7,7,5] und Werte = [0,7,5]
Ausgabe: 17
Erläuterung:
Es gibt drei Möglichkeiten, Zahlen zu dividieren:

[[2,3,5],[7,7,7],[5]] mit der Summe der Werte 5 + 7 + 5 == 17.
[[2,3,5,7],[7,7],[5]] mit der Summe der Werte 7 + 7 + 5 == 19.
[[2,3,5,7,7],[7],[5]] mit der Summe der Werte 7 + 7 + 5 == 19.

Die minimal mögliche Summe der Werte beträgt 17.

Beispiel 3:

Eingabe: nums = [1,2,3,4], andValues = [2]
Ausgabe: -1
Erläuterung:
Das bitweise UND der gesamten Array-Zahlen ist 0. Da es keine Möglichkeit gibt, Zahlen in ein einzelnes Unterarray aufzuteilen, um das bitweise UND der Elemente 2 zu erhalten, geben Sie -1 zurück.

Einschränkungen:

1 <= n == nums.length <= 10^4
1 <= m == andValues.length <= min(n, 10)
1 <= nums[i] < 10^5
0 <= andValues[j] < 10^5


Sie erhalten ein Integer-Array „nums“, das positive ganze Zahlen enthält. Wir definieren eine Funktion encrypt so, dass encrypt(x) jede Ziffer in x durch die größte Ziffer in x ersetzt. Beispiel: encrypt(523) = 555 und encrypt(213) = 333.
Gibt die Summe der verschlüsselten Elemente zurück.

Beispiel 1:

Eingabe: nums = [1,2,3]
Ausgabe: 6
Erläuterung: Die verschlüsselten Elemente sind [1,2,3]. Die Summe der verschlüsselten Elemente beträgt 1 + 2 + 3 == 6.

Beispiel 2:

Eingabe: nums = [10,21,31]
Ausgabe: 66
Erläuterung: Die verschlüsselten Elemente sind [11,22,33]. Die Summe der verschlüsselten Elemente beträgt 11 + 22 + 33 == 66.

Einschränkungen:

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

Sie erhalten ein ganzzahliges Array nums, das positive ganze Zahlen enthält. Wir definieren eine Funktion encrypt so, dass encrypt(x) jede Ziffer in x durch die größte Ziffer in x ersetzt. Beispiel: encrypt(523) = 555 und encrypt(213) = 333.
Gibt die Summe der verschlüsselten Elemente zurück.

Beispiel 1:

Eingabe: nums = [1,2,3]
Ausgang: 6
Erklärung: Die verschlüsselten Elemente sind [1,2,3]. Die Summe der verschlüsselten Elemente ist 1 + 2 + 3 == 6.

Beispiel 2:

Eingabe: nums = [10,21,31]
Ausgang: 66
Erklärung: Die verschlüsselten Elemente sind [11,22,33]. Die Summe der verschlüsselten Elemente ist 11 + 22 + 33 == 66.

Zwänge:

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

Sie erhalten ein Integer-Array „nums“, das positive ganze Zahlen enthält. Wir definieren eine Funktion encrypt so, dass encrypt(x) jede Ziffer in x durch die größte Ziffer in x ersetzt. Beispiel: encrypt(523) = 555 und encrypt(213) = 333.
Gibt die Summe der verschlüsselten Elemente zurück.

Beispiel 1:

Eingabe: nums = [1,2,3]
Ausgabe: 6
Erläuterung: Die verschlüsselten Elemente sind [1,2,3]. Die Summe der verschlüsselten Elemente beträgt 1 + 2 + 3 == 6.

Beispiel 2:

Eingabe: nums = [10,21,31]
Ausgabe: 66
Erläuterung: Die verschlüsselten Elemente sind [11,22,33]. Die Summe der verschlüsselten Elemente beträgt 11 + 22 + 33 == 66.

Einschränkungen:

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


Sie erhalten ein 0-indiziertes Array nums der Größe n, das aus positiven ganzen Zahlen besteht.
Sie erhalten außerdem ein 2D-Array mit Abfragen der Größe m, wobei query[i] = [index_i, k_i] ist.
Zunächst sind alle Elemente des Arrays unmarkiert.
Sie müssen der Reihe nach m Abfragen auf das Array anwenden, wobei Sie bei der i^-ten Abfrage Folgendes tun:

Markieren Sie das Element am Index index_i, falls es noch nicht markiert ist.
Markieren Sie dann k_i unmarkierte Elemente im Array mit den kleinsten Werten. Wenn mehrere solcher Elemente vorhanden sind, markieren Sie diejenigen mit den kleinsten Indizes. Und wenn weniger als k_i unmarkierte Elemente vorhanden sind, markieren Sie alle.

Gibt eine Array-Antwort der Größe m zurück, wobei Antwort[i] die Summe der nicht markierten Elemente im Array nach der i^-ten Abfrage ist.

Beispiel 1:

Eingabe: Zahlen = [1,2,2,1,2,3,1], Abfragen = [[1,2],[3,3],[4,2]]
Ausgabe: [8,3,0]
Erläuterung:
Wir führen die folgenden Abfragen für das Array durch:

Markieren Sie das Element mit Index 1 und 2 der kleinsten unmarkierten Elemente mit den kleinsten Indizes, falls vorhanden. Die markierten Elemente sind jetzt nums = [1,2,2,1,2,3,1]. Die Summe der nicht markierten Elemente beträgt 2 + 2 + 3 + 1 = 8.
Markieren Sie das Element bei Index 3, da es bereits markiert ist, überspringen wir es. Dann markieren wir 3 der kleinsten unmarkierten Elemente mit den kleinsten Indizes, die markierten Elemente sind jetzt nums = [1,2,2,1,2,3,1]. Die Summe der nicht markierten Elemente beträgt 3.
Markieren Sie das Element bei Index 4, da es bereits markiert ist, überspringen wir es. Dann markieren wir 2 der kleinsten unmarkierten Elemente mit den kleinsten Indizes, falls vorhanden, die markierten Elemente sind jetzt nums = [1,2,2,1,2,3,1]. Die Summe der nicht markierten Elemente ist 0.

Beispiel 2:

Eingabe: Zahlen = [1,4,2,3], Abfragen = [[0,1]]
Ausgabe: [7]
Erläuterung: Wir führen eine Abfrage durch, bei der das Element bei Index 0 markiert wird und das kleinste Element unter den nicht markierten Elementen markiert wird. Die markierten Elemente sind nums = [1,4,2,3] und die Summe der nicht markierten Elemente beträgt 4 + 3 = 7.

Einschränkungen:

n == nums.length
m == query.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
query[i].length == 2
0 <= index_i, k_i <= n - 1

Sie erhalten eine mit 0-indexierten Array nums der Größe N, die aus positiven Ganzzahlen besteht.
Sie erhalten außerdem ein 2D -Array -Abfragen von Größe m, bei dem Abfragen [i] = [index_i, k_i].
Zunächst sind alle Elemente des Arrays nicht markiert.
Sie müssen M -Abfragen auf das Array anwenden, in der Sie die folgende Abfrage machen:

Markieren Sie das Element an Index index_i, falls es noch nicht markiert ist.
Dann markieren Sie k_i nicht markierte Elemente im Array mit den kleinsten Werten. Wenn mehrere solche Elemente vorhanden sind, markieren Sie die mit den kleinsten Indizes. Und wenn weniger als K_I nicht markierte Elemente existieren, markieren Sie sie alle.

Geben Sie eine Array -Antwort von Größe m zurück, bei der die Antwort [i] die Summe nicht markierter Elemente im Array nach der Abfrage ist.

Beispiel 1:

Eingabe: nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]
Ausgabe: [8,3,0]
Erläuterung:
Wir machen die folgenden Abfragen auf dem Array:

Markieren Sie das Element am Index 1 und 2 der kleinsten nicht markierten Elemente mit den kleinsten Indizes, wenn sie existieren, sind die markierten Elemente jetzt nums = [1,2,2,1,2,3,1]. Die Summe der nicht markierten Elemente beträgt 2 + 2 + 3 + 1 = 8.
Markieren Sie das Element bei Index 3, da es bereits markiert ist, überspringen wir es. Dann markieren wir 3 der kleinsten nicht markierten Elemente mit den kleinsten Indizes, die markierten Elemente sind jetzt nums = [1,2,2,1,2,3,1]. Die Summe der nicht markierten Elemente beträgt 3.
Markieren Sie das Element bei Index 4, da es bereits markiert ist, überspringen wir es. Dann markieren wir 2 der kleinsten nicht markierten Elemente mit den kleinsten Indizes, wenn sie existieren. Die markierten Elemente sind jetzt nums = [1,2,2,1,2,3,1]. Die Summe der nicht markierten Elemente beträgt 0.

Beispiel 2:

Eingabe: nums = [1,4,2,3], queries = [[0,1]]
Ausgabe: [7]
Erläuterung: Wir machen eine Abfrage, die das Element am Index 0 markiert und das kleinste Element unter nicht markierten Elementen markiert. Die markierten Elemente sind nums = [1,4,2,3], und die Summe der nicht markierten Elemente beträgt 4 + 3 = 7.

Einschränkungen:

n == nums.length
m == queries.length
1 <= m <= n <= 10^5
1 <= nums[i] <= 10^5
queries[i].length == 2
0 <= index_i, k_i <= n - 1