PAT Etat 1001 A + B Format 20 minutes

sujet Présentation

Calculer a + b et la sortie la somme en format standard - qui est, les chiffres doivent être séparés en groupes de trois par des virgules (à moins qu'il existe au moins quatre chiffres).

informations d'entrée

Chaque fichier d'entrée contient un cas de test. Chaque cas contient une paire de nombres entiers a et b, où -10 ^ 6 <= a, b <= 10 ^ 6 Les chiffres sont séparés par un espace.

sortie

Pour chaque test, vous devriez sortir la somme d' un et b en une ligne. La somme doit être écrit dans le format standard.

Exemple d'entrée

-1000000 9

Exemple de sortie

-999991

analyse

Compte tenu de deux chiffres, et un B, et leurs calculés et ajoutés tous les trois séparateurs (ajouter des séparateurs millièmes)
comme entrant dans le cadre de l'int, donc nous ne considérons pas le problème de trop - plein. (Maximum 2 x 10 ^ 6)

Tout d' abord, il existe un moyen simple est tiré à l' intérieur d' un très utile classes Java --DecimalFormat
(test PS :. PAT dans lequel, pour une limite de temps de 20 minutes sujet moins exigeants, souvent en Java peut rapidement spike aussi longtemps que bonne chaîne, BigInteger, Decimal et d' autres catégories)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.StringTokenizer;

public class Main {
	static final int BUFFER_SIZE = 8192 * 25;
	static BufferedReader br;
	static StringTokenizer tokenizer;

	static void initInput(InputStream in) throws Exception {
		br = new BufferedReader(new InputStreamReader(in), BUFFER_SIZE);
		tokenizer = new StringTokenizer("");
	}

	static String next() throws Exception {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(br.readLine());
		}
		return tokenizer.nextToken();
	}

	static int nextInt() throws Exception {
		return Integer.parseInt(next());
	}

	static PrintWriter pw;

	public static void main(String[] args) throws Exception {
		initInput(System.in);
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out), BUFFER_SIZE));
		
		/*正式代码开始*/
		int a = nextInt(),b=nextInt();
		int c = a+b;
		DecimalFormat df = new DecimalFormat("#,###");
		//如果要求按四位分割，就改为#,####即可
		pw.println(df.format(c));
		/*结束*/
		
		pw.flush();
	}
}

Comme représenté, le code de base est seulement quatre lignes. (Pourquoi le IO à être ainsi attaché à écrire le texte, et donnera un modèle)

Sans surprise, beaucoup de temps et de la mémoire sont élevés, il est écrit en Java PAT normale (Python forte de temps que Java. mais sans préjudice agréable aussi ~ sur la ligne)

test normal nous avons couru une minute pour obtenir des points, mais comme une phase d'apprentissage devrait alors réfléchir sérieusement sur la façon de le faire à la fin.
Pour un certain nombre 1234567890 (après sommation), il est représenté par 1.234.567.890
Si ce nombre est converti en une chaîne, chaque caractère d' une correspondance entre les indices comme suit:
0. 5. 4. 3. 2. 1 6. 7. 8. 9
1 2. 4. 3. 567 890
Comme on le voit, dans l'impression str [0], str [3 ], après str [6] nécessité d'imprimer un caractère de virgule.
En observant les lois, ensemble à l' index I , la condition est satisfaite (i + 1)% 3 == len% 3 nécessité d'imprimer une virgule. Si j'étais le dernier (ie i == len-1 ) vous n'avez pas besoin d'imprimer. Si elle est négative, vous pouvez sauter, également conforme à la loi. Tels que: -1234567 0 2. 3. 1. 4. 5. 6. 7

• 3 1,2 4,5 67
  imprime une virgule après str [1], str [4 ].
  (Référence @ Liu récalcitrante idée)
  C ++ pour atteindre les objectifs suivants:

#include <iostream>
#include <string>
using namespace std;
int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	string s = to_string(a + b);
	for (int i = 0; i < s.length(); i++) {
		printf("%c", s[i]);
		if (s[i] != '-' && (i + 1) % 3 == s.length() % 3 && i != s.length() - 1)
			printf(",");
	}
	return 0;
}

(Ceci est mauvais jours de temps pour faire le ...)

Annexe - (problèmes temps de fonctionnement) sur l'efficacité de l'examen PAT

Trois à quatre questions commençant j'utilisais réponse Java, mais la partie arrière du sujet ne peut pas vraiment passer. (300ms limiter les sujets suivants, en utilisant Java presque impossible), les conseils suivants pour Java, est seulement amélioré dans une certaine mesure, si vous venez d' apprendre à pratiquer vos propres sujets, vous pouvez utiliser Java pour écrire, mais si vous voulez passer l'examen S'il vous plaît passer le plus tôt possible. La raison en est que:
1, par Pat explication officielle , Oh, voilà tout.
2, les jugements PTA système de questions relatives compilateur Java a été longtemps sans entretien, le temps de démarrage machine virtuelle Java sont également compté dans le temps de l' exécution du programme.
Tout d' abord, si la réponse Java
Java appartenant à expliquer après la première compilé langue, bien que .java en fichiers .class compilés par le temps ne compte pas, mais le démarrage de la machine virtuelle Java (jusqu'à 50 ms +) du temps sera compté à l' intérieur. Si la méthode inefficace IO, l'effet sera encore pire. En revanche, pur langages interprétés (tels que Python), et ont en fait plus rapide (comparaison).
Voici plusieurs méthodes pour améliorer la vitesse, l'effet réel est à son tour affaibli.

• Réécrite en C ++.
• Scanner lit d'arrêt à l'aide, au lieu de l'emballage par la classe lecteur

BufferedReader br = new BufferedReader(new InputStreamReader(System.in)));

Scanner Bien que facile à utiliser, mais l'efficacité est faible, voir
Entrée rapide pour Java
expériences à l' aide d' un des acteurs internationaux de Java douzaine faire acm

• Au lieu d'utiliser StringTokenizer String.parse, l'efficacité StringTokenizer sera plusieurs fois plus élevé que String.parse.
• Sur l'un des liens où il y a des explications.
• arrêt de sortie System.in à l'aide, au lieu de l'emballage par la classe Writer.

PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

Utilisez BufferedWriter transformé de l'encapsulation System.out, efficacité peut être améliorée, réutilisation des emballages PrintWriter, facile à utiliser l'impression, printf, comme println.

• Tous les objets statiques peuvent essayer statique (douteux)
  cette pratique est GC ne vérifie pas l'origine et les objets statiques récupérés dans le domaine, et réduire la fréquence de GC est à une certaine augmentation de mesure (en fait, l'effet de l' efficacité opérationnelle est très évident, presque pas)
  ne sera pas l' objet en temps opportun est réglé sur il pourrait également nulle être en mesure d'améliorer l' efficacité
• Modifier BufferedReader, BufferedWriter taille de la mémoire tampon par défaut (valeur par défaut est 8192, je vais l' augmenter à 25 fois l'original), de manière à modifier l'efficacité de lecture mémoire.
  C'est aussi pourquoi écrire une ligne:

static final int BUFFER_SIZE = 8192 * 25;

Forget est vu où quelqu'un une fois écrit ainsi, le véritable effet doute, ne peuvent pas utiliser des oeufs.

Java peut tirer pleinement à l'intérieur quelques-unes des plus efficaces modèle de lecture suit comme:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main{
	static final int BUFFER_SIZE = 8192*25;
	static BufferedReader br;
	static StringTokenizer tokenizer;

	static void initInput(InputStream in) throws Exception {
		br = new BufferedReader(new InputStreamReader(in), BUFFER_SIZE);
		tokenizer = new StringTokenizer("");
	}
	static String next() throws Exception{
		while(!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(br.readLine());
		}
		return tokenizer.nextToken();
	}

	static int nextInt() throws Exception {
		return Integer.parseInt(next());
	}
	static double nextDouble() throws Exception{
		return Double.parseDouble(next());
	}
	static PrintWriter pw;
	public static void main(String[] args) throws Exception {
		initInput(System.in);
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out),BUFFER_SIZE));
		
		/*在这里插入你的代码*/
		int i = nextInt(); //读取一个整数
		String s = next(); //读取一个字符串
		double d = nextDouble(); //读取一个浮点数
		pw.flush();
	}
}

REMARQUE: delimiter par défaut StringTokenizer est un aliment de l' espace et de la ligne, si nécessaire après avoir utilisé la méthode d' autres moyens déversés, ou suivant () lit la chaîne appropriée.
En second lieu , si la réponse C la langue
ne peut pas vivre commutateur C ++, sans pratiquement STL.
3. Si la réponse en utilisant C ++
C ++ est rien à dire, en général, pas de gros problème (souvent, Java nécessite l'utilisation d'algorithmes d'optimisation peuvent aussi, C ++ ou de violence , même sur la ligne)
que quelques points à noter:

• Essayez d'utiliser printf et scanf à lire ou à l'entrée (certains cin dire, peut annuler Cout rafraîchissement), en particulier dans le temps nécessaire pour lire un grand nombre de chaînes, l'amélioration de l'efficacité scanf est particulièrement évidente.
• Faites bon usage de la carte, ensemble, unordered_map et unordered_set. En général, si la clé est de type int peut être utilisé à la place d'un tableau, une chaîne de type clé lorsqu'il est utilisé carte. Toutefois, si une grande quantité de données, il est nécessaire d'utiliser unordered_map. (Carte / régler le fond est la mise en œuvre de l' arbre rouge-noir, peut garantir un certain ordre, unordered_map / unordered_set table de hachage sous - jacente pour atteindre, un peu plus efficace, mais il faut du temps aux tables de construction) a
  conclu que:
  un tableau En général, seule clé la valeur n'a pas besoin d'utiliser SET / unordered_set
  carte clé lorsqu'il est utilisé pour la chaîne.
  La quantité de données (carte avec délai d' attente), sans utiliser unordered_map lors de la commande. Lorsque vous utilisez unordered_map, essayez de spécifier lors de l' initialisation de bonne taille (table de hachage pour réduire la surcharge provoquée par l' expansion)
  lors de la commande nécessaire (tri), en utilisant la carte. (Titre verra plus tard)
• Quelques petits points, la liste de contiguïté ne doivent pas utiliser la matrice de contiguïté, avec l'opérateur de concaténation de chaîne de stringstream est pas surchargé et donc
• Utiliser vecteur au lieu de tableaux réguliers. Array peut faire compétent vecteur, mais aussi plus pratique.

Bien sûr, parfois un peu de commodité méthode inefficace peut être utilisé. Quoi qu'il en soit, vous pouvez alors changer le mauvais (examen PAT sans pénalité quand) (évasion)