fork download
copy 
  1. #include <iostream>
  2. #include <cstdint>
  3. #include <algorithm>
  4. #include <vector>
  5.  
  6. typedef std::vector<std::int64_t> DType;
  7.  
  8. bool AddDidit(DType& D, std::uint64_t R) {
  9. 	bool C = false;
  10. 	if (D.size() == 0) return false;
  11. 	D[0]++;
  12. 	for (std::size_t i = 0; i < D.size(); i++) {
  13. 		if (C == true) {
  14. 			D[i]++;
  15. 		}
  16. 		C = false;
  17. 		if (D[i] >= R) {
  18. 			D[i]= 0;
  19. 			C = true;
  20. 		}else {
  21. 			break;
  22. 		}
  23.  
  24.  
  25.  
  26. 	}
  27.  
  28. 	return C;
  29. }
  30.  
  31. DType Pre(const DType& N,DType& D,const DType& E) {
  32. 	DType R;
  33. 	std::size_t P = 0;
  34. 	for (std::size_t i = 0; i < N.size(); i++) {
  35. 		if (E[i]) {
  36. 			R.push_back(N[i]);
  37. 		}else{
  38. 			D.erase(D.begin() + (i - P));
  39. 			P++;
  40. 		}
  41. 	}
  42.  
  43. 	for (std::size_t j = 0; j < D.size(); j++) {
  44. 		for (std::size_t i = 0; i < D[j]; i++) {
  45. 			R[j] *= R[j];
  46. 		}
  47. 	}
  48.  
  49. 	return R;
  50. }
  51.  
  52. std::uint64_t Calc(DType D, DType Op) {
  53. 	if (D.size() <= 1)return D[0];
  54. 	for (std::size_t i = 0; i < Op.size(); i++) {
  55. 		if (Op[i] == 2) {
  56. 			D[i] *= D[i + 1];
  57. 			D.erase(D.begin() + i + 1);
  58. 			Op.erase(Op.begin() + i);
  59. 			i--;
  60. 			continue;
  61. 		}
  62. 		if (Op[i] == 3) {
  63. 			D[i] /= D[i + 1];
  64. 			D.erase(D.begin() + i + 1);
  65. 			Op.erase(Op.begin() + i);
  66. 			i--;
  67. 			continue;
  68. 		}
  69. 	}
  70. 	for (std::size_t i = 0; i < Op.size(); i++) {
  71. 		if (Op[i] == 1) {
  72. 			D[i] -= D[i + 1];
  73. 			D.erase(D.begin() + i + 1);
  74. 			Op.erase(Op.begin() + i);
  75. 			i--;
  76. 			continue;
  77. 		}
  78. 		if (Op[i] == 0) {
  79. 			D[i] += D[i + 1];
  80. 			D.erase(D.begin() + i + 1);
  81. 			Op.erase(Op.begin() + i);
  82. 			i--;
  83. 			continue;
  84. 		}
  85. 	}
  86.  
  87. 	return D[0];
  88. }
  89. bool Show(const DType&N, const DType& D, const DType& O, const DType& E, const std::uint64_t& F, const std::uint64_t& L) {
  90. 	char Op[] = "+-*/";
  91. 	std::uint64_t C = 0;
  92. 	for (std::size_t i = 0; i < N.size(); i++) {
  93. 		if (E[i] == 0) {
  94. 			C++;
  95. 			continue;
  96.  
  97. 		}
  98. 		//if (F == i)std::cout << '(';
  99. 		std::cout << N[i];
  100. 		if (D[i] != 0)std::cout << "^(2*" << D[i] << ")";
  101. 		//if (L == i)std::cout << ')';
  102. 		if (O.size() > (i-C))std::cout << Op[O[i-C]];
  103. 	}
  104. 	std::cout << std::endl;
  105. 	return true;
  106. }
  107.  
  108. bool ProsessKakko(DType& D, DType& Op, std::uint64_t F, std::uint64_t L) {
  109. 	if (F == L) return false;
  110. 	DType DC(D.begin() + F, D.begin() + L);
  111. 	DType OC(Op.begin() + F, Op.begin() + (L-1));
  112.  
  113. 	if (OC.size() == 0)return false;
  114.  
  115. 	std::uint64_t A = Calc(DC, OC);
  116. 	D.erase(D.begin() + F, D.begin() + L);
  117. 	D.insert(D.begin() + F, A);
  118. 	Op.erase(Op.begin() + F, Op.begin() + (L - 1));
  119.  
  120. 	return true;
  121. }
  122.  
  123. bool MakeHogeOne(DType D, std::uint64_t A) {
  124. 	DType Op;
  125. 	DType Double;
  126. 	DType Eraser;
  127.  
  128. 	DType T;
  129.  
  130. 	std::sort(D.begin(), D.end());
  131.  
  132. 	do {
  133.  
  134. 		Double.clear();
  135. 		Double.resize(D.size());
  136.  
  137.  
  138. 		do {
  139. 			Eraser.clear();
  140. 			Eraser.resize(D.size());
  141. 			while (AddDidit(Eraser, 2)==false) {
  142. 				DType Do = Double;
  143. 				T = Pre(D, Do, Eraser);
  144. 				Op.clear();
  145. 				if (T.size() != 0) {
  146. 					Op.resize(T.size() - 1);
  147. 				}
  148. 				else {
  149. 					continue;
  150. 				}
  151. 				if (T.size() == 1) {
  152. 					if (T[0] == A) {
  153. 						Show(D, Double , Op,Eraser, 0, 0);
  154. 						return true;
  155. 					}
  156. 					else {
  157. 						continue;
  158. 					}
  159. 				}
  160. 				for (std::uint64_t F = 0; F < T.size(); F++) {
  161. 					for (std::uint64_t L= F; L < T.size(); L++) {
  162. 						do {
  163. 							//ProsessKakko(T, Op, F, L);
  164. 							if (Calc(T, Op) == A) {	
  165. 								Show(D, Double , Op,Eraser, F, L);
  166. 								return true;
  167. 							}
  168. 						} while (AddDidit(Op, 4)==false);
  169. 					}
  170. 				}
  171. 			} ;
  172. 		} while (AddDidit(Double, 8) == false);
  173.  
  174.  
  175. 	} while (std::next_permutation(D.begin(), D.end()));
  176.  
  177. 	return false;
  178. }
  179.  
  180. bool MakeHoge(DType D) {
  181.  
  182. 	for (std::size_t i = 1; MakeHogeOne(D, i); i++);
  183.  
  184. 	return true;
  185. }
  186.  
  187. int main() {
  188. 	DType D{ 3,5,7 };
  189.  
  190. //	MakeHogeOne(D,1);
  191. //	MakeHogeOne(D,2);
  192. 	MakeHoge(D);
  193. 	return 0;
  194. }
Success #stdin #stdout 0.11s 15248KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
3+5-7
3*5/7
3
3^(2*1)-5
5
3^(2*1)*5/7
7
3+5
3^(2*1)
3+7
3^(2*1)-5+7
5+7
3^(2*3)*5/7^(2*2)
3^(2*1)+5
3*5
3^(2*1)+7
3^(2*3)/5^(2*2)+7
5^(2*1)-7
3^(2*6)/7^(2*7)+5
3^(2*6)/7^(2*6)*5
3*7
3*5+7
3^(2*2)/5+7
3^(2*6)/5^(2*7)-7
5^(2*1)
3^(2*3)/5/7^(2*1)
3^(2*1)+5^(2*1)-7
3+5^(2*1)
3*7^(2*1)/5
3^(2*3)*5^(2*4)/7^(2*4)
3^(2*6)/5^(2*7)
5^(2*1)+7
3^(2*1)-5^(2*1)+7^(2*1)
3^(2*1)+5^(2*1)
5*7
3^(2*2)/7+5^(2*1)
3^(2*3)/5^(2*1)/7
3+5*7
3^(2*6)/7^(2*7)+5^(2*1)
3^(2*3)*7^(2*2)/5^(2*3)
3^(2*1)+5^(2*1)+7
7^(2*3)/5^(2*3)*3
https://ideone.com/k7hAtB
language:
C++ (gcc 8.3)
created:
6 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!