Es gibt drei Karten mit den Buchstaben $\texttt{a}$, $\texttt{b}$, $\texttt{c}$, die in einer bestimmten Reihenfolge in einer Reihe angeordnet sind. Sie können die folgende Operation höchstens einmal durchführen:

- Wählen Sie zwei Karten und tauschen Sie sie. Ist es möglich, dass die Reihe nach der Operation zu $\texttt{abc}$ wird? Geben Sie „YES“ aus, wenn dies möglich ist, und andernfalls „NO“.

Eingabe

Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 6$) – die Anzahl der Testfälle.

Die einzige Zeile jedes Testfalls enthält eine einzelne Zeichenfolge, die aus jedem der drei Zeichen $\texttt{a}$, $\texttt{b}$ und $\texttt{c}$ genau einmal besteht und die Karten darstellt.

Ausgabe

Geben Sie für jeden Testfall „YES“ aus, wenn Sie die Reihe mit höchstens einer Operation zu $\texttt{abc}$ machen können, andernfalls „NO“.

Sie können die Antwort in jedem Fall ausgeben (beispielsweise werden die Zeichenfolgen „yEs“, „yes“, „Yes“ und „YES“ als positive Antwort erkannt).Beispieleingabe 1:
6

abc

acb

bac

bca

cab

cba

Beispielausgabe 1:

YES
YES
YES
NO
NO
YES

Hinweis

Im ersten Testfall müssen wir keine Operationen durchführen, da die Zeile bereits $\texttt{abc}$ ist.

Im zweiten Testfall können wir $\texttt{c}$ und $\texttt{b}$ vertauschen: $\texttt{acb} \to \texttt{abc}$.

Im dritten Testfall können wir $\texttt{b}$ und $\texttt{a}$ vertauschen: $\texttt{bac} \to \texttt{abc}$.

Im vierten Testfall ist es unmöglich, $\texttt{abc}$ mit höchstens einer Operation zu erstellen.

Es gibt drei Karten mit den Buchstaben $\texttt{a}$, $\texttt{b}$, $\texttt{c}$, die in einer Reihe in einer bestimmten Reihenfolge angeordnet sind. Sie können den folgenden Vorgang höchstens einmal ausführen:

- Wählen Sie zwei Karten und tauschen Sie sie aus.  Ist es möglich, dass die Zeile nach der Operation zu $\texttt{abc}$ wird? Geben Sie „YES“ aus, wenn es möglich ist, andernfalls „NO“.

Eingabe

Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 6$) – die Anzahl der Testfälle.

Die einzige Zeile jedes Testfalls enthält eine einzelne Zeichenfolge, die genau einmal aus jedem der drei Zeichen $\texttt{a}$, $\texttt{b}$ und $\texttt{c}$ besteht und die Karten darstellt.

Ausgabe

Geben Sie für jeden Testfall „YES“ aus, wenn Sie die Zeile $\texttt{abc}$ mit höchstens einer Operation erstellen können, andernfalls „NO“.

Du kannst die Antwort in beliebiger Schreibweise ausgeben (z. B. werden die Zeichenfolgen „yEs“, „yes“, „Yes“ und „YES“ als positive Antwort erkannt).Beispieleingabe 1:
6

ABC

acb

bac

bca

cab

cba

Beispielausgabe 1:

YES
YES
YES
NO
NO
YES

Notiz

Im ersten Testfall müssen wir keine Operationen durchführen, da die Zeile bereits $\texttt{abc}$ ist.

Im zweiten Testfall können wir $\texttt{c}$ und $\texttt{b}$ vertauschen: $\texttt{acb} \to \texttt{abc}$.

Im dritten Testfall können wir $\texttt{b}$ und $\texttt{a}$ vertauschen: $\texttt{bac} \to \texttt{abc}$.

Im vierten Testfall ist es unmöglich, $\texttt{abc}$ mit höchstens einer Operation zu erstellen.

Es gibt drei Karten mit den Buchstaben $\texttt{a}$, $\texttt{b}$, $\texttt{c}$, die in einer bestimmten Reihenfolge hintereinander angeordnet sind. Sie können den folgenden Vorgang höchstens einmal ausführen:

- Wählen Sie zwei Karten und tauschen Sie sie aus.  Ist es möglich, dass die Zeile nach der Operation zu $\texttt{abc}$ wird? Geben Sie „YES“ aus, wenn es möglich ist, andernfalls „NO“.

Eingabe

Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 6$) – die Anzahl der Testfälle.

Die einzige Zeile jedes Testfalls enthält eine einzelne Zeichenfolge, die genau einmal aus jedem der drei Zeichen $\texttt{a}$, $\texttt{b}$ und $\texttt{c}$ besteht und die Karten darstellt.

Ausgabe

Geben Sie für jeden Testfall „YES“ aus, wenn Sie die Zeile $\texttt{abc}$ mit höchstens einer Operation erstellen können, andernfalls „NO“.

Sie können die Antwort in jedem Fall ausgeben (z. B. werden die Zeichenfolgen „yEs“, „yes“, „Yes“ und „YES“ als positive Antwort erkannt).Beispieleingabe 1:
6

abc

acb

bac

bca

cab

cba

Beispielausgabe 1:

YES
YES
YES
NO
NO
YES

Notiz

Im ersten Testfall müssen wir keine Operationen durchführen, da die Zeile bereits $\texttt{abc}$ ist.

Im zweiten Testfall können wir $\texttt{c}$ und $\texttt{b}$ vertauschen: $\texttt{acb} \to \texttt{abc}$.

Im dritten Testfall können wir $\texttt{b}$ und $\texttt{a}$ vertauschen: $\texttt{bac} \to \texttt{abc}$.

Im vierten Testfall ist es unmöglich, $\texttt{abc}$ mit höchstens einer Operation zu erstellen.


Slavic bereitet ein Geschenk für den Geburtstag eines Freundes vor. Er hat ein Array $a$ von $n$ Ziffern und die Gegenwart wird das Produkt aller dieser Ziffern sein. Da Slavic ein guter Junge ist, der das größtmögliche Produkt herstellen möchte, möchte er genau einer seiner Ziffern 1 $ hinzufügen.

Was ist das maximale Produkt, das Slavic herstellen kann?

Eingang

Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine einzelne ganze Zahl $n$ ($1 \leq n \leq 9$) – die Anzahl der Ziffern.

Die zweite Zeile jedes Testfalls enthält $n$ durch Leerzeichen getrennte ganze Zahlen $a_i$ ($0 \leq a_i \leq 9$) – die Ziffern im Array.

Ausgabe

Geben Sie für jeden Testfall eine einzelne ganze Zahl aus – das maximale Produkt, das Slavic erzeugen kann, indem $1$ zu genau einer seiner Ziffern addiert wird. Beispieleingabe 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Beispielausgabe 1:

16
2
432
430467210

Slavic bereitet ein Geschenk für den Geburtstag eines Freundes vor. Er hat ein Array $a$ von $n$ Ziffern und die Gegenwart wird das Produkt aller dieser Ziffern sein. Da Slavic ein guter Junge ist, der das größtmögliche Produkt herstellen möchte, möchte er genau einer seiner Ziffern 1 $ hinzufügen.

Was ist das maximale Produkt, das Slavic herstellen kann?

Eingang

Die erste Zeile enthält eine einzelne ganze Zahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine einzelne ganze Zahl $n$ ($1 \leq n \leq 9$) – die Anzahl der Ziffern.

Die zweite Zeile jedes Testfalls enthält $n$ durch Leerzeichen getrennte ganze Zahlen $a_i$ ($0 \leq a_i \leq 9$) – die Ziffern im Array.

Ausgabe

Geben Sie für jeden Testfall eine einzelne ganze Zahl aus – das maximale Produkt, das Slavic erzeugen kann, indem $1$ zu genau einer seiner Ziffern addiert wird. Beispieleingabe 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Beispielausgabe 1:

16
2
432
430467210

Slavic bereitet ein Geschenk für den Geburtstag eines Freundes vor. Er hat ein Array $a$ von $n$ Ziffern und die Gegenwart wird das Produkt aller dieser Ziffern sein. Da Slavic ein guter Junge ist, der das größtmögliche Produkt herstellen möchte, möchte er genau einer seiner Ziffern 1 $ hinzufügen.

Was ist das maximale Produkt, das Slavic herstellen kann?

Eingang

Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine einzelne ganze Zahl $n$ ($1 \leq n \leq 9$) – die Anzahl der Ziffern.

Die zweite Zeile jedes Testfalls enthält $n$ durch Leerzeichen getrennte ganze Zahlen $a_i$ ($0 \leq a_i \leq 9$) – die Ziffern im Array.

Ausgabe

Geben Sie für jeden Testfall eine einzelne ganze Zahl aus – das maximale Produkt, das Slavic erzeugen kann, indem es $1$ zu genau einer seiner Ziffern addiert. Beispieleingabe 1:
4

4

2 2 1 2

3

0 1 2

5

4 3 2 3 4

9

9 9 9 9 9 9 9 9 9

Beispielausgabe 1:

16
2
432
430467210


Sie erhalten einen Papierstreifen $s$ mit einer Länge von $n$ Zellen. Jede Zelle ist entweder schwarz oder weiß. In einer Operation können Sie alle $k$ aufeinanderfolgenden Zellen nehmen und sie alle weiß machen.

Ermitteln Sie die Mindestanzahl an Vorgängen, die zum Entfernen aller schwarzen Zellen erforderlich sind.

Eingang

Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 1000$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält zwei Ganzzahlen $n$ und $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$) – die Länge des Papiers und die in der Operation verwendete Ganzzahl.

Die zweite Zeile jedes Testfalls enthält eine Zeichenfolge $s$ der Länge $n$, die aus den Zeichen $\texttt{B}$ (für eine schwarze Zelle) oder $\texttt{W}$ (für eine weiße Zelle) besteht.

Die Summe von $n$ über alle Testfälle überschreitet nicht $2 \cdot 10^5$.

Ausgabe

Geben Sie für jeden Testfall eine einzelne Ganzzahl aus – die Mindestanzahl an Operationen, die erforderlich sind, um alle schwarzen Zellen zu entfernen. Beispieleingabe 1:
8

6 3

WWBWWB

7 3

WWBWWW

5 4

BWBWB

5 5

BBBBB

8 2

BWBWBBBB

10 2

WBBWBBWBBW

4 1

BBBB

3 2

WWW

Beispielausgabe 1:

2
1
2
1
4
3
4
0

Notiz

Im ersten Testfall können Sie folgende Operationen durchführen: $$\color{red}{\texttt{WBW}}\texttt{WWB} \to \texttt{WWW}\color{red}{\texttt{WWB}} \zu \texttt{WWWWWW}$$

Im zweiten Testfall können Sie folgende Operationen durchführen: $$\texttt{WW}\color{red}{\texttt{BWB}}\texttt{WW} \to \texttt{WWWWWWW}$$

Im dritten Testfall können Sie folgende Operationen durchführen: $$\texttt{B}\color{red}{\texttt{WBWB}} \to \color{red}{\texttt{BWWW}}\texttt{W} \zu \texttt{WWWWW}$$


Sie erhalten eine Zeichenkette $s$ mit der Länge $n$, die aus lateinischen Kleinbuchstaben und einer Ganzzahl $k$ besteht.

Sie müssen prüfen, ob es möglich ist, genau $k$ Zeichen aus dem String $s$ so zu entfernen, dass die restlichen Zeichen neu angeordnet werden können, um ein Palindrom zu bilden. Beachten Sie, dass Sie die verbleibenden Zeichen auf beliebige Weise neu anordnen können.

Ein Palindrom ist eine Zeichenkette, die vorwärts und rückwärts dasselbe liest. Zum Beispiel sind die Zeichenfolgen "z", "aaa", "aba", "abccba" Palindrome, während die Zeichenfolgen "codeforces", "reality", "ab" dies nicht sind.

Eingabe

Jeder Test besteht aus mehreren Testfällen. Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 10^4$) — die Anzahl der Testfälle. Darauf folgt ihre Beschreibung.

Die erste Zeile jedes Testfalls enthält zwei ganze Zahlen $n$ und $k$ ($0 \leq k < n \leq 10^5$) — die Länge der Zeichenkette $s$ und die Anzahl der Zeichen, die gelöscht werden sollen.

Die zweite Zeile jedes Testfalls enthält eine Zeichenkette $s$ mit der Länge $n$, die aus lateinischen Kleinbuchstaben besteht.

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall "YES" aus, wenn es möglich ist, genau $k$ Zeichen aus dem String $s$ so zu entfernen, dass die restlichen Zeichen zu einem Palindrom neu angeordnet werden können, andernfalls "NO".

Sie können die Antwort in jedem Fall ausgeben (Groß- oder Kleinbuchstaben). Zum Beispiel werden die Zeichenfolgen "yEs", "yes", "Yes" und "YES" als positive Antworten erkannt. Beispiel-Eingang 1:
14

1 0

a

2 0

ab

2 1

ba

3 1

abb

3 2

abc

6 2

bacacd

6 2

fagbza

6 2

Zwaafa

7 2

Taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

debca

5 3

abaac

Beispiel-Ausgabe 1:

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Anmerkung

Im ersten Testfall kann nichts entfernt werden, und die Zeichenkette "a" ist ein Palindrom.

Im zweiten Testfall kann nichts entfernt werden, aber die Zeichenketten "ab" und "ba" sind keine Palindrome.

Im dritten Testfall kann ein beliebiges Zeichen entfernt werden, und die resultierende Zeichenfolge ist ein Palindrom.

Im vierten Testfall kann ein Vorkommen des Zeichens "a" entfernt werden, was zu der Zeichenkette "bb" führt, die ein Palindrom ist.

Im sechsten Testfall kann ein Vorkommen der Zeichen "b" und "d" entfernt werden, wodurch der String "acac" entsteht, der zum String "acca" umgeordnet werden kann.

Im neunten Testfall kann ein Vorkommen der Zeichen "t" und "k" entfernt werden, was zu der Zeichenkette "aagaa" führt, bei der es sich um ein Palindrom handelt.

Sie erhalten eine Zeichenfolge $s$ der Länge $n$, bestehend aus lateinischen Kleinbuchstaben und einer Ganzzahl $k$.

Sie müssen prüfen, ob es möglich ist, genau $k$ Zeichen aus der Zeichenfolge $s$ zu entfernen, sodass die verbleibenden Zeichen neu angeordnet werden können, um ein Palindrom zu bilden. Beachten Sie, dass Sie die verbleibenden Zeichen beliebig neu anordnen können.

Ein Palindrom ist eine Zeichenfolge, die vorwärts und rückwärts dasselbe liest. Beispielsweise sind die Zeichenfolgen „z“, „aaa“, „aba“, „abccba“ Palindrome, während dies bei den Zeichenfolgen „codeforces“, „reality“ und „ab“ nicht der Fall ist.

Eingang

Jeder Test besteht aus mehreren Testfällen. Die erste Zeile enthält eine einzelne ganze Zahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle. Anschließend folgt deren Beschreibung.

Die erste Zeile jedes Testfalls enthält zwei ganze Zahlen $n$ und $k$ ($0 \leq k < n \leq 10^5$) – die Länge der Zeichenfolge $s$ und die Anzahl der zu löschenden Zeichen.

Die zweite Zeile jedes Testfalls enthält eine Zeichenfolge $s$ der Länge $n$, bestehend aus lateinischen Kleinbuchstaben.

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall „YES“ aus, wenn es möglich ist, genau $k$ Zeichen aus der Zeichenfolge $s$ zu entfernen, sodass die verbleibenden Zeichen neu angeordnet werden können, um ein Palindrom zu bilden, andernfalls „NO“.

Sie können die Antwort in beliebiger Schreibweise (Groß- oder Kleinschreibung) ausgeben. Beispielsweise werden die Zeichenfolgen „yEs“, „yes“, „Yes“ und „YES“ als positive Antworten erkannt.Beispieleingabe 1:
14

1 0

A

2 0

ab

2 1

ba

3 1

abb

3 2

ABC

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

Taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

Debca

5 3

Abaac

Beispielausgabe 1:

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Notiz

Im ersten Testfall kann nichts entfernt werden und die Zeichenfolge „a“ ist ein Palindrom.

Im zweiten Testfall kann nichts entfernt werden, aber die Zeichenfolgen „ab“ und „ba“ sind keine Palindrome.

Im dritten Testfall kann jedes Zeichen entfernt werden und die resultierende Zeichenfolge ist ein Palindrom.

Im vierten Testfall kann ein Vorkommen des Zeichens „a“ entfernt werden, wodurch die Zeichenfolge „bb“ entsteht, bei der es sich um ein Palindrom handelt.

Im sechsten Testfall kann ein Vorkommen der Zeichen „b“ und „d“ entfernt werden, wodurch die Zeichenfolge „acac“ entsteht, die in die Zeichenfolge „acca“ umgewandelt werden kann.

Im neunten Testfall kann ein Vorkommen der Zeichen „t“ und „k“ entfernt werden, was zur Zeichenfolge „aagaa“ führt, bei der es sich um ein Palindrom handelt.

Sie erhalten eine Zeichenfolge $s$ der Länge $n$, bestehend aus lateinischen Kleinbuchstaben und einer Ganzzahl $k$.

Sie müssen prüfen, ob es möglich ist, genau $k$ Zeichen aus der Zeichenfolge $s$ zu entfernen, sodass die verbleibenden Zeichen neu angeordnet werden können, um ein Palindrom zu bilden. Beachten Sie, dass Sie die verbleibenden Zeichen beliebig neu anordnen können.

Ein Palindrom ist eine Zeichenfolge, die vorwärts und rückwärts dasselbe liest. Beispielsweise sind die Zeichenfolgen „z“, „aaa“, „aba“, „abccba“ Palindrome, während dies bei den Zeichenfolgen „codeforces“, „reality“ und „ab“ nicht der Fall ist.

Eingang

Jeder Test besteht aus mehreren Testfällen. Die erste Zeile enthält eine einzelne ganze Zahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle. Anschließend folgt deren Beschreibung.

Die erste Zeile jedes Testfalls enthält zwei ganze Zahlen $n$ und $k$ ($0 \leq k < n \leq 10^5$) – die Länge der Zeichenfolge $s$ und die Anzahl der zu löschenden Zeichen.

Die zweite Zeile jedes Testfalls enthält eine Zeichenfolge $s$ der Länge $n$, bestehend aus lateinischen Kleinbuchstaben.

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall „YES“ aus, wenn es möglich ist, genau $k$ Zeichen aus der Zeichenfolge $s$ zu entfernen, sodass die verbleibenden Zeichen neu angeordnet werden können, um ein Palindrom zu bilden, andernfalls „NO“.

Sie können die Antwort in beliebiger Schreibweise (Groß- oder Kleinschreibung) ausgeben. Beispielsweise werden die Zeichenfolgen „yEs“, „yes“, „Yes“ und „YES“ als positive Antworten erkannt. Beispieleingabe 1:
14

1 0

A

2 0

ab

2 1

ba

3 1

abb

3 2

ABC

6 2

bacacd

6 2

fagbza

6 2

zwaafa

7 2

Taagaak

14 3

ttrraakkttoorr

5 3

debdb

5 4

ecadc

5 3

Debca

5 3

Abaac

Beispielausgabe 1:

YES
NO
YES
YES
YES
YES
NO
NO
YES
YES
YES
YES
NO
YES

Notiz

Im ersten Testfall kann nichts entfernt werden und die Zeichenfolge „a“ ist ein Palindrom.

Im zweiten Testfall kann nichts entfernt werden, aber die Zeichenfolgen „ab“ und „ba“ sind keine Palindrome.

Im dritten Testfall kann jedes Zeichen entfernt werden und die resultierende Zeichenfolge ist ein Palindrom.

Im vierten Testfall kann ein Vorkommen des Zeichens „a“ entfernt werden, wodurch die Zeichenfolge „bb“ entsteht, bei der es sich um ein Palindrom handelt.

Im sechsten Testfall kann ein Vorkommen der Zeichen „b“ und „d“ entfernt werden, wodurch die Zeichenfolge „acac“ entsteht, die in die Zeichenfolge „acca“ umgewandelt werden kann.

Im neunten Testfall kann ein Vorkommen der Zeichen „t“ und „k“ entfernt werden, was zur Zeichenfolge „aagaa“ führt, bei der es sich um ein Palindrom handelt.


Sie erhalten ein Array aus ganzen Zahlen $a_1, a_2, \ldots, a_n$ und einer Zahl $k$ ($2 \leq k \leq 5$). In einem Vorgang können Sie Folgendes tun:

- Wählen Sie einen Index $1 \leq i \leq n$,
- Setzen Sie $a_i = a_i + 1$. Finden Sie die Mindestanzahl an Operationen, die erforderlich sind, um das Produkt aller Zahlen im Array $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ durch $k$ teilbar zu machen.

Eingang

Jeder Test besteht aus mehreren Testfällen. Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle. Anschließend folgt die Beschreibung der Testfälle.

Die erste Zeile jedes Testfalls enthält zwei ganze Zahlen $n$ und $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) – die Größe des Arrays $a$ und die Zahl $k$.

Die zweite Zeile jedes Testfalls enthält $n$ ganze Zahlen $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall die Mindestanzahl an Operationen aus, die erforderlich sind, um das Produkt aller Zahlen im Array durch $k$ teilbar zu machen. Beispieleingabe 1:
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

Beispielausgabe 1:

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

Notiz

Im ersten Testfall müssen wir den Index $i = 2$ zweimal wählen. Danach ist das Array $a = [7, 5]$. Das Produkt aller Zahlen im Array ist 35 $.

Im vierten Testfall beträgt das Produkt der Zahlen im Array 120 $, was bereits durch 5 $ teilbar ist, sodass keine Operationen erforderlich sind.

Im achten Testfall können wir zwei Operationen ausführen, indem wir $i = 2$ und $i = 3$ in beliebiger Reihenfolge wählen. Danach ist das Array $a = [1, 6, 10]$. Das Produkt der Zahlen im Array beträgt $60$.

Sie erhalten eine Reihe von Ganzzahlen $a_1, a_2, \ldots, a_n$ und eine Nummer $k$ ($2 \leq k \leq 5$). In einer Operation können Sie Folgendes ausführen:

- Wählen Sie einen Index $1 \leq i \leq n$,
- Setzen Sie $a_i = a_i + 1$ .FIND Die Mindestanzahl von Vorgängen, die erforderlich sind, um das Produkt aller Zahlen im Array $a_1 \cdot a_2 \cdot \ldots \cdot a_n$ divisible durch $k$ zu erstellen.

Eingang

Jeder Test besteht aus mehreren Testfällen. Die erste Zeile enthält eine einzelne Ganzzahl $t$ ($1 \leq t \leq 10^4$) - die Anzahl der Testfälle. Folgt dann der Beschreibung der Testfälle.

Die erste Zeile jedes Testfalls enthält zwei Ganzzahlen $n$ und $k$ ($2 \leq n \leq 10^5$, $2 \leq k \leq 5$) - die Größe des Array $a$ und die ummer $k$.n

Die zweite Zeile jedes Testfalles enthält $n$ Integer $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10$).

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall die Mindestanzahl an Operationen aus, die erforderlich sind, um das Produkt aller Zahlen im Array durch $k$ teilbar zu machen. Beispieleingabe 1:
15

2 5

7 3

3 3

7 4 1

5 2

9 7 7 3 9

5 5

5 4 1 2 3

7 4

9 5 1 5 9 5 1

3 4

6 3 6

3 4

6 1 5

3 4

1 5 9

4 4

1 4 1 1

3 4

3 5 3

4 5

8 9 9 3

2 5

1 6

2 5

10 10

4 5

1 6 1 1

2 5

7 7

Probenausgang 1:

2
2
1
0
2
0
1
2
0
1
1
4
0
4
3

Notiz

Im ersten Testfall müssen wir den Index $i = 2$ zweimal auswählen. Danach wird das Array $a = [7, 5]$ sein. Das Produkt aller Zahlen im Array beträgt 35.

Im vierten Testfall beträgt das Produkt der Zahlen im Array 120, was bereits um 5 teilbar ist, sodass keine Vorgänge erforderlich sind.

Im achten Testfall können wir zwei Operationen ausführen, indem wir $i = 2$ und $i = 3$ in jeder Reihenfolge auswählen. Danach wird das Array $a = [1, 6, 10]$ sein. Das Produkt der Zahlen im Array beträgt $60$.


Vanya und Vova spielen ein Spiel. Die Spieler erhalten eine ganze Zahl $n$. Wenn der Spieler an der Reihe ist, kann er $1$ zur aktuellen Ganzzahl addieren oder $1$ subtrahieren. Die Spieler wechseln sich ab; Vanya beginnt. Wenn nach Vanyas Zug die ganze Zahl durch $3$ teilbar ist, dann gewinnt er. Wenn $10$ Züge bestanden haben und Vanya nicht gewonnen hat, dann gewinnt Vova.

Schreiben Sie ein Programm, das auf der Grundlage der Ganzzahl $n$ bestimmt, wer gewinnt, wenn beide Spieler optimal spielen.

Eingabe

Die erste Zeile enthält die Ganzzahl $t$ ($1 \leq t \leq 100$) — die Anzahl der Testfälle.

Die einzelne Zeile jedes Testfalls enthält die ganze Zahl $n$ ($1 \leq n \leq 1000$).

Ausgabe

Geben Sie für jeden Testfall „Erster“ ohne Anführungszeichen aus, wenn Vanya gewinnt, und „Zweiter“ ohne Anführungszeichen, wenn Vova gewinnt.Eingabebeispiel 1:
6

1

3

5

100

999

1000

Beispiel-Ausgabe 1:

First
Second
First
First
Second
First

Wanja und Vova spielen ein Spiel. Den Spielern wird eine ganze Zahl $n$ gegeben. Wenn der Spieler an der Reihe ist, kann er 1 zur aktuellen Ganzzahl addieren oder 1 subtrahieren. Die Spieler wechseln sich ab; Wanja beginnt. Wenn nach Vanyas Zug die ganze Zahl durch $3$ teilbar ist, dann gewinnt er. Wenn $10$-Züge vergangen sind und Wanja nicht gewonnen hat, dann gewinnt Vova.

Schreiben Sie ein Programm, das auf der Grundlage der ganzen Zahl $n$ bestimmt, wer gewinnt, wenn beide Spieler optimal spielen.

Eingabe

Die erste Zeile enthält die ganze Zahl $t$ ($1 \leq t \leq 100$), die Anzahl der Testfälle.

Die einzelne Zeile jedes Testfalls enthält die ganze Zahl $n$ ($1 \leq n \leq 1000$).

Ausgabe

Geben Sie für jeden Testfall „First“ ohne Anführungszeichen aus, wenn Wanja gewinnt, und „Second“ ohne Anführungszeichen, wenn Vova gewinnt. Beispiel Eingabe 1:
6

1

3

5

100

999

1000

Beispiel Ausgabe 1:

First
Second
First
First
Second
First

Vanya und Vova spielen ein Spiel. Den Spielern wird eine ganze Zahl n gegeben. Wenn der Spieler an der Reihe ist, kann er 1 zur aktuellen Ganzzahl addieren oder 1 subtrahieren. Die Spieler wechseln sich ab; Wanja beginnt. Wenn nach Vanyas Zug die ganze Zahl durch 3 teilbar ist, dann gewinnt er. Wenn 10-Züge vergangen sind und Vanya nicht gewonnen hat, dann gewinnt Vova.

Schreiben Sie ein Programm, das auf der Grundlage der ganzen Zahl $n$ bestimmt, wer gewinnt, wenn beide Spieler optimal spielen.

Eingabe

Die erste Zeile enthält die ganze Zahl $t$ ($1 \leq t \leq 100$) – die Anzahl der Testfälle.

Die einzelne Zeile jedes Testfalls enthält die ganze Zahl $n$ ($1 \leq n \leq 1000$).

Ausgabe

Geben Sie für jeden Testfall „First“ ohne Anführungszeichen aus, wenn Vanya gewinnt, und „Second“ ohne Anführungszeichen, wenn Vova gewinnt. Beispieleingabe 1:
6

1

3

5

100

999

1000

Beispielausgabe 1:

First
Second
First
First
Second
First


Alex nimmt an den Dreharbeiten zu einem weiteren Video von BrMeast teil, und BrMeast hat Alex gebeten, 250.000 Tonnen TNT vorzubereiten, aber Alex hörte ihn nicht gut, also bereitete er n$-Kisten vor und stellte sie in einer Reihe auf, um sie auf Lastwagen zu laden. Die $i$-te Kiste von links wiegt $a_i$ Tonnen.

Alle LKW, die Alex benutzen wird, enthalten die gleiche Anzahl an Kisten, angegeben mit $k$. Das Laden geschieht folgendermaßen:

- Die ersten $k$-Kisten gehen an den ersten LKW,
- Die zweiten $k$-Kisten gehen an den zweiten LKW,
- $\dotsb$
- Die letzten $k$-Kisten gehen an den $\frac{n}{k}$-ten LKW. Nach Abschluss der Beladung muss jeder LKW über genau $k$ Kisten verfügen. Mit anderen Worten: Wenn es irgendwann nicht mehr möglich ist, genau $k$ Kisten in den LKW zu laden, dann ist die Ladeoption mit diesen $k$ nicht möglich.

Alex hasst Gerechtigkeit, daher möchte er, dass der maximale absolute Unterschied zwischen den Gesamtgewichten zweier Lastwagen so groß wie möglich ist. Wenn es nur einen LKW gibt, beträgt dieser Wert $0$.

Alex hat ziemlich viele Verbindungen, also kann er für jeden $1 \leq k \leq n$ ein Unternehmen finden, bei dem jeder seiner Lastwagen genau $k$ Kisten aufnehmen kann. Drucken Sie die maximale absolute Differenz zwischen den Gesamtgewichten zweier beliebiger LKW aus.

Eingang

Die erste Zeile enthält eine ganze Zahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine ganze Zahl $n$ ($1 \leq n \leq 150\,000$) – die Anzahl der Kisten.

Die zweite Zeile enthält $n$ ganze Zahlen $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – die Gewichte der Kisten.

Es wird garantiert, dass die Summe von $n$ für alle Testfälle 150.000$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall eine einzelne Ganzzahl aus – die Antwort auf das Problem. Beispieleingabe 1:
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

Beispielausgabe 1:

1
9
0
189114
112141

Notiz

Im ersten Fall sollten wir zwei LKW auswählen, sodass der erste nur die erste Box und der zweite nur die zweite Box hat.

Im zweiten Fall sollten wir sechs LKW auswählen, sodass das Maximum 10 $, das Minimum 1 $ beträgt und die Antwort 10 $ - 1 = 9 $ lautet.

Im dritten Fall haben die LKW für alle möglichen k$ das gleiche Gesamtgewicht an Kisten, die Antwort lautet also 0 $.

Alex nimmt an den Dreharbeiten zu einem weiteren Video von BrMeast teil, und BrMeast hat Alex gebeten, 250.000 Tonnen TNT vorzubereiten, aber Alex hörte ihn nicht gut, also bereitete er n$-Kisten vor und stellte sie in einer Reihe auf, die auf Lastwagen wartete. Die $i$-te Kiste von links wiegt $a_i$ Tonnen.

Alle LKWs, die Alex benutzen wird, enthalten die gleiche Anzahl an Kisten, angegeben mit $k$. Das Laden geschieht folgendermaßen:

- Die ersten $k$-Boxen gehen an den ersten LKW,
- Die zweiten $k$-Boxen gehen an den zweiten LKW,
- $\dotsb$
- Die letzten $k$-Boxen gehen an den $\frac{n}{k}$-ten LKW. Nach Abschluss der Beladung muss jeder LKW über genau $k$ Kartons verfügen. Mit anderen Worten: Wenn es irgendwann nicht mehr möglich ist, genau $k$ Kartons in den LKW zu laden, dann ist die Ladeoption mit diesen $k$ nicht möglich.

Alex hasst Gerechtigkeit, daher möchte er, dass der maximale absolute Unterschied zwischen den Gesamtgewichten zweier Lastwagen möglichst groß ist. Wenn es nur einen LKW gibt, beträgt dieser Wert $0$.

Alex hat ziemlich viele Verbindungen, also kann er für jeden $1 \leq k \leq n$ ein Unternehmen finden, bei dem jeder seiner Lastwagen genau $k$ Kartons aufnehmen kann. Drucken Sie die maximale absolute Differenz zwischen den Gesamtgewichten zweier beliebiger LKWs aus.

Eingang

Die erste Zeile enthält eine Ganzzahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine ganze Zahl $n$ ($1 \leq n \leq 150\,000$) – die Anzahl der Boxen.

Die zweite Zeile enthält $n$ ganze Zahlen $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – die Gewichte der Boxen.

Es wird garantiert, dass die Summe von $n$ für alle Testfälle $150\,000$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall eine einzelne Ganzzahl aus – die Antwort auf das Problem. Beispieleingabe 1:
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

Beispielausgabe 1:

1
9
0
189114
112141

Notiz

Im ersten Fall sollten wir zwei LKWs auswählen, sodass der erste nur die erste Box und der zweite nur die zweite Box hat.

Im zweiten Fall sollten wir sechs LKWs auswählen, sodass das Maximum $10$, das Minimum $1$ beträgt und die Antwort $10 - 1 = 9$ lautet.

Im dritten Fall haben die LKWs für alle möglichen $k$ das gleiche Gesamtgewicht an Kisten, die Antwort lautet also $0$.

Alex nimmt an den Dreharbeiten zu einem weiteren Video von BrMeast teil und BrMeast bat Alex, 250.000 Tonnen TNT vorzubereiten, aber Alex hörte ihn nicht gut, also bereitete er n$-Kisten vor und stellte sie in einer Reihe auf, die auf Lastwagen wartete. Die $i$-te Kiste von links wiegt $a_i$ Tonnen.

Alle LKWs, die Alex benutzen wird, enthalten die gleiche Anzahl an Kisten, angegeben mit $k$. Das Laden geschieht folgendermaßen:

- Die ersten $k$-Kisten gehen an den ersten LKW,
- Die zweiten $k$-Kisten gehen an den zweiten LKW,
- $\dotsb$
- Die letzten $k$-Kisten gehen an den $\frac{n}{k}$-ten LKW. Nach Abschluss der Beladung muss jeder LKW über genau $k$ Kisten verfügen. Mit anderen Worten: Wenn es irgendwann nicht mehr möglich ist, genau $k$ Kisten in den LKW zu laden, dann ist die Beladungsoption mit diesen $k$ nicht möglich.

Alex hasst Gerechtigkeit, daher möchte er, dass der maximale absolute Unterschied zwischen den Gesamtgewichten zweier Lastwagen so groß wie möglich ist. Wenn es nur einen LKW gibt, beträgt dieser Wert $0$.

Alex hat ziemlich viele Verbindungen, also kann er für jeden $1 \leq k \leq n$ ein Unternehmen finden, bei dem jeder seiner Lastwagen genau $k$ Kisten aufnehmen kann. Geben Sie die maximale absolute Differenz zwischen den Gesamtgewichten zweier beliebiger LKWs aus.
Eingang

Die erste Zeile enthält eine Ganzzahl $t$ ($1 \leq t \leq 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine ganze Zahl $n$ ($1 \leq n \leq 150\,000$) – die Anzahl der Kisten.

Die zweite Zeile enthält $n$ ganze Zahlen $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – die Gewichte der Kisten.

Es ist garantiert, dass die Summe von $n$ für alle Testfälle 150.000$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall eine einzelne Ganzzahl aus – die Antwort auf das Problem. Beispieleingabe 1:
5

2

1 2

6

10 2 3 6 1 3

4

1000000000 1000000000 1000000000 1000000000

15

60978 82265 78961 56708 39846 31071 4913 4769 29092 91348 64119 72421 98405 222 14294

8

19957 69913 37531 96991 57838 21008 14207 19198

Beispielausgabe 1:

1
9
0
189114
112141

Notiz

Im ersten Fall sollten wir zwei LKWs auswählen, sodass der erste nur die erste Box und der zweite nur die zweite Box hat.

Im zweiten Fall sollten wir sechs LKWs auswählen, sodass das Maximum 10 $, das Minimum 1 $ beträgt und die Antwort 10 $ - 1 = 9 $ lautet.

Im dritten Fall haben die LKWs für alle möglichen k$ das gleiche Gesamtgewicht an Kisten, sodass die Antwort 0 $ ist.


Ein Unterarray ist ein zusammenhängender Teil eines Arrays.

Yarik hat kürzlich ein Array $a$ mit $n$ Elementen gefunden und ist sehr daran interessiert, die maximale Summe eines nicht leeren Unterarrays zu finden. Yarik mag jedoch keine aufeinanderfolgenden Ganzzahlen mit derselben Parität, daher muss der von ihm gewählte Unterarray abwechselnde Paritäten für benachbarte Elemente haben.

Zum Beispiel ist $[1, 2, 3]$ akzeptabel, aber $[1, 2, 4]$ nicht, da $2$ und $4$ beide gerade und benachbart sind.

Du musst Yarik helfen, indem du die maximale Summe eines solchen Unterarrays findest.

Eingabe

Die erste Zeile enthält eine ganze Zahl $t$ $(1 \le t \le 10^4)$ — Anzahl der Testfälle. Jeder Testfall wird wie folgt beschrieben.

Die erste Zeile jedes Testfalls enthält eine ganze Zahl $n$ $(1 \le n \le 2 \cdot 10^5)$ — Länge des Arrays.

Die zweite Zeile jedes Testfalls enthält $n$ ganze Zahlen $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — Elemente des Arrays.

Es ist garantiert, dass die Summe von $n$ für alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Für jeden Testfall gib eine einzelne Ganzzahl aus — die Antwort auf das Problem.

Beispiel Eingabe 1:
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

-10 5 -8 10 6 -10 7 9 -2 -6 7 2 -4 6 -1 7 -6 -7 4 1

Beispiel Ausgabe 1:

15
17
8
4
-1000
101
10

Ein Subarray ist ein kontinuierlicher Teil eines Arrays.

Yarik hat kürzlich ein Array $a$ von $n$ Elementen gefunden und war sehr daran interessiert, die maximale Summe eines nicht leeren Subarrays zu finden. Yarik mag jedoch keine aufeinanderfolgenden ganzen Zahlen mit der gleichen Parität, daher muss das von ihm gewählte Subarray abwechselnde Paritäten für benachbarte Elemente aufweisen.

Zum Beispiel ist $[1, 2, 3]$ akzeptabel, $[1, 2, 4]$ jedoch nicht, da $2$ und $4$ sowohl gerade als auch nebeneinander liegen.

Sie müssen Yarik helfen, indem Sie die maximale Summe eines solchen Subarrays ermitteln.

Eingabe

Die erste Zeile enthält eine Ganzzahl $t$ $(1 \le t \le 10^4)$ — Anzahl der Testfälle. Jeder Testfall wird wie folgt beschrieben.

Die erste Zeile jedes Testfalls enthält eine Ganzzahl $n$ $(1 \le n \le 2 \cdot 10^5)$ — Länge des Arrays.

Die zweite Zeile jedes Testfalls enthält $n$ Ganzzahlen $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ — Elemente des Arrays.

Es ist garantiert, dass die Summe von $n$ für alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall eine einzelne Ganzzahl aus – die Antwort auf das Problem. Beispiel-Eingang 1:
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

-10 5 -8 10 6 -10 7 9 -2 -6 7 2 -4 6 -1 7 -6 -7 4 1

Beispiel-Ausgabe 1:

15
17
8
4
-1000
101
10

Ein Subarray ist ein kontinuierlicher Teil eines Arrays.

Yarik hat kürzlich ein Array $a$ mit $n$ Elementen gefunden und war sehr daran interessiert, die maximale Summe eines nicht leeren Subarrays zu ermitteln. Allerdings mag Yarik keine aufeinanderfolgenden ganzen Zahlen mit derselben Parität, daher muss das von ihm ausgewählte Unterarray abwechselnde Paritäten für benachbarte Elemente haben.

Beispielsweise ist $[1, 2, 3]$ akzeptabel, $[1, 2, 4]$ jedoch nicht, da $2$ und $4$ beide gerade und benachbart sind.

Sie müssen Yarik helfen, indem Sie die maximale Summe eines solchen Subarrays ermitteln.

Eingang

Die erste Zeile enthält eine ganze Zahl $t$ $(1 \le t \le 10^4)$ – Anzahl der Testfälle. Jeder Testfall wird wie folgt beschrieben.

Die erste Zeile jedes Testfalls enthält eine ganze Zahl $n$ $(1 \le n \le 2 \cdot 10^5)$ – Länge des Arrays.

Die zweite Zeile jedes Testfalls enthält $n$ ganze Zahlen $a_1, a_2, \dots, a_n$ $(-10^3 \le a_i \le 10^3)$ – Elemente des Arrays.

Es ist garantiert, dass die Summe von $n$ für alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall eine einzelne Ganzzahl aus – die Antwort auf das Problem. Beispieleingabe 1:
7

5

1 2 3 4 5

4

9 9 8 8

6

-1 4 -1 0 5 -4

4

-1 2 4 -3

1

-1000

3

101 -99 101

20

-10 5 -8 10 6 -10 7 9 -2 -6 7 2 -4 6 -1 7 -6 -7 4 1

Beispielausgabe 1:

15
17
8
4
-1000
101
10


Yarik ist ein großer Fan vieler Musikrichtungen. Aber Yarik liebt es nicht nur, Musik zu hören, sondern auch, sie zu schreiben. Am liebsten mag er elektronische Musik, deshalb hat er sein eigenes Notensystem erstellt, das seiner Meinung nach am besten dafür geeignet ist.

Da Yarik sich auch für Informatik interessiert, werden Notizen in seinem System durch ganze Zahlen von $2^k$ bezeichnet, wobei $k \ge 1$ eine positive ganze Zahl ist. Aber wie Sie wissen, kann man zum Schreiben von Musik nicht nur Noten verwenden, deshalb verwendet Yarik Kombinationen aus zwei Noten. Die Kombination zweier Noten $(a, b)$, wobei $a = 2^k$ und $b = 2^l$, bezeichnet er mit der ganzen Zahl $a^b$.

Wenn beispielsweise $a = 8 = 2^3$, $b = 4 = 2^2$, dann wird die Kombination $(a, b)$ durch die ganze Zahl $a^b = 8^4 = 4096$ bezeichnet . Beachten Sie, dass verschiedene Kombinationen dieselbe Notation haben können, z. B. wird die Kombination $(64, 2)$ auch durch die ganze Zahl $4096 = 64^2$ bezeichnet.

Yarik hat bereits $n$ Noten ausgewählt, die er in seiner neuen Melodie verwenden möchte. Da ihre ganzen Zahlen jedoch sehr groß sein können, hat er sie als Array $a$ der Länge $n$ aufgeschrieben, dann ist die Note $i$ $b_i = 2^{a_i}$. Die ganzen Zahlen im Array $a$ können wiederholt werden.

Die Melodie besteht aus mehreren Kombinationen von zwei Noten. Yarik fragte sich, wie viele Notenpaare $b_i, b_j$ $(i < j)$ existieren, sodass die Kombination $(b_i, b_j)$ gleich der Kombination $(b_j, b_i)$ ist. Mit anderen Worten, er möchte die Anzahl der Paare $(i, j)$ $(i < j)$ zählen, so dass $b_i^{b_j} = b_j^{b_i}$. Helfen Sie ihm, die Anzahl solcher Paare zu ermitteln.

Eingang

Die erste Zeile der Eingabe enthält eine ganze Zahl $t$ ($1 \le t \le 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine Ganzzahl $n$ ($1 \leq n \leq 2 \cdot 10^5$) – die Länge der Arrays.

Die nächste Zeile enthält $n$ ganze Zahlen $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – Array $a$.

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall die Anzahl der Paare aus, die die gegebene Bedingung erfüllen. Beispieleingabe 1:
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

2 4 1 6 2 8 5 4 2 10 5 10 8 7 4 3 2 6 10

Beispielausgabe 1:

0
2
1
3
19

Yarik ist ein großer Fan von vielen Arten von Musik. Aber Yarik liebt es, Musik nicht nur zu hören, sondern auch zu schreiben. Er mag elektronische Musik am meisten, daher hat er sein eigenes Notensystem entwickelt, das seiner Meinung nach am besten dafür geeignet ist.

Da Yarik auch Informatik liebt, werden Noten in seinem System mit ganzen Zahlen von $2^k$ bezeichnet, wobei $k \ge 1$ — eine positive ganze Zahl ist. Aber wie du weißt, kann man nicht nur Noten verwenden, um Musik zu schreiben, also verwendet Yarik Kombinationen aus zwei Noten. Die Kombination zweier Töne $(a, b)$, wobei $a = 2^k$ und $b = 2^l$ ist, bezeichnet er mit der ganzen Zahl $a^b$.

Wenn z.B. $a = 8 = 2^3$, $b = 4 = 2^2$ ist, dann wird die Kombination $(a, b)$ mit der ganzen Zahl $a^b = 8^4 = 4096$ bezeichnet. Beachten Sie, dass verschiedene Kombinationen die gleiche Schreibweise haben können, z.B. wird die Kombination $(64, 2)$ auch mit der Ganzzahl $4096 = 64^2$ bezeichnet.

Yarik hat bereits $n$-Noten ausgewählt, die er in seiner neuen Melodie verwenden möchte. Da ihre ganzen Zahlen jedoch sehr groß sein können, hat er sie als Array $a$ der Länge $n$ notiert, dann ist die Note $i$ $b_i = 2^{a_i}$. Die ganzen Zahlen im Array $a$ können wiederholt werden.

Die Melodie besteht aus mehreren Kombinationen von zwei Noten. Yarik fragte sich, wie viele Notenpaare $b_i, b_j$ $(i < j)$ existieren, so dass die Kombination $(b_i, b_j)$ gleich der Kombination $(b_j, b_i)$ ist. Mit anderen Worten, er möchte die Anzahl der Paare $(i, j)$ $(i < j)$ so zählen, dass $b_i^{b_j} = b_j^{b_i}$ ist. Hilf ihm, die Anzahl solcher Paare zu finden.

Eingabe

Die erste Zeile der Eingabe enthält eine Ganzzahl $t$ ($1 \le t \le 10^4$) — die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine Ganzzahl $n$ ($1 \leq n \leq 2 \cdot 10^5$) — die Länge der Arrays.

Die nächste Zeile enthält $n$ Ganzzahlen $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) — array $a$.

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall die Anzahl der Paare aus, die die angegebene Bedingung erfüllen. Beispiel-Eingang 1:
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

2 4 1 6 2 8 5 4 2 10 5 10 8 7 4 3 2 6 10

Beispiel-Ausgabe 1:

0
2
1
3
19

Yarik ist ein großer Fan vieler Musikrichtungen. Aber Yarik liebt es nicht nur, Musik zu hören, sondern auch, sie zu schreiben. Am liebsten mag er elektronische Musik, deshalb hat er sein eigenes Notensystem erstellt, das seiner Meinung nach am besten dafür geeignet ist.

Da Yarik sich auch für Informatik interessiert, werden Notizen in seinem System durch ganze Zahlen von $2^k$ bezeichnet, wobei $k \ge 1$ eine positive ganze Zahl ist. Aber wie Sie wissen, kann man zum Schreiben von Musik nicht nur Noten verwenden, deshalb verwendet Yarik Kombinationen aus zwei Noten. Die Kombination zweier Noten $(a, b)$, wobei $a = 2^k$ und $b = 2^l$, bezeichnet er mit der ganzen Zahl $a^b$.

Wenn beispielsweise $a = 8 = 2^3$, $b = 4 = 2^2$, dann wird die Kombination $(a, b)$ durch die ganze Zahl $a^b = 8^4 = 4096$ bezeichnet . Beachten Sie, dass verschiedene Kombinationen dieselbe Notation haben können, z. B. wird die Kombination $(64, 2)$ auch durch die ganze Zahl $4096 = 64^2$ bezeichnet.

Yarik hat bereits $n$ Noten ausgewählt, die er in seiner neuen Melodie verwenden möchte. Da ihre ganzen Zahlen jedoch sehr groß sein können, hat er sie als Array $a$ der Länge $n$ aufgeschrieben, dann ist die Note $i$ $b_i = 2^{a_i}$. Die ganzen Zahlen im Array $a$ können wiederholt werden.

Die Melodie besteht aus mehreren Kombinationen von zwei Noten. Yarik fragte sich, wie viele Notenpaare $b_i, b_j$ $(i < j)$ existieren, sodass die Kombination $(b_i, b_j)$ gleich der Kombination $(b_j, b_i)$ ist. Mit anderen Worten, er möchte die Anzahl der Paare $(i, j)$ $(i < j)$ zählen, so dass $b_i^{b_j} = b_j^{b_i}$. Helfen Sie ihm, die Anzahl solcher Paare zu ermitteln.

Eingang

Die erste Zeile der Eingabe enthält eine ganze Zahl $t$ ($1 \le t \le 10^4$) – die Anzahl der Testfälle.

Die erste Zeile jedes Testfalls enthält eine ganze Zahl $n$ ($1 \leq n \leq 2 \cdot 10^5$) – die Länge der Arrays.

Die nächste Zeile enthält $n$ Ganzzahlen $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq 10^9$) – Array $a$.

Es ist garantiert, dass die Summe von $n$ über alle Testfälle $2 \cdot 10^5$ nicht überschreitet.

Ausgabe

Geben Sie für jeden Testfall die Anzahl der Paare aus, die die gegebene Bedingung erfüllen. Beispieleingabe 1:
5

1

2

4

3 1 3 2

2

1000 1000

3

1 1 1

19

2 4 1 6 2 8 5 4 2 10 5 10 8 7 4 3 2 6 10

Beispielausgabe 1:

0
2
1
3
19


Sie erhalten ein Array mit 0-indizierten Zeichenfolgendetails. Jedes Element der Details enthält Informationen zu einem bestimmten Passagier, komprimiert in eine Zeichenfolge der Länge 15. Das System ist wie folgt:

Die ersten zehn Zeichen bestehen aus der Telefonnummer der Passagiere.
Das nächste Zeichen gibt das Geschlecht der Person an.
Die folgenden zwei Zeichen werden verwendet, um das Alter der Person anzugeben.
Die letzten beiden Zeichen bestimmen den dieser Person zugewiesenen Sitzplatz.

Gibt die Anzahl der Passagiere zurück, die streng genommen älter als 60 Jahre sind.

Beispiel 1:

Eingabe: details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Ausgabe: 2
Erklärung: Die Passagiere an den Indizes 0, 1 und 2 sind 75, 92 und 40 Jahre alt. Es gibt also 2 Personen, die über 60 Jahre alt sind.

Beispiel 2:

Eingabe: details = ["1313579440F2036","2921522980M5644"]
Ausgabe: 0
Erklärung: Keiner der Passagiere ist älter als 60.

Einschränkungen:

1 <= details.length <= 100
details[i].length == 15
details[i] besteht aus Ziffern von '0' bis '9'.
details[i][10] ist entweder 'M' oder 'F' oder 'O'.
Die Telefonnummern und Sitznummern der Passagiere sind unterschiedlich.

Sie erhalten ein 0-indiziertes Array mit Zeichenfolgendetails. Jedes Detailelement liefert Informationen über einen bestimmten Passagier, komprimiert in einer Zeichenfolge der Länge 15. Das System ist so aufgebaut, dass:

Die ersten zehn Zeichen bestehen aus der Telefonnummer der Passagiere.
Das nächste Zeichen gibt das Geschlecht der Person an.
Die folgenden zwei Zeichen werden verwendet, um das Alter der Person anzugeben.
Die letzten beiden Zeichen bestimmen den dieser Person zugewiesenen Sitzplatz.

Geben Sie die Anzahl der Passagiere an, die älter als 60 Jahre sind.

Beispiel 1:

Eingabe: Details = ["7868190130M7522","5303914400F9211","9273338290F4010"]
Ausgabe: 2
Erläuterung: Die Passagiere mit den Indizes 0, 1 und 2 sind 75, 92 und 40 Jahre alt. Es gibt also 2 Personen, die über 60 Jahre alt sind.

Beispiel 2:

Eingabe: Details = ["1313579440F2036","2921522980M5644"]
Ausgabe: 0
Erläuterung: Keiner der Passagiere ist älter als 60 Jahre.

Einschränkungen:

1 <= Details.Länge <= 100
Details[i].length == 15
details[i] besteht aus Ziffern von „0“ bis „9“.
details[i][10] ist entweder „M“ oder „F“ oder „O“.
Die Telefonnummern und Sitzplatznummern der Passagiere sind unterschiedlich.

Sie erhalten ein 0-indiziertes Array mit Zeichenfolgendetails. Jedes Detailelement liefert Informationen über einen bestimmten Passagier, komprimiert in einer Zeichenfolge der Länge 15. Das System ist so aufgebaut, dass:

Die ersten zehn Zeichen bestehen aus der Telefonnummer der Passagiere.
Das nächste Zeichen gibt das Geschlecht der Person an.
Die folgenden zwei Zeichen werden verwendet, um das Alter der Person anzugeben.
Die letzten beiden Zeichen bestimmen den dieser Person zugewiesenen Sitzplatz.

Geben Sie die Anzahl der Passagiere an, die unbedingt älter als 60 Jahre sind.

Beispiel 1:

Eingabe: Details = ["7868190130M7522",5303914400F9211","9273338290F4010"]
Ausgabe: 2
Erläuterung: Die Passagiere mit den Indizes 0, 1 und 2 sind 75, 92 und 40 Jahre alt. Es gibt also 2 Personen, die über 60 Jahre alt sind.

Beispiel 2:

Eingabe: Details = ["1313579440F2036","2921522980M5644"]
Ausgabe: 0
Erläuterung: Keiner der Passagiere ist älter als 60 Jahre.

Einschränkungen:

1 <= Details.Länge <= 100
Details[i].length == 15
details[i] besteht aus Ziffern von „0“ bis „9“.
details[i][10] ist entweder „M“ oder „F“ oder „O“.
Die Telefonnummern und Sitzplatznummern der Passagiere sind unterschiedlich.


Sie erhalten ein 0-indiziertes 2D-Integer-Array nums. Zu Beginn beträgt Ihr Punktestand 0. Führen Sie die folgenden Operationen aus, bis die Matrix leer ist:

Wählen Sie aus jeder Zeile der Matrix die größte Zahl aus und entfernen Sie sie. Bei Gleichstand spielt es keine Rolle, welche Nummer gewählt wird.
Identifizieren Sie die höchste Zahl aller in Schritt 1 entfernten Zahlen. Addieren Sie diese Zahl zu Ihrer Punktzahl.

Geben Sie das Endergebnis zurück.

Beispiel 1:

Eingabe: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
Ausgabe: 15
Erläuterung: In der ersten Operation entfernen wir 7, 6, 6 und 3. Anschließend addieren wir 7 zu unserem Punktestand. Als nächstes entfernen wir 2, 4, 5 und 2. Wir addieren 5 zu unserem Punktestand. Zuletzt entfernen wir 1, 2, 3 und 1. Wir addieren 3 zu unserem Punktestand. Somit ist unser Endergebnis 7 + 5 + 3 = 15.

Beispiel 2:

Eingabe: nums = [[1]]
Ausgabe: 1
Erläuterung: Wir entfernen 1 und fügen sie der Antwort hinzu. Wir geben 1 zurück.

Einschränkungen:

1 <= Anzahl.Länge <= 300
1 <= nums[i].length <= 500
0 <= nums[i][j] <= 10^3


Sie erhalten ein 0-indiziertes Ganzzahlarray mit der Länge n und einer Ganzzahl k. In einer Operation können Sie ein Element auswählen und es mit 2 multiplizieren.
Geben Sie den maximal möglichen Wert von nums[0] | nums[1] | ... | nums[n - 1] zurück, die erhalten werden können, nachdem die Operation höchstens k-mal auf nums angewendet wurde.
Beachten Sie, dass ein | b bezeichnet die bitweise oder zwischen zwei ganzen Zahlen a und b.

Beispiel 1:

Eingabe: nums = [12,9], k = 1
Ausgabe: 30
Erläuterung: Wenn wir die Operation auf Index 1 anwenden, sind unsere neuen Array-Nummern gleich [12,18]. Somit geben wir das bitweise ODER von 12 und 18 zurück, also 30.

Beispiel 2:

Eingabe: nums = [8,1,2], k = 2
Ausgabe: 35
Erläuterung: Wenn wir die Operation zweimal auf den Index 0 anwenden, erhalten wir ein neues Array [32,1,2]. Somit geben wir 32|1|2 = 35 zurück.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahlarray mit der Länge n und einer Ganzzahl k. In einer Operation können Sie ein Element auswählen und es mit 2 multiplizieren.
Geben Sie den maximal möglichen Wert von nums[0] | nums[1] | ... | nums[n - 1] zurück, die erhalten werden können, nachdem die Operation höchstens k-mal auf nums angewendet wurde.
Beachten Sie, dass ein | b bezeichnet die bitweise oder zwischen zwei ganzen nums a und b.

Beispiel 1:

Eingabe: nums = [12,9], k = 1
Ausgabe: 30
Erläuterung: Wenn wir die Operation auf Index 1 anwenden, sind unsere neuen Array-Nummern gleich [12,18]. Somit geben wir das bitweise ODER von 12 und 18 zurück, also 30.

Beispiel 2:

Eingabe: nums = [8,1,2], k = 2
Ausgabe: 35
Erläuterung: Wenn wir die Operation zweimal auf den Index 0 anwenden, erhalten wir ein neues Array [32,1,2]. Somit geben wir 32|1|2 = 35 zurück.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahlarray mit der Länge n und einer Ganzzahl k. In einer Operation können Sie ein Element auswählen und es mit 2 multiplizieren.
Geben Sie den maximal möglichen Wert von nums[0] | nums[1] | ... | nums[n - 1] zurück, die erhalten werden können, nachdem die Operation höchstens k-mal auf nums angewendet wurde.
Beachten Sie, dass ein | b bezeichnet die bitweise oder zwischen zwei ganzen nums a und b.

Beispiel 1:

Eingabe: nums = [12,9], k = 1
Ausgabe: 30
Erläuterung: Wenn wir die Operation auf Index 1 anwenden, sind unsere neuen Array-Nummern gleich [12,18]. Somit geben wir das bitweise ODER von 12 und 18 zurück, also 30.

Beispiel 2:

Eingabe: nums = [8,1,2], k = 2
Ausgabe: 35
Erläuterung: wenn wir die Operation zweimal auf den Index 0 anwenden, erhalten wir ein neues Array [32,1,2]. Somit geben wir 32|1|2 = 35 zurück.

Einschränkungen:

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


Es wird Ihnen ein 0-indiziertes ganzzahliges Array 'nums' gegeben, das die Punktzahl der Schüler in einer Prüfung darstellt. Der Lehrer möchte eine nicht leere Gruppe von Schülern mit maximaler Stärke bilden, wobei die Stärke einer Gruppe von Schülern mit den Indizes i_0, i_1, i_2, ..., i_k als nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k] definiert ist.
Gibt die maximale Stärke einer Gruppe zurück, die der Lehrer erstellen kann.

Beispiel 1:

Eingabe: nums = [3,-1,-5,2,5,-9]
Ausgabe: 1350
Erläuterung: Eine Möglichkeit, eine Gruppe maximaler Stärke zu bilden, besteht darin, die Schüler nach Indizes [0,2,3,4,5] zu gruppieren. Ihre Stärke beträgt 3 * (-5) * 2 * 5 * (-9) = 1350, was optimal ist..

Beispiel 2:

Eingabe: nums = [-4,-5,-4]
Ausgabe: 20
Erläuterung: Gruppieren Sie die Schüler nach den Indizes [0, 1] . Dann haben wir eine resultierende Stärke von 20. Eine größere Stärke ist nicht erreichbar.

Einschränkungen:

1 <= nums.length <= 13
-9 <= nums[i] <= 9

Sie erhalten ein 0-indiziertes ganzzahliges Array „nums“, das die Punktzahl der Schüler in einer Prüfung darstellt. Der Lehrer möchte eine nicht leere Gruppe von Schülern mit maximaler Stärke bilden, wobei die Stärke einer Gruppe von Schülern mit den Indizes i_0, i_1, i_2, ..., i_k als nums[i_0] * nums[i_1] definiert ist. * nums[i_2] * ... * nums[i_k].
Gibt die maximale Stärke einer Gruppe zurück, die der Lehrer erstellen kann.

Beispiel 1:

Eingabe: nums = [3,-1,-5,2,5,-9]
Ausgabe: 1350
Erläuterung: Eine Möglichkeit, eine Gruppe maximaler Stärke zu bilden, ist die Gruppierung der Schüler nach den Indizes [0,2,3,4,5]. Ihre Stärke beträgt 3 * (-5) * 2 * 5 * (-9) = 1350, was unserer Meinung nach optimal ist.

Beispiel 2:

Eingabe: nums = [-4,-5,-4]
Ausgabe: 20
Erläuterung: Gruppieren Sie die Schüler nach den Indizes [0, 1] . Dann haben wir eine resultierende Stärke von 20. Eine größere Stärke können wir nicht erreichen.

Einschränkungen:

1 <= nums.length <= 13
-9 <= nums[i] <= 9

Sie erhalten ein 0-indiziertes ganzzahliges Array „nums“, das die Punktzahl der Schüler in einer Prüfung darstellt. Der Lehrer möchte eine nicht leere Gruppe von Schülern mit maximaler Stärke bilden, wobei die Stärke einer Gruppe von Schülern mit den Indizes i_0, i_1, i_2, ..., i_k als nums[i_0] * nums[i_1] * nums[i_2] * ... * nums[i_k].
Gibt die maximale Stärke einer Gruppe zurück, die der Lehrer erstellen kann.

Beispiel 1:

Eingabe: nums = [3,-1,-5,2,5,-9]
Ausgabe: 1350
Erläuterung: Eine Möglichkeit, eine Gruppe maximaler Stärke zu bilden, besteht darin, die Schüler nach Indizes [0,2,3,4,5] zu gruppieren. Ihre Stärke beträgt 3 * (-5) * 2 * 5 * (-9) = 1350, was als optimal nachgewiesen werden kann" or "was als optimal gezeigt werden kann.

Beispiel 2:

Eingabe: nums = [-4,-5,-4]
Ausgabe: 20
Erläuterung: Gruppieren Sie die Schüler nach den Indizes [0, 1] . Dann haben wir eine resultierende Stärke von 20. Eine größere Stärke können wir nicht erreichen.

Einschränkungen:

1 <= nums.Länge <= 13
-9 <= nums[i] <= 9


Sie erhalten eine 0-indizierte Zeichenfolge s und ein Wörterbuch mit Wörtern. Sie müssen s in eine oder mehrere nicht überlappende Teilzeichenfolgen aufteilen, sodass jede Teilzeichenfolge im Wörterbuch vorhanden ist. Möglicherweise gibt es in s einige zusätzliche Zeichen, die in keinem der Teilstrings vorhanden sind.
Geben Sie die minimale Anzahl zusätzlicher Zeichen zurück, die übrig bleiben, wenn Sie s optimal aufteilen.

Beispiel 1:

Eingabe: s = „leetscode“, dictionary = [„leet“, „code“, „leetcode“]
Ausgabe: 1
Erläuterung: Wir können s in zwei Teilzeichenfolgen aufteilen: „leet“ von Index 0 bis 3 und „code“ von Index 5 bis 8. Es gibt nur 1 unbenutztes Zeichen (bei Index 4), also geben wir 1 zurück.

Beispiel 2:

Eingabe: s = „sayhelloworld“, dictionary = [„hello“, „world“]
Ausgabe: 3
Erläuterung: Wir können s in zwei Teilzeichenfolgen aufteilen: „hello“ von Index 3 bis 7 und „world“ von Index 8 bis 12. Die Zeichen an den Indizes 0, 1, 2 werden in keiner Teilzeichenfolge verwendet und werden daher als zusätzliche Zeichen betrachtet . Daher geben wir 3 zurück.

Einschränkungen:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] und s bestehen nur aus englischen Kleinbuchstaben
Das Wörterbuch enthält verschiedene Wörter

Sie erhalten eine 0-indizierte Zeichenkette s und ein Wörterbuch mit Wörtern dictionary. Sie müssen s in eine oder mehrere sich nicht überschneidende Teilzeichenketten zerlegen, so dass jede Teilzeichenkette im Wörterbuch enthalten ist. Es kann einige zusätzliche Zeichen in s geben, die in keiner der Teilzeichenketten enthalten sind.
Geben Sie die minimale Anzahl von zusätzlichen Zeichen zurück, die übrig bleiben, wenn Sie s optimal aufteilen.

Beispiel 1:

Eingabe: s = "leetscode", dictionary = ["leet","code","leetcode"]
Ausgabe: 1
Erläuterung: Wir können s in zwei Teilstrings zerlegen: „leet“ von Index 0 bis 3 und „code“ von Index 5 bis 8. Es gibt nur 1 unbenutztes Zeichen (bei Index 4), also geben wir 1 zurück.

Beispiel 2:

Eingabe: s = "sayhelloworld", dictionary = ["hello","world"]
Ausgabe: 3
Erläuterung: Wir können s in zwei Teilstrings zerlegen: „hallo“ von Index 3 bis 7 und „Welt“ von Index 8 bis 12. Die Zeichen bei den Indizes 0, 1, 2 werden in keiner Teilzeichenkette verwendet und werden daher als zusätzliche Zeichen betrachtet. Daher wird 3 zurückgegeben.

Beschränkungen:

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] und s bestehen nur aus englischen Kleinbuchstaben
dictionary enthält eindeutige Wörter


Sie erhalten ein ganzzahliges Array von Preisen, das die Preise verschiedener Pralinen in einem Geschäft darstellt. Sie erhalten außerdem eine einzelne ganze Zahl, die Ihren ursprünglichen Geldbetrag darstellt.
Sie müssen genau zwei Pralinen so kaufen, dass noch nicht negatives Restgeld übrig bleibt. Sie möchten die Summe der Preise der beiden Pralinen, die Sie kaufen, minimieren.
Geben Sie den Geldbetrag zurück, der nach dem Kauf der beiden Pralinen übrig bleibt. Wenn es für Sie keine Möglichkeit gibt, zwei Pralinen zu kaufen, ohne Schulden zu machen, geben Sie das Geld zurück. Beachten Sie, dass der Rest nicht negativ sein darf.

Beispiel 1:

Eingabe: Preise = [1,2,2], Geld = 3
Ausgabe: 0
Erläuterung: Kaufen Sie die Pralinen zum Preis von 1 bzw. 2 Einheiten. Danach haben Sie 3 - 3 = 0 Geldeinheiten. Somit geben wir 0 zurück.

Beispiel 2:

Eingabe: Preise = [3,2,3], Geld = 3
Ausgabe: 3
Erläuterung: Man kann nicht 2 Pralinen kaufen, ohne Schulden zu machen, also geben wir 3 zurück.

Einschränkungen:

2 <= Preise.Länge <= 50
1 <= Preise[i] <= 100
1 <= Geld <= 100

Sie erhalten ein ganzzahliges Array Preise, das die Preise der verschiedenen Schokoladen in einem Geschäft darstellt. Außerdem erhalten Sie eine ganzzahlige Zahl money, die Ihren ursprünglichen Geldbetrag darstellt.
Sie müssen genau zwei Pralinen kaufen, und zwar so, dass Sie noch einen nicht-negativen Restbetrag übrig haben. Sie möchten die Summe der Preise der beiden Pralinen, die Sie kaufen, minimieren.
Geben Sie den Geldbetrag zurück, der Ihnen nach dem Kauf der beiden Pralinen übrig bleibt. Wenn Sie keine Möglichkeit haben, zwei Pralinen zu kaufen, ohne sich zu verschulden, geben Sie das Geld zurück. Beachten Sie, dass der Restbetrag nicht negativ sein darf.

Beispiel 1:

Eingabe: prices = [1,2,2], money = 3
Ausgabe: 0
Erläuterung: Kaufe die Pralinen zum Preis von 1 bzw. 2 Einheiten. Sie haben danach 3 - 3 = 0 Geldeinheiten. Wir geben also 0 zurück.

Beispiel 2:

Eingabe: prices = [3,2,3], money = 3
Ausgabe: 3
Erläuterung: Man kann nicht 2 Pralinen kaufen, ohne sich zu verschulden, also geben wir 3 aus.

Randbedingungen:

2 <= prices.length <= 50
1 <= prices[i] <= 100
1 <= money <= 100


Du erhältst zwei numerische Zeichenketten num1 und num2 sowie zwei ganze Zahlen max_sum und min_sum. Wir bezeichnen eine ganze Zahl x als gut, wenn:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Gib die Anzahl der guten ganzen Zahlen zurück. Da das Ergebnis groß sein kann, gib es modulo 10^9 + 7 zurück. Beachte, dass digit_sum(x) die Summe der Ziffern von x bezeichnet.

Beispiel 1:

Input: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Output: 11
Erläuterung: Es gibt 11 ganze Zahlen, deren Ziffernsumme zwischen 1 und 8 liegt: 1,2,3,4,5,6,7,8,10,11 und 12. Daher geben wir 11 zurück.

Beispiel 2:

Input: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Output: 5
Erläuterung: Die 5 ganzen Zahlen, deren Ziffernsumme zwischen 1 und 5 liegt, sind 1,2,3,4 und 5. Daher geben wir 5 zurück.

Einschränkungen:

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400

Sie erhalten zwei numerische Zeichenfolgen num1 und num2 sowie zwei Ganzzahlen max_sum und min_sum. Wir bezeichnen eine ganze Zahl x als gut, wenn:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Gibt die Anzahl guter Ganzzahlen zurück. Da die Antwort groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Beachten Sie, dass digit_sum(x) die Summe der Ziffern von x bezeichnet.

Beispiel 1:

Eingabe: num1 = „1“, num2 = „12“, min_sum = 1, max_sum = 8
Ausgabe: 11
Erläuterung: Es gibt 11 ganze Zahlen, deren Ziffernsumme zwischen 1 und 8 liegt: 1,2,3,4,5,6,7,8,10,11 und 12. Somit geben wir 11 zurück.

Beispiel 2:

Eingabe: num1 = „1“, num2 = „5“, min_sum = 1, max_sum = 5
Ausgabe: 5
Erläuterung: Die 5 ganzen Zahlen, deren Ziffernsumme zwischen 1 und 5 liegt, sind 1,2,3,4 und 5. Somit geben wir 5 zurück.

Einschränkungen:

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400

Sie erhalten zwei numerische Zeichenketten num1 und num2 und zwei ganze Zahlen max_sum und min_sum. Wir bezeichnen eine ganze Zahl x als gut, wenn:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Geben Sie die Anzahl der guten ganzen Zahlen zurück. Da die Antwort groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.
Beachten Sie, dass digit_sum(x) die Summe der Ziffern von x angibt.

Beispiel 1:

Eingabe: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Ausgabe: 11
Erläuterung: Es gibt 11 ganze Zahlen, deren Summe der Ziffern zwischen 1 und 8 liegt: 1,2,3,4,5,6,7,8,10,11 und 12. Wir geben also 11 zurück.

Beispiel 2:

Eingabe: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Ausgabe: 5
Erläuterung: Die 5 ganzen Zahlen, deren Summe der Ziffern zwischen 1 und 5 liegt, sind 1,2,3,4, und 5. Wir geben also 5 zurück.

Randbedingungen:

1 <= num1 <= num2 <= 10^22
1 <= min_sum <= max_sum <= 400


Du hast ein 0-indiziertes Array nums der Länge n gegeben.
Das Array der eindeutigen Unterschiede von nums ist ein Array diff der Länge n, sodass diff[i] gleich der Anzahl der eindeutigen Elemente im Suffix nums[i + 1, ..., n - 1] minus der Anzahl der eindeutigen Elemente im Präfix nums[0, ..., i] ist.
Gib das Array der eindeutigen Unterschiede von nums zurück.
Beachte, dass nums[i, ..., j] den Teilarray von nums bezeichnet, der bei Index i beginnt und bei Index j einschließlich endet. Insbesondere, wenn i > j, bezeichnet nums[i, ..., j] ein leeres Teilarray.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: [-3,-1,1,3,5]
Erklärung: Für Index i = 0 gibt es 1 Element im Präfix und 4 verschiedene Elemente im Suffix. Somit ist diff[0] = 1 - 4 = -3.
Für Index i = 1 gibt es 2 verschiedene Elemente im Präfix und 3 verschiedene Elemente im Suffix. Somit ist diff[1] = 2 - 3 = -1.
Für Index i = 2 gibt es 3 verschiedene Elemente im Präfix und 2 verschiedene Elemente im Suffix. Somit ist diff[2] = 3 - 2 = 1.
Für Index i = 3 gibt es 4 verschiedene Elemente im Präfix und 1 verschiedenes Element im Suffix. Somit ist diff[3] = 4 - 1 = 3.
Für Index i = 4 gibt es 5 verschiedene Elemente im Präfix und keine Elemente im Suffix. Somit ist diff[4] = 5 - 0 = 5.

Beispiel 2:

Eingabe: nums = [3,2,3,4,2]
Ausgabe: [-2,-1,0,2,3]
Erklärung: Für Index i = 0 gibt es 1 Element im Präfix und 3 verschiedene Elemente im Suffix. Somit ist diff[0] = 1 - 3 = -2.
Für Index i = 1 gibt es 2 verschiedene Elemente im Präfix und 3 verschiedene Elemente im Suffix. Somit ist diff[1] = 2 - 3 = -1.
Für Index i = 2 gibt es 2 verschiedene Elemente im Präfix und 2 verschiedene Elemente im Suffix. Somit ist diff[2] = 2 - 2 = 0.
Für Index i = 3 gibt es 3 verschiedene Elemente im Präfix und 1 verschiedenes Element im Suffix. Somit ist diff[3] = 3 - 1 = 2.
Für Index i = 4 gibt es 3 verschiedene Elemente im Präfix und keine Elemente im Suffix. Somit ist diff[4] = 3 - 0 = 3.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Array nums der Länge n.
Das Distinct-Difference-Array von Nums ist ein Array Diff der Länge n, sodass diff[i] gleich der Anzahl der Distinct-Elemente im Suffix Nums[i + 1, ..., n - 1] ist, subtrahiert von der Anzahl der Distinct Elemente im Präfix nums[0, ..., i].
Gibt das eindeutige Differenzarray von Zahlen zurück.
Beachten Sie, dass nums[i, ..., j] das Subarray von nums bezeichnet, das bei Index i beginnt und bei Index j endet. Insbesondere wenn i > j, dann bezeichnet nums[i, ..., j] ein leeres Subarray.

Beispiel 1:

Eingabe: nums = [1,2,3,4,5]
Ausgabe: [-3,-1,1,3,5]
Erläuterung: Für Index i = 0 gibt es 1 Element im Präfix und 4 verschiedene Elemente im Suffix. Somit ist diff[0] = 1 - 4 = -3.
Für Index i = 1 gibt es 2 unterschiedliche Elemente im Präfix und 3 unterschiedliche Elemente im Suffix. Somit ist diff[1] = 2 - 3 = -1.
Für Index i = 2 gibt es 3 unterschiedliche Elemente im Präfix und 2 unterschiedliche Elemente im Suffix. Somit ist diff[2] = 3 - 2 = 1.
Für Index i = 3 gibt es 4 unterschiedliche Elemente im Präfix und 1 unterschiedliche Elemente im Suffix. Somit ist diff[3] = 4 - 1 = 3.
Für den Index i = 4 gibt es 5 verschiedene Elemente im Präfix und keine Elemente im Suffix. Somit ist diff[4] = 5 - 0 = 5.

Beispiel 2:

Eingabe: nums = [3,2,3,4,2]
Ausgabe: [-2,-1,0,2,3]
Erläuterung: Für Index i = 0 gibt es 1 Element im Präfix und 3 verschiedene Elemente im Suffix. Somit ist diff[0] = 1 - 3 = -2.
Für Index i = 1 gibt es 2 unterschiedliche Elemente im Präfix und 3 unterschiedliche Elemente im Suffix. Somit ist diff[1] = 2 - 3 = -1.
Für den Index i = 2 gibt es zwei unterschiedliche Elemente im Präfix und zwei unterschiedliche Elemente im Suffix. Somit ist diff[2] = 2 - 2 = 0.
Für den Index i = 3 gibt es 3 unterschiedliche Elemente im Präfix und 1 unterschiedliche Elemente im Suffix. Somit ist diff[3] = 3 - 1 = 2.
Für den Index i = 4 gibt es drei verschiedene Elemente im Präfix und keine Elemente im Suffix. Somit ist diff[4] = 3 - 0 = 3.

Einschränkungen:

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


Es gibt ein 0-indiziertes Array nums der Länge n. Ursprünglich sind alle Elemente ungefärbt (haben den Wert 0).
Du erhältst ein 2D-Integer-Array queries, wobei queries[i] = [index_i, color_i].
Für jede Anfrage färbst du den Index index_i mit der Farbe color_i im Array nums.
Gib ein Array answer derselben Länge wie queries zurück, wobei answer[i] die Anzahl der gleichfarbigen benachbarten Elemente nach der i-ten Anfrage ist.
Formal ist answer[i] die Anzahl der Indizes j, so dass 0 <= j < n - 1 und nums[j] == nums[j + 1] und nums[j] != 0 nach der i-ten Anfrage.

Beispiel 1:

Eingabe: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Ausgabe: [0,1,1,0,2]
Erläuterung: Ursprünglich ist das Array nums = [0,0,0,0], wobei 0 ungefärbte Elemente des Arrays bezeichnet.
- Nach der 1. Anfrage nums = [2,0,0,0]. Die Anzahl der benachbarten Elemente mit derselben Farbe ist 0.
- Nach der 2. Anfrage nums = [2,2,0,0]. Die Anzahl der benachbarten Elemente mit derselben Farbe ist 1.
- Nach der 3. Anfrage nums = [2,2,0,1]. Die Anzahl der benachbarten Elemente mit derselben Farbe ist 1.
- Nach der 4. Anfrage nums = [2,1,0,1]. Die Anzahl der benachbarten Elemente mit derselben Farbe ist 0.
- Nach der 5. Anfrage nums = [2,1,1,1]. Die Anzahl der benachbarten Elemente mit derselben Farbe ist 2.

Beispiel 2:

Eingabe: n = 1, queries = [[0,100000]]
Ausgabe: [0]
Erläuterung: Ursprünglich ist das Array nums = [0], wobei 0 ungefärbte Elemente des Arrays bezeichnet.
- Nach der 1. Anfrage nums = [100000]. Die Anzahl der benachbarten Elemente mit derselben Farbe ist 0.

Einschränkungen:

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <= color_i <= 10^5

Es gibt ein 0-indiziertes Array nums der Länge n. Zunächst sind alle Elemente ungefärbt (hat den Wert 0).
Sie erhalten eine 2D-Integer-Array-Abfrage, bei der query[i] = [index_i, color_i] ist.
Für jede Abfrage färben Sie den Index index_i mit der Farbe color_i im Array nums.
Gibt eine Array-Antwort mit derselben Länge wie Abfragen zurück, wobei Antwort[i] die Anzahl benachbarter Elemente mit derselben Farbe nach der i^-ten Abfrage ist.
Formeller ausgedrückt ist Antwort[i] die Anzahl der Indizes j, sodass 0 <= j < n - 1 und nums[j] == nums[j + 1] und nums[j] != 0 nach dem i^ten Abfrage.

Beispiel 1:

Eingabe: n = 4, Abfragen = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Ausgabe: [0,1,1,0,2]
Erläuterung: Anfänglich gilt Array-Nummern = [0,0,0,0], wobei 0 ungefärbte Elemente des Arrays bezeichnet.
- Nach der 1. Abfrage nums = [2,0,0,0]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 0.
- Nach der 2. Abfrage nums = [2,2,0,0]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 1.
- Nach der 3. Abfrage nums = [2,2,0,1]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 1.
- Nach der 4. Abfrage nums = [2,1,0,1]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 0.
- Nach der 5. Abfrage nums = [2,1,1,1]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 2.

Beispiel 2:

Eingabe: n = 1, Abfragen = [[0,100000]]
Ausgabe: [0]
Erläuterung: Anfänglich gilt Array-Nummern = [0], wobei 0 ungefärbte Elemente des Arrays bezeichnet.
- Nach der 1. Abfrage nums = [100000]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 0.

Einschränkungen:

1 <= n <= 10^5
1 <= query.length <= 10^5
query[i].length == 2
0 <= index_i <= n - 1
1 <= color_i <= 10^5

Es gibt eine 0-indizierte Array-Anzahl der Länge n. Zunächst sind alle Elemente nicht geolgt (hat einen Wert von 0).
Sie erhalten ein 2D -Integer -Array -Abfragen, bei dem Abfragen [i] = [index_i, color_i].
Für jede Abfrage färben Sie den Index index_i mit der color color_i in den Array -nums.
Geben Sie eine Array-Antwort der gleichen Länge wie Abfragen zurück, bei denen die Antwort [i] die Anzahl der benachbarten Elemente mit der gleichen Farbe nach der Abfrage ist.
Formaler ist die Antwort [i] die Anzahl der Indizes j, so dass 0 <= j <n - 1 und nums [j] == nums [j + 1] und nums [j] ! = 0 nach dem i^th Abfrage.

Beispiel 1:

Eingabe: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
Ausgabe: [0,1,1,0,2]
Erläuterung: Zunächst Array nums = [0,0,0,0], wobei 0 ungesetzte Elemente des Arrays bezeichnet.
- nach der 1. Abfrage nums = [2,0,0,0]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 0.
- nach dem 2^nd Abfrage nums = [2,2,0,0]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 1.
- Nach dem 3^rd -Abfrage nums = [2,2,0,1]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 1.
- nach dem 4^th Abfrage nums = [2,1,0,1]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 0.
- nach dem 5^th Abfrage nums = [2,1,1,1]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 2.

Beispiel 2:

Eingabe: n = 1, queries = [[0,100000]]
Ausgabe: [0]
Erläuterung: Anfänglich Array nums = [0], wobei 0 unpolierte Elemente des Arrays bezeichnet.
- nach dem 1^st Query nums = [100000]. Die Anzahl benachbarter Elemente mit derselben Farbe beträgt 0.

Einschränkungen:

1 <= n <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 2
0 <= index_i <= n - 1
1 <=  color_i <= 10^5


Sie erhalten ein 0-indiziertes Ganzzahl-Array, das die Stärke einiger Helden darstellt. Die Macht einer Heldengruppe wird wie folgt definiert:

Seien i_0, i_1, ... ,i_k die Indizes der Helden in einer Gruppe. Dann ist die Macht dieser Gruppe max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[ i_k]).

Gib die Summe der Kräfte aller möglichen nicht leeren Heldengruppen zurück. Da die Summe sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: nums = [2,1,4]
Ausgabe: 141
Erläuterung:
1. Gruppe: [2] hat Macht = 2^2 * 2 = 8.
2. Gruppe: [1] hat Macht = 1^2 * 1 = 1.
3. Gruppe: [4] hat Macht = 4^2 * 4 = 64.
4. Gruppe: [2,1] hat Macht = 2^2 * 1 = 4.
5. Gruppe: [2,4] hat Macht = 4^2 * 2 = 32.
6. Gruppe: [1,4] hat Macht = 4^2 * 1 = 16.
7. Gruppe: [2,1,4] hat Macht = 4^2 * 1 = 16.
Die Summe der Macht aller Gruppen beträgt 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Beispiel 2:

Eingabe: nums = [1,1,1]
Ausgabe: 7
Erläuterung: Insgesamt sind 7 Gruppen möglich, und die Macht jeder Gruppe beträgt 1. Daher beträgt die Summe der Macht aller Gruppen 7.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array, das die Stärke einiger Helden darstellt. Die Macht einer Heldengruppe wird wie folgt definiert:

Seien i_0, i_1, ... ,i_k die Indizes der Helden in einer Gruppe. Dann ist die Macht dieser Gruppe max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[ i_k]).

Gib die Summe der Kräfte aller möglichen nicht leeren Heldengruppen zurück. Da die Summe sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: nums = [2,1,4]
Ausgabe: 141
Erläuterung:
1. Gruppe: [2] hat Macht = 2^2 * 2 = 8.
2. Gruppe: [1] hat Macht = 1^2 * 1 = 1.
3. Gruppe: [4] hat Macht = 4^2 * 4 = 64.
4. Gruppe: [2,1] hat Macht = 2^2 * 1 = 4.
5. Gruppe: [2,4] hat Macht = 4^2 * 2 = 32.
6. Gruppe: [1,4] hat Macht = 4^2 * 1 = 16.
7. Gruppe: [2,1,4] hat Macht = 4^2 * 1 = 16.
Die Summe der Potenzen aller Gruppen beträgt 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Beispiel 2:

Eingabe: nums = [1,1,1]
Ausgabe: 7
Erläuterung: Insgesamt sind 7 Gruppen möglich, und die Macht jeder Gruppe beträgt 1. Daher beträgt die Summe der Potenzen aller Gruppen 7.

Einschränkungen:

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

Sie erhalten ein 0-indiziertes Ganzzahl-Array, das die Stärke einiger Helden darstellt. Die Macht einer Heldengruppe wird wie folgt definiert:

Seien i_0, i_1, ... ,i_k die Indizes der Helden in einer Gruppe. Dann ist die Potenz dieser Gruppe max(nums[i_0], nums[i_1], ... ,nums[i_k])^2 * min(nums[i_0], nums[i_1], ... ,nums[ ich k]).

Gib die Summe der Kräfte aller möglichen nicht leeren Heldengruppen zurück. Da die Summe sehr groß sein kann, geben Sie sie modulo 10^9 + 7 zurück.

Beispiel 1:

Eingabe: nums = [2,1,4]
Ausgabe: 141
Erläuterung:
1^. Gruppe: [2] hat Potenz = 2^2 * 2 = 8.
2^. Gruppe: [1] hat Potenz = 1^2 * 1 = 1.
3. Gruppe: [4] hat Potenz = 4^2 * 4 = 64.
4^. Gruppe: [2,1] hat Potenz = 2^2 * 1 = 4.
5^. Gruppe: [2,4] hat Potenz = 4^2 * 2 = 32.
6^. Gruppe: [1,4] hat Potenz = 4^2 * 1 = 16.
77^te Gruppe: [2,1,4] hat Potenz = 4^2 * 1 = 16.
Die Summe der Potenzen aller Gruppen beträgt 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.

Beispiel 2:

Eingabe: nums = [1,1,1]
Ausgabe: 7
Erläuterung: Insgesamt sind 7 Gruppen möglich, und die Potenz jeder Gruppe beträgt 1. Daher beträgt die Summe der Potenzen aller Gruppen 7.

Einschränkungen:

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


Sie erhalten eine 0-indizierte Permutation von n ganzen Zahlen.
Eine Permutation heißt halbgeordnet, wenn die erste Zahl gleich 1 und die letzte Zahl gleich n ist. Sie können die folgende Operation so oft ausführen, wie Sie möchten, bis Sie Nums zu einer halbgeordneten Permutation machen:

Wählen Sie zwei benachbarte Elemente in Nums aus und tauschen Sie sie dann aus.

Gibt die minimale Anzahl von Operationen zurück, um Nums zu einer halbgeordneten Permutation zu machen.
Eine Permutation ist eine Folge von ganzen Zahlen von 1 bis n der Länge n, die jede Zahl genau einmal enthält.

Beispiel 1:

Eingabe: nums = [2,1,4,3]
Ausgabe: 2
Erläuterung: Mit dieser Operationsfolge können wir die Permutation halbgeordnet gestalten:
1 – vertausche i = 0 und j = 1. Die Permutation wird zu [1,2,4,3].
2 - Vertausche i = 2 und j = 3. Die Permutation wird zu [1,2,3,4].
Es kann bewiesen werden, dass es keine Folge von weniger als zwei Operationen gibt, die Nums zu einer halbgeordneten Permutation machen.

Beispiel 2:

Eingabe: nums = [2,4,1,3]
Ausgabe: 3
Erläuterung: Mit dieser Operationsfolge können wir die Permutation halbgeordnet gestalten:
1 - Vertausche i = 1 und j = 2. Die Permutation wird zu [2,1,4,3].
2 - Vertausche i = 0 und j = 1. Die Permutation wird zu [1,2,4,3].
3 - Vertausche i = 2 und j = 3. Die Permutation wird zu [1,2,3,4].
Es kann bewiesen werden, dass es keine Folge von weniger als drei Operationen gibt, die Nums zu einer halbgeordneten Permutation machen.

Beispiel 3:

Eingabe: nums = [1,3,4,2,5]
Ausgabe: 0
Erläuterung: Die Permutation ist bereits eine halbgeordnete Permutation.

Einschränkungen:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums ist eine Permutation.

Sie erhalten eine 0-indizierte Permutation von n ganzen Zahlen.
Eine Permutation heißt halbgeordnet, wenn die erste Zahl gleich 1 und die letzte Zahl gleich n ist. Sie können die folgende Operation so oft ausführen, wie Sie möchten, bis Sie Nums zu einer halbgeordneten Permutation machen:

Wählen Sie zwei benachbarte Elemente in Zahlen aus und tauschen Sie sie dann aus.

Gibt die Mindestanzahl an Operationen zurück, um Nums zu einer halbgeordneten Permutation zu machen.
Eine Permutation ist eine Folge von ganzen Zahlen von 1 bis n der Länge n, die jede Zahl genau einmal enthält.

Beispiel 1:

Eingabe: nums = [2,1,4,3]
Ausgabe: 2
Erläuterung: Mit dieser Operationsfolge können wir die Permutation halbgeordnet gestalten:
1 – vertausche i = 0 und j = 1. Die Permutation wird zu [1,2,4,3].
2 - Vertausche i = 2 und j = 3. Die Permutation wird zu [1,2,3,4].
Es kann bewiesen werden, dass es keine Folge von weniger als zwei Operationen gibt, die Nums zu einer halbgeordneten Permutation machen.

Beispiel 2:

Eingabe: nums = [2,4,1,3]
Ausgabe: 3
Erläuterung: Mit dieser Operationsfolge können wir die Permutation halbgeordnet gestalten:
1 – vertausche i = 1 und j = 2. Die Permutation wird zu [2,1,4,3].
2 - Vertausche i = 0 und j = 1. Die Permutation wird zu [1,2,4,3].
3 - Vertausche i = 2 und j = 3. Die Permutation wird zu [1,2,3,4].
Es kann bewiesen werden, dass es keine Folge von weniger als drei Operationen gibt, die Nums zu einer halbgeordneten Permutation machen.

Beispiel 3:

Eingabe: nums = [1,3,4,2,5]
Ausgabe: 0
Erläuterung: Die Permutation ist bereits eine halbgeordnete Permutation.

Einschränkungen:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums ist eine Permutation.

Sie erhalten eine 0-indizierte Permutation von n ganzen Zahlen.
Eine Permutation heißt halbgeordnet, wenn die erste Zahl gleich 1 und die letzte Zahl gleich n ist. Sie können die folgende Operation so oft ausführen, wie Sie möchten, bis Sie Nums zu einer halbgeordneten Permutation machen:

Wählen Sie zwei benachbarte Elemente in Zahlen aus und tauschen Sie sie dann aus.

Gibt die Mindestanzahl an Operationen zurück, um Nums zu einer halbgeordneten Permutation zu machen.
Eine Permutation ist eine Folge von ganzen Zahlen von 1 bis n der Länge n, die jede Zahl genau einmal enthält.

Beispiel 1:

Eingabe: nums = [2,1,4,3]
Ausgabe: 2
Erläuterung: Mit dieser Operationsfolge können wir die Permutation halbgeordnet gestalten:
1 – vertausche i = 0 und j = 1. Die Permutation wird zu [1,2,4,3].
2 - Vertausche i = 2 und j = 3. Die Permutation wird zu [1,2,3,4].
Es kann bewiesen werden, dass es keine Folge von weniger als zwei Operationen gibt, die Nums zu einer halbgeordneten Permutation machen.

Beispiel 2:

Eingabe: nums = [2,4,1,3]
Ausgabe: 3
Erläuterung: Mit dieser Operationsfolge können wir die Permutation halbgeordnet gestalten:
1 - Vertausche i = 1 und j = 2. Die Permutation wird zu [2,1,4,3].
2 - Vertausche i = 0 und j = 1. Die Permutation wird zu [1,2,4,3].
3 - Vertausche i = 2 und j = 3. Die Permutation wird zu [1,2,3,4].
Es kann bewiesen werden, dass es keine Folge von weniger als drei Operationen gibt, die Nums zu einer halbgeordneten Permutation machen.

Beispiel 3:

Eingabe: nums = [1,3,4,2,5]
Ausgabe: 0
Erläuterung: Die Permutation ist bereits eine halbgeordnete Permutation.

Einschränkungen:

2 <= nums.length == n <= 50
1 <= nums[i] <= 50
nums ist eine Permutation.


Sie erhalten eine 0-indizierte Zeichenfolge s, die aus Ziffern von 0 bis 9 besteht.
Eine Zeichenfolge t heißt semirepetitiv, wenn sich in t höchstens ein aufeinanderfolgendes Paar gleicher Ziffern befindet. Beispielsweise sind 0010, 002020, 0123, 2002 und 54944 halbwiederholend, während dies bei 00101022 und 1101234883 nicht der Fall ist.
Gibt die Länge des längsten semi-repetitiven Teilstrings innerhalb von s zurück.
Ein Teilstring ist eine zusammenhängende, nicht leere Folge von Zeichen innerhalb eines Strings.

Beispiel 1:

Eingabe: s = „52233“
Ausgabe: 4
Erläuterung: Der längste semi-repetitive Teilstring ist „5223“, der bei i = 0 beginnt und bei j = 3 endet.

Beispiel 2:

Eingabe: s = „5494“
Ausgabe: 4
Erläuterung: s ist eine semi-reptitive Zeichenfolge, daher lautet die Antwort 4.

Beispiel 3:

Eingabe: s = „1111111“
Ausgabe: 2
Erläuterung: Der längste semi-repetitive Teilstring ist „11“, der bei i = 0 beginnt und bei j = 1 endet.

Einschränkungen:

1 <= s.length <= 50
'0' <= s[i] <= '9'


Es gibt n Freunde, die ein Spiel spielen. Die Freunde sitzen im Kreis und werden im Uhrzeigersinn von 1 bis n nummeriert. Formeller ausgedrückt führt Sie eine Bewegung im Uhrzeigersinn vom i^-ten Freund zum (i+1)^-ten Freund für 1 <= i < n, und eine Bewegung im Uhrzeigersinn vom n^-ten Freund bringt Sie zum 1^-ten Freund.
Die Spielregeln lauten wie folgt:
Der erste Freund erhält den Ball.

Danach gibt der 1. Freund es an den Freund weiter, der im Uhrzeigersinn k Schritte von ihm entfernt ist.
Danach sollte der Freund, der den Ball erhält, ihn an den Freund weitergeben, der im Uhrzeigersinn 2 * k Schritte von ihm entfernt ist.
Danach sollte der Freund, der den Ball erhält, ihn an den Freund weitergeben, der im Uhrzeigersinn 3 * k Schritte von ihm entfernt ist, und so weiter und so weiter.

Mit anderen Worten: In der i-ten Runde sollte der Freund, der den Ball hält, ihn an den Freund weitergeben, der i * k Schritte im Uhrzeigersinn von ihm entfernt ist.
Das Spiel endet, wenn ein Freund zum zweiten Mal den Ball erhält.
Verlierer des Spiels sind Freunde, die im gesamten Spiel den Ball nicht erhalten haben.
Geben Sie bei gegebener Anzahl der Freunde, n, und einer ganzen Zahl k die Array-Antwort zurück, die die Verlierer des Spiels in aufsteigender Reihenfolge enthält.

Beispiel 1:

Eingabe: n = 5, k = 2
Ausgabe: [4,5]
Erläuterung: Das Spiel läuft wie folgt ab:
1) Beginnen Sie beim 1. Freund und geben Sie den Ball an den Freund weiter, der 2 Schritte von ihm entfernt ist – den 3. Freund.
2) Der 3. Freund passt den Ball an den Freund, der 4 Schritte von ihm entfernt ist – den 2. Freund.
3) Der 2. Freund gibt den Ball an den Freund weiter, der 6 Schritte von ihm entfernt ist – den 3. Freund.
4) Das Spiel endet, wenn der dritte Freund zum zweiten Mal den Ball erhält.

Beispiel 2:

Eingabe: n = 4, k = 4
Ausgabe: [2,3,4]
Erläuterung: Das Spiel läuft wie folgt ab:
1) Beginnen Sie beim ersten Freund und geben Sie den Ball an den Freund weiter, der 4 Schritte von ihm entfernt ist – den ersten Freund.
2) Das Spiel endet, wenn der erste Freund zum zweiten Mal den Ball erhält.

Einschränkungen:

1 <= k <= n <= 50

Es gibt n Freunde, die ein Spiel spielen. Die Freunde sitzen im Kreis und werden im Uhrzeigersinn von 1 bis n nummeriert. Formeller ausgedrückt führt Sie eine Bewegung im Uhrzeigersinn vom i^-ten Freund zum (i+1)^-ten Freund für 1 <= i < n, und eine Bewegung im Uhrzeigersinn vom n^-ten Freund bringt Sie zum 1^-ten Freund.
Die Spielregeln lauten wie folgt:
Der erste Freund erhält den Ball.

Danach gibt der 1. Freund es an den Freund weiter, der im Uhrzeigersinn k Schritte von ihm entfernt ist.
Danach sollte der Freund, der den Ball erhält, ihn an den Freund weitergeben, der im Uhrzeigersinn 2 * k Schritte von ihm entfernt ist.
Danach sollte der Freund, der den Ball erhält, ihn an den Freund weitergeben, der im Uhrzeigersinn 3 * k Schritte von ihm entfernt ist, und so weiter und so fort.

Mit anderen Worten: In der i-ten Runde sollte der Freund, der den Ball hält, ihn an den Freund weitergeben, der im Uhrzeigersinn i * k Schritte von ihm entfernt ist.
Das Spiel endet, wenn ein Freund zum zweiten Mal den Ball erhält.
Verlierer des Spiels sind Freunde, die den Ball im gesamten Spiel nicht erhalten haben.
Geben Sie bei gegebener Anzahl der Freunde, n, und einer ganzen Zahl k die Array-Antwort zurück, die die Verlierer des Spiels in aufsteigender Reihenfolge enthält.

Beispiel 1:

Eingabe: n = 5, k = 2
Ausgabe: [4,5]
Erläuterung: Das Spiel läuft wie folgt ab:
1) Beginnen Sie beim 1. Freund und geben Sie den Ball an den Freund weiter, der 2 Schritte von ihm entfernt ist – den 3. Freund.
2) Der 3. Freund passt den Ball an den Freund, der 4 Schritte von ihm entfernt ist – den 2. Freund.
3) Der 2. Freund gibt den Ball an den Freund weiter, der 6 Schritte von ihm entfernt ist – den 3. Freund.
4) Das Spiel endet, wenn der dritte Freund zum zweiten Mal den Ball erhält.

Beispiel 2:

Eingabe: n = 4, k = 4
Ausgabe: [2,3,4]
Erläuterung: Das Spiel läuft wie folgt ab:
1) Beginnen Sie beim ersten Freund und geben Sie den Ball an den Freund weiter, der 4 Schritte von ihm entfernt ist – den ersten Freund.
2) Das Spiel endet, wenn der erste Freund zum zweiten Mal den Ball erhält.

Einschränkungen:

1 <= k <= n <= 50


Ein 0-indiziertes Array mit der Länge n wird abgeleitet, indem das bitweise XOR (⊕) benachbarter Werte in einem binären Array-Original der Länge n berechnet wird.
Konkret gilt für jeden Index i im Bereich [0, n - 1]:

Wenn i = n - 1, dann abgeleitet[i] = original[i] ⊕ original[0].
Ansonsten ist abgeleitet[i] = Original[i] ⊕ Original[i + 1].

Bei einem abgeleiteten Array besteht Ihre Aufgabe darin, festzustellen, ob ein gültiges binäres Original-Array-Original vorhanden ist, das abgeleitet sein könnte.
Gibt true zurück, wenn ein solches Array existiert, andernfalls false.

Ein binäres Array ist ein Array, das nur Nullen und Einsen enthält

Beispiel 1:

Eingabe: abgeleitet = [1,1,0]
Ausgabe: wahr
Erläuterungen: Ein gültiges Originalarray, das abgeleitet[i] liefert, ist [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Beispiel 2:

Eingabe: derived = [1,1]
Ausgabe: wahr
Erläuterungen: Ein gültiges Originalarray, das abgeleitet[i] liefert, ist [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Beispiel 3:

Eingabe: derived = [1,0]
Ausgabe: falsch
Erläuterungen: Es gibt kein gültiges Original-Array, das abgeleitet[i] liefert.

Einschränkungen:

n == derived.length
1 <= n <= 10^5
Die abgeleiteten Werte sind entweder 0 oder 1

Ein 0-indiziertes Array, das mit der Länge n abgeleitet wird, wird abgeleitet, indem das bitweise XOR (⊕) benachbarter Werte in einem binären Array der Länge n berechnet wird.
Konkret gilt für jeden Index i im Bereich [0, n - 1]:

Wenn i = n - 1, dann derived[i] = original[i] ⊕ original[0].
Andernfalls ist derived[i] = original[i] ⊕ original[i + 1].

Bei einem abgeleiteten Array besteht Ihre Aufgabe darin, zu bestimmen, ob ein gültiges binäres Array original vorhanden ist, das sich als abgeleitet hätte bilden können.
Gibt true zurück, wenn ein solches Array vorhanden ist, andernfalls false.

Ein binäres Array ist ein Array, das nur 0en und 1en enthält

Beispiel 1:

Eingabe: derived = [1,1,0]
Ausgabe: true
Erläuterung: Ein gültiges ursprüngliches Array, das abgeleitete Arrays ergibt, ist [0,1,0].
derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1
derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1
derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0

Beispiel 2:

Eingabe: derived = [1,1]
Ausgabe: true
Erklärung: Ein gültiges ursprüngliches Array, das abgeleitete Arrays ergibt, ist [0,1].
derived[0] = original[0] ⊕ original[1] = 1
derived[1] = original[1] ⊕ original[0] = 1

Beispiel 3:

Eingabe: derived = [1,0]
Ausgabe: false
Erklärung: Es gibt kein gültiges ursprüngliches Array, das derived angibt.

Zwänge:

n == derived.length
1 <= n <= 10^5
Die abgeleiteten Werte sind entweder 0 oder 1

Ein mit der Länge n Abgeleitet 0-indiziertes Array wird durch Berechnen des bitweisen XOR (⊕) benachbarter Werte in einem binären Array-Original der Länge n Abgeleitet.
Konkret gilt für jeden Index i im Bereich [0, n - 1]:

Wenn i = n - 1, dann Abgeleitet[i] = Original[i] ⊕ Original[0].
Ansonsten ist Abgeleitet[i] = Original[i] ⊕ Original[i + 1].

Bei einem Abgeleitet Array besteht Ihre Aufgabe darin, zu bestimmen, ob ein gültiges binäres Array-Original existiert, das Abgeleitet sein könnte.
"Gibt 'true' zurück, wenn ein solches Array existiert, andernfalls 'false' zurück."

Ein binäres Array ist ein Array, das nur Nullen und Einsen enthält

Beispiel 1:

Eingabe: Abgeleitet = [1,1,0]
Ausgabe: wahr
Erläuterungen: Ein gültiges Originalarray, das Abgeleitet Daten liefert, ist [0,1,0].
Abgeleitet[0] = Original[0] ⊕ Original[1] = 0 ⊕ 1 = 1
Abgeleitet[1] = Original[1] ⊕ Original[2] = 1 ⊕ 0 = 1
Abgeleitet[2] = Original[2] ⊕ Original[0] = 0 ⊕ 0 = 0

Beispiel 2:

Eingabe: Abgeleitet = [1,1]
Ausgabe: wahr
Erläuterungen: Ein gültiges Originalarray, das Abgeleitet Daten liefert, ist [0,1].
Abgeleitet[0] = Original[0] ⊕ Original[1] = 1
Abgeleitet[1] = Original[1] ⊕ Original[0] = 1

Beispiel 3:

Eingabe: Abgeleitet = [1,0]
Ausgabe: falsch
Erläuterungen: Es gibt kein gültiges Originalarray, das Abgeleitet Daten liefert.

Einschränkungen:

n == Abgeleitet.Länge
1 <= n <= 10^5
Die Abgeleitet Werte sind entweder 0 oder 1


Sie erhalten eine Zeichenfolge, die nur aus englischen Großbuchstaben besteht.
Sie können einige Operationen auf diese Zeichenfolge anwenden, bei denen Sie in einer Operation jedes Vorkommen einer der Teilzeichenfolgen „AB“ oder „CD“ aus s entfernen können.
Gibt die minimal mögliche Länge der resultierenden Zeichenfolge zurück, die Sie erhalten können.
Beachten Sie, dass die Zeichenfolge nach dem Entfernen der Teilzeichenfolge verkettet wird und neue Teilzeichenfolgen „AB“ oder „CD“ erzeugen können.

Beispiel 1:

Eingabe: s = „ABFCACDB“
Ausgabe: 2
Erläuterung: Wir können die folgenden Operationen ausführen:
- Entfernen Sie die Teilzeichenfolge „ABFCACDB“, also s = „FCACDB“.
- Entfernen Sie den Teilstring „FCACDB“, also s = „FCAB“.
- Entfernen Sie die Teilzeichenfolge „FCAB“, also s = „FC“.
Die resultierende Länge der Zeichenfolge beträgt also 2.
Es kann gezeigt werden, dass dies die minimale Länge ist, die wir erhalten können.
Beispiel 2:

Eingabe: s = „ACBBD“
Ausgabe: 5
Erläuterung: Wir können keine Operationen an der Zeichenfolge ausführen, daher bleibt die Länge gleich.

Einschränkungen:

1 <= s.length <= 100
s besteht nur aus englischen Großbuchstaben.

Sie erhalten eine Zeichenfolge, die nur aus englischen Großbuchstaben besteht.
Sie können auf diese Zeichenfolge einige Operationen anwenden, bei denen Sie in einer Operation jedes Vorkommen einer der Teilzeichenfolgen „AB“ oder „CD“ aus s entfernen können.
Gibt die minimal mögliche Länge der resultierenden Zeichenfolge zurück, die Sie erhalten können.
Beachten Sie, dass die Zeichenfolge nach dem Entfernen der Teilzeichenfolge verkettet wird und neue Teilzeichenfolgen „AB“ oder „CD“ erzeugen können.

Beispiel 1:

Eingabe: s = „ABFCACDB“
Ausgabe: 2
Erläuterung: Wir können die folgenden Operationen ausführen:
- Entfernen Sie die Teilzeichenfolge „ABFCACDB“, also s = „FCACDB“.
- Entfernen Sie den Teilstring „FCACDB“, also s = „FCAB“.
- Entfernen Sie die Teilzeichenfolge „FCAB“, also s = „FC“.
Die resultierende Länge der Zeichenfolge beträgt also 2.
Es kann gezeigt werden, dass dies die minimale Länge ist, die wir erhalten können.
Beispiel 2:

Eingabe: s = „ACBBD“
Ausgabe: 5
Erläuterung: Wir können keine Operationen an der Zeichenfolge ausführen, daher bleibt die Länge gleich.

Einschränkungen:

1 <= s.length <= 100
s besteht nur aus englischen Großbuchstaben.


Gib bei einer positiven ganzen Zahl n die Bestrafungszahl von n zurück.
Die Bestrafungszahl von n ist definiert als die Summe der Quadrate aller ganzen Zahlen i, die so beschaffen sind, dass:

1 <= i <= n
Die Dezimaldarstellung von i * i kann in zusammenhängende Teilstrings unterteilt werden, so dass die Summe der ganzzahligen Werte dieser Teilstrings gleich i ist.

Beispiel 1:

Eingabe: n = 10
Ausgabe: 182
Erläuterung: Es gibt genau 3 ganze Zahlen i, die die Bedingungen der Anweisung erfüllen:
- 1, da 1 * 1 = 1
- 9, da 9 * 9 = 81 ist und 81 in 8 + 1 zerlegt werden kann.
- 10, da 10 * 10 = 100 ist und 100 in 10 + 0 zerlegt werden kann.
Folglich ist die Strafzahl von 10 1 + 81 + 100 = 182

Beispiel 2:

Eingabe: n = 37
Ausgabe: 1478
Erläuterung: Es gibt genau 4 ganze Zahlen i, die die Bedingungen der Anweisung erfüllen:
- 1, da 1 * 1 = 1.
- 9, da 9 * 9 = 81 ist und 81 in 8 + 1 zerlegt werden kann.
- 10, da 10 * 10 = 100 ist und 100 in 10 + 0 zerlegt werden kann.
- 36, da 36 * 36 = 1296 ist und 1296 in 1 + 29 + 6 zerlegt werden kann.
Folglich ist die Strafzahl von 37 1 + 81 + 100 + 1296 = 1478

Nebenbedingungen:

1 <= n <= 1000

Geben Sie bei einer positiven ganzen Zahl n die Bestrafungszahl von n zurück.
Die Strafzahl von n ist definiert als die Summe der Quadrate aller ganzen Zahlen i, so dass:

1 <= i <= n
Die dezimale Darstellung von i * i kann in zusammenhängende Teilzeichenfolgen unterteilt werden, sodass die Summe der ganzzahligen Werte dieser Teilzeichenfolgen gleich i ist.

Beispiel 1:

Eingabe: n = 10
Ausgabe: 182
Erläuterung: Es gibt genau 3 ganze Zahlen i, die die Bedingungen in der Anweisung erfüllen:
- 1, da 1 * 1 = 1
- 9, da 9 * 9 = 81 und 81 in 8 + 1 unterteilt werden kann.
- 10, da 10 * 10 = 100 und 100 in 10 + 0 aufgeteilt werden kann.
Daher ist die Strafzahl 10 1 + 81 + 100 = 182

Beispiel 2:

Eingabe: n = 37
Ausgabe: 1478
Erläuterung: Es gibt genau 4 ganze Zahlen i, die die Bedingungen in der Anweisung erfüllen:
- 1, da 1 * 1 = 1.
- 9, da 9 * 9 = 81 und 81 in 8 + 1 unterteilt werden kann.
- 10, da 10 * 10 = 100 und 100 in 10 + 0 aufgeteilt werden kann.
- 36, da 36 * 36 = 1296 und 1296 in 1 + 29 + 6 aufgeteilt werden kann.
Daher ist die Strafzahl von 37 1 + 81 + 100 + 1296 = 1478

Einschränkungen:

1 <= n <= 1000


Du hast zwei 0-indizierte Ganzzahl-Arrays, cost und time, der Größe n, die die Kosten und die benötigte Zeit zum Streichen von n verschiedenen Wänden darstellen. Es gibt zwei Maler zur Verfügung:

Ein bezahlter Maler, der die i-te Wand in time[i] Zeiteinheiten streicht und cost[i] Geldeinheiten verlangt.
Ein kostenloser Maler, der jede Wand in 1 Zeiteinheit ohne Kosten streicht. Der kostenlose Maler kann jedoch nur eingesetzt werden, wenn der bezahlte Maler bereits beschäftigt ist.

Gib die minimale Geldmenge zurück, die benötigt wird, um die n Wände zu streichen.

Beispiel 1:

Eingabe: cost = [1,2,3,2], time = [1,2,3,2]
Ausgabe: 3
Erklärung: Die Wände an den Indizes 0 und 1 werden vom bezahlten Maler gestrichen und benötigen 3 Zeiteinheiten; währenddessen wird der kostenlose Maler die Wände an den Indizes 2 und 3 kostenlos in 2 Zeiteinheiten streichen. Somit betragen die Gesamtkosten 1 + 2 = 3.

Beispiel 2:

Eingabe: cost = [2,3,4,2], time = [1,1,1,1]
Ausgabe: 4
Erklärung: Die Wände an den Indizes 0 und 3 werden vom bezahlten Maler gestrichen und benötigen 2 Zeiteinheiten; währenddessen wird der kostenlose Maler die Wände an den Indizes 1 und 2 kostenlos in 2 Zeiteinheiten streichen. Somit betragen die Gesamtkosten 2 + 2 = 4.

Beschränkungen:

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500

Sie erhalten zwei 0-indizierte ganzzahlige Arrays, Kosten und Zeit, der Größe n, die die Kosten bzw. die Zeit darstellen, die zum Streichen von n verschiedenen Wänden benötigt wird. Es stehen zwei Maler zur Verfügung:

Ein bezahlter Maler, der die i^te Wand in Zeiteinheiten malt und dafür Geldeinheiten kostet.
Ein kostenloser Maler, der jede Wand in einer Zeiteinheit zum Preis von 0 streicht. Der kostenlose Maler kann jedoch nur eingesetzt werden, wenn der bezahlte Maler bereits beschäftigt ist.

Geben Sie den Mindestbetrag zurück, der zum Streichen der n Wände erforderlich ist.

Beispiel 1:

Eingabe: Kosten = [1,2,3,2], Zeit = [1,2,3,2]
Ausgabe: 3
Erläuterung: Die Wände bei Index 0 und 1 werden vom bezahlten Maler gestrichen und es wird 3 Zeiteinheiten dauern; In der Zwischenzeit streicht der freie Maler die Wände bei Index 2 und 3 kostenlos in 2 Zeiteinheiten. Somit betragen die Gesamtkosten 1 + 2 = 3.

Beispiel 2:

Eingabe: Kosten = [2,3,4,2], Zeit = [1,1,1,1]
Ausgabe: 4
Erläuterung: Die Wände bei Index 0 und 3 werden vom bezahlten Maler gestrichen und es wird 2 Zeiteinheiten dauern; In der Zwischenzeit streicht der freie Maler die Wände bei Index 1 und 2 kostenlos in 2 Zeiteinheiten. Somit betragen die Gesamtkosten 2 + 2 = 4.

Einschränkungen:

1 <= Kosten.Länge <= 500
Kosten.Länge == Zeit.Länge
1 <= Kosten[i] <= 10^6
1 <= Zeit[i] <= 500

Sie erhalten zwei 0-indizierte ganzzahlige Arrays, cost und time, mit der Größe n, die die Kosten und die Zeit darstellen, die zum Streichen von n verschiedenen Wänden benötigt wird. Es stehen zwei Maler zur Verfügung:

Ein bezahlter Maler, der die i^te Wand in Zeit[i] Zeiteinheiten malt und Kosten[i] Geldeinheiten nimmt.
Ein kostenloser Maler, der jede Wand in 1 Zeiteinheit zu einem Preis von 0 bemalt. Der kostenlose Maler kann aber nur genutzt werden, wenn der bezahlte Maler bereits besetzt ist.

Geben Sie den Mindestbetrag zurück, der zum Streichen der n Wände erforderlich ist.

Beispiel 1:

Eingabe: cost = [1,2,3,2], time = [1,2,3,2]
Ausgang: 3
Erklärung: Die Wände mit Index 0 und 1 werden vom bezahlten Maler gestrichen, und es werden 3 Zeiteinheiten benötigt; In der Zwischenzeit streicht der freie Maler die Wände mit Index 2 und 3, kostenlos in 2 Zeiteinheiten. Somit betragen die Gesamtkosten 1 + 2 = 3.

Beispiel 2:

Eingabe: cost = [2,3,4,2], time = [1,1,1,1]
Ausgang: 4
Erklärung: Die Wände mit Index 0 und 3 werden vom bezahlten Maler gestrichen, und es dauert 2 Zeiteinheiten; In der Zwischenzeit wird der freie Maler die Wände mit Index 1 und 2 kostenlos in 2 Zeiteinheiten streichen. Somit betragen die Gesamtkosten 2 + 2 = 4.

Zwänge:

1 <= cost.length <= 500
cost.length == time.length
1 <= cost[i] <= 10^6
1 <= time[i] <= 500