Was tun als nächstes nach der Registrierung bei AtCoder? Wenn Sie so viel lösen, können Sie genug kämpfen! Ich habe versucht, das in den letzten 10 ausgewählten Fragen ~ mit Java eingeführte Problem zu lösen.
Im obigen Artikel wird die Lösungsmethode in C ++ geschrieben und der Artikel, den ich in anderen Sprachen zu lösen versucht habe, wird vorgestellt. Daher werde ich hier versuchen, so viele Java-spezifische Methoden wie möglich zu verwenden. Java ist jedoch eine C ++ - basierte Sprache, sodass eine ähnliche Implementierung in C ++ möglich ist ...
Es ist eine Frage der Gleichmäßigkeit des Produkts zweier ganzer Zahlen. Es ist ein Grundproblem.
In Java wird beim Empfang von Eingaben "System.in" an "Scanner" übergeben und verwendet. Verwenden Sie je nach Art der empfangenen Daten auch verschiedene Methoden.
next ()
--nextInt () für ganze Zahlen
--nextLine () für Zeichenketten (1 Zeile)Dieses Mal haben wir es mit ganzen Zahlen zu tun, also verwenden wir "nextInt ()".
Nebenbei bemerkt, wenn es um Ganzzahlen geht, ist "Integer.parseInt (sc.next ())" schneller als "nextInt ()", oder "Scanner" ist in erster Linie langsam, also Leute, die ihre eigene Scannermethode verwenden. Es scheint zu geben. Wenn Sie interessiert sind, versuchen Sie es bitte mit Google.
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
if ((a * b) % 2 == 0)
System.out.println("Even");
else
System.out.println("Odd");
}
}
Es ist ein Problem, "1" in der angegebenen dreistelligen Zahl zu zählen.
Es ist ein Problem beim Umgang mit Zahlen, aber da es leicht zu lösen ist, wenn es als Zeichenfolge behandelt wird, verwenden Sie next ().
Es ist eine Zeichenfolge, die nur aus "0" und "1" besteht. Wenn Sie also die Länge der restlichen Zeichenfolge ohne "0" nachschlagen, ist dies die Antwort.
Ersetzen wir "0" durch "" durch "replaceAll ()".
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
s = s.replaceAll("0", "");
System.out.println(s.length());
}
}
Das Problem ist, wie oft Sie mehrere Ganzzahlen gleichzeitig durch 2 teilen können, bis eine davon nicht teilbar ist.
Die Tatsache, dass eine Zahl durch 2 teilbar ist, entspricht der Tatsache, dass die Einerstelle 0 ist, wenn sie binär ausgedrückt wird. Mit anderen Worten, wie oft eine Zahl durch 2 teilbar ist, kann durch Untersuchen der Anzahl von Nullen ermittelt werden, die von unten fortgesetzt wird. Sie können dies für alle Zahlen oder Werte tun, um die Antwort für die kleinste Zahl zu finden, die durch zwei geteilt werden kann. Die Anzahl der Nullen finden Sie unten mit "Integer.numberOfTrailingZeros ()".
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int bit = 0;
for (int i=0; i<N; i++) {
bit |= sc.nextInt();
}
System.out.println(Integer.numberOfTrailingZeros(bit));
}
}
Es ist eine Frage, wie viele Möglichkeiten es gibt, einen bestimmten Betrag mit 500-Yen-Bällen, 100-Yen-Bällen und 50-Yen-Bällen zu bezahlen.
Die Anzahl der 500-Yen-Bälle und die Anzahl der 100-Yen-Bälle werden durch die for-Anweisung bestimmt, und die Anzahl der 50-Yen-Bälle wird durch die Differenz von X berechnet. Da die Bedingung des Problems besagt, dass X ein Vielfaches von 50 ist, besteht keine Notwendigkeit, den Fall zu berücksichtigen, in dem die Anzahl von 50-Yen-Bällen ein Bruchteil wird.
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int A = sc.nextInt();
int B = sc.nextInt();
int C = sc.nextInt();
int X = sc.nextInt();
int res = 0;
for (int a=0; a<=A; a++) {
for (int b=0; b<=B; b++) {
int c = (X - a * 500 - b * 100) / 50;
if (c >= 0 && c <= C)
res++;
}
}
System.out.println(res);
}
}
Für Zahlen kleiner oder gleich N besteht das Problem darin, die Summe der Zahlen zu finden, deren Summe jeder Ziffer A oder mehr und B oder weniger ist.
Hier werden wir gehorsam die Summe jeder Ziffer für jeden Wert zwischen 1 und N untersuchen.
Es ist die while-Anweisung, die die Summe jeder Ziffer berechnet.
n% 10 addiert den niedrigstwertigen Wert zu digSum und n / = 10 verwirft die niedrigstwertige Ziffer.
Ich mag keine Dezimalzahlen, weil sie umständlicher zu handhaben sind als Binärzahlen ...
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int A = sc.nextInt();
int B = sc.nextInt();
int sum = 0;
for (int i=1; i<=N; i++) {
int n = i;
int digSum = 0;
while (n > 0) {
digSum += n % 10;
n /= 10;
}
if (digSum >= A && digSum <= B)
sum += i;
}
System.out.println(sum);
}
}
Stellen Sie sich ein Spiel vor, in dem mehrere Karten mit Zahlen geschrieben sind und zwei Personen sie abwechselnd nehmen und um die Gesamtsumme kämpfen. Zu diesem Zeitpunkt besteht das Problem darin, herauszufinden, wie viele Zahlen der erste Spieler als der zweite Spieler annehmen kann.
Um die Karten zu erhalten, die die Punkte des anderen maximieren, nehmen wir die Karte mit der größten Anzahl von Karten im Spiel. Mit anderen Worten, die Karten werden in absteigender Reihenfolge sortiert und die Karten werden von Anfang an abwechselnd genommen.
Verwenden Sie Arrays.sort (), um die Arrays zu sortieren.
Auch dieses Mal möchten wir in absteigender Reihenfolge sortieren, also übergeben Sie "Comparator.reverseOrder ()" als zweites Argument.
Übrigens, wenn Sie "Liste" sortieren möchten, verwenden Sie "Collections.sort ()".
Java verwendet "List" häufiger als Arrays, daher ist es möglicherweise wahrscheinlicher, dass Sie es verwenden.
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
Integer a[] = new Integer[N];
for (int i=0; i<N; i++) {
a[i] = sc.nextInt();
}
Arrays.sort(a, Comparator.reverseOrder());
int Alice = 0;
int Bob = 0;
for (int i=0; i<N; i+=2) {
Alice += a[i];
}
for (int i=1; i<N; i+=2) {
Bob += a[i];
}
System.out.println(Alice - Bob);
}
}
Wenn es mehrere Reiskuchen unterschiedlicher Größe gibt, ist es eine Frage, wie viele Stufen von Spiegelreiskuchen nur mit Reiskuchen unterschiedlicher Größe hergestellt werden können.
Set ist nützlich bei Problemen mit nicht doppelten Zahlen.
Set kann eine beliebige Anzahl von Objekten wie List speichern, Duplikate werden jedoch ignoriert.
Sie können die Antwort leicht finden, indem Sie alle Reiskuchengrößen zu "Set" hinzufügen und schließlich die Anzahl der Daten zählen, die "Set" enthält.
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
Set<Integer> num = new HashSet<>();
for (int i=0; i<N; i++) {
int di = sc.nextInt();
num.add(di);
}
System.out.println(num.size());
}
}
Es gibt 10000-Yen-Scheine, 5000-Yen-Scheine und 1000-Yen-Scheine, und das Problem besteht darin, eine Kombination zu finden, die die Summe aus N- und Y-Yen ergibt.
Es ist ein ähnliches Problem wie bei Frage 4. Die Lösungsmethode ist ähnlich, z. B. die Verwendung einer double for-Anweisung.
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int Y = sc.nextInt();
for (int a=0; a<=N; a++) {
for (int b=0; b<=N-a; b++) {
int c = N - a - b;
int total = a * 10000 + b * 5000 + c * 1000;
if (total == Y) {
System.out.println(a + " " + b + " " + c);
return;
}
}
}
System.out.println("-1 -1 -1");
}
}
Es ist ein Problem zu beurteilen, ob eine bestimmte Zeichenkette durch Verketten einer Kombination aus "Traum", "Träumer", "Löschen" und "Radiergummi" erstellt werden kann.
Wenn Sie die Zeichenfolge von Anfang an anwenden, stimmt der Anfang von "Träumerase" mit "Träumer" überein, oder der Anfang von "Träumerase" stimmt mit "Traum" überein. Überprüfen Sie dies daher von hinten. Von hinten treten solche Fehler nicht auf.
Verwenden Sie endsWith (), um herauszufinden, ob eine Zeichenfolge mit dem Ende einer anderen übereinstimmt.
Natürlich gibt es auch startWith (), das prüft, ob eine Zeichenfolge mit dem Anfang einer anderen übereinstimmt.
import java.util.*;
class Main {
static String[] strs = {
"dream",
"dreamer",
"erase",
"eraser"
};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
while (true) {
boolean endsWithStr = false;
for (String str: strs) {
if (S.endsWith(str)) {
endsWithStr = true;
S = S.substring(0, S.length() - str.length());
break;
}
}
if (!endsWithStr) {
System.out.println("NO");
break;
}
if (S.length() <= 0) {
System.out.println("YES");
break;
}
}
}
}
Ich habe versucht, es zu schreiben, aber tatsächlich kann ich es in dieser Antwort nicht mit AtCoder weitergeben. Es ist MLE ... Anscheinend ist die Ursache zu viel String-Generierung. Ich habe einige Verbesserungen vorgenommen und dafür gesorgt, dass der Code nicht "EndsWith ()" verwendet, und es ist bestanden, aber es ist nicht interessant, es zu setzen, also werde ich eine andere Lösung setzen.
Ersetzen Sie einfach jede Zeichenfolge und löschen Sie sie. Legen Sie bei dieser Methode die Reihenfolge der zu löschenden Zeichenfolgen fest, damit kein versehentliches Löschen erfolgt. Lösche den Träumer vor dem Traum, den Radiergummi vor dem Löschen, den Löscher und den Radiergummi vor dem Träumer.
[Zusatz] Mit dieser Methode werden Sie fälschlicherweise denken, dass eine Zeichenkette wie "Dreameraseer" aus Löschen und Träumen bestehen kann. Ersetzen Sie es beim Ersetzen durch ein nicht verwendetes Zeichen ohne leere Zeichenfolge und löschen Sie dieses Zeichen am Ende, um das richtige Ergebnis zu erhalten. Vielen Dank an @ CuriousFairy315 für diesen Hinweis!
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
S = S.replaceAll("eraser", "-");
S = S.replaceAll("erase", "-");
S = S.replaceAll("dreamer", "-");
S = S.replaceAll("dream", "-");
S = S.replaceAll("-", "");
if (S.length() == 0)
System.out.println("YES");
else
System.out.println("NO");
}
}
Die Frage ist, bei den Koordinaten (0, 0) zu beginnen und zu bestimmen, ob Sie zum Zeitpunkt ti bei (xi, yi) sein können.
Wenn es möglich ist, die Zielkoordinaten zu einem bestimmten Zeitpunkt zu erreichen, können Sie die Zeit anpassen, indem Sie umherwandern. Wenn Sie jedoch vor der ungeraden Zeit zu den Zielkoordinaten gelangen, ist dies genau der Zeitpunkt Beachten Sie, dass Sie nicht an den gewünschten Koordinaten sein können.
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int preT = 0;
int preX = 0;
int preY = 0;
for (int i=0; i<N; i++) {
int postT = sc.nextInt();
int postX = sc.nextInt();
int postY = sc.nextInt();
int dt = postT - preT;
int dist = Math.abs(postX - preX) + Math.abs(postY - preY);
if ((dt < dist) || ((dist - dt) % 2 != 0)) {
System.out.println("No");
return;
}
preT = postT;
preX = postX;
preY = postY;
}
System.out.println("Yes");
}
}
Ich bin ein Mädchen, das seit ungefähr einem Monat im Wettbewerb ist, daher gibt es wahrscheinlich viele bessere Lösungen. (Bitte lassen Sie es uns in den Kommentaren wissen!)
Java ist im Moment nicht so langsam, aber es ist immer noch langsamer als C und C ++ und nimmt mehr Speicherplatz in Anspruch. Wenn ich die frühere Implementierung in C ++ schreiben würde, könnte ich die 9. Frage normal bestehen. Es wäre schön, wenn die Zeit- und Speicherbeschränkungen für jede Sprache wie AOJ gelockert würden, aber mit AtCoder sind alle Sprachen gleich.
Ich bin der Meinung, dass die Verwendung von C ++ der beste Weg ist, um mit AtCoder zu konkurrieren. (Natürlich macht es Spaß, in anderen Sprachen zu lösen!) Ich selbst studiere derzeit C ++ für einen wettbewerbsfähigen Profi. Wenn Sie ein wettbewerbsfähiger Profi außer C ++ sind, starten wir C ++ zu diesem Zeitpunkt! (C ++ wird in Java-Artikeln empfohlen ...)
Recommended Posts