fork download
copy 
  1. #include <iostream>
  2. #include <cmath>
  3. #include <limits>
  4. #include <string>
  5. #include <vector>
  6. #include <algorithm>
  7. #include <cassert>
  8. #include <random>
  9.  
  10. namespace detail {
  11. 	void clear_bad_input(std::istream &in) {
  12. 		in.clear();
  13. 	    in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
  14. 	}
  15.  
  16. 	template<typename T, typename MessageF, typename Pred>
  17. 	T read_if(MessageF messagef, Pred pred, std::istream &in) {
  18. 		T result {};
  19. 	    while(in.good()) {
  20. 	    	messagef();
  21. 	    	if((std::cin >> result) && pred(result)) {
  22. 	    		break;
  23. 	    	}
  24. 	        clear_bad_input(in);
  25. 	    }
  26. 	    return result;
  27. 	}
  28. }
  29.  
  30. template<typename T, typename Pred>
  31. T read_if(std::string const &msg, Pred pred, std::ostream &out = std::cout, std::istream &in = std::cin) {
  32. 	auto msgf = [&msg, &out] { return static_cast<bool>(out << msg << '\n'); };
  33. 	return detail::read_if<T>(msgf, pred, in);
  34. }
  35.  
  36. template<typename Cont>
  37. auto read_one_of(std::string const &msg, Cont const &container) {
  38. 	auto pred = [&container](auto &&item) {
  39. 		return std::find(std::begin(container), std::end(container), item) != std::end(container);
  40. 	};
  41. 	return read_if<typename Cont::value_type>(msg, pred);
  42. }
  43.  
  44. double nth_root(double num, double n) {
  45. 	return std::pow(num, 1./n);
  46. }
  47.  
  48. using namespace std;
  49.  
  50. namespace handy {
  51. 	int random_int_from_range(int min, int max) {
  52. 		assert(min <= max);
  53. 		static std::default_random_engine gen;
  54. 		return std::uniform_int_distribution<>{min, max}(gen);
  55. 	}
  56.  
  57. 	auto read_even_size() {
  58. 		return read_if<size_t>("enter even size", [](auto num) {
  59. 			return (num % 2) == 0;	
  60. 		});
  61. 	}
  62.  
  63. 	auto read_decision() {
  64. 		return read_one_of("enter [values] or [range]", vector<string> {
  65. 			"values", "range"	
  66. 		});
  67. 	}
  68.  
  69. 	auto read_elements(size_t size) {
  70. 		vector<int> result;
  71. 		while(size --> 0) {
  72. 			int num;
  73. 			cin >> num;
  74. 			result.emplace_back(num);
  75. 		}
  76. 		return result;
  77. 	}
  78.  
  79. 	auto gen_elements(size_t size) {
  80. 		vector<int> result;
  81. 		int a, b;
  82. 		while((cin >> a >> b) && ((b-a) == size));
  83. 		while(size --> 0) {
  84. 			result.emplace_back(random_int_from_range(a, b));
  85. 		}
  86. 		return result;
  87. 	}
  88.  
  89. 	auto read_or_gen_elements(size_t size, string const &decision) {
  90. 		if(!(decision == "values" || decision == "range")) {
  91. 			cerr << "decision: " << decision << '\n';
  92. 			assert(false);
  93. 		}
  94. 		return decision == "values"?
  95. 			read_elements(size)    :
  96. 			gen_elements(size);
  97. 	}
  98. }
  99.  
  100. int main() {
  101. 	auto size = handy::read_even_size();
  102. 	auto decision = handy::read_decision(); 
  103. 	auto elements = handy::read_or_gen_elements(size, decision);
  104.  
  105. 	return 0;
  106. }
Success #stdin #stdout 0s 3480KB
comments (?)
stdin
copy 
7
8
range
0 8
stdout
copy 
enter even size
enter even size
enter [values] or [range]
https://ideone.com/ggaAEl
language:
C++14 (gcc 8.3)
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!