fork download
copy 
  1. import java.io.BufferedReader;
  2. 	import java.io.IOException;
  3. 	import java.io.InputStreamReader;
  4. 	import java.util.HashMap;
  5. 	import java.util.Iterator;
  6. 	import java.util.Map;
  7. 	import java.util.Map.Entry;
  8. 	import java.util.Set;
  9. 	import java.util.Vector;
  10. 	import java.util.concurrent.atomic.AtomicInteger;
  11.  
  12. 	public class Main {
  13.  
  14. 		/**
  15. 		 * Only supports element numbers that are one/two digit(s)...
  16. 		 * @param args
  17. 		 */
  18. 		public static void main(String[] args) {
  19. 			try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
  20. 				String line;
  21. 				while ((line = br.readLine()) != null) {
  22. 					evaluate(line, expand(line));
  23. 				}
  24. 			} catch (IOException e) {
  25. 				e.printStackTrace();
  26. 			} catch (NumberFormatException e) {
  27. 				e.printStackTrace();
  28. 			}
  29. 		}
  30.  
  31. 		/**
  32. 		 * Counts the number of elements in a chemical formula
  33. 		 * @param line: Line consisting of the elements
  34. 		 */
  35. 		private static void evaluate(String orig, String line) {
  36. 			Map<String, AtomicInteger> map = new HashMap<String, AtomicInteger>();
  37. 			for (int i = 0; i < line.length(); i++) {
  38. 				char cur = line.charAt(i);
  39. 				if (i + 1 < line.length()) {
  40. 					char next = line.charAt(i + 1);
  41. 					if (next >= 'A' && next <= 'Z') {
  42. 						String ele = new StringBuilder("").append(cur).toString();
  43. 						if (map.containsKey(ele)) {
  44. 							map.get(ele).incrementAndGet();
  45. 						} else {
  46. 							map.put(ele, new AtomicInteger(1));
  47. 						}
  48. 					} else if (next >= 'a' && next <= 'z') {
  49. 						if (i + 2 < line.length()) {
  50. 							char possibleNum = line.charAt(i + 2);
  51. 							int possibleNum2 = -1;
  52. 							if (i + 3 < line.length())
  53. 								possibleNum2 = (int) line.charAt(i + 3);
  54. 							String ele = new StringBuilder("").append(cur).append(next).toString();
  55. 							if (possibleNum >= '0' && possibleNum <= '9') {
  56. 								StringBuilder number = new StringBuilder("").append(possibleNum);
  57. 								if ((char) possibleNum2 >= '0' && (char) possibleNum2 <= '9') {
  58. 									number.append((char) possibleNum2);
  59. 									i++;
  60. 								}
  61. 								int num = Integer.parseInt(number.toString());
  62. 								if (map.containsKey(ele)) {
  63. 									for (int j = 0; j < num; j++)
  64. 										map.get(ele).incrementAndGet();
  65. 								} else {
  66. 									map.put(ele, new AtomicInteger(num));
  67. 								}
  68. 								i += 2;
  69. 							} else {
  70. 								if (map.containsKey(ele)) {
  71. 									map.get(ele).incrementAndGet();
  72. 								} else {
  73. 									map.put(ele, new AtomicInteger(1));
  74. 								}
  75. 								i++;
  76. 							}
  77. 						} else {
  78. 							String ele = new StringBuilder("").append(cur).append(next).toString();
  79. 							if (map.containsKey(ele)) {
  80. 								map.get(ele).incrementAndGet();
  81. 							} else {
  82. 								map.put(ele, new AtomicInteger(1));
  83.  
  84. 							}
  85. 							i++;
  86. 						}
  87. 					} else if (next >= '0' && next <= '9') {
  88. 						String ele = new StringBuilder("").append(cur).toString();
  89. 						StringBuilder number = new StringBuilder("").append(next);
  90.  
  91. 						if (i + 2 < line.length()) {
  92. 							if (line.charAt(i + 2) >= '0' && line.charAt(i + 2) <= '9') {
  93. 								number.append(line.charAt(i + 2));
  94. 								i++;
  95. 							}
  96. 						}
  97. 						int num = Integer.parseInt(number.toString());
  98. 						if (map.containsKey(cur + "")) {
  99. 							for (int j = 0; j < num; j++)
  100. 								map.get(ele).incrementAndGet();
  101. 						} else {
  102. 							map.put(ele, new AtomicInteger(num));
  103. 						}
  104. 						i++;
  105. 					}
  106. 				} else {
  107. 					// we are on the last element, it must be a single letter
  108. 					String ele = new StringBuilder("").append(cur).toString();
  109. 					if (map.containsKey(ele)) {
  110. 						map.get(ele).incrementAndGet();
  111. 					} else {
  112. 						map.put(ele, new AtomicInteger(1));
  113. 					}
  114. 				}
  115. 			}
  116.  
  117. 			print(orig, map);
  118. 		}
  119.  
  120. 		/**
  121. 		 * Prints the map
  122. 		 * @param line
  123. 		 * @param map
  124. 		 */
  125. 		private static void print(String line, Map<String, AtomicInteger> map) {
  126. 			System.out.printf("%s\n", line);
  127. 			Set<Entry<String, AtomicInteger>> entries = map.entrySet();
  128. 			Iterator<Entry<String, AtomicInteger>> it = entries.iterator();
  129. 			while (it.hasNext()) {
  130. 				Entry<String, AtomicInteger> e = it.next();
  131. 				System.out.println("\t" + e.getKey() + ": " + e.getValue().get());
  132. 			}
  133. 			System.out.printf("\n");
  134. 		}
  135.  
  136. 		/**
  137. 		 * Method expands 'tougher' chemical compounds consisting of
  138. 		 * multiple inner molecules
  139. 		 * 
  140. 		 * I.E.
  141. 		 * 	C4H8(OH)2 -> C4H8OHOH
  142. 		 * @param line: Line consisting of the elements
  143. 		 * @return String: expanded line
  144. 		 * 
  145. 		 * PRECONDITION: Parentheses are balanced and contain at least
  146. 		 * 				 one element
  147. 		 */
  148. 		private static String expand(String line) throws NumberFormatException {
  149. 			if (!line.contains("("))
  150. 				return line;
  151. 			// find the indexes of the parentheses and create a
  152. 			// stringbuilder object
  153. 			Vector<Integer> vec = getOpenClose(line);
  154. 			int open = vec.get(0);
  155. 			int closed = vec.get(1);
  156. 			StringBuilder newString = new StringBuilder("");
  157.  
  158. 			// append the beginning of the formula
  159. 			for (int i = 0; i < open; i++) {
  160. 				newString.append(line.charAt(i));
  161. 			}
  162.  
  163. 			// repeat the elements in the parenthese's the repeated
  164. 			// number of times
  165. 			int repeat = Integer.parseInt(line.charAt(closed + 1) + "");
  166. 			for (int i = 0; i < repeat; i++) {
  167. 				for (int j = open + 1; j < closed; j++) {
  168. 					newString.append(line.charAt(j));
  169. 				}
  170. 			}
  171.  
  172. 			// append the rest of the string onto the new string
  173. 			for (int i = closed + 2; i < line.length(); i++) {
  174. 				newString.append(line.charAt(i));
  175. 			}
  176.  
  177. 			// recurse through in case we have another pair of parentheses
  178. 			return expand(newString.toString());
  179. 		}
  180.  
  181. 		/**
  182. 		 * Gets the index of the inner-most set of parentheses
  183. 		 * @param line: line to search
  184. 		 * @return Vector<Integer>: vector of the two indexes
  185. 		 */
  186. 		public static Vector<Integer> getOpenClose(String line) {
  187. 			Vector<Integer> vec = new Vector<Integer>();
  188. 			int open = -1;
  189. 			int closed = -1;
  190. 			for (int i = 0; i < line.length(); i++) {
  191. 				if (line.charAt(i) == ')') {
  192. 					closed = i;
  193. 					break;
  194. 				}
  195. 			}
  196. 			stop: for (int i = closed; i >= 0; i--) {
  197. 				if (line.charAt(i) == '(') {
  198. 					open = i;
  199. 					break stop;
  200. 				}
  201. 			}
  202.  
  203. 			vec.add(0, open);
  204. 			vec.add(1, closed);
  205. 			return vec;
  206. 		}
  207. 	}
Success #stdin #stdout 0.05s 4386816KB
comments (?)
stdin
copy 
C6H12O6
CCl2F2
NaHCO3
C4H8(OH)2
PbCl(NH3)2(COOH)2
stdout
copy 
C6H12O6
	C: 6
	H: 12
	O: 6

CCl2F2
	C: 1
	F: 2
	Cl: 2

NaHCO3
	Na: 1
	C: 1
	H: 1
	O: 3

C4H8(OH)2
	C: 4
	H: 10
	O: 2

PbCl(NH3)2(COOH)2
	Pb: 1
	C: 2
	H: 8
	Cl: 1
	N: 2
	O: 4
https://ideone.com/4Lp4ho
language:
Java (HotSpot 12)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!