Statistics

Problem Statement for "VariableSolve"

Problem Statement

You will be given an equation of the form <side>=<side> where <side> is a list of <term>s separated by <op>s. Each <op> is either + or -, and each <term> is a positive length string of uppercase letters. Each letter denotes a variable taking on real values. No letter will occur in a <term> more than twice.

The <term>s are products of variables. As you would expect, the + and - operators take lower precedence than the multiplications within the <term>s. For example, 
	ABC+ADF=PQ-PQ
is a properly formatted equation. Sometimes, by fixing a single variable at a particular value, we can force the entire equation to always be true. Return a String[] containing all such variables that satisfy this requirement. If a variable can be set to n distinct values all of which satisfy this requirement, then that variable should occur n times in the return. If a variable can be set to an infinite number of distinct values that satisfy this requirement, it should not be returned. The return should be sorted in alphabetical order.

Definition

Class:
VariableSolve
Method:
getSolutions
Parameters:
String
Returns:
String[]
Method signature:
String[] getSolutions(String equation)
(be sure your method is public)

Constraints

  • equation will contain between 3 and 50 characters inclusive.
  • equation will be formatted as described in the problem statement.

Examples

  1. "ABCD+ABCD-ABCD=ABCD"

    Returns: { }

  2. "ABA+BA+B=P-P"

    Returns: {"B" }

  3. "ABA+BA+B=P-P+B"

    Returns: {"A", "A", "B" }

  4. "ABA+BA+B=P-P+B+B"

    Returns: {"A", "A", "B" }

  5. "P=NP"

    Returns: {"N", "P" }

    Simpler than it looks: let N = 1 or P = 0.

  6. "RED+BLUE=PURPLE"

    Returns: {"E" }

    Only E = 0 guarantees the equation holds.

  7. "ABCD+ABCD-ABCD=ABCD"

    Returns: { }

    Each variable has an infinite number of values causing the equation to hold.

  8. "BAA+BA+B=P-P"

    Returns: {"B" }

    We cannot consider the complex solutions for A.

  9. "B-AB+AAB-BC+ABC-AABC+BCC+AABCC=ABCC"

    Returns: {"B" }

  10. "B-AB+ABC+AABC+ABCC+AABCC=BCC+AAB+BC"

    Returns: {"A", "A", "B", "C", "C" }

  11. "AB+AAB-BC+ABC+AABC-BCC+ABCC+AABCC=B"

    Returns: {"A", "A", "B" }

  12. "BBACAD+GRAPA+AFLAD=DBCBA+AGRP+DALF"

    Returns: {"A", "A" }

  13. "BBACAD+GRAPA+AFLAD=DBCBA+AGRP+DAF"

    Returns: {"A" }

  14. "BBACAD+GRAPA+AFLAD+DALF=DBCBA+AGRP"

    Returns: {"A" }

  15. "BBACAD+GRAPA+AFLAD=GDBCBA+GAGRP+GDALF"

    Returns: {"A" }

  16. "DAAB-BAD-ADB+BD=P-P"

    Returns: {"A", "B", "D" }

  17. "BAA+BA+B=P"

    Returns: { }

  18. "BAA-BA-B=CAB+P-P-BAC"

    Returns: {"A", "A", "B" }

  19. "BAA+BAA-AB-AB-BA-BA=B+C+B-C"

    Returns: {"A", "A", "B" }

  20. "BAA+BAA-AB-AB-BA-BA=C-B-C-B"

    Returns: {"A", "B" }

  21. "BAA+BAA-AB-AB-BA-BA=C-B-C-B+CAA+CAA"

    Returns: { }

  22. "BAA+BAA-AB-AB-BA-BA=C-B-C-B+CAA-CAA"

    Returns: {"A", "B" }

  23. "BAA+BAA-AB-AB-BA-BA=C-B-C-B+CAA+CAA+CA+CA"

    Returns: { }

  24. "BAA+BAA-AB-AB-BA-BA=C-B+C-B+CAA+CAA+CA+CA"

    Returns: { }

  25. "CA+BAA+BAA-AB-AB-BA-BA+CA=C-B+C-B+CAA+CAA-CA-CA"

    Returns: {"A" }

  26. "AA=P-P"

    Returns: {"A" }

  27. "GRAA=P-P-GR-GR"

    Returns: {"G", "R" }

  28. "GRAA=P-P+GR+GR"

    Returns: {"A", "A", "G", "R" }

  29. "BBACC+BBA-CAC-ACC-CCA-A-A-A=D-D"

    Returns: {"A", "B", "B" }

  30. "ACC-A=ACC+ACC-A-A"

    Returns: {"A", "C", "C" }

  31. "ACC-A=BCC+BCC-B-B-DCC-DCC+D+D"

    Returns: {"C", "C" }

  32. "ACC-A=BCC+BCC-B-B-DCC-DCC+D+D+D"

    Returns: { }

  33. "ACC-A=BCC+BCC-B-B-DCC+D+D"

    Returns: { }

  34. "ACC-A=BCC-B-B-DCC-DCC+D+D"

    Returns: { }

  35. "ACC-A-A=BCC-B-B-DCC+D+D"

    Returns: {"C", "C" }

  36. "A-B=CCB+A"

    Returns: {"B" }

  37. "A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A=AA+AB+BA"

    Returns: {"A" }

  38. "A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A=AA+AB-BA"

    Returns: {"A" }

  39. "A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A+A-A=AA+AB-BA+A"

    Returns: {"A", "A" }

  40. "BAA-BA+B=P"

    Returns: { }

  41. "A-A=CA-AC"

    Returns: { }

  42. "ABC=P-P"

    Returns: {"A", "B", "C" }

  43. "P-P+D-D=ABC+AB"

    Returns: {"A", "B", "C" }

  44. "P-P+D-D=AABBCC"

    Returns: {"A", "B", "C" }

  45. "P-P+D-D=AABBCC-ABC"

    Returns: {"A", "B", "C" }

  46. "P-P+D-D=AABBCC+ABC"

    Returns: {"A", "B", "C" }

  47. "P-P+D-D=AABBCC-AABCC"

    Returns: {"A", "B", "B", "C" }

  48. "P-P+D-D=AABBCC-AABCC+AACC"

    Returns: {"A", "C" }

  49. "AACC+P-P+D-D=AABBCC-AABCC"

    Returns: {"A", "B", "B", "C" }

  50. "AACC+P-P+D-D=AABBCC"

    Returns: {"A", "B", "B", "C" }

  51. "AAB-AB-BA+B=CAA+AAC-AC-CA+C"

    Returns: { }

  52. "BAA-B+CAA-AC-CA+C=P-P"

    Returns: {"A" }

  53. "XYX+XY-Y-Y-Y+XZ=Z+Z+Y+Y+Y"

    Returns: {"X" }

  54. "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJ=P-P"

    Returns: {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" }

  55. "AAB+AB=B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B"

    Returns: {"A", "A", "B" }

  56. "ZZX+X=ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX+ZX"

    Returns: {"X", "Z", "Z" }

  57. "E-QQE=QQE+QQE+QQE+QQE+QQE+QQE+QQE+QQE+QQE+QQE+QQE"

    Returns: {"E", "Q", "Q" }

  58. "E+E-QQE=QE+QQE+QQE+QQE+QQE+QQE+QQE+QQE+QQE+QQE+QQE"

    Returns: {"E", "Q", "Q" }

  59. "ABB-AB-AB+A=BCB-C"

    Returns: {"B" }

  60. "ABB-A-A=CBB-C"

    Returns: { }

  61. "AB-C+BA-A-C+BCB+CB-C=A+C+C-CBB+A+C"

    Returns: {"B" }

  62. "ABCA+ACA+BAC+CA=BD+BBD+DBA+BDBA"

    Returns: {"A", "B" }

  63. "GGH+GGH+GGH+GGH+GGH+GGH+GGH+GGH+GGH+GGH+GGH+GGH=GH"

    Returns: {"G", "G", "H" }

  64. "GHH-G=KH-K"

    Returns: {"H" }

  65. "AXX+AXX-AX-AX-AX+A=BX+BX-B"

    Returns: {"X" }

  66. "AXX+AXX+AXX-AX-AX-AX-AX+A=BX+BX-B"

    Returns: { }

  67. "AXX+AXX+AXX-AX-AX-AX-AX+A=BX+BX+BX-B"

    Returns: {"X" }

  68. "ABCB+ABC-AC=AC+AC-ABC"

    Returns: {"A", "B", "B", "C" }

  69. "VX-XZYZ=Q-Q-ZZYX+XXV"

    Returns: {"V", "X", "X" }

  70. "AABB+AAB+AB+ABB=B+BB"

    Returns: {"A", "A", "B", "B" }

  71. "BA+BA+BA+BA+BA+BA+AB+BA+BA+BA+BA+BA+BA+BA+BA+BA=B"

    Returns: {"A", "B" }

  72. "ACC+ACC=A+A+A+A"

    Returns: {"A", "C", "C" }

  73. "RED+BLUE=PURPLE"

    Returns: {"E" }

  74. "AB+AB+AB=B"

    Returns: {"A", "B" }

  75. "A+A=ABB"

    Returns: {"A", "B", "B" }

  76. "AB+AB=A+A+A"

    Returns: {"A", "B" }

  77. "AACD+ABCD-CCDD=ABCD-AACD-CCD+D"

    Returns: {"D" }

  78. "ZABAB-AZA-BBZ+Z=ZAA-Z"

    Returns: {"A", "A", "B", "B", "Z" }

  79. "DCBA+ABCD=ABCDE"

    Returns: {"A", "B", "C", "D", "E" }

  80. "BAA+BA+B=P-P"

    Returns: {"B" }

  81. "AAB+AAB=B"

    Returns: {"A", "A", "B" }

  82. "A+B+B+C=A+BDD+C"

    Returns: {"B", "D", "D" }

  83. "A+A=AB-AB-AB-AB-AB-AB-AB"

    Returns: {"A", "B" }

  84. "AAB+B=B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B+B"

    Returns: {"A", "A", "B" }

  85. "RN-R+NR-R+NRN-R=R-RN-RN"

    Returns: {"N", "N", "R" }

  86. "A+A+A+A-AA=C-C"

    Returns: {"A", "A" }

  87. "BAA-BA-B=P-P"

    Returns: {"A", "A", "B" }

  88. "AACB+ACB=CB"

    Returns: {"A", "A", "B", "C" }

  89. "XAX+XXB+BXX+CXX=AX+BX+BX+CX+C+B+B+A"

    Returns: {"X", "X" }

  90. "AAB+AAB+AB=B+B+B"

    Returns: {"A", "A", "B" }

  91. "AAB-B=B"

    Returns: {"A", "A", "B" }

  92. "BAA+BA-B=P-P"

    Returns: {"A", "A", "B" }

  93. "BC+BC=C"

    Returns: {"B", "C" }

  94. "ABC+BA=BCA+AB"

    Returns: { }

  95. "ABC=CB"

    Returns: {"A", "B", "C" }

  96. "AA+AB+AC+AD+AE+AH+AI=A+B+C+D+E+F+G+H+I+J+K+L+M+N+O"

    Returns: { }

  97. "XAX+XXA+AXX+XXA-AX-AX-XA-XA=A-A-A"

    Returns: {"A", "X" }

  98. "UUA=A+A"

    Returns: {"A", "U", "U" }

  99. "A+A+A+A+A+A+A+A+A+A+A+A+A+A+A+A+A=BA+BBA"

    Returns: {"A", "B", "B" }

  100. "AJ=AY"

    Returns: {"A" }

  101. "AAB=B+B"

    Returns: {"A", "A", "B" }

  102. "AAB-AB-AB-AB+B=C-C"

    Returns: {"A", "A", "B" }

  103. "AB+AB+C=A+A+A+C+DEFGHI-DEFGHI"

    Returns: {"A", "B" }

  104. "ABB-A+BBC-BC-BC=P-P"

    Returns: { }

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2024, TopCoder, Inc. All rights reserved.
This problem was used for: