Geometria 1

$\times$ ALL THE THINGS!

Body: Napríklad takto

template <typename Number>
class Point {
public:
    Number x, y;
    Point<Number>(Number _x = 0, Number _y = 0) {
        x = _x;
        y = _y;
    }
    bool operator==(const Point<Number>& p2) const { return x == p2.x && y == p2.y; }
    bool operator!=(const Point<Number>& p2) const { return x != p2.x || y != p2.y; }
    void operator+=(const Point<Number>& p2) { x += p2.x; y += p2.y; }
    void operator-=(const Point<Number>& p2) { x -= p2.x; y -= p2.y; }
    Point<Number> operator+ (const Point<Number>& p2) { return Point<Number>(x + p2.x, y + p2.y); }
    Point<Number> operator- (const Point<Number>& p2) { return Point<Number>(x - p2.x, y - p2.y); }
};
template <typename Number>
double dist(const Point<Number>& p1, const Point<Number>& p2) { return sqrt((p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y)); }

template <typename Number>
ostream& operator<<(ostream& os, const Point<Number>& p) { return os << "[" << p.x << "," << p.y << "]"; }

Body: Napríklad takto

template <typename Number>
class Point {
public:
    Number x, y;
    Point<Number>(Number _x = 0, Number _y = 0) {
        x = _x;
        y = _y;
    }
    bool operator==(const Point<Number>& p2) const { return x == p2.x && y == p2.y; }
    bool operator!=(const Point<Number>& p2) const { return x != p2.x || y != p2.y; }
    void operator+=(const Point<Number>& p2) { x += p2.x; y += p2.y; }
    void operator-=(const Point<Number>& p2) { x -= p2.x; y -= p2.y; }
    Point<Number> operator+ (const Point<Number>& p2) { return Point<Number>(x + p2.x, y + p2.y); }
    Point<Number> operator- (const Point<Number>& p2) { return Point<Number>(x - p2.x, y - p2.y); }
};
template <typename Number>
double dist(const Point<Number>& p1, const Point<Number>& p2) { return sqrt((p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y)); }

template <typename Number>
ostream& operator<<(ostream& os, const Point<Number>& p) { return os << "[" << p.x << "," << p.y << "]"; }

×

Body: Alebo takto!

temný trik: <complex> to the rescue!

#include <complex>
#define X real
#define Y imag
typedef complex<long long int> P;

P a(0,0); P b; b.X(1); b.Y(1);

abs(a - b);  // $\leftarrow \sqrt 2$
// :-)

Vpravo, vľavo

Liaheň: Deti na lúke

Keď sa Olívia pozerá na Bašku, je Žaba po jej pravej alebo ľavej ruke?

Vpravo, vľavo

možné riešenie: $f\colon y = ax + b$, pýtame sa, či je bod nad alebo pod $f$

fuj, bleee: special cases, čo so zvislými priamkami a pod...

:-(

Vpravo, vľavo

#include <stdio.h>

int main() {
  int t, i;
  int ax, ay, bx, by, cx, cy, y; /* suradnice Adamka, Betky a Cilky */

  scanf("%d", &t);

  for (i = 0; i < t; i++) {
    scanf("%d %d %d %d %d %d", &ax, &ay, &bx, &by, &cx, &cy);

    /* Posuvam zaciatok suradnic do polohy Adamka pre zjednodusenie */
    bx -= ax;
    by -= ay;
    cx -= ax;
    cy -= ay;
    ax = ay = 0;

    /* ked je B presne nad alebo pod A, tak to nie je funkcia, a dole by som 
       delila nulou, takze tento pripad riesim zvlast */
    if (bx == 0) {
      if (cx == 0)
    printf("rovno\n");
      else
    if ((by > 0 && cx < 0) || (by < 0 && cx > 0))
      printf("vlavo\n");
    else
      printf("vpravo\n");
    }
    else {
      /* Ak je Cilka na jednej priamke s A. a B., a jej x-ova suradnica je cx,
     potom jej y-ova suradnica musi byt a*cx, kde a = by/bx. */
      if (cy*bx == by*cx)
    printf("rovno\n");
      else
    if ((bx*cy > by*cx && bx > 0) || (bx*cy > by*cx && bx < 0)) /* Tie podmienky vidno, */
      printf("vlavo\n");                     /* ked si to clovek nakresli */
    else
      printf("vpravo\n");
    }
  }

  return 0;
}

Vpravo, vľavo

lepšie riešenie:

int main (){
  int ax, ay, bx, by, cx, cy;
  scanf("%d %d %d %d %d %d ",&ax,&ay,&bx,&by,&cx,&cy);

  int ux = bx-ax, uy = by-ay;
  int vx = cx-ax, vy = cy-ay;
  int res = ux*vy - uy*vx;

  if (res == 0) printf("rovno\n");
  if (res < 0)  printf("vpravo\n");
  if (res > 0)  printf("vlavo\n");

  return 0;
}

...wat?

Vektorový súčin

definovaný pre 3-rozmerné vektory

Vektorový súčin

$r = a\times b$

$r_x = a_y b_z - a_z b_y$ $r_y = a_z b_x - a_x b_z$ $r_z = a_x b_y - a_y b_x$

$r$ je kolmý na pôvodné vektory
„väčší ak sú menej rovnakým smerom”

Vektorový súčin

$r = a\times b$

$r_x = a_y b_z - a_z b_y$ $r_y = a_z b_x - a_x b_z$ $r_z = a_x b_y - a_y b_x$

Vpravo, vľavo

int main (){
  int ax, ay, bx, by, cx, cy;
  scanf("%d %d %d %d %d %d ",&ax,&ay,&bx,&by,&cx,&cy);

  int ux = bx-ax, uy = by-ay;
  int vx = cx-ax, vy = cy-ay;
  int res = ux*vy - uy*vx;

  if (res == 0) printf("rovno\n");
  if (res < 0)  printf("vpravo\n");
  if (res > 0)  printf("vlavo\n");

  return 0;
}

$a_z = b_z = 0 \Rightarrow |r| = r_z$

Vpravo, vľavo

int main (){
  int ax, ay, bx, by, cx, cy;
  scanf("%d %d %d %d %d %d ",&ax,&ay,&bx,&by,&cx,&cy);

  int ux = bx-ax, uy = by-ay;
  int vx = cx-ax, vy = cy-ay;
  int res = ux*vy - uy*vx;

  if (res == 0) printf("rovno\n");
  if (res < 0)  printf("vpravo\n");
  if (res > 0)  printf("vlavo\n");

  return 0;
}

$a_z = b_z = 0 \Rightarrow |r| = r_z$ ✓

Vpravo, vľavo: pretínajú sa 2 úsečky?

Vektorový súčin

$r = a\times b$

$r_x = a_y b_z - a_z b_y$ $r_y = a_z b_x - a_x b_z$ $r_z = a_x b_y - a_y b_x$

$|r| = |a||b| \sin \alpha$
⇒ $S = |r|$

Obsah $n$-uholníka

$S_{12} = \frac{|v_1 \times v_2|}{2}$

Obsah $n$-uholníka

$S_{23} = \frac{|v_2 \times v_3|}{2}$

Obsah $n$-uholníka

$ S = $ $\frac{|v_1 \times v_2|}{2}$ $+$ $\frac{|v_2 \times v_3|}{2}$ $+$ $\ldots$ $+$ $\frac{|v_{n-1} \times v_n|}{2}$ $+$ $\frac{|v_n \times v_1|}{2}$