Dans l'article ci-dessus, la solution en C ++ est écrite et l'article que j'ai essayé de résoudre dans d'autres langages est présenté, donc ici je vais essayer d'utiliser autant que possible des méthodes spécifiques à Java. Cependant, Java est un langage basé sur C ++, donc une implémentation similaire est possible en C ++ ...
Il s'agit de la régularité du produit de deux entiers. C'est un problème fondamental.
En Java, lors de la réception d'une entrée, System.in est passé à Scanner et utilisé.
Utilisez également plusieurs méthodes en fonction du type de données reçues.
--Pour les mots, suivant ()
--nextInt () pour les entiers
--nextLine () pour les chaînes de caractères (1 ligne)
Cette fois, nous avons affaire à des entiers, donc nous utilisons nextInt ().
Par ailleurs, lorsqu'il s'agit d'entiers, ʻInteger.parseInt (sc.next ()) est plus rapide que nextInt () , ou Scanner` est lent en premier lieu, donc les gens qui utilisent leur propre méthode Scanner Il semble y avoir.
Si vous êtes intéressé, essayez 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");
}
}
C'est un problème de compter "1" dans le nombre à trois chiffres donné.
C'est un problème avec les nombres, mais comme il est facile à résoudre s'il est traité comme une chaîne de caractères, utilisez next ().
Puisqu'il s'agit d'une chaîne composée uniquement de "0" et "1", la réponse est de vérifier la longueur de la chaîne restante après avoir supprimé "0".
Remplaçons "0" par "" par 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());
}
}
La question est de savoir combien de fois diviser plusieurs entiers en même temps par 2 jusqu'à ce que l'un d'eux ne soit pas divisible.
Le fait qu'un nombre soit divisible par 2 équivaut au fait que la place du 1 est 0 lorsqu'elle est exprimée en binaire. En d'autres termes, le nombre de fois qu'un nombre est divisible par 2 peut être trouvé en examinant le nombre de 0 qui continue à partir du bas. Vous pouvez le faire pour tous les nombres ou valeurs afin de trouver la réponse au plus petit nombre pouvant être divisé par deux. Le nombre de 0 suivant le bas peut être trouvé avec ʻ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));
}
}
Il s'agit de savoir combien de façons de payer un certain montant en utilisant 500 balles de yens, 100 balles de yens et 50 balles de yens.
Le nombre de balles de 500 yens et le nombre de balles de 100 yens sont déterminés par l'instruction for, et le nombre de balles de 50 yens est calculé par la différence de X. Puisque la condition du problème stipule que X est un multiple de 50, il n'est pas nécessaire de considérer le cas où le nombre de balles de 50 yens devient une fraction.
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);
}
}
Pour les nombres inférieurs ou égaux à N, le problème est de trouver la somme des nombres dont le total de chaque chiffre est A ou plus et B ou moins.
Ici, nous examinerons docilement la somme de chaque chiffre pour chaque valeur entre 1 et N. C'est l'instruction while qui calcule la somme de chaque chiffre. «n% 10» ajoute la valeur la moins significative à «digSum» et «n / = 10» supprime le chiffre le moins significatif. Je n'aime pas les nombres décimaux car ils sont plus encombrants à gérer que les nombres binaires ...
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);
}
}
Considérez un jeu dans lequel vous avez plusieurs cartes avec des numéros écrits dessus, et deux personnes les prennent alternativement et se disputent le total. À ce stade, le problème est de savoir combien de numéros le premier joueur peut prendre par rapport au deuxième joueur.
Afin d'obtenir les cartes qui maximisent les points de chacun, nous prendrons la carte avec le plus grand nombre de cartes en jeu. En d'autres termes, les cartes sont triées par ordre décroissant et les cartes sont prises en alternance depuis le début.
Utilisez ʻArrays.sort () pour trier le tableau. De plus, cette fois, nous voulons trier par ordre décroissant, alors passez Comparator.reverseOrder ()comme deuxième argument. Au fait, si vous voulez trierListe, utilisez Collections.sort (). Java utilise List` plus souvent que les tableaux, vous serez donc plus susceptible de l'utiliser.
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);
}
}
Lorsqu'il y a plusieurs galettes de riz de différentes tailles, il est difficile de savoir combien d'étapes de galettes de riz miroir peuvent être faites en utilisant uniquement des galettes de riz de différentes tailles.
Set est utile pour les problèmes liés aux nombres non dupliqués.
Set peut stocker n'importe quel nombre d'objets comme List, mais les doublons seront ignorés.
Vous pouvez facilement trouver la réponse en ajoutant les tailles de tous les gâteaux de riz à Set et en comptant enfin le nombre de données que Set a.
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());
}
}
Il y a des factures de 10000 yens, des factures de 5000 yens et des factures de 1000 yens, et le problème est de trouver une combinaison qui fait le total de N et Y yens.
C'est un problème similaire à la question 4. La méthode de résolution est similaire, comme l'utilisation d'une instruction double for.
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");
}
}
C'est un problème de juger si une certaine chaîne de caractères peut être créée en concaténant une combinaison de "rêve", "rêveur", "effacer" et "gomme".
Si vous appliquez la chaîne de caractères depuis le début, le début de "dreamerase" correspondra à "dreamer", ou le début de "dreamererase" correspondra à "dream", alors vérifiez à l'arrière. De derrière, de telles erreurs ne se produisent pas.
Utilisez ʻendsWith () pour savoir si une chaîne correspond au bas d'une autre. Bien sûr, il y a aussi startsWith ()`, qui vérifie si une chaîne correspond au début d'une autre.
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;
}
}
}
}
J'ai essayé de l'écrire, mais en fait, je ne peux pas le passer avec AtCoder dans cette réponse. C'est MLE ... Apparemment, la cause est trop de génération de chaînes. J'ai fait quelques améliorations et j'ai fait le code sans ʻendsWith () `, mais je pourrais le passer, mais ce n'est pas intéressant de le mettre, donc je vais mettre une autre solution.
Remplacez simplement chaque chaîne et supprimez-la. Dans cette méthode, définissez l'ordre des chaînes de caractères à supprimer afin que la suppression accidentelle ne se produise pas. Supprimer le rêveur avant le rêve, la gomme avant l'effacement, l'effacer et la gomme avant le rêveur.
[Une addition] Avec cette méthode, vous penserez à tort qu'une chaîne comme "dreameraseer" peut être composée d'effacement et de rêveur. Lors du remplacement, remplacez-le par un caractère inutilisé sans chaîne de caractères vide et supprimez ce caractère à la fin pour obtenir le résultat correct. Merci à @ CuriousFairy315 pour l'avoir signalé!
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");
}
}
La question est de commencer aux coordonnées (0, 0) et de déterminer si vous pouvez être à (xi, yi) au temps ti.
S'il est possible d'atteindre les coordonnées cibles à l'heure, vous pouvez ajuster l'heure en vous promenant, mais si vous arrivez aux coordonnées cibles avant l'heure impaire de l'heure, ce sera à l'heure exacte. Notez que vous ne pouvez pas être aux coordonnées souhaitées.
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");
}
}
Je suis une nana qui est en compétition depuis environ un mois, il y aura donc probablement de meilleures solutions. (Merci de nous le faire savoir dans les commentaires!)
Java n'est pas si lent pour le moment, mais il est toujours plus lent que C et C ++, et il prend plus de mémoire. En fait, si j'écrivais l'ancienne implémentation en C ++, je pourrais passer la 9ème question normalement. Ce serait bien s'il y avait une relaxation des restrictions de temps et de mémoire pour chaque langue, comme AOJ, mais avec AtCoder, toutes les langues sont égales.
Je pense que l'utilisation de C ++ est le meilleur moyen de rivaliser avec AtCoder. (Bien sûr, c'est amusant à résoudre dans d'autres langues!) J'étudie moi-même actuellement C ++ pour un professionnel compétitif. Si vous êtes un professionnel compétitif autre que C ++, commençons C ++ en ce moment! (C ++ est recommandé dans les articles Java ...)
Recommended Posts