/* *That is (not) an Evangelion reference * *Challenge to use other language's methods in your *own language. *No output - write your own source code and test my stuff :P * *IMPORTANT: *I know not everything looks like in C#, e.g. the array initialization, use of :: instead of .operator with Console,... *That is because up to now, I was more focused on the functions rather than the classes and only coded them to be able to show the methods. *But I'll try to make it look more like C# from now on. * *Credit here goes to @Dennis for saving me twice * *Currently features: *C#: *Console:: -> Write(), WriteLine(), ReadLine() *Convert::ToXXX() *Arrays (e.g. Array myArray(size);) *Arrays -> Max(), Min(), Sum(), Length, = *Strings (e.g. String s("Hello");) *Strings -> Length(), IndexOf(), Insert(), Remove(), *Substring(), Contains(), get(), set(), = *Random -> Next(), Next(int), Next(int, int), *NextDouble() * *Known Bugs: Cant declare & define a string at the same time; */ // //***********PREPROCESSOR**********\\ // #include #include #include #include #include #include #include #include // //**********C-SHARP**********\\ // class Console { private: Console() {} ~Console() {} public: //Write Begin template static inline void Write(Data d) { std::cout << d; } //Args makes an arbitary amount of arguments possible, thanks to @Hatsy Rei (although he doesnt know^^) template static inline void Write(Data d, Args... args) { Write(d); Write(args...); } //Write End //WriteLine Begin template static inline void WriteLine(Data d) { std::cout << d << std::endl; } template static inline void WriteLine(Data d, Args... args) { Write(d); Write(args...); //calling Write() here so there is no new line after each argument std::cout << std::endl; } //WriteLine End static inline std::string ReadLine() { std::string s; getline(std::cin, s); return s; } }; class Convert { private: Convert() {}; ~Convert() {}; public: static inline short ToInt16(std::string s) { return atoi(s.c_str()); } static inline long ToInt32(std::string s) { return strtol(s.c_str(), nullptr, 10); } static inline long long ToInt64(std::string s) { return strtoll(s.c_str(), nullptr, 10); } static inline float ToFloat(std::string s) { return strtof(s.c_str(), nullptr); } static inline double ToDouble(std::string s) { return strtod(s.c_str(), nullptr); } static inline char ToChar(std::string s) { return s.front(); } template static inline std::string ToString(T t) { std::ostringstream oss; oss << t; return oss.str(); } static inline bool ToBool(std::string s) { return (strtol(s.c_str(), nullptr, 10) == 0 ? 0 : 1); } }; template class Array { private: size_t size; A *myArray; public: const int Length; Array (size_t s) :size(s), Length(s) { myArray = new A[Length]; } ~Array() { delete[] myArray; } inline void setArray(size_t pos, A val) { myArray[pos] = val; } inline A getArray(const size_t pos) const { return myArray[pos]; } inline int Max() { A max = myArray[0]; for (int it = 0; it < size; ++it) { if (myArray[it] > max) {max = myArray[it];} } return max; } inline int Min() { A min = myArray[0]; for (int it = 0; it < size; ++it) { if (myArray[it] < min) {min = myArray[it];} } return min; } inline int Sum() { A sum = 0; for (int it = 0; it < size; ++it) { sum += myArray[it]; } return sum; } A& operator[](const size_t pos) { return myArray[pos]; } const A& operator[](const size_t pos) const { return myArray[pos]; } }; class string { private: std::string str; public: inline std::string get() const { return this->str; } inline void set(std::string s) { this->str = s; } inline int Length() const { return this->str.length(); } inline int IndexOf(const std::string s) const { return str.find(s); } inline void Insert(const int pos, const std::string s) { str.insert(pos, s); } inline void Remove(const int begin, const int end = 0) { str.erase(str.begin() + begin, str.end() - end); } inline std::string Substring(const int pos, const int length) { return str.substr(pos, length); } inline bool Contains(const std::string s) const { int pos = str.find(s); return (pos != -1 ? true : false); } string operator=(std::string s) { this->str = s; return *this; } }; class Random { private: const int MAX_VALUE = 200000000; std::default_random_engine generator; public: Random() { unsigned seed = static_cast(time(nullptr)); generator.seed(seed); } inline int Next() { std::uniform_int_distribution distribution(0, MAX_VALUE); return distribution(generator); } inline int Next(int max) { std::uniform_int_distribution distribution(0, max); return distribution(generator); } inline int Next(int min, int max) { std::uniform_int_distribution distribution(min, max); return distribution(generator); } inline double NextDouble() { std::uniform_real_distribution distribution(0.0, 1.0); return distribution(generator); } }; // //**********MAIN FUNCTION**********\\ // //using System; //using System.Collections.Generic; //using System.Linq; //using System.Text; //using System.Threading.Tasks; //namespace SoloLearn { // class Program { int main() { // your code goes here -> } // } //}

This is (not) C++