/* The following program generates a random triangle on a 38*30 ocean map and then plots a random course for a ship from the boundaries. The program then simulates the ship's trajectory and checks if the ship sinks, which is likely to happen if the ship's trajectory passes through the triangle. The program also tries to print a visualization of the above scenario with random values every time. No Input is required from the user, as everything (trajectory, triangle, etc) is randomized. */ #include // cout, cin #include // pair, make_pair // minstd_rand, uniform_int_distribution #include #include // system_clock // Current Ocean Width const unsigned int o_width = 38; // Current Ocean Length const unsigned int o_length = 30; // Minimum area required of the Triangle. const double req_area = 0.3 * o_width * o_length; // Default Linear Congruential Engine. std::minstd_rand eng; std::uniform_int_distribution randgen(0,65535); // Seeds the random engine with a new clock // value from the system clock. void seed_random() { unsigned seedval = std::chrono:: system_clock::now().time_since_epoch(). count(); eng.seed(seedval); } // Returns a random integer from // the specified range [lower,upper] int random(int lower, int upper) { std::uniform_int_distribution ::param_type range(lower,upper); randgen.param(range); return randgen(eng); } // Allows easy handling of Coordinates struct Coordinate { int X,Y; constexpr Coordinate(int cx=0, int cy=0) : X(cx), Y(cy) {} constexpr bool operator< (const Coordinate& C2) const noexcept { return ((X*X)+(Y*Y))<((C2.X* C2.X)+(C2.Y*C2.Y)); } constexpr bool operator> (const Coordinate& C2) const noexcept { return ((X*X)+(Y*Y))>((C2.X* C2.X)+(C2.Y*C2.Y)); } constexpr bool operator== (const Coordinate& C2) const noexcept { return C2.X==X&&C2.Y==Y; } constexpr Coordinate operator- (const Coordinate& C2) const noexcept { return {X-C2.X,Y-C2.Y}; } constexpr double operator* (const Coordinate& C2) const noexcept { return abs((X*C2.Y)-(Y*C2.X)); } }; Coordinate random (const Coordinate& C1, const Coordinate& C2) { return {random(std::min(C1.X,C2.X), std::max(C1.X,C2.X)), random(std::min(C1.Y,C2.Y), std::max(C1.Y,C2.Y))}; } std::ostream& operator<<(std::ostream& os, const Coordinate& C) { os<<"("< (sqrt((C.X*C.X)+(C.Y*C.Y))); } constexpr double area(Coordinate Tri[3]) { return 0.5*((Tri[1]-Tri[0]) *(Tri[2]-Tri[0])); } // Returns a pair of bool and Coordinate, // indicating the status of intersection, // and the point of intersection. auto is_intersecting (Coordinate A1, Coordinate A2, Coordinate B1, Coordinate B2) { double x,y,det,a1,a2,b1,b2,c1,c2; bool chk; a1 = A2.Y-A1.Y; b1 = A1.X-A2.X; c1 = a1*(A1.X)+b1*(A1.Y); a2 = B2.Y-B1.Y; b2 = B1.X-B2.X; c2 = a2*(B1.X)+b2*(B1.Y); det = a1*b2-a2*b1; if(!det) { return std::make_pair(false, Coordinate(0,0)); } else { x = (b2*c1-b1*c2)/det, y = (a1*c2-a2*c1)/det; chk = (x<=o_width-1&&x>=1) &&(y<=o_length-1&&y>=1); chk &= (x>=std::min(A1.X,A2.X)&& x<=std::max(A1.X,A2.X))&& (y>=std::min(A1.Y,A2.Y)&& y<=std::max(A1.Y,A2.Y)); return std::make_pair(chk, Coordinate(x,y)); } } // Returns if the ship drowned in the // triangle. The outcome is random, // but usually in favour if the distance // travelled through the triangle is small. bool is_drowned (const Coordinate& C1, const Coordinate& C2) { int n = abs(C1-C2); int x = random(1,n), y = random(1,n); return abs(x-y)<=((n/2)-1); } // Allows handling of the map, // for visualization purpose only. class Ocean { unsigned int sx, sy; char** area; public: explicit Ocean (unsigned int dx=10, unsigned int dy=10) : sx(dx), sy(dy) { area = new char*[sx+2]; for(unsigned int i=0;i0) { y+=r; D-=2*dx; } D+=2*dy; } } else { if(dx<0){ dx=-dx; r=-1; } D=2*dx-dy; x=C1.X; for(y=C1.Y;y<=C2.Y;y++) { area[y][x] = boundary; if(D>0) { x+=r; D-=2*dy; } D+=2*dx; } } } // Prints the ocean boundary, // and all its content. void print() const noexcept { for(unsigned int i=0;i

Challenge - Bermuda Triangle