Go: package main

import (
        "fmt"
)

func main() {
        var x1, y1, x2, y2, x3, y3, px, py float64
        var oax, oay, obx, oby, opx, opy float64
        var det float64
        var s, t float64

        for {
                _, err := fmt.Scanf("%f %f %f %f %f %f %f %f", &x1, &y1, &x2, &y2, &x3, &y3, &px, &py)
                if err != nil {
                        break
                }
                oax = x2 - x1
                oay = y2 - y1
                obx = x3 - x1
                oby = y3 - y1
                opx = px - x1
                opy = py - y1
                det = oax*oby - obx*oay

                if det == 0 {
                        fmt.Printf("NO\n")
                } else {
                        s = (oby*opx - obx*opy) / det
                        t = (oax*opy - oay*opx) / det

                        if (s+t < 1 && s > 0 && t > 0) {
                                fmt.Printf("YES\n")
                        } else {
                                fmt.Printf("NO\n")
                        }
                }
        }
}

C++: #include <iostream>
#include <fstream>
#include <typeinfo>
#include <vector>
#include <cmath>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <iomanip>
#include <cctype>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<25;
const double pi=acos(-1);
const double eps=1e-8;
const vi emp;

double add_double(double a,double b){
	if(abs(a+b)<eps*(abs(a)+abs(b))) return 0;
	return a+b;
}

struct point{
	double x,y;
	point operator+(point p){
		return point{add_double(x,p.x),add_double(y,p.y)};
	}
	point operator-(point p){
		return point{add_double(x,-p.x),add_double(y,-p.y)};
	}
	point operator*(double p){
		return point{x*p,y*p};
	}
	point operator/(double p){
		if(!p) return point{0,0}; 
		return point{x/p,y/p};
	}
	bool operator==(point p){
		return fabs(add_double(x,-p.x))<eps&&fabs(add_double(y,-p.y))<eps;
	}
	bool operator<(point p){
		if(fabs(x-p.x)>eps) return x<p.x;
		return y<p.y;
	}
};
 
typedef pair<point,point> pp;
typedef vector<point> VP;
const point O{0,0};
 
class Geom{
	public:
	double Length(point x,point y){
		point z=y-x;
		return z.x*z.x+z.y*z.y;
	}
	double IP(point p,point q){
		return p.x*q.x+p.y*q.y;
	}
	double CP(point p,point q){
		return p.x*q.y-q.x*p.y;
	}
	string Containment_polyon_point(VP p,point x){
		bool flag=0;
		p.push_back(p[0]);
		for(VP::iterator i=p.begin();i!=p.end()-1;i++){
			point a=*i-x,b=*(i+1)-x;
			if(a.y>b.y) swap(a,b);
			double ip=IP(a,b),cp=CP(a,b);
			if(a.y<=0&&b.y>0&&cp<0) flag=!flag;
			if(cp<eps&&cp>-eps&&ip<=0) return "On_side";
		}
		return flag?"Containment":"not_Containment";
	}
	void Point_in(point& p){
		cin>>p.x>>p.y;
	}
	void Point_out(point p){
		cout<<p.x<<' '<<p.y<<endl;
	}
};

VP Tri(3);
point p;

int main(){
	Geom geo;
	while(cin>>Tri[0].x){
		cin>>Tri[0].y;
		geo.Point_in(Tri[1]);
		geo.Point_in(Tri[2]);
		geo.Point_in(p);
		string s=geo.Containment_polyon_point(Tri,p);
		if(s=="Containment") cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
}

C++: #include<iostream>
#include<stdio.h>
#include<cmath>

using namespace std;

#define EPS 1e-10

struct point{
	double x;
	double y;
};
struct line{
	double a; // 傾き
	double b; // 切片
};

int recog_point_place( const point& a , const point&b , const point& c );
bool get_line( const point& a , const point& b , line *a_b );

int main(void)
{
	point a, b, c, p;
	int num_of_data;

	while( scanf("%d", &num_of_data ) != EOF )
	{
		cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y >> p.x >> p.y;

		int result_ab_c = recog_point_place( a , b , c );
		int result_ab_p = recog_point_place( a , b , p );
		int result_bc_a = recog_point_place( b , c , a );
		int result_bc_p = recog_point_place( b , c , p );
		int result_ca_b = recog_point_place( c , a , b );
		int result_ca_p = recog_point_place( c , a , p );

		if( result_ab_c == result_ab_p && result_bc_a == result_bc_p && result_ca_b == result_ca_p ) cout << "YES" << endl;
		else cout << "NO" << endl;
	}

	return 0;
}

int recog_point_place( const point& a , const point&b , const point& c )
{
	line a_b;

	bool result = get_line( a , b , &a_b );
	if( result == false )
	{
		if( (a.x + b.x)/2 < c.x ) return 1; // 点が直線より右にある場合に1をリターン
		else return 0;
	}
	else if( result == true )
	{
		if( c.y > a_b.a * c.x + a_b.b ) return 1; // 点が直線より上にある場合に1をリターン
		else return 0;
	}

}

bool get_line( const point& a , const point& b , line *a_b )
{
	if( fabs(a.x - b.x) < EPS )
	{
		return false;
	}
	else
	{
		a_b->a = (a.y - b.y) / (a.x - b.x);
		a_b->b = a.y - a_b->a * a.x;

		return true;
	}
}

C++: #include<iostream>
#include<cmath>
using namespace std;

void couten(double x[], double y[], double &cx, double &cy){
	double a2, b2, c2, a, b, c, s, S2;
	a2 = abs((x[2]-x[1])*(x[2]-x[1]) + (y[2]-y[1])*(y[2]-y[1]));
    b2 = abs((x[0]-x[2])*(x[0]-x[2]) + (y[0]-y[2])*(y[0]-y[2]));
    c2 = abs((x[1]-x[0])*(x[1]-x[0]) + (y[1]-y[0])*(y[1]-y[0]));
    a = sqrt(a2); b = sqrt(b2); c = sqrt(c2);
	if((a + b + c) == 0){
		s = 0;
		cx = 0;
		cy = 0;
	} else{
		s = (a + b + c) / 2;S2 = s * (s-a) * (s-b) * (s-c);
		cx = (a2*(b2+c2-a2)*x[0] + b2*(c2+a2-b2)*x[1] + c2*(a2+b2-c2)*x[2]) / (16 * S2);
		cy = (a2*(b2+c2-a2)*y[0] + b2*(c2+a2-b2)*y[1] + c2*(a2+b2-c2)*y[2]) / (16 * S2);
	}
}

int hantei(double x[], double y[], double &cx, double &cy, double xp, double yp){
	bool flag[3];
	double tc, tp, tcc, tpp;
	x[3] = x[0]; y[3] = y[0];
	for(int i = 0; i < 3; i++){
		tc = (x[i] - x[i + 1]) * (cy - y[i]) + (y[i] - y[i + 1]) * (x[i] - cx);
		tp = (x[i] - x[i + 1]) * (yp - y[i]) + (y[i] - y[i + 1]) * (x[i] - xp);
		if(tc * tp >= 0){
			flag[i] = true;
		} else{
			continue;
		}
	}
	if(flag[0] == true && flag[1] == true && flag[2] == true){
		return 1;
	} else{
		return 0;
	}
}


int main(){
	double x[3], y[3], xp, yp, cxx, cyy;
	double &cx = cxx, &cy = cyy;
	
	while(cin >>x[0] >>y[0] >>x[1] >>y[1] >>x[2] >>y[2] >>xp >>yp){
		couten(x, y, cx, cy);
		if(hantei(x, y, cx, cy, xp, yp)){
			cout <<"Yes"<<endl;
		} else{
			cout <<"No"<<endl;
		}
	}
	
	return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <vector>
#include <complex>

using namespace std;

typedef	complex<double> P;

double dot(P a, P b) {
  return (a.real() * b.real() + a.imag() * b.imag());
}

double cross(P a, P b) {
  return (a.real() * b.imag() - a.imag() * b.real());
}
int main(){

	double xp,yp,x1,x2,x3,y1,y2,y3;
	while(cin>>x1>>y1>>x2>>y2>>x3>>y3>>xp>>yp){
		P p1(x1,y1);
		P p2(x2,y2);
		P p3(x3,y3);
		P p(xp,yp);

		double v1 = cross(p1,p2);
		double v2 = cross(p2,p3);
		double v3 = cross(p3,p1);

		if((v1>=0&&v2>=0&&v3>=0)||(v1<0&&v2<0&&v3<0))
			cout << "YES" << endl;
		else
			cout << "NO" << endl;

	}

	return 0;
}

C++: #define _CRT_SECURE_NO_WARNINGS
#define M_PI 3.14159265358979
#include <iostream>
#include <stdio.h>
#include <string>
#include <math.h>
#include<iomanip>
#include<vector>
#include<cmath>
#include <algorithm>

using namespace std;

int main(){
	double x1, y1, x2, y2, x3, y3, xp, yp, a, b, c;
	
	while (cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp)
	{
		a = (x2 - x1)*(yp - y1) - (y2 - y1)*(xp - x1);
		b = (x3 - x2)*(yp - y2) - (y3 - y2)*(xp - x2);
		c = (x1 - x3)*(yp - y3) - (y1 - y3)*(xp - x3);
		if ((a>0 && b>0 && c>0) || (a<0 && b<0 && c<0))
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}
	return 0;
}